gdb/parse.c

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