gdb/parse.c

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