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