- Bird-users - Mailing Lists

[RFC PATCH 12/20] force consistent number of function arguments
by Asbjørn Sloth Tønnesen 30 Dec '19

30 Dec '19

--- conf/cf-lex.l | 1 + conf/conf.h | 1 + filter/adapt.c | 5 +++++ filter/config.Y | 2 ++ 4 files changed, 9 insertions(+) diff --git a/conf/cf-lex.l b/conf/cf-lex.l index 9b7df0b2..ab984dca 100644 --- a/conf/cf-lex.l +++ b/conf/cf-lex.l @@ -677,6 +677,7 @@ cf_type_symbol(struct symbol *sym, const int class, const u8 net_type) sym->class = class; sym->flags |= SYM_FLAG_IS_TYPED; + typed->parent = sym; cf_assert(typed->scope == new_config->root_scope, "wrong scope for typed symbol"); diff --git a/conf/conf.h b/conf/conf.h index 0104d070..c3031a65 100644 --- a/conf/conf.h +++ b/conf/conf.h @@ -112,6 +112,7 @@ extern int (*cf_read_hook)(byte *buf, uint max, int fd); struct symbol { node n; /* In list of symbols in config */ struct symbol *next; + struct symbol *parent; /* for parent of typed symbol */ struct sym_scope *scope; int class; /* SYM_* */ u8 net_type; /* Routing table network type (NET_*), 0 for undefined */ diff --git a/filter/adapt.c b/filter/adapt.c index cb43177d..13c090da 100644 --- a/filter/adapt.c +++ b/filter/adapt.c @@ -33,6 +33,11 @@ filter_tree_has_typed_symbols(const struct f_tree *t) void filter_validate_function(struct symbol *sym) { + const struct symbol *parent = sym->parent; + if (parent && parent->function->args != sym->function->args) + cf_error("Incorrent amount of arguments in definition of %s:%s", + sym->name, net_label[sym->net_type]); + if (f_has_typed_symbols(sym->function)) sym->flags |= SYM_FLAG_DO_ADAPT; } diff --git a/filter/config.Y b/filter/config.Y index 1caef0fc..caca0d2b 100644 --- a/filter/config.Y +++ b/filter/config.Y @@ -615,6 +615,8 @@ function_def: $5->args = $4; $2->function = $5; cf_pop_scope(); + if ($2->parent && !$2->parent->function) + $2->parent->function = $5; filter_validate_function($2); } ; -- 2.24.0

1 0

[RFC PATCH 11/20] check if functions need to be adapted
by Asbjørn Sloth Tønnesen 30 Dec '19

30 Dec '19

--- filter/adapt.c | 7 +++++++ filter/config.Y | 1 + filter/filter.h | 1 + 3 files changed, 9 insertions(+) diff --git a/filter/adapt.c b/filter/adapt.c index b1223169..cb43177d 100644 --- a/filter/adapt.c +++ b/filter/adapt.c @@ -29,3 +29,10 @@ filter_tree_has_typed_symbols(const struct f_tree *t) return 0; } + +void +filter_validate_function(struct symbol *sym) +{ + if (f_has_typed_symbols(sym->function)) + sym->flags |= SYM_FLAG_DO_ADAPT; +} diff --git a/filter/config.Y b/filter/config.Y index c8b868af..1caef0fc 100644 --- a/filter/config.Y +++ b/filter/config.Y @@ -615,6 +615,7 @@ function_def: $5->args = $4; $2->function = $5; cf_pop_scope(); + filter_validate_function($2); } ; diff --git a/filter/filter.h b/filter/filter.h index 7c4b0ae9..33c452e8 100644 --- a/filter/filter.h +++ b/filter/filter.h @@ -65,6 +65,7 @@ int f_same(const struct f_line *f1, const struct f_line *f2); int f_has_typed_symbols(const struct f_line *line); int filter_tree_has_typed_symbols(const struct f_tree *t); +void filter_validate_function(struct symbol *sym); void filter_commit(struct config *new, struct config *old); -- 2.24.0

1 0

[RFC PATCH 10/20] show symbol flags in dump filter all
by Asbjørn Sloth Tønnesen 30 Dec '19

30 Dec '19

--- filter/filter.c | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/filter/filter.c b/filter/filter.c index 2e3ae8ba..3e9660f8 100644 --- a/filter/filter.c +++ b/filter/filter.c @@ -486,13 +486,17 @@ void filters_dump_all(void) WALK_LIST(sym, config->symbols) { switch (sym->class) { case SYM_FILTER: - debug("Named filter %s:\n", sym->name); - f_dump_line(sym->filter->root, 1); - break; + debug("Named filter %s<%s>:\n", sym->name, net_label[sym->net_type]); + if (sym->flags & SYM_FLAG_IS_TYPED) debug(" Flag: IS TYPED\n"); + if (sym->flags & SYM_FLAG_DO_ADAPT) debug(" Flag: DO ADAPT\n"); + f_dump_line(sym->filter->root, 1); + break; case SYM_FUNCTION: - debug("Function %s:\n", sym->name); - f_dump_line(sym->function, 1); - break; + debug("Function %s<%s>:\n", sym->name, net_label[sym->net_type]); + if (sym->flags & SYM_FLAG_IS_TYPED) debug(" Flag: IS TYPED\n"); + if (sym->flags & SYM_FLAG_DO_ADAPT) debug(" Flag: DO ADAPT\n"); + f_dump_line(sym->function, 1); + break; case SYM_PROTO: { debug("Protocol %s:\n", sym->name); -- 2.24.0

1 0

[RFC PATCH 09/20] use net_type when looking up symbols in SYM_FLAG_SAME check
by Asbjørn Sloth Tønnesen 30 Dec '19

30 Dec '19

--- filter/filter.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/filter/filter.c b/filter/filter.c index b8147662..2e3ae8ba 100644 --- a/filter/filter.c +++ b/filter/filter.c @@ -461,7 +461,7 @@ filter_commit(struct config *new, struct config *old) WALK_LIST(sym, new->symbols) switch (sym->class) { case SYM_FUNCTION: - if ((osym = cf_find_symbol(old, sym->name)) && + if ((osym = cf_find_typed_symbol(old, sym->name, sym->net_type)) && (osym->class == SYM_FUNCTION) && f_same(sym->function, osym->function)) sym->flags |= SYM_FLAG_SAME; @@ -470,7 +470,7 @@ filter_commit(struct config *new, struct config *old) break; case SYM_FILTER: - if ((osym = cf_find_symbol(old, sym->name)) && + if ((osym = cf_find_typed_symbol(old, sym->name, sym->net_type)) && (osym->class == SYM_FILTER) && f_same(sym->filter->root, osym->filter->root)) sym->flags |= SYM_FLAG_SAME; -- 2.24.0

1 0

[RFC PATCH 08/20] add f_has_typed_symbols helper function
by Asbjørn Sloth Tønnesen 30 Dec '19

30 Dec '19

--- filter/Makefile | 2 +- filter/adapt.c | 31 +++++++++++++++++++++++++++++++ filter/decl.m4 | 44 ++++++++++++++++++++++++++++++++++++-------- filter/f-inst.c | 9 +++++++++ filter/filter.h | 3 +++ 5 files changed, 80 insertions(+), 9 deletions(-) create mode 100644 filter/adapt.c diff --git a/filter/Makefile b/filter/Makefile index c2062534..633960b2 100644 --- a/filter/Makefile +++ b/filter/Makefile @@ -1,4 +1,4 @@ -src := filter.c data.c f-util.c tree.c trie.c inst-gen.c +src := filter.c data.c f-util.c tree.c trie.c inst-gen.c adapt.c obj := $(src-o-files) $(all-daemon) $(cf-local) diff --git a/filter/adapt.c b/filter/adapt.c new file mode 100644 index 00000000..b1223169 --- /dev/null +++ b/filter/adapt.c @@ -0,0 +1,31 @@ +/* + * Filters: adaptation functions + * + * Copyright 1998 Pavel Machek <pavel(a)ucw.cz> + * + * Can be freely distributed and used under the terms of the GNU GPL. + */ + +#undef LOCAL_DEBUG + +#include "lib/net.h" +#include "filter/filter.h" +#include "filter/f-inst.h" + +int +filter_tree_has_typed_symbols(const struct f_tree *t) +{ + if (t == NULL) + return 0; + + if (filter_tree_has_typed_symbols(t->left)) + return 1; + + if (filter_tree_has_typed_symbols(t->right)) + return 1; + + if (t->data && f_has_typed_symbols(t->data)) + return 1; + + return 0; +} diff --git a/filter/decl.m4 b/filter/decl.m4 index a78450a3..23024d35 100644 --- a/filter/decl.m4 +++ b/filter/decl.m4 @@ -40,6 +40,7 @@ m4_divert(-1)m4_dnl # 106 comparator body # 107 struct f_line_item content # 108 interpreter body +# 109 f_has_typed_symbls # # Here are macros to allow you to _divert to the right directions. m4_define(FID_STRUCT_IN, `m4_divert(101)') @@ -50,6 +51,7 @@ m4_define(FID_LINEARIZE_BODY, `m4_divert(105)') m4_define(FID_SAME_BODY, `m4_divert(106)') m4_define(FID_LINE_IN, `m4_divert(107)') m4_define(FID_INTERPRET_BODY, `m4_divert(108)') +m4_define(FID_HAS_TYPED_BODY, `m4_divert(109)') # Sometimes you want slightly different code versions in different # outputs. @@ -206,6 +208,8 @@ FID_LINEARIZE_BODY()m4_dnl item->fl$1 = f_linearize(whati->f$1); FID_SAME_BODY()m4_dnl if (!f_same(f1->fl$1, f2->fl$1)) return 0; +FID_HAS_TYPED_BODY()m4_dnl +if (f_has_typed_symbols(item->fl$1)) return 1; FID_INTERPRET_EXEC()m4_dnl do { if (whati->fl$1) { LINEX_(whati->fl$1); @@ -254,14 +258,15 @@ m4_define(ACCESS_RTE, `FID_HIC(,[[do { if (!fs->rte) runtime("No route to access # into appropriate headers and structures and saves them into global # diversions listed: # -# 4 enum fi_code -# 5 enum fi_code to string -# 6 dump line item -# 7 dump line item callers -# 8 linearize -# 9 same (filter comparator) -# 1 union in struct f_inst -# 3 constructors + interpreter +# 4 enum fi_code +# 5 enum fi_code to string +# 6 dump line item +# 7 dump line item callers +# 8 linearize +# 9 same (filter comparator) +# 10 f_has_typed_symbols +# 1 union in struct f_inst +# 3 constructors + interpreter # # These global diversions contain blocks of code that can be directly # put into the final file, yet it still can't be written out now as @@ -280,6 +285,7 @@ m4_define(FID_DUMP, `FID_ZONE(6, Dump line)') m4_define(FID_DUMP_CALLER, `FID_ZONE(7, Dump line caller)') m4_define(FID_LINEARIZE, `FID_ZONE(8, Linearize)') m4_define(FID_SAME, `FID_ZONE(9, Comparison)') +m4_define(FID_HAS_TYPED, `FID_ZONE(10, Has typed symbol)') # This macro does all the code wrapping. See inline comments. m4_define(INST_FLUSH, `m4_ifdef([[INST_NAME]], [[ @@ -367,6 +373,13 @@ m4_undivert(106)m4_dnl #undef f2 break; +FID_HAS_TYPED()m4_dnl This code checks if a f_line used typed symbols +case INST_NAME(): +#define item (&(fl_item->i_]]INST_NAME()[[)) +m4_undivert(109)m4_dnl +#undef item +break; + m4_divert(-1)FID_FLUSH(101,200)m4_dnl And finally this flushes all the unused diversions ]])') @@ -577,6 +590,21 @@ FID_WR_PUT(9) return 1; } +/* Does this line refer to any typed symbols? */ +int +f_has_typed_symbols(const struct f_line *fl) +{ + if (fl == NULL) return 0; + + for (uint i=0; i<fl->len; i++) { + const struct f_line_item *fl_item = &fl->items[i]; + switch (fl_item->fi_code) { +FID_WR_PUT(10) + } + } + return 0; +} + #if defined(__GNUC__) && __GNUC__ >= 6 #pragma GCC diagnostic pop #endif diff --git a/filter/f-inst.c b/filter/f-inst.c index 37fa0f39..46354aa2 100644 --- a/filter/f-inst.c +++ b/filter/f-inst.c @@ -443,6 +443,8 @@ NEVER_CONSTANT; RESULT_TYPE(sym->class & 0xff); + FID_HAS_TYPED_BODY() + return 1; FID_INTERPRET_BODY() runtime("FI_TYPED_CONSTANT can't be interpreted", sym); } @@ -935,6 +937,9 @@ FID_SAME_BODY() if (!(f1->sym->flags & SYM_FLAG_SAME)) return 0; + FID_HAS_TYPED_BODY() + if (item->sym->flags & SYM_FLAGS_TYPED) + return 1; FID_INTERPRET_BODY() /* Push the body on stack */ @@ -963,6 +968,10 @@ ARG_ANY(1); FID_MEMBER(struct f_tree *, tree, [[!same_tree(f1->tree, f2->tree)]], "tree %p", item->tree); + FID_HAS_TYPED_BODY() + if (filter_tree_has_typed_symbols(item->tree)) + return 1; + FID_INTERPRET_BODY() const struct f_tree *t = find_tree(tree, &v1); if (!t) { diff --git a/filter/filter.h b/filter/filter.h index 84b6b0be..7c4b0ae9 100644 --- a/filter/filter.h +++ b/filter/filter.h @@ -63,6 +63,9 @@ const char *filter_name(const struct filter *filter); int filter_same(const struct filter *new, const struct filter *old); int f_same(const struct f_line *f1, const struct f_line *f2); +int f_has_typed_symbols(const struct f_line *line); +int filter_tree_has_typed_symbols(const struct f_tree *t); + void filter_commit(struct config *new, struct config *old); void filters_dump_all(void); -- 2.24.0

1 0

[RFC PATCH 07/20] add generic pseudo filter check function
by Asbjørn Sloth Tønnesen 30 Dec '19

30 Dec '19

--- filter/filter.c | 9 +++++++-- filter/filter.h | 1 + 2 files changed, 8 insertions(+), 2 deletions(-) diff --git a/filter/filter.c b/filter/filter.c index e505d570..b8147662 100644 --- a/filter/filter.c +++ b/filter/filter.c @@ -413,6 +413,12 @@ f_eval_buf(const struct f_line *expr, struct linpool *tmp_pool, buffer *buf) return fret; } +int +is_pseudo_filter(const struct filter *f) +{ + return f == FILTER_ACCEPT || f == FILTER_REJECT || f == FILTER_UNDEF; +} + /** * filter_same - compare two filters * @new: first filter to be compared @@ -427,8 +433,7 @@ filter_same(const struct filter *new, const struct filter *old) { if (old == new) /* Handle FILTER_ACCEPT and FILTER_REJECT */ return 1; - if (old == FILTER_ACCEPT || old == FILTER_REJECT || - new == FILTER_ACCEPT || new == FILTER_REJECT) + if (is_pseudo_filter(old) || is_pseudo_filter(new)) return 0; if ((!old->sym) && (!new->sym)) diff --git a/filter/filter.h b/filter/filter.h index 9d997efb..84b6b0be 100644 --- a/filter/filter.h +++ b/filter/filter.h @@ -58,6 +58,7 @@ enum filter_return f_eval_rte(const struct f_line *expr, struct rte **rte, struc uint f_eval_int(const struct f_line *expr); enum filter_return f_eval_buf(const struct f_line *expr, struct linpool *tmp_pool, buffer *buf); +int is_pseudo_filter(const struct filter *f); const char *filter_name(const struct filter *filter); int filter_same(const struct filter *new, const struct filter *old); int f_same(const struct f_line *f1, const struct f_line *f2); -- 2.24.0

1 0

[RFC PATCH 06/20] add initial FI_TYPED_CONSTANT instruction
by Asbjørn Sloth Tønnesen 30 Dec '19

30 Dec '19

This instruction will eventually be replaced by FI_CONSTANT. --- filter/f-inst.c | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/filter/f-inst.c b/filter/f-inst.c index 51a35350..37fa0f39 100644 --- a/filter/f-inst.c +++ b/filter/f-inst.c @@ -438,6 +438,15 @@ RESULT_VAL(fstk->vstk[curline.vbase + sym->offset]); } + INST(FI_TYPED_CONSTANT, 0, 1) { + SYMBOL; + NEVER_CONSTANT; + RESULT_TYPE(sym->class & 0xff); + + FID_INTERPRET_BODY() + runtime("FI_TYPED_CONSTANT can't be interpreted", sym); + } + INST(FI_CONSTANT, 0, 1) { FID_MEMBER( struct f_val, -- 2.24.0

1 0

[RFC PATCH 04/20] add support for defining typed symbols
by Asbjørn Sloth Tønnesen 30 Dec '19

30 Dec '19

--- 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

1 0

[RFC PATCH 03/20] add new symbol flags for typed symbols
by Asbjørn Sloth Tønnesen 30 Dec '19

30 Dec '19

--- conf/conf.h | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/conf/conf.h b/conf/conf.h index 6029fee2..39015e62 100644 --- a/conf/conf.h +++ b/conf/conf.h @@ -156,7 +156,11 @@ struct sym_scope { #define SYM_VAL(s) ((s)->val->val) /* Symbol flags */ -#define SYM_FLAG_SAME 0x1 /* For SYM_FUNCTION and SYM_FILTER */ +#define SYM_FLAG_SAME 0x1 /* For SYM_FUNCTION and SYM_FILTER */ +#define SYM_FLAG_IS_TYPED 0x2 /* This is a net_typed symbol */ +#define SYM_FLAG_DO_ADAPT 0x4 /* Tihis symbol must be adapted */ + +#define SYM_FLAGS_TYPED (SYM_FLAG_IS_TYPED | SYM_FLAG_DO_ADAPT) struct include_file_stack { void *buffer; /* Internal lexer state */ -- 2.24.0

1 0

[RFC PATCH 02/20] make symbol types maskable
by Asbjørn Sloth Tønnesen 30 Dec '19

30 Dec '19

--- conf/conf.h | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/conf/conf.h b/conf/conf.h index 21dc3fa1..6029fee2 100644 --- a/conf/conf.h +++ b/conf/conf.h @@ -138,18 +138,20 @@ struct sym_scope { /* Remember to update cf_symbol_class_name() */ #define SYM_VOID 0 -#define SYM_PROTO 1 -#define SYM_TEMPLATE 2 -#define SYM_FUNCTION 3 -#define SYM_FILTER 4 -#define SYM_TABLE 5 -#define SYM_ATTRIBUTE 6 +#define SYM_PROTO 0x1 +#define SYM_TEMPLATE 0x2 +#define SYM_FUNCTION 0x4 +#define SYM_FILTER 0x8 +#define SYM_TABLE 0x10 +#define SYM_ATTRIBUTE 0x20 #define SYM_VARIABLE 0x100 /* 0x100-0x1ff are variable types */ #define SYM_VARIABLE_RANGE SYM_VARIABLE ... (SYM_VARIABLE | 0xff) #define SYM_CONSTANT 0x200 /* 0x200-0x2ff are variable types */ #define SYM_CONSTANT_RANGE SYM_CONSTANT ... (SYM_CONSTANT | 0xff) +#define SYM_TYPEABLE (SYM_CONSTANT | SYM_FUNCTION | SYM_FILTER) + #define SYM_TYPE(s) ((s)->val->type) #define SYM_VAL(s) ((s)->val->val) -- 2.24.0

1 0