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

comparison libinterp/parse-tree/oct-parse.in.yy @ 16287:04a7953496a7

create base class for parser; use reference for curr_lexer * lex.h, lex.ll (octave_base_parser): New base class for parser class. Move most of previous octave_parser class here. Use reference for curr_lexer object instead of pointer. Change all uses. (octave_parser): Derive from octave_base_parser.

author	John W. Eaton <jwe@octave.org>
date	Tue, 12 Mar 2013 00:18:28 -0400
parents	3389152014ca
children	fe3b9a51e625

comparison

equal deleted inserted replaced

-:3389152014ca
+:04a7953496a7
 static std::map<std::string, std::string> autoload_map;
 // Forward declarations for some functions defined at the bottom of
 // the file.
-static void yyerror (octave_parser& curr_parser, const char *s);
+static void yyerror (octave_base_parser& curr_parser, const char *s);
 // Finish building a statement.
 template <class T>
 static tree_statement *
 make_statement (T *arg)
 { \
 yyerrok; \
 if (! parser_symtab_context.empty ()) \
 parser_symtab_context.pop (); \
 if ((interactive || forced_interactive)   \
-&& ! (curr_lexer)->input_from_eval_string ()) \
+&& ! curr_lexer.input_from_eval_string ()) \
 YYACCEPT; \
 else \
 YYABORT; \
 } \
 while (0)
 #define curr_lexer curr_parser.curr_lexer
-#define scanner curr_lexer->scanner
+#define scanner curr_lexer.scanner
 %}
 // Bison declarations.
 // care to properly save and restore (typically with an unwind_protect
 // object) relevant global values before and after the nested call.
 %define api.pure
 %PUSH_PULL_DECL%
-%parse-param { octave_parser& curr_parser }
+%parse-param { octave_base_parser& curr_parser }
 %lex-param { void *scanner }
 %union
 {
 // The type of the basic tokens returned by the lexer.
 input1          : '\n'
 { $$ = 0; }
 | END_OF_INPUT
 {
-curr_lexer->end_of_input = true;
+curr_lexer.end_of_input = true;
 $$ = 0;
 }
 | simple_list
 { $$ = $1; }
 | simple_list '\n'
 ;
 fcn_handle      : '@' FCN_HANDLE
 {
 $$ = curr_parser.make_fcn_handle ($2);
-curr_lexer->looking_at_function_handle--;
+curr_lexer.looking_at_function_handle--;
 }
 ;
 anon_fcn_handle : '@' param_list statement
 {
 $$ = curr_parser.make_anon_fcn_handle ($2, $3);
-curr_lexer->nesting_level.remove ();
+curr_lexer.nesting_level.remove ();
 }
 ;
 primary_expr    : identifier
 { $$ = $1; }
 { $$ = $1; }
 | fcn_handle
 { $$ = $1; }
 | matrix
 {
-curr_lexer->looking_at_matrix_or_assign_lhs = false;
+curr_lexer.looking_at_matrix_or_assign_lhs = false;
 $$ = $1;
 }
 | cell
 { $$ = $1; }
 | meta_identifier
 $$ = $1;
 }
 ;
 indirect_ref_op : '.'
-{ curr_lexer->looking_at_indirect_ref = true; }
+{ curr_lexer.looking_at_indirect_ref = true; }
 ;
 oper_expr       : primary_expr
 { $$ = $1; }
 | oper_expr PLUS_PLUS
 assign_lhs      : simple_expr
 {
 $$ = curr_parser.validate_matrix_for_assignment ($1);
 if ($$)
-{ curr_lexer->looking_at_matrix_or_assign_lhs = false; }
+{ curr_lexer.looking_at_matrix_or_assign_lhs = false; }
 else
 {
 // validate_matrix_for_assignment deleted $1.
 ABORT_PARSE;
 }
 // =====================
 declaration     : GLOBAL decl1
 {
 $$ = curr_parser.make_decl_command (GLOBAL, $1, $2);
-curr_lexer->looking_at_decl_list = false;
+curr_lexer.looking_at_decl_list = false;
 }
 | PERSISTENT decl1
 {
 $$ = curr_parser.make_decl_command (PERSISTENT, $1, $2);
-curr_lexer->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
-{ curr_lexer->looking_at_initializer_expression = true; }
+{ curr_lexer.looking_at_initializer_expression = true; }
 decl2           : identifier
 { $$ = new tree_decl_elt ($1); }
 | identifier '=' decl_param_init expression
 {
-curr_lexer->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);
 }
 ;
 if_cmd_list1    : expression opt_sep opt_list
 {
-$1->mark_braindead_shortcircuit (curr_lexer->fcn_file_full_name);
+$1->mark_braindead_shortcircuit (curr_lexer.fcn_file_full_name);
 $$ = curr_parser.start_if_command ($1, $3);
 }
 | if_cmd_list1 elseif_clause
 {
 }
 ;
 elseif_clause   : ELSEIF stash_comment opt_sep expression opt_sep opt_list
 {
-$4->mark_braindead_shortcircuit (curr_lexer->fcn_file_full_name);
+$4->mark_braindead_shortcircuit (curr_lexer.fcn_file_full_name);
 $$ = curr_parser.make_elseif_clause ($1, $4, $6, $2);
 }
 ;
 // Looping
 // =======
 loop_command    : WHILE stash_comment expression opt_sep opt_list END
 {
-$3->mark_braindead_shortcircuit (curr_lexer->fcn_file_full_name);
+$3->mark_braindead_shortcircuit (curr_lexer.fcn_file_full_name);
 if (! ($$ = curr_parser.make_while_command ($1, $3, $5, $6, $2)))
 ABORT_PARSE;
 }
 | DO stash_comment opt_sep opt_list UNTIL expression
 symbol_table::set_scope (symbol_table::alloc_scope ());
 curr_parser.function_scopes.push_back (symbol_table::current_scope ());
-if (! curr_lexer->reading_script_file
+if (! curr_lexer.reading_script_file
 && curr_parser.curr_fcn_depth == 1
 && ! curr_parser.parsing_subfunctions)
 curr_parser.primary_fcn_scope = symbol_table::current_scope ();
-if (curr_lexer->reading_script_file
+if (curr_lexer.reading_script_file
 && curr_parser.curr_fcn_depth > 1)
 curr_parser.bison_error ("nested functions not implemented in this context");
 }
 ;
 // List of function parameters
 // ===========================
 param_list_beg  : '('
 {
-curr_lexer->looking_at_parameter_list = true;
+curr_lexer.looking_at_parameter_list = true;
-if (curr_lexer->looking_at_function_handle)
+if (curr_lexer.looking_at_function_handle)
 {
 parser_symtab_context.push ();
 symbol_table::set_scope (symbol_table::alloc_scope ());
-curr_lexer->looking_at_function_handle--;
+curr_lexer.looking_at_function_handle--;
-curr_lexer->looking_at_anon_fcn_args = true;
+curr_lexer.looking_at_anon_fcn_args = true;
 }
 }
 ;
 param_list_end  : ')'
 {
-curr_lexer->looking_at_parameter_list = false;
+curr_lexer.looking_at_parameter_list = false;
-curr_lexer->looking_for_object_index = false;
+curr_lexer.looking_for_object_index = false;
 }
 ;
 param_list      : param_list_beg param_list1 param_list_end
 { $$ = $2; }
 // List of function return value names
 // ===================================
 return_list     : '[' ']'
 {
-curr_lexer->looking_at_return_list = false;
+curr_lexer.looking_at_return_list = false;
 $$ = new tree_parameter_list ();
 }
 | return_list1
 {
-curr_lexer->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 ']'
 {
-curr_lexer->looking_at_return_list = false;
+curr_lexer.looking_at_return_list = false;
 if ($2->validate (tree_parameter_list::out))
 $$ = $2;
 else
 ABORT_PARSE;
 }
 // Script or function file
 // =======================
 file            : INPUT_FILE opt_nl opt_list END_OF_INPUT
 {
-if (! curr_lexer->reading_fcn_file)
+if (! curr_lexer.reading_fcn_file)
 {
 tree_statement *end_of_script
 = curr_parser.make_end ("endscript",
-curr_lexer->input_line_number,
+curr_lexer.input_line_number,
-curr_lexer->current_input_column);
+curr_lexer.current_input_column);
 curr_parser.make_script ($3, end_of_script);
 }
 $$ = 0;
 // ===================
 function_beg    : push_fcn_symtab FCN stash_comment
 {
 $$ = $3;
-if (curr_lexer->reading_classdef_file
+if (curr_lexer.reading_classdef_file
-|| curr_lexer->parsing_classdef)
+|| curr_lexer.parsing_classdef)
-curr_lexer->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 ();
-curr_lexer->parsed_function_name.top () = true;
+curr_lexer.parsed_function_name.top () = true;
-curr_lexer->maybe_classdef_get_set_method = false;
+curr_lexer.maybe_classdef_get_set_method = false;
 $$ = $1;
 }
 | GET '.' identifier
 {
-curr_lexer->parsed_function_name.top () = true;
+curr_lexer.parsed_function_name.top () = true;
-curr_lexer->maybe_classdef_get_set_method = false;
+curr_lexer.maybe_classdef_get_set_method = false;
 $$ = $3;
 }
 | SET '.' identifier
 {
-curr_lexer->parsed_function_name.top () = true;
+curr_lexer.parsed_function_name.top () = true;
-curr_lexer->maybe_classdef_get_set_method = false;
+curr_lexer.maybe_classdef_get_set_method = false;
 $$ = $3;
 }
 ;
 function1       : fcn_name function2
 ABORT_PARSE;
 }
 | END_OF_INPUT
 {
 // A lot of tests are based on the assumption that this is OK
-//                  if (curr_lexer->reading_script_file)
+//                  if (curr_lexer.reading_script_file)
 //                    {
 //                      curr_parser.bison_error ("function body open at end of script");
 //                      YYABORT;
 //                    }
 "if one function is explicitly ended, "
 "so must all the others");
 YYABORT;
 }
-if (! (curr_lexer->reading_fcn_file || curr_lexer->reading_script_file
+if (! (curr_lexer.reading_fcn_file || curr_lexer.reading_script_file
-|| (curr_lexer)->input_from_eval_string ()))
+|| curr_lexer.input_from_eval_string ()))
 {
 curr_parser.bison_error ("function body open at end of input");
 YYABORT;
 }
-if (curr_lexer->reading_classdef_file)
+if (curr_lexer.reading_classdef_file)
 {
 curr_parser.bison_error ("classdef body open at end of input");
 YYABORT;
 }
 $$ = curr_parser.make_end ("endfunction",
-curr_lexer->input_line_number,
+curr_lexer.input_line_number,
-curr_lexer->current_input_column);
+curr_lexer.current_input_column);
 }
 ;
 // ========
 // Classdef
 // ========
 classdef_beg    : CLASSDEF stash_comment
 {
 $$ = 0;
-curr_lexer->parsing_classdef = true;
+curr_lexer.parsing_classdef = true;
 }
 ;
 classdef_end    : END
 {
-curr_lexer->parsing_classdef = false;
+curr_lexer.parsing_classdef = false;
 if (curr_parser.end_token_ok ($1, token::classdef_end))
 $$ = curr_parser.make_end ("endclassdef", $1->line (), $1->column ());
 else
 ABORT_PARSE;
 // Generic error messages.
 #undef curr_lexer
 static void
-yyerror (octave_parser& curr_parser, const char *s)
+yyerror (octave_base_parser& curr_parser, const char *s)
 {
 curr_parser.bison_error (s);
 }
-octave_parser::~octave_parser (void)
+octave_base_parser::~octave_base_parser (void)
 {
 #if defined (OCTAVE_USE_PUSH_PARSER)
 yypstate_delete (static_cast<yypstate *> (parser_state));
 #endif
 delete stmt_list;
-delete curr_lexer;
+delete &curr_lexer;
 }
-void octave_parser::init (void)
+void octave_base_parser::init (void)
 {
 #if defined (OCTAVE_USE_PUSH_PARSER)
 parser_state = yypstate_new ();
 #endif
-CURR_LEXER = curr_lexer;
+CURR_LEXER = &curr_lexer;
 }
 void
-octave_parser::reset (void)
+octave_base_parser::reset (void)
 {
 delete stmt_list;
 stmt_list = 0;
-curr_lexer->reset ();
+curr_lexer.reset ();
-}
-int
-octave_parser::run (void)
-{
-int status = 0;
-#if defined (OCTAVE_USE_PUSH_PARSER)
-do
-{
-YYSTYPE lval;
-int token = octave_lex (&lval, scanner);
-yypstate *pstate = static_cast<yypstate *> (parser_state);
-status = octave_push_parse (pstate, token, &lval, *this);
-}
-while (status == YYPUSH_MORE);
-#else
-status = octave_parse (*this);
-#endif
-return status;
 }
 // Error mesages for mismatched end tokens.
 void
-octave_parser::end_error (const char *type, token::end_tok_type ettype,
+octave_base_parser::end_error (const char *type, token::end_tok_type ettype,
 int l, int c)
 {
 static const char *fmt
 = "'%s' command matched by '%s' near line %d column %d";
 switch (ettype)
 }
 // Check to see that end tokens are properly matched.
 bool
-octave_parser::end_token_ok (token *tok, token::end_tok_type expected)
+octave_base_parser::end_token_ok (token *tok, token::end_tok_type expected)
 {
 bool retval = true;
 token::end_tok_type ettype = tok->ettype ();
 // Maybe print a warning if an assignment expression is used as the
 // test in a logical expression.
 void
-octave_parser::maybe_warn_assign_as_truth_value (tree_expression *expr)
+octave_base_parser::maybe_warn_assign_as_truth_value (tree_expression *expr)
 {
 if (expr->is_assignment_expression ()
 && expr->paren_count () < 2)
 {
-if (curr_lexer->fcn_file_full_name.empty ())
+if (curr_lexer.fcn_file_full_name.empty ())
 warning_with_id
 ("Octave:assign-as-truth-value",
 "suggest parenthesis around assignment used as truth value");
 else
 warning_with_id
 ("Octave:assign-as-truth-value",
 "suggest parenthesis around assignment used as truth value near line %d, column %d in file '%s'",
-expr->line (), expr->column (), curr_lexer->fcn_file_full_name.c_str ());
+expr->line (), expr->column (), curr_lexer.fcn_file_full_name.c_str ());
 }
 }
 // Maybe print a warning about switch labels that aren't constants.
 void
-octave_parser::maybe_warn_variable_switch_label (tree_expression *expr)
+octave_base_parser::maybe_warn_variable_switch_label (tree_expression *expr)
 {
 if (! expr->is_constant ())
 {
-if (curr_lexer->fcn_file_full_name.empty ())
+if (curr_lexer.fcn_file_full_name.empty ())
 warning_with_id ("Octave:variable-switch-label",
 "variable switch label");
 else
 warning_with_id
 ("Octave:variable-switch-label",
 "variable switch label near line %d, column %d in file '%s'",
-expr->line (), expr->column (), curr_lexer->fcn_file_full_name.c_str ());
+expr->line (), expr->column (), curr_lexer.fcn_file_full_name.c_str ());
 }
 }
 static tree_expression *
 fold (tree_binary_expression *e)
 }
 // Finish building a range.
 tree_expression *
-octave_parser::finish_colon_expression (tree_colon_expression *e)
+octave_base_parser::finish_colon_expression (tree_colon_expression *e)
 {
 tree_expression *retval = e;
 unwind_protect frame;
 }
 // Make a constant.
 tree_constant *
-octave_parser::make_constant (int op, token *tok_val)
+octave_base_parser::make_constant (int op, token *tok_val)
 {
 int l = tok_val->line ();
 int c = tok_val->column ();
 tree_constant *retval = 0;
 }
 // Make a function handle.
 tree_fcn_handle *
-octave_parser::make_fcn_handle (token *tok_val)
+octave_base_parser::make_fcn_handle (token *tok_val)
 {
 int l = tok_val->line ();
 int c = tok_val->column ();
 tree_fcn_handle *retval = new tree_fcn_handle (tok_val->text (), l, c);
 }
 // Make an anonymous function handle.
 tree_anon_fcn_handle *
-octave_parser::make_anon_fcn_handle (tree_parameter_list *param_list,
+octave_base_parser::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 = curr_lexer->input_line_number;
+int l = curr_lexer.input_line_number;
-int c = curr_lexer->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 ();
 tree_anon_fcn_handle *retval
 = new tree_anon_fcn_handle (param_list, ret_list, body, fcn_scope, l, c);
 // FIXME: Stash the filename.  This does not work and produces
 // errors when executed.
-//retval->stash_file_name (curr_lexer->fcn_file_name);
+//retval->stash_file_name (curr_lexer.fcn_file_name);
 return retval;
 }
 // Build a binary expression.
 tree_expression *
-octave_parser::make_binary_op (int op, tree_expression *op1, token *tok_val,
+octave_base_parser::make_binary_op (int op, tree_expression *op1,
-tree_expression *op2)
+token *tok_val, tree_expression *op2)
 {
 octave_value::binary_op t = octave_value::unknown_binary_op;
 switch (op)
 {
 }
 // Build a boolean expression.
 tree_expression *
-octave_parser::make_boolean_op (int op, tree_expression *op1, token *tok_val,
+octave_base_parser::make_boolean_op (int op, tree_expression *op1,
-tree_expression *op2)
+token *tok_val, tree_expression *op2)
 {
 tree_boolean_expression::type t;
 switch (op)
 {
 }
 // Build a prefix expression.
 tree_expression *
-octave_parser::make_prefix_op (int op, tree_expression *op1, token *tok_val)
+octave_base_parser::make_prefix_op (int op, tree_expression *op1,
+token *tok_val)
 {
 octave_value::unary_op t = octave_value::unknown_unary_op;
 switch (op)
 {
 }
 // Build a postfix expression.
 tree_expression *
-octave_parser::make_postfix_op (int op, tree_expression *op1, token *tok_val)
+octave_base_parser::make_postfix_op (int op, tree_expression *op1,
+token *tok_val)
 {
 octave_value::unary_op t = octave_value::unknown_unary_op;
 switch (op)
 {
 }
 // Build an unwind-protect command.
 tree_command *
-octave_parser::make_unwind_command (token *unwind_tok,
+octave_base_parser::make_unwind_command (token *unwind_tok,
 tree_statement_list *body,
 tree_statement_list *cleanup_stmts,
 token *end_tok,
 octave_comment_list *lc,
 octave_comment_list *mc)
 {
 tree_command *retval = 0;
 if (end_token_ok (end_tok, token::unwind_protect_end))
 {
 }
 // Build a try-catch command.
 tree_command *
-octave_parser::make_try_command (token *try_tok, tree_statement_list *body,
+octave_base_parser::make_try_command (token *try_tok,
-tree_statement_list *cleanup_stmts,
+tree_statement_list *body,
-token *end_tok,
+tree_statement_list *cleanup_stmts,
-octave_comment_list *lc,
+token *end_tok,
-octave_comment_list *mc)
+octave_comment_list *lc,
+octave_comment_list *mc)
 {
 tree_command *retval = 0;
 if (end_token_ok (end_tok, token::try_catch_end))
 {
 }
 // Build a while command.
 tree_command *
-octave_parser::make_while_command (token *while_tok, tree_expression *expr,
+octave_base_parser::make_while_command (token *while_tok,
-tree_statement_list *body, token *end_tok,
+tree_expression *expr,
-octave_comment_list *lc)
+tree_statement_list *body,
+token *end_tok,
+octave_comment_list *lc)
 {
 tree_command *retval = 0;
 maybe_warn_assign_as_truth_value (expr);
 if (end_token_ok (end_tok, token::while_end))
 {
 octave_comment_list *tc = octave_comment_buffer::get_comment ();
-curr_lexer->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);
 }
 // Build a do-until command.
 tree_command *
-octave_parser::make_do_until_command (token *until_tok,
+octave_base_parser::make_do_until_command (token *until_tok,
 tree_statement_list *body,
 tree_expression *expr,
 octave_comment_list *lc)
 {
 tree_command *retval = 0;
 maybe_warn_assign_as_truth_value (expr);
 octave_comment_list *tc = octave_comment_buffer::get_comment ();
-curr_lexer->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);
 }
 // Build a for command.
 tree_command *
-octave_parser::make_for_command (int tok_id, token *for_tok,
+octave_base_parser::make_for_command (int tok_id, token *for_tok,
 tree_argument_list *lhs,
 tree_expression *expr,
 tree_expression *maxproc,
-tree_statement_list *body, token *end_tok,
+tree_statement_list *body,
-octave_comment_list *lc)
+token *end_tok,
+octave_comment_list *lc)
 {
 tree_command *retval = 0;
 bool parfor = tok_id == PARFOR;
 if (end_token_ok (end_tok, parfor ? token::parfor_end : token::for_end))
 {
 octave_comment_list *tc = octave_comment_buffer::get_comment ();
-curr_lexer->looping--;
+curr_lexer.looping--;
 int l = for_tok->line ();
 int c = for_tok->column ();
 if (lhs->length () == 1)
 }
 // Build a break command.
 tree_command *
-octave_parser::make_break_command (token *break_tok)
+octave_base_parser::make_break_command (token *break_tok)
 {
 tree_command *retval = 0;
 int l = break_tok->line ();
 int c = break_tok->column ();
 }
 // Build a continue command.
 tree_command *
-octave_parser::make_continue_command (token *continue_tok)
+octave_base_parser::make_continue_command (token *continue_tok)
 {
 tree_command *retval = 0;
 int l = continue_tok->line ();
 int c = continue_tok->column ();
 }
 // Build a return command.
 tree_command *
-octave_parser::make_return_command (token *return_tok)
+octave_base_parser::make_return_command (token *return_tok)
 {
 tree_command *retval = 0;
 int l = return_tok->line ();
 int c = return_tok->column ();
 }
 // Start an if command.
 tree_if_command_list *
-octave_parser::start_if_command (tree_expression *expr,
+octave_base_parser::start_if_command (tree_expression *expr,
 tree_statement_list *list)
 {
 maybe_warn_assign_as_truth_value (expr);
 tree_if_clause *t = new tree_if_clause (expr, list);
 }
 // Finish an if command.
 tree_if_command *
-octave_parser::finish_if_command (token *if_tok, tree_if_command_list *list,
+octave_base_parser::finish_if_command (token *if_tok,
-token *end_tok, octave_comment_list *lc)
+tree_if_command_list *list,
+token *end_tok,
+octave_comment_list *lc)
 {
 tree_if_command *retval = 0;
 if (end_token_ok (end_tok, token::if_end))
 {
 }
 // Build an elseif clause.
 tree_if_clause *
-octave_parser::make_elseif_clause (token *elseif_tok, tree_expression *expr,
+octave_base_parser::make_elseif_clause (token *elseif_tok,
-tree_statement_list *list,
+tree_expression *expr,
-octave_comment_list *lc)
+tree_statement_list *list,
+octave_comment_list *lc)
 {
 maybe_warn_assign_as_truth_value (expr);
 int l = elseif_tok->line ();
 int c = elseif_tok->column ();
 }
 // Finish a switch command.
 tree_switch_command *
-octave_parser::finish_switch_command (token *switch_tok, tree_expression *expr,
+octave_base_parser::finish_switch_command (token *switch_tok,
-tree_switch_case_list *list,
+tree_expression *expr,
-token *end_tok, octave_comment_list *lc)
+tree_switch_case_list *list,
+token *end_tok,
+octave_comment_list *lc)
 {
 tree_switch_command *retval = 0;
 if (end_token_ok (end_tok, token::switch_end))
 {
 }
 // Build a switch case.
 tree_switch_case *
-octave_parser::make_switch_case (token *case_tok, tree_expression *expr,
+octave_base_parser::make_switch_case (token *case_tok,
-tree_statement_list *list,
+tree_expression *expr,
-octave_comment_list *lc)
+tree_statement_list *list,
+octave_comment_list *lc)
 {
 maybe_warn_variable_switch_label (expr);
 int l = case_tok->line ();
 int c = case_tok->column ();
 }
 // Build an assignment to a variable.
 tree_expression *
-octave_parser::make_assign_op (int op, tree_argument_list *lhs, token *eq_tok,
+octave_base_parser::make_assign_op (int op, tree_argument_list *lhs,
-tree_expression *rhs)
+token *eq_tok, tree_expression *rhs)
 {
 tree_expression *retval = 0;
 octave_value::assign_op t = octave_value::unknown_assign_op;
 }
 // Define a script.
 void
-octave_parser::make_script (tree_statement_list *cmds,
+octave_base_parser::make_script (tree_statement_list *cmds,
 tree_statement *end_script)
 {
 if (! cmds)
 cmds = new tree_statement_list ();
 cmds->append (end_script);
 octave_user_script *script
-= new octave_user_script (curr_lexer->fcn_file_full_name,
+= new octave_user_script (curr_lexer.fcn_file_full_name,
-curr_lexer->fcn_file_name,
+curr_lexer.fcn_file_name,
-cmds, curr_lexer->help_text);
+cmds, curr_lexer.help_text);
-curr_lexer->help_text = "";
+curr_lexer.help_text = "";
 octave_time now;
 script->stash_fcn_file_time (now);
 }
 // Begin defining a function.
 octave_user_function *
-octave_parser::start_function (tree_parameter_list *param_list,
+octave_base_parser::start_function (tree_parameter_list *param_list,
 tree_statement_list *body,
 tree_statement *end_fcn_stmt)
 {
 // We'll fill in the return list later.
 if (! body)
 body = new tree_statement_list ();
 return fcn;
 }
 tree_statement *
-octave_parser::make_end (const std::string& type, int l, int c)
+octave_base_parser::make_end (const std::string& type, int l, int c)
 {
 return make_statement (new tree_no_op_command (type, l, c));
 }
 // Do most of the work for defining a function.
 octave_user_function *
-octave_parser::frob_function (const std::string& fname,
+octave_base_parser::frob_function (const std::string& fname,
 octave_user_function *fcn)
 {
 std::string id_name = fname;
 // If input is coming from a file, issue a warning if the name of
 // the file does not match the name of the function stated in the
 // file.  Matlab doesn't provide a diagnostic (it ignores the stated
 // name).
-if (! autoloading && curr_lexer->reading_fcn_file
+if (! autoloading && curr_lexer.reading_fcn_file
 && curr_fcn_depth == 1 && ! parsing_subfunctions)
 {
-// FIXME -- should curr_lexer->fcn_file_name already be
+// FIXME -- should curr_lexer.fcn_file_name already be
 // preprocessed when we get here?  It seems to only be a
 // problem with relative file names.
-std::string nm = curr_lexer->fcn_file_name;
+std::string nm = curr_lexer.fcn_file_name;
 size_t pos = nm.find_last_of (file_ops::dir_sep_chars ());
 if (pos != std::string::npos)
-nm = curr_lexer->fcn_file_name.substr (pos+1);
+nm = curr_lexer.fcn_file_name.substr (pos+1);
 if (nm != id_name)
 {
 warning_with_id
 ("Octave:function-name-clash",
 "function name '%s' does not agree with function file name '%s'",
-id_name.c_str (), curr_lexer->fcn_file_full_name.c_str ());
+id_name.c_str (), curr_lexer.fcn_file_full_name.c_str ());
 id_name = nm;
 }
 }
-if (curr_lexer->reading_fcn_file || curr_lexer->reading_classdef_file || autoloading)
+if (curr_lexer.reading_fcn_file || curr_lexer.reading_classdef_file || autoloading)
 {
 octave_time now;
-fcn->stash_fcn_file_name (curr_lexer->fcn_file_full_name);
+fcn->stash_fcn_file_name (curr_lexer.fcn_file_full_name);
 fcn->stash_fcn_file_time (now);
 fcn->mark_as_system_fcn_file ();
 if (fcn_file_from_relative_lookup)
 fcn->mark_relative ();
 if (curr_fcn_depth > 1 || parsing_subfunctions)
 {
-fcn->stash_parent_fcn_name (curr_lexer->fcn_file_name);
+fcn->stash_parent_fcn_name (curr_lexer.fcn_file_name);
 if (curr_fcn_depth > 1)
 fcn->stash_parent_fcn_scope (function_scopes[function_scopes.size ()-2]);
 else
 fcn->stash_parent_fcn_scope (primary_fcn_scope);
 }
-if (curr_lexer->parsing_class_method)
+if (curr_lexer.parsing_class_method)
 {
 if (curr_class_name == id_name)
 fcn->mark_as_class_constructor ();
 else
 fcn->mark_as_class_method ();
 if (fs && fs.is_newer (now))
 warning_with_id ("Octave:future-time-stamp",
 "time stamp for '%s' is in the future", nm.c_str ());
 }
 else if (! input_from_tmp_history_file
-&& ! curr_lexer->force_script
+&& ! curr_lexer.force_script
-&& curr_lexer->reading_script_file
+&& curr_lexer.reading_script_file
-&& curr_lexer->fcn_file_name == id_name)
+&& curr_lexer.fcn_file_name == id_name)
 {
 warning ("function '%s' defined within script file '%s'",
-id_name.c_str (), curr_lexer->fcn_file_full_name.c_str ());
+id_name.c_str (), curr_lexer.fcn_file_full_name.c_str ());
 }
 fcn->stash_function_name (id_name);
-fcn->stash_fcn_location (curr_lexer->input_line_number,
+fcn->stash_fcn_location (curr_lexer.input_line_number,
-curr_lexer->current_input_column);
+curr_lexer.current_input_column);
-if (! curr_lexer->help_text.empty () && curr_fcn_depth == 1
+if (! curr_lexer.help_text.empty () && curr_fcn_depth == 1
 && ! parsing_subfunctions)
 {
-fcn->document (curr_lexer->help_text);
+fcn->document (curr_lexer.help_text);
-curr_lexer->help_text = "";
+curr_lexer.help_text = "";
 }
-if (curr_lexer->reading_fcn_file && curr_fcn_depth == 1
+if (curr_lexer.reading_fcn_file && curr_fcn_depth == 1
 && ! parsing_subfunctions)
 primary_fcn_ptr = fcn;
 return fcn;
 }
 tree_function_def *
-octave_parser::finish_function (tree_parameter_list *ret_list,
+octave_base_parser::finish_function (tree_parameter_list *ret_list,
 octave_user_function *fcn,
 octave_comment_list *lc)
 {
 tree_function_def *retval = 0;
 if (ret_list)
 ret_list->mark_as_formal_parameters ();
 }
 if (curr_fcn_depth == 1 && fcn)
 symbol_table::update_nest (fcn->scope ());
-if (! curr_lexer->reading_fcn_file && curr_fcn_depth == 1)
+if (! curr_lexer.reading_fcn_file && curr_fcn_depth == 1)
 {
 // We are either reading a script file or defining a function
 // at the command line, so this definition creates a
 // tree_function object that is placed in the parse tree.
 // Otherwise, it is just inserted in the symbol table,
 return retval;
 }
 void
-octave_parser::recover_from_parsing_function (void)
+octave_base_parser::recover_from_parsing_function (void)
 {
 if (parser_symtab_context.empty ())
 panic_impossible ();
 parser_symtab_context.pop ();
-if (curr_lexer->reading_fcn_file && curr_fcn_depth == 1
+if (curr_lexer.reading_fcn_file && curr_fcn_depth == 1
 && ! parsing_subfunctions)
 parsing_subfunctions = true;
 curr_fcn_depth--;
 function_scopes.pop_back ();
-curr_lexer->defining_func--;
+curr_lexer.defining_func--;
-curr_lexer->parsed_function_name.pop ();
+curr_lexer.parsed_function_name.pop ();
-curr_lexer->looking_at_return_list = false;
+curr_lexer.looking_at_return_list = false;
-curr_lexer->looking_at_parameter_list = false;
+curr_lexer.looking_at_parameter_list = false;
 }
 // Make an index expression.
 tree_index_expression *
-octave_parser::make_index_expression (tree_expression *expr,
+octave_base_parser::make_index_expression (tree_expression *expr,
-tree_argument_list *args, char type)
+tree_argument_list *args,
+char type)
 {
 tree_index_expression *retval = 0;
 if (args && args->has_magic_tilde ())
 {
 }
 // Make an indirect reference expression.
 tree_index_expression *
-octave_parser::make_indirect_ref (tree_expression *expr,
+octave_base_parser::make_indirect_ref (tree_expression *expr,
 const std::string& elt)
 {
 tree_index_expression *retval = 0;
 int l = expr->line ();
 int c = expr->column ();
 retval = tmp;
 }
 else
 retval = new tree_index_expression (expr, elt, l, c);
-curr_lexer->looking_at_indirect_ref = false;
+curr_lexer.looking_at_indirect_ref = false;
 return retval;
 }
 // Make an indirect reference expression with dynamic field name.
 tree_index_expression *
-octave_parser::make_indirect_ref (tree_expression *expr, tree_expression *elt)
+octave_base_parser::make_indirect_ref (tree_expression *expr, tree_expression *elt)
 {
 tree_index_expression *retval = 0;
 int l = expr->line ();
 int c = expr->column ();
 retval = tmp;
 }
 else
 retval = new tree_index_expression (expr, elt, l, c);
-curr_lexer->looking_at_indirect_ref = false;
+curr_lexer.looking_at_indirect_ref = false;
 return retval;
 }
 // Make a declaration command.
 tree_decl_command *
-octave_parser::make_decl_command (int tok, token *tok_val,
+octave_base_parser::make_decl_command (int tok, token *tok_val,
 tree_decl_init_list *lst)
 {
 tree_decl_command *retval = 0;
 int l = tok_val->line ();
 int c = tok_val->column ();
 case PERSISTENT:
 if (curr_fcn_depth > 0)
 retval = new tree_persistent_command (lst, l, c);
 else
 {
-if (curr_lexer->reading_script_file)
+if (curr_lexer.reading_script_file)
 warning ("ignoring persistent declaration near line %d of file '%s'",
-l, curr_lexer->fcn_file_full_name.c_str ());
+l, curr_lexer.fcn_file_full_name.c_str ());
 else
 warning ("ignoring persistent declaration near line %d", l);
 }
 break;
 return retval;
 }
 bool
-octave_parser::validate_array_list (tree_expression *e)
+octave_base_parser::validate_array_list (tree_expression *e)
 {
 bool retval = true;
 tree_array_list *al = dynamic_cast<tree_array_list *> (e);
 return retval;
 }
 tree_argument_list *
-octave_parser::validate_matrix_for_assignment (tree_expression *e)
+octave_base_parser::validate_matrix_for_assignment (tree_expression *e)
 {
 tree_argument_list *retval = 0;
 if (e->is_constant ())
 {
 }
 // Finish building an array_list.
 tree_expression *
-octave_parser::finish_array_list (tree_array_list *array_list)
+octave_base_parser::finish_array_list (tree_array_list *array_list)
 {
 tree_expression *retval = array_list;
 unwind_protect frame;
 }
 // Finish building a matrix list.
 tree_expression *
-octave_parser::finish_matrix (tree_matrix *m)
+octave_base_parser::finish_matrix (tree_matrix *m)
 {
 return finish_array_list (m);
 }
 // Finish building a cell list.
 tree_expression *
-octave_parser::finish_cell (tree_cell *c)
+octave_base_parser::finish_cell (tree_cell *c)
 {
 return finish_array_list (c);
 }
 void
-octave_parser::maybe_warn_missing_semi (tree_statement_list *t)
+octave_base_parser::maybe_warn_missing_semi (tree_statement_list *t)
 {
 if (curr_fcn_depth > 0)
 {
 tree_statement *tmp = t->back ();
 if (tmp->is_expression ())
 warning_with_id
 ("Octave:missing-semicolon",
 "missing semicolon near line %d, column %d in file '%s'",
-tmp->line (), tmp->column (), curr_lexer->fcn_file_full_name.c_str ());
+tmp->line (), tmp->column (), curr_lexer.fcn_file_full_name.c_str ());
 }
 }
 tree_statement_list *
-octave_parser::set_stmt_print_flag (tree_statement_list *list, char sep,
+octave_base_parser::set_stmt_print_flag (tree_statement_list *list,
-bool warn_missing_semi)
+char sep, bool warn_missing_semi)
 {
 tree_statement *tmp = list->back ();
 switch (sep)
 {
 return list;
 }
 tree_statement_list *
-octave_parser::make_statement_list (tree_statement *stmt)
+octave_base_parser::make_statement_list (tree_statement *stmt)
 {
 return new tree_statement_list (stmt);
 }
 tree_statement_list *
-octave_parser::append_statement_list (tree_statement_list *list, char sep,
+octave_base_parser::append_statement_list (tree_statement_list *list,
-tree_statement *stmt,
+char sep, tree_statement *stmt,
 bool warn_missing_semi)
 {
 set_stmt_print_flag (list, sep, warn_missing_semi);
 list->append (stmt);
 return list;
 }
 void
-octave_parser::bison_error (const char *s)
+octave_base_parser::bison_error (const char *s)
 {
-int err_col = curr_lexer->current_input_column - 1;
+int err_col = curr_lexer.current_input_column - 1;
 std::ostringstream output_buf;
-if (curr_lexer->reading_fcn_file || curr_lexer->reading_script_file || curr_lexer->reading_classdef_file)
+if (curr_lexer.reading_fcn_file || curr_lexer.reading_script_file || curr_lexer.reading_classdef_file)
-output_buf << "parse error near line " << curr_lexer->input_line_number
+output_buf << "parse error near line " << curr_lexer.input_line_number
-<< " of file " << curr_lexer->fcn_file_full_name;
+<< " of file " << curr_lexer.fcn_file_full_name;
 else
 output_buf << "parse error:";
 if (s && strcmp (s, "parse error") != 0)
 output_buf << "\n\n  " << s;
 output_buf << "\n\n";
-std::string curr_line = curr_lexer->current_input_line;
+std::string curr_line = curr_lexer.current_input_line;
 if (! curr_line.empty ())
 {
 size_t len = curr_line.length ();
 output_buf << "\n";
 std::string msg = output_buf.str ();
 parse_error ("%s", msg.c_str ());
+}
+int
+octave_parser::run (void)
+{
+return octave_parse (*this);
 }
 static void
 safe_fclose (FILE *f)
 {
 frame.add_fcn (safe_fclose, ffile);
 if (ffile)
 {
-// octave_parser constructor sets this for us.
+// octave_base_parser constructor sets this for us.
 frame.protect_var (CURR_LEXER);
 octave_parser curr_parser (ffile);
 curr_parser.curr_class_name = dispatch_type;
 curr_parser.autoloading = autoload;
 curr_parser.fcn_file_from_relative_lookup = relative_lookup;
-curr_parser.curr_lexer->force_script = force_script;
+curr_parser.curr_lexer.force_script = force_script;
-curr_parser.curr_lexer->prep_for_file ();
+curr_parser.curr_lexer.prep_for_file ();
-curr_parser.curr_lexer->parsing_class_method = ! dispatch_type.empty ();
+curr_parser.curr_lexer.parsing_class_method = ! dispatch_type.empty ();
-curr_parser.curr_lexer->fcn_file_name = file;
+curr_parser.curr_lexer.fcn_file_name = file;
-curr_parser.curr_lexer->fcn_file_full_name = full_file;
+curr_parser.curr_lexer.fcn_file_full_name = full_file;
 int status = curr_parser.run ();
 fcn_ptr = curr_parser.primary_fcn_ptr;
 {
 octave_value_list retval;
 unwind_protect frame;
-// octave_parser constructor sets this for us.
+// octave_base_parser constructor sets this for us.
 frame.protect_var (CURR_LEXER);
 octave_parser curr_parser (eval_str);
 do
 || tree_return_command::returning
 || tree_break_command::breaking
 || tree_continue_command::continuing)
 break;
 }
-else if (curr_parser.curr_lexer->end_of_input)
+else if (curr_parser.curr_lexer.end_of_input)
 break;
 }
 }
 while (parse_status == 0);

Mercurial > hg > octave-nkf

comparison libinterp/parse-tree/oct-parse.in.yy @ 16287:04a7953496a7