--- conf/cf-lex.l | 74 +++++++++++++++++++++++++++++++++++++++++-------- conf/conf.h | 37 ++++++++++++++++++++----- conf/confbase.Y | 1 - 3 files changed, 93 insertions(+), 19 deletions(-) diff --git a/conf/cf-lex.l b/conf/cf-lex.l index 1d6cae2c..9b7df0b2 100644 --- a/conf/cf-lex.l +++ b/conf/cf-lex.l @@ -73,10 +73,10 @@ static uint cf_hash(const byte *c); #define KW_FN(k) cf_hash(k) #define KW_ORDER 8 /* Fixed */ -#define SYM_KEY(n) n->name, n->scope->active +#define SYM_KEY(n) n->name, n->scope->active, n->net_type #define SYM_NEXT(n) n->next -#define SYM_EQ(a,s1,b,s2) !strcmp(a,b) && s1 == s2 -#define SYM_FN(k,s) cf_hash(k) +#define SYM_EQ(a,s1,t1,b,s2,t2) !strcmp(a,b) && s1 == s2 && t1 == t2 +#define SYM_FN(k,s,t) cf_hash(k) #define SYM_ORDER 6 /* Initial */ #define SYM_REHASH sym_rehash @@ -544,7 +544,7 @@ check_eof(void) } static struct symbol * -cf_new_symbol(const byte *c) +cf_new_symbol(const byte *c, const u8 net_type) { struct symbol *s; @@ -553,7 +553,11 @@ cf_new_symbol(const byte *c) cf_error("Symbol too long"); s = cfg_allocz(sizeof(struct symbol) + l + 1); - *s = (struct symbol) { .scope = conf_this_scope, .class = SYM_VOID, }; + *s = (struct symbol) { + .scope = conf_this_scope, + .class = SYM_VOID, + .net_type = net_type + }; strcpy(s->name, c); if (!new_config->sym_hash.data) @@ -566,6 +570,21 @@ cf_new_symbol(const byte *c) return s; } +struct symbol * +cf_find_typed_symbol(const struct config *cfg, const byte *c, const u8 net_type) +{ + struct symbol *s, *typed; + s = HASH_FIND(cfg->sym_hash, SYM, c, 1, NET_ANY); + if (!s) return NULL; + if (net_type == NET_ANY) return s; + if (!(s->flags & SYM_FLAG_IS_TYPED)) return NULL; + + typed = HASH_FIND(cfg->sym_hash, SYM, c, 1, net_type); + if (!typed) return NULL; + cf_assert(s->scope == typed->scope, "bug: wrong scope"); + return typed; +} + /** * cf_find_symbol - find a symbol by name * @cfg: specificed config @@ -583,13 +602,13 @@ cf_find_symbol(const struct config *cfg, const byte *c) struct symbol *s; if (cfg->sym_hash.data && - (s = HASH_FIND(cfg->sym_hash, SYM, c, 1))) + (s = HASH_FIND(cfg->sym_hash, SYM, c, 1, NET_ANY))) return s; /* In CLI command parsing, fallback points to the current config, otherwise it is NULL. */ if (cfg->fallback && cfg->fallback->sym_hash.data && - (s = HASH_FIND(cfg->fallback->sym_hash, SYM, c, 1))) + (s = HASH_FIND(cfg->fallback->sym_hash, SYM, c, 1, NET_ANY))) return s; return NULL; @@ -607,7 +626,7 @@ cf_find_symbol(const struct config *cfg, const byte *c) struct symbol * cf_get_symbol(const byte *c) { - return cf_find_symbol(new_config, c) ?: cf_new_symbol(c); + return cf_find_symbol(new_config, c) ?: cf_new_symbol(c, NET_ANY); } /** @@ -625,13 +644,46 @@ cf_localize_symbol(struct symbol *sym) return sym; /* If the scope is the current, it is already defined in this scope. */ - if (sym->scope == conf_this_scope) - cf_error("Symbol already defined"); + if (sym->scope == conf_this_scope) { + if (sym->flags & SYM_FLAGS_TYPED) + return sym; + else + cf_error("Symbol already defined"); + } /* Not allocated here yet, doing it now. */ - return cf_new_symbol(sym->name); + return cf_new_symbol(sym->name, NET_ANY); } +struct symbol * +cf_type_symbol(struct symbol *sym, const int class, const u8 net_type) +{ + if (net_type == NET_ANY) { + if (sym->flags & SYM_FLAG_IS_TYPED) + cf_error("generic definitions not allowed for typed symbol"); + else + return sym; + } + + cf_assert(class & SYM_TYPEABLE, "Symbol not typeable"); + + if (sym->flags & SYM_FLAG_IS_TYPED && sym->class != class) + cf_error("Mixed symbol classes"); + + if (HASH_FIND(new_config->sym_hash, SYM, sym->name, 1, net_type)) + cf_error("Symbol already defined for this channel type"); + + struct symbol *typed = cf_new_symbol(sym->name, net_type); + + sym->class = class; + sym->flags |= SYM_FLAG_IS_TYPED; + + cf_assert(typed->scope == new_config->root_scope, "wrong scope for typed symbol"); + + return typed; +} + + struct symbol * cf_default_name(char *template, int *counter) { diff --git a/conf/conf.h b/conf/conf.h index 39015e62..0104d070 100644 --- a/conf/conf.h +++ b/conf/conf.h @@ -15,6 +15,8 @@ #include "lib/resource.h" #include "lib/timer.h" +#define cf_assert(cond, ...) do { if (!(cond)) cf_error(__VA_ARGS__); } while (0) + /* Configuration structure */ struct config { @@ -112,6 +114,7 @@ struct symbol { struct symbol *next; struct sym_scope *scope; int class; /* SYM_* */ + u8 net_type; /* Routing table network type (NET_*), 0 for undefined */ uint flags; /* SYM_FLAG_* */ union { @@ -184,31 +187,51 @@ void cf_lex_init(int is_cli, struct config *c); void cf_lex_unwind(void); struct symbol *cf_find_symbol(const struct config *cfg, const byte *c); +struct symbol *cf_find_typed_symbol(const struct config *cfg, const byte *c, const u8 net_type); struct symbol *cf_get_symbol(const byte *c); struct symbol *cf_default_name(char *template, int *counter); struct symbol *cf_localize_symbol(struct symbol *sym); +struct symbol *cf_type_symbol(struct symbol *sym, const int class, const u8 net_type); /** - * cf_define_symbol - define meaning of a symbol + * cf_define_typed_symbol - define meaning of a symbol * @sym: symbol to be defined * @type: symbol class to assign * @def: class dependent data + * @net_type: NET_* network type * * Defines new meaning of a symbol. If the symbol is an undefined * one (%SYM_VOID), it's just re-defined to the new type. If it's defined * in different scope, a new symbol in current scope is created and the * meaning is assigned to it. If it's already defined in the current scope, - * an error is reported via cf_error(). + * an error is reported via cf_error(). If net_type is not %NET_ANY, a the + * typed version of the symbol will be returned. + * + * Result: Pointer to the newly defined symbol. If we are in the top-level + * scope, it's the same @sym as passed to the function. + */ +#define cf_define_typed_symbol(sym_, type_, var_, def_, net_type_) ({ \ + struct symbol *main_sym = cf_localize_symbol(sym_); \ + struct symbol *typed = cf_type_symbol(main_sym, type_, net_type_); \ + typed->class = type_; \ + typed->var_ = def_; \ + typed; }) + +/** + * cf_define_symbol - define meaning of a symbol + * @sym: symbol to be defined + * @type: symbol class to assign + * @def: class dependent data + * + * This is a simple wrapper around %cf_define_typed_symbol, with + * net_type always passed as %NET_ANY. * * Result: Pointer to the newly defined symbol. If we are in the top-level * scope, it's the same @sym as passed to the function. */ -#define cf_define_symbol(sym_, type_, var_, def_) ({ \ - struct symbol *sym = cf_localize_symbol(sym_); \ - sym->class = type_; \ - sym->var_ = def_; \ - sym; }) +#define cf_define_symbol(sym_, type_, var_, def_) \ + cf_define_typed_symbol(sym_, type_, var_, def_, NET_ANY) void cf_push_scope(struct symbol *); void cf_pop_scope(void); diff --git a/conf/confbase.Y b/conf/confbase.Y index 75158927..eda5b9c1 100644 --- a/conf/confbase.Y +++ b/conf/confbase.Y @@ -33,7 +33,6 @@ check_u16(uint val) cf_error("Value %u out of range (0-65535)", val); } -#define cf_assert(cond, ...) do { if (!(cond)) cf_error(__VA_ARGS__); } while (0) static inline void cf_assert_symbol(const struct symbol *sym, uint class) { switch (class) { case SYM_PROTO: cf_assert(sym->class == SYM_PROTO, "Protocol name required"); break; -- 2.24.0