/* conffile.c - process the configuration file */
+/*
+ * This file is part of secnet.
+ * See README for full list of copyright holders.
+ *
+ * secnet is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * secnet is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * version 3 along with secnet; if not, see
+ * https://www.gnu.org/licenses/gpl.html.
+ */
/* #define DUMP_PARSE_TREE */
if (dict_ilookup_primitive(dict, key)) {
fatal("duplicate key \"%s\" in dictionary",key);
}
- e=safe_malloc(sizeof(*e),"dict_add");
+ NEW(e);
e->next=dict->entries;
e->key=key;
e->val=val;
{
dict_t *d;
- d=safe_malloc(sizeof(*d),"dict_new");
+ NEW(d);
d->parent=parent;
d->search=NULL;
d->entries=NULL;
static struct p_node *node_copy(struct p_node *n)
{
struct p_node *r;
- r=safe_malloc(sizeof(*r),"node_copy");
+ NEW(r);
*r=*n;
return r;
}
#ifdef DUMP_PARSE_TREE
/* Convert a node type to a string, for parse tree dump */
-static string_t ntype(uint32_t type)
+static const char *ntype(uint32_t type)
{
switch(type) {
case T_STRING: return "T_STRING";
for (i=0; i<amount; i++) printf(" . ");
}
-static void ptree_dump(struct p_node *n, uint32_t d)
+static void ptree_dump(struct p_node *n, int d)
{
if (!n) {
printf("NULL\n");
return;
}
- if (n->type<10) {
+ if (T_IS_PRIMITIVE(n->type)) {
switch(n->type) {
case T_STRING: printf("T_STRING: \"%s\" (%s line %d)\n",
n->data.string,n->loc.file,n->loc.line); break;
default: printf("**unknown primitive type**\n"); break;
}
} else {
- assert(d<INT_MAX);
+ assert(d<10000);
printf("%s: (%s line %d)\n",ntype(n->type),n->loc.file,n->loc.line);
ptree_indent(d);
printf(" |-"); ptree_dump(n->l, d+1);
{
item_t *i;
- i=safe_malloc(sizeof(*i),"new_item");
+ NEW(i);
i->type=type;
i->loc=loc;
return i;
if (!i) {
/* Did't find it; create a new one */
- i=safe_malloc(sizeof(*i),"intern: alloc list entry");
+ NEW(i);
i->a=safe_strdup(s,"intern: alloc string");
i->next=atoms;
atoms=i;
{
atom_t *r, *j;
struct entry *i;
- r=safe_malloc(sizeof(*r)*(dict->size+1),"dict_keys");
+ NEW_ARY(r,dict->size+1);
for (i=dict->entries, j=r; i; i=i->next, j++) {
*j=i->key;
}
return NULL;
}
-int32_t list_length(list_t *a)
+int32_t list_length(const list_t *a)
{
int32_t l=0;
- list_t *i;
+ const list_t *i;
for (i=a; i; i=i->next) { assert(l < INT_MAX); l++; }
return l;
}
l=NULL;
r=NULL;
for (i=a; i; i=i->next) {
- b=safe_malloc(sizeof(*b),"list_copy");
+ NEW(b);
if (l) l->next=b; else r=b;
l=b;
b->item=i->item;
{
list_t *l;
- l=safe_malloc(sizeof(*l),"list_append");
+ NEW(l);
l->item=item;
l->next=NULL;
void add_closure(dict_t *dict, cstring_t name, apply_fn apply)
{
closure_t *c;
- c=safe_malloc(sizeof(*c),"add_closure");
+ NEW(c);
c->description=name;
c->type=CL_PURE;
c->apply=apply;
void *find_cl_if(dict_t *dict, cstring_t name, uint32_t type,
bool_t fail_if_invalid, cstring_t desc, struct cloc loc)
{
- list_t *l;
item_t *i;
closure_t *cl;
- l=dict_lookup(dict,name);
- if (!l) {
- if (!fail_if_invalid) return NULL;
- cfgfatal(loc,desc,"closure \"%s\" not found\n",name);
- }
- i=list_elem(l,0);
+ i = dict_find_item(dict,name,fail_if_invalid,desc,loc);
if (i->type!=t_closure) {
if (!fail_if_invalid) return NULL;
cfgfatal(loc,desc,"\"%s\" must be a closure\n",name);
if (!required) return NULL;
cfgfatal(loc,desc,"required parameter \"%s\" not found\n",key);
}
+ if(list_length(l) != 1)
+ cfgfatal(loc,desc,"parameter \"%s\" has wrong number of values",key);
i=list_elem(l,0);
return i;
}
return r;
}
+const char **dict_read_string_array(dict_t *dict, cstring_t key,
+ bool_t required, cstring_t desc,
+ struct cloc loc, const char *const *def)
+{
+ list_t *l;
+ const char **ra, **rap;
+
+ l=dict_lookup(dict,key);
+ if (!l) {
+ if (!required) return (const char**)def;
+ cfgfatal(loc,desc,"required string list \"%s\" not found\n",key);
+ }
+
+ int32_t ll=list_length(l);
+ NEW_ARY(ra, ll+1);
+ for (rap=ra; l; l=l->next,rap++) {
+ item_t *it=l->item;
+ if (it->type!=t_string)
+ cfgfatal(it->loc,desc,"\"%s\" entry must be a string\n",key);
+ *rap=it->data.string;
+ }
+ *rap=0;
+ return ra;
+}
+
uint32_t dict_read_number(dict_t *dict, cstring_t key, bool_t required,
cstring_t desc, struct cloc loc, uint32_t def)
{
return r;
}
+dict_t *dict_read_dict(dict_t *dict, cstring_t key, bool_t required,
+ cstring_t desc, struct cloc loc)
+{
+ item_t *i;
+ dict_t *r;
+
+ i=dict_find_item(dict,key,required,desc,loc);
+ if (!i) return NULL;
+ if (i->type!=t_dict) {
+ cfgfatal(loc,desc,"\"%s\" must be a dictionary\n",key);
+ }
+ r=i->data.dict;
+ return r;
+}
+
uint32_t string_to_word(cstring_t s, struct cloc loc,
struct flagstr *f, cstring_t desc)
{