gdb/jv-exp.y

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