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 "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 CORE_ADDR expression_context_pc
;
75 struct block
*innermost_block
;
77 union type_stack_elt
*type_stack
;
78 int type_stack_depth
, type_stack_size
;
85 static int expressiondebug
= 0;
87 extern int hp_som_som_object_present
;
89 static void free_funcalls (void *ignore
);
91 static void prefixify_expression (struct expression
*);
93 static void prefixify_subexp (struct expression
*, struct expression
*, int,
96 void _initialize_parse (void);
98 /* Data structure for saving values of arglist_len for function calls whose
99 arguments contain other function calls. */
103 struct funcall
*next
;
107 static struct funcall
*funcall_chain
;
109 /* Begin counting arguments for a function call,
110 saving the data about any containing call. */
117 new = (struct funcall
*) xmalloc (sizeof (struct funcall
));
118 new->next
= funcall_chain
;
119 new->arglist_len
= arglist_len
;
124 /* Return the number of arguments in a function call just terminated,
125 and restore the data for the containing function call. */
130 int val
= arglist_len
;
131 struct funcall
*call
= funcall_chain
;
132 funcall_chain
= call
->next
;
133 arglist_len
= call
->arglist_len
;
138 /* Free everything in the funcall chain.
139 Used when there is an error inside parsing. */
142 free_funcalls (void *ignore
)
144 struct funcall
*call
, *next
;
146 for (call
= funcall_chain
; call
; call
= next
)
153 /* This page contains the functions for adding data to the struct expression
154 being constructed. */
156 /* Add one element to the end of the expression. */
158 /* To avoid a bug in the Sun 4 compiler, we pass things that can fit into
159 a register through here */
162 write_exp_elt (union exp_element expelt
)
164 if (expout_ptr
>= expout_size
)
167 expout
= (struct expression
*)
168 xrealloc ((char *) expout
, sizeof (struct expression
)
169 + EXP_ELEM_TO_BYTES (expout_size
));
171 expout
->elts
[expout_ptr
++] = expelt
;
175 write_exp_elt_opcode (enum exp_opcode expelt
)
177 union exp_element tmp
;
185 write_exp_elt_sym (struct symbol
*expelt
)
187 union exp_element tmp
;
195 write_exp_elt_block (struct block
*b
)
197 union exp_element tmp
;
203 write_exp_elt_longcst (LONGEST expelt
)
205 union exp_element tmp
;
207 tmp
.longconst
= expelt
;
213 write_exp_elt_dblcst (DOUBLEST expelt
)
215 union exp_element tmp
;
217 tmp
.doubleconst
= expelt
;
223 write_exp_elt_type (struct type
*expelt
)
225 union exp_element tmp
;
233 write_exp_elt_intern (struct internalvar
*expelt
)
235 union exp_element tmp
;
237 tmp
.internalvar
= expelt
;
242 /* Add a string constant to the end of the expression.
244 String constants are stored by first writing an expression element
245 that contains the length of the string, then stuffing the string
246 constant itself into however many expression elements are needed
247 to hold it, and then writing another expression element that contains
248 the length of the string. I.E. an expression element at each end of
249 the string records the string length, so you can skip over the
250 expression elements containing the actual string bytes from either
251 end of the string. Note that this also allows gdb to handle
252 strings with embedded null bytes, as is required for some languages.
254 Don't be fooled by the fact that the string is null byte terminated,
255 this is strictly for the convenience of debugging gdb itself. Gdb
256 Gdb does not depend up the string being null terminated, since the
257 actual length is recorded in expression elements at each end of the
258 string. The null byte is taken into consideration when computing how
259 many expression elements are required to hold the string constant, of
264 write_exp_string (struct stoken str
)
266 int len
= str
.length
;
270 /* Compute the number of expression elements required to hold the string
271 (including a null byte terminator), along with one expression element
272 at each end to record the actual string length (not including the
273 null byte terminator). */
275 lenelt
= 2 + BYTES_TO_EXP_ELEM (len
+ 1);
277 /* Ensure that we have enough available expression elements to store
280 if ((expout_ptr
+ lenelt
) >= expout_size
)
282 expout_size
= max (expout_size
* 2, expout_ptr
+ lenelt
+ 10);
283 expout
= (struct expression
*)
284 xrealloc ((char *) expout
, (sizeof (struct expression
)
285 + EXP_ELEM_TO_BYTES (expout_size
)));
288 /* Write the leading length expression element (which advances the current
289 expression element index), then write the string constant followed by a
290 terminating null byte, and then write the trailing length expression
293 write_exp_elt_longcst ((LONGEST
) len
);
294 strdata
= (char *) &expout
->elts
[expout_ptr
];
295 memcpy (strdata
, str
.ptr
, len
);
296 *(strdata
+ len
) = '\0';
297 expout_ptr
+= lenelt
- 2;
298 write_exp_elt_longcst ((LONGEST
) len
);
301 /* Add a bitstring constant to the end of the expression.
303 Bitstring constants are stored by first writing an expression element
304 that contains the length of the bitstring (in bits), then stuffing the
305 bitstring constant itself into however many expression elements are
306 needed to hold it, and then writing another expression element that
307 contains the length of the bitstring. I.E. an expression element at
308 each end of the bitstring records the bitstring length, so you can skip
309 over the expression elements containing the actual bitstring bytes from
310 either end of the bitstring. */
313 write_exp_bitstring (struct stoken str
)
315 int bits
= str
.length
; /* length in bits */
316 int len
= (bits
+ HOST_CHAR_BIT
- 1) / HOST_CHAR_BIT
;
320 /* Compute the number of expression elements required to hold the bitstring,
321 along with one expression element at each end to record the actual
322 bitstring length in bits. */
324 lenelt
= 2 + BYTES_TO_EXP_ELEM (len
);
326 /* Ensure that we have enough available expression elements to store
329 if ((expout_ptr
+ lenelt
) >= expout_size
)
331 expout_size
= max (expout_size
* 2, expout_ptr
+ lenelt
+ 10);
332 expout
= (struct expression
*)
333 xrealloc ((char *) expout
, (sizeof (struct expression
)
334 + EXP_ELEM_TO_BYTES (expout_size
)));
337 /* Write the leading length expression element (which advances the current
338 expression element index), then write the bitstring constant, and then
339 write the trailing length expression element. */
341 write_exp_elt_longcst ((LONGEST
) bits
);
342 strdata
= (char *) &expout
->elts
[expout_ptr
];
343 memcpy (strdata
, str
.ptr
, len
);
344 expout_ptr
+= lenelt
- 2;
345 write_exp_elt_longcst ((LONGEST
) bits
);
348 /* Add the appropriate elements for a minimal symbol to the end of
349 the expression. The rationale behind passing in text_symbol_type and
350 data_symbol_type was so that Modula-2 could pass in WORD for
351 data_symbol_type. Perhaps it still is useful to have those types vary
352 based on the language, but they no longer have names like "int", so
353 the initial rationale is gone. */
355 static struct type
*msym_text_symbol_type
;
356 static struct type
*msym_data_symbol_type
;
357 static struct type
*msym_unknown_symbol_type
;
360 write_exp_msymbol (struct minimal_symbol
*msymbol
,
361 struct type
*text_symbol_type
,
362 struct type
*data_symbol_type
)
366 write_exp_elt_opcode (OP_LONG
);
367 /* Let's make the type big enough to hold a 64-bit address. */
368 write_exp_elt_type (builtin_type_CORE_ADDR
);
370 addr
= SYMBOL_VALUE_ADDRESS (msymbol
);
371 if (overlay_debugging
)
372 addr
= symbol_overlayed_address (addr
, SYMBOL_BFD_SECTION (msymbol
));
373 write_exp_elt_longcst ((LONGEST
) addr
);
375 write_exp_elt_opcode (OP_LONG
);
377 write_exp_elt_opcode (UNOP_MEMVAL
);
378 switch (msymbol
->type
)
382 case mst_solib_trampoline
:
383 write_exp_elt_type (msym_text_symbol_type
);
390 write_exp_elt_type (msym_data_symbol_type
);
394 write_exp_elt_type (msym_unknown_symbol_type
);
397 write_exp_elt_opcode (UNOP_MEMVAL
);
400 /* Recognize tokens that start with '$'. These include:
402 $regname A native register name or a "standard
405 $variable A convenience variable with a name chosen
408 $digits Value history with index <digits>, starting
409 from the first value which has index 1.
411 $$digits Value history with index <digits> relative
412 to the last value. I.E. $$0 is the last
413 value, $$1 is the one previous to that, $$2
414 is the one previous to $$1, etc.
416 $ | $0 | $$0 The last value in the value history.
418 $$ An abbreviation for the second to the last
419 value in the value history, I.E. $$1
424 write_dollar_variable (struct stoken str
)
426 /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
427 and $$digits (equivalent to $<-digits> if you could type that). */
431 /* Double dollar means negate the number and add -1 as well.
432 Thus $$ alone means -1. */
433 if (str
.length
>= 2 && str
.ptr
[1] == '$')
440 /* Just dollars (one or two) */
444 /* Is the rest of the token digits? */
445 for (; i
< str
.length
; i
++)
446 if (!(str
.ptr
[i
] >= '0' && str
.ptr
[i
] <= '9'))
450 i
= atoi (str
.ptr
+ 1 + negate
);
456 /* Handle tokens that refer to machine registers:
457 $ followed by a register name. */
458 i
= frame_map_name_to_regnum (deprecated_selected_frame
,
459 str
.ptr
+ 1, str
.length
- 1);
461 goto handle_register
;
463 if (SYMBOLS_CAN_START_WITH_DOLLAR
)
465 struct symbol
*sym
= NULL
;
466 struct minimal_symbol
*msym
= NULL
;
468 /* On HP-UX, certain system routines (millicode) have names beginning
469 with $ or $$, e.g. $$dyncall, which handles inter-space procedure
470 calls on PA-RISC. Check for those, first. */
472 /* This code is not enabled on non HP-UX systems, since worst case
473 symbol table lookup performance is awful, to put it mildly. */
475 sym
= lookup_symbol (copy_name (str
), (struct block
*) NULL
,
476 VAR_DOMAIN
, (int *) NULL
, (struct symtab
**) NULL
);
479 write_exp_elt_opcode (OP_VAR_VALUE
);
480 write_exp_elt_block (block_found
); /* set by lookup_symbol */
481 write_exp_elt_sym (sym
);
482 write_exp_elt_opcode (OP_VAR_VALUE
);
485 msym
= lookup_minimal_symbol (copy_name (str
), NULL
, NULL
);
488 write_exp_msymbol (msym
,
489 lookup_function_type (builtin_type_int
),
495 /* Any other names starting in $ are debugger internal variables. */
497 write_exp_elt_opcode (OP_INTERNALVAR
);
498 write_exp_elt_intern (lookup_internalvar (copy_name (str
) + 1));
499 write_exp_elt_opcode (OP_INTERNALVAR
);
502 write_exp_elt_opcode (OP_LAST
);
503 write_exp_elt_longcst ((LONGEST
) i
);
504 write_exp_elt_opcode (OP_LAST
);
507 write_exp_elt_opcode (OP_REGISTER
);
508 write_exp_elt_longcst (i
);
509 write_exp_elt_opcode (OP_REGISTER
);
514 /* Parse a string that is possibly a namespace / nested class
515 specification, i.e., something of the form A::B::C::x. Input
516 (NAME) is the entire string; LEN is the current valid length; the
517 output is a string, TOKEN, which points to the largest recognized
518 prefix which is a series of namespaces or classes. CLASS_PREFIX is
519 another output, which records whether a nested class spec was
520 recognized (= 1) or a fully qualified variable name was found (=
521 0). ARGPTR is side-effected (if non-NULL) to point to beyond the
522 string recognized and consumed by this routine.
524 The return value is a pointer to the symbol for the base class or
525 variable if found, or NULL if not found. Callers must check this
526 first -- if NULL, the outputs may not be correct.
528 This function is used c-exp.y. This is used specifically to get
529 around HP aCC (and possibly other compilers), which insists on
530 generating names with embedded colons for namespace or nested class
533 (Argument LEN is currently unused. 1997-08-27)
535 Callers must free memory allocated for the output string TOKEN. */
537 static const char coloncolon
[2] =
541 parse_nested_classes_for_hpacc (char *name
, int len
, char **token
,
542 int *class_prefix
, char **argptr
)
544 /* Comment below comes from decode_line_1 which has very similar
545 code, which is called for "break" command parsing. */
547 /* We have what looks like a class or namespace
548 scope specification (A::B), possibly with many
549 levels of namespaces or classes (A::B::C::D).
551 Some versions of the HP ANSI C++ compiler (as also possibly
552 other compilers) generate class/function/member names with
553 embedded double-colons if they are inside namespaces. To
554 handle this, we loop a few times, considering larger and
555 larger prefixes of the string as though they were single
556 symbols. So, if the initially supplied string is
557 A::B::C::D::foo, we have to look up "A", then "A::B",
558 then "A::B::C", then "A::B::C::D", and finally
559 "A::B::C::D::foo" as single, monolithic symbols, because
560 A, B, C or D may be namespaces.
562 Note that namespaces can nest only inside other
563 namespaces, and not inside classes. So we need only
564 consider *prefixes* of the string; there is no need to look up
565 "B::C" separately as a symbol in the previous example. */
571 struct symbol
*sym_class
= NULL
;
572 struct symbol
*sym_var
= NULL
;
578 /* Check for HP-compiled executable -- in other cases
579 return NULL, and caller must default to standard GDB
582 if (!hp_som_som_object_present
)
583 return (struct symbol
*) NULL
;
587 /* Skip over whitespace and possible global "::" */
588 while (*p
&& (*p
== ' ' || *p
== '\t'))
590 if (p
[0] == ':' && p
[1] == ':')
592 while (*p
&& (*p
== ' ' || *p
== '\t'))
597 /* Get to the end of the next namespace or class spec. */
598 /* If we're looking at some non-token, fail immediately */
600 if (!(isalpha (*p
) || *p
== '$' || *p
== '_'))
601 return (struct symbol
*) NULL
;
603 while (*p
&& (isalnum (*p
) || *p
== '$' || *p
== '_'))
608 /* If we have the start of a template specification,
609 scan right ahead to its end */
610 q
= find_template_name_end (p
);
617 /* Skip over "::" and whitespace for next time around */
618 while (*p
&& (*p
== ' ' || *p
== '\t'))
620 if (p
[0] == ':' && p
[1] == ':')
622 while (*p
&& (*p
== ' ' || *p
== '\t'))
625 /* Done with tokens? */
626 if (!*p
|| !(isalpha (*p
) || *p
== '$' || *p
== '_'))
629 tmp
= (char *) alloca (prefix_len
+ end
- start
+ 3);
632 memcpy (tmp
, prefix
, prefix_len
);
633 memcpy (tmp
+ prefix_len
, coloncolon
, 2);
634 memcpy (tmp
+ prefix_len
+ 2, start
, end
- start
);
635 tmp
[prefix_len
+ 2 + end
- start
] = '\000';
639 memcpy (tmp
, start
, end
- start
);
640 tmp
[end
- start
] = '\000';
644 prefix_len
= strlen (prefix
);
646 /* See if the prefix we have now is something we know about */
650 /* More tokens to process, so this must be a class/namespace */
651 sym_class
= lookup_symbol (prefix
, 0, STRUCT_DOMAIN
,
652 0, (struct symtab
**) NULL
);
656 /* No more tokens, so try as a variable first */
657 sym_var
= lookup_symbol (prefix
, 0, VAR_DOMAIN
,
658 0, (struct symtab
**) NULL
);
659 /* If failed, try as class/namespace */
661 sym_class
= lookup_symbol (prefix
, 0, STRUCT_DOMAIN
,
662 0, (struct symtab
**) NULL
);
667 (t
= check_typedef (SYMBOL_TYPE (sym_class
)),
668 (TYPE_CODE (t
) == TYPE_CODE_STRUCT
669 || TYPE_CODE (t
) == TYPE_CODE_UNION
))))
671 /* We found a valid token */
672 *token
= (char *) xmalloc (prefix_len
+ 1);
673 memcpy (*token
, prefix
, prefix_len
);
674 (*token
)[prefix_len
] = '\000';
678 /* No variable or class/namespace found, no more tokens */
680 return (struct symbol
*) NULL
;
683 /* Out of loop, so we must have found a valid token */
690 *argptr
= done
? p
: end
;
692 return sym_var
? sym_var
: sym_class
; /* found */
696 find_template_name_end (char *p
)
699 int just_seen_right
= 0;
700 int just_seen_colon
= 0;
701 int just_seen_space
= 0;
703 if (!p
|| (*p
!= '<'))
714 /* In future, may want to allow these?? */
717 depth
++; /* start nested template */
718 if (just_seen_colon
|| just_seen_right
|| just_seen_space
)
719 return 0; /* but not after : or :: or > or space */
722 if (just_seen_colon
|| just_seen_right
)
723 return 0; /* end a (nested?) template */
724 just_seen_right
= 1; /* but not after : or :: */
725 if (--depth
== 0) /* also disallow >>, insist on > > */
726 return ++p
; /* if outermost ended, return */
729 if (just_seen_space
|| (just_seen_colon
> 1))
730 return 0; /* nested class spec coming up */
731 just_seen_colon
++; /* we allow :: but not :::: */
736 if (!((*p
>= 'a' && *p
<= 'z') || /* allow token chars */
737 (*p
>= 'A' && *p
<= 'Z') ||
738 (*p
>= '0' && *p
<= '9') ||
739 (*p
== '_') || (*p
== ',') || /* commas for template args */
740 (*p
== '&') || (*p
== '*') || /* pointer and ref types */
741 (*p
== '(') || (*p
== ')') || /* function types */
742 (*p
== '[') || (*p
== ']'))) /* array types */
757 /* Return a null-terminated temporary copy of the name
758 of a string token. */
761 copy_name (struct stoken token
)
763 memcpy (namecopy
, token
.ptr
, token
.length
);
764 namecopy
[token
.length
] = 0;
768 /* Reverse an expression from suffix form (in which it is constructed)
769 to prefix form (in which we can conveniently print or execute it). */
772 prefixify_expression (struct expression
*expr
)
775 sizeof (struct expression
) + EXP_ELEM_TO_BYTES (expr
->nelts
);
776 struct expression
*temp
;
777 int inpos
= expr
->nelts
, outpos
= 0;
779 temp
= (struct expression
*) alloca (len
);
781 /* Copy the original expression into temp. */
782 memcpy (temp
, expr
, len
);
784 prefixify_subexp (temp
, expr
, inpos
, outpos
);
787 /* Return the number of exp_elements in the subexpression of EXPR
788 whose last exp_element is at index ENDPOS - 1 in EXPR. */
791 length_of_subexp (struct expression
*expr
, int endpos
)
798 error ("?error in length_of_subexp");
800 i
= (int) expr
->elts
[endpos
- 1].opcode
;
806 oplen
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
807 oplen
= 5 + BYTES_TO_EXP_ELEM (oplen
+ 1);
830 case OP_F77_UNDETERMINED_ARGLIST
:
832 args
= 1 + longest_to_int (expr
->elts
[endpos
- 2].longconst
);
835 case OP_OBJC_MSGCALL
: /* Objective C message (method) call */
837 args
= 1 + longest_to_int (expr
->elts
[endpos
- 2].longconst
);
865 case STRUCTOP_STRUCT
:
871 case OP_OBJC_NSSTRING
: /* Objective C Foundation Class NSString constant */
872 case OP_OBJC_SELECTOR
: /* Objective C "@selector" pseudo-op */
875 oplen
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
876 oplen
= 4 + BYTES_TO_EXP_ELEM (oplen
+ 1);
880 oplen
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
881 oplen
= (oplen
+ HOST_CHAR_BIT
- 1) / HOST_CHAR_BIT
;
882 oplen
= 4 + BYTES_TO_EXP_ELEM (oplen
);
887 args
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
888 args
-= longest_to_int (expr
->elts
[endpos
- 3].longconst
);
894 case TERNOP_SLICE_COUNT
:
899 case MULTI_SUBSCRIPT
:
901 args
= 1 + longest_to_int (expr
->elts
[endpos
- 2].longconst
);
904 case BINOP_ASSIGN_MODIFY
:
916 args
= 1 + (i
< (int) BINOP_END
);
921 oplen
+= length_of_subexp (expr
, endpos
- oplen
);
928 /* Copy the subexpression ending just before index INEND in INEXPR
929 into OUTEXPR, starting at index OUTBEG.
930 In the process, convert it from suffix to prefix form. */
933 prefixify_subexp (struct expression
*inexpr
,
934 struct expression
*outexpr
, int inend
, int outbeg
)
940 enum exp_opcode opcode
;
942 /* Compute how long the last operation is (in OPLEN),
943 and also how many preceding subexpressions serve as
944 arguments for it (in ARGS). */
946 opcode
= inexpr
->elts
[inend
- 1].opcode
;
951 oplen
= longest_to_int (inexpr
->elts
[inend
- 2].longconst
);
952 oplen
= 5 + BYTES_TO_EXP_ELEM (oplen
+ 1);
975 case OP_F77_UNDETERMINED_ARGLIST
:
977 args
= 1 + longest_to_int (inexpr
->elts
[inend
- 2].longconst
);
980 case OP_OBJC_MSGCALL
: /* Objective C message (method) call */
982 args
= 1 + longest_to_int (inexpr
->elts
[inend
- 2].longconst
);
1008 case STRUCTOP_STRUCT
:
1015 case OP_OBJC_NSSTRING
: /* Objective C Foundation Class NSString constant */
1016 case OP_OBJC_SELECTOR
: /* Objective C "@selector" pseudo-op */
1019 oplen
= longest_to_int (inexpr
->elts
[inend
- 2].longconst
);
1020 oplen
= 4 + BYTES_TO_EXP_ELEM (oplen
+ 1);
1024 oplen
= longest_to_int (inexpr
->elts
[inend
- 2].longconst
);
1025 oplen
= (oplen
+ HOST_CHAR_BIT
- 1) / HOST_CHAR_BIT
;
1026 oplen
= 4 + BYTES_TO_EXP_ELEM (oplen
);
1031 args
= longest_to_int (inexpr
->elts
[inend
- 2].longconst
);
1032 args
-= longest_to_int (inexpr
->elts
[inend
- 3].longconst
);
1038 case TERNOP_SLICE_COUNT
:
1042 case BINOP_ASSIGN_MODIFY
:
1048 case MULTI_SUBSCRIPT
:
1050 args
= 1 + longest_to_int (inexpr
->elts
[inend
- 2].longconst
);
1060 args
= 1 + ((int) opcode
< (int) BINOP_END
);
1063 /* Copy the final operator itself, from the end of the input
1064 to the beginning of the output. */
1066 memcpy (&outexpr
->elts
[outbeg
], &inexpr
->elts
[inend
],
1067 EXP_ELEM_TO_BYTES (oplen
));
1070 /* Find the lengths of the arg subexpressions. */
1071 arglens
= (int *) alloca (args
* sizeof (int));
1072 for (i
= args
- 1; i
>= 0; i
--)
1074 oplen
= length_of_subexp (inexpr
, inend
);
1079 /* Now copy each subexpression, preserving the order of
1080 the subexpressions, but prefixifying each one.
1081 In this loop, inend starts at the beginning of
1082 the expression this level is working on
1083 and marches forward over the arguments.
1084 outbeg does similarly in the output. */
1085 for (i
= 0; i
< args
; i
++)
1089 prefixify_subexp (inexpr
, outexpr
, inend
, outbeg
);
1094 /* This page contains the two entry points to this file. */
1096 /* Read an expression from the string *STRINGPTR points to,
1097 parse it, and return a pointer to a struct expression that we malloc.
1098 Use block BLOCK as the lexical context for variable names;
1099 if BLOCK is zero, use the block of the selected stack frame.
1100 Meanwhile, advance *STRINGPTR to point after the expression,
1101 at the first nonwhite character that is not part of the expression
1102 (possibly a null character).
1104 If COMMA is nonzero, stop if a comma is reached. */
1107 parse_exp_1 (char **stringptr
, struct block
*block
, int comma
)
1109 struct cleanup
*old_chain
;
1111 lexptr
= *stringptr
;
1115 type_stack_depth
= 0;
1117 comma_terminates
= comma
;
1119 if (lexptr
== 0 || *lexptr
== 0)
1120 error_no_arg ("expression to compute");
1122 old_chain
= make_cleanup (free_funcalls
, 0 /*ignore*/);
1127 expression_context_block
= block
;
1128 expression_context_pc
= BLOCK_START (block
);
1131 expression_context_block
= get_selected_block (&expression_context_pc
);
1133 namecopy
= (char *) alloca (strlen (lexptr
) + 1);
1136 expout
= (struct expression
*)
1137 xmalloc (sizeof (struct expression
) + EXP_ELEM_TO_BYTES (expout_size
));
1138 expout
->language_defn
= current_language
;
1139 make_cleanup (free_current_contents
, &expout
);
1141 if (current_language
->la_parser ())
1142 current_language
->la_error (NULL
);
1144 discard_cleanups (old_chain
);
1146 /* Record the actual number of expression elements, and then
1147 reallocate the expression memory so that we free up any
1150 expout
->nelts
= expout_ptr
;
1151 expout
= (struct expression
*)
1152 xrealloc ((char *) expout
,
1153 sizeof (struct expression
) + EXP_ELEM_TO_BYTES (expout_ptr
));;
1155 /* Convert expression from postfix form as generated by yacc
1156 parser, to a prefix form. */
1158 if (expressiondebug
)
1159 dump_prefix_expression (expout
, gdb_stdlog
,
1160 "before conversion to prefix form");
1162 prefixify_expression (expout
);
1164 if (expressiondebug
)
1165 dump_postfix_expression (expout
, gdb_stdlog
,
1166 "after conversion to prefix form");
1168 *stringptr
= lexptr
;
1172 /* Parse STRING as an expression, and complain if this fails
1173 to use up all of the contents of STRING. */
1176 parse_expression (char *string
)
1178 struct expression
*exp
;
1179 exp
= parse_exp_1 (&string
, 0, 0);
1181 error ("Junk after end of expression.");
1185 /* Stuff for maintaining a stack of types. Currently just used by C, but
1186 probably useful for any language which declares its types "backwards". */
1189 check_type_stack_depth (void)
1191 if (type_stack_depth
== type_stack_size
)
1193 type_stack_size
*= 2;
1194 type_stack
= (union type_stack_elt
*)
1195 xrealloc ((char *) type_stack
, type_stack_size
* sizeof (*type_stack
));
1200 push_type (enum type_pieces tp
)
1202 check_type_stack_depth ();
1203 type_stack
[type_stack_depth
++].piece
= tp
;
1207 push_type_int (int n
)
1209 check_type_stack_depth ();
1210 type_stack
[type_stack_depth
++].int_val
= n
;
1214 push_type_address_space (char *string
)
1216 push_type_int (address_space_name_to_int (string
));
1222 if (type_stack_depth
)
1223 return type_stack
[--type_stack_depth
].piece
;
1230 if (type_stack_depth
)
1231 return type_stack
[--type_stack_depth
].int_val
;
1232 /* "Can't happen". */
1236 /* Pop the type stack and return the type which corresponds to FOLLOW_TYPE
1237 as modified by all the stuff on the stack. */
1239 follow_types (struct type
*follow_type
)
1243 int make_volatile
= 0;
1244 int make_addr_space
= 0;
1246 struct type
*range_type
;
1249 switch (pop_type ())
1254 follow_type
= make_cv_type (make_const
,
1255 TYPE_VOLATILE (follow_type
),
1258 follow_type
= make_cv_type (TYPE_CONST (follow_type
),
1261 if (make_addr_space
)
1262 follow_type
= make_type_with_address_space (follow_type
,
1264 make_const
= make_volatile
= 0;
1265 make_addr_space
= 0;
1273 case tp_space_identifier
:
1274 make_addr_space
= pop_type_int ();
1277 follow_type
= lookup_pointer_type (follow_type
);
1279 follow_type
= make_cv_type (make_const
,
1280 TYPE_VOLATILE (follow_type
),
1283 follow_type
= make_cv_type (TYPE_CONST (follow_type
),
1286 if (make_addr_space
)
1287 follow_type
= make_type_with_address_space (follow_type
,
1289 make_const
= make_volatile
= 0;
1290 make_addr_space
= 0;
1293 follow_type
= lookup_reference_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 array_size
= pop_type_int ();
1310 /* FIXME-type-allocation: need a way to free this type when we are
1313 create_range_type ((struct type
*) NULL
,
1314 builtin_type_int
, 0,
1315 array_size
>= 0 ? array_size
- 1 : 0);
1317 create_array_type ((struct type
*) NULL
,
1318 follow_type
, range_type
);
1320 TYPE_ARRAY_UPPER_BOUND_TYPE (follow_type
)
1321 = BOUND_CANNOT_BE_DETERMINED
;
1324 /* FIXME-type-allocation: need a way to free this type when we are
1326 follow_type
= lookup_function_type (follow_type
);
1332 static void build_parse (void);
1338 msym_text_symbol_type
=
1339 init_type (TYPE_CODE_FUNC
, 1, 0, "<text variable, no debug info>", NULL
);
1340 TYPE_TARGET_TYPE (msym_text_symbol_type
) = builtin_type_int
;
1341 msym_data_symbol_type
=
1342 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ HOST_CHAR_BIT
, 0,
1343 "<data variable, no debug info>", NULL
);
1344 msym_unknown_symbol_type
=
1345 init_type (TYPE_CODE_INT
, 1, 0,
1346 "<variable (not text or data), no debug info>",
1350 /* This function avoids direct calls to fprintf
1351 in the parser generated debug code. */
1353 parser_fprintf (FILE *x
, const char *y
, ...)
1358 vfprintf_unfiltered (gdb_stderr
, y
, args
);
1361 fprintf_unfiltered (gdb_stderr
, " Unknown FILE used.\n");
1362 vfprintf_unfiltered (gdb_stderr
, y
, args
);
1368 _initialize_parse (void)
1370 type_stack_size
= 80;
1371 type_stack_depth
= 0;
1372 type_stack
= (union type_stack_elt
*)
1373 xmalloc (type_stack_size
* sizeof (*type_stack
));
1377 /* FIXME - For the moment, handle types by swapping them in and out.
1378 Should be using the per-architecture data-pointer and a large
1380 register_gdbarch_swap (&msym_text_symbol_type
, sizeof (msym_text_symbol_type
), NULL
);
1381 register_gdbarch_swap (&msym_data_symbol_type
, sizeof (msym_data_symbol_type
), NULL
);
1382 register_gdbarch_swap (&msym_unknown_symbol_type
, sizeof (msym_unknown_symbol_type
), NULL
);
1384 register_gdbarch_swap (NULL
, 0, build_parse
);
1387 add_set_cmd ("expression", class_maintenance
, var_zinteger
,
1388 (char *) &expressiondebug
,
1389 "Set expression debugging.\n\
1390 When non-zero, the internal representation of expressions will be printed.",