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     case OP_TYPEOF:
 942     case OP_DECLTYPE:
 943       oplen = 1;
 944       args = 1;
 945       break;
 946
 947     case OP_ADL_FUNC:
 948       oplen = longest_to_int (expr->elts[endpos - 2].longconst);
 949       oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
 950       oplen++;
 951       oplen++;
 952       break;
 953
 954     case OP_LABELED:
 955     case STRUCTOP_STRUCT:
 956     case STRUCTOP_PTR:
 957       args = 1;
 958       /* fall through */
 959     case OP_REGISTER:
 960     case OP_M2_STRING:
 961     case OP_STRING:
 962     case OP_OBJC_NSSTRING:      /* Objective C Foundation Class
 963                                    NSString constant.  */
 964     case OP_OBJC_SELECTOR:      /* Objective C "@selector" pseudo-op.  */
 965     case OP_NAME:
 966       oplen = longest_to_int (expr->elts[endpos - 2].longconst);
 967       oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
 968       break;
 969
 970     case OP_BITSTRING:
 971       oplen = longest_to_int (expr->elts[endpos - 2].longconst);
 972       oplen = (oplen + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
 973       oplen = 4 + BYTES_TO_EXP_ELEM (oplen);
 974       break;
 975
 976     case OP_ARRAY:
 977       oplen = 4;
 978       args = longest_to_int (expr->elts[endpos - 2].longconst);
 979       args -= longest_to_int (expr->elts[endpos - 3].longconst);
 980       args += 1;
 981       break;
 982
 983     case TERNOP_COND:
 984     case TERNOP_SLICE:
 985     case TERNOP_SLICE_COUNT:
 986       args = 3;
 987       break;
 988
 989       /* Modula-2 */
 990     case MULTI_SUBSCRIPT:
 991       oplen = 3;
 992       args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
 993       break;
 994
 995     case BINOP_ASSIGN_MODIFY:
 996       oplen = 3;
 997       args = 2;
 998       break;
 999
1000       /* C++ */
1001     case OP_THIS:
1002       oplen = 2;
1003       break;
1004
1005     case OP_F90_RANGE:
1006       oplen = 3;
1007
1008       range_type = longest_to_int (expr->elts[endpos - 2].longconst);
1009       switch (range_type)
1010         {
1011         case LOW_BOUND_DEFAULT:
1012         case HIGH_BOUND_DEFAULT:
1013           args = 1;
1014           break;
1015         case BOTH_BOUND_DEFAULT:
1016           args = 0;
1017           break;
1018         case NONE_BOUND_DEFAULT:
1019           args = 2;
1020           break;
1021         }
1022
1023       break;
1024
1025     default:
1026       args = 1 + (i < (int) BINOP_END);
1027     }
1028
1029   *oplenp = oplen;
1030   *argsp = args;
1031 }
1032
1033 /* Copy the subexpression ending just before index INEND in INEXPR
1034    into OUTEXPR, starting at index OUTBEG.
1035    In the process, convert it from suffix to prefix form.
1036    If EXPOUT_LAST_STRUCT is -1, then this function always returns -1.
1037    Otherwise, it returns the index of the subexpression which is the
1038    left-hand-side of the expression at EXPOUT_LAST_STRUCT.  */
1039
1040 static int
1041 prefixify_subexp (struct expression *inexpr,
1042                   struct expression *outexpr, int inend, int outbeg)
1043 {
1044   int oplen;
1045   int args;
1046   int i;
1047   int *arglens;
1048   int result = -1;
1049
1050   operator_length (inexpr, inend, &oplen, &args);
1051
1052   /* Copy the final operator itself, from the end of the input
1053      to the beginning of the output.  */
1054   inend -= oplen;
1055   memcpy (&outexpr->elts[outbeg], &inexpr->elts[inend],
1056           EXP_ELEM_TO_BYTES (oplen));
1057   outbeg += oplen;
1058
1059   if (expout_last_struct == inend)
1060     result = outbeg - oplen;
1061
1062   /* Find the lengths of the arg subexpressions.  */
1063   arglens = (int *) alloca (args * sizeof (int));
1064   for (i = args - 1; i >= 0; i--)
1065     {
1066       oplen = length_of_subexp (inexpr, inend);
1067       arglens[i] = oplen;
1068       inend -= oplen;
1069     }
1070
1071   /* Now copy each subexpression, preserving the order of
1072      the subexpressions, but prefixifying each one.
1073      In this loop, inend starts at the beginning of
1074      the expression this level is working on
1075      and marches forward over the arguments.
1076      outbeg does similarly in the output.  */
1077   for (i = 0; i < args; i++)
1078     {
1079       int r;
1080
1081       oplen = arglens[i];
1082       inend += oplen;
1083       r = prefixify_subexp (inexpr, outexpr, inend, outbeg);
1084       if (r != -1)
1085         {
1086           /* Return immediately.  We probably have only parsed a
1087              partial expression, so we don't want to try to reverse
1088              the other operands.  */
1089           return r;
1090         }
1091       outbeg += oplen;
1092     }
1093
1094   return result;
1095 }
1096 \f
1097 /* Read an expression from the string *STRINGPTR points to,
1098    parse it, and return a pointer to a struct expression that we malloc.
1099    Use block BLOCK as the lexical context for variable names;
1100    if BLOCK is zero, use the block of the selected stack frame.
1101    Meanwhile, advance *STRINGPTR to point after the expression,
1102    at the first nonwhite character that is not part of the expression
1103    (possibly a null character).
1104
1105    If COMMA is nonzero, stop if a comma is reached.  */
1106
1107 struct expression *
1108 parse_exp_1 (char **stringptr, CORE_ADDR pc, struct block *block, int comma)
1109 {
1110   return parse_exp_in_context (stringptr, pc, block, comma, 0, NULL);
1111 }
1112
1113 /* As for parse_exp_1, except that if VOID_CONTEXT_P, then
1114    no value is expected from the expression.
1115    OUT_SUBEXP is set when attempting to complete a field name; in this
1116    case it is set to the index of the subexpression on the
1117    left-hand-side of the struct op.  If not doing such completion, it
1118    is left untouched.  */
1119
1120 static struct expression *
1121 parse_exp_in_context (char **stringptr, CORE_ADDR pc, struct block *block,
1122                       int comma, int void_context_p, int *out_subexp)
1123 {
1124   volatile struct gdb_exception except;
1125   struct cleanup *old_chain;
1126   const struct language_defn *lang = NULL;
1127   int subexp;
1128
1129   lexptr = *stringptr;
1130   prev_lexptr = NULL;
1131
1132   paren_depth = 0;
1133   type_stack.depth = 0;
1134   expout_last_struct = -1;
1135
1136   comma_terminates = comma;
1137
1138   if (lexptr == 0 || *lexptr == 0)
1139     error_no_arg (_("expression to compute"));
1140
1141   old_chain = make_cleanup (free_funcalls, 0 /*ignore*/);
1142   funcall_chain = 0;
1143
1144   expression_context_block = block;
1145
1146   /* If no context specified, try using the current frame, if any.  */
1147   if (!expression_context_block)
1148     expression_context_block = get_selected_block (&expression_context_pc);
1149   else if (pc == 0)
1150     expression_context_pc = BLOCK_START (expression_context_block);
1151   else
1152     expression_context_pc = pc;
1153
1154   /* Fall back to using the current source static context, if any.  */
1155
1156   if (!expression_context_block)
1157     {
1158       struct symtab_and_line cursal = get_current_source_symtab_and_line ();
1159       if (cursal.symtab)
1160         expression_context_block
1161           = BLOCKVECTOR_BLOCK (BLOCKVECTOR (cursal.symtab), STATIC_BLOCK);
1162       if (expression_context_block)
1163         expression_context_pc = BLOCK_START (expression_context_block);
1164     }
1165
1166   if (language_mode == language_mode_auto && block != NULL)
1167     {
1168       /* Find the language associated to the given context block.
1169          Default to the current language if it can not be determined.
1170
1171          Note that using the language corresponding to the current frame
1172          can sometimes give unexpected results.  For instance, this
1173          routine is often called several times during the inferior
1174          startup phase to re-parse breakpoint expressions after
1175          a new shared library has been loaded.  The language associated
1176          to the current frame at this moment is not relevant for
1177          the breakpoint.  Using it would therefore be silly, so it seems
1178          better to rely on the current language rather than relying on
1179          the current frame language to parse the expression.  That's why
1180          we do the following language detection only if the context block
1181          has been specifically provided.  */
1182       struct symbol *func = block_linkage_function (block);
1183
1184       if (func != NULL)
1185         lang = language_def (SYMBOL_LANGUAGE (func));
1186       if (lang == NULL || lang->la_language == language_unknown)
1187         lang = current_language;
1188     }
1189   else
1190     lang = current_language;
1191
1192   initialize_expout (10, lang, get_current_arch ());
1193
1194   TRY_CATCH (except, RETURN_MASK_ALL)
1195     {
1196       if (lang->la_parser ())
1197         lang->la_error (NULL);
1198     }
1199   if (except.reason < 0)
1200     {
1201       if (! in_parse_field)
1202         {
1203           xfree (expout);
1204           throw_exception (except);
1205         }
1206     }
1207
1208   discard_cleanups (old_chain);
1209
1210   reallocate_expout ();
1211
1212   /* Convert expression from postfix form as generated by yacc
1213      parser, to a prefix form.  */
1214
1215   if (expressiondebug)
1216     dump_raw_expression (expout, gdb_stdlog,
1217                          "before conversion to prefix form");
1218
1219   subexp = prefixify_expression (expout);
1220   if (out_subexp)
1221     *out_subexp = subexp;
1222
1223   lang->la_post_parser (&expout, void_context_p);
1224
1225   if (expressiondebug)
1226     dump_prefix_expression (expout, gdb_stdlog);
1227
1228   *stringptr = lexptr;
1229   return expout;
1230 }
1231
1232 /* Parse STRING as an expression, and complain if this fails
1233    to use up all of the contents of STRING.  */
1234
1235 struct expression *
1236 parse_expression (char *string)
1237 {
1238   struct expression *exp;
1239
1240   exp = parse_exp_1 (&string, 0, 0, 0);
1241   if (*string)
1242     error (_("Junk after end of expression."));
1243   return exp;
1244 }
1245
1246 /* Parse STRING as an expression.  If parsing ends in the middle of a
1247    field reference, return the type of the left-hand-side of the
1248    reference; furthermore, if the parsing ends in the field name,
1249    return the field name in *NAME.  If the parsing ends in the middle
1250    of a field reference, but the reference is somehow invalid, throw
1251    an exception.  In all other cases, return NULL.  Returned non-NULL
1252    *NAME must be freed by the caller.  */
1253
1254 struct type *
1255 parse_field_expression (char *string, char **name)
1256 {
1257   struct expression *exp = NULL;
1258   struct value *val;
1259   int subexp;
1260   volatile struct gdb_exception except;
1261
1262   TRY_CATCH (except, RETURN_MASK_ERROR)
1263     {
1264       in_parse_field = 1;
1265       exp = parse_exp_in_context (&string, 0, 0, 0, 0, &subexp);
1266     }
1267   in_parse_field = 0;
1268   if (except.reason < 0 || ! exp)
1269     return NULL;
1270   if (expout_last_struct == -1)
1271     {
1272       xfree (exp);
1273       return NULL;
1274     }
1275
1276   *name = extract_field_op (exp, &subexp);
1277   if (!*name)
1278     {
1279       xfree (exp);
1280       return NULL;
1281     }
1282
1283   /* This might throw an exception.  If so, we want to let it
1284      propagate.  */
1285   val = evaluate_subexpression_type (exp, subexp);
1286   /* (*NAME) is a part of the EXP memory block freed below.  */
1287   *name = xstrdup (*name);
1288   xfree (exp);
1289
1290   return value_type (val);
1291 }
1292
1293 /* A post-parser that does nothing.  */
1294
1295 void
1296 null_post_parser (struct expression **exp, int void_context_p)
1297 {
1298 }
1299
1300 /* Parse floating point value P of length LEN.
1301    Return 0 (false) if invalid, 1 (true) if valid.
1302    The successfully parsed number is stored in D.
1303    *SUFFIX points to the suffix of the number in P.
1304
1305    NOTE: This accepts the floating point syntax that sscanf accepts.  */
1306
1307 int
1308 parse_float (const char *p, int len, DOUBLEST *d, const char **suffix)
1309 {
1310   char *copy;
1311   int n, num;
1312
1313   copy = xmalloc (len + 1);
1314   memcpy (copy, p, len);
1315   copy[len] = 0;
1316
1317   num = sscanf (copy, "%" DOUBLEST_SCAN_FORMAT "%n", d, &n);
1318   xfree (copy);
1319
1320   /* The sscanf man page suggests not making any assumptions on the effect
1321      of %n on the result, so we don't.
1322      That is why we simply test num == 0.  */
1323   if (num == 0)
1324     return 0;
1325
1326   *suffix = p + n;
1327   return 1;
1328 }
1329
1330 /* Parse floating point value P of length LEN, using the C syntax for floats.
1331    Return 0 (false) if invalid, 1 (true) if valid.
1332    The successfully parsed number is stored in *D.
1333    Its type is taken from builtin_type (gdbarch) and is stored in *T.  */
1334
1335 int
1336 parse_c_float (struct gdbarch *gdbarch, const char *p, int len,
1337                DOUBLEST *d, struct type **t)
1338 {
1339   const char *suffix;
1340   int suffix_len;
1341   const struct builtin_type *builtin_types = builtin_type (gdbarch);
1342
1343   if (! parse_float (p, len, d, &suffix))
1344     return 0;
1345
1346   suffix_len = p + len - suffix;
1347
1348   if (suffix_len == 0)
1349     *t = builtin_types->builtin_double;
1350   else if (suffix_len == 1)
1351     {
1352       /* Handle suffixes: 'f' for float, 'l' for long double.  */
1353       if (tolower (*suffix) == 'f')
1354         *t = builtin_types->builtin_float;
1355       else if (tolower (*suffix) == 'l')
1356         *t = builtin_types->builtin_long_double;
1357       else
1358         return 0;
1359     }
1360   else
1361     return 0;
1362
1363   return 1;
1364 }
1365 \f
1366 /* Stuff for maintaining a stack of types.  Currently just used by C, but
1367    probably useful for any language which declares its types "backwards".  */
1368
1369 /* Ensure that there are HOWMUCH open slots on the type stack STACK.  */
1370
1371 static void
1372 type_stack_reserve (struct type_stack *stack, int howmuch)
1373 {
1374   if (stack->depth + howmuch >= stack->size)
1375     {
1376       stack->size *= 2;
1377       if (stack->size < howmuch)
1378         stack->size = howmuch;
1379       stack->elements = xrealloc (stack->elements,
1380                                   stack->size * sizeof (union type_stack_elt));
1381     }
1382 }
1383
1384 /* Ensure that there is a single open slot in the global type stack.  */
1385
1386 static void
1387 check_type_stack_depth (void)
1388 {
1389   type_stack_reserve (&type_stack, 1);
1390 }
1391
1392 /* A helper function for insert_type and insert_type_address_space.
1393    This does work of expanding the type stack and inserting the new
1394    element, ELEMENT, into the stack at location SLOT.  */
1395
1396 static void
1397 insert_into_type_stack (int slot, union type_stack_elt element)
1398 {
1399   check_type_stack_depth ();
1400
1401   if (slot < type_stack.depth)
1402     memmove (&type_stack.elements[slot + 1], &type_stack.elements[slot],
1403              (type_stack.depth - slot) * sizeof (union type_stack_elt));
1404   type_stack.elements[slot] = element;
1405   ++type_stack.depth;
1406 }
1407
1408 /* Insert a new type, TP, at the bottom of the type stack.  If TP is
1409    tp_pointer or tp_reference, it is inserted at the bottom.  If TP is
1410    a qualifier, it is inserted at slot 1 (just above a previous
1411    tp_pointer) if there is anything on the stack, or simply pushed if
1412    the stack is empty.  Other values for TP are invalid.  */
1413
1414 void
1415 insert_type (enum type_pieces tp)
1416 {
1417   union type_stack_elt element;
1418   int slot;
1419
1420   gdb_assert (tp == tp_pointer || tp == tp_reference
1421               || tp == tp_const || tp == tp_volatile);
1422
1423   /* If there is anything on the stack (we know it will be a
1424      tp_pointer), insert the qualifier above it.  Otherwise, simply
1425      push this on the top of the stack.  */
1426   if (type_stack.depth && (tp == tp_const || tp == tp_volatile))
1427     slot = 1;
1428   else
1429     slot = 0;
1430
1431   element.piece = tp;
1432   insert_into_type_stack (slot, element);
1433 }
1434
1435 void
1436 push_type (enum type_pieces tp)
1437 {
1438   check_type_stack_depth ();
1439   type_stack.elements[type_stack.depth++].piece = tp;
1440 }
1441
1442 void
1443 push_type_int (int n)
1444 {
1445   check_type_stack_depth ();
1446   type_stack.elements[type_stack.depth++].int_val = n;
1447 }
1448
1449 /* Insert a tp_space_identifier and the corresponding address space
1450    value into the stack.  STRING is the name of an address space, as
1451    recognized by address_space_name_to_int.  If the stack is empty,
1452    the new elements are simply pushed.  If the stack is not empty,
1453    this function assumes that the first item on the stack is a
1454    tp_pointer, and the new values are inserted above the first
1455    item.  */
1456
1457 void
1458 insert_type_address_space (char *string)
1459 {
1460   union type_stack_elt element;
1461   int slot;
1462
1463   /* If there is anything on the stack (we know it will be a
1464      tp_pointer), insert the address space qualifier above it.
1465      Otherwise, simply push this on the top of the stack.  */
1466   if (type_stack.depth)
1467     slot = 1;
1468   else
1469     slot = 0;
1470
1471   element.piece = tp_space_identifier;
1472   insert_into_type_stack (slot, element);
1473   element.int_val = address_space_name_to_int (parse_gdbarch, string);
1474   insert_into_type_stack (slot, element);
1475 }
1476
1477 enum type_pieces
1478 pop_type (void)
1479 {
1480   if (type_stack.depth)
1481     return type_stack.elements[--type_stack.depth].piece;
1482   return tp_end;
1483 }
1484
1485 int
1486 pop_type_int (void)
1487 {
1488   if (type_stack.depth)
1489     return type_stack.elements[--type_stack.depth].int_val;
1490   /* "Can't happen".  */
1491   return 0;
1492 }
1493
1494 /* Pop a type list element from the global type stack.  */
1495
1496 static VEC (type_ptr) *
1497 pop_typelist (void)
1498 {
1499   gdb_assert (type_stack.depth);
1500   return type_stack.elements[--type_stack.depth].typelist_val;
1501 }
1502
1503 /* Pop a type_stack element from the global type stack.  */
1504
1505 static struct type_stack *
1506 pop_type_stack (void)
1507 {
1508   gdb_assert (type_stack.depth);
1509   return type_stack.elements[--type_stack.depth].stack_val;
1510 }
1511
1512 /* Append the elements of the type stack FROM to the type stack TO.
1513    Always returns TO.  */
1514
1515 struct type_stack *
1516 append_type_stack (struct type_stack *to, struct type_stack *from)
1517 {
1518   type_stack_reserve (to, from->depth);
1519
1520   memcpy (&to->elements[to->depth], &from->elements[0],
1521           from->depth * sizeof (union type_stack_elt));
1522   to->depth += from->depth;
1523
1524   return to;
1525 }
1526
1527 /* Push the type stack STACK as an element on the global type stack.  */
1528
1529 void
1530 push_type_stack (struct type_stack *stack)
1531 {
1532   check_type_stack_depth ();
1533   type_stack.elements[type_stack.depth++].stack_val = stack;
1534   push_type (tp_type_stack);
1535 }
1536
1537 /* Copy the global type stack into a newly allocated type stack and
1538    return it.  The global stack is cleared.  The returned type stack
1539    must be freed with type_stack_cleanup.  */
1540
1541 struct type_stack *
1542 get_type_stack (void)
1543 {
1544   struct type_stack *result = XNEW (struct type_stack);
1545
1546   *result = type_stack;
1547   type_stack.depth = 0;
1548   type_stack.size = 0;
1549   type_stack.elements = NULL;
1550
1551   return result;
1552 }
1553
1554 /* A cleanup function that destroys a single type stack.  */
1555
1556 void
1557 type_stack_cleanup (void *arg)
1558 {
1559   struct type_stack *stack = arg;
1560
1561   xfree (stack->elements);
1562   xfree (stack);
1563 }
1564
1565 /* Push a function type with arguments onto the global type stack.
1566    LIST holds the argument types.  If the final item in LIST is NULL,
1567    then the function will be varargs.  */
1568
1569 void
1570 push_typelist (VEC (type_ptr) *list)
1571 {
1572   check_type_stack_depth ();
1573   type_stack.elements[type_stack.depth++].typelist_val = list;
1574   push_type (tp_function_with_arguments);
1575 }
1576
1577 /* Pop the type stack and return the type which corresponds to FOLLOW_TYPE
1578    as modified by all the stuff on the stack.  */
1579 struct type *
1580 follow_types (struct type *follow_type)
1581 {
1582   int done = 0;
1583   int make_const = 0;
1584   int make_volatile = 0;
1585   int make_addr_space = 0;
1586   int array_size;
1587
1588   while (!done)
1589     switch (pop_type ())
1590       {
1591       case tp_end:
1592         done = 1;
1593         if (make_const)
1594           follow_type = make_cv_type (make_const,
1595                                       TYPE_VOLATILE (follow_type),
1596                                       follow_type, 0);
1597         if (make_volatile)
1598           follow_type = make_cv_type (TYPE_CONST (follow_type),
1599                                       make_volatile,
1600                                       follow_type, 0);
1601         if (make_addr_space)
1602           follow_type = make_type_with_address_space (follow_type,
1603                                                       make_addr_space);
1604         make_const = make_volatile = 0;
1605         make_addr_space = 0;
1606         break;
1607       case tp_const:
1608         make_const = 1;
1609         break;
1610       case tp_volatile:
1611         make_volatile = 1;
1612         break;
1613       case tp_space_identifier:
1614         make_addr_space = pop_type_int ();
1615         break;
1616       case tp_pointer:
1617         follow_type = lookup_pointer_type (follow_type);
1618         if (make_const)
1619           follow_type = make_cv_type (make_const,
1620                                       TYPE_VOLATILE (follow_type),
1621                                       follow_type, 0);
1622         if (make_volatile)
1623           follow_type = make_cv_type (TYPE_CONST (follow_type),
1624                                       make_volatile,
1625                                       follow_type, 0);
1626         if (make_addr_space)
1627           follow_type = make_type_with_address_space (follow_type,
1628                                                       make_addr_space);
1629         make_const = make_volatile = 0;
1630         make_addr_space = 0;
1631         break;
1632       case tp_reference:
1633         follow_type = lookup_reference_type (follow_type);
1634         if (make_const)
1635           follow_type = make_cv_type (make_const,
1636                                       TYPE_VOLATILE (follow_type),
1637                                       follow_type, 0);
1638         if (make_volatile)
1639           follow_type = make_cv_type (TYPE_CONST (follow_type),
1640                                       make_volatile,
1641                                       follow_type, 0);
1642         if (make_addr_space)
1643           follow_type = make_type_with_address_space (follow_type,
1644                                                       make_addr_space);
1645         make_const = make_volatile = 0;
1646         make_addr_space = 0;
1647         break;
1648       case tp_array:
1649         array_size = pop_type_int ();
1650         /* FIXME-type-allocation: need a way to free this type when we are
1651            done with it.  */
1652         follow_type =
1653           lookup_array_range_type (follow_type,
1654                                    0, array_size >= 0 ? array_size - 1 : 0);
1655         if (array_size < 0)
1656           TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (follow_type) = 1;
1657         break;
1658       case tp_function:
1659         /* FIXME-type-allocation: need a way to free this type when we are
1660            done with it.  */
1661         follow_type = lookup_function_type (follow_type);
1662         break;
1663
1664       case tp_function_with_arguments:
1665         {
1666           VEC (type_ptr) *args = pop_typelist ();
1667
1668           follow_type
1669             = lookup_function_type_with_arguments (follow_type,
1670                                                    VEC_length (type_ptr, args),
1671                                                    VEC_address (type_ptr,
1672                                                                 args));
1673           VEC_free (type_ptr, args);
1674         }
1675         break;
1676
1677       case tp_type_stack:
1678         {
1679           struct type_stack *stack = pop_type_stack ();
1680           /* Sort of ugly, but not really much worse than the
1681              alternatives.  */
1682           struct type_stack save = type_stack;
1683
1684           type_stack = *stack;
1685           follow_type = follow_types (follow_type);
1686           gdb_assert (type_stack.depth == 0);
1687
1688           type_stack = save;
1689         }
1690         break;
1691       default:
1692         gdb_assert_not_reached ("unrecognized tp_ value in follow_types");
1693       }
1694   return follow_type;
1695 }
1696 \f
1697 /* This function avoids direct calls to fprintf
1698    in the parser generated debug code.  */
1699 void
1700 parser_fprintf (FILE *x, const char *y, ...)
1701 {
1702   va_list args;
1703
1704   va_start (args, y);
1705   if (x == stderr)
1706     vfprintf_unfiltered (gdb_stderr, y, args);
1707   else
1708     {
1709       fprintf_unfiltered (gdb_stderr, " Unknown FILE used.\n");
1710       vfprintf_unfiltered (gdb_stderr, y, args);
1711     }
1712   va_end (args);
1713 }
1714
1715 /* Implementation of the exp_descriptor method operator_check.  */
1716
1717 int
1718 operator_check_standard (struct expression *exp, int pos,
1719                          int (*objfile_func) (struct objfile *objfile,
1720                                               void *data),
1721                          void *data)
1722 {
1723   const union exp_element *const elts = exp->elts;
1724   struct type *type = NULL;
1725   struct objfile *objfile = NULL;
1726
1727   /* Extended operators should have been already handled by exp_descriptor
1728      iterate method of its specific language.  */
1729   gdb_assert (elts[pos].opcode < OP_EXTENDED0);
1730
1731   /* Track the callers of write_exp_elt_type for this table.  */
1732
1733   switch (elts[pos].opcode)
1734     {
1735     case BINOP_VAL:
1736     case OP_COMPLEX:
1737     case OP_DECFLOAT:
1738     case OP_DOUBLE:
1739     case OP_LONG:
1740     case OP_SCOPE:
1741     case OP_TYPE:
1742     case UNOP_CAST:
1743     case UNOP_MAX:
1744     case UNOP_MEMVAL:
1745     case UNOP_MIN:
1746       type = elts[pos + 1].type;
1747       break;
1748
1749     case TYPE_INSTANCE:
1750       {
1751         LONGEST arg, nargs = elts[pos + 1].longconst;
1752
1753         for (arg = 0; arg < nargs; arg++)
1754           {
1755             struct type *type = elts[pos + 2 + arg].type;
1756             struct objfile *objfile = TYPE_OBJFILE (type);
1757
1758             if (objfile && (*objfile_func) (objfile, data))
1759               return 1;
1760           }
1761       }
1762       break;
1763
1764     case UNOP_MEMVAL_TLS:
1765       objfile = elts[pos + 1].objfile;
1766       type = elts[pos + 2].type;
1767       break;
1768
1769     case OP_VAR_VALUE:
1770       {
1771         const struct block *const block = elts[pos + 1].block;
1772         const struct symbol *const symbol = elts[pos + 2].symbol;
1773
1774         /* Check objfile where the variable itself is placed.
1775            SYMBOL_OBJ_SECTION (symbol) may be NULL.  */
1776         if ((*objfile_func) (SYMBOL_SYMTAB (symbol)->objfile, data))
1777           return 1;
1778
1779         /* Check objfile where is placed the code touching the variable.  */
1780         objfile = lookup_objfile_from_block (block);
1781
1782         type = SYMBOL_TYPE (symbol);
1783       }
1784       break;
1785     }
1786
1787   /* Invoke callbacks for TYPE and OBJFILE if they were set as non-NULL.  */
1788
1789   if (type && TYPE_OBJFILE (type)
1790       && (*objfile_func) (TYPE_OBJFILE (type), data))
1791     return 1;
1792   if (objfile && (*objfile_func) (objfile, data))
1793     return 1;
1794
1795   return 0;
1796 }
1797
1798 /* Call OBJFILE_FUNC for any TYPE and OBJFILE found being referenced by EXP.
1799    The functions are never called with NULL OBJFILE.  Functions get passed an
1800    arbitrary caller supplied DATA pointer.  If any of the functions returns
1801    non-zero value then (any other) non-zero value is immediately returned to
1802    the caller.  Otherwise zero is returned after iterating through whole EXP.
1803    */
1804
1805 static int
1806 exp_iterate (struct expression *exp,
1807              int (*objfile_func) (struct objfile *objfile, void *data),
1808              void *data)
1809 {
1810   int endpos;
1811
1812   for (endpos = exp->nelts; endpos > 0; )
1813     {
1814       int pos, args, oplen = 0;
1815
1816       operator_length (exp, endpos, &oplen, &args);
1817       gdb_assert (oplen > 0);
1818
1819       pos = endpos - oplen;
1820       if (exp->language_defn->la_exp_desc->operator_check (exp, pos,
1821                                                            objfile_func, data))
1822         return 1;
1823
1824       endpos = pos;
1825     }
1826
1827   return 0;
1828 }
1829
1830 /* Helper for exp_uses_objfile.  */
1831
1832 static int
1833 exp_uses_objfile_iter (struct objfile *exp_objfile, void *objfile_voidp)
1834 {
1835   struct objfile *objfile = objfile_voidp;
1836
1837   if (exp_objfile->separate_debug_objfile_backlink)
1838     exp_objfile = exp_objfile->separate_debug_objfile_backlink;
1839
1840   return exp_objfile == objfile;
1841 }
1842
1843 /* Return 1 if EXP uses OBJFILE (and will become dangling when OBJFILE
1844    is unloaded), otherwise return 0.  OBJFILE must not be a separate debug info
1845    file.  */
1846
1847 int
1848 exp_uses_objfile (struct expression *exp, struct objfile *objfile)
1849 {
1850   gdb_assert (objfile->separate_debug_objfile_backlink == NULL);
1851
1852   return exp_iterate (exp, exp_uses_objfile_iter, objfile);
1853 }
1854
1855 void
1856 _initialize_parse (void)
1857 {
1858   type_stack.size = 0;
1859   type_stack.depth = 0;
1860   type_stack.elements = NULL;
1861
1862   add_setshow_zinteger_cmd ("expression", class_maintenance,
1863                             &expressiondebug,
1864                             _("Set expression debugging."),
1865                             _("Show expression debugging."),
1866                             _("When non-zero, the internal representation "
1867                               "of expressions will be printed."),
1868                             NULL,
1869                             show_expressiondebug,
1870                             &setdebuglist, &showdebuglist);
1871   add_setshow_boolean_cmd ("parser", class_maintenance,
1872                             &parser_debug,
1873                            _("Set parser debugging."),
1874                            _("Show parser debugging."),
1875                            _("When non-zero, expression parser "
1876                              "tracing will be enabled."),
1877                             NULL,
1878                             show_parserdebug,
1879                             &setdebuglist, &showdebuglist);
1880 }