Line data    Source code

       1             : %code requires {
       2             : /* Required to break a circular dependency introduced with bison 2.6 */
       3             : typedef void* yyscan_t;
       4             : }
       5             : %code top {
       6             : #include <errno.h>
       7             : #include "lang.h"
       8             : #include "lexer.h"
       9             : 
      10           0 : static int yyerror(struct lgfs2_lang_state *state, yyscan_t lexer, const char *errorstr)
      11             : {
      12           0 :         fprintf(stderr, "%d:%d: %s\n", state->ls_linenum, state->ls_colnum, errorstr);
      13           0 :         return 1;
      14             : }
      15             : 
      16             : }
      17             : %defines
      18             : %debug
      19             : %define api.pure
      20             : %parse-param { struct lgfs2_lang_state *state }
      21             : %parse-param { yyscan_t lexer }
      22             : %lex-param { yyscan_t lexer }
      23             : %start script
      24             : %token TOK_COLON
      25             : %token TOK_COMMA
      26             : %token TOK_ID
      27             : %token TOK_LBRACE
      28             : %token TOK_LBRACKET
      29             : %token TOK_NUMBER
      30             : %token TOK_OFFSET
      31             : %token TOK_RBRACE
      32             : %token TOK_RBRACKET
      33             : %token TOK_SEMI
      34             : %token TOK_SET
      35             : %token TOK_GET
      36             : %token TOK_STATE
      37             : %token TOK_STRING
      38             : %token TOK_PATH
      39             : %%
      40             : script: statements {
      41           8 :                 state->ls_ast_root = $1;
      42           8 :                 state->ls_interp_curr = $1;
      43             :         }
      44             :         | statements TOK_SEMI {
      45           0 :                 state->ls_ast_root = $1;
      46           0 :                 state->ls_interp_curr = $1;
      47             :         }
      48             : ;
      49             : statements: statements TOK_SEMI statement {
      50           0 :                 state->ls_ast_tail->ast_left = $3;
      51           0 :                 state->ls_ast_tail = $3;
      52           0 :                 $$ = $1;
      53             :         }
      54             :         | statement {
      55           8 :                 if (state->ls_ast_tail == NULL)
      56           8 :                         state->ls_ast_tail = $1;
      57           8 :                 $$ = $1;
      58             :         }
      59             : ;
      60           8 : statement: set_stmt { $$ = $1;}
      61           0 :         | get_stmt { $$ = $1; }
      62             : ;
      63             : set_stmt: TOK_SET blockspec structspec {
      64           8 :                 $1->ast_right = $2;
      65           8 :                 $2->ast_right = $3;
      66           8 :                 $$ = $1;
      67             :         }
      68             :         | TOK_SET blockspec typespec structspec {
      69           0 :                 $1->ast_right = $2;
      70           0 :                 $2->ast_right = $3;
      71           0 :                 $3->ast_right = $4;
      72           0 :                 $$ = $1;
      73             :         }
      74             : ;
      75             : get_stmt: TOK_GET blockspec {
      76           0 :                 $1->ast_right = $2; $$ = $1;
      77             :         }
      78             :         | TOK_GET blockspec TOK_STATE {
      79           0 :                 $1->ast_right = $2;
      80           0 :                 $2->ast_right = $3;
      81           0 :                 $$ = $1;
      82             :         }
      83             : ;
      84           0 : blockspec: offset { $$ = $1; }
      85           0 :         | address { $$ = $1; }
      86           1 :         | path { $$ = $1; }
      87           7 :         | block_literal { $$ = $1; }
      88           0 :         | subscript { $$ = $1; }
      89             : ;
      90             : offset: blockspec TOK_OFFSET {
      91           0 :                 $2->ast_left = $1;
      92           0 :                 $$ = $2;
      93             :         }
      94             : ;
      95             : typespec: identifier {
      96           0 :                 $1->ast_type = AST_EX_TYPESPEC;
      97           0 :                 $$ = $1;
      98             :         }
      99             : ;
     100           7 : block_literal: identifier { $$ = $1; }
     101             : ;
     102             : subscript: block_literal TOK_LBRACKET index TOK_RBRACKET {
     103           0 :                 $4->ast_left = $1;
     104           0 :                 $1->ast_left = $3;
     105           0 :                 $$ = $4;
     106             :         }
     107             : ;
     108           0 : index: number { $$ = $1; }
     109           0 :         | identifier { $$ = $1; }
     110             : ;
     111             : address: number {
     112           0 :                 $1->ast_type = AST_EX_ADDRESS;
     113           0 :                 $$ = $1;
     114             :          }
     115             : ;
     116           8 : structspec: TOK_LBRACE fieldspecs TOK_RBRACE { $$ = $2; }
     117           0 :         | TOK_LBRACE TOK_RBRACE { $$ = NULL; }
     118             : ;
     119             : fieldspecs: fieldspecs TOK_COMMA fieldspec {
     120           0 :                 $1->ast_left = $3;
     121           0 :                 $$ = $1;
     122             :         }
     123           8 :         | fieldspec { $$ = $1; }
     124             : ;
     125             : fieldspec: identifier TOK_COLON fieldvalue {
     126           8 :                 $2->ast_right = $1;
     127           8 :                 $1->ast_right = $3;
     128           8 :                 $$ = $2;
     129             :         }
     130             : ;
     131           8 : fieldvalue: number { $$ = $1; }
     132           0 :         | string { $$ = $1; }
     133             : ;
     134           8 : number: TOK_NUMBER { $$ = $1; }
     135           0 : string: TOK_STRING { $$ = $1; }
     136          15 : identifier: TOK_ID { $$ = $1; }
     137           1 : path: TOK_PATH { $$ = $1; }
     138             : %%
     139             : 
     140             : /**
     141             :  * Allocate and initialize a new parse state structure. The caller must free the
     142             :  * memory returned by this function.
     143             :  */
     144           8 : struct lgfs2_lang_state *lgfs2_lang_init(void)
     145             : {
     146             :         struct lgfs2_lang_state *state;
     147           8 :         state = calloc(1, sizeof(struct lgfs2_lang_state));
     148           8 :         if (state == NULL) {
     149           0 :                 return NULL;
     150             :         }
     151           8 :         state->ls_linenum = 1;
     152           8 :         return state;
     153             : }
     154             : 
     155           8 : void lgfs2_lang_free(struct lgfs2_lang_state **state)
     156             : {
     157           8 :         ast_destroy(&(*state)->ls_ast_root);
     158           8 :         free(*state);
     159           8 :         *state = NULL;
     160           8 : }
     161             : 
     162           8 : int lgfs2_lang_parsef(struct lgfs2_lang_state *state, FILE *src)
     163             : {
     164           8 :         int ret = 0;
     165             :         yyscan_t lexer;
     166             : 
     167           8 :         ret = yylex_init_extra(state, &lexer);
     168           8 :         if (ret != 0) {
     169           0 :                 fprintf(stderr, "Failed to initialize lexer.\n");
     170           0 :                 return ret;
     171             :         }
     172             : 
     173           8 :         yyset_in(src, lexer);
     174           8 :         ret = yyparse(state, lexer);
     175           8 :         yylex_destroy(lexer);
     176           8 :         return ret;
     177             : }
     178             : 
     179           0 : int lgfs2_lang_parses(struct lgfs2_lang_state *state, const char *cstr)
     180             : {
     181             :         int ret;
     182             :         FILE *src;
     183           0 :         char *str = strdup(cstr);
     184             : 
     185           0 :         if (str == NULL) {
     186           0 :                 perror("Failed to duplicate source string");
     187           0 :                 return 1;
     188             :         }
     189             :         /* coverity[alloc_strlen:SUPPRESS] False positive */
     190           0 :         src = fmemopen(str, strlen(str), "r");
     191           0 :         if (src == NULL) {
     192           0 :                 perror("Failed to open string as source file");
     193           0 :                 free(str);
     194           0 :                 return 1;
     195             :         }
     196           0 :         ret = lgfs2_lang_parsef(state, src);
     197           0 :         fclose(src);
     198           0 :         free(str);
     199           0 :         if (ret != 0 || state->ls_errnum != 0) {
     200           0 :                 return 1;
     201             :         }
     202           0 :         return 0;
     203             : }