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