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