gdb/parse.c

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