6654780c185ddcd88ad3d3d8517fc48c1e566813
1 /*
2 * SysDB - src/parser/grammar.y
3 * Copyright (C) 2013-2015 Sebastian 'tokkee' Harl <sh@tokkee.org>
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
17 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
18 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
19 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
20 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
22 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
23 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
24 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
25 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
28 /*
29 * Grammar for the SysDB Query Language (SysQL).
30 */
32 %{
34 #include "core/store.h"
35 #include "core/time.h"
37 #include "parser/ast.h"
38 #include "parser/parser.h"
39 #include "parser/grammar.h"
41 #include "utils/error.h"
42 #include "utils/llist.h"
44 #include <assert.h>
46 #include <stdio.h>
47 #include <string.h>
49 /*
50 * public API
51 */
53 int
54 sdb_parser_yylex(YYSTYPE *yylval, YYLTYPE *yylloc, sdb_parser_yyscan_t yyscanner);
56 sdb_parser_yyextra_t *
57 sdb_parser_yyget_extra(sdb_parser_yyscan_t scanner);
59 void
60 sdb_parser_yyerror(YYLTYPE *lval, sdb_parser_yyscan_t scanner, const char *msg);
61 void
62 sdb_parser_yyerrorf(YYLTYPE *lval, sdb_parser_yyscan_t scanner, const char *fmt, ...);
64 /* quick access to the current parse tree */
65 #define pt sdb_parser_yyget_extra(scanner)->parsetree
67 /* quick access to the parser mode */
68 #define parser_mode sdb_parser_yyget_extra(scanner)->mode
70 /* quick access to the parser's error buffer */
71 #define errbuf sdb_parser_yyget_extra(scanner)->errbuf
73 #define CK_OOM(p) \
74 do { \
75 if (! (p)) { \
76 sdb_parser_yyerror(&yylloc, scanner, YY_("out of memory")); \
77 YYABORT; \
78 } \
79 } while (0)
81 #define MODE_TO_STRING(m) \
82 (((m) == SDB_PARSE_DEFAULT) ? "statement" \
83 : ((m) == SDB_PARSE_COND) ? "condition" \
84 : ((m) == SDB_PARSE_ARITH) ? "arithmetic expression" \
85 : "UNKNOWN")
87 %}
89 %pure-parser
90 %lex-param {sdb_parser_yyscan_t scanner}
91 %parse-param {sdb_parser_yyscan_t scanner}
92 %locations
93 %error-verbose
94 %expect 0
95 %name-prefix "sdb_parser_yy"
97 %union {
98 char *str;
99 int integer;
101 sdb_data_t data;
102 sdb_time_t datetime;
104 sdb_llist_t *list;
105 sdb_ast_node_t *node;
107 struct { char *type; char *id; sdb_time_t last_update; } metric_store;
108 }
110 %start statements
112 %token SCANNER_ERROR
114 %token AND OR IS NOT MATCHING FILTER
115 %token CMP_EQUAL CMP_NEQUAL CMP_REGEX CMP_NREGEX
116 %token CMP_LT CMP_LE CMP_GE CMP_GT ALL ANY IN
117 %token CONCAT
119 %token HOST_T HOSTS_T SERVICE_T SERVICES_T METRIC_T METRICS_T
120 %token ATTRIBUTE_T ATTRIBUTES_T
121 %token NAME_T LAST_UPDATE_T AGE_T INTERVAL_T BACKEND_T VALUE_T
123 %token LAST UPDATE
125 %token START END
127 /* NULL token */
128 %token NULL_T
130 %token TRUE FALSE
132 %token FETCH LIST LOOKUP STORE TIMESERIES
134 %token <str> IDENTIFIER STRING
136 %token <data> INTEGER FLOAT
138 %token <datetime> DATE TIME
140 /* Precedence (lowest first): */
141 %left OR
142 %left AND
143 %right NOT
144 %left CMP_EQUAL CMP_NEQUAL
145 %left CMP_LT CMP_LE CMP_GE CMP_GT
146 %nonassoc CMP_REGEX CMP_NREGEX
147 %nonassoc IN
148 %left CONCAT
149 %nonassoc IS
150 %left '+' '-'
151 %left '*' '/' '%'
152 %left '[' ']'
153 %left '(' ')'
154 %left '.'
156 %type <list> statements
157 %type <node> statement
158 fetch_statement
159 list_statement
160 lookup_statement
161 store_statement
162 timeseries_statement
163 matching_clause
164 filter_clause
165 condition comparison
166 expression object_expression
168 %type <integer> object_type object_type_plural
169 %type <integer> field
170 %type <integer> cmp
172 %type <data> data
173 interval interval_elem
174 array array_elem_list
176 %type <datetime> datetime
177 start_clause end_clause
178 last_update_clause
180 %type <metric_store> metric_store_clause
182 %destructor { free($$); } <str>
183 %destructor { sdb_object_deref(SDB_OBJ($$)); } <node>
184 %destructor { sdb_data_free_datum(&$$); } <data>
186 %%
188 statements:
189 statements ';' statement
190 {
191 /* only accepted in default parse mode */
192 if (parser_mode != SDB_PARSE_DEFAULT) {
193 sdb_parser_yyerrorf(&yylloc, scanner,
194 YY_("syntax error, unexpected statement, "
195 "expecting %s"), MODE_TO_STRING(parser_mode));
196 sdb_object_deref(SDB_OBJ($3));
197 YYABORT;
198 }
200 if ($3) {
201 sdb_llist_append(pt, SDB_OBJ($3));
202 sdb_object_deref(SDB_OBJ($3));
203 }
204 }
205 |
206 statement
207 {
208 /* only accepted in default parse mode */
209 if (parser_mode != SDB_PARSE_DEFAULT) {
210 sdb_parser_yyerrorf(&yylloc, scanner,
211 YY_("syntax error, unexpected statement, "
212 "expecting %s"), MODE_TO_STRING(parser_mode));
213 sdb_object_deref(SDB_OBJ($1));
214 YYABORT;
215 }
217 if ($1) {
218 sdb_llist_append(pt, SDB_OBJ($1));
219 sdb_object_deref(SDB_OBJ($1));
220 }
221 }
222 |
223 condition
224 {
225 /* only accepted in condition parse mode */
226 if (! (parser_mode & SDB_PARSE_COND)) {
227 sdb_parser_yyerrorf(&yylloc, scanner,
228 YY_("syntax error, unexpected condition, "
229 "expecting %s"), MODE_TO_STRING(parser_mode));
230 sdb_object_deref(SDB_OBJ($1));
231 YYABORT;
232 }
234 if ($1) {
235 sdb_llist_append(pt, SDB_OBJ($1));
236 sdb_object_deref(SDB_OBJ($1));
237 }
238 }
239 |
240 expression
241 {
242 /* only accepted in expression parse mode */
243 if (! (parser_mode & SDB_PARSE_ARITH)) {
244 sdb_parser_yyerrorf(&yylloc, scanner,
245 YY_("syntax error, unexpected expression, "
246 "expecting %s"), MODE_TO_STRING(parser_mode));
247 sdb_object_deref(SDB_OBJ($1));
248 YYABORT;
249 }
251 if ($1) {
252 sdb_llist_append(pt, SDB_OBJ($1));
253 sdb_object_deref(SDB_OBJ($1));
254 }
255 }
256 ;
258 statement:
259 fetch_statement
260 |
261 list_statement
262 |
263 lookup_statement
264 |
265 store_statement
266 |
267 timeseries_statement
268 |
269 /* empty */
270 {
271 $$ = NULL;
272 }
273 ;
275 /*
276 * FETCH host <hostname> [FILTER <condition>];
277 * FETCH <type> <hostname>.<name> [FILTER <condition>];
278 *
279 * Retrieve detailed information about a single object.
280 */
281 fetch_statement:
282 FETCH object_type STRING filter_clause
283 {
284 $$ = sdb_ast_fetch_create($2, NULL, -1, NULL, $3, 1, $4);
285 CK_OOM($$);
286 }
287 |
288 FETCH object_type STRING '.' STRING filter_clause
289 {
290 $$ = sdb_ast_fetch_create($2, $3, -1, NULL, $5, 1, $6);
291 CK_OOM($$);
292 }
293 ;
295 /*
296 * LIST <type> [FILTER <condition>];
297 *
298 * Returns a list of all objects in the store.
299 */
300 list_statement:
301 LIST object_type_plural filter_clause
302 {
303 $$ = sdb_ast_list_create($2, $3);
304 CK_OOM($$);
305 }
306 ;
308 /*
309 * LOOKUP <type> [MATCHING <condition>] [FILTER <condition>];
310 *
311 * Returns detailed information about objects matching a condition.
312 */
313 lookup_statement:
314 LOOKUP object_type_plural matching_clause filter_clause
315 {
316 $$ = sdb_ast_lookup_create($2, $3, $4);
317 CK_OOM($$);
318 }
319 ;
321 matching_clause:
322 MATCHING condition { $$ = $2; }
323 |
324 /* empty */ { $$ = NULL; }
326 filter_clause:
327 FILTER condition { $$ = $2; }
328 |
329 /* empty */ { $$ = NULL; }
331 /*
332 * STORE <type> <name>|<host>.<name> [LAST UPDATE <datetime>];
333 * STORE METRIC <host>.<name> STORE <type> <id> [LAST UPDATE <datetime>];
334 * STORE <type> ATTRIBUTE <parent>.<key> <datum> [LAST UPDATE <datetime>];
335 *
336 * Store or update an object in the database.
337 */
338 store_statement:
339 STORE HOST_T STRING last_update_clause
340 {
341 $$ = sdb_ast_store_create(SDB_HOST, NULL, 0, NULL,
342 $3, $4, NULL, NULL, 0, SDB_DATA_NULL);
343 CK_OOM($$);
344 }
345 |
346 STORE SERVICE_T STRING '.' STRING last_update_clause
347 {
348 $$ = sdb_ast_store_create(SDB_SERVICE, $3, 0, NULL,
349 $5, $6, NULL, NULL, 0, SDB_DATA_NULL);
350 CK_OOM($$);
351 }
352 |
353 STORE METRIC_T STRING '.' STRING metric_store_clause last_update_clause
354 {
355 $$ = sdb_ast_store_create(SDB_METRIC, $3, 0, NULL,
356 $5, $7, $6.type, $6.id, $6.last_update, SDB_DATA_NULL);
357 CK_OOM($$);
358 }
359 |
360 STORE HOST_T ATTRIBUTE_T STRING '.' STRING data last_update_clause
361 {
362 $$ = sdb_ast_store_create(SDB_ATTRIBUTE, $4, 0, NULL,
363 $6, $8, NULL, NULL, 0, $7);
364 CK_OOM($$);
365 }
366 |
367 STORE SERVICE_T ATTRIBUTE_T STRING '.' STRING '.' STRING data last_update_clause
368 {
369 $$ = sdb_ast_store_create(SDB_ATTRIBUTE, $4, SDB_SERVICE, $6,
370 $8, $10, NULL, NULL, 0, $9);
371 CK_OOM($$);
372 }
373 |
374 STORE METRIC_T ATTRIBUTE_T STRING '.' STRING '.' STRING data last_update_clause
375 {
376 $$ = sdb_ast_store_create(SDB_ATTRIBUTE, $4, SDB_METRIC, $6,
377 $8, $10, NULL, NULL, 0, $9);
378 CK_OOM($$);
379 }
380 ;
382 last_update_clause:
383 LAST UPDATE datetime { $$ = $3; }
384 |
385 /* empty */ { $$ = sdb_gettime(); }
387 metric_store_clause:
388 STORE STRING STRING datetime { $$.type = $2; $$.id = $3; $$.last_update = $4; }
389 |
390 STORE STRING STRING { $$.type = $2; $$.id = $3; $$.last_update = 0; }
391 |
392 /* empty */ { $$.type = $$.id = NULL; $$.last_update = 0; }
394 /*
395 * TIMESERIES <host>.<metric> [START <datetime>] [END <datetime>];
396 *
397 * Returns a time-series for the specified host's metric.
398 */
399 timeseries_statement:
400 TIMESERIES STRING '.' STRING start_clause end_clause
401 {
402 $$ = sdb_ast_timeseries_create($2, $4, $5, $6);
403 CK_OOM($$);
404 }
405 ;
407 start_clause:
408 START datetime { $$ = $2; }
409 |
410 /* empty */ { $$ = sdb_gettime() - SDB_INTERVAL_HOUR; }
412 end_clause:
413 END datetime { $$ = $2; }
414 |
415 /* empty */ { $$ = sdb_gettime(); }
417 /*
418 * Basic expressions.
419 */
421 condition:
422 '(' condition ')'
423 {
424 $$ = $2;
425 }
426 |
427 condition AND condition
428 {
429 $$ = sdb_ast_op_create(SDB_AST_AND, $1, $3);
430 CK_OOM($$);
431 }
432 |
433 condition OR condition
434 {
435 $$ = sdb_ast_op_create(SDB_AST_OR, $1, $3);
436 CK_OOM($$);
437 }
438 |
439 NOT condition
440 {
441 $$ = sdb_ast_op_create(SDB_AST_NOT, NULL, $2);
442 CK_OOM($$);
443 }
444 |
445 comparison
446 {
447 $$ = $1;
448 }
449 ;
451 comparison:
452 expression cmp expression
453 {
454 $$ = sdb_ast_op_create($2, $1, $3);
455 CK_OOM($$);
456 }
457 |
458 ANY expression cmp expression
459 {
460 sdb_ast_node_t *n = sdb_ast_op_create($3, NULL, $4);
461 CK_OOM(n);
462 $$ = sdb_ast_iter_create(SDB_AST_ANY, $2, n);
463 CK_OOM($$);
464 }
465 |
466 ALL expression cmp expression
467 {
468 sdb_ast_node_t *n = sdb_ast_op_create($3, NULL, $4);
469 CK_OOM(n);
470 $$ = sdb_ast_iter_create(SDB_AST_ALL, $2, n);
471 CK_OOM($$);
472 }
473 |
474 expression IS NULL_T
475 {
476 $$ = sdb_ast_op_create(SDB_AST_ISNULL, NULL, $1);
477 CK_OOM($$);
478 }
479 |
480 expression IS NOT NULL_T
481 {
482 $$ = sdb_ast_op_create(SDB_AST_ISNULL, NULL, $1);
483 CK_OOM($$);
484 $$ = sdb_ast_op_create(SDB_AST_NOT, NULL, $$);
485 CK_OOM($$);
486 }
487 |
488 expression IS TRUE
489 {
490 $$ = sdb_ast_op_create(SDB_AST_ISTRUE, NULL, $1);
491 CK_OOM($$);
492 }
493 |
494 expression IS NOT TRUE
495 {
496 $$ = sdb_ast_op_create(SDB_AST_ISTRUE, NULL, $1);
497 CK_OOM($$);
498 $$ = sdb_ast_op_create(SDB_AST_NOT, NULL, $$);
499 CK_OOM($$);
500 }
501 |
502 expression IS FALSE
503 {
504 $$ = sdb_ast_op_create(SDB_AST_ISFALSE, NULL, $1);
505 CK_OOM($$);
506 }
507 |
508 expression IS NOT FALSE
509 {
510 $$ = sdb_ast_op_create(SDB_AST_ISFALSE, NULL, $1);
511 CK_OOM($$);
512 $$ = sdb_ast_op_create(SDB_AST_NOT, NULL, $$);
513 CK_OOM($$);
514 }
515 |
516 expression IN expression
517 {
518 $$ = sdb_ast_op_create(SDB_AST_IN, $1, $3);
519 CK_OOM($$);
520 }
521 |
522 expression NOT IN expression
523 {
524 $$ = sdb_ast_op_create(SDB_AST_IN, $1, $4);
525 CK_OOM($$);
526 $$ = sdb_ast_op_create(SDB_AST_NOT, NULL, $$);
527 CK_OOM($$);
528 }
529 ;
531 expression:
532 '(' expression ')'
533 {
534 $$ = $2;
535 }
536 |
537 expression '+' expression
538 {
539 $$ = sdb_ast_op_create(SDB_AST_ADD, $1, $3);
540 CK_OOM($$);
541 }
542 |
543 expression '-' expression
544 {
545 $$ = sdb_ast_op_create(SDB_AST_SUB, $1, $3);
546 CK_OOM($$);
547 }
548 |
549 expression '*' expression
550 {
551 $$ = sdb_ast_op_create(SDB_AST_MUL, $1, $3);
552 CK_OOM($$);
553 }
554 |
555 expression '/' expression
556 {
557 $$ = sdb_ast_op_create(SDB_AST_DIV, $1, $3);
558 CK_OOM($$);
559 }
560 |
561 expression '%' expression
562 {
563 $$ = sdb_ast_op_create(SDB_AST_MOD, $1, $3);
564 CK_OOM($$);
565 }
566 |
567 expression CONCAT expression
568 {
569 $$ = sdb_ast_op_create(SDB_AST_CONCAT, $1, $3);
570 CK_OOM($$);
571 }
572 |
573 object_expression
574 {
575 $$ = $1;
576 }
577 |
578 data
579 {
580 $$ = sdb_ast_const_create($1);
581 CK_OOM($$);
582 }
583 ;
585 object_expression:
586 object_type '.' object_expression
587 {
588 $$ = sdb_ast_typed_create($1, $3);
589 CK_OOM($$);
590 }
591 |
592 ATTRIBUTE_T '.' object_expression
593 {
594 $$ = sdb_ast_typed_create(SDB_ATTRIBUTE, $3);
595 CK_OOM($$);
596 }
597 |
598 field
599 {
600 $$ = sdb_ast_value_create($1, NULL);
601 CK_OOM($$);
602 }
603 |
604 ATTRIBUTE_T '[' STRING ']'
605 {
606 $$ = sdb_ast_value_create(SDB_ATTRIBUTE, $3);
607 CK_OOM($$);
608 }
609 ;
611 object_type:
612 HOST_T { $$ = SDB_HOST; }
613 |
614 SERVICE_T { $$ = SDB_SERVICE; }
615 |
616 METRIC_T { $$ = SDB_METRIC; }
617 ;
619 object_type_plural:
620 HOSTS_T { $$ = SDB_HOST; }
621 |
622 SERVICES_T { $$ = SDB_SERVICE; }
623 |
624 METRICS_T { $$ = SDB_METRIC; }
625 ;
627 field:
628 NAME_T { $$ = SDB_FIELD_NAME; }
629 |
630 LAST_UPDATE_T { $$ = SDB_FIELD_LAST_UPDATE; }
631 |
632 AGE_T { $$ = SDB_FIELD_AGE; }
633 |
634 INTERVAL_T { $$ = SDB_FIELD_INTERVAL; }
635 |
636 BACKEND_T { $$ = SDB_FIELD_BACKEND; }
637 |
638 VALUE_T { $$ = SDB_FIELD_VALUE; }
639 |
640 TIMESERIES { $$ = SDB_FIELD_TIMESERIES; }
641 ;
643 cmp:
644 CMP_EQUAL { $$ = SDB_AST_EQ; }
645 |
646 CMP_NEQUAL { $$ = SDB_AST_NE; }
647 |
648 CMP_REGEX { $$ = SDB_AST_REGEX; }
649 |
650 CMP_NREGEX { $$ = SDB_AST_NREGEX; }
651 |
652 CMP_LT { $$ = SDB_AST_LT; }
653 |
654 CMP_LE { $$ = SDB_AST_LE; }
655 |
656 CMP_GE { $$ = SDB_AST_GE; }
657 |
658 CMP_GT { $$ = SDB_AST_GT; }
659 ;
661 data:
662 STRING { $$.type = SDB_TYPE_STRING; $$.data.string = $1; }
663 |
664 INTEGER { $$ = $1; }
665 |
666 FLOAT { $$ = $1; }
667 |
668 datetime { $$.type = SDB_TYPE_DATETIME; $$.data.datetime = $1; }
669 |
670 interval { $$ = $1; }
671 |
672 array { $$ = $1; }
673 ;
675 datetime:
676 DATE TIME { $$ = $1 + $2; }
677 |
678 DATE { $$ = $1; }
679 |
680 TIME { $$ = $1; }
681 ;
683 interval:
684 interval interval_elem
685 {
686 $$.data.datetime = $1.data.datetime + $2.data.datetime;
687 }
688 |
689 interval_elem { $$ = $1; }
690 ;
692 interval_elem:
693 INTEGER IDENTIFIER
694 {
695 sdb_time_t unit = sdb_strpunit($2);
696 if (! unit) {
697 sdb_parser_yyerrorf(&yylloc, scanner,
698 YY_("syntax error, invalid time unit %s"), $2);
699 free($2); $2 = NULL;
700 YYABORT;
701 }
702 free($2); $2 = NULL;
704 if ($1.data.integer < 0) {
705 sdb_parser_yyerror(&yylloc, scanner,
706 YY_("syntax error, negative intervals not supported"));
707 YYABORT;
708 }
710 $$.type = SDB_TYPE_DATETIME;
711 $$.data.datetime = (sdb_time_t)$1.data.integer * unit;
712 }
713 ;
715 array:
716 '[' array_elem_list ']'
717 {
718 $$ = $2;
719 }
720 ;
722 array_elem_list:
723 array_elem_list ',' data
724 {
725 size_t elem_size = sdb_data_sizeof($3.type);
727 if (($3.type & SDB_TYPE_ARRAY) || (($1.type & 0xff) != $3.type)) {
728 sdb_parser_yyerrorf(&yylloc, scanner, YY_("syntax error, "
729 "cannot use element of type %s in array of type %s"),
730 SDB_TYPE_TO_STRING($3.type),
731 SDB_TYPE_TO_STRING($1.type));
732 sdb_data_free_datum(&$1);
733 sdb_data_free_datum(&$3);
734 YYABORT;
735 }
737 $$ = $1;
738 $$.data.array.values = realloc($$.data.array.values,
739 ($$.data.array.length + 1) * elem_size);
740 CK_OOM($$.data.array.values);
742 memcpy((char *)$$.data.array.values + $$.data.array.length * elem_size,
743 &$3.data, elem_size);
744 ++$$.data.array.length;
745 }
746 |
747 data
748 {
749 size_t elem_size = sdb_data_sizeof($1.type);
751 if ($1.type & SDB_TYPE_ARRAY) {
752 sdb_parser_yyerrorf(&yylloc, scanner, YY_("syntax error, "
753 "cannot construct array of type %s"),
754 SDB_TYPE_TO_STRING($1.type));
755 sdb_data_free_datum(&$1);
756 YYABORT;
757 }
759 $$ = $1;
760 $$.type |= SDB_TYPE_ARRAY;
761 $$.data.array.values = malloc(elem_size);
762 CK_OOM($$.data.array.values);
764 memcpy($$.data.array.values, &$1.data, elem_size);
765 $$.data.array.length = 1;
766 }
767 ;
769 %%
771 void
772 sdb_parser_yyerror(YYLTYPE *lval, sdb_parser_yyscan_t scanner, const char *msg)
773 {
774 sdb_log(SDB_LOG_ERR, "parser: parse error: %s", msg);
775 sdb_strbuf_sprintf(errbuf, "%s", msg);
776 } /* sdb_parser_yyerror */
778 void
779 sdb_parser_yyerrorf(YYLTYPE *lval, sdb_parser_yyscan_t scanner, const char *fmt, ...)
780 {
781 va_list ap, aq;
782 va_start(ap, fmt);
783 va_copy(aq, ap);
784 sdb_vlog(SDB_LOG_ERR, fmt, ap);
785 sdb_strbuf_vsprintf(errbuf, fmt, aq);
786 va_end(ap);
787 } /* sdb_parser_yyerrorf */
789 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */