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

annotate 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

rev	line source
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	1 /*
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	2
19697 4197fc428c7d maint: Update copyright notices for 2015. John W. Eaton <jwe@octave.org> parents: 19380 diff changeset	3 Copyright (C) 2009-2015 John W. Eaton
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	4
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	5 This file is part of Octave.
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	6
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	7 Octave is free software; you can redistribute it and/or modify it
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	8 under the terms of the GNU General Public License as published by the
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	9 Free Software Foundation; either version 3 of the License, or (at your
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	10 option) any later version.
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	11
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	12 Octave is distributed in the hope that it will be useful, but WITHOUT
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	15 for more details.
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	16
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	17 You should have received a copy of the GNU General Public License
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	18 along with Octave; see the file COPYING. If not, see
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	19 <http://www.gnu.org/licenses/>.
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	20
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	21 */
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	22
21724 aba2e6293dd8 use "#if ..." consistently instead of "#ifdef" and "#ifndef" John W. Eaton <jwe@octave.org> parents: 21542 diff changeset	23 #if defined (HAVE_CONFIG_H)
21301 40de9f8f23a6 Use '#include "config.h"' rather than <config.h>. Rik <rik@octave.org> parents: 21211 diff changeset	24 # include "config.h"
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	25 #endif
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	26
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	27 #include <cctype>
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	28
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	29 #include <iostream>
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	30
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	31 #include <fstream>
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	32 #include <typeinfo>
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	33
22091 0f6fc2ec3b1a move call_stack class to a separate file John W. Eaton <jwe@octave.org> parents: 21966 diff changeset	34 #include "call-stack.h"
10186 095a1e670e68 make dbstep work with keyboard function John W. Eaton <jwe@octave.org> parents: 10160 diff changeset	35 #include "debug.h"
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	36 #include "defun.h"
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	37 #include "error.h"
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 20962 diff changeset	38 #include "errwarn.h"
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	39 #include "input.h"
22094 9203833cab7d move new interpreter class to separate file John W. Eaton <jwe@octave.org> parents: 22091 diff changeset	40 #include "interpreter.h"
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	41 #include "ov-fcn-handle.h"
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	42 #include "ov-usr-fcn.h"
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	43 #include "variables.h"
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	44 #include "pt-all.h"
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	45 #include "pt-eval.h"
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	46 #include "symtab.h"
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	47 #include "unwind-prot.h"
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	48
14899 f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: 14429 diff changeset	49 //FIXME: This should be part of tree_evaluator
f25d2224fa02 Initial JIT support Max Brister <max@2bass.com> parents: 14429 diff changeset	50 #include "pt-jit.h"
15310 b055fc077224 allow jit compiler to be enabled at run-time John W. Eaton <jwe@octave.org> parents: 15244 diff changeset	51
10578 cb0883127251 limit on recursion via calls to source function John W. Eaton <jwe@octave.org> parents: 10315 diff changeset	52 // Maximum nesting level for functions, scripts, or sourced files called
cb0883127251 limit on recursion via calls to source function John W. Eaton <jwe@octave.org> parents: 10315 diff changeset	53 // recursively.
cb0883127251 limit on recursion via calls to source function John W. Eaton <jwe@octave.org> parents: 10315 diff changeset	54 int Vmax_recursion_depth = 256;
cb0883127251 limit on recursion via calls to source function John W. Eaton <jwe@octave.org> parents: 10315 diff changeset	55
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	56 // If TRUE, turn off printing of results in functions (as if a
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	57 // semicolon has been appended to each statement).
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	58 static bool Vsilent_functions = false;
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	59
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	60 namespace octave
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	61 {
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	62 int tree_evaluator::dbstep_flag = 0;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	63
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	64 size_t tree_evaluator::current_frame = 0;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	65
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	66 bool tree_evaluator::debug_mode = false;
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	67
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	68 bool tree_evaluator::quiet_breakpoint_flag = false;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	69
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	70 tree_evaluator::stmt_list_type tree_evaluator::statement_context
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	71 = tree_evaluator::other;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	72
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	73 bool tree_evaluator::in_loop_command = false;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	74
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	75 // Normal evaluator.
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	76
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	77 void
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	78 tree_evaluator::visit_anon_fcn_handle (tree_anon_fcn_handle&)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	79 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	80 panic_impossible ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	81 }
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	82
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	83 void
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	84 tree_evaluator::visit_argument_list (tree_argument_list&)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	85 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	86 panic_impossible ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	87 }
8845 5a6db6bd1a02 eigs.cc (Feigs): fix handling of sigma arg John W. Eaton <jwe@octave.org> parents: 8679 diff changeset	88
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	89 void
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	90 tree_evaluator::visit_binary_expression (tree_binary_expression&)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	91 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	92 panic_impossible ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	93 }
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	94
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	95 void
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	96 tree_evaluator::visit_break_command (tree_break_command& cmd)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	97 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	98 if (debug_mode)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	99 do_breakpoint (cmd.is_breakpoint (true));
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	100
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	101 if (statement_context == function \|\| statement_context == script
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	102 \|\| in_loop_command)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	103 tree_break_command::breaking = 1;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	104 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	105
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	106 void
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	107 tree_evaluator::visit_colon_expression (tree_colon_expression&)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	108 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	109 panic_impossible ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	110 }
10188 97ae300aa73a improve implementation of break, continue, and return commands John W. Eaton <jwe@octave.org> parents: 10186 diff changeset	111
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	112 void
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	113 tree_evaluator::visit_continue_command (tree_continue_command& cmd)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	114 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	115 if (debug_mode)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	116 do_breakpoint (cmd.is_breakpoint (true));
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	117
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	118 if (statement_context == function \|\| statement_context == script
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	119 \|\| in_loop_command)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	120 tree_continue_command::continuing = 1;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	121 }
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	122
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	123 void
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	124 tree_evaluator::reset_debug_state (void)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	125 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	126 debug_mode = bp_table::have_breakpoints () \|\| Vdebugging;
10186 095a1e670e68 make dbstep work with keyboard function John W. Eaton <jwe@octave.org> parents: 10160 diff changeset	127
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	128 dbstep_flag = 0;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	129 }
10186 095a1e670e68 make dbstep work with keyboard function John W. Eaton <jwe@octave.org> parents: 10160 diff changeset	130
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	131 bool
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	132 tree_evaluator::statement_printing_enabled (void)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	133 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	134 return ! (Vsilent_functions && (statement_context == function
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	135 \|\| statement_context == script));
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	136 }
15606 fb9dffe5fbfb The silent_functions flag no longer modifies the parse tree Max Brister <max@2bass.com> parents: 15582 diff changeset	137 }
fb9dffe5fbfb The silent_functions flag no longer modifies the parse tree Max Brister <max@2bass.com> parents: 15582 diff changeset	138
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	139 static inline void
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	140 do_global_init (tree_decl_elt& elt)
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	141 {
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	142 tree_identifier *id = elt.ident ();
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	143
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	144 if (id)
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	145 {
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	146 id->mark_global ();
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	147
20560 56fee8f84fe7 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20535 diff changeset	148 octave_lvalue ult = id->lvalue ();
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	149
20560 56fee8f84fe7 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20535 diff changeset	150 if (ult.is_undefined ())
56fee8f84fe7 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20535 diff changeset	151 {
56fee8f84fe7 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20535 diff changeset	152 tree_expression *expr = elt.expression ();
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	153
20560 56fee8f84fe7 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20535 diff changeset	154 octave_value init_val;
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	155
20560 56fee8f84fe7 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20535 diff changeset	156 if (expr)
56fee8f84fe7 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20535 diff changeset	157 init_val = expr->rvalue1 ();
56fee8f84fe7 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20535 diff changeset	158 else
56fee8f84fe7 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20535 diff changeset	159 init_val = Matrix ();
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	160
20560 56fee8f84fe7 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20535 diff changeset	161 ult.assign (octave_value::op_asn_eq, init_val);
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10219 diff changeset	162 }
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	163 }
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	164 }
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	165
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	166 static inline void
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	167 do_static_init (tree_decl_elt& elt)
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	168 {
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	169 tree_identifier *id = elt.ident ();
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	170
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	171 if (id)
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	172 {
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	173 id->mark_as_static ();
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	174
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	175 octave_lvalue ult = id->lvalue ();
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	176
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	177 if (ult.is_undefined ())
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10219 diff changeset	178 {
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10219 diff changeset	179 tree_expression *expr = elt.expression ();
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	180
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10219 diff changeset	181 octave_value init_val;
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	182
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10219 diff changeset	183 if (expr)
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10219 diff changeset	184 init_val = expr->rvalue1 ();
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10219 diff changeset	185 else
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10219 diff changeset	186 init_val = Matrix ();
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	187
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10219 diff changeset	188 ult.assign (octave_value::op_asn_eq, init_val);
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10219 diff changeset	189 }
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	190 }
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	191 }
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	192
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	193 namespace octave
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	194 {
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	195 void
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	196 tree_evaluator::do_decl_init_list (decl_elt_init_fcn fcn,
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	197 tree_decl_init_list *init_list)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	198 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	199 if (init_list)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	200 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	201 for (tree_decl_init_list::iterator p = init_list->begin ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	202 p != init_list->end (); p++)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	203 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	204 tree_decl_elt elt = p;
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	205
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	206 fcn (*elt);
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	207 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	208 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	209 }
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	210
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	211 void
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	212 tree_evaluator::visit_global_command (tree_global_command& cmd)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	213 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	214 if (debug_mode)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	215 do_breakpoint (cmd.is_breakpoint (true));
8845 5a6db6bd1a02 eigs.cc (Feigs): fix handling of sigma arg John W. Eaton <jwe@octave.org> parents: 8679 diff changeset	216
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	217 do_decl_init_list (do_global_init, cmd.initializer_list ());
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	218 }
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	219
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	220 void
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	221 tree_evaluator::visit_persistent_command (tree_persistent_command& cmd)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	222 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	223 if (debug_mode)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	224 do_breakpoint (cmd.is_breakpoint (true));
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	225
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	226 do_decl_init_list (do_static_init, cmd.initializer_list ());
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	227 }
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	228
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	229 void
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	230 tree_evaluator::visit_decl_elt (tree_decl_elt&)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	231 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	232 panic_impossible ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	233 }
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	234
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	235 void
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	236 tree_evaluator::visit_decl_init_list (tree_decl_init_list&)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	237 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	238 panic_impossible ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	239 }
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	240 }
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	241
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	242 // Decide if it's time to quit a for or while loop.
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	243 static inline bool
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	244 quit_loop_now (void)
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	245 {
10142 829e69ec3110 make OCTAVE_QUIT a function Jaroslav Hajek <highegg@gmail.com> parents: 10066 diff changeset	246 octave_quit ();
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	247
15466 d174210ce1ec use ' instead of ` in error messages, warnings and most comments John W. Eaton <jwe@octave.org> parents: 14138 diff changeset	248 // Maybe handle 'continue N' someday...
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	249
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	250 if (tree_continue_command::continuing)
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	251 tree_continue_command::continuing--;
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	252
20560 56fee8f84fe7 eliminate more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20535 diff changeset	253 bool quit = (tree_return_command::returning
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10219 diff changeset	254 \|\| tree_break_command::breaking
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10219 diff changeset	255 \|\| tree_continue_command::continuing);
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	256
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	257 if (tree_break_command::breaking)
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	258 tree_break_command::breaking--;
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	259
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	260 return quit;
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	261 }
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	262
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	263 namespace octave
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	264 {
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	265 void
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	266 tree_evaluator::visit_simple_for_command (tree_simple_for_command& cmd)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	267 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	268 if (debug_mode)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	269 do_breakpoint (cmd.is_breakpoint (true));
13245 027a2186cd90 parfor keyword and infrastructure, but handle parfor as normal for loop for now John W. Eaton <jwe@octave.org> parents: 13226 diff changeset	270
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	271 // FIXME: need to handle PARFOR loops here using cmd.in_parallel ()
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	272 // and cmd.maxproc_expr ();
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	273
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	274 octave::unwind_protect frame;
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	275
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	276 frame.protect_var (in_loop_command);
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	277
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	278 in_loop_command = true;
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	279
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	280 tree_expression *expr = cmd.control_expr ();
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	281
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	282 octave_value rhs = expr->rvalue1 ();
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	283
21211 2cf8bc5c7017 use "#if defined (HAVE_FOO)" instead of "#if HAVE_FOO" for feature tests John W. Eaton <jwe@octave.org> parents: 21200 diff changeset	284 #if defined (HAVE_LLVM)
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	285 if (tree_jit::execute (cmd, rhs))
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	286 return;
15027 741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	287 #endif
741d2dbcc117 Check trip count before compiling for loops. Max Brister <max@2bass.com> parents: 15023 diff changeset	288
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	289 if (rhs.is_undefined ())
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	290 return;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	291
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	292 tree_expression *lhs = cmd.left_hand_side ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	293
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	294 octave_lvalue ult = lhs->lvalue ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	295
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	296 tree_statement_list *loop_body = cmd.body ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	297
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	298 if (rhs.is_range ())
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	299 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	300 Range rng = rhs.range_value ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	301
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	302 octave_idx_type steps = rng.numel ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	303
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	304 for (octave_idx_type i = 0; i < steps; i++)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	305 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	306 octave_value val (rng.elem (i));
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	307
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	308 ult.assign (octave_value::op_asn_eq, val);
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	309
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	310 if (loop_body)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	311 loop_body->accept (*this);
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	312
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	313 if (quit_loop_now ())
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	314 break;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	315 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	316 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	317 else if (rhs.is_scalar_type ())
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	318 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	319 ult.assign (octave_value::op_asn_eq, rhs);
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	320
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	321 if (loop_body)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	322 loop_body->accept (*this);
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	323
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	324 // Maybe decrement break and continue states.
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	325 quit_loop_now ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	326 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	327 else if (rhs.is_matrix_type () \|\| rhs.is_cell () \|\| rhs.is_string ()
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	328 \|\| rhs.is_map ())
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	329 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	330 // A matrix or cell is reshaped to 2 dimensions and iterated by
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	331 // columns.
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	332
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	333 dim_vector dv = rhs.dims ().redim (2);
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	334
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	335 octave_idx_type nrows = dv(0);
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	336 octave_idx_type steps = dv(1);
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	337
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	338 if (steps > 0)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	339 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	340 octave_value arg = rhs;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	341 if (rhs.ndims () > 2)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	342 arg = arg.reshape (dv);
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	343
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	344 // for row vectors, use single index to speed things up.
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	345 octave_value_list idx;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	346 octave_idx_type iidx;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	347 if (nrows == 1)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	348 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	349 idx.resize (1);
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	350 iidx = 0;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	351 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	352 else
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	353 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	354 idx.resize (2);
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	355 idx(0) = octave_value::magic_colon_t;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	356 iidx = 1;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	357 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	358
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	359 for (octave_idx_type i = 1; i <= steps; i++)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	360 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	361 // do_index_op expects one-based indices.
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	362 idx(iidx) = i;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	363 octave_value val = arg.do_index_op (idx);
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	364
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	365 ult.assign (octave_value::op_asn_eq, val);
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	366
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	367 if (loop_body)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	368 loop_body->accept (*this);
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	369
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	370 if (quit_loop_now ())
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	371 break;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	372 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	373 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	374 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	375 else
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	376 error ("invalid type in for loop expression near line %d, column %d",
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	377 cmd.line (), cmd.column ());
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	378 }
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	379
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	380 void
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	381 tree_evaluator::visit_complex_for_command (tree_complex_for_command& cmd)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	382 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	383 if (debug_mode)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	384 do_breakpoint (cmd.is_breakpoint (true));
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	385
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	386 octave::unwind_protect frame;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	387
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	388 frame.protect_var (in_loop_command);
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	389
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	390 in_loop_command = true;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	391
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	392 tree_expression *expr = cmd.control_expr ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	393
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	394 octave_value rhs = expr->rvalue1 ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	395
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	396 if (rhs.is_undefined ())
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	397 return;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	398
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	399 if (! rhs.is_map ())
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	400 error ("in statement 'for [X, Y] = VAL', VAL must be a structure");
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	401
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	402 // Cycle through structure elements. First element of id_list
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	403 // is set to value and the second is set to the name of the
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	404 // structure element.
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	405
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	406 tree_argument_list *lhs = cmd.left_hand_side ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	407
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	408 tree_argument_list::iterator p = lhs->begin ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	409
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	410 tree_expression elt = p++;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	411
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	412 octave_lvalue val_ref = elt->lvalue ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	413
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	414 elt = *p;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	415
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	416 octave_lvalue key_ref = elt->lvalue ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	417
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	418 const octave_map tmp_val = rhs.map_value ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	419
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	420 tree_statement_list *loop_body = cmd.body ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	421
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	422 string_vector keys = tmp_val.keys ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	423
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	424 octave_idx_type nel = keys.numel ();
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	425
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	426 for (octave_idx_type i = 0; i < nel; i++)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	427 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	428 std::string key = keys[i];
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	429
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	430 const Cell val_lst = tmp_val.contents (key);
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	431
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	432 octave_idx_type n = val_lst.numel ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	433
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	434 octave_value val = (n == 1) ? val_lst(0) : octave_value (val_lst);
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	435
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	436 val_ref.assign (octave_value::op_asn_eq, val);
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	437 key_ref.assign (octave_value::op_asn_eq, key);
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	438
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	439 if (loop_body)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	440 loop_body->accept (*this);
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	441
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	442 if (quit_loop_now ())
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	443 break;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	444 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	445 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	446
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	447 void
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	448 tree_evaluator::visit_octave_user_script (octave_user_script&)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	449 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	450 panic_impossible ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	451 }
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	452
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	453 void
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	454 tree_evaluator::visit_octave_user_function (octave_user_function&)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	455 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	456 panic_impossible ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	457 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	458
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	459 void
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	460 tree_evaluator::visit_octave_user_function_header (octave_user_function&)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	461 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	462 panic_impossible ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	463 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	464
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	465 void
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	466 tree_evaluator::visit_octave_user_function_trailer (octave_user_function&)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	467 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	468 panic_impossible ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	469 }
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	470
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	471 void
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	472 tree_evaluator::visit_function_def (tree_function_def& cmd)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	473 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	474 octave_value fcn = cmd.function ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	475
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	476 octave_function *f = fcn.function_value ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	477
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	478 if (f)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	479 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	480 std::string nm = f->name ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	481
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	482 symbol_table::install_cmdline_function (nm, fcn);
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	483
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	484 // Make sure that any variable with the same name as the new
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	485 // function is cleared.
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	486
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	487 symbol_table::assign (nm);
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	488 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	489 }
13225 359153d26cc1 eliminate DO_SIMPLE_FOR_LOOP_ONCE macro John W. Eaton <jwe@octave.org> parents: 12833 diff changeset	490
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	491 void
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	492 tree_evaluator::visit_identifier (tree_identifier&)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	493 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	494 panic_impossible ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	495 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	496
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	497 void
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	498 tree_evaluator::visit_if_clause (tree_if_clause&)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	499 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	500 panic_impossible ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	501 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	502
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	503 void
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	504 tree_evaluator::visit_if_command (tree_if_command& cmd)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	505 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	506 tree_if_command_list *lst = cmd.cmd_list ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	507
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	508 if (lst)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	509 lst->accept (*this);
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	510 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	511
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	512 void
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	513 tree_evaluator::visit_if_command_list (tree_if_command_list& lst)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	514 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	515 for (tree_if_command_list::iterator p = lst.begin (); p != lst.end (); p++)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	516 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	517 tree_if_clause tic = p;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	518
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	519 tree_expression *expr = tic->condition ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	520
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	521 if (statement_context == function \|\| statement_context == script)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	522 octave_call_stack::set_location (tic->line (), tic->column ());
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	523
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	524 if (debug_mode && ! tic->is_else_clause ())
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	525 do_breakpoint (tic->is_breakpoint (true));
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	526
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	527 if (tic->is_else_clause () \|\| expr->is_logically_true ("if"))
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	528 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	529 tree_statement_list *stmt_lst = tic->commands ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	530
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	531 if (stmt_lst)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	532 stmt_lst->accept (*this);
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	533
20784 52f6921dde09 * pt-eval.cc: Style fixes. John W. Eaton <jwe@octave.org> parents: 20715 diff changeset	534 break;
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	535 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	536 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	537 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	538
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	539 void
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	540 tree_evaluator::visit_index_expression (tree_index_expression&)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	541 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	542 panic_impossible ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	543 }
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	544
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	545 void
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	546 tree_evaluator::visit_matrix (tree_matrix&)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	547 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	548 panic_impossible ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	549 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	550
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	551 void
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	552 tree_evaluator::visit_cell (tree_cell&)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	553 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	554 panic_impossible ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	555 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	556
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	557 void
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	558 tree_evaluator::visit_multi_assignment (tree_multi_assignment&)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	559 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	560 panic_impossible ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	561 }
13225 359153d26cc1 eliminate DO_SIMPLE_FOR_LOOP_ONCE macro John W. Eaton <jwe@octave.org> parents: 12833 diff changeset	562
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	563 void
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	564 tree_evaluator::visit_no_op_command (tree_no_op_command& cmd)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	565 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	566 if (debug_mode && cmd.is_end_of_fcn_or_script ())
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	567 do_breakpoint (cmd.is_breakpoint (true), true);
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	568 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	569
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	570 void
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	571 tree_evaluator::visit_constant (tree_constant&)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	572 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	573 panic_impossible ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	574 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	575
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	576 void
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	577 tree_evaluator::visit_fcn_handle (tree_fcn_handle&)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	578 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	579 panic_impossible ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	580 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	581
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	582 void
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	583 tree_evaluator::visit_funcall (tree_funcall&)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	584 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	585 panic_impossible ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	586 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	587
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	588 void
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	589 tree_evaluator::visit_parameter_list (tree_parameter_list&)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	590 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	591 panic_impossible ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	592 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	593
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	594 void
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	595 tree_evaluator::visit_postfix_expression (tree_postfix_expression&)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	596 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	597 panic_impossible ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	598 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	599
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	600 void
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	601 tree_evaluator::visit_prefix_expression (tree_prefix_expression&)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	602 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	603 panic_impossible ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	604 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	605
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	606 void
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	607 tree_evaluator::visit_return_command (tree_return_command& cmd)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	608 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	609 if (debug_mode)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	610 do_breakpoint (cmd.is_breakpoint (true));
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	611
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	612 // Act like dbcont.
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	613
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	614 if (Vdebugging
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	615 && octave_call_stack::current_frame () == current_frame)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	616 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	617 Vdebugging = false;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	618
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	619 reset_debug_state ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	620 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	621 else if (statement_context == function \|\| statement_context == script
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	622 \|\| in_loop_command)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	623 tree_return_command::returning = 1;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	624 }
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	625
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	626 void
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	627 tree_evaluator::visit_return_list (tree_return_list&)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	628 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	629 panic_impossible ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	630 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	631
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	632 void
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	633 tree_evaluator::visit_simple_assignment (tree_simple_assignment&)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	634 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	635 panic_impossible ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	636 }
8662 af72c8137d64 improve looping over arrays Jaroslav Hajek <highegg@gmail.com> parents: 8658 diff changeset	637
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	638 void
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	639 tree_evaluator::visit_statement (tree_statement& stmt)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	640 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	641 tree_command *cmd = stmt.command ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	642 tree_expression *expr = stmt.expression ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	643
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	644 if (cmd \|\| expr)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	645 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	646 if (statement_context == function \|\| statement_context == script)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	647 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	648 // Skip commands issued at a debug> prompt to avoid disturbing
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	649 // the state of the program we are debugging.
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	650
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	651 if (Vtrack_line_num)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	652 octave_call_stack::set_location (stmt.line (), stmt.column ());
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	653
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	654 if ((statement_context == script
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	655 && ((Vecho_executing_commands & ECHO_SCRIPTS
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	656 && octave_call_stack::all_scripts ())
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	657 \|\| Vecho_executing_commands & ECHO_FUNCTIONS))
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	658 \|\| (statement_context == function
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	659 && Vecho_executing_commands & ECHO_FUNCTIONS))
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	660 stmt.echo_code ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	661 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	662
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	663 try
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	664 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	665 if (cmd)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	666 cmd->accept (*this);
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	667 else
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	668 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	669 if (debug_mode)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	670 do_breakpoint (expr->is_breakpoint (true));
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	671
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	672 // FIXME: maybe all of this should be packaged in
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	673 // one virtual function that returns a flag saying whether
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	674 // or not the expression will take care of binding ans and
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	675 // printing the result.
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	676
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	677 // FIXME: it seems that we should just have to
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	678 // call expr->rvalue1 () and that should take care of
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	679 // everything, binding ans as necessary?
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	680
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	681 bool do_bind_ans = false;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	682
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	683 if (expr->is_identifier ())
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	684 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	685 tree_identifier id = dynamic_cast<tree_identifier > (expr);
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	686
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	687 do_bind_ans = (! id->is_variable ());
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	688 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	689 else
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	690 do_bind_ans = (! expr->is_assignment_expression ());
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	691
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	692 octave_value tmp_result = expr->rvalue1 (0);
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	693
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	694 if (do_bind_ans && tmp_result.is_defined ())
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	695 bind_ans (tmp_result, expr->print_result ()
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	696 && statement_printing_enabled ());
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	697
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	698 // if (tmp_result.is_defined ())
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	699 // result_values(0) = tmp_result;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	700 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	701 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	702 catch (const std::bad_alloc&)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	703 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	704 // FIXME: We want to use error_with_id here so that give users
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	705 // control over this error message but error_with_id will
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	706 // require some memory allocations. Is there anything we can
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	707 // do to make those more likely to succeed?
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	708
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	709 error_with_id ("Octave:bad-alloc",
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	710 "out of memory or dimension too large for Octave's index type");
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	711 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	712 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	713 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	714
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	715 void
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	716 tree_evaluator::visit_statement_list (tree_statement_list& lst)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	717 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	718 // FIXME: commented out along with else clause below.
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	719 // static octave_value_list empty_list;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	720
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	721 tree_statement_list::iterator p = lst.begin ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	722
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	723 if (p != lst.end ())
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	724 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	725 while (true)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	726 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	727 tree_statement elt = p++;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	728
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	729 if (! elt)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	730 error ("invalid statement found in statement list!");
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	731
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	732 octave_quit ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	733
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	734 elt->accept (*this);
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	735
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	736 if (tree_break_command::breaking
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	737 \|\| tree_continue_command::continuing)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	738 break;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	739
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	740 if (tree_return_command::returning)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	741 break;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	742
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	743 if (p == lst.end ())
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	744 break;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	745 else
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	746 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	747 // Clear previous values before next statement is
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	748 // evaluated so that we aren't holding an extra
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	749 // reference to a value that may be used next. For
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	750 // example, in code like this:
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	751 //
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	752 // X = rand (N); # refcount for X should be 1
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	753 // # after this statement
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	754 //
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	755 // X(idx) = val; # no extra copy of X should be
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	756 // # needed, but we will be faked
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	757 // # out if retval is not cleared
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	758 // # between statements here
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	759
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	760 // result_values = empty_list;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	761 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	762 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	763 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	764 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	765
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	766 void
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	767 tree_evaluator::visit_switch_case (tree_switch_case&)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	768 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	769 panic_impossible ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	770 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	771
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	772 void
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	773 tree_evaluator::visit_switch_case_list (tree_switch_case_list&)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	774 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	775 panic_impossible ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	776 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	777
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	778 void
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	779 tree_evaluator::visit_switch_command (tree_switch_command& cmd)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	780 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	781 if (debug_mode)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	782 do_breakpoint (cmd.is_breakpoint (true));
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	783
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	784 tree_expression *expr = cmd.switch_value ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	785
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	786 if (! expr)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	787 error ("missing value in switch command near line %d, column %d",
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	788 cmd.line (), cmd.column ());
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	789
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	790 octave_value val = expr->rvalue1 ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	791
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	792 tree_switch_case_list *lst = cmd.case_list ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	793
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	794 if (lst)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	795 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	796 for (tree_switch_case_list::iterator p = lst->begin ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	797 p != lst->end (); p++)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	798 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	799 tree_switch_case t = p;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	800
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	801 if (t->is_default_case () \|\| t->label_matches (val))
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	802 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	803 tree_statement_list *stmt_lst = t->commands ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	804
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	805 if (stmt_lst)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	806 stmt_lst->accept (*this);
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	807
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	808 break;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	809 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	810 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	811 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	812 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	813
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	814 void
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	815 tree_evaluator::visit_try_catch_command (tree_try_catch_command& cmd)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	816 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	817 bool execution_error = false;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	818
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	819 { // unwind frame before catch block
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	820 octave::unwind_protect frame;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	821
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	822 frame.protect_var (buffer_error_messages);
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	823 frame.protect_var (Vdebug_on_error);
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	824 frame.protect_var (Vdebug_on_warning);
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	825
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	826 buffer_error_messages++;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	827 Vdebug_on_error = false;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	828 Vdebug_on_warning = false;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	829
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	830 // The catch code is not added to unwind_protect stack;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	831 // it doesn't need to be run on interrupts.
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	832
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	833 tree_statement_list *try_code = cmd.body ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	834
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	835 if (try_code)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	836 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	837 try
20784 52f6921dde09 * pt-eval.cc: Style fixes. John W. Eaton <jwe@octave.org> parents: 20715 diff changeset	838 {
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	839 in_try_catch++;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	840 try_code->accept (*this);
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	841 in_try_catch--;
20784 52f6921dde09 * pt-eval.cc: Style fixes. John W. Eaton <jwe@octave.org> parents: 20715 diff changeset	842 }
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	843 catch (const octave_execution_exception&)
20784 52f6921dde09 * pt-eval.cc: Style fixes. John W. Eaton <jwe@octave.org> parents: 20715 diff changeset	844 {
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	845 recover_from_exception ();
13225 359153d26cc1 eliminate DO_SIMPLE_FOR_LOOP_ONCE macro John W. Eaton <jwe@octave.org> parents: 12833 diff changeset	846
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	847 in_try_catch--; // must be restored before "catch" block
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	848 execution_error = true;
20784 52f6921dde09 * pt-eval.cc: Style fixes. John W. Eaton <jwe@octave.org> parents: 20715 diff changeset	849 }
52f6921dde09 * pt-eval.cc: Style fixes. John W. Eaton <jwe@octave.org> parents: 20715 diff changeset	850 }
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	851 // Unwind to let the user print any messages from
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	852 // errors that occurred in the body of the try_catch statement,
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	853 // or throw further errors.
20784 52f6921dde09 * pt-eval.cc: Style fixes. John W. Eaton <jwe@octave.org> parents: 20715 diff changeset	854 }
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	855
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	856 if (execution_error)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	857 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	858 tree_statement_list *catch_code = cmd.cleanup ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	859 if (catch_code)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	860 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	861 tree_identifier *expr_id = cmd.identifier ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	862 octave_lvalue ult;
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	863
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	864 if (expr_id)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	865 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	866 ult = expr_id->lvalue ();
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	867
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	868 octave_scalar_map err;
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	869
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	870 err.assign ("message", last_error_message ());
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	871 err.assign ("identifier", last_error_id ());
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	872 err.assign ("stack", last_error_stack ());
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	873
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	874 ult.assign (octave_value::op_asn_eq, err);
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	875 }
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	876
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	877 // perform actual "catch" block
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	878 if (catch_code)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	879 catch_code->accept (*this);
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	880 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	881 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	882 }
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	883
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	884 void
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	885 tree_evaluator::do_unwind_protect_cleanup_code (tree_statement_list *list)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	886 {
21922 c34f9c182dcf Make debug_on_error to apply to the "catch" block of try/catch (bug #47685) Rik <rik@octave.org> parents: 21743 diff changeset	887 octave::unwind_protect frame;
c34f9c182dcf Make debug_on_error to apply to the "catch" block of try/catch (bug #47685) Rik <rik@octave.org> parents: 21743 diff changeset	888
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	889 frame.protect_var (octave_interrupt_state);
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	890 octave_interrupt_state = 0;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	891
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	892 // We want to preserve the last location info for possible
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	893 // backtracking.
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	894 frame.add_fcn (octave_call_stack::set_line,
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	895 octave_call_stack::current_line ());
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	896 frame.add_fcn (octave_call_stack::set_column,
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	897 octave_call_stack::current_column ());
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	898
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	899 // Similarly, if we have seen a return or break statement, allow all
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	900 // the cleanup code to run before returning or handling the break.
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	901 // We don't have to worry about continue statements because they can
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	902 // only occur in loops.
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	903
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	904 frame.protect_var (tree_return_command::returning);
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	905 tree_return_command::returning = 0;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	906
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	907 frame.protect_var (tree_break_command::breaking);
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	908 tree_break_command::breaking = 0;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	909
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	910 try
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	911 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	912 if (list)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	913 list->accept (*this);
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	914 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	915 catch (const octave_execution_exception&)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	916 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	917 recover_from_exception ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	918
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	919 if (tree_break_command::breaking \|\| tree_return_command::returning)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	920 frame.discard (2);
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	921 else
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	922 frame.run (2);
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	923
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	924 frame.discard (2);
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	925
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	926 throw;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	927 }
21922 c34f9c182dcf Make debug_on_error to apply to the "catch" block of try/catch (bug #47685) Rik <rik@octave.org> parents: 21743 diff changeset	928
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	929 // The unwind_protects are popped off the stack in the reverse of
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	930 // the order they are pushed on.
21922 c34f9c182dcf Make debug_on_error to apply to the "catch" block of try/catch (bug #47685) Rik <rik@octave.org> parents: 21743 diff changeset	931
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	932 // FIXME: these statements say that if we see a break or
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	933 // return statement in the cleanup block, that we want to use the
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	934 // new value of the breaking or returning flag instead of restoring
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	935 // the previous value. Is that the right thing to do? I think so.
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	936 // Consider the case of
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	937 //
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	938 // function foo ()
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	939 // unwind_protect
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	940 // fprintf (stderr, "1: this should always be executed\n");
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	941 // break;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	942 // fprintf (stderr, "1: this should never be executed\n");
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	943 // unwind_protect_cleanup
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	944 // fprintf (stderr, "2: this should always be executed\n");
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	945 // return;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	946 // fprintf (stderr, "2: this should never be executed\n");
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	947 // end_unwind_protect
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	948 // endfunction
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	949 //
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	950 // If we reset the value of the breaking flag, both the returning
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	951 // flag and the breaking flag will be set, and we shouldn't have
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	952 // both. So, use the most recent one. If there is no return or
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	953 // break in the cleanup block, the values should be reset to
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	954 // whatever they were when the cleanup block was entered.
21922 c34f9c182dcf Make debug_on_error to apply to the "catch" block of try/catch (bug #47685) Rik <rik@octave.org> parents: 21743 diff changeset	955
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	956 if (tree_break_command::breaking \|\| tree_return_command::returning)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	957 frame.discard (2);
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	958 else
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	959 frame.run (2);
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	960 }
20666 e0e2c2ce7e94 defer stack trace until back at top level John W. Eaton <jwe@octave.org> parents: 20560 diff changeset	961
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	962 void
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	963 tree_evaluator::visit_unwind_protect_command (tree_unwind_protect_command& cmd)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	964 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	965 tree_statement_list *cleanup_code = cmd.cleanup ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	966
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	967 tree_statement_list *unwind_protect_code = cmd.body ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	968
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	969 if (unwind_protect_code)
21922 c34f9c182dcf Make debug_on_error to apply to the "catch" block of try/catch (bug #47685) Rik <rik@octave.org> parents: 21743 diff changeset	970 {
c34f9c182dcf Make debug_on_error to apply to the "catch" block of try/catch (bug #47685) Rik <rik@octave.org> parents: 21743 diff changeset	971 try
c34f9c182dcf Make debug_on_error to apply to the "catch" block of try/catch (bug #47685) Rik <rik@octave.org> parents: 21743 diff changeset	972 {
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	973 unwind_protect_code->accept (*this);
21922 c34f9c182dcf Make debug_on_error to apply to the "catch" block of try/catch (bug #47685) Rik <rik@octave.org> parents: 21743 diff changeset	974 }
c34f9c182dcf Make debug_on_error to apply to the "catch" block of try/catch (bug #47685) Rik <rik@octave.org> parents: 21743 diff changeset	975 catch (const octave_execution_exception&)
c34f9c182dcf Make debug_on_error to apply to the "catch" block of try/catch (bug #47685) Rik <rik@octave.org> parents: 21743 diff changeset	976 {
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	977 // FIXME: Maybe we should be able to temporarily set the
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	978 // interpreter's exception handling state to something "safe"
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	979 // while the cleanup block runs instead of just resetting it
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	980 // here?
21922 c34f9c182dcf Make debug_on_error to apply to the "catch" block of try/catch (bug #47685) Rik <rik@octave.org> parents: 21743 diff changeset	981 recover_from_exception ();
c34f9c182dcf Make debug_on_error to apply to the "catch" block of try/catch (bug #47685) Rik <rik@octave.org> parents: 21743 diff changeset	982
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	983 // Run the cleanup code on exceptions, so that it is run even
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	984 // in case of interrupt or out-of-memory.
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	985 do_unwind_protect_cleanup_code (cleanup_code);
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	986
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	987 // If an error occurs inside the cleanup code, a new
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	988 // exception will be thrown instead of the original.
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	989 throw;
21922 c34f9c182dcf Make debug_on_error to apply to the "catch" block of try/catch (bug #47685) Rik <rik@octave.org> parents: 21743 diff changeset	990 }
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	991
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	992 // Also execute the unwind_protect_cleanump code if the
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	993 // unwind_protect block runs without error.
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	994 do_unwind_protect_cleanup_code (cleanup_code);
21922 c34f9c182dcf Make debug_on_error to apply to the "catch" block of try/catch (bug #47685) Rik <rik@octave.org> parents: 21743 diff changeset	995 }
c34f9c182dcf Make debug_on_error to apply to the "catch" block of try/catch (bug #47685) Rik <rik@octave.org> parents: 21743 diff changeset	996 }
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	997
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	998 void
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	999 tree_evaluator::visit_while_command (tree_while_command& cmd)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1000 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1001 #if defined (HAVE_LLVM)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1002 if (tree_jit::execute (cmd))
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1003 return;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1004 #endif
9383 d57f0c56195f improve error handling Jaroslav Hajek <highegg@gmail.com> parents: 9378 diff changeset	1005
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1006 octave::unwind_protect frame;
10210 752f349052a2 ensure correct backtraces after error in unwind_protect Jaroslav Hajek <highegg@gmail.com> parents: 10194 diff changeset	1007
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1008 frame.protect_var (in_loop_command);
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	1009
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1010 in_loop_command = true;
20666 e0e2c2ce7e94 defer stack trace until back at top level John W. Eaton <jwe@octave.org> parents: 20560 diff changeset	1011
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1012 tree_expression *expr = cmd.condition ();
20824 8848e35e5ef8 better handling of exceptions in unwind-protect blocks John W. Eaton <jwe@octave.org> parents: 20784 diff changeset	1013
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1014 if (! expr)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1015 panic_impossible ();
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	1016
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1017 for (;;)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1018 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1019 if (debug_mode)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1020 do_breakpoint (cmd.is_breakpoint (true));
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	1021
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1022 if (expr->is_logically_true ("while"))
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1023 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1024 tree_statement_list *loop_body = cmd.body ();
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	1025
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1026 if (loop_body)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1027 loop_body->accept (*this);
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	1028
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1029 if (quit_loop_now ())
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1030 break;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1031 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1032 else
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1033 break;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1034 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1035 }
20666 e0e2c2ce7e94 defer stack trace until back at top level John W. Eaton <jwe@octave.org> parents: 20560 diff changeset	1036
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1037 void
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1038 tree_evaluator::visit_do_until_command (tree_do_until_command& cmd)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1039 {
21211 2cf8bc5c7017 use "#if defined (HAVE_FOO)" instead of "#if HAVE_FOO" for feature tests John W. Eaton <jwe@octave.org> parents: 21200 diff changeset	1040 #if defined (HAVE_LLVM)
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1041 if (tree_jit::execute (cmd))
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1042 return;
15023 75d1bc2fd6d2 Compile top level while loops in JIT. Max Brister <max@2bass.com> parents: 14932 diff changeset	1043 #endif
75d1bc2fd6d2 Compile top level while loops in JIT. Max Brister <max@2bass.com> parents: 14932 diff changeset	1044
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1045 octave::unwind_protect frame;
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	1046
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1047 frame.protect_var (in_loop_command);
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	1048
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1049 in_loop_command = true;
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	1050
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1051 tree_expression *expr = cmd.condition ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1052 int until_line = cmd.line ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1053 int until_column = cmd.column ();
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	1054
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1055 if (! expr)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1056 panic_impossible ();
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	1057
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1058 for (;;)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1059 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1060 tree_statement_list *loop_body = cmd.body ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1061
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1062 if (loop_body)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1063 loop_body->accept (*this);
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	1064
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1065 if (quit_loop_now ())
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1066 break;
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	1067
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1068 if (debug_mode)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1069 do_breakpoint (cmd.is_breakpoint (true));
18325 2a8243d8327a jit compiler: Add support for the do_until statement LYH <lyh.kernel@gmail.com> parents: 18270 diff changeset	1070
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1071 octave_call_stack::set_location (until_line, until_column);
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	1072
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1073 if (expr->is_logically_true ("do-until"))
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1074 break;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1075 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1076 }
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	1077
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1078 void
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1079 tree_evaluator::do_breakpoint (tree_statement& stmt) const
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1080 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1081 do_breakpoint (stmt.is_breakpoint (true), stmt.is_end_of_fcn_or_script ());
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1082 }
8845 5a6db6bd1a02 eigs.cc (Feigs): fix handling of sigma arg John W. Eaton <jwe@octave.org> parents: 8679 diff changeset	1083
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1084 void
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1085 tree_evaluator::do_breakpoint (bool is_breakpoint,
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1086 bool is_end_of_fcn_or_script) const
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1087 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1088 bool break_on_this_statement = false;
21542 7ba48ff6ce83 Record correct line number with "until" command (bug #43249) Lachlan Andrew <lachlanbis@gmail.com> parents: 21301 diff changeset	1089
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1090 if (octave_debug_on_interrupt_state)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1091 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1092 break_on_this_statement = true;
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	1093
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1094 octave_debug_on_interrupt_state = false;
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	1095
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1096 current_frame = octave_call_stack::current_frame ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1097 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1098 else if (is_breakpoint)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1099 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1100 break_on_this_statement = true;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1101
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1102 dbstep_flag = 0;
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	1103
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1104 current_frame = octave_call_stack::current_frame ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1105 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1106 else if (dbstep_flag > 0)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1107 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1108 if (octave_call_stack::current_frame () == current_frame)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1109 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1110 if (dbstep_flag == 1 \|\| is_end_of_fcn_or_script)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1111 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1112 // We get here if we are doing a "dbstep" or a "dbstep N" and the
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1113 // count has reached 1 so that we must stop and return to debug
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1114 // prompt. Alternatively, "dbstep N" has been used but the end
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1115 // of the frame has been reached so we stop at the last line and
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1116 // return to prompt.
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	1117
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1118 break_on_this_statement = true;
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	1119
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1120 dbstep_flag = 0;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1121 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1122 else
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1123 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1124 // Executing "dbstep N". Decrease N by one and continue.
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1125
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1126 dbstep_flag--;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1127 }
15574 d20cbfec6df7 Fix off-by-1 error when executing 'dbstep N' Rik <rik@octave.org> parents: 15469 diff changeset	1128
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1129 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1130 else if (dbstep_flag == 1
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1131 && octave_call_stack::current_frame () < current_frame)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1132 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1133 // We stepped out from the end of a function.
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	1134
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1135 current_frame = octave_call_stack::current_frame ();
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	1136
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1137 break_on_this_statement = true;
15574 d20cbfec6df7 Fix off-by-1 error when executing 'dbstep N' Rik <rik@octave.org> parents: 15469 diff changeset	1138
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1139 dbstep_flag = 0;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1140 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1141 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1142 else if (dbstep_flag == -1)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1143 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1144 // We get here if we are doing a "dbstep in".
16396 c6a13c1900fc make "dbstep out" and "dbstep" after "dbstep in" work properly John W. Eaton <jwe@octave.org> parents: 16354 diff changeset	1145
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1146 break_on_this_statement = true;
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	1147
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1148 dbstep_flag = 0;
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	1149
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1150 current_frame = octave_call_stack::current_frame ();
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1151 }
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1152 else if (dbstep_flag == -2)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1153 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1154 // We get here if we are doing a "dbstep out". Check for end of
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1155 // function and whether the current frame is the same as the
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1156 // cached value because we want to step out from the frame where
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1157 // "dbstep out" was evaluated, not from any functions called from
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1158 // that frame.
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1159
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1160 if (is_end_of_fcn_or_script
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1161 && octave_call_stack::current_frame () == current_frame)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1162 dbstep_flag = -1;
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1163 }
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	1164
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1165 if (break_on_this_statement)
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1166 do_keyboard ();
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	1167
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1168 }
10219 979fb2606c4f new tree_evaluator::do_keyoard function Ryan Rusaw <rrusaw@gmail.com> parents: 10210 diff changeset	1169
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1170 // ARGS is currently unused, but since the do_keyboard function in
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1171 // input.cc accepts an argument list, we preserve it here so that the
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1172 // interface won't have to change if we decide to use it in the future.
10219 979fb2606c4f new tree_evaluator::do_keyoard function Ryan Rusaw <rrusaw@gmail.com> parents: 10210 diff changeset	1173
22196 dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1174 octave_value
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1175 tree_evaluator::do_keyboard (const octave_value_list& args) const
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1176 {
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1177 return ::do_keyboard (args);
dd992fd74fce put parser, lexer, and evaluator in namespace; interpreter now owns evaluator John W. Eaton <jwe@octave.org> parents: 22164 diff changeset	1178 }
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	1179 }
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	1180
10578 cb0883127251 limit on recursion via calls to source function John W. Eaton <jwe@octave.org> parents: 10315 diff changeset	1181 DEFUN (max_recursion_depth, args, nargout,
21966 112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21922 diff changeset	1182 doc: /* -- texinfo --
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21922 diff changeset	1183 @deftypefn {} {@var{val} =} max_recursion_depth ()
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21922 diff changeset	1184 @deftypefnx {} {@var{old_val} =} max_recursion_depth (@var{new_val})
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21922 diff changeset	1185 @deftypefnx {} {} max_recursion_depth (@var{new_val}, "local")
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21922 diff changeset	1186 Query or set the internal limit on the number of times a function may
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21922 diff changeset	1187 be called recursively.
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21922 diff changeset	1188
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21922 diff changeset	1189 If the limit is exceeded, an error message is printed and control returns to
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21922 diff changeset	1190 the top level.
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21922 diff changeset	1191
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21922 diff changeset	1192 When called from inside a function with the @qcode{"local"} option, the
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21922 diff changeset	1193 variable is changed locally for the function and any subroutines it calls.
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21922 diff changeset	1194 The original variable value is restored when exiting the function.
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21922 diff changeset	1195 @end deftypefn */)
10578 cb0883127251 limit on recursion via calls to source function John W. Eaton <jwe@octave.org> parents: 10315 diff changeset	1196 {
cb0883127251 limit on recursion via calls to source function John W. Eaton <jwe@octave.org> parents: 10315 diff changeset	1197 return SET_INTERNAL_VARIABLE (max_recursion_depth);
cb0883127251 limit on recursion via calls to source function John W. Eaton <jwe@octave.org> parents: 10315 diff changeset	1198 }
cb0883127251 limit on recursion via calls to source function John W. Eaton <jwe@octave.org> parents: 10315 diff changeset	1199
12833 9f0f2c226053 codesprint: new tests for functions in pt-eval.cc John W. Eaton <jwe@octave.org> parents: 11586 diff changeset	1200 /*
9f0f2c226053 codesprint: new tests for functions in pt-eval.cc John W. Eaton <jwe@octave.org> parents: 11586 diff changeset	1201 %!test
9f0f2c226053 codesprint: new tests for functions in pt-eval.cc John W. Eaton <jwe@octave.org> parents: 11586 diff changeset	1202 %! orig_val = max_recursion_depth ();
9f0f2c226053 codesprint: new tests for functions in pt-eval.cc John W. Eaton <jwe@octave.org> parents: 11586 diff changeset	1203 %! old_val = max_recursion_depth (2*orig_val);
9f0f2c226053 codesprint: new tests for functions in pt-eval.cc John W. Eaton <jwe@octave.org> parents: 11586 diff changeset	1204 %! assert (orig_val, old_val);
9f0f2c226053 codesprint: new tests for functions in pt-eval.cc John W. Eaton <jwe@octave.org> parents: 11586 diff changeset	1205 %! assert (max_recursion_depth (), 2*orig_val);
9f0f2c226053 codesprint: new tests for functions in pt-eval.cc John W. Eaton <jwe@octave.org> parents: 11586 diff changeset	1206 %! max_recursion_depth (orig_val);
9f0f2c226053 codesprint: new tests for functions in pt-eval.cc John W. Eaton <jwe@octave.org> parents: 11586 diff changeset	1207 %! assert (max_recursion_depth (), orig_val);
14429 eff4a5933e28 Update %!tests in src/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14294 diff changeset	1208
eff4a5933e28 Update %!tests in src/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14294 diff changeset	1209 %!error (max_recursion_depth (1, 2))
12833 9f0f2c226053 codesprint: new tests for functions in pt-eval.cc John W. Eaton <jwe@octave.org> parents: 11586 diff changeset	1210 */
9f0f2c226053 codesprint: new tests for functions in pt-eval.cc John W. Eaton <jwe@octave.org> parents: 11586 diff changeset	1211
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	1212 DEFUN (silent_functions, args, nargout,
21966 112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21922 diff changeset	1213 doc: /* -- texinfo --
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21922 diff changeset	1214 @deftypefn {} {@var{val} =} silent_functions ()
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21922 diff changeset	1215 @deftypefnx {} {@var{old_val} =} silent_functions (@var{new_val})
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21922 diff changeset	1216 @deftypefnx {} {} silent_functions (@var{new_val}, "local")
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21922 diff changeset	1217 Query or set the internal variable that controls whether internal
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21922 diff changeset	1218 output from a function is suppressed.
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21922 diff changeset	1219
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21922 diff changeset	1220 If this option is disabled, Octave will display the results produced by
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21922 diff changeset	1221 evaluating expressions within a function body that are not terminated with
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21922 diff changeset	1222 a semicolon.
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21922 diff changeset	1223
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21922 diff changeset	1224 When called from inside a function with the @qcode{"local"} option, the
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21922 diff changeset	1225 variable is changed locally for the function and any subroutines it calls.
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21922 diff changeset	1226 The original variable value is restored when exiting the function.
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21922 diff changeset	1227 @end deftypefn */)
8658 73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	1228 {
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	1229 return SET_INTERNAL_VARIABLE (silent_functions);
73c4516fae10 New evaluator and debugger derived from tree-walker class John W. Eaton <jwe@octave.org> parents: diff changeset	1230 }
12833 9f0f2c226053 codesprint: new tests for functions in pt-eval.cc John W. Eaton <jwe@octave.org> parents: 11586 diff changeset	1231
9f0f2c226053 codesprint: new tests for functions in pt-eval.cc John W. Eaton <jwe@octave.org> parents: 11586 diff changeset	1232 /*
9f0f2c226053 codesprint: new tests for functions in pt-eval.cc John W. Eaton <jwe@octave.org> parents: 11586 diff changeset	1233 %!test
9f0f2c226053 codesprint: new tests for functions in pt-eval.cc John W. Eaton <jwe@octave.org> parents: 11586 diff changeset	1234 %! orig_val = silent_functions ();
9f0f2c226053 codesprint: new tests for functions in pt-eval.cc John W. Eaton <jwe@octave.org> parents: 11586 diff changeset	1235 %! old_val = silent_functions (! orig_val);
9f0f2c226053 codesprint: new tests for functions in pt-eval.cc John W. Eaton <jwe@octave.org> parents: 11586 diff changeset	1236 %! assert (orig_val, old_val);
9f0f2c226053 codesprint: new tests for functions in pt-eval.cc John W. Eaton <jwe@octave.org> parents: 11586 diff changeset	1237 %! assert (silent_functions (), ! orig_val);
9f0f2c226053 codesprint: new tests for functions in pt-eval.cc John W. Eaton <jwe@octave.org> parents: 11586 diff changeset	1238 %! silent_functions (orig_val);
9f0f2c226053 codesprint: new tests for functions in pt-eval.cc John W. Eaton <jwe@octave.org> parents: 11586 diff changeset	1239 %! assert (silent_functions (), orig_val);
14429 eff4a5933e28 Update %!tests in src/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14294 diff changeset	1240
eff4a5933e28 Update %!tests in src/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14294 diff changeset	1241 %!error (silent_functions (1, 2))
12833 9f0f2c226053 codesprint: new tests for functions in pt-eval.cc John W. Eaton <jwe@octave.org> parents: 11586 diff changeset	1242 */

Mercurial > octave

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