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; } 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, 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, 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, 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, $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, $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, $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 { $$.type = $2; $$.id = $3; }
 389         |
 390         /* empty */ { $$.type = $$.id = NULL; }
 391
 392 /*
 393  * TIMESERIES <host>.<metric> [START <datetime>] [END <datetime>];
 394  *
 395  * Returns a time-series for the specified host's metric.
 396  */
 397 timeseries_statement:
 398         TIMESERIES STRING '.' STRING start_clause end_clause
 399                 {
 400                         $$ = sdb_ast_timeseries_create($2, $4, $5, $6);
 401                         CK_OOM($$);
 402                 }
 403         ;
 404
 405 start_clause:
 406         START datetime { $$ = $2; }
 407         |
 408         /* empty */ { $$ = sdb_gettime() - SDB_INTERVAL_HOUR; }
 409
 410 end_clause:
 411         END datetime { $$ = $2; }
 412         |
 413         /* empty */ { $$ = sdb_gettime(); }
 414
 415 /*
 416  * Basic expressions.
 417  */
 418
 419 condition:
 420         '(' condition ')'
 421                 {
 422                         $$ = $2;
 423                 }
 424         |
 425         condition AND condition
 426                 {
 427                         $$ = sdb_ast_op_create(SDB_AST_AND, $1, $3);
 428                         CK_OOM($$);
 429                 }
 430         |
 431         condition OR condition
 432                 {
 433                         $$ = sdb_ast_op_create(SDB_AST_OR, $1, $3);
 434                         CK_OOM($$);
 435                 }
 436         |
 437         NOT condition
 438                 {
 439                         $$ = sdb_ast_op_create(SDB_AST_NOT, NULL, $2);
 440                         CK_OOM($$);
 441                 }
 442         |
 443         comparison
 444                 {
 445                         $$ = $1;
 446                 }
 447         ;
 448
 449 comparison:
 450         expression cmp expression
 451                 {
 452                         $$ = sdb_ast_op_create($2, $1, $3);
 453                         CK_OOM($$);
 454                 }
 455         |
 456         ANY expression cmp expression
 457                 {
 458                         sdb_ast_node_t *n = sdb_ast_op_create($3, NULL, $4);
 459                         CK_OOM(n);
 460                         $$ = sdb_ast_iter_create(SDB_AST_ANY, $2, n);
 461                         CK_OOM($$);
 462                 }
 463         |
 464         ALL expression cmp expression
 465                 {
 466                         sdb_ast_node_t *n = sdb_ast_op_create($3, NULL, $4);
 467                         CK_OOM(n);
 468                         $$ = sdb_ast_iter_create(SDB_AST_ALL, $2, n);
 469                         CK_OOM($$);
 470                 }
 471         |
 472         expression IS NULL_T
 473                 {
 474                         $$ = sdb_ast_op_create(SDB_AST_ISNULL, NULL, $1);
 475                         CK_OOM($$);
 476                 }
 477         |
 478         expression IS NOT NULL_T
 479                 {
 480                         $$ = sdb_ast_op_create(SDB_AST_ISNULL, NULL, $1);
 481                         CK_OOM($$);
 482                         $$ = sdb_ast_op_create(SDB_AST_NOT, NULL, $$);
 483                         CK_OOM($$);
 484                 }
 485         |
 486         expression IS TRUE
 487                 {
 488                         $$ = sdb_ast_op_create(SDB_AST_ISTRUE, NULL, $1);
 489                         CK_OOM($$);
 490                 }
 491         |
 492         expression IS NOT TRUE
 493                 {
 494                         $$ = sdb_ast_op_create(SDB_AST_ISTRUE, NULL, $1);
 495                         CK_OOM($$);
 496                         $$ = sdb_ast_op_create(SDB_AST_NOT, NULL, $$);
 497                         CK_OOM($$);
 498                 }
 499         |
 500         expression IS FALSE
 501                 {
 502                         $$ = sdb_ast_op_create(SDB_AST_ISFALSE, NULL, $1);
 503                         CK_OOM($$);
 504                 }
 505         |
 506         expression IS NOT FALSE
 507                 {
 508                         $$ = sdb_ast_op_create(SDB_AST_ISFALSE, NULL, $1);
 509                         CK_OOM($$);
 510                         $$ = sdb_ast_op_create(SDB_AST_NOT, NULL, $$);
 511                         CK_OOM($$);
 512                 }
 513         |
 514         expression IN expression
 515                 {
 516                         $$ = sdb_ast_op_create(SDB_AST_IN, $1, $3);
 517                         CK_OOM($$);
 518                 }
 519         |
 520         expression NOT IN expression
 521                 {
 522                         $$ = sdb_ast_op_create(SDB_AST_IN, $1, $4);
 523                         CK_OOM($$);
 524                         $$ = sdb_ast_op_create(SDB_AST_NOT, NULL, $$);
 525                         CK_OOM($$);
 526                 }
 527         ;
 528
 529 expression:
 530         '(' expression ')'
 531                 {
 532                         $$ = $2;
 533                 }
 534         |
 535         expression '+' expression
 536                 {
 537                         $$ = sdb_ast_op_create(SDB_AST_ADD, $1, $3);
 538                         CK_OOM($$);
 539                 }
 540         |
 541         expression '-' expression
 542                 {
 543                         $$ = sdb_ast_op_create(SDB_AST_SUB, $1, $3);
 544                         CK_OOM($$);
 545                 }
 546         |
 547         expression '*' expression
 548                 {
 549                         $$ = sdb_ast_op_create(SDB_AST_MUL, $1, $3);
 550                         CK_OOM($$);
 551                 }
 552         |
 553         expression '/' expression
 554                 {
 555                         $$ = sdb_ast_op_create(SDB_AST_DIV, $1, $3);
 556                         CK_OOM($$);
 557                 }
 558         |
 559         expression '%' expression
 560                 {
 561                         $$ = sdb_ast_op_create(SDB_AST_MOD, $1, $3);
 562                         CK_OOM($$);
 563                 }
 564         |
 565         expression CONCAT expression
 566                 {
 567                         $$ = sdb_ast_op_create(SDB_AST_CONCAT, $1, $3);
 568                         CK_OOM($$);
 569                 }
 570         |
 571         object_expression
 572                 {
 573                         $$ = $1;
 574                 }
 575         |
 576         data
 577                 {
 578                         $$ = sdb_ast_const_create($1);
 579                         CK_OOM($$);
 580                 }
 581         ;
 582
 583 object_expression:
 584         object_type '.' object_expression
 585                 {
 586                         $$ = sdb_ast_typed_create($1, $3);
 587                         CK_OOM($$);
 588                 }
 589         |
 590         ATTRIBUTE_T '.' object_expression
 591                 {
 592                         $$ = sdb_ast_typed_create(SDB_ATTRIBUTE, $3);
 593                         CK_OOM($$);
 594                 }
 595         |
 596         field
 597                 {
 598                         $$ = sdb_ast_value_create($1, NULL);
 599                         CK_OOM($$);
 600                 }
 601         |
 602         ATTRIBUTE_T '[' STRING ']'
 603                 {
 604                         $$ = sdb_ast_value_create(SDB_ATTRIBUTE, $3);
 605                         CK_OOM($$);
 606                 }
 607         ;
 608
 609 object_type:
 610         HOST_T { $$ = SDB_HOST; }
 611         |
 612         SERVICE_T { $$ = SDB_SERVICE; }
 613         |
 614         METRIC_T { $$ = SDB_METRIC; }
 615         ;
 616
 617 object_type_plural:
 618         HOSTS_T { $$ = SDB_HOST; }
 619         |
 620         SERVICES_T { $$ = SDB_SERVICE; }
 621         |
 622         METRICS_T { $$ = SDB_METRIC; }
 623         ;
 624
 625 field:
 626         NAME_T { $$ = SDB_FIELD_NAME; }
 627         |
 628         LAST_UPDATE_T { $$ = SDB_FIELD_LAST_UPDATE; }
 629         |
 630         AGE_T { $$ = SDB_FIELD_AGE; }
 631         |
 632         INTERVAL_T { $$ = SDB_FIELD_INTERVAL; }
 633         |
 634         BACKEND_T { $$ = SDB_FIELD_BACKEND; }
 635         |
 636         VALUE_T { $$ = SDB_FIELD_VALUE; }
 637         |
 638         TIMESERIES { $$ = SDB_FIELD_TIMESERIES; }
 639         ;
 640
 641 cmp:
 642         CMP_EQUAL { $$ = SDB_AST_EQ; }
 643         |
 644         CMP_NEQUAL { $$ = SDB_AST_NE; }
 645         |
 646         CMP_REGEX { $$ = SDB_AST_REGEX; }
 647         |
 648         CMP_NREGEX { $$ = SDB_AST_NREGEX; }
 649         |
 650         CMP_LT { $$ = SDB_AST_LT; }
 651         |
 652         CMP_LE { $$ = SDB_AST_LE; }
 653         |
 654         CMP_GE { $$ = SDB_AST_GE; }
 655         |
 656         CMP_GT { $$ = SDB_AST_GT; }
 657         ;
 658
 659 data:
 660         STRING { $$.type = SDB_TYPE_STRING; $$.data.string = $1; }
 661         |
 662         INTEGER { $$ = $1; }
 663         |
 664         FLOAT { $$ = $1; }
 665         |
 666         datetime { $$.type = SDB_TYPE_DATETIME; $$.data.datetime = $1; }
 667         |
 668         interval { $$ = $1; }
 669         |
 670         array { $$ = $1; }
 671         ;
 672
 673 datetime:
 674         DATE TIME { $$ = $1 + $2; }
 675         |
 676         DATE { $$ = $1; }
 677         |
 678         TIME { $$ = $1; }
 679         ;
 680
 681 interval:
 682         interval interval_elem
 683                 {
 684                         $$.data.datetime = $1.data.datetime + $2.data.datetime;
 685                 }
 686         |
 687         interval_elem { $$ = $1; }
 688         ;
 689
 690 interval_elem:
 691         INTEGER IDENTIFIER
 692                 {
 693                         sdb_time_t unit = sdb_strpunit($2);
 694                         if (! unit) {
 695                                 sdb_parser_yyerrorf(&yylloc, scanner,
 696                                                 YY_("syntax error, invalid time unit %s"), $2);
 697                                 free($2); $2 = NULL;
 698                                 YYABORT;
 699                         }
 700                         free($2); $2 = NULL;
 701
 702                         if ($1.data.integer < 0) {
 703                                 sdb_parser_yyerror(&yylloc, scanner,
 704                                                 YY_("syntax error, negative intervals not supported"));
 705                                 YYABORT;
 706                         }
 707
 708                         $$.type = SDB_TYPE_DATETIME;
 709                         $$.data.datetime = (sdb_time_t)$1.data.integer * unit;
 710                 }
 711         ;
 712
 713 array:
 714         '[' array_elem_list ']'
 715                 {
 716                         $$ = $2;
 717                 }
 718         ;
 719
 720 array_elem_list:
 721         array_elem_list ',' data
 722                 {
 723                         size_t elem_size = sdb_data_sizeof($3.type);
 724
 725                         if (($3.type & SDB_TYPE_ARRAY) || (($1.type & 0xff) != $3.type)) {
 726                                 sdb_parser_yyerrorf(&yylloc, scanner, YY_("syntax error, "
 727                                                 "cannot use element of type %s in array of type %s"),
 728                                                 SDB_TYPE_TO_STRING($3.type),
 729                                                 SDB_TYPE_TO_STRING($1.type));
 730                                 sdb_data_free_datum(&$1);
 731                                 sdb_data_free_datum(&$3);
 732                                 YYABORT;
 733                         }
 734
 735                         $$ = $1;
 736                         $$.data.array.values = realloc($$.data.array.values,
 737                                         ($$.data.array.length + 1) * elem_size);
 738                         CK_OOM($$.data.array.values);
 739
 740                         memcpy((char *)$$.data.array.values + $$.data.array.length * elem_size,
 741                                         &$3.data, elem_size);
 742                         ++$$.data.array.length;
 743                 }
 744         |
 745         data
 746                 {
 747                         size_t elem_size = sdb_data_sizeof($1.type);
 748
 749                         if ($1.type & SDB_TYPE_ARRAY) {
 750                                 sdb_parser_yyerrorf(&yylloc, scanner, YY_("syntax error, "
 751                                                 "cannot construct array of type %s"),
 752                                                 SDB_TYPE_TO_STRING($1.type));
 753                                 sdb_data_free_datum(&$1);
 754                                 YYABORT;
 755                         }
 756
 757                         $$ = $1;
 758                         $$.type |= SDB_TYPE_ARRAY;
 759                         $$.data.array.values = malloc(elem_size);
 760                         CK_OOM($$.data.array.values);
 761
 762                         memcpy($$.data.array.values, &$1.data, elem_size);
 763                         $$.data.array.length = 1;
 764                 }
 765         ;
 766
 767 %%
 768
 769 void
 770 sdb_parser_yyerror(YYLTYPE *lval, sdb_parser_yyscan_t scanner, const char *msg)
 771 {
 772         sdb_log(SDB_LOG_ERR, "parser: parse error: %s", msg);
 773         sdb_strbuf_sprintf(errbuf, "%s", msg);
 774 } /* sdb_parser_yyerror */
 775
 776 void
 777 sdb_parser_yyerrorf(YYLTYPE *lval, sdb_parser_yyscan_t scanner, const char *fmt, ...)
 778 {
 779         va_list ap, aq;
 780         va_start(ap, fmt);
 781         va_copy(aq, ap);
 782         sdb_vlog(SDB_LOG_ERR, fmt, ap);
 783         sdb_strbuf_vsprintf(errbuf, fmt, aq);
 784         va_end(ap);
 785 } /* sdb_parser_yyerrorf */
 786
 787 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */
 788