formats/ctf/metadata/ctf-parser.y

   1 %{
   2 /*
   3  * ctf-parser.y
   4  *
   5  * Common Trace Format Metadata Grammar.
   6  *
   7  * Copyright 2010 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   8  *
   9  * Permission is hereby granted, free of charge, to any person obtaining a copy
  10  * of this software and associated documentation files (the "Software"), to deal
  11  * in the Software without restriction, including without limitation the rights
  12  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  13  * copies of the Software, and to permit persons to whom the Software is
  14  * furnished to do so, subject to the following conditions:
  15  *
  16  * The above copyright notice and this permission notice shall be included in
  17  * all copies or substantial portions of the Software.
  18  */
  19
  20 #include <stdio.h>
  21 #include <unistd.h>
  22 #include <string.h>
  23 #include <stdlib.h>
  24 #include <assert.h>
  25 #include <helpers/list.h>
  26 #include <glib.h>
  27 #include "ctf-scanner.h"
  28 #include "ctf-parser.h"
  29 #include "ctf-ast.h"
  30
  31 #define printf_dbg(fmt, args...)        fprintf(stderr, "%s: " fmt, __func__, args)
  32 #define printf_dbg_noarg(fmt)   fprintf(stderr, "%s: " fmt, __func__)
  33
  34 int yyparse(struct ctf_scanner *scanner);
  35 int yylex(union YYSTYPE *yyval, struct ctf_scanner *scanner);
  36 int yylex_init_extra(struct ctf_scanner *scanner, yyscan_t * ptr_yy_globals);
  37 int yylex_destroy(yyscan_t yyscanner) ;
  38 void yyset_in(FILE * in_str, yyscan_t scanner);
  39
  40 int yydebug;
  41
  42 struct gc_string {
  43         struct cds_list_head gc;
  44         char s[];
  45 };
  46
  47 char *strredup(char **dest, const char *src)
  48 {
  49         size_t len = strlen(src) + 1;
  50
  51         *dest = realloc(*dest, len);
  52         if (!*dest)
  53                 return NULL;
  54         strcpy(*dest, src);
  55         return *dest;
  56 }
  57
  58 static struct gc_string *gc_string_alloc(struct ctf_scanner *scanner, size_t len)
  59 {
  60         struct gc_string *gstr;
  61
  62         gstr = malloc(sizeof(*gstr) + len);
  63         cds_list_add(&gstr->gc, &scanner->allocated_strings);
  64         return gstr;
  65 }
  66
  67 void setstring(struct ctf_scanner *scanner, YYSTYPE *lvalp, const char *src)
  68 {
  69         lvalp->gs = gc_string_alloc(scanner, strlen(src) + 1);
  70         strcpy(lvalp->gs->s, src);
  71 }
  72
  73 static void init_scope(struct ctf_scanner_scope *scope,
  74                        struct ctf_scanner_scope *parent)
  75 {
  76         scope->parent = parent;
  77         scope->types = g_hash_table_new_full(g_str_hash, g_str_equal,
  78                                              (GDestroyNotify) free, NULL);
  79 }
  80
  81 static void finalize_scope(struct ctf_scanner_scope *scope)
  82 {
  83         g_hash_table_destroy(scope->types);
  84 }
  85
  86 static void push_scope(struct ctf_scanner *scanner)
  87 {
  88         struct ctf_scanner_scope *ns;
  89
  90         printf_dbg_noarg("push scope\n");
  91         ns = malloc(sizeof(struct ctf_scanner_scope));
  92         init_scope(ns, scanner->cs);
  93         scanner->cs = ns;
  94 }
  95
  96 static void pop_scope(struct ctf_scanner *scanner)
  97 {
  98         struct ctf_scanner_scope *os;
  99
 100         printf_dbg_noarg("pop scope\n");
 101         os = scanner->cs;
 102         scanner->cs = os->parent;
 103         finalize_scope(os);
 104         free(os);
 105 }
 106
 107 static int lookup_type(struct ctf_scanner_scope *s, const char *id)
 108 {
 109         int ret;
 110
 111         ret = (int) g_hash_table_lookup(s->types, id);
 112         printf_dbg("lookup %p %s %d\n", s, id, ret);
 113         return ret;
 114 }
 115
 116 int is_type(struct ctf_scanner *scanner, const char *id)
 117 {
 118         struct ctf_scanner_scope *it;
 119         int ret = 0;
 120
 121         for (it = scanner->cs; it != NULL; it = it->parent) {
 122                 if (lookup_type(it, id)) {
 123                         ret = 1;
 124                         break;
 125                 }
 126         }
 127         printf_dbg("is type %s %d\n", id, ret);
 128         return ret;
 129 }
 130
 131 static void add_type(struct ctf_scanner *scanner, const char *id)
 132 {
 133         char *type_id = NULL;
 134
 135         printf_dbg("add type %s\n", id);
 136         if (lookup_type(scanner->cs, id))
 137                 return;
 138         strredup(&type_id, id);
 139         g_hash_table_insert(scanner->cs->types, type_id, type_id);
 140 }
 141
 142 void yyerror(struct ctf_scanner *scanner, const char *str)
 143 {
 144         fprintf(stderr, "error %s\n", str);
 145 }
 146
 147 int yywrap(void)
 148 {
 149         return 1;
 150 }
 151
 152 static void free_strings(struct cds_list_head *list)
 153 {
 154         struct gc_string *gstr, *tmp;
 155
 156         cds_list_for_each_entry_safe(gstr, tmp, list, gc)
 157                 free(gstr);
 158 }
 159
 160 static struct ctf_ast *ctf_ast_alloc(void)
 161 {
 162         struct ctf_ast *ast;
 163
 164         ast = malloc(sizeof(*ast));
 165         if (!ast)
 166                 return NULL;
 167         memset(ast, 0, sizeof(*ast));
 168         return ast;
 169 }
 170
 171 static void ctf_ast_free(struct ctf_ast *ast)
 172 {
 173 }
 174
 175 int ctf_scanner_append_ast(struct ctf_scanner *scanner)
 176 {
 177         return yyparse(scanner);
 178 }
 179
 180 struct ctf_scanner *ctf_scanner_alloc(FILE *input)
 181 {
 182         struct ctf_scanner *scanner;
 183         int ret;
 184
 185         scanner = malloc(sizeof(*scanner));
 186         if (!scanner)
 187                 return NULL;
 188         memset(scanner, 0, sizeof(*scanner));
 189
 190         ret = yylex_init_extra(scanner, &scanner->scanner);
 191         if (ret) {
 192                 fprintf(stderr, "yylex_init error\n");
 193                 goto cleanup_scanner;
 194         }
 195         yyset_in(input, scanner);
 196
 197         scanner->ast = ctf_ast_alloc();
 198         if (!scanner->ast)
 199                 goto cleanup_lexer;
 200         init_scope(&scanner->root_scope, NULL);
 201         CDS_INIT_LIST_HEAD(&scanner->allocated_strings);
 202
 203         return scanner;
 204
 205 cleanup_lexer:
 206         ret = yylex_destroy(scanner->scanner);
 207         if (!ret)
 208                 fprintf(stderr, "yylex_destroy error\n");
 209 cleanup_scanner:
 210         free(scanner);
 211         return NULL;
 212 }
 213
 214 void ctf_scanner_free(struct ctf_scanner *scanner)
 215 {
 216         int ret;
 217
 218         finalize_scope(&scanner->root_scope);
 219         free_strings(&scanner->allocated_strings);
 220         ctf_ast_free(scanner->ast);
 221         ret = yylex_destroy(scanner->scanner);
 222         if (ret)
 223                 fprintf(stderr, "yylex_destroy error\n");
 224         free(scanner);
 225 }
 226
 227 %}
 228
 229 %define api.pure
 230         /* %locations */
 231 %parse-param {struct ctf_scanner *scanner}
 232 %lex-param {struct ctf_scanner *scanner}
 233 %start file
 234 %token CHARACTER_CONSTANT_START SQUOTE STRING_LITERAL_START DQUOTE ESCSEQ CHAR_STRING_TOKEN LSBRAC RSBRAC LPAREN RPAREN LBRAC RBRAC RARROW STAR PLUS MINUS LT GT TYPEASSIGN COLON SEMICOLON DOTDOTDOT DOT EQUAL COMMA CONST CHAR DOUBLE ENUM EVENT FLOATING_POINT FLOAT INTEGER INT LONG SHORT SIGNED STREAM STRING STRUCT TRACE TYPEALIAS TYPEDEF UNSIGNED VARIANT VOID _BOOL _COMPLEX _IMAGINARY DECIMAL_CONSTANT OCTAL_CONSTANT HEXADECIMAL_CONSTANT
 235 %token <gs> IDENTIFIER ID_TYPE
 236 %token ERROR
 237 %union
 238 {
 239         long long ll;
 240         char c;
 241         struct gc_string *gs;
 242         struct ctf_node *n;
 243 }
 244
 245 %%
 246
 247 file:
 248                 declaration
 249         |       file declaration
 250         ;
 251
 252 keywords:
 253                 VOID
 254         |       CHAR
 255         |       SHORT
 256         |       INT
 257         |       LONG
 258         |       FLOAT
 259         |       DOUBLE
 260         |       SIGNED
 261         |       UNSIGNED
 262         |       _BOOL
 263         |       _COMPLEX
 264         |       FLOATING_POINT
 265         |       INTEGER
 266         |       STRING
 267         |       ENUM
 268         |       VARIANT
 269         |       STRUCT
 270         |       CONST
 271         |       TYPEDEF
 272         |       EVENT
 273         |       STREAM
 274         |       TRACE
 275         ;
 276
 277 /* 1.5 Constants */
 278
 279 c_char_sequence:
 280                 c_char
 281         |       c_char_sequence c_char
 282         ;
 283
 284 c_char:
 285                 CHAR_STRING_TOKEN
 286         |       ESCSEQ
 287         ;
 288
 289 /* 1.6 String literals */
 290
 291 s_char_sequence:
 292                 s_char
 293         |       s_char_sequence s_char
 294         ;
 295
 296 s_char:
 297                 CHAR_STRING_TOKEN
 298         |       ESCSEQ
 299         ;
 300
 301 /* 2: Phrase structure grammar */
 302
 303 postfix_expression:
 304                 IDENTIFIER
 305         |       ID_TYPE
 306         |       keywords
 307         |       DECIMAL_CONSTANT
 308         |       OCTAL_CONSTANT
 309         |       HEXADECIMAL_CONSTANT
 310         |       STRING_LITERAL_START DQUOTE
 311         |       STRING_LITERAL_START s_char_sequence DQUOTE
 312         |       CHARACTER_CONSTANT_START c_char_sequence SQUOTE
 313         |       LPAREN unary_expression RPAREN
 314         |       postfix_expression LSBRAC unary_expression RSBRAC
 315         |       postfix_expression DOT IDENTIFIER
 316         |       postfix_expression DOT ID_TYPE
 317         |       postfix_expression RARROW IDENTIFIER
 318         |       postfix_expression RARROW ID_TYPE
 319         ;
 320
 321 unary_expression:
 322                 postfix_expression
 323         |       PLUS postfix_expression
 324         |       MINUS postfix_expression
 325         ;
 326
 327 unary_expression_or_range:
 328                 unary_expression DOTDOTDOT unary_expression
 329         |       unary_expression
 330         ;
 331
 332 /* 2.2: Declarations */
 333
 334 declaration:
 335                 declaration_specifiers SEMICOLON
 336         |       event_declaration
 337         |       stream_declaration
 338         |       trace_declaration
 339         |       declaration_specifiers TYPEDEF declaration_specifiers type_declarator_list SEMICOLON
 340         |       TYPEDEF declaration_specifiers type_declarator_list SEMICOLON
 341         |       declaration_specifiers TYPEDEF type_declarator_list SEMICOLON
 342         |       TYPEALIAS declaration_specifiers abstract_declarator_list COLON declaration_specifiers abstract_type_declarator_list SEMICOLON
 343         |       TYPEALIAS declaration_specifiers abstract_declarator_list COLON type_declarator_list SEMICOLON
 344         ;
 345
 346 event_declaration:
 347                 event_declaration_begin event_declaration_end
 348         |       event_declaration_begin ctf_assignment_expression_list event_declaration_end
 349         ;
 350
 351 event_declaration_begin:
 352                 EVENT LBRAC
 353                 {
 354                         push_scope(scanner);
 355                 }
 356         ;
 357
 358 event_declaration_end:
 359                 RBRAC SEMICOLON
 360                 {
 361                         pop_scope(scanner);
 362                 }
 363         ;
 364
 365
 366 stream_declaration:
 367                 stream_declaration_begin stream_declaration_end
 368         |       stream_declaration_begin ctf_assignment_expression_list stream_declaration_end
 369         ;
 370
 371 stream_declaration_begin:
 372                 STREAM LBRAC
 373                 {
 374                         push_scope(scanner);
 375                 }
 376         ;
 377
 378 stream_declaration_end:
 379                 RBRAC SEMICOLON
 380                 {
 381                         pop_scope(scanner);
 382                 }
 383         ;
 384
 385
 386 trace_declaration:
 387                 trace_declaration_begin trace_declaration_end
 388         |       trace_declaration_begin ctf_assignment_expression_list trace_declaration_end
 389         ;
 390
 391 trace_declaration_begin:
 392                 TRACE LBRAC
 393                 {
 394                         push_scope(scanner);
 395                 }
 396         ;
 397
 398 trace_declaration_end:
 399                 RBRAC SEMICOLON
 400                 {
 401                         pop_scope(scanner);
 402                 }
 403         ;
 404
 405 declaration_specifiers:
 406                 CONST
 407         |       type_specifier
 408         |       declaration_specifiers CONST
 409         |       declaration_specifiers type_specifier
 410         ;
 411
 412 type_declarator_list:
 413                 type_declarator
 414         |       type_declarator_list COMMA type_declarator
 415         ;
 416
 417 abstract_type_declarator_list:
 418                 abstract_type_declarator
 419         |       abstract_type_declarator_list COMMA abstract_type_declarator
 420         ;
 421
 422 type_specifier:
 423                 VOID
 424         |       CHAR
 425         |       SHORT
 426         |       INT
 427         |       LONG
 428         |       FLOAT
 429         |       DOUBLE
 430         |       SIGNED
 431         |       UNSIGNED
 432         |       _BOOL
 433         |       _COMPLEX
 434         |       ID_TYPE
 435         |       FLOATING_POINT LBRAC RBRAC
 436         |       FLOATING_POINT LBRAC ctf_assignment_expression_list RBRAC
 437         |       INTEGER LBRAC RBRAC
 438         |       INTEGER LBRAC ctf_assignment_expression_list RBRAC
 439         |       STRING LBRAC RBRAC
 440         |       STRING LBRAC ctf_assignment_expression_list RBRAC
 441         |       ENUM enum_type_specifier
 442         |       VARIANT variant_type_specifier
 443         |       STRUCT struct_type_specifier
 444         ;
 445
 446 struct_type_specifier:
 447                 struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end
 448         |       IDENTIFIER struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end
 449         |       ID_TYPE struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end
 450         |       IDENTIFIER
 451         |       ID_TYPE
 452         ;
 453
 454 struct_declaration_begin:
 455                 LBRAC
 456                 {
 457                         push_scope(scanner);
 458                 }
 459         ;
 460
 461 struct_declaration_end:
 462                 RBRAC
 463                 {
 464                         pop_scope(scanner);
 465                 }
 466         ;
 467
 468 variant_type_specifier:
 469                 variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
 470         |       LT IDENTIFIER GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
 471         |       LT ID_TYPE GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
 472         |       IDENTIFIER variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
 473         |       IDENTIFIER LT IDENTIFIER GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
 474         |       IDENTIFIER LT IDENTIFIER GT
 475         |       IDENTIFIER LT ID_TYPE GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
 476         |       IDENTIFIER LT ID_TYPE GT
 477         |       ID_TYPE variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
 478         |       ID_TYPE LT IDENTIFIER GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
 479         |       ID_TYPE LT IDENTIFIER GT
 480         |       ID_TYPE LT ID_TYPE GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
 481         |       ID_TYPE LT ID_TYPE GT
 482         ;
 483
 484 variant_declaration_begin:
 485                 LBRAC
 486                 {
 487                         push_scope(scanner);
 488                 }
 489         ;
 490
 491 variant_declaration_end:
 492                 RBRAC
 493                 {
 494                         pop_scope(scanner);
 495                 }
 496         ;
 497
 498 type_specifier_or_integer_constant:
 499                 declaration_specifiers
 500         |       DECIMAL_CONSTANT
 501         |       OCTAL_CONSTANT
 502         |       HEXADECIMAL_CONSTANT
 503         ;
 504
 505 enum_type_specifier:
 506                 LBRAC enumerator_list RBRAC
 507         |       LT type_specifier_or_integer_constant GT LBRAC enumerator_list RBRAC
 508         |       IDENTIFIER LBRAC enumerator_list RBRAC
 509         |       IDENTIFIER LT type_specifier_or_integer_constant GT LBRAC enumerator_list RBRAC
 510         |       ID_TYPE LBRAC enumerator_list RBRAC
 511         |       ID_TYPE LT type_specifier_or_integer_constant GT LBRAC enumerator_list RBRAC
 512         |       LBRAC enumerator_list COMMA RBRAC
 513         |       LT type_specifier_or_integer_constant GT LBRAC enumerator_list COMMA RBRAC
 514         |       IDENTIFIER LBRAC enumerator_list COMMA RBRAC
 515         |       IDENTIFIER LT type_specifier_or_integer_constant GT LBRAC enumerator_list COMMA RBRAC
 516         |       IDENTIFIER
 517         |       IDENTIFIER LT type_specifier_or_integer_constant GT
 518         |       ID_TYPE LBRAC enumerator_list COMMA RBRAC
 519         |       ID_TYPE LT type_specifier_or_integer_constant GT LBRAC enumerator_list COMMA RBRAC
 520         |       ID_TYPE
 521         |       ID_TYPE LT type_specifier_or_integer_constant GT
 522         ;
 523
 524 struct_or_variant_declaration_list:
 525                 /* empty */
 526         |       struct_or_variant_declaration_list struct_or_variant_declaration
 527         ;
 528
 529 struct_or_variant_declaration:
 530                 specifier_qualifier_list struct_or_variant_declarator_list SEMICOLON
 531         |       specifier_qualifier_list TYPEDEF specifier_qualifier_list type_declarator_list SEMICOLON
 532         |       TYPEDEF specifier_qualifier_list type_declarator_list SEMICOLON
 533         |       specifier_qualifier_list TYPEDEF type_declarator_list SEMICOLON
 534         |       TYPEALIAS specifier_qualifier_list abstract_declarator_list COLON specifier_qualifier_list abstract_type_declarator_list SEMICOLON
 535         |       TYPEALIAS specifier_qualifier_list abstract_declarator_list COLON type_declarator_list SEMICOLON
 536         ;
 537
 538 specifier_qualifier_list:
 539                 CONST
 540         |       type_specifier
 541         |       specifier_qualifier_list CONST
 542         |       specifier_qualifier_list type_specifier
 543         ;
 544
 545 struct_or_variant_declarator_list:
 546                 struct_or_variant_declarator
 547         |       struct_or_variant_declarator_list COMMA struct_or_variant_declarator
 548         ;
 549
 550 struct_or_variant_declarator:
 551                 declarator
 552         |       COLON unary_expression
 553         |       declarator COLON unary_expression
 554         ;
 555
 556 enumerator_list:
 557                 enumerator
 558         |       enumerator_list COMMA enumerator
 559         ;
 560
 561 enumerator:
 562                 IDENTIFIER
 563         |       ID_TYPE
 564         |       keywords
 565         |       STRING_LITERAL_START DQUOTE
 566         |       STRING_LITERAL_START s_char_sequence DQUOTE
 567         |       IDENTIFIER EQUAL unary_expression_or_range
 568         |       ID_TYPE EQUAL unary_expression_or_range
 569         |       keywords EQUAL unary_expression_or_range
 570         |       STRING_LITERAL_START DQUOTE EQUAL unary_expression_or_range
 571         |       STRING_LITERAL_START s_char_sequence DQUOTE EQUAL unary_expression_or_range
 572         ;
 573
 574 abstract_declarator_list:
 575                 abstract_declarator
 576         |       abstract_declarator_list COMMA abstract_declarator
 577         ;
 578
 579 abstract_declarator:
 580                 direct_abstract_declarator
 581         |       pointer direct_abstract_declarator
 582         ;
 583
 584 direct_abstract_declarator:
 585                 /* empty */
 586         |       IDENTIFIER
 587         |       LPAREN abstract_declarator RPAREN
 588         |       direct_abstract_declarator LSBRAC type_specifier_or_integer_constant RSBRAC
 589         |       direct_abstract_declarator LSBRAC RSBRAC
 590         ;
 591
 592 declarator:
 593                 direct_declarator
 594         |       pointer direct_declarator
 595         ;
 596
 597 direct_declarator:
 598                 IDENTIFIER
 599         |       LPAREN declarator RPAREN
 600         |       direct_declarator LSBRAC type_specifier_or_integer_constant RSBRAC
 601         ;
 602
 603 type_declarator:
 604                 direct_type_declarator
 605         |       pointer direct_type_declarator
 606         ;
 607
 608 direct_type_declarator:
 609                 IDENTIFIER
 610                 {
 611                         add_type(scanner, $1->s);
 612                 }
 613         |       LPAREN type_declarator RPAREN
 614         |       direct_type_declarator LSBRAC type_specifier_or_integer_constant RSBRAC
 615         ;
 616
 617 abstract_type_declarator:
 618                 direct_abstract_type_declarator
 619         |       pointer direct_abstract_type_declarator
 620         ;
 621
 622 direct_abstract_type_declarator:
 623                 /* empty */
 624         |       IDENTIFIER
 625                 {
 626                         add_type(scanner, $1->s);
 627                 }
 628         |       LPAREN abstract_type_declarator RPAREN
 629         |       direct_abstract_type_declarator LSBRAC type_specifier_or_integer_constant RSBRAC
 630         |       direct_abstract_type_declarator LSBRAC RSBRAC
 631         ;
 632
 633 pointer:
 634                 STAR
 635         |       STAR pointer
 636         |       STAR type_qualifier_list pointer
 637         ;
 638
 639 type_qualifier_list:
 640                 CONST
 641         |       type_qualifier_list CONST
 642         ;
 643
 644 /* 2.3: CTF-specific declarations */
 645
 646 ctf_assignment_expression_list:
 647                 ctf_assignment_expression SEMICOLON
 648         |       ctf_assignment_expression_list ctf_assignment_expression SEMICOLON
 649         ;
 650
 651 ctf_assignment_expression:
 652                 unary_expression EQUAL unary_expression
 653         |       unary_expression TYPEASSIGN type_specifier
 654         |       declaration_specifiers TYPEDEF declaration_specifiers type_declarator_list
 655         |       TYPEDEF declaration_specifiers type_declarator_list
 656         |       declaration_specifiers TYPEDEF type_declarator_list
 657         |       TYPEALIAS declaration_specifiers abstract_declarator_list COLON declaration_specifiers abstract_type_declarator_list
 658         |       TYPEALIAS declaration_specifiers abstract_declarator_list COLON type_declarator_list
 659         ;