Statistics
| Branch: | Revision:

iof-bird / bird-2.0.1 / conf / cf-lex.l @ 6b3f1a54

History | View | Annotate | Download (17.1 KB)

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
#include "lib/hash.h"
52

    
53
struct keyword {
54
  byte *name;
55
  int value;
56
  struct keyword *next;
57
};
58

    
59
#include "conf/keywords.h"
60

    
61
/* Could be defined by Bison in cf-parse.tab.h, inteferes with SYM hash */
62
#ifdef SYM
63
#undef SYM
64
#endif
65

    
66

    
67
static uint cf_hash(byte *c);
68

    
69
#define KW_KEY(n)		n->name
70
#define KW_NEXT(n)		n->next
71
#define KW_EQ(a,b)		!strcmp(a,b)
72
#define KW_FN(k)		cf_hash(k)
73
#define KW_ORDER		8 /* Fixed */
74

    
75
#define SYM_KEY(n)		n->name, n->scope->active
76
#define SYM_NEXT(n)		n->next
77
#define SYM_EQ(a,s1,b,s2)	!strcmp(a,b) && s1 == s2
78
#define SYM_FN(k,s)		cf_hash(k)
79
#define SYM_ORDER		6 /* Initial */
80

    
81
#define SYM_REHASH		sym_rehash
82
#define SYM_PARAMS		/8, *1, 2, 2, 6, 20
83

    
84

    
85
HASH_DEFINE_REHASH_FN(SYM, struct symbol)
86

    
87
HASH(struct keyword) kw_hash;
88

    
89

    
90
static struct sym_scope *conf_this_scope;
91

    
92
linpool *cfg_mem;
93

    
94
int (*cf_read_hook)(byte *buf, unsigned int max, int fd);
95
struct include_file_stack *ifs;
96
static struct include_file_stack *ifs_head;
97

    
98
#define MAX_INCLUDE_DEPTH 8
99

    
100
#define YY_INPUT(buf,result,max) result = cf_read_hook(buf, max, ifs->fd);
101
#define YY_NO_UNPUT
102
#define YY_FATAL_ERROR(msg) cf_error(msg)
103

    
104
static void cf_include(char *arg, int alen);
105
static int check_eof(void);
106

    
107
%}
108

    
109
%option noyywrap
110
%option noinput
111
%option nounput
112
%option noreject
113

    
114
%x COMMENT CCOMM CLI
115

    
116
ALPHA [a-zA-Z_]
117
DIGIT [0-9]
118
XIGIT [0-9a-fA-F]
119
ALNUM [a-zA-Z_0-9]
120
WHITE [ \t]
121
include   ^{WHITE}*include{WHITE}*\".*\"{WHITE}*;
122

    
123
%%
124
{include} {
125
  char *start, *end;
126

    
127
  if (!ifs->depth)
128
    cf_error("Include not allowed in CLI");
129

    
130
  start = strchr(yytext, '"');
131
  start++;
132

    
133
  end = strchr(start, '"');
134
  *end = 0;
135

    
136
  if (start == end)
137
    cf_error("Include with empty argument");
138

    
139
  cf_include(start, end-start);
140
}
141

    
142
{DIGIT}+:{DIGIT}+ {
143
  uint len1 UNUSED, len2;
144
  u64 l;
145
  char *e;
146

    
147
  errno = 0;
148
  l = strtoul(yytext, &e, 10);
149
  if (e && (*e != ':') || (errno == ERANGE) || (l >> 32))
150
    cf_error("ASN out of range");
151

    
152
  if (l >> 16)
153
  {
154
    len1 = 32;
155
    len2 = 16;
156
    cf_lval.i64 = (2ULL << 48) | (((u64) l) << len2);
157
  }
158
  else
159
  {
160
    len1 = 16;
161
    len2 = 32;
162
    cf_lval.i64 = 0 | (((u64) l) << len2);
163
  }
164

    
165
  errno = 0;
166
  l = strtoul(e+1, &e, 10);
167
  if (e && *e || (errno == ERANGE) || (l >> len2))
168
    cf_error("Number out of range");
169
  cf_lval.i64 |= l;
170

    
171
  return VPN_RD;
172
}
173

    
174
[02]:{DIGIT}+:{DIGIT}+ {
175
  uint len1, len2;
176
  u64 l;
177
  char *e;
178

    
179
  if (yytext[0] == '0')
180
  {
181
    cf_lval.i64 = 0;
182
    len1 = 16;
183
    len2 = 32;
184
  }
185
  else
186
  {
187
    cf_lval.i64 = 2ULL << 48;
188
    len1 = 32;
189
    len2 = 16;
190
  }
191

    
192
  errno = 0;
193
  l = strtoul(yytext+2, &e, 10);
194
  if (e && (*e != ':') || (errno == ERANGE) || (l >> len1))
195
    cf_error("ASN out of range");
196
  cf_lval.i64 |= ((u64) l) << len2;
197

    
198
  errno = 0;
199
  l = strtoul(e+1, &e, 10);
200
  if (e && *e || (errno == ERANGE) || (l >> len2))
201
    cf_error("Number out of range");
202
  cf_lval.i64 |= l;
203

    
204
  return VPN_RD;
205
}
206

    
207
{DIGIT}+\.{DIGIT}+\.{DIGIT}+\.{DIGIT}+:{DIGIT}+ {
208
  unsigned long int l;
209
  ip4_addr ip4;
210
  char *e;
211

    
212
  cf_lval.i64 = 1ULL << 48;
213

    
214
  e = strchr(yytext, ':');
215
  *e++ = '\0';
216
  if (!ip4_pton(yytext, &ip4))
217
    cf_error("Invalid IPv4 address %s in Route Distinguisher", yytext);
218
  cf_lval.i64 |= ((u64) ip4_to_u32(ip4)) << 16;
219

    
220
  errno = 0;
221
  l = strtoul(e, &e, 10);
222
  if (e && *e || (errno == ERANGE) || (l >> 16))
223
    cf_error("Number out of range");
224
  cf_lval.i64 |= l;
225

    
226
  return VPN_RD;
227
}
228

    
229
{DIGIT}+\.{DIGIT}+\.{DIGIT}+\.{DIGIT}+ {
230
  if (!ip4_pton(yytext, &cf_lval.ip4))
231
    cf_error("Invalid IPv4 address %s", yytext);
232
  return IP4;
233
}
234

    
235
({XIGIT}*::|({XIGIT}*:){3,})({XIGIT}*|{DIGIT}+\.{DIGIT}+\.{DIGIT}+\.{DIGIT}+) {
236
  if (!ip6_pton(yytext, &cf_lval.ip6))
237
    cf_error("Invalid IPv6 address %s", yytext);
238
  return IP6;
239
}
240

    
241
0x{XIGIT}+ {
242
  char *e;
243
  unsigned long int l;
244
  errno = 0;
245
  l = strtoul(yytext+2, &e, 16);
246
  if (e && *e || errno == ERANGE || (unsigned long int)(unsigned int) l != l)
247
    cf_error("Number out of range");
248
  cf_lval.i = l;
249
  return NUM;
250
}
251

    
252
{DIGIT}+ {
253
  char *e;
254
  unsigned long int l;
255
  errno = 0;
256
  l = strtoul(yytext, &e, 10);
257
  if (e && *e || errno == ERANGE || (unsigned long int)(unsigned int) l != l)
258
    cf_error("Number out of range");
259
  cf_lval.i = l;
260
  return NUM;
261
}
262

    
263
else: {
264
  /* Hack to distinguish if..else from else: in case */
265
  return ELSECOL;
266
}
267

    
268
({ALPHA}{ALNUM}*|[']({ALNUM}|[-]|[\.]|[:])*[']) {
269
  if(*yytext == '\'') {
270
    yytext[yyleng-1] = 0;
271
    yytext++;
272
  }
273

    
274
  struct keyword *k = HASH_FIND(kw_hash, KW, yytext);
275
  if (k)
276
  {
277
    if (k->value > 0)
278
      return k->value;
279
    else
280
    {
281
      cf_lval.i = -k->value;
282
      return ENUM;
283
    }
284
  }
285

    
286
  cf_lval.s = cf_get_symbol(yytext);
287
  return SYM;
288
}
289

    
290
<CLI>(.|\n) {
291
  BEGIN(INITIAL);
292
  return CLI_MARKER;
293
}
294

    
295
\.\. {
296
  return DDOT;
297
}
298

    
299
[={}:;,.()+*/%<>~\[\]?!\|-] {
300
  return yytext[0];
301
}
302

    
303
["][^"\n]*["] {
304
  yytext[yyleng-1] = 0;
305
  cf_lval.t = cfg_strdup(yytext+1);
306
  yytext[yyleng-1] = '"';
307
  return TEXT;
308
}
309

    
310
["][^"\n]*\n	cf_error("Unterminated string");
311

    
312
<INITIAL,COMMENT><<EOF>>	{ if (check_eof()) return END; }
313

    
314
{WHITE}+
315

    
316
\n	ifs->lino++;
317

    
318
#	BEGIN(COMMENT);
319

    
320
\/\*	BEGIN(CCOMM);
321

    
322
.	cf_error("Unknown character");
323

    
324
<COMMENT>\n {
325
  ifs->lino++;
326
  BEGIN(INITIAL);
327
}
328

    
329
<COMMENT>.
330

    
331
<CCOMM>\*\/	BEGIN(INITIAL);
332
<CCOMM>\n	ifs->lino++;
333
<CCOMM>\/\*	cf_error("Comment nesting not supported");
334
<CCOMM><<EOF>>	cf_error("Unterminated comment");
335
<CCOMM>.
336

    
337
\!\= return NEQ;
338
\!\~ return NMA;
339
\<\= return LEQ;
340
\>\= return GEQ;
341
\&\& return AND;
342
\|\| return OR;
343

    
344
\[\= return PO;
345
\=\] return PC;
346

    
347
%%
348

    
349
static uint
350
cf_hash(byte *c)
351
{
352
  uint h = 13 << 24;
353

    
354
  while (*c)
355
    h = h + (h >> 2) + (h >> 5) + ((uint) *c++ << 24);
356
  return h;
357
}
358

    
359

    
360
/*
361
 * IFS stack - it contains structures needed for recursive processing
362
 * of include in config files. On the top of the stack is a structure
363
 * for currently processed file. Other structures are either for
364
 * active files interrupted because of include directive (these have
365
 * fd and flex buffer) or for inactive files scheduled to be processed
366
 * later (when parent requested including of several files by wildcard
367
 * match - these do not have fd and flex buffer yet).
368
 *
369
 * FIXME: Most of these ifs and include functions are really sysdep/unix.
370
 */
371

    
372
static struct include_file_stack *
373
push_ifs(struct include_file_stack *old)
374
{
375
  struct include_file_stack *ret;
376
  ret = cfg_allocz(sizeof(struct include_file_stack));
377
  ret->lino = 1;
378
  ret->prev = old;
379
  return ret;
380
}
381

    
382
static struct include_file_stack *
383
pop_ifs(struct include_file_stack *old)
384
{
385
 yy_delete_buffer(old->buffer);
386
 close(old->fd);
387
 return old->prev;
388
}
389

    
390
static void
391
enter_ifs(struct include_file_stack *new)
392
{
393
  if (!new->buffer)
394
    {
395
      new->fd = open(new->file_name, O_RDONLY);
396
      if (new->fd < 0)
397
        {
398
          ifs = ifs->up;
399
	  cf_error("Unable to open included file %s: %m", new->file_name);
400
        }
401

    
402
      new->buffer = yy_create_buffer(NULL, YY_BUF_SIZE);
403
    }
404

    
405
  yy_switch_to_buffer(new->buffer);
406
}
407

    
408
/**
409
 * cf_lex_unwind - unwind lexer state during error
410
 *
411
 * cf_lex_unwind() frees the internal state on IFS stack when the lexical
412
 * analyzer is terminated by cf_error().
413
 */
414
void
415
cf_lex_unwind(void)
416
{
417
  struct include_file_stack *n;
418

    
419
  for (n = ifs; n != ifs_head; n = n->prev)
420
    {
421
      /* Memory is freed automatically */
422
      if (n->buffer)
423
	yy_delete_buffer(n->buffer);
424
      if (n->fd)
425
        close(n->fd);
426
    }
427

    
428
  ifs = ifs_head;
429
}
430

    
431
static void
432
cf_include(char *arg, int alen)
433
{
434
  struct include_file_stack *base_ifs = ifs;
435
  int new_depth, rv, i;
436
  char *patt;
437
  glob_t g = {};
438

    
439
  new_depth = ifs->depth + 1;
440
  if (new_depth > MAX_INCLUDE_DEPTH)
441
    cf_error("Max include depth reached");
442

    
443
  /* expand arg to properly handle relative filenames */
444
  if (*arg != '/')
445
    {
446
      int dlen = strlen(ifs->file_name);
447
      char *dir = alloca(dlen + 1);
448
      patt = alloca(dlen + alen + 2);
449
      memcpy(dir, ifs->file_name, dlen + 1);
450
      sprintf(patt, "%s/%s", dirname(dir), arg);
451
    }
452
  else
453
    patt = arg;
454

    
455
  /* Skip globbing if there are no wildcards, mainly to get proper
456
     response when the included config file is missing */
457
  if (!strpbrk(arg, "?*["))
458
    {
459
      ifs = push_ifs(ifs);
460
      ifs->file_name = cfg_strdup(patt);
461
      ifs->depth = new_depth;
462
      ifs->up = base_ifs;
463
      enter_ifs(ifs);
464
      return;
465
    }
466

    
467
  /* Expand the pattern */
468
  rv = glob(patt, GLOB_ERR | GLOB_NOESCAPE, NULL, &g);
469
  if (rv == GLOB_ABORTED)
470
    cf_error("Unable to match pattern %s: %m", patt);
471
  if ((rv != 0) || (g.gl_pathc <= 0))
472
    return;
473

    
474
  /*
475
   * Now we put all found files to ifs stack in reverse order, they
476
   * will be activated and processed in order as ifs stack is popped
477
   * by pop_ifs() and enter_ifs() in check_eof().
478
   */
479
  for(i = g.gl_pathc - 1; i >= 0; i--)
480
    {
481
      char *fname = g.gl_pathv[i];
482
      struct stat fs;
483

    
484
      if (stat(fname, &fs) < 0)
485
	{
486
	  globfree(&g);
487
	  cf_error("Unable to stat included file %s: %m", fname);
488
	}
489

    
490
      if (fs.st_mode & S_IFDIR)
491
        continue;
492

    
493
      /* Prepare new stack item */
494
      ifs = push_ifs(ifs);
495
      ifs->file_name = cfg_strdup(fname);
496
      ifs->depth = new_depth;
497
      ifs->up = base_ifs;
498
    }
499

    
500
  globfree(&g);
501
  enter_ifs(ifs);
502
}
503

    
504
static int
505
check_eof(void)
506
{
507
  if (ifs == ifs_head)
508
    {
509
      /* EOF in main config file */
510
      ifs->lino = 1; /* Why this? */
511
      return 1;
512
    }
513

    
514
  ifs = pop_ifs(ifs);
515
  enter_ifs(ifs);
516
  return 0;
517
}
518

    
519
static struct symbol *
520
cf_new_symbol(byte *c)
521
{
522
  struct symbol *s;
523

    
524
  uint l = strlen(c);
525
  if (l > SYM_MAX_LEN)
526
    cf_error("Symbol too long");
527

    
528
  s = cfg_alloc(sizeof(struct symbol) + l);
529
  s->scope = conf_this_scope;
530
  s->class = SYM_VOID;
531
  s->def = NULL;
532
  s->aux = 0;
533
  strcpy(s->name, c);
534

    
535
  if (!new_config->sym_hash.data)
536
    HASH_INIT(new_config->sym_hash, new_config->pool, SYM_ORDER);
537

    
538
  HASH_INSERT2(new_config->sym_hash, SYM, new_config->pool, s);
539

    
540
  return s;
541
}
542

    
543
/**
544
 * cf_find_symbol - find a symbol by name
545
 * @cfg: specificed config
546
 * @c: symbol name
547
 *
548
 * This functions searches the symbol table in the config @cfg for a symbol of
549
 * given name. First it examines the current scope, then the second recent one
550
 * and so on until it either finds the symbol and returns a pointer to its
551
 * &symbol structure or reaches the end of the scope chain and returns %NULL to
552
 * signify no match.
553
 */
554
struct symbol *
555
cf_find_symbol(struct config *cfg, byte *c)
556
{
557
  struct symbol *s;
558

    
559
  if (cfg->sym_hash.data &&
560
      (s = HASH_FIND(cfg->sym_hash, SYM, c, 1)))
561
    return s;
562

    
563
  if (cfg->fallback &&
564
      cfg->fallback->sym_hash.data &&
565
      (s = HASH_FIND(cfg->fallback->sym_hash, SYM, c, 1)))
566
    return s;
567

    
568
  return NULL;
569
}
570

    
571
/**
572
 * cf_get_symbol - get a symbol by name
573
 * @c: symbol name
574
 *
575
 * This functions searches the symbol table of the currently parsed config
576
 * (@new_config) for a symbol of given name. It returns either the already
577
 * existing symbol or a newly allocated undefined (%SYM_VOID) symbol if no
578
 * existing symbol is found.
579
 */
580
struct symbol *
581
cf_get_symbol(byte *c)
582
{
583
  return cf_find_symbol(new_config, c) ?: cf_new_symbol(c);
584
}
585

    
586
struct symbol *
587
cf_default_name(char *template, int *counter)
588
{
589
  char buf[SYM_MAX_LEN];
590
  struct symbol *s;
591
  char *perc = strchr(template, '%');
592

    
593
  for(;;)
594
    {
595
      bsprintf(buf, template, ++(*counter));
596
      s = cf_get_symbol(buf);
597
      if (s->class == SYM_VOID)
598
	return s;
599
      if (!perc)
600
	break;
601
    }
602
  cf_error("Unable to generate default name");
603
}
604

    
605
/**
606
 * cf_define_symbol - define meaning of a symbol
607
 * @sym: symbol to be defined
608
 * @type: symbol class to assign
609
 * @def: class dependent data
610
 *
611
 * Defines new meaning of a symbol. If the symbol is an undefined
612
 * one (%SYM_VOID), it's just re-defined to the new type. If it's defined
613
 * in different scope, a new symbol in current scope is created and the
614
 * meaning is assigned to it. If it's already defined in the current scope,
615
 * an error is reported via cf_error().
616
 *
617
 * Result: Pointer to the newly defined symbol. If we are in the top-level
618
 * scope, it's the same @sym as passed to the function.
619
 */
620
struct symbol *
621
cf_define_symbol(struct symbol *sym, int type, void *def)
622
{
623
  if (sym->class)
624
    {
625
      if (sym->scope == conf_this_scope)
626
	cf_error("Symbol already defined");
627
      sym = cf_new_symbol(sym->name);
628
    }
629
  sym->class = type;
630
  sym->def = def;
631
  return sym;
632
}
633

    
634
static void
635
cf_lex_init_kh(void)
636
{
637
  HASH_INIT(kw_hash, &root_pool, KW_ORDER);
638

    
639
  struct keyword *k;
640
  for (k=keyword_list; k->name; k++)
641
    HASH_INSERT(kw_hash, KW, k);
642
}
643

    
644
/**
645
 * cf_lex_init - initialize the lexer
646
 * @is_cli: true if we're going to parse CLI command, false for configuration
647
 * @c: configuration structure
648
 *
649
 * cf_lex_init() initializes the lexical analyzer and prepares it for
650
 * parsing of a new input.
651
 */
652
void
653
cf_lex_init(int is_cli, struct config *c)
654
{
655
  if (!kw_hash.data)
656
    cf_lex_init_kh();
657

    
658
  ifs_head = ifs = push_ifs(NULL);
659
  if (!is_cli)
660
    {
661
      ifs->file_name = c->file_name;
662
      ifs->fd = c->file_fd;
663
      ifs->depth = 1;
664
    }
665

    
666
  yyrestart(NULL);
667
  ifs->buffer = YY_CURRENT_BUFFER;
668

    
669
  if (is_cli)
670
    BEGIN(CLI);
671
  else
672
    BEGIN(INITIAL);
673

    
674
  conf_this_scope = cfg_allocz(sizeof(struct sym_scope));
675
  conf_this_scope->active = 1;
676
}
677

    
678
/**
679
 * cf_push_scope - enter new scope
680
 * @sym: symbol representing scope name
681
 *
682
 * If we want to enter a new scope to process declarations inside
683
 * a nested block, we can just call cf_push_scope() to push a new
684
 * scope onto the scope stack which will cause all new symbols to be
685
 * defined in this scope and all existing symbols to be sought for
686
 * in all scopes stored on the stack.
687
 */
688
void
689
cf_push_scope(struct symbol *sym)
690
{
691
  struct sym_scope *s = cfg_alloc(sizeof(struct sym_scope));
692

    
693
  s->next = conf_this_scope;
694
  conf_this_scope = s;
695
  s->active = 1;
696
  s->name = sym;
697
}
698

    
699
/**
700
 * cf_pop_scope - leave a scope
701
 *
702
 * cf_pop_scope() pops the topmost scope from the scope stack,
703
 * leaving all its symbols in the symbol table, but making them
704
 * invisible to the rest of the config.
705
 */
706
void
707
cf_pop_scope(void)
708
{
709
  conf_this_scope->active = 0;
710
  conf_this_scope = conf_this_scope->next;
711
  ASSERT(conf_this_scope);
712
}
713

    
714
/**
715
 * cf_symbol_class_name - get name of a symbol class
716
 * @sym: symbol
717
 *
718
 * This function returns a string representing the class
719
 * of the given symbol.
720
 */
721
char *
722
cf_symbol_class_name(struct symbol *sym)
723
{
724
  if (cf_symbol_is_constant(sym))
725
    return "constant";
726

    
727
  switch (sym->class)
728
    {
729
    case SYM_VOID:
730
      return "undefined";
731
    case SYM_PROTO:
732
      return "protocol";
733
    case SYM_TEMPLATE:
734
      return "protocol template";
735
    case SYM_FUNCTION:
736
      return "function";
737
    case SYM_FILTER:
738
      return "filter";
739
    case SYM_TABLE:
740
      return "routing table";
741
    default:
742
      return "unknown type";
743
    }
744
}
745

    
746

    
747
/**
748
 * DOC: Parser
749
 *
750
 * Both the configuration and CLI commands are analyzed using a syntax
751
 * driven parser generated by the |bison| tool from a grammar which
752
 * is constructed from information gathered from grammar snippets by
753
 * the |gen_parser.m4| script.
754
 *
755
 * Grammar snippets are files (usually with extension |.Y|) contributed
756
 * by various BIRD modules in order to provide information about syntax of their
757
 * configuration and their CLI commands. Each snipped consists of several
758
 * sections, each of them starting with a special keyword: |CF_HDR| for
759
 * a list of |#include| directives needed by the C code, |CF_DEFINES|
760
 * for a list of C declarations, |CF_DECLS| for |bison| declarations
761
 * including keyword definitions specified as |CF_KEYWORDS|, |CF_GRAMMAR|
762
 * for the grammar rules, |CF_CODE| for auxiliary C code and finally
763
 * |CF_END| at the end of the snippet.
764
 *
765
 * To create references between the snippets, it's possible to define
766
 * multi-part rules by utilizing the |CF_ADDTO| macro which adds a new
767
 * alternative to a multi-part rule.
768
 *
769
 * CLI commands are defined using a |CF_CLI| macro. Its parameters are:
770
 * the list of keywords determining the command, the list of parameters,
771
 * help text for the parameters and help text for the command.
772
 *
773
 * Values of |enum| filter types can be defined using |CF_ENUM| with
774
 * the following parameters: name of filter type, prefix common for all
775
 * literals of this type and names of all the possible values.
776
 */