X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fmathed%2FMathParser.cpp;h=0f10aa5ed75c7104c38d94e18e72b7c8dee8d8bd;hb=89342f2946abd5d01b019a729d1f160b0c9d3d50;hp=7c67f0df87d167b61d32a9a18d3c857c092ee144;hpb=ff4460603e3888948b46f0ab5bfa69a862d538ad;p=lyx.git diff --git a/src/mathed/MathParser.cpp b/src/mathed/MathParser.cpp index 7c67f0df87..0f10aa5ed7 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" @@ -55,16 +56,21 @@ following hack as starting point to write some macros: #include "InsetMathRef.h" #include "InsetMathRoot.h" #include "InsetMathScript.h" +#include "InsetMathSideset.h" #include "InsetMathSpace.h" #include "InsetMathSplit.h" #include "InsetMathSqrt.h" +#include "InsetMathStackrel.h" +#include "InsetMathString.h" #include "InsetMathTabular.h" #include "MathMacroTemplate.h" +#include "MathExtern.h" #include "MathFactory.h" #include "MathMacroArgument.h" #include "MathSupport.h" #include "Buffer.h" +#include "BufferParams.h" #include "Encoding.h" #include "Lexer.h" @@ -212,7 +218,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|} @@ -223,6 +229,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) { @@ -239,6 +247,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 @@ -316,9 +337,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: /// @@ -332,7 +353,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(). @@ -380,6 +401,12 @@ public: int lineno() const { return lineno_; } /// void putback(); + /// store current position + void pushPosition(); + /// restore previous position + void popPosition(); + /// forget last saved position + void dropPosition(); private: /// @@ -427,6 +454,8 @@ private: vector tokens_; /// unsigned pos_; + /// + std::vector positions_; /// Stack of active environments vector environments_; /// @@ -442,8 +471,6 @@ Parser::Parser(Lexer & lexer, parse_mode mode, Buffer * buf) : lineno_(lexer.lineNumber()), pos_(0), mode_(mode), success_(true), buffer_(buf) { - if (buf) - buf->updateMacros(); tokenize(lexer.getStream()); lexer.eatLine(); } @@ -452,8 +479,6 @@ Parser::Parser(Lexer & lexer, parse_mode mode, Buffer * buf) Parser::Parser(istream & is, parse_mode mode, Buffer * buf) : lineno_(0), pos_(0), mode_(mode), success_(true), buffer_(buf) { - if (buf) - buf->updateMacros(); tokenize(is); } @@ -461,8 +486,6 @@ Parser::Parser(istream & is, parse_mode mode, Buffer * buf) Parser::Parser(docstring const & str, parse_mode mode, Buffer * buf) : lineno_(0), pos_(0), mode_(mode), success_(true), buffer_(buf) { - if (buf) - buf->updateMacros(); tokenize(str); } @@ -514,6 +537,25 @@ void Parser::putback() } +void Parser::pushPosition() +{ + positions_.push_back(pos_); +} + + +void Parser::popPosition() +{ + pos_ = positions_.back(); + positions_.pop_back(); +} + + +void Parser::dropPosition() +{ + positions_.pop_back(); +} + + bool Parser::good() const { return pos_ < tokens_.size(); @@ -524,7 +566,6 @@ char_type Parser::getChar() { if (!good()) { error("The input stream is not well..."); - putback(); return 0; } return tokens_[pos_++].character(); @@ -533,9 +574,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) @@ -618,6 +662,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 @@ -836,18 +882,25 @@ 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(buffer_, 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(); if (mode == InsetMath::UNDECIDED_MODE) { - cell->push_back(MathAtom(new InsetMathHull(buffer_, hullSimple))); + cell->push_back(MathAtom(new InsetMathHull(buf, hullSimple))); parse2(cell->back(), FLAG_SIMPLE, InsetMath::MATH_MODE, false); } else { // Don't create nested math hulls (bug #5392) - cell->push_back(MathAtom(new InsetMathEnsureMath(buffer_))); + cell->push_back(MathAtom(new InsetMathEnsureMath(buf))); parse(cell->back().nucleus()->cell(0), FLAG_SIMPLE, InsetMath::MATH_MODE); } } @@ -859,8 +912,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); + } } } @@ -883,7 +947,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; @@ -917,15 +981,15 @@ 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()) - cell->push_back(MathAtom(new InsetMathScript(buffer_, up))); + if (cell->empty()) + cell->push_back(MathAtom(new InsetMathScript(buf, up))); else if (cell->back()->asScriptInset() && !cell->back()->asScriptInset()->has(up)) cell->back().nucleus()->asScriptInset()->ensure(up); else if (cell->back()->asScriptInset()) - cell->push_back(MathAtom(new InsetMathScript(buffer_, up))); + cell->push_back(MathAtom(new InsetMathScript(buf, up))); else - cell->back() = MathAtom(new InsetMathScript(buffer_, cell->back(), up)); + cell->back() = MathAtom(new InsetMathScript(buf, cell->back(), up)); InsetMathScript * p = cell->back().nucleus()->asScriptInset(); // special handling of {}-bases // Here we could remove the brace inset for things @@ -939,6 +1003,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); @@ -976,9 +1048,9 @@ 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(buffer_, s))); + cell->push_back(MathAtom(new InsetMathComment(buf, s))); skipSpaces(); } @@ -987,7 +1059,7 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags, // else if (t.cs() == "lyxlock") { - if (cell->size()) + if (!cell->empty()) cell->back().nucleus()->lock(true); } @@ -995,10 +1067,10 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags, t.cs() == "def") { if (t.cs() == "global") getToken(); - + // get name docstring name = getToken().cs(); - + // read parameters int nargs = 0; docstring pars; @@ -1007,22 +1079,25 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags, ++nargs; } nargs /= 2; - + // read definition MathData def; parse(def, FLAG_ITEM, InsetMath::UNDECIDED_MODE); - + // is a version for display attached? skipSpaces(); MathData display; if (nextToken().cat() == catBegin) parse(display, FLAG_ITEM, InsetMath::MATH_MODE); - - cell->push_back(MathAtom(new MathMacroTemplate(buffer_, name, - nargs, 0, MacroTypeDef, + + cell->push_back(MathAtom(new MathMacroTemplate(buf, + name, nargs, 0, MacroTypeDef, vector(), def, display))); + + if (buf && (mode_ & Parse::TRACKMACRO)) + buf->usermacros.insert(name); } - + else if (t.cs() == "newcommand" || t.cs() == "renewcommand" || t.cs() == "newlyxcommand") { @@ -1036,13 +1111,13 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags, error("'}' in \\newcommand expected"); return success_; } - + // get arity docstring const arg = getArg('[', ']'); int nargs = 0; if (!arg.empty()) nargs = convert(arg); - + // optional argument given? skipSpaces(); int optionals = 0; @@ -1053,21 +1128,24 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags, parse(optionalValues[optionals], FLAG_BRACK_LAST, mode); ++optionals; } - + MathData def; parse(def, FLAG_ITEM, InsetMath::UNDECIDED_MODE); - + // is a version for display attached? skipSpaces(); MathData display; if (nextToken().cat() == catBegin) parse(display, FLAG_ITEM, InsetMath::MATH_MODE); - - cell->push_back(MathAtom(new MathMacroTemplate(buffer_, name, - nargs, optionals, MacroTypeNewcommand, + + cell->push_back(MathAtom(new MathMacroTemplate(buf, + name, nargs, optionals, MacroTypeNewcommand, optionalValues, def, display))); + + if (buf && (mode_ & Parse::TRACKMACRO)) + buf->usermacros.insert(name); } - + else if (t.cs() == "newcommandx" || t.cs() == "renewcommandx") { // \newcommandx{\foo}[2][usedefault, addprefix=\global,1=default]{#1,#2} @@ -1082,7 +1160,7 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags, } } else name = getToken().cs(); - + // get arity docstring const arg = getArg('[', ']'); if (arg.empty()) { @@ -1090,14 +1168,14 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags, return success_; } int nargs = convert(arg); - + // get options int optionals = 0; vector optionalValues; if (nextToken().character() == '[') { // skip '[' getToken(); - + // handle 'opt=value' options, separated by ','. skipSpaces(); while (nextToken().character() != ']' && good()) { @@ -1110,14 +1188,14 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags, "for given optional parameter."); return success_; } - + // skip '=' if (getToken().character() != '=') { error("'=' and optional parameter value " "expected for \\newcommandx"); return success_; } - + // get value int optNum = max(size_t(n), optionalValues.size()); optionalValues.resize(optNum); @@ -1132,12 +1210,12 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags, } else if (nextToken().cat() == catLetter) { // we in fact ignore every non-optional // parameter - + // get option name docstring opt; while (nextToken().cat() == catLetter) opt += getChar(); - + // value? skipSpaces(); MathData value; @@ -1145,14 +1223,14 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags, getToken(); while (nextToken().character() != ']' && nextToken().character() != ',') - parse(value, FLAG_ITEM, + parse(value, FLAG_ITEM, InsetMath::UNDECIDED_MODE); } } else { error("option for \\newcommandx expected"); return success_; } - + // skip komma skipSpaces(); if (nextToken().character() == ',') { @@ -1164,7 +1242,7 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags, return success_; } } - + // skip ']' if (!good()) return success_; @@ -1181,26 +1259,31 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags, if (nextToken().cat() == catBegin) parse(display, FLAG_ITEM, InsetMath::MATH_MODE); - cell->push_back(MathAtom(new MathMacroTemplate(buffer_, name, - nargs, optionals, MacroTypeNewcommandx, + cell->push_back(MathAtom(new MathMacroTemplate(buf, + name, nargs, optionals, MacroTypeNewcommandx, optionalValues, def, display))); + + if (buf && (mode_ & Parse::TRACKMACRO)) + buf->usermacros.insert(name); } else if (t.cs() == "(") { - if (mode == InsetMath::MATH_MODE) { - error("bad math environment"); - break; + if (mode == InsetMath::UNDECIDED_MODE) { + cell->push_back(MathAtom(new InsetMathHull(buf, hullSimple))); + parse2(cell->back(), FLAG_SIMPLE2, InsetMath::MATH_MODE, false); + } else { + // Don't create nested math hulls (bug #5392) + cell->push_back(MathAtom(new InsetMathEnsureMath(buf))); + parse(cell->back().nucleus()->cell(0), FLAG_SIMPLE2, InsetMath::MATH_MODE); } - cell->push_back(MathAtom(new InsetMathHull(buffer_, hullSimple))); - parse2(cell->back(), FLAG_SIMPLE2, InsetMath::MATH_MODE, false); } else if (t.cs() == "[") { if (mode != InsetMath::UNDECIDED_MODE) { - error("bad math environment"); + error("bad math environment ["); break; } - cell->push_back(MathAtom(new InsetMathHull(buffer_, hullEquation))); + cell->push_back(MathAtom(new InsetMathHull(buf, hullEquation))); parse2(cell->back(), FLAG_EQUATION, InsetMath::MATH_MODE, false); } @@ -1229,7 +1312,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_; } @@ -1252,14 +1335,36 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags, else if (t.cs() == "\\") { if (flags & FLAG_ALIGN) return success_; - bool added = false; + bool starred = false; + docstring arg; if (nextToken().asInput() == "*") { getToken(); - added = addRow(grid, cellrow, docstring(), false); - } else if (good()) - added = addRow(grid, cellrow, getArg('[', ']')); - else + starred = true; + } else if (nextToken().asInput() == "[") + arg = getArg('[', ']'); + else if (!good()) error("missing token after \\\\"); + // skip "{}" added in front of "[" (the + // counterpart is in InsetMathGrid::eolString()) + // skip spaces because formula could come from tex2lyx + bool skipBraces = false; + pushPosition(); + if (nextToken().cat() == catBegin) { + getToken(); + if (nextToken().cat() == catEnd) { + getToken(); + pushPosition(); + skipSpaces(); + if (nextToken().asInput() == "[") + skipBraces = true; + popPosition(); + } + } + if (skipBraces) + dropPosition(); + else + popPosition(); + bool const added = addRow(grid, cellrow, arg, !starred); if (added) { cellcol = 0; if (grid.asHullInset()) @@ -1270,7 +1375,6 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags, } } -#if 0 else if (t.cs() == "multicolumn") { // extract column count and insert dummy cells MathData count; @@ -1278,46 +1382,48 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags, int cols = 1; if (!extractNumber(count, cols)) { success_ = false; - lyxerr << " can't extract number of cells from " << count << endl; + error("can't extract number of multicolumn cells"); } // resize the table if necessary + size_t first = 0; for (int i = 0; i < cols; ++i) { if (addCol(grid, cellcol)) { - cell = &grid.cell(grid.index( - cellrow, cellcol)); - // mark this as dummy - grid.cellinfo(grid.index( - cellrow, cellcol)).dummy_ = true; + size_t const idx = grid.index(cellrow, cellcol); + if (i == 0) + first = idx; + grid.cellinfo(idx).multi_ = + InsetMathGrid::CELL_PART_OF_MULTICOLUMN; } } - // the last cell is the real thing, not a dummy - grid.cellinfo(grid.index(cellrow, cellcol)).dummy_ = false; + + // the first cell is the real thing, not a dummy + cell = &grid.cell(first); + grid.cellinfo(first).multi_ = InsetMathGrid::CELL_BEGIN_OF_MULTICOLUMN; // read special alignment - MathData align; - parse(align, FLAG_ITEM, mode); - //grid.cellinfo(grid.index(cellrow, cellcol)).align_ = extractString(align); + grid.cellinfo(first).align_ = parse_verbatim_item(); // parse the remaining contents into the "real" cell parse(*cell, FLAG_ITEM, mode); } -#endif - - else if (t.cs() == "limits") - limits = 1; - - else if (t.cs() == "nolimits") - limits = -1; - else if (t.cs() == "nonumber") { - if (grid.asHullInset()) - grid.asHullInset()->numbered(cellrow, false); + 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() == "number") { - if (grid.asHullInset()) - grid.asHullInset()->numbered(cellrow, true); - } + // \notag is the same as \nonumber if amsmath is used + else if ((t.cs() == "nonumber" || t.cs() == "notag") && + grid.asHullInset()) + grid.asHullInset()->numbered(cellrow, false); + + else if (t.cs() == "number" && grid.asHullInset()) + grid.asHullInset()->numbered(cellrow, true); else if (t.cs() == "hline") { grid.rowinfo(cellrow).lines_ ++; @@ -1326,26 +1432,34 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags, else if (t.cs() == "sqrt") { MathData ar; parse(ar, FLAG_OPTION, mode); - if (ar.size()) { - cell->push_back(MathAtom(new InsetMathRoot(buffer_))); + 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); } else { - cell->push_back(MathAtom(new InsetMathSqrt(buffer_))); + cell->push_back(MathAtom(new InsetMathSqrt(buf))); parse(cell->back().nucleus()->cell(0), FLAG_ITEM, mode); } } + 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()) { - cell->push_back(MathAtom(new InsetMathFrac(buffer_, InsetMathFrac::UNIT))); + 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); } else { - cell->push_back(MathAtom(new InsetMathFrac(buffer_, InsetMathFrac::UNIT, 1))); + cell->push_back(MathAtom(new InsetMathFrac(buf, InsetMathFrac::UNIT, 1))); parse(cell->back().nucleus()->cell(0), FLAG_ITEM, mode); } } @@ -1354,11 +1468,11 @@ 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()) { - cell->push_back(MathAtom(new InsetMathFrac(buffer_, InsetMathFrac::UNITFRAC, 3))); + if (!ar.empty()) { + cell->push_back(MathAtom(new InsetMathFrac(buf, InsetMathFrac::UNITFRAC, 3))); cell->back().nucleus()->cell(2) = ar; } else { - cell->push_back(MathAtom(new InsetMathFrac(buffer_, InsetMathFrac::UNITFRAC))); + cell->push_back(MathAtom(new InsetMathFrac(buf, InsetMathFrac::UNITFRAC))); } parse(cell->back().nucleus()->cell(0), FLAG_ITEM, mode); parse(cell->back().nucleus()->cell(1), FLAG_ITEM, mode); @@ -1367,13 +1481,13 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags, else if (t.cs() == "cfrac") { // allowed formats are \cfrac[pos]{num}{denom} docstring const arg = getArg('[', ']'); - //lyxerr << "got so far: '" << arg << "'" << endl; + //lyxerr << "got so far: '" << arg << "'" << endl; if (arg == "l") - cell->push_back(MathAtom(new InsetMathFrac(buffer_, InsetMathFrac::CFRACLEFT))); + cell->push_back(MathAtom(new InsetMathFrac(buf, InsetMathFrac::CFRACLEFT))); else if (arg == "r") - cell->push_back(MathAtom(new InsetMathFrac(buffer_, InsetMathFrac::CFRACRIGHT))); + cell->push_back(MathAtom(new InsetMathFrac(buf, InsetMathFrac::CFRACRIGHT))); else if (arg.empty() || arg == "c") - cell->push_back(MathAtom(new InsetMathFrac(buffer_, InsetMathFrac::CFRAC))); + cell->push_back(MathAtom(new InsetMathFrac(buf, InsetMathFrac::CFRAC))); else { error("found invalid optional argument"); break; @@ -1382,19 +1496,76 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags, parse(cell->back().nucleus()->cell(1), FLAG_ITEM, mode); } + else if (t.cs() == "sideset") { + // Here allowed formats are \sideset{_{bl}^{tl}}{_{br}^{tr}}{operator} + MathData ar[2]; + InsetMathScript * script[2] = {0, 0}; + for (int i = 0; i < 2; ++i) { + parse(ar[i], FLAG_ITEM, mode); + if (ar[i].size() == 1) + script[i] = ar[i][0].nucleus()->asScriptInset(); + } + bool const hasscript[2] = {script[0] ? true : false, script[1] ? true : false}; + cell->push_back(MathAtom(new InsetMathSideset(buf, hasscript[0], hasscript[1]))); + if (hasscript[0]) { + if (script[0]->hasDown()) + cell->back().nucleus()->cell(1) = script[0]->down(); + if (script[0]->hasUp()) + cell->back().nucleus()->cell(2) = script[0]->up(); + } else + cell->back().nucleus()->cell(1) = ar[0]; + if (hasscript[1]) { + if (script[1]->hasDown()) + cell->back().nucleus()->cell(2 + hasscript[0]) = script[1]->down(); + if (script[1]->hasUp()) + cell->back().nucleus()->cell(3 + hasscript[0]) = script[1]->up(); + } else + cell->back().nucleus()->cell(2 + hasscript[0]) = ar[1]; + parse(cell->back().nucleus()->cell(0), FLAG_ITEM, mode); + } + + else if (t.cs() == "stackrel") { + // Here allowed formats are \stackrel[subscript]{superscript}{operator} + MathData ar; + parse(ar, FLAG_OPTION, mode); + cell->push_back(MathAtom(new InsetMathStackrel(buf, !ar.empty()))); + if (!ar.empty()) + cell->back().nucleus()->cell(2) = ar; + parse(cell->back().nucleus()->cell(0), FLAG_ITEM, mode); + parse(cell->back().nucleus()->cell(1), FLAG_ITEM, mode); + } + else if (t.cs() == "xrightarrow" || t.cs() == "xleftarrow") { cell->push_back(createInsetMath(t.cs(), buf)); parse(cell->back().nucleus()->cell(1), FLAG_OPTION, mode); parse(cell->back().nucleus()->cell(0), FLAG_ITEM, mode); } - else if (t.cs() == "ref" || t.cs() == "eqref" || t.cs() == "prettyref" - || t.cs() == "pageref" || t.cs() == "vpageref" || t.cs() == "vref") { - cell->push_back(MathAtom(new InsetMathRef(buffer_, t.cs()))); + else if (t.cs() == "xhookrightarrow" || t.cs() == "xhookleftarrow" || + t.cs() == "xRightarrow" || t.cs() == "xLeftarrow" || + t.cs() == "xleftrightarrow" || t.cs() == "xLeftrightarrow" || + t.cs() == "xrightharpoondown" || t.cs() == "xrightharpoonup" || + t.cs() == "xleftharpoondown" || t.cs() == "xleftharpoonup" || + t.cs() == "xleftrightharpoons" || t.cs() == "xrightleftharpoons" || + t.cs() == "xmapsto") { + cell->push_back(createInsetMath(t.cs(), buf)); parse(cell->back().nucleus()->cell(1), FLAG_OPTION, mode); parse(cell->back().nucleus()->cell(0), FLAG_ITEM, mode); } + else if (t.cs() == "ref" || t.cs() == "eqref" || t.cs() == "prettyref" + || t.cs() == "pageref" || t.cs() == "vpageref" || t.cs() == "vref") { + cell->push_back(MathAtom(new InsetMathRef(buf, t.cs()))); + docstring const opt = parse_verbatim_option(); + docstring const ref = parse_verbatim_item(); + if (!opt.empty()) { + cell->back().nucleus()->cell(1).push_back( + MathAtom(new InsetMathString(opt))); + } + cell->back().nucleus()->cell(0).push_back( + MathAtom(new InsetMathString(ref))); + } + else if (t.cs() == "left") { skipSpaces(); Token const & tl = getToken(); @@ -1422,12 +1593,19 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags, else if (t.cs() == "begin") { docstring const name = getArg('{', '}'); + + if (name.empty()) { + success_ = false; + error("found invalid environment"); + return success_; + } + environments_.push_back(name); if (name == "array" || name == "subarray") { docstring const valign = parse_verbatim_option() + 'c'; docstring const halign = parse_verbatim_item(); - cell->push_back(MathAtom(new InsetMathArray(buffer_, name, + cell->push_back(MathAtom(new InsetMathArray(buf, name, InsetMathGrid::guessColumns(halign), 1, (char)valign[0], halign))); parse2(cell->back(), FLAG_END, mode, false); } @@ -1435,7 +1613,7 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags, else if (name == "tabular") { docstring const valign = parse_verbatim_option() + 'c'; docstring const halign = parse_verbatim_item(); - cell->push_back(MathAtom(new InsetMathTabular(buffer_, name, + cell->push_back(MathAtom(new InsetMathTabular(buf, name, InsetMathGrid::guessColumns(halign), 1, (char)valign[0], halign))); parse2(cell->back(), FLAG_END, InsetMath::TEXT_MODE, false); } @@ -1449,104 +1627,108 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags, docstring const valign = parse_verbatim_option() + 'c'; // ignore this for a while getArg('{', '}'); - cell->push_back(MathAtom(new InsetMathSplit(buffer_, name, (char)valign[0]))); + cell->push_back(MathAtom(new InsetMathSplit(buf, name, (char)valign[0]))); parse2(cell->back(), FLAG_END, mode, false); } else if (name == "math") { - if (mode == InsetMath::MATH_MODE) { - error("bad math environment"); - break; + if (mode == InsetMath::UNDECIDED_MODE) { + cell->push_back(MathAtom(new InsetMathHull(buf, hullSimple))); + parse2(cell->back(), FLAG_END, InsetMath::MATH_MODE, false); + } else { + // Don't create nested math hulls (bug #5392) + cell->push_back(MathAtom(new InsetMathEnsureMath(buf))); + parse(cell->back().nucleus()->cell(0), FLAG_END, InsetMath::MATH_MODE); } - cell->push_back(MathAtom(new InsetMathHull(buffer_, hullSimple))); - parse2(cell->back(), FLAG_END, InsetMath::MATH_MODE, true); } else if (name == "equation" || name == "equation*" || name == "displaymath") { if (mode != InsetMath::UNDECIDED_MODE) { - error("bad math environment"); + error("bad math environment " + name); break; } - cell->push_back(MathAtom(new InsetMathHull(buffer_, hullEquation))); + cell->push_back(MathAtom(new InsetMathHull(buf, hullEquation))); parse2(cell->back(), FLAG_END, InsetMath::MATH_MODE, (name == "equation")); } else if (name == "eqnarray" || name == "eqnarray*") { if (mode != InsetMath::UNDECIDED_MODE) { - error("bad math environment"); + error("bad math environment " + name); break; } - cell->push_back(MathAtom(new InsetMathHull(buffer_, hullEqnArray))); + cell->push_back(MathAtom(new InsetMathHull(buf, hullEqnArray))); parse2(cell->back(), FLAG_END, InsetMath::MATH_MODE, !stared(name)); } else if (name == "align" || name == "align*") { - if (mode != InsetMath::UNDECIDED_MODE) { - error("bad math environment"); - break; + if (mode == InsetMath::UNDECIDED_MODE) { + cell->push_back(MathAtom(new InsetMathHull(buf, hullAlign))); + parse2(cell->back(), FLAG_END, InsetMath::MATH_MODE, !stared(name)); + } else { + cell->push_back(MathAtom(new InsetMathSplit(buf, name, + 'c', !stared(name)))); + parse2(cell->back(), FLAG_END, mode, !stared(name)); } - cell->push_back(MathAtom(new InsetMathHull(buffer_, hullAlign))); - parse2(cell->back(), FLAG_END, InsetMath::MATH_MODE, !stared(name)); } else if (name == "flalign" || name == "flalign*") { if (mode != InsetMath::UNDECIDED_MODE) { - error("bad math environment"); + error("bad math environment " + name); break; } - cell->push_back(MathAtom(new InsetMathHull(buffer_, hullFlAlign))); + cell->push_back(MathAtom(new InsetMathHull(buf, hullFlAlign))); parse2(cell->back(), FLAG_END, InsetMath::MATH_MODE, !stared(name)); } else if (name == "alignat" || name == "alignat*") { if (mode != InsetMath::UNDECIDED_MODE) { - error("bad math environment"); + error("bad math environment " + name); break; } // ignore this for a while getArg('{', '}'); - cell->push_back(MathAtom(new InsetMathHull(buffer_, hullAlignAt))); + cell->push_back(MathAtom(new InsetMathHull(buf, hullAlignAt))); parse2(cell->back(), FLAG_END, InsetMath::MATH_MODE, !stared(name)); } else if (name == "xalignat" || name == "xalignat*") { if (mode != InsetMath::UNDECIDED_MODE) { - error("bad math environment"); + error("bad math environment " + name); break; } // ignore this for a while getArg('{', '}'); - cell->push_back(MathAtom(new InsetMathHull(buffer_, hullXAlignAt))); + cell->push_back(MathAtom(new InsetMathHull(buf, hullXAlignAt))); parse2(cell->back(), FLAG_END, InsetMath::MATH_MODE, !stared(name)); } else if (name == "xxalignat") { if (mode != InsetMath::UNDECIDED_MODE) { - error("bad math environment"); + error("bad math environment " + name); break; } // ignore this for a while getArg('{', '}'); - cell->push_back(MathAtom(new InsetMathHull(buffer_, hullXXAlignAt))); + cell->push_back(MathAtom(new InsetMathHull(buf, hullXXAlignAt))); parse2(cell->back(), FLAG_END, InsetMath::MATH_MODE, !stared(name)); } else if (name == "multline" || name == "multline*") { if (mode != InsetMath::UNDECIDED_MODE) { - error("bad math environment"); + error("bad math environment " + name); break; } - cell->push_back(MathAtom(new InsetMathHull(buffer_, hullMultline))); + cell->push_back(MathAtom(new InsetMathHull(buf, hullMultline))); parse2(cell->back(), FLAG_END, InsetMath::MATH_MODE, !stared(name)); } else if (name == "gather" || name == "gather*") { if (mode != InsetMath::UNDECIDED_MODE) { - error("bad math environment"); + error("bad math environment " + name); break; } - cell->push_back(MathAtom(new InsetMathHull(buffer_, hullGather))); + cell->push_back(MathAtom(new InsetMathHull(buf, hullGather))); parse2(cell->back(), FLAG_END, InsetMath::MATH_MODE, !stared(name)); } @@ -1557,7 +1739,7 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags, } else if (l->inset == "split") { docstring const valign = parse_verbatim_option() + 'c'; cell->push_back(MathAtom( - new InsetMathSplit(buffer_, name, (char)valign[0]))); + new InsetMathSplit(buf, name, (char)valign[0]))); parse2(cell->back(), FLAG_END, mode, false); } else { success_ = false; @@ -1566,11 +1748,11 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags, lyxerr << "found math environment `" << to_utf8(name) << "' in symbols file with unsupported inset `" - << to_utf8(l->inset) + << l->inset << "'." << endl; } // create generic environment inset - cell->push_back(MathAtom(new InsetMathEnv(buffer_, name))); + cell->push_back(MathAtom(new InsetMathEnv(buf, name))); parse(cell->back().nucleus()->cell(0), FLAG_END, mode); } } @@ -1583,7 +1765,7 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags, << to_utf8(name) << "'" << endl; } // create generic environment inset - cell->push_back(MathAtom(new InsetMathEnv(buffer_, name))); + cell->push_back(MathAtom(new InsetMathEnv(buf, name))); parse(cell->back().nucleus()->cell(0), FLAG_END, mode); } } @@ -1637,14 +1819,14 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags, else if (t.cs() == "color") { docstring const color = parse_verbatim_item(); - cell->push_back(MathAtom(new InsetMathColor(buffer_, true, color))); + cell->push_back(MathAtom(new InsetMathColor(buf, true, color))); parse(cell->back().nucleus()->cell(0), flags, mode); return success_; } else if (t.cs() == "textcolor") { docstring const color = parse_verbatim_item(); - cell->push_back(MathAtom(new InsetMathColor(buffer_, false, color))); + cell->push_back(MathAtom(new InsetMathColor(buf, false, color))); parse(cell->back().nucleus()->cell(0), FLAG_ITEM, InsetMath::TEXT_MODE); } @@ -1657,6 +1839,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") { @@ -1665,6 +1852,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") { @@ -1683,23 +1883,54 @@ 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. - cell->push_back(MathAtom(new MathMacro(buffer_, name))); + cell->push_back(MathAtom(new MathMacro(buf, name))); MathData ar; - mathed_parse_cell(ar, '{' + arg + '}', - Parse::NORMAL); + mathed_parse_cell(ar, '{' + arg + '}', mode_); cell->append(ar); } } + else if (t.cs() == "smash") { + skipSpaces(); + if (nextToken().asInput() == "[") { + // Since the phantom inset cannot handle optional arguments + // other than b and t, we must not create an InsetMathPhantom + // if opt is different from b and t (bug 8967). + docstring const opt = parse_verbatim_option(); + if (opt == "t" || opt == "b") { + cell->push_back(createInsetMath(t.cs() + opt, buf)); + parse(cell->back().nucleus()->cell(0), FLAG_ITEM, mode); + } else { + docstring const arg = parse_verbatim_item(); + cell->push_back(MathAtom(new MathMacro(buf, t.cs()))); + MathData ar; + mathed_parse_cell(ar, '[' + opt + ']', mode_); + cell->append(ar); + ar = MathData(); + mathed_parse_cell(ar, '{' + arg + '}', mode_); + cell->append(ar); + } + } + else { + cell->push_back(createInsetMath(t.cs(), buf)); + parse(cell->back().nucleus()->cell(0), FLAG_ITEM, mode); + } + } + #if 0 else if (t.cs() == "infer") { MathData ar; @@ -1747,24 +1978,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()) { - bool const is_user_macro = - buffer_ && buffer_->getMacro(t.cs(), false); + else if (!t.cs().empty()) { + bool const no_mhchem = + (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)); + latexkeys const * l = in_word_set(t.cs()); if (l && !is_user_macro) { if (l->inset == "big") { @@ -1833,8 +2075,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 += '{'; @@ -1842,9 +2086,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 { @@ -1854,7 +2115,7 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags, } if (!is_unicode_symbol) { MathAtom at = is_user_macro ? - MathAtom(new MathMacro(buffer_, t.cs())) + MathAtom(new MathMacro(buf, t.cs())) : createInsetMath(t.cs(), buf); InsetMath::mode_type m = mode; //if (m == InsetMath::UNDECIDED_MODE) @@ -1866,13 +2127,14 @@ 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; //} for (InsetMath::idx_type i = start; i < at->nargs(); ++i) { parse(at.nucleus()->cell(i), FLAG_ITEM, m); - skipSpaces(); + if (mode == InsetMath::MATH_MODE) + skipSpaces(); } cell->push_back(at); } @@ -1893,6 +2155,15 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags, } // anonymous namespace +// FIXME This will likely need some work. +char const * latexkeys::MathMLtype() const +{ + if (extra == "mathord") + return "mi"; + return "mo"; +} + + bool mathed_parse_cell(MathData & ar, docstring const & str, Parse::flags f) { return Parser(str, f, ar.buffer()).parse(ar, 0, f & Parse::TEXTMODE ?