1 /* original parser id follows */
2 /* yysccsid[] = "@(#)yaccpar	1.9 (Berkeley) 02/21/93" */
3 /* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
4 
5 #define YYBYACC 1
6 #define YYMAJOR 1
7 #define YYMINOR 9
8 #define YYCHECK "yyyymmdd"
9 
10 #define YYEMPTY        (-1)
11 #define yyclearin      (yychar = YYEMPTY)
12 #define yyerrok        (yyerrflag = 0)
13 #define YYRECOVERING() (yyerrflag != 0)
14 #define YYENOMEM       (-2)
15 #define YYEOF          0
16 #undef YYBTYACC
17 #define YYBTYACC 0
18 #define YYDEBUGSTR YYPREFIX "debug"
19 
20 #ifndef yyparse
21 #define yyparse    ok_syntax1_parse
22 #endif /* yyparse */
23 
24 #ifndef yylex
25 #define yylex      ok_syntax1_lex
26 #endif /* yylex */
27 
28 #ifndef yyerror
29 #define yyerror    ok_syntax1_error
30 #endif /* yyerror */
31 
32 #ifndef yychar
33 #define yychar     ok_syntax1_char
34 #endif /* yychar */
35 
36 #ifndef yyval
37 #define yyval      ok_syntax1_val
38 #endif /* yyval */
39 
40 #ifndef yylval
41 #define yylval     ok_syntax1_lval
42 #endif /* yylval */
43 
44 #ifndef yydebug
45 #define yydebug    ok_syntax1_debug
46 #endif /* yydebug */
47 
48 #ifndef yynerrs
49 #define yynerrs    ok_syntax1_nerrs
50 #endif /* yynerrs */
51 
52 #ifndef yyerrflag
53 #define yyerrflag  ok_syntax1_errflag
54 #endif /* yyerrflag */
55 
56 #ifndef yylhs
57 #define yylhs      ok_syntax1_lhs
58 #endif /* yylhs */
59 
60 #ifndef yylen
61 #define yylen      ok_syntax1_len
62 #endif /* yylen */
63 
64 #ifndef yydefred
65 #define yydefred   ok_syntax1_defred
66 #endif /* yydefred */
67 
68 #ifndef yystos
69 #define yystos     ok_syntax1_stos
70 #endif /* yystos */
71 
72 #ifndef yydgoto
73 #define yydgoto    ok_syntax1_dgoto
74 #endif /* yydgoto */
75 
76 #ifndef yysindex
77 #define yysindex   ok_syntax1_sindex
78 #endif /* yysindex */
79 
80 #ifndef yyrindex
81 #define yyrindex   ok_syntax1_rindex
82 #endif /* yyrindex */
83 
84 #ifndef yygindex
85 #define yygindex   ok_syntax1_gindex
86 #endif /* yygindex */
87 
88 #ifndef yytable
89 #define yytable    ok_syntax1_table
90 #endif /* yytable */
91 
92 #ifndef yycheck
93 #define yycheck    ok_syntax1_check
94 #endif /* yycheck */
95 
96 #ifndef yyname
97 #define yyname     ok_syntax1_name
98 #endif /* yyname */
99 
100 #ifndef yyrule
101 #define yyrule     ok_syntax1_rule
102 #endif /* yyrule */
103 
104 #if YYBTYACC
105 
106 #ifndef yycindex
107 #define yycindex   ok_syntax1_cindex
108 #endif /* yycindex */
109 
110 #ifndef yyctable
111 #define yyctable   ok_syntax1_ctable
112 #endif /* yyctable */
113 
114 #endif /* YYBTYACC */
115 
116 #define YYPREFIX "ok_syntax1_"
117 
118 #define YYPURE 1
119 
120 #line 9 "ok_syntax1.y"
121 # include <stdio.h>
122 # include <ctype.h>
123 
124 #ifdef YYBISON
125 #define YYSTYPE int
126 #define YYLEX_PARAM base
127 #define YYLEX_DECL() yylex(YYSTYPE *yylval, int *YYLEX_PARAM)
128 #define YYERROR_DECL() yyerror(int regs[26], int *base, const char *s)
129 int YYLEX_DECL();
130 static void YYERROR_DECL();
131 #endif
132 
133 #ifdef YYSTYPE
134 #undef  YYSTYPE_IS_DECLARED
135 #define YYSTYPE_IS_DECLARED 1
136 #endif
137 #ifndef YYSTYPE_IS_DECLARED
138 #define YYSTYPE_IS_DECLARED 1
139 #line 43 "ok_syntax1.y"
140 typedef union
141 {
142     char *	cval;
143     int		ival;
144     double	dval;
145 } YYSTYPE;
146 #endif /* !YYSTYPE_IS_DECLARED */
147 #line 148 "ok_syntax1.tab.c"
148 
149 /* compatibility with bison */
150 #ifdef YYPARSE_PARAM
151 /* compatibility with FreeBSD */
152 # ifdef YYPARSE_PARAM_TYPE
153 #  define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
154 # else
155 #  define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
156 # endif
157 #else
158 # define YYPARSE_DECL() yyparse(int regs[26], int *base)
159 #endif
160 
161 /* Parameters sent to lex. */
162 #ifdef YYLEX_PARAM
163 # ifdef YYLEX_PARAM_TYPE
164 #  define YYLEX_DECL() yylex(YYSTYPE *yylval, YYLEX_PARAM_TYPE YYLEX_PARAM)
165 # else
166 #  define YYLEX_DECL() yylex(YYSTYPE *yylval, void * YYLEX_PARAM)
167 # endif
168 # define YYLEX yylex(&yylval, YYLEX_PARAM)
169 #else
170 # define YYLEX_DECL() yylex(YYSTYPE *yylval, int *base)
171 # define YYLEX yylex(&yylval, base)
172 #endif
173 
174 /* Parameters sent to yyerror. */
175 #ifndef YYERROR_DECL
176 #define YYERROR_DECL() yyerror(int regs[26], int *base, const char *s)
177 #endif
178 #ifndef YYERROR_CALL
179 #define YYERROR_CALL(msg) yyerror(regs, base, msg)
180 #endif
181 
182 extern int YYPARSE_DECL();
183 
184 #define DIGIT 257
185 #define LETTER 258
186 #define OCT1 259
187 #define HEX1 260
188 #define HEX2 261
189 #define HEX3 262
190 #define STR1 263
191 #define STR2 265
192 #define BELL 266
193 #define BS 267
194 #define NL 268
195 #define LF 269
196 #define CR 270
197 #define TAB 271
198 #define VT 272
199 #define UMINUS 273
200 #define YYERRCODE 256
201 typedef short YYINT;
202 static const YYINT ok_syntax1_lhs[] = {                  -1,
203     0,    0,    0,    1,    1,    2,    2,    2,    2,    2,
204     2,    2,    2,    2,    2,    2,    3,    3,
205 };
206 static const YYINT ok_syntax1_len[] = {                   2,
207     0,    3,    3,    1,    3,    3,    3,    3,    3,    3,
208     3,    3,    3,    2,    1,    1,    1,    2,
209 };
210 static const YYINT ok_syntax1_defred[] = {                1,
211     0,    0,   17,    0,    0,    0,    0,    0,    0,    3,
212     0,   15,   14,    0,    2,    0,    0,    0,    0,    0,
213     0,    0,   18,    0,    6,    0,    0,    0,    0,    9,
214    10,   11,
215 };
216 #if defined(YYDESTRUCT_CALL) || defined(YYSTYPE_TOSTRING)
217 static const YYINT ok_syntax1_stos[] = {                  0,
218   275,  256,  257,  258,   45,   40,  276,  277,  278,   10,
219    61,  258,  277,  277,   10,  124,   38,   43,   45,   42,
220    47,   37,  257,  277,   41,  277,  277,  277,  277,  277,
221   277,  277,
222 };
223 #endif /* YYDESTRUCT_CALL || YYSTYPE_TOSTRING */
224 static const YYINT ok_syntax1_dgoto[] = {                 1,
225     7,    8,    9,
226 };
227 static const YYINT ok_syntax1_sindex[] = {                0,
228   -40,   -7,    0,  -55,  -38,  -38,    1,  -29, -247,    0,
229   -38,    0,    0,   22,    0,  -38,  -38,  -38,  -38,  -38,
230   -38,  -38,    0,  -29,    0,   51,   60,  -20,  -20,    0,
231     0,    0,
232 };
233 static const YYINT ok_syntax1_rindex[] = {                0,
234     0,    0,    0,    2,    0,    0,    0,    9,   -9,    0,
235     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
236     0,    0,    0,   10,    0,   -6,   14,    5,   13,    0,
237     0,    0,
238 };
239 #if YYBTYACC
240 static const YYINT ok_syntax1_cindex[] = {                0,
241     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
242     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
243     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
244     0,    0,
245 };
246 #endif
247 static const YYINT ok_syntax1_gindex[] = {                0,
248     0,   65,    0,
249 };
250 #define YYTABLESIZE 220
251 static const YYINT ok_syntax1_table[] = {                 6,
252    16,    6,   10,   13,    5,   11,    5,   22,   17,   23,
253    15,   15,   20,   18,    7,   19,   22,   21,    4,    5,
254     0,   20,    8,   12,    0,    0,   21,   16,   16,    0,
255     0,   16,   16,   16,   13,   16,    0,   16,   15,   15,
256     0,    0,    7,   15,   15,    7,   15,    7,   15,    7,
257     8,   12,    0,    8,   12,    8,    0,    8,   22,   17,
258     0,    0,   25,   20,   18,    0,   19,    0,   21,   13,
259    14,    0,    0,    0,    0,   24,    0,    0,    0,    0,
260    26,   27,   28,   29,   30,   31,   32,   22,   17,    0,
261     0,    0,   20,   18,   16,   19,   22,   21,    0,    0,
262     0,   20,   18,    0,   19,    0,   21,    0,    0,    0,
263     0,    0,    0,    0,   16,    0,    0,   13,    0,    0,
264     0,    0,    0,    0,    0,   15,    0,    0,    7,    0,
265     0,    0,    0,    0,    0,    0,    8,   12,    0,    0,
266     0,    0,    0,    0,    0,   16,    0,    0,    0,    0,
267     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
268     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
269     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
270     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
271     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
272     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
273     0,    0,    0,    0,    0,    2,    3,    4,    3,   12,
274 };
275 static const YYINT ok_syntax1_check[] = {                40,
276    10,   40,   10,   10,   45,   61,   45,   37,   38,  257,
277    10,   10,   42,   43,   10,   45,   37,   47,   10,   10,
278    -1,   42,   10,   10,   -1,   -1,   47,   37,   38,   -1,
279    -1,   41,   42,   43,   41,   45,   -1,   47,   37,   38,
280    -1,   -1,   38,   42,   43,   41,   45,   43,   47,   45,
281    38,   38,   -1,   41,   41,   43,   -1,   45,   37,   38,
282    -1,   -1,   41,   42,   43,   -1,   45,   -1,   47,    5,
283     6,   -1,   -1,   -1,   -1,   11,   -1,   -1,   -1,   -1,
284    16,   17,   18,   19,   20,   21,   22,   37,   38,   -1,
285    -1,   -1,   42,   43,  124,   45,   37,   47,   -1,   -1,
286    -1,   42,   43,   -1,   45,   -1,   47,   -1,   -1,   -1,
287    -1,   -1,   -1,   -1,  124,   -1,   -1,  124,   -1,   -1,
288    -1,   -1,   -1,   -1,   -1,  124,   -1,   -1,  124,   -1,
289    -1,   -1,   -1,   -1,   -1,   -1,  124,  124,   -1,   -1,
290    -1,   -1,   -1,   -1,   -1,  124,   -1,   -1,   -1,   -1,
291    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
292    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
293    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
294    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
295    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
296    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
297    -1,   -1,   -1,   -1,   -1,  256,  257,  258,  257,  258,
298 };
299 #if YYBTYACC
300 static const YYINT ok_syntax1_ctable[] = {               -1,
301    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
302    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
303    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
304    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
305    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
306    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
307    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
308    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
309    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
310    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
311    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
312    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
313    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
314    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
315    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
316    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
317    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
318    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
319    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
320    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
321    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
322    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
323 };
324 #endif
325 #define YYFINAL 1
326 #ifndef YYDEBUG
327 #define YYDEBUG 0
328 #endif
329 #define YYMAXTOKEN 273
330 #define YYUNDFTOKEN 279
331 #define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a))
332 #if YYDEBUG
333 static const char *const ok_syntax1_name[] = {
334 
335 "$end",0,0,0,0,0,0,"'\\a'","'\\b'","'\\t'","'\\n'","'\\v'","'\\f'","'\\r'",0,0,
336 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'#'",0,"'%'","'&'",0,"'('","')'","'*'",
337 "'+'",0,"'-'",0,"'/'",0,0,0,0,0,0,0,0,0,0,0,0,0,"'='",0,0,"'@'",0,0,0,0,0,0,0,0,
338 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'^'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
339 0,0,0,0,0,0,0,0,0,0,0,0,0,"'|'",0,"'~'","'\\177'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
340 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
341 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
342 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'\\377'",
343 "error","DIGIT","LETTER","OCT1","HEX1","HEX2","HEX3","STR1",
344 "\"\\177\\177\\\\\\n\"","STR2","BELL","BS","NL","LF","CR","TAB","VT","UMINUS",
345 "$accept","list","stat","expr","number","illegal-symbol",
346 };
347 static const char *const ok_syntax1_rule[] = {
348 "$accept : list",
349 "list :",
350 "list : list stat '\\n'",
351 "list : list error '\\n'",
352 "stat : expr",
353 "stat : LETTER '=' expr",
354 "expr : '(' expr ')'",
355 "expr : expr '+' expr",
356 "expr : expr '-' expr",
357 "expr : expr '*' expr",
358 "expr : expr '/' expr",
359 "expr : expr '%' expr",
360 "expr : expr '&' expr",
361 "expr : expr '|' expr",
362 "expr : '-' expr",
363 "expr : LETTER",
364 "expr : number",
365 "number : DIGIT",
366 "number : number DIGIT",
367 
368 };
369 #endif
370 
371 int      yydebug;
372 int      yynerrs;
373 
374 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
375 #ifndef YYLLOC_DEFAULT
376 #define YYLLOC_DEFAULT(loc, rhs, n) \
377 do \
378 { \
379     if (n == 0) \
380     { \
381         (loc).first_line   = ((rhs)[-1]).last_line; \
382         (loc).first_column = ((rhs)[-1]).last_column; \
383         (loc).last_line    = ((rhs)[-1]).last_line; \
384         (loc).last_column  = ((rhs)[-1]).last_column; \
385     } \
386     else \
387     { \
388         (loc).first_line   = ((rhs)[ 0 ]).first_line; \
389         (loc).first_column = ((rhs)[ 0 ]).first_column; \
390         (loc).last_line    = ((rhs)[n-1]).last_line; \
391         (loc).last_column  = ((rhs)[n-1]).last_column; \
392     } \
393 } while (0)
394 #endif /* YYLLOC_DEFAULT */
395 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
396 #if YYBTYACC
397 
398 #ifndef YYLVQUEUEGROWTH
399 #define YYLVQUEUEGROWTH 32
400 #endif
401 #endif /* YYBTYACC */
402 
403 /* define the initial stack-sizes */
404 #ifdef YYSTACKSIZE
405 #undef YYMAXDEPTH
406 #define YYMAXDEPTH  YYSTACKSIZE
407 #else
408 #ifdef YYMAXDEPTH
409 #define YYSTACKSIZE YYMAXDEPTH
410 #else
411 #define YYSTACKSIZE 10000
412 #define YYMAXDEPTH  10000
413 #endif
414 #endif
415 
416 #ifndef YYINITSTACKSIZE
417 #define YYINITSTACKSIZE 200
418 #endif
419 
420 typedef struct {
421     unsigned stacksize;
422     YYINT    *s_base;
423     YYINT    *s_mark;
424     YYINT    *s_last;
425     YYSTYPE  *l_base;
426     YYSTYPE  *l_mark;
427 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
428     YYLTYPE  *p_base;
429     YYLTYPE  *p_mark;
430 #endif
431 } YYSTACKDATA;
432 #if YYBTYACC
433 
434 struct YYParseState_s
435 {
436     struct YYParseState_s *save;    /* Previously saved parser state */
437     YYSTACKDATA            yystack; /* saved parser stack */
438     int                    state;   /* saved parser state */
439     int                    errflag; /* saved error recovery status */
440     int                    lexeme;  /* saved index of the conflict lexeme in the lexical queue */
441     YYINT                  ctry;    /* saved index in yyctable[] for this conflict */
442 };
443 typedef struct YYParseState_s YYParseState;
444 #endif /* YYBTYACC */
445 #line 104 "ok_syntax1.y"
446  /* start of programs */
447 
448 #ifdef YYBYACC
449 extern int YYLEX_DECL();
450 #endif
451 
452 int
main(void)453 main (void)
454 {
455     int regs[26];
456     int base = 10;
457 
458     while(!feof(stdin)) {
459 	yyparse(regs, &base);
460     }
461     return 0;
462 }
463 
464 #define UNUSED(x) ((void)(x))
465 
466 static void
YYERROR_DECL()467 YYERROR_DECL()
468 {
469     UNUSED(regs); /* %parse-param regs is not actually used here */
470     UNUSED(base); /* %parse-param base is not actually used here */
471     fprintf(stderr, "%s\n", s);
472 }
473 
474 int
YYLEX_DECL()475 YYLEX_DECL()
476 {
477 	/* lexical analysis routine */
478 	/* returns LETTER for a lower case letter, yylval = 0 through 25 */
479 	/* return DIGIT for a digit, yylval = 0 through 9 */
480 	/* all other characters are returned immediately */
481 
482     int c;
483 
484     while( (c=getchar()) == ' ' )   { /* skip blanks */ }
485 
486     /* c is now nonblank */
487 
488     if( islower( c )) {
489 	yylval->ival = (c - 'a');
490 	return ( LETTER );
491     }
492     if( isdigit( c )) {
493 	yylval->ival = (c - '0') % (*base);
494 	return ( DIGIT );
495     }
496     return( c );
497 }
498 #line 499 "ok_syntax1.tab.c"
499 
500 /* For use in generated program */
501 #define yydepth (int)(yystack.s_mark - yystack.s_base)
502 #if YYBTYACC
503 #define yytrial (yyps->save)
504 #endif /* YYBTYACC */
505 
506 #if YYDEBUG
507 #include <stdio.h>	/* needed for printf */
508 #endif
509 
510 #include <stdlib.h>	/* needed for malloc, etc */
511 #include <string.h>	/* needed for memset */
512 
513 /* allocate initial stack or double stack size, up to YYMAXDEPTH */
yygrowstack(YYSTACKDATA * data)514 static int yygrowstack(YYSTACKDATA *data)
515 {
516     int i;
517     unsigned newsize;
518     YYINT *newss;
519     YYSTYPE *newvs;
520 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
521     YYLTYPE *newps;
522 #endif
523 
524     if ((newsize = data->stacksize) == 0)
525         newsize = YYINITSTACKSIZE;
526     else if (newsize >= YYMAXDEPTH)
527         return YYENOMEM;
528     else if ((newsize *= 2) > YYMAXDEPTH)
529         newsize = YYMAXDEPTH;
530 
531     i = (int) (data->s_mark - data->s_base);
532     newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss));
533     if (newss == 0)
534         return YYENOMEM;
535 
536     data->s_base = newss;
537     data->s_mark = newss + i;
538 
539     newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
540     if (newvs == 0)
541         return YYENOMEM;
542 
543     data->l_base = newvs;
544     data->l_mark = newvs + i;
545 
546 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
547     newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps));
548     if (newps == 0)
549         return YYENOMEM;
550 
551     data->p_base = newps;
552     data->p_mark = newps + i;
553 #endif
554 
555     data->stacksize = newsize;
556     data->s_last = data->s_base + newsize - 1;
557 
558 #if YYDEBUG
559     if (yydebug)
560         fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize);
561 #endif
562     return 0;
563 }
564 
565 #if YYPURE || defined(YY_NO_LEAKS)
yyfreestack(YYSTACKDATA * data)566 static void yyfreestack(YYSTACKDATA *data)
567 {
568     free(data->s_base);
569     free(data->l_base);
570 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
571     free(data->p_base);
572 #endif
573     memset(data, 0, sizeof(*data));
574 }
575 #else
576 #define yyfreestack(data) /* nothing */
577 #endif /* YYPURE || defined(YY_NO_LEAKS) */
578 #if YYBTYACC
579 
580 static YYParseState *
yyNewState(unsigned size)581 yyNewState(unsigned size)
582 {
583     YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState));
584     if (p == NULL) return NULL;
585 
586     p->yystack.stacksize = size;
587     if (size == 0)
588     {
589         p->yystack.s_base = NULL;
590         p->yystack.l_base = NULL;
591 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
592         p->yystack.p_base = NULL;
593 #endif
594         return p;
595     }
596     p->yystack.s_base    = (YYINT *) malloc(size * sizeof(YYINT));
597     if (p->yystack.s_base == NULL) return NULL;
598     p->yystack.l_base    = (YYSTYPE *) malloc(size * sizeof(YYSTYPE));
599     if (p->yystack.l_base == NULL) return NULL;
600     memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE));
601 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
602     p->yystack.p_base    = (YYLTYPE *) malloc(size * sizeof(YYLTYPE));
603     if (p->yystack.p_base == NULL) return NULL;
604     memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE));
605 #endif
606 
607     return p;
608 }
609 
610 static void
yyFreeState(YYParseState * p)611 yyFreeState(YYParseState *p)
612 {
613     yyfreestack(&p->yystack);
614     free(p);
615 }
616 #endif /* YYBTYACC */
617 
618 #define YYABORT  goto yyabort
619 #define YYREJECT goto yyabort
620 #define YYACCEPT goto yyaccept
621 #define YYERROR  goto yyerrlab
622 #if YYBTYACC
623 #define YYVALID        do { if (yyps->save)            goto yyvalid; } while(0)
624 #define YYVALID_NESTED do { if (yyps->save && \
625                                 yyps->save->save == 0) goto yyvalid; } while(0)
626 #endif /* YYBTYACC */
627 
628 int
YYPARSE_DECL()629 YYPARSE_DECL()
630 {
631     int      yyerrflag;
632     int      yychar;
633     YYSTYPE  yyval;
634     YYSTYPE  yylval;
635 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
636     YYLTYPE  yyloc; /* position returned by actions */
637     YYLTYPE  yylloc; /* position from the lexer */
638 #endif
639 
640     /* variables for the parser stack */
641     YYSTACKDATA yystack;
642 #if YYBTYACC
643 
644     /* Current parser state */
645     static YYParseState *yyps = 0;
646 
647     /* yypath != NULL: do the full parse, starting at *yypath parser state. */
648     static YYParseState *yypath = 0;
649 
650     /* Base of the lexical value queue */
651     static YYSTYPE *yylvals = 0;
652 
653     /* Current position at lexical value queue */
654     static YYSTYPE *yylvp = 0;
655 
656     /* End position of lexical value queue */
657     static YYSTYPE *yylve = 0;
658 
659     /* The last allocated position at the lexical value queue */
660     static YYSTYPE *yylvlim = 0;
661 
662 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
663     /* Base of the lexical position queue */
664     static YYLTYPE *yylpsns = 0;
665 
666     /* Current position at lexical position queue */
667     static YYLTYPE *yylpp = 0;
668 
669     /* End position of lexical position queue */
670     static YYLTYPE *yylpe = 0;
671 
672     /* The last allocated position at the lexical position queue */
673     static YYLTYPE *yylplim = 0;
674 #endif
675 
676     /* Current position at lexical token queue */
677     static YYINT  *yylexp = 0;
678 
679     static YYINT  *yylexemes = 0;
680 #endif /* YYBTYACC */
681     int yym, yyn, yystate, yyresult;
682 #if YYBTYACC
683     int yynewerrflag;
684     YYParseState *yyerrctx = NULL;
685 #endif /* YYBTYACC */
686 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
687     YYLTYPE  yyerror_loc_range[2]; /* position of error start & end */
688 #endif
689 #if YYDEBUG
690     const char *yys;
691 
692     if ((yys = getenv("YYDEBUG")) != 0)
693     {
694         yyn = *yys;
695         if (yyn >= '0' && yyn <= '9')
696             yydebug = yyn - '0';
697     }
698     if (yydebug)
699         fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX);
700 #endif
701 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
702     memset(yyerror_loc_range, 0, sizeof(yyerror_loc_range));
703 #endif
704 
705     yyerrflag = 0;
706     yychar = 0;
707     memset(&yyval,  0, sizeof(yyval));
708     memset(&yylval, 0, sizeof(yylval));
709 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
710     memset(&yyloc,  0, sizeof(yyloc));
711     memset(&yylloc, 0, sizeof(yylloc));
712 #endif
713 
714 #if YYBTYACC
715     yyps = yyNewState(0); if (yyps == 0) goto yyenomem;
716     yyps->save = 0;
717 #endif /* YYBTYACC */
718     yym = 0;
719     yyn = 0;
720     yynerrs = 0;
721     yyerrflag = 0;
722     yychar = YYEMPTY;
723     yystate = 0;
724 
725 #if YYPURE
726     memset(&yystack, 0, sizeof(yystack));
727 #endif
728 
729     if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
730     yystack.s_mark = yystack.s_base;
731     yystack.l_mark = yystack.l_base;
732 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
733     yystack.p_mark = yystack.p_base;
734 #endif
735     yystate = 0;
736     *yystack.s_mark = 0;
737 
738 yyloop:
739     if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
740     if (yychar < 0)
741     {
742 #if YYBTYACC
743         do {
744         if (yylvp < yylve)
745         {
746             /* we're currently re-reading tokens */
747             yylval = *yylvp++;
748 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
749             yylloc = *yylpp++;
750 #endif
751             yychar = *yylexp++;
752             break;
753         }
754         if (yyps->save)
755         {
756             /* in trial mode; save scanner results for future parse attempts */
757             if (yylvp == yylvlim)
758             {   /* Enlarge lexical value queue */
759                 size_t p = (size_t) (yylvp - yylvals);
760                 size_t s = (size_t) (yylvlim - yylvals);
761 
762                 s += YYLVQUEUEGROWTH;
763                 if ((yylexemes = realloc(yylexemes, s * sizeof(YYINT))) == NULL) goto yyenomem;
764                 if ((yylvals   = realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem;
765 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
766                 if ((yylpsns   = realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem;
767 #endif
768                 yylvp   = yylve = yylvals + p;
769                 yylvlim = yylvals + s;
770 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
771                 yylpp   = yylpe = yylpsns + p;
772                 yylplim = yylpsns + s;
773 #endif
774                 yylexp  = yylexemes + p;
775             }
776             *yylexp = (YYINT) YYLEX;
777             *yylvp++ = yylval;
778             yylve++;
779 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
780             *yylpp++ = yylloc;
781             yylpe++;
782 #endif
783             yychar = *yylexp++;
784             break;
785         }
786         /* normal operation, no conflict encountered */
787 #endif /* YYBTYACC */
788         yychar = YYLEX;
789 #if YYBTYACC
790         } while (0);
791 #endif /* YYBTYACC */
792         if (yychar < 0) yychar = YYEOF;
793 #if YYDEBUG
794         if (yydebug)
795         {
796             if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
797             fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)",
798                             YYDEBUGSTR, yydepth, yystate, yychar, yys);
799 #ifdef YYSTYPE_TOSTRING
800 #if YYBTYACC
801             if (!yytrial)
802 #endif /* YYBTYACC */
803                 fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval));
804 #endif
805             fputc('\n', stderr);
806         }
807 #endif
808     }
809 #if YYBTYACC
810 
811     /* Do we have a conflict? */
812     if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
813         yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
814     {
815         YYINT ctry;
816 
817         if (yypath)
818         {
819             YYParseState *save;
820 #if YYDEBUG
821             if (yydebug)
822                 fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n",
823                                 YYDEBUGSTR, yydepth, yystate);
824 #endif
825             /* Switch to the next conflict context */
826             save = yypath;
827             yypath = save->save;
828             save->save = NULL;
829             ctry = save->ctry;
830             if (save->state != yystate) YYABORT;
831             yyFreeState(save);
832 
833         }
834         else
835         {
836 
837             /* Unresolved conflict - start/continue trial parse */
838             YYParseState *save;
839 #if YYDEBUG
840             if (yydebug)
841             {
842                 fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate);
843                 if (yyps->save)
844                     fputs("ALREADY in conflict, continuing trial parse.\n", stderr);
845                 else
846                     fputs("Starting trial parse.\n", stderr);
847             }
848 #endif
849             save                  = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
850             if (save == NULL) goto yyenomem;
851             save->save            = yyps->save;
852             save->state           = yystate;
853             save->errflag         = yyerrflag;
854             save->yystack.s_mark  = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
855             memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
856             save->yystack.l_mark  = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
857             memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
858 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
859             save->yystack.p_mark  = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
860             memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
861 #endif
862             ctry                  = yytable[yyn];
863             if (yyctable[ctry] == -1)
864             {
865 #if YYDEBUG
866                 if (yydebug && yychar >= YYEOF)
867                     fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth);
868 #endif
869                 ctry++;
870             }
871             save->ctry = ctry;
872             if (yyps->save == NULL)
873             {
874                 /* If this is a first conflict in the stack, start saving lexemes */
875                 if (!yylexemes)
876                 {
877                     yylexemes = malloc((YYLVQUEUEGROWTH) * sizeof(YYINT));
878                     if (yylexemes == NULL) goto yyenomem;
879                     yylvals   = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE));
880                     if (yylvals == NULL) goto yyenomem;
881                     yylvlim   = yylvals + YYLVQUEUEGROWTH;
882 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
883                     yylpsns   = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE));
884                     if (yylpsns == NULL) goto yyenomem;
885                     yylplim   = yylpsns + YYLVQUEUEGROWTH;
886 #endif
887                 }
888                 if (yylvp == yylve)
889                 {
890                     yylvp  = yylve = yylvals;
891 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
892                     yylpp  = yylpe = yylpsns;
893 #endif
894                     yylexp = yylexemes;
895                     if (yychar >= YYEOF)
896                     {
897                         *yylve++ = yylval;
898 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
899                         *yylpe++ = yylloc;
900 #endif
901                         *yylexp  = (YYINT) yychar;
902                         yychar   = YYEMPTY;
903                     }
904                 }
905             }
906             if (yychar >= YYEOF)
907             {
908                 yylvp--;
909 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
910                 yylpp--;
911 #endif
912                 yylexp--;
913                 yychar = YYEMPTY;
914             }
915             save->lexeme = (int) (yylvp - yylvals);
916             yyps->save   = save;
917         }
918         if (yytable[yyn] == ctry)
919         {
920 #if YYDEBUG
921             if (yydebug)
922                 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
923                                 YYDEBUGSTR, yydepth, yystate, yyctable[ctry]);
924 #endif
925             if (yychar < 0)
926             {
927                 yylvp++;
928 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
929                 yylpp++;
930 #endif
931                 yylexp++;
932             }
933             if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
934                 goto yyoverflow;
935             yystate = yyctable[ctry];
936             *++yystack.s_mark = (YYINT) yystate;
937             *++yystack.l_mark = yylval;
938 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
939             *++yystack.p_mark = yylloc;
940 #endif
941             yychar  = YYEMPTY;
942             if (yyerrflag > 0) --yyerrflag;
943             goto yyloop;
944         }
945         else
946         {
947             yyn = yyctable[ctry];
948             goto yyreduce;
949         }
950     } /* End of code dealing with conflicts */
951 #endif /* YYBTYACC */
952     if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
953             yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
954     {
955 #if YYDEBUG
956         if (yydebug)
957             fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
958                             YYDEBUGSTR, yydepth, yystate, yytable[yyn]);
959 #endif
960         if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
961         yystate = yytable[yyn];
962         *++yystack.s_mark = yytable[yyn];
963         *++yystack.l_mark = yylval;
964 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
965         *++yystack.p_mark = yylloc;
966 #endif
967         yychar = YYEMPTY;
968         if (yyerrflag > 0)  --yyerrflag;
969         goto yyloop;
970     }
971     if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
972             yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
973     {
974         yyn = yytable[yyn];
975         goto yyreduce;
976     }
977     if (yyerrflag != 0) goto yyinrecovery;
978 #if YYBTYACC
979 
980     yynewerrflag = 1;
981     goto yyerrhandler;
982     goto yyerrlab; /* redundant goto avoids 'unused label' warning */
983 
984 yyerrlab:
985     /* explicit YYERROR from an action -- pop the rhs of the rule reduced
986      * before looking for error recovery */
987     yystack.s_mark -= yym;
988     yystate = *yystack.s_mark;
989     yystack.l_mark -= yym;
990 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
991     yystack.p_mark -= yym;
992 #endif
993 
994     yynewerrflag = 0;
995 yyerrhandler:
996     while (yyps->save)
997     {
998         int ctry;
999         YYParseState *save = yyps->save;
1000 #if YYDEBUG
1001         if (yydebug)
1002             fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n",
1003                             YYDEBUGSTR, yydepth, yystate, yyps->save->state,
1004                     (int)(yylvp - yylvals - yyps->save->lexeme));
1005 #endif
1006         /* Memorize most forward-looking error state in case it's really an error. */
1007         if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals)
1008         {
1009             /* Free old saved error context state */
1010             if (yyerrctx) yyFreeState(yyerrctx);
1011             /* Create and fill out new saved error context state */
1012             yyerrctx                 = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
1013             if (yyerrctx == NULL) goto yyenomem;
1014             yyerrctx->save           = yyps->save;
1015             yyerrctx->state          = yystate;
1016             yyerrctx->errflag        = yyerrflag;
1017             yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
1018             memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1019             yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
1020             memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1021 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1022             yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
1023             memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1024 #endif
1025             yyerrctx->lexeme         = (int) (yylvp - yylvals);
1026         }
1027         yylvp          = yylvals   + save->lexeme;
1028 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1029         yylpp          = yylpsns   + save->lexeme;
1030 #endif
1031         yylexp         = yylexemes + save->lexeme;
1032         yychar         = YYEMPTY;
1033         yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
1034         memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1035         yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
1036         memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1037 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1038         yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
1039         memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1040 #endif
1041         ctry           = ++save->ctry;
1042         yystate        = save->state;
1043         /* We tried shift, try reduce now */
1044         if ((yyn = yyctable[ctry]) >= 0) goto yyreduce;
1045         yyps->save     = save->save;
1046         save->save     = NULL;
1047         yyFreeState(save);
1048 
1049         /* Nothing left on the stack -- error */
1050         if (!yyps->save)
1051         {
1052 #if YYDEBUG
1053             if (yydebug)
1054                 fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n",
1055                                 YYPREFIX, yydepth);
1056 #endif
1057             /* Restore state as it was in the most forward-advanced error */
1058             yylvp          = yylvals   + yyerrctx->lexeme;
1059 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1060             yylpp          = yylpsns   + yyerrctx->lexeme;
1061 #endif
1062             yylexp         = yylexemes + yyerrctx->lexeme;
1063             yychar         = yylexp[-1];
1064             yylval         = yylvp[-1];
1065 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1066             yylloc         = yylpp[-1];
1067 #endif
1068             yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
1069             memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1070             yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
1071             memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1072 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1073             yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
1074             memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1075 #endif
1076             yystate        = yyerrctx->state;
1077             yyFreeState(yyerrctx);
1078             yyerrctx       = NULL;
1079         }
1080         yynewerrflag = 1;
1081     }
1082     if (yynewerrflag == 0) goto yyinrecovery;
1083 #endif /* YYBTYACC */
1084 
1085     YYERROR_CALL("syntax error");
1086 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1087     yyerror_loc_range[0] = yylloc; /* lookahead position is error start position */
1088 #endif
1089 
1090 #if !YYBTYACC
1091     goto yyerrlab; /* redundant goto avoids 'unused label' warning */
1092 yyerrlab:
1093 #endif
1094     ++yynerrs;
1095 
1096 yyinrecovery:
1097     if (yyerrflag < 3)
1098     {
1099         yyerrflag = 3;
1100         for (;;)
1101         {
1102             if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&
1103                     yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)
1104             {
1105 #if YYDEBUG
1106                 if (yydebug)
1107                     fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n",
1108                                     YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]);
1109 #endif
1110                 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1111                 yystate = yytable[yyn];
1112                 *++yystack.s_mark = yytable[yyn];
1113                 *++yystack.l_mark = yylval;
1114 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1115                 /* lookahead position is error end position */
1116                 yyerror_loc_range[1] = yylloc;
1117                 YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */
1118                 *++yystack.p_mark = yyloc;
1119 #endif
1120                 goto yyloop;
1121             }
1122             else
1123             {
1124 #if YYDEBUG
1125                 if (yydebug)
1126                     fprintf(stderr, "%s[%d]: error recovery discarding state %d\n",
1127                                     YYDEBUGSTR, yydepth, *yystack.s_mark);
1128 #endif
1129                 if (yystack.s_mark <= yystack.s_base) goto yyabort;
1130 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1131                 /* the current TOS position is the error start position */
1132                 yyerror_loc_range[0] = *yystack.p_mark;
1133 #endif
1134 #if defined(YYDESTRUCT_CALL)
1135 #if YYBTYACC
1136                 if (!yytrial)
1137 #endif /* YYBTYACC */
1138 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1139                     YYDESTRUCT_CALL("error: discarding state",
1140                                     yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark);
1141 #else
1142                     YYDESTRUCT_CALL("error: discarding state",
1143                                     yystos[*yystack.s_mark], yystack.l_mark);
1144 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1145 #endif /* defined(YYDESTRUCT_CALL) */
1146                 --yystack.s_mark;
1147                 --yystack.l_mark;
1148 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1149                 --yystack.p_mark;
1150 #endif
1151             }
1152         }
1153     }
1154     else
1155     {
1156         if (yychar == YYEOF) goto yyabort;
1157 #if YYDEBUG
1158         if (yydebug)
1159         {
1160             if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
1161             fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n",
1162                             YYDEBUGSTR, yydepth, yystate, yychar, yys);
1163         }
1164 #endif
1165 #if defined(YYDESTRUCT_CALL)
1166 #if YYBTYACC
1167         if (!yytrial)
1168 #endif /* YYBTYACC */
1169 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1170             YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc);
1171 #else
1172             YYDESTRUCT_CALL("error: discarding token", yychar, &yylval);
1173 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1174 #endif /* defined(YYDESTRUCT_CALL) */
1175         yychar = YYEMPTY;
1176         goto yyloop;
1177     }
1178 
1179 yyreduce:
1180     yym = yylen[yyn];
1181 #if YYDEBUG
1182     if (yydebug)
1183     {
1184         fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)",
1185                         YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]);
1186 #ifdef YYSTYPE_TOSTRING
1187 #if YYBTYACC
1188         if (!yytrial)
1189 #endif /* YYBTYACC */
1190             if (yym > 0)
1191             {
1192                 int i;
1193                 fputc('<', stderr);
1194                 for (i = yym; i > 0; i--)
1195                 {
1196                     if (i != yym) fputs(", ", stderr);
1197                     fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]],
1198                                            yystack.l_mark[1-i]), stderr);
1199                 }
1200                 fputc('>', stderr);
1201             }
1202 #endif
1203         fputc('\n', stderr);
1204     }
1205 #endif
1206     if (yym > 0)
1207         yyval = yystack.l_mark[1-yym];
1208     else
1209         memset(&yyval, 0, sizeof yyval);
1210 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1211 
1212     /* Perform position reduction */
1213     memset(&yyloc, 0, sizeof(yyloc));
1214 #if YYBTYACC
1215     if (!yytrial)
1216 #endif /* YYBTYACC */
1217     {
1218         YYLLOC_DEFAULT(yyloc, &yystack.p_mark[1-yym], yym);
1219         /* just in case YYERROR is invoked within the action, save
1220            the start of the rhs as the error start position */
1221         yyerror_loc_range[0] = yystack.p_mark[1-yym];
1222     }
1223 #endif
1224 
1225     switch (yyn)
1226     {
1227 case 3:
1228 #line 66 "ok_syntax1.y"
1229 	{  yyerrok ; }
1230 break;
1231 case 4:
1232 #line 70 "ok_syntax1.y"
1233 	{  printf("%d\n",yystack.l_mark[0].ival);}
1234 break;
1235 case 5:
1236 #line 72 "ok_syntax1.y"
1237 	{  regs[yystack.l_mark[-2].ival] = yystack.l_mark[0].ival; }
1238 break;
1239 case 6:
1240 #line 76 "ok_syntax1.y"
1241 	{  yyval.ival = yystack.l_mark[-1].ival; }
1242 break;
1243 case 7:
1244 #line 78 "ok_syntax1.y"
1245 	{  yyval.ival = yystack.l_mark[-2].ival + yystack.l_mark[0].ival; }
1246 break;
1247 case 8:
1248 #line 80 "ok_syntax1.y"
1249 	{  yyval.ival = yystack.l_mark[-2].ival - yystack.l_mark[0].ival; }
1250 break;
1251 case 9:
1252 #line 82 "ok_syntax1.y"
1253 	{  yyval.ival = yystack.l_mark[-2].ival * yystack.l_mark[0].ival; }
1254 break;
1255 case 10:
1256 #line 84 "ok_syntax1.y"
1257 	{  yyval.ival = yystack.l_mark[-2].ival / yystack.l_mark[0].ival; }
1258 break;
1259 case 11:
1260 #line 86 "ok_syntax1.y"
1261 	{  yyval.ival = yystack.l_mark[-2].ival % yystack.l_mark[0].ival; }
1262 break;
1263 case 12:
1264 #line 88 "ok_syntax1.y"
1265 	{  yyval.ival = yystack.l_mark[-2].ival & yystack.l_mark[0].ival; }
1266 break;
1267 case 13:
1268 #line 90 "ok_syntax1.y"
1269 	{  yyval.ival = yystack.l_mark[-2].ival | yystack.l_mark[0].ival; }
1270 break;
1271 case 14:
1272 #line 92 "ok_syntax1.y"
1273 	{  yyval.ival = - yystack.l_mark[0].ival; }
1274 break;
1275 case 15:
1276 #line 94 "ok_syntax1.y"
1277 	{  yyval.ival = regs[yystack.l_mark[0].ival]; }
1278 break;
1279 case 17:
1280 #line 99 "ok_syntax1.y"
1281 	{  yyval.ival = yystack.l_mark[0].ival; (*base) = (yystack.l_mark[0].ival==0) ? 8 : 10; }
1282 break;
1283 case 18:
1284 #line 101 "ok_syntax1.y"
1285 	{  yyval.ival = (*base) * yystack.l_mark[-1].ival + yystack.l_mark[0].ival; }
1286 break;
1287 #line 1288 "ok_syntax1.tab.c"
1288     default:
1289         break;
1290     }
1291     yystack.s_mark -= yym;
1292     yystate = *yystack.s_mark;
1293     yystack.l_mark -= yym;
1294 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1295     yystack.p_mark -= yym;
1296 #endif
1297     yym = yylhs[yyn];
1298     if (yystate == 0 && yym == 0)
1299     {
1300 #if YYDEBUG
1301         if (yydebug)
1302         {
1303             fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1304 #ifdef YYSTYPE_TOSTRING
1305 #if YYBTYACC
1306             if (!yytrial)
1307 #endif /* YYBTYACC */
1308                 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval));
1309 #endif
1310             fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL);
1311         }
1312 #endif
1313         yystate = YYFINAL;
1314         *++yystack.s_mark = YYFINAL;
1315         *++yystack.l_mark = yyval;
1316 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1317         *++yystack.p_mark = yyloc;
1318 #endif
1319         if (yychar < 0)
1320         {
1321 #if YYBTYACC
1322             do {
1323             if (yylvp < yylve)
1324             {
1325                 /* we're currently re-reading tokens */
1326                 yylval = *yylvp++;
1327 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1328                 yylloc = *yylpp++;
1329 #endif
1330                 yychar = *yylexp++;
1331                 break;
1332             }
1333             if (yyps->save)
1334             {
1335                 /* in trial mode; save scanner results for future parse attempts */
1336                 if (yylvp == yylvlim)
1337                 {   /* Enlarge lexical value queue */
1338                     size_t p = (size_t) (yylvp - yylvals);
1339                     size_t s = (size_t) (yylvlim - yylvals);
1340 
1341                     s += YYLVQUEUEGROWTH;
1342                     if ((yylexemes = realloc(yylexemes, s * sizeof(YYINT))) == NULL)
1343                         goto yyenomem;
1344                     if ((yylvals   = realloc(yylvals, s * sizeof(YYSTYPE))) == NULL)
1345                         goto yyenomem;
1346 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1347                     if ((yylpsns   = realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL)
1348                         goto yyenomem;
1349 #endif
1350                     yylvp   = yylve = yylvals + p;
1351                     yylvlim = yylvals + s;
1352 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1353                     yylpp   = yylpe = yylpsns + p;
1354                     yylplim = yylpsns + s;
1355 #endif
1356                     yylexp  = yylexemes + p;
1357                 }
1358                 *yylexp = (YYINT) YYLEX;
1359                 *yylvp++ = yylval;
1360                 yylve++;
1361 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1362                 *yylpp++ = yylloc;
1363                 yylpe++;
1364 #endif
1365                 yychar = *yylexp++;
1366                 break;
1367             }
1368             /* normal operation, no conflict encountered */
1369 #endif /* YYBTYACC */
1370             yychar = YYLEX;
1371 #if YYBTYACC
1372             } while (0);
1373 #endif /* YYBTYACC */
1374             if (yychar < 0) yychar = YYEOF;
1375 #if YYDEBUG
1376             if (yydebug)
1377             {
1378                 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
1379                 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)\n",
1380                                 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys);
1381             }
1382 #endif
1383         }
1384         if (yychar == YYEOF) goto yyaccept;
1385         goto yyloop;
1386     }
1387     if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
1388             yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
1389         yystate = yytable[yyn];
1390     else
1391         yystate = yydgoto[yym];
1392 #if YYDEBUG
1393     if (yydebug)
1394     {
1395         fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1396 #ifdef YYSTYPE_TOSTRING
1397 #if YYBTYACC
1398         if (!yytrial)
1399 #endif /* YYBTYACC */
1400             fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval));
1401 #endif
1402         fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate);
1403     }
1404 #endif
1405     if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1406     *++yystack.s_mark = (YYINT) yystate;
1407     *++yystack.l_mark = yyval;
1408 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1409     *++yystack.p_mark = yyloc;
1410 #endif
1411     goto yyloop;
1412 #if YYBTYACC
1413 
1414     /* Reduction declares that this path is valid. Set yypath and do a full parse */
1415 yyvalid:
1416     if (yypath) YYABORT;
1417     while (yyps->save)
1418     {
1419         YYParseState *save = yyps->save;
1420         yyps->save = save->save;
1421         save->save = yypath;
1422         yypath = save;
1423     }
1424 #if YYDEBUG
1425     if (yydebug)
1426         fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n",
1427                         YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme));
1428 #endif
1429     if (yyerrctx)
1430     {
1431         yyFreeState(yyerrctx);
1432         yyerrctx = NULL;
1433     }
1434     yylvp          = yylvals + yypath->lexeme;
1435 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1436     yylpp          = yylpsns + yypath->lexeme;
1437 #endif
1438     yylexp         = yylexemes + yypath->lexeme;
1439     yychar         = YYEMPTY;
1440     yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
1441     memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1442     yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
1443     memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1444 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1445     yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
1446     memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1447 #endif
1448     yystate        = yypath->state;
1449     goto yyloop;
1450 #endif /* YYBTYACC */
1451 
1452 yyoverflow:
1453     YYERROR_CALL("yacc stack overflow");
1454 #if YYBTYACC
1455     goto yyabort_nomem;
1456 yyenomem:
1457     YYERROR_CALL("memory exhausted");
1458 yyabort_nomem:
1459 #endif /* YYBTYACC */
1460     yyresult = 2;
1461     goto yyreturn;
1462 
1463 yyabort:
1464     yyresult = 1;
1465     goto yyreturn;
1466 
1467 yyaccept:
1468 #if YYBTYACC
1469     if (yyps->save) goto yyvalid;
1470 #endif /* YYBTYACC */
1471     yyresult = 0;
1472 
1473 yyreturn:
1474 #if defined(YYDESTRUCT_CALL)
1475     if (yychar != YYEOF && yychar != YYEMPTY)
1476 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1477         YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc);
1478 #else
1479         YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval);
1480 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1481 
1482     {
1483         YYSTYPE *pv;
1484 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1485         YYLTYPE *pp;
1486 
1487         for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp)
1488              YYDESTRUCT_CALL("cleanup: discarding state",
1489                              yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp);
1490 #else
1491         for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv)
1492              YYDESTRUCT_CALL("cleanup: discarding state",
1493                              yystos[*(yystack.s_base + (pv - yystack.l_base))], pv);
1494 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1495     }
1496 #endif /* defined(YYDESTRUCT_CALL) */
1497 
1498 #if YYBTYACC
1499     if (yyerrctx)
1500     {
1501         yyFreeState(yyerrctx);
1502         yyerrctx = NULL;
1503     }
1504     while (yyps)
1505     {
1506         YYParseState *save = yyps;
1507         yyps = save->save;
1508         save->save = NULL;
1509         yyFreeState(save);
1510     }
1511     while (yypath)
1512     {
1513         YYParseState *save = yypath;
1514         yypath = save->save;
1515         save->save = NULL;
1516         yyFreeState(save);
1517     }
1518 #endif /* YYBTYACC */
1519     yyfreestack(&yystack);
1520     return (yyresult);
1521 }
1522