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