08f2b7e674842814b79dd56b76aedb6c05b3f635
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 /* Return a null-terminated temporary copy of the name
343 of a string token. */
349 memcpy (namecopy
, token
.ptr
, token
.length
);
350 namecopy
[token
.length
] = 0;
354 /* Reverse an expression from suffix form (in which it is constructed)
355 to prefix form (in which we can conveniently print or execute it). */
358 prefixify_expression (expr
)
359 register struct expression
*expr
;
362 sizeof (struct expression
) + EXP_ELEM_TO_BYTES (expr
->nelts
);
363 register struct expression
*temp
;
364 register int inpos
= expr
->nelts
, outpos
= 0;
366 temp
= (struct expression
*) alloca (len
);
368 /* Copy the original expression into temp. */
369 memcpy (temp
, expr
, len
);
371 prefixify_subexp (temp
, expr
, inpos
, outpos
);
374 /* Return the number of exp_elements in the subexpression of EXPR
375 whose last exp_element is at index ENDPOS - 1 in EXPR. */
378 length_of_subexp (expr
, endpos
)
379 register struct expression
*expr
;
382 register int oplen
= 1;
383 register int args
= 0;
387 error ("?error in length_of_subexp");
389 i
= (int) expr
->elts
[endpos
- 1].opcode
;
395 oplen
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
396 oplen
= 5 + BYTES_TO_EXP_ELEM (oplen
+ 1);
415 args
= 1 + longest_to_int (expr
->elts
[endpos
- 2].longconst
);
442 case STRUCTOP_STRUCT
:
448 oplen
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
449 oplen
= 4 + BYTES_TO_EXP_ELEM (oplen
+ 1);
453 oplen
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
454 oplen
= (oplen
+ HOST_CHAR_BIT
- 1) / HOST_CHAR_BIT
;
455 oplen
= 4 + BYTES_TO_EXP_ELEM (oplen
);
460 args
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
461 args
-= longest_to_int (expr
->elts
[endpos
- 3].longconst
);
470 case MULTI_SUBSCRIPT
:
472 args
= 1 + longest_to_int (expr
->elts
[endpos
- 2].longconst
);
475 case BINOP_ASSIGN_MODIFY
:
486 args
= 1 + (i
< (int) BINOP_END
);
491 oplen
+= length_of_subexp (expr
, endpos
- oplen
);
498 /* Copy the subexpression ending just before index INEND in INEXPR
499 into OUTEXPR, starting at index OUTBEG.
500 In the process, convert it from suffix to prefix form. */
503 prefixify_subexp (inexpr
, outexpr
, inend
, outbeg
)
504 register struct expression
*inexpr
;
505 struct expression
*outexpr
;
509 register int oplen
= 1;
510 register int args
= 0;
513 enum exp_opcode opcode
;
515 /* Compute how long the last operation is (in OPLEN),
516 and also how many preceding subexpressions serve as
517 arguments for it (in ARGS). */
519 opcode
= inexpr
->elts
[inend
- 1].opcode
;
524 oplen
= longest_to_int (inexpr
->elts
[inend
- 2].longconst
);
525 oplen
= 5 + BYTES_TO_EXP_ELEM (oplen
+ 1);
544 args
= 1 + longest_to_int (inexpr
->elts
[inend
- 2].longconst
);
570 case STRUCTOP_STRUCT
:
576 oplen
= longest_to_int (inexpr
->elts
[inend
- 2].longconst
);
577 oplen
= 4 + BYTES_TO_EXP_ELEM (oplen
+ 1);
581 oplen
= longest_to_int (inexpr
->elts
[inend
- 2].longconst
);
582 oplen
= (oplen
+ HOST_CHAR_BIT
- 1) / HOST_CHAR_BIT
;
583 oplen
= 4 + BYTES_TO_EXP_ELEM (oplen
);
588 args
= longest_to_int (inexpr
->elts
[inend
- 2].longconst
);
589 args
-= longest_to_int (inexpr
->elts
[inend
- 3].longconst
);
597 case BINOP_ASSIGN_MODIFY
:
603 case MULTI_SUBSCRIPT
:
605 args
= 1 + longest_to_int (inexpr
->elts
[inend
- 2].longconst
);
614 args
= 1 + ((int) opcode
< (int) BINOP_END
);
617 /* Copy the final operator itself, from the end of the input
618 to the beginning of the output. */
620 memcpy (&outexpr
->elts
[outbeg
], &inexpr
->elts
[inend
],
621 EXP_ELEM_TO_BYTES (oplen
));
624 /* Find the lengths of the arg subexpressions. */
625 arglens
= (int *) alloca (args
* sizeof (int));
626 for (i
= args
- 1; i
>= 0; i
--)
628 oplen
= length_of_subexp (inexpr
, inend
);
633 /* Now copy each subexpression, preserving the order of
634 the subexpressions, but prefixifying each one.
635 In this loop, inend starts at the beginning of
636 the expression this level is working on
637 and marches forward over the arguments.
638 outbeg does similarly in the output. */
639 for (i
= 0; i
< args
; i
++)
643 prefixify_subexp (inexpr
, outexpr
, inend
, outbeg
);
648 /* This page contains the two entry points to this file. */
650 /* Read an expression from the string *STRINGPTR points to,
651 parse it, and return a pointer to a struct expression that we malloc.
652 Use block BLOCK as the lexical context for variable names;
653 if BLOCK is zero, use the block of the selected stack frame.
654 Meanwhile, advance *STRINGPTR to point after the expression,
655 at the first nonwhite character that is not part of the expression
656 (possibly a null character).
658 If COMMA is nonzero, stop if a comma is reached. */
661 parse_exp_1 (stringptr
, block
, comma
)
666 struct cleanup
*old_chain
;
671 type_stack_depth
= 0;
673 comma_terminates
= comma
;
675 if (lexptr
== 0 || *lexptr
== 0)
676 error_no_arg ("expression to compute");
678 old_chain
= make_cleanup (free_funcalls
, 0);
681 expression_context_block
= block
? block
: get_selected_block ();
683 namecopy
= (char *) alloca (strlen (lexptr
) + 1);
686 expout
= (struct expression
*)
687 xmalloc (sizeof (struct expression
) + EXP_ELEM_TO_BYTES (expout_size
));
688 expout
->language_defn
= current_language
;
689 make_cleanup (free_current_contents
, &expout
);
691 if (current_language
->la_parser ())
692 current_language
->la_error (NULL
);
694 discard_cleanups (old_chain
);
696 /* Record the actual number of expression elements, and then
697 reallocate the expression memory so that we free up any
700 expout
->nelts
= expout_ptr
;
701 expout
= (struct expression
*)
702 xrealloc ((char *) expout
,
703 sizeof (struct expression
) + EXP_ELEM_TO_BYTES (expout_ptr
));;
705 /* Convert expression from postfix form as generated by yacc
706 parser, to a prefix form. */
708 DUMP_EXPRESSION (expout
, stdout
, "before conversion to prefix form");
709 prefixify_expression (expout
);
710 DUMP_EXPRESSION (expout
, stdout
, "after conversion to prefix form");
716 /* Parse STRING as an expression, and complain if this fails
717 to use up all of the contents of STRING. */
720 parse_expression (string
)
723 register struct expression
*exp
;
724 exp
= parse_exp_1 (&string
, 0, 0);
726 error ("Junk after end of expression.");
730 /* Stuff for maintaining a stack of types. Currently just used by C, but
731 probably useful for any language which declares its types "backwards". */
737 if (type_stack_depth
== type_stack_size
)
739 type_stack_size
*= 2;
740 type_stack
= (union type_stack_elt
*)
741 xrealloc ((char *) type_stack
, type_stack_size
* sizeof (*type_stack
));
743 type_stack
[type_stack_depth
++].piece
= tp
;
750 if (type_stack_depth
== type_stack_size
)
752 type_stack_size
*= 2;
753 type_stack
= (union type_stack_elt
*)
754 xrealloc ((char *) type_stack
, type_stack_size
* sizeof (*type_stack
));
756 type_stack
[type_stack_depth
++].int_val
= n
;
762 if (type_stack_depth
)
763 return type_stack
[--type_stack_depth
].piece
;
770 if (type_stack_depth
)
771 return type_stack
[--type_stack_depth
].int_val
;
772 /* "Can't happen". */
776 /* Pop the type stack and return the type which corresponds to FOLLOW_TYPE
777 as modified by all the stuff on the stack. */
779 follow_types (follow_type
)
780 struct type
*follow_type
;
784 struct type
*range_type
;
793 follow_type
= lookup_pointer_type (follow_type
);
796 follow_type
= lookup_reference_type (follow_type
);
799 array_size
= pop_type_int ();
800 if (array_size
!= -1)
803 create_range_type ((struct type
*) NULL
,
807 create_array_type ((struct type
*) NULL
,
808 follow_type
, range_type
);
811 follow_type
= lookup_pointer_type (follow_type
);
814 follow_type
= lookup_function_type (follow_type
);
823 type_stack_size
= 80;
824 type_stack_depth
= 0;
825 type_stack
= (union type_stack_elt
*)
826 xmalloc (type_stack_size
* sizeof (*type_stack
));