2 /* $NetBSD: yacc.y,v 1.11 2016/06/28 09:22:16 wiz Exp $ */
6 * SPDX-License-Identifier: BSD-2-Clause
8 * Copyright (c)2003, 2006 Citrus Project,
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
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.
20 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33 #include <sys/cdefs.h>
34 #include <sys/types.h>
44 #include <arpa/inet.h>
52 #include "citrus_namespace.h"
53 #include "citrus_types.h"
54 #include "citrus_mapper_std_file.h"
55 #include "citrus_region.h"
56 #include "citrus_db_factory.h"
57 #include "citrus_db_hash.h"
58 #include "citrus_lookup_factory.h"
59 #include "citrus_pivot_factory.h"
65 static linear_zone_t rowcol[_CITRUS_MAPPER_STD_ROWCOL_MAX];
66 static char *map_name;
67 static char *output = NULL;
68 static void *table = NULL;
69 static size_t rowcol_len = 0;
70 static size_t table_size;
71 static u_int32_t done_flag = 0;
72 static u_int32_t dst_ilseq, dst_invalid, dst_unit_bits, oob_mode;
73 static u_int32_t rowcol_bits = 0, rowcol_mask = 0;
74 static u_int32_t src_next;
76 static void (*putfunc)(void *, size_t, u_int32_t) = NULL;
78 #define DF_TYPE 0x00000001
79 #define DF_NAME 0x00000002
80 #define DF_SRC_ZONE 0x00000004
81 #define DF_DST_INVALID 0x00000008
82 #define DF_DST_ILSEQ 0x00000010
83 #define DF_DST_UNIT_BITS 0x00000020
84 #define DF_OOB_MODE 0x00000040
86 static void dump_file(void);
87 static void setup_map(void);
88 static void set_type(int);
89 static void set_name(char *);
90 static void set_src_zone(u_int32_t);
91 static void set_dst_invalid(u_int32_t);
92 static void set_dst_ilseq(u_int32_t);
93 static void set_dst_unit_bits(u_int32_t);
94 static void set_oob_mode(u_int32_t);
95 static int check_src(u_int32_t, u_int32_t);
96 static void store(const linear_zone_t *, u_int32_t, int);
97 static void put8(void *, size_t, u_int32_t);
98 static void put16(void *, size_t, u_int32_t);
99 static void put32(void *, size_t, u_int32_t);
100 static void set_range(u_int32_t, u_int32_t);
101 static void set_src(linear_zone_t *, u_int32_t, u_int32_t);
107 linear_zone_t lz_value;
110 %token R_TYPE R_NAME R_SRC_ZONE R_DST_UNIT_BITS
111 %token R_DST_INVALID R_DST_ILSEQ
112 %token R_BEGIN_MAP R_END_MAP R_INVALID R_ROWCOL
113 %token R_ILSEQ R_OOB_MODE
115 %token <i_value> L_IMM
116 %token <s_value> L_STRING
119 %type <i_value> dst types oob_mode_sel zone
123 file : property mapping lns
126 property : /* empty */
131 | property dst_invalid
133 | property dst_unit_bits
136 name : R_NAME L_STRING { set_name($2); $2 = NULL; }
137 type : R_TYPE types { set_type($2); }
138 types : R_ROWCOL { $$ = R_ROWCOL; }
139 range : L_IMM '-' L_IMM { set_range($1, $3); }
144 src_zone : R_SRC_ZONE zone { set_src_zone($2); }
148 | range '/' range '/' ranges L_IMM {
152 dst_invalid : R_DST_INVALID L_IMM { set_dst_invalid($2); }
153 dst_ilseq : R_DST_ILSEQ L_IMM { set_dst_ilseq($2); }
154 dst_unit_bits : R_DST_UNIT_BITS L_IMM { set_dst_unit_bits($2); }
155 oob_mode : R_OOB_MODE oob_mode_sel { set_oob_mode($2); }
157 oob_mode_sel : R_INVALID { $$ = _CITRUS_MAPPER_STD_OOB_NONIDENTICAL; }
158 | R_ILSEQ { $$ = _CITRUS_MAPPER_STD_OOB_ILSEQ; }
160 mapping : begin_map map_elems R_END_MAP
161 begin_map : R_BEGIN_MAP lns { setup_map(); }
163 map_elems : /* empty */
164 | map_elems map_elem lns
166 map_elem : src '=' dst
167 { store(&$1, $3, 0); }
169 { store(&$1, $3, 1); }
185 set_src(&$$, src_next, src_next);
189 set_src(&$$, $1, $1);
193 set_src(&$$, $1, $3);
197 set_src(&$$, src_next, $2);
205 warning(const char *s)
208 fprintf(stderr, "%s in %d\n", s, linenumber);
212 yyerror(const char *s)
220 put8(void *ptr, size_t ofs, u_int32_t val)
223 *((u_int8_t *)ptr + ofs) = val;
227 put16(void *ptr, size_t ofs, u_int32_t val)
230 u_int16_t oval = htons(val);
231 memcpy((u_int16_t *)ptr + ofs, &oval, 2);
235 put32(void *ptr, size_t ofs, u_int32_t val)
238 u_int32_t oval = htonl(val);
239 memcpy((u_int32_t *)ptr + ofs, &oval, 4);
251 table_size = p->width;
254 table_size *= p->width;
256 table = (void *)malloc(table_size * dst_unit_bits / 8);
263 case _CITRUS_MAPPER_STD_OOB_NONIDENTICAL:
266 case _CITRUS_MAPPER_STD_OOB_ILSEQ:
272 for (i = 0; i < table_size; i++)
273 (*putfunc)(table, i, val);
280 if ((done_flag & DF_SRC_ZONE)==0) {
281 fprintf(stderr, "SRC_ZONE is mandatory.\n");
284 if ((done_flag & DF_DST_UNIT_BITS)==0) {
285 fprintf(stderr, "DST_UNIT_BITS is mandatory.\n");
289 if ((done_flag & DF_DST_INVALID) == 0)
290 dst_invalid = 0xFFFFFFFF;
291 if ((done_flag & DF_DST_ILSEQ) == 0)
292 dst_ilseq = 0xFFFFFFFE;
293 if ((done_flag & DF_OOB_MODE) == 0)
294 oob_mode = _CITRUS_MAPPER_STD_OOB_NONIDENTICAL;
300 create_rowcol_info(struct _region *r)
306 ptr = malloc(_CITRUS_MAPPER_STD_ROWCOL_INFO_SIZE);
308 err(EXIT_FAILURE, "malloc");
309 put32(ptr, ofs, rowcol_bits); ofs++;
310 put32(ptr, ofs, dst_invalid); ofs++;
312 /* XXX: keep backward compatibility */
313 switch (rowcol_len) {
315 put32(ptr, ofs, 0); ofs++;
316 put32(ptr, ofs, 0); ofs++;
324 for (i = 0; i < rowcol_len; ++i) {
325 put32(ptr, ofs, rowcol[i].begin); ofs++;
326 put32(ptr, ofs, rowcol[i].end); ofs++;
328 put32(ptr, ofs, dst_unit_bits); ofs++;
329 put32(ptr, ofs, len); ofs++;
331 _region_init(r, ptr, ofs * 4);
336 create_rowcol_ext_ilseq_info(struct _region *r)
342 ptr = malloc(_CITRUS_MAPPER_STD_ROWCOL_EXT_ILSEQ_SIZE);
344 err(EXIT_FAILURE, "malloc");
346 put32(ptr, ofs, oob_mode); ofs++;
347 put32(ptr, ofs, dst_ilseq); ofs++;
349 _region_init(r, ptr, _CITRUS_MAPPER_STD_ROWCOL_EXT_ILSEQ_SIZE);
352 #define CHKERR(ret, func, a) \
356 errx(EXIT_FAILURE, "%s: %s", #func, strerror(ret)); \
357 } while (/*CONSTCOND*/0)
362 struct _db_factory *df;
372 CHKERR(ret, _db_factory_create, (&df, _db_hash_std, NULL));
375 CHKERR(ret, _db_factory_addstr_by_s,
376 (df, _CITRUS_MAPPER_STD_SYM_TYPE, _CITRUS_MAPPER_STD_TYPE_ROWCOL));
379 create_rowcol_info(&data);
380 CHKERR(ret, _db_factory_add_by_s,
381 (df, _CITRUS_MAPPER_STD_SYM_INFO, &data, 1));
383 /* ilseq extension */
384 create_rowcol_ext_ilseq_info(&data);
385 CHKERR(ret, _db_factory_add_by_s,
386 (df, _CITRUS_MAPPER_STD_SYM_ROWCOL_EXT_ILSEQ, &data, 1));
389 _region_init(&data, table, table_size*dst_unit_bits/8);
390 CHKERR(ret, _db_factory_add_by_s,
391 (df, _CITRUS_MAPPER_STD_SYM_TABLE, &data, 1));
394 * dump database to file
396 fp = output ? fopen(output, "wb") : stdout;
403 /* dump database body */
404 size = _db_factory_calc_size(df);
405 serialized = malloc(size);
406 _region_init(&data, serialized, size);
407 CHKERR(ret, _db_factory_serialize,
408 (df, _CITRUS_MAPPER_STD_MAGIC, &data));
409 if (fwrite(serialized, size, 1, fp) != 1)
410 err(EXIT_FAILURE, "fwrite");
420 if (done_flag & DF_TYPE) {
421 warning("TYPE is duplicated. ignored this one");
427 done_flag |= DF_TYPE;
435 if (done_flag & DF_NAME) {
436 warning("NAME is duplicated. ignored this one");
442 done_flag |= DF_NAME;
446 set_src_zone(u_int32_t val)
451 if (done_flag & DF_SRC_ZONE) {
452 warning("SRC_ZONE is duplicated. ignored this one");
458 switch (rowcol_bits) {
459 case 8: case 16: case 32:
460 if (rowcol_len <= 32 / rowcol_bits)
466 rowcol_mask = 1u << (rowcol_bits - 1);
467 rowcol_mask |= rowcol_mask - 1;
468 for (i = 0; i < rowcol_len; ++i) {
470 if (p->end > rowcol_mask)
473 done_flag |= DF_SRC_ZONE;
477 yyerror("Illegal argument for SRC_ZONE");
481 set_dst_invalid(u_int32_t val)
484 if (done_flag & DF_DST_INVALID) {
485 warning("DST_INVALID is duplicated. ignored this one");
491 done_flag |= DF_DST_INVALID;
495 set_dst_ilseq(u_int32_t val)
498 if (done_flag & DF_DST_ILSEQ) {
499 warning("DST_ILSEQ is duplicated. ignored this one");
505 done_flag |= DF_DST_ILSEQ;
509 set_oob_mode(u_int32_t val)
512 if (done_flag & DF_OOB_MODE) {
513 warning("OOB_MODE is duplicated. ignored this one");
519 done_flag |= DF_OOB_MODE;
523 set_dst_unit_bits(u_int32_t val)
526 if (done_flag & DF_DST_UNIT_BITS) {
527 warning("DST_UNIT_BITS is duplicated. ignored this one");
545 yyerror("Illegal argument for DST_UNIT_BITS");
547 done_flag |= DF_DST_UNIT_BITS;
551 check_src(u_int32_t begin, u_int32_t end)
560 m = begin & ~rowcol_mask;
561 n = end & ~rowcol_mask;
565 for (i = rowcol_len * rowcol_bits, p = &rowcol[0]; i > 0; ++p) {
567 m = (begin >> i) & rowcol_mask;
568 if (m < p->begin || m > p->end)
572 n = end & rowcol_mask;
574 if (n < p->begin || n > p->end)
581 store(const linear_zone_t *lz, u_int32_t dst, int inc)
588 for (i = rowcol_len * rowcol_bits, p = &rowcol[0]; i > 0; ++p) {
590 n = ((lz->begin >> i) & rowcol_mask) - p->begin;
591 ofs = (ofs * p->width) + n;
595 (*putfunc)(table, ofs++, dst);
602 set_range(u_int32_t begin, u_int32_t end)
606 if (rowcol_len >= _CITRUS_MAPPER_STD_ROWCOL_MAX)
608 p = &rowcol[rowcol_len++];
612 p->begin = begin, p->end = end;
613 p->width = end - begin + 1;
618 yyerror("Illegal argument for SRC_ZONE");
622 set_src(linear_zone_t *lz, u_int32_t begin, u_int32_t end)
625 if (check_src(begin, end) != 0)
626 yyerror("illegal zone");
628 lz->begin = begin, lz->end = end;
629 lz->width = end - begin + 1;
640 /* dump DB to file */
641 out = output ? fopen(output, "wb") : stdout;
644 err(EXIT_FAILURE, "fopen");
646 ret = _lookup_factory_convert(out, in);
649 unlink(output); /* dump failure */
658 /* dump pivot to file */
659 out = output ? fopen(output, "wb") : stdout;
662 err(EXIT_FAILURE, "fopen");
664 ret = _pivot_factory_convert(out, in);
667 unlink(output); /* dump failure */
669 errx(EXIT_FAILURE, "%s\n", strerror(ret));
675 fprintf(stderr, "Usage: %s [-d] [-m|-p] [-o outfile] [infile]\n",
681 main(int argc, char **argv)
684 int ch, mkdb = 0, mkpv = 0;
686 while ((ch = getopt(argc, argv, "do:mp")) != EOF) {
692 output = strdup(optarg);
712 in = fopen(argv[0], "r");
714 err(EXIT_FAILURE, "%s", argv[0]);