X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;ds=sidebyside;f=src%2Fmathed%2Fmath_extern.C;h=da2e448a4b0520df92c17f2a9681cd93c15eef83;hb=b54bf51387237b8fd8e9c6064143cff4239c2eec;hp=00055dec7363135a1041cba3a29c8d680a5909c2;hpb=a794a4594906064b3b72f11c6d08b3953510d14a;p=lyx.git diff --git a/src/mathed/math_extern.C b/src/mathed/math_extern.C index 00055dec73..da2e448a4b 100644 --- a/src/mathed/math_extern.C +++ b/src/mathed/math_extern.C @@ -44,7 +44,7 @@ ostream & operator<<(ostream & os, MathArray const & ar) // define a function for tests -typedef bool TestItemFunc(MathInset *); +typedef bool TestItemFunc(MathAtom const &); // define a function for replacing subexpressions typedef MathInset * ReplaceArgumentFunc(const MathArray & ar); @@ -132,14 +132,14 @@ void extractStrings(MathArray & ar) if (!ar[i]->asCharInset()) continue; string s = charSequence(ar.begin() + i, ar.end()); - ar[i].reset(new MathStringInset(s)); + ar[i] = MathAtom(new MathStringInset(s)); ar.erase(i + 1, i + s.size()); } //lyxerr << "\nStrings to: " << ar << "\n"; } -MathInset * singleItem(MathArray & ar) +MathInset const * singleItem(MathArray const & ar) { return ar.size() == 1 ? ar.begin()->nucleus() : 0; } @@ -150,10 +150,10 @@ void extractMatrices(MathArray & ar) //lyxerr << "\nMatrices from: " << ar << "\n"; // first pass for explicitly delimited stuff for (MathArray::iterator it = ar.begin(); it != ar.end(); ++it) { - MathDelimInset * del = (*it)->asDelimInset(); + MathDelimInset const * del = (*it)->asDelimInset(); if (!del) continue; - MathInset * arr = singleItem(del->cell(0)); + MathInset const * arr = singleItem(del->cell(0)); if (!arr || !arr->asGridInset()) continue; *it = MathAtom(new MathMatrixInset(*(arr->asGridInset()))); @@ -161,7 +161,7 @@ void extractMatrices(MathArray & ar) // second pass for AMS "pmatrix" etc for (MathArray::iterator it = ar.begin(); it != ar.end(); ++it) { - MathAMSArrayInset * ams = (*it)->asAMSArrayInset(); + MathAMSArrayInset const * ams = (*it)->asAMSArrayInset(); if (!ams) continue; *it = MathAtom(new MathMatrixInset(*ams)); @@ -171,16 +171,14 @@ void extractMatrices(MathArray & ar) // convert this inset somehow to a string -bool extractString(MathInset * p, string & str) +bool extractString(MathAtom const & at, string & str) { - if (!p) - return false; - if (p->getChar()) { - str = string(1, p->getChar()); + if (at->getChar()) { + str = string(1, at->getChar()); return true; } - if (p->asStringInset()) { - str = p->asStringInset()->str(); + if (at->asStringInset()) { + str = at->asStringInset()->str(); return true; } return false; @@ -204,10 +202,10 @@ bool extractNumber(MathArray const & ar, double & d) } -bool testString(MathInset * p, const string & str) +bool testString(MathAtom const & at, const string & str) { string s; - return extractString(p, s) && str == s; + return extractString(at, s) && str == s; } @@ -220,9 +218,9 @@ MathArray::iterator endNestSearch( ) { for (int level = 0; it != last; ++it) { - if (testOpen(it->nucleus())) + if (testOpen(*it)) ++level; - if (testClose(it->nucleus())) + if (testClose(*it)) --level; if (level == 0) break; @@ -244,7 +242,7 @@ void replaceNested( for (MathArray::size_type i = 0; i < ar.size(); ++i) { // check whether this is the begin of the sequence MathArray::iterator it = ar.begin() + i; - if (!testOpen(it->nucleus())) + if (!testOpen(*it)) continue; // search end of sequence @@ -257,7 +255,7 @@ void replaceNested( // replace the original stuff by the new inset ar.erase(it + 1, jt + 1); - (*it).reset(p); + *it = MathAtom(p); } } @@ -275,7 +273,7 @@ void splitScripts(MathArray & ar) MathArray::iterator it = ar.begin() + i; // is this script inset? - MathScriptInset * p = (*it)->asScriptInset(); + MathScriptInset * p = (*it).nucleus()->asScriptInset(); if (!p) continue; @@ -314,12 +312,12 @@ void extractExps(MathArray & ar) continue; // we need an exponent but no subscript - MathScriptInset * sup = (*(it + 1))->asScriptInset(); + MathScriptInset const * sup = (*(it + 1))->asScriptInset(); if (!sup || sup->hasDown()) continue; // create a proper exp-inset as replacement - *it = new MathExFuncInset("exp", sup->cell(1)); + *it = MathAtom(new MathExFuncInset("exp", sup->cell(1))); ar.erase(it + 1); } //lyxerr << "\nExps to: " << ar << "\n"; @@ -333,12 +331,12 @@ void extractDets(MathArray & ar) { //lyxerr << "\ndet from: " << ar << "\n"; for (MathArray::iterator it = ar.begin(); it != ar.end(); ++it) { - MathDelimInset * del = (*it)->asDelimInset(); + MathDelimInset const * del = (*it)->asDelimInset(); if (!del) continue; if (!del->isAbs()) continue; - *it = new MathExFuncInset("det", del->cell(0)); + *it = MathAtom(new MathExFuncInset("det", del->cell(0))); } //lyxerr << "\ndet to: " << ar << "\n"; } @@ -379,7 +377,7 @@ void extractNumbers(MathArray & ar) string s = digitSequence(ar.begin() + i, ar.end()); - ar[i].reset(new MathNumberInset(s)); + ar[i] = MathAtom(new MathNumberInset(s)); ar.erase(i + 1, i + s.size()); } //lyxerr << "\nNumbers to: " << ar << "\n"; @@ -391,15 +389,15 @@ void extractNumbers(MathArray & ar) // search deliminiters // -bool testOpenParan(MathInset * p) +bool testOpenParan(MathAtom const & at) { - return testString(p, "("); + return testString(at, "("); } -bool testCloseParan(MathInset * p) +bool testCloseParan(MathAtom const & at) { - return testString(p, ")"); + return testString(at, ")"); } @@ -441,18 +439,18 @@ void extractFunctions(MathArray & ar) // is it a function? if ((*it)->asUnknownInset()) { // it certainly is if it is well known... - name = (*it)->asUnknownInset()->name(); + name = (*it)->name(); } else { // is this a user defined function? // it it probably not, if it doesn't have a name. - if (!extractString((*it).nucleus(), name)) + if (!extractString(*it, name)) continue; // it is not if it has no argument if (jt == ar.end()) continue; // guess so, if this is followed by // a DelimInset with a single item in the cell - MathDelimInset * del = (*jt)->asDelimInset(); + MathDelimInset const * del = (*jt)->asDelimInset(); if (!del || del->cell(0).size() != 1) continue; // fall trough into main branch @@ -470,7 +468,7 @@ void extractFunctions(MathArray & ar) MathArray::iterator st = extractArgument(p->cell(0), jt, ar.end()); // replace the function name by a real function inset - (*it).reset(p); + *it = MathAtom(p); // remove the source of the argument from the array ar.erase(it + 1, st); @@ -486,21 +484,32 @@ void extractFunctions(MathArray & ar) // search integrals // -bool testSymbol(MathInset * p, string const & name) +bool testSymbol(MathAtom const & at, string const & name) { - return p->asSymbolInset() && p->asSymbolInset()->name() == name; + return at->asSymbolInset() && at->asSymbolInset()->name() == name; } -bool testIntSymbol(MathInset * p) +bool testIntSymbol(MathAtom const & at) { - return testSymbol(p, "int"); + return testSymbol(at, "int"); } -bool testIntDiff(MathInset * p) +bool testIntegral(MathAtom const & at) +{ + return + testIntSymbol(at) || + ( at->asScriptInset() + && at->asScriptInset()->nuc().size() + && testIntSymbol(at->asScriptInset()->nuc().back()) ); +} + + + +bool testIntDiff(MathAtom const & at) { - return testString(p, "d"); + return testString(at, "d"); } @@ -516,47 +525,34 @@ void extractIntegrals(MathArray & ar) for (MathArray::size_type i = 0; i + 1 < ar.size(); ++i) { MathArray::iterator it = ar.begin() + i; - // is this a integral name? - if (!testIntSymbol(it->nucleus())) - continue; - // search 'd' MathArray::iterator jt = - endNestSearch(it, ar.end(), testIntSymbol, testIntDiff); + endNestSearch(it, ar.end(), testIntegral, testIntDiff); // something sensible found? if (jt == ar.end()) continue; - // create a proper inset as replacement - MathExIntInset * p = new MathExIntInset("int"); - - // collect subscript if any - MathArray::iterator st = it + 1; - if (st != ar.end()) - if (MathScriptInset * sub = (*st)->asScriptInset()) - if (sub->hasDown()) { - p->cell(2) = sub->down().data(); - ++st; - } - - // collect superscript if any - if (st != ar.end()) - if (MathScriptInset * sup = (*st)->asScriptInset()) - if (sup->hasUp()) { - p->cell(3) = sup->up().data(); - ++st; - } + // is this a integral name? + if (!testIntegral(*it)) + continue; // core ist part from behind the scripts to the 'd' - p->cell(0) = MathArray(st, jt); + MathExIntInset * p = new MathExIntInset("int"); + + // handle scripts if available + if (!testIntSymbol(*it)) { + p->cell(2) = (*it)->asScriptInset()->down(); + p->cell(3) = (*it)->asScriptInset()->up(); + } + p->cell(0) = MathArray(it + 1, jt); // use the "thing" behind the 'd' as differential MathArray::iterator tt = extractArgument(p->cell(1), jt + 1, ar.end()); // remove used parts ar.erase(it + 1, tt); - (*it).reset(p); + *it = MathAtom(p); } //lyxerr << "\nIntegrals to: " << ar << "\n"; } @@ -569,10 +565,25 @@ void extractIntegrals(MathArray & ar) bool testEqualSign(MathAtom const & at) { - return testString(at.nucleus(), "="); + return testString(at, "="); } +bool testSumSymbol(MathAtom const & p) +{ + return testSymbol(p, "sum"); +} + + +bool testSum(MathAtom const & at) +{ + return + testSumSymbol(at) || + ( at->asScriptInset() + && at->asScriptInset()->nuc().size() + && testSumSymbol(at->asScriptInset()->nuc().back()) ); +} + // replace '\sum' ['_^'] f(x) sequences by a real MathExIntInset // assume 'extractDelims' ran before @@ -587,47 +598,40 @@ void extractSums(MathArray & ar) MathArray::iterator it = ar.begin() + i; // is this a sum name? - if (!testSymbol(it->nucleus(), "sum")) + if (!testSum(*it)) continue; // create a proper inset as replacement MathExIntInset * p = new MathExIntInset("sum"); // collect lower bound and summation index - MathArray::iterator st = it + 1; - if (st != ar.end()) - if (MathScriptInset * sub = (*st)->asScriptInset()) - if (sub->hasDown()) { - // try to figure out the summation index from the subscript - MathArray & ar = sub->down().data(); - MathArray::iterator it = - find_if(ar.begin(), ar.end(), &testEqualSign); - if (it != ar.end()) { - // we found a '=', use everything in front of that as index, - // and everything behind as lower index - p->cell(1) = MathArray(ar.begin(), it); - p->cell(2) = MathArray(it + 1, ar.end()); - } else { - // use everything as summation index, don't use scripts. - p->cell(1) = ar; - } - ++st; - } + MathScriptInset const * sub = (*it)->asScriptInset(); + if (sub && sub->hasDown()) { + // try to figure out the summation index from the subscript + MathArray const & ar = sub->down(); + MathArray::const_iterator xt = + find_if(ar.begin(), ar.end(), &testEqualSign); + if (xt != ar.end()) { + // we found a '=', use everything in front of that as index, + // and everything behind as lower index + p->cell(1) = MathArray(ar.begin(), xt); + p->cell(2) = MathArray(xt + 1, ar.end()); + } else { + // use everything as summation index, don't use scripts. + p->cell(1) = ar; + } + } // collect upper bound - if (st != ar.end()) - if (MathScriptInset * sup = (*st)->asScriptInset()) - if (sup->hasUp()) { - p->cell(3) = sup->up().data(); - ++st; - } + if (sub && sub->hasUp()) + p->cell(3) = sub->up(); - // use some behind the script as core - MathArray::iterator tt = extractArgument(p->cell(0), st, ar.end()); + // use something behind the script as core + MathArray::iterator tt = extractArgument(p->cell(0), it + 1, ar.end()); // cleanup ar.erase(it + 1, tt); - (*it).reset(p); + *it = MathAtom(p); } //lyxerr << "\nSums to: " << ar << "\n"; } @@ -640,7 +644,7 @@ void extractSums(MathArray & ar) // tests for 'd' or '\partial' bool testDiffItem(MathAtom const & at) { - return testString(at.nucleus(), "d"); + return testString(at, "d"); } @@ -650,25 +654,12 @@ bool testDiffArray(MathArray const & ar) } -bool testDiffFrac(MathInset * p) -{ - MathFracInset * f = p->asFracInset(); - return f && testDiffArray(f->cell(0)) && testDiffArray(f->cell(1)); -} - - -// is this something like ^number? -bool extractDiffExponent(MathArray::iterator it, int & i) +bool testDiffFrac(MathAtom const & at) { - if (!(*it)->asScriptInset()) - return false; - - string s; - if (!extractString((*it).nucleus(), s)) - return false; - istringstream is(s.c_str()); - is >> i; - return is; + return + at->asFracInset() + && testDiffArray(at->asFracInset()->cell(0)) + && testDiffArray(at->asFracInset()->cell(1)); } @@ -679,10 +670,10 @@ void extractDiff(MathArray & ar) MathArray::iterator it = ar.begin() + i; // is this a "differential fraction"? - if (!testDiffFrac(it->nucleus())) + if (!testDiffFrac(*it)) continue; - MathFracInset * f = (*it)->asFracInset(); + MathFracInset const * f = (*it)->asFracInset(); if (!f) { lyxerr << "should not happen\n"; continue; @@ -694,7 +685,7 @@ void extractDiff(MathArray & ar) // collect function, let jt point behind last used item MathArray::iterator jt = it + 1; //int n = 1; - MathArray & numer = f->cell(0); + MathArray const & numer = f->cell(0); if (numer.size() > 1 && numer[1]->asScriptInset()) { // this is something like d^n f(x) / d... or d^n / d... // FIXME @@ -712,18 +703,19 @@ void extractDiff(MathArray & ar) } // collect denominator parts - MathArray & denom = f->cell(1); - for (MathArray::iterator dt = denom.begin(); dt != denom.end();) { + MathArray const & denom = f->cell(1); + for (MathArray::const_iterator dt = denom.begin(); dt != denom.end();) { // find the next 'd' - MathArray::iterator et = find_if(dt + 1, denom.end(), &testDiffItem); + MathArray::const_iterator et + = find_if(dt + 1, denom.end(), &testDiffItem); // point before this - MathArray::iterator st = et - 1; - MathScriptInset * script = (*st)->asScriptInset(); + MathArray::const_iterator st = et - 1; + MathScriptInset const * script = (*st)->asScriptInset(); if (script && script->hasUp()) { // things like d.../dx^n int mult = 1; - if (extractNumber(script->up().data(), mult)) { + if (extractNumber(script->up(), mult)) { //lyxerr << "mult: " << mult << endl; for (int i = 0; i < mult; ++i) diff->addDer(MathArray(dt + 1, st)); @@ -737,7 +729,7 @@ void extractDiff(MathArray & ar) // cleanup ar.erase(it + 1, jt); - (*it).reset(diff); + *it = MathAtom(diff); } //lyxerr << "\nDiffs to: " << ar << "\n"; } @@ -750,9 +742,7 @@ void extractDiff(MathArray & ar) bool testRightArrow(MathAtom const & at) { - return - testSymbol(at.nucleus(), "to") || - testSymbol(at.nucleus(), "rightarrow"); + return testSymbol(at, "to") || testSymbol(at, "rightarrow"); } @@ -770,17 +760,17 @@ void extractLims(MathArray & ar) MathArray::iterator it = ar.begin() + i; // is this a limit function? - if (!testSymbol(it->nucleus(), "lim")) + if (!testSymbol(*it, "lim")) continue; // the next one must be a subscript (without superscript) - MathScriptInset * sub = (*(it + 1))->asScriptInset(); + MathScriptInset const * sub = (*(it + 1))->asScriptInset(); if (!sub || !sub->hasDown() || sub->hasUp()) continue; // and it must contain a -> symbol - MathArray & s = sub->down().data(); - MathArray::iterator st = find_if(s.begin(), s.end(), &testRightArrow); + MathArray const & s = sub->down(); + MathArray::const_iterator st = find_if(s.begin(), s.end(), &testRightArrow); if (st == s.end()) continue; @@ -792,12 +782,11 @@ void extractLims(MathArray & ar) MathArray f; MathArray::iterator tt = extractArgument(f, it + 2, ar.end()); - // create a proper inset as replacement - MathLimInset * p = new MathLimInset(f, x, x0); - // cleanup ar.erase(it + 1, tt); - (*it).reset(p); + + // create a proper inset as replacement + *it = MathAtom(new MathLimInset(f, x, x0)); } //lyxerr << "\nLimits to: " << ar << "\n"; } @@ -809,14 +798,14 @@ void extractLims(MathArray & ar) void extractStructure(MathArray & ar) { + extractIntegrals(ar); + extractSums(ar); splitScripts(ar); extractNumbers(ar); extractMatrices(ar); extractDelims(ar); extractFunctions(ar); extractDets(ar); - extractIntegrals(ar); - extractSums(ar); extractDiff(ar); extractExps(ar); extractLims(ar); @@ -828,8 +817,11 @@ void write(MathArray const & dat, WriteStream & wi) { MathArray ar = dat; extractStrings(ar); - for (MathArray::const_iterator it = ar.begin(); it != ar.end(); ++it) + wi.firstitem() = true; + for (MathArray::const_iterator it = ar.begin(); it != ar.end(); ++it) { (*it)->write(wi); + wi.firstitem() = false; + } } @@ -874,7 +866,7 @@ void mathmlize(MathArray const & dat, MathMLStream & os) if (ar.size() == 0) os << ""; else if (ar.size() == 1) - os << ar.begin()->nucleus(); + os << ar.front(); else { os << MTag("mrow"); for (MathArray::const_iterator it = ar.begin(); it != ar.end(); ++it) @@ -1042,7 +1034,7 @@ namespace { res.append(mat->cell(0)); else { res.push_back(MathAtom(new MathDelimInset("(", ")"))); - res.back()->cell(0).push_back(at); + res.back().nucleus()->cell(0).push_back(at); } return res; }