gdb/parse.c

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