gdb/parse.c

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