Mercurial > octave
annotate libinterp/parse-tree/lex.h @ 29724:c19f8cbe0fd5
initial implementation of parsing for arguments validaton block (bug #59405)
This change allows parsing of arguments validation blocks. Octave
should now accept the arguments block syntax in a mostly Matlab
compatible way. Multiple argument blocks are allowed. All arguments
blocks must appear before any other exectuable statements in a function.
Similar to "methods", "properties", etc., "arguments" is defined as a
keyword in the octave.gperf file so that converting "arguments" to the
ARGUMENTS token in the lexer and parser is simplified but it is not
really treated as a reserved keyword in the language. One known
problem with the current approach is that
function [...] = f (...)
arguments = 13;
...
end
will result in a parse error. A simple workaround is to place another
statement (that is not an arguments block) ahead of the "arguments =
..." line in the function. Fixing this problem generally might
require a different parsing method that allows a different type of
lookahead than we currently use.
NOTE: arguments blocks do not currently perform any actions.
Since they may provide default values and/or transform arguments to
different types or values, ignoring the arguments block can lead to
incorrect results.
Octave also currently allows arguments blocks in nested functions
though they should be rejected.
Special treatment of "arguments" and "endarguments" may be disabled by
defining the macro DISABLE_ARGUMENTS_VALIDATION_BLOCK. With this
macro defined, Octave's lexer will never return the ARGUMENTS token,
so the parser will fail to parse these program elements and the
behavior should be the same as prior to this change.
* pt-args-block.h, pt-args-block.cc: New files.
* libinterp/parse-tree/module.mk: Update.
* lex.h, lex.ll (lexical_feedback::m_arguments_is_keyword):
New member variable.
(lexical_feedback::reset): Reset m_arguments_is_keyword to false.
(iskeyword, Fiskeyword): Also handle "arguments" as a special case.
(base_lexer::make_keyword_token): Handle arguments and endarguments.
* parse.h, oct-parse.yy (base_parser::make_arguments_block,
base_parser::make_args_attribute_list,
base_parser::make_arg_validation,
base_parser::make_args_validation_list,
base_parser::append_args_validation_list,
base_parser::make_arg_size_spec,
base_parser::make_arg_validation_fcns): New functions.
(function_body, at_first_executable_stmt, function_body1,
arguments_block, arguments_beg, args_attr_list, args_validation_list,
arg_validation, size_spec, class_name, validation_fcns,
default_value): New non-terminals.
(ARGUMENTS): New token.
(function): Use new function_body and function_body1 non-terminals to
accept arguments blocks, but only at the beginning of a function.
(fcn_name): Set lexer.m_arguments_is_keyword to true after parsing
function name.
(param_list_beg): Set lexer.m_arguments_is_keyword to false while
parsing function parameter list.
(param_list_beg): Reset lexer.m_arguments_is_keyword to true after
parsing function parameter list.
(tree_arguments_block_type, tree_args_block_attribute_list_type,
tree_args_block_validation_list_type, tree_arg_size_spec_type,
tree_arg_validation_type, tree_arg_validation_fcns_type): New
non-terminal types. Also declare %destructors for them.
* octave.gperf (octave_kw_id): New IDs, arguments_kw and endarguments_kw.
Provide entries for arguments and endarguments keywords.
* pt-all.h: Include pt-args-block.h.
* pt-bp.h, pt-bp.cc (tree_breakpoint::visit_arguments_block,
tree_breakpoint::visit_args_block_attribute_list,
tree_breakpoint::visit_args_block_validation_list,
tree_breakpoint::visit_arg_validation,
tree_breakpoint::visit_arg_size_spec,
tree_breakpoint::visit_arg_validation_fcns): New virtual functions for
arguments block elements.
* pt-eval.h, pt-eval.cc (tree_evaluator::visit_arguments_block,
tree_evaluator::visit_args_block_attribute_list,
tree_evaluator::visit_args_block_validation_list,
tree_evaluator::visit_arg_validation,
tree_evaluator::visit_arg_size_spec,
tree_evaluator::visit_arg_validation_fcns): New virtual functions for
arguments block elements.
* pt-pr-code.h, pt-pr-code.cc (tree_print_code::visit_arguments_block,
tree_print_code::visit_args_block_attribute_list,
tree_print_code::visit_args_block_validation_list,
tree_print_code::visit_arg_validation,
tree_print_code::visit_arg_size_spec,
tree_print_code::visit_arg_validation_fcns): New virtual functions for
arguments block elements.
* pt-walk.h, pt-walk.cc (tree_walker::visit_arguments_block,
tree_walker::visit_args_block_attribute_list,
tree_walker::visit_args_block_validation_list,
tree_walker::visit_arg_validation, tree_walker::visit_arg_size_spec,
tree_walker::visit_arg_validation_fcns): New virtual functions for
arguments block elements.
* token.h (end_tok_type): New type, arguments_end.
author | John W. Eaton <jwe@octave.org> |
---|---|
date | Tue, 01 Jun 2021 13:34:57 -0400 |
parents | 6858992dfadf |
children | 05d7b7e64811 |
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 // |
29358
0a5b15007766
update Octave Project Developers copyright for the new year
John W. Eaton <jwe@octave.org>
parents:
28407
diff
changeset
|
3 // Copyright (C) 1993-2021 The Octave Project Developers |
27923
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:
19852
diff
changeset
|
26 #if ! defined (octave_lex_h) |
383 | 27 #define octave_lex_h 1 |
1 | 28 |
21244
1473547f50f5
include octave-config.h in public header files
John W. Eaton <jwe@octave.org>
parents:
21102
diff
changeset
|
29 #include "octave-config.h" |
1473547f50f5
include octave-config.h in public header files
John W. Eaton <jwe@octave.org>
parents:
21102
diff
changeset
|
30 |
16230
4bf907906134
use a queue to hold tokens in the lexer
John W. Eaton <jwe@octave.org>
parents:
16229
diff
changeset
|
31 #include <deque> |
8745
6dc61981d18b
better handling of object indexing in lexer
John W. Eaton <jwe@octave.org>
parents:
8701
diff
changeset
|
32 #include <list> |
16101
8d19626b38ae
provide copy contructor and operator = for lexical_feedback class.
John W. Eaton <jwe@octave.org>
parents:
16100
diff
changeset
|
33 #include <set> |
11464
21b5284fa78d
avoid error when parsing nested functions
John W. Eaton <jwe@octave.org>
parents:
11367
diff
changeset
|
34 #include <stack> |
8745
6dc61981d18b
better handling of object indexing in lexer
John W. Eaton <jwe@octave.org>
parents:
8701
diff
changeset
|
35 |
16228
e19b1632d7c1
revamp most comment handling
John W. Eaton <jwe@octave.org>
parents:
16224
diff
changeset
|
36 #include "comment-list.h" |
27766
0ca7f17de041
use file position object to track line and column info in lexer and parser
John W. Eaton <jwe@octave.org>
parents:
27736
diff
changeset
|
37 #include "filepos.h" |
16195
b52d2f9294b6
use class for reading lexer input
John W. Eaton <jwe@octave.org>
parents:
16194
diff
changeset
|
38 #include "input.h" |
24380
51a1d6c84d0c
* lex.h: Include symscope.h for clang on OS X.
John W. Eaton <jwe@octave.org>
parents:
24362
diff
changeset
|
39 #include "symscope.h" |
16230
4bf907906134
use a queue to hold tokens in the lexer
John W. Eaton <jwe@octave.org>
parents:
16229
diff
changeset
|
40 #include "token.h" |
16195
b52d2f9294b6
use class for reading lexer input
John W. Eaton <jwe@octave.org>
parents:
16194
diff
changeset
|
41 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
42 namespace octave |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
43 { |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
44 class interpreter; |
1826 | 45 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
46 // Is the given string a keyword? |
26059
da2bbcf1fbcd
Deprecate C++ function is_keyword in favor of iskeyword for readability.
Rik <rik@octave.org>
parents:
25994
diff
changeset
|
47 extern bool iskeyword (const std::string& s); |
1826 | 48 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
49 // For communication between the lexer and parser. |
16320
09f0cb9cac7d
don't modify symbol table scope in the parser
John W. Eaton <jwe@octave.org>
parents:
16294
diff
changeset
|
50 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
51 class |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
52 lexical_feedback |
16320
09f0cb9cac7d
don't modify symbol table scope in the parser
John W. Eaton <jwe@octave.org>
parents:
16294
diff
changeset
|
53 { |
09f0cb9cac7d
don't modify symbol table scope in the parser
John W. Eaton <jwe@octave.org>
parents:
16294
diff
changeset
|
54 public: |
09f0cb9cac7d
don't modify symbol table scope in the parser
John W. Eaton <jwe@octave.org>
parents:
16294
diff
changeset
|
55 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
56 // Track symbol table information when parsing functions. |
16320
09f0cb9cac7d
don't modify symbol table scope in the parser
John W. Eaton <jwe@octave.org>
parents:
16294
diff
changeset
|
57 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
58 class symbol_table_context |
16320
09f0cb9cac7d
don't modify symbol table scope in the parser
John W. Eaton <jwe@octave.org>
parents:
16294
diff
changeset
|
59 { |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
60 public: |
16320
09f0cb9cac7d
don't modify symbol table scope in the parser
John W. Eaton <jwe@octave.org>
parents:
16294
diff
changeset
|
61 |
27443
075602880383
store ref to interpreter in lexical_feedback and symbol_table_context classes
John W. Eaton <jwe@octave.org>
parents:
27162
diff
changeset
|
62 symbol_table_context (interpreter& interp) |
075602880383
store ref to interpreter in lexical_feedback and symbol_table_context classes
John W. Eaton <jwe@octave.org>
parents:
27162
diff
changeset
|
63 : m_interpreter (interp), m_frame_stack () { } |
16320
09f0cb9cac7d
don't modify symbol table scope in the parser
John W. Eaton <jwe@octave.org>
parents:
16294
diff
changeset
|
64 |
23602
214cb58ccc1c
use pointer to scope instead of scope id
John W. Eaton <jwe@octave.org>
parents:
23599
diff
changeset
|
65 ~symbol_table_context (void) { clear (); } |
23599
5cb3a2bb5e1e
don't use singleton for symbol_table
John W. Eaton <jwe@octave.org>
parents:
23532
diff
changeset
|
66 |
5cb3a2bb5e1e
don't use singleton for symbol_table
John W. Eaton <jwe@octave.org>
parents:
23532
diff
changeset
|
67 void clear (void); |
17796
6b51f5f44aea
find symbols in proper scope when debugging (bug #40397)
John W. Eaton <jwe@octave.org>
parents:
17787
diff
changeset
|
68 |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
69 bool empty (void) const { return m_frame_stack.empty (); } |
16320
09f0cb9cac7d
don't modify symbol table scope in the parser
John W. Eaton <jwe@octave.org>
parents:
16294
diff
changeset
|
70 |
29654
d13d090cb03a
use std::size_t and std::ptrdiff_t in C++ code (bug #60471)
John W. Eaton <jwe@octave.org>
parents:
29358
diff
changeset
|
71 std::size_t size (void) const { return m_frame_stack.size (); } |
23599
5cb3a2bb5e1e
don't use singleton for symbol_table
John W. Eaton <jwe@octave.org>
parents:
23532
diff
changeset
|
72 |
23602
214cb58ccc1c
use pointer to scope instead of scope id
John W. Eaton <jwe@octave.org>
parents:
23599
diff
changeset
|
73 void pop (void); |
16320
09f0cb9cac7d
don't modify symbol table scope in the parser
John W. Eaton <jwe@octave.org>
parents:
16294
diff
changeset
|
74 |
24361
8bcfddad15ec
use shared_ptr to manage symbol_scope objects
John W. Eaton <jwe@octave.org>
parents:
24270
diff
changeset
|
75 void push (const symbol_scope& scope) |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
76 { |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
77 m_frame_stack.push_front (scope); |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
78 } |
16104
c8974e28da59
move nesting_level to lexical_feedback class
John W. Eaton <jwe@octave.org>
parents:
16103
diff
changeset
|
79 |
24361
8bcfddad15ec
use shared_ptr to manage symbol_scope objects
John W. Eaton <jwe@octave.org>
parents:
24270
diff
changeset
|
80 symbol_scope curr_scope (void) const; |
8bcfddad15ec
use shared_ptr to manage symbol_scope objects
John W. Eaton <jwe@octave.org>
parents:
24270
diff
changeset
|
81 symbol_scope parent_scope (void) const; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
82 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
83 private: |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
84 |
27443
075602880383
store ref to interpreter in lexical_feedback and symbol_table_context classes
John W. Eaton <jwe@octave.org>
parents:
27162
diff
changeset
|
85 interpreter& m_interpreter; |
075602880383
store ref to interpreter in lexical_feedback and symbol_table_context classes
John W. Eaton <jwe@octave.org>
parents:
27162
diff
changeset
|
86 |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
87 std::deque<symbol_scope> m_frame_stack; |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
88 }; |
16104
c8974e28da59
move nesting_level to lexical_feedback class
John W. Eaton <jwe@octave.org>
parents:
16103
diff
changeset
|
89 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
90 // Track nesting of square brackets, curly braces, and parentheses. |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
91 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
92 class bbp_nesting_level |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
93 { |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
94 private: |
16104
c8974e28da59
move nesting_level to lexical_feedback class
John W. Eaton <jwe@octave.org>
parents:
16103
diff
changeset
|
95 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
96 enum bracket_type |
22407
34ce5be04942
maint: Style check C++ code in libinterp/.
Rik <rik@octave.org>
parents:
22323
diff
changeset
|
97 { |
34ce5be04942
maint: Style check C++ code in libinterp/.
Rik <rik@octave.org>
parents:
22323
diff
changeset
|
98 BRACKET = 1, |
34ce5be04942
maint: Style check C++ code in libinterp/.
Rik <rik@octave.org>
parents:
22323
diff
changeset
|
99 BRACE = 2, |
34ce5be04942
maint: Style check C++ code in libinterp/.
Rik <rik@octave.org>
parents:
22323
diff
changeset
|
100 PAREN = 3, |
34ce5be04942
maint: Style check C++ code in libinterp/.
Rik <rik@octave.org>
parents:
22323
diff
changeset
|
101 ANON_FCN_BODY = 4 |
34ce5be04942
maint: Style check C++ code in libinterp/.
Rik <rik@octave.org>
parents:
22323
diff
changeset
|
102 }; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
103 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
104 public: |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
105 |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
106 bbp_nesting_level (void) : m_context () { } |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
107 |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
108 bbp_nesting_level (const bbp_nesting_level& nl) |
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
109 : m_context (nl.m_context) |
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
110 { } |
16104
c8974e28da59
move nesting_level to lexical_feedback class
John W. Eaton <jwe@octave.org>
parents:
16103
diff
changeset
|
111 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
112 bbp_nesting_level& operator = (const bbp_nesting_level& nl) |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
113 { |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
114 if (&nl != this) |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
115 m_context = nl.m_context; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
116 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
117 return *this; |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
118 } |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
119 |
22868
87e3163f6c87
use c++11 "= default" syntax for declaration of trivial destructors
John W. Eaton <jwe@octave.org>
parents:
22865
diff
changeset
|
120 ~bbp_nesting_level (void) = default; |
16104
c8974e28da59
move nesting_level to lexical_feedback class
John W. Eaton <jwe@octave.org>
parents:
16103
diff
changeset
|
121 |
26345
7c6ff9b36302
lex.h: Fix static analyzer detected issues (bug #55347).
Rik <rik@octave.org>
parents:
26059
diff
changeset
|
122 // Alias for clear function. |
7c6ff9b36302
lex.h: Fix static analyzer detected issues (bug #55347).
Rik <rik@octave.org>
parents:
26059
diff
changeset
|
123 void reset (void) { clear (); } |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
124 |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
125 void bracket (void) { m_context.push (BRACKET); } |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
126 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
127 bool is_bracket (void) |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
128 { |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
129 return ! m_context.empty () && m_context.top () == BRACKET; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
130 } |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
131 |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
132 void brace (void) { m_context.push (BRACE); } |
16104
c8974e28da59
move nesting_level to lexical_feedback class
John W. Eaton <jwe@octave.org>
parents:
16103
diff
changeset
|
133 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
134 bool is_brace (void) |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
135 { |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
136 return ! m_context.empty () && m_context.top () == BRACE; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
137 } |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
138 |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
139 void paren (void) { m_context.push (PAREN); } |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
140 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
141 bool is_paren (void) |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
142 { |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
143 return ! m_context.empty () && m_context.top () == PAREN; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
144 } |
16104
c8974e28da59
move nesting_level to lexical_feedback class
John W. Eaton <jwe@octave.org>
parents:
16103
diff
changeset
|
145 |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
146 void anon_fcn_body (void) { m_context.push (ANON_FCN_BODY); } |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
147 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
148 bool is_anon_fcn_body (void) |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
149 { |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
150 return ! m_context.empty () && m_context.top () == ANON_FCN_BODY; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
151 } |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
152 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
153 bool is_bracket_or_brace (void) |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
154 { |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
155 return (! m_context.empty () |
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
156 && (m_context.top () == BRACKET || m_context.top () == BRACE)); |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
157 } |
16104
c8974e28da59
move nesting_level to lexical_feedback class
John W. Eaton <jwe@octave.org>
parents:
16103
diff
changeset
|
158 |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
159 bool none (void) { return m_context.empty (); } |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
160 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
161 void remove (void) |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
162 { |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
163 if (! m_context.empty ()) |
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
164 m_context.pop (); |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
165 } |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
166 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
167 void clear (void) |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
168 { |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
169 while (! m_context.empty ()) |
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
170 m_context.pop (); |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
171 } |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
172 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
173 private: |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
174 |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
175 std::stack<int> m_context; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
176 }; |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
177 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
178 class token_cache |
16194
b7ca669af528
reset lexical_feedback state before starting a new parse
John W. Eaton <jwe@octave.org>
parents:
16193
diff
changeset
|
179 { |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
180 public: |
16194
b7ca669af528
reset lexical_feedback state before starting a new parse
John W. Eaton <jwe@octave.org>
parents:
16193
diff
changeset
|
181 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
182 // Store an "unlimited" number of tokens. |
22858
a183a0929653
eliminate size limit for token cache; provide destructor for class
John W. Eaton <jwe@octave.org>
parents:
22857
diff
changeset
|
183 |
a183a0929653
eliminate size limit for token cache; provide destructor for class
John W. Eaton <jwe@octave.org>
parents:
22857
diff
changeset
|
184 // Tokens are allocated with new. Delete them when they are |
a183a0929653
eliminate size limit for token cache; provide destructor for class
John W. Eaton <jwe@octave.org>
parents:
22857
diff
changeset
|
185 // removed from the cache. |
a183a0929653
eliminate size limit for token cache; provide destructor for class
John W. Eaton <jwe@octave.org>
parents:
22857
diff
changeset
|
186 // |
a183a0929653
eliminate size limit for token cache; provide destructor for class
John W. Eaton <jwe@octave.org>
parents:
22857
diff
changeset
|
187 // One of the reasons for using this class instead of std::deque |
a183a0929653
eliminate size limit for token cache; provide destructor for class
John W. Eaton <jwe@octave.org>
parents:
22857
diff
changeset
|
188 // directly is that we can ensure that memory is cleaned up |
a183a0929653
eliminate size limit for token cache; provide destructor for class
John W. Eaton <jwe@octave.org>
parents:
22857
diff
changeset
|
189 // properly. It's more tedious to do that with deque since the |
a183a0929653
eliminate size limit for token cache; provide destructor for class
John W. Eaton <jwe@octave.org>
parents:
22857
diff
changeset
|
190 // deque destructor and clear method don't call delete on the |
a183a0929653
eliminate size limit for token cache; provide destructor for class
John W. Eaton <jwe@octave.org>
parents:
22857
diff
changeset
|
191 // elements that it stores. Another reason is that it makes it |
a183a0929653
eliminate size limit for token cache; provide destructor for class
John W. Eaton <jwe@octave.org>
parents:
22857
diff
changeset
|
192 // easier to change the implementation later if needed. |
a183a0929653
eliminate size limit for token cache; provide destructor for class
John W. Eaton <jwe@octave.org>
parents:
22857
diff
changeset
|
193 |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
194 token_cache (void) : m_buffer () { } |
22858
a183a0929653
eliminate size limit for token cache; provide destructor for class
John W. Eaton <jwe@octave.org>
parents:
22857
diff
changeset
|
195 |
22869
f75d289645ec
make deleted functions public
John W. Eaton <jwe@octave.org>
parents:
22868
diff
changeset
|
196 // No copying! |
f75d289645ec
make deleted functions public
John W. Eaton <jwe@octave.org>
parents:
22868
diff
changeset
|
197 |
f75d289645ec
make deleted functions public
John W. Eaton <jwe@octave.org>
parents:
22868
diff
changeset
|
198 token_cache (const token_cache&) = delete; |
f75d289645ec
make deleted functions public
John W. Eaton <jwe@octave.org>
parents:
22868
diff
changeset
|
199 |
f75d289645ec
make deleted functions public
John W. Eaton <jwe@octave.org>
parents:
22868
diff
changeset
|
200 token_cache& operator = (const token_cache&) = delete; |
f75d289645ec
make deleted functions public
John W. Eaton <jwe@octave.org>
parents:
22868
diff
changeset
|
201 |
22858
a183a0929653
eliminate size limit for token cache; provide destructor for class
John W. Eaton <jwe@octave.org>
parents:
22857
diff
changeset
|
202 ~token_cache (void) { clear (); } |
16104
c8974e28da59
move nesting_level to lexical_feedback class
John W. Eaton <jwe@octave.org>
parents:
16103
diff
changeset
|
203 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
204 void push (token *tok) |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
205 { |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
206 m_buffer.push_front (tok); |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
207 } |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
208 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
209 void pop (void) |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
210 { |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
211 if (! empty ()) |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
212 { |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
213 delete m_buffer.back (); |
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
214 m_buffer.pop_back (); |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
215 } |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
216 } |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
217 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
218 // Direct access. |
29654
d13d090cb03a
use std::size_t and std::ptrdiff_t in C++ code (bug #60471)
John W. Eaton <jwe@octave.org>
parents:
29358
diff
changeset
|
219 token * at (std::size_t n) |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
220 { |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
221 return empty () ? nullptr : m_buffer.at (n); |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
222 } |
16104
c8974e28da59
move nesting_level to lexical_feedback class
John W. Eaton <jwe@octave.org>
parents:
16103
diff
changeset
|
223 |
29654
d13d090cb03a
use std::size_t and std::ptrdiff_t in C++ code (bug #60471)
John W. Eaton <jwe@octave.org>
parents:
29358
diff
changeset
|
224 const token * at (std::size_t n) const |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
225 { |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
226 return empty () ? nullptr : m_buffer.at (n); |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
227 } |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
228 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
229 // Most recently pushed. |
23446
cd4e1ee28716
maint: Use convention 'void * fcn ()' for functions which return pointers.
Rik <rik@octave.org>
parents:
23220
diff
changeset
|
230 token * front (void) |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
231 { |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
232 return empty () ? nullptr : m_buffer.front (); |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
233 } |
16104
c8974e28da59
move nesting_level to lexical_feedback class
John W. Eaton <jwe@octave.org>
parents:
16103
diff
changeset
|
234 |
23446
cd4e1ee28716
maint: Use convention 'void * fcn ()' for functions which return pointers.
Rik <rik@octave.org>
parents:
23220
diff
changeset
|
235 const token * front (void) const |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
236 { |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
237 return empty () ? nullptr : m_buffer.front (); |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
238 } |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
239 |
23446
cd4e1ee28716
maint: Use convention 'void * fcn ()' for functions which return pointers.
Rik <rik@octave.org>
parents:
23220
diff
changeset
|
240 token * back (void) |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
241 { |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
242 return empty () ? nullptr : m_buffer.back (); |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
243 } |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
244 |
23446
cd4e1ee28716
maint: Use convention 'void * fcn ()' for functions which return pointers.
Rik <rik@octave.org>
parents:
23220
diff
changeset
|
245 const token * back (void) const |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
246 { |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
247 return empty () ? nullptr : m_buffer.back (); |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
248 } |
16104
c8974e28da59
move nesting_level to lexical_feedback class
John W. Eaton <jwe@octave.org>
parents:
16103
diff
changeset
|
249 |
22858
a183a0929653
eliminate size limit for token cache; provide destructor for class
John W. Eaton <jwe@octave.org>
parents:
22857
diff
changeset
|
250 // Number of elements currently in the buffer. |
29654
d13d090cb03a
use std::size_t and std::ptrdiff_t in C++ code (bug #60471)
John W. Eaton <jwe@octave.org>
parents:
29358
diff
changeset
|
251 std::size_t size (void) const { return m_buffer.size (); } |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
252 |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
253 bool empty (void) const { return m_buffer.empty (); } |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
254 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
255 void clear (void) |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
256 { |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
257 while (! empty ()) |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
258 pop (); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
259 } |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
260 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
261 private: |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
262 |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
263 std::deque<token *> m_buffer; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
264 }; |
16104
c8974e28da59
move nesting_level to lexical_feedback class
John W. Eaton <jwe@octave.org>
parents:
16103
diff
changeset
|
265 |
27443
075602880383
store ref to interpreter in lexical_feedback and symbol_table_context classes
John W. Eaton <jwe@octave.org>
parents:
27162
diff
changeset
|
266 lexical_feedback (interpreter& interp) |
075602880383
store ref to interpreter in lexical_feedback and symbol_table_context classes
John W. Eaton <jwe@octave.org>
parents:
27162
diff
changeset
|
267 : m_interpreter (interp), |
075602880383
store ref to interpreter in lexical_feedback and symbol_table_context classes
John W. Eaton <jwe@octave.org>
parents:
27162
diff
changeset
|
268 m_end_of_input (false), |
26662
05fc703b419a
update handling of command-style function call syntax in eval
John W. Eaton <jwe@octave.org>
parents:
26376
diff
changeset
|
269 m_allow_command_syntax (true), |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
270 m_at_beginning_of_statement (true), |
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
271 m_looking_at_anon_fcn_args (false), |
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
272 m_looking_at_return_list (false), |
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
273 m_looking_at_parameter_list (false), |
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
274 m_looking_at_decl_list (false), |
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
275 m_looking_at_initializer_expression (false), |
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
276 m_looking_at_matrix_or_assign_lhs (false), |
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
277 m_looking_for_object_index (false), |
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
278 m_looking_at_indirect_ref (false), |
29724
c19f8cbe0fd5
initial implementation of parsing for arguments validaton block (bug #59405)
John W. Eaton <jwe@octave.org>
parents:
29723
diff
changeset
|
279 m_arguments_is_keyword (false), |
27736
bd80e14f268a
improve parse error message for @()x+=expr (bug #57255)
John W. Eaton <jwe@octave.org>
parents:
27528
diff
changeset
|
280 m_parsing_anon_fcn_body (false), |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
281 m_parsing_class_method (false), |
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
282 m_parsing_classdef (false), |
26709
17e7d310def8
revamp parsing of superclass identifiers in classdef decls
John W. Eaton <jwe@octave.org>
parents:
26699
diff
changeset
|
283 m_parsing_classdef_decl (false), |
17e7d310def8
revamp parsing of superclass identifiers in classdef decls
John W. Eaton <jwe@octave.org>
parents:
26699
diff
changeset
|
284 m_parsing_classdef_superclass (false), |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
285 m_maybe_classdef_get_set_method (false), |
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
286 m_parsing_classdef_get_method (false), |
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
287 m_parsing_classdef_set_method (false), |
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
288 m_quote_is_transpose (false), |
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
289 m_force_script (false), |
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
290 m_reading_fcn_file (false), |
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
291 m_reading_script_file (false), |
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
292 m_reading_classdef_file (false), |
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
293 m_buffer_function_text (false), |
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
294 m_bracketflag (0), |
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
295 m_braceflag (0), |
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
296 m_looping (0), |
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
297 m_defining_func (0), |
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
298 m_looking_at_function_handle (0), |
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
299 m_block_comment_nesting_level (0), |
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
300 m_command_arg_paren_count (0), |
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
301 m_token_count (0), |
27766
0ca7f17de041
use file position object to track line and column info in lexer and parser
John W. Eaton <jwe@octave.org>
parents:
27736
diff
changeset
|
302 m_filepos (), |
27778
2f8559459314
store beginning and ending location info for tokens recognized by lexer
John W. Eaton <jwe@octave.org>
parents:
27777
diff
changeset
|
303 m_tok_beg (), |
2f8559459314
store beginning and ending location info for tokens recognized by lexer
John W. Eaton <jwe@octave.org>
parents:
27777
diff
changeset
|
304 m_tok_end (), |
27768
d6701f835496
use filepos object to store beginning position of character strings
John W. Eaton <jwe@octave.org>
parents:
27766
diff
changeset
|
305 m_string_text (), |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
306 m_current_input_line (), |
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
307 m_comment_text (), |
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
308 m_help_text (), |
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
309 m_function_text (), |
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
310 m_fcn_file_name (), |
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
311 m_fcn_file_full_name (), |
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
312 m_dir_name (), |
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
313 m_package_name (), |
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
314 m_looking_at_object_index (), |
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
315 m_parsed_function_name (), |
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
316 m_pending_local_variables (), |
27443
075602880383
store ref to interpreter in lexical_feedback and symbol_table_context classes
John W. Eaton <jwe@octave.org>
parents:
27162
diff
changeset
|
317 m_symtab_context (interp), |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
318 m_nesting_level (), |
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
319 m_tokens () |
16104
c8974e28da59
move nesting_level to lexical_feedback class
John W. Eaton <jwe@octave.org>
parents:
16103
diff
changeset
|
320 { |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
321 init (); |
16265
71ee3afedb69
5/10 commits reworking the lexer
John W. Eaton <jwe@octave.org>
parents:
16263
diff
changeset
|
322 } |
71ee3afedb69
5/10 commits reworking the lexer
John W. Eaton <jwe@octave.org>
parents:
16263
diff
changeset
|
323 |
22869
f75d289645ec
make deleted functions public
John W. Eaton <jwe@octave.org>
parents:
22868
diff
changeset
|
324 // No copying! |
f75d289645ec
make deleted functions public
John W. Eaton <jwe@octave.org>
parents:
22868
diff
changeset
|
325 |
f75d289645ec
make deleted functions public
John W. Eaton <jwe@octave.org>
parents:
22868
diff
changeset
|
326 lexical_feedback (const lexical_feedback&) = delete; |
f75d289645ec
make deleted functions public
John W. Eaton <jwe@octave.org>
parents:
22868
diff
changeset
|
327 |
f75d289645ec
make deleted functions public
John W. Eaton <jwe@octave.org>
parents:
22868
diff
changeset
|
328 lexical_feedback& operator = (const lexical_feedback&) = delete; |
f75d289645ec
make deleted functions public
John W. Eaton <jwe@octave.org>
parents:
22868
diff
changeset
|
329 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
330 ~lexical_feedback (void); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
331 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
332 void init (void); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
333 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
334 void reset (void); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
335 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
336 int previous_token_value (void) const; |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
337 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
338 bool previous_token_value_is (int tok_val) const; |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
339 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
340 void mark_previous_token_trailing_space (void); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
341 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
342 bool space_follows_previous_token (void) const; |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
343 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
344 bool previous_token_is_binop (void) const; |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
345 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
346 bool previous_token_is_keyword (void) const; |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
347 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
348 bool previous_token_may_be_command (void) const; |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
349 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
350 void maybe_mark_previous_token_as_variable (void); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
351 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
352 void mark_as_variable (const std::string& nm); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
353 void mark_as_variables (const std::list<std::string>& lst); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
354 |
27443
075602880383
store ref to interpreter in lexical_feedback and symbol_table_context classes
John W. Eaton <jwe@octave.org>
parents:
27162
diff
changeset
|
355 interpreter& m_interpreter; |
075602880383
store ref to interpreter in lexical_feedback and symbol_table_context classes
John W. Eaton <jwe@octave.org>
parents:
27162
diff
changeset
|
356 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
357 // true means that we have encountered eof on the input stream. |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
358 bool m_end_of_input; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
359 |
26662
05fc703b419a
update handling of command-style function call syntax in eval
John W. Eaton <jwe@octave.org>
parents:
26376
diff
changeset
|
360 // true means command syntax is allowed. |
05fc703b419a
update handling of command-style function call syntax in eval
John W. Eaton <jwe@octave.org>
parents:
26376
diff
changeset
|
361 bool m_allow_command_syntax; |
05fc703b419a
update handling of command-style function call syntax in eval
John W. Eaton <jwe@octave.org>
parents:
26376
diff
changeset
|
362 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
363 // true means we are at the beginning of a statement, where a |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
364 // command name is possible. |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
365 bool m_at_beginning_of_statement; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
366 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
367 // true means we are parsing an anonymous function argument list. |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
368 bool m_looking_at_anon_fcn_args; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
369 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
370 // true means we're parsing the return list for a function. |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
371 bool m_looking_at_return_list; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
372 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
373 // true means we're parsing the parameter list for a function. |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
374 bool m_looking_at_parameter_list; |
16104
c8974e28da59
move nesting_level to lexical_feedback class
John W. Eaton <jwe@octave.org>
parents:
16103
diff
changeset
|
375 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
376 // true means we're parsing a declaration list (global or |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
377 // persistent). |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
378 bool m_looking_at_decl_list; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
379 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
380 // true means we are looking at the initializer expression for a |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
381 // parameter list element. |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
382 bool m_looking_at_initializer_expression; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
383 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
384 // true means we're parsing a matrix or the left hand side of |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
385 // multi-value assignment statement. |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
386 bool m_looking_at_matrix_or_assign_lhs; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
387 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
388 // object index not possible until we've seen something. |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
389 bool m_looking_for_object_index; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
390 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
391 // true means we're looking at an indirect reference to a |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
392 // structure element. |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
393 bool m_looking_at_indirect_ref; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
394 |
29724
c19f8cbe0fd5
initial implementation of parsing for arguments validaton block (bug #59405)
John W. Eaton <jwe@octave.org>
parents:
29723
diff
changeset
|
395 // true means arguments is handled as keyword. |
c19f8cbe0fd5
initial implementation of parsing for arguments validaton block (bug #59405)
John W. Eaton <jwe@octave.org>
parents:
29723
diff
changeset
|
396 bool m_arguments_is_keyword; |
c19f8cbe0fd5
initial implementation of parsing for arguments validaton block (bug #59405)
John W. Eaton <jwe@octave.org>
parents:
29723
diff
changeset
|
397 |
27736
bd80e14f268a
improve parse error message for @()x+=expr (bug #57255)
John W. Eaton <jwe@octave.org>
parents:
27528
diff
changeset
|
398 // true means we are parsing the body of an anonymous function. |
bd80e14f268a
improve parse error message for @()x+=expr (bug #57255)
John W. Eaton <jwe@octave.org>
parents:
27528
diff
changeset
|
399 bool m_parsing_anon_fcn_body; |
bd80e14f268a
improve parse error message for @()x+=expr (bug #57255)
John W. Eaton <jwe@octave.org>
parents:
27528
diff
changeset
|
400 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
401 // true means we are parsing a class method in function or classdef file. |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
402 bool m_parsing_class_method; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
403 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
404 // true means we are parsing a classdef file |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
405 bool m_parsing_classdef; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
406 |
26709
17e7d310def8
revamp parsing of superclass identifiers in classdef decls
John W. Eaton <jwe@octave.org>
parents:
26699
diff
changeset
|
407 // true means we are parsing the initial classdef declaration |
17e7d310def8
revamp parsing of superclass identifiers in classdef decls
John W. Eaton <jwe@octave.org>
parents:
26699
diff
changeset
|
408 // portion of classdef file, from the "classdef" token through the |
17e7d310def8
revamp parsing of superclass identifiers in classdef decls
John W. Eaton <jwe@octave.org>
parents:
26699
diff
changeset
|
409 // optional list of superclasses. |
17e7d310def8
revamp parsing of superclass identifiers in classdef decls
John W. Eaton <jwe@octave.org>
parents:
26699
diff
changeset
|
410 bool m_parsing_classdef_decl; |
17e7d310def8
revamp parsing of superclass identifiers in classdef decls
John W. Eaton <jwe@octave.org>
parents:
26699
diff
changeset
|
411 |
17e7d310def8
revamp parsing of superclass identifiers in classdef decls
John W. Eaton <jwe@octave.org>
parents:
26699
diff
changeset
|
412 // true means we are parsing the superclass part of a classdef |
17e7d310def8
revamp parsing of superclass identifiers in classdef decls
John W. Eaton <jwe@octave.org>
parents:
26699
diff
changeset
|
413 // declaration. |
17e7d310def8
revamp parsing of superclass identifiers in classdef decls
John W. Eaton <jwe@octave.org>
parents:
26699
diff
changeset
|
414 bool m_parsing_classdef_superclass; |
17e7d310def8
revamp parsing of superclass identifiers in classdef decls
John W. Eaton <jwe@octave.org>
parents:
26699
diff
changeset
|
415 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
416 // true means we are parsing a class method declaration line in a |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
417 // classdef file and can accept a property get or set method name. |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
418 // for example, "get.propertyname" is recognized as a function name. |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
419 bool m_maybe_classdef_get_set_method; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
420 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
421 // TRUE means we are parsing a classdef get.method. |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
422 bool m_parsing_classdef_get_method; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
423 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
424 // TRUE means we are parsing a classdef set.method. |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
425 bool m_parsing_classdef_set_method; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
426 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
427 // return transpose or start a string? |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
428 bool m_quote_is_transpose; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
429 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
430 // TRUE means treat the current file as a script even if the first |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
431 // token is "function" or "classdef". |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
432 bool m_force_script; |
16104
c8974e28da59
move nesting_level to lexical_feedback class
John W. Eaton <jwe@octave.org>
parents:
16103
diff
changeset
|
433 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
434 // TRUE means we're parsing a function file. |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
435 bool m_reading_fcn_file; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
436 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
437 // TRUE means we're parsing a script file. |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
438 bool m_reading_script_file; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
439 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
440 // TRUE means we're parsing a classdef file. |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
441 bool m_reading_classdef_file; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
442 |
23730
85f1d31956c0
make echo work for command-line functions
John W. Eaton <jwe@octave.org>
parents:
23693
diff
changeset
|
443 // TRUE means we should store the text of the function we are |
85f1d31956c0
make echo work for command-line functions
John W. Eaton <jwe@octave.org>
parents:
23693
diff
changeset
|
444 // parsing. |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
445 bool m_buffer_function_text; |
23730
85f1d31956c0
make echo work for command-line functions
John W. Eaton <jwe@octave.org>
parents:
23693
diff
changeset
|
446 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
447 // square bracket level count. |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
448 int m_bracketflag; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
449 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
450 // curly brace level count. |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
451 int m_braceflag; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
452 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
453 // true means we're in the middle of defining a loop. |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
454 int m_looping; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
455 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
456 // nonzero means we're in the middle of defining a function. |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
457 int m_defining_func; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
458 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
459 // nonzero means we are parsing a function handle. |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
460 int m_looking_at_function_handle; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
461 |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
462 // nestng level for block comments. |
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
463 int m_block_comment_nesting_level; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
464 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
465 // Parenthesis count for command argument parsing. |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
466 int m_command_arg_paren_count; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
467 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
468 // Count of tokens recognized by this lexer since initialized or |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
469 // since the last reset. |
29654
d13d090cb03a
use std::size_t and std::ptrdiff_t in C++ code (bug #60471)
John W. Eaton <jwe@octave.org>
parents:
29358
diff
changeset
|
470 std::size_t m_token_count; |
16104
c8974e28da59
move nesting_level to lexical_feedback class
John W. Eaton <jwe@octave.org>
parents:
16103
diff
changeset
|
471 |
27766
0ca7f17de041
use file position object to track line and column info in lexer and parser
John W. Eaton <jwe@octave.org>
parents:
27736
diff
changeset
|
472 // The current position in the file (line and column). |
0ca7f17de041
use file position object to track line and column info in lexer and parser
John W. Eaton <jwe@octave.org>
parents:
27736
diff
changeset
|
473 filepos m_filepos; |
0ca7f17de041
use file position object to track line and column info in lexer and parser
John W. Eaton <jwe@octave.org>
parents:
27736
diff
changeset
|
474 |
27778
2f8559459314
store beginning and ending location info for tokens recognized by lexer
John W. Eaton <jwe@octave.org>
parents:
27777
diff
changeset
|
475 // The positions of the beginning and end of the current token after |
2f8559459314
store beginning and ending location info for tokens recognized by lexer
John W. Eaton <jwe@octave.org>
parents:
27777
diff
changeset
|
476 // calling update_token_positions. Also used apart from |
2f8559459314
store beginning and ending location info for tokens recognized by lexer
John W. Eaton <jwe@octave.org>
parents:
27777
diff
changeset
|
477 // update_token_positions to handle the beginning and end of |
2f8559459314
store beginning and ending location info for tokens recognized by lexer
John W. Eaton <jwe@octave.org>
parents:
27777
diff
changeset
|
478 // character strings. |
2f8559459314
store beginning and ending location info for tokens recognized by lexer
John W. Eaton <jwe@octave.org>
parents:
27777
diff
changeset
|
479 filepos m_tok_beg; |
2f8559459314
store beginning and ending location info for tokens recognized by lexer
John W. Eaton <jwe@octave.org>
parents:
27777
diff
changeset
|
480 filepos m_tok_end; |
27768
d6701f835496
use filepos object to store beginning position of character strings
John W. Eaton <jwe@octave.org>
parents:
27766
diff
changeset
|
481 |
d6701f835496
use filepos object to store beginning position of character strings
John W. Eaton <jwe@octave.org>
parents:
27766
diff
changeset
|
482 // The current character string text. |
d6701f835496
use filepos object to store beginning position of character strings
John W. Eaton <jwe@octave.org>
parents:
27766
diff
changeset
|
483 std::string m_string_text; |
d6701f835496
use filepos object to store beginning position of character strings
John W. Eaton <jwe@octave.org>
parents:
27766
diff
changeset
|
484 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
485 // The current line of input. |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
486 std::string m_current_input_line; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
487 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
488 // The current comment text. |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
489 std::string m_comment_text; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
490 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
491 // The current help text. |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
492 std::string m_help_text; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
493 |
23730
85f1d31956c0
make echo work for command-line functions
John W. Eaton <jwe@octave.org>
parents:
23693
diff
changeset
|
494 // The text of functions entered on the command line. |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
495 std::string m_function_text; |
23730
85f1d31956c0
make echo work for command-line functions
John W. Eaton <jwe@octave.org>
parents:
23693
diff
changeset
|
496 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
497 // Simple name of function file we are reading. |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
498 std::string m_fcn_file_name; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
499 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
500 // Full name of file we are reading. |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
501 std::string m_fcn_file_full_name; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
502 |
23667
2d4a7ae1f6cd
store directory and package names in function when function is parsed
John W. Eaton <jwe@octave.org>
parents:
23602
diff
changeset
|
503 // Directory name where this file was found. May be relative. |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
504 std::string m_dir_name; |
23667
2d4a7ae1f6cd
store directory and package names in function when function is parsed
John W. Eaton <jwe@octave.org>
parents:
23602
diff
changeset
|
505 |
2d4a7ae1f6cd
store directory and package names in function when function is parsed
John W. Eaton <jwe@octave.org>
parents:
23602
diff
changeset
|
506 // Name of +package containing this file, if any. |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
507 std::string m_package_name; |
23667
2d4a7ae1f6cd
store directory and package names in function when function is parsed
John W. Eaton <jwe@octave.org>
parents:
23602
diff
changeset
|
508 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
509 // if the front of the list is true, the closest paren, brace, or |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
510 // bracket nesting is an index for an object. |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
511 std::list<bool> m_looking_at_object_index; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
512 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
513 // if the top of the stack is true, then we've already seen the name |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
514 // of the current function. should only matter if |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
515 // current_function_level > 0 |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
516 std::stack<bool> m_parsed_function_name; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
517 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
518 // set of identifiers that might be local variable names. |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
519 std::set<std::string> m_pending_local_variables; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
520 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
521 // Track current symbol table scope and context. |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
522 symbol_table_context m_symtab_context; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
523 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
524 // is the closest nesting level a square bracket, squiggly brace, |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
525 // a paren, or an anonymous function body? |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
526 bbp_nesting_level m_nesting_level; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
527 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
528 // Tokens generated by the lexer. |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
529 token_cache m_tokens; |
16230
4bf907906134
use a queue to hold tokens in the lexer
John W. Eaton <jwe@octave.org>
parents:
16229
diff
changeset
|
530 }; |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
531 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
532 // base_lexer inherits from lexical_feedback because we will |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
533 // eventually have several different constructors and it is easier to |
27983
44a019d01aa5
fix more spelling errors (bug #57613)
Mike Miller <mtmiller@octave.org>
parents:
26376
diff
changeset
|
534 // initialize if everything is grouped in a parent class rather than |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
535 // listing all the members in the base_lexer class. |
16193
d7392bf42fd1
use inheritance to simplify initialization in octave_lexer constructor
John W. Eaton <jwe@octave.org>
parents:
16185
diff
changeset
|
536 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
537 class |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
538 base_lexer : public lexical_feedback |
16183
359d56094efa
handle lexer input buffering with class
John W. Eaton <jwe@octave.org>
parents:
16164
diff
changeset
|
539 { |
359d56094efa
handle lexer input buffering with class
John W. Eaton <jwe@octave.org>
parents:
16164
diff
changeset
|
540 public: |
359d56094efa
handle lexer input buffering with class
John W. Eaton <jwe@octave.org>
parents:
16164
diff
changeset
|
541 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
542 // Handle buffering of input for lexer. |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
543 |
25103
078b795c5219
maint: style check C++ ahead of 4.4 release.
Rik <rik@octave.org>
parents:
25054
diff
changeset
|
544 class input_buffer |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
545 { |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
546 public: |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
547 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
548 input_buffer (void) |
28407
808e3964987b
accept multi-line interactive input (bug #58370)
John W. Eaton <jwe@octave.org>
parents:
28264
diff
changeset
|
549 : m_buffer (), m_offset (0), m_chars_left (0), m_eof (false) |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
550 { } |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
551 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
552 void fill (const std::string& input, bool eof_arg); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
553 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
554 // Copy at most max_size characters to buf. |
29654
d13d090cb03a
use std::size_t and std::ptrdiff_t in C++ code (bug #60471)
John W. Eaton <jwe@octave.org>
parents:
29358
diff
changeset
|
555 int copy_chunk (char *buf, std::size_t max_size, bool by_lines = false); |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
556 |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
557 bool empty (void) const { return m_chars_left == 0; } |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
558 |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
559 bool at_eof (void) const { return m_eof; } |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
560 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
561 private: |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
562 |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
563 std::string m_buffer; |
29654
d13d090cb03a
use std::size_t and std::ptrdiff_t in C++ code (bug #60471)
John W. Eaton <jwe@octave.org>
parents:
29358
diff
changeset
|
564 std::size_t m_offset; |
d13d090cb03a
use std::size_t and std::ptrdiff_t in C++ code (bug #60471)
John W. Eaton <jwe@octave.org>
parents:
29358
diff
changeset
|
565 std::size_t m_chars_left; |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
566 bool m_eof; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
567 }; |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
568 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
569 // Collect comment text. |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
570 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
571 class |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
572 comment_buffer |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
573 { |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
574 public: |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
575 |
23795
980f39c3ab90
Use C++11 nullptr rather than 0 in code (bug #51565).
Rik <rik@octave.org>
parents:
23750
diff
changeset
|
576 comment_buffer (void) : m_comment_list (nullptr) { } |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
577 |
23750
ea879bc55272
move comment_list and comment_elt classes to octave namespace
John W. Eaton <jwe@octave.org>
parents:
23730
diff
changeset
|
578 ~comment_buffer (void) { delete m_comment_list; } |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
579 |
23750
ea879bc55272
move comment_list and comment_elt classes to octave namespace
John W. Eaton <jwe@octave.org>
parents:
23730
diff
changeset
|
580 void append (const std::string& s, comment_elt::comment_type t) |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
581 { |
23750
ea879bc55272
move comment_list and comment_elt classes to octave namespace
John W. Eaton <jwe@octave.org>
parents:
23730
diff
changeset
|
582 if (! m_comment_list) |
ea879bc55272
move comment_list and comment_elt classes to octave namespace
John W. Eaton <jwe@octave.org>
parents:
23730
diff
changeset
|
583 m_comment_list = new comment_list (); |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
584 |
23750
ea879bc55272
move comment_list and comment_elt classes to octave namespace
John W. Eaton <jwe@octave.org>
parents:
23730
diff
changeset
|
585 m_comment_list->append (s, t); |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
586 } |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
587 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
588 // Caller is expected to delete the returned value. |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
589 |
23750
ea879bc55272
move comment_list and comment_elt classes to octave namespace
John W. Eaton <jwe@octave.org>
parents:
23730
diff
changeset
|
590 comment_list * get_comment (void) |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
591 { |
23750
ea879bc55272
move comment_list and comment_elt classes to octave namespace
John W. Eaton <jwe@octave.org>
parents:
23730
diff
changeset
|
592 comment_list *retval = m_comment_list; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
593 |
23795
980f39c3ab90
Use C++11 nullptr rather than 0 in code (bug #51565).
Rik <rik@octave.org>
parents:
23750
diff
changeset
|
594 m_comment_list = nullptr; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
595 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
596 return retval; |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
597 } |
16183
359d56094efa
handle lexer input buffering with class
John W. Eaton <jwe@octave.org>
parents:
16164
diff
changeset
|
598 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
599 void reset (void) |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
600 { |
23750
ea879bc55272
move comment_list and comment_elt classes to octave namespace
John W. Eaton <jwe@octave.org>
parents:
23730
diff
changeset
|
601 delete m_comment_list; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
602 |
23795
980f39c3ab90
Use C++11 nullptr rather than 0 in code (bug #51565).
Rik <rik@octave.org>
parents:
23750
diff
changeset
|
603 m_comment_list = nullptr; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
604 } |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
605 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
606 private: |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
607 |
23750
ea879bc55272
move comment_list and comment_elt classes to octave namespace
John W. Eaton <jwe@octave.org>
parents:
23730
diff
changeset
|
608 comment_list *m_comment_list; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
609 }; |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
610 |
25441
143007dad864
store reference instead of pointer to interpreter in lexer
John W. Eaton <jwe@octave.org>
parents:
25438
diff
changeset
|
611 base_lexer (interpreter& interp) |
27526
cb964b74d8a0
Backed out changeset 28ed77ca1e4a
John W. Eaton <jwe@octave.org>
parents:
27513
diff
changeset
|
612 : lexical_feedback (interp), m_scanner (nullptr), m_input_buf (), |
cb964b74d8a0
Backed out changeset 28ed77ca1e4a
John W. Eaton <jwe@octave.org>
parents:
27513
diff
changeset
|
613 m_comment_buf () |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
614 { |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
615 init (); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
616 } |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
617 |
22869
f75d289645ec
make deleted functions public
John W. Eaton <jwe@octave.org>
parents:
22868
diff
changeset
|
618 // No copying! |
f75d289645ec
make deleted functions public
John W. Eaton <jwe@octave.org>
parents:
22868
diff
changeset
|
619 |
f75d289645ec
make deleted functions public
John W. Eaton <jwe@octave.org>
parents:
22868
diff
changeset
|
620 base_lexer (const base_lexer&) = delete; |
f75d289645ec
make deleted functions public
John W. Eaton <jwe@octave.org>
parents:
22868
diff
changeset
|
621 |
f75d289645ec
make deleted functions public
John W. Eaton <jwe@octave.org>
parents:
22868
diff
changeset
|
622 base_lexer& operator = (const base_lexer&) = delete; |
f75d289645ec
make deleted functions public
John W. Eaton <jwe@octave.org>
parents:
22868
diff
changeset
|
623 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
624 virtual ~base_lexer (void); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
625 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
626 void init (void); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
627 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
628 virtual bool is_push_lexer (void) const { return false; } |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
629 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
630 virtual void reset (void); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
631 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
632 void prep_for_file (void); |
16183
359d56094efa
handle lexer input buffering with class
John W. Eaton <jwe@octave.org>
parents:
16164
diff
changeset
|
633 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
634 void begin_string (int state); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
635 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
636 virtual int fill_flex_buffer (char *buf, unsigned int max_size) = 0; |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
637 |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
638 bool at_end_of_buffer (void) const { return m_input_buf.empty (); } |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
639 |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
640 bool at_end_of_file (void) const { return m_input_buf.at_eof (); } |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
641 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
642 int handle_end_of_input (void); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
643 |
23446
cd4e1ee28716
maint: Use convention 'void * fcn ()' for functions which return pointers.
Rik <rik@octave.org>
parents:
23220
diff
changeset
|
644 char * flex_yytext (void); |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
645 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
646 int flex_yyleng (void); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
647 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
648 int text_yyinput (void); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
649 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
650 void xunput (char c, char *buf); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
651 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
652 void xunput (char c); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
653 |
27778
2f8559459314
store beginning and ending location info for tokens recognized by lexer
John W. Eaton <jwe@octave.org>
parents:
27777
diff
changeset
|
654 void update_token_positions (int tok_len); |
2f8559459314
store beginning and ending location info for tokens recognized by lexer
John W. Eaton <jwe@octave.org>
parents:
27777
diff
changeset
|
655 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
656 bool looking_at_space (void); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
657 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
658 bool inside_any_object_index (void); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
659 |
29723
6858992dfadf
enter symbols into current scope in parser instead of lexer
John W. Eaton <jwe@octave.org>
parents:
29655
diff
changeset
|
660 bool is_variable (const std::string& name); |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
661 |
27771
cd566153edd6
split base_lexer::is_keyword_token into two functions
John W. Eaton <jwe@octave.org>
parents:
27768
diff
changeset
|
662 int make_keyword_token (const std::string& s); |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
663 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
664 bool fq_identifier_contains_keyword (const std::string& s); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
665 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
666 bool whitespace_is_significant (void); |
16183
359d56094efa
handle lexer input buffering with class
John W. Eaton <jwe@octave.org>
parents:
16164
diff
changeset
|
667 |
28583
96e7dc4c2214
improve Matlab compatibility for binary and hexadecimal constants
John W. Eaton <jwe@octave.org>
parents:
28565
diff
changeset
|
668 // We only provide specializations with base equal to 2, 10, or 16. |
96e7dc4c2214
improve Matlab compatibility for binary and hexadecimal constants
John W. Eaton <jwe@octave.org>
parents:
28565
diff
changeset
|
669 template <int base> |
96e7dc4c2214
improve Matlab compatibility for binary and hexadecimal constants
John W. Eaton <jwe@octave.org>
parents:
28565
diff
changeset
|
670 int handle_number (void); |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
671 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
672 void handle_continuation (void); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
673 |
23750
ea879bc55272
move comment_list and comment_elt classes to octave namespace
John W. Eaton <jwe@octave.org>
parents:
23730
diff
changeset
|
674 void finish_comment (comment_elt::comment_type typ); |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
675 |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
676 comment_list * get_comment (void) { return m_comment_buf.get_comment (); } |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
677 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
678 int handle_close_bracket (int bracket_type); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
679 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
680 bool looks_like_command_arg (void); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
681 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
682 int handle_superclass_identifier (void); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
683 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
684 int handle_meta_identifier (void); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
685 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
686 int handle_fq_identifier (void); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
687 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
688 int handle_identifier (void); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
689 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
690 void maybe_warn_separator_insert (char sep); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
691 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
692 void warn_single_quote_string (void); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
693 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
694 void warn_language_extension (const std::string& msg); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
695 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
696 void maybe_warn_language_extension_comment (char c); |
16183
359d56094efa
handle lexer input buffering with class
John W. Eaton <jwe@octave.org>
parents:
16164
diff
changeset
|
697 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
698 void warn_language_extension_continuation (void); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
699 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
700 void warn_language_extension_operator (const std::string& op); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
701 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
702 void push_token (token *); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
703 |
23446
cd4e1ee28716
maint: Use convention 'void * fcn ()' for functions which return pointers.
Rik <rik@octave.org>
parents:
23220
diff
changeset
|
704 token * current_token (void); |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
705 |
29654
d13d090cb03a
use std::size_t and std::ptrdiff_t in C++ code (bug #60471)
John W. Eaton <jwe@octave.org>
parents:
29358
diff
changeset
|
706 std::size_t pending_token_count (void) const; |
28264
d938c4d22200
handle comments in multi-line statements with push parser/lexer (bug #58198)
John W. Eaton <jwe@octave.org>
parents:
28156
diff
changeset
|
707 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
708 void display_token (int tok); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
709 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
710 void fatal_error (const char *msg); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
711 |
25443
2fa7cd178c4a
new class for miscellaneous interpreter settings
John W. Eaton <jwe@octave.org>
parents:
25441
diff
changeset
|
712 bool debug_flag (void) const; |
2fa7cd178c4a
new class for miscellaneous interpreter settings
John W. Eaton <jwe@octave.org>
parents:
25441
diff
changeset
|
713 |
2fa7cd178c4a
new class for miscellaneous interpreter settings
John W. Eaton <jwe@octave.org>
parents:
25441
diff
changeset
|
714 bool display_tokens (void) const; |
2fa7cd178c4a
new class for miscellaneous interpreter settings
John W. Eaton <jwe@octave.org>
parents:
25441
diff
changeset
|
715 |
2fa7cd178c4a
new class for miscellaneous interpreter settings
John W. Eaton <jwe@octave.org>
parents:
25441
diff
changeset
|
716 void increment_token_count (void); |
2fa7cd178c4a
new class for miscellaneous interpreter settings
John W. Eaton <jwe@octave.org>
parents:
25441
diff
changeset
|
717 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
718 void lexer_debug (const char *pattern); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
719 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
720 // Internal state of the flex-generated lexer. |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
721 void *m_scanner; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
722 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
723 // Object that reads and buffers input. |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
724 input_buffer m_input_buf; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
725 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
726 // Object that collects comment text. |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
727 comment_buffer m_comment_buf; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
728 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
729 virtual std::string input_source (void) const { return "unknown"; } |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
730 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
731 virtual bool input_from_terminal (void) const { return false; } |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
732 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
733 virtual bool input_from_file (void) const { return false; } |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
734 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
735 virtual bool input_from_eval_string (void) const { return false; } |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
736 |
25994
f881d3e271d2
eliminate global and file-scope static variables in oct-hist.cc
John W. Eaton <jwe@octave.org>
parents:
25443
diff
changeset
|
737 bool input_from_tmp_history_file (void); |
f881d3e271d2
eliminate global and file-scope static variables in oct-hist.cc
John W. Eaton <jwe@octave.org>
parents:
25443
diff
changeset
|
738 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
739 void push_start_state (int state); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
740 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
741 void pop_start_state (void); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
742 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
743 void clear_start_state (void); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
744 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
745 int start_state (void) const { return start_state_stack.top (); } |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
746 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
747 void display_start_state (void) const; |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
748 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
749 bool maybe_unput_comma_before_unary_op (int tok); |
16183
359d56094efa
handle lexer input buffering with class
John W. Eaton <jwe@octave.org>
parents:
16164
diff
changeset
|
750 |
28149
026bff6a54d7
improve position tracking in the lexer (bug #57924)
John W. Eaton <jwe@octave.org>
parents:
27987
diff
changeset
|
751 int handle_op (int tok, bool bos = false, bool compat = true); |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
752 |
27777
3b6920ee4383
eliminate COMMAND_ARG_FINISH macro in lexer
John W. Eaton <jwe@octave.org>
parents:
27771
diff
changeset
|
753 int finish_command_arg (void); |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
754 |
23457
21baad6b35c4
maint: Use C++11 nullptr rather than 0 or NULL when possible.
Rik <rik@octave.org>
parents:
23446
diff
changeset
|
755 int handle_token (int tok, token *tok_val = nullptr); |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
756 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
757 int count_token (int tok); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
758 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
759 int count_token_internal (int tok); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
760 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
761 int show_token (int tok); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
762 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
763 protected: |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
764 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
765 std::stack<int> start_state_stack; |
16183
359d56094efa
handle lexer input buffering with class
John W. Eaton <jwe@octave.org>
parents:
16164
diff
changeset
|
766 }; |
359d56094efa
handle lexer input buffering with class
John W. Eaton <jwe@octave.org>
parents:
16164
diff
changeset
|
767 |
17693
efbe746f8fa8
eliminate octave_comment_buffer singleton
John W. Eaton <jwe@octave.org>
parents:
16898
diff
changeset
|
768 class |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
769 lexer : public base_lexer |
17693
efbe746f8fa8
eliminate octave_comment_buffer singleton
John W. Eaton <jwe@octave.org>
parents:
16898
diff
changeset
|
770 { |
efbe746f8fa8
eliminate octave_comment_buffer singleton
John W. Eaton <jwe@octave.org>
parents:
16898
diff
changeset
|
771 public: |
efbe746f8fa8
eliminate octave_comment_buffer singleton
John W. Eaton <jwe@octave.org>
parents:
16898
diff
changeset
|
772 |
25441
143007dad864
store reference instead of pointer to interpreter in lexer
John W. Eaton <jwe@octave.org>
parents:
25438
diff
changeset
|
773 lexer (interpreter& interp) |
27528
e51284fc0a51
eliminate promptflag from the lexer and input reader classes
John W. Eaton <jwe@octave.org>
parents:
27527
diff
changeset
|
774 : base_lexer (interp), m_reader (interp), m_initial_input (true) |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
775 { } |
17693
efbe746f8fa8
eliminate octave_comment_buffer singleton
John W. Eaton <jwe@octave.org>
parents:
16898
diff
changeset
|
776 |
25441
143007dad864
store reference instead of pointer to interpreter in lexer
John W. Eaton <jwe@octave.org>
parents:
25438
diff
changeset
|
777 lexer (FILE *file, interpreter& interp) |
27528
e51284fc0a51
eliminate promptflag from the lexer and input reader classes
John W. Eaton <jwe@octave.org>
parents:
27527
diff
changeset
|
778 : base_lexer (interp), m_reader (interp, file), m_initial_input (true) |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
779 { } |
17693
efbe746f8fa8
eliminate octave_comment_buffer singleton
John W. Eaton <jwe@octave.org>
parents:
16898
diff
changeset
|
780 |
28953
dff830c84726
Add function "dir_encoding" to set a file encoding per directory (bug #49685).
Markus Mützel <markus.muetzel@gmx.de>
parents:
28583
diff
changeset
|
781 lexer (FILE *file, interpreter& interp, const 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:
28583
diff
changeset
|
782 : base_lexer (interp), m_reader (interp, file, encoding), m_initial_input (true) |
dff830c84726
Add function "dir_encoding" to set a file encoding per directory (bug #49685).
Markus Mützel <markus.muetzel@gmx.de>
parents:
28583
diff
changeset
|
783 { } |
dff830c84726
Add function "dir_encoding" to set a file encoding per directory (bug #49685).
Markus Mützel <markus.muetzel@gmx.de>
parents:
28583
diff
changeset
|
784 |
25441
143007dad864
store reference instead of pointer to interpreter in lexer
John W. Eaton <jwe@octave.org>
parents:
25438
diff
changeset
|
785 lexer (const std::string& eval_string, interpreter& interp) |
27528
e51284fc0a51
eliminate promptflag from the lexer and input reader classes
John W. Eaton <jwe@octave.org>
parents:
27527
diff
changeset
|
786 : base_lexer (interp), m_reader (interp, eval_string), |
e51284fc0a51
eliminate promptflag from the lexer and input reader classes
John W. Eaton <jwe@octave.org>
parents:
27527
diff
changeset
|
787 m_initial_input (true) |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
788 { } |
17693
efbe746f8fa8
eliminate octave_comment_buffer singleton
John W. Eaton <jwe@octave.org>
parents:
16898
diff
changeset
|
789 |
22869
f75d289645ec
make deleted functions public
John W. Eaton <jwe@octave.org>
parents:
22868
diff
changeset
|
790 // No copying! |
f75d289645ec
make deleted functions public
John W. Eaton <jwe@octave.org>
parents:
22868
diff
changeset
|
791 |
f75d289645ec
make deleted functions public
John W. Eaton <jwe@octave.org>
parents:
22868
diff
changeset
|
792 lexer (const lexer&) = delete; |
f75d289645ec
make deleted functions public
John W. Eaton <jwe@octave.org>
parents:
22868
diff
changeset
|
793 |
f75d289645ec
make deleted functions public
John W. Eaton <jwe@octave.org>
parents:
22868
diff
changeset
|
794 lexer& operator = (const lexer&) = delete; |
f75d289645ec
make deleted functions public
John W. Eaton <jwe@octave.org>
parents:
22868
diff
changeset
|
795 |
17693
efbe746f8fa8
eliminate octave_comment_buffer singleton
John W. Eaton <jwe@octave.org>
parents:
16898
diff
changeset
|
796 void reset (void) |
efbe746f8fa8
eliminate octave_comment_buffer singleton
John W. Eaton <jwe@octave.org>
parents:
16898
diff
changeset
|
797 { |
27528
e51284fc0a51
eliminate promptflag from the lexer and input reader classes
John W. Eaton <jwe@octave.org>
parents:
27527
diff
changeset
|
798 m_initial_input = true; |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
799 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
800 base_lexer::reset (); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
801 } |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
802 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
803 std::string input_source (void) const |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
804 { |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
805 return m_reader.input_source (); |
17693
efbe746f8fa8
eliminate octave_comment_buffer singleton
John W. Eaton <jwe@octave.org>
parents:
16898
diff
changeset
|
806 } |
efbe746f8fa8
eliminate octave_comment_buffer singleton
John W. Eaton <jwe@octave.org>
parents:
16898
diff
changeset
|
807 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
808 bool input_from_terminal (void) const |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
809 { |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
810 return m_reader.input_from_terminal (); |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
811 } |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
812 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
813 bool input_from_file (void) const |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
814 { |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
815 return m_reader.input_from_file (); |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
816 } |
17693
efbe746f8fa8
eliminate octave_comment_buffer singleton
John W. Eaton <jwe@octave.org>
parents:
16898
diff
changeset
|
817 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
818 bool input_from_eval_string (void) const |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
819 { |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
820 return m_reader.input_from_eval_string (); |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
821 } |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
822 |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
823 int fill_flex_buffer (char *buf, unsigned int max_size); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
824 |
24833
7c88cf242111
use m_ prefix for data members in more classes
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
825 input_reader m_reader; |
27528
e51284fc0a51
eliminate promptflag from the lexer and input reader classes
John W. Eaton <jwe@octave.org>
parents:
27527
diff
changeset
|
826 |
e51284fc0a51
eliminate promptflag from the lexer and input reader classes
John W. Eaton <jwe@octave.org>
parents:
27527
diff
changeset
|
827 // TRUE means we are filling the input buffer for the first time. |
e51284fc0a51
eliminate promptflag from the lexer and input reader classes
John W. Eaton <jwe@octave.org>
parents:
27527
diff
changeset
|
828 // Otherwise, we are requesting more input to complete the parse |
e51284fc0a51
eliminate promptflag from the lexer and input reader classes
John W. Eaton <jwe@octave.org>
parents:
27527
diff
changeset
|
829 // and, if printing a prompt, should use the secondary prompt |
e51284fc0a51
eliminate promptflag from the lexer and input reader classes
John W. Eaton <jwe@octave.org>
parents:
27527
diff
changeset
|
830 // string. |
e51284fc0a51
eliminate promptflag from the lexer and input reader classes
John W. Eaton <jwe@octave.org>
parents:
27527
diff
changeset
|
831 |
e51284fc0a51
eliminate promptflag from the lexer and input reader classes
John W. Eaton <jwe@octave.org>
parents:
27527
diff
changeset
|
832 bool m_initial_input; |
17693
efbe746f8fa8
eliminate octave_comment_buffer singleton
John W. Eaton <jwe@octave.org>
parents:
16898
diff
changeset
|
833 }; |
efbe746f8fa8
eliminate octave_comment_buffer singleton
John W. Eaton <jwe@octave.org>
parents:
16898
diff
changeset
|
834 |
28583
96e7dc4c2214
improve Matlab compatibility for binary and hexadecimal constants
John W. Eaton <jwe@octave.org>
parents:
28565
diff
changeset
|
835 template <> int base_lexer::handle_number<2> (); |
96e7dc4c2214
improve Matlab compatibility for binary and hexadecimal constants
John W. Eaton <jwe@octave.org>
parents:
28565
diff
changeset
|
836 template <> int base_lexer::handle_number<10> (); |
96e7dc4c2214
improve Matlab compatibility for binary and hexadecimal constants
John W. Eaton <jwe@octave.org>
parents:
28565
diff
changeset
|
837 template <> int base_lexer::handle_number<16> (); |
96e7dc4c2214
improve Matlab compatibility for binary and hexadecimal constants
John W. Eaton <jwe@octave.org>
parents:
28565
diff
changeset
|
838 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
839 class |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
840 push_lexer : public base_lexer |
16195
b52d2f9294b6
use class for reading lexer input
John W. Eaton <jwe@octave.org>
parents:
16194
diff
changeset
|
841 { |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
842 public: |
16113
7c5e5e97a3bc
move static lexer helper functions to lexical_feedback class
John W. Eaton <jwe@octave.org>
parents:
16111
diff
changeset
|
843 |
25441
143007dad864
store reference instead of pointer to interpreter in lexer
John W. Eaton <jwe@octave.org>
parents:
25438
diff
changeset
|
844 push_lexer (interpreter& interp) |
27527
73be3c628eac
refactor input_reader class and its use in lexer
John W. Eaton <jwe@octave.org>
parents:
27526
diff
changeset
|
845 : base_lexer (interp) |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
846 { |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
847 append_input ("", false); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
848 } |
16253
a89cf57ba3a5
partial cleanup of continuation handling in lexer
John W. Eaton <jwe@octave.org>
parents:
16231
diff
changeset
|
849 |
25441
143007dad864
store reference instead of pointer to interpreter in lexer
John W. Eaton <jwe@octave.org>
parents:
25438
diff
changeset
|
850 push_lexer (const std::string& input, interpreter& interp) |
27527
73be3c628eac
refactor input_reader class and its use in lexer
John W. Eaton <jwe@octave.org>
parents:
27526
diff
changeset
|
851 : base_lexer (interp) |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
852 { |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
853 append_input (input, false); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
854 } |
16113
7c5e5e97a3bc
move static lexer helper functions to lexical_feedback class
John W. Eaton <jwe@octave.org>
parents:
16111
diff
changeset
|
855 |
25441
143007dad864
store reference instead of pointer to interpreter in lexer
John W. Eaton <jwe@octave.org>
parents:
25438
diff
changeset
|
856 push_lexer (bool eof, interpreter& interp) |
27527
73be3c628eac
refactor input_reader class and its use in lexer
John W. Eaton <jwe@octave.org>
parents:
27526
diff
changeset
|
857 : base_lexer (interp) |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
858 { |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
859 append_input ("", eof); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
860 } |
16209
e7ff32e7cf82
move global promptflag variable to octave_reader class
John W. Eaton <jwe@octave.org>
parents:
16207
diff
changeset
|
861 |
25441
143007dad864
store reference instead of pointer to interpreter in lexer
John W. Eaton <jwe@octave.org>
parents:
25438
diff
changeset
|
862 push_lexer (const std::string& input, bool eof, interpreter& interp) |
27527
73be3c628eac
refactor input_reader class and its use in lexer
John W. Eaton <jwe@octave.org>
parents:
27526
diff
changeset
|
863 : base_lexer (interp) |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
864 { |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
865 append_input (input, eof); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
866 } |
16224
4a848eb52de2
use stack for tracking lexer start states
John W. Eaton <jwe@octave.org>
parents:
16209
diff
changeset
|
867 |
22869
f75d289645ec
make deleted functions public
John W. Eaton <jwe@octave.org>
parents:
22868
diff
changeset
|
868 // No copying! |
f75d289645ec
make deleted functions public
John W. Eaton <jwe@octave.org>
parents:
22868
diff
changeset
|
869 |
f75d289645ec
make deleted functions public
John W. Eaton <jwe@octave.org>
parents:
22868
diff
changeset
|
870 push_lexer (const push_lexer&) = delete; |
f75d289645ec
make deleted functions public
John W. Eaton <jwe@octave.org>
parents:
22868
diff
changeset
|
871 |
f75d289645ec
make deleted functions public
John W. Eaton <jwe@octave.org>
parents:
22868
diff
changeset
|
872 push_lexer& operator = (const push_lexer&) = delete; |
f75d289645ec
make deleted functions public
John W. Eaton <jwe@octave.org>
parents:
22868
diff
changeset
|
873 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
874 bool is_push_lexer (void) const { return true; } |
16263
9acb86e6ac90
4/10 commits reworking the lexer
John W. Eaton <jwe@octave.org>
parents:
16259
diff
changeset
|
875 |
23730
85f1d31956c0
make echo work for command-line functions
John W. Eaton <jwe@octave.org>
parents:
23693
diff
changeset
|
876 void append_input (const std::string& input, bool eof); |
16293
57e87ddfee14
create base class for lexer
John W. Eaton <jwe@octave.org>
parents:
16292
diff
changeset
|
877 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
878 std::string input_source (void) const { return "push buffer"; } |
16294
0925d1f6875e
push parser/lexer interface
John W. Eaton <jwe@octave.org>
parents:
16293
diff
changeset
|
879 |
22196
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
880 int fill_flex_buffer (char *buf, unsigned int max_size); |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
881 }; |
dd992fd74fce
put parser, lexer, and evaluator in namespace; interpreter now owns evaluator
John W. Eaton <jwe@octave.org>
parents:
21814
diff
changeset
|
882 } |
16294
0925d1f6875e
push parser/lexer interface
John W. Eaton <jwe@octave.org>
parents:
16293
diff
changeset
|
883 |
1 | 884 #endif |