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