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