1 /* Parse expressions for GDB.
2 Copyright (C) 1986, 1989, 1990, 1991, 1994 Free Software Foundation, Inc.
3 Modified from expread.y by the Department of Computer Science at the
4 State University of New York at Buffalo, 1991.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
22 /* Parse an expression from text in a string,
23 and return the result as a struct expression pointer.
24 That structure contains arithmetic operations in reverse polish,
25 with constants represented by operations that are followed by special data.
26 See expression.h for the details of the format.
27 What is important here is that it can be built up sequentially
28 during the process of parsing; the lower levels of the tree always
29 come first in the result. */
32 #include "gdb_string.h"
36 #include "expression.h"
40 #include "parser-defs.h"
42 /* Global variables declared in parser-defs.h (and commented there). */
43 struct expression *expout;
46 struct block *expression_context_block;
47 struct block *innermost_block;
49 union type_stack_elt *type_stack;
50 int type_stack_depth, type_stack_size;
57 free_funcalls PARAMS ((void));
60 prefixify_expression PARAMS ((struct expression *));
63 length_of_subexp PARAMS ((struct expression *, int));
66 prefixify_subexp PARAMS ((struct expression *, struct expression *, int, int));
68 /* Data structure for saving values of arglist_len for function calls whose
69 arguments contain other function calls. */
77 static struct funcall *funcall_chain;
79 /* Assign machine-independent names to certain registers
80 (unless overridden by the REGISTER_NAMES table) */
83 unsigned num_std_regs = 0;
84 struct std_regs std_regs[1];
86 struct std_regs std_regs[] = {
103 unsigned num_std_regs = (sizeof std_regs / sizeof std_regs[0]);
108 /* Begin counting arguments for a function call,
109 saving the data about any containing call. */
114 register struct funcall *new;
116 new = (struct funcall *) xmalloc (sizeof (struct funcall));
117 new->next = funcall_chain;
118 new->arglist_len = arglist_len;
123 /* Return the number of arguments in a function call just terminated,
124 and restore the data for the containing function call. */
129 register int val = arglist_len;
130 register struct funcall *call = funcall_chain;
131 funcall_chain = call->next;
132 arglist_len = call->arglist_len;
137 /* Free everything in the funcall chain.
138 Used when there is an error inside parsing. */
143 register struct funcall *call, *next;
145 for (call = funcall_chain; call; call = next)
152 /* This page contains the functions for adding data to the struct expression
153 being constructed. */
155 /* Add one element to the end of the expression. */
157 /* To avoid a bug in the Sun 4 compiler, we pass things that can fit into
158 a register through here */
161 write_exp_elt (expelt)
162 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 (expelt)
176 enum exp_opcode expelt;
178 union exp_element tmp;
186 write_exp_elt_sym (expelt)
187 struct symbol *expelt;
189 union exp_element tmp;
197 write_exp_elt_block (b)
200 union exp_element tmp;
206 write_exp_elt_longcst (expelt)
209 union exp_element tmp;
211 tmp.longconst = expelt;
217 write_exp_elt_dblcst (expelt)
220 union exp_element tmp;
222 tmp.doubleconst = expelt;
228 write_exp_elt_type (expelt)
231 union exp_element tmp;
239 write_exp_elt_intern (expelt)
240 struct internalvar *expelt;
242 union exp_element tmp;
244 tmp.internalvar = expelt;
249 /* Add a string constant to the end of the expression.
251 String constants are stored by first writing an expression element
252 that contains the length of the string, then stuffing the string
253 constant itself into however many expression elements are needed
254 to hold it, and then writing another expression element that contains
255 the length of the string. I.E. an expression element at each end of
256 the string records the string length, so you can skip over the
257 expression elements containing the actual string bytes from either
258 end of the string. Note that this also allows gdb to handle
259 strings with embedded null bytes, as is required for some languages.
261 Don't be fooled by the fact that the string is null byte terminated,
262 this is strictly for the convenience of debugging gdb itself. Gdb
263 Gdb does not depend up the string being null terminated, since the
264 actual length is recorded in expression elements at each end of the
265 string. The null byte is taken into consideration when computing how
266 many expression elements are required to hold the string constant, of
271 write_exp_string (str)
274 register int len = str.length;
276 register char *strdata;
278 /* Compute the number of expression elements required to hold the string
279 (including a null byte terminator), along with one expression element
280 at each end to record the actual string length (not including the
281 null byte terminator). */
283 lenelt = 2 + BYTES_TO_EXP_ELEM (len + 1);
285 /* Ensure that we have enough available expression elements to store
288 if ((expout_ptr + lenelt) >= expout_size)
290 expout_size = max (expout_size * 2, expout_ptr + lenelt + 10);
291 expout = (struct expression *)
292 xrealloc ((char *) expout, (sizeof (struct expression)
293 + EXP_ELEM_TO_BYTES (expout_size)));
296 /* Write the leading length expression element (which advances the current
297 expression element index), then write the string constant followed by a
298 terminating null byte, and then write the trailing length expression
301 write_exp_elt_longcst ((LONGEST) len);
302 strdata = (char *) &expout->elts[expout_ptr];
303 memcpy (strdata, str.ptr, len);
304 *(strdata + len) = '\0';
305 expout_ptr += lenelt - 2;
306 write_exp_elt_longcst ((LONGEST) len);
309 /* Add a bitstring constant to the end of the expression.
311 Bitstring constants are stored by first writing an expression element
312 that contains the length of the bitstring (in bits), then stuffing the
313 bitstring constant itself into however many expression elements are
314 needed to hold it, and then writing another expression element that
315 contains the length of the bitstring. I.E. an expression element at
316 each end of the bitstring records the bitstring length, so you can skip
317 over the expression elements containing the actual bitstring bytes from
318 either end of the bitstring. */
321 write_exp_bitstring (str)
324 register int bits = str.length; /* length in bits */
325 register int len = (bits + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
327 register char *strdata;
329 /* Compute the number of expression elements required to hold the bitstring,
330 along with one expression element at each end to record the actual
331 bitstring length in bits. */
333 lenelt = 2 + BYTES_TO_EXP_ELEM (len);
335 /* Ensure that we have enough available expression elements to store
338 if ((expout_ptr + lenelt) >= expout_size)
340 expout_size = max (expout_size * 2, expout_ptr + lenelt + 10);
341 expout = (struct expression *)
342 xrealloc ((char *) expout, (sizeof (struct expression)
343 + EXP_ELEM_TO_BYTES (expout_size)));
346 /* Write the leading length expression element (which advances the current
347 expression element index), then write the bitstring constant, and then
348 write the trailing length expression element. */
350 write_exp_elt_longcst ((LONGEST) bits);
351 strdata = (char *) &expout->elts[expout_ptr];
352 memcpy (strdata, str.ptr, len);
353 expout_ptr += lenelt - 2;
354 write_exp_elt_longcst ((LONGEST) bits);
357 /* Add the appropriate elements for a minimal symbol to the end of
358 the expression. The rationale behind passing in text_symbol_type and
359 data_symbol_type was so that Modula-2 could pass in WORD for
360 data_symbol_type. Perhaps it still is useful to have those types vary
361 based on the language, but they no longer have names like "int", so
362 the initial rationale is gone. */
364 static struct type *msym_text_symbol_type;
365 static struct type *msym_data_symbol_type;
366 static struct type *msym_unknown_symbol_type;
369 write_exp_msymbol (msymbol, text_symbol_type, data_symbol_type)
370 struct minimal_symbol *msymbol;
371 struct type *text_symbol_type;
372 struct type *data_symbol_type;
374 write_exp_elt_opcode (OP_LONG);
375 write_exp_elt_type (lookup_pointer_type (builtin_type_void));
376 write_exp_elt_longcst ((LONGEST) SYMBOL_VALUE_ADDRESS (msymbol));
377 write_exp_elt_opcode (OP_LONG);
379 write_exp_elt_opcode (UNOP_MEMVAL);
380 switch (msymbol -> type)
384 case mst_solib_trampoline:
385 write_exp_elt_type (msym_text_symbol_type);
392 write_exp_elt_type (msym_data_symbol_type);
396 write_exp_elt_type (msym_unknown_symbol_type);
399 write_exp_elt_opcode (UNOP_MEMVAL);
402 /* Recognize tokens that start with '$'. These include:
404 $regname A native register name or a "standard
407 $variable A convenience variable with a name chosen
410 $digits Value history with index <digits>, starting
411 from the first value which has index 1.
413 $$digits Value history with index <digits> relative
414 to the last value. I.E. $$0 is the last
415 value, $$1 is the one previous to that, $$2
416 is the one previous to $$1, etc.
418 $ | $0 | $$0 The last value in the value history.
420 $$ An abbreviation for the second to the last
421 value in the value history, I.E. $$1
426 write_dollar_variable (str)
429 /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
430 and $$digits (equivalent to $<-digits> if you could type that). */
434 /* Double dollar means negate the number and add -1 as well.
435 Thus $$ alone means -1. */
436 if (str.length >= 2 && str.ptr[1] == '$')
443 /* Just dollars (one or two) */
447 /* Is the rest of the token digits? */
448 for (; i < str.length; i++)
449 if (!(str.ptr[i] >= '0' && str.ptr[i] <= '9'))
453 i = atoi (str.ptr + 1 + negate);
459 /* Handle tokens that refer to machine registers:
460 $ followed by a register name. */
461 for (i = 0; i < NUM_REGS; i++)
462 if (str.length - 1 == strlen (reg_names[i])
463 && STREQN (str.ptr + 1, reg_names[i], str.length - 1))
465 goto handle_register;
467 for (i = 0; i < num_std_regs; i++)
468 if (str.length - 1 == strlen (std_regs[i].name)
469 && STREQN (str.ptr + 1, std_regs[i].name, str.length - 1))
471 i = std_regs[i].regnum;
472 goto handle_register;
475 /* Any other names starting in $ are debugger internal variables. */
477 write_exp_elt_opcode (OP_INTERNALVAR);
478 write_exp_elt_intern (lookup_internalvar (copy_name (str) + 1));
479 write_exp_elt_opcode (OP_INTERNALVAR);
482 write_exp_elt_opcode (OP_LAST);
483 write_exp_elt_longcst ((LONGEST) i);
484 write_exp_elt_opcode (OP_LAST);
487 write_exp_elt_opcode (OP_REGISTER);
488 write_exp_elt_longcst (i);
489 write_exp_elt_opcode (OP_REGISTER);
493 /* Return a null-terminated temporary copy of the name
494 of a string token. */
500 memcpy (namecopy, token.ptr, token.length);
501 namecopy[token.length] = 0;
505 /* Reverse an expression from suffix form (in which it is constructed)
506 to prefix form (in which we can conveniently print or execute it). */
509 prefixify_expression (expr)
510 register struct expression *expr;
513 sizeof (struct expression) + EXP_ELEM_TO_BYTES (expr->nelts);
514 register struct expression *temp;
515 register int inpos = expr->nelts, outpos = 0;
517 temp = (struct expression *) alloca (len);
519 /* Copy the original expression into temp. */
520 memcpy (temp, expr, len);
522 prefixify_subexp (temp, expr, inpos, outpos);
525 /* Return the number of exp_elements in the subexpression of EXPR
526 whose last exp_element is at index ENDPOS - 1 in EXPR. */
529 length_of_subexp (expr, endpos)
530 register struct expression *expr;
533 register int oplen = 1;
534 register int args = 0;
538 error ("?error in length_of_subexp");
540 i = (int) expr->elts[endpos - 1].opcode;
546 oplen = longest_to_int (expr->elts[endpos - 2].longconst);
547 oplen = 5 + BYTES_TO_EXP_ELEM (oplen + 1);
570 case OP_F77_UNDETERMINED_ARGLIST:
572 args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
600 case STRUCTOP_STRUCT:
608 oplen = longest_to_int (expr->elts[endpos - 2].longconst);
609 oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
613 oplen = longest_to_int (expr->elts[endpos - 2].longconst);
614 oplen = (oplen + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
615 oplen = 4 + BYTES_TO_EXP_ELEM (oplen);
620 args = longest_to_int (expr->elts[endpos - 2].longconst);
621 args -= longest_to_int (expr->elts[endpos - 3].longconst);
627 case TERNOP_SLICE_COUNT:
632 case MULTI_SUBSCRIPT:
634 args = 1 + longest_to_int (expr->elts[endpos- 2].longconst);
637 case BINOP_ASSIGN_MODIFY:
648 args = 1 + (i < (int) BINOP_END);
653 oplen += length_of_subexp (expr, endpos - oplen);
660 /* Copy the subexpression ending just before index INEND in INEXPR
661 into OUTEXPR, starting at index OUTBEG.
662 In the process, convert it from suffix to prefix form. */
665 prefixify_subexp (inexpr, outexpr, inend, outbeg)
666 register struct expression *inexpr;
667 struct expression *outexpr;
671 register int oplen = 1;
672 register int args = 0;
675 enum exp_opcode opcode;
677 /* Compute how long the last operation is (in OPLEN),
678 and also how many preceding subexpressions serve as
679 arguments for it (in ARGS). */
681 opcode = inexpr->elts[inend - 1].opcode;
686 oplen = longest_to_int (inexpr->elts[inend - 2].longconst);
687 oplen = 5 + BYTES_TO_EXP_ELEM (oplen + 1);
710 case OP_F77_UNDETERMINED_ARGLIST:
712 args = 1 + longest_to_int (inexpr->elts[inend - 2].longconst);
738 case STRUCTOP_STRUCT:
747 oplen = longest_to_int (inexpr->elts[inend - 2].longconst);
748 oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
752 oplen = longest_to_int (inexpr->elts[inend - 2].longconst);
753 oplen = (oplen + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
754 oplen = 4 + BYTES_TO_EXP_ELEM (oplen);
759 args = longest_to_int (inexpr->elts[inend - 2].longconst);
760 args -= longest_to_int (inexpr->elts[inend - 3].longconst);
766 case TERNOP_SLICE_COUNT:
770 case BINOP_ASSIGN_MODIFY:
776 case MULTI_SUBSCRIPT:
778 args = 1 + longest_to_int (inexpr->elts[inend - 2].longconst);
787 args = 1 + ((int) opcode < (int) BINOP_END);
790 /* Copy the final operator itself, from the end of the input
791 to the beginning of the output. */
793 memcpy (&outexpr->elts[outbeg], &inexpr->elts[inend],
794 EXP_ELEM_TO_BYTES (oplen));
797 /* Find the lengths of the arg subexpressions. */
798 arglens = (int *) alloca (args * sizeof (int));
799 for (i = args - 1; i >= 0; i--)
801 oplen = length_of_subexp (inexpr, inend);
806 /* Now copy each subexpression, preserving the order of
807 the subexpressions, but prefixifying each one.
808 In this loop, inend starts at the beginning of
809 the expression this level is working on
810 and marches forward over the arguments.
811 outbeg does similarly in the output. */
812 for (i = 0; i < args; i++)
816 prefixify_subexp (inexpr, outexpr, inend, outbeg);
821 /* This page contains the two entry points to this file. */
823 /* Read an expression from the string *STRINGPTR points to,
824 parse it, and return a pointer to a struct expression that we malloc.
825 Use block BLOCK as the lexical context for variable names;
826 if BLOCK is zero, use the block of the selected stack frame.
827 Meanwhile, advance *STRINGPTR to point after the expression,
828 at the first nonwhite character that is not part of the expression
829 (possibly a null character).
831 If COMMA is nonzero, stop if a comma is reached. */
834 parse_exp_1 (stringptr, block, comma)
839 struct cleanup *old_chain;
844 type_stack_depth = 0;
846 comma_terminates = comma;
848 if (lexptr == 0 || *lexptr == 0)
849 error_no_arg ("expression to compute");
851 old_chain = make_cleanup (free_funcalls, 0);
854 expression_context_block = block ? block : get_selected_block ();
856 namecopy = (char *) alloca (strlen (lexptr) + 1);
859 expout = (struct expression *)
860 xmalloc (sizeof (struct expression) + EXP_ELEM_TO_BYTES (expout_size));
861 expout->language_defn = current_language;
862 make_cleanup (free_current_contents, &expout);
864 if (current_language->la_parser ())
865 current_language->la_error (NULL);
867 discard_cleanups (old_chain);
869 /* Record the actual number of expression elements, and then
870 reallocate the expression memory so that we free up any
873 expout->nelts = expout_ptr;
874 expout = (struct expression *)
875 xrealloc ((char *) expout,
876 sizeof (struct expression) + EXP_ELEM_TO_BYTES (expout_ptr));;
878 /* Convert expression from postfix form as generated by yacc
879 parser, to a prefix form. */
881 DUMP_EXPRESSION (expout, gdb_stdout, "before conversion to prefix form");
882 prefixify_expression (expout);
883 DUMP_EXPRESSION (expout, gdb_stdout, "after conversion to prefix form");
889 /* Parse STRING as an expression, and complain if this fails
890 to use up all of the contents of STRING. */
893 parse_expression (string)
896 register struct expression *exp;
897 exp = parse_exp_1 (&string, 0, 0);
899 error ("Junk after end of expression.");
903 /* Stuff for maintaining a stack of types. Currently just used by C, but
904 probably useful for any language which declares its types "backwards". */
910 if (type_stack_depth == type_stack_size)
912 type_stack_size *= 2;
913 type_stack = (union type_stack_elt *)
914 xrealloc ((char *) type_stack, type_stack_size * sizeof (*type_stack));
916 type_stack[type_stack_depth++].piece = tp;
923 if (type_stack_depth == type_stack_size)
925 type_stack_size *= 2;
926 type_stack = (union type_stack_elt *)
927 xrealloc ((char *) type_stack, type_stack_size * sizeof (*type_stack));
929 type_stack[type_stack_depth++].int_val = n;
935 if (type_stack_depth)
936 return type_stack[--type_stack_depth].piece;
943 if (type_stack_depth)
944 return type_stack[--type_stack_depth].int_val;
945 /* "Can't happen". */
949 /* Pop the type stack and return the type which corresponds to FOLLOW_TYPE
950 as modified by all the stuff on the stack. */
952 follow_types (follow_type)
953 struct type *follow_type;
957 struct type *range_type;
966 follow_type = lookup_pointer_type (follow_type);
969 follow_type = lookup_reference_type (follow_type);
972 array_size = pop_type_int ();
973 /* FIXME-type-allocation: need a way to free this type when we are
976 create_range_type ((struct type *) NULL,
978 array_size >= 0 ? array_size - 1 : 0);
980 create_array_type ((struct type *) NULL,
981 follow_type, range_type);
983 TYPE_ARRAY_UPPER_BOUND_TYPE(follow_type)
984 = BOUND_CANNOT_BE_DETERMINED;
987 /* FIXME-type-allocation: need a way to free this type when we are
989 follow_type = lookup_function_type (follow_type);
998 type_stack_size = 80;
999 type_stack_depth = 0;
1000 type_stack = (union type_stack_elt *)
1001 xmalloc (type_stack_size * sizeof (*type_stack));
1003 msym_text_symbol_type =
1004 init_type (TYPE_CODE_FUNC, 1, 0, "<text variable, no debug info>", NULL);
1005 TYPE_TARGET_TYPE (msym_text_symbol_type) = builtin_type_int;
1006 msym_data_symbol_type =
1007 init_type (TYPE_CODE_INT, TARGET_INT_BIT / HOST_CHAR_BIT, 0,
1008 "<data variable, no debug info>", NULL);
1009 msym_unknown_symbol_type =
1010 init_type (TYPE_CODE_INT, 1, 0,
1011 "<variable (not text or data), no debug info>",