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