1 /* $NetBSD: slc-gram.y,v 1.2 2017/01/28 21:31:50 christos Exp $ */
2
3 %{
4 /*
5 * Copyright (c) 2004-2006 Kungliga Tekniska Högskolan
6 * (Royal Institute of Technology, Stockholm, Sweden).
7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 *
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 *
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 *
20 * 3. Neither the name of the Institute nor the names of its contributors
21 * may be used to endorse or promote products derived from this software
22 * without specific prior written permission.
23 *
24 * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
25 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27 * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34 * SUCH DAMAGE.
35 */
36
37 #include <config.h>
38
39 #include <stdio.h>
40 #include <stdlib.h>
41 #include <err.h>
42 #include <ctype.h>
43 #include <limits.h>
44 #include <getarg.h>
45 #include <vers.h>
46 #include <roken.h>
47
48 #include "slc.h"
49 extern FILE *yyin;
50 extern struct assignment *assignment;
51
52 /* Declarations for Bison:
53 */
54 #define YYMALLOC malloc
55 #define YYFREE free
56
57 %}
58
59 %union {
60 char *string;
61 struct assignment *assignment;
62 }
63
64 %token <string> LITERAL
65 %token <string> STRING
66 %type <assignment> assignment assignments
67
68 %start start
69
70 %%
71
72 start : assignments
73 {
74 assignment = $1;
75 }
76 ;
77
78 assignments : assignment assignments
79 {
80 $1->next = $2;
81 $$ = $1;
82 }
83 | assignment
84 ;
85
86 assignment : LITERAL '=' STRING
87 {
88 $$ = malloc(sizeof(*$$));
89 $$->name = $1;
90 $$->type = a_value;
91 $$->lineno = lineno;
92 $$->u.value = $3;
93 $$->next = NULL;
94 }
95 | LITERAL '=' '{' assignments '}'
96 {
97 $$ = malloc(sizeof(*$$));
98 $$->name = $1;
99 $$->type = a_assignment;
100 $$->lineno = lineno;
101 $$->u.assignment = $4;
102 $$->next = NULL;
103 }
104 ;
105
106 %%
107 char *filename;
108 FILE *cfile, *hfile;
109 int error_flag;
110 struct assignment *assignment;
111
112
113 static void
ex(struct assignment * a,const char * fmt,...)114 ex(struct assignment *a, const char *fmt, ...)
115 {
116 va_list ap;
117 fprintf(stderr, "%s:%d: ", a->name, a->lineno);
118 va_start(ap, fmt);
119 vfprintf(stderr, fmt, ap);
120 va_end(ap);
121 fprintf(stderr, "\n");
122 }
123
124
125
126 static int
check_option(struct assignment * as)127 check_option(struct assignment *as)
128 {
129 struct assignment *a;
130 int seen_long = 0;
131 int seen_name = 0;
132 int seen_short = 0;
133 int seen_type = 0;
134 int seen_argument = 0;
135 int seen_help = 0;
136 int seen_default = 0;
137 int ret = 0;
138
139 for(a = as; a != NULL; a = a->next) {
140 if(strcmp(a->name, "long") == 0)
141 seen_long++;
142 else if(strcmp(a->name, "short") == 0)
143 seen_short++;
144 else if(strcmp(a->name, "name") == 0)
145 seen_name++;
146 else if(strcmp(a->name, "type") == 0)
147 seen_type++;
148 else if(strcmp(a->name, "argument") == 0)
149 seen_argument++;
150 else if(strcmp(a->name, "help") == 0)
151 seen_help++;
152 else if(strcmp(a->name, "default") == 0)
153 seen_default++;
154 else {
155 ex(a, "unknown name %s", a->name);
156 ret++;
157 }
158 }
159 if(seen_long == 0 && seen_short == 0) {
160 ex(as, "neither long nor short option");
161 ret++;
162 }
163 if (seen_long == 0 && seen_name == 0) {
164 ex(as, "either of long or name option must be used");
165 ret++;
166 }
167 if(seen_long > 1) {
168 ex(as, "multiple long options");
169 ret++;
170 }
171 if(seen_short > 1) {
172 ex(as, "multiple short options");
173 ret++;
174 }
175 if(seen_type > 1) {
176 ex(as, "multiple types");
177 ret++;
178 }
179 if(seen_argument > 1) {
180 ex(as, "multiple arguments");
181 ret++;
182 }
183 if(seen_help > 1) {
184 ex(as, "multiple help strings");
185 ret++;
186 }
187 if(seen_default > 1) {
188 ex(as, "multiple default values");
189 ret++;
190 }
191 return ret;
192 }
193
194 static int
check_command(struct assignment * as)195 check_command(struct assignment *as)
196 {
197 struct assignment *a;
198 int seen_name = 0;
199 int seen_function = 0;
200 int seen_help = 0;
201 int seen_argument = 0;
202 int seen_minargs = 0;
203 int seen_maxargs = 0;
204 int ret = 0;
205 for(a = as; a != NULL; a = a->next) {
206 if(strcmp(a->name, "name") == 0)
207 seen_name++;
208 else if(strcmp(a->name, "function") == 0) {
209 seen_function++;
210 } else if(strcmp(a->name, "option") == 0)
211 ret += check_option(a->u.assignment);
212 else if(strcmp(a->name, "help") == 0) {
213 seen_help++;
214 } else if(strcmp(a->name, "argument") == 0) {
215 seen_argument++;
216 } else if(strcmp(a->name, "min_args") == 0) {
217 seen_minargs++;
218 } else if(strcmp(a->name, "max_args") == 0) {
219 seen_maxargs++;
220 } else {
221 ex(a, "unknown name: %s", a->name);
222 ret++;
223 }
224 }
225 if(seen_name == 0) {
226 ex(as, "no command name");
227 ret++;
228 }
229 if(seen_function > 1) {
230 ex(as, "multiple function names");
231 ret++;
232 }
233 if(seen_help > 1) {
234 ex(as, "multiple help strings");
235 ret++;
236 }
237 if(seen_argument > 1) {
238 ex(as, "multiple argument strings");
239 ret++;
240 }
241 if(seen_minargs > 1) {
242 ex(as, "multiple min_args strings");
243 ret++;
244 }
245 if(seen_maxargs > 1) {
246 ex(as, "multiple max_args strings");
247 ret++;
248 }
249
250 return ret;
251 }
252
253 static int
check(struct assignment * as)254 check(struct assignment *as)
255 {
256 struct assignment *a;
257 int ret = 0;
258 for(a = as; a != NULL; a = a->next) {
259 if(strcmp(a->name, "command")) {
260 fprintf(stderr, "unknown type %s line %d\n", a->name, a->lineno);
261 ret++;
262 continue;
263 }
264 if(a->type != a_assignment) {
265 fprintf(stderr, "bad command definition %s line %d\n", a->name, a->lineno);
266 ret++;
267 continue;
268 }
269 ret += check_command(a->u.assignment);
270 }
271 return ret;
272 }
273
274 static struct assignment *
find_next(struct assignment * as,const char * name)275 find_next(struct assignment *as, const char *name)
276 {
277 for(as = as->next; as != NULL; as = as->next) {
278 if(strcmp(as->name, name) == 0)
279 return as;
280 }
281 return NULL;
282 }
283
284 static struct assignment *
find(struct assignment * as,const char * name)285 find(struct assignment *as, const char *name)
286 {
287 for(; as != NULL; as = as->next) {
288 if(strcmp(as->name, name) == 0)
289 return as;
290 }
291 return NULL;
292 }
293
294 static void
space(FILE * f,int level)295 space(FILE *f, int level)
296 {
297 fprintf(f, "%*.*s", level * 4, level * 4, " ");
298 }
299
300 static void
cprint(int level,const char * fmt,...)301 cprint(int level, const char *fmt, ...)
302 {
303 va_list ap;
304 va_start(ap, fmt);
305 space(cfile, level);
306 vfprintf(cfile, fmt, ap);
307 va_end(ap);
308 }
309
310 static void
hprint(int level,const char * fmt,...)311 hprint(int level, const char *fmt, ...)
312 {
313 va_list ap;
314 va_start(ap, fmt);
315 space(hfile, level);
316 vfprintf(hfile, fmt, ap);
317 va_end(ap);
318 }
319
320 static void gen_name(char *str);
321
322 static void
gen_command(struct assignment * as)323 gen_command(struct assignment *as)
324 {
325 struct assignment *a, *b;
326 char *f;
327 a = find(as, "name");
328 f = strdup(a->u.value);
329 gen_name(f);
330 cprint(1, " { ");
331 fprintf(cfile, "\"%s\", ", a->u.value);
332 fprintf(cfile, "%s_wrap, ", f);
333 free(f);
334 b = find(as, "argument");
335 if(b)
336 fprintf(cfile, "\"%s %s\", ", a->u.value, b->u.value);
337 else
338 fprintf(cfile, "\"%s\", ", a->u.value);
339 b = find(as, "help");
340 if(b)
341 fprintf(cfile, "\"%s\"", b->u.value);
342 else
343 fprintf(cfile, "NULL");
344 fprintf(cfile, " },\n");
345 for(a = a->next; a != NULL; a = a->next)
346 if(strcmp(a->name, "name") == 0)
347 cprint(1, " { \"%s\", NULL, NULL, NULL },\n", a->u.value);
348 cprint(0, "\n");
349 }
350
351 static void
gen_name(char * str)352 gen_name(char *str)
353 {
354 char *p;
355 for(p = str; *p != '\0'; p++)
356 if(!isalnum((unsigned char)*p))
357 *p = '_';
358 }
359
360 static char *
make_name(struct assignment * as)361 make_name(struct assignment *as)
362 {
363 struct assignment *lopt;
364 struct assignment *type;
365 char *s;
366 int ret;
367
368 lopt = find(as, "long");
369 if(lopt == NULL)
370 lopt = find(as, "name");
371 if(lopt == NULL)
372 return NULL;
373
374 type = find(as, "type");
375 if(strcmp(type->u.value, "-flag") == 0)
376 ret = asprintf(&s, "%s_flag", lopt->u.value);
377 else
378 ret = asprintf(&s, "%s_%s", lopt->u.value, type->u.value);
379 if (ret == -1)
380 return NULL;
381 gen_name(s);
382 return s;
383 }
384
385
defval_int(const char * name,struct assignment * defval)386 static void defval_int(const char *name, struct assignment *defval)
387 {
388 if(defval != NULL)
389 cprint(1, "opt.%s = %s;\n", name, defval->u.value);
390 else
391 cprint(1, "opt.%s = 0;\n", name);
392 }
defval_neg_flag(const char * name,struct assignment * defval)393 static void defval_neg_flag(const char *name, struct assignment *defval)
394 {
395 if(defval != NULL)
396 cprint(1, "opt.%s = %s;\n", name, defval->u.value);
397 else
398 cprint(1, "opt.%s = 1;\n", name);
399 }
defval_string(const char * name,struct assignment * defval)400 static void defval_string(const char *name, struct assignment *defval)
401 {
402 if(defval != NULL)
403 cprint(1, "opt.%s = (char *)(unsigned long)\"%s\";\n", name, defval->u.value);
404 else
405 cprint(1, "opt.%s = NULL;\n", name);
406 }
defval_strings(const char * name,struct assignment * defval)407 static void defval_strings(const char *name, struct assignment *defval)
408 {
409 cprint(1, "opt.%s.num_strings = 0;\n", name);
410 cprint(1, "opt.%s.strings = NULL;\n", name);
411 }
412
free_strings(const char * name)413 static void free_strings(const char *name)
414 {
415 cprint(1, "free_getarg_strings (&opt.%s);\n", name);
416 }
417
418 struct type_handler {
419 const char *typename;
420 const char *c_type;
421 const char *getarg_type;
422 void (*defval)(const char*, struct assignment*);
423 void (*free)(const char*);
424 } type_handlers[] = {
425 { "integer",
426 "int",
427 "arg_integer",
428 defval_int,
429 NULL
430 },
431 { "string",
432 "char*",
433 "arg_string",
434 defval_string,
435 NULL
436 },
437 { "strings",
438 "struct getarg_strings",
439 "arg_strings",
440 defval_strings,
441 free_strings
442 },
443 { "flag",
444 "int",
445 "arg_flag",
446 defval_int,
447 NULL
448 },
449 { "-flag",
450 "int",
451 "arg_negative_flag",
452 defval_neg_flag,
453 NULL
454 },
455 { NULL, NULL, NULL, NULL, NULL }
456 };
457
find_handler(struct assignment * type)458 static struct type_handler *find_handler(struct assignment *type)
459 {
460 struct type_handler *th;
461 for(th = type_handlers; th->typename != NULL; th++)
462 if(strcmp(type->u.value, th->typename) == 0)
463 return th;
464 ex(type, "unknown type \"%s\"", type->u.value);
465 exit(1);
466 }
467
468 static void
gen_options(struct assignment * opt1,const char * name)469 gen_options(struct assignment *opt1, const char *name)
470 {
471 struct assignment *tmp;
472
473 hprint(0, "struct %s_options {\n", name);
474
475 for(tmp = opt1;
476 tmp != NULL;
477 tmp = find_next(tmp, "option")) {
478 struct assignment *type;
479 struct type_handler *th;
480 char *s;
481
482 s = make_name(tmp->u.assignment);
483 type = find(tmp->u.assignment, "type");
484 th = find_handler(type);
485 hprint(1, "%s %s;\n", th->c_type, s);
486 free(s);
487 }
488 hprint(0, "};\n");
489 }
490
491 static void
gen_wrapper(struct assignment * as)492 gen_wrapper(struct assignment *as)
493 {
494 struct assignment *name;
495 struct assignment *arg;
496 struct assignment *opt1;
497 struct assignment *function;
498 struct assignment *tmp;
499 char *n, *f;
500 int nargs = 0;
501 int narguments = 0;
502
503 name = find(as, "name");
504 n = strdup(name->u.value);
505 gen_name(n);
506 arg = find(as, "argument");
507 if (arg)
508 narguments++;
509 opt1 = find(as, "option");
510 function = find(as, "function");
511 if(function)
512 f = function->u.value;
513 else
514 f = n;
515
516
517 if(opt1 != NULL) {
518 gen_options(opt1, n);
519 hprint(0, "int %s(struct %s_options*, int, char **);\n", f, n);
520 } else {
521 hprint(0, "int %s(void*, int, char **);\n", f);
522 }
523
524 fprintf(cfile, "static int\n");
525 fprintf(cfile, "%s_wrap(int argc, char **argv)\n", n);
526 fprintf(cfile, "{\n");
527 if(opt1 != NULL)
528 cprint(1, "struct %s_options opt;\n", n);
529 cprint(1, "int ret;\n");
530 cprint(1, "int optidx = 0;\n");
531 cprint(1, "struct getargs args[] = {\n");
532 for(tmp = find(as, "option");
533 tmp != NULL;
534 tmp = find_next(tmp, "option")) {
535 struct assignment *type = find(tmp->u.assignment, "type");
536 struct assignment *lopt = find(tmp->u.assignment, "long");
537 struct assignment *sopt = find(tmp->u.assignment, "short");
538 struct assignment *aarg = find(tmp->u.assignment, "argument");
539 struct assignment *help = find(tmp->u.assignment, "help");
540
541 struct type_handler *th;
542
543 cprint(2, "{ ");
544 if(lopt)
545 fprintf(cfile, "\"%s\", ", lopt->u.value);
546 else
547 fprintf(cfile, "NULL, ");
548 if(sopt)
549 fprintf(cfile, "'%c', ", *sopt->u.value);
550 else
551 fprintf(cfile, "0, ");
552 th = find_handler(type);
553 fprintf(cfile, "%s, ", th->getarg_type);
554 fprintf(cfile, "NULL, ");
555 if(help)
556 fprintf(cfile, "\"%s\", ", help->u.value);
557 else
558 fprintf(cfile, "NULL, ");
559 if(aarg) {
560 fprintf(cfile, "\"%s\"", aarg->u.value);
561 narguments++;
562 } else
563 fprintf(cfile, "NULL");
564 fprintf(cfile, " },\n");
565 }
566 cprint(2, "{ \"help\", 'h', arg_flag, NULL, NULL, NULL }\n");
567 cprint(1, "};\n");
568 cprint(1, "int help_flag = 0;\n");
569
570 for(tmp = find(as, "option");
571 tmp != NULL;
572 tmp = find_next(tmp, "option")) {
573 char *s;
574 struct assignment *type = find(tmp->u.assignment, "type");
575
576 struct assignment *defval = find(tmp->u.assignment, "default");
577
578 struct type_handler *th;
579
580 s = make_name(tmp->u.assignment);
581 th = find_handler(type);
582 (*th->defval)(s, defval);
583 free(s);
584 }
585
586 for(tmp = find(as, "option");
587 tmp != NULL;
588 tmp = find_next(tmp, "option")) {
589 char *s;
590 s = make_name(tmp->u.assignment);
591 cprint(1, "args[%d].value = &opt.%s;\n", nargs++, s);
592 free(s);
593 }
594 cprint(1, "args[%d].value = &help_flag;\n", nargs++);
595 cprint(1, "if(getarg(args, %d, argc, argv, &optidx))\n", nargs);
596 cprint(2, "goto usage;\n");
597
598 {
599 int min_args = -1;
600 int max_args = -1;
601 char *end;
602 if(narguments == 0) {
603 max_args = 0;
604 } else {
605 if((tmp = find(as, "min_args")) != NULL) {
606 min_args = strtol(tmp->u.value, &end, 0);
607 if(*end != '\0') {
608 ex(tmp, "min_args is not numeric");
609 exit(1);
610 }
611 if(min_args < 0) {
612 ex(tmp, "min_args must be non-negative");
613 exit(1);
614 }
615 }
616 if((tmp = find(as, "max_args")) != NULL) {
617 max_args = strtol(tmp->u.value, &end, 0);
618 if(*end != '\0') {
619 ex(tmp, "max_args is not numeric");
620 exit(1);
621 }
622 if(max_args < 0) {
623 ex(tmp, "max_args must be non-negative");
624 exit(1);
625 }
626 }
627 }
628 if(min_args != -1 || max_args != -1) {
629 if(min_args == max_args) {
630 cprint(1, "if(argc - optidx != %d) {\n",
631 min_args);
632 cprint(2, "fprintf(stderr, \"Need exactly %u parameters (%%u given).\\n\\n\", argc - optidx);\n", min_args);
633 cprint(2, "goto usage;\n");
634 cprint(1, "}\n");
635 } else {
636 if(max_args != -1) {
637 cprint(1, "if(argc - optidx > %d) {\n", max_args);
638 cprint(2, "fprintf(stderr, \"Arguments given (%%u) are more than expected (%u).\\n\\n\", argc - optidx);\n", max_args);
639 cprint(2, "goto usage;\n");
640 cprint(1, "}\n");
641 }
642 if(min_args != -1) {
643 cprint(1, "if(argc - optidx < %d) {\n", min_args);
644 cprint(2, "fprintf(stderr, \"Arguments given (%%u) are less than expected (%u).\\n\\n\", argc - optidx);\n", min_args);
645 cprint(2, "goto usage;\n");
646 cprint(1, "}\n");
647 }
648 }
649 }
650 }
651
652 cprint(1, "if(help_flag)\n");
653 cprint(2, "goto usage;\n");
654
655 cprint(1, "ret = %s(%s, argc - optidx, argv + optidx);\n",
656 f, opt1 ? "&opt": "NULL");
657
658 /* free allocated data */
659 for(tmp = find(as, "option");
660 tmp != NULL;
661 tmp = find_next(tmp, "option")) {
662 char *s;
663 struct assignment *type = find(tmp->u.assignment, "type");
664 struct type_handler *th;
665 th = find_handler(type);
666 if(th->free == NULL)
667 continue;
668 s = make_name(tmp->u.assignment);
669 (*th->free)(s);
670 free(s);
671 }
672 cprint(1, "return ret;\n");
673
674 cprint(0, "usage:\n");
675 cprint(1, "arg_printusage (args, %d, \"%s\", \"%s\");\n", nargs,
676 name->u.value, arg ? arg->u.value : "");
677 /* free allocated data */
678 for(tmp = find(as, "option");
679 tmp != NULL;
680 tmp = find_next(tmp, "option")) {
681 char *s;
682 struct assignment *type = find(tmp->u.assignment, "type");
683 struct type_handler *th;
684 th = find_handler(type);
685 if(th->free == NULL)
686 continue;
687 s = make_name(tmp->u.assignment);
688 (*th->free)(s);
689 free(s);
690 }
691 cprint(1, "return 0;\n");
692 cprint(0, "}\n");
693 cprint(0, "\n");
694 }
695
696 char cname[PATH_MAX];
697 char hname[PATH_MAX];
698
699 static void
gen(struct assignment * as)700 gen(struct assignment *as)
701 {
702 struct assignment *a;
703 cprint(0, "#include <stdio.h>\n");
704 cprint(0, "#include <krb5/getarg.h>\n");
705 cprint(0, "#include <krb5/sl.h>\n");
706 cprint(0, "#include \"%s\"\n\n", hname);
707
708 hprint(0, "#include <stdio.h>\n");
709 hprint(0, "#include <krb5/sl.h>\n");
710 hprint(0, "\n");
711
712
713 for(a = as; a != NULL; a = a->next)
714 gen_wrapper(a->u.assignment);
715
716 cprint(0, "SL_cmd commands[] = {\n");
717 for(a = as; a != NULL; a = a->next)
718 gen_command(a->u.assignment);
719 cprint(1, "{ NULL, NULL, NULL, NULL }\n");
720 cprint(0, "};\n");
721
722 hprint(0, "extern SL_cmd commands[];\n");
723 }
724
725 int version_flag;
726 int help_flag;
727 struct getargs args[] = {
728 { "version", 0, arg_flag, &version_flag, NULL, NULL },
729 { "help", 0, arg_flag, &help_flag, NULL, NULL }
730 };
731 int num_args = sizeof(args) / sizeof(args[0]);
732
733 static void
usage(int code)734 usage(int code)
735 {
736 arg_printusage(args, num_args, NULL, "command-table");
737 exit(code);
738 }
739
740 int
main(int argc,char ** argv)741 main(int argc, char **argv)
742 {
743 char *p;
744
745 int optidx = 0;
746
747 setprogname(argv[0]);
748 if(getarg(args, num_args, argc, argv, &optidx))
749 usage(1);
750 if(help_flag)
751 usage(0);
752 if(version_flag) {
753 print_version(NULL);
754 exit(0);
755 }
756
757 if(argc == optidx)
758 usage(1);
759
760 filename = argv[optidx];
761 yyin = fopen(filename, "r");
762 if(yyin == NULL)
763 err(1, "%s", filename);
764 p = strrchr(filename, '/');
765 if(p)
766 strlcpy(cname, p + 1, sizeof(cname));
767 else
768 strlcpy(cname, filename, sizeof(cname));
769 p = strrchr(cname, '.');
770 if(p)
771 *p = '\0';
772 strlcpy(hname, cname, sizeof(hname));
773 strlcat(cname, ".c", sizeof(cname));
774 strlcat(hname, ".h", sizeof(hname));
775 yyparse();
776 if(error_flag)
777 exit(1);
778 if(check(assignment) == 0) {
779 cfile = fopen(cname, "w");
780 if(cfile == NULL)
781 err(1, "%s", cname);
782 hfile = fopen(hname, "w");
783 if(hfile == NULL)
784 err(1, "%s", hname);
785 gen(assignment);
786 fclose(cfile);
787 fclose(hfile);
788 }
789 fclose(yyin);
790 return 0;
791 }
792