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