ca9bcc8c9b011fd36689b640eedad801c5095ff9
1 /* Parse expressions for GDB.
2 Copyright (C) 1986, 1989, 1990, 1991 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., 675 Mass Ave, Cambridge, MA 02139, 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. */
35 #include "expression.h"
39 #include "parser-defs.h"
42 free_funcalls
PARAMS ((void));
45 prefixify_expression
PARAMS ((struct expression
*));
48 length_of_subexp
PARAMS ((struct expression
*, int));
51 prefixify_subexp
PARAMS ((struct expression
*, struct expression
*, int, int));
53 /* Data structure for saving values of arglist_len for function calls whose
54 arguments contain other function calls. */
62 static struct funcall
*funcall_chain
;
64 /* Assign machine-independent names to certain registers
65 (unless overridden by the REGISTER_NAMES table) */
68 unsigned num_std_regs
= 0;
69 struct std_regs std_regs
[1];
71 struct std_regs std_regs
[] = {
88 unsigned num_std_regs
= (sizeof std_regs
/ sizeof std_regs
[0]);
93 /* Begin counting arguments for a function call,
94 saving the data about any containing call. */
99 register struct funcall
*new;
101 new = (struct funcall
*) xmalloc (sizeof (struct funcall
));
102 new->next
= funcall_chain
;
103 new->arglist_len
= arglist_len
;
108 /* Return the number of arguments in a function call just terminated,
109 and restore the data for the containing function call. */
114 register int val
= arglist_len
;
115 register struct funcall
*call
= funcall_chain
;
116 funcall_chain
= call
->next
;
117 arglist_len
= call
->arglist_len
;
122 /* Free everything in the funcall chain.
123 Used when there is an error inside parsing. */
128 register struct funcall
*call
, *next
;
130 for (call
= funcall_chain
; call
; call
= next
)
137 /* This page contains the functions for adding data to the struct expression
138 being constructed. */
140 /* Add one element to the end of the expression. */
142 /* To avoid a bug in the Sun 4 compiler, we pass things that can fit into
143 a register through here */
146 write_exp_elt (expelt
)
147 union exp_element expelt
;
149 if (expout_ptr
>= expout_size
)
152 expout
= (struct expression
*)
153 xrealloc ((char *) expout
, sizeof (struct expression
)
154 + EXP_ELEM_TO_BYTES (expout_size
));
156 expout
->elts
[expout_ptr
++] = expelt
;
160 write_exp_elt_opcode (expelt
)
161 enum exp_opcode expelt
;
163 union exp_element tmp
;
171 write_exp_elt_sym (expelt
)
172 struct symbol
*expelt
;
174 union exp_element tmp
;
182 write_exp_elt_block (b
)
185 union exp_element tmp
;
191 write_exp_elt_longcst (expelt
)
194 union exp_element tmp
;
196 tmp
.longconst
= expelt
;
202 write_exp_elt_dblcst (expelt
)
205 union exp_element tmp
;
207 tmp
.doubleconst
= expelt
;
213 write_exp_elt_type (expelt
)
216 union exp_element tmp
;
224 write_exp_elt_intern (expelt
)
225 struct internalvar
*expelt
;
227 union exp_element tmp
;
229 tmp
.internalvar
= expelt
;
234 /* Add a string constant to the end of the expression.
236 String constants are stored by first writing an expression element
237 that contains the length of the string, then stuffing the string
238 constant itself into however many expression elements are needed
239 to hold it, and then writing another expression element that contains
240 the length of the string. I.E. an expression element at each end of
241 the string records the string length, so you can skip over the
242 expression elements containing the actual string bytes from either
243 end of the string. Note that this also allows gdb to handle
244 strings with embedded null bytes, as is required for some languages.
246 Don't be fooled by the fact that the string is null byte terminated,
247 this is strictly for the convenience of debugging gdb itself. Gdb
248 Gdb does not depend up the string being null terminated, since the
249 actual length is recorded in expression elements at each end of the
250 string. The null byte is taken into consideration when computing how
251 many expression elements are required to hold the string constant, of
256 write_exp_string (str
)
259 register int len
= str
.length
;
261 register char *strdata
;
263 /* Compute the number of expression elements required to hold the string
264 (including a null byte terminator), along with one expression element
265 at each end to record the actual string length (not including the
266 null byte terminator). */
268 lenelt
= 2 + BYTES_TO_EXP_ELEM (len
+ 1);
270 /* Ensure that we have enough available expression elements to store
273 if ((expout_ptr
+ lenelt
) >= expout_size
)
275 expout_size
= max (expout_size
* 2, expout_ptr
+ lenelt
+ 10);
276 expout
= (struct expression
*)
277 xrealloc ((char *) expout
, (sizeof (struct expression
)
278 + EXP_ELEM_TO_BYTES (expout_size
)));
281 /* Write the leading length expression element (which advances the current
282 expression element index), then write the string constant followed by a
283 terminating null byte, and then write the trailing length expression
286 write_exp_elt_longcst ((LONGEST
) len
);
287 strdata
= (char *) &expout
->elts
[expout_ptr
];
288 memcpy (strdata
, str
.ptr
, len
);
289 *(strdata
+ len
) = '\0';
290 expout_ptr
+= lenelt
- 2;
291 write_exp_elt_longcst ((LONGEST
) len
);
294 /* Add a bitstring constant to the end of the expression.
296 Bitstring constants are stored by first writing an expression element
297 that contains the length of the bitstring (in bits), then stuffing the
298 bitstring constant itself into however many expression elements are
299 needed to hold it, and then writing another expression element that
300 contains the length of the bitstring. I.E. an expression element at
301 each end of the bitstring records the bitstring length, so you can skip
302 over the expression elements containing the actual bitstring bytes from
303 either end of the bitstring. */
306 write_exp_bitstring (str
)
309 register int bits
= str
.length
; /* length in bits */
310 register int len
= (bits
+ HOST_CHAR_BIT
- 1) / HOST_CHAR_BIT
;
312 register char *strdata
;
314 /* Compute the number of expression elements required to hold the bitstring,
315 along with one expression element at each end to record the actual
316 bitstring length in bits. */
318 lenelt
= 2 + BYTES_TO_EXP_ELEM (len
);
320 /* Ensure that we have enough available expression elements to store
323 if ((expout_ptr
+ lenelt
) >= expout_size
)
325 expout_size
= max (expout_size
* 2, expout_ptr
+ lenelt
+ 10);
326 expout
= (struct expression
*)
327 xrealloc ((char *) expout
, (sizeof (struct expression
)
328 + EXP_ELEM_TO_BYTES (expout_size
)));
331 /* Write the leading length expression element (which advances the current
332 expression element index), then write the bitstring constant, and then
333 write the trailing length expression element. */
335 write_exp_elt_longcst ((LONGEST
) bits
);
336 strdata
= (char *) &expout
->elts
[expout_ptr
];
337 memcpy (strdata
, str
.ptr
, len
);
338 expout_ptr
+= lenelt
- 2;
339 write_exp_elt_longcst ((LONGEST
) bits
);
342 /* Add the appropriate elements for a minimal symbol to the end of
346 write_exp_msymbol (msymbol
, text_symbol_type
, data_symbol_type
)
347 struct minimal_symbol
*msymbol
;
348 struct type
*text_symbol_type
;
349 struct type
*data_symbol_type
;
351 write_exp_elt_opcode (OP_LONG
);
352 write_exp_elt_type (builtin_type_long
);
353 write_exp_elt_longcst ((LONGEST
) SYMBOL_VALUE_ADDRESS (msymbol
));
354 write_exp_elt_opcode (OP_LONG
);
356 write_exp_elt_opcode (UNOP_MEMVAL
);
357 switch (msymbol
-> type
)
361 write_exp_elt_type (text_symbol_type
);
368 write_exp_elt_type (data_symbol_type
);
372 write_exp_elt_type (builtin_type_char
);
375 write_exp_elt_opcode (UNOP_MEMVAL
);
378 /* Return a null-terminated temporary copy of the name
379 of a string token. */
385 memcpy (namecopy
, token
.ptr
, token
.length
);
386 namecopy
[token
.length
] = 0;
390 /* Reverse an expression from suffix form (in which it is constructed)
391 to prefix form (in which we can conveniently print or execute it). */
394 prefixify_expression (expr
)
395 register struct expression
*expr
;
398 sizeof (struct expression
) + EXP_ELEM_TO_BYTES (expr
->nelts
);
399 register struct expression
*temp
;
400 register int inpos
= expr
->nelts
, outpos
= 0;
402 temp
= (struct expression
*) alloca (len
);
404 /* Copy the original expression into temp. */
405 memcpy (temp
, expr
, len
);
407 prefixify_subexp (temp
, expr
, inpos
, outpos
);
410 /* Return the number of exp_elements in the subexpression of EXPR
411 whose last exp_element is at index ENDPOS - 1 in EXPR. */
414 length_of_subexp (expr
, endpos
)
415 register struct expression
*expr
;
418 register int oplen
= 1;
419 register int args
= 0;
423 error ("?error in length_of_subexp");
425 i
= (int) expr
->elts
[endpos
- 1].opcode
;
431 oplen
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
432 oplen
= 5 + BYTES_TO_EXP_ELEM (oplen
+ 1);
451 args
= 1 + longest_to_int (expr
->elts
[endpos
- 2].longconst
);
478 case STRUCTOP_STRUCT
:
484 oplen
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
485 oplen
= 4 + BYTES_TO_EXP_ELEM (oplen
+ 1);
489 oplen
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
490 oplen
= (oplen
+ HOST_CHAR_BIT
- 1) / HOST_CHAR_BIT
;
491 oplen
= 4 + BYTES_TO_EXP_ELEM (oplen
);
496 args
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
497 args
-= longest_to_int (expr
->elts
[endpos
- 3].longconst
);
506 case MULTI_SUBSCRIPT
:
508 args
= 1 + longest_to_int (expr
->elts
[endpos
- 2].longconst
);
511 case BINOP_ASSIGN_MODIFY
:
522 args
= 1 + (i
< (int) BINOP_END
);
527 oplen
+= length_of_subexp (expr
, endpos
- oplen
);
534 /* Copy the subexpression ending just before index INEND in INEXPR
535 into OUTEXPR, starting at index OUTBEG.
536 In the process, convert it from suffix to prefix form. */
539 prefixify_subexp (inexpr
, outexpr
, inend
, outbeg
)
540 register struct expression
*inexpr
;
541 struct expression
*outexpr
;
545 register int oplen
= 1;
546 register int args
= 0;
549 enum exp_opcode opcode
;
551 /* Compute how long the last operation is (in OPLEN),
552 and also how many preceding subexpressions serve as
553 arguments for it (in ARGS). */
555 opcode
= inexpr
->elts
[inend
- 1].opcode
;
560 oplen
= longest_to_int (inexpr
->elts
[inend
- 2].longconst
);
561 oplen
= 5 + BYTES_TO_EXP_ELEM (oplen
+ 1);
580 args
= 1 + longest_to_int (inexpr
->elts
[inend
- 2].longconst
);
606 case STRUCTOP_STRUCT
:
612 oplen
= longest_to_int (inexpr
->elts
[inend
- 2].longconst
);
613 oplen
= 4 + BYTES_TO_EXP_ELEM (oplen
+ 1);
617 oplen
= longest_to_int (inexpr
->elts
[inend
- 2].longconst
);
618 oplen
= (oplen
+ HOST_CHAR_BIT
- 1) / HOST_CHAR_BIT
;
619 oplen
= 4 + BYTES_TO_EXP_ELEM (oplen
);
624 args
= longest_to_int (inexpr
->elts
[inend
- 2].longconst
);
625 args
-= longest_to_int (inexpr
->elts
[inend
- 3].longconst
);
633 case BINOP_ASSIGN_MODIFY
:
639 case MULTI_SUBSCRIPT
:
641 args
= 1 + longest_to_int (inexpr
->elts
[inend
- 2].longconst
);
650 args
= 1 + ((int) opcode
< (int) BINOP_END
);
653 /* Copy the final operator itself, from the end of the input
654 to the beginning of the output. */
656 memcpy (&outexpr
->elts
[outbeg
], &inexpr
->elts
[inend
],
657 EXP_ELEM_TO_BYTES (oplen
));
660 /* Find the lengths of the arg subexpressions. */
661 arglens
= (int *) alloca (args
* sizeof (int));
662 for (i
= args
- 1; i
>= 0; i
--)
664 oplen
= length_of_subexp (inexpr
, inend
);
669 /* Now copy each subexpression, preserving the order of
670 the subexpressions, but prefixifying each one.
671 In this loop, inend starts at the beginning of
672 the expression this level is working on
673 and marches forward over the arguments.
674 outbeg does similarly in the output. */
675 for (i
= 0; i
< args
; i
++)
679 prefixify_subexp (inexpr
, outexpr
, inend
, outbeg
);
684 /* This page contains the two entry points to this file. */
686 /* Read an expression from the string *STRINGPTR points to,
687 parse it, and return a pointer to a struct expression that we malloc.
688 Use block BLOCK as the lexical context for variable names;
689 if BLOCK is zero, use the block of the selected stack frame.
690 Meanwhile, advance *STRINGPTR to point after the expression,
691 at the first nonwhite character that is not part of the expression
692 (possibly a null character).
694 If COMMA is nonzero, stop if a comma is reached. */
697 parse_exp_1 (stringptr
, block
, comma
)
702 struct cleanup
*old_chain
;
707 type_stack_depth
= 0;
709 comma_terminates
= comma
;
711 if (lexptr
== 0 || *lexptr
== 0)
712 error_no_arg ("expression to compute");
714 old_chain
= make_cleanup (free_funcalls
, 0);
717 expression_context_block
= block
? block
: get_selected_block ();
719 namecopy
= (char *) alloca (strlen (lexptr
) + 1);
722 expout
= (struct expression
*)
723 xmalloc (sizeof (struct expression
) + EXP_ELEM_TO_BYTES (expout_size
));
724 expout
->language_defn
= current_language
;
725 make_cleanup (free_current_contents
, &expout
);
727 if (current_language
->la_parser ())
728 current_language
->la_error (NULL
);
730 discard_cleanups (old_chain
);
732 /* Record the actual number of expression elements, and then
733 reallocate the expression memory so that we free up any
736 expout
->nelts
= expout_ptr
;
737 expout
= (struct expression
*)
738 xrealloc ((char *) expout
,
739 sizeof (struct expression
) + EXP_ELEM_TO_BYTES (expout_ptr
));;
741 /* Convert expression from postfix form as generated by yacc
742 parser, to a prefix form. */
744 DUMP_EXPRESSION (expout
, gdb_stdout
, "before conversion to prefix form");
745 prefixify_expression (expout
);
746 DUMP_EXPRESSION (expout
, gdb_stdout
, "after conversion to prefix form");
752 /* Parse STRING as an expression, and complain if this fails
753 to use up all of the contents of STRING. */
756 parse_expression (string
)
759 register struct expression
*exp
;
760 exp
= parse_exp_1 (&string
, 0, 0);
762 error ("Junk after end of expression.");
766 /* Stuff for maintaining a stack of types. Currently just used by C, but
767 probably useful for any language which declares its types "backwards". */
773 if (type_stack_depth
== type_stack_size
)
775 type_stack_size
*= 2;
776 type_stack
= (union type_stack_elt
*)
777 xrealloc ((char *) type_stack
, type_stack_size
* sizeof (*type_stack
));
779 type_stack
[type_stack_depth
++].piece
= tp
;
786 if (type_stack_depth
== type_stack_size
)
788 type_stack_size
*= 2;
789 type_stack
= (union type_stack_elt
*)
790 xrealloc ((char *) type_stack
, type_stack_size
* sizeof (*type_stack
));
792 type_stack
[type_stack_depth
++].int_val
= n
;
798 if (type_stack_depth
)
799 return type_stack
[--type_stack_depth
].piece
;
806 if (type_stack_depth
)
807 return type_stack
[--type_stack_depth
].int_val
;
808 /* "Can't happen". */
812 /* Pop the type stack and return the type which corresponds to FOLLOW_TYPE
813 as modified by all the stuff on the stack. */
815 follow_types (follow_type
)
816 struct type
*follow_type
;
820 struct type
*range_type
;
829 follow_type
= lookup_pointer_type (follow_type
);
832 follow_type
= lookup_reference_type (follow_type
);
835 array_size
= pop_type_int ();
836 if (array_size
!= -1)
839 create_range_type ((struct type
*) NULL
,
843 create_array_type ((struct type
*) NULL
,
844 follow_type
, range_type
);
847 follow_type
= lookup_pointer_type (follow_type
);
850 follow_type
= lookup_function_type (follow_type
);
859 type_stack_size
= 80;
860 type_stack_depth
= 0;
861 type_stack
= (union type_stack_elt
*)
862 xmalloc (type_stack_size
* sizeof (*type_stack
));