1/* A Bison parser, made by GNU Bison 1.875c. */ 2 3/* Skeleton parser for Yacc-like parsing with Bison, 4 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003 Free Software Foundation, Inc. 5 6 This program is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 2, or (at your option) 9 any later version. 10 11 This program is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program; if not, write to the Free Software 18 Foundation, Inc., 59 Temple Place - Suite 330, 19 Boston, MA 02111-1307, USA. */ 20 21/* As a special exception, when this file is copied by Bison into a 22 Bison output file, you may use that output file without restriction. 23 This special exception was added by the Free Software Foundation 24 in version 1.24 of Bison. */ 25 26/* Written by Richard Stallman by simplifying the original so called 27 ``semantic'' parser. */ 28 29/* All symbols defined below should begin with yy or YY, to avoid 30 infringing on user name space. This should be done even for local 31 variables, as they might otherwise be expanded by user macros. 32 There are some unavoidable exceptions within include files to 33 define necessary library symbols; they are noted "INFRINGES ON 34 USER NAME SPACE" below. */ 35 36/* Identify Bison output. */ 37#define YYBISON 1 38 39/* Skeleton name. */ 40#define YYSKELETON_NAME "yacc.c" 41 42/* Pure parsers. */ 43#define YYPURE 0 44 45/* Using locations. */ 46#define YYLSP_NEEDED 0 47 48 49 50/* Tokens. */ 51#ifndef YYTOKENTYPE 52# define YYTOKENTYPE 53 /* Put the tokens into the symbol table, so that GDB and other debuggers 54 know about them. */ 55 enum yytokentype { 56 INTEGER_LITERAL = 258, 57 FLOATING_POINT_LITERAL = 259, 58 IDENTIFIER = 260, 59 STRING_LITERAL = 261, 60 BOOLEAN_LITERAL = 262, 61 TYPENAME = 263, 62 NAME_OR_INT = 264, 63 ERROR = 265, 64 LONG = 266, 65 SHORT = 267, 66 BYTE = 268, 67 INT = 269, 68 CHAR = 270, 69 BOOLEAN = 271, 70 DOUBLE = 272, 71 FLOAT = 273, 72 VARIABLE = 274, 73 ASSIGN_MODIFY = 275, 74 SUPER = 276, 75 NEW = 277, 76 OROR = 278, 77 ANDAND = 279, 78 NOTEQUAL = 280, 79 EQUAL = 281, 80 GEQ = 282, 81 LEQ = 283, 82 RSH = 284, 83 LSH = 285, 84 DECREMENT = 286, 85 INCREMENT = 287 86 }; 87#endif 88#define INTEGER_LITERAL 258 89#define FLOATING_POINT_LITERAL 259 90#define IDENTIFIER 260 91#define STRING_LITERAL 261 92#define BOOLEAN_LITERAL 262 93#define TYPENAME 263 94#define NAME_OR_INT 264 95#define ERROR 265 96#define LONG 266 97#define SHORT 267 98#define BYTE 268 99#define INT 269 100#define CHAR 270 101#define BOOLEAN 271 102#define DOUBLE 272 103#define FLOAT 273 104#define VARIABLE 274 105#define ASSIGN_MODIFY 275 106#define SUPER 276 107#define NEW 277 108#define OROR 278 109#define ANDAND 279 110#define NOTEQUAL 280 111#define EQUAL 281 112#define GEQ 282 113#define LEQ 283 114#define RSH 284 115#define LSH 285 116#define DECREMENT 286 117#define INCREMENT 287 118 119 120 121 122/* Copy the first part of user declarations. */ 123#line 39 "jv-exp.y" 124 125 126#include "defs.h" 127#include "gdb_string.h" 128#include <ctype.h> 129#include "expression.h" 130#include "value.h" 131#include "parser-defs.h" 132#include "language.h" 133#include "jv-lang.h" 134#include "bfd.h" /* Required by objfiles.h. */ 135#include "symfile.h" /* Required by objfiles.h. */ 136#include "objfiles.h" /* For have_full_symbols and have_partial_symbols */ 137#include "block.h" 138 139/* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc), 140 as well as gratuitiously global symbol names, so we can have multiple 141 yacc generated parsers in gdb. Note that these are only the variables 142 produced by yacc. If other parser generators (bison, byacc, etc) produce 143 additional global names that conflict at link time, then those parser 144 generators need to be fixed instead of adding those names to this list. */ 145 146#define yymaxdepth java_maxdepth 147#define yyparse java_parse 148#define yylex java_lex 149#define yyerror java_error 150#define yylval java_lval 151#define yychar java_char 152#define yydebug java_debug 153#define yypact java_pact 154#define yyr1 java_r1 155#define yyr2 java_r2 156#define yydef java_def 157#define yychk java_chk 158#define yypgo java_pgo 159#define yyact java_act 160#define yyexca java_exca 161#define yyerrflag java_errflag 162#define yynerrs java_nerrs 163#define yyps java_ps 164#define yypv java_pv 165#define yys java_s 166#define yy_yys java_yys 167#define yystate java_state 168#define yytmp java_tmp 169#define yyv java_v 170#define yy_yyv java_yyv 171#define yyval java_val 172#define yylloc java_lloc 173#define yyreds java_reds /* With YYDEBUG defined */ 174#define yytoks java_toks /* With YYDEBUG defined */ 175#define yyname java_name /* With YYDEBUG defined */ 176#define yyrule java_rule /* With YYDEBUG defined */ 177#define yylhs java_yylhs 178#define yylen java_yylen 179#define yydefred java_yydefred 180#define yydgoto java_yydgoto 181#define yysindex java_yysindex 182#define yyrindex java_yyrindex 183#define yygindex java_yygindex 184#define yytable java_yytable 185#define yycheck java_yycheck 186 187#ifndef YYDEBUG 188#define YYDEBUG 1 /* Default to yydebug support */ 189#endif 190 191#define YYFPRINTF parser_fprintf 192 193int yyparse (void); 194 195static int yylex (void); 196 197void yyerror (char *); 198 199static struct type *java_type_from_name (struct stoken); 200static void push_expression_name (struct stoken); 201static void push_fieldnames (struct stoken); 202 203static struct expression *copy_exp (struct expression *, int); 204static void insert_exp (int, struct expression *); 205 206 207 208/* Enabling traces. */ 209#ifndef YYDEBUG 210# define YYDEBUG 0 211#endif 212 213/* Enabling verbose error messages. */ 214#ifdef YYERROR_VERBOSE 215# undef YYERROR_VERBOSE 216# define YYERROR_VERBOSE 1 217#else 218# define YYERROR_VERBOSE 0 219#endif 220 221#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED) 222#line 128 "jv-exp.y" 223typedef union YYSTYPE { 224 LONGEST lval; 225 struct { 226 LONGEST val; 227 struct type *type; 228 } typed_val_int; 229 struct { 230 DOUBLEST dval; 231 struct type *type; 232 } typed_val_float; 233 struct symbol *sym; 234 struct type *tval; 235 struct stoken sval; 236 struct ttype tsym; 237 struct symtoken ssym; 238 struct block *bval; 239 enum exp_opcode opcode; 240 struct internalvar *ivar; 241 int *ivec; 242 } YYSTYPE; 243/* Line 191 of yacc.c. */ 244#line 245 "jv-exp.c.tmp" 245# define yystype YYSTYPE /* obsolescent; will be withdrawn */ 246# define YYSTYPE_IS_DECLARED 1 247# define YYSTYPE_IS_TRIVIAL 1 248#endif 249 250 251 252/* Copy the second part of user declarations. */ 253#line 149 "jv-exp.y" 254 255/* YYSTYPE gets defined by %union */ 256static int parse_number (char *, int, int, YYSTYPE *); 257 258 259/* Line 214 of yacc.c. */ 260#line 261 "jv-exp.c.tmp" 261 262#if ! defined (yyoverflow) || YYERROR_VERBOSE 263 264# ifndef YYFREE 265# define YYFREE free 266# endif 267# ifndef YYMALLOC 268# define YYMALLOC xmalloc 269# endif 270 271/* The parser invokes alloca or xmalloc; define the necessary symbols. */ 272 273# ifdef YYSTACK_USE_ALLOCA 274# if YYSTACK_USE_ALLOCA 275# define YYSTACK_ALLOC alloca 276# endif 277# else 278# if defined (alloca) || defined (_ALLOCA_H) 279# define YYSTACK_ALLOC alloca 280# else 281# ifdef __GNUC__ 282# define YYSTACK_ALLOC __builtin_alloca 283# endif 284# endif 285# endif 286 287# ifdef YYSTACK_ALLOC 288 /* Pacify GCC's `empty if-body' warning. */ 289# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) 290# else 291# if defined (__STDC__) || defined (__cplusplus) 292# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 293# define YYSIZE_T size_t 294# endif 295# define YYSTACK_ALLOC YYMALLOC 296# define YYSTACK_FREE YYFREE 297# endif 298#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */ 299 300 301#if (! defined (yyoverflow) \ 302 && (! defined (__cplusplus) \ 303 || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL))) 304 305/* A type that is properly aligned for any stack member. */ 306union yyalloc 307{ 308 short yyss; 309 YYSTYPE yyvs; 310 }; 311 312/* The size of the maximum gap between one aligned stack and the next. */ 313# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) 314 315/* The size of an array large to enough to hold all stacks, each with 316 N elements. */ 317# define YYSTACK_BYTES(N) \ 318 ((N) * (sizeof (short) + sizeof (YYSTYPE)) \ 319 + YYSTACK_GAP_MAXIMUM) 320 321/* Copy COUNT objects from FROM to TO. The source and destination do 322 not overlap. */ 323# ifndef YYCOPY 324# if defined (__GNUC__) && 1 < __GNUC__ 325# define YYCOPY(To, From, Count) \ 326 __builtin_memcpy (To, From, (Count) * sizeof (*(From))) 327# else 328# define YYCOPY(To, From, Count) \ 329 do \ 330 { \ 331 register YYSIZE_T yyi; \ 332 for (yyi = 0; yyi < (Count); yyi++) \ 333 (To)[yyi] = (From)[yyi]; \ 334 } \ 335 while (0) 336# endif 337# endif 338 339/* Relocate STACK from its old location to the new one. The 340 local variables YYSIZE and YYSTACKSIZE give the old and new number of 341 elements in the stack, and YYPTR gives the new location of the 342 stack. Advance YYPTR to a properly aligned location for the next 343 stack. */ 344# define YYSTACK_RELOCATE(Stack) \ 345 do \ 346 { \ 347 YYSIZE_T yynewbytes; \ 348 YYCOPY (&yyptr->Stack, Stack, yysize); \ 349 Stack = &yyptr->Stack; \ 350 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ 351 yyptr += yynewbytes / sizeof (*yyptr); \ 352 } \ 353 while (0) 354 355#endif 356 357#if defined (__STDC__) || defined (__cplusplus) 358 typedef signed char yysigned_char; 359#else 360 typedef short yysigned_char; 361#endif 362 363/* YYFINAL -- State number of the termination state. */ 364#define YYFINAL 98 365/* YYLAST -- Last index in YYTABLE. */ 366#define YYLAST 373 367 368/* YYNTOKENS -- Number of terminals. */ 369#define YYNTOKENS 56 370/* YYNNTS -- Number of nonterminals. */ 371#define YYNNTS 58 372/* YYNRULES -- Number of rules. */ 373#define YYNRULES 132 374/* YYNRULES -- Number of states. */ 375#define YYNSTATES 209 376 377/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ 378#define YYUNDEFTOK 2 379#define YYMAXUTOK 287 380 381#define YYTRANSLATE(YYX) \ 382 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) 383 384/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ 385static const unsigned char yytranslate[] = 386{ 387 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 388 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 389 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 390 2, 2, 2, 54, 2, 2, 2, 43, 30, 2, 391 48, 49, 41, 39, 23, 40, 46, 42, 2, 2, 392 2, 2, 2, 2, 2, 2, 2, 2, 55, 2, 393 33, 24, 34, 25, 2, 2, 2, 2, 2, 2, 394 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 395 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 396 2, 47, 2, 52, 29, 2, 2, 2, 2, 2, 397 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 398 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 399 2, 2, 2, 50, 28, 51, 53, 2, 2, 2, 400 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 401 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 402 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 403 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 404 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 405 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 406 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 407 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 408 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 409 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 410 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 411 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 412 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 413 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 414 15, 16, 17, 18, 19, 20, 21, 22, 26, 27, 415 31, 32, 35, 36, 37, 38, 44, 45 416}; 417 418#if YYDEBUG 419/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in 420 YYRHS. */ 421static const unsigned short yyprhs[] = 422{ 423 0, 0, 3, 5, 7, 9, 11, 13, 15, 17, 424 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 425 39, 41, 43, 45, 47, 49, 51, 54, 57, 59, 426 61, 63, 65, 67, 69, 73, 75, 79, 81, 83, 427 85, 89, 91, 93, 95, 97, 101, 103, 105, 111, 428 113, 117, 118, 120, 125, 130, 132, 135, 139, 142, 429 146, 148, 149, 153, 157, 160, 161, 166, 173, 180, 430 185, 190, 195, 197, 199, 201, 203, 205, 208, 211, 431 213, 215, 218, 221, 224, 226, 229, 232, 234, 237, 432 240, 242, 248, 253, 259, 261, 265, 269, 273, 275, 433 279, 283, 285, 289, 293, 295, 299, 303, 307, 311, 434 313, 317, 321, 323, 327, 329, 333, 335, 339, 341, 435 345, 347, 351, 353, 359, 361, 363, 367, 371, 373, 436 375, 377, 379 437}; 438 439/* YYRHS -- A `-1'-separated list of the rules' RHS. */ 440static const yysigned_char yyrhs[] = 441{ 442 57, 0, -1, 73, -1, 58, -1, 59, -1, 62, 443 -1, 68, -1, 6, -1, 3, -1, 9, -1, 4, 444 -1, 7, -1, 60, -1, 63, -1, 16, -1, 64, 445 -1, 65, -1, 13, -1, 12, -1, 14, -1, 11, 446 -1, 15, -1, 18, -1, 17, -1, 69, -1, 66, 447 -1, 62, 84, -1, 69, 84, -1, 5, -1, 72, 448 -1, 71, -1, 72, -1, 5, -1, 9, -1, 69, 449 46, 71, -1, 113, -1, 73, 23, 113, -1, 75, 450 -1, 81, -1, 61, -1, 48, 113, 49, -1, 78, 451 -1, 86, -1, 88, -1, 90, -1, 76, 79, 77, 452 -1, 50, -1, 51, -1, 22, 67, 48, 80, 49, 453 -1, 113, -1, 79, 23, 113, -1, -1, 79, -1, 454 22, 62, 82, 85, -1, 22, 66, 82, 85, -1, 455 83, -1, 82, 83, -1, 47, 113, 52, -1, 47, 456 52, -1, 84, 47, 52, -1, 84, -1, -1, 74, 457 46, 71, -1, 19, 46, 71, -1, 69, 48, -1, 458 -1, 87, 89, 80, 49, -1, 74, 46, 71, 48, 459 80, 49, -1, 21, 46, 71, 48, 80, 49, -1, 460 69, 47, 113, 52, -1, 19, 47, 113, 52, -1, 461 75, 47, 113, 52, -1, 74, -1, 69, -1, 19, 462 -1, 92, -1, 93, -1, 91, 45, -1, 91, 44, 463 -1, 95, -1, 96, -1, 39, 94, -1, 40, 94, 464 -1, 41, 94, -1, 97, -1, 45, 94, -1, 44, 465 94, -1, 91, -1, 53, 94, -1, 54, 94, -1, 466 98, -1, 48, 62, 85, 49, 94, -1, 48, 113, 467 49, 97, -1, 48, 69, 84, 49, 97, -1, 94, 468 -1, 99, 41, 94, -1, 99, 42, 94, -1, 99, 469 43, 94, -1, 99, -1, 100, 39, 99, -1, 100, 470 40, 99, -1, 100, -1, 101, 38, 100, -1, 101, 471 37, 100, -1, 101, -1, 102, 33, 101, -1, 102, 472 34, 101, -1, 102, 36, 101, -1, 102, 35, 101, 473 -1, 102, -1, 103, 32, 102, -1, 103, 31, 102, 474 -1, 103, -1, 104, 30, 103, -1, 104, -1, 105, 475 29, 104, -1, 105, -1, 106, 28, 105, -1, 106, 476 -1, 107, 27, 106, -1, 107, -1, 108, 26, 107, 477 -1, 108, -1, 108, 25, 113, 55, 109, -1, 109, 478 -1, 111, -1, 112, 24, 109, -1, 112, 20, 109, 479 -1, 70, -1, 19, -1, 86, -1, 90, -1, 110, 480 -1 481}; 482 483/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ 484static const unsigned short yyrline[] = 485{ 486 0, 205, 205, 206, 209, 218, 219, 223, 232, 237, 487 245, 250, 255, 266, 267, 272, 273, 277, 279, 281, 488 283, 285, 290, 292, 304, 309, 313, 315, 320, 321, 489 325, 326, 330, 331, 335, 358, 359, 364, 365, 369, 490 370, 371, 372, 373, 374, 375, 383, 388, 393, 399, 491 401, 407, 408, 412, 415, 421, 422, 426, 430, 432, 492 437, 439, 443, 445, 451, 457, 456, 462, 464, 469, 493 486, 488, 493, 494, 496, 498, 499, 503, 508, 513, 494 514, 515, 516, 518, 520, 524, 529, 534, 535, 537, 495 539, 543, 547, 568, 576, 577, 579, 581, 586, 587, 496 589, 594, 595, 597, 603, 604, 606, 608, 610, 616, 497 617, 619, 624, 625, 630, 631, 635, 636, 641, 642, 498 647, 648, 653, 654, 659, 660, 664, 666, 673, 675, 499 677, 678, 683 500}; 501#endif 502 503#if YYDEBUG || YYERROR_VERBOSE 504/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. 505 First, the terminals, then, starting at YYNTOKENS, nonterminals. */ 506static const char *const yytname[] = 507{ 508 "$end", "error", "$undefined", "INTEGER_LITERAL", 509 "FLOATING_POINT_LITERAL", "IDENTIFIER", "STRING_LITERAL", 510 "BOOLEAN_LITERAL", "TYPENAME", "NAME_OR_INT", "ERROR", "LONG", "SHORT", 511 "BYTE", "INT", "CHAR", "BOOLEAN", "DOUBLE", "FLOAT", "VARIABLE", 512 "ASSIGN_MODIFY", "SUPER", "NEW", "','", "'='", "'?'", "OROR", "ANDAND", 513 "'|'", "'^'", "'&'", "NOTEQUAL", "EQUAL", "'<'", "'>'", "GEQ", "LEQ", 514 "RSH", "LSH", "'+'", "'-'", "'*'", "'/'", "'%'", "DECREMENT", 515 "INCREMENT", "'.'", "'['", "'('", "')'", "'{'", "'}'", "']'", "'~'", 516 "'!'", "':'", "$accept", "start", "type_exp", "PrimitiveOrArrayType", 517 "StringLiteral", "Literal", "PrimitiveType", "NumericType", 518 "IntegralType", "FloatingPointType", "ClassOrInterfaceType", "ClassType", 519 "ArrayType", "Name", "ForcedName", "SimpleName", "QualifiedName", "exp1", 520 "Primary", "PrimaryNoNewArray", "lcurly", "rcurly", 521 "ClassInstanceCreationExpression", "ArgumentList", "ArgumentList_opt", 522 "ArrayCreationExpression", "DimExprs", "DimExpr", "Dims", "Dims_opt", 523 "FieldAccess", "FuncStart", "MethodInvocation", "@1", "ArrayAccess", 524 "PostfixExpression", "PostIncrementExpression", 525 "PostDecrementExpression", "UnaryExpression", "PreIncrementExpression", 526 "PreDecrementExpression", "UnaryExpressionNotPlusMinus", 527 "CastExpression", "MultiplicativeExpression", "AdditiveExpression", 528 "ShiftExpression", "RelationalExpression", "EqualityExpression", 529 "AndExpression", "ExclusiveOrExpression", "InclusiveOrExpression", 530 "ConditionalAndExpression", "ConditionalOrExpression", 531 "ConditionalExpression", "AssignmentExpression", "Assignment", 532 "LeftHandSide", "Expression", 0 533}; 534#endif 535 536# ifdef YYPRINT 537/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to 538 token YYLEX-NUM. */ 539static const unsigned short yytoknum[] = 540{ 541 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, 542 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 543 275, 276, 277, 44, 61, 63, 278, 279, 124, 94, 544 38, 280, 281, 60, 62, 282, 283, 284, 285, 43, 545 45, 42, 47, 37, 286, 287, 46, 91, 40, 41, 546 123, 125, 93, 126, 33, 58 547}; 548# endif 549 550/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ 551static const unsigned char yyr1[] = 552{ 553 0, 56, 57, 57, 58, 59, 59, 60, 61, 61, 554 61, 61, 61, 62, 62, 63, 63, 64, 64, 64, 555 64, 64, 65, 65, 66, 67, 68, 68, 69, 69, 556 70, 70, 71, 71, 72, 73, 73, 74, 74, 75, 557 75, 75, 75, 75, 75, 75, 76, 77, 78, 79, 558 79, 80, 80, 81, 81, 82, 82, 83, 84, 84, 559 85, 85, 86, 86, 87, 89, 88, 88, 88, 90, 560 90, 90, 91, 91, 91, 91, 91, 92, 93, 94, 561 94, 94, 94, 94, 94, 95, 96, 97, 97, 97, 562 97, 98, 98, 98, 99, 99, 99, 99, 100, 100, 563 100, 101, 101, 101, 102, 102, 102, 102, 102, 103, 564 103, 103, 104, 104, 105, 105, 106, 106, 107, 107, 565 108, 108, 109, 109, 110, 110, 111, 111, 112, 112, 566 112, 112, 113 567}; 568 569/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ 570static const unsigned char yyr2[] = 571{ 572 0, 2, 1, 1, 1, 1, 1, 1, 1, 1, 573 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 574 1, 1, 1, 1, 1, 1, 2, 2, 1, 1, 575 1, 1, 1, 1, 3, 1, 3, 1, 1, 1, 576 3, 1, 1, 1, 1, 3, 1, 1, 5, 1, 577 3, 0, 1, 4, 4, 1, 2, 3, 2, 3, 578 1, 0, 3, 3, 2, 0, 4, 6, 6, 4, 579 4, 4, 1, 1, 1, 1, 1, 2, 2, 1, 580 1, 2, 2, 2, 1, 2, 2, 1, 2, 2, 581 1, 5, 4, 5, 1, 3, 3, 3, 1, 3, 582 3, 1, 3, 3, 1, 3, 3, 3, 3, 1, 583 3, 3, 1, 3, 1, 3, 1, 3, 1, 3, 584 1, 3, 1, 5, 1, 1, 3, 3, 1, 1, 585 1, 1, 1 586}; 587 588/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state 589 STATE-NUM when YYTABLE doesn't specify something else to do. Zero 590 means the default is an error. */ 591static const unsigned char yydefact[] = 592{ 593 0, 8, 10, 28, 7, 11, 9, 20, 18, 17, 594 19, 21, 14, 23, 22, 74, 0, 0, 0, 0, 595 0, 0, 0, 0, 46, 0, 0, 0, 3, 4, 596 12, 39, 5, 13, 15, 16, 6, 73, 128, 30, 597 29, 2, 72, 37, 0, 41, 38, 42, 65, 43, 598 44, 87, 75, 76, 94, 79, 80, 84, 90, 98, 599 101, 104, 109, 112, 114, 116, 118, 120, 122, 124, 600 132, 125, 0, 35, 0, 0, 0, 28, 0, 25, 601 0, 24, 29, 9, 74, 73, 42, 44, 81, 82, 602 83, 86, 85, 61, 73, 0, 88, 89, 1, 0, 603 26, 0, 0, 64, 27, 0, 0, 0, 0, 49, 604 51, 78, 77, 0, 0, 0, 0, 0, 0, 0, 605 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 606 0, 0, 0, 0, 32, 33, 63, 0, 0, 0, 607 61, 55, 61, 51, 0, 60, 0, 0, 40, 58, 608 0, 34, 0, 36, 62, 0, 0, 47, 45, 52, 609 0, 95, 96, 97, 99, 100, 103, 102, 105, 106, 610 108, 107, 111, 110, 113, 115, 117, 119, 0, 121, 611 127, 126, 70, 51, 0, 0, 56, 53, 54, 0, 612 0, 0, 92, 59, 69, 51, 71, 50, 66, 0, 613 0, 57, 48, 91, 93, 0, 123, 68, 67 614}; 615 616/* YYDEFGOTO[NTERM-NUM]. */ 617static const short yydefgoto[] = 618{ 619 -1, 27, 28, 29, 30, 31, 32, 33, 34, 35, 620 79, 80, 36, 85, 38, 39, 82, 41, 42, 43, 621 44, 158, 45, 159, 160, 46, 140, 141, 145, 146, 622 86, 48, 49, 110, 87, 51, 52, 53, 54, 55, 623 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 624 66, 67, 68, 69, 70, 71, 72, 109 625}; 626 627/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 628 STATE-NUM. */ 629#define YYPACT_NINF -145 630static const short yypact[] = 631{ 632 215, -145, -145, -5, -145, -145, 1, -145, -145, -145, 633 -145, -145, -145, -145, -145, -7, -19, 279, 50, 50, 634 50, 50, 50, 215, -145, 50, 50, 46, -145, -145, 635 -145, -145, -9, -145, -145, -145, -145, 87, -145, -145, 636 12, 44, 5, 16, 319, -145, -145, 28, -145, -145, 637 38, 29, -145, -145, -145, -145, -145, -145, -145, 99, 638 53, 85, 52, 94, 66, 41, 71, 74, 122, -145, 639 -145, -145, 40, -145, 26, 319, 26, -145, 59, 59, 640 67, 82, -145, -145, 111, 107, -145, -145, -145, -145, 641 -145, -145, -145, -9, 87, 68, -145, -145, -145, 79, 642 91, 26, 267, -145, 91, 319, 26, 319, -18, -145, 643 319, -145, -145, 50, 50, 50, 50, 50, 50, 50, 644 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 645 319, 50, 50, 50, -145, -145, -145, 112, 126, 319, 646 128, -145, 128, 319, 319, 91, 127, -31, 193, -145, 647 125, -145, 129, -145, 131, 130, 319, -145, -145, 157, 648 135, -145, -145, -145, 99, 99, 53, 53, 85, 85, 649 85, 85, 52, 52, 94, 66, 41, 71, 132, 74, 650 -145, -145, -145, 319, 134, 267, -145, -145, -145, 139, 651 50, 193, -145, -145, -145, 319, -145, -145, -145, 50, 652 141, -145, -145, -145, -145, 144, -145, -145, -145 653}; 654 655/* YYPGOTO[NTERM-NUM]. */ 656static const short yypgoto[] = 657{ 658 -145, -145, -145, -145, -145, -145, -3, -145, -145, -145, 659 -145, -145, -145, 11, -145, -64, 0, -145, -145, -145, 660 -145, -145, -145, 150, -134, -145, 124, -116, -29, -99, 661 6, -145, -145, -145, 22, -145, -145, -145, 58, -145, 662 -145, -144, -145, 43, 49, -2, 45, 78, 81, 83, 663 77, 92, -145, -131, -145, -145, -145, 7 664}; 665 666/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If 667 positive, shift that token. If negative, reduce the rule which 668 number is the opposite. If zero, do what YYDEFACT says. 669 If YYTABLE_NINF, syntax error. */ 670#define YYTABLE_NINF -132 671static const short yytable[] = 672{ 673 40, 180, 181, 100, 192, 156, 47, 73, 104, 189, 674 136, 37, 138, -129, 78, -32, 150, -129, 191, -32, 675 93, -33, 50, 40, 186, -33, 186, 76, 81, 47, 676 95, 134, -31, 157, 94, 135, -31, 151, 99, 74, 677 75, 187, 154, 188, 40, 50, 98, 204, -130, 200, 678 47, 106, -130, 1, 2, 77, 4, 5, -131, 83, 679 132, 205, -131, 107, 133, 147, 50, 105, 206, 84, 680 127, 16, 17, 111, 112, 40, 88, 89, 90, 91, 681 92, 47, 137, 96, 97, 120, 121, 122, 123, 18, 682 19, 20, 116, 117, 21, 22, 126, 50, 23, 128, 683 24, 129, 40, 25, 26, 40, 139, 40, 47, 152, 684 40, 47, 153, 47, 155, 143, 47, 148, 168, 169, 685 170, 171, 118, 119, 50, 124, 125, 50, 101, 50, 686 40, 149, 50, 101, 102, 103, 47, 178, 150, 40, 687 113, 114, 115, 40, 40, 47, 184, 130, 131, 47, 688 47, 152, 50, 101, 144, 103, 40, 74, 75, 164, 689 165, 50, 47, 197, 182, 50, 50, 166, 167, 172, 690 173, 161, 162, 163, 183, 185, 190, 193, 50, 195, 691 156, 194, 196, 40, 198, 40, 201, 199, 202, 47, 692 207, 47, 184, 208, 108, 40, 1, 2, 77, 4, 693 5, 47, 83, 142, 174, 50, 177, 50, 175, 0, 694 0, 176, 84, 0, 16, 17, 0, 50, 1, 2, 695 3, 4, 5, 179, 6, 0, 7, 8, 9, 10, 696 11, 12, 13, 14, 15, 0, 16, 17, 0, 0, 697 0, 23, 0, 24, 0, 0, 25, 26, 203, 0, 698 0, 0, 0, 0, 18, 19, 20, 0, 0, 21, 699 22, 0, 0, 23, 0, 24, 0, 0, 25, 26, 700 1, 2, 3, 4, 5, 0, 6, 0, 0, 0, 701 0, 0, 0, 0, 77, 0, 15, 0, 16, 17, 702 7, 8, 9, 10, 11, 12, 13, 14, 0, 0, 703 0, 0, 0, 0, 0, 0, 18, 19, 20, 0, 704 0, 21, 22, 0, 0, 23, 0, 24, 0, 149, 705 25, 26, 1, 2, 3, 4, 5, 0, 6, 0, 706 0, 0, 0, 0, 0, 0, 0, 0, 15, 0, 707 16, 17, 0, 0, 0, 0, 0, 0, 0, 0, 708 0, 0, 0, 0, 0, 0, 0, 0, 18, 19, 709 20, 0, 0, 21, 22, 0, 0, 23, 0, 24, 710 0, 0, 25, 26 711}; 712 713static const short yycheck[] = 714{ 715 0, 132, 133, 32, 148, 23, 0, 0, 37, 143, 716 74, 0, 76, 20, 17, 20, 47, 24, 49, 24, 717 23, 20, 0, 23, 140, 24, 142, 46, 17, 23, 718 23, 5, 20, 51, 23, 9, 24, 101, 47, 46, 719 47, 140, 106, 142, 44, 23, 0, 191, 20, 183, 720 44, 46, 24, 3, 4, 5, 6, 7, 20, 9, 721 20, 195, 24, 47, 24, 94, 44, 23, 199, 19, 722 29, 21, 22, 44, 45, 75, 18, 19, 20, 21, 723 22, 75, 75, 25, 26, 33, 34, 35, 36, 39, 724 40, 41, 39, 40, 44, 45, 30, 75, 48, 28, 725 50, 27, 102, 53, 54, 105, 47, 107, 102, 102, 726 110, 105, 105, 107, 107, 48, 110, 49, 120, 121, 727 122, 123, 37, 38, 102, 31, 32, 105, 46, 107, 728 130, 52, 110, 46, 47, 48, 130, 130, 47, 139, 729 41, 42, 43, 143, 144, 139, 139, 25, 26, 143, 730 144, 144, 130, 46, 47, 48, 156, 46, 47, 116, 731 117, 139, 156, 156, 52, 143, 144, 118, 119, 124, 732 125, 113, 114, 115, 48, 47, 49, 52, 156, 48, 733 23, 52, 52, 183, 49, 185, 52, 55, 49, 183, 734 49, 185, 185, 49, 44, 195, 3, 4, 5, 6, 735 7, 195, 9, 79, 126, 183, 129, 185, 127, -1, 736 -1, 128, 19, -1, 21, 22, -1, 195, 3, 4, 737 5, 6, 7, 131, 9, -1, 11, 12, 13, 14, 738 15, 16, 17, 18, 19, -1, 21, 22, -1, -1, 739 -1, 48, -1, 50, -1, -1, 53, 54, 190, -1, 740 -1, -1, -1, -1, 39, 40, 41, -1, -1, 44, 741 45, -1, -1, 48, -1, 50, -1, -1, 53, 54, 742 3, 4, 5, 6, 7, -1, 9, -1, -1, -1, 743 -1, -1, -1, -1, 5, -1, 19, -1, 21, 22, 744 11, 12, 13, 14, 15, 16, 17, 18, -1, -1, 745 -1, -1, -1, -1, -1, -1, 39, 40, 41, -1, 746 -1, 44, 45, -1, -1, 48, -1, 50, -1, 52, 747 53, 54, 3, 4, 5, 6, 7, -1, 9, -1, 748 -1, -1, -1, -1, -1, -1, -1, -1, 19, -1, 749 21, 22, -1, -1, -1, -1, -1, -1, -1, -1, 750 -1, -1, -1, -1, -1, -1, -1, -1, 39, 40, 751 41, -1, -1, 44, 45, -1, -1, 48, -1, 50, 752 -1, -1, 53, 54 753}; 754 755/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing 756 symbol of state STATE-NUM. */ 757static const unsigned char yystos[] = 758{ 759 0, 3, 4, 5, 6, 7, 9, 11, 12, 13, 760 14, 15, 16, 17, 18, 19, 21, 22, 39, 40, 761 41, 44, 45, 48, 50, 53, 54, 57, 58, 59, 762 60, 61, 62, 63, 64, 65, 68, 69, 70, 71, 763 72, 73, 74, 75, 76, 78, 81, 86, 87, 88, 764 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 765 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 766 110, 111, 112, 113, 46, 47, 46, 5, 62, 66, 767 67, 69, 72, 9, 19, 69, 86, 90, 94, 94, 768 94, 94, 94, 62, 69, 113, 94, 94, 0, 47, 769 84, 46, 47, 48, 84, 23, 46, 47, 79, 113, 770 89, 44, 45, 41, 42, 43, 39, 40, 37, 38, 771 33, 34, 35, 36, 31, 32, 30, 29, 28, 27, 772 25, 26, 20, 24, 5, 9, 71, 113, 71, 47, 773 82, 83, 82, 48, 47, 84, 85, 84, 49, 52, 774 47, 71, 113, 113, 71, 113, 23, 51, 77, 79, 775 80, 94, 94, 94, 99, 99, 100, 100, 101, 101, 776 101, 101, 102, 102, 103, 104, 105, 106, 113, 107, 777 109, 109, 52, 48, 113, 47, 83, 85, 85, 80, 778 49, 49, 97, 52, 52, 48, 52, 113, 49, 55, 779 80, 52, 49, 94, 97, 80, 109, 49, 49 780}; 781 782#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__) 783# define YYSIZE_T __SIZE_TYPE__ 784#endif 785#if ! defined (YYSIZE_T) && defined (size_t) 786# define YYSIZE_T size_t 787#endif 788#if ! defined (YYSIZE_T) 789# if defined (__STDC__) || defined (__cplusplus) 790# include <stddef.h> /* INFRINGES ON USER NAME SPACE */ 791# define YYSIZE_T size_t 792# endif 793#endif 794#if ! defined (YYSIZE_T) 795# define YYSIZE_T unsigned int 796#endif 797 798#define yyerrok (yyerrstatus = 0) 799#define yyclearin (yychar = YYEMPTY) 800#define YYEMPTY (-2) 801#define YYEOF 0 802 803#define YYACCEPT goto yyacceptlab 804#define YYABORT goto yyabortlab 805#define YYERROR goto yyerrorlab 806 807 808/* Like YYERROR except do call yyerror. This remains here temporarily 809 to ease the transition to the new meaning of YYERROR, for GCC. 810 Once GCC version 2 has supplanted version 1, this can go. */ 811 812#define YYFAIL goto yyerrlab 813 814#define YYRECOVERING() (!!yyerrstatus) 815 816#define YYBACKUP(Token, Value) \ 817do \ 818 if (yychar == YYEMPTY && yylen == 1) \ 819 { \ 820 yychar = (Token); \ 821 yylval = (Value); \ 822 yytoken = YYTRANSLATE (yychar); \ 823 YYPOPSTACK; \ 824 goto yybackup; \ 825 } \ 826 else \ 827 { \ 828 yyerror ("syntax error: cannot back up");\ 829 YYERROR; \ 830 } \ 831while (0) 832 833#define YYTERROR 1 834#define YYERRCODE 256 835 836/* YYLLOC_DEFAULT -- Compute the default location (before the actions 837 are run). */ 838 839#ifndef YYLLOC_DEFAULT 840# define YYLLOC_DEFAULT(Current, Rhs, N) \ 841 ((Current).first_line = (Rhs)[1].first_line, \ 842 (Current).first_column = (Rhs)[1].first_column, \ 843 (Current).last_line = (Rhs)[N].last_line, \ 844 (Current).last_column = (Rhs)[N].last_column) 845#endif 846 847/* YYLEX -- calling `yylex' with the right arguments. */ 848 849#ifdef YYLEX_PARAM 850# define YYLEX yylex (YYLEX_PARAM) 851#else 852# define YYLEX yylex () 853#endif 854 855/* Enable debugging if requested. */ 856#if YYDEBUG 857 858# ifndef YYFPRINTF 859# include <stdio.h> /* INFRINGES ON USER NAME SPACE */ 860# define YYFPRINTF fprintf 861# endif 862 863# define YYDPRINTF(Args) \ 864do { \ 865 if (yydebug) \ 866 YYFPRINTF Args; \ 867} while (0) 868 869# define YYDSYMPRINT(Args) \ 870do { \ 871 if (yydebug) \ 872 yysymprint Args; \ 873} while (0) 874 875# define YYDSYMPRINTF(Title, Token, Value, Location) \ 876do { \ 877 if (yydebug) \ 878 { \ 879 YYFPRINTF (stderr, "%s ", Title); \ 880 yysymprint (stderr, \ 881 Token, Value); \ 882 YYFPRINTF (stderr, "\n"); \ 883 } \ 884} while (0) 885 886/*------------------------------------------------------------------. 887| yy_stack_print -- Print the state stack from its BOTTOM up to its | 888| TOP (included). | 889`------------------------------------------------------------------*/ 890 891#if defined (__STDC__) || defined (__cplusplus) 892static void 893yy_stack_print (short *bottom, short *top) 894#else 895static void 896yy_stack_print (bottom, top) 897 short *bottom; 898 short *top; 899#endif 900{ 901 YYFPRINTF (stderr, "Stack now"); 902 for (/* Nothing. */; bottom <= top; ++bottom) 903 YYFPRINTF (stderr, " %d", *bottom); 904 YYFPRINTF (stderr, "\n"); 905} 906 907# define YY_STACK_PRINT(Bottom, Top) \ 908do { \ 909 if (yydebug) \ 910 yy_stack_print ((Bottom), (Top)); \ 911} while (0) 912 913 914/*------------------------------------------------. 915| Report that the YYRULE is going to be reduced. | 916`------------------------------------------------*/ 917 918#if defined (__STDC__) || defined (__cplusplus) 919static void 920yy_reduce_print (int yyrule) 921#else 922static void 923yy_reduce_print (yyrule) 924 int yyrule; 925#endif 926{ 927 int yyi; 928 unsigned int yylno = yyrline[yyrule]; 929 YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ", 930 yyrule - 1, yylno); 931 /* Print the symbols being reduced, and their result. */ 932 for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++) 933 YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]); 934 YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]); 935} 936 937# define YY_REDUCE_PRINT(Rule) \ 938do { \ 939 if (yydebug) \ 940 yy_reduce_print (Rule); \ 941} while (0) 942 943/* Nonzero means print parse trace. It is left uninitialized so that 944 multiple parsers can coexist. */ 945int yydebug; 946#else /* !YYDEBUG */ 947# define YYDPRINTF(Args) 948# define YYDSYMPRINT(Args) 949# define YYDSYMPRINTF(Title, Token, Value, Location) 950# define YY_STACK_PRINT(Bottom, Top) 951# define YY_REDUCE_PRINT(Rule) 952#endif /* !YYDEBUG */ 953 954 955/* YYINITDEPTH -- initial size of the parser's stacks. */ 956#ifndef YYINITDEPTH 957# define YYINITDEPTH 200 958#endif 959 960/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only 961 if the built-in stack extension method is used). 962 963 Do not make this value too large; the results are undefined if 964 SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH) 965 evaluated with infinite-precision integer arithmetic. */ 966 967#if defined (YYMAXDEPTH) && YYMAXDEPTH == 0 968# undef YYMAXDEPTH 969#endif 970 971#ifndef YYMAXDEPTH 972# define YYMAXDEPTH 10000 973#endif 974 975 976 977#if YYERROR_VERBOSE 978 979# ifndef yystrlen 980# if defined (__GLIBC__) && defined (_STRING_H) 981# define yystrlen strlen 982# else 983/* Return the length of YYSTR. */ 984static YYSIZE_T 985# if defined (__STDC__) || defined (__cplusplus) 986yystrlen (const char *yystr) 987# else 988yystrlen (yystr) 989 const char *yystr; 990# endif 991{ 992 register const char *yys = yystr; 993 994 while (*yys++ != '\0') 995 continue; 996 997 return yys - yystr - 1; 998} 999# endif 1000# endif 1001 1002# ifndef yystpcpy 1003# if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE) 1004# define yystpcpy stpcpy 1005# else 1006/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in 1007 YYDEST. */ 1008static char * 1009# if defined (__STDC__) || defined (__cplusplus) 1010yystpcpy (char *yydest, const char *yysrc) 1011# else 1012yystpcpy (yydest, yysrc) 1013 char *yydest; 1014 const char *yysrc; 1015# endif 1016{ 1017 register char *yyd = yydest; 1018 register const char *yys = yysrc; 1019 1020 while ((*yyd++ = *yys++) != '\0') 1021 continue; 1022 1023 return yyd - 1; 1024} 1025# endif 1026# endif 1027 1028#endif /* !YYERROR_VERBOSE */ 1029 1030 1031 1032#if YYDEBUG 1033/*--------------------------------. 1034| Print this symbol on YYOUTPUT. | 1035`--------------------------------*/ 1036 1037#if defined (__STDC__) || defined (__cplusplus) 1038static void 1039yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep) 1040#else 1041static void 1042yysymprint (yyoutput, yytype, yyvaluep) 1043 FILE *yyoutput; 1044 int yytype; 1045 YYSTYPE *yyvaluep; 1046#endif 1047{ 1048 /* Pacify ``unused variable'' warnings. */ 1049 (void) yyvaluep; 1050 1051 if (yytype < YYNTOKENS) 1052 { 1053 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); 1054# ifdef YYPRINT 1055 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); 1056# endif 1057 } 1058 else 1059 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); 1060 1061 switch (yytype) 1062 { 1063 default: 1064 break; 1065 } 1066 YYFPRINTF (yyoutput, ")"); 1067} 1068 1069#endif /* ! YYDEBUG */ 1070/*-----------------------------------------------. 1071| Release the memory associated to this symbol. | 1072`-----------------------------------------------*/ 1073 1074#if defined (__STDC__) || defined (__cplusplus) 1075static void 1076yydestruct (int yytype, YYSTYPE *yyvaluep) 1077#else 1078static void 1079yydestruct (yytype, yyvaluep) 1080 int yytype; 1081 YYSTYPE *yyvaluep; 1082#endif 1083{ 1084 /* Pacify ``unused variable'' warnings. */ 1085 (void) yyvaluep; 1086 1087 switch (yytype) 1088 { 1089 1090 default: 1091 break; 1092 } 1093} 1094 1095 1096/* Prevent warnings from -Wmissing-prototypes. */ 1097 1098#ifdef YYPARSE_PARAM 1099# if defined (__STDC__) || defined (__cplusplus) 1100int yyparse (void *YYPARSE_PARAM); 1101# else 1102int yyparse (); 1103# endif 1104#else /* ! YYPARSE_PARAM */ 1105#if defined (__STDC__) || defined (__cplusplus) 1106int yyparse (void); 1107#else 1108int yyparse (); 1109#endif 1110#endif /* ! YYPARSE_PARAM */ 1111 1112 1113 1114/* The lookahead symbol. */ 1115int yychar; 1116 1117/* The semantic value of the lookahead symbol. */ 1118YYSTYPE yylval; 1119 1120/* Number of syntax errors so far. */ 1121int yynerrs; 1122 1123 1124 1125/*----------. 1126| yyparse. | 1127`----------*/ 1128 1129#ifdef YYPARSE_PARAM 1130# if defined (__STDC__) || defined (__cplusplus) 1131int yyparse (void *YYPARSE_PARAM) 1132# else 1133int yyparse (YYPARSE_PARAM) 1134 void *YYPARSE_PARAM; 1135# endif 1136#else /* ! YYPARSE_PARAM */ 1137#if defined (__STDC__) || defined (__cplusplus) 1138int 1139yyparse (void) 1140#else 1141int 1142yyparse () 1143 1144#endif 1145#endif 1146{ 1147 1148 register int yystate; 1149 register int yyn; 1150 int yyresult; 1151 /* Number of tokens to shift before error messages enabled. */ 1152 int yyerrstatus; 1153 /* Lookahead token as an internal (translated) token number. */ 1154 int yytoken = 0; 1155 1156 /* Three stacks and their tools: 1157 `yyss': related to states, 1158 `yyvs': related to semantic values, 1159 `yyls': related to locations. 1160 1161 Refer to the stacks thru separate pointers, to allow yyoverflow 1162 to xreallocate them elsewhere. */ 1163 1164 /* The state stack. */ 1165 short yyssa[YYINITDEPTH]; 1166 short *yyss = yyssa; 1167 register short *yyssp; 1168 1169 /* The semantic value stack. */ 1170 YYSTYPE yyvsa[YYINITDEPTH]; 1171 YYSTYPE *yyvs = yyvsa; 1172 register YYSTYPE *yyvsp; 1173 1174 1175 1176#define YYPOPSTACK (yyvsp--, yyssp--) 1177 1178 YYSIZE_T yystacksize = YYINITDEPTH; 1179 1180 /* The variables used to return semantic value and location from the 1181 action routines. */ 1182 YYSTYPE yyval; 1183 1184 1185 /* When reducing, the number of symbols on the RHS of the reduced 1186 rule. */ 1187 int yylen; 1188 1189 YYDPRINTF ((stderr, "Starting parse\n")); 1190 1191 yystate = 0; 1192 yyerrstatus = 0; 1193 yynerrs = 0; 1194 yychar = YYEMPTY; /* Cause a token to be read. */ 1195 1196 /* Initialize stack pointers. 1197 Waste one element of value and location stack 1198 so that they stay on the same level as the state stack. 1199 The wasted elements are never initialized. */ 1200 1201 yyssp = yyss; 1202 yyvsp = yyvs; 1203 1204 goto yysetstate; 1205 1206/*------------------------------------------------------------. 1207| yynewstate -- Push a new state, which is found in yystate. | 1208`------------------------------------------------------------*/ 1209 yynewstate: 1210 /* In all cases, when you get here, the value and location stacks 1211 have just been pushed. so pushing a state here evens the stacks. 1212 */ 1213 yyssp++; 1214 1215 yysetstate: 1216 *yyssp = yystate; 1217 1218 if (yyss + yystacksize - 1 <= yyssp) 1219 { 1220 /* Get the current used size of the three stacks, in elements. */ 1221 YYSIZE_T yysize = yyssp - yyss + 1; 1222 1223#ifdef yyoverflow 1224 { 1225 /* Give user a chance to xreallocate the stack. Use copies of 1226 these so that the &'s don't force the real ones into 1227 memory. */ 1228 YYSTYPE *yyvs1 = yyvs; 1229 short *yyss1 = yyss; 1230 1231 1232 /* Each stack pointer address is followed by the size of the 1233 data in use in that stack, in bytes. This used to be a 1234 conditional around just the two extra args, but that might 1235 be undefined if yyoverflow is a macro. */ 1236 yyoverflow ("parser stack overflow", 1237 &yyss1, yysize * sizeof (*yyssp), 1238 &yyvs1, yysize * sizeof (*yyvsp), 1239 1240 &yystacksize); 1241 1242 yyss = yyss1; 1243 yyvs = yyvs1; 1244 } 1245#else /* no yyoverflow */ 1246# ifndef YYSTACK_RELOCATE 1247 goto yyoverflowlab; 1248# else 1249 /* Extend the stack our own way. */ 1250 if (YYMAXDEPTH <= yystacksize) 1251 goto yyoverflowlab; 1252 yystacksize *= 2; 1253 if (YYMAXDEPTH < yystacksize) 1254 yystacksize = YYMAXDEPTH; 1255 1256 { 1257 short *yyss1 = yyss; 1258 union yyalloc *yyptr = 1259 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); 1260 if (! yyptr) 1261 goto yyoverflowlab; 1262 YYSTACK_RELOCATE (yyss); 1263 YYSTACK_RELOCATE (yyvs); 1264 1265# undef YYSTACK_RELOCATE 1266 if (yyss1 != yyssa) 1267 YYSTACK_FREE (yyss1); 1268 } 1269# endif 1270#endif /* no yyoverflow */ 1271 1272 yyssp = yyss + yysize - 1; 1273 yyvsp = yyvs + yysize - 1; 1274 1275 1276 YYDPRINTF ((stderr, "Stack size increased to %lu\n", 1277 (unsigned long int) yystacksize)); 1278 1279 if (yyss + yystacksize - 1 <= yyssp) 1280 YYABORT; 1281 } 1282 1283 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 1284 1285 goto yybackup; 1286 1287/*-----------. 1288| yybackup. | 1289`-----------*/ 1290yybackup: 1291 1292/* Do appropriate processing given the current state. */ 1293/* Read a lookahead token if we need one and don't already have one. */ 1294/* yyresume: */ 1295 1296 /* First try to decide what to do without reference to lookahead token. */ 1297 1298 yyn = yypact[yystate]; 1299 if (yyn == YYPACT_NINF) 1300 goto yydefault; 1301 1302 /* Not known => get a lookahead token if don't already have one. */ 1303 1304 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ 1305 if (yychar == YYEMPTY) 1306 { 1307 YYDPRINTF ((stderr, "Reading a token: ")); 1308 yychar = YYLEX; 1309 } 1310 1311 if (yychar <= YYEOF) 1312 { 1313 yychar = yytoken = YYEOF; 1314 YYDPRINTF ((stderr, "Now at end of input.\n")); 1315 } 1316 else 1317 { 1318 yytoken = YYTRANSLATE (yychar); 1319 YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc); 1320 } 1321 1322 /* If the proper action on seeing token YYTOKEN is to reduce or to 1323 detect an error, take that action. */ 1324 yyn += yytoken; 1325 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) 1326 goto yydefault; 1327 yyn = yytable[yyn]; 1328 if (yyn <= 0) 1329 { 1330 if (yyn == 0 || yyn == YYTABLE_NINF) 1331 goto yyerrlab; 1332 yyn = -yyn; 1333 goto yyreduce; 1334 } 1335 1336 if (yyn == YYFINAL) 1337 YYACCEPT; 1338 1339 /* Shift the lookahead token. */ 1340 YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken])); 1341 1342 /* Discard the token being shifted unless it is eof. */ 1343 if (yychar != YYEOF) 1344 yychar = YYEMPTY; 1345 1346 *++yyvsp = yylval; 1347 1348 1349 /* Count tokens shifted since error; after three, turn off error 1350 status. */ 1351 if (yyerrstatus) 1352 yyerrstatus--; 1353 1354 yystate = yyn; 1355 goto yynewstate; 1356 1357 1358/*-----------------------------------------------------------. 1359| yydefault -- do the default action for the current state. | 1360`-----------------------------------------------------------*/ 1361yydefault: 1362 yyn = yydefact[yystate]; 1363 if (yyn == 0) 1364 goto yyerrlab; 1365 goto yyreduce; 1366 1367 1368/*-----------------------------. 1369| yyreduce -- Do a reduction. | 1370`-----------------------------*/ 1371yyreduce: 1372 /* yyn is the number of a rule to reduce with. */ 1373 yylen = yyr2[yyn]; 1374 1375 /* If YYLEN is nonzero, implement the default value of the action: 1376 `$$ = $1'. 1377 1378 Otherwise, the following line sets YYVAL to garbage. 1379 This behavior is undocumented and Bison 1380 users should not rely upon it. Assigning to YYVAL 1381 unconditionally makes the parser a bit smaller, and it avoids a 1382 GCC warning that YYVAL may be used uninitialized. */ 1383 yyval = yyvsp[1-yylen]; 1384 1385 1386 YY_REDUCE_PRINT (yyn); 1387 switch (yyn) 1388 { 1389 case 4: 1390#line 210 "jv-exp.y" 1391 { 1392 write_exp_elt_opcode(OP_TYPE); 1393 write_exp_elt_type(yyvsp[0].tval); 1394 write_exp_elt_opcode(OP_TYPE); 1395 } 1396 break; 1397 1398 case 7: 1399#line 224 "jv-exp.y" 1400 { 1401 write_exp_elt_opcode (OP_STRING); 1402 write_exp_string (yyvsp[0].sval); 1403 write_exp_elt_opcode (OP_STRING); 1404 } 1405 break; 1406 1407 case 8: 1408#line 233 "jv-exp.y" 1409 { write_exp_elt_opcode (OP_LONG); 1410 write_exp_elt_type (yyvsp[0].typed_val_int.type); 1411 write_exp_elt_longcst ((LONGEST)(yyvsp[0].typed_val_int.val)); 1412 write_exp_elt_opcode (OP_LONG); } 1413 break; 1414 1415 case 9: 1416#line 238 "jv-exp.y" 1417 { YYSTYPE val; 1418 parse_number (yyvsp[0].sval.ptr, yyvsp[0].sval.length, 0, &val); 1419 write_exp_elt_opcode (OP_LONG); 1420 write_exp_elt_type (val.typed_val_int.type); 1421 write_exp_elt_longcst ((LONGEST)val.typed_val_int.val); 1422 write_exp_elt_opcode (OP_LONG); 1423 } 1424 break; 1425 1426 case 10: 1427#line 246 "jv-exp.y" 1428 { write_exp_elt_opcode (OP_DOUBLE); 1429 write_exp_elt_type (yyvsp[0].typed_val_float.type); 1430 write_exp_elt_dblcst (yyvsp[0].typed_val_float.dval); 1431 write_exp_elt_opcode (OP_DOUBLE); } 1432 break; 1433 1434 case 11: 1435#line 251 "jv-exp.y" 1436 { write_exp_elt_opcode (OP_LONG); 1437 write_exp_elt_type (java_boolean_type); 1438 write_exp_elt_longcst ((LONGEST)yyvsp[0].lval); 1439 write_exp_elt_opcode (OP_LONG); } 1440 break; 1441 1442 case 14: 1443#line 268 "jv-exp.y" 1444 { yyval.tval = java_boolean_type; } 1445 break; 1446 1447 case 17: 1448#line 278 "jv-exp.y" 1449 { yyval.tval = java_byte_type; } 1450 break; 1451 1452 case 18: 1453#line 280 "jv-exp.y" 1454 { yyval.tval = java_short_type; } 1455 break; 1456 1457 case 19: 1458#line 282 "jv-exp.y" 1459 { yyval.tval = java_int_type; } 1460 break; 1461 1462 case 20: 1463#line 284 "jv-exp.y" 1464 { yyval.tval = java_long_type; } 1465 break; 1466 1467 case 21: 1468#line 286 "jv-exp.y" 1469 { yyval.tval = java_char_type; } 1470 break; 1471 1472 case 22: 1473#line 291 "jv-exp.y" 1474 { yyval.tval = java_float_type; } 1475 break; 1476 1477 case 23: 1478#line 293 "jv-exp.y" 1479 { yyval.tval = java_double_type; } 1480 break; 1481 1482 case 24: 1483#line 305 "jv-exp.y" 1484 { yyval.tval = java_type_from_name (yyvsp[0].sval); } 1485 break; 1486 1487 case 26: 1488#line 314 "jv-exp.y" 1489 { yyval.tval = java_array_type (yyvsp[-1].tval, yyvsp[0].lval); } 1490 break; 1491 1492 case 27: 1493#line 316 "jv-exp.y" 1494 { yyval.tval = java_array_type (java_type_from_name (yyvsp[-1].sval), yyvsp[0].lval); } 1495 break; 1496 1497 case 34: 1498#line 336 "jv-exp.y" 1499 { yyval.sval.length = yyvsp[-2].sval.length + yyvsp[0].sval.length + 1; 1500 if (yyvsp[-2].sval.ptr + yyvsp[-2].sval.length + 1 == yyvsp[0].sval.ptr 1501 && yyvsp[-2].sval.ptr[yyvsp[-2].sval.length] == '.') 1502 yyval.sval.ptr = yyvsp[-2].sval.ptr; /* Optimization. */ 1503 else 1504 { 1505 yyval.sval.ptr = (char *) xmalloc (yyval.sval.length + 1); 1506 make_cleanup (free, yyval.sval.ptr); 1507 sprintf (yyval.sval.ptr, "%.*s.%.*s", 1508 yyvsp[-2].sval.length, yyvsp[-2].sval.ptr, yyvsp[0].sval.length, yyvsp[0].sval.ptr); 1509 } } 1510 break; 1511 1512 case 36: 1513#line 360 "jv-exp.y" 1514 { write_exp_elt_opcode (BINOP_COMMA); } 1515 break; 1516 1517 case 45: 1518#line 376 "jv-exp.y" 1519 { write_exp_elt_opcode (OP_ARRAY); 1520 write_exp_elt_longcst ((LONGEST) 0); 1521 write_exp_elt_longcst ((LONGEST) yyvsp[0].lval); 1522 write_exp_elt_opcode (OP_ARRAY); } 1523 break; 1524 1525 case 46: 1526#line 384 "jv-exp.y" 1527 { start_arglist (); } 1528 break; 1529 1530 case 47: 1531#line 389 "jv-exp.y" 1532 { yyval.lval = end_arglist () - 1; } 1533 break; 1534 1535 case 48: 1536#line 394 "jv-exp.y" 1537 { internal_error (__FILE__, __LINE__, 1538 _("FIXME - ClassInstanceCreationExpression")); } 1539 break; 1540 1541 case 49: 1542#line 400 "jv-exp.y" 1543 { arglist_len = 1; } 1544 break; 1545 1546 case 50: 1547#line 402 "jv-exp.y" 1548 { arglist_len++; } 1549 break; 1550 1551 case 51: 1552#line 407 "jv-exp.y" 1553 { arglist_len = 0; } 1554 break; 1555 1556 case 53: 1557#line 413 "jv-exp.y" 1558 { internal_error (__FILE__, __LINE__, 1559 _("FIXME - ArrayCreationExpression")); } 1560 break; 1561 1562 case 54: 1563#line 416 "jv-exp.y" 1564 { internal_error (__FILE__, __LINE__, 1565 _("FIXME - ArrayCreationExpression")); } 1566 break; 1567 1568 case 58: 1569#line 431 "jv-exp.y" 1570 { yyval.lval = 1; } 1571 break; 1572 1573 case 59: 1574#line 433 "jv-exp.y" 1575 { yyval.lval = yyvsp[-2].lval + 1; } 1576 break; 1577 1578 case 61: 1579#line 439 "jv-exp.y" 1580 { yyval.lval = 0; } 1581 break; 1582 1583 case 62: 1584#line 444 "jv-exp.y" 1585 { push_fieldnames (yyvsp[0].sval); } 1586 break; 1587 1588 case 63: 1589#line 446 "jv-exp.y" 1590 { push_fieldnames (yyvsp[0].sval); } 1591 break; 1592 1593 case 64: 1594#line 452 "jv-exp.y" 1595 { push_expression_name (yyvsp[-1].sval); } 1596 break; 1597 1598 case 65: 1599#line 457 "jv-exp.y" 1600 { start_arglist(); } 1601 break; 1602 1603 case 66: 1604#line 459 "jv-exp.y" 1605 { write_exp_elt_opcode (OP_FUNCALL); 1606 write_exp_elt_longcst ((LONGEST) end_arglist ()); 1607 write_exp_elt_opcode (OP_FUNCALL); } 1608 break; 1609 1610 case 67: 1611#line 463 "jv-exp.y" 1612 { error (_("Form of method invocation not implemented")); } 1613 break; 1614 1615 case 68: 1616#line 465 "jv-exp.y" 1617 { error (_("Form of method invocation not implemented")); } 1618 break; 1619 1620 case 69: 1621#line 470 "jv-exp.y" 1622 { 1623 /* Emit code for the Name now, then exchange it in the 1624 expout array with the Expression's code. We could 1625 introduce a OP_SWAP code or a reversed version of 1626 BINOP_SUBSCRIPT, but that makes the rest of GDB pay 1627 for our parsing kludges. */ 1628 struct expression *name_expr; 1629 1630 push_expression_name (yyvsp[-3].sval); 1631 name_expr = copy_exp (expout, expout_ptr); 1632 expout_ptr -= name_expr->nelts; 1633 insert_exp (expout_ptr-length_of_subexp (expout, expout_ptr), 1634 name_expr); 1635 free (name_expr); 1636 write_exp_elt_opcode (BINOP_SUBSCRIPT); 1637 } 1638 break; 1639 1640 case 70: 1641#line 487 "jv-exp.y" 1642 { write_exp_elt_opcode (BINOP_SUBSCRIPT); } 1643 break; 1644 1645 case 71: 1646#line 489 "jv-exp.y" 1647 { write_exp_elt_opcode (BINOP_SUBSCRIPT); } 1648 break; 1649 1650 case 73: 1651#line 495 "jv-exp.y" 1652 { push_expression_name (yyvsp[0].sval); } 1653 break; 1654 1655 case 77: 1656#line 504 "jv-exp.y" 1657 { write_exp_elt_opcode (UNOP_POSTINCREMENT); } 1658 break; 1659 1660 case 78: 1661#line 509 "jv-exp.y" 1662 { write_exp_elt_opcode (UNOP_POSTDECREMENT); } 1663 break; 1664 1665 case 82: 1666#line 517 "jv-exp.y" 1667 { write_exp_elt_opcode (UNOP_NEG); } 1668 break; 1669 1670 case 83: 1671#line 519 "jv-exp.y" 1672 { write_exp_elt_opcode (UNOP_IND); } 1673 break; 1674 1675 case 85: 1676#line 525 "jv-exp.y" 1677 { write_exp_elt_opcode (UNOP_PREINCREMENT); } 1678 break; 1679 1680 case 86: 1681#line 530 "jv-exp.y" 1682 { write_exp_elt_opcode (UNOP_PREDECREMENT); } 1683 break; 1684 1685 case 88: 1686#line 536 "jv-exp.y" 1687 { write_exp_elt_opcode (UNOP_COMPLEMENT); } 1688 break; 1689 1690 case 89: 1691#line 538 "jv-exp.y" 1692 { write_exp_elt_opcode (UNOP_LOGICAL_NOT); } 1693 break; 1694 1695 case 91: 1696#line 544 "jv-exp.y" 1697 { write_exp_elt_opcode (UNOP_CAST); 1698 write_exp_elt_type (java_array_type (yyvsp[-3].tval, yyvsp[-2].lval)); 1699 write_exp_elt_opcode (UNOP_CAST); } 1700 break; 1701 1702 case 92: 1703#line 548 "jv-exp.y" 1704 { 1705 int exp_size = expout_ptr; 1706 int last_exp_size = length_of_subexp(expout, expout_ptr); 1707 struct type *type; 1708 int i; 1709 int base = expout_ptr - last_exp_size - 3; 1710 if (base < 0 || expout->elts[base+2].opcode != OP_TYPE) 1711 error (_("Invalid cast expression")); 1712 type = expout->elts[base+1].type; 1713 /* Remove the 'Expression' and slide the 1714 UnaryExpressionNotPlusMinus down to replace it. */ 1715 for (i = 0; i < last_exp_size; i++) 1716 expout->elts[base + i] = expout->elts[base + i + 3]; 1717 expout_ptr -= 3; 1718 if (TYPE_CODE (type) == TYPE_CODE_STRUCT) 1719 type = lookup_pointer_type (type); 1720 write_exp_elt_opcode (UNOP_CAST); 1721 write_exp_elt_type (type); 1722 write_exp_elt_opcode (UNOP_CAST); 1723 } 1724 break; 1725 1726 case 93: 1727#line 569 "jv-exp.y" 1728 { write_exp_elt_opcode (UNOP_CAST); 1729 write_exp_elt_type (java_array_type (java_type_from_name (yyvsp[-3].sval), yyvsp[-2].lval)); 1730 write_exp_elt_opcode (UNOP_CAST); } 1731 break; 1732 1733 case 95: 1734#line 578 "jv-exp.y" 1735 { write_exp_elt_opcode (BINOP_MUL); } 1736 break; 1737 1738 case 96: 1739#line 580 "jv-exp.y" 1740 { write_exp_elt_opcode (BINOP_DIV); } 1741 break; 1742 1743 case 97: 1744#line 582 "jv-exp.y" 1745 { write_exp_elt_opcode (BINOP_REM); } 1746 break; 1747 1748 case 99: 1749#line 588 "jv-exp.y" 1750 { write_exp_elt_opcode (BINOP_ADD); } 1751 break; 1752 1753 case 100: 1754#line 590 "jv-exp.y" 1755 { write_exp_elt_opcode (BINOP_SUB); } 1756 break; 1757 1758 case 102: 1759#line 596 "jv-exp.y" 1760 { write_exp_elt_opcode (BINOP_LSH); } 1761 break; 1762 1763 case 103: 1764#line 598 "jv-exp.y" 1765 { write_exp_elt_opcode (BINOP_RSH); } 1766 break; 1767 1768 case 105: 1769#line 605 "jv-exp.y" 1770 { write_exp_elt_opcode (BINOP_LESS); } 1771 break; 1772 1773 case 106: 1774#line 607 "jv-exp.y" 1775 { write_exp_elt_opcode (BINOP_GTR); } 1776 break; 1777 1778 case 107: 1779#line 609 "jv-exp.y" 1780 { write_exp_elt_opcode (BINOP_LEQ); } 1781 break; 1782 1783 case 108: 1784#line 611 "jv-exp.y" 1785 { write_exp_elt_opcode (BINOP_GEQ); } 1786 break; 1787 1788 case 110: 1789#line 618 "jv-exp.y" 1790 { write_exp_elt_opcode (BINOP_EQUAL); } 1791 break; 1792 1793 case 111: 1794#line 620 "jv-exp.y" 1795 { write_exp_elt_opcode (BINOP_NOTEQUAL); } 1796 break; 1797 1798 case 113: 1799#line 626 "jv-exp.y" 1800 { write_exp_elt_opcode (BINOP_BITWISE_AND); } 1801 break; 1802 1803 case 115: 1804#line 632 "jv-exp.y" 1805 { write_exp_elt_opcode (BINOP_BITWISE_XOR); } 1806 break; 1807 1808 case 117: 1809#line 637 "jv-exp.y" 1810 { write_exp_elt_opcode (BINOP_BITWISE_IOR); } 1811 break; 1812 1813 case 119: 1814#line 643 "jv-exp.y" 1815 { write_exp_elt_opcode (BINOP_LOGICAL_AND); } 1816 break; 1817 1818 case 121: 1819#line 649 "jv-exp.y" 1820 { write_exp_elt_opcode (BINOP_LOGICAL_OR); } 1821 break; 1822 1823 case 123: 1824#line 655 "jv-exp.y" 1825 { write_exp_elt_opcode (TERNOP_COND); } 1826 break; 1827 1828 case 126: 1829#line 665 "jv-exp.y" 1830 { write_exp_elt_opcode (BINOP_ASSIGN); } 1831 break; 1832 1833 case 127: 1834#line 667 "jv-exp.y" 1835 { write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); 1836 write_exp_elt_opcode (yyvsp[-1].opcode); 1837 write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); } 1838 break; 1839 1840 case 128: 1841#line 674 "jv-exp.y" 1842 { push_expression_name (yyvsp[0].sval); } 1843 break; 1844 1845 1846 } 1847 1848/* Line 1000 of yacc.c. */ 1849#line 1850 "jv-exp.c.tmp" 1850 1851 yyvsp -= yylen; 1852 yyssp -= yylen; 1853 1854 1855 YY_STACK_PRINT (yyss, yyssp); 1856 1857 *++yyvsp = yyval; 1858 1859 1860 /* Now `shift' the result of the reduction. Determine what state 1861 that goes to, based on the state we popped back to and the rule 1862 number reduced by. */ 1863 1864 yyn = yyr1[yyn]; 1865 1866 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; 1867 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) 1868 yystate = yytable[yystate]; 1869 else 1870 yystate = yydefgoto[yyn - YYNTOKENS]; 1871 1872 goto yynewstate; 1873 1874 1875/*------------------------------------. 1876| yyerrlab -- here on detecting error | 1877`------------------------------------*/ 1878yyerrlab: 1879 /* If not already recovering from an error, report this error. */ 1880 if (!yyerrstatus) 1881 { 1882 ++yynerrs; 1883#if YYERROR_VERBOSE 1884 yyn = yypact[yystate]; 1885 1886 if (YYPACT_NINF < yyn && yyn < YYLAST) 1887 { 1888 YYSIZE_T yysize = 0; 1889 int yytype = YYTRANSLATE (yychar); 1890 const char* yyprefix; 1891 char *yymsg; 1892 int yyx; 1893 1894 /* Start YYX at -YYN if negative to avoid negative indexes in 1895 YYCHECK. */ 1896 int yyxbegin = yyn < 0 ? -yyn : 0; 1897 1898 /* Stay within bounds of both yycheck and yytname. */ 1899 int yychecklim = YYLAST - yyn; 1900 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; 1901 int yycount = 0; 1902 1903 yyprefix = ", expecting "; 1904 for (yyx = yyxbegin; yyx < yyxend; ++yyx) 1905 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) 1906 { 1907 yysize += yystrlen (yyprefix) + yystrlen (yytname [yyx]); 1908 yycount += 1; 1909 if (yycount == 5) 1910 { 1911 yysize = 0; 1912 break; 1913 } 1914 } 1915 yysize += (sizeof ("syntax error, unexpected ") 1916 + yystrlen (yytname[yytype])); 1917 yymsg = (char *) YYSTACK_ALLOC (yysize); 1918 if (yymsg != 0) 1919 { 1920 char *yyp = yystpcpy (yymsg, "syntax error, unexpected "); 1921 yyp = yystpcpy (yyp, yytname[yytype]); 1922 1923 if (yycount < 5) 1924 { 1925 yyprefix = ", expecting "; 1926 for (yyx = yyxbegin; yyx < yyxend; ++yyx) 1927 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) 1928 { 1929 yyp = yystpcpy (yyp, yyprefix); 1930 yyp = yystpcpy (yyp, yytname[yyx]); 1931 yyprefix = " or "; 1932 } 1933 } 1934 yyerror (yymsg); 1935 YYSTACK_FREE (yymsg); 1936 } 1937 else 1938 yyerror ("syntax error; also virtual memory exhausted"); 1939 } 1940 else 1941#endif /* YYERROR_VERBOSE */ 1942 yyerror ("syntax error"); 1943 } 1944 1945 1946 1947 if (yyerrstatus == 3) 1948 { 1949 /* If just tried and failed to reuse lookahead token after an 1950 error, discard it. */ 1951 1952 if (yychar <= YYEOF) 1953 { 1954 /* If at end of input, pop the error token, 1955 then the rest of the stack, then return failure. */ 1956 if (yychar == YYEOF) 1957 for (;;) 1958 { 1959 YYPOPSTACK; 1960 if (yyssp == yyss) 1961 YYABORT; 1962 YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp); 1963 yydestruct (yystos[*yyssp], yyvsp); 1964 } 1965 } 1966 else 1967 { 1968 YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc); 1969 yydestruct (yytoken, &yylval); 1970 yychar = YYEMPTY; 1971 1972 } 1973 } 1974 1975 /* Else will try to reuse lookahead token after shifting the error 1976 token. */ 1977 goto yyerrlab1; 1978 1979 1980/*---------------------------------------------------. 1981| yyerrorlab -- error raised explicitly by YYERROR. | 1982`---------------------------------------------------*/ 1983yyerrorlab: 1984 1985#ifdef __GNUC__ 1986 /* Pacify GCC when the user code never invokes YYERROR and the label 1987 yyerrorlab therefore never appears in user code. */ 1988 if (0) 1989 goto yyerrorlab; 1990#endif 1991 1992 yyvsp -= yylen; 1993 yyssp -= yylen; 1994 yystate = *yyssp; 1995 goto yyerrlab1; 1996 1997 1998/*-------------------------------------------------------------. 1999| yyerrlab1 -- common code for both syntax error and YYERROR. | 2000`-------------------------------------------------------------*/ 2001yyerrlab1: 2002 yyerrstatus = 3; /* Each real token shifted decrements this. */ 2003 2004 for (;;) 2005 { 2006 yyn = yypact[yystate]; 2007 if (yyn != YYPACT_NINF) 2008 { 2009 yyn += YYTERROR; 2010 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) 2011 { 2012 yyn = yytable[yyn]; 2013 if (0 < yyn) 2014 break; 2015 } 2016 } 2017 2018 /* Pop the current state because it cannot handle the error token. */ 2019 if (yyssp == yyss) 2020 YYABORT; 2021 2022 YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp); 2023 yydestruct (yystos[yystate], yyvsp); 2024 YYPOPSTACK; 2025 yystate = *yyssp; 2026 YY_STACK_PRINT (yyss, yyssp); 2027 } 2028 2029 if (yyn == YYFINAL) 2030 YYACCEPT; 2031 2032 YYDPRINTF ((stderr, "Shifting error token, ")); 2033 2034 *++yyvsp = yylval; 2035 2036 2037 yystate = yyn; 2038 goto yynewstate; 2039 2040 2041/*-------------------------------------. 2042| yyacceptlab -- YYACCEPT comes here. | 2043`-------------------------------------*/ 2044yyacceptlab: 2045 yyresult = 0; 2046 goto yyreturn; 2047 2048/*-----------------------------------. 2049| yyabortlab -- YYABORT comes here. | 2050`-----------------------------------*/ 2051yyabortlab: 2052 yyresult = 1; 2053 goto yyreturn; 2054 2055#ifndef yyoverflow 2056/*----------------------------------------------. 2057| yyoverflowlab -- parser overflow comes here. | 2058`----------------------------------------------*/ 2059yyoverflowlab: 2060 yyerror ("parser stack overflow"); 2061 yyresult = 2; 2062 /* Fall through. */ 2063#endif 2064 2065yyreturn: 2066#ifndef yyoverflow 2067 if (yyss != yyssa) 2068 YYSTACK_FREE (yyss); 2069#endif 2070 return yyresult; 2071} 2072 2073 2074#line 686 "jv-exp.y" 2075 2076/* Take care of parsing a number (anything that starts with a digit). 2077 Set yylval and return the token type; update lexptr. 2078 LEN is the number of characters in it. */ 2079 2080/*** Needs some error checking for the float case ***/ 2081 2082static int 2083parse_number (p, len, parsed_float, putithere) 2084 char *p; 2085 int len; 2086 int parsed_float; 2087 YYSTYPE *putithere; 2088{ 2089 ULONGEST n = 0; 2090 ULONGEST limit, limit_div_base; 2091 2092 int c; 2093 int base = input_radix; 2094 2095 struct type *type; 2096 2097 if (parsed_float) 2098 { 2099 /* It's a float since it contains a point or an exponent. */ 2100 char c; 2101 int num = 0; /* number of tokens scanned by scanf */ 2102 char saved_char = p[len]; 2103 2104 p[len] = 0; /* null-terminate the token */ 2105 num = sscanf (p, DOUBLEST_SCAN_FORMAT "%c", 2106 &putithere->typed_val_float.dval, &c); 2107 p[len] = saved_char; /* restore the input stream */ 2108 if (num != 1) /* check scanf found ONLY a float ... */ 2109 return ERROR; 2110 /* See if it has `f' or `d' suffix (float or double). */ 2111 2112 c = tolower (p[len - 1]); 2113 2114 if (c == 'f' || c == 'F') 2115 putithere->typed_val_float.type = builtin_type_float; 2116 else if (isdigit (c) || c == '.' || c == 'd' || c == 'D') 2117 putithere->typed_val_float.type = builtin_type_double; 2118 else 2119 return ERROR; 2120 2121 return FLOATING_POINT_LITERAL; 2122 } 2123 2124 /* Handle base-switching prefixes 0x, 0t, 0d, 0 */ 2125 if (p[0] == '0') 2126 switch (p[1]) 2127 { 2128 case 'x': 2129 case 'X': 2130 if (len >= 3) 2131 { 2132 p += 2; 2133 base = 16; 2134 len -= 2; 2135 } 2136 break; 2137 2138 case 't': 2139 case 'T': 2140 case 'd': 2141 case 'D': 2142 if (len >= 3) 2143 { 2144 p += 2; 2145 base = 10; 2146 len -= 2; 2147 } 2148 break; 2149 2150 default: 2151 base = 8; 2152 break; 2153 } 2154 2155 c = p[len-1]; 2156 /* A paranoid calculation of (1<<64)-1. */ 2157 limit = (ULONGEST)0xffffffff; 2158 limit = ((limit << 16) << 16) | limit; 2159 if (c == 'l' || c == 'L') 2160 { 2161 type = java_long_type; 2162 len--; 2163 } 2164 else 2165 { 2166 type = java_int_type; 2167 } 2168 limit_div_base = limit / (ULONGEST) base; 2169 2170 while (--len >= 0) 2171 { 2172 c = *p++; 2173 if (c >= '0' && c <= '9') 2174 c -= '0'; 2175 else if (c >= 'A' && c <= 'Z') 2176 c -= 'A' - 10; 2177 else if (c >= 'a' && c <= 'z') 2178 c -= 'a' - 10; 2179 else 2180 return ERROR; /* Char not a digit */ 2181 if (c >= base) 2182 return ERROR; 2183 if (n > limit_div_base 2184 || (n *= base) > limit - c) 2185 error (_("Numeric constant too large")); 2186 n += c; 2187 } 2188 2189 /* If the type is bigger than a 32-bit signed integer can be, implicitly 2190 promote to long. Java does not do this, so mark it as builtin_type_uint64 2191 rather than java_long_type. 0x80000000 will become -0x80000000 instead 2192 of 0x80000000L, because we don't know the sign at this point. 2193 */ 2194 if (type == java_int_type && n > (ULONGEST)0x80000000) 2195 type = builtin_type_uint64; 2196 2197 putithere->typed_val_int.val = n; 2198 putithere->typed_val_int.type = type; 2199 2200 return INTEGER_LITERAL; 2201} 2202 2203struct token 2204{ 2205 char *operator; 2206 int token; 2207 enum exp_opcode opcode; 2208}; 2209 2210static const struct token tokentab3[] = 2211 { 2212 {">>=", ASSIGN_MODIFY, BINOP_RSH}, 2213 {"<<=", ASSIGN_MODIFY, BINOP_LSH} 2214 }; 2215 2216static const struct token tokentab2[] = 2217 { 2218 {"+=", ASSIGN_MODIFY, BINOP_ADD}, 2219 {"-=", ASSIGN_MODIFY, BINOP_SUB}, 2220 {"*=", ASSIGN_MODIFY, BINOP_MUL}, 2221 {"/=", ASSIGN_MODIFY, BINOP_DIV}, 2222 {"%=", ASSIGN_MODIFY, BINOP_REM}, 2223 {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR}, 2224 {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND}, 2225 {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR}, 2226 {"++", INCREMENT, BINOP_END}, 2227 {"--", DECREMENT, BINOP_END}, 2228 {"&&", ANDAND, BINOP_END}, 2229 {"||", OROR, BINOP_END}, 2230 {"<<", LSH, BINOP_END}, 2231 {">>", RSH, BINOP_END}, 2232 {"==", EQUAL, BINOP_END}, 2233 {"!=", NOTEQUAL, BINOP_END}, 2234 {"<=", LEQ, BINOP_END}, 2235 {">=", GEQ, BINOP_END} 2236 }; 2237 2238/* Read one token, getting characters through lexptr. */ 2239 2240static int 2241yylex () 2242{ 2243 int c; 2244 int namelen; 2245 unsigned int i; 2246 char *tokstart; 2247 char *tokptr; 2248 int tempbufindex; 2249 static char *tempbuf; 2250 static int tempbufsize; 2251 2252 retry: 2253 2254 prev_lexptr = lexptr; 2255 2256 tokstart = lexptr; 2257 /* See if it is a special token of length 3. */ 2258 for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++) 2259 if (strncmp (tokstart, tokentab3[i].operator, 3) == 0) 2260 { 2261 lexptr += 3; 2262 yylval.opcode = tokentab3[i].opcode; 2263 return tokentab3[i].token; 2264 } 2265 2266 /* See if it is a special token of length 2. */ 2267 for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++) 2268 if (strncmp (tokstart, tokentab2[i].operator, 2) == 0) 2269 { 2270 lexptr += 2; 2271 yylval.opcode = tokentab2[i].opcode; 2272 return tokentab2[i].token; 2273 } 2274 2275 switch (c = *tokstart) 2276 { 2277 case 0: 2278 return 0; 2279 2280 case ' ': 2281 case '\t': 2282 case '\n': 2283 lexptr++; 2284 goto retry; 2285 2286 case '\'': 2287 /* We either have a character constant ('0' or '\177' for example) 2288 or we have a quoted symbol reference ('foo(int,int)' in C++ 2289 for example). */ 2290 lexptr++; 2291 c = *lexptr++; 2292 if (c == '\\') 2293 c = parse_escape (&lexptr); 2294 else if (c == '\'') 2295 error (_("Empty character constant")); 2296 2297 yylval.typed_val_int.val = c; 2298 yylval.typed_val_int.type = java_char_type; 2299 2300 c = *lexptr++; 2301 if (c != '\'') 2302 { 2303 namelen = skip_quoted (tokstart) - tokstart; 2304 if (namelen > 2) 2305 { 2306 lexptr = tokstart + namelen; 2307 if (lexptr[-1] != '\'') 2308 error (_("Unmatched single quote")); 2309 namelen -= 2; 2310 tokstart++; 2311 goto tryname; 2312 } 2313 error (_("Invalid character constant")); 2314 } 2315 return INTEGER_LITERAL; 2316 2317 case '(': 2318 paren_depth++; 2319 lexptr++; 2320 return c; 2321 2322 case ')': 2323 if (paren_depth == 0) 2324 return 0; 2325 paren_depth--; 2326 lexptr++; 2327 return c; 2328 2329 case ',': 2330 if (comma_terminates && paren_depth == 0) 2331 return 0; 2332 lexptr++; 2333 return c; 2334 2335 case '.': 2336 /* Might be a floating point number. */ 2337 if (lexptr[1] < '0' || lexptr[1] > '9') 2338 goto symbol; /* Nope, must be a symbol. */ 2339 /* FALL THRU into number case. */ 2340 2341 case '0': 2342 case '1': 2343 case '2': 2344 case '3': 2345 case '4': 2346 case '5': 2347 case '6': 2348 case '7': 2349 case '8': 2350 case '9': 2351 { 2352 /* It's a number. */ 2353 int got_dot = 0, got_e = 0, toktype; 2354 char *p = tokstart; 2355 int hex = input_radix > 10; 2356 2357 if (c == '0' && (p[1] == 'x' || p[1] == 'X')) 2358 { 2359 p += 2; 2360 hex = 1; 2361 } 2362 else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D')) 2363 { 2364 p += 2; 2365 hex = 0; 2366 } 2367 2368 for (;; ++p) 2369 { 2370 /* This test includes !hex because 'e' is a valid hex digit 2371 and thus does not indicate a floating point number when 2372 the radix is hex. */ 2373 if (!hex && !got_e && (*p == 'e' || *p == 'E')) 2374 got_dot = got_e = 1; 2375 /* This test does not include !hex, because a '.' always indicates 2376 a decimal floating point number regardless of the radix. */ 2377 else if (!got_dot && *p == '.') 2378 got_dot = 1; 2379 else if (got_e && (p[-1] == 'e' || p[-1] == 'E') 2380 && (*p == '-' || *p == '+')) 2381 /* This is the sign of the exponent, not the end of the 2382 number. */ 2383 continue; 2384 /* We will take any letters or digits. parse_number will 2385 complain if past the radix, or if L or U are not final. */ 2386 else if ((*p < '0' || *p > '9') 2387 && ((*p < 'a' || *p > 'z') 2388 && (*p < 'A' || *p > 'Z'))) 2389 break; 2390 } 2391 toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval); 2392 if (toktype == ERROR) 2393 { 2394 char *err_copy = (char *) alloca (p - tokstart + 1); 2395 2396 memcpy (err_copy, tokstart, p - tokstart); 2397 err_copy[p - tokstart] = 0; 2398 error (_("Invalid number \"%s\""), err_copy); 2399 } 2400 lexptr = p; 2401 return toktype; 2402 } 2403 2404 case '+': 2405 case '-': 2406 case '*': 2407 case '/': 2408 case '%': 2409 case '|': 2410 case '&': 2411 case '^': 2412 case '~': 2413 case '!': 2414 case '<': 2415 case '>': 2416 case '[': 2417 case ']': 2418 case '?': 2419 case ':': 2420 case '=': 2421 case '{': 2422 case '}': 2423 symbol: 2424 lexptr++; 2425 return c; 2426 2427 case '"': 2428 2429 /* Build the gdb internal form of the input string in tempbuf, 2430 translating any standard C escape forms seen. Note that the 2431 buffer is null byte terminated *only* for the convenience of 2432 debugging gdb itself and printing the buffer contents when 2433 the buffer contains no embedded nulls. Gdb does not depend 2434 upon the buffer being null byte terminated, it uses the length 2435 string instead. This allows gdb to handle C strings (as well 2436 as strings in other languages) with embedded null bytes */ 2437 2438 tokptr = ++tokstart; 2439 tempbufindex = 0; 2440 2441 do { 2442 /* Grow the static temp buffer if necessary, including allocating 2443 the first one on demand. */ 2444 if (tempbufindex + 1 >= tempbufsize) 2445 { 2446 tempbuf = (char *) xrealloc (tempbuf, tempbufsize += 64); 2447 } 2448 switch (*tokptr) 2449 { 2450 case '\0': 2451 case '"': 2452 /* Do nothing, loop will terminate. */ 2453 break; 2454 case '\\': 2455 tokptr++; 2456 c = parse_escape (&tokptr); 2457 if (c == -1) 2458 { 2459 continue; 2460 } 2461 tempbuf[tempbufindex++] = c; 2462 break; 2463 default: 2464 tempbuf[tempbufindex++] = *tokptr++; 2465 break; 2466 } 2467 } while ((*tokptr != '"') && (*tokptr != '\0')); 2468 if (*tokptr++ != '"') 2469 { 2470 error (_("Unterminated string in expression")); 2471 } 2472 tempbuf[tempbufindex] = '\0'; /* See note above */ 2473 yylval.sval.ptr = tempbuf; 2474 yylval.sval.length = tempbufindex; 2475 lexptr = tokptr; 2476 return (STRING_LITERAL); 2477 } 2478 2479 if (!(c == '_' || c == '$' 2480 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))) 2481 /* We must have come across a bad character (e.g. ';'). */ 2482 error (_("Invalid character '%c' in expression"), c); 2483 2484 /* It's a name. See how long it is. */ 2485 namelen = 0; 2486 for (c = tokstart[namelen]; 2487 (c == '_' 2488 || c == '$' 2489 || (c >= '0' && c <= '9') 2490 || (c >= 'a' && c <= 'z') 2491 || (c >= 'A' && c <= 'Z') 2492 || c == '<'); 2493 ) 2494 { 2495 if (c == '<') 2496 { 2497 int i = namelen; 2498 while (tokstart[++i] && tokstart[i] != '>'); 2499 if (tokstart[i] == '>') 2500 namelen = i; 2501 } 2502 c = tokstart[++namelen]; 2503 } 2504 2505 /* The token "if" terminates the expression and is NOT 2506 removed from the input stream. */ 2507 if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f') 2508 { 2509 return 0; 2510 } 2511 2512 lexptr += namelen; 2513 2514 tryname: 2515 2516 /* Catch specific keywords. Should be done with a data structure. */ 2517 switch (namelen) 2518 { 2519 case 7: 2520 if (DEPRECATED_STREQN (tokstart, "boolean", 7)) 2521 return BOOLEAN; 2522 break; 2523 case 6: 2524 if (DEPRECATED_STREQN (tokstart, "double", 6)) 2525 return DOUBLE; 2526 break; 2527 case 5: 2528 if (DEPRECATED_STREQN (tokstart, "short", 5)) 2529 return SHORT; 2530 if (DEPRECATED_STREQN (tokstart, "false", 5)) 2531 { 2532 yylval.lval = 0; 2533 return BOOLEAN_LITERAL; 2534 } 2535 if (DEPRECATED_STREQN (tokstart, "super", 5)) 2536 return SUPER; 2537 if (DEPRECATED_STREQN (tokstart, "float", 5)) 2538 return FLOAT; 2539 break; 2540 case 4: 2541 if (DEPRECATED_STREQN (tokstart, "long", 4)) 2542 return LONG; 2543 if (DEPRECATED_STREQN (tokstart, "byte", 4)) 2544 return BYTE; 2545 if (DEPRECATED_STREQN (tokstart, "char", 4)) 2546 return CHAR; 2547 if (DEPRECATED_STREQN (tokstart, "true", 4)) 2548 { 2549 yylval.lval = 1; 2550 return BOOLEAN_LITERAL; 2551 } 2552 break; 2553 case 3: 2554 if (strncmp (tokstart, "int", 3) == 0) 2555 return INT; 2556 if (strncmp (tokstart, "new", 3) == 0) 2557 return NEW; 2558 break; 2559 default: 2560 break; 2561 } 2562 2563 yylval.sval.ptr = tokstart; 2564 yylval.sval.length = namelen; 2565 2566 if (*tokstart == '$') 2567 { 2568 write_dollar_variable (yylval.sval); 2569 return VARIABLE; 2570 } 2571 2572 /* Input names that aren't symbols but ARE valid hex numbers, 2573 when the input radix permits them, can be names or numbers 2574 depending on the parse. Note we support radixes > 16 here. */ 2575 if (((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10) || 2576 (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10))) 2577 { 2578 YYSTYPE newlval; /* Its value is ignored. */ 2579 int hextype = parse_number (tokstart, namelen, 0, &newlval); 2580 if (hextype == INTEGER_LITERAL) 2581 return NAME_OR_INT; 2582 } 2583 return IDENTIFIER; 2584} 2585 2586void 2587yyerror (msg) 2588 char *msg; 2589{ 2590 if (prev_lexptr) 2591 lexptr = prev_lexptr; 2592 2593 if (msg) 2594 error (_("%s: near `%s'"), msg, lexptr); 2595 else 2596 error (_("error in expression, near `%s'"), lexptr); 2597} 2598 2599static struct type * 2600java_type_from_name (name) 2601 struct stoken name; 2602 2603{ 2604 char *tmp = copy_name (name); 2605 struct type *typ = java_lookup_class (tmp); 2606 if (typ == NULL || TYPE_CODE (typ) != TYPE_CODE_STRUCT) 2607 error (_("No class named `%s'"), tmp); 2608 return typ; 2609} 2610 2611/* If NAME is a valid variable name in this scope, push it and return 1. 2612 Otherwise, return 0. */ 2613 2614static int 2615push_variable (struct stoken name) 2616{ 2617 char *tmp = copy_name (name); 2618 int is_a_field_of_this = 0; 2619 struct symbol *sym; 2620 sym = lookup_symbol (tmp, expression_context_block, VAR_DOMAIN, 2621 &is_a_field_of_this, (struct symtab **) NULL); 2622 if (sym && SYMBOL_CLASS (sym) != LOC_TYPEDEF) 2623 { 2624 if (symbol_read_needs_frame (sym)) 2625 { 2626 if (innermost_block == 0 || 2627 contained_in (block_found, innermost_block)) 2628 innermost_block = block_found; 2629 } 2630 2631 write_exp_elt_opcode (OP_VAR_VALUE); 2632 /* We want to use the selected frame, not another more inner frame 2633 which happens to be in the same block. */ 2634 write_exp_elt_block (NULL); 2635 write_exp_elt_sym (sym); 2636 write_exp_elt_opcode (OP_VAR_VALUE); 2637 return 1; 2638 } 2639 if (is_a_field_of_this) 2640 { 2641 /* it hangs off of `this'. Must not inadvertently convert from a 2642 method call to data ref. */ 2643 if (innermost_block == 0 || 2644 contained_in (block_found, innermost_block)) 2645 innermost_block = block_found; 2646 write_exp_elt_opcode (OP_THIS); 2647 write_exp_elt_opcode (OP_THIS); 2648 write_exp_elt_opcode (STRUCTOP_PTR); 2649 write_exp_string (name); 2650 write_exp_elt_opcode (STRUCTOP_PTR); 2651 return 1; 2652 } 2653 return 0; 2654} 2655 2656/* Assuming a reference expression has been pushed, emit the 2657 STRUCTOP_PTR ops to access the field named NAME. If NAME is a 2658 qualified name (has '.'), generate a field access for each part. */ 2659 2660static void 2661push_fieldnames (name) 2662 struct stoken name; 2663{ 2664 int i; 2665 struct stoken token; 2666 token.ptr = name.ptr; 2667 for (i = 0; ; i++) 2668 { 2669 if (i == name.length || name.ptr[i] == '.') 2670 { 2671 /* token.ptr is start of current field name. */ 2672 token.length = &name.ptr[i] - token.ptr; 2673 write_exp_elt_opcode (STRUCTOP_PTR); 2674 write_exp_string (token); 2675 write_exp_elt_opcode (STRUCTOP_PTR); 2676 token.ptr += token.length + 1; 2677 } 2678 if (i >= name.length) 2679 break; 2680 } 2681} 2682 2683/* Helper routine for push_expression_name. 2684 Handle a qualified name, where DOT_INDEX is the index of the first '.' */ 2685 2686static void 2687push_qualified_expression_name (struct stoken name, int dot_index) 2688{ 2689 struct stoken token; 2690 char *tmp; 2691 struct type *typ; 2692 2693 token.ptr = name.ptr; 2694 token.length = dot_index; 2695 2696 if (push_variable (token)) 2697 { 2698 token.ptr = name.ptr + dot_index + 1; 2699 token.length = name.length - dot_index - 1; 2700 push_fieldnames (token); 2701 return; 2702 } 2703 2704 token.ptr = name.ptr; 2705 for (;;) 2706 { 2707 token.length = dot_index; 2708 tmp = copy_name (token); 2709 typ = java_lookup_class (tmp); 2710 if (typ != NULL) 2711 { 2712 if (dot_index == name.length) 2713 { 2714 write_exp_elt_opcode(OP_TYPE); 2715 write_exp_elt_type(typ); 2716 write_exp_elt_opcode(OP_TYPE); 2717 return; 2718 } 2719 dot_index++; /* Skip '.' */ 2720 name.ptr += dot_index; 2721 name.length -= dot_index; 2722 dot_index = 0; 2723 while (dot_index < name.length && name.ptr[dot_index] != '.') 2724 dot_index++; 2725 token.ptr = name.ptr; 2726 token.length = dot_index; 2727 write_exp_elt_opcode (OP_SCOPE); 2728 write_exp_elt_type (typ); 2729 write_exp_string (token); 2730 write_exp_elt_opcode (OP_SCOPE); 2731 if (dot_index < name.length) 2732 { 2733 dot_index++; 2734 name.ptr += dot_index; 2735 name.length -= dot_index; 2736 push_fieldnames (name); 2737 } 2738 return; 2739 } 2740 else if (dot_index >= name.length) 2741 break; 2742 dot_index++; /* Skip '.' */ 2743 while (dot_index < name.length && name.ptr[dot_index] != '.') 2744 dot_index++; 2745 } 2746 error (_("unknown type `%.*s'"), name.length, name.ptr); 2747} 2748 2749/* Handle Name in an expression (or LHS). 2750 Handle VAR, TYPE, TYPE.FIELD1....FIELDN and VAR.FIELD1....FIELDN. */ 2751 2752static void 2753push_expression_name (name) 2754 struct stoken name; 2755{ 2756 char *tmp; 2757 struct type *typ; 2758 char *ptr; 2759 int i; 2760 2761 for (i = 0; i < name.length; i++) 2762 { 2763 if (name.ptr[i] == '.') 2764 { 2765 /* It's a Qualified Expression Name. */ 2766 push_qualified_expression_name (name, i); 2767 return; 2768 } 2769 } 2770 2771 /* It's a Simple Expression Name. */ 2772 2773 if (push_variable (name)) 2774 return; 2775 tmp = copy_name (name); 2776 typ = java_lookup_class (tmp); 2777 if (typ != NULL) 2778 { 2779 write_exp_elt_opcode(OP_TYPE); 2780 write_exp_elt_type(typ); 2781 write_exp_elt_opcode(OP_TYPE); 2782 } 2783 else 2784 { 2785 struct minimal_symbol *msymbol; 2786 2787 msymbol = lookup_minimal_symbol (tmp, NULL, NULL); 2788 if (msymbol != NULL) 2789 { 2790 write_exp_msymbol (msymbol, 2791 lookup_function_type (builtin_type_int), 2792 builtin_type_int); 2793 } 2794 else if (!have_full_symbols () && !have_partial_symbols ()) 2795 error (_("No symbol table is loaded. Use the \"file\" command")); 2796 else 2797 error (_("No symbol \"%s\" in current context"), tmp); 2798 } 2799 2800} 2801 2802 2803/* The following two routines, copy_exp and insert_exp, aren't specific to 2804 Java, so they could go in parse.c, but their only purpose is to support 2805 the parsing kludges we use in this file, so maybe it's best to isolate 2806 them here. */ 2807 2808/* Copy the expression whose last element is at index ENDPOS - 1 in EXPR 2809 into a freshly xmalloc'ed struct expression. Its language_defn is set 2810 to null. */ 2811static struct expression * 2812copy_exp (expr, endpos) 2813 struct expression *expr; 2814 int endpos; 2815{ 2816 int len = length_of_subexp (expr, endpos); 2817 struct expression *new 2818 = (struct expression *) xmalloc (sizeof (*new) + EXP_ELEM_TO_BYTES (len)); 2819 new->nelts = len; 2820 memcpy (new->elts, expr->elts + endpos - len, EXP_ELEM_TO_BYTES (len)); 2821 new->language_defn = 0; 2822 2823 return new; 2824} 2825 2826/* Insert the expression NEW into the current expression (expout) at POS. */ 2827static void 2828insert_exp (pos, new) 2829 int pos; 2830 struct expression *new; 2831{ 2832 int newlen = new->nelts; 2833 2834 /* Grow expout if necessary. In this function's only use at present, 2835 this should never be necessary. */ 2836 if (expout_ptr + newlen > expout_size) 2837 { 2838 expout_size = max (expout_size * 2, expout_ptr + newlen + 10); 2839 expout = (struct expression *) 2840 xrealloc ((char *) expout, (sizeof (struct expression) 2841 + EXP_ELEM_TO_BYTES (expout_size))); 2842 } 2843 2844 { 2845 int i; 2846 2847 for (i = expout_ptr - 1; i >= pos; i--) 2848 expout->elts[i + newlen] = expout->elts[i]; 2849 } 2850 2851 memcpy (expout->elts + pos, new->elts, EXP_ELEM_TO_BYTES (newlen)); 2852 expout_ptr += newlen; 2853} 2854 2855 2856