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