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
   3 %{
   4 /*-
   5  * Copyright (c)2003 Citrus Project,
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  */
  29
  30 #include <sys/types.h>
  31 #include <sys/queue.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 "citrus_namespace.h"
  42 #include "citrus_types.h"
  43 #include "citrus_region.h"
  44 #include "citrus_esdb_file.h"
  45 #include "citrus_db_hash.h"
  46 #include "citrus_db_factory.h"
  47 #include "citrus_lookup_factory.h"
  48
  49 #include "ldef.h"
  50
  51 extern FILE     *yyin;
  52
  53 static int                      debug = 0, num_csids = 0;
  54 static char                     *output = NULL;
  55 static char                     *name, *encoding, *variable;
  56 static uint32_t                 invalid;
  57 static int                      use_invalid = 0;
  58 static struct named_csid_list   named_csids;
  59
  60 static void     dump_file(void);
  61 static void     register_named_csid(char *, uint32_t);
  62 static void     set_prop_string(const char *, char **, char **);
  63 static void     set_invalid(uint32_t);
  64
  65 int yylex (void);
  66 %}
  67 %union {
  68         uint32_t        i_value;
  69         char            *s_value;
  70 }
  71
  72 %token                  R_NAME R_ENCODING R_VARIABLE R_DEFCSID R_INVALID
  73 %token                  R_LN
  74 %token <i_value>        L_IMM
  75 %token <s_value>        L_STRING
  76
  77 %%
  78
  79 file            : property
  80                 { dump_file(); }
  81
  82 property        : /* empty */
  83                 | property R_LN
  84                 | property name R_LN
  85                 | property encoding R_LN
  86                 | property variable R_LN
  87                 | property defcsid R_LN
  88                 | property invalid R_LN
  89
  90 name            : R_NAME L_STRING
  91                 {
  92                         set_prop_string("NAME", &name, &$2);
  93                 }
  94
  95 encoding        : R_ENCODING L_STRING
  96                 {
  97                         set_prop_string("ENCODING", &encoding, &$2);
  98                 }
  99 variable        : R_VARIABLE L_STRING
 100                 {
 101                         set_prop_string("VARIABLE", &variable, &$2);
 102                 }
 103 defcsid         : R_DEFCSID L_STRING L_IMM
 104                 {
 105                         register_named_csid($2, $3);
 106                         $2 = NULL;
 107                 }
 108 invalid         : R_INVALID L_IMM
 109                 {
 110                         set_invalid($2);
 111                 }
 112 %%
 113
 114 int
 115 yyerror(const char *s)
 116 {
 117         fprintf(stderr, "%s in %d\n", s, aline_number);
 118
 119         return (0);
 120 }
 121
 122 #define CHKERR(ret, func, a)                                            \
 123 do {                                                                    \
 124         ret = func a;                                                   \
 125         if (ret)                                                        \
 126                 errx(EXIT_FAILURE, "%s: %s", #func, strerror(ret));     \
 127 } while (/*CONSTCOND*/0)
 128 static void
 129 dump_file(void)
 130 {
 131         int ret;
 132         FILE *fp;
 133         struct _db_factory *df;
 134         struct _region data;
 135         struct named_csid *csid;
 136         char buf[100];
 137         int i;
 138         void *serialized;
 139         size_t size;
 140
 141         ret = 0;
 142         if (!name) {
 143                 fprintf(stderr, "NAME is mandatory.\n");
 144                 ret = 1;
 145         }
 146         if (!encoding) {
 147                 fprintf(stderr, "ENCODING is mandatory.\n");
 148                 ret = 1;
 149         }
 150         if (ret)
 151                 exit(1);
 152
 153         /*
 154          * build database
 155          */
 156         CHKERR(ret, _db_factory_create, (&df, _db_hash_std, NULL));
 157
 158         /* store version */
 159         CHKERR(ret, _db_factory_add32_by_s, (df, _CITRUS_ESDB_SYM_VERSION,
 160                                              _CITRUS_ESDB_VERSION));
 161
 162         /* store encoding */
 163         CHKERR(ret, _db_factory_addstr_by_s, (df, _CITRUS_ESDB_SYM_ENCODING,
 164                                               encoding));
 165
 166         /* store variable */
 167         if (variable)
 168                 CHKERR(ret, _db_factory_addstr_by_s,
 169                        (df, _CITRUS_ESDB_SYM_VARIABLE, variable));
 170
 171         /* store invalid */
 172         if (use_invalid)
 173                 CHKERR(ret, _db_factory_add32_by_s, (df,
 174                                                      _CITRUS_ESDB_SYM_INVALID,
 175                                                      invalid));
 176
 177         /* store num of charsets */
 178         CHKERR(ret, _db_factory_add32_by_s, (df, _CITRUS_ESDB_SYM_NUM_CHARSETS,
 179                                              num_csids));
 180         i=0;
 181         STAILQ_FOREACH(csid, &named_csids, ci_entry) {
 182                 snprintf(buf, sizeof(buf), _CITRUS_ESDB_SYM_CSNAME_PREFIX "%d",
 183                     i);
 184                 CHKERR(ret, _db_factory_addstr_by_s,
 185                        (df, buf, csid->ci_symbol));
 186                 snprintf(buf, sizeof(buf), _CITRUS_ESDB_SYM_CSID_PREFIX "%d",
 187                     i);
 188                 CHKERR(ret, _db_factory_add32_by_s, (df, buf, csid->ci_csid));
 189                 i++;
 190         }
 191
 192         /*
 193          * dump database to file
 194          */
 195         if (output)
 196                 fp = fopen(output, "wb");
 197         else
 198                 fp = stdout;
 199
 200         if (fp == NULL) {
 201                 perror("fopen");
 202                 exit(1);
 203         }
 204
 205         /* dump database body */
 206         size = _db_factory_calc_size(df);
 207         serialized = malloc(size);
 208         _region_init(&data, serialized, size);
 209         CHKERR(ret, _db_factory_serialize, (df, _CITRUS_ESDB_MAGIC, &data));
 210         if (fwrite(serialized, size, 1, fp) != 1)
 211                 err(EXIT_FAILURE, "fwrite");
 212
 213         fclose(fp);
 214 }
 215
 216 static void
 217 set_prop_string(const char *res, char **store, char **data)
 218 {
 219         char buf[256];
 220
 221         if (*store) {
 222                 snprintf(buf, sizeof(buf),
 223                          "%s is duplicated. ignored the one", res);
 224                 yyerror(buf);
 225                 return;
 226         }
 227
 228         *store = *data;
 229         *data = NULL;
 230 }
 231
 232 static void
 233 set_invalid(uint32_t inv)
 234 {
 235         invalid = inv;
 236         use_invalid = 1;
 237 }
 238
 239 static void
 240 register_named_csid(char *sym, uint32_t val)
 241 {
 242         struct named_csid *csid;
 243
 244         STAILQ_FOREACH(csid, &named_csids, ci_entry) {
 245                 if (strcmp(csid->ci_symbol, sym) == 0) {
 246                         yyerror("multiply defined CSID");
 247                         exit(1);
 248                 }
 249         }
 250
 251         csid = malloc(sizeof(*csid));
 252         if (csid == NULL) {
 253                 perror("malloc");
 254                 exit(1);
 255         }
 256         csid->ci_symbol = sym;
 257         csid->ci_csid = val;
 258         STAILQ_INSERT_TAIL(&named_csids, csid, ci_entry);
 259         num_csids++;
 260 }
 261
 262 static void
 263 do_mkdb(FILE *in)
 264 {
 265         int ret;
 266         FILE *out;
 267
 268         /* dump DB to file */
 269         if (output)
 270                 out = fopen(output, "wb");
 271         else
 272                 out = stdout;
 273
 274         if (out==NULL)
 275                 err(EXIT_FAILURE, "fopen");
 276
 277         ret = _lookup_factory_convert(out, in);
 278         fclose(out);
 279         if (ret && output)
 280                 unlink(output); /* dump failure */
 281         if (ret)
 282                 errx(EXIT_FAILURE, "%s\n", strerror(ret));
 283 }
 284
 285 static void
 286 usage(void)
 287 {
 288         errx(EXIT_FAILURE,
 289              "usage:\n"
 290              "\t%s [-o outfile] [infile]\n"
 291              "\t%s -m [-o outfile] [infile]",
 292              getprogname(), getprogname());
 293 }
 294
 295 int
 296 main(int argc, char **argv)
 297 {
 298         int ch;
 299         FILE *in = NULL;
 300         int mkdb = 0;
 301
 302         while ((ch=getopt(argc, argv, "do:m")) != -1) {
 303                 switch (ch) {
 304                 case 'd':
 305                         debug = 1;
 306                         break;
 307                 case 'o':
 308                         output = strdup(optarg);
 309                         break;
 310                 case 'm':
 311                         mkdb = 1;
 312                         break;
 313                 default:
 314                         usage();
 315                 }
 316         }
 317
 318         argc-=optind;
 319         argv+=optind;
 320         switch (argc) {
 321         case 0:
 322                 in = stdin;
 323                 break;
 324         case 1:
 325                 in = fopen(argv[0], "r");
 326                 if (!in)
 327                         err(EXIT_FAILURE, "%s", argv[0]);
 328                 break;
 329         default:
 330                 usage();
 331         }
 332
 333         if (mkdb)
 334                 do_mkdb(in);
 335         else {
 336                 STAILQ_INIT(&named_csids);
 337                 yyin=in;
 338                 yyparse();
 339         }
 340
 341         return (0);
 342 }