Annotation of embedaddon/bird2/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 "filter/f-inst.h"
! 49: #include "conf/conf.h"
! 50: #include "conf/cf-parse.tab.h"
! 51: #include "lib/string.h"
! 52: #include "lib/hash.h"
! 53:
! 54: struct keyword {
! 55: byte *name;
! 56: int value;
! 57: struct keyword *next;
! 58: };
! 59:
! 60: #include "conf/keywords.h"
! 61:
! 62: /* Could be defined by Bison in cf-parse.tab.h, inteferes with SYM hash */
! 63: #ifdef SYM
! 64: #undef SYM
! 65: #endif
! 66:
! 67:
! 68: static uint cf_hash(const byte *c);
! 69:
! 70: #define KW_KEY(n) n->name
! 71: #define KW_NEXT(n) n->next
! 72: #define KW_EQ(a,b) !strcmp(a,b)
! 73: #define KW_FN(k) cf_hash(k)
! 74: #define KW_ORDER 8 /* Fixed */
! 75:
! 76: #define SYM_KEY(n) n->name, n->scope->active
! 77: #define SYM_NEXT(n) n->next
! 78: #define SYM_EQ(a,s1,b,s2) !strcmp(a,b) && s1 == s2
! 79: #define SYM_FN(k,s) cf_hash(k)
! 80: #define SYM_ORDER 6 /* Initial */
! 81:
! 82: #define SYM_REHASH sym_rehash
! 83: #define SYM_PARAMS /8, *1, 2, 2, 6, 20
! 84:
! 85:
! 86: HASH_DEFINE_REHASH_FN(SYM, struct symbol)
! 87:
! 88: HASH(struct keyword) kw_hash;
! 89:
! 90:
! 91: struct sym_scope *conf_this_scope;
! 92:
! 93: linpool *cfg_mem;
! 94:
! 95: int (*cf_read_hook)(byte *buf, unsigned int max, int fd);
! 96: struct include_file_stack *ifs;
! 97: static struct include_file_stack *ifs_head;
! 98:
! 99: #define QUOTED_BUFFER_SIZE 4096
! 100: static BUFFER_(char) quoted_buffer;
! 101: static char quoted_buffer_data[QUOTED_BUFFER_SIZE];
! 102: static inline void quoted_buffer_init(void) {
! 103: quoted_buffer.used = 0;
! 104: quoted_buffer.size = QUOTED_BUFFER_SIZE;
! 105: quoted_buffer.data = quoted_buffer_data;
! 106: }
! 107:
! 108: #define MAX_INCLUDE_DEPTH 8
! 109:
! 110: #define YY_INPUT(buf,result,max) result = cf_read_hook(buf, max, ifs->fd);
! 111: #define YY_NO_UNPUT
! 112: #define YY_FATAL_ERROR(msg) cf_error(msg)
! 113: #define YY_USER_ACTION ifs->chno += yyleng; ifs->toklen = yyleng;
! 114:
! 115: static void cf_include(char *arg, int alen);
! 116: static int check_eof(void);
! 117:
! 118: static enum yytokentype cf_lex_symbol(const char *data);
! 119:
! 120: %}
! 121:
! 122: %option noyywrap
! 123: %option noinput
! 124: %option nounput
! 125: %option noreject
! 126:
! 127: %x COMMENT CCOMM CLI QUOTED APOSTROPHED INCLUDE
! 128:
! 129: ALPHA [a-zA-Z_]
! 130: DIGIT [0-9]
! 131: XIGIT [0-9a-fA-F]
! 132: ALNUM [a-zA-Z_0-9]
! 133: WHITE [ \t]
! 134:
! 135: %%
! 136: ^{WHITE}*include{WHITE}*\" {
! 137: if (!ifs->depth)
! 138: cf_error("Include not allowed in CLI");
! 139:
! 140: BEGIN(INCLUDE);
! 141: }
! 142:
! 143: <INCLUDE>[^"\n]+["]{WHITE}*; {
! 144: char *start, *end;
! 145:
! 146: start = yytext;
! 147:
! 148: end = strchr(start, '"');
! 149: *end = 0;
! 150:
! 151: if (start == end)
! 152: cf_error("Include with empty argument");
! 153:
! 154: cf_include(start, end-start);
! 155:
! 156: BEGIN(INITIAL);
! 157: }
! 158:
! 159: <INCLUDE>["] cf_error("Include with empty argument");
! 160: <INCLUDE>. cf_error("Unterminated include");
! 161: <INCLUDE>\n cf_error("Unterminated include");
! 162: <INCLUDE><<EOF>> cf_error("Unterminated include");
! 163:
! 164:
! 165: {DIGIT}+:{DIGIT}+ {
! 166: uint len1 UNUSED, len2;
! 167: u64 l;
! 168: char *e;
! 169:
! 170: errno = 0;
! 171: l = bstrtoul10(yytext, &e);
! 172: if (e && (*e != ':') || (errno == ERANGE) || (l >> 32))
! 173: cf_error("ASN out of range");
! 174:
! 175: if (l >> 16)
! 176: {
! 177: len1 = 32;
! 178: len2 = 16;
! 179: cf_lval.i64 = (2ULL << 48) | (((u64) l) << len2);
! 180: }
! 181: else
! 182: {
! 183: len1 = 16;
! 184: len2 = 32;
! 185: cf_lval.i64 = 0 | (((u64) l) << len2);
! 186: }
! 187:
! 188: errno = 0;
! 189: l = bstrtoul10(e+1, &e);
! 190: if (e && *e || (errno == ERANGE) || (l >> len2))
! 191: cf_error("Number out of range");
! 192: cf_lval.i64 |= l;
! 193:
! 194: return VPN_RD;
! 195: }
! 196:
! 197: [02]:{DIGIT}+:{DIGIT}+ {
! 198: uint len1, len2;
! 199: u64 l;
! 200: char *e;
! 201:
! 202: if (yytext[0] == '0')
! 203: {
! 204: cf_lval.i64 = 0;
! 205: len1 = 16;
! 206: len2 = 32;
! 207: }
! 208: else
! 209: {
! 210: cf_lval.i64 = 2ULL << 48;
! 211: len1 = 32;
! 212: len2 = 16;
! 213: }
! 214:
! 215: errno = 0;
! 216: l = bstrtoul10(yytext+2, &e);
! 217: if (e && (*e != ':') || (errno == ERANGE) || (l >> len1))
! 218: cf_error("ASN out of range");
! 219: cf_lval.i64 |= ((u64) l) << len2;
! 220:
! 221: errno = 0;
! 222: l = bstrtoul10(e+1, &e);
! 223: if (e && *e || (errno == ERANGE) || (l >> len2))
! 224: cf_error("Number out of range");
! 225: cf_lval.i64 |= l;
! 226:
! 227: return VPN_RD;
! 228: }
! 229:
! 230: {DIGIT}+\.{DIGIT}+\.{DIGIT}+\.{DIGIT}+:{DIGIT}+ {
! 231: unsigned long int l;
! 232: ip4_addr ip4;
! 233: char *e;
! 234:
! 235: cf_lval.i64 = 1ULL << 48;
! 236:
! 237: e = strchr(yytext, ':');
! 238: *e++ = '\0';
! 239: if (!ip4_pton(yytext, &ip4))
! 240: cf_error("Invalid IPv4 address %s in Route Distinguisher", yytext);
! 241: cf_lval.i64 |= ((u64) ip4_to_u32(ip4)) << 16;
! 242:
! 243: errno = 0;
! 244: l = bstrtoul10(e, &e);
! 245: if (e && *e || (errno == ERANGE) || (l >> 16))
! 246: cf_error("Number out of range");
! 247: cf_lval.i64 |= l;
! 248:
! 249: return VPN_RD;
! 250: }
! 251:
! 252: {DIGIT}+\.{DIGIT}+\.{DIGIT}+\.{DIGIT}+ {
! 253: if (!ip4_pton(yytext, &cf_lval.ip4))
! 254: cf_error("Invalid IPv4 address %s", yytext);
! 255: return IP4;
! 256: }
! 257:
! 258: ({XIGIT}*::|({XIGIT}*:){3,})({XIGIT}*|{DIGIT}+\.{DIGIT}+\.{DIGIT}+\.{DIGIT}+) {
! 259: if (!ip6_pton(yytext, &cf_lval.ip6))
! 260: cf_error("Invalid IPv6 address %s", yytext);
! 261: return IP6;
! 262: }
! 263:
! 264: 0x{XIGIT}+ {
! 265: char *e;
! 266: unsigned long int l;
! 267: errno = 0;
! 268: l = bstrtoul16(yytext+2, &e);
! 269: if (e && *e || errno == ERANGE || (unsigned long int)(unsigned int) l != l)
! 270: cf_error("Number out of range");
! 271: cf_lval.i = l;
! 272: return NUM;
! 273: }
! 274:
! 275: {DIGIT}+ {
! 276: char *e;
! 277: unsigned long int l;
! 278: errno = 0;
! 279: l = bstrtoul10(yytext, &e);
! 280: if (e && *e || errno == ERANGE || (unsigned long int)(unsigned int) l != l)
! 281: cf_error("Number out of range");
! 282: cf_lval.i = l;
! 283: return NUM;
! 284: }
! 285:
! 286: else: {
! 287: /* Hack to distinguish if..else from else: in case */
! 288: return ELSECOL;
! 289: }
! 290:
! 291: ['] {
! 292: BEGIN(APOSTROPHED);
! 293: quoted_buffer_init();
! 294: }
! 295:
! 296: <APOSTROPHED>{ALNUM}|[-]|[.:] BUFFER_PUSH(quoted_buffer) = yytext[0];
! 297: <APOSTROPHED>\n cf_error("Unterminated symbol");
! 298: <APOSTROPHED><<EOF>> cf_error("Unterminated symbol");
! 299: <APOSTROPHED>['] {
! 300: BEGIN(INITIAL);
! 301: BUFFER_PUSH(quoted_buffer) = 0;
! 302: return cf_lex_symbol(quoted_buffer_data);
! 303: }
! 304: <APOSTROPHED>. cf_error("Invalid character in apostrophed symbol");
! 305:
! 306: ({ALPHA}{ALNUM}*) {
! 307: return cf_lex_symbol(yytext);
! 308: }
! 309:
! 310: <CLI>(.|\n) {
! 311: BEGIN(INITIAL);
! 312: return CLI_MARKER;
! 313: }
! 314:
! 315: \.\. {
! 316: return DDOT;
! 317: }
! 318:
! 319: [={}:;,.()+*/%<>~\[\]?!\|-] {
! 320: return yytext[0];
! 321: }
! 322:
! 323: ["] {
! 324: BEGIN(QUOTED);
! 325: quoted_buffer_init();
! 326: }
! 327:
! 328: <QUOTED>\n cf_error("Unterminated string");
! 329: <QUOTED><<EOF>> cf_error("Unterminated string");
! 330: <QUOTED>["] {
! 331: BEGIN(INITIAL);
! 332: BUFFER_PUSH(quoted_buffer) = 0;
! 333: cf_lval.t = cfg_strdup(quoted_buffer_data);
! 334: return TEXT;
! 335: }
! 336:
! 337: <QUOTED>. BUFFER_PUSH(quoted_buffer) = yytext[0];
! 338:
! 339: <INITIAL,COMMENT><<EOF>> { if (check_eof()) return END; }
! 340:
! 341: {WHITE}+
! 342:
! 343: \n ifs->lino++; ifs->chno = 0;
! 344:
! 345: # BEGIN(COMMENT);
! 346:
! 347: \/\* BEGIN(CCOMM);
! 348:
! 349: . cf_error("Unknown character");
! 350:
! 351: <COMMENT>\n {
! 352: ifs->lino++;
! 353: ifs->chno = 0;
! 354: BEGIN(INITIAL);
! 355: }
! 356:
! 357: <COMMENT>.
! 358:
! 359: <CCOMM>\*\/ BEGIN(INITIAL);
! 360: <CCOMM>\n ifs->lino++; ifs->chno = 0;
! 361: <CCOMM>\/\* cf_error("Comment nesting not supported");
! 362: <CCOMM><<EOF>> cf_error("Unterminated comment");
! 363: <CCOMM>.
! 364:
! 365: \!\= return NEQ;
! 366: \!\~ return NMA;
! 367: \<\= return LEQ;
! 368: \>\= return GEQ;
! 369: \&\& return AND;
! 370: \|\| return OR;
! 371:
! 372: \[\= return PO;
! 373: \=\] return PC;
! 374:
! 375: %%
! 376:
! 377: static uint
! 378: cf_hash(const byte *c)
! 379: {
! 380: uint h = 13 << 24;
! 381:
! 382: while (*c)
! 383: h = h + (h >> 2) + (h >> 5) + ((uint) *c++ << 24);
! 384: return h;
! 385: }
! 386:
! 387: /*
! 388: * IFS stack - it contains structures needed for recursive processing
! 389: * of include in config files. On the top of the stack is a structure
! 390: * for currently processed file. Other structures are either for
! 391: * active files interrupted because of include directive (these have
! 392: * fd and flex buffer) or for inactive files scheduled to be processed
! 393: * later (when parent requested including of several files by wildcard
! 394: * match - these do not have fd and flex buffer yet).
! 395: *
! 396: * FIXME: Most of these ifs and include functions are really sysdep/unix.
! 397: */
! 398:
! 399: static struct include_file_stack *
! 400: push_ifs(struct include_file_stack *old)
! 401: {
! 402: struct include_file_stack *ret;
! 403: ret = cfg_allocz(sizeof(struct include_file_stack));
! 404: ret->lino = 1;
! 405: ret->prev = old;
! 406: return ret;
! 407: }
! 408:
! 409: static struct include_file_stack *
! 410: pop_ifs(struct include_file_stack *old)
! 411: {
! 412: yy_delete_buffer(old->buffer);
! 413: close(old->fd);
! 414: return old->prev;
! 415: }
! 416:
! 417: static void
! 418: enter_ifs(struct include_file_stack *new)
! 419: {
! 420: if (!new->buffer)
! 421: {
! 422: new->fd = open(new->file_name, O_RDONLY);
! 423: if (new->fd < 0)
! 424: {
! 425: ifs = ifs->up;
! 426: cf_error("Unable to open included file %s: %m", new->file_name);
! 427: }
! 428:
! 429: new->buffer = yy_create_buffer(NULL, YY_BUF_SIZE);
! 430: }
! 431:
! 432: yy_switch_to_buffer(new->buffer);
! 433: }
! 434:
! 435: /**
! 436: * cf_lex_unwind - unwind lexer state during error
! 437: *
! 438: * cf_lex_unwind() frees the internal state on IFS stack when the lexical
! 439: * analyzer is terminated by cf_error().
! 440: */
! 441: void
! 442: cf_lex_unwind(void)
! 443: {
! 444: struct include_file_stack *n;
! 445:
! 446: for (n = ifs; n != ifs_head; n = n->prev)
! 447: {
! 448: /* Memory is freed automatically */
! 449: if (n->buffer)
! 450: yy_delete_buffer(n->buffer);
! 451: if (n->fd)
! 452: close(n->fd);
! 453: }
! 454:
! 455: ifs = ifs_head;
! 456: }
! 457:
! 458: static void
! 459: cf_include(char *arg, int alen)
! 460: {
! 461: struct include_file_stack *base_ifs = ifs;
! 462: int new_depth, rv, i;
! 463: char *patt;
! 464: glob_t g = {};
! 465:
! 466: new_depth = ifs->depth + 1;
! 467: if (new_depth > MAX_INCLUDE_DEPTH)
! 468: cf_error("Max include depth reached");
! 469:
! 470: /* expand arg to properly handle relative filenames */
! 471: if (*arg != '/')
! 472: {
! 473: int dlen = strlen(ifs->file_name);
! 474: char *dir = alloca(dlen + 1);
! 475: patt = alloca(dlen + alen + 2);
! 476: memcpy(dir, ifs->file_name, dlen + 1);
! 477: sprintf(patt, "%s/%s", dirname(dir), arg);
! 478: }
! 479: else
! 480: patt = arg;
! 481:
! 482: /* Skip globbing if there are no wildcards, mainly to get proper
! 483: response when the included config file is missing */
! 484: if (!strpbrk(arg, "?*["))
! 485: {
! 486: ifs = push_ifs(ifs);
! 487: ifs->file_name = cfg_strdup(patt);
! 488: ifs->depth = new_depth;
! 489: ifs->up = base_ifs;
! 490: enter_ifs(ifs);
! 491: return;
! 492: }
! 493:
! 494: /* Expand the pattern */
! 495: rv = glob(patt, GLOB_ERR | GLOB_NOESCAPE, NULL, &g);
! 496: if (rv == GLOB_ABORTED)
! 497: cf_error("Unable to match pattern %s: %m", patt);
! 498: if ((rv != 0) || (g.gl_pathc <= 0))
! 499: return;
! 500:
! 501: /*
! 502: * Now we put all found files to ifs stack in reverse order, they
! 503: * will be activated and processed in order as ifs stack is popped
! 504: * by pop_ifs() and enter_ifs() in check_eof().
! 505: */
! 506: for(i = g.gl_pathc - 1; i >= 0; i--)
! 507: {
! 508: char *fname = g.gl_pathv[i];
! 509: struct stat fs;
! 510:
! 511: if (stat(fname, &fs) < 0)
! 512: {
! 513: globfree(&g);
! 514: cf_error("Unable to stat included file %s: %m", fname);
! 515: }
! 516:
! 517: if (fs.st_mode & S_IFDIR)
! 518: continue;
! 519:
! 520: /* Prepare new stack item */
! 521: ifs = push_ifs(ifs);
! 522: ifs->file_name = cfg_strdup(fname);
! 523: ifs->depth = new_depth;
! 524: ifs->up = base_ifs;
! 525: }
! 526:
! 527: globfree(&g);
! 528: enter_ifs(ifs);
! 529: }
! 530:
! 531: static int
! 532: check_eof(void)
! 533: {
! 534: if (ifs == ifs_head)
! 535: {
! 536: /* EOF in main config file */
! 537: ifs->lino = 1; /* Why this? */
! 538: return 1;
! 539: }
! 540:
! 541: ifs = pop_ifs(ifs);
! 542: enter_ifs(ifs);
! 543: return 0;
! 544: }
! 545:
! 546: static struct symbol *
! 547: cf_new_symbol(const byte *c)
! 548: {
! 549: struct symbol *s;
! 550:
! 551: uint l = strlen(c);
! 552: if (l > SYM_MAX_LEN)
! 553: cf_error("Symbol too long");
! 554:
! 555: s = cfg_allocz(sizeof(struct symbol) + l + 1);
! 556: *s = (struct symbol) { .scope = conf_this_scope, .class = SYM_VOID, };
! 557: strcpy(s->name, c);
! 558:
! 559: if (!new_config->sym_hash.data)
! 560: HASH_INIT(new_config->sym_hash, new_config->pool, SYM_ORDER);
! 561:
! 562: HASH_INSERT2(new_config->sym_hash, SYM, new_config->pool, s);
! 563:
! 564: add_tail(&(new_config->symbols), &(s->n));
! 565:
! 566: return s;
! 567: }
! 568:
! 569: /**
! 570: * cf_find_symbol - find a symbol by name
! 571: * @cfg: specificed config
! 572: * @c: symbol name
! 573: *
! 574: * This functions searches the symbol table in the config @cfg for a symbol of
! 575: * given name. First it examines the current scope, then the second recent one
! 576: * and so on until it either finds the symbol and returns a pointer to its
! 577: * &symbol structure or reaches the end of the scope chain and returns %NULL to
! 578: * signify no match.
! 579: */
! 580: struct symbol *
! 581: cf_find_symbol(const struct config *cfg, const byte *c)
! 582: {
! 583: struct symbol *s;
! 584:
! 585: if (cfg->sym_hash.data &&
! 586: (s = HASH_FIND(cfg->sym_hash, SYM, c, 1)))
! 587: return s;
! 588:
! 589: /* In CLI command parsing, fallback points to the current config, otherwise it is NULL. */
! 590: if (cfg->fallback &&
! 591: cfg->fallback->sym_hash.data &&
! 592: (s = HASH_FIND(cfg->fallback->sym_hash, SYM, c, 1)))
! 593: return s;
! 594:
! 595: return NULL;
! 596: }
! 597:
! 598: /**
! 599: * cf_get_symbol - get a symbol by name
! 600: * @c: symbol name
! 601: *
! 602: * This functions searches the symbol table of the currently parsed config
! 603: * (@new_config) for a symbol of given name. It returns either the already
! 604: * existing symbol or a newly allocated undefined (%SYM_VOID) symbol if no
! 605: * existing symbol is found.
! 606: */
! 607: struct symbol *
! 608: cf_get_symbol(const byte *c)
! 609: {
! 610: return cf_find_symbol(new_config, c) ?: cf_new_symbol(c);
! 611: }
! 612:
! 613: /**
! 614: * cf_localize_symbol - get the local instance of given symbol
! 615: * @sym: the symbol to localize
! 616: *
! 617: * This functions finds the symbol that is local to current scope
! 618: * for purposes of cf_define_symbol().
! 619: */
! 620: struct symbol *
! 621: cf_localize_symbol(struct symbol *sym)
! 622: {
! 623: /* If the symbol type is void, it has been recently allocated just in this scope. */
! 624: if (!sym->class)
! 625: return sym;
! 626:
! 627: /* If the scope is the current, it is already defined in this scope. */
! 628: if (sym->scope == conf_this_scope)
! 629: cf_error("Symbol already defined");
! 630:
! 631: /* Not allocated here yet, doing it now. */
! 632: return cf_new_symbol(sym->name);
! 633: }
! 634:
! 635: struct symbol *
! 636: cf_default_name(char *template, int *counter)
! 637: {
! 638: char buf[SYM_MAX_LEN];
! 639: struct symbol *s;
! 640: char *perc = strchr(template, '%');
! 641:
! 642: for(;;)
! 643: {
! 644: bsprintf(buf, template, ++(*counter));
! 645: s = cf_get_symbol(buf);
! 646: if (s->class == SYM_VOID)
! 647: return s;
! 648: if (!perc)
! 649: break;
! 650: }
! 651: cf_error("Unable to generate default name");
! 652: }
! 653:
! 654: static enum yytokentype
! 655: cf_lex_symbol(const char *data)
! 656: {
! 657: /* Have we defined such a symbol? */
! 658: struct symbol *sym = cf_get_symbol(data);
! 659: cf_lval.s = sym;
! 660:
! 661: if (sym->class != SYM_VOID)
! 662: return CF_SYM_KNOWN;
! 663:
! 664: /* Is it a keyword? */
! 665: struct keyword *k = HASH_FIND(kw_hash, KW, data);
! 666: if (k)
! 667: {
! 668: if (k->value > 0)
! 669: return k->value;
! 670: else
! 671: {
! 672: cf_lval.i = -k->value;
! 673: return ENUM;
! 674: }
! 675: }
! 676:
! 677: /* OK, undefined symbol */
! 678: cf_lval.s = sym;
! 679: return CF_SYM_UNDEFINED;
! 680: }
! 681:
! 682: static void
! 683: cf_lex_init_kh(void)
! 684: {
! 685: HASH_INIT(kw_hash, &root_pool, KW_ORDER);
! 686:
! 687: struct keyword *k;
! 688: for (k=keyword_list; k->name; k++)
! 689: HASH_INSERT(kw_hash, KW, k);
! 690: }
! 691:
! 692: /**
! 693: * cf_lex_init - initialize the lexer
! 694: * @is_cli: true if we're going to parse CLI command, false for configuration
! 695: * @c: configuration structure
! 696: *
! 697: * cf_lex_init() initializes the lexical analyzer and prepares it for
! 698: * parsing of a new input.
! 699: */
! 700: void
! 701: cf_lex_init(int is_cli, struct config *c)
! 702: {
! 703: if (!kw_hash.data)
! 704: cf_lex_init_kh();
! 705:
! 706: ifs_head = ifs = push_ifs(NULL);
! 707: if (!is_cli)
! 708: {
! 709: ifs->file_name = c->file_name;
! 710: ifs->fd = c->file_fd;
! 711: ifs->depth = 1;
! 712: }
! 713:
! 714: yyrestart(NULL);
! 715: ifs->buffer = YY_CURRENT_BUFFER;
! 716:
! 717: if (is_cli)
! 718: BEGIN(CLI);
! 719: else
! 720: BEGIN(INITIAL);
! 721:
! 722: c->root_scope = cfg_allocz(sizeof(struct sym_scope));
! 723: conf_this_scope = c->root_scope;
! 724: conf_this_scope->active = 1;
! 725: }
! 726:
! 727: /**
! 728: * cf_push_scope - enter new scope
! 729: * @sym: symbol representing scope name
! 730: *
! 731: * If we want to enter a new scope to process declarations inside
! 732: * a nested block, we can just call cf_push_scope() to push a new
! 733: * scope onto the scope stack which will cause all new symbols to be
! 734: * defined in this scope and all existing symbols to be sought for
! 735: * in all scopes stored on the stack.
! 736: */
! 737: void
! 738: cf_push_scope(struct symbol *sym)
! 739: {
! 740: struct sym_scope *s = cfg_alloc(sizeof(struct sym_scope));
! 741:
! 742: s->next = conf_this_scope;
! 743: conf_this_scope = s;
! 744: s->active = 1;
! 745: s->name = sym;
! 746: s->slots = 0;
! 747: }
! 748:
! 749: /**
! 750: * cf_pop_scope - leave a scope
! 751: *
! 752: * cf_pop_scope() pops the topmost scope from the scope stack,
! 753: * leaving all its symbols in the symbol table, but making them
! 754: * invisible to the rest of the config.
! 755: */
! 756: void
! 757: cf_pop_scope(void)
! 758: {
! 759: conf_this_scope->active = 0;
! 760: conf_this_scope = conf_this_scope->next;
! 761:
! 762: ASSERT(conf_this_scope);
! 763: }
! 764:
! 765: /**
! 766: * cf_symbol_class_name - get name of a symbol class
! 767: * @sym: symbol
! 768: *
! 769: * This function returns a string representing the class
! 770: * of the given symbol.
! 771: */
! 772: char *
! 773: cf_symbol_class_name(struct symbol *sym)
! 774: {
! 775: switch (sym->class)
! 776: {
! 777: case SYM_VOID:
! 778: return "undefined";
! 779: case SYM_PROTO:
! 780: return "protocol";
! 781: case SYM_TEMPLATE:
! 782: return "protocol template";
! 783: case SYM_FUNCTION:
! 784: return "function";
! 785: case SYM_FILTER:
! 786: return "filter";
! 787: case SYM_TABLE:
! 788: return "routing table";
! 789: case SYM_ATTRIBUTE:
! 790: return "custom attribute";
! 791: case SYM_CONSTANT_RANGE:
! 792: return "constant";
! 793: case SYM_VARIABLE_RANGE:
! 794: return "variable";
! 795: default:
! 796: return "unknown type";
! 797: }
! 798: }
! 799:
! 800:
! 801: /**
! 802: * DOC: Parser
! 803: *
! 804: * Both the configuration and CLI commands are analyzed using a syntax
! 805: * driven parser generated by the |bison| tool from a grammar which
! 806: * is constructed from information gathered from grammar snippets by
! 807: * the |gen_parser.m4| script.
! 808: *
! 809: * Grammar snippets are files (usually with extension |.Y|) contributed
! 810: * by various BIRD modules in order to provide information about syntax of their
! 811: * configuration and their CLI commands. Each snipped consists of several
! 812: * sections, each of them starting with a special keyword: |CF_HDR| for
! 813: * a list of |#include| directives needed by the C code, |CF_DEFINES|
! 814: * for a list of C declarations, |CF_DECLS| for |bison| declarations
! 815: * including keyword definitions specified as |CF_KEYWORDS|, |CF_GRAMMAR|
! 816: * for the grammar rules, |CF_CODE| for auxiliary C code and finally
! 817: * |CF_END| at the end of the snippet.
! 818: *
! 819: * To create references between the snippets, it's possible to define
! 820: * multi-part rules by utilizing the |CF_ADDTO| macro which adds a new
! 821: * alternative to a multi-part rule.
! 822: *
! 823: * CLI commands are defined using a |CF_CLI| macro. Its parameters are:
! 824: * the list of keywords determining the command, the list of parameters,
! 825: * help text for the parameters and help text for the command.
! 826: *
! 827: * Values of |enum| filter types can be defined using |CF_ENUM| with
! 828: * the following parameters: name of filter type, prefix common for all
! 829: * literals of this type and names of all the possible values.
! 830: */
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 / bird2 / conf