src/common/filter/filter-grammar-test.c

   1 /*
   2  * filter-grammar-test.c
   3  *
   4  * LTTng filter grammar test
   5  *
   6  * Copyright 2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   7  *
   8  * SPDX-License-Identifier: LGPL-2.1-only
   9  *
  10  */
  11
  12 #include <stdio.h>
  13 #include <unistd.h>
  14 #include <string.h>
  15 #include <stdlib.h>
  16 #include <assert.h>
  17 #include <errno.h>
  18 #include <inttypes.h>
  19 #include "filter-ast.h"
  20 #include "filter-parser.h"
  21 #include "filter-bytecode.h"
  22
  23 int main(int argc, char **argv)
  24 {
  25         struct filter_parser_ctx *ctx;
  26         int ret;
  27         int print_xml = 0, generate_ir = 0, generate_bytecode = 0,
  28                 print_bytecode = 0;
  29         int i;
  30
  31         for (i = 1; i < argc; i++) {
  32                 if (strcmp(argv[i], "-p") == 0)
  33                         print_xml = 1;
  34                 else if (strcmp(argv[i], "-i") == 0)
  35                         generate_ir = 1;
  36                 else if (strcmp(argv[i], "-b") == 0)
  37                         generate_bytecode = 1;
  38                 else if (strcmp(argv[i], "-d") == 0)
  39                         filter_parser_debug = 1;
  40                 else if (strcmp(argv[i], "-B") == 0)
  41                         print_bytecode = 1;
  42         }
  43
  44         ctx = filter_parser_ctx_alloc(stdin);
  45         if (!ctx) {
  46                 fprintf(stderr, "Error allocating parser\n");
  47                 goto alloc_error;
  48         }
  49         ret = filter_parser_ctx_append_ast(ctx);
  50         if (ret) {
  51                 fprintf(stderr, "Parse error\n");
  52                 goto parse_error;
  53         }
  54         if (print_xml) {
  55                 ret = filter_visitor_print_xml(ctx, stdout, 0);
  56                 if (ret) {
  57                         fflush(stdout);
  58                         fprintf(stderr, "XML print error\n");
  59                         goto parse_error;
  60                 }
  61         }
  62         if (generate_ir) {
  63                 printf("Generating IR... ");
  64                 fflush(stdout);
  65                 ret = filter_visitor_ir_generate(ctx);
  66                 if (ret) {
  67                         fprintf(stderr, "Generate IR error\n");
  68                         goto parse_error;
  69                 }
  70                 printf("done\n");
  71
  72                 printf("Validating IR... ");
  73                 fflush(stdout);
  74                 ret = filter_visitor_ir_check_binary_op_nesting(ctx);
  75                 if (ret) {
  76                         goto parse_error;
  77                 }
  78                 printf("done\n");
  79         }
  80         if (generate_bytecode) {
  81                 printf("Generating bytecode... ");
  82                 fflush(stdout);
  83                 ret = filter_visitor_bytecode_generate(ctx);
  84                 if (ret) {
  85                         fprintf(stderr, "Generate bytecode error\n");
  86                         goto parse_error;
  87                 }
  88                 printf("done\n");
  89                 printf("Size of bytecode generated: %u bytes.\n",
  90                         bytecode_get_len(&ctx->bytecode->b));
  91         }
  92
  93         if (print_bytecode) {
  94                 unsigned int bytecode_len, len, i;
  95
  96                 len = bytecode_get_len(&ctx->bytecode->b);
  97                 bytecode_len = ctx->bytecode->b.reloc_table_offset;
  98                 printf("Bytecode:\n");
  99                 for (i = 0; i < bytecode_len; i++) {
 100                         printf("0x%X ",
 101                                 ((uint8_t *) ctx->bytecode->b.data)[i]);
 102                 }
 103                 printf("\n");
 104                 printf("Reloc table:\n");
 105                 for (i = bytecode_len; i < len;) {
 106                         printf("{ 0x%X, ",
 107                                 *(uint16_t *) &ctx->bytecode->b.data[i]);
 108                         i += sizeof(uint16_t);
 109                         printf("%s } ", &((char *) ctx->bytecode->b.data)[i]);
 110                         i += strlen(&((char *) ctx->bytecode->b.data)[i]) + 1;
 111                 }
 112                 printf("\n");
 113         }
 114
 115         filter_bytecode_free(ctx);
 116         filter_ir_free(ctx);
 117         filter_parser_ctx_free(ctx);
 118         return 0;
 119
 120 parse_error:
 121         filter_bytecode_free(ctx);
 122         filter_ir_free(ctx);
 123         filter_parser_ctx_free(ctx);
 124 alloc_error:
 125         exit(EXIT_FAILURE);
 126 }