Mercurial > octave
annotate libinterp/parse-tree/parse.h @ 28698:d45d1b4bb919 stable
allow functions to be redefined in scripts (bug #52851)
* parse.h, oct-parse.yy (base_parser::parent_scope_info::m_parser):
New data member to allow access to parent parser object. Update
constructor and use.
(base_parser::parent_scope_info::name_ok): Only fail when a duplicate
is found if parsing a subfunction, local function, or nested function.
(base_parser::parsing_subfunctions, base_parser::curr_fcn_depth):
Provide access to the corresponding member variables.
* test/bug-52851/bug-52851.tst, test/bug-52851/script1.m,
test/bug-52851/script2.m, test/bug-52851/script3.m,
test/bug-52851/script4.m: New test files.
* test/bug-52851/module.mk: New file.
* test/module.mk b/test/module.mk: Update.
author | John W. Eaton <jwe@octave.org> |
---|---|
date | Wed, 09 Sep 2020 13:41:46 -0400 |
parents | 59dfd9ed72a3 |
children | 61a089ada620 45d958bc3437 |
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) 1993-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 //////////////////////////////////////////////////////////////////////// |
1 | 25 |
20791
f7084eae3318
maint: Use Octave coding conventions for #if statements.
Rik <rik@octave.org>
parents:
19697
diff
changeset
|
26 #if ! defined (octave_parse_h) |
383 | 27 #define octave_parse_h 1 |
1 | 28 |
21244
1473547f50f5
include octave-config.h in public header files
John W. Eaton <jwe@octave.org>
parents:
21139
diff
changeset
|
29 #include "octave-config.h" |
1473547f50f5
include octave-config.h in public header files
John W. Eaton <jwe@octave.org>
parents:
21139
diff
changeset
|
30 |
3021 | 31 #include <cstdio> |
32 | |
23054
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
33 #include <deque> |
16153
a57c2c8c8163
move some variables into the octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16149
diff
changeset
|
34 #include <map> |
27504
7a31b25e3252
use shared_ptr for storing classdef and statement_list objects in parser
John W. Eaton <jwe@octave.org>
parents:
27016
diff
changeset
|
35 #include <memory> |
23054
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
36 #include <set> |
27504
7a31b25e3252
use shared_ptr for storing classdef and statement_list objects in parser
John W. Eaton <jwe@octave.org>
parents:
27016
diff
changeset
|
37 #include <string> |
4426 | 38 |
28266
ce7a5b60e102
restore pull parser interface when input is not interactive (bug #58198)
John W. Eaton <jwe@octave.org>
parents:
27957
diff
changeset
|
39 #include "input.h" |
16139
2fd39ab12209
move a function and data member from lexical_feedback to octave_parser
John W. Eaton <jwe@octave.org>
parents:
16138
diff
changeset
|
40 #include "lex.h" |
23654
da89ce0d49eb
avoid possible memory leak in parser
John W. Eaton <jwe@octave.org>
parents:
23653
diff
changeset
|
41 #include "pt-misc.h" |
24362
3fc24b792a24
avoid including symtab.h, symscope.h, or symrec.h unnecessarily
John W. Eaton <jwe@octave.org>
parents:
24361
diff
changeset
|
42 #include "symscope.h" |
16134
ec9c6222ef5a
move static parser helper functions to octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16133
diff
changeset
|
43 #include "token.h" |
ec9c6222ef5a
move static parser helper functions to octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16133
diff
changeset
|
44 |
ec9c6222ef5a
move static parser helper functions to octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16133
diff
changeset
|
45 class octave_function; |
ec9c6222ef5a
move static parser helper functions to octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16133
diff
changeset
|
46 class octave_user_function; |
23075
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
47 |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
48 namespace octave |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
49 { |
23750
ea879bc55272
move comment_list and comment_elt classes to octave namespace
John W. Eaton <jwe@octave.org>
parents:
23696
diff
changeset
|
50 class comment_list; |
23075
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
51 class tree; |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
52 class tree_anon_fcn_handle; |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
53 class tree_argument_list; |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
54 class tree_array_list; |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
55 class tree_cell; |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
56 class tree_classdef; |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
57 class tree_classdef_attribute_list; |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
58 class tree_classdef_body; |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
59 class tree_classdef_enum_block; |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
60 class tree_classdef_enum_list; |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
61 class tree_classdef_events_block; |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
62 class tree_classdef_events_list; |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
63 class tree_classdef_methods_block; |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
64 class tree_classdef_methods_list; |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
65 class tree_classdef_properties_block; |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
66 class tree_classdef_property_list; |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
67 class tree_classdef_superclass_list; |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
68 class tree_colon_expression; |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
69 class tree_command; |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
70 class tree_constant; |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
71 class tree_decl_command; |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
72 class tree_decl_init_list; |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
73 class tree_expression; |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
74 class tree_fcn_handle; |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
75 class tree_function_def; |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
76 class tree_identifier; |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
77 class tree_if_clause; |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
78 class tree_if_command; |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
79 class tree_if_command_list; |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
80 class tree_index_expression; |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
81 class tree_matrix; |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
82 class tree_matrix; |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
83 class tree_parameter_list; |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
84 class tree_statement; |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
85 class tree_statement_list; |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
86 class tree_statement_listtree_statement; |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
87 class tree_switch_case; |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
88 class tree_switch_case_list; |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
89 class tree_switch_command; |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
90 } |
3772 | 91 |
20940
48b2ad5ee801
maint: Rename oct-obj.[cc|h] to ovl.[cc|h] for clarity.
Rik <rik@octave.org>
parents:
20791
diff
changeset
|
92 #include "ovl.h" |
1 | 93 |
94 // Nonzero means print parser debugging info (-d). | |
4753 | 95 extern int octave_debug; |
1 | 96 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
97 namespace octave |
16133
249d62b3fac8
new class for parser state
John W. Eaton <jwe@octave.org>
parents:
16122
diff
changeset
|
98 { |
23694
4a62da62af09
use m_ prefix for member variables in parser
John W. Eaton <jwe@octave.org>
parents:
23673
diff
changeset
|
99 class base_parser |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
100 { |
23054
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
101 private: |
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
102 |
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
103 class parent_scope_info |
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
104 { |
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
105 public: |
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
106 |
24361
8bcfddad15ec
use shared_ptr to manage symbol_scope objects
John W. Eaton <jwe@octave.org>
parents:
24270
diff
changeset
|
107 typedef std::pair<symbol_scope, std::string> value_type; |
23054
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
108 |
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
109 typedef std::deque<value_type>::iterator iterator; |
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
110 typedef std::deque<value_type>::const_iterator const_iterator; |
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
111 |
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
112 typedef std::deque<value_type>::reverse_iterator reverse_iterator; |
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
113 typedef std::deque<value_type>::const_reverse_iterator const_reverse_iterator; |
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
114 |
28698
d45d1b4bb919
allow functions to be redefined in scripts (bug #52851)
John W. Eaton <jwe@octave.org>
parents:
28511
diff
changeset
|
115 parent_scope_info (void) = delete; |
d45d1b4bb919
allow functions to be redefined in scripts (bug #52851)
John W. Eaton <jwe@octave.org>
parents:
28511
diff
changeset
|
116 |
d45d1b4bb919
allow functions to be redefined in scripts (bug #52851)
John W. Eaton <jwe@octave.org>
parents:
28511
diff
changeset
|
117 parent_scope_info (base_parser& parser) |
d45d1b4bb919
allow functions to be redefined in scripts (bug #52851)
John W. Eaton <jwe@octave.org>
parents:
28511
diff
changeset
|
118 : m_parser (parser), m_info (), m_all_names () |
d45d1b4bb919
allow functions to be redefined in scripts (bug #52851)
John W. Eaton <jwe@octave.org>
parents:
28511
diff
changeset
|
119 { } |
23054
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
120 |
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
121 parent_scope_info (const parent_scope_info&) = default; |
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
122 |
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
123 parent_scope_info& operator = (const parent_scope_info&) = default; |
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
124 |
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
125 ~parent_scope_info (void) = default; |
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
126 |
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
127 size_t size (void) const; |
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
128 |
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
129 void push (const value_type& elt); |
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
130 |
24361
8bcfddad15ec
use shared_ptr to manage symbol_scope objects
John W. Eaton <jwe@octave.org>
parents:
24270
diff
changeset
|
131 void push (const symbol_scope& id); |
23054
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
132 |
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
133 void pop (void); |
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
134 |
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
135 bool name_ok (const std::string& name); |
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
136 |
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
137 bool name_current_scope (const std::string& name); |
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
138 |
24361
8bcfddad15ec
use shared_ptr to manage symbol_scope objects
John W. Eaton <jwe@octave.org>
parents:
24270
diff
changeset
|
139 symbol_scope parent_scope (void) const; |
23054
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
140 |
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
141 std::string parent_name (void) const; |
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
142 |
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
143 void clear (void); |
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
144 |
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
145 private: |
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
146 |
28698
d45d1b4bb919
allow functions to be redefined in scripts (bug #52851)
John W. Eaton <jwe@octave.org>
parents:
28511
diff
changeset
|
147 base_parser& m_parser; |
23694
4a62da62af09
use m_ prefix for member variables in parser
John W. Eaton <jwe@octave.org>
parents:
23673
diff
changeset
|
148 std::deque<value_type> m_info; |
4a62da62af09
use m_ prefix for member variables in parser
John W. Eaton <jwe@octave.org>
parents:
23673
diff
changeset
|
149 std::set<std::string> m_all_names; |
23054
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
150 }; |
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
151 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
152 public: |
16195
b52d2f9294b6
use class for reading lexer input
John W. Eaton <jwe@octave.org>
parents:
16177
diff
changeset
|
153 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
154 base_parser (base_lexer& lxr); |
16157
335041cc657a
optionally use push parser interface
John W. Eaton <jwe@octave.org>
parents:
16153
diff
changeset
|
155 |
22869
f75d289645ec
make deleted functions public
John W. Eaton <jwe@octave.org>
parents:
22868
diff
changeset
|
156 // No copying! |
f75d289645ec
make deleted functions public
John W. Eaton <jwe@octave.org>
parents:
22868
diff
changeset
|
157 |
f75d289645ec
make deleted functions public
John W. Eaton <jwe@octave.org>
parents:
22868
diff
changeset
|
158 base_parser (const base_parser&) = delete; |
f75d289645ec
make deleted functions public
John W. Eaton <jwe@octave.org>
parents:
22868
diff
changeset
|
159 |
f75d289645ec
make deleted functions public
John W. Eaton <jwe@octave.org>
parents:
22868
diff
changeset
|
160 base_parser& operator = (const base_parser&) = delete; |
f75d289645ec
make deleted functions public
John W. Eaton <jwe@octave.org>
parents:
22868
diff
changeset
|
161 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
162 ~base_parser (void); |
16139
2fd39ab12209
move a function and data member from lexical_feedback to octave_parser
John W. Eaton <jwe@octave.org>
parents:
16138
diff
changeset
|
163 |
27510
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
164 base_lexer& get_lexer (void) const { return m_lexer; } |
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
165 |
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
166 bool at_end_of_input (void) const { return m_lexer.m_end_of_input; } |
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
167 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
168 void reset (void); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
169 |
27504
7a31b25e3252
use shared_ptr for storing classdef and statement_list objects in parser
John W. Eaton <jwe@octave.org>
parents:
27016
diff
changeset
|
170 void classdef_object (const std::shared_ptr<tree_classdef>& obj) |
7a31b25e3252
use shared_ptr for storing classdef and statement_list objects in parser
John W. Eaton <jwe@octave.org>
parents:
27016
diff
changeset
|
171 { |
7a31b25e3252
use shared_ptr for storing classdef and statement_list objects in parser
John W. Eaton <jwe@octave.org>
parents:
27016
diff
changeset
|
172 m_classdef_object = obj; |
7a31b25e3252
use shared_ptr for storing classdef and statement_list objects in parser
John W. Eaton <jwe@octave.org>
parents:
27016
diff
changeset
|
173 } |
7a31b25e3252
use shared_ptr for storing classdef and statement_list objects in parser
John W. Eaton <jwe@octave.org>
parents:
27016
diff
changeset
|
174 |
7a31b25e3252
use shared_ptr for storing classdef and statement_list objects in parser
John W. Eaton <jwe@octave.org>
parents:
27016
diff
changeset
|
175 std::shared_ptr<tree_classdef> classdef_object (void) const |
7a31b25e3252
use shared_ptr for storing classdef and statement_list objects in parser
John W. Eaton <jwe@octave.org>
parents:
27016
diff
changeset
|
176 { |
7a31b25e3252
use shared_ptr for storing classdef and statement_list objects in parser
John W. Eaton <jwe@octave.org>
parents:
27016
diff
changeset
|
177 return m_classdef_object; |
7a31b25e3252
use shared_ptr for storing classdef and statement_list objects in parser
John W. Eaton <jwe@octave.org>
parents:
27016
diff
changeset
|
178 } |
7a31b25e3252
use shared_ptr for storing classdef and statement_list objects in parser
John W. Eaton <jwe@octave.org>
parents:
27016
diff
changeset
|
179 |
28407
808e3964987b
accept multi-line interactive input (bug #58370)
John W. Eaton <jwe@octave.org>
parents:
28266
diff
changeset
|
180 void statement_list (std::shared_ptr<tree_statement_list>& lst); |
27504
7a31b25e3252
use shared_ptr for storing classdef and statement_list objects in parser
John W. Eaton <jwe@octave.org>
parents:
27016
diff
changeset
|
181 |
7a31b25e3252
use shared_ptr for storing classdef and statement_list objects in parser
John W. Eaton <jwe@octave.org>
parents:
27016
diff
changeset
|
182 std::shared_ptr<tree_statement_list> statement_list (void) const |
7a31b25e3252
use shared_ptr for storing classdef and statement_list objects in parser
John W. Eaton <jwe@octave.org>
parents:
27016
diff
changeset
|
183 { |
7a31b25e3252
use shared_ptr for storing classdef and statement_list objects in parser
John W. Eaton <jwe@octave.org>
parents:
27016
diff
changeset
|
184 return m_stmt_list; |
7a31b25e3252
use shared_ptr for storing classdef and statement_list objects in parser
John W. Eaton <jwe@octave.org>
parents:
27016
diff
changeset
|
185 } |
7a31b25e3252
use shared_ptr for storing classdef and statement_list objects in parser
John W. Eaton <jwe@octave.org>
parents:
27016
diff
changeset
|
186 |
28698
d45d1b4bb919
allow functions to be redefined in scripts (bug #52851)
John W. Eaton <jwe@octave.org>
parents:
28511
diff
changeset
|
187 void parsing_subfunctions (bool flag) |
d45d1b4bb919
allow functions to be redefined in scripts (bug #52851)
John W. Eaton <jwe@octave.org>
parents:
28511
diff
changeset
|
188 { |
d45d1b4bb919
allow functions to be redefined in scripts (bug #52851)
John W. Eaton <jwe@octave.org>
parents:
28511
diff
changeset
|
189 m_parsing_subfunctions = flag; |
d45d1b4bb919
allow functions to be redefined in scripts (bug #52851)
John W. Eaton <jwe@octave.org>
parents:
28511
diff
changeset
|
190 } |
d45d1b4bb919
allow functions to be redefined in scripts (bug #52851)
John W. Eaton <jwe@octave.org>
parents:
28511
diff
changeset
|
191 |
d45d1b4bb919
allow functions to be redefined in scripts (bug #52851)
John W. Eaton <jwe@octave.org>
parents:
28511
diff
changeset
|
192 bool parsing_subfunctions (void) const |
d45d1b4bb919
allow functions to be redefined in scripts (bug #52851)
John W. Eaton <jwe@octave.org>
parents:
28511
diff
changeset
|
193 { |
d45d1b4bb919
allow functions to be redefined in scripts (bug #52851)
John W. Eaton <jwe@octave.org>
parents:
28511
diff
changeset
|
194 return m_parsing_subfunctions; |
d45d1b4bb919
allow functions to be redefined in scripts (bug #52851)
John W. Eaton <jwe@octave.org>
parents:
28511
diff
changeset
|
195 } |
d45d1b4bb919
allow functions to be redefined in scripts (bug #52851)
John W. Eaton <jwe@octave.org>
parents:
28511
diff
changeset
|
196 |
27510
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
197 void parsing_local_functions (bool flag) |
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
198 { |
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
199 m_parsing_local_functions = flag; |
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
200 } |
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
201 |
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
202 bool parsing_local_functions (void) const |
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
203 { |
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
204 return m_parsing_local_functions; |
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
205 } |
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
206 |
28698
d45d1b4bb919
allow functions to be redefined in scripts (bug #52851)
John W. Eaton <jwe@octave.org>
parents:
28511
diff
changeset
|
207 int curr_fcn_depth (void) const |
d45d1b4bb919
allow functions to be redefined in scripts (bug #52851)
John W. Eaton <jwe@octave.org>
parents:
28511
diff
changeset
|
208 { |
d45d1b4bb919
allow functions to be redefined in scripts (bug #52851)
John W. Eaton <jwe@octave.org>
parents:
28511
diff
changeset
|
209 return m_curr_fcn_depth; |
d45d1b4bb919
allow functions to be redefined in scripts (bug #52851)
John W. Eaton <jwe@octave.org>
parents:
28511
diff
changeset
|
210 } |
d45d1b4bb919
allow functions to be redefined in scripts (bug #52851)
John W. Eaton <jwe@octave.org>
parents:
28511
diff
changeset
|
211 |
27510
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
212 void endfunction_found (bool flag) |
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
213 { |
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
214 m_endfunction_found = flag; |
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
215 } |
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
216 |
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
217 bool endfunction_found (void) const |
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
218 { |
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
219 return m_endfunction_found; |
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
220 } |
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
221 |
27956
2310164737b3
fix many spelling errors (bug #57613)
John W. Eaton <jwe@octave.org>
parents:
26512
diff
changeset
|
222 // Error messages for mismatched end tokens. |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
223 void end_token_error (token *tok, token::end_tok_type expected); |
16134
ec9c6222ef5a
move static parser helper functions to octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16133
diff
changeset
|
224 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
225 // Check to see that end tokens are properly matched. |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
226 bool end_token_ok (token *tok, token::end_tok_type expected); |
16134
ec9c6222ef5a
move static parser helper functions to octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16133
diff
changeset
|
227 |
27510
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
228 // Handle pushing symbol table for new function scope. |
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
229 bool push_fcn_symtab (void); |
16134
ec9c6222ef5a
move static parser helper functions to octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16133
diff
changeset
|
230 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
231 // Build a constant. |
23446
cd4e1ee28716
maint: Use convention 'void * fcn ()' for functions which return pointers.
Rik <rik@octave.org>
parents:
23343
diff
changeset
|
232 tree_constant * make_constant (int op, token *tok_val); |
16134
ec9c6222ef5a
move static parser helper functions to octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16133
diff
changeset
|
233 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
234 // Build a function handle. |
23446
cd4e1ee28716
maint: Use convention 'void * fcn ()' for functions which return pointers.
Rik <rik@octave.org>
parents:
23343
diff
changeset
|
235 tree_fcn_handle * make_fcn_handle (token *tok_val); |
16134
ec9c6222ef5a
move static parser helper functions to octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16133
diff
changeset
|
236 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
237 // Build an anonymous function handle. |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
238 tree_anon_fcn_handle * |
23600
db947ba52118
explicitly limit anonymous functions to a single expression
John W. Eaton <jwe@octave.org>
parents:
23502
diff
changeset
|
239 make_anon_fcn_handle (tree_parameter_list *param_list, |
27778
2f8559459314
store beginning and ending location info for tokens recognized by lexer
John W. Eaton <jwe@octave.org>
parents:
27764
diff
changeset
|
240 tree_expression * expr, const filepos& at_pos); |
16134
ec9c6222ef5a
move static parser helper functions to octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16133
diff
changeset
|
241 |
23655
bbcc1e08aaed
improve colon expression construction and avoid possible memory leak
John W. Eaton <jwe@octave.org>
parents:
23654
diff
changeset
|
242 // Build a colon expression. |
bbcc1e08aaed
improve colon expression construction and avoid possible memory leak
John W. Eaton <jwe@octave.org>
parents:
23654
diff
changeset
|
243 tree_expression * |
bbcc1e08aaed
improve colon expression construction and avoid possible memory leak
John W. Eaton <jwe@octave.org>
parents:
23654
diff
changeset
|
244 make_colon_expression (tree_expression *base, tree_expression *limit, |
bbcc1e08aaed
improve colon expression construction and avoid possible memory leak
John W. Eaton <jwe@octave.org>
parents:
23654
diff
changeset
|
245 tree_expression *incr = nullptr); |
bbcc1e08aaed
improve colon expression construction and avoid possible memory leak
John W. Eaton <jwe@octave.org>
parents:
23654
diff
changeset
|
246 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
247 // Build a binary expression. |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
248 tree_expression * |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
249 make_binary_op (int op, tree_expression *op1, token *tok_val, |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
250 tree_expression *op2); |
16134
ec9c6222ef5a
move static parser helper functions to octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16133
diff
changeset
|
251 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
252 // Build a boolean expression. |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
253 tree_expression * |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
254 make_boolean_op (int op, tree_expression *op1, token *tok_val, |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
255 tree_expression *op2); |
16134
ec9c6222ef5a
move static parser helper functions to octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16133
diff
changeset
|
256 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
257 // Build a prefix expression. |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
258 tree_expression * |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
259 make_prefix_op (int op, tree_expression *op1, token *tok_val); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
260 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
261 // Build a postfix expression. |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
262 tree_expression * |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
263 make_postfix_op (int op, tree_expression *op1, token *tok_val); |
16134
ec9c6222ef5a
move static parser helper functions to octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16133
diff
changeset
|
264 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
265 // Build an unwind-protect command. |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
266 tree_command * |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
267 make_unwind_command (token *unwind_tok, tree_statement_list *body, |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
268 tree_statement_list *cleanup, token *end_tok, |
23750
ea879bc55272
move comment_list and comment_elt classes to octave namespace
John W. Eaton <jwe@octave.org>
parents:
23696
diff
changeset
|
269 comment_list *lc, comment_list *mc); |
16134
ec9c6222ef5a
move static parser helper functions to octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16133
diff
changeset
|
270 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
271 // Build a try-catch command. |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
272 tree_command * |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
273 make_try_command (token *try_tok, tree_statement_list *body, |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
274 char catch_sep, tree_statement_list *cleanup, |
23750
ea879bc55272
move comment_list and comment_elt classes to octave namespace
John W. Eaton <jwe@octave.org>
parents:
23696
diff
changeset
|
275 token *end_tok, comment_list *lc, |
ea879bc55272
move comment_list and comment_elt classes to octave namespace
John W. Eaton <jwe@octave.org>
parents:
23696
diff
changeset
|
276 comment_list *mc); |
16134
ec9c6222ef5a
move static parser helper functions to octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16133
diff
changeset
|
277 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
278 // Build a while command. |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
279 tree_command * |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
280 make_while_command (token *while_tok, tree_expression *expr, |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
281 tree_statement_list *body, token *end_tok, |
23750
ea879bc55272
move comment_list and comment_elt classes to octave namespace
John W. Eaton <jwe@octave.org>
parents:
23696
diff
changeset
|
282 comment_list *lc); |
16134
ec9c6222ef5a
move static parser helper functions to octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16133
diff
changeset
|
283 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
284 // Build a do-until command. |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
285 tree_command * |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
286 make_do_until_command (token *until_tok, tree_statement_list *body, |
23750
ea879bc55272
move comment_list and comment_elt classes to octave namespace
John W. Eaton <jwe@octave.org>
parents:
23696
diff
changeset
|
287 tree_expression *expr, comment_list *lc); |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
288 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
289 // Build a for command. |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
290 tree_command * |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
291 make_for_command (int tok_id, token *for_tok, tree_argument_list *lhs, |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
292 tree_expression *expr, tree_expression *maxproc, |
16134
ec9c6222ef5a
move static parser helper functions to octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16133
diff
changeset
|
293 tree_statement_list *body, token *end_tok, |
23750
ea879bc55272
move comment_list and comment_elt classes to octave namespace
John W. Eaton <jwe@octave.org>
parents:
23696
diff
changeset
|
294 comment_list *lc); |
16134
ec9c6222ef5a
move static parser helper functions to octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16133
diff
changeset
|
295 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
296 // Build a break command. |
23446
cd4e1ee28716
maint: Use convention 'void * fcn ()' for functions which return pointers.
Rik <rik@octave.org>
parents:
23343
diff
changeset
|
297 tree_command * make_break_command (token *break_tok); |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
298 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
299 // Build a continue command. |
23446
cd4e1ee28716
maint: Use convention 'void * fcn ()' for functions which return pointers.
Rik <rik@octave.org>
parents:
23343
diff
changeset
|
300 tree_command * make_continue_command (token *continue_tok); |
16134
ec9c6222ef5a
move static parser helper functions to octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16133
diff
changeset
|
301 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
302 // Build a return command. |
23446
cd4e1ee28716
maint: Use convention 'void * fcn ()' for functions which return pointers.
Rik <rik@octave.org>
parents:
23343
diff
changeset
|
303 tree_command * make_return_command (token *return_tok); |
16134
ec9c6222ef5a
move static parser helper functions to octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16133
diff
changeset
|
304 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
305 // Start an if command. |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
306 tree_if_command_list * |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
307 start_if_command (tree_expression *expr, tree_statement_list *list); |
16134
ec9c6222ef5a
move static parser helper functions to octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16133
diff
changeset
|
308 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
309 // Finish an if command. |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
310 tree_if_command * |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
311 finish_if_command (token *if_tok, tree_if_command_list *list, |
23750
ea879bc55272
move comment_list and comment_elt classes to octave namespace
John W. Eaton <jwe@octave.org>
parents:
23696
diff
changeset
|
312 token *end_tok, comment_list *lc); |
16134
ec9c6222ef5a
move static parser helper functions to octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16133
diff
changeset
|
313 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
314 // Build an elseif clause. |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
315 tree_if_clause * |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
316 make_elseif_clause (token *elseif_tok, tree_expression *expr, |
23750
ea879bc55272
move comment_list and comment_elt classes to octave namespace
John W. Eaton <jwe@octave.org>
parents:
23696
diff
changeset
|
317 tree_statement_list *list, comment_list *lc); |
16134
ec9c6222ef5a
move static parser helper functions to octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16133
diff
changeset
|
318 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
319 // Finish a switch command. |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
320 tree_switch_command * |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
321 finish_switch_command (token *switch_tok, tree_expression *expr, |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
322 tree_switch_case_list *list, token *end_tok, |
23750
ea879bc55272
move comment_list and comment_elt classes to octave namespace
John W. Eaton <jwe@octave.org>
parents:
23696
diff
changeset
|
323 comment_list *lc); |
16134
ec9c6222ef5a
move static parser helper functions to octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16133
diff
changeset
|
324 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
325 // Build a switch case. |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
326 tree_switch_case * |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
327 make_switch_case (token *case_tok, tree_expression *expr, |
23750
ea879bc55272
move comment_list and comment_elt classes to octave namespace
John W. Eaton <jwe@octave.org>
parents:
23696
diff
changeset
|
328 tree_statement_list *list, comment_list *lc); |
16134
ec9c6222ef5a
move static parser helper functions to octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16133
diff
changeset
|
329 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
330 // Build an assignment to a variable. |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
331 tree_expression * |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
332 make_assign_op (int op, tree_argument_list *lhs, token *eq_tok, |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
333 tree_expression *rhs); |
16134
ec9c6222ef5a
move static parser helper functions to octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16133
diff
changeset
|
334 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
335 // Define a script. |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
336 void make_script (tree_statement_list *cmds, tree_statement *end_script); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
337 |
27510
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
338 // Handle identifier that is recognized as a function name. |
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
339 tree_identifier * |
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
340 make_fcn_name (tree_identifier *id); |
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
341 |
23673
1d1ce4df5255
refactor bison rules for parsing functions
John W. Eaton <jwe@octave.org>
parents:
23655
diff
changeset
|
342 // Define a function. |
1d1ce4df5255
refactor bison rules for parsing functions
John W. Eaton <jwe@octave.org>
parents:
23655
diff
changeset
|
343 tree_function_def * |
1d1ce4df5255
refactor bison rules for parsing functions
John W. Eaton <jwe@octave.org>
parents:
23655
diff
changeset
|
344 make_function (token *fcn_tok, tree_parameter_list *ret_list, |
1d1ce4df5255
refactor bison rules for parsing functions
John W. Eaton <jwe@octave.org>
parents:
23655
diff
changeset
|
345 tree_identifier *id, tree_parameter_list *param_list, |
1d1ce4df5255
refactor bison rules for parsing functions
John W. Eaton <jwe@octave.org>
parents:
23655
diff
changeset
|
346 tree_statement_list *body, tree_statement *end_fcn_stmt, |
23750
ea879bc55272
move comment_list and comment_elt classes to octave namespace
John W. Eaton <jwe@octave.org>
parents:
23696
diff
changeset
|
347 comment_list *lc); |
23673
1d1ce4df5255
refactor bison rules for parsing functions
John W. Eaton <jwe@octave.org>
parents:
23655
diff
changeset
|
348 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
349 // Begin defining a function. |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
350 octave_user_function * |
23673
1d1ce4df5255
refactor bison rules for parsing functions
John W. Eaton <jwe@octave.org>
parents:
23655
diff
changeset
|
351 start_function (tree_identifier *id, tree_parameter_list *param_list, |
1d1ce4df5255
refactor bison rules for parsing functions
John W. Eaton <jwe@octave.org>
parents:
23655
diff
changeset
|
352 tree_statement_list *body, tree_statement *end_function); |
16134
ec9c6222ef5a
move static parser helper functions to octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16133
diff
changeset
|
353 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
354 // Create a no-op statement for end_function. |
27778
2f8559459314
store beginning and ending location info for tokens recognized by lexer
John W. Eaton <jwe@octave.org>
parents:
27764
diff
changeset
|
355 tree_statement * make_end (const std::string& type, bool eof, |
2f8559459314
store beginning and ending location info for tokens recognized by lexer
John W. Eaton <jwe@octave.org>
parents:
27764
diff
changeset
|
356 const filepos& beg_pos, const filepos& end_pos); |
16134
ec9c6222ef5a
move static parser helper functions to octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16133
diff
changeset
|
357 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
358 // Do most of the work for defining a function. |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
359 octave_user_function * |
23673
1d1ce4df5255
refactor bison rules for parsing functions
John W. Eaton <jwe@octave.org>
parents:
23655
diff
changeset
|
360 frob_function (tree_identifier *id, octave_user_function *fcn); |
16134
ec9c6222ef5a
move static parser helper functions to octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16133
diff
changeset
|
361 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
362 // Finish defining a function. |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
363 tree_function_def * |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
364 finish_function (tree_parameter_list *ret_list, |
23750
ea879bc55272
move comment_list and comment_elt classes to octave namespace
John W. Eaton <jwe@octave.org>
parents:
23696
diff
changeset
|
365 octave_user_function *fcn, comment_list *lc, |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
366 int l, int c); |
16134
ec9c6222ef5a
move static parser helper functions to octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16133
diff
changeset
|
367 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
368 // Reset state after parsing function. |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
369 void |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
370 recover_from_parsing_function (void); |
16134
ec9c6222ef5a
move static parser helper functions to octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16133
diff
changeset
|
371 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
372 tree_classdef * |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
373 make_classdef (token *tok_val, tree_classdef_attribute_list *a, |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
374 tree_identifier *id, tree_classdef_superclass_list *sc, |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
375 tree_classdef_body *body, token *end_tok, |
28511
59dfd9ed72a3
capture comments for classdef classes, properties, events, and enumerations
John W. Eaton <jwe@octave.org>
parents:
28407
diff
changeset
|
376 comment_list *lc, comment_list *tc); |
16155
0259254a3ccc
maint: periodic merge of default to classdef
John W. Eaton <jwe@octave.org>
parents:
16153
diff
changeset
|
377 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
378 tree_classdef_properties_block * |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
379 make_classdef_properties_block (token *tok_val, |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
380 tree_classdef_attribute_list *a, |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
381 tree_classdef_property_list *plist, |
28511
59dfd9ed72a3
capture comments for classdef classes, properties, events, and enumerations
John W. Eaton <jwe@octave.org>
parents:
28407
diff
changeset
|
382 token *end_tok, comment_list *lc, |
59dfd9ed72a3
capture comments for classdef classes, properties, events, and enumerations
John W. Eaton <jwe@octave.org>
parents:
28407
diff
changeset
|
383 comment_list *tc); |
16155
0259254a3ccc
maint: periodic merge of default to classdef
John W. Eaton <jwe@octave.org>
parents:
16153
diff
changeset
|
384 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
385 tree_classdef_methods_block * |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
386 make_classdef_methods_block (token *tok_val, |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
387 tree_classdef_attribute_list *a, |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
388 tree_classdef_methods_list *mlist, |
28511
59dfd9ed72a3
capture comments for classdef classes, properties, events, and enumerations
John W. Eaton <jwe@octave.org>
parents:
28407
diff
changeset
|
389 token *end_tok, comment_list *lc, |
59dfd9ed72a3
capture comments for classdef classes, properties, events, and enumerations
John W. Eaton <jwe@octave.org>
parents:
28407
diff
changeset
|
390 comment_list *tc); |
16155
0259254a3ccc
maint: periodic merge of default to classdef
John W. Eaton <jwe@octave.org>
parents:
16153
diff
changeset
|
391 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
392 tree_classdef_events_block * |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
393 make_classdef_events_block (token *tok_val, |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
394 tree_classdef_attribute_list *a, |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
395 tree_classdef_events_list *elist, |
28511
59dfd9ed72a3
capture comments for classdef classes, properties, events, and enumerations
John W. Eaton <jwe@octave.org>
parents:
28407
diff
changeset
|
396 token *end_tok, comment_list *lc, |
59dfd9ed72a3
capture comments for classdef classes, properties, events, and enumerations
John W. Eaton <jwe@octave.org>
parents:
28407
diff
changeset
|
397 comment_list *tc); |
16155
0259254a3ccc
maint: periodic merge of default to classdef
John W. Eaton <jwe@octave.org>
parents:
16153
diff
changeset
|
398 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
399 tree_classdef_enum_block * |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
400 make_classdef_enum_block (token *tok_val, |
16155
0259254a3ccc
maint: periodic merge of default to classdef
John W. Eaton <jwe@octave.org>
parents:
16153
diff
changeset
|
401 tree_classdef_attribute_list *a, |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
402 tree_classdef_enum_list *elist, |
28511
59dfd9ed72a3
capture comments for classdef classes, properties, events, and enumerations
John W. Eaton <jwe@octave.org>
parents:
28407
diff
changeset
|
403 token *end_tok, comment_list *lc, |
59dfd9ed72a3
capture comments for classdef classes, properties, events, and enumerations
John W. Eaton <jwe@octave.org>
parents:
28407
diff
changeset
|
404 comment_list *tc); |
16155
0259254a3ccc
maint: periodic merge of default to classdef
John W. Eaton <jwe@octave.org>
parents:
16153
diff
changeset
|
405 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
406 octave_user_function * |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
407 start_classdef_external_method (tree_identifier *id, |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
408 tree_parameter_list *pl); |
16155
0259254a3ccc
maint: periodic merge of default to classdef
John W. Eaton <jwe@octave.org>
parents:
16153
diff
changeset
|
409 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
410 tree_function_def * |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
411 finish_classdef_external_method (octave_user_function *fcn, |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
412 tree_parameter_list *ret_list, |
23750
ea879bc55272
move comment_list and comment_elt classes to octave namespace
John W. Eaton <jwe@octave.org>
parents:
23696
diff
changeset
|
413 comment_list *cl); |
18262
69990d5edcc2
Allow to parse external methods declaration in classdef files.
Michael Goffioul <michael.goffioul@gmail.com>
parents:
17856
diff
changeset
|
414 |
24067
5b88383b9a69
install local functions after classdef parse is complete (bug #52080)
John W. Eaton <jwe@octave.org>
parents:
23750
diff
changeset
|
415 void |
5b88383b9a69
install local functions after classdef parse is complete (bug #52080)
John W. Eaton <jwe@octave.org>
parents:
23750
diff
changeset
|
416 finish_classdef_file (tree_classdef *cls, |
5b88383b9a69
install local functions after classdef parse is complete (bug #52080)
John W. Eaton <jwe@octave.org>
parents:
23750
diff
changeset
|
417 tree_statement_list *local_fcns); |
5b88383b9a69
install local functions after classdef parse is complete (bug #52080)
John W. Eaton <jwe@octave.org>
parents:
23750
diff
changeset
|
418 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
419 // Make an index expression. |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
420 tree_index_expression * |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
421 make_index_expression (tree_expression *expr, |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
422 tree_argument_list *args, char type); |
18262
69990d5edcc2
Allow to parse external methods declaration in classdef files.
Michael Goffioul <michael.goffioul@gmail.com>
parents:
17856
diff
changeset
|
423 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
424 // Make an indirect reference expression. |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
425 tree_index_expression * |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
426 make_indirect_ref (tree_expression *expr, const std::string&); |
16134
ec9c6222ef5a
move static parser helper functions to octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16133
diff
changeset
|
427 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
428 // Make an indirect reference expression with dynamic field name. |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
429 tree_index_expression * |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
430 make_indirect_ref (tree_expression *expr, tree_expression *field); |
16134
ec9c6222ef5a
move static parser helper functions to octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16133
diff
changeset
|
431 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
432 // Make a declaration command. |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
433 tree_decl_command * |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
434 make_decl_command (int tok, token *tok_val, tree_decl_init_list *lst); |
16134
ec9c6222ef5a
move static parser helper functions to octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16133
diff
changeset
|
435 |
23654
da89ce0d49eb
avoid possible memory leak in parser
John W. Eaton <jwe@octave.org>
parents:
23653
diff
changeset
|
436 // Validate an function parameter list. |
da89ce0d49eb
avoid possible memory leak in parser
John W. Eaton <jwe@octave.org>
parents:
23653
diff
changeset
|
437 bool validate_param_list (tree_parameter_list *lst, |
da89ce0d49eb
avoid possible memory leak in parser
John W. Eaton <jwe@octave.org>
parents:
23653
diff
changeset
|
438 tree_parameter_list::in_or_out type); |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
439 // Validate matrix or cell |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
440 bool validate_array_list (tree_expression *e); |
16134
ec9c6222ef5a
move static parser helper functions to octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16133
diff
changeset
|
441 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
442 // Validate matrix object used in "[lhs] = ..." assignments. |
23446
cd4e1ee28716
maint: Use convention 'void * fcn ()' for functions which return pointers.
Rik <rik@octave.org>
parents:
23343
diff
changeset
|
443 tree_argument_list * validate_matrix_for_assignment (tree_expression *e); |
16273
c5e5f6ccac5d
9/10 commits reworking the lexer
John W. Eaton <jwe@octave.org>
parents:
16237
diff
changeset
|
444 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
445 // Finish building an array_list (common action for finish_matrix |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
446 // and finish_cell). |
27764
f64e399b6dda
report missing semicolon location for array expressions (bug #57159)
John W. Eaton <jwe@octave.org>
parents:
27528
diff
changeset
|
447 tree_expression * finish_array_list (tree_array_list *a, token *open_delim, |
f64e399b6dda
report missing semicolon location for array expressions (bug #57159)
John W. Eaton <jwe@octave.org>
parents:
27528
diff
changeset
|
448 token *close_delim); |
16134
ec9c6222ef5a
move static parser helper functions to octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16133
diff
changeset
|
449 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
450 // Finish building a matrix list. |
27764
f64e399b6dda
report missing semicolon location for array expressions (bug #57159)
John W. Eaton <jwe@octave.org>
parents:
27528
diff
changeset
|
451 tree_expression * finish_matrix (tree_matrix *m, token *open_delim, |
f64e399b6dda
report missing semicolon location for array expressions (bug #57159)
John W. Eaton <jwe@octave.org>
parents:
27528
diff
changeset
|
452 token *close_delim); |
16237
70f465930546
rearrange class heirarchy for tree_cell and tree_matrix
John W. Eaton <jwe@octave.org>
parents:
16210
diff
changeset
|
453 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
454 // Finish building a cell list. |
27764
f64e399b6dda
report missing semicolon location for array expressions (bug #57159)
John W. Eaton <jwe@octave.org>
parents:
27528
diff
changeset
|
455 tree_expression * finish_cell (tree_cell *c, token *open_delim, |
f64e399b6dda
report missing semicolon location for array expressions (bug #57159)
John W. Eaton <jwe@octave.org>
parents:
27528
diff
changeset
|
456 token *close_delim); |
16134
ec9c6222ef5a
move static parser helper functions to octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16133
diff
changeset
|
457 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
458 // Set the print flag for a statement based on the separator type. |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
459 tree_statement_list * |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
460 set_stmt_print_flag (tree_statement_list *, char, bool); |
16134
ec9c6222ef5a
move static parser helper functions to octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16133
diff
changeset
|
461 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
462 // Finish building a statement. |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
463 template <typename T> |
23446
cd4e1ee28716
maint: Use convention 'void * fcn ()' for functions which return pointers.
Rik <rik@octave.org>
parents:
23343
diff
changeset
|
464 tree_statement * make_statement (T *arg); |
16134
ec9c6222ef5a
move static parser helper functions to octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16133
diff
changeset
|
465 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
466 // Create a statement list. |
23446
cd4e1ee28716
maint: Use convention 'void * fcn ()' for functions which return pointers.
Rik <rik@octave.org>
parents:
23343
diff
changeset
|
467 tree_statement_list * make_statement_list (tree_statement *stmt); |
17693
efbe746f8fa8
eliminate octave_comment_buffer singleton
John W. Eaton <jwe@octave.org>
parents:
17283
diff
changeset
|
468 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
469 // Append a statement to an existing statement list. |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
470 tree_statement_list * |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
471 append_statement_list (tree_statement_list *list, char sep, |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
472 tree_statement *stmt, bool warn_missing_semi); |
16134
ec9c6222ef5a
move static parser helper functions to octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16133
diff
changeset
|
473 |
26662
05fc703b419a
update handling of command-style function call syntax in eval
John W. Eaton <jwe@octave.org>
parents:
26513
diff
changeset
|
474 // Don't allow parsing command syntax. If the parser/lexer is |
05fc703b419a
update handling of command-style function call syntax in eval
John W. Eaton <jwe@octave.org>
parents:
26513
diff
changeset
|
475 // reset, this setting is also reset to the default (allow command |
05fc703b419a
update handling of command-style function call syntax in eval
John W. Eaton <jwe@octave.org>
parents:
26513
diff
changeset
|
476 // syntax). |
05fc703b419a
update handling of command-style function call syntax in eval
John W. Eaton <jwe@octave.org>
parents:
26513
diff
changeset
|
477 void disallow_command_syntax (void); |
05fc703b419a
update handling of command-style function call syntax in eval
John W. Eaton <jwe@octave.org>
parents:
26513
diff
changeset
|
478 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
479 // Generic error messages. |
27778
2f8559459314
store beginning and ending location info for tokens recognized by lexer
John W. Eaton <jwe@octave.org>
parents:
27764
diff
changeset
|
480 void bison_error (const std::string& s); |
2f8559459314
store beginning and ending location info for tokens recognized by lexer
John W. Eaton <jwe@octave.org>
parents:
27764
diff
changeset
|
481 void bison_error (const std::string& s, const filepos& pos); |
2f8559459314
store beginning and ending location info for tokens recognized by lexer
John W. Eaton <jwe@octave.org>
parents:
27764
diff
changeset
|
482 void bison_error (const std::string& s, int line, int column); |
16134
ec9c6222ef5a
move static parser helper functions to octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16133
diff
changeset
|
483 |
27509
fefc780b4e2e
move parse_fcn_file from interpreter member function to parser friend
John W. Eaton <jwe@octave.org>
parents:
27507
diff
changeset
|
484 friend octave_value |
fefc780b4e2e
move parse_fcn_file from interpreter member function to parser friend
John W. Eaton <jwe@octave.org>
parents:
27507
diff
changeset
|
485 parse_fcn_file (interpreter& interp, const std::string& full_file, |
fefc780b4e2e
move parse_fcn_file from interpreter member function to parser friend
John W. Eaton <jwe@octave.org>
parents:
27507
diff
changeset
|
486 const std::string& file, const std::string& dir_name, |
fefc780b4e2e
move parse_fcn_file from interpreter member function to parser friend
John W. Eaton <jwe@octave.org>
parents:
27507
diff
changeset
|
487 const std::string& dispatch_type, |
fefc780b4e2e
move parse_fcn_file from interpreter member function to parser friend
John W. Eaton <jwe@octave.org>
parents:
27507
diff
changeset
|
488 const std::string& package_name, bool require_file, |
fefc780b4e2e
move parse_fcn_file from interpreter member function to parser friend
John W. Eaton <jwe@octave.org>
parents:
27507
diff
changeset
|
489 bool force_script, bool autoload, bool relative_lookup); |
fefc780b4e2e
move parse_fcn_file from interpreter member function to parser friend
John W. Eaton <jwe@octave.org>
parents:
27507
diff
changeset
|
490 |
28266
ce7a5b60e102
restore pull parser interface when input is not interactive (bug #58198)
John W. Eaton <jwe@octave.org>
parents:
27957
diff
changeset
|
491 // Thih interface allows push or pull parsers to be used |
ce7a5b60e102
restore pull parser interface when input is not interactive (bug #58198)
John W. Eaton <jwe@octave.org>
parents:
27957
diff
changeset
|
492 // equivalently, provided that the push parser also owns its input |
ce7a5b60e102
restore pull parser interface when input is not interactive (bug #58198)
John W. Eaton <jwe@octave.org>
parents:
27957
diff
changeset
|
493 // method (see below). Alternatively, the push parser interface may |
ce7a5b60e102
restore pull parser interface when input is not interactive (bug #58198)
John W. Eaton <jwe@octave.org>
parents:
27957
diff
changeset
|
494 // use a separate run method and completely separate input from |
ce7a5b60e102
restore pull parser interface when input is not interactive (bug #58198)
John W. Eaton <jwe@octave.org>
parents:
27957
diff
changeset
|
495 // lexical analysis and parsing. |
ce7a5b60e102
restore pull parser interface when input is not interactive (bug #58198)
John W. Eaton <jwe@octave.org>
parents:
27957
diff
changeset
|
496 |
ce7a5b60e102
restore pull parser interface when input is not interactive (bug #58198)
John W. Eaton <jwe@octave.org>
parents:
27957
diff
changeset
|
497 virtual int run (void) = 0; |
ce7a5b60e102
restore pull parser interface when input is not interactive (bug #58198)
John W. Eaton <jwe@octave.org>
parents:
27957
diff
changeset
|
498 |
27510
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
499 protected: |
16134
ec9c6222ef5a
move static parser helper functions to octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16133
diff
changeset
|
500 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
501 // Contains error message if Bison-generated parser returns non-zero |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
502 // status. |
23694
4a62da62af09
use m_ prefix for member variables in parser
John W. Eaton <jwe@octave.org>
parents:
23673
diff
changeset
|
503 std::string m_parse_error_msg; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
504 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
505 // Have we found an explicit end to a function? |
23694
4a62da62af09
use m_ prefix for member variables in parser
John W. Eaton <jwe@octave.org>
parents:
23673
diff
changeset
|
506 bool m_endfunction_found; |
16142
26d65d677557
rename yyerror to bison_error and make it a member of octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16139
diff
changeset
|
507 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
508 // TRUE means we are in the process of autoloading a function. |
23694
4a62da62af09
use m_ prefix for member variables in parser
John W. Eaton <jwe@octave.org>
parents:
23673
diff
changeset
|
509 bool m_autoloading; |
16153
a57c2c8c8163
move some variables into the octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16149
diff
changeset
|
510 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
511 // TRUE means the current function file was found in a relative path |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
512 // element. |
23694
4a62da62af09
use m_ prefix for member variables in parser
John W. Eaton <jwe@octave.org>
parents:
23673
diff
changeset
|
513 bool m_fcn_file_from_relative_lookup; |
16153
a57c2c8c8163
move some variables into the octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16149
diff
changeset
|
514 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
515 // FALSE if we are still at the primary function. Subfunctions can |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
516 // only be declared inside function files. |
23694
4a62da62af09
use m_ prefix for member variables in parser
John W. Eaton <jwe@octave.org>
parents:
23673
diff
changeset
|
517 bool m_parsing_subfunctions; |
16153
a57c2c8c8163
move some variables into the octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16149
diff
changeset
|
518 |
23343
49f051ef6f2f
local functions in classdef files (bug #41723)
John W. Eaton <jwe@octave.org>
parents:
23342
diff
changeset
|
519 // TRUE if we are parsing local functions defined at after a |
49f051ef6f2f
local functions in classdef files (bug #41723)
John W. Eaton <jwe@octave.org>
parents:
23342
diff
changeset
|
520 // classdef block. Local functions can only be declared inside |
49f051ef6f2f
local functions in classdef files (bug #41723)
John W. Eaton <jwe@octave.org>
parents:
23342
diff
changeset
|
521 // classdef files. |
23694
4a62da62af09
use m_ prefix for member variables in parser
John W. Eaton <jwe@octave.org>
parents:
23673
diff
changeset
|
522 bool m_parsing_local_functions; |
23343
49f051ef6f2f
local functions in classdef files (bug #41723)
John W. Eaton <jwe@octave.org>
parents:
23342
diff
changeset
|
523 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
524 // Maximum function depth detected. Used to determine whether |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
525 // we have nested functions or just implicitly ended subfunctions. |
23694
4a62da62af09
use m_ prefix for member variables in parser
John W. Eaton <jwe@octave.org>
parents:
23673
diff
changeset
|
526 int m_max_fcn_depth; |
16153
a57c2c8c8163
move some variables into the octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16149
diff
changeset
|
527 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
528 // = 0 currently outside any function. |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
529 // = 1 inside the primary function or a subfunction. |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
530 // > 1 means we are looking at a function definition that seems to be |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
531 // inside a function. Note that the function still might not be a |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
532 // nested function. |
23694
4a62da62af09
use m_ prefix for member variables in parser
John W. Eaton <jwe@octave.org>
parents:
23673
diff
changeset
|
533 int m_curr_fcn_depth; |
16153
a57c2c8c8163
move some variables into the octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16149
diff
changeset
|
534 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
535 // Scope where we install all subfunctions and nested functions. Only |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
536 // used while reading function files. |
24361
8bcfddad15ec
use shared_ptr to manage symbol_scope objects
John W. Eaton <jwe@octave.org>
parents:
24270
diff
changeset
|
537 symbol_scope m_primary_fcn_scope; |
16153
a57c2c8c8163
move some variables into the octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16149
diff
changeset
|
538 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
539 // Name of the current class when we are parsing class methods or |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
540 // constructors. |
23694
4a62da62af09
use m_ prefix for member variables in parser
John W. Eaton <jwe@octave.org>
parents:
23673
diff
changeset
|
541 std::string m_curr_class_name; |
16153
a57c2c8c8163
move some variables into the octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16149
diff
changeset
|
542 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
543 // Name of the current package when we are parsing an element contained |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
544 // in a package directory (+-directory). |
23694
4a62da62af09
use m_ prefix for member variables in parser
John W. Eaton <jwe@octave.org>
parents:
23673
diff
changeset
|
545 std::string m_curr_package_name; |
16676
7368654f302f
Initial support for (classdef) packages.
Michael Goffioul <michael.goffioul@gmail.com>
parents:
16644
diff
changeset
|
546 |
23054
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
547 // Nested function scopes and names currently being parsed. |
23694
4a62da62af09
use m_ prefix for member variables in parser
John W. Eaton <jwe@octave.org>
parents:
23673
diff
changeset
|
548 parent_scope_info m_function_scopes; |
16153
a57c2c8c8163
move some variables into the octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16149
diff
changeset
|
549 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
550 // Pointer to the primary user function or user script function. |
27505
c409d16b7190
eliminate some uses of bare pointers to octave_function objects
John W. Eaton <jwe@octave.org>
parents:
27504
diff
changeset
|
551 octave_value m_primary_fcn; |
16153
a57c2c8c8163
move some variables into the octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16149
diff
changeset
|
552 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
553 // List of subfunction names, initially in the order they are |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
554 // installed in the symbol table, then ordered as they appear in the |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
555 // file. Eventually stashed in the primary function object. |
23694
4a62da62af09
use m_ prefix for member variables in parser
John W. Eaton <jwe@octave.org>
parents:
23673
diff
changeset
|
556 std::list<std::string> m_subfunction_names; |
16627
de91b1621260
adjust location of eof marker for files with subfunctions but no explicit end statements
John W. Eaton <jwe@octave.org>
parents:
16335
diff
changeset
|
557 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
558 // Pointer to the classdef object we just parsed, if any. |
27504
7a31b25e3252
use shared_ptr for storing classdef and statement_list objects in parser
John W. Eaton <jwe@octave.org>
parents:
27016
diff
changeset
|
559 std::shared_ptr<tree_classdef> m_classdef_object; |
16211
3449bf257514
maint: fix botched merge of default to classdef
John W. Eaton <jwe@octave.org>
parents:
16205
diff
changeset
|
560 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
561 // Result of parsing input. |
27504
7a31b25e3252
use shared_ptr for storing classdef and statement_list objects in parser
John W. Eaton <jwe@octave.org>
parents:
27016
diff
changeset
|
562 std::shared_ptr <tree_statement_list> m_stmt_list; |
16177
a7669b4d27f6
eliminate global global_command variable
John W. Eaton <jwe@octave.org>
parents:
16164
diff
changeset
|
563 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
564 // State of the lexer. |
23694
4a62da62af09
use m_ prefix for member variables in parser
John W. Eaton <jwe@octave.org>
parents:
23673
diff
changeset
|
565 base_lexer& m_lexer; |
16149
49dfba4fd3c5
use pure parser and reentrant lexer interfaces
John W. Eaton <jwe@octave.org>
parents:
16142
diff
changeset
|
566 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
567 // Internal state of the Bison parser. |
23694
4a62da62af09
use m_ prefix for member variables in parser
John W. Eaton <jwe@octave.org>
parents:
23673
diff
changeset
|
568 void *m_parser_state; |
27510
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
569 |
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
570 private: |
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
571 |
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
572 // Maybe print a warning if an assignment expression is used as the |
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
573 // test in a logical expression. |
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
574 void maybe_warn_assign_as_truth_value (tree_expression *expr); |
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
575 |
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
576 // Maybe print a warning about switch labels that aren't constants. |
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
577 void maybe_warn_variable_switch_label (tree_expression *expr); |
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
578 |
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
579 // Maybe print a warning. |
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
580 void maybe_warn_missing_semi (tree_statement_list *); |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
581 }; |
16287
04a7953496a7
create base class for parser; use reference for curr_lexer
John W. Eaton <jwe@octave.org>
parents:
16273
diff
changeset
|
582 |
27509
fefc780b4e2e
move parse_fcn_file from interpreter member function to parser friend
John W. Eaton <jwe@octave.org>
parents:
27507
diff
changeset
|
583 // Publish externally used friend functions. |
fefc780b4e2e
move parse_fcn_file from interpreter member function to parser friend
John W. Eaton <jwe@octave.org>
parents:
27507
diff
changeset
|
584 |
fefc780b4e2e
move parse_fcn_file from interpreter member function to parser friend
John W. Eaton <jwe@octave.org>
parents:
27507
diff
changeset
|
585 extern OCTAVE_API octave_value |
fefc780b4e2e
move parse_fcn_file from interpreter member function to parser friend
John W. Eaton <jwe@octave.org>
parents:
27507
diff
changeset
|
586 parse_fcn_file (interpreter& interp, const std::string& full_file, |
fefc780b4e2e
move parse_fcn_file from interpreter member function to parser friend
John W. Eaton <jwe@octave.org>
parents:
27507
diff
changeset
|
587 const std::string& file, const std::string& dir_name, |
fefc780b4e2e
move parse_fcn_file from interpreter member function to parser friend
John W. Eaton <jwe@octave.org>
parents:
27507
diff
changeset
|
588 const std::string& dispatch_type, |
fefc780b4e2e
move parse_fcn_file from interpreter member function to parser friend
John W. Eaton <jwe@octave.org>
parents:
27507
diff
changeset
|
589 const std::string& package_name, bool require_file, |
fefc780b4e2e
move parse_fcn_file from interpreter member function to parser friend
John W. Eaton <jwe@octave.org>
parents:
27507
diff
changeset
|
590 bool force_script, bool autoload, bool relative_lookup); |
fefc780b4e2e
move parse_fcn_file from interpreter member function to parser friend
John W. Eaton <jwe@octave.org>
parents:
27507
diff
changeset
|
591 |
23694
4a62da62af09
use m_ prefix for member variables in parser
John W. Eaton <jwe@octave.org>
parents:
23673
diff
changeset
|
592 class parser : public base_parser |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
593 { |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
594 public: |
16287
04a7953496a7
create base class for parser; use reference for curr_lexer
John W. Eaton <jwe@octave.org>
parents:
16273
diff
changeset
|
595 |
25441
143007dad864
store reference instead of pointer to interpreter in lexer
John W. Eaton <jwe@octave.org>
parents:
25103
diff
changeset
|
596 parser (interpreter& interp) |
143007dad864
store reference instead of pointer to interpreter in lexer
John W. Eaton <jwe@octave.org>
parents:
25103
diff
changeset
|
597 : base_parser (*(new lexer (interp))) |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
598 { } |
16287
04a7953496a7
create base class for parser; use reference for curr_lexer
John W. Eaton <jwe@octave.org>
parents:
16273
diff
changeset
|
599 |
25441
143007dad864
store reference instead of pointer to interpreter in lexer
John W. Eaton <jwe@octave.org>
parents:
25103
diff
changeset
|
600 parser (FILE *file, interpreter& interp) |
143007dad864
store reference instead of pointer to interpreter in lexer
John W. Eaton <jwe@octave.org>
parents:
25103
diff
changeset
|
601 : base_parser (*(new lexer (file, interp))) |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
602 { } |
16287
04a7953496a7
create base class for parser; use reference for curr_lexer
John W. Eaton <jwe@octave.org>
parents:
16273
diff
changeset
|
603 |
25441
143007dad864
store reference instead of pointer to interpreter in lexer
John W. Eaton <jwe@octave.org>
parents:
25103
diff
changeset
|
604 parser (const std::string& eval_string, interpreter& interp) |
143007dad864
store reference instead of pointer to interpreter in lexer
John W. Eaton <jwe@octave.org>
parents:
25103
diff
changeset
|
605 : base_parser (*(new lexer (eval_string, interp))) |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
606 { } |
16287
04a7953496a7
create base class for parser; use reference for curr_lexer
John W. Eaton <jwe@octave.org>
parents:
16273
diff
changeset
|
607 |
26512
4d6392c879d7
avoid double free of lexer on exit (bug #55347)
John W. Eaton <jwe@octave.org>
parents:
26423
diff
changeset
|
608 // The lexer must be allocated with new. The parser object |
4d6392c879d7
avoid double free of lexer on exit (bug #55347)
John W. Eaton <jwe@octave.org>
parents:
26423
diff
changeset
|
609 // takes ownership of and deletes the lexer object in its |
4d6392c879d7
avoid double free of lexer on exit (bug #55347)
John W. Eaton <jwe@octave.org>
parents:
26423
diff
changeset
|
610 // destructor. |
4d6392c879d7
avoid double free of lexer on exit (bug #55347)
John W. Eaton <jwe@octave.org>
parents:
26423
diff
changeset
|
611 |
4d6392c879d7
avoid double free of lexer on exit (bug #55347)
John W. Eaton <jwe@octave.org>
parents:
26423
diff
changeset
|
612 parser (lexer *lxr) |
4d6392c879d7
avoid double free of lexer on exit (bug #55347)
John W. Eaton <jwe@octave.org>
parents:
26423
diff
changeset
|
613 : base_parser (*lxr) |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
614 { } |
16335
bef822a80ffb
if not interactive, bypass readline and read stdin as a file (bug #38520)
John W. Eaton <jwe@octave.org>
parents:
16294
diff
changeset
|
615 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
616 // No copying! |
16133
249d62b3fac8
new class for parser state
John W. Eaton <jwe@octave.org>
parents:
16122
diff
changeset
|
617 |
22865
89756f2f085b
use c++11 style for deleting default copy constructor and assignment operator
John W. Eaton <jwe@octave.org>
parents:
22755
diff
changeset
|
618 parser (const parser&) = delete; |
16133
249d62b3fac8
new class for parser state
John W. Eaton <jwe@octave.org>
parents:
16122
diff
changeset
|
619 |
22865
89756f2f085b
use c++11 style for deleting default copy constructor and assignment operator
John W. Eaton <jwe@octave.org>
parents:
22755
diff
changeset
|
620 parser& operator = (const parser&) = delete; |
22869
f75d289645ec
make deleted functions public
John W. Eaton <jwe@octave.org>
parents:
22868
diff
changeset
|
621 |
f75d289645ec
make deleted functions public
John W. Eaton <jwe@octave.org>
parents:
22868
diff
changeset
|
622 ~parser (void) = default; |
16287
04a7953496a7
create base class for parser; use reference for curr_lexer
John W. Eaton <jwe@octave.org>
parents:
16273
diff
changeset
|
623 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
624 int run (void); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
625 }; |
16133
249d62b3fac8
new class for parser state
John W. Eaton <jwe@octave.org>
parents:
16122
diff
changeset
|
626 |
23694
4a62da62af09
use m_ prefix for member variables in parser
John W. Eaton <jwe@octave.org>
parents:
23673
diff
changeset
|
627 class push_parser : public base_parser |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
628 { |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
629 public: |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
630 |
25441
143007dad864
store reference instead of pointer to interpreter in lexer
John W. Eaton <jwe@octave.org>
parents:
25103
diff
changeset
|
631 push_parser (interpreter& interp) |
28266
ce7a5b60e102
restore pull parser interface when input is not interactive (bug #58198)
John W. Eaton <jwe@octave.org>
parents:
27957
diff
changeset
|
632 : base_parser (*(new push_lexer (interp))), |
ce7a5b60e102
restore pull parser interface when input is not interactive (bug #58198)
John W. Eaton <jwe@octave.org>
parents:
27957
diff
changeset
|
633 m_interpreter (interp), m_reader () |
ce7a5b60e102
restore pull parser interface when input is not interactive (bug #58198)
John W. Eaton <jwe@octave.org>
parents:
27957
diff
changeset
|
634 { } |
ce7a5b60e102
restore pull parser interface when input is not interactive (bug #58198)
John W. Eaton <jwe@octave.org>
parents:
27957
diff
changeset
|
635 |
ce7a5b60e102
restore pull parser interface when input is not interactive (bug #58198)
John W. Eaton <jwe@octave.org>
parents:
27957
diff
changeset
|
636 // The parser assumes ownership of READER, which must be created |
ce7a5b60e102
restore pull parser interface when input is not interactive (bug #58198)
John W. Eaton <jwe@octave.org>
parents:
27957
diff
changeset
|
637 // with new. |
ce7a5b60e102
restore pull parser interface when input is not interactive (bug #58198)
John W. Eaton <jwe@octave.org>
parents:
27957
diff
changeset
|
638 |
ce7a5b60e102
restore pull parser interface when input is not interactive (bug #58198)
John W. Eaton <jwe@octave.org>
parents:
27957
diff
changeset
|
639 push_parser (interpreter& interp, input_reader *reader) |
ce7a5b60e102
restore pull parser interface when input is not interactive (bug #58198)
John W. Eaton <jwe@octave.org>
parents:
27957
diff
changeset
|
640 : base_parser (*(new push_lexer (interp))), |
ce7a5b60e102
restore pull parser interface when input is not interactive (bug #58198)
John W. Eaton <jwe@octave.org>
parents:
27957
diff
changeset
|
641 m_interpreter (interp), m_reader (reader) |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
642 { } |
16294
0925d1f6875e
push parser/lexer interface
John W. Eaton <jwe@octave.org>
parents:
16293
diff
changeset
|
643 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
644 // No copying! |
16294
0925d1f6875e
push parser/lexer interface
John W. Eaton <jwe@octave.org>
parents:
16293
diff
changeset
|
645 |
22865
89756f2f085b
use c++11 style for deleting default copy constructor and assignment operator
John W. Eaton <jwe@octave.org>
parents:
22755
diff
changeset
|
646 push_parser (const push_parser&) = delete; |
16294
0925d1f6875e
push parser/lexer interface
John W. Eaton <jwe@octave.org>
parents:
16293
diff
changeset
|
647 |
22865
89756f2f085b
use c++11 style for deleting default copy constructor and assignment operator
John W. Eaton <jwe@octave.org>
parents:
22755
diff
changeset
|
648 push_parser& operator = (const push_parser&) = delete; |
22869
f75d289645ec
make deleted functions public
John W. Eaton <jwe@octave.org>
parents:
22868
diff
changeset
|
649 |
f75d289645ec
make deleted functions public
John W. Eaton <jwe@octave.org>
parents:
22868
diff
changeset
|
650 ~push_parser (void) = default; |
16294
0925d1f6875e
push parser/lexer interface
John W. Eaton <jwe@octave.org>
parents:
16293
diff
changeset
|
651 |
28266
ce7a5b60e102
restore pull parser interface when input is not interactive (bug #58198)
John W. Eaton <jwe@octave.org>
parents:
27957
diff
changeset
|
652 // Use the push parser in the same way as the pull parser. The |
ce7a5b60e102
restore pull parser interface when input is not interactive (bug #58198)
John W. Eaton <jwe@octave.org>
parents:
27957
diff
changeset
|
653 // parser arranges for input through the M_READER object. See, for |
ce7a5b60e102
restore pull parser interface when input is not interactive (bug #58198)
John W. Eaton <jwe@octave.org>
parents:
27957
diff
changeset
|
654 // example, interpreter::main_loop. |
ce7a5b60e102
restore pull parser interface when input is not interactive (bug #58198)
John W. Eaton <jwe@octave.org>
parents:
27957
diff
changeset
|
655 |
ce7a5b60e102
restore pull parser interface when input is not interactive (bug #58198)
John W. Eaton <jwe@octave.org>
parents:
27957
diff
changeset
|
656 int run (void); |
ce7a5b60e102
restore pull parser interface when input is not interactive (bug #58198)
John W. Eaton <jwe@octave.org>
parents:
27957
diff
changeset
|
657 |
ce7a5b60e102
restore pull parser interface when input is not interactive (bug #58198)
John W. Eaton <jwe@octave.org>
parents:
27957
diff
changeset
|
658 // Parse INPUT. M_READER is not used. The user is responsible for |
ce7a5b60e102
restore pull parser interface when input is not interactive (bug #58198)
John W. Eaton <jwe@octave.org>
parents:
27957
diff
changeset
|
659 // collecting input. |
ce7a5b60e102
restore pull parser interface when input is not interactive (bug #58198)
John W. Eaton <jwe@octave.org>
parents:
27957
diff
changeset
|
660 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
661 int run (const std::string& input, bool eof); |
28266
ce7a5b60e102
restore pull parser interface when input is not interactive (bug #58198)
John W. Eaton <jwe@octave.org>
parents:
27957
diff
changeset
|
662 |
ce7a5b60e102
restore pull parser interface when input is not interactive (bug #58198)
John W. Eaton <jwe@octave.org>
parents:
27957
diff
changeset
|
663 private: |
ce7a5b60e102
restore pull parser interface when input is not interactive (bug #58198)
John W. Eaton <jwe@octave.org>
parents:
27957
diff
changeset
|
664 |
ce7a5b60e102
restore pull parser interface when input is not interactive (bug #58198)
John W. Eaton <jwe@octave.org>
parents:
27957
diff
changeset
|
665 interpreter& m_interpreter; |
ce7a5b60e102
restore pull parser interface when input is not interactive (bug #58198)
John W. Eaton <jwe@octave.org>
parents:
27957
diff
changeset
|
666 |
ce7a5b60e102
restore pull parser interface when input is not interactive (bug #58198)
John W. Eaton <jwe@octave.org>
parents:
27957
diff
changeset
|
667 std::shared_ptr<input_reader> m_reader; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
668 }; |
16294
0925d1f6875e
push parser/lexer interface
John W. Eaton <jwe@octave.org>
parents:
16293
diff
changeset
|
669 |
23075
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
670 extern OCTINTERP_API std::string |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
671 get_help_from_file (const std::string& nm, bool& symbol_found, |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
672 std::string& file); |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
673 |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
674 extern OCTINTERP_API std::string |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
675 get_help_from_file (const std::string& nm, bool& symbol_found); |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
676 |
23653
3bb0a937c071
avoid possible memory errors when parsing function files
John W. Eaton <jwe@octave.org>
parents:
23615
diff
changeset
|
677 extern OCTINTERP_API octave_value |
23075
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
678 load_fcn_from_file (const std::string& file_name, |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
679 const std::string& dir_name = "", |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
680 const std::string& dispatch_type = "", |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
681 const std::string& package_name = "", |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
682 const std::string& fcn_name = "", |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
683 bool autoload = false); |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
684 |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
685 extern OCTINTERP_API void |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
686 source_file (const std::string& file_name, |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
687 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:
27505
diff
changeset
|
688 bool verbose = false, bool require_file = true); |
23075
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
689 |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
690 extern OCTINTERP_API octave_value_list |
26883
a2aed4b49be3
fix const-ness of feval arguments
John W. Eaton <jwe@octave.org>
parents:
26686
diff
changeset
|
691 feval (const char *name, |
a2aed4b49be3
fix const-ness of feval arguments
John W. Eaton <jwe@octave.org>
parents:
26686
diff
changeset
|
692 const octave_value_list& args = octave_value_list (), |
a2aed4b49be3
fix const-ness of feval arguments
John W. Eaton <jwe@octave.org>
parents:
26686
diff
changeset
|
693 int nargout = 0); |
23075
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
694 |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
695 extern OCTINTERP_API octave_value_list |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
696 feval (const std::string& name, |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
697 const octave_value_list& args = octave_value_list (), |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
698 int nargout = 0); |
16294
0925d1f6875e
push parser/lexer interface
John W. Eaton <jwe@octave.org>
parents:
16293
diff
changeset
|
699 |
23075
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
700 extern OCTINTERP_API octave_value_list |
23502
c6714ae1c06c
eliminate remaining do_multi_index_op methods
John W. Eaton <jwe@octave.org>
parents:
23473
diff
changeset
|
701 feval (octave_function *fcn, |
23473
55916f99b8b6
prefer feval over do_multi_index_op
John W. Eaton <jwe@octave.org>
parents:
23446
diff
changeset
|
702 const octave_value_list& args = octave_value_list (), |
55916f99b8b6
prefer feval over do_multi_index_op
John W. Eaton <jwe@octave.org>
parents:
23446
diff
changeset
|
703 int nargout = 0); |
55916f99b8b6
prefer feval over do_multi_index_op
John W. Eaton <jwe@octave.org>
parents:
23446
diff
changeset
|
704 |
55916f99b8b6
prefer feval over do_multi_index_op
John W. Eaton <jwe@octave.org>
parents:
23446
diff
changeset
|
705 extern OCTINTERP_API octave_value_list |
26883
a2aed4b49be3
fix const-ness of feval arguments
John W. Eaton <jwe@octave.org>
parents:
26686
diff
changeset
|
706 feval (const octave_value& val, |
23075
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
707 const octave_value_list& args = octave_value_list (), |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
708 int nargout = 0); |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
709 |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
710 extern OCTINTERP_API octave_value_list |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
711 feval (const octave_value_list& args, int nargout = 0); |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
712 |
26113
8a15f3bace49
move eval_string inside interpreter/evaluator class
John W. Eaton <jwe@octave.org>
parents:
25441
diff
changeset
|
713 OCTAVE_DEPRECATED (5, "use 'octave::interpreter::eval_string' instead") |
23075
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
714 extern OCTINTERP_API octave_value_list |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
715 eval_string (const std::string&, bool silent, int& parse_status, int nargout); |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
716 |
26113
8a15f3bace49
move eval_string inside interpreter/evaluator class
John W. Eaton <jwe@octave.org>
parents:
25441
diff
changeset
|
717 OCTAVE_DEPRECATED (5, "use 'octave::interpreter::eval_string' instead") |
23075
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
718 extern OCTINTERP_API octave_value |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
719 eval_string (const std::string&, bool silent, int& parse_status); |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
720 |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
721 extern OCTINTERP_API void |
23696
08036a7f3660
remove octave:: namespace tag from symbols used inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23694
diff
changeset
|
722 cleanup_statement_list (tree_statement_list **lst); |
23075
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
723 } |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
724 |
1 | 725 #endif |