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 INT = 258,
57 HEX = 259,
58 ERROR = 260,
59 UINT = 261,
60 M2_TRUE = 262,
61 M2_FALSE = 263,
62 CHAR = 264,
63 FLOAT = 265,
64 STRING = 266,
65 NAME = 267,
66 BLOCKNAME = 268,
67 IDENT = 269,
68 VARNAME = 270,
69 TYPENAME = 271,
70 SIZE = 272,
71 CAP = 273,
72 ORD = 274,
73 HIGH = 275,
74 ABS = 276,
75 MIN_FUNC = 277,
76 MAX_FUNC = 278,
77 FLOAT_FUNC = 279,
78 VAL = 280,
79 CHR = 281,
80 ODD = 282,
81 TRUNC = 283,
82 INC = 284,
83 DEC = 285,
84 INCL = 286,
85 EXCL = 287,
86 COLONCOLON = 288,
87 INTERNAL_VAR = 289,
88 ABOVE_COMMA = 290,
89 ASSIGN = 291,
90 IN = 292,
91 NOTEQUAL = 293,
92 GEQ = 294,
93 LEQ = 295,
94 OROR = 296,
95 LOGICAL_AND = 297,
96 MOD = 298,
97 DIV = 299,
98 UNARY = 300,
99 DOT = 301,
100 NOT = 302,
101 QID = 303
102 };
103 #endif
104 #define INT 258
105 #define HEX 259
106 #define ERROR 260
107 #define UINT 261
108 #define M2_TRUE 262
109 #define M2_FALSE 263
110 #define CHAR 264
111 #define FLOAT 265
112 #define STRING 266
113 #define NAME 267
114 #define BLOCKNAME 268
115 #define IDENT 269
116 #define VARNAME 270
117 #define TYPENAME 271
118 #define SIZE 272
119 #define CAP 273
120 #define ORD 274
121 #define HIGH 275
122 #define ABS 276
123 #define MIN_FUNC 277
124 #define MAX_FUNC 278
125 #define FLOAT_FUNC 279
126 #define VAL 280
127 #define CHR 281
128 #define ODD 282
129 #define TRUNC 283
130 #define INC 284
131 #define DEC 285
132 #define INCL 286
133 #define EXCL 287
134 #define COLONCOLON 288
135 #define INTERNAL_VAR 289
136 #define ABOVE_COMMA 290
137 #define ASSIGN 291
138 #define IN 292
139 #define NOTEQUAL 293
140 #define GEQ 294
141 #define LEQ 295
142 #define OROR 296
143 #define LOGICAL_AND 297
144 #define MOD 298
145 #define DIV 299
146 #define UNARY 300
147 #define DOT 301
148 #define NOT 302
149 #define QID 303
150
151
152
153
154 /* Copy the first part of user declarations. */
155 #line 41 "m2-exp.y"
156
157
158 #include "defs.h"
159 #include "gdb_string.h"
160 #include "expression.h"
161 #include "language.h"
162 #include "value.h"
163 #include "parser-defs.h"
164 #include "m2-lang.h"
165 #include "bfd.h" /* Required by objfiles.h. */
166 #include "symfile.h" /* Required by objfiles.h. */
167 #include "objfiles.h" /* For have_full_symbols and have_partial_symbols */
168 #include "block.h"
169
170 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc),
171 as well as gratuitiously global symbol names, so we can have multiple
172 yacc generated parsers in gdb. Note that these are only the variables
173 produced by yacc. If other parser generators (bison, byacc, etc) produce
174 additional global names that conflict at link time, then those parser
175 generators need to be fixed instead of adding those names to this list. */
176
177 #define yymaxdepth m2_maxdepth
178 #define yyparse m2_parse
179 #define yylex m2_lex
180 #define yyerror m2_error
181 #define yylval m2_lval
182 #define yychar m2_char
183 #define yydebug m2_debug
184 #define yypact m2_pact
185 #define yyr1 m2_r1
186 #define yyr2 m2_r2
187 #define yydef m2_def
188 #define yychk m2_chk
189 #define yypgo m2_pgo
190 #define yyact m2_act
191 #define yyexca m2_exca
192 #define yyerrflag m2_errflag
193 #define yynerrs m2_nerrs
194 #define yyps m2_ps
195 #define yypv m2_pv
196 #define yys m2_s
197 #define yy_yys m2_yys
198 #define yystate m2_state
199 #define yytmp m2_tmp
200 #define yyv m2_v
201 #define yy_yyv m2_yyv
202 #define yyval m2_val
203 #define yylloc m2_lloc
204 #define yyreds m2_reds /* With YYDEBUG defined */
205 #define yytoks m2_toks /* With YYDEBUG defined */
206 #define yyname m2_name /* With YYDEBUG defined */
207 #define yyrule m2_rule /* With YYDEBUG defined */
208 #define yylhs m2_yylhs
209 #define yylen m2_yylen
210 #define yydefred m2_yydefred
211 #define yydgoto m2_yydgoto
212 #define yysindex m2_yysindex
213 #define yyrindex m2_yyrindex
214 #define yygindex m2_yygindex
215 #define yytable m2_yytable
216 #define yycheck m2_yycheck
217
218 #ifndef YYDEBUG
219 #define YYDEBUG 1 /* Default to yydebug support */
220 #endif
221
222 #define YYFPRINTF parser_fprintf
223
224 int yyparse (void);
225
226 static int yylex (void);
227
228 void yyerror (char *);
229
230 #if 0
231 static char *make_qualname (char *, char *);
232 #endif
233
234 static int parse_number (int);
235
236 /* The sign of the number being parsed. */
237 static int number_sign = 1;
238
239 /* The block that the module specified by the qualifer on an identifer is
240 contained in, */
241 #if 0
242 static struct block *modblock=0;
243 #endif
244
245
246
247 /* Enabling traces. */
248 #ifndef YYDEBUG
249 # define YYDEBUG 0
250 #endif
251
252 /* Enabling verbose error messages. */
253 #ifdef YYERROR_VERBOSE
254 # undef YYERROR_VERBOSE
255 # define YYERROR_VERBOSE 1
256 #else
257 # define YYERROR_VERBOSE 0
258 #endif
259
260 #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
261 #line 137 "m2-exp.y"
262 typedef union YYSTYPE {
263 LONGEST lval;
264 ULONGEST ulval;
265 DOUBLEST dval;
266 struct symbol *sym;
267 struct type *tval;
268 struct stoken sval;
269 int voidval;
270 struct block *bval;
271 enum exp_opcode opcode;
272 struct internalvar *ivar;
273
274 struct type **tvec;
275 int *ivec;
276 } YYSTYPE;
277 /* Line 191 of yacc.c. */
278 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
279 # define YYSTYPE_IS_DECLARED 1
280 # define YYSTYPE_IS_TRIVIAL 1
281 #endif
282
283
284
285 /* Copy the second part of user declarations. */
286
287
288 /* Line 214 of yacc.c. */
289
290 #if ! defined (yyoverflow) || YYERROR_VERBOSE
291
292 # ifndef YYFREE
293 # define YYFREE free
294 # endif
295 # ifndef YYMALLOC
296 # define YYMALLOC xmalloc
297 # endif
298
299 /* The parser invokes alloca or xmalloc; define the necessary symbols. */
300
301 # ifdef YYSTACK_USE_ALLOCA
302 # if YYSTACK_USE_ALLOCA
303 # define YYSTACK_ALLOC alloca
304 # endif
305 # else
306 # if defined (alloca) || defined (_ALLOCA_H)
307 # define YYSTACK_ALLOC alloca
308 # else
309 # ifdef __GNUC__
310 # define YYSTACK_ALLOC __builtin_alloca
311 # endif
312 # endif
313 # endif
314
315 # ifdef YYSTACK_ALLOC
316 /* Pacify GCC's `empty if-body' warning. */
317 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
318 # else
319 # if defined (__STDC__) || defined (__cplusplus)
320 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
321 # define YYSIZE_T size_t
322 # endif
323 # define YYSTACK_ALLOC YYMALLOC
324 # define YYSTACK_FREE YYFREE
325 # endif
326 #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
327
328
329 #if (! defined (yyoverflow) \
330 && (! defined (__cplusplus) \
331 || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
332
333 /* A type that is properly aligned for any stack member. */
334 union yyalloc
335 {
336 short yyss;
337 YYSTYPE yyvs;
338 };
339
340 /* The size of the maximum gap between one aligned stack and the next. */
341 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
342
343 /* The size of an array large to enough to hold all stacks, each with
344 N elements. */
345 # define YYSTACK_BYTES(N) \
346 ((N) * (sizeof (short) + sizeof (YYSTYPE)) \
347 + YYSTACK_GAP_MAXIMUM)
348
349 /* Copy COUNT objects from FROM to TO. The source and destination do
350 not overlap. */
351 # ifndef YYCOPY
352 # if defined (__GNUC__) && 1 < __GNUC__
353 # define YYCOPY(To, From, Count) \
354 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
355 # else
356 # define YYCOPY(To, From, Count) \
357 do \
358 { \
359 register YYSIZE_T yyi; \
360 for (yyi = 0; yyi < (Count); yyi++) \
361 (To)[yyi] = (From)[yyi]; \
362 } \
363 while (0)
364 # endif
365 # endif
366
367 /* Relocate STACK from its old location to the new one. The
368 local variables YYSIZE and YYSTACKSIZE give the old and new number of
369 elements in the stack, and YYPTR gives the new location of the
370 stack. Advance YYPTR to a properly aligned location for the next
371 stack. */
372 # define YYSTACK_RELOCATE(Stack) \
373 do \
374 { \
375 YYSIZE_T yynewbytes; \
376 YYCOPY (&yyptr->Stack, Stack, yysize); \
377 Stack = &yyptr->Stack; \
378 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
379 yyptr += yynewbytes / sizeof (*yyptr); \
380 } \
381 while (0)
382
383 #endif
384
385 #if defined (__STDC__) || defined (__cplusplus)
386 typedef signed char yysigned_char;
387 #else
388 typedef short yysigned_char;
389 #endif
390
391 /* YYFINAL -- State number of the termination state. */
392 #define YYFINAL 67
393 /* YYLAST -- Last index in YYTABLE. */
394 #define YYLAST 848
395
396 /* YYNTOKENS -- Number of terminals. */
397 #define YYNTOKENS 68
398 /* YYNNTS -- Number of nonterminals. */
399 #define YYNNTS 15
400 /* YYNRULES -- Number of rules. */
401 #define YYNRULES 80
402 /* YYNRULES -- Number of states. */
403 #define YYNSTATES 181
404
405 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
406 #define YYUNDEFTOK 2
407 #define YYMAXUTOK 303
408
409 #define YYTRANSLATE(YYX) \
410 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
411
412 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
413 static const unsigned char yytranslate[] =
414 {
415 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
416 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
417 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
418 2, 2, 2, 2, 2, 41, 2, 2, 47, 2,
419 59, 64, 52, 50, 35, 51, 2, 53, 2, 2,
420 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
421 38, 40, 39, 2, 49, 2, 2, 2, 2, 2,
422 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
423 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
424 2, 58, 2, 67, 57, 2, 2, 2, 2, 2,
425 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
426 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
427 2, 2, 2, 65, 2, 66, 61, 2, 2, 2,
428 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
429 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
430 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
431 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
432 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
433 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
434 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
435 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
436 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
437 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
438 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
439 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
440 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
441 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
442 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
443 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
444 36, 37, 42, 43, 44, 45, 46, 48, 54, 55,
445 56, 60, 62, 63
446 };
447
448 #if YYDEBUG
449 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
450 YYRHS. */
451 static const unsigned short yyprhs[] =
452 {
453 0, 0, 3, 5, 7, 9, 12, 13, 17, 20,
454 23, 25, 27, 32, 37, 42, 47, 52, 57, 62,
455 69, 74, 79, 84, 87, 92, 99, 104, 111, 115,
456 117, 121, 128, 135, 139, 144, 145, 151, 152, 158,
457 159, 161, 165, 167, 171, 176, 181, 185, 189, 193,
458 197, 201, 205, 209, 213, 217, 221, 225, 229, 233,
459 237, 241, 245, 249, 253, 255, 257, 259, 261, 263,
460 265, 267, 272, 274, 276, 278, 282, 284, 286, 290,
461 292
462 };
463
464 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
465 static const yysigned_char yyrhs[] =
466 {
467 69, 0, -1, 71, -1, 70, -1, 82, -1, 71,
468 57, -1, -1, 51, 72, 71, -1, 50, 71, -1,
469 73, 71, -1, 62, -1, 61, -1, 18, 59, 71,
470 64, -1, 19, 59, 71, 64, -1, 21, 59, 71,
471 64, -1, 20, 59, 71, 64, -1, 22, 59, 82,
472 64, -1, 23, 59, 82, 64, -1, 24, 59, 71,
473 64, -1, 25, 59, 82, 35, 71, 64, -1, 26,
474 59, 71, 64, -1, 27, 59, 71, 64, -1, 28,
475 59, 71, 64, -1, 17, 71, -1, 29, 59, 71,
476 64, -1, 29, 59, 71, 35, 71, 64, -1, 30,
477 59, 71, 64, -1, 30, 59, 71, 35, 71, 64,
478 -1, 71, 60, 12, -1, 74, -1, 71, 42, 74,
479 -1, 31, 59, 71, 35, 71, 64, -1, 32, 59,
480 71, 35, 71, 64, -1, 65, 77, 66, -1, 82,
481 65, 77, 66, -1, -1, 71, 58, 75, 78, 67,
482 -1, -1, 71, 59, 76, 77, 64, -1, -1, 71,
483 -1, 77, 35, 71, -1, 71, -1, 78, 35, 71,
484 -1, 65, 82, 66, 71, -1, 82, 59, 71, 64,
485 -1, 59, 71, 64, -1, 71, 49, 71, -1, 71,
486 52, 71, -1, 71, 53, 71, -1, 71, 55, 71,
487 -1, 71, 54, 71, -1, 71, 50, 71, -1, 71,
488 51, 71, -1, 71, 40, 71, -1, 71, 43, 71,
489 -1, 71, 41, 71, -1, 71, 45, 71, -1, 71,
490 44, 71, -1, 71, 38, 71, -1, 71, 39, 71,
491 -1, 71, 48, 71, -1, 71, 46, 71, -1, 71,
492 37, 71, -1, 7, -1, 8, -1, 3, -1, 6,
493 -1, 9, -1, 10, -1, 81, -1, 17, 59, 82,
494 64, -1, 11, -1, 80, -1, 13, -1, 79, 33,
495 13, -1, 80, -1, 34, -1, 79, 33, 12, -1,
496 12, -1, 16, -1
497 };
498
499 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
500 static const unsigned short yyrline[] =
501 {
502 0, 205, 205, 206, 209, 218, 223, 222, 229, 233,
503 237, 238, 241, 245, 249, 253, 257, 263, 269, 273,
504 279, 283, 287, 291, 296, 300, 306, 310, 316, 322,
505 325, 329, 333, 337, 339, 349, 345, 359, 356, 366,
506 369, 373, 378, 383, 388, 394, 400, 408, 412, 416,
507 420, 424, 428, 432, 436, 440, 442, 446, 450, 454,
508 458, 462, 466, 470, 477, 483, 489, 496, 505, 513,
509 520, 523, 530, 537, 541, 550, 562, 570, 574, 590,
510 641
511 };
512 #endif
513
514 #if YYDEBUG || YYERROR_VERBOSE
515 /* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
516 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
517 static const char *const yytname[] =
518 {
519 "$end", "error", "$undefined", "INT", "HEX", "ERROR", "UINT", "M2_TRUE",
520 "M2_FALSE", "CHAR", "FLOAT", "STRING", "NAME", "BLOCKNAME", "IDENT",
521 "VARNAME", "TYPENAME", "SIZE", "CAP", "ORD", "HIGH", "ABS", "MIN_FUNC",
522 "MAX_FUNC", "FLOAT_FUNC", "VAL", "CHR", "ODD", "TRUNC", "INC", "DEC",
523 "INCL", "EXCL", "COLONCOLON", "INTERNAL_VAR", "','", "ABOVE_COMMA",
524 "ASSIGN", "'<'", "'>'", "'='", "'#'", "IN", "NOTEQUAL", "GEQ", "LEQ",
525 "OROR", "'&'", "LOGICAL_AND", "'@'", "'+'", "'-'", "'*'", "'/'", "MOD",
526 "DIV", "UNARY", "'^'", "'['", "'('", "DOT", "'~'", "NOT", "QID", "')'",
527 "'{'", "'}'", "']'", "$accept", "start", "type_exp", "exp", "@1",
528 "not_exp", "set", "@2", "@3", "arglist", "non_empty_arglist", "block",
529 "fblock", "variable", "type", 0
530 };
531 #endif
532
533 # ifdef YYPRINT
534 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
535 token YYLEX-NUM. */
536 static const unsigned short yytoknum[] =
537 {
538 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
539 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
540 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
541 285, 286, 287, 288, 289, 44, 290, 291, 60, 62,
542 61, 35, 292, 293, 294, 295, 296, 38, 297, 64,
543 43, 45, 42, 47, 298, 299, 300, 94, 91, 40,
544 301, 126, 302, 303, 41, 123, 125, 93
545 };
546 # endif
547
548 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
549 static const unsigned char yyr1[] =
550 {
551 0, 68, 69, 69, 70, 71, 72, 71, 71, 71,
552 73, 73, 71, 71, 71, 71, 71, 71, 71, 71,
553 71, 71, 71, 71, 71, 71, 71, 71, 71, 71,
554 71, 71, 71, 74, 74, 75, 71, 76, 71, 77,
555 77, 77, 78, 78, 71, 71, 71, 71, 71, 71,
556 71, 71, 71, 71, 71, 71, 71, 71, 71, 71,
557 71, 71, 71, 71, 71, 71, 71, 71, 71, 71,
558 71, 71, 71, 79, 80, 80, 81, 81, 81, 81,
559 82
560 };
561
562 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
563 static const unsigned char yyr2[] =
564 {
565 0, 2, 1, 1, 1, 2, 0, 3, 2, 2,
566 1, 1, 4, 4, 4, 4, 4, 4, 4, 6,
567 4, 4, 4, 2, 4, 6, 4, 6, 3, 1,
568 3, 6, 6, 3, 4, 0, 5, 0, 5, 0,
569 1, 3, 1, 3, 4, 4, 3, 3, 3, 3,
570 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
571 3, 3, 3, 3, 1, 1, 1, 1, 1, 1,
572 1, 4, 1, 1, 1, 3, 1, 1, 3, 1,
573 1
574 };
575
576 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
577 STATE-NUM when YYTABLE doesn't specify something else to do. Zero
578 means the default is an error. */
579 static const unsigned char yydefact[] =
580 {
581 0, 66, 67, 64, 65, 68, 69, 72, 79, 74,
582 80, 0, 0, 0, 0, 0, 0, 0, 0, 0,
583 0, 0, 0, 0, 0, 0, 0, 77, 0, 6,
584 0, 11, 10, 39, 0, 3, 2, 0, 29, 0,
585 76, 70, 4, 0, 23, 0, 0, 0, 0, 0,
586 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
587 0, 8, 0, 0, 40, 0, 0, 1, 0, 0,
588 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
589 0, 0, 0, 0, 0, 0, 5, 35, 37, 0,
590 9, 0, 0, 39, 0, 0, 0, 0, 0, 0,
591 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
592 7, 46, 0, 33, 0, 63, 59, 60, 54, 56,
593 39, 30, 0, 55, 58, 57, 62, 61, 47, 52,
594 53, 48, 49, 51, 50, 0, 39, 28, 78, 75,
595 0, 0, 71, 12, 13, 15, 14, 16, 17, 18,
596 0, 20, 21, 22, 0, 24, 0, 26, 0, 0,
597 41, 44, 42, 0, 0, 45, 34, 0, 0, 0,
598 0, 0, 0, 36, 38, 19, 25, 27, 31, 32,
599 43
600 };
601
602 /* YYDEFGOTO[NTERM-NUM]. */
603 static const short yydefgoto[] =
604 {
605 -1, 34, 35, 64, 62, 37, 38, 135, 136, 65,
606 163, 39, 40, 41, 45
607 };
608
609 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
610 STATE-NUM. */
611 #define YYPACT_NINF -92
612 static const short yypact[] =
613 {
614 157, -92, -92, -92, -92, -92, -92, -92, -92, -92,
615 -92, 217, -53, -27, -18, -17, -8, 2, 8, 14,
616 28, 29, 30, 31, 32, 34, 35, -92, 157, -92,
617 157, -92, -92, 157, 44, -92, 744, 157, -92, 62,
618 64, -92, -34, 157, 6, -34, 157, 157, 157, 157,
619 13, 13, 157, 13, 157, 157, 157, 157, 157, 157,
620 157, 6, 157, 79, 744, -30, -39, -92, 157, 157,
621 157, 157, 157, -15, 157, 157, 157, 157, 157, 157,
622 157, 157, 157, 157, 157, 157, -92, -92, -92, 86,
623 6, -4, 157, 157, -25, 302, 330, 358, 386, 36,
624 37, 414, 67, 442, 470, 498, 246, 274, 694, 720,
625 6, -92, 157, -92, 157, 768, -36, -36, -36, -36,
626 157, -92, 40, -36, -36, -36, 144, 203, 779, 788,
627 788, 6, 6, 6, 6, 157, 157, -92, -92, -92,
628 526, -28, -92, -92, -92, -92, -92, -92, -92, -92,
629 157, -92, -92, -92, 157, -92, 157, -92, 157, 157,
630 744, 6, 744, -32, -31, -92, -92, 554, 582, 610,
631 638, 666, 157, -92, -92, -92, -92, -92, -92, -92,
632 744
633 };
634
635 /* YYPGOTO[NTERM-NUM]. */
636 static const yysigned_char yypgoto[] =
637 {
638 -92, -92, -92, 0, -92, -92, 26, -92, -92, -91,
639 -92, -92, -92, -92, 53
640 };
641
642 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
643 positive, shift that token. If negative, reduce the rule which
644 number is the opposite. If zero, do what YYDEFACT says.
645 If YYTABLE_NINF, syntax error. */
646 #define YYTABLE_NINF -74
647 static const short yytable[] =
648 {
649 36, 10, 141, 172, 112, 112, 46, 112, 138, 139,
650 77, 44, 78, 79, 80, 81, 82, 83, 84, 85,
651 92, 86, 87, 88, 89, 92, 93, 114, 61, 10,
652 63, 93, 47, 174, 92, 173, 113, 90, 166, 142,
653 93, 48, 49, 63, 67, 164, 95, 96, 97, 98,
654 120, 50, 101, 42, 103, 104, 105, 106, 107, 108,
655 109, 51, 110, 86, 87, 88, 89, 52, 115, 116,
656 117, 118, 119, 53, 123, 124, 125, 126, 127, 128,
657 129, 130, 131, 132, 133, 134, 66, 54, 55, 56,
658 57, 58, 140, 59, 60, 91, 94, -73, 137, 121,
659 147, 148, 150, 99, 100, 93, 102, 0, 0, 0,
660 0, 0, 160, 0, 161, 0, 68, 69, 70, 71,
661 72, 73, 74, 75, 76, 77, 122, 78, 79, 80,
662 81, 82, 83, 84, 85, 162, 86, 87, 88, 89,
663 0, 0, 0, 111, 0, 0, 0, 0, 0, 0,
664 167, 0, 0, 0, 168, 0, 169, 0, 170, 171,
665 1, 0, 0, 2, 3, 4, 5, 6, 7, 8,
666 9, 0, 180, 10, 11, 12, 13, 14, 15, 16,
667 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
668 0, 27, 78, 79, 80, 81, 82, 83, 84, 85,
669 0, 86, 87, 88, 89, 0, 0, 28, 29, 0,
670 0, 0, 0, 0, 0, 0, 30, 0, 31, 32,
671 1, 0, 33, 2, 3, 4, 5, 6, 7, 8,
672 9, 0, 0, 10, 11, 12, 13, 14, 15, 16,
673 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
674 0, 27, 79, 80, 81, 82, 83, 84, 85, 0,
675 86, 87, 88, 89, 0, 0, 0, 28, 29, 0,
676 0, 0, 0, 0, 0, 0, 43, 0, 31, 32,
677 0, 154, 33, 68, 69, 70, 71, 72, 73, 74,
678 75, 76, 77, 0, 78, 79, 80, 81, 82, 83,
679 84, 85, 0, 86, 87, 88, 89, 0, 0, 156,
680 155, 68, 69, 70, 71, 72, 73, 74, 75, 76,
681 77, 0, 78, 79, 80, 81, 82, 83, 84, 85,
682 0, 86, 87, 88, 89, 0, 0, 0, 157, 68,
683 69, 70, 71, 72, 73, 74, 75, 76, 77, 0,
684 78, 79, 80, 81, 82, 83, 84, 85, 0, 86,
685 87, 88, 89, 0, 0, 0, 143, 68, 69, 70,
686 71, 72, 73, 74, 75, 76, 77, 0, 78, 79,
687 80, 81, 82, 83, 84, 85, 0, 86, 87, 88,
688 89, 0, 0, 0, 144, 68, 69, 70, 71, 72,
689 73, 74, 75, 76, 77, 0, 78, 79, 80, 81,
690 82, 83, 84, 85, 0, 86, 87, 88, 89, 0,
691 0, 0, 145, 68, 69, 70, 71, 72, 73, 74,
692 75, 76, 77, 0, 78, 79, 80, 81, 82, 83,
693 84, 85, 0, 86, 87, 88, 89, 0, 0, 0,
694 146, 68, 69, 70, 71, 72, 73, 74, 75, 76,
695 77, 0, 78, 79, 80, 81, 82, 83, 84, 85,
696 0, 86, 87, 88, 89, 0, 0, 0, 149, 68,
697 69, 70, 71, 72, 73, 74, 75, 76, 77, 0,
698 78, 79, 80, 81, 82, 83, 84, 85, 0, 86,
699 87, 88, 89, 0, 0, 0, 151, 68, 69, 70,
700 71, 72, 73, 74, 75, 76, 77, 0, 78, 79,
701 80, 81, 82, 83, 84, 85, 0, 86, 87, 88,
702 89, 0, 0, 0, 152, 68, 69, 70, 71, 72,
703 73, 74, 75, 76, 77, 0, 78, 79, 80, 81,
704 82, 83, 84, 85, 0, 86, 87, 88, 89, 0,
705 0, 0, 153, 68, 69, 70, 71, 72, 73, 74,
706 75, 76, 77, 0, 78, 79, 80, 81, 82, 83,
707 84, 85, 0, 86, 87, 88, 89, 0, 0, 0,
708 165, 68, 69, 70, 71, 72, 73, 74, 75, 76,
709 77, 0, 78, 79, 80, 81, 82, 83, 84, 85,
710 0, 86, 87, 88, 89, 0, 0, 0, 175, 68,
711 69, 70, 71, 72, 73, 74, 75, 76, 77, 0,
712 78, 79, 80, 81, 82, 83, 84, 85, 0, 86,
713 87, 88, 89, 0, 0, 0, 176, 68, 69, 70,
714 71, 72, 73, 74, 75, 76, 77, 0, 78, 79,
715 80, 81, 82, 83, 84, 85, 0, 86, 87, 88,
716 89, 0, 0, 0, 177, 68, 69, 70, 71, 72,
717 73, 74, 75, 76, 77, 0, 78, 79, 80, 81,
718 82, 83, 84, 85, 0, 86, 87, 88, 89, 0,
719 0, 0, 178, 68, 69, 70, 71, 72, 73, 74,
720 75, 76, 77, 0, 78, 79, 80, 81, 82, 83,
721 84, 85, 0, 86, 87, 88, 89, 0, 0, 158,
722 179, 68, 69, 70, 71, 72, 73, 74, 75, 76,
723 77, 0, 78, 79, 80, 81, 82, 83, 84, 85,
724 0, 86, 87, 88, 89, 159, 0, 68, 69, 70,
725 71, 72, 73, 74, 75, 76, 77, 0, 78, 79,
726 80, 81, 82, 83, 84, 85, 0, 86, 87, 88,
727 89, 68, 69, 70, 71, 72, 73, 74, 75, 76,
728 77, 0, 78, 79, 80, 81, 82, 83, 84, 85,
729 0, 86, 87, 88, 89, -74, 69, 70, 71, 72,
730 73, 74, 75, 76, 77, 0, 78, 79, 80, 81,
731 82, 83, 84, 85, 0, 86, 87, 88, 89, 80,
732 81, 82, 83, 84, 85, 0, 86, 87, 88, 89,
733 82, 83, 84, 85, 0, 86, 87, 88, 89
734 };
735
736 static const short yycheck[] =
737 {
738 0, 16, 93, 35, 35, 35, 59, 35, 12, 13,
739 46, 11, 48, 49, 50, 51, 52, 53, 54, 55,
740 59, 57, 58, 59, 60, 59, 65, 66, 28, 16,
741 30, 65, 59, 64, 59, 67, 66, 37, 66, 64,
742 65, 59, 59, 43, 0, 136, 46, 47, 48, 49,
743 65, 59, 52, 0, 54, 55, 56, 57, 58, 59,
744 60, 59, 62, 57, 58, 59, 60, 59, 68, 69,
745 70, 71, 72, 59, 74, 75, 76, 77, 78, 79,
746 80, 81, 82, 83, 84, 85, 33, 59, 59, 59,
747 59, 59, 92, 59, 59, 33, 43, 33, 12, 73,
748 64, 64, 35, 50, 51, 65, 53, -1, -1, -1,
749 -1, -1, 112, -1, 114, -1, 37, 38, 39, 40,
750 41, 42, 43, 44, 45, 46, 73, 48, 49, 50,
751 51, 52, 53, 54, 55, 135, 57, 58, 59, 60,
752 -1, -1, -1, 64, -1, -1, -1, -1, -1, -1,
753 150, -1, -1, -1, 154, -1, 156, -1, 158, 159,
754 3, -1, -1, 6, 7, 8, 9, 10, 11, 12,
755 13, -1, 172, 16, 17, 18, 19, 20, 21, 22,
756 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
757 -1, 34, 48, 49, 50, 51, 52, 53, 54, 55,
758 -1, 57, 58, 59, 60, -1, -1, 50, 51, -1,
759 -1, -1, -1, -1, -1, -1, 59, -1, 61, 62,
760 3, -1, 65, 6, 7, 8, 9, 10, 11, 12,
761 13, -1, -1, 16, 17, 18, 19, 20, 21, 22,
762 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
763 -1, 34, 49, 50, 51, 52, 53, 54, 55, -1,
764 57, 58, 59, 60, -1, -1, -1, 50, 51, -1,
765 -1, -1, -1, -1, -1, -1, 59, -1, 61, 62,
766 -1, 35, 65, 37, 38, 39, 40, 41, 42, 43,
767 44, 45, 46, -1, 48, 49, 50, 51, 52, 53,
768 54, 55, -1, 57, 58, 59, 60, -1, -1, 35,
769 64, 37, 38, 39, 40, 41, 42, 43, 44, 45,
770 46, -1, 48, 49, 50, 51, 52, 53, 54, 55,
771 -1, 57, 58, 59, 60, -1, -1, -1, 64, 37,
772 38, 39, 40, 41, 42, 43, 44, 45, 46, -1,
773 48, 49, 50, 51, 52, 53, 54, 55, -1, 57,
774 58, 59, 60, -1, -1, -1, 64, 37, 38, 39,
775 40, 41, 42, 43, 44, 45, 46, -1, 48, 49,
776 50, 51, 52, 53, 54, 55, -1, 57, 58, 59,
777 60, -1, -1, -1, 64, 37, 38, 39, 40, 41,
778 42, 43, 44, 45, 46, -1, 48, 49, 50, 51,
779 52, 53, 54, 55, -1, 57, 58, 59, 60, -1,
780 -1, -1, 64, 37, 38, 39, 40, 41, 42, 43,
781 44, 45, 46, -1, 48, 49, 50, 51, 52, 53,
782 54, 55, -1, 57, 58, 59, 60, -1, -1, -1,
783 64, 37, 38, 39, 40, 41, 42, 43, 44, 45,
784 46, -1, 48, 49, 50, 51, 52, 53, 54, 55,
785 -1, 57, 58, 59, 60, -1, -1, -1, 64, 37,
786 38, 39, 40, 41, 42, 43, 44, 45, 46, -1,
787 48, 49, 50, 51, 52, 53, 54, 55, -1, 57,
788 58, 59, 60, -1, -1, -1, 64, 37, 38, 39,
789 40, 41, 42, 43, 44, 45, 46, -1, 48, 49,
790 50, 51, 52, 53, 54, 55, -1, 57, 58, 59,
791 60, -1, -1, -1, 64, 37, 38, 39, 40, 41,
792 42, 43, 44, 45, 46, -1, 48, 49, 50, 51,
793 52, 53, 54, 55, -1, 57, 58, 59, 60, -1,
794 -1, -1, 64, 37, 38, 39, 40, 41, 42, 43,
795 44, 45, 46, -1, 48, 49, 50, 51, 52, 53,
796 54, 55, -1, 57, 58, 59, 60, -1, -1, -1,
797 64, 37, 38, 39, 40, 41, 42, 43, 44, 45,
798 46, -1, 48, 49, 50, 51, 52, 53, 54, 55,
799 -1, 57, 58, 59, 60, -1, -1, -1, 64, 37,
800 38, 39, 40, 41, 42, 43, 44, 45, 46, -1,
801 48, 49, 50, 51, 52, 53, 54, 55, -1, 57,
802 58, 59, 60, -1, -1, -1, 64, 37, 38, 39,
803 40, 41, 42, 43, 44, 45, 46, -1, 48, 49,
804 50, 51, 52, 53, 54, 55, -1, 57, 58, 59,
805 60, -1, -1, -1, 64, 37, 38, 39, 40, 41,
806 42, 43, 44, 45, 46, -1, 48, 49, 50, 51,
807 52, 53, 54, 55, -1, 57, 58, 59, 60, -1,
808 -1, -1, 64, 37, 38, 39, 40, 41, 42, 43,
809 44, 45, 46, -1, 48, 49, 50, 51, 52, 53,
810 54, 55, -1, 57, 58, 59, 60, -1, -1, 35,
811 64, 37, 38, 39, 40, 41, 42, 43, 44, 45,
812 46, -1, 48, 49, 50, 51, 52, 53, 54, 55,
813 -1, 57, 58, 59, 60, 35, -1, 37, 38, 39,
814 40, 41, 42, 43, 44, 45, 46, -1, 48, 49,
815 50, 51, 52, 53, 54, 55, -1, 57, 58, 59,
816 60, 37, 38, 39, 40, 41, 42, 43, 44, 45,
817 46, -1, 48, 49, 50, 51, 52, 53, 54, 55,
818 -1, 57, 58, 59, 60, 37, 38, 39, 40, 41,
819 42, 43, 44, 45, 46, -1, 48, 49, 50, 51,
820 52, 53, 54, 55, -1, 57, 58, 59, 60, 50,
821 51, 52, 53, 54, 55, -1, 57, 58, 59, 60,
822 52, 53, 54, 55, -1, 57, 58, 59, 60
823 };
824
825 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
826 symbol of state STATE-NUM. */
827 static const unsigned char yystos[] =
828 {
829 0, 3, 6, 7, 8, 9, 10, 11, 12, 13,
830 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
831 26, 27, 28, 29, 30, 31, 32, 34, 50, 51,
832 59, 61, 62, 65, 69, 70, 71, 73, 74, 79,
833 80, 81, 82, 59, 71, 82, 59, 59, 59, 59,
834 59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
835 59, 71, 72, 71, 71, 77, 82, 0, 37, 38,
836 39, 40, 41, 42, 43, 44, 45, 46, 48, 49,
837 50, 51, 52, 53, 54, 55, 57, 58, 59, 60,
838 71, 33, 59, 65, 82, 71, 71, 71, 71, 82,
839 82, 71, 82, 71, 71, 71, 71, 71, 71, 71,
840 71, 64, 35, 66, 66, 71, 71, 71, 71, 71,
841 65, 74, 82, 71, 71, 71, 71, 71, 71, 71,
842 71, 71, 71, 71, 71, 75, 76, 12, 12, 13,
843 71, 77, 64, 64, 64, 64, 64, 64, 64, 64,
844 35, 64, 64, 64, 35, 64, 35, 64, 35, 35,
845 71, 71, 71, 78, 77, 64, 66, 71, 71, 71,
846 71, 71, 35, 67, 64, 64, 64, 64, 64, 64,
847 71
848 };
849
850 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
851 # define YYSIZE_T __SIZE_TYPE__
852 #endif
853 #if ! defined (YYSIZE_T) && defined (size_t)
854 # define YYSIZE_T size_t
855 #endif
856 #if ! defined (YYSIZE_T)
857 # if defined (__STDC__) || defined (__cplusplus)
858 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
859 # define YYSIZE_T size_t
860 # endif
861 #endif
862 #if ! defined (YYSIZE_T)
863 # define YYSIZE_T unsigned int
864 #endif
865
866 #define yyerrok (yyerrstatus = 0)
867 #define yyclearin (yychar = YYEMPTY)
868 #define YYEMPTY (-2)
869 #define YYEOF 0
870
871 #define YYACCEPT goto yyacceptlab
872 #define YYABORT goto yyabortlab
873 #define YYERROR goto yyerrorlab
874
875
876 /* Like YYERROR except do call yyerror. This remains here temporarily
877 to ease the transition to the new meaning of YYERROR, for GCC.
878 Once GCC version 2 has supplanted version 1, this can go. */
879
880 #define YYFAIL goto yyerrlab
881
882 #define YYRECOVERING() (!!yyerrstatus)
883
884 #define YYBACKUP(Token, Value) \
885 do \
886 if (yychar == YYEMPTY && yylen == 1) \
887 { \
888 yychar = (Token); \
889 yylval = (Value); \
890 yytoken = YYTRANSLATE (yychar); \
891 YYPOPSTACK; \
892 goto yybackup; \
893 } \
894 else \
895 { \
896 yyerror ("syntax error: cannot back up");\
897 YYERROR; \
898 } \
899 while (0)
900
901 #define YYTERROR 1
902 #define YYERRCODE 256
903
904 /* YYLLOC_DEFAULT -- Compute the default location (before the actions
905 are run). */
906
907 #ifndef YYLLOC_DEFAULT
908 # define YYLLOC_DEFAULT(Current, Rhs, N) \
909 ((Current).first_line = (Rhs)[1].first_line, \
910 (Current).first_column = (Rhs)[1].first_column, \
911 (Current).last_line = (Rhs)[N].last_line, \
912 (Current).last_column = (Rhs)[N].last_column)
913 #endif
914
915 /* YYLEX -- calling `yylex' with the right arguments. */
916
917 #ifdef YYLEX_PARAM
918 # define YYLEX yylex (YYLEX_PARAM)
919 #else
920 # define YYLEX yylex ()
921 #endif
922
923 /* Enable debugging if requested. */
924 #if YYDEBUG
925
926 # ifndef YYFPRINTF
927 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
928 # define YYFPRINTF fprintf
929 # endif
930
931 # define YYDPRINTF(Args) \
932 do { \
933 if (yydebug) \
934 YYFPRINTF Args; \
935 } while (0)
936
937 # define YYDSYMPRINT(Args) \
938 do { \
939 if (yydebug) \
940 yysymprint Args; \
941 } while (0)
942
943 # define YYDSYMPRINTF(Title, Token, Value, Location) \
944 do { \
945 if (yydebug) \
946 { \
947 YYFPRINTF (stderr, "%s ", Title); \
948 yysymprint (stderr, \
949 Token, Value); \
950 YYFPRINTF (stderr, "\n"); \
951 } \
952 } while (0)
953
954 /*------------------------------------------------------------------.
955 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
956 | TOP (included). |
957 `------------------------------------------------------------------*/
958
959 #if defined (__STDC__) || defined (__cplusplus)
960 static void
yy_stack_print(short * bottom,short * top)961 yy_stack_print (short *bottom, short *top)
962 #else
963 static void
964 yy_stack_print (bottom, top)
965 short *bottom;
966 short *top;
967 #endif
968 {
969 YYFPRINTF (stderr, "Stack now");
970 for (/* Nothing. */; bottom <= top; ++bottom)
971 YYFPRINTF (stderr, " %d", *bottom);
972 YYFPRINTF (stderr, "\n");
973 }
974
975 # define YY_STACK_PRINT(Bottom, Top) \
976 do { \
977 if (yydebug) \
978 yy_stack_print ((Bottom), (Top)); \
979 } while (0)
980
981
982 /*------------------------------------------------.
983 | Report that the YYRULE is going to be reduced. |
984 `------------------------------------------------*/
985
986 #if defined (__STDC__) || defined (__cplusplus)
987 static void
yy_reduce_print(int yyrule)988 yy_reduce_print (int yyrule)
989 #else
990 static void
991 yy_reduce_print (yyrule)
992 int yyrule;
993 #endif
994 {
995 int yyi;
996 unsigned int yylno = yyrline[yyrule];
997 YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ",
998 yyrule - 1, yylno);
999 /* Print the symbols being reduced, and their result. */
1000 for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
1001 YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]);
1002 YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]);
1003 }
1004
1005 # define YY_REDUCE_PRINT(Rule) \
1006 do { \
1007 if (yydebug) \
1008 yy_reduce_print (Rule); \
1009 } while (0)
1010
1011 /* Nonzero means print parse trace. It is left uninitialized so that
1012 multiple parsers can coexist. */
1013 int yydebug;
1014 #else /* !YYDEBUG */
1015 # define YYDPRINTF(Args)
1016 # define YYDSYMPRINT(Args)
1017 # define YYDSYMPRINTF(Title, Token, Value, Location)
1018 # define YY_STACK_PRINT(Bottom, Top)
1019 # define YY_REDUCE_PRINT(Rule)
1020 #endif /* !YYDEBUG */
1021
1022
1023 /* YYINITDEPTH -- initial size of the parser's stacks. */
1024 #ifndef YYINITDEPTH
1025 # define YYINITDEPTH 200
1026 #endif
1027
1028 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1029 if the built-in stack extension method is used).
1030
1031 Do not make this value too large; the results are undefined if
1032 SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
1033 evaluated with infinite-precision integer arithmetic. */
1034
1035 #if defined (YYMAXDEPTH) && YYMAXDEPTH == 0
1036 # undef YYMAXDEPTH
1037 #endif
1038
1039 #ifndef YYMAXDEPTH
1040 # define YYMAXDEPTH 10000
1041 #endif
1042
1043
1044
1045 #if YYERROR_VERBOSE
1046
1047 # ifndef yystrlen
1048 # if defined (__GLIBC__) && defined (_STRING_H)
1049 # define yystrlen strlen
1050 # else
1051 /* Return the length of YYSTR. */
1052 static YYSIZE_T
1053 # if defined (__STDC__) || defined (__cplusplus)
yystrlen(const char * yystr)1054 yystrlen (const char *yystr)
1055 # else
1056 yystrlen (yystr)
1057 const char *yystr;
1058 # endif
1059 {
1060 register const char *yys = yystr;
1061
1062 while (*yys++ != '\0')
1063 continue;
1064
1065 return yys - yystr - 1;
1066 }
1067 # endif
1068 # endif
1069
1070 # ifndef yystpcpy
1071 # if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
1072 # define yystpcpy stpcpy
1073 # else
1074 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1075 YYDEST. */
1076 static char *
1077 # if defined (__STDC__) || defined (__cplusplus)
yystpcpy(char * yydest,const char * yysrc)1078 yystpcpy (char *yydest, const char *yysrc)
1079 # else
1080 yystpcpy (yydest, yysrc)
1081 char *yydest;
1082 const char *yysrc;
1083 # endif
1084 {
1085 register char *yyd = yydest;
1086 register const char *yys = yysrc;
1087
1088 while ((*yyd++ = *yys++) != '\0')
1089 continue;
1090
1091 return yyd - 1;
1092 }
1093 # endif
1094 # endif
1095
1096 #endif /* !YYERROR_VERBOSE */
1097
1098
1099
1100 #if YYDEBUG
1101 /*--------------------------------.
1102 | Print this symbol on YYOUTPUT. |
1103 `--------------------------------*/
1104
1105 #if defined (__STDC__) || defined (__cplusplus)
1106 static void
yysymprint(FILE * yyoutput,int yytype,YYSTYPE * yyvaluep)1107 yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
1108 #else
1109 static void
1110 yysymprint (yyoutput, yytype, yyvaluep)
1111 FILE *yyoutput;
1112 int yytype;
1113 YYSTYPE *yyvaluep;
1114 #endif
1115 {
1116 /* Pacify ``unused variable'' warnings. */
1117 (void) yyvaluep;
1118
1119 if (yytype < YYNTOKENS)
1120 {
1121 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
1122 # ifdef YYPRINT
1123 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
1124 # endif
1125 }
1126 else
1127 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
1128
1129 switch (yytype)
1130 {
1131 default:
1132 break;
1133 }
1134 YYFPRINTF (yyoutput, ")");
1135 }
1136
1137 #endif /* ! YYDEBUG */
1138 /*-----------------------------------------------.
1139 | Release the memory associated to this symbol. |
1140 `-----------------------------------------------*/
1141
1142 #if defined (__STDC__) || defined (__cplusplus)
1143 static void
yydestruct(int yytype,YYSTYPE * yyvaluep)1144 yydestruct (int yytype, YYSTYPE *yyvaluep)
1145 #else
1146 static void
1147 yydestruct (yytype, yyvaluep)
1148 int yytype;
1149 YYSTYPE *yyvaluep;
1150 #endif
1151 {
1152 /* Pacify ``unused variable'' warnings. */
1153 (void) yyvaluep;
1154
1155 switch (yytype)
1156 {
1157
1158 default:
1159 break;
1160 }
1161 }
1162
1163
1164 /* Prevent warnings from -Wmissing-prototypes. */
1165
1166 #ifdef YYPARSE_PARAM
1167 # if defined (__STDC__) || defined (__cplusplus)
1168 int yyparse (void *YYPARSE_PARAM);
1169 # else
1170 int yyparse ();
1171 # endif
1172 #else /* ! YYPARSE_PARAM */
1173 #if defined (__STDC__) || defined (__cplusplus)
1174 int yyparse (void);
1175 #else
1176 int yyparse ();
1177 #endif
1178 #endif /* ! YYPARSE_PARAM */
1179
1180
1181
1182 /* The lookahead symbol. */
1183 int yychar;
1184
1185 /* The semantic value of the lookahead symbol. */
1186 YYSTYPE yylval;
1187
1188 /* Number of syntax errors so far. */
1189 int yynerrs;
1190
1191
1192
1193 /*----------.
1194 | yyparse. |
1195 `----------*/
1196
1197 #ifdef YYPARSE_PARAM
1198 # if defined (__STDC__) || defined (__cplusplus)
yyparse(void * YYPARSE_PARAM)1199 int yyparse (void *YYPARSE_PARAM)
1200 # else
1201 int yyparse (YYPARSE_PARAM)
1202 void *YYPARSE_PARAM;
1203 # endif
1204 #else /* ! YYPARSE_PARAM */
1205 #if defined (__STDC__) || defined (__cplusplus)
1206 int
1207 yyparse (void)
1208 #else
1209 int
1210 yyparse ()
1211
1212 #endif
1213 #endif
1214 {
1215
1216 register int yystate;
1217 register int yyn;
1218 int yyresult;
1219 /* Number of tokens to shift before error messages enabled. */
1220 int yyerrstatus;
1221 /* Lookahead token as an internal (translated) token number. */
1222 int yytoken = 0;
1223
1224 /* Three stacks and their tools:
1225 `yyss': related to states,
1226 `yyvs': related to semantic values,
1227 `yyls': related to locations.
1228
1229 Refer to the stacks thru separate pointers, to allow yyoverflow
1230 to xreallocate them elsewhere. */
1231
1232 /* The state stack. */
1233 short yyssa[YYINITDEPTH];
1234 short *yyss = yyssa;
1235 register short *yyssp;
1236
1237 /* The semantic value stack. */
1238 YYSTYPE yyvsa[YYINITDEPTH];
1239 YYSTYPE *yyvs = yyvsa;
1240 register YYSTYPE *yyvsp;
1241
1242
1243
1244 #define YYPOPSTACK (yyvsp--, yyssp--)
1245
1246 YYSIZE_T yystacksize = YYINITDEPTH;
1247
1248 /* The variables used to return semantic value and location from the
1249 action routines. */
1250 YYSTYPE yyval;
1251
1252
1253 /* When reducing, the number of symbols on the RHS of the reduced
1254 rule. */
1255 int yylen;
1256
1257 YYDPRINTF ((stderr, "Starting parse\n"));
1258
1259 yystate = 0;
1260 yyerrstatus = 0;
1261 yynerrs = 0;
1262 yychar = YYEMPTY; /* Cause a token to be read. */
1263
1264 /* Initialize stack pointers.
1265 Waste one element of value and location stack
1266 so that they stay on the same level as the state stack.
1267 The wasted elements are never initialized. */
1268
1269 yyssp = yyss;
1270 yyvsp = yyvs;
1271
1272 goto yysetstate;
1273
1274 /*------------------------------------------------------------.
1275 | yynewstate -- Push a new state, which is found in yystate. |
1276 `------------------------------------------------------------*/
1277 yynewstate:
1278 /* In all cases, when you get here, the value and location stacks
1279 have just been pushed. so pushing a state here evens the stacks.
1280 */
1281 yyssp++;
1282
1283 yysetstate:
1284 *yyssp = yystate;
1285
1286 if (yyss + yystacksize - 1 <= yyssp)
1287 {
1288 /* Get the current used size of the three stacks, in elements. */
1289 YYSIZE_T yysize = yyssp - yyss + 1;
1290
1291 #ifdef yyoverflow
1292 {
1293 /* Give user a chance to xreallocate the stack. Use copies of
1294 these so that the &'s don't force the real ones into
1295 memory. */
1296 YYSTYPE *yyvs1 = yyvs;
1297 short *yyss1 = yyss;
1298
1299
1300 /* Each stack pointer address is followed by the size of the
1301 data in use in that stack, in bytes. This used to be a
1302 conditional around just the two extra args, but that might
1303 be undefined if yyoverflow is a macro. */
1304 yyoverflow ("parser stack overflow",
1305 &yyss1, yysize * sizeof (*yyssp),
1306 &yyvs1, yysize * sizeof (*yyvsp),
1307
1308 &yystacksize);
1309
1310 yyss = yyss1;
1311 yyvs = yyvs1;
1312 }
1313 #else /* no yyoverflow */
1314 # ifndef YYSTACK_RELOCATE
1315 goto yyoverflowlab;
1316 # else
1317 /* Extend the stack our own way. */
1318 if (YYMAXDEPTH <= yystacksize)
1319 goto yyoverflowlab;
1320 yystacksize *= 2;
1321 if (YYMAXDEPTH < yystacksize)
1322 yystacksize = YYMAXDEPTH;
1323
1324 {
1325 short *yyss1 = yyss;
1326 union yyalloc *yyptr =
1327 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1328 if (! yyptr)
1329 goto yyoverflowlab;
1330 YYSTACK_RELOCATE (yyss);
1331 YYSTACK_RELOCATE (yyvs);
1332
1333 # undef YYSTACK_RELOCATE
1334 if (yyss1 != yyssa)
1335 YYSTACK_FREE (yyss1);
1336 }
1337 # endif
1338 #endif /* no yyoverflow */
1339
1340 yyssp = yyss + yysize - 1;
1341 yyvsp = yyvs + yysize - 1;
1342
1343
1344 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1345 (unsigned long int) yystacksize));
1346
1347 if (yyss + yystacksize - 1 <= yyssp)
1348 YYABORT;
1349 }
1350
1351 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1352
1353 goto yybackup;
1354
1355 /*-----------.
1356 | yybackup. |
1357 `-----------*/
1358 yybackup:
1359
1360 /* Do appropriate processing given the current state. */
1361 /* Read a lookahead token if we need one and don't already have one. */
1362 /* yyresume: */
1363
1364 /* First try to decide what to do without reference to lookahead token. */
1365
1366 yyn = yypact[yystate];
1367 if (yyn == YYPACT_NINF)
1368 goto yydefault;
1369
1370 /* Not known => get a lookahead token if don't already have one. */
1371
1372 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1373 if (yychar == YYEMPTY)
1374 {
1375 YYDPRINTF ((stderr, "Reading a token: "));
1376 yychar = YYLEX;
1377 }
1378
1379 if (yychar <= YYEOF)
1380 {
1381 yychar = yytoken = YYEOF;
1382 YYDPRINTF ((stderr, "Now at end of input.\n"));
1383 }
1384 else
1385 {
1386 yytoken = YYTRANSLATE (yychar);
1387 YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc);
1388 }
1389
1390 /* If the proper action on seeing token YYTOKEN is to reduce or to
1391 detect an error, take that action. */
1392 yyn += yytoken;
1393 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1394 goto yydefault;
1395 yyn = yytable[yyn];
1396 if (yyn <= 0)
1397 {
1398 if (yyn == 0 || yyn == YYTABLE_NINF)
1399 goto yyerrlab;
1400 yyn = -yyn;
1401 goto yyreduce;
1402 }
1403
1404 if (yyn == YYFINAL)
1405 YYACCEPT;
1406
1407 /* Shift the lookahead token. */
1408 YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken]));
1409
1410 /* Discard the token being shifted unless it is eof. */
1411 if (yychar != YYEOF)
1412 yychar = YYEMPTY;
1413
1414 *++yyvsp = yylval;
1415
1416
1417 /* Count tokens shifted since error; after three, turn off error
1418 status. */
1419 if (yyerrstatus)
1420 yyerrstatus--;
1421
1422 yystate = yyn;
1423 goto yynewstate;
1424
1425
1426 /*-----------------------------------------------------------.
1427 | yydefault -- do the default action for the current state. |
1428 `-----------------------------------------------------------*/
1429 yydefault:
1430 yyn = yydefact[yystate];
1431 if (yyn == 0)
1432 goto yyerrlab;
1433 goto yyreduce;
1434
1435
1436 /*-----------------------------.
1437 | yyreduce -- Do a reduction. |
1438 `-----------------------------*/
1439 yyreduce:
1440 /* yyn is the number of a rule to reduce with. */
1441 yylen = yyr2[yyn];
1442
1443 /* If YYLEN is nonzero, implement the default value of the action:
1444 `$$ = $1'.
1445
1446 Otherwise, the following line sets YYVAL to garbage.
1447 This behavior is undocumented and Bison
1448 users should not rely upon it. Assigning to YYVAL
1449 unconditionally makes the parser a bit smaller, and it avoids a
1450 GCC warning that YYVAL may be used uninitialized. */
1451 yyval = yyvsp[1-yylen];
1452
1453
1454 YY_REDUCE_PRINT (yyn);
1455 switch (yyn)
1456 {
1457 case 4:
1458 #line 210 "m2-exp.y"
1459 { write_exp_elt_opcode(OP_TYPE);
1460 write_exp_elt_type(yyvsp[0].tval);
1461 write_exp_elt_opcode(OP_TYPE);
1462 }
1463 break;
1464
1465 case 5:
1466 #line 219 "m2-exp.y"
1467 { write_exp_elt_opcode (UNOP_IND); }
1468 break;
1469
1470 case 6:
1471 #line 223 "m2-exp.y"
1472 { number_sign = -1; }
1473 break;
1474
1475 case 7:
1476 #line 225 "m2-exp.y"
1477 { number_sign = 1;
1478 write_exp_elt_opcode (UNOP_NEG); }
1479 break;
1480
1481 case 8:
1482 #line 230 "m2-exp.y"
1483 { write_exp_elt_opcode(UNOP_PLUS); }
1484 break;
1485
1486 case 9:
1487 #line 234 "m2-exp.y"
1488 { write_exp_elt_opcode (UNOP_LOGICAL_NOT); }
1489 break;
1490
1491 case 12:
1492 #line 242 "m2-exp.y"
1493 { write_exp_elt_opcode (UNOP_CAP); }
1494 break;
1495
1496 case 13:
1497 #line 246 "m2-exp.y"
1498 { write_exp_elt_opcode (UNOP_ORD); }
1499 break;
1500
1501 case 14:
1502 #line 250 "m2-exp.y"
1503 { write_exp_elt_opcode (UNOP_ABS); }
1504 break;
1505
1506 case 15:
1507 #line 254 "m2-exp.y"
1508 { write_exp_elt_opcode (UNOP_HIGH); }
1509 break;
1510
1511 case 16:
1512 #line 258 "m2-exp.y"
1513 { write_exp_elt_opcode (UNOP_MIN);
1514 write_exp_elt_type (yyvsp[-1].tval);
1515 write_exp_elt_opcode (UNOP_MIN); }
1516 break;
1517
1518 case 17:
1519 #line 264 "m2-exp.y"
1520 { write_exp_elt_opcode (UNOP_MAX);
1521 write_exp_elt_type (yyvsp[-1].tval);
1522 write_exp_elt_opcode (UNOP_MIN); }
1523 break;
1524
1525 case 18:
1526 #line 270 "m2-exp.y"
1527 { write_exp_elt_opcode (UNOP_FLOAT); }
1528 break;
1529
1530 case 19:
1531 #line 274 "m2-exp.y"
1532 { write_exp_elt_opcode (BINOP_VAL);
1533 write_exp_elt_type (yyvsp[-3].tval);
1534 write_exp_elt_opcode (BINOP_VAL); }
1535 break;
1536
1537 case 20:
1538 #line 280 "m2-exp.y"
1539 { write_exp_elt_opcode (UNOP_CHR); }
1540 break;
1541
1542 case 21:
1543 #line 284 "m2-exp.y"
1544 { write_exp_elt_opcode (UNOP_ODD); }
1545 break;
1546
1547 case 22:
1548 #line 288 "m2-exp.y"
1549 { write_exp_elt_opcode (UNOP_TRUNC); }
1550 break;
1551
1552 case 23:
1553 #line 292 "m2-exp.y"
1554 { write_exp_elt_opcode (UNOP_SIZEOF); }
1555 break;
1556
1557 case 24:
1558 #line 297 "m2-exp.y"
1559 { write_exp_elt_opcode(UNOP_PREINCREMENT); }
1560 break;
1561
1562 case 25:
1563 #line 301 "m2-exp.y"
1564 { write_exp_elt_opcode(BINOP_ASSIGN_MODIFY);
1565 write_exp_elt_opcode(BINOP_ADD);
1566 write_exp_elt_opcode(BINOP_ASSIGN_MODIFY); }
1567 break;
1568
1569 case 26:
1570 #line 307 "m2-exp.y"
1571 { write_exp_elt_opcode(UNOP_PREDECREMENT);}
1572 break;
1573
1574 case 27:
1575 #line 311 "m2-exp.y"
1576 { write_exp_elt_opcode(BINOP_ASSIGN_MODIFY);
1577 write_exp_elt_opcode(BINOP_SUB);
1578 write_exp_elt_opcode(BINOP_ASSIGN_MODIFY); }
1579 break;
1580
1581 case 28:
1582 #line 317 "m2-exp.y"
1583 { write_exp_elt_opcode (STRUCTOP_STRUCT);
1584 write_exp_string (yyvsp[0].sval);
1585 write_exp_elt_opcode (STRUCTOP_STRUCT); }
1586 break;
1587
1588 case 30:
1589 #line 326 "m2-exp.y"
1590 { error("Sets are not implemented.");}
1591 break;
1592
1593 case 31:
1594 #line 330 "m2-exp.y"
1595 { error("Sets are not implemented.");}
1596 break;
1597
1598 case 32:
1599 #line 334 "m2-exp.y"
1600 { error("Sets are not implemented.");}
1601 break;
1602
1603 case 33:
1604 #line 338 "m2-exp.y"
1605 { error("Sets are not implemented.");}
1606 break;
1607
1608 case 34:
1609 #line 340 "m2-exp.y"
1610 { error("Sets are not implemented.");}
1611 break;
1612
1613 case 35:
1614 #line 349 "m2-exp.y"
1615 { start_arglist(); }
1616 break;
1617
1618 case 36:
1619 #line 351 "m2-exp.y"
1620 { write_exp_elt_opcode (MULTI_SUBSCRIPT);
1621 write_exp_elt_longcst ((LONGEST) end_arglist());
1622 write_exp_elt_opcode (MULTI_SUBSCRIPT); }
1623 break;
1624
1625 case 37:
1626 #line 359 "m2-exp.y"
1627 { start_arglist (); }
1628 break;
1629
1630 case 38:
1631 #line 361 "m2-exp.y"
1632 { write_exp_elt_opcode (OP_FUNCALL);
1633 write_exp_elt_longcst ((LONGEST) end_arglist ());
1634 write_exp_elt_opcode (OP_FUNCALL); }
1635 break;
1636
1637 case 40:
1638 #line 370 "m2-exp.y"
1639 { arglist_len = 1; }
1640 break;
1641
1642 case 41:
1643 #line 374 "m2-exp.y"
1644 { arglist_len++; }
1645 break;
1646
1647 case 42:
1648 #line 379 "m2-exp.y"
1649 { arglist_len = 1; }
1650 break;
1651
1652 case 43:
1653 #line 384 "m2-exp.y"
1654 { arglist_len++; }
1655 break;
1656
1657 case 44:
1658 #line 389 "m2-exp.y"
1659 { write_exp_elt_opcode (UNOP_MEMVAL);
1660 write_exp_elt_type (yyvsp[-2].tval);
1661 write_exp_elt_opcode (UNOP_MEMVAL); }
1662 break;
1663
1664 case 45:
1665 #line 395 "m2-exp.y"
1666 { write_exp_elt_opcode (UNOP_CAST);
1667 write_exp_elt_type (yyvsp[-3].tval);
1668 write_exp_elt_opcode (UNOP_CAST); }
1669 break;
1670
1671 case 46:
1672 #line 401 "m2-exp.y"
1673 { }
1674 break;
1675
1676 case 47:
1677 #line 409 "m2-exp.y"
1678 { write_exp_elt_opcode (BINOP_REPEAT); }
1679 break;
1680
1681 case 48:
1682 #line 413 "m2-exp.y"
1683 { write_exp_elt_opcode (BINOP_MUL); }
1684 break;
1685
1686 case 49:
1687 #line 417 "m2-exp.y"
1688 { write_exp_elt_opcode (BINOP_DIV); }
1689 break;
1690
1691 case 50:
1692 #line 421 "m2-exp.y"
1693 { write_exp_elt_opcode (BINOP_INTDIV); }
1694 break;
1695
1696 case 51:
1697 #line 425 "m2-exp.y"
1698 { write_exp_elt_opcode (BINOP_REM); }
1699 break;
1700
1701 case 52:
1702 #line 429 "m2-exp.y"
1703 { write_exp_elt_opcode (BINOP_ADD); }
1704 break;
1705
1706 case 53:
1707 #line 433 "m2-exp.y"
1708 { write_exp_elt_opcode (BINOP_SUB); }
1709 break;
1710
1711 case 54:
1712 #line 437 "m2-exp.y"
1713 { write_exp_elt_opcode (BINOP_EQUAL); }
1714 break;
1715
1716 case 55:
1717 #line 441 "m2-exp.y"
1718 { write_exp_elt_opcode (BINOP_NOTEQUAL); }
1719 break;
1720
1721 case 56:
1722 #line 443 "m2-exp.y"
1723 { write_exp_elt_opcode (BINOP_NOTEQUAL); }
1724 break;
1725
1726 case 57:
1727 #line 447 "m2-exp.y"
1728 { write_exp_elt_opcode (BINOP_LEQ); }
1729 break;
1730
1731 case 58:
1732 #line 451 "m2-exp.y"
1733 { write_exp_elt_opcode (BINOP_GEQ); }
1734 break;
1735
1736 case 59:
1737 #line 455 "m2-exp.y"
1738 { write_exp_elt_opcode (BINOP_LESS); }
1739 break;
1740
1741 case 60:
1742 #line 459 "m2-exp.y"
1743 { write_exp_elt_opcode (BINOP_GTR); }
1744 break;
1745
1746 case 61:
1747 #line 463 "m2-exp.y"
1748 { write_exp_elt_opcode (BINOP_LOGICAL_AND); }
1749 break;
1750
1751 case 62:
1752 #line 467 "m2-exp.y"
1753 { write_exp_elt_opcode (BINOP_LOGICAL_OR); }
1754 break;
1755
1756 case 63:
1757 #line 471 "m2-exp.y"
1758 { write_exp_elt_opcode (BINOP_ASSIGN); }
1759 break;
1760
1761 case 64:
1762 #line 478 "m2-exp.y"
1763 { write_exp_elt_opcode (OP_BOOL);
1764 write_exp_elt_longcst ((LONGEST) yyvsp[0].ulval);
1765 write_exp_elt_opcode (OP_BOOL); }
1766 break;
1767
1768 case 65:
1769 #line 484 "m2-exp.y"
1770 { write_exp_elt_opcode (OP_BOOL);
1771 write_exp_elt_longcst ((LONGEST) yyvsp[0].ulval);
1772 write_exp_elt_opcode (OP_BOOL); }
1773 break;
1774
1775 case 66:
1776 #line 490 "m2-exp.y"
1777 { write_exp_elt_opcode (OP_LONG);
1778 write_exp_elt_type (builtin_type_m2_int);
1779 write_exp_elt_longcst ((LONGEST) yyvsp[0].lval);
1780 write_exp_elt_opcode (OP_LONG); }
1781 break;
1782
1783 case 67:
1784 #line 497 "m2-exp.y"
1785 {
1786 write_exp_elt_opcode (OP_LONG);
1787 write_exp_elt_type (builtin_type_m2_card);
1788 write_exp_elt_longcst ((LONGEST) yyvsp[0].ulval);
1789 write_exp_elt_opcode (OP_LONG);
1790 }
1791 break;
1792
1793 case 68:
1794 #line 506 "m2-exp.y"
1795 { write_exp_elt_opcode (OP_LONG);
1796 write_exp_elt_type (builtin_type_m2_char);
1797 write_exp_elt_longcst ((LONGEST) yyvsp[0].ulval);
1798 write_exp_elt_opcode (OP_LONG); }
1799 break;
1800
1801 case 69:
1802 #line 514 "m2-exp.y"
1803 { write_exp_elt_opcode (OP_DOUBLE);
1804 write_exp_elt_type (builtin_type_m2_real);
1805 write_exp_elt_dblcst (yyvsp[0].dval);
1806 write_exp_elt_opcode (OP_DOUBLE); }
1807 break;
1808
1809 case 71:
1810 #line 524 "m2-exp.y"
1811 { write_exp_elt_opcode (OP_LONG);
1812 write_exp_elt_type (builtin_type_int);
1813 write_exp_elt_longcst ((LONGEST) TYPE_LENGTH (yyvsp[-1].tval));
1814 write_exp_elt_opcode (OP_LONG); }
1815 break;
1816
1817 case 72:
1818 #line 531 "m2-exp.y"
1819 { write_exp_elt_opcode (OP_M2_STRING);
1820 write_exp_string (yyvsp[0].sval);
1821 write_exp_elt_opcode (OP_M2_STRING); }
1822 break;
1823
1824 case 73:
1825 #line 538 "m2-exp.y"
1826 { yyval.bval = SYMBOL_BLOCK_VALUE(yyvsp[0].sym); }
1827 break;
1828
1829 case 74:
1830 #line 542 "m2-exp.y"
1831 { struct symbol *sym
1832 = lookup_symbol (copy_name (yyvsp[0].sval), expression_context_block,
1833 VAR_DOMAIN, 0, NULL);
1834 yyval.sym = sym;}
1835 break;
1836
1837 case 75:
1838 #line 551 "m2-exp.y"
1839 { struct symbol *tem
1840 = lookup_symbol (copy_name (yyvsp[0].sval), yyvsp[-2].bval,
1841 VAR_DOMAIN, 0, NULL);
1842 if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
1843 error ("No function \"%s\" in specified context.",
1844 copy_name (yyvsp[0].sval));
1845 yyval.sym = tem;
1846 }
1847 break;
1848
1849 case 76:
1850 #line 563 "m2-exp.y"
1851 { write_exp_elt_opcode(OP_VAR_VALUE);
1852 write_exp_elt_block (NULL);
1853 write_exp_elt_sym (yyvsp[0].sym);
1854 write_exp_elt_opcode (OP_VAR_VALUE); }
1855 break;
1856
1857 case 78:
1858 #line 575 "m2-exp.y"
1859 { struct symbol *sym;
1860 sym = lookup_symbol (copy_name (yyvsp[0].sval), yyvsp[-2].bval,
1861 VAR_DOMAIN, 0, NULL);
1862 if (sym == 0)
1863 error ("No symbol \"%s\" in specified context.",
1864 copy_name (yyvsp[0].sval));
1865
1866 write_exp_elt_opcode (OP_VAR_VALUE);
1867 /* block_found is set by lookup_symbol. */
1868 write_exp_elt_block (block_found);
1869 write_exp_elt_sym (sym);
1870 write_exp_elt_opcode (OP_VAR_VALUE); }
1871 break;
1872
1873 case 79:
1874 #line 591 "m2-exp.y"
1875 { struct symbol *sym;
1876 int is_a_field_of_this;
1877
1878 sym = lookup_symbol (copy_name (yyvsp[0].sval),
1879 expression_context_block,
1880 VAR_DOMAIN,
1881 &is_a_field_of_this,
1882 NULL);
1883 if (sym)
1884 {
1885 if (symbol_read_needs_frame (sym))
1886 {
1887 if (innermost_block == 0 ||
1888 contained_in (block_found,
1889 innermost_block))
1890 innermost_block = block_found;
1891 }
1892
1893 write_exp_elt_opcode (OP_VAR_VALUE);
1894 /* We want to use the selected frame, not
1895 another more inner frame which happens to
1896 be in the same block. */
1897 write_exp_elt_block (NULL);
1898 write_exp_elt_sym (sym);
1899 write_exp_elt_opcode (OP_VAR_VALUE);
1900 }
1901 else
1902 {
1903 struct minimal_symbol *msymbol;
1904 char *arg = copy_name (yyvsp[0].sval);
1905
1906 msymbol =
1907 lookup_minimal_symbol (arg, NULL, NULL);
1908 if (msymbol != NULL)
1909 {
1910 write_exp_msymbol
1911 (msymbol,
1912 lookup_function_type (builtin_type_int),
1913 builtin_type_int);
1914 }
1915 else if (!have_full_symbols () && !have_partial_symbols ())
1916 error ("No symbol table is loaded. Use the \"symbol-file\" command.");
1917 else
1918 error ("No symbol \"%s\" in current context.",
1919 copy_name (yyvsp[0].sval));
1920 }
1921 }
1922 break;
1923
1924 case 80:
1925 #line 642 "m2-exp.y"
1926 { yyval.tval = lookup_typename (copy_name (yyvsp[0].sval),
1927 expression_context_block, 0); }
1928 break;
1929
1930
1931 }
1932
1933 /* Line 1000 of yacc.c. */
1934
1935 yyvsp -= yylen;
1936 yyssp -= yylen;
1937
1938
1939 YY_STACK_PRINT (yyss, yyssp);
1940
1941 *++yyvsp = yyval;
1942
1943
1944 /* Now `shift' the result of the reduction. Determine what state
1945 that goes to, based on the state we popped back to and the rule
1946 number reduced by. */
1947
1948 yyn = yyr1[yyn];
1949
1950 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1951 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1952 yystate = yytable[yystate];
1953 else
1954 yystate = yydefgoto[yyn - YYNTOKENS];
1955
1956 goto yynewstate;
1957
1958
1959 /*------------------------------------.
1960 | yyerrlab -- here on detecting error |
1961 `------------------------------------*/
1962 yyerrlab:
1963 /* If not already recovering from an error, report this error. */
1964 if (!yyerrstatus)
1965 {
1966 ++yynerrs;
1967 #if YYERROR_VERBOSE
1968 yyn = yypact[yystate];
1969
1970 if (YYPACT_NINF < yyn && yyn < YYLAST)
1971 {
1972 YYSIZE_T yysize = 0;
1973 int yytype = YYTRANSLATE (yychar);
1974 const char* yyprefix;
1975 char *yymsg;
1976 int yyx;
1977
1978 /* Start YYX at -YYN if negative to avoid negative indexes in
1979 YYCHECK. */
1980 int yyxbegin = yyn < 0 ? -yyn : 0;
1981
1982 /* Stay within bounds of both yycheck and yytname. */
1983 int yychecklim = YYLAST - yyn;
1984 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1985 int yycount = 0;
1986
1987 yyprefix = ", expecting ";
1988 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1989 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1990 {
1991 yysize += yystrlen (yyprefix) + yystrlen (yytname [yyx]);
1992 yycount += 1;
1993 if (yycount == 5)
1994 {
1995 yysize = 0;
1996 break;
1997 }
1998 }
1999 yysize += (sizeof ("syntax error, unexpected ")
2000 + yystrlen (yytname[yytype]));
2001 yymsg = (char *) YYSTACK_ALLOC (yysize);
2002 if (yymsg != 0)
2003 {
2004 char *yyp = yystpcpy (yymsg, "syntax error, unexpected ");
2005 yyp = yystpcpy (yyp, yytname[yytype]);
2006
2007 if (yycount < 5)
2008 {
2009 yyprefix = ", expecting ";
2010 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
2011 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
2012 {
2013 yyp = yystpcpy (yyp, yyprefix);
2014 yyp = yystpcpy (yyp, yytname[yyx]);
2015 yyprefix = " or ";
2016 }
2017 }
2018 yyerror (yymsg);
2019 YYSTACK_FREE (yymsg);
2020 }
2021 else
2022 yyerror ("syntax error; also virtual memory exhausted");
2023 }
2024 else
2025 #endif /* YYERROR_VERBOSE */
2026 yyerror ("syntax error");
2027 }
2028
2029
2030
2031 if (yyerrstatus == 3)
2032 {
2033 /* If just tried and failed to reuse lookahead token after an
2034 error, discard it. */
2035
2036 if (yychar <= YYEOF)
2037 {
2038 /* If at end of input, pop the error token,
2039 then the rest of the stack, then return failure. */
2040 if (yychar == YYEOF)
2041 for (;;)
2042 {
2043 YYPOPSTACK;
2044 if (yyssp == yyss)
2045 YYABORT;
2046 YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
2047 yydestruct (yystos[*yyssp], yyvsp);
2048 }
2049 }
2050 else
2051 {
2052 YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc);
2053 yydestruct (yytoken, &yylval);
2054 yychar = YYEMPTY;
2055
2056 }
2057 }
2058
2059 /* Else will try to reuse lookahead token after shifting the error
2060 token. */
2061 goto yyerrlab1;
2062
2063
2064 /*---------------------------------------------------.
2065 | yyerrorlab -- error raised explicitly by YYERROR. |
2066 `---------------------------------------------------*/
2067 yyerrorlab:
2068
2069 #ifdef __GNUC__
2070 /* Pacify GCC when the user code never invokes YYERROR and the label
2071 yyerrorlab therefore never appears in user code. */
2072 if (0)
2073 goto yyerrorlab;
2074 #endif
2075
2076 yyvsp -= yylen;
2077 yyssp -= yylen;
2078 yystate = *yyssp;
2079 goto yyerrlab1;
2080
2081
2082 /*-------------------------------------------------------------.
2083 | yyerrlab1 -- common code for both syntax error and YYERROR. |
2084 `-------------------------------------------------------------*/
2085 yyerrlab1:
2086 yyerrstatus = 3; /* Each real token shifted decrements this. */
2087
2088 for (;;)
2089 {
2090 yyn = yypact[yystate];
2091 if (yyn != YYPACT_NINF)
2092 {
2093 yyn += YYTERROR;
2094 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
2095 {
2096 yyn = yytable[yyn];
2097 if (0 < yyn)
2098 break;
2099 }
2100 }
2101
2102 /* Pop the current state because it cannot handle the error token. */
2103 if (yyssp == yyss)
2104 YYABORT;
2105
2106 YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
2107 yydestruct (yystos[yystate], yyvsp);
2108 YYPOPSTACK;
2109 yystate = *yyssp;
2110 YY_STACK_PRINT (yyss, yyssp);
2111 }
2112
2113 if (yyn == YYFINAL)
2114 YYACCEPT;
2115
2116 YYDPRINTF ((stderr, "Shifting error token, "));
2117
2118 *++yyvsp = yylval;
2119
2120
2121 yystate = yyn;
2122 goto yynewstate;
2123
2124
2125 /*-------------------------------------.
2126 | yyacceptlab -- YYACCEPT comes here. |
2127 `-------------------------------------*/
2128 yyacceptlab:
2129 yyresult = 0;
2130 goto yyreturn;
2131
2132 /*-----------------------------------.
2133 | yyabortlab -- YYABORT comes here. |
2134 `-----------------------------------*/
2135 yyabortlab:
2136 yyresult = 1;
2137 goto yyreturn;
2138
2139 #ifndef yyoverflow
2140 /*----------------------------------------------.
2141 | yyoverflowlab -- parser overflow comes here. |
2142 `----------------------------------------------*/
2143 yyoverflowlab:
2144 yyerror ("parser stack overflow");
2145 yyresult = 2;
2146 /* Fall through. */
2147 #endif
2148
2149 yyreturn:
2150 #ifndef yyoverflow
2151 if (yyss != yyssa)
2152 YYSTACK_FREE (yyss);
2153 #endif
2154 return yyresult;
2155 }
2156
2157
2158 #line 647 "m2-exp.y"
2159
2160
2161 #if 0 /* FIXME! */
2162 int
2163 overflow(a,b)
2164 long a,b;
2165 {
2166 return (MAX_OF_TYPE(builtin_type_m2_int) - b) < a;
2167 }
2168
2169 int
2170 uoverflow(a,b)
2171 unsigned long a,b;
2172 {
2173 return (MAX_OF_TYPE(builtin_type_m2_card) - b) < a;
2174 }
2175 #endif /* FIXME */
2176
2177 /* Take care of parsing a number (anything that starts with a digit).
2178 Set yylval and return the token type; update lexptr.
2179 LEN is the number of characters in it. */
2180
2181 /*** Needs some error checking for the float case ***/
2182
2183 static int
parse_number(olen)2184 parse_number (olen)
2185 int olen;
2186 {
2187 char *p = lexptr;
2188 LONGEST n = 0;
2189 LONGEST prevn = 0;
2190 int c,i,ischar=0;
2191 int base = input_radix;
2192 int len = olen;
2193 int unsigned_p = number_sign == 1 ? 1 : 0;
2194
2195 if(p[len-1] == 'H')
2196 {
2197 base = 16;
2198 len--;
2199 }
2200 else if(p[len-1] == 'C' || p[len-1] == 'B')
2201 {
2202 base = 8;
2203 ischar = p[len-1] == 'C';
2204 len--;
2205 }
2206
2207 /* Scan the number */
2208 for (c = 0; c < len; c++)
2209 {
2210 if (p[c] == '.' && base == 10)
2211 {
2212 /* It's a float since it contains a point. */
2213 yylval.dval = atof (p);
2214 lexptr += len;
2215 return FLOAT;
2216 }
2217 if (p[c] == '.' && base != 10)
2218 error("Floating point numbers must be base 10.");
2219 if (base == 10 && (p[c] < '0' || p[c] > '9'))
2220 error("Invalid digit \'%c\' in number.",p[c]);
2221 }
2222
2223 while (len-- > 0)
2224 {
2225 c = *p++;
2226 n *= base;
2227 if( base == 8 && (c == '8' || c == '9'))
2228 error("Invalid digit \'%c\' in octal number.",c);
2229 if (c >= '0' && c <= '9')
2230 i = c - '0';
2231 else
2232 {
2233 if (base == 16 && c >= 'A' && c <= 'F')
2234 i = c - 'A' + 10;
2235 else
2236 return ERROR;
2237 }
2238 n+=i;
2239 if(i >= base)
2240 return ERROR;
2241 if(!unsigned_p && number_sign == 1 && (prevn >= n))
2242 unsigned_p=1; /* Try something unsigned */
2243 /* Don't do the range check if n==i and i==0, since that special
2244 case will give an overflow error. */
2245 if(RANGE_CHECK && n!=i && i)
2246 {
2247 if((unsigned_p && (unsigned)prevn >= (unsigned)n) ||
2248 ((!unsigned_p && number_sign==-1) && -prevn <= -n))
2249 range_error("Overflow on numeric constant.");
2250 }
2251 prevn=n;
2252 }
2253
2254 lexptr = p;
2255 if(*p == 'B' || *p == 'C' || *p == 'H')
2256 lexptr++; /* Advance past B,C or H */
2257
2258 if (ischar)
2259 {
2260 yylval.ulval = n;
2261 return CHAR;
2262 }
2263 else if ( unsigned_p && number_sign == 1)
2264 {
2265 yylval.ulval = n;
2266 return UINT;
2267 }
2268 else if((unsigned_p && (n<0))) {
2269 range_error("Overflow on numeric constant -- number too large.");
2270 /* But, this can return if range_check == range_warn. */
2271 }
2272 yylval.lval = n;
2273 return INT;
2274 }
2275
2276
2277 /* Some tokens */
2278
2279 static struct
2280 {
2281 char name[2];
2282 int token;
2283 } tokentab2[] =
2284 {
2285 { {'<', '>'}, NOTEQUAL },
2286 { {':', '='}, ASSIGN },
2287 { {'<', '='}, LEQ },
2288 { {'>', '='}, GEQ },
2289 { {':', ':'}, COLONCOLON },
2290
2291 };
2292
2293 /* Some specific keywords */
2294
2295 struct keyword {
2296 char keyw[10];
2297 int token;
2298 };
2299
2300 static struct keyword keytab[] =
2301 {
2302 {"OR" , OROR },
2303 {"IN", IN },/* Note space after IN */
2304 {"AND", LOGICAL_AND},
2305 {"ABS", ABS },
2306 {"CHR", CHR },
2307 {"DEC", DEC },
2308 {"NOT", NOT },
2309 {"DIV", DIV },
2310 {"INC", INC },
2311 {"MAX", MAX_FUNC },
2312 {"MIN", MIN_FUNC },
2313 {"MOD", MOD },
2314 {"ODD", ODD },
2315 {"CAP", CAP },
2316 {"ORD", ORD },
2317 {"VAL", VAL },
2318 {"EXCL", EXCL },
2319 {"HIGH", HIGH },
2320 {"INCL", INCL },
2321 {"SIZE", SIZE },
2322 {"FLOAT", FLOAT_FUNC },
2323 {"TRUNC", TRUNC },
2324 };
2325
2326
2327 /* Read one token, getting characters through lexptr. */
2328
2329 /* This is where we will check to make sure that the language and the operators used are
2330 compatible */
2331
2332 static int
yylex()2333 yylex ()
2334 {
2335 int c;
2336 int namelen;
2337 int i;
2338 char *tokstart;
2339 char quote;
2340
2341 retry:
2342
2343 prev_lexptr = lexptr;
2344
2345 tokstart = lexptr;
2346
2347
2348 /* See if it is a special token of length 2 */
2349 for( i = 0 ; i < (int) (sizeof tokentab2 / sizeof tokentab2[0]) ; i++)
2350 if(DEPRECATED_STREQN(tokentab2[i].name, tokstart, 2))
2351 {
2352 lexptr += 2;
2353 return tokentab2[i].token;
2354 }
2355
2356 switch (c = *tokstart)
2357 {
2358 case 0:
2359 return 0;
2360
2361 case ' ':
2362 case '\t':
2363 case '\n':
2364 lexptr++;
2365 goto retry;
2366
2367 case '(':
2368 paren_depth++;
2369 lexptr++;
2370 return c;
2371
2372 case ')':
2373 if (paren_depth == 0)
2374 return 0;
2375 paren_depth--;
2376 lexptr++;
2377 return c;
2378
2379 case ',':
2380 if (comma_terminates && paren_depth == 0)
2381 return 0;
2382 lexptr++;
2383 return c;
2384
2385 case '.':
2386 /* Might be a floating point number. */
2387 if (lexptr[1] >= '0' && lexptr[1] <= '9')
2388 break; /* Falls into number code. */
2389 else
2390 {
2391 lexptr++;
2392 return DOT;
2393 }
2394
2395 /* These are character tokens that appear as-is in the YACC grammar */
2396 case '+':
2397 case '-':
2398 case '*':
2399 case '/':
2400 case '^':
2401 case '<':
2402 case '>':
2403 case '[':
2404 case ']':
2405 case '=':
2406 case '{':
2407 case '}':
2408 case '#':
2409 case '@':
2410 case '~':
2411 case '&':
2412 lexptr++;
2413 return c;
2414
2415 case '\'' :
2416 case '"':
2417 quote = c;
2418 for (namelen = 1; (c = tokstart[namelen]) != quote && c != '\0'; namelen++)
2419 if (c == '\\')
2420 {
2421 c = tokstart[++namelen];
2422 if (c >= '0' && c <= '9')
2423 {
2424 c = tokstart[++namelen];
2425 if (c >= '0' && c <= '9')
2426 c = tokstart[++namelen];
2427 }
2428 }
2429 if(c != quote)
2430 error("Unterminated string or character constant.");
2431 yylval.sval.ptr = tokstart + 1;
2432 yylval.sval.length = namelen - 1;
2433 lexptr += namelen + 1;
2434
2435 if(namelen == 2) /* Single character */
2436 {
2437 yylval.ulval = tokstart[1];
2438 return CHAR;
2439 }
2440 else
2441 return STRING;
2442 }
2443
2444 /* Is it a number? */
2445 /* Note: We have already dealt with the case of the token '.'.
2446 See case '.' above. */
2447 if ((c >= '0' && c <= '9'))
2448 {
2449 /* It's a number. */
2450 int got_dot = 0, got_e = 0;
2451 char *p = tokstart;
2452 int toktype;
2453
2454 for (++p ;; ++p)
2455 {
2456 if (!got_e && (*p == 'e' || *p == 'E'))
2457 got_dot = got_e = 1;
2458 else if (!got_dot && *p == '.')
2459 got_dot = 1;
2460 else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
2461 && (*p == '-' || *p == '+'))
2462 /* This is the sign of the exponent, not the end of the
2463 number. */
2464 continue;
2465 else if ((*p < '0' || *p > '9') &&
2466 (*p < 'A' || *p > 'F') &&
2467 (*p != 'H')) /* Modula-2 hexadecimal number */
2468 break;
2469 }
2470 toktype = parse_number (p - tokstart);
2471 if (toktype == ERROR)
2472 {
2473 char *err_copy = (char *) alloca (p - tokstart + 1);
2474
2475 memcpy (err_copy, tokstart, p - tokstart);
2476 err_copy[p - tokstart] = 0;
2477 error ("Invalid number \"%s\".", err_copy);
2478 }
2479 lexptr = p;
2480 return toktype;
2481 }
2482
2483 if (!(c == '_' || c == '$'
2484 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
2485 /* We must have come across a bad character (e.g. ';'). */
2486 error ("Invalid character '%c' in expression.", c);
2487
2488 /* It's a name. See how long it is. */
2489 namelen = 0;
2490 for (c = tokstart[namelen];
2491 (c == '_' || c == '$' || (c >= '0' && c <= '9')
2492 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));
2493 c = tokstart[++namelen])
2494 ;
2495
2496 /* The token "if" terminates the expression and is NOT
2497 removed from the input stream. */
2498 if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f')
2499 {
2500 return 0;
2501 }
2502
2503 lexptr += namelen;
2504
2505 /* Lookup special keywords */
2506 for(i = 0 ; i < (int) (sizeof(keytab) / sizeof(keytab[0])) ; i++)
2507 if(namelen == strlen(keytab[i].keyw) && DEPRECATED_STREQN(tokstart,keytab[i].keyw,namelen))
2508 return keytab[i].token;
2509
2510 yylval.sval.ptr = tokstart;
2511 yylval.sval.length = namelen;
2512
2513 if (*tokstart == '$')
2514 {
2515 write_dollar_variable (yylval.sval);
2516 return INTERNAL_VAR;
2517 }
2518
2519 /* Use token-type BLOCKNAME for symbols that happen to be defined as
2520 functions. If this is not so, then ...
2521 Use token-type TYPENAME for symbols that happen to be defined
2522 currently as names of types; NAME for other symbols.
2523 The caller is not constrained to care about the distinction. */
2524 {
2525
2526
2527 char *tmp = copy_name (yylval.sval);
2528 struct symbol *sym;
2529
2530 if (lookup_partial_symtab (tmp))
2531 return BLOCKNAME;
2532 sym = lookup_symbol (tmp, expression_context_block,
2533 VAR_DOMAIN, 0, NULL);
2534 if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
2535 return BLOCKNAME;
2536 if (lookup_typename (copy_name (yylval.sval), expression_context_block, 1))
2537 return TYPENAME;
2538
2539 if(sym)
2540 {
2541 switch(sym->aclass)
2542 {
2543 case LOC_STATIC:
2544 case LOC_REGISTER:
2545 case LOC_ARG:
2546 case LOC_REF_ARG:
2547 case LOC_REGPARM:
2548 case LOC_REGPARM_ADDR:
2549 case LOC_LOCAL:
2550 case LOC_LOCAL_ARG:
2551 case LOC_BASEREG:
2552 case LOC_BASEREG_ARG:
2553 case LOC_CONST:
2554 case LOC_CONST_BYTES:
2555 case LOC_OPTIMIZED_OUT:
2556 case LOC_COMPUTED:
2557 case LOC_COMPUTED_ARG:
2558 return NAME;
2559
2560 case LOC_TYPEDEF:
2561 return TYPENAME;
2562
2563 case LOC_BLOCK:
2564 return BLOCKNAME;
2565
2566 case LOC_UNDEF:
2567 error("internal: Undefined class in m2lex()");
2568
2569 case LOC_LABEL:
2570 case LOC_UNRESOLVED:
2571 error("internal: Unforseen case in m2lex()");
2572
2573 default:
2574 error ("unhandled token in m2lex()");
2575 break;
2576 }
2577 }
2578 else
2579 {
2580 /* Built-in BOOLEAN type. This is sort of a hack. */
2581 if(DEPRECATED_STREQN(tokstart,"TRUE",4))
2582 {
2583 yylval.ulval = 1;
2584 return M2_TRUE;
2585 }
2586 else if(DEPRECATED_STREQN(tokstart,"FALSE",5))
2587 {
2588 yylval.ulval = 0;
2589 return M2_FALSE;
2590 }
2591 }
2592
2593 /* Must be another type of name... */
2594 return NAME;
2595 }
2596 }
2597
2598 #if 0 /* Unused */
2599 static char *
2600 make_qualname(mod,ident)
2601 char *mod, *ident;
2602 {
2603 char *new = xmalloc(strlen(mod)+strlen(ident)+2);
2604
2605 strcpy(new,mod);
2606 strcat(new,".");
2607 strcat(new,ident);
2608 return new;
2609 }
2610 #endif /* 0 */
2611
2612 void
yyerror(msg)2613 yyerror (msg)
2614 char *msg;
2615 {
2616 if (prev_lexptr)
2617 lexptr = prev_lexptr;
2618
2619 error ("A %s in expression, near `%s'.", (msg ? msg : "error"), lexptr);
2620 }
2621
2622
2623