1 /* YACC parser for Java expressions, for GDB. 2 Copyright (C) 1997, 1998, 1999, 2000, 2006, 2007, 2008, 2009 3 Free Software Foundation, Inc. 4 5 This file is part of GDB. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 19 20 /* Parse a Java expression from text in a string, 21 and return the result as a struct expression pointer. 22 That structure contains arithmetic operations in reverse polish, 23 with constants represented by operations that are followed by special data. 24 See expression.h for the details of the format. 25 What is important here is that it can be built up sequentially 26 during the process of parsing; the lower levels of the tree always 27 come first in the result. Well, almost always; see ArrayAccess. 28 29 Note that malloc's and realloc's in this file are transformed to 30 xmalloc and xrealloc respectively by the same sed command in the 31 makefile that remaps any other malloc/realloc inserted by the parser 32 generator. Doing this with #defines and trying to control the interaction 33 with include files (<malloc.h> and <stdlib.h> for example) just became 34 too messy, particularly when such includes can be inserted at random 35 times by the parser generator. */ 36 37 %{ 38 39 #include "defs.h" 40 #include "gdb_string.h" 41 #include <ctype.h> 42 #include "expression.h" 43 #include "value.h" 44 #include "parser-defs.h" 45 #include "language.h" 46 #include "jv-lang.h" 47 #include "bfd.h" /* Required by objfiles.h. */ 48 #include "symfile.h" /* Required by objfiles.h. */ 49 #include "objfiles.h" /* For have_full_symbols and have_partial_symbols */ 50 #include "block.h" 51 52 #define parse_type builtin_type (parse_gdbarch) 53 #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 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 exp_size = expout_ptr; 551 int last_exp_size = length_of_subexp(expout, expout_ptr); 552 struct type *type; 553 int i; 554 int base = expout_ptr - last_exp_size - 3; 555 if (base < 0 || expout->elts[base+2].opcode != OP_TYPE) 556 error (_("Invalid cast expression")); 557 type = expout->elts[base+1].type; 558 /* Remove the 'Expression' and slide the 559 UnaryExpressionNotPlusMinus down to replace it. */ 560 for (i = 0; i < last_exp_size; i++) 561 expout->elts[base + i] = expout->elts[base + i + 3]; 562 expout_ptr -= 3; 563 if (TYPE_CODE (type) == TYPE_CODE_STRUCT) 564 type = lookup_pointer_type (type); 565 write_exp_elt_opcode (UNOP_CAST); 566 write_exp_elt_type (type); 567 write_exp_elt_opcode (UNOP_CAST); 568 } 569 | '(' Name Dims ')' UnaryExpressionNotPlusMinus 570 { write_exp_elt_opcode (UNOP_CAST); 571 write_exp_elt_type (java_array_type (java_type_from_name ($2), $3)); 572 write_exp_elt_opcode (UNOP_CAST); } 573 ; 574 575 576 MultiplicativeExpression: 577 UnaryExpression 578 | MultiplicativeExpression '*' UnaryExpression 579 { write_exp_elt_opcode (BINOP_MUL); } 580 | MultiplicativeExpression '/' UnaryExpression 581 { write_exp_elt_opcode (BINOP_DIV); } 582 | MultiplicativeExpression '%' UnaryExpression 583 { write_exp_elt_opcode (BINOP_REM); } 584 ; 585 586 AdditiveExpression: 587 MultiplicativeExpression 588 | AdditiveExpression '+' MultiplicativeExpression 589 { write_exp_elt_opcode (BINOP_ADD); } 590 | AdditiveExpression '-' MultiplicativeExpression 591 { write_exp_elt_opcode (BINOP_SUB); } 592 ; 593 594 ShiftExpression: 595 AdditiveExpression 596 | ShiftExpression LSH AdditiveExpression 597 { write_exp_elt_opcode (BINOP_LSH); } 598 | ShiftExpression RSH AdditiveExpression 599 { write_exp_elt_opcode (BINOP_RSH); } 600 /* | ShiftExpression >>> AdditiveExpression { FIXME } */ 601 ; 602 603 RelationalExpression: 604 ShiftExpression 605 | RelationalExpression '<' ShiftExpression 606 { write_exp_elt_opcode (BINOP_LESS); } 607 | RelationalExpression '>' ShiftExpression 608 { write_exp_elt_opcode (BINOP_GTR); } 609 | RelationalExpression LEQ ShiftExpression 610 { write_exp_elt_opcode (BINOP_LEQ); } 611 | RelationalExpression GEQ ShiftExpression 612 { write_exp_elt_opcode (BINOP_GEQ); } 613 /* | RelationalExpresion INSTANCEOF ReferenceType { FIXME } */ 614 ; 615 616 EqualityExpression: 617 RelationalExpression 618 | EqualityExpression EQUAL RelationalExpression 619 { write_exp_elt_opcode (BINOP_EQUAL); } 620 | EqualityExpression NOTEQUAL RelationalExpression 621 { write_exp_elt_opcode (BINOP_NOTEQUAL); } 622 ; 623 624 AndExpression: 625 EqualityExpression 626 | AndExpression '&' EqualityExpression 627 { write_exp_elt_opcode (BINOP_BITWISE_AND); } 628 ; 629 630 ExclusiveOrExpression: 631 AndExpression 632 | ExclusiveOrExpression '^' AndExpression 633 { write_exp_elt_opcode (BINOP_BITWISE_XOR); } 634 ; 635 InclusiveOrExpression: 636 ExclusiveOrExpression 637 | InclusiveOrExpression '|' ExclusiveOrExpression 638 { write_exp_elt_opcode (BINOP_BITWISE_IOR); } 639 ; 640 641 ConditionalAndExpression: 642 InclusiveOrExpression 643 | ConditionalAndExpression ANDAND InclusiveOrExpression 644 { write_exp_elt_opcode (BINOP_LOGICAL_AND); } 645 ; 646 647 ConditionalOrExpression: 648 ConditionalAndExpression 649 | ConditionalOrExpression OROR ConditionalAndExpression 650 { write_exp_elt_opcode (BINOP_LOGICAL_OR); } 651 ; 652 653 ConditionalExpression: 654 ConditionalOrExpression 655 | ConditionalOrExpression '?' Expression ':' ConditionalExpression 656 { write_exp_elt_opcode (TERNOP_COND); } 657 ; 658 659 AssignmentExpression: 660 ConditionalExpression 661 | Assignment 662 ; 663 664 Assignment: 665 LeftHandSide '=' ConditionalExpression 666 { write_exp_elt_opcode (BINOP_ASSIGN); } 667 | LeftHandSide ASSIGN_MODIFY ConditionalExpression 668 { write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); 669 write_exp_elt_opcode ($2); 670 write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); } 671 ; 672 673 LeftHandSide: 674 ForcedName 675 { push_expression_name ($1); } 676 | VARIABLE 677 /* Already written by write_dollar_variable. */ 678 | FieldAccess 679 | ArrayAccess 680 ; 681 682 683 Expression: 684 AssignmentExpression 685 ; 686 687 %% 688 /* Take care of parsing a number (anything that starts with a digit). 689 Set yylval and return the token type; update lexptr. 690 LEN is the number of characters in it. */ 691 692 /*** Needs some error checking for the float case ***/ 693 694 static int 695 parse_number (char *p, int len, int parsed_float, YYSTYPE *putithere) 696 { 697 ULONGEST n = 0; 698 ULONGEST limit, limit_div_base; 699 700 int c; 701 int base = input_radix; 702 703 struct type *type; 704 705 if (parsed_float) 706 { 707 /* It's a float since it contains a point or an exponent. */ 708 char c; 709 int num = 0; /* number of tokens scanned by scanf */ 710 char saved_char = p[len]; 711 712 p[len] = 0; /* null-terminate the token */ 713 num = sscanf (p, "%" DOUBLEST_SCAN_FORMAT "%c", 714 &putithere->typed_val_float.dval, &c); 715 p[len] = saved_char; /* restore the input stream */ 716 if (num != 1) /* check scanf found ONLY a float ... */ 717 return ERROR; 718 /* See if it has `f' or `d' suffix (float or double). */ 719 720 c = tolower (p[len - 1]); 721 722 if (c == 'f' || c == 'F') 723 putithere->typed_val_float.type = parse_type->builtin_float; 724 else if (isdigit (c) || c == '.' || c == 'd' || c == 'D') 725 putithere->typed_val_float.type = parse_type->builtin_double; 726 else 727 return ERROR; 728 729 return FLOATING_POINT_LITERAL; 730 } 731 732 /* Handle base-switching prefixes 0x, 0t, 0d, 0 */ 733 if (p[0] == '0') 734 switch (p[1]) 735 { 736 case 'x': 737 case 'X': 738 if (len >= 3) 739 { 740 p += 2; 741 base = 16; 742 len -= 2; 743 } 744 break; 745 746 case 't': 747 case 'T': 748 case 'd': 749 case 'D': 750 if (len >= 3) 751 { 752 p += 2; 753 base = 10; 754 len -= 2; 755 } 756 break; 757 758 default: 759 base = 8; 760 break; 761 } 762 763 c = p[len-1]; 764 /* A paranoid calculation of (1<<64)-1. */ 765 limit = (ULONGEST)0xffffffff; 766 limit = ((limit << 16) << 16) | limit; 767 if (c == 'l' || c == 'L') 768 { 769 type = parse_java_type->builtin_long; 770 len--; 771 } 772 else 773 { 774 type = parse_java_type->builtin_int; 775 } 776 limit_div_base = limit / (ULONGEST) base; 777 778 while (--len >= 0) 779 { 780 c = *p++; 781 if (c >= '0' && c <= '9') 782 c -= '0'; 783 else if (c >= 'A' && c <= 'Z') 784 c -= 'A' - 10; 785 else if (c >= 'a' && c <= 'z') 786 c -= 'a' - 10; 787 else 788 return ERROR; /* Char not a digit */ 789 if (c >= base) 790 return ERROR; 791 if (n > limit_div_base 792 || (n *= base) > limit - c) 793 error (_("Numeric constant too large")); 794 n += c; 795 } 796 797 /* If the type is bigger than a 32-bit signed integer can be, implicitly 798 promote to long. Java does not do this, so mark it as 799 parse_type->builtin_uint64 rather than parse_java_type->builtin_long. 800 0x80000000 will become -0x80000000 instead of 0x80000000L, because we 801 don't know the sign at this point. */ 802 if (type == parse_java_type->builtin_int && n > (ULONGEST)0x80000000) 803 type = parse_type->builtin_uint64; 804 805 putithere->typed_val_int.val = n; 806 putithere->typed_val_int.type = type; 807 808 return INTEGER_LITERAL; 809 } 810 811 struct token 812 { 813 char *operator; 814 int token; 815 enum exp_opcode opcode; 816 }; 817 818 static const struct token tokentab3[] = 819 { 820 {">>=", ASSIGN_MODIFY, BINOP_RSH}, 821 {"<<=", ASSIGN_MODIFY, BINOP_LSH} 822 }; 823 824 static const struct token tokentab2[] = 825 { 826 {"+=", ASSIGN_MODIFY, BINOP_ADD}, 827 {"-=", ASSIGN_MODIFY, BINOP_SUB}, 828 {"*=", ASSIGN_MODIFY, BINOP_MUL}, 829 {"/=", ASSIGN_MODIFY, BINOP_DIV}, 830 {"%=", ASSIGN_MODIFY, BINOP_REM}, 831 {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR}, 832 {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND}, 833 {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR}, 834 {"++", INCREMENT, BINOP_END}, 835 {"--", DECREMENT, BINOP_END}, 836 {"&&", ANDAND, BINOP_END}, 837 {"||", OROR, BINOP_END}, 838 {"<<", LSH, BINOP_END}, 839 {">>", RSH, BINOP_END}, 840 {"==", EQUAL, BINOP_END}, 841 {"!=", NOTEQUAL, BINOP_END}, 842 {"<=", LEQ, BINOP_END}, 843 {">=", GEQ, BINOP_END} 844 }; 845 846 /* Read one token, getting characters through lexptr. */ 847 848 static int 849 yylex (void) 850 { 851 int c; 852 int namelen; 853 unsigned int i; 854 char *tokstart; 855 char *tokptr; 856 int tempbufindex; 857 static char *tempbuf; 858 static int tempbufsize; 859 860 retry: 861 862 prev_lexptr = lexptr; 863 864 tokstart = lexptr; 865 /* See if it is a special token of length 3. */ 866 for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++) 867 if (strncmp (tokstart, tokentab3[i].operator, 3) == 0) 868 { 869 lexptr += 3; 870 yylval.opcode = tokentab3[i].opcode; 871 return tokentab3[i].token; 872 } 873 874 /* See if it is a special token of length 2. */ 875 for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++) 876 if (strncmp (tokstart, tokentab2[i].operator, 2) == 0) 877 { 878 lexptr += 2; 879 yylval.opcode = tokentab2[i].opcode; 880 return tokentab2[i].token; 881 } 882 883 switch (c = *tokstart) 884 { 885 case 0: 886 return 0; 887 888 case ' ': 889 case '\t': 890 case '\n': 891 lexptr++; 892 goto retry; 893 894 case '\'': 895 /* We either have a character constant ('0' or '\177' for example) 896 or we have a quoted symbol reference ('foo(int,int)' in C++ 897 for example). */ 898 lexptr++; 899 c = *lexptr++; 900 if (c == '\\') 901 c = parse_escape (&lexptr); 902 else if (c == '\'') 903 error (_("Empty character constant")); 904 905 yylval.typed_val_int.val = c; 906 yylval.typed_val_int.type = parse_java_type->builtin_char; 907 908 c = *lexptr++; 909 if (c != '\'') 910 { 911 namelen = skip_quoted (tokstart) - tokstart; 912 if (namelen > 2) 913 { 914 lexptr = tokstart + namelen; 915 if (lexptr[-1] != '\'') 916 error (_("Unmatched single quote")); 917 namelen -= 2; 918 tokstart++; 919 goto tryname; 920 } 921 error (_("Invalid character constant")); 922 } 923 return INTEGER_LITERAL; 924 925 case '(': 926 paren_depth++; 927 lexptr++; 928 return c; 929 930 case ')': 931 if (paren_depth == 0) 932 return 0; 933 paren_depth--; 934 lexptr++; 935 return c; 936 937 case ',': 938 if (comma_terminates && paren_depth == 0) 939 return 0; 940 lexptr++; 941 return c; 942 943 case '.': 944 /* Might be a floating point number. */ 945 if (lexptr[1] < '0' || lexptr[1] > '9') 946 goto symbol; /* Nope, must be a symbol. */ 947 /* FALL THRU into number case. */ 948 949 case '0': 950 case '1': 951 case '2': 952 case '3': 953 case '4': 954 case '5': 955 case '6': 956 case '7': 957 case '8': 958 case '9': 959 { 960 /* It's a number. */ 961 int got_dot = 0, got_e = 0, toktype; 962 char *p = tokstart; 963 int hex = input_radix > 10; 964 965 if (c == '0' && (p[1] == 'x' || p[1] == 'X')) 966 { 967 p += 2; 968 hex = 1; 969 } 970 else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D')) 971 { 972 p += 2; 973 hex = 0; 974 } 975 976 for (;; ++p) 977 { 978 /* This test includes !hex because 'e' is a valid hex digit 979 and thus does not indicate a floating point number when 980 the radix is hex. */ 981 if (!hex && !got_e && (*p == 'e' || *p == 'E')) 982 got_dot = got_e = 1; 983 /* This test does not include !hex, because a '.' always indicates 984 a decimal floating point number regardless of the radix. */ 985 else if (!got_dot && *p == '.') 986 got_dot = 1; 987 else if (got_e && (p[-1] == 'e' || p[-1] == 'E') 988 && (*p == '-' || *p == '+')) 989 /* This is the sign of the exponent, not the end of the 990 number. */ 991 continue; 992 /* We will take any letters or digits. parse_number will 993 complain if past the radix, or if L or U are not final. */ 994 else if ((*p < '0' || *p > '9') 995 && ((*p < 'a' || *p > 'z') 996 && (*p < 'A' || *p > 'Z'))) 997 break; 998 } 999 toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval); 1000 if (toktype == ERROR) 1001 { 1002 char *err_copy = (char *) alloca (p - tokstart + 1); 1003 1004 memcpy (err_copy, tokstart, p - tokstart); 1005 err_copy[p - tokstart] = 0; 1006 error (_("Invalid number \"%s\""), err_copy); 1007 } 1008 lexptr = p; 1009 return toktype; 1010 } 1011 1012 case '+': 1013 case '-': 1014 case '*': 1015 case '/': 1016 case '%': 1017 case '|': 1018 case '&': 1019 case '^': 1020 case '~': 1021 case '!': 1022 case '<': 1023 case '>': 1024 case '[': 1025 case ']': 1026 case '?': 1027 case ':': 1028 case '=': 1029 case '{': 1030 case '}': 1031 symbol: 1032 lexptr++; 1033 return c; 1034 1035 case '"': 1036 1037 /* Build the gdb internal form of the input string in tempbuf, 1038 translating any standard C escape forms seen. Note that the 1039 buffer is null byte terminated *only* for the convenience of 1040 debugging gdb itself and printing the buffer contents when 1041 the buffer contains no embedded nulls. Gdb does not depend 1042 upon the buffer being null byte terminated, it uses the length 1043 string instead. This allows gdb to handle C strings (as well 1044 as strings in other languages) with embedded null bytes */ 1045 1046 tokptr = ++tokstart; 1047 tempbufindex = 0; 1048 1049 do { 1050 /* Grow the static temp buffer if necessary, including allocating 1051 the first one on demand. */ 1052 if (tempbufindex + 1 >= tempbufsize) 1053 { 1054 tempbuf = (char *) realloc (tempbuf, tempbufsize += 64); 1055 } 1056 switch (*tokptr) 1057 { 1058 case '\0': 1059 case '"': 1060 /* Do nothing, loop will terminate. */ 1061 break; 1062 case '\\': 1063 tokptr++; 1064 c = parse_escape (&tokptr); 1065 if (c == -1) 1066 { 1067 continue; 1068 } 1069 tempbuf[tempbufindex++] = c; 1070 break; 1071 default: 1072 tempbuf[tempbufindex++] = *tokptr++; 1073 break; 1074 } 1075 } while ((*tokptr != '"') && (*tokptr != '\0')); 1076 if (*tokptr++ != '"') 1077 { 1078 error (_("Unterminated string in expression")); 1079 } 1080 tempbuf[tempbufindex] = '\0'; /* See note above */ 1081 yylval.sval.ptr = tempbuf; 1082 yylval.sval.length = tempbufindex; 1083 lexptr = tokptr; 1084 return (STRING_LITERAL); 1085 } 1086 1087 if (!(c == '_' || c == '$' 1088 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))) 1089 /* We must have come across a bad character (e.g. ';'). */ 1090 error (_("Invalid character '%c' in expression"), c); 1091 1092 /* It's a name. See how long it is. */ 1093 namelen = 0; 1094 for (c = tokstart[namelen]; 1095 (c == '_' 1096 || c == '$' 1097 || (c >= '0' && c <= '9') 1098 || (c >= 'a' && c <= 'z') 1099 || (c >= 'A' && c <= 'Z') 1100 || c == '<'); 1101 ) 1102 { 1103 if (c == '<') 1104 { 1105 int i = namelen; 1106 while (tokstart[++i] && tokstart[i] != '>'); 1107 if (tokstart[i] == '>') 1108 namelen = i; 1109 } 1110 c = tokstart[++namelen]; 1111 } 1112 1113 /* The token "if" terminates the expression and is NOT 1114 removed from the input stream. */ 1115 if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f') 1116 { 1117 return 0; 1118 } 1119 1120 lexptr += namelen; 1121 1122 tryname: 1123 1124 /* Catch specific keywords. Should be done with a data structure. */ 1125 switch (namelen) 1126 { 1127 case 7: 1128 if (strncmp (tokstart, "boolean", 7) == 0) 1129 return BOOLEAN; 1130 break; 1131 case 6: 1132 if (strncmp (tokstart, "double", 6) == 0) 1133 return DOUBLE; 1134 break; 1135 case 5: 1136 if (strncmp (tokstart, "short", 5) == 0) 1137 return SHORT; 1138 if (strncmp (tokstart, "false", 5) == 0) 1139 { 1140 yylval.lval = 0; 1141 return BOOLEAN_LITERAL; 1142 } 1143 if (strncmp (tokstart, "super", 5) == 0) 1144 return SUPER; 1145 if (strncmp (tokstart, "float", 5) == 0) 1146 return FLOAT; 1147 break; 1148 case 4: 1149 if (strncmp (tokstart, "long", 4) == 0) 1150 return LONG; 1151 if (strncmp (tokstart, "byte", 4) == 0) 1152 return BYTE; 1153 if (strncmp (tokstart, "char", 4) == 0) 1154 return CHAR; 1155 if (strncmp (tokstart, "true", 4) == 0) 1156 { 1157 yylval.lval = 1; 1158 return BOOLEAN_LITERAL; 1159 } 1160 break; 1161 case 3: 1162 if (strncmp (tokstart, "int", 3) == 0) 1163 return INT; 1164 if (strncmp (tokstart, "new", 3) == 0) 1165 return NEW; 1166 break; 1167 default: 1168 break; 1169 } 1170 1171 yylval.sval.ptr = tokstart; 1172 yylval.sval.length = namelen; 1173 1174 if (*tokstart == '$') 1175 { 1176 write_dollar_variable (yylval.sval); 1177 return VARIABLE; 1178 } 1179 1180 /* Input names that aren't symbols but ARE valid hex numbers, 1181 when the input radix permits them, can be names or numbers 1182 depending on the parse. Note we support radixes > 16 here. */ 1183 if (((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10) || 1184 (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10))) 1185 { 1186 YYSTYPE newlval; /* Its value is ignored. */ 1187 int hextype = parse_number (tokstart, namelen, 0, &newlval); 1188 if (hextype == INTEGER_LITERAL) 1189 return NAME_OR_INT; 1190 } 1191 return IDENTIFIER; 1192 } 1193 1194 void 1195 yyerror (char *msg) 1196 { 1197 if (prev_lexptr) 1198 lexptr = prev_lexptr; 1199 1200 if (msg) 1201 error (_("%s: near `%s'"), msg, lexptr); 1202 else 1203 error (_("error in expression, near `%s'"), lexptr); 1204 } 1205 1206 static struct type * 1207 java_type_from_name (struct stoken name) 1208 { 1209 char *tmp = copy_name (name); 1210 struct type *typ = java_lookup_class (tmp); 1211 if (typ == NULL || TYPE_CODE (typ) != TYPE_CODE_STRUCT) 1212 error (_("No class named `%s'"), tmp); 1213 return typ; 1214 } 1215 1216 /* If NAME is a valid variable name in this scope, push it and return 1. 1217 Otherwise, return 0. */ 1218 1219 static int 1220 push_variable (struct stoken name) 1221 { 1222 char *tmp = copy_name (name); 1223 int is_a_field_of_this = 0; 1224 struct symbol *sym; 1225 sym = lookup_symbol (tmp, expression_context_block, VAR_DOMAIN, 1226 &is_a_field_of_this); 1227 if (sym && SYMBOL_CLASS (sym) != LOC_TYPEDEF) 1228 { 1229 if (symbol_read_needs_frame (sym)) 1230 { 1231 if (innermost_block == 0 || 1232 contained_in (block_found, innermost_block)) 1233 innermost_block = block_found; 1234 } 1235 1236 write_exp_elt_opcode (OP_VAR_VALUE); 1237 /* We want to use the selected frame, not another more inner frame 1238 which happens to be in the same block. */ 1239 write_exp_elt_block (NULL); 1240 write_exp_elt_sym (sym); 1241 write_exp_elt_opcode (OP_VAR_VALUE); 1242 return 1; 1243 } 1244 if (is_a_field_of_this) 1245 { 1246 /* it hangs off of `this'. Must not inadvertently convert from a 1247 method call to data ref. */ 1248 if (innermost_block == 0 || 1249 contained_in (block_found, innermost_block)) 1250 innermost_block = block_found; 1251 write_exp_elt_opcode (OP_THIS); 1252 write_exp_elt_opcode (OP_THIS); 1253 write_exp_elt_opcode (STRUCTOP_PTR); 1254 write_exp_string (name); 1255 write_exp_elt_opcode (STRUCTOP_PTR); 1256 return 1; 1257 } 1258 return 0; 1259 } 1260 1261 /* Assuming a reference expression has been pushed, emit the 1262 STRUCTOP_PTR ops to access the field named NAME. If NAME is a 1263 qualified name (has '.'), generate a field access for each part. */ 1264 1265 static void 1266 push_fieldnames (struct stoken name) 1267 { 1268 int i; 1269 struct stoken token; 1270 token.ptr = name.ptr; 1271 for (i = 0; ; i++) 1272 { 1273 if (i == name.length || name.ptr[i] == '.') 1274 { 1275 /* token.ptr is start of current field name. */ 1276 token.length = &name.ptr[i] - token.ptr; 1277 write_exp_elt_opcode (STRUCTOP_PTR); 1278 write_exp_string (token); 1279 write_exp_elt_opcode (STRUCTOP_PTR); 1280 token.ptr += token.length + 1; 1281 } 1282 if (i >= name.length) 1283 break; 1284 } 1285 } 1286 1287 /* Helper routine for push_expression_name. 1288 Handle a qualified name, where DOT_INDEX is the index of the first '.' */ 1289 1290 static void 1291 push_qualified_expression_name (struct stoken name, int dot_index) 1292 { 1293 struct stoken token; 1294 char *tmp; 1295 struct type *typ; 1296 1297 token.ptr = name.ptr; 1298 token.length = dot_index; 1299 1300 if (push_variable (token)) 1301 { 1302 token.ptr = name.ptr + dot_index + 1; 1303 token.length = name.length - dot_index - 1; 1304 push_fieldnames (token); 1305 return; 1306 } 1307 1308 token.ptr = name.ptr; 1309 for (;;) 1310 { 1311 token.length = dot_index; 1312 tmp = copy_name (token); 1313 typ = java_lookup_class (tmp); 1314 if (typ != NULL) 1315 { 1316 if (dot_index == name.length) 1317 { 1318 write_exp_elt_opcode(OP_TYPE); 1319 write_exp_elt_type(typ); 1320 write_exp_elt_opcode(OP_TYPE); 1321 return; 1322 } 1323 dot_index++; /* Skip '.' */ 1324 name.ptr += dot_index; 1325 name.length -= dot_index; 1326 dot_index = 0; 1327 while (dot_index < name.length && name.ptr[dot_index] != '.') 1328 dot_index++; 1329 token.ptr = name.ptr; 1330 token.length = dot_index; 1331 write_exp_elt_opcode (OP_SCOPE); 1332 write_exp_elt_type (typ); 1333 write_exp_string (token); 1334 write_exp_elt_opcode (OP_SCOPE); 1335 if (dot_index < name.length) 1336 { 1337 dot_index++; 1338 name.ptr += dot_index; 1339 name.length -= dot_index; 1340 push_fieldnames (name); 1341 } 1342 return; 1343 } 1344 else if (dot_index >= name.length) 1345 break; 1346 dot_index++; /* Skip '.' */ 1347 while (dot_index < name.length && name.ptr[dot_index] != '.') 1348 dot_index++; 1349 } 1350 error (_("unknown type `%.*s'"), name.length, name.ptr); 1351 } 1352 1353 /* Handle Name in an expression (or LHS). 1354 Handle VAR, TYPE, TYPE.FIELD1....FIELDN and VAR.FIELD1....FIELDN. */ 1355 1356 static void 1357 push_expression_name (struct stoken name) 1358 { 1359 char *tmp; 1360 struct type *typ; 1361 char *ptr; 1362 int i; 1363 1364 for (i = 0; i < name.length; i++) 1365 { 1366 if (name.ptr[i] == '.') 1367 { 1368 /* It's a Qualified Expression Name. */ 1369 push_qualified_expression_name (name, i); 1370 return; 1371 } 1372 } 1373 1374 /* It's a Simple Expression Name. */ 1375 1376 if (push_variable (name)) 1377 return; 1378 tmp = copy_name (name); 1379 typ = java_lookup_class (tmp); 1380 if (typ != NULL) 1381 { 1382 write_exp_elt_opcode(OP_TYPE); 1383 write_exp_elt_type(typ); 1384 write_exp_elt_opcode(OP_TYPE); 1385 } 1386 else 1387 { 1388 struct minimal_symbol *msymbol; 1389 1390 msymbol = lookup_minimal_symbol (tmp, NULL, NULL); 1391 if (msymbol != NULL) 1392 write_exp_msymbol (msymbol); 1393 else if (!have_full_symbols () && !have_partial_symbols ()) 1394 error (_("No symbol table is loaded. Use the \"file\" command")); 1395 else 1396 error (_("No symbol \"%s\" in current context"), tmp); 1397 } 1398 1399 } 1400 1401 1402 /* The following two routines, copy_exp and insert_exp, aren't specific to 1403 Java, so they could go in parse.c, but their only purpose is to support 1404 the parsing kludges we use in this file, so maybe it's best to isolate 1405 them here. */ 1406 1407 /* Copy the expression whose last element is at index ENDPOS - 1 in EXPR 1408 into a freshly malloc'ed struct expression. Its language_defn is set 1409 to null. */ 1410 static struct expression * 1411 copy_exp (struct expression *expr, int endpos) 1412 { 1413 int len = length_of_subexp (expr, endpos); 1414 struct expression *new 1415 = (struct expression *) malloc (sizeof (*new) + EXP_ELEM_TO_BYTES (len)); 1416 new->nelts = len; 1417 memcpy (new->elts, expr->elts + endpos - len, EXP_ELEM_TO_BYTES (len)); 1418 new->language_defn = 0; 1419 1420 return new; 1421 } 1422 1423 /* Insert the expression NEW into the current expression (expout) at POS. */ 1424 static void 1425 insert_exp (int pos, struct expression *new) 1426 { 1427 int newlen = new->nelts; 1428 1429 /* Grow expout if necessary. In this function's only use at present, 1430 this should never be necessary. */ 1431 if (expout_ptr + newlen > expout_size) 1432 { 1433 expout_size = max (expout_size * 2, expout_ptr + newlen + 10); 1434 expout = (struct expression *) 1435 realloc ((char *) expout, (sizeof (struct expression) 1436 + EXP_ELEM_TO_BYTES (expout_size))); 1437 } 1438 1439 { 1440 int i; 1441 1442 for (i = expout_ptr - 1; i >= pos; i--) 1443 expout->elts[i + newlen] = expout->elts[i]; 1444 } 1445 1446 memcpy (expout->elts + pos, new->elts, EXP_ELEM_TO_BYTES (newlen)); 1447 expout_ptr += newlen; 1448 } 1449