de.po

[lyx.git] / src / mathed / MathParser.cpp

diff --git a/src/mathed/MathParser.cpp b/src/mathed/MathParser.cpp
index ace167c439608455f732a80db037f7084ec610cc..2452b6bb45abc7c9619e3136efb817fb5bc4e7e3 100644 (file)
--- a/src/mathed/MathParser.cpp
+++ b/src/mathed/MathParser.cpp
@@ -51,7 +51,7 @@ following hack as starting point to write some macros:
 #include "InsetMathEnv.h"
 #include "InsetMathFrac.h"
 #include "InsetMathKern.h"
-#include "MathMacro.h"
+#include "InsetMathMacro.h"
 #include "InsetMathPar.h"
 #include "InsetMathRef.h"
 #include "InsetMathRoot.h"
@@ -63,10 +63,10 @@ following hack as starting point to write some macros:
 #include "InsetMathStackrel.h"
 #include "InsetMathString.h"
 #include "InsetMathTabular.h"
-#include "MathMacroTemplate.h"
+#include "InsetMathMacroTemplate.h"
 #include "MathExtern.h"
 #include "MathFactory.h"
-#include "MathMacroArgument.h"
+#include "InsetMathMacroArgument.h"
 #include "MathSupport.h"
 
 #include "Buffer.h"
@@ -745,7 +745,7 @@ docstring Parser::parse_verbatim_option()
        docstring res;
        if (nextToken().character() == '[') {
                Token t = getToken();
-               for (Token t = getToken(); t.character() != ']' && good(); t = getToken()) {
+               for (t = getToken(); t.character() != ']' && good(); t = getToken()) {
                        if (t.cat() == catBegin) {
                                putback();
                                res += '{' + parse_verbatim_item() + '}';
@@ -763,7 +763,7 @@ docstring Parser::parse_verbatim_item()
        docstring res;
        if (nextToken().cat() == catBegin) {
                Token t = getToken();
-               for (Token t = getToken(); t.cat() != catEnd && good(); t = getToken()) {
+               for (t = getToken(); t.cat() != catEnd && good(); t = getToken()) {
                        if (t.cat() == catBegin) {
                                putback();
                                res += '{' + parse_verbatim_item() + '}';
@@ -932,7 +932,7 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags,
                        Token const & n = nextToken();
                        char_type c = n.character();
                        if (c && '0' < c && c <= '9') {
-                               cell->push_back(MathAtom(new MathMacroArgument(c - '0')));
+                               cell->push_back(MathAtom(new InsetMathMacroArgument(c - '0')));
                                getToken();
                        } else
                                cell->push_back(MathAtom(new InsetMathHash()));
@@ -1037,10 +1037,10 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags,
                else if (t.cat() == catComment) {
                        docstring s;
                        while (good()) {
-                               Token const & t = getToken();
-                               if (t.cat() == catNewline)
+                               Token const & tt = getToken();
+                               if (tt.cat() == catNewline)
                                        break;
-                               s += t.asInput();
+                               s += tt.asInput();
                        }
                        cell->push_back(MathAtom(new InsetMathComment(buf, s)));
                        skipSpaces();
@@ -1082,7 +1082,7 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags,
                        if (nextToken().cat() == catBegin)
                                parse(display, FLAG_ITEM, InsetMath::MATH_MODE);
 
-                       cell->push_back(MathAtom(new MathMacroTemplate(buf,
+                       cell->push_back(MathAtom(new InsetMathMacroTemplate(buf,
                                name, nargs, 0, MacroTypeDef,
                                vector<MathData>(), def, display)));
 
@@ -1130,7 +1130,7 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags,
                        if (nextToken().cat() == catBegin)
                                parse(display, FLAG_ITEM, InsetMath::MATH_MODE);
 
-                       cell->push_back(MathAtom(new MathMacroTemplate(buf,
+                       cell->push_back(MathAtom(new InsetMathMacroTemplate(buf,
                                name, nargs, optionals, MacroTypeNewcommand,
                                optionalValues, def, display)));
 
@@ -1251,7 +1251,7 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags,
                        if (nextToken().cat() == catBegin)
                                parse(display, FLAG_ITEM, InsetMath::MATH_MODE);
 
-                       cell->push_back(MathAtom(new MathMacroTemplate(buf,
+                       cell->push_back(MathAtom(new InsetMathMacroTemplate(buf,
                                name, nargs, optionals, MacroTypeNewcommandx,
                                optionalValues, def, display)));
 
@@ -1375,7 +1375,7 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags,
                        parse(count, FLAG_ITEM, mode);
                        int cols;
                        // limit arbitrarily to 100 columns
-                       if (extractNumber(count, cols) && cols < 100) {
+                       if (extractNumber(count, cols) && cols > 0 && cols < 100) {
                                // resize the table if necessary
                                size_t first = grid.index(cellrow, cellcol);
                                for (int i = 1; i < cols; ++i) {
@@ -1399,7 +1399,7 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags,
                                // parse the remaining contents into the "real" cell
                                parse(*cell, FLAG_ITEM, mode);
                        } else {
-                               MathAtom at = MathAtom(new MathMacro(buf, t.cs()));
+                               MathAtom at = MathAtom(new InsetMathMacro(buf, t.cs()));
                                cell->push_back(at);
                                cell->push_back(MathAtom(new InsetMathBrace(count)));
                        }
@@ -1432,12 +1432,10 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags,
                        parse(ar, FLAG_OPTION, mode);
                        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->back().nucleus()->cell(1) = ar;
+                       } else
                                cell->push_back(MathAtom(new InsetMathSqrt(buf)));
-                               parse(cell->back().nucleus()->cell(0), FLAG_ITEM, mode);
-                       }
+                       parse(cell->back().nucleus()->cell(0), FLAG_ITEM, mode);
                }
 
                else if (t.cs() == "cancelto") {
@@ -1529,8 +1527,8 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags,
                        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);
+                       parse(cell->back().nucleus()->cell(0), FLAG_ITEM, mode);
                }
 
                else if (t.cs() == "xrightarrow" || t.cs() == "xleftarrow") {
@@ -1552,7 +1550,8 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags,
                }
 
                else if (t.cs() == "ref" || t.cs() == "eqref" || t.cs() == "prettyref"
-                         || t.cs() == "pageref" || t.cs() == "vpageref" || t.cs() == "vref") {
+                         || t.cs() == "nameref" || 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();
@@ -1757,7 +1756,8 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags,
 
                        else {
                                success_ = false;
-                               if (!(mode_ & Parse::QUIET)) {
+                               if (!(mode_ & Parse::QUIET) &&
+                                   !(mode_ & Parse::TRACKMACRO)) {
                                        dump();
                                        lyxerr << "found unknown math environment '"
                                               << to_utf8(name) << "'" << endl;
@@ -1773,7 +1773,7 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags,
                        docstring s;
                        int num_tokens = 0;
                        while (true) {
-                               Token const & t = getToken();
+                               Token const & tt = getToken();
                                ++num_tokens;
                                if (!good()) {
                                        s.clear();
@@ -1781,12 +1781,12 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags,
                                                putback();
                                        break;
                                }
-                               s += t.character();
+                               s += tt.character();
                                if (isValidLength(to_utf8(s)))
                                        break;
                        }
                        if (s.empty())
-                               cell->push_back(MathAtom(new MathMacro(buf, t.cs())));
+                               cell->push_back(MathAtom(new InsetMathMacro(buf, t.cs())));
                        else
                                cell->push_back(MathAtom(new InsetMathKern(s)));
                }
@@ -1798,6 +1798,7 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags,
                        asArray(label, ar);
                        if (grid.asHullInset()) {
                                grid.asHullInset()->label(cellrow, label);
+                               grid.asHullInset()->numbered(cellrow, true);
                        } else {
                                cell->push_back(createInsetMath(t.cs(), buf));
                                cell->push_back(MathAtom(new InsetMathBrace(ar)));
@@ -1895,7 +1896,7 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags,
                        else {
                                // Since the Length class cannot use length variables
                                // we must not create an InsetMathSpace.
-                               cell->push_back(MathAtom(new MathMacro(buf, name)));
+                               cell->push_back(MathAtom(new InsetMathMacro(buf, name)));
                                MathData ar;
                                mathed_parse_cell(ar, '{' + arg + '}', mode_);
                                cell->append(ar);
@@ -1914,7 +1915,7 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags,
                                        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())));
+                                       cell->push_back(MathAtom(new InsetMathMacro(buf, t.cs())));
                                        MathData ar;
                                        mathed_parse_cell(ar, '[' + opt + ']', mode_);
                                        cell->append(ar);
@@ -1998,7 +1999,10 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags,
                                                        new InsetMathBig(t.cs(), delim)));
                                        else {
                                                cell->push_back(createInsetMath(t.cs(), buf));
-                                               putback();
+                                               // For some reason delim.empty()
+                                               // is always false here
+                                               if (delim.at(0))
+                                                       putback();
                                        }
                                }
 
@@ -2028,6 +2032,12 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags,
                                        putback();
                                }
 
+                               else if (l->inset == "underset" || l->inset == "overset") {
+                                       cell->push_back(createInsetMath(t.cs(), buf));
+                                       parse(cell->back().nucleus()->cell(1), FLAG_ITEM, mode);
+                                       parse(cell->back().nucleus()->cell(0), FLAG_ITEM, mode);
+                               }
+
                                else {
                                        MathAtom at = createInsetMath(t.cs(), buf);
                                        for (InsetMath::idx_type i = 0; i < at->nargs(); ++i)
@@ -2096,7 +2106,7 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags,
                                }
                                if (!is_unicode_symbol) {
                                        MathAtom at = is_user_macro ?
-                                               MathAtom(new MathMacro(buf, t.cs()))
+                                               MathAtom(new InsetMathMacro(buf, t.cs()))
                                                : createInsetMath(t.cs(), buf);
                                        InsetMath::mode_type m = mode;
                                        //if (m == InsetMath::UNDECIDED_MODE)