gdb/parse.c

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