lib/shell/config.c

   1 /*
   2  *      UCW Library -- Shell Interface to Configuration Files
   3  *
   4  *      (c) 2002--2005 Martin Mares <mj@ucw.cz>
   5  *      (c) 2006 Robert Spalek <robert@ucw.cz>
   6  *      (c) 2006 Pavel Charvat <pchar@ucw.cz>
   7  *
   8  *      Once we were using this beautiful Shell version, but it turned out
   9  *      that it doesn't work with nested config files:
  10  *
  11  *              eval `sed <cf/sherlock '/^#/d;/^ *$/d;s/ \+$//;
  12  *              h;s@[^  ]*@@;x;s@[      ].*@@;y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/;G;s/\n//;
  13  *              /^\[SECTION\]/,/^\[/ {; /^[A-Z]/ { s/^\([^      ]\+\)[  ]*\(.*\)$/SH_\1="\2"/; p; }; };
  14  *              d;'`
  15  *
  16  *      This software may be freely distributed and used according to the terms
  17  *      of the GNU Lesser General Public License.
  18  */
  19
  20 #include "lib/lib.h"
  21 #include "lib/conf.h"
  22 #include "lib/getopt.h"
  23 #include "lib/clists.h"
  24 #include "lib/mempool.h"
  25 #include "lib/chartype.h"
  26 #include "lib/bbuf.h"
  27
  28 #include <stdlib.h>
  29 #include <stdio.h>
  30 #include <string.h>
  31 #include <alloca.h>
  32
  33 static void
  34 help(void)
  35 {
  36   fputs("\n\
  37 Usage: config [-C<configfile>] [-S<section>.<option>=<value>] <sections>\n\
  38 \n\
  39 <sections>\t<section>[,<sections>]\n\
  40 <section>\t[*]<name>{[<items>]}\n\
  41 <items>\t\t<item>[,<items>]\n\
  42 <item>\t\t<static> | @<list>\n\
  43 <static>\t[-]<type><name>\n\
  44 <list>\t\t<name>{[<items>]}\n\
  45 \n\
  46 Types:\n\
  47 <empty>\t\tString\n\
  48 #\t\t32-bit integer\n\
  49 ##\t\t64-bit integer\n\
  50 $\t\tFloating point number\n\
  51 \n\
  52 Modifiers:\n\
  53 *\t\tReport unknown items as errors\n\
  54 -\t\tDo not dump item's value\n\
  55 ", stderr);
  56   exit(1);
  57 }
  58
  59 union value {
  60   void *v_ptr;
  61   int v_int;
  62   u64 v_u64;
  63   double v_double;
  64   clist list;
  65 };
  66
  67 #define FLAG_HIDE               0x1
  68 #define FLAG_NO_UNKNOWN         0x2
  69
  70 struct item {
  71   cnode node;
  72   uns flags;
  73   struct cf_item cf;
  74   union value value;
  75 };
  76
  77 struct section {
  78   struct item item;
  79   clist list;
  80   uns count;
  81   uns size;
  82 };
  83
  84 static struct mempool *pool;
  85 static clist sections;
  86 static byte *pos;
  87
  88 static void
  89 parse_white(void)
  90 {
  91   while (Cspace(*pos))
  92     pos++;
  93 }
  94
  95 static void
  96 parse_char(byte c)
  97 {
  98   if (*pos++ != c)
  99     die("Missing '%c'", c);
 100 }
 101
 102 static byte *
 103 parse_name(void)
 104 {
 105   byte *name = pos;
 106   while (Cword(*pos))
 107     pos++;
 108   uns len = pos - name;
 109   if (!len)
 110     die("Expected item/section name");
 111   byte *buf = mp_alloc(pool, len + 1);
 112   memcpy(buf, name, len);
 113   buf[len] = 0;
 114   return buf;
 115 }
 116
 117 static void
 118 parse_section(struct section *section)
 119 {
 120   for (uns sep = 0; ; sep = 1)
 121     {
 122       parse_white();
 123       if (!*pos || *pos == '}')
 124         break;
 125       if (sep)
 126         parse_char(',');
 127       parse_white();
 128
 129       struct item *item;
 130
 131       if (*pos == '@')
 132         {
 133           pos++;
 134           struct section *sec = mp_alloc_zero(pool, sizeof(*sec));
 135           sec->size = sizeof(cnode);
 136           clist_init(&sec->list);
 137           item = &sec->item;
 138           item->cf.name = parse_name();
 139           item->cf.cls = CC_LIST;
 140           item->cf.number = 1;
 141           parse_white();
 142           parse_char('{');
 143           parse_section(sec);
 144           parse_char('}');
 145         }
 146       else
 147         {
 148           item = mp_alloc_zero(pool, sizeof(*item));
 149           if (*pos == '-')
 150             {
 151               item->flags |= FLAG_HIDE;
 152               pos++;
 153             }
 154           item->cf.cls = CC_STATIC;
 155           item->cf.number = 1;
 156           switch (*pos)
 157             {
 158               case '#':
 159                 if (*++pos == '#')
 160                   {
 161                     pos++;
 162                     item->cf.type = CT_U64;
 163                   }
 164                 else
 165                   item->cf.type = CT_INT;
 166                 break;
 167               case '$':
 168                 pos++;
 169                 item->cf.type = CT_DOUBLE;
 170                 break;
 171               default:
 172                 if (!Cword(*pos))
 173                   die("Invalid type syntax");
 174                 item->cf.type = CT_STRING;
 175                 break;
 176             }
 177           item->cf.name = parse_name();
 178         }
 179       if (section->item.cf.cls == CC_LIST)
 180         {
 181           item->cf.ptr = (void *)section->size;
 182           section->size += sizeof(union value);
 183         }
 184       else
 185         item->cf.ptr = &item->value;
 186       clist_add_tail(&section->list, &item->node);
 187       section->count++;
 188     }
 189 }
 190
 191 static void
 192 parse_outer(void)
 193 {
 194   for (uns sep = 0; ; sep = 1)
 195     {
 196       parse_white();
 197       if (!*pos)
 198         break;
 199       if (sep)
 200         parse_char(',');
 201       parse_white();
 202       struct section *sec = mp_alloc_zero(pool, sizeof(*sec));
 203       if (*pos == '*')
 204         {
 205           pos++;
 206           sec->item.flags |= FLAG_NO_UNKNOWN;
 207         }
 208       sec->item.cf.name = parse_name();
 209       parse_white();
 210       parse_char('{');
 211       clist_add_tail(&sections, &sec->item.node);
 212       clist_init(&sec->list);
 213       parse_section(sec);
 214       parse_char('}');
 215     }
 216 }
 217
 218 static struct cf_section *
 219 generate_section(struct section *section)
 220 {
 221   struct cf_section *sec = mp_alloc_zero(pool, sizeof(*sec));
 222   if (section->item.cf.cls == CC_LIST)
 223     sec->size = section->size;
 224   struct cf_item *c = sec->cfg = mp_alloc_zero(pool, sizeof(struct cf_item) * (section->count + 1));
 225   CLIST_FOR_EACH(struct item *, item, section->list)
 226     {
 227       *c = item->cf;
 228       if (c->cls == CC_LIST)
 229         c->u.sec = generate_section((struct section *)item);
 230       c++;
 231     }
 232   c->cls = CC_END;
 233   return sec;
 234 }
 235
 236 static bb_t path;
 237
 238 static void
 239 dump_item(struct item *item, void *ptr, uns path_len)
 240 {
 241   if (item->flags & FLAG_HIDE)
 242     return;
 243   union value *val = (union value *)((addr_int_t)ptr + (addr_int_t)item->cf.ptr);
 244   if (item->cf.cls == CC_LIST)
 245     {
 246       uns len = strlen(item->cf.name);
 247       bb_grow(&path, path_len + len + 1);
 248       path.ptr[path_len] = '_';
 249       memcpy(path.ptr + path_len + 1, item->cf.name, len);
 250       CLIST_FOR_EACH(cnode *, ptr2, val->list)
 251         CLIST_FOR_EACH(struct item *, item2, ((struct section *)item)->list)
 252           dump_item(item2, ptr2, path_len + len + 1);
 253     }
 254   else
 255     {
 256       byte *name = item->cf.name;
 257       byte buf[128], *value = buf;
 258       bb_grow(&path, path_len + 1)[path_len] = 0;
 259       if (!ptr)
 260         printf("CF_%s_%s='", path.ptr, name);
 261       else
 262         printf("CF_%s_%s[${#CF_%s_%s[*]}]='", path.ptr, name, path.ptr, name);
 263       switch (item->cf.type)
 264         {
 265           case CT_INT:
 266             sprintf(buf, "%d", val->v_int);
 267             break;
 268           case CT_U64:
 269             sprintf(buf, "%Lu", val->v_u64);
 270             break;
 271           case CT_DOUBLE:
 272             sprintf(buf, "%g", val->v_double);
 273             break;
 274           case CT_STRING:
 275             if (val->v_ptr)
 276               value = val->v_ptr;
 277             else
 278               *value = 0;
 279             break;
 280           default:
 281             ASSERT(0);
 282         }
 283           while (*value) {
 284 #if 0
 285             if (*value == '\'')
 286               die("Apostrophes are not supported in config of scripts");
 287 #endif
 288             if (*value == '\'')
 289               printf("'\\''");
 290             else
 291               putchar(*value);
 292             value++;
 293           }
 294           printf("'\n");
 295     }
 296 }
 297
 298 int main(int argc, char **argv)
 299 {
 300   log_init("config");
 301   if (argc < 2)
 302     help();
 303   pos = argv[argc - 1];
 304   argv[argc - 1] = NULL;
 305
 306   pool = mp_new(0x1000);
 307   clist_init(&sections);
 308   parse_outer();
 309   CLIST_FOR_EACH(struct section *, sec, sections)
 310     cf_declare_section(sec->item.cf.name, generate_section(sec), !(sec->item.flags & FLAG_NO_UNKNOWN));
 311
 312   if (cf_getopt(argc - 1, argv, CF_SHORT_OPTS, CF_NO_LONG_OPTS, NULL) != -1)
 313     help();
 314
 315   bb_init(&path);
 316   CLIST_FOR_EACH(struct section *, section, sections)
 317     {
 318       uns len = strlen(section->item.cf.name);
 319       memcpy(bb_grow(&path, len), section->item.cf.name, len);
 320       CLIST_FOR_EACH(struct item *, item, section->list)
 321         dump_item(item, NULL, len);
 322     }
 323   bb_done(&path);
 324
 325   return 0;
 326 }
 327