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