Mercurial > octave
annotate libinterp/parse-tree/parse.h @ 29151:6aa1440e415a
* parse.h (base_parser::~base_parser): Declare virtual.
author | John W. Eaton <jwe@octave.org> |
---|---|
date | Sat, 05 Dec 2020 13:29:48 -0500 |
parents | dff830c84726 |
children | d16d73a050b2 |
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; |
28518
b8ab8b58547d
accept spmd command blocks as language elements (bug #58676)
John W. Eaton <jwe@octave.org>
parents:
28516
diff
changeset
|
84 class tree_spmd_command; |
23075
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
85 class tree_statement; |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
86 class tree_statement_list; |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
87 class tree_statement_listtree_statement; |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
88 class tree_switch_case; |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
89 class tree_switch_case_list; |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
90 class tree_switch_command; |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
91 } |
3772 | 92 |
20940
48b2ad5ee801
maint: Rename oct-obj.[cc|h] to ovl.[cc|h] for clarity.
Rik <rik@octave.org>
parents:
20791
diff
changeset
|
93 #include "ovl.h" |
1 | 94 |
95 // Nonzero means print parser debugging info (-d). | |
4753 | 96 extern int octave_debug; |
1 | 97 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
98 namespace octave |
16133
249d62b3fac8
new class for parser state
John W. Eaton <jwe@octave.org>
parents:
16122
diff
changeset
|
99 { |
23694
4a62da62af09
use m_ prefix for member variables in parser
John W. Eaton <jwe@octave.org>
parents:
23673
diff
changeset
|
100 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
|
101 { |
23054
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
102 private: |
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
103 |
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
104 class parent_scope_info |
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
105 { |
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
106 public: |
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
107 |
24361
8bcfddad15ec
use shared_ptr to manage symbol_scope objects
John W. Eaton <jwe@octave.org>
parents:
24270
diff
changeset
|
108 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
|
109 |
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>::iterator iterator; |
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
111 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
|
112 |
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>::reverse_iterator reverse_iterator; |
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
114 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
|
115 |
28698
d45d1b4bb919
allow functions to be redefined in scripts (bug #52851)
John W. Eaton <jwe@octave.org>
parents:
28511
diff
changeset
|
116 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
|
117 |
d45d1b4bb919
allow functions to be redefined in scripts (bug #52851)
John W. Eaton <jwe@octave.org>
parents:
28511
diff
changeset
|
118 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
|
119 : 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
|
120 { } |
23054
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
121 |
28718
45d958bc3437
disable copying for base_parser::parent_scope_info class
John W. Eaton <jwe@octave.org>
parents:
28698
diff
changeset
|
122 // No copying! |
23054
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
123 |
28718
45d958bc3437
disable copying for base_parser::parent_scope_info class
John W. Eaton <jwe@octave.org>
parents:
28698
diff
changeset
|
124 parent_scope_info (const parent_scope_info&) = delete; |
45d958bc3437
disable copying for base_parser::parent_scope_info class
John W. Eaton <jwe@octave.org>
parents:
28698
diff
changeset
|
125 |
45d958bc3437
disable copying for base_parser::parent_scope_info class
John W. Eaton <jwe@octave.org>
parents:
28698
diff
changeset
|
126 parent_scope_info& operator = (const parent_scope_info&) = delete; |
23054
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
127 |
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
128 ~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
|
129 |
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
130 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
|
131 |
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
132 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
|
133 |
24361
8bcfddad15ec
use shared_ptr to manage symbol_scope objects
John W. Eaton <jwe@octave.org>
parents:
24270
diff
changeset
|
134 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
|
135 |
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
136 void pop (void); |
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
137 |
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
138 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
|
139 |
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
140 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
|
141 |
24361
8bcfddad15ec
use shared_ptr to manage symbol_scope objects
John W. Eaton <jwe@octave.org>
parents:
24270
diff
changeset
|
142 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
|
143 |
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
144 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
|
145 |
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
146 void clear (void); |
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
147 |
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
148 private: |
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
149 |
28698
d45d1b4bb919
allow functions to be redefined in scripts (bug #52851)
John W. Eaton <jwe@octave.org>
parents:
28511
diff
changeset
|
150 base_parser& m_parser; |
23694
4a62da62af09
use m_ prefix for member variables in parser
John W. Eaton <jwe@octave.org>
parents:
23673
diff
changeset
|
151 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
|
152 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
|
153 }; |
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
154 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
155 public: |
16195
b52d2f9294b6
use class for reading lexer input
John W. Eaton <jwe@octave.org>
parents:
16177
diff
changeset
|
156 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
157 base_parser (base_lexer& lxr); |
16157
335041cc657a
optionally use push parser interface
John W. Eaton <jwe@octave.org>
parents:
16153
diff
changeset
|
158 |
22869
f75d289645ec
make deleted functions public
John W. Eaton <jwe@octave.org>
parents:
22868
diff
changeset
|
159 // No copying! |
f75d289645ec
make deleted functions public
John W. Eaton <jwe@octave.org>
parents:
22868
diff
changeset
|
160 |
f75d289645ec
make deleted functions public
John W. Eaton <jwe@octave.org>
parents:
22868
diff
changeset
|
161 base_parser (const base_parser&) = delete; |
f75d289645ec
make deleted functions public
John W. Eaton <jwe@octave.org>
parents:
22868
diff
changeset
|
162 |
f75d289645ec
make deleted functions public
John W. Eaton <jwe@octave.org>
parents:
22868
diff
changeset
|
163 base_parser& operator = (const base_parser&) = delete; |
f75d289645ec
make deleted functions public
John W. Eaton <jwe@octave.org>
parents:
22868
diff
changeset
|
164 |
29151
6aa1440e415a
* parse.h (base_parser::~base_parser): Declare virtual.
John W. Eaton <jwe@octave.org>
parents:
28953
diff
changeset
|
165 virtual ~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
|
166 |
27510
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
167 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
|
168 |
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
169 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
|
170 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
171 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
|
172 |
27504
7a31b25e3252
use shared_ptr for storing classdef and statement_list objects in parser
John W. Eaton <jwe@octave.org>
parents:
27016
diff
changeset
|
173 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
|
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 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
|
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 |
7a31b25e3252
use shared_ptr for storing classdef and statement_list objects in parser
John W. Eaton <jwe@octave.org>
parents:
27016
diff
changeset
|
178 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
|
179 { |
7a31b25e3252
use shared_ptr for storing classdef and statement_list objects in parser
John W. Eaton <jwe@octave.org>
parents:
27016
diff
changeset
|
180 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
|
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 |
28407
808e3964987b
accept multi-line interactive input (bug #58370)
John W. Eaton <jwe@octave.org>
parents:
28266
diff
changeset
|
183 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
|
184 |
7a31b25e3252
use shared_ptr for storing classdef and statement_list objects in parser
John W. Eaton <jwe@octave.org>
parents:
27016
diff
changeset
|
185 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
|
186 { |
7a31b25e3252
use shared_ptr for storing classdef and statement_list objects in parser
John W. Eaton <jwe@octave.org>
parents:
27016
diff
changeset
|
187 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
|
188 } |
7a31b25e3252
use shared_ptr for storing classdef and statement_list objects in parser
John W. Eaton <jwe@octave.org>
parents:
27016
diff
changeset
|
189 |
28698
d45d1b4bb919
allow functions to be redefined in scripts (bug #52851)
John W. Eaton <jwe@octave.org>
parents:
28511
diff
changeset
|
190 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
|
191 { |
d45d1b4bb919
allow functions to be redefined in scripts (bug #52851)
John W. Eaton <jwe@octave.org>
parents:
28511
diff
changeset
|
192 m_parsing_subfunctions = flag; |
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 |
d45d1b4bb919
allow functions to be redefined in scripts (bug #52851)
John W. Eaton <jwe@octave.org>
parents:
28511
diff
changeset
|
195 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
|
196 { |
d45d1b4bb919
allow functions to be redefined in scripts (bug #52851)
John W. Eaton <jwe@octave.org>
parents:
28511
diff
changeset
|
197 return m_parsing_subfunctions; |
d45d1b4bb919
allow functions to be redefined in scripts (bug #52851)
John W. Eaton <jwe@octave.org>
parents:
28511
diff
changeset
|
198 } |
d45d1b4bb919
allow functions to be redefined in scripts (bug #52851)
John W. Eaton <jwe@octave.org>
parents:
28511
diff
changeset
|
199 |
27510
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
200 void parsing_local_functions (bool flag) |
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 m_parsing_local_functions = flag; |
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 |
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
205 bool parsing_local_functions (void) const |
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
206 { |
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
207 return m_parsing_local_functions; |
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
208 } |
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
209 |
28698
d45d1b4bb919
allow functions to be redefined in scripts (bug #52851)
John W. Eaton <jwe@octave.org>
parents:
28511
diff
changeset
|
210 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
|
211 { |
d45d1b4bb919
allow functions to be redefined in scripts (bug #52851)
John W. Eaton <jwe@octave.org>
parents:
28511
diff
changeset
|
212 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
|
213 } |
d45d1b4bb919
allow functions to be redefined in scripts (bug #52851)
John W. Eaton <jwe@octave.org>
parents:
28511
diff
changeset
|
214 |
27510
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
215 void endfunction_found (bool flag) |
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 m_endfunction_found = flag; |
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 |
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
220 bool endfunction_found (void) const |
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
221 { |
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
222 return m_endfunction_found; |
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
223 } |
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
224 |
27956
2310164737b3
fix many spelling errors (bug #57613)
John W. Eaton <jwe@octave.org>
parents:
26512
diff
changeset
|
225 // 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
|
226 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
|
227 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
228 // 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
|
229 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
|
230 |
27510
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
231 // 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
|
232 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
|
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 constant. |
23446
cd4e1ee28716
maint: Use convention 'void * fcn ()' for functions which return pointers.
Rik <rik@octave.org>
parents:
23343
diff
changeset
|
235 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
|
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 a function handle. |
23446
cd4e1ee28716
maint: Use convention 'void * fcn ()' for functions which return pointers.
Rik <rik@octave.org>
parents:
23343
diff
changeset
|
238 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
|
239 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
240 // 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
|
241 tree_anon_fcn_handle * |
23600
db947ba52118
explicitly limit anonymous functions to a single expression
John W. Eaton <jwe@octave.org>
parents:
23502
diff
changeset
|
242 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
|
243 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
|
244 |
23655
bbcc1e08aaed
improve colon expression construction and avoid possible memory leak
John W. Eaton <jwe@octave.org>
parents:
23654
diff
changeset
|
245 // Build a colon expression. |
bbcc1e08aaed
improve colon expression construction and avoid possible memory leak
John W. Eaton <jwe@octave.org>
parents:
23654
diff
changeset
|
246 tree_expression * |
bbcc1e08aaed
improve colon expression construction and avoid possible memory leak
John W. Eaton <jwe@octave.org>
parents:
23654
diff
changeset
|
247 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
|
248 tree_expression *incr = nullptr); |
bbcc1e08aaed
improve colon expression construction and avoid possible memory leak
John W. Eaton <jwe@octave.org>
parents:
23654
diff
changeset
|
249 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
250 // 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
|
251 tree_expression * |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
252 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
|
253 tree_expression *op2); |
16134
ec9c6222ef5a
move static parser helper functions to octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16133
diff
changeset
|
254 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
255 // 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
|
256 tree_expression * |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
257 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
|
258 tree_expression *op2); |
16134
ec9c6222ef5a
move static parser helper functions to octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16133
diff
changeset
|
259 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
260 // 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
|
261 tree_expression * |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
262 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
|
263 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
264 // 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
|
265 tree_expression * |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
266 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
|
267 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
268 // 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
|
269 tree_command * |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
270 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
|
271 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
|
272 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
|
273 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
274 // 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
|
275 tree_command * |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
276 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
|
277 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
|
278 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
|
279 comment_list *mc); |
16134
ec9c6222ef5a
move static parser helper functions to octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16133
diff
changeset
|
280 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
281 // 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
|
282 tree_command * |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
283 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
|
284 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
|
285 comment_list *lc); |
16134
ec9c6222ef5a
move static parser helper functions to octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16133
diff
changeset
|
286 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
287 // 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
|
288 tree_command * |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
289 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
|
290 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
|
291 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
292 // 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
|
293 tree_command * |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
294 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
|
295 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
|
296 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
|
297 comment_list *lc); |
16134
ec9c6222ef5a
move static parser helper functions to octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16133
diff
changeset
|
298 |
22196
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 break 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_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
|
301 |
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 continue 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_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
|
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 // Build a return command. |
23446
cd4e1ee28716
maint: Use convention 'void * fcn ()' for functions which return pointers.
Rik <rik@octave.org>
parents:
23343
diff
changeset
|
306 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
|
307 |
28518
b8ab8b58547d
accept spmd command blocks as language elements (bug #58676)
John W. Eaton <jwe@octave.org>
parents:
28516
diff
changeset
|
308 // Build an spmd command. |
b8ab8b58547d
accept spmd command blocks as language elements (bug #58676)
John W. Eaton <jwe@octave.org>
parents:
28516
diff
changeset
|
309 |
b8ab8b58547d
accept spmd command blocks as language elements (bug #58676)
John W. Eaton <jwe@octave.org>
parents:
28516
diff
changeset
|
310 tree_spmd_command * |
b8ab8b58547d
accept spmd command blocks as language elements (bug #58676)
John W. Eaton <jwe@octave.org>
parents:
28516
diff
changeset
|
311 make_spmd_command (token *spmd_tok, tree_statement_list *body, |
b8ab8b58547d
accept spmd command blocks as language elements (bug #58676)
John W. Eaton <jwe@octave.org>
parents:
28516
diff
changeset
|
312 token *end_tok, comment_list *lc, comment_list *tc); |
b8ab8b58547d
accept spmd command blocks as language elements (bug #58676)
John W. Eaton <jwe@octave.org>
parents:
28516
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 // 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
|
315 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
|
316 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
|
317 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
318 // 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
|
319 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
|
320 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
|
321 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
|
322 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
323 // 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
|
324 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
|
325 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
|
326 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
|
327 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
328 // 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
|
329 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
|
330 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
|
331 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
|
332 comment_list *lc); |
16134
ec9c6222ef5a
move static parser helper functions to octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16133
diff
changeset
|
333 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
334 // 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
|
335 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
|
336 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
|
337 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
|
338 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
339 // 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
|
340 tree_expression * |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
341 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
|
342 tree_expression *rhs); |
16134
ec9c6222ef5a
move static parser helper functions to octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16133
diff
changeset
|
343 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
344 // 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
|
345 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
|
346 |
27510
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
347 // 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
|
348 tree_identifier * |
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
349 make_fcn_name (tree_identifier *id); |
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
350 |
23673
1d1ce4df5255
refactor bison rules for parsing functions
John W. Eaton <jwe@octave.org>
parents:
23655
diff
changeset
|
351 // Define a function. |
1d1ce4df5255
refactor bison rules for parsing functions
John W. Eaton <jwe@octave.org>
parents:
23655
diff
changeset
|
352 tree_function_def * |
1d1ce4df5255
refactor bison rules for parsing functions
John W. Eaton <jwe@octave.org>
parents:
23655
diff
changeset
|
353 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
|
354 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
|
355 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
|
356 comment_list *lc); |
23673
1d1ce4df5255
refactor bison rules for parsing functions
John W. Eaton <jwe@octave.org>
parents:
23655
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 // 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
|
359 octave_user_function * |
23673
1d1ce4df5255
refactor bison rules for parsing functions
John W. Eaton <jwe@octave.org>
parents:
23655
diff
changeset
|
360 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
|
361 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
|
362 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
363 // 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
|
364 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
|
365 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
|
366 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
367 // 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
|
368 octave_user_function * |
23673
1d1ce4df5255
refactor bison rules for parsing functions
John W. Eaton <jwe@octave.org>
parents:
23655
diff
changeset
|
369 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
|
370 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
371 // 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
|
372 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
|
373 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
|
374 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
|
375 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
|
376 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
377 // 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
|
378 void |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
379 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
|
380 |
22196
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 * |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
382 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
|
383 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
|
384 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
|
385 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
|
386 |
22196
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_properties_block * |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
388 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
|
389 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
|
390 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
|
391 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
|
392 comment_list *tc); |
16155
0259254a3ccc
maint: periodic merge of default to classdef
John W. Eaton <jwe@octave.org>
parents:
16153
diff
changeset
|
393 |
22196
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_methods_block * |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
395 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
|
396 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
|
397 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
|
398 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
|
399 comment_list *tc); |
16155
0259254a3ccc
maint: periodic merge of default to classdef
John W. Eaton <jwe@octave.org>
parents:
16153
diff
changeset
|
400 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
401 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
|
402 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
|
403 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
|
404 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
|
405 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
|
406 comment_list *tc); |
16155
0259254a3ccc
maint: periodic merge of default to classdef
John W. Eaton <jwe@octave.org>
parents:
16153
diff
changeset
|
407 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
408 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
|
409 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
|
410 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
|
411 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
|
412 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
|
413 comment_list *tc); |
16155
0259254a3ccc
maint: periodic merge of default to classdef
John W. Eaton <jwe@octave.org>
parents:
16153
diff
changeset
|
414 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
415 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
|
416 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
|
417 tree_parameter_list *pl); |
16155
0259254a3ccc
maint: periodic merge of default to classdef
John W. Eaton <jwe@octave.org>
parents:
16153
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 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
|
420 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
|
421 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
|
422 comment_list *cl); |
18262
69990d5edcc2
Allow to parse external methods declaration in classdef files.
Michael Goffioul <michael.goffioul@gmail.com>
parents:
17856
diff
changeset
|
423 |
24067
5b88383b9a69
install local functions after classdef parse is complete (bug #52080)
John W. Eaton <jwe@octave.org>
parents:
23750
diff
changeset
|
424 void |
5b88383b9a69
install local functions after classdef parse is complete (bug #52080)
John W. Eaton <jwe@octave.org>
parents:
23750
diff
changeset
|
425 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
|
426 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
|
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 index expression. |
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_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
|
431 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
|
432 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
433 // 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
|
434 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
|
435 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
|
436 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
437 // 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
|
438 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
|
439 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
|
440 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
441 // 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
|
442 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
|
443 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
|
444 |
23654
da89ce0d49eb
avoid possible memory leak in parser
John W. Eaton <jwe@octave.org>
parents:
23653
diff
changeset
|
445 // Validate an function parameter list. |
da89ce0d49eb
avoid possible memory leak in parser
John W. Eaton <jwe@octave.org>
parents:
23653
diff
changeset
|
446 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
|
447 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
|
448 // 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
|
449 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
|
450 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
451 // 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
|
452 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
|
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 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
|
455 // and finish_cell). |
27764
f64e399b6dda
report missing semicolon location for array expressions (bug #57159)
John W. Eaton <jwe@octave.org>
parents:
27528
diff
changeset
|
456 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
|
457 token *close_delim); |
16134
ec9c6222ef5a
move static parser helper functions to octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16133
diff
changeset
|
458 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
459 // 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
|
460 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
|
461 token *close_delim); |
16237
70f465930546
rearrange class heirarchy for tree_cell and tree_matrix
John W. Eaton <jwe@octave.org>
parents:
16210
diff
changeset
|
462 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
463 // 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
|
464 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
|
465 token *close_delim); |
16134
ec9c6222ef5a
move static parser helper functions to octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16133
diff
changeset
|
466 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
467 // 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
|
468 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
|
469 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
|
470 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
471 // 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
|
472 template <typename T> |
23446
cd4e1ee28716
maint: Use convention 'void * fcn ()' for functions which return pointers.
Rik <rik@octave.org>
parents:
23343
diff
changeset
|
473 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
|
474 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
475 // Create a statement list. |
23446
cd4e1ee28716
maint: Use convention 'void * fcn ()' for functions which return pointers.
Rik <rik@octave.org>
parents:
23343
diff
changeset
|
476 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
|
477 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
478 // 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
|
479 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
|
480 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
|
481 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
|
482 |
26662
05fc703b419a
update handling of command-style function call syntax in eval
John W. Eaton <jwe@octave.org>
parents:
26513
diff
changeset
|
483 // 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
|
484 // 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
|
485 // syntax). |
05fc703b419a
update handling of command-style function call syntax in eval
John W. Eaton <jwe@octave.org>
parents:
26513
diff
changeset
|
486 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
|
487 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
488 // 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
|
489 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
|
490 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
|
491 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
|
492 |
27509
fefc780b4e2e
move parse_fcn_file from interpreter member function to parser friend
John W. Eaton <jwe@octave.org>
parents:
27507
diff
changeset
|
493 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
|
494 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
|
495 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
|
496 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
|
497 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
|
498 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
|
499 |
28266
ce7a5b60e102
restore pull parser interface when input is not interactive (bug #58198)
John W. Eaton <jwe@octave.org>
parents:
27957
diff
changeset
|
500 // 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
|
501 // 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
|
502 // 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
|
503 // 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
|
504 // 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
|
505 |
ce7a5b60e102
restore pull parser interface when input is not interactive (bug #58198)
John W. Eaton <jwe@octave.org>
parents:
27957
diff
changeset
|
506 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
|
507 |
27510
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
508 protected: |
16134
ec9c6222ef5a
move static parser helper functions to octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16133
diff
changeset
|
509 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
510 // 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
|
511 // status. |
23694
4a62da62af09
use m_ prefix for member variables in parser
John W. Eaton <jwe@octave.org>
parents:
23673
diff
changeset
|
512 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
|
513 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
514 // 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
|
515 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
|
516 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
517 // 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
|
518 bool m_autoloading; |
16153
a57c2c8c8163
move some variables into the octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16149
diff
changeset
|
519 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
520 // 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
|
521 // element. |
23694
4a62da62af09
use m_ prefix for member variables in parser
John W. Eaton <jwe@octave.org>
parents:
23673
diff
changeset
|
522 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
|
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 // 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
|
525 // 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
|
526 bool m_parsing_subfunctions; |
16153
a57c2c8c8163
move some variables into the octave_parser class
John W. Eaton <jwe@octave.org>
parents:
16149
diff
changeset
|
527 |
23343
49f051ef6f2f
local functions in classdef files (bug #41723)
John W. Eaton <jwe@octave.org>
parents:
23342
diff
changeset
|
528 // 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
|
529 // 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
|
530 // classdef files. |
23694
4a62da62af09
use m_ prefix for member variables in parser
John W. Eaton <jwe@octave.org>
parents:
23673
diff
changeset
|
531 bool m_parsing_local_functions; |
23343
49f051ef6f2f
local functions in classdef files (bug #41723)
John W. Eaton <jwe@octave.org>
parents:
23342
diff
changeset
|
532 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
533 // 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
|
534 // 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
|
535 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
|
536 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
537 // = 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
|
538 // = 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
|
539 // > 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
|
540 // 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
|
541 // nested function. |
23694
4a62da62af09
use m_ prefix for member variables in parser
John W. Eaton <jwe@octave.org>
parents:
23673
diff
changeset
|
542 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
|
543 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
544 // 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
|
545 // 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
|
546 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
|
547 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
548 // 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
|
549 // constructors. |
23694
4a62da62af09
use m_ prefix for member variables in parser
John W. Eaton <jwe@octave.org>
parents:
23673
diff
changeset
|
550 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
|
551 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
552 // 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
|
553 // 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
|
554 std::string m_curr_package_name; |
16676
7368654f302f
Initial support for (classdef) packages.
Michael Goffioul <michael.goffioul@gmail.com>
parents:
16644
diff
changeset
|
555 |
23054
564e959a0e89
avoid invalid nested function and subfunctions definitions (bug #50014)
John W. Eaton <jwe@octave.org>
parents:
22869
diff
changeset
|
556 // 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
|
557 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
|
558 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
559 // 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
|
560 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
|
561 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
562 // 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
|
563 // 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
|
564 // 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
|
565 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
|
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 // 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
|
568 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
|
569 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
570 // 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
|
571 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
|
572 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
573 // State of the lexer. |
23694
4a62da62af09
use m_ prefix for member variables in parser
John W. Eaton <jwe@octave.org>
parents:
23673
diff
changeset
|
574 base_lexer& m_lexer; |
16149
49dfba4fd3c5
use pure parser and reentrant lexer interfaces
John W. Eaton <jwe@octave.org>
parents:
16142
diff
changeset
|
575 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
576 // 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
|
577 void *m_parser_state; |
27510
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 private: |
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
580 |
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
581 // 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
|
582 // test in a logical expression. |
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
583 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
|
584 |
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
585 // 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
|
586 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
|
587 |
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
588 // Maybe print a warning. |
5438a82a18fb
declare base_parser class data protected
John W. Eaton <jwe@octave.org>
parents:
27509
diff
changeset
|
589 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
|
590 }; |
16287
04a7953496a7
create base class for parser; use reference for curr_lexer
John W. Eaton <jwe@octave.org>
parents:
16273
diff
changeset
|
591 |
27509
fefc780b4e2e
move parse_fcn_file from interpreter member function to parser friend
John W. Eaton <jwe@octave.org>
parents:
27507
diff
changeset
|
592 // 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
|
593 |
fefc780b4e2e
move parse_fcn_file from interpreter member function to parser friend
John W. Eaton <jwe@octave.org>
parents:
27507
diff
changeset
|
594 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
|
595 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
|
596 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
|
597 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
|
598 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
|
599 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
|
600 |
23694
4a62da62af09
use m_ prefix for member variables in parser
John W. Eaton <jwe@octave.org>
parents:
23673
diff
changeset
|
601 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
|
602 { |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
603 public: |
16287
04a7953496a7
create base class for parser; use reference for curr_lexer
John W. Eaton <jwe@octave.org>
parents:
16273
diff
changeset
|
604 |
25441
143007dad864
store reference instead of pointer to interpreter in lexer
John W. Eaton <jwe@octave.org>
parents:
25103
diff
changeset
|
605 parser (interpreter& interp) |
143007dad864
store reference instead of pointer to interpreter in lexer
John W. Eaton <jwe@octave.org>
parents:
25103
diff
changeset
|
606 : 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
|
607 { } |
16287
04a7953496a7
create base class for parser; use reference for curr_lexer
John W. Eaton <jwe@octave.org>
parents:
16273
diff
changeset
|
608 |
25441
143007dad864
store reference instead of pointer to interpreter in lexer
John W. Eaton <jwe@octave.org>
parents:
25103
diff
changeset
|
609 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
|
610 : 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
|
611 { } |
16287
04a7953496a7
create base class for parser; use reference for curr_lexer
John W. Eaton <jwe@octave.org>
parents:
16273
diff
changeset
|
612 |
28953
dff830c84726
Add function "dir_encoding" to set a file encoding per directory (bug #49685).
Markus Mützel <markus.muetzel@gmx.de>
parents:
28719
diff
changeset
|
613 parser (FILE *file, interpreter& interp, std::string encoding) |
dff830c84726
Add function "dir_encoding" to set a file encoding per directory (bug #49685).
Markus Mützel <markus.muetzel@gmx.de>
parents:
28719
diff
changeset
|
614 : base_parser (*(new lexer (file, interp, encoding))) |
dff830c84726
Add function "dir_encoding" to set a file encoding per directory (bug #49685).
Markus Mützel <markus.muetzel@gmx.de>
parents:
28719
diff
changeset
|
615 { } |
dff830c84726
Add function "dir_encoding" to set a file encoding per directory (bug #49685).
Markus Mützel <markus.muetzel@gmx.de>
parents:
28719
diff
changeset
|
616 |
25441
143007dad864
store reference instead of pointer to interpreter in lexer
John W. Eaton <jwe@octave.org>
parents:
25103
diff
changeset
|
617 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
|
618 : 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
|
619 { } |
16287
04a7953496a7
create base class for parser; use reference for curr_lexer
John W. Eaton <jwe@octave.org>
parents:
16273
diff
changeset
|
620 |
26512
4d6392c879d7
avoid double free of lexer on exit (bug #55347)
John W. Eaton <jwe@octave.org>
parents:
26423
diff
changeset
|
621 // 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
|
622 // 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
|
623 // destructor. |
4d6392c879d7
avoid double free of lexer on exit (bug #55347)
John W. Eaton <jwe@octave.org>
parents:
26423
diff
changeset
|
624 |
4d6392c879d7
avoid double free of lexer on exit (bug #55347)
John W. Eaton <jwe@octave.org>
parents:
26423
diff
changeset
|
625 parser (lexer *lxr) |
4d6392c879d7
avoid double free of lexer on exit (bug #55347)
John W. Eaton <jwe@octave.org>
parents:
26423
diff
changeset
|
626 : 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
|
627 { } |
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
|
628 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
629 // No copying! |
16133
249d62b3fac8
new class for parser state
John W. Eaton <jwe@octave.org>
parents:
16122
diff
changeset
|
630 |
22865
89756f2f085b
use c++11 style for deleting default copy constructor and assignment operator
John W. Eaton <jwe@octave.org>
parents:
22755
diff
changeset
|
631 parser (const parser&) = delete; |
16133
249d62b3fac8
new class for parser state
John W. Eaton <jwe@octave.org>
parents:
16122
diff
changeset
|
632 |
22865
89756f2f085b
use c++11 style for deleting default copy constructor and assignment operator
John W. Eaton <jwe@octave.org>
parents:
22755
diff
changeset
|
633 parser& operator = (const parser&) = delete; |
22869
f75d289645ec
make deleted functions public
John W. Eaton <jwe@octave.org>
parents:
22868
diff
changeset
|
634 |
f75d289645ec
make deleted functions public
John W. Eaton <jwe@octave.org>
parents:
22868
diff
changeset
|
635 ~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
|
636 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
637 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
|
638 }; |
16133
249d62b3fac8
new class for parser state
John W. Eaton <jwe@octave.org>
parents:
16122
diff
changeset
|
639 |
23694
4a62da62af09
use m_ prefix for member variables in parser
John W. Eaton <jwe@octave.org>
parents:
23673
diff
changeset
|
640 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
|
641 { |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
642 public: |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
643 |
25441
143007dad864
store reference instead of pointer to interpreter in lexer
John W. Eaton <jwe@octave.org>
parents:
25103
diff
changeset
|
644 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
|
645 : 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
|
646 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
|
647 { } |
ce7a5b60e102
restore pull parser interface when input is not interactive (bug #58198)
John W. Eaton <jwe@octave.org>
parents:
27957
diff
changeset
|
648 |
ce7a5b60e102
restore pull parser interface when input is not interactive (bug #58198)
John W. Eaton <jwe@octave.org>
parents:
27957
diff
changeset
|
649 // 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
|
650 // with new. |
ce7a5b60e102
restore pull parser interface when input is not interactive (bug #58198)
John W. Eaton <jwe@octave.org>
parents:
27957
diff
changeset
|
651 |
ce7a5b60e102
restore pull parser interface when input is not interactive (bug #58198)
John W. Eaton <jwe@octave.org>
parents:
27957
diff
changeset
|
652 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
|
653 : 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
|
654 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
|
655 { } |
16294
0925d1f6875e
push parser/lexer interface
John W. Eaton <jwe@octave.org>
parents:
16293
diff
changeset
|
656 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
657 // No copying! |
16294
0925d1f6875e
push parser/lexer interface
John W. Eaton <jwe@octave.org>
parents:
16293
diff
changeset
|
658 |
22865
89756f2f085b
use c++11 style for deleting default copy constructor and assignment operator
John W. Eaton <jwe@octave.org>
parents:
22755
diff
changeset
|
659 push_parser (const push_parser&) = delete; |
16294
0925d1f6875e
push parser/lexer interface
John W. Eaton <jwe@octave.org>
parents:
16293
diff
changeset
|
660 |
22865
89756f2f085b
use c++11 style for deleting default copy constructor and assignment operator
John W. Eaton <jwe@octave.org>
parents:
22755
diff
changeset
|
661 push_parser& operator = (const push_parser&) = delete; |
22869
f75d289645ec
make deleted functions public
John W. Eaton <jwe@octave.org>
parents:
22868
diff
changeset
|
662 |
f75d289645ec
make deleted functions public
John W. Eaton <jwe@octave.org>
parents:
22868
diff
changeset
|
663 ~push_parser (void) = default; |
16294
0925d1f6875e
push parser/lexer interface
John W. Eaton <jwe@octave.org>
parents:
16293
diff
changeset
|
664 |
28266
ce7a5b60e102
restore pull parser interface when input is not interactive (bug #58198)
John W. Eaton <jwe@octave.org>
parents:
27957
diff
changeset
|
665 // 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
|
666 // 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
|
667 // 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
|
668 |
ce7a5b60e102
restore pull parser interface when input is not interactive (bug #58198)
John W. Eaton <jwe@octave.org>
parents:
27957
diff
changeset
|
669 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
|
670 |
ce7a5b60e102
restore pull parser interface when input is not interactive (bug #58198)
John W. Eaton <jwe@octave.org>
parents:
27957
diff
changeset
|
671 // 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
|
672 // collecting input. |
ce7a5b60e102
restore pull parser interface when input is not interactive (bug #58198)
John W. Eaton <jwe@octave.org>
parents:
27957
diff
changeset
|
673 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
674 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
|
675 |
ce7a5b60e102
restore pull parser interface when input is not interactive (bug #58198)
John W. Eaton <jwe@octave.org>
parents:
27957
diff
changeset
|
676 private: |
ce7a5b60e102
restore pull parser interface when input is not interactive (bug #58198)
John W. Eaton <jwe@octave.org>
parents:
27957
diff
changeset
|
677 |
ce7a5b60e102
restore pull parser interface when input is not interactive (bug #58198)
John W. Eaton <jwe@octave.org>
parents:
27957
diff
changeset
|
678 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
|
679 |
ce7a5b60e102
restore pull parser interface when input is not interactive (bug #58198)
John W. Eaton <jwe@octave.org>
parents:
27957
diff
changeset
|
680 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
|
681 }; |
16294
0925d1f6875e
push parser/lexer interface
John W. Eaton <jwe@octave.org>
parents:
16293
diff
changeset
|
682 |
23075
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
683 extern OCTINTERP_API std::string |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
684 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
|
685 std::string& file); |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
686 |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
687 extern OCTINTERP_API std::string |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
688 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
|
689 |
23653
3bb0a937c071
avoid possible memory errors when parsing function files
John W. Eaton <jwe@octave.org>
parents:
23615
diff
changeset
|
690 extern OCTINTERP_API octave_value |
23075
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
691 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
|
692 const std::string& dir_name = "", |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
693 const std::string& dispatch_type = "", |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
694 const std::string& package_name = "", |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
695 const std::string& fcn_name = "", |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
696 bool autoload = false); |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
697 |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
698 extern OCTINTERP_API void |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
699 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
|
700 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
|
701 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
|
702 |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
703 extern OCTINTERP_API octave_value_list |
26883
a2aed4b49be3
fix const-ness of feval arguments
John W. Eaton <jwe@octave.org>
parents:
26686
diff
changeset
|
704 feval (const char *name, |
a2aed4b49be3
fix const-ness of feval arguments
John W. Eaton <jwe@octave.org>
parents:
26686
diff
changeset
|
705 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
|
706 int nargout = 0); |
23075
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
707 |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
708 extern OCTINTERP_API octave_value_list |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
709 feval (const std::string& name, |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
710 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
|
711 int nargout = 0); |
16294
0925d1f6875e
push parser/lexer interface
John W. Eaton <jwe@octave.org>
parents:
16293
diff
changeset
|
712 |
23075
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
713 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
|
714 feval (octave_function *fcn, |
23473
55916f99b8b6
prefer feval over do_multi_index_op
John W. Eaton <jwe@octave.org>
parents:
23446
diff
changeset
|
715 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
|
716 int nargout = 0); |
55916f99b8b6
prefer feval over do_multi_index_op
John W. Eaton <jwe@octave.org>
parents:
23446
diff
changeset
|
717 |
55916f99b8b6
prefer feval over do_multi_index_op
John W. Eaton <jwe@octave.org>
parents:
23446
diff
changeset
|
718 extern OCTINTERP_API octave_value_list |
26883
a2aed4b49be3
fix const-ness of feval arguments
John W. Eaton <jwe@octave.org>
parents:
26686
diff
changeset
|
719 feval (const octave_value& val, |
23075
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
720 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
|
721 int nargout = 0); |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
722 |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
723 extern OCTINTERP_API octave_value_list |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
724 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
|
725 |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
726 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
|
727 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
|
728 } |
4e3d47dc7e25
move parse tree classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
23054
diff
changeset
|
729 |
1 | 730 #endif |