octave-nkf: libinterp/parse-tree/oct-parse.yy comparison

comparison libinterp/parse-tree/oct-parse.yy @ 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	229eb14653fd
children	ea5d92f574e0

comparison

equal deleted inserted replaced

-:229eb14653fd
+:7302f8a4df83
 input1          : '\n'
 { $$ = 0; }
 | END_OF_INPUT
 {
-lexer_flags.parser_end_of_input = 1;
+curr_lexer->parser_end_of_input = 1;
 $$ = 0;
 }
 | simple_list
 { $$ = $1; }
 | simple_list '\n'
 ;
 matrix          : '[' ']'
 {
 $$ = new tree_constant (octave_null_matrix::instance);
-lexer_flags.looking_at_matrix_or_assign_lhs = false;
+curr_lexer->looking_at_matrix_or_assign_lhs = false;
-lexer_flags.pending_local_variables.clear ();
+curr_lexer->pending_local_variables.clear ();
 }
 | '[' ';' ']'
 {
 $$ = new tree_constant (octave_null_matrix::instance);
-lexer_flags.looking_at_matrix_or_assign_lhs = false;
+curr_lexer->looking_at_matrix_or_assign_lhs = false;
-lexer_flags.pending_local_variables.clear ();
+curr_lexer->pending_local_variables.clear ();
 }
 | '[' ',' ']'
 {
 $$ = new tree_constant (octave_null_matrix::instance);
-lexer_flags.looking_at_matrix_or_assign_lhs = false;
+curr_lexer->looking_at_matrix_or_assign_lhs = false;
-lexer_flags.pending_local_variables.clear ();
+curr_lexer->pending_local_variables.clear ();
 }
 | '[' matrix_rows ']'
 {
 $$ = finish_matrix ($2);
-lexer_flags.looking_at_matrix_or_assign_lhs = false;
+curr_lexer->looking_at_matrix_or_assign_lhs = false;
-lexer_flags.pending_local_variables.clear ();
+curr_lexer->pending_local_variables.clear ();
 }
 ;
 matrix_rows     : matrix_rows1
 { $$ = $1; }
 ;
 fcn_handle      : '@' FCN_HANDLE
 {
 $$ = make_fcn_handle ($2);
-lexer_flags.looking_at_function_handle--;
+curr_lexer->looking_at_function_handle--;
 }
 ;
 anon_fcn_handle : '@' param_list statement
 {
-lexer_flags.quote_is_transpose = false;
+curr_lexer->quote_is_transpose = false;
 $$ = make_anon_fcn_handle ($2, $3);
 }
 ;
 primary_expr    : identifier
 $$ = $1;
 }
 ;
 indirect_ref_op : '.'
-{ lexer_flags.looking_at_indirect_ref = true; }
+{ curr_lexer->looking_at_indirect_ref = true; }
 ;
 oper_expr       : primary_expr
 { $$ = $1; }
 | oper_expr PLUS_PLUS
 $$->mark_as_simple_assign_lhs ();
 }
 | '[' arg_list opt_comma CLOSE_BRACE
 {
 $$ = $2;
-lexer_flags.looking_at_matrix_or_assign_lhs = false;
+curr_lexer->looking_at_matrix_or_assign_lhs = false;
-for (std::set<std::string>::const_iterator p = lexer_flags.pending_local_variables.begin ();
+for (std::set<std::string>::const_iterator p = curr_lexer->pending_local_variables.begin ();
-p != lexer_flags.pending_local_variables.end ();
+p != curr_lexer->pending_local_variables.end ();
 p++)
 {
 symbol_table::force_variable (*p);
 }
-lexer_flags.pending_local_variables.clear ();
+curr_lexer->pending_local_variables.clear ();
 }
 ;
 assign_expr     : assign_lhs '=' expression
 { $$ = make_assign_op ('=', $1, $2, $3); }
 // Declaration statemnts
 // =====================
 parsing_decl_list
 : // empty
-{ lexer_flags.looking_at_decl_list = true; }
+{ curr_lexer->looking_at_decl_list = true; }
 declaration     : GLOBAL parsing_decl_list decl1
 {
 $$ = make_decl_command (GLOBAL, $1, $3);
-lexer_flags.looking_at_decl_list = false;
+curr_lexer->looking_at_decl_list = false;
 }
 | PERSISTENT parsing_decl_list decl1
 {
 $$ = make_decl_command (PERSISTENT, $1, $3);
-lexer_flags.looking_at_decl_list = false;
+curr_lexer->looking_at_decl_list = false;
 }
 ;
 decl1           : decl2
 { $$ = new tree_decl_init_list ($1); }
 $$ = $1;
 }
 ;
 decl_param_init : // empty
-{ lexer_flags.looking_at_initializer_expression = true; }
+{ curr_lexer->looking_at_initializer_expression = true; }
 decl2           : identifier
 { $$ = new tree_decl_elt ($1); }
 | identifier '=' decl_param_init expression
 {
-lexer_flags.looking_at_initializer_expression = false;
+curr_lexer->looking_at_initializer_expression = false;
 $$ = new tree_decl_elt ($1, $4);
 }
 | magic_tilde
 {
 $$ = new tree_decl_elt ($1);
 // List of function parameters
 // ===========================
 param_list_beg  : '('
 {
-lexer_flags.looking_at_parameter_list = true;
+curr_lexer->looking_at_parameter_list = true;
-if (lexer_flags.looking_at_function_handle)
+if (curr_lexer->looking_at_function_handle)
 {
 parser_symtab_context.push ();
 symbol_table::set_scope (symbol_table::alloc_scope ());
-lexer_flags.looking_at_function_handle--;
+curr_lexer->looking_at_function_handle--;
-lexer_flags.looking_at_anon_fcn_args = true;
+curr_lexer->looking_at_anon_fcn_args = true;
 }
 }
 ;
 param_list_end  : ')'
 {
-lexer_flags.looking_at_parameter_list = false;
+curr_lexer->looking_at_parameter_list = false;
-lexer_flags.looking_for_object_index = false;
+curr_lexer->looking_for_object_index = false;
 }
 ;
 param_list      : param_list_beg param_list1 param_list_end
 {
-lexer_flags.quote_is_transpose = false;
+curr_lexer->quote_is_transpose = false;
 $$ = $2;
 }
 | param_list_beg error
 {
 yyerror ("invalid parameter list");
 // List of function return value names
 // ===================================
 return_list     : '[' ']'
 {
-lexer_flags.looking_at_return_list = false;
+curr_lexer->looking_at_return_list = false;
 $$ = new tree_parameter_list ();
 }
 | return_list1
 {
-lexer_flags.looking_at_return_list = false;
+curr_lexer->looking_at_return_list = false;
 if ($1->validate (tree_parameter_list::out))
 $$ = $1;
 else
 ABORT_PARSE;
 }
 | '[' return_list1 ']'
 {
-lexer_flags.looking_at_return_list = false;
+curr_lexer->looking_at_return_list = false;
 if ($2->validate (tree_parameter_list::out))
 $$ = $2;
 else
 ABORT_PARSE;
 }
 // ===========
 script_file     : SCRIPT_FILE opt_list END_OF_INPUT
 {
 tree_statement *end_of_script
-= make_end ("endscript", lexer_flags.input_line_number,
+= make_end ("endscript", curr_lexer->input_line_number,
-lexer_flags.current_input_column);
+curr_lexer->current_input_column);
 make_script ($2, end_of_script);
 $$ = 0;
 }
 function_beg    : push_fcn_symtab FCN stash_comment
 {
 $$ = $3;
-if (reading_classdef_file || lexer_flags.parsing_classdef)
+if (reading_classdef_file || curr_lexer->parsing_classdef)
-lexer_flags.maybe_classdef_get_set_method = true;
+curr_lexer->maybe_classdef_get_set_method = true;
 }
 ;
 function        : function_beg function1
 {
 fcn_name        : identifier
 {
 std::string id_name = $1->name ();
-lexer_flags.parsed_function_name.top () = true;
+curr_lexer->parsed_function_name.top () = true;
-lexer_flags.maybe_classdef_get_set_method = false;
+curr_lexer->maybe_classdef_get_set_method = false;
 $$ = $1;
 }
 | GET '.' identifier
 {
-lexer_flags.parsed_function_name.top () = true;
+curr_lexer->parsed_function_name.top () = true;
-lexer_flags.maybe_classdef_get_set_method = false;
+curr_lexer->maybe_classdef_get_set_method = false;
 $$ = $3;
 }
 | SET '.' identifier
 {
-lexer_flags.parsed_function_name.top () = true;
+curr_lexer->parsed_function_name.top () = true;
-lexer_flags.maybe_classdef_get_set_method = false;
+curr_lexer->maybe_classdef_get_set_method = false;
 $$ = $3;
 }
 ;
 function1       : fcn_name function2
 {
 yyerror ("classdef body open at end of input");
 YYABORT;
 }
-$$ = make_end ("endfunction", lexer_flags.input_line_number,
+$$ = make_end ("endfunction", curr_lexer->input_line_number,
-lexer_flags.current_input_column);
+curr_lexer->current_input_column);
 }
 ;
 // ========
 // Classdef
 // ========
 classdef_beg    : CLASSDEF stash_comment
 {
 $$ = 0;
-lexer_flags.parsing_classdef = true;
+curr_lexer->parsing_classdef = true;
 }
 ;
 classdef_end    : END
 {
-lexer_flags.parsing_classdef = false;
+curr_lexer->parsing_classdef = false;
 if (end_token_ok ($1, token::classdef_end))
 $$ = make_end ("endclassdef", $1->line (), $1->column ());
 else
 ABORT_PARSE;
 // Generic error messages.
 static void
 yyerror (const char *s)
 {
-int err_col = lexer_flags.current_input_column - 1;
+int err_col = curr_lexer->current_input_column - 1;
 std::ostringstream output_buf;
 if (reading_fcn_file || reading_script_file || reading_classdef_file)
-output_buf << "parse error near line " << lexer_flags.input_line_number
+output_buf << "parse error near line " << curr_lexer->input_line_number
 << " of file " << curr_fcn_file_full_name;
 else
 output_buf << "parse error:";
 if (s && strcmp (s, "parse error") != 0)
 static tree_anon_fcn_handle *
 make_anon_fcn_handle (tree_parameter_list *param_list, tree_statement *stmt)
 {
 // FIXME -- need to get these from the location of the @ symbol.
-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;
 tree_parameter_list *ret_list = 0;
 symbol_table::scope_id fcn_scope = symbol_table::current_scope ();
 if (end_token_ok (end_tok, token::while_end))
 {
 octave_comment_list *tc = octave_comment_buffer::get_comment ();
-lexer_flags.looping--;
+curr_lexer->looping--;
 int l = while_tok->line ();
 int c = while_tok->column ();
 retval = new tree_while_command (expr, body, lc, tc, l, c);
 maybe_warn_assign_as_truth_value (expr);
 octave_comment_list *tc = octave_comment_buffer::get_comment ();
-lexer_flags.looping--;
+curr_lexer->looping--;
 int l = until_tok->line ();
 int c = until_tok->column ();
 retval = new tree_do_until_command (expr, body, lc, tc, l, c);
 if (end_token_ok (end_tok, parfor ? token::parfor_end : token::for_end))
 {
 octave_comment_list *tc = octave_comment_buffer::get_comment ();
-lexer_flags.looping--;
+curr_lexer->looping--;
 int l = for_tok->line ();
 int c = for_tok->column ();
 if (lhs->length () == 1)
 fcn->stash_parent_fcn_scope (function_scopes[function_scopes.size ()-2]);
 else
 fcn->stash_parent_fcn_scope (primary_fcn_scope);
 }
-if (lexer_flags.parsing_class_method)
+if (curr_lexer->parsing_class_method)
 {
 if (current_class_name == id_name)
 fcn->mark_as_class_constructor ();
 else
 fcn->mark_as_class_method ();
 warning ("function '%s' defined within script file '%s'",
 id_name.c_str (), curr_fcn_file_full_name.c_str ());
 }
 fcn->stash_function_name (id_name);
-fcn->stash_fcn_location (lexer_flags.input_line_number,
+fcn->stash_fcn_location (curr_lexer->input_line_number,
-lexer_flags.current_input_column);
+curr_lexer->current_input_column);
 if (! help_buf.empty () && current_function_depth == 1
 && ! parsing_subfunctions)
 {
 fcn->document (help_buf.top ());
 parsing_subfunctions = true;
 current_function_depth--;
 function_scopes.pop_back ();
-lexer_flags.defining_func--;
+curr_lexer->defining_func--;
-lexer_flags.parsed_function_name.pop ();
+curr_lexer->parsed_function_name.pop ();
-lexer_flags.looking_at_return_list = false;
+curr_lexer->looking_at_return_list = false;
-lexer_flags.looking_at_parameter_list = false;
+curr_lexer->looking_at_parameter_list = false;
 }
 // Make an index expression.
 static tree_index_expression *
 retval = tmp;
 }
 else
 retval = new tree_index_expression (expr, elt, l, c);
-lexer_flags.looking_at_indirect_ref = false;
+curr_lexer->looking_at_indirect_ref = false;
 return retval;
 }
 // Make an indirect reference expression with dynamic field name.
 retval = tmp;
 }
 else
 retval = new tree_index_expression (expr, elt, l, c);
-lexer_flags.looking_at_indirect_ref = false;
+curr_lexer->looking_at_indirect_ref = false;
 return retval;
 }
 // Make a declaration command.
 c = '\n';
 }
 }
 if (c == '\n')
-lexer_flags.input_line_number++;
+curr_lexer->input_line_number++;
 return c;
 }
 class
 int getc (void) { return ::text_getc (f); }
 int ungetc (int c)
 {
 if (c == '\n')
-lexer_flags.input_line_number--;
+curr_lexer->input_line_number--;
 return ::ungetc (c, f);
 }
 private:
 {
 switch (c)
 {
 case ' ':
 case '\t':
-lexer_flags.current_input_column++;
+curr_lexer->current_input_column++;
 break;
 case '\n':
-lexer_flags.current_input_column = 1;
+curr_lexer->current_input_column = 1;
 break;
 default:
 reader.ungetc (c);
 goto done;
 if (ffile)
 {
 bool eof;
-frame.protect_var (lexer_flags);
+frame.protect_var (curr_lexer);
-// Also resets lexer_flags.
+curr_lexer = new lexical_feedback ();
 reset_parser ();
 std::string help_txt = gobble_leading_white_space (ffile, eof);
 if (! help_txt.empty ())
 if (reading_script_file)
 prep_lexer_for_script_file ();
 else
 prep_lexer_for_function_file ();
-lexer_flags.parsing_class_method = ! dispatch_type.empty ();
+curr_lexer->parsing_class_method = ! dispatch_type.empty ();
 frame.protect_var (global_command);
 global_command = 0;
 file_type.c_str (), ff.c_str ());
 }
 else
 {
 tree_statement *end_of_script
-= make_end ("endscript", lexer_flags.input_line_number,
+= make_end ("endscript", curr_lexer->input_line_number,
-lexer_flags.current_input_column);
+curr_lexer->current_input_column);
 make_script (0, end_of_script);
 fcn_ptr = primary_fcn_ptr;
 }
 {
 octave_value_list retval;
 unwind_protect frame;
-frame.protect_var (lexer_flags);
+frame.protect_var (curr_lexer);
 frame.protect_var (get_input_from_eval_string);
 frame.protect_var (line_editing);
 frame.protect_var (current_eval_string);
 frame.protect_var (current_function_depth);
 frame.protect_var (endfunction_found);
 frame.protect_var (reading_fcn_file);
 frame.protect_var (reading_script_file);
 frame.protect_var (reading_classdef_file);
-lexer_flags = lexical_feedback ();
+curr_lexer = new lexical_feedback ();
 get_input_from_eval_string = true;
 line_editing = false;
 current_function_depth = 0;
 function_scopes.clear ();
 || tree_return_command::returning
 || tree_break_command::breaking
 || tree_continue_command::continuing)
 break;
 }
-else if (lexer_flags.parser_end_of_input)
+else if (curr_lexer->parser_end_of_input)
 break;
 }
 }
 while (parse_status == 0);

Mercurial > hg > octave-nkf

comparison libinterp/parse-tree/oct-parse.yy @ 16110:7302f8a4df83