Mercurial > octave
view libinterp/parse-tree/pt-stmt.h @ 21157:94fc5f13d51b
dbstop: conditional breakpoint, dbstop if caught error etc. (bug #46795)
* debug.cc (parse_dbfunction_params): Accept "in", "at" and "if" tokens.
Only breakpoints are returned; "dbstop if error" etc. are processed in
the parser.
* debug.cc (dbstop_process_map_ags, Fdbstop): set breakpoints etc. based on the
output of A=dbstatus. The structure of A is not Matlab compatible.
* debug.cc (do_add_breakpoint_1, do_get_breakpoint_list): Store file
(not subfunction) names in bp_set, to avoid crash in "dbclear all".
* debug.cc (dbclear_all_signals, condition_valid,
stop_on_err_warn_status): New function
* debug.cc (do_add_breakpoint): take "condition" parameter.
* debug.cc (do_get_breakpoint_list): Make invariant copy of bp_set (bug #44195)
* debug.cc (do_add_breakpoint, do_remove_breakpoint,
do_remove_all_breakpoints_in_file): More informative error messages.
* debug.cc (Fdbclear): clear break on signals (error, warning etc.)
* debug.cc (Fdbstatus): Return all breakpoints when debugging, so that
"s = dbstatus; ...; dbstop (s)" works.
(Related to bug #41338, bug #41556)
* debug.cc (Fdbstatus): Return structure with conditions, and "if error" etc.
* debug.h (debug_on_err, debug_on_caught, debug_on_warn): New functions
* debug.h: Rename "fname_line_map" to "fname_bp_map", as it has conditions
* error.cc (verror): Allow dbstop on selected errors, or errors in try/catch
* error.h New globals: Vdebug_on_caught, in_try_catch.
* toplev.cc: Experimental code for Matlab's "dbstop if naninf".
* symtab.cc (load_class_constructor): Add class constructors to list of
methods so they can be breakpointed
* pt-pb.{cc,h} (take_action): Add "condition" to set_breakpoint call,
track bp_cond_list.
* pt-eval.cc visit_.*_command: Ask if breakpoint condition is satisfied.
* pt-eval.cc (visit_try_catch_command): Count the number of levels of
try/catch we are in to allow "dbstop if caught error".
* pt-stmt.cc (set_breakpoint): Pass condition
* pt-stmt.cc (is_breakpoint): If new argument is true, only return true
if the condition is set.
* pt-stmt.cc (bp_cond, preakpoints_and_conds): new function
* pt-stmt.h: new declarations
* pt.{cc,h} (meets_bp_condition, bp_cond): New function
* octave-link.h (update_breakpoint): Accept condition
author | Lachlan Andrew <lachlanbis@gmail.com> |
---|---|
date | Sun, 24 Jan 2016 11:02:30 +1100 |
parents | f7084eae3318 |
children | 1473547f50f5 |
line wrap: on
line source
/* Copyright (C) 1996-2015 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_pt_stmt_h) #define octave_pt_stmt_h 1 class octave_value_list; class tree_command; class tree_expression; class tree_walker; #include <deque> #include "base-list.h" #include "comment-list.h" #include "debug.h" #include "symtab.h" #include "pt.h" // A statement is either a command to execute or an expression to // evaluate. class tree_statement : public tree { public: tree_statement (void) : cmd (0), expr (0), comm (0) { } tree_statement (tree_command *c, octave_comment_list *cl) : cmd (c), expr (0), comm (cl) { } tree_statement (tree_expression *e, octave_comment_list *cl) : cmd (0), expr (e), comm (cl) { } ~tree_statement (void); void set_print_flag (bool print_flag); bool print_result (void); bool is_command (void) const { return cmd != 0; } bool is_expression (void) const { return expr != 0; } void set_breakpoint (const std::string& condition); void delete_breakpoint (void); bool is_breakpoint (bool check_valid = false) const; std::string bp_cond () const; int line (void) const; int column (void) const; void set_location (int l, int c); void echo_code (void); tree_command *command (void) { return cmd; } tree_expression *expression (void) { return expr; } octave_comment_list *comment_text (void) { return comm; } bool is_null_statement (void) const { return ! (cmd || expr || comm); } bool is_end_of_fcn_or_script (void) const; bool is_end_of_file (void) const; // Allow modification of this statement. Note that there is no // checking. If you use these, are you sure you knwo what you are // doing? void set_command (tree_command *c) { cmd = c; } void set_expression (tree_expression *e) { expr = e; } tree_statement *dup (symbol_table::scope_id scope, symbol_table::context_id context) const; void accept (tree_walker& tw); private: // Only one of cmd or expr can be valid at once. // Command to execute. tree_command *cmd; // Expression to evaluate. tree_expression *expr; // Comment associated with this statement. octave_comment_list *comm; // No copying! tree_statement (const tree_statement&); tree_statement& operator = (const tree_statement&); }; // A list of statements to evaluate. class tree_statement_list : public octave_base_list<tree_statement *> { public: tree_statement_list (void) : function_body (false), anon_function_body (false), script_body (false) { } tree_statement_list (tree_statement *s) : function_body (false), anon_function_body (false), script_body (false) { append (s); } ~tree_statement_list (void) { while (! empty ()) { iterator p = begin (); delete *p; erase (p); } } void mark_as_function_body (void) { function_body = true; } void mark_as_anon_function_body (void) { anon_function_body = true; } void mark_as_script_body (void) { script_body = true; } bool is_function_body (void) const { return function_body; } bool is_anon_function_body (void) const { return anon_function_body; } bool is_script_body (void) const { return script_body; } int set_breakpoint (int line, const std::string& condition); void delete_breakpoint (int line); octave_value_list list_breakpoints (void); std::list<bp_type> breakpoints_and_conds (void); bp_table::intmap add_breakpoint (const std::string& file, const bp_table::intmap& line, const std::string& condition); bp_table::intmap remove_all_breakpoints (const std::string& file); tree_statement_list *dup (symbol_table::scope_id scope, symbol_table::context_id context) const; void accept (tree_walker& tw); private: // Does this list of statements make up the body of a function? bool function_body; // Does this list of statements make up the body of a function? bool anon_function_body; // Does this list of statements make up the body of a script? bool script_body; // No copying! tree_statement_list (const tree_statement_list&); tree_statement_list& operator = (const tree_statement_list&); }; #endif