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., 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. */
36 #include "expression.h"
40 #include "parser-defs.h"
43 free_funcalls
PARAMS ((void));
46 prefixify_expression
PARAMS ((struct expression
*));
49 length_of_subexp
PARAMS ((struct expression
*, int));
52 prefixify_subexp
PARAMS ((struct expression
*, struct expression
*, int, int));
54 /* Data structure for saving values of arglist_len for function calls whose
55 arguments contain other function calls. */
63 static struct funcall
*funcall_chain
;
65 /* Assign machine-independent names to certain registers
66 (unless overridden by the REGISTER_NAMES table) */
69 unsigned num_std_regs
= 0;
70 struct std_regs std_regs
[1];
72 struct std_regs std_regs
[] = {
89 unsigned num_std_regs
= (sizeof std_regs
/ sizeof std_regs
[0]);
94 /* Begin counting arguments for a function call,
95 saving the data about any containing call. */
100 register struct funcall
*new;
102 new = (struct funcall
*) xmalloc (sizeof (struct funcall
));
103 new->next
= funcall_chain
;
104 new->arglist_len
= arglist_len
;
109 /* Return the number of arguments in a function call just terminated,
110 and restore the data for the containing function call. */
115 register int val
= arglist_len
;
116 register struct funcall
*call
= funcall_chain
;
117 funcall_chain
= call
->next
;
118 arglist_len
= call
->arglist_len
;
123 /* Free everything in the funcall chain.
124 Used when there is an error inside parsing. */
129 register struct funcall
*call
, *next
;
131 for (call
= funcall_chain
; call
; call
= next
)
138 /* This page contains the functions for adding data to the struct expression
139 being constructed. */
141 /* Add one element to the end of the expression. */
143 /* To avoid a bug in the Sun 4 compiler, we pass things that can fit into
144 a register through here */
147 write_exp_elt (expelt
)
148 union exp_element expelt
;
150 if (expout_ptr
>= expout_size
)
153 expout
= (struct expression
*)
154 xrealloc ((char *) expout
, sizeof (struct expression
)
155 + EXP_ELEM_TO_BYTES (expout_size
));
157 expout
->elts
[expout_ptr
++] = expelt
;
161 write_exp_elt_opcode (expelt
)
162 enum exp_opcode expelt
;
164 union exp_element tmp
;
172 write_exp_elt_sym (expelt
)
173 struct symbol
*expelt
;
175 union exp_element tmp
;
183 write_exp_elt_block (b
)
186 union exp_element tmp
;
192 write_exp_elt_longcst (expelt
)
195 union exp_element tmp
;
197 tmp
.longconst
= expelt
;
203 write_exp_elt_dblcst (expelt
)
206 union exp_element tmp
;
208 tmp
.doubleconst
= expelt
;
214 write_exp_elt_type (expelt
)
217 union exp_element tmp
;
225 write_exp_elt_intern (expelt
)
226 struct internalvar
*expelt
;
228 union exp_element tmp
;
230 tmp
.internalvar
= expelt
;
235 /* Add a string constant to the end of the expression.
237 String constants are stored by first writing an expression element
238 that contains the length of the string, then stuffing the string
239 constant itself into however many expression elements are needed
240 to hold it, and then writing another expression element that contains
241 the length of the string. I.E. an expression element at each end of
242 the string records the string length, so you can skip over the
243 expression elements containing the actual string bytes from either
244 end of the string. Note that this also allows gdb to handle
245 strings with embedded null bytes, as is required for some languages.
247 Don't be fooled by the fact that the string is null byte terminated,
248 this is strictly for the convenience of debugging gdb itself. Gdb
249 Gdb does not depend up the string being null terminated, since the
250 actual length is recorded in expression elements at each end of the
251 string. The null byte is taken into consideration when computing how
252 many expression elements are required to hold the string constant, of
257 write_exp_string (str
)
260 register int len
= str
.length
;
262 register char *strdata
;
264 /* Compute the number of expression elements required to hold the string
265 (including a null byte terminator), along with one expression element
266 at each end to record the actual string length (not including the
267 null byte terminator). */
269 lenelt
= 2 + BYTES_TO_EXP_ELEM (len
+ 1);
271 /* Ensure that we have enough available expression elements to store
274 if ((expout_ptr
+ lenelt
) >= expout_size
)
276 expout_size
= max (expout_size
* 2, expout_ptr
+ lenelt
+ 10);
277 expout
= (struct expression
*)
278 xrealloc ((char *) expout
, (sizeof (struct expression
)
279 + EXP_ELEM_TO_BYTES (expout_size
)));
282 /* Write the leading length expression element (which advances the current
283 expression element index), then write the string constant followed by a
284 terminating null byte, and then write the trailing length expression
287 write_exp_elt_longcst ((LONGEST
) len
);
288 strdata
= (char *) &expout
->elts
[expout_ptr
];
289 memcpy (strdata
, str
.ptr
, len
);
290 *(strdata
+ len
) = '\0';
291 expout_ptr
+= lenelt
- 2;
292 write_exp_elt_longcst ((LONGEST
) len
);
295 /* Add a bitstring constant to the end of the expression.
297 Bitstring constants are stored by first writing an expression element
298 that contains the length of the bitstring (in bits), then stuffing the
299 bitstring constant itself into however many expression elements are
300 needed to hold it, and then writing another expression element that
301 contains the length of the bitstring. I.E. an expression element at
302 each end of the bitstring records the bitstring length, so you can skip
303 over the expression elements containing the actual bitstring bytes from
304 either end of the bitstring. */
307 write_exp_bitstring (str
)
310 register int bits
= str
.length
; /* length in bits */
311 register int len
= (bits
+ HOST_CHAR_BIT
- 1) / HOST_CHAR_BIT
;
313 register char *strdata
;
315 /* Compute the number of expression elements required to hold the bitstring,
316 along with one expression element at each end to record the actual
317 bitstring length in bits. */
319 lenelt
= 2 + BYTES_TO_EXP_ELEM (len
);
321 /* Ensure that we have enough available expression elements to store
324 if ((expout_ptr
+ lenelt
) >= expout_size
)
326 expout_size
= max (expout_size
* 2, expout_ptr
+ lenelt
+ 10);
327 expout
= (struct expression
*)
328 xrealloc ((char *) expout
, (sizeof (struct expression
)
329 + EXP_ELEM_TO_BYTES (expout_size
)));
332 /* Write the leading length expression element (which advances the current
333 expression element index), then write the bitstring constant, and then
334 write the trailing length expression element. */
336 write_exp_elt_longcst ((LONGEST
) bits
);
337 strdata
= (char *) &expout
->elts
[expout_ptr
];
338 memcpy (strdata
, str
.ptr
, len
);
339 expout_ptr
+= lenelt
- 2;
340 write_exp_elt_longcst ((LONGEST
) bits
);
343 /* Type that corresponds to the address given in a minimal symbol. */
345 static struct type
*msymbol_addr_type
;
347 /* Add the appropriate elements for a minimal symbol to the end of
351 write_exp_msymbol (msymbol
, text_symbol_type
, data_symbol_type
)
352 struct minimal_symbol
*msymbol
;
353 struct type
*text_symbol_type
;
354 struct type
*data_symbol_type
;
356 write_exp_elt_opcode (OP_LONG
);
357 write_exp_elt_type (msymbol_addr_type
);
358 write_exp_elt_longcst ((LONGEST
) SYMBOL_VALUE_ADDRESS (msymbol
));
359 write_exp_elt_opcode (OP_LONG
);
361 write_exp_elt_opcode (UNOP_MEMVAL
);
362 switch (msymbol
-> type
)
366 write_exp_elt_type (text_symbol_type
);
373 write_exp_elt_type (data_symbol_type
);
377 write_exp_elt_type (builtin_type_char
);
380 write_exp_elt_opcode (UNOP_MEMVAL
);
383 /* Return a null-terminated temporary copy of the name
384 of a string token. */
390 memcpy (namecopy
, token
.ptr
, token
.length
);
391 namecopy
[token
.length
] = 0;
395 /* Reverse an expression from suffix form (in which it is constructed)
396 to prefix form (in which we can conveniently print or execute it). */
399 prefixify_expression (expr
)
400 register struct expression
*expr
;
403 sizeof (struct expression
) + EXP_ELEM_TO_BYTES (expr
->nelts
);
404 register struct expression
*temp
;
405 register int inpos
= expr
->nelts
, outpos
= 0;
407 temp
= (struct expression
*) alloca (len
);
409 /* Copy the original expression into temp. */
410 memcpy (temp
, expr
, len
);
412 prefixify_subexp (temp
, expr
, inpos
, outpos
);
415 /* Return the number of exp_elements in the subexpression of EXPR
416 whose last exp_element is at index ENDPOS - 1 in EXPR. */
419 length_of_subexp (expr
, endpos
)
420 register struct expression
*expr
;
423 register int oplen
= 1;
424 register int args
= 0;
428 error ("?error in length_of_subexp");
430 i
= (int) expr
->elts
[endpos
- 1].opcode
;
436 oplen
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
437 oplen
= 5 + BYTES_TO_EXP_ELEM (oplen
+ 1);
456 args
= 1 + longest_to_int (expr
->elts
[endpos
- 2].longconst
);
483 case STRUCTOP_STRUCT
:
489 oplen
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
490 oplen
= 4 + BYTES_TO_EXP_ELEM (oplen
+ 1);
494 oplen
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
495 oplen
= (oplen
+ HOST_CHAR_BIT
- 1) / HOST_CHAR_BIT
;
496 oplen
= 4 + BYTES_TO_EXP_ELEM (oplen
);
501 args
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
502 args
-= longest_to_int (expr
->elts
[endpos
- 3].longconst
);
511 case MULTI_SUBSCRIPT
:
513 args
= 1 + longest_to_int (expr
->elts
[endpos
- 2].longconst
);
516 case BINOP_ASSIGN_MODIFY
:
527 args
= 1 + (i
< (int) BINOP_END
);
532 oplen
+= length_of_subexp (expr
, endpos
- oplen
);
539 /* Copy the subexpression ending just before index INEND in INEXPR
540 into OUTEXPR, starting at index OUTBEG.
541 In the process, convert it from suffix to prefix form. */
544 prefixify_subexp (inexpr
, outexpr
, inend
, outbeg
)
545 register struct expression
*inexpr
;
546 struct expression
*outexpr
;
550 register int oplen
= 1;
551 register int args
= 0;
554 enum exp_opcode opcode
;
556 /* Compute how long the last operation is (in OPLEN),
557 and also how many preceding subexpressions serve as
558 arguments for it (in ARGS). */
560 opcode
= inexpr
->elts
[inend
- 1].opcode
;
565 oplen
= longest_to_int (inexpr
->elts
[inend
- 2].longconst
);
566 oplen
= 5 + BYTES_TO_EXP_ELEM (oplen
+ 1);
585 args
= 1 + longest_to_int (inexpr
->elts
[inend
- 2].longconst
);
611 case STRUCTOP_STRUCT
:
617 oplen
= longest_to_int (inexpr
->elts
[inend
- 2].longconst
);
618 oplen
= 4 + BYTES_TO_EXP_ELEM (oplen
+ 1);
622 oplen
= longest_to_int (inexpr
->elts
[inend
- 2].longconst
);
623 oplen
= (oplen
+ HOST_CHAR_BIT
- 1) / HOST_CHAR_BIT
;
624 oplen
= 4 + BYTES_TO_EXP_ELEM (oplen
);
629 args
= longest_to_int (inexpr
->elts
[inend
- 2].longconst
);
630 args
-= longest_to_int (inexpr
->elts
[inend
- 3].longconst
);
638 case BINOP_ASSIGN_MODIFY
:
644 case MULTI_SUBSCRIPT
:
646 args
= 1 + longest_to_int (inexpr
->elts
[inend
- 2].longconst
);
655 args
= 1 + ((int) opcode
< (int) BINOP_END
);
658 /* Copy the final operator itself, from the end of the input
659 to the beginning of the output. */
661 memcpy (&outexpr
->elts
[outbeg
], &inexpr
->elts
[inend
],
662 EXP_ELEM_TO_BYTES (oplen
));
665 /* Find the lengths of the arg subexpressions. */
666 arglens
= (int *) alloca (args
* sizeof (int));
667 for (i
= args
- 1; i
>= 0; i
--)
669 oplen
= length_of_subexp (inexpr
, inend
);
674 /* Now copy each subexpression, preserving the order of
675 the subexpressions, but prefixifying each one.
676 In this loop, inend starts at the beginning of
677 the expression this level is working on
678 and marches forward over the arguments.
679 outbeg does similarly in the output. */
680 for (i
= 0; i
< args
; i
++)
684 prefixify_subexp (inexpr
, outexpr
, inend
, outbeg
);
689 /* This page contains the two entry points to this file. */
691 /* Read an expression from the string *STRINGPTR points to,
692 parse it, and return a pointer to a struct expression that we malloc.
693 Use block BLOCK as the lexical context for variable names;
694 if BLOCK is zero, use the block of the selected stack frame.
695 Meanwhile, advance *STRINGPTR to point after the expression,
696 at the first nonwhite character that is not part of the expression
697 (possibly a null character).
699 If COMMA is nonzero, stop if a comma is reached. */
702 parse_exp_1 (stringptr
, block
, comma
)
707 struct cleanup
*old_chain
;
712 type_stack_depth
= 0;
714 comma_terminates
= comma
;
716 if (lexptr
== 0 || *lexptr
== 0)
717 error_no_arg ("expression to compute");
719 old_chain
= make_cleanup (free_funcalls
, 0);
722 expression_context_block
= block
? block
: get_selected_block ();
724 namecopy
= (char *) alloca (strlen (lexptr
) + 1);
727 expout
= (struct expression
*)
728 xmalloc (sizeof (struct expression
) + EXP_ELEM_TO_BYTES (expout_size
));
729 expout
->language_defn
= current_language
;
730 make_cleanup (free_current_contents
, &expout
);
732 if (current_language
->la_parser ())
733 current_language
->la_error (NULL
);
735 discard_cleanups (old_chain
);
737 /* Record the actual number of expression elements, and then
738 reallocate the expression memory so that we free up any
741 expout
->nelts
= expout_ptr
;
742 expout
= (struct expression
*)
743 xrealloc ((char *) expout
,
744 sizeof (struct expression
) + EXP_ELEM_TO_BYTES (expout_ptr
));;
746 /* Convert expression from postfix form as generated by yacc
747 parser, to a prefix form. */
749 DUMP_EXPRESSION (expout
, gdb_stdout
, "before conversion to prefix form");
750 prefixify_expression (expout
);
751 DUMP_EXPRESSION (expout
, gdb_stdout
, "after conversion to prefix form");
757 /* Parse STRING as an expression, and complain if this fails
758 to use up all of the contents of STRING. */
761 parse_expression (string
)
764 register struct expression
*exp
;
765 exp
= parse_exp_1 (&string
, 0, 0);
767 error ("Junk after end of expression.");
771 /* Stuff for maintaining a stack of types. Currently just used by C, but
772 probably useful for any language which declares its types "backwards". */
778 if (type_stack_depth
== type_stack_size
)
780 type_stack_size
*= 2;
781 type_stack
= (union type_stack_elt
*)
782 xrealloc ((char *) type_stack
, type_stack_size
* sizeof (*type_stack
));
784 type_stack
[type_stack_depth
++].piece
= tp
;
791 if (type_stack_depth
== type_stack_size
)
793 type_stack_size
*= 2;
794 type_stack
= (union type_stack_elt
*)
795 xrealloc ((char *) type_stack
, type_stack_size
* sizeof (*type_stack
));
797 type_stack
[type_stack_depth
++].int_val
= n
;
803 if (type_stack_depth
)
804 return type_stack
[--type_stack_depth
].piece
;
811 if (type_stack_depth
)
812 return type_stack
[--type_stack_depth
].int_val
;
813 /* "Can't happen". */
817 /* Pop the type stack and return the type which corresponds to FOLLOW_TYPE
818 as modified by all the stuff on the stack. */
820 follow_types (follow_type
)
821 struct type
*follow_type
;
825 struct type
*range_type
;
834 follow_type
= lookup_pointer_type (follow_type
);
837 follow_type
= lookup_reference_type (follow_type
);
840 array_size
= pop_type_int ();
841 if (array_size
!= -1)
844 create_range_type ((struct type
*) NULL
,
848 create_array_type ((struct type
*) NULL
,
849 follow_type
, range_type
);
852 follow_type
= lookup_pointer_type (follow_type
);
855 follow_type
= lookup_function_type (follow_type
);
864 type_stack_size
= 80;
865 type_stack_depth
= 0;
866 type_stack
= (union type_stack_elt
*)
867 xmalloc (type_stack_size
* sizeof (*type_stack
));
869 /* We don't worry too much about what the name of this type is
870 because the name should rarely appear in output to the user. */
873 init_type (TYPE_CODE_PTR
, TARGET_PTR_BIT
/ HOST_CHAR_BIT
, 0,
This page took 0.046852 seconds and 4 git commands to generate.