import gdb-1999-09-08 snapshot
[deliverable/binutils-gdb.git] / gdb / parse.c
1 /* Parse expressions for GDB.
2 Copyright (C) 1986, 89, 90, 91, 94, 98, 1999 Free Software Foundation, Inc.
3 Modified from expread.y by the Department of Computer Science at the
4 State University of New York at Buffalo, 1991.
5
6 This file is part of GDB.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
22
23 /* Parse an expression from text in a string,
24 and return the result as a struct expression pointer.
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. */
31
32 #include <ctype.h>
33
34 #include "defs.h"
35 #include "gdb_string.h"
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"
43 #include "parser-defs.h"
44 #include "gdbcmd.h"
45 #include "symfile.h" /* for overlay functions */
46 \f
47 /* Global variables declared in parser-defs.h (and commented there). */
48 struct expression *expout;
49 int expout_size;
50 int expout_ptr;
51 struct block *expression_context_block;
52 struct block *innermost_block;
53 int arglist_len;
54 union type_stack_elt *type_stack;
55 int type_stack_depth, type_stack_size;
56 char *lexptr;
57 char *namecopy;
58 int paren_depth;
59 int comma_terminates;
60 \f
61 static int expressiondebug = 0;
62
63 extern int hp_som_som_object_present;
64
65 static void
66 free_funcalls PARAMS ((void));
67
68 static void
69 prefixify_expression PARAMS ((struct expression *));
70
71 static void
72 prefixify_subexp PARAMS ((struct expression *, struct expression *, int, int));
73
74 void _initialize_parse PARAMS ((void));
75
76 /* Data structure for saving values of arglist_len for function calls whose
77 arguments contain other function calls. */
78
79 struct funcall
80 {
81 struct funcall *next;
82 int arglist_len;
83 };
84
85 static struct funcall *funcall_chain;
86
87 /* Assign machine-independent names to certain registers
88 (unless overridden by the REGISTER_NAMES table) */
89
90 unsigned num_std_regs = 0;
91 struct std_regs *std_regs;
92
93 /* The generic method for targets to specify how their registers are
94 named. The mapping can be derived from three sources:
95 REGISTER_NAME; std_regs; or a target specific alias hook. */
96
97 int
98 target_map_name_to_register (str, len)
99 char *str;
100 int len;
101 {
102 int i;
103
104 /* First try target specific aliases. We try these first because on some
105 systems standard names can be context dependent (eg. $pc on a
106 multiprocessor can be could be any of several PCs). */
107 #ifdef REGISTER_NAME_ALIAS_HOOK
108 i = REGISTER_NAME_ALIAS_HOOK (str, len);
109 if (i >= 0)
110 return i;
111 #endif
112
113 /* Search architectural register name space. */
114 for (i = 0; i < NUM_REGS; i++)
115 if (REGISTER_NAME (i) && len == strlen (REGISTER_NAME (i))
116 && STREQN (str, REGISTER_NAME (i), len))
117 {
118 return i;
119 }
120
121 /* Try standard aliases */
122 for (i = 0; i < num_std_regs; i++)
123 if (std_regs[i].name && len == strlen (std_regs[i].name)
124 && STREQN (str, std_regs[i].name, len))
125 {
126 return std_regs[i].regnum;
127 }
128
129 return -1;
130 }
131
132 /* Begin counting arguments for a function call,
133 saving the data about any containing call. */
134
135 void
136 start_arglist ()
137 {
138 register struct funcall *new;
139
140 new = (struct funcall *) xmalloc (sizeof (struct funcall));
141 new->next = funcall_chain;
142 new->arglist_len = arglist_len;
143 arglist_len = 0;
144 funcall_chain = new;
145 }
146
147 /* Return the number of arguments in a function call just terminated,
148 and restore the data for the containing function call. */
149
150 int
151 end_arglist ()
152 {
153 register int val = arglist_len;
154 register struct funcall *call = funcall_chain;
155 funcall_chain = call->next;
156 arglist_len = call->arglist_len;
157 free ((PTR) call);
158 return val;
159 }
160
161 /* Free everything in the funcall chain.
162 Used when there is an error inside parsing. */
163
164 static void
165 free_funcalls ()
166 {
167 register struct funcall *call, *next;
168
169 for (call = funcall_chain; call; call = next)
170 {
171 next = call->next;
172 free ((PTR) call);
173 }
174 }
175 \f
176 /* This page contains the functions for adding data to the struct expression
177 being constructed. */
178
179 /* Add one element to the end of the expression. */
180
181 /* To avoid a bug in the Sun 4 compiler, we pass things that can fit into
182 a register through here */
183
184 void
185 write_exp_elt (expelt)
186 union exp_element expelt;
187 {
188 if (expout_ptr >= expout_size)
189 {
190 expout_size *= 2;
191 expout = (struct expression *)
192 xrealloc ((char *) expout, sizeof (struct expression)
193 + EXP_ELEM_TO_BYTES (expout_size));
194 }
195 expout->elts[expout_ptr++] = expelt;
196 }
197
198 void
199 write_exp_elt_opcode (expelt)
200 enum exp_opcode expelt;
201 {
202 union exp_element tmp;
203
204 tmp.opcode = expelt;
205
206 write_exp_elt (tmp);
207 }
208
209 void
210 write_exp_elt_sym (expelt)
211 struct symbol *expelt;
212 {
213 union exp_element tmp;
214
215 tmp.symbol = expelt;
216
217 write_exp_elt (tmp);
218 }
219
220 void
221 write_exp_elt_block (b)
222 struct block *b;
223 {
224 union exp_element tmp;
225 tmp.block = b;
226 write_exp_elt (tmp);
227 }
228
229 void
230 write_exp_elt_longcst (expelt)
231 LONGEST expelt;
232 {
233 union exp_element tmp;
234
235 tmp.longconst = expelt;
236
237 write_exp_elt (tmp);
238 }
239
240 void
241 write_exp_elt_dblcst (expelt)
242 DOUBLEST expelt;
243 {
244 union exp_element tmp;
245
246 tmp.doubleconst = expelt;
247
248 write_exp_elt (tmp);
249 }
250
251 void
252 write_exp_elt_type (expelt)
253 struct type *expelt;
254 {
255 union exp_element tmp;
256
257 tmp.type = expelt;
258
259 write_exp_elt (tmp);
260 }
261
262 void
263 write_exp_elt_intern (expelt)
264 struct internalvar *expelt;
265 {
266 union exp_element tmp;
267
268 tmp.internalvar = expelt;
269
270 write_exp_elt (tmp);
271 }
272
273 /* Add a string constant to the end of the expression.
274
275 String constants are stored by first writing an expression element
276 that contains the length of the string, then stuffing the string
277 constant itself into however many expression elements are needed
278 to hold it, and then writing another expression element that contains
279 the length of the string. I.E. an expression element at each end of
280 the string records the string length, so you can skip over the
281 expression elements containing the actual string bytes from either
282 end of the string. Note that this also allows gdb to handle
283 strings with embedded null bytes, as is required for some languages.
284
285 Don't be fooled by the fact that the string is null byte terminated,
286 this is strictly for the convenience of debugging gdb itself. Gdb
287 Gdb does not depend up the string being null terminated, since the
288 actual length is recorded in expression elements at each end of the
289 string. The null byte is taken into consideration when computing how
290 many expression elements are required to hold the string constant, of
291 course. */
292
293
294 void
295 write_exp_string (str)
296 struct stoken str;
297 {
298 register int len = str.length;
299 register int lenelt;
300 register char *strdata;
301
302 /* Compute the number of expression elements required to hold the string
303 (including a null byte terminator), along with one expression element
304 at each end to record the actual string length (not including the
305 null byte terminator). */
306
307 lenelt = 2 + BYTES_TO_EXP_ELEM (len + 1);
308
309 /* Ensure that we have enough available expression elements to store
310 everything. */
311
312 if ((expout_ptr + lenelt) >= expout_size)
313 {
314 expout_size = max (expout_size * 2, expout_ptr + lenelt + 10);
315 expout = (struct expression *)
316 xrealloc ((char *) expout, (sizeof (struct expression)
317 + EXP_ELEM_TO_BYTES (expout_size)));
318 }
319
320 /* Write the leading length expression element (which advances the current
321 expression element index), then write the string constant followed by a
322 terminating null byte, and then write the trailing length expression
323 element. */
324
325 write_exp_elt_longcst ((LONGEST) len);
326 strdata = (char *) &expout->elts[expout_ptr];
327 memcpy (strdata, str.ptr, len);
328 *(strdata + len) = '\0';
329 expout_ptr += lenelt - 2;
330 write_exp_elt_longcst ((LONGEST) len);
331 }
332
333 /* Add a bitstring constant to the end of the expression.
334
335 Bitstring constants are stored by first writing an expression element
336 that contains the length of the bitstring (in bits), then stuffing the
337 bitstring constant itself into however many expression elements are
338 needed to hold it, and then writing another expression element that
339 contains the length of the bitstring. I.E. an expression element at
340 each end of the bitstring records the bitstring length, so you can skip
341 over the expression elements containing the actual bitstring bytes from
342 either end of the bitstring. */
343
344 void
345 write_exp_bitstring (str)
346 struct stoken str;
347 {
348 register int bits = str.length; /* length in bits */
349 register int len = (bits + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
350 register int lenelt;
351 register char *strdata;
352
353 /* Compute the number of expression elements required to hold the bitstring,
354 along with one expression element at each end to record the actual
355 bitstring length in bits. */
356
357 lenelt = 2 + BYTES_TO_EXP_ELEM (len);
358
359 /* Ensure that we have enough available expression elements to store
360 everything. */
361
362 if ((expout_ptr + lenelt) >= expout_size)
363 {
364 expout_size = max (expout_size * 2, expout_ptr + lenelt + 10);
365 expout = (struct expression *)
366 xrealloc ((char *) expout, (sizeof (struct expression)
367 + EXP_ELEM_TO_BYTES (expout_size)));
368 }
369
370 /* Write the leading length expression element (which advances the current
371 expression element index), then write the bitstring constant, and then
372 write the trailing length expression element. */
373
374 write_exp_elt_longcst ((LONGEST) bits);
375 strdata = (char *) &expout->elts[expout_ptr];
376 memcpy (strdata, str.ptr, len);
377 expout_ptr += lenelt - 2;
378 write_exp_elt_longcst ((LONGEST) bits);
379 }
380
381 /* Add the appropriate elements for a minimal symbol to the end of
382 the expression. The rationale behind passing in text_symbol_type and
383 data_symbol_type was so that Modula-2 could pass in WORD for
384 data_symbol_type. Perhaps it still is useful to have those types vary
385 based on the language, but they no longer have names like "int", so
386 the initial rationale is gone. */
387
388 static struct type *msym_text_symbol_type;
389 static struct type *msym_data_symbol_type;
390 static struct type *msym_unknown_symbol_type;
391
392 void
393 write_exp_msymbol (msymbol, text_symbol_type, data_symbol_type)
394 struct minimal_symbol *msymbol;
395 struct type *text_symbol_type;
396 struct type *data_symbol_type;
397 {
398 CORE_ADDR addr;
399
400 write_exp_elt_opcode (OP_LONG);
401 write_exp_elt_type (lookup_pointer_type (builtin_type_void));
402
403 addr = SYMBOL_VALUE_ADDRESS (msymbol);
404 if (overlay_debugging)
405 addr = symbol_overlayed_address (addr, SYMBOL_BFD_SECTION (msymbol));
406 write_exp_elt_longcst ((LONGEST) addr);
407
408 write_exp_elt_opcode (OP_LONG);
409
410 write_exp_elt_opcode (UNOP_MEMVAL);
411 switch (msymbol->type)
412 {
413 case mst_text:
414 case mst_file_text:
415 case mst_solib_trampoline:
416 write_exp_elt_type (msym_text_symbol_type);
417 break;
418
419 case mst_data:
420 case mst_file_data:
421 case mst_bss:
422 case mst_file_bss:
423 write_exp_elt_type (msym_data_symbol_type);
424 break;
425
426 default:
427 write_exp_elt_type (msym_unknown_symbol_type);
428 break;
429 }
430 write_exp_elt_opcode (UNOP_MEMVAL);
431 }
432 \f
433 /* Recognize tokens that start with '$'. These include:
434
435 $regname A native register name or a "standard
436 register name".
437
438 $variable A convenience variable with a name chosen
439 by the user.
440
441 $digits Value history with index <digits>, starting
442 from the first value which has index 1.
443
444 $$digits Value history with index <digits> relative
445 to the last value. I.E. $$0 is the last
446 value, $$1 is the one previous to that, $$2
447 is the one previous to $$1, etc.
448
449 $ | $0 | $$0 The last value in the value history.
450
451 $$ An abbreviation for the second to the last
452 value in the value history, I.E. $$1
453
454 */
455
456 void
457 write_dollar_variable (str)
458 struct stoken str;
459 {
460 /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
461 and $$digits (equivalent to $<-digits> if you could type that). */
462
463 struct symbol *sym = NULL;
464 struct minimal_symbol *msym = NULL;
465
466 int negate = 0;
467 int i = 1;
468 /* Double dollar means negate the number and add -1 as well.
469 Thus $$ alone means -1. */
470 if (str.length >= 2 && str.ptr[1] == '$')
471 {
472 negate = 1;
473 i = 2;
474 }
475 if (i == str.length)
476 {
477 /* Just dollars (one or two) */
478 i = -negate;
479 goto handle_last;
480 }
481 /* Is the rest of the token digits? */
482 for (; i < str.length; i++)
483 if (!(str.ptr[i] >= '0' && str.ptr[i] <= '9'))
484 break;
485 if (i == str.length)
486 {
487 i = atoi (str.ptr + 1 + negate);
488 if (negate)
489 i = -i;
490 goto handle_last;
491 }
492
493 /* Handle tokens that refer to machine registers:
494 $ followed by a register name. */
495 i = target_map_name_to_register (str.ptr + 1, str.length - 1);
496 if (i >= 0)
497 goto handle_register;
498
499 /* On HP-UX, certain system routines (millicode) have names beginning
500 with $ or $$, e.g. $$dyncall, which handles inter-space procedure
501 calls on PA-RISC. Check for those, first. */
502
503 sym = lookup_symbol (copy_name (str), (struct block *) NULL,
504 VAR_NAMESPACE, (int *) NULL, (struct symtab **) NULL);
505 if (sym)
506 {
507 write_exp_elt_opcode (OP_VAR_VALUE);
508 write_exp_elt_block (block_found); /* set by lookup_symbol */
509 write_exp_elt_sym (sym);
510 write_exp_elt_opcode (OP_VAR_VALUE);
511 return;
512 }
513 msym = lookup_minimal_symbol (copy_name (str), NULL, NULL);
514 if (msym)
515 {
516 write_exp_msymbol (msym,
517 lookup_function_type (builtin_type_int),
518 builtin_type_int);
519 return;
520 }
521
522 /* Any other names starting in $ are debugger internal variables. */
523
524 write_exp_elt_opcode (OP_INTERNALVAR);
525 write_exp_elt_intern (lookup_internalvar (copy_name (str) + 1));
526 write_exp_elt_opcode (OP_INTERNALVAR);
527 return;
528 handle_last:
529 write_exp_elt_opcode (OP_LAST);
530 write_exp_elt_longcst ((LONGEST) i);
531 write_exp_elt_opcode (OP_LAST);
532 return;
533 handle_register:
534 write_exp_elt_opcode (OP_REGISTER);
535 write_exp_elt_longcst (i);
536 write_exp_elt_opcode (OP_REGISTER);
537 return;
538 }
539
540
541 /* Parse a string that is possibly a namespace / nested class
542 specification, i.e., something of the form A::B::C::x. Input
543 (NAME) is the entire string; LEN is the current valid length; the
544 output is a string, TOKEN, which points to the largest recognized
545 prefix which is a series of namespaces or classes. CLASS_PREFIX is
546 another output, which records whether a nested class spec was
547 recognized (= 1) or a fully qualified variable name was found (=
548 0). ARGPTR is side-effected (if non-NULL) to point to beyond the
549 string recognized and consumed by this routine.
550
551 The return value is a pointer to the symbol for the base class or
552 variable if found, or NULL if not found. Callers must check this
553 first -- if NULL, the outputs may not be correct.
554
555 This function is used c-exp.y. This is used specifically to get
556 around HP aCC (and possibly other compilers), which insists on
557 generating names with embedded colons for namespace or nested class
558 members.
559
560 (Argument LEN is currently unused. 1997-08-27)
561
562 Callers must free memory allocated for the output string TOKEN. */
563
564 static const char coloncolon[2] =
565 {':', ':'};
566
567 struct symbol *
568 parse_nested_classes_for_hpacc (name, len, token, class_prefix, argptr)
569 char *name;
570 int len;
571 char **token;
572 int *class_prefix;
573 char **argptr;
574 {
575 /* Comment below comes from decode_line_1 which has very similar
576 code, which is called for "break" command parsing. */
577
578 /* We have what looks like a class or namespace
579 scope specification (A::B), possibly with many
580 levels of namespaces or classes (A::B::C::D).
581
582 Some versions of the HP ANSI C++ compiler (as also possibly
583 other compilers) generate class/function/member names with
584 embedded double-colons if they are inside namespaces. To
585 handle this, we loop a few times, considering larger and
586 larger prefixes of the string as though they were single
587 symbols. So, if the initially supplied string is
588 A::B::C::D::foo, we have to look up "A", then "A::B",
589 then "A::B::C", then "A::B::C::D", and finally
590 "A::B::C::D::foo" as single, monolithic symbols, because
591 A, B, C or D may be namespaces.
592
593 Note that namespaces can nest only inside other
594 namespaces, and not inside classes. So we need only
595 consider *prefixes* of the string; there is no need to look up
596 "B::C" separately as a symbol in the previous example. */
597
598 register char *p;
599 char *start, *end;
600 char *prefix = NULL;
601 char *tmp;
602 struct symbol *sym_class = NULL;
603 struct symbol *sym_var = NULL;
604 struct type *t;
605 int prefix_len = 0;
606 int done = 0;
607 char *q;
608
609 /* Check for HP-compiled executable -- in other cases
610 return NULL, and caller must default to standard GDB
611 behaviour. */
612
613 if (!hp_som_som_object_present)
614 return (struct symbol *) NULL;
615
616 p = name;
617
618 /* Skip over whitespace and possible global "::" */
619 while (*p && (*p == ' ' || *p == '\t'))
620 p++;
621 if (p[0] == ':' && p[1] == ':')
622 p += 2;
623 while (*p && (*p == ' ' || *p == '\t'))
624 p++;
625
626 while (1)
627 {
628 /* Get to the end of the next namespace or class spec. */
629 /* If we're looking at some non-token, fail immediately */
630 start = p;
631 if (!(isalpha (*p) || *p == '$' || *p == '_'))
632 return (struct symbol *) NULL;
633 p++;
634 while (*p && (isalnum (*p) || *p == '$' || *p == '_'))
635 p++;
636
637 if (*p == '<')
638 {
639 /* If we have the start of a template specification,
640 scan right ahead to its end */
641 q = find_template_name_end (p);
642 if (q)
643 p = q;
644 }
645
646 end = p;
647
648 /* Skip over "::" and whitespace for next time around */
649 while (*p && (*p == ' ' || *p == '\t'))
650 p++;
651 if (p[0] == ':' && p[1] == ':')
652 p += 2;
653 while (*p && (*p == ' ' || *p == '\t'))
654 p++;
655
656 /* Done with tokens? */
657 if (!*p || !(isalpha (*p) || *p == '$' || *p == '_'))
658 done = 1;
659
660 tmp = (char *) alloca (prefix_len + end - start + 3);
661 if (prefix)
662 {
663 memcpy (tmp, prefix, prefix_len);
664 memcpy (tmp + prefix_len, coloncolon, 2);
665 memcpy (tmp + prefix_len + 2, start, end - start);
666 tmp[prefix_len + 2 + end - start] = '\000';
667 }
668 else
669 {
670 memcpy (tmp, start, end - start);
671 tmp[end - start] = '\000';
672 }
673
674 prefix = tmp;
675 prefix_len = strlen (prefix);
676
677 /* See if the prefix we have now is something we know about */
678
679 if (!done)
680 {
681 /* More tokens to process, so this must be a class/namespace */
682 sym_class = lookup_symbol (prefix, 0, STRUCT_NAMESPACE,
683 0, (struct symtab **) NULL);
684 }
685 else
686 {
687 /* No more tokens, so try as a variable first */
688 sym_var = lookup_symbol (prefix, 0, VAR_NAMESPACE,
689 0, (struct symtab **) NULL);
690 /* If failed, try as class/namespace */
691 if (!sym_var)
692 sym_class = lookup_symbol (prefix, 0, STRUCT_NAMESPACE,
693 0, (struct symtab **) NULL);
694 }
695
696 if (sym_var ||
697 (sym_class &&
698 (t = check_typedef (SYMBOL_TYPE (sym_class)),
699 (TYPE_CODE (t) == TYPE_CODE_STRUCT
700 || TYPE_CODE (t) == TYPE_CODE_UNION))))
701 {
702 /* We found a valid token */
703 *token = (char *) xmalloc (prefix_len + 1);
704 memcpy (*token, prefix, prefix_len);
705 (*token)[prefix_len] = '\000';
706 break;
707 }
708
709 /* No variable or class/namespace found, no more tokens */
710 if (done)
711 return (struct symbol *) NULL;
712 }
713
714 /* Out of loop, so we must have found a valid token */
715 if (sym_var)
716 *class_prefix = 0;
717 else
718 *class_prefix = 1;
719
720 if (argptr)
721 *argptr = done ? p : end;
722
723 return sym_var ? sym_var : sym_class; /* found */
724 }
725
726 char *
727 find_template_name_end (p)
728 char *p;
729 {
730 int depth = 1;
731 int just_seen_right = 0;
732 int just_seen_colon = 0;
733 int just_seen_space = 0;
734
735 if (!p || (*p != '<'))
736 return 0;
737
738 while (*++p)
739 {
740 switch (*p)
741 {
742 case '\'':
743 case '\"':
744 case '{':
745 case '}':
746 /* In future, may want to allow these?? */
747 return 0;
748 case '<':
749 depth++; /* start nested template */
750 if (just_seen_colon || just_seen_right || just_seen_space)
751 return 0; /* but not after : or :: or > or space */
752 break;
753 case '>':
754 if (just_seen_colon || just_seen_right)
755 return 0; /* end a (nested?) template */
756 just_seen_right = 1; /* but not after : or :: */
757 if (--depth == 0) /* also disallow >>, insist on > > */
758 return ++p; /* if outermost ended, return */
759 break;
760 case ':':
761 if (just_seen_space || (just_seen_colon > 1))
762 return 0; /* nested class spec coming up */
763 just_seen_colon++; /* we allow :: but not :::: */
764 break;
765 case ' ':
766 break;
767 default:
768 if (!((*p >= 'a' && *p <= 'z') || /* allow token chars */
769 (*p >= 'A' && *p <= 'Z') ||
770 (*p >= '0' && *p <= '9') ||
771 (*p == '_') || (*p == ',') || /* commas for template args */
772 (*p == '&') || (*p == '*') || /* pointer and ref types */
773 (*p == '(') || (*p == ')') || /* function types */
774 (*p == '[') || (*p == ']'))) /* array types */
775 return 0;
776 }
777 if (*p != ' ')
778 just_seen_space = 0;
779 if (*p != ':')
780 just_seen_colon = 0;
781 if (*p != '>')
782 just_seen_right = 0;
783 }
784 return 0;
785 }
786 \f
787
788
789 /* Return a null-terminated temporary copy of the name
790 of a string token. */
791
792 char *
793 copy_name (token)
794 struct stoken token;
795 {
796 memcpy (namecopy, token.ptr, token.length);
797 namecopy[token.length] = 0;
798 return namecopy;
799 }
800 \f
801 /* Reverse an expression from suffix form (in which it is constructed)
802 to prefix form (in which we can conveniently print or execute it). */
803
804 static void
805 prefixify_expression (expr)
806 register struct expression *expr;
807 {
808 register int len =
809 sizeof (struct expression) + EXP_ELEM_TO_BYTES (expr->nelts);
810 register struct expression *temp;
811 register int inpos = expr->nelts, outpos = 0;
812
813 temp = (struct expression *) alloca (len);
814
815 /* Copy the original expression into temp. */
816 memcpy (temp, expr, len);
817
818 prefixify_subexp (temp, expr, inpos, outpos);
819 }
820
821 /* Return the number of exp_elements in the subexpression of EXPR
822 whose last exp_element is at index ENDPOS - 1 in EXPR. */
823
824 int
825 length_of_subexp (expr, endpos)
826 register struct expression *expr;
827 register int endpos;
828 {
829 register int oplen = 1;
830 register int args = 0;
831 register int i;
832
833 if (endpos < 1)
834 error ("?error in length_of_subexp");
835
836 i = (int) expr->elts[endpos - 1].opcode;
837
838 switch (i)
839 {
840 /* C++ */
841 case OP_SCOPE:
842 oplen = longest_to_int (expr->elts[endpos - 2].longconst);
843 oplen = 5 + BYTES_TO_EXP_ELEM (oplen + 1);
844 break;
845
846 case OP_LONG:
847 case OP_DOUBLE:
848 case OP_VAR_VALUE:
849 oplen = 4;
850 break;
851
852 case OP_TYPE:
853 case OP_BOOL:
854 case OP_LAST:
855 case OP_REGISTER:
856 case OP_INTERNALVAR:
857 oplen = 3;
858 break;
859
860 case OP_COMPLEX:
861 oplen = 1;
862 args = 2;
863 break;
864
865 case OP_FUNCALL:
866 case OP_F77_UNDETERMINED_ARGLIST:
867 oplen = 3;
868 args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
869 break;
870
871 case UNOP_MAX:
872 case UNOP_MIN:
873 oplen = 3;
874 break;
875
876 case BINOP_VAL:
877 case UNOP_CAST:
878 case UNOP_MEMVAL:
879 oplen = 3;
880 args = 1;
881 break;
882
883 case UNOP_ABS:
884 case UNOP_CAP:
885 case UNOP_CHR:
886 case UNOP_FLOAT:
887 case UNOP_HIGH:
888 case UNOP_ODD:
889 case UNOP_ORD:
890 case UNOP_TRUNC:
891 oplen = 1;
892 args = 1;
893 break;
894
895 case OP_LABELED:
896 case STRUCTOP_STRUCT:
897 case STRUCTOP_PTR:
898 args = 1;
899 /* fall through */
900 case OP_M2_STRING:
901 case OP_STRING:
902 case OP_NAME:
903 case OP_EXPRSTRING:
904 oplen = longest_to_int (expr->elts[endpos - 2].longconst);
905 oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
906 break;
907
908 case OP_BITSTRING:
909 oplen = longest_to_int (expr->elts[endpos - 2].longconst);
910 oplen = (oplen + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
911 oplen = 4 + BYTES_TO_EXP_ELEM (oplen);
912 break;
913
914 case OP_ARRAY:
915 oplen = 4;
916 args = longest_to_int (expr->elts[endpos - 2].longconst);
917 args -= longest_to_int (expr->elts[endpos - 3].longconst);
918 args += 1;
919 break;
920
921 case TERNOP_COND:
922 case TERNOP_SLICE:
923 case TERNOP_SLICE_COUNT:
924 args = 3;
925 break;
926
927 /* Modula-2 */
928 case MULTI_SUBSCRIPT:
929 oplen = 3;
930 args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
931 break;
932
933 case BINOP_ASSIGN_MODIFY:
934 oplen = 3;
935 args = 2;
936 break;
937
938 /* C++ */
939 case OP_THIS:
940 oplen = 2;
941 break;
942
943 default:
944 args = 1 + (i < (int) BINOP_END);
945 }
946
947 while (args > 0)
948 {
949 oplen += length_of_subexp (expr, endpos - oplen);
950 args--;
951 }
952
953 return oplen;
954 }
955
956 /* Copy the subexpression ending just before index INEND in INEXPR
957 into OUTEXPR, starting at index OUTBEG.
958 In the process, convert it from suffix to prefix form. */
959
960 static void
961 prefixify_subexp (inexpr, outexpr, inend, outbeg)
962 register struct expression *inexpr;
963 struct expression *outexpr;
964 register int inend;
965 int outbeg;
966 {
967 register int oplen = 1;
968 register int args = 0;
969 register int i;
970 int *arglens;
971 enum exp_opcode opcode;
972
973 /* Compute how long the last operation is (in OPLEN),
974 and also how many preceding subexpressions serve as
975 arguments for it (in ARGS). */
976
977 opcode = inexpr->elts[inend - 1].opcode;
978 switch (opcode)
979 {
980 /* C++ */
981 case OP_SCOPE:
982 oplen = longest_to_int (inexpr->elts[inend - 2].longconst);
983 oplen = 5 + BYTES_TO_EXP_ELEM (oplen + 1);
984 break;
985
986 case OP_LONG:
987 case OP_DOUBLE:
988 case OP_VAR_VALUE:
989 oplen = 4;
990 break;
991
992 case OP_TYPE:
993 case OP_BOOL:
994 case OP_LAST:
995 case OP_REGISTER:
996 case OP_INTERNALVAR:
997 oplen = 3;
998 break;
999
1000 case OP_COMPLEX:
1001 oplen = 1;
1002 args = 2;
1003 break;
1004
1005 case OP_FUNCALL:
1006 case OP_F77_UNDETERMINED_ARGLIST:
1007 oplen = 3;
1008 args = 1 + longest_to_int (inexpr->elts[inend - 2].longconst);
1009 break;
1010
1011 case UNOP_MIN:
1012 case UNOP_MAX:
1013 oplen = 3;
1014 break;
1015
1016 case UNOP_CAST:
1017 case UNOP_MEMVAL:
1018 oplen = 3;
1019 args = 1;
1020 break;
1021
1022 case UNOP_ABS:
1023 case UNOP_CAP:
1024 case UNOP_CHR:
1025 case UNOP_FLOAT:
1026 case UNOP_HIGH:
1027 case UNOP_ODD:
1028 case UNOP_ORD:
1029 case UNOP_TRUNC:
1030 oplen = 1;
1031 args = 1;
1032 break;
1033
1034 case STRUCTOP_STRUCT:
1035 case STRUCTOP_PTR:
1036 case OP_LABELED:
1037 args = 1;
1038 /* fall through */
1039 case OP_M2_STRING:
1040 case OP_STRING:
1041 case OP_NAME:
1042 case OP_EXPRSTRING:
1043 oplen = longest_to_int (inexpr->elts[inend - 2].longconst);
1044 oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
1045 break;
1046
1047 case OP_BITSTRING:
1048 oplen = longest_to_int (inexpr->elts[inend - 2].longconst);
1049 oplen = (oplen + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
1050 oplen = 4 + BYTES_TO_EXP_ELEM (oplen);
1051 break;
1052
1053 case OP_ARRAY:
1054 oplen = 4;
1055 args = longest_to_int (inexpr->elts[inend - 2].longconst);
1056 args -= longest_to_int (inexpr->elts[inend - 3].longconst);
1057 args += 1;
1058 break;
1059
1060 case TERNOP_COND:
1061 case TERNOP_SLICE:
1062 case TERNOP_SLICE_COUNT:
1063 args = 3;
1064 break;
1065
1066 case BINOP_ASSIGN_MODIFY:
1067 oplen = 3;
1068 args = 2;
1069 break;
1070
1071 /* Modula-2 */
1072 case MULTI_SUBSCRIPT:
1073 oplen = 3;
1074 args = 1 + longest_to_int (inexpr->elts[inend - 2].longconst);
1075 break;
1076
1077 /* C++ */
1078 case OP_THIS:
1079 oplen = 2;
1080 break;
1081
1082 default:
1083 args = 1 + ((int) opcode < (int) BINOP_END);
1084 }
1085
1086 /* Copy the final operator itself, from the end of the input
1087 to the beginning of the output. */
1088 inend -= oplen;
1089 memcpy (&outexpr->elts[outbeg], &inexpr->elts[inend],
1090 EXP_ELEM_TO_BYTES (oplen));
1091 outbeg += oplen;
1092
1093 /* Find the lengths of the arg subexpressions. */
1094 arglens = (int *) alloca (args * sizeof (int));
1095 for (i = args - 1; i >= 0; i--)
1096 {
1097 oplen = length_of_subexp (inexpr, inend);
1098 arglens[i] = oplen;
1099 inend -= oplen;
1100 }
1101
1102 /* Now copy each subexpression, preserving the order of
1103 the subexpressions, but prefixifying each one.
1104 In this loop, inend starts at the beginning of
1105 the expression this level is working on
1106 and marches forward over the arguments.
1107 outbeg does similarly in the output. */
1108 for (i = 0; i < args; i++)
1109 {
1110 oplen = arglens[i];
1111 inend += oplen;
1112 prefixify_subexp (inexpr, outexpr, inend, outbeg);
1113 outbeg += oplen;
1114 }
1115 }
1116 \f
1117 /* This page contains the two entry points to this file. */
1118
1119 /* Read an expression from the string *STRINGPTR points to,
1120 parse it, and return a pointer to a struct expression that we malloc.
1121 Use block BLOCK as the lexical context for variable names;
1122 if BLOCK is zero, use the block of the selected stack frame.
1123 Meanwhile, advance *STRINGPTR to point after the expression,
1124 at the first nonwhite character that is not part of the expression
1125 (possibly a null character).
1126
1127 If COMMA is nonzero, stop if a comma is reached. */
1128
1129 struct expression *
1130 parse_exp_1 (stringptr, block, comma)
1131 char **stringptr;
1132 struct block *block;
1133 int comma;
1134 {
1135 struct cleanup *old_chain;
1136
1137 lexptr = *stringptr;
1138
1139 paren_depth = 0;
1140 type_stack_depth = 0;
1141
1142 comma_terminates = comma;
1143
1144 if (lexptr == 0 || *lexptr == 0)
1145 error_no_arg ("expression to compute");
1146
1147 old_chain = make_cleanup ((make_cleanup_func) free_funcalls, 0);
1148 funcall_chain = 0;
1149
1150 expression_context_block = block ? block : get_selected_block ();
1151
1152 namecopy = (char *) alloca (strlen (lexptr) + 1);
1153 expout_size = 10;
1154 expout_ptr = 0;
1155 expout = (struct expression *)
1156 xmalloc (sizeof (struct expression) + EXP_ELEM_TO_BYTES (expout_size));
1157 expout->language_defn = current_language;
1158 make_cleanup ((make_cleanup_func) free_current_contents, &expout);
1159
1160 if (current_language->la_parser ())
1161 current_language->la_error (NULL);
1162
1163 discard_cleanups (old_chain);
1164
1165 /* Record the actual number of expression elements, and then
1166 reallocate the expression memory so that we free up any
1167 excess elements. */
1168
1169 expout->nelts = expout_ptr;
1170 expout = (struct expression *)
1171 xrealloc ((char *) expout,
1172 sizeof (struct expression) + EXP_ELEM_TO_BYTES (expout_ptr));;
1173
1174 /* Convert expression from postfix form as generated by yacc
1175 parser, to a prefix form. */
1176
1177 if (expressiondebug)
1178 dump_prefix_expression (expout, gdb_stdlog,
1179 "before conversion to prefix form");
1180
1181 prefixify_expression (expout);
1182
1183 if (expressiondebug)
1184 dump_postfix_expression (expout, gdb_stdlog,
1185 "after conversion to prefix form");
1186
1187 *stringptr = lexptr;
1188 return expout;
1189 }
1190
1191 /* Parse STRING as an expression, and complain if this fails
1192 to use up all of the contents of STRING. */
1193
1194 struct expression *
1195 parse_expression (string)
1196 char *string;
1197 {
1198 register struct expression *exp;
1199 exp = parse_exp_1 (&string, 0, 0);
1200 if (*string)
1201 error ("Junk after end of expression.");
1202 return exp;
1203 }
1204 \f
1205 /* Stuff for maintaining a stack of types. Currently just used by C, but
1206 probably useful for any language which declares its types "backwards". */
1207
1208 void
1209 push_type (tp)
1210 enum type_pieces tp;
1211 {
1212 if (type_stack_depth == type_stack_size)
1213 {
1214 type_stack_size *= 2;
1215 type_stack = (union type_stack_elt *)
1216 xrealloc ((char *) type_stack, type_stack_size * sizeof (*type_stack));
1217 }
1218 type_stack[type_stack_depth++].piece = tp;
1219 }
1220
1221 void
1222 push_type_int (n)
1223 int n;
1224 {
1225 if (type_stack_depth == type_stack_size)
1226 {
1227 type_stack_size *= 2;
1228 type_stack = (union type_stack_elt *)
1229 xrealloc ((char *) type_stack, type_stack_size * sizeof (*type_stack));
1230 }
1231 type_stack[type_stack_depth++].int_val = n;
1232 }
1233
1234 enum type_pieces
1235 pop_type ()
1236 {
1237 if (type_stack_depth)
1238 return type_stack[--type_stack_depth].piece;
1239 return tp_end;
1240 }
1241
1242 int
1243 pop_type_int ()
1244 {
1245 if (type_stack_depth)
1246 return type_stack[--type_stack_depth].int_val;
1247 /* "Can't happen". */
1248 return 0;
1249 }
1250
1251 /* Pop the type stack and return the type which corresponds to FOLLOW_TYPE
1252 as modified by all the stuff on the stack. */
1253 struct type *
1254 follow_types (follow_type)
1255 struct type *follow_type;
1256 {
1257 int done = 0;
1258 int array_size;
1259 struct type *range_type;
1260
1261 while (!done)
1262 switch (pop_type ())
1263 {
1264 case tp_end:
1265 done = 1;
1266 break;
1267 case tp_pointer:
1268 follow_type = lookup_pointer_type (follow_type);
1269 break;
1270 case tp_reference:
1271 follow_type = lookup_reference_type (follow_type);
1272 break;
1273 case tp_array:
1274 array_size = pop_type_int ();
1275 /* FIXME-type-allocation: need a way to free this type when we are
1276 done with it. */
1277 range_type =
1278 create_range_type ((struct type *) NULL,
1279 builtin_type_int, 0,
1280 array_size >= 0 ? array_size - 1 : 0);
1281 follow_type =
1282 create_array_type ((struct type *) NULL,
1283 follow_type, range_type);
1284 if (array_size < 0)
1285 TYPE_ARRAY_UPPER_BOUND_TYPE (follow_type)
1286 = BOUND_CANNOT_BE_DETERMINED;
1287 break;
1288 case tp_function:
1289 /* FIXME-type-allocation: need a way to free this type when we are
1290 done with it. */
1291 follow_type = lookup_function_type (follow_type);
1292 break;
1293 }
1294 return follow_type;
1295 }
1296 \f
1297 static void build_parse PARAMS ((void));
1298 static void
1299 build_parse ()
1300 {
1301 int i;
1302
1303 msym_text_symbol_type =
1304 init_type (TYPE_CODE_FUNC, 1, 0, "<text variable, no debug info>", NULL);
1305 TYPE_TARGET_TYPE (msym_text_symbol_type) = builtin_type_int;
1306 msym_data_symbol_type =
1307 init_type (TYPE_CODE_INT, TARGET_INT_BIT / HOST_CHAR_BIT, 0,
1308 "<data variable, no debug info>", NULL);
1309 msym_unknown_symbol_type =
1310 init_type (TYPE_CODE_INT, 1, 0,
1311 "<variable (not text or data), no debug info>",
1312 NULL);
1313
1314 /* create the std_regs table */
1315
1316 num_std_regs = 0;
1317 #ifdef PC_REGNUM
1318 if (PC_REGNUM >= 0)
1319 num_std_regs++;
1320 #endif
1321 #ifdef FP_REGNUM
1322 if (FP_REGNUM >= 0)
1323 num_std_regs++;
1324 #endif
1325 #ifdef SP_REGNUM
1326 if (SP_REGNUM >= 0)
1327 num_std_regs++;
1328 #endif
1329 #ifdef PS_REGNUM
1330 if (PS_REGNUM >= 0)
1331 num_std_regs++;
1332 #endif
1333 /* create an empty table */
1334 std_regs = xmalloc ((num_std_regs + 1) * sizeof *std_regs);
1335 i = 0;
1336 /* fill it in */
1337 #ifdef PC_REGNUM
1338 std_regs[i].name = "pc";
1339 std_regs[i].regnum = PC_REGNUM;
1340 i++;
1341 #endif
1342 #ifdef FP_REGNUM
1343 std_regs[i].name = "fp";
1344 std_regs[i].regnum = FP_REGNUM;
1345 i++;
1346 #endif
1347 #ifdef SP_REGNUM
1348 std_regs[i].name = "sp";
1349 std_regs[i].regnum = SP_REGNUM;
1350 i++;
1351 #endif
1352 #ifdef PS_REGNUM
1353 std_regs[i].name = "ps";
1354 std_regs[i].regnum = PS_REGNUM;
1355 i++;
1356 #endif
1357 memset (&std_regs[i], 0, sizeof (std_regs[i]));
1358 }
1359
1360 void
1361 _initialize_parse ()
1362 {
1363 type_stack_size = 80;
1364 type_stack_depth = 0;
1365 type_stack = (union type_stack_elt *)
1366 xmalloc (type_stack_size * sizeof (*type_stack));
1367
1368 build_parse ();
1369
1370 /* FIXME - For the moment, handle types by swapping them in and out.
1371 Should be using the per-architecture data-pointer and a large
1372 struct. */
1373 register_gdbarch_swap (&msym_text_symbol_type, sizeof (msym_text_symbol_type), NULL);
1374 register_gdbarch_swap (&msym_data_symbol_type, sizeof (msym_data_symbol_type), NULL);
1375 register_gdbarch_swap (&msym_unknown_symbol_type, sizeof (msym_unknown_symbol_type), NULL);
1376
1377 register_gdbarch_swap (&num_std_regs, sizeof (std_regs), NULL);
1378 register_gdbarch_swap (&std_regs, sizeof (std_regs), NULL);
1379 register_gdbarch_swap (NULL, 0, build_parse);
1380
1381 add_show_from_set (
1382 add_set_cmd ("expressiondebug", class_maintenance, var_zinteger,
1383 (char *) &expressiondebug,
1384 "Set expression debugging.\n\
1385 When non-zero, the internal representation of expressions will be printed.",
1386 &setlist),
1387 &showlist);
1388 }
This page took 0.057328 seconds and 4 git commands to generate.