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