1 : /* A Bison parser, made by GNU Bison 2.3. */
2 :
3 : /* Skeleton implementation for Bison's Yacc-like parsers in C
4 :
5 : Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
6 : Free Software Foundation, Inc.
7 :
8 : This program is free software; you can redistribute it and/or modify
9 : it under the terms of the GNU General Public License as published by
10 : the Free Software Foundation; either version 2, or (at your option)
11 : any later version.
12 :
13 : This program is distributed in the hope that it will be useful,
14 : but WITHOUT ANY WARRANTY; without even the implied warranty of
15 : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 : GNU General Public License for more details.
17 :
18 : You should have received a copy of the GNU General Public License
19 : along with this program; if not, write to the Free Software
20 : Foundation, Inc., 51 Franklin Street, Fifth Floor,
21 : Boston, MA 02110-1301, USA. */
22 :
23 : /* As a special exception, you may create a larger work that contains
24 : part or all of the Bison parser skeleton and distribute that work
25 : under terms of your choice, so long as that work isn't itself a
26 : parser generator using the skeleton or a modified version thereof
27 : as a parser skeleton. Alternatively, if you modify or redistribute
28 : the parser skeleton itself, you may (at your option) remove this
29 : special exception, which will cause the skeleton and the resulting
30 : Bison output files to be licensed under the GNU General Public
31 : License without this special exception.
32 :
33 : This special exception was added by the Free Software Foundation in
34 : version 2.2 of Bison. */
35 :
36 : /* C LALR(1) parser skeleton written by Richard Stallman, by
37 : simplifying the original so-called "semantic" parser. */
38 :
39 : /* All symbols defined below should begin with yy or YY, to avoid
40 : infringing on user name space. This should be done even for local
41 : variables, as they might otherwise be expanded by user macros.
42 : There are some unavoidable exceptions within include files to
43 : define necessary library symbols; they are noted "INFRINGES ON
44 : USER NAME SPACE" below. */
45 :
46 : /* Identify Bison output. */
47 : #define YYBISON 1
48 :
49 : /* Bison version. */
50 : #define YYBISON_VERSION "2.3"
51 :
52 : /* Skeleton name. */
53 : #define YYSKELETON_NAME "yacc.c"
54 :
55 : /* Pure parsers. */
56 : #define YYPURE 0
57 :
58 : /* Using locations. */
59 : #define YYLSP_NEEDED 0
60 :
61 :
62 :
63 : /* Tokens. */
64 : #ifndef YYTOKENTYPE
65 : # define YYTOKENTYPE
66 : /* Put the tokens into the symbol table, so that GDB and other debuggers
67 : know about them. */
68 : enum yytokentype {
69 : TK_EOL = 258,
70 : TK_LPAREN = 259,
71 : TK_RPAREN = 260,
72 : TK_LBRACK = 261,
73 : TK_RBRACK = 262,
74 : TK_IDENTIFIER = 263,
75 : TK_PRIMITIVE = 264,
76 : STRING_LITERAL = 265,
77 : TK_REDUCE = 266,
78 : TK_TIMEOUT = 267,
79 : NUMERICAL_CONSTANT = 268,
80 : TK_ALGORITHM_NAME = 269,
81 : TK_DEF = 270,
82 : TK_TIME = 271,
83 : TK_LOAD = 272,
84 : TK_ELABORATE = 273,
85 : TK_TRACE = 274,
86 : TK_SINGLE_STEP = 275,
87 : TK_DEBUG = 276,
88 : TK_MAX_COUNT = 277,
89 : TK_SET_BRACKET_ABSTRACTION = 278
90 : };
91 : #endif
92 : /* Tokens. */
93 : #define TK_EOL 258
94 : #define TK_LPAREN 259
95 : #define TK_RPAREN 260
96 : #define TK_LBRACK 261
97 : #define TK_RBRACK 262
98 : #define TK_IDENTIFIER 263
99 : #define TK_PRIMITIVE 264
100 : #define STRING_LITERAL 265
101 : #define TK_REDUCE 266
102 : #define TK_TIMEOUT 267
103 : #define NUMERICAL_CONSTANT 268
104 : #define TK_ALGORITHM_NAME 269
105 : #define TK_DEF 270
106 : #define TK_TIME 271
107 : #define TK_LOAD 272
108 : #define TK_ELABORATE 273
109 : #define TK_TRACE 274
110 : #define TK_SINGLE_STEP 275
111 : #define TK_DEBUG 276
112 : #define TK_MAX_COUNT 277
113 : #define TK_SET_BRACKET_ABSTRACTION 278
114 :
115 :
116 :
117 :
118 : /* Copy the first part of user declarations. */
119 : #line 1 "grammar.y"
120 :
121 : /*
122 : Copyright (C) 2007, Bruce Ediger
123 :
124 : This file is part of cl.
125 :
126 : cl is free software; you can redistribute it and/or modify
127 : it under the terms of the GNU General Public License as published by
128 : the Free Software Foundation; either version 2 of the License, or
129 : (at your option) any later version.
130 :
131 : cl is distributed in the hope that it will be useful,
132 : but WITHOUT ANY WARRANTY; without even the implied warranty of
133 : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
134 : GNU General Public License for more details.
135 :
136 : You should have received a copy of the GNU General Public License
137 : along with cl; if not, write to the Free Software
138 : Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
139 :
140 : */
141 : #include <stdio.h>
142 : #include <errno.h> /* errno */
143 : #include <string.h> /* strerror() */
144 : #include <stdlib.h> /* malloc(), free(), strtoul() */
145 : #include <unistd.h> /* getopt() */
146 : #include <signal.h> /* signal(), etc */
147 : #include <setjmp.h> /* setjmp(), longjmp(), jmp_buf */
148 : #include <sys/time.h> /* gettimeofday(), struct timeval */
149 :
150 : extern char *optarg;
151 :
152 : #include <node.h>
153 : #include <hashtable.h>
154 : #include <atom.h>
155 : #include <graph.h>
156 : #include <abbreviations.h>
157 : #include <spine_stack.h>
158 : #include <bracket_abstraction.h>
159 :
160 : #ifdef YYBISON
161 : #define YYERROR_VERBOSE
162 : #endif
163 :
164 : /* flags, binary on/off for various outputs */
165 : int debug_reduction = 0;
166 : int elaborate_output = 0;
167 : int trace_reduction = 0;
168 : int reduction_timer = 0;
169 : int single_step = 0;
170 : int memory_info = 0;
171 : int count_reductions = 0; /* produce a count of reductions */
172 :
173 : int reduction_timeout = 0; /* how long to let a graph reduction run, seconds */
174 : int max_reduction_count = 0; /* when non-zero, how many reductions to perform */
175 :
176 : int prompting = 1;
177 :
178 : /* Signal handling. in_reduce_graph used to (a) handle
179 : * contrl-C interruptions (b) reduction-run-time timeouts,
180 : * (c) getting out of single-stepped graph reduction in reduce_graph()
181 : */
182 : void sigint_handler(int signo);
183 : sigjmp_buf in_reduce_graph;
184 : int interpreter_interrupted = 0;
185 : int reduction_interrupted = 0;
186 :
187 : void top_level_cleanup(int syntax_error_processing);
188 :
189 : struct node *reduce_tree(struct node *root);
190 : struct node *execute_bracket_abstraction(
191 : struct node *(*bafunc)(struct node *, struct node *),
192 : struct node *abstracted_var,
193 : struct node *root
194 : );
195 : float elapsed_time(struct timeval before, struct timeval after);
196 : void usage(char *progname);
197 :
198 : struct filename_node {
199 : const char *filename;
200 : struct filename_node *next;
201 : };
202 :
203 : /* from lex.l */
204 : extern void set_yyin_stdin(void);
205 : extern void set_yyin(const char *filename);
206 : extern void reset_yyin(void);
207 : extern void push_and_open(const char *filename);
208 :
209 : extern int yylex(void);
210 : int yyerror(char *s1);
211 :
212 : /* Various "treat as combinator" flags.
213 : * For example: S_as_combinator, when set (default) causes
214 : * the lexer to treat "S" as an S-combinator. When unset,
215 : * the lexer treats "S" as any other variable. This can interact
216 : * strangely with bracket abstraction, which assumes that its
217 : * own use of "S" (again, as example) always constitutes a combinator.
218 : */
219 : int S_as_combinator = 1;
220 : int K_as_combinator = 1;
221 : int I_as_combinator = 1;
222 : int B_as_combinator = 1;
223 : int C_as_combinator = 1;
224 : int W_as_combinator = 1;
225 : int T_as_combinator = 1;
226 : int M_as_combinator = 1;
227 :
228 :
229 :
230 : /* Enabling traces. */
231 : #ifndef YYDEBUG
232 : # define YYDEBUG 0
233 : #endif
234 :
235 : /* Enabling verbose error messages. */
236 : #ifdef YYERROR_VERBOSE
237 : # undef YYERROR_VERBOSE
238 : # define YYERROR_VERBOSE 1
239 : #else
240 : # define YYERROR_VERBOSE 0
241 : #endif
242 :
243 : /* Enabling the token table. */
244 : #ifndef YYTOKEN_TABLE
245 : # define YYTOKEN_TABLE 0
246 : #endif
247 :
248 : #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
249 : typedef union YYSTYPE
250 : #line 111 "grammar.y"
251 : {
252 : const char *identifier;
253 : const char *string_constant;
254 : int numerical_constant;
255 : struct node *node;
256 : enum combinatorName cn;
257 : struct node *(*bafunc)(struct node *, struct node *);
258 : }
259 : /* Line 187 of yacc.c. */
260 : #line 261 "y.tab.c"
261 : YYSTYPE;
262 : # define yystype YYSTYPE /* obsolescent; will be withdrawn */
263 : # define YYSTYPE_IS_DECLARED 1
264 : # define YYSTYPE_IS_TRIVIAL 1
265 : #endif
266 :
267 :
268 :
269 : /* Copy the second part of user declarations. */
270 :
271 :
272 : /* Line 216 of yacc.c. */
273 : #line 274 "y.tab.c"
274 :
275 : #ifdef short
276 : # undef short
277 : #endif
278 :
279 : #ifdef YYTYPE_UINT8
280 : typedef YYTYPE_UINT8 yytype_uint8;
281 : #else
282 : typedef unsigned char yytype_uint8;
283 : #endif
284 :
285 : #ifdef YYTYPE_INT8
286 : typedef YYTYPE_INT8 yytype_int8;
287 : #elif (defined __STDC__ || defined __C99__FUNC__ \
288 : || defined __cplusplus || defined _MSC_VER)
289 : typedef signed char yytype_int8;
290 : #else
291 : typedef short int yytype_int8;
292 : #endif
293 :
294 : #ifdef YYTYPE_UINT16
295 : typedef YYTYPE_UINT16 yytype_uint16;
296 : #else
297 : typedef unsigned short int yytype_uint16;
298 : #endif
299 :
300 : #ifdef YYTYPE_INT16
301 : typedef YYTYPE_INT16 yytype_int16;
302 : #else
303 : typedef short int yytype_int16;
304 : #endif
305 :
306 : #ifndef YYSIZE_T
307 : # ifdef __SIZE_TYPE__
308 : # define YYSIZE_T __SIZE_TYPE__
309 : # elif defined size_t
310 : # define YYSIZE_T size_t
311 : # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
312 : || defined __cplusplus || defined _MSC_VER)
313 : # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
314 : # define YYSIZE_T size_t
315 : # else
316 : # define YYSIZE_T unsigned int
317 : # endif
318 : #endif
319 :
320 : #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
321 :
322 : #ifndef YY_
323 : # if YYENABLE_NLS
324 : # if ENABLE_NLS
325 : # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
326 : # define YY_(msgid) dgettext ("bison-runtime", msgid)
327 : # endif
328 : # endif
329 : # ifndef YY_
330 : # define YY_(msgid) msgid
331 : # endif
332 : #endif
333 :
334 : /* Suppress unused-variable warnings by "using" E. */
335 : #if ! defined lint || defined __GNUC__
336 : # define YYUSE(e) ((void) (e))
337 : #else
338 : # define YYUSE(e) /* empty */
339 : #endif
340 :
341 : /* Identity function, used to suppress warnings about constant conditions. */
342 : #ifndef lint
343 : # define YYID(n) (n)
344 : #else
345 : #if (defined __STDC__ || defined __C99__FUNC__ \
346 : || defined __cplusplus || defined _MSC_VER)
347 : static int
348 : YYID (int i)
349 : #else
350 : static int
351 : YYID (i)
352 : int i;
353 : #endif
354 : {
355 : return i;
356 : }
357 : #endif
358 :
359 : #if ! defined yyoverflow || YYERROR_VERBOSE
360 :
361 : /* The parser invokes alloca or malloc; define the necessary symbols. */
362 :
363 : # ifdef YYSTACK_USE_ALLOCA
364 : # if YYSTACK_USE_ALLOCA
365 : # ifdef __GNUC__
366 : # define YYSTACK_ALLOC __builtin_alloca
367 : # elif defined __BUILTIN_VA_ARG_INCR
368 : # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
369 : # elif defined _AIX
370 : # define YYSTACK_ALLOC __alloca
371 : # elif defined _MSC_VER
372 : # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
373 : # define alloca _alloca
374 : # else
375 : # define YYSTACK_ALLOC alloca
376 : # if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
377 : || defined __cplusplus || defined _MSC_VER)
378 : # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
379 : # ifndef _STDLIB_H
380 : # define _STDLIB_H 1
381 : # endif
382 : # endif
383 : # endif
384 : # endif
385 : # endif
386 :
387 : # ifdef YYSTACK_ALLOC
388 : /* Pacify GCC's `empty if-body' warning. */
389 : # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
390 : # ifndef YYSTACK_ALLOC_MAXIMUM
391 : /* The OS might guarantee only one guard page at the bottom of the stack,
392 : and a page size can be as small as 4096 bytes. So we cannot safely
393 : invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
394 : to allow for a few compiler-allocated temporary stack slots. */
395 : # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
396 : # endif
397 : # else
398 : # define YYSTACK_ALLOC YYMALLOC
399 : # define YYSTACK_FREE YYFREE
400 : # ifndef YYSTACK_ALLOC_MAXIMUM
401 : # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
402 : # endif
403 : # if (defined __cplusplus && ! defined _STDLIB_H \
404 : && ! ((defined YYMALLOC || defined malloc) \
405 : && (defined YYFREE || defined free)))
406 : # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
407 : # ifndef _STDLIB_H
408 : # define _STDLIB_H 1
409 : # endif
410 : # endif
411 : # ifndef YYMALLOC
412 : # define YYMALLOC malloc
413 : # if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
414 : || defined __cplusplus || defined _MSC_VER)
415 : void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
416 : # endif
417 : # endif
418 : # ifndef YYFREE
419 : # define YYFREE free
420 : # if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
421 : || defined __cplusplus || defined _MSC_VER)
422 : void free (void *); /* INFRINGES ON USER NAME SPACE */
423 : # endif
424 : # endif
425 : # endif
426 : #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
427 :
428 :
429 : #if (! defined yyoverflow \
430 : && (! defined __cplusplus \
431 : || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
432 :
433 : /* A type that is properly aligned for any stack member. */
434 : union yyalloc
435 : {
436 : yytype_int16 yyss;
437 : YYSTYPE yyvs;
438 : };
439 :
440 : /* The size of the maximum gap between one aligned stack and the next. */
441 : # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
442 :
443 : /* The size of an array large to enough to hold all stacks, each with
444 : N elements. */
445 : # define YYSTACK_BYTES(N) \
446 : ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
447 : + YYSTACK_GAP_MAXIMUM)
448 :
449 : /* Copy COUNT objects from FROM to TO. The source and destination do
450 : not overlap. */
451 : # ifndef YYCOPY
452 : # if defined __GNUC__ && 1 < __GNUC__
453 : # define YYCOPY(To, From, Count) \
454 : __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
455 : # else
456 : # define YYCOPY(To, From, Count) \
457 : do \
458 : { \
459 : YYSIZE_T yyi; \
460 : for (yyi = 0; yyi < (Count); yyi++) \
461 : (To)[yyi] = (From)[yyi]; \
462 : } \
463 : while (YYID (0))
464 : # endif
465 : # endif
466 :
467 : /* Relocate STACK from its old location to the new one. The
468 : local variables YYSIZE and YYSTACKSIZE give the old and new number of
469 : elements in the stack, and YYPTR gives the new location of the
470 : stack. Advance YYPTR to a properly aligned location for the next
471 : stack. */
472 : # define YYSTACK_RELOCATE(Stack) \
473 : do \
474 : { \
475 : YYSIZE_T yynewbytes; \
476 : YYCOPY (&yyptr->Stack, Stack, yysize); \
477 : Stack = &yyptr->Stack; \
478 : yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
479 : yyptr += yynewbytes / sizeof (*yyptr); \
480 : } \
481 : while (YYID (0))
482 :
483 : #endif
484 :
485 : /* YYFINAL -- State number of the termination state. */
486 : #define YYFINAL 39
487 : /* YYLAST -- Last index in YYTABLE. */
488 : #define YYLAST 68
489 :
490 : /* YYNTOKENS -- Number of terminals. */
491 : #define YYNTOKENS 24
492 : /* YYNNTS -- Number of nonterminals. */
493 : #define YYNNTS 10
494 : /* YYNRULES -- Number of rules. */
495 : #define YYNRULES 30
496 : /* YYNRULES -- Number of states. */
497 : #define YYNSTATES 55
498 :
499 : /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
500 : #define YYUNDEFTOK 2
501 : #define YYMAXUTOK 278
502 :
503 : #define YYTRANSLATE(YYX) \
504 : ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
505 :
506 : /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
507 : static const yytype_uint8 yytranslate[] =
508 : {
509 : 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
510 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
511 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
512 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
513 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
514 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
515 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
516 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
517 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
518 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
519 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
520 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
521 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
522 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
523 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
524 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
525 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
526 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
527 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
528 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
529 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
530 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
531 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
532 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
533 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
534 : 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
535 : 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
536 : 15, 16, 17, 18, 19, 20, 21, 22, 23
537 : };
538 :
539 : #if YYDEBUG
540 : /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
541 : YYRHS. */
542 : static const yytype_uint8 yyprhs[] =
543 : {
544 : 0, 0, 3, 5, 8, 10, 13, 18, 20, 22,
545 : 25, 28, 31, 34, 37, 41, 45, 49, 53, 55,
546 : 57, 60, 64, 66, 67, 70, 73, 77, 79, 81,
547 : 85
548 : };
549 :
550 : /* YYRHS -- A `-1'-separated list of the rules' RHS. */
551 : static const yytype_int8 yyrhs[] =
552 : {
553 : 25, 0, -1, 26, -1, 25, 26, -1, 1, -1,
554 : 28, 3, -1, 15, 8, 28, 3, -1, 27, -1,
555 : 3, -1, 16, 3, -1, 18, 3, -1, 21, 3,
556 : -1, 19, 3, -1, 20, 3, -1, 17, 10, 3,
557 : -1, 12, 13, 3, -1, 22, 13, 3, -1, 23,
558 : 14, 3, -1, 30, -1, 32, -1, 11, 28, -1,
559 : 31, 29, 28, -1, 14, -1, -1, 32, 32, -1,
560 : 30, 32, -1, 6, 8, 7, -1, 33, -1, 8,
561 : -1, 4, 28, 5, -1, 9, -1
562 : };
563 :
564 : /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
565 : static const yytype_uint8 yyrline[] =
566 : {
567 : 0, 139, 139, 140, 141, 146, 154, 160, 161, 165,
568 : 166, 167, 168, 169, 170, 171, 172, 173, 177, 178,
569 : 179, 188, 199, 200, 204, 205, 209, 214, 215, 221,
570 : 225
571 : };
572 : #endif
573 :
574 : #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
575 : /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
576 : First, the terminals, then, starting at YYNTOKENS, nonterminals. */
577 : static const char *const yytname[] =
578 : {
579 : "$end", "error", "$undefined", "TK_EOL", "TK_LPAREN", "TK_RPAREN",
580 : "TK_LBRACK", "TK_RBRACK", "TK_IDENTIFIER", "TK_PRIMITIVE",
581 : "STRING_LITERAL", "TK_REDUCE", "TK_TIMEOUT", "NUMERICAL_CONSTANT",
582 : "TK_ALGORITHM_NAME", "TK_DEF", "TK_TIME", "TK_LOAD", "TK_ELABORATE",
583 : "TK_TRACE", "TK_SINGLE_STEP", "TK_DEBUG", "TK_MAX_COUNT",
584 : "TK_SET_BRACKET_ABSTRACTION", "$accept", "program", "stmnt",
585 : "interpreter_command", "expression", "abstraction_algorithm",
586 : "application", "bracket_abstraction", "term", "constant", 0
587 : };
588 : #endif
589 :
590 : # ifdef YYPRINT
591 : /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
592 : token YYLEX-NUM. */
593 : static const yytype_uint16 yytoknum[] =
594 : {
595 : 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
596 : 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
597 : 275, 276, 277, 278
598 : };
599 : # endif
600 :
601 : /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
602 : static const yytype_uint8 yyr1[] =
603 : {
604 : 0, 24, 25, 25, 25, 26, 26, 26, 26, 27,
605 : 27, 27, 27, 27, 27, 27, 27, 27, 28, 28,
606 : 28, 28, 29, 29, 30, 30, 31, 32, 32, 32,
607 : 33
608 : };
609 :
610 : /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
611 : static const yytype_uint8 yyr2[] =
612 : {
613 : 0, 2, 1, 2, 1, 2, 4, 1, 1, 2,
614 : 2, 2, 2, 2, 3, 3, 3, 3, 1, 1,
615 : 2, 3, 1, 0, 2, 2, 3, 1, 1, 3,
616 : 1
617 : };
618 :
619 : /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
620 : STATE-NUM when YYTABLE doesn't specify something else to do. Zero
621 : means the default is an error. */
622 : static const yytype_uint8 yydefact[] =
623 : {
624 : 0, 4, 8, 0, 0, 28, 30, 0, 0, 0,
625 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 2,
626 : 7, 0, 18, 23, 19, 27, 0, 0, 20, 0,
627 : 0, 9, 0, 10, 12, 13, 11, 0, 0, 1,
628 : 3, 5, 25, 22, 0, 24, 29, 26, 15, 0,
629 : 14, 16, 17, 21, 6
630 : };
631 :
632 : /* YYDEFGOTO[NTERM-NUM]. */
633 : static const yytype_int8 yydefgoto[] =
634 : {
635 : -1, 18, 19, 20, 21, 44, 22, 23, 24, 25
636 : };
637 :
638 : /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
639 : STATE-NUM. */
640 : #define YYPACT_NINF -22
641 : static const yytype_int8 yypact[] =
642 : {
643 : 27, -22, -22, 47, -1, -22, -22, 47, -4, 4,
644 : 12, 6, 23, 26, 29, 31, 24, 38, 2, -22,
645 : -22, 37, 53, 40, 53, -22, 54, 56, -22, 57,
646 : 47, -22, 61, -22, -22, -22, -22, 62, 63, -22,
647 : -22, -22, -22, -22, 47, -22, -22, -22, -22, 64,
648 : -22, -22, -22, -22, -22
649 : };
650 :
651 : /* YYPGOTO[NTERM-NUM]. */
652 : static const yytype_int8 yypgoto[] =
653 : {
654 : -22, -22, 50, -22, -3, -22, -22, -22, -21, -22
655 : };
656 :
657 : /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
658 : positive, shift that token. If negative, reduce the rule which
659 : number is the opposite. If zero, do what YYDEFACT says.
660 : If YYTABLE_NINF, syntax error. */
661 : #define YYTABLE_NINF -1
662 : static const yytype_uint8 yytable[] =
663 : {
664 : 26, 42, 39, 45, 28, 2, 3, 27, 4, 29,
665 : 5, 6, 30, 7, 8, 31, 32, 9, 10, 11,
666 : 12, 13, 14, 15, 16, 17, 33, 49, 1, 34,
667 : 2, 3, 35, 4, 36, 5, 6, 37, 7, 8,
668 : 41, 53, 9, 10, 11, 12, 13, 14, 15, 16,
669 : 17, 3, 38, 4, 43, 5, 6, 3, 7, 46,
670 : 48, 5, 6, 47, 50, 51, 52, 54, 40
671 : };
672 :
673 : static const yytype_uint8 yycheck[] =
674 : {
675 : 3, 22, 0, 24, 7, 3, 4, 8, 6, 13,
676 : 8, 9, 8, 11, 12, 3, 10, 15, 16, 17,
677 : 18, 19, 20, 21, 22, 23, 3, 30, 1, 3,
678 : 3, 4, 3, 6, 3, 8, 9, 13, 11, 12,
679 : 3, 44, 15, 16, 17, 18, 19, 20, 21, 22,
680 : 23, 4, 14, 6, 14, 8, 9, 4, 11, 5,
681 : 3, 8, 9, 7, 3, 3, 3, 3, 18
682 : };
683 :
684 : /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
685 : symbol of state STATE-NUM. */
686 : static const yytype_uint8 yystos[] =
687 : {
688 : 0, 1, 3, 4, 6, 8, 9, 11, 12, 15,
689 : 16, 17, 18, 19, 20, 21, 22, 23, 25, 26,
690 : 27, 28, 30, 31, 32, 33, 28, 8, 28, 13,
691 : 8, 3, 10, 3, 3, 3, 3, 13, 14, 0,
692 : 26, 3, 32, 14, 29, 32, 5, 7, 3, 28,
693 : 3, 3, 3, 28, 3
694 : };
695 :
696 : #define yyerrok (yyerrstatus = 0)
697 : #define yyclearin (yychar = YYEMPTY)
698 : #define YYEMPTY (-2)
699 : #define YYEOF 0
700 :
701 : #define YYACCEPT goto yyacceptlab
702 : #define YYABORT goto yyabortlab
703 : #define YYERROR goto yyerrorlab
704 :
705 :
706 : /* Like YYERROR except do call yyerror. This remains here temporarily
707 : to ease the transition to the new meaning of YYERROR, for GCC.
708 : Once GCC version 2 has supplanted version 1, this can go. */
709 :
710 : #define YYFAIL goto yyerrlab
711 :
712 : #define YYRECOVERING() (!!yyerrstatus)
713 :
714 : #define YYBACKUP(Token, Value) \
715 : do \
716 : if (yychar == YYEMPTY && yylen == 1) \
717 : { \
718 : yychar = (Token); \
719 : yylval = (Value); \
720 : yytoken = YYTRANSLATE (yychar); \
721 : YYPOPSTACK (1); \
722 : goto yybackup; \
723 : } \
724 : else \
725 : { \
726 : yyerror (YY_("syntax error: cannot back up")); \
727 : YYERROR; \
728 : } \
729 : while (YYID (0))
730 :
731 :
732 : #define YYTERROR 1
733 : #define YYERRCODE 256
734 :
735 :
736 : /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
737 : If N is 0, then set CURRENT to the empty location which ends
738 : the previous symbol: RHS[0] (always defined). */
739 :
740 : #define YYRHSLOC(Rhs, K) ((Rhs)[K])
741 : #ifndef YYLLOC_DEFAULT
742 : # define YYLLOC_DEFAULT(Current, Rhs, N) \
743 : do \
744 : if (YYID (N)) \
745 : { \
746 : (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
747 : (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
748 : (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
749 : (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
750 : } \
751 : else \
752 : { \
753 : (Current).first_line = (Current).last_line = \
754 : YYRHSLOC (Rhs, 0).last_line; \
755 : (Current).first_column = (Current).last_column = \
756 : YYRHSLOC (Rhs, 0).last_column; \
757 : } \
758 : while (YYID (0))
759 : #endif
760 :
761 :
762 : /* YY_LOCATION_PRINT -- Print the location on the stream.
763 : This macro was not mandated originally: define only if we know
764 : we won't break user code: when these are the locations we know. */
765 :
766 : #ifndef YY_LOCATION_PRINT
767 : # if YYLTYPE_IS_TRIVIAL
768 : # define YY_LOCATION_PRINT(File, Loc) \
769 : fprintf (File, "%d.%d-%d.%d", \
770 : (Loc).first_line, (Loc).first_column, \
771 : (Loc).last_line, (Loc).last_column)
772 : # else
773 : # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
774 : # endif
775 : #endif
776 :
777 :
778 : /* YYLEX -- calling `yylex' with the right arguments. */
779 :
780 : #ifdef YYLEX_PARAM
781 : # define YYLEX yylex (YYLEX_PARAM)
782 : #else
783 : # define YYLEX yylex ()
784 : #endif
785 :
786 : /* Enable debugging if requested. */
787 : #if YYDEBUG
788 :
789 : # ifndef YYFPRINTF
790 : # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
791 : # define YYFPRINTF fprintf
792 : # endif
793 :
794 : # define YYDPRINTF(Args) \
795 : do { \
796 : if (yydebug) \
797 : YYFPRINTF Args; \
798 : } while (YYID (0))
799 :
800 : # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
801 : do { \
802 : if (yydebug) \
803 : { \
804 : YYFPRINTF (stderr, "%s ", Title); \
805 : yy_symbol_print (stderr, \
806 : Type, Value); \
807 : YYFPRINTF (stderr, "\n"); \
808 : } \
809 : } while (YYID (0))
810 :
811 :
812 : /*--------------------------------.
813 : | Print this symbol on YYOUTPUT. |
814 : `--------------------------------*/
815 :
816 : /*ARGSUSED*/
817 : #if (defined __STDC__ || defined __C99__FUNC__ \
818 : || defined __cplusplus || defined _MSC_VER)
819 : static void
820 : yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
821 : #else
822 : static void
823 : yy_symbol_value_print (yyoutput, yytype, yyvaluep)
824 : FILE *yyoutput;
825 : int yytype;
826 : YYSTYPE const * const yyvaluep;
827 : #endif
828 : {
829 : if (!yyvaluep)
830 : return;
831 : # ifdef YYPRINT
832 : if (yytype < YYNTOKENS)
833 : YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
834 : # else
835 : YYUSE (yyoutput);
836 : # endif
837 : switch (yytype)
838 : {
839 : default:
840 : break;
841 : }
842 : }
843 :
844 :
845 : /*--------------------------------.
846 : | Print this symbol on YYOUTPUT. |
847 : `--------------------------------*/
848 :
849 : #if (defined __STDC__ || defined __C99__FUNC__ \
850 : || defined __cplusplus || defined _MSC_VER)
851 : static void
852 : yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
853 : #else
854 : static void
855 : yy_symbol_print (yyoutput, yytype, yyvaluep)
856 : FILE *yyoutput;
857 : int yytype;
858 : YYSTYPE const * const yyvaluep;
859 : #endif
860 : {
861 : if (yytype < YYNTOKENS)
862 : YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
863 : else
864 : YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
865 :
866 : yy_symbol_value_print (yyoutput, yytype, yyvaluep);
867 : YYFPRINTF (yyoutput, ")");
868 : }
869 :
870 : /*------------------------------------------------------------------.
871 : | yy_stack_print -- Print the state stack from its BOTTOM up to its |
872 : | TOP (included). |
873 : `------------------------------------------------------------------*/
874 :
875 : #if (defined __STDC__ || defined __C99__FUNC__ \
876 : || defined __cplusplus || defined _MSC_VER)
877 : static void
878 : yy_stack_print (yytype_int16 *bottom, yytype_int16 *top)
879 : #else
880 : static void
881 : yy_stack_print (bottom, top)
882 : yytype_int16 *bottom;
883 : yytype_int16 *top;
884 : #endif
885 : {
886 : YYFPRINTF (stderr, "Stack now");
887 : for (; bottom <= top; ++bottom)
888 : YYFPRINTF (stderr, " %d", *bottom);
889 : YYFPRINTF (stderr, "\n");
890 : }
891 :
892 : # define YY_STACK_PRINT(Bottom, Top) \
893 : do { \
894 : if (yydebug) \
895 : yy_stack_print ((Bottom), (Top)); \
896 : } while (YYID (0))
897 :
898 :
899 : /*------------------------------------------------.
900 : | Report that the YYRULE is going to be reduced. |
901 : `------------------------------------------------*/
902 :
903 : #if (defined __STDC__ || defined __C99__FUNC__ \
904 : || defined __cplusplus || defined _MSC_VER)
905 : static void
906 : yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
907 : #else
908 : static void
909 : yy_reduce_print (yyvsp, yyrule)
910 : YYSTYPE *yyvsp;
911 : int yyrule;
912 : #endif
913 : {
914 : int yynrhs = yyr2[yyrule];
915 : int yyi;
916 : unsigned long int yylno = yyrline[yyrule];
917 : YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
918 : yyrule - 1, yylno);
919 : /* The symbols being reduced. */
920 : for (yyi = 0; yyi < yynrhs; yyi++)
921 : {
922 : fprintf (stderr, " $%d = ", yyi + 1);
923 : yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
924 : &(yyvsp[(yyi + 1) - (yynrhs)])
925 : );
926 : fprintf (stderr, "\n");
927 : }
928 : }
929 :
930 : # define YY_REDUCE_PRINT(Rule) \
931 : do { \
932 : if (yydebug) \
933 : yy_reduce_print (yyvsp, Rule); \
934 : } while (YYID (0))
935 :
936 : /* Nonzero means print parse trace. It is left uninitialized so that
937 : multiple parsers can coexist. */
938 : int yydebug;
939 : #else /* !YYDEBUG */
940 : # define YYDPRINTF(Args)
941 : # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
942 : # define YY_STACK_PRINT(Bottom, Top)
943 : # define YY_REDUCE_PRINT(Rule)
944 : #endif /* !YYDEBUG */
945 :
946 :
947 : /* YYINITDEPTH -- initial size of the parser's stacks. */
948 : #ifndef YYINITDEPTH
949 : # define YYINITDEPTH 200
950 : #endif
951 :
952 : /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
953 : if the built-in stack extension method is used).
954 :
955 : Do not make this value too large; the results are undefined if
956 : YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
957 : evaluated with infinite-precision integer arithmetic. */
958 :
959 : #ifndef YYMAXDEPTH
960 : # define YYMAXDEPTH 10000
961 : #endif
962 :
963 :
964 :
965 : #if YYERROR_VERBOSE
966 :
967 : # ifndef yystrlen
968 : # if defined __GLIBC__ && defined _STRING_H
969 : # define yystrlen strlen
970 : # else
971 : /* Return the length of YYSTR. */
972 : #if (defined __STDC__ || defined __C99__FUNC__ \
973 : || defined __cplusplus || defined _MSC_VER)
974 : static YYSIZE_T
975 : yystrlen (const char *yystr)
976 : #else
977 : static YYSIZE_T
978 : yystrlen (yystr)
979 : const char *yystr;
980 : #endif
981 : {
982 : YYSIZE_T yylen;
983 : for (yylen = 0; yystr[yylen]; yylen++)
984 : continue;
985 : return yylen;
986 : }
987 : # endif
988 : # endif
989 :
990 : # ifndef yystpcpy
991 : # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
992 : # define yystpcpy stpcpy
993 : # else
994 : /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
995 : YYDEST. */
996 : #if (defined __STDC__ || defined __C99__FUNC__ \
997 : || defined __cplusplus || defined _MSC_VER)
998 : static char *
999 : yystpcpy (char *yydest, const char *yysrc)
1000 : #else
1001 : static char *
1002 : yystpcpy (yydest, yysrc)
1003 : char *yydest;
1004 : const char *yysrc;
1005 : #endif
1006 11 : {
1007 11 : char *yyd = yydest;
1008 11 : const char *yys = yysrc;
1009 :
1010 138 : while ((*yyd++ = *yys++) != '\0')
1011 : continue;
1012 :
1013 11 : return yyd - 1;
1014 : }
1015 : # endif
1016 : # endif
1017 :
1018 : # ifndef yytnamerr
1019 : /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1020 : quotes and backslashes, so that it's suitable for yyerror. The
1021 : heuristic is that double-quoting is unnecessary unless the string
1022 : contains an apostrophe, a comma, or backslash (other than
1023 : backslash-backslash). YYSTR is taken from yytname. If YYRES is
1024 : null, do not copy; instead, return the length of what the result
1025 : would have been. */
1026 : static YYSIZE_T
1027 : yytnamerr (char *yyres, const char *yystr)
1028 11 : {
1029 11 : if (*yystr == '"')
1030 : {
1031 0 : YYSIZE_T yyn = 0;
1032 0 : char const *yyp = yystr;
1033 :
1034 : for (;;)
1035 0 : switch (*++yyp)
1036 : {
1037 : case '\'':
1038 : case ',':
1039 0 : goto do_not_strip_quotes;
1040 :
1041 : case '\\':
1042 0 : if (*++yyp != '\\')
1043 0 : goto do_not_strip_quotes;
1044 : /* Fall through. */
1045 : default:
1046 0 : if (yyres)
1047 0 : yyres[yyn] = *yyp;
1048 0 : yyn++;
1049 : break;
1050 :
1051 : case '"':
1052 0 : if (yyres)
1053 0 : yyres[yyn] = '\0';
1054 0 : return yyn;
1055 0 : }
1056 11 : do_not_strip_quotes: ;
1057 : }
1058 :
1059 11 : if (! yyres)
1060 10 : return yystrlen (yystr);
1061 :
1062 1 : return yystpcpy (yyres, yystr) - yyres;
1063 : }
1064 : # endif
1065 :
1066 : /* Copy into YYRESULT an error message about the unexpected token
1067 : YYCHAR while in state YYSTATE. Return the number of bytes copied,
1068 : including the terminating null byte. If YYRESULT is null, do not
1069 : copy anything; just return the number of bytes that would be
1070 : copied. As a special case, return 0 if an ordinary "syntax error"
1071 : message will do. Return YYSIZE_MAXIMUM if overflow occurs during
1072 : size calculation. */
1073 : static YYSIZE_T
1074 : yysyntax_error (char *yyresult, int yystate, int yychar)
1075 2 : {
1076 2 : int yyn = yypact[yystate];
1077 :
1078 2 : if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
1079 0 : return 0;
1080 : else
1081 : {
1082 2 : int yytype = YYTRANSLATE (yychar);
1083 2 : YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
1084 2 : YYSIZE_T yysize = yysize0;
1085 : YYSIZE_T yysize1;
1086 2 : int yysize_overflow = 0;
1087 : enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1088 : char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1089 : int yyx;
1090 :
1091 : # if 0
1092 : /* This is so xgettext sees the translatable formats that are
1093 : constructed on the fly. */
1094 : YY_("syntax error, unexpected %s");
1095 : YY_("syntax error, unexpected %s, expecting %s");
1096 : YY_("syntax error, unexpected %s, expecting %s or %s");
1097 : YY_("syntax error, unexpected %s, expecting %s or %s or %s");
1098 : YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
1099 : # endif
1100 : char *yyfmt;
1101 : char const *yyf;
1102 : static char const yyunexpected[] = "syntax error, unexpected %s";
1103 : static char const yyexpecting[] = ", expecting %s";
1104 : static char const yyor[] = " or %s";
1105 : char yyformat[sizeof yyunexpected
1106 : + sizeof yyexpecting - 1
1107 : + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
1108 : * (sizeof yyor - 1))];
1109 2 : char const *yyprefix = yyexpecting;
1110 :
1111 : /* Start YYX at -YYN if negative to avoid negative indexes in
1112 : YYCHECK. */
1113 2 : int yyxbegin = yyn < 0 ? -yyn : 0;
1114 :
1115 : /* Stay within bounds of both yycheck and yytname. */
1116 2 : int yychecklim = YYLAST - yyn + 1;
1117 2 : int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1118 2 : int yycount = 1;
1119 :
1120 2 : yyarg[0] = yytname[yytype];
1121 2 : yyfmt = yystpcpy (yyformat, yyunexpected);
1122 :
1123 24 : for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1124 24 : if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1125 : {
1126 10 : if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1127 : {
1128 2 : yycount = 1;
1129 2 : yysize = yysize0;
1130 2 : yyformat[sizeof yyunexpected - 1] = '\0';
1131 2 : break;
1132 : }
1133 8 : yyarg[yycount++] = yytname[yyx];
1134 8 : yysize1 = yysize + yytnamerr (0, yytname[yyx]);
1135 8 : yysize_overflow |= (yysize1 < yysize);
1136 8 : yysize = yysize1;
1137 8 : yyfmt = yystpcpy (yyfmt, yyprefix);
1138 8 : yyprefix = yyor;
1139 : }
1140 :
1141 2 : yyf = YY_(yyformat);
1142 2 : yysize1 = yysize + yystrlen (yyf);
1143 2 : yysize_overflow |= (yysize1 < yysize);
1144 2 : yysize = yysize1;
1145 :
1146 2 : if (yysize_overflow)
1147 0 : return YYSIZE_MAXIMUM;
1148 :
1149 2 : if (yyresult)
1150 : {
1151 : /* Avoid sprintf, as that infringes on the user's name space.
1152 : Don't have undefined behavior even if the translation
1153 : produced a string with the wrong number of "%s"s. */
1154 1 : char *yyp = yyresult;
1155 1 : int yyi = 0;
1156 28 : while ((*yyp = *yyf) != '\0')
1157 : {
1158 27 : if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
1159 : {
1160 1 : yyp += yytnamerr (yyp, yyarg[yyi++]);
1161 1 : yyf += 2;
1162 : }
1163 : else
1164 : {
1165 25 : yyp++;
1166 25 : yyf++;
1167 : }
1168 : }
1169 : }
1170 2 : return yysize;
1171 : }
1172 : }
1173 : #endif /* YYERROR_VERBOSE */
1174 :
1175 :
1176 : /*-----------------------------------------------.
1177 : | Release the memory associated to this symbol. |
1178 : `-----------------------------------------------*/
1179 :
1180 : /*ARGSUSED*/
1181 : #if (defined __STDC__ || defined __C99__FUNC__ \
1182 : || defined __cplusplus || defined _MSC_VER)
1183 : static void
1184 : yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
1185 : #else
1186 : static void
1187 : yydestruct (yymsg, yytype, yyvaluep)
1188 : const char *yymsg;
1189 : int yytype;
1190 : YYSTYPE *yyvaluep;
1191 : #endif
1192 61 : {
1193 : YYUSE (yyvaluep);
1194 :
1195 61 : if (!yymsg)
1196 0 : yymsg = "Deleting";
1197 : YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1198 :
1199 : switch (yytype)
1200 : {
1201 :
1202 : default:
1203 : break;
1204 : }
1205 61 : }
1206 :
1207 :
1208 : /* Prevent warnings from -Wmissing-prototypes. */
1209 :
1210 : #ifdef YYPARSE_PARAM
1211 : #if defined __STDC__ || defined __cplusplus
1212 : int yyparse (void *YYPARSE_PARAM);
1213 : #else
1214 : int yyparse ();
1215 : #endif
1216 : #else /* ! YYPARSE_PARAM */
1217 : #if defined __STDC__ || defined __cplusplus
1218 : int yyparse (void);
1219 : #else
1220 : int yyparse ();
1221 : #endif
1222 : #endif /* ! YYPARSE_PARAM */
1223 :
1224 :
1225 :
1226 : /* The look-ahead symbol. */
1227 : int yychar;
1228 :
1229 : /* The semantic value of the look-ahead symbol. */
1230 : YYSTYPE yylval;
1231 :
1232 : /* Number of syntax errors so far. */
1233 : int yynerrs;
1234 :
1235 :
1236 :
1237 : /*----------.
1238 : | yyparse. |
1239 : `----------*/
1240 :
1241 : #ifdef YYPARSE_PARAM
1242 : #if (defined __STDC__ || defined __C99__FUNC__ \
1243 : || defined __cplusplus || defined _MSC_VER)
1244 : int
1245 : yyparse (void *YYPARSE_PARAM)
1246 : #else
1247 : int
1248 : yyparse (YYPARSE_PARAM)
1249 : void *YYPARSE_PARAM;
1250 : #endif
1251 : #else /* ! YYPARSE_PARAM */
1252 : #if (defined __STDC__ || defined __C99__FUNC__ \
1253 : || defined __cplusplus || defined _MSC_VER)
1254 : int
1255 : yyparse (void)
1256 : #else
1257 : int
1258 : yyparse ()
1259 :
1260 : #endif
1261 : #endif
1262 56 : {
1263 :
1264 : int yystate;
1265 : int yyn;
1266 : int yyresult;
1267 : /* Number of tokens to shift before error messages enabled. */
1268 : int yyerrstatus;
1269 : /* Look-ahead token as an internal (translated) token number. */
1270 56 : int yytoken = 0;
1271 : #if YYERROR_VERBOSE
1272 : /* Buffer for error messages, and its allocated size. */
1273 : char yymsgbuf[128];
1274 56 : char *yymsg = yymsgbuf;
1275 56 : YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1276 : #endif
1277 :
1278 : /* Three stacks and their tools:
1279 : `yyss': related to states,
1280 : `yyvs': related to semantic values,
1281 : `yyls': related to locations.
1282 :
1283 : Refer to the stacks thru separate pointers, to allow yyoverflow
1284 : to reallocate them elsewhere. */
1285 :
1286 : /* The state stack. */
1287 : yytype_int16 yyssa[YYINITDEPTH];
1288 56 : yytype_int16 *yyss = yyssa;
1289 : yytype_int16 *yyssp;
1290 :
1291 : /* The semantic value stack. */
1292 : YYSTYPE yyvsa[YYINITDEPTH];
1293 56 : YYSTYPE *yyvs = yyvsa;
1294 : YYSTYPE *yyvsp;
1295 :
1296 :
1297 :
1298 : #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1299 :
1300 56 : YYSIZE_T yystacksize = YYINITDEPTH;
1301 :
1302 : /* The variables used to return semantic value and location from the
1303 : action routines. */
1304 : YYSTYPE yyval;
1305 :
1306 :
1307 : /* The number of symbols on the RHS of the reduced rule.
1308 : Keep to zero when no symbol should be popped. */
1309 56 : int yylen = 0;
1310 :
1311 : YYDPRINTF ((stderr, "Starting parse\n"));
1312 :
1313 56 : yystate = 0;
1314 56 : yyerrstatus = 0;
1315 56 : yynerrs = 0;
1316 56 : yychar = YYEMPTY; /* Cause a token to be read. */
1317 :
1318 : /* Initialize stack pointers.
1319 : Waste one element of value and location stack
1320 : so that they stay on the same level as the state stack.
1321 : The wasted elements are never initialized. */
1322 :
1323 56 : yyssp = yyss;
1324 56 : yyvsp = yyvs;
1325 :
1326 56 : goto yysetstate;
1327 :
1328 : /*------------------------------------------------------------.
1329 : | yynewstate -- Push a new state, which is found in yystate. |
1330 : `------------------------------------------------------------*/
1331 12308 : yynewstate:
1332 : /* In all cases, when you get here, the value and location stacks
1333 : have just been pushed. So pushing a state here evens the stacks. */
1334 12308 : yyssp++;
1335 :
1336 12364 : yysetstate:
1337 12364 : *yyssp = yystate;
1338 :
1339 12364 : if (yyss + yystacksize - 1 <= yyssp)
1340 : {
1341 : /* Get the current used size of the three stacks, in elements. */
1342 0 : YYSIZE_T yysize = yyssp - yyss + 1;
1343 :
1344 : #ifdef yyoverflow
1345 : {
1346 : /* Give user a chance to reallocate the stack. Use copies of
1347 : these so that the &'s don't force the real ones into
1348 : memory. */
1349 : YYSTYPE *yyvs1 = yyvs;
1350 : yytype_int16 *yyss1 = yyss;
1351 :
1352 :
1353 : /* Each stack pointer address is followed by the size of the
1354 : data in use in that stack, in bytes. This used to be a
1355 : conditional around just the two extra args, but that might
1356 : be undefined if yyoverflow is a macro. */
1357 : yyoverflow (YY_("memory exhausted"),
1358 : &yyss1, yysize * sizeof (*yyssp),
1359 : &yyvs1, yysize * sizeof (*yyvsp),
1360 :
1361 : &yystacksize);
1362 :
1363 : yyss = yyss1;
1364 : yyvs = yyvs1;
1365 : }
1366 : #else /* no yyoverflow */
1367 : # ifndef YYSTACK_RELOCATE
1368 : goto yyexhaustedlab;
1369 : # else
1370 : /* Extend the stack our own way. */
1371 0 : if (YYMAXDEPTH <= yystacksize)
1372 0 : goto yyexhaustedlab;
1373 0 : yystacksize *= 2;
1374 0 : if (YYMAXDEPTH < yystacksize)
1375 0 : yystacksize = YYMAXDEPTH;
1376 :
1377 : {
1378 0 : yytype_int16 *yyss1 = yyss;
1379 : union yyalloc *yyptr =
1380 0 : (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1381 0 : if (! yyptr)
1382 0 : goto yyexhaustedlab;
1383 0 : YYSTACK_RELOCATE (yyss);
1384 0 : YYSTACK_RELOCATE (yyvs);
1385 :
1386 : # undef YYSTACK_RELOCATE
1387 0 : if (yyss1 != yyssa)
1388 0 : YYSTACK_FREE (yyss1);
1389 : }
1390 : # endif
1391 : #endif /* no yyoverflow */
1392 :
1393 0 : yyssp = yyss + yysize - 1;
1394 0 : yyvsp = yyvs + yysize - 1;
1395 :
1396 :
1397 : YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1398 : (unsigned long int) yystacksize));
1399 :
1400 0 : if (yyss + yystacksize - 1 <= yyssp)
1401 0 : YYABORT;
1402 : }
1403 :
1404 : YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1405 :
1406 : goto yybackup;
1407 :
1408 : /*-----------.
1409 : | yybackup. |
1410 : `-----------*/
1411 12364 : yybackup:
1412 :
1413 : /* Do appropriate processing given the current state. Read a
1414 : look-ahead token if we need one and don't already have one. */
1415 :
1416 : /* First try to decide what to do without reference to look-ahead token. */
1417 12364 : yyn = yypact[yystate];
1418 12364 : if (yyn == YYPACT_NINF)
1419 6586 : goto yydefault;
1420 :
1421 : /* Not known => get a look-ahead token if don't already have one. */
1422 :
1423 : /* YYCHAR is either YY |
