lib/libc/citrus/citrus_prop.c

   1 /* $NetBSD: citrus_prop.c,v 1.5 2014/06/24 22:24:18 spz Exp $ */
   2
   3 /*-
   4  * Copyright (c)2006 Citrus Project,
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  *
  28  */
  29
  30 #include <sys/cdefs.h>
  31 #if defined(LIBC_SCCS) && !defined(lint)
  32 __RCSID("$NetBSD: citrus_prop.c,v 1.5 2014/06/24 22:24:18 spz Exp $");
  33 #endif /* LIBC_SCCS and not lint */
  34
  35 #include <assert.h>
  36 #include <errno.h>
  37 #include <limits.h>
  38 #include <stdbool.h>
  39 #include <stddef.h>
  40 #include <stdio.h>
  41 #include <stdint.h>
  42 #include <stdlib.h>
  43 #include <string.h>
  44
  45 #include "citrus_namespace.h"
  46 #include "citrus_bcs.h"
  47 #include "citrus_region.h"
  48 #include "citrus_memstream.h"
  49 #include "citrus_prop.h"
  50
  51 typedef struct {
  52         _citrus_prop_type_t type;
  53         union {
  54                 const char *str;
  55                 int chr;
  56                 bool boolean;
  57                 uint64_t num;
  58         } u;
  59 } _citrus_prop_object_t;
  60
  61 static __inline void
  62 _citrus_prop_object_init(_citrus_prop_object_t *obj, _citrus_prop_type_t type)
  63 {
  64         _DIAGASSERT(obj != NULL);
  65
  66         obj->type = type;
  67         memset(&obj->u, 0, sizeof(obj->u));
  68 }
  69
  70 static __inline void
  71 _citrus_prop_object_uninit(_citrus_prop_object_t *obj)
  72 {
  73         _DIAGASSERT(obj != NULL);
  74
  75         if (obj->type == _CITRUS_PROP_STR)
  76                 free(__UNCONST(obj->u.str));
  77 }
  78
  79 static const char *xdigit = "0123456789ABCDEF";
  80
  81 #define _CITRUS_PROP_READ_UINT_COMMON(_func_, _type_, _max_)            \
  82 static int                                                              \
  83 _citrus_prop_read_##_func_##_common(struct _memstream * __restrict ms,  \
  84         _type_ * __restrict result, int base)                           \
  85 {                                                                       \
  86         _type_ acc, cutoff;                                             \
  87         int n, ch, cutlim;                                              \
  88         char *p;                                                        \
  89                                                                         \
  90         _DIAGASSERT(ms != NULL);                                        \
  91         _DIAGASSERT(result != NULL);                                    \
  92                                                                         \
  93         acc = (_type_)0;                                                \
  94         cutoff = _max_ / base;                                          \
  95         cutlim = _max_ % base;                                          \
  96         for (;;) {                                                      \
  97                 ch = _memstream_getc(ms);                               \
  98                 p = strchr(xdigit, _bcs_toupper(ch));                   \
  99                 if (p == NULL || (n = (p - xdigit)) >= base)            \
 100                         break;                                          \
 101                 if (acc > cutoff || (acc == cutoff && n > cutlim))      \
 102                         break;                                          \
 103                 acc *= base;                                            \
 104                 acc += n;                                               \
 105         }                                                               \
 106         _memstream_ungetc(ms, ch);                                      \
 107         *result = acc;                                                  \
 108         return 0;                                                       \
 109 }
 110 _CITRUS_PROP_READ_UINT_COMMON(chr, int, UCHAR_MAX)
 111 _CITRUS_PROP_READ_UINT_COMMON(num, uint64_t, UINT64_MAX)
 112 #undef _CITRUS_PROP_READ_UINT_COMMON
 113
 114 #define _CITRUS_PROP_READ_INT(_func_, _type_)                   \
 115 static int                                                      \
 116 _citrus_prop_read_##_func_(struct _memstream * __restrict ms,   \
 117         _citrus_prop_object_t * __restrict obj)                 \
 118 {                                                               \
 119         int ch, neg, base;                                      \
 120                                                                 \
 121         _DIAGASSERT(ms != NULL);                                \
 122         _DIAGASSERT(obj != NULL);                               \
 123                                                                 \
 124         _memstream_skip_ws(ms);                                 \
 125         ch = _memstream_getc(ms);                               \
 126         neg = 0;                                                \
 127         switch (ch) {                                           \
 128         case '-':                                               \
 129                 neg = 1;                                        \
 130         case '+':                                               \
 131                 ch = _memstream_getc(ms);                       \
 132         }                                                       \
 133         base = 10;                                              \
 134         if (ch == '0') {                                        \
 135                 base -= 2;                                      \
 136                 ch = _memstream_getc(ms);                       \
 137                 if (ch == 'x' || ch == 'X') {                   \
 138                         ch = _memstream_getc(ms);               \
 139                         if (_bcs_isxdigit(ch) == 0) {           \
 140                                 _memstream_ungetc(ms, ch);      \
 141                                 obj->u._func_ = 0;              \
 142                                 return 0;                       \
 143                         }                                       \
 144                         base += 8;                              \
 145                 }                                               \
 146         } else if (_bcs_isdigit(ch) == 0)                       \
 147                 return EINVAL;                                  \
 148         _memstream_ungetc(ms, ch);                              \
 149         return _citrus_prop_read_##_func_##_common              \
 150             (ms, &obj->u._func_, base);                         \
 151 }
 152 _CITRUS_PROP_READ_INT(chr, int)
 153 _CITRUS_PROP_READ_INT(num, uint64_t)
 154 #undef _CITRUS_PROP_READ_INT
 155
 156 static int
 157 _citrus_prop_read_character_common(struct _memstream * __restrict ms,
 158         int * __restrict result)
 159 {
 160         int ch, base;
 161
 162         _DIAGASSERT(ms != NULL);
 163         _DIAGASSERT(result != NULL);
 164
 165         ch = _memstream_getc(ms);
 166         if (ch != '\\') {
 167                 *result = ch;
 168         } else {
 169                 ch = _memstream_getc(ms);
 170                 base = 16;
 171                 switch (ch) {
 172                 case 'a': *result = '\a'; break;
 173                 case 'b': *result = '\b'; break;
 174                 case 'f': *result = '\f'; break;
 175                 case 'n': *result = '\n'; break;
 176                 case 'r': *result = '\r'; break;
 177                 case 't': *result = '\t'; break;
 178                 case 'v': *result = '\v'; break;
 179                 /*FALLTHROUGH*/
 180                 case '0': case '1': case '2': case '3':
 181                 case '4': case '5': case '6': case '7':
 182                         _memstream_ungetc(ms, ch);
 183                         base -= 8;
 184                 case 'x':
 185                         return _citrus_prop_read_chr_common(ms, result, base);
 186
 187                 default:
 188                         /* unknown escape */
 189                         *result = ch;
 190                 }
 191         }
 192         return 0;
 193 }
 194
 195 static int
 196 _citrus_prop_read_character(struct _memstream * __restrict ms,
 197         _citrus_prop_object_t * __restrict obj)
 198 {
 199         int ch, errnum;
 200
 201         _DIAGASSERT(ms != NULL);
 202         _DIAGASSERT(obj != NULL);
 203
 204         _memstream_skip_ws(ms);
 205         ch = _memstream_getc(ms);
 206         if (ch != '\'') {
 207                 _memstream_ungetc(ms, ch);
 208                 return _citrus_prop_read_chr(ms, obj);
 209         }
 210         errnum = _citrus_prop_read_character_common(ms, &ch);
 211         if (errnum != 0)
 212                 return errnum;
 213         obj->u.chr = ch;
 214         ch = _memstream_getc(ms);
 215         if (ch != '\'')
 216                 return EINVAL;
 217         return 0;
 218 }
 219
 220 static int
 221 _citrus_prop_read_bool(struct _memstream * __restrict ms,
 222         _citrus_prop_object_t * __restrict obj)
 223 {
 224         _DIAGASSERT(ms != NULL);
 225         _DIAGASSERT(obj != NULL);
 226
 227         _memstream_skip_ws(ms);
 228         switch (_bcs_tolower(_memstream_getc(ms))) {
 229         case 't':
 230                 if (_bcs_tolower(_memstream_getc(ms)) == 'r' &&
 231                     _bcs_tolower(_memstream_getc(ms)) == 'u' &&
 232                     _bcs_tolower(_memstream_getc(ms)) == 'e') {
 233                         obj->u.boolean = true;
 234                         return 0;
 235                 }
 236                 break;
 237         case 'f':
 238                 if (_bcs_tolower(_memstream_getc(ms)) == 'a' &&
 239                     _bcs_tolower(_memstream_getc(ms)) == 'l' &&
 240                     _bcs_tolower(_memstream_getc(ms)) == 's' &&
 241                     _bcs_tolower(_memstream_getc(ms)) == 'e') {
 242                         obj->u.boolean = false;
 243                         return 0;
 244                 }
 245         }
 246         return EINVAL;
 247 }
 248
 249 static int
 250 _citrus_prop_read_str(struct _memstream * __restrict ms,
 251         _citrus_prop_object_t * __restrict obj)
 252 {
 253         int errnum, quot, ch;
 254         char *s, *t;
 255 #define _CITRUS_PROP_STR_BUFSIZ 512
 256         size_t n, m;
 257
 258         _DIAGASSERT(ms != NULL);
 259         _DIAGASSERT(obj != NULL);
 260
 261         m = _CITRUS_PROP_STR_BUFSIZ;
 262         s = malloc(m);
 263         if (s == NULL)
 264                 return ENOMEM;
 265         n = 0;
 266         _memstream_skip_ws(ms);
 267         quot = _memstream_getc(ms);
 268         switch (quot) {
 269         case EOF:
 270                 goto done;
 271         case '\\':
 272                 _memstream_ungetc(ms, quot);
 273                 quot = EOF;
 274         /*FALLTHROUGH*/
 275         case '\"': case '\'':
 276                 break;
 277         default:
 278                 s[n] = quot;
 279                 ++n, --m;
 280                 quot = EOF;
 281         }
 282         for (;;) {
 283                 if (m < 1) {
 284                         m = _CITRUS_PROP_STR_BUFSIZ;
 285                         t = realloc(s, n + m);
 286                         if (t == NULL) {
 287                                 free(s);
 288                                 return ENOMEM;
 289                         }
 290                         s = t;
 291                 }
 292                 ch = _memstream_getc(ms);
 293                 if (quot == ch || (quot == EOF &&
 294                     (ch == ';' || _bcs_isspace(ch)))) {
 295 done:
 296                         s[n] = '\0';
 297                         obj->u.str = (const char *)s;
 298                         return 0;
 299                 }
 300                 _memstream_ungetc(ms, ch);
 301                 errnum = _citrus_prop_read_character_common(ms, &ch);
 302                 if (errnum != 0)
 303                         return errnum;
 304                 s[n] = ch;
 305                 ++n, --m;
 306         }
 307         free(s);
 308         return EINVAL;
 309 #undef _CITRUS_PROP_STR_BUFSIZ
 310 }
 311
 312 typedef int (*_citrus_prop_read_type_t)(struct _memstream * __restrict,
 313         _citrus_prop_object_t * __restrict);
 314
 315 static const _citrus_prop_read_type_t readers[] = {
 316         _citrus_prop_read_bool,
 317         _citrus_prop_read_str,
 318         _citrus_prop_read_character,
 319         _citrus_prop_read_num,
 320 };
 321
 322 static __inline int
 323 _citrus_prop_read_symbol(struct _memstream * __restrict ms,
 324         char * __restrict s, size_t n)
 325 {
 326         int ch;
 327         size_t m;
 328
 329         _DIAGASSERT(ms != NULL);
 330         _DIAGASSERT(s != NULL);
 331         _DIAGASSERT(n > 0);
 332
 333         for (m = 0; m < n; ++m) {
 334                 ch = _memstream_getc(ms);
 335                 if (ch != '_' && _bcs_isalnum(ch) == 0)
 336                         goto name_found;
 337                 s[m] = ch;
 338         }
 339         ch = _memstream_getc(ms);
 340         if (ch == '_' || _bcs_isalnum(ch) != 0)
 341                 return EINVAL;
 342
 343 name_found:
 344         _memstream_ungetc(ms, ch);
 345         s[m] = '\0';
 346
 347         return 0;
 348 }
 349
 350 static int
 351 _citrus_prop_parse_element(struct _memstream * __restrict ms,
 352         const _citrus_prop_hint_t * __restrict hints,
 353         void * __restrict context)
 354 {
 355         int ch, errnum;
 356 #define _CITRUS_PROP_HINT_NAME_LEN_MAX  255
 357         char name[_CITRUS_PROP_HINT_NAME_LEN_MAX + 1];
 358         const _citrus_prop_hint_t *hint;
 359         _citrus_prop_object_t ostart, oend;
 360
 361         _DIAGASSERT(ms != NULL);
 362         _DIAGASSERT(hints != NULL);
 363
 364         errnum = _citrus_prop_read_symbol(ms, name, sizeof(name));
 365         if (errnum != 0)
 366                 return errnum;
 367         for (hint = hints; hint->name != NULL; ++hint) {
 368                 if (_citrus_bcs_strcasecmp(name, hint->name) == 0)
 369                         goto hint_found;
 370         }
 371         return EINVAL;
 372
 373 hint_found:
 374         _memstream_skip_ws(ms);
 375         ch = _memstream_getc(ms);
 376         if (ch != '=' && ch != ':')
 377                 _memstream_ungetc(ms, ch);
 378         do {
 379                 _citrus_prop_object_init(&ostart, hint->type);
 380                 _citrus_prop_object_init(&oend, hint->type);
 381                 errnum = (*readers[hint->type])(ms, &ostart);
 382                 if (errnum != 0)
 383                         return errnum;
 384                 _memstream_skip_ws(ms);
 385                 ch = _memstream_getc(ms);
 386                 switch (hint->type) {
 387                 case _CITRUS_PROP_BOOL:
 388                 case _CITRUS_PROP_STR:
 389                         break;
 390                 default:
 391                         if (ch != '-')
 392                                 break;
 393                         errnum = (*readers[hint->type])(ms, &oend);
 394                         if (errnum != 0)
 395                                 return errnum;
 396                         _memstream_skip_ws(ms);
 397                         ch = _memstream_getc(ms);
 398                 }
 399 #define CALL0(_func_)                                   \
 400 do {                                                    \
 401         _DIAGASSERT(hint->cb._func_.func != NULL);      \
 402         errnum = (*hint->cb._func_.func)(context,       \
 403             hint->name, ostart.u._func_);               \
 404 } while (/*CONSTCOND*/0)
 405 #define CALL1(_func_)                                   \
 406 do {                                                    \
 407         _DIAGASSERT(hint->cb._func_.func != NULL);      \
 408         errnum = (*hint->cb._func_.func)(context,       \
 409             hint->name, ostart.u._func_, oend.u._func_);\
 410 } while (/*CONSTCOND*/0)
 411
 412                 switch (hint->type) {
 413
 414                 case _CITRUS_PROP_BOOL:
 415                         CALL0(boolean);
 416                         break;
 417
 418                 case _CITRUS_PROP_STR:
 419                         CALL0(str);
 420                         break;
 421
 422                 case _CITRUS_PROP_CHR:
 423                         CALL1(chr);
 424                         break;
 425
 426                 case _CITRUS_PROP_NUM:
 427                         CALL1(num);
 428                         break;
 429
 430                 default:
 431                         abort();
 432                         /*NOTREACHED*/
 433                 }
 434 #undef CALL0
 435 #undef CALL1
 436                 _citrus_prop_object_uninit(&ostart);
 437                 _citrus_prop_object_uninit(&oend);
 438                 if (errnum != 0)
 439                         return errnum;
 440         } while (ch == ',');
 441         if (ch != ';')
 442                 _memstream_ungetc(ms, ch);
 443         return 0;
 444 }
 445
 446 int
 447 _citrus_prop_parse_variable(const _citrus_prop_hint_t * __restrict hints,
 448         void * __restrict context, const void *var, size_t lenvar)
 449 {
 450         struct _memstream ms;
 451         int errnum, ch;
 452
 453         _DIAGASSERT(hints != NULL);
 454
 455         _memstream_bind_ptr(&ms, __UNCONST(var), lenvar);
 456         for (;;) {
 457                 _memstream_skip_ws(&ms);
 458                 ch = _memstream_getc(&ms);
 459                 if (ch == EOF || ch == '\0')
 460                         break;
 461                 _memstream_ungetc(&ms, ch);
 462                 errnum = _citrus_prop_parse_element(&ms, hints, context);
 463                 if (errnum != 0)
 464                         return errnum;
 465         }
 466         return 0;
 467 }