gdb/parse.c

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