fix #1073

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

diff --git a/src/mathed/math_parser.C b/src/mathed/math_parser.C
index fb00252908f933449fd83d77c58921ddf1a31bd0..57d04f882ec19621f9023277c359b605ae4dc595 100644 (file)
--- a/src/mathed/math_parser.C
+++ b/src/mathed/math_parser.C
@@ -22,9 +22,9 @@ following hack as starting point to write some macros:
   ...
 
   \[\begin{array}{ccc}
-   1 & 2\b & 3^2\\
-   4 & 5\e & 6\\
-   7 & 8 & 9
+1
+&
+
   \end{array}\]
 
 */
@@ -32,9 +32,6 @@ following hack as starting point to write some macros:
 
 #include <config.h>
 
-#ifdef __GNUG__
-#pragma implementation
-#endif
 
 #include "math_parser.h"
 #include "math_inset.h"
@@ -59,6 +56,7 @@ following hack as starting point to write some macros:
 #include "math_sqrtinset.h"
 #include "math_stringinset.h"
 #include "math_support.h"
+#include "math_tabularinset.h"
 #include "math_xyarrowinset.h"
 
 //#include "insets/insetref.h"
@@ -88,6 +86,7 @@ namespace {
 
 MathInset::mode_type asMode(MathInset::mode_type oldmode, string const & str)
 {
+       lyxerr << "handling mode: '" << str << "'\n";
        if (str == "mathmode")
                return MathInset::MATH_MODE;
        if (str == "textmode" || str == "forcetext")
@@ -208,6 +207,8 @@ ostream & operator<<(ostream & os, Token const & t)
 {
        if (t.cs().size())
                os << '\\' << t.cs();
+       else if (t.cat() == catLetter)
+               os << t.character();
        else
                os << '[' << t.character() << ',' << t.cat() << ']';
        return os;
@@ -531,6 +532,7 @@ bool Parser::parse(MathAtom & at)
 
 string Parser::parse_verbatim_option()
 {
+       skipSpaces();
        string res;
        if (nextToken().character() == '[') {
                Token t = getToken();
@@ -548,6 +550,7 @@ string Parser::parse_verbatim_option()
 
 string Parser::parse_verbatim_item()
 {
+       skipSpaces();
        string res;
        if (nextToken().cat() == catBegin) {
                Token t = getToken();
@@ -580,15 +583,15 @@ void Parser::parse(MathArray & array, unsigned flags, mode_type mode)
 }
 
 
-void Parser::parse2(MathAtom & at, unsigned flags, mode_type mode,
-       bool numbered)
+void Parser::parse2(MathAtom & at, const unsigned flags, const mode_type mode,
+       const bool numbered)
 {
        parse1(*(at.nucleus()->asGridInset()), flags, mode, numbered);
 }
 
 
 void Parser::parse1(MathGridInset & grid, unsigned flags,
-       mode_type mode, bool numbered)
+       const mode_type mode, const bool numbered)
 {
        int limits = 0;
        MathGridInset::row_type cellrow = 0;
@@ -599,6 +602,8 @@ void Parser::parse1(MathGridInset & grid, unsigned flags,
                grid.asHullInset()->numbered(cellrow, numbered);
 
        //dump();
+       //lyxerr << " flags: " << flags << "\n";
+       //lyxerr << " mode: " << mode  << "\n";
        //lyxerr << "grid: " << grid << endl;
 
        while (good()) {
@@ -606,24 +611,22 @@ void Parser::parse1(MathGridInset & grid, unsigned flags,
 
 #ifdef FILEDEBUG
                lyxerr << "t: " << t << " flags: " << flags << "\n";
+               lyxerr << "mode: " << mode  << "\n";
                cell->dump();
                lyxerr << "\n";
 #endif
 
                if (flags & FLAG_ITEM) {
-                       if (t.cat() == catSpace)
-                               continue;
 
-                       flags &= ~FLAG_ITEM;
-                       if (t.cat() == catBegin) {
+               if (t.cat() == catBegin) {
                                // skip the brace and collect everything to the next matching
                                // closing brace
-                               flags |= FLAG_BRACE_LAST;
-                               continue;
+                               parse1(grid, FLAG_BRACE_LAST, mode, numbered);
+                               return;
                        }
 
                        // handle only this single token, leave the loop if done
-                       flags |= FLAG_LEAVE;
+                       flags = FLAG_LEAVE;
                }
 
 
@@ -693,8 +696,10 @@ void Parser::parse1(MathGridInset & grid, unsigned flags,
                                cell->push_back(MathAtom(new MathCharInset(t.character())));
                }
 
-               else if (t.cat() == catNewline && mode != MathInset::MATH_MODE)
-                       cell->push_back(MathAtom(new MathCharInset(t.character())));
+               else if (t.cat() == catNewline && mode != MathInset::MATH_MODE) {
+                       if (cell->empty() || cell->back()->getChar() != ' ')
+                               cell->push_back(MathAtom(new MathCharInset(' ')));
+               }
 
                else if (t.cat() == catParameter) {
                        Token const & n = getToken();
@@ -749,9 +754,10 @@ void Parser::parse1(MathGridInset & grid, unsigned flags,
                        MathScriptInset * p = cell->back().nucleus()->asScriptInset();
                        // special handling of {}-bases
                        // is this always correct?
-                       if (p->nuc().size() == 1 && p->nuc().back()->asNestInset() &&
-                                       p->nuc().back()->extraBraces())
-                               p->nuc() = p->nuc().back()->asNestInset()->cell(0);
+                       // It appears that this is wrong (Dekel)
+                       //if (p->nuc().size() == 1 && p->nuc().back()->asNestInset() &&
+                       //    p->nuc().back()->extraBraces())
+                       //      p->nuc() = p->nuc().back()->asNestInset()->cell(0);
                        parse(p->cell(up), FLAG_ITEM, mode);
                        if (limits) {
                                p->limits(limits);
@@ -838,9 +844,8 @@ void Parser::parse1(MathGridInset & grid, unsigned flags,
                        // is a version for display attached?
                        skipSpaces();
                        MathArray ar2;
-                       if (nextToken().cat() == catBegin) {
+                       if (nextToken().cat() == catBegin)
                                parse(ar2, FLAG_ITEM, MathInset::MATH_MODE);
-                       }
 
                        cell->push_back(MathAtom(new MathMacroTemplate(name, nargs, ar1, ar2)));
                }
@@ -965,16 +970,19 @@ void Parser::parse1(MathGridInset & grid, unsigned flags,
                        parse(cell->back().nucleus()->cell(0), FLAG_ITEM, mode);
                }
 
-               else if (t.cs() == "ref") {
-                       cell->push_back(MathAtom(new RefInset));
+               else if (t.cs() == "ref" || t.cs() == "prettyref" ||
+                               t.cs() == "pageref" || t.cs() == "vpageref" || t.cs() == "vref") {
+                       cell->push_back(MathAtom(new RefInset(t.cs())));
                        parse(cell->back().nucleus()->cell(1), FLAG_OPTION, mode);
                        parse(cell->back().nucleus()->cell(0), FLAG_ITEM, mode);
                }
 
                else if (t.cs() == "left") {
+                       skipSpaces();
                        string l = getToken().asString();
                        MathArray ar;
                        parse(ar, FLAG_RIGHT, mode);
+                       skipSpaces();
                        string r = getToken().asString();
                        cell->push_back(MathAtom(new MathDelimInset(l, r, ar)));
                }
@@ -997,6 +1005,13 @@ void Parser::parse1(MathGridInset & grid, unsigned flags,
                                parse2(cell->back(), FLAG_END, mode, false);
                        }
 
+                       else if (name == "tabular") {
+                               string const valign = parse_verbatim_option() + 'c';
+                               string const halign = parse_verbatim_item();
+                               cell->push_back(MathAtom(new MathTabularInset(name, valign[0], halign)));
+                               parse2(cell->back(), FLAG_END, MathInset::TEXT_MODE, false);
+                       }
+
                        else if (name == "split" || name == "cases" ||
                                         name == "gathered" || name == "aligned") {
                                cell->push_back(createMathInset(name));
@@ -1068,10 +1083,11 @@ void Parser::parse1(MathGridInset & grid, unsigned flags,
                        }
 
                        else {
-                               // lyxerr << "unknow math inset begin '" << name << "'\n";
+                               dump();
+                               lyxerr << "found unknown math environment '" << name << "'\n";
                                // create generic environment inset
                                cell->push_back(MathAtom(new MathEnvInset(name)));
-                               parse(cell->back().nucleus()->cell(0), FLAG_END, mode);
+                               parse(cell->back().nucleus()->cell(0), FLAG_ITEM, mode);
                        }
                }
 
@@ -1124,8 +1140,9 @@ void Parser::parse1(MathGridInset & grid, unsigned flags,
 
                else if (t.cs() == "framebox") {
                        cell->push_back(createMathInset(t.cs()));
-                       parse(cell->back().nucleus()->cell(0), FLAG_OPTION, mode);
-                       parse(cell->back().nucleus()->cell(1), FLAG_ITEM, mode);
+                       parse(cell->back().nucleus()->cell(0), FLAG_OPTION, MathInset::TEXT_MODE);
+                       parse(cell->back().nucleus()->cell(1), FLAG_OPTION, MathInset::TEXT_MODE);
+                       parse(cell->back().nucleus()->cell(2), FLAG_ITEM, MathInset::TEXT_MODE);
                }
 
 #if 0
@@ -1195,8 +1212,11 @@ void Parser::parse1(MathGridInset & grid, unsigned flags,
                        else {
                                MathAtom at = createMathInset(t.cs());
                                MathInset::mode_type m = mode;
-                               if (m == MathInset::UNDECIDED_MODE)
+                               //if (m == MathInset::UNDECIDED_MODE)
+                               lyxerr << "default creation: m1: " << m << "\n";
+                               if (at->currentMode() != MathInset::UNDECIDED_MODE)
                                        m = at->currentMode();
+                               lyxerr << "default creation: m2: " << m << "\n";
                                MathInset::idx_type start = 0;
                                // this fails on \bigg[...\bigg]
                                //MathArray opt;