octave-lyh: src/pt-eval.cc comparison

comparison src/pt-eval.cc @ 10315:57a59eae83cc

untabify src C++ source files

author	John W. Eaton <jwe@octave.org>
date	Thu, 11 Feb 2010 12:41:46 -0500
parents	979fb2606c4f
children	cb0883127251

comparison

equal deleted inserted replaced

-:07ebe522dac2
+:57a59eae83cc
 tree_evaluator::visit_break_command (tree_break_command& cmd)
 {
 if (! error_state)
 {
 if (debug_mode)
-	do_breakpoint (cmd.is_breakpoint ());
+do_breakpoint (cmd.is_breakpoint ());
 if (tree_evaluator::in_fcn_or_script_body
 || tree_evaluator::in_loop_command)
 tree_break_command::breaking = 1;
 }
 tree_evaluator::visit_continue_command (tree_continue_command& cmd)
 {
 if (! error_state)
 {
 if (debug_mode)
-	do_breakpoint (cmd.is_breakpoint ());
+do_breakpoint (cmd.is_breakpoint ());
 if (tree_evaluator::in_fcn_or_script_body
 || tree_evaluator::in_loop_command)
 tree_continue_command::continuing = 1;
 }
 if (id)
 {
 id->mark_global ();
 if (! error_state)
-	{
+{
-	  octave_lvalue ult = id->lvalue ();
+octave_lvalue ult = id->lvalue ();
-	  if (ult.is_undefined ())
+if (ult.is_undefined ())
-	    {
+{
-	      tree_expression *expr = elt.expression ();
+tree_expression *expr = elt.expression ();
-	      octave_value init_val;
+octave_value init_val;
-	      if (expr)
+if (expr)
-		init_val = expr->rvalue1 ();
+init_val = expr->rvalue1 ();
-	      else
+else
-		init_val = Matrix ();
+init_val = Matrix ();
-	      ult.assign (octave_value::op_asn_eq, init_val);
+ult.assign (octave_value::op_asn_eq, init_val);
-	    }
+}
-	}
+}
 }
 }
 static inline void
 do_static_init (tree_decl_elt& elt)
 id->mark_as_static ();
 octave_lvalue ult = id->lvalue ();
 if (ult.is_undefined ())
-	{
+{
-	  tree_expression *expr = elt.expression ();
+tree_expression *expr = elt.expression ();
-	  octave_value init_val;
+octave_value init_val;
-	  if (expr)
+if (expr)
-	    init_val = expr->rvalue1 ();
+init_val = expr->rvalue1 ();
-	  else
+else
-	    init_val = Matrix ();
+init_val = Matrix ();
-	  ult.assign (octave_value::op_asn_eq, init_val);
+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)
+tree_decl_init_list *init_list)
 {
 if (init_list)
 {
 for (tree_decl_init_list::iterator p = init_list->begin ();
-	   p != init_list->end (); p++)
+p != init_list->end (); p++)
-	{
+{
-	  tree_decl_elt *elt = *p;
+tree_decl_elt *elt = *p;
-	  fcn (*elt);
+fcn (*elt);
-	  if (error_state)
+if (error_state)
-	    break;
+break;
-	}
+}
 }
 }
 void
 tree_evaluator::visit_global_command (tree_global_command& cmd)
 if (tree_continue_command::continuing)
 tree_continue_command::continuing--;
 bool quit = (error_state
-	       || tree_return_command::returning
+|| tree_return_command::returning
-	       || tree_break_command::breaking
+|| tree_break_command::breaking
-	       || tree_continue_command::continuing);
+|| tree_continue_command::continuing);
 if (tree_break_command::breaking)
 tree_break_command::breaking--;
 return quit;
 do \
 { \
 ult.assign (octave_value::op_asn_eq, VAL); \
 \
 if (! error_state && loop_body) \
-	loop_body->accept (*this); \
+loop_body->accept (*this); \
 \
 quit = quit_loop_now (); \
 } \
 while (0)
 tree_statement_list *loop_body = cmd.body ();
 if (rhs.is_range ())
 {
-	Range rng = rhs.range_value ();
+Range rng = rhs.range_value ();
-	octave_idx_type steps = rng.nelem ();
+octave_idx_type steps = rng.nelem ();
-	double b = rng.base ();
+double b = rng.base ();
-	double increment = rng.inc ();
+double increment = rng.inc ();
-	bool quit = false;
+bool quit = false;
-	for (octave_idx_type i = 0; i < steps; i++)
+for (octave_idx_type i = 0; i < steps; i++)
-	  {
+{
-	    // Use multiplication here rather than declaring a
+// Use multiplication here rather than declaring a
-	    // temporary variable outside the loop and using
+// temporary variable outside the loop and using
-	    //
+//
-	    //   tmp_val += increment
+//   tmp_val += increment
-	    //
+//
-	    // to avoid problems with limited precision.  Also, this
+// to avoid problems with limited precision.  Also, this
-	    // is consistent with the way Range::matrix_value is
+// is consistent with the way Range::matrix_value is
-	    // implemented.
+// implemented.
-	    octave_value val (b + i * increment);
+octave_value val (b + i * increment);
-	    DO_SIMPLE_FOR_LOOP_ONCE (val);
+DO_SIMPLE_FOR_LOOP_ONCE (val);
-	    if (quit)
+if (quit)
-	      break;
+break;
-	  }
+}
 }
 else if (rhs.is_scalar_type ())
 {
-	bool quit = false;
+bool quit = false;
-	DO_SIMPLE_FOR_LOOP_ONCE (rhs);
+DO_SIMPLE_FOR_LOOP_ONCE (rhs);
 }
 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
 }
 }
 }
 else
 {
-	::error ("invalid type in for loop expression near line %d, column %d",
+::error ("invalid type in for loop expression near line %d, column %d",
-		 cmd.line (), cmd.column ());
+cmd.line (), cmd.column ());
 }
 }
 }
 void
 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];
+std::string key = keys[i];
-	  const Cell val_lst = tmp_val.contents (key);
+const Cell val_lst = tmp_val.contents (key);
-	  octave_idx_type n = val_lst.numel ();
+octave_idx_type n = val_lst.numel ();
-	  octave_value val = (n == 1) ? val_lst(0) : octave_value (val_lst);
+octave_value val = (n == 1) ? val_lst(0) : octave_value (val_lst);
-	  val_ref.assign (octave_value::op_asn_eq, val);
+val_ref.assign (octave_value::op_asn_eq, val);
-	  key_ref.assign (octave_value::op_asn_eq, key);
+key_ref.assign (octave_value::op_asn_eq, key);
-	  if (! error_state && loop_body)
+if (! error_state && loop_body)
-	    loop_body->accept (*this);
+loop_body->accept (*this);
-	  if (quit_loop_now ())
+if (quit_loop_now ())
-	    break;
+break;
-	}
+}
 }
 else
 error ("in statement `for [X, Y] = VAL', VAL must be a structure");
 }
 tree_if_clause *tic = *p;
 tree_expression *expr = tic->condition ();
 if (debug_mode && ! tic->is_else_clause ())
-	do_breakpoint (tic->is_breakpoint ());
+do_breakpoint (tic->is_breakpoint ());
 if (tic->is_else_clause () || expr->is_logically_true ("if"))
-	{
+{
-	  if (! error_state)
+if (! error_state)
-	    {
+{
-	      tree_statement_list *stmt_lst = tic->commands ();
+tree_statement_list *stmt_lst = tic->commands ();
-	      if (stmt_lst)
+if (stmt_lst)
-		stmt_lst->accept (*this);
+stmt_lst->accept (*this);
-	    }
+}
-	  break;
+break;
-	}
+}
 }
 }
 void
 tree_evaluator::visit_index_expression (tree_index_expression&)
 tree_evaluator::visit_return_command (tree_return_command& cmd)
 {
 if (! error_state)
 {
 if (debug_mode)
-	do_breakpoint (cmd.is_breakpoint ());
+do_breakpoint (cmd.is_breakpoint ());
 // Act like dbcont.
 if (Vdebugging
 && octave_call_stack::current_frame () == current_frame)
 tree_expression *expr = stmt.expression ();
 if (cmd || expr)
 {
 if (in_fcn_or_script_body)
-	{
+{
-	  octave_call_stack::set_statement (&stmt);
+octave_call_stack::set_statement (&stmt);
-	  if (Vecho_executing_commands & ECHO_FUNCTIONS)
+if (Vecho_executing_commands & ECHO_FUNCTIONS)
-	    stmt.echo_code ();
+stmt.echo_code ();
-	}
+}
 try
-	{
+{
-	  if (cmd)
+if (cmd)
-	    cmd->accept (*this);
+cmd->accept (*this);
-	  else
+else
-	    {
+{
-	      if (debug_mode)
+if (debug_mode)
-		do_breakpoint (expr->is_breakpoint ());
+do_breakpoint (expr->is_breakpoint ());
-	      if (in_fcn_or_script_body && Vsilent_functions)
+if (in_fcn_or_script_body && Vsilent_functions)
-		expr->set_print_flag (false);
+expr->set_print_flag (false);
-	      // FIXME -- maybe all of this should be packaged in
+// FIXME -- maybe all of this should be packaged in
-	      // one virtual function that returns a flag saying whether
+// one virtual function that returns a flag saying whether
-	      // or not the expression will take care of binding ans and
+// or not the expression will take care of binding ans and
-	      // printing the result.
+// printing the result.
-	      // FIXME -- it seems that we should just have to
+// FIXME -- it seems that we should just have to
-	      // call expr->rvalue1 () and that should take care of
+// call expr->rvalue1 () and that should take care of
-	      // everything, binding ans as necessary?
+// everything, binding ans as necessary?
-	      bool do_bind_ans = false;
+bool do_bind_ans = false;
-	      if (expr->is_identifier ())
+if (expr->is_identifier ())
-		{
+{
-		  tree_identifier *id = dynamic_cast<tree_identifier *> (expr);
+tree_identifier *id = dynamic_cast<tree_identifier *> (expr);
-		  do_bind_ans = (! id->is_variable ());
+do_bind_ans = (! id->is_variable ());
-		}
+}
-	      else
+else
-		do_bind_ans = (! expr->is_assignment_expression ());
+do_bind_ans = (! expr->is_assignment_expression ());
-	      octave_value tmp_result = expr->rvalue1 (0);
+octave_value tmp_result = expr->rvalue1 (0);
-	      if (do_bind_ans && ! (error_state || tmp_result.is_undefined ()))
+if (do_bind_ans && ! (error_state || tmp_result.is_undefined ()))
-		bind_ans (tmp_result, expr->print_result ());
+bind_ans (tmp_result, expr->print_result ());
-	      //	      if (tmp_result.is_defined ())
+//              if (tmp_result.is_defined ())
-	      //		result_values(0) = tmp_result;
+//                result_values(0) = tmp_result;
-	    }
+}
-	}
+}
 catch (octave_execution_exception)
-	{
+{
-	  gripe_library_execution_error ();
+gripe_library_execution_error ();
-	}
+}
 }
 }
 void
 tree_evaluator::visit_statement_list (tree_statement_list& lst)
 tree_statement_list::iterator p = lst.begin ();
 if (p != lst.end ())
 {
 while (true)
-	{
+{
-	  tree_statement *elt = *p++;
+tree_statement *elt = *p++;
-	  if (elt)
+if (elt)
-	    {
+{
-	      octave_quit ();
+octave_quit ();
-	      elt->accept (*this);
+elt->accept (*this);
-	      if (error_state)
+if (error_state)
-		break;
+break;
-	      if (tree_break_command::breaking
+if (tree_break_command::breaking
-		  || tree_continue_command::continuing)
+|| tree_continue_command::continuing)
-		break;
+break;
-	      if (tree_return_command::returning)
+if (tree_return_command::returning)
-		break;
+break;
-	      if (p == lst.end ())
+if (p == lst.end ())
-		break;
+break;
-	      else
+else
-		{
+{
-		  // Clear preivous values before next statement is
+// Clear preivous values before next statement is
-		  // evaluated so that we aren't holding an extra
+// evaluated so that we aren't holding an extra
-		  // reference to a value that may be used next.  For
+// reference to a value that may be used next.  For
-		  // example, in code like this:
+// example, in code like this:
-		  //
+//
-		  //   X = rand (N);  ## refcount for X should be 1
+//   X = rand (N);  ## refcount for X should be 1
-		  //                  ## after this statement
+//                  ## after this statement
-		  //
+//
-		  //   X(idx) = val;  ## no extra copy of X should be
+//   X(idx) = val;  ## no extra copy of X should be
-		  //                  ## needed, but we will be faked
+//                  ## needed, but we will be faked
-		  //                  ## out if retval is not cleared
+//                  ## out if retval is not cleared
-		  //                  ## between statements here
+//                  ## between statements here
-		  //		  result_values = empty_list;
+//              result_values = empty_list;
-		}
+}
-	    }
+}
-	  else
+else
-	    error ("invalid statement found in statement list!");
+error ("invalid statement found in statement list!");
-	}
+}
 }
 }
 void
 tree_evaluator::visit_switch_case (tree_switch_case&)
 octave_value val = expr->rvalue1 ();
 tree_switch_case_list *lst = cmd.case_list ();
 if (! error_state && lst)
-	{
+{
-	  for (tree_switch_case_list::iterator p = lst->begin ();
+for (tree_switch_case_list::iterator p = lst->begin ();
-	       p != lst->end (); p++)
+p != lst->end (); p++)
-	    {
+{
-	      tree_switch_case *t = *p;
+tree_switch_case *t = *p;
-	      if (debug_mode && ! t->is_default_case ())
+if (debug_mode && ! t->is_default_case ())
-		do_breakpoint (t->is_breakpoint ());
+do_breakpoint (t->is_breakpoint ());
-	      if (t->is_default_case () || t->label_matches (val))
+if (t->is_default_case () || t->label_matches (val))
-		{
+{
-		  if (error_state)
+if (error_state)
-		    break;
+break;
-		  tree_statement_list *stmt_lst = t->commands ();
+tree_statement_list *stmt_lst = t->commands ();
-		  if (stmt_lst)
+if (stmt_lst)
-		    stmt_lst->accept (*this);
+stmt_lst->accept (*this);
-		  break;
+break;
-		}
+}
-	    }
+}
-	}
+}
 }
 else
 ::error ("missing value in switch command near line %d, column %d",
-	     cmd.line (), cmd.column ());
+cmd.line (), cmd.column ());
 }
 void
 tree_evaluator::visit_try_catch_command (tree_try_catch_command& cmd)
 {
 panic_impossible ();
 for (;;)
 {
 if (debug_mode)
-	do_breakpoint (cmd.is_breakpoint ());
+do_breakpoint (cmd.is_breakpoint ());
 if (expr->is_logically_true ("while"))
-	{
+{
-	  tree_statement_list *loop_body = cmd.body ();
+tree_statement_list *loop_body = cmd.body ();
-	  if (loop_body)
+if (loop_body)
-	    {
+{
-	      loop_body->accept (*this);
+loop_body->accept (*this);
-	      if (error_state)
+if (error_state)
 return;
-	    }
+}
-	  if (quit_loop_now ())
+if (quit_loop_now ())
-	    break;
+break;
-	}
+}
 else
-	break;
+break;
 }
 }
 void
 tree_evaluator::visit_do_until_command (tree_do_until_command& cmd)
 for (;;)
 {
 tree_statement_list *loop_body = cmd.body ();
 if (loop_body)
-	{
+{
-	  loop_body->accept (*this);
+loop_body->accept (*this);
-	  if (error_state)
+if (error_state)
 return;
-	}
+}
 if (quit_loop_now ())
-	break;
+break;
 if (debug_mode)
-	do_breakpoint (cmd.is_breakpoint ());
+do_breakpoint (cmd.is_breakpoint ());
 if (expr->is_logically_true ("do-until"))
-	break;
+break;
 }
 }
 void
 tree_evaluator::do_breakpoint (tree_statement& stmt) const
 do_breakpoint (stmt.is_breakpoint (), stmt.is_end_of_fcn_or_script ());
 }
 void
 tree_evaluator::do_breakpoint (bool is_breakpoint,
-			       bool is_end_of_fcn_or_script) const
+bool is_end_of_fcn_or_script) const
 {
 bool break_on_this_statement = false;
 // Don't decrement break flag unless we are in the same frame as we
 // were when we saw the "dbstep N" command.
 if (dbstep_flag > 1)
 {
 if (octave_call_stack::current_frame () == current_frame)
-	{
+{
-	  // Don't allow dbstep N to step past end of current frame.
+// Don't allow dbstep N to step past end of current frame.
-	  if (is_end_of_fcn_or_script)
+if (is_end_of_fcn_or_script)
-	    dbstep_flag = 1;
+dbstep_flag = 1;
-	  else
+else
-	    dbstep_flag--;
+dbstep_flag--;
-	}
+}
 }
 if (octave_debug_on_interrupt_state)
 {
 break_on_this_statement = true;
 current_frame = octave_call_stack::current_frame ();
 }
 else if (dbstep_flag == 1)
 {
 if (octave_call_stack::current_frame () == current_frame)
-	{
+{
-	  // We get here if we are doing a "dbstep" or a "dbstep N"
+// We get here if we are doing a "dbstep" or a "dbstep N"
-	  // and the count has reached 1 and we are in the current
+// and the count has reached 1 and we are in the current
-	  // debugging frame.
+// debugging frame.
-	  break_on_this_statement = true;
+break_on_this_statement = true;
-	  dbstep_flag = 0;
+dbstep_flag = 0;
-	}
+}
 }
 else if (dbstep_flag == -1)
 {
 // We get here if we are doing a "dbstep in".
 else if (dbstep_flag == -2)
 {
 // We get here if we are doing a "dbstep out".
 if (is_end_of_fcn_or_script)
-	dbstep_flag = -1;
+dbstep_flag = -1;
 }
 if (break_on_this_statement)
 do_keyboard ();

Mercurial > hg > octave-lyh

comparison src/pt-eval.cc @ 10315:57a59eae83cc