xref: /freebsd/contrib/byacc/test/btyacc/ok_syntax1.tab.c (revision c7d813a93eeb447470734c9bc0c140d90a54c271)
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
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
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
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 */
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)
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 *
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
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
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 
702 #if YYBTYACC
703     yyps = yyNewState(0); if (yyps == 0) goto yyenomem;
704     yyps->save = 0;
705 #endif /* YYBTYACC */
706     yym = 0;
707     yyn = 0;
708     yynerrs = 0;
709     yyerrflag = 0;
710     yychar = YYEMPTY;
711     yystate = 0;
712 
713 #if YYPURE
714     memset(&yystack, 0, sizeof(yystack));
715 #endif
716 
717     if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
718     yystack.s_mark = yystack.s_base;
719     yystack.l_mark = yystack.l_base;
720 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
721     yystack.p_mark = yystack.p_base;
722 #endif
723     yystate = 0;
724     *yystack.s_mark = 0;
725 
726 yyloop:
727     if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
728     if (yychar < 0)
729     {
730 #if YYBTYACC
731         do {
732         if (yylvp < yylve)
733         {
734             /* we're currently re-reading tokens */
735             yylval = *yylvp++;
736 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
737             yylloc = *yylpp++;
738 #endif
739             yychar = *yylexp++;
740             break;
741         }
742         if (yyps->save)
743         {
744             /* in trial mode; save scanner results for future parse attempts */
745             if (yylvp == yylvlim)
746             {   /* Enlarge lexical value queue */
747                 size_t p = (size_t) (yylvp - yylvals);
748                 size_t s = (size_t) (yylvlim - yylvals);
749 
750                 s += YYLVQUEUEGROWTH;
751                 if ((yylexemes = realloc(yylexemes, s * sizeof(YYINT))) == NULL) goto yyenomem;
752                 if ((yylvals   = realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem;
753 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
754                 if ((yylpsns   = realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem;
755 #endif
756                 yylvp   = yylve = yylvals + p;
757                 yylvlim = yylvals + s;
758 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
759                 yylpp   = yylpe = yylpsns + p;
760                 yylplim = yylpsns + s;
761 #endif
762                 yylexp  = yylexemes + p;
763             }
764             *yylexp = (YYINT) YYLEX;
765             *yylvp++ = yylval;
766             yylve++;
767 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
768             *yylpp++ = yylloc;
769             yylpe++;
770 #endif
771             yychar = *yylexp++;
772             break;
773         }
774         /* normal operation, no conflict encountered */
775 #endif /* YYBTYACC */
776         yychar = YYLEX;
777 #if YYBTYACC
778         } while (0);
779 #endif /* YYBTYACC */
780         if (yychar < 0) yychar = YYEOF;
781 #if YYDEBUG
782         if (yydebug)
783         {
784             if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
785             fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)",
786                             YYDEBUGSTR, yydepth, yystate, yychar, yys);
787 #ifdef YYSTYPE_TOSTRING
788 #if YYBTYACC
789             if (!yytrial)
790 #endif /* YYBTYACC */
791                 fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval));
792 #endif
793             fputc('\n', stderr);
794         }
795 #endif
796     }
797 #if YYBTYACC
798 
799     /* Do we have a conflict? */
800     if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
801         yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
802     {
803         YYINT ctry;
804 
805         if (yypath)
806         {
807             YYParseState *save;
808 #if YYDEBUG
809             if (yydebug)
810                 fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n",
811                                 YYDEBUGSTR, yydepth, yystate);
812 #endif
813             /* Switch to the next conflict context */
814             save = yypath;
815             yypath = save->save;
816             save->save = NULL;
817             ctry = save->ctry;
818             if (save->state != yystate) YYABORT;
819             yyFreeState(save);
820 
821         }
822         else
823         {
824 
825             /* Unresolved conflict - start/continue trial parse */
826             YYParseState *save;
827 #if YYDEBUG
828             if (yydebug)
829             {
830                 fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate);
831                 if (yyps->save)
832                     fputs("ALREADY in conflict, continuing trial parse.\n", stderr);
833                 else
834                     fputs("Starting trial parse.\n", stderr);
835             }
836 #endif
837             save                  = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
838             if (save == NULL) goto yyenomem;
839             save->save            = yyps->save;
840             save->state           = yystate;
841             save->errflag         = yyerrflag;
842             save->yystack.s_mark  = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
843             memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
844             save->yystack.l_mark  = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
845             memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
846 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
847             save->yystack.p_mark  = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
848             memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
849 #endif
850             ctry                  = yytable[yyn];
851             if (yyctable[ctry] == -1)
852             {
853 #if YYDEBUG
854                 if (yydebug && yychar >= YYEOF)
855                     fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth);
856 #endif
857                 ctry++;
858             }
859             save->ctry = ctry;
860             if (yyps->save == NULL)
861             {
862                 /* If this is a first conflict in the stack, start saving lexemes */
863                 if (!yylexemes)
864                 {
865                     yylexemes = malloc((YYLVQUEUEGROWTH) * sizeof(YYINT));
866                     if (yylexemes == NULL) goto yyenomem;
867                     yylvals   = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE));
868                     if (yylvals == NULL) goto yyenomem;
869                     yylvlim   = yylvals + YYLVQUEUEGROWTH;
870 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
871                     yylpsns   = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE));
872                     if (yylpsns == NULL) goto yyenomem;
873                     yylplim   = yylpsns + YYLVQUEUEGROWTH;
874 #endif
875                 }
876                 if (yylvp == yylve)
877                 {
878                     yylvp  = yylve = yylvals;
879 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
880                     yylpp  = yylpe = yylpsns;
881 #endif
882                     yylexp = yylexemes;
883                     if (yychar >= YYEOF)
884                     {
885                         *yylve++ = yylval;
886 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
887                         *yylpe++ = yylloc;
888 #endif
889                         *yylexp  = (YYINT) yychar;
890                         yychar   = YYEMPTY;
891                     }
892                 }
893             }
894             if (yychar >= YYEOF)
895             {
896                 yylvp--;
897 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
898                 yylpp--;
899 #endif
900                 yylexp--;
901                 yychar = YYEMPTY;
902             }
903             save->lexeme = (int) (yylvp - yylvals);
904             yyps->save   = save;
905         }
906         if (yytable[yyn] == ctry)
907         {
908 #if YYDEBUG
909             if (yydebug)
910                 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
911                                 YYDEBUGSTR, yydepth, yystate, yyctable[ctry]);
912 #endif
913             if (yychar < 0)
914             {
915                 yylvp++;
916 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
917                 yylpp++;
918 #endif
919                 yylexp++;
920             }
921             if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
922                 goto yyoverflow;
923             yystate = yyctable[ctry];
924             *++yystack.s_mark = (YYINT) yystate;
925             *++yystack.l_mark = yylval;
926 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
927             *++yystack.p_mark = yylloc;
928 #endif
929             yychar  = YYEMPTY;
930             if (yyerrflag > 0) --yyerrflag;
931             goto yyloop;
932         }
933         else
934         {
935             yyn = yyctable[ctry];
936             goto yyreduce;
937         }
938     } /* End of code dealing with conflicts */
939 #endif /* YYBTYACC */
940     if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
941             yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
942     {
943 #if YYDEBUG
944         if (yydebug)
945             fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
946                             YYDEBUGSTR, yydepth, yystate, yytable[yyn]);
947 #endif
948         if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
949         yystate = yytable[yyn];
950         *++yystack.s_mark = yytable[yyn];
951         *++yystack.l_mark = yylval;
952 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
953         *++yystack.p_mark = yylloc;
954 #endif
955         yychar = YYEMPTY;
956         if (yyerrflag > 0)  --yyerrflag;
957         goto yyloop;
958     }
959     if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
960             yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
961     {
962         yyn = yytable[yyn];
963         goto yyreduce;
964     }
965     if (yyerrflag != 0) goto yyinrecovery;
966 #if YYBTYACC
967 
968     yynewerrflag = 1;
969     goto yyerrhandler;
970     goto yyerrlab; /* redundant goto avoids 'unused label' warning */
971 
972 yyerrlab:
973     /* explicit YYERROR from an action -- pop the rhs of the rule reduced
974      * before looking for error recovery */
975     yystack.s_mark -= yym;
976     yystate = *yystack.s_mark;
977     yystack.l_mark -= yym;
978 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
979     yystack.p_mark -= yym;
980 #endif
981 
982     yynewerrflag = 0;
983 yyerrhandler:
984     while (yyps->save)
985     {
986         int ctry;
987         YYParseState *save = yyps->save;
988 #if YYDEBUG
989         if (yydebug)
990             fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n",
991                             YYDEBUGSTR, yydepth, yystate, yyps->save->state,
992                     (int)(yylvp - yylvals - yyps->save->lexeme));
993 #endif
994         /* Memorize most forward-looking error state in case it's really an error. */
995         if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals)
996         {
997             /* Free old saved error context state */
998             if (yyerrctx) yyFreeState(yyerrctx);
999             /* Create and fill out new saved error context state */
1000             yyerrctx                 = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
1001             if (yyerrctx == NULL) goto yyenomem;
1002             yyerrctx->save           = yyps->save;
1003             yyerrctx->state          = yystate;
1004             yyerrctx->errflag        = yyerrflag;
1005             yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
1006             memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1007             yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
1008             memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1009 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1010             yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
1011             memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1012 #endif
1013             yyerrctx->lexeme         = (int) (yylvp - yylvals);
1014         }
1015         yylvp          = yylvals   + save->lexeme;
1016 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1017         yylpp          = yylpsns   + save->lexeme;
1018 #endif
1019         yylexp         = yylexemes + save->lexeme;
1020         yychar         = YYEMPTY;
1021         yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
1022         memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1023         yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
1024         memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1025 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1026         yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
1027         memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1028 #endif
1029         ctry           = ++save->ctry;
1030         yystate        = save->state;
1031         /* We tried shift, try reduce now */
1032         if ((yyn = yyctable[ctry]) >= 0) goto yyreduce;
1033         yyps->save     = save->save;
1034         save->save     = NULL;
1035         yyFreeState(save);
1036 
1037         /* Nothing left on the stack -- error */
1038         if (!yyps->save)
1039         {
1040 #if YYDEBUG
1041             if (yydebug)
1042                 fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n",
1043                                 YYPREFIX, yydepth);
1044 #endif
1045             /* Restore state as it was in the most forward-advanced error */
1046             yylvp          = yylvals   + yyerrctx->lexeme;
1047 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1048             yylpp          = yylpsns   + yyerrctx->lexeme;
1049 #endif
1050             yylexp         = yylexemes + yyerrctx->lexeme;
1051             yychar         = yylexp[-1];
1052             yylval         = yylvp[-1];
1053 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1054             yylloc         = yylpp[-1];
1055 #endif
1056             yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
1057             memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1058             yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
1059             memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1060 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1061             yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
1062             memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1063 #endif
1064             yystate        = yyerrctx->state;
1065             yyFreeState(yyerrctx);
1066             yyerrctx       = NULL;
1067         }
1068         yynewerrflag = 1;
1069     }
1070     if (yynewerrflag == 0) goto yyinrecovery;
1071 #endif /* YYBTYACC */
1072 
1073     YYERROR_CALL("syntax error");
1074 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1075     yyerror_loc_range[0] = yylloc; /* lookahead position is error start position */
1076 #endif
1077 
1078 #if !YYBTYACC
1079     goto yyerrlab; /* redundant goto avoids 'unused label' warning */
1080 yyerrlab:
1081 #endif
1082     ++yynerrs;
1083 
1084 yyinrecovery:
1085     if (yyerrflag < 3)
1086     {
1087         yyerrflag = 3;
1088         for (;;)
1089         {
1090             if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&
1091                     yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)
1092             {
1093 #if YYDEBUG
1094                 if (yydebug)
1095                     fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n",
1096                                     YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]);
1097 #endif
1098                 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1099                 yystate = yytable[yyn];
1100                 *++yystack.s_mark = yytable[yyn];
1101                 *++yystack.l_mark = yylval;
1102 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1103                 /* lookahead position is error end position */
1104                 yyerror_loc_range[1] = yylloc;
1105                 YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */
1106                 *++yystack.p_mark = yyloc;
1107 #endif
1108                 goto yyloop;
1109             }
1110             else
1111             {
1112 #if YYDEBUG
1113                 if (yydebug)
1114                     fprintf(stderr, "%s[%d]: error recovery discarding state %d\n",
1115                                     YYDEBUGSTR, yydepth, *yystack.s_mark);
1116 #endif
1117                 if (yystack.s_mark <= yystack.s_base) goto yyabort;
1118 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1119                 /* the current TOS position is the error start position */
1120                 yyerror_loc_range[0] = *yystack.p_mark;
1121 #endif
1122 #if defined(YYDESTRUCT_CALL)
1123 #if YYBTYACC
1124                 if (!yytrial)
1125 #endif /* YYBTYACC */
1126 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1127                     YYDESTRUCT_CALL("error: discarding state",
1128                                     yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark);
1129 #else
1130                     YYDESTRUCT_CALL("error: discarding state",
1131                                     yystos[*yystack.s_mark], yystack.l_mark);
1132 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1133 #endif /* defined(YYDESTRUCT_CALL) */
1134                 --yystack.s_mark;
1135                 --yystack.l_mark;
1136 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1137                 --yystack.p_mark;
1138 #endif
1139             }
1140         }
1141     }
1142     else
1143     {
1144         if (yychar == YYEOF) goto yyabort;
1145 #if YYDEBUG
1146         if (yydebug)
1147         {
1148             if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
1149             fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n",
1150                             YYDEBUGSTR, yydepth, yystate, yychar, yys);
1151         }
1152 #endif
1153 #if defined(YYDESTRUCT_CALL)
1154 #if YYBTYACC
1155         if (!yytrial)
1156 #endif /* YYBTYACC */
1157 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1158             YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc);
1159 #else
1160             YYDESTRUCT_CALL("error: discarding token", yychar, &yylval);
1161 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1162 #endif /* defined(YYDESTRUCT_CALL) */
1163         yychar = YYEMPTY;
1164         goto yyloop;
1165     }
1166 
1167 yyreduce:
1168     yym = yylen[yyn];
1169 #if YYDEBUG
1170     if (yydebug)
1171     {
1172         fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)",
1173                         YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]);
1174 #ifdef YYSTYPE_TOSTRING
1175 #if YYBTYACC
1176         if (!yytrial)
1177 #endif /* YYBTYACC */
1178             if (yym > 0)
1179             {
1180                 int i;
1181                 fputc('<', stderr);
1182                 for (i = yym; i > 0; i--)
1183                 {
1184                     if (i != yym) fputs(", ", stderr);
1185                     fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]],
1186                                            yystack.l_mark[1-i]), stderr);
1187                 }
1188                 fputc('>', stderr);
1189             }
1190 #endif
1191         fputc('\n', stderr);
1192     }
1193 #endif
1194     if (yym > 0)
1195         yyval = yystack.l_mark[1-yym];
1196     else
1197         memset(&yyval, 0, sizeof yyval);
1198 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1199 
1200     /* Perform position reduction */
1201     memset(&yyloc, 0, sizeof(yyloc));
1202 #if YYBTYACC
1203     if (!yytrial)
1204 #endif /* YYBTYACC */
1205     {
1206         YYLLOC_DEFAULT(yyloc, &yystack.p_mark[1-yym], yym);
1207         /* just in case YYERROR is invoked within the action, save
1208            the start of the rhs as the error start position */
1209         yyerror_loc_range[0] = yystack.p_mark[1-yym];
1210     }
1211 #endif
1212 
1213     switch (yyn)
1214     {
1215 case 3:
1216 #line 66 "ok_syntax1.y"
1217 	{  yyerrok ; }
1218 break;
1219 case 4:
1220 #line 70 "ok_syntax1.y"
1221 	{  printf("%d\n",yystack.l_mark[0].ival);}
1222 break;
1223 case 5:
1224 #line 72 "ok_syntax1.y"
1225 	{  regs[yystack.l_mark[-2].ival] = yystack.l_mark[0].ival; }
1226 break;
1227 case 6:
1228 #line 76 "ok_syntax1.y"
1229 	{  yyval.ival = yystack.l_mark[-1].ival; }
1230 break;
1231 case 7:
1232 #line 78 "ok_syntax1.y"
1233 	{  yyval.ival = yystack.l_mark[-2].ival + yystack.l_mark[0].ival; }
1234 break;
1235 case 8:
1236 #line 80 "ok_syntax1.y"
1237 	{  yyval.ival = yystack.l_mark[-2].ival - yystack.l_mark[0].ival; }
1238 break;
1239 case 9:
1240 #line 82 "ok_syntax1.y"
1241 	{  yyval.ival = yystack.l_mark[-2].ival * yystack.l_mark[0].ival; }
1242 break;
1243 case 10:
1244 #line 84 "ok_syntax1.y"
1245 	{  yyval.ival = yystack.l_mark[-2].ival / yystack.l_mark[0].ival; }
1246 break;
1247 case 11:
1248 #line 86 "ok_syntax1.y"
1249 	{  yyval.ival = yystack.l_mark[-2].ival % yystack.l_mark[0].ival; }
1250 break;
1251 case 12:
1252 #line 88 "ok_syntax1.y"
1253 	{  yyval.ival = yystack.l_mark[-2].ival & yystack.l_mark[0].ival; }
1254 break;
1255 case 13:
1256 #line 90 "ok_syntax1.y"
1257 	{  yyval.ival = yystack.l_mark[-2].ival | yystack.l_mark[0].ival; }
1258 break;
1259 case 14:
1260 #line 92 "ok_syntax1.y"
1261 	{  yyval.ival = - yystack.l_mark[0].ival; }
1262 break;
1263 case 15:
1264 #line 94 "ok_syntax1.y"
1265 	{  yyval.ival = regs[yystack.l_mark[0].ival]; }
1266 break;
1267 case 17:
1268 #line 99 "ok_syntax1.y"
1269 	{  yyval.ival = yystack.l_mark[0].ival; (*base) = (yystack.l_mark[0].ival==0) ? 8 : 10; }
1270 break;
1271 case 18:
1272 #line 101 "ok_syntax1.y"
1273 	{  yyval.ival = (*base) * yystack.l_mark[-1].ival + yystack.l_mark[0].ival; }
1274 break;
1275 #line 1276 "ok_syntax1.tab.c"
1276     default:
1277         break;
1278     }
1279     yystack.s_mark -= yym;
1280     yystate = *yystack.s_mark;
1281     yystack.l_mark -= yym;
1282 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1283     yystack.p_mark -= yym;
1284 #endif
1285     yym = yylhs[yyn];
1286     if (yystate == 0 && yym == 0)
1287     {
1288 #if YYDEBUG
1289         if (yydebug)
1290         {
1291             fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1292 #ifdef YYSTYPE_TOSTRING
1293 #if YYBTYACC
1294             if (!yytrial)
1295 #endif /* YYBTYACC */
1296                 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval));
1297 #endif
1298             fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL);
1299         }
1300 #endif
1301         yystate = YYFINAL;
1302         *++yystack.s_mark = YYFINAL;
1303         *++yystack.l_mark = yyval;
1304 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1305         *++yystack.p_mark = yyloc;
1306 #endif
1307         if (yychar < 0)
1308         {
1309 #if YYBTYACC
1310             do {
1311             if (yylvp < yylve)
1312             {
1313                 /* we're currently re-reading tokens */
1314                 yylval = *yylvp++;
1315 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1316                 yylloc = *yylpp++;
1317 #endif
1318                 yychar = *yylexp++;
1319                 break;
1320             }
1321             if (yyps->save)
1322             {
1323                 /* in trial mode; save scanner results for future parse attempts */
1324                 if (yylvp == yylvlim)
1325                 {   /* Enlarge lexical value queue */
1326                     size_t p = (size_t) (yylvp - yylvals);
1327                     size_t s = (size_t) (yylvlim - yylvals);
1328 
1329                     s += YYLVQUEUEGROWTH;
1330                     if ((yylexemes = realloc(yylexemes, s * sizeof(YYINT))) == NULL)
1331                         goto yyenomem;
1332                     if ((yylvals   = realloc(yylvals, s * sizeof(YYSTYPE))) == NULL)
1333                         goto yyenomem;
1334 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1335                     if ((yylpsns   = realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL)
1336                         goto yyenomem;
1337 #endif
1338                     yylvp   = yylve = yylvals + p;
1339                     yylvlim = yylvals + s;
1340 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1341                     yylpp   = yylpe = yylpsns + p;
1342                     yylplim = yylpsns + s;
1343 #endif
1344                     yylexp  = yylexemes + p;
1345                 }
1346                 *yylexp = (YYINT) YYLEX;
1347                 *yylvp++ = yylval;
1348                 yylve++;
1349 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1350                 *yylpp++ = yylloc;
1351                 yylpe++;
1352 #endif
1353                 yychar = *yylexp++;
1354                 break;
1355             }
1356             /* normal operation, no conflict encountered */
1357 #endif /* YYBTYACC */
1358             yychar = YYLEX;
1359 #if YYBTYACC
1360             } while (0);
1361 #endif /* YYBTYACC */
1362             if (yychar < 0) yychar = YYEOF;
1363 #if YYDEBUG
1364             if (yydebug)
1365             {
1366                 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
1367                 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)\n",
1368                                 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys);
1369             }
1370 #endif
1371         }
1372         if (yychar == YYEOF) goto yyaccept;
1373         goto yyloop;
1374     }
1375     if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
1376             yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
1377         yystate = yytable[yyn];
1378     else
1379         yystate = yydgoto[yym];
1380 #if YYDEBUG
1381     if (yydebug)
1382     {
1383         fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1384 #ifdef YYSTYPE_TOSTRING
1385 #if YYBTYACC
1386         if (!yytrial)
1387 #endif /* YYBTYACC */
1388             fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval));
1389 #endif
1390         fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate);
1391     }
1392 #endif
1393     if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1394     *++yystack.s_mark = (YYINT) yystate;
1395     *++yystack.l_mark = yyval;
1396 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1397     *++yystack.p_mark = yyloc;
1398 #endif
1399     goto yyloop;
1400 #if YYBTYACC
1401 
1402     /* Reduction declares that this path is valid. Set yypath and do a full parse */
1403 yyvalid:
1404     if (yypath) YYABORT;
1405     while (yyps->save)
1406     {
1407         YYParseState *save = yyps->save;
1408         yyps->save = save->save;
1409         save->save = yypath;
1410         yypath = save;
1411     }
1412 #if YYDEBUG
1413     if (yydebug)
1414         fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n",
1415                         YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme));
1416 #endif
1417     if (yyerrctx)
1418     {
1419         yyFreeState(yyerrctx);
1420         yyerrctx = NULL;
1421     }
1422     yylvp          = yylvals + yypath->lexeme;
1423 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1424     yylpp          = yylpsns + yypath->lexeme;
1425 #endif
1426     yylexp         = yylexemes + yypath->lexeme;
1427     yychar         = YYEMPTY;
1428     yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
1429     memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1430     yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
1431     memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1432 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1433     yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
1434     memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1435 #endif
1436     yystate        = yypath->state;
1437     goto yyloop;
1438 #endif /* YYBTYACC */
1439 
1440 yyoverflow:
1441     YYERROR_CALL("yacc stack overflow");
1442 #if YYBTYACC
1443     goto yyabort_nomem;
1444 yyenomem:
1445     YYERROR_CALL("memory exhausted");
1446 yyabort_nomem:
1447 #endif /* YYBTYACC */
1448     yyresult = 2;
1449     goto yyreturn;
1450 
1451 yyabort:
1452     yyresult = 1;
1453     goto yyreturn;
1454 
1455 yyaccept:
1456 #if YYBTYACC
1457     if (yyps->save) goto yyvalid;
1458 #endif /* YYBTYACC */
1459     yyresult = 0;
1460 
1461 yyreturn:
1462 #if defined(YYDESTRUCT_CALL)
1463     if (yychar != YYEOF && yychar != YYEMPTY)
1464 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1465         YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc);
1466 #else
1467         YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval);
1468 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1469 
1470     {
1471         YYSTYPE *pv;
1472 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1473         YYLTYPE *pp;
1474 
1475         for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp)
1476              YYDESTRUCT_CALL("cleanup: discarding state",
1477                              yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp);
1478 #else
1479         for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv)
1480              YYDESTRUCT_CALL("cleanup: discarding state",
1481                              yystos[*(yystack.s_base + (pv - yystack.l_base))], pv);
1482 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1483     }
1484 #endif /* defined(YYDESTRUCT_CALL) */
1485 
1486 #if YYBTYACC
1487     if (yyerrctx)
1488     {
1489         yyFreeState(yyerrctx);
1490         yyerrctx = NULL;
1491     }
1492     while (yyps)
1493     {
1494         YYParseState *save = yyps;
1495         yyps = save->save;
1496         save->save = NULL;
1497         yyFreeState(save);
1498     }
1499     while (yypath)
1500     {
1501         YYParseState *save = yypath;
1502         yypath = save->save;
1503         save->save = NULL;
1504         yyFreeState(save);
1505     }
1506 #endif /* YYBTYACC */
1507     yyfreestack(&yystack);
1508     return (yyresult);
1509 }
1510