2 * Command format string parser for CLI backend.
5 * Copyright (C) 2016 Cumulus Networks, Inc.
7 * This file is part of GNU Zebra.
9 * GNU Zebra is free software; you can redistribute it and/or modify it
10 * under the terms of the GNU General Public License as published by the
11 * Free Software Foundation; either version 2, or (at your option) any
14 * GNU Zebra is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with GNU Zebra; see the file COPYING. If not, write to the Free
21 * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
26 // compile with debugging facilities
31 /* define parse.error verbose */
33 /* define api.prefix {cmd_yy} */
35 /* names for generated header and parser files */
36 %defines "lib/command_parse.h"
37 %output "lib/command_parse.c"
39 /* note: code blocks are output in order, to both .c and .h:
41 * 2. %union + bison forward decls
43 * command_lex.h needs to be included at 3.; it needs the union and YYSTYPE.
44 * struct parser_ctx is needed for the bison forward decls.
54 #include "command_graph.h"
59 #define YYSTYPE CMD_YYSTYPE
60 #define YYLTYPE CMD_YYLTYPE
63 /* subgraph semantic value */
65 struct graph_node *start, *end;
72 struct graph_node *node;
73 struct subgraph subgraph;
78 #include "lib/command_lex.h"
81 extern void set_lexer_string (yyscan_t *scn, const char *string);
82 extern void cleanup_lexer (yyscan_t *scn);
87 const struct cmd_element *el;
90 struct graph_node *currnode;
92 /* pointers to copy of command docstring */
93 char *docstr_start, *docstr;
97 /* union types for lexed tokens */
100 %token <string> IPV4_PREFIX
102 %token <string> IPV6_PREFIX
103 %token <string> VARIABLE
104 %token <string> RANGE
106 %token <string> MAC_PREFIX
108 /* special syntax, value is irrelevant */
109 %token <string> EXCL_BRACKET
111 /* union types for parsed rules */
113 %type <node> literal_token
114 %type <node> placeholder_token
115 %type <node> placeholder_token_real
116 %type <node> simple_token
117 %type <subgraph> selector
118 %type <subgraph> selector_token
119 %type <subgraph> selector_token_seq
120 %type <subgraph> selector_seq_seq
122 %type <string> varname_token
126 /* bison declarations */
128 cmd_yyerror (CMD_YYLTYPE *locp, struct parser_ctx *ctx, char const *msg);
130 /* helper functions for parser */
132 doc_next (struct parser_ctx *ctx);
134 static struct graph_node *
135 new_token_node (struct parser_ctx *,
136 enum cmd_token_type type,
141 terminate_graph (CMD_YYLTYPE *locp, struct parser_ctx *ctx,
142 struct graph_node *);
145 cleanup (struct parser_ctx *ctx);
147 static void loopcheck(struct parser_ctx *ctx, struct subgraph *sg);
149 #define scanner ctx->scanner
152 /* yyparse parameters */
153 %lex-param {yyscan_t scanner}
154 %parse-param {struct parser_ctx *ctx}
156 /* called automatically before yyparse */
158 /* clear state pointers */
159 ctx->currnode = vector_slot (ctx->graph->nodes, 0);
161 /* copy docstring and keep a pointer to the copy */
164 // allocate a new buffer, making room for a flag
165 size_t length = (size_t) strlen (ctx->el->doc) + 2;
166 ctx->docstr = malloc (length);
167 memcpy (ctx->docstr, ctx->el->doc, strlen (ctx->el->doc));
168 // set the flag so doc_next knows when to print a warning
169 ctx->docstr[length - 2] = 0x03;
171 ctx->docstr[length - 1] = 0x00;
173 ctx->docstr_start = ctx->docstr;
181 // tack on the command element
182 terminate_graph (&@1, ctx, ctx->currnode);
184 | cmd_token_seq placeholder_token '.' '.' '.'
186 if ((ctx->currnode = graph_add_edge (ctx->currnode, $2)) != $2)
187 graph_delete_node (ctx->graph, $2);
189 ((struct cmd_token *)ctx->currnode->data)->allowrepeat = 1;
191 // adding a node as a child of itself accepts any number
192 // of the same token, which is what we want for variadics
193 graph_add_edge (ctx->currnode, ctx->currnode);
195 // tack on the command element
196 terminate_graph (&@1, ctx, ctx->currnode);
200 varname_token: '$' WORD
212 | cmd_token_seq cmd_token
218 if ((ctx->currnode = graph_add_edge (ctx->currnode, $1)) != $1)
219 graph_delete_node (ctx->graph, $1);
223 graph_add_edge (ctx->currnode, $1.start);
224 ctx->currnode = $1.end;
233 literal_token: WORD varname_token
235 $$ = new_token_node (ctx, WORD_TKN, $1, doc_next(ctx));
236 cmd_token_varname_set ($$->data, $2);
237 XFREE (MTYPE_LEX, $2);
238 XFREE (MTYPE_LEX, $1);
242 placeholder_token_real:
245 $$ = new_token_node (ctx, IPV4_TKN, $1, doc_next(ctx));
246 XFREE (MTYPE_LEX, $1);
250 $$ = new_token_node (ctx, IPV4_PREFIX_TKN, $1, doc_next(ctx));
251 XFREE (MTYPE_LEX, $1);
255 $$ = new_token_node (ctx, IPV6_TKN, $1, doc_next(ctx));
256 XFREE (MTYPE_LEX, $1);
260 $$ = new_token_node (ctx, IPV6_PREFIX_TKN, $1, doc_next(ctx));
261 XFREE (MTYPE_LEX, $1);
265 $$ = new_token_node (ctx, VARIABLE_TKN, $1, doc_next(ctx));
266 XFREE (MTYPE_LEX, $1);
270 $$ = new_token_node (ctx, RANGE_TKN, $1, doc_next(ctx));
271 struct cmd_token *token = $$->data;
273 // get the numbers out
275 token->min = strtoll (yylval.string, &yylval.string, 10);
276 strsep (&yylval.string, "-");
277 token->max = strtoll (yylval.string, &yylval.string, 10);
280 if (token->min > token->max) cmd_yyerror (&@1, ctx, "Invalid range.");
282 XFREE (MTYPE_LEX, $1);
286 $$ = new_token_node (ctx, MAC_TKN, $1, doc_next(ctx));
287 XFREE (MTYPE_LEX, $1);
291 $$ = new_token_node (ctx, MAC_PREFIX_TKN, $1, doc_next(ctx));
292 XFREE (MTYPE_LEX, $1);
296 placeholder_token_real varname_token
298 struct cmd_token *token = $$->data;
300 cmd_token_varname_set (token, $2);
301 XFREE (MTYPE_LEX, $2);
305 /* <selector|set> productions */
306 selector: '<' selector_seq_seq '>' varname_token
309 cmd_token_varname_set ($2.end->data, $4);
310 XFREE (MTYPE_LEX, $4);
314 selector_seq_seq '|' selector_token_seq
317 graph_add_edge ($$.start, $3.start);
318 graph_add_edge ($3.end, $$.end);
322 $$.start = new_token_node (ctx, FORK_TKN, NULL, NULL);
323 $$.end = new_token_node (ctx, JOIN_TKN, NULL, NULL);
324 ((struct cmd_token *)$$.start->data)->forkjoin = $$.end;
325 ((struct cmd_token *)$$.end->data)->forkjoin = $$.start;
327 graph_add_edge ($$.start, $1.start);
328 graph_add_edge ($1.end, $$.end);
332 /* {keyword} productions */
333 selector: '{' selector_seq_seq '}' varname_token
336 graph_add_edge ($$.end, $$.start);
337 /* there is intentionally no start->end link, for two reasons:
338 * 1) this allows "at least 1 of" semantics, which are otherwise impossible
339 * 2) this would add a start->end->start loop in the graph that the current
340 * loop-avoidal fails to handle
341 * just use [{a|b}] if neccessary, that will work perfectly fine, and reason
342 * #1 is good enough to keep it this way. */
345 cmd_token_varname_set ($2.end->data, $4);
346 XFREE (MTYPE_LEX, $4);
353 $$.start = $$.end = $1;
359 selector_token_seq selector_token
361 graph_add_edge ($1.end, $2.start);
368 /* [option] productions */
369 selector: '[' selector_seq_seq ']' varname_token
372 graph_add_edge ($$.start, $$.end);
373 cmd_token_varname_set ($2.end->data, $4);
374 XFREE (MTYPE_LEX, $4);
378 /* ![option] productions */
379 selector: EXCL_BRACKET selector_seq_seq ']' varname_token
381 struct graph_node *neg_only = new_token_node (ctx, NEG_ONLY_TKN, NULL, NULL);
384 graph_add_edge ($$.start, neg_only);
385 graph_add_edge (neg_only, $$.end);
386 cmd_token_varname_set ($2.end->data, $4);
387 XFREE (MTYPE_LEX, $4);
395 DEFINE_MTYPE(LIB, LEX, "Lexer token (temporary)");
398 cmd_graph_parse (struct graph *graph, const struct cmd_element *cmd)
400 struct parser_ctx ctx = { .graph = graph, .el = cmd };
402 // set to 1 to enable parser traces
405 set_lexer_string (&ctx.scanner, cmd->string);
407 // parse command into DFA
411 cleanup_lexer (&ctx.scanner);
417 /* parser helper functions */
419 static bool loopcheck_inner(struct graph_node *start, struct graph_node *node,
420 struct graph_node *end, size_t depth)
429 for (i = 0; i < vector_active(node->to); i++) {
430 struct graph_node *next = vector_slot(node->to, i);
431 struct cmd_token *tok = next->data;
433 if (next == end || next == start)
435 if (tok->type < SPECIAL_TKN)
437 ret = loopcheck_inner(start, next, end, depth);
444 static void loopcheck(struct parser_ctx *ctx, struct subgraph *sg)
446 if (loopcheck_inner(sg->start, sg->start, sg->end, 0))
447 zlog_err("FATAL: '%s': {} contains an empty path! Use [{...}]",
452 yyerror (CMD_YYLTYPE *loc, struct parser_ctx *ctx, char const *msg)
454 char *tmpstr = strdup(ctx->el->string);
459 zlog_notice ("%s: FATAL parse error: %s", __func__, msg);
460 zlog_notice ("%s: %d:%d-%d of this command definition:", __func__, loc->first_line, loc->first_column, loc->last_column);
465 eol = strchr(line, '\n');
469 zlog_notice ("%s: | %s", __func__, line);
470 if (lineno == loc->first_line && lineno == loc->last_line
471 && loc->first_column < (int)sizeof(spacing) - 1
472 && loc->last_column < (int)sizeof(spacing) - 1) {
474 int len = loc->last_column - loc->first_column;
478 memset(spacing, ' ', loc->first_column - 1);
479 memset(spacing + loc->first_column - 1, '^', len);
480 spacing[loc->first_column - 1 + len] = '\0';
481 zlog_notice ("%s: | %s", __func__, spacing);
483 } while ((line = eol));
488 cleanup (struct parser_ctx *ctx)
491 free (ctx->docstr_start);
493 /* clear state pointers */
494 ctx->currnode = NULL;
495 ctx->docstr_start = ctx->docstr = NULL;
499 terminate_graph (CMD_YYLTYPE *locp, struct parser_ctx *ctx,
500 struct graph_node *finalnode)
502 // end of graph should look like this
503 // * -> finalnode -> END_TKN -> cmd_element
504 const struct cmd_element *element = ctx->el;
505 struct graph_node *end_token_node =
506 new_token_node (ctx, END_TKN, CMD_CR_TEXT, "");
507 struct graph_node *end_element_node =
508 graph_new_node (ctx->graph, (void *)element, NULL);
510 if (ctx->docstr && strlen (ctx->docstr) > 1) {
511 zlog_err ("Excessive docstring while parsing '%s'", ctx->el->string);
512 zlog_err ("----------");
513 while (ctx->docstr && ctx->docstr[1] != '\0')
514 zlog_err ("%s", strsep(&ctx->docstr, "\n"));
515 zlog_err ("----------");
518 graph_add_edge (finalnode, end_token_node);
519 graph_add_edge (end_token_node, end_element_node);
523 doc_next (struct parser_ctx *ctx)
525 const char *piece = ctx->docstr ? strsep (&ctx->docstr, "\n") : "";
528 zlog_err ("Ran out of docstring while parsing '%s'", ctx->el->string);
535 static struct graph_node *
536 new_token_node (struct parser_ctx *ctx, enum cmd_token_type type,
537 const char *text, const char *doc)
539 struct cmd_token *token = cmd_token_new (type, ctx->el->attr, text, doc);
540 return graph_new_node (ctx->graph, token, (void (*)(void *)) &cmd_token_del);