distrib/sources/tas/lib/lib.y

   1 %{
   2 #include "lib_global.h"
   3 int liberror();
   4 int liblex();
   5 int libdebug ;
   6 extern int LIB_LINE;
   7
   8 %}
   9
  10
  11 %union {
  12     char                                        *stringtype;
  13     struct chain                                *chainlist;
  14     struct { char *ident; struct chain *param;} head_struct;
  15 };
  16
  17
  18 %token <stringtype>        _NUMBER
  19 %token <stringtype>        _STRING
  20 %token <stringtype>        _IDENT
  21 %token                     _LPAR
  22 %token                     _RPAR
  23 %token                     _LCURLY
  24 %token                     _RCURLY
  25 %token                     _SEMI
  26 %token                     _COLON
  27 %token                     _COMMA
  28 %token <stringtype>        _OPE
  29
  30 %start test
  31
  32 %type  <stringtype>         primary operateur make_expression
  33 %type  <stringtype>         expression attr_val
  34 %type  <chainlist>          param_list
  35 %type  <head_struct>        head
  36
  37 %%
  38
  39 /*file  : group */
  40 /*              ;       */
  41
  42
  43 test : {yydebug=0;} group ;
  44
  45 group   : head _LCURLY
  46         {
  47             lib_treat_group_head($1.ident, $1.param);
  48         }
  49
  50         statements _RCURLY
  51         {
  52             lib_treat_group_end();
  53         }
  54
  55         | head _LCURLY
  56         {
  57             lib_treat_group_head($1.ident, $1.param);
  58         }
  59
  60         _RCURLY
  61                 {
  62             lib_treat_group_end();
  63         }
  64         ;
  65
  66
  67 statements      : statement
  68                         | statements statement
  69                         ;
  70
  71
  72 statement       : simple_attr
  73                         | complex_attr
  74                         | group
  75                         ;
  76
  77 simple_attr     : _IDENT _COLON attr_val _SEMI
  78             {
  79                 lib_treat_s_attr($1, $3);
  80             }
  81
  82
  83                         | _IDENT _COLON attr_val
  84             {
  85                 lib_treat_s_attr($1, $3);
  86             }
  87                         ;
  88
  89 complex_attr    : head  _SEMI
  90                 {
  91                     lib_treat_c_attr($1.ident, $1.param);
  92                 }
  93                 | head
  94                 {
  95                     lib_treat_c_attr($1.ident, $1.param);
  96                 }
  97                                 ;
  98
  99 head    : _IDENT _LPAR param_list _RPAR
 100         {
 101             $$.ident=$1;
 102             $$.param=reverse($3);
 103         }
 104         | _IDENT _LPAR _RPAR
 105
 106         {
 107            $$.ident=$1;
 108            $$.param=NULL;
 109         }
 110         ;
 111
 112
 113 param_list  : attr_val
 114             {
 115                 $$ = addchain(NULL,$1);
 116             }
 117             | param_list _COMMA attr_val
 118             {
 119                 $$ = addchain($1,$3);
 120             }
 121                         ;
 122
 123 attr_val : _STRING { $$ = lib_unquote($1);}
 124          | expression { $$ = $1;}
 125                  ;
 126
 127 expression : make_expression
 128             {
 129             $$ = $1;
 130             }
 131             ;
 132
 133 make_expression    : operateur primary
 134                   {
 135                   char concat[1024];
 136                   strcpy(concat, $1);
 137                   strcat(concat, $2);
 138                   $$ = mbkstrdup(concat);
 139                   mbkfree($2);
 140                   }
 141               | make_expression _OPE primary
 142                   {
 143                   char concat[1024];
 144                   strcpy(concat, $1);
 145                   strcat(concat, $2);
 146                   strcat(concat, $3);
 147                   $$ = mbkstrdup(concat);
 148                   mbkfree($1); mbkfree($2); mbkfree($3);
 149                   }
 150               | operateur _LPAR make_expression _RPAR
 151                   {
 152                   char concat[1024];
 153                   strcpy(concat, $1);
 154                   strcat(concat, "(");
 155                   strcat(concat, $3);
 156                   strcat(concat, ")");
 157                   $$ = mbkstrdup(concat);
 158                   mbkfree($1);  mbkfree($3);
 159                   }
 160               | make_expression _OPE _LPAR make_expression _RPAR
 161                   {
 162                   char concat[1024];
 163                   strcpy(concat, $1);
 164                   strcat(concat, $2);
 165                   strcat(concat, "(");
 166                   strcat(concat, $4);
 167                   strcat(concat, ")");
 168                   $$ = mbkstrdup(concat);
 169                   mbkfree($1); mbkfree($2); mbkfree($4);
 170                   }
 171               ;
 172
 173 operateur    :          { $$ = ""; }
 174              | _OPE     { $$ = $1; }
 175              ;
 176
 177 primary   : _IDENT    {$$ = $1;}
 178           | _NUMBER   {$$ = $1;}
 179
 180           ;
 181
 182 %%
 183
 184
 185
 186
 187 int liberror ()
 188 {
 189     fprintf (stderr, "LIBERTY ERROR: parse error line %d\n", LIB_LINE) ;
 190     return 0;
 191 }
 192