]> mj.ucw.cz Git - libucw.git/blob - ucw/shell/config.c
The big move. Step #1: Move whole lib/ to ucw/.
[libucw.git] / ucw / 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 "ucw/lib.h"
21 #include "ucw/conf.h"
22 #include "ucw/getopt.h"
23 #include "ucw/conf-internal.h"
24 #include "ucw/clists.h"
25 #include "ucw/mempool.h"
26 #include "ucw/chartype.h"
27 #include "ucw/bbuf.h"
28 #include "ucw/string.h"
29
30 #include <stdlib.h>
31 #include <stdio.h>
32 #include <string.h>
33 #include <alloca.h>
34
35 static void
36 help(void)
37 {
38   fputs("\n\
39 Usage: config [-C<configfile>] [-S<section>.<option>=<value>] <sections>\n\
40 \n\
41 <sections>\t<section>[;<sections>]\n\
42 <section>\t[!]<name>{[<items>]}\n\
43 <items>\t\t[-]<item>[;<items>]\n\
44 <item>\t\t<static> | <array> | <list>\n\
45 <static>\t<type><name>[=<value>]\n\
46 <list>\t\t@<name>{[<items>]}\n\
47 <array>\t\t<type><name><left-bracket>[<number>]<right-bracket>\n\
48 <value>\t\t[a-zA-Z0-9.-/]* | 'string without single quotes'<value> | \"c-like string\"<value>\n\
49 \n\
50 Types:\n\
51 <empty>\t\tString\n\
52 #\t\t32-bit integer\n\
53 ##\t\t64-bit integer\n\
54 $\t\tFloating point number\n\
55 \n\
56 Modifiers:\n\
57 !\t\tReport unknown items as errors\n\
58 -\t\tDo not dump item's value\n\
59 ", stderr);
60   exit(1);
61 }
62
63 union value {
64   void *v_ptr;
65   int v_int;
66   u64 v_u64;
67   double v_double;
68   clist list;
69 };
70
71 #define FLAG_HIDE               0x1
72 #define FLAG_NO_UNKNOWN         0x2
73
74 struct item {
75   cnode node;
76   uns flags;
77   struct cf_item cf;
78   union value value;
79   uns index;
80 };
81
82 struct section {
83   struct item item;
84   clist list;
85   uns count;
86   uns size;
87 };
88
89 static struct mempool *pool;
90 static clist sections;
91 static byte *pos;
92
93 static void
94 parse_white(void)
95 {
96   while (Cspace(*pos))
97     pos++;
98 }
99
100 static void
101 parse_char(byte c)
102 {
103   if (*pos++ != c)
104     die("Missing '%c'", c);
105 }
106
107 static byte *
108 parse_name(void)
109 {
110   byte *name = pos;
111   while (Cword(*pos))
112     pos++;
113   uns len = pos - name;
114   if (!len)
115     die("Expected item/section name");
116   byte *buf = mp_alloc(pool, len + 1);
117   memcpy(buf, name, len);
118   buf[len] = 0;
119   return buf;
120 }
121
122 static void
123 parse_section(struct section *section)
124 {
125 #define TRY(x) do{byte *_err=(x); if (_err) die(_err); }while(0)
126   for (uns sep = 0; ; sep = 1)
127     {
128       parse_white();
129       if (!*pos || *pos == '}')
130         break;
131       if (sep)
132         parse_char(';');
133       parse_white();
134
135       struct item *item;
136
137       if (*pos == '@')
138         {
139           pos++;
140           struct section *sec = mp_alloc_zero(pool, sizeof(*sec));
141           sec->size = sizeof(cnode);
142           clist_init(&sec->list);
143           item = &sec->item;
144           item->cf.name = parse_name();
145           item->cf.cls = CC_LIST;
146           item->cf.number = 1;
147           parse_white();
148           parse_char('{');
149           parse_section(sec);
150           parse_char('}');
151         }
152       else
153         {
154           item = mp_alloc_zero(pool, sizeof(*item));
155           if (*pos == '-')
156             {
157               item->flags |= FLAG_HIDE;
158               pos++;
159             }
160           item->cf.cls = CC_STATIC;
161           item->cf.number = 1;
162           switch (*pos)
163             {
164               case '#':
165                 if (*++pos == '#')
166                   {
167                     pos++;
168                     item->cf.type = CT_U64;
169                   }
170                 else
171                   item->cf.type = CT_INT;
172                 break;
173               case '$':
174                 pos++;
175                 item->cf.type = CT_DOUBLE;
176                 break;
177               default:
178                 if (!Cword(*pos))
179                   die("Invalid type syntax");
180                 item->cf.type = CT_STRING;
181                 break;
182             }
183           parse_white();
184           item->cf.name = parse_name();
185           parse_white();
186           if (*pos == '[')
187             {
188               pos++;
189               parse_white();
190               item->cf.cls = CC_DYNAMIC;
191               byte *num = pos;
192               while (*pos && *pos != ']')
193                 pos++;
194               if (!*pos)
195                 die("Missing ']'");
196               *pos++ = 0;
197               if (!*num)
198                 item->cf.number = CF_ANY_NUM;
199               else
200                 {
201                   int inum;
202                   TRY(cf_parse_int(num, &inum));
203                   if (!inum)
204                     die("Invalid array length");
205                   item->cf.number = inum;
206                 }
207               parse_white();
208             }
209           if (*pos == '=')
210             {
211               pos++;
212               parse_white();
213               if (section->item.cf.cls == CC_LIST)
214                 die("List items can not have default values");
215               if (item->cf.cls == CC_DYNAMIC)
216                 die("Arrays can not have default values");
217               byte *def = pos, *d = def;
218               while (*pos != ';' && *pos != '}' && !Cspace(*pos))
219                 {
220                   if (*pos == '\'')
221                     {
222                       pos++;
223                       while (*pos != '\'')
224                         {
225                           if (!*pos)
226                             die("Unterminated string");
227                           *d++ = *pos++;
228                         }
229                       pos++;
230                     }
231                   else if (*pos == '"')
232                     {
233                       pos++;
234                       byte *start = d;
235                       uns esc = 0;
236                       while (*pos != '"' || esc)
237                         {
238                           if (!*pos)
239                             die("Unterminated string");
240                           if (*pos == '\\')
241                             esc ^= 1;
242                           else
243                             esc = 0;
244                           *d++ = *pos++;
245                         }
246                       pos++;
247                       *d = 0;
248                       d = str_unesc(start, start);
249                     }
250                   else
251                     *d++ = *pos++;
252                 }
253               uns len = d - def;
254               byte *buf = mp_alloc(pool, len + 1);
255               memcpy(buf, def, len);
256               buf[len] = 0;
257               switch (item->cf.type)
258                 {
259                   case CT_STRING:
260                     item->value.v_ptr = buf;
261                     break;
262                   case CT_INT:
263                     TRY(cf_parse_int(buf, &item->value.v_int));
264                     break;
265                   case CT_U64:
266                     TRY(cf_parse_u64(buf, &item->value.v_u64));
267                     break;
268                   case CT_DOUBLE:
269                     TRY(cf_parse_double(buf, &item->value.v_double));
270                     break;
271                   default:
272                     ASSERT(0);
273                 }
274             }
275         }
276       if (section->item.cf.cls == CC_LIST)
277         {
278           item->cf.ptr = (void *)(uintptr_t)section->size;
279           section->size += sizeof(union value);
280         }
281       else
282         item->cf.ptr = &item->value;
283       clist_add_tail(&section->list, &item->node);
284       section->count++;
285     }
286 #undef TRY
287 }
288
289 static void
290 parse_outer(void)
291 {
292   for (uns sep = 0; ; sep = 1)
293     {
294       parse_white();
295       if (!*pos)
296         break;
297       if (sep)
298         parse_char(';');
299       parse_white();
300       struct section *sec = mp_alloc_zero(pool, sizeof(*sec));
301       if (*pos == '!')
302         {
303           pos++;
304           sec->item.flags |= FLAG_NO_UNKNOWN;
305         }
306       sec->item.cf.name = parse_name();
307       parse_white();
308       parse_char('{');
309       clist_add_tail(&sections, &sec->item.node);
310       clist_init(&sec->list);
311       parse_section(sec);
312       parse_char('}');
313     }
314 }
315
316 static struct cf_section *
317 generate_section(struct section *section)
318 {
319   struct cf_section *sec = mp_alloc_zero(pool, sizeof(*sec));
320   if (section->item.cf.cls == CC_LIST)
321     sec->size = section->size;
322   struct cf_item *c = sec->cfg = mp_alloc_zero(pool, sizeof(struct cf_item) * (section->count + 1));
323   CLIST_FOR_EACH(struct item *, item, section->list)
324     {
325       *c = item->cf;
326       if (c->cls == CC_LIST)
327         c->u.sec = generate_section((struct section *)item);
328       c++;
329     }
330   c->cls = CC_END;
331   return sec;
332 }
333
334 static bb_t path;
335
336 static void
337 dump_value(uns array, struct item *item, void *v)
338 {
339   byte buf[128], *value = buf;
340   if (!array)
341     printf("CF_%s_%s='", path.ptr, item->cf.name);
342   else
343     printf("CF_%s_%s[%u]='", path.ptr, item->cf.name, ++item->index);
344   switch (item->cf.type)
345     {
346       case CT_INT:
347         sprintf(buf, "%d", *(int *)v);
348         break;
349       case CT_U64:
350         sprintf(buf, "%llu", (long long) *(u64 *)v);
351         break;
352       case CT_DOUBLE:
353         sprintf(buf, "%g", *(double *)v);
354         break;
355       case CT_STRING:
356         if (*(byte **)v)
357           value = *(byte **)v;
358         else
359           *value = 0;
360         break;
361       default:
362         ASSERT(0);
363     }
364   while (*value) {
365     if (*value == '\'')
366       printf("'\\''");
367     else
368       putchar(*value);
369     value++;
370   }
371   printf("'\n");
372 }
373
374 static void
375 dump_item(struct item *item, void *ptr, uns path_len)
376 {
377   if (item->flags & FLAG_HIDE)
378     return;
379   byte *val = (byte *)((uintptr_t)ptr + (uintptr_t)item->cf.ptr);
380   if (item->cf.cls == CC_LIST)
381     {
382       uns len = strlen(item->cf.name);
383       bb_grow(&path, path_len + len + 1);
384       path.ptr[path_len] = '_';
385       memcpy(path.ptr + path_len + 1, item->cf.name, len);
386       CLIST_FOR_EACH(cnode *, ptr2, *(clist *)val)
387         CLIST_FOR_EACH(struct item *, item2, ((struct section *)item)->list)
388           dump_item(item2, ptr2, path_len + len + 1);
389     }
390   else
391     {
392       bb_grow(&path, path_len + 1)[path_len] = 0;
393       if (item->cf.cls == CC_STATIC)
394         dump_value(!!ptr, item, val);
395       else
396         {
397           val = *(void **)val;
398           uns len = DARY_LEN(val);
399           uns size = cf_type_size(item->cf.type, NULL);
400           for (uns i = 0; i < len; i++, val += size)
401             dump_value(1, item, val);
402         }
403     }
404 }
405
406 int main(int argc, char **argv)
407 {
408   log_init("config");
409   if (argc < 2)
410     help();
411   pos = argv[argc - 1];
412   argv[argc - 1] = NULL;
413
414   pool = mp_new(0x1000);
415   clist_init(&sections);
416   parse_outer();
417   CLIST_FOR_EACH(struct section *, sec, sections)
418     cf_declare_section(sec->item.cf.name, generate_section(sec), !(sec->item.flags & FLAG_NO_UNKNOWN));
419
420   if (cf_getopt(argc - 1, argv, CF_SHORT_OPTS, CF_NO_LONG_OPTS, NULL) != -1)
421     help();
422
423   bb_init(&path);
424   CLIST_FOR_EACH(struct section *, section, sections)
425     {
426       uns len = strlen(section->item.cf.name);
427       memcpy(bb_grow(&path, len), section->item.cf.name, len);
428       CLIST_FOR_EACH(struct item *, item, section->list)
429         dump_item(item, NULL, len);
430     }
431   bb_done(&path);
432
433   return 0;
434 }
435