CoCalc -- calc_code

GitHub Repository: freebsd/freebsd-src
Path: blob/main/contrib/byacc/test/btyacc/calc_code_all.tab.c
⁴⁸⁰⁸³ views
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 2
7
#define YYMINOR 0
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

17
/* %code "top" block start */
18
#line 5 "calc_code_all.y"
19
/* CODE-TOP */ 
20
/* %code "top" block end */
21
#line 22 "calc_code_all.tab.c"
22
#undef YYBTYACC
23
#define YYBTYACC 0
24
#define YYDEBUGSTR YYPREFIX "debug"
25

26
#ifndef yyparse
27
#define yyparse    calc_code_all_parse
28
#endif /* yyparse */
29

30
#ifndef yylex
31
#define yylex      calc_code_all_lex
32
#endif /* yylex */
33

34
#ifndef yyerror
35
#define yyerror    calc_code_all_error
36
#endif /* yyerror */
37

38
#ifndef yychar
39
#define yychar     calc_code_all_char
40
#endif /* yychar */
41

42
#ifndef yyval
43
#define yyval      calc_code_all_val
44
#endif /* yyval */
45

46
#ifndef yylval
47
#define yylval     calc_code_all_lval
48
#endif /* yylval */
49

50
#ifndef yydebug
51
#define yydebug    calc_code_all_debug
52
#endif /* yydebug */
53

54
#ifndef yynerrs
55
#define yynerrs    calc_code_all_nerrs
56
#endif /* yynerrs */
57

58
#ifndef yyerrflag
59
#define yyerrflag  calc_code_all_errflag
60
#endif /* yyerrflag */
61

62
#ifndef yylhs
63
#define yylhs      calc_code_all_lhs
64
#endif /* yylhs */
65

66
#ifndef yylen
67
#define yylen      calc_code_all_len
68
#endif /* yylen */
69

70
#ifndef yydefred
71
#define yydefred   calc_code_all_defred
72
#endif /* yydefred */
73

74
#ifndef yystos
75
#define yystos     calc_code_all_stos
76
#endif /* yystos */
77

78
#ifndef yydgoto
79
#define yydgoto    calc_code_all_dgoto
80
#endif /* yydgoto */
81

82
#ifndef yysindex
83
#define yysindex   calc_code_all_sindex
84
#endif /* yysindex */
85

86
#ifndef yyrindex
87
#define yyrindex   calc_code_all_rindex
88
#endif /* yyrindex */
89

90
#ifndef yygindex
91
#define yygindex   calc_code_all_gindex
92
#endif /* yygindex */
93

94
#ifndef yytable
95
#define yytable    calc_code_all_table
96
#endif /* yytable */
97

98
#ifndef yycheck
99
#define yycheck    calc_code_all_check
100
#endif /* yycheck */
101

102
#ifndef yyname
103
#define yyname     calc_code_all_name
104
#endif /* yyname */
105

106
#ifndef yyrule
107
#define yyrule     calc_code_all_rule
108
#endif /* yyrule */
109

110
#if YYBTYACC
111

112
#ifndef yycindex
113
#define yycindex   calc_code_all_cindex
114
#endif /* yycindex */
115

116
#ifndef yyctable
117
#define yyctable   calc_code_all_ctable
118
#endif /* yyctable */
119

120
#endif /* YYBTYACC */
121

122
#define YYPREFIX "calc_code_all_"
123

124
#define YYPURE 0
125

126
#line 9 "calc_code_all.y"
127
# include <stdio.h>
128
# include <ctype.h>
129

130
int regs[26];
131
int base;
132

133
extern int yylex(void);
134
static void yyerror(const char *s);
135

136
#line 137 "calc_code_all.tab.c"
137

138
#if ! defined(YYSTYPE) && ! defined(YYSTYPE_IS_DECLARED)
139
/* Default: YYSTYPE is the semantic value type. */
140
typedef int YYSTYPE;
141
# define YYSTYPE_IS_DECLARED 1
142
#endif
143

144
/* compatibility with bison */
145
#ifdef YYPARSE_PARAM
146
/* compatibility with FreeBSD */
147
# ifdef YYPARSE_PARAM_TYPE
148
#  define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
149
# else
150
#  define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
151
# endif
152
#else
153
# define YYPARSE_DECL() yyparse(void)
154
#endif
155

156
/* Parameters sent to lex. */
157
#ifdef YYLEX_PARAM
158
# define YYLEX_DECL() yylex(void *YYLEX_PARAM)
159
# define YYLEX yylex(YYLEX_PARAM)
160
#else
161
# define YYLEX_DECL() yylex(void)
162
# define YYLEX yylex()
163
#endif
164

165
/* Parameters sent to yyerror. */
166
#ifndef YYERROR_DECL
167
#define YYERROR_DECL() yyerror(const char *s)
168
#endif
169
#ifndef YYERROR_CALL
170
#define YYERROR_CALL(msg) yyerror(msg)
171
#endif
172

173
extern int YYPARSE_DECL();
174

175
#define DIGIT 257
176
#define LETTER 258
177
#define UMINUS 259
178
#define YYERRCODE 256
179
typedef int YYINT;
180
static const YYINT calc_code_all_lhs[] = {               -1,
181
    0,    0,    0,    1,    1,    2,    2,    2,    2,    2,
182
    2,    2,    2,    2,    2,    2,    3,    3,
183
};
184
static const YYINT calc_code_all_len[] = {                2,
185
    0,    3,    3,    1,    3,    3,    3,    3,    3,    3,
186
    3,    3,    3,    2,    1,    1,    1,    2,
187
};
188
static const YYINT calc_code_all_defred[] = {             1,
189
    0,    0,   17,    0,    0,    0,    0,    0,    0,    3,
190
    0,   15,   14,    0,    2,    0,    0,    0,    0,    0,
191
    0,    0,   18,    0,    6,    0,    0,    0,    0,    9,
192
   10,   11,
193
};
194
#if defined(YYDESTRUCT_CALL) || defined(YYSTYPE_TOSTRING)
195
static const YYINT calc_code_all_stos[] = {               0,
196
  261,  256,  257,  258,   45,   40,  262,  263,  264,   10,
197
   61,  258,  263,  263,   10,  124,   38,   43,   45,   42,
198
   47,   37,  257,  263,   41,  263,  263,  263,  263,  263,
199
  263,  263,
200
};
201
#endif /* YYDESTRUCT_CALL || YYSTYPE_TOSTRING */
202
static const YYINT calc_code_all_dgoto[] = {              1,
203
    7,    8,    9,
204
};
205
static const YYINT calc_code_all_sindex[] = {             0,
206
  -40,   -7,    0,  -55,  -38,  -38,    1,  -29, -247,    0,
207
  -38,    0,    0,   22,    0,  -38,  -38,  -38,  -38,  -38,
208
  -38,  -38,    0,  -29,    0,   51,   60,  -20,  -20,    0,
209
    0,    0,
210
};
211
static const YYINT calc_code_all_rindex[] = {             0,
212
    0,    0,    0,    2,    0,    0,    0,    9,   -9,    0,
213
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
214
    0,    0,    0,   10,    0,   -6,   14,    5,   13,    0,
215
    0,    0,
216
};
217
#if YYBTYACC
218
static const YYINT calc_code_all_cindex[] = {             0,
219
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
220
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
221
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
222
    0,    0,
223
};
224
#endif
225
static const YYINT calc_code_all_gindex[] = {             0,
226
    0,   65,    0,
227
};
228
#define YYTABLESIZE 220
229
static const YYINT calc_code_all_table[] = {              6,
230
   16,    6,   10,   13,    5,   11,    5,   22,   17,   23,
231
   15,   15,   20,   18,    7,   19,   22,   21,    4,    5,
232
    0,   20,    8,   12,    0,    0,   21,   16,   16,    0,
233
    0,   16,   16,   16,   13,   16,    0,   16,   15,   15,
234
    0,    0,    7,   15,   15,    7,   15,    7,   15,    7,
235
    8,   12,    0,    8,   12,    8,    0,    8,   22,   17,
236
    0,    0,   25,   20,   18,    0,   19,    0,   21,   13,
237
   14,    0,    0,    0,    0,   24,    0,    0,    0,    0,
238
   26,   27,   28,   29,   30,   31,   32,   22,   17,    0,
239
    0,    0,   20,   18,   16,   19,   22,   21,    0,    0,
240
    0,   20,   18,    0,   19,    0,   21,    0,    0,    0,
241
    0,    0,    0,    0,   16,    0,    0,   13,    0,    0,
242
    0,    0,    0,    0,    0,   15,    0,    0,    7,    0,
243
    0,    0,    0,    0,    0,    0,    8,   12,    0,    0,
244
    0,    0,    0,    0,    0,   16,    0,    0,    0,    0,
245
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
246
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
247
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
248
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
249
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
250
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
251
    0,    0,    0,    0,    0,    2,    3,    4,    3,   12,
252
};
253
static const YYINT calc_code_all_check[] = {             40,
254
   10,   40,   10,   10,   45,   61,   45,   37,   38,  257,
255
   10,   10,   42,   43,   10,   45,   37,   47,   10,   10,
256
   -1,   42,   10,   10,   -1,   -1,   47,   37,   38,   -1,
257
   -1,   41,   42,   43,   41,   45,   -1,   47,   37,   38,
258
   -1,   -1,   38,   42,   43,   41,   45,   43,   47,   45,
259
   38,   38,   -1,   41,   41,   43,   -1,   45,   37,   38,
260
   -1,   -1,   41,   42,   43,   -1,   45,   -1,   47,    5,
261
    6,   -1,   -1,   -1,   -1,   11,   -1,   -1,   -1,   -1,
262
   16,   17,   18,   19,   20,   21,   22,   37,   38,   -1,
263
   -1,   -1,   42,   43,  124,   45,   37,   47,   -1,   -1,
264
   -1,   42,   43,   -1,   45,   -1,   47,   -1,   -1,   -1,
265
   -1,   -1,   -1,   -1,  124,   -1,   -1,  124,   -1,   -1,
266
   -1,   -1,   -1,   -1,   -1,  124,   -1,   -1,  124,   -1,
267
   -1,   -1,   -1,   -1,   -1,   -1,  124,  124,   -1,   -1,
268
   -1,   -1,   -1,   -1,   -1,  124,   -1,   -1,   -1,   -1,
269
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
270
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
271
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
272
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
273
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
274
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
275
   -1,   -1,   -1,   -1,   -1,  256,  257,  258,  257,  258,
276
};
277
#if YYBTYACC
278
static const YYINT calc_code_all_ctable[] = {            -1,
279
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
280
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
281
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
282
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
283
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
284
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
285
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
286
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
287
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
288
   -1,   -1,   -1,   -1,   -1,   -1,   -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,   -1,   -1,   -1,   -1,   -1,
296
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
297
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
298
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
299
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
300
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
301
};
302
#endif
303
#define YYFINAL 1
304
#ifndef YYDEBUG
305
#define YYDEBUG 0
306
#endif
307
#define YYMAXTOKEN 259
308
#define YYUNDFTOKEN 265
309
#define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a))
310
#if YYDEBUG
311
static const char *const calc_code_all_name[] = {
312

313
"$end",0,0,0,0,0,0,0,0,0,"'\\n'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
314
0,0,0,"'%'","'&'",0,"'('","')'","'*'","'+'",0,"'-'",0,"'/'",0,0,0,0,0,0,0,0,0,0,
315
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,
316
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,
317
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,
318
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,
319
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,
320
0,0,"error","DIGIT","LETTER","UMINUS","$accept","list","stat","expr","number",
321
"illegal-symbol",
322
};
323
static const char *const calc_code_all_rule[] = {
324
"$accept : list",
325
"list :",
326
"list : list stat '\\n'",
327
"list : list error '\\n'",
328
"stat : expr",
329
"stat : LETTER '=' expr",
330
"expr : '(' expr ')'",
331
"expr : expr '+' expr",
332
"expr : expr '-' expr",
333
"expr : expr '*' expr",
334
"expr : expr '/' expr",
335
"expr : expr '%' expr",
336
"expr : expr '&' expr",
337
"expr : expr '|' expr",
338
"expr : '-' expr",
339
"expr : LETTER",
340
"expr : number",
341
"number : DIGIT",
342
"number : number DIGIT",
343

344
};
345
#endif
346

347
#if YYDEBUG
348
int      yydebug;
349
#endif
350

351
int      yyerrflag;
352
int      yychar;
353
YYSTYPE  yyval;
354
YYSTYPE  yylval;
355
int      yynerrs;
356

357
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
358
YYLTYPE  yyloc; /* position returned by actions */
359
YYLTYPE  yylloc; /* position from the lexer */
360
#endif
361

362
/* %code "requires" block start */
363
#line 3 "calc_code_all.y"
364
/* CODE-REQUIRES */ 
365
/* %code "requires" block end */
366
#line 367 "calc_code_all.tab.c"
367

368
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
369
#ifndef YYLLOC_DEFAULT
370
#define YYLLOC_DEFAULT(loc, rhs, n) \
371
do \
372
{ \
373
    if (n == 0) \
374
    { \
375
        (loc).first_line   = YYRHSLOC(rhs, 0).last_line; \
376
        (loc).first_column = YYRHSLOC(rhs, 0).last_column; \
377
        (loc).last_line    = YYRHSLOC(rhs, 0).last_line; \
378
        (loc).last_column  = YYRHSLOC(rhs, 0).last_column; \
379
    } \
380
    else \
381
    { \
382
        (loc).first_line   = YYRHSLOC(rhs, 1).first_line; \
383
        (loc).first_column = YYRHSLOC(rhs, 1).first_column; \
384
        (loc).last_line    = YYRHSLOC(rhs, n).last_line; \
385
        (loc).last_column  = YYRHSLOC(rhs, n).last_column; \
386
    } \
387
} while (0)
388
#endif /* YYLLOC_DEFAULT */
389
#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
390
#if YYBTYACC
391

392
#ifndef YYLVQUEUEGROWTH
393
#define YYLVQUEUEGROWTH 32
394
#endif
395
#endif /* YYBTYACC */
396

397
/* define the initial stack-sizes */
398
#ifdef YYSTACKSIZE
399
#undef YYMAXDEPTH
400
#define YYMAXDEPTH  YYSTACKSIZE
401
#else
402
#ifdef YYMAXDEPTH
403
#define YYSTACKSIZE YYMAXDEPTH
404
#else
405
#define YYSTACKSIZE 10000
406
#define YYMAXDEPTH  10000
407
#endif
408
#endif
409

410
#ifndef YYINITSTACKSIZE
411
#define YYINITSTACKSIZE 200
412
#endif
413

414
typedef struct {
415
    unsigned stacksize;
416
    YYINT    *s_base;
417
    YYINT    *s_mark;
418
    YYINT    *s_last;
419
    YYSTYPE  *l_base;
420
    YYSTYPE  *l_mark;
421
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
422
    YYLTYPE  *p_base;
423
    YYLTYPE  *p_mark;
424
#endif
425
} YYSTACKDATA;
426
#if YYBTYACC
427

428
struct YYParseState_s
429
{
430
    struct YYParseState_s *save;    /* Previously saved parser state */
431
    YYSTACKDATA            yystack; /* saved parser stack */
432
    int                    state;   /* saved parser state */
433
    int                    errflag; /* saved error recovery status */
434
    int                    lexeme;  /* saved index of the conflict lexeme in the lexical queue */
435
    YYINT                  ctry;    /* saved index in yyctable[] for this conflict */
436
};
437
typedef struct YYParseState_s YYParseState;
438
#endif /* YYBTYACC */
439
/* variables for the parser stack */
440
static YYSTACKDATA yystack;
441
#if YYBTYACC
442

443
/* Current parser state */
444
static YYParseState *yyps = 0;
445

446
/* yypath != NULL: do the full parse, starting at *yypath parser state. */
447
static YYParseState *yypath = 0;
448

449
/* Base of the lexical value queue */
450
static YYSTYPE *yylvals = 0;
451

452
/* Current position at lexical value queue */
453
static YYSTYPE *yylvp = 0;
454

455
/* End position of lexical value queue */
456
static YYSTYPE *yylve = 0;
457

458
/* The last allocated position at the lexical value queue */
459
static YYSTYPE *yylvlim = 0;
460

461
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
462
/* Base of the lexical position queue */
463
static YYLTYPE *yylpsns = 0;
464

465
/* Current position at lexical position queue */
466
static YYLTYPE *yylpp = 0;
467

468
/* End position of lexical position queue */
469
static YYLTYPE *yylpe = 0;
470

471
/* The last allocated position at the lexical position queue */
472
static YYLTYPE *yylplim = 0;
473
#endif
474

475
/* Current position at lexical token queue */
476
static YYINT  *yylexp = 0;
477

478
static YYINT  *yylexemes = 0;
479
#endif /* YYBTYACC */
480

481
/* %code "provides" block start */
482
#line 4 "calc_code_all.y"
483
/* CODE-PROVIDES */ 
484
#line 6 "calc_code_all.y"
485
/* CODE-PROVIDES2 */ 
486
/* %code "provides" block end */
487
#line 488 "calc_code_all.tab.c"
488

489
/* %code "" block start */
490
#line 1 "calc_code_all.y"
491
/* CODE-DEFAULT2 */ 
492
#line 2 "calc_code_all.y"
493
/* CODE-DEFAULT */ 
494
/* %code "" block end */
495
#line 496 "calc_code_all.tab.c"
496
#line 73 "calc_code_all.y"
497
 /* start of programs */
498

499
int
500
main (void)
501
{
502
    while(!feof(stdin)) {
503
	yyparse();
504
    }
505
    return 0;
506
}
507

508
static void
509
yyerror(const char *s)
510
{
511
    fprintf(stderr, "%s\n", s);
512
}
513

514
int
515
yylex(void)
516
{
517
	/* lexical analysis routine */
518
	/* returns LETTER for a lower case letter, yylval = 0 through 25 */
519
	/* return DIGIT for a digit, yylval = 0 through 9 */
520
	/* all other characters are returned immediately */
521

522
    int c;
523

524
    while( (c=getchar()) == ' ' )   { /* skip blanks */ }
525

526
    /* c is now nonblank */
527

528
    if( islower( c )) {
529
	yylval = c - 'a';
530
	return ( LETTER );
531
    }
532
    if( isdigit( c )) {
533
	yylval = c - '0';
534
	return ( DIGIT );
535
    }
536
    return( c );
537
}
538
#line 539 "calc_code_all.tab.c"
539

540
/* For use in generated program */
541
#define yydepth (int)(yystack.s_mark - yystack.s_base)
542
#if YYBTYACC
543
#define yytrial (yyps->save)
544
#endif /* YYBTYACC */
545

546
#if YYDEBUG
547
#include <stdio.h>	/* needed for printf */
548
#endif
549

550
#include <stdlib.h>	/* needed for malloc, etc */
551
#include <string.h>	/* needed for memset */
552

553
/* allocate initial stack or double stack size, up to YYMAXDEPTH */
554
static int yygrowstack(YYSTACKDATA *data)
555
{
556
    int i;
557
    unsigned newsize;
558
    YYINT *newss;
559
    YYSTYPE *newvs;
560
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
561
    YYLTYPE *newps;
562
#endif
563

564
    if ((newsize = data->stacksize) == 0)
565
        newsize = YYINITSTACKSIZE;
566
    else if (newsize >= YYMAXDEPTH)
567
        return YYENOMEM;
568
    else if ((newsize *= 2) > YYMAXDEPTH)
569
        newsize = YYMAXDEPTH;
570

571
    i = (int) (data->s_mark - data->s_base);
572
    newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss));
573
    if (newss == NULL)
574
        return YYENOMEM;
575

576
    data->s_base = newss;
577
    data->s_mark = newss + i;
578

579
    newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
580
    if (newvs == NULL)
581
        return YYENOMEM;
582

583
    data->l_base = newvs;
584
    data->l_mark = newvs + i;
585

586
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
587
    newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps));
588
    if (newps == NULL)
589
        return YYENOMEM;
590

591
    data->p_base = newps;
592
    data->p_mark = newps + i;
593
#endif
594

595
    data->stacksize = newsize;
596
    data->s_last = data->s_base + newsize - 1;
597

598
#if YYDEBUG
599
    if (yydebug)
600
        fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize);
601
#endif
602
    return 0;
603
}
604

605
#if YYPURE || defined(YY_NO_LEAKS)
606
static void yyfreestack(YYSTACKDATA *data)
607
{
608
    free(data->s_base);
609
    free(data->l_base);
610
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
611
    free(data->p_base);
612
#endif
613
    memset(data, 0, sizeof(*data));
614
}
615
#else
616
#define yyfreestack(data) /* nothing */
617
#endif /* YYPURE || defined(YY_NO_LEAKS) */
618
#if YYBTYACC
619

620
static YYParseState *
621
yyNewState(unsigned size)
622
{
623
    YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState));
624
    if (p == NULL) return NULL;
625

626
    p->yystack.stacksize = size;
627
    if (size == 0)
628
    {
629
        p->yystack.s_base = NULL;
630
        p->yystack.l_base = NULL;
631
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
632
        p->yystack.p_base = NULL;
633
#endif
634
        return p;
635
    }
636
    p->yystack.s_base    = (YYINT *) malloc(size * sizeof(YYINT));
637
    if (p->yystack.s_base == NULL) return NULL;
638
    p->yystack.l_base    = (YYSTYPE *) malloc(size * sizeof(YYSTYPE));
639
    if (p->yystack.l_base == NULL) return NULL;
640
    memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE));
641
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
642
    p->yystack.p_base    = (YYLTYPE *) malloc(size * sizeof(YYLTYPE));
643
    if (p->yystack.p_base == NULL) return NULL;
644
    memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE));
645
#endif
646

647
    return p;
648
}
649

650
static void
651
yyFreeState(YYParseState *p)
652
{
653
    yyfreestack(&p->yystack);
654
    free(p);
655
}
656
#endif /* YYBTYACC */
657

658
#define YYABORT  goto yyabort
659
#define YYREJECT goto yyabort
660
#define YYACCEPT goto yyaccept
661
#define YYERROR  goto yyerrlab
662
#if YYBTYACC
663
#define YYVALID        do { if (yyps->save)            goto yyvalid; } while(0)
664
#define YYVALID_NESTED do { if (yyps->save && \
665
                                yyps->save->save == 0) goto yyvalid; } while(0)
666
#endif /* YYBTYACC */
667

668
int
669
YYPARSE_DECL()
670
{
671
    int yym, yyn, yystate, yyresult;
672
#if YYBTYACC
673
    int yynewerrflag;
674
    YYParseState *yyerrctx = NULL;
675
#endif /* YYBTYACC */
676
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
677
    YYLTYPE  yyerror_loc_range[3]; /* position of error start/end (0 unused) */
678
#endif
679
#if YYDEBUG
680
    const char *yys;
681

682
    if ((yys = getenv("YYDEBUG")) != NULL)
683
    {
684
        yyn = *yys;
685
        if (yyn >= '0' && yyn <= '9')
686
            yydebug = yyn - '0';
687
    }
688
    if (yydebug)
689
        fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX);
690
#endif
691
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
692
    memset(yyerror_loc_range, 0, sizeof(yyerror_loc_range));
693
#endif
694

695
#if YYBTYACC
696
    yyps = yyNewState(0); if (yyps == 0) goto yyenomem;
697
    yyps->save = 0;
698
#endif /* YYBTYACC */
699
    yym = 0;
700
    /* yyn is set below */
701
    yynerrs = 0;
702
    yyerrflag = 0;
703
    yychar = YYEMPTY;
704
    yystate = 0;
705

706
#if YYPURE
707
    memset(&yystack, 0, sizeof(yystack));
708
#endif
709

710
    if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
711
    yystack.s_mark = yystack.s_base;
712
    yystack.l_mark = yystack.l_base;
713
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
714
    yystack.p_mark = yystack.p_base;
715
#endif
716
    yystate = 0;
717
    *yystack.s_mark = 0;
718

719
yyloop:
720
    if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
721
    if (yychar < 0)
722
    {
723
#if YYBTYACC
724
        do {
725
        if (yylvp < yylve)
726
        {
727
            /* we're currently re-reading tokens */
728
            yylval = *yylvp++;
729
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
730
            yylloc = *yylpp++;
731
#endif
732
            yychar = *yylexp++;
733
            break;
734
        }
735
        if (yyps->save)
736
        {
737
            /* in trial mode; save scanner results for future parse attempts */
738
            if (yylvp == yylvlim)
739
            {   /* Enlarge lexical value queue */
740
                size_t p = (size_t) (yylvp - yylvals);
741
                size_t s = (size_t) (yylvlim - yylvals);
742

743
                s += YYLVQUEUEGROWTH;
744
                if ((yylexemes = (YYINT *)realloc(yylexemes, s * sizeof(YYINT))) == NULL) goto yyenomem;
745
                if ((yylvals   = (YYSTYPE *)realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem;
746
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
747
                if ((yylpsns   = (YYLTYPE *)realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem;
748
#endif
749
                yylvp   = yylve = yylvals + p;
750
                yylvlim = yylvals + s;
751
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
752
                yylpp   = yylpe = yylpsns + p;
753
                yylplim = yylpsns + s;
754
#endif
755
                yylexp  = yylexemes + p;
756
            }
757
            *yylexp = (YYINT) YYLEX;
758
            *yylvp++ = yylval;
759
            yylve++;
760
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
761
            *yylpp++ = yylloc;
762
            yylpe++;
763
#endif
764
            yychar = *yylexp++;
765
            break;
766
        }
767
        /* normal operation, no conflict encountered */
768
#endif /* YYBTYACC */
769
        yychar = YYLEX;
770
#if YYBTYACC
771
        } while (0);
772
#endif /* YYBTYACC */
773
        if (yychar < 0) yychar = YYEOF;
774
#if YYDEBUG
775
        if (yydebug)
776
        {
777
            if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
778
            fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)",
779
                            YYDEBUGSTR, yydepth, yystate, yychar, yys);
780
#ifdef YYSTYPE_TOSTRING
781
#if YYBTYACC
782
            if (!yytrial)
783
#endif /* YYBTYACC */
784
                fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval));
785
#endif
786
            fputc('\n', stderr);
787
        }
788
#endif
789
    }
790
#if YYBTYACC
791

792
    /* Do we have a conflict? */
793
    if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
794
        yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
795
    {
796
        YYINT ctry;
797

798
        if (yypath)
799
        {
800
            YYParseState *save;
801
#if YYDEBUG
802
            if (yydebug)
803
                fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n",
804
                                YYDEBUGSTR, yydepth, yystate);
805
#endif
806
            /* Switch to the next conflict context */
807
            save = yypath;
808
            yypath = save->save;
809
            save->save = NULL;
810
            ctry = save->ctry;
811
            if (save->state != yystate) YYABORT;
812
            yyFreeState(save);
813

814
        }
815
        else
816
        {
817

818
            /* Unresolved conflict - start/continue trial parse */
819
            YYParseState *save;
820
#if YYDEBUG
821
            if (yydebug)
822
            {
823
                fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate);
824
                if (yyps->save)
825
                    fputs("ALREADY in conflict, continuing trial parse.\n", stderr);
826
                else
827
                    fputs("Starting trial parse.\n", stderr);
828
            }
829
#endif
830
            save                  = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
831
            if (save == NULL) goto yyenomem;
832
            save->save            = yyps->save;
833
            save->state           = yystate;
834
            save->errflag         = yyerrflag;
835
            save->yystack.s_mark  = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
836
            memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
837
            save->yystack.l_mark  = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
838
            memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
839
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
840
            save->yystack.p_mark  = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
841
            memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
842
#endif
843
            ctry                  = yytable[yyn];
844
            if (yyctable[ctry] == -1)
845
            {
846
#if YYDEBUG
847
                if (yydebug && yychar >= YYEOF)
848
                    fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth);
849
#endif
850
                ctry++;
851
            }
852
            save->ctry = ctry;
853
            if (yyps->save == NULL)
854
            {
855
                /* If this is a first conflict in the stack, start saving lexemes */
856
                if (!yylexemes)
857
                {
858
                    yylexemes = (YYINT *) malloc((YYLVQUEUEGROWTH) * sizeof(YYINT));
859
                    if (yylexemes == NULL) goto yyenomem;
860
                    yylvals   = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE));
861
                    if (yylvals == NULL) goto yyenomem;
862
                    yylvlim   = yylvals + YYLVQUEUEGROWTH;
863
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
864
                    yylpsns   = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE));
865
                    if (yylpsns == NULL) goto yyenomem;
866
                    yylplim   = yylpsns + YYLVQUEUEGROWTH;
867
#endif
868
                }
869
                if (yylvp == yylve)
870
                {
871
                    yylvp  = yylve = yylvals;
872
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
873
                    yylpp  = yylpe = yylpsns;
874
#endif
875
                    yylexp = yylexemes;
876
                    if (yychar >= YYEOF)
877
                    {
878
                        *yylve++ = yylval;
879
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
880
                        *yylpe++ = yylloc;
881
#endif
882
                        *yylexp  = (YYINT) yychar;
883
                        yychar   = YYEMPTY;
884
                    }
885
                }
886
            }
887
            if (yychar >= YYEOF)
888
            {
889
                yylvp--;
890
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
891
                yylpp--;
892
#endif
893
                yylexp--;
894
                yychar = YYEMPTY;
895
            }
896
            save->lexeme = (int) (yylvp - yylvals);
897
            yyps->save   = save;
898
        }
899
        if (yytable[yyn] == ctry)
900
        {
901
#if YYDEBUG
902
            if (yydebug)
903
                fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
904
                                YYDEBUGSTR, yydepth, yystate, yyctable[ctry]);
905
#endif
906
            if (yychar < 0)
907
            {
908
                yylvp++;
909
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
910
                yylpp++;
911
#endif
912
                yylexp++;
913
            }
914
            if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
915
                goto yyoverflow;
916
            yystate = yyctable[ctry];
917
            *++yystack.s_mark = (YYINT) yystate;
918
            *++yystack.l_mark = yylval;
919
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
920
            *++yystack.p_mark = yylloc;
921
#endif
922
            yychar  = YYEMPTY;
923
            if (yyerrflag > 0) --yyerrflag;
924
            goto yyloop;
925
        }
926
        else
927
        {
928
            yyn = yyctable[ctry];
929
            goto yyreduce;
930
        }
931
    } /* End of code dealing with conflicts */
932
#endif /* YYBTYACC */
933
    if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
934
            yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
935
    {
936
#if YYDEBUG
937
        if (yydebug)
938
            fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
939
                            YYDEBUGSTR, yydepth, yystate, yytable[yyn]);
940
#endif
941
        if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
942
        yystate = yytable[yyn];
943
        *++yystack.s_mark = yytable[yyn];
944
        *++yystack.l_mark = yylval;
945
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
946
        *++yystack.p_mark = yylloc;
947
#endif
948
        yychar = YYEMPTY;
949
        if (yyerrflag > 0)  --yyerrflag;
950
        goto yyloop;
951
    }
952
    if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
953
            yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
954
    {
955
        yyn = yytable[yyn];
956
        goto yyreduce;
957
    }
958
    if (yyerrflag != 0) goto yyinrecovery;
959
#if YYBTYACC
960

961
    yynewerrflag = 1;
962
    goto yyerrhandler;
963
    goto yyerrlab; /* redundant goto avoids 'unused label' warning */
964

965
yyerrlab:
966
    /* explicit YYERROR from an action -- pop the rhs of the rule reduced
967
     * before looking for error recovery */
968
    yystack.s_mark -= yym;
969
    yystate = *yystack.s_mark;
970
    yystack.l_mark -= yym;
971
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
972
    yystack.p_mark -= yym;
973
#endif
974

975
    yynewerrflag = 0;
976
yyerrhandler:
977
    while (yyps->save)
978
    {
979
        int ctry;
980
        YYParseState *save = yyps->save;
981
#if YYDEBUG
982
        if (yydebug)
983
            fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n",
984
                            YYDEBUGSTR, yydepth, yystate, yyps->save->state,
985
                    (int)(yylvp - yylvals - yyps->save->lexeme));
986
#endif
987
        /* Memorize most forward-looking error state in case it's really an error. */
988
        if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals)
989
        {
990
            /* Free old saved error context state */
991
            if (yyerrctx) yyFreeState(yyerrctx);
992
            /* Create and fill out new saved error context state */
993
            yyerrctx                 = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
994
            if (yyerrctx == NULL) goto yyenomem;
995
            yyerrctx->save           = yyps->save;
996
            yyerrctx->state          = yystate;
997
            yyerrctx->errflag        = yyerrflag;
998
            yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
999
            memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1000
            yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
1001
            memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1002
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1003
            yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
1004
            memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1005
#endif
1006
            yyerrctx->lexeme         = (int) (yylvp - yylvals);
1007
        }
1008
        yylvp          = yylvals   + save->lexeme;
1009
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1010
        yylpp          = yylpsns   + save->lexeme;
1011
#endif
1012
        yylexp         = yylexemes + save->lexeme;
1013
        yychar         = YYEMPTY;
1014
        yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
1015
        memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1016
        yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
1017
        memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1018
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1019
        yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
1020
        memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1021
#endif
1022
        ctry           = ++save->ctry;
1023
        yystate        = save->state;
1024
        /* We tried shift, try reduce now */
1025
        if ((yyn = yyctable[ctry]) >= 0) goto yyreduce;
1026
        yyps->save     = save->save;
1027
        save->save     = NULL;
1028
        yyFreeState(save);
1029

1030
        /* Nothing left on the stack -- error */
1031
        if (!yyps->save)
1032
        {
1033
#if YYDEBUG
1034
            if (yydebug)
1035
                fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n",
1036
                                YYPREFIX, yydepth);
1037
#endif
1038
            /* Restore state as it was in the most forward-advanced error */
1039
            yylvp          = yylvals   + yyerrctx->lexeme;
1040
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1041
            yylpp          = yylpsns   + yyerrctx->lexeme;
1042
#endif
1043
            yylexp         = yylexemes + yyerrctx->lexeme;
1044
            yychar         = yylexp[-1];
1045
            yylval         = yylvp[-1];
1046
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1047
            yylloc         = yylpp[-1];
1048
#endif
1049
            yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
1050
            memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1051
            yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
1052
            memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1053
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1054
            yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
1055
            memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1056
#endif
1057
            yystate        = yyerrctx->state;
1058
            yyFreeState(yyerrctx);
1059
            yyerrctx       = NULL;
1060
        }
1061
        yynewerrflag = 1;
1062
    }
1063
    if (yynewerrflag == 0) goto yyinrecovery;
1064
#endif /* YYBTYACC */
1065

1066
    YYERROR_CALL("syntax error");
1067
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1068
    yyerror_loc_range[1] = yylloc; /* lookahead position is error start position */
1069
#endif
1070

1071
#if !YYBTYACC
1072
    goto yyerrlab; /* redundant goto avoids 'unused label' warning */
1073
yyerrlab:
1074
#endif
1075
    ++yynerrs;
1076

1077
yyinrecovery:
1078
    if (yyerrflag < 3)
1079
    {
1080
        yyerrflag = 3;
1081
        for (;;)
1082
        {
1083
            if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&
1084
                    yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)
1085
            {
1086
#if YYDEBUG
1087
                if (yydebug)
1088
                    fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n",
1089
                                    YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]);
1090
#endif
1091
                if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1092
                yystate = yytable[yyn];
1093
                *++yystack.s_mark = yytable[yyn];
1094
                *++yystack.l_mark = yylval;
1095
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1096
                /* lookahead position is error end position */
1097
                yyerror_loc_range[2] = yylloc;
1098
                YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */
1099
                *++yystack.p_mark = yyloc;
1100
#endif
1101
                goto yyloop;
1102
            }
1103
            else
1104
            {
1105
#if YYDEBUG
1106
                if (yydebug)
1107
                    fprintf(stderr, "%s[%d]: error recovery discarding state %d\n",
1108
                                    YYDEBUGSTR, yydepth, *yystack.s_mark);
1109
#endif
1110
                if (yystack.s_mark <= yystack.s_base) goto yyabort;
1111
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1112
                /* the current TOS position is the error start position */
1113
                yyerror_loc_range[1] = *yystack.p_mark;
1114
#endif
1115
#if defined(YYDESTRUCT_CALL)
1116
#if YYBTYACC
1117
                if (!yytrial)
1118
#endif /* YYBTYACC */
1119
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1120
                    YYDESTRUCT_CALL("error: discarding state",
1121
                                    yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark);
1122
#else
1123
                    YYDESTRUCT_CALL("error: discarding state",
1124
                                    yystos[*yystack.s_mark], yystack.l_mark);
1125
#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1126
#endif /* defined(YYDESTRUCT_CALL) */
1127
                --yystack.s_mark;
1128
                --yystack.l_mark;
1129
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1130
                --yystack.p_mark;
1131
#endif
1132
            }
1133
        }
1134
    }
1135
    else
1136
    {
1137
        if (yychar == YYEOF) goto yyabort;
1138
#if YYDEBUG
1139
        if (yydebug)
1140
        {
1141
            if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
1142
            fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n",
1143
                            YYDEBUGSTR, yydepth, yystate, yychar, yys);
1144
        }
1145
#endif
1146
#if defined(YYDESTRUCT_CALL)
1147
#if YYBTYACC
1148
        if (!yytrial)
1149
#endif /* YYBTYACC */
1150
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1151
            YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc);
1152
#else
1153
            YYDESTRUCT_CALL("error: discarding token", yychar, &yylval);
1154
#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1155
#endif /* defined(YYDESTRUCT_CALL) */
1156
        yychar = YYEMPTY;
1157
        goto yyloop;
1158
    }
1159

1160
yyreduce:
1161
    yym = yylen[yyn];
1162
#if YYDEBUG
1163
    if (yydebug)
1164
    {
1165
        fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)",
1166
                        YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]);
1167
#ifdef YYSTYPE_TOSTRING
1168
#if YYBTYACC
1169
        if (!yytrial)
1170
#endif /* YYBTYACC */
1171
            if (yym > 0)
1172
            {
1173
                int i;
1174
                fputc('<', stderr);
1175
                for (i = yym; i > 0; i--)
1176
                {
1177
                    if (i != yym) fputs(", ", stderr);
1178
                    fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]],
1179
                                           yystack.l_mark[1-i]), stderr);
1180
                }
1181
                fputc('>', stderr);
1182
            }
1183
#endif
1184
        fputc('\n', stderr);
1185
    }
1186
#endif
1187
    if (yym > 0)
1188
        yyval = yystack.l_mark[1-yym];
1189
    else
1190
        memset(&yyval, 0, sizeof yyval);
1191
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1192

1193
    /* Perform position reduction */
1194
    memset(&yyloc, 0, sizeof(yyloc));
1195
#if YYBTYACC
1196
    if (!yytrial)
1197
#endif /* YYBTYACC */
1198
    {
1199
        YYLLOC_DEFAULT(yyloc, &yystack.p_mark[-yym], yym);
1200
        /* just in case YYERROR is invoked within the action, save
1201
           the start of the rhs as the error start position */
1202
        yyerror_loc_range[1] = yystack.p_mark[1-yym];
1203
    }
1204
#endif
1205

1206
    switch (yyn)
1207
    {
1208
case 3:
1209
#line 35 "calc_code_all.y"
1210
	{  yyerrok ; }
1211
#line 1212 "calc_code_all.tab.c"
1212
break;
1213
case 4:
1214
#line 39 "calc_code_all.y"
1215
	{  printf("%d\n",yystack.l_mark[0]);}
1216
#line 1217 "calc_code_all.tab.c"
1217
break;
1218
case 5:
1219
#line 41 "calc_code_all.y"
1220
	{  regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
1221
#line 1222 "calc_code_all.tab.c"
1222
break;
1223
case 6:
1224
#line 45 "calc_code_all.y"
1225
	{  yyval = yystack.l_mark[-1]; }
1226
#line 1227 "calc_code_all.tab.c"
1227
break;
1228
case 7:
1229
#line 47 "calc_code_all.y"
1230
	{  yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
1231
#line 1232 "calc_code_all.tab.c"
1232
break;
1233
case 8:
1234
#line 49 "calc_code_all.y"
1235
	{  yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
1236
#line 1237 "calc_code_all.tab.c"
1237
break;
1238
case 9:
1239
#line 51 "calc_code_all.y"
1240
	{  yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
1241
#line 1242 "calc_code_all.tab.c"
1242
break;
1243
case 10:
1244
#line 53 "calc_code_all.y"
1245
	{  yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
1246
#line 1247 "calc_code_all.tab.c"
1247
break;
1248
case 11:
1249
#line 55 "calc_code_all.y"
1250
	{  yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
1251
#line 1252 "calc_code_all.tab.c"
1252
break;
1253
case 12:
1254
#line 57 "calc_code_all.y"
1255
	{  yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
1256
#line 1257 "calc_code_all.tab.c"
1257
break;
1258
case 13:
1259
#line 59 "calc_code_all.y"
1260
	{  yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
1261
#line 1262 "calc_code_all.tab.c"
1262
break;
1263
case 14:
1264
#line 61 "calc_code_all.y"
1265
	{  yyval = - yystack.l_mark[0]; }
1266
#line 1267 "calc_code_all.tab.c"
1267
break;
1268
case 15:
1269
#line 63 "calc_code_all.y"
1270
	{  yyval = regs[yystack.l_mark[0]]; }
1271
#line 1272 "calc_code_all.tab.c"
1272
break;
1273
case 17:
1274
#line 68 "calc_code_all.y"
1275
	{  yyval = yystack.l_mark[0]; base = (yystack.l_mark[0]==0) ? 8 : 10; }
1276
#line 1277 "calc_code_all.tab.c"
1277
break;
1278
case 18:
1279
#line 70 "calc_code_all.y"
1280
	{  yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
1281
#line 1282 "calc_code_all.tab.c"
1282
break;
1283
#line 1284 "calc_code_all.tab.c"
1284
    default:
1285
        break;
1286
    }
1287
    yystack.s_mark -= yym;
1288
    yystate = *yystack.s_mark;
1289
    yystack.l_mark -= yym;
1290
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1291
    yystack.p_mark -= yym;
1292
#endif
1293
    yym = yylhs[yyn];
1294
    if (yystate == 0 && yym == 0)
1295
    {
1296
#if YYDEBUG
1297
        if (yydebug)
1298
        {
1299
            fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1300
#ifdef YYSTYPE_TOSTRING
1301
#if YYBTYACC
1302
            if (!yytrial)
1303
#endif /* YYBTYACC */
1304
                fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval));
1305
#endif
1306
            fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL);
1307
        }
1308
#endif
1309
        yystate = YYFINAL;
1310
        *++yystack.s_mark = YYFINAL;
1311
        *++yystack.l_mark = yyval;
1312
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1313
        *++yystack.p_mark = yyloc;
1314
#endif
1315
        if (yychar < 0)
1316
        {
1317
#if YYBTYACC
1318
            do {
1319
            if (yylvp < yylve)
1320
            {
1321
                /* we're currently re-reading tokens */
1322
                yylval = *yylvp++;
1323
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1324
                yylloc = *yylpp++;
1325
#endif
1326
                yychar = *yylexp++;
1327
                break;
1328
            }
1329
            if (yyps->save)
1330
            {
1331
                /* in trial mode; save scanner results for future parse attempts */
1332
                if (yylvp == yylvlim)
1333
                {   /* Enlarge lexical value queue */
1334
                    size_t p = (size_t) (yylvp - yylvals);
1335
                    size_t s = (size_t) (yylvlim - yylvals);
1336

1337
                    s += YYLVQUEUEGROWTH;
1338
                    if ((yylexemes = (YYINT *)realloc(yylexemes, s * sizeof(YYINT))) == NULL)
1339
                        goto yyenomem;
1340
                    if ((yylvals   = (YYSTYPE *)realloc(yylvals, s * sizeof(YYSTYPE))) == NULL)
1341
                        goto yyenomem;
1342
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1343
                    if ((yylpsns   = (YYLTYPE *)realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL)
1344
                        goto yyenomem;
1345
#endif
1346
                    yylvp   = yylve = yylvals + p;
1347
                    yylvlim = yylvals + s;
1348
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1349
                    yylpp   = yylpe = yylpsns + p;
1350
                    yylplim = yylpsns + s;
1351
#endif
1352
                    yylexp  = yylexemes + p;
1353
                }
1354
                *yylexp = (YYINT) YYLEX;
1355
                *yylvp++ = yylval;
1356
                yylve++;
1357
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1358
                *yylpp++ = yylloc;
1359
                yylpe++;
1360
#endif
1361
                yychar = *yylexp++;
1362
                break;
1363
            }
1364
            /* normal operation, no conflict encountered */
1365
#endif /* YYBTYACC */
1366
            yychar = YYLEX;
1367
#if YYBTYACC
1368
            } while (0);
1369
#endif /* YYBTYACC */
1370
            if (yychar < 0) yychar = YYEOF;
1371
#if YYDEBUG
1372
            if (yydebug)
1373
            {
1374
                if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
1375
                fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)\n",
1376
                                YYDEBUGSTR, yydepth, YYFINAL, yychar, yys);
1377
            }
1378
#endif
1379
        }
1380
        if (yychar == YYEOF) goto yyaccept;
1381
        goto yyloop;
1382
    }
1383
    if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
1384
            yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
1385
        yystate = yytable[yyn];
1386
    else
1387
        yystate = yydgoto[yym];
1388
#if YYDEBUG
1389
    if (yydebug)
1390
    {
1391
        fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1392
#ifdef YYSTYPE_TOSTRING
1393
#if YYBTYACC
1394
        if (!yytrial)
1395
#endif /* YYBTYACC */
1396
            fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval));
1397
#endif
1398
        fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate);
1399
    }
1400
#endif
1401
    if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1402
    *++yystack.s_mark = (YYINT) yystate;
1403
    *++yystack.l_mark = yyval;
1404
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1405
    *++yystack.p_mark = yyloc;
1406
#endif
1407
    goto yyloop;
1408
#if YYBTYACC
1409

1410
    /* Reduction declares that this path is valid. Set yypath and do a full parse */
1411
yyvalid:
1412
    if (yypath) YYABORT;
1413
    while (yyps->save)
1414
    {
1415
        YYParseState *save = yyps->save;
1416
        yyps->save = save->save;
1417
        save->save = yypath;
1418
        yypath = save;
1419
    }
1420
#if YYDEBUG
1421
    if (yydebug)
1422
        fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n",
1423
                        YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme));
1424
#endif
1425
    if (yyerrctx)
1426
    {
1427
        yyFreeState(yyerrctx);
1428
        yyerrctx = NULL;
1429
    }
1430
    yylvp          = yylvals + yypath->lexeme;
1431
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1432
    yylpp          = yylpsns + yypath->lexeme;
1433
#endif
1434
    yylexp         = yylexemes + yypath->lexeme;
1435
    yychar         = YYEMPTY;
1436
    yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
1437
    memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1438
    yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
1439
    memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1440
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1441
    yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
1442
    memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1443
#endif
1444
    yystate        = yypath->state;
1445
    goto yyloop;
1446
#endif /* YYBTYACC */
1447

1448
yyoverflow:
1449
    YYERROR_CALL("yacc stack overflow");
1450
#if YYBTYACC
1451
    goto yyabort_nomem;
1452
yyenomem:
1453
    YYERROR_CALL("memory exhausted");
1454
yyabort_nomem:
1455
#endif /* YYBTYACC */
1456
    yyresult = 2;
1457
    goto yyreturn;
1458

1459
yyabort:
1460
    yyresult = 1;
1461
    goto yyreturn;
1462

1463
yyaccept:
1464
#if YYBTYACC
1465
    if (yyps->save) goto yyvalid;
1466
#endif /* YYBTYACC */
1467
    yyresult = 0;
1468

1469
yyreturn:
1470
#if defined(YYDESTRUCT_CALL)
1471
    if (yychar != YYEOF && yychar != YYEMPTY)
1472
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1473
        YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc);
1474
#else
1475
        YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval);
1476
#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1477

1478
    {
1479
        YYSTYPE *pv;
1480
#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1481
        YYLTYPE *pp;
1482

1483
        for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp)
1484
             YYDESTRUCT_CALL("cleanup: discarding state",
1485
                             yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp);
1486
#else
1487
        for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv)
1488
             YYDESTRUCT_CALL("cleanup: discarding state",
1489
                             yystos[*(yystack.s_base + (pv - yystack.l_base))], pv);
1490
#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1491
    }
1492
#endif /* defined(YYDESTRUCT_CALL) */
1493

1494
#if YYBTYACC
1495
    if (yyerrctx)
1496
    {
1497
        yyFreeState(yyerrctx);
1498
        yyerrctx = NULL;
1499
    }
1500
    while (yyps)
1501
    {
1502
        YYParseState *save = yyps;
1503
        yyps = save->save;
1504
        save->save = NULL;
1505
        yyFreeState(save);
1506
    }
1507
    while (yypath)
1508
    {
1509
        YYParseState *save = yypath;
1510
        yypath = save->save;
1511
        save->save = NULL;
1512
        yyFreeState(save);
1513
    }
1514
#endif /* YYBTYACC */
1515
    yyfreestack(&yystack);
1516
    return (yyresult);
1517
}
1518

1519
Product

Resources

Company
