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