?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Sync usage with man page.
[netbsd-mini2440.git] / gnu / dist / gdb6 / gdb / jv-exp.c
blobaea50440b98fb37a2c813824fbf06aeeee4d79c0
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
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 128 "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 #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 */
256 static 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. */
306 union 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. */
385 static 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. */
421 static 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. */
440 static 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. */
484 static 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. */
506 static 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. */
539 static 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. */
551 static 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. */
570 static 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. */
591 static 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]. */
617 static 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
630 static 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]. */
656 static 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
671 static 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
713 static 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. */
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 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) \
817 do \
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 } \
831 while (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) \
864 do { \
865 if (yydebug) \
866 YYFPRINTF Args; \
867 } while (0)
868
869 # define YYDSYMPRINT(Args) \
870 do { \
871 if (yydebug) \
872 yysymprint Args; \
873 } while (0)
874
875 # define YYDSYMPRINTF(Title, Token, Value, Location) \
876 do { \
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)
892 static void
893 yy_stack_print (short *bottom, short *top)
894 #else
895 static void
896 yy_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) \
908 do { \
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)
919 static void
920 yy_reduce_print (int yyrule)
921 #else
922 static void
923 yy_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) \
938 do { \
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. */
945 int 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 \f
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. */
984 static YYSIZE_T
985 # if defined (__STDC__) || defined (__cplusplus)
986 yystrlen (const char *yystr)
987 # else
988 yystrlen (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. */
1008 static char *
1009 # if defined (__STDC__) || defined (__cplusplus)
1010 yystpcpy (char *yydest, const char *yysrc)
1011 # else
1012 yystpcpy (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 \f
1031
1032 #if YYDEBUG
1033 /*--------------------------------.
1034 | Print this symbol on YYOUTPUT. |
1035 `--------------------------------*/
1036
1037 #if defined (__STDC__) || defined (__cplusplus)
1038 static void
1039 yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
1040 #else
1041 static void
1042 yysymprint (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)
1075 static void
1076 yydestruct (int yytype, YYSTYPE *yyvaluep)
1077 #else
1078 static void
1079 yydestruct (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 \f
1095
1096 /* Prevent warnings from -Wmissing-prototypes. */
1097
1098 #ifdef YYPARSE_PARAM
1099 # if defined (__STDC__) || defined (__cplusplus)
1100 int yyparse (void *YYPARSE_PARAM);
1101 # else
1102 int yyparse ();
1103 # endif
1104 #else /* ! YYPARSE_PARAM */
1105 #if defined (__STDC__) || defined (__cplusplus)
1106 int yyparse (void);
1107 #else
1108 int yyparse ();
1109 #endif
1110 #endif /* ! YYPARSE_PARAM */
1111
1112
1113
1114 /* The lookahead symbol. */
1115 int yychar;
1116
1117 /* The semantic value of the lookahead symbol. */
1118 YYSTYPE yylval;
1119
1120 /* Number of syntax errors so far. */
1121 int yynerrs;
1122
1123
1124
1125 /*----------.
1126 | yyparse. |
1127 `----------*/
1128
1129 #ifdef YYPARSE_PARAM
1130 # if defined (__STDC__) || defined (__cplusplus)
1131 int yyparse (void *YYPARSE_PARAM)
1132 # else
1133 int yyparse (YYPARSE_PARAM)
1134 void *YYPARSE_PARAM;
1135 # endif
1136 #else /* ! YYPARSE_PARAM */
1137 #if defined (__STDC__) || defined (__cplusplus)
1138 int
1139 yyparse (void)
1140 #else
1141 int
1142 yyparse ()
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 `-----------*/
1290 yybackup:
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 `-----------------------------------------------------------*/
1361 yydefault:
1362 yyn = yydefact[yystate];
1363 if (yyn == 0)
1364 goto yyerrlab;
1365 goto yyreduce;
1366
1367
1368 /*-----------------------------.
1369 | yyreduce -- Do a reduction. |
1370 `-----------------------------*/
1371 yyreduce:
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 \f
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 `------------------------------------*/
1878 yyerrlab:
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 `---------------------------------------------------*/
1983 yyerrorlab:
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 `-------------------------------------------------------------*/
2001 yyerrlab1:
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 `-------------------------------------*/
2044 yyacceptlab:
2045 yyresult = 0;
2046 goto yyreturn;
2047
2048 /*-----------------------------------.
2049 | yyabortlab -- YYABORT comes here. |
2050 `-----------------------------------*/
2051 yyabortlab:
2052 yyresult = 1;
2053 goto yyreturn;
2054
2055 #ifndef yyoverflow
2056 /*----------------------------------------------.
2057 | yyoverflowlab -- parser overflow comes here. |
2058 `----------------------------------------------*/
2059 yyoverflowlab:
2060 yyerror ("parser stack overflow");
2061 yyresult = 2;
2062 /* Fall through. */
2063 #endif
2064
2065 yyreturn:
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
2082 static int
2083 parse_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
2203 struct token
2204 {
2205 char *operator;
2206 int token;
2207 enum exp_opcode opcode;
2208 };
2209
2210 static const struct token tokentab3[] =
2211 {
2212 {">>=", ASSIGN_MODIFY, BINOP_RSH},
2213 {"<<=", ASSIGN_MODIFY, BINOP_LSH}
2214 };
2215
2216 static 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
2240 static int
2241 yylex ()
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
2586 void
2587 yyerror (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
2599 static struct type *
2600 java_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
2614 static int
2615 push_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_STRUCT ops to access the field named NAME. If NAME is a
2658 qualified name (has '.'), generate a field access for each part. */
2659
2660 static void
2661 push_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_STRUCT);
2674 write_exp_string (token);
2675 write_exp_elt_opcode (STRUCTOP_STRUCT);
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
2686 static void
2687 push_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
2752 static void
2753 push_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. */
2811 static struct expression *
2812 copy_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. */
2827 static void
2828 insert_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
NetBSD on the FriendlyARM MINI2440