gdb/jv-exp.y

   1 /* YACC parser for Java expressions, for GDB.
   2    Copyright (C) 1997, 1998, 1999, 2000, 2006, 2007, 2008, 2009
   3    Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 /* Parse a Java expression from text in a string,
  21    and return the result as a  struct expression  pointer.
  22    That structure contains arithmetic operations in reverse polish,
  23    with constants represented by operations that are followed by special data.
  24    See expression.h for the details of the format.
  25    What is important here is that it can be built up sequentially
  26    during the process of parsing; the lower levels of the tree always
  27    come first in the result.  Well, almost always; see ArrayAccess.
  28
  29    Note that malloc's and realloc's in this file are transformed to
  30    xmalloc and xrealloc respectively by the same sed command in the
  31    makefile that remaps any other malloc/realloc inserted by the parser
  32    generator.  Doing this with #defines and trying to control the interaction
  33    with include files (<malloc.h> and <stdlib.h> for example) just became
  34    too messy, particularly when such includes can be inserted at random
  35    times by the parser generator.  */
  36
  37 %{
  38
  39 #include "defs.h"
  40 #include "gdb_string.h"
  41 #include <ctype.h>
  42 #include "expression.h"
  43 #include "value.h"
  44 #include "parser-defs.h"
  45 #include "language.h"
  46 #include "jv-lang.h"
  47 #include "bfd.h" /* Required by objfiles.h.  */
  48 #include "symfile.h" /* Required by objfiles.h.  */
  49 #include "objfiles.h" /* For have_full_symbols and have_partial_symbols */
  50 #include "block.h"
  51
  52 #define parse_type builtin_type (parse_gdbarch)
  53
  54 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc),
  55    as well as gratuitiously global symbol names, so we can have multiple
  56    yacc generated parsers in gdb.  Note that these are only the variables
  57    produced by yacc.  If other parser generators (bison, byacc, etc) produce
  58    additional global names that conflict at link time, then those parser
  59    generators need to be fixed instead of adding those names to this list. */
  60
  61 #define yymaxdepth java_maxdepth
  62 #define yyparse java_parse
  63 #define yylex   java_lex
  64 #define yyerror java_error
  65 #define yylval  java_lval
  66 #define yychar  java_char
  67 #define yydebug java_debug
  68 #define yypact  java_pact
  69 #define yyr1    java_r1
  70 #define yyr2    java_r2
  71 #define yydef   java_def
  72 #define yychk   java_chk
  73 #define yypgo   java_pgo
  74 #define yyact   java_act
  75 #define yyexca  java_exca
  76 #define yyerrflag java_errflag
  77 #define yynerrs java_nerrs
  78 #define yyps    java_ps
  79 #define yypv    java_pv
  80 #define yys     java_s
  81 #define yy_yys  java_yys
  82 #define yystate java_state
  83 #define yytmp   java_tmp
  84 #define yyv     java_v
  85 #define yy_yyv  java_yyv
  86 #define yyval   java_val
  87 #define yylloc  java_lloc
  88 #define yyreds  java_reds               /* With YYDEBUG defined */
  89 #define yytoks  java_toks               /* With YYDEBUG defined */
  90 #define yyname  java_name               /* With YYDEBUG defined */
  91 #define yyrule  java_rule               /* With YYDEBUG defined */
  92 #define yylhs   java_yylhs
  93 #define yylen   java_yylen
  94 #define yydefred java_yydefred
  95 #define yydgoto java_yydgoto
  96 #define yysindex java_yysindex
  97 #define yyrindex java_yyrindex
  98 #define yygindex java_yygindex
  99 #define yytable  java_yytable
 100 #define yycheck  java_yycheck
 101
 102 #ifndef YYDEBUG
 103 #define YYDEBUG 1               /* Default to yydebug support */
 104 #endif
 105
 106 #define YYFPRINTF parser_fprintf
 107
 108 int yyparse (void);
 109
 110 static int yylex (void);
 111
 112 void yyerror (char *);
 113
 114 static struct type *java_type_from_name (struct stoken);
 115 static void push_expression_name (struct stoken);
 116 static void push_fieldnames (struct stoken);
 117
 118 static struct expression *copy_exp (struct expression *, int);
 119 static void insert_exp (int, struct expression *);
 120
 121 %}
 122
 123 /* Although the yacc "value" of an expression is not used,
 124    since the result is stored in the structure being created,
 125    other node types do have values.  */
 126
 127 %union
 128   {
 129     LONGEST lval;
 130     struct {
 131       LONGEST val;
 132       struct type *type;
 133     } typed_val_int;
 134     struct {
 135       DOUBLEST dval;
 136       struct type *type;
 137     } typed_val_float;
 138     struct symbol *sym;
 139     struct type *tval;
 140     struct stoken sval;
 141     struct ttype tsym;
 142     struct symtoken ssym;
 143     struct block *bval;
 144     enum exp_opcode opcode;
 145     struct internalvar *ivar;
 146     int *ivec;
 147   }
 148
 149 %{
 150 /* YYSTYPE gets defined by %union */
 151 static int parse_number (char *, int, int, YYSTYPE *);
 152 %}
 153
 154 %type <lval> rcurly Dims Dims_opt
 155 %type <tval> ClassOrInterfaceType ClassType /* ReferenceType Type ArrayType */
 156 %type <tval> IntegralType FloatingPointType NumericType PrimitiveType ArrayType PrimitiveOrArrayType
 157
 158 %token <typed_val_int> INTEGER_LITERAL
 159 %token <typed_val_float> FLOATING_POINT_LITERAL
 160
 161 %token <sval> IDENTIFIER
 162 %token <sval> STRING_LITERAL
 163 %token <lval> BOOLEAN_LITERAL
 164 %token <tsym> TYPENAME
 165 %type <sval> Name SimpleName QualifiedName ForcedName
 166
 167 /* A NAME_OR_INT is a symbol which is not known in the symbol table,
 168    but which would parse as a valid number in the current input radix.
 169    E.g. "c" when input_radix==16.  Depending on the parse, it will be
 170    turned into a name or into a number.  */
 171
 172 %token <sval> NAME_OR_INT
 173
 174 %token ERROR
 175
 176 /* Special type cases, put in to allow the parser to distinguish different
 177    legal basetypes.  */
 178 %token LONG SHORT BYTE INT CHAR BOOLEAN DOUBLE FLOAT
 179
 180 %token VARIABLE
 181
 182 %token <opcode> ASSIGN_MODIFY
 183
 184 %token SUPER NEW
 185
 186 %left ','
 187 %right '=' ASSIGN_MODIFY
 188 %right '?'
 189 %left OROR
 190 %left ANDAND
 191 %left '|'
 192 %left '^'
 193 %left '&'
 194 %left EQUAL NOTEQUAL
 195 %left '<' '>' LEQ GEQ
 196 %left LSH RSH
 197 %left '+' '-'
 198 %left '*' '/' '%'
 199 %right INCREMENT DECREMENT
 200 %right '.' '[' '('
 201
 202 \f
 203 %%
 204
 205 start   :       exp1
 206         |       type_exp
 207         ;
 208
 209 type_exp:       PrimitiveOrArrayType
 210                 {
 211                   write_exp_elt_opcode(OP_TYPE);
 212                   write_exp_elt_type($1);
 213                   write_exp_elt_opcode(OP_TYPE);
 214                 }
 215         ;
 216
 217 PrimitiveOrArrayType:
 218                 PrimitiveType
 219         |       ArrayType
 220         ;
 221
 222 StringLiteral:
 223         STRING_LITERAL
 224                 {
 225                   write_exp_elt_opcode (OP_STRING);
 226                   write_exp_string ($1);
 227                   write_exp_elt_opcode (OP_STRING);
 228                 }
 229 ;
 230
 231 Literal:
 232         INTEGER_LITERAL
 233                 { write_exp_elt_opcode (OP_LONG);
 234                   write_exp_elt_type ($1.type);
 235                   write_exp_elt_longcst ((LONGEST)($1.val));
 236                   write_exp_elt_opcode (OP_LONG); }
 237 |       NAME_OR_INT
 238                 { YYSTYPE val;
 239                   parse_number ($1.ptr, $1.length, 0, &val);
 240                   write_exp_elt_opcode (OP_LONG);
 241                   write_exp_elt_type (val.typed_val_int.type);
 242                   write_exp_elt_longcst ((LONGEST)val.typed_val_int.val);
 243                   write_exp_elt_opcode (OP_LONG);
 244                 }
 245 |       FLOATING_POINT_LITERAL
 246                 { write_exp_elt_opcode (OP_DOUBLE);
 247                   write_exp_elt_type ($1.type);
 248                   write_exp_elt_dblcst ($1.dval);
 249                   write_exp_elt_opcode (OP_DOUBLE); }
 250 |       BOOLEAN_LITERAL
 251                 { write_exp_elt_opcode (OP_LONG);
 252                   write_exp_elt_type (java_boolean_type);
 253                   write_exp_elt_longcst ((LONGEST)$1);
 254                   write_exp_elt_opcode (OP_LONG); }
 255 |       StringLiteral
 256         ;
 257
 258 /* UNUSED:
 259 Type:
 260         PrimitiveType
 261 |       ReferenceType
 262 ;
 263 */
 264
 265 PrimitiveType:
 266         NumericType
 267 |       BOOLEAN
 268                 { $$ = java_boolean_type; }
 269 ;
 270
 271 NumericType:
 272         IntegralType
 273 |       FloatingPointType
 274 ;
 275
 276 IntegralType:
 277         BYTE
 278                 { $$ = java_byte_type; }
 279 |       SHORT
 280                 { $$ = java_short_type; }
 281 |       INT
 282                 { $$ = java_int_type; }
 283 |       LONG
 284                 { $$ = java_long_type; }
 285 |       CHAR
 286                 { $$ = java_char_type; }
 287 ;
 288
 289 FloatingPointType:
 290         FLOAT
 291                 { $$ = java_float_type; }
 292 |       DOUBLE
 293                 { $$ = java_double_type; }
 294 ;
 295
 296 /* UNUSED:
 297 ReferenceType:
 298         ClassOrInterfaceType
 299 |       ArrayType
 300 ;
 301 */
 302
 303 ClassOrInterfaceType:
 304         Name
 305                 { $$ = java_type_from_name ($1); }
 306 ;
 307
 308 ClassType:
 309         ClassOrInterfaceType
 310 ;
 311
 312 ArrayType:
 313         PrimitiveType Dims
 314                 { $$ = java_array_type ($1, $2); }
 315 |       Name Dims
 316                 { $$ = java_array_type (java_type_from_name ($1), $2); }
 317 ;
 318
 319 Name:
 320         IDENTIFIER
 321 |       QualifiedName
 322 ;
 323
 324 ForcedName:
 325         SimpleName
 326 |       QualifiedName
 327 ;
 328
 329 SimpleName:
 330         IDENTIFIER
 331 |       NAME_OR_INT
 332 ;
 333
 334 QualifiedName:
 335         Name '.' SimpleName
 336                 { $$.length = $1.length + $3.length + 1;
 337                   if ($1.ptr + $1.length + 1 == $3.ptr
 338                       && $1.ptr[$1.length] == '.')
 339                     $$.ptr = $1.ptr;  /* Optimization. */
 340                   else
 341                     {
 342                       $$.ptr = (char *) malloc ($$.length + 1);
 343                       make_cleanup (free, $$.ptr);
 344                       sprintf ($$.ptr, "%.*s.%.*s",
 345                                $1.length, $1.ptr, $3.length, $3.ptr);
 346                 } }
 347 ;
 348
 349 /*
 350 type_exp:       type
 351                         { write_exp_elt_opcode(OP_TYPE);
 352                           write_exp_elt_type($1);
 353                           write_exp_elt_opcode(OP_TYPE);}
 354         ;
 355         */
 356
 357 /* Expressions, including the comma operator.  */
 358 exp1    :       Expression
 359         |       exp1 ',' Expression
 360                         { write_exp_elt_opcode (BINOP_COMMA); }
 361         ;
 362
 363 Primary:
 364         PrimaryNoNewArray
 365 |       ArrayCreationExpression
 366 ;
 367
 368 PrimaryNoNewArray:
 369         Literal
 370 |       '(' Expression ')'
 371 |       ClassInstanceCreationExpression
 372 |       FieldAccess
 373 |       MethodInvocation
 374 |       ArrayAccess
 375 |       lcurly ArgumentList rcurly
 376                 { write_exp_elt_opcode (OP_ARRAY);
 377                   write_exp_elt_longcst ((LONGEST) 0);
 378                   write_exp_elt_longcst ((LONGEST) $3);
 379                   write_exp_elt_opcode (OP_ARRAY); }
 380 ;
 381
 382 lcurly:
 383         '{'
 384                 { start_arglist (); }
 385 ;
 386
 387 rcurly:
 388         '}'
 389                 { $$ = end_arglist () - 1; }
 390 ;
 391
 392 ClassInstanceCreationExpression:
 393         NEW ClassType '(' ArgumentList_opt ')'
 394                 { internal_error (__FILE__, __LINE__,
 395                                   _("FIXME - ClassInstanceCreationExpression")); }
 396 ;
 397
 398 ArgumentList:
 399         Expression
 400                 { arglist_len = 1; }
 401 |       ArgumentList ',' Expression
 402                 { arglist_len++; }
 403 ;
 404
 405 ArgumentList_opt:
 406         /* EMPTY */
 407                 { arglist_len = 0; }
 408 | ArgumentList
 409 ;
 410
 411 ArrayCreationExpression:
 412         NEW PrimitiveType DimExprs Dims_opt
 413                 { internal_error (__FILE__, __LINE__,
 414                                   _("FIXME - ArrayCreationExpression")); }
 415 |       NEW ClassOrInterfaceType DimExprs Dims_opt
 416                 { internal_error (__FILE__, __LINE__,
 417                                   _("FIXME - ArrayCreationExpression")); }
 418 ;
 419
 420 DimExprs:
 421         DimExpr
 422 |       DimExprs DimExpr
 423 ;
 424
 425 DimExpr:
 426         '[' Expression ']'
 427 ;
 428
 429 Dims:
 430         '[' ']'
 431                 { $$ = 1; }
 432 |       Dims '[' ']'
 433         { $$ = $1 + 1; }
 434 ;
 435
 436 Dims_opt:
 437         Dims
 438 |       /* EMPTY */
 439                 { $$ = 0; }
 440 ;
 441
 442 FieldAccess:
 443         Primary '.' SimpleName
 444                 { push_fieldnames ($3); }
 445 |       VARIABLE '.' SimpleName
 446                 { push_fieldnames ($3); }
 447 /*|     SUPER '.' SimpleName { FIXME } */
 448 ;
 449
 450 FuncStart:
 451         Name '('
 452                 { push_expression_name ($1); }
 453 ;
 454
 455 MethodInvocation:
 456         FuncStart
 457                 { start_arglist(); }
 458         ArgumentList_opt ')'
 459                 { write_exp_elt_opcode (OP_FUNCALL);
 460                   write_exp_elt_longcst ((LONGEST) end_arglist ());
 461                   write_exp_elt_opcode (OP_FUNCALL); }
 462 |       Primary '.' SimpleName '(' ArgumentList_opt ')'
 463                 { error (_("Form of method invocation not implemented")); }
 464 |       SUPER '.' SimpleName '(' ArgumentList_opt ')'
 465                 { error (_("Form of method invocation not implemented")); }
 466 ;
 467
 468 ArrayAccess:
 469         Name '[' Expression ']'
 470                 {
 471                   /* Emit code for the Name now, then exchange it in the
 472                      expout array with the Expression's code.  We could
 473                      introduce a OP_SWAP code or a reversed version of
 474                      BINOP_SUBSCRIPT, but that makes the rest of GDB pay
 475                      for our parsing kludges.  */
 476                   struct expression *name_expr;
 477
 478                   push_expression_name ($1);
 479                   name_expr = copy_exp (expout, expout_ptr);
 480                   expout_ptr -= name_expr->nelts;
 481                   insert_exp (expout_ptr-length_of_subexp (expout, expout_ptr),
 482                               name_expr);
 483                   free (name_expr);
 484                   write_exp_elt_opcode (BINOP_SUBSCRIPT);
 485                 }
 486 |       VARIABLE '[' Expression ']'
 487                 { write_exp_elt_opcode (BINOP_SUBSCRIPT); }
 488 |       PrimaryNoNewArray '[' Expression ']'
 489                 { write_exp_elt_opcode (BINOP_SUBSCRIPT); }
 490 ;
 491
 492 PostfixExpression:
 493         Primary
 494 |       Name
 495                 { push_expression_name ($1); }
 496 |       VARIABLE
 497                 /* Already written by write_dollar_variable. */
 498 |       PostIncrementExpression
 499 |       PostDecrementExpression
 500 ;
 501
 502 PostIncrementExpression:
 503         PostfixExpression INCREMENT
 504                 { write_exp_elt_opcode (UNOP_POSTINCREMENT); }
 505 ;
 506
 507 PostDecrementExpression:
 508         PostfixExpression DECREMENT
 509                 { write_exp_elt_opcode (UNOP_POSTDECREMENT); }
 510 ;
 511
 512 UnaryExpression:
 513         PreIncrementExpression
 514 |       PreDecrementExpression
 515 |       '+' UnaryExpression
 516 |       '-' UnaryExpression
 517                 { write_exp_elt_opcode (UNOP_NEG); }
 518 |       '*' UnaryExpression
 519                 { write_exp_elt_opcode (UNOP_IND); } /*FIXME not in Java  */
 520 |       UnaryExpressionNotPlusMinus
 521 ;
 522
 523 PreIncrementExpression:
 524         INCREMENT UnaryExpression
 525                 { write_exp_elt_opcode (UNOP_PREINCREMENT); }
 526 ;
 527
 528 PreDecrementExpression:
 529         DECREMENT UnaryExpression
 530                 { write_exp_elt_opcode (UNOP_PREDECREMENT); }
 531 ;
 532
 533 UnaryExpressionNotPlusMinus:
 534         PostfixExpression
 535 |       '~' UnaryExpression
 536                 { write_exp_elt_opcode (UNOP_COMPLEMENT); }
 537 |       '!' UnaryExpression
 538                 { write_exp_elt_opcode (UNOP_LOGICAL_NOT); }
 539 |       CastExpression
 540         ;
 541
 542 CastExpression:
 543         '(' PrimitiveType Dims_opt ')' UnaryExpression
 544                 { write_exp_elt_opcode (UNOP_CAST);
 545                   write_exp_elt_type (java_array_type ($2, $3));
 546                   write_exp_elt_opcode (UNOP_CAST); }
 547 |       '(' Expression ')' UnaryExpressionNotPlusMinus
 548                 {
 549                   int exp_size = expout_ptr;
 550                   int last_exp_size = length_of_subexp(expout, expout_ptr);
 551                   struct type *type;
 552                   int i;
 553                   int base = expout_ptr - last_exp_size - 3;
 554                   if (base < 0 || expout->elts[base+2].opcode != OP_TYPE)
 555                     error (_("Invalid cast expression"));
 556                   type = expout->elts[base+1].type;
 557                   /* Remove the 'Expression' and slide the
 558                      UnaryExpressionNotPlusMinus down to replace it. */
 559                   for (i = 0;  i < last_exp_size;  i++)
 560                     expout->elts[base + i] = expout->elts[base + i + 3];
 561                   expout_ptr -= 3;
 562                   if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
 563                     type = lookup_pointer_type (type);
 564                   write_exp_elt_opcode (UNOP_CAST);
 565                   write_exp_elt_type (type);
 566                   write_exp_elt_opcode (UNOP_CAST);
 567                 }
 568 |       '(' Name Dims ')' UnaryExpressionNotPlusMinus
 569                 { write_exp_elt_opcode (UNOP_CAST);
 570                   write_exp_elt_type (java_array_type (java_type_from_name ($2), $3));
 571                   write_exp_elt_opcode (UNOP_CAST); }
 572 ;
 573
 574
 575 MultiplicativeExpression:
 576         UnaryExpression
 577 |       MultiplicativeExpression '*' UnaryExpression
 578                 { write_exp_elt_opcode (BINOP_MUL); }
 579 |       MultiplicativeExpression '/' UnaryExpression
 580                 { write_exp_elt_opcode (BINOP_DIV); }
 581 |       MultiplicativeExpression '%' UnaryExpression
 582                 { write_exp_elt_opcode (BINOP_REM); }
 583 ;
 584
 585 AdditiveExpression:
 586         MultiplicativeExpression
 587 |       AdditiveExpression '+' MultiplicativeExpression
 588                 { write_exp_elt_opcode (BINOP_ADD); }
 589 |       AdditiveExpression '-' MultiplicativeExpression
 590                 { write_exp_elt_opcode (BINOP_SUB); }
 591 ;
 592
 593 ShiftExpression:
 594         AdditiveExpression
 595 |       ShiftExpression LSH AdditiveExpression
 596                 { write_exp_elt_opcode (BINOP_LSH); }
 597 |       ShiftExpression RSH AdditiveExpression
 598                 { write_exp_elt_opcode (BINOP_RSH); }
 599 /* |    ShiftExpression >>> AdditiveExpression { FIXME } */
 600 ;
 601
 602 RelationalExpression:
 603         ShiftExpression
 604 |       RelationalExpression '<' ShiftExpression
 605                 { write_exp_elt_opcode (BINOP_LESS); }
 606 |       RelationalExpression '>' ShiftExpression
 607                 { write_exp_elt_opcode (BINOP_GTR); }
 608 |       RelationalExpression LEQ ShiftExpression
 609                 { write_exp_elt_opcode (BINOP_LEQ); }
 610 |       RelationalExpression GEQ ShiftExpression
 611                 { write_exp_elt_opcode (BINOP_GEQ); }
 612 /* | RelationalExpresion INSTANCEOF ReferenceType { FIXME } */
 613 ;
 614
 615 EqualityExpression:
 616         RelationalExpression
 617 |       EqualityExpression EQUAL RelationalExpression
 618                 { write_exp_elt_opcode (BINOP_EQUAL); }
 619 |       EqualityExpression NOTEQUAL RelationalExpression
 620                 { write_exp_elt_opcode (BINOP_NOTEQUAL); }
 621 ;
 622
 623 AndExpression:
 624         EqualityExpression
 625 |       AndExpression '&' EqualityExpression
 626                 { write_exp_elt_opcode (BINOP_BITWISE_AND); }
 627 ;
 628
 629 ExclusiveOrExpression:
 630         AndExpression
 631 |       ExclusiveOrExpression '^' AndExpression
 632                 { write_exp_elt_opcode (BINOP_BITWISE_XOR); }
 633 ;
 634 InclusiveOrExpression:
 635         ExclusiveOrExpression
 636 |       InclusiveOrExpression '|' ExclusiveOrExpression
 637                 { write_exp_elt_opcode (BINOP_BITWISE_IOR); }
 638 ;
 639
 640 ConditionalAndExpression:
 641         InclusiveOrExpression
 642 |       ConditionalAndExpression ANDAND InclusiveOrExpression
 643                 { write_exp_elt_opcode (BINOP_LOGICAL_AND); }
 644 ;
 645
 646 ConditionalOrExpression:
 647         ConditionalAndExpression
 648 |       ConditionalOrExpression OROR ConditionalAndExpression
 649                 { write_exp_elt_opcode (BINOP_LOGICAL_OR); }
 650 ;
 651
 652 ConditionalExpression:
 653         ConditionalOrExpression
 654 |       ConditionalOrExpression '?' Expression ':' ConditionalExpression
 655                 { write_exp_elt_opcode (TERNOP_COND); }
 656 ;
 657
 658 AssignmentExpression:
 659         ConditionalExpression
 660 |       Assignment
 661 ;
 662
 663 Assignment:
 664         LeftHandSide '=' ConditionalExpression
 665                 { write_exp_elt_opcode (BINOP_ASSIGN); }
 666 |       LeftHandSide ASSIGN_MODIFY ConditionalExpression
 667                 { write_exp_elt_opcode (BINOP_ASSIGN_MODIFY);
 668                   write_exp_elt_opcode ($2);
 669                   write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); }
 670 ;
 671
 672 LeftHandSide:
 673         ForcedName
 674                 { push_expression_name ($1); }
 675 |       VARIABLE
 676                 /* Already written by write_dollar_variable. */
 677 |       FieldAccess
 678 |       ArrayAccess
 679 ;
 680
 681
 682 Expression:
 683         AssignmentExpression
 684 ;
 685
 686 %%
 687 /* Take care of parsing a number (anything that starts with a digit).
 688    Set yylval and return the token type; update lexptr.
 689    LEN is the number of characters in it.  */
 690
 691 /*** Needs some error checking for the float case ***/
 692
 693 static int
 694 parse_number (char *p, int len, int parsed_float, YYSTYPE *putithere)
 695 {
 696   ULONGEST n = 0;
 697   ULONGEST limit, limit_div_base;
 698
 699   int c;
 700   int base = input_radix;
 701
 702   struct type *type;
 703
 704   if (parsed_float)
 705     {
 706       /* It's a float since it contains a point or an exponent.  */
 707       char c;
 708       int num = 0;      /* number of tokens scanned by scanf */
 709       char saved_char = p[len];
 710
 711       p[len] = 0;       /* null-terminate the token */
 712       num = sscanf (p, "%" DOUBLEST_SCAN_FORMAT "%c",
 713                     &putithere->typed_val_float.dval, &c);
 714       p[len] = saved_char;      /* restore the input stream */
 715       if (num != 1)             /* check scanf found ONLY a float ... */
 716         return ERROR;
 717       /* See if it has `f' or `d' suffix (float or double).  */
 718
 719       c = tolower (p[len - 1]);
 720
 721       if (c == 'f' || c == 'F')
 722         putithere->typed_val_float.type = parse_type->builtin_float;
 723       else if (isdigit (c) || c == '.' || c == 'd' || c == 'D')
 724         putithere->typed_val_float.type = parse_type->builtin_double;
 725       else
 726         return ERROR;
 727
 728       return FLOATING_POINT_LITERAL;
 729     }
 730
 731   /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
 732   if (p[0] == '0')
 733     switch (p[1])
 734       {
 735       case 'x':
 736       case 'X':
 737         if (len >= 3)
 738           {
 739             p += 2;
 740             base = 16;
 741             len -= 2;
 742           }
 743         break;
 744
 745       case 't':
 746       case 'T':
 747       case 'd':
 748       case 'D':
 749         if (len >= 3)
 750           {
 751             p += 2;
 752             base = 10;
 753             len -= 2;
 754           }
 755         break;
 756
 757       default:
 758         base = 8;
 759         break;
 760       }
 761
 762   c = p[len-1];
 763   /* A paranoid calculation of (1<<64)-1. */
 764   limit = (ULONGEST)0xffffffff;
 765   limit = ((limit << 16) << 16) | limit;
 766   if (c == 'l' || c == 'L')
 767     {
 768       type = java_long_type;
 769       len--;
 770     }
 771   else
 772     {
 773       type = java_int_type;
 774     }
 775   limit_div_base = limit / (ULONGEST) base;
 776
 777   while (--len >= 0)
 778     {
 779       c = *p++;
 780       if (c >= '0' && c <= '9')
 781         c -= '0';
 782       else if (c >= 'A' && c <= 'Z')
 783         c -= 'A' - 10;
 784       else if (c >= 'a' && c <= 'z')
 785         c -= 'a' - 10;
 786       else
 787         return ERROR;   /* Char not a digit */
 788       if (c >= base)
 789         return ERROR;
 790       if (n > limit_div_base
 791           || (n *= base) > limit - c)
 792         error (_("Numeric constant too large"));
 793       n += c;
 794         }
 795
 796   /* If the type is bigger than a 32-bit signed integer can be, implicitly
 797      promote to long.  Java does not do this, so mark it as builtin_type_uint64
 798      rather than java_long_type.  0x80000000 will become -0x80000000 instead
 799      of 0x80000000L, because we don't know the sign at this point.
 800   */
 801   if (type == java_int_type && n > (ULONGEST)0x80000000)
 802     type = builtin_type_uint64;
 803
 804   putithere->typed_val_int.val = n;
 805   putithere->typed_val_int.type = type;
 806
 807   return INTEGER_LITERAL;
 808 }
 809
 810 struct token
 811 {
 812   char *operator;
 813   int token;
 814   enum exp_opcode opcode;
 815 };
 816
 817 static const struct token tokentab3[] =
 818   {
 819     {">>=", ASSIGN_MODIFY, BINOP_RSH},
 820     {"<<=", ASSIGN_MODIFY, BINOP_LSH}
 821   };
 822
 823 static const struct token tokentab2[] =
 824   {
 825     {"+=", ASSIGN_MODIFY, BINOP_ADD},
 826     {"-=", ASSIGN_MODIFY, BINOP_SUB},
 827     {"*=", ASSIGN_MODIFY, BINOP_MUL},
 828     {"/=", ASSIGN_MODIFY, BINOP_DIV},
 829     {"%=", ASSIGN_MODIFY, BINOP_REM},
 830     {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR},
 831     {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND},
 832     {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR},
 833     {"++", INCREMENT, BINOP_END},
 834     {"--", DECREMENT, BINOP_END},
 835     {"&&", ANDAND, BINOP_END},
 836     {"||", OROR, BINOP_END},
 837     {"<<", LSH, BINOP_END},
 838     {">>", RSH, BINOP_END},
 839     {"==", EQUAL, BINOP_END},
 840     {"!=", NOTEQUAL, BINOP_END},
 841     {"<=", LEQ, BINOP_END},
 842     {">=", GEQ, BINOP_END}
 843   };
 844
 845 /* Read one token, getting characters through lexptr.  */
 846
 847 static int
 848 yylex (void)
 849 {
 850   int c;
 851   int namelen;
 852   unsigned int i;
 853   char *tokstart;
 854   char *tokptr;
 855   int tempbufindex;
 856   static char *tempbuf;
 857   static int tempbufsize;
 858
 859  retry:
 860
 861   prev_lexptr = lexptr;
 862
 863   tokstart = lexptr;
 864   /* See if it is a special token of length 3.  */
 865   for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
 866     if (strncmp (tokstart, tokentab3[i].operator, 3) == 0)
 867       {
 868         lexptr += 3;
 869         yylval.opcode = tokentab3[i].opcode;
 870         return tokentab3[i].token;
 871       }
 872
 873   /* See if it is a special token of length 2.  */
 874   for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
 875     if (strncmp (tokstart, tokentab2[i].operator, 2) == 0)
 876       {
 877         lexptr += 2;
 878         yylval.opcode = tokentab2[i].opcode;
 879         return tokentab2[i].token;
 880       }
 881
 882   switch (c = *tokstart)
 883     {
 884     case 0:
 885       return 0;
 886
 887     case ' ':
 888     case '\t':
 889     case '\n':
 890       lexptr++;
 891       goto retry;
 892
 893     case '\'':
 894       /* We either have a character constant ('0' or '\177' for example)
 895          or we have a quoted symbol reference ('foo(int,int)' in C++
 896          for example). */
 897       lexptr++;
 898       c = *lexptr++;
 899       if (c == '\\')
 900         c = parse_escape (&lexptr);
 901       else if (c == '\'')
 902         error (_("Empty character constant"));
 903
 904       yylval.typed_val_int.val = c;
 905       yylval.typed_val_int.type = java_char_type;
 906
 907       c = *lexptr++;
 908       if (c != '\'')
 909         {
 910           namelen = skip_quoted (tokstart) - tokstart;
 911           if (namelen > 2)
 912             {
 913               lexptr = tokstart + namelen;
 914               if (lexptr[-1] != '\'')
 915                 error (_("Unmatched single quote"));
 916               namelen -= 2;
 917               tokstart++;
 918               goto tryname;
 919             }
 920           error (_("Invalid character constant"));
 921         }
 922       return INTEGER_LITERAL;
 923
 924     case '(':
 925       paren_depth++;
 926       lexptr++;
 927       return c;
 928
 929     case ')':
 930       if (paren_depth == 0)
 931         return 0;
 932       paren_depth--;
 933       lexptr++;
 934       return c;
 935
 936     case ',':
 937       if (comma_terminates && paren_depth == 0)
 938         return 0;
 939       lexptr++;
 940       return c;
 941
 942     case '.':
 943       /* Might be a floating point number.  */
 944       if (lexptr[1] < '0' || lexptr[1] > '9')
 945         goto symbol;            /* Nope, must be a symbol. */
 946       /* FALL THRU into number case.  */
 947
 948     case '0':
 949     case '1':
 950     case '2':
 951     case '3':
 952     case '4':
 953     case '5':
 954     case '6':
 955     case '7':
 956     case '8':
 957     case '9':
 958       {
 959         /* It's a number.  */
 960         int got_dot = 0, got_e = 0, toktype;
 961         char *p = tokstart;
 962         int hex = input_radix > 10;
 963
 964         if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
 965           {
 966             p += 2;
 967             hex = 1;
 968           }
 969         else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
 970           {
 971             p += 2;
 972             hex = 0;
 973           }
 974
 975         for (;; ++p)
 976           {
 977             /* This test includes !hex because 'e' is a valid hex digit
 978                and thus does not indicate a floating point number when
 979                the radix is hex.  */
 980             if (!hex && !got_e && (*p == 'e' || *p == 'E'))
 981               got_dot = got_e = 1;
 982             /* This test does not include !hex, because a '.' always indicates
 983                a decimal floating point number regardless of the radix.  */
 984             else if (!got_dot && *p == '.')
 985               got_dot = 1;
 986             else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
 987                      && (*p == '-' || *p == '+'))
 988               /* This is the sign of the exponent, not the end of the
 989                  number.  */
 990               continue;
 991             /* We will take any letters or digits.  parse_number will
 992                complain if past the radix, or if L or U are not final.  */
 993             else if ((*p < '0' || *p > '9')
 994                      && ((*p < 'a' || *p > 'z')
 995                                   && (*p < 'A' || *p > 'Z')))
 996               break;
 997           }
 998         toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval);
 999         if (toktype == ERROR)
1000           {
1001             char *err_copy = (char *) alloca (p - tokstart + 1);
1002
1003             memcpy (err_copy, tokstart, p - tokstart);
1004             err_copy[p - tokstart] = 0;
1005             error (_("Invalid number \"%s\""), err_copy);
1006           }
1007         lexptr = p;
1008         return toktype;
1009       }
1010
1011     case '+':
1012     case '-':
1013     case '*':
1014     case '/':
1015     case '%':
1016     case '|':
1017     case '&':
1018     case '^':
1019     case '~':
1020     case '!':
1021     case '<':
1022     case '>':
1023     case '[':
1024     case ']':
1025     case '?':
1026     case ':':
1027     case '=':
1028     case '{':
1029     case '}':
1030     symbol:
1031       lexptr++;
1032       return c;
1033
1034     case '"':
1035
1036       /* Build the gdb internal form of the input string in tempbuf,
1037          translating any standard C escape forms seen.  Note that the
1038          buffer is null byte terminated *only* for the convenience of
1039          debugging gdb itself and printing the buffer contents when
1040          the buffer contains no embedded nulls.  Gdb does not depend
1041          upon the buffer being null byte terminated, it uses the length
1042          string instead.  This allows gdb to handle C strings (as well
1043          as strings in other languages) with embedded null bytes */
1044
1045       tokptr = ++tokstart;
1046       tempbufindex = 0;
1047
1048       do {
1049         /* Grow the static temp buffer if necessary, including allocating
1050            the first one on demand. */
1051         if (tempbufindex + 1 >= tempbufsize)
1052           {
1053             tempbuf = (char *) realloc (tempbuf, tempbufsize += 64);
1054           }
1055         switch (*tokptr)
1056           {
1057           case '\0':
1058           case '"':
1059             /* Do nothing, loop will terminate. */
1060             break;
1061           case '\\':
1062             tokptr++;
1063             c = parse_escape (&tokptr);
1064             if (c == -1)
1065               {
1066                 continue;
1067               }
1068             tempbuf[tempbufindex++] = c;
1069             break;
1070           default:
1071             tempbuf[tempbufindex++] = *tokptr++;
1072             break;
1073           }
1074       } while ((*tokptr != '"') && (*tokptr != '\0'));
1075       if (*tokptr++ != '"')
1076         {
1077           error (_("Unterminated string in expression"));
1078         }
1079       tempbuf[tempbufindex] = '\0';     /* See note above */
1080       yylval.sval.ptr = tempbuf;
1081       yylval.sval.length = tempbufindex;
1082       lexptr = tokptr;
1083       return (STRING_LITERAL);
1084     }
1085
1086   if (!(c == '_' || c == '$'
1087         || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
1088     /* We must have come across a bad character (e.g. ';').  */
1089     error (_("Invalid character '%c' in expression"), c);
1090
1091   /* It's a name.  See how long it is.  */
1092   namelen = 0;
1093   for (c = tokstart[namelen];
1094        (c == '_'
1095         || c == '$'
1096         || (c >= '0' && c <= '9')
1097         || (c >= 'a' && c <= 'z')
1098         || (c >= 'A' && c <= 'Z')
1099         || c == '<');
1100        )
1101     {
1102       if (c == '<')
1103         {
1104           int i = namelen;
1105           while (tokstart[++i] && tokstart[i] != '>');
1106           if (tokstart[i] == '>')
1107             namelen = i;
1108         }
1109        c = tokstart[++namelen];
1110      }
1111
1112   /* The token "if" terminates the expression and is NOT
1113      removed from the input stream.  */
1114   if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f')
1115     {
1116       return 0;
1117     }
1118
1119   lexptr += namelen;
1120
1121   tryname:
1122
1123   /* Catch specific keywords.  Should be done with a data structure.  */
1124   switch (namelen)
1125     {
1126     case 7:
1127       if (strncmp (tokstart, "boolean", 7) == 0)
1128         return BOOLEAN;
1129       break;
1130     case 6:
1131       if (strncmp (tokstart, "double", 6) == 0)
1132         return DOUBLE;
1133       break;
1134     case 5:
1135       if (strncmp (tokstart, "short", 5) == 0)
1136         return SHORT;
1137       if (strncmp (tokstart, "false", 5) == 0)
1138         {
1139           yylval.lval = 0;
1140           return BOOLEAN_LITERAL;
1141         }
1142       if (strncmp (tokstart, "super", 5) == 0)
1143         return SUPER;
1144       if (strncmp (tokstart, "float", 5) == 0)
1145         return FLOAT;
1146       break;
1147     case 4:
1148       if (strncmp (tokstart, "long", 4) == 0)
1149         return LONG;
1150       if (strncmp (tokstart, "byte", 4) == 0)
1151         return BYTE;
1152       if (strncmp (tokstart, "char", 4) == 0)
1153         return CHAR;
1154       if (strncmp (tokstart, "true", 4) == 0)
1155         {
1156           yylval.lval = 1;
1157           return BOOLEAN_LITERAL;
1158         }
1159       break;
1160     case 3:
1161       if (strncmp (tokstart, "int", 3) == 0)
1162         return INT;
1163       if (strncmp (tokstart, "new", 3) == 0)
1164         return NEW;
1165       break;
1166     default:
1167       break;
1168     }
1169
1170   yylval.sval.ptr = tokstart;
1171   yylval.sval.length = namelen;
1172
1173   if (*tokstart == '$')
1174     {
1175       write_dollar_variable (yylval.sval);
1176       return VARIABLE;
1177     }
1178
1179   /* Input names that aren't symbols but ARE valid hex numbers,
1180      when the input radix permits them, can be names or numbers
1181      depending on the parse.  Note we support radixes > 16 here.  */
1182   if (((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10) ||
1183        (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)))
1184     {
1185       YYSTYPE newlval;  /* Its value is ignored.  */
1186       int hextype = parse_number (tokstart, namelen, 0, &newlval);
1187       if (hextype == INTEGER_LITERAL)
1188         return NAME_OR_INT;
1189     }
1190   return IDENTIFIER;
1191 }
1192
1193 void
1194 yyerror (char *msg)
1195 {
1196   if (prev_lexptr)
1197     lexptr = prev_lexptr;
1198
1199   if (msg)
1200     error (_("%s: near `%s'"), msg, lexptr);
1201   else
1202     error (_("error in expression, near `%s'"), lexptr);
1203 }
1204
1205 static struct type *
1206 java_type_from_name (struct stoken name)
1207 {
1208   char *tmp = copy_name (name);
1209   struct type *typ = java_lookup_class (tmp);
1210   if (typ == NULL || TYPE_CODE (typ) != TYPE_CODE_STRUCT)
1211     error (_("No class named `%s'"), tmp);
1212   return typ;
1213 }
1214
1215 /* If NAME is a valid variable name in this scope, push it and return 1.
1216    Otherwise, return 0. */
1217
1218 static int
1219 push_variable (struct stoken name)
1220 {
1221   char *tmp = copy_name (name);
1222   int is_a_field_of_this = 0;
1223   struct symbol *sym;
1224   sym = lookup_symbol (tmp, expression_context_block, VAR_DOMAIN,
1225                        &is_a_field_of_this);
1226   if (sym && SYMBOL_CLASS (sym) != LOC_TYPEDEF)
1227     {
1228       if (symbol_read_needs_frame (sym))
1229         {
1230           if (innermost_block == 0 ||
1231               contained_in (block_found, innermost_block))
1232             innermost_block = block_found;
1233         }
1234
1235       write_exp_elt_opcode (OP_VAR_VALUE);
1236       /* We want to use the selected frame, not another more inner frame
1237          which happens to be in the same block.  */
1238       write_exp_elt_block (NULL);
1239       write_exp_elt_sym (sym);
1240       write_exp_elt_opcode (OP_VAR_VALUE);
1241       return 1;
1242     }
1243   if (is_a_field_of_this)
1244     {
1245       /* it hangs off of `this'.  Must not inadvertently convert from a
1246          method call to data ref.  */
1247       if (innermost_block == 0 ||
1248           contained_in (block_found, innermost_block))
1249         innermost_block = block_found;
1250       write_exp_elt_opcode (OP_THIS);
1251       write_exp_elt_opcode (OP_THIS);
1252       write_exp_elt_opcode (STRUCTOP_PTR);
1253       write_exp_string (name);
1254       write_exp_elt_opcode (STRUCTOP_PTR);
1255       return 1;
1256     }
1257   return 0;
1258 }
1259
1260 /* Assuming a reference expression has been pushed, emit the
1261    STRUCTOP_PTR ops to access the field named NAME.  If NAME is a
1262    qualified name (has '.'), generate a field access for each part. */
1263
1264 static void
1265 push_fieldnames (struct stoken name)
1266 {
1267   int i;
1268   struct stoken token;
1269   token.ptr = name.ptr;
1270   for (i = 0;  ;  i++)
1271     {
1272       if (i == name.length || name.ptr[i] == '.')
1273         {
1274           /* token.ptr is start of current field name. */
1275           token.length = &name.ptr[i] - token.ptr;
1276           write_exp_elt_opcode (STRUCTOP_PTR);
1277           write_exp_string (token);
1278           write_exp_elt_opcode (STRUCTOP_PTR);
1279           token.ptr += token.length + 1;
1280         }
1281       if (i >= name.length)
1282         break;
1283     }
1284 }
1285
1286 /* Helper routine for push_expression_name.
1287    Handle a qualified name, where DOT_INDEX is the index of the first '.' */
1288
1289 static void
1290 push_qualified_expression_name (struct stoken name, int dot_index)
1291 {
1292   struct stoken token;
1293   char *tmp;
1294   struct type *typ;
1295
1296   token.ptr = name.ptr;
1297   token.length = dot_index;
1298
1299   if (push_variable (token))
1300     {
1301       token.ptr = name.ptr + dot_index + 1;
1302       token.length = name.length - dot_index - 1;
1303       push_fieldnames (token);
1304       return;
1305     }
1306
1307   token.ptr = name.ptr;
1308   for (;;)
1309     {
1310       token.length = dot_index;
1311       tmp = copy_name (token);
1312       typ = java_lookup_class (tmp);
1313       if (typ != NULL)
1314         {
1315           if (dot_index == name.length)
1316             {
1317               write_exp_elt_opcode(OP_TYPE);
1318               write_exp_elt_type(typ);
1319               write_exp_elt_opcode(OP_TYPE);
1320               return;
1321             }
1322           dot_index++;  /* Skip '.' */
1323           name.ptr += dot_index;
1324           name.length -= dot_index;
1325           dot_index = 0;
1326           while (dot_index < name.length && name.ptr[dot_index] != '.')
1327             dot_index++;
1328           token.ptr = name.ptr;
1329           token.length = dot_index;
1330           write_exp_elt_opcode (OP_SCOPE);
1331           write_exp_elt_type (typ);
1332           write_exp_string (token);
1333           write_exp_elt_opcode (OP_SCOPE);
1334           if (dot_index < name.length)
1335             {
1336               dot_index++;
1337               name.ptr += dot_index;
1338               name.length -= dot_index;
1339               push_fieldnames (name);
1340             }
1341           return;
1342         }
1343       else if (dot_index >= name.length)
1344         break;
1345       dot_index++;  /* Skip '.' */
1346       while (dot_index < name.length && name.ptr[dot_index] != '.')
1347         dot_index++;
1348     }
1349   error (_("unknown type `%.*s'"), name.length, name.ptr);
1350 }
1351
1352 /* Handle Name in an expression (or LHS).
1353    Handle VAR, TYPE, TYPE.FIELD1....FIELDN and VAR.FIELD1....FIELDN. */
1354
1355 static void
1356 push_expression_name (struct stoken name)
1357 {
1358   char *tmp;
1359   struct type *typ;
1360   char *ptr;
1361   int i;
1362
1363   for (i = 0;  i < name.length;  i++)
1364     {
1365       if (name.ptr[i] == '.')
1366         {
1367           /* It's a Qualified Expression Name. */
1368           push_qualified_expression_name (name, i);
1369           return;
1370         }
1371     }
1372
1373   /* It's a Simple Expression Name. */
1374
1375   if (push_variable (name))
1376     return;
1377   tmp = copy_name (name);
1378   typ = java_lookup_class (tmp);
1379   if (typ != NULL)
1380     {
1381       write_exp_elt_opcode(OP_TYPE);
1382       write_exp_elt_type(typ);
1383       write_exp_elt_opcode(OP_TYPE);
1384     }
1385   else
1386     {
1387       struct minimal_symbol *msymbol;
1388
1389       msymbol = lookup_minimal_symbol (tmp, NULL, NULL);
1390       if (msymbol != NULL)
1391         write_exp_msymbol (msymbol);
1392       else if (!have_full_symbols () && !have_partial_symbols ())
1393         error (_("No symbol table is loaded.  Use the \"file\" command"));
1394       else
1395         error (_("No symbol \"%s\" in current context"), tmp);
1396     }
1397
1398 }
1399
1400
1401 /* The following two routines, copy_exp and insert_exp, aren't specific to
1402    Java, so they could go in parse.c, but their only purpose is to support
1403    the parsing kludges we use in this file, so maybe it's best to isolate
1404    them here.  */
1405
1406 /* Copy the expression whose last element is at index ENDPOS - 1 in EXPR
1407    into a freshly malloc'ed struct expression.  Its language_defn is set
1408    to null.  */
1409 static struct expression *
1410 copy_exp (struct expression *expr, int endpos)
1411 {
1412   int len = length_of_subexp (expr, endpos);
1413   struct expression *new
1414     = (struct expression *) malloc (sizeof (*new) + EXP_ELEM_TO_BYTES (len));
1415   new->nelts = len;
1416   memcpy (new->elts, expr->elts + endpos - len, EXP_ELEM_TO_BYTES (len));
1417   new->language_defn = 0;
1418
1419   return new;
1420 }
1421
1422 /* Insert the expression NEW into the current expression (expout) at POS.  */
1423 static void
1424 insert_exp (int pos, struct expression *new)
1425 {
1426   int newlen = new->nelts;
1427
1428   /* Grow expout if necessary.  In this function's only use at present,
1429      this should never be necessary.  */
1430   if (expout_ptr + newlen > expout_size)
1431     {
1432       expout_size = max (expout_size * 2, expout_ptr + newlen + 10);
1433       expout = (struct expression *)
1434         realloc ((char *) expout, (sizeof (struct expression)
1435                                     + EXP_ELEM_TO_BYTES (expout_size)));
1436     }
1437
1438   {
1439     int i;
1440
1441     for (i = expout_ptr - 1; i >= pos; i--)
1442       expout->elts[i + newlen] = expout->elts[i];
1443   }
1444
1445   memcpy (expout->elts + pos, new->elts, EXP_ELEM_TO_BYTES (newlen));
1446   expout_ptr += newlen;
1447 }