Annotation of embedaddon/bird/conf/cf-lex.l, revision 1.1
1.1 ! misho 1: /*
! 2: * BIRD -- Configuration Lexer
! 3: *
! 4: * (c) 1998--2000 Martin Mares <mj@ucw.cz>
! 5: *
! 6: * Can be freely distributed and used under the terms of the GNU GPL.
! 7: */
! 8:
! 9: /**
! 10: * DOC: Lexical analyzer
! 11: *
! 12: * The lexical analyzer used for configuration files and CLI commands
! 13: * is generated using the |flex| tool accompanied by a couple of
! 14: * functions maintaining the hash tables containing information about
! 15: * symbols and keywords.
! 16: *
! 17: * Each symbol is represented by a &symbol structure containing name
! 18: * of the symbol, its lexical scope, symbol class (%SYM_PROTO for a
! 19: * name of a protocol, %SYM_CONSTANT for a constant etc.) and class
! 20: * dependent data. When an unknown symbol is encountered, it's
! 21: * automatically added to the symbol table with class %SYM_VOID.
! 22: *
! 23: * The keyword tables are generated from the grammar templates
! 24: * using the |gen_keywords.m4| script.
! 25: */
! 26:
! 27: %{
! 28: #undef REJECT /* Avoid name clashes */
! 29:
! 30: #include <errno.h>
! 31: #include <stdlib.h>
! 32: #include <stdarg.h>
! 33: #include <stdint.h>
! 34: #include <unistd.h>
! 35: #include <libgen.h>
! 36: #include <glob.h>
! 37: #include <fcntl.h>
! 38: #include <sys/stat.h>
! 39: #include <sys/types.h>
! 40: #include <sys/stat.h>
! 41:
! 42: #define PARSER 1
! 43:
! 44: #include "nest/bird.h"
! 45: #include "nest/route.h"
! 46: #include "nest/protocol.h"
! 47: #include "filter/filter.h"
! 48: #include "conf/conf.h"
! 49: #include "conf/cf-parse.tab.h"
! 50: #include "lib/string.h"
! 51:
! 52: struct keyword {
! 53: byte *name;
! 54: int value;
! 55: struct keyword *next;
! 56: };
! 57:
! 58: #include "conf/keywords.h"
! 59:
! 60: #define KW_HASH_SIZE 64
! 61: static struct keyword *kw_hash[KW_HASH_SIZE];
! 62: static int kw_hash_inited;
! 63:
! 64: #define SYM_HASH_SIZE 128
! 65:
! 66: struct sym_scope {
! 67: struct sym_scope *next; /* Next on scope stack */
! 68: struct symbol *name; /* Name of this scope */
! 69: int active; /* Currently entered */
! 70: };
! 71: static struct sym_scope *conf_this_scope;
! 72:
! 73: static int cf_hash(byte *c);
! 74: static inline struct symbol * cf_get_sym(byte *c, uint h0);
! 75:
! 76: linpool *cfg_mem;
! 77:
! 78: int (*cf_read_hook)(byte *buf, unsigned int max, int fd);
! 79: struct include_file_stack *ifs;
! 80: static struct include_file_stack *ifs_head;
! 81:
! 82: #define MAX_INCLUDE_DEPTH 8
! 83:
! 84: #define YY_INPUT(buf,result,max) result = cf_read_hook(buf, max, ifs->fd);
! 85: #define YY_NO_UNPUT
! 86: #define YY_FATAL_ERROR(msg) cf_error(msg)
! 87:
! 88: static void cf_include(char *arg, int alen);
! 89: static int check_eof(void);
! 90:
! 91: %}
! 92:
! 93: %option noyywrap
! 94: %option noinput
! 95: %option nounput
! 96: %option noreject
! 97:
! 98: %x COMMENT CCOMM CLI
! 99:
! 100: ALPHA [a-zA-Z_]
! 101: DIGIT [0-9]
! 102: XIGIT [0-9a-fA-F]
! 103: ALNUM [a-zA-Z_0-9]
! 104: WHITE [ \t]
! 105: include ^{WHITE}*include{WHITE}*\".*\"{WHITE}*;
! 106:
! 107: %%
! 108: {include} {
! 109: char *start, *end;
! 110:
! 111: if (!ifs->depth)
! 112: cf_error("Include not allowed in CLI");
! 113:
! 114: start = strchr(yytext, '"');
! 115: start++;
! 116:
! 117: end = strchr(start, '"');
! 118: *end = 0;
! 119:
! 120: if (start == end)
! 121: cf_error("Include with empty argument");
! 122:
! 123: cf_include(start, end-start);
! 124: }
! 125:
! 126: {DIGIT}+\.{DIGIT}+\.{DIGIT}+\.{DIGIT}+ {
! 127: ip4_addr a;
! 128: if (!ip4_pton(yytext, &a))
! 129: cf_error("Invalid IPv4 address %s", yytext);
! 130:
! 131: #ifdef IPV6
! 132: cf_lval.i32 = ip4_to_u32(a);
! 133: return RTRID;
! 134: #else
! 135: cf_lval.a = ipa_from_ip4(a);
! 136: return IPA;
! 137: #endif
! 138: }
! 139:
! 140: ({XIGIT}*::|({XIGIT}*:){3,})({XIGIT}*|{DIGIT}+\.{DIGIT}+\.{DIGIT}+\.{DIGIT}+) {
! 141: #ifdef IPV6
! 142: if (ipa_pton(yytext, &cf_lval.a))
! 143: return IPA;
! 144: cf_error("Invalid IPv6 address %s", yytext);
! 145: #else
! 146: cf_error("This is an IPv4 router, therefore IPv6 addresses are not supported");
! 147: #endif
! 148: }
! 149:
! 150: 0x{XIGIT}+ {
! 151: char *e;
! 152: unsigned long int l;
! 153: errno = 0;
! 154: l = strtoul(yytext+2, &e, 16);
! 155: if (e && *e || errno == ERANGE || (unsigned long int)(unsigned int) l != l)
! 156: cf_error("Number out of range");
! 157: cf_lval.i = l;
! 158: return NUM;
! 159: }
! 160:
! 161: {DIGIT}+ {
! 162: char *e;
! 163: unsigned long int l;
! 164: errno = 0;
! 165: l = strtoul(yytext, &e, 10);
! 166: if (e && *e || errno == ERANGE || (unsigned long int)(unsigned int) l != l)
! 167: cf_error("Number out of range");
! 168: cf_lval.i = l;
! 169: return NUM;
! 170: }
! 171:
! 172: else: {
! 173: /* Hack to distinguish if..else from else: in case */
! 174: return ELSECOL;
! 175: }
! 176:
! 177: ({ALPHA}{ALNUM}*|[']({ALNUM}|[-]|[\.]|[:])*[']) {
! 178: if(*yytext == '\'') {
! 179: yytext[yyleng-1] = 0;
! 180: yytext++;
! 181: }
! 182: unsigned int h = cf_hash(yytext);
! 183: struct keyword *k = kw_hash[h & (KW_HASH_SIZE-1)];
! 184: while (k)
! 185: {
! 186: if (!strcmp(k->name, yytext))
! 187: {
! 188: if (k->value > 0)
! 189: return k->value;
! 190: else
! 191: {
! 192: cf_lval.i = -k->value;
! 193: return ENUM;
! 194: }
! 195: }
! 196: k=k->next;
! 197: }
! 198: cf_lval.s = cf_get_sym(yytext, h);
! 199: return SYM;
! 200: }
! 201:
! 202: <CLI>(.|\n) {
! 203: BEGIN(INITIAL);
! 204: return CLI_MARKER;
! 205: }
! 206:
! 207: \.\. {
! 208: return DDOT;
! 209: }
! 210:
! 211: [={}:;,.()+*/%<>~\[\]?!\|-] {
! 212: return yytext[0];
! 213: }
! 214:
! 215: ["][^"\n]*["] {
! 216: yytext[yyleng-1] = 0;
! 217: cf_lval.t = cfg_strdup(yytext+1);
! 218: return TEXT;
! 219: }
! 220:
! 221: ["][^"\n]*\n cf_error("Unterminated string");
! 222:
! 223: <INITIAL,COMMENT><<EOF>> { if (check_eof()) return END; }
! 224:
! 225: {WHITE}+
! 226:
! 227: \n ifs->lino++;
! 228:
! 229: # BEGIN(COMMENT);
! 230:
! 231: \/\* BEGIN(CCOMM);
! 232:
! 233: . cf_error("Unknown character");
! 234:
! 235: <COMMENT>\n {
! 236: ifs->lino++;
! 237: BEGIN(INITIAL);
! 238: }
! 239:
! 240: <COMMENT>.
! 241:
! 242: <CCOMM>\*\/ BEGIN(INITIAL);
! 243: <CCOMM>\n ifs->lino++;
! 244: <CCOMM>\/\* cf_error("Comment nesting not supported");
! 245: <CCOMM><<EOF>> cf_error("Unterminated comment");
! 246: <CCOMM>.
! 247:
! 248: \!\= return NEQ;
! 249: \!\~ return NMA;
! 250: \<\= return LEQ;
! 251: \>\= return GEQ;
! 252: \&\& return AND;
! 253: \|\| return OR;
! 254:
! 255: \[\= return PO;
! 256: \=\] return PC;
! 257:
! 258: %%
! 259:
! 260: static int
! 261: cf_hash(byte *c)
! 262: {
! 263: unsigned int h = 13;
! 264:
! 265: while (*c)
! 266: h = (h * 37) + *c++;
! 267: return h;
! 268: }
! 269:
! 270:
! 271: /*
! 272: * IFS stack - it contains structures needed for recursive processing
! 273: * of include in config files. On the top of the stack is a structure
! 274: * for currently processed file. Other structures are either for
! 275: * active files interrupted because of include directive (these have
! 276: * fd and flex buffer) or for inactive files scheduled to be processed
! 277: * later (when parent requested including of several files by wildcard
! 278: * match - these do not have fd and flex buffer yet).
! 279: *
! 280: * FIXME: Most of these ifs and include functions are really sysdep/unix.
! 281: */
! 282:
! 283: static struct include_file_stack *
! 284: push_ifs(struct include_file_stack *old)
! 285: {
! 286: struct include_file_stack *ret;
! 287: ret = cfg_allocz(sizeof(struct include_file_stack));
! 288: ret->lino = 1;
! 289: ret->prev = old;
! 290: return ret;
! 291: }
! 292:
! 293: static struct include_file_stack *
! 294: pop_ifs(struct include_file_stack *old)
! 295: {
! 296: yy_delete_buffer(old->buffer);
! 297: close(old->fd);
! 298: return old->prev;
! 299: }
! 300:
! 301: static void
! 302: enter_ifs(struct include_file_stack *new)
! 303: {
! 304: if (!new->buffer)
! 305: {
! 306: new->fd = open(new->file_name, O_RDONLY);
! 307: if (new->fd < 0)
! 308: {
! 309: ifs = ifs->up;
! 310: cf_error("Unable to open included file %s: %m", new->file_name);
! 311: }
! 312:
! 313: new->buffer = yy_create_buffer(NULL, YY_BUF_SIZE);
! 314: }
! 315:
! 316: yy_switch_to_buffer(new->buffer);
! 317: }
! 318:
! 319: /**
! 320: * cf_lex_unwind - unwind lexer state during error
! 321: *
! 322: * cf_lex_unwind() frees the internal state on IFS stack when the lexical
! 323: * analyzer is terminated by cf_error().
! 324: */
! 325: void
! 326: cf_lex_unwind(void)
! 327: {
! 328: struct include_file_stack *n;
! 329:
! 330: for (n = ifs; n != ifs_head; n = n->prev)
! 331: {
! 332: /* Memory is freed automatically */
! 333: if (n->buffer)
! 334: yy_delete_buffer(n->buffer);
! 335: if (n->fd)
! 336: close(n->fd);
! 337: }
! 338:
! 339: ifs = ifs_head;
! 340: }
! 341:
! 342: static void
! 343: cf_include(char *arg, int alen)
! 344: {
! 345: struct include_file_stack *base_ifs = ifs;
! 346: int new_depth, rv, i;
! 347: char *patt;
! 348: glob_t g = {};
! 349:
! 350: new_depth = ifs->depth + 1;
! 351: if (new_depth > MAX_INCLUDE_DEPTH)
! 352: cf_error("Max include depth reached");
! 353:
! 354: /* expand arg to properly handle relative filenames */
! 355: if (*arg != '/')
! 356: {
! 357: int dlen = strlen(ifs->file_name);
! 358: char *dir = alloca(dlen + 1);
! 359: patt = alloca(dlen + alen + 2);
! 360: memcpy(dir, ifs->file_name, dlen + 1);
! 361: sprintf(patt, "%s/%s", dirname(dir), arg);
! 362: }
! 363: else
! 364: patt = arg;
! 365:
! 366: /* Skip globbing if there are no wildcards, mainly to get proper
! 367: response when the included config file is missing */
! 368: if (!strpbrk(arg, "?*["))
! 369: {
! 370: ifs = push_ifs(ifs);
! 371: ifs->file_name = cfg_strdup(patt);
! 372: ifs->depth = new_depth;
! 373: ifs->up = base_ifs;
! 374: enter_ifs(ifs);
! 375: return;
! 376: }
! 377:
! 378: /* Expand the pattern */
! 379: rv = glob(patt, GLOB_ERR | GLOB_NOESCAPE, NULL, &g);
! 380: if (rv == GLOB_ABORTED)
! 381: cf_error("Unable to match pattern %s: %m", patt);
! 382: if ((rv != 0) || (g.gl_pathc <= 0))
! 383: return;
! 384:
! 385: /*
! 386: * Now we put all found files to ifs stack in reverse order, they
! 387: * will be activated and processed in order as ifs stack is popped
! 388: * by pop_ifs() and enter_ifs() in check_eof().
! 389: */
! 390: for(i = g.gl_pathc - 1; i >= 0; i--)
! 391: {
! 392: char *fname = g.gl_pathv[i];
! 393: struct stat fs;
! 394:
! 395: if (stat(fname, &fs) < 0)
! 396: {
! 397: globfree(&g);
! 398: cf_error("Unable to stat included file %s: %m", fname);
! 399: }
! 400:
! 401: if (fs.st_mode & S_IFDIR)
! 402: continue;
! 403:
! 404: /* Prepare new stack item */
! 405: ifs = push_ifs(ifs);
! 406: ifs->file_name = cfg_strdup(fname);
! 407: ifs->depth = new_depth;
! 408: ifs->up = base_ifs;
! 409: }
! 410:
! 411: globfree(&g);
! 412: enter_ifs(ifs);
! 413: }
! 414:
! 415: static int
! 416: check_eof(void)
! 417: {
! 418: if (ifs == ifs_head)
! 419: {
! 420: /* EOF in main config file */
! 421: ifs->lino = 1; /* Why this? */
! 422: return 1;
! 423: }
! 424:
! 425: ifs = pop_ifs(ifs);
! 426: enter_ifs(ifs);
! 427: return 0;
! 428: }
! 429:
! 430: static struct symbol *
! 431: cf_new_sym(byte *c, uint h0)
! 432: {
! 433: uint h = h0 & (SYM_HASH_SIZE-1);
! 434: struct symbol *s, **ht;
! 435: int l;
! 436:
! 437: if (!new_config->sym_hash)
! 438: new_config->sym_hash = cfg_allocz(SYM_HASH_SIZE * sizeof(struct keyword *));
! 439: ht = new_config->sym_hash;
! 440: l = strlen(c);
! 441: if (l > SYM_MAX_LEN)
! 442: cf_error("Symbol too long");
! 443: s = cfg_alloc(sizeof(struct symbol) + l);
! 444: s->next = ht[h];
! 445: ht[h] = s;
! 446: s->scope = conf_this_scope;
! 447: s->class = SYM_VOID;
! 448: s->def = NULL;
! 449: s->aux = 0;
! 450: strcpy(s->name, c);
! 451: return s;
! 452: }
! 453:
! 454: static struct symbol *
! 455: cf_find_sym(struct config *cfg, byte *c, uint h0)
! 456: {
! 457: uint h = h0 & (SYM_HASH_SIZE-1);
! 458: struct symbol *s, **ht;
! 459:
! 460: if (ht = cfg->sym_hash)
! 461: {
! 462: for(s = ht[h]; s; s=s->next)
! 463: if (!strcmp(s->name, c) && s->scope->active)
! 464: return s;
! 465: }
! 466: if (ht = cfg->sym_fallback)
! 467: {
! 468: /* We know only top-level scope is active */
! 469: for(s = ht[h]; s; s=s->next)
! 470: if (!strcmp(s->name, c) && s->scope->active)
! 471: return s;
! 472: }
! 473:
! 474: return NULL;
! 475: }
! 476:
! 477: static inline struct symbol *
! 478: cf_get_sym(byte *c, uint h0)
! 479: {
! 480: return cf_find_sym(new_config, c, h0) ?: cf_new_sym(c, h0);
! 481: }
! 482:
! 483: /**
! 484: * cf_find_symbol - find a symbol by name
! 485: * @cfg: specificed config
! 486: * @c: symbol name
! 487: *
! 488: * This functions searches the symbol table in the config @cfg for a symbol of
! 489: * given name. First it examines the current scope, then the second recent one
! 490: * and so on until it either finds the symbol and returns a pointer to its
! 491: * &symbol structure or reaches the end of the scope chain and returns %NULL to
! 492: * signify no match.
! 493: */
! 494: struct symbol *
! 495: cf_find_symbol(struct config *cfg, byte *c)
! 496: {
! 497: return cf_find_sym(cfg, c, cf_hash(c));
! 498: }
! 499:
! 500: /**
! 501: * cf_get_symbol - get a symbol by name
! 502: * @c: symbol name
! 503: *
! 504: * This functions searches the symbol table of the currently parsed config
! 505: * (@new_config) for a symbol of given name. It returns either the already
! 506: * existing symbol or a newly allocated undefined (%SYM_VOID) symbol if no
! 507: * existing symbol is found.
! 508: */
! 509: struct symbol *
! 510: cf_get_symbol(byte *c)
! 511: {
! 512: return cf_get_sym(c, cf_hash(c));
! 513: }
! 514:
! 515: struct symbol *
! 516: cf_default_name(char *template, int *counter)
! 517: {
! 518: char buf[SYM_MAX_LEN];
! 519: struct symbol *s;
! 520: char *perc = strchr(template, '%');
! 521:
! 522: for(;;)
! 523: {
! 524: bsprintf(buf, template, ++(*counter));
! 525: s = cf_get_sym(buf, cf_hash(buf));
! 526: if (s->class == SYM_VOID)
! 527: return s;
! 528: if (!perc)
! 529: break;
! 530: }
! 531: cf_error("Unable to generate default name");
! 532: }
! 533:
! 534: /**
! 535: * cf_define_symbol - define meaning of a symbol
! 536: * @sym: symbol to be defined
! 537: * @type: symbol class to assign
! 538: * @def: class dependent data
! 539: *
! 540: * Defines new meaning of a symbol. If the symbol is an undefined
! 541: * one (%SYM_VOID), it's just re-defined to the new type. If it's defined
! 542: * in different scope, a new symbol in current scope is created and the
! 543: * meaning is assigned to it. If it's already defined in the current scope,
! 544: * an error is reported via cf_error().
! 545: *
! 546: * Result: Pointer to the newly defined symbol. If we are in the top-level
! 547: * scope, it's the same @sym as passed to the function.
! 548: */
! 549: struct symbol *
! 550: cf_define_symbol(struct symbol *sym, int type, void *def)
! 551: {
! 552: if (sym->class)
! 553: {
! 554: if (sym->scope == conf_this_scope)
! 555: cf_error("Symbol already defined");
! 556: sym = cf_new_sym(sym->name, cf_hash(sym->name));
! 557: }
! 558: sym->class = type;
! 559: sym->def = def;
! 560: return sym;
! 561: }
! 562:
! 563: static void
! 564: cf_lex_init_kh(void)
! 565: {
! 566: struct keyword *k;
! 567:
! 568: for(k=keyword_list; k->name; k++)
! 569: {
! 570: unsigned h = cf_hash(k->name) & (KW_HASH_SIZE-1);
! 571: k->next = kw_hash[h];
! 572: kw_hash[h] = k;
! 573: }
! 574: kw_hash_inited = 1;
! 575: }
! 576:
! 577: /**
! 578: * cf_lex_init - initialize the lexer
! 579: * @is_cli: true if we're going to parse CLI command, false for configuration
! 580: * @c: configuration structure
! 581: *
! 582: * cf_lex_init() initializes the lexical analyzer and prepares it for
! 583: * parsing of a new input.
! 584: */
! 585: void
! 586: cf_lex_init(int is_cli, struct config *c)
! 587: {
! 588: if (!kw_hash_inited)
! 589: cf_lex_init_kh();
! 590:
! 591: ifs_head = ifs = push_ifs(NULL);
! 592: if (!is_cli)
! 593: {
! 594: ifs->file_name = c->file_name;
! 595: ifs->fd = c->file_fd;
! 596: ifs->depth = 1;
! 597: }
! 598:
! 599: yyrestart(NULL);
! 600: ifs->buffer = YY_CURRENT_BUFFER;
! 601:
! 602: if (is_cli)
! 603: BEGIN(CLI);
! 604: else
! 605: BEGIN(INITIAL);
! 606:
! 607: conf_this_scope = cfg_allocz(sizeof(struct sym_scope));
! 608: conf_this_scope->active = 1;
! 609: }
! 610:
! 611: /**
! 612: * cf_push_scope - enter new scope
! 613: * @sym: symbol representing scope name
! 614: *
! 615: * If we want to enter a new scope to process declarations inside
! 616: * a nested block, we can just call cf_push_scope() to push a new
! 617: * scope onto the scope stack which will cause all new symbols to be
! 618: * defined in this scope and all existing symbols to be sought for
! 619: * in all scopes stored on the stack.
! 620: */
! 621: void
! 622: cf_push_scope(struct symbol *sym)
! 623: {
! 624: struct sym_scope *s = cfg_alloc(sizeof(struct sym_scope));
! 625:
! 626: s->next = conf_this_scope;
! 627: conf_this_scope = s;
! 628: s->active = 1;
! 629: s->name = sym;
! 630: }
! 631:
! 632: /**
! 633: * cf_pop_scope - leave a scope
! 634: *
! 635: * cf_pop_scope() pops the topmost scope from the scope stack,
! 636: * leaving all its symbols in the symbol table, but making them
! 637: * invisible to the rest of the config.
! 638: */
! 639: void
! 640: cf_pop_scope(void)
! 641: {
! 642: conf_this_scope->active = 0;
! 643: conf_this_scope = conf_this_scope->next;
! 644: ASSERT(conf_this_scope);
! 645: }
! 646:
! 647: struct symbol *
! 648: cf_walk_symbols(struct config *cf, struct symbol *sym, int *pos)
! 649: {
! 650: for(;;)
! 651: {
! 652: if (!sym)
! 653: {
! 654: if (*pos >= SYM_HASH_SIZE)
! 655: return NULL;
! 656: sym = cf->sym_hash[(*pos)++];
! 657: }
! 658: else
! 659: sym = sym->next;
! 660: if (sym && sym->scope->active)
! 661: return sym;
! 662: }
! 663: }
! 664:
! 665: /**
! 666: * cf_symbol_class_name - get name of a symbol class
! 667: * @sym: symbol
! 668: *
! 669: * This function returns a string representing the class
! 670: * of the given symbol.
! 671: */
! 672: char *
! 673: cf_symbol_class_name(struct symbol *sym)
! 674: {
! 675: if (cf_symbol_is_constant(sym))
! 676: return "constant";
! 677:
! 678: switch (sym->class)
! 679: {
! 680: case SYM_VOID:
! 681: return "undefined";
! 682: case SYM_PROTO:
! 683: return "protocol";
! 684: case SYM_TEMPLATE:
! 685: return "protocol template";
! 686: case SYM_FUNCTION:
! 687: return "function";
! 688: case SYM_FILTER:
! 689: return "filter";
! 690: case SYM_TABLE:
! 691: return "routing table";
! 692: case SYM_ROA:
! 693: return "ROA table";
! 694: default:
! 695: return "unknown type";
! 696: }
! 697: }
! 698:
! 699:
! 700: /**
! 701: * DOC: Parser
! 702: *
! 703: * Both the configuration and CLI commands are analyzed using a syntax
! 704: * driven parser generated by the |bison| tool from a grammar which
! 705: * is constructed from information gathered from grammar snippets by
! 706: * the |gen_parser.m4| script.
! 707: *
! 708: * Grammar snippets are files (usually with extension |.Y|) contributed
! 709: * by various BIRD modules in order to provide information about syntax of their
! 710: * configuration and their CLI commands. Each snipped consists of several
! 711: * sections, each of them starting with a special keyword: |CF_HDR| for
! 712: * a list of |#include| directives needed by the C code, |CF_DEFINES|
! 713: * for a list of C declarations, |CF_DECLS| for |bison| declarations
! 714: * including keyword definitions specified as |CF_KEYWORDS|, |CF_GRAMMAR|
! 715: * for the grammar rules, |CF_CODE| for auxiliary C code and finally
! 716: * |CF_END| at the end of the snippet.
! 717: *
! 718: * To create references between the snippets, it's possible to define
! 719: * multi-part rules by utilizing the |CF_ADDTO| macro which adds a new
! 720: * alternative to a multi-part rule.
! 721: *
! 722: * CLI commands are defined using a |CF_CLI| macro. Its parameters are:
! 723: * the list of keywords determining the command, the list of parameters,
! 724: * help text for the parameters and help text for the command.
! 725: *
! 726: * Values of |enum| filter types can be defined using |CF_ENUM| with
! 727: * the following parameters: name of filter type, prefix common for all
! 728: * literals of this type and names of all the possible values.
! 729: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to cf-lex.l CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / bird / conf