---

Parser Class Reference

#include <texparser.h>

List of all members.

Public Types
typedef MathInset::mode_type	mode_type
Public Methods
	Parser (LyXLex &lex)
	Parser (istream &is)
bool	parse (MathAtom &at)
void	parse (MathArray &array, unsigned flags, mode_type mode)
void	parse1 (MathGridInset &grid, unsigned flags, mode_type mode, bool numbered)
MathArray	parse (unsigned flags, mode_type mode)
int	lineno () const
void	putback ()
	Parser (std::istream &is)
	Parser (std::string const &s)
int	lineno () const
void	putback ()
void	dump () const
	dump contents to screen. More...
std::string	getArg (char left, char right)
std::string	getOpt ()
	getArg('[', ']') including the brackets. More...
char	getChar ()
void	error (std::string const &msg)
void	tokenize (std::istream &is)
void	push_back (Token const &t)
void	pop_back ()
Token const &	prev_token () const
Token const &	next_token () const
Token const &	get_token ()
void	skip_spaces ()
	skips spaces if any. More...
void	lex (std::string const &s)
bool	good () const
std::string	verbatim_item ()
std::string	verbatimOption ()
void	setCatCode (char c, CatCode cat)
CatCode	getCatCode (char c) const
Public Attributes
std::vector< Token >	tokens_
Private Methods
void	parse2 (MathAtom &at, unsigned flags, mode_type mode, bool numbered)
string	getArg (char left, char right)
	get arg delimited by 'left' and 'right'. More...
char	getChar ()
void	error (string const &msg)
void	dump () const
	dump contents to screen. More...
void	tokenize (istream &is)
void	tokenize (string const &s)
void	skipSpaceTokens (istream &is, char c)
void	push_back (Token const &t)
void	pop_back ()
Token const &	prevToken () const
Token const &	nextToken () const
Token const &	getToken ()
void	skipSpaces ()
	skips spaces if any. More...
void	lex (string const &s)
bool	good () const
string	parse_verbatim_item ()
string	parse_verbatim_option ()
Private Attributes
int	lineno_
vector< Token >	tokens_
unsigned	pos_

---

Member Typedef Documentation

typedef MathInset::mode_type Parser::mode_type

Definition at line 220 of file math_parser.C.

---

Constructor & Destructor Documentation

Parser::Parser (  LyXLex &    lex )

Definition at line 288 of file math_parser.C. References tokenize. Referenced by operator<<. : lineno_(lexer.getLineNo()), pos_(0) { tokenize(lexer.getStream()); lexer.eatLine(); }

Parser::Parser (  istream &    is )

Definition at line 296 of file math_parser.C. References tokenize. : lineno_(0), pos_(0) { tokenize(is); }

Parser::Parser (  std::istream &    is )

Parser::Parser (  std::string const &    s )

Definition at line 127 of file texparser.C. References tokenize. : lineno_(0), pos_(0) { istringstream is(s); tokenize(is); }

---

Member Function Documentation

void Parser::dump (    )  const

dump contents to screen.

void Parser::dump (    )  const [private]

dump contents to screen. Definition at line 492 of file math_parser.C. References pos_, and tokens_. Referenced by error, parse1, and tokenize. { lyxerr << "\nTokens: "; for (unsigned i = 0; i < tokens_.size(); ++i) { if (i == pos_) lyxerr << " <#> "; lyxerr << tokens_[i]; } lyxerr << " pos: " << pos_ << "\n"; }

void Parser::error (  std::string const &    msg )

void Parser::error (  string const &    msg )  [private]

Definition at line 504 of file math_parser.C. References dump, and lineno_. Referenced by getChar, parse1, parse_math, parse_table, parse_text, tokenize, and verbatim_item. { lyxerr << "Line ~" << lineno_ << ": Math parse error: " << msg << endl; dump(); //exit(1); }

Token const & Parser::get_token (    )

Definition at line 161 of file texparser.C. References good, pos_, and tokens_. Referenced by handle_colalign, handle_comment, handle_tabular, parse_math, parse_preamble, parse_table, parse_text, read_hlines, skip_braces, skip_spaces, verbatim_item, and verbatimOption. { static const Token dummy; //cerr << "looking at token " << tokens_[pos_] << " pos: " << pos_ << '\n'; return good() ? tokens_[pos_++] : dummy; }

std::string Parser::getArg (  char    left, char    right )

string Parser::getArg (  char    left, char    right )  [private]

get arg delimited by 'left' and 'right'. Definition at line 364 of file math_parser.C. References getChar, good, putback, and skipSpaces. Referenced by getOpt, parse1, parse_math, parse_preamble, parse_table, and parse_text. { skipSpaces(); string result; char c = getChar(); if (c != left) putback(); else while ((c = getChar()) != right && good()) result += c; return result; }

CatCode Parser::getCatCode (  char    c )  const

Definition at line 375 of file texparser.C. References theCatcode. { return theCatcode[c]; }

char Parser::getChar (    )

char Parser::getChar (    )  [private]

Definition at line 356 of file math_parser.C. References error, good, pos_, and tokens_. Referenced by getArg. { if (!good()) error("The input stream is not well..."); return tokens_[pos_++].character(); }

string Parser::getOpt (    )

getArg('[', ']') including the brackets. Definition at line 220 of file texparser.C. References getArg. Referenced by handle_tabular, parse_preamble, and parse_text. { string const res = getArg('[', ']'); return res.size() ? '[' + res + ']' : string(); }

Token const & Parser::getToken (    )  [private]

Definition at line 329 of file math_parser.C. References good, pos_, and tokens_. Referenced by parse1, parse_verbatim_item, parse_verbatim_option, and skipSpaces. { static const Token dummy; //lyxerr << "looking at token " << tokens_[pos_] << " pos: " << pos_ << '\n'; return good() ? tokens_[pos_++] : dummy; }

bool Parser::good (    )  const

bool Parser::good (    )  const [private]

Definition at line 350 of file math_parser.C. References pos_, and tokens_. Referenced by get_token, getArg, getChar, getToken, handle_colalign, handle_comment, handle_tabular, next_token, nextToken, parse1, parse_math, parse_preamble, parse_table, parse_text, parse_verbatim_item, parse_verbatim_option, read_hlines, verbatim_item, and verbatimOption. { return pos_ < tokens_.size(); }

void Parser::lex (  std::string const &    s )

void Parser::lex (  string const &    s )  [private]

int Parser::lineno (    )  const [inline]

Definition at line 104 of file texparser.h. References lineno_. { return lineno_; }

int Parser::lineno (    )  const [inline]

Definition at line 237 of file math_parser.C. References lineno_. { return lineno_; }

Token const & Parser::next_token (    )  const

Definition at line 154 of file texparser.C. References good, pos_, and tokens_. Referenced by handle_tabular, parse_preamble, parse_text, read_hlines, skip_braces, skip_spaces, verbatim_item, and verbatimOption. { static const Token dummy; return good() ? tokens_[pos_] : dummy; }

Token const & Parser::nextToken (    )  const [private]

Definition at line 322 of file math_parser.C. References good, pos_, and tokens_. Referenced by parse1, parse_verbatim_item, parse_verbatim_option, and skipSpaces. { static const Token dummy; return good() ? tokens_[pos_] : dummy; }

MathArray Parser::parse (  unsigned    flags, mode_type    mode )

Definition at line 568 of file math_parser.C. References mode_type, and parse. { MathArray ar; parse(ar, flags, mode); return ar; }

void Parser::parse (  MathArray &    array, unsigned    flags, mode_type    mode )

Definition at line 576 of file math_parser.C. References MathNestInset::cell, mode_type, and parse1. { MathGridInset grid(1, 1); parse1(grid, flags, mode, false); array = grid.cell(0); }

bool Parser::parse (  MathAtom &    at )

Definition at line 512 of file math_parser.C. References skipSpaces, and MathInset::UNDECIDED_MODE. Referenced by parse, and parse1. { skipSpaces(); MathArray ar; parse(ar, false, MathInset::UNDECIDED_MODE); if (ar.size() != 1 || ar.front()->getType() == "none") { lyxerr << "unusual contents found: " << ar << endl; at = MathAtom(new MathParInset(ar)); //if (at->nargs() > 0) // at.nucleus()->cell(0) = ar; //else // lyxerr << "unusual contents found: " << ar << endl; return true; } at = ar[0]; return true; }

void Parser::parse1 (  MathGridInset &    grid, unsigned    flags, mode_type    mode, bool    numbered )

Definition at line 591 of file math_parser.C. References MathGridInset::addCol, MathGridInset::addRow, MathArray::append, asArray, MathInset::asHullInset, asMode, Token::asString, lyx::support::atoi, Token::cat, catActive, catAlign, catBegin, catComment, catEnd, catLetter, catMath, catNewline, catOther, catParameter, catSpace, catSub, catSuper, MathInset::cell, MathNestInset::cell, MathGridInset::cellinfo, Token::character, InsetBase::col_type, lyx::count, createMathInset, Token::cs, dump, MathArray::dump, error, latexkeys::extra, extractNumber, FLAG_BRACE_LAST, FLAG_BRACED, FLAG_BRACK_LAST, FLAG_END, FLAG_EQUATION, FLAG_ITEM, FLAG_LEAVE, FLAG_OPTION, FLAG_RIGHT, FLAG_SIMPLE, FLAG_SIMPLE2, getArg, getToken, good, InsetBase::idx_type, in_word_set, MathGridInset::index, latexkeys::inset, isValidLength, MathHullInset::label, MathScriptInset::limits, MathInset::MATH_MODE, MathInset::mode_type, mode_type, MathGridInset::ncols, nextToken, MathGridInset::nrows, MathAtom::nucleus, MathHullInset::numbered, parse, parse2, parse_verbatim_item, parse_verbatim_option, putback, InsetBase::row_type, MathGridInset::rowinfo, skipSpaces, stared, lyx_gui::start, MathInset::TEXT_MODE, MathInset::UNDECIDED_MODE, MathXYArrowInset::up_, and MathGridInset::vcrskip. Referenced by parse, and parse2. { int limits = 0; MathGridInset::row_type cellrow = 0; MathGridInset::col_type cellcol = 0; MathArray * cell = &grid.cell(grid.index(cellrow, cellcol)); if (grid.asHullInset()) grid.asHullInset()->numbered(cellrow, numbered); //dump(); //lyxerr << " flags: " << flags << "\n"; //lyxerr << " mode: " << mode << "\n"; //lyxerr << "grid: " << grid << endl; while (good()) { Token const & t = getToken(); #ifdef FILEDEBUG lyxerr << "t: " << t << " flags: " << flags << "\n"; lyxerr << "mode: " << mode << "\n"; cell->dump(); lyxerr << "\n"; #endif if (flags & FLAG_ITEM) { if (t.cat() == catBegin) { // skip the brace and collect everything to the next matching // closing brace parse1(grid, FLAG_BRACE_LAST, mode, numbered); return; } // handle only this single token, leave the loop if done flags = FLAG_LEAVE; } if (flags & FLAG_BRACED) { if (t.cat() == catSpace) continue; if (t.cat() != catBegin) { error("opening brace expected"); return; } // skip the brace and collect everything to the next matching // closing brace flags = FLAG_BRACE_LAST; } if (flags & FLAG_OPTION) { if (t.cat() == catOther && t.character() == '[') { MathArray ar; parse(ar, FLAG_BRACK_LAST, mode); cell->append(ar); } else { // no option found, put back token and we are done putback(); } return; } // // cat codes // if (t.cat() == catMath) { if (mode != MathInset::MATH_MODE) { // we are inside some text mode thingy, so opening new math is allowed Token const & n = getToken(); if (n.cat() == catMath) { // TeX's $$...$$ syntax for displayed math cell->push_back(MathAtom(new MathHullInset("equation"))); parse2(cell->back(), FLAG_SIMPLE, MathInset::MATH_MODE, false); getToken(); // skip the second '$' token } else { // simple $...$ stuff putback(); cell->push_back(MathAtom(new MathHullInset("simple"))); parse2(cell->back(), FLAG_SIMPLE, MathInset::MATH_MODE, false); } } else if (flags & FLAG_SIMPLE) { // this is the end of the formula return; } else { error("something strange in the parser\n"); break; } } else if (t.cat() == catLetter) cell->push_back(MathAtom(new MathCharInset(t.character()))); else if (t.cat() == catSpace && mode != MathInset::MATH_MODE) { if (cell->empty() || cell->back()->getChar() != ' ') cell->push_back(MathAtom(new MathCharInset(t.character()))); } else if (t.cat() == catNewline && mode != MathInset::MATH_MODE) { if (cell->empty() || cell->back()->getChar() != ' ') cell->push_back(MathAtom(new MathCharInset(' '))); } else if (t.cat() == catParameter) { Token const & n = getToken(); cell->push_back(MathAtom(new MathMacroArgument(n.character()-'0'))); } else if (t.cat() == catActive) cell->push_back(MathAtom(new MathCharInset(t.character()))); else if (t.cat() == catBegin) { MathArray ar; parse(ar, FLAG_BRACE_LAST, mode); // do not create a BraceInset if they were written by LyX // this helps to keep the annoyance of "a choose b" to a minimum if (ar.size() == 1 && ar[0]->extraBraces()) cell->append(ar); else cell->push_back(MathAtom(new MathBraceInset(ar))); } else if (t.cat() == catEnd) { if (flags & FLAG_BRACE_LAST) return; error("found '}' unexpectedly"); //lyx::Assert(0); //add(cell, '}', LM_TC_TEX); } else if (t.cat() == catAlign) { ++cellcol; //lyxerr << " column now " << cellcol << " max: " << grid.ncols() << "\n"; if (cellcol == grid.ncols()) { //lyxerr << "adding column " << cellcol << "\n"; grid.addCol(cellcol - 1); } cell = &grid.cell(grid.index(cellrow, cellcol)); } else if (t.cat() == catSuper || t.cat() == catSub) { bool up = (t.cat() == catSuper); // we need no new script inset if the last thing was a scriptinset, // which has that script already not the same script already if (!cell->size()) cell->push_back(MathAtom(new MathScriptInset(up))); else if (cell->back()->asScriptInset() && !cell->back()->asScriptInset()->has(up)) cell->back().nucleus()->asScriptInset()->ensure(up); else if (cell->back()->asScriptInset()) cell->push_back(MathAtom(new MathScriptInset(up))); else cell->back() = MathAtom(new MathScriptInset(cell->back(), up)); MathScriptInset * p = cell->back().nucleus()->asScriptInset(); // special handling of {}-bases // is this always correct? // It appears that this is wrong (Dekel) //if (p->nuc().size() == 1 && p->nuc().back()->asNestInset() && // p->nuc().back()->extraBraces()) // p->nuc() = p->nuc().back()->asNestInset()->cell(0); parse(p->cell(up), FLAG_ITEM, mode); if (limits) { p->limits(limits); limits = 0; } } else if (t.character() == ']' && (flags & FLAG_BRACK_LAST)) { //lyxerr << "finished reading option\n"; return; } else if (t.cat() == catOther) cell->push_back(MathAtom(new MathCharInset(t.character()))); else if (t.cat() == catComment) { string s; while (good()) { Token const & t = getToken(); if (t.cat() == catNewline) break; s += t.asString(); } cell->push_back(MathAtom(new MathCommentInset(s))); skipSpaces(); } // // control sequences // else if (t.cs() == "lyxlock") { if (cell->size()) cell->back().nucleus()->lock(true); } else if (t.cs() == "def" || t.cs() == "newcommand" || t.cs() == "renewcommand") { string const type = t.cs(); string name; int nargs = 0; if (t.cs() == "def") { // get name name = getToken().cs(); // read parameter string pars; while (good() && nextToken().cat() != catBegin) { pars += getToken().cs(); ++nargs; } nargs /= 2; //lyxerr << "read \\def parameter list '" << pars << "'\n"; } else { // t.cs() == "newcommand" || t.cs() == "renewcommand" if (getToken().cat() != catBegin) { error("'{' in \\newcommand expected (1) \n"); return; } name = getToken().cs(); if (getToken().cat() != catEnd) { error("'}' in \\newcommand expected\n"); return; } string arg = getArg('[', ']'); if (!arg.empty()) nargs = atoi(arg.c_str()); } MathArray ar1; parse(ar1, FLAG_ITEM, MathInset::UNDECIDED_MODE); // we cannot handle recursive stuff at all //MathArray test; //test.push_back(createMathInset(name)); //if (ar1.contains(test)) { // error("we cannot handle recursive macros at all.\n"); // return; //} // is a version for display attached? skipSpaces(); MathArray ar2; if (nextToken().cat() == catBegin) parse(ar2, FLAG_ITEM, MathInset::MATH_MODE); cell->push_back(MathAtom(new MathMacroTemplate(name, nargs, type, ar1, ar2))); } else if (t.cs() == "(") { cell->push_back(MathAtom(new MathHullInset("simple"))); parse2(cell->back(), FLAG_SIMPLE2, MathInset::MATH_MODE, false); } else if (t.cs() == "[") { cell->push_back(MathAtom(new MathHullInset("equation"))); parse2(cell->back(), FLAG_EQUATION, MathInset::MATH_MODE, false); } else if (t.cs() == "protect") // ignore \\protect, will hopefully be re-added during output ; else if (t.cs() == "end") { if (flags & FLAG_END) { // eat environment name //string const name = getArg('{', '}'); // FIXME: check that we ended the correct environment return; } error("found 'end' unexpectedly"); } else if (t.cs() == ")") { if (flags & FLAG_SIMPLE2) return; error("found '\\)' unexpectedly"); } else if (t.cs() == "]") { if (flags & FLAG_EQUATION) return; error("found '\\]' unexpectedly"); } else if (t.cs() == "\\") { grid.vcrskip(LyXLength(getArg('[', ']')), cellrow); ++cellrow; cellcol = 0; if (cellrow == grid.nrows()) grid.addRow(cellrow - 1); if (grid.asHullInset()) grid.asHullInset()->numbered(cellrow, numbered); cell = &grid.cell(grid.index(cellrow, cellcol)); } #if 0 else if (t.cs() == "multicolumn") { // extract column count and insert dummy cells MathArray count; parse(count, FLAG_ITEM, mode); int cols = 1; if (!extractNumber(count, cols)) { lyxerr << " can't extract number of cells from " << count << "\n"; } // resize the table if necessary for (int i = 0; i < cols; ++i) { ++cellcol; if (cellcol == grid.ncols()) { //lyxerr << "adding column " << cellcol << "\n"; grid.addCol(cellcol - 1); } cell = &grid.cell(grid.index(cellrow, cellcol)); // mark this as dummy grid.cellinfo(grid.index(cellrow, cellcol)).dummy_ = true; } // the last cell is the real thng, not a dummy grid.cellinfo(grid.index(cellrow, cellcol)).dummy_ = false; // read special alignment MathArray align; parse(align, FLAG_ITEM, mode); //grid.cellinfo(grid.index(cellrow, cellcol)).align_ = extractString(align); // parse the remaining contents into the "real" cell parse(*cell, FLAG_ITEM, mode); } #endif else if (t.cs() == "limits") limits = 1; else if (t.cs() == "nolimits") limits = -1; else if (t.cs() == "nonumber") { if (grid.asHullInset()) grid.asHullInset()->numbered(cellrow, false); } else if (t.cs() == "number") { if (grid.asHullInset()) grid.asHullInset()->numbered(cellrow, true); } else if (t.cs() == "hline") { grid.rowinfo(cellrow).lines_ ++; } else if (t.cs() == "sqrt") { MathArray ar; parse(ar, FLAG_OPTION, mode); if (ar.size()) { cell->push_back(MathAtom(new MathRootInset)); cell->back().nucleus()->cell(0) = ar; parse(cell->back().nucleus()->cell(1), FLAG_ITEM, mode); } else { cell->push_back(MathAtom(new MathSqrtInset)); parse(cell->back().nucleus()->cell(0), FLAG_ITEM, mode); } } else if (t.cs() == "xrightarrow" || t.cs() == "xleftarrow") { cell->push_back(createMathInset(t.cs())); parse(cell->back().nucleus()->cell(1), FLAG_OPTION, mode); parse(cell->back().nucleus()->cell(0), FLAG_ITEM, mode); } else if (t.cs() == "ref" || t.cs() == "prettyref" || t.cs() == "pageref" || t.cs() == "vpageref" || t.cs() == "vref") { cell->push_back(MathAtom(new RefInset(t.cs()))); parse(cell->back().nucleus()->cell(1), FLAG_OPTION, mode); parse(cell->back().nucleus()->cell(0), FLAG_ITEM, mode); } else if (t.cs() == "left") { skipSpaces(); string l = getToken().asString(); MathArray ar; parse(ar, FLAG_RIGHT, mode); skipSpaces(); string r = getToken().asString(); cell->push_back(MathAtom(new MathDelimInset(l, r, ar))); } else if (t.cs() == "right") { if (flags & FLAG_RIGHT) return; //lyxerr << "got so far: '" << cell << "'\n"; error("Unmatched right delimiter"); return; } else if (t.cs() == "begin") { string const name = getArg('{', '}'); if (name == "array" || name == "subarray") { string const valign = parse_verbatim_option() + 'c'; string const halign = parse_verbatim_item(); cell->push_back(MathAtom(new MathArrayInset(name, valign[0], halign))); parse2(cell->back(), FLAG_END, mode, false); } else if (name == "tabular") { string const valign = parse_verbatim_option() + 'c'; string const halign = parse_verbatim_item(); cell->push_back(MathAtom(new MathTabularInset(name, valign[0], halign))); parse2(cell->back(), FLAG_END, MathInset::TEXT_MODE, false); } else if (name == "split" || name == "cases" || name == "gathered" || name == "aligned") { cell->push_back(createMathInset(name)); parse2(cell->back(), FLAG_END, mode, false); } else if (name == "math") { cell->push_back(MathAtom(new MathHullInset("simple"))); parse2(cell->back(), FLAG_END, MathInset::MATH_MODE, true); } else if (name == "equation" || name == "equation*" || name == "displaymath") { cell->push_back(MathAtom(new MathHullInset("equation"))); parse2(cell->back(), FLAG_END, MathInset::MATH_MODE, (name == "equation")); } else if (name == "eqnarray" || name == "eqnarray*") { cell->push_back(MathAtom(new MathHullInset("eqnarray"))); parse2(cell->back(), FLAG_END, MathInset::MATH_MODE, !stared(name)); } else if (name == "align" || name == "align*") { cell->push_back(MathAtom(new MathHullInset("align"))); parse2(cell->back(), FLAG_END, MathInset::MATH_MODE, !stared(name)); } else if (name == "flalign" || name == "flalign*") { cell->push_back(MathAtom(new MathHullInset("flalign"))); parse2(cell->back(), FLAG_END, MathInset::MATH_MODE, !stared(name)); } else if (name == "alignat" || name == "alignat*") { // ignore this for a while getArg('{', '}'); cell->push_back(MathAtom(new MathHullInset("alignat"))); parse2(cell->back(), FLAG_END, MathInset::MATH_MODE, !stared(name)); } else if (name == "xalignat" || name == "xalignat*") { // ignore this for a while getArg('{', '}'); cell->push_back(MathAtom(new MathHullInset("xalignat"))); parse2(cell->back(), FLAG_END, MathInset::MATH_MODE, !stared(name)); } else if (name == "xxalignat") { // ignore this for a while getArg('{', '}'); cell->push_back(MathAtom(new MathHullInset("xxalignat"))); parse2(cell->back(), FLAG_END, MathInset::MATH_MODE, !stared(name)); } else if (name == "multline" || name == "multline*") { cell->push_back(MathAtom(new MathHullInset("multline"))); parse2(cell->back(), FLAG_END, MathInset::MATH_MODE, !stared(name)); } else if (name == "gather" || name == "gather*") { cell->push_back(MathAtom(new MathHullInset("gather"))); parse2(cell->back(), FLAG_END, MathInset::MATH_MODE, !stared(name)); } else if (latexkeys const * l = in_word_set(name)) { if (l->inset == "matrix") { cell->push_back(createMathInset(name)); parse2(cell->back(), FLAG_END, mode, false); } } else { dump(); lyxerr << "found unknown math environment '" << name << "'\n"; // create generic environment inset cell->push_back(MathAtom(new MathEnvInset(name))); parse(cell->back().nucleus()->cell(0), FLAG_ITEM, mode); } } else if (t.cs() == "kern") { #ifdef WITH_WARNINGS #warning A hack... #endif string s; while (true) { Token const & t = getToken(); if (!good()) { putback(); break; } s += t.character(); if (isValidLength(s)) break; } cell->push_back(MathAtom(new MathKernInset(s))); } else if (t.cs() == "label") { string label = parse_verbatim_item(); MathArray ar; asArray(label, ar); if (grid.asHullInset()) { grid.asHullInset()->label(cellrow, label); } else { cell->push_back(createMathInset(t.cs())); cell->push_back(MathAtom(new MathBraceInset(ar))); } } else if (t.cs() == "choose" || t.cs() == "over" || t.cs() == "atop") { MathAtom at = createMathInset(t.cs()); at.nucleus()->cell(0) = *cell; cell->clear(); parse(at.nucleus()->cell(1), flags, mode); cell->push_back(at); return; } else if (t.cs() == "substack") { cell->push_back(createMathInset(t.cs())); parse2(cell->back(), FLAG_ITEM, mode, false); } else if (t.cs() == "framebox" || t.cs() == "makebox") { cell->push_back(createMathInset(t.cs())); parse(cell->back().nucleus()->cell(0), FLAG_OPTION, MathInset::TEXT_MODE); parse(cell->back().nucleus()->cell(1), FLAG_OPTION, MathInset::TEXT_MODE); parse(cell->back().nucleus()->cell(2), FLAG_ITEM, MathInset::TEXT_MODE); } #if 0 else if (t.cs() == "infer") { MathArray ar; parse(ar, FLAG_OPTION, mode); cell->push_back(createMathInset(t.cs())); parse2(cell->back(), FLAG_ITEM, mode, false); } // Disabled else if (1 && t.cs() == "ar") { MathXYArrowInset * p = new MathXYArrowInset; // try to read target parse(p->cell(0), FLAG_OTPTION, mode); // try to read label if (nextToken().cat() == catSuper || nextToken().cat() == catSub) { p->up_ = nextToken().cat() == catSuper; getToken(); parse(p->cell(1), FLAG_ITEM, mode); //lyxerr << "read label: " << p->cell(1) << "\n"; } cell->push_back(MathAtom(p)); //lyxerr << "read cell: " << cell << "\n"; } #endif else if (t.cs().size()) { latexkeys const * l = in_word_set(t.cs()); if (l) { if (l->inset == "font") { cell->push_back(createMathInset(t.cs()));