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