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