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 *) xrealloc ((char *) expout,
 130                                                sizeof (struct expression)
 131                                                + expout_size * sizeof (union exp_element));
 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 + (len + sizeof (union exp_element)) / sizeof (union exp_element);
 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                            + (expout_size * sizeof (union exp_element))));
 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 \f
 262 /* Return a null-terminated temporary copy of the name
 263    of a string token.  */
 264
 265 char *
 266 copy_name (token)
 267      struct stoken token;
 268 {
 269   memcpy (namecopy, token.ptr, token.length);
 270   namecopy[token.length] = 0;
 271   return namecopy;
 272 }
 273 \f
 274 /* Reverse an expression from suffix form (in which it is constructed)
 275    to prefix form (in which we can conveniently print or execute it).  */
 276
 277 static void
 278 prefixify_expression (expr)
 279      register struct expression *expr;
 280 {
 281   register int len = sizeof (struct expression) +
 282                                     expr->nelts * sizeof (union exp_element);
 283   register struct expression *temp;
 284   register int inpos = expr->nelts, outpos = 0;
 285
 286   temp = (struct expression *) alloca (len);
 287
 288   /* Copy the original expression into temp.  */
 289   memcpy (temp, expr, len);
 290
 291   prefixify_subexp (temp, expr, inpos, outpos);
 292 }
 293
 294 /* Return the number of exp_elements in the subexpression of EXPR
 295    whose last exp_element is at index ENDPOS - 1 in EXPR.  */
 296
 297 static int
 298 length_of_subexp (expr, endpos)
 299      register struct expression *expr;
 300      register int endpos;
 301 {
 302   register int oplen = 1;
 303   register int args = 0;
 304   register int i;
 305
 306   if (endpos < 1)
 307     error ("?error in length_of_subexp");
 308
 309   i = (int) expr->elts[endpos - 1].opcode;
 310
 311   switch (i)
 312     {
 313       /* C++  */
 314     case OP_SCOPE:
 315       oplen = 5 + ((longest_to_int (expr->elts[endpos - 2].longconst)
 316                     + sizeof (union exp_element))
 317                    / sizeof (union exp_element));
 318       break;
 319
 320     case OP_LONG:
 321     case OP_DOUBLE:
 322       oplen = 4;
 323       break;
 324
 325     case OP_TYPE:
 326     case OP_BOOL:
 327     case OP_VAR_VALUE:
 328     case OP_LAST:
 329     case OP_REGISTER:
 330     case OP_INTERNALVAR:
 331       oplen = 3;
 332       break;
 333
 334     case OP_FUNCALL:
 335       oplen = 3;
 336       args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
 337       break;
 338
 339     case UNOP_MAX:
 340     case UNOP_MIN:
 341       oplen = 3;
 342       break;
 343
 344    case BINOP_VAL:
 345    case UNOP_CAST:
 346    case UNOP_MEMVAL:
 347       oplen = 3;
 348       args = 1;
 349       break;
 350
 351     case UNOP_ABS:
 352     case UNOP_CAP:
 353     case UNOP_CHR:
 354     case UNOP_FLOAT:
 355     case UNOP_HIGH:
 356     case UNOP_ODD:
 357     case UNOP_ORD:
 358     case UNOP_TRUNC:
 359       oplen = 1;
 360       args = 1;
 361       break;
 362
 363     case STRUCTOP_STRUCT:
 364     case STRUCTOP_PTR:
 365       args = 1;
 366       /* fall through */
 367     case OP_M2_STRING:
 368     case OP_STRING:
 369       oplen = 4 + ((longest_to_int (expr->elts[endpos - 2].longconst)
 370                     + sizeof (union exp_element))
 371                    / sizeof (union exp_element));
 372       break;
 373
 374     case TERNOP_COND:
 375       args = 3;
 376       break;
 377
 378       /* Modula-2 */
 379    case MULTI_SUBSCRIPT:
 380       oplen=3;
 381       args = 1 + longest_to_int (expr->elts[endpos- 2].longconst);
 382       break;
 383
 384     case BINOP_ASSIGN_MODIFY:
 385       oplen = 3;
 386       args = 2;
 387       break;
 388
 389       /* C++ */
 390     case OP_THIS:
 391       oplen = 2;
 392       break;
 393
 394     default:
 395       args = 1 + (i < (int) BINOP_END);
 396     }
 397
 398   while (args > 0)
 399     {
 400       oplen += length_of_subexp (expr, endpos - oplen);
 401       args--;
 402     }
 403
 404   return oplen;
 405 }
 406
 407 /* Copy the subexpression ending just before index INEND in INEXPR
 408    into OUTEXPR, starting at index OUTBEG.
 409    In the process, convert it from suffix to prefix form.  */
 410
 411 static void
 412 prefixify_subexp (inexpr, outexpr, inend, outbeg)
 413      register struct expression *inexpr;
 414      struct expression *outexpr;
 415      register int inend;
 416      int outbeg;
 417 {
 418   register int oplen = 1;
 419   register int args = 0;
 420   register int i;
 421   int *arglens;
 422   enum exp_opcode opcode;
 423
 424   /* Compute how long the last operation is (in OPLEN),
 425      and also how many preceding subexpressions serve as
 426      arguments for it (in ARGS).  */
 427
 428   opcode = inexpr->elts[inend - 1].opcode;
 429   switch (opcode)
 430     {
 431       /* C++  */
 432     case OP_SCOPE:
 433       oplen = 5 + ((longest_to_int (inexpr->elts[inend - 2].longconst)
 434                     + sizeof (union exp_element))
 435                    / sizeof (union exp_element));
 436       break;
 437
 438     case OP_LONG:
 439     case OP_DOUBLE:
 440       oplen = 4;
 441       break;
 442
 443     case OP_TYPE:
 444     case OP_BOOL:
 445     case OP_VAR_VALUE:
 446     case OP_LAST:
 447     case OP_REGISTER:
 448     case OP_INTERNALVAR:
 449       oplen = 3;
 450       break;
 451
 452     case OP_FUNCALL:
 453       oplen = 3;
 454       args = 1 + longest_to_int (inexpr->elts[inend - 2].longconst);
 455       break;
 456
 457     case UNOP_MIN:
 458     case UNOP_MAX:
 459       oplen = 3;
 460       break;
 461
 462     case UNOP_CAST:
 463     case UNOP_MEMVAL:
 464       oplen = 3;
 465       args = 1;
 466       break;
 467
 468     case UNOP_ABS:
 469     case UNOP_CAP:
 470     case UNOP_CHR:
 471     case UNOP_FLOAT:
 472     case UNOP_HIGH:
 473     case UNOP_ODD:
 474     case UNOP_ORD:
 475     case UNOP_TRUNC:
 476       oplen=1;
 477       args=1;
 478       break;
 479
 480    case STRUCTOP_STRUCT:
 481     case STRUCTOP_PTR:
 482       args = 1;
 483       /* fall through */
 484     case OP_M2_STRING:
 485     case OP_STRING:
 486       oplen = 4 + ((longest_to_int (inexpr->elts[inend - 2].longconst)
 487                     + sizeof (union exp_element))
 488                    / sizeof (union exp_element));
 489       break;
 490
 491     case TERNOP_COND:
 492       args = 3;
 493       break;
 494
 495     case BINOP_ASSIGN_MODIFY:
 496       oplen = 3;
 497       args = 2;
 498       break;
 499
 500       /* Modula-2 */
 501    case MULTI_SUBSCRIPT:
 502       oplen=3;
 503       args = 1 + longest_to_int (inexpr->elts[inend - 2].longconst);
 504       break;
 505
 506       /* C++ */
 507     case OP_THIS:
 508       oplen = 2;
 509       break;
 510
 511     default:
 512       args = 1 + ((int) opcode < (int) BINOP_END);
 513     }
 514
 515   /* Copy the final operator itself, from the end of the input
 516      to the beginning of the output.  */
 517   inend -= oplen;
 518   memcpy (&outexpr->elts[outbeg], &inexpr->elts[inend],
 519                  oplen * sizeof (union exp_element));
 520   outbeg += oplen;
 521
 522   /* Find the lengths of the arg subexpressions.  */
 523   arglens = (int *) alloca (args * sizeof (int));
 524   for (i = args - 1; i >= 0; i--)
 525     {
 526       oplen = length_of_subexp (inexpr, inend);
 527       arglens[i] = oplen;
 528       inend -= oplen;
 529     }
 530
 531   /* Now copy each subexpression, preserving the order of
 532      the subexpressions, but prefixifying each one.
 533      In this loop, inend starts at the beginning of
 534      the expression this level is working on
 535      and marches forward over the arguments.
 536      outbeg does similarly in the output.  */
 537   for (i = 0; i < args; i++)
 538     {
 539       oplen = arglens[i];
 540       inend += oplen;
 541       prefixify_subexp (inexpr, outexpr, inend, outbeg);
 542       outbeg += oplen;
 543     }
 544 }
 545 \f
 546 /* This page contains the two entry points to this file.  */
 547
 548 /* Read an expression from the string *STRINGPTR points to,
 549    parse it, and return a pointer to a  struct expression  that we malloc.
 550    Use block BLOCK as the lexical context for variable names;
 551    if BLOCK is zero, use the block of the selected stack frame.
 552    Meanwhile, advance *STRINGPTR to point after the expression,
 553    at the first nonwhite character that is not part of the expression
 554    (possibly a null character).
 555
 556    If COMMA is nonzero, stop if a comma is reached.  */
 557
 558 struct expression *
 559 parse_exp_1 (stringptr, block, comma)
 560      char **stringptr;
 561      struct block *block;
 562      int comma;
 563 {
 564   struct cleanup *old_chain;
 565
 566   lexptr = *stringptr;
 567
 568   paren_depth = 0;
 569   type_stack_depth = 0;
 570
 571   comma_terminates = comma;
 572
 573   if (lexptr == 0 || *lexptr == 0)
 574     error_no_arg ("expression to compute");
 575
 576   old_chain = make_cleanup (free_funcalls, 0);
 577   funcall_chain = 0;
 578
 579   expression_context_block = block ? block : get_selected_block ();
 580
 581   namecopy = (char *) alloca (strlen (lexptr) + 1);
 582   expout_size = 10;
 583   expout_ptr = 0;
 584   expout = (struct expression *)
 585     xmalloc (sizeof (struct expression)
 586              + expout_size * sizeof (union exp_element));
 587   expout->language_defn = current_language;
 588   make_cleanup (free_current_contents, &expout);
 589
 590   if (current_language->la_parser ())
 591     current_language->la_error (NULL);
 592
 593   discard_cleanups (old_chain);
 594
 595   /* Record the actual number of expression elements, and then
 596      reallocate the expression memory so that we free up any
 597      excess elements. */
 598
 599   expout->nelts = expout_ptr;
 600   expout = (struct expression *)
 601     xrealloc ((char *) expout,
 602               sizeof (struct expression)
 603               + expout_ptr * sizeof (union exp_element));
 604
 605   /* Convert expression from postfix form as generated by yacc
 606      parser, to a prefix form. */
 607
 608   DUMP_EXPRESSION (expout, stdout, "before conversion to prefix form");
 609   prefixify_expression (expout);
 610   DUMP_EXPRESSION (expout, stdout, "after conversion to prefix form");
 611
 612   *stringptr = lexptr;
 613   return expout;
 614 }
 615
 616 /* Parse STRING as an expression, and complain if this fails
 617    to use up all of the contents of STRING.  */
 618
 619 struct expression *
 620 parse_expression (string)
 621      char *string;
 622 {
 623   register struct expression *exp;
 624   exp = parse_exp_1 (&string, 0, 0);
 625   if (*string)
 626     error ("Junk after end of expression.");
 627   return exp;
 628 }
 629
 630 void
 631 push_type (tp)
 632      enum type_pieces tp;
 633 {
 634   if (type_stack_depth == type_stack_size)
 635     {
 636       type_stack_size *= 2;
 637       type_stack = (union type_stack_elt *)
 638         xrealloc ((char *) type_stack, type_stack_size * sizeof (*type_stack));
 639     }
 640   type_stack[type_stack_depth++].piece = tp;
 641 }
 642
 643 void
 644 push_type_int (n)
 645      int n;
 646 {
 647   if (type_stack_depth == type_stack_size)
 648     {
 649       type_stack_size *= 2;
 650       type_stack = (union type_stack_elt *)
 651         xrealloc ((char *) type_stack, type_stack_size * sizeof (*type_stack));
 652     }
 653   type_stack[type_stack_depth++].int_val = n;
 654 }
 655
 656 enum type_pieces
 657 pop_type ()
 658 {
 659   if (type_stack_depth)
 660     return type_stack[--type_stack_depth].piece;
 661   return tp_end;
 662 }
 663
 664 int
 665 pop_type_int ()
 666 {
 667   if (type_stack_depth)
 668     return type_stack[--type_stack_depth].int_val;
 669   /* "Can't happen".  */
 670   return 0;
 671 }
 672
 673 void
 674 _initialize_parse ()
 675 {
 676   type_stack_size = 80;
 677   type_stack_depth = 0;
 678   type_stack = (union type_stack_elt *)
 679     xmalloc (type_stack_size * sizeof (*type_stack));
 680 }