Added sample rpld.conf file to load gPXE
[rpld.git] / rpld_conf.tab.c
1 #ifndef lint
2 static const char yysccsid[] = "@(#)yaccpar     1.9 (Berkeley) 02/21/93";
3 #endif
4 #define YYBYACC 1
5 #define YYMAJOR 1
6 #define YYMINOR 9
7 #define yyclearin (yychar=(-1))
8 #define yyerrok (yyerrflag=0)
9 #define YYRECOVERING (yyerrflag!=0)
10 extern int yyparse(void);
11 #define YYPREFIX "yy"
12 #line 80 "rpld_conf.y"
13
14 static char rcsid[]="$Id: rpld_conf.y,v 1.8 2001/11/01 15:23:59 root Exp $";
15
16 #include "project.h"
17
18 #include <stdlib.h>
19
20 /* state machine stuff*/
21
22 typedef enum {START, BLOCK_START, BLOCK_END, ASSERTION, ASSIGNMENT} THING ;
23 typedef enum {INIT, GLOBALBLOCK, HOSTBLOCK, FILEBLOCK} STATE ;
24
25 /*void process_thing(THING thing, char *name, int type, YYSTYPE *pvalue);*/
26
27 #line 98 "rpld_conf.y"
28 typedef union {
29                 long number;
30                 char *name;
31                 char *text;
32                 char mac_address[6];
33                 struct partial_mac {
34                         char mac_address[6];
35                         int mac_len;
36                 } pm;
37         } YYSTYPE;
38 #line 39 "rpld_conf.tab.c"
39 #define BLOCK_START 257
40 #define BLOCK_END 258
41 #define NAME 259
42 #define TEXT 260
43 #define NUMBER 261
44 #define MACADDR 262
45 #define MACADDR_PARTIAL 263
46 #define YYERRCODE 256
47 short yylhs[] = {                                        -1,
48     0,    0,    1,    1,    2,    2,    3,    3,    3,    4,
49     4,    4,    4,    4,    4,
50 };
51 short yylen[] = {                                         2,
52     2,    3,    3,    2,    2,    1,    1,    2,    3,    1,
53     3,    3,    3,    3,    1,
54 };
55 short yydefred[] = {                                      0,
56     6,    0,    0,    0,    0,    5,    0,    1,    4,    0,
57     7,   15,    0,    0,    2,    0,    3,    0,    8,   11,
58    12,   13,   14,    9,
59 };
60 short yydgoto[] = {                                       3,
61    12,    5,   13,   14,
62 };
63 short yysindex[] = {                                   -244,
64     0, -250, -244,  -51,  -59,    0,  -45,    0,    0,  -60,
65     0,    0, -247,  -43,    0, -258,    0,  -42,    0,    0,
66     0,    0,    0,    0,
67 };
68 short yyrindex[] = {                                      0,
69     0,    0,    0,    0,    0,    0,    0,    0,    0,  -41,
70     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
71     0,    0,    0,    0,
72 };
73 short yygindex[] = {                                      0,
74     6,    0,    0,    7,
75 };
76 #define YYTABLESIZE 200
77 short yytable[] = {                                      11,
78    16,   20,   21,   22,   23,    4,    6,    8,    7,    1,
79    17,   10,    1,   15,    2,   19,   24,   10,    0,   18,
80     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
81     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
82     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
83     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
84     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
85     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
86     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
87     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
88     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
89     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
90     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
91     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
92     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
93     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
94     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
95     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
96     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
97     0,    0,    0,    0,    0,    0,    6,    1,    9,   10,
98 };
99 short yycheck[] = {                                      59,
100    61,  260,  261,  262,  263,    0,  257,   59,    3,  257,
101   258,  259,  257,   59,  259,   59,   59,   59,   -1,   13,
102    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
103    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
104    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
105    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
106    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
107    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
108    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
109    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
110    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
111    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
112    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
113    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
114    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
115    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
116    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
117    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
118    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
119    -1,   -1,   -1,   -1,   -1,   -1,  257,  257,  258,  259,
120 };
121 #define YYFINAL 3
122 #ifndef YYDEBUG
123 #define YYDEBUG 0
124 #endif
125 #define YYMAXTOKEN 263
126 #if YYDEBUG
127 char *yyname[] = {
128 "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,
129 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"';'",0,"'='",0,0,0,0,0,0,0,0,
130 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
131 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
132 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
133 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
134 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"BLOCK_START","BLOCK_END",
135 "NAME","TEXT","NUMBER","MACADDR","MACADDR_PARTIAL",
136 };
137 char *yyrule[] = {
138 "$accept : block_list",
139 "block_list : block ';'",
140 "block_list : block_list block ';'",
141 "block : block_start statement_list BLOCK_END",
142 "block : block_start BLOCK_END",
143 "block_start : NAME BLOCK_START",
144 "block_start : BLOCK_START",
145 "statement_list : ';'",
146 "statement_list : statement ';'",
147 "statement_list : statement_list statement ';'",
148 "statement : NAME",
149 "statement : NAME '=' TEXT",
150 "statement : NAME '=' NUMBER",
151 "statement : NAME '=' MACADDR",
152 "statement : NAME '=' MACADDR_PARTIAL",
153 "statement : block",
154 };
155 #endif
156 #ifdef YYSTACKSIZE
157 #undef YYMAXDEPTH
158 #define YYMAXDEPTH YYSTACKSIZE
159 #else
160 #ifdef YYMAXDEPTH
161 #define YYSTACKSIZE YYMAXDEPTH
162 #else
163 #define YYSTACKSIZE 500
164 #define YYMAXDEPTH 500
165 #endif
166 #endif
167 int yydebug;
168 int yynerrs;
169 int yyerrflag;
170 int yychar;
171 short *yyssp;
172 YYSTYPE *yyvsp;
173 YYSTYPE yyval;
174 YYSTYPE yylval;
175 short yyss[YYSTACKSIZE];
176 YYSTYPE yyvs[YYSTACKSIZE];
177 #define yystacksize YYSTACKSIZE
178 #line 136 "rpld_conf.y"
179
180 //
181 // ERROR REPORTING
182 //
183
184 // the lineno variable from our parser
185 extern int lineno;
186
187 // the yytext variable from lex for error reporting
188 extern char* yytext;
189
190 void yyerror(char *s)
191 {
192         fprintf(stderr, "rpld: config line %d: %s near `%s'\n", lineno, s, yytext);
193 }
194
195 //
196 // CONFIGURATION PROCESSOR
197 //
198
199 // This is the bit that actually does the work
200
201 #define strsame(a, b)   (!strcmp((a), (b)))
202 /*
203 struct global_parameters
204 {
205
206 } g_params;
207 */
208
209 struct clientinfo
210 {
211         int have_mac;
212         int have_run_addr;
213         int have_files;
214         // optional
215         int have_framesize;
216         int have_blocksize;
217         int have_pacing;
218         int have_nospew;
219 };
220
221 struct clfileinfo
222 {
223         int have_path;
224         int have_load_addr;
225         // optional
226         int have_offset;
227         int have_length;
228 };
229
230 extern struct client *clients;
231
232 // hideous, we need to cope with a semicolon after this
233 //#define THROW_ERROR(a)        do { yyerror((a)); exit(1); } while(0)
234 #define THROW_ERROR(a)  do { fprintf(stderr, "rpld: config line %d: %s near `%s'\n", lineno, (a), name); exit(1); } while(0)
235
236 void process_thing(THING thing, char *name, int type, YYSTYPE *pvalue)
237 {
238         static STATE state;
239         static struct client *pc;
240         static struct clientinfo ci;
241         static struct clfile *pcf;
242         static struct clfileinfo cfi;
243
244         switch(thing)
245         {
246         // boot the state machine
247         case START:
248                 state = INIT;
249                 break;
250
251         //
252         // Blocks, which contain related options
253         //
254         
255         // start of a block
256         case BLOCK_START:
257                 // in initial state, move to GLOBALBLOCK or HOSTBLOCK
258                 if (state == INIT) {
259                         if (strsame(name, "GLOBAL")) {
260                                 state = GLOBALBLOCK;
261                                 break;
262                         } else if (strsame(name, "HOST") || strsame(name, "CLIENT")) {
263                                 // construct a new client entity
264                                 pc = (struct client*)malloc(sizeof(struct client));
265                                 bzero(pc, sizeof(struct client));
266                                 // reset info about what options have been set for this client
267                                 bzero(&ci, sizeof(ci));
268
269                                 pc->blocklen=MY_BLOCK_LEN;
270                                 pc->framelen=MY_FRAME_LEN;
271                                 pc->pacing=MY_PACING;
272                                 
273                                 state = HOSTBLOCK;
274                                 break;
275                         } else THROW_ERROR("Unknown top-level parameter block");
276                 }
277                 // in a HOST block, this must be a FILE
278                 else if (state == HOSTBLOCK) {
279                         if (strsame(name, "FILE")) {
280                                 // construct a new file entity
281                                 pcf = (struct clfile*)malloc(sizeof(struct clfile));
282                                 bzero(pcf, sizeof(struct clfile));
283                                 pcf->length=-1;
284                                 // reset info about options set for this file
285                                 bzero(&cfi, sizeof(cfi));
286                                 
287                                 state = FILEBLOCK;
288                                 break;
289                         } else THROW_ERROR("Only a FILE parameter block can be included in a HOST block");
290                 }
291                 // fuck knows
292                 else
293                 {
294                         yyerror("Unknown parameter block");
295                         exit(1);
296                 }
297                 break;
298
299         // end of a block, we should have a bunch of info now
300         case BLOCK_END:
301                 // end GLOBAL block
302                 if (state == GLOBALBLOCK) {
303                         // no more global params, at least for the moment
304                 }
305                 // end HOST block
306                 else if (state == HOSTBLOCK) {
307                         // should have a complete host specification
308                         if (!ci.have_mac) THROW_ERROR("Must specify an ethernet (MAC) address for host");
309                         else if (!ci.have_run_addr) THROW_ERROR("Must specify an initial execute address for host");
310                         else if (!ci.have_files) THROW_ERROR("Must specify at least one file to load for host");
311
312                         // OK, should have an entire host spec, so copy it in
313                         pc->next = clients;
314                         clients = pc;
315
316                         // finished this host spec
317                         state = INIT;
318                         break;
319                 }
320                 // end FILE block
321                 else if (state == FILEBLOCK) {
322                         // should have a complete file specification
323                         if (!cfi.have_path) THROW_ERROR("Must specify a path for file");
324                         else if (!cfi.have_load_addr) THROW_ERROR("Must specify a load address for file");
325
326                         // have an entire file spec, copy it into the host spec
327                         pcf->next = pc->files;
328                         pc->files = pcf;
329
330                         ci.have_files = 1;
331
332                         // done
333                         state = HOSTBLOCK;
334                         break;
335                 }
336
337         //
338         // The various things that go inside blocks
339         //
340         
341         case ASSERTION:
342                 if (state == GLOBALBLOCK) {
343                         // no global assertions ATM
344                         THROW_ERROR("Unknown directive");
345                 } else if (state == HOSTBLOCK) {
346                         // no host assertions ATM
347                         if (strsame(name,"nospew")) {
348                                 if (ci.have_pacing) THROW_ERROR("Directive nospew incompatible with pacing ");
349                                 if (ci.have_nospew) THROW_ERROR("Repeated directive");
350                                 ci.have_nospew=1;
351                                 pc->nospew++;
352                         } else THROW_ERROR("Unknown directive");
353                 } else if (state == FILEBLOCK) {
354                         if (strsame(name,"linux")) {
355                                 if (!cfi.have_path) THROW_ERROR("A path to a valid kernel must precede linux");
356
357                                 do_linux_kernel(pc,pcf);
358                                 cfi.have_load_addr=1;
359                                 cfi.have_offset=1;
360                                 cfi.have_length=1;
361                                 ci.have_run_addr=1;
362                         }else{
363                         THROW_ERROR("Unknown directive");
364                         }
365                 } else THROW_ERROR("Unknown directive");
366                 break;
367
368         case ASSIGNMENT:
369                 if (state == GLOBALBLOCK) {
370                         // no global assignments ATM
371                         THROW_ERROR("Unknown directive");
372                 } else if (state == HOSTBLOCK) {
373                         // ethernet address
374                         if (strsame(name, "ethernet") || strsame(name, "mac")) {
375                                 if (type != MACADDR && type != MACADDR_PARTIAL)
376                                         THROW_ERROR("Directive must be followed by a (partial or complete) ethernet address");
377                                 else if (ci.have_mac) THROW_ERROR("Repeated directive");
378
379                                 if (type == MACADDR) {
380                                         // set MAC address; this is non-partial, so len = ETH_ALEN
381                                         bcopy(pvalue->mac_address, pc->mac, ETH_ALEN);
382                                         pc->partial_mac_len = ETH_ALEN;
383                                 } else {
384                                         bcopy(pvalue->pm.mac_address, pc->mac, pvalue->pm.mac_len);
385                                         pc->partial_mac_len = pvalue->pm.mac_len;
386                                 }
387
388                                 ci.have_mac = 1;
389                         }
390                         // execute address
391                         else if (strsame(name, "execute") || strsame(name, "run")) {
392                                 if (type != NUMBER) THROW_ERROR("Directive must be followed by a memory address");
393                                 else if (ci.have_run_addr==2) THROW_ERROR("Repeated directive");
394
395                                 // set address
396                                 pc->run_addr = pvalue->number;
397                                 ci.have_run_addr = 2;
398                         }
399                         else if (strsame(name, "blocksize")) {
400                                 if (type != NUMBER) THROW_ERROR("Directive must be followed by an integer ");
401                                 else if (ci.have_blocksize) THROW_ERROR("Repeated directive");
402
403                                 // set address
404                                 pc->blocklen = pvalue->number;
405                                 ci.have_blocksize = 1;
406                         }
407                         else if (strsame(name, "framesize")) {
408                                 if (type != NUMBER) THROW_ERROR("Directive must be followed by an integer ");
409                                 else if (ci.have_framesize) THROW_ERROR("Repeated directive");
410
411                                 // set size
412                                 pc->framelen = pvalue->number;
413                                 ci.have_framesize = 1;
414                         }
415                         else if (strsame(name,"pacing")) {
416                                 if (type != NUMBER) THROW_ERROR("Directive must be followed by an integer ");
417                                 if (ci.have_nospew) THROW_ERROR("Directive pacing incompatible with nospew ");
418                                 if (ci.have_pacing) THROW_ERROR("Repeated directive");
419                                 pc->pacing = pvalue->number;
420                                 ci.have_pacing =1;
421                         }
422                         else THROW_ERROR("Unknown directive");
423                 } else if (state == FILEBLOCK) {
424                         // path
425                         if (strsame(name, "path")) {
426                                 if (type != TEXT) THROW_ERROR("Directive must be followed by a filename");
427                                 else if (cfi.have_path) THROW_ERROR("Repeated directive");
428
429                                 // set filename
430                                 pcf->path = pvalue->text;
431                                 cfi.have_path = 1;
432                         }
433                         // load address
434                         else if (strsame(name, "load")) {
435                                 if (type != NUMBER) THROW_ERROR("Directive must be followed by a memory address");
436                                 else if (cfi.have_load_addr) THROW_ERROR("Repeated directive");
437
438                                 // set load address
439                                 pcf->load_addr = pvalue->number;
440                                 cfi.have_load_addr = 1;
441                         }
442                         // offset
443                         else if (strsame(name, "offset")) {
444                                 if (type != NUMBER) THROW_ERROR("Directive must be followed by a memory address");
445                                 else if (cfi.have_offset) THROW_ERROR("Repeated directive");
446
447                                 // set offset
448                                 pcf->offset = pvalue->number;
449                                 cfi.have_offset = 1;
450                         }
451                         // length
452                         else if (strsame(name, "length")) {
453                                 if (type != NUMBER) THROW_ERROR("Directive must be followed by a memory address");
454                                 else if (cfi.have_length) THROW_ERROR("Repeated directive");
455
456                                 // set length
457                                 pcf->length = pvalue->number;
458                                 cfi.have_length = 1;
459                         }
460                         else THROW_ERROR("Unknown directive");
461                 }
462                 break;
463
464                 default: THROW_ERROR("Mistake");
465         }
466         
467
468 }
469 #line 470 "rpld_conf.tab.c"
470 #define YYABORT goto yyabort
471 #define YYREJECT goto yyabort
472 #define YYACCEPT goto yyaccept
473 #define YYERROR goto yyerrlab
474 int
475 yyparse(void)
476 {
477     register int yym, yyn, yystate;
478 #if YYDEBUG
479     register char *yys;
480     extern char *getenv();
481
482     if (yys = getenv("YYDEBUG"))
483     {
484         yyn = *yys;
485         if (yyn >= '0' && yyn <= '9')
486             yydebug = yyn - '0';
487     }
488 #endif
489
490     yynerrs = 0;
491     yyerrflag = 0;
492     yychar = (-1);
493
494     yyssp = yyss;
495     yyvsp = yyvs;
496     *yyssp = yystate = 0;
497
498 yyloop:
499     if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
500     if (yychar < 0)
501     {
502         if ((yychar = yylex()) < 0) yychar = 0;
503 #if YYDEBUG
504         if (yydebug)
505         {
506             yys = 0;
507             if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
508             if (!yys) yys = "illegal-symbol";
509             printf("%sdebug: state %d, reading %d (%s)\n",
510                     YYPREFIX, yystate, yychar, yys);
511         }
512 #endif
513     }
514     if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
515             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
516     {
517 #if YYDEBUG
518         if (yydebug)
519             printf("%sdebug: state %d, shifting to state %d\n",
520                     YYPREFIX, yystate, yytable[yyn]);
521 #endif
522         if (yyssp >= yyss + yystacksize - 1)
523         {
524             goto yyoverflow;
525         }
526         *++yyssp = yystate = yytable[yyn];
527         *++yyvsp = yylval;
528         yychar = (-1);
529         if (yyerrflag > 0)  --yyerrflag;
530         goto yyloop;
531     }
532     if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
533             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
534     {
535         yyn = yytable[yyn];
536         goto yyreduce;
537     }
538     if (yyerrflag) goto yyinrecovery;
539 #ifdef lint
540     goto yynewerror;
541 #endif
542 yynewerror:
543     yyerror("syntax error");
544 #ifdef lint
545     goto yyerrlab;
546 #endif
547 yyerrlab:
548     ++yynerrs;
549 yyinrecovery:
550     if (yyerrflag < 3)
551     {
552         yyerrflag = 3;
553         for (;;)
554         {
555             if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 &&
556                     yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
557             {
558 #if YYDEBUG
559                 if (yydebug)
560                     printf("%sdebug: state %d, error recovery shifting\
561  to state %d\n", YYPREFIX, *yyssp, yytable[yyn]);
562 #endif
563                 if (yyssp >= yyss + yystacksize - 1)
564                 {
565                     goto yyoverflow;
566                 }
567                 *++yyssp = yystate = yytable[yyn];
568                 *++yyvsp = yylval;
569                 goto yyloop;
570             }
571             else
572             {
573 #if YYDEBUG
574                 if (yydebug)
575                     printf("%sdebug: error recovery discarding state %d\n",
576                             YYPREFIX, *yyssp);
577 #endif
578                 if (yyssp <= yyss) goto yyabort;
579                 --yyssp;
580                 --yyvsp;
581             }
582         }
583     }
584     else
585     {
586         if (yychar == 0) goto yyabort;
587 #if YYDEBUG
588         if (yydebug)
589         {
590             yys = 0;
591             if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
592             if (!yys) yys = "illegal-symbol";
593             printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
594                     YYPREFIX, yystate, yychar, yys);
595         }
596 #endif
597         yychar = (-1);
598         goto yyloop;
599     }
600 yyreduce:
601 #if YYDEBUG
602     if (yydebug)
603         printf("%sdebug: state %d, reducing by rule %d (%s)\n",
604                 YYPREFIX, yystate, yyn, yyrule[yyn]);
605 #endif
606     yym = yylen[yyn];
607     yyval = yyvsp[1-yym];
608     switch (yyn)
609     {
610 case 3:
611 #line 117 "rpld_conf.y"
612 { process_thing(BLOCK_END, "", 0, NULL); }
613 break;
614 case 4:
615 #line 118 "rpld_conf.y"
616 { process_thing(BLOCK_END, "", 0, NULL); }
617 break;
618 case 5:
619 #line 120 "rpld_conf.y"
620 { process_thing(BLOCK_START, yyvsp[-1].name, 0, NULL); }
621 break;
622 case 6:
623 #line 121 "rpld_conf.y"
624 { process_thing(BLOCK_START, "", 0, NULL); }
625 break;
626 case 10:
627 #line 128 "rpld_conf.y"
628 { process_thing(ASSERTION, yyvsp[0].name, 0, NULL); }
629 break;
630 case 11:
631 #line 129 "rpld_conf.y"
632 { process_thing(ASSIGNMENT, yyvsp[-2].name, TEXT, &yyvsp[0]); }
633 break;
634 case 12:
635 #line 130 "rpld_conf.y"
636 { process_thing(ASSIGNMENT, yyvsp[-2].name, NUMBER, &yyvsp[0]); }
637 break;
638 case 13:
639 #line 131 "rpld_conf.y"
640 { process_thing(ASSIGNMENT, yyvsp[-2].name, MACADDR, &yyvsp[0]); }
641 break;
642 case 14:
643 #line 132 "rpld_conf.y"
644 { process_thing(ASSIGNMENT, yyvsp[-2].name, MACADDR_PARTIAL, &yyvsp[0]); }
645 break;
646 #line 647 "rpld_conf.tab.c"
647     }
648     yyssp -= yym;
649     yystate = *yyssp;
650     yyvsp -= yym;
651     yym = yylhs[yyn];
652     if (yystate == 0 && yym == 0)
653     {
654 #if YYDEBUG
655         if (yydebug)
656             printf("%sdebug: after reduction, shifting from state 0 to\
657  state %d\n", YYPREFIX, YYFINAL);
658 #endif
659         yystate = YYFINAL;
660         *++yyssp = YYFINAL;
661         *++yyvsp = yyval;
662         if (yychar < 0)
663         {
664             if ((yychar = yylex()) < 0) yychar = 0;
665 #if YYDEBUG
666             if (yydebug)
667             {
668                 yys = 0;
669                 if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
670                 if (!yys) yys = "illegal-symbol";
671                 printf("%sdebug: state %d, reading %d (%s)\n",
672                         YYPREFIX, YYFINAL, yychar, yys);
673             }
674 #endif
675         }
676         if (yychar == 0) goto yyaccept;
677         goto yyloop;
678     }
679     if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
680             yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
681         yystate = yytable[yyn];
682     else
683         yystate = yydgoto[yym];
684 #if YYDEBUG
685     if (yydebug)
686         printf("%sdebug: after reduction, shifting from state %d \
687 to state %d\n", YYPREFIX, *yyssp, yystate);
688 #endif
689     if (yyssp >= yyss + yystacksize - 1)
690     {
691         goto yyoverflow;
692     }
693     *++yyssp = yystate;
694     *++yyvsp = yyval;
695     goto yyloop;
696 yyoverflow:
697     yyerror("yacc stack overflow");
698 yyabort:
699     return (1);
700 yyaccept:
701     return (0);
702 }