Mercurial > octave
annotate libinterp/parse-tree/pt-eval.h @ 27957:c20b7290c778
merge stable to default.
author | John W. Eaton <jwe@octave.org> |
---|---|
date | Fri, 17 Jan 2020 13:27:27 -0600 |
parents | b018f553fd85 2310164737b3 |
children | 3241ede9806c |
rev | line source |
---|---|
27923
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
1 //////////////////////////////////////////////////////////////////////// |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
2 // |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
3 // Copyright (C) 2009-2020 The Octave Project Developers |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
4 // |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
5 // See the file COPYRIGHT.md in the top-level directory of this |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
6 // distribution or <https://octave.org/copyright/>. |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
7 // |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
8 // This file is part of Octave. |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
9 // |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
10 // Octave is free software: you can redistribute it and/or modify it |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
11 // under the terms of the GNU General Public License as published by |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
12 // the Free Software Foundation, either version 3 of the License, or |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
13 // (at your option) any later version. |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
14 // |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
15 // Octave is distributed in the hope that it will be useful, but |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
16 // WITHOUT ANY WARRANTY; without even the implied warranty of |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
17 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
18 // GNU General Public License for more details. |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
19 // |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
20 // You should have received a copy of the GNU General Public License |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
21 // along with Octave; see the file COPYING. If not, see |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
22 // <https://www.gnu.org/licenses/>. |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
23 // |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
24 //////////////////////////////////////////////////////////////////////// |
8658
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
diff
changeset
|
25 |
20791
f7084eae3318
maint: Use Octave coding conventions for #if statements.
Rik <rik@octave.org>
parents:
20535
diff
changeset
|
26 #if ! defined (octave_pt_eval_h) |
17822
ebb3ef964372
maint: Use common #define syntax "octave_filename_h" in h_files.
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
27 #define octave_pt_eval_h 1 |
8658
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
diff
changeset
|
28 |
21244
1473547f50f5
include octave-config.h in public header files
John W. Eaton <jwe@octave.org>
parents:
20940
diff
changeset
|
29 #include "octave-config.h" |
1473547f50f5
include octave-config.h in public header files
John W. Eaton <jwe@octave.org>
parents:
20940
diff
changeset
|
30 |
27205
6648d1ae05fe
eliminate direct access to call stack in debug functions
John W. Eaton <jwe@octave.org>
parents:
27204
diff
changeset
|
31 #include <iosfwd> |
23435
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
32 #include <list> |
27519
804e5d42b728
move reader and parser from evaluator repl to interpreter main_loop
John W. Eaton <jwe@octave.org>
parents:
27507
diff
changeset
|
33 #include <memory> |
23723
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
34 #include <set> |
8658
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
diff
changeset
|
35 #include <stack> |
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
diff
changeset
|
36 #include <string> |
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
diff
changeset
|
37 |
25360
bc5f225bc578
eliminate some global accesses to the breakpoint table
John W. Eaton <jwe@octave.org>
parents:
25317
diff
changeset
|
38 #include "bp-table.h" |
23553
14723784b9f2
don't use singleton for call_stack
John W. Eaton <jwe@octave.org>
parents:
23532
diff
changeset
|
39 #include "call-stack.h" |
27371
fcaecdbc8d8a
don't use visitor pattern for expression evaluation (bug #56752)
John W. Eaton <jwe@octave.org>
parents:
27370
diff
changeset
|
40 #include "oct-lvalue.h" |
24563
8f2c479eb125
eliminate unnecessary value stack in evaluator
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
41 #include "ov.h" |
20940
48b2ad5ee801
maint: Rename oct-obj.[cc|h] to ovl.[cc|h] for clarity.
Rik <rik@octave.org>
parents:
20824
diff
changeset
|
42 #include "ovl.h" |
23753
c3828bd031cd
move profiler inside evaluator and inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23750
diff
changeset
|
43 #include "profiler.h" |
8658
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
diff
changeset
|
44 #include "pt-walk.h" |
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
diff
changeset
|
45 |
25360
bc5f225bc578
eliminate some global accesses to the breakpoint table
John W. Eaton <jwe@octave.org>
parents:
25317
diff
changeset
|
46 class octave_user_code; |
bc5f225bc578
eliminate some global accesses to the breakpoint table
John W. Eaton <jwe@octave.org>
parents:
25317
diff
changeset
|
47 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21244
diff
changeset
|
48 namespace octave |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21244
diff
changeset
|
49 { |
27203
79065f9d5553
eliminate direct access to call stack in load-save functions
John W. Eaton <jwe@octave.org>
parents:
27202
diff
changeset
|
50 class symbol_info_list; |
24362
3fc24b792a24
avoid including symtab.h, symscope.h, or symrec.h unnecessarily
John W. Eaton <jwe@octave.org>
parents:
24361
diff
changeset
|
51 class symbol_scope; |
23435
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
52 class tree_decl_elt; |
23075
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
53 class tree_expression; |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
54 |
27037
8408acb7ca4f
make dbup/dbdown work again (bug #56020)
John W. Eaton <jwe@octave.org>
parents:
27019
diff
changeset
|
55 class debugger; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21244
diff
changeset
|
56 class interpreter; |
23723
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
57 class unwind_protect; |
8658
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
diff
changeset
|
58 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21244
diff
changeset
|
59 // How to evaluate the code that the parse trees represent. |
8658
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
diff
changeset
|
60 |
23075
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
61 class OCTINTERP_API tree_evaluator : public tree_walker |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21244
diff
changeset
|
62 { |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21244
diff
changeset
|
63 public: |
8658
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
diff
changeset
|
64 |
23723
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
65 enum echo_state |
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
66 { |
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
67 ECHO_OFF = 0, |
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
68 ECHO_SCRIPTS = 1, |
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
69 ECHO_FUNCTIONS = 2, |
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
70 ECHO_ALL = 4 |
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
71 }; |
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
72 |
23435
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
73 template <typename T> |
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
74 class value_stack |
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
75 { |
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
76 public: |
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
77 |
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
78 value_stack (void) = default; |
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
79 |
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
80 value_stack (const value_stack&) = default; |
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
81 |
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
82 value_stack& operator = (const value_stack&) = default; |
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
83 |
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
84 ~value_stack (void) = default; |
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
85 |
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
86 void push (const T& val) { m_stack.push (val); } |
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
87 |
23481
73558a835b64
eliminate lvalue list arguments from evaluator functions
John W. Eaton <jwe@octave.org>
parents:
23469
diff
changeset
|
88 void pop (void) |
73558a835b64
eliminate lvalue list arguments from evaluator functions
John W. Eaton <jwe@octave.org>
parents:
23469
diff
changeset
|
89 { |
73558a835b64
eliminate lvalue list arguments from evaluator functions
John W. Eaton <jwe@octave.org>
parents:
23469
diff
changeset
|
90 m_stack.pop (); |
73558a835b64
eliminate lvalue list arguments from evaluator functions
John W. Eaton <jwe@octave.org>
parents:
23469
diff
changeset
|
91 } |
73558a835b64
eliminate lvalue list arguments from evaluator functions
John W. Eaton <jwe@octave.org>
parents:
23469
diff
changeset
|
92 |
73558a835b64
eliminate lvalue list arguments from evaluator functions
John W. Eaton <jwe@octave.org>
parents:
23469
diff
changeset
|
93 T val_pop (void) |
23435
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
94 { |
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
95 T retval = m_stack.top (); |
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
96 m_stack.pop (); |
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
97 return retval; |
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
98 } |
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
99 |
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
100 T top (void) const |
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
101 { |
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
102 return m_stack.top (); |
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
103 } |
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
104 |
23481
73558a835b64
eliminate lvalue list arguments from evaluator functions
John W. Eaton <jwe@octave.org>
parents:
23469
diff
changeset
|
105 size_t size (void) const |
73558a835b64
eliminate lvalue list arguments from evaluator functions
John W. Eaton <jwe@octave.org>
parents:
23469
diff
changeset
|
106 { |
73558a835b64
eliminate lvalue list arguments from evaluator functions
John W. Eaton <jwe@octave.org>
parents:
23469
diff
changeset
|
107 return m_stack.size (); |
73558a835b64
eliminate lvalue list arguments from evaluator functions
John W. Eaton <jwe@octave.org>
parents:
23469
diff
changeset
|
108 } |
73558a835b64
eliminate lvalue list arguments from evaluator functions
John W. Eaton <jwe@octave.org>
parents:
23469
diff
changeset
|
109 |
73558a835b64
eliminate lvalue list arguments from evaluator functions
John W. Eaton <jwe@octave.org>
parents:
23469
diff
changeset
|
110 bool empty (void) const |
73558a835b64
eliminate lvalue list arguments from evaluator functions
John W. Eaton <jwe@octave.org>
parents:
23469
diff
changeset
|
111 { |
73558a835b64
eliminate lvalue list arguments from evaluator functions
John W. Eaton <jwe@octave.org>
parents:
23469
diff
changeset
|
112 return m_stack.empty (); |
73558a835b64
eliminate lvalue list arguments from evaluator functions
John W. Eaton <jwe@octave.org>
parents:
23469
diff
changeset
|
113 } |
73558a835b64
eliminate lvalue list arguments from evaluator functions
John W. Eaton <jwe@octave.org>
parents:
23469
diff
changeset
|
114 |
23435
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
115 void clear (void) |
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
116 { |
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
117 while (! m_stack.empty ()) |
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
118 m_stack.pop (); |
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
119 } |
23458
0f4ed33886de
maint: Strip trailing whitespace from source files.
John W. Eaton <jwe@octave.org>
parents:
23457
diff
changeset
|
120 |
23435
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
121 private: |
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
122 |
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
123 std::stack<T> m_stack; |
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
124 }; |
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
125 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21244
diff
changeset
|
126 typedef void (*decl_elt_init_fcn) (tree_decl_elt&); |
8658
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
diff
changeset
|
127 |
23532
084245f9bd03
pass reference to evaluator to octave_function call methods
John W. Eaton <jwe@octave.org>
parents:
23482
diff
changeset
|
128 tree_evaluator (interpreter& interp) |
25401
6f6479125d80
eliminate some globals from tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
25400
diff
changeset
|
129 : m_interpreter (interp), m_statement_context (SC_OTHER), |
27371
fcaecdbc8d8a
don't use visitor pattern for expression evaluation (bug #56752)
John W. Eaton <jwe@octave.org>
parents:
27370
diff
changeset
|
130 m_lvalue_list (nullptr), m_autoload_map (), m_bp_table (*this), |
27037
8408acb7ca4f
make dbup/dbdown work again (bug #56020)
John W. Eaton <jwe@octave.org>
parents:
27019
diff
changeset
|
131 m_call_stack (*this), m_profiler (), m_debug_frame (0), |
27016
9b261300a001
move file-scope static autoload map variable and functions to evaluator
John W. Eaton <jwe@octave.org>
parents:
27015
diff
changeset
|
132 m_debug_mode (false), m_quiet_breakpoint_flag (false), |
27037
8408acb7ca4f
make dbup/dbdown work again (bug #56020)
John W. Eaton <jwe@octave.org>
parents:
27019
diff
changeset
|
133 m_debugger_stack (), m_max_recursion_depth (256), |
26087
7656fcd0ff9f
move whos_line_format to evaluator
John W. Eaton <jwe@octave.org>
parents:
26039
diff
changeset
|
134 m_whos_line_format (" %a:4; %ln:6; %cs:16:6:1; %rb:12; %lc:-1;\n"), |
25377 | 135 m_silent_functions (false), m_string_fill_char (' '), |
136 m_PS4 ("+ "), m_dbstep_flag (0), m_echo (ECHO_OFF), | |
23723
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
137 m_echo_state (false), m_echo_file_name (), m_echo_file_pos (1), |
25382
749d9e858553
move convert_to_const_vector from tree_argument_list to tree_evaluator
John W. Eaton <jwe@octave.org>
parents:
25381
diff
changeset
|
138 m_echo_files (), m_in_loop_command (false), |
25403
2b7d7a3f5f57
move returning, breaking, and continuing flags to evaluator
John W. Eaton <jwe@octave.org>
parents:
25402
diff
changeset
|
139 m_breaking (0), m_continuing (0), m_returning (0), |
26661
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
140 m_indexed_object (nullptr), m_index_position (0), |
27519
804e5d42b728
move reader and parser from evaluator repl to interpreter main_loop
John W. Eaton <jwe@octave.org>
parents:
27507
diff
changeset
|
141 m_num_indices (0) |
23435
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
142 { } |
8658
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
diff
changeset
|
143 |
22869
f75d289645ec
make deleted functions public
John W. Eaton <jwe@octave.org>
parents:
22868
diff
changeset
|
144 // No copying! |
8658
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
diff
changeset
|
145 |
22869
f75d289645ec
make deleted functions public
John W. Eaton <jwe@octave.org>
parents:
22868
diff
changeset
|
146 tree_evaluator (const tree_evaluator&) = delete; |
f75d289645ec
make deleted functions public
John W. Eaton <jwe@octave.org>
parents:
22868
diff
changeset
|
147 |
f75d289645ec
make deleted functions public
John W. Eaton <jwe@octave.org>
parents:
22868
diff
changeset
|
148 tree_evaluator& operator = (const tree_evaluator&) = delete; |
f75d289645ec
make deleted functions public
John W. Eaton <jwe@octave.org>
parents:
22868
diff
changeset
|
149 |
22868
87e3163f6c87
use c++11 "= default" syntax for declaration of trivial destructors
John W. Eaton <jwe@octave.org>
parents:
22865
diff
changeset
|
150 ~tree_evaluator (void) = default; |
8658
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
diff
changeset
|
151 |
26661
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
152 bool at_top_level (void) const; |
23435
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
153 |
27519
804e5d42b728
move reader and parser from evaluator repl to interpreter main_loop
John W. Eaton <jwe@octave.org>
parents:
27507
diff
changeset
|
154 void eval (std::shared_ptr<tree_statement_list>& stmt_list, |
804e5d42b728
move reader and parser from evaluator repl to interpreter main_loop
John W. Eaton <jwe@octave.org>
parents:
27507
diff
changeset
|
155 bool interactive); |
25404
e37d857716c3
move core of interpreter::main_loop to evaluator
John W. Eaton <jwe@octave.org>
parents:
25403
diff
changeset
|
156 |
27015
4d9e1a832a55
move core of mfilename function to evaluator
John W. Eaton <jwe@octave.org>
parents:
27014
diff
changeset
|
157 std::string mfilename (const std::string& opt = "") const; |
25404
e37d857716c3
move core of interpreter::main_loop to evaluator
John W. Eaton <jwe@octave.org>
parents:
25403
diff
changeset
|
158 |
26113
8a15f3bace49
move eval_string inside interpreter/evaluator class
John W. Eaton <jwe@octave.org>
parents:
26094
diff
changeset
|
159 octave_value_list eval_string (const std::string& eval_str, bool silent, |
8a15f3bace49
move eval_string inside interpreter/evaluator class
John W. Eaton <jwe@octave.org>
parents:
26094
diff
changeset
|
160 int& parse_status, int nargout); |
8a15f3bace49
move eval_string inside interpreter/evaluator class
John W. Eaton <jwe@octave.org>
parents:
26094
diff
changeset
|
161 |
8a15f3bace49
move eval_string inside interpreter/evaluator class
John W. Eaton <jwe@octave.org>
parents:
26094
diff
changeset
|
162 octave_value eval_string (const std::string& eval_str, bool silent, |
8a15f3bace49
move eval_string inside interpreter/evaluator class
John W. Eaton <jwe@octave.org>
parents:
26094
diff
changeset
|
163 int& parse_status); |
8a15f3bace49
move eval_string inside interpreter/evaluator class
John W. Eaton <jwe@octave.org>
parents:
26094
diff
changeset
|
164 |
8a15f3bace49
move eval_string inside interpreter/evaluator class
John W. Eaton <jwe@octave.org>
parents:
26094
diff
changeset
|
165 octave_value_list eval_string (const octave_value& arg, bool silent, |
8a15f3bace49
move eval_string inside interpreter/evaluator class
John W. Eaton <jwe@octave.org>
parents:
26094
diff
changeset
|
166 int& parse_status, int nargout); |
8a15f3bace49
move eval_string inside interpreter/evaluator class
John W. Eaton <jwe@octave.org>
parents:
26094
diff
changeset
|
167 |
27019
6cb675912f2b
move core of eval function to evaluator
John W. Eaton <jwe@octave.org>
parents:
27018
diff
changeset
|
168 octave_value_list eval (const std::string& try_code, int nargout); |
6cb675912f2b
move core of eval function to evaluator
John W. Eaton <jwe@octave.org>
parents:
27018
diff
changeset
|
169 |
6cb675912f2b
move core of eval function to evaluator
John W. Eaton <jwe@octave.org>
parents:
27018
diff
changeset
|
170 octave_value_list eval (const std::string& try_code, |
6cb675912f2b
move core of eval function to evaluator
John W. Eaton <jwe@octave.org>
parents:
27018
diff
changeset
|
171 const std::string& catch_code, int nargout); |
6cb675912f2b
move core of eval function to evaluator
John W. Eaton <jwe@octave.org>
parents:
27018
diff
changeset
|
172 |
27018
a20ead51515d
move core of evalin function to evaluator
John W. Eaton <jwe@octave.org>
parents:
27017
diff
changeset
|
173 octave_value_list evalin (const std::string& context, |
a20ead51515d
move core of evalin function to evaluator
John W. Eaton <jwe@octave.org>
parents:
27017
diff
changeset
|
174 const std::string& try_code, int nargout); |
a20ead51515d
move core of evalin function to evaluator
John W. Eaton <jwe@octave.org>
parents:
27017
diff
changeset
|
175 |
a20ead51515d
move core of evalin function to evaluator
John W. Eaton <jwe@octave.org>
parents:
27017
diff
changeset
|
176 octave_value_list evalin (const std::string& context, |
a20ead51515d
move core of evalin function to evaluator
John W. Eaton <jwe@octave.org>
parents:
27017
diff
changeset
|
177 const std::string& try_code, |
a20ead51515d
move core of evalin function to evaluator
John W. Eaton <jwe@octave.org>
parents:
27017
diff
changeset
|
178 const std::string& catch_code, int nargout); |
a20ead51515d
move core of evalin function to evaluator
John W. Eaton <jwe@octave.org>
parents:
27017
diff
changeset
|
179 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21244
diff
changeset
|
180 void visit_anon_fcn_handle (tree_anon_fcn_handle&); |
8658
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
diff
changeset
|
181 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21244
diff
changeset
|
182 void visit_argument_list (tree_argument_list&); |
8658
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
diff
changeset
|
183 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21244
diff
changeset
|
184 void visit_binary_expression (tree_binary_expression&); |
8658
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
diff
changeset
|
185 |
23435
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
186 void visit_boolean_expression (tree_boolean_expression&); |
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
187 |
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
188 void visit_compound_binary_expression (tree_compound_binary_expression&); |
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
189 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21244
diff
changeset
|
190 void visit_break_command (tree_break_command&); |
8658
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
diff
changeset
|
191 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21244
diff
changeset
|
192 void visit_colon_expression (tree_colon_expression&); |
8658
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
diff
changeset
|
193 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21244
diff
changeset
|
194 void visit_continue_command (tree_continue_command&); |
8658
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
diff
changeset
|
195 |
23469
2699c5974844
handle global and persistent in tree_decl_command, not as separate classes
John W. Eaton <jwe@octave.org>
parents:
23458
diff
changeset
|
196 void visit_decl_command (tree_decl_command&); |
8658
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
diff
changeset
|
197 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21244
diff
changeset
|
198 void visit_decl_elt (tree_decl_elt&); |
8658
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
diff
changeset
|
199 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21244
diff
changeset
|
200 void visit_simple_for_command (tree_simple_for_command&); |
8658
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
diff
changeset
|
201 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21244
diff
changeset
|
202 void visit_complex_for_command (tree_complex_for_command&); |
8658
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
diff
changeset
|
203 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21244
diff
changeset
|
204 void visit_octave_user_script (octave_user_script&); |
8658
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
diff
changeset
|
205 |
25400
d423ce60f5c8
evaluate script and function code in tree_evaluator methods
John W. Eaton <jwe@octave.org>
parents:
25382
diff
changeset
|
206 octave_value_list |
d423ce60f5c8
evaluate script and function code in tree_evaluator methods
John W. Eaton <jwe@octave.org>
parents:
25382
diff
changeset
|
207 execute_user_script (octave_user_script& user_script, int nargout, |
d423ce60f5c8
evaluate script and function code in tree_evaluator methods
John W. Eaton <jwe@octave.org>
parents:
25382
diff
changeset
|
208 const octave_value_list& args); |
d423ce60f5c8
evaluate script and function code in tree_evaluator methods
John W. Eaton <jwe@octave.org>
parents:
25382
diff
changeset
|
209 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21244
diff
changeset
|
210 void visit_octave_user_function (octave_user_function&); |
8658
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
diff
changeset
|
211 |
25400
d423ce60f5c8
evaluate script and function code in tree_evaluator methods
John W. Eaton <jwe@octave.org>
parents:
25382
diff
changeset
|
212 octave_value_list |
26825
6e9034836239
allow handles to nested functions to work (bug #39257)
John W. Eaton <jwe@octave.org>
parents:
26686
diff
changeset
|
213 execute_user_function (octave_user_function& user_function, |
6e9034836239
allow handles to nested functions to work (bug #39257)
John W. Eaton <jwe@octave.org>
parents:
26686
diff
changeset
|
214 int nargout, const octave_value_list& args, |
6e9034836239
allow handles to nested functions to work (bug #39257)
John W. Eaton <jwe@octave.org>
parents:
26686
diff
changeset
|
215 stack_frame *closure_frames = nullptr); |
25400
d423ce60f5c8
evaluate script and function code in tree_evaluator methods
John W. Eaton <jwe@octave.org>
parents:
25382
diff
changeset
|
216 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21244
diff
changeset
|
217 void visit_octave_user_function_header (octave_user_function&); |
8658
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
diff
changeset
|
218 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21244
diff
changeset
|
219 void visit_octave_user_function_trailer (octave_user_function&); |
8658
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
diff
changeset
|
220 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21244
diff
changeset
|
221 void visit_function_def (tree_function_def&); |
8658
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
diff
changeset
|
222 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21244
diff
changeset
|
223 void visit_identifier (tree_identifier&); |
8658
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
diff
changeset
|
224 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21244
diff
changeset
|
225 void visit_if_clause (tree_if_clause&); |
8658
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
diff
changeset
|
226 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21244
diff
changeset
|
227 void visit_if_command (tree_if_command&); |
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:
21244
diff
changeset
|
229 void visit_if_command_list (tree_if_command_list&); |
8658
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
diff
changeset
|
230 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21244
diff
changeset
|
231 void visit_index_expression (tree_index_expression&); |
8658
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
diff
changeset
|
232 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21244
diff
changeset
|
233 void visit_matrix (tree_matrix&); |
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:
21244
diff
changeset
|
235 void visit_cell (tree_cell&); |
8658
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
diff
changeset
|
236 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21244
diff
changeset
|
237 void visit_multi_assignment (tree_multi_assignment&); |
8658
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
diff
changeset
|
238 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21244
diff
changeset
|
239 void visit_no_op_command (tree_no_op_command&); |
8658
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
diff
changeset
|
240 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21244
diff
changeset
|
241 void visit_constant (tree_constant&); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21244
diff
changeset
|
242 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21244
diff
changeset
|
243 void visit_fcn_handle (tree_fcn_handle&); |
15035 | 244 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21244
diff
changeset
|
245 void visit_parameter_list (tree_parameter_list&); |
8658
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
diff
changeset
|
246 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21244
diff
changeset
|
247 void visit_postfix_expression (tree_postfix_expression&); |
8658
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
diff
changeset
|
248 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21244
diff
changeset
|
249 void visit_prefix_expression (tree_prefix_expression&); |
8658
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
diff
changeset
|
250 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21244
diff
changeset
|
251 void visit_return_command (tree_return_command&); |
8658
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
diff
changeset
|
252 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21244
diff
changeset
|
253 void visit_return_list (tree_return_list&); |
8658
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
diff
changeset
|
254 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21244
diff
changeset
|
255 void 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:
21244
diff
changeset
|
256 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21244
diff
changeset
|
257 void visit_statement (tree_statement&); |
8658
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
diff
changeset
|
258 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21244
diff
changeset
|
259 void visit_statement_list (tree_statement_list&); |
8658
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
diff
changeset
|
260 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21244
diff
changeset
|
261 void visit_switch_case (tree_switch_case&); |
8658
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:
21244
diff
changeset
|
263 void visit_switch_case_list (tree_switch_case_list&); |
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:
21244
diff
changeset
|
265 void visit_switch_command (tree_switch_command&); |
8658
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
diff
changeset
|
266 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21244
diff
changeset
|
267 void visit_try_catch_command (tree_try_catch_command&); |
8658
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
diff
changeset
|
268 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21244
diff
changeset
|
269 void do_unwind_protect_cleanup_code (tree_statement_list *list); |
10066
2cd940306a06
make unwind_protect frames local
Jaroslav Hajek <highegg@gmail.com>
parents:
9484
diff
changeset
|
270 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21244
diff
changeset
|
271 void visit_unwind_protect_command (tree_unwind_protect_command&); |
8658
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
diff
changeset
|
272 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21244
diff
changeset
|
273 void visit_while_command (tree_while_command&); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21244
diff
changeset
|
274 void visit_do_until_command (tree_do_until_command&); |
8658
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
diff
changeset
|
275 |
26686
581d01526b34
eliminate unnecessary tree_funcall class
John W. Eaton <jwe@octave.org>
parents:
26661
diff
changeset
|
276 void visit_superclass_ref (tree_superclass_ref&); |
581d01526b34
eliminate unnecessary tree_funcall class
John W. Eaton <jwe@octave.org>
parents:
26661
diff
changeset
|
277 void visit_metaclass_query (tree_metaclass_query&); |
581d01526b34
eliminate unnecessary tree_funcall class
John W. Eaton <jwe@octave.org>
parents:
26661
diff
changeset
|
278 |
23702
d396b5fd9199
move bind_ans to tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23696
diff
changeset
|
279 void bind_ans (const octave_value& val, bool print); |
d396b5fd9199
move bind_ans to tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23696
diff
changeset
|
280 |
23705
4c597585ff52
move Vmax_recursion_depth and Vsilent_functions to tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23702
diff
changeset
|
281 bool statement_printing_enabled (void); |
10186
095a1e670e68
make dbstep work with keyboard function
John W. Eaton <jwe@octave.org>
parents:
10160
diff
changeset
|
282 |
25360
bc5f225bc578
eliminate some global accesses to the breakpoint table
John W. Eaton <jwe@octave.org>
parents:
25317
diff
changeset
|
283 void reset_debug_state (void); |
15606
fb9dffe5fbfb
The silent_functions flag no longer modifies the parse tree
Max Brister <max@2bass.com>
parents:
15195
diff
changeset
|
284 |
25360
bc5f225bc578
eliminate some global accesses to the breakpoint table
John W. Eaton <jwe@octave.org>
parents:
25317
diff
changeset
|
285 void reset_debug_state (bool mode); |
bc5f225bc578
eliminate some global accesses to the breakpoint table
John W. Eaton <jwe@octave.org>
parents:
25317
diff
changeset
|
286 |
27037
8408acb7ca4f
make dbup/dbdown work again (bug #56020)
John W. Eaton <jwe@octave.org>
parents:
27019
diff
changeset
|
287 void enter_debugger (const std::string& prompt = "debug> "); |
8408acb7ca4f
make dbup/dbdown work again (bug #56020)
John W. Eaton <jwe@octave.org>
parents:
27019
diff
changeset
|
288 |
8408acb7ca4f
make dbup/dbdown work again (bug #56020)
John W. Eaton <jwe@octave.org>
parents:
27019
diff
changeset
|
289 void keyboard (const std::string& prompt = "keyboard> "); |
8408acb7ca4f
make dbup/dbdown work again (bug #56020)
John W. Eaton <jwe@octave.org>
parents:
27019
diff
changeset
|
290 |
8408acb7ca4f
make dbup/dbdown work again (bug #56020)
John W. Eaton <jwe@octave.org>
parents:
27019
diff
changeset
|
291 void dbupdown (int n, bool verbose = false); |
8658
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
diff
changeset
|
292 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21244
diff
changeset
|
293 // Possible types of evaluation contexts. |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21244
diff
changeset
|
294 enum stmt_list_type |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21244
diff
changeset
|
295 { |
25401
6f6479125d80
eliminate some globals from tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
25400
diff
changeset
|
296 SC_FUNCTION, // function body |
6f6479125d80
eliminate some globals from tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
25400
diff
changeset
|
297 SC_SCRIPT, // script file |
6f6479125d80
eliminate some globals from tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
25400
diff
changeset
|
298 SC_OTHER // command-line input or eval string |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21244
diff
changeset
|
299 }; |
11304 | 300 |
23481
73558a835b64
eliminate lvalue list arguments from evaluator functions
John W. Eaton <jwe@octave.org>
parents:
23469
diff
changeset
|
301 Matrix ignored_fcn_outputs (void) const; |
73558a835b64
eliminate lvalue list arguments from evaluator functions
John W. Eaton <jwe@octave.org>
parents:
23469
diff
changeset
|
302 |
23435
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
303 octave_value evaluate (tree_decl_elt *); |
24349
4ced2bfd737e
deprecate defun_isargout functions
John W. Eaton <jwe@octave.org>
parents:
24270
diff
changeset
|
304 |
26661
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
305 void install_variable (const std::string& name, |
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
306 const octave_value& value, bool global); |
24349
4ced2bfd737e
deprecate defun_isargout functions
John W. Eaton <jwe@octave.org>
parents:
24270
diff
changeset
|
307 |
26661
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
308 octave_value global_varval (const std::string& name) const; |
23481
73558a835b64
eliminate lvalue list arguments from evaluator functions
John W. Eaton <jwe@octave.org>
parents:
23469
diff
changeset
|
309 |
27211
8c27802a76c4
store reference to evaluator instead of call stack in stack frame
John W. Eaton <jwe@octave.org>
parents:
27210
diff
changeset
|
310 octave_value& global_varref (const std::string& name); |
8c27802a76c4
store reference to evaluator instead of call stack in stack frame
John W. Eaton <jwe@octave.org>
parents:
27210
diff
changeset
|
311 |
26661
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
312 void global_assign (const std::string& name, |
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
313 const octave_value& val = octave_value ()); |
24563
8f2c479eb125
eliminate unnecessary value stack in evaluator
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
314 |
26661
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
315 octave_value top_level_varval (const std::string& name) const; |
24563
8f2c479eb125
eliminate unnecessary value stack in evaluator
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
316 |
26661
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
317 void top_level_assign (const std::string& name, |
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
318 const octave_value& val = octave_value ()); |
24563
8f2c479eb125
eliminate unnecessary value stack in evaluator
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
319 |
26661
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
320 bool is_variable (const std::string& name) const; |
23435
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
321 |
26661
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
322 bool is_local_variable (const std::string& name) const; |
23435
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
323 |
26661
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
324 bool is_variable (const tree_expression *expr) const; |
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
325 |
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
326 bool is_defined (const tree_expression *expr) const; |
23435
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
327 |
26661
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
328 bool is_variable (const symbol_record& sym) const; |
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
329 |
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
330 bool is_defined (const symbol_record& sym) const; |
24563
8f2c479eb125
eliminate unnecessary value stack in evaluator
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
331 |
26661
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
332 bool is_global (const std::string& name) const; |
24563
8f2c479eb125
eliminate unnecessary value stack in evaluator
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
333 |
26661
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
334 octave_value varval (const symbol_record& sym) const; |
23435
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
335 |
26661
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
336 octave_value varval (const std::string& name) const; |
23435
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
337 |
26661
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
338 void assign (const std::string& name, |
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
339 const octave_value& val = octave_value ()); |
23435
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
340 |
27014
daab1b311a98
move core of assignin function to evaluator
John W. Eaton <jwe@octave.org>
parents:
27005
diff
changeset
|
341 void assignin (const std::string& context, const std::string& name, |
daab1b311a98
move core of assignin function to evaluator
John W. Eaton <jwe@octave.org>
parents:
27005
diff
changeset
|
342 const octave_value& val = octave_value ()); |
24563
8f2c479eb125
eliminate unnecessary value stack in evaluator
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
343 |
27017
24b7e6326e26
move parse_fcn_file to interpreter; source_file to evaluator
John W. Eaton <jwe@octave.org>
parents:
27016
diff
changeset
|
344 void source_file (const std::string& file_name, |
24b7e6326e26
move parse_fcn_file to interpreter; source_file to evaluator
John W. Eaton <jwe@octave.org>
parents:
27016
diff
changeset
|
345 const std::string& context = "", |
27507
2d537a089e5d
eliminate warn_for argument for source_file and parse_fcn_file functions
John W. Eaton <jwe@octave.org>
parents:
27471
diff
changeset
|
346 bool verbose = false, bool require_file = true); |
24563
8f2c479eb125
eliminate unnecessary value stack in evaluator
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
347 |
26661
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
348 void set_auto_fcn_var (stack_frame::auto_var_type avt, |
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
349 const octave_value& val = octave_value ()); |
24563
8f2c479eb125
eliminate unnecessary value stack in evaluator
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
350 |
26661
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
351 octave_value get_auto_fcn_var (stack_frame::auto_var_type avt) const; |
23435
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
352 |
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
353 void define_parameter_list_from_arg_vector |
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
354 (tree_parameter_list *param_list, const octave_value_list& args); |
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
355 |
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
356 void undefine_parameter_list (tree_parameter_list *param_list); |
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
357 |
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
358 octave_value_list |
25382
749d9e858553
move convert_to_const_vector from tree_argument_list to tree_evaluator
John W. Eaton <jwe@octave.org>
parents:
25381
diff
changeset
|
359 convert_to_const_vector (tree_argument_list *arg_list, |
749d9e858553
move convert_to_const_vector from tree_argument_list to tree_evaluator
John W. Eaton <jwe@octave.org>
parents:
25381
diff
changeset
|
360 const octave_value *object = nullptr); |
749d9e858553
move convert_to_const_vector from tree_argument_list to tree_evaluator
John W. Eaton <jwe@octave.org>
parents:
25381
diff
changeset
|
361 |
749d9e858553
move convert_to_const_vector from tree_argument_list to tree_evaluator
John W. Eaton <jwe@octave.org>
parents:
25381
diff
changeset
|
362 octave_value_list |
23916
85488effc0ff
refactor function value return code
John W. Eaton <jwe@octave.org>
parents:
23795
diff
changeset
|
363 convert_return_list_to_const_vector |
85488effc0ff
refactor function value return code
John W. Eaton <jwe@octave.org>
parents:
23795
diff
changeset
|
364 (tree_parameter_list *ret_list, int nargout, const Cell& varargout); |
23435
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
365 |
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
366 bool eval_decl_elt (tree_decl_elt *elt); |
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
367 |
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
368 bool switch_case_label_matches (tree_switch_case *expr, |
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
369 const octave_value& val); |
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
370 |
25360
bc5f225bc578
eliminate some global accesses to the breakpoint table
John W. Eaton <jwe@octave.org>
parents:
25317
diff
changeset
|
371 interpreter& get_interpreter (void) { return m_interpreter; } |
bc5f225bc578
eliminate some global accesses to the breakpoint table
John W. Eaton <jwe@octave.org>
parents:
25317
diff
changeset
|
372 |
bc5f225bc578
eliminate some global accesses to the breakpoint table
John W. Eaton <jwe@octave.org>
parents:
25317
diff
changeset
|
373 bp_table& get_bp_table (void) { return m_bp_table; } |
bc5f225bc578
eliminate some global accesses to the breakpoint table
John W. Eaton <jwe@octave.org>
parents:
25317
diff
changeset
|
374 |
23753
c3828bd031cd
move profiler inside evaluator and inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23750
diff
changeset
|
375 profiler& get_profiler (void) { return m_profiler; } |
c3828bd031cd
move profiler inside evaluator and inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23750
diff
changeset
|
376 |
23553
14723784b9f2
don't use singleton for call_stack
John W. Eaton <jwe@octave.org>
parents:
23532
diff
changeset
|
377 call_stack& get_call_stack (void) { return m_call_stack; } |
14723784b9f2
don't use singleton for call_stack
John W. Eaton <jwe@octave.org>
parents:
23532
diff
changeset
|
378 |
27210
bd684aad1821
eliminate some direct access to call stack in legacy class and function objects
John W. Eaton <jwe@octave.org>
parents:
27208
diff
changeset
|
379 void push_stack_frame (const symbol_scope& scope); |
bd684aad1821
eliminate some direct access to call stack in legacy class and function objects
John W. Eaton <jwe@octave.org>
parents:
27208
diff
changeset
|
380 |
bd684aad1821
eliminate some direct access to call stack in legacy class and function objects
John W. Eaton <jwe@octave.org>
parents:
27208
diff
changeset
|
381 void push_stack_frame (octave_user_function *fcn, |
bd684aad1821
eliminate some direct access to call stack in legacy class and function objects
John W. Eaton <jwe@octave.org>
parents:
27208
diff
changeset
|
382 unwind_protect *up_frame, |
bd684aad1821
eliminate some direct access to call stack in legacy class and function objects
John W. Eaton <jwe@octave.org>
parents:
27208
diff
changeset
|
383 stack_frame *closure_frames = nullptr); |
bd684aad1821
eliminate some direct access to call stack in legacy class and function objects
John W. Eaton <jwe@octave.org>
parents:
27208
diff
changeset
|
384 |
bd684aad1821
eliminate some direct access to call stack in legacy class and function objects
John W. Eaton <jwe@octave.org>
parents:
27208
diff
changeset
|
385 void push_stack_frame (octave_user_script *script, |
bd684aad1821
eliminate some direct access to call stack in legacy class and function objects
John W. Eaton <jwe@octave.org>
parents:
27208
diff
changeset
|
386 unwind_protect *up_frame); |
bd684aad1821
eliminate some direct access to call stack in legacy class and function objects
John W. Eaton <jwe@octave.org>
parents:
27208
diff
changeset
|
387 |
bd684aad1821
eliminate some direct access to call stack in legacy class and function objects
John W. Eaton <jwe@octave.org>
parents:
27208
diff
changeset
|
388 void push_stack_frame (octave_function *fcn); |
bd684aad1821
eliminate some direct access to call stack in legacy class and function objects
John W. Eaton <jwe@octave.org>
parents:
27208
diff
changeset
|
389 |
bd684aad1821
eliminate some direct access to call stack in legacy class and function objects
John W. Eaton <jwe@octave.org>
parents:
27208
diff
changeset
|
390 void pop_stack_frame (void); |
bd684aad1821
eliminate some direct access to call stack in legacy class and function objects
John W. Eaton <jwe@octave.org>
parents:
27208
diff
changeset
|
391 |
26661
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
392 const stack_frame& get_current_stack_frame (void) const |
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
393 { |
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
394 return m_call_stack.get_current_stack_frame (); |
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
395 } |
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
396 |
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
397 stack_frame& get_current_stack_frame (void) |
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
398 { |
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
399 return m_call_stack.get_current_stack_frame (); |
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
400 } |
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
401 |
27200
dc1edf932248
eliminate direct access to call_stack in input functions
John W. Eaton <jwe@octave.org>
parents:
27199
diff
changeset
|
402 stack_frame * current_user_frame (void) const |
dc1edf932248
eliminate direct access to call_stack in input functions
John W. Eaton <jwe@octave.org>
parents:
27199
diff
changeset
|
403 { |
dc1edf932248
eliminate direct access to call_stack in input functions
John W. Eaton <jwe@octave.org>
parents:
27199
diff
changeset
|
404 return m_call_stack.current_user_frame (); |
dc1edf932248
eliminate direct access to call_stack in input functions
John W. Eaton <jwe@octave.org>
parents:
27199
diff
changeset
|
405 } |
dc1edf932248
eliminate direct access to call_stack in input functions
John W. Eaton <jwe@octave.org>
parents:
27199
diff
changeset
|
406 |
dc1edf932248
eliminate direct access to call_stack in input functions
John W. Eaton <jwe@octave.org>
parents:
27199
diff
changeset
|
407 // Current line in current function. |
dc1edf932248
eliminate direct access to call_stack in input functions
John W. Eaton <jwe@octave.org>
parents:
27199
diff
changeset
|
408 int current_line (void) const; |
dc1edf932248
eliminate direct access to call_stack in input functions
John W. Eaton <jwe@octave.org>
parents:
27199
diff
changeset
|
409 |
dc1edf932248
eliminate direct access to call_stack in input functions
John W. Eaton <jwe@octave.org>
parents:
27199
diff
changeset
|
410 // Current column in current function. |
dc1edf932248
eliminate direct access to call_stack in input functions
John W. Eaton <jwe@octave.org>
parents:
27199
diff
changeset
|
411 int current_column (void) const; |
dc1edf932248
eliminate direct access to call_stack in input functions
John W. Eaton <jwe@octave.org>
parents:
27199
diff
changeset
|
412 |
27205
6648d1ae05fe
eliminate direct access to call stack in debug functions
John W. Eaton <jwe@octave.org>
parents:
27204
diff
changeset
|
413 // Line number in current function that we are debugging. |
6648d1ae05fe
eliminate direct access to call stack in debug functions
John W. Eaton <jwe@octave.org>
parents:
27204
diff
changeset
|
414 int debug_user_code_line (void) const; |
6648d1ae05fe
eliminate direct access to call stack in debug functions
John W. Eaton <jwe@octave.org>
parents:
27204
diff
changeset
|
415 |
6648d1ae05fe
eliminate direct access to call stack in debug functions
John W. Eaton <jwe@octave.org>
parents:
27204
diff
changeset
|
416 // Column number in current function that we are debugging. |
6648d1ae05fe
eliminate direct access to call stack in debug functions
John W. Eaton <jwe@octave.org>
parents:
27204
diff
changeset
|
417 int debug_user_code_column (void) const; |
6648d1ae05fe
eliminate direct access to call stack in debug functions
John W. Eaton <jwe@octave.org>
parents:
27204
diff
changeset
|
418 |
6648d1ae05fe
eliminate direct access to call stack in debug functions
John W. Eaton <jwe@octave.org>
parents:
27204
diff
changeset
|
419 void debug_where (std::ostream& os) const; |
6648d1ae05fe
eliminate direct access to call stack in debug functions
John W. Eaton <jwe@octave.org>
parents:
27204
diff
changeset
|
420 |
27200
dc1edf932248
eliminate direct access to call_stack in input functions
John W. Eaton <jwe@octave.org>
parents:
27199
diff
changeset
|
421 octave_user_code * current_user_code (void) const; |
dc1edf932248
eliminate direct access to call_stack in input functions
John W. Eaton <jwe@octave.org>
parents:
27199
diff
changeset
|
422 |
27204
9a3e92d02a03
eliminate direct access to call stack in variables functions
John W. Eaton <jwe@octave.org>
parents:
27203
diff
changeset
|
423 unwind_protect * curr_fcn_unwind_protect_frame (void) const; |
27200
dc1edf932248
eliminate direct access to call_stack in input functions
John W. Eaton <jwe@octave.org>
parents:
27199
diff
changeset
|
424 |
27202
23962b243bad
eliminate direct access to call stack in help functions
John W. Eaton <jwe@octave.org>
parents:
27201
diff
changeset
|
425 // Current function that we are debugging. |
23962b243bad
eliminate direct access to call stack in help functions
John W. Eaton <jwe@octave.org>
parents:
27201
diff
changeset
|
426 octave_user_code * debug_user_code (void) const; |
23962b243bad
eliminate direct access to call stack in help functions
John W. Eaton <jwe@octave.org>
parents:
27201
diff
changeset
|
427 |
27873
020d0e8f7ac6
reafactor mlock, munlock, and mislocked functions
John W. Eaton <jwe@octave.org>
parents:
27725
diff
changeset
|
428 octave_function * current_function (bool skip_first = false) const; |
27201
bd49997051ef
eliminate direct access to call stack in defun functions
John W. Eaton <jwe@octave.org>
parents:
27200
diff
changeset
|
429 |
27204
9a3e92d02a03
eliminate direct access to call stack in variables functions
John W. Eaton <jwe@octave.org>
parents:
27203
diff
changeset
|
430 octave_function * caller_function (void) const; |
9a3e92d02a03
eliminate direct access to call stack in variables functions
John W. Eaton <jwe@octave.org>
parents:
27203
diff
changeset
|
431 |
27200
dc1edf932248
eliminate direct access to call_stack in input functions
John W. Eaton <jwe@octave.org>
parents:
27199
diff
changeset
|
432 bool goto_frame (size_t n = 0, bool verbose = false); |
dc1edf932248
eliminate direct access to call_stack in input functions
John W. Eaton <jwe@octave.org>
parents:
27199
diff
changeset
|
433 |
27206
4e4a9d7b436e
eliminate direct access to call stack in mex functions
John W. Eaton <jwe@octave.org>
parents:
27205
diff
changeset
|
434 void goto_caller_frame (void); |
4e4a9d7b436e
eliminate direct access to call stack in mex functions
John W. Eaton <jwe@octave.org>
parents:
27205
diff
changeset
|
435 |
4e4a9d7b436e
eliminate direct access to call stack in mex functions
John W. Eaton <jwe@octave.org>
parents:
27205
diff
changeset
|
436 void goto_base_frame (void); |
4e4a9d7b436e
eliminate direct access to call stack in mex functions
John W. Eaton <jwe@octave.org>
parents:
27205
diff
changeset
|
437 |
27200
dc1edf932248
eliminate direct access to call_stack in input functions
John W. Eaton <jwe@octave.org>
parents:
27199
diff
changeset
|
438 void restore_frame (size_t n); |
dc1edf932248
eliminate direct access to call_stack in input functions
John W. Eaton <jwe@octave.org>
parents:
27199
diff
changeset
|
439 |
27210
bd684aad1821
eliminate some direct access to call stack in legacy class and function objects
John W. Eaton <jwe@octave.org>
parents:
27208
diff
changeset
|
440 std::string get_dispatch_class (void) const; |
bd684aad1821
eliminate some direct access to call stack in legacy class and function objects
John W. Eaton <jwe@octave.org>
parents:
27208
diff
changeset
|
441 |
bd684aad1821
eliminate some direct access to call stack in legacy class and function objects
John W. Eaton <jwe@octave.org>
parents:
27208
diff
changeset
|
442 void set_dispatch_class (const std::string& class_name); |
bd684aad1821
eliminate some direct access to call stack in legacy class and function objects
John W. Eaton <jwe@octave.org>
parents:
27208
diff
changeset
|
443 |
bd684aad1821
eliminate some direct access to call stack in legacy class and function objects
John W. Eaton <jwe@octave.org>
parents:
27208
diff
changeset
|
444 bool is_class_method_executing (std::string& dispatch_class) const; |
bd684aad1821
eliminate some direct access to call stack in legacy class and function objects
John W. Eaton <jwe@octave.org>
parents:
27208
diff
changeset
|
445 |
bd684aad1821
eliminate some direct access to call stack in legacy class and function objects
John W. Eaton <jwe@octave.org>
parents:
27208
diff
changeset
|
446 bool is_class_constructor_executing (std::string& dispatch_class) const; |
27200
dc1edf932248
eliminate direct access to call_stack in input functions
John W. Eaton <jwe@octave.org>
parents:
27199
diff
changeset
|
447 |
27199
f27002104c5b
eliminate direct access to call_stack in error functions
John W. Eaton <jwe@octave.org>
parents:
27037
diff
changeset
|
448 std::list<stack_frame *> |
f27002104c5b
eliminate direct access to call_stack in error functions
John W. Eaton <jwe@octave.org>
parents:
27037
diff
changeset
|
449 backtrace_frames (octave_idx_type& curr_user_frame) const; |
f27002104c5b
eliminate direct access to call_stack in error functions
John W. Eaton <jwe@octave.org>
parents:
27037
diff
changeset
|
450 |
f27002104c5b
eliminate direct access to call_stack in error functions
John W. Eaton <jwe@octave.org>
parents:
27037
diff
changeset
|
451 std::list<stack_frame *> backtrace_frames () const; |
f27002104c5b
eliminate direct access to call_stack in error functions
John W. Eaton <jwe@octave.org>
parents:
27037
diff
changeset
|
452 |
27471 | 453 std::list<frame_info> backtrace_info (octave_idx_type& curr_user_frame, |
454 bool print_subfn = true) const; | |
455 | |
456 std::list<frame_info> backtrace_info (void) const; | |
457 | |
27199
f27002104c5b
eliminate direct access to call_stack in error functions
John W. Eaton <jwe@octave.org>
parents:
27037
diff
changeset
|
458 octave_map backtrace (octave_idx_type& curr_user_frame, |
f27002104c5b
eliminate direct access to call_stack in error functions
John W. Eaton <jwe@octave.org>
parents:
27037
diff
changeset
|
459 bool print_subfn = true) const; |
24037
21915520ac7b
use more direct method for non-local symbol access (bug #38236)
John W. Eaton <jwe@octave.org>
parents:
23916
diff
changeset
|
460 |
27471 | 461 octave_map backtrace (void) const; |
27199
f27002104c5b
eliminate direct access to call_stack in error functions
John W. Eaton <jwe@octave.org>
parents:
27037
diff
changeset
|
462 |
f27002104c5b
eliminate direct access to call_stack in error functions
John W. Eaton <jwe@octave.org>
parents:
27037
diff
changeset
|
463 octave_map empty_backtrace (void) const; |
f27002104c5b
eliminate direct access to call_stack in error functions
John W. Eaton <jwe@octave.org>
parents:
27037
diff
changeset
|
464 |
27471 | 465 std::string backtrace_message (void) const; |
466 | |
27001
3cea1cfb37d3
move toward limiting direct access of call stack
John W. Eaton <jwe@octave.org>
parents:
26975
diff
changeset
|
467 void push_dummy_scope (const std::string& name); |
3cea1cfb37d3
move toward limiting direct access of call stack
John W. Eaton <jwe@octave.org>
parents:
26975
diff
changeset
|
468 void pop_scope (void); |
23753
c3828bd031cd
move profiler inside evaluator and inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23750
diff
changeset
|
469 |
26661
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
470 symbol_scope get_top_scope (void) const; |
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
471 symbol_scope get_current_scope (void) const; |
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
472 |
27873
020d0e8f7ac6
reafactor mlock, munlock, and mislocked functions
John W. Eaton <jwe@octave.org>
parents:
27725
diff
changeset
|
473 void mlock (bool skip_first = false) const; |
020d0e8f7ac6
reafactor mlock, munlock, and mislocked functions
John W. Eaton <jwe@octave.org>
parents:
27725
diff
changeset
|
474 |
020d0e8f7ac6
reafactor mlock, munlock, and mislocked functions
John W. Eaton <jwe@octave.org>
parents:
27725
diff
changeset
|
475 void munlock (bool skip_first = false) const; |
020d0e8f7ac6
reafactor mlock, munlock, and mislocked functions
John W. Eaton <jwe@octave.org>
parents:
27725
diff
changeset
|
476 |
020d0e8f7ac6
reafactor mlock, munlock, and mislocked functions
John W. Eaton <jwe@octave.org>
parents:
27725
diff
changeset
|
477 bool mislocked (bool skip_first = false) const; |
27212
f84c5528e932
eliminate direct access to call stack in interpreter::mlock
John W. Eaton <jwe@octave.org>
parents:
27211
diff
changeset
|
478 |
27211
8c27802a76c4
store reference to evaluator instead of call stack in stack frame
John W. Eaton <jwe@octave.org>
parents:
27210
diff
changeset
|
479 octave_value max_stack_depth (const octave_value_list& args, int nargout); |
8c27802a76c4
store reference to evaluator instead of call stack in stack frame
John W. Eaton <jwe@octave.org>
parents:
27210
diff
changeset
|
480 |
8c27802a76c4
store reference to evaluator instead of call stack in stack frame
John W. Eaton <jwe@octave.org>
parents:
27210
diff
changeset
|
481 // Useful for debugging |
8c27802a76c4
store reference to evaluator instead of call stack in stack frame
John W. Eaton <jwe@octave.org>
parents:
27210
diff
changeset
|
482 void display_call_stack (void) const; |
8c27802a76c4
store reference to evaluator instead of call stack in stack frame
John W. Eaton <jwe@octave.org>
parents:
27210
diff
changeset
|
483 |
26661
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
484 octave_value find (const std::string& name); |
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
485 |
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
486 void clear_objects (void); |
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
487 |
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
488 void clear_variable (const std::string& name); |
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
489 |
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
490 void clear_variable_pattern (const std::string& pattern); |
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
491 |
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
492 void clear_variable_regexp (const std::string& pattern); |
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
493 |
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
494 void clear_variables (void); |
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
495 |
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
496 void clear_global_variable (const std::string& name); |
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
497 |
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
498 void clear_global_variable_pattern (const std::string& pattern); |
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
499 |
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
500 void clear_global_variable_regexp (const std::string& pattern); |
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
501 |
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
502 void clear_global_variables (void); |
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
503 |
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
504 void clear_all (bool force = false); |
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
505 |
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
506 void clear_symbol (const std::string& name); |
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
507 |
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
508 void clear_symbol_pattern (const std::string& pattern); |
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
509 |
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
510 void clear_symbol_regexp (const std::string& pattern); |
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
511 |
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
512 std::list<std::string> global_variable_names (void) const; |
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
513 |
27594
e091e09d26f0
restore some symbol table functions for backward compatibility
John W. Eaton <jwe@octave.org>
parents:
27519
diff
changeset
|
514 std::list<std::string> top_level_variable_names (void) const; |
e091e09d26f0
restore some symbol table functions for backward compatibility
John W. Eaton <jwe@octave.org>
parents:
27519
diff
changeset
|
515 |
26661
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
516 std::list<std::string> variable_names (void) const; |
24037
21915520ac7b
use more direct method for non-local symbol access (bug #38236)
John W. Eaton <jwe@octave.org>
parents:
23916
diff
changeset
|
517 |
26975
de826e69a5ea
make breakpoints in classdef methods work (bug #45404, bug #46451)
John W. Eaton <jwe@octave.org>
parents:
26825
diff
changeset
|
518 octave_user_code * get_user_code (const std::string& fname = "", |
de826e69a5ea
make breakpoints in classdef methods work (bug #45404, bug #46451)
John W. Eaton <jwe@octave.org>
parents:
26825
diff
changeset
|
519 const std::string& class_name = ""); |
25360
bc5f225bc578
eliminate some global accesses to the breakpoint table
John W. Eaton <jwe@octave.org>
parents:
25317
diff
changeset
|
520 |
27873
020d0e8f7ac6
reafactor mlock, munlock, and mislocked functions
John W. Eaton <jwe@octave.org>
parents:
27725
diff
changeset
|
521 std::string current_function_name (bool skip_first = false) const; |
27199
f27002104c5b
eliminate direct access to call_stack in error functions
John W. Eaton <jwe@octave.org>
parents:
27037
diff
changeset
|
522 |
f27002104c5b
eliminate direct access to call_stack in error functions
John W. Eaton <jwe@octave.org>
parents:
27037
diff
changeset
|
523 bool in_user_code (void) const; |
f27002104c5b
eliminate direct access to call_stack in error functions
John W. Eaton <jwe@octave.org>
parents:
27037
diff
changeset
|
524 |
27203
79065f9d5553
eliminate direct access to call stack in load-save functions
John W. Eaton <jwe@octave.org>
parents:
27202
diff
changeset
|
525 symbol_info_list glob_symbol_info (const std::string& pattern) const; |
79065f9d5553
eliminate direct access to call stack in load-save functions
John W. Eaton <jwe@octave.org>
parents:
27202
diff
changeset
|
526 |
79065f9d5553
eliminate direct access to call stack in load-save functions
John W. Eaton <jwe@octave.org>
parents:
27202
diff
changeset
|
527 symbol_info_list regexp_symbol_info (const std::string& pattern) const; |
79065f9d5553
eliminate direct access to call stack in load-save functions
John W. Eaton <jwe@octave.org>
parents:
27202
diff
changeset
|
528 |
79065f9d5553
eliminate direct access to call stack in load-save functions
John W. Eaton <jwe@octave.org>
parents:
27202
diff
changeset
|
529 symbol_info_list get_symbol_info (void); |
79065f9d5553
eliminate direct access to call stack in load-save functions
John W. Eaton <jwe@octave.org>
parents:
27202
diff
changeset
|
530 |
79065f9d5553
eliminate direct access to call stack in load-save functions
John W. Eaton <jwe@octave.org>
parents:
27202
diff
changeset
|
531 symbol_info_list top_scope_symbol_info (void) const; |
79065f9d5553
eliminate direct access to call stack in load-save functions
John W. Eaton <jwe@octave.org>
parents:
27202
diff
changeset
|
532 |
27016
9b261300a001
move file-scope static autoload map variable and functions to evaluator
John W. Eaton <jwe@octave.org>
parents:
27015
diff
changeset
|
533 octave_map get_autoload_map (void) const; |
9b261300a001
move file-scope static autoload map variable and functions to evaluator
John W. Eaton <jwe@octave.org>
parents:
27015
diff
changeset
|
534 |
9b261300a001
move file-scope static autoload map variable and functions to evaluator
John W. Eaton <jwe@octave.org>
parents:
27015
diff
changeset
|
535 std::string lookup_autoload (const std::string& nm) const; |
9b261300a001
move file-scope static autoload map variable and functions to evaluator
John W. Eaton <jwe@octave.org>
parents:
27015
diff
changeset
|
536 |
9b261300a001
move file-scope static autoload map variable and functions to evaluator
John W. Eaton <jwe@octave.org>
parents:
27015
diff
changeset
|
537 std::list<std::string> autoloaded_functions (void) const; |
9b261300a001
move file-scope static autoload map variable and functions to evaluator
John W. Eaton <jwe@octave.org>
parents:
27015
diff
changeset
|
538 |
9b261300a001
move file-scope static autoload map variable and functions to evaluator
John W. Eaton <jwe@octave.org>
parents:
27015
diff
changeset
|
539 std::list<std::string> reverse_lookup_autoload (const std::string& nm) const; |
9b261300a001
move file-scope static autoload map variable and functions to evaluator
John W. Eaton <jwe@octave.org>
parents:
27015
diff
changeset
|
540 |
9b261300a001
move file-scope static autoload map variable and functions to evaluator
John W. Eaton <jwe@octave.org>
parents:
27015
diff
changeset
|
541 void add_autoload (const std::string& fcn, const std::string& nm); |
9b261300a001
move file-scope static autoload map variable and functions to evaluator
John W. Eaton <jwe@octave.org>
parents:
27015
diff
changeset
|
542 |
9b261300a001
move file-scope static autoload map variable and functions to evaluator
John W. Eaton <jwe@octave.org>
parents:
27015
diff
changeset
|
543 void remove_autoload (const std::string& fcn, const std::string& nm); |
25360
bc5f225bc578
eliminate some global accesses to the breakpoint table
John W. Eaton <jwe@octave.org>
parents:
25317
diff
changeset
|
544 |
23705
4c597585ff52
move Vmax_recursion_depth and Vsilent_functions to tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23702
diff
changeset
|
545 int max_recursion_depth (void) const { return m_max_recursion_depth; } |
4c597585ff52
move Vmax_recursion_depth and Vsilent_functions to tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23702
diff
changeset
|
546 |
4c597585ff52
move Vmax_recursion_depth and Vsilent_functions to tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23702
diff
changeset
|
547 int max_recursion_depth (int n) |
4c597585ff52
move Vmax_recursion_depth and Vsilent_functions to tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23702
diff
changeset
|
548 { |
4c597585ff52
move Vmax_recursion_depth and Vsilent_functions to tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23702
diff
changeset
|
549 int val = m_max_recursion_depth; |
4c597585ff52
move Vmax_recursion_depth and Vsilent_functions to tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23702
diff
changeset
|
550 m_max_recursion_depth = n; |
4c597585ff52
move Vmax_recursion_depth and Vsilent_functions to tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23702
diff
changeset
|
551 return val; |
4c597585ff52
move Vmax_recursion_depth and Vsilent_functions to tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23702
diff
changeset
|
552 } |
4c597585ff52
move Vmax_recursion_depth and Vsilent_functions to tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23702
diff
changeset
|
553 |
4c597585ff52
move Vmax_recursion_depth and Vsilent_functions to tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23702
diff
changeset
|
554 octave_value |
4c597585ff52
move Vmax_recursion_depth and Vsilent_functions to tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23702
diff
changeset
|
555 max_recursion_depth (const octave_value_list& args, int nargout); |
4c597585ff52
move Vmax_recursion_depth and Vsilent_functions to tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23702
diff
changeset
|
556 |
4c597585ff52
move Vmax_recursion_depth and Vsilent_functions to tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23702
diff
changeset
|
557 bool silent_functions (void) const { return m_silent_functions; } |
4c597585ff52
move Vmax_recursion_depth and Vsilent_functions to tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23702
diff
changeset
|
558 |
4c597585ff52
move Vmax_recursion_depth and Vsilent_functions to tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23702
diff
changeset
|
559 bool silent_functions (bool b) |
4c597585ff52
move Vmax_recursion_depth and Vsilent_functions to tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23702
diff
changeset
|
560 { |
4c597585ff52
move Vmax_recursion_depth and Vsilent_functions to tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23702
diff
changeset
|
561 int val = m_silent_functions; |
4c597585ff52
move Vmax_recursion_depth and Vsilent_functions to tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23702
diff
changeset
|
562 m_silent_functions = b; |
4c597585ff52
move Vmax_recursion_depth and Vsilent_functions to tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23702
diff
changeset
|
563 return val; |
4c597585ff52
move Vmax_recursion_depth and Vsilent_functions to tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23702
diff
changeset
|
564 } |
4c597585ff52
move Vmax_recursion_depth and Vsilent_functions to tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23702
diff
changeset
|
565 |
26087
7656fcd0ff9f
move whos_line_format to evaluator
John W. Eaton <jwe@octave.org>
parents:
26039
diff
changeset
|
566 octave_value whos_line_format (const octave_value_list& args, int nargout); |
7656fcd0ff9f
move whos_line_format to evaluator
John W. Eaton <jwe@octave.org>
parents:
26039
diff
changeset
|
567 |
7656fcd0ff9f
move whos_line_format to evaluator
John W. Eaton <jwe@octave.org>
parents:
26039
diff
changeset
|
568 std::string whos_line_format (void) const { return m_whos_line_format; } |
7656fcd0ff9f
move whos_line_format to evaluator
John W. Eaton <jwe@octave.org>
parents:
26039
diff
changeset
|
569 |
7656fcd0ff9f
move whos_line_format to evaluator
John W. Eaton <jwe@octave.org>
parents:
26039
diff
changeset
|
570 std::string whos_line_format (const std::string& s) |
7656fcd0ff9f
move whos_line_format to evaluator
John W. Eaton <jwe@octave.org>
parents:
26039
diff
changeset
|
571 { |
7656fcd0ff9f
move whos_line_format to evaluator
John W. Eaton <jwe@octave.org>
parents:
26039
diff
changeset
|
572 std::string val = m_whos_line_format; |
7656fcd0ff9f
move whos_line_format to evaluator
John W. Eaton <jwe@octave.org>
parents:
26039
diff
changeset
|
573 m_whos_line_format = s; |
7656fcd0ff9f
move whos_line_format to evaluator
John W. Eaton <jwe@octave.org>
parents:
26039
diff
changeset
|
574 return val; |
7656fcd0ff9f
move whos_line_format to evaluator
John W. Eaton <jwe@octave.org>
parents:
26039
diff
changeset
|
575 } |
7656fcd0ff9f
move whos_line_format to evaluator
John W. Eaton <jwe@octave.org>
parents:
26039
diff
changeset
|
576 |
23705
4c597585ff52
move Vmax_recursion_depth and Vsilent_functions to tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23702
diff
changeset
|
577 octave_value |
4c597585ff52
move Vmax_recursion_depth and Vsilent_functions to tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23702
diff
changeset
|
578 silent_functions (const octave_value_list& args, int nargout); |
4c597585ff52
move Vmax_recursion_depth and Vsilent_functions to tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23702
diff
changeset
|
579 |
27037
8408acb7ca4f
make dbup/dbdown work again (bug #56020)
John W. Eaton <jwe@octave.org>
parents:
27019
diff
changeset
|
580 size_t debug_frame (void) const { return m_debug_frame; } |
25402
ef2b9d4abf4a
eliminate some global variables from tree_evaluator
John W. Eaton <jwe@octave.org>
parents:
25401
diff
changeset
|
581 |
27037
8408acb7ca4f
make dbup/dbdown work again (bug #56020)
John W. Eaton <jwe@octave.org>
parents:
27019
diff
changeset
|
582 size_t debug_frame (size_t n) |
25402
ef2b9d4abf4a
eliminate some global variables from tree_evaluator
John W. Eaton <jwe@octave.org>
parents:
25401
diff
changeset
|
583 { |
27037
8408acb7ca4f
make dbup/dbdown work again (bug #56020)
John W. Eaton <jwe@octave.org>
parents:
27019
diff
changeset
|
584 size_t val = m_debug_frame; |
8408acb7ca4f
make dbup/dbdown work again (bug #56020)
John W. Eaton <jwe@octave.org>
parents:
27019
diff
changeset
|
585 m_debug_frame = n; |
25402
ef2b9d4abf4a
eliminate some global variables from tree_evaluator
John W. Eaton <jwe@octave.org>
parents:
25401
diff
changeset
|
586 return val; |
ef2b9d4abf4a
eliminate some global variables from tree_evaluator
John W. Eaton <jwe@octave.org>
parents:
25401
diff
changeset
|
587 } |
ef2b9d4abf4a
eliminate some global variables from tree_evaluator
John W. Eaton <jwe@octave.org>
parents:
25401
diff
changeset
|
588 |
27199
f27002104c5b
eliminate direct access to call_stack in error functions
John W. Eaton <jwe@octave.org>
parents:
27037
diff
changeset
|
589 size_t current_call_stack_frame_number (void) const |
25402
ef2b9d4abf4a
eliminate some global variables from tree_evaluator
John W. Eaton <jwe@octave.org>
parents:
25401
diff
changeset
|
590 { |
27199
f27002104c5b
eliminate direct access to call_stack in error functions
John W. Eaton <jwe@octave.org>
parents:
27037
diff
changeset
|
591 return m_call_stack.current_frame (); |
25402
ef2b9d4abf4a
eliminate some global variables from tree_evaluator
John W. Eaton <jwe@octave.org>
parents:
25401
diff
changeset
|
592 } |
ef2b9d4abf4a
eliminate some global variables from tree_evaluator
John W. Eaton <jwe@octave.org>
parents:
25401
diff
changeset
|
593 |
ef2b9d4abf4a
eliminate some global variables from tree_evaluator
John W. Eaton <jwe@octave.org>
parents:
25401
diff
changeset
|
594 bool quiet_breakpoint_flag (void) const { return m_quiet_breakpoint_flag; } |
ef2b9d4abf4a
eliminate some global variables from tree_evaluator
John W. Eaton <jwe@octave.org>
parents:
25401
diff
changeset
|
595 |
ef2b9d4abf4a
eliminate some global variables from tree_evaluator
John W. Eaton <jwe@octave.org>
parents:
25401
diff
changeset
|
596 bool quiet_breakpoint_flag (bool flag) |
ef2b9d4abf4a
eliminate some global variables from tree_evaluator
John W. Eaton <jwe@octave.org>
parents:
25401
diff
changeset
|
597 { |
ef2b9d4abf4a
eliminate some global variables from tree_evaluator
John W. Eaton <jwe@octave.org>
parents:
25401
diff
changeset
|
598 bool val = m_quiet_breakpoint_flag; |
ef2b9d4abf4a
eliminate some global variables from tree_evaluator
John W. Eaton <jwe@octave.org>
parents:
25401
diff
changeset
|
599 m_quiet_breakpoint_flag = flag; |
ef2b9d4abf4a
eliminate some global variables from tree_evaluator
John W. Eaton <jwe@octave.org>
parents:
25401
diff
changeset
|
600 return val; |
ef2b9d4abf4a
eliminate some global variables from tree_evaluator
John W. Eaton <jwe@octave.org>
parents:
25401
diff
changeset
|
601 } |
ef2b9d4abf4a
eliminate some global variables from tree_evaluator
John W. Eaton <jwe@octave.org>
parents:
25401
diff
changeset
|
602 |
23706
6683451b75b2
move Vstring_fill_char to tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23705
diff
changeset
|
603 char string_fill_char (void) const { return m_string_fill_char; } |
6683451b75b2
move Vstring_fill_char to tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23705
diff
changeset
|
604 |
6683451b75b2
move Vstring_fill_char to tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23705
diff
changeset
|
605 char string_fill_char (char c) |
6683451b75b2
move Vstring_fill_char to tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23705
diff
changeset
|
606 { |
6683451b75b2
move Vstring_fill_char to tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23705
diff
changeset
|
607 int val = m_string_fill_char; |
6683451b75b2
move Vstring_fill_char to tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23705
diff
changeset
|
608 m_string_fill_char = c; |
6683451b75b2
move Vstring_fill_char to tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23705
diff
changeset
|
609 return val; |
6683451b75b2
move Vstring_fill_char to tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23705
diff
changeset
|
610 } |
6683451b75b2
move Vstring_fill_char to tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23705
diff
changeset
|
611 |
27282
49c60d16866f
improve dbquit and dbcont behavior
John W. Eaton <jwe@octave.org>
parents:
27234
diff
changeset
|
612 // The following functions are provided for convenience. They |
49c60d16866f
improve dbquit and dbcont behavior
John W. Eaton <jwe@octave.org>
parents:
27234
diff
changeset
|
613 // call the corresponding functions in the debugger class for the |
27037
8408acb7ca4f
make dbup/dbdown work again (bug #56020)
John W. Eaton <jwe@octave.org>
parents:
27019
diff
changeset
|
614 // current debugger (if any). |
27282
49c60d16866f
improve dbquit and dbcont behavior
John W. Eaton <jwe@octave.org>
parents:
27234
diff
changeset
|
615 |
27037
8408acb7ca4f
make dbup/dbdown work again (bug #56020)
John W. Eaton <jwe@octave.org>
parents:
27019
diff
changeset
|
616 bool in_debug_repl (void) const; |
27282
49c60d16866f
improve dbquit and dbcont behavior
John W. Eaton <jwe@octave.org>
parents:
27234
diff
changeset
|
617 |
49c60d16866f
improve dbquit and dbcont behavior
John W. Eaton <jwe@octave.org>
parents:
27234
diff
changeset
|
618 void dbcont (void); |
49c60d16866f
improve dbquit and dbcont behavior
John W. Eaton <jwe@octave.org>
parents:
27234
diff
changeset
|
619 |
49c60d16866f
improve dbquit and dbcont behavior
John W. Eaton <jwe@octave.org>
parents:
27234
diff
changeset
|
620 void dbquit (bool all = false); |
27037
8408acb7ca4f
make dbup/dbdown work again (bug #56020)
John W. Eaton <jwe@octave.org>
parents:
27019
diff
changeset
|
621 |
23723
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
622 octave_value PS4 (const octave_value_list& args, int nargout); |
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
623 |
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
624 std::string PS4 (void) const { return m_PS4; } |
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
625 |
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
626 std::string PS4 (const std::string& s) |
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
627 { |
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
628 std::string val = m_PS4; |
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
629 m_PS4 = s; |
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
630 return val; |
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
631 } |
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
632 |
25382
749d9e858553
move convert_to_const_vector from tree_argument_list to tree_evaluator
John W. Eaton <jwe@octave.org>
parents:
25381
diff
changeset
|
633 const octave_value * indexed_object (void) const |
749d9e858553
move convert_to_const_vector from tree_argument_list to tree_evaluator
John W. Eaton <jwe@octave.org>
parents:
25381
diff
changeset
|
634 { |
749d9e858553
move convert_to_const_vector from tree_argument_list to tree_evaluator
John W. Eaton <jwe@octave.org>
parents:
25381
diff
changeset
|
635 return m_indexed_object; |
749d9e858553
move convert_to_const_vector from tree_argument_list to tree_evaluator
John W. Eaton <jwe@octave.org>
parents:
25381
diff
changeset
|
636 } |
749d9e858553
move convert_to_const_vector from tree_argument_list to tree_evaluator
John W. Eaton <jwe@octave.org>
parents:
25381
diff
changeset
|
637 |
749d9e858553
move convert_to_const_vector from tree_argument_list to tree_evaluator
John W. Eaton <jwe@octave.org>
parents:
25381
diff
changeset
|
638 int index_position (void) const { return m_index_position; } |
749d9e858553
move convert_to_const_vector from tree_argument_list to tree_evaluator
John W. Eaton <jwe@octave.org>
parents:
25381
diff
changeset
|
639 |
749d9e858553
move convert_to_const_vector from tree_argument_list to tree_evaluator
John W. Eaton <jwe@octave.org>
parents:
25381
diff
changeset
|
640 int num_indices (void) const { return m_num_indices; } |
749d9e858553
move convert_to_const_vector from tree_argument_list to tree_evaluator
John W. Eaton <jwe@octave.org>
parents:
25381
diff
changeset
|
641 |
27371
fcaecdbc8d8a
don't use visitor pattern for expression evaluation (bug #56752)
John W. Eaton <jwe@octave.org>
parents:
27370
diff
changeset
|
642 const std::list<octave_lvalue> * lvalue_list (void) const |
fcaecdbc8d8a
don't use visitor pattern for expression evaluation (bug #56752)
John W. Eaton <jwe@octave.org>
parents:
27370
diff
changeset
|
643 { |
fcaecdbc8d8a
don't use visitor pattern for expression evaluation (bug #56752)
John W. Eaton <jwe@octave.org>
parents:
27370
diff
changeset
|
644 return m_lvalue_list; |
fcaecdbc8d8a
don't use visitor pattern for expression evaluation (bug #56752)
John W. Eaton <jwe@octave.org>
parents:
27370
diff
changeset
|
645 } |
fcaecdbc8d8a
don't use visitor pattern for expression evaluation (bug #56752)
John W. Eaton <jwe@octave.org>
parents:
27370
diff
changeset
|
646 |
fcaecdbc8d8a
don't use visitor pattern for expression evaluation (bug #56752)
John W. Eaton <jwe@octave.org>
parents:
27370
diff
changeset
|
647 void set_lvalue_list (const std::list<octave_lvalue> *lst) |
fcaecdbc8d8a
don't use visitor pattern for expression evaluation (bug #56752)
John W. Eaton <jwe@octave.org>
parents:
27370
diff
changeset
|
648 { |
fcaecdbc8d8a
don't use visitor pattern for expression evaluation (bug #56752)
John W. Eaton <jwe@octave.org>
parents:
27370
diff
changeset
|
649 m_lvalue_list = lst; |
fcaecdbc8d8a
don't use visitor pattern for expression evaluation (bug #56752)
John W. Eaton <jwe@octave.org>
parents:
27370
diff
changeset
|
650 } |
fcaecdbc8d8a
don't use visitor pattern for expression evaluation (bug #56752)
John W. Eaton <jwe@octave.org>
parents:
27370
diff
changeset
|
651 |
25403
2b7d7a3f5f57
move returning, breaking, and continuing flags to evaluator
John W. Eaton <jwe@octave.org>
parents:
25402
diff
changeset
|
652 int breaking (void) const { return m_breaking; } |
2b7d7a3f5f57
move returning, breaking, and continuing flags to evaluator
John W. Eaton <jwe@octave.org>
parents:
25402
diff
changeset
|
653 |
25404
e37d857716c3
move core of interpreter::main_loop to evaluator
John W. Eaton <jwe@octave.org>
parents:
25403
diff
changeset
|
654 int breaking (int n) |
e37d857716c3
move core of interpreter::main_loop to evaluator
John W. Eaton <jwe@octave.org>
parents:
25403
diff
changeset
|
655 { |
e37d857716c3
move core of interpreter::main_loop to evaluator
John W. Eaton <jwe@octave.org>
parents:
25403
diff
changeset
|
656 int val = m_breaking; |
e37d857716c3
move core of interpreter::main_loop to evaluator
John W. Eaton <jwe@octave.org>
parents:
25403
diff
changeset
|
657 m_breaking = n; |
e37d857716c3
move core of interpreter::main_loop to evaluator
John W. Eaton <jwe@octave.org>
parents:
25403
diff
changeset
|
658 return val; |
e37d857716c3
move core of interpreter::main_loop to evaluator
John W. Eaton <jwe@octave.org>
parents:
25403
diff
changeset
|
659 } |
e37d857716c3
move core of interpreter::main_loop to evaluator
John W. Eaton <jwe@octave.org>
parents:
25403
diff
changeset
|
660 |
25403
2b7d7a3f5f57
move returning, breaking, and continuing flags to evaluator
John W. Eaton <jwe@octave.org>
parents:
25402
diff
changeset
|
661 int continuing (void) const { return m_continuing; } |
2b7d7a3f5f57
move returning, breaking, and continuing flags to evaluator
John W. Eaton <jwe@octave.org>
parents:
25402
diff
changeset
|
662 |
25404
e37d857716c3
move core of interpreter::main_loop to evaluator
John W. Eaton <jwe@octave.org>
parents:
25403
diff
changeset
|
663 int continuing (int n) |
e37d857716c3
move core of interpreter::main_loop to evaluator
John W. Eaton <jwe@octave.org>
parents:
25403
diff
changeset
|
664 { |
e37d857716c3
move core of interpreter::main_loop to evaluator
John W. Eaton <jwe@octave.org>
parents:
25403
diff
changeset
|
665 int val = m_continuing; |
e37d857716c3
move core of interpreter::main_loop to evaluator
John W. Eaton <jwe@octave.org>
parents:
25403
diff
changeset
|
666 m_continuing = n; |
e37d857716c3
move core of interpreter::main_loop to evaluator
John W. Eaton <jwe@octave.org>
parents:
25403
diff
changeset
|
667 return val; |
e37d857716c3
move core of interpreter::main_loop to evaluator
John W. Eaton <jwe@octave.org>
parents:
25403
diff
changeset
|
668 } |
e37d857716c3
move core of interpreter::main_loop to evaluator
John W. Eaton <jwe@octave.org>
parents:
25403
diff
changeset
|
669 |
25403
2b7d7a3f5f57
move returning, breaking, and continuing flags to evaluator
John W. Eaton <jwe@octave.org>
parents:
25402
diff
changeset
|
670 int returning (void) const { return m_returning; } |
2b7d7a3f5f57
move returning, breaking, and continuing flags to evaluator
John W. Eaton <jwe@octave.org>
parents:
25402
diff
changeset
|
671 |
25404
e37d857716c3
move core of interpreter::main_loop to evaluator
John W. Eaton <jwe@octave.org>
parents:
25403
diff
changeset
|
672 int returning (int n) |
e37d857716c3
move core of interpreter::main_loop to evaluator
John W. Eaton <jwe@octave.org>
parents:
25403
diff
changeset
|
673 { |
e37d857716c3
move core of interpreter::main_loop to evaluator
John W. Eaton <jwe@octave.org>
parents:
25403
diff
changeset
|
674 int val = m_returning; |
e37d857716c3
move core of interpreter::main_loop to evaluator
John W. Eaton <jwe@octave.org>
parents:
25403
diff
changeset
|
675 m_returning = n; |
e37d857716c3
move core of interpreter::main_loop to evaluator
John W. Eaton <jwe@octave.org>
parents:
25403
diff
changeset
|
676 return val; |
e37d857716c3
move core of interpreter::main_loop to evaluator
John W. Eaton <jwe@octave.org>
parents:
25403
diff
changeset
|
677 } |
e37d857716c3
move core of interpreter::main_loop to evaluator
John W. Eaton <jwe@octave.org>
parents:
25403
diff
changeset
|
678 |
27037
8408acb7ca4f
make dbup/dbdown work again (bug #56020)
John W. Eaton <jwe@octave.org>
parents:
27019
diff
changeset
|
679 int dbstep_flag (void) const { return m_dbstep_flag; } |
8408acb7ca4f
make dbup/dbdown work again (bug #56020)
John W. Eaton <jwe@octave.org>
parents:
27019
diff
changeset
|
680 |
8408acb7ca4f
make dbup/dbdown work again (bug #56020)
John W. Eaton <jwe@octave.org>
parents:
27019
diff
changeset
|
681 int dbstep_flag (int val) |
8408acb7ca4f
make dbup/dbdown work again (bug #56020)
John W. Eaton <jwe@octave.org>
parents:
27019
diff
changeset
|
682 { |
8408acb7ca4f
make dbup/dbdown work again (bug #56020)
John W. Eaton <jwe@octave.org>
parents:
27019
diff
changeset
|
683 int old_val = m_dbstep_flag; |
8408acb7ca4f
make dbup/dbdown work again (bug #56020)
John W. Eaton <jwe@octave.org>
parents:
27019
diff
changeset
|
684 m_dbstep_flag = val; |
8408acb7ca4f
make dbup/dbdown work again (bug #56020)
John W. Eaton <jwe@octave.org>
parents:
27019
diff
changeset
|
685 return old_val; |
8408acb7ca4f
make dbup/dbdown work again (bug #56020)
John W. Eaton <jwe@octave.org>
parents:
27019
diff
changeset
|
686 } |
8408acb7ca4f
make dbup/dbdown work again (bug #56020)
John W. Eaton <jwe@octave.org>
parents:
27019
diff
changeset
|
687 |
8408acb7ca4f
make dbup/dbdown work again (bug #56020)
John W. Eaton <jwe@octave.org>
parents:
27019
diff
changeset
|
688 void set_dbstep_flag (int step) { m_dbstep_flag = step; } |
8408acb7ca4f
make dbup/dbdown work again (bug #56020)
John W. Eaton <jwe@octave.org>
parents:
27019
diff
changeset
|
689 |
23723
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
690 octave_value echo (const octave_value_list& args, int nargout); |
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
691 |
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
692 int echo (void) const { return m_echo; } |
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
693 |
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
694 int echo (int val) |
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
695 { |
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
696 int old_val = m_echo; |
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
697 m_echo = val; |
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
698 return old_val; |
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
699 } |
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
700 |
23706
6683451b75b2
move Vstring_fill_char to tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23705
diff
changeset
|
701 octave_value |
6683451b75b2
move Vstring_fill_char to tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23705
diff
changeset
|
702 string_fill_char (const octave_value_list& args, int nargout); |
6683451b75b2
move Vstring_fill_char to tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23705
diff
changeset
|
703 |
26094
8fb0df0c8772
eliminate duplicate final_index_error function
John W. Eaton <jwe@octave.org>
parents:
26087
diff
changeset
|
704 void final_index_error (index_exception& e, const tree_expression *expr); |
8fb0df0c8772
eliminate duplicate final_index_error function
John W. Eaton <jwe@octave.org>
parents:
26087
diff
changeset
|
705 |
27005
a1ea0e7aecde
move do_who inside call_stack, make accessible from evaluator
John W. Eaton <jwe@octave.org>
parents:
27001
diff
changeset
|
706 octave_value do_who (int argc, const string_vector& argv, |
a1ea0e7aecde
move do_who inside call_stack, make accessible from evaluator
John W. Eaton <jwe@octave.org>
parents:
27001
diff
changeset
|
707 bool return_list, bool verbose = false); |
a1ea0e7aecde
move do_who inside call_stack, make accessible from evaluator
John W. Eaton <jwe@octave.org>
parents:
27001
diff
changeset
|
708 |
27371
fcaecdbc8d8a
don't use visitor pattern for expression evaluation (bug #56752)
John W. Eaton <jwe@octave.org>
parents:
27370
diff
changeset
|
709 octave_value_list |
fcaecdbc8d8a
don't use visitor pattern for expression evaluation (bug #56752)
John W. Eaton <jwe@octave.org>
parents:
27370
diff
changeset
|
710 make_value_list (tree_argument_list *args, |
fcaecdbc8d8a
don't use visitor pattern for expression evaluation (bug #56752)
John W. Eaton <jwe@octave.org>
parents:
27370
diff
changeset
|
711 const string_vector& arg_nm, |
fcaecdbc8d8a
don't use visitor pattern for expression evaluation (bug #56752)
John W. Eaton <jwe@octave.org>
parents:
27370
diff
changeset
|
712 const octave_value *object, bool rvalue = true); |
fcaecdbc8d8a
don't use visitor pattern for expression evaluation (bug #56752)
John W. Eaton <jwe@octave.org>
parents:
27370
diff
changeset
|
713 |
fcaecdbc8d8a
don't use visitor pattern for expression evaluation (bug #56752)
John W. Eaton <jwe@octave.org>
parents:
27370
diff
changeset
|
714 std::list<octave_lvalue> make_lvalue_list (tree_argument_list *); |
fcaecdbc8d8a
don't use visitor pattern for expression evaluation (bug #56752)
John W. Eaton <jwe@octave.org>
parents:
27370
diff
changeset
|
715 |
23729
06b3d1d54054
allow echo state to be modified from inside functions
John W. Eaton <jwe@octave.org>
parents:
23728
diff
changeset
|
716 void push_echo_state (unwind_protect& frame, int type, |
06b3d1d54054
allow echo state to be modified from inside functions
John W. Eaton <jwe@octave.org>
parents:
23728
diff
changeset
|
717 const std::string& file_name, size_t pos = 1); |
06b3d1d54054
allow echo state to be modified from inside functions
John W. Eaton <jwe@octave.org>
parents:
23728
diff
changeset
|
718 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21244
diff
changeset
|
719 private: |
8658
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
diff
changeset
|
720 |
23729
06b3d1d54054
allow echo state to be modified from inside functions
John W. Eaton <jwe@octave.org>
parents:
23728
diff
changeset
|
721 void set_echo_state (int type, const std::string& file_name, size_t pos); |
06b3d1d54054
allow echo state to be modified from inside functions
John W. Eaton <jwe@octave.org>
parents:
23728
diff
changeset
|
722 |
06b3d1d54054
allow echo state to be modified from inside functions
John W. Eaton <jwe@octave.org>
parents:
23728
diff
changeset
|
723 void maybe_set_echo_state (void); |
06b3d1d54054
allow echo state to be modified from inside functions
John W. Eaton <jwe@octave.org>
parents:
23728
diff
changeset
|
724 |
06b3d1d54054
allow echo state to be modified from inside functions
John W. Eaton <jwe@octave.org>
parents:
23728
diff
changeset
|
725 void push_echo_state_cleanup (unwind_protect& frame); |
06b3d1d54054
allow echo state to be modified from inside functions
John W. Eaton <jwe@octave.org>
parents:
23728
diff
changeset
|
726 |
06b3d1d54054
allow echo state to be modified from inside functions
John W. Eaton <jwe@octave.org>
parents:
23728
diff
changeset
|
727 bool maybe_push_echo_state_cleanup (void); |
06b3d1d54054
allow echo state to be modified from inside functions
John W. Eaton <jwe@octave.org>
parents:
23728
diff
changeset
|
728 |
25360
bc5f225bc578
eliminate some global accesses to the breakpoint table
John W. Eaton <jwe@octave.org>
parents:
25317
diff
changeset
|
729 void do_breakpoint (tree_statement& stmt); |
8658
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
diff
changeset
|
730 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21244
diff
changeset
|
731 void do_breakpoint (bool is_breakpoint, |
25360
bc5f225bc578
eliminate some global accesses to the breakpoint table
John W. Eaton <jwe@octave.org>
parents:
25317
diff
changeset
|
732 bool is_end_of_fcn_or_script = false); |
8658
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
diff
changeset
|
733 |
23435
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
734 bool is_logically_true (tree_expression *expr, const char *warn_for); |
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
735 |
23723
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
736 // For unwind-protect. |
25653
b3d357990b52
better use of templates for action_container and derived classes
John W. Eaton <jwe@octave.org>
parents:
25404
diff
changeset
|
737 void uwp_set_echo_state (bool state, const std::string& file_name, |
b3d357990b52
better use of templates for action_container and derived classes
John W. Eaton <jwe@octave.org>
parents:
25404
diff
changeset
|
738 size_t pos); |
23723
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
739 |
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
740 bool echo_this_file (const std::string& file, int type) const; |
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
741 |
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
742 void echo_code (size_t line); |
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
743 |
25403
2b7d7a3f5f57
move returning, breaking, and continuing flags to evaluator
John W. Eaton <jwe@octave.org>
parents:
25402
diff
changeset
|
744 bool quit_loop_now (void); |
2b7d7a3f5f57
move returning, breaking, and continuing flags to evaluator
John W. Eaton <jwe@octave.org>
parents:
25402
diff
changeset
|
745 |
26661
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
746 void bind_auto_fcn_vars (const string_vector& arg_names, int nargin, |
26039
d2aae3570c81
perform automatic function variable binding in tree_evaluator
John W. Eaton <jwe@octave.org>
parents:
25653
diff
changeset
|
747 int nargout, bool takes_varargs, |
d2aae3570c81
perform automatic function variable binding in tree_evaluator
John W. Eaton <jwe@octave.org>
parents:
25653
diff
changeset
|
748 const octave_value_list& va_args); |
d2aae3570c81
perform automatic function variable binding in tree_evaluator
John W. Eaton <jwe@octave.org>
parents:
25653
diff
changeset
|
749 |
26661
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
750 void init_local_fcn_vars (octave_user_function& user_fcn); |
cf9e10ce3351
move variable values from symbol_record objects to stack_frame objects
John W. Eaton <jwe@octave.org>
parents:
26377
diff
changeset
|
751 |
27016
9b261300a001
move file-scope static autoload map variable and functions to evaluator
John W. Eaton <jwe@octave.org>
parents:
27015
diff
changeset
|
752 std::string check_autoload_file (const std::string& nm) const; |
9b261300a001
move file-scope static autoload map variable and functions to evaluator
John W. Eaton <jwe@octave.org>
parents:
27015
diff
changeset
|
753 |
23705
4c597585ff52
move Vmax_recursion_depth and Vsilent_functions to tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23702
diff
changeset
|
754 interpreter& m_interpreter; |
4c597585ff52
move Vmax_recursion_depth and Vsilent_functions to tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23702
diff
changeset
|
755 |
25401
6f6479125d80
eliminate some globals from tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
25400
diff
changeset
|
756 // The context for the current evaluation. |
6f6479125d80
eliminate some globals from tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
25400
diff
changeset
|
757 stmt_list_type m_statement_context; |
6f6479125d80
eliminate some globals from tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
25400
diff
changeset
|
758 |
27370
a2d3fa82b730
don't use stack to save and restore lvalue list value in evaluator (bug #56752)
John W. Eaton <jwe@octave.org>
parents:
27369
diff
changeset
|
759 const std::list<octave_lvalue> *m_lvalue_list; |
23435
c452180ab672
begin refactoring parse tree evaluator
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
760 |
27016
9b261300a001
move file-scope static autoload map variable and functions to evaluator
John W. Eaton <jwe@octave.org>
parents:
27015
diff
changeset
|
761 // List of autoloads (function -> file mapping). |
9b261300a001
move file-scope static autoload map variable and functions to evaluator
John W. Eaton <jwe@octave.org>
parents:
27015
diff
changeset
|
762 std::map<std::string, std::string> m_autoload_map; |
10219
979fb2606c4f
new tree_evaluator::do_keyoard function
Ryan Rusaw <rrusaw@gmail.com>
parents:
10186
diff
changeset
|
763 |
25360
bc5f225bc578
eliminate some global accesses to the breakpoint table
John W. Eaton <jwe@octave.org>
parents:
25317
diff
changeset
|
764 bp_table m_bp_table; |
bc5f225bc578
eliminate some global accesses to the breakpoint table
John W. Eaton <jwe@octave.org>
parents:
25317
diff
changeset
|
765 |
23553
14723784b9f2
don't use singleton for call_stack
John W. Eaton <jwe@octave.org>
parents:
23532
diff
changeset
|
766 call_stack m_call_stack; |
14723784b9f2
don't use singleton for call_stack
John W. Eaton <jwe@octave.org>
parents:
23532
diff
changeset
|
767 |
23753
c3828bd031cd
move profiler inside evaluator and inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23750
diff
changeset
|
768 profiler m_profiler; |
c3828bd031cd
move profiler inside evaluator and inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23750
diff
changeset
|
769 |
25402
ef2b9d4abf4a
eliminate some global variables from tree_evaluator
John W. Eaton <jwe@octave.org>
parents:
25401
diff
changeset
|
770 // The number of the stack frame we are currently debugging. |
27037
8408acb7ca4f
make dbup/dbdown work again (bug #56020)
John W. Eaton <jwe@octave.org>
parents:
27019
diff
changeset
|
771 size_t m_debug_frame; |
25402
ef2b9d4abf4a
eliminate some global variables from tree_evaluator
John W. Eaton <jwe@octave.org>
parents:
25401
diff
changeset
|
772 |
ef2b9d4abf4a
eliminate some global variables from tree_evaluator
John W. Eaton <jwe@octave.org>
parents:
25401
diff
changeset
|
773 bool m_debug_mode; |
ef2b9d4abf4a
eliminate some global variables from tree_evaluator
John W. Eaton <jwe@octave.org>
parents:
25401
diff
changeset
|
774 |
ef2b9d4abf4a
eliminate some global variables from tree_evaluator
John W. Eaton <jwe@octave.org>
parents:
25401
diff
changeset
|
775 bool m_quiet_breakpoint_flag; |
ef2b9d4abf4a
eliminate some global variables from tree_evaluator
John W. Eaton <jwe@octave.org>
parents:
25401
diff
changeset
|
776 |
27037
8408acb7ca4f
make dbup/dbdown work again (bug #56020)
John W. Eaton <jwe@octave.org>
parents:
27019
diff
changeset
|
777 // When entering the debugger we push it on this stack. Managing |
8408acb7ca4f
make dbup/dbdown work again (bug #56020)
John W. Eaton <jwe@octave.org>
parents:
27019
diff
changeset
|
778 // debugger invocations this way allows us to handle recursive |
8408acb7ca4f
make dbup/dbdown work again (bug #56020)
John W. Eaton <jwe@octave.org>
parents:
27019
diff
changeset
|
779 // debugger calls. When we exit a debugger the object is popped |
8408acb7ca4f
make dbup/dbdown work again (bug #56020)
John W. Eaton <jwe@octave.org>
parents:
27019
diff
changeset
|
780 // from the stack and deleted and we resume working with the |
8408acb7ca4f
make dbup/dbdown work again (bug #56020)
John W. Eaton <jwe@octave.org>
parents:
27019
diff
changeset
|
781 // previous debugger (if any) that is now at the top of the stack. |
8408acb7ca4f
make dbup/dbdown work again (bug #56020)
John W. Eaton <jwe@octave.org>
parents:
27019
diff
changeset
|
782 std::stack<debugger *> m_debugger_stack; |
8408acb7ca4f
make dbup/dbdown work again (bug #56020)
John W. Eaton <jwe@octave.org>
parents:
27019
diff
changeset
|
783 |
23705
4c597585ff52
move Vmax_recursion_depth and Vsilent_functions to tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23702
diff
changeset
|
784 // Maximum nesting level for functions, scripts, or sourced files |
4c597585ff52
move Vmax_recursion_depth and Vsilent_functions to tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23702
diff
changeset
|
785 // called recursively. |
4c597585ff52
move Vmax_recursion_depth and Vsilent_functions to tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23702
diff
changeset
|
786 int m_max_recursion_depth; |
4c597585ff52
move Vmax_recursion_depth and Vsilent_functions to tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23702
diff
changeset
|
787 |
26087
7656fcd0ff9f
move whos_line_format to evaluator
John W. Eaton <jwe@octave.org>
parents:
26039
diff
changeset
|
788 // Defines layout for the whos/who -long command |
7656fcd0ff9f
move whos_line_format to evaluator
John W. Eaton <jwe@octave.org>
parents:
26039
diff
changeset
|
789 std::string m_whos_line_format; |
7656fcd0ff9f
move whos_line_format to evaluator
John W. Eaton <jwe@octave.org>
parents:
26039
diff
changeset
|
790 |
23705
4c597585ff52
move Vmax_recursion_depth and Vsilent_functions to tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23702
diff
changeset
|
791 // If TRUE, turn off printing of results in functions (as if a |
4c597585ff52
move Vmax_recursion_depth and Vsilent_functions to tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23702
diff
changeset
|
792 // semicolon has been appended to each statement). |
4c597585ff52
move Vmax_recursion_depth and Vsilent_functions to tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23702
diff
changeset
|
793 bool m_silent_functions; |
23706
6683451b75b2
move Vstring_fill_char to tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23705
diff
changeset
|
794 |
6683451b75b2
move Vstring_fill_char to tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23705
diff
changeset
|
795 // The character to fill with when creating string arrays. |
6683451b75b2
move Vstring_fill_char to tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23705
diff
changeset
|
796 char m_string_fill_char; |
23723
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
797 |
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
798 // String printed before echoed commands (enabled by --echo-commands). |
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
799 std::string m_PS4; |
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
800 |
25360
bc5f225bc578
eliminate some global accesses to the breakpoint table
John W. Eaton <jwe@octave.org>
parents:
25317
diff
changeset
|
801 // If > 0, stop executing at the (N-1)th stopping point, counting |
bc5f225bc578
eliminate some global accesses to the breakpoint table
John W. Eaton <jwe@octave.org>
parents:
25317
diff
changeset
|
802 // from the the current execution point in the current frame. |
bc5f225bc578
eliminate some global accesses to the breakpoint table
John W. Eaton <jwe@octave.org>
parents:
25317
diff
changeset
|
803 // |
bc5f225bc578
eliminate some global accesses to the breakpoint table
John W. Eaton <jwe@octave.org>
parents:
25317
diff
changeset
|
804 // If < 0, stop executing at the next possible stopping point. |
bc5f225bc578
eliminate some global accesses to the breakpoint table
John W. Eaton <jwe@octave.org>
parents:
25317
diff
changeset
|
805 int m_dbstep_flag; |
bc5f225bc578
eliminate some global accesses to the breakpoint table
John W. Eaton <jwe@octave.org>
parents:
25317
diff
changeset
|
806 |
23723
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
807 // Echo commands as they are executed? |
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
808 // |
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
809 // 1 ==> echo commands read from script files |
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
810 // 2 ==> echo commands from functions |
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
811 // |
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
812 // more than one state can be active at once. |
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
813 int m_echo; |
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
814 |
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
815 // Are we currently echoing commands? This state is set by the |
27956
2310164737b3
fix many spelling errors (bug #57613)
John W. Eaton <jwe@octave.org>
parents:
26376
diff
changeset
|
816 // functions that execute functions and scripts. |
23723
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
817 bool m_echo_state; |
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
818 |
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
819 std::string m_echo_file_name; |
23728
b40b7243a782
new class for caching file contents for debug and echo
John W. Eaton <jwe@octave.org>
parents:
23723
diff
changeset
|
820 |
b40b7243a782
new class for caching file contents for debug and echo
John W. Eaton <jwe@octave.org>
parents:
23723
diff
changeset
|
821 // Next line to echo, counting from 1. |
23723
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
822 size_t m_echo_file_pos; |
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
823 |
ab8831d346c1
revamp echo command and move related variables inside tree_evaluator class
John W. Eaton <jwe@octave.org>
parents:
23706
diff
changeset
|
824 std::map<std::string, bool> m_echo_files; |
25360
bc5f225bc578
eliminate some global accesses to the breakpoint table
John W. Eaton <jwe@octave.org>
parents:
25317
diff
changeset
|
825 |
bc5f225bc578
eliminate some global accesses to the breakpoint table
John W. Eaton <jwe@octave.org>
parents:
25317
diff
changeset
|
826 // TRUE means we are evaluating some kind of looping construct. |
bc5f225bc578
eliminate some global accesses to the breakpoint table
John W. Eaton <jwe@octave.org>
parents:
25317
diff
changeset
|
827 bool m_in_loop_command; |
25382
749d9e858553
move convert_to_const_vector from tree_argument_list to tree_evaluator
John W. Eaton <jwe@octave.org>
parents:
25381
diff
changeset
|
828 |
25403
2b7d7a3f5f57
move returning, breaking, and continuing flags to evaluator
John W. Eaton <jwe@octave.org>
parents:
25402
diff
changeset
|
829 // Nonzero means we're breaking out of a loop or function body. |
2b7d7a3f5f57
move returning, breaking, and continuing flags to evaluator
John W. Eaton <jwe@octave.org>
parents:
25402
diff
changeset
|
830 int m_breaking; |
2b7d7a3f5f57
move returning, breaking, and continuing flags to evaluator
John W. Eaton <jwe@octave.org>
parents:
25402
diff
changeset
|
831 |
2b7d7a3f5f57
move returning, breaking, and continuing flags to evaluator
John W. Eaton <jwe@octave.org>
parents:
25402
diff
changeset
|
832 // Nonzero means we're jumping to the end of a loop. |
2b7d7a3f5f57
move returning, breaking, and continuing flags to evaluator
John W. Eaton <jwe@octave.org>
parents:
25402
diff
changeset
|
833 int m_continuing; |
2b7d7a3f5f57
move returning, breaking, and continuing flags to evaluator
John W. Eaton <jwe@octave.org>
parents:
25402
diff
changeset
|
834 |
2b7d7a3f5f57
move returning, breaking, and continuing flags to evaluator
John W. Eaton <jwe@octave.org>
parents:
25402
diff
changeset
|
835 // Nonzero means we're returning from a function. |
2b7d7a3f5f57
move returning, breaking, and continuing flags to evaluator
John W. Eaton <jwe@octave.org>
parents:
25402
diff
changeset
|
836 int m_returning; |
2b7d7a3f5f57
move returning, breaking, and continuing flags to evaluator
John W. Eaton <jwe@octave.org>
parents:
25402
diff
changeset
|
837 |
25382
749d9e858553
move convert_to_const_vector from tree_argument_list to tree_evaluator
John W. Eaton <jwe@octave.org>
parents:
25381
diff
changeset
|
838 // Used by END function. |
749d9e858553
move convert_to_const_vector from tree_argument_list to tree_evaluator
John W. Eaton <jwe@octave.org>
parents:
25381
diff
changeset
|
839 const octave_value *m_indexed_object; |
749d9e858553
move convert_to_const_vector from tree_argument_list to tree_evaluator
John W. Eaton <jwe@octave.org>
parents:
25381
diff
changeset
|
840 int m_index_position; |
749d9e858553
move convert_to_const_vector from tree_argument_list to tree_evaluator
John W. Eaton <jwe@octave.org>
parents:
25381
diff
changeset
|
841 int m_num_indices; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21244
diff
changeset
|
842 }; |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21244
diff
changeset
|
843 } |
8658
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
diff
changeset
|
844 |
73c4516fae10
New evaluator and debugger derived from tree-walker class
John W. Eaton <jwe@octave.org>
parents:
diff
changeset
|
845 #endif |