Mercurial > octave-nkf
view libinterp/parse-tree/parse.h @ 16134:ec9c6222ef5a
move static parser helper functions to octave_parser class
* oct-parse.yy, parse.h (append_statement_list, end_error,
end_token_ok, finish_cell, finish_colon_expression, finish_function,
finish_if_command, finish_matrix, finish_switch_command,
frob_function, make_anon_fcn_handle, make_assign_op, make_binary_op,
make_boolean_op, make_break_command, make_constant,
make_continue_command, make_decl_command, make_do_until_command,
make_elseif_clause, make_end, make_fcn_handle, make_for_command,
make_index_expression, make_indirect_ref, make_postfix_op,
make_prefix_op, make_return_command, make_script,
make_statement_list, make_switch_case, make_try_command,
make_unwind_command, make_while_command,
maybe_warn_assign_as_truth_value, maybe_warn_missing_semi,
maybe_warn_variable_switch_label, recover_from_parsing_function,
set_stmt_print_flag, start_function, start_if_command,
validate_matrix_row): Declare as members of octave_parser class.
Change all callers.
author | John W. Eaton <jwe@octave.org> |
---|---|
date | Tue, 26 Feb 2013 21:04:40 -0500 |
parents | 249d62b3fac8 |
children | ed36d5543b27 |
line wrap: on
line source
/* Copyright (C) 1993-2012 John W. Eaton This file is part of Octave. Octave is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. Octave is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with Octave; see the file COPYING. If not, see <http://www.gnu.org/licenses/>. */ #if !defined (octave_parse_h) #define octave_parse_h 1 #include <cstdio> #include <string> #include <stack> #include "token.h" extern int octave_lex (void); class octave_comment_list; class octave_function; class octave_user_function; class tree; class tree_anon_fcn_handle; class tree_argument_list; class tree_cell; class tree_colon_expression; class tree_command; class tree_constant; class tree_decl_command; class tree_decl_init_list; class tree_expression; class tree_fcn_handle; class tree_function_def; class tree_identifier; class tree_if_clause; class tree_if_command; class tree_if_command_list; class tree_index_expression; class tree_matrix; class tree_matrix; class tree_parameter_list; class tree_statement; class tree_statement_list; class tree_statement_listtree_statement; class tree_switch_case; class tree_switch_case_list; class tree_switch_command; #include "oct-obj.h" // Nonzero means print parser debugging info (-d). extern int octave_debug; // Buffer for help text snagged from function files. extern std::stack<std::string> help_buf; // TRUE means we are using readline. extern bool line_editing; // TRUE means we printed messages about reading startup files. extern bool reading_startup_message_printed; // TRUE means input is coming from startup file. extern bool input_from_startup_file; // Name of the current class when we are parsing class methods or // constructors. extern std::string current_class_name; extern OCTINTERP_API std::string get_help_from_file (const std::string& nm, bool& symbol_found, std::string& file); extern OCTINTERP_API std::string get_help_from_file (const std::string& nm, bool& symbol_found); extern OCTINTERP_API std::string lookup_autoload (const std::string& nm); extern OCTINTERP_API string_vector autoloaded_functions (void); extern OCTINTERP_API string_vector reverse_lookup_autoload (const std::string& nm); extern OCTINTERP_API octave_function * load_fcn_from_file (const std::string& file_name, const std::string& dir_name = std::string (), const std::string& dispatch_type = std::string (), const std::string& fcn_name = std::string (), bool autoload = false); extern OCTINTERP_API void source_file (const std::string& file_name, const std::string& context = std::string (), bool verbose = false, bool require_file = true, const std::string& warn_for = std::string ()); extern OCTINTERP_API octave_value_list feval (const std::string& name, const octave_value_list& args = octave_value_list (), int nargout = 0); extern OCTINTERP_API octave_value_list feval (octave_function *fcn, const octave_value_list& args = octave_value_list (), int nargout = 0); extern OCTINTERP_API octave_value_list feval (const octave_value_list& args, int nargout = 0); extern OCTINTERP_API octave_value_list eval_string (const std::string&, bool silent, int& parse_status, int hargout); extern OCTINTERP_API octave_value eval_string (const std::string&, bool silent, int& parse_status); extern OCTINTERP_API void cleanup_statement_list (tree_statement_list **lst); extern OCTINTERP_API int octave_parse_input (void); class octave_parser { public: octave_parser (void) { } ~octave_parser (void) { } // Error mesages for mismatched end tokens. static void end_error (const char *type, token::end_tok_type ettype, int l, int c); // Check to see that end tokens are properly matched. static bool end_token_ok (token *tok, token::end_tok_type expected); // Maybe print a warning if an assignment expression is used as the // test in a logical expression. static void maybe_warn_assign_as_truth_value (tree_expression *expr); // Maybe print a warning about switch labels that aren't constants. static void maybe_warn_variable_switch_label (tree_expression *expr); // Finish building a range. static tree_expression * finish_colon_expression (tree_colon_expression *e); // Build a constant. static tree_constant * make_constant (int op, token *tok_val); // Build a function handle. static tree_fcn_handle * make_fcn_handle (token *tok_val); // Build an anonymous function handle. static tree_anon_fcn_handle * make_anon_fcn_handle (tree_parameter_list *param_list, tree_statement *stmt); // Build a binary expression. static tree_expression * make_binary_op (int op, tree_expression *op1, token *tok_val, tree_expression *op2); // Build a boolean expression. static tree_expression * make_boolean_op (int op, tree_expression *op1, token *tok_val, tree_expression *op2); // Build a prefix expression. static tree_expression * make_prefix_op (int op, tree_expression *op1, token *tok_val); // Build a postfix expression. static tree_expression * make_postfix_op (int op, tree_expression *op1, token *tok_val); // Build an unwind-protect command. static tree_command * make_unwind_command (token *unwind_tok, tree_statement_list *body, tree_statement_list *cleanup, token *end_tok, octave_comment_list *lc, octave_comment_list *mc); // Build a try-catch command. static tree_command * make_try_command (token *try_tok, tree_statement_list *body, tree_statement_list *cleanup, token *end_tok, octave_comment_list *lc, octave_comment_list *mc); // Build a while command. static tree_command * make_while_command (token *while_tok, tree_expression *expr, tree_statement_list *body, token *end_tok, octave_comment_list *lc); // Build a do-until command. static tree_command * make_do_until_command (token *until_tok, tree_statement_list *body, tree_expression *expr, octave_comment_list *lc); // Build a for command. static tree_command * 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, octave_comment_list *lc); // Build a break command. static tree_command * make_break_command (token *break_tok); // Build a continue command. static tree_command * make_continue_command (token *continue_tok); // Build a return command. static tree_command * make_return_command (token *return_tok); // Start an if command. static tree_if_command_list * start_if_command (tree_expression *expr, tree_statement_list *list); // Finish an if command. static tree_if_command * finish_if_command (token *if_tok, tree_if_command_list *list, token *end_tok, octave_comment_list *lc); // Build an elseif clause. static tree_if_clause * make_elseif_clause (token *elseif_tok, tree_expression *expr, tree_statement_list *list, octave_comment_list *lc); // Finish a switch command. static tree_switch_command * finish_switch_command (token *switch_tok, tree_expression *expr, tree_switch_case_list *list, token *end_tok, octave_comment_list *lc); // Build a switch case. static tree_switch_case * make_switch_case (token *case_tok, tree_expression *expr, tree_statement_list *list, octave_comment_list *lc); // Build an assignment to a variable. static tree_expression * make_assign_op (int op, tree_argument_list *lhs, token *eq_tok, tree_expression *rhs); // Define a script. static void make_script (tree_statement_list *cmds, tree_statement *end_script); // Begin defining a function. static octave_user_function * start_function (tree_parameter_list *param_list, tree_statement_list *body, tree_statement *end_function); // Create a no-op statement for end_function. static tree_statement * make_end (const std::string& type, int l, int c); // Do most of the work for defining a function. static octave_user_function * frob_function (const std::string& fname, octave_user_function *fcn); // Finish defining a function. static tree_function_def * finish_function (tree_parameter_list *ret_list, octave_user_function *fcn, octave_comment_list *lc); // Reset state after parsing function. static void recover_from_parsing_function (void); // Make an index expression. static tree_index_expression * make_index_expression (tree_expression *expr, tree_argument_list *args, char type); // Make an indirect reference expression. static tree_index_expression * make_indirect_ref (tree_expression *expr, const std::string&); // Make an indirect reference expression with dynamic field name. static tree_index_expression * make_indirect_ref (tree_expression *expr, tree_expression *field); // Make a declaration command. static tree_decl_command * make_decl_command (int tok, token *tok_val, tree_decl_init_list *lst); // Validate argument list forming a matrix or cell row. static tree_argument_list * validate_matrix_row (tree_argument_list *row); // Finish building a matrix list. static tree_expression * finish_matrix (tree_matrix *m); // Finish building a cell list. static tree_expression * finish_cell (tree_cell *c); // Maybe print a warning. Duh. static void maybe_warn_missing_semi (tree_statement_list *); // Set the print flag for a statement based on the separator type. static tree_statement_list * set_stmt_print_flag (tree_statement_list *, char, bool); // Create a statement list. static tree_statement_list *make_statement_list (tree_statement *stmt); // Append a statement to an existing statement list. static tree_statement_list * append_statement_list (tree_statement_list *list, char sep, tree_statement *stmt, bool warn_missing_semi); // For unwind protect. static void cleanup (octave_parser *parser) { delete parser; } private: // No copying! octave_parser (const octave_parser&); octave_parser& operator = (const octave_parser&); }; // The current state of the parser. extern octave_parser *curr_parser; #endif