gdb/jv-exp.y

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