X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fmathed%2FMathParser.cpp;h=1982af3c86c47b2b2e85f59fb367d4a1c9a654c0;hb=f67cf6f4bb3e3d22ac9aebfa22027c3537cbdf61;hp=77ba3bf485d7ca523e912fff10981d88c63ea93e;hpb=63cb2b52aaeb5ee3f87b17acc0f293f1ab48ff4b;p=lyx.git diff --git a/src/mathed/MathParser.cpp b/src/mathed/MathParser.cpp index 77ba3bf485..1982af3c86 100644 --- a/src/mathed/MathParser.cpp +++ b/src/mathed/MathParser.cpp @@ -42,6 +42,7 @@ following hack as starting point to write some macros: #include "InsetMathArray.h" #include "InsetMathBig.h" #include "InsetMathBrace.h" +#include "InsetMathCancelto.h" #include "InsetMathChar.h" #include "InsetMathColor.h" #include "InsetMathComment.h" @@ -214,7 +215,7 @@ bool addCol(InsetMathGrid & grid, InsetMathGrid::col_type & cellcol) /*! - * Check wether the last row is empty and remove it if yes. + * Check whether the last row is empty and remove it if yes. * Otherwise the following code * \verbatim \begin{array}{|c|c|} @@ -225,6 +226,8 @@ bool addCol(InsetMathGrid & grid, InsetMathGrid::col_type & cellcol) * \endverbatim * will result in a grid with 3 rows (+ the dummy row that is always present), * because the last '\\' opens a new row. + * Note that this is only needed for inner-hull grid types, such as array + * or aligned, but not for outer-hull grid types, such as eqnarray or align. */ void delEmptyLastRow(InsetMathGrid & grid) { @@ -241,6 +244,19 @@ void delEmptyLastRow(InsetMathGrid & grid) } +/*! + * Tell whether the environment name corresponds to an inner-hull grid type. + */ +bool innerHull(docstring const & name) +{ + // For [bB]matrix, [vV]matrix, and pmatrix we can check the suffix only + return name == "array" || name == "cases" || name == "aligned" + || name == "alignedat" || name == "gathered" || name == "split" + || name == "subarray" || name == "tabular" || name == "matrix" + || name == "smallmatrix" || name.substr(1) == "matrix"; +} + + // These are TeX's catcodes enum CatCode { catEscape, // 0 backslash @@ -318,9 +334,9 @@ public: /// char_type character() const { return char_; } /// - docstring asString() const { return cs_.size() ? cs_ : docstring(1, char_); } + docstring asString() const { return !cs_.empty() ? cs_ : docstring(1, char_); } /// - docstring asInput() const { return cs_.size() ? '\\' + cs_ : docstring(1, char_); } + docstring asInput() const { return !cs_.empty() ? '\\' + cs_ : docstring(1, char_); } private: /// @@ -334,7 +350,7 @@ private: ostream & operator<<(ostream & os, Token const & t) { - if (t.cs().size()) { + if (!t.cs().empty()) { docstring const & cs = t.cs(); // FIXME: For some strange reason, the stream operator instanciate // a new Token before outputting the contents of t.cs(). @@ -520,7 +536,6 @@ char_type Parser::getChar() { if (!good()) { error("The input stream is not well..."); - putback(); return 0; } return tokens_[pos_++].character(); @@ -529,9 +544,12 @@ char_type Parser::getChar() docstring Parser::getArg(char_type left, char_type right) { + docstring result; skipSpaces(); - docstring result; + if (!good()) + return result; + char_type c = getChar(); if (c != left) @@ -614,6 +632,8 @@ void Parser::tokenize(docstring const & buffer) if (!is) { error("unexpected end of input"); } else { + if (c == '\n') + c = ' '; docstring s(1, c); if (catcode(c) == catLetter) { // collect letters @@ -832,9 +852,16 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags, Token const & n = getToken(); if (n.cat() == catMath) { // TeX's $$...$$ syntax for displayed math - cell->push_back(MathAtom(new InsetMathHull(buf, hullEquation))); - parse2(cell->back(), FLAG_SIMPLE, InsetMath::MATH_MODE, false); - getToken(); // skip the second '$' token + if (mode == InsetMath::UNDECIDED_MODE) { + cell->push_back(MathAtom(new InsetMathHull(buf, hullEquation))); + parse2(cell->back(), FLAG_SIMPLE, InsetMath::MATH_MODE, false); + getToken(); // skip the second '$' token + } else { + // This is not an outer hull and display math is + // not allowed inside text mode environments. + error("bad math environment"); + break; + } } else { // simple $...$ stuff putback(); @@ -855,8 +882,19 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags, } else { - error("something strange in the parser"); - break; + Token const & n = getToken(); + if (n.cat() == catMath) { + error("something strange in the parser"); + break; + } else { + // This is inline math ($...$), but the parser thinks we are + // already in math mode and latex would issue an error, unless we + // are inside a text mode user macro. We have no way to tell, so + // let's play safe by using \ensuremath, as it will work in any case. + putback(); + cell->push_back(MathAtom(new InsetMathEnsureMath(buf))); + parse(cell->back().nucleus()->cell(0), FLAG_SIMPLE, InsetMath::MATH_MODE); + } } } @@ -879,7 +917,7 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags, } else if (t.cat() == catActive) - cell->push_back(MathAtom(new InsetMathChar(t.character()))); + cell->push_back(MathAtom(new InsetMathSpace(string(1, t.character()), ""))); else if (t.cat() == catBegin) { MathData ar; @@ -913,7 +951,7 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags, bool up = (t.cat() == catSuper); // we need no new script inset if the last thing was a scriptinset, // which has that script already not the same script already - if (!cell->size()) + if (cell->empty()) cell->push_back(MathAtom(new InsetMathScript(buf, up))); else if (cell->back()->asScriptInset() && !cell->back()->asScriptInset()->has(up)) @@ -935,6 +973,14 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags, // in an unreliable way. See this thread // http://www.mail-archive.com/lyx-devel%40lists.lyx.org/msg104917.html // for more details. + // However, we remove empty braces because they look + // ugly on screen and we are sure that they were added + // by the write() method (and will be re-added on save). + if (p->nuc().size() == 1 && + p->nuc().back()->asBraceInset() && + p->nuc().back()->asBraceInset()->cell(0).empty()) + p->nuc().erase(0); + parse(p->cell(p->idxOfScript(up)), FLAG_ITEM, mode); if (limits) { p->limits(limits); @@ -972,7 +1018,7 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags, Token const & t = getToken(); if (t.cat() == catNewline) break; - s += t.asString(); + s += t.asInput(); } cell->push_back(MathAtom(new InsetMathComment(buf, s))); skipSpaces(); @@ -983,7 +1029,7 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags, // else if (t.cs() == "lyxlock") { - if (cell->size()) + if (!cell->empty()) cell->back().nucleus()->lock(true); } @@ -1192,12 +1238,8 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags, } else if (t.cs() == "(") { - if (mode == InsetMath::MATH_MODE) { - error("bad math environment"); - break; - } - cell->push_back(MathAtom(new InsetMathHull(buf, hullSimple))); - parse2(cell->back(), FLAG_SIMPLE2, InsetMath::MATH_MODE, false); + cell->push_back(MathAtom(new InsetMathEnsureMath(buf))); + parse(cell->back().nucleus()->cell(0), FLAG_SIMPLE2, InsetMath::MATH_MODE); } else if (t.cs() == "[") { @@ -1234,7 +1276,7 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags, // probably need to refine this test. // Right now we only have to test for // single line hull insets. - if (grid.nrows() > 1) + if (grid.nrows() > 1 && innerHull(name)) delEmptyLastRow(grid); return success_; } @@ -1308,11 +1350,15 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags, } #endif - else if (t.cs() == "limits") - limits = 1; - - else if (t.cs() == "nolimits") - limits = -1; + else if (t.cs() == "limits" || t.cs() == "nolimits") { + CatCode const cat = nextToken().cat(); + if (cat == catSuper || cat == catSub) + limits = t.cs() == "limits" ? 1 : -1; + else { + MathAtom at = createInsetMath(t.cs(), buf); + cell->push_back(at); + } + } else if (t.cs() == "nonumber") { if (grid.asHullInset()) @@ -1331,7 +1377,7 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags, else if (t.cs() == "sqrt") { MathData ar; parse(ar, FLAG_OPTION, mode); - if (ar.size()) { + if (!ar.empty()) { cell->push_back(MathAtom(new InsetMathRoot(buf))); cell->back().nucleus()->cell(0) = ar; parse(cell->back().nucleus()->cell(1), FLAG_ITEM, mode); @@ -1341,11 +1387,19 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags, } } + else if (t.cs() == "cancelto") { + MathData ar; + parse(ar, FLAG_ITEM, mode); + cell->push_back(MathAtom(new InsetMathCancelto(buf))); + cell->back().nucleus()->cell(1) = ar; + parse(cell->back().nucleus()->cell(0), FLAG_ITEM, mode); + } + else if (t.cs() == "unit") { // Allowed formats \unit[val]{unit} MathData ar; parse(ar, FLAG_OPTION, mode); - if (ar.size()) { + if (!ar.empty()) { cell->push_back(MathAtom(new InsetMathFrac(buf, InsetMathFrac::UNIT))); cell->back().nucleus()->cell(0) = ar; parse(cell->back().nucleus()->cell(1), FLAG_ITEM, mode); @@ -1359,7 +1413,7 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags, // Here allowed formats are \unitfrac[val]{num}{denom} MathData ar; parse(ar, FLAG_OPTION, mode); - if (ar.size()) { + if (!ar.empty()) { cell->push_back(MathAtom(new InsetMathFrac(buf, InsetMathFrac::UNITFRAC, 3))); cell->back().nucleus()->cell(2) = ar; } else { @@ -1465,12 +1519,8 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags, } else if (name == "math") { - if (mode == InsetMath::MATH_MODE) { - error("bad math environment"); - break; - } - cell->push_back(MathAtom(new InsetMathHull(buf, hullSimple))); - parse2(cell->back(), FLAG_END, InsetMath::MATH_MODE, true); + cell->push_back(MathAtom(new InsetMathEnsureMath(buf))); + parse(cell->back().nucleus()->cell(0), FLAG_END, InsetMath::MATH_MODE); } else if (name == "equation" || name == "equation*" @@ -1668,6 +1718,11 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags, else if (t.cs() == "substack") { cell->push_back(createInsetMath(t.cs(), buf)); parse2(cell->back(), FLAG_ITEM, mode, false); + // Delete empty last row if present + InsetMathGrid & subgrid = + *(cell->back().nucleus()->asGridInset()); + if (subgrid.nrows() > 1) + delEmptyLastRow(subgrid); } else if (t.cs() == "xymatrix") { @@ -1676,6 +1731,19 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags, os << getToken().asInput(); cell->push_back(createInsetMath(t.cs() + os.str(), buf)); parse2(cell->back(), FLAG_ITEM, mode, false); + // Delete empty last row if present + InsetMathGrid & subgrid = + *(cell->back().nucleus()->asGridInset()); + if (subgrid.nrows() > 1) + delEmptyLastRow(subgrid); + } + + else if (t.cs() == "Diagram") { + odocstringstream os; + while (good() && nextToken().cat() != catBegin) + os << getToken().asInput(); + cell->push_back(createInsetMath(t.cs() + os.str(), buf)); + parse2(cell->back(), FLAG_ITEM, mode, false); } else if (t.cs() == "framebox" || t.cs() == "makebox") { @@ -1694,12 +1762,17 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags, parse(cell->back().nucleus()->cell(0), FLAG_ITEM, InsetMath::TEXT_MODE); } - else if (t.cs() == "hspace" && nextToken().character() != '*') { + else if (t.cs() == "hspace") { + bool const prot = nextToken().character() == '*'; + if (prot) + getToken(); docstring const name = t.cs(); docstring const arg = parse_verbatim_item(); Length length; - if (isValidLength(to_utf8(arg), &length)) - cell->push_back(MathAtom(new InsetMathSpace(length))); + if (prot && arg == "\\fill") + cell->push_back(MathAtom(new InsetMathSpace("hspace*{\\fill}", ""))); + else if (isValidLength(to_utf8(arg), &length)) + cell->push_back(MathAtom(new InsetMathSpace(length, prot))); else { // Since the Length class cannot use length variables // we must not create an InsetMathSpace. @@ -1757,29 +1830,35 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags, error("'}' expected in \\" + t.cs()); return success_; } + bool termination; docstring rem; do { - cmd = Encodings::fromLaTeXCommand(cmd, rem); + cmd = Encodings::fromLaTeXCommand(cmd, + Encodings::MATH_CMD | Encodings::TEXT_CMD, + termination, rem); for (size_t i = 0; i < cmd.size(); ++i) cell->push_back(MathAtom(new InsetMathChar(cmd[i]))); - if (rem.size()) { + if (!rem.empty()) { char_type c = rem[0]; cell->push_back(MathAtom(new InsetMathChar(c))); cmd = rem.substr(1); rem.clear(); } else cmd.clear(); - } while (cmd.size()); + } while (!cmd.empty()); } - else if (t.cs().size()) { + else if (!t.cs().empty()) { bool const no_mhchem = - (t.cs() == "ce" || t.cs() == "cf") && buf - && buf->params().use_mhchem == BufferParams::package_off; + (t.cs() == "ce" || t.cs() == "cf") + && buf && buf->params().use_package("mhchem") == + BufferParams::package_off; + bool const is_user_macro = no_mhchem || (buf && (mode_ & Parse::TRACKMACRO - ? buf->usermacros.count(t.cs()) != 0 - : buf->getMacro(t.cs(), false) != 0)); + ? buf->usermacros.count(t.cs()) != 0 + : buf->getMacro(t.cs(), false) != 0)); + latexkeys const * l = in_word_set(t.cs()); if (l && !is_user_macro) { if (l->inset == "big") { @@ -1848,8 +1927,10 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags, } } bool is_combining; - char_type c = - Encodings::fromLaTeXCommand(cmd, is_combining); + bool termination; + char_type c = Encodings::fromLaTeXCommand(cmd, + Encodings::MATH_CMD | Encodings::TEXT_CMD, + is_combining, termination); if (is_combining) { if (cat == catLetter) cmd += '{'; @@ -1857,9 +1938,26 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags, ++num_tokens; if (cat == catLetter) cmd += '}'; - c = Encodings::fromLaTeXCommand(cmd, is_combining); + c = Encodings::fromLaTeXCommand(cmd, + Encodings::MATH_CMD | Encodings::TEXT_CMD, + is_combining, termination); } if (c) { + if (termination) { + if (nextToken().cat() == catBegin) { + getToken(); + if (nextToken().cat() == catEnd) { + getToken(); + num_tokens += 2; + } else + putback(); + } else { + while (nextToken().cat() == catSpace) { + getToken(); + ++num_tokens; + } + } + } is_unicode_symbol = true; cell->push_back(MathAtom(new InsetMathChar(c))); } else { @@ -1881,7 +1979,7 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags, // this fails on \bigg[...\bigg] //MathData opt; //parse(opt, FLAG_OPTION, InsetMath::VERBATIM_MODE); - //if (opt.size()) { + //if (!opt.empty()) { // start = 1; // at.nucleus()->cell(0) = opt; //}