gdb/parse.c

   1 /* Parse expressions for GDB.
   2
   3    Copyright (C) 1986, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
   4    1998, 1999, 2000, 2001, 2004, 2005, 2007 Free Software 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 2 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, write to the Free Software
  23    Foundation, Inc., 51 Franklin Street, Fifth Floor,
  24    Boston, MA 02110-1301, USA.  */
  25
  26 /* Parse an expression from text in a string,
  27    and return the result as a  struct expression  pointer.
  28    That structure contains arithmetic operations in reverse polish,
  29    with constants represented by operations that are followed by special data.
  30    See expression.h for the details of the format.
  31    What is important here is that it can be built up sequentially
  32    during the process of parsing; the lower levels of the tree always
  33    come first in the result.  */
  34
  35 #include <ctype.h>
  36
  37 #include "defs.h"
  38 #include "gdb_string.h"
  39 #include "symtab.h"
  40 #include "gdbtypes.h"
  41 #include "frame.h"
  42 #include "expression.h"
  43 #include "value.h"
  44 #include "command.h"
  45 #include "language.h"
  46 #include "f-lang.h"
  47 #include "parser-defs.h"
  48 #include "gdbcmd.h"
  49 #include "symfile.h"            /* for overlay functions */
  50 #include "inferior.h"
  51 #include "doublest.h"
  52 #include "gdb_assert.h"
  53 #include "block.h"
  54 #include "source.h"
  55 #include "objfiles.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     op_name_standard,
  65     dump_subexp_body_standard,
  66     evaluate_subexp_standard
  67   };
  68 \f
  69 /* Global variables declared in parser-defs.h (and commented there).  */
  70 struct expression *expout;
  71 int expout_size;
  72 int expout_ptr;
  73 struct block *expression_context_block;
  74 CORE_ADDR expression_context_pc;
  75 struct block *innermost_block;
  76 int arglist_len;
  77 union type_stack_elt *type_stack;
  78 int type_stack_depth, type_stack_size;
  79 char *lexptr;
  80 char *prev_lexptr;
  81 int paren_depth;
  82 int comma_terminates;
  83
  84 /* A temporary buffer for identifiers, so we can null-terminate them.
  85
  86    We allocate this with xrealloc.  parse_exp_1 used to allocate with
  87    alloca, using the size of the whole expression as a conservative
  88    estimate of the space needed.  However, macro expansion can
  89    introduce names longer than the original expression; there's no
  90    practical way to know beforehand how large that might be.  */
  91 char *namecopy;
  92 size_t namecopy_size;
  93 \f
  94 static int expressiondebug = 0;
  95 static void
  96 show_expressiondebug (struct ui_file *file, int from_tty,
  97                       struct cmd_list_element *c, const char *value)
  98 {
  99   fprintf_filtered (file, _("Expression debugging is %s.\n"), value);
 100 }
 101
 102 static void free_funcalls (void *ignore);
 103
 104 static void prefixify_expression (struct expression *);
 105
 106 static void prefixify_subexp (struct expression *, struct expression *, int,
 107                               int);
 108
 109 static struct expression *parse_exp_in_context (char **, struct block *, int,
 110                                                 int);
 111
 112 void _initialize_parse (void);
 113
 114 /* Data structure for saving values of arglist_len for function calls whose
 115    arguments contain other function calls.  */
 116
 117 struct funcall
 118   {
 119     struct funcall *next;
 120     int arglist_len;
 121   };
 122
 123 static struct funcall *funcall_chain;
 124
 125 /* Begin counting arguments for a function call,
 126    saving the data about any containing call.  */
 127
 128 void
 129 start_arglist (void)
 130 {
 131   struct funcall *new;
 132
 133   new = (struct funcall *) xmalloc (sizeof (struct funcall));
 134   new->next = funcall_chain;
 135   new->arglist_len = arglist_len;
 136   arglist_len = 0;
 137   funcall_chain = new;
 138 }
 139
 140 /* Return the number of arguments in a function call just terminated,
 141    and restore the data for the containing function call.  */
 142
 143 int
 144 end_arglist (void)
 145 {
 146   int val = arglist_len;
 147   struct funcall *call = funcall_chain;
 148   funcall_chain = call->next;
 149   arglist_len = call->arglist_len;
 150   xfree (call);
 151   return val;
 152 }
 153
 154 /* Free everything in the funcall chain.
 155    Used when there is an error inside parsing.  */
 156
 157 static void
 158 free_funcalls (void *ignore)
 159 {
 160   struct funcall *call, *next;
 161
 162   for (call = funcall_chain; call; call = next)
 163     {
 164       next = call->next;
 165       xfree (call);
 166     }
 167 }
 168 \f
 169 /* This page contains the functions for adding data to the  struct expression
 170    being constructed.  */
 171
 172 /* Add one element to the end of the expression.  */
 173
 174 /* To avoid a bug in the Sun 4 compiler, we pass things that can fit into
 175    a register through here */
 176
 177 void
 178 write_exp_elt (union exp_element expelt)
 179 {
 180   if (expout_ptr >= expout_size)
 181     {
 182       expout_size *= 2;
 183       expout = (struct expression *)
 184         xrealloc ((char *) expout, sizeof (struct expression)
 185                   + EXP_ELEM_TO_BYTES (expout_size));
 186     }
 187   expout->elts[expout_ptr++] = expelt;
 188 }
 189
 190 void
 191 write_exp_elt_opcode (enum exp_opcode expelt)
 192 {
 193   union exp_element tmp;
 194   memset (&tmp, 0, sizeof (union exp_element));
 195
 196   tmp.opcode = expelt;
 197
 198   write_exp_elt (tmp);
 199 }
 200
 201 void
 202 write_exp_elt_sym (struct symbol *expelt)
 203 {
 204   union exp_element tmp;
 205   memset (&tmp, 0, sizeof (union exp_element));
 206
 207   tmp.symbol = expelt;
 208
 209   write_exp_elt (tmp);
 210 }
 211
 212 void
 213 write_exp_elt_block (struct block *b)
 214 {
 215   union exp_element tmp;
 216   memset (&tmp, 0, sizeof (union exp_element));
 217   tmp.block = b;
 218   write_exp_elt (tmp);
 219 }
 220
 221 void
 222 write_exp_elt_objfile (struct objfile *objfile)
 223 {
 224   union exp_element tmp;
 225   memset (&tmp, 0, sizeof (union exp_element));
 226   tmp.objfile = objfile;
 227   write_exp_elt (tmp);
 228 }
 229
 230 void
 231 write_exp_elt_longcst (LONGEST expelt)
 232 {
 233   union exp_element tmp;
 234   memset (&tmp, 0, sizeof (union exp_element));
 235
 236   tmp.longconst = expelt;
 237
 238   write_exp_elt (tmp);
 239 }
 240
 241 void
 242 write_exp_elt_dblcst (DOUBLEST expelt)
 243 {
 244   union exp_element tmp;
 245   memset (&tmp, 0, sizeof (union exp_element));
 246
 247   tmp.doubleconst = expelt;
 248
 249   write_exp_elt (tmp);
 250 }
 251
 252 void
 253 write_exp_elt_type (struct type *expelt)
 254 {
 255   union exp_element tmp;
 256   memset (&tmp, 0, sizeof (union exp_element));
 257
 258   tmp.type = expelt;
 259
 260   write_exp_elt (tmp);
 261 }
 262
 263 void
 264 write_exp_elt_intern (struct internalvar *expelt)
 265 {
 266   union exp_element tmp;
 267   memset (&tmp, 0, sizeof (union exp_element));
 268
 269   tmp.internalvar = expelt;
 270
 271   write_exp_elt (tmp);
 272 }
 273
 274 /* Add a string constant to the end of the expression.
 275
 276    String constants are stored by first writing an expression element
 277    that contains the length of the string, then stuffing the string
 278    constant itself into however many expression elements are needed
 279    to hold it, and then writing another expression element that contains
 280    the length of the string.  I.E. an expression element at each end of
 281    the string records the string length, so you can skip over the
 282    expression elements containing the actual string bytes from either
 283    end of the string.  Note that this also allows gdb to handle
 284    strings with embedded null bytes, as is required for some languages.
 285
 286    Don't be fooled by the fact that the string is null byte terminated,
 287    this is strictly for the convenience of debugging gdb itself.  Gdb
 288    Gdb does not depend up the string being null terminated, since the
 289    actual length is recorded in expression elements at each end of the
 290    string.  The null byte is taken into consideration when computing how
 291    many expression elements are required to hold the string constant, of
 292    course. */
 293
 294
 295 void
 296 write_exp_string (struct stoken str)
 297 {
 298   int len = str.length;
 299   int lenelt;
 300   char *strdata;
 301
 302   /* Compute the number of expression elements required to hold the string
 303      (including a null byte terminator), along with one expression element
 304      at each end to record the actual string length (not including the
 305      null byte terminator). */
 306
 307   lenelt = 2 + BYTES_TO_EXP_ELEM (len + 1);
 308
 309   /* Ensure that we have enough available expression elements to store
 310      everything. */
 311
 312   if ((expout_ptr + lenelt) >= expout_size)
 313     {
 314       expout_size = max (expout_size * 2, expout_ptr + lenelt + 10);
 315       expout = (struct expression *)
 316         xrealloc ((char *) expout, (sizeof (struct expression)
 317                                     + EXP_ELEM_TO_BYTES (expout_size)));
 318     }
 319
 320   /* Write the leading length expression element (which advances the current
 321      expression element index), then write the string constant followed by a
 322      terminating null byte, and then write the trailing length expression
 323      element. */
 324
 325   write_exp_elt_longcst ((LONGEST) len);
 326   strdata = (char *) &expout->elts[expout_ptr];
 327   memcpy (strdata, str.ptr, len);
 328   *(strdata + len) = '\0';
 329   expout_ptr += lenelt - 2;
 330   write_exp_elt_longcst ((LONGEST) len);
 331 }
 332
 333 /* Add a bitstring constant to the end of the expression.
 334
 335    Bitstring constants are stored by first writing an expression element
 336    that contains the length of the bitstring (in bits), then stuffing the
 337    bitstring constant itself into however many expression elements are
 338    needed to hold it, and then writing another expression element that
 339    contains the length of the bitstring.  I.E. an expression element at
 340    each end of the bitstring records the bitstring length, so you can skip
 341    over the expression elements containing the actual bitstring bytes from
 342    either end of the bitstring. */
 343
 344 void
 345 write_exp_bitstring (struct stoken str)
 346 {
 347   int bits = str.length;        /* length in bits */
 348   int len = (bits + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
 349   int lenelt;
 350   char *strdata;
 351
 352   /* Compute the number of expression elements required to hold the bitstring,
 353      along with one expression element at each end to record the actual
 354      bitstring length in bits. */
 355
 356   lenelt = 2 + BYTES_TO_EXP_ELEM (len);
 357
 358   /* Ensure that we have enough available expression elements to store
 359      everything. */
 360
 361   if ((expout_ptr + lenelt) >= expout_size)
 362     {
 363       expout_size = max (expout_size * 2, expout_ptr + lenelt + 10);
 364       expout = (struct expression *)
 365         xrealloc ((char *) expout, (sizeof (struct expression)
 366                                     + EXP_ELEM_TO_BYTES (expout_size)));
 367     }
 368
 369   /* Write the leading length expression element (which advances the current
 370      expression element index), then write the bitstring constant, and then
 371      write the trailing length expression element. */
 372
 373   write_exp_elt_longcst ((LONGEST) bits);
 374   strdata = (char *) &expout->elts[expout_ptr];
 375   memcpy (strdata, str.ptr, len);
 376   expout_ptr += lenelt - 2;
 377   write_exp_elt_longcst ((LONGEST) bits);
 378 }
 379
 380 /* Add the appropriate elements for a minimal symbol to the end of
 381    the expression.  The rationale behind passing in text_symbol_type and
 382    data_symbol_type was so that Modula-2 could pass in WORD for
 383    data_symbol_type.  Perhaps it still is useful to have those types vary
 384    based on the language, but they no longer have names like "int", so
 385    the initial rationale is gone.  */
 386
 387 static struct type *msym_text_symbol_type;
 388 static struct type *msym_data_symbol_type;
 389 static struct type *msym_unknown_symbol_type;
 390 static struct type *msym_tls_symbol_type;
 391
 392 void
 393 write_exp_msymbol (struct minimal_symbol *msymbol,
 394                    struct type *text_symbol_type,
 395                    struct type *data_symbol_type)
 396 {
 397   CORE_ADDR addr;
 398
 399   write_exp_elt_opcode (OP_LONG);
 400   /* Let's make the type big enough to hold a 64-bit address.  */
 401   write_exp_elt_type (builtin_type_CORE_ADDR);
 402
 403   addr = SYMBOL_VALUE_ADDRESS (msymbol);
 404   if (overlay_debugging)
 405     addr = symbol_overlayed_address (addr, SYMBOL_BFD_SECTION (msymbol));
 406   write_exp_elt_longcst ((LONGEST) addr);
 407
 408   write_exp_elt_opcode (OP_LONG);
 409
 410   if (SYMBOL_BFD_SECTION (msymbol)
 411       && SYMBOL_BFD_SECTION (msymbol)->flags & SEC_THREAD_LOCAL)
 412     {
 413       bfd *bfd = SYMBOL_BFD_SECTION (msymbol)->owner;
 414       struct objfile *ofp;
 415
 416       ALL_OBJFILES (ofp)
 417         if (ofp->obfd == bfd)
 418           break;
 419
 420       write_exp_elt_opcode (UNOP_MEMVAL_TLS);
 421       write_exp_elt_objfile (ofp);
 422       write_exp_elt_type (msym_tls_symbol_type);
 423       write_exp_elt_opcode (UNOP_MEMVAL_TLS);
 424       return;
 425     }
 426
 427   write_exp_elt_opcode (UNOP_MEMVAL);
 428   switch (msymbol->type)
 429     {
 430     case mst_text:
 431     case mst_file_text:
 432     case mst_solib_trampoline:
 433       write_exp_elt_type (msym_text_symbol_type);
 434       break;
 435
 436     case mst_data:
 437     case mst_file_data:
 438     case mst_bss:
 439     case mst_file_bss:
 440       write_exp_elt_type (msym_data_symbol_type);
 441       break;
 442
 443     default:
 444       write_exp_elt_type (msym_unknown_symbol_type);
 445       break;
 446     }
 447   write_exp_elt_opcode (UNOP_MEMVAL);
 448 }
 449 \f
 450 /* Recognize tokens that start with '$'.  These include:
 451
 452    $regname     A native register name or a "standard
 453    register name".
 454
 455    $variable    A convenience variable with a name chosen
 456    by the user.
 457
 458    $digits              Value history with index <digits>, starting
 459    from the first value which has index 1.
 460
 461    $$digits     Value history with index <digits> relative
 462    to the last value.  I.E. $$0 is the last
 463    value, $$1 is the one previous to that, $$2
 464    is the one previous to $$1, etc.
 465
 466    $ | $0 | $$0 The last value in the value history.
 467
 468    $$           An abbreviation for the second to the last
 469    value in the value history, I.E. $$1
 470
 471  */
 472
 473 void
 474 write_dollar_variable (struct stoken str)
 475 {
 476   struct symbol *sym = NULL;
 477   struct minimal_symbol *msym = NULL;
 478
 479   /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
 480      and $$digits (equivalent to $<-digits> if you could type that). */
 481
 482   int negate = 0;
 483   int i = 1;
 484   /* Double dollar means negate the number and add -1 as well.
 485      Thus $$ alone means -1.  */
 486   if (str.length >= 2 && str.ptr[1] == '$')
 487     {
 488       negate = 1;
 489       i = 2;
 490     }
 491   if (i == str.length)
 492     {
 493       /* Just dollars (one or two) */
 494       i = -negate;
 495       goto handle_last;
 496     }
 497   /* Is the rest of the token digits?  */
 498   for (; i < str.length; i++)
 499     if (!(str.ptr[i] >= '0' && str.ptr[i] <= '9'))
 500       break;
 501   if (i == str.length)
 502     {
 503       i = atoi (str.ptr + 1 + negate);
 504       if (negate)
 505         i = -i;
 506       goto handle_last;
 507     }
 508
 509   /* Handle tokens that refer to machine registers:
 510      $ followed by a register name.  */
 511   i = frame_map_name_to_regnum (deprecated_safe_get_selected_frame (),
 512                                 str.ptr + 1, str.length - 1);
 513   if (i >= 0)
 514     goto handle_register;
 515
 516   /* On some systems, such as HP-UX and hppa-linux, certain system routines
 517      have names beginning with $ or $$.  Check for those, first. */
 518
 519   sym = lookup_symbol (copy_name (str), (struct block *) NULL,
 520                        VAR_DOMAIN, (int *) NULL, (struct symtab **) NULL);
 521   if (sym)
 522     {
 523       write_exp_elt_opcode (OP_VAR_VALUE);
 524       write_exp_elt_block (block_found);        /* set by lookup_symbol */
 525       write_exp_elt_sym (sym);
 526       write_exp_elt_opcode (OP_VAR_VALUE);
 527       return;
 528     }
 529   msym = lookup_minimal_symbol (copy_name (str), NULL, NULL);
 530   if (msym)
 531     {
 532       write_exp_msymbol (msym,
 533                          lookup_function_type (builtin_type_int),
 534                          builtin_type_int);
 535       return;
 536     }
 537
 538   /* Any other names starting in $ are debugger internal variables.  */
 539
 540   write_exp_elt_opcode (OP_INTERNALVAR);
 541   write_exp_elt_intern (lookup_internalvar (copy_name (str) + 1));
 542   write_exp_elt_opcode (OP_INTERNALVAR);
 543   return;
 544 handle_last:
 545   write_exp_elt_opcode (OP_LAST);
 546   write_exp_elt_longcst ((LONGEST) i);
 547   write_exp_elt_opcode (OP_LAST);
 548   return;
 549 handle_register:
 550   write_exp_elt_opcode (OP_REGISTER);
 551   write_exp_elt_longcst (i);
 552   write_exp_elt_opcode (OP_REGISTER);
 553   return;
 554 }
 555
 556
 557 /* Parse a string that is possibly a namespace / nested class
 558    specification, i.e., something of the form A::B::C::x.  Input
 559    (NAME) is the entire string; LEN is the current valid length; the
 560    output is a string, TOKEN, which points to the largest recognized
 561    prefix which is a series of namespaces or classes.  CLASS_PREFIX is
 562    another output, which records whether a nested class spec was
 563    recognized (= 1) or a fully qualified variable name was found (=
 564    0).  ARGPTR is side-effected (if non-NULL) to point to beyond the
 565    string recognized and consumed by this routine.
 566
 567    The return value is a pointer to the symbol for the base class or
 568    variable if found, or NULL if not found.  Callers must check this
 569    first -- if NULL, the outputs may not be correct.
 570
 571    This function is used c-exp.y.  This is used specifically to get
 572    around HP aCC (and possibly other compilers), which insists on
 573    generating names with embedded colons for namespace or nested class
 574    members.
 575
 576    (Argument LEN is currently unused. 1997-08-27)
 577
 578    Callers must free memory allocated for the output string TOKEN.  */
 579
 580 static const char coloncolon[2] =
 581 {':', ':'};
 582
 583 struct symbol *
 584 parse_nested_classes_for_hpacc (char *name, int len, char **token,
 585                                 int *class_prefix, char **argptr)
 586 {
 587   /* Comment below comes from decode_line_1 which has very similar
 588      code, which is called for "break" command parsing. */
 589
 590   /* We have what looks like a class or namespace
 591      scope specification (A::B), possibly with many
 592      levels of namespaces or classes (A::B::C::D).
 593
 594      Some versions of the HP ANSI C++ compiler (as also possibly
 595      other compilers) generate class/function/member names with
 596      embedded double-colons if they are inside namespaces. To
 597      handle this, we loop a few times, considering larger and
 598      larger prefixes of the string as though they were single
 599      symbols.  So, if the initially supplied string is
 600      A::B::C::D::foo, we have to look up "A", then "A::B",
 601      then "A::B::C", then "A::B::C::D", and finally
 602      "A::B::C::D::foo" as single, monolithic symbols, because
 603      A, B, C or D may be namespaces.
 604
 605      Note that namespaces can nest only inside other
 606      namespaces, and not inside classes.  So we need only
 607      consider *prefixes* of the string; there is no need to look up
 608      "B::C" separately as a symbol in the previous example. */
 609
 610   char *p;
 611   char *start, *end;
 612   char *prefix = NULL;
 613   char *tmp;
 614   struct symbol *sym_class = NULL;
 615   struct symbol *sym_var = NULL;
 616   struct type *t;
 617   int prefix_len = 0;
 618   int done = 0;
 619   char *q;
 620
 621   /* Check for HP-compiled executable -- in other cases
 622      return NULL, and caller must default to standard GDB
 623      behaviour. */
 624
 625   if (!deprecated_hp_som_som_object_present)
 626     return (struct symbol *) NULL;
 627
 628   p = name;
 629
 630   /* Skip over whitespace and possible global "::" */
 631   while (*p && (*p == ' ' || *p == '\t'))
 632     p++;
 633   if (p[0] == ':' && p[1] == ':')
 634     p += 2;
 635   while (*p && (*p == ' ' || *p == '\t'))
 636     p++;
 637
 638   while (1)
 639     {
 640       /* Get to the end of the next namespace or class spec. */
 641       /* If we're looking at some non-token, fail immediately */
 642       start = p;
 643       if (!(isalpha (*p) || *p == '$' || *p == '_'))
 644         return (struct symbol *) NULL;
 645       p++;
 646       while (*p && (isalnum (*p) || *p == '$' || *p == '_'))
 647         p++;
 648
 649       if (*p == '<')
 650         {
 651           /* If we have the start of a template specification,
 652              scan right ahead to its end */
 653           q = find_template_name_end (p);
 654           if (q)
 655             p = q;
 656         }
 657
 658       end = p;
 659
 660       /* Skip over "::" and whitespace for next time around */
 661       while (*p && (*p == ' ' || *p == '\t'))
 662         p++;
 663       if (p[0] == ':' && p[1] == ':')
 664         p += 2;
 665       while (*p && (*p == ' ' || *p == '\t'))
 666         p++;
 667
 668       /* Done with tokens? */
 669       if (!*p || !(isalpha (*p) || *p == '$' || *p == '_'))
 670         done = 1;
 671
 672       tmp = (char *) alloca (prefix_len + end - start + 3);
 673       if (prefix)
 674         {
 675           memcpy (tmp, prefix, prefix_len);
 676           memcpy (tmp + prefix_len, coloncolon, 2);
 677           memcpy (tmp + prefix_len + 2, start, end - start);
 678           tmp[prefix_len + 2 + end - start] = '\000';
 679         }
 680       else
 681         {
 682           memcpy (tmp, start, end - start);
 683           tmp[end - start] = '\000';
 684         }
 685
 686       prefix = tmp;
 687       prefix_len = strlen (prefix);
 688
 689       /* See if the prefix we have now is something we know about */
 690
 691       if (!done)
 692         {
 693           /* More tokens to process, so this must be a class/namespace */
 694           sym_class = lookup_symbol (prefix, 0, STRUCT_DOMAIN,
 695                                      0, (struct symtab **) NULL);
 696         }
 697       else
 698         {
 699           /* No more tokens, so try as a variable first */
 700           sym_var = lookup_symbol (prefix, 0, VAR_DOMAIN,
 701                                    0, (struct symtab **) NULL);
 702           /* If failed, try as class/namespace */
 703           if (!sym_var)
 704             sym_class = lookup_symbol (prefix, 0, STRUCT_DOMAIN,
 705                                        0, (struct symtab **) NULL);
 706         }
 707
 708       if (sym_var ||
 709           (sym_class &&
 710            (t = check_typedef (SYMBOL_TYPE (sym_class)),
 711             (TYPE_CODE (t) == TYPE_CODE_STRUCT
 712              || TYPE_CODE (t) == TYPE_CODE_UNION))))
 713         {
 714           /* We found a valid token */
 715           *token = (char *) xmalloc (prefix_len + 1);
 716           memcpy (*token, prefix, prefix_len);
 717           (*token)[prefix_len] = '\000';
 718           break;
 719         }
 720
 721       /* No variable or class/namespace found, no more tokens */
 722       if (done)
 723         return (struct symbol *) NULL;
 724     }
 725
 726   /* Out of loop, so we must have found a valid token */
 727   if (sym_var)
 728     *class_prefix = 0;
 729   else
 730     *class_prefix = 1;
 731
 732   if (argptr)
 733     *argptr = done ? p : end;
 734
 735   return sym_var ? sym_var : sym_class;         /* found */
 736 }
 737
 738 char *
 739 find_template_name_end (char *p)
 740 {
 741   int depth = 1;
 742   int just_seen_right = 0;
 743   int just_seen_colon = 0;
 744   int just_seen_space = 0;
 745
 746   if (!p || (*p != '<'))
 747     return 0;
 748
 749   while (*++p)
 750     {
 751       switch (*p)
 752         {
 753         case '\'':
 754         case '\"':
 755         case '{':
 756         case '}':
 757           /* In future, may want to allow these?? */
 758           return 0;
 759         case '<':
 760           depth++;              /* start nested template */
 761           if (just_seen_colon || just_seen_right || just_seen_space)
 762             return 0;           /* but not after : or :: or > or space */
 763           break;
 764         case '>':
 765           if (just_seen_colon || just_seen_right)
 766             return 0;           /* end a (nested?) template */
 767           just_seen_right = 1;  /* but not after : or :: */
 768           if (--depth == 0)     /* also disallow >>, insist on > > */
 769             return ++p;         /* if outermost ended, return */
 770           break;
 771         case ':':
 772           if (just_seen_space || (just_seen_colon > 1))
 773             return 0;           /* nested class spec coming up */
 774           just_seen_colon++;    /* we allow :: but not :::: */
 775           break;
 776         case ' ':
 777           break;
 778         default:
 779           if (!((*p >= 'a' && *p <= 'z') ||     /* allow token chars */
 780                 (*p >= 'A' && *p <= 'Z') ||
 781                 (*p >= '0' && *p <= '9') ||
 782                 (*p == '_') || (*p == ',') ||   /* commas for template args */
 783                 (*p == '&') || (*p == '*') ||   /* pointer and ref types */
 784                 (*p == '(') || (*p == ')') ||   /* function types */
 785                 (*p == '[') || (*p == ']')))    /* array types */
 786             return 0;
 787         }
 788       if (*p != ' ')
 789         just_seen_space = 0;
 790       if (*p != ':')
 791         just_seen_colon = 0;
 792       if (*p != '>')
 793         just_seen_right = 0;
 794     }
 795   return 0;
 796 }
 797 \f
 798
 799
 800 /* Return a null-terminated temporary copy of the name
 801    of a string token.  */
 802
 803 char *
 804 copy_name (struct stoken token)
 805 {
 806   /* Make sure there's enough space for the token.  */
 807   if (namecopy_size < token.length + 1)
 808     {
 809       namecopy_size = token.length + 1;
 810       namecopy = xrealloc (namecopy, token.length + 1);
 811     }
 812
 813   memcpy (namecopy, token.ptr, token.length);
 814   namecopy[token.length] = 0;
 815
 816   return namecopy;
 817 }
 818 \f
 819 /* Reverse an expression from suffix form (in which it is constructed)
 820    to prefix form (in which we can conveniently print or execute it).  */
 821
 822 static void
 823 prefixify_expression (struct expression *expr)
 824 {
 825   int len =
 826   sizeof (struct expression) + EXP_ELEM_TO_BYTES (expr->nelts);
 827   struct expression *temp;
 828   int inpos = expr->nelts, outpos = 0;
 829
 830   temp = (struct expression *) alloca (len);
 831
 832   /* Copy the original expression into temp.  */
 833   memcpy (temp, expr, len);
 834
 835   prefixify_subexp (temp, expr, inpos, outpos);
 836 }
 837
 838 /* Return the number of exp_elements in the postfix subexpression
 839    of EXPR whose operator is at index ENDPOS - 1 in EXPR.  */
 840
 841 int
 842 length_of_subexp (struct expression *expr, int endpos)
 843 {
 844   int oplen, args, i;
 845
 846   operator_length (expr, endpos, &oplen, &args);
 847
 848   while (args > 0)
 849     {
 850       oplen += length_of_subexp (expr, endpos - oplen);
 851       args--;
 852     }
 853
 854   return oplen;
 855 }
 856
 857 /* Sets *OPLENP to the length of the operator whose (last) index is
 858    ENDPOS - 1 in EXPR, and sets *ARGSP to the number of arguments that
 859    operator takes.  */
 860
 861 void
 862 operator_length (struct expression *expr, int endpos, int *oplenp, int *argsp)
 863 {
 864   expr->language_defn->la_exp_desc->operator_length (expr, endpos,
 865                                                      oplenp, argsp);
 866 }
 867
 868 /* Default value for operator_length in exp_descriptor vectors.  */
 869
 870 void
 871 operator_length_standard (struct expression *expr, int endpos,
 872                           int *oplenp, int *argsp)
 873 {
 874   int oplen = 1;
 875   int args = 0;
 876   enum f90_range_type range_type;
 877   int i;
 878
 879   if (endpos < 1)
 880     error (_("?error in operator_length_standard"));
 881
 882   i = (int) expr->elts[endpos - 1].opcode;
 883
 884   switch (i)
 885     {
 886       /* C++  */
 887     case OP_SCOPE:
 888       oplen = longest_to_int (expr->elts[endpos - 2].longconst);
 889       oplen = 5 + BYTES_TO_EXP_ELEM (oplen + 1);
 890       break;
 891
 892     case OP_LONG:
 893     case OP_DOUBLE:
 894     case OP_VAR_VALUE:
 895       oplen = 4;
 896       break;
 897
 898     case OP_TYPE:
 899     case OP_BOOL:
 900     case OP_LAST:
 901     case OP_REGISTER:
 902     case OP_INTERNALVAR:
 903       oplen = 3;
 904       break;
 905
 906     case OP_COMPLEX:
 907       oplen = 1;
 908       args = 2;
 909       break;
 910
 911     case OP_FUNCALL:
 912     case OP_F77_UNDETERMINED_ARGLIST:
 913       oplen = 3;
 914       args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
 915       break;
 916
 917     case OP_OBJC_MSGCALL:       /* Objective C message (method) call */
 918       oplen = 4;
 919       args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
 920       break;
 921
 922     case UNOP_MAX:
 923     case UNOP_MIN:
 924       oplen = 3;
 925       break;
 926
 927     case BINOP_VAL:
 928     case UNOP_CAST:
 929     case UNOP_MEMVAL:
 930       oplen = 3;
 931       args = 1;
 932       break;
 933
 934     case UNOP_MEMVAL_TLS:
 935       oplen = 4;
 936       args = 1;
 937       break;
 938
 939     case UNOP_ABS:
 940     case UNOP_CAP:
 941     case UNOP_CHR:
 942     case UNOP_FLOAT:
 943     case UNOP_HIGH:
 944     case UNOP_ODD:
 945     case UNOP_ORD:
 946     case UNOP_TRUNC:
 947       oplen = 1;
 948       args = 1;
 949       break;
 950
 951     case OP_LABELED:
 952     case STRUCTOP_STRUCT:
 953     case STRUCTOP_PTR:
 954       args = 1;
 955       /* fall through */
 956     case OP_M2_STRING:
 957     case OP_STRING:
 958     case OP_OBJC_NSSTRING:      /* Objective C Foundation Class NSString constant */
 959     case OP_OBJC_SELECTOR:      /* Objective C "@selector" pseudo-op */
 960     case OP_NAME:
 961       oplen = longest_to_int (expr->elts[endpos - 2].longconst);
 962       oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
 963       break;
 964
 965     case OP_BITSTRING:
 966       oplen = longest_to_int (expr->elts[endpos - 2].longconst);
 967       oplen = (oplen + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
 968       oplen = 4 + BYTES_TO_EXP_ELEM (oplen);
 969       break;
 970
 971     case OP_ARRAY:
 972       oplen = 4;
 973       args = longest_to_int (expr->elts[endpos - 2].longconst);
 974       args -= longest_to_int (expr->elts[endpos - 3].longconst);
 975       args += 1;
 976       break;
 977
 978     case TERNOP_COND:
 979     case TERNOP_SLICE:
 980     case TERNOP_SLICE_COUNT:
 981       args = 3;
 982       break;
 983
 984       /* Modula-2 */
 985     case MULTI_SUBSCRIPT:
 986       oplen = 3;
 987       args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
 988       break;
 989
 990     case BINOP_ASSIGN_MODIFY:
 991       oplen = 3;
 992       args = 2;
 993       break;
 994
 995       /* C++ */
 996     case OP_THIS:
 997     case OP_OBJC_SELF:
 998       oplen = 2;
 999       break;
1000
1001     case OP_F90_RANGE:
1002       oplen = 3;
1003
1004       range_type = longest_to_int (expr->elts[endpos - 2].longconst);
1005       switch (range_type)
1006         {
1007         case LOW_BOUND_DEFAULT:
1008         case HIGH_BOUND_DEFAULT:
1009           args = 1;
1010           break;
1011         case BOTH_BOUND_DEFAULT:
1012           args = 0;
1013           break;
1014         case NONE_BOUND_DEFAULT:
1015           args = 2;
1016           break;
1017         }
1018
1019       break;
1020
1021     default:
1022       args = 1 + (i < (int) BINOP_END);
1023     }
1024
1025   *oplenp = oplen;
1026   *argsp = args;
1027 }
1028
1029 /* Copy the subexpression ending just before index INEND in INEXPR
1030    into OUTEXPR, starting at index OUTBEG.
1031    In the process, convert it from suffix to prefix form.  */
1032
1033 static void
1034 prefixify_subexp (struct expression *inexpr,
1035                   struct expression *outexpr, int inend, int outbeg)
1036 {
1037   int oplen;
1038   int args;
1039   int i;
1040   int *arglens;
1041   enum exp_opcode opcode;
1042
1043   operator_length (inexpr, inend, &oplen, &args);
1044
1045   /* Copy the final operator itself, from the end of the input
1046      to the beginning of the output.  */
1047   inend -= oplen;
1048   memcpy (&outexpr->elts[outbeg], &inexpr->elts[inend],
1049           EXP_ELEM_TO_BYTES (oplen));
1050   outbeg += oplen;
1051
1052   /* Find the lengths of the arg subexpressions.  */
1053   arglens = (int *) alloca (args * sizeof (int));
1054   for (i = args - 1; i >= 0; i--)
1055     {
1056       oplen = length_of_subexp (inexpr, inend);
1057       arglens[i] = oplen;
1058       inend -= oplen;
1059     }
1060
1061   /* Now copy each subexpression, preserving the order of
1062      the subexpressions, but prefixifying each one.
1063      In this loop, inend starts at the beginning of
1064      the expression this level is working on
1065      and marches forward over the arguments.
1066      outbeg does similarly in the output.  */
1067   for (i = 0; i < args; i++)
1068     {
1069       oplen = arglens[i];
1070       inend += oplen;
1071       prefixify_subexp (inexpr, outexpr, inend, outbeg);
1072       outbeg += oplen;
1073     }
1074 }
1075 \f
1076 /* This page contains the two entry points to this file.  */
1077
1078 /* Read an expression from the string *STRINGPTR points to,
1079    parse it, and return a pointer to a  struct expression  that we malloc.
1080    Use block BLOCK as the lexical context for variable names;
1081    if BLOCK is zero, use the block of the selected stack frame.
1082    Meanwhile, advance *STRINGPTR to point after the expression,
1083    at the first nonwhite character that is not part of the expression
1084    (possibly a null character).
1085
1086    If COMMA is nonzero, stop if a comma is reached.  */
1087
1088 struct expression *
1089 parse_exp_1 (char **stringptr, struct block *block, int comma)
1090 {
1091   return parse_exp_in_context (stringptr, block, comma, 0);
1092 }
1093
1094 /* As for parse_exp_1, except that if VOID_CONTEXT_P, then
1095    no value is expected from the expression.  */
1096
1097 static struct expression *
1098 parse_exp_in_context (char **stringptr, struct block *block, int comma,
1099                       int void_context_p)
1100 {
1101   struct cleanup *old_chain;
1102
1103   lexptr = *stringptr;
1104   prev_lexptr = NULL;
1105
1106   paren_depth = 0;
1107   type_stack_depth = 0;
1108
1109   comma_terminates = comma;
1110
1111   if (lexptr == 0 || *lexptr == 0)
1112     error_no_arg (_("expression to compute"));
1113
1114   old_chain = make_cleanup (free_funcalls, 0 /*ignore*/);
1115   funcall_chain = 0;
1116
1117   /* If no context specified, try using the current frame, if any. */
1118
1119   if (!block)
1120     block = get_selected_block (&expression_context_pc);
1121
1122   /* Fall back to using the current source static context, if any. */
1123
1124   if (!block)
1125     {
1126       struct symtab_and_line cursal = get_current_source_symtab_and_line ();
1127       if (cursal.symtab)
1128         block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (cursal.symtab), STATIC_BLOCK);
1129     }
1130
1131   /* Save the context, if specified by caller, or found above. */
1132
1133   if (block)
1134     {
1135       expression_context_block = block;
1136       expression_context_pc = BLOCK_START (block);
1137     }
1138
1139   expout_size = 10;
1140   expout_ptr = 0;
1141   expout = (struct expression *)
1142     xmalloc (sizeof (struct expression) + EXP_ELEM_TO_BYTES (expout_size));
1143   expout->language_defn = current_language;
1144   make_cleanup (free_current_contents, &expout);
1145
1146   if (current_language->la_parser ())
1147     current_language->la_error (NULL);
1148
1149   discard_cleanups (old_chain);
1150
1151   /* Record the actual number of expression elements, and then
1152      reallocate the expression memory so that we free up any
1153      excess elements. */
1154
1155   expout->nelts = expout_ptr;
1156   expout = (struct expression *)
1157     xrealloc ((char *) expout,
1158               sizeof (struct expression) + EXP_ELEM_TO_BYTES (expout_ptr));;
1159
1160   /* Convert expression from postfix form as generated by yacc
1161      parser, to a prefix form. */
1162
1163   if (expressiondebug)
1164     dump_raw_expression (expout, gdb_stdlog,
1165                          "before conversion to prefix form");
1166
1167   prefixify_expression (expout);
1168
1169   current_language->la_post_parser (&expout, void_context_p);
1170
1171   if (expressiondebug)
1172     dump_prefix_expression (expout, gdb_stdlog);
1173
1174   *stringptr = lexptr;
1175   return expout;
1176 }
1177
1178 /* Parse STRING as an expression, and complain if this fails
1179    to use up all of the contents of STRING.  */
1180
1181 struct expression *
1182 parse_expression (char *string)
1183 {
1184   struct expression *exp;
1185   exp = parse_exp_1 (&string, 0, 0);
1186   if (*string)
1187     error (_("Junk after end of expression."));
1188   return exp;
1189 }
1190
1191
1192 /* As for parse_expression, except that if VOID_CONTEXT_P, then
1193    no value is expected from the expression.  */
1194
1195 struct expression *
1196 parse_expression_in_context (char *string, int void_context_p)
1197 {
1198   struct expression *exp;
1199   exp = parse_exp_in_context (&string, 0, 0, void_context_p);
1200   if (*string != '\000')
1201     error (_("Junk after end of expression."));
1202   return exp;
1203 }
1204
1205 /* A post-parser that does nothing */
1206
1207 void
1208 null_post_parser (struct expression **exp, int void_context_p)
1209 {
1210 }
1211 \f
1212 /* Stuff for maintaining a stack of types.  Currently just used by C, but
1213    probably useful for any language which declares its types "backwards".  */
1214
1215 static void
1216 check_type_stack_depth (void)
1217 {
1218   if (type_stack_depth == type_stack_size)
1219     {
1220       type_stack_size *= 2;
1221       type_stack = (union type_stack_elt *)
1222         xrealloc ((char *) type_stack, type_stack_size * sizeof (*type_stack));
1223     }
1224 }
1225
1226 void
1227 push_type (enum type_pieces tp)
1228 {
1229   check_type_stack_depth ();
1230   type_stack[type_stack_depth++].piece = tp;
1231 }
1232
1233 void
1234 push_type_int (int n)
1235 {
1236   check_type_stack_depth ();
1237   type_stack[type_stack_depth++].int_val = n;
1238 }
1239
1240 void
1241 push_type_address_space (char *string)
1242 {
1243   push_type_int (address_space_name_to_int (string));
1244 }
1245
1246 enum type_pieces
1247 pop_type (void)
1248 {
1249   if (type_stack_depth)
1250     return type_stack[--type_stack_depth].piece;
1251   return tp_end;
1252 }
1253
1254 int
1255 pop_type_int (void)
1256 {
1257   if (type_stack_depth)
1258     return type_stack[--type_stack_depth].int_val;
1259   /* "Can't happen".  */
1260   return 0;
1261 }
1262
1263 /* Pop the type stack and return the type which corresponds to FOLLOW_TYPE
1264    as modified by all the stuff on the stack.  */
1265 struct type *
1266 follow_types (struct type *follow_type)
1267 {
1268   int done = 0;
1269   int make_const = 0;
1270   int make_volatile = 0;
1271   int make_addr_space = 0;
1272   int array_size;
1273   struct type *range_type;
1274
1275   while (!done)
1276     switch (pop_type ())
1277       {
1278       case tp_end:
1279         done = 1;
1280         if (make_const)
1281           follow_type = make_cv_type (make_const,
1282                                       TYPE_VOLATILE (follow_type),
1283                                       follow_type, 0);
1284         if (make_volatile)
1285           follow_type = make_cv_type (TYPE_CONST (follow_type),
1286                                       make_volatile,
1287                                       follow_type, 0);
1288         if (make_addr_space)
1289           follow_type = make_type_with_address_space (follow_type,
1290                                                       make_addr_space);
1291         make_const = make_volatile = 0;
1292         make_addr_space = 0;
1293         break;
1294       case tp_const:
1295         make_const = 1;
1296         break;
1297       case tp_volatile:
1298         make_volatile = 1;
1299         break;
1300       case tp_space_identifier:
1301         make_addr_space = pop_type_int ();
1302         break;
1303       case tp_pointer:
1304         follow_type = lookup_pointer_type (follow_type);
1305         if (make_const)
1306           follow_type = make_cv_type (make_const,
1307                                       TYPE_VOLATILE (follow_type),
1308                                       follow_type, 0);
1309         if (make_volatile)
1310           follow_type = make_cv_type (TYPE_CONST (follow_type),
1311                                       make_volatile,
1312                                       follow_type, 0);
1313         if (make_addr_space)
1314           follow_type = make_type_with_address_space (follow_type,
1315                                                       make_addr_space);
1316         make_const = make_volatile = 0;
1317         make_addr_space = 0;
1318         break;
1319       case tp_reference:
1320         follow_type = lookup_reference_type (follow_type);
1321         if (make_const)
1322           follow_type = make_cv_type (make_const,
1323                                       TYPE_VOLATILE (follow_type),
1324                                       follow_type, 0);
1325         if (make_volatile)
1326           follow_type = make_cv_type (TYPE_CONST (follow_type),
1327                                       make_volatile,
1328                                       follow_type, 0);
1329         if (make_addr_space)
1330           follow_type = make_type_with_address_space (follow_type,
1331                                                       make_addr_space);
1332         make_const = make_volatile = 0;
1333         make_addr_space = 0;
1334         break;
1335       case tp_array:
1336         array_size = pop_type_int ();
1337         /* FIXME-type-allocation: need a way to free this type when we are
1338            done with it.  */
1339         range_type =
1340           create_range_type ((struct type *) NULL,
1341                              builtin_type_int, 0,
1342                              array_size >= 0 ? array_size - 1 : 0);
1343         follow_type =
1344           create_array_type ((struct type *) NULL,
1345                              follow_type, range_type);
1346         if (array_size < 0)
1347           TYPE_ARRAY_UPPER_BOUND_TYPE (follow_type)
1348             = BOUND_CANNOT_BE_DETERMINED;
1349         break;
1350       case tp_function:
1351         /* FIXME-type-allocation: need a way to free this type when we are
1352            done with it.  */
1353         follow_type = lookup_function_type (follow_type);
1354         break;
1355       }
1356   return follow_type;
1357 }
1358 \f
1359 static void build_parse (void);
1360 static void
1361 build_parse (void)
1362 {
1363   int i;
1364
1365   msym_text_symbol_type =
1366     init_type (TYPE_CODE_FUNC, 1, 0, "<text variable, no debug info>", NULL);
1367   TYPE_TARGET_TYPE (msym_text_symbol_type) = builtin_type_int;
1368   msym_data_symbol_type =
1369     init_type (TYPE_CODE_INT, TARGET_INT_BIT / HOST_CHAR_BIT, 0,
1370                "<data variable, no debug info>", NULL);
1371   msym_unknown_symbol_type =
1372     init_type (TYPE_CODE_INT, 1, 0,
1373                "<variable (not text or data), no debug info>",
1374                NULL);
1375
1376   msym_tls_symbol_type =
1377     init_type (TYPE_CODE_INT, TARGET_INT_BIT / HOST_CHAR_BIT, 0,
1378                "<thread local variable, no debug info>", NULL);
1379 }
1380
1381 /* This function avoids direct calls to fprintf
1382    in the parser generated debug code.  */
1383 void
1384 parser_fprintf (FILE *x, const char *y, ...)
1385 {
1386   va_list args;
1387   va_start (args, y);
1388   if (x == stderr)
1389     vfprintf_unfiltered (gdb_stderr, y, args);
1390   else
1391     {
1392       fprintf_unfiltered (gdb_stderr, " Unknown FILE used.\n");
1393       vfprintf_unfiltered (gdb_stderr, y, args);
1394     }
1395   va_end (args);
1396 }
1397
1398 void
1399 _initialize_parse (void)
1400 {
1401   type_stack_size = 80;
1402   type_stack_depth = 0;
1403   type_stack = (union type_stack_elt *)
1404     xmalloc (type_stack_size * sizeof (*type_stack));
1405
1406   build_parse ();
1407
1408   /* FIXME - For the moment, handle types by swapping them in and out.
1409      Should be using the per-architecture data-pointer and a large
1410      struct. */
1411   DEPRECATED_REGISTER_GDBARCH_SWAP (msym_text_symbol_type);
1412   DEPRECATED_REGISTER_GDBARCH_SWAP (msym_data_symbol_type);
1413   DEPRECATED_REGISTER_GDBARCH_SWAP (msym_unknown_symbol_type);
1414   deprecated_register_gdbarch_swap (NULL, 0, build_parse);
1415
1416   add_setshow_zinteger_cmd ("expression", class_maintenance,
1417                             &expressiondebug, _("\
1418 Set expression debugging."), _("\
1419 Show expression debugging."), _("\
1420 When non-zero, the internal representation of expressions will be printed."),
1421                             NULL,
1422                             show_expressiondebug,
1423                             &setdebuglist, &showdebuglist);
1424 }