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