1 /* Parse expressions for GDB.
2 Copyright 1986, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
3 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
4 Modified from expread.y by the Department of Computer Science at the
5 State University of New York at Buffalo, 1991.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
24 /* Parse an expression from text in a string,
25 and return the result as a struct expression pointer.
26 That structure contains arithmetic operations in reverse polish,
27 with constants represented by operations that are followed by special data.
28 See expression.h for the details of the format.
29 What is important here is that it can be built up sequentially
30 during the process of parsing; the lower levels of the tree always
31 come first in the result. */
36 #include "gdb_string.h"
40 #include "expression.h"
44 #include "parser-defs.h"
46 #include "symfile.h" /* for overlay functions */
47 #include "inferior.h" /* for NUM_PSEUDO_REGS. NOTE: replace
48 with "gdbarch.h" when appropriate. */
50 #include "builtin-regs.h"
51 #include "gdb_assert.h"
54 /* Symbols which architectures can redefine. */
56 /* Some systems have routines whose names start with `$'. Giving this
57 macro a non-zero value tells GDB's expression parser to check for
58 such routines when parsing tokens that begin with `$'.
60 On HP-UX, certain system routines (millicode) have names beginning
61 with `$' or `$$'. For example, `$$dyncall' is a millicode routine
62 that handles inter-space procedure calls on PA-RISC. */
63 #ifndef SYMBOLS_CAN_START_WITH_DOLLAR
64 #define SYMBOLS_CAN_START_WITH_DOLLAR (0)
69 /* Global variables declared in parser-defs.h (and commented there). */
70 struct expression
*expout
;
73 struct block
*expression_context_block
;
74 struct block
*innermost_block
;
76 union type_stack_elt
*type_stack
;
77 int type_stack_depth
, type_stack_size
;
83 static int expressiondebug
= 0;
85 extern int hp_som_som_object_present
;
87 static void free_funcalls (void *ignore
);
89 static void prefixify_expression (struct expression
*);
92 prefixify_subexp (struct expression
*, struct expression
*, int, int);
94 void _initialize_parse (void);
96 /* Data structure for saving values of arglist_len for function calls whose
97 arguments contain other function calls. */
101 struct funcall
*next
;
105 static struct funcall
*funcall_chain
;
107 /* Assign machine-independent names to certain registers
108 (unless overridden by the REGISTER_NAMES table) */
110 unsigned num_std_regs
= 0;
111 struct std_regs
*std_regs
;
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. */
118 target_map_name_to_register (char *str
, int len
)
122 /* Search register name space. */
123 for (i
= 0; i
< NUM_REGS
+ NUM_PSEUDO_REGS
; i
++)
124 if (REGISTER_NAME (i
) && len
== strlen (REGISTER_NAME (i
))
125 && STREQN (str
, REGISTER_NAME (i
), len
))
130 /* Try standard aliases. */
131 for (i
= 0; i
< num_std_regs
; i
++)
132 if (std_regs
[i
].name
&& len
== strlen (std_regs
[i
].name
)
133 && STREQN (str
, std_regs
[i
].name
, len
))
135 return std_regs
[i
].regnum
;
138 /* Try builtin registers. */
139 i
= builtin_reg_map_name_to_regnum (str
, len
);
142 gdb_assert (i
>= NUM_REGS
+ NUM_PSEUDO_REGS
);
149 /* Begin counting arguments for a function call,
150 saving the data about any containing call. */
155 register struct funcall
*new;
157 new = (struct funcall
*) xmalloc (sizeof (struct funcall
));
158 new->next
= funcall_chain
;
159 new->arglist_len
= arglist_len
;
164 /* Return the number of arguments in a function call just terminated,
165 and restore the data for the containing function call. */
170 register int val
= arglist_len
;
171 register struct funcall
*call
= funcall_chain
;
172 funcall_chain
= call
->next
;
173 arglist_len
= call
->arglist_len
;
178 /* Free everything in the funcall chain.
179 Used when there is an error inside parsing. */
182 free_funcalls (void *ignore
)
184 register struct funcall
*call
, *next
;
186 for (call
= funcall_chain
; call
; call
= next
)
193 /* This page contains the functions for adding data to the struct expression
194 being constructed. */
196 /* Add one element to the end of the expression. */
198 /* To avoid a bug in the Sun 4 compiler, we pass things that can fit into
199 a register through here */
202 write_exp_elt (union exp_element expelt
)
204 if (expout_ptr
>= expout_size
)
207 expout
= (struct expression
*)
208 xrealloc ((char *) expout
, sizeof (struct expression
)
209 + EXP_ELEM_TO_BYTES (expout_size
));
211 expout
->elts
[expout_ptr
++] = expelt
;
215 write_exp_elt_opcode (enum exp_opcode expelt
)
217 union exp_element tmp
;
225 write_exp_elt_sym (struct symbol
*expelt
)
227 union exp_element tmp
;
235 write_exp_elt_block (struct block
*b
)
237 union exp_element tmp
;
243 write_exp_elt_longcst (LONGEST expelt
)
245 union exp_element tmp
;
247 tmp
.longconst
= expelt
;
253 write_exp_elt_dblcst (DOUBLEST expelt
)
255 union exp_element tmp
;
257 tmp
.doubleconst
= expelt
;
263 write_exp_elt_type (struct type
*expelt
)
265 union exp_element tmp
;
273 write_exp_elt_intern (struct internalvar
*expelt
)
275 union exp_element tmp
;
277 tmp
.internalvar
= expelt
;
282 /* Add a string constant to the end of the expression.
284 String constants are stored by first writing an expression element
285 that contains the length of the string, then stuffing the string
286 constant itself into however many expression elements are needed
287 to hold it, and then writing another expression element that contains
288 the length of the string. I.E. an expression element at each end of
289 the string records the string length, so you can skip over the
290 expression elements containing the actual string bytes from either
291 end of the string. Note that this also allows gdb to handle
292 strings with embedded null bytes, as is required for some languages.
294 Don't be fooled by the fact that the string is null byte terminated,
295 this is strictly for the convenience of debugging gdb itself. Gdb
296 Gdb does not depend up the string being null terminated, since the
297 actual length is recorded in expression elements at each end of the
298 string. The null byte is taken into consideration when computing how
299 many expression elements are required to hold the string constant, of
304 write_exp_string (struct stoken str
)
306 register int len
= str
.length
;
308 register char *strdata
;
310 /* Compute the number of expression elements required to hold the string
311 (including a null byte terminator), along with one expression element
312 at each end to record the actual string length (not including the
313 null byte terminator). */
315 lenelt
= 2 + BYTES_TO_EXP_ELEM (len
+ 1);
317 /* Ensure that we have enough available expression elements to store
320 if ((expout_ptr
+ lenelt
) >= expout_size
)
322 expout_size
= max (expout_size
* 2, expout_ptr
+ lenelt
+ 10);
323 expout
= (struct expression
*)
324 xrealloc ((char *) expout
, (sizeof (struct expression
)
325 + EXP_ELEM_TO_BYTES (expout_size
)));
328 /* Write the leading length expression element (which advances the current
329 expression element index), then write the string constant followed by a
330 terminating null byte, and then write the trailing length expression
333 write_exp_elt_longcst ((LONGEST
) len
);
334 strdata
= (char *) &expout
->elts
[expout_ptr
];
335 memcpy (strdata
, str
.ptr
, len
);
336 *(strdata
+ len
) = '\0';
337 expout_ptr
+= lenelt
- 2;
338 write_exp_elt_longcst ((LONGEST
) len
);
341 /* Add a bitstring constant to the end of the expression.
343 Bitstring constants are stored by first writing an expression element
344 that contains the length of the bitstring (in bits), then stuffing the
345 bitstring constant itself into however many expression elements are
346 needed to hold it, and then writing another expression element that
347 contains the length of the bitstring. I.E. an expression element at
348 each end of the bitstring records the bitstring length, so you can skip
349 over the expression elements containing the actual bitstring bytes from
350 either end of the bitstring. */
353 write_exp_bitstring (struct stoken str
)
355 register int bits
= str
.length
; /* length in bits */
356 register int len
= (bits
+ HOST_CHAR_BIT
- 1) / HOST_CHAR_BIT
;
358 register char *strdata
;
360 /* Compute the number of expression elements required to hold the bitstring,
361 along with one expression element at each end to record the actual
362 bitstring length in bits. */
364 lenelt
= 2 + BYTES_TO_EXP_ELEM (len
);
366 /* Ensure that we have enough available expression elements to store
369 if ((expout_ptr
+ lenelt
) >= expout_size
)
371 expout_size
= max (expout_size
* 2, expout_ptr
+ lenelt
+ 10);
372 expout
= (struct expression
*)
373 xrealloc ((char *) expout
, (sizeof (struct expression
)
374 + EXP_ELEM_TO_BYTES (expout_size
)));
377 /* Write the leading length expression element (which advances the current
378 expression element index), then write the bitstring constant, and then
379 write the trailing length expression element. */
381 write_exp_elt_longcst ((LONGEST
) bits
);
382 strdata
= (char *) &expout
->elts
[expout_ptr
];
383 memcpy (strdata
, str
.ptr
, len
);
384 expout_ptr
+= lenelt
- 2;
385 write_exp_elt_longcst ((LONGEST
) bits
);
388 /* Add the appropriate elements for a minimal symbol to the end of
389 the expression. The rationale behind passing in text_symbol_type and
390 data_symbol_type was so that Modula-2 could pass in WORD for
391 data_symbol_type. Perhaps it still is useful to have those types vary
392 based on the language, but they no longer have names like "int", so
393 the initial rationale is gone. */
395 static struct type
*msym_text_symbol_type
;
396 static struct type
*msym_data_symbol_type
;
397 static struct type
*msym_unknown_symbol_type
;
400 write_exp_msymbol (struct minimal_symbol
*msymbol
,
401 struct type
*text_symbol_type
,
402 struct type
*data_symbol_type
)
406 write_exp_elt_opcode (OP_LONG
);
407 /* Let's make the type big enough to hold a 64-bit address. */
408 write_exp_elt_type (builtin_type_CORE_ADDR
);
410 addr
= SYMBOL_VALUE_ADDRESS (msymbol
);
411 if (overlay_debugging
)
412 addr
= symbol_overlayed_address (addr
, SYMBOL_BFD_SECTION (msymbol
));
413 write_exp_elt_longcst ((LONGEST
) addr
);
415 write_exp_elt_opcode (OP_LONG
);
417 write_exp_elt_opcode (UNOP_MEMVAL
);
418 switch (msymbol
->type
)
422 case mst_solib_trampoline
:
423 write_exp_elt_type (msym_text_symbol_type
);
430 write_exp_elt_type (msym_data_symbol_type
);
434 write_exp_elt_type (msym_unknown_symbol_type
);
437 write_exp_elt_opcode (UNOP_MEMVAL
);
440 /* Recognize tokens that start with '$'. These include:
442 $regname A native register name or a "standard
445 $variable A convenience variable with a name chosen
448 $digits Value history with index <digits>, starting
449 from the first value which has index 1.
451 $$digits Value history with index <digits> relative
452 to the last value. I.E. $$0 is the last
453 value, $$1 is the one previous to that, $$2
454 is the one previous to $$1, etc.
456 $ | $0 | $$0 The last value in the value history.
458 $$ An abbreviation for the second to the last
459 value in the value history, I.E. $$1
464 write_dollar_variable (struct stoken str
)
466 /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
467 and $$digits (equivalent to $<-digits> if you could type that). */
471 /* Double dollar means negate the number and add -1 as well.
472 Thus $$ alone means -1. */
473 if (str
.length
>= 2 && str
.ptr
[1] == '$')
480 /* Just dollars (one or two) */
484 /* Is the rest of the token digits? */
485 for (; i
< str
.length
; i
++)
486 if (!(str
.ptr
[i
] >= '0' && str
.ptr
[i
] <= '9'))
490 i
= atoi (str
.ptr
+ 1 + negate
);
496 /* Handle tokens that refer to machine registers:
497 $ followed by a register name. */
498 i
= target_map_name_to_register (str
.ptr
+ 1, str
.length
- 1);
500 goto handle_register
;
502 if (SYMBOLS_CAN_START_WITH_DOLLAR
)
504 struct symbol
*sym
= NULL
;
505 struct minimal_symbol
*msym
= NULL
;
507 /* On HP-UX, certain system routines (millicode) have names beginning
508 with $ or $$, e.g. $$dyncall, which handles inter-space procedure
509 calls on PA-RISC. Check for those, first. */
511 /* This code is not enabled on non HP-UX systems, since worst case
512 symbol table lookup performance is awful, to put it mildly. */
514 sym
= lookup_symbol (copy_name (str
), (struct block
*) NULL
,
515 VAR_NAMESPACE
, (int *) NULL
, (struct symtab
**) NULL
);
518 write_exp_elt_opcode (OP_VAR_VALUE
);
519 write_exp_elt_block (block_found
); /* set by lookup_symbol */
520 write_exp_elt_sym (sym
);
521 write_exp_elt_opcode (OP_VAR_VALUE
);
524 msym
= lookup_minimal_symbol (copy_name (str
), NULL
, NULL
);
527 write_exp_msymbol (msym
,
528 lookup_function_type (builtin_type_int
),
534 /* Any other names starting in $ are debugger internal variables. */
536 write_exp_elt_opcode (OP_INTERNALVAR
);
537 write_exp_elt_intern (lookup_internalvar (copy_name (str
) + 1));
538 write_exp_elt_opcode (OP_INTERNALVAR
);
541 write_exp_elt_opcode (OP_LAST
);
542 write_exp_elt_longcst ((LONGEST
) i
);
543 write_exp_elt_opcode (OP_LAST
);
546 write_exp_elt_opcode (OP_REGISTER
);
547 write_exp_elt_longcst (i
);
548 write_exp_elt_opcode (OP_REGISTER
);
553 /* Parse a string that is possibly a namespace / nested class
554 specification, i.e., something of the form A::B::C::x. Input
555 (NAME) is the entire string; LEN is the current valid length; the
556 output is a string, TOKEN, which points to the largest recognized
557 prefix which is a series of namespaces or classes. CLASS_PREFIX is
558 another output, which records whether a nested class spec was
559 recognized (= 1) or a fully qualified variable name was found (=
560 0). ARGPTR is side-effected (if non-NULL) to point to beyond the
561 string recognized and consumed by this routine.
563 The return value is a pointer to the symbol for the base class or
564 variable if found, or NULL if not found. Callers must check this
565 first -- if NULL, the outputs may not be correct.
567 This function is used c-exp.y. This is used specifically to get
568 around HP aCC (and possibly other compilers), which insists on
569 generating names with embedded colons for namespace or nested class
572 (Argument LEN is currently unused. 1997-08-27)
574 Callers must free memory allocated for the output string TOKEN. */
576 static const char coloncolon
[2] =
580 parse_nested_classes_for_hpacc (char *name
, int len
, char **token
,
581 int *class_prefix
, char **argptr
)
583 /* Comment below comes from decode_line_1 which has very similar
584 code, which is called for "break" command parsing. */
586 /* We have what looks like a class or namespace
587 scope specification (A::B), possibly with many
588 levels of namespaces or classes (A::B::C::D).
590 Some versions of the HP ANSI C++ compiler (as also possibly
591 other compilers) generate class/function/member names with
592 embedded double-colons if they are inside namespaces. To
593 handle this, we loop a few times, considering larger and
594 larger prefixes of the string as though they were single
595 symbols. So, if the initially supplied string is
596 A::B::C::D::foo, we have to look up "A", then "A::B",
597 then "A::B::C", then "A::B::C::D", and finally
598 "A::B::C::D::foo" as single, monolithic symbols, because
599 A, B, C or D may be namespaces.
601 Note that namespaces can nest only inside other
602 namespaces, and not inside classes. So we need only
603 consider *prefixes* of the string; there is no need to look up
604 "B::C" separately as a symbol in the previous example. */
610 struct symbol
*sym_class
= NULL
;
611 struct symbol
*sym_var
= NULL
;
617 /* Check for HP-compiled executable -- in other cases
618 return NULL, and caller must default to standard GDB
621 if (!hp_som_som_object_present
)
622 return (struct symbol
*) NULL
;
626 /* Skip over whitespace and possible global "::" */
627 while (*p
&& (*p
== ' ' || *p
== '\t'))
629 if (p
[0] == ':' && p
[1] == ':')
631 while (*p
&& (*p
== ' ' || *p
== '\t'))
636 /* Get to the end of the next namespace or class spec. */
637 /* If we're looking at some non-token, fail immediately */
639 if (!(isalpha (*p
) || *p
== '$' || *p
== '_'))
640 return (struct symbol
*) NULL
;
642 while (*p
&& (isalnum (*p
) || *p
== '$' || *p
== '_'))
647 /* If we have the start of a template specification,
648 scan right ahead to its end */
649 q
= find_template_name_end (p
);
656 /* Skip over "::" and whitespace for next time around */
657 while (*p
&& (*p
== ' ' || *p
== '\t'))
659 if (p
[0] == ':' && p
[1] == ':')
661 while (*p
&& (*p
== ' ' || *p
== '\t'))
664 /* Done with tokens? */
665 if (!*p
|| !(isalpha (*p
) || *p
== '$' || *p
== '_'))
668 tmp
= (char *) alloca (prefix_len
+ end
- start
+ 3);
671 memcpy (tmp
, prefix
, prefix_len
);
672 memcpy (tmp
+ prefix_len
, coloncolon
, 2);
673 memcpy (tmp
+ prefix_len
+ 2, start
, end
- start
);
674 tmp
[prefix_len
+ 2 + end
- start
] = '\000';
678 memcpy (tmp
, start
, end
- start
);
679 tmp
[end
- start
] = '\000';
683 prefix_len
= strlen (prefix
);
685 /* See if the prefix we have now is something we know about */
689 /* More tokens to process, so this must be a class/namespace */
690 sym_class
= lookup_symbol (prefix
, 0, STRUCT_NAMESPACE
,
691 0, (struct symtab
**) NULL
);
695 /* No more tokens, so try as a variable first */
696 sym_var
= lookup_symbol (prefix
, 0, VAR_NAMESPACE
,
697 0, (struct symtab
**) NULL
);
698 /* If failed, try as class/namespace */
700 sym_class
= lookup_symbol (prefix
, 0, STRUCT_NAMESPACE
,
701 0, (struct symtab
**) NULL
);
706 (t
= check_typedef (SYMBOL_TYPE (sym_class
)),
707 (TYPE_CODE (t
) == TYPE_CODE_STRUCT
708 || TYPE_CODE (t
) == TYPE_CODE_UNION
))))
710 /* We found a valid token */
711 *token
= (char *) xmalloc (prefix_len
+ 1);
712 memcpy (*token
, prefix
, prefix_len
);
713 (*token
)[prefix_len
] = '\000';
717 /* No variable or class/namespace found, no more tokens */
719 return (struct symbol
*) NULL
;
722 /* Out of loop, so we must have found a valid token */
729 *argptr
= done
? p
: end
;
731 return sym_var
? sym_var
: sym_class
; /* found */
735 find_template_name_end (char *p
)
738 int just_seen_right
= 0;
739 int just_seen_colon
= 0;
740 int just_seen_space
= 0;
742 if (!p
|| (*p
!= '<'))
753 /* In future, may want to allow these?? */
756 depth
++; /* start nested template */
757 if (just_seen_colon
|| just_seen_right
|| just_seen_space
)
758 return 0; /* but not after : or :: or > or space */
761 if (just_seen_colon
|| just_seen_right
)
762 return 0; /* end a (nested?) template */
763 just_seen_right
= 1; /* but not after : or :: */
764 if (--depth
== 0) /* also disallow >>, insist on > > */
765 return ++p
; /* if outermost ended, return */
768 if (just_seen_space
|| (just_seen_colon
> 1))
769 return 0; /* nested class spec coming up */
770 just_seen_colon
++; /* we allow :: but not :::: */
775 if (!((*p
>= 'a' && *p
<= 'z') || /* allow token chars */
776 (*p
>= 'A' && *p
<= 'Z') ||
777 (*p
>= '0' && *p
<= '9') ||
778 (*p
== '_') || (*p
== ',') || /* commas for template args */
779 (*p
== '&') || (*p
== '*') || /* pointer and ref types */
780 (*p
== '(') || (*p
== ')') || /* function types */
781 (*p
== '[') || (*p
== ']'))) /* array types */
796 /* Return a null-terminated temporary copy of the name
797 of a string token. */
800 copy_name (struct stoken token
)
802 memcpy (namecopy
, token
.ptr
, token
.length
);
803 namecopy
[token
.length
] = 0;
807 /* Reverse an expression from suffix form (in which it is constructed)
808 to prefix form (in which we can conveniently print or execute it). */
811 prefixify_expression (register struct expression
*expr
)
814 sizeof (struct expression
) + EXP_ELEM_TO_BYTES (expr
->nelts
);
815 register struct expression
*temp
;
816 register int inpos
= expr
->nelts
, outpos
= 0;
818 temp
= (struct expression
*) alloca (len
);
820 /* Copy the original expression into temp. */
821 memcpy (temp
, expr
, len
);
823 prefixify_subexp (temp
, expr
, inpos
, outpos
);
826 /* Return the number of exp_elements in the subexpression of EXPR
827 whose last exp_element is at index ENDPOS - 1 in EXPR. */
830 length_of_subexp (register struct expression
*expr
, register int endpos
)
832 register int oplen
= 1;
833 register int args
= 0;
837 error ("?error in length_of_subexp");
839 i
= (int) expr
->elts
[endpos
- 1].opcode
;
845 oplen
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
846 oplen
= 5 + BYTES_TO_EXP_ELEM (oplen
+ 1);
869 case OP_F77_UNDETERMINED_ARGLIST
:
871 args
= 1 + longest_to_int (expr
->elts
[endpos
- 2].longconst
);
899 case STRUCTOP_STRUCT
:
907 oplen
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
908 oplen
= 4 + BYTES_TO_EXP_ELEM (oplen
+ 1);
912 oplen
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
913 oplen
= (oplen
+ HOST_CHAR_BIT
- 1) / HOST_CHAR_BIT
;
914 oplen
= 4 + BYTES_TO_EXP_ELEM (oplen
);
919 args
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
920 args
-= longest_to_int (expr
->elts
[endpos
- 3].longconst
);
926 case TERNOP_SLICE_COUNT
:
931 case MULTI_SUBSCRIPT
:
933 args
= 1 + longest_to_int (expr
->elts
[endpos
- 2].longconst
);
936 case BINOP_ASSIGN_MODIFY
:
947 args
= 1 + (i
< (int) BINOP_END
);
952 oplen
+= length_of_subexp (expr
, endpos
- oplen
);
959 /* Copy the subexpression ending just before index INEND in INEXPR
960 into OUTEXPR, starting at index OUTBEG.
961 In the process, convert it from suffix to prefix form. */
964 prefixify_subexp (register struct expression
*inexpr
,
965 struct expression
*outexpr
, register int inend
, int outbeg
)
967 register int oplen
= 1;
968 register int args
= 0;
971 enum exp_opcode opcode
;
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). */
977 opcode
= inexpr
->elts
[inend
- 1].opcode
;
982 oplen
= longest_to_int (inexpr
->elts
[inend
- 2].longconst
);
983 oplen
= 5 + BYTES_TO_EXP_ELEM (oplen
+ 1);
1006 case OP_F77_UNDETERMINED_ARGLIST
:
1008 args
= 1 + longest_to_int (inexpr
->elts
[inend
- 2].longconst
);
1034 case STRUCTOP_STRUCT
:
1043 oplen
= longest_to_int (inexpr
->elts
[inend
- 2].longconst
);
1044 oplen
= 4 + BYTES_TO_EXP_ELEM (oplen
+ 1);
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
);
1055 args
= longest_to_int (inexpr
->elts
[inend
- 2].longconst
);
1056 args
-= longest_to_int (inexpr
->elts
[inend
- 3].longconst
);
1062 case TERNOP_SLICE_COUNT
:
1066 case BINOP_ASSIGN_MODIFY
:
1072 case MULTI_SUBSCRIPT
:
1074 args
= 1 + longest_to_int (inexpr
->elts
[inend
- 2].longconst
);
1083 args
= 1 + ((int) opcode
< (int) BINOP_END
);
1086 /* Copy the final operator itself, from the end of the input
1087 to the beginning of the output. */
1089 memcpy (&outexpr
->elts
[outbeg
], &inexpr
->elts
[inend
],
1090 EXP_ELEM_TO_BYTES (oplen
));
1093 /* Find the lengths of the arg subexpressions. */
1094 arglens
= (int *) alloca (args
* sizeof (int));
1095 for (i
= args
- 1; i
>= 0; i
--)
1097 oplen
= length_of_subexp (inexpr
, inend
);
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
++)
1112 prefixify_subexp (inexpr
, outexpr
, inend
, outbeg
);
1117 /* This page contains the two entry points to this file. */
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).
1127 If COMMA is nonzero, stop if a comma is reached. */
1130 parse_exp_1 (char **stringptr
, struct block
*block
, int comma
)
1132 struct cleanup
*old_chain
;
1134 lexptr
= *stringptr
;
1137 type_stack_depth
= 0;
1139 comma_terminates
= comma
;
1141 if (lexptr
== 0 || *lexptr
== 0)
1142 error_no_arg ("expression to compute");
1144 old_chain
= make_cleanup (free_funcalls
, 0 /*ignore*/);
1147 expression_context_block
= block
? block
: get_selected_block (0);
1149 namecopy
= (char *) alloca (strlen (lexptr
) + 1);
1152 expout
= (struct expression
*)
1153 xmalloc (sizeof (struct expression
) + EXP_ELEM_TO_BYTES (expout_size
));
1154 expout
->language_defn
= current_language
;
1155 make_cleanup (free_current_contents
, &expout
);
1157 if (current_language
->la_parser ())
1158 current_language
->la_error (NULL
);
1160 discard_cleanups (old_chain
);
1162 /* Record the actual number of expression elements, and then
1163 reallocate the expression memory so that we free up any
1166 expout
->nelts
= expout_ptr
;
1167 expout
= (struct expression
*)
1168 xrealloc ((char *) expout
,
1169 sizeof (struct expression
) + EXP_ELEM_TO_BYTES (expout_ptr
));;
1171 /* Convert expression from postfix form as generated by yacc
1172 parser, to a prefix form. */
1174 if (expressiondebug
)
1175 dump_prefix_expression (expout
, gdb_stdlog
,
1176 "before conversion to prefix form");
1178 prefixify_expression (expout
);
1180 if (expressiondebug
)
1181 dump_postfix_expression (expout
, gdb_stdlog
,
1182 "after conversion to prefix form");
1184 *stringptr
= lexptr
;
1188 /* Parse STRING as an expression, and complain if this fails
1189 to use up all of the contents of STRING. */
1192 parse_expression (char *string
)
1194 register struct expression
*exp
;
1195 exp
= parse_exp_1 (&string
, 0, 0);
1197 error ("Junk after end of expression.");
1201 /* Stuff for maintaining a stack of types. Currently just used by C, but
1202 probably useful for any language which declares its types "backwards". */
1205 check_type_stack_depth (void)
1207 if (type_stack_depth
== type_stack_size
)
1209 type_stack_size
*= 2;
1210 type_stack
= (union type_stack_elt
*)
1211 xrealloc ((char *) type_stack
, type_stack_size
* sizeof (*type_stack
));
1216 push_type (enum type_pieces tp
)
1218 check_type_stack_depth ();
1219 type_stack
[type_stack_depth
++].piece
= tp
;
1223 push_type_int (int n
)
1225 check_type_stack_depth ();
1226 type_stack
[type_stack_depth
++].int_val
= n
;
1230 push_type_address_space (char *string
)
1232 push_type_int (address_space_name_to_int (string
));
1238 if (type_stack_depth
)
1239 return type_stack
[--type_stack_depth
].piece
;
1246 if (type_stack_depth
)
1247 return type_stack
[--type_stack_depth
].int_val
;
1248 /* "Can't happen". */
1252 /* Pop the type stack and return the type which corresponds to FOLLOW_TYPE
1253 as modified by all the stuff on the stack. */
1255 follow_types (struct type
*follow_type
)
1259 int make_volatile
= 0;
1260 int make_addr_space
= 0;
1262 struct type
*range_type
;
1265 switch (pop_type ())
1270 follow_type
= make_cv_type (make_const
,
1271 TYPE_VOLATILE (follow_type
),
1274 follow_type
= make_cv_type (TYPE_CONST (follow_type
),
1277 if (make_addr_space
)
1278 follow_type
= make_type_with_address_space (follow_type
,
1280 make_const
= make_volatile
= 0;
1281 make_addr_space
= 0;
1289 case tp_space_identifier
:
1290 make_addr_space
= pop_type_int ();
1293 follow_type
= lookup_pointer_type (follow_type
);
1295 follow_type
= make_cv_type (make_const
,
1296 TYPE_VOLATILE (follow_type
),
1299 follow_type
= make_cv_type (TYPE_CONST (follow_type
),
1302 if (make_addr_space
)
1303 follow_type
= make_type_with_address_space (follow_type
,
1305 make_const
= make_volatile
= 0;
1306 make_addr_space
= 0;
1309 follow_type
= lookup_reference_type (follow_type
);
1311 follow_type
= make_cv_type (make_const
,
1312 TYPE_VOLATILE (follow_type
),
1315 follow_type
= make_cv_type (TYPE_CONST (follow_type
),
1318 if (make_addr_space
)
1319 follow_type
= make_type_with_address_space (follow_type
,
1321 make_const
= make_volatile
= 0;
1322 make_addr_space
= 0;
1325 array_size
= pop_type_int ();
1326 /* FIXME-type-allocation: need a way to free this type when we are
1329 create_range_type ((struct type
*) NULL
,
1330 builtin_type_int
, 0,
1331 array_size
>= 0 ? array_size
- 1 : 0);
1333 create_array_type ((struct type
*) NULL
,
1334 follow_type
, range_type
);
1336 TYPE_ARRAY_UPPER_BOUND_TYPE (follow_type
)
1337 = BOUND_CANNOT_BE_DETERMINED
;
1340 /* FIXME-type-allocation: need a way to free this type when we are
1342 follow_type
= lookup_function_type (follow_type
);
1348 static void build_parse (void);
1354 msym_text_symbol_type
=
1355 init_type (TYPE_CODE_FUNC
, 1, 0, "<text variable, no debug info>", NULL
);
1356 TYPE_TARGET_TYPE (msym_text_symbol_type
) = builtin_type_int
;
1357 msym_data_symbol_type
=
1358 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ HOST_CHAR_BIT
, 0,
1359 "<data variable, no debug info>", NULL
);
1360 msym_unknown_symbol_type
=
1361 init_type (TYPE_CODE_INT
, 1, 0,
1362 "<variable (not text or data), no debug info>",
1365 /* create the std_regs table */
1384 /* create an empty table */
1385 std_regs
= xmalloc ((num_std_regs
+ 1) * sizeof *std_regs
);
1391 std_regs
[i
].name
= "pc";
1392 std_regs
[i
].regnum
= PC_REGNUM
;
1399 std_regs
[i
].name
= "fp";
1400 std_regs
[i
].regnum
= FP_REGNUM
;
1407 std_regs
[i
].name
= "sp";
1408 std_regs
[i
].regnum
= SP_REGNUM
;
1415 std_regs
[i
].name
= "ps";
1416 std_regs
[i
].regnum
= PS_REGNUM
;
1420 memset (&std_regs
[i
], 0, sizeof (std_regs
[i
]));
1424 _initialize_parse (void)
1426 type_stack_size
= 80;
1427 type_stack_depth
= 0;
1428 type_stack
= (union type_stack_elt
*)
1429 xmalloc (type_stack_size
* sizeof (*type_stack
));
1433 /* FIXME - For the moment, handle types by swapping them in and out.
1434 Should be using the per-architecture data-pointer and a large
1436 register_gdbarch_swap (&msym_text_symbol_type
, sizeof (msym_text_symbol_type
), NULL
);
1437 register_gdbarch_swap (&msym_data_symbol_type
, sizeof (msym_data_symbol_type
), NULL
);
1438 register_gdbarch_swap (&msym_unknown_symbol_type
, sizeof (msym_unknown_symbol_type
), NULL
);
1440 register_gdbarch_swap (&num_std_regs
, sizeof (std_regs
), NULL
);
1441 register_gdbarch_swap (&std_regs
, sizeof (std_regs
), NULL
);
1442 register_gdbarch_swap (NULL
, 0, build_parse
);
1445 add_set_cmd ("expression", class_maintenance
, var_zinteger
,
1446 (char *) &expressiondebug
,
1447 "Set expression debugging.\n\
1448 When non-zero, the internal representation of expressions will be printed.",