contrib/gdb-6.2.1/gdb/parse.c

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