4e07d3eb2733d72216f6d9397c03176ee22ed1d7
[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 34 "rpld_conf.y"
12
13 static char rcsid[]="$Id: rpld_conf.y,v 1.3 1999/09/26 10:46:56 root Exp root $";
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 50 "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 88 "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 };
215
216 struct clfileinfo
217 {
218         int have_path;
219         int have_load_addr;
220         // optional
221         int have_offset;
222         int have_length;
223 };
224
225 extern struct client *clients;
226
227 // hideous, we need to cope with a semicolon after this
228 //#define THROW_ERROR(a)        do { yyerror((a)); exit(1); } while(0)
229 #define THROW_ERROR(a)  do { fprintf(stderr, "rpld: config line %d: %s near `%s'\n", lineno, (a), name); exit(1); } while(0)
230
231 void process_thing(THING thing, char *name, int type, YYSTYPE *pvalue)
232 {
233         static STATE state;
234         static struct client *pc;
235         static struct clientinfo ci;
236         static struct clfile *pcf;
237         static struct clfileinfo cfi;
238
239         switch(thing)
240         {
241         // boot the state machine
242         case START:
243                 state = INIT;
244                 break;
245
246         //
247         // Blocks, which contain related options
248         //
249         
250         // start of a block
251         case BLOCK_START:
252                 // in initial state, move to GLOBALBLOCK or HOSTBLOCK
253                 if (state == INIT) {
254                         if (strsame(name, "GLOBAL")) {
255                                 state = GLOBALBLOCK;
256                                 break;
257                         } else if (strsame(name, "HOST") || strsame(name, "CLIENT")) {
258                                 // construct a new client entity
259                                 pc = (struct client*)malloc(sizeof(struct client));
260                                 bzero(pc, sizeof(struct client));
261                                 // reset info about what options have been set for this client
262                                 bzero(&ci, sizeof(ci));
263
264                                 pc->blocklen=MY_BLOCK_LEN;
265                                 pc->framelen=MY_FRAME_LEN;
266                                 
267                                 state = HOSTBLOCK;
268                                 break;
269                         } else THROW_ERROR("Unknown top-level parameter block");
270                 }
271                 // in a HOST block, this must be a FILE
272                 else if (state == HOSTBLOCK) {
273                         if (strsame(name, "FILE")) {
274                                 // construct a new file entity
275                                 pcf = (struct clfile*)malloc(sizeof(struct clfile));
276                                 bzero(pcf, sizeof(struct clfile));
277                                 pcf->length=-1;
278                                 // reset info about options set for this file
279                                 bzero(&cfi, sizeof(cfi));
280                                 
281                                 state = FILEBLOCK;
282                                 break;
283                         } else THROW_ERROR("Only a FILE parameter block can be included in a HOST block");
284                 }
285                 // fuck knows
286                 else
287                 {
288                         yyerror("Unknown parameter block");
289                         exit(1);
290                 }
291                 break;
292
293         // end of a block, we should have a bunch of info now
294         case BLOCK_END:
295                 // end GLOBAL block
296                 if (state == GLOBALBLOCK) {
297                         // no more global params, at least for the moment
298                 }
299                 // end HOST block
300                 else if (state == HOSTBLOCK) {
301                         // should have a complete host specification
302                         if (!ci.have_mac) THROW_ERROR("Must specify an ethernet (MAC) address for host");
303                         else if (!ci.have_run_addr) THROW_ERROR("Must specify an initial execute address for host");
304                         else if (!ci.have_files) THROW_ERROR("Must specify at least one file to load for host");
305
306                         // OK, should have an entire host spec, so copy it in
307                         pc->next = clients;
308                         clients = pc;
309
310                         // finished this host spec
311                         state = INIT;
312                         break;
313                 }
314                 // end FILE block
315                 else if (state == FILEBLOCK) {
316                         // should have a complete file specification
317                         if (!cfi.have_path) THROW_ERROR("Must specify a path for file");
318                         else if (!cfi.have_load_addr) THROW_ERROR("Must specify a load address for file");
319
320                         // have an entire file spec, copy it into the host spec
321                         pcf->next = pc->files;
322                         pc->files = pcf;
323
324                         ci.have_files = 1;
325
326                         // done
327                         state = HOSTBLOCK;
328                         break;
329                 }
330
331         //
332         // The various things that go inside blocks
333         //
334         
335         case ASSERTION:
336                 if (state == GLOBALBLOCK) {
337                         // no global assertions ATM
338                         THROW_ERROR("Unknown directive");
339                 } else if (state == HOSTBLOCK) {
340                         // no host assertions ATM
341                         THROW_ERROR("Unknown directive");
342                 } else if (state == FILEBLOCK) {
343                         if (strsame(name,"linux")) {
344                                 if (!cfi.have_path) THROW_ERROR("A path to a
345 valid kernel must precede linux");
346
347                                 do_linux_kernel(pc,pcf);
348                                 cfi.have_load_addr=1;
349                                 cfi.have_offset=1;
350                                 cfi.have_length=1;
351                                 ci.have_run_addr=1;
352                         } else{
353                         THROW_ERROR("Unknown directive");
354                         }
355                 } else THROW_ERROR("Unknown directive");
356                 break;
357
358         case ASSIGNMENT:
359                 if (state == GLOBALBLOCK) {
360                         // no global assignments ATM
361                         THROW_ERROR("Unknown directive");
362                 } else if (state == HOSTBLOCK) {
363                         // ethernet address
364                         if (strsame(name, "ethernet") || strsame(name, "mac")) {
365                                 if (type != MACADDR && type != MACADDR_PARTIAL)
366                                         THROW_ERROR("Directive must be followed by a (partial or complete) ethernet address");
367                                 else if (ci.have_mac) THROW_ERROR("Repeated directive");
368
369                                 if (type == MACADDR) {
370                                         // set MAC address; this is non-partial, so len = ETH_ALEN
371                                         bcopy(pvalue->mac_address, pc->mac, ETH_ALEN);
372                                         pc->partial_mac_len = ETH_ALEN;
373                                 } else {
374                                         bcopy(pvalue->pm.mac_address, pc->mac, pvalue->pm.mac_len);
375                                         pc->partial_mac_len = pvalue->pm.mac_len;
376                                 }
377
378                                 ci.have_mac = 1;
379                         }
380                         // execute address
381                         else if (strsame(name, "execute") || strsame(name, "run")) {
382                                 if (type != NUMBER) THROW_ERROR("Directive must be followed by a memory address");
383                                 else if (ci.have_run_addr==2) THROW_ERROR("Repeated directive");
384
385                                 // set address
386                                 pc->run_addr = pvalue->number;
387                                 ci.have_run_addr = 2;
388                         }
389                         else if (strsame(name, "blocksize")) {
390                                 if (type != NUMBER) THROW_ERROR("Directive must be followed by an integer ");
391                                 else if (ci.have_blocksize) THROW_ERROR("Repeated directive");
392
393                                 // set address
394                                 pc->blocklen = pvalue->number;
395                                 ci.have_blocksize = 1;
396                         }
397                         else if (strsame(name, "framesize")) {
398                                 if (type != NUMBER) THROW_ERROR("Directive must be followed by an integer ");
399                                 else if (ci.have_framesize) THROW_ERROR("Repeated directive");
400
401                                 // set size
402                                 pc->framelen = pvalue->number;
403                                 ci.have_framesize = 1;
404                         }
405                         else THROW_ERROR("Unknown directive");
406                 } else if (state == FILEBLOCK) {
407                         // path
408                         if (strsame(name, "path")) {
409                                 if (type != TEXT) THROW_ERROR("Directive must be followed by a filename");
410                                 else if (cfi.have_path) THROW_ERROR("Repeated directive");
411
412                                 // set filename
413                                 pcf->path = pvalue->text;
414                                 cfi.have_path = 1;
415                         }
416                         // load address
417                         else if (strsame(name, "load")) {
418                                 if (type != NUMBER) THROW_ERROR("Directive must be followed by a memory address");
419                                 else if (cfi.have_load_addr) THROW_ERROR("Repeated directive");
420
421                                 // set load address
422                                 pcf->load_addr = pvalue->number;
423                                 cfi.have_load_addr = 1;
424                         }
425                         // offset
426                         else if (strsame(name, "offset")) {
427                                 if (type != NUMBER) THROW_ERROR("Directive must be followed by a memory address");
428                                 else if (cfi.have_offset) THROW_ERROR("Repeated directive");
429
430                                 // set offset
431                                 pcf->offset = pvalue->number;
432                                 cfi.have_offset = 1;
433                         }
434                         // length
435                         else if (strsame(name, "length")) {
436                                 if (type != NUMBER) THROW_ERROR("Directive must be followed by a memory address");
437                                 else if (cfi.have_length) THROW_ERROR("Repeated directive");
438
439                                 // set length
440                                 pcf->length = pvalue->number;
441                                 cfi.have_length = 1;
442                         }
443                         else THROW_ERROR("Unknown directive");
444                 }
445                 break;
446
447                 default: THROW_ERROR("Mistake");
448         }
449         
450
451 }
452 #line 453 "rpld_conf.tab.c"
453 #define YYABORT goto yyabort
454 #define YYREJECT goto yyabort
455 #define YYACCEPT goto yyaccept
456 #define YYERROR goto yyerrlab
457 int
458 yyparse()
459 {
460     register int yym, yyn, yystate;
461 #if YYDEBUG
462     register char *yys;
463     extern char *getenv();
464
465     if (yys = getenv("YYDEBUG"))
466     {
467         yyn = *yys;
468         if (yyn >= '0' && yyn <= '9')
469             yydebug = yyn - '0';
470     }
471 #endif
472
473     yynerrs = 0;
474     yyerrflag = 0;
475     yychar = (-1);
476
477     yyssp = yyss;
478     yyvsp = yyvs;
479     *yyssp = yystate = 0;
480
481 yyloop:
482     if (yyn = yydefred[yystate]) goto yyreduce;
483     if (yychar < 0)
484     {
485         if ((yychar = yylex()) < 0) yychar = 0;
486 #if YYDEBUG
487         if (yydebug)
488         {
489             yys = 0;
490             if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
491             if (!yys) yys = "illegal-symbol";
492             printf("%sdebug: state %d, reading %d (%s)\n",
493                     YYPREFIX, yystate, yychar, yys);
494         }
495 #endif
496     }
497     if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
498             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
499     {
500 #if YYDEBUG
501         if (yydebug)
502             printf("%sdebug: state %d, shifting to state %d\n",
503                     YYPREFIX, yystate, yytable[yyn]);
504 #endif
505         if (yyssp >= yyss + yystacksize - 1)
506         {
507             goto yyoverflow;
508         }
509         *++yyssp = yystate = yytable[yyn];
510         *++yyvsp = yylval;
511         yychar = (-1);
512         if (yyerrflag > 0)  --yyerrflag;
513         goto yyloop;
514     }
515     if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
516             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
517     {
518         yyn = yytable[yyn];
519         goto yyreduce;
520     }
521     if (yyerrflag) goto yyinrecovery;
522 #ifdef lint
523     goto yynewerror;
524 #endif
525 yynewerror:
526     yyerror("syntax error");
527 #ifdef lint
528     goto yyerrlab;
529 #endif
530 yyerrlab:
531     ++yynerrs;
532 yyinrecovery:
533     if (yyerrflag < 3)
534     {
535         yyerrflag = 3;
536         for (;;)
537         {
538             if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 &&
539                     yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
540             {
541 #if YYDEBUG
542                 if (yydebug)
543                     printf("%sdebug: state %d, error recovery shifting\
544  to state %d\n", YYPREFIX, *yyssp, yytable[yyn]);
545 #endif
546                 if (yyssp >= yyss + yystacksize - 1)
547                 {
548                     goto yyoverflow;
549                 }
550                 *++yyssp = yystate = yytable[yyn];
551                 *++yyvsp = yylval;
552                 goto yyloop;
553             }
554             else
555             {
556 #if YYDEBUG
557                 if (yydebug)
558                     printf("%sdebug: error recovery discarding state %d\n",
559                             YYPREFIX, *yyssp);
560 #endif
561                 if (yyssp <= yyss) goto yyabort;
562                 --yyssp;
563                 --yyvsp;
564             }
565         }
566     }
567     else
568     {
569         if (yychar == 0) goto yyabort;
570 #if YYDEBUG
571         if (yydebug)
572         {
573             yys = 0;
574             if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
575             if (!yys) yys = "illegal-symbol";
576             printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
577                     YYPREFIX, yystate, yychar, yys);
578         }
579 #endif
580         yychar = (-1);
581         goto yyloop;
582     }
583 yyreduce:
584 #if YYDEBUG
585     if (yydebug)
586         printf("%sdebug: state %d, reducing by rule %d (%s)\n",
587                 YYPREFIX, yystate, yyn, yyrule[yyn]);
588 #endif
589     yym = yylen[yyn];
590     yyval = yyvsp[1-yym];
591     switch (yyn)
592     {
593 case 3:
594 #line 69 "rpld_conf.y"
595 { process_thing(BLOCK_END, "", 0, NULL); }
596 break;
597 case 4:
598 #line 70 "rpld_conf.y"
599 { process_thing(BLOCK_END, "", 0, NULL); }
600 break;
601 case 5:
602 #line 72 "rpld_conf.y"
603 { process_thing(BLOCK_START, yyvsp[-1].name, 0, NULL); }
604 break;
605 case 6:
606 #line 73 "rpld_conf.y"
607 { process_thing(BLOCK_START, "", 0, NULL); }
608 break;
609 case 10:
610 #line 80 "rpld_conf.y"
611 { process_thing(ASSERTION, yyvsp[0].name, 0, NULL); }
612 break;
613 case 11:
614 #line 81 "rpld_conf.y"
615 { process_thing(ASSIGNMENT, yyvsp[-2].name, TEXT, &yyvsp[0]); }
616 break;
617 case 12:
618 #line 82 "rpld_conf.y"
619 { process_thing(ASSIGNMENT, yyvsp[-2].name, NUMBER, &yyvsp[0]); }
620 break;
621 case 13:
622 #line 83 "rpld_conf.y"
623 { process_thing(ASSIGNMENT, yyvsp[-2].name, MACADDR, &yyvsp[0]); }
624 break;
625 case 14:
626 #line 84 "rpld_conf.y"
627 { process_thing(ASSIGNMENT, yyvsp[-2].name, MACADDR_PARTIAL, &yyvsp[0]); }
628 break;
629 #line 630 "rpld_conf.tab.c"
630     }
631     yyssp -= yym;
632     yystate = *yyssp;
633     yyvsp -= yym;
634     yym = yylhs[yyn];
635     if (yystate == 0 && yym == 0)
636     {
637 #if YYDEBUG
638         if (yydebug)
639             printf("%sdebug: after reduction, shifting from state 0 to\
640  state %d\n", YYPREFIX, YYFINAL);
641 #endif
642         yystate = YYFINAL;
643         *++yyssp = YYFINAL;
644         *++yyvsp = yyval;
645         if (yychar < 0)
646         {
647             if ((yychar = yylex()) < 0) yychar = 0;
648 #if YYDEBUG
649             if (yydebug)
650             {
651                 yys = 0;
652                 if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
653                 if (!yys) yys = "illegal-symbol";
654                 printf("%sdebug: state %d, reading %d (%s)\n",
655                         YYPREFIX, YYFINAL, yychar, yys);
656             }
657 #endif
658         }
659         if (yychar == 0) goto yyaccept;
660         goto yyloop;
661     }
662     if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
663             yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
664         yystate = yytable[yyn];
665     else
666         yystate = yydgoto[yym];
667 #if YYDEBUG
668     if (yydebug)
669         printf("%sdebug: after reduction, shifting from state %d \
670 to state %d\n", YYPREFIX, *yyssp, yystate);
671 #endif
672     if (yyssp >= yyss + yystacksize - 1)
673     {
674         goto yyoverflow;
675     }
676     *++yyssp = yystate;
677     *++yyvsp = yyval;
678     goto yyloop;
679 yyoverflow:
680     yyerror("yacc stack overflow");
681 yyabort:
682     return (1);
683 yyaccept:
684     return (0);
685 }