octave-nkf: libinterp/parse-tree/lex.ll comparison

comparison libinterp/parse-tree/lex.ll @ 16110:7302f8a4df83

use pointer for global lexical_feedback structure * lex.h, lex.ll (curr_lexer): Rename from lexer_flags. Declare as pointer. Change all uses. * lex.h (lexical_feedback): Make copy constructor and operator= private. * toplev.cc (main_loop): Protect existing and initialize new curr_lexer. * input.cc (get_debug_input): Likewise.

author	John W. Eaton <jwe@octave.org>
date	Tue, 26 Feb 2013 01:10:08 -0500
parents	031117f4db7c
children	3ec4f6488569

comparison

equal deleted inserted replaced

-:229eb14653fd
+:7302f8a4df83
 while (0)
 #define TOK_RETURN(tok) \
 do \
 { \
-lexer_flags.current_input_column += yyleng; \
+curr_lexer->current_input_column += yyleng; \
-lexer_flags.quote_is_transpose = false; \
+curr_lexer->quote_is_transpose = false; \
-lexer_flags.convert_spaces_to_comma = true; \
+curr_lexer->convert_spaces_to_comma = true; \
 COUNT_TOK_AND_RETURN (tok); \
 } \
 while (0)
 #define TOK_PUSH_AND_RETURN(name, tok) \
 do \
 { \
-yylval.tok_val = new token (name, lexer_flags.input_line_number, \
+yylval.tok_val = new token (name, curr_lexer->input_line_number, \
-lexer_flags.current_input_column); \
+curr_lexer->current_input_column); \
 token_stack.push (yylval.tok_val); \
 TOK_RETURN (tok); \
 } \
 while (0)
 #define BIN_OP_RETURN_INTERNAL(tok, convert, bos, qit) \
 do \
 { \
-yylval.tok_val = new token (lexer_flags.input_line_number, \
+yylval.tok_val = new token (curr_lexer->input_line_number, \
-lexer_flags.current_input_column); \
+curr_lexer->current_input_column); \
 token_stack.push (yylval.tok_val); \
-lexer_flags.current_input_column += yyleng; \
+curr_lexer->current_input_column += yyleng; \
-lexer_flags.quote_is_transpose = qit; \
+curr_lexer->quote_is_transpose = qit; \
-lexer_flags.convert_spaces_to_comma = convert; \
+curr_lexer->convert_spaces_to_comma = convert; \
-lexer_flags.looking_for_object_index = false; \
+curr_lexer->looking_for_object_index = false; \
-lexer_flags.at_beginning_of_statement = bos; \
+curr_lexer->at_beginning_of_statement = bos; \
 COUNT_TOK_AND_RETURN (tok); \
 } \
 while (0)
 #define XBIN_OP_RETURN_INTERNAL(tok, convert, bos, qit) \
 lexer_debug (pattern, yytext); \
 } \
 while (0)
 // The state of the lexer.
-lexical_feedback lexer_flags;
+lexical_feedback *curr_lexer = 0;
 // Stack to hold tokens so that we can delete them when the parser is
 // reset and avoid growing forever just because we are stashing some
 // information.  This has to appear before lex.h is included, because
 // one of the macros defined there uses token_stack.
 <COMMAND_START>{NL} {
 LEXER_DEBUG ("<COMMAND_START>{NL}");
 BEGIN (INITIAL);
-lexer_flags.input_line_number++;
+curr_lexer->input_line_number++;
-lexer_flags.current_input_column = 1;
+curr_lexer->current_input_column = 1;
-lexer_flags.quote_is_transpose = false;
+curr_lexer->quote_is_transpose = false;
-lexer_flags.convert_spaces_to_comma = true;
+curr_lexer->convert_spaces_to_comma = true;
-lexer_flags.looking_for_object_index = false;
+curr_lexer->looking_for_object_index = false;
-lexer_flags.at_beginning_of_statement = true;
+curr_lexer->at_beginning_of_statement = true;
 COUNT_TOK_AND_RETURN ('\n');
 }
 <COMMAND_START>[\;\,] {
 LEXER_DEBUG ("<COMMAND_START>[\\;\\,]");
-lexer_flags.looking_for_object_index = false;
+curr_lexer->looking_for_object_index = false;
-lexer_flags.at_beginning_of_statement = true;
+curr_lexer->at_beginning_of_statement = true;
 BEGIN (INITIAL);
 if (strcmp (yytext, ",") == 0)
 TOK_RETURN (',');
 }
 <COMMAND_START>[\"\'] {
 LEXER_DEBUG ("<COMMAND_START>[\\\"\\']");
-lexer_flags.at_beginning_of_statement = false;
+curr_lexer->at_beginning_of_statement = false;
-lexer_flags.current_input_column++;
+curr_lexer->current_input_column++;
 int tok = handle_string (yytext[0]);
 COUNT_TOK_AND_RETURN (tok);
 }
 <COMMAND_START>[^#% \t\r\n\;\,\"\'][^ \t\r\n\;\,]*{S}* {
 LEXER_DEBUG ("<COMMAND_START>[^#% \\t\\r\\n\\;\\,\\\"\\'][^ \\t\\r\\n\\;\\,]*{S}*");
 std::string tok = strip_trailing_whitespace (yytext);
-lexer_flags.looking_for_object_index = false;
+curr_lexer->looking_for_object_index = false;
-lexer_flags.at_beginning_of_statement = false;
+curr_lexer->at_beginning_of_statement = false;
 TOK_PUSH_AND_RETURN (tok, SQ_STRING);
 }
 %{
 LEXER_DEBUG ("<MATRIX_START>{SNLCMT}*\\]{S}*");
 scan_for_comments (yytext);
 fixup_column_count (yytext);
-lexer_flags.looking_at_object_index.pop_front ();
+curr_lexer->looking_at_object_index.pop_front ();
-lexer_flags.looking_for_object_index = true;
+curr_lexer->looking_for_object_index = true;
-lexer_flags.at_beginning_of_statement = false;
+curr_lexer->at_beginning_of_statement = false;
 int c = yytext[yyleng-1];
 bool cont_is_spc = (eat_continuation () != lexical_feedback::NO_WHITESPACE);
 bool spc_gobbled = (cont_is_spc || c == ' ' || c == '\t');
 int tok_to_return = handle_close_bracket (spc_gobbled, ']');
 LEXER_DEBUG ("<MATRIX_START>{SNLCMT}*\\}{S}*");
 scan_for_comments (yytext);
 fixup_column_count (yytext);
-lexer_flags.looking_at_object_index.pop_front ();
+curr_lexer->looking_at_object_index.pop_front ();
-lexer_flags.looking_for_object_index = true;
+curr_lexer->looking_for_object_index = true;
-lexer_flags.at_beginning_of_statement = false;
+curr_lexer->at_beginning_of_statement = false;
 int c = yytext[yyleng-1];
 bool cont_is_spc = (eat_continuation () != lexical_feedback::NO_WHITESPACE);
 bool spc_gobbled = (cont_is_spc || c == ' ' || c == '\t');
 int tok_to_return = handle_close_bracket (spc_gobbled, '}');
 %}
 <MATRIX_START>{S}*\,{S}* {
 LEXER_DEBUG ("<MATRIX_START>{S}*\\,{S}*");
-lexer_flags.current_input_column += yyleng;
+curr_lexer->current_input_column += yyleng;
 int tmp = eat_continuation ();
-lexer_flags.quote_is_transpose = false;
+curr_lexer->quote_is_transpose = false;
-lexer_flags.convert_spaces_to_comma = true;
+curr_lexer->convert_spaces_to_comma = true;
-lexer_flags.looking_for_object_index = false;
+curr_lexer->looking_for_object_index = false;
-lexer_flags.at_beginning_of_statement = false;
+curr_lexer->at_beginning_of_statement = false;
-if (! lexer_flags.looking_at_object_index.front ())
+if (! curr_lexer->looking_at_object_index.front ())
 {
 if ((tmp & lexical_feedback::NEWLINE) == lexical_feedback::NEWLINE)
 {
 maybe_warn_separator_insert (';');
 %}
 <MATRIX_START>{S}+ {
 LEXER_DEBUG ("<MATRIX_START>{S}+");
-lexer_flags.current_input_column += yyleng;
+curr_lexer->current_input_column += yyleng;
-lexer_flags.at_beginning_of_statement = false;
+curr_lexer->at_beginning_of_statement = false;
 int tmp = eat_continuation ();
-if (! lexer_flags.looking_at_object_index.front ())
+if (! curr_lexer->looking_at_object_index.front ())
 {
 bool bin_op = next_token_is_bin_op (true);
 bool postfix_un_op = next_token_is_postfix_unary_op (true);
 bool sep_op = next_token_is_sep_op ();
 if (! (postfix_un_op || bin_op || sep_op)
-&& lexer_flags.nesting_level.is_bracket_or_brace ()
+&& curr_lexer->nesting_level.is_bracket_or_brace ()
-&& lexer_flags.convert_spaces_to_comma)
+&& curr_lexer->convert_spaces_to_comma)
 {
 if ((tmp & lexical_feedback::NEWLINE) == lexical_feedback::NEWLINE)
 {
 maybe_warn_separator_insert (';');
 xunput (';', yytext);
 }
-lexer_flags.quote_is_transpose = false;
+curr_lexer->quote_is_transpose = false;
-lexer_flags.convert_spaces_to_comma = true;
+curr_lexer->convert_spaces_to_comma = true;
-lexer_flags.looking_for_object_index = false;
+curr_lexer->looking_for_object_index = false;
 maybe_warn_separator_insert (',');
 COUNT_TOK_AND_RETURN (',');
 }
 scan_for_comments (yytext);
 fixup_column_count (yytext);
 eat_whitespace ();
-lexer_flags.quote_is_transpose = false;
+curr_lexer->quote_is_transpose = false;
-lexer_flags.convert_spaces_to_comma = true;
+curr_lexer->convert_spaces_to_comma = true;
-lexer_flags.looking_for_object_index = false;
+curr_lexer->looking_for_object_index = false;
-lexer_flags.at_beginning_of_statement = false;
+curr_lexer->at_beginning_of_statement = false;
 COUNT_TOK_AND_RETURN (';');
 }
 %{
 scan_for_comments (yytext);
 fixup_column_count (yytext);
 eat_whitespace ();
-lexer_flags.quote_is_transpose = false;
+curr_lexer->quote_is_transpose = false;
-lexer_flags.convert_spaces_to_comma = true;
+curr_lexer->convert_spaces_to_comma = true;
-lexer_flags.at_beginning_of_statement = false;
+curr_lexer->at_beginning_of_statement = false;
-if (lexer_flags.nesting_level.none ())
+if (curr_lexer->nesting_level.none ())
 return LEXICAL_ERROR;
-if (! lexer_flags.looking_at_object_index.front ()
+if (! curr_lexer->looking_at_object_index.front ()
-&& lexer_flags.nesting_level.is_bracket_or_brace ())
+&& curr_lexer->nesting_level.is_bracket_or_brace ())
 {
 maybe_warn_separator_insert (';');
 COUNT_TOK_AND_RETURN (';');
 }
 }
 \[{S}* {
 LEXER_DEBUG ("\\[{S}*");
-lexer_flags.nesting_level.bracket ();
+curr_lexer->nesting_level.bracket ();
-lexer_flags.looking_at_object_index.push_front (false);
+curr_lexer->looking_at_object_index.push_front (false);
-lexer_flags.current_input_column += yyleng;
+curr_lexer->current_input_column += yyleng;
-lexer_flags.quote_is_transpose = false;
+curr_lexer->quote_is_transpose = false;
-lexer_flags.convert_spaces_to_comma = true;
+curr_lexer->convert_spaces_to_comma = true;
-lexer_flags.looking_for_object_index = false;
+curr_lexer->looking_for_object_index = false;
-lexer_flags.at_beginning_of_statement = false;
+curr_lexer->at_beginning_of_statement = false;
-if (lexer_flags.defining_func
+if (curr_lexer->defining_func
-&& ! lexer_flags.parsed_function_name.top ())
+&& ! curr_lexer->parsed_function_name.top ())
-lexer_flags.looking_at_return_list = true;
+curr_lexer->looking_at_return_list = true;
 else
-lexer_flags.looking_at_matrix_or_assign_lhs = true;
+curr_lexer->looking_at_matrix_or_assign_lhs = true;
 promptflag--;
 eat_whitespace ();
-lexer_flags.bracketflag++;
+curr_lexer->bracketflag++;
 BEGIN (MATRIX_START);
 COUNT_TOK_AND_RETURN ('[');
 }
 \] {
 LEXER_DEBUG ("\\]");
-lexer_flags.nesting_level.remove ();
+curr_lexer->nesting_level.remove ();
-lexer_flags.looking_at_object_index.pop_front ();
+curr_lexer->looking_at_object_index.pop_front ();
-lexer_flags.looking_for_object_index = true;
+curr_lexer->looking_for_object_index = true;
-lexer_flags.at_beginning_of_statement = false;
+curr_lexer->at_beginning_of_statement = false;
 TOK_RETURN (']');
 }
 %{
 // Eat whitespace.  Whitespace inside matrix constants is handled by
 // the <MATRIX_START> start state code above.
 %}
 {S}* {
-lexer_flags.current_input_column += yyleng;
+curr_lexer->current_input_column += yyleng;
 }
 %{
 // Continuation lines.  Allow comments after continuations.
 %}
 if (yytext[0] == '\\')
 gripe_matlab_incompatible_continuation ();
 scan_for_comments (yytext);
 promptflag--;
-lexer_flags.input_line_number++;
+curr_lexer->input_line_number++;
-lexer_flags.current_input_column = 1;
+curr_lexer->current_input_column = 1;
 }
 %{
 // End of file.
 %}
 <<EOF>> {
 LEXER_DEBUG ("<<EOF>>");
-if (lexer_flags.block_comment_nesting_level != 0)
+if (curr_lexer->block_comment_nesting_level != 0)
 {
 warning ("block comment open at end of input");
 if ((reading_fcn_file || reading_script_file || reading_classdef_file)
 && ! curr_fcn_file_name.empty ())
 warning ("near line %d of file '%s.m'",
-lexer_flags.input_line_number, curr_fcn_file_name.c_str ());
+curr_lexer->input_line_number, curr_fcn_file_name.c_str ());
 }
 TOK_RETURN (END_OF_INPUT);
 }
 int id_tok = handle_superclass_identifier ();
 if (id_tok >= 0)
 {
-lexer_flags.looking_for_object_index = true;
+curr_lexer->looking_for_object_index = true;
 COUNT_TOK_AND_RETURN (SUPERCLASSREF);
 }
 }
 int id_tok = handle_meta_identifier ();
 if (id_tok >= 0)
 {
-lexer_flags.looking_for_object_index = true;
+curr_lexer->looking_for_object_index = true;
 COUNT_TOK_AND_RETURN (METAQUERY);
 }
 }
 %}
 "@" {
 LEXER_DEBUG ("@");
-lexer_flags.current_input_column++;
+curr_lexer->current_input_column++;
-lexer_flags.quote_is_transpose = false;
+curr_lexer->quote_is_transpose = false;
-lexer_flags.convert_spaces_to_comma = false;
+curr_lexer->convert_spaces_to_comma = false;
-lexer_flags.looking_at_function_handle++;
+curr_lexer->looking_at_function_handle++;
-lexer_flags.looking_for_object_index = false;
+curr_lexer->looking_for_object_index = false;
-lexer_flags.at_beginning_of_statement = false;
+curr_lexer->at_beginning_of_statement = false;
 COUNT_TOK_AND_RETURN ('@');
 }
 %}
 {NL} {
 LEXER_DEBUG ("{NL}");
-lexer_flags.input_line_number++;
+curr_lexer->input_line_number++;
-lexer_flags.current_input_column = 1;
+curr_lexer->current_input_column = 1;
-lexer_flags.quote_is_transpose = false;
+curr_lexer->quote_is_transpose = false;
-lexer_flags.convert_spaces_to_comma = true;
+curr_lexer->convert_spaces_to_comma = true;
-if (lexer_flags.nesting_level.none ())
+if (curr_lexer->nesting_level.none ())
 {
-lexer_flags.at_beginning_of_statement = true;
+curr_lexer->at_beginning_of_statement = true;
 COUNT_TOK_AND_RETURN ('\n');
 }
-else if (lexer_flags.nesting_level.is_paren ())
+else if (curr_lexer->nesting_level.is_paren ())
 {
-lexer_flags.at_beginning_of_statement = false;
+curr_lexer->at_beginning_of_statement = false;
 gripe_matlab_incompatible ("bare newline inside parentheses");
 }
-else if (lexer_flags.nesting_level.is_bracket_or_brace ())
+else if (curr_lexer->nesting_level.is_bracket_or_brace ())
 return LEXICAL_ERROR;
 }
 %{
 // Single quote can either be the beginning of a string or a transpose
 %}
 "'" {
 LEXER_DEBUG ("'");
-lexer_flags.current_input_column++;
+curr_lexer->current_input_column++;
-lexer_flags.convert_spaces_to_comma = true;
+curr_lexer->convert_spaces_to_comma = true;
-if (lexer_flags.quote_is_transpose)
+if (curr_lexer->quote_is_transpose)
 {
 do_comma_insert_check ();
 COUNT_TOK_AND_RETURN (QUOTE);
 }
 else
 %}
 \" {
 LEXER_DEBUG ("\"");
-lexer_flags.current_input_column++;
+curr_lexer->current_input_column++;
 int tok = handle_string ('"');
 COUNT_TOK_AND_RETURN (tok);
 }
 %}
 {CCHAR} {
 LEXER_DEBUG ("{CCHAR}");
-lexer_flags.looking_for_object_index = false;
+curr_lexer->looking_for_object_index = false;
 xunput (yytext[0], yytext);
 bool eof = false;
 int tok = process_comment (false, eof);
 %}
 ^{S}*{CCHAR}\{{S}*{NL} {
 LEXER_DEBUG ("^{S}*{CCHAR}\\{{S}*{NL}");
-lexer_flags.looking_for_object_index = false;
+curr_lexer->looking_for_object_index = false;
-lexer_flags.input_line_number++;
+curr_lexer->input_line_number++;
-lexer_flags.current_input_column = 1;
+curr_lexer->current_input_column = 1;
-lexer_flags.block_comment_nesting_level++;
+curr_lexer->block_comment_nesting_level++;
 promptflag--;
 bool eof = false;
 process_comment (true, eof);
 }
 "-"     { LEXER_DEBUG ("-"); BIN_OP_RETURN ('-', false, false); }
 "*"     { LEXER_DEBUG ("*"); BIN_OP_RETURN ('*', false, false); }
 "/"     { LEXER_DEBUG ("/"); BIN_OP_RETURN ('/', false, false); }
 "\\"    { LEXER_DEBUG ("\\"); BIN_OP_RETURN (LEFTDIV, false, false); }
 ";"     { LEXER_DEBUG (";"); BIN_OP_RETURN (';', true, true); }
-","     { LEXER_DEBUG (","); BIN_OP_RETURN (',', true, ! lexer_flags.looking_at_object_index.front ()); }
+","     { LEXER_DEBUG (","); BIN_OP_RETURN (',', true, ! curr_lexer->looking_at_object_index.front ()); }
 "^"     { LEXER_DEBUG ("^"); BIN_OP_RETURN (POW, false, false); }
 "**"    { LEXER_DEBUG ("**"); XBIN_OP_RETURN (POW, false, false); }
 "="     { LEXER_DEBUG ("="); BIN_OP_RETURN ('=', true, false); }
 "&&"    { LEXER_DEBUG ("&&"); BIN_OP_RETURN (EXPR_AND_AND, false, false); }
 "||"    { LEXER_DEBUG ("||"); BIN_OP_RETURN (EXPR_OR_OR, false, false); }
 // If we are looking for an object index, then push TRUE for
 // looking_at_object_index.  Otherwise, just push whatever state
 // is current (so that we can pop it off the stack when we find
 // the matching close paren).
-lexer_flags.looking_at_object_index.push_front
+curr_lexer->looking_at_object_index.push_front
-(lexer_flags.looking_for_object_index);
+(curr_lexer->looking_for_object_index);
-lexer_flags.looking_at_indirect_ref = false;
+curr_lexer->looking_at_indirect_ref = false;
-lexer_flags.looking_for_object_index = false;
+curr_lexer->looking_for_object_index = false;
-lexer_flags.at_beginning_of_statement = false;
+curr_lexer->at_beginning_of_statement = false;
-lexer_flags.nesting_level.paren ();
+curr_lexer->nesting_level.paren ();
 promptflag--;
 TOK_RETURN ('(');
 }
 ")" {
 LEXER_DEBUG (")");
-lexer_flags.nesting_level.remove ();
+curr_lexer->nesting_level.remove ();
-lexer_flags.current_input_column++;
+curr_lexer->current_input_column++;
-lexer_flags.looking_at_object_index.pop_front ();
+curr_lexer->looking_at_object_index.pop_front ();
-lexer_flags.quote_is_transpose = true;
+curr_lexer->quote_is_transpose = true;
-lexer_flags.convert_spaces_to_comma
+curr_lexer->convert_spaces_to_comma
-= (lexer_flags.nesting_level.is_bracket_or_brace ()
+= (curr_lexer->nesting_level.is_bracket_or_brace ()
-&& ! lexer_flags.looking_at_anon_fcn_args);
+&& ! curr_lexer->looking_at_anon_fcn_args);
-lexer_flags.looking_for_object_index = true;
+curr_lexer->looking_for_object_index = true;
-lexer_flags.at_beginning_of_statement = false;
+curr_lexer->at_beginning_of_statement = false;
-if (lexer_flags.looking_at_anon_fcn_args)
+if (curr_lexer->looking_at_anon_fcn_args)
-lexer_flags.looking_at_anon_fcn_args = false;
+curr_lexer->looking_at_anon_fcn_args = false;
 do_comma_insert_check ();
 COUNT_TOK_AND_RETURN (')');
 }
 "." {
 LEXER_DEBUG (".");
-lexer_flags.looking_for_object_index = false;
+curr_lexer->looking_for_object_index = false;
-lexer_flags.at_beginning_of_statement = false;
+curr_lexer->at_beginning_of_statement = false;
 TOK_RETURN ('.');
 }
 "+="    { LEXER_DEBUG ("+="); XBIN_OP_RETURN (ADD_EQ, false, false); }
 ">>="   { LEXER_DEBUG (">>="); XBIN_OP_RETURN (RSHIFT_EQ, false, false); }
 \{{S}* {
 LEXER_DEBUG ("\\{{S}*");
-lexer_flags.nesting_level.brace ();
+curr_lexer->nesting_level.brace ();
-lexer_flags.looking_at_object_index.push_front
+curr_lexer->looking_at_object_index.push_front
-(lexer_flags.looking_for_object_index);
+(curr_lexer->looking_for_object_index);
-lexer_flags.current_input_column += yyleng;
+curr_lexer->current_input_column += yyleng;
-lexer_flags.quote_is_transpose = false;
+curr_lexer->quote_is_transpose = false;
-lexer_flags.convert_spaces_to_comma = true;
+curr_lexer->convert_spaces_to_comma = true;
-lexer_flags.looking_for_object_index = false;
+curr_lexer->looking_for_object_index = false;
-lexer_flags.at_beginning_of_statement = false;
+curr_lexer->at_beginning_of_statement = false;
 promptflag--;
 eat_whitespace ();
-lexer_flags.braceflag++;
+curr_lexer->braceflag++;
 BEGIN (MATRIX_START);
 COUNT_TOK_AND_RETURN ('{');
 }
 "}" {
 LEXER_DEBUG ("}");
-lexer_flags.looking_at_object_index.pop_front ();
+curr_lexer->looking_at_object_index.pop_front ();
-lexer_flags.looking_for_object_index = true;
+curr_lexer->looking_for_object_index = true;
-lexer_flags.at_beginning_of_statement = false;
+curr_lexer->at_beginning_of_statement = false;
-lexer_flags.nesting_level.remove ();
+curr_lexer->nesting_level.remove ();
 TOK_RETURN ('}');
 }
 %{
 int c = text_yyinput ();
 if (c != EOF)
 {
-lexer_flags.current_input_column++;
+curr_lexer->current_input_column++;
 error ("invalid character '%s' (ASCII %d) near line %d, column %d",
 undo_string_escape (static_cast<char> (c)), c,
-lexer_flags.input_line_number, lexer_flags.current_input_column);
+curr_lexer->input_line_number, curr_lexer->current_input_column);
 return LEXICAL_ERROR;
 }
 else
 TOK_RETURN (END_OF_INPUT);
 xunput (c, yytext);
 if (spc_gobbled)
 xunput (' ', yytext);
-lexer_flags.do_comma_insert = (! lexer_flags.looking_at_object_index.front ()
+curr_lexer->do_comma_insert = (! curr_lexer->looking_at_object_index.front ()
-&& lexer_flags.bracketflag && c == '[');
+&& curr_lexer->bracketflag && c == '[');
 }
 // Fix things up for errors or interrupts.  The parser is never called
 // recursively, so it is always safe to reinitialize its state before
 // doing any parsing.
 yyrestart (stdin);
 // Clear the buffer for help text.
 while (! help_buf.empty ())
 help_buf.pop ();
-// Reset other flags.
-lexer_flags = lexical_feedback ();
 }
 static void
 display_character (char c)
 {
 c = '\n';
 }
 }
 if (c == '\n')
-lexer_flags.input_line_number++;
+curr_lexer->input_line_number++;
 return c;
 }
 static void
 display_character (c);
 std::cerr << std::endl;
 }
 if (c == '\n')
-lexer_flags.input_line_number--;
+curr_lexer->input_line_number--;
 yyunput (c, buf);
 }
 // If we read some newlines, we need figure out what column we're
 char c;
 while ((c = *s++) != '\0')
 {
 if (c == '\n')
 {
-lexer_flags.input_line_number++;
+curr_lexer->input_line_number++;
-lexer_flags.current_input_column = 1;
+curr_lexer->current_input_column = 1;
 }
 else
-lexer_flags.current_input_column++;
+curr_lexer->current_input_column++;
 }
 }
 // Include these so that we don't have to link to libfl.a.
 static bool
 inside_any_object_index (void)
 {
 bool retval = false;
-for (std::list<bool>::const_iterator i = lexer_flags.looking_at_object_index.begin ();
+for (std::list<bool>::const_iterator i = curr_lexer->looking_at_object_index.begin ();
-i != lexer_flags.looking_at_object_index.end (); i++)
+i != curr_lexer->looking_at_object_index.end (); i++)
 {
 if (*i)
 {
 retval = true;
 break;
 // Handle keywords.  Return -1 if the keyword should be ignored.
 static int
 is_keyword_token (const std::string& s)
 {
-int l = lexer_flags.input_line_number;
+int l = curr_lexer->input_line_number;
-int c = lexer_flags.current_input_column;
+int c = curr_lexer->current_input_column;
 int len = s.length ();
 const octave_kw *kw = octave_kw_hash::in_word_set (s.c_str (), len);
 case continue_kw:
 case else_kw:
 case otherwise_kw:
 case return_kw:
 case unwind_protect_cleanup_kw:
-lexer_flags.at_beginning_of_statement = true;
+curr_lexer->at_beginning_of_statement = true;
 break;
 case static_kw:
 if ((reading_fcn_file || reading_script_file
 || reading_classdef_file)
 && ! curr_fcn_file_full_name.empty ())
 warning_with_id ("Octave:deprecated-keyword",
 "the 'static' keyword is obsolete and will be removed from a future version of Octave; please use 'persistent' instead; near line %d of file '%s'",
-lexer_flags.input_line_number,
+curr_lexer->input_line_number,
 curr_fcn_file_full_name.c_str ());
 else
 warning_with_id ("Octave:deprecated-keyword",
 "the 'static' keyword is obsolete and will be removed from a future version of Octave; please use 'persistent' instead; near line %d",
-lexer_flags.input_line_number);
+curr_lexer->input_line_number);
 // fall through ...
 case persistent_kw:
 break;
 break;
 case end_kw:
 if (inside_any_object_index ()
 || (! reading_classdef_file
-&& (lexer_flags.defining_func
+&& (curr_lexer->defining_func
-&& ! (lexer_flags.looking_at_return_list
+&& ! (curr_lexer->looking_at_return_list
-|| lexer_flags.parsed_function_name.top ()))))
+|| curr_lexer->parsed_function_name.top ()))))
 return 0;
 yylval.tok_val = new token (token::simple_end, l, c);
-lexer_flags.at_beginning_of_statement = true;
+curr_lexer->at_beginning_of_statement = true;
 break;
 case end_try_catch_kw:
 yylval.tok_val = new token (token::try_catch_end, l, c);
-lexer_flags.at_beginning_of_statement = true;
+curr_lexer->at_beginning_of_statement = true;
 break;
 case end_unwind_protect_kw:
 yylval.tok_val = new token (token::unwind_protect_end, l, c);
-lexer_flags.at_beginning_of_statement = true;
+curr_lexer->at_beginning_of_statement = true;
 break;
 case endfor_kw:
 yylval.tok_val = new token (token::for_end, l, c);
-lexer_flags.at_beginning_of_statement = true;
+curr_lexer->at_beginning_of_statement = true;
 break;
 case endfunction_kw:
 yylval.tok_val = new token (token::function_end, l, c);
-lexer_flags.at_beginning_of_statement = true;
+curr_lexer->at_beginning_of_statement = true;
 break;
 case endif_kw:
 yylval.tok_val = new token (token::if_end, l, c);
-lexer_flags.at_beginning_of_statement = true;
+curr_lexer->at_beginning_of_statement = true;
 break;
 case endparfor_kw:
 yylval.tok_val = new token (token::parfor_end, l, c);
-lexer_flags.at_beginning_of_statement = true;
+curr_lexer->at_beginning_of_statement = true;
 break;
 case endswitch_kw:
 yylval.tok_val = new token (token::switch_end, l, c);
-lexer_flags.at_beginning_of_statement = true;
+curr_lexer->at_beginning_of_statement = true;
 break;
 case endwhile_kw:
 yylval.tok_val = new token (token::while_end, l, c);
-lexer_flags.at_beginning_of_statement = true;
+curr_lexer->at_beginning_of_statement = true;
 break;
 case endclassdef_kw:
 yylval.tok_val = new token (token::classdef_end, l, c);
-lexer_flags.at_beginning_of_statement = true;
+curr_lexer->at_beginning_of_statement = true;
 break;
 case endenumeration_kw:
 yylval.tok_val = new token (token::enumeration_end, l, c);
-lexer_flags.at_beginning_of_statement = true;
+curr_lexer->at_beginning_of_statement = true;
 break;
 case endevents_kw:
 yylval.tok_val = new token (token::events_end, l, c);
-lexer_flags.at_beginning_of_statement = true;
+curr_lexer->at_beginning_of_statement = true;
 break;
 case endmethods_kw:
 yylval.tok_val = new token (token::methods_end, l, c);
-lexer_flags.at_beginning_of_statement = true;
+curr_lexer->at_beginning_of_statement = true;
 break;
 case endproperties_kw:
 yylval.tok_val = new token (token::properties_end, l, c);
-lexer_flags.at_beginning_of_statement = true;
+curr_lexer->at_beginning_of_statement = true;
 break;
 case for_kw:
 case parfor_kw:
 case while_kw:
 promptflag--;
-lexer_flags.looping++;
+curr_lexer->looping++;
 break;
 case do_kw:
-lexer_flags.at_beginning_of_statement = true;
+curr_lexer->at_beginning_of_statement = true;
 promptflag--;
-lexer_flags.looping++;
+curr_lexer->looping++;
 break;
 case try_kw:
 case unwind_protect_kw:
-lexer_flags.at_beginning_of_statement = true;
+curr_lexer->at_beginning_of_statement = true;
 promptflag--;
 break;
 case if_kw:
 case switch_kw:
 case get_kw:
 case set_kw:
 // 'get' and 'set' are keywords in classdef method
 // declarations.
-if (! lexer_flags.maybe_classdef_get_set_method)
+if (! curr_lexer->maybe_classdef_get_set_method)
 return 0;
 break;
 case enumeration_kw:
 case events_kw:
 case methods_kw:
 case properties_kw:
 // 'properties', 'methods' and 'events' are keywords for
 // classdef blocks.
-if (! lexer_flags.parsing_classdef)
+if (! curr_lexer->parsing_classdef)
 return 0;
 // fall through ...
 case classdef_kw:
 // 'classdef' is always a keyword.
 break;
 case function_kw:
 promptflag--;
-lexer_flags.defining_func++;
+curr_lexer->defining_func++;
-lexer_flags.parsed_function_name.push (false);
+curr_lexer->parsed_function_name.push (false);
 if (! (reading_fcn_file || reading_script_file
 || reading_classdef_file))
-lexer_flags.input_line_number = 1;
+curr_lexer->input_line_number = 1;
 break;
 case magic_file_kw:
 {
 if ((reading_fcn_file || reading_script_file
 static bool
 is_variable (const std::string& name)
 {
 return (symbol_table::is_variable (name)
-|| (lexer_flags.pending_local_variables.find (name)
+|| (curr_lexer->pending_local_variables.find (name)
-!= lexer_flags.pending_local_variables.end ()));
+!= curr_lexer->pending_local_variables.end ()));
 }
 static std::string
 grab_block_comment (stream_reader& reader, bool& eof)
 {
 int c = 0;
 while ((c = reader.getc ()) != EOF)
 {
-lexer_flags.current_input_column++;
+curr_lexer->current_input_column++;
 if (look_for_marker)
 {
 at_bol = false;
 look_for_marker = false;
 bool done = false;
 while ((c = reader.getc ()) != EOF && ! done)
 {
-lexer_flags.current_input_column++;
+curr_lexer->current_input_column++;
 switch (c)
 {
 case ' ':
 case '\t':
 tmp_buf += static_cast<char> (c);
 break;
 case '\n':
 {
-lexer_flags.current_input_column = 0;
+curr_lexer->current_input_column = 0;
 at_bol = true;
 done = true;
 if (type == '{')
 {
-lexer_flags.block_comment_nesting_level++;
+curr_lexer->block_comment_nesting_level++;
 promptflag--;
 }
 else
 {
-lexer_flags.block_comment_nesting_level--;
+curr_lexer->block_comment_nesting_level--;
 promptflag++;
-if (lexer_flags.block_comment_nesting_level == 0)
+if (curr_lexer->block_comment_nesting_level == 0)
 {
 buf += grab_comment_block (reader, true, eof);
 return buf;
 }
 {
 buf += static_cast<char> (c);
 if (c == '\n')
 {
-lexer_flags.current_input_column = 0;
+curr_lexer->current_input_column = 0;
 at_bol = true;
 }
 }
 }
 int c = 0;
 while ((c = reader.getc ()) != EOF)
 {
-lexer_flags.current_input_column++;
+curr_lexer->current_input_column++;
 if (begin_comment)
 {
 if (c == '%' || c == '#')
 {
 bool done = false;
 while ((c = reader.getc ()) != EOF && ! done)
 {
-lexer_flags.current_input_column++;
+curr_lexer->current_input_column++;
 switch (c)
 {
 case ' ':
 case '\t':
 tmp_buf += static_cast<char> (c);
 break;
 case '\n':
 {
-lexer_flags.current_input_column = 0;
+curr_lexer->current_input_column = 0;
 at_bol = true;
 done = true;
-lexer_flags.block_comment_nesting_level++;
+curr_lexer->block_comment_nesting_level++;
 promptflag--;
 buf += grab_block_comment (reader, eof);
 in_comment = false;
 buf += static_cast<char> (c);
 if (c == '\n')
 {
 at_bol = true;
-lexer_flags.current_input_column = 0;
+curr_lexer->current_input_column = 0;
 in_comment = false;
 // FIXME -- bailing out here prevents things like
 //
 //    octave> # comment
 in_comment = true;
 begin_comment = true;
 break;
 default:
-lexer_flags.current_input_column--;
+curr_lexer->current_input_column--;
 reader.ungetc (c);
 goto done;
 }
 }
 }
 : grab_comment_block (flex_reader, false, eof);
 if (lexer_debug_flag)
 std::cerr << "C: " << txt << std::endl;
-if (help_txt.empty () && lexer_flags.nesting_level.none ())
+if (help_txt.empty () && curr_lexer->nesting_level.none ())
 {
 if (! help_buf.empty ())
 help_buf.pop ();
 help_buf.push (txt);
 }
 octave_comment_buffer::append (txt);
-lexer_flags.current_input_column = 1;
+curr_lexer->current_input_column = 1;
-lexer_flags.quote_is_transpose = false;
+curr_lexer->quote_is_transpose = false;
-lexer_flags.convert_spaces_to_comma = true;
+curr_lexer->convert_spaces_to_comma = true;
-lexer_flags.at_beginning_of_statement = true;
+curr_lexer->at_beginning_of_statement = true;
 if (YY_START == COMMAND_START)
 BEGIN (INITIAL);
-if (lexer_flags.nesting_level.none ())
+if (curr_lexer->nesting_level.none ())
 return '\n';
-else if (lexer_flags.nesting_level.is_bracket_or_brace ())
+else if (curr_lexer->nesting_level.is_bracket_or_brace ())
 return ';';
 else
 return 0;
 }
 int c = 0;
 while ((c = text_yyinput ()) != EOF)
 {
-lexer_flags.current_input_column++;
+curr_lexer->current_input_column++;
 switch (c)
 {
 case ' ':
 case '\t':
 octave_comment_buffer::append (comment_buf);
 comment_buf.resize (0);
 in_comment = false;
 beginning_of_comment = false;
 }
-lexer_flags.current_input_column = 0;
+curr_lexer->current_input_column = 0;
 break;
 case '#':
 case '%':
 if (in_comment)
 if (! comment_buf.empty ())
 octave_comment_buffer::append (comment_buf);
 done:
 xunput (c, yytext);
-lexer_flags.current_input_column--;
+curr_lexer->current_input_column--;
 return retval;
 }
 static inline bool
 looks_like_hex (const char *s, int len)
 // If yytext doesn't contain a valid number, we are in deep doo doo.
 assert (nread == 1);
-lexer_flags.quote_is_transpose = true;
+curr_lexer->quote_is_transpose = true;
-lexer_flags.convert_spaces_to_comma = true;
+curr_lexer->convert_spaces_to_comma = true;
-lexer_flags.looking_for_object_index = false;
+curr_lexer->looking_for_object_index = false;
-lexer_flags.at_beginning_of_statement = false;
+curr_lexer->at_beginning_of_statement = false;
-yylval.tok_val = new token (value, yytext, lexer_flags.input_line_number,
+yylval.tok_val = new token (value, yytext, curr_lexer->input_line_number,
-lexer_flags.current_input_column);
+curr_lexer->current_input_column);
 token_stack.push (yylval.tok_val);
-lexer_flags.current_input_column += yyleng;
+curr_lexer->current_input_column += yyleng;
 do_comma_insert_check ();
 }
 // We have seen a backslash and need to find out if it should be
 if (in_comment)
 {
 comment_buf += static_cast<char> (c);
 octave_comment_buffer::append (comment_buf);
 }
-lexer_flags.current_input_column = 0;
+curr_lexer->current_input_column = 0;
 promptflag--;
 gripe_matlab_incompatible_continuation ();
 return true;
 default:
 static int
 handle_string (char delim)
 {
 std::ostringstream buf;
-int bos_line = lexer_flags.input_line_number;
+int bos_line = curr_lexer->input_line_number;
-int bos_col = lexer_flags.current_input_column;
+int bos_col = curr_lexer->current_input_column;
 int c;
 int escape_pending = 0;
 while ((c = text_yyinput ()) != EOF)
 {
-lexer_flags.current_input_column++;
+curr_lexer->current_input_column++;
 if (c == '\\')
 {
 if (delim == '\'' || escape_pending)
 {
 if (delim == '\'')
 s = buf.str ();
 else
 s = do_string_escapes (buf.str ());
-lexer_flags.quote_is_transpose = true;
+curr_lexer->quote_is_transpose = true;
-lexer_flags.convert_spaces_to_comma = true;
+curr_lexer->convert_spaces_to_comma = true;
 yylval.tok_val = new token (s, bos_line, bos_col);
 token_stack.push (yylval.tok_val);
 if (delim == '"')
 gripe_matlab_incompatible ("\" used as string delimiter");
 else if (delim == '\'')
 gripe_single_quote_string ();
-lexer_flags.looking_for_object_index = true;
+curr_lexer->looking_for_object_index = true;
-lexer_flags.at_beginning_of_statement = false;
+curr_lexer->at_beginning_of_statement = false;
 return delim == '"' ? DQ_STRING : SQ_STRING;
 }
 }
 }
 static int
 handle_close_bracket (bool spc_gobbled, int bracket_type)
 {
 int retval = bracket_type;
-if (! lexer_flags.nesting_level.none ())
+if (! curr_lexer->nesting_level.none ())
 {
-lexer_flags.nesting_level.remove ();
+curr_lexer->nesting_level.remove ();
 if (bracket_type == ']')
-lexer_flags.bracketflag--;
+curr_lexer->bracketflag--;
 else if (bracket_type == '}')
-lexer_flags.braceflag--;
+curr_lexer->braceflag--;
 else
 panic_impossible ();
 }
-if (lexer_flags.bracketflag == 0 && lexer_flags.braceflag == 0)
+if (curr_lexer->bracketflag == 0 && curr_lexer->braceflag == 0)
 BEGIN (INITIAL);
 if (bracket_type == ']'
 && next_token_is_assign_op ()
-&& ! lexer_flags.looking_at_return_list)
+&& ! curr_lexer->looking_at_return_list)
 {
 retval = CLOSE_BRACE;
 }
-else if ((lexer_flags.bracketflag || lexer_flags.braceflag)
+else if ((curr_lexer->bracketflag || curr_lexer->braceflag)
-&& lexer_flags.convert_spaces_to_comma
+&& curr_lexer->convert_spaces_to_comma
-&& (lexer_flags.nesting_level.is_bracket ()
+&& (curr_lexer->nesting_level.is_bracket ()
-|| (lexer_flags.nesting_level.is_brace ()
+|| (curr_lexer->nesting_level.is_brace ()
-&& ! lexer_flags.looking_at_object_index.front ())))
+&& ! curr_lexer->looking_at_object_index.front ())))
 {
 bool index_op = next_token_is_index_op ();
 // Don't insert comma if we are looking at something like
 //
 return retval;
 }
 }
 }
-lexer_flags.quote_is_transpose = true;
+curr_lexer->quote_is_transpose = true;
-lexer_flags.convert_spaces_to_comma = true;
+curr_lexer->convert_spaces_to_comma = true;
 return retval;
 }
 static void
 maybe_unput_comma (int spc_gobbled)
 {
-if (lexer_flags.nesting_level.is_bracket ()
+if (curr_lexer->nesting_level.is_bracket ()
-|| (lexer_flags.nesting_level.is_brace ()
+|| (curr_lexer->nesting_level.is_brace ()
-&& ! lexer_flags.looking_at_object_index.front ()))
+&& ! curr_lexer->looking_at_object_index.front ()))
 {
 int bin_op = next_token_is_bin_op (spc_gobbled);
 int postfix_un_op = next_token_is_postfix_unary_op (spc_gobbled);
 yylval.tok_val
 = new token (meth.empty () ? 0 : &(symbol_table::insert (meth)),
 cls.empty () ? 0 : &(symbol_table::insert (cls)),
 pkg.empty () ? 0 : &(symbol_table::insert (pkg)),
-lexer_flags.input_line_number,
+curr_lexer->input_line_number,
-lexer_flags.current_input_column);
+curr_lexer->current_input_column);
 token_stack.push (yylval.tok_val);
-lexer_flags.convert_spaces_to_comma = true;
+curr_lexer->convert_spaces_to_comma = true;
-lexer_flags.current_input_column += yyleng;
+curr_lexer->current_input_column += yyleng;
 return SUPERCLASSREF;
 }
 static int
 }
 yylval.tok_val
 = new token (cls.empty () ? 0 : &(symbol_table::insert (cls)),
 pkg.empty () ? 0 : &(symbol_table::insert (pkg)),
-lexer_flags.input_line_number,
+curr_lexer->input_line_number,
-lexer_flags.current_input_column);
+curr_lexer->current_input_column);
 token_stack.push (yylval.tok_val);
-lexer_flags.convert_spaces_to_comma = true;
+curr_lexer->convert_spaces_to_comma = true;
-lexer_flags.current_input_column += yyleng;
+curr_lexer->current_input_column += yyleng;
 return METAQUERY;
 }
 // Figure out exactly what kind of token to return when we have seen
 // should be ignored.
 static int
 handle_identifier (void)
 {
-bool at_bos = lexer_flags.at_beginning_of_statement;
+bool at_bos = curr_lexer->at_beginning_of_statement;
 std::string tok = strip_trailing_whitespace (yytext);
 int c = yytext[yyleng-1];
 // If we are expecting a structure element, avoid recognizing
 // keywords and other special names and return STRUCT_ELT, which is
 // a string that is also a valid identifier.  But first, we have to
 // decide whether to insert a comma.
-if (lexer_flags.looking_at_indirect_ref)
+if (curr_lexer->looking_at_indirect_ref)
 {
 do_comma_insert_check ();
 maybe_unput_comma (spc_gobbled);
-yylval.tok_val = new token (tok, lexer_flags.input_line_number,
+yylval.tok_val = new token (tok, curr_lexer->input_line_number,
-lexer_flags.current_input_column);
+curr_lexer->current_input_column);
 token_stack.push (yylval.tok_val);
-lexer_flags.quote_is_transpose = true;
+curr_lexer->quote_is_transpose = true;
-lexer_flags.convert_spaces_to_comma = true;
+curr_lexer->convert_spaces_to_comma = true;
-lexer_flags.looking_for_object_index = true;
+curr_lexer->looking_for_object_index = true;
-lexer_flags.current_input_column += yyleng;
+curr_lexer->current_input_column += yyleng;
 return STRUCT_ELT;
 }
-lexer_flags.at_beginning_of_statement = false;
+curr_lexer->at_beginning_of_statement = false;
 // The is_keyword_token may reset
-// lexer_flags.at_beginning_of_statement.  For example, if it sees
+// curr_lexer->at_beginning_of_statement.  For example, if it sees
 // an else token, then the next token is at the beginning of a
 // statement.
 int kw_token = is_keyword_token (tok);
 // If we found a keyword token, then the beginning_of_statement flag
 // is already set.  Otherwise, we won't be at the beginning of a
 // statement.
-if (lexer_flags.looking_at_function_handle)
+if (curr_lexer->looking_at_function_handle)
 {
 if (kw_token)
 {
 error ("function handles may not refer to keywords");
 return LEXICAL_ERROR;
 }
 else
 {
-yylval.tok_val = new token (tok, lexer_flags.input_line_number,
+yylval.tok_val = new token (tok, curr_lexer->input_line_number,
-lexer_flags.current_input_column);
+curr_lexer->current_input_column);
 token_stack.push (yylval.tok_val);
-lexer_flags.current_input_column += yyleng;
+curr_lexer->current_input_column += yyleng;
-lexer_flags.quote_is_transpose = false;
+curr_lexer->quote_is_transpose = false;
-lexer_flags.convert_spaces_to_comma = true;
+curr_lexer->convert_spaces_to_comma = true;
-lexer_flags.looking_for_object_index = true;
+curr_lexer->looking_for_object_index = true;
 return FCN_HANDLE;
 }
 }
 if (kw_token)
 {
 if (kw_token >= 0)
 {
-lexer_flags.current_input_column += yyleng;
+curr_lexer->current_input_column += yyleng;
-lexer_flags.quote_is_transpose = false;
+curr_lexer->quote_is_transpose = false;
-lexer_flags.convert_spaces_to_comma = true;
+curr_lexer->convert_spaces_to_comma = true;
-lexer_flags.looking_for_object_index = false;
+curr_lexer->looking_for_object_index = false;
 }
 return kw_token;
 }
 && looks_like_command_arg ())
 {
 BEGIN (COMMAND_START);
 }
 else if (next_tok_is_eq
-|| lexer_flags.looking_at_decl_list
+|| curr_lexer->looking_at_decl_list
-|| lexer_flags.looking_at_return_list
+|| curr_lexer->looking_at_return_list
-|| (lexer_flags.looking_at_parameter_list
+|| (curr_lexer->looking_at_parameter_list
-&& ! lexer_flags.looking_at_initializer_expression))
+&& ! curr_lexer->looking_at_initializer_expression))
 {
 symbol_table::force_variable (tok);
 }
-else if (lexer_flags.looking_at_matrix_or_assign_lhs)
+else if (curr_lexer->looking_at_matrix_or_assign_lhs)
 {
-lexer_flags.pending_local_variables.insert (tok);
+curr_lexer->pending_local_variables.insert (tok);
 }
 }
 // Find the token in the symbol table.  Beware the magic
 // transformation of the end keyword...
 if (tok == "end")
 tok = "__end__";
 yylval.tok_val = new token (&(symbol_table::insert (tok)),
-lexer_flags.input_line_number,
+curr_lexer->input_line_number,
-lexer_flags.current_input_column);
+curr_lexer->current_input_column);
 token_stack.push (yylval.tok_val);
 // After seeing an identifer, it is ok to convert spaces to a comma
 // (if needed).
-lexer_flags.convert_spaces_to_comma = true;
+curr_lexer->convert_spaces_to_comma = true;
 if (! (next_tok_is_eq || YY_START == COMMAND_START))
 {
-lexer_flags.quote_is_transpose = true;
+curr_lexer->quote_is_transpose = true;
 do_comma_insert_check ();
 maybe_unput_comma (spc_gobbled);
 }
-lexer_flags.current_input_column += yyleng;
+curr_lexer->current_input_column += yyleng;
 if (tok != "__end__")
-lexer_flags.looking_for_object_index = true;
+curr_lexer->looking_for_object_index = true;
 return NAME;
 }
 bool
 std::string nm = curr_fcn_file_full_name;
 if (nm.empty ())
 warning_with_id ("Octave:separator-insert",
 "potential auto-insertion of '%c' near line %d",
-sep, lexer_flags.input_line_number);
+sep, curr_lexer->input_line_number);
 else
 warning_with_id ("Octave:separator-insert",
 "potential auto-insertion of '%c' near line %d of file %s",
-sep, lexer_flags.input_line_number, nm.c_str ());
+sep, curr_lexer->input_line_number, nm.c_str ());
 }
 static void
 gripe_single_quote_string (void)
 {
 std::string nm = curr_fcn_file_full_name;
 if (nm.empty ())
 warning_with_id ("Octave:single-quote-string",
 "single quote delimited string near line %d",
-lexer_flags.input_line_number);
+curr_lexer->input_line_number);
 else
 warning_with_id ("Octave:single-quote-string",
 "single quote delimited string near line %d of file %s",
-lexer_flags.input_line_number, nm.c_str ());
+curr_lexer->input_line_number, nm.c_str ());
 }
 static void
 gripe_matlab_incompatible (const std::string& msg)
 {
 "potential Matlab compatibility problem: %s",
 msg.c_str ());
 else
 warning_with_id ("Octave:matlab-incompatible",
 "potential Matlab compatibility problem: %s near line %d offile %s",
-msg.c_str (), lexer_flags.input_line_number, nm.c_str ());
+msg.c_str (), curr_lexer->input_line_number, nm.c_str ());
 }
 static void
 maybe_gripe_matlab_incompatible_comment (char c)
 {

Mercurial > hg > octave-nkf

comparison libinterp/parse-tree/lex.ll @ 16110:7302f8a4df83