src/parser/grammar.y

   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  */
  27
  28 /*
  29  * Grammar for the SysDB Query Language (SysQL).
  30  */
  31
  32 %{
  33
  34 #include "core/store.h"
  35 #include "core/time.h"
  36
  37 #include "parser/ast.h"
  38 #include "parser/parser.h"
  39 #include "parser/grammar.h"
  40
  41 #include "utils/error.h"
  42 #include "utils/llist.h"
  43
  44 #include <assert.h>
  45
  46 #include <stdio.h>
  47 #include <string.h>
  48
  49 /*
  50  * public API
  51  */
  52
  53 int
  54 sdb_parser_yylex(YYSTYPE *yylval, YYLTYPE *yylloc, sdb_parser_yyscan_t yyscanner);
  55
  56 sdb_parser_yyextra_t *
  57 sdb_parser_yyget_extra(sdb_parser_yyscan_t scanner);
  58
  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, ...);
  63
  64 /* quick access to the current parse tree */
  65 #define pt sdb_parser_yyget_extra(scanner)->parsetree
  66
  67 /* quick access to the parser mode */
  68 #define parser_mode sdb_parser_yyget_extra(scanner)->mode
  69
  70 /* quick access to the parser's error buffer */
  71 #define errbuf sdb_parser_yyget_extra(scanner)->errbuf
  72
  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)
  80
  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")
  86
  87 %}
  88
  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"
  96
  97 %union {
  98         char *str;
  99         int integer;
 100
 101         sdb_data_t data;
 102         sdb_time_t datetime;
 103
 104         sdb_llist_t    *list;
 105         sdb_ast_node_t *node;
 106
 107         struct { char *type; char *id; sdb_time_t last_update; } metric_store;
 108 }
 109
 110 %start statements
 111
 112 %token SCANNER_ERROR
 113
 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
 118
 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
 122
 123 %token LAST UPDATE
 124
 125 %token START END
 126
 127 /* NULL token */
 128 %token NULL_T
 129
 130 %token TRUE FALSE
 131
 132 %token FETCH LIST LOOKUP STORE TIMESERIES
 133
 134 %token <str> IDENTIFIER STRING
 135
 136 %token <data> INTEGER FLOAT
 137
 138 %token <datetime> DATE TIME
 139
 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 '.'
 155
 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
 167
 168 %type <integer> object_type object_type_plural
 169 %type <integer> field
 170 %type <integer> cmp
 171
 172 %type <data> data
 173         interval interval_elem
 174         array array_elem_list
 175
 176 %type <datetime> datetime
 177         start_clause end_clause
 178         last_update_clause
 179
 180 %type <metric_store> metric_store_clause
 181
 182 %destructor { free($$); } <str>
 183 %destructor { sdb_object_deref(SDB_OBJ($$)); } <node>
 184 %destructor { sdb_data_free_datum(&$$); } <data>
 185
 186 %%
 187
 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                         }
 199
 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                         }
 216
 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                         }
 233
 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                         }
 250
 251                         if ($1) {
 252                                 sdb_llist_append(pt, SDB_OBJ($1));
 253                                 sdb_object_deref(SDB_OBJ($1));
 254                         }
 255                 }
 256         ;
 257
 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         ;
 274
 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         ;
 294
 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         ;
 307
 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         ;
 320
 321 matching_clause:
 322         MATCHING condition { $$ = $2; }
 323         |
 324         /* empty */ { $$ = NULL; }
 325
 326 filter_clause:
 327         FILTER condition { $$ = $2; }
 328         |
 329         /* empty */ { $$ = NULL; }
 330
 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         ;
 381
 382 last_update_clause:
 383         LAST UPDATE datetime { $$ = $3; }
 384         |
 385         /* empty */ { $$ = sdb_gettime(); }
 386
 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; }
 393
 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         ;
 406
 407 start_clause:
 408         START datetime { $$ = $2; }
 409         |
 410         /* empty */ { $$ = sdb_gettime() - SDB_INTERVAL_HOUR; }
 411
 412 end_clause:
 413         END datetime { $$ = $2; }
 414         |
 415         /* empty */ { $$ = sdb_gettime(); }
 416
 417 /*
 418  * Basic expressions.
 419  */
 420
 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         ;
 450
 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         ;
 530
 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         ;
 584
 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         ;
 610
 611 object_type:
 612         HOST_T { $$ = SDB_HOST; }
 613         |
 614         SERVICE_T { $$ = SDB_SERVICE; }
 615         |
 616         METRIC_T { $$ = SDB_METRIC; }
 617         ;
 618
 619 object_type_plural:
 620         HOSTS_T { $$ = SDB_HOST; }
 621         |
 622         SERVICES_T { $$ = SDB_SERVICE; }
 623         |
 624         METRICS_T { $$ = SDB_METRIC; }
 625         ;
 626
 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         ;
 642
 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         ;
 660
 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         ;
 674
 675 datetime:
 676         DATE TIME { $$ = $1 + $2; }
 677         |
 678         DATE { $$ = $1; }
 679         |
 680         TIME { $$ = $1; }
 681         ;
 682
 683 interval:
 684         interval interval_elem
 685                 {
 686                         $$.data.datetime = $1.data.datetime + $2.data.datetime;
 687                 }
 688         |
 689         interval_elem { $$ = $1; }
 690         ;
 691
 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;
 703
 704                         if ($1.data.integer < 0) {
 705                                 sdb_parser_yyerror(&yylloc, scanner,
 706                                                 YY_("syntax error, negative intervals not supported"));
 707                                 YYABORT;
 708                         }
 709
 710                         $$.type = SDB_TYPE_DATETIME;
 711                         $$.data.datetime = (sdb_time_t)$1.data.integer * unit;
 712                 }
 713         ;
 714
 715 array:
 716         '[' array_elem_list ']'
 717                 {
 718                         $$ = $2;
 719                 }
 720         ;
 721
 722 array_elem_list:
 723         array_elem_list ',' data
 724                 {
 725                         size_t elem_size = sdb_data_sizeof($3.type);
 726
 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                         }
 736
 737                         $$ = $1;
 738                         $$.data.array.values = realloc($$.data.array.values,
 739                                         ($$.data.array.length + 1) * elem_size);
 740                         CK_OOM($$.data.array.values);
 741
 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);
 750
 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                         }
 758
 759                         $$ = $1;
 760                         $$.type |= SDB_TYPE_ARRAY;
 761                         $$.data.array.values = malloc(elem_size);
 762                         CK_OOM($$.data.array.values);
 763
 764                         memcpy($$.data.array.values, &$1.data, elem_size);
 765                         $$.data.array.length = 1;
 766                 }
 767         ;
 768
 769 %%
 770
 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 */
 777
 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 */
 788
 789 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */
 790