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 UNOP_MAX:
 834     case UNOP_MIN:
 835       oplen = 3;
 836       break;
 837
 838     case BINOP_VAL:
 839     case UNOP_CAST:
 840     case UNOP_MEMVAL:
 841       oplen = 3;
 842       args = 1;
 843       break;
 844
 845     case UNOP_ABS:
 846     case UNOP_CAP:
 847     case UNOP_CHR:
 848     case UNOP_FLOAT:
 849     case UNOP_HIGH:
 850     case UNOP_ODD:
 851     case UNOP_ORD:
 852     case UNOP_TRUNC:
 853       oplen = 1;
 854       args = 1;
 855       break;
 856
 857     case OP_LABELED:
 858     case STRUCTOP_STRUCT:
 859     case STRUCTOP_PTR:
 860       args = 1;
 861       /* fall through */
 862     case OP_M2_STRING:
 863     case OP_STRING:
 864     case OP_NAME:
 865     case OP_EXPRSTRING:
 866       oplen = longest_to_int (expr->elts[endpos - 2].longconst);
 867       oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
 868       break;
 869
 870     case OP_BITSTRING:
 871       oplen = longest_to_int (expr->elts[endpos - 2].longconst);
 872       oplen = (oplen + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
 873       oplen = 4 + BYTES_TO_EXP_ELEM (oplen);
 874       break;
 875
 876     case OP_ARRAY:
 877       oplen = 4;
 878       args = longest_to_int (expr->elts[endpos - 2].longconst);
 879       args -= longest_to_int (expr->elts[endpos - 3].longconst);
 880       args += 1;
 881       break;
 882
 883     case TERNOP_COND:
 884     case TERNOP_SLICE:
 885     case TERNOP_SLICE_COUNT:
 886       args = 3;
 887       break;
 888
 889       /* Modula-2 */
 890     case MULTI_SUBSCRIPT:
 891       oplen = 3;
 892       args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
 893       break;
 894
 895     case BINOP_ASSIGN_MODIFY:
 896       oplen = 3;
 897       args = 2;
 898       break;
 899
 900       /* C++ */
 901     case OP_THIS:
 902       oplen = 2;
 903       break;
 904
 905     default:
 906       args = 1 + (i < (int) BINOP_END);
 907     }
 908
 909   while (args > 0)
 910     {
 911       oplen += length_of_subexp (expr, endpos - oplen);
 912       args--;
 913     }
 914
 915   return oplen;
 916 }
 917
 918 /* Copy the subexpression ending just before index INEND in INEXPR
 919    into OUTEXPR, starting at index OUTBEG.
 920    In the process, convert it from suffix to prefix form.  */
 921
 922 static void
 923 prefixify_subexp (register struct expression *inexpr,
 924                   struct expression *outexpr, register int inend, int outbeg)
 925 {
 926   register int oplen = 1;
 927   register int args = 0;
 928   register int i;
 929   int *arglens;
 930   enum exp_opcode opcode;
 931
 932   /* Compute how long the last operation is (in OPLEN),
 933      and also how many preceding subexpressions serve as
 934      arguments for it (in ARGS).  */
 935
 936   opcode = inexpr->elts[inend - 1].opcode;
 937   switch (opcode)
 938     {
 939       /* C++  */
 940     case OP_SCOPE:
 941       oplen = longest_to_int (inexpr->elts[inend - 2].longconst);
 942       oplen = 5 + BYTES_TO_EXP_ELEM (oplen + 1);
 943       break;
 944
 945     case OP_LONG:
 946     case OP_DOUBLE:
 947     case OP_VAR_VALUE:
 948       oplen = 4;
 949       break;
 950
 951     case OP_TYPE:
 952     case OP_BOOL:
 953     case OP_LAST:
 954     case OP_REGISTER:
 955     case OP_INTERNALVAR:
 956       oplen = 3;
 957       break;
 958
 959     case OP_COMPLEX:
 960       oplen = 1;
 961       args = 2;
 962       break;
 963
 964     case OP_FUNCALL:
 965     case OP_F77_UNDETERMINED_ARGLIST:
 966       oplen = 3;
 967       args = 1 + longest_to_int (inexpr->elts[inend - 2].longconst);
 968       break;
 969
 970     case UNOP_MIN:
 971     case UNOP_MAX:
 972       oplen = 3;
 973       break;
 974
 975     case UNOP_CAST:
 976     case UNOP_MEMVAL:
 977       oplen = 3;
 978       args = 1;
 979       break;
 980
 981     case UNOP_ABS:
 982     case UNOP_CAP:
 983     case UNOP_CHR:
 984     case UNOP_FLOAT:
 985     case UNOP_HIGH:
 986     case UNOP_ODD:
 987     case UNOP_ORD:
 988     case UNOP_TRUNC:
 989       oplen = 1;
 990       args = 1;
 991       break;
 992
 993     case STRUCTOP_STRUCT:
 994     case STRUCTOP_PTR:
 995     case OP_LABELED:
 996       args = 1;
 997       /* fall through */
 998     case OP_M2_STRING:
 999     case OP_STRING:
1000     case OP_NAME:
1001     case OP_EXPRSTRING:
1002       oplen = longest_to_int (inexpr->elts[inend - 2].longconst);
1003       oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
1004       break;
1005
1006     case OP_BITSTRING:
1007       oplen = longest_to_int (inexpr->elts[inend - 2].longconst);
1008       oplen = (oplen + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
1009       oplen = 4 + BYTES_TO_EXP_ELEM (oplen);
1010       break;
1011
1012     case OP_ARRAY:
1013       oplen = 4;
1014       args = longest_to_int (inexpr->elts[inend - 2].longconst);
1015       args -= longest_to_int (inexpr->elts[inend - 3].longconst);
1016       args += 1;
1017       break;
1018
1019     case TERNOP_COND:
1020     case TERNOP_SLICE:
1021     case TERNOP_SLICE_COUNT:
1022       args = 3;
1023       break;
1024
1025     case BINOP_ASSIGN_MODIFY:
1026       oplen = 3;
1027       args = 2;
1028       break;
1029
1030       /* Modula-2 */
1031     case MULTI_SUBSCRIPT:
1032       oplen = 3;
1033       args = 1 + longest_to_int (inexpr->elts[inend - 2].longconst);
1034       break;
1035
1036       /* C++ */
1037     case OP_THIS:
1038       oplen = 2;
1039       break;
1040
1041     default:
1042       args = 1 + ((int) opcode < (int) BINOP_END);
1043     }
1044
1045   /* Copy the final operator itself, from the end of the input
1046      to the beginning of the output.  */
1047   inend -= oplen;
1048   memcpy (&outexpr->elts[outbeg], &inexpr->elts[inend],
1049           EXP_ELEM_TO_BYTES (oplen));
1050   outbeg += oplen;
1051
1052   /* Find the lengths of the arg subexpressions.  */
1053   arglens = (int *) alloca (args * sizeof (int));
1054   for (i = args - 1; i >= 0; i--)
1055     {
1056       oplen = length_of_subexp (inexpr, inend);
1057       arglens[i] = oplen;
1058       inend -= oplen;
1059     }
1060
1061   /* Now copy each subexpression, preserving the order of
1062      the subexpressions, but prefixifying each one.
1063      In this loop, inend starts at the beginning of
1064      the expression this level is working on
1065      and marches forward over the arguments.
1066      outbeg does similarly in the output.  */
1067   for (i = 0; i < args; i++)
1068     {
1069       oplen = arglens[i];
1070       inend += oplen;
1071       prefixify_subexp (inexpr, outexpr, inend, outbeg);
1072       outbeg += oplen;
1073     }
1074 }
1075 \f
1076 /* This page contains the two entry points to this file.  */
1077
1078 /* Read an expression from the string *STRINGPTR points to,
1079    parse it, and return a pointer to a  struct expression  that we malloc.
1080    Use block BLOCK as the lexical context for variable names;
1081    if BLOCK is zero, use the block of the selected stack frame.
1082    Meanwhile, advance *STRINGPTR to point after the expression,
1083    at the first nonwhite character that is not part of the expression
1084    (possibly a null character).
1085
1086    If COMMA is nonzero, stop if a comma is reached.  */
1087
1088 struct expression *
1089 parse_exp_1 (char **stringptr, struct block *block, int comma)
1090 {
1091   struct cleanup *old_chain;
1092
1093   lexptr = *stringptr;
1094   prev_lexptr = NULL;
1095
1096   paren_depth = 0;
1097   type_stack_depth = 0;
1098
1099   comma_terminates = comma;
1100
1101   if (lexptr == 0 || *lexptr == 0)
1102     error_no_arg ("expression to compute");
1103
1104   old_chain = make_cleanup (free_funcalls, 0 /*ignore*/);
1105   funcall_chain = 0;
1106
1107   if (block)
1108     {
1109       expression_context_block = block;
1110       expression_context_pc = block->startaddr;
1111     }
1112   else
1113     expression_context_block = get_selected_block (&expression_context_pc);
1114
1115   namecopy = (char *) alloca (strlen (lexptr) + 1);
1116   expout_size = 10;
1117   expout_ptr = 0;
1118   expout = (struct expression *)
1119     xmalloc (sizeof (struct expression) + EXP_ELEM_TO_BYTES (expout_size));
1120   expout->language_defn = current_language;
1121   make_cleanup (free_current_contents, &expout);
1122
1123   if (current_language->la_parser ())
1124     current_language->la_error (NULL);
1125
1126   discard_cleanups (old_chain);
1127
1128   /* Record the actual number of expression elements, and then
1129      reallocate the expression memory so that we free up any
1130      excess elements. */
1131
1132   expout->nelts = expout_ptr;
1133   expout = (struct expression *)
1134     xrealloc ((char *) expout,
1135               sizeof (struct expression) + EXP_ELEM_TO_BYTES (expout_ptr));;
1136
1137   /* Convert expression from postfix form as generated by yacc
1138      parser, to a prefix form. */
1139
1140   if (expressiondebug)
1141     dump_prefix_expression (expout, gdb_stdlog,
1142                             "before conversion to prefix form");
1143
1144   prefixify_expression (expout);
1145
1146   if (expressiondebug)
1147     dump_postfix_expression (expout, gdb_stdlog,
1148                              "after conversion to prefix form");
1149
1150   *stringptr = lexptr;
1151   return expout;
1152 }
1153
1154 /* Parse STRING as an expression, and complain if this fails
1155    to use up all of the contents of STRING.  */
1156
1157 struct expression *
1158 parse_expression (char *string)
1159 {
1160   register struct expression *exp;
1161   exp = parse_exp_1 (&string, 0, 0);
1162   if (*string)
1163     error ("Junk after end of expression.");
1164   return exp;
1165 }
1166 \f
1167 /* Stuff for maintaining a stack of types.  Currently just used by C, but
1168    probably useful for any language which declares its types "backwards".  */
1169
1170 static void
1171 check_type_stack_depth (void)
1172 {
1173   if (type_stack_depth == type_stack_size)
1174     {
1175       type_stack_size *= 2;
1176       type_stack = (union type_stack_elt *)
1177         xrealloc ((char *) type_stack, type_stack_size * sizeof (*type_stack));
1178     }
1179 }
1180
1181 void
1182 push_type (enum type_pieces tp)
1183 {
1184   check_type_stack_depth ();
1185   type_stack[type_stack_depth++].piece = tp;
1186 }
1187
1188 void
1189 push_type_int (int n)
1190 {
1191   check_type_stack_depth ();
1192   type_stack[type_stack_depth++].int_val = n;
1193 }
1194
1195 void
1196 push_type_address_space (char *string)
1197 {
1198   push_type_int (address_space_name_to_int (string));
1199 }
1200
1201 enum type_pieces
1202 pop_type (void)
1203 {
1204   if (type_stack_depth)
1205     return type_stack[--type_stack_depth].piece;
1206   return tp_end;
1207 }
1208
1209 int
1210 pop_type_int (void)
1211 {
1212   if (type_stack_depth)
1213     return type_stack[--type_stack_depth].int_val;
1214   /* "Can't happen".  */
1215   return 0;
1216 }
1217
1218 /* Pop the type stack and return the type which corresponds to FOLLOW_TYPE
1219    as modified by all the stuff on the stack.  */
1220 struct type *
1221 follow_types (struct type *follow_type)
1222 {
1223   int done = 0;
1224   int make_const = 0;
1225   int make_volatile = 0;
1226   int make_addr_space = 0;
1227   int array_size;
1228   struct type *range_type;
1229
1230   while (!done)
1231     switch (pop_type ())
1232       {
1233       case tp_end:
1234         done = 1;
1235         if (make_const)
1236           follow_type = make_cv_type (make_const,
1237                                       TYPE_VOLATILE (follow_type),
1238                                       follow_type, 0);
1239         if (make_volatile)
1240           follow_type = make_cv_type (TYPE_CONST (follow_type),
1241                                       make_volatile,
1242                                       follow_type, 0);
1243         if (make_addr_space)
1244           follow_type = make_type_with_address_space (follow_type,
1245                                                       make_addr_space);
1246         make_const = make_volatile = 0;
1247         make_addr_space = 0;
1248         break;
1249       case tp_const:
1250         make_const = 1;
1251         break;
1252       case tp_volatile:
1253         make_volatile = 1;
1254         break;
1255       case tp_space_identifier:
1256         make_addr_space = pop_type_int ();
1257         break;
1258       case tp_pointer:
1259         follow_type = lookup_pointer_type (follow_type);
1260         if (make_const)
1261           follow_type = make_cv_type (make_const,
1262                                       TYPE_VOLATILE (follow_type),
1263                                       follow_type, 0);
1264         if (make_volatile)
1265           follow_type = make_cv_type (TYPE_CONST (follow_type),
1266                                       make_volatile,
1267                                       follow_type, 0);
1268         if (make_addr_space)
1269           follow_type = make_type_with_address_space (follow_type,
1270                                                       make_addr_space);
1271         make_const = make_volatile = 0;
1272         make_addr_space = 0;
1273         break;
1274       case tp_reference:
1275         follow_type = lookup_reference_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_array:
1291         array_size = pop_type_int ();
1292         /* FIXME-type-allocation: need a way to free this type when we are
1293            done with it.  */
1294         range_type =
1295           create_range_type ((struct type *) NULL,
1296                              builtin_type_int, 0,
1297                              array_size >= 0 ? array_size - 1 : 0);
1298         follow_type =
1299           create_array_type ((struct type *) NULL,
1300                              follow_type, range_type);
1301         if (array_size < 0)
1302           TYPE_ARRAY_UPPER_BOUND_TYPE (follow_type)
1303             = BOUND_CANNOT_BE_DETERMINED;
1304         break;
1305       case tp_function:
1306         /* FIXME-type-allocation: need a way to free this type when we are
1307            done with it.  */
1308         follow_type = lookup_function_type (follow_type);
1309         break;
1310       }
1311   return follow_type;
1312 }
1313 \f
1314 static void build_parse (void);
1315 static void
1316 build_parse (void)
1317 {
1318   int i;
1319
1320   msym_text_symbol_type =
1321     init_type (TYPE_CODE_FUNC, 1, 0, "<text variable, no debug info>", NULL);
1322   TYPE_TARGET_TYPE (msym_text_symbol_type) = builtin_type_int;
1323   msym_data_symbol_type =
1324     init_type (TYPE_CODE_INT, TARGET_INT_BIT / HOST_CHAR_BIT, 0,
1325                "<data variable, no debug info>", NULL);
1326   msym_unknown_symbol_type =
1327     init_type (TYPE_CODE_INT, 1, 0,
1328                "<variable (not text or data), no debug info>",
1329                NULL);
1330 }
1331
1332 /* This function avoids direct calls to fprintf
1333    in the parser generated debug code.  */
1334 void
1335 parser_fprintf (FILE *x, const char *y, ...)
1336 {
1337   va_list args;
1338   va_start (args, y);
1339   if (x == stderr)
1340     vfprintf_unfiltered (gdb_stderr, y, args);
1341   else
1342     {
1343       fprintf_unfiltered (gdb_stderr, " Unknown FILE used.\n");
1344       vfprintf_unfiltered (gdb_stderr, y, args);
1345     }
1346   va_end (args);
1347 }
1348
1349 void
1350 _initialize_parse (void)
1351 {
1352   type_stack_size = 80;
1353   type_stack_depth = 0;
1354   type_stack = (union type_stack_elt *)
1355     xmalloc (type_stack_size * sizeof (*type_stack));
1356
1357   build_parse ();
1358
1359   /* FIXME - For the moment, handle types by swapping them in and out.
1360      Should be using the per-architecture data-pointer and a large
1361      struct. */
1362   register_gdbarch_swap (&msym_text_symbol_type, sizeof (msym_text_symbol_type), NULL);
1363   register_gdbarch_swap (&msym_data_symbol_type, sizeof (msym_data_symbol_type), NULL);
1364   register_gdbarch_swap (&msym_unknown_symbol_type, sizeof (msym_unknown_symbol_type), NULL);
1365
1366   register_gdbarch_swap (NULL, 0, build_parse);
1367
1368   add_show_from_set (
1369             add_set_cmd ("expression", class_maintenance, var_zinteger,
1370                          (char *) &expressiondebug,
1371                          "Set expression debugging.\n\
1372 When non-zero, the internal representation of expressions will be printed.",
1373                          &setdebuglist),
1374                       &showdebuglist);
1375 }