26d92bb892
The old BIRD grammar needs two lookaheads to distinguish if..else from else: in case, which caused the parser to fail on some combinations of both expressions. This patch replaces two tokens 'else' ':' by one token 'else:' to fix that.
495 lines
11 KiB
Text
495 lines
11 KiB
Text
/*
|
|
* BIRD -- Configuration Lexer
|
|
*
|
|
* (c) 1998--2000 Martin Mares <mj@ucw.cz>
|
|
*
|
|
* Can be freely distributed and used under the terms of the GNU GPL.
|
|
*/
|
|
|
|
/**
|
|
* DOC: Lexical analyzer
|
|
*
|
|
* The lexical analyzer used for configuration files and CLI commands
|
|
* is generated using the |flex| tool accompanied by a couple of
|
|
* functions maintaining the hash tables containing information about
|
|
* symbols and keywords.
|
|
*
|
|
* Each symbol is represented by a &symbol structure containing name
|
|
* of the symbol, its lexical scope, symbol class (%SYM_PROTO for a name of a protocol,
|
|
* %SYM_NUMBER for a numeric constant etc.) and class dependent data.
|
|
* When an unknown symbol is encountered, it's automatically added to the
|
|
* symbol table with class %SYM_VOID.
|
|
*
|
|
* The keyword tables are generated from the grammar templates
|
|
* using the |gen_keywords.m4| script.
|
|
*/
|
|
|
|
%{
|
|
#undef REJECT /* Avoid name clashes */
|
|
|
|
#include <errno.h>
|
|
#include <stdlib.h>
|
|
#include <stdarg.h>
|
|
|
|
#define PARSER 1
|
|
|
|
#include "nest/bird.h"
|
|
#include "nest/route.h"
|
|
#include "nest/protocol.h"
|
|
#include "filter/filter.h"
|
|
#include "conf/conf.h"
|
|
#include "conf/cf-parse.tab.h"
|
|
#include "lib/string.h"
|
|
|
|
struct keyword {
|
|
byte *name;
|
|
int value;
|
|
struct keyword *next;
|
|
};
|
|
|
|
#include "conf/keywords.h"
|
|
|
|
#define KW_HASH_SIZE 64
|
|
static struct keyword *kw_hash[KW_HASH_SIZE];
|
|
static int kw_hash_inited;
|
|
|
|
#define SYM_HASH_SIZE 128
|
|
#define SYM_MAX_LEN 32
|
|
|
|
struct sym_scope {
|
|
struct sym_scope *next; /* Next on scope stack */
|
|
struct symbol *name; /* Name of this scope */
|
|
int active; /* Currently entered */
|
|
};
|
|
static struct sym_scope *conf_this_scope;
|
|
|
|
int conf_lino;
|
|
|
|
static int cf_hash(byte *c);
|
|
static struct symbol *cf_find_sym(byte *c, unsigned int h0);
|
|
|
|
linpool *cfg_mem;
|
|
|
|
int (*cf_read_hook)(byte *buf, unsigned int max);
|
|
|
|
#define YY_INPUT(buf,result,max) result = cf_read_hook(buf, max);
|
|
#define YY_NO_UNPUT
|
|
#define YY_FATAL_ERROR(msg) cf_error(msg)
|
|
|
|
%}
|
|
|
|
%option noyywrap
|
|
%option noinput
|
|
%option nounput
|
|
%option noreject
|
|
|
|
%x COMMENT CCOMM CLI
|
|
|
|
ALPHA [a-zA-Z_]
|
|
DIGIT [0-9]
|
|
XIGIT [0-9a-fA-F]
|
|
ALNUM [a-zA-Z_0-9]
|
|
WHITE [ \t]
|
|
|
|
%%
|
|
|
|
{DIGIT}+\.{DIGIT}+\.{DIGIT}+\.{DIGIT}+ {
|
|
#ifdef IPV6
|
|
if (ipv4_pton_u32(yytext, &cf_lval.i32))
|
|
return RTRID;
|
|
cf_error("Invalid IPv4 address %s", yytext);
|
|
#else
|
|
if (ip_pton(yytext, &cf_lval.a))
|
|
return IPA;
|
|
cf_error("Invalid IP address %s", yytext);
|
|
#endif
|
|
}
|
|
|
|
({XIGIT}*::|({XIGIT}*:){3,})({XIGIT}*|{DIGIT}+\.{DIGIT}+\.{DIGIT}+\.{DIGIT}+) {
|
|
#ifdef IPV6
|
|
if (ip_pton(yytext, &cf_lval.a))
|
|
return IPA;
|
|
cf_error("Invalid IP address %s", yytext);
|
|
#else
|
|
cf_error("This is an IPv4 router, therefore IPv6 addresses are not supported");
|
|
#endif
|
|
}
|
|
|
|
0x{XIGIT}+ {
|
|
char *e;
|
|
long int l;
|
|
errno = 0;
|
|
l = strtoul(yytext+2, &e, 16);
|
|
if (e && *e || errno == ERANGE || (long int)(int) l != l)
|
|
cf_error("Number out of range");
|
|
cf_lval.i = l;
|
|
return NUM;
|
|
}
|
|
|
|
{DIGIT}+ {
|
|
char *e;
|
|
long int l;
|
|
errno = 0;
|
|
l = strtoul(yytext, &e, 10);
|
|
if (e && *e || errno == ERANGE || (long int)(int) l != l)
|
|
cf_error("Number out of range");
|
|
cf_lval.i = l;
|
|
return NUM;
|
|
}
|
|
|
|
else: {
|
|
/* Hack to distinguish if..else from else: in case */
|
|
return ELSECOL;
|
|
}
|
|
|
|
({ALPHA}{ALNUM}*|[']({ALNUM}|[-])*[']) {
|
|
if(*yytext == '\'') {
|
|
yytext[yyleng-1] = 0;
|
|
yytext++;
|
|
}
|
|
unsigned int h = cf_hash(yytext);
|
|
struct keyword *k = kw_hash[h & (KW_HASH_SIZE-1)];
|
|
while (k)
|
|
{
|
|
if (!strcmp(k->name, yytext))
|
|
{
|
|
if (k->value > 0)
|
|
return k->value;
|
|
else
|
|
{
|
|
cf_lval.i = -k->value;
|
|
return ENUM;
|
|
}
|
|
}
|
|
k=k->next;
|
|
}
|
|
cf_lval.s = cf_find_sym(yytext, h);
|
|
return SYM;
|
|
}
|
|
|
|
<CLI>(.|\n) {
|
|
BEGIN(INITIAL);
|
|
return CLI_MARKER;
|
|
}
|
|
|
|
[={}:;,.()+*/%<>~\[\]?!\|-] {
|
|
return yytext[0];
|
|
}
|
|
|
|
["][^"\n]*["] {
|
|
yytext[yyleng-1] = 0;
|
|
cf_lval.t = cfg_strdup(yytext+1);
|
|
return TEXT;
|
|
}
|
|
|
|
["][^"\n]*\n cf_error("Unterminated string");
|
|
|
|
<INITIAL,COMMENT><<EOF>> return END;
|
|
|
|
{WHITE}+
|
|
|
|
\n conf_lino++;
|
|
|
|
# BEGIN(COMMENT);
|
|
|
|
\/\* BEGIN(CCOMM);
|
|
|
|
. cf_error("Unknown character");
|
|
|
|
<COMMENT>\n {
|
|
conf_lino++;
|
|
BEGIN(INITIAL);
|
|
}
|
|
|
|
<COMMENT>.
|
|
|
|
<CCOMM>\*\/ BEGIN(INITIAL);
|
|
<CCOMM>\n conf_lino++;
|
|
<CCOMM>\/\* cf_error("Comment nesting not supported");
|
|
<CCOMM><<EOF>> cf_error("Unterminated comment");
|
|
<CCOMM>.
|
|
|
|
\!\= return NEQ;
|
|
\<\= return LEQ;
|
|
\>\= return GEQ;
|
|
\&\& return AND;
|
|
\|\| return OR;
|
|
|
|
\[\= return PO;
|
|
\=\] return PC;
|
|
|
|
%%
|
|
|
|
static int
|
|
cf_hash(byte *c)
|
|
{
|
|
unsigned int h = 13;
|
|
|
|
while (*c)
|
|
h = (h * 37) + *c++;
|
|
return h;
|
|
}
|
|
|
|
static struct symbol *
|
|
cf_new_sym(byte *c, unsigned int h)
|
|
{
|
|
struct symbol *s, **ht;
|
|
int l;
|
|
|
|
if (!new_config->sym_hash)
|
|
new_config->sym_hash = cfg_allocz(SYM_HASH_SIZE * sizeof(struct keyword *));
|
|
ht = new_config->sym_hash;
|
|
l = strlen(c);
|
|
if (l > SYM_MAX_LEN)
|
|
cf_error("Symbol too long");
|
|
s = cfg_alloc(sizeof(struct symbol) + l);
|
|
s->next = ht[h];
|
|
ht[h] = s;
|
|
s->scope = conf_this_scope;
|
|
s->class = SYM_VOID;
|
|
s->def = NULL;
|
|
s->aux = 0;
|
|
strcpy(s->name, c);
|
|
return s;
|
|
}
|
|
|
|
static struct symbol *
|
|
cf_find_sym(byte *c, unsigned int h0)
|
|
{
|
|
unsigned int h = h0 & (SYM_HASH_SIZE-1);
|
|
struct symbol *s, **ht;
|
|
|
|
if (ht = new_config->sym_hash)
|
|
{
|
|
for(s = ht[h]; s; s=s->next)
|
|
if (!strcmp(s->name, c) && s->scope->active)
|
|
return s;
|
|
}
|
|
if (new_config->sym_fallback)
|
|
{
|
|
/* We know only top-level scope is active */
|
|
for(s = new_config->sym_fallback[h]; s; s=s->next)
|
|
if (!strcmp(s->name, c) && s->scope->active)
|
|
return s;
|
|
}
|
|
return cf_new_sym(c, h);
|
|
}
|
|
|
|
/**
|
|
* cf_find_symbol - find a symbol by name
|
|
* @c: symbol name
|
|
*
|
|
* This functions searches the symbol table for a symbol of given
|
|
* name. First it examines the current scope, then the second recent
|
|
* one and so on until it either finds the symbol and returns a pointer
|
|
* to its &symbol structure or reaches the end of the scope chain
|
|
* and returns %NULL to signify no match.
|
|
*/
|
|
struct symbol *
|
|
cf_find_symbol(byte *c)
|
|
{
|
|
return cf_find_sym(c, cf_hash(c));
|
|
}
|
|
|
|
struct symbol *
|
|
cf_default_name(char *template, int *counter)
|
|
{
|
|
char buf[32];
|
|
struct symbol *s;
|
|
char *perc = strchr(template, '%');
|
|
|
|
for(;;)
|
|
{
|
|
bsprintf(buf, template, ++(*counter));
|
|
s = cf_find_sym(buf, cf_hash(buf));
|
|
if (!s)
|
|
break;
|
|
if (s->class == SYM_VOID)
|
|
return s;
|
|
if (!perc)
|
|
break;
|
|
}
|
|
cf_error("Unable to generate default name");
|
|
}
|
|
|
|
/**
|
|
* cf_define_symbol - define meaning of a symbol
|
|
* @sym: symbol to be defined
|
|
* @type: symbol class to assign
|
|
* @def: class dependent data
|
|
*
|
|
* Defines new meaning of a symbol. If the symbol is an undefined
|
|
* one (%SYM_VOID), it's just re-defined to the new type. If it's defined
|
|
* in different scope, a new symbol in current scope is created and the
|
|
* meaning is assigned to it. If it's already defined in the current scope,
|
|
* an error is reported via cf_error().
|
|
*
|
|
* Result: Pointer to the newly defined symbol. If we are in the top-level
|
|
* scope, it's the same @sym as passed to the function.
|
|
*/
|
|
struct symbol *
|
|
cf_define_symbol(struct symbol *sym, int type, void *def)
|
|
{
|
|
if (sym->class)
|
|
{
|
|
if (sym->scope == conf_this_scope)
|
|
cf_error("Symbol already defined");
|
|
sym = cf_new_sym(sym->name, cf_hash(sym->name) & (SYM_HASH_SIZE-1));
|
|
}
|
|
sym->class = type;
|
|
sym->def = def;
|
|
return sym;
|
|
}
|
|
|
|
static void
|
|
cf_lex_init_kh(void)
|
|
{
|
|
struct keyword *k;
|
|
|
|
for(k=keyword_list; k->name; k++)
|
|
{
|
|
unsigned h = cf_hash(k->name) & (KW_HASH_SIZE-1);
|
|
k->next = kw_hash[h];
|
|
kw_hash[h] = k;
|
|
}
|
|
kw_hash_inited = 1;
|
|
}
|
|
|
|
/**
|
|
* cf_lex_init - initialize the lexer
|
|
* @is_cli: true if we're going to parse CLI command, false for configuration
|
|
*
|
|
* cf_lex_init() initializes the lexical analyzer and prepares it for
|
|
* parsing of a new input.
|
|
*/
|
|
void
|
|
cf_lex_init(int is_cli)
|
|
{
|
|
if (!kw_hash_inited)
|
|
cf_lex_init_kh();
|
|
conf_lino = 1;
|
|
yyrestart(NULL);
|
|
if (is_cli)
|
|
BEGIN(CLI);
|
|
else
|
|
BEGIN(INITIAL);
|
|
conf_this_scope = cfg_allocz(sizeof(struct sym_scope));
|
|
conf_this_scope->active = 1;
|
|
}
|
|
|
|
/**
|
|
* cf_push_scope - enter new scope
|
|
* @sym: symbol representing scope name
|
|
*
|
|
* If we want to enter a new scope to process declarations inside
|
|
* a nested block, we can just call cf_push_scope() to push a new
|
|
* scope onto the scope stack which will cause all new symbols to be
|
|
* defined in this scope and all existing symbols to be sought for
|
|
* in all scopes stored on the stack.
|
|
*/
|
|
void
|
|
cf_push_scope(struct symbol *sym)
|
|
{
|
|
struct sym_scope *s = cfg_alloc(sizeof(struct sym_scope));
|
|
|
|
s->next = conf_this_scope;
|
|
conf_this_scope = s;
|
|
s->active = 1;
|
|
s->name = sym;
|
|
}
|
|
|
|
/**
|
|
* cf_pop_scope - leave a scope
|
|
*
|
|
* cf_pop_scope() pops the topmost scope from the scope stack,
|
|
* leaving all its symbols in the symbol table, but making them
|
|
* invisible to the rest of the config.
|
|
*/
|
|
void
|
|
cf_pop_scope(void)
|
|
{
|
|
conf_this_scope->active = 0;
|
|
conf_this_scope = conf_this_scope->next;
|
|
ASSERT(conf_this_scope);
|
|
}
|
|
|
|
struct symbol *
|
|
cf_walk_symbols(struct config *cf, struct symbol *sym, int *pos)
|
|
{
|
|
for(;;)
|
|
{
|
|
if (!sym)
|
|
{
|
|
if (*pos >= SYM_HASH_SIZE)
|
|
return NULL;
|
|
sym = cf->sym_hash[(*pos)++];
|
|
}
|
|
else
|
|
sym = sym->next;
|
|
if (sym && sym->scope->active)
|
|
return sym;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* cf_symbol_class_name - get name of a symbol class
|
|
* @sym: symbol
|
|
*
|
|
* This function returns a string representing the class
|
|
* of the given symbol.
|
|
*/
|
|
char *
|
|
cf_symbol_class_name(struct symbol *sym)
|
|
{
|
|
switch (sym->class)
|
|
{
|
|
case SYM_VOID:
|
|
return "undefined";
|
|
case SYM_PROTO:
|
|
return "protocol";
|
|
case SYM_NUMBER:
|
|
return "numeric constant";
|
|
case SYM_FUNCTION:
|
|
return "function";
|
|
case SYM_FILTER:
|
|
return "filter";
|
|
case SYM_TABLE:
|
|
return "routing table";
|
|
case SYM_IPA:
|
|
return "network address";
|
|
default:
|
|
return "unknown type";
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* DOC: Parser
|
|
*
|
|
* Both the configuration and CLI commands are analyzed using a syntax
|
|
* driven parser generated by the |bison| tool from a grammar which
|
|
* is constructed from information gathered from grammar snippets by
|
|
* the |gen_parser.m4| script.
|
|
*
|
|
* Grammar snippets are files (usually with extension |.Y|) contributed
|
|
* by various BIRD modules in order to provide information about syntax of their
|
|
* configuration and their CLI commands. Each snipped consists of several
|
|
* sections, each of them starting with a special keyword: |CF_HDR| for
|
|
* a list of |#include| directives needed by the C code, |CF_DEFINES|
|
|
* for a list of C declarations, |CF_DECLS| for |bison| declarations
|
|
* including keyword definitions specified as |CF_KEYWORDS|, |CF_GRAMMAR|
|
|
* for the grammar rules, |CF_CODE| for auxiliary C code and finally
|
|
* |CF_END| at the end of the snippet.
|
|
*
|
|
* To create references between the snippets, it's possible to define
|
|
* multi-part rules by utilizing the |CF_ADDTO| macro which adds a new
|
|
* alternative to a multi-part rule.
|
|
*
|
|
* CLI commands are defined using a |CF_CLI| macro. Its parameters are:
|
|
* the list of keywords determining the command, the list of parameters,
|
|
* help text for the parameters and help text for the command.
|
|
*
|
|
* Values of |enum| filter types can be defined using |CF_ENUM| with
|
|
* the following parameters: name of filter type, prefix common for all
|
|
* literals of this type and names of all the possible values.
|
|
*/
|