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