contrib/gdb-6.2.1/gdb/jv-exp.y

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