distrib/sources/yagle/slib/slib.y

   1 /************************************************************/
   2 /*                         slib.y                           */
   3 /************************************************************/
   4
   5 /************************************************************/
   6 /*                       declaration                        */
   7 /************************************************************/
   8 %{
   9 #include <stdio.h>
  10 #include <string.h>
  11 #include <stdlib.h>
  12 #include "slib_error.h"
  13 #include SLB_H
  14
  15 library     *SLIB_LIBRARY;
  16 symbol_list *SLIB_CURRENT_SYMBOL;
  17
  18 draw_list   *FUNC_TION;
  19 line        *U_LINE;
  20 arc         *U_ARC;
  21 circle      *U_CIRCLE;
  22 pin         *U_PIN;
  23
  24 int yydebug;
  25 int yyerror();
  26 int yylex();
  27 extern int slibParseLine  ;
  28 extern eqt_ctx *slibEqtCtx;
  29
  30 int id;
  31
  32 %}
  33
  34 /************************************************************/
  35 /*                    union pour yylval                     */
  36 /************************************************************/
  37 %union {
  38     char    *string_type;
  39     float   float_type;
  40     int     int_type;
  41     double  double_type;
  42     };
  43
  44
  45
  46 /************************************************************/
  47 /*                         token                            */
  48 /************************************************************/
  49 %token <string_type> EGAL SEMI COLON COMMA
  50 %token <string_type> LPAR RPAR LCURLY RCURLY
  51 %token LIB SYMBOL SYMBNAME LAYER SUB_SYMB AREA ANNOTATE
  52 %token LINE ARC CIRCLE PIN T_GRID
  53 %token <string_type> NUM
  54 %token <string_type> STRING
  55 %token <string_type> OPE
  56
  57 %type <string_type> expression_list make_expression operateur primary function choice
  58 %type <double_type> expression
  59 %%
  60
  61 file    :  statements
  62           {
  63             slibEqtCtx->EQT_RES_CALC = EQT_COMPLETE;
  64             if(!eqt_getvar (slibEqtCtx,namealloc("AND_HEIGHT")))
  65                 slib_error(ERR_NO_REF_HEIGHT, slibParseLine,NULL);
  66
  67             SLIB_LIBRARY->REFHEIGHT = eqt_getvar(slibEqtCtx,namealloc("AND_HEIGHT"));
  68
  69             SLIB_LIBRARY->SYMB = (symbol_list *)reverse((chain_list *)SLIB_LIBRARY->SYMB);
  70           }
  71         ;
  72
  73 group   : head LCURLY statements RCURLY
  74           {}
  75         | head LCURLY  RCURLY
  76           {}
  77         ;
  78
  79 statements      : statement
  80               {}
  81                         | statements statement
  82               {}
  83                         ;
  84
  85 statement       : group  {}
  86             | egality SEMI{}
  87             | function SEMI { mbkfree($1); }
  88             | canonicalname {}
  89             | define SEMI {}
  90             | draw SEMI {}
  91             | call SEMI {}
  92             | useless SEMI {}
  93             | T_GRID LPAR choice RPAR SEMI
  94             {
  95               slib_set_lib_grid( SLIB_LIBRARY, eqt_eval(slibEqtCtx,namealloc($3),EQTFAST) );
  96
  97               if(eqt_resistrue(slibEqtCtx) != EQT_COMPLETE)
  98                   slib_error(ERR_NO_GRID, slibParseLine,$3);
  99             }
 100             ;
 101
 102 choice  : NUM     { $$=$1; }
 103         | STRING  { $$=$1; }
 104         ;
 105
 106 egality     : STRING EGAL expression
 107             {
 108               if(eqt_resistrue(slibEqtCtx))
 109                   eqt_addvar(slibEqtCtx,namealloc($1),$3);
 110               else
 111                   slib_error(ERR_NO_EVAL, slibParseLine,$1);
 112             }
 113             ;
 114
 115 define      : STRING COLON expression {}
 116             ;
 117
 118 canonicalname : SYMBNAME COLON STRING SEMI
 119                {}
 120               ;
 121
 122 ident   : LIB
 123           {
 124           id =1;
 125           slib_set_function(slibEqtCtx);
 126           }
 127         | SYMBOL
 128           { id =2; }
 129         | LAYER
 130           { id =0; }
 131         | ANNOTATE
 132           { id =0; }
 133         ;
 134
 135 head    : ident LPAR STRING RPAR
 136             {
 137             if (id ==1){
 138                   SLIB_LIBRARY = slib_create_lib($3) ;
 139                 }
 140             if (id ==2){
 141                   SLIB_CURRENT_SYMBOL = slib_add_symbol(SLIB_LIBRARY,$3);
 142                 }
 143             }
 144         | ident LPAR RPAR {}
 145                 ;
 146
 147 call        : SUB_SYMB LPAR STRING COMMA expression COMMA expression COMMA expression RPAR
 148               {
 149                 if(!slib_getsymbol(SLIB_LIBRARY, $3))
 150                     slib_error(ERR_NO_SYMBOL, slibParseLine,$3);
 151
 152                 slib_add_subsymbol(SLIB_LIBRARY,SLIB_CURRENT_SYMBOL,$3,$5,$7,$9);
 153               }
 154             ;
 155
 156 useless : AREA LPAR expression_list RPAR
 157         { mbkfree($3); }
 158         ;
 159
 160 draw    : LINE   LPAR expression COMMA expression COMMA expression COMMA expression RPAR
 161           {
 162           slib_add_draw_line(SLIB_CURRENT_SYMBOL,$3,$5,$7,$9,SLIB_LIBRARY->GRID);
 163           }
 164         | ARC    LPAR expression COMMA expression COMMA expression COMMA expression COMMA expression COMMA expression RPAR
 165           {
 166           slib_add_draw_arc(SLIB_CURRENT_SYMBOL,$3,$5,$7,$9,$11,$13,SLIB_LIBRARY->GRID);
 167           }
 168         | CIRCLE LPAR expression COMMA expression COMMA expression RPAR
 169           {
 170           slib_add_draw_circle(SLIB_CURRENT_SYMBOL,$3,$5,$7,SLIB_LIBRARY->GRID);
 171           }
 172         | PIN    LPAR STRING COMMA expression COMMA expression COMMA STRING RPAR
 173           {
 174           int pin_direction;
 175
 176           if( !strcasecmp($9,"UP") )
 177             pin_direction = SLIB_PIN_UP ;
 178           else if ( !strcasecmp($9,"DOWN") )
 179             pin_direction = SLIB_PIN_DOWN ;
 180           else if ( !strcasecmp($9,"LEFT") )
 181             pin_direction = SLIB_PIN_LEFT ;
 182           else if ( !strcasecmp($9,"RIGHT") )
 183             pin_direction = SLIB_PIN_RIGHT ;
 184           else
 185             slib_error(ERR_PIN_DIR, slibParseLine,$9);
 186
 187           slib_add_draw_pin(SLIB_CURRENT_SYMBOL,$3,$5,$7,pin_direction,SLIB_LIBRARY->GRID);
 188           }
 189         ;
 190
 191
 192 function    : STRING LPAR expression_list RPAR
 193             {
 194             char concat[1024];
 195             strcpy(concat, $1);
 196             strcat(concat, "(");
 197             strcat(concat, $3);
 198             strcat(concat, ")");
 199             $$ = mbkstrdup(concat);
 200             //printf("### fonction crée:\t%s\n",$$);
 201             mbkfree($3);
 202             }
 203             ;
 204
 205 expression_list : expression
 206                 {
 207                 char concat[1024];
 208                 sprintf(concat,"%f",$1);
 209                 $$ = mbkstrdup(concat);
 210                 }
 211                 | expression_list COMMA expression
 212                 {
 213                 char concat[1024];
 214                 char rescue[1024];
 215                 sprintf(rescue,"%f",$3);
 216                 strcpy(concat, $1);
 217                 strcat(concat, ",");
 218                 strcat(concat, rescue);
 219                 $$ = mbkstrdup(concat);
 220                 mbkfree($1);
 221                 }
 222                 ;
 223
 224 expression : make_expression
 225             {
 226             $$ = eqt_eval(slibEqtCtx,namealloc($1),EQTFAST);
 227             mbkfree($1);
 228             }
 229             ;
 230
 231 make_expression    : operateur primary
 232                   {
 233                   char concat[1024];
 234                   strcpy(concat, $1);
 235                   strcat(concat, $2);
 236                   $$ = mbkstrdup(concat);
 237                   mbkfree($2);
 238                   }
 239               | make_expression OPE primary
 240                   {
 241                   char concat[1024];
 242                   strcpy(concat, $1);
 243                   strcat(concat, $2);
 244                   strcat(concat, $3);
 245                   $$ = mbkstrdup(concat);
 246                   mbkfree($1); mbkfree($3);
 247                   }
 248               | operateur LPAR make_expression RPAR
 249                   {
 250                   char concat[1024];
 251                   strcpy(concat, $1);
 252                   strcat(concat, "(");
 253                   strcat(concat, $3);
 254                   strcat(concat, ")");
 255                   $$ = mbkstrdup(concat);
 256                   mbkfree($3);
 257                   }
 258               | make_expression OPE LPAR make_expression RPAR
 259                   {
 260                   char concat[1024];
 261                   strcpy(concat, $1);
 262                   strcat(concat, $2);
 263                   strcat(concat, "(");
 264                   strcat(concat, $4);
 265                   strcat(concat, ")");
 266                   $$ = mbkstrdup(concat);
 267                   mbkfree($1); mbkfree($4);
 268                   }
 269               ;
 270
 271 operateur    :     { $$ = ""; }
 272              | OPE { $$ = $1; }
 273              ;
 274
 275 primary   : choice   { $$ = mbkstrdup($1); }
 276           | function { $$ = mbkstrdup($1); mbkfree($1); }
 277           ;
 278
 279
 280
 281
 282 %%
 283
 284 int yyerror()
 285 {
 286         printf("SLIB Parse Error at line %d .\n",slibParseLine);
 287     EXIT (EXIT_FAILURE) ;
 288     return 0;
 289 }