Remove another unnecessary assignment

[features.git] / src / mathed / MathParser.cpp

diff --git a/src/mathed/MathParser.cpp b/src/mathed/MathParser.cpp
index 0286ba103c6d197cdb5a2dfef7d58dcd03d0dac8..00f7e99004fb25bf9c469190d27112c16c17567c 100644 (file)
--- a/src/mathed/MathParser.cpp
+++ b/src/mathed/MathParser.cpp
@@ -162,7 +162,7 @@ docstring escapeSpecialChars(docstring const & str, bool textmode)
  * environments like "equation" that have a fixed number of rows.
  */
 bool addRow(InsetMathGrid & grid, InsetMathGrid::row_type & cellrow,
-           docstring const & vskip, bool allow_newpage_ = true)
+           docstring const & vskip, bool allow_newpage = true)
 {
        ++cellrow;
        if (cellrow == grid.nrows()) {
@@ -179,14 +179,14 @@ bool addRow(InsetMathGrid & grid, InsetMathGrid::row_type & cellrow,
                        lyxerr << "ignoring extra row";
                        if (!vskip.empty())
                                lyxerr << " with extra space " << to_utf8(vskip);
-                       if (!allow_newpage_)
+                       if (!allow_newpage)
                                lyxerr << " with no page break allowed";
                        lyxerr << '.' << endl;
                        return false;
                }
        }
        grid.vcrskip(Length(to_utf8(vskip)), cellrow - 1);
-       grid.rowinfo(cellrow - 1).allow_newpage_ = allow_newpage_;
+       grid.rowinfo(cellrow - 1).allow_newpage = allow_newpage;
        return true;
 }
 
@@ -241,7 +241,7 @@ void delEmptyLastRow(InsetMathGrid & grid)
        for (InsetMathGrid::col_type col = 0; col < grid.ncols(); ++col) {
                InsetMathGrid::idx_type const idx = grid.index(row, col);
                if (!grid.cell(idx).empty() ||
-                   grid.cellinfo(idx).multi_ != InsetMathGrid::CELL_NORMAL)
+                   grid.cellinfo(idx).multi != InsetMathGrid::CELL_NORMAL)
                        return;
        }
        // Copy the row information of the empty row (which would contain the
@@ -622,7 +622,7 @@ void Parser::tokenize(istream & is)
 
 void Parser::tokenize(docstring const & buffer)
 {
-       idocstringstream is(mode_ & Parse::VERBATIM
+       idocstringstream is((mode_ & Parse::VERBATIM)
                        ? escapeSpecialChars(buffer, mode_ & Parse::TEXTMODE)
                        : buffer, ios::in | ios::binary);
 
@@ -744,8 +744,9 @@ docstring Parser::parse_verbatim_option()
        skipSpaces();
        docstring res;
        if (nextToken().character() == '[') {
-               Token t = getToken();
-               for (t = getToken(); t.character() != ']' && good(); t = getToken()) {
+               // eat [
+               getToken();
+               for (Token t = getToken(); t.character() != ']' && good(); t = getToken()) {
                        if (t.cat() == catBegin) {
                                putback();
                                res += '{' + parse_verbatim_item() + '}';
@@ -762,8 +763,9 @@ docstring Parser::parse_verbatim_item()
        skipSpaces();
        docstring res;
        if (nextToken().cat() == catBegin) {
-               Token t = getToken();
-               for (t = getToken(); t.cat() != catEnd && good(); t = getToken()) {
+               // eat catBegin
+               getToken();
+               for (Token t = getToken(); t.cat() != catEnd && good(); t = getToken()) {
                        if (t.cat() == catBegin) {
                                putback();
                                res += '{' + parse_verbatim_item() + '}';
@@ -946,13 +948,7 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags,
                        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
-                       // But create a BraceInset if a script follows (#9348)
-                       InsetMathBrace const * mb;
-                       if (ar.size() > 0)
-                               mb = ar[0]->asBraceInset();
-                       if (ar.size() == 1 && (ar[0]->extraBraces()
-                                              || (mb && mb->cell(0).size()
-                                                  && !mb->cell(0)[0].nucleus()->asScriptInset())))
+                       if (ar.size() == 1 && ar[0]->extraBraces())
                                cell->append(ar);
                        else
                                cell->push_back(MathAtom(new InsetMathBrace(ar)));
@@ -1387,20 +1383,20 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags,
                                for (int i = 1; i < cols; ++i) {
                                        if (addCol(grid, cellcol)) {
                                                size_t const idx = grid.index(cellrow, cellcol);
-                                               grid.cellinfo(idx).multi_ =
+                                               grid.cellinfo(idx).multi =
                                                        InsetMathGrid::CELL_PART_OF_MULTICOLUMN;
                                        }
                                }
 
                                // the first cell is the real thing, not a dummy
                                cell = &grid.cell(first);
-                               grid.cellinfo(first).multi_ =
+                               grid.cellinfo(first).multi =
                                        InsetMathGrid::CELL_BEGIN_OF_MULTICOLUMN;
 
                                // read special alignment
                                MathData align;
                                parse(align, FLAG_ITEM, mode);
-                               grid.cellinfo(first).align_ = asString(align);
+                               grid.cellinfo(first).align = asString(align);
 
                                // parse the remaining contents into the "real" cell
                                parse(*cell, FLAG_ITEM, mode);
@@ -1430,7 +1426,7 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags,
                        grid.asHullInset()->numbered(cellrow, true);
 
                else if (t.cs() == "hline") {
-                       grid.rowinfo(cellrow).lines_ ++;
+                       grid.rowinfo(cellrow).lines++;
                }
 
                else if (t.cs() == "sqrt") {
@@ -1610,7 +1606,7 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags,
                                docstring const halign = parse_verbatim_item();
                                cell->push_back(MathAtom(new InsetMathArray(buf, name,
                                        InsetMathGrid::guessColumns(halign), 1, (char)valign[0], halign)));
-                               parse2(cell->back(), FLAG_END, mode, false);
+                               parse2(cell->back(), FLAG_END, InsetMath::MATH_MODE, false);
                        }
 
                        else if (name == "tabular") {
@@ -1991,7 +1987,7 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags,
                                                BufferParams::package_off;
 
                        bool const is_user_macro = no_mhchem ||
-                               (buf && (mode_ & Parse::TRACKMACRO
+                               (buf && ((mode_ & Parse::TRACKMACRO)
                                         ? buf->usermacros.count(t.cs()) != 0
                                         : buf->getMacro(t.cs(), false) != 0));
 
@@ -2087,19 +2083,17 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags,
                                                        Encodings::MATH_CMD | Encodings::TEXT_CMD,
                                                        is_combining, termination);
                                        }
-                                       if (c) {
+                                       if (c && buf && buf->params().encoding().encodable(c)) {
                                                if (termination) {
                                                        if (nextToken().cat() == catBegin) {
                                                                getToken();
                                                                if (nextToken().cat() == catEnd) {
                                                                        getToken();
-                                                                       num_tokens += 2;
                                                                } else
                                                                        putback();
                                                        } else {
                                                                while (nextToken().cat() == catSpace) {
                                                                        getToken();
-                                                                       ++num_tokens;
                                                                }
                                                        }
                                                }
@@ -2140,7 +2134,6 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags,
 
 
                if (flags & FLAG_LEAVE) {
-                       flags &= ~FLAG_LEAVE;
                        break;
                }
        }
@@ -2163,14 +2156,14 @@ char const * latexkeys::MathMLtype() const
 
 bool mathed_parse_cell(MathData & ar, docstring const & str, Parse::flags f)
 {
-       return Parser(str, f, ar.buffer()).parse(ar, 0, f & Parse::TEXTMODE ?
+       return Parser(str, f, ar.buffer()).parse(ar, 0, (f & Parse::TEXTMODE) ?
                                InsetMath::TEXT_MODE : InsetMath::MATH_MODE);
 }
 
 
 bool mathed_parse_cell(MathData & ar, istream & is, Parse::flags f)
 {
-       return Parser(is, f, ar.buffer()).parse(ar, 0, f & Parse::TEXTMODE ?
+       return Parser(is, f, ar.buffer()).parse(ar, 0, (f & Parse::TEXTMODE) ?
                                InsetMath::TEXT_MODE : InsetMath::MATH_MODE);
 }
 
@@ -2192,7 +2185,7 @@ bool mathed_parse_normal(Buffer * buf, MathAtom & t, Lexer & lex,
 bool mathed_parse_normal(InsetMathGrid & grid, docstring const & str,
                         Parse::flags f)
 {
-       return Parser(str, f, &grid.buffer()).parse1(grid, 0, f & Parse::TEXTMODE ?
+       return Parser(str, f, &grid.buffer()).parse1(grid, 0, (f & Parse::TEXTMODE) ?
                        InsetMath::TEXT_MODE : InsetMath::MATH_MODE, false);
 }