Filter: refactoring of instruction constructors

1 files changed, 117 insertions, 105 deletions

diff --git a/filter/filter.h b/filter/filter.h
index 87bd2c36..39f16e93 100644
--- a/filter/filter.h
+++ b/filter/filter.h
@@ -2,6 +2,7 @@
  *	BIRD Internet Routing Daemon -- Filters
  *
  *	(c) 1999 Pavel Machek <pavel@ucw.cz>
+ *	(c) 2018--2019 Maria Matejka <mq@jmq.cz>
  *
  *	Can be freely distributed and used under the terms of the GNU GPL.
  */
@@ -11,6 +12,7 @@
 
 #include "lib/resource.h"
 #include "lib/ip.h"
+#include "lib/macro.h"
 #include "nest/route.h"
 #include "nest/attrs.h"
 
@@ -115,71 +117,80 @@ struct f_static_attr {
   int readonly:1;			/* Don't allow writing */
 };
 
-/* Filter instruction words */
-#define FI__TWOCHAR(a,b)	((a<<8) | b)
+/* Possible return values of filter execution */
+enum filter_return {
+  F_NOP = 0,
+  F_NONL,
+  F_RETURN,
+  F_ACCEPT,   /* Need to preserve ordering: accepts < rejects! */
+  F_REJECT,
+  F_ERROR,
+  F_QUITBIRD,
+};
+
+/* Filter instruction declarations */
 #define FI__LIST \
-  F(FI_NOP,			  0, '0') \
-  F(FI_ADD,			  0, '+') \
-  F(FI_SUBTRACT,		  0, '-') \
-  F(FI_MULTIPLY,		  0, '*') \
-  F(FI_DIVIDE,			  0, '/') \
-  F(FI_AND,			  0, '&') \
-  F(FI_OR,			  0, '|') \
-  F(FI_PAIR_CONSTRUCT,		'm', 'p') \
-  F(FI_EC_CONSTRUCT,		'm', 'c') \
-  F(FI_LC_CONSTRUCT,		'm', 'l') \
-  F(FI_PATHMASK_CONSTRUCT,	'm', 'P') \
-  F(FI_NEQ,			'!', '=') \
-  F(FI_EQ,			'=', '=') \
-  F(FI_LT,			  0, '<') \
-  F(FI_LTE,			'<', '=') \
-  F(FI_NOT,			  0, '!') \
-  F(FI_MATCH,			  0, '~') \
-  F(FI_NOT_MATCH,		'!', '~') \
-  F(FI_DEFINED,			'd', 'e') \
-  F(FI_TYPE,			  0, 'T') \
-  F(FI_IS_V4,			'I', 'i') \
-  F(FI_SET,			  0, 's') \
-  F(FI_CONSTANT,		  0, 'c') \
-  F(FI_VARIABLE,		  0, 'V') \
-  F(FI_CONSTANT_INDIRECT,	  0, 'C') \
-  F(FI_PRINT,			  0, 'p') \
-  F(FI_CONDITION,		  0, '?') \
-  F(FI_PRINT_AND_DIE,		'p', ',') \
-  F(FI_RTA_GET,			  0, 'a') \
-  F(FI_RTA_SET,			'a', 'S') \
-  F(FI_EA_GET,			'e', 'a') \
-  F(FI_EA_SET,			'e', 'S') \
-  F(FI_PREF_GET,		  0, 'P') \
-  F(FI_PREF_SET,		'P', 'S') \
-  F(FI_LENGTH,			  0, 'L') \
-  F(FI_ROA_MAXLEN,		'R', 'M') \
-  F(FI_ROA_ASN,			'R', 'A') \
-  F(FI_SADR_SRC,		'n', 's') \
-  F(FI_IP,			'c', 'p') \
-  F(FI_ROUTE_DISTINGUISHER,	'R', 'D') \
-  F(FI_AS_PATH_FIRST,		'a', 'f') \
-  F(FI_AS_PATH_LAST,		'a', 'l') \
-  F(FI_AS_PATH_LAST_NAG,	'a', 'L') \
-  F(FI_RETURN,			  0, 'r') \
-  F(FI_CALL,			'c', 'a') \
-  F(FI_DROP_RESULT,		'd', 'r') \
-  F(FI_CLEAR_LOCAL_VARS,	'c', 'V') \
-  F(FI_SWITCH,			'S', 'W') \
-  F(FI_IP_MASK,			'i', 'M') \
-  F(FI_PATH_PREPEND,		'A', 'p') \
-  F(FI_CLIST_ADD,		'C', 'a') \
-  F(FI_CLIST_DEL,		'C', 'd') \
-  F(FI_CLIST_FILTER,		'C', 'f') \
-  F(FI_ROA_CHECK_IMPLICIT,	'R', 'i') \
-  F(FI_ROA_CHECK_EXPLICIT,	'R', 'e') \
-  F(FI_FORMAT,			  0, 'F') \
-  F(FI_ASSERT,			'a', 's')
+  F(FI_NOP) \
+  F(FI_ADD, ARG, ARG) \
+  F(FI_SUBTRACT, ARG, ARG) \
+  F(FI_MULTIPLY, ARG, ARG) \
+  F(FI_DIVIDE, ARG, ARG) \
+  F(FI_AND, ARG, LINE) \
+  F(FI_OR, ARG, LINE) \
+  F(FI_PAIR_CONSTRUCT, ARG, ARG) \
+  F(FI_EC_CONSTRUCT, ARG, ARG, ECS) \
+  F(FI_LC_CONSTRUCT, ARG, ARG, ARG) \
+  F(FI_PATHMASK_CONSTRUCT, ARG, COUNT) \
+  F(FI_NEQ, ARG, ARG) \
+  F(FI_EQ, ARG, ARG) \
+  F(FI_LT, ARG, ARG) \
+  F(FI_LTE, ARG, ARG) \
+  F(FI_NOT, ARG) \
+  F(FI_MATCH, ARG, ARG) \
+  F(FI_NOT_MATCH, ARG, ARG) \
+  F(FI_DEFINED, ARG) \
+  F(FI_TYPE, ARG) \
+  F(FI_IS_V4, ARG) \
+  F(FI_SET, ARG, SYMBOL) \
+  F(FI_CONSTANT, VALI) \
+  F(FI_VARIABLE, SYMBOL) \
+  F(FI_CONSTANT_INDIRECT, VALP) \
+  F(FI_PRINT, ARG) \
+  F(FI_CONDITION, ARG, LINE, LINE) \
+  F(FI_PRINT_AND_DIE, ARG, FRET) \
+  F(FI_RTA_GET, SA) \
+  F(FI_RTA_SET, SA, ARG) \
+  F(FI_EA_GET, EA) \
+  F(FI_EA_SET, EA, ARG) \
+  F(FI_EA_UNSET, EA) \
+  F(FI_PREF_GET) \
+  F(FI_PREF_SET, ARG) \
+  F(FI_LENGTH, ARG) \
+  F(FI_ROA_MAXLEN, ARG) \
+  F(FI_ROA_ASN, ARG) \
+  F(FI_SADR_SRC, ARG) \
+  F(FI_IP, ARG) \
+  F(FI_ROUTE_DISTINGUISHER, ARG) \
+  F(FI_AS_PATH_FIRST, ARG) \
+  F(FI_AS_PATH_LAST, ARG) \
+  F(FI_AS_PATH_LAST_NAG, ARG) \
+  F(FI_RETURN, ARG) \
+  F(FI_CALL, SYMBOL, LINE) \
+  F(FI_DROP_RESULT, ARG) \
+  F(FI_SWITCH, ARG, TREE) \
+  F(FI_IP_MASK, ARG, ARG) \
+  F(FI_PATH_PREPEND, ARG, ARG) \
+  F(FI_CLIST_ADD, ARG, ARG) \
+  F(FI_CLIST_DEL, ARG, ARG) \
+  F(FI_CLIST_FILTER, ARG, ARG) \
+  F(FI_ROA_CHECK_IMPLICIT, RTC) \
+  F(FI_ROA_CHECK_EXPLICIT, ARG, ARG, RTC) \
+  F(FI_FORMAT, ARG) \
+  F(FI_ASSERT, ARG, STRING)
 
 /* The enum itself */
 enum f_instruction_code {
-#define F(c,a,b) \
-  c,
+#define F(c, ...) c,
 FI__LIST
 #undef F
   FI__MAX,
@@ -188,47 +199,50 @@ FI__LIST
 /* Convert the instruction back to the enum name */
 const char *f_instruction_name(enum f_instruction_code fi);
 
+struct f_inst;
+void f_inst_next(struct f_inst *first, const struct f_inst *append);
+struct f_inst *f_clear_local_vars(struct f_inst *decls);
+
+#define FIA(x)	, FIA_##x
+#define FIA_ARG	const struct f_inst *
+#define FIA_LINE const struct f_inst *
+#define FIA_COUNT uint
+#define FIA_SYMBOL const struct symbol *
+#define FIA_VALI struct f_val
+#define FIA_VALP const struct f_val *
+#define FIA_FRET enum filter_return
+#define FIA_ECS enum ec_subtype
+#define FIA_SA struct f_static_attr
+#define FIA_EA struct f_dynamic_attr
+#define FIA_RTC const struct rtable_config *
+#define FIA_TREE const struct f_tree *
+#define FIA_STRING const char *
+#define F(c, ...) \
+  struct f_inst *f_new_inst_##c(enum f_instruction_code MACRO_IFELSE(MACRO_ISLAST(__VA_ARGS__))()(MACRO_FOREACH(FIA, __VA_ARGS__)));
+FI__LIST
+#undef F
+#undef FIA_ARG
+#undef FIA_LINE
+#undef FIA_LINEP
+#undef FIA_COUNT
+#undef FIA_SYMBOL
+#undef FIA_VALI
+#undef FIA_VALP
+#undef FIA_FRET
+#undef FIA_ECS
+#undef FIA_SA
+#undef FIA_EA
+#undef FIA_RTC
+#undef FIA_STRING
+#undef FIA
+
+#define f_new_inst(...) MACRO_CONCAT_AFTER(f_new_inst_, MACRO_FIRST(__VA_ARGS__))(__VA_ARGS__)
+
+/* Flags for instructions */
 enum f_instruction_flags {
   FIF_PRINTED = 1,		/* FI_PRINT_AND_DIE: message put in buffer */
 };
 
-union f_inst_attr {
-  uint i;
-  void *p;
-  struct rtable_config *rtc;
-};
-
-/* Instruction structure for config */
-struct f_inst {
-  struct f_inst *next;	/* Next instruction to be executed */
-  enum f_instruction_code fi_code;	/* The instruction itself */
-  u16 aux;		/* Extension to instruction code, T_*, EA_*, EAF_*  */
-  union {
-    union f_inst_attr a[3];		/* The three arguments */
-    struct f_val val;	/* The value if FI_CONSTANT */
-    struct {
-      union f_inst_attr sa_a[1];
-      struct f_static_attr sa;	/* Static attribute def for FI_RTA_* */
-    };
-    struct {
-      union f_inst_attr da_a[1];
-      struct f_dynamic_attr da; /* Dynamic attribute def for FI_EA_* */
-    };
-  };
-  int lineno;
-};
-
-/* Possible return values of filter execution */
-enum filter_return {
-  F_NOP = 0,
-  F_NONL,
-  F_RETURN,
-  F_ACCEPT,   /* Need to preserve ordering: accepts < rejects! */
-  F_REJECT,
-  F_ERROR,
-  F_QUITBIRD,
-};
-
 /* Filter structures for execution */
 struct f_line;
 
@@ -242,6 +256,7 @@ struct f_line_item {
       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;
@@ -267,9 +282,9 @@ struct filter {
 };
 
 /* Convert the f_inst infix tree to the f_line structures */
-struct f_line *f_postfixify_concat(struct f_inst *root, ...);
-static inline struct f_line *f_postfixify(struct f_inst *root)
-{ return f_postfixify_concat(root, NULL); }
+struct f_line *f_postfixify_concat(const struct f_inst * const inst[], uint count);
+static inline struct f_line *f_postfixify(const struct f_inst *root)
+{ return f_postfixify_concat(&root, 1); }
 
 #define F_VAL_STACK_MAX	4096
 
@@ -295,12 +310,9 @@ struct f_exec_stack {
     enum f_exception emask;		/* Exception mask */
   } item[F_EXEC_STACK_MAX];
   uint cnt;				/* Current stack size; 0 for empty */
-  
 };
 
-struct f_inst *f_new_inst(enum f_instruction_code fi_code);
-struct f_inst *f_new_inst_da(enum f_instruction_code fi_code, struct f_dynamic_attr da);
-struct f_inst *f_new_inst_sa(enum f_instruction_code fi_code, struct f_static_attr sa);
+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 */
 static inline struct f_static_attr f_new_static_attr(int f_type, int code, int readonly)