X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fmathed%2Fmath_parser.C;h=d0d480743b0befe95c551f9f6f58b6fbf92b3650;hb=74124b4bf85af8e902b2ed844ab8b6349073e814;hp=68bc7bff671f4d52d47864d46814896006b1f2df;hpb=31b38676debcc272a3bf220f233511aac4e85ed7;p=lyx.git diff --git a/src/mathed/math_parser.C b/src/mathed/math_parser.C index 68bc7bff67..d0d480743b 100644 --- a/src/mathed/math_parser.C +++ b/src/mathed/math_parser.C @@ -25,89 +25,69 @@ #include "math_parser.h" #include "array.h" -#include "math_rowst.h" -#include "math_iter.h" #include "math_inset.h" +#include "math_arrayinset.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_root.h" #include "math_matrixinset.h" -#include "math_accentinset.h" -#include "math_bigopinset.h" -#include "math_funcinset.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_dotsinset.h" -#include "math_fracinset.h" -#include "math_deliminset.h" -#include "math_decorationinset.h" +#include "math_sqrtinset.h" +#include "math_stackrelinset.h" +#include "math_symbolinset.h" #include "debug.h" -#include "support/lyxlib.h" #include "mathed/support.h" -#include "boost/array.hpp" +#include "lyxlex.h" +#include "support/lstrings.h" using std::istream; using std::endl; -extern MathMatrixInset * create_multiline(short int type, int cols); - - -enum { - FLAG_BRACE = 1, // A { needed - FLAG_BRACE_ARG = 2, // Next { is argument - FLAG_BRACE_OPT = 4, // Optional { - FLAG_BRACE_LAST = 8, // Last } ends the parsing process - FLAG_BRACK_ARG = 16, // Optional [ - FLAG_RIGHT = 32, // Next right ends the parsing process - FLAG_END = 64, // Next end ends the parsing process - FLAG_BRACE_FONT = 128, // Next } closes a font - FLAG_BRACK_END = 256 // Next ] ends the parsing process -}; - +namespace { -/// -union YYSTYPE { - /// - unsigned char c; - /// - char const * s; - /// - int i; - /// - latexkeys const * l; -}; - - -static -YYSTYPE yylval; - - -static -MathedInsetTypes mathed_env = LM_OT_MIN; - - -string mathed_label; - - -int const latex_mathenv_num = 12; -char const * latex_mathenv[latex_mathenv_num] = { - "math", - "displaymath", - "equation", - "eqnarray*", - "eqnarray", - "align*", - "align", - "alignat*", - "alignat", - "multline*", - "multline", - "array" -}; +MathScriptInset * prevScriptInset(MathArray const & array) +{ + MathInset * p = array.back(); + return (p && p->isScriptInset()) ? static_cast(p) : 0; +} -char const * latex_special_chars = "#$%&_{}"; +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 @@ -115,9 +95,7 @@ enum lexcode_enum { LexNone, LexESC, LexAlpha, - LexDigit, LexBOP, // Binary operators or relations - LexMathSpace, LexOpen, LexClose, LexComment, @@ -125,51 +103,76 @@ enum lexcode_enum { LexSpace, LexNewLine, LexOther, + LexMath, LexSelf }; +lexcode_enum lexcode[256]; -static lexcode_enum lexcode[256]; -#warning Replace with string -//static char yytext[256]; -static array yytext; -static int yylineno; -static istream * yyis; -static bool yy_mtextmode= false; +const unsigned char LM_TK_OPEN = '{'; +const unsigned char LM_TK_CLOSE = '}'; -static inline -void mathPrintError(string const & msg) -{ - lyxerr << "Line ~" << yylineno << ": Math parse error: " - << msg << endl; -} +enum { + FLAG_BRACE = 1 << 0, // A { needed //} + 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_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 + FLAG_ITEM = 1 << 8, // read a (possibly braced token) + FLAG_LEAVE = 1 << 9, // marker for leaving the + FLAG_OPTARG = 1 << 10 // reads an argument in [] +}; -static -void LexInitCodes() +struct latex_mathenv_type { + char const * name; + char const * basename; + MathInsetTypes typ; + bool numbered; + bool ams; +}; + +latex_mathenv_type latex_mathenv[] = { + {"math", "math", LM_OT_SIMPLE, 0, 0}, + {"equation*", "equation", LM_OT_EQUATION, 0, 0}, + {"equation", "equation", LM_OT_EQUATION, 1, 0}, + {"eqnarray*", "eqnarray", LM_OT_EQNARRAY, 0, 0}, + {"eqnarray", "eqnarray", LM_OT_EQNARRAY, 1, 0}, + {"align*", "align", LM_OT_ALIGN, 0, 1}, + {"align", "align", LM_OT_ALIGN, 1, 1}, + {"alignat*", "alignat", LM_OT_ALIGNAT, 0, 1}, + {"alignat", "alignat", LM_OT_ALIGNAT, 1, 1}, + {"multline*", "multline", LM_OT_MULTLINE, 0, 1}, + {"multline", "multline", LM_OT_MULTLINE, 1, 1}, + {"array", "array", LM_OT_MATRIX, 0, 1} +}; + +int const latex_mathenv_num = sizeof(latex_mathenv)/sizeof(latex_mathenv[0]); + + + +void lexInit() { - for (int i = 0; i <= 255; ++i) { - if (isalpha(i)) - lexcode[i] = LexAlpha; - else if (isdigit(i)) - lexcode[i] = LexDigit; + for (int i = 0; i <= 255; ++i) { + if (isdigit(i)) + lexcode[i] = LexOther; else if (isspace(i)) lexcode[i] = LexSpace; else - lexcode[i] = LexNone; + lexcode[i] = LexAlpha; } lexcode['\t'] = lexcode['\f'] = lexcode[' '] = LexSpace; lexcode['\n'] = LexNewLine; lexcode['%'] = LexComment; lexcode['#'] = LexArgument; + lexcode['$'] = LexMath; lexcode['+'] = lexcode['-'] = lexcode['*'] = lexcode['/'] = lexcode['<'] = lexcode['>'] = lexcode['='] = LexBOP; - lexcode['!'] = lexcode[','] = lexcode[':'] - = lexcode[';'] = LexMathSpace; - lexcode['('] = lexcode[')'] = lexcode['|'] = lexcode['.'] = lexcode['?'] = LexOther; @@ -184,162 +187,198 @@ void LexInitCodes() } -static -char LexGetArg(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) { - // unsigned char c; - // char cc; - while (yyis->good()) { - char cc; - yyis->get(cc); - unsigned char c = cc; - if (c > ' ') { - if (!lf) - lf = c; - else if (c != lf) { - lyxerr << "Math parse error: unexpected '" - << c << "'" << endl; - return '\0'; - } + string result; + unsigned char c = 0; + while (is_.good()) { + c = getuchar(); + if (!isspace(c)) break; - } } - char const rg = - (lf == '{') ? '}' : - ((lf == '[') ? ']' - : ((lf == '(') ? ')' : 0)); + + if (c != lf) { + is_.putback(c); + return result; + } + + unsigned char rg = 0; + if (lf == '{') rg = '}'; + if (lf == '[') rg = ']'; + if (lf == '(') rg = ')'; if (!rg) { - lyxerr << "Math parse error: unknown bracket '" - << lf << "'" << endl; - return '\0'; + lyxerr[Debug::MATHED] << "Math parse error: unknown bracket '" + << lf << "'" << endl; + return result; } - char * p = &yytext[0]; - int bcnt = 1; + + int depth = 1; do { - char cc; - yyis->get(cc); - unsigned char c = cc; - if (c == lf) ++bcnt; - if (c == rg) --bcnt; - if ((c > ' ' || (c == ' ' && accept_spaces)) && bcnt > 0) - *(p++) = c; - } while (bcnt > 0 && yyis->good() && p - yytext.data() < 255); - - *p = '\0'; - return rg; + 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 && is_.good()); + + return result; } -static -int yylex(void) +int Parser::yylex() { - static int init_done = 0; + static bool init_done = false; - if (!init_done) LexInitCodes(); + if (!init_done) { + lexInit(); + init_done = true; + } - unsigned char c; - char cc; - while (yyis->good()) { - yyis->get(cc); - c = cc; + while (is_.good()) { + unsigned char c = getuchar(); + //lyxerr << "reading byte: '" << c << "' code: " << lexcode[c] << endl; - if (yy_mtextmode && 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 { - yyis->get(cc); - c = cc; - } 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) { + ival_ = 0; + return LM_TK_MATH; } else if (lexcode[c] == LexSelf) { return c; } else if (lexcode[c] == LexArgument) { - yyis->get(cc); - c = cc; - 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) { - yyis->get(cc); - c = cc; - if (c == '\\') { - return LM_TK_NEWLINE; - } - if (c == '(') { - yylval.i = LM_OT_MIN; - return LM_TK_BEGIN; - } - if (c == ')') { - yylval.i = LM_OT_MIN; - return LM_TK_END; + 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 (c == '[') { - yylval.i = LM_OT_PAR; - return LM_TK_BEGIN; - } - if (c == ']') { - yylval.i = LM_OT_PAR; - return LM_TK_END; - } - if (strchr(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; - } - if (lexcode[c] == LexAlpha || lexcode[c] == LexDigit) { - char * p = &yytext[0]; - while ((lexcode[c] == LexAlpha || lexcode[c] == LexDigit) - && p - yytext.data() < 255) { - *p = c; - yyis->get(cc); - c = cc; - ++p; + if (lexcode[c] == LexAlpha) { + sval_.erase(); + while (lexcode[c] == LexAlpha && is_.good()) { + sval_ += c; + c = getuchar(); } - *p = '\0'; - if (yyis->good()) yyis->putback(c); - latexkeys const * l = in_word_set (yytext.data(), strlen(yytext.data())); - if (l) { - if (l->token == LM_TK_BEGIN || l->token == LM_TK_END) { - int i; - LexGetArg('{'); -// for (i = 0; i < 5 && compare(yytext, latex_mathenv[i], -// strlen(latex_mathenv[i])); ++i); - - for (i = 0; - i < latex_mathenv_num - && compare(yytext.data(), latex_mathenv[i]); ++i); - yylval.i = i; - } else if (l->token == LM_TK_SPACE) - yylval.i = l->id; - else - yylval.l = l; - return l->token; - } else { - yylval.s = yytext.data(); + 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; - } + + if (l->token == LM_TK_BEGIN || l->token == LM_TK_END) { + string name = lexArg('{'); + int i = 0; + while (i < latex_mathenv_num && name != latex_mathenv[i].name) + ++i; + ival_ = i; + } else if (l->token == LM_TK_SPACE) + ival_ = l->id; + else + lval_ = l; + return l->token; } } } @@ -347,619 +386,563 @@ int yylex(void) } -static inline -int parse_align(char * hor, char *) +void Parser::error(string const & msg) { - int nc = 0; - for (char * c = hor; c && *c > ' '; ++c) ++nc; - return nc; + lyxerr << "Line ~" << lineno_ << ": Math parse error: " << msg << endl; } -// Accent hacks only for 0.12. Stolen from Cursor. -static -int accent = 0; -static -int nestaccent[8]; +void Parser::parse_lines(MathGridInset * p, int col, bool numbered, bool outmost) +{ + // save global variables + bool const saved_num = curr_num_; + string const saved_label = curr_label_; + + for (int row = 0; true; ++row) { + // reset global variables + curr_num_ = numbered; + curr_label_.erase(); + + // reading a row + int idx = p->nargs() - p->ncols(); + for (int i = 0; i < col - 1; ++i, ++idx) + 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_); + if (curr_skip_.size()) { + m->vskip(LyXLength(curr_skip_), row); + curr_skip_.erase(); + } + } + +#ifdef WITH_WARNINGS +#warning Hack! +#endif + // no newline + if (ival_ != -1) + break; + + p->appendRow(); + } + + // restore "global" variables + curr_num_ = saved_num; + curr_label_ = saved_label; +} -static inline -void setAccent(int ac) + +MathMacroTemplate * Parser::parse_macro() { - if (ac > 0 && accent < 8) { - nestaccent[accent++] = ac; - } else - accent = 0; // consumed! + 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; } -static -MathedInset * doAccent(byte c, MathedTextCodes t) +MathMatrixInset * Parser::parse_normal() { - MathedInset * ac = 0; - - for (int i = accent - 1; i >= 0; --i) { - if (i == accent - 1) - ac = new MathAccentInset(c, t, nestaccent[i]); - else - ac = new MathAccentInset(ac, nestaccent[i]); + MathMatrixInset * p = 0; + int t = yylex(); + + switch (t) { + case LM_TK_MATH: + case LM_TK_BEGIN: { + 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); + + switch (typ) { + + case LM_OT_SIMPLE: { + 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_.erase(); + parse_into(p->cell(0), FLAG_END); + p->numbered(0, curr_num_); + p->label(0, curr_label_); + break; + } + + case LM_OT_EQNARRAY: { + parse_lines(p, 3, latex_mathenv[i].numbered, true); + break; + } + + case LM_OT_ALIGN: { + p->halign(lexArg('{')); + parse_lines(p, 2, latex_mathenv[i].numbered, true); + break; + } + + case LM_OT_ALIGNAT: { + p->halign(lexArg('{')); + parse_lines(p, 2, latex_mathenv[i].numbered, true); + break; + } + + default: + lyxerr[Debug::MATHED] + << "1: unknown math environment: " << typ << "\n"; + } + + break; + } + + default: + lyxerr[Debug::MATHED] + << "2 unknown math environment: " << t << "\n"; } - accent = 0; // consumed! - - return ac; + + return p; } -static -MathedInset * doAccent(MathedInset * p) +latexkeys const * Parser::read_delim() { - MathedInset * ac = 0; - - for (int i = accent - 1; i >= 0; --i) { - if (i == accent - 1) - ac = new MathAccentInset(p, nestaccent[i]); - else - ac = new MathAccentInset(ac, nestaccent[i]); + 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"; + } } - accent = 0; // consumed! - - return ac; + return l; } -/** - */ -void mathed_parse(MathedArray & array, unsigned flags = 0, - MathParInset ** mtx = 0) +void Parser::parse_into(MathArray & array, unsigned flags) { - int t = yylex(); - int tprev = 0; - bool panic = false; - static int plevel = -1; - static int size = LM_ST_TEXT; - MathedTextCodes varcode = LM_TC_VAR; - MathedInset * binset = 0; - static MathMacroTemplate * macro = 0; - - int brace = 0; - int acc_brace = 0; - int acc_braces[8]; - MathParInset * mt = (mtx) ? *mtx : 0; - MathedRowContainer::iterator crow; - if (mt) - crow = mt->getRowSt().begin(); - - ++plevel; - MathedIter data(&array); + MathTextCodes yyvarcode = LM_TC_VAR; + + int t = yylex(); + bool panic = false; + int brace = 0; + int limits = 0; + while (t) { - if ((flags & FLAG_BRACE) && t != LM_TK_OPEN) { - if ((flags & FLAG_BRACK_ARG) && t == '[') { + //lyxerr << "t: " << t << " flags: " << flags << " i: " << ival_ + // << " '" << sval_ << "'\n"; + //array.dump(lyxerr); + //lyxerr << "\n"; + + if (flags & FLAG_ITEM) { + flags &= ~FLAG_ITEM; + if (t == LM_TK_OPEN) { + // skip the brace and regard everything to the next matching + // closing brace + t = yylex(); + ++brace; + flags |= FLAG_BRACE_LAST; } else { - mathPrintError("Expected {. Maybe you forgot to enclose an argument in {}"); - panic = true; - break; + // regard only this single token + flags |= FLAG_LEAVE; } } - MathedInsetTypes fractype = LM_OT_FRAC; - switch (t) { - - case LM_TK_ALPHA: - if (accent) { - data.insertInset(doAccent(yylval.i, varcode), - LM_TC_INSET); - } else - data.insert(yylval.i, varcode); //LM_TC_VAR); - break; - case LM_TK_ARGUMENT: - if (macro) { - data.insertInset(macro - ->getMacroPar(yylval.i - 1), - LM_TC_INSET); - } else { - lyxerr[Debug::MATHED] << "mathed_parse: macro arg outside macro def." << endl; - } - + if ((flags & FLAG_BRACE) && t != LM_TK_OPEN) { + error( + "Expected {. Maybe you forgot to enclose an argument in {}"); + panic = true; break; + } - case LM_TK_NEWCOMMAND: - { - int na = 0; - - LexGetArg('{'); - string const name(&yytext[1]); + switch (t) { - // ugly trick to be removed soon (lyx3) - char const c = yyis->peek(); - if (c == '[') { - LexGetArg('['); - na = lyx::atoi(yytext.data()); - } - macro = new MathMacroTemplate(name, na); - flags = FLAG_BRACE|FLAG_BRACE_LAST; + case LM_TK_ALPHA: + if (!isspace(ival_) || yyvarcode == LM_TC_TEXTRM) + array.push_back(new MathCharInset(ival_, yyvarcode)); + break; - *mtx = macro; - macro->setData(array); + case LM_TK_ARGUMENT: { + MathMacroArgument * p = new MathMacroArgument(ival_); + //p->code(yyvarcode); + array.push_back(p); break; } - + case LM_TK_SPECIAL: - data.insert(yylval.i, LM_TC_SPECIAL); + array.push_back(new MathCharInset(ival_, LM_TC_SPECIAL)); break; case LM_TK_STR: - if (accent) { - data.insertInset(doAccent(yylval.i, LM_TC_CONST), LM_TC_INSET); - } else - data.insert(yylval.i, LM_TC_CONST); + array.push_back(new MathCharInset(ival_, LM_TC_CONST)); break; case LM_TK_OPEN: - ++brace; - if (accent && tprev == LM_TK_ACCENT) { - acc_braces[acc_brace++] = brace; - break; - } - if (flags & FLAG_BRACE_OPT) { - flags &= ~FLAG_BRACE_OPT; - flags |= FLAG_BRACE; - } - - if (flags & FLAG_BRACE) - flags &= ~FLAG_BRACE; - else { - data.insert('{', 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 (acc_brace && brace == acc_braces[acc_brace - 1] - 1) { - --acc_brace; - break; - } - if (flags & FLAG_BRACE_FONT) { - varcode = LM_TC_VAR; - yy_mtextmode = false; - flags &= ~FLAG_BRACE_FONT; - break; - } - if (brace == 0 && (flags & FLAG_BRACE_LAST)) { - --plevel; - return; - } else { - data.insert('}', LM_TC_TEX); + if (flags & FLAG_BRACE_LAST) { + flags |= FLAG_LEAVE; } break; case '[': - if (flags & FLAG_BRACK_ARG) { - flags &= ~FLAG_BRACK_ARG; - char const rg = LexGetArg('['); - if (rg != ']') { - mathPrintError("Expected ']'"); - panic = true; - break; - } - // if (arg) strcpy(arg, yytext); - } else - data.insert('[', LM_TC_CONST); + array.push_back(new MathCharInset('[', LM_TC_CONST)); break; case ']': - if (flags & FLAG_BRACK_END) { - --plevel; - return; - } else - data.insert(']', LM_TC_CONST); + if (flags & FLAG_BRACK_END) + flags |= FLAG_LEAVE; + else + array.push_back(new MathCharInset(']', LM_TC_CONST)); break; case '^': - { - MathParInset * p = new MathParInset(size, "", - LM_OT_SCRIPT); - MathedArray ar; - mathed_parse(ar, FLAG_BRACE_OPT|FLAG_BRACE_LAST); - p->setData(ar); - // lyxerr << "UP[" << p->GetStyle() << "]" << endl; - data.insertInset(p, LM_TC_UP); + parse_into( + lastScriptInset(array, true, false, limits)->cell(0), FLAG_ITEM); break; - } case '_': - { - MathParInset * p = new MathParInset(size, "", - LM_OT_SCRIPT); - MathedArray ar; - mathed_parse(ar, FLAG_BRACE_OPT|FLAG_BRACE_LAST); - p->setData(ar); - data.insertInset(p, LM_TC_DOWN); + parse_into( + lastScriptInset(array, false, true, limits)->cell(1), FLAG_ITEM); break; - } case LM_TK_LIMIT: - if (binset) { - binset->SetLimits(bool(yylval.l->id)); - binset = 0; - } + limits = lval_->id; + //lyxerr << "setting limit to " << limits << "\n"; break; - case '&': // Tab - if ((flags & FLAG_END) && mt - && data.getCol()GetColumns() - 1) { - data.setNumCols(mt->GetColumns()); - data.insert('T', LM_TC_TAB); - } else - mathPrintError("Unexpected tab"); - // debug info. [made that conditional -JMarc] - if (lyxerr.debugging(Debug::MATHED)) - lyxerr << data.getCol() << " " - << mt->GetColumns() << endl; + case '&': + if (flags & FLAG_AMPERSAND) { + flags &= ~FLAG_AMPERSAND; + return; + } + lyxerr[Debug::MATHED] + << "found tab unexpectedly, array: '" << array << "'\n"; break; case LM_TK_NEWLINE: - if (mt && (flags & FLAG_END)) { - if (mt->Permit(LMPF_ALLOW_CR)) { - mt->getRowSt().insert(crow); - ++crow; - data.insert('K', LM_TC_CR); - } else - mathPrintError("Unexpected newline"); + { + curr_skip_ = lexArg('['); + if (flags & FLAG_NEWLINE) { + flags &= ~FLAG_NEWLINE; + 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: - { - binset = new MathBigopInset(yylval.l->name, yylval.l->id); - data.insertInset(binset, LM_TC_INSET); + limits = 0; + array.push_back(new MathBigopInset(lval_)); break; - } - + + case LM_TK_FUNCLIM: + limits = 0; + array.push_back(new MathFuncLimInset(lval_)); + break; + case LM_TK_SYM: - if (yylval.l->id < 256) { - MathedTextCodes tc = MathIsBOPS(yylval.l->id) ? LM_TC_BOPS: LM_TC_SYMB; - if (accent) { - data.insertInset(doAccent(yylval.l->id, tc), LM_TC_INSET); - } else - data.insert(yylval.l->id, tc); - } else { - MathFuncInset * bg = new MathFuncInset(yylval.l->name); - if (accent) { - data.insertInset(doAccent(bg), LM_TC_INSET); - } else { -#warning This is suspisious! (Lgb) - // it should not take a bool as second arg (Lgb) - data.insertInset(bg, true); - } - - } + limits = 0; + array.push_back(new MathSymbolInset(lval_)); break; case LM_TK_BOP: - if (accent) { - data.insertInset(doAccent(yylval.i, LM_TC_BOP), LM_TC_INSET); - } else - data.insert(yylval.i, LM_TC_BOP); + array.push_back(new MathCharInset(ival_, LM_TC_BOP)); break; - case LM_TK_STY: - if (mt) { - mt->UserSetSize(yylval.l->id); - } - break; - case LM_TK_SPACE: - if (yylval.i >= 0) { - MathSpaceInset * sp = new MathSpaceInset(yylval.i); - data.insertInset(sp, LM_TC_INSET); - } + if (ival_ >= 0) + array.push_back(new MathSpaceInset(ival_)); break; case LM_TK_DOTS: - { - MathDotsInset * p = new MathDotsInset(yylval.l->name, yylval.l->id); - data.insertInset(p, LM_TC_INSET); + array.push_back(new MathDotsInset(lval_)); break; - } case LM_TK_STACK: - fractype = LM_OT_STACKREL; - // fallthru + { + 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: { - MathFracInset * fc = new MathFracInset(fractype); - MathedArray num; - mathed_parse(num, FLAG_BRACE|FLAG_BRACE_LAST); - MathedArray den; - mathed_parse(den, FLAG_BRACE|FLAG_BRACE_LAST); - fc->SetData(num, den); - data.insertInset(fc, LM_TC_ACTIVE_INSET); + 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: - { - MathParInset * rt; - - char c; - yyis->get(c); - + { + unsigned char c = getuchar(); if (c == '[') { - rt = new MathRootInset(size); - rt->setArgumentIdx(0); - MathedArray ar; - mathed_parse(ar, FLAG_BRACK_END, &rt); - rt->setData(ar); // I belive that line is not needed (Lgb) - rt->setArgumentIdx(1); + array.push_back(new MathRootInset); + parse_into(array.back()->cell(0), FLAG_BRACK_END); + parse_into(array.back()->cell(1), FLAG_ITEM); } else { - yyis->putback(c); - rt = new MathSqrtInset(size); + is_.putback(c); + array.push_back(new MathSqrtInset); + parse_into(array.back()->cell(0), FLAG_ITEM); } - MathedArray ar; - mathed_parse(ar, FLAG_BRACE|FLAG_BRACE_LAST, &rt); - rt->setData(ar); // I belive that this line is not needed (Lgb) - data.insertInset(rt, LM_TC_ACTIVE_INSET); break; } case LM_TK_LEFT: { - int lfd = yylex(); - if (lfd == LM_TK_SYM || lfd == LM_TK_STR || lfd == LM_TK_BOP|| lfd == LM_TK_SPECIAL) - lfd = (lfd == LM_TK_SYM) ? yylval.l->id: yylval.i; -// lyxerr << "L[" << lfd << " " << lfd << "]"; - MathedArray ar; - mathed_parse(ar, FLAG_RIGHT); - int rgd = yylex(); -// lyxerr << "R[" << rgd << "]"; - if (rgd == LM_TK_SYM || rgd == LM_TK_STR || rgd == LM_TK_BOP || rgd == LM_TK_SPECIAL) - rgd = (rgd == LM_TK_SYM) ? yylval.l->id: yylval.i; - MathDelimInset * dl = new MathDelimInset(lfd, rgd); - dl->setData(ar); - data.insertInset(dl, LM_TC_ACTIVE_INSET); -// lyxerr << "RL[" << lfd << " " << rgd << "]"; + latexkeys const * l = read_delim(); + MathArray ar; + 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; - } else { - mathPrintError("Unmatched right delimiter"); -// panic = true; - } + error("Unmatched right delimiter"); +// panic = true; break; case LM_TK_FONT: - varcode = static_cast(yylval.l->id); - yy_mtextmode = bool(varcode == LM_TC_TEXTRM); - 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_WIDE: - { - MathDecorationInset * sq = new MathDecorationInset(yylval.l->id, - size); - MathedArray ar; - mathed_parse(ar, FLAG_BRACE|FLAG_BRACE_LAST); - sq->setData(ar); - data.insertInset(sq, LM_TC_ACTIVE_INSET); + 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(lval_->id)); + //array.push_back(p); + //parse_into(p->cell(0), FLAG_BRACE_FONT); + break; } - - case LM_TK_ACCENT: - setAccent(yylval.l->id); + + case LM_TK_DECORATION: + { + MathDecorationInset * p = new MathDecorationInset(lval_); + parse_into(p->cell(0), FLAG_ITEM); + array.push_back(p); break; + } case LM_TK_NONUM: - if (crow) - crow->setNumbered(false); + curr_num_ = false; break; - case LM_TK_PMOD: case LM_TK_FUNC: - if (accent) { - data.insert(t, LM_TC_CONST); - } else { - MathedInset * bg = new MathFuncInset(yylval.l->name); - data.insertInset(bg, LM_TC_INSET); - } + array.push_back(new MathSymbolInset(lval_)); break; - case LM_TK_FUNCLIM: - data.insertInset(new MathFuncInset(yylval.l->name, LM_OT_FUNCLIM), - LM_TC_INSET); - break; - - case LM_TK_UNDEF: - { - - MathMacro * p = - MathMacroTable::mathMTable.createMacro(yylval.s); - if (p) { - if (accent) - data.insertInset(doAccent(p), p->getTCode()); - else - data.insertInset(p, p->getTCode()); - for (int i = 0; p->setArgumentIdx(i); ++i) { - MathedArray ar; - mathed_parse(ar, FLAG_BRACE|FLAG_BRACE_LAST); - p->setData(ar); - } - } else { - MathedInset * q = new MathFuncInset(yylval.s, LM_OT_UNDEF); - if (accent) { - data.insertInset(doAccent(q), LM_TC_INSET); - } else { - data.insertInset(q, LM_TC_INSET); - } - } + case LM_TK_UNDEF: + if (MathMacroTable::hasTemplate(sval_)) { + MathMacro * m = MathMacroTable::cloneTemplate(sval_); + for (int i = 0; i < m->nargs(); ++i) + parse_into(m->cell(i), FLAG_ITEM); + array.push_back(m); + m->metrics(LM_ST_TEXT); + } else + array.push_back(new MathFuncInset(sval_)); break; - } + case LM_TK_MATH: case LM_TK_END: - if (mathed_env != yylval.i && yylval.i != LM_OT_MATRIX) - mathPrintError("Unmatched environment"); - // debug info [made that conditional -JMarc] - if (lyxerr.debugging(Debug::MATHED)) - lyxerr << "[" << yylval.i << "]" << endl; - --plevel; - if (mt) { // && (flags & FLAG_END)) { - mt->setData(array); - array.clear(); - } return; case LM_TK_BEGIN: - if (yylval.i == LM_OT_MATRIX) { - char ar[120]; - char ar2[8]; - ar[0] = ar2[0] = '\0'; - char rg = LexGetArg(0); - if (rg == ']') { - strcpy(ar2, yytext.data()); - rg = LexGetArg('{'); - } - strcpy(ar, yytext.data()); - int const nc = parse_align(ar, ar2); - MathParInset * mm = new MathMatrixInset(nc, 0); - mm->SetAlign(ar2[0], ar); - data.insertInset(mm, LM_TC_ACTIVE_INSET); - MathedArray dat; - mathed_parse(dat, FLAG_END, &mm); - } else if (is_eqn_type(yylval.i)) { - if (plevel!= 0) { - mathPrintError("Misplaced environment"); - break; - } - if (!mt) { - mathPrintError("0 paragraph."); - panic = true; - } - - mathed_env = static_cast(yylval.i); - if (mathed_env != LM_OT_MIN) { - size = LM_ST_DISPLAY; - if (is_multiline(mathed_env)) { - int cols = 1; - if (is_multicolumn(mathed_env)) { - if (mathed_env != LM_OT_ALIGNAT && - mathed_env != LM_OT_ALIGNATN && - yyis->good()) { - char c; - yyis->get(c); - if (c != '%') - lyxerr << "Math parse error: unexpected '" - << c << "'" << endl; - } - LexGetArg('{'); - cols = strToInt(string(yytext.data())); - } - mt = create_multiline(mathed_env, cols); - if (mtx) *mtx = mt; - flags |= FLAG_END; -// data.Insert(' ', LM_TC_TAB); -// data.Insert(' ', LM_TC_TAB); -// data.Reset(); - } - mt->SetStyle(size); - mt->SetType(mathed_env); - crow = mt->getRowSt().begin(); - } - - lyxerr[Debug::MATHED] << "MATH BEGIN[" << mathed_env << "]" << endl; - } else { -// lyxerr << "MATHCRO[" << yytext << "]"; - MathMacro * p = - MathMacroTable::mathMTable.createMacro(yytext.data()); - if (p) { - data.insertInset(p, p->getTCode()); - p->setArgumentIdx(0); - //mathed_parse(p->GetData(), FLAG_END, reinterpret_cast(&p)); - MathedArray dat; - mathed_parse(dat, FLAG_END, reinterpret_cast(&p)); -// for (int i = 0; p->setArgumentIdx(i); ++i) -// p->SetData(mathed_parse(FLAG_BRACE|FLAG_BRACE_LAST)); - } else - mathPrintError("Unrecognized environment"); - } + { + int i = ival_; + MathInsetTypes typ = latex_mathenv[i].typ; + + if (typ == LM_OT_MATRIX) { + 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); + + parse_lines(m, halign.size(), latex_mathenv[i].numbered, false); + array.push_back(m); + //lyxerr << "read matrix " << *m << "\n"; + break; + } else + lyxerr[Debug::MATHED] << "unknow math inset " << typ << "\n"; break; - + } + case LM_TK_MACRO: - { - MathedInset * p = - MathMacroTable::mathMTable.createMacro(yylval.l->name); - - if (p) { - if (accent) { - data.insertInset(doAccent(p), LM_TC_INSET); - } else - data.insertInset(p, static_cast(p)->getTCode()); - } + array.push_back(MathMacroTable::cloneTemplate(lval_->name)); break; - } case LM_TK_LABEL: - { - char const rg = LexGetArg('\0', true); - if (rg != '}') { - mathPrintError("Expected '{'"); - // debug info - lyxerr << "[" << yytext.data() << "]" << endl; - panic = true; - break; - } - if (crow) { - crow->setLabel(yytext.data()); - } else { - mathed_label = yytext.data(); - } - lyxerr[Debug::MATHED] << "Label[" << mathed_label << "]" << endl; + curr_label_ = lexArg('{', true); break; - } default: - mathPrintError("Unrecognized token"); - // debug info - lyxerr << "[" << t << " " << yytext.data() << "]" << endl; + error("Unrecognized token"); + lyxerr[Debug::MATHED] << "[" << t << " " << sval_ << "]" << endl; break; - } // end of switch - - tprev = t; + + } // end of big switch + + if (flags & FLAG_LEAVE) { + flags &= ~FLAG_LEAVE; + break; + } + if (panic) { lyxerr << " Math Panic, expect problems!" << endl; // Search for the end command. do { - t = yylex (); - } while (t != LM_TK_END && t); - } else - t = yylex (); - - if ((flags & FLAG_BRACE_OPT)/* && t!= '^' && t!= '_'*/) { - flags &= ~FLAG_BRACE_OPT; - //data.Insert (LM_TC_CLOSE); - break; + t = yylex(); + } while (is_.good() && t != LM_TK_END && t); + } else { + t = yylex(); } } - --plevel; } -void mathed_parser_file(istream & is, int lineno) +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()); + Parser parser(is); + MathArray ar; + parser.parse_into(ar, 0); + return ar; +} + + + +MathMacroTemplate * mathed_parse_macro(string const & str) +{ + istringstream is(str.c_str()); + Parser parser(is); + return parser.parse_macro(); +} + +MathMacroTemplate * mathed_parse_macro(istream & is) +{ + Parser parser(is); + return parser.parse_macro(); +} + +MathMacroTemplate * mathed_parse_macro(LyXLex & lex) +{ + Parser parser(lex); + MathMacroTemplate * p = parser.parse_macro(); + parse_end(lex, parser.lineno()); + return p; +} + + + +MathMatrixInset * mathed_parse_normal(string const & str) { - yyis = &is; - yylineno = lineno; - if (!MathMacroTable::built) - MathMacroTable::mathMTable.builtinMacros(); + 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(); +} -int mathed_parser_lineno() +MathMatrixInset * mathed_parse_normal(LyXLex & lex) { - return yylineno; + Parser parser(lex); + MathMatrixInset * p = parser.parse_normal(); + parse_end(lex, parser.lineno()); + return p; } +