gdb/parse.c

   1 /* Parse expressions for GDB.
   2    Copyright (C) 1986, 1989, 1990, 1991 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., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  21
  22 /* Parse an expression from text in a string,
  23    and return the result as a  struct expression  pointer.
  24    That structure contains arithmetic operations in reverse polish,
  25    with constants represented by operations that are followed by special data.
  26    See expression.h for the details of the format.
  27    What is important here is that it can be built up sequentially
  28    during the process of parsing; the lower levels of the tree always
  29    come first in the result.  */
  30
  31 #include "defs.h"
  32 #include "symtab.h"
  33 #include "gdbtypes.h"
  34 #include "frame.h"
  35 #include "expression.h"
  36 #include "value.h"
  37 #include "command.h"
  38 #include "language.h"
  39 #include "parser-defs.h"
  40
  41 static void
  42 prefixify_expression PARAMS ((struct expression *));
  43
  44 static int
  45 length_of_subexp PARAMS ((struct expression *, int));
  46
  47 static void
  48 prefixify_subexp PARAMS ((struct expression *, struct expression *, int, int));
  49
  50 /* Assign machine-independent names to certain registers
  51    (unless overridden by the REGISTER_NAMES table) */
  52
  53 struct std_regs std_regs[] = {
  54 #ifdef PC_REGNUM
  55         { "pc", PC_REGNUM },
  56 #endif
  57 #ifdef FP_REGNUM
  58         { "fp", FP_REGNUM },
  59 #endif
  60 #ifdef SP_REGNUM
  61         { "sp", SP_REGNUM },
  62 #endif
  63 #ifdef PS_REGNUM
  64         { "ps", PS_REGNUM },
  65 #endif
  66 };
  67
  68 unsigned num_std_regs = (sizeof std_regs / sizeof std_regs[0]);
  69
  70
  71 /* Begin counting arguments for a function call,
  72    saving the data about any containing call.  */
  73
  74 void
  75 start_arglist ()
  76 {
  77   register struct funcall *new = (struct funcall *) xmalloc (sizeof (struct funcall));
  78
  79   new->next = funcall_chain;
  80   new->arglist_len = arglist_len;
  81   arglist_len = 0;
  82   funcall_chain = new;
  83 }
  84
  85 /* Return the number of arguments in a function call just terminated,
  86    and restore the data for the containing function call.  */
  87
  88 int
  89 end_arglist ()
  90 {
  91   register int val = arglist_len;
  92   register struct funcall *call = funcall_chain;
  93   funcall_chain = call->next;
  94   arglist_len = call->arglist_len;
  95   free ((PTR)call);
  96   return val;
  97 }
  98
  99 /* Free everything in the funcall chain.
 100    Used when there is an error inside parsing.  */
 101
 102 void
 103 free_funcalls ()
 104 {
 105   register struct funcall *call, *next;
 106
 107   for (call = funcall_chain; call; call = next)
 108     {
 109       next = call->next;
 110       free ((PTR)call);
 111     }
 112 }
 113 \f
 114 /* This page contains the functions for adding data to the  struct expression
 115    being constructed.  */
 116
 117 /* Add one element to the end of the expression.  */
 118
 119 /* To avoid a bug in the Sun 4 compiler, we pass things that can fit into
 120    a register through here */
 121
 122 void
 123 write_exp_elt (expelt)
 124      union exp_element expelt;
 125 {
 126   if (expout_ptr >= expout_size)
 127     {
 128       expout_size *= 2;
 129       expout = (struct expression *)
 130         xrealloc ((char *) expout, sizeof (struct expression)
 131                   + EXP_ELEM_TO_BYTES (expout_size));
 132     }
 133   expout->elts[expout_ptr++] = expelt;
 134 }
 135
 136 void
 137 write_exp_elt_opcode (expelt)
 138      enum exp_opcode expelt;
 139 {
 140   union exp_element tmp;
 141
 142   tmp.opcode = expelt;
 143
 144   write_exp_elt (tmp);
 145 }
 146
 147 void
 148 write_exp_elt_sym (expelt)
 149      struct symbol *expelt;
 150 {
 151   union exp_element tmp;
 152
 153   tmp.symbol = expelt;
 154
 155   write_exp_elt (tmp);
 156 }
 157
 158 void
 159 write_exp_elt_longcst (expelt)
 160      LONGEST expelt;
 161 {
 162   union exp_element tmp;
 163
 164   tmp.longconst = expelt;
 165
 166   write_exp_elt (tmp);
 167 }
 168
 169 void
 170 write_exp_elt_dblcst (expelt)
 171      double expelt;
 172 {
 173   union exp_element tmp;
 174
 175   tmp.doubleconst = expelt;
 176
 177   write_exp_elt (tmp);
 178 }
 179
 180 void
 181 write_exp_elt_type (expelt)
 182      struct type *expelt;
 183 {
 184   union exp_element tmp;
 185
 186   tmp.type = expelt;
 187
 188   write_exp_elt (tmp);
 189 }
 190
 191 void
 192 write_exp_elt_intern (expelt)
 193      struct internalvar *expelt;
 194 {
 195   union exp_element tmp;
 196
 197   tmp.internalvar = expelt;
 198
 199   write_exp_elt (tmp);
 200 }
 201
 202 /* Add a string constant to the end of the expression.
 203
 204    String constants are stored by first writing an expression element
 205    that contains the length of the string, then stuffing the string
 206    constant itself into however many expression elements are needed
 207    to hold it, and then writing another expression element that contains
 208    the length of the string.  I.E. an expression element at each end of
 209    the string records the string length, so you can skip over the
 210    expression elements containing the actual string bytes from either
 211    end of the string.  Note that this also allows gdb to handle
 212    strings with embedded null bytes, as is required for some languages.
 213
 214    Don't be fooled by the fact that the string is null byte terminated,
 215    this is strictly for the convenience of debugging gdb itself.  Gdb
 216    Gdb does not depend up the string being null terminated, since the
 217    actual length is recorded in expression elements at each end of the
 218    string.  The null byte is taken into consideration when computing how
 219    many expression elements are required to hold the string constant, of
 220    course. */
 221
 222
 223 void
 224 write_exp_string (str)
 225      struct stoken str;
 226 {
 227   register int len = str.length;
 228   register int lenelt;
 229   register char *strdata;
 230
 231   /* Compute the number of expression elements required to hold the string
 232      (including a null byte terminator), along with one expression element
 233      at each end to record the actual string length (not including the
 234      null byte terminator). */
 235
 236   lenelt = 2 + BYTES_TO_EXP_ELEM (len + 1);
 237
 238   /* Ensure that we have enough available expression elements to store
 239      everything. */
 240
 241   if ((expout_ptr + lenelt) >= expout_size)
 242     {
 243       expout_size = max (expout_size * 2, expout_ptr + lenelt + 10);
 244       expout = (struct expression *)
 245         xrealloc ((char *) expout, (sizeof (struct expression)
 246                                     + EXP_ELEM_TO_BYTES (expout_size)));
 247     }
 248
 249   /* Write the leading length expression element (which advances the current
 250      expression element index), then write the string constant followed by a
 251      terminating null byte, and then write the trailing length expression
 252      element. */
 253
 254   write_exp_elt_longcst ((LONGEST) len);
 255   strdata = (char *) &expout->elts[expout_ptr];
 256   memcpy (strdata, str.ptr, len);
 257   *(strdata + len) = '\0';
 258   expout_ptr += lenelt - 2;
 259   write_exp_elt_longcst ((LONGEST) len);
 260 }
 261
 262 /* Add a bitstring constant to the end of the expression.
 263
 264    Bitstring constants are stored by first writing an expression element
 265    that contains the length of the bitstring (in bits), then stuffing the
 266    bitstring constant itself into however many expression elements are
 267    needed to hold it, and then writing another expression element that
 268    contains the length of the bitstring.  I.E. an expression element at
 269    each end of the bitstring records the bitstring length, so you can skip
 270    over the expression elements containing the actual bitstring bytes from
 271    either end of the bitstring. */
 272
 273 void
 274 write_exp_bitstring (str)
 275      struct stoken str;
 276 {
 277   register int bits = str.length;       /* length in bits */
 278   register int len = (bits + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
 279   register int lenelt;
 280   register char *strdata;
 281
 282   /* Compute the number of expression elements required to hold the bitstring,
 283      along with one expression element at each end to record the actual
 284      bitstring length in bits. */
 285
 286   lenelt = 2 + BYTES_TO_EXP_ELEM (len);
 287
 288   /* Ensure that we have enough available expression elements to store
 289      everything. */
 290
 291   if ((expout_ptr + lenelt) >= expout_size)
 292     {
 293       expout_size = max (expout_size * 2, expout_ptr + lenelt + 10);
 294       expout = (struct expression *)
 295         xrealloc ((char *) expout, (sizeof (struct expression)
 296                                     + EXP_ELEM_TO_BYTES (expout_size)));
 297     }
 298
 299   /* Write the leading length expression element (which advances the current
 300      expression element index), then write the bitstring constant, and then
 301      write the trailing length expression element. */
 302
 303   write_exp_elt_longcst ((LONGEST) bits);
 304   strdata = (char *) &expout->elts[expout_ptr];
 305   memcpy (strdata, str.ptr, len);
 306   expout_ptr += lenelt - 2;
 307   write_exp_elt_longcst ((LONGEST) bits);
 308 }
 309 \f
 310 /* Return a null-terminated temporary copy of the name
 311    of a string token.  */
 312
 313 char *
 314 copy_name (token)
 315      struct stoken token;
 316 {
 317   memcpy (namecopy, token.ptr, token.length);
 318   namecopy[token.length] = 0;
 319   return namecopy;
 320 }
 321 \f
 322 /* Reverse an expression from suffix form (in which it is constructed)
 323    to prefix form (in which we can conveniently print or execute it).  */
 324
 325 static void
 326 prefixify_expression (expr)
 327      register struct expression *expr;
 328 {
 329   register int len =
 330     sizeof (struct expression) + EXP_ELEM_TO_BYTES (expr->nelts);
 331   register struct expression *temp;
 332   register int inpos = expr->nelts, outpos = 0;
 333
 334   temp = (struct expression *) alloca (len);
 335
 336   /* Copy the original expression into temp.  */
 337   memcpy (temp, expr, len);
 338
 339   prefixify_subexp (temp, expr, inpos, outpos);
 340 }
 341
 342 /* Return the number of exp_elements in the subexpression of EXPR
 343    whose last exp_element is at index ENDPOS - 1 in EXPR.  */
 344
 345 static int
 346 length_of_subexp (expr, endpos)
 347      register struct expression *expr;
 348      register int endpos;
 349 {
 350   register int oplen = 1;
 351   register int args = 0;
 352   register int i;
 353
 354   if (endpos < 1)
 355     error ("?error in length_of_subexp");
 356
 357   i = (int) expr->elts[endpos - 1].opcode;
 358
 359   switch (i)
 360     {
 361       /* C++  */
 362     case OP_SCOPE:
 363       oplen = longest_to_int (expr->elts[endpos - 2].longconst);
 364       oplen = 5 + BYTES_TO_EXP_ELEM (oplen + 1);
 365       break;
 366
 367     case OP_LONG:
 368     case OP_DOUBLE:
 369       oplen = 4;
 370       break;
 371
 372     case OP_TYPE:
 373     case OP_BOOL:
 374     case OP_VAR_VALUE:
 375     case OP_LAST:
 376     case OP_REGISTER:
 377     case OP_INTERNALVAR:
 378       oplen = 3;
 379       break;
 380
 381     case OP_FUNCALL:
 382       oplen = 3;
 383       args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
 384       break;
 385
 386     case UNOP_MAX:
 387     case UNOP_MIN:
 388       oplen = 3;
 389       break;
 390
 391    case BINOP_VAL:
 392    case UNOP_CAST:
 393    case UNOP_MEMVAL:
 394       oplen = 3;
 395       args = 1;
 396       break;
 397
 398     case UNOP_ABS:
 399     case UNOP_CAP:
 400     case UNOP_CHR:
 401     case UNOP_FLOAT:
 402     case UNOP_HIGH:
 403     case UNOP_ODD:
 404     case UNOP_ORD:
 405     case UNOP_TRUNC:
 406       oplen = 1;
 407       args = 1;
 408       break;
 409
 410     case STRUCTOP_STRUCT:
 411     case STRUCTOP_PTR:
 412       args = 1;
 413       /* fall through */
 414     case OP_M2_STRING:
 415     case OP_STRING:
 416       oplen = longest_to_int (expr->elts[endpos - 2].longconst);
 417       oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
 418       break;
 419
 420     case OP_BITSTRING:
 421       oplen = longest_to_int (expr->elts[endpos - 2].longconst);
 422       oplen = (oplen + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
 423       oplen = 4 + BYTES_TO_EXP_ELEM (oplen);
 424       break;
 425
 426     case TERNOP_COND:
 427       args = 3;
 428       break;
 429
 430       /* Modula-2 */
 431    case MULTI_SUBSCRIPT:
 432       oplen=3;
 433       args = 1 + longest_to_int (expr->elts[endpos- 2].longconst);
 434       break;
 435
 436     case BINOP_ASSIGN_MODIFY:
 437       oplen = 3;
 438       args = 2;
 439       break;
 440
 441       /* C++ */
 442     case OP_THIS:
 443       oplen = 2;
 444       break;
 445
 446     default:
 447       args = 1 + (i < (int) BINOP_END);
 448     }
 449
 450   while (args > 0)
 451     {
 452       oplen += length_of_subexp (expr, endpos - oplen);
 453       args--;
 454     }
 455
 456   return oplen;
 457 }
 458
 459 /* Copy the subexpression ending just before index INEND in INEXPR
 460    into OUTEXPR, starting at index OUTBEG.
 461    In the process, convert it from suffix to prefix form.  */
 462
 463 static void
 464 prefixify_subexp (inexpr, outexpr, inend, outbeg)
 465      register struct expression *inexpr;
 466      struct expression *outexpr;
 467      register int inend;
 468      int outbeg;
 469 {
 470   register int oplen = 1;
 471   register int args = 0;
 472   register int i;
 473   int *arglens;
 474   enum exp_opcode opcode;
 475
 476   /* Compute how long the last operation is (in OPLEN),
 477      and also how many preceding subexpressions serve as
 478      arguments for it (in ARGS).  */
 479
 480   opcode = inexpr->elts[inend - 1].opcode;
 481   switch (opcode)
 482     {
 483       /* C++  */
 484     case OP_SCOPE:
 485       oplen = longest_to_int (inexpr->elts[inend - 2].longconst);
 486       oplen = 5 + BYTES_TO_EXP_ELEM (oplen + 1);
 487       break;
 488
 489     case OP_LONG:
 490     case OP_DOUBLE:
 491       oplen = 4;
 492       break;
 493
 494     case OP_TYPE:
 495     case OP_BOOL:
 496     case OP_VAR_VALUE:
 497     case OP_LAST:
 498     case OP_REGISTER:
 499     case OP_INTERNALVAR:
 500       oplen = 3;
 501       break;
 502
 503     case OP_FUNCALL:
 504       oplen = 3;
 505       args = 1 + longest_to_int (inexpr->elts[inend - 2].longconst);
 506       break;
 507
 508     case UNOP_MIN:
 509     case UNOP_MAX:
 510       oplen = 3;
 511       break;
 512
 513     case UNOP_CAST:
 514     case UNOP_MEMVAL:
 515       oplen = 3;
 516       args = 1;
 517       break;
 518
 519     case UNOP_ABS:
 520     case UNOP_CAP:
 521     case UNOP_CHR:
 522     case UNOP_FLOAT:
 523     case UNOP_HIGH:
 524     case UNOP_ODD:
 525     case UNOP_ORD:
 526     case UNOP_TRUNC:
 527       oplen=1;
 528       args=1;
 529       break;
 530
 531    case STRUCTOP_STRUCT:
 532     case STRUCTOP_PTR:
 533       args = 1;
 534       /* fall through */
 535     case OP_M2_STRING:
 536     case OP_STRING:
 537       oplen = longest_to_int (inexpr->elts[inend - 2].longconst);
 538       oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
 539       break;
 540
 541     case OP_BITSTRING:
 542       oplen = longest_to_int (inexpr->elts[inend - 2].longconst);
 543       oplen = (oplen + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
 544       oplen = 4 + BYTES_TO_EXP_ELEM (oplen);
 545       break;
 546
 547     case TERNOP_COND:
 548       args = 3;
 549       break;
 550
 551     case BINOP_ASSIGN_MODIFY:
 552       oplen = 3;
 553       args = 2;
 554       break;
 555
 556       /* Modula-2 */
 557    case MULTI_SUBSCRIPT:
 558       oplen=3;
 559       args = 1 + longest_to_int (inexpr->elts[inend - 2].longconst);
 560       break;
 561
 562       /* C++ */
 563     case OP_THIS:
 564       oplen = 2;
 565       break;
 566
 567     default:
 568       args = 1 + ((int) opcode < (int) BINOP_END);
 569     }
 570
 571   /* Copy the final operator itself, from the end of the input
 572      to the beginning of the output.  */
 573   inend -= oplen;
 574   memcpy (&outexpr->elts[outbeg], &inexpr->elts[inend],
 575           EXP_ELEM_TO_BYTES (oplen));
 576   outbeg += oplen;
 577
 578   /* Find the lengths of the arg subexpressions.  */
 579   arglens = (int *) alloca (args * sizeof (int));
 580   for (i = args - 1; i >= 0; i--)
 581     {
 582       oplen = length_of_subexp (inexpr, inend);
 583       arglens[i] = oplen;
 584       inend -= oplen;
 585     }
 586
 587   /* Now copy each subexpression, preserving the order of
 588      the subexpressions, but prefixifying each one.
 589      In this loop, inend starts at the beginning of
 590      the expression this level is working on
 591      and marches forward over the arguments.
 592      outbeg does similarly in the output.  */
 593   for (i = 0; i < args; i++)
 594     {
 595       oplen = arglens[i];
 596       inend += oplen;
 597       prefixify_subexp (inexpr, outexpr, inend, outbeg);
 598       outbeg += oplen;
 599     }
 600 }
 601 \f
 602 /* This page contains the two entry points to this file.  */
 603
 604 /* Read an expression from the string *STRINGPTR points to,
 605    parse it, and return a pointer to a  struct expression  that we malloc.
 606    Use block BLOCK as the lexical context for variable names;
 607    if BLOCK is zero, use the block of the selected stack frame.
 608    Meanwhile, advance *STRINGPTR to point after the expression,
 609    at the first nonwhite character that is not part of the expression
 610    (possibly a null character).
 611
 612    If COMMA is nonzero, stop if a comma is reached.  */
 613
 614 struct expression *
 615 parse_exp_1 (stringptr, block, comma)
 616      char **stringptr;
 617      struct block *block;
 618      int comma;
 619 {
 620   struct cleanup *old_chain;
 621
 622   lexptr = *stringptr;
 623
 624   paren_depth = 0;
 625   type_stack_depth = 0;
 626
 627   comma_terminates = comma;
 628
 629   if (lexptr == 0 || *lexptr == 0)
 630     error_no_arg ("expression to compute");
 631
 632   old_chain = make_cleanup (free_funcalls, 0);
 633   funcall_chain = 0;
 634
 635   expression_context_block = block ? block : get_selected_block ();
 636
 637   namecopy = (char *) alloca (strlen (lexptr) + 1);
 638   expout_size = 10;
 639   expout_ptr = 0;
 640   expout = (struct expression *)
 641     xmalloc (sizeof (struct expression) + EXP_ELEM_TO_BYTES (expout_size));
 642   expout->language_defn = current_language;
 643   make_cleanup (free_current_contents, &expout);
 644
 645   if (current_language->la_parser ())
 646     current_language->la_error (NULL);
 647
 648   discard_cleanups (old_chain);
 649
 650   /* Record the actual number of expression elements, and then
 651      reallocate the expression memory so that we free up any
 652      excess elements. */
 653
 654   expout->nelts = expout_ptr;
 655   expout = (struct expression *)
 656     xrealloc ((char *) expout,
 657               sizeof (struct expression) + EXP_ELEM_TO_BYTES (expout_ptr));;
 658
 659   /* Convert expression from postfix form as generated by yacc
 660      parser, to a prefix form. */
 661
 662   DUMP_EXPRESSION (expout, stdout, "before conversion to prefix form");
 663   prefixify_expression (expout);
 664   DUMP_EXPRESSION (expout, stdout, "after conversion to prefix form");
 665
 666   *stringptr = lexptr;
 667   return expout;
 668 }
 669
 670 /* Parse STRING as an expression, and complain if this fails
 671    to use up all of the contents of STRING.  */
 672
 673 struct expression *
 674 parse_expression (string)
 675      char *string;
 676 {
 677   register struct expression *exp;
 678   exp = parse_exp_1 (&string, 0, 0);
 679   if (*string)
 680     error ("Junk after end of expression.");
 681   return exp;
 682 }
 683
 684 void
 685 push_type (tp)
 686      enum type_pieces tp;
 687 {
 688   if (type_stack_depth == type_stack_size)
 689     {
 690       type_stack_size *= 2;
 691       type_stack = (union type_stack_elt *)
 692         xrealloc ((char *) type_stack, type_stack_size * sizeof (*type_stack));
 693     }
 694   type_stack[type_stack_depth++].piece = tp;
 695 }
 696
 697 void
 698 push_type_int (n)
 699      int n;
 700 {
 701   if (type_stack_depth == type_stack_size)
 702     {
 703       type_stack_size *= 2;
 704       type_stack = (union type_stack_elt *)
 705         xrealloc ((char *) type_stack, type_stack_size * sizeof (*type_stack));
 706     }
 707   type_stack[type_stack_depth++].int_val = n;
 708 }
 709
 710 enum type_pieces
 711 pop_type ()
 712 {
 713   if (type_stack_depth)
 714     return type_stack[--type_stack_depth].piece;
 715   return tp_end;
 716 }
 717
 718 int
 719 pop_type_int ()
 720 {
 721   if (type_stack_depth)
 722     return type_stack[--type_stack_depth].int_val;
 723   /* "Can't happen".  */
 724   return 0;
 725 }
 726
 727 void
 728 _initialize_parse ()
 729 {
 730   type_stack_size = 80;
 731   type_stack_depth = 0;
 732   type_stack = (union type_stack_elt *)
 733     xmalloc (type_stack_size * sizeof (*type_stack));
 734 }