gdb/parse.c

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