1 /* Parser definitions for GDB.
3 Copyright (C) 1986-2021 Free Software Foundation, Inc.
5 Modified from expread.y by the Department of Computer Science at the
6 State University of New York at Buffalo.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #if !defined (PARSER_DEFS_H)
24 #define PARSER_DEFS_H 1
26 #include "expression.h"
33 class innermost_block_tracker
;
35 extern bool parser_debug
;
37 /* A class that can be used to build a "struct expression". */
41 /* Constructor. LANG is the language used to parse the expression.
42 And GDBARCH is the gdbarch to use during parsing. */
44 expr_builder (const struct language_defn
*lang
,
45 struct gdbarch
*gdbarch
);
47 DISABLE_COPY_AND_ASSIGN (expr_builder
);
49 /* Resize the allocated expression to the correct size, and return
50 it as an expression_up -- passing ownership to the caller. */
51 ATTRIBUTE_UNUSED_RESULT expression_up
release ();
53 /* Return the gdbarch that was passed to the constructor. */
55 struct gdbarch
*gdbarch ()
57 return expout
->gdbarch
;
60 /* Return the language that was passed to the constructor. */
62 const struct language_defn
*language ()
64 return expout
->language_defn
;
67 /* Set the root operation of the expression that is currently being
69 void set_operation (expr::operation_up
&&op
)
71 expout
->op
= std::move (op
);
74 /* The expression related to this parser state. */
79 /* This is used for expression completion. */
81 struct expr_completion_state
83 /* The last struct expression directly before a '.' or '->'. This
84 is set when parsing and is only used when completing a field
85 name. It is nullptr if no dereference operation was found. */
86 expr::structop_base_operation
*expout_last_op
= nullptr;
88 /* If we are completing a tagged type name, this will be nonzero. */
89 enum type_code expout_tag_completion_type
= TYPE_CODE_UNDEF
;
91 /* The token for tagged type name completion. */
92 gdb::unique_xmalloc_ptr
<char> expout_completion_name
;
95 /* An instance of this type is instantiated during expression parsing,
96 and passed to the appropriate parser. It holds both inputs to the
97 parser, and result. */
99 struct parser_state
: public expr_builder
101 /* Constructor. LANG is the language used to parse the expression.
102 And GDBARCH is the gdbarch to use during parsing. */
104 parser_state (const struct language_defn
*lang
,
105 struct gdbarch
*gdbarch
,
106 const struct block
*context_block
,
107 CORE_ADDR context_pc
,
111 innermost_block_tracker
*tracker
,
113 : expr_builder (lang
, gdbarch
),
114 expression_context_block (context_block
),
115 expression_context_pc (context_pc
),
116 comma_terminates (comma
),
118 parse_completion (completion
),
119 block_tracker (tracker
),
120 void_context_p (void_p
)
124 DISABLE_COPY_AND_ASSIGN (parser_state
);
126 /* Begin counting arguments for a function call,
127 saving the data about any containing call. */
129 void start_arglist ()
131 m_funcall_chain
.push_back (arglist_len
);
135 /* Return the number of arguments in a function call just terminated,
136 and restore the data for the containing function call. */
140 int val
= arglist_len
;
141 arglist_len
= m_funcall_chain
.back ();
142 m_funcall_chain
.pop_back ();
146 /* Mark the given operation as the starting location of a structure
147 expression. This is used when completing on field names. */
149 void mark_struct_expression (expr::structop_base_operation
*op
);
151 /* Indicate that the current parser invocation is completing a tag.
152 TAG is the type code of the tag, and PTR and LENGTH represent the
153 start of the tag name. */
155 void mark_completion_tag (enum type_code tag
, const char *ptr
, int length
);
157 /* Push an operation on the stack. */
158 void push (expr::operation_up
&&op
)
160 m_operations
.push_back (std::move (op
));
163 /* Create a new operation and push it on the stack. */
164 template<typename T
, typename
... Arg
>
165 void push_new (Arg
... args
)
167 m_operations
.emplace_back (new T (std::forward
<Arg
> (args
)...));
170 /* Push a new C string operation. */
171 void push_c_string (int, struct stoken_vector
*vec
);
173 /* Push a symbol reference. If SYM is nullptr, look for a minimal
175 void push_symbol (const char *name
, block_symbol sym
);
177 /* Push a reference to $mumble. This may result in a convenience
178 variable, a history reference, or a register. */
179 void push_dollar (struct stoken str
);
181 /* Pop an operation from the stack. */
182 expr::operation_up
pop ()
184 expr::operation_up result
= std::move (m_operations
.back ());
185 m_operations
.pop_back ();
189 /* Pop N elements from the stack and return a vector. */
190 std::vector
<expr::operation_up
> pop_vector (int n
)
192 std::vector
<expr::operation_up
> result (n
);
193 for (int i
= 1; i
<= n
; ++i
)
194 result
[n
- i
] = pop ();
198 /* A helper that pops an operation, wraps it in some other
199 operation, and pushes it again. */
203 using namespace expr
;
204 operation_up v
= ::expr::make_operation
<T
> (pop ());
205 push (std::move (v
));
208 /* A helper that pops two operations, wraps them in some other
209 operation, and pushes the result. */
213 expr::operation_up rhs
= pop ();
214 expr::operation_up lhs
= pop ();
215 push (expr::make_operation
<T
> (std::move (lhs
), std::move (rhs
)));
218 /* If this is nonzero, this block is used as the lexical context for
221 const struct block
* const expression_context_block
;
223 /* If expression_context_block is non-zero, then this is the PC
224 within the block that we want to evaluate expressions at. When
225 debugging C or C++ code, we use this to find the exact line we're
226 at, and then look up the macro definitions active at that
228 const CORE_ADDR expression_context_pc
;
230 /* Nonzero means stop parsing on first comma (if not within parentheses). */
232 int comma_terminates
;
234 /* During parsing of a C expression, the pointer to the next character
235 is in this variable. */
239 /* After a token has been recognized, this variable points to it.
240 Currently used only for error reporting. */
241 const char *prev_lexptr
= nullptr;
243 /* Number of arguments seen so far in innermost function call. */
247 /* True if parsing an expression to attempt completion. */
248 int parse_completion
;
250 /* Completion state is updated here. */
251 expr_completion_state m_completion_state
;
253 /* The innermost block tracker. */
254 innermost_block_tracker
*block_tracker
;
256 /* True if no value is expected from the expression. */
261 /* Data structure for saving values of arglist_len for function calls whose
262 arguments contain other function calls. */
264 std::vector
<int> m_funcall_chain
;
266 /* Stack of operations. */
267 std::vector
<expr::operation_up
> m_operations
;
270 /* When parsing expressions we track the innermost block that was
273 class innermost_block_tracker
276 innermost_block_tracker (innermost_block_tracker_types types
277 = INNERMOST_BLOCK_FOR_SYMBOLS
)
279 m_innermost_block (NULL
)
282 /* Update the stored innermost block if the new block B is more inner
283 than the currently stored block, or if no block is stored yet. The
284 type T tells us whether the block B was for a symbol or for a
285 register. The stored innermost block is only updated if the type T is
286 a type we are interested in, the types we are interested in are held
287 in M_TYPES and set during RESET. */
288 void update (const struct block
*b
, innermost_block_tracker_types t
);
290 /* Overload of main UPDATE method which extracts the block from BS. */
291 void update (const struct block_symbol
&bs
)
293 update (bs
.block
, INNERMOST_BLOCK_FOR_SYMBOLS
);
296 /* Return the stored innermost block. Can be nullptr if no symbols or
297 registers were found during an expression parse, and so no innermost
298 block was defined. */
299 const struct block
*block () const
301 return m_innermost_block
;
305 /* The type of innermost block being looked for. */
306 innermost_block_tracker_types m_types
;
308 /* The currently stored innermost block found while parsing an
310 const struct block
*m_innermost_block
;
313 /* A string token, either a char-string or bit-string. Char-strings are
314 used, for example, for the names of symbols. */
318 /* Pointer to first byte of char-string or first bit of bit-string. */
320 /* Length of string in bytes for char-string or bits for bit-string. */
326 /* A language-specific type field. */
328 /* Pointer to first byte of char-string or first bit of bit-string. */
330 /* Length of string in bytes for char-string or bits for bit-string. */
337 struct typed_stoken
*tokens
;
342 struct stoken stoken
;
348 struct stoken stoken
;
349 struct block_symbol sym
;
350 int is_a_field_of_this
;
353 struct objc_class_str
355 struct stoken stoken
;
360 extern const char *find_template_name_end (const char *);
362 extern std::string
copy_name (struct stoken
);
364 extern bool parse_float (const char *p
, int len
,
365 const struct type
*type
, gdb_byte
*data
);
368 /* Function used to avoid direct calls to fprintf
369 in the code generated by the bison parser. */
371 extern void parser_fprintf (FILE *, const char *, ...) ATTRIBUTE_PRINTF (2, 3);
373 extern int exp_uses_objfile (struct expression
*exp
, struct objfile
*objfile
);
375 #endif /* PARSER_DEFS_H */