filter/config.Y

   1 /*
   2  *      BIRD - filters
   3  *
   4  *      Copyright 1998--2000 Pavel Machek
   5  *
   6  *      Can be freely distributed and used under the terms of the GNU GPL.
   7  *
   8         FIXME: priority of ! should be lower
   9  */
  10
  11 CF_HDR
  12
  13 CF_DEFINES
  14
  15 #define P(a,b) ((a<<8) | b)
  16
  17 CF_DECLS
  18
  19 CF_KEYWORDS(FUNCTION, PRINT, PRINTN, UNSET, RETURN,
  20         ACCEPT, REJECT, ERROR, QUITBIRD,
  21         INT, BOOL, IP, PREFIX, PAIR, SET, STRING, BGPMASK, BGPPATH, CLIST,
  22         IF, THEN, ELSE, CASE,
  23         TRUE, FALSE,
  24         FROM, GW, NET, MASK, SOURCE, SCOPE, CAST, DEST, PREFERENCE,
  25         LEN,
  26         DEFINED,
  27         ADD, DELETE, CONTAINS, RESET,
  28         PREPEND, MATCH,
  29         EMPTY,
  30         FILTER, WHERE, EVAL)
  31
  32 %nonassoc THEN
  33 %nonassoc ELSE
  34
  35 %type <x> term block cmds cmd function_body constant print_one print_list var_list var_listn dynamic_attr static_attr function_call
  36 %type <f> filter filter_body where_filter
  37 %type <i> type break_command pair
  38 %type <e> set_item set_items switch_body
  39 %type <v> set_atom fprefix fprefix_s fipa
  40 %type <s> decls declsn one_decl function_params
  41 %type <h> bgp_path
  42 %type <i> bgp_one
  43
  44 CF_GRAMMAR
  45
  46 CF_ADDTO(conf, filter_def)
  47 filter_def:
  48    FILTER SYM { cf_push_scope( $2 ); } filter_body {
  49      cf_define_symbol($2, SYM_FILTER, $4);
  50      $4->name = $2->name;
  51      DBG( "We have new filter defined (%s)\n", $2->name );
  52      cf_pop_scope();
  53    }
  54  ;
  55
  56 CF_ADDTO(conf, filter_eval)
  57 filter_eval:
  58    EVAL term { f_eval_int($2); }
  59  ;
  60
  61 type:
  62    INT { $$ = T_INT; }
  63  | BOOL { $$ = T_BOOL; }
  64  | IP { $$ = T_IP; }
  65  | PREFIX { $$ = T_PREFIX; }
  66  | PAIR { $$ = T_PAIR; }
  67  | STRING { $$ = T_STRING; }
  68  | BGPMASK { $$ = T_PATH_MASK; }
  69  | BGPPATH { $$ = T_PATH; }
  70  | CLIST { $$ = T_CLIST; }
  71  | type SET {
  72         switch ($1) {
  73           default:
  74                 cf_error( "You can not create sets of this type" );
  75           case T_INT: case T_IP: case T_PREFIX: case T_PAIR:
  76         }
  77         $$ = $1 | T_SET;
  78         }
  79  ;
  80
  81 one_decl:
  82    type SYM {
  83      cf_define_symbol($2, SYM_VARIABLE | $1, NULL);
  84      DBG( "New variable %s type %x\n", $2->name, $1 );
  85      $2->aux = 0;
  86      {
  87        struct f_val * val;
  88        val = cfg_alloc(sizeof(struct f_val));
  89        val->type = $1;
  90        $2->aux2 = val;
  91      }
  92      $$=$2;
  93    }
  94  ;
  95
  96 /* Decls with ';' at the end */
  97 decls: /* EMPTY */ { $$ = NULL; }
  98  | one_decl ';' decls {
  99      $$ = $1;
 100      $$->aux = (int) $3;
 101    }
 102  ;
 103
 104 /* Declarations that have no ';' at the end. */
 105 declsn: one_decl { $$ = $1; }
 106  | declsn ';' one_decl {
 107      $$ = $1;
 108      $$->aux = (int) $3;
 109    }
 110  ;
 111
 112 filter_body:
 113    function_body {
 114      struct filter *f = cfg_alloc(sizeof(struct filter));
 115      f->name = NULL;
 116      f->root = $1;
 117      $$ = f;
 118    }
 119  ;
 120
 121 filter:
 122    SYM {
 123      if ($1->class != SYM_FILTER) cf_error("No such filter");
 124      $$ = $1->def;
 125    }
 126  | filter_body
 127  ;
 128
 129 where_filter:
 130    WHERE term {
 131      /* Construct 'IF term THEN ACCEPT; REJECT;' */
 132      struct filter *f = cfg_alloc(sizeof(struct filter));
 133      struct f_inst *i, *acc, *rej;
 134      acc = f_new_inst();                /* ACCEPT */
 135      acc->code = P('p',',');
 136      acc->a1.p = NULL;
 137      acc->a2.i = F_ACCEPT;
 138      rej = f_new_inst();                /* REJECT */
 139      rej->code = P('p',',');
 140      rej->a1.p = NULL;
 141      rej->a2.i = F_REJECT;
 142      i = f_new_inst();                  /* IF */
 143      i->code = '?';
 144      i->a1.p = $2;
 145      i->a2.p = acc;
 146      i->next = rej;
 147      f->name = NULL;
 148      f->root = i;
 149      $$ = f;
 150   }
 151  ;
 152
 153 function_params:
 154    '(' declsn ')' { DBG( "Have function parameters\n" ); $$=$2; }
 155  | '(' ')' { $$=NULL; }
 156  ;
 157
 158 function_body:
 159    decls '{' cmds '}' {
 160      $$ = $3;
 161    }
 162  ;
 163
 164 CF_ADDTO(conf, function_def)
 165 function_def:
 166    FUNCTION SYM { DBG( "Beginning of function %s\n", $2->name ); cf_push_scope($2); } function_params function_body {
 167      cf_define_symbol($2, SYM_FUNCTION, $5);
 168      $2->aux = (int) $4;
 169      $2->aux2 = $5;
 170      DBG("Hmm, we've got one function here - %s\n", $2->name);
 171      cf_pop_scope();
 172    }
 173  ;
 174
 175 /* Programs */
 176
 177 cmds: /* EMPTY */ { $$ = NULL; }
 178  | cmd cmds {
 179      if ($1) {
 180        if ($1->next)
 181          bug("Command has next already set");
 182        $1->next = $2;
 183        $$ = $1;
 184      } else $$ = $2;
 185    }
 186  ;
 187
 188 block:
 189    cmd {
 190      $$=$1;
 191    }
 192  | '{' cmds '}' {
 193      $$=$2;
 194    }
 195  ;
 196
 197 /*
 198  * Simple types, their bison value is int
 199  */
 200 pair:
 201    '(' NUM ',' NUM ')' { $$ = $2 << 16 | $4; }
 202  ;
 203
 204 /*
 205  * Complex types, their bison value is struct f_val
 206  */
 207 fprefix_s:
 208    IPA '/' NUM %prec '/' {
 209      if (!ip_is_prefix($1, $3)) cf_error("Invalid network prefix: %I/%d", $1, $3);
 210      $$.type = T_PREFIX; $$.val.px.ip = $1; $$.val.px.len = $3;
 211    }
 212  ;
 213
 214 fprefix:
 215    fprefix_s { $$ = $1; }
 216  | fprefix_s '+' { $$ = $1; $$.val.px.len |= LEN_PLUS; }
 217  | fprefix_s '-' { $$ = $1; $$.val.px.len |= LEN_MINUS; }
 218  | fprefix_s '{' NUM ',' NUM '}' { $$ = $1; $$.val.px.len |= LEN_RANGE | ($3 << 16) | ($5 << 8); }
 219  ;
 220
 221 fipa:
 222    IPA %prec PREFIX_DUMMY { $$.type = T_IP; $$.val.px.ip = $1; }
 223  ;
 224
 225 set_atom:
 226    NUM  { $$.type = T_INT; $$.val.i = $1; }
 227  | pair { $$.type = T_PAIR; $$.val.i = $1; }
 228  | fipa { $$ = $1; }
 229  | fprefix { $$ = $1; }
 230  | ENUM {  $$.type = $1 >> 16; $$.val.i = $1 & 0xffff; }
 231  ;
 232
 233 set_item:
 234    set_atom {
 235         $$ = f_new_tree();
 236         $$->from = $1;
 237         if ($1.type != T_PREFIX)
 238                 $$->to = $1;
 239         else {
 240                 $$->to = $1;
 241                 $$->to.val.px.ip = ipa_or( $$->to.val.px.ip, ipa_not( ipa_mkmask( $$->to.val.px.len ) ));
 242         }
 243    }
 244  | set_atom '.' '.' set_atom {
 245         $$ = f_new_tree();
 246         $$->from = $1;
 247         $$->to = $4;
 248         if (($1.type == T_PREFIX) || ($4.type == T_PREFIX)) cf_error( "You can not use prefixes for range" );
 249    }
 250  ;
 251
 252 set_items:
 253    set_item { $$ = $1; }
 254  | set_items ',' set_item { $$ = $3; $$->left = $1; }
 255  ;
 256
 257 switch_body: /* EMPTY */ { $$ = NULL; }
 258  | set_item ':' cmds switch_body {
 259      $$ = $1;
 260      $$->data = $3;
 261      $$->left = $4;
 262    }
 263  | ELSE ':' cmds {
 264      $$ = f_new_tree();
 265      $$->from.type = T_VOID;
 266      $$->to.type = T_VOID;
 267      $$->data = $3;
 268    }
 269  ;
 270
 271 /* CONST '(' expr ')' { $$ = f_new_inst(); $$->code = 'c'; $$->aux = T_INT; $$->a2.i = $3; } */
 272
 273 bgp_one:
 274    NUM { $$ = $1; }
 275  | '?' { $$ = PM_ANY; }
 276  ;
 277
 278 bgp_path:
 279    bgp_one          { $$ = cfg_alloc(sizeof(struct f_path_mask)); $$->next = NULL; $$->val  = $1; }
 280  | bgp_one bgp_path { $$ = cfg_alloc(sizeof(struct f_path_mask)); $$->next = $2;   $$->val  = $1; }
 281  ;
 282
 283 constant:
 284    NUM    { $$ = f_new_inst(); $$->code = 'c'; $$->aux = T_INT;  $$->a2.i = $1; }
 285  | TRUE   { $$ = f_new_inst(); $$->code = 'c'; $$->aux = T_BOOL; $$->a2.i = 1;  }
 286  | FALSE  { $$ = f_new_inst(); $$->code = 'c'; $$->aux = T_BOOL; $$->a2.i = 0;  }
 287  | TEXT   { $$ = f_new_inst(); $$->code = 'c'; $$->aux = T_STRING; $$->a2.p = $1; }
 288  | pair   { $$ = f_new_inst(); $$->code = 'c'; $$->aux = T_PAIR;  $$->a2.i = $1; }
 289  | fipa    { NEW_F_VAL; $$ = f_new_inst(); $$->code = 'C'; $$->a1.p = val; *val = $1; }
 290  | fprefix_s {NEW_F_VAL; $$ = f_new_inst(); $$->code = 'C'; $$->a1.p = val; *val = $1; }
 291  | '[' set_items ']' { DBG( "We've got a set here..." ); $$ = f_new_inst(); $$->code = 'c'; $$->aux = T_SET; $$->a2.p = build_tree($2); DBG( "ook\n" ); }
 292  | ENUM   { $$ = f_new_inst(); $$->code = 'c'; $$->aux = $1 >> 16; $$->a2.i = $1 & 0xffff; }
 293  | '/' bgp_path '/' { NEW_F_VAL; $$ = f_new_inst(); $$->code = 'C'; val->type = T_PATH_MASK; val->val.path_mask = $2; $$->a1.p = val; }
 294  ;
 295
 296 /*
 297  *  Maybe there are no dynamic attributes defined by protocols.
 298  *  For such cases, we force the dynamic_attr list to contain
 299  *  at least an invalid token, so it's syntantically correct.
 300  */
 301 CF_ADDTO(dynamic_attr, INVALID_TOKEN { $$ = NULL; })
 302
 303 rtadot: /* EMPTY, we are not permitted RTA. prefix */
 304  ;
 305
 306 function_call:
 307    SYM '(' var_list ')' {
 308      struct symbol *sym;
 309      struct f_inst *inst = $3;
 310      if ($1->class != SYM_FUNCTION)
 311        cf_error("You can not call something which is not function. Really.");
 312      DBG("You are calling function %s\n", $1->name);
 313      $$ = f_new_inst();
 314      $$->code = P('c','a');
 315      $$->a1.p = inst;
 316      $$->a2.p = $1->aux2;
 317      sym = (void *) $1->aux;
 318      while (sym || inst) {
 319        if (!sym || !inst)
 320          cf_error("wrong number of arguments for function %s.", $1->name);
 321        DBG( "You should pass parameter called %s\n", sym->name);
 322        inst->a1.p = sym;
 323        sym = (void *) sym->aux;
 324        inst = inst->next;
 325      }
 326    }
 327  ;
 328
 329 static_attr:
 330    FROM    { $$ = f_new_inst(); $$->aux = T_IP;         $$->a2.i = OFFSETOF(struct rta, from);   $$->a1.i = 1; }
 331
 332  | GW      { $$ = f_new_inst(); $$->aux = T_IP;         $$->a2.i = OFFSETOF(struct rta, gw);     $$->a1.i = 1; }
 333  | NET     { $$ = f_new_inst(); $$->aux = T_PREFIX;     $$->a2.i = 0x12345678; /* This is actually ok - T_PREFIX is special-cased. */ }
 334  | SOURCE  { $$ = f_new_inst(); $$->aux = T_ENUM_RTS;   $$->a2.i = OFFSETOF(struct rta, source); }
 335  | SCOPE   { $$ = f_new_inst(); $$->aux = T_ENUM_SCOPE; $$->a2.i = OFFSETOF(struct rta, scope);  $$->a1.i = 1; }
 336  | CAST    { $$ = f_new_inst(); $$->aux = T_ENUM_RTC;   $$->a2.i = OFFSETOF(struct rta, cast); }
 337  | DEST    { $$ = f_new_inst(); $$->aux = T_ENUM_RTD;   $$->a2.i = OFFSETOF(struct rta, dest); }
 338  ;
 339
 340 term:
 341    '(' term ')'      { $$ = $2; }
 342  | term '+' term     { $$ = f_new_inst(); $$->code = '+';        $$->a1.p = $1; $$->a2.p = $3; }
 343  | term '-' term     { $$ = f_new_inst(); $$->code = '-';        $$->a1.p = $1; $$->a2.p = $3; }
 344  | term '*' term     { $$ = f_new_inst(); $$->code = '*';        $$->a1.p = $1; $$->a2.p = $3; }
 345  | term '/' term     { $$ = f_new_inst(); $$->code = '/';        $$->a1.p = $1; $$->a2.p = $3; }
 346  | term AND term     { $$ = f_new_inst(); $$->code = '&';        $$->a1.p = $1; $$->a2.p = $3; }
 347  | term OR  term     { $$ = f_new_inst(); $$->code = '|';        $$->a1.p = $1; $$->a2.p = $3; }
 348  | term '=' term     { $$ = f_new_inst(); $$->code = P('=','='); $$->a1.p = $1; $$->a2.p = $3; }
 349  | term NEQ term { $$ = f_new_inst(); $$->code = P('!','=');     $$->a1.p = $1; $$->a2.p = $3; }
 350  | term '<' term     { $$ = f_new_inst(); $$->code = '<';        $$->a1.p = $1; $$->a2.p = $3; }
 351  | term LEQ term { $$ = f_new_inst(); $$->code = P('<','=');     $$->a1.p = $1; $$->a2.p = $3; }
 352  | term '>' term     { $$ = f_new_inst(); $$->code = '<';        $$->a1.p = $3; $$->a2.p = $1; }
 353  | term GEQ term { $$ = f_new_inst(); $$->code = P('<','=');     $$->a1.p = $3; $$->a2.p = $1; }
 354  | term '~' term     { $$ = f_new_inst(); $$->code = '~';        $$->a1.p = $1; $$->a2.p = $3; }
 355  | '!' term { $$ = f_new_inst(); $$->code = '!'; $$->a1.p = $2; }
 356  | DEFINED '(' term ')' { $$ = f_new_inst(); $$->code = P('d','e');  $$->a1.p = $3; }
 357
 358  | constant { $$ = $1; }
 359  | SYM {
 360      $$ = f_new_inst();
 361      switch ($1->class) {
 362        case SYM_NUMBER:
 363         $$ = f_new_inst();
 364         $$->code = 'c';
 365         $$->aux = T_INT;
 366         $$->a2.i = $1->aux;
 367         break;
 368        case SYM_IPA:
 369         { NEW_F_VAL; $$ = f_new_inst(); $$->code = 'C'; $$->a1.p = val; val->type = T_IP; val->val.px.ip = * (ip_addr *) ($1->def); }
 370         break;
 371        case SYM_VARIABLE | T_INT:
 372        case SYM_VARIABLE | T_PAIR:
 373        case SYM_VARIABLE | T_PREFIX:
 374        case SYM_VARIABLE | T_IP:
 375        case SYM_VARIABLE | T_PATH_MASK:
 376        case SYM_VARIABLE | T_PATH:
 377        case SYM_VARIABLE | T_CLIST:
 378          $$->code = 'C';
 379          $$->a1.p = $1->aux2;
 380          break;
 381        default:
 382          cf_error("Can not use this class of symbol (%s,%x) as variable.", $1->name, $1->class );
 383      }
 384    }
 385
 386  | PREFERENCE { $$ = f_new_inst(); $$->code = 'P'; }
 387
 388  | rtadot static_attr { $$ = $2; $$->code = 'a'; }
 389
 390  | rtadot dynamic_attr { $$ = $2; $$->code = P('e','a'); }
 391
 392  | term '.' IP { $$ = f_new_inst(); $$->code = P('c','p'); $$->a1.p = $1; $$->aux = T_IP; }
 393  | term '.' LEN { $$ = f_new_inst(); $$->code = 'L'; $$->a1.p = $1; }
 394  | term '.' MASK '(' term ')' { $$ = f_new_inst(); $$->code = P('i','M'); $$->a1.p = $1; $$->a2.p = $5; }
 395
 396 /* Communities */
 397 /* This causes one shift/reduce conflict
 398  | rtadot dynamic_attr '.' ADD '(' term ')' { }
 399  | rtadot dynamic_attr '.' DELETE '(' term ')' { }
 400  | rtadot dynamic_attr '.' CONTAINS '(' term ')' { }
 401  | rtadot dynamic_attr '.' RESET{ }
 402 */
 403
 404  | '+' EMPTY '+' { $$ = f_new_inst(); $$->code = 'E'; $$->aux = T_PATH; }
 405  | '-' EMPTY '-' { $$ = f_new_inst(); $$->code = 'E'; $$->aux = T_CLIST; }
 406  | PREPEND '(' term ',' term ')' { $$ = f_new_inst(); $$->code = P('A','p'); $$->a1.p = $3; $$->a2.p = $5; }
 407  | ADD '(' term ',' term ')' { $$ = f_new_inst(); $$->code = P('C','a'); $$->a1.p = $3; $$->a2.p = $5; $$->aux = 'a'; }
 408  | DELETE '(' term ',' term ')' { $$ = f_new_inst(); $$->code = P('C','a'); $$->a1.p = $3; $$->a2.p = $5; $$->aux = 'd'; }
 409
 410 /* | term '.' LEN { $$->code = P('P','l'); } */
 411
 412 /* function_call is inlined here */
 413  | SYM '(' var_list ')' {
 414      struct symbol *sym;
 415      struct f_inst *inst = $3;
 416      if ($1->class != SYM_FUNCTION)
 417        cf_error("You can not call something which is not function. Really.");
 418      DBG("You are calling function %s\n", $1->name);
 419      $$ = f_new_inst();
 420      $$->code = P('c','a');
 421      $$->a1.p = inst;
 422      $$->a2.p = $1->aux2;
 423      sym = (void *) $1->aux;
 424      while (sym || inst) {
 425        if (!sym || !inst)
 426          cf_error("wrong number of arguments for function %s.", $1->name);
 427        DBG( "You should pass parameter called %s\n", sym->name);
 428        inst->a1.p = sym;
 429        sym = (void *) sym->aux;
 430        inst = inst->next;
 431      }
 432    }
 433  ;
 434
 435 break_command:
 436    QUITBIRD { $$ = F_QUITBIRD }
 437  | ACCEPT { $$ = F_ACCEPT }
 438  | REJECT { $$ = F_REJECT }
 439  | ERROR { $$ = F_ERROR }
 440  | PRINT { $$ = F_NOP }
 441  | PRINTN { $$ = F_NONL }
 442  ;
 443
 444 print_one:
 445    term { $$ = f_new_inst(); $$->code = 'p'; $$->a1.p = $1; $$->a2.p = NULL; }
 446  ;
 447
 448 print_list: /* EMPTY */ { $$ = NULL; }
 449  | print_one { $$ = $1; }
 450  | print_one ',' print_list {
 451      if ($1) {
 452        $1->next = $3;
 453        $$ = $1;
 454      } else $$ = $3;
 455    }
 456
 457  ;
 458
 459 var_listn: term {
 460      $$ = f_new_inst();
 461      $$->code = 's';
 462      $$->a1.p = NULL;
 463      $$->a2.p = $1;
 464      $$->next = NULL;
 465    }
 466  | term ',' var_listn {
 467      $$ = f_new_inst();
 468      $$->code = 's';
 469      $$->a1.p = NULL;
 470      $$->a2.p = $1;
 471      $$->next = $3;
 472    }
 473  ;
 474
 475 var_list: /* EMPTY */ { $$ = NULL; }
 476  | var_listn { $$ = $1; }
 477  ;
 478
 479 cmd:
 480    IF term THEN block {
 481      $$ = f_new_inst();
 482      $$->code = '?';
 483      $$->a1.p = $2;
 484      $$->a2.p = $4;
 485    }
 486  | IF term THEN block ELSE block {
 487      struct f_inst *i = f_new_inst();
 488      i->code = '?';
 489      i->a1.p = $2;
 490      i->a2.p = $4;
 491      $$ = f_new_inst();
 492      $$->code = '?';
 493      $$->a1.p = i;
 494      $$->a2.p = $6;
 495    }
 496  | SYM '=' term ';' {
 497      $$ = f_new_inst();
 498      DBG( "Ook, we'll set value\n" );
 499      if (($1->class & ~T_MASK) != SYM_VARIABLE)
 500        cf_error( "You may only set variables, and this is %x.", $1->class );
 501      $$->code = 's';
 502      $$->a1.p = $1;
 503      $$->a2.p = $3;
 504    }
 505  | RETURN term ';' {
 506      $$ = f_new_inst();
 507      DBG( "Ook, we'll return the value\n" );
 508      $$->code = 'r';
 509      $$->a1.p = $2;
 510    }
 511  | rtadot dynamic_attr '=' term ';' {
 512      $$ = $2;
 513      $$->code = P('e','S');
 514      $$->a1.p = $4;
 515    }
 516  | rtadot static_attr '=' term ';' {
 517      $$ = $2;
 518      if (!$$->a1.i)
 519        cf_error( "This static attribute is read-only.");
 520      $$->code = P('a','S');
 521      $$->a1.p = $4;
 522    }
 523  | PREFERENCE '=' term ';' {
 524      $$ = f_new_inst();
 525      $$->code = P('P','S');
 526      $$->a1.p = $3;
 527    }
 528  | UNSET '(' rtadot dynamic_attr ')' ';' {
 529      $$ = $4;
 530      $$->aux = EAF_TYPE_UNDEF | EAF_TEMP;
 531      $$->code = P('e','S');
 532      $$->a1.p = NULL;
 533    }
 534  | break_command print_list ';' { $$ = f_new_inst(); $$->code = P('p',','); $$->a1.p = $2; $$->a2.i = $1; }
 535  | function_call ';' { $$ = $1; }
 536  | CASE term '{' switch_body '}' {
 537       $$ = f_new_inst();
 538       $$->code = P('S','W');
 539       $$->a1.p = $2;
 540       $$->a2.p = build_tree( $4 );
 541    }
 542
 543
 544  | rtadot dynamic_attr '.' EMPTY ';'
 545   { struct f_inst *i = f_new_inst(); i->code = 'E'; i->aux = T_CLIST; $$ = $2; $$->code = P('e','S'); $$->a1.p = i; }
 546  | rtadot dynamic_attr '.' PREPEND '(' term ')' ';'   { $$ = f_generate_complex( P('A','p'), 'x', $2, $6 ); }
 547  | rtadot dynamic_attr '.' ADD '(' term ')' ';'       { $$ = f_generate_complex( P('C','a'), 'a', $2, $6 ); }
 548  | rtadot dynamic_attr '.' DELETE '(' term ')' ';'    { $$ = f_generate_complex( P('C','a'), 'd', $2, $6 ); }
 549  ;
 550
 551 CF_END