usr.bin/mkcsmapper/yacc.y

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