make \newcommand{\bb}[1]{\mathbf{#1}} work for read/write/display.

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

diff --git a/src/mathed/math_parser.C b/src/mathed/math_parser.C
index fe3244226cfd53b7c39498439965a5cab11cd0cb..98940b4537ccd53da89cda5bb27680a899370b0e 100644 (file)
--- a/src/mathed/math_parser.C
+++ b/src/mathed/math_parser.C
@@ -45,9 +45,6 @@ point to write some macros:
 
 #include <config.h>
 
-#include <cctype>
-#include <stack>
-
 #ifdef __GNUG__
 #pragma implementation
 #endif
@@ -67,28 +64,36 @@ point to write some macros:
 #include "math_macrotemplate.h"
 #include "math_hullinset.h"
 #include "math_rootinset.h"
+#include "math_sizeinset.h"
 #include "math_sqrtinset.h"
 #include "math_scriptinset.h"
 #include "math_specialcharinset.h"
 #include "math_splitinset.h"
 #include "math_sqrtinset.h"
 #include "math_support.h"
+
 #include "lyxlex.h"
 #include "debug.h"
+
 #include "support/lstrings.h"
 
+#include <cctype>
+#include <stack>
+#include <algorithm>
+
 using std::istream;
 using std::ostream;
 using std::ios;
 using std::endl;
 using std::stack;
+using std::fill;
 
 
 namespace {
 
 bool stared(string const & s)
 {
-       unsigned n = s.size();
+       string::size_type const n = s.size();
        return n && s[n - 1] == '*';
 }
 
@@ -133,6 +138,7 @@ enum {
        FLAG_RIGHT      = 1 << 2,  //  next \\right ends the parsing process
        FLAG_END        = 1 << 3,  //  next \\end ends the parsing process
        FLAG_BRACK_END  = 1 << 4,  //  next closing bracket ends the parsing process
+       FLAG_BOX        = 1 << 5,  //  we are in a box
        FLAG_ITEM       = 1 << 7,  //  read a (possibly braced token)
        FLAG_BLOCK      = 1 << 8,  //  next block ends the parsing process
        FLAG_LEAVE      = 1 << 9   //  leave the loop at the end
@@ -141,12 +147,9 @@ enum {
 
 void catInit()
 {
-       for (int i = 0; i <= 255; ++i) 
-               theCatcode[i] = catOther;
-       for (int i = 'a'; i <= 'z'; ++i) 
-               theCatcode[i] = catLetter;
-       for (int i = 'A'; i <= 'Z'; ++i) 
-               theCatcode[i] = catLetter;
+       fill(theCatcode, theCatcode + 256, catOther);
+       fill(theCatcode + 'a', theCatcode + 'z' + 1, catLetter);
+       fill(theCatcode + 'A', theCatcode + 'Z' + 1, catLetter);
 
        theCatcode['\\'] = catEscape;   
        theCatcode['{']  = catBegin;    
@@ -178,7 +181,7 @@ public:
        ///
        Token(char c, CatCode cat) : cs_(), char_(c), cat_(cat) {}
        ///
-       Token(const string & cs) : cs_(cs), char_(0), cat_(catIgnore) {}
+       Token(string const & cs) : cs_(cs), char_(0), cat_(catIgnore) {}
 
        ///
        string const & cs() const { return cs_; }
@@ -216,10 +219,11 @@ bool operator==(Token const & s, Token const & t)
                && s.cat() == t.cat() && s.cs() == t.cs(); 
 }
 
-bool operator!=(Token const & s, Token const & t)
-{
-       return !(s == t);
-}
+// Angus' compiler says this is not needed
+//bool operator!=(Token const & s, Token const & t)
+//{
+//     return !(s == t);
+//}
 
 ostream & operator<<(ostream & os, Token const & t)
 {
@@ -500,7 +504,7 @@ bool Parser::parse_lines(MathAtom & t, bool numbered, bool outmost)
                return false;
        }
 
-       const int cols = p->ncols();
+       MathInset::col_type const cols = p->ncols();
 
        // save global variables
        bool   const saved_num   = curr_num_;
@@ -515,7 +519,7 @@ bool Parser::parse_lines(MathAtom & t, bool numbered, bool outmost)
                curr_label_.erase();
 
                // reading a row
-               for (int col = 0; col < cols; ++col) {
+               for (MathInset::col_type col = 0; col < cols; ++col) {
                        //lyxerr << "reading cell " << row << " " << col << "\n";
                        parse_into(p->cell(col + row * cols), FLAG_BLOCK);
 
@@ -669,6 +673,12 @@ bool Parser::parse_normal(MathAtom & matrix)
 
        string const name = getArg('{', '}');
 
+       if (name == "math") {
+               matrix = MathAtom(new MathHullInset(LM_OT_SIMPLE));
+               parse_into(matrix->cell(0), 0);
+               return true;
+       }
+
        if (name == "equation" || name == "equation*" || name == "displaymath") {
                curr_num_ = (name == "equation");
                curr_label_.erase();
@@ -759,8 +769,16 @@ void Parser::parse_into(MathArray & array, unsigned flags, MathTextCodes code)
                //
                // cat codes
                //
-               if (t.cat() == catMath)
-                       break;
+               if (t.cat() == catMath) {
+                       if (flags & FLAG_BOX) {
+                               // we are inside an mbox, so opening new math is allowed
+                               array.push_back(MathAtom(new MathHullInset(LM_OT_SIMPLE)));
+                               parse_into(array.back()->cell(0), 0);
+                       } else {
+                               // otherwise this is the end of the formula
+                               break;
+                       }
+               }
 
                else if (t.cat() == catLetter)
                        add(array, t.character(), code);
@@ -770,7 +788,7 @@ void Parser::parse_into(MathArray & array, unsigned flags, MathTextCodes code)
 
                else if (t.cat() == catParameter) {
                        Token const & n = getToken();
-                       array.push_back(MathAtom(new MathMacroArgument(n.character() - '0')));
+                       array.push_back(MathAtom(new MathMacroArgument(n.character()-'0', code)));
                }
 
                else if (t.cat() == catBegin) {
@@ -889,19 +907,6 @@ void Parser::parse_into(MathArray & array, unsigned flags, MathTextCodes code)
                        return;
                }
 
-/*             
-               case LM_TK_STY:
-               {
-                       lyxerr[Debug::MATHED] << "LM_TK_STY not implemented\n";
-                       //MathArray tmp = array;
-                       //MathSizeInset * p = new MathSizeInset(MathStyles(lval_->id));
-                       //array.push_back(p);
-                       //parse_into(p->cell(0), FLAG_BRACE_FONT);
-                       break; 
-               }
-
-*/
-               
                else if (t.cs() == "begin") {
                        string const name = getArg('{', '}');   
                        if (name == "array") {
@@ -949,8 +954,8 @@ void Parser::parse_into(MathArray & array, unsigned flags, MathTextCodes code)
                        return;
                }
 
-/*
                // Disabled
+#if 0
                else if (t.cs() == "mbox") {
                        array.push_back(createMathInset(t.cs()));
                        // slurp in the argument of mbox
@@ -958,7 +963,8 @@ void Parser::parse_into(MathArray & array, unsigned flags, MathTextCodes code)
                        MathBoxInset * p = array.back()->asBoxInset();
                        //lyx::assert(p);
                }
-*/
+#endif
+
        
                else if (t.cs().size()) {
                        latexkeys const * l = in_word_set(t.cs());
@@ -984,6 +990,19 @@ void Parser::parse_into(MathArray & array, unsigned flags, MathTextCodes code)
                                        code = static_cast<MathTextCodes>(l->id);
                                }
 
+                               else if (l->token == LM_TK_BOX) {
+                                       MathAtom p = createMathInset(t.cs());
+                                       parse_into(p->cell(0), FLAG_ITEM | FLAG_BOX, LM_TC_BOX);
+                                       array.push_back(p);
+                               }
+
+                               else if (l->token == LM_TK_STY) {
+                                       MathAtom p = createMathInset(t.cs());
+                                       parse_into(p->cell(0), flags, code);
+                                       array.push_back(p);
+                                       return;
+                               }
+
                                else {
                                        MathAtom p = createMathInset(t.cs());
                                        for (MathInset::idx_type i = 0; i < p->nargs(); ++i)