#include <cctype>
#ifdef __GNUG__
-#pragma implementation "math_parser.h"
+#pragma implementation
#endif
#include "math_parser.h"
+#include "array.h"
+#include "math_rowst.h"
#include "math_iter.h"
#include "math_inset.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_spaceinset.h"
+#include "math_dotsinset.h"
+#include "math_fracinset.h"
+#include "math_deliminset.h"
+#include "math_decorationinset.h"
#include "debug.h"
#include "support/lyxlib.h"
+#include "mathed/support.h"
+#include "boost/array.hpp"
using std::istream;
using std::endl;
-#if 0
-using std::isalpha;
-using std::isdigit;
-using std::isspace;
-#endif
extern MathMatrixInset * create_multiline(short int type, int cols);
FLAG_BRACK_END = 256 // Next ] ends the parsing process
};
+
+///
+union YYSTYPE {
+ ///
+ unsigned char c;
+ ///
+ char const * s;
+ ///
+ int i;
+ ///
+ latexkeys const * l;
+};
+
static
YYSTYPE yylval;
string mathed_label;
-int const latex_mathenv_num = 10;
+int const latex_mathenv_num = 12;
char const * latex_mathenv[latex_mathenv_num] = {
"math",
"displaymath",
"equation",
"eqnarray*",
"eqnarray",
+ "align*",
+ "align",
"alignat*",
"alignat",
"multline*",
};
-char const * latex_mathspace[] = {
- "!", ",", ":", ";", "quad", "qquad"
-};
char const * latex_special_chars = "#$%&_{}";
static lexcode_enum lexcode[256];
#warning Replace with string
-static char yytext[256];
+//static char yytext[256];
+static array<char, 256> yytext;
static int yylineno;
static istream * yyis;
static bool yy_mtextmode= false;
if (c == lf) ++bcnt;
if (c == rg) --bcnt;
if ((c > ' ' || (c == ' ' && accept_spaces)) && bcnt > 0) *(p++) = c;
- } while (bcnt > 0 && yyis->good() && p-yytext < 255);
+ } while (bcnt > 0 && yyis->good() && p - yytext.data() < 255);
*p = '\0';
return rg;
}
if (lexcode[c] == LexAlpha || lexcode[c] == LexDigit) {
char * p = &yytext[0];
while ((lexcode[c] == LexAlpha || lexcode[c] == LexDigit)
- && p-yytext < 255) {
+ && p - yytext.data() < 255) {
*p = c;
yyis->get(cc);
c = cc;
}
*p = '\0';
if (yyis->good()) yyis->putback(c);
- latexkeys * l = in_word_set (yytext, strlen(yytext));
+ 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 && strncmp(yytext, latex_mathenv[i],
+// for (i = 0; i < 5 && compare(yytext, latex_mathenv[i],
// strlen(latex_mathenv[i])); ++i);
for (i = 0; i < latex_mathenv_num
- && strcmp(yytext, latex_mathenv[i]); ++i);
+ && compare(yytext.data(), latex_mathenv[i]); ++i);
yylval.i = i;
} else
if (l->token == LM_TK_SPACE)
yylval.l = l;
return l->token;
} else {
- yylval.s = yytext;
+ yylval.s = yytext.data();
return LM_TK_UNDEF;
}
}
}
-LyxArrayBase * mathed_parse(unsigned flags, LyxArrayBase * array,
- MathParInset ** mtx)
+MathedArray * mathed_parse(unsigned flags = 0, MathedArray * array = 0,
+ MathParInset ** mtx = 0)
{
int t = yylex();
int tprev = 0;
MathedRowSt * crow = (mt) ? mt->getRowSt() : 0;
++plevel;
- if (!array) array = new LyxArrayBase;
+ if (!array) array = new MathedArray;
MathedIter data(array);
while (t) {
if ((flags & FLAG_BRACE) && t != LM_TK_OPEN) {
char const c = yyis->peek();
if (c == '[') {
LexGetArg('[');
- na = lyx::atoi(yytext);
+ na = lyx::atoi(yytext.data());
}
macro = new MathMacroTemplate(name, na);
flags = FLAG_BRACE|FLAG_BRACE_LAST;
*mtx = macro;
- macro->SetData(array);
+ macro->setData(array);
break;
}
case LM_TK_SPECIAL:
case '^':
{
MathParInset * p = new MathParInset(size, "", LM_OT_SCRIPT);
- LyxArrayBase * ar = mathed_parse(FLAG_BRACE_OPT|FLAG_BRACE_LAST, 0);
- p->SetData(ar);
+ MathedArray * ar = mathed_parse(FLAG_BRACE_OPT|FLAG_BRACE_LAST, 0);
+ p->setData(ar);
// lyxerr << "UP[" << p->GetStyle() << "]" << endl;
data.Insert (p, LM_TC_UP);
break;
case '_':
{
MathParInset * p = new MathParInset(size, "", LM_OT_SCRIPT);
- LyxArrayBase * ar = mathed_parse(FLAG_BRACE_OPT|FLAG_BRACE_LAST, 0);
- p->SetData(ar);
+ MathedArray * ar = mathed_parse(FLAG_BRACE_OPT|FLAG_BRACE_LAST, 0);
+ p->setData(ar);
data.Insert (p, LM_TC_DOWN);
break;
}
case LM_TK_FRAC:
{
MathFracInset * fc = new MathFracInset(fractype);
- LyxArrayBase * num = mathed_parse(FLAG_BRACE|FLAG_BRACE_LAST);
- LyxArrayBase * den = mathed_parse(FLAG_BRACE|FLAG_BRACE_LAST);
+ MathedArray * num = mathed_parse(FLAG_BRACE|FLAG_BRACE_LAST);
+ MathedArray * den = mathed_parse(FLAG_BRACE|FLAG_BRACE_LAST);
fc->SetData(num, den);
data.Insert(fc, LM_TC_ACTIVE_INSET);
break;
if (c == '[') {
rt = new MathRootInset(size);
rt->setArgumentIdx(0);
- rt->SetData(mathed_parse(FLAG_BRACK_END, 0, &rt));
+ rt->setData(mathed_parse(FLAG_BRACK_END, 0, &rt));
rt->setArgumentIdx(1);
} else {
yyis->putback(c);
rt = new MathSqrtInset(size);
}
- rt->SetData(mathed_parse(FLAG_BRACE|FLAG_BRACE_LAST, 0, &rt));
+ rt->setData(mathed_parse(FLAG_BRACE|FLAG_BRACE_LAST, 0, &rt));
data.Insert(rt, LM_TC_ACTIVE_INSET);
break;
}
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 << "]";
- LyxArrayBase * a = mathed_parse(FLAG_RIGHT);
+ MathedArray * a = mathed_parse(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(a);
+ dl->setData(a);
data.Insert(dl, LM_TC_ACTIVE_INSET);
// lyxerr << "RL[" << lfd << " " << rgd << "]";
break;
{
MathDecorationInset * sq = new MathDecorationInset(yylval.l->id,
size);
- sq->SetData(mathed_parse(FLAG_BRACE|FLAG_BRACE_LAST));
+ sq->setData(mathed_parse(FLAG_BRACE|FLAG_BRACE_LAST));
data.Insert(sq, LM_TC_ACTIVE_INSET);
break;
}
else
data.Insert(p, p->getTCode());
for (int i = 0; p->setArgumentIdx(i); ++i)
- p->SetData(mathed_parse(FLAG_BRACE|FLAG_BRACE_LAST));
+ p->setData(mathed_parse(FLAG_BRACE|FLAG_BRACE_LAST));
}
else {
MathedInset * q = new MathFuncInset(yylval.s, LM_OT_UNDEF);
lyxerr << "[" << yylval.i << "]" << endl;
--plevel;
if (mt) { // && (flags & FLAG_END)) {
- mt->SetData(array);
+ mt->setData(array);
array = 0;
}
return array;
ar[0] = ar2[0] = '\0';
char rg = LexGetArg(0);
if (rg == ']') {
- strcpy(ar2, yytext);
+ strcpy(ar2, yytext.data());
rg = LexGetArg('{');
}
- strcpy(ar, yytext);
+ strcpy(ar, yytext.data());
int const nc = parse_align(ar, ar2);
MathParInset * mm = new MathMatrixInset(nc, 0);
mm->SetAlign(ar2[0], ar);
panic = true;
}
- mathed_env = yylval.i;
+ mathed_env = static_cast<MathedInsetTypes>(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));
+ cols = strToInt(string(yytext.data()));
}
mt = create_multiline(mathed_env, cols);
if (mtx) *mtx = mt;
} else {
// lyxerr << "MATHCRO[" << yytext << "]";
MathMacro * p =
- MathMacroTable::mathMTable.getMacro(yytext);
+ MathMacroTable::mathMTable.getMacro(yytext.data());
if (p) {
data.Insert(p, p->getTCode());
p->setArgumentIdx(0);
if (rg != '}') {
mathPrintError("Expected '{'");
// debug info
- lyxerr << "[" << yytext << "]" << endl;
+ lyxerr << "[" << yytext.data() << "]" << endl;
panic = true;
break;
}
if (crow) {
- crow->setLabel(yytext);
+ crow->setLabel(yytext.data());
} else {
- mathed_label = yytext;
+ mathed_label = yytext.data();
}
#ifdef DEBUG
lyxerr << "Label[" << mathed_label << "]" << endl;
default:
mathPrintError("Unrecognized token");
// debug info
- lyxerr << "[" << t << " " << yytext << "]" << endl;
+ lyxerr << "[" << t << " " << yytext.data() << "]" << endl;
break;
}
tprev = t;
projects / lyx.git / blobdiff