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. */
52 /* Symbols which architectures can redefine. */
54 /* Some systems have routines whose names start with `$'. Giving this
55 macro a non-zero value tells GDB's expression parser to check for
56 such routines when parsing tokens that begin with `$'.
58 On HP-UX, certain system routines (millicode) have names beginning
59 with `$' or `$$'. For example, `$$dyncall' is a millicode routine
60 that handles inter-space procedure calls on PA-RISC. */
61 #ifndef SYMBOLS_CAN_START_WITH_DOLLAR
62 #define SYMBOLS_CAN_START_WITH_DOLLAR (0)
67 /* Global variables declared in parser-defs.h (and commented there). */
68 struct expression *expout;
71 struct block *expression_context_block;
72 struct block *innermost_block;
74 union type_stack_elt *type_stack;
75 int type_stack_depth, type_stack_size;
81 static int expressiondebug = 0;
83 extern int hp_som_som_object_present;
85 static void free_funcalls (void *ignore);
87 static void prefixify_expression (struct expression *);
90 prefixify_subexp (struct expression *, struct expression *, int, int);
92 void _initialize_parse (void);
94 /* Data structure for saving values of arglist_len for function calls whose
95 arguments contain other function calls. */
103 static struct funcall *funcall_chain;
105 /* Assign machine-independent names to certain registers
106 (unless overridden by the REGISTER_NAMES table) */
108 unsigned num_std_regs = 0;
109 struct std_regs *std_regs;
111 /* The generic method for targets to specify how their registers are
112 named. The mapping can be derived from three sources:
113 REGISTER_NAME; std_regs; or a target specific alias hook. */
116 target_map_name_to_register (char *str, int len)
120 /* Search register name space. */
121 for (i = 0; i < NUM_REGS + NUM_PSEUDO_REGS; i++)
122 if (REGISTER_NAME (i) && len == strlen (REGISTER_NAME (i))
123 && STREQN (str, REGISTER_NAME (i), len))
128 /* Try standard aliases. */
129 for (i = 0; i < num_std_regs; i++)
130 if (std_regs[i].name && len == strlen (std_regs[i].name)
131 && STREQN (str, std_regs[i].name, len))
133 return std_regs[i].regnum;
139 /* Begin counting arguments for a function call,
140 saving the data about any containing call. */
145 register struct funcall *new;
147 new = (struct funcall *) xmalloc (sizeof (struct funcall));
148 new->next = funcall_chain;
149 new->arglist_len = arglist_len;
154 /* Return the number of arguments in a function call just terminated,
155 and restore the data for the containing function call. */
160 register int val = arglist_len;
161 register struct funcall *call = funcall_chain;
162 funcall_chain = call->next;
163 arglist_len = call->arglist_len;
168 /* Free everything in the funcall chain.
169 Used when there is an error inside parsing. */
172 free_funcalls (void *ignore)
174 register struct funcall *call, *next;
176 for (call = funcall_chain; call; call = next)
183 /* This page contains the functions for adding data to the struct expression
184 being constructed. */
186 /* Add one element to the end of the expression. */
188 /* To avoid a bug in the Sun 4 compiler, we pass things that can fit into
189 a register through here */
192 write_exp_elt (union exp_element expelt)
194 if (expout_ptr >= expout_size)
197 expout = (struct expression *)
198 xrealloc ((char *) expout, sizeof (struct expression)
199 + EXP_ELEM_TO_BYTES (expout_size));
201 expout->elts[expout_ptr++] = expelt;
205 write_exp_elt_opcode (enum exp_opcode expelt)
207 union exp_element tmp;
215 write_exp_elt_sym (struct symbol *expelt)
217 union exp_element tmp;
225 write_exp_elt_block (struct block *b)
227 union exp_element tmp;
233 write_exp_elt_longcst (LONGEST expelt)
235 union exp_element tmp;
237 tmp.longconst = expelt;
243 write_exp_elt_dblcst (DOUBLEST expelt)
245 union exp_element tmp;
247 tmp.doubleconst = expelt;
253 write_exp_elt_type (struct type *expelt)
255 union exp_element tmp;
263 write_exp_elt_intern (struct internalvar *expelt)
265 union exp_element tmp;
267 tmp.internalvar = expelt;
272 /* Add a string constant to the end of the expression.
274 String constants are stored by first writing an expression element
275 that contains the length of the string, then stuffing the string
276 constant itself into however many expression elements are needed
277 to hold it, and then writing another expression element that contains
278 the length of the string. I.E. an expression element at each end of
279 the string records the string length, so you can skip over the
280 expression elements containing the actual string bytes from either
281 end of the string. Note that this also allows gdb to handle
282 strings with embedded null bytes, as is required for some languages.
284 Don't be fooled by the fact that the string is null byte terminated,
285 this is strictly for the convenience of debugging gdb itself. Gdb
286 Gdb does not depend up the string being null terminated, since the
287 actual length is recorded in expression elements at each end of the
288 string. The null byte is taken into consideration when computing how
289 many expression elements are required to hold the string constant, of
294 write_exp_string (struct stoken str)
296 register int len = str.length;
298 register char *strdata;
300 /* Compute the number of expression elements required to hold the string
301 (including a null byte terminator), along with one expression element
302 at each end to record the actual string length (not including the
303 null byte terminator). */
305 lenelt = 2 + BYTES_TO_EXP_ELEM (len + 1);
307 /* Ensure that we have enough available expression elements to store
310 if ((expout_ptr + lenelt) >= expout_size)
312 expout_size = max (expout_size * 2, expout_ptr + lenelt + 10);
313 expout = (struct expression *)
314 xrealloc ((char *) expout, (sizeof (struct expression)
315 + EXP_ELEM_TO_BYTES (expout_size)));
318 /* Write the leading length expression element (which advances the current
319 expression element index), then write the string constant followed by a
320 terminating null byte, and then write the trailing length expression
323 write_exp_elt_longcst ((LONGEST) len);
324 strdata = (char *) &expout->elts[expout_ptr];
325 memcpy (strdata, str.ptr, len);
326 *(strdata + len) = '\0';
327 expout_ptr += lenelt - 2;
328 write_exp_elt_longcst ((LONGEST) len);
331 /* Add a bitstring constant to the end of the expression.
333 Bitstring constants are stored by first writing an expression element
334 that contains the length of the bitstring (in bits), then stuffing the
335 bitstring constant itself into however many expression elements are
336 needed to hold it, and then writing another expression element that
337 contains the length of the bitstring. I.E. an expression element at
338 each end of the bitstring records the bitstring length, so you can skip
339 over the expression elements containing the actual bitstring bytes from
340 either end of the bitstring. */
343 write_exp_bitstring (struct stoken str)
345 register int bits = str.length; /* length in bits */
346 register int len = (bits + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
348 register char *strdata;
350 /* Compute the number of expression elements required to hold the bitstring,
351 along with one expression element at each end to record the actual
352 bitstring length in bits. */
354 lenelt = 2 + BYTES_TO_EXP_ELEM (len);
356 /* Ensure that we have enough available expression elements to store
359 if ((expout_ptr + lenelt) >= expout_size)
361 expout_size = max (expout_size * 2, expout_ptr + lenelt + 10);
362 expout = (struct expression *)
363 xrealloc ((char *) expout, (sizeof (struct expression)
364 + EXP_ELEM_TO_BYTES (expout_size)));
367 /* Write the leading length expression element (which advances the current
368 expression element index), then write the bitstring constant, and then
369 write the trailing length expression element. */
371 write_exp_elt_longcst ((LONGEST) bits);
372 strdata = (char *) &expout->elts[expout_ptr];
373 memcpy (strdata, str.ptr, len);
374 expout_ptr += lenelt - 2;
375 write_exp_elt_longcst ((LONGEST) bits);
378 /* Add the appropriate elements for a minimal symbol to the end of
379 the expression. The rationale behind passing in text_symbol_type and
380 data_symbol_type was so that Modula-2 could pass in WORD for
381 data_symbol_type. Perhaps it still is useful to have those types vary
382 based on the language, but they no longer have names like "int", so
383 the initial rationale is gone. */
385 static struct type *msym_text_symbol_type;
386 static struct type *msym_data_symbol_type;
387 static struct type *msym_unknown_symbol_type;
390 write_exp_msymbol (struct minimal_symbol *msymbol,
391 struct type *text_symbol_type,
392 struct type *data_symbol_type)
396 write_exp_elt_opcode (OP_LONG);
397 /* Let's make the type big enough to hold a 64-bit address. */
398 write_exp_elt_type (builtin_type_CORE_ADDR);
400 addr = SYMBOL_VALUE_ADDRESS (msymbol);
401 if (overlay_debugging)
402 addr = symbol_overlayed_address (addr, SYMBOL_BFD_SECTION (msymbol));
403 write_exp_elt_longcst ((LONGEST) addr);
405 write_exp_elt_opcode (OP_LONG);
407 write_exp_elt_opcode (UNOP_MEMVAL);
408 switch (msymbol->type)
412 case mst_solib_trampoline:
413 write_exp_elt_type (msym_text_symbol_type);
420 write_exp_elt_type (msym_data_symbol_type);
424 write_exp_elt_type (msym_unknown_symbol_type);
427 write_exp_elt_opcode (UNOP_MEMVAL);
430 /* Recognize tokens that start with '$'. These include:
432 $regname A native register name or a "standard
435 $variable A convenience variable with a name chosen
438 $digits Value history with index <digits>, starting
439 from the first value which has index 1.
441 $$digits Value history with index <digits> relative
442 to the last value. I.E. $$0 is the last
443 value, $$1 is the one previous to that, $$2
444 is the one previous to $$1, etc.
446 $ | $0 | $$0 The last value in the value history.
448 $$ An abbreviation for the second to the last
449 value in the value history, I.E. $$1
454 write_dollar_variable (struct stoken str)
456 /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
457 and $$digits (equivalent to $<-digits> if you could type that). */
461 /* Double dollar means negate the number and add -1 as well.
462 Thus $$ alone means -1. */
463 if (str.length >= 2 && str.ptr[1] == '$')
470 /* Just dollars (one or two) */
474 /* Is the rest of the token digits? */
475 for (; i < str.length; i++)
476 if (!(str.ptr[i] >= '0' && str.ptr[i] <= '9'))
480 i = atoi (str.ptr + 1 + negate);
486 /* Handle tokens that refer to machine registers:
487 $ followed by a register name. */
488 i = target_map_name_to_register (str.ptr + 1, str.length - 1);
490 goto handle_register;
492 if (SYMBOLS_CAN_START_WITH_DOLLAR)
494 struct symbol *sym = NULL;
495 struct minimal_symbol *msym = NULL;
497 /* On HP-UX, certain system routines (millicode) have names beginning
498 with $ or $$, e.g. $$dyncall, which handles inter-space procedure
499 calls on PA-RISC. Check for those, first. */
501 /* This code is not enabled on non HP-UX systems, since worst case
502 symbol table lookup performance is awful, to put it mildly. */
504 sym = lookup_symbol (copy_name (str), (struct block *) NULL,
505 VAR_NAMESPACE, (int *) NULL, (struct symtab **) NULL);
508 write_exp_elt_opcode (OP_VAR_VALUE);
509 write_exp_elt_block (block_found); /* set by lookup_symbol */
510 write_exp_elt_sym (sym);
511 write_exp_elt_opcode (OP_VAR_VALUE);
514 msym = lookup_minimal_symbol (copy_name (str), NULL, NULL);
517 write_exp_msymbol (msym,
518 lookup_function_type (builtin_type_int),
524 /* Any other names starting in $ are debugger internal variables. */
526 write_exp_elt_opcode (OP_INTERNALVAR);
527 write_exp_elt_intern (lookup_internalvar (copy_name (str) + 1));
528 write_exp_elt_opcode (OP_INTERNALVAR);
531 write_exp_elt_opcode (OP_LAST);
532 write_exp_elt_longcst ((LONGEST) i);
533 write_exp_elt_opcode (OP_LAST);
536 write_exp_elt_opcode (OP_REGISTER);
537 write_exp_elt_longcst (i);
538 write_exp_elt_opcode (OP_REGISTER);
543 /* Parse a string that is possibly a namespace / nested class
544 specification, i.e., something of the form A::B::C::x. Input
545 (NAME) is the entire string; LEN is the current valid length; the
546 output is a string, TOKEN, which points to the largest recognized
547 prefix which is a series of namespaces or classes. CLASS_PREFIX is
548 another output, which records whether a nested class spec was
549 recognized (= 1) or a fully qualified variable name was found (=
550 0). ARGPTR is side-effected (if non-NULL) to point to beyond the
551 string recognized and consumed by this routine.
553 The return value is a pointer to the symbol for the base class or
554 variable if found, or NULL if not found. Callers must check this
555 first -- if NULL, the outputs may not be correct.
557 This function is used c-exp.y. This is used specifically to get
558 around HP aCC (and possibly other compilers), which insists on
559 generating names with embedded colons for namespace or nested class
562 (Argument LEN is currently unused. 1997-08-27)
564 Callers must free memory allocated for the output string TOKEN. */
566 static const char coloncolon[2] =
570 parse_nested_classes_for_hpacc (char *name, int len, char **token,
571 int *class_prefix, char **argptr)
573 /* Comment below comes from decode_line_1 which has very similar
574 code, which is called for "break" command parsing. */
576 /* We have what looks like a class or namespace
577 scope specification (A::B), possibly with many
578 levels of namespaces or classes (A::B::C::D).
580 Some versions of the HP ANSI C++ compiler (as also possibly
581 other compilers) generate class/function/member names with
582 embedded double-colons if they are inside namespaces. To
583 handle this, we loop a few times, considering larger and
584 larger prefixes of the string as though they were single
585 symbols. So, if the initially supplied string is
586 A::B::C::D::foo, we have to look up "A", then "A::B",
587 then "A::B::C", then "A::B::C::D", and finally
588 "A::B::C::D::foo" as single, monolithic symbols, because
589 A, B, C or D may be namespaces.
591 Note that namespaces can nest only inside other
592 namespaces, and not inside classes. So we need only
593 consider *prefixes* of the string; there is no need to look up
594 "B::C" separately as a symbol in the previous example. */
600 struct symbol *sym_class = NULL;
601 struct symbol *sym_var = NULL;
607 /* Check for HP-compiled executable -- in other cases
608 return NULL, and caller must default to standard GDB
611 if (!hp_som_som_object_present)
612 return (struct symbol *) NULL;
616 /* Skip over whitespace and possible global "::" */
617 while (*p && (*p == ' ' || *p == '\t'))
619 if (p[0] == ':' && p[1] == ':')
621 while (*p && (*p == ' ' || *p == '\t'))
626 /* Get to the end of the next namespace or class spec. */
627 /* If we're looking at some non-token, fail immediately */
629 if (!(isalpha (*p) || *p == '$' || *p == '_'))
630 return (struct symbol *) NULL;
632 while (*p && (isalnum (*p) || *p == '$' || *p == '_'))
637 /* If we have the start of a template specification,
638 scan right ahead to its end */
639 q = find_template_name_end (p);
646 /* Skip over "::" and whitespace for next time around */
647 while (*p && (*p == ' ' || *p == '\t'))
649 if (p[0] == ':' && p[1] == ':')
651 while (*p && (*p == ' ' || *p == '\t'))
654 /* Done with tokens? */
655 if (!*p || !(isalpha (*p) || *p == '$' || *p == '_'))
658 tmp = (char *) alloca (prefix_len + end - start + 3);
661 memcpy (tmp, prefix, prefix_len);
662 memcpy (tmp + prefix_len, coloncolon, 2);
663 memcpy (tmp + prefix_len + 2, start, end - start);
664 tmp[prefix_len + 2 + end - start] = '\000';
668 memcpy (tmp, start, end - start);
669 tmp[end - start] = '\000';
673 prefix_len = strlen (prefix);
675 /* See if the prefix we have now is something we know about */
679 /* More tokens to process, so this must be a class/namespace */
680 sym_class = lookup_symbol (prefix, 0, STRUCT_NAMESPACE,
681 0, (struct symtab **) NULL);
685 /* No more tokens, so try as a variable first */
686 sym_var = lookup_symbol (prefix, 0, VAR_NAMESPACE,
687 0, (struct symtab **) NULL);
688 /* If failed, try as class/namespace */
690 sym_class = lookup_symbol (prefix, 0, STRUCT_NAMESPACE,
691 0, (struct symtab **) NULL);
696 (t = check_typedef (SYMBOL_TYPE (sym_class)),
697 (TYPE_CODE (t) == TYPE_CODE_STRUCT
698 || TYPE_CODE (t) == TYPE_CODE_UNION))))
700 /* We found a valid token */
701 *token = (char *) xmalloc (prefix_len + 1);
702 memcpy (*token, prefix, prefix_len);
703 (*token)[prefix_len] = '\000';
707 /* No variable or class/namespace found, no more tokens */
709 return (struct symbol *) NULL;
712 /* Out of loop, so we must have found a valid token */
719 *argptr = done ? p : end;
721 return sym_var ? sym_var : sym_class; /* found */
725 find_template_name_end (char *p)
728 int just_seen_right = 0;
729 int just_seen_colon = 0;
730 int just_seen_space = 0;
732 if (!p || (*p != '<'))
743 /* In future, may want to allow these?? */
746 depth++; /* start nested template */
747 if (just_seen_colon || just_seen_right || just_seen_space)
748 return 0; /* but not after : or :: or > or space */
751 if (just_seen_colon || just_seen_right)
752 return 0; /* end a (nested?) template */
753 just_seen_right = 1; /* but not after : or :: */
754 if (--depth == 0) /* also disallow >>, insist on > > */
755 return ++p; /* if outermost ended, return */
758 if (just_seen_space || (just_seen_colon > 1))
759 return 0; /* nested class spec coming up */
760 just_seen_colon++; /* we allow :: but not :::: */
765 if (!((*p >= 'a' && *p <= 'z') || /* allow token chars */
766 (*p >= 'A' && *p <= 'Z') ||
767 (*p >= '0' && *p <= '9') ||
768 (*p == '_') || (*p == ',') || /* commas for template args */
769 (*p == '&') || (*p == '*') || /* pointer and ref types */
770 (*p == '(') || (*p == ')') || /* function types */
771 (*p == '[') || (*p == ']'))) /* array types */
786 /* Return a null-terminated temporary copy of the name
787 of a string token. */
790 copy_name (struct stoken token)
792 memcpy (namecopy, token.ptr, token.length);
793 namecopy[token.length] = 0;
797 /* Reverse an expression from suffix form (in which it is constructed)
798 to prefix form (in which we can conveniently print or execute it). */
801 prefixify_expression (register struct expression *expr)
804 sizeof (struct expression) + EXP_ELEM_TO_BYTES (expr->nelts);
805 register struct expression *temp;
806 register int inpos = expr->nelts, outpos = 0;
808 temp = (struct expression *) alloca (len);
810 /* Copy the original expression into temp. */
811 memcpy (temp, expr, len);
813 prefixify_subexp (temp, expr, inpos, outpos);
816 /* Return the number of exp_elements in the subexpression of EXPR
817 whose last exp_element is at index ENDPOS - 1 in EXPR. */
820 length_of_subexp (register struct expression *expr, register int endpos)
822 register int oplen = 1;
823 register int args = 0;
827 error ("?error in length_of_subexp");
829 i = (int) expr->elts[endpos - 1].opcode;
835 oplen = longest_to_int (expr->elts[endpos - 2].longconst);
836 oplen = 5 + BYTES_TO_EXP_ELEM (oplen + 1);
859 case OP_F77_UNDETERMINED_ARGLIST:
861 args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
889 case STRUCTOP_STRUCT:
897 oplen = longest_to_int (expr->elts[endpos - 2].longconst);
898 oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
902 oplen = longest_to_int (expr->elts[endpos - 2].longconst);
903 oplen = (oplen + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
904 oplen = 4 + BYTES_TO_EXP_ELEM (oplen);
909 args = longest_to_int (expr->elts[endpos - 2].longconst);
910 args -= longest_to_int (expr->elts[endpos - 3].longconst);
916 case TERNOP_SLICE_COUNT:
921 case MULTI_SUBSCRIPT:
923 args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
926 case BINOP_ASSIGN_MODIFY:
937 args = 1 + (i < (int) BINOP_END);
942 oplen += length_of_subexp (expr, endpos - oplen);
949 /* Copy the subexpression ending just before index INEND in INEXPR
950 into OUTEXPR, starting at index OUTBEG.
951 In the process, convert it from suffix to prefix form. */
954 prefixify_subexp (register struct expression *inexpr,
955 struct expression *outexpr, register int inend, int outbeg)
957 register int oplen = 1;
958 register int args = 0;
961 enum exp_opcode opcode;
963 /* Compute how long the last operation is (in OPLEN),
964 and also how many preceding subexpressions serve as
965 arguments for it (in ARGS). */
967 opcode = inexpr->elts[inend - 1].opcode;
972 oplen = longest_to_int (inexpr->elts[inend - 2].longconst);
973 oplen = 5 + BYTES_TO_EXP_ELEM (oplen + 1);
996 case OP_F77_UNDETERMINED_ARGLIST:
998 args = 1 + longest_to_int (inexpr->elts[inend - 2].longconst);
1024 case STRUCTOP_STRUCT:
1033 oplen = longest_to_int (inexpr->elts[inend - 2].longconst);
1034 oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
1038 oplen = longest_to_int (inexpr->elts[inend - 2].longconst);
1039 oplen = (oplen + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
1040 oplen = 4 + BYTES_TO_EXP_ELEM (oplen);
1045 args = longest_to_int (inexpr->elts[inend - 2].longconst);
1046 args -= longest_to_int (inexpr->elts[inend - 3].longconst);
1052 case TERNOP_SLICE_COUNT:
1056 case BINOP_ASSIGN_MODIFY:
1062 case MULTI_SUBSCRIPT:
1064 args = 1 + longest_to_int (inexpr->elts[inend - 2].longconst);
1073 args = 1 + ((int) opcode < (int) BINOP_END);
1076 /* Copy the final operator itself, from the end of the input
1077 to the beginning of the output. */
1079 memcpy (&outexpr->elts[outbeg], &inexpr->elts[inend],
1080 EXP_ELEM_TO_BYTES (oplen));
1083 /* Find the lengths of the arg subexpressions. */
1084 arglens = (int *) alloca (args * sizeof (int));
1085 for (i = args - 1; i >= 0; i--)
1087 oplen = length_of_subexp (inexpr, inend);
1092 /* Now copy each subexpression, preserving the order of
1093 the subexpressions, but prefixifying each one.
1094 In this loop, inend starts at the beginning of
1095 the expression this level is working on
1096 and marches forward over the arguments.
1097 outbeg does similarly in the output. */
1098 for (i = 0; i < args; i++)
1102 prefixify_subexp (inexpr, outexpr, inend, outbeg);
1107 /* This page contains the two entry points to this file. */
1109 /* Read an expression from the string *STRINGPTR points to,
1110 parse it, and return a pointer to a struct expression that we malloc.
1111 Use block BLOCK as the lexical context for variable names;
1112 if BLOCK is zero, use the block of the selected stack frame.
1113 Meanwhile, advance *STRINGPTR to point after the expression,
1114 at the first nonwhite character that is not part of the expression
1115 (possibly a null character).
1117 If COMMA is nonzero, stop if a comma is reached. */
1120 parse_exp_1 (char **stringptr, struct block *block, int comma)
1122 struct cleanup *old_chain;
1124 lexptr = *stringptr;
1127 type_stack_depth = 0;
1129 comma_terminates = comma;
1131 if (lexptr == 0 || *lexptr == 0)
1132 error_no_arg ("expression to compute");
1134 old_chain = make_cleanup (free_funcalls, 0 /*ignore*/);
1137 expression_context_block = block ? block : get_selected_block ();
1139 namecopy = (char *) alloca (strlen (lexptr) + 1);
1142 expout = (struct expression *)
1143 xmalloc (sizeof (struct expression) + EXP_ELEM_TO_BYTES (expout_size));
1144 expout->language_defn = current_language;
1145 make_cleanup (free_current_contents, &expout);
1147 if (current_language->la_parser ())
1148 current_language->la_error (NULL);
1150 discard_cleanups (old_chain);
1152 /* Record the actual number of expression elements, and then
1153 reallocate the expression memory so that we free up any
1156 expout->nelts = expout_ptr;
1157 expout = (struct expression *)
1158 xrealloc ((char *) expout,
1159 sizeof (struct expression) + EXP_ELEM_TO_BYTES (expout_ptr));;
1161 /* Convert expression from postfix form as generated by yacc
1162 parser, to a prefix form. */
1164 if (expressiondebug)
1165 dump_prefix_expression (expout, gdb_stdlog,
1166 "before conversion to prefix form");
1168 prefixify_expression (expout);
1170 if (expressiondebug)
1171 dump_postfix_expression (expout, gdb_stdlog,
1172 "after conversion to prefix form");
1174 *stringptr = lexptr;
1178 /* Parse STRING as an expression, and complain if this fails
1179 to use up all of the contents of STRING. */
1182 parse_expression (char *string)
1184 register struct expression *exp;
1185 exp = parse_exp_1 (&string, 0, 0);
1187 error ("Junk after end of expression.");
1191 /* Stuff for maintaining a stack of types. Currently just used by C, but
1192 probably useful for any language which declares its types "backwards". */
1195 check_type_stack_depth (void)
1197 if (type_stack_depth == type_stack_size)
1199 type_stack_size *= 2;
1200 type_stack = (union type_stack_elt *)
1201 xrealloc ((char *) type_stack, type_stack_size * sizeof (*type_stack));
1206 push_type (enum type_pieces tp)
1208 check_type_stack_depth ();
1209 type_stack[type_stack_depth++].piece = tp;
1213 push_type_int (int n)
1215 check_type_stack_depth ();
1216 type_stack[type_stack_depth++].int_val = n;
1220 push_type_address_space (char *string)
1222 push_type_int (address_space_name_to_int (string));
1228 if (type_stack_depth)
1229 return type_stack[--type_stack_depth].piece;
1236 if (type_stack_depth)
1237 return type_stack[--type_stack_depth].int_val;
1238 /* "Can't happen". */
1242 /* Pop the type stack and return the type which corresponds to FOLLOW_TYPE
1243 as modified by all the stuff on the stack. */
1245 follow_types (struct type *follow_type)
1249 int make_volatile = 0;
1250 int make_addr_space = 0;
1252 struct type *range_type;
1255 switch (pop_type ())
1260 follow_type = make_cv_type (make_const,
1261 TYPE_VOLATILE (follow_type),
1264 follow_type = make_cv_type (TYPE_CONST (follow_type),
1267 if (make_addr_space)
1268 follow_type = make_type_with_address_space (follow_type,
1270 make_const = make_volatile = 0;
1271 make_addr_space = 0;
1279 case tp_space_identifier:
1280 make_addr_space = pop_type_int ();
1283 follow_type = lookup_pointer_type (follow_type);
1285 follow_type = make_cv_type (make_const,
1286 TYPE_VOLATILE (follow_type),
1289 follow_type = make_cv_type (TYPE_CONST (follow_type),
1292 if (make_addr_space)
1293 follow_type = make_type_with_address_space (follow_type,
1295 make_const = make_volatile = 0;
1296 make_addr_space = 0;
1299 follow_type = lookup_reference_type (follow_type);
1301 follow_type = make_cv_type (make_const,
1302 TYPE_VOLATILE (follow_type),
1305 follow_type = make_cv_type (TYPE_CONST (follow_type),
1308 if (make_addr_space)
1309 follow_type = make_type_with_address_space (follow_type,
1311 make_const = make_volatile = 0;
1312 make_addr_space = 0;
1315 array_size = pop_type_int ();
1316 /* FIXME-type-allocation: need a way to free this type when we are
1319 create_range_type ((struct type *) NULL,
1320 builtin_type_int, 0,
1321 array_size >= 0 ? array_size - 1 : 0);
1323 create_array_type ((struct type *) NULL,
1324 follow_type, range_type);
1326 TYPE_ARRAY_UPPER_BOUND_TYPE (follow_type)
1327 = BOUND_CANNOT_BE_DETERMINED;
1330 /* FIXME-type-allocation: need a way to free this type when we are
1332 follow_type = lookup_function_type (follow_type);
1338 static void build_parse (void);
1344 msym_text_symbol_type =
1345 init_type (TYPE_CODE_FUNC, 1, 0, "<text variable, no debug info>", NULL);
1346 TYPE_TARGET_TYPE (msym_text_symbol_type) = builtin_type_int;
1347 msym_data_symbol_type =
1348 init_type (TYPE_CODE_INT, TARGET_INT_BIT / HOST_CHAR_BIT, 0,
1349 "<data variable, no debug info>", NULL);
1350 msym_unknown_symbol_type =
1351 init_type (TYPE_CODE_INT, 1, 0,
1352 "<variable (not text or data), no debug info>",
1355 /* create the std_regs table */
1374 /* create an empty table */
1375 std_regs = xmalloc ((num_std_regs + 1) * sizeof *std_regs);
1381 std_regs[i].name = "pc";
1382 std_regs[i].regnum = PC_REGNUM;
1389 std_regs[i].name = "fp";
1390 std_regs[i].regnum = FP_REGNUM;
1397 std_regs[i].name = "sp";
1398 std_regs[i].regnum = SP_REGNUM;
1405 std_regs[i].name = "ps";
1406 std_regs[i].regnum = PS_REGNUM;
1410 memset (&std_regs[i], 0, sizeof (std_regs[i]));
1414 _initialize_parse (void)
1416 type_stack_size = 80;
1417 type_stack_depth = 0;
1418 type_stack = (union type_stack_elt *)
1419 xmalloc (type_stack_size * sizeof (*type_stack));
1423 /* FIXME - For the moment, handle types by swapping them in and out.
1424 Should be using the per-architecture data-pointer and a large
1426 register_gdbarch_swap (&msym_text_symbol_type, sizeof (msym_text_symbol_type), NULL);
1427 register_gdbarch_swap (&msym_data_symbol_type, sizeof (msym_data_symbol_type), NULL);
1428 register_gdbarch_swap (&msym_unknown_symbol_type, sizeof (msym_unknown_symbol_type), NULL);
1430 register_gdbarch_swap (&num_std_regs, sizeof (std_regs), NULL);
1431 register_gdbarch_swap (&std_regs, sizeof (std_regs), NULL);
1432 register_gdbarch_swap (NULL, 0, build_parse);
1435 add_set_cmd ("expression", class_maintenance, var_zinteger,
1436 (char *) &expressiondebug,
1437 "Set expression debugging.\n\
1438 When non-zero, the internal representation of expressions will be printed.",