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. */
51 /* Symbols which architectures can redefine. */
53 /* Some systems have routines whose names start with `$'. Giving this
54 macro a non-zero value tells GDB's expression parser to check for
55 such routines when parsing tokens that begin with `$'.
57 On HP-UX, certain system routines (millicode) have names beginning
58 with `$' or `$$'. For example, `$$dyncall' is a millicode routine
59 that handles inter-space procedure calls on PA-RISC. */
60 #ifndef SYMBOLS_CAN_START_WITH_DOLLAR
61 #define SYMBOLS_CAN_START_WITH_DOLLAR (0)
66 /* Global variables declared in parser-defs.h (and commented there). */
67 struct expression
*expout
;
70 struct block
*expression_context_block
;
71 struct block
*innermost_block
;
73 union type_stack_elt
*type_stack
;
74 int type_stack_depth
, type_stack_size
;
80 static int expressiondebug
= 0;
82 extern int hp_som_som_object_present
;
84 static void free_funcalls (void *ignore
);
86 static void prefixify_expression (struct expression
*);
89 prefixify_subexp (struct expression
*, struct expression
*, int, int);
91 void _initialize_parse (void);
93 /* Data structure for saving values of arglist_len for function calls whose
94 arguments contain other function calls. */
102 static struct funcall
*funcall_chain
;
104 /* Assign machine-independent names to certain registers
105 (unless overridden by the REGISTER_NAMES table) */
107 unsigned num_std_regs
= 0;
108 struct std_regs
*std_regs
;
110 /* The generic method for targets to specify how their registers are
111 named. The mapping can be derived from three sources:
112 REGISTER_NAME; std_regs; or a target specific alias hook. */
115 target_map_name_to_register (char *str
, int len
)
119 /* First try target specific aliases. We try these first because on some
120 systems standard names can be context dependent (eg. $pc on a
121 multiprocessor can be could be any of several PCs). */
122 #ifdef REGISTER_NAME_ALIAS_HOOK
123 i
= REGISTER_NAME_ALIAS_HOOK (str
, len
);
128 /* Search architectural register name space. */
129 for (i
= 0; i
< NUM_REGS
; i
++)
130 if (REGISTER_NAME (i
) && len
== strlen (REGISTER_NAME (i
))
131 && STREQN (str
, REGISTER_NAME (i
), len
))
136 /* Try pseudo-registers, if any. */
137 for (i
= NUM_REGS
; i
< NUM_REGS
+ NUM_PSEUDO_REGS
; i
++)
138 if (REGISTER_NAME (i
) && len
== strlen (REGISTER_NAME (i
))
139 && STREQN (str
, REGISTER_NAME (i
), len
))
144 /* Try standard aliases. */
145 for (i
= 0; i
< num_std_regs
; i
++)
146 if (std_regs
[i
].name
&& len
== strlen (std_regs
[i
].name
)
147 && STREQN (str
, std_regs
[i
].name
, len
))
149 return std_regs
[i
].regnum
;
155 /* Begin counting arguments for a function call,
156 saving the data about any containing call. */
161 register struct funcall
*new;
163 new = (struct funcall
*) xmalloc (sizeof (struct funcall
));
164 new->next
= funcall_chain
;
165 new->arglist_len
= arglist_len
;
170 /* Return the number of arguments in a function call just terminated,
171 and restore the data for the containing function call. */
176 register int val
= arglist_len
;
177 register struct funcall
*call
= funcall_chain
;
178 funcall_chain
= call
->next
;
179 arglist_len
= call
->arglist_len
;
184 /* Free everything in the funcall chain.
185 Used when there is an error inside parsing. */
188 free_funcalls (void *ignore
)
190 register struct funcall
*call
, *next
;
192 for (call
= funcall_chain
; call
; call
= next
)
199 /* This page contains the functions for adding data to the struct expression
200 being constructed. */
202 /* Add one element to the end of the expression. */
204 /* To avoid a bug in the Sun 4 compiler, we pass things that can fit into
205 a register through here */
208 write_exp_elt (union exp_element expelt
)
210 if (expout_ptr
>= expout_size
)
213 expout
= (struct expression
*)
214 xrealloc ((char *) expout
, sizeof (struct expression
)
215 + EXP_ELEM_TO_BYTES (expout_size
));
217 expout
->elts
[expout_ptr
++] = expelt
;
221 write_exp_elt_opcode (enum exp_opcode expelt
)
223 union exp_element tmp
;
231 write_exp_elt_sym (struct symbol
*expelt
)
233 union exp_element tmp
;
241 write_exp_elt_block (struct block
*b
)
243 union exp_element tmp
;
249 write_exp_elt_longcst (LONGEST expelt
)
251 union exp_element tmp
;
253 tmp
.longconst
= expelt
;
259 write_exp_elt_dblcst (DOUBLEST expelt
)
261 union exp_element tmp
;
263 tmp
.doubleconst
= expelt
;
269 write_exp_elt_type (struct type
*expelt
)
271 union exp_element tmp
;
279 write_exp_elt_intern (struct internalvar
*expelt
)
281 union exp_element tmp
;
283 tmp
.internalvar
= expelt
;
288 /* Add a string constant to the end of the expression.
290 String constants are stored by first writing an expression element
291 that contains the length of the string, then stuffing the string
292 constant itself into however many expression elements are needed
293 to hold it, and then writing another expression element that contains
294 the length of the string. I.E. an expression element at each end of
295 the string records the string length, so you can skip over the
296 expression elements containing the actual string bytes from either
297 end of the string. Note that this also allows gdb to handle
298 strings with embedded null bytes, as is required for some languages.
300 Don't be fooled by the fact that the string is null byte terminated,
301 this is strictly for the convenience of debugging gdb itself. Gdb
302 Gdb does not depend up the string being null terminated, since the
303 actual length is recorded in expression elements at each end of the
304 string. The null byte is taken into consideration when computing how
305 many expression elements are required to hold the string constant, of
310 write_exp_string (struct stoken str
)
312 register int len
= str
.length
;
314 register char *strdata
;
316 /* Compute the number of expression elements required to hold the string
317 (including a null byte terminator), along with one expression element
318 at each end to record the actual string length (not including the
319 null byte terminator). */
321 lenelt
= 2 + BYTES_TO_EXP_ELEM (len
+ 1);
323 /* Ensure that we have enough available expression elements to store
326 if ((expout_ptr
+ lenelt
) >= expout_size
)
328 expout_size
= max (expout_size
* 2, expout_ptr
+ lenelt
+ 10);
329 expout
= (struct expression
*)
330 xrealloc ((char *) expout
, (sizeof (struct expression
)
331 + EXP_ELEM_TO_BYTES (expout_size
)));
334 /* Write the leading length expression element (which advances the current
335 expression element index), then write the string constant followed by a
336 terminating null byte, and then write the trailing length expression
339 write_exp_elt_longcst ((LONGEST
) len
);
340 strdata
= (char *) &expout
->elts
[expout_ptr
];
341 memcpy (strdata
, str
.ptr
, len
);
342 *(strdata
+ len
) = '\0';
343 expout_ptr
+= lenelt
- 2;
344 write_exp_elt_longcst ((LONGEST
) len
);
347 /* Add a bitstring constant to the end of the expression.
349 Bitstring constants are stored by first writing an expression element
350 that contains the length of the bitstring (in bits), then stuffing the
351 bitstring constant itself into however many expression elements are
352 needed to hold it, and then writing another expression element that
353 contains the length of the bitstring. I.E. an expression element at
354 each end of the bitstring records the bitstring length, so you can skip
355 over the expression elements containing the actual bitstring bytes from
356 either end of the bitstring. */
359 write_exp_bitstring (struct stoken str
)
361 register int bits
= str
.length
; /* length in bits */
362 register int len
= (bits
+ HOST_CHAR_BIT
- 1) / HOST_CHAR_BIT
;
364 register char *strdata
;
366 /* Compute the number of expression elements required to hold the bitstring,
367 along with one expression element at each end to record the actual
368 bitstring length in bits. */
370 lenelt
= 2 + BYTES_TO_EXP_ELEM (len
);
372 /* Ensure that we have enough available expression elements to store
375 if ((expout_ptr
+ lenelt
) >= expout_size
)
377 expout_size
= max (expout_size
* 2, expout_ptr
+ lenelt
+ 10);
378 expout
= (struct expression
*)
379 xrealloc ((char *) expout
, (sizeof (struct expression
)
380 + EXP_ELEM_TO_BYTES (expout_size
)));
383 /* Write the leading length expression element (which advances the current
384 expression element index), then write the bitstring constant, and then
385 write the trailing length expression element. */
387 write_exp_elt_longcst ((LONGEST
) bits
);
388 strdata
= (char *) &expout
->elts
[expout_ptr
];
389 memcpy (strdata
, str
.ptr
, len
);
390 expout_ptr
+= lenelt
- 2;
391 write_exp_elt_longcst ((LONGEST
) bits
);
394 /* Add the appropriate elements for a minimal symbol to the end of
395 the expression. The rationale behind passing in text_symbol_type and
396 data_symbol_type was so that Modula-2 could pass in WORD for
397 data_symbol_type. Perhaps it still is useful to have those types vary
398 based on the language, but they no longer have names like "int", so
399 the initial rationale is gone. */
401 static struct type
*msym_text_symbol_type
;
402 static struct type
*msym_data_symbol_type
;
403 static struct type
*msym_unknown_symbol_type
;
406 write_exp_msymbol (struct minimal_symbol
*msymbol
,
407 struct type
*text_symbol_type
,
408 struct type
*data_symbol_type
)
412 write_exp_elt_opcode (OP_LONG
);
413 /* Let's make the type big enough to hold a 64-bit address. */
414 write_exp_elt_type (builtin_type_CORE_ADDR
);
416 addr
= SYMBOL_VALUE_ADDRESS (msymbol
);
417 if (overlay_debugging
)
418 addr
= symbol_overlayed_address (addr
, SYMBOL_BFD_SECTION (msymbol
));
419 write_exp_elt_longcst ((LONGEST
) addr
);
421 write_exp_elt_opcode (OP_LONG
);
423 write_exp_elt_opcode (UNOP_MEMVAL
);
424 switch (msymbol
->type
)
428 case mst_solib_trampoline
:
429 write_exp_elt_type (msym_text_symbol_type
);
436 write_exp_elt_type (msym_data_symbol_type
);
440 write_exp_elt_type (msym_unknown_symbol_type
);
443 write_exp_elt_opcode (UNOP_MEMVAL
);
446 /* Recognize tokens that start with '$'. These include:
448 $regname A native register name or a "standard
451 $variable A convenience variable with a name chosen
454 $digits Value history with index <digits>, starting
455 from the first value which has index 1.
457 $$digits Value history with index <digits> relative
458 to the last value. I.E. $$0 is the last
459 value, $$1 is the one previous to that, $$2
460 is the one previous to $$1, etc.
462 $ | $0 | $$0 The last value in the value history.
464 $$ An abbreviation for the second to the last
465 value in the value history, I.E. $$1
470 write_dollar_variable (struct stoken str
)
472 /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
473 and $$digits (equivalent to $<-digits> if you could type that). */
477 /* Double dollar means negate the number and add -1 as well.
478 Thus $$ alone means -1. */
479 if (str
.length
>= 2 && str
.ptr
[1] == '$')
486 /* Just dollars (one or two) */
490 /* Is the rest of the token digits? */
491 for (; i
< str
.length
; i
++)
492 if (!(str
.ptr
[i
] >= '0' && str
.ptr
[i
] <= '9'))
496 i
= atoi (str
.ptr
+ 1 + negate
);
502 /* Handle tokens that refer to machine registers:
503 $ followed by a register name. */
504 i
= target_map_name_to_register (str
.ptr
+ 1, str
.length
- 1);
506 goto handle_register
;
508 if (SYMBOLS_CAN_START_WITH_DOLLAR
)
510 struct symbol
*sym
= NULL
;
511 struct minimal_symbol
*msym
= NULL
;
513 /* On HP-UX, certain system routines (millicode) have names beginning
514 with $ or $$, e.g. $$dyncall, which handles inter-space procedure
515 calls on PA-RISC. Check for those, first. */
517 /* This code is not enabled on non HP-UX systems, since worst case
518 symbol table lookup performance is awful, to put it mildly. */
520 sym
= lookup_symbol (copy_name (str
), (struct block
*) NULL
,
521 VAR_NAMESPACE
, (int *) NULL
, (struct symtab
**) NULL
);
524 write_exp_elt_opcode (OP_VAR_VALUE
);
525 write_exp_elt_block (block_found
); /* set by lookup_symbol */
526 write_exp_elt_sym (sym
);
527 write_exp_elt_opcode (OP_VAR_VALUE
);
530 msym
= lookup_minimal_symbol (copy_name (str
), NULL
, NULL
);
533 write_exp_msymbol (msym
,
534 lookup_function_type (builtin_type_int
),
540 /* Any other names starting in $ are debugger internal variables. */
542 write_exp_elt_opcode (OP_INTERNALVAR
);
543 write_exp_elt_intern (lookup_internalvar (copy_name (str
) + 1));
544 write_exp_elt_opcode (OP_INTERNALVAR
);
547 write_exp_elt_opcode (OP_LAST
);
548 write_exp_elt_longcst ((LONGEST
) i
);
549 write_exp_elt_opcode (OP_LAST
);
552 write_exp_elt_opcode (OP_REGISTER
);
553 write_exp_elt_longcst (i
);
554 write_exp_elt_opcode (OP_REGISTER
);
559 /* Parse a string that is possibly a namespace / nested class
560 specification, i.e., something of the form A::B::C::x. Input
561 (NAME) is the entire string; LEN is the current valid length; the
562 output is a string, TOKEN, which points to the largest recognized
563 prefix which is a series of namespaces or classes. CLASS_PREFIX is
564 another output, which records whether a nested class spec was
565 recognized (= 1) or a fully qualified variable name was found (=
566 0). ARGPTR is side-effected (if non-NULL) to point to beyond the
567 string recognized and consumed by this routine.
569 The return value is a pointer to the symbol for the base class or
570 variable if found, or NULL if not found. Callers must check this
571 first -- if NULL, the outputs may not be correct.
573 This function is used c-exp.y. This is used specifically to get
574 around HP aCC (and possibly other compilers), which insists on
575 generating names with embedded colons for namespace or nested class
578 (Argument LEN is currently unused. 1997-08-27)
580 Callers must free memory allocated for the output string TOKEN. */
582 static const char coloncolon
[2] =
586 parse_nested_classes_for_hpacc (char *name
, int len
, char **token
,
587 int *class_prefix
, char **argptr
)
589 /* Comment below comes from decode_line_1 which has very similar
590 code, which is called for "break" command parsing. */
592 /* We have what looks like a class or namespace
593 scope specification (A::B), possibly with many
594 levels of namespaces or classes (A::B::C::D).
596 Some versions of the HP ANSI C++ compiler (as also possibly
597 other compilers) generate class/function/member names with
598 embedded double-colons if they are inside namespaces. To
599 handle this, we loop a few times, considering larger and
600 larger prefixes of the string as though they were single
601 symbols. So, if the initially supplied string is
602 A::B::C::D::foo, we have to look up "A", then "A::B",
603 then "A::B::C", then "A::B::C::D", and finally
604 "A::B::C::D::foo" as single, monolithic symbols, because
605 A, B, C or D may be namespaces.
607 Note that namespaces can nest only inside other
608 namespaces, and not inside classes. So we need only
609 consider *prefixes* of the string; there is no need to look up
610 "B::C" separately as a symbol in the previous example. */
616 struct symbol
*sym_class
= NULL
;
617 struct symbol
*sym_var
= NULL
;
623 /* Check for HP-compiled executable -- in other cases
624 return NULL, and caller must default to standard GDB
627 if (!hp_som_som_object_present
)
628 return (struct symbol
*) NULL
;
632 /* Skip over whitespace and possible global "::" */
633 while (*p
&& (*p
== ' ' || *p
== '\t'))
635 if (p
[0] == ':' && p
[1] == ':')
637 while (*p
&& (*p
== ' ' || *p
== '\t'))
642 /* Get to the end of the next namespace or class spec. */
643 /* If we're looking at some non-token, fail immediately */
645 if (!(isalpha (*p
) || *p
== '$' || *p
== '_'))
646 return (struct symbol
*) NULL
;
648 while (*p
&& (isalnum (*p
) || *p
== '$' || *p
== '_'))
653 /* If we have the start of a template specification,
654 scan right ahead to its end */
655 q
= find_template_name_end (p
);
662 /* Skip over "::" and whitespace for next time around */
663 while (*p
&& (*p
== ' ' || *p
== '\t'))
665 if (p
[0] == ':' && p
[1] == ':')
667 while (*p
&& (*p
== ' ' || *p
== '\t'))
670 /* Done with tokens? */
671 if (!*p
|| !(isalpha (*p
) || *p
== '$' || *p
== '_'))
674 tmp
= (char *) alloca (prefix_len
+ end
- start
+ 3);
677 memcpy (tmp
, prefix
, prefix_len
);
678 memcpy (tmp
+ prefix_len
, coloncolon
, 2);
679 memcpy (tmp
+ prefix_len
+ 2, start
, end
- start
);
680 tmp
[prefix_len
+ 2 + end
- start
] = '\000';
684 memcpy (tmp
, start
, end
- start
);
685 tmp
[end
- start
] = '\000';
689 prefix_len
= strlen (prefix
);
691 /* See if the prefix we have now is something we know about */
695 /* More tokens to process, so this must be a class/namespace */
696 sym_class
= lookup_symbol (prefix
, 0, STRUCT_NAMESPACE
,
697 0, (struct symtab
**) NULL
);
701 /* No more tokens, so try as a variable first */
702 sym_var
= lookup_symbol (prefix
, 0, VAR_NAMESPACE
,
703 0, (struct symtab
**) NULL
);
704 /* If failed, try as class/namespace */
706 sym_class
= lookup_symbol (prefix
, 0, STRUCT_NAMESPACE
,
707 0, (struct symtab
**) NULL
);
712 (t
= check_typedef (SYMBOL_TYPE (sym_class
)),
713 (TYPE_CODE (t
) == TYPE_CODE_STRUCT
714 || TYPE_CODE (t
) == TYPE_CODE_UNION
))))
716 /* We found a valid token */
717 *token
= (char *) xmalloc (prefix_len
+ 1);
718 memcpy (*token
, prefix
, prefix_len
);
719 (*token
)[prefix_len
] = '\000';
723 /* No variable or class/namespace found, no more tokens */
725 return (struct symbol
*) NULL
;
728 /* Out of loop, so we must have found a valid token */
735 *argptr
= done
? p
: end
;
737 return sym_var
? sym_var
: sym_class
; /* found */
741 find_template_name_end (char *p
)
744 int just_seen_right
= 0;
745 int just_seen_colon
= 0;
746 int just_seen_space
= 0;
748 if (!p
|| (*p
!= '<'))
759 /* In future, may want to allow these?? */
762 depth
++; /* start nested template */
763 if (just_seen_colon
|| just_seen_right
|| just_seen_space
)
764 return 0; /* but not after : or :: or > or space */
767 if (just_seen_colon
|| just_seen_right
)
768 return 0; /* end a (nested?) template */
769 just_seen_right
= 1; /* but not after : or :: */
770 if (--depth
== 0) /* also disallow >>, insist on > > */
771 return ++p
; /* if outermost ended, return */
774 if (just_seen_space
|| (just_seen_colon
> 1))
775 return 0; /* nested class spec coming up */
776 just_seen_colon
++; /* we allow :: but not :::: */
781 if (!((*p
>= 'a' && *p
<= 'z') || /* allow token chars */
782 (*p
>= 'A' && *p
<= 'Z') ||
783 (*p
>= '0' && *p
<= '9') ||
784 (*p
== '_') || (*p
== ',') || /* commas for template args */
785 (*p
== '&') || (*p
== '*') || /* pointer and ref types */
786 (*p
== '(') || (*p
== ')') || /* function types */
787 (*p
== '[') || (*p
== ']'))) /* array types */
802 /* Return a null-terminated temporary copy of the name
803 of a string token. */
806 copy_name (struct stoken token
)
808 memcpy (namecopy
, token
.ptr
, token
.length
);
809 namecopy
[token
.length
] = 0;
813 /* Reverse an expression from suffix form (in which it is constructed)
814 to prefix form (in which we can conveniently print or execute it). */
817 prefixify_expression (register struct expression
*expr
)
820 sizeof (struct expression
) + EXP_ELEM_TO_BYTES (expr
->nelts
);
821 register struct expression
*temp
;
822 register int inpos
= expr
->nelts
, outpos
= 0;
824 temp
= (struct expression
*) alloca (len
);
826 /* Copy the original expression into temp. */
827 memcpy (temp
, expr
, len
);
829 prefixify_subexp (temp
, expr
, inpos
, outpos
);
832 /* Return the number of exp_elements in the subexpression of EXPR
833 whose last exp_element is at index ENDPOS - 1 in EXPR. */
836 length_of_subexp (register struct expression
*expr
, register int endpos
)
838 register int oplen
= 1;
839 register int args
= 0;
843 error ("?error in length_of_subexp");
845 i
= (int) expr
->elts
[endpos
- 1].opcode
;
851 oplen
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
852 oplen
= 5 + BYTES_TO_EXP_ELEM (oplen
+ 1);
875 case OP_F77_UNDETERMINED_ARGLIST
:
877 args
= 1 + longest_to_int (expr
->elts
[endpos
- 2].longconst
);
905 case STRUCTOP_STRUCT
:
913 oplen
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
914 oplen
= 4 + BYTES_TO_EXP_ELEM (oplen
+ 1);
918 oplen
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
919 oplen
= (oplen
+ HOST_CHAR_BIT
- 1) / HOST_CHAR_BIT
;
920 oplen
= 4 + BYTES_TO_EXP_ELEM (oplen
);
925 args
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
926 args
-= longest_to_int (expr
->elts
[endpos
- 3].longconst
);
932 case TERNOP_SLICE_COUNT
:
937 case MULTI_SUBSCRIPT
:
939 args
= 1 + longest_to_int (expr
->elts
[endpos
- 2].longconst
);
942 case BINOP_ASSIGN_MODIFY
:
953 args
= 1 + (i
< (int) BINOP_END
);
958 oplen
+= length_of_subexp (expr
, endpos
- oplen
);
965 /* Copy the subexpression ending just before index INEND in INEXPR
966 into OUTEXPR, starting at index OUTBEG.
967 In the process, convert it from suffix to prefix form. */
970 prefixify_subexp (register struct expression
*inexpr
,
971 struct expression
*outexpr
, register int inend
, int outbeg
)
973 register int oplen
= 1;
974 register int args
= 0;
977 enum exp_opcode opcode
;
979 /* Compute how long the last operation is (in OPLEN),
980 and also how many preceding subexpressions serve as
981 arguments for it (in ARGS). */
983 opcode
= inexpr
->elts
[inend
- 1].opcode
;
988 oplen
= longest_to_int (inexpr
->elts
[inend
- 2].longconst
);
989 oplen
= 5 + BYTES_TO_EXP_ELEM (oplen
+ 1);
1002 case OP_INTERNALVAR
:
1012 case OP_F77_UNDETERMINED_ARGLIST
:
1014 args
= 1 + longest_to_int (inexpr
->elts
[inend
- 2].longconst
);
1040 case STRUCTOP_STRUCT
:
1049 oplen
= longest_to_int (inexpr
->elts
[inend
- 2].longconst
);
1050 oplen
= 4 + BYTES_TO_EXP_ELEM (oplen
+ 1);
1054 oplen
= longest_to_int (inexpr
->elts
[inend
- 2].longconst
);
1055 oplen
= (oplen
+ HOST_CHAR_BIT
- 1) / HOST_CHAR_BIT
;
1056 oplen
= 4 + BYTES_TO_EXP_ELEM (oplen
);
1061 args
= longest_to_int (inexpr
->elts
[inend
- 2].longconst
);
1062 args
-= longest_to_int (inexpr
->elts
[inend
- 3].longconst
);
1068 case TERNOP_SLICE_COUNT
:
1072 case BINOP_ASSIGN_MODIFY
:
1078 case MULTI_SUBSCRIPT
:
1080 args
= 1 + longest_to_int (inexpr
->elts
[inend
- 2].longconst
);
1089 args
= 1 + ((int) opcode
< (int) BINOP_END
);
1092 /* Copy the final operator itself, from the end of the input
1093 to the beginning of the output. */
1095 memcpy (&outexpr
->elts
[outbeg
], &inexpr
->elts
[inend
],
1096 EXP_ELEM_TO_BYTES (oplen
));
1099 /* Find the lengths of the arg subexpressions. */
1100 arglens
= (int *) alloca (args
* sizeof (int));
1101 for (i
= args
- 1; i
>= 0; i
--)
1103 oplen
= length_of_subexp (inexpr
, inend
);
1108 /* Now copy each subexpression, preserving the order of
1109 the subexpressions, but prefixifying each one.
1110 In this loop, inend starts at the beginning of
1111 the expression this level is working on
1112 and marches forward over the arguments.
1113 outbeg does similarly in the output. */
1114 for (i
= 0; i
< args
; i
++)
1118 prefixify_subexp (inexpr
, outexpr
, inend
, outbeg
);
1123 /* This page contains the two entry points to this file. */
1125 /* Read an expression from the string *STRINGPTR points to,
1126 parse it, and return a pointer to a struct expression that we malloc.
1127 Use block BLOCK as the lexical context for variable names;
1128 if BLOCK is zero, use the block of the selected stack frame.
1129 Meanwhile, advance *STRINGPTR to point after the expression,
1130 at the first nonwhite character that is not part of the expression
1131 (possibly a null character).
1133 If COMMA is nonzero, stop if a comma is reached. */
1136 parse_exp_1 (char **stringptr
, struct block
*block
, int comma
)
1138 struct cleanup
*old_chain
;
1140 lexptr
= *stringptr
;
1143 type_stack_depth
= 0;
1145 comma_terminates
= comma
;
1147 if (lexptr
== 0 || *lexptr
== 0)
1148 error_no_arg ("expression to compute");
1150 old_chain
= make_cleanup (free_funcalls
, 0 /*ignore*/);
1153 expression_context_block
= block
? block
: get_selected_block ();
1155 namecopy
= (char *) alloca (strlen (lexptr
) + 1);
1158 expout
= (struct expression
*)
1159 xmalloc (sizeof (struct expression
) + EXP_ELEM_TO_BYTES (expout_size
));
1160 expout
->language_defn
= current_language
;
1161 make_cleanup (free_current_contents
, &expout
);
1163 if (current_language
->la_parser ())
1164 current_language
->la_error (NULL
);
1166 discard_cleanups (old_chain
);
1168 /* Record the actual number of expression elements, and then
1169 reallocate the expression memory so that we free up any
1172 expout
->nelts
= expout_ptr
;
1173 expout
= (struct expression
*)
1174 xrealloc ((char *) expout
,
1175 sizeof (struct expression
) + EXP_ELEM_TO_BYTES (expout_ptr
));;
1177 /* Convert expression from postfix form as generated by yacc
1178 parser, to a prefix form. */
1180 if (expressiondebug
)
1181 dump_prefix_expression (expout
, gdb_stdlog
,
1182 "before conversion to prefix form");
1184 prefixify_expression (expout
);
1186 if (expressiondebug
)
1187 dump_postfix_expression (expout
, gdb_stdlog
,
1188 "after conversion to prefix form");
1190 *stringptr
= lexptr
;
1194 /* Parse STRING as an expression, and complain if this fails
1195 to use up all of the contents of STRING. */
1198 parse_expression (char *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". */
1211 push_type (enum type_pieces tp
)
1213 if (type_stack_depth
== type_stack_size
)
1215 type_stack_size
*= 2;
1216 type_stack
= (union type_stack_elt
*)
1217 xrealloc ((char *) type_stack
, type_stack_size
* sizeof (*type_stack
));
1219 type_stack
[type_stack_depth
++].piece
= tp
;
1223 push_type_int (int n
)
1225 if (type_stack_depth
== type_stack_size
)
1227 type_stack_size
*= 2;
1228 type_stack
= (union type_stack_elt
*)
1229 xrealloc ((char *) type_stack
, type_stack_size
* sizeof (*type_stack
));
1231 type_stack
[type_stack_depth
++].int_val
= n
;
1237 if (type_stack_depth
)
1238 return type_stack
[--type_stack_depth
].piece
;
1245 if (type_stack_depth
)
1246 return type_stack
[--type_stack_depth
].int_val
;
1247 /* "Can't happen". */
1251 /* Pop the type stack and return the type which corresponds to FOLLOW_TYPE
1252 as modified by all the stuff on the stack. */
1254 follow_types (struct type
*follow_type
)
1258 struct type
*range_type
;
1261 switch (pop_type ())
1267 follow_type
= lookup_pointer_type (follow_type
);
1270 follow_type
= lookup_reference_type (follow_type
);
1273 array_size
= pop_type_int ();
1274 /* FIXME-type-allocation: need a way to free this type when we are
1277 create_range_type ((struct type
*) NULL
,
1278 builtin_type_int
, 0,
1279 array_size
>= 0 ? array_size
- 1 : 0);
1281 create_array_type ((struct type
*) NULL
,
1282 follow_type
, range_type
);
1284 TYPE_ARRAY_UPPER_BOUND_TYPE (follow_type
)
1285 = BOUND_CANNOT_BE_DETERMINED
;
1288 /* FIXME-type-allocation: need a way to free this type when we are
1290 follow_type
= lookup_function_type (follow_type
);
1296 static void build_parse (void);
1302 msym_text_symbol_type
=
1303 init_type (TYPE_CODE_FUNC
, 1, 0, "<text variable, no debug info>", NULL
);
1304 TYPE_TARGET_TYPE (msym_text_symbol_type
) = builtin_type_int
;
1305 msym_data_symbol_type
=
1306 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ HOST_CHAR_BIT
, 0,
1307 "<data variable, no debug info>", NULL
);
1308 msym_unknown_symbol_type
=
1309 init_type (TYPE_CODE_INT
, 1, 0,
1310 "<variable (not text or data), no debug info>",
1313 /* create the std_regs table */
1332 /* create an empty table */
1333 std_regs
= xmalloc ((num_std_regs
+ 1) * sizeof *std_regs
);
1339 std_regs
[i
].name
= "pc";
1340 std_regs
[i
].regnum
= PC_REGNUM
;
1347 std_regs
[i
].name
= "fp";
1348 std_regs
[i
].regnum
= FP_REGNUM
;
1355 std_regs
[i
].name
= "sp";
1356 std_regs
[i
].regnum
= SP_REGNUM
;
1363 std_regs
[i
].name
= "ps";
1364 std_regs
[i
].regnum
= PS_REGNUM
;
1368 memset (&std_regs
[i
], 0, sizeof (std_regs
[i
]));
1372 _initialize_parse (void)
1374 type_stack_size
= 80;
1375 type_stack_depth
= 0;
1376 type_stack
= (union type_stack_elt
*)
1377 xmalloc (type_stack_size
* sizeof (*type_stack
));
1381 /* FIXME - For the moment, handle types by swapping them in and out.
1382 Should be using the per-architecture data-pointer and a large
1384 register_gdbarch_swap (&msym_text_symbol_type
, sizeof (msym_text_symbol_type
), NULL
);
1385 register_gdbarch_swap (&msym_data_symbol_type
, sizeof (msym_data_symbol_type
), NULL
);
1386 register_gdbarch_swap (&msym_unknown_symbol_type
, sizeof (msym_unknown_symbol_type
), NULL
);
1388 register_gdbarch_swap (&num_std_regs
, sizeof (std_regs
), NULL
);
1389 register_gdbarch_swap (&std_regs
, sizeof (std_regs
), NULL
);
1390 register_gdbarch_swap (NULL
, 0, build_parse
);
1393 add_set_cmd ("expression", class_maintenance
, var_zinteger
,
1394 (char *) &expressiondebug
,
1395 "Set expression debugging.\n\
1396 When non-zero, the internal representation of expressions will be printed.",