lib/libc/iconv/citrus_pivot_factory.c

   1 /* $FreeBSD$ */
   2 /* $NetBSD: citrus_pivot_factory.c,v 1.7 2009/04/12 14:20:19 lukem Exp $ */
   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/cdefs.h>
  31 #include <sys/queue.h>
  32
  33 #include <assert.h>
  34 #include <ctype.h>
  35 #include <errno.h>
  36 #include <limits.h>
  37 #include <stdio.h>
  38 #include <stdlib.h>
  39 #include <string.h>
  40
  41 #include "citrus_namespace.h"
  42 #include "citrus_region.h"
  43 #include "citrus_bcs.h"
  44 #include "citrus_db_factory.h"
  45 #include "citrus_db_hash.h"
  46 #include "citrus_pivot_file.h"
  47 #include "citrus_pivot_factory.h"
  48
  49 struct src_entry {
  50         char                            *se_name;
  51         struct _citrus_db_factory       *se_df;
  52         STAILQ_ENTRY(src_entry)          se_entry;
  53 };
  54 STAILQ_HEAD(src_head, src_entry);
  55
  56 static int
  57 find_src(struct src_head *sh, struct src_entry **rse, const char *name)
  58 {
  59         int ret;
  60         struct src_entry *se;
  61
  62         STAILQ_FOREACH(se, sh, se_entry) {
  63                 if (_bcs_strcasecmp(se->se_name, name) == 0) {
  64                         *rse = se;
  65                         return (0);
  66                 }
  67         }
  68         se = malloc(sizeof(*se));
  69         if (se == NULL)
  70                 return (errno);
  71         se->se_name = strdup(name);
  72         if (se->se_name == NULL) {
  73                 ret = errno;
  74                 free(se);
  75                 return (ret);
  76         }
  77         ret = _db_factory_create(&se->se_df, &_db_hash_std, NULL);
  78         if (ret) {
  79                 free(se->se_name);
  80                 free(se);
  81                 return (ret);
  82         }
  83         STAILQ_INSERT_TAIL(sh, se, se_entry);
  84         *rse = se;
  85
  86         return (0);
  87 }
  88
  89 static void
  90 free_src(struct src_head *sh)
  91 {
  92         struct src_entry *se;
  93
  94         while ((se = STAILQ_FIRST(sh)) != NULL) {
  95                 STAILQ_REMOVE_HEAD(sh, se_entry);
  96                 _db_factory_free(se->se_df);
  97                 free(se->se_name);
  98                 free(se);
  99         }
 100 }
 101
 102
 103 #define T_COMM '#'
 104 static int
 105 convert_line(struct src_head *sh, const char *line, size_t len)
 106 {
 107         struct src_entry *se;
 108         const char *p;
 109         char key1[LINE_MAX], key2[LINE_MAX], data[LINE_MAX];
 110         char *ep;
 111         uint32_t val;
 112         int ret;
 113
 114         se = NULL;
 115
 116         /* cut off trailing comment */
 117         p = memchr(line, T_COMM, len);
 118         if (p)
 119                 len = p - line;
 120
 121         /* key1 */
 122         line = _bcs_skip_ws_len(line, &len);
 123         if (len == 0)
 124                 return (0);
 125         p = _bcs_skip_nonws_len(line, &len);
 126         if (p == line)
 127                 return (0);
 128         snprintf(key1, sizeof(key1), "%.*s", (int)(p - line), line);
 129
 130         /* key2 */
 131         line = _bcs_skip_ws_len(p, &len);
 132         if (len == 0)
 133                 return (0);
 134         p = _bcs_skip_nonws_len(line, &len);
 135         if (p == line)
 136                 return (0);
 137         snprintf(key2, sizeof(key2), "%.*s", (int)(p - line), line);
 138
 139         /* data */
 140         line = _bcs_skip_ws_len(p, &len);
 141         _bcs_trunc_rws_len(line, &len);
 142         snprintf(data, sizeof(data), "%.*s", (int)len, line);
 143         val = strtoul(data, &ep, 0);
 144         if (*ep != '\0')
 145                 return (EFTYPE);
 146
 147         /* insert to DB */
 148         ret = find_src(sh, &se, key1);
 149         if (ret)
 150                 return (ret);
 151
 152         return (_db_factory_add32_by_s(se->se_df, key2, val));
 153 }
 154
 155 static int
 156 dump_db(struct src_head *sh, struct _region *r)
 157 {
 158         struct _db_factory *df;
 159         struct src_entry *se;
 160         struct _region subr;
 161         void *ptr;
 162         size_t size;
 163         int ret;
 164
 165         ret = _db_factory_create(&df, &_db_hash_std, NULL);
 166         if (ret)
 167                 return (ret);
 168
 169         STAILQ_FOREACH(se, sh, se_entry) {
 170                 size = _db_factory_calc_size(se->se_df);
 171                 ptr = malloc(size);
 172                 if (ptr == NULL)
 173                         goto quit;
 174                 _region_init(&subr, ptr, size);
 175                 ret = _db_factory_serialize(se->se_df, _CITRUS_PIVOT_SUB_MAGIC,
 176                     &subr);
 177                 if (ret)
 178                         goto quit;
 179                 ret = _db_factory_add_by_s(df, se->se_name, &subr, 1);
 180                 if (ret)
 181                         goto quit;
 182         }
 183
 184         size = _db_factory_calc_size(df);
 185         ptr = malloc(size);
 186         if (ptr == NULL)
 187                 goto quit;
 188         _region_init(r, ptr, size);
 189
 190         ret = _db_factory_serialize(df, _CITRUS_PIVOT_MAGIC, r);
 191         ptr = NULL;
 192
 193 quit:
 194         free(ptr);
 195         _db_factory_free(df);
 196         return (ret);
 197 }
 198
 199 int
 200 _citrus_pivot_factory_convert(FILE *out, FILE *in)
 201 {
 202         struct src_head sh;
 203         struct _region r;
 204         char *line;
 205         size_t size;
 206         int ret;
 207
 208         STAILQ_INIT(&sh);
 209
 210         while ((line = fgetln(in, &size)) != NULL)
 211                 if ((ret = convert_line(&sh, line, size))) {
 212                         free_src(&sh);
 213                         return (ret);
 214                 }
 215
 216         ret = dump_db(&sh, &r);
 217         free_src(&sh);
 218         if (ret)
 219                 return (ret);
 220
 221         if (fwrite(_region_head(&r), _region_size(&r), 1, out) != 1)
 222                 return (errno);
 223
 224         return (0);
 225 }