X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fmathed%2Fmath_parser.C;h=d0d480743b0befe95c551f9f6f58b6fbf92b3650;hb=74124b4bf85af8e902b2ed844ab8b6349073e814;hp=918f4c81d2c37044271de5c8ed4e0889a6d070ac;hpb=2e4ad730241fb288dbc3020cdc4bb6d830fc51d4;p=lyx.git diff --git a/src/mathed/math_parser.C b/src/mathed/math_parser.C index 918f4c81d2..d0d480743b 100644 --- a/src/mathed/math_parser.C +++ b/src/mathed/math_parser.C @@ -15,8 +15,6 @@ * the GNU General Public Licence version 2 or later. */ -// {[( - #include #include @@ -29,38 +27,75 @@ #include "array.h" #include "math_inset.h" #include "math_arrayinset.h" -#include "math_symbolinset.h" +#include "math_bigopinset.h" +#include "math_charinset.h" #include "math_dotsinset.h" #include "math_decorationinset.h" #include "math_deliminset.h" #include "math_fracinset.h" #include "math_funcinset.h" +#include "math_funcliminset.h" #include "math_macro.h" #include "math_macrotable.h" #include "math_macrotemplate.h" #include "math_matrixinset.h" +#include "math_noglyphinset.h" #include "math_rootinset.h" +#include "math_scopeinset.h" +#include "math_sqrtinset.h" #include "math_scriptinset.h" #include "math_sizeinset.h" #include "math_spaceinset.h" #include "math_sqrtinset.h" +#include "math_stackrelinset.h" +#include "math_symbolinset.h" #include "debug.h" #include "mathed/support.h" #include "lyxlex.h" +#include "support/lstrings.h" using std::istream; using std::endl; +namespace { + +MathScriptInset * prevScriptInset(MathArray const & array) +{ + MathInset * p = array.back(); + return (p && p->isScriptInset()) ? static_cast(p) : 0; +} + + +MathInset * lastScriptInset(MathArray & array, bool up, bool down, int limits) +{ + MathScriptInset * p = prevScriptInset(array); + if (!p) { + MathInset * b = array.back(); + if (b && b->isScriptable()) { + p = new MathScriptInset(up, down, b->clone()); + array.pop_back(); + } else { + p = new MathScriptInset(up, down); + } + array.push_back(p); + } + if (up) + p->up(true); + if (down) + p->down(down); + if (limits) + p->limits(limits); + return p; +} + // These are lexical codes, not semantic enum lexcode_enum { LexNone, LexESC, LexAlpha, - LexDigit, LexBOP, // Binary operators or relations - LexMathSpace, LexOpen, LexClose, LexComment, @@ -75,20 +110,6 @@ enum lexcode_enum { lexcode_enum lexcode[256]; -char const * latex_special_chars = "#$%&_{}"; - - -namespace { - -void mathed_parse(MathArray & array, unsigned flags); - -unsigned char getuchar(std::istream * is) -{ - char c; - is->get(c); - return static_cast(c); -} - const unsigned char LM_TK_OPEN = '{'; const unsigned char LM_TK_CLOSE = '}'; @@ -97,7 +118,6 @@ enum { FLAG_BRACE_LAST = 1 << 1, // // { Last } ends the parsing process FLAG_RIGHT = 1 << 2, // Next right ends the parsing process FLAG_END = 1 << 3, // Next end ends the parsing process - FLAG_BRACE_FONT = 1 << 4, // // { Next } closes a font FLAG_BRACK_END = 1 << 5, // // [ Next ] ends the parsing process FLAG_AMPERSAND = 1 << 6, // Next & ends the parsing process FLAG_NEWLINE = 1 << 7, // Next \\ ends the parsing process @@ -106,22 +126,6 @@ enum { FLAG_OPTARG = 1 << 10 // reads an argument in [] }; -/// -union { - /// - int i; - /// - latexkeys const * l; -} yylval; - - - -string yytext; -int yylineno; -istream * yyis; -MathTextCodes yyvarcode; - - struct latex_mathenv_type { char const * name; @@ -150,18 +154,11 @@ int const latex_mathenv_num = sizeof(latex_mathenv)/sizeof(latex_mathenv[0]); -void mathPrintError(string const & msg) -{ - //lyxerr[Debug::MATHED] << "Line ~" << yylineno << ": Math parse error: " << msg << endl; - lyxerr << "Line ~" << yylineno << ": Math parse error: " << msg << endl; -} - - void lexInit() { for (int i = 0; i <= 255; ++i) { if (isdigit(i)) - lexcode[i] = LexDigit; + lexcode[i] = LexOther; else if (isspace(i)) lexcode[i] = LexSpace; else @@ -176,9 +173,6 @@ void lexInit() lexcode['+'] = lexcode['-'] = lexcode['*'] = lexcode['/'] = lexcode['<'] = lexcode['>'] = lexcode['='] = LexBOP; - lexcode['!'] = lexcode[','] = lexcode[':'] - = lexcode[';'] = LexMathSpace; - lexcode['('] = lexcode[')'] = lexcode['|'] = lexcode['.'] = lexcode['?'] = LexOther; @@ -193,18 +187,86 @@ void lexInit() } -string lexArg(unsigned char lf, bool accept_spaces = false) + +// +// Helper class for parsing +// + + +class Parser { +public: + /// + Parser(LyXLex & lex) : is_(lex.getStream()), lineno_(lex.getLineNo()) {} + /// + Parser(istream & is) : is_(is), lineno_(0) {} + + /// + MathMacroTemplate * parse_macro(); + /// + MathMatrixInset * parse_normal(); + /// + void parse_into(MathArray & array, unsigned flags); + /// + int lineno() const { return lineno_; } + +private: + /// + int yylex(); + /// + string lexArg(unsigned char lf, bool accept_spaces = false); + /// + unsigned char getuchar(); + /// + void error(string const & msg); + /// + void parse_lines(MathGridInset * p, int col, bool numbered, bool outmost); + /// + latexkeys const * read_delim(); + +private: + /// + istream & is_; + /// + int lineno_; + + /// + int ival_; + /// + latexkeys const * lval_; + /// + string sval_; + + /// + bool curr_num_; + /// + string curr_label_; + /// + string curr_skip_; +}; + + +unsigned char Parser::getuchar() +{ + char c = 0; + if (!is_.good()) + lyxerr << "The input stream is not well..." << endl; + is_.get(c); + return static_cast(c); +} + + +string Parser::lexArg(unsigned char lf, bool accept_spaces = false) { string result; unsigned char c = 0; - while (yyis->good()) { - c = getuchar(yyis); + while (is_.good()) { + c = getuchar(); if (!isspace(c)) break; } if (c != lf) { - yyis->putback(c); + is_.putback(c); return result; } @@ -220,20 +282,20 @@ string lexArg(unsigned char lf, bool accept_spaces = false) int depth = 1; do { - unsigned char c = getuchar(yyis); + unsigned char c = getuchar(); if (c == lf) ++depth; if (c == rg) --depth; if ((!isspace(c) || (c == ' ' && accept_spaces)) && depth > 0) result += c; - } while (depth > 0 && yyis->good()); + } while (depth > 0 && is_.good()); return result; } -int yylex() +int Parser::yylex() { static bool init_done = false; @@ -242,87 +304,67 @@ int yylex() init_done = true; } - while (yyis->good()) { - unsigned char c = getuchar(yyis); + while (is_.good()) { + unsigned char c = getuchar(); //lyxerr << "reading byte: '" << c << "' code: " << lexcode[c] << endl; - if (yyvarcode == LM_TC_TEXTRM && c == ' ') { - yylval.i = ' '; - return LM_TK_ALPHA; - } else if (lexcode[c] == LexNewLine) { - ++yylineno; + if (lexcode[c] == LexNewLine) { + ++lineno_; continue; } else if (lexcode[c] == LexComment) { do { - c = getuchar(yyis); - } while (c != '\n' && yyis->good()); // eat comments - } else if (lexcode[c] == LexDigit - || lexcode[c] == LexOther - || lexcode[c] == LexMathSpace) { - yylval.i = c; + c = getuchar(); + } while (c != '\n' && is_.good()); // eat comments + } else if (lexcode[c] == LexOther) { + ival_ = c; return LM_TK_STR; - } else if (lexcode[c] == LexAlpha) { - yylval.i = c; + } else if (lexcode[c] == LexAlpha || lexcode[c] == LexSpace) { + ival_ = c; return LM_TK_ALPHA; } else if (lexcode[c] == LexBOP) { - yylval.i = c; + ival_ = c; return LM_TK_BOP; } else if (lexcode[c] == LexMath) { - yylval.i = 0; + ival_ = 0; return LM_TK_MATH; } else if (lexcode[c] == LexSelf) { return c; } else if (lexcode[c] == LexArgument) { - c = getuchar(yyis); - yylval.i = c - '0'; + c = getuchar(); + ival_ = c - '0'; return LM_TK_ARGUMENT; } else if (lexcode[c] == LexOpen) { return LM_TK_OPEN; } else if (lexcode[c] == LexClose) { return LM_TK_CLOSE; } else if (lexcode[c] == LexESC) { - c = getuchar(yyis); - if (c == '\\') { - yylval.i = -1; - return LM_TK_NEWLINE; - } - if (c == '(') { - yylval.i = LM_OT_SIMPLE; - return LM_TK_BEGIN; - } - if (c == ')') { - yylval.i = LM_OT_SIMPLE; - return LM_TK_END; - } - if (c == '[') { - yylval.i = LM_OT_EQUATION; - return LM_TK_BEGIN; - } - if (c == ']') { - yylval.i = LM_OT_EQUATION; - return LM_TK_END; - } - if (contains(latex_special_chars, c)) { - yylval.i = c; - return LM_TK_SPECIAL; - } - if (lexcode[c] == LexMathSpace) { - int i; - for (i = 0; i < 4 && static_cast(c) != latex_mathspace[i][0]; ++i) - ; - yylval.i = (i < 4) ? i : 0; - return LM_TK_SPACE; + c = getuchar(); + //lyxerr << "reading second byte: '" << c << "' code: " << lexcode[c] << endl; + string s; + s += c; + latexkeys const * l = in_word_set(s); + if (l) { + //lyxerr << "found key: " << l << endl; + //lyxerr << "found key name: " << l->name << endl; + //lyxerr << "found key token: " << l->token << endl; + lval_ = l; + ival_ = l->id; + return l->token; } if (lexcode[c] == LexAlpha) { - yytext.erase(); - while (lexcode[c] == LexAlpha && yyis->good()) { - yytext += c; - c = getuchar(yyis); + sval_.erase(); + while (lexcode[c] == LexAlpha && is_.good()) { + sval_ += c; + c = getuchar(); } - if (yyis->good()) - yyis->putback(c); - //lyxerr[Debug::MATHED] << "reading: text '" << yytext << "'\n"; - latexkeys const * l = in_word_set(yytext); + while (lexcode[c] == LexSpace && is_.good()) + c = getuchar(); + if (lexcode[c] != LexSpace) + is_.putback(c); + + //lyxerr[Debug::MATHED] << "reading: text '" << sval_ << "'\n"; + //lyxerr << "reading: text '" << sval_ << "'\n"; + latexkeys const * l = in_word_set(sval_); if (!l) return LM_TK_UNDEF; @@ -331,11 +373,11 @@ int yylex() int i = 0; while (i < latex_mathenv_num && name != latex_mathenv[i].name) ++i; - yylval.i = i; + ival_ = i; } else if (l->token == LM_TK_SPACE) - yylval.i = l->id; + ival_ = l->id; else - yylval.l = l; + lval_ = l; return l->token; } } @@ -344,140 +386,121 @@ int yylex() } - -MathScriptInset * prevScriptInset(MathArray const & array) +void Parser::error(string const & msg) { - MathInset * p = array.back_inset(); - return (p && p->isScriptInset()) ? static_cast(p) : 0; + lyxerr << "Line ~" << lineno_ << ": Math parse error: " << msg << endl; } -MathInset * lastScriptInset(MathArray & array, bool up, bool down, int limits) -{ - MathScriptInset * p = prevScriptInset(array); - if (!p) { - MathInset * b = array.back_inset(); - if (b && b->isScriptable()) { - p = new MathScriptInset(up, down, b->clone()); - array.pop_back(); - } else { - p = new MathScriptInset(up, down); - } - array.push_back(p); - } - if (up) - p->up(true); - if (down) - p->down(down); - if (limits) - p->limits(limits); - return p; -} - - - -static bool curr_num; -static string curr_label; - -void mathed_parse_lines(MathInset * inset, int col, bool numbered, bool outmost) +void Parser::parse_lines(MathGridInset * p, int col, bool numbered, bool outmost) { // save global variables - bool saved_num = curr_num; - string saved_label = curr_label; + bool const saved_num = curr_num_; + string const saved_label = curr_label_; - MathGridInset * p = static_cast(inset); for (int row = 0; true; ++row) { // reset global variables - curr_num = numbered; - curr_label = string(); + curr_num_ = numbered; + curr_label_.erase(); // reading a row int idx = p->nargs() - p->ncols(); for (int i = 0; i < col - 1; ++i, ++idx) - mathed_parse(p->cell(idx), FLAG_AMPERSAND); - mathed_parse(p->cell(idx), FLAG_NEWLINE | FLAG_END); + parse_into(p->cell(idx), FLAG_AMPERSAND); + parse_into(p->cell(idx), FLAG_NEWLINE | FLAG_END); if (outmost) { MathMatrixInset * m = static_cast(p); - m->numbered(row, curr_num); - m->label(row, curr_label); + m->numbered(row, curr_num_); + m->label(row, curr_label_); + if (curr_skip_.size()) { + m->vskip(LyXLength(curr_skip_), row); + curr_skip_.erase(); + } } - // Hack! +#ifdef WITH_WARNINGS +#warning Hack! +#endif // no newline - if (yylval.i != -1) + if (ival_ != -1) break; p->appendRow(); } - // restore global variables - curr_num = saved_num; - curr_label = saved_label; + // restore "global" variables + curr_num_ = saved_num; + curr_label_ = saved_label; +} + + +MathMacroTemplate * Parser::parse_macro() +{ + if (yylex() != LM_TK_NEWCOMMAND) { + lyxerr << "\\newcommand expected\n"; + return 0; + } + + string name = lexArg('{').substr(1); + string arg = lexArg('['); + int narg = arg.empty() ? 0 : atoi(arg.c_str()); + MathMacroTemplate * p = new MathMacroTemplate(name, narg); + parse_into(p->cell(0), FLAG_BRACE | FLAG_BRACE_LAST); + return p; } -MathInset * mathed_parse() +MathMatrixInset * Parser::parse_normal() { - MathInset * p = 0; + MathMatrixInset * p = 0; int t = yylex(); switch (t) { - case LM_TK_NEWCOMMAND: { - string name = lexArg('{').substr(1); - string arg = lexArg('['); - int narg = arg.empty() ? 0 : atoi(arg.c_str()); - p = new MathMacroTemplate(name, narg); - mathed_parse(p->cell(0), FLAG_BRACE | FLAG_BRACE_LAST); - //lyxerr[Debug::MATHED] << "LM_TK_NEWCOMMAND: name: " - // << name << " nargs: " << narg << "\n"; - break; - } - case LM_TK_MATH: case LM_TK_BEGIN: { - int i = yylval.i; + int i = ival_; lyxerr[Debug::MATHED] << "reading math environment " << i << " " << latex_mathenv[i].name << "\n"; MathInsetTypes typ = latex_mathenv[i].typ; p = new MathMatrixInset(typ); - MathMatrixInset * m = static_cast(p); + switch (typ) { case LM_OT_SIMPLE: { - curr_num = latex_mathenv[i].numbered; - curr_label = string(); - mathed_parse(m->cell(0), 0); - m->numbered(0, curr_num); - m->label(0, curr_label); + curr_num_ = latex_mathenv[i].numbered; + curr_label_.erase(); + parse_into(p->cell(0), 0); + p->numbered(0, curr_num_); + p->label(0, curr_label_); break; } case LM_OT_EQUATION: { - curr_num = latex_mathenv[i].numbered; - curr_label = string(); - mathed_parse(m->cell(0), FLAG_END); - m->numbered(0, curr_num); - m->label(0, curr_label); + curr_num_ = latex_mathenv[i].numbered; + curr_label_.erase(); + parse_into(p->cell(0), FLAG_END); + p->numbered(0, curr_num_); + p->label(0, curr_label_); break; } case LM_OT_EQNARRAY: { - mathed_parse_lines(m, 3, latex_mathenv[i].numbered, true); + parse_lines(p, 3, latex_mathenv[i].numbered, true); break; } case LM_OT_ALIGN: { - m->halign(lexArg('{')); - mathed_parse_lines(m, 2, latex_mathenv[i].numbered, true); + p->halign(lexArg('{')); + parse_lines(p, 2, latex_mathenv[i].numbered, true); break; } case LM_OT_ALIGNAT: { - m->halign(lexArg('{')); - mathed_parse_lines(m, 2, latex_mathenv[i].numbered, true); + p->halign(lexArg('{')); + parse_lines(p, 2, latex_mathenv[i].numbered, true); break; } @@ -486,8 +509,6 @@ MathInset * mathed_parse() << "1: unknown math environment: " << typ << "\n"; } - p->setName(latex_mathenv[i].basename); - break; } @@ -500,21 +521,43 @@ MathInset * mathed_parse() } -void handle_frac(MathArray & array, string const & name) +latexkeys const * Parser::read_delim() { - MathFracInset * p = new MathFracInset(name); - mathed_parse(p->cell(0), FLAG_ITEM); - mathed_parse(p->cell(1), FLAG_ITEM); - array.push_back(p); + int ld = yylex(); + //lyxerr << "found symbol: " << ld << "\n"; + latexkeys const * l = in_word_set("."); + switch (ld) { + case LM_TK_SYM: + case LM_TK_NOGLYPH: + case LM_TK_SPECIAL: + case LM_TK_BEGIN: { + l = lval_; + //lyxerr << "found key 1: '" << l << "'\n"; + //lyxerr << "found key 1: '" << l->name << "'\n"; + break; + } + case ']': + case '[': { + string s; + s += ld; + l = in_word_set(s); + //lyxerr << "found key 2: '" << l->name << "'\n"; + break; + } + case LM_TK_STR: { + string s; + s += ival_; + l = in_word_set(s); + //lyxerr << "found key 2: '" << l->name << "'\n"; + } + } + return l; } -void mathed_parse(MathArray & array, unsigned flags) +void Parser::parse_into(MathArray & array, unsigned flags) { - static int plevel = -1; - - ++plevel; - yyvarcode = LM_TC_VAR; + MathTextCodes yyvarcode = LM_TC_VAR; int t = yylex(); bool panic = false; @@ -522,8 +565,8 @@ void mathed_parse(MathArray & array, unsigned flags) int limits = 0; while (t) { - //lyxerr << "t: " << t << " flags: " << flags << " i: " << yylval.i - // << " '" << yytext << "'\n"; + //lyxerr << "t: " << t << " flags: " << flags << " i: " << ival_ + // << " '" << sval_ << "'\n"; //array.dump(lyxerr); //lyxerr << "\n"; @@ -542,7 +585,7 @@ void mathed_parse(MathArray & array, unsigned flags) } if ((flags & FLAG_BRACE) && t != LM_TK_OPEN) { - mathPrintError( + error( "Expected {. Maybe you forgot to enclose an argument in {}"); panic = true; break; @@ -551,77 +594,65 @@ void mathed_parse(MathArray & array, unsigned flags) switch (t) { case LM_TK_ALPHA: - array.push_back(yylval.i, yyvarcode); + if (!isspace(ival_) || yyvarcode == LM_TC_TEXTRM) + array.push_back(new MathCharInset(ival_, yyvarcode)); break; - case LM_TK_ARGUMENT: - array.push_back(new MathMacroArgument(yylval.i)); + case LM_TK_ARGUMENT: { + MathMacroArgument * p = new MathMacroArgument(ival_); + //p->code(yyvarcode); + array.push_back(p); break; + } case LM_TK_SPECIAL: - array.push_back(yylval.i, LM_TC_SPECIAL); + array.push_back(new MathCharInset(ival_, LM_TC_SPECIAL)); break; case LM_TK_STR: - array.push_back(yylval.i, LM_TC_CONST); + array.push_back(new MathCharInset(ival_, LM_TC_CONST)); break; case LM_TK_OPEN: - ++brace; - if (flags & FLAG_BRACE) - flags &= ~FLAG_BRACE; - else - array.push_back('{', LM_TC_TEX); + array.push_back(new MathScopeInset); + parse_into(array.back()->cell(0), FLAG_BRACE_LAST); break; case LM_TK_CLOSE: - --brace; - if (brace < 0) { - mathPrintError("Unmatching braces"); - panic = true; - break; - } - if (flags & FLAG_BRACE_FONT) { - yyvarcode = LM_TC_VAR; - flags &= ~FLAG_BRACE_FONT; - break; - } - if (brace == 0 && (flags & FLAG_BRACE_LAST)) + if (flags & FLAG_BRACE_LAST) { flags |= FLAG_LEAVE; - else - array.push_back('}', LM_TC_TEX); + } break; case '[': - array.push_back('[', LM_TC_CONST); + array.push_back(new MathCharInset('[', LM_TC_CONST)); break; case ']': if (flags & FLAG_BRACK_END) flags |= FLAG_LEAVE; else - array.push_back(']', LM_TC_CONST); + array.push_back(new MathCharInset(']', LM_TC_CONST)); break; case '^': - mathed_parse( + parse_into( lastScriptInset(array, true, false, limits)->cell(0), FLAG_ITEM); break; case '_': - mathed_parse( + parse_into( lastScriptInset(array, false, true, limits)->cell(1), FLAG_ITEM); break; case LM_TK_LIMIT: - limits = yylval.l->id; + limits = lval_->id; //lyxerr << "setting limit to " << limits << "\n"; break; case '&': if (flags & FLAG_AMPERSAND) { flags &= ~FLAG_AMPERSAND; - --plevel; return; } lyxerr[Debug::MATHED] @@ -629,161 +660,177 @@ void mathed_parse(MathArray & array, unsigned flags) break; case LM_TK_NEWLINE: + { + curr_skip_ = lexArg('['); if (flags & FLAG_NEWLINE) { flags &= ~FLAG_NEWLINE; - --plevel; return; } lyxerr[Debug::MATHED] << "found newline unexpectedly, array: '" << array << "'\n"; break; + } case LM_TK_PROTECT: break; + case LM_TK_NOGLYPH: + case LM_TK_NOGLYPHB: + limits = 0; + array.push_back(new MathNoglyphInset(lval_)); + break; + case LM_TK_BIGSYM: - case LM_TK_SYM: + limits = 0; + array.push_back(new MathBigopInset(lval_)); + break; + case LM_TK_FUNCLIM: limits = 0; - array.push_back(new MathSymbolInset(yylval.l)); + array.push_back(new MathFuncLimInset(lval_)); + break; + + case LM_TK_SYM: + limits = 0; + array.push_back(new MathSymbolInset(lval_)); break; case LM_TK_BOP: - array.push_back(yylval.i, LM_TC_BOP); + array.push_back(new MathCharInset(ival_, LM_TC_BOP)); break; case LM_TK_SPACE: - if (yylval.i >= 0) - array.push_back(new MathSpaceInset(yylval.i)); + if (ival_ >= 0) + array.push_back(new MathSpaceInset(ival_)); break; case LM_TK_DOTS: - array.push_back(new MathDotsInset(yylval.l)); + array.push_back(new MathDotsInset(lval_)); break; - case LM_TK_CHOOSE: - handle_frac(array, "atop"); - break; - case LM_TK_STACK: - handle_frac(array, "stackrel"); + { + MathStackrelInset * p = new MathStackrelInset; + parse_into(p->cell(0), FLAG_ITEM); + parse_into(p->cell(1), FLAG_ITEM); + array.push_back(p); break; + } case LM_TK_FRAC: - handle_frac(array, "frac"); + { + MathFracInset * p = new MathFracInset; + parse_into(p->cell(0), FLAG_ITEM); + parse_into(p->cell(1), FLAG_ITEM); + array.push_back(p); break; + } case LM_TK_SQRT: { - unsigned char c = getuchar(yyis); + unsigned char c = getuchar(); if (c == '[') { array.push_back(new MathRootInset); - mathed_parse(array.back_inset()->cell(0), FLAG_BRACK_END); - mathed_parse(array.back_inset()->cell(1), FLAG_ITEM); + parse_into(array.back()->cell(0), FLAG_BRACK_END); + parse_into(array.back()->cell(1), FLAG_ITEM); } else { - yyis->putback(c); + is_.putback(c); array.push_back(new MathSqrtInset); - mathed_parse(array.back_inset()->cell(0), FLAG_ITEM); + parse_into(array.back()->cell(0), FLAG_ITEM); } break; } case LM_TK_LEFT: { - int ld = yylex(); - if (ld == LM_TK_SYM) - ld = yylval.l->id; - else if (ld == LM_TK_STR || ld == LM_TK_BOP || ld == LM_TK_SPECIAL) - ld = yylval.i; - + latexkeys const * l = read_delim(); MathArray ar; - mathed_parse(ar, FLAG_RIGHT); - - int rd = yylex(); - if (rd == LM_TK_SYM) - rd = yylval.l->id; - else if (rd == LM_TK_STR || rd == LM_TK_BOP || rd == LM_TK_SPECIAL) - rd = yylval.i; - - MathDelimInset * dl = new MathDelimInset(ld, rd); + parse_into(ar, FLAG_RIGHT); + latexkeys const * r = read_delim(); + MathDelimInset * dl = new MathDelimInset(l, r); dl->cell(0) = ar; array.push_back(dl); break; } case LM_TK_RIGHT: - if (flags & FLAG_RIGHT) { - --plevel; + if (flags & FLAG_RIGHT) return; - } - mathPrintError("Unmatched right delimiter"); + error("Unmatched right delimiter"); // panic = true; break; case LM_TK_FONT: - yyvarcode = static_cast(yylval.l->id); - flags |= (FLAG_BRACE | FLAG_BRACE_FONT); + { + MathTextCodes t = static_cast(lval_->id); + MathArray ar; + parse_into(ar, FLAG_ITEM); + for (MathArray::iterator it = ar.begin(); it != ar.end(); ++it) + (*it)->handleFont(t); + array.push_back(ar); + break; + } + + case LM_TK_OLDFONT: + yyvarcode = static_cast(lval_->id); break; case LM_TK_STY: { lyxerr[Debug::MATHED] << "LM_TK_STY not implemented\n"; //MathArray tmp = array; - //MathSizeInset * p = new MathSizeInset(MathStyles(yylval.l->id)); + //MathSizeInset * p = new MathSizeInset(MathStyles(lval_->id)); //array.push_back(p); - //mathed_parse(p->cell(0), FLAG_BRACE_FONT); + //parse_into(p->cell(0), FLAG_BRACE_FONT); break; } - case LM_TK_DECORATION: { - MathDecorationInset * p = new MathDecorationInset(yylval.l); - mathed_parse(p->cell(0), FLAG_ITEM); + MathDecorationInset * p = new MathDecorationInset(lval_); + parse_into(p->cell(0), FLAG_ITEM); array.push_back(p); break; } case LM_TK_NONUM: - curr_num = false; + curr_num_ = false; break; case LM_TK_FUNC: - array.push_back(new MathSymbolInset(yylval.l)); + array.push_back(new MathSymbolInset(lval_)); break; case LM_TK_UNDEF: - if (MathMacroTable::hasTemplate(yytext)) { - lyxerr << "@@@ Found macro!\n"; - MathMacro * m = MathMacroTable::cloneTemplate(yytext); + if (MathMacroTable::hasTemplate(sval_)) { + MathMacro * m = MathMacroTable::cloneTemplate(sval_); for (int i = 0; i < m->nargs(); ++i) - mathed_parse(m->cell(i), FLAG_ITEM); + parse_into(m->cell(i), FLAG_ITEM); array.push_back(m); m->metrics(LM_ST_TEXT); } else - array.push_back(new MathFuncInset(yytext)); + array.push_back(new MathFuncInset(sval_)); break; case LM_TK_MATH: case LM_TK_END: - --plevel; return; case LM_TK_BEGIN: { - int i = yylval.i; + int i = ival_; MathInsetTypes typ = latex_mathenv[i].typ; if (typ == LM_OT_MATRIX) { - string valign = lexArg('[') + 'c'; - string halign = lexArg('{'); + string const valign = lexArg('[') + 'c'; + string const halign = lexArg('{'); //lyxerr << "valign: '" << valign << "'\n"; //lyxerr << "halign: '" << halign << "'\n"; MathArrayInset * m = new MathArrayInset(halign.size(), 1); m->valign(valign[0]); m->halign(halign); - mathed_parse_lines(m, halign.size(), latex_mathenv[i].numbered, false); + parse_lines(m, halign.size(), latex_mathenv[i].numbered, false); array.push_back(m); //lyxerr << "read matrix " << *m << "\n"; break; @@ -793,16 +840,16 @@ void mathed_parse(MathArray & array, unsigned flags) } case LM_TK_MACRO: - array.push_back(MathMacroTable::cloneTemplate(yylval.l->name)); + array.push_back(MathMacroTable::cloneTemplate(lval_->name)); break; case LM_TK_LABEL: - curr_label = lexArg('{', true); + curr_label_ = lexArg('{', true); break; default: - mathPrintError("Unrecognized token"); - lyxerr[Debug::MATHED] << "[" << t << " " << yytext << "]" << endl; + error("Unrecognized token"); + lyxerr[Debug::MATHED] << "[" << t << " " << sval_ << "]" << endl; break; } // end of big switch @@ -817,63 +864,85 @@ void mathed_parse(MathArray & array, unsigned flags) // Search for the end command. do { t = yylex(); - } while (yyis->good() && t != LM_TK_END && t); - } else + } while (is_.good() && t != LM_TK_END && t); + } else { t = yylex(); - + } } - --plevel; } + +void parse_end(LyXLex & lex, int lineno) +{ + // Update line number + lex.setLineNo(lineno); + + // reading of end_inset + while (lex.isOK()) { + lex.nextToken(); + if (lex.getString() == "\\end_inset") + break; + lyxerr[Debug::MATHED] << "InsetFormula::Read: Garbage before \\end_inset," + " or missing \\end_inset!" << endl; + } } +} // anonymous namespace + + MathArray mathed_parse_cell(string const & str) { istringstream is(str.c_str()); - yyis = &is; - yylineno = 0; + Parser parser(is); MathArray ar; - mathed_parse(ar, 0); + parser.parse_into(ar, 0); return ar; } -MathInset * mathed_parse(string const & str) + +MathMacroTemplate * mathed_parse_macro(string const & str) { istringstream is(str.c_str()); - return mathed_parse(is); + Parser parser(is); + return parser.parse_macro(); } - -MathInset * mathed_parse(istream & is) +MathMacroTemplate * mathed_parse_macro(istream & is) { - yyis = &is; - yylineno = 0; - return mathed_parse(); + Parser parser(is); + return parser.parse_macro(); } - -MathInset * mathed_parse(LyXLex & lex) +MathMacroTemplate * mathed_parse_macro(LyXLex & lex) { - yyis = &lex.getStream(); - yylineno = lex.GetLineNo(); + Parser parser(lex); + MathMacroTemplate * p = parser.parse_macro(); + parse_end(lex, parser.lineno()); + return p; +} - MathInset * p = mathed_parse(); - // Update line number - lex.setLineNo(yylineno); - // reading of end_inset - while (lex.IsOK()) { - lex.nextToken(); - if (lex.GetString() == "\\end_inset") - break; - lyxerr[Debug::MATHED] << "InsetFormula::Read: Garbage before \\end_inset," - " or missing \\end_inset!" << endl; - } +MathMatrixInset * mathed_parse_normal(string const & str) +{ + istringstream is(str.c_str()); + Parser parser(is); + return parser.parse_normal(); +} +MathMatrixInset * mathed_parse_normal(istream & is) +{ + Parser parser(is); + return parser.parse_normal(); +} + +MathMatrixInset * mathed_parse_normal(LyXLex & lex) +{ + Parser parser(lex); + MathMatrixInset * p = parser.parse_normal(); + parse_end(lex, parser.lineno()); return p; } -//]})