GDB (xrefs)
/tmp/gdb-7.10/gdb/parse.c
Go to the documentation of this file.
1 /* Parse expressions for GDB.
2 
3  Copyright (C) 1986-2015 Free Software Foundation, Inc.
4 
5  Modified from expread.y by the Department of Computer Science at the
6  State University of New York at Buffalo, 1991.
7 
8  This file is part of GDB.
9 
10  This program is free software; you can redistribute it and/or modify
11  it under the terms of the GNU General Public License as published by
12  the Free Software Foundation; either version 3 of the License, or
13  (at your option) any later version.
14 
15  This program is distributed in the hope that it will be useful,
16  but WITHOUT ANY WARRANTY; without even the implied warranty of
17  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18  GNU General Public License for more details.
19 
20  You should have received a copy of the GNU General Public License
21  along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 
23 /* Parse an expression from text in a string,
24  and return the result as a struct expression pointer.
25  That structure contains arithmetic operations in reverse polish,
26  with constants represented by operations that are followed by special data.
27  See expression.h for the details of the format.
28  What is important here is that it can be built up sequentially
29  during the process of parsing; the lower levels of the tree always
30  come first in the result. */
31 
32 #include "defs.h"
33 #include <ctype.h>
34 #include "arch-utils.h"
35 #include "symtab.h"
36 #include "gdbtypes.h"
37 #include "frame.h"
38 #include "expression.h"
39 #include "value.h"
40 #include "command.h"
41 #include "language.h"
42 #include "f-lang.h"
43 #include "parser-defs.h"
44 #include "gdbcmd.h"
45 #include "symfile.h" /* for overlay functions */
46 #include "inferior.h"
47 #include "doublest.h"
48 #include "block.h"
49 #include "source.h"
50 #include "objfiles.h"
51 #include "user-regs.h"
52 
53 /* Standard set of definitions for printing, dumping, prefixifying,
54  * and evaluating expressions. */
55 
56 const struct exp_descriptor exp_descriptor_standard =
57  {
64  };
65 
66 /* Global variables declared in parser-defs.h (and commented there). */
69 const struct block *innermost_block;
71 static struct type_stack type_stack;
72 const char *lexptr;
73 const char *prev_lexptr;
76 
77 /* True if parsing an expression to attempt completion. */
79 
80 /* The index of the last struct expression directly before a '.' or
81  '->'. This is set when parsing and is only used when completing a
82  field name. It is -1 if no dereference operation was found. */
83 static int expout_last_struct = -1;
84 
85 /* If we are completing a tagged type name, this will be nonzero. */
87 
88 /* The token for tagged type name completion. */
90 
91 
92 static unsigned int expressiondebug = 0;
93 static void
94 show_expressiondebug (struct ui_file *file, int from_tty,
95  struct cmd_list_element *c, const char *value)
96 {
97  fprintf_filtered (file, _("Expression debugging is %s.\n"), value);
98 }
99 
100 
101 /* Non-zero if an expression parser should set yydebug. */
103 
104 static void
105 show_parserdebug (struct ui_file *file, int from_tty,
106  struct cmd_list_element *c, const char *value)
107 {
108  fprintf_filtered (file, _("Parser debugging is %s.\n"), value);
109 }
110 
111 
112 static void free_funcalls (void *ignore);
113 
114 static int prefixify_subexp (struct expression *, struct expression *, int,
115  int);
116 
117 static struct expression *parse_exp_in_context (const char **, CORE_ADDR,
118  const struct block *, int,
119  int, int *);
120 static struct expression *parse_exp_in_context_1 (const char **, CORE_ADDR,
121  const struct block *, int,
122  int, int *);
123 
124 void _initialize_parse (void);
125 
126 /* Data structure for saving values of arglist_len for function calls whose
127  arguments contain other function calls. */
128 
129 struct funcall
130  {
131  struct funcall *next;
133  };
134 
135 static struct funcall *funcall_chain;
136 
137 /* Begin counting arguments for a function call,
138  saving the data about any containing call. */
139 
140 void
142 {
143  struct funcall *newobj;
144 
145  newobj = (struct funcall *) xmalloc (sizeof (struct funcall));
146  newobj->next = funcall_chain;
147  newobj->arglist_len = arglist_len;
148  arglist_len = 0;
149  funcall_chain = newobj;
150 }
151 
152 /* Return the number of arguments in a function call just terminated,
153  and restore the data for the containing function call. */
154 
155 int
157 {
158  int val = arglist_len;
159  struct funcall *call = funcall_chain;
160 
161  funcall_chain = call->next;
162  arglist_len = call->arglist_len;
163  xfree (call);
164  return val;
165 }
166 
167 /* Free everything in the funcall chain.
168  Used when there is an error inside parsing. */
169 
170 static void
172 {
173  struct funcall *call, *next;
174 
175  for (call = funcall_chain; call; call = next)
176  {
177  next = call->next;
178  xfree (call);
179  }
180 }
181 
182 
183 /* See definition in parser-defs.h. */
184 
185 void
186 initialize_expout (struct parser_state *ps, size_t initial_size,
187  const struct language_defn *lang,
188  struct gdbarch *gdbarch)
189 {
190  ps->expout_size = initial_size;
191  ps->expout_ptr = 0;
192  ps->expout = xmalloc (sizeof (struct expression)
194  ps->expout->language_defn = lang;
195  ps->expout->gdbarch = gdbarch;
196 }
197 
198 /* See definition in parser-defs.h. */
199 
200 void
202 {
203  /* Record the actual number of expression elements, and then
204  reallocate the expression memory so that we free up any
205  excess elements. */
206 
207  ps->expout->nelts = ps->expout_ptr;
208  ps->expout = (struct expression *)
209  xrealloc (ps->expout,
210  sizeof (struct expression)
211  + EXP_ELEM_TO_BYTES (ps->expout_ptr));
212 }
213 
214 /* This page contains the functions for adding data to the struct expression
215  being constructed. */
216 
217 /* Add one element to the end of the expression. */
218 
219 /* To avoid a bug in the Sun 4 compiler, we pass things that can fit into
220  a register through here. */
221 
222 static void
223 write_exp_elt (struct parser_state *ps, const union exp_element *expelt)
224 {
225  if (ps->expout_ptr >= ps->expout_size)
226  {
227  ps->expout_size *= 2;
228  ps->expout = (struct expression *)
229  xrealloc (ps->expout, sizeof (struct expression)
231  }
232  ps->expout->elts[ps->expout_ptr++] = *expelt;
233 }
234 
235 void
237 {
238  union exp_element tmp;
239 
240  memset (&tmp, 0, sizeof (union exp_element));
241  tmp.opcode = expelt;
242  write_exp_elt (ps, &tmp);
243 }
244 
245 void
246 write_exp_elt_sym (struct parser_state *ps, struct symbol *expelt)
247 {
248  union exp_element tmp;
249 
250  memset (&tmp, 0, sizeof (union exp_element));
251  tmp.symbol = expelt;
252  write_exp_elt (ps, &tmp);
253 }
254 
255 void
256 write_exp_elt_block (struct parser_state *ps, const struct block *b)
257 {
258  union exp_element tmp;
259 
260  memset (&tmp, 0, sizeof (union exp_element));
261  tmp.block = b;
262  write_exp_elt (ps, &tmp);
263 }
264 
265 void
267 {
268  union exp_element tmp;
269 
270  memset (&tmp, 0, sizeof (union exp_element));
271  tmp.objfile = objfile;
272  write_exp_elt (ps, &tmp);
273 }
274 
275 void
277 {
278  union exp_element tmp;
279 
280  memset (&tmp, 0, sizeof (union exp_element));
281  tmp.longconst = expelt;
282  write_exp_elt (ps, &tmp);
283 }
284 
285 void
287 {
288  union exp_element tmp;
289 
290  memset (&tmp, 0, sizeof (union exp_element));
291  tmp.doubleconst = expelt;
292  write_exp_elt (ps, &tmp);
293 }
294 
295 void
297 {
298  union exp_element tmp;
299  int index;
300 
301  for (index = 0; index < 16; index++)
302  tmp.decfloatconst[index] = expelt[index];
303 
304  write_exp_elt (ps, &tmp);
305 }
306 
307 void
308 write_exp_elt_type (struct parser_state *ps, struct type *expelt)
309 {
310  union exp_element tmp;
311 
312  memset (&tmp, 0, sizeof (union exp_element));
313  tmp.type = expelt;
314  write_exp_elt (ps, &tmp);
315 }
316 
317 void
319 {
320  union exp_element tmp;
321 
322  memset (&tmp, 0, sizeof (union exp_element));
323  tmp.internalvar = expelt;
324  write_exp_elt (ps, &tmp);
325 }
326 
327 /* Add a string constant to the end of the expression.
328 
329  String constants are stored by first writing an expression element
330  that contains the length of the string, then stuffing the string
331  constant itself into however many expression elements are needed
332  to hold it, and then writing another expression element that contains
333  the length of the string. I.e. an expression element at each end of
334  the string records the string length, so you can skip over the
335  expression elements containing the actual string bytes from either
336  end of the string. Note that this also allows gdb to handle
337  strings with embedded null bytes, as is required for some languages.
338 
339  Don't be fooled by the fact that the string is null byte terminated,
340  this is strictly for the convenience of debugging gdb itself.
341  Gdb does not depend up the string being null terminated, since the
342  actual length is recorded in expression elements at each end of the
343  string. The null byte is taken into consideration when computing how
344  many expression elements are required to hold the string constant, of
345  course. */
346 
347 
348 void
349 write_exp_string (struct parser_state *ps, struct stoken str)
350 {
351  int len = str.length;
352  size_t lenelt;
353  char *strdata;
354 
355  /* Compute the number of expression elements required to hold the string
356  (including a null byte terminator), along with one expression element
357  at each end to record the actual string length (not including the
358  null byte terminator). */
359 
360  lenelt = 2 + BYTES_TO_EXP_ELEM (len + 1);
361 
362  increase_expout_size (ps, lenelt);
363 
364  /* Write the leading length expression element (which advances the current
365  expression element index), then write the string constant followed by a
366  terminating null byte, and then write the trailing length expression
367  element. */
368 
369  write_exp_elt_longcst (ps, (LONGEST) len);
370  strdata = (char *) &ps->expout->elts[ps->expout_ptr];
371  memcpy (strdata, str.ptr, len);
372  *(strdata + len) = '\0';
373  ps->expout_ptr += lenelt - 2;
374  write_exp_elt_longcst (ps, (LONGEST) len);
375 }
376 
377 /* Add a vector of string constants to the end of the expression.
378 
379  This adds an OP_STRING operation, but encodes the contents
380  differently from write_exp_string. The language is expected to
381  handle evaluation of this expression itself.
382 
383  After the usual OP_STRING header, TYPE is written into the
384  expression as a long constant. The interpretation of this field is
385  up to the language evaluator.
386 
387  Next, each string in VEC is written. The length is written as a
388  long constant, followed by the contents of the string. */
389 
390 void
392  struct stoken_vector *vec)
393 {
394  int i, len;
395  size_t n_slots;
396 
397  /* Compute the size. We compute the size in number of slots to
398  avoid issues with string padding. */
399  n_slots = 0;
400  for (i = 0; i < vec->len; ++i)
401  {
402  /* One slot for the length of this element, plus the number of
403  slots needed for this string. */
404  n_slots += 1 + BYTES_TO_EXP_ELEM (vec->tokens[i].length);
405  }
406 
407  /* One more slot for the type of the string. */
408  ++n_slots;
409 
410  /* Now compute a phony string length. */
411  len = EXP_ELEM_TO_BYTES (n_slots) - 1;
412 
413  n_slots += 4;
414  increase_expout_size (ps, n_slots);
415 
416  write_exp_elt_opcode (ps, OP_STRING);
417  write_exp_elt_longcst (ps, len);
418  write_exp_elt_longcst (ps, type);
419 
420  for (i = 0; i < vec->len; ++i)
421  {
422  write_exp_elt_longcst (ps, vec->tokens[i].length);
423  memcpy (&ps->expout->elts[ps->expout_ptr], vec->tokens[i].ptr,
424  vec->tokens[i].length);
425  ps->expout_ptr += BYTES_TO_EXP_ELEM (vec->tokens[i].length);
426  }
427 
428  write_exp_elt_longcst (ps, len);
429  write_exp_elt_opcode (ps, OP_STRING);
430 }
431 
432 /* Add a bitstring constant to the end of the expression.
433 
434  Bitstring constants are stored by first writing an expression element
435  that contains the length of the bitstring (in bits), then stuffing the
436  bitstring constant itself into however many expression elements are
437  needed to hold it, and then writing another expression element that
438  contains the length of the bitstring. I.e. an expression element at
439  each end of the bitstring records the bitstring length, so you can skip
440  over the expression elements containing the actual bitstring bytes from
441  either end of the bitstring. */
442 
443 void
445 {
446  int bits = str.length; /* length in bits */
447  int len = (bits + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
448  size_t lenelt;
449  char *strdata;
450 
451  /* Compute the number of expression elements required to hold the bitstring,
452  along with one expression element at each end to record the actual
453  bitstring length in bits. */
454 
455  lenelt = 2 + BYTES_TO_EXP_ELEM (len);
456 
457  increase_expout_size (ps, lenelt);
458 
459  /* Write the leading length expression element (which advances the current
460  expression element index), then write the bitstring constant, and then
461  write the trailing length expression element. */
462 
463  write_exp_elt_longcst (ps, (LONGEST) bits);
464  strdata = (char *) &ps->expout->elts[ps->expout_ptr];
465  memcpy (strdata, str.ptr, len);
466  ps->expout_ptr += lenelt - 2;
467  write_exp_elt_longcst (ps, (LONGEST) bits);
468 }
469 
470 /* Add the appropriate elements for a minimal symbol to the end of
471  the expression. */
472 
473 void
475  struct bound_minimal_symbol bound_msym)
476 {
477  struct minimal_symbol *msymbol = bound_msym.minsym;
478  struct objfile *objfile = bound_msym.objfile;
479  struct gdbarch *gdbarch = get_objfile_arch (objfile);
480 
481  CORE_ADDR addr = BMSYMBOL_VALUE_ADDRESS (bound_msym);
482  struct obj_section *section = MSYMBOL_OBJ_SECTION (objfile, msymbol);
483  enum minimal_symbol_type type = MSYMBOL_TYPE (msymbol);
484  CORE_ADDR pc;
485 
486  /* The minimal symbol might point to a function descriptor;
487  resolve it to the actual code address instead. */
488  pc = gdbarch_convert_from_func_ptr_addr (gdbarch, addr, &current_target);
489  if (pc != addr)
490  {
491  struct bound_minimal_symbol ifunc_msym = lookup_minimal_symbol_by_pc (pc);
492 
493  /* In this case, assume we have a code symbol instead of
494  a data symbol. */
495 
496  if (ifunc_msym.minsym != NULL
497  && MSYMBOL_TYPE (ifunc_msym.minsym) == mst_text_gnu_ifunc
498  && BMSYMBOL_VALUE_ADDRESS (ifunc_msym) == pc)
499  {
500  /* A function descriptor has been resolved but PC is still in the
501  STT_GNU_IFUNC resolver body (such as because inferior does not
502  run to be able to call it). */
503 
504  type = mst_text_gnu_ifunc;
505  }
506  else
507  type = mst_text;
508  section = NULL;
509  addr = pc;
510  }
511 
512  if (overlay_debugging)
513  addr = symbol_overlayed_address (addr, section);
514 
515  write_exp_elt_opcode (ps, OP_LONG);
516  /* Let's make the type big enough to hold a 64-bit address. */
517  write_exp_elt_type (ps, objfile_type (objfile)->builtin_core_addr);
518  write_exp_elt_longcst (ps, (LONGEST) addr);
519  write_exp_elt_opcode (ps, OP_LONG);
520 
521  if (section && section->the_bfd_section->flags & SEC_THREAD_LOCAL)
522  {
523  write_exp_elt_opcode (ps, UNOP_MEMVAL_TLS);
524  write_exp_elt_objfile (ps, objfile);
525  write_exp_elt_type (ps, objfile_type (objfile)->nodebug_tls_symbol);
526  write_exp_elt_opcode (ps, UNOP_MEMVAL_TLS);
527  return;
528  }
529 
530  write_exp_elt_opcode (ps, UNOP_MEMVAL);
531  switch (type)
532  {
533  case mst_text:
534  case mst_file_text:
536  write_exp_elt_type (ps, objfile_type (objfile)->nodebug_text_symbol);
537  break;
538 
539  case mst_text_gnu_ifunc:
540  write_exp_elt_type (ps, objfile_type (objfile)
541  ->nodebug_text_gnu_ifunc_symbol);
542  break;
543 
544  case mst_data:
545  case mst_file_data:
546  case mst_bss:
547  case mst_file_bss:
548  write_exp_elt_type (ps, objfile_type (objfile)->nodebug_data_symbol);
549  break;
550 
551  case mst_slot_got_plt:
552  write_exp_elt_type (ps, objfile_type (objfile)->nodebug_got_plt_symbol);
553  break;
554 
555  default:
556  write_exp_elt_type (ps, objfile_type (objfile)->nodebug_unknown_symbol);
557  break;
558  }
559  write_exp_elt_opcode (ps, UNOP_MEMVAL);
560 }
561 
562 /* Mark the current index as the starting location of a structure
563  expression. This is used when completing on field names. */
564 
565 void
567 {
568  gdb_assert (parse_completion
569  && expout_tag_completion_type == TYPE_CODE_UNDEF);
570  expout_last_struct = ps->expout_ptr;
571 }
572 
573 /* Indicate that the current parser invocation is completing a tag.
574  TAG is the type code of the tag, and PTR and LENGTH represent the
575  start of the tag name. */
576 
577 void
578 mark_completion_tag (enum type_code tag, const char *ptr, int length)
579 {
580  gdb_assert (parse_completion
581  && expout_tag_completion_type == TYPE_CODE_UNDEF
582  && expout_completion_name == NULL
583  && expout_last_struct == -1);
585  || tag == TYPE_CODE_STRUCT
586  || tag == TYPE_CODE_ENUM);
587  expout_tag_completion_type = tag;
588  expout_completion_name = xmalloc (length + 1);
589  memcpy (expout_completion_name, ptr, length);
590  expout_completion_name[length] = '\0';
591 }
592 
593 
594 /* Recognize tokens that start with '$'. These include:
595 
596  $regname A native register name or a "standard
597  register name".
598 
599  $variable A convenience variable with a name chosen
600  by the user.
601 
602  $digits Value history with index <digits>, starting
603  from the first value which has index 1.
604 
605  $$digits Value history with index <digits> relative
606  to the last value. I.e. $$0 is the last
607  value, $$1 is the one previous to that, $$2
608  is the one previous to $$1, etc.
609 
610  $ | $0 | $$0 The last value in the value history.
611 
612  $$ An abbreviation for the second to the last
613  value in the value history, I.e. $$1 */
614 
615 void
617 {
618  struct symbol *sym = NULL;
619  struct bound_minimal_symbol msym;
620  struct internalvar *isym = NULL;
621 
622  /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
623  and $$digits (equivalent to $<-digits> if you could type that). */
624 
625  int negate = 0;
626  int i = 1;
627  /* Double dollar means negate the number and add -1 as well.
628  Thus $$ alone means -1. */
629  if (str.length >= 2 && str.ptr[1] == '$')
630  {
631  negate = 1;
632  i = 2;
633  }
634  if (i == str.length)
635  {
636  /* Just dollars (one or two). */
637  i = -negate;
638  goto handle_last;
639  }
640  /* Is the rest of the token digits? */
641  for (; i < str.length; i++)
642  if (!(str.ptr[i] >= '0' && str.ptr[i] <= '9'))
643  break;
644  if (i == str.length)
645  {
646  i = atoi (str.ptr + 1 + negate);
647  if (negate)
648  i = -i;
649  goto handle_last;
650  }
651 
652  /* Handle tokens that refer to machine registers:
653  $ followed by a register name. */
655  str.ptr + 1, str.length - 1);
656  if (i >= 0)
657  goto handle_register;
658 
659  /* Any names starting with $ are probably debugger internal variables. */
660 
661  isym = lookup_only_internalvar (copy_name (str) + 1);
662  if (isym)
663  {
664  write_exp_elt_opcode (ps, OP_INTERNALVAR);
665  write_exp_elt_intern (ps, isym);
666  write_exp_elt_opcode (ps, OP_INTERNALVAR);
667  return;
668  }
669 
670  /* On some systems, such as HP-UX and hppa-linux, certain system routines
671  have names beginning with $ or $$. Check for those, first. */
672 
673  sym = lookup_symbol (copy_name (str), (struct block *) NULL,
674  VAR_DOMAIN, NULL);
675  if (sym)
676  {
677  write_exp_elt_opcode (ps, OP_VAR_VALUE);
678  write_exp_elt_block (ps, block_found); /* set by lookup_symbol */
679  write_exp_elt_sym (ps, sym);
680  write_exp_elt_opcode (ps, OP_VAR_VALUE);
681  return;
682  }
683  msym = lookup_bound_minimal_symbol (copy_name (str));
684  if (msym.minsym)
685  {
686  write_exp_msymbol (ps, msym);
687  return;
688  }
689 
690  /* Any other names are assumed to be debugger internal variables. */
691 
692  write_exp_elt_opcode (ps, OP_INTERNALVAR);
694  write_exp_elt_opcode (ps, OP_INTERNALVAR);
695  return;
696 handle_last:
697  write_exp_elt_opcode (ps, OP_LAST);
698  write_exp_elt_longcst (ps, (LONGEST) i);
699  write_exp_elt_opcode (ps, OP_LAST);
700  return;
701 handle_register:
702  write_exp_elt_opcode (ps, OP_REGISTER);
703  str.length--;
704  str.ptr++;
705  write_exp_string (ps, str);
706  write_exp_elt_opcode (ps, OP_REGISTER);
707  return;
708 }
709 
710 
711 const char *
712 find_template_name_end (const char *p)
713 {
714  int depth = 1;
715  int just_seen_right = 0;
716  int just_seen_colon = 0;
717  int just_seen_space = 0;
718 
719  if (!p || (*p != '<'))
720  return 0;
721 
722  while (*++p)
723  {
724  switch (*p)
725  {
726  case '\'':
727  case '\"':
728  case '{':
729  case '}':
730  /* In future, may want to allow these?? */
731  return 0;
732  case '<':
733  depth++; /* start nested template */
734  if (just_seen_colon || just_seen_right || just_seen_space)
735  return 0; /* but not after : or :: or > or space */
736  break;
737  case '>':
738  if (just_seen_colon || just_seen_right)
739  return 0; /* end a (nested?) template */
740  just_seen_right = 1; /* but not after : or :: */
741  if (--depth == 0) /* also disallow >>, insist on > > */
742  return ++p; /* if outermost ended, return */
743  break;
744  case ':':
745  if (just_seen_space || (just_seen_colon > 1))
746  return 0; /* nested class spec coming up */
747  just_seen_colon++; /* we allow :: but not :::: */
748  break;
749  case ' ':
750  break;
751  default:
752  if (!((*p >= 'a' && *p <= 'z') || /* allow token chars */
753  (*p >= 'A' && *p <= 'Z') ||
754  (*p >= '0' && *p <= '9') ||
755  (*p == '_') || (*p == ',') || /* commas for template args */
756  (*p == '&') || (*p == '*') || /* pointer and ref types */
757  (*p == '(') || (*p == ')') || /* function types */
758  (*p == '[') || (*p == ']'))) /* array types */
759  return 0;
760  }
761  if (*p != ' ')
762  just_seen_space = 0;
763  if (*p != ':')
764  just_seen_colon = 0;
765  if (*p != '>')
766  just_seen_right = 0;
767  }
768  return 0;
769 }
770 
771 
772 /* Return a null-terminated temporary copy of the name of a string token.
773 
774  Tokens that refer to names do so with explicit pointer and length,
775  so they can share the storage that lexptr is parsing.
776  When it is necessary to pass a name to a function that expects
777  a null-terminated string, the substring is copied out
778  into a separate block of storage.
779 
780  N.B. A single buffer is reused on each call. */
781 
782 char *
784 {
785  /* A temporary buffer for identifiers, so we can null-terminate them.
786  We allocate this with xrealloc. parse_exp_1 used to allocate with
787  alloca, using the size of the whole expression as a conservative
788  estimate of the space needed. However, macro expansion can
789  introduce names longer than the original expression; there's no
790  practical way to know beforehand how large that might be. */
791  static char *namecopy;
792  static size_t namecopy_size;
793 
794  /* Make sure there's enough space for the token. */
795  if (namecopy_size < token.length + 1)
796  {
797  namecopy_size = token.length + 1;
798  namecopy = xrealloc (namecopy, token.length + 1);
799  }
800 
801  memcpy (namecopy, token.ptr, token.length);
802  namecopy[token.length] = 0;
803 
804  return namecopy;
805 }
806 
807 
808 /* See comments on parser-defs.h. */
809 
810 int
812 {
813  int len = sizeof (struct expression) + EXP_ELEM_TO_BYTES (expr->nelts);
814  struct expression *temp;
815  int inpos = expr->nelts, outpos = 0;
816 
817  temp = (struct expression *) alloca (len);
818 
819  /* Copy the original expression into temp. */
820  memcpy (temp, expr, len);
821 
822  return prefixify_subexp (temp, expr, inpos, outpos);
823 }
824 
825 /* Return the number of exp_elements in the postfix subexpression
826  of EXPR whose operator is at index ENDPOS - 1 in EXPR. */
827 
828 int
829 length_of_subexp (struct expression *expr, int endpos)
830 {
831  int oplen, args;
832 
833  operator_length (expr, endpos, &oplen, &args);
834 
835  while (args > 0)
836  {
837  oplen += length_of_subexp (expr, endpos - oplen);
838  args--;
839  }
840 
841  return oplen;
842 }
843 
844 /* Sets *OPLENP to the length of the operator whose (last) index is
845  ENDPOS - 1 in EXPR, and sets *ARGSP to the number of arguments that
846  operator takes. */
847 
848 void
849 operator_length (const struct expression *expr, int endpos, int *oplenp,
850  int *argsp)
851 {
852  expr->language_defn->la_exp_desc->operator_length (expr, endpos,
853  oplenp, argsp);
854 }
855 
856 /* Default value for operator_length in exp_descriptor vectors. */
857 
858 void
859 operator_length_standard (const struct expression *expr, int endpos,
860  int *oplenp, int *argsp)
861 {
862  int oplen = 1;
863  int args = 0;
864  enum f90_range_type range_type;
865  int i;
866 
867  if (endpos < 1)
868  error (_("?error in operator_length_standard"));
869 
870  i = (int) expr->elts[endpos - 1].opcode;
871 
872  switch (i)
873  {
874  /* C++ */
875  case OP_SCOPE:
876  oplen = longest_to_int (expr->elts[endpos - 2].longconst);
877  oplen = 5 + BYTES_TO_EXP_ELEM (oplen + 1);
878  break;
879 
880  case OP_LONG:
881  case OP_DOUBLE:
882  case OP_DECFLOAT:
883  case OP_VAR_VALUE:
884  oplen = 4;
885  break;
886 
887  case OP_TYPE:
888  case OP_BOOL:
889  case OP_LAST:
890  case OP_INTERNALVAR:
891  case OP_VAR_ENTRY_VALUE:
892  oplen = 3;
893  break;
894 
895  case OP_COMPLEX:
896  oplen = 3;
897  args = 2;
898  break;
899 
900  case OP_FUNCALL:
901  case OP_F77_UNDETERMINED_ARGLIST:
902  oplen = 3;
903  args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
904  break;
905 
906  case TYPE_INSTANCE:
907  oplen = 4 + longest_to_int (expr->elts[endpos - 2].longconst);
908  args = 1;
909  break;
910 
911  case OP_OBJC_MSGCALL: /* Objective C message (method) call. */
912  oplen = 4;
913  args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
914  break;
915 
916  case UNOP_MAX:
917  case UNOP_MIN:
918  oplen = 3;
919  break;
920 
921  case UNOP_CAST_TYPE:
922  case UNOP_DYNAMIC_CAST:
923  case UNOP_REINTERPRET_CAST:
924  case UNOP_MEMVAL_TYPE:
925  oplen = 1;
926  args = 2;
927  break;
928 
929  case BINOP_VAL:
930  case UNOP_CAST:
931  case UNOP_MEMVAL:
932  oplen = 3;
933  args = 1;
934  break;
935 
936  case UNOP_MEMVAL_TLS:
937  oplen = 4;
938  args = 1;
939  break;
940 
941  case UNOP_ABS:
942  case UNOP_CAP:
943  case UNOP_CHR:
944  case UNOP_FLOAT:
945  case UNOP_HIGH:
946  case UNOP_ODD:
947  case UNOP_ORD:
948  case UNOP_TRUNC:
949  case OP_TYPEOF:
950  case OP_DECLTYPE:
951  case OP_TYPEID:
952  oplen = 1;
953  args = 1;
954  break;
955 
956  case OP_ADL_FUNC:
957  oplen = longest_to_int (expr->elts[endpos - 2].longconst);
958  oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
959  oplen++;
960  oplen++;
961  break;
962 
963  case STRUCTOP_STRUCT:
964  case STRUCTOP_PTR:
965  args = 1;
966  /* fall through */
967  case OP_REGISTER:
968  case OP_M2_STRING:
969  case OP_STRING:
970  case OP_OBJC_NSSTRING: /* Objective C Foundation Class
971  NSString constant. */
972  case OP_OBJC_SELECTOR: /* Objective C "@selector" pseudo-op. */
973  case OP_NAME:
974  oplen = longest_to_int (expr->elts[endpos - 2].longconst);
975  oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
976  break;
977 
978  case OP_ARRAY:
979  oplen = 4;
980  args = longest_to_int (expr->elts[endpos - 2].longconst);
981  args -= longest_to_int (expr->elts[endpos - 3].longconst);
982  args += 1;
983  break;
984 
985  case TERNOP_COND:
986  case TERNOP_SLICE:
987  args = 3;
988  break;
989 
990  /* Modula-2 */
991  case MULTI_SUBSCRIPT:
992  oplen = 3;
993  args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
994  break;
995 
996  case BINOP_ASSIGN_MODIFY:
997  oplen = 3;
998  args = 2;
999  break;
1000 
1001  /* C++ */
1002  case OP_THIS:
1003  oplen = 2;
1004  break;
1005 
1006  case OP_F90_RANGE:
1007  oplen = 3;
1008 
1009  range_type = longest_to_int (expr->elts[endpos - 2].longconst);
1010  switch (range_type)
1011  {
1012  case LOW_BOUND_DEFAULT:
1013  case HIGH_BOUND_DEFAULT:
1014  args = 1;
1015  break;
1016  case BOTH_BOUND_DEFAULT:
1017  args = 0;
1018  break;
1019  case NONE_BOUND_DEFAULT:
1020  args = 2;
1021  break;
1022  }
1023 
1024  break;
1025 
1026  default:
1027  args = 1 + (i < (int) BINOP_END);
1028  }
1029 
1030  *oplenp = oplen;
1031  *argsp = args;
1032 }
1033 
1034 /* Copy the subexpression ending just before index INEND in INEXPR
1035  into OUTEXPR, starting at index OUTBEG.
1036  In the process, convert it from suffix to prefix form.
1037  If EXPOUT_LAST_STRUCT is -1, then this function always returns -1.
1038  Otherwise, it returns the index of the subexpression which is the
1039  left-hand-side of the expression at EXPOUT_LAST_STRUCT. */
1040 
1041 static int
1043  struct expression *outexpr, int inend, int outbeg)
1044 {
1045  int oplen;
1046  int args;
1047  int i;
1048  int *arglens;
1049  int result = -1;
1050 
1051  operator_length (inexpr, inend, &oplen, &args);
1052 
1053  /* Copy the final operator itself, from the end of the input
1054  to the beginning of the output. */
1055  inend -= oplen;
1056  memcpy (&outexpr->elts[outbeg], &inexpr->elts[inend],
1057  EXP_ELEM_TO_BYTES (oplen));
1058  outbeg += oplen;
1059 
1060  if (expout_last_struct == inend)
1061  result = outbeg - oplen;
1062 
1063  /* Find the lengths of the arg subexpressions. */
1064  arglens = (int *) alloca (args * sizeof (int));
1065  for (i = args - 1; i >= 0; i--)
1066  {
1067  oplen = length_of_subexp (inexpr, inend);
1068  arglens[i] = oplen;
1069  inend -= oplen;
1070  }
1071 
1072  /* Now copy each subexpression, preserving the order of
1073  the subexpressions, but prefixifying each one.
1074  In this loop, inend starts at the beginning of
1075  the expression this level is working on
1076  and marches forward over the arguments.
1077  outbeg does similarly in the output. */
1078  for (i = 0; i < args; i++)
1079  {
1080  int r;
1081 
1082  oplen = arglens[i];
1083  inend += oplen;
1084  r = prefixify_subexp (inexpr, outexpr, inend, outbeg);
1085  if (r != -1)
1086  {
1087  /* Return immediately. We probably have only parsed a
1088  partial expression, so we don't want to try to reverse
1089  the other operands. */
1090  return r;
1091  }
1092  outbeg += oplen;
1093  }
1094 
1095  return result;
1096 }
1097 
1098 /* Read an expression from the string *STRINGPTR points to,
1099  parse it, and return a pointer to a struct expression that we malloc.
1100  Use block BLOCK as the lexical context for variable names;
1101  if BLOCK is zero, use the block of the selected stack frame.
1102  Meanwhile, advance *STRINGPTR to point after the expression,
1103  at the first nonwhite character that is not part of the expression
1104  (possibly a null character).
1105 
1106  If COMMA is nonzero, stop if a comma is reached. */
1107 
1108 struct expression *
1109 parse_exp_1 (const char **stringptr, CORE_ADDR pc, const struct block *block,
1110  int comma)
1111 {
1112  return parse_exp_in_context (stringptr, pc, block, comma, 0, NULL);
1113 }
1114 
1115 static struct expression *
1116 parse_exp_in_context (const char **stringptr, CORE_ADDR pc,
1117  const struct block *block,
1118  int comma, int void_context_p, int *out_subexp)
1119 {
1120  return parse_exp_in_context_1 (stringptr, pc, block, comma,
1121  void_context_p, out_subexp);
1122 }
1123 
1124 /* As for parse_exp_1, except that if VOID_CONTEXT_P, then
1125  no value is expected from the expression.
1126  OUT_SUBEXP is set when attempting to complete a field name; in this
1127  case it is set to the index of the subexpression on the
1128  left-hand-side of the struct op. If not doing such completion, it
1129  is left untouched. */
1130 
1131 static struct expression *
1132 parse_exp_in_context_1 (const char **stringptr, CORE_ADDR pc,
1133  const struct block *block,
1134  int comma, int void_context_p, int *out_subexp)
1135 {
1136  struct cleanup *old_chain, *inner_chain;
1137  const struct language_defn *lang = NULL;
1138  struct parser_state ps;
1139  int subexp;
1140 
1141  lexptr = *stringptr;
1142  prev_lexptr = NULL;
1143 
1144  paren_depth = 0;
1145  type_stack.depth = 0;
1146  expout_last_struct = -1;
1147  expout_tag_completion_type = TYPE_CODE_UNDEF;
1148  xfree (expout_completion_name);
1149  expout_completion_name = NULL;
1150 
1151  comma_terminates = comma;
1152 
1153  if (lexptr == 0 || *lexptr == 0)
1154  error_no_arg (_("expression to compute"));
1155 
1156  old_chain = make_cleanup (free_funcalls, 0 /*ignore*/);
1157  funcall_chain = 0;
1158 
1159  expression_context_block = block;
1160 
1161  /* If no context specified, try using the current frame, if any. */
1162  if (!expression_context_block)
1163  expression_context_block = get_selected_block (&expression_context_pc);
1164  else if (pc == 0)
1165  expression_context_pc = BLOCK_START (expression_context_block);
1166  else
1167  expression_context_pc = pc;
1168 
1169  /* Fall back to using the current source static context, if any. */
1170 
1171  if (!expression_context_block)
1172  {
1174  if (cursal.symtab)
1175  expression_context_block
1177  STATIC_BLOCK);
1178  if (expression_context_block)
1179  expression_context_pc = BLOCK_START (expression_context_block);
1180  }
1181 
1182  if (language_mode == language_mode_auto && block != NULL)
1183  {
1184  /* Find the language associated to the given context block.
1185  Default to the current language if it can not be determined.
1186 
1187  Note that using the language corresponding to the current frame
1188  can sometimes give unexpected results. For instance, this
1189  routine is often called several times during the inferior
1190  startup phase to re-parse breakpoint expressions after
1191  a new shared library has been loaded. The language associated
1192  to the current frame at this moment is not relevant for
1193  the breakpoint. Using it would therefore be silly, so it seems
1194  better to rely on the current language rather than relying on
1195  the current frame language to parse the expression. That's why
1196  we do the following language detection only if the context block
1197  has been specifically provided. */
1198  struct symbol *func = block_linkage_function (block);
1199 
1200  if (func != NULL)
1201  lang = language_def (SYMBOL_LANGUAGE (func));
1202  if (lang == NULL || lang->la_language == language_unknown)
1203  lang = current_language;
1204  }
1205  else
1206  lang = current_language;
1207 
1208  /* get_current_arch may reset CURRENT_LANGUAGE via select_frame.
1209  While we need CURRENT_LANGUAGE to be set to LANG (for lookup_symbol
1210  and others called from *.y) ensure CURRENT_LANGUAGE gets restored
1211  to the value matching SELECTED_FRAME as set by get_current_arch. */
1212 
1213  initialize_expout (&ps, 10, lang, get_current_arch ());
1214  inner_chain = make_cleanup_restore_current_language ();
1215  set_language (lang->la_language);
1216 
1217  TRY
1218  {
1219  if (lang->la_parser (&ps))
1220  lang->la_error (NULL);
1221  }
1222  CATCH (except, RETURN_MASK_ALL)
1223  {
1224  if (! parse_completion)
1225  {
1226  xfree (ps.expout);
1227  throw_exception (except);
1228  }
1229  }
1230  END_CATCH
1231 
1232  reallocate_expout (&ps);
1233 
1234  /* Convert expression from postfix form as generated by yacc
1235  parser, to a prefix form. */
1236 
1237  if (expressiondebug)
1239  "before conversion to prefix form");
1240 
1241  subexp = prefixify_expression (ps.expout);
1242  if (out_subexp)
1243  *out_subexp = subexp;
1244 
1245  lang->la_post_parser (&ps.expout, void_context_p);
1246 
1247  if (expressiondebug)
1249 
1250  do_cleanups (inner_chain);
1251  discard_cleanups (old_chain);
1252 
1253  *stringptr = lexptr;
1254  return ps.expout;
1255 }
1256 
1257 /* Parse STRING as an expression, and complain if this fails
1258  to use up all of the contents of STRING. */
1259 
1260 struct expression *
1261 parse_expression (const char *string)
1262 {
1263  struct expression *exp;
1264 
1265  exp = parse_exp_1 (&string, 0, 0, 0);
1266  if (*string)
1267  error (_("Junk after end of expression."));
1268  return exp;
1269 }
1270 
1271 /* Same as parse_expression, but using the given language (LANG)
1272  to parse the expression. */
1273 
1274 struct expression *
1275 parse_expression_with_language (const char *string, enum language lang)
1276 {
1277  struct cleanup *old_chain = NULL;
1278  struct expression *expr;
1279 
1280  if (current_language->la_language != lang)
1281  {
1283  set_language (lang);
1284  }
1285 
1286  expr = parse_expression (string);
1287 
1288  if (old_chain != NULL)
1289  do_cleanups (old_chain);
1290  return expr;
1291 }
1292 
1293 /* Parse STRING as an expression. If parsing ends in the middle of a
1294  field reference, return the type of the left-hand-side of the
1295  reference; furthermore, if the parsing ends in the field name,
1296  return the field name in *NAME. If the parsing ends in the middle
1297  of a field reference, but the reference is somehow invalid, throw
1298  an exception. In all other cases, return NULL. Returned non-NULL
1299  *NAME must be freed by the caller. */
1300 
1301 struct type *
1302 parse_expression_for_completion (const char *string, char **name,
1303  enum type_code *code)
1304 {
1305  struct expression *exp = NULL;
1306  struct value *val;
1307  int subexp;
1308 
1309  TRY
1310  {
1311  parse_completion = 1;
1312  exp = parse_exp_in_context (&string, 0, 0, 0, 0, &subexp);
1313  }
1314  CATCH (except, RETURN_MASK_ERROR)
1315  {
1316  /* Nothing, EXP remains NULL. */
1317  }
1318  END_CATCH
1319 
1320  parse_completion = 0;
1321  if (exp == NULL)
1322  return NULL;
1323 
1324  if (expout_tag_completion_type != TYPE_CODE_UNDEF)
1325  {
1327  *name = expout_completion_name;
1328  expout_completion_name = NULL;
1329  return NULL;
1330  }
1331 
1332  if (expout_last_struct == -1)
1333  {
1334  xfree (exp);
1335  return NULL;
1336  }
1337 
1338  *name = extract_field_op (exp, &subexp);
1339  if (!*name)
1340  {
1341  xfree (exp);
1342  return NULL;
1343  }
1344 
1345  /* This might throw an exception. If so, we want to let it
1346  propagate. */
1347  val = evaluate_subexpression_type (exp, subexp);
1348  /* (*NAME) is a part of the EXP memory block freed below. */
1349  *name = xstrdup (*name);
1350  xfree (exp);
1351 
1352  return value_type (val);
1353 }
1354 
1355 /* A post-parser that does nothing. */
1356 
1357 void
1358 null_post_parser (struct expression **exp, int void_context_p)
1359 {
1360 }
1361 
1362 /* Parse floating point value P of length LEN.
1363  Return 0 (false) if invalid, 1 (true) if valid.
1364  The successfully parsed number is stored in D.
1365  *SUFFIX points to the suffix of the number in P.
1366 
1367  NOTE: This accepts the floating point syntax that sscanf accepts. */
1368 
1369 int
1370 parse_float (const char *p, int len, DOUBLEST *d, const char **suffix)
1371 {
1372  char *copy;
1373  int n, num;
1374 
1375  copy = xmalloc (len + 1);
1376  memcpy (copy, p, len);
1377  copy[len] = 0;
1378 
1379  num = sscanf (copy, "%" DOUBLEST_SCAN_FORMAT "%n", d, &n);
1380  xfree (copy);
1381 
1382  /* The sscanf man page suggests not making any assumptions on the effect
1383  of %n on the result, so we don't.
1384  That is why we simply test num == 0. */
1385  if (num == 0)
1386  return 0;
1387 
1388  *suffix = p + n;
1389  return 1;
1390 }
1391 
1392 /* Parse floating point value P of length LEN, using the C syntax for floats.
1393  Return 0 (false) if invalid, 1 (true) if valid.
1394  The successfully parsed number is stored in *D.
1395  Its type is taken from builtin_type (gdbarch) and is stored in *T. */
1396 
1397 int
1398 parse_c_float (struct gdbarch *gdbarch, const char *p, int len,
1399  DOUBLEST *d, struct type **t)
1400 {
1401  const char *suffix;
1402  int suffix_len;
1403  const struct builtin_type *builtin_types = builtin_type (gdbarch);
1404 
1405  if (! parse_float (p, len, d, &suffix))
1406  return 0;
1407 
1408  suffix_len = p + len - suffix;
1409 
1410  if (suffix_len == 0)
1411  *t = builtin_types->builtin_double;
1412  else if (suffix_len == 1)
1413  {
1414  /* Handle suffixes: 'f' for float, 'l' for long double. */
1415  if (tolower (*suffix) == 'f')
1416  *t = builtin_types->builtin_float;
1417  else if (tolower (*suffix) == 'l')
1418  *t = builtin_types->builtin_long_double;
1419  else
1420  return 0;
1421  }
1422  else
1423  return 0;
1424 
1425  return 1;
1426 }
1427 
1428 /* Stuff for maintaining a stack of types. Currently just used by C, but
1429  probably useful for any language which declares its types "backwards". */
1430 
1431 /* Ensure that there are HOWMUCH open slots on the type stack STACK. */
1432 
1433 static void
1434 type_stack_reserve (struct type_stack *stack, int howmuch)
1435 {
1436  if (stack->depth + howmuch >= stack->size)
1437  {
1438  stack->size *= 2;
1439  if (stack->size < howmuch)
1440  stack->size = howmuch;
1441  stack->elements = xrealloc (stack->elements,
1442  stack->size * sizeof (union type_stack_elt));
1443  }
1444 }
1445 
1446 /* Ensure that there is a single open slot in the global type stack. */
1447 
1448 static void
1450 {
1452 }
1453 
1454 /* A helper function for insert_type and insert_type_address_space.
1455  This does work of expanding the type stack and inserting the new
1456  element, ELEMENT, into the stack at location SLOT. */
1457 
1458 static void
1459 insert_into_type_stack (int slot, union type_stack_elt element)
1460 {
1462 
1463  if (slot < type_stack.depth)
1464  memmove (&type_stack.elements[slot + 1], &type_stack.elements[slot],
1465  (type_stack.depth - slot) * sizeof (union type_stack_elt));
1466  type_stack.elements[slot] = element;
1467  ++type_stack.depth;
1468 }
1469 
1470 /* Insert a new type, TP, at the bottom of the type stack. If TP is
1471  tp_pointer or tp_reference, it is inserted at the bottom. If TP is
1472  a qualifier, it is inserted at slot 1 (just above a previous
1473  tp_pointer) if there is anything on the stack, or simply pushed if
1474  the stack is empty. Other values for TP are invalid. */
1475 
1476 void
1478 {
1479  union type_stack_elt element;
1480  int slot;
1481 
1482  gdb_assert (tp == tp_pointer || tp == tp_reference
1483  || tp == tp_const || tp == tp_volatile);
1484 
1485  /* If there is anything on the stack (we know it will be a
1486  tp_pointer), insert the qualifier above it. Otherwise, simply
1487  push this on the top of the stack. */
1488  if (type_stack.depth && (tp == tp_const || tp == tp_volatile))
1489  slot = 1;
1490  else
1491  slot = 0;
1492 
1493  element.piece = tp;
1494  insert_into_type_stack (slot, element);
1495 }
1496 
1497 void
1499 {
1502 }
1503 
1504 void
1506 {
1509 }
1510 
1511 /* Insert a tp_space_identifier and the corresponding address space
1512  value into the stack. STRING is the name of an address space, as
1513  recognized by address_space_name_to_int. If the stack is empty,
1514  the new elements are simply pushed. If the stack is not empty,
1515  this function assumes that the first item on the stack is a
1516  tp_pointer, and the new values are inserted above the first
1517  item. */
1518 
1519 void
1521 {
1522  union type_stack_elt element;
1523  int slot;
1524 
1525  /* If there is anything on the stack (we know it will be a
1526  tp_pointer), insert the address space qualifier above it.
1527  Otherwise, simply push this on the top of the stack. */
1528  if (type_stack.depth)
1529  slot = 1;
1530  else
1531  slot = 0;
1532 
1533  element.piece = tp_space_identifier;
1534  insert_into_type_stack (slot, element);
1535  element.int_val = address_space_name_to_int (parse_gdbarch (pstate),
1536  string);
1537  insert_into_type_stack (slot, element);
1538 }
1539 
1540 enum type_pieces
1541 pop_type (void)
1542 {
1543  if (type_stack.depth)
1545  return tp_end;
1546 }
1547 
1548 int
1550 {
1551  if (type_stack.depth)
1553  /* "Can't happen". */
1554  return 0;
1555 }
1556 
1557 /* Pop a type list element from the global type stack. */
1558 
1559 static VEC (type_ptr) *
1560 pop_typelist (void)
1561 {
1563  return type_stack.elements[--type_stack.depth].typelist_val;
1564 }
1565 
1566 /* Pop a type_stack element from the global type stack. */
1567 
1568 static struct type_stack *
1570 {
1573 }
1574 
1575 /* Append the elements of the type stack FROM to the type stack TO.
1576  Always returns TO. */
1577 
1578 struct type_stack *
1580 {
1581  type_stack_reserve (to, from->depth);
1582 
1583  memcpy (&to->elements[to->depth], &from->elements[0],
1584  from->depth * sizeof (union type_stack_elt));
1585  to->depth += from->depth;
1586 
1587  return to;
1588 }
1589 
1590 /* Push the type stack STACK as an element on the global type stack. */
1591 
1592 void
1594 {
1598 }
1599 
1600 /* Copy the global type stack into a newly allocated type stack and
1601  return it. The global stack is cleared. The returned type stack
1602  must be freed with type_stack_cleanup. */
1603 
1604 struct type_stack *
1606 {
1607  struct type_stack *result = XNEW (struct type_stack);
1608 
1609  *result = type_stack;
1610  type_stack.depth = 0;
1611  type_stack.size = 0;
1612  type_stack.elements = NULL;
1613 
1614  return result;
1615 }
1616 
1617 /* A cleanup function that destroys a single type stack. */
1618 
1619 void
1621 {
1622  struct type_stack *stack = arg;
1623 
1624  xfree (stack->elements);
1625  xfree (stack);
1626 }
1627 
1628 /* Push a function type with arguments onto the global type stack.
1629  LIST holds the argument types. If the final item in LIST is NULL,
1630  then the function will be varargs. */
1631 
1632 void
1634 {
1636  type_stack.elements[type_stack.depth++].typelist_val = list;
1638 }
1639 
1640 /* Pop the type stack and return the type which corresponds to FOLLOW_TYPE
1641  as modified by all the stuff on the stack. */
1642 struct type *
1643 follow_types (struct type *follow_type)
1644 {
1645  int done = 0;
1646  int make_const = 0;
1647  int make_volatile = 0;
1648  int make_addr_space = 0;
1649  int array_size;
1650 
1651  while (!done)
1652  switch (pop_type ())
1653  {
1654  case tp_end:
1655  done = 1;
1656  if (make_const)
1657  follow_type = make_cv_type (make_const,
1658  TYPE_VOLATILE (follow_type),
1659  follow_type, 0);
1660  if (make_volatile)
1661  follow_type = make_cv_type (TYPE_CONST (follow_type),
1662  make_volatile,
1663  follow_type, 0);
1664  if (make_addr_space)
1665  follow_type = make_type_with_address_space (follow_type,
1666  make_addr_space);
1667  make_const = make_volatile = 0;
1668  make_addr_space = 0;
1669  break;
1670  case tp_const:
1671  make_const = 1;
1672  break;
1673  case tp_volatile:
1674  make_volatile = 1;
1675  break;
1676  case tp_space_identifier:
1677  make_addr_space = pop_type_int ();
1678  break;
1679  case tp_pointer:
1680  follow_type = lookup_pointer_type (follow_type);
1681  if (make_const)
1682  follow_type = make_cv_type (make_const,
1683  TYPE_VOLATILE (follow_type),
1684  follow_type, 0);
1685  if (make_volatile)
1686  follow_type = make_cv_type (TYPE_CONST (follow_type),
1687  make_volatile,
1688  follow_type, 0);
1689  if (make_addr_space)
1690  follow_type = make_type_with_address_space (follow_type,
1691  make_addr_space);
1692  make_const = make_volatile = 0;
1693  make_addr_space = 0;
1694  break;
1695  case tp_reference:
1696  follow_type = lookup_reference_type (follow_type);
1697  if (make_const)
1698  follow_type = make_cv_type (make_const,
1699  TYPE_VOLATILE (follow_type),
1700  follow_type, 0);
1701  if (make_volatile)
1702  follow_type = make_cv_type (TYPE_CONST (follow_type),
1703  make_volatile,
1704  follow_type, 0);
1705  if (make_addr_space)
1706  follow_type = make_type_with_address_space (follow_type,
1707  make_addr_space);
1708  make_const = make_volatile = 0;
1709  make_addr_space = 0;
1710  break;
1711  case tp_array:
1712  array_size = pop_type_int ();
1713  /* FIXME-type-allocation: need a way to free this type when we are
1714  done with it. */
1715  follow_type =
1716  lookup_array_range_type (follow_type,
1717  0, array_size >= 0 ? array_size - 1 : 0);
1718  if (array_size < 0)
1719  TYPE_HIGH_BOUND_KIND (TYPE_INDEX_TYPE (follow_type))
1720  = PROP_UNDEFINED;
1721  break;
1722  case tp_function:
1723  /* FIXME-type-allocation: need a way to free this type when we are
1724  done with it. */
1725  follow_type = lookup_function_type (follow_type);
1726  break;
1727 
1729  {
1730  VEC (type_ptr) *args = pop_typelist ();
1731 
1732  follow_type
1733  = lookup_function_type_with_arguments (follow_type,
1734  VEC_length (type_ptr, args),
1736  args));
1737  VEC_free (type_ptr, args);
1738  }
1739  break;
1740 
1741  case tp_type_stack:
1742  {
1743  struct type_stack *stack = pop_type_stack ();
1744  /* Sort of ugly, but not really much worse than the
1745  alternatives. */
1746  struct type_stack save = type_stack;
1747 
1748  type_stack = *stack;
1749  follow_type = follow_types (follow_type);
1750  gdb_assert (type_stack.depth == 0);
1751 
1752  type_stack = save;
1753  }
1754  break;
1755  default:
1756  gdb_assert_not_reached ("unrecognized tp_ value in follow_types");
1757  }
1758  return follow_type;
1759 }
1760 
1761 /* This function avoids direct calls to fprintf
1762  in the parser generated debug code. */
1763 void
1764 parser_fprintf (FILE *x, const char *y, ...)
1765 {
1766  va_list args;
1767 
1768  va_start (args, y);
1769  if (x == stderr)
1770  vfprintf_unfiltered (gdb_stderr, y, args);
1771  else
1772  {
1773  fprintf_unfiltered (gdb_stderr, " Unknown FILE used.\n");
1774  vfprintf_unfiltered (gdb_stderr, y, args);
1775  }
1776  va_end (args);
1777 }
1778 
1779 /* Implementation of the exp_descriptor method operator_check. */
1780 
1781 int
1782 operator_check_standard (struct expression *exp, int pos,
1783  int (*objfile_func) (struct objfile *objfile,
1784  void *data),
1785  void *data)
1786 {
1787  const union exp_element *const elts = exp->elts;
1788  struct type *type = NULL;
1789  struct objfile *objfile = NULL;
1790 
1791  /* Extended operators should have been already handled by exp_descriptor
1792  iterate method of its specific language. */
1793  gdb_assert (elts[pos].opcode < OP_EXTENDED0);
1794 
1795  /* Track the callers of write_exp_elt_type for this table. */
1796 
1797  switch (elts[pos].opcode)
1798  {
1799  case BINOP_VAL:
1800  case OP_COMPLEX:
1801  case OP_DECFLOAT:
1802  case OP_DOUBLE:
1803  case OP_LONG:
1804  case OP_SCOPE:
1805  case OP_TYPE:
1806  case UNOP_CAST:
1807  case UNOP_MAX:
1808  case UNOP_MEMVAL:
1809  case UNOP_MIN:
1810  type = elts[pos + 1].type;
1811  break;
1812 
1813  case TYPE_INSTANCE:
1814  {
1815  LONGEST arg, nargs = elts[pos + 1].longconst;
1816 
1817  for (arg = 0; arg < nargs; arg++)
1818  {
1819  struct type *type = elts[pos + 2 + arg].type;
1820  struct objfile *objfile = TYPE_OBJFILE (type);
1821 
1822  if (objfile && (*objfile_func) (objfile, data))
1823  return 1;
1824  }
1825  }
1826  break;
1827 
1828  case UNOP_MEMVAL_TLS:
1829  objfile = elts[pos + 1].objfile;
1830  type = elts[pos + 2].type;
1831  break;
1832 
1833  case OP_VAR_VALUE:
1834  {
1835  const struct block *const block = elts[pos + 1].block;
1836  const struct symbol *const symbol = elts[pos + 2].symbol;
1837 
1838  /* Check objfile where the variable itself is placed.
1839  SYMBOL_OBJ_SECTION (symbol) may be NULL. */
1840  if ((*objfile_func) (symbol_objfile (symbol), data))
1841  return 1;
1842 
1843  /* Check objfile where is placed the code touching the variable. */
1844  objfile = lookup_objfile_from_block (block);
1845 
1846  type = SYMBOL_TYPE (symbol);
1847  }
1848  break;
1849  }
1850 
1851  /* Invoke callbacks for TYPE and OBJFILE if they were set as non-NULL. */
1852 
1853  if (type && TYPE_OBJFILE (type)
1854  && (*objfile_func) (TYPE_OBJFILE (type), data))
1855  return 1;
1856  if (objfile && (*objfile_func) (objfile, data))
1857  return 1;
1858 
1859  return 0;
1860 }
1861 
1862 /* Call OBJFILE_FUNC for any objfile found being referenced by EXP.
1863  OBJFILE_FUNC is never called with NULL OBJFILE. OBJFILE_FUNC get
1864  passed an arbitrary caller supplied DATA pointer. If OBJFILE_FUNC
1865  returns non-zero value then (any other) non-zero value is immediately
1866  returned to the caller. Otherwise zero is returned after iterating
1867  through whole EXP. */
1868 
1869 static int
1871  int (*objfile_func) (struct objfile *objfile, void *data),
1872  void *data)
1873 {
1874  int endpos;
1875 
1876  for (endpos = exp->nelts; endpos > 0; )
1877  {
1878  int pos, args, oplen = 0;
1879 
1880  operator_length (exp, endpos, &oplen, &args);
1881  gdb_assert (oplen > 0);
1882 
1883  pos = endpos - oplen;
1884  if (exp->language_defn->la_exp_desc->operator_check (exp, pos,
1885  objfile_func, data))
1886  return 1;
1887 
1888  endpos = pos;
1889  }
1890 
1891  return 0;
1892 }
1893 
1894 /* Helper for exp_uses_objfile. */
1895 
1896 static int
1897 exp_uses_objfile_iter (struct objfile *exp_objfile, void *objfile_voidp)
1898 {
1899  struct objfile *objfile = objfile_voidp;
1900 
1901  if (exp_objfile->separate_debug_objfile_backlink)
1902  exp_objfile = exp_objfile->separate_debug_objfile_backlink;
1903 
1904  return exp_objfile == objfile;
1905 }
1906 
1907 /* Return 1 if EXP uses OBJFILE (and will become dangling when OBJFILE
1908  is unloaded), otherwise return 0. OBJFILE must not be a separate debug info
1909  file. */
1910 
1911 int
1913 {
1914  gdb_assert (objfile->separate_debug_objfile_backlink == NULL);
1915 
1916  return exp_iterate (exp, exp_uses_objfile_iter, objfile);
1917 }
1918 
1919 /* See definition in parser-defs.h. */
1920 
1921 void
1922 increase_expout_size (struct parser_state *ps, size_t lenelt)
1923 {
1924  if ((ps->expout_ptr + lenelt) >= ps->expout_size)
1925  {
1926  ps->expout_size = max (ps->expout_size * 2,
1927  ps->expout_ptr + lenelt + 10);
1928  ps->expout = (struct expression *)
1929  xrealloc (ps->expout, (sizeof (struct expression)
1930  + EXP_ELEM_TO_BYTES (ps->expout_size)));
1931  }
1932 }
1933 
1934 void
1936 {
1937  type_stack.size = 0;
1938  type_stack.depth = 0;
1939  type_stack.elements = NULL;
1940 
1942  &expressiondebug,
1943  _("Set expression debugging."),
1944  _("Show expression debugging."),
1945  _("When non-zero, the internal representation "
1946  "of expressions will be printed."),
1947  NULL,
1951  &parser_debug,
1952  _("Set parser debugging."),
1953  _("Show parser debugging."),
1954  _("When non-zero, expression parser "
1955  "tracing will be enabled."),
1956  NULL,
1959 }
void error_no_arg(const char *why)
Definition: cli-cmds.c:205
#define TYPE_HIGH_BOUND_KIND(range_type)
Definition: gdbtypes.h:1254
f90_range_type
Definition: f-lang.h:45
union exp_element elts[1]
Definition: expression.h:85
type_code
Definition: gdbtypes.h:85
int address_space_name_to_int(struct gdbarch *gdbarch, char *space_identifier)
Definition: gdbtypes.c:528
void initialize_expout(struct parser_state *ps, size_t initial_size, const struct language_defn *lang, struct gdbarch *gdbarch)
Definition: parse.c:186
struct type * lookup_array_range_type(struct type *element_type, LONGEST low_bound, LONGEST high_bound)
Definition: gdbtypes.c:1128
struct internalvar * create_internalvar(const char *name)
Definition: value.c:2076
void write_exp_elt_decfloatcst(struct parser_state *ps, gdb_byte expelt[16])
Definition: parse.c:296
struct value * evaluate_subexpression_type(struct expression *exp, int subexp)
Definition: eval.c:181
int exp_uses_objfile(struct expression *exp, struct objfile *objfile)
Definition: parse.c:1912
void write_exp_elt_sym(struct parser_state *ps, struct symbol *expelt)
Definition: parse.c:246
struct type * builtin_long_double
Definition: gdbtypes.h:1492
void add_setshow_zuinteger_cmd(const char *name, enum command_class theclass, unsigned int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:763
const struct block * innermost_block
Definition: parse.c:69
enum exp_opcode opcode
Definition: expression.h:65
void push_type_stack(struct type_stack *stack)
Definition: parse.c:1593
bfd_vma CORE_ADDR
Definition: common-types.h:41
#define parse_gdbarch(ps)
Definition: parser-defs.h:36
void type_stack_cleanup(void *arg)
Definition: parse.c:1620
enum type_pieces pop_type(void)
Definition: parse.c:1541
int(* operator_check)(struct expression *exp, int pos, int(*objfile_func)(struct objfile *objfile, void *data), void *data)
Definition: parser-defs.h:347
struct expression * parse_expression_with_language(const char *string, enum language lang)
Definition: parse.c:1275
const char * ptr
Definition: parser-defs.h:79
void xfree(void *)
Definition: common-utils.c:97
struct objfile * separate_debug_objfile_backlink
Definition: objfiles.h:401
CORE_ADDR expression_context_pc
Definition: parse.c:68
static struct funcall * funcall_chain
Definition: parse.c:135
int comma_terminates
Definition: parse.c:75
#define TYPE_OBJFILE(t)
Definition: gdbtypes.h:326
static void show_parserdebug(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: parse.c:105
void(* func)(char *)
struct bfd_section * the_bfd_section
Definition: objfiles.h:121
#define BMSYMBOL_VALUE_ADDRESS(symbol)
Definition: symtab.h:393
struct type_stack * stack_val
Definition: parser-defs.h:143
static void write_exp_elt(struct parser_state *ps, const union exp_element *expelt)
Definition: parse.c:223
struct internalvar * lookup_only_internalvar(const char *name)
Definition: value.c:2037
#define TYPE_VOLATILE(t)
Definition: gdbtypes.h:350
enum language set_language(enum language lang)
Definition: language.c:346
struct symtab_and_line get_current_source_symtab_and_line(void)
Definition: source.c:181
static int exp_uses_objfile_iter(struct objfile *exp_objfile, void *objfile_voidp)
Definition: parse.c:1897
int end_arglist(void)
Definition: parse.c:156
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
Definition: gdbtypes.c:4766
int arglist_len
Definition: parse.c:70
static struct type_stack * pop_type_stack(void)
Definition: parse.c:1569
void dump_raw_expression(struct expression *exp, struct ui_file *stream, char *note)
Definition: expprint.c:685
const struct language_defn * language_defn
Definition: expression.h:81
const struct language_defn * language_def(enum language lang)
Definition: language.c:471
size_t expout_size
Definition: parser-defs.h:47
struct type * parse_expression_for_completion(const char *string, char **name, enum type_code *code)
Definition: parse.c:1302
static struct expression * parse_exp_in_context(const char **, CORE_ADDR, const struct block *, int, int, int *)
Definition: parse.c:1116
struct symbol * block_linkage_function(const struct block *bl)
Definition: block.c:100
enum language la_language
Definition: language.h:152
Definition: c-exp.c:4859
int parse_completion
Definition: parse.c:78
#define BLOCKVECTOR_BLOCK(blocklist, n)
Definition: block.h:136
void push_type(enum type_pieces tp)
Definition: parse.c:1498
static int expout_last_struct
Definition: parse.c:83
#define _(String)
Definition: gdb_locale.h:40
#define BLOCK_START(bl)
Definition: block.h:116
#define bits(obj, st, fn)
#define BYTES_TO_EXP_ELEM(bytes)
Definition: expression.h:93
#define END_CATCH
int parse_c_float(struct gdbarch *gdbarch, const char *p, int len, DOUBLEST *d, struct type **t)
Definition: parse.c:1398
struct objfile * symbol_objfile(const struct symbol *symbol)
Definition: symtab.c:6231
enum type_pieces piece
Definition: parser-defs.h:141
int longest_to_int(LONGEST)
Definition: valprint.c:1054
struct internalvar * internalvar
Definition: expression.h:74
struct symbol * symbol
Definition: expression.h:66
struct type * type
Definition: expression.h:73
struct funcall * next
Definition: parse.c:131
void push_type_int(int n)
Definition: parse.c:1505
#define MSYMBOL_OBJ_SECTION(objfile, symbol)
Definition: symtab.h:402
const char * lexptr
Definition: parse.c:72
#define TRY
const struct block * block
Definition: expression.h:75
const char *const name
Definition: aarch64-tdep.c:68
void write_exp_elt_block(struct parser_state *ps, const struct block *b)
Definition: parse.c:256
#define SYMTAB_BLOCKVECTOR(symtab)
Definition: symtab.h:968
int * from
Definition: varobj.h:282
const struct exp_descriptor * la_exp_desc
Definition: language.h:170
void write_exp_elt_longcst(struct parser_state *ps, LONGEST expelt)
Definition: parse.c:276
static unsigned int expressiondebug
Definition: parse.c:92
union type_stack_elt * elements
Definition: parser-defs.h:152
void insert_type(enum type_pieces tp)
Definition: parse.c:1477
#define CATCH(EXCEPTION, MASK)
void increase_expout_size(struct parser_state *ps, size_t lenelt)
Definition: parse.c:1922
type_pieces
Definition: parser-defs.h:125
void null_post_parser(struct expression **exp, int void_context_p)
Definition: parse.c:1358
static char * expout_completion_name
Definition: parse.c:89
struct target_ops current_target
struct type * follow_types(struct type *follow_type)
Definition: parse.c:1643
static struct parser_state * pstate
Definition: ada-exp.c:149
void dump_prefix_expression(struct expression *exp, struct ui_file *stream)
Definition: expprint.c:1044
int prefixify_expression(struct expression *expr)
Definition: parse.c:811
void fprintf_filtered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2351
int pop_type_int(void)
Definition: parse.c:1549
CORE_ADDR gdbarch_convert_from_func_ptr_addr(struct gdbarch *gdbarch, CORE_ADDR addr, struct target_ops *targ)
Definition: gdbarch.c:2975
void write_exp_elt_dblcst(struct parser_state *ps, DOUBLEST expelt)
Definition: parse.c:286
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2361
void vfprintf_unfiltered(struct ui_file *stream, const char *format, va_list args)
Definition: utils.c:2308
double DOUBLEST
Definition: doublest.h:24
#define gdb_assert_not_reached(message)
Definition: gdb_assert.h:56
#define VEC_length(T, V)
Definition: vec.h:124
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:117
struct gdbarch * get_objfile_arch(const struct objfile *objfile)
Definition: objfiles.c:368
void(* la_error)(char *)
Definition: language.h:178
DOUBLEST doubleconst
Definition: expression.h:68
int length_of_subexp(struct expression *expr, int endpos)
Definition: parse.c:829
Definition: gdbtypes.h:749
char * ptr
Definition: parser-defs.h:89
const struct block * block_found
Definition: symtab.c:250
CORE_ADDR symbol_overlayed_address(CORE_ADDR address, struct obj_section *section)
Definition: symfile.c:3257
void write_dollar_variable(struct parser_state *ps, struct stoken str)
Definition: parse.c:616
struct gdbarch * get_current_arch(void)
Definition: arch-utils.c:781
const char * find_template_name_end(const char *p)
Definition: parse.c:712
int dump_subexp_body_standard(struct expression *exp, struct ui_file *stream, int elt)
Definition: expprint.c:762
void push_typelist(VEC(type_ptr)*list)
Definition: parse.c:1633
#define gdb_assert(expr)
Definition: gdb_assert.h:33
void mark_struct_expression(struct parser_state *ps)
Definition: parse.c:566
struct type_stack * get_type_stack(void)
Definition: parse.c:1605
struct expression * parse_expression(const char *string)
Definition: parse.c:1261
int(* la_parser)(struct parser_state *)
Definition: language.h:174
language_mode
Definition: language.h:432
struct expression * expout
Definition: parser-defs.h:43
struct cmd_list_element * setdebuglist
Definition: cli-cmds.c:173
char * op_name_standard(enum exp_opcode opcode)
Definition: expprint.c:662
int user_reg_map_name_to_regnum(struct gdbarch *gdbarch, const char *name, int len)
Definition: user-regs.c:129
void * xmalloc(YYSIZE_T)
struct symtab * symtab
Definition: symtab.h:1369
static void type_stack_reserve(struct type_stack *stack, int howmuch)
Definition: parse.c:1434
struct ui_file * gdb_stdlog
Definition: main.c:73
int parser_debug
Definition: parse.c:102
#define EXP_ELEM_TO_BYTES(elements)
Definition: expression.h:91
void write_exp_msymbol(struct parser_state *ps, struct bound_minimal_symbol bound_msym)
Definition: parse.c:474
int paren_depth
Definition: parse.c:74
static struct type_stack type_stack
Definition: parse.c:71
#define DOUBLEST_SCAN_FORMAT
Definition: doublest.h:55
static int prefixify_subexp(struct expression *, struct expression *, int, int)
Definition: parse.c:1042
Definition: block.h:60
Definition: value.c:172
char * extract_field_op(struct expression *exp, int *subexp)
Definition: eval.c:291
PTR xrealloc(PTR ptr, size_t size)
Definition: common-utils.c:51
void write_exp_elt_opcode(struct parser_state *ps, enum exp_opcode expelt)
Definition: parse.c:236
gdb_byte decfloatconst[16]
Definition: expression.h:69
void throw_exception(struct gdb_exception exception)
const char const char int
Definition: command.h:229
bfd_byte gdb_byte
Definition: common-types.h:38
void write_exp_elt_objfile(struct parser_state *ps, struct objfile *objfile)
Definition: parse.c:266
void insert_type_address_space(struct parser_state *pstate, char *string)
Definition: parse.c:1520
#define MSYMBOL_TYPE(msymbol)
Definition: symtab.h:382
struct type * make_cv_type(int cnst, int voltl, struct type *type, struct type **typeptr)
Definition: gdbtypes.c:651
void discard_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:213
const struct language_defn * current_language
Definition: language.c:85
struct type * builtin_double
Definition: gdbtypes.h:1491
struct bound_minimal_symbol lookup_minimal_symbol_by_pc(CORE_ADDR pc)
Definition: minsyms.c:801
#define max(a, b)
Definition: defs.h:109
void operator_length(const struct expression *expr, int endpos, int *oplenp, int *argsp)
Definition: parse.c:849
static void insert_into_type_stack(int slot, union type_stack_elt element)
Definition: parse.c:1459
void print_subexp_standard(struct expression *exp, int *pos, struct ui_file *stream, enum precedence prec)
Definition: expprint.c:58
static void check_type_stack_depth(void)
Definition: parse.c:1449
static int exp_iterate(struct expression *exp, int(*objfile_func)(struct objfile *objfile, void *data), void *data)
Definition: parse.c:1870
void(* operator_length)(const struct expression *, int, int *, int *)
Definition: parser-defs.h:337
#define TYPE_INDEX_TYPE(type)
Definition: gdbtypes.h:1244
struct ui_file * gdb_stderr
Definition: main.c:72
struct minimal_symbol * minsym
Definition: minsyms.h:32
void parser_fprintf(FILE *x, const char *y,...)
Definition: parse.c:1764
const char * prev_lexptr
Definition: parse.c:73
static void free_funcalls(void *ignore)
Definition: parse.c:171
int operator_check_standard(struct expression *exp, int pos, int(*objfile_func)(struct objfile *objfile, void *data), void *data)
Definition: parse.c:1782
struct symbol * lookup_symbol(const char *name, const struct block *block, domain_enum domain, struct field_of_this_result *is_a_field_of_this)
Definition: symtab.c:1967
static enum type_code expout_tag_completion_type
Definition: parse.c:86
Definition: parse.c:129
struct bound_minimal_symbol lookup_bound_minimal_symbol(const char *name)
Definition: minsyms.c:335
int code
Definition: ser-unix.c:684
#define VEC_free(T, V)
Definition: vec.h:180
struct type * make_type_with_address_space(struct type *type, int space_flag)
Definition: gdbtypes.c:627
#define SYMBOL_LANGUAGE(symbol)
Definition: symtab.h:187
exp_opcode
Definition: expression.h:43
#define VEC_address(T, V)
Definition: vec.h:369
struct type_stack * append_type_stack(struct type_stack *to, struct type_stack *from)
Definition: parse.c:1579
struct objfile * objfile
Definition: expression.h:76
struct value * evaluate_subexp_standard(struct type *expect_type, struct expression *exp, int *pos, enum noside noside)
Definition: eval.c:699
LONGEST longconst
Definition: expression.h:67
void operator_length_standard(const struct expression *expr, int endpos, int *oplenp, int *argsp)
Definition: parse.c:859
struct expression * parse_exp_1(const char **stringptr, CORE_ADDR pc, const struct block *block, int comma)
Definition: parse.c:1109
static struct expression * parse_exp_in_context_1(const char **, CORE_ADDR, const struct block *, int, int, int *)
Definition: parse.c:1132
const struct block * get_selected_block(CORE_ADDR *addr_in_block)
Definition: stack.c:2230
const struct block * expression_context_block
Definition: parse.c:67
enum overlay_debugging_state overlay_debugging
Definition: symfile.c:3081
struct typed_stoken * tokens
Definition: parser-defs.h:97
int arglist_len
Definition: parse.c:132
static void show_expressiondebug(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: parse.c:94
static int ignore(struct target_ops *ops, struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
Definition: corelow.c:917
language
Definition: defs.h:167
struct gdbarch * gdbarch
Definition: expression.h:83
struct objfile * lookup_objfile_from_block(const struct block *block)
Definition: symtab.c:2228
struct type * lookup_function_type_with_arguments(struct type *type, int nparams, struct type **param_types)
Definition: gdbtypes.c:492
struct type * value_type(const struct value *value)
Definition: value.c:1021
#define SYMBOL_TYPE(symbol)
Definition: symtab.h:799
Definition: symtab.h:703
struct type * lookup_reference_type(struct type *type)
Definition: gdbtypes.c:441
struct cmd_list_element * showdebuglist
Definition: cli-cmds.c:175
void mark_completion_tag(enum type_code tag, const char *ptr, int length)
Definition: parse.c:578
void start_arglist(void)
Definition: parse.c:141
int int * to
Definition: varobj.h:282
struct objfile * objfile
Definition: minsyms.h:37
#define HOST_CHAR_BIT
Definition: host-defs.h:40
void _initialize_parse(void)
Definition: parse.c:1935
minimal_symbol_type
Definition: symtab.h:287
void reallocate_expout(struct parser_state *ps)
Definition: parse.c:201
void write_exp_elt_intern(struct parser_state *ps, struct internalvar *expelt)
Definition: parse.c:318
static VEC(type_ptr)
Definition: parse.c:1559
#define TYPE_CONST(t)
Definition: gdbtypes.h:345
void write_exp_string(struct parser_state *ps, struct stoken str)
Definition: parse.c:349
void write_exp_elt_type(struct parser_state *ps, struct type *expelt)
Definition: parse.c:308
void write_exp_bitstring(struct parser_state *ps, struct stoken str)
Definition: parse.c:444
struct cleanup * make_cleanup_restore_current_language(void)
Definition: utils.c:441
void error(const char *fmt,...)
Definition: errors.c:38
void(* la_post_parser)(struct expression **expp, int void_context_p)
Definition: language.h:186
void write_exp_string_vector(struct parser_state *ps, int type, struct stoken_vector *vec)
Definition: parse.c:391
struct type * lookup_pointer_type(struct type *type)
Definition: gdbtypes.c:368
long long LONGEST
Definition: common-types.h:52
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:175
void add_setshow_boolean_cmd(const char *name, enum command_class theclass, int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:541
size_t expout_ptr
Definition: parser-defs.h:52
struct type * lookup_function_type(struct type *type)
Definition: gdbtypes.c:482
int length
Definition: parser-defs.h:81
char * copy_name(struct stoken token)
Definition: parse.c:783
struct type * builtin_float
Definition: gdbtypes.h:1490
const ULONGEST const LONGEST len
Definition: target.h:309
int parse_float(const char *p, int len, DOUBLEST *d, const char **suffix)
Definition: parse.c:1370