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