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

comparison libinterp/parse-tree/pt-eval.cc @ 20592:56fee8f84fe7

eliminate more simple uses of error_state * cellfun.cc, syscalls.cc, urlwrite.cc, ov.cc, pt-eval.cc: Eliminate uses of error_state.

author	John W. Eaton <jwe@octave.org>
date	Mon, 05 Oct 2015 22:47:42 -0400
parents	b70cc4bd8109
children	b65888ec820e

comparison

equal deleted inserted replaced

-:0650b8431037
+:56fee8f84fe7
 }
 void
 tree_evaluator::visit_break_command (tree_break_command& cmd)
 {
-if (! error_state)
+if (debug_mode)
-{
+do_breakpoint (cmd.is_breakpoint ());
-if (debug_mode)
-do_breakpoint (cmd.is_breakpoint ());
+if (statement_context == function || statement_context == script
+|| in_loop_command)
-if (statement_context == function || statement_context == script
+tree_break_command::breaking = 1;
-|| in_loop_command)
-tree_break_command::breaking = 1;
-}
 }
 void
 tree_evaluator::visit_colon_expression (tree_colon_expression&)
 {
 }
 void
 tree_evaluator::visit_continue_command (tree_continue_command& cmd)
 {
-if (! error_state)
+if (debug_mode)
-{
+do_breakpoint (cmd.is_breakpoint ());
-if (debug_mode)
-do_breakpoint (cmd.is_breakpoint ());
+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_continue_command::continuing = 1;
-}
 }
 void
 tree_evaluator::reset_debug_state (void)
 {
 tree_identifier *id = elt.ident ();
 if (id)
 {
 id->mark_global ();
-if (! error_state)
-{
-octave_lvalue ult = id->lvalue ();
-if (ult.is_undefined ())
-{
-tree_expression *expr = elt.expression ();
-octave_value init_val;
-if (expr)
-init_val = expr->rvalue1 ();
-else
-init_val = Matrix ();
-ult.assign (octave_value::op_asn_eq, init_val);
-}
-}
-}
-}
-static inline void
-do_static_init (tree_decl_elt& elt)
-{
-tree_identifier *id = elt.ident ();
-if (id)
-{
-id->mark_as_static ();
 octave_lvalue ult = id->lvalue ();
 if (ult.is_undefined ())
 {
 ult.assign (octave_value::op_asn_eq, init_val);
 }
 }
 }
+static inline void
+do_static_init (tree_decl_elt& elt)
+{
+tree_identifier *id = elt.ident ();
+if (id)
+{
+id->mark_as_static ();
+octave_lvalue ult = id->lvalue ();
+if (ult.is_undefined ())
+{
+tree_expression *expr = elt.expression ();
+octave_value init_val;
+if (expr)
+init_val = expr->rvalue1 ();
+else
+init_val = Matrix ();
+ult.assign (octave_value::op_asn_eq, init_val);
+}
+}
+}
 void
 tree_evaluator::do_decl_init_list (decl_elt_init_fcn fcn,
 tree_decl_init_list *init_list)
 {
 if (init_list)
 p != init_list->end (); p++)
 {
 tree_decl_elt *elt = *p;
 fcn (*elt);
-if (error_state)
-break;
 }
 }
 }
 void
 {
 octave_lvalue ult = id->lvalue ();
 octave_value init_val = expr->rvalue1 ();
-if (! error_state)
+ult.assign (octave_value::op_asn_eq, init_val);
-{
-ult.assign (octave_value::op_asn_eq, init_val);
+retval = true;
-retval = true;
-}
 }
 return retval;
 }
 #endif
 // Maybe handle 'continue N' someday...
 if (tree_continue_command::continuing)
 tree_continue_command::continuing--;
-bool quit = (error_state
+bool quit = (tree_return_command::returning
-|| tree_return_command::returning
 || tree_break_command::breaking
 || tree_continue_command::continuing);
 if (tree_break_command::breaking)
 tree_break_command::breaking--;
 }
 void
 tree_evaluator::visit_simple_for_command (tree_simple_for_command& cmd)
 {
-if (error_state)
-return;
 if (debug_mode)
 do_breakpoint (cmd.is_breakpoint ());
 // FIXME: need to handle PARFOR loops here using cmd.in_parallel ()
 // and cmd.maxproc_expr ();
 #if HAVE_LLVM
 if (tree_jit::execute (cmd, rhs))
 return;
 #endif
-if (error_state || rhs.is_undefined ())
+if (rhs.is_undefined ())
 return;
 {
 tree_expression *lhs = cmd.left_hand_side ();
 octave_lvalue ult = lhs->lvalue ();
-if (error_state)
-return;
 tree_statement_list *loop_body = cmd.body ();
 if (rhs.is_range ())
 {
 {
 octave_value val (rng.elem (i));
 ult.assign (octave_value::op_asn_eq, val);
-if (! error_state && loop_body)
+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 (! error_state && loop_body)
+if (loop_body)
 loop_body->accept (*this);
 // Maybe decrement break and continue states.
 quit_loop_now ();
 }
 idx(iidx) = i;
 octave_value val = arg.do_index_op (idx);
 ult.assign (octave_value::op_asn_eq, val);
-if (! error_state && loop_body)
+if (loop_body)
 loop_body->accept (*this);
 if (quit_loop_now ())
 break;
 }
 }
 void
 tree_evaluator::visit_complex_for_command (tree_complex_for_command& cmd)
 {
-if (error_state)
-return;
 if (debug_mode)
 do_breakpoint (cmd.is_breakpoint ());
 unwind_protect frame;
 tree_expression *expr = cmd.control_expr ();
 octave_value rhs = expr->rvalue1 ();
-if (error_state || rhs.is_undefined ())
+if (rhs.is_undefined ())
 return;
 if (rhs.is_map ())
 {
 // Cycle through structure elements.  First element of id_list
 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 (! error_state && loop_body)
+if (loop_body)
 loop_body->accept (*this);
 if (quit_loop_now ())
 break;
 }
 if (debug_mode && ! tic->is_else_clause ())
 do_breakpoint (tic->is_breakpoint ());
 if (tic->is_else_clause () || expr->is_logically_true ("if"))
 {
-if (! error_state)
+tree_statement_list *stmt_lst = tic->commands ();
-{
-tree_statement_list *stmt_lst = tic->commands ();
+if (stmt_lst)
+stmt_lst->accept (*this);
-if (stmt_lst)
-stmt_lst->accept (*this);
-}
 break;
 }
 }
 }
 }
 void
 tree_evaluator::visit_return_command (tree_return_command& cmd)
 {
-if (! error_state)
+if (debug_mode)
-{
+do_breakpoint (cmd.is_breakpoint ());
-if (debug_mode)
-do_breakpoint (cmd.is_breakpoint ());
+// Act like dbcont.
-// Act like dbcont.
+if (Vdebugging
+&& octave_call_stack::current_frame () == current_frame)
-if (Vdebugging
+{
-&& octave_call_stack::current_frame () == current_frame)
+Vdebugging = false;
-{
-Vdebugging = false;
+reset_debug_state ();
+}
-reset_debug_state ();
+else if (statement_context == function || statement_context == script
-}
+|| in_loop_command)
-else if (statement_context == function || statement_context == script
+tree_return_command::returning = 1;
-|| in_loop_command)
-tree_return_command::returning = 1;
-}
 }
 void
 tree_evaluator::visit_return_list (tree_return_list&)
 {
 else
 do_bind_ans = (! expr->is_assignment_expression ());
 octave_value tmp_result = expr->rvalue1 (0);
-if (do_bind_ans && ! (error_state || tmp_result.is_undefined ()))
+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 we set
+// FIXME: We want to use error_with_id here so that give users
-// the error state, give users control over this error
+// control over this error message but error_with_id will
-// message, and so that we set the error_state appropriately
+// require some memory allocations.  Is there anything we can
-// so we'll get stack trace info when appropriate.  But
+// do to make those more likely to succeed?
-// 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)
 {
 static octave_value_list empty_list;
-if (error_state)
-return;
 tree_statement_list::iterator p = lst.begin ();
 if (p != lst.end ())
 {
 if (elt)
 {
 octave_quit ();
 elt->accept (*this);
-if (error_state)
-break;
 if (tree_break_command::breaking
 || tree_continue_command::continuing)
 break;
 {
 octave_value val = expr->rvalue1 ();
 tree_switch_case_list *lst = cmd.case_list ();
-if (! error_state && lst)
+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))
 {
-if (error_state)
-break;
 tree_statement_list *stmt_lst = t->commands ();
 if (stmt_lst)
 stmt_lst->accept (*this);
 // 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);
-// FIXME: should error_state be checked here?
+// We want to rethrow the exception so that interrupts continue.
-// We want to rethrow the exception, even if error_state is set, so
-// that interrupts continue.
 throw;
 }
 do_unwind_protect_cleanup_code (cleanup_code);
 }
 }
 void
 tree_evaluator::visit_while_command (tree_while_command& cmd)
 {
-if (error_state)
-return;
 #if HAVE_LLVM
 if (tree_jit::execute (cmd))
 return;
 #endif
 if (expr->is_logically_true ("while"))
 {
 tree_statement_list *loop_body = cmd.body ();
 if (loop_body)
-{
+loop_body->accept (*this);
-loop_body->accept (*this);
-if (error_state)
-return;
-}
 if (quit_loop_now ())
 break;
 }
 else
 }
 void
 tree_evaluator::visit_do_until_command (tree_do_until_command& cmd)
 {
-if (error_state)
-return;
 #if HAVE_LLVM
 if (tree_jit::execute (cmd))
 return;
 #endif
 for (;;)
 {
 tree_statement_list *loop_body = cmd.body ();
 if (loop_body)
-{
+loop_body->accept (*this);
-loop_body->accept (*this);
-if (error_state)
-return;
-}
 if (quit_loop_now ())
 break;
 if (debug_mode)

Mercurial > octave-nkf

comparison libinterp/parse-tree/pt-eval.cc @ 20592:56fee8f84fe7