filter/decl.m4

   1 m4_divert(-1)m4_dnl
   2 #
   3 #       BIRD -- Construction of per-instruction structures
   4 #
   5 #       (c) 2018 Maria Matejka <mq@jmq.cz>
   6 #
   7 #       Can be freely distributed and used under the terms of the GNU GPL.
   8 #
   9 #
  10 #       Global Diversions:
  11 #       4       enum fi_code
  12 #       5       enum fi_code to string
  13 #       6       dump line item
  14 #       7       dump line item callers
  15 #       8       linearize
  16 #       9       same (filter comparator)
  17 #       1       union in struct f_inst
  18 #       3       constructors
  19 #       10      interpreter
  20 #
  21 #       Per-inst Diversions:
  22 #       101     content of per-inst struct
  23 #       102     constructor arguments
  24 #       103     constructor body
  25 #       104     dump line item content
  26 #       105     linearize body
  27 #       106     comparator body
  28 #       107     struct f_line_item content
  29 #       108     interpreter body
  30 #
  31 #       Diversions for TARGET=I: 7xx
  32 #       Diversions for TARGET=C: 8xx
  33 #       Diversions for TARGET=H: 9xx
  34
  35 # Flush the completed instruction
  36 m4_define(FID_END, `m4_divert(-1)')
  37
  38 m4_dnl m4_debugmode(aceflqtx)
  39
  40 m4_define(FID_ZONE, `m4_divert($1) /* $2 for INST_NAME() */')
  41 m4_define(FID_INST, `FID_ZONE(1, Instruction structure for config)')
  42 m4_define(FID_LINE, `FID_ZONE(2, Instruction structure for interpreter)')
  43 m4_define(FID_NEW, `FID_ZONE(3, Constructor)')
  44 m4_define(FID_ENUM, `FID_ZONE(4, Code enum)')
  45 m4_define(FID_ENUM_STR, `FID_ZONE(5, Code enum to string)')
  46 m4_define(FID_DUMP, `FID_ZONE(6, Dump line)')
  47 m4_define(FID_DUMP_CALLER, `FID_ZONE(7, Dump line caller)')
  48 m4_define(FID_LINEARIZE, `FID_ZONE(8, Linearize)')
  49 m4_define(FID_SAME, `FID_ZONE(9, Comparison)')
  50 m4_define(FID_INTERPRET, `FID_ZONE(10, Interpret)')
  51
  52 m4_define(FID_STRUCT_IN, `m4_divert(101)')
  53 m4_define(FID_NEW_ARGS, `m4_divert(102)')
  54 m4_define(FID_NEW_BODY, `m4_divert(103)')
  55 m4_define(FID_DUMP_BODY, `m4_divert(104)m4_define([[FID_DUMP_BODY_EXISTS]])')
  56 m4_define(FID_LINEARIZE_BODY, `m4_divert(105)m4_define([[FID_LINEARIZE_BODY_EXISTS]])')
  57 m4_define(FID_SAME_BODY, `m4_divert(106)')
  58 m4_define(FID_LINE_IN, `m4_divert(107)')
  59 m4_define(FID_INTERPRET_BODY, `m4_divert(108)')
  60
  61 m4_define(FID_ALL, `FID_INTERPRET_BODY');
  62
  63 m4_define(FID_ALL_TARGETS, `m4_ifdef([[FID_CURDIV]], [[m4_divert(FID_CURDIV)m4_undefine([[FID_CURDIV]])]])')
  64 m4_define(FID_C, `m4_ifelse(TARGET, [[C]], FID_ALL_TARGETS, [[m4_define(FID_CURDIV, m4_divnum)m4_divert(-1)]])')
  65 m4_define(FID_I, `m4_ifelse(TARGET, [[I]], FID_ALL_TARGETS, [[m4_define(FID_CURDIV, m4_divnum)m4_divert(-1)]])')
  66 m4_define(FID_H, `m4_ifelse(TARGET, [[H]], FID_ALL_TARGETS, [[m4_define(FID_CURDIV, m4_divnum)m4_divert(-1)]])')
  67
  68
  69 m4_define(INST_FLUSH, `m4_ifdef([[INST_NAME]], [[
  70 FID_ENUM
  71 INST_NAME(),
  72 FID_ENUM_STR
  73 [INST_NAME()] = "INST_NAME()",
  74 FID_INST
  75 struct {
  76 m4_undivert(101)
  77 } i_[[]]INST_NAME();
  78 FID_LINE
  79 struct {
  80 m4_undivert(107)
  81 } i_[[]]INST_NAME();
  82 FID_NEW
  83 struct f_inst *f_new_inst_]]INST_NAME()[[(enum f_instruction_code fi_code
  84 m4_undivert(102)
  85 )
  86 FID_H
  87 ;
  88 FID_C
  89 {
  90   struct f_inst *what_ = cfg_allocz(sizeof(struct f_inst));
  91   what_->fi_code = fi_code;
  92   what_->lineno = ifs->lino;
  93   what_->size = 1;
  94 #define what (&(what_->i_]]INST_NAME()[[))
  95 m4_undivert(103)
  96 #undef what
  97   return what_;
  98 }
  99
 100 FID_DUMP_CALLER
 101 case INST_NAME(): f_dump_line_item_]]INST_NAME()[[(item, indent + 1); break;
 102
 103 FID_DUMP
 104 m4_ifdef([[FID_DUMP_BODY_EXISTS]],
 105 [[static inline void f_dump_line_item_]]INST_NAME()[[(const struct f_line_item *item_, const int indent)]],
 106 [[static inline void f_dump_line_item_]]INST_NAME()[[(const struct f_line_item *item UNUSED, const int indent UNUSED)]])
 107 m4_undefine([[FID_DUMP_BODY_EXISTS]])
 108 {
 109 #define item (&(item_->i_]]INST_NAME()[[))
 110 m4_undivert(104)
 111 #undef item
 112 }
 113 FID_ALL_TARGETS
 114
 115 FID_LINEARIZE
 116 case INST_NAME(): {
 117 #define what (&(what_->i_]]INST_NAME()[[))
 118 #define item (&(dest->items[pos].i_]]INST_NAME()[[))
 119   m4_undivert(105)
 120 #undef what
 121 #undef item
 122   break;
 123 }
 124 m4_undefine([[FID_LINEARIZE_BODY_EXISTS]])
 125
 126 FID_SAME
 127 case INST_NAME():
 128 #define f1 (&(f1_->i_]]INST_NAME()[[))
 129 #define f2 (&(f2_->i_]]INST_NAME()[[))
 130 m4_undivert(106)
 131 #undef f1
 132 #undef f2
 133 break;
 134
 135 FID_INTERPRET
 136 case INST_NAME():
 137 #define whati (&(what->i_]]INST_NAME()[[))
 138 m4_ifelse(m4_eval(INST_INVAL() > 0), 1, [[if (fstk->vcnt < INST_INVAL()) runtime("Stack underflow"); fstk->vcnt -= INST_INVAL(); ]])
 139 m4_undivert(108)
 140 #undef whati
 141 break;
 142
 143 FID_END
 144 ]])')
 145
 146 m4_define(INST, `m4_dnl
 147 INST_FLUSH()m4_dnl
 148 m4_define([[INST_NAME]], [[$1]])m4_dnl
 149 m4_define([[INST_INVAL]], [[$2]])m4_dnl
 150 FID_ALL() m4_dnl
 151 ')
 152
 153 m4_dnl FID_MEMBER call:
 154 m4_dnl type
 155 m4_dnl name in f_inst
 156 m4_dnl name in f_line_item
 157 m4_dnl comparator for same
 158 m4_dnl dump format string
 159 m4_dnl dump format args
 160 m4_dnl interpreter body
 161 m4_define(FID_MEMBER, `m4_dnl
 162 FID_LINE_IN
 163 $1 $2;
 164 FID_STRUCT_IN
 165 $1 $2;
 166 FID_NEW_ARGS
 167 , $1 $2
 168 FID_NEW_BODY
 169 what->$2 = $2;
 170 m4_ifelse($3,,,[[
 171 FID_LINEARIZE_BODY
 172 item->$3 = what->$2;
 173 ]])
 174 m4_ifelse($4,,,[[
 175 FID_SAME_BODY
 176 if ($4) return 0;
 177 ]])
 178 m4_ifelse($5,,,[[
 179 FID_DUMP_BODY
 180 debug("%s$5\n", INDENT, $6);
 181 ]])
 182 m4_ifelse($7,,,[[
 183 FID_INTERPRET_BODY
 184 $7
 185 ]])
 186 FID_ALL')
 187
 188 m4_define(ARG_ANY, `
 189 FID_STRUCT_IN
 190 const struct f_inst * f$1;
 191 FID_NEW_ARGS
 192 , const struct f_inst * f$1
 193 FID_NEW_BODY
 194 what->f$1 = f$1;
 195 for (const struct f_inst *child = f$1; child; child = child->next) what_->size += child->size;
 196 FID_LINEARIZE_BODY
 197 pos = linearize(dest, what->f$1, pos);m4_dnl
 198 FID_ALL()')
 199
 200 m4_define(ARG, `ARG_ANY($1)
 201 FID_INTERPRET_BODY
 202 if (v$1.type != $2) runtime("Argument $1 of instruction %s must be of type $2, got 0x%02x", f_instruction_name(what->fi_code), v$1.type)m4_dnl
 203 FID_ALL()')
 204
 205 m4_define(LINEX, `FID_INTERPRET_BODY
 206 do {
 207   fstk->estk[fstk->ecnt].pos = 0;
 208   fstk->estk[fstk->ecnt].line = $1;
 209   fstk->estk[fstk->ecnt].ventry = fstk->vcnt;
 210   fstk->estk[fstk->ecnt].vbase = fstk->estk[fstk->ecnt-1].vbase;
 211   fstk->estk[fstk->ecnt].emask = 0;
 212   fstk->ecnt++;
 213 } while (0)m4_dnl
 214 FID_ALL()')
 215
 216 m4_define(LINE, `
 217 FID_LINE_IN
 218 const struct f_line * fl$1;
 219 FID_STRUCT_IN
 220 const struct f_inst * f$1;
 221 FID_NEW_ARGS
 222 , const struct f_inst * f$1
 223 FID_NEW_BODY
 224 what->f$1 = f$1;
 225 FID_DUMP_BODY
 226 f_dump_line(item->fl$1, indent + 1);
 227 FID_LINEARIZE_BODY
 228 item->fl$1 = f_linearize(what->f$1);
 229 FID_SAME_BODY
 230 if (!f_same(f1->fl$1, f2->fl$1)) return 0;
 231 FID_INTERPRET_BODY
 232 do { if (whati->fl$1) {
 233   LINEX(whati->fl$1);
 234 } } while(0)m4_dnl
 235 FID_ALL()')
 236
 237 m4_define(RESULT_PTR, `
 238 FID_INTERPRET_BODY
 239   do {
 240     enum filter_return fret = f_lval_set(fs, &(what->result), $1);
 241     if (fret != F_NOP) return fret;
 242   } while (0)m4_dnl
 243 FID_ALL()')
 244
 245 m4_define(RESULT, `
 246 FID_INTERPRET_BODY
 247   do {
 248     struct f_val res_ = { .type = $1, .val.$2 = $3 };
 249     RESULT_PTR(&res_);
 250   } while (0)m4_dnl
 251 FID_ALL()')
 252
 253 m4_define(RESULT_VOID, `
 254 FID_INTERPRET_BODY
 255   do {
 256     struct f_val res_ = { .type = T_VOID };
 257     RESULT_PTR(&res_);
 258   } while (0)m4_dnl
 259 FID_ALL()')
 260
 261 m4_define(SYMBOL, `FID_MEMBER(const struct symbol *, sym, sym,
 262 [[strcmp(f1->sym->name, f2->sym->name) || (f1->sym->class != f2->sym->class)]], symbol %s, item->sym->name, const struct symbol *sym = whati->sym)')
 263 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),)')
 264 m4_define(FRET, `FID_MEMBER(enum filter_return, fret, fret, f1->fret != f2->fret, %s, filter_return_str(item->fret), enum filter_return fret = whati->fret)')
 265 m4_define(ECS, `FID_MEMBER(enum ec_subtype, ecs, ecs, f1->ecs != f2->ecs, ec subtype %s, ec_subtype_str(item->ecs), enum ec_subtype ecs = whati->ecs)')
 266 m4_define(RTC, `FID_MEMBER(const struct rtable_config *, rtc, rtc, [[strcmp(f1->rtc->name, f2->rtc->name)]], route table %s, item->rtc->name, struct rtable *table = whati->rtc->table)')
 267 m4_define(STATIC_ATTR, `FID_MEMBER(struct f_static_attr, sa, sa, f1->sa.sa_code != f2->sa.sa_code,,, struct f_static_attr sa = whati->sa)')
 268 m4_define(DYNAMIC_ATTR, `FID_MEMBER(struct f_dynamic_attr, da, da, f1->da.ea_code != f2->da.ea_code,,, struct f_dynamic_attr da = whati->da)')
 269 m4_define(COUNT, `FID_MEMBER(uint, count, count, f1->count != f2->count, number %u, item->count)')
 270 m4_define(TREE, `FID_MEMBER(const struct f_tree *, tree, tree, [[!same_tree(f1->tree, f2->tree)]], tree %p, item->tree, const struct f_tree *tree = whati->tree)')
 271 m4_define(STRING, `FID_MEMBER(const char *, s, s, [[strcmp(f1->s, f2->s)]], string \"%s\", item->s)')
 272
 273 m4_define(FID_WR_PUT_LIST)
 274 m4_define(FID_WR_DROP_LIST)
 275
 276 m4_define(FID_WR_IPUT, `m4_define([[FID_WR_CUR_DIRECT]], m4_eval(FID_WR_CUR_DIRECT + 1))m4_define([[FID_WR_PUT_LIST]], FID_WR_PUT_LIST[[]]FID_WR_DPUT($1)FID_WR_DPUT(FID_WR_CUR_DIRECT))m4_divert(FID_WR_CUR_DIRECT)')
 277 m4_define(FID_WR_IDROP, `m4_define([[FID_WR_CUR_DIRECT]], m4_eval(FID_WR_CUR_DIRECT + 1))m4_define([[FID_WR_DROP_LIST]], FID_WR_DROP_LIST[[]]FID_WR_DPUT($1)FID_WR_DPUT(FID_WR_CUR_DIRECT))m4_divert(FID_WR_CUR_DIRECT)')
 278
 279 m4_define(FID_WR_DIRECT, `m4_define([[FID_WR_CUR_DIRECT]],$1)m4_ifelse(TARGET,[[$2]],[[m4_define([[FID_WR_PUT]], [[FID_WR_IPUT($]][[@)]])m4_define([[FID_WR_PUT_LIST]],FID_WR_PUT_LIST[[]]FID_WR_DPUT($1))]],[[m4_define([[FID_WR_PUT]], [[FID_WR_IDROP($]][[@)]])m4_define([[FID_WR_DROP_LIST]],FID_WR_DROP_LIST[[]]FID_WR_DPUT($1))]])m4_divert($1)')
 280
 281 m4_dnl m4_define(FID_WR_CUR_DIRECT,m4_ifelse(TARGET,`C',800,TARGET,`H',900,m4_errprint(`Bad TARGET: 'TARGET)m4_m4exit(1)))
 282 m4_changequote([[,]])
 283 FID_WR_DIRECT(700,I)
 284 FID_WR_PUT(10)
 285 FID_WR_DIRECT(800,C)
 286 #include "nest/bird.h"
 287 #include "filter/filter.h"
 288 #include "filter/f-inst.h"
 289
 290 /* Instruction codes to string */
 291 static const char * const f_instruction_name_str[] = {
 292 FID_WR_PUT(5)
 293 };
 294
 295 const char *
 296 f_instruction_name(enum f_instruction_code fi)
 297 {
 298   if (fi < (sizeof(f_instruction_name_str) / sizeof(f_instruction_name_str[0])))
 299     return f_instruction_name_str[fi];
 300   else
 301     bug("Got unknown instruction code: %d", fi);
 302 }
 303
 304 /* Instruction constructors */
 305 FID_WR_PUT(3)
 306
 307 /* Line dumpers */
 308 #define INDENT (((const char *) f_dump_line_indent_str) + sizeof(f_dump_line_indent_str) - (indent) - 1)
 309 static const char f_dump_line_indent_str[] = "                                ";
 310
 311 FID_WR_PUT(6)
 312
 313 void f_dump_line(const struct f_line *dest, uint indent)
 314 {
 315   if (!dest) {
 316     debug("%sNo filter line (NULL)\n", INDENT);
 317     return;
 318   }
 319   debug("%sFilter line %p (len=%u)\n", INDENT, dest, dest->len);
 320   for (uint i=0; i<dest->len; i++) {
 321     const struct f_line_item *item = &dest->items[i];
 322     debug("%sInstruction %s at line %u\n", INDENT, f_instruction_name(item->fi_code), item->lineno);
 323
 324     switch (item->result.type) {
 325       case F_LVAL_STACK: debug("%son stack\n", INDENT); break;
 326       case F_LVAL_EXCEPTION: debug("%s=>exception 0x%x\n", INDENT, item->result.exception); break;
 327       case F_LVAL_VARIABLE: debug("%s=>%s\n", INDENT, item->result.sym->name); break;
 328       case F_LVAL_PREFERENCE: debug("%s=>preference\n", INDENT); break;
 329       case F_LVAL_SA: debug("%s=>sa\n", INDENT); break;
 330       case F_LVAL_EA: debug("%s=>ea\n", INDENT); break;
 331     }
 332
 333     switch (item->fi_code) {
 334 FID_WR_PUT(7)
 335       default: bug("Unknown instruction %x in f_dump_line", item->fi_code);
 336     }
 337   }
 338   debug("%sFilter line %p dump done\n", INDENT, dest);
 339 }
 340
 341 /* Linearize */
 342 static uint
 343 linearize(struct f_line *dest, const struct f_inst *what_, uint pos)
 344 {
 345   for ( ; what_; what_ = what_->next) {
 346     switch (what_->fi_code) {
 347 FID_WR_PUT(8)
 348     }
 349     dest->items[pos].fi_code = what_->fi_code;
 350     dest->items[pos].lineno = what_->lineno;
 351     dest->items[pos].result = what_->result;
 352     pos++;
 353   }
 354   return pos;
 355 }
 356
 357 struct f_line *
 358 f_linearize_concat(const struct f_inst * const inst[], uint count)
 359 {
 360   uint len = 0;
 361   for (uint i=0; i<count; i++)
 362     for (const struct f_inst *what = inst[i]; what; what = what->next)
 363       len += what->size;
 364
 365   struct f_line *out = cfg_allocz(sizeof(struct f_line) + sizeof(struct f_line_item)*len);
 366
 367   for (uint i=0; i<count; i++)
 368     out->len = linearize(out, inst[i], out->len);
 369
 370 #if DEBUGGING
 371   f_dump_line(out, 0);
 372 #endif
 373   return out;
 374 }
 375
 376 /* Filter line comparison */
 377 int
 378 f_same(const struct f_line *fl1, const struct f_line *fl2)
 379 {
 380   if ((!fl1) && (!fl2))
 381     return 1;
 382   if ((!fl1) || (!fl2))
 383     return 0;
 384   if (fl1->len != fl2->len)
 385     return 0;
 386   for (uint i=0; i<fl1->len; i++) {
 387 #define f1_ (&(fl1->items[i]))
 388 #define f2_ (&(fl2->items[i]))
 389     if (f1_->fi_code != f2_->fi_code)
 390       return 0;
 391     if (f1_->flags != f2_->flags)
 392       return 0;
 393
 394     if (f1_->result.type != f2_->result.type) return 0;
 395     switch (f1_->result.type) {
 396       case F_LVAL_STACK:
 397         break;
 398       case F_LVAL_EXCEPTION:
 399         if (f1_->result.exception != f2_->result.exception)
 400           return 0;
 401         break;
 402       case F_LVAL_VARIABLE:
 403         if (strcmp(f1_->result.sym->name, f2_->result.sym->name))
 404           return 0;
 405         if (f1_->result.sym->class != f2_->result.sym->class)
 406           return 0;
 407         break;
 408       case F_LVAL_PREFERENCE:
 409         break;
 410       case F_LVAL_SA:
 411         if (f1_->result.sa.sa_code != f2_->result.sa.sa_code)
 412           return 0;
 413         break;
 414       case F_LVAL_EA:
 415         if (f1_->result.da.ea_code != f2_->result.da.ea_code)
 416           return 0;
 417         break;
 418     }
 419
 420     switch(f1_->fi_code) {
 421 FID_WR_PUT(9)
 422     }
 423   }
 424 #undef f1_
 425 #undef f2_
 426   return 1;
 427 }
 428
 429
 430 FID_WR_DIRECT(900,H)
 431 /* Filter instruction codes */
 432 enum f_instruction_code {
 433 FID_WR_PUT(4)
 434 } PACKED;
 435
 436 /* Filter instruction structure for config */
 437 struct f_inst {
 438   struct f_inst *next;                  /* Next instruction */
 439   enum f_instruction_code fi_code;      /* Instruction code */
 440   int size;                             /* How many instructions are underneath */
 441   int lineno;                           /* Line number */
 442   struct f_lval result;                 /* Destination */
 443   union {
 444     FID_WR_PUT(1)
 445   };
 446 };
 447
 448 /* Filter line item */
 449 struct f_line_item {
 450   enum f_instruction_code fi_code;      /* What to do */
 451   enum f_instruction_flags flags;       /* Flags, instruction-specific */
 452   uint lineno;                          /* Where */
 453   struct f_lval result;                 /* Destination */
 454   union {
 455     FID_WR_PUT(2)
 456   };
 457 };
 458
 459 /* Instruction constructors */
 460 FID_WR_PUT(3)
 461
 462 m4_divert(-1)
 463 m4_changequote(`,')
 464
 465 m4_m4wrap(`INST_FLUSH()m4_define(FID_WR_DPUT, [[m4_undivert($1)]])m4_divert(0)FID_WR_PUT_LIST[[]]m4_divert(-1)FID_WR_DROP_LIST[[]]')
 466
 467 m4_changequote([[,]])