Branch data Line data Source code
1 : : #ifndef lint
2 : : static const char yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93";
3 : : #endif
4 : :
5 : : #define YYBYACC 1
6 : : #define YYMAJOR 1
7 : : #define YYMINOR 9
8 : : #define YYPATCH 20101229
9 : :
10 : : #define YYEMPTY (-1)
11 : : #define yyclearin (yychar = YYEMPTY)
12 : : #define yyerrok (yyerrflag = 0)
13 : : #define YYRECOVERING() (yyerrflag != 0)
14 : :
15 : : #define YYPREFIX "yy"
16 : :
17 : : #define YYPURE 0
18 : :
19 : : /*
20 : : * Copyright (c) 1998 - 2000 Kungliga Tekniska Högskolan
21 : : * (Royal Institute of Technology, Stockholm, Sweden).
22 : : * All rights reserved.
23 : : *
24 : : * Redistribution and use in source and binary forms, with or without
25 : : * modification, are permitted provided that the following conditions
26 : : * are met:
27 : : *
28 : : * 1. Redistributions of source code must retain the above copyright
29 : : * notice, this list of conditions and the following disclaimer.
30 : : *
31 : : * 2. Redistributions in binary form must reproduce the above copyright
32 : : * notice, this list of conditions and the following disclaimer in the
33 : : * documentation and/or other materials provided with the distribution.
34 : : *
35 : : * 3. Neither the name of the Institute nor the names of its contributors
36 : : * may be used to endorse or promote products derived from this software
37 : : * without specific prior written permission.
38 : : *
39 : : * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
40 : : * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
41 : : * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
42 : : * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
43 : : * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
44 : : * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
45 : : * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
46 : : * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
47 : : * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
48 : : * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
49 : : * SUCH DAMAGE.
50 : : */
51 : :
52 : : #include "compile_et.h"
53 : : #include "lex.h"
54 : :
55 : : void yyerror (char *s);
56 : : static long name2number(const char *str);
57 : :
58 : : extern char *yytext;
59 : :
60 : : /* This is for bison */
61 : :
62 : : #if !defined(alloca) && !defined(HAVE_ALLOCA)
63 : : #define alloca(x) malloc(x)
64 : : #endif
65 : :
66 : : #define YYMALLOC malloc
67 : : #define YYFREE free
68 : :
69 : : #ifdef YYSTYPE
70 : : #undef YYSTYPE_IS_DECLARED
71 : : #define YYSTYPE_IS_DECLARED 1
72 : : #endif
73 : : #ifndef YYSTYPE_IS_DECLARED
74 : : #define YYSTYPE_IS_DECLARED 1
75 : : typedef union {
76 : : char *string;
77 : : int number;
78 : : } YYSTYPE;
79 : : #endif /* !YYSTYPE_IS_DECLARED */
80 : : /* compatibility with bison */
81 : : #ifdef YYPARSE_PARAM
82 : : /* compatibility with FreeBSD */
83 : : # ifdef YYPARSE_PARAM_TYPE
84 : : # define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
85 : : # else
86 : : # define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
87 : : # endif
88 : : #else
89 : : # define YYPARSE_DECL() yyparse(void)
90 : : #endif
91 : :
92 : : /* Parameters sent to lex. */
93 : : #ifdef YYLEX_PARAM
94 : : # define YYLEX_DECL() yylex(void *YYLEX_PARAM)
95 : : # define YYLEX yylex(YYLEX_PARAM)
96 : : #else
97 : : # define YYLEX_DECL() yylex(void)
98 : : # define YYLEX yylex()
99 : : #endif
100 : :
101 : : /* Parameters sent to yyerror. */
102 : : #define YYERROR_DECL() yyerror(const char *s)
103 : : #define YYERROR_CALL(msg) yyerror(msg)
104 : :
105 : : extern int YYPARSE_DECL();
106 : :
107 : : #define ET 257
108 : : #define INDEX 258
109 : : #define PREFIX 259
110 : : #define EC 260
111 : : #define ID 261
112 : : #define END 262
113 : : #define STRING 263
114 : : #define NUMBER 264
115 : : #define YYERRCODE 256
116 : : static const short yylhs[] = { -1,
117 : : 0, 0, 1, 1, 3, 4, 4, 2, 2, 5,
118 : : 5, 5, 5, 5,
119 : : };
120 : : static const short yylen[] = { 2,
121 : : 0, 2, 2, 1, 2, 2, 3, 1, 2, 2,
122 : : 2, 1, 4, 1,
123 : : };
124 : : static const short yydefred[] = { 0,
125 : : 0, 0, 0, 0, 0, 4, 0, 5, 0, 0,
126 : : 0, 14, 0, 8, 3, 7, 10, 11, 0, 9,
127 : : 0, 13,
128 : : };
129 : : static const short yydgoto[] = { 3,
130 : : 4, 13, 5, 6, 14,
131 : : };
132 : : static const short yysindex[] = { -247,
133 : : -263, -258, 0, -256, -245, 0, -250, 0, -249, -246,
134 : : -244, 0, -256, 0, 0, 0, 0, 0, -28, 0,
135 : : -243, 0,
136 : : };
137 : : static const short yyrindex[] = { 18,
138 : : 0, 0, 0, 0, 0, 0, -251, 0, 0, 1,
139 : : 0, 0, 21, 0, 0, 0, 0, 0, 0, 0,
140 : : 0, 0,
141 : : };
142 : : static const short yygindex[] = { 0,
143 : : 0, 0, 0, 17, 10,
144 : : };
145 : : #define YYTABLESIZE 263
146 : : static const short yytable[] = { 7,
147 : : 12, 9, 10, 11, 8, 12, 6, 6, 6, 1,
148 : : 6, 1, 16, 2, 17, 21, 18, 1, 19, 22,
149 : : 2, 15, 20, 0, 0, 0, 0, 0, 0, 0,
150 : : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
151 : : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
152 : : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
153 : : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
154 : : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
155 : : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
156 : : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
157 : : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
158 : : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
159 : : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
160 : : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
161 : : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
162 : : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
163 : : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
164 : : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
165 : : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
166 : : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
167 : : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
168 : : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
169 : : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
170 : : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
171 : : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
172 : : 0, 0, 0, 0, 0, 0, 0, 0, 12, 12,
173 : : 12, 0, 12,
174 : : };
175 : : static const short yycheck[] = { 263,
176 : : 0, 258, 259, 260, 263, 262, 258, 259, 260, 257,
177 : : 262, 257, 263, 261, 264, 44, 263, 0, 263, 263,
178 : : 0, 5, 13, -1, -1, -1, -1, -1, -1, -1,
179 : : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
180 : : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
181 : : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
182 : : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
183 : : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
184 : : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
185 : : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
186 : : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
187 : : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
188 : : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
189 : : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
190 : : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
191 : : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
192 : : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
193 : : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
194 : : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
195 : : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
196 : : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
197 : : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
198 : : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
199 : : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
200 : : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
201 : : -1, -1, -1, -1, -1, -1, -1, -1, 258, 259,
202 : : 260, -1, 262,
203 : : };
204 : : #define YYFINAL 3
205 : : #ifndef YYDEBUG
206 : : #define YYDEBUG 0
207 : : #endif
208 : : #define YYMAXTOKEN 264
209 : : #if YYDEBUG
210 : : static const char *yyname[] = {
211 : :
212 : : "end-of-file",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,
213 : : 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,
214 : : 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,
215 : : 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,
216 : : 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,
217 : : 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,
218 : : 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,"ET","INDEX","PREFIX","EC",
219 : : "ID","END","STRING","NUMBER",
220 : : };
221 : : static const char *yyrule[] = {
222 : : "$accept : file",
223 : : "file :",
224 : : "file : header statements",
225 : : "header : id et",
226 : : "header : et",
227 : : "id : ID STRING",
228 : : "et : ET STRING",
229 : : "et : ET STRING STRING",
230 : : "statements : statement",
231 : : "statements : statements statement",
232 : : "statement : INDEX NUMBER",
233 : : "statement : PREFIX STRING",
234 : : "statement : PREFIX",
235 : : "statement : EC STRING ',' STRING",
236 : : "statement : END",
237 : :
238 : : };
239 : : #endif
240 : : /* define the initial stack-sizes */
241 : : #ifdef YYSTACKSIZE
242 : : #undef YYMAXDEPTH
243 : : #define YYMAXDEPTH YYSTACKSIZE
244 : : #else
245 : : #ifdef YYMAXDEPTH
246 : : #define YYSTACKSIZE YYMAXDEPTH
247 : : #else
248 : : #define YYSTACKSIZE 500
249 : : #define YYMAXDEPTH 500
250 : : #endif
251 : : #endif
252 : :
253 : : #define YYINITSTACKSIZE 500
254 : :
255 : : int yydebug;
256 : : int yynerrs;
257 : :
258 : : typedef struct {
259 : : unsigned stacksize;
260 : : short *s_base;
261 : : short *s_mark;
262 : : short *s_last;
263 : : YYSTYPE *l_base;
264 : : YYSTYPE *l_mark;
265 : : } YYSTACKDATA;
266 : : int yyerrflag;
267 : : int yychar;
268 : : YYSTYPE yyval;
269 : : YYSTYPE yylval;
270 : :
271 : : /* variables for the parser stack */
272 : : static YYSTACKDATA yystack;
273 : :
274 : : static long
275 : 10 : name2number(const char *str)
276 : : {
277 : : const char *p;
278 : 10 : long num = 0;
279 : : const char *x = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
280 : 10 : "abcdefghijklmnopqrstuvwxyz0123456789_";
281 [ - + ]: 10 : if(strlen(str) > 4) {
282 : 0 : yyerror("table name too long");
283 : 0 : return 0;
284 : : }
285 [ + + ]: 45 : for(p = str; *p; p++){
286 : 35 : char *q = strchr(x, *p);
287 [ - + ]: 35 : if(q == NULL) {
288 : 0 : yyerror("invalid character in table name");
289 : 0 : return 0;
290 : : }
291 : 35 : num = (num << 6) + (q - x) + 1;
292 : : }
293 : 10 : num <<= 8;
294 [ + + ]: 10 : if(num > 0x7fffffff)
295 : 5 : num = -(0xffffffff - num + 1);
296 : 10 : return num;
297 : : }
298 : :
299 : : void
300 : 0 : yyerror (char *s)
301 : : {
302 : 0 : _lex_error_message ("%s\n", s);
303 : 0 : }
304 : :
305 : : #if YYDEBUG
306 : : #include <stdio.h> /* needed for printf */
307 : : #endif
308 : :
309 : : #include <stdlib.h> /* needed for malloc, etc */
310 : : #include <string.h> /* needed for memset */
311 : :
312 : : /* allocate initial stack or double stack size, up to YYMAXDEPTH */
313 : 10 : static int yygrowstack(YYSTACKDATA *data)
314 : : {
315 : : int i;
316 : : unsigned newsize;
317 : : short *newss;
318 : : YYSTYPE *newvs;
319 : :
320 [ + - ]: 10 : if ((newsize = data->stacksize) == 0)
321 : 10 : newsize = YYINITSTACKSIZE;
322 [ # # ]: 0 : else if (newsize >= YYMAXDEPTH)
323 : 0 : return -1;
324 [ # # ]: 0 : else if ((newsize *= 2) > YYMAXDEPTH)
325 : 0 : newsize = YYMAXDEPTH;
326 : :
327 : 10 : i = data->s_mark - data->s_base;
328 : 10 : newss = (short *)realloc(data->s_base, newsize * sizeof(*newss));
329 [ - + ]: 10 : if (newss == 0)
330 : 0 : return -1;
331 : :
332 : 10 : data->s_base = newss;
333 : 10 : data->s_mark = newss + i;
334 : :
335 : 10 : newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
336 [ - + ]: 10 : if (newvs == 0)
337 : 0 : return -1;
338 : :
339 : 10 : data->l_base = newvs;
340 : 10 : data->l_mark = newvs + i;
341 : :
342 : 10 : data->stacksize = newsize;
343 : 10 : data->s_last = data->s_base + newsize - 1;
344 : 10 : return 0;
345 : : }
346 : :
347 : : #if YYPURE || defined(YY_NO_LEAKS)
348 : : static void yyfreestack(YYSTACKDATA *data)
349 : : {
350 : : free(data->s_base);
351 : : free(data->l_base);
352 : : memset(data, 0, sizeof(*data));
353 : : }
354 : : #else
355 : : #define yyfreestack(data) /* nothing */
356 : : #endif
357 : :
358 : : #define YYABORT goto yyabort
359 : : #define YYREJECT goto yyabort
360 : : #define YYACCEPT goto yyaccept
361 : : #define YYERROR goto yyerrlab
362 : :
363 : : int
364 : 10 : YYPARSE_DECL()
365 : : {
366 : : int yym, yyn, yystate;
367 : : #if YYDEBUG
368 : : const char *yys;
369 : :
370 : : if ((yys = getenv("YYDEBUG")) != 0)
371 : : {
372 : : yyn = *yys;
373 : : if (yyn >= '0' && yyn <= '9')
374 : : yydebug = yyn - '0';
375 : : }
376 : : #endif
377 : :
378 : 10 : yynerrs = 0;
379 : 10 : yyerrflag = 0;
380 : 10 : yychar = YYEMPTY;
381 : 10 : yystate = 0;
382 : :
383 : : #if YYPURE
384 : : memset(&yystack, 0, sizeof(yystack));
385 : : #endif
386 : :
387 [ + - ][ - + ]: 10 : if (yystack.s_base == NULL && yygrowstack(&yystack)) goto yyoverflow;
388 : 10 : yystack.s_mark = yystack.s_base;
389 : 10 : yystack.l_mark = yystack.l_base;
390 : 10 : yystate = 0;
391 : 10 : *yystack.s_mark = 0;
392 : :
393 : : yyloop:
394 [ + + ]: 2746 : if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
395 [ + + ]: 1800 : if (yychar < 0)
396 : : {
397 [ - + ]: 1789 : if ((yychar = YYLEX) < 0) yychar = 0;
398 : : #if YYDEBUG
399 : : if (yydebug)
400 : : {
401 : : yys = 0;
402 : : if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
403 : : if (!yys) yys = "illegal-symbol";
404 : : printf("%sdebug: state %d, reading %d (%s)\n",
405 : : YYPREFIX, yystate, yychar, yys);
406 : : }
407 : : #endif
408 : : }
409 [ + - ][ + + ]: 1800 : if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
[ + - ][ + + ]
410 : 1798 : yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
411 : : {
412 : : #if YYDEBUG
413 : : if (yydebug)
414 : : printf("%sdebug: state %d, shifting to state %d\n",
415 : : YYPREFIX, yystate, yytable[yyn]);
416 : : #endif
417 [ - + ][ # # ]: 1787 : if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
418 : : {
419 : 0 : goto yyoverflow;
420 : : }
421 : 1787 : yystate = yytable[yyn];
422 : 1787 : *++yystack.s_mark = yytable[yyn];
423 : 1787 : *++yystack.l_mark = yylval;
424 : 1787 : yychar = YYEMPTY;
425 [ - + ]: 1787 : if (yyerrflag > 0) --yyerrflag;
426 : 1787 : goto yyloop;
427 : : }
428 [ + - ][ + - ]: 13 : if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
[ + - ][ + - ]
429 : 13 : yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
430 : : {
431 : 13 : yyn = yytable[yyn];
432 : 13 : goto yyreduce;
433 : : }
434 [ # # ]: 0 : if (yyerrflag) goto yyinrecovery;
435 : :
436 : 0 : yyerror("syntax error");
437 : :
438 : : goto yyerrlab;
439 : :
440 : : yyerrlab:
441 : 0 : ++yynerrs;
442 : :
443 : : yyinrecovery:
444 [ # # ]: 0 : if (yyerrflag < 3)
445 : : {
446 : 0 : yyerrflag = 3;
447 : : for (;;)
448 : : {
449 [ # # ][ # # ]: 0 : if ((yyn = yysindex[*yystack.s_mark]) && (yyn += YYERRCODE) >= 0 &&
[ # # ][ # # ]
450 : 0 : yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
451 : : {
452 : : #if YYDEBUG
453 : : if (yydebug)
454 : : printf("%sdebug: state %d, error recovery shifting\
455 : : to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]);
456 : : #endif
457 [ # # ][ # # ]: 0 : if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
458 : : {
459 : 0 : goto yyoverflow;
460 : : }
461 : 0 : yystate = yytable[yyn];
462 : 0 : *++yystack.s_mark = yytable[yyn];
463 : 0 : *++yystack.l_mark = yylval;
464 : 0 : goto yyloop;
465 : : }
466 : : else
467 : : {
468 : : #if YYDEBUG
469 : : if (yydebug)
470 : : printf("%sdebug: error recovery discarding state %d\n",
471 : : YYPREFIX, *yystack.s_mark);
472 : : #endif
473 [ # # ]: 0 : if (yystack.s_mark <= yystack.s_base) goto yyabort;
474 : 0 : --yystack.s_mark;
475 : 0 : --yystack.l_mark;
476 : : }
477 : 0 : }
478 : : }
479 : : else
480 : : {
481 [ # # ]: 0 : if (yychar == 0) goto yyabort;
482 : : #if YYDEBUG
483 : : if (yydebug)
484 : : {
485 : : yys = 0;
486 : : if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
487 : : if (!yys) yys = "illegal-symbol";
488 : : printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
489 : : YYPREFIX, yystate, yychar, yys);
490 : : }
491 : : #endif
492 : 0 : yychar = YYEMPTY;
493 : 0 : goto yyloop;
494 : : }
495 : :
496 : : yyreduce:
497 : : #if YYDEBUG
498 : : if (yydebug)
499 : : printf("%sdebug: state %d, reducing by rule %d (%s)\n",
500 : : YYPREFIX, yystate, yyn, yyrule[yyn]);
501 : : #endif
502 : 959 : yym = yylen[yyn];
503 [ + - ]: 959 : if (yym)
504 : 959 : yyval = yystack.l_mark[1-yym];
505 : : else
506 : 0 : memset(&yyval, 0, sizeof yyval);
507 [ + + - + : 959 : switch (yyn)
+ + + +
+ ]
508 : : {
509 : : case 5:
510 : : {
511 : 9 : id_str = yystack.l_mark[0].string;
512 : : }
513 : 9 : break;
514 : : case 6:
515 : : {
516 : 10 : base_id = name2number(yystack.l_mark[0].string);
517 : 10 : strlcpy(name, yystack.l_mark[0].string, sizeof(name));
518 : 10 : free(yystack.l_mark[0].string);
519 : : }
520 : 10 : break;
521 : : case 7:
522 : : {
523 : 0 : base_id = name2number(yystack.l_mark[-1].string);
524 : 0 : strlcpy(name, yystack.l_mark[0].string, sizeof(name));
525 : 0 : free(yystack.l_mark[-1].string);
526 : 0 : free(yystack.l_mark[0].string);
527 : : }
528 : 0 : break;
529 : : case 10:
530 : : {
531 : 26 : number = yystack.l_mark[0].number;
532 : : }
533 : 26 : break;
534 : : case 11:
535 : : {
536 : 22 : free(prefix);
537 : 22 : asprintf (&prefix, "%s_", yystack.l_mark[0].string);
538 [ - + ]: 22 : if (prefix == NULL)
539 : 0 : errx(1, "malloc");
540 : 22 : free(yystack.l_mark[0].string);
541 : : }
542 : 22 : break;
543 : : case 12:
544 : : {
545 : 1 : prefix = realloc(prefix, 1);
546 [ - + ]: 1 : if (prefix == NULL)
547 : 0 : errx(1, "malloc");
548 : 1 : *prefix = '\0';
549 : : }
550 : 1 : break;
551 : : case 13:
552 : : {
553 : 411 : struct error_code *ec = malloc(sizeof(*ec));
554 : :
555 [ - + ]: 411 : if (ec == NULL)
556 : 0 : errx(1, "malloc");
557 : :
558 : 411 : ec->next = NULL;
559 : 411 : ec->number = number;
560 [ + - ][ + + ]: 714 : if(prefix && *prefix != '\0') {
561 : 303 : asprintf (&ec->name, "%s%s", prefix, yystack.l_mark[-2].string);
562 [ - + ]: 303 : if (ec->name == NULL)
563 : 0 : errx(1, "malloc");
564 : 303 : free(yystack.l_mark[-2].string);
565 : : } else
566 : 108 : ec->name = yystack.l_mark[-2].string;
567 : 411 : ec->string = yystack.l_mark[0].string;
568 [ + + ]: 411 : APPEND(codes, ec);
569 : 411 : number++;
570 : : }
571 : 411 : break;
572 : : case 14:
573 : : {
574 : 8 : YYACCEPT;
575 : : }
576 : : break;
577 : : }
578 : 951 : yystack.s_mark -= yym;
579 : 951 : yystate = *yystack.s_mark;
580 : 951 : yystack.l_mark -= yym;
581 : 951 : yym = yylhs[yyn];
582 [ + + ][ + + ]: 951 : if (yystate == 0 && yym == 0)
583 : : {
584 : : #if YYDEBUG
585 : : if (yydebug)
586 : : printf("%sdebug: after reduction, shifting from state 0 to\
587 : : state %d\n", YYPREFIX, YYFINAL);
588 : : #endif
589 : 2 : yystate = YYFINAL;
590 : 2 : *++yystack.s_mark = YYFINAL;
591 : 2 : *++yystack.l_mark = yyval;
592 [ - + ]: 2 : if (yychar < 0)
593 : : {
594 [ # # ]: 0 : if ((yychar = YYLEX) < 0) yychar = 0;
595 : : #if YYDEBUG
596 : : if (yydebug)
597 : : {
598 : : yys = 0;
599 : : if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
600 : : if (!yys) yys = "illegal-symbol";
601 : : printf("%sdebug: state %d, reading %d (%s)\n",
602 : : YYPREFIX, YYFINAL, yychar, yys);
603 : : }
604 : : #endif
605 : : }
606 [ + - ]: 2 : if (yychar == 0) goto yyaccept;
607 : 0 : goto yyloop;
608 : : }
609 [ + + ][ + - ]: 949 : if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
[ + - ][ + + ]
610 : 470 : yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
611 : 459 : yystate = yytable[yyn];
612 : : else
613 : 490 : yystate = yydgoto[yym];
614 : : #if YYDEBUG
615 : : if (yydebug)
616 : : printf("%sdebug: after reduction, shifting from state %d \
617 : : to state %d\n", YYPREFIX, *yystack.s_mark, yystate);
618 : : #endif
619 [ - + ][ # # ]: 949 : if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
620 : : {
621 : 0 : goto yyoverflow;
622 : : }
623 : 949 : *++yystack.s_mark = (short) yystate;
624 : 949 : *++yystack.l_mark = yyval;
625 : 949 : goto yyloop;
626 : :
627 : : yyoverflow:
628 : 0 : yyerror("yacc stack overflow");
629 : :
630 : : yyabort:
631 : : yyfreestack(&yystack);
632 : 0 : return (1);
633 : :
634 : : yyaccept:
635 : : yyfreestack(&yystack);
636 : 10 : return (0);
637 : : }
|
