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