*/
#include <config.h>
-#include <stdlib.h>
-#include <ctype.h>
+#include <cstdlib>
+#include <cctype>
#ifdef __GNUG__
#pragma implementation "math_parser.h"
static short mathed_env = LM_EN_INTEXT;
-char *mathed_label = 0;
+char * mathed_label = 0;
-char const *latex_mathenv[] = {
+char const * latex_mathenv[] = {
"math",
"displaymath",
"equation",
};
-char const *latex_mathspace[] = {
+char const * latex_mathspace[] = {
"!", ",", ":", ";", "quad", "qquad"
};
-char const *latex_special_chars = "#$%&_{}";
+char const * latex_special_chars = "#$%&_{}";
// These are lexical codes, not semantic
enum lexcode_enum {
static lexcode_enum lexcode[256];
static char yytext[256];
static int yylineno;
-static FILE *yyin;
-static bool yy_mtextmode=false;
+static istream * yyis;
+static bool yy_mtextmode= false;
inline
-char *strnew(char const* s)
+char * strnew(char const * s)
{
- char *s1 = new char[strlen(s)+1]; // this leaks when not delete[]'ed
+ char * s1 = new char[strlen(s) + 1]; // this leaks when not delete[]'ed
strcpy(s1, s);
return s1;
}
-static void mathPrintError(char const *msg)
+static
+void mathPrintError(char const * msg)
{
lyxerr << "Line ~" << yylineno << ": Math parse error: "
<< msg << endl;
}
-static void LexInitCodes()
+static
+void LexInitCodes()
{
- int i;
-
- for (i=0; i<=255; i++) {
+ for (int i = 0; i <= 255; ++i) {
if (isalpha(i)) lexcode[i] = LexAlpha;
else if (isdigit(i)) lexcode[i] = LexDigit;
else if (isspace(i)) lexcode[i] = LexSpace;
lexcode['}'] = LexClose;
}
-static char LexGetArg(char lf, bool accept_spaces=false)
+
+static
+char LexGetArg(char lf, bool accept_spaces= false)
{
- char c, rg, *p = &yytext[0];
- int bcnt =1;
-
- while (!feof(yyin)) {
- c = getc(yyin);
- if (c>' ') {
+ char rg;
+ char * p = &yytext[0];
+ int bcnt = 1;
+ unsigned char c;
+ char cc;
+ while (yyis->good()) {
+ yyis->get(cc);
+ c = cc;
+ if (c > ' ') {
if (!lf) lf = c; else
- if (c!=lf)
+ if (c != lf)
lyxerr << "Math parse error: unexpected '"
<< c << "'" << endl;
break;
}
}
- rg = (lf=='{') ? '}': ((lf=='[') ? ']': ((lf=='(') ? ')': 0));
+ rg = (lf == '{') ? '}': ((lf == '[') ? ']': ((lf == '(') ? ')': 0));
if (!rg) {
lyxerr << "Math parse error: unknown bracket '"
<< lf << "'" << endl;
return '\0';
}
do {
- c = getc(yyin);
- if (c==lf) bcnt++;
- if (c==rg) bcnt--;
- if ((c>' ' || (c==' ' && accept_spaces)) && bcnt>0) *(p++) = c;
- } while (bcnt>0 && !feof(yyin));
+ yyis->get(cc);
+ 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 = '\0';
return rg;
}
-static int yylex(void)
+
+static
+int yylex(void)
{
static int init_done = 0;
unsigned char c;
+ char cc;
if (!init_done) LexInitCodes();
- while (!feof(yyin)) {
- c = getc(yyin);
+ while (yyis->good()) {
+ yyis->get(cc);
+ c = cc;
- if (yy_mtextmode && c==' ') {
- yylval.i=' ';
+ if (yy_mtextmode && c == ' ') {
+ yylval.i= ' ';
return LM_TK_ALPHA;
}
- if (lexcode[c]==LexNewLine) {
- yylineno++;
+ if (lexcode[c] == LexNewLine) {
+ ++yylineno;
continue;
}
- if (lexcode[c]==LexComment)
- do c = getc(yyin); while (c!='\n' % !feof(yyin)); // eat comments
+ if (lexcode[c] == LexComment)
+ do { yyis->get(cc); c = cc; } while (c != '\n' % yyis->good()); // eat comments
- if (lexcode[c]==LexDigit || lexcode[c]==LexOther || lexcode[c]==LexMathSpace)
- { yylval.i= c; return LM_TK_STR; }
- if (lexcode[c]==LexAlpha) { yylval.i=c; return LM_TK_ALPHA; }
- if (lexcode[c]==LexBOP) { yylval.i=c; return LM_TK_BOP; }
- if (lexcode[c]==LexSelf) { return c; }
- if (lexcode[c]==LexArgument) {
- c = getc(yyin);
+ if (lexcode[c] == LexDigit || lexcode[c] == LexOther || lexcode[c] == LexMathSpace) { yylval.i = c; return LM_TK_STR; }
+ if (lexcode[c] == LexAlpha) { yylval.i= c; return LM_TK_ALPHA; }
+ if (lexcode[c] == LexBOP) { yylval.i= c; return LM_TK_BOP; }
+ if (lexcode[c] == LexSelf) { return c; }
+ if (lexcode[c] == LexArgument) {
+ yyis->get(cc);
+ c = cc;
yylval.i = c - '0';
return LM_TK_ARGUMENT;
}
- if (lexcode[c]==LexOpen) { return LM_TK_OPEN; }
- if (lexcode[c]==LexClose) { return LM_TK_CLOSE; }
+ if (lexcode[c] == LexOpen) { return LM_TK_OPEN; }
+ if (lexcode[c] == LexClose) { return LM_TK_CLOSE; }
- if (lexcode[c]==LexESC) {
- c = getc(yyin);
- if (c=='\\') { return LM_TK_NEWLINE; }
- if (c=='(') { yylval.i = LM_EN_INTEXT; return LM_TK_BEGIN; }
- if (c==')') { yylval.i = LM_EN_INTEXT; return LM_TK_END; }
- if (c=='[') { yylval.i = LM_EN_DISPLAY; return LM_TK_BEGIN; }
- if (c==']') { yylval.i = LM_EN_DISPLAY; return LM_TK_END; }
+ if (lexcode[c] == LexESC) {
+ yyis->get(cc);
+ c = cc;
+ if (c == '\\') { return LM_TK_NEWLINE; }
+ if (c == '(') { yylval.i = LM_EN_INTEXT; return LM_TK_BEGIN; }
+ if (c == ')') { yylval.i = LM_EN_INTEXT; return LM_TK_END; }
+ if (c == '[') { yylval.i = LM_EN_DISPLAY; return LM_TK_BEGIN; }
+ if (c == ']') { yylval.i = LM_EN_DISPLAY; return LM_TK_END; }
if (strchr(latex_special_chars, c)) {
yylval.i = c;
return LM_TK_SPECIAL;
}
- if (lexcode[c]==LexMathSpace) {
+ if (lexcode[c] == LexMathSpace) {
int i;
- for (i=0; i<4 && c!=latex_mathspace[i][0]; i++);
- yylval.i = (i<4) ? i: 0;
+ for (i = 0; i < 4 && static_cast<int>(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) {
+ if (lexcode[c] == LexAlpha || lexcode[c] == LexDigit) {
+ char * p = &yytext[0];
+ while (lexcode[c] == LexAlpha || lexcode[c] == LexDigit) {
*p = c;
- c = getc(yyin);
- p++;
+ yyis->get(cc);
+ c = cc;
+ ++p;
}
*p = '\0';
- if (!feof(yyin)) ungetc(c, yyin);
- latexkeys *l = in_word_set (yytext, strlen(yytext));
+ if (yyis->good()) yyis->putback(c);
+ latexkeys * l = in_word_set (yytext, strlen(yytext));
if (l) {
- if (l->token==LM_TK_BEGIN || l->token==LM_TK_END) {
+ if (l->token == LM_TK_BEGIN || l->token == LM_TK_END) {
int i;
LexGetArg('{');
-// for (i=0; i<5 && strncmp(yytext, latex_mathenv[i],
-// strlen(latex_mathenv[i])); i++);
+// for (i = 0; i < 5 && strncmp(yytext, latex_mathenv[i],
+// strlen(latex_mathenv[i])); ++i);
- for (i=0; i<6 && strcmp(yytext, latex_mathenv[i]); i++);
+ for (i = 0; i < 6 && strcmp(yytext, latex_mathenv[i]); ++i);
yylval.i = i;
} else
- if (l->token==LM_TK_SPACE)
+ if (l->token == LM_TK_SPACE)
yylval.i = l->id;
else
yylval.l = l;
return 0;
}
-int parse_align(char *hor, char *)
-{
- char *c;
+int parse_align(char * hor, char *)
+{
int nc = 0;
- for (c=hor; c && *c>' '; c++) nc++;
+ for (char * c = hor; c && *c > ' '; ++c) ++nc;
return nc;
}
+
// Accent hacks only for 0.12. Stolen from Cursor.
int accent = 0;
int nestaccent[8];
}
-MathedInset *doAccent(byte c, MathedTextCodes t)
+MathedInset * doAccent(byte c, MathedTextCodes t)
{
- MathedInset *ac = 0;
+ MathedInset * ac = 0;
- for (int i=accent-1; i>=0; i--) {
- if (i==accent-1)
+ 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]);
}
-MathedInset *doAccent(MathedInset *p)
+MathedInset * doAccent(MathedInset * p)
{
- MathedInset *ac = 0;
+ MathedInset * ac = 0;
- for (int i=accent-1; i>=0; i--) {
- if (i==accent-1)
+ 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]);
}
-
-
-LyxArrayBase *mathed_parse(unsigned flags, LyxArrayBase *array, MathParInset **mtx)
+LyxArrayBase * mathed_parse(unsigned flags, LyxArrayBase * array,
+ MathParInset ** mtx)
{
int t = yylex(), 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;
+ MathedInset * binset = 0;
+ static MathMacroTemplate * macro= 0;
int brace = 0;
int acc_brace = 0;
int acc_braces[8];
- MathParInset *mt = (mtx) ? *mtx: 0;//(MathParInset*)0;
- MathedRowSt *crow = (mt) ? mt->getRowSt(): 0;
+ MathParInset * mt = (mtx) ? *mtx : 0;//(MathParInset*)0;
+ MathedRowSt * crow = (mt) ? mt->getRowSt() : 0;
- plevel++;
+ ++plevel;
if (!array) array = new LyxArrayBase;
MathedIter data(array);
while (t) {
if ((flags & FLAG_BRACE) && t != LM_TK_OPEN) {
- if ((flags & FLAG_BRACK_ARG) && t=='[') {
+ if ((flags & FLAG_BRACK_ARG) && t == '[') {
}
else {
mathPrintError("Expected {. Maybe you forgot to enclose an argument in {}");
LexGetArg('{');
// This name lives until quitting, for that reason
// I didn't care on deleting explicitly. Later I will.
- char const *name = strnew(&yytext[1]);
+ char const * name = strnew(&yytext[1]);
// ugly trick to be removed soon (lyx3)
- char c = getc(yyin);
- ungetc(c, yyin);
- if (c=='[') {
+ char c; yyis->get(c);
+ yyis->putback(c);
+ if (c == '[') {
LexGetArg('[');
na = atoi(yytext);
}
}
case LM_TK_OPEN:
{
- brace++;
- if (accent && tprev==LM_TK_ACCENT) {
+ ++brace;
+ if (accent && tprev == LM_TK_ACCENT) {
acc_braces[acc_brace++] = brace;
break;
}
}
case LM_TK_CLOSE:
{
- brace--;
+ --brace;
if (brace < 0) {
mathPrintError("Unmatching braces");
panic = true;
break;
}
- if (acc_brace && brace==acc_braces[acc_brace-1]-1) {
- acc_brace--;
+ if (acc_brace && brace == acc_braces[acc_brace-1]-1) {
+ --acc_brace;
break;
}
if (flags & FLAG_BRACE_FONT) {
break;
}
if (brace == 0 && (flags & FLAG_BRACE_LAST)) {
- plevel--;
+ --plevel;
return array;
} else {
data.Insert ('}', LM_TC_TEX);
{
if (flags & FLAG_BRACK_ARG) {
flags &= ~FLAG_BRACK_ARG;
- char rg=LexGetArg('[');
- if (rg!=']') {
+ char rg = LexGetArg('[');
+ if (rg!= ']') {
mathPrintError("Expected ']'");
panic = true;
break;
case ']':
{
if (flags & FLAG_BRACK_END) {
- plevel--;
+ --plevel;
return array;
} else
data.Insert (']');
case '^':
{
- MathParInset *p = new MathParInset(size, "", LM_OT_SCRIPT);
+ MathParInset * p = new MathParInset(size, "", LM_OT_SCRIPT);
LyxArrayBase * ar = mathed_parse(FLAG_BRACE_OPT|FLAG_BRACE_LAST, 0);
p->SetData(ar);
// lyxerr << "UP[" << p->GetStyle() << "]" << endl;
}
case '_':
{
- MathParInset *p = new MathParInset(size, "", LM_OT_SCRIPT);
+ MathParInset * p = new MathParInset(size, "", LM_OT_SCRIPT);
LyxArrayBase * ar = mathed_parse(FLAG_BRACE_OPT|FLAG_BRACE_LAST, 0);
p->SetData(ar);
data.Insert (p, LM_TC_DOWN);
case LM_TK_LIMIT:
{
if (binset) {
- binset->SetLimits((bool)(yylval.l->id));
+ binset->SetLimits(bool(yylval.l->id));
binset = 0;
}
break;
}
case LM_TK_BIGSYM:
{
- binset = new MathBigopInset(yylval.l->name,yylval.l->id);
+ binset = new MathBigopInset(yylval.l->name, yylval.l->id);
data.Insert(binset);
break;
}
} else
data.Insert (yylval.l->id, tc);
} else {
- MathFuncInset *bg = new MathFuncInset(yylval.l->name);
+ MathFuncInset * bg = new MathFuncInset(yylval.l->name);
if (accent) {
data.Insert(doAccent(bg));
} else
}
case LM_TK_SPACE:
{
- if (yylval.i>=0) {
- MathSpaceInset *sp = new MathSpaceInset(yylval.i);
+ if (yylval.i >= 0) {
+ MathSpaceInset * sp = new MathSpaceInset(yylval.i);
data.Insert(sp);
}
break;
}
case LM_TK_DOTS:
{
- MathDotsInset *p = new MathDotsInset(yylval.l->name, yylval.l->id);
+ MathDotsInset * p = new MathDotsInset(yylval.l->name, yylval.l->id);
data.Insert(p);
break;
- }
+ }
case LM_TK_STACK:
fractype = LM_OT_STACKREL;
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);
+ MathFracInset * fc = new MathFracInset(fractype);
+ LyxArrayBase * num = mathed_parse(FLAG_BRACE|FLAG_BRACE_LAST);
+ LyxArrayBase * den = mathed_parse(FLAG_BRACE|FLAG_BRACE_LAST);
fc->SetData(num, den);
data.Insert(fc, LM_TC_ACTIVE_INSET);
break;
}
case LM_TK_SQRT:
{
- MathParInset *rt;
+ MathParInset * rt;
- char c = getc(yyin);
+ char c; yyis->get(c);
- if (c=='[') {
+ if (c == '[') {
rt = new MathRootInset(size);
rt->setArgumentIdx(0);
rt->SetData(mathed_parse(FLAG_BRACK_END, 0, &rt));
rt->setArgumentIdx(1);
} else {
- ungetc(c, yyin);
+ yyis->putback(c);
rt = new MathSqrtInset(size);
}
rt->SetData(mathed_parse(FLAG_BRACE|FLAG_BRACE_LAST, 0, &rt));
case LM_TK_LEFT:
{
int lfd, rgd;
- 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;
+ 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 << "]";
- LyxArrayBase* a = mathed_parse(FLAG_RIGHT);
- rgd=yylex();
+ LyxArrayBase * a = mathed_parse(FLAG_RIGHT);
+ 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);
+ 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);
data.Insert(dl, LM_TC_ACTIVE_INSET);
// lyxerr << "RL[" << lfd << " " << rgd << "]";
case LM_TK_RIGHT:
{
if (flags & FLAG_RIGHT) {
- plevel--;
+ --plevel;
return array;
} else {
mathPrintError("Unmatched right delimiter");
case LM_TK_FONT:
{
- varcode = (MathedTextCodes)yylval.l->id;
- yy_mtextmode = (bool)(varcode==LM_TC_TEXTRM);
+ varcode = static_cast<MathedTextCodes>(yylval.l->id);
+ yy_mtextmode = bool(varcode == LM_TC_TEXTRM);
flags |= (FLAG_BRACE|FLAG_BRACE_FONT);
break;
}
case LM_TK_WIDE:
{
- MathDecorationInset *sq = new MathDecorationInset(yylval.l->id, size);
+ MathDecorationInset * sq = new MathDecorationInset(yylval.l->id,
+ size);
sq->SetData(mathed_parse(FLAG_BRACE|FLAG_BRACE_LAST));
data.Insert(sq, LM_TC_ACTIVE_INSET);
break;
case LM_TK_PMOD:
case LM_TK_FUNC:
{
- MathedInset *bg = new MathFuncInset(yylval.l->name);
+ MathedInset * bg = new MathFuncInset(yylval.l->name);
if (accent) {
data.Insert(t);
} else
case LM_TK_UNDEF:
{
- MathMacro* p =
+ MathMacro * p =
MathMacroTable::mathMTable.getMacro(yylval.s);
if (p) {
if (accent)
data.Insert(doAccent(p), p->getTCode());
else
data.Insert(p, p->getTCode());
- for (int i=0; p->setArgumentIdx(i); i++)
+ for (int i = 0; p->setArgumentIdx(i); ++i)
p->SetData(mathed_parse(FLAG_BRACE|FLAG_BRACE_LAST));
}
else {
- MathedInset *q = new MathFuncInset(yylval.s, LM_OT_UNDEF);
+ MathedInset * q = new MathFuncInset(yylval.s, LM_OT_UNDEF);
if (accent) {
data.Insert(doAccent(q));
} else {
}
case LM_TK_END:
{
- if (mathed_env != yylval.i && yylval.i!=LM_EN_ARRAY)
+ if (mathed_env != yylval.i && yylval.i!= LM_EN_ARRAY)
mathPrintError("Unmatched environment");
// debug info [made that conditional -JMarc]
if (lyxerr.debugging(Debug::MATHED))
lyxerr << "[" << yylval.i << "]" << endl;
- plevel--;
+ --plevel;
if (mt) { // && (flags & FLAG_END)) {
mt->SetData(array);
array = 0;
}
case LM_TK_BEGIN:
{
- if (yylval.i==LM_EN_ARRAY) {
+ if (yylval.i == LM_EN_ARRAY) {
char ar[120], ar2[8];
ar[0] = ar2[0] = '\0';
- char rg=LexGetArg(0);
- if (rg==']') {
+ char rg = LexGetArg(0);
+ if (rg == ']') {
strcpy(ar2, yytext);
rg = LexGetArg('{');
}
strcpy(ar, yytext);
int nc = parse_align(ar, ar2);
- MathParInset* mm = new MathMatrixInset(nc, 0);
+ MathParInset * mm = new MathMatrixInset(nc, 0);
mm->SetAlign(ar2[0], ar);
data.Insert(mm, LM_TC_ACTIVE_INSET);
mathed_parse(FLAG_END, mm->GetData(), &mm);
} else
- if (yylval.i>=LM_EN_INTEXT && yylval.i<=LM_EN_EQNARRAY) {
- if (plevel!=0) {
+ if (yylval.i >= LM_EN_INTEXT && yylval.i<= LM_EN_EQNARRAY) {
+ if (plevel!= 0) {
mathPrintError("Misplaced environment");
break;
}
}
mathed_env = yylval.i;
- if (mathed_env>=LM_EN_DISPLAY) {
+ if (mathed_env>= LM_EN_DISPLAY) {
size = LM_ST_DISPLAY;
if (mathed_env>LM_EN_EQUATION) {
mt = new MathMatrixInset(3, -1);
#endif
} else {
// lyxerr << "MATHCRO[" << yytext << "]";
- MathMacro* p =
+ MathMacro * p =
MathMacroTable::mathMTable.getMacro(yytext);
if (p) {
data.Insert(p, p->getTCode());
p->setArgumentIdx(0);
- mathed_parse(FLAG_END, p->GetData(), (MathParInset**)&p);
-// for (int i=0; p->setArgumentIdx(i); i++)
+ mathed_parse(FLAG_END, p->GetData(), reinterpret_cast<MathParInset**>(&p));
+// for (int i = 0; p->setArgumentIdx(i); ++i)
// p->SetData(mathed_parse(FLAG_BRACE|FLAG_BRACE_LAST));
} else
mathPrintError("Unrecognized environment");
case LM_TK_MACRO:
{
- MathedInset* p =
+ MathedInset * p =
MathMacroTable::mathMTable.getMacro(yylval.l->name);
if (p) {
if (accent) {
data.Insert(doAccent(p));
} else
- data.Insert(p, ((MathMacro*)p)->getTCode());
+ data.Insert(p, static_cast<MathMacro*>(p)->getTCode());
}
break;
}
} else
t = yylex ();
- if ((flags & FLAG_BRACE_OPT)/* && t!='^' && t!='_'*/) {
+ if ((flags & FLAG_BRACE_OPT)/* && t!= '^' && t!= '_'*/) {
flags &= ~FLAG_BRACE_OPT;
//data.Insert (LM_TC_CLOSE);
break;
}
}
- plevel--;
+ --plevel;
return array;
}
-void mathed_parser_file(FILE* file, int lineno)
+void mathed_parser_file(istream & is, int lineno)
{
- yyin = file;
+ yyis = &is;
yylineno = lineno;
if (!MathMacroTable::built)
MathMacroTable::mathMTable.builtinMacros();
projects / features.git / blobdiff