/* Declarations that have no ';' at the end. Beware; these are reversed. */
declsn: one_decl { $$.inst = $1; $$.count = 1; }
| one_decl ';' declsn {
- $$ = $3;
- $$.count++;
- $$.inst->next = $1;
+ $1->next = $3.inst;
+ $$.count = $3.count + 1;
+ $$.inst = $1;
}
;
;
symbol_value:
- CF_SYM_CONSTANT { $$ = f_new_inst(FI_CONSTANT_INDIRECT, $1->val); }
+ CF_SYM_CONSTANT { $$ = f_new_inst(FI_VARIABLE, $1); }
| CF_SYM_VARIABLE { $$ = f_new_inst(FI_VARIABLE, $1); }
| CF_SYM_ATTRIBUTE { $$ = f_new_inst(FI_EA_GET, *$1->attribute); }
;
# 7 dump line item callers
# 8 postfixify
# 9 same (filter comparator)
-# 1 struct f_inst_FI_...
-# 2 union in struct f_inst
+# 1 union in struct f_inst
# 3 constructors
#
# Per-inst Diversions:
-# 101 content of struct f_inst_FI_...
+# 101 content of per-inst struct
# 102 constructor arguments
# 103 constructor body
# 104 dump line item content
m4_dnl m4_debugmode(aceflqtx)
m4_define(FID_ZONE, `m4_divert($1) /* $2 for INST_NAME() */')
-m4_define(FID_STRUCT, `FID_ZONE(1, Per-instruction structure)')
-m4_define(FID_UNION, `FID_ZONE(2, Union member)')
+m4_define(FID_INST, `FID_ZONE(1, Instruction structure for config)')
+m4_define(FID_LINE, `FID_ZONE(2, Instruction structure for interpreter)')
m4_define(FID_NEW, `FID_ZONE(3, Constructor)')
m4_define(FID_ENUM, `FID_ZONE(4, Code enum)')
m4_define(FID_ENUM_STR, `FID_ZONE(5, Code enum to string)')
m4_define(FID_DUMP_BODY, `m4_divert(104)m4_define([[FID_DUMP_BODY_EXISTS]])')
m4_define(FID_POSTFIXIFY_BODY, `m4_divert(105)m4_define([[FID_POSTFIXIFY_BODY_EXISTS]])')
m4_define(FID_SAME_BODY, `m4_divert(106)')
+m4_define(FID_LINE_IN, `m4_divert(107)')
m4_define(FID_ALL, `m4_ifdef([[FID_CURDIV]], [[m4_divert(FID_CURDIV)m4_undefine([[FID_CURDIV]])]])')
m4_define(FID_C, `m4_ifelse(TARGET, [[C]], FID_ALL, [[m4_define(FID_CURDIV, m4_divnum)m4_divert(-1)]])')
INST_NAME(),
FID_ENUM_STR
[INST_NAME()] = "INST_NAME()",
-FID_STRUCT
-struct f_inst_[[]]INST_NAME() {
+FID_INST
+struct {
m4_undivert(101)
-};
-FID_UNION
-struct f_inst_[[]]INST_NAME() i_[[]]INST_NAME();
+} i_[[]]INST_NAME();
+FID_LINE
+struct {
+m4_undivert(107)
+} i_[[]]INST_NAME();
FID_NEW
struct f_inst *f_new_inst_]]INST_NAME()[[(enum f_instruction_code fi_code
m4_undivert(102)
what_->fi_code = fi_code;
what_->lineno = ifs->lino;
what_->size = 1;
- struct f_inst_[[]]INST_NAME() *what UNUSED = &(what_->i_[[]]INST_NAME());
+#define what (&(what_->i_]]INST_NAME()[[))
m4_undivert(103)
+#undef what
return what_;
}
FID_DUMP
m4_ifdef([[FID_DUMP_BODY_EXISTS]],
-[[static inline void f_dump_line_item_]]INST_NAME()[[(const struct f_line_item *item, const int indent)]]
-,
+[[static inline void f_dump_line_item_]]INST_NAME()[[(const struct f_line_item *item_, const int indent)]],
[[static inline void f_dump_line_item_]]INST_NAME()[[(const struct f_line_item *item UNUSED, const int indent UNUSED)]])
m4_undefine([[FID_DUMP_BODY_EXISTS]])
{
+#define item (&(item_->i_]]INST_NAME()[[))
m4_undivert(104)
+#undef item
}
FID_ALL
FID_POSTFIXIFY
case INST_NAME(): {
-m4_ifdef([[FID_POSTFIXIFY_BODY_EXISTS]], [[const struct f_inst_]]INST_NAME()[[ *what = &(what_->i_]]INST_NAME()[[);]], [[]])
+#define what (&(what_->i_]]INST_NAME()[[))
+#define item (&(dest->items[pos].i_]]INST_NAME()[[))
m4_undivert(105)
+#undef what
+#undef item
dest->items[pos].fi_code = what_->fi_code;
dest->items[pos].lineno = what_->lineno;
break;
FID_SAME
case INST_NAME():
+#define f1 (&(f1_->i_]]INST_NAME()[[))
+#define f2 (&(f2_->i_]]INST_NAME()[[))
m4_undivert(106)
+#undef f1
+#undef f2
break;
FID_END
m4_dnl dump format string
m4_dnl dump format args
m4_define(FID_MEMBER, `m4_dnl
+FID_LINE_IN
+$1 $2;
FID_STRUCT_IN
$1 $2;
FID_NEW_ARGS
what->$2 = $2;
m4_ifelse($3,,,[[
FID_POSTFIXIFY_BODY
-dest->items[pos].$3 = what->$2;
+item->$3 = what->$2;
]])
m4_ifelse($4,,,[[
FID_SAME_BODY
]])
FID_END')
-m4_define(ARG, `FID_MEMBER(const struct f_inst *, f$1,,,,)
+m4_define(ARG, `
+FID_STRUCT_IN
+const struct f_inst * f$1;
+FID_NEW_ARGS
+, const struct f_inst * f$1
FID_NEW_BODY
+what->f$1 = f$1;
for (const struct f_inst *child = f$1; child; child = child->next) what_->size += child->size;
FID_POSTFIXIFY_BODY
pos = postfixify(dest, what->f$1, pos);
FID_END')
-m4_define(ARG_ANY, `FID_MEMBER(const struct f_inst *, f$1,,,,)
+m4_define(ARG_ANY, `ARG($@)')
+m4_define(LINE, `
+FID_LINE_IN
+const struct f_line * fl$1;
+FID_STRUCT_IN
+const struct f_inst * f$1;
+FID_NEW_ARGS
+, const struct f_inst * f$1
FID_NEW_BODY
-for (const struct f_inst *child = f$1; child; child = child->next) what_->size += child->size;
-FID_POSTFIXIFY_BODY
-pos = postfixify(dest, what->f$1, pos);
-FID_END')
-m4_define(LINE, `FID_MEMBER(const struct f_inst *, f$1,,[[!f_same(f1->lines[$2], f2->lines[$2])]],,)
+what->f$1 = f$1;
FID_DUMP_BODY
-f_dump_line(item->lines[$2], indent + 1);
+f_dump_line(item->fl$1, indent + 1);
FID_POSTFIXIFY_BODY
-dest->items[pos].lines[$2] = f_postfixify(what->f$1);
-FID_END')
-m4_define(LINEP, `FID_STRUCT_IN
-const struct f_line *fl$1;
-FID_DUMP_BODY
-f_dump_line(item->lines[$2], indent + 1)
-FID_POSTFIXIFY_BODY
-dest->items[pos].lines[$2] = what->fl$1;
+item->fl$1 = f_postfixify(what->f$1);
FID_SAME_BODY
-if (!f_same(f1->lines[$2], f2->lines[$2])) return 0;
+if (!f_same(f1->fl$1, f2->fl$1)) return 0;
FID_END')
m4_define(SYMBOL, `FID_MEMBER(const struct symbol *, sym, sym,
[[strcmp(f1->sym->name, f2->sym->name) || (f1->sym->class != f2->sym->class)]], symbol %s, item->sym->name)')
-m4_define(VALI, `FID_MEMBER(struct f_val, vali, val, [[!val_same(&f1->val, &f2->val)]], value %s, val_dump(&item->val))')
-m4_define(VALP, `FID_MEMBER(const struct f_val *, valp,, [[!val_same(&f1->val, &f2->val)]], value %s, val_dump(&item->val))
-FID_POSTFIXIFY_BODY
-dest->items[pos].val = *(what->valp);
-FID_END')
-m4_define(VAR, `m4_dnl
-FID_STRUCT_IN
-const struct f_val *valp;
-const struct symbol *sym;
-FID_NEW_ARGS
-, const struct symbol *sym
-FID_NEW_BODY
-what->valp = (what->sym = sym)->val;
-FID_POSTFIXIFY_BODY
-dest->items[pos].vp = (dest->items[pos].sym = what->sym)->val;
-FID_SAME_BODY
-if (strcmp(f1->sym->name, f2->sym->name) || (f1->sym->class != f2->sym->class)) return 0;
-FID_DUMP_BODY
-debug("%svariable %s with value %s\n", INDENT, item->sym->name, val_dump(item->vp));
-FID_END')
+m4_define(VAL, `FID_MEMBER(struct f_val $1, val, val m4_ifelse($1,,,[0]), [[!val_same(&f1->val, &f2->val)]], value %s, val_dump(&item->val))')
m4_define(FRET, `FID_MEMBER(enum filter_return, fret, fret, f1->fret != f2->fret, %s, filter_return_str(item->fret))')
m4_define(ECS, `FID_MEMBER(enum ec_subtype, ecs, ecs, f1->ecs != f2->ecs, ec subtype %s, ec_subtype_str(item->ecs))')
m4_define(RTC, `FID_MEMBER(const struct rtable_config *, rtc, rtc, [[strcmp(f1->rtc->name, f2->rtc->name)]], route table %s, item->rtc->name)')
/* Line dumpers */
#define INDENT (((const char *) f_dump_line_indent_str) + sizeof(f_dump_line_indent_str) - (indent) - 1)
static const char f_dump_line_indent_str[] = " ";
-void f_dump_line(const struct f_line *dest, int indent);
FID_WR_PUT(6)
-void f_dump_line(const struct f_line *dest, int indent)
+void f_dump_line(const struct f_line *dest, uint indent)
{
if (!dest) {
debug("%sNo filter line (NULL)\n", INDENT);
if (fl1->len != fl2->len)
return 0;
for (uint i=0; i<fl1->len; i++) {
-#define f1 (&(fl1->items[i]))
-#define f2 (&(fl2->items[i]))
- if (f1->fi_code != f2->fi_code)
+#define f1_ (&(fl1->items[i]))
+#define f2_ (&(fl2->items[i]))
+ if (f1_->fi_code != f2_->fi_code)
return 0;
- if (f1->flags != f2->flags)
+ if (f1_->flags != f2_->flags)
return 0;
- switch(f1->fi_code) {
+ switch(f1_->fi_code) {
FID_WR_PUT(9)
}
}
+#undef f1_
+#undef f2_
return 1;
}
/* Filter instruction codes */
enum f_instruction_code {
FID_WR_PUT(4)
-};
-
-/* Per-instruction structures */
-FID_WR_PUT(1)
+} PACKED;
+/* Filter instruction structure for config */
struct f_inst {
const struct f_inst *next; /* Next instruction */
enum f_instruction_code fi_code; /* Instruction code */
int size; /* How many instructions are underneath */
int lineno; /* Line number */
+ union {
+ FID_WR_PUT(1)
+ };
+};
+
+/* Filter line item */
+struct f_line_item {
+ enum f_instruction_code fi_code; /* What to do */
+ enum f_instruction_flags flags; /* Flags, instruction-specific */
+ uint lineno; /* Where */
union {
FID_WR_PUT(2)
};
what->count = len;
FID_END
- if (vstk.cnt < what->count) /* TODO: make this check systematic */
- runtime("Construction of BGP path mask from %u elements must have at least that number of elements", what->count);
+ if (vstk.cnt < whati->count) /* TODO: make this check systematic */
+ runtime("Construction of BGP path mask from %u elements must have at least that number of elements", whati->count);
- struct f_path_mask *pm = lp_alloc(fs->pool, sizeof(struct f_path_mask) + what->count * sizeof(struct f_path_mask_item));
- for (uint i=0; i<what->count; i++) {
-//#define pv vstk.val[vstk.cnt-i-1]
-#define pv vstk.val[vstk.cnt - what->count + i]
+ struct f_path_mask *pm = lp_alloc(fs->pool, sizeof(struct f_path_mask) + whati->count * sizeof(struct f_path_mask_item));
+ for (uint i=0; i<whati->count; i++) {
+#define pv vstk.val[vstk.cnt - whati->count + i]
switch (pv.type) {
case T_PATH_MASK_ITEM:
pm->item[i] = pv.val.pmi;
}
}
- vstk.cnt -= what->count;
- pm->len = what->count;
+ vstk.cnt -= whati->count;
+ pm->len = whati->count;
RESULT(T_PATH_MASK, path_mask, pm);
}
/* some constants have value in a[1], some in *a[0].p, strange. */
INST(FI_CONSTANT, 0, 1) { /* integer (or simple type) constant, string, set, or prefix_set */
- VALI; // res = what->val;
+ FID_LINE_IN
+ struct f_val val;
+ FID_STRUCT_IN
+ struct f_val val;
+ FID_NEW_ARGS
+ , const struct f_val val
+ FID_NEW_BODY
+ what->val = val;
+ FID_POSTFIXIFY_BODY
+ item->val = what->val;
+ FID_SAME_BODY
+ if (!val_same(&(f1->val), &(f2->val))) return 0;
+ FID_DUMP_BODY
+ debug("%svalue %s\n", INDENT, val_dump(&item->val));
+ FID_END
+
+ res = whati->val;
RESULT_OK;
}
INST(FI_VARIABLE, 0, 1) {
- VAR;
- RESULT_OK;
- }
- INST(FI_CONSTANT_INDIRECT, 0, 1) {
- VALP;
+ FID_STRUCT_IN
+ const struct symbol *sym;
+ FID_LINE_IN
+ const struct symbol *sym;
+ const struct f_val *valp;
+ FID_NEW_ARGS
+ , const struct symbol *sym
+ FID_NEW_BODY
+ what->sym = sym;
+ FID_POSTFIXIFY_BODY
+ item->valp = (item->sym = what->sym)->val;
+ FID_SAME_BODY
+ if (strcmp(f1->sym->name, f2->sym->name) || (f1->sym->class != f2->sym->class)) return 0;
+ FID_DUMP_BODY
+ switch (item->sym->class) {
+ case SYM_CONSTANT_RANGE:
+ debug("%sconstant %s with value %s\n", INDENT, item->sym->name, val_dump(item->valp));
+ break;
+ case SYM_VARIABLE_RANGE:
+ debug("%svariable %s with current value %s\n", INDENT, item->sym->name, val_dump(item->valp));
+ break;
+ default:
+ bug("Symbol %s of type %d doesn't reference a value", item->sym->name, item->sym->class);
+ }
+ FID_END
+
+ res = *whati->valp;
RESULT_OK;
}
INST(FI_PRINT, 1, 0) {
}
INST(FI_CALL, 0, 1) {
- /* Do not use the symbol on execution */
- if (0) {
- UNUSED SYMBOL;
- }
-
- /* Postfixify extracts the function body from the symbol */
- FID_POSTFIXIFY_BODY
- dest->items[pos].lines[0] = what->sym->function;
- FID_END
-
- /* First push the body on stack */
- LINEX(what->lines[0]);
- curline.emask |= FE_RETURN;
-
- /* Then push the arguments */
- LINE(1,1);
-
+ FID_LINE_IN
+ const struct f_line *args;
+ const struct f_line *body;
+ struct symbol *sym;
+ FID_STRUCT_IN
+ struct symbol *sym;
+ const struct f_inst *args;
+ FID_NEW_ARGS
+ , struct symbol * sym
+ , const struct f_inst *args
FID_NEW_BODY
if (sym->class != SYM_FUNCTION)
cf_error("You can't call something which is not a function. Really.");
uint count = 0;
- for (const struct f_inst *inst = f1; inst; inst = inst->next)
+ for (const struct f_inst *inst = args; inst; inst = inst->next)
count++;
if (count != sym->function->args)
cf_error("Function %s takes %u arguments, got %u.", sym->name, sym->function->args, count);
+
+ what->sym = sym;
+ what->args = args;
+ FID_DUMP_BODY
+ debug("%scalling %s with following args\n", INDENT, item->sym->name);
+ f_dump_line(item->args, indent + 1);
+ FID_POSTFIXIFY_BODY
+ item->args = f_postfixify(what->args);
+ item->body = (item->sym = what->sym)->function;
+ FID_SAME_BODY
+ /* To be done better */
+ if (strcmp(f1->sym->name, f2->sym->name)) return 0;
+ if (!f_same(f1->args, f2->args)) return 0;
+ if (!f_same(f1->body, f2->body)) return 0;
FID_END
- /* FIXME: Optimization of function comparison. */
+ /* First push the body on stack */
+ LINEX(whati->body);
+ curline.emask |= FE_RETURN;
+
+ /* Then push the arguments */
+ LINEX(whati->args);
}
INST(FI_DROP_RESULT, 1, 0) {
INST(FI_SWITCH, 1, 0) {
ARG_ANY(1);
TREE;
- const struct f_tree *t = find_tree(what->tree, &v1);
- if (!t) {
+ if (!tree) {
v1.type = T_VOID;
- t = find_tree(what->tree, &v1);
- if (!t) {
+ tree = find_tree(tree, &v1);
+ if (!tree) {
debug( "No else statement?\n");
break;
}
}
/* It is actually possible to have t->data NULL */
- LINEX(t->data);
+ LINEX(tree->data);
}
INST(FI_IP_MASK, 2, 1) { /* IP.MASK(val) */
#include "filter/filter.h"
#include "filter/data.h"
+/* Flags for instructions */
+enum f_instruction_flags {
+ FIF_PRINTED = 1, /* FI_PRINT_AND_DIE: message put in buffer */
+} PACKED;
+
/* Include generated filter instruction declarations */
#include "filter/inst-gen.h"
struct f_inst *f_clear_local_vars(struct f_inst *decls);
-/* Flags for instructions */
-enum f_instruction_flags {
- FIF_PRINTED = 1, /* FI_PRINT_AND_DIE: message put in buffer */
-};
-
/* Filter structures for execution */
struct f_line;
-/* The single instruction item */
-struct f_line_item {
- enum f_instruction_code fi_code; /* What to do */
- enum f_instruction_flags flags; /* Flags, instruction-specific */
- uint lineno; /* Where */
- union {
- struct {
- const struct f_val *vp;
- const struct symbol *sym;
- };
- struct f_val val;
- const struct f_line *lines[2];
- enum filter_return fret;
- struct f_static_attr sa;
- struct f_dynamic_attr da;
- enum ec_subtype ecs;
- const char *s;
- const struct f_tree *tree;
- const struct rtable_config *rtc;
- uint count;
- }; /* Additional instruction data */
-};
-
/* Line of instructions to be unconditionally executed one after another */
struct f_line {
uint len; /* Line length */
static inline struct f_line *f_postfixify(const struct f_inst *root)
{ return f_postfixify_concat(&root, 1); }
+void f_dump_line(const struct f_line *, uint indent);
+
struct filter *f_new_where(const struct f_inst *);
static inline struct f_dynamic_attr f_new_dynamic_attr(u8 type, u8 bit, enum f_type f_type, uint code) /* Type as core knows it, type as filters know it, and code of dynamic attribute */
{ return (struct f_dynamic_attr) { .type = type, .bit = bit, .f_type = f_type, .ea_code = code }; } /* f_type currently unused; will be handy for static type checking */
#define curline estk.item[estk.cnt-1]
+#if DEBUGGING
+ debug("Interpreting line.");
+ f_dump_line(line, 1);
+#endif
+
while (estk.cnt > 0) {
while (curline.pos < curline.line->len) {
const struct f_line_item *what = &(curline.line->items[curline.pos++]);
bt_suit_case_result = 0;
}
- bt_log_suite_case_result(bt_suit_case_result, "Assertion at line %d (%s)", assert->lineno, assert->s);
+ bt_log_suite_case_result(bt_suit_case_result, "Assertion at line %d (%s)",
+ assert->lineno, assert->i_FI_ASSERT.s);
}
int
m4_define(INST_FLUSH, `m4_ifdef([[INST_NAME]], [[
m4_divert(1)
case INST_NAME():
+#define whati (&(what->i_]]INST_NAME()[[))
m4_ifelse(m4_eval(INST_INVAL() > 0), 1, [[if (vstk.cnt < INST_INVAL()) runtime("Stack underflow"); vstk.cnt -= INST_INVAL(); ]])
m4_undivert(2)
+#undef whati
break;
m4_divert(-1)
]])')
} while (0)')
m4_define(LINE, `do {
- if (what->lines[$2]) {
+ if (whati->fl$1) {
estk.item[estk.cnt].pos = 0;
- estk.item[estk.cnt].line = what->lines[$2];
+ estk.item[estk.cnt].line = whati->fl$1;
estk.item[estk.cnt].ventry = vstk.cnt;
estk.item[estk.cnt].emask = 0;
estk.cnt++;
}
} while (0)')
-m4_define(LINEP, LINE($1, $2))
-
m4_define(ARG_ANY, `')
-m4_define(SYMBOL, `const struct symbol *sym = what->sym')
+m4_define(SYMBOL, `const struct symbol *sym = whati->sym')
-m4_define(VALI, `res = what->val')
-m4_define(VALP, `res = what->val')
-m4_define(VAR, `res = *what->vp')
-m4_define(FRET, `enum filter_return fret = what->fret')
-m4_define(ECS, `enum ec_subtype ecs = what->ecs')
-m4_define(RTC, `struct rtable *table = what->rtc->table')
-m4_define(STATIC_ATTR, `struct f_static_attr sa = what->sa')
-m4_define(DYNAMIC_ATTR, `struct f_dynamic_attr da = what->da')
-m4_define(TREE, `')
+m4_define(FRET, `enum filter_return fret = whati->fret')
+m4_define(ECS, `enum ec_subtype ecs = whati->ecs')
+m4_define(RTC, `struct rtable *table = whati->rtc->table')
+m4_define(STATIC_ATTR, `struct f_static_attr sa = whati->sa')
+m4_define(DYNAMIC_ATTR, `struct f_dynamic_attr da = whati->da')
+m4_define(TREE, `const struct f_tree *tree = whati->tree')
m4_define(STRING, `')
m4_define(COUNT, `')
m4_define(SAME, `')
m4_define(FID_STRUCT_IN, `m4_divert(-1)')
+m4_define(FID_LINE_IN, `m4_divert(-1)')
m4_define(FID_NEW_ARGS, `m4_divert(-1)')
m4_define(FID_NEW_BODY, `m4_divert(-1)')
m4_define(FID_POSTFIXIFY_BODY, `m4_divert(-1)')
+m4_define(FID_SAME_BODY, `m4_divert(-1)')
+m4_define(FID_DUMP_BODY, `m4_divert(-1)')
m4_define(FID_END, `m4_divert(2)')
m4_m4wrap(`
return 0;
}
+function callmeagain(int a; int b; int c)
+{
+ return a + b + c;
+}
+
function fifteen()
{
return 15;
bt_assert(callme(3, 2) = 6);
bt_assert(callme(4, 4) = 16);
bt_assert(callme(7, 2) = 14);
+ bt_assert(callmeagain(1, 2, 3) = 6);
}
bt_test_suite(t_call_function, "Testing calling functions");
projects / thirdparty / bird.git / commitdiff
