usr.bin/mkesdb/yacc.y

   1 /*      $NetBSD: src/usr.bin/mkesdb/yacc.y,v 1.3 2004/01/02 12:09:48 itojun Exp $       */
   2 /*      $DragonFly: src/usr.bin/mkesdb/yacc.y,v 1.2 2008/07/10 18:29:51 swildner 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 <sys/queue.h>
  33 #include <assert.h>
  34 #include <err.h>
  35 #include <errno.h>
  36 #include <limits.h>
  37 #include <stdio.h>
  38 #include <stdlib.h>
  39 #include <string.h>
  40 #include <unistd.h>
  41
  42 #include "citrus_namespace.h"
  43 #include "citrus_types.h"
  44 #include "citrus_region.h"
  45 #include "citrus_esdb_file.h"
  46 #include "citrus_db_hash.h"
  47 #include "citrus_db_factory.h"
  48 #include "citrus_lookup_factory.h"
  49
  50 #include "ldef.h"
  51
  52 extern FILE     *yyin;
  53
  54 static int                      debug = 0, num_csids = 0;
  55 static char                     *output = NULL;
  56 static char                     *name, *encoding, *variable;
  57 static uint32_t                 invalid;
  58 static int                      use_invalid = 0;
  59 static struct named_csid_list   named_csids;
  60
  61 static void     dump_file(void);
  62 static void     register_named_csid(char *, uint32_t);
  63 static void     set_prop_string(const char *, char **, char **);
  64 static void     set_invalid(uint32_t);
  65 %}
  66 %union {
  67         uint32_t        i_value;
  68         char            *s_value;
  69 }
  70
  71 %token                  R_NAME R_ENCODING R_VARIABLE R_DEFCSID R_INVALID
  72 %token                  R_LN
  73 %token <i_value>        L_IMM
  74 %token <s_value>        L_STRING
  75
  76 %%
  77
  78 file            : property
  79                 { dump_file(); }
  80
  81 property        : /* empty */
  82                 | property R_LN
  83                 | property name R_LN
  84                 | property encoding R_LN
  85                 | property variable R_LN
  86                 | property defcsid R_LN
  87                 | property invalid R_LN
  88
  89 name            : R_NAME L_STRING
  90                 {
  91                         set_prop_string("NAME", &name, &$2);
  92                 }
  93
  94 encoding        : R_ENCODING L_STRING
  95                 {
  96                         set_prop_string("ENCODING", &encoding, &$2);
  97                 }
  98 variable        : R_VARIABLE L_STRING
  99                 {
 100                         set_prop_string("VARIABLE", &variable, &$2);
 101                 }
 102 defcsid         : R_DEFCSID L_STRING L_IMM
 103                 {
 104                         register_named_csid($2, $3);
 105                         $2 = NULL;
 106                 }
 107 invalid         : R_INVALID L_IMM
 108                 {
 109                         set_invalid($2);
 110                 }
 111 %%
 112
 113 int
 114 yyerror(const char *s)
 115 {
 116         fprintf(stderr, "%s in %d\n", s, line_number);
 117
 118         return (0);
 119 }
 120
 121 #define CHKERR(ret, func, a)                                            \
 122 do {                                                                    \
 123         ret = func a;                                                   \
 124         if (ret)                                                        \
 125                 errx(EXIT_FAILURE, "%s: %s", #func, strerror(ret));     \
 126 } while (/*CONSTCOND*/0)
 127 static void
 128 dump_file(void)
 129 {
 130         int ret;
 131         FILE *fp;
 132         struct _db_factory *df;
 133         struct _region data;
 134         struct named_csid *csid;
 135         char buf[100];
 136         int i;
 137         void *serialized;
 138         size_t size;
 139
 140         ret = 0;
 141         if (!name) {
 142                 fprintf(stderr, "NAME is mandatory.\n");
 143                 ret = 1;
 144         }
 145         if (!encoding) {
 146                 fprintf(stderr, "ENCODING is mandatory.\n");
 147                 ret = 1;
 148         }
 149         if (ret)
 150                 exit(1);
 151
 152         /*
 153          * build database
 154          */
 155         CHKERR(ret, _db_factory_create, (&df, _db_hash_std, NULL));
 156
 157         /* store version */
 158         CHKERR(ret, _db_factory_add32_by_s, (df, _CITRUS_ESDB_SYM_VERSION,
 159                                              _CITRUS_ESDB_VERSION));
 160
 161         /* store encoding */
 162         CHKERR(ret, _db_factory_addstr_by_s, (df, _CITRUS_ESDB_SYM_ENCODING,
 163                                               encoding));
 164
 165         /* store variable */
 166         if (variable)
 167                 CHKERR(ret, _db_factory_addstr_by_s,
 168                        (df, _CITRUS_ESDB_SYM_VARIABLE, variable));
 169
 170         /* store invalid */
 171         if (use_invalid)
 172                 CHKERR(ret, _db_factory_add32_by_s, (df,
 173                                                      _CITRUS_ESDB_SYM_INVALID,
 174                                                      invalid));
 175
 176         /* store num of charsets */
 177         CHKERR(ret, _db_factory_add32_by_s, (df, _CITRUS_ESDB_SYM_NUM_CHARSETS,
 178                                              num_csids));
 179         i=0;
 180         STAILQ_FOREACH(csid, &named_csids, ci_entry) {
 181                 snprintf(buf, sizeof(buf), _CITRUS_ESDB_SYM_CSNAME_PREFIX "%d",
 182                     i);
 183                 CHKERR(ret, _db_factory_addstr_by_s,
 184                        (df, buf, csid->ci_symbol));
 185                 snprintf(buf, sizeof(buf), _CITRUS_ESDB_SYM_CSID_PREFIX "%d",
 186                     i);
 187                 CHKERR(ret, _db_factory_add32_by_s, (df, buf, csid->ci_csid));
 188                 i++;
 189         }
 190
 191         /*
 192          * dump database to file
 193          */
 194         if (output)
 195                 fp = fopen(output, "wb");
 196         else
 197                 fp = stdout;
 198
 199         if (fp == NULL) {
 200                 perror("fopen");
 201                 exit(1);
 202         }
 203
 204         /* dump database body */
 205         size = _db_factory_calc_size(df);
 206         serialized = malloc(size);
 207         _region_init(&data, serialized, size);
 208         CHKERR(ret, _db_factory_serialize, (df, _CITRUS_ESDB_MAGIC, &data));
 209         if (fwrite(serialized, size, 1, fp) != 1)
 210                 err(EXIT_FAILURE, "fwrite");
 211
 212         fclose(fp);
 213 }
 214
 215 static void
 216 set_prop_string(const char *res, char **store, char **data)
 217 {
 218         char buf[256];
 219
 220         if (*store) {
 221                 snprintf(buf, sizeof(buf),
 222                          "%s is duplicated. ignored the one", res);
 223                 yyerror(buf);
 224                 return;
 225         }
 226
 227         *store = *data;
 228         *data = NULL;
 229 }
 230
 231 static void
 232 set_invalid(uint32_t inv)
 233 {
 234         invalid = inv;
 235         use_invalid = 1;
 236 }
 237
 238 static void
 239 register_named_csid(char *sym, uint32_t val)
 240 {
 241         struct named_csid *csid;
 242
 243         STAILQ_FOREACH(csid, &named_csids, ci_entry) {
 244                 if (strcmp(csid->ci_symbol, sym) == 0) {
 245                         yyerror("multiply defined CSID");
 246                         exit(1);
 247                 }
 248         }
 249
 250         csid = malloc(sizeof(*csid));
 251         if (csid == NULL) {
 252                 perror("malloc");
 253                 exit(1);
 254         }
 255         csid->ci_symbol = sym;
 256         csid->ci_csid = val;
 257         STAILQ_INSERT_TAIL(&named_csids, csid, ci_entry);
 258         num_csids++;
 259 }
 260
 261 static void
 262 do_mkdb(FILE *in)
 263 {
 264         int ret;
 265         FILE *out;
 266
 267         /* dump DB to file */
 268         if (output)
 269                 out = fopen(output, "wb");
 270         else
 271                 out = stdout;
 272
 273         if (out==NULL)
 274                 err(EXIT_FAILURE, "fopen");
 275
 276         ret = _lookup_factory_convert(out, in);
 277         fclose(out);
 278         if (ret && output)
 279                 unlink(output); /* dump failure */
 280         if (ret)
 281                 errx(EXIT_FAILURE, "%s\n", strerror(ret));
 282 }
 283
 284 static void
 285 usage(void)
 286 {
 287         errx(EXIT_FAILURE,
 288              "usage:\n"
 289              "\t%s [-o outfile] [infile]\n"
 290              "\t%s -m [-o outfile] [infile]",
 291              getprogname(), getprogname());
 292 }
 293
 294 int
 295 main(int argc, char **argv)
 296 {
 297         int ch;
 298         FILE *in = NULL;
 299         int mkdb = 0;
 300
 301         while ((ch=getopt(argc, argv, "do:m")) != -1) {
 302                 switch (ch) {
 303                 case 'd':
 304                         debug = 1;
 305                         break;
 306                 case 'o':
 307                         output = strdup(optarg);
 308                         break;
 309                 case 'm':
 310                         mkdb = 1;
 311                         break;
 312                 default:
 313                         usage();
 314                 }
 315         }
 316
 317         argc-=optind;
 318         argv+=optind;
 319         switch (argc) {
 320         case 0:
 321                 in = stdin;
 322                 break;
 323         case 1:
 324                 in = fopen(argv[0], "r");
 325                 if (!in)
 326                         err(EXIT_FAILURE, argv[0]);
 327                 break;
 328         default:
 329                 usage();
 330         }
 331
 332         if (mkdb)
 333                 do_mkdb(in);
 334         else {
 335                 STAILQ_INIT(&named_csids);
 336                 yyin=in;
 337                 yyparse();
 338         }
 339
 340         return (0);
 341 }