Move lexptr and prev_lexptr to parser_state
[deliverable/binutils-gdb.git] / gdb / parse.c
CommitLineData
c906108c 1/* Parse expressions for GDB.
c4a172b5 2
42a4f53d 3 Copyright (C) 1986-2019 Free Software Foundation, Inc.
c4a172b5 4
c906108c
SS
5 Modified from expread.y by the Department of Computer Science at the
6 State University of New York at Buffalo, 1991.
7
c5aa993b 8 This file is part of GDB.
c906108c 9
c5aa993b
JM
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
a9762ec7 12 the Free Software Foundation; either version 3 of the License, or
c5aa993b 13 (at your option) any later version.
c906108c 14
c5aa993b
JM
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.
c906108c 19
c5aa993b 20 You should have received a copy of the GNU General Public License
a9762ec7 21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
c906108c
SS
22
23/* Parse an expression from text in a string,
ae0c443d 24 and return the result as a struct expression pointer.
c906108c
SS
25 That structure contains arithmetic operations in reverse polish,
26 with constants represented by operations that are followed by special data.
27 See expression.h for the details of the format.
28 What is important here is that it can be built up sequentially
29 during the process of parsing; the lower levels of the tree always
30 come first in the result. */
c5aa993b 31
c906108c 32#include "defs.h"
12c89474 33#include <ctype.h>
e17c207e 34#include "arch-utils.h"
c906108c
SS
35#include "symtab.h"
36#include "gdbtypes.h"
37#include "frame.h"
38#include "expression.h"
39#include "value.h"
40#include "command.h"
41#include "language.h"
0b4e1325 42#include "f-lang.h"
c906108c
SS
43#include "parser-defs.h"
44#include "gdbcmd.h"
c5aa993b 45#include "symfile.h" /* for overlay functions */
f57d151a 46#include "inferior.h"
f69fdf9b 47#include "target-float.h"
fe898f56 48#include "block.h"
59f92a09 49#include "source.h"
9e35dae4 50#include "objfiles.h"
029a67e4 51#include "user-regs.h"
325fac50 52#include <algorithm>
e3ad2841 53#include "common/gdb_optional.h"
e2305d34 54
5f9769d1
PH
55/* Standard set of definitions for printing, dumping, prefixifying,
56 * and evaluating expressions. */
57
58const struct exp_descriptor exp_descriptor_standard =
59 {
60 print_subexp_standard,
61 operator_length_standard,
c0201579 62 operator_check_standard,
5f9769d1
PH
63 op_name_standard,
64 dump_subexp_body_standard,
65 evaluate_subexp_standard
66 };
c906108c
SS
67\f
68/* Global variables declared in parser-defs.h (and commented there). */
aee1fcdf 69innermost_block_tracker innermost_block;
c906108c 70int arglist_len;
1a7d0ce4 71static struct type_stack type_stack;
3a913e29 72
155da517
TT
73/* True if parsing an expression to attempt completion. */
74int parse_completion;
65d12d83
TT
75
76/* The index of the last struct expression directly before a '.' or
77 '->'. This is set when parsing and is only used when completing a
78 field name. It is -1 if no dereference operation was found. */
79static int expout_last_struct = -1;
2f68a895
TT
80
81/* If we are completing a tagged type name, this will be nonzero. */
82static enum type_code expout_tag_completion_type = TYPE_CODE_UNDEF;
83
84/* The token for tagged type name completion. */
3eac2b65 85static gdb::unique_xmalloc_ptr<char> expout_completion_name;
2f68a895 86
c906108c 87\f
ccce17b0 88static unsigned int expressiondebug = 0;
920d2a44
AC
89static void
90show_expressiondebug (struct ui_file *file, int from_tty,
91 struct cmd_list_element *c, const char *value)
92{
93 fprintf_filtered (file, _("Expression debugging is %s.\n"), value);
94}
c906108c 95
92981e24
TT
96
97/* Non-zero if an expression parser should set yydebug. */
98int parser_debug;
99
100static void
101show_parserdebug (struct ui_file *file, int from_tty,
102 struct cmd_list_element *c, const char *value)
103{
104 fprintf_filtered (file, _("Parser debugging is %s.\n"), value);
105}
106
107
65d12d83
TT
108static int prefixify_subexp (struct expression *, struct expression *, int,
109 int);
c906108c 110
4d01a485
PA
111static expression_up parse_exp_in_context (const char **, CORE_ADDR,
112 const struct block *, int,
7ad417dd
TT
113 int, int *,
114 innermost_block_tracker_types);
e85c3284 115
37eedb39 116static void increase_expout_size (struct expr_builder *ps, size_t lenelt);
e3980ce2
TT
117
118
aee1fcdf
AB
119/* Documented at it's declaration. */
120
121void
ae451627
AB
122innermost_block_tracker::update (const struct block *b,
123 innermost_block_tracker_types t)
aee1fcdf 124{
ae451627
AB
125 if ((m_types & t) != 0
126 && (m_innermost_block == NULL
127 || contained_in (b, m_innermost_block)))
aee1fcdf
AB
128 m_innermost_block = b;
129}
130
c906108c
SS
131/* Data structure for saving values of arglist_len for function calls whose
132 arguments contain other function calls. */
133
69c1e056 134static std::vector<int> *funcall_chain;
c906108c 135
c906108c
SS
136/* Begin counting arguments for a function call,
137 saving the data about any containing call. */
138
139void
fba45db2 140start_arglist (void)
c906108c 141{
69c1e056 142 funcall_chain->push_back (arglist_len);
c906108c 143 arglist_len = 0;
c906108c
SS
144}
145
146/* Return the number of arguments in a function call just terminated,
147 and restore the data for the containing function call. */
148
149int
fba45db2 150end_arglist (void)
c906108c 151{
f86f5ca3 152 int val = arglist_len;
69c1e056
TT
153 arglist_len = funcall_chain->back ();
154 funcall_chain->pop_back ();
c906108c
SS
155 return val;
156}
157
c906108c 158\f
c906108c 159
55aa24fb 160/* See definition in parser-defs.h. */
2dbca4d6 161
37eedb39 162expr_builder::expr_builder (const struct language_defn *lang,
e9d9f57e 163 struct gdbarch *gdbarch)
1201a264 164 : expout_size (10),
e9d9f57e
TT
165 expout (XNEWVAR (expression,
166 (sizeof (expression)
167 + EXP_ELEM_TO_BYTES (expout_size)))),
168 expout_ptr (0)
2dbca4d6 169{
e9d9f57e
TT
170 expout->language_defn = lang;
171 expout->gdbarch = gdbarch;
2dbca4d6
SDJ
172}
173
e9d9f57e 174expression_up
37eedb39 175expr_builder::release ()
2dbca4d6
SDJ
176{
177 /* Record the actual number of expression elements, and then
178 reallocate the expression memory so that we free up any
179 excess elements. */
180
e9d9f57e
TT
181 expout->nelts = expout_ptr;
182 expout.reset (XRESIZEVAR (expression, expout.release (),
183 (sizeof (expression)
184 + EXP_ELEM_TO_BYTES (expout_ptr))));
185
186 return std::move (expout);
2dbca4d6
SDJ
187}
188
410a0ff2
SDJ
189/* This page contains the functions for adding data to the struct expression
190 being constructed. */
191
c906108c
SS
192/* Add one element to the end of the expression. */
193
194/* To avoid a bug in the Sun 4 compiler, we pass things that can fit into
0df8b418 195 a register through here. */
c906108c 196
ae0c443d 197static void
37eedb39 198write_exp_elt (struct expr_builder *ps, const union exp_element *expelt)
c906108c 199{
410a0ff2 200 if (ps->expout_ptr >= ps->expout_size)
c906108c 201 {
410a0ff2 202 ps->expout_size *= 2;
e9d9f57e
TT
203 ps->expout.reset (XRESIZEVAR (expression, ps->expout.release (),
204 (sizeof (expression)
205 + EXP_ELEM_TO_BYTES (ps->expout_size))));
c906108c 206 }
410a0ff2 207 ps->expout->elts[ps->expout_ptr++] = *expelt;
c906108c
SS
208}
209
210void
37eedb39 211write_exp_elt_opcode (struct expr_builder *ps, enum exp_opcode expelt)
c906108c
SS
212{
213 union exp_element tmp;
214
ad3bbd48 215 memset (&tmp, 0, sizeof (union exp_element));
c906108c 216 tmp.opcode = expelt;
410a0ff2 217 write_exp_elt (ps, &tmp);
c906108c
SS
218}
219
220void
37eedb39 221write_exp_elt_sym (struct expr_builder *ps, struct symbol *expelt)
c906108c
SS
222{
223 union exp_element tmp;
224
ad3bbd48 225 memset (&tmp, 0, sizeof (union exp_element));
c906108c 226 tmp.symbol = expelt;
410a0ff2 227 write_exp_elt (ps, &tmp);
c906108c
SS
228}
229
74ea4be4 230void
37eedb39 231write_exp_elt_msym (struct expr_builder *ps, minimal_symbol *expelt)
74ea4be4
PA
232{
233 union exp_element tmp;
234
235 memset (&tmp, 0, sizeof (union exp_element));
236 tmp.msymbol = expelt;
237 write_exp_elt (ps, &tmp);
238}
239
c906108c 240void
37eedb39 241write_exp_elt_block (struct expr_builder *ps, const struct block *b)
c906108c
SS
242{
243 union exp_element tmp;
ad3bbd48 244
09153d55 245 memset (&tmp, 0, sizeof (union exp_element));
c906108c 246 tmp.block = b;
410a0ff2 247 write_exp_elt (ps, &tmp);
c906108c
SS
248}
249
9e35dae4 250void
37eedb39 251write_exp_elt_objfile (struct expr_builder *ps, struct objfile *objfile)
9e35dae4
DJ
252{
253 union exp_element tmp;
ad3bbd48 254
9e35dae4
DJ
255 memset (&tmp, 0, sizeof (union exp_element));
256 tmp.objfile = objfile;
410a0ff2 257 write_exp_elt (ps, &tmp);
9e35dae4
DJ
258}
259
c906108c 260void
37eedb39 261write_exp_elt_longcst (struct expr_builder *ps, LONGEST expelt)
c906108c
SS
262{
263 union exp_element tmp;
264
ad3bbd48 265 memset (&tmp, 0, sizeof (union exp_element));
c906108c 266 tmp.longconst = expelt;
410a0ff2 267 write_exp_elt (ps, &tmp);
c906108c
SS
268}
269
270void
37eedb39 271write_exp_elt_floatcst (struct expr_builder *ps, const gdb_byte expelt[16])
27bc4d80
TJB
272{
273 union exp_element tmp;
274 int index;
275
276 for (index = 0; index < 16; index++)
edd079d9 277 tmp.floatconst[index] = expelt[index];
27bc4d80 278
410a0ff2 279 write_exp_elt (ps, &tmp);
27bc4d80
TJB
280}
281
c906108c 282void
37eedb39 283write_exp_elt_type (struct expr_builder *ps, struct type *expelt)
c906108c
SS
284{
285 union exp_element tmp;
286
ad3bbd48 287 memset (&tmp, 0, sizeof (union exp_element));
c906108c 288 tmp.type = expelt;
410a0ff2 289 write_exp_elt (ps, &tmp);
c906108c
SS
290}
291
292void
37eedb39 293write_exp_elt_intern (struct expr_builder *ps, struct internalvar *expelt)
c906108c
SS
294{
295 union exp_element tmp;
296
ad3bbd48 297 memset (&tmp, 0, sizeof (union exp_element));
c906108c 298 tmp.internalvar = expelt;
410a0ff2 299 write_exp_elt (ps, &tmp);
c906108c
SS
300}
301
302/* Add a string constant to the end of the expression.
303
304 String constants are stored by first writing an expression element
305 that contains the length of the string, then stuffing the string
306 constant itself into however many expression elements are needed
307 to hold it, and then writing another expression element that contains
0df8b418 308 the length of the string. I.e. an expression element at each end of
c906108c
SS
309 the string records the string length, so you can skip over the
310 expression elements containing the actual string bytes from either
311 end of the string. Note that this also allows gdb to handle
312 strings with embedded null bytes, as is required for some languages.
313
314 Don't be fooled by the fact that the string is null byte terminated,
bc3b79fd 315 this is strictly for the convenience of debugging gdb itself.
c906108c
SS
316 Gdb does not depend up the string being null terminated, since the
317 actual length is recorded in expression elements at each end of the
318 string. The null byte is taken into consideration when computing how
319 many expression elements are required to hold the string constant, of
0df8b418 320 course. */
c906108c
SS
321
322
323void
37eedb39 324write_exp_string (struct expr_builder *ps, struct stoken str)
c906108c 325{
f86f5ca3 326 int len = str.length;
410a0ff2 327 size_t lenelt;
f86f5ca3 328 char *strdata;
c906108c
SS
329
330 /* Compute the number of expression elements required to hold the string
331 (including a null byte terminator), along with one expression element
332 at each end to record the actual string length (not including the
0df8b418 333 null byte terminator). */
c906108c
SS
334
335 lenelt = 2 + BYTES_TO_EXP_ELEM (len + 1);
336
410a0ff2 337 increase_expout_size (ps, lenelt);
c906108c
SS
338
339 /* Write the leading length expression element (which advances the current
340 expression element index), then write the string constant followed by a
341 terminating null byte, and then write the trailing length expression
0df8b418 342 element. */
c906108c 343
410a0ff2
SDJ
344 write_exp_elt_longcst (ps, (LONGEST) len);
345 strdata = (char *) &ps->expout->elts[ps->expout_ptr];
c906108c
SS
346 memcpy (strdata, str.ptr, len);
347 *(strdata + len) = '\0';
410a0ff2
SDJ
348 ps->expout_ptr += lenelt - 2;
349 write_exp_elt_longcst (ps, (LONGEST) len);
c906108c
SS
350}
351
6c7a06a3
TT
352/* Add a vector of string constants to the end of the expression.
353
354 This adds an OP_STRING operation, but encodes the contents
355 differently from write_exp_string. The language is expected to
356 handle evaluation of this expression itself.
357
358 After the usual OP_STRING header, TYPE is written into the
359 expression as a long constant. The interpretation of this field is
360 up to the language evaluator.
361
362 Next, each string in VEC is written. The length is written as a
363 long constant, followed by the contents of the string. */
364
365void
37eedb39 366write_exp_string_vector (struct expr_builder *ps, int type,
410a0ff2 367 struct stoken_vector *vec)
6c7a06a3 368{
410a0ff2
SDJ
369 int i, len;
370 size_t n_slots;
6c7a06a3
TT
371
372 /* Compute the size. We compute the size in number of slots to
373 avoid issues with string padding. */
374 n_slots = 0;
375 for (i = 0; i < vec->len; ++i)
376 {
377 /* One slot for the length of this element, plus the number of
378 slots needed for this string. */
379 n_slots += 1 + BYTES_TO_EXP_ELEM (vec->tokens[i].length);
380 }
381
382 /* One more slot for the type of the string. */
383 ++n_slots;
384
385 /* Now compute a phony string length. */
386 len = EXP_ELEM_TO_BYTES (n_slots) - 1;
387
388 n_slots += 4;
410a0ff2 389 increase_expout_size (ps, n_slots);
6c7a06a3 390
410a0ff2
SDJ
391 write_exp_elt_opcode (ps, OP_STRING);
392 write_exp_elt_longcst (ps, len);
393 write_exp_elt_longcst (ps, type);
6c7a06a3
TT
394
395 for (i = 0; i < vec->len; ++i)
396 {
410a0ff2
SDJ
397 write_exp_elt_longcst (ps, vec->tokens[i].length);
398 memcpy (&ps->expout->elts[ps->expout_ptr], vec->tokens[i].ptr,
6c7a06a3 399 vec->tokens[i].length);
410a0ff2 400 ps->expout_ptr += BYTES_TO_EXP_ELEM (vec->tokens[i].length);
6c7a06a3
TT
401 }
402
410a0ff2
SDJ
403 write_exp_elt_longcst (ps, len);
404 write_exp_elt_opcode (ps, OP_STRING);
6c7a06a3
TT
405}
406
c906108c
SS
407/* Add a bitstring constant to the end of the expression.
408
409 Bitstring constants are stored by first writing an expression element
410 that contains the length of the bitstring (in bits), then stuffing the
411 bitstring constant itself into however many expression elements are
412 needed to hold it, and then writing another expression element that
0df8b418 413 contains the length of the bitstring. I.e. an expression element at
c906108c
SS
414 each end of the bitstring records the bitstring length, so you can skip
415 over the expression elements containing the actual bitstring bytes from
0df8b418 416 either end of the bitstring. */
c906108c
SS
417
418void
37eedb39 419write_exp_bitstring (struct expr_builder *ps, struct stoken str)
c906108c 420{
f86f5ca3
PH
421 int bits = str.length; /* length in bits */
422 int len = (bits + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
410a0ff2 423 size_t lenelt;
f86f5ca3 424 char *strdata;
c906108c
SS
425
426 /* Compute the number of expression elements required to hold the bitstring,
427 along with one expression element at each end to record the actual
0df8b418 428 bitstring length in bits. */
c906108c
SS
429
430 lenelt = 2 + BYTES_TO_EXP_ELEM (len);
431
410a0ff2 432 increase_expout_size (ps, lenelt);
c906108c
SS
433
434 /* Write the leading length expression element (which advances the current
435 expression element index), then write the bitstring constant, and then
0df8b418 436 write the trailing length expression element. */
c906108c 437
410a0ff2
SDJ
438 write_exp_elt_longcst (ps, (LONGEST) bits);
439 strdata = (char *) &ps->expout->elts[ps->expout_ptr];
c906108c 440 memcpy (strdata, str.ptr, len);
410a0ff2
SDJ
441 ps->expout_ptr += lenelt - 2;
442 write_exp_elt_longcst (ps, (LONGEST) bits);
c906108c
SS
443}
444
74ea4be4
PA
445/* Return the type of MSYMBOL, a minimal symbol of OBJFILE. If
446 ADDRESS_P is not NULL, set it to the MSYMBOL's resolved
447 address. */
c906108c 448
74ea4be4
PA
449type *
450find_minsym_type_and_address (minimal_symbol *msymbol,
451 struct objfile *objfile,
452 CORE_ADDR *address_p)
c906108c 453{
74ea4be4 454 bound_minimal_symbol bound_msym = {msymbol, objfile};
efd66ac6 455 struct obj_section *section = MSYMBOL_OBJ_SECTION (objfile, msymbol);
712f90be 456 enum minimal_symbol_type type = MSYMBOL_TYPE (msymbol);
bccdca4a 457
fbd1b771
JK
458 bool is_tls = (section != NULL
459 && section->the_bfd_section->flags & SEC_THREAD_LOCAL);
460
bccdca4a
UW
461 /* The minimal symbol might point to a function descriptor;
462 resolve it to the actual code address instead. */
f50776aa
PA
463 CORE_ADDR addr;
464 if (is_tls)
bccdca4a 465 {
f50776aa
PA
466 /* Addresses of TLS symbols are really offsets into a
467 per-objfile/per-thread storage block. */
468 addr = MSYMBOL_VALUE_RAW_ADDRESS (bound_msym.minsym);
469 }
470 else if (msymbol_is_function (objfile, msymbol, &addr))
471 {
472 if (addr != BMSYMBOL_VALUE_ADDRESS (bound_msym))
0875794a 473 {
f50776aa
PA
474 /* This means we resolved a function descriptor, and we now
475 have an address for a code/text symbol instead of a data
476 symbol. */
477 if (MSYMBOL_TYPE (msymbol) == mst_data_gnu_ifunc)
478 type = mst_text_gnu_ifunc;
479 else
480 type = mst_text;
481 section = NULL;
0875794a 482 }
bccdca4a 483 }
f50776aa
PA
484 else
485 addr = BMSYMBOL_VALUE_ADDRESS (bound_msym);
bccdca4a
UW
486
487 if (overlay_debugging)
714835d5 488 addr = symbol_overlayed_address (addr, section);
c906108c 489
fbd1b771 490 if (is_tls)
9e35dae4 491 {
74ea4be4
PA
492 /* Skip translation if caller does not need the address. */
493 if (address_p != NULL)
494 *address_p = target_translate_tls_address (objfile, addr);
495 return objfile_type (objfile)->nodebug_tls_symbol;
9e35dae4
DJ
496 }
497
74ea4be4
PA
498 if (address_p != NULL)
499 *address_p = addr;
500
bccdca4a 501 switch (type)
c906108c
SS
502 {
503 case mst_text:
504 case mst_file_text:
505 case mst_solib_trampoline:
74ea4be4 506 return objfile_type (objfile)->nodebug_text_symbol;
c906108c 507
0875794a 508 case mst_text_gnu_ifunc:
74ea4be4 509 return objfile_type (objfile)->nodebug_text_gnu_ifunc_symbol;
0875794a 510
c906108c
SS
511 case mst_data:
512 case mst_file_data:
513 case mst_bss:
514 case mst_file_bss:
74ea4be4 515 return objfile_type (objfile)->nodebug_data_symbol;
c906108c 516
0875794a 517 case mst_slot_got_plt:
74ea4be4 518 return objfile_type (objfile)->nodebug_got_plt_symbol;
0875794a 519
c906108c 520 default:
74ea4be4 521 return objfile_type (objfile)->nodebug_unknown_symbol;
c906108c 522 }
74ea4be4
PA
523}
524
525/* Add the appropriate elements for a minimal symbol to the end of
526 the expression. */
527
528void
37eedb39 529write_exp_msymbol (struct expr_builder *ps,
74ea4be4
PA
530 struct bound_minimal_symbol bound_msym)
531{
532 write_exp_elt_opcode (ps, OP_VAR_MSYM_VALUE);
533 write_exp_elt_objfile (ps, bound_msym.objfile);
534 write_exp_elt_msym (ps, bound_msym.minsym);
535 write_exp_elt_opcode (ps, OP_VAR_MSYM_VALUE);
c906108c 536}
65d12d83
TT
537
538/* Mark the current index as the starting location of a structure
539 expression. This is used when completing on field names. */
540
541void
37eedb39 542mark_struct_expression (struct expr_builder *ps)
65d12d83 543{
2f68a895
TT
544 gdb_assert (parse_completion
545 && expout_tag_completion_type == TYPE_CODE_UNDEF);
410a0ff2 546 expout_last_struct = ps->expout_ptr;
65d12d83
TT
547}
548
2f68a895
TT
549/* Indicate that the current parser invocation is completing a tag.
550 TAG is the type code of the tag, and PTR and LENGTH represent the
551 start of the tag name. */
552
553void
554mark_completion_tag (enum type_code tag, const char *ptr, int length)
555{
556 gdb_assert (parse_completion
557 && expout_tag_completion_type == TYPE_CODE_UNDEF
558 && expout_completion_name == NULL
559 && expout_last_struct == -1);
560 gdb_assert (tag == TYPE_CODE_UNION
561 || tag == TYPE_CODE_STRUCT
2f68a895
TT
562 || tag == TYPE_CODE_ENUM);
563 expout_tag_completion_type = tag;
3eac2b65 564 expout_completion_name.reset (xstrndup (ptr, length));
2f68a895
TT
565}
566
c906108c
SS
567\f
568/* Recognize tokens that start with '$'. These include:
569
c5aa993b
JM
570 $regname A native register name or a "standard
571 register name".
c906108c 572
c5aa993b
JM
573 $variable A convenience variable with a name chosen
574 by the user.
c906108c 575
c5aa993b
JM
576 $digits Value history with index <digits>, starting
577 from the first value which has index 1.
c906108c 578
c5aa993b 579 $$digits Value history with index <digits> relative
0df8b418 580 to the last value. I.e. $$0 is the last
c5aa993b
JM
581 value, $$1 is the one previous to that, $$2
582 is the one previous to $$1, etc.
c906108c 583
c5aa993b 584 $ | $0 | $$0 The last value in the value history.
c906108c 585
c5aa993b 586 $$ An abbreviation for the second to the last
0df8b418 587 value in the value history, I.e. $$1 */
c906108c
SS
588
589void
1e58a4a4 590write_dollar_variable (struct parser_state *ps, struct stoken str)
c906108c 591{
d12307c1 592 struct block_symbol sym;
7c7b6655 593 struct bound_minimal_symbol msym;
c4a3d09a 594 struct internalvar *isym = NULL;
d7318818 595
c906108c 596 /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
0df8b418 597 and $$digits (equivalent to $<-digits> if you could type that). */
c906108c 598
c906108c
SS
599 int negate = 0;
600 int i = 1;
601 /* Double dollar means negate the number and add -1 as well.
602 Thus $$ alone means -1. */
603 if (str.length >= 2 && str.ptr[1] == '$')
604 {
605 negate = 1;
606 i = 2;
607 }
608 if (i == str.length)
609 {
0df8b418 610 /* Just dollars (one or two). */
c5aa993b 611 i = -negate;
c906108c
SS
612 goto handle_last;
613 }
614 /* Is the rest of the token digits? */
615 for (; i < str.length; i++)
616 if (!(str.ptr[i] >= '0' && str.ptr[i] <= '9'))
617 break;
618 if (i == str.length)
619 {
620 i = atoi (str.ptr + 1 + negate);
621 if (negate)
c5aa993b 622 i = -i;
c906108c
SS
623 goto handle_last;
624 }
c5aa993b 625
c906108c
SS
626 /* Handle tokens that refer to machine registers:
627 $ followed by a register name. */
fa9f5be6 628 i = user_reg_map_name_to_regnum (ps->gdbarch (),
029a67e4 629 str.ptr + 1, str.length - 1);
c5aa993b 630 if (i >= 0)
c906108c
SS
631 goto handle_register;
632
c4a3d09a
MF
633 /* Any names starting with $ are probably debugger internal variables. */
634
635 isym = lookup_only_internalvar (copy_name (str) + 1);
636 if (isym)
637 {
410a0ff2
SDJ
638 write_exp_elt_opcode (ps, OP_INTERNALVAR);
639 write_exp_elt_intern (ps, isym);
640 write_exp_elt_opcode (ps, OP_INTERNALVAR);
c4a3d09a
MF
641 return;
642 }
643
d7318818 644 /* On some systems, such as HP-UX and hppa-linux, certain system routines
0df8b418 645 have names beginning with $ or $$. Check for those, first. */
d7318818 646
582942f4 647 sym = lookup_symbol (copy_name (str), NULL, VAR_DOMAIN, NULL);
d12307c1 648 if (sym.symbol)
d7318818 649 {
410a0ff2 650 write_exp_elt_opcode (ps, OP_VAR_VALUE);
d12307c1
PMR
651 write_exp_elt_block (ps, sym.block);
652 write_exp_elt_sym (ps, sym.symbol);
410a0ff2 653 write_exp_elt_opcode (ps, OP_VAR_VALUE);
d7318818
RC
654 return;
655 }
7c7b6655
TT
656 msym = lookup_bound_minimal_symbol (copy_name (str));
657 if (msym.minsym)
c906108c 658 {
410a0ff2 659 write_exp_msymbol (ps, msym);
d7318818 660 return;
c906108c 661 }
c5aa993b 662
c4a3d09a 663 /* Any other names are assumed to be debugger internal variables. */
c906108c 664
410a0ff2
SDJ
665 write_exp_elt_opcode (ps, OP_INTERNALVAR);
666 write_exp_elt_intern (ps, create_internalvar (copy_name (str) + 1));
667 write_exp_elt_opcode (ps, OP_INTERNALVAR);
c906108c 668 return;
c5aa993b 669handle_last:
410a0ff2
SDJ
670 write_exp_elt_opcode (ps, OP_LAST);
671 write_exp_elt_longcst (ps, (LONGEST) i);
672 write_exp_elt_opcode (ps, OP_LAST);
c906108c 673 return;
c5aa993b 674handle_register:
410a0ff2 675 write_exp_elt_opcode (ps, OP_REGISTER);
67f3407f
DJ
676 str.length--;
677 str.ptr++;
410a0ff2
SDJ
678 write_exp_string (ps, str);
679 write_exp_elt_opcode (ps, OP_REGISTER);
1e58a4a4 680 innermost_block.update (ps->expression_context_block,
ae451627 681 INNERMOST_BLOCK_FOR_REGISTERS);
c906108c
SS
682 return;
683}
684
685
d7561cbb
KS
686const char *
687find_template_name_end (const char *p)
c906108c
SS
688{
689 int depth = 1;
690 int just_seen_right = 0;
691 int just_seen_colon = 0;
692 int just_seen_space = 0;
c5aa993b 693
c906108c
SS
694 if (!p || (*p != '<'))
695 return 0;
696
697 while (*++p)
698 {
699 switch (*p)
c5aa993b
JM
700 {
701 case '\'':
702 case '\"':
703 case '{':
704 case '}':
0df8b418 705 /* In future, may want to allow these?? */
c5aa993b
JM
706 return 0;
707 case '<':
708 depth++; /* start nested template */
709 if (just_seen_colon || just_seen_right || just_seen_space)
710 return 0; /* but not after : or :: or > or space */
711 break;
712 case '>':
713 if (just_seen_colon || just_seen_right)
714 return 0; /* end a (nested?) template */
715 just_seen_right = 1; /* but not after : or :: */
716 if (--depth == 0) /* also disallow >>, insist on > > */
717 return ++p; /* if outermost ended, return */
718 break;
719 case ':':
720 if (just_seen_space || (just_seen_colon > 1))
721 return 0; /* nested class spec coming up */
722 just_seen_colon++; /* we allow :: but not :::: */
723 break;
724 case ' ':
725 break;
726 default:
727 if (!((*p >= 'a' && *p <= 'z') || /* allow token chars */
728 (*p >= 'A' && *p <= 'Z') ||
729 (*p >= '0' && *p <= '9') ||
730 (*p == '_') || (*p == ',') || /* commas for template args */
731 (*p == '&') || (*p == '*') || /* pointer and ref types */
732 (*p == '(') || (*p == ')') || /* function types */
733 (*p == '[') || (*p == ']'))) /* array types */
734 return 0;
735 }
c906108c 736 if (*p != ' ')
c5aa993b 737 just_seen_space = 0;
c906108c 738 if (*p != ':')
c5aa993b 739 just_seen_colon = 0;
c906108c 740 if (*p != '>')
c5aa993b 741 just_seen_right = 0;
c906108c
SS
742 }
743 return 0;
744}
c5aa993b 745\f
c906108c 746
1a4eeb98 747/* Return a null-terminated temporary copy of the name of a string token.
c906108c 748
1a4eeb98
DE
749 Tokens that refer to names do so with explicit pointer and length,
750 so they can share the storage that lexptr is parsing.
751 When it is necessary to pass a name to a function that expects
752 a null-terminated string, the substring is copied out
753 into a separate block of storage.
754
755 N.B. A single buffer is reused on each call. */
c906108c
SS
756
757char *
fba45db2 758copy_name (struct stoken token)
c906108c 759{
1a4eeb98
DE
760 /* A temporary buffer for identifiers, so we can null-terminate them.
761 We allocate this with xrealloc. parse_exp_1 used to allocate with
762 alloca, using the size of the whole expression as a conservative
763 estimate of the space needed. However, macro expansion can
764 introduce names longer than the original expression; there's no
765 practical way to know beforehand how large that might be. */
766 static char *namecopy;
767 static size_t namecopy_size;
768
3a913e29
JB
769 /* Make sure there's enough space for the token. */
770 if (namecopy_size < token.length + 1)
771 {
772 namecopy_size = token.length + 1;
224c3ddb 773 namecopy = (char *) xrealloc (namecopy, token.length + 1);
3a913e29
JB
774 }
775
c906108c
SS
776 memcpy (namecopy, token.ptr, token.length);
777 namecopy[token.length] = 0;
3a913e29 778
c906108c
SS
779 return namecopy;
780}
781\f
55aa24fb
SDJ
782
783/* See comments on parser-defs.h. */
784
785int
f86f5ca3 786prefixify_expression (struct expression *expr)
c906108c 787{
5e70ee09 788 gdb_assert (expr->nelts > 0);
df2a60d0 789 int len = sizeof (struct expression) + EXP_ELEM_TO_BYTES (expr->nelts);
f86f5ca3
PH
790 struct expression *temp;
791 int inpos = expr->nelts, outpos = 0;
c906108c
SS
792
793 temp = (struct expression *) alloca (len);
794
795 /* Copy the original expression into temp. */
796 memcpy (temp, expr, len);
797
65d12d83 798 return prefixify_subexp (temp, expr, inpos, outpos);
c906108c
SS
799}
800
24daaebc
PH
801/* Return the number of exp_elements in the postfix subexpression
802 of EXPR whose operator is at index ENDPOS - 1 in EXPR. */
c906108c 803
cf81cf60 804static int
f86f5ca3 805length_of_subexp (struct expression *expr, int endpos)
24daaebc 806{
6b4398f7 807 int oplen, args;
24daaebc
PH
808
809 operator_length (expr, endpos, &oplen, &args);
810
811 while (args > 0)
812 {
813 oplen += length_of_subexp (expr, endpos - oplen);
814 args--;
815 }
816
817 return oplen;
818}
819
820/* Sets *OPLENP to the length of the operator whose (last) index is
821 ENDPOS - 1 in EXPR, and sets *ARGSP to the number of arguments that
822 operator takes. */
823
824void
554794dc
SDJ
825operator_length (const struct expression *expr, int endpos, int *oplenp,
826 int *argsp)
5f9769d1
PH
827{
828 expr->language_defn->la_exp_desc->operator_length (expr, endpos,
829 oplenp, argsp);
830}
831
832/* Default value for operator_length in exp_descriptor vectors. */
833
834void
554794dc 835operator_length_standard (const struct expression *expr, int endpos,
5f9769d1 836 int *oplenp, int *argsp)
c906108c 837{
f86f5ca3
PH
838 int oplen = 1;
839 int args = 0;
01739a3b 840 enum range_type range_type;
f86f5ca3 841 int i;
c906108c
SS
842
843 if (endpos < 1)
8a3fe4f8 844 error (_("?error in operator_length_standard"));
c906108c
SS
845
846 i = (int) expr->elts[endpos - 1].opcode;
847
848 switch (i)
849 {
850 /* C++ */
851 case OP_SCOPE:
852 oplen = longest_to_int (expr->elts[endpos - 2].longconst);
853 oplen = 5 + BYTES_TO_EXP_ELEM (oplen + 1);
854 break;
855
856 case OP_LONG:
edd079d9 857 case OP_FLOAT:
c906108c 858 case OP_VAR_VALUE:
74ea4be4 859 case OP_VAR_MSYM_VALUE:
c906108c
SS
860 oplen = 4;
861 break;
862
858be34c
PA
863 case OP_FUNC_STATIC_VAR:
864 oplen = longest_to_int (expr->elts[endpos - 2].longconst);
865 oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
866 args = 1;
867 break;
868
c906108c
SS
869 case OP_TYPE:
870 case OP_BOOL:
871 case OP_LAST:
c906108c 872 case OP_INTERNALVAR:
36b11add 873 case OP_VAR_ENTRY_VALUE:
c906108c
SS
874 oplen = 3;
875 break;
876
877 case OP_COMPLEX:
c806c55a 878 oplen = 3;
c906108c 879 args = 2;
c5aa993b 880 break;
c906108c
SS
881
882 case OP_FUNCALL:
883 case OP_F77_UNDETERMINED_ARGLIST:
884 oplen = 3;
885 args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
886 break;
887
072bba3b 888 case TYPE_INSTANCE:
3693fdb3 889 oplen = 5 + longest_to_int (expr->elts[endpos - 2].longconst);
072bba3b
KS
890 args = 1;
891 break;
892
0df8b418 893 case OP_OBJC_MSGCALL: /* Objective C message (method) call. */
53c551b7
AF
894 oplen = 4;
895 args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
896 break;
897
c906108c
SS
898 case UNOP_MAX:
899 case UNOP_MIN:
900 oplen = 3;
901 break;
902
9eaf6705 903 case UNOP_CAST_TYPE:
4e8f195d
TT
904 case UNOP_DYNAMIC_CAST:
905 case UNOP_REINTERPRET_CAST:
9eaf6705
TT
906 case UNOP_MEMVAL_TYPE:
907 oplen = 1;
908 args = 2;
909 break;
910
911 case BINOP_VAL:
912 case UNOP_CAST:
c5aa993b 913 case UNOP_MEMVAL:
c906108c
SS
914 oplen = 3;
915 args = 1;
916 break;
917
918 case UNOP_ABS:
919 case UNOP_CAP:
920 case UNOP_CHR:
921 case UNOP_FLOAT:
922 case UNOP_HIGH:
4d00f5d8 923 case UNOP_KIND:
c906108c
SS
924 case UNOP_ODD:
925 case UNOP_ORD:
926 case UNOP_TRUNC:
608b4967
TT
927 case OP_TYPEOF:
928 case OP_DECLTYPE:
6e72ca20 929 case OP_TYPEID:
c906108c
SS
930 oplen = 1;
931 args = 1;
932 break;
933
7322dca9
SW
934 case OP_ADL_FUNC:
935 oplen = longest_to_int (expr->elts[endpos - 2].longconst);
936 oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
937 oplen++;
938 oplen++;
939 break;
940
c906108c
SS
941 case STRUCTOP_STRUCT:
942 case STRUCTOP_PTR:
943 args = 1;
944 /* fall through */
67f3407f 945 case OP_REGISTER:
c906108c
SS
946 case OP_M2_STRING:
947 case OP_STRING:
3e43a32a 948 case OP_OBJC_NSSTRING: /* Objective C Foundation Class
0df8b418
MS
949 NSString constant. */
950 case OP_OBJC_SELECTOR: /* Objective C "@selector" pseudo-op. */
c906108c 951 case OP_NAME:
c906108c
SS
952 oplen = longest_to_int (expr->elts[endpos - 2].longconst);
953 oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
954 break;
955
c906108c
SS
956 case OP_ARRAY:
957 oplen = 4;
958 args = longest_to_int (expr->elts[endpos - 2].longconst);
959 args -= longest_to_int (expr->elts[endpos - 3].longconst);
960 args += 1;
961 break;
962
963 case TERNOP_COND:
964 case TERNOP_SLICE:
c906108c
SS
965 args = 3;
966 break;
967
968 /* Modula-2 */
c5aa993b 969 case MULTI_SUBSCRIPT:
c906108c 970 oplen = 3;
c5aa993b 971 args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
c906108c
SS
972 break;
973
974 case BINOP_ASSIGN_MODIFY:
975 oplen = 3;
976 args = 2;
977 break;
978
979 /* C++ */
980 case OP_THIS:
981 oplen = 2;
982 break;
983
01739a3b 984 case OP_RANGE:
0b4e1325 985 oplen = 3;
01739a3b 986 range_type = (enum range_type)
aead7601 987 longest_to_int (expr->elts[endpos - 2].longconst);
0b4e1325 988
0b4e1325
WZ
989 switch (range_type)
990 {
991 case LOW_BOUND_DEFAULT:
6873858b 992 case LOW_BOUND_DEFAULT_EXCLUSIVE:
0b4e1325
WZ
993 case HIGH_BOUND_DEFAULT:
994 args = 1;
995 break;
996 case BOTH_BOUND_DEFAULT:
997 args = 0;
998 break;
999 case NONE_BOUND_DEFAULT:
6873858b 1000 case NONE_BOUND_DEFAULT_EXCLUSIVE:
0b4e1325
WZ
1001 args = 2;
1002 break;
1003 }
1004
1005 break;
1006
c906108c
SS
1007 default:
1008 args = 1 + (i < (int) BINOP_END);
1009 }
1010
24daaebc
PH
1011 *oplenp = oplen;
1012 *argsp = args;
c906108c
SS
1013}
1014
1015/* Copy the subexpression ending just before index INEND in INEXPR
1016 into OUTEXPR, starting at index OUTBEG.
65d12d83
TT
1017 In the process, convert it from suffix to prefix form.
1018 If EXPOUT_LAST_STRUCT is -1, then this function always returns -1.
1019 Otherwise, it returns the index of the subexpression which is the
1020 left-hand-side of the expression at EXPOUT_LAST_STRUCT. */
c906108c 1021
65d12d83 1022static int
f86f5ca3
PH
1023prefixify_subexp (struct expression *inexpr,
1024 struct expression *outexpr, int inend, int outbeg)
c906108c 1025{
24daaebc
PH
1026 int oplen;
1027 int args;
f86f5ca3 1028 int i;
c906108c 1029 int *arglens;
65d12d83 1030 int result = -1;
c906108c 1031
24daaebc 1032 operator_length (inexpr, inend, &oplen, &args);
c906108c
SS
1033
1034 /* Copy the final operator itself, from the end of the input
1035 to the beginning of the output. */
1036 inend -= oplen;
1037 memcpy (&outexpr->elts[outbeg], &inexpr->elts[inend],
1038 EXP_ELEM_TO_BYTES (oplen));
1039 outbeg += oplen;
1040
65d12d83
TT
1041 if (expout_last_struct == inend)
1042 result = outbeg - oplen;
1043
c906108c
SS
1044 /* Find the lengths of the arg subexpressions. */
1045 arglens = (int *) alloca (args * sizeof (int));
1046 for (i = args - 1; i >= 0; i--)
1047 {
1048 oplen = length_of_subexp (inexpr, inend);
1049 arglens[i] = oplen;
1050 inend -= oplen;
1051 }
1052
1053 /* Now copy each subexpression, preserving the order of
1054 the subexpressions, but prefixifying each one.
1055 In this loop, inend starts at the beginning of
1056 the expression this level is working on
1057 and marches forward over the arguments.
1058 outbeg does similarly in the output. */
1059 for (i = 0; i < args; i++)
1060 {
65d12d83 1061 int r;
ad3bbd48 1062
c906108c
SS
1063 oplen = arglens[i];
1064 inend += oplen;
65d12d83
TT
1065 r = prefixify_subexp (inexpr, outexpr, inend, outbeg);
1066 if (r != -1)
1067 {
1068 /* Return immediately. We probably have only parsed a
1069 partial expression, so we don't want to try to reverse
1070 the other operands. */
1071 return r;
1072 }
c906108c
SS
1073 outbeg += oplen;
1074 }
65d12d83
TT
1075
1076 return result;
c906108c
SS
1077}
1078\f
c906108c 1079/* Read an expression from the string *STRINGPTR points to,
ae0c443d 1080 parse it, and return a pointer to a struct expression that we malloc.
c906108c
SS
1081 Use block BLOCK as the lexical context for variable names;
1082 if BLOCK is zero, use the block of the selected stack frame.
1083 Meanwhile, advance *STRINGPTR to point after the expression,
1084 at the first nonwhite character that is not part of the expression
1085 (possibly a null character).
1086
1087 If COMMA is nonzero, stop if a comma is reached. */
1088
4d01a485 1089expression_up
bbc13ae3 1090parse_exp_1 (const char **stringptr, CORE_ADDR pc, const struct block *block,
7ad417dd 1091 int comma, innermost_block_tracker_types tracker_types)
6f937416 1092{
7ad417dd
TT
1093 return parse_exp_in_context (stringptr, pc, block, comma, 0, NULL,
1094 tracker_types);
e85c3284
PH
1095}
1096
1097/* As for parse_exp_1, except that if VOID_CONTEXT_P, then
65d12d83
TT
1098 no value is expected from the expression.
1099 OUT_SUBEXP is set when attempting to complete a field name; in this
1100 case it is set to the index of the subexpression on the
1101 left-hand-side of the struct op. If not doing such completion, it
1102 is left untouched. */
e85c3284 1103
4d01a485 1104static expression_up
7ad417dd
TT
1105parse_exp_in_context (const char **stringptr, CORE_ADDR pc,
1106 const struct block *block,
1107 int comma, int void_context_p, int *out_subexp,
1108 innermost_block_tracker_types tracker_types)
c906108c 1109{
0cce5bd9 1110 const struct language_defn *lang = NULL;
65d12d83 1111 int subexp;
c906108c 1112
858d8004 1113 type_stack.elements.clear ();
65d12d83 1114 expout_last_struct = -1;
2f68a895 1115 expout_tag_completion_type = TYPE_CODE_UNDEF;
3eac2b65 1116 expout_completion_name.reset ();
7ad417dd 1117 innermost_block.reset (tracker_types);
c906108c 1118
5776fca3 1119 if (*stringptr == 0 || **stringptr == 0)
e2e0b3e5 1120 error_no_arg (_("expression to compute"));
c906108c 1121
69c1e056
TT
1122 std::vector<int> funcalls;
1123 scoped_restore save_funcall_chain = make_scoped_restore (&funcall_chain,
1124 &funcalls);
c906108c 1125
1e58a4a4
TT
1126 const struct block *expression_context_block = block;
1127 CORE_ADDR expression_context_pc = 0;
59f92a09 1128
d705c43c
PA
1129 /* If no context specified, try using the current frame, if any. */
1130 if (!expression_context_block)
1131 expression_context_block = get_selected_block (&expression_context_pc);
1bb9788d 1132 else if (pc == 0)
2b1ffcfd 1133 expression_context_pc = BLOCK_ENTRY_PC (expression_context_block);
1bb9788d
TT
1134 else
1135 expression_context_pc = pc;
59f92a09 1136
d705c43c 1137 /* Fall back to using the current source static context, if any. */
59f92a09 1138
d705c43c 1139 if (!expression_context_block)
59f92a09
FF
1140 {
1141 struct symtab_and_line cursal = get_current_source_symtab_and_line ();
1142 if (cursal.symtab)
d705c43c 1143 expression_context_block
439247b6
DE
1144 = BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (cursal.symtab),
1145 STATIC_BLOCK);
d705c43c 1146 if (expression_context_block)
2b1ffcfd 1147 expression_context_pc = BLOCK_ENTRY_PC (expression_context_block);
84f0252a 1148 }
c906108c 1149
0cce5bd9
JB
1150 if (language_mode == language_mode_auto && block != NULL)
1151 {
1152 /* Find the language associated to the given context block.
1153 Default to the current language if it can not be determined.
1154
1155 Note that using the language corresponding to the current frame
1156 can sometimes give unexpected results. For instance, this
1157 routine is often called several times during the inferior
1158 startup phase to re-parse breakpoint expressions after
1159 a new shared library has been loaded. The language associated
1160 to the current frame at this moment is not relevant for
0df8b418 1161 the breakpoint. Using it would therefore be silly, so it seems
0cce5bd9 1162 better to rely on the current language rather than relying on
0df8b418 1163 the current frame language to parse the expression. That's why
0cce5bd9
JB
1164 we do the following language detection only if the context block
1165 has been specifically provided. */
1166 struct symbol *func = block_linkage_function (block);
1167
1168 if (func != NULL)
1169 lang = language_def (SYMBOL_LANGUAGE (func));
1170 if (lang == NULL || lang->la_language == language_unknown)
1171 lang = current_language;
1172 }
1173 else
1174 lang = current_language;
1175
5b12a61c
JK
1176 /* get_current_arch may reset CURRENT_LANGUAGE via select_frame.
1177 While we need CURRENT_LANGUAGE to be set to LANG (for lookup_symbol
1178 and others called from *.y) ensure CURRENT_LANGUAGE gets restored
1179 to the value matching SELECTED_FRAME as set by get_current_arch. */
410a0ff2 1180
1e58a4a4 1181 parser_state ps (lang, get_current_arch (), expression_context_block,
5776fca3 1182 expression_context_pc, comma, *stringptr);
e3ad2841
TT
1183
1184 scoped_restore_current_language lang_saver;
5b12a61c 1185 set_language (lang->la_language);
c906108c 1186
492d29ea 1187 TRY
65d12d83 1188 {
69d340c6 1189 lang->la_parser (&ps);
65d12d83 1190 }
492d29ea 1191 CATCH (except, RETURN_MASK_ALL)
65d12d83 1192 {
5e70ee09
TT
1193 /* If parsing for completion, allow this to succeed; but if no
1194 expression elements have been written, then there's nothing
1195 to do, so fail. */
1196 if (! parse_completion || ps.expout_ptr == 0)
e9d9f57e 1197 throw_exception (except);
65d12d83 1198 }
492d29ea 1199 END_CATCH
c906108c 1200
e9d9f57e
TT
1201 /* We have to operate on an "expression *", due to la_post_parser,
1202 which explains this funny-looking double release. */
1203 expression_up result = ps.release ();
c906108c
SS
1204
1205 /* Convert expression from postfix form as generated by yacc
0df8b418 1206 parser, to a prefix form. */
c906108c 1207
c906108c 1208 if (expressiondebug)
e9d9f57e 1209 dump_raw_expression (result.get (), gdb_stdlog,
24daaebc 1210 "before conversion to prefix form");
c906108c 1211
e9d9f57e 1212 subexp = prefixify_expression (result.get ());
65d12d83
TT
1213 if (out_subexp)
1214 *out_subexp = subexp;
c906108c 1215
e9d9f57e 1216 lang->la_post_parser (&result, void_context_p);
e85c3284 1217
c906108c 1218 if (expressiondebug)
e9d9f57e 1219 dump_prefix_expression (result.get (), gdb_stdlog);
c906108c 1220
5776fca3 1221 *stringptr = ps.lexptr;
e9d9f57e 1222 return result;
c906108c
SS
1223}
1224
1225/* Parse STRING as an expression, and complain if this fails
1226 to use up all of the contents of STRING. */
1227
4d01a485 1228expression_up
bbc13ae3 1229parse_expression (const char *string)
c906108c 1230{
4d01a485 1231 expression_up exp = parse_exp_1 (&string, 0, 0, 0);
c906108c 1232 if (*string)
8a3fe4f8 1233 error (_("Junk after end of expression."));
c906108c
SS
1234 return exp;
1235}
e85c3284 1236
429e1e81
JB
1237/* Same as parse_expression, but using the given language (LANG)
1238 to parse the expression. */
1239
4d01a485 1240expression_up
429e1e81
JB
1241parse_expression_with_language (const char *string, enum language lang)
1242{
e3ad2841 1243 gdb::optional<scoped_restore_current_language> lang_saver;
429e1e81
JB
1244 if (current_language->la_language != lang)
1245 {
e3ad2841 1246 lang_saver.emplace ();
429e1e81
JB
1247 set_language (lang);
1248 }
1249
e3ad2841 1250 return parse_expression (string);
429e1e81
JB
1251}
1252
65d12d83
TT
1253/* Parse STRING as an expression. If parsing ends in the middle of a
1254 field reference, return the type of the left-hand-side of the
1255 reference; furthermore, if the parsing ends in the field name,
c92817ce
TT
1256 return the field name in *NAME. If the parsing ends in the middle
1257 of a field reference, but the reference is somehow invalid, throw
3eac2b65 1258 an exception. In all other cases, return NULL. */
65d12d83
TT
1259
1260struct type *
3eac2b65
TT
1261parse_expression_for_completion (const char *string,
1262 gdb::unique_xmalloc_ptr<char> *name,
2f68a895 1263 enum type_code *code)
65d12d83 1264{
4d01a485 1265 expression_up exp;
65d12d83
TT
1266 struct value *val;
1267 int subexp;
65d12d83 1268
492d29ea 1269 TRY
65d12d83 1270 {
155da517 1271 parse_completion = 1;
7ad417dd
TT
1272 exp = parse_exp_in_context (&string, 0, 0, 0, 0, &subexp,
1273 INNERMOST_BLOCK_FOR_SYMBOLS);
65d12d83 1274 }
492d29ea 1275 CATCH (except, RETURN_MASK_ERROR)
7556d4a4
PA
1276 {
1277 /* Nothing, EXP remains NULL. */
1278 }
492d29ea 1279 END_CATCH
7556d4a4 1280
155da517 1281 parse_completion = 0;
7556d4a4 1282 if (exp == NULL)
65d12d83 1283 return NULL;
2f68a895
TT
1284
1285 if (expout_tag_completion_type != TYPE_CODE_UNDEF)
1286 {
1287 *code = expout_tag_completion_type;
3eac2b65 1288 *name = std::move (expout_completion_name);
2f68a895
TT
1289 return NULL;
1290 }
1291
65d12d83 1292 if (expout_last_struct == -1)
4d01a485 1293 return NULL;
65d12d83 1294
3eac2b65
TT
1295 const char *fieldname = extract_field_op (exp.get (), &subexp);
1296 if (fieldname == NULL)
1297 {
1298 name->reset ();
1299 return NULL;
1300 }
a0b7aece 1301
3eac2b65 1302 name->reset (xstrdup (fieldname));
c92817ce
TT
1303 /* This might throw an exception. If so, we want to let it
1304 propagate. */
4d01a485 1305 val = evaluate_subexpression_type (exp.get (), subexp);
65d12d83
TT
1306
1307 return value_type (val);
1308}
1309
0df8b418 1310/* A post-parser that does nothing. */
e85c3284 1311
e85c3284 1312void
e9d9f57e 1313null_post_parser (expression_up *exp, int void_context_p)
e85c3284
PH
1314{
1315}
d30f5e1f
DE
1316
1317/* Parse floating point value P of length LEN.
edd079d9
UW
1318 Return false if invalid, true if valid.
1319 The successfully parsed number is stored in DATA in
1320 target format for floating-point type TYPE.
d30f5e1f
DE
1321
1322 NOTE: This accepts the floating point syntax that sscanf accepts. */
1323
edd079d9
UW
1324bool
1325parse_float (const char *p, int len,
1326 const struct type *type, gdb_byte *data)
d30f5e1f 1327{
f69fdf9b 1328 return target_float_from_string (data, type, std::string (p, len));
d30f5e1f 1329}
c906108c
SS
1330\f
1331/* Stuff for maintaining a stack of types. Currently just used by C, but
1332 probably useful for any language which declares its types "backwards". */
1333
95c391b6
TT
1334/* A helper function for insert_type and insert_type_address_space.
1335 This does work of expanding the type stack and inserting the new
1336 element, ELEMENT, into the stack at location SLOT. */
1337
1338static void
1339insert_into_type_stack (int slot, union type_stack_elt element)
1340{
858d8004
SM
1341 gdb_assert (slot <= type_stack.elements.size ());
1342 type_stack.elements.insert (type_stack.elements.begin () + slot, element);
95c391b6
TT
1343}
1344
1345/* Insert a new type, TP, at the bottom of the type stack. If TP is
53cc15f5
AV
1346 tp_pointer, tp_reference or tp_rvalue_reference, it is inserted at the
1347 bottom. If TP is a qualifier, it is inserted at slot 1 (just above a
1348 previous tp_pointer) if there is anything on the stack, or simply pushed
1349 if the stack is empty. Other values for TP are invalid. */
95c391b6
TT
1350
1351void
1352insert_type (enum type_pieces tp)
1353{
1354 union type_stack_elt element;
1355 int slot;
1356
1357 gdb_assert (tp == tp_pointer || tp == tp_reference
53cc15f5
AV
1358 || tp == tp_rvalue_reference || tp == tp_const
1359 || tp == tp_volatile);
95c391b6
TT
1360
1361 /* If there is anything on the stack (we know it will be a
1362 tp_pointer), insert the qualifier above it. Otherwise, simply
1363 push this on the top of the stack. */
858d8004 1364 if (!type_stack.elements.empty () && (tp == tp_const || tp == tp_volatile))
95c391b6
TT
1365 slot = 1;
1366 else
1367 slot = 0;
1368
1369 element.piece = tp;
1370 insert_into_type_stack (slot, element);
1371}
1372
47663de5
MS
1373void
1374push_type (enum type_pieces tp)
1375{
858d8004
SM
1376 type_stack_elt elt;
1377 elt.piece = tp;
1378 type_stack.elements.push_back (elt);
c906108c
SS
1379}
1380
1381void
fba45db2 1382push_type_int (int n)
c906108c 1383{
858d8004
SM
1384 type_stack_elt elt;
1385 elt.int_val = n;
1386 type_stack.elements.push_back (elt);
c906108c
SS
1387}
1388
95c391b6
TT
1389/* Insert a tp_space_identifier and the corresponding address space
1390 value into the stack. STRING is the name of an address space, as
1391 recognized by address_space_name_to_int. If the stack is empty,
1392 the new elements are simply pushed. If the stack is not empty,
1393 this function assumes that the first item on the stack is a
1394 tp_pointer, and the new values are inserted above the first
1395 item. */
1396
47663de5 1397void
37eedb39 1398insert_type_address_space (struct expr_builder *pstate, char *string)
47663de5 1399{
95c391b6
TT
1400 union type_stack_elt element;
1401 int slot;
1402
1403 /* If there is anything on the stack (we know it will be a
1404 tp_pointer), insert the address space qualifier above it.
1405 Otherwise, simply push this on the top of the stack. */
858d8004 1406 if (!type_stack.elements.empty ())
95c391b6
TT
1407 slot = 1;
1408 else
1409 slot = 0;
1410
1411 element.piece = tp_space_identifier;
1412 insert_into_type_stack (slot, element);
fa9f5be6 1413 element.int_val = address_space_name_to_int (pstate->gdbarch (),
410a0ff2 1414 string);
95c391b6 1415 insert_into_type_stack (slot, element);
47663de5
MS
1416}
1417
c5aa993b 1418enum type_pieces
fba45db2 1419pop_type (void)
c906108c 1420{
858d8004
SM
1421 if (!type_stack.elements.empty ())
1422 {
1423 type_stack_elt elt = type_stack.elements.back ();
1424 type_stack.elements.pop_back ();
1425 return elt.piece;
1426 }
c906108c
SS
1427 return tp_end;
1428}
1429
1430int
fba45db2 1431pop_type_int (void)
c906108c 1432{
858d8004
SM
1433 if (!type_stack.elements.empty ())
1434 {
1435 type_stack_elt elt = type_stack.elements.back ();
1436 type_stack.elements.pop_back ();
1437 return elt.int_val;
1438 }
c906108c
SS
1439 /* "Can't happen". */
1440 return 0;
1441}
1442
71918a86
TT
1443/* Pop a type list element from the global type stack. */
1444
02e12e38 1445static std::vector<struct type *> *
71918a86
TT
1446pop_typelist (void)
1447{
858d8004
SM
1448 gdb_assert (!type_stack.elements.empty ());
1449 type_stack_elt elt = type_stack.elements.back ();
1450 type_stack.elements.pop_back ();
1451 return elt.typelist_val;
71918a86
TT
1452}
1453
fcde5961
TT
1454/* Pop a type_stack element from the global type stack. */
1455
1456static struct type_stack *
1457pop_type_stack (void)
1458{
858d8004
SM
1459 gdb_assert (!type_stack.elements.empty ());
1460 type_stack_elt elt = type_stack.elements.back ();
1461 type_stack.elements.pop_back ();
1462 return elt.stack_val;
fcde5961
TT
1463}
1464
1465/* Append the elements of the type stack FROM to the type stack TO.
1466 Always returns TO. */
1467
1468struct type_stack *
1469append_type_stack (struct type_stack *to, struct type_stack *from)
1470{
858d8004
SM
1471 to->elements.insert (to->elements.end (), from->elements.begin (),
1472 from->elements.end ());
fcde5961
TT
1473 return to;
1474}
1475
1476/* Push the type stack STACK as an element on the global type stack. */
1477
1478void
1479push_type_stack (struct type_stack *stack)
1480{
858d8004
SM
1481 type_stack_elt elt;
1482 elt.stack_val = stack;
1483 type_stack.elements.push_back (elt);
fcde5961
TT
1484 push_type (tp_type_stack);
1485}
1486
1487/* Copy the global type stack into a newly allocated type stack and
1488 return it. The global stack is cleared. The returned type stack
02e12e38 1489 must be freed with delete. */
fcde5961
TT
1490
1491struct type_stack *
1492get_type_stack (void)
1493{
858d8004
SM
1494 struct type_stack *result = new struct type_stack (std::move (type_stack));
1495 type_stack.elements.clear ();
fcde5961
TT
1496 return result;
1497}
1498
71918a86 1499/* Push a function type with arguments onto the global type stack.
a6fb9c08
TT
1500 LIST holds the argument types. If the final item in LIST is NULL,
1501 then the function will be varargs. */
71918a86
TT
1502
1503void
02e12e38 1504push_typelist (std::vector<struct type *> *list)
71918a86 1505{
858d8004
SM
1506 type_stack_elt elt;
1507 elt.typelist_val = list;
1508 type_stack.elements.push_back (elt);
71918a86
TT
1509 push_type (tp_function_with_arguments);
1510}
1511
3693fdb3
PA
1512/* Pop the type stack and return a type_instance_flags that
1513 corresponds the const/volatile qualifiers on the stack. This is
1514 called by the C++ parser when parsing methods types, and as such no
1515 other kind of type in the type stack is expected. */
1516
1517type_instance_flags
1518follow_type_instance_flags ()
1519{
1520 type_instance_flags flags = 0;
1521
1522 for (;;)
1523 switch (pop_type ())
1524 {
1525 case tp_end:
1526 return flags;
1527 case tp_const:
1528 flags |= TYPE_INSTANCE_FLAG_CONST;
1529 break;
1530 case tp_volatile:
1531 flags |= TYPE_INSTANCE_FLAG_VOLATILE;
1532 break;
1533 default:
1534 gdb_assert_not_reached ("unrecognized tp_ value in follow_types");
1535 }
1536}
1537
1538
c906108c
SS
1539/* Pop the type stack and return the type which corresponds to FOLLOW_TYPE
1540 as modified by all the stuff on the stack. */
1541struct type *
fba45db2 1542follow_types (struct type *follow_type)
c906108c
SS
1543{
1544 int done = 0;
2e2394a0
MS
1545 int make_const = 0;
1546 int make_volatile = 0;
47663de5 1547 int make_addr_space = 0;
c906108c 1548 int array_size;
c906108c
SS
1549
1550 while (!done)
1551 switch (pop_type ())
1552 {
1553 case tp_end:
1554 done = 1;
2e2394a0
MS
1555 if (make_const)
1556 follow_type = make_cv_type (make_const,
1557 TYPE_VOLATILE (follow_type),
1558 follow_type, 0);
1559 if (make_volatile)
1560 follow_type = make_cv_type (TYPE_CONST (follow_type),
1561 make_volatile,
1562 follow_type, 0);
47663de5
MS
1563 if (make_addr_space)
1564 follow_type = make_type_with_address_space (follow_type,
1565 make_addr_space);
1566 make_const = make_volatile = 0;
1567 make_addr_space = 0;
2e2394a0
MS
1568 break;
1569 case tp_const:
1570 make_const = 1;
1571 break;
1572 case tp_volatile:
1573 make_volatile = 1;
c906108c 1574 break;
47663de5
MS
1575 case tp_space_identifier:
1576 make_addr_space = pop_type_int ();
1577 break;
c906108c
SS
1578 case tp_pointer:
1579 follow_type = lookup_pointer_type (follow_type);
2e2394a0
MS
1580 if (make_const)
1581 follow_type = make_cv_type (make_const,
1582 TYPE_VOLATILE (follow_type),
1583 follow_type, 0);
1584 if (make_volatile)
1585 follow_type = make_cv_type (TYPE_CONST (follow_type),
1586 make_volatile,
1587 follow_type, 0);
47663de5
MS
1588 if (make_addr_space)
1589 follow_type = make_type_with_address_space (follow_type,
1590 make_addr_space);
2e2394a0 1591 make_const = make_volatile = 0;
47663de5 1592 make_addr_space = 0;
c906108c
SS
1593 break;
1594 case tp_reference:
53cc15f5
AV
1595 follow_type = lookup_lvalue_reference_type (follow_type);
1596 goto process_reference;
1597 case tp_rvalue_reference:
1598 follow_type = lookup_rvalue_reference_type (follow_type);
1599 process_reference:
1600 if (make_const)
1601 follow_type = make_cv_type (make_const,
1602 TYPE_VOLATILE (follow_type),
1603 follow_type, 0);
1604 if (make_volatile)
1605 follow_type = make_cv_type (TYPE_CONST (follow_type),
1606 make_volatile,
1607 follow_type, 0);
1608 if (make_addr_space)
1609 follow_type = make_type_with_address_space (follow_type,
1610 make_addr_space);
2e2394a0 1611 make_const = make_volatile = 0;
47663de5 1612 make_addr_space = 0;
c906108c
SS
1613 break;
1614 case tp_array:
1615 array_size = pop_type_int ();
1616 /* FIXME-type-allocation: need a way to free this type when we are
1617 done with it. */
c906108c 1618 follow_type =
e3506a9f
UW
1619 lookup_array_range_type (follow_type,
1620 0, array_size >= 0 ? array_size - 1 : 0);
c906108c 1621 if (array_size < 0)
729efb13
SA
1622 TYPE_HIGH_BOUND_KIND (TYPE_INDEX_TYPE (follow_type))
1623 = PROP_UNDEFINED;
c906108c
SS
1624 break;
1625 case tp_function:
1626 /* FIXME-type-allocation: need a way to free this type when we are
1627 done with it. */
1628 follow_type = lookup_function_type (follow_type);
1629 break;
fcde5961 1630
71918a86
TT
1631 case tp_function_with_arguments:
1632 {
02e12e38 1633 std::vector<struct type *> *args = pop_typelist ();
71918a86
TT
1634
1635 follow_type
1636 = lookup_function_type_with_arguments (follow_type,
02e12e38
TT
1637 args->size (),
1638 args->data ());
71918a86
TT
1639 }
1640 break;
1641
fcde5961
TT
1642 case tp_type_stack:
1643 {
1644 struct type_stack *stack = pop_type_stack ();
1645 /* Sort of ugly, but not really much worse than the
1646 alternatives. */
1647 struct type_stack save = type_stack;
1648
1649 type_stack = *stack;
1650 follow_type = follow_types (follow_type);
858d8004 1651 gdb_assert (type_stack.elements.empty ());
fcde5961
TT
1652
1653 type_stack = save;
1654 }
1655 break;
1656 default:
1657 gdb_assert_not_reached ("unrecognized tp_ value in follow_types");
c906108c
SS
1658 }
1659 return follow_type;
1660}
1661\f
f461f5cf
PM
1662/* This function avoids direct calls to fprintf
1663 in the parser generated debug code. */
1664void
1665parser_fprintf (FILE *x, const char *y, ...)
1666{
1667 va_list args;
ad3bbd48 1668
f461f5cf
PM
1669 va_start (args, y);
1670 if (x == stderr)
1671 vfprintf_unfiltered (gdb_stderr, y, args);
1672 else
1673 {
1674 fprintf_unfiltered (gdb_stderr, " Unknown FILE used.\n");
1675 vfprintf_unfiltered (gdb_stderr, y, args);
1676 }
1677 va_end (args);
1678}
1679
c0201579
JK
1680/* Implementation of the exp_descriptor method operator_check. */
1681
1682int
1683operator_check_standard (struct expression *exp, int pos,
1684 int (*objfile_func) (struct objfile *objfile,
1685 void *data),
1686 void *data)
1687{
1688 const union exp_element *const elts = exp->elts;
1689 struct type *type = NULL;
1690 struct objfile *objfile = NULL;
1691
1692 /* Extended operators should have been already handled by exp_descriptor
1693 iterate method of its specific language. */
1694 gdb_assert (elts[pos].opcode < OP_EXTENDED0);
1695
1696 /* Track the callers of write_exp_elt_type for this table. */
1697
1698 switch (elts[pos].opcode)
1699 {
1700 case BINOP_VAL:
1701 case OP_COMPLEX:
edd079d9 1702 case OP_FLOAT:
c0201579
JK
1703 case OP_LONG:
1704 case OP_SCOPE:
1705 case OP_TYPE:
1706 case UNOP_CAST:
c0201579
JK
1707 case UNOP_MAX:
1708 case UNOP_MEMVAL:
1709 case UNOP_MIN:
1710 type = elts[pos + 1].type;
1711 break;
1712
1713 case TYPE_INSTANCE:
1714 {
3693fdb3 1715 LONGEST arg, nargs = elts[pos + 2].longconst;
c0201579
JK
1716
1717 for (arg = 0; arg < nargs; arg++)
1718 {
b926417a
TT
1719 struct type *inst_type = elts[pos + 3 + arg].type;
1720 struct objfile *inst_objfile = TYPE_OBJFILE (inst_type);
c0201579 1721
b926417a 1722 if (inst_objfile && (*objfile_func) (inst_objfile, data))
c0201579
JK
1723 return 1;
1724 }
1725 }
1726 break;
1727
c0201579
JK
1728 case OP_VAR_VALUE:
1729 {
1730 const struct block *const block = elts[pos + 1].block;
1731 const struct symbol *const symbol = elts[pos + 2].symbol;
1732
1733 /* Check objfile where the variable itself is placed.
1734 SYMBOL_OBJ_SECTION (symbol) may be NULL. */
08be3fe3 1735 if ((*objfile_func) (symbol_objfile (symbol), data))
c0201579
JK
1736 return 1;
1737
1738 /* Check objfile where is placed the code touching the variable. */
1739 objfile = lookup_objfile_from_block (block);
1740
1741 type = SYMBOL_TYPE (symbol);
1742 }
1743 break;
74ea4be4
PA
1744 case OP_VAR_MSYM_VALUE:
1745 objfile = elts[pos + 1].objfile;
1746 break;
c0201579
JK
1747 }
1748
1749 /* Invoke callbacks for TYPE and OBJFILE if they were set as non-NULL. */
1750
1751 if (type && TYPE_OBJFILE (type)
1752 && (*objfile_func) (TYPE_OBJFILE (type), data))
1753 return 1;
1754 if (objfile && (*objfile_func) (objfile, data))
1755 return 1;
1756
1757 return 0;
1758}
1759
a1c7835a
YQ
1760/* Call OBJFILE_FUNC for any objfile found being referenced by EXP.
1761 OBJFILE_FUNC is never called with NULL OBJFILE. OBJFILE_FUNC get
1762 passed an arbitrary caller supplied DATA pointer. If OBJFILE_FUNC
1763 returns non-zero value then (any other) non-zero value is immediately
1764 returned to the caller. Otherwise zero is returned after iterating
1765 through whole EXP. */
c0201579
JK
1766
1767static int
1768exp_iterate (struct expression *exp,
1769 int (*objfile_func) (struct objfile *objfile, void *data),
1770 void *data)
1771{
1772 int endpos;
c0201579
JK
1773
1774 for (endpos = exp->nelts; endpos > 0; )
1775 {
1776 int pos, args, oplen = 0;
1777
dc21167c 1778 operator_length (exp, endpos, &oplen, &args);
c0201579
JK
1779 gdb_assert (oplen > 0);
1780
1781 pos = endpos - oplen;
1782 if (exp->language_defn->la_exp_desc->operator_check (exp, pos,
1783 objfile_func, data))
1784 return 1;
1785
1786 endpos = pos;
1787 }
1788
1789 return 0;
1790}
1791
1792/* Helper for exp_uses_objfile. */
1793
1794static int
1795exp_uses_objfile_iter (struct objfile *exp_objfile, void *objfile_voidp)
1796{
19ba03f4 1797 struct objfile *objfile = (struct objfile *) objfile_voidp;
c0201579
JK
1798
1799 if (exp_objfile->separate_debug_objfile_backlink)
1800 exp_objfile = exp_objfile->separate_debug_objfile_backlink;
1801
1802 return exp_objfile == objfile;
1803}
1804
1805/* Return 1 if EXP uses OBJFILE (and will become dangling when OBJFILE
1806 is unloaded), otherwise return 0. OBJFILE must not be a separate debug info
1807 file. */
1808
1809int
1810exp_uses_objfile (struct expression *exp, struct objfile *objfile)
1811{
1812 gdb_assert (objfile->separate_debug_objfile_backlink == NULL);
1813
1814 return exp_iterate (exp, exp_uses_objfile_iter, objfile);
1815}
1816
e3980ce2
TT
1817/* Reallocate the `expout' pointer inside PS so that it can accommodate
1818 at least LENELT expression elements. This function does nothing if
1819 there is enough room for the elements. */
410a0ff2 1820
e3980ce2 1821static void
37eedb39 1822increase_expout_size (struct expr_builder *ps, size_t lenelt)
410a0ff2
SDJ
1823{
1824 if ((ps->expout_ptr + lenelt) >= ps->expout_size)
1825 {
325fac50 1826 ps->expout_size = std::max (ps->expout_size * 2,
e9d9f57e
TT
1827 ps->expout_ptr + lenelt + 10);
1828 ps->expout.reset (XRESIZEVAR (expression,
1829 ps->expout.release (),
1830 (sizeof (struct expression)
1831 + EXP_ELEM_TO_BYTES (ps->expout_size))));
410a0ff2
SDJ
1832 }
1833}
1834
ac9a91a7 1835void
fba45db2 1836_initialize_parse (void)
ac9a91a7 1837{
ccce17b0
YQ
1838 add_setshow_zuinteger_cmd ("expression", class_maintenance,
1839 &expressiondebug,
1840 _("Set expression debugging."),
1841 _("Show expression debugging."),
1842 _("When non-zero, the internal representation "
1843 "of expressions will be printed."),
1844 NULL,
1845 show_expressiondebug,
1846 &setdebuglist, &showdebuglist);
92981e24 1847 add_setshow_boolean_cmd ("parser", class_maintenance,
3e43a32a
MS
1848 &parser_debug,
1849 _("Set parser debugging."),
1850 _("Show parser debugging."),
1851 _("When non-zero, expression parser "
1852 "tracing will be enabled."),
92981e24
TT
1853 NULL,
1854 show_parserdebug,
1855 &setdebuglist, &showdebuglist);
c906108c 1856}
This page took 1.85184 seconds and 4 git commands to generate.