fix typo that put too many include paths for most people

[lyx.git] / src / mathed / math_parser.C

diff --git a/src/mathed/math_parser.C b/src/mathed/math_parser.C
index f7cead75b04300daa66d275ded8b3011c5e7d659..70e827a319868badc88672d0ae707cf61bb2e4d1 100644 (file)
--- a/src/mathed/math_parser.C
+++ b/src/mathed/math_parser.C
@@ -426,17 +426,17 @@ char Parser::getChar()
 }
 
 
-string Parser::getArg(char lf, char rg)
+string Parser::getArg(char left, char right)
 {
        skipSpaces();
 
        string result;
        char c = getChar();
 
-       if (c != lf)
+       if (c != left)
                putback();
        else
-               while ((c = getChar()) != rg && good())
+               while ((c = getChar()) != right && good())
                        result += c;
 
        return result;
@@ -552,8 +552,11 @@ void Parser::tokenize(string const & buffer)
 void Parser::dump() const
 {
        lyxerr << "\nTokens: ";
-       for (unsigned i = 0; i < tokens_.size(); ++i)
+       for (unsigned i = 0; i < tokens_.size(); ++i) {
+               if (i == pos_)
+                       lyxerr << " <#> ";
                lyxerr << tokens_[i];
+       }
        lyxerr << "\n";
 }
 
@@ -727,48 +730,82 @@ bool Parser::parse_lines2(MathAtom & t, bool braced)
 
 
 
+
 bool Parser::parse_macro(string & name)
 {
+       int nargs = 0;
        name = "{error}";
        skipSpaces();
 
-       if (getToken().cs() != "newcommand") {
-               lyxerr << "\\newcommand expected\n";
-               return false;
-       }
+       if (nextToken().cs() == "def") {
 
-       if (getToken().cat() != catBegin) {
-               lyxerr << "'{' in \\newcommand expected (1)\n";
-               return false;
-       }
+               getToken();
+               name = getToken().cs();
+
+               string pars;
+               while (good() && nextToken().cat() != catBegin)
+                       pars += getToken().cs();
+       
+               if (!good()) {
+                       lyxerr << "bad stream in parse_macro\n";
+                       dump();
+                       return false;
+               }
+                       
+               //lyxerr << "read \\def parameter list '" << pars << "'\n";
+               if (!pars.empty()) {
+                       lyxerr << "can't handle non-empty parameter lists\n";
+                       dump();
+                       return false;
+               }
 
-       name = getToken().cs();
+       } else if (nextToken().cs() == "newcommand") {
 
-       if (getToken().cat() != catEnd) {
-               lyxerr << "'}' expected\n";
+               getToken();
+
+               if (getToken().cat() != catBegin) {
+                       lyxerr << "'{' in \\newcommand expected (1) \n";
+                       dump();
+                       return false;
+               }
+
+               name = getToken().cs();
+
+               if (getToken().cat() != catEnd) {
+                       lyxerr << "'}' expected\n";
+                       return false;
+               }
+
+               string arg  = getArg('[', ']');
+               if (!arg.empty())
+                       nargs = atoi(arg.c_str());
+
+       } else { 
+               lyxerr << "\\newcommand or \\def  expected\n";
                return false;
        }
 
-       string    arg  = getArg('[', ']');
-       int       narg = arg.empty() ? 0 : atoi(arg.c_str());
 
        if (getToken().cat() != catBegin) {
-               lyxerr << "'{' in \\newcommand expected (2)\n";
+               lyxerr << "'{' in macro definition expected (2)\n";
                return false;
        }
 
-       MathArray ar;
-       parse_into(ar, FLAG_BRACE_LAST);
+       MathArray ar1;
+       parse_into(ar1, FLAG_BRACE_LAST);
 
        // we cannot handle recursive stuff at all
        MathArray test;
        test.push_back(createMathInset(name));
-       if (ar.contains(test)) {
+       if (ar1.contains(test)) {
                lyxerr << "we cannot handle recursive macros at all.\n";
                return false;
        }
 
-       MathMacroTable::create(name, narg, ar);
+       MathArray ar2;
+       parse_into(ar2, FLAG_ITEM);
+
+       MathMacroTable::create(name, nargs, ar1, ar2);
        return true;
 }
 
@@ -991,6 +1028,7 @@ void Parser::parse_into1(MathArray & array, unsigned flags, MathTextCodes code)
                else if (t.cat() == catEnd) {
                        if (flags & FLAG_BRACE_LAST)
                                return;
+                       dump();
                        lyxerr << "found '}' unexpectedly, array: '" << array << "'\n";
                        //lyxerr << "found '}' unexpectedly\n";
                        lyx::Assert(0);
@@ -1127,6 +1165,14 @@ void Parser::parse_into1(MathArray & array, unsigned flags, MathTextCodes code)
                        array.push_back(MathAtom(new MathKernInset(s)));
                }
 
+/*
+               else if (t.cs() == "lyxkern") {
+                       MathAtom p = createMathInset(t.cs());
+                       parse_into(p->cell(0), flags, code);
+                       array.push_back(p);
+               }
+*/
+
                else if (t.cs() == "label") {
                        curr_label_ = getArg('{', '}');
                }