octave: libinterp/parse-tree/pt-eval.cc comparison

comparison libinterp/parse-tree/pt-eval.cc @ 22196:dd992fd74fce

put parser, lexer, and evaluator in namespace; interpreter now owns evaluator * oct-parse.in.yy, parse.h: Move parser classes to octave namespace. * lex.ll, lex.h: Move lexer classes to octave namespace. * pt-eval.h, pt-eval.cc: Move evaluator class to octave namespace. Don't define global current evaluator pointer here. * debug.cc, error.cc, input.cc, input.h, ls-mat-ascii.cc, pt-jit.cc, sighandlers.cc, utils.cc, variables.cc, ov-usr-fcn.cc, pt-assign.cc, pt-exp.h, pt-id.cc: Update for namespaces. * interpreter.cc, interpreter.h (current_evaluator): New global var. (interpreter::m_evaluator): New data member. (interpreter::~interpreter): Delete evaluator.

author	John W. Eaton <jwe@octave.org>
date	Tue, 12 Jul 2016 14:28:07 -0400
parents	5d4a286061c8
children	bac0d6f07a3e

comparison

equal deleted inserted replaced

-:93ed9396f2c3
+:dd992fd74fce
 #include "unwind-prot.h"
 //FIXME: This should be part of tree_evaluator
 #include "pt-jit.h"
-static tree_evaluator std_evaluator;
-tree_evaluator *current_evaluator = &std_evaluator;
-int tree_evaluator::dbstep_flag = 0;
-size_t tree_evaluator::current_frame = 0;
-bool tree_evaluator::debug_mode = false;
-bool tree_evaluator::quiet_breakpoint_flag = false;
-tree_evaluator::stmt_list_type tree_evaluator::statement_context
-= tree_evaluator::other;
-bool tree_evaluator::in_loop_command = false;
 // Maximum nesting level for functions, scripts, or sourced files called
 // recursively.
 int Vmax_recursion_depth = 256;
 // If TRUE, turn off printing of results in functions (as if a
 // semicolon has been appended to each statement).
 static bool Vsilent_functions = false;
-// Normal evaluator.
+namespace octave
-void
-tree_evaluator::visit_anon_fcn_handle (tree_anon_fcn_handle&)
 {
-panic_impossible ();
+int tree_evaluator::dbstep_flag = 0;
-}
+size_t tree_evaluator::current_frame = 0;
-void
-tree_evaluator::visit_argument_list (tree_argument_list&)
+bool tree_evaluator::debug_mode = false;
-{
-panic_impossible ();
+bool tree_evaluator::quiet_breakpoint_flag = false;
-}
+tree_evaluator::stmt_list_type tree_evaluator::statement_context
-void
+= tree_evaluator::other;
-tree_evaluator::visit_binary_expression (tree_binary_expression&)
-{
+bool tree_evaluator::in_loop_command = false;
-panic_impossible ();
-}
+// Normal evaluator.
 void
-tree_evaluator::visit_break_command (tree_break_command& cmd)
+tree_evaluator::visit_anon_fcn_handle (tree_anon_fcn_handle&)
 {
-if (debug_mode)
+panic_impossible ();
-do_breakpoint (cmd.is_breakpoint (true));
+}
-if (statement_context == function || statement_context == script
+void
-|| in_loop_command)
+tree_evaluator::visit_argument_list (tree_argument_list&)
-tree_break_command::breaking = 1;
+{
-}
+panic_impossible ();
+}
-void
-tree_evaluator::visit_colon_expression (tree_colon_expression&)
+void
-{
+tree_evaluator::visit_binary_expression (tree_binary_expression&)
-panic_impossible ();
+{
-}
+panic_impossible ();
+}
-void
-tree_evaluator::visit_continue_command (tree_continue_command& cmd)
+void
-{
+tree_evaluator::visit_break_command (tree_break_command& cmd)
-if (debug_mode)
+{
-do_breakpoint (cmd.is_breakpoint (true));
+if (debug_mode)
+do_breakpoint (cmd.is_breakpoint (true));
-if (statement_context == function || statement_context == script
-|| in_loop_command)
+if (statement_context == function || statement_context == script
-tree_continue_command::continuing = 1;
+|| in_loop_command)
-}
+tree_break_command::breaking = 1;
+}
-void
-tree_evaluator::reset_debug_state (void)
+void
-{
+tree_evaluator::visit_colon_expression (tree_colon_expression&)
-debug_mode = bp_table::have_breakpoints () || Vdebugging;
+{
+panic_impossible ();
-dbstep_flag = 0;
+}
-}
+void
-bool
+tree_evaluator::visit_continue_command (tree_continue_command& cmd)
-tree_evaluator::statement_printing_enabled (void)
+{
-{
+if (debug_mode)
-return ! (Vsilent_functions && (statement_context == function
+do_breakpoint (cmd.is_breakpoint (true));
-|| statement_context == script));
+if (statement_context == function || statement_context == script
+|| in_loop_command)
+tree_continue_command::continuing = 1;
+}
+void
+tree_evaluator::reset_debug_state (void)
+{
+debug_mode = bp_table::have_breakpoints () || Vdebugging;
+dbstep_flag = 0;
+}
+bool
+tree_evaluator::statement_printing_enabled (void)
+{
+return ! (Vsilent_functions && (statement_context == function
+|| statement_context == script));
+}
 }
 static inline void
 do_global_init (tree_decl_elt& elt)
 {
 ult.assign (octave_value::op_asn_eq, init_val);
 }
 }
 }
-void
+namespace octave
-tree_evaluator::do_decl_init_list (decl_elt_init_fcn fcn,
-tree_decl_init_list *init_list)
 {
-if (init_list)
+void
-{
+tree_evaluator::do_decl_init_list (decl_elt_init_fcn fcn,
-for (tree_decl_init_list::iterator p = init_list->begin ();
+tree_decl_init_list *init_list)
-p != init_list->end (); p++)
+{
-{
+if (init_list)
-tree_decl_elt *elt = *p;
+{
+for (tree_decl_init_list::iterator p = init_list->begin ();
-fcn (*elt);
+p != init_list->end (); p++)
-}
+{
-}
+tree_decl_elt *elt = *p;
-}
+fcn (*elt);
-void
+}
-tree_evaluator::visit_global_command (tree_global_command& cmd)
+}
-{
+}
-if (debug_mode)
-do_breakpoint (cmd.is_breakpoint (true));
+void
+tree_evaluator::visit_global_command (tree_global_command& cmd)
-do_decl_init_list (do_global_init, cmd.initializer_list ());
+{
-}
+if (debug_mode)
+do_breakpoint (cmd.is_breakpoint (true));
-void
-tree_evaluator::visit_persistent_command (tree_persistent_command& cmd)
+do_decl_init_list (do_global_init, cmd.initializer_list ());
-{
+}
-if (debug_mode)
-do_breakpoint (cmd.is_breakpoint (true));
+void
+tree_evaluator::visit_persistent_command (tree_persistent_command& cmd)
-do_decl_init_list (do_static_init, cmd.initializer_list ());
+{
-}
+if (debug_mode)
+do_breakpoint (cmd.is_breakpoint (true));
-void
-tree_evaluator::visit_decl_elt (tree_decl_elt&)
+do_decl_init_list (do_static_init, cmd.initializer_list ());
-{
+}
-panic_impossible ();
-}
+void
+tree_evaluator::visit_decl_elt (tree_decl_elt&)
-#if 0
+{
-bool
+panic_impossible ();
-tree_decl_elt::eval (void)
+}
-{
-bool retval = false;
+void
+tree_evaluator::visit_decl_init_list (tree_decl_init_list&)
-if (id && expr)
+{
-{
+panic_impossible ();
-octave_lvalue ult = id->lvalue ();
+}
-octave_value init_val = expr->rvalue1 ();
-ult.assign (octave_value::op_asn_eq, init_val);
-retval = true;
-}
-return retval;
-}
-#endif
-void
-tree_evaluator::visit_decl_init_list (tree_decl_init_list&)
-{
-panic_impossible ();
 }
 // Decide if it's time to quit a for or while loop.
 static inline bool
 quit_loop_now (void)
 tree_break_command::breaking--;
 return quit;
 }
-void
+namespace octave
-tree_evaluator::visit_simple_for_command (tree_simple_for_command& cmd)
 {
-if (debug_mode)
+void
-do_breakpoint (cmd.is_breakpoint (true));
+tree_evaluator::visit_simple_for_command (tree_simple_for_command& cmd)
+{
-// FIXME: need to handle PARFOR loops here using cmd.in_parallel ()
+if (debug_mode)
-// and cmd.maxproc_expr ();
+do_breakpoint (cmd.is_breakpoint (true));
-octave::unwind_protect frame;
+// FIXME: need to handle PARFOR loops here using cmd.in_parallel ()
+// and cmd.maxproc_expr ();
-frame.protect_var (in_loop_command);
+octave::unwind_protect frame;
-in_loop_command = true;
+frame.protect_var (in_loop_command);
-tree_expression *expr = cmd.control_expr ();
+in_loop_command = true;
-octave_value rhs = expr->rvalue1 ();
+tree_expression *expr = cmd.control_expr ();
+octave_value rhs = expr->rvalue1 ();
 #if defined (HAVE_LLVM)
 if (tree_jit::execute (cmd, rhs))
 return;
 #endif
 if (rhs.is_undefined ())
 return;
 tree_expression *lhs = cmd.left_hand_side ();
 octave_lvalue ult = lhs->lvalue ();
 tree_statement_list *loop_body = cmd.body ();
 if (rhs.is_range ())
 {
 Range rng = rhs.range_value ();
 octave_idx_type steps = rng.numel ();
 for (octave_idx_type i = 0; i < steps; i++)
+{
+octave_value val (rng.elem (i));
+ult.assign (octave_value::op_asn_eq, val);
+if (loop_body)
+loop_body->accept (*this);
+if (quit_loop_now ())
+break;
+}
+}
+else if (rhs.is_scalar_type ())
+{
+ult.assign (octave_value::op_asn_eq, rhs);
+if (loop_body)
+loop_body->accept (*this);
+// Maybe decrement break and continue states.
+quit_loop_now ();
+}
+else if (rhs.is_matrix_type () || rhs.is_cell () || rhs.is_string ()
+|| rhs.is_map ())
+{
+// A matrix or cell is reshaped to 2 dimensions and iterated by
+// columns.
+dim_vector dv = rhs.dims ().redim (2);
+octave_idx_type nrows = dv(0);
+octave_idx_type steps = dv(1);
+if (steps > 0)
+{
+octave_value arg = rhs;
+if (rhs.ndims () > 2)
+arg = arg.reshape (dv);
+// for row vectors, use single index to speed things up.
+octave_value_list idx;
+octave_idx_type iidx;
+if (nrows == 1)
+{
+idx.resize (1);
+iidx = 0;
+}
+else
+{
+idx.resize (2);
+idx(0) = octave_value::magic_colon_t;
+iidx = 1;
+}
+for (octave_idx_type i = 1; i <= steps; i++)
+{
+// do_index_op expects one-based indices.
+idx(iidx) = i;
+octave_value val = arg.do_index_op (idx);
+ult.assign (octave_value::op_asn_eq, val);
+if (loop_body)
+loop_body->accept (*this);
+if (quit_loop_now ())
+break;
+}
+}
+}
+else
+error ("invalid type in for loop expression near line %d, column %d",
+cmd.line (), cmd.column ());
+}
+void
+tree_evaluator::visit_complex_for_command (tree_complex_for_command& cmd)
+{
+if (debug_mode)
+do_breakpoint (cmd.is_breakpoint (true));
+octave::unwind_protect frame;
+frame.protect_var (in_loop_command);
+in_loop_command = true;
+tree_expression *expr = cmd.control_expr ();
+octave_value rhs = expr->rvalue1 ();
+if (rhs.is_undefined ())
+return;
+if (! rhs.is_map ())
+error ("in statement 'for [X, Y] = VAL', VAL must be a structure");
+// Cycle through structure elements.  First element of id_list
+// is set to value and the second is set to the name of the
+// structure element.
+tree_argument_list *lhs = cmd.left_hand_side ();
+tree_argument_list::iterator p = lhs->begin ();
+tree_expression *elt = *p++;
+octave_lvalue val_ref = elt->lvalue ();
+elt = *p;
+octave_lvalue key_ref = elt->lvalue ();
+const octave_map tmp_val = rhs.map_value ();
+tree_statement_list *loop_body = cmd.body ();
+string_vector keys = tmp_val.keys ();
+octave_idx_type nel = keys.numel ();
+for (octave_idx_type i = 0; i < nel; i++)
+{
+std::string key = keys[i];
+const Cell val_lst = tmp_val.contents (key);
+octave_idx_type n = val_lst.numel ();
+octave_value val = (n == 1) ? val_lst(0) : octave_value (val_lst);
+val_ref.assign (octave_value::op_asn_eq, val);
+key_ref.assign (octave_value::op_asn_eq, key);
+if (loop_body)
+loop_body->accept (*this);
+if (quit_loop_now ())
+break;
+}
+}
+void
+tree_evaluator::visit_octave_user_script (octave_user_script&)
+{
+panic_impossible ();
+}
+void
+tree_evaluator::visit_octave_user_function (octave_user_function&)
+{
+panic_impossible ();
+}
+void
+tree_evaluator::visit_octave_user_function_header (octave_user_function&)
+{
+panic_impossible ();
+}
+void
+tree_evaluator::visit_octave_user_function_trailer (octave_user_function&)
+{
+panic_impossible ();
+}
+void
+tree_evaluator::visit_function_def (tree_function_def& cmd)
+{
+octave_value fcn = cmd.function ();
+octave_function *f = fcn.function_value ();
+if (f)
+{
+std::string nm = f->name ();
+symbol_table::install_cmdline_function (nm, fcn);
+// Make sure that any variable with the same name as the new
+// function is cleared.
+symbol_table::assign (nm);
+}
+}
+void
+tree_evaluator::visit_identifier (tree_identifier&)
+{
+panic_impossible ();
+}
+void
+tree_evaluator::visit_if_clause (tree_if_clause&)
+{
+panic_impossible ();
+}
+void
+tree_evaluator::visit_if_command (tree_if_command& cmd)
+{
+tree_if_command_list *lst = cmd.cmd_list ();
+if (lst)
+lst->accept (*this);
+}
+void
+tree_evaluator::visit_if_command_list (tree_if_command_list& lst)
+{
+for (tree_if_command_list::iterator p = lst.begin (); p != lst.end (); p++)
+{
+tree_if_clause *tic = *p;
+tree_expression *expr = tic->condition ();
+if (statement_context == function || statement_context == script)
+octave_call_stack::set_location (tic->line (), tic->column ());
+if (debug_mode && ! tic->is_else_clause ())
+do_breakpoint (tic->is_breakpoint (true));
+if (tic->is_else_clause () || expr->is_logically_true ("if"))
+{
+tree_statement_list *stmt_lst = tic->commands ();
+if (stmt_lst)
+stmt_lst->accept (*this);
+break;
+}
+}
+}
+void
+tree_evaluator::visit_index_expression (tree_index_expression&)
+{
+panic_impossible ();
+}
+void
+tree_evaluator::visit_matrix (tree_matrix&)
+{
+panic_impossible ();
+}
+void
+tree_evaluator::visit_cell (tree_cell&)
+{
+panic_impossible ();
+}
+void
+tree_evaluator::visit_multi_assignment (tree_multi_assignment&)
+{
+panic_impossible ();
+}
+void
+tree_evaluator::visit_no_op_command (tree_no_op_command& cmd)
+{
+if (debug_mode && cmd.is_end_of_fcn_or_script ())
+do_breakpoint (cmd.is_breakpoint (true), true);
+}
+void
+tree_evaluator::visit_constant (tree_constant&)
+{
+panic_impossible ();
+}
+void
+tree_evaluator::visit_fcn_handle (tree_fcn_handle&)
+{
+panic_impossible ();
+}
+void
+tree_evaluator::visit_funcall (tree_funcall&)
+{
+panic_impossible ();
+}
+void
+tree_evaluator::visit_parameter_list (tree_parameter_list&)
+{
+panic_impossible ();
+}
+void
+tree_evaluator::visit_postfix_expression (tree_postfix_expression&)
+{
+panic_impossible ();
+}
+void
+tree_evaluator::visit_prefix_expression (tree_prefix_expression&)
+{
+panic_impossible ();
+}
+void
+tree_evaluator::visit_return_command (tree_return_command& cmd)
+{
+if (debug_mode)
+do_breakpoint (cmd.is_breakpoint (true));
+// Act like dbcont.
+if (Vdebugging
+&& octave_call_stack::current_frame () == current_frame)
+{
+Vdebugging = false;
+reset_debug_state ();
+}
+else if (statement_context == function || statement_context == script
+|| in_loop_command)
+tree_return_command::returning = 1;
+}
+void
+tree_evaluator::visit_return_list (tree_return_list&)
+{
+panic_impossible ();
+}
+void
+tree_evaluator::visit_simple_assignment (tree_simple_assignment&)
+{
+panic_impossible ();
+}
+void
+tree_evaluator::visit_statement (tree_statement& stmt)
+{
+tree_command *cmd = stmt.command ();
+tree_expression *expr = stmt.expression ();
+if (cmd || expr)
+{
+if (statement_context == function || statement_context == script)
+{
+// Skip commands issued at a debug> prompt to avoid disturbing
+// the state of the program we are debugging.
+if (Vtrack_line_num)
+octave_call_stack::set_location (stmt.line (), stmt.column ());
+if ((statement_context == script
+&& ((Vecho_executing_commands & ECHO_SCRIPTS
+&& octave_call_stack::all_scripts ())
+|| Vecho_executing_commands & ECHO_FUNCTIONS))
+|| (statement_context == function
+&& Vecho_executing_commands & ECHO_FUNCTIONS))
+stmt.echo_code ();
+}
+try
+{
+if (cmd)
+cmd->accept (*this);
+else
+{
+if (debug_mode)
+do_breakpoint (expr->is_breakpoint (true));
+// FIXME: maybe all of this should be packaged in
+// one virtual function that returns a flag saying whether
+// or not the expression will take care of binding ans and
+// printing the result.
+// FIXME: it seems that we should just have to
+// call expr->rvalue1 () and that should take care of
+// everything, binding ans as necessary?
+bool do_bind_ans = false;
+if (expr->is_identifier ())
+{
+tree_identifier *id = dynamic_cast<tree_identifier *> (expr);
+do_bind_ans = (! id->is_variable ());
+}
+else
+do_bind_ans = (! expr->is_assignment_expression ());
+octave_value tmp_result = expr->rvalue1 (0);
+if (do_bind_ans && tmp_result.is_defined ())
+bind_ans (tmp_result, expr->print_result ()
+&& statement_printing_enabled ());
+//              if (tmp_result.is_defined ())
+//                result_values(0) = tmp_result;
+}
+}
+catch (const std::bad_alloc&)
+{
+// FIXME: We want to use error_with_id here so that give users
+// control over this error message but error_with_id will
+// require some memory allocations.  Is there anything we can
+// do to make those more likely to succeed?
+error_with_id ("Octave:bad-alloc",
+"out of memory or dimension too large for Octave's index type");
+}
+}
+}
+void
+tree_evaluator::visit_statement_list (tree_statement_list& lst)
+{
+// FIXME: commented out along with else clause below.
+// static octave_value_list empty_list;
+tree_statement_list::iterator p = lst.begin ();
+if (p != lst.end ())
+{
+while (true)
+{
+tree_statement *elt = *p++;
+if (! elt)
+error ("invalid statement found in statement list!");
+octave_quit ();
+elt->accept (*this);
+if (tree_break_command::breaking
+|| tree_continue_command::continuing)
+break;
+if (tree_return_command::returning)
+break;
+if (p == lst.end ())
+break;
+else
+{
+// Clear previous values before next statement is
+// evaluated so that we aren't holding an extra
+// reference to a value that may be used next.  For
+// example, in code like this:
+//
+//   X = rand (N);  # refcount for X should be 1
+//                  # after this statement
+//
+//   X(idx) = val;  # no extra copy of X should be
+//                  # needed, but we will be faked
+//                  # out if retval is not cleared
+//                  # between statements here
+//              result_values = empty_list;
+}
+}
+}
+}
+void
+tree_evaluator::visit_switch_case (tree_switch_case&)
+{
+panic_impossible ();
+}
+void
+tree_evaluator::visit_switch_case_list (tree_switch_case_list&)
+{
+panic_impossible ();
+}
+void
+tree_evaluator::visit_switch_command (tree_switch_command& cmd)
+{
+if (debug_mode)
+do_breakpoint (cmd.is_breakpoint (true));
+tree_expression *expr = cmd.switch_value ();
+if (! expr)
+error ("missing value in switch command near line %d, column %d",
+cmd.line (), cmd.column ());
+octave_value val = expr->rvalue1 ();
+tree_switch_case_list *lst = cmd.case_list ();
+if (lst)
+{
+for (tree_switch_case_list::iterator p = lst->begin ();
+p != lst->end (); p++)
+{
+tree_switch_case *t = *p;
+if (t->is_default_case () || t->label_matches (val))
+{
+tree_statement_list *stmt_lst = t->commands ();
+if (stmt_lst)
+stmt_lst->accept (*this);
+break;
+}
+}
+}
+}
+void
+tree_evaluator::visit_try_catch_command (tree_try_catch_command& cmd)
+{
+bool execution_error = false;
+{ // unwind frame before catch block
+octave::unwind_protect frame;
+frame.protect_var (buffer_error_messages);
+frame.protect_var (Vdebug_on_error);
+frame.protect_var (Vdebug_on_warning);
+buffer_error_messages++;
+Vdebug_on_error = false;
+Vdebug_on_warning = false;
+// The catch code is *not* added to unwind_protect stack;
+// it doesn't need to be run on interrupts.
+tree_statement_list *try_code = cmd.body ();
+if (try_code)
 {
-octave_value val (rng.elem (i));
+try
-ult.assign (octave_value::op_asn_eq, val);
-if (loop_body)
-loop_body->accept (*this);
-if (quit_loop_now ())
-break;
-}
-}
-else if (rhs.is_scalar_type ())
-{
-ult.assign (octave_value::op_asn_eq, rhs);
-if (loop_body)
-loop_body->accept (*this);
-// Maybe decrement break and continue states.
-quit_loop_now ();
-}
-else if (rhs.is_matrix_type () || rhs.is_cell () || rhs.is_string ()
-|| rhs.is_map ())
-{
-// A matrix or cell is reshaped to 2 dimensions and iterated by
-// columns.
-dim_vector dv = rhs.dims ().redim (2);
-octave_idx_type nrows = dv(0);
-octave_idx_type steps = dv(1);
-if (steps > 0)
-{
-octave_value arg = rhs;
-if (rhs.ndims () > 2)
-arg = arg.reshape (dv);
-// for row vectors, use single index to speed things up.
-octave_value_list idx;
-octave_idx_type iidx;
-if (nrows == 1)
 {
-idx.resize (1);
+in_try_catch++;
-iidx = 0;
+try_code->accept (*this);
+in_try_catch--;
 }
-else
+catch (const octave_execution_exception&)
 {
-idx.resize (2);
+recover_from_exception ();
-idx(0) = octave_value::magic_colon_t;
-iidx = 1;
+in_try_catch--;          // must be restored before "catch" block
-}
+execution_error = true;
-for (octave_idx_type i = 1; i <= steps; i++)
-{
-// do_index_op expects one-based indices.
-idx(iidx) = i;
-octave_value val = arg.do_index_op (idx);
-ult.assign (octave_value::op_asn_eq, val);
-if (loop_body)
-loop_body->accept (*this);
-if (quit_loop_now ())
-break;
 }
 }
+// Unwind to let the user print any messages from
+// errors that occurred in the body of the try_catch statement,
+// or throw further errors.
 }
-else
-error ("invalid type in for loop expression near line %d, column %d",
+if (execution_error)
-cmd.line (), cmd.column ());
+{
-}
+tree_statement_list *catch_code = cmd.cleanup ();
+if (catch_code)
-void
+{
-tree_evaluator::visit_complex_for_command (tree_complex_for_command& cmd)
+tree_identifier *expr_id = cmd.identifier ();
-{
+octave_lvalue ult;
-if (debug_mode)
-do_breakpoint (cmd.is_breakpoint (true));
+if (expr_id)
+{
-octave::unwind_protect frame;
+ult = expr_id->lvalue ();
-frame.protect_var (in_loop_command);
+octave_scalar_map err;
-in_loop_command = true;
+err.assign ("message", last_error_message ());
+err.assign ("identifier", last_error_id ());
-tree_expression *expr = cmd.control_expr ();
+err.assign ("stack", last_error_stack ());
-octave_value rhs = expr->rvalue1 ();
+ult.assign (octave_value::op_asn_eq, err);
+}
-if (rhs.is_undefined ())
-return;
+// perform actual "catch" block
+if (catch_code)
-if (! rhs.is_map ())
+catch_code->accept (*this);
-error ("in statement 'for [X, Y] = VAL', VAL must be a structure");
+}
+}
-// Cycle through structure elements.  First element of id_list
+}
-// is set to value and the second is set to the name of the
-// structure element.
+void
+tree_evaluator::do_unwind_protect_cleanup_code (tree_statement_list *list)
-tree_argument_list *lhs = cmd.left_hand_side ();
+{
+octave::unwind_protect frame;
-tree_argument_list::iterator p = lhs->begin ();
+frame.protect_var (octave_interrupt_state);
-tree_expression *elt = *p++;
+octave_interrupt_state = 0;
-octave_lvalue val_ref = elt->lvalue ();
+// We want to preserve the last location info for possible
+// backtracking.
-elt = *p;
+frame.add_fcn (octave_call_stack::set_line,
+octave_call_stack::current_line ());
-octave_lvalue key_ref = elt->lvalue ();
+frame.add_fcn (octave_call_stack::set_column,
+octave_call_stack::current_column ());
-const octave_map tmp_val = rhs.map_value ();
+// Similarly, if we have seen a return or break statement, allow all
-tree_statement_list *loop_body = cmd.body ();
+// the cleanup code to run before returning or handling the break.
+// We don't have to worry about continue statements because they can
-string_vector keys = tmp_val.keys ();
+// only occur in loops.
-octave_idx_type nel = keys.numel ();
+frame.protect_var (tree_return_command::returning);
+tree_return_command::returning = 0;
-for (octave_idx_type i = 0; i < nel; i++)
-{
+frame.protect_var (tree_break_command::breaking);
-std::string key = keys[i];
+tree_break_command::breaking = 0;
-const Cell val_lst = tmp_val.contents (key);
+try
+{
-octave_idx_type n = val_lst.numel ();
+if (list)
+list->accept (*this);
-octave_value val = (n == 1) ? val_lst(0) : octave_value (val_lst);
+}
+catch (const octave_execution_exception&)
-val_ref.assign (octave_value::op_asn_eq, val);
+{
-key_ref.assign (octave_value::op_asn_eq, key);
+recover_from_exception ();
-if (loop_body)
+if (tree_break_command::breaking || tree_return_command::returning)
-loop_body->accept (*this);
+frame.discard (2);
+else
-if (quit_loop_now ())
+frame.run (2);
-break;
-}
+frame.discard (2);
-}
+throw;
-void
+}
-tree_evaluator::visit_octave_user_script (octave_user_script&)
-{
+// The unwind_protects are popped off the stack in the reverse of
-panic_impossible ();
+// the order they are pushed on.
-}
+// FIXME: these statements say that if we see a break or
-void
+// return statement in the cleanup block, that we want to use the
-tree_evaluator::visit_octave_user_function (octave_user_function&)
+// new value of the breaking or returning flag instead of restoring
-{
+// the previous value.  Is that the right thing to do?  I think so.
-panic_impossible ();
+// Consider the case of
-}
+//
+//   function foo ()
-void
+//     unwind_protect
-tree_evaluator::visit_octave_user_function_header (octave_user_function&)
+//       fprintf (stderr, "1: this should always be executed\n");
-{
+//       break;
-panic_impossible ();
+//       fprintf (stderr, "1: this should never be executed\n");
-}
+//     unwind_protect_cleanup
+//       fprintf (stderr, "2: this should always be executed\n");
-void
+//       return;
-tree_evaluator::visit_octave_user_function_trailer (octave_user_function&)
+//       fprintf (stderr, "2: this should never be executed\n");
-{
+//     end_unwind_protect
-panic_impossible ();
+//   endfunction
-}
+//
+// If we reset the value of the breaking flag, both the returning
-void
+// flag and the breaking flag will be set, and we shouldn't have
-tree_evaluator::visit_function_def (tree_function_def& cmd)
+// both.  So, use the most recent one.  If there is no return or
-{
+// break in the cleanup block, the values should be reset to
-octave_value fcn = cmd.function ();
+// whatever they were when the cleanup block was entered.
-octave_function *f = fcn.function_value ();
+if (tree_break_command::breaking || tree_return_command::returning)
+frame.discard (2);
-if (f)
+else
-{
+frame.run (2);
-std::string nm = f->name ();
+}
-symbol_table::install_cmdline_function (nm, fcn);
+void
+tree_evaluator::visit_unwind_protect_command (tree_unwind_protect_command& cmd)
-// Make sure that any variable with the same name as the new
+{
-// function is cleared.
+tree_statement_list *cleanup_code = cmd.cleanup ();
-symbol_table::assign (nm);
+tree_statement_list *unwind_protect_code = cmd.body ();
-}
-}
+if (unwind_protect_code)
+{
-void
+try
-tree_evaluator::visit_identifier (tree_identifier&)
+{
-{
+unwind_protect_code->accept (*this);
-panic_impossible ();
+}
-}
+catch (const octave_execution_exception&)
+{
-void
+// FIXME: Maybe we should be able to temporarily set the
-tree_evaluator::visit_if_clause (tree_if_clause&)
+// interpreter's exception handling state to something "safe"
-{
+// while the cleanup block runs instead of just resetting it
-panic_impossible ();
+// here?
-}
+recover_from_exception ();
-void
+// Run the cleanup code on exceptions, so that it is run even
-tree_evaluator::visit_if_command (tree_if_command& cmd)
+// in case of interrupt or out-of-memory.
-{
+do_unwind_protect_cleanup_code (cleanup_code);
-tree_if_command_list *lst = cmd.cmd_list ();
+// If an error occurs inside the cleanup code, a new
-if (lst)
+// exception will be thrown instead of the original.
-lst->accept (*this);
+throw;
 }
-void
+// Also execute the unwind_protect_cleanump code if the
-tree_evaluator::visit_if_command_list (tree_if_command_list& lst)
+// unwind_protect block runs without error.
-{
+do_unwind_protect_cleanup_code (cleanup_code);
-for (tree_if_command_list::iterator p = lst.begin (); p != lst.end (); p++)
+}
-{
+}
-tree_if_clause *tic = *p;
+void
-tree_expression *expr = tic->condition ();
+tree_evaluator::visit_while_command (tree_while_command& cmd)
+{
-if (statement_context == function || statement_context == script)
+#if defined (HAVE_LLVM)
-octave_call_stack::set_location (tic->line (), tic->column ());
+if (tree_jit::execute (cmd))
+return;
-if (debug_mode && ! tic->is_else_clause ())
+#endif
-do_breakpoint (tic->is_breakpoint (true));
+octave::unwind_protect frame;
-if (tic->is_else_clause () || expr->is_logically_true ("if"))
-{
+frame.protect_var (in_loop_command);
-tree_statement_list *stmt_lst = tic->commands ();
+in_loop_command = true;
-if (stmt_lst)
-stmt_lst->accept (*this);
+tree_expression *expr = cmd.condition ();
+if (! expr)
+panic_impossible ();
+for (;;)
+{
+if (debug_mode)
+do_breakpoint (cmd.is_breakpoint (true));
+if (expr->is_logically_true ("while"))
+{
+tree_statement_list *loop_body = cmd.body ();
+if (loop_body)
+loop_body->accept (*this);
+if (quit_loop_now ())
+break;
+}
+else
 break;
 }
 }
-}
+void
-void
+tree_evaluator::visit_do_until_command (tree_do_until_command& cmd)
-tree_evaluator::visit_index_expression (tree_index_expression&)
+{
-{
+#if defined (HAVE_LLVM)
-panic_impossible ();
+if (tree_jit::execute (cmd))
-}
+return;
+#endif
-void
-tree_evaluator::visit_matrix (tree_matrix&)
-{
-panic_impossible ();
-}
-void
-tree_evaluator::visit_cell (tree_cell&)
-{
-panic_impossible ();
-}
-void
-tree_evaluator::visit_multi_assignment (tree_multi_assignment&)
-{
-panic_impossible ();
-}
-void
-tree_evaluator::visit_no_op_command (tree_no_op_command& cmd)
-{
-if (debug_mode && cmd.is_end_of_fcn_or_script ())
-do_breakpoint (cmd.is_breakpoint (true), true);
-}
-void
-tree_evaluator::visit_constant (tree_constant&)
-{
-panic_impossible ();
-}
-void
-tree_evaluator::visit_fcn_handle (tree_fcn_handle&)
-{
-panic_impossible ();
-}
-void
-tree_evaluator::visit_funcall (tree_funcall&)
-{
-panic_impossible ();
-}
-void
-tree_evaluator::visit_parameter_list (tree_parameter_list&)
-{
-panic_impossible ();
-}
-void
-tree_evaluator::visit_postfix_expression (tree_postfix_expression&)
-{
-panic_impossible ();
-}
-void
-tree_evaluator::visit_prefix_expression (tree_prefix_expression&)
-{
-panic_impossible ();
-}
-void
-tree_evaluator::visit_return_command (tree_return_command& cmd)
-{
-if (debug_mode)
-do_breakpoint (cmd.is_breakpoint (true));
-// Act like dbcont.
-if (Vdebugging
-&& octave_call_stack::current_frame () == current_frame)
-{
-Vdebugging = false;
-reset_debug_state ();
-}
-else if (statement_context == function || statement_context == script
-|| in_loop_command)
-tree_return_command::returning = 1;
-}
-void
-tree_evaluator::visit_return_list (tree_return_list&)
-{
-panic_impossible ();
-}
-void
-tree_evaluator::visit_simple_assignment (tree_simple_assignment&)
-{
-panic_impossible ();
-}
-void
-tree_evaluator::visit_statement (tree_statement& stmt)
-{
-tree_command *cmd = stmt.command ();
-tree_expression *expr = stmt.expression ();
-if (cmd || expr)
-{
-if (statement_context == function || statement_context == script)
-{
-// Skip commands issued at a debug> prompt to avoid disturbing
-// the state of the program we are debugging, but still track
-// progress through user functions called from debug> prompt.
-if (Vtrack_line_num)
-octave_call_stack::set_location (stmt.line (), stmt.column ());
-if ((statement_context == script
-&& ((Vecho_executing_commands & ECHO_SCRIPTS
-&& octave_call_stack::all_scripts ())
-|| Vecho_executing_commands & ECHO_FUNCTIONS))
-|| (statement_context == function
-&& Vecho_executing_commands & ECHO_FUNCTIONS))
-stmt.echo_code ();
-}
-try
-{
-if (cmd)
-cmd->accept (*this);
-else
-{
-if (debug_mode)
-do_breakpoint (expr->is_breakpoint (true));
-// FIXME: maybe all of this should be packaged in
-// one virtual function that returns a flag saying whether
-// or not the expression will take care of binding ans and
-// printing the result.
-// FIXME: it seems that we should just have to
-// call expr->rvalue1 () and that should take care of
-// everything, binding ans as necessary?
-bool do_bind_ans = false;
-if (expr->is_identifier ())
-{
-tree_identifier *id = dynamic_cast<tree_identifier *> (expr);
-do_bind_ans = (! id->is_variable ());
-}
-else
-do_bind_ans = (! expr->is_assignment_expression ());
-octave_value tmp_result = expr->rvalue1 (0);
-if (do_bind_ans && tmp_result.is_defined ())
-bind_ans (tmp_result, expr->print_result ()
-&& statement_printing_enabled ());
-//              if (tmp_result.is_defined ())
-//                result_values(0) = tmp_result;
-}
-}
-catch (const std::bad_alloc&)
-{
-// FIXME: We want to use error_with_id here so that give users
-// control over this error message but error_with_id will
-// require some memory allocations.  Is there anything we can
-// do to make those more likely to succeed?
-error_with_id ("Octave:bad-alloc",
-"out of memory or dimension too large for Octave's index type");
-}
-}
-}
-void
-tree_evaluator::visit_statement_list (tree_statement_list& lst)
-{
-// FIXME: commented out along with else clause below.
-// static octave_value_list empty_list;
-tree_statement_list::iterator p = lst.begin ();
-if (p != lst.end ())
-{
-while (true)
-{
-tree_statement *elt = *p++;
-if (! elt)
-error ("invalid statement found in statement list!");
-octave_quit ();
-elt->accept (*this);
-if (tree_break_command::breaking
-|| tree_continue_command::continuing)
-break;
-if (tree_return_command::returning)
-break;
-if (p == lst.end ())
-break;
-else
-{
-// Clear previous values before next statement is
-// evaluated so that we aren't holding an extra
-// reference to a value that may be used next.  For
-// example, in code like this:
-//
-//   X = rand (N);  # refcount for X should be 1
-//                  # after this statement
-//
-//   X(idx) = val;  # no extra copy of X should be
-//                  # needed, but we will be faked
-//                  # out if retval is not cleared
-//                  # between statements here
-//              result_values = empty_list;
-}
-}
-}
-}
-void
-tree_evaluator::visit_switch_case (tree_switch_case&)
-{
-panic_impossible ();
-}
-void
-tree_evaluator::visit_switch_case_list (tree_switch_case_list&)
-{
-panic_impossible ();
-}
-void
-tree_evaluator::visit_switch_command (tree_switch_command& cmd)
-{
-if (debug_mode)
-do_breakpoint (cmd.is_breakpoint (true));
-tree_expression *expr = cmd.switch_value ();
-if (! expr)
-error ("missing value in switch command near line %d, column %d",
-cmd.line (), cmd.column ());
-octave_value val = expr->rvalue1 ();
-tree_switch_case_list *lst = cmd.case_list ();
-if (lst)
-{
-for (tree_switch_case_list::iterator p = lst->begin ();
-p != lst->end (); p++)
-{
-tree_switch_case *t = *p;
-if (t->is_default_case () || t->label_matches (val))
-{
-tree_statement_list *stmt_lst = t->commands ();
-if (stmt_lst)
-stmt_lst->accept (*this);
-break;
-}
-}
-}
-}
-void
-tree_evaluator::visit_try_catch_command (tree_try_catch_command& cmd)
-{
-bool execution_error = false;
-{ // unwind frame before catch block
 octave::unwind_protect frame;
-frame.protect_var (buffer_error_messages);
+frame.protect_var (in_loop_command);
-frame.protect_var (Vdebug_on_error);
-frame.protect_var (Vdebug_on_warning);
+in_loop_command = true;
-buffer_error_messages++;
+tree_expression *expr = cmd.condition ();
-Vdebug_on_error = false;
+int until_line = cmd.line ();
-Vdebug_on_warning = false;
+int until_column = cmd.column ();
-// The catch code is *not* added to unwind_protect stack;
+if (! expr)
-// it doesn't need to be run on interrupts.
+panic_impossible ();
-tree_statement_list *try_code = cmd.body ();
+for (;;)
+{
-if (try_code)
+tree_statement_list *loop_body = cmd.body ();
-{
-try
+if (loop_body)
-{
+loop_body->accept (*this);
-in_try_catch++;
-try_code->accept (*this);
+if (quit_loop_now ())
-in_try_catch--;
+break;
-}
-catch (const octave_execution_exception&)
+if (debug_mode)
-{
+do_breakpoint (cmd.is_breakpoint (true));
-recover_from_exception ();
+octave_call_stack::set_location (until_line, until_column);
-in_try_catch--;          // must be restored before "catch" block
-execution_error = true;
+if (expr->is_logically_true ("do-until"))
-}
+break;
 }
-// Unwind to let the user print any messages from
+}
-// errors that occurred in the body of the try_catch statement,
-// or throw further errors.
+void
-}
+tree_evaluator::do_breakpoint (tree_statement& stmt) const
+{
-if (execution_error)
+do_breakpoint (stmt.is_breakpoint (true), stmt.is_end_of_fcn_or_script ());
-{
+}
-tree_statement_list *catch_code = cmd.cleanup ();
-if (catch_code)
+void
-{
+tree_evaluator::do_breakpoint (bool is_breakpoint,
-tree_identifier *expr_id = cmd.identifier ();
+bool is_end_of_fcn_or_script) const
-octave_lvalue ult;
+{
+bool break_on_this_statement = false;
-if (expr_id)
-{
+if (octave_debug_on_interrupt_state)
-ult = expr_id->lvalue ();
+{
+break_on_this_statement = true;
-octave_scalar_map err;
+octave_debug_on_interrupt_state = false;
-err.assign ("message", last_error_message ());
-err.assign ("identifier", last_error_id ());
+current_frame = octave_call_stack::current_frame ();
-err.assign ("stack", last_error_stack ());
+}
+else if (is_breakpoint)
-ult.assign (octave_value::op_asn_eq, err);
+{
-}
+break_on_this_statement = true;
-// perform actual "catch" block
+dbstep_flag = 0;
-if (catch_code)
-catch_code->accept (*this);
+current_frame = octave_call_stack::current_frame ();
 }
-}
+else if (dbstep_flag > 0)
-}
+{
+if (octave_call_stack::current_frame () == current_frame)
-void
+{
-tree_evaluator::do_unwind_protect_cleanup_code (tree_statement_list *list)
+if (dbstep_flag == 1 || is_end_of_fcn_or_script)
 {
-octave::unwind_protect frame;
+// We get here if we are doing a "dbstep" or a "dbstep N" and the
+// count has reached 1 so that we must stop and return to debug
-frame.protect_var (octave_interrupt_state);
+// prompt.  Alternatively, "dbstep N" has been used but the end
-octave_interrupt_state = 0;
+// of the frame has been reached so we stop at the last line and
+// return to prompt.
-// We want to preserve the last location info for possible
-// backtracking.
+break_on_this_statement = true;
-frame.add_fcn (octave_call_stack::set_line,
-octave_call_stack::current_line ());
+dbstep_flag = 0;
-frame.add_fcn (octave_call_stack::set_column,
+}
-octave_call_stack::current_column ());
+else
+{
-// Similarly, if we have seen a return or break statement, allow all
+// Executing "dbstep N".  Decrease N by one and continue.
-// the cleanup code to run before returning or handling the break.
-// We don't have to worry about continue statements because they can
+dbstep_flag--;
-// only occur in loops.
+}
-frame.protect_var (tree_return_command::returning);
+}
-tree_return_command::returning = 0;
+else if (dbstep_flag == 1
+&& octave_call_stack::current_frame () < current_frame)
-frame.protect_var (tree_break_command::breaking);
+{
-tree_break_command::breaking = 0;
+// We stepped out from the end of a function.
-try
+current_frame = octave_call_stack::current_frame ();
-{
-if (list)
+break_on_this_statement = true;
-list->accept (*this);
-}
+dbstep_flag = 0;
-catch (const octave_execution_exception&)
+}
-{
+}
-recover_from_exception ();
+else if (dbstep_flag == -1)
+{
-if (tree_break_command::breaking || tree_return_command::returning)
+// We get here if we are doing a "dbstep in".
-frame.discard (2);
-else
+break_on_this_statement = true;
-frame.run (2);
+dbstep_flag = 0;
-frame.discard (2);
+current_frame = octave_call_stack::current_frame ();
-throw;
+}
-}
+else if (dbstep_flag == -2)
+{
-// The unwind_protects are popped off the stack in the reverse of
+// We get here if we are doing a "dbstep out".  Check for end of
-// the order they are pushed on.
+// function and whether the current frame is the same as the
+// cached value because we want to step out from the frame where
-// FIXME: these statements say that if we see a break or
+// "dbstep out" was evaluated, not from any functions called from
-// return statement in the cleanup block, that we want to use the
+// that frame.
-// new value of the breaking or returning flag instead of restoring
-// the previous value.  Is that the right thing to do?  I think so.
+if (is_end_of_fcn_or_script
-// Consider the case of
+&& octave_call_stack::current_frame () == current_frame)
-//
+dbstep_flag = -1;
-//   function foo ()
+}
-//     unwind_protect
-//       fprintf (stderr, "1: this should always be executed\n");
+if (break_on_this_statement)
-//       break;
+do_keyboard ();
-//       fprintf (stderr, "1: this should never be executed\n");
-//     unwind_protect_cleanup
+}
-//       fprintf (stderr, "2: this should always be executed\n");
-//       return;
+// ARGS is currently unused, but since the do_keyboard function in
-//       fprintf (stderr, "2: this should never be executed\n");
+// input.cc accepts an argument list, we preserve it here so that the
-//     end_unwind_protect
+// interface won't have to change if we decide to use it in the future.
-//   endfunction
-//
+octave_value
-// If we reset the value of the breaking flag, both the returning
+tree_evaluator::do_keyboard (const octave_value_list& args) const
-// flag and the breaking flag will be set, and we shouldn't have
+{
-// both.  So, use the most recent one.  If there is no return or
+return ::do_keyboard (args);
-// break in the cleanup block, the values should be reset to
+}
-// whatever they were when the cleanup block was entered.
-if (tree_break_command::breaking || tree_return_command::returning)
-frame.discard (2);
-else
-frame.run (2);
-}
-void
-tree_evaluator::visit_unwind_protect_command (tree_unwind_protect_command& cmd)
-{
-tree_statement_list *cleanup_code = cmd.cleanup ();
-tree_statement_list *unwind_protect_code = cmd.body ();
-if (unwind_protect_code)
-{
-try
-{
-unwind_protect_code->accept (*this);
-}
-catch (const octave_execution_exception&)
-{
-// FIXME: Maybe we should be able to temporarily set the
-// interpreter's exception handling state to something "safe"
-// while the cleanup block runs instead of just resetting it
-// here?
-recover_from_exception ();
-// Run the cleanup code on exceptions, so that it is run even
-// in case of interrupt or out-of-memory.
-do_unwind_protect_cleanup_code (cleanup_code);
-// If an error occurs inside the cleanup code, a new
-// exception will be thrown instead of the original.
-throw;
-}
-// Also execute the unwind_protect_cleanump code if the
-// unwind_protect block runs without error.
-do_unwind_protect_cleanup_code (cleanup_code);
-}
-}
-void
-tree_evaluator::visit_while_command (tree_while_command& cmd)
-{
-#if defined (HAVE_LLVM)
-if (tree_jit::execute (cmd))
-return;
-#endif
-octave::unwind_protect frame;
-frame.protect_var (in_loop_command);
-in_loop_command = true;
-tree_expression *expr = cmd.condition ();
-if (! expr)
-panic_impossible ();
-for (;;)
-{
-if (debug_mode)
-do_breakpoint (cmd.is_breakpoint (true));
-if (expr->is_logically_true ("while"))
-{
-tree_statement_list *loop_body = cmd.body ();
-if (loop_body)
-loop_body->accept (*this);
-if (quit_loop_now ())
-break;
-}
-else
-break;
-}
-}
-void
-tree_evaluator::visit_do_until_command (tree_do_until_command& cmd)
-{
-#if defined (HAVE_LLVM)
-if (tree_jit::execute (cmd))
-return;
-#endif
-octave::unwind_protect frame;
-frame.protect_var (in_loop_command);
-in_loop_command = true;
-tree_expression *expr = cmd.condition ();
-int until_line = cmd.line ();
-int until_column = cmd.column ();
-if (! expr)
-panic_impossible ();
-for (;;)
-{
-tree_statement_list *loop_body = cmd.body ();
-if (loop_body)
-loop_body->accept (*this);
-if (quit_loop_now ())
-break;
-if (debug_mode)
-do_breakpoint (cmd.is_breakpoint (true));
-octave_call_stack::set_location (until_line, until_column);
-if (expr->is_logically_true ("do-until"))
-break;
-}
-}
-void
-tree_evaluator::do_breakpoint (tree_statement& stmt) const
-{
-do_breakpoint (stmt.is_breakpoint (true), stmt.is_end_of_fcn_or_script ());
-}
-void
-tree_evaluator::do_breakpoint (bool is_breakpoint,
-bool is_end_of_fcn_or_script) const
-{
-bool break_on_this_statement = false;
-if (octave_debug_on_interrupt_state)
-{
-break_on_this_statement = true;
-octave_debug_on_interrupt_state = false;
-current_frame = octave_call_stack::current_frame ();
-}
-else if (is_breakpoint)
-{
-break_on_this_statement = true;
-dbstep_flag = 0;
-current_frame = octave_call_stack::current_frame ();
-}
-else if (dbstep_flag > 0)
-{
-if (octave_call_stack::current_frame () == current_frame)
-{
-if (dbstep_flag == 1 || is_end_of_fcn_or_script)
-{
-// We get here if we are doing a "dbstep" or a "dbstep N" and the
-// count has reached 1 so that we must stop and return to debug
-// prompt.  Alternatively, "dbstep N" has been used but the end
-// of the frame has been reached so we stop at the last line and
-// return to prompt.
-break_on_this_statement = true;
-dbstep_flag = 0;
-}
-else
-{
-// Executing "dbstep N".  Decrease N by one and continue.
-dbstep_flag--;
-}
-}
-else if (dbstep_flag == 1
-&& octave_call_stack::current_frame () < current_frame)
-{
-// We stepped out from the end of a function.
-current_frame = octave_call_stack::current_frame ();
-break_on_this_statement = true;
-dbstep_flag = 0;
-}
-}
-else if (dbstep_flag == -1)
-{
-// We get here if we are doing a "dbstep in".
-break_on_this_statement = true;
-dbstep_flag = 0;
-current_frame = octave_call_stack::current_frame ();
-}
-else if (dbstep_flag == -2)
-{
-// We get here if we are doing a "dbstep out".  Check for end of
-// function and whether the current frame is the same as the
-// cached value because we want to step out from the frame where
-// "dbstep out" was evaluated, not from any functions called from
-// that frame.
-if (is_end_of_fcn_or_script
-&& octave_call_stack::current_frame () == current_frame)
-dbstep_flag = -1;
-}
-if (break_on_this_statement)
-do_keyboard ();
-}
-// ARGS is currently unused, but since the do_keyboard function in
-// input.cc accepts an argument list, we preserve it here so that the
-// interface won't have to change if we decide to use it in the future.
-octave_value
-tree_evaluator::do_keyboard (const octave_value_list& args) const
-{
-return ::do_keyboard (args);
 }
 DEFUN (max_recursion_depth, args, nargout,
 doc: /* -*- texinfo -*-
 @deftypefn  {} {@var{val} =} max_recursion_depth ()

Mercurial > octave

comparison libinterp/parse-tree/pt-eval.cc @ 22196:dd992fd74fce