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.
6 This file is part of GDB.
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.
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.
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. */
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. */
35 #include "gdb_string.h"
39 #include "expression.h"
43 #include "parser-defs.h"
45 #include "symfile.h" /* for overlay functions */
47 /* Global variables declared in parser-defs.h (and commented there). */
48 struct expression
*expout
;
51 struct block
*expression_context_block
;
52 struct block
*innermost_block
;
54 union type_stack_elt
*type_stack
;
55 int type_stack_depth
, type_stack_size
;
61 static int expressiondebug
= 0;
63 extern int hp_som_som_object_present
;
66 free_funcalls
PARAMS ((void));
69 prefixify_expression
PARAMS ((struct expression
*));
72 prefixify_subexp
PARAMS ((struct expression
*, struct expression
*, int, int));
74 void _initialize_parse
PARAMS ((void));
76 /* Data structure for saving values of arglist_len for function calls whose
77 arguments contain other function calls. */
85 static struct funcall
*funcall_chain
;
87 /* Assign machine-independent names to certain registers
88 (unless overridden by the REGISTER_NAMES table) */
90 unsigned num_std_regs
= 0;
91 struct std_regs
*std_regs
;
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. */
98 target_map_name_to_register (str
, len
)
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
);
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
))
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
))
126 return std_regs
[i
].regnum
;
132 /* Begin counting arguments for a function call,
133 saving the data about any containing call. */
138 register struct funcall
*new;
140 new = (struct funcall
*) xmalloc (sizeof (struct funcall
));
141 new->next
= funcall_chain
;
142 new->arglist_len
= arglist_len
;
147 /* Return the number of arguments in a function call just terminated,
148 and restore the data for the containing function call. */
153 register int val
= arglist_len
;
154 register struct funcall
*call
= funcall_chain
;
155 funcall_chain
= call
->next
;
156 arglist_len
= call
->arglist_len
;
161 /* Free everything in the funcall chain.
162 Used when there is an error inside parsing. */
167 register struct funcall
*call
, *next
;
169 for (call
= funcall_chain
; call
; call
= next
)
176 /* This page contains the functions for adding data to the struct expression
177 being constructed. */
179 /* Add one element to the end of the expression. */
181 /* To avoid a bug in the Sun 4 compiler, we pass things that can fit into
182 a register through here */
185 write_exp_elt (expelt
)
186 union exp_element expelt
;
188 if (expout_ptr
>= expout_size
)
191 expout
= (struct expression
*)
192 xrealloc ((char *) expout
, sizeof (struct expression
)
193 + EXP_ELEM_TO_BYTES (expout_size
));
195 expout
->elts
[expout_ptr
++] = expelt
;
199 write_exp_elt_opcode (expelt
)
200 enum exp_opcode expelt
;
202 union exp_element tmp
;
210 write_exp_elt_sym (expelt
)
211 struct symbol
*expelt
;
213 union exp_element tmp
;
221 write_exp_elt_block (b
)
224 union exp_element tmp
;
230 write_exp_elt_longcst (expelt
)
233 union exp_element tmp
;
235 tmp
.longconst
= expelt
;
241 write_exp_elt_dblcst (expelt
)
244 union exp_element tmp
;
246 tmp
.doubleconst
= expelt
;
252 write_exp_elt_type (expelt
)
255 union exp_element tmp
;
263 write_exp_elt_intern (expelt
)
264 struct internalvar
*expelt
;
266 union exp_element tmp
;
268 tmp
.internalvar
= expelt
;
273 /* Add a string constant to the end of the expression.
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.
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
295 write_exp_string (str
)
298 register int len
= str
.length
;
300 register char *strdata
;
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). */
307 lenelt
= 2 + BYTES_TO_EXP_ELEM (len
+ 1);
309 /* Ensure that we have enough available expression elements to store
312 if ((expout_ptr
+ lenelt
) >= expout_size
)
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
)));
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
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
);
333 /* Add a bitstring constant to the end of the expression.
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. */
345 write_exp_bitstring (str
)
348 register int bits
= str
.length
; /* length in bits */
349 register int len
= (bits
+ HOST_CHAR_BIT
- 1) / HOST_CHAR_BIT
;
351 register char *strdata
;
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. */
357 lenelt
= 2 + BYTES_TO_EXP_ELEM (len
);
359 /* Ensure that we have enough available expression elements to store
362 if ((expout_ptr
+ lenelt
) >= expout_size
)
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
)));
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. */
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
);
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. */
388 static struct type
*msym_text_symbol_type
;
389 static struct type
*msym_data_symbol_type
;
390 static struct type
*msym_unknown_symbol_type
;
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
;
400 write_exp_elt_opcode (OP_LONG
);
401 write_exp_elt_type (lookup_pointer_type (builtin_type_void
));
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
);
408 write_exp_elt_opcode (OP_LONG
);
410 write_exp_elt_opcode (UNOP_MEMVAL
);
411 switch (msymbol
->type
)
415 case mst_solib_trampoline
:
416 write_exp_elt_type (msym_text_symbol_type
);
423 write_exp_elt_type (msym_data_symbol_type
);
427 write_exp_elt_type (msym_unknown_symbol_type
);
430 write_exp_elt_opcode (UNOP_MEMVAL
);
433 /* Recognize tokens that start with '$'. These include:
435 $regname A native register name or a "standard
438 $variable A convenience variable with a name chosen
441 $digits Value history with index <digits>, starting
442 from the first value which has index 1.
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.
449 $ | $0 | $$0 The last value in the value history.
451 $$ An abbreviation for the second to the last
452 value in the value history, I.E. $$1
457 write_dollar_variable (str
)
460 /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
461 and $$digits (equivalent to $<-digits> if you could type that). */
463 struct symbol
*sym
= NULL
;
464 struct minimal_symbol
*msym
= NULL
;
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] == '$')
477 /* Just dollars (one or two) */
481 /* Is the rest of the token digits? */
482 for (; i
< str
.length
; i
++)
483 if (!(str
.ptr
[i
] >= '0' && str
.ptr
[i
] <= '9'))
487 i
= atoi (str
.ptr
+ 1 + negate
);
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);
497 goto handle_register
;
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. */
503 sym
= lookup_symbol (copy_name (str
), (struct block
*) NULL
,
504 VAR_NAMESPACE
, (int *) NULL
, (struct symtab
**) NULL
);
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
);
513 msym
= lookup_minimal_symbol (copy_name (str
), NULL
, NULL
);
516 write_exp_msymbol (msym
,
517 lookup_function_type (builtin_type_int
),
522 /* Any other names starting in $ are debugger internal variables. */
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
);
529 write_exp_elt_opcode (OP_LAST
);
530 write_exp_elt_longcst ((LONGEST
) i
);
531 write_exp_elt_opcode (OP_LAST
);
534 write_exp_elt_opcode (OP_REGISTER
);
535 write_exp_elt_longcst (i
);
536 write_exp_elt_opcode (OP_REGISTER
);
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.
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.
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
560 (Argument LEN is currently unused. 1997-08-27)
562 Callers must free memory allocated for the output string TOKEN. */
564 static const char coloncolon
[2] =
568 parse_nested_classes_for_hpacc (name
, len
, token
, class_prefix
, argptr
)
575 /* Comment below comes from decode_line_1 which has very similar
576 code, which is called for "break" command parsing. */
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).
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.
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. */
602 struct symbol
*sym_class
= NULL
;
603 struct symbol
*sym_var
= NULL
;
606 int colons_found
= 0;
611 /* Check for HP-compiled executable -- in other cases
612 return NULL, and caller must default to standard GDB
615 if (!hp_som_som_object_present
)
616 return (struct symbol
*) NULL
;
620 /* Skip over whitespace and possible global "::" */
621 while (*p
&& (*p
== ' ' || *p
== '\t'))
623 if (p
[0] == ':' && p
[1] == ':')
625 while (*p
&& (*p
== ' ' || *p
== '\t'))
630 /* Get to the end of the next namespace or class spec. */
631 /* If we're looking at some non-token, fail immediately */
633 if (!(isalpha (*p
) || *p
== '$' || *p
== '_'))
634 return (struct symbol
*) NULL
;
636 while (*p
&& (isalnum (*p
) || *p
== '$' || *p
== '_'))
641 /* If we have the start of a template specification,
642 scan right ahead to its end */
643 q
= find_template_name_end (p
);
650 /* Skip over "::" and whitespace for next time around */
651 while (*p
&& (*p
== ' ' || *p
== '\t'))
653 if (p
[0] == ':' && p
[1] == ':')
655 while (*p
&& (*p
== ' ' || *p
== '\t'))
658 /* Done with tokens? */
659 if (!*p
|| !(isalpha (*p
) || *p
== '$' || *p
== '_'))
662 tmp
= (char *) alloca (prefix_len
+ end
- start
+ 3);
665 memcpy (tmp
, prefix
, prefix_len
);
666 memcpy (tmp
+ prefix_len
, coloncolon
, 2);
667 memcpy (tmp
+ prefix_len
+ 2, start
, end
- start
);
668 tmp
[prefix_len
+ 2 + end
- start
] = '\000';
672 memcpy (tmp
, start
, end
- start
);
673 tmp
[end
- start
] = '\000';
677 prefix_len
= strlen (prefix
);
679 /* See if the prefix we have now is something we know about */
683 /* More tokens to process, so this must be a class/namespace */
684 sym_class
= lookup_symbol (prefix
, 0, STRUCT_NAMESPACE
,
685 0, (struct symtab
**) NULL
);
689 /* No more tokens, so try as a variable first */
690 sym_var
= lookup_symbol (prefix
, 0, VAR_NAMESPACE
,
691 0, (struct symtab
**) NULL
);
692 /* If failed, try as class/namespace */
694 sym_class
= lookup_symbol (prefix
, 0, STRUCT_NAMESPACE
,
695 0, (struct symtab
**) NULL
);
700 (t
= check_typedef (SYMBOL_TYPE (sym_class
)),
701 (TYPE_CODE (t
) == TYPE_CODE_STRUCT
702 || TYPE_CODE (t
) == TYPE_CODE_UNION
))))
704 /* We found a valid token */
705 *token
= (char *) xmalloc (prefix_len
+ 1);
706 memcpy (*token
, prefix
, prefix_len
);
707 (*token
)[prefix_len
] = '\000';
711 /* No variable or class/namespace found, no more tokens */
713 return (struct symbol
*) NULL
;
716 /* Out of loop, so we must have found a valid token */
723 *argptr
= done
? p
: end
;
725 return sym_var
? sym_var
: sym_class
; /* found */
729 find_template_name_end (p
)
733 int just_seen_right
= 0;
734 int just_seen_colon
= 0;
735 int just_seen_space
= 0;
737 if (!p
|| (*p
!= '<'))
748 /* In future, may want to allow these?? */
751 depth
++; /* start nested template */
752 if (just_seen_colon
|| just_seen_right
|| just_seen_space
)
753 return 0; /* but not after : or :: or > or space */
756 if (just_seen_colon
|| just_seen_right
)
757 return 0; /* end a (nested?) template */
758 just_seen_right
= 1; /* but not after : or :: */
759 if (--depth
== 0) /* also disallow >>, insist on > > */
760 return ++p
; /* if outermost ended, return */
763 if (just_seen_space
|| (just_seen_colon
> 1))
764 return 0; /* nested class spec coming up */
765 just_seen_colon
++; /* we allow :: but not :::: */
770 if (!((*p
>= 'a' && *p
<= 'z') || /* allow token chars */
771 (*p
>= 'A' && *p
<= 'Z') ||
772 (*p
>= '0' && *p
<= '9') ||
773 (*p
== '_') || (*p
== ',') || /* commas for template args */
774 (*p
== '&') || (*p
== '*') || /* pointer and ref types */
775 (*p
== '(') || (*p
== ')') || /* function types */
776 (*p
== '[') || (*p
== ']'))) /* array types */
791 /* Return a null-terminated temporary copy of the name
792 of a string token. */
798 memcpy (namecopy
, token
.ptr
, token
.length
);
799 namecopy
[token
.length
] = 0;
803 /* Reverse an expression from suffix form (in which it is constructed)
804 to prefix form (in which we can conveniently print or execute it). */
807 prefixify_expression (expr
)
808 register struct expression
*expr
;
811 sizeof (struct expression
) + EXP_ELEM_TO_BYTES (expr
->nelts
);
812 register struct expression
*temp
;
813 register int inpos
= expr
->nelts
, outpos
= 0;
815 temp
= (struct expression
*) alloca (len
);
817 /* Copy the original expression into temp. */
818 memcpy (temp
, expr
, len
);
820 prefixify_subexp (temp
, expr
, inpos
, outpos
);
823 /* Return the number of exp_elements in the subexpression of EXPR
824 whose last exp_element is at index ENDPOS - 1 in EXPR. */
827 length_of_subexp (expr
, endpos
)
828 register struct expression
*expr
;
831 register int oplen
= 1;
832 register int args
= 0;
836 error ("?error in length_of_subexp");
838 i
= (int) expr
->elts
[endpos
- 1].opcode
;
844 oplen
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
845 oplen
= 5 + BYTES_TO_EXP_ELEM (oplen
+ 1);
868 case OP_F77_UNDETERMINED_ARGLIST
:
870 args
= 1 + longest_to_int (expr
->elts
[endpos
- 2].longconst
);
898 case STRUCTOP_STRUCT
:
906 oplen
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
907 oplen
= 4 + BYTES_TO_EXP_ELEM (oplen
+ 1);
911 oplen
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
912 oplen
= (oplen
+ HOST_CHAR_BIT
- 1) / HOST_CHAR_BIT
;
913 oplen
= 4 + BYTES_TO_EXP_ELEM (oplen
);
918 args
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
919 args
-= longest_to_int (expr
->elts
[endpos
- 3].longconst
);
925 case TERNOP_SLICE_COUNT
:
930 case MULTI_SUBSCRIPT
:
932 args
= 1 + longest_to_int (expr
->elts
[endpos
- 2].longconst
);
935 case BINOP_ASSIGN_MODIFY
:
946 args
= 1 + (i
< (int) BINOP_END
);
951 oplen
+= length_of_subexp (expr
, endpos
- oplen
);
958 /* Copy the subexpression ending just before index INEND in INEXPR
959 into OUTEXPR, starting at index OUTBEG.
960 In the process, convert it from suffix to prefix form. */
963 prefixify_subexp (inexpr
, outexpr
, inend
, outbeg
)
964 register struct expression
*inexpr
;
965 struct expression
*outexpr
;
969 register int oplen
= 1;
970 register int args
= 0;
973 enum exp_opcode opcode
;
975 /* Compute how long the last operation is (in OPLEN),
976 and also how many preceding subexpressions serve as
977 arguments for it (in ARGS). */
979 opcode
= inexpr
->elts
[inend
- 1].opcode
;
984 oplen
= longest_to_int (inexpr
->elts
[inend
- 2].longconst
);
985 oplen
= 5 + BYTES_TO_EXP_ELEM (oplen
+ 1);
1008 case OP_F77_UNDETERMINED_ARGLIST
:
1010 args
= 1 + longest_to_int (inexpr
->elts
[inend
- 2].longconst
);
1036 case STRUCTOP_STRUCT
:
1045 oplen
= longest_to_int (inexpr
->elts
[inend
- 2].longconst
);
1046 oplen
= 4 + BYTES_TO_EXP_ELEM (oplen
+ 1);
1050 oplen
= longest_to_int (inexpr
->elts
[inend
- 2].longconst
);
1051 oplen
= (oplen
+ HOST_CHAR_BIT
- 1) / HOST_CHAR_BIT
;
1052 oplen
= 4 + BYTES_TO_EXP_ELEM (oplen
);
1057 args
= longest_to_int (inexpr
->elts
[inend
- 2].longconst
);
1058 args
-= longest_to_int (inexpr
->elts
[inend
- 3].longconst
);
1064 case TERNOP_SLICE_COUNT
:
1068 case BINOP_ASSIGN_MODIFY
:
1074 case MULTI_SUBSCRIPT
:
1076 args
= 1 + longest_to_int (inexpr
->elts
[inend
- 2].longconst
);
1085 args
= 1 + ((int) opcode
< (int) BINOP_END
);
1088 /* Copy the final operator itself, from the end of the input
1089 to the beginning of the output. */
1091 memcpy (&outexpr
->elts
[outbeg
], &inexpr
->elts
[inend
],
1092 EXP_ELEM_TO_BYTES (oplen
));
1095 /* Find the lengths of the arg subexpressions. */
1096 arglens
= (int *) alloca (args
* sizeof (int));
1097 for (i
= args
- 1; i
>= 0; i
--)
1099 oplen
= length_of_subexp (inexpr
, inend
);
1104 /* Now copy each subexpression, preserving the order of
1105 the subexpressions, but prefixifying each one.
1106 In this loop, inend starts at the beginning of
1107 the expression this level is working on
1108 and marches forward over the arguments.
1109 outbeg does similarly in the output. */
1110 for (i
= 0; i
< args
; i
++)
1114 prefixify_subexp (inexpr
, outexpr
, inend
, outbeg
);
1119 /* This page contains the two entry points to this file. */
1121 /* Read an expression from the string *STRINGPTR points to,
1122 parse it, and return a pointer to a struct expression that we malloc.
1123 Use block BLOCK as the lexical context for variable names;
1124 if BLOCK is zero, use the block of the selected stack frame.
1125 Meanwhile, advance *STRINGPTR to point after the expression,
1126 at the first nonwhite character that is not part of the expression
1127 (possibly a null character).
1129 If COMMA is nonzero, stop if a comma is reached. */
1132 parse_exp_1 (stringptr
, block
, comma
)
1134 struct block
*block
;
1137 struct cleanup
*old_chain
;
1139 lexptr
= *stringptr
;
1142 type_stack_depth
= 0;
1144 comma_terminates
= comma
;
1146 if (lexptr
== 0 || *lexptr
== 0)
1147 error_no_arg ("expression to compute");
1149 old_chain
= make_cleanup ((make_cleanup_func
) free_funcalls
, 0);
1152 expression_context_block
= block
? block
: get_selected_block ();
1154 namecopy
= (char *) alloca (strlen (lexptr
) + 1);
1157 expout
= (struct expression
*)
1158 xmalloc (sizeof (struct expression
) + EXP_ELEM_TO_BYTES (expout_size
));
1159 expout
->language_defn
= current_language
;
1160 make_cleanup ((make_cleanup_func
) free_current_contents
, &expout
);
1162 if (current_language
->la_parser ())
1163 current_language
->la_error (NULL
);
1165 discard_cleanups (old_chain
);
1167 /* Record the actual number of expression elements, and then
1168 reallocate the expression memory so that we free up any
1171 expout
->nelts
= expout_ptr
;
1172 expout
= (struct expression
*)
1173 xrealloc ((char *) expout
,
1174 sizeof (struct expression
) + EXP_ELEM_TO_BYTES (expout_ptr
));;
1176 /* Convert expression from postfix form as generated by yacc
1177 parser, to a prefix form. */
1179 if (expressiondebug
)
1180 dump_prefix_expression (expout
, gdb_stdlog
,
1181 "before conversion to prefix form");
1183 prefixify_expression (expout
);
1185 if (expressiondebug
)
1186 dump_postfix_expression (expout
, gdb_stdlog
,
1187 "after conversion to prefix form");
1189 *stringptr
= lexptr
;
1193 /* Parse STRING as an expression, and complain if this fails
1194 to use up all of the contents of STRING. */
1197 parse_expression (string
)
1200 register struct expression
*exp
;
1201 exp
= parse_exp_1 (&string
, 0, 0);
1203 error ("Junk after end of expression.");
1207 /* Stuff for maintaining a stack of types. Currently just used by C, but
1208 probably useful for any language which declares its types "backwards". */
1212 enum type_pieces tp
;
1214 if (type_stack_depth
== type_stack_size
)
1216 type_stack_size
*= 2;
1217 type_stack
= (union type_stack_elt
*)
1218 xrealloc ((char *) type_stack
, type_stack_size
* sizeof (*type_stack
));
1220 type_stack
[type_stack_depth
++].piece
= tp
;
1227 if (type_stack_depth
== type_stack_size
)
1229 type_stack_size
*= 2;
1230 type_stack
= (union type_stack_elt
*)
1231 xrealloc ((char *) type_stack
, type_stack_size
* sizeof (*type_stack
));
1233 type_stack
[type_stack_depth
++].int_val
= n
;
1239 if (type_stack_depth
)
1240 return type_stack
[--type_stack_depth
].piece
;
1247 if (type_stack_depth
)
1248 return type_stack
[--type_stack_depth
].int_val
;
1249 /* "Can't happen". */
1253 /* Pop the type stack and return the type which corresponds to FOLLOW_TYPE
1254 as modified by all the stuff on the stack. */
1256 follow_types (follow_type
)
1257 struct type
*follow_type
;
1261 struct type
*range_type
;
1264 switch (pop_type ())
1270 follow_type
= lookup_pointer_type (follow_type
);
1273 follow_type
= lookup_reference_type (follow_type
);
1276 array_size
= pop_type_int ();
1277 /* FIXME-type-allocation: need a way to free this type when we are
1280 create_range_type ((struct type
*) NULL
,
1281 builtin_type_int
, 0,
1282 array_size
>= 0 ? array_size
- 1 : 0);
1284 create_array_type ((struct type
*) NULL
,
1285 follow_type
, range_type
);
1287 TYPE_ARRAY_UPPER_BOUND_TYPE (follow_type
)
1288 = BOUND_CANNOT_BE_DETERMINED
;
1291 /* FIXME-type-allocation: need a way to free this type when we are
1293 follow_type
= lookup_function_type (follow_type
);
1299 static void build_parse
PARAMS ((void));
1305 msym_text_symbol_type
=
1306 init_type (TYPE_CODE_FUNC
, 1, 0, "<text variable, no debug info>", NULL
);
1307 TYPE_TARGET_TYPE (msym_text_symbol_type
) = builtin_type_int
;
1308 msym_data_symbol_type
=
1309 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ HOST_CHAR_BIT
, 0,
1310 "<data variable, no debug info>", NULL
);
1311 msym_unknown_symbol_type
=
1312 init_type (TYPE_CODE_INT
, 1, 0,
1313 "<variable (not text or data), no debug info>",
1316 /* create the std_regs table */
1335 /* create an empty table */
1336 std_regs
= xmalloc ((num_std_regs
+ 1) * sizeof *std_regs
);
1340 std_regs
[i
].name
= "pc";
1341 std_regs
[i
].regnum
= PC_REGNUM
;
1345 std_regs
[i
].name
= "fp";
1346 std_regs
[i
].regnum
= FP_REGNUM
;
1350 std_regs
[i
].name
= "sp";
1351 std_regs
[i
].regnum
= SP_REGNUM
;
1355 std_regs
[i
].name
= "ps";
1356 std_regs
[i
].regnum
= PS_REGNUM
;
1359 memset (&std_regs
[i
], 0, sizeof (std_regs
[i
]));
1363 _initialize_parse ()
1365 type_stack_size
= 80;
1366 type_stack_depth
= 0;
1367 type_stack
= (union type_stack_elt
*)
1368 xmalloc (type_stack_size
* sizeof (*type_stack
));
1372 /* FIXME - For the moment, handle types by swapping them in and out.
1373 Should be using the per-architecture data-pointer and a large
1375 register_gdbarch_swap (&msym_text_symbol_type
, sizeof (msym_text_symbol_type
), NULL
);
1376 register_gdbarch_swap (&msym_data_symbol_type
, sizeof (msym_data_symbol_type
), NULL
);
1377 register_gdbarch_swap (&msym_unknown_symbol_type
, sizeof (msym_unknown_symbol_type
), NULL
);
1379 register_gdbarch_swap (&num_std_regs
, sizeof (std_regs
), NULL
);
1380 register_gdbarch_swap (&std_regs
, sizeof (std_regs
), NULL
);
1381 register_gdbarch_swap (NULL
, 0, build_parse
);
1384 add_set_cmd ("expressiondebug", class_maintenance
, var_zinteger
,
1385 (char *) &expressiondebug
,
1386 "Set expression debugging.\n\
1387 When non-zero, the internal representation of expressions will be printed.",