style: compare return value of getopt() against -1 rather than EOF
[games.git] / usr.bin / mkcsmapper / yacc.y
1 /*      $NetBSD: yacc.y,v 1.7 2006/09/09 14:35:17 tnozaki Exp $ */
2 /*      $DragonFly: src/usr.bin/mkcsmapper/yacc.y,v 1.3 2008/07/10 18:29:51 swildner Exp $      */
3
4 %{
5 /*-
6  * Copyright (c)2003, 2006 Citrus Project,
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  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer.
14  * 2. Redistributions in binary form must reproduce the above copyright
15  *    notice, this list of conditions and the following disclaimer in the
16  *    documentation and/or other materials provided with the distribution.
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
22  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28  * SUCH DAMAGE.
29  */
30
31 #include <sys/types.h>
32 #include <assert.h>
33 #include <err.h>
34 #include <errno.h>
35 #include <limits.h>
36 #include <stdio.h>
37 #include <stdlib.h>
38 #include <string.h>
39 #include <unistd.h>
40
41 #include <netinet/in.h>
42
43 #include "ldef.h"
44
45 #include "citrus_namespace.h"
46 #include "citrus_types.h"
47 #include "citrus_mapper_std_file.h"
48 #include "citrus_region.h"
49 #include "citrus_db_factory.h"
50 #include "citrus_db_hash.h"
51 #include "citrus_lookup_factory.h"
52 #include "citrus_pivot_factory.h"
53
54 extern FILE *   yyin;
55
56 int                     debug = 0;
57 static char             *output = NULL;
58 static void             *table = NULL;
59 static size_t           table_size;
60 static char             *map_name;
61 static int              map_type;
62 static u_int32_t        dst_invalid, dst_ilseq, oob_mode, dst_unit_bits;
63 static void             (*putfunc)(void *, size_t, u_int32_t) = 0;
64
65 static u_int32_t        src_next;
66
67 static u_int32_t        done_flag = 0;
68 #define DF_TYPE                 0x00000001
69 #define DF_NAME                 0x00000002
70 #define DF_SRC_ZONE             0x00000004
71 #define DF_DST_INVALID          0x00000008
72 #define DF_DST_ILSEQ            0x00000010
73 #define DF_DST_UNIT_BITS        0x00000020
74 #define DF_OOB_MODE             0x00000040
75
76 static linear_zone_t    rowcol[_CITRUS_MAPPER_STD_ROWCOL_MAX];
77 static size_t           rowcol_len = 0;
78 static u_int32_t        rowcol_bits = 0, rowcol_mask = 0;
79
80 static void     dump_file(void);
81 static void     setup_map(void);
82 static void     set_type(int);
83 static void     set_name(char *);
84 static void     set_src_zone(u_int32_t);
85 static void     set_dst_invalid(u_int32_t);
86 static void     set_dst_ilseq(u_int32_t);
87 static void     set_dst_unit_bits(u_int32_t);
88 static void     set_oob_mode(u_int32_t);
89 static int      check_src(u_int32_t, u_int32_t);
90 static void     store(const linear_zone_t *, u_int32_t, int);
91 static void     put8(void *, size_t, u_int32_t);
92 static void     put16(void *, size_t, u_int32_t);
93 static void     put32(void *, size_t, u_int32_t);
94 static void     set_range(u_int32_t, u_int32_t);
95 static void     set_src(linear_zone_t *, u_int32_t, u_int32_t);
96 %}
97
98 %union {
99         u_int32_t       i_value;
100         char            *s_value;
101         linear_zone_t   lz_value;
102 }
103
104 %token                  R_TYPE R_NAME R_SRC_ZONE R_DST_UNIT_BITS
105 %token                  R_DST_INVALID R_DST_ILSEQ
106 %token                  R_BEGIN_MAP R_END_MAP R_INVALID R_ROWCOL
107 %token                  R_ILSEQ R_OOB_MODE
108 %token                  R_LN
109 %token <i_value>        L_IMM
110 %token <s_value>        L_STRING
111
112 %type <lz_value>        src
113 %type <i_value>         dst types oob_mode_sel zone
114
115 %%
116
117 file            : property mapping lns
118                 { dump_file(); }
119
120 property        : /* empty */
121                 | property R_LN
122                 | property name
123                 | property type
124                 | property src_zone
125                 | property dst_invalid
126                 | property dst_ilseq
127                 | property dst_unit_bits
128                 | property oob_mode
129
130 name            : R_NAME L_STRING { set_name($2); $2 = NULL; }
131 type            : R_TYPE types { set_type($2); }
132 types           : R_ROWCOL { $$ = R_ROWCOL; }
133 range           : L_IMM '-' L_IMM { set_range($1, $3); }
134
135 ranges          : /* empty */
136                 | ranges range '/'
137
138 src_zone        : R_SRC_ZONE zone { set_src_zone($2); }
139 zone            : range {
140                         $$ = 32;
141                 }
142                 | range '/' range '/' ranges L_IMM {
143                         $$ = $6;
144                 }
145
146 dst_invalid     : R_DST_INVALID L_IMM { set_dst_invalid($2); }
147 dst_ilseq       : R_DST_ILSEQ L_IMM { set_dst_ilseq($2); }
148 dst_unit_bits   : R_DST_UNIT_BITS L_IMM { set_dst_unit_bits($2); }
149 oob_mode        : R_OOB_MODE oob_mode_sel { set_oob_mode($2); }
150
151 oob_mode_sel    : R_INVALID { $$ = _CITRUS_MAPPER_STD_OOB_NONIDENTICAL; }
152                 | R_ILSEQ { $$ = _CITRUS_MAPPER_STD_OOB_ILSEQ; }
153
154 mapping         : begin_map map_elems R_END_MAP
155 begin_map       : R_BEGIN_MAP lns { setup_map(); }
156
157 map_elems       : /* empty */
158                 | map_elems map_elem lns
159
160 map_elem        : src '=' dst
161                 { store(&$1, $3, 0); }
162                 | src '=' L_IMM '-'
163                 { store(&$1, $3, 1); }
164 dst             : L_IMM
165                 {
166                         $$ = $1;
167                 }
168                 | R_INVALID
169                 {
170                         $$ = dst_invalid;
171                 }
172                 | R_ILSEQ
173                 {
174                         $$ = dst_ilseq;
175                 }
176
177 src             : /* empty */
178                 {
179                         set_src(&$$, src_next, src_next);
180                 }
181                 | L_IMM
182                 {
183                         set_src(&$$, $1, $1);
184                 }
185                 | L_IMM '-' L_IMM
186                 {
187                         set_src(&$$, $1, $3);
188                 }
189                 | '-' L_IMM
190                 {
191                         set_src(&$$, src_next, $2);
192                 }
193 lns             : R_LN
194                 | lns R_LN
195
196 %%
197
198 static void
199 warning(const char *s)
200 {
201         fprintf(stderr, "%s in %d\n", s, line_number);
202 }
203
204 int
205 yyerror(const char *s)
206 {
207         warning(s);
208         exit(1);
209 }
210
211 void
212 put8(void *ptr, size_t ofs, u_int32_t val)
213 {
214         *((u_int8_t *)ptr + ofs) = val;
215 }
216
217 void
218 put16(void *ptr, size_t ofs, u_int32_t val)
219 {
220         u_int16_t oval = htons(val);
221         memcpy((u_int16_t *)ptr + ofs, &oval, 2);
222 }
223
224 void
225 put32(void *ptr, size_t ofs, u_int32_t val)
226 {
227         u_int32_t oval = htonl(val);
228         memcpy((u_int32_t *)ptr + ofs, &oval, 4);
229 }
230
231 static void
232 alloc_table(void)
233 {
234         size_t i;
235         u_int32_t val = 0;
236         linear_zone_t *p;
237
238         i = rowcol_len;
239         p = &rowcol[--i];
240         table_size = p->width;
241         while (i > 0) {
242                 p = &rowcol[--i];
243                 table_size *= p->width;
244         }
245         table = (void *)malloc(table_size * dst_unit_bits / 8);
246         if (table == NULL) {
247                 perror("malloc");
248                 exit(1);
249         }
250
251         switch (oob_mode) {
252         case _CITRUS_MAPPER_STD_OOB_NONIDENTICAL:
253                 val = dst_invalid;
254                 break;
255         case _CITRUS_MAPPER_STD_OOB_ILSEQ:
256                 val = dst_ilseq;
257                 break;
258         default:
259                 ;
260         }
261         for (i = 0; i < table_size; i++)
262                 (*putfunc)(table, i, val);
263 }
264
265 static void
266 setup_map(void)
267 {
268
269         if ((done_flag & DF_SRC_ZONE)==0) {
270                 fprintf(stderr, "SRC_ZONE is mandatory.\n");
271                 exit(1);
272         }
273         if ((done_flag & DF_DST_UNIT_BITS)==0) {
274                 fprintf(stderr, "DST_UNIT_BITS is mandatory.\n");
275                 exit(1);
276         }
277
278         if ((done_flag & DF_DST_INVALID) == 0)
279                 dst_invalid = 0xFFFFFFFF;
280         if ((done_flag & DF_DST_ILSEQ) == 0)
281                 dst_ilseq = 0xFFFFFFFE;
282         if ((done_flag & DF_OOB_MODE) == 0)
283                 oob_mode = _CITRUS_MAPPER_STD_OOB_NONIDENTICAL;
284
285         alloc_table();
286 }
287
288 static void
289 create_rowcol_info(struct _region *r)
290 {
291         void *ptr;
292         size_t ofs, i, len;
293
294         ofs = 0;
295         ptr = malloc(_CITRUS_MAPPER_STD_ROWCOL_INFO_SIZE);
296         if (ptr == NULL)
297                 err(EXIT_FAILURE, "malloc");
298         put32(ptr, ofs, rowcol_bits); ofs++;
299         put32(ptr, ofs, dst_invalid); ofs++;
300
301         /* XXX: keep backward compatibility */
302         switch (rowcol_len) {
303         case 1:
304                 put32(ptr, ofs, 0); ofs++;
305                 put32(ptr, ofs, 0); ofs++;
306         /*FALLTHROUGH*/
307         case 2:
308                 len = 0;
309                 break;
310         default:
311                 len = rowcol_len;
312         }
313         for (i = 0; i < rowcol_len; ++i) {
314                 put32(ptr, ofs, rowcol[i].begin); ofs++;
315                 put32(ptr, ofs, rowcol[i].end); ofs++;
316         }
317         put32(ptr, ofs, dst_unit_bits); ofs++;
318         put32(ptr, ofs, len); ofs++;
319
320         _region_init(r, ptr, ofs * 4);
321 }
322
323
324 static void
325 create_rowcol_ext_ilseq_info(struct _region *r)
326 {
327         void *ptr;
328         size_t ofs;
329
330         ofs = 0;
331         ptr = malloc(_CITRUS_MAPPER_STD_ROWCOL_EXT_ILSEQ_SIZE);
332         if (ptr==NULL)
333                 err(EXIT_FAILURE, "malloc");
334
335         put32(ptr, ofs, oob_mode); ofs++;
336         put32(ptr, ofs, dst_ilseq); ofs++;
337
338         _region_init(r, ptr, _CITRUS_MAPPER_STD_ROWCOL_EXT_ILSEQ_SIZE);
339 }
340
341 #define CHKERR(ret, func, a)                                            \
342 do {                                                                    \
343         ret = func a;                                                   \
344         if (ret)                                                        \
345                 errx(EXIT_FAILURE, "%s: %s", #func, strerror(ret));     \
346 } while (/*CONSTCOND*/0)
347
348 static void
349 dump_file(void)
350 {
351         FILE *fp;
352         int ret;
353         struct _db_factory *df;
354         struct _region data;
355         void *serialized;
356         size_t size;
357
358         /*
359          * build database
360          */
361         CHKERR(ret, _db_factory_create, (&df, _db_hash_std, NULL));
362
363         /* store type */
364         CHKERR(ret, _db_factory_addstr_by_s,
365                (df, _CITRUS_MAPPER_STD_SYM_TYPE,
366                 _CITRUS_MAPPER_STD_TYPE_ROWCOL));
367
368         /* store info */
369         create_rowcol_info(&data);
370         CHKERR(ret, _db_factory_add_by_s,
371                (df, _CITRUS_MAPPER_STD_SYM_INFO, &data, 1));
372
373         /* ilseq extension */
374         create_rowcol_ext_ilseq_info(&data);
375         CHKERR(ret, _db_factory_add_by_s,
376                (df, _CITRUS_MAPPER_STD_SYM_ROWCOL_EXT_ILSEQ, &data, 1));
377
378         /* store table */
379         _region_init(&data, table, table_size*dst_unit_bits/8);
380         CHKERR(ret, _db_factory_add_by_s,
381                (df, _CITRUS_MAPPER_STD_SYM_TABLE, &data, 1));
382
383         /*
384          * dump database to file
385          */
386         if (output)
387                 fp = fopen(output, "wb");
388         else
389                 fp = stdout;
390
391         if (fp == NULL) {
392                 perror("fopen");
393                 exit(1);
394         }
395
396         /* dump database body */
397         size = _db_factory_calc_size(df);
398         serialized = malloc(size);
399         _region_init(&data, serialized, size);
400         CHKERR(ret, _db_factory_serialize,
401                (df, _CITRUS_MAPPER_STD_MAGIC, &data));
402         if (fwrite(serialized, size, 1, fp) != 1)
403                 err(EXIT_FAILURE, "fwrite");
404
405         fclose(fp);
406 }
407
408 static void
409 /*ARGSUSED*/
410 set_type(int type)
411 {
412
413         if (done_flag & DF_TYPE) {
414                 warning("TYPE is duplicated. ignored this one");
415                 return;
416         }
417
418         map_type = type;
419
420         done_flag |= DF_TYPE;
421 }
422 static void
423 /*ARGSUSED*/
424 set_name(char *str)
425 {
426
427         if (done_flag & DF_NAME) {
428                 warning("NAME is duplicated. ignored this one");
429                 return;
430         }
431
432         map_name = str;
433
434         done_flag |= DF_NAME;
435 }
436 static void
437 set_src_zone(u_int32_t val)
438 {
439         size_t i;
440         linear_zone_t *p;
441
442         if (done_flag & DF_SRC_ZONE) {
443                 warning("SRC_ZONE is duplicated. ignored this one");
444                 return;
445         }
446         rowcol_bits = val;
447
448         /* sanity check */
449         switch (rowcol_bits) {
450         case 8: case 16: case 32:
451                 if (rowcol_len <= 32 / rowcol_bits)
452                         break;
453         /*FALLTHROUGH*/
454         default: 
455                 goto bad;
456         }
457         rowcol_mask = 1 << (rowcol_bits - 1);
458         rowcol_mask |= rowcol_mask - 1;
459         for (i = 0; i < rowcol_len; ++i) {
460                 p = &rowcol[i];
461                 _DIAGASSERT(p->begin <= p->end);
462                 if (p->end > rowcol_mask)
463                         goto bad;
464         }
465         done_flag |= DF_SRC_ZONE;
466         return;
467
468 bad:
469         yyerror("Illegal argument for SRC_ZONE");
470 }
471 static void
472 set_dst_invalid(u_int32_t val)
473 {
474
475         if (done_flag & DF_DST_INVALID) {
476                 warning("DST_INVALID is duplicated. ignored this one");
477                 return;
478         }
479
480         dst_invalid = val;
481
482         done_flag |= DF_DST_INVALID;
483 }
484 static void
485 set_dst_ilseq(u_int32_t val)
486 {
487
488         if (done_flag & DF_DST_ILSEQ) {
489                 warning("DST_ILSEQ is duplicated. ignored this one");
490                 return;
491         }
492
493         dst_ilseq = val;
494
495         done_flag |= DF_DST_ILSEQ;
496 }
497 static void
498 set_oob_mode(u_int32_t val)
499 {
500
501         if (done_flag & DF_OOB_MODE) {
502                 warning("OOB_MODE is duplicated. ignored this one");
503                 return;
504         }
505
506         oob_mode = val;
507
508         done_flag |= DF_OOB_MODE;
509 }
510 static void
511 set_dst_unit_bits(u_int32_t val)
512 {
513
514         if (done_flag & DF_DST_UNIT_BITS) {
515                 warning("DST_UNIT_BITS is duplicated. ignored this one");
516                 return;
517         }
518
519         switch (val) {
520         case 8:
521                 putfunc = &put8;
522                 dst_unit_bits = val;
523                 break;
524         case 16:
525                 putfunc = &put16;
526                 dst_unit_bits = val;
527                 break;
528         case 32:
529                 putfunc = &put32;
530                 dst_unit_bits = val;
531                 break;
532         default:
533                 yyerror("Illegal argument for DST_UNIT_BITS");
534         }
535         done_flag |= DF_DST_UNIT_BITS;
536 }
537 static int
538 check_src(u_int32_t begin, u_int32_t end)
539 {
540         size_t i;
541         linear_zone_t *p;
542         u_int32_t m, n;
543
544         if (begin > end)
545                 return 1;
546         if (begin < end) {
547                 m = begin & ~rowcol_mask;
548                 n = end & ~rowcol_mask;
549                 if (m != n)
550                         return 1;
551         }
552         for (i = rowcol_len * rowcol_bits, p = &rowcol[0]; i > 0; ++p) {
553                 i -= rowcol_bits;
554                 m = (begin >> i) & rowcol_mask;
555                 if (m < p->begin || m > p->end)
556                         return 1;
557         }
558         if (begin < end) {
559                 n = end & rowcol_mask;
560                 _DIAGASSERT(p > rowcol);
561                 --p;
562                 if (n < p->begin || n > p->end)
563                         return 1;
564         }
565         return 0;
566 }
567 static void
568 store(const linear_zone_t *lz, u_int32_t dst, int inc)
569 {
570         size_t i, ofs;
571         linear_zone_t *p;
572         u_int32_t n;
573
574         ofs = 0;
575         for (i = rowcol_len * rowcol_bits, p = &rowcol[0]; i > 0; ++p) {
576                 i -= rowcol_bits;
577                 n = ((lz->begin >> i) & rowcol_mask) - p->begin;
578                 ofs = (ofs * p->width) + n;
579         }
580         n = lz->width;
581         while (n-- > 0) {
582                 (*putfunc)(table, ofs++, dst);
583                 if (inc)
584                         dst++;
585         }
586 }
587 static void
588 set_range(u_int32_t begin, u_int32_t end)
589 {
590         linear_zone_t *p;
591
592         if (rowcol_len >= _CITRUS_MAPPER_STD_ROWCOL_MAX)
593                 goto bad;
594         p = &rowcol[rowcol_len++];
595
596         if (begin > end)
597                 goto bad;
598         p->begin = begin, p->end = end;
599         p->width = end - begin + 1;
600
601         return;
602
603 bad:
604         yyerror("Illegal argument for SRC_ZONE");
605 }
606 static void
607 set_src(linear_zone_t *lz, u_int32_t begin, u_int32_t end)
608 {
609         _DIAGASSERT(lz != NULL);
610
611         if (check_src(begin, end) != 0)
612                 yyerror("illegal zone");
613
614         lz->begin = begin, lz->end = end;
615         lz->width = end - begin + 1;
616
617         src_next = end + 1;
618 }
619
620 static void
621 do_mkdb(FILE *in)
622 {
623         int ret;
624         FILE *out;
625
626         /* dump DB to file */
627         if (output)
628                 out = fopen(output, "wb");
629         else
630                 out = stdout;
631
632         if (out==NULL)
633                 err(EXIT_FAILURE, "fopen");
634
635         ret = _lookup_factory_convert(out, in);
636         fclose(out);
637         if (ret && output)
638                 unlink(output); /* dump failure */
639 }
640
641 static void
642 do_mkpv(FILE *in)
643 {
644         int ret;
645         FILE *out;
646
647         /* dump pivot to file */
648         if (output)
649                 out = fopen(output, "wb");
650         else
651                 out = stdout;
652
653         if (out==NULL)
654                 err(EXIT_FAILURE, "fopen");
655
656         ret = _pivot_factory_convert(out, in);
657         fclose(out);
658         if (ret && output)
659                 unlink(output); /* dump failure */
660         if (ret)
661                 errx(EXIT_FAILURE, "%s\n", strerror(ret));
662 }
663
664 static void
665 usage(void)
666 {
667         warnx("usage: \n"
668               "\t%s [-d] [-o outfile] [infile]\n"
669               "\t%s -m [-d] [-o outfile] [infile]\n"
670               "\t%s -p [-d] [-o outfile] [infile]\n",
671               getprogname(), getprogname(), getprogname());
672         exit(1);
673 }
674
675 int
676 main(int argc, char **argv)
677 {
678         int ch;
679         FILE *in = NULL;
680         int mkdb = 0, mkpv = 0;
681
682         while ((ch = getopt(argc, argv, "do:mp")) != -1) {
683                 switch (ch) {
684                 case 'd':
685                         debug=1;
686                         break;
687                 case 'o':
688                         output = strdup(optarg);
689                         break;
690                 case 'm':
691                         mkdb = 1;
692                         break;
693                 case 'p':
694                         mkpv = 1;
695                         break;
696                 default:
697                         usage();
698                 }
699         }
700
701         argc-=optind;
702         argv+=optind;
703         switch (argc) {
704         case 0:
705                 in = stdin;
706                 break;
707         case 1:
708                 in = fopen(argv[0], "r");
709                 if (!in)
710                         err(EXIT_FAILURE, argv[0]);
711                 break;
712         default:
713                 usage();
714         }
715
716         if (mkdb)
717                 do_mkdb(in);
718         else if (mkpv)
719                 do_mkpv(in);
720         else {
721                 yyin = in;
722                 yyparse();
723         }
724
725         return (0);
726 }