helm/software/matita/contribs/assembly/parser/parser.y

   1 \r
   2 /* ******************************** */\r
   3 /* PER UNA CORRETTA VISUALIZZAZIONE */\r
   4 /*           tab size=4             */\r
   5 /* ******************************** */\r
   6 \r
   7 %{\r
   8 \r
   9 #include        <stdio.h>\r
  10 #include        <stdlib.h>\r
  11 #include        <string.h>\r
  12 #include        <sys/types.h>\r
  13 \r
  14 /* ************************************************************************* */\r
  15 \r
  16 #define         YYDEBUG         1                                       /* debug interno di bison */\r
  17 \r
  18 #define         inline                                                  /* compatibilita' con l'opzione %glr-parser */\r
  19 #define         YYLTYPE_IS_DECLARED     1                       /* compatibilita' con VISUAL C */\r
  20 \r
  21 #define         SEP                     '\n'                            /* formattazione in input */\r
  22 \r
  23 #define         YYSTYPE         valueLeaf *                     /* struttura puntata dai nodi/foglie */\r
  24 \r
  25 #define         ERR_EXIT        -1\r
  26 \r
  27 /* manipolazione della posizione nel sorgente (bison) */\r
  28 #define         YYLLOC_DEFAULT(Current,Rhs,N) \\r
  29         do \\r
  30                 if(N) \\r
  31                         { \\r
  32                         (Current).first_line=YYRHSLOC(Rhs,1).first_line; \\r
  33                         (Current).first_column=YYRHSLOC(Rhs,1).first_column; \\r
  34                         (Current).last_line=YYRHSLOC(Rhs,N).last_line; \\r
  35                         (Current).last_column=YYRHSLOC(Rhs,N).last_column; \\r
  36                         (Current).source=YYRHSLOC(Rhs,1).source; \\r
  37                         } \\r
  38                 else \\r
  39                         { \\r
  40                         (Current).first_line=(Current).last_line=YYRHSLOC(Rhs,0).last_line; \\r
  41                         (Current).first_column=(Current).last_column=YYRHSLOC(Rhs,0).last_column; \\r
  42                         (Current).source=YYRHSLOC(Rhs,0).source; \\r
  43                         } \\r
  44         while(0)\r
  45 \r
  46 #ifndef         __STDC__\r
  47 #define         __STDC__\r
  48 \r
  49 #define         myMalloc(x)                     malloc((x<512) ? 512 : x)\r
  50 typedef         unsigned __int32        _DWORD_;        /* definizione univoca DWORD */\r
  51 typedef         unsigned __int16        _WORD_;         /* definizione univoca WORD */\r
  52 typedef         unsigned __int8         _BYTE_;         /* definizione univoca BYTE */\r
  53 \r
  54 #else\r
  55 \r
  56 #define         myMalloc(x)                     malloc((x<512) ? 512 : x)\r
  57 typedef         __uint32_t                      _DWORD_;        /* definizione univoca DWORD */\r
  58 typedef         __uint16_t                      _WORD_;         /* definizione univoca WORD */\r
  59 typedef         __uint8_t                       _BYTE_;         /* definizione univoca BYTE */\r
  60 \r
  61 #endif\r
  62 \r
  63 /* ************************************************************************* */\r
  64 \r
  65 /* struttura per la posizione manipolata direttamente da YYLOC_DEFAULT (bison) */\r
  66 typedef struct YYLTYPE\r
  67         {\r
  68         int             first_line;\r
  69         int             first_column;\r
  70         int             last_line;\r
  71         int             last_column;\r
  72         char    *source;\r
  73         } YYLTYPE;\r
  74 \r
  75 /* enumerazione delle etichette dei nodi/foglie */\r
  76 typedef enum {\r
  77         E_VALUE_ARRAY,\r
  78         E_VALUE_STRUCT,\r
  79         E_VALUE_DWORD,\r
  80         E_VALUE_WORD,\r
  81         E_VALUE_BYTE,\r
  82         E_VALUE_INUM,\r
  83         E_VALUE_STRING,\r
  84 \r
  85         E_DECL_CONST,\r
  86         E_DECL_VAR,\r
  87 \r
  88         E_STM_ASG,\r
  89         E_STM_WHILE,\r
  90         E_STM_IF,\r
  91         E_STM_IFEXPRBODY,\r
  92 \r
  93         E_EXPR_NEG,\r
  94         E_EXPR_NOT,\r
  95         E_EXPR_COM,\r
  96         E_EXPR_MUL,\r
  97         E_EXPR_DIV,\r
  98         E_EXPR_ADD,\r
  99         E_EXPR_SUB,\r
 100         E_EXPR_SHL,\r
 101         E_EXPR_SHR,\r
 102         E_EXPR_LT,\r
 103         E_EXPR_LTE,\r
 104         E_EXPR_GT,\r
 105         E_EXPR_GTE,\r
 106         E_EXPR_NEQ,\r
 107         E_EXPR_EQ,\r
 108         E_EXPR_AND,\r
 109         E_EXPR_OR,\r
 110         E_EXPR_XOR,\r
 111         E_EXPR_B2W,\r
 112         E_EXPR_B2DW,\r
 113         E_EXPR_W2B,\r
 114         E_EXPR_W2DW,\r
 115         E_EXPR_DW2B,\r
 116         E_EXPR_DW2W,\r
 117         E_EXPR_VAR,\r
 118 \r
 119         E_VAR_ROOT,\r
 120         E_VAR_STRUCT,\r
 121         E_VAR_ARRAY,\r
 122 \r
 123         E_TYPE_ARRAY,\r
 124         E_TYPE_STRUCT,\r
 125         E_TYPE_DWORD,\r
 126         E_TYPE_WORD,\r
 127         E_TYPE_BYTE,\r
 128 \r
 129         } vEnum;\r
 130 \r
 131 /* struttura polimorfa dei nodi/foglie */\r
 132 typedef struct _valueLeaf_\r
 133         {\r
 134         /* etichetta */\r
 135         vEnum                           id;\r
 136 \r
 137         _DWORD_                         dwordValue;\r
 138         _WORD_                          wordValue;\r
 139         _BYTE_                          byteValue;\r
 140         unsigned long int       inumValue;\r
 141         char                            *stringValue;\r
 142 \r
 143         struct _valueLeaf_      *param1;\r
 144         struct _valueLeaf_      *param2;\r
 145         struct _valueLeaf_      *param3;\r
 146         struct _valueLeaf_      *param4;\r
 147 \r
 148         /* per tutti */\r
 149         struct _valueLeaf_      *next;\r
 150         struct _valueLeaf_      *last;\r
 151 \r
 152         /* posizione nel sorgente */\r
 153         int                                     fileLine;\r
 154         int                                     fileRow;\r
 155         char                            *source;\r
 156         } valueLeaf;\r
 157 \r
 158 /* ************************************************************************* */\r
 159 \r
 160 valueLeaf       root;                           /* radice dell'AST */\r
 161 \r
 162 int                     numErr=0;\r
 163 \r
 164 /* ************************************************************************* */\r
 165 \r
 166 int                     yylex(YYSTYPE *lvalp,YYLTYPE *llocp,void *p);\r
 167 void            yyerror(const YYLTYPE *locp,void *p,char const *msg);\r
 168 valueLeaf       *treeAlloc(\\r
 169                                 vEnum id,\\r
 170                                 _DWORD_ dwordValue,\\r
 171                                 _WORD_ wordValue,\\r
 172                                 _BYTE_ byteValue,\\r
 173                                 unsigned long int inumValue,\\r
 174                                 char *stringValue,\\r
 175                                 valueLeaf *param1,\\r
 176                                 valueLeaf *param2,\\r
 177                                 valueLeaf *param3,\\r
 178                                 const YYLTYPE *locp);\r
 179 \r
 180 valueLeaf       *treeDwordAlloc(_DWORD_ dwordValue,const YYLTYPE *locp);\r
 181 valueLeaf       *treeWordAlloc(_WORD_ wordValue,const YYLTYPE *locp);\r
 182 valueLeaf       *treeByteAlloc(_BYTE_ byteValue,const YYLTYPE *locp);\r
 183 valueLeaf       *treeInumAlloc(unsigned long int inumValue,const YYLTYPE *locp);\r
 184 valueLeaf       *treeStringAlloc(char *stringValue,const YYLTYPE *locp);\r
 185 valueLeaf       *treeId0Alloc(vEnum id,const YYLTYPE *locp);\r
 186 valueLeaf       *treeId1Alloc(vEnum id,valueLeaf *param1,const YYLTYPE *locp);\r
 187 valueLeaf       *treeId2Alloc(vEnum id,valueLeaf *param1,valueLeaf *param2,const YYLTYPE *locp);\r
 188 valueLeaf       *treeId3Alloc(vEnum id,valueLeaf *param1,valueLeaf *param2,valueLeaf *param3,const YYLTYPE *locp);\r
 189 \r
 190 void prettyPrint(valueLeaf *cur,int indent);\r
 191 \r
 192 /* ************************************************************************* */\r
 193 \r
 194 %}\r
 195 \r
 196 %locations\r
 197 %pure-parser\r
 198 %lex-param              {void *p}\r
 199 %parse-param    {void *p}\r
 200 %error-verbose\r
 201 \r
 202 /* ************************************************************************* */\r
 203 \r
 204 /* keyword */\r
 205 %token          Keyword_STRUCT          Keyword_ARRAY           Keyword_OF                      \r
 206 %token          Keyword_IF                      Keyword_ELSIF           Keyword_ELSE            Keyword_WHILE           Keyword_CONST\r
 207 %token          Keyword_B2W                     Keyword_B2DW            Keyword_W2B                     Keyword_W2DW            Keyword_DW2B            Keyword_DW2W\r
 208 \r
 209 /* tipi nativi */\r
 210 %token          Type_BYTE                       Type_WORD                       Type_DWORD\r
 211 \r
 212 /* parentesi */\r
 213 %token          OpenBracket_BODY        CloseBracket_BODY\r
 214 %token          OpenBracket_SQUARE      CloseBracket_SQUARE\r
 215 %token          OpenBracket_ROUND       CloseBracket_ROUND\r
 216 \r
 217 /* operatori unari */\r
 218 %token          UnaryOperator_NOT       UnaryOperator_COM\r
 219 \r
 220 /* operatori duali */\r
 221 %token          DualOperator_AND        DualOperator_OR         DualOperator_XOR\r
 222 %token          DualOperator_ADD        DualOperator_SUB        DualOperator_MUL        DualOperator_DIV\r
 223 %token          DualOperator_NEQ        DualOperator_EQ         DualOperator_LT         DualOperator_GT         DualOperator_LTE        DualOperator_GTE\r
 224 %token          DualOperator_ASG        DualOperator_SHR        DualOperator_SHL\r
 225 \r
 226 /* separatori */\r
 227 %token          Separator_COLUMN        Separator_SELECT        Separator_COMMA\r
 228 \r
 229 /* valori */\r
 230 %token          Value_DWORD                     Value_WORD                      Value_BYTE                      Value_INUM                      Value_STRING\r
 231 \r
 232 /* ************************************************************************* */\r
 233 \r
 234 %start          _start_\r
 235 \r
 236 /* priorita' minima */\r
 237 \r
 238 %right          Separator_COMMA\r
 239 \r
 240 %nonassoc       DualOperator_ASG\r
 241 \r
 242 %nonassoc       Keyword_B2W                     Keyword_B2DW            Keyword_W2B             Keyword_W2DW            Keyword_DW2B            Keyword_DW2W\r
 243 \r
 244 %left           DualOperator_OR\r
 245 %left           DualOperator_XOR\r
 246 %left           DualOperator_AND\r
 247 \r
 248 %nonassoc       DualOperator_NEQ\r
 249 %nonassoc       DualOperator_EQ\r
 250 %nonassoc       DualOperator_GTE\r
 251 %nonassoc       DualOperator_GT\r
 252 %nonassoc       DualOperator_LTE\r
 253 %nonassoc       DualOperator_LT\r
 254 \r
 255 %left           DualOperator_SHR\r
 256 %left           DualOperator_SHL\r
 257 %left           DualOperator_SUB\r
 258 %left           DualOperator_ADD\r
 259 %left           DualOperator_DIV\r
 260 %left           DualOperator_MUL\r
 261 \r
 262 %nonassoc       UnaryOperator_SUB\r
 263 %nonassoc       UnaryOperator_COM\r
 264 %nonassoc       UnaryOperator_NOT\r
 265 \r
 266 %right          Separator_SELECT\r
 267 %right          Separator_COLUMN\r
 268 \r
 269 %nonassoc       OpenBracket_SQUARE      CloseBracket_SQUARE\r
 270 %nonassoc       OpenBracket_ROUND       CloseBracket_ROUND      \r
 271 %nonassoc       OpenBracket_BODY        CloseBracket_BODY\r
 272 \r
 273 /* priorita' massima */ \r
 274 \r
 275 /* ************************************************************************* */\r
 276 \r
 277 %%\r
 278 \r
 279 /* ** FUNZIONE PRINCIPALE ** */\r
 280 _start_                 :       OpenBracket_BODY _decl_lst_ CloseBracket_BODY\r
 281                                                 { memcpy(&root,$2,sizeof(valueLeaf)); };\r
 282 \r
 283 /* ** GESTIONE DICHIARAZIONI ** */\r
 284 _decl_lst_              :       Keyword_CONST _type_ Value_STRING DualOperator_ASG _init_choice_ Separator_COLUMN _decl_lst_\r
 285                                                 {\r
 286                                                 $$=treeId3Alloc(E_DECL_CONST,$2,$3,$5,&@1);\r
 287                                                 $$->next=$7;\r
 288                                                 }|\r
 289                                         _type_ Value_STRING _init_ Separator_COLUMN _decl_lst_\r
 290                                                 {\r
 291                                                 $$=treeId3Alloc(E_DECL_VAR,$1,$2,$3,&@1);\r
 292                                                 $$->next=$5;\r
 293                                                 }|\r
 294                                         _stm_lst_\r
 295                                                 { $$=$1; };\r
 296 \r
 297 _type_                  :       Keyword_ARRAY OpenBracket_SQUARE Value_INUM CloseBracket_SQUARE Keyword_OF _type_\r
 298                                                 {\r
 299                                                 if(!($3->inumValue))\r
 300                                                         { yyerror(&@1,p,"unallowed empty array"); }\r
 301                                                 else\r
 302                                                         {\r
 303                                                         $$=treeId2Alloc(E_TYPE_ARRAY,$3,$6,&@1);\r
 304                                                         $3->inumValue--;\r
 305                                                         }\r
 306                                                 }|\r
 307                                         Keyword_STRUCT OpenBracket_BODY _type_ Separator_COLUMN _type_lst_ CloseBracket_BODY\r
 308                                                 {\r
 309                                                 $$=treeId1Alloc(E_TYPE_STRUCT,$3,&@1);\r
 310                                                 $3->next=$5;\r
 311                                                 }|\r
 312                                         Type_DWORD\r
 313                                                 { $$=treeId0Alloc(E_TYPE_DWORD,&@1); }|\r
 314                                         Type_WORD\r
 315                                                 { $$=treeId0Alloc(E_TYPE_WORD,&@1); }|\r
 316                                         Type_BYTE\r
 317                                                 { $$=treeId0Alloc(E_TYPE_BYTE,&@1); };\r
 318 \r
 319 _type_lst_              :       _type_ Separator_COLUMN _type_lst_\r
 320                                                 {\r
 321                                                 $1->next=$3;\r
 322                                                 $$=$1;\r
 323                                                 }|\r
 324                                         /* epsilon */\r
 325                                                 { $$=NULL; };\r
 326 \r
 327 _init_                  :       DualOperator_ASG _init_choice_\r
 328                                                 { $$=$2; }|\r
 329                                         /* epsilon */\r
 330                                                 { $$=NULL; };\r
 331 \r
 332 _init_choice_   :       _init_val_\r
 333                                                 { $$=$1; }|\r
 334                                         _var_\r
 335                                                 { $$=$1; };\r
 336 \r
 337 _init_val_              :       OpenBracket_SQUARE _init_val_ _init_val_lst_ CloseBracket_SQUARE\r
 338                                                 {\r
 339                                                 $$=treeId1Alloc(E_VALUE_ARRAY,$2,&@1);\r
 340                                                 $2->next=$3;\r
 341                                                 }|\r
 342                                         OpenBracket_BODY _init_val_ _init_val_lst_ CloseBracket_BODY\r
 343                                                 {\r
 344                                                 $$=treeId1Alloc(E_VALUE_STRUCT,$2,&@1);\r
 345                                                 $2->next=$3;\r
 346                                                 }|\r
 347                                         Value_DWORD\r
 348                                                 { $$=$1; }|\r
 349                                         Value_WORD\r
 350                                                 { $$=$1; }|\r
 351                                         Value_BYTE\r
 352                                                 { $$=$1; };\r
 353 \r
 354 _init_val_lst_  :       Separator_COMMA _init_val_ _init_val_lst_\r
 355                                                 {\r
 356                                                 $2->next=$3;\r
 357                                                 $$=$2;\r
 358                                                 }|\r
 359                                         /* epsilon */\r
 360                                                 { $$=NULL; };\r
 361 \r
 362 /* ** GESTIONE STATEMENT ** */\r
 363 _stm_lst_               :       _var_ DualOperator_ASG _expr_ Separator_COLUMN _stm_lst_\r
 364                                                 {\r
 365                                                 $$=treeId2Alloc(E_STM_ASG,$1,$3,&@1);\r
 366                                                 $$->next=$5;\r
 367                                                 }|\r
 368                                         Keyword_WHILE OpenBracket_ROUND _expr_ CloseBracket_ROUND OpenBracket_BODY _decl_lst_ CloseBracket_BODY _stm_lst_\r
 369                                                 {\r
 370                                                 $$=treeId2Alloc(E_STM_WHILE,$3,$6,&@1);\r
 371                                                 $$->next=$8;\r
 372                                                 }|\r
 373                                         Keyword_IF OpenBracket_ROUND _expr_ CloseBracket_ROUND OpenBracket_BODY _decl_lst_ CloseBracket_BODY _elsif_lst_ _else_ _stm_lst_\r
 374                                                 {\r
 375                                                 $$=treeId2Alloc(E_STM_IF,treeId2Alloc(E_STM_IFEXPRBODY,$3,$6,&@1),$9,&@1);\r
 376                                                 $$->param1->next=$8;\r
 377                                                 $$->next=$10;\r
 378                                                 }|\r
 379                                         /* epsilon */\r
 380                                                 { $$=NULL; };\r
 381 \r
 382 _elsif_lst_             :       Keyword_ELSIF OpenBracket_ROUND _expr_ CloseBracket_ROUND OpenBracket_BODY _decl_lst_ CloseBracket_BODY _elsif_lst_\r
 383                                                 {\r
 384                                                 $$=treeId2Alloc(E_STM_IFEXPRBODY,$3,$6,&@1);\r
 385                                                 $$->next=$8;\r
 386                                                 }|\r
 387                                         /* epsilon */\r
 388                                                 { $$=NULL; };\r
 389 \r
 390 _else_                  :       Keyword_ELSE OpenBracket_BODY _decl_lst_ CloseBracket_BODY\r
 391                                                 { $$=$3; }|\r
 392                                         /* epsilon */\r
 393                                                 { $$=NULL; }\r
 394 \r
 395 _expr_                  :       OpenBracket_ROUND _expr_ CloseBracket_ROUND\r
 396                                                 { $$=$2; }|\r
 397                                         UnaryOperator_NOT _expr_\r
 398                                                 { $$=treeId1Alloc(E_EXPR_NOT,$2,&@1); }|\r
 399                                         UnaryOperator_COM _expr_\r
 400                                                 { $$=treeId1Alloc(E_EXPR_COM,$2,&@1); }|\r
 401                                         DualOperator_SUB _expr_ %prec UnaryOperator_SUB\r
 402                                                 { $$=treeId1Alloc(E_EXPR_NEG,$2,&@1); }|\r
 403                                         Keyword_B2W OpenBracket_ROUND _expr_ CloseBracket_ROUND\r
 404                                                 { $$=treeId1Alloc(E_EXPR_B2W,$3,&@1); }|\r
 405                                         Keyword_B2DW OpenBracket_ROUND _expr_ CloseBracket_ROUND\r
 406                                                 { $$=treeId1Alloc(E_EXPR_B2DW,$3,&@1); }|\r
 407                                         Keyword_W2B OpenBracket_ROUND _expr_ CloseBracket_ROUND\r
 408                                                 { $$=treeId1Alloc(E_EXPR_W2B,$3,&@1); }|\r
 409                                         Keyword_W2DW OpenBracket_ROUND _expr_ CloseBracket_ROUND\r
 410                                                 { $$=treeId1Alloc(E_EXPR_W2DW,$3,&@1); }|\r
 411                                         Keyword_DW2B OpenBracket_ROUND _expr_ CloseBracket_ROUND\r
 412                                                 { $$=treeId1Alloc(E_EXPR_DW2B,$3,&@1); }|\r
 413                                         Keyword_DW2W OpenBracket_ROUND _expr_ CloseBracket_ROUND\r
 414                                                 { $$=treeId1Alloc(E_EXPR_DW2W,$3,&@1); }|\r
 415                                         _expr_ DualOperator_MUL _expr_\r
 416                                                 { $$=treeId2Alloc(E_EXPR_MUL,$1,$3,&@1); }|\r
 417                                         _expr_ DualOperator_DIV _expr_\r
 418                                                 { $$=treeId2Alloc(E_EXPR_DIV,$1,$3,&@1); }|\r
 419                                         _expr_ DualOperator_ADD _expr_\r
 420                                                 { $$=treeId2Alloc(E_EXPR_ADD,$1,$3,&@1); }|\r
 421                                         _expr_ DualOperator_SUB _expr_\r
 422                                                 { $$=treeId2Alloc(E_EXPR_SUB,$1,$3,&@1); }|\r
 423                                         _expr_ DualOperator_SHL _expr_\r
 424                                                 { $$=treeId2Alloc(E_EXPR_SHL,$1,$3,&@1); }|\r
 425                                         _expr_ DualOperator_SHR _expr_\r
 426                                                 { $$=treeId2Alloc(E_EXPR_SHR,$1,$3,&@1); }|\r
 427                                         _expr_ DualOperator_LT _expr_\r
 428                                                 { $$=treeId2Alloc(E_EXPR_LT,$1,$3,&@1); }|\r
 429                                         _expr_ DualOperator_LTE _expr_\r
 430                                                 { $$=treeId2Alloc(E_EXPR_LTE,$1,$3,&@1); }|\r
 431                                         _expr_ DualOperator_GT _expr_\r
 432                                                 { $$=treeId2Alloc(E_EXPR_GT,$1,$3,&@1); }|\r
 433                                         _expr_ DualOperator_GTE _expr_\r
 434                                                 { $$=treeId2Alloc(E_EXPR_GTE,$1,$3,&@1); }|\r
 435                                         _expr_ DualOperator_NEQ _expr_\r
 436                                                 { $$=treeId2Alloc(E_EXPR_NEQ,$1,$3,&@1); }|\r
 437                                         _expr_ DualOperator_EQ _expr_\r
 438                                                 { $$=treeId2Alloc(E_EXPR_EQ,$1,$3,&@1); }|\r
 439                                         _expr_ DualOperator_AND _expr_\r
 440                                                 { $$=treeId2Alloc(E_EXPR_AND,$1,$3,&@1); }|\r
 441                                         _expr_ DualOperator_OR _expr_\r
 442                                                 { $$=treeId2Alloc(E_EXPR_OR,$1,$3,&@1); }|\r
 443                                         _expr_ DualOperator_XOR _expr_\r
 444                                                 { $$=treeId2Alloc(E_EXPR_XOR,$1,$3,&@1); }|\r
 445                                         Value_DWORD\r
 446                                                 { $$=$1; }|\r
 447                                         Value_WORD\r
 448                                                 { $$=$1; }|\r
 449                                         Value_BYTE\r
 450                                                 { $$=$1; }|\r
 451                                         _var_\r
 452                                                 { $$=treeId1Alloc(E_EXPR_VAR,$1,&@1); };\r
 453 \r
 454 _var_                   :       Value_STRING _var_sub_\r
 455                                                 {\r
 456                                                 if($2)\r
 457                                                         {\r
 458                                                         $$=$2;\r
 459                                                         $$->last->next=treeId1Alloc(E_VAR_ROOT,$1,&@1);\r
 460                                                         }\r
 461                                                 else\r
 462                                                         { $$=treeId1Alloc(E_VAR_ROOT,$1,&@1); }\r
 463                                                 };\r
 464 \r
 465 _var_sub_               :       Separator_SELECT Value_INUM _var_sub_\r
 466                                                 {\r
 467                                                 if($3)\r
 468                                                         {\r
 469                                                         valueLeaf       *tmp=treeId1Alloc(E_VAR_STRUCT,$2,&@1);\r
 470 \r
 471                                                         $$=$3;\r
 472                                                         $$->last->next=tmp;\r
 473                                                         $$->last=tmp;\r
 474                                                         }\r
 475                                                 else\r
 476                                                         {\r
 477                                                         $$=treeId1Alloc(E_VAR_STRUCT,$2,&@1);\r
 478                                                         $$->last=$$;\r
 479                                                         }\r
 480                                                 }|\r
 481                                         OpenBracket_SQUARE _expr_ CloseBracket_SQUARE _var_sub_\r
 482                                                 {\r
 483                                                 if($4)\r
 484                                                         {\r
 485                                                         valueLeaf       *tmp=treeId1Alloc(E_VAR_ARRAY,$2,&@1);\r
 486 \r
 487                                                         $$=$4;\r
 488                                                         $$->last->next=tmp;\r
 489                                                         $$->last=tmp;\r
 490                                                         }\r
 491                                                 else\r
 492                                                         {\r
 493                                                         $$=treeId1Alloc(E_VAR_ARRAY,$2,&@1);\r
 494                                                         $$->last=$$;\r
 495                                                         }\r
 496                                                 }|\r
 497                                         /* epsilon */\r
 498                                                 { $$=NULL; };\r
 499 \r
 500 /* ************************************************************************* */\r
 501 \r
 502 %%\r
 503 \r
 504 void yyerror(const YYLTYPE *locp,void *p,char const *msg)\r
 505 {\r
 506         if(locp->first_line>=0)\r
 507                 { printf("%s:%d,%d\tParsError: %s%c",locp->source,locp->first_line,locp->first_column,msg,SEP); }\r
 508         else\r
 509                 { printf(":0,0\tParsError: %s%c",msg,SEP); }\r
 510 \r
 511         numErr++;\r
 512 \r
 513         return;\r
 514 }\r
 515 \r
 516 valueLeaf       *treeAlloc(\\r
 517                                 vEnum id,\\r
 518                                 _DWORD_ dwordValue,\\r
 519                                 _WORD_ wordValue,\\r
 520                                 _BYTE_ byteValue,\\r
 521                                 unsigned long int inumValue,\\r
 522                                 char *stringValue,\\r
 523                                 valueLeaf *param1,\\r
 524                                 valueLeaf *param2,\\r
 525                                 valueLeaf *param3,\\r
 526                                 const YYLTYPE *locp)\r
 527 {\r
 528         valueLeaf       *tmp;\r
 529 \r
 530         if(!(tmp=(valueLeaf *) myMalloc(sizeof(valueLeaf))))\r
 531                 {\r
 532                 printf("[%s:%d] ParsError:OutOfMemory%c",__FILE__,__LINE__,SEP);\r
 533                 exit(ERR_EXIT);\r
 534                 }\r
 535 \r
 536         memset(tmp,0,sizeof(valueLeaf));\r
 537 \r
 538         tmp->id=id;\r
 539         tmp->dwordValue=dwordValue;\r
 540         tmp->wordValue=wordValue;\r
 541         tmp->byteValue=byteValue;\r
 542         tmp->inumValue=inumValue;\r
 543         tmp->stringValue=stringValue;\r
 544         tmp->param1=param1;\r
 545         tmp->param2=param2;\r
 546         tmp->param3=param3;\r
 547 \r
 548         return(tmp);\r
 549 }\r
 550 \r
 551 valueLeaf *treeDwordAlloc(_DWORD_ dwordValue,const YYLTYPE *locp)\r
 552 { return(treeAlloc(E_VALUE_DWORD,dwordValue,0,0,0,NULL,NULL,NULL,NULL,locp)); }\r
 553 \r
 554 valueLeaf *treeWordAlloc(_WORD_ wordValue,const YYLTYPE *locp)\r
 555 { return(treeAlloc(E_VALUE_WORD,0,wordValue,0,0,NULL,NULL,NULL,NULL,locp)); }\r
 556 \r
 557 valueLeaf *treeByteAlloc(_BYTE_ byteValue,const YYLTYPE *locp)\r
 558 { return(treeAlloc(E_VALUE_BYTE,0,0,byteValue,0,NULL,NULL,NULL,NULL,locp)); }\r
 559 \r
 560 valueLeaf *treeInumAlloc(unsigned long int inumValue,const YYLTYPE *locp)\r
 561 { return(treeAlloc(E_VALUE_INUM,0,0,0,inumValue,NULL,NULL,NULL,NULL,locp)); }\r
 562 \r
 563 valueLeaf *treeStringAlloc(char *stringValue,const YYLTYPE *locp)\r
 564 { return(treeAlloc(E_VALUE_STRING,0,0,0,0,stringValue,NULL,NULL,NULL,locp)); }\r
 565 \r
 566 valueLeaf *treeId0Alloc(vEnum id,const YYLTYPE *locp)\r
 567 { return(treeAlloc(id,0,0,0,0,NULL,NULL,NULL,NULL,locp)); }\r
 568 \r
 569 valueLeaf *treeId1Alloc(vEnum id,valueLeaf *param1,const YYLTYPE *locp)\r
 570 { return(treeAlloc(id,0,0,0,0,NULL,param1,NULL,NULL,locp)); }\r
 571 \r
 572 valueLeaf *treeId2Alloc(vEnum id,valueLeaf *param1,valueLeaf *param2,const YYLTYPE *locp)\r
 573 { return(treeAlloc(id,0,0,0,0,NULL,param1,param2,NULL,locp)); }\r
 574 \r
 575 valueLeaf *treeId3Alloc(vEnum id,valueLeaf *param1,valueLeaf *param2,valueLeaf *param3,const YYLTYPE *locp)\r
 576 { return(treeAlloc(id,0,0,0,0,NULL,param1,param2,param3,locp)); }\r
 577 \r
 578 /* riconoscimento token da input */\r
 579 int yylex(YYSTYPE *lvalp,YYLTYPE *llocp,void *p)\r
 580 {\r
 581         char    bufLine[256];\r
 582         char    bufToken[256];\r
 583         char    bufString[256];\r
 584         char    *tmp1,*tmp2;\r
 585 \r
 586         /* riconoscimento di source:linea,colonna */\r
 587         fscanf(stdin,"%s%s%s\n",bufLine,bufToken,bufString,SEP);\r
 588 \r
 589         if(!strcmp(bufToken,"ERR"))\r
 590                 {\r
 591                 printf("%s\t%s%c",bufLine,bufString,SEP);\r
 592                 exit(ERR_EXIT);\r
 593                 }\r
 594 \r
 595         for(tmp1=bufLine;*tmp1!=':';tmp1++);\r
 596         *tmp1=0;\r
 597 \r
 598         for(tmp2=tmp1+1;*tmp2!=',';tmp2++);\r
 599         *tmp2=0;\r
 600 \r
 601         llocp->first_line=llocp->last_line=atoi(tmp1+1);\r
 602         llocp->first_column=llocp->last_column=atoi(tmp2+1);\r
 603 \r
 604         if(!(llocp->source=(char *) myMalloc(strlen(bufLine)+1)))\r
 605                 {\r
 606                 printf("[%s:%d] ParsError:OutOfMemory%c",__FILE__,__LINE__,SEP);\r
 607                 exit(ERR_EXIT);\r
 608                 }\r
 609 \r
 610         *llocp->source=0;\r
 611         strcpy(llocp->source,bufLine);\r
 612 \r
 613         *tmp1=':';\r
 614         *tmp2=',';\r
 615 \r
 616         /* analisi */\r
 617         if(!strcmp(bufToken,"OK"))\r
 618                 {\r
 619                 root.source=llocp->source;\r
 620                 root.fileLine=llocp->first_line;\r
 621                 root.fileRow=llocp->first_column;\r
 622 \r
 623                 return yylex(lvalp,llocp,p);\r
 624                 }\r
 625         else if(!strcmp(bufToken,"EOF"))\r
 626                 { return(0); }\r
 627 \r
 628         /* categoria keyword */\r
 629         if(!strcmp(bufToken,"KEW"))\r
 630                 {\r
 631                 if(!strcmp(bufString,"struct"))\r
 632                         { return(Keyword_STRUCT); }\r
 633                 else if(!strcmp(bufString,"array"))\r
 634                         { return(Keyword_ARRAY); }\r
 635                 else if(!strcmp(bufString,"of"))\r
 636                         { return(Keyword_OF); }\r
 637                 else if(!strcmp(bufString,"if"))\r
 638                         { return(Keyword_IF); }\r
 639                 else if(!strcmp(bufString,"elsif"))\r
 640                         { return(Keyword_ELSIF); }\r
 641                 else if(!strcmp(bufString,"else"))\r
 642                         { return(Keyword_ELSE); }\r
 643                 else if(!strcmp(bufString,"while"))\r
 644                         { return(Keyword_WHILE); }\r
 645                 else if(!strcmp(bufString,"const"))\r
 646                         { return(Keyword_CONST); }\r
 647                 else if(!strcmp(bufString,"b2w"))\r
 648                         { return(Keyword_B2W); }\r
 649                 else if(!strcmp(bufString,"b2dw"))\r
 650                         { return(Keyword_B2DW); }\r
 651                 else if(!strcmp(bufString,"w2b"))\r
 652                         { return(Keyword_W2B); }\r
 653                 else if(!strcmp(bufString,"w2dw"))\r
 654                         { return(Keyword_W2DW); }\r
 655                 else if(!strcmp(bufString,"dw2b"))\r
 656                         { return(Keyword_DW2B); }\r
 657                 else if(!strcmp(bufString,"dw2w"))\r
 658                         { return(Keyword_DW2W); }\r
 659                 else\r
 660                         {\r
 661                         printf("%s\tParsError:UnknownKeywordToken(%s)%c",bufLine,bufString,SEP);\r
 662                         exit(ERR_EXIT);\r
 663                         }\r
 664                 }\r
 665         /* categoria tipo nativo */\r
 666         else if(!strcmp(bufToken,"TYP"))\r
 667                 {\r
 668                 if(!strcmp(bufString,"dword"))\r
 669                         { return(Type_DWORD); }\r
 670                 else if(!strcmp(bufString,"word"))\r
 671                         { return(Type_WORD); }\r
 672                 else if(!strcmp(bufString,"byte"))\r
 673                         { return(Type_BYTE); }\r
 674                 else\r
 675                         {\r
 676                         printf("%s\tParsError:UnknownTypeToken(%s)%c",bufLine,bufString,SEP);\r
 677                         exit(ERR_EXIT);\r
 678                         }\r
 679                 }\r
 680         /* categoria parentesi */\r
 681         else if(!strcmp(bufToken,"BRK"))\r
 682                 {\r
 683                 if(!strcmp(bufString,"{"))\r
 684                         { return(OpenBracket_BODY); }\r
 685                 else if(!strcmp(bufString,"}"))\r
 686                         { return(CloseBracket_BODY); }\r
 687                 else if(!strcmp(bufString,"["))\r
 688                         { return(OpenBracket_SQUARE); }\r
 689                 else if(!strcmp(bufString,"]"))\r
 690                         { return(CloseBracket_SQUARE); }\r
 691                 else if(!strcmp(bufString,"("))\r
 692                         { return(OpenBracket_ROUND); }\r
 693                 else if(!strcmp(bufString,")"))\r
 694                         { return(CloseBracket_ROUND); }\r
 695                 else\r
 696                         {\r
 697                         printf("%s\tParsError:UnknownBracketToken(%s)%c",bufLine,bufString,SEP);\r
 698                         exit(ERR_EXIT);\r
 699                         }\r
 700                 }\r
 701         /* categoria operatore unario */\r
 702         else if(!strcmp(bufToken,"MOP"))\r
 703                 {\r
 704                 if(!strcmp(bufString,"!"))\r
 705                         { return(UnaryOperator_NOT); }\r
 706                 else if(!strcmp(bufString,"~"))\r
 707                         { return(UnaryOperator_COM); }\r
 708                 else\r
 709                         {\r
 710                         printf("%s\tParsError:UnknownUnaryOperatorToken(%s)%c",bufLine,bufString,SEP);\r
 711                         exit(ERR_EXIT);\r
 712                         }\r
 713                 }\r
 714         /* categoria operatore duale */\r
 715         else if(!strcmp(bufToken,"DOP"))\r
 716                 {\r
 717                 if(!strcmp(bufString,"&"))\r
 718                         { return(DualOperator_AND); }\r
 719                 else if(!strcmp(bufString,"|"))\r
 720                         { return(DualOperator_OR); }\r
 721                 else if(!strcmp(bufString,"^"))\r
 722                         { return(DualOperator_XOR); }\r
 723                 else if(!strcmp(bufString,"+"))\r
 724                         { return(DualOperator_ADD); }\r
 725                 else if(!strcmp(bufString,"-"))\r
 726                         { return(DualOperator_SUB); }\r
 727                 else if(!strcmp(bufString,"*"))\r
 728                         { return(DualOperator_MUL); }\r
 729                 else if(!strcmp(bufString,"/"))\r
 730                         { return(DualOperator_DIV); }\r
 731                 else if(!strcmp(bufString,"!="))\r
 732                         { return(DualOperator_NEQ); }\r
 733                 else if(!strcmp(bufString,"=="))\r
 734                         { return(DualOperator_EQ); }\r
 735                 else if(!strcmp(bufString,"<"))\r
 736                         { return(DualOperator_LT); }\r
 737                 else if(!strcmp(bufString,">"))\r
 738                         { return(DualOperator_GT); }\r
 739                 else if(!strcmp(bufString,"<="))\r
 740                         { return(DualOperator_LTE); }\r
 741                 else if(!strcmp(bufString,">="))\r
 742                         { return(DualOperator_GTE); }\r
 743                 else if(!strcmp(bufString,">>"))\r
 744                         { return(DualOperator_SHR); }\r
 745                 else if(!strcmp(bufString,"<<"))\r
 746                         { return(DualOperator_SHL); }\r
 747                 else if(!strcmp(bufString,"="))\r
 748                         { return(DualOperator_ASG); }\r
 749                 else\r
 750                         {\r
 751                         printf("%s\tParsError:UnknownDualOperatorToken(%s)%c",bufLine,bufString,SEP);\r
 752                         exit(ERR_EXIT);\r
 753                         }\r
 754                 }\r
 755         /* categoria separatore */\r
 756         else if(!strcmp(bufToken,"SEP"))\r
 757                 {\r
 758                 if(!strcmp(bufString,";"))\r
 759                         { return(Separator_COLUMN); }\r
 760                 else if(!strcmp(bufString,"."))\r
 761                         { return(Separator_SELECT); }\r
 762                 else if(!strcmp(bufString,","))\r
 763                         { return(Separator_COMMA); }\r
 764                 else\r
 765                         {\r
 766                         printf("%s\tParsError:UnknownSeparatorToken(%s)%c",bufLine,bufString,SEP);\r
 767                         exit(ERR_EXIT);\r
 768                         }\r
 769                 }\r
 770         /* categoria dword */\r
 771         else if(!strcmp(bufToken,"W32"))\r
 772                 {\r
 773                 unsigned long int       tmpI;\r
 774 \r
 775                 if(sscanf(bufString,"0x%lx",&tmpI)==1)\r
 776                         {\r
 777                         *lvalp=treeDwordAlloc((_DWORD_) (tmpI&0xFFFFFFFF),llocp);\r
 778                         return(Value_DWORD);\r
 779                         }\r
 780                 else\r
 781                         {\r
 782                         printf("%s\tParsError:UnknownIntToken(%s)%c",bufLine,bufString,SEP);\r
 783                         exit(ERR_EXIT);\r
 784                         }\r
 785                 }\r
 786         /* categoria word */\r
 787         else if(!strcmp(bufToken,"W16"))\r
 788                 {\r
 789                 unsigned long int       tmpI;\r
 790 \r
 791                 if(sscanf(bufString,"0x%lx",&tmpI)==1)\r
 792                         {\r
 793                         *lvalp=treeWordAlloc((_WORD_) (tmpI&0xFFFF),llocp);\r
 794                         return(Value_WORD);\r
 795                         }\r
 796                 else\r
 797                         {\r
 798                         printf("%s\tParsError:UnknownIntToken(%s)%c",bufLine,bufString,SEP);\r
 799                         exit(ERR_EXIT);\r
 800                         }\r
 801                 }\r
 802         /* categoria byte */\r
 803         else if(!strcmp(bufToken,"BY8"))\r
 804                 {\r
 805                 unsigned long int       tmpI;\r
 806 \r
 807                 if(sscanf(bufString,"0x%lx",&tmpI)==1)\r
 808                         {\r
 809                         *lvalp=treeByteAlloc((_BYTE_) (tmpI&0xFF),llocp);\r
 810                         return(Value_BYTE);\r
 811                         }\r
 812                 else\r
 813                         {\r
 814                         printf("%s\tParsError:UnknownIntToken(%s)%c",bufLine,bufString,SEP);\r
 815                         exit(ERR_EXIT);\r
 816                         }\r
 817                 }\r
 818         /* categoria numero intero */\r
 819         else if(!strcmp(bufToken,"INU"))\r
 820                 {\r
 821                 unsigned long int       tmpI;\r
 822 \r
 823                 if(sscanf(bufString,"%lu",&tmpI)==1)\r
 824                         {\r
 825                         *lvalp=treeInumAlloc(tmpI,llocp);\r
 826                         return(Value_INUM);\r
 827                         }\r
 828                 else\r
 829                         {\r
 830                         printf("%s\tParsError:UnknownIntToken(%s)%c",bufLine,bufString,SEP);\r
 831                         exit(ERR_EXIT);\r
 832                         }\r
 833                 }\r
 834         /* categoria ID == stringa */\r
 835         else if(!strcmp(bufToken,"IID"))\r
 836                 {\r
 837                 char            *tmpS;\r
 838 \r
 839                 if(!(tmpS=(char *) myMalloc(strlen(bufString)+1)))\r
 840                         {\r
 841                         printf("[%s:%d] ParsError:OutOfMemory%c",__FILE__,__LINE__,SEP);\r
 842                         exit(ERR_EXIT);\r
 843                         }\r
 844 \r
 845                 *tmpS=0;\r
 846                 strcpy(tmpS,bufString);\r
 847 \r
 848                 *lvalp=treeStringAlloc(tmpS,llocp);\r
 849                 return(Value_STRING);\r
 850                 }\r
 851         else\r
 852                 {\r
 853                 printf("%s\tParsError:UnknownToken(%s)%c",bufLine,bufString,SEP);\r
 854                 exit(ERR_EXIT);\r
 855                 }\r
 856 }\r
 857 \r
 858 void usage(char *name)\r
 859 {\r
 860         printf("\nC Parser - Cosimo Oliboni\n\n");\r
 861         printf("\"%s\" parsing da stdin\n\n",name);\r
 862 \r
 863         return;\r
 864 }\r
 865 \r
 866 void prettyPrintString(char *str)\r
 867 {\r
 868         printf("([");\r
 869 \r
 870         while(*str)\r
 871                 {\r
 872                 printf("ch_%c",*str);\r
 873 \r
 874                 if(*(str+1))\r
 875                         { printf(";"); }\r
 876 \r
 877                 str++;\r
 878                 }\r
 879 \r
 880         printf("])");\r
 881 }\r
 882 \r
 883 void prettyPrintByte(_BYTE_ num)\r
 884 {\r
 885         printf("(\\langle x%1X,x%1X \\rangle)",(unsigned int) (num>>4),(unsigned int) (num&0xF));\r
 886 }\r
 887 \r
 888 void prettyPrintWord(_WORD_ num)\r
 889 {\r
 890         printf("(\\langle \\langle x%1X,x%1X \\rangle : \\langle x%1X,x%1X \\rangle \\rangle)",\\r
 891                 (unsigned int) (num>>12),(unsigned int) ((num>>8)&0xF),\\r
 892                 (unsigned int) ((num>>4)&0xF),(unsigned int) (num&0xF));\r
 893 }\r
 894 \r
 895 void prettyPrintDword(_DWORD_ num)\r
 896 {\r
 897         printf("(\\langle \\langle \\langle x%1X,x%1X \\rangle : \\langle x%1X,x%1X \\rangle \\rangle . \\langle \\langle x%1X,x%1X \\rangle : \\langle x%1X,x%1X \\rangle \\rangle \\rangle)",\\r
 898                 (unsigned int) (num>>28),(unsigned int) ((num>>24)&0xF),\\r
 899                 (unsigned int) ((num>>20)&0xF),(unsigned int) ((num>>16)&0xF),\\r
 900                 (unsigned int) ((num>>12)&0xF),(unsigned int) ((num>>8)&0xF),\\r
 901                 (unsigned int) ((num>>4)&0xF),(unsigned int) (num&0xF));\r
 902 }\r
 903 \r
 904 void prettyPrintIndent(int indent)\r
 905 {\r
 906         int     index;\r
 907 \r
 908         for(index=0;index<indent;index++)\r
 909                 { printf(" "); }\r
 910 }\r
 911 \r
 912 void prettyPrintInum(unsigned long int num)\r
 913 {\r
 914         if(!num)\r
 915                 { printf("O\n"); }\r
 916         else\r
 917                 { printf("%lu\n",num); }\r
 918 }\r
 919 \r
 920 void prettyPrintInit(valueLeaf *cur,int indent)\r
 921 {\r
 922         if(cur->id==E_VALUE_BYTE)\r
 923                 { prettyPrintIndent(indent); printf("(PREAST_INIT_VAL_BYTE8 "); prettyPrintByte(cur->byteValue); printf(")\n"); }\r
 924         else if(cur->id==E_VALUE_WORD)\r
 925                 { prettyPrintIndent(indent); printf("(PREAST_INIT_VAL_WORD16 "); prettyPrintWord(cur->wordValue); printf(")\n"); }\r
 926         else if(cur->id==E_VALUE_DWORD)\r
 927                 { prettyPrintIndent(indent); printf("(PREAST_INIT_VAL_WORD32 "); prettyPrintDword(cur->dwordValue); printf(")\n"); }\r
 928         else if(cur->id==E_VALUE_ARRAY)\r
 929                 {\r
 930                 valueLeaf       *tmp=cur->param1;\r
 931 \r
 932                 prettyPrintIndent(indent); printf("(PREAST_INIT_VAL_ARRAY\n");\r
 933 \r
 934                 prettyPrintIndent(indent+1); printf("(\\laquo\n");\r
 935                 if(!tmp->next)\r
 936                         { prettyPrintIndent(indent+2); printf("£\n"); }\r
 937                 while(tmp)\r
 938                         {\r
 939                         prettyPrintInit(tmp,indent+2);\r
 940 \r
 941                         if(tmp->next)\r
 942                                 {\r
 943                                 if(tmp->next->next)\r
 944                                         { prettyPrintIndent(indent+2); printf(";\n"); }\r
 945                                 else\r
 946                                         { prettyPrintIndent(indent+2); printf("£\n"); }\r
 947                                 }\r
 948 \r
 949                         tmp=tmp->next;\r
 950                         }\r
 951                 prettyPrintIndent(indent+1); printf("\\raquo)\n");\r
 952 \r
 953                 prettyPrintIndent(indent); printf(")\n");\r
 954                 }\r
 955         else if(cur->id==E_VALUE_STRUCT)\r
 956                 {\r
 957                 valueLeaf       *tmp=cur->param1;\r
 958 \r
 959                 prettyPrintIndent(indent); printf("(PREAST_INIT_VAL_STRUCT\n");\r
 960 \r
 961                 prettyPrintIndent(indent+1); printf("(\\laquo\n");\r
 962                 if(!tmp->next)\r
 963                         { prettyPrintIndent(indent+2); printf("£\n"); }\r
 964                 while(tmp)\r
 965                         {\r
 966                         prettyPrintInit(tmp,indent+2);\r
 967 \r
 968                         if(tmp->next)\r
 969                                 {\r
 970                                 if(tmp->next->next)\r
 971                                         { prettyPrintIndent(indent+2); printf(";\n"); }\r
 972                                 else\r
 973                                         { prettyPrintIndent(indent+2); printf("£\n"); }\r
 974                                 }\r
 975 \r
 976                         tmp=tmp->next;\r
 977                         }\r
 978                 prettyPrintIndent(indent+1); printf("\\raquo)\n");\r
 979 \r
 980                 prettyPrintIndent(indent); printf(")\n");\r
 981                 }\r
 982 }\r
 983 \r
 984 void prettyPrintBody(valueLeaf *cur,int indent)\r
 985 {\r
 986         if(!cur)\r
 987                 { prettyPrintIndent(indent); printf("(PREAST_NO_DECL [])\n"); }\r
 988         else if((cur->id==E_DECL_CONST)||(cur->id==E_DECL_VAR))\r
 989                 { prettyPrint(cur,indent); }\r
 990         else\r
 991                 {\r
 992                 valueLeaf       *tmp=cur;\r
 993 \r
 994                 prettyPrintIndent(indent); printf("(PREAST_NO_DECL\n");\r
 995 \r
 996                 prettyPrintIndent(indent+1); printf("[\n");\r
 997                 while(tmp)\r
 998                         {\r
 999                         prettyPrint(tmp,indent+2);\r
1000 \r
1001                         if(tmp->next)\r
1002                                 { prettyPrintIndent(indent+2); printf(";\n"); }\r
1003 \r
1004                         tmp=tmp->next;\r
1005                         }\r
1006                 prettyPrintIndent(indent+1); printf("]\n");\r
1007 \r
1008                 prettyPrintIndent(indent); printf(")\n");\r
1009                 }\r
1010 \r
1011 }\r
1012 \r
1013 void prettyPrint(valueLeaf *cur,int indent)\r
1014 {\r
1015         /* ** misc ** */\r
1016         if(cur->id==E_VALUE_STRING)\r
1017                 { prettyPrintIndent(indent); prettyPrintString(cur->stringValue); printf("\n"); }\r
1018         else if(cur->id==E_VALUE_INUM)\r
1019                 { prettyPrintIndent(indent); prettyPrintInum(cur->inumValue); }\r
1020 \r
1021         /* ** tipi ** */\r
1022         else if(cur->id==E_TYPE_BYTE)\r
1023                 { prettyPrintIndent(indent); printf("(AST_TYPE_BASE AST_BASE_TYPE_BYTE8)\n"); }\r
1024         else if(cur->id==E_TYPE_WORD)\r
1025                 { prettyPrintIndent(indent); printf("(AST_TYPE_BASE AST_BASE_TYPE_WORD16)\n"); }\r
1026         else if(cur->id==E_TYPE_DWORD)\r
1027                 { prettyPrintIndent(indent); printf("(AST_TYPE_BASE AST_BASE_TYPE_WORD32)\n"); }\r
1028         else if(cur->id==E_TYPE_ARRAY)\r
1029                 {\r
1030                 prettyPrintIndent(indent); printf("(AST_TYPE_ARRAY\n");\r
1031                 prettyPrint(cur->param2,indent+1);      //type\r
1032                 prettyPrint(cur->param1,indent+1);      //size\r
1033                 prettyPrintIndent(indent); printf(")\n");\r
1034                 }\r
1035         else if(cur->id==E_TYPE_STRUCT)\r
1036                 {\r
1037                 valueLeaf       *tmp=cur->param1;\r
1038 \r
1039                 prettyPrintIndent(indent); printf("(AST_TYPE_STRUCT\n");\r
1040 \r
1041                 prettyPrintIndent(indent+1); printf("(\\laquo\n");\r
1042                 if(!tmp->next)\r
1043                         { prettyPrintIndent(indent+2); printf("£\n"); }\r
1044                 while(tmp)\r
1045                         {\r
1046                         prettyPrint(tmp,indent+2);\r
1047 \r
1048                         if(tmp->next)\r
1049                                 {\r
1050                                 if(tmp->next->next)\r
1051                                         { prettyPrintIndent(indent+2); printf(";\n"); }\r
1052                                 else\r
1053                                         { prettyPrintIndent(indent+2); printf("£\n"); }\r
1054                                 }\r
1055 \r
1056                         tmp=tmp->next;\r
1057                         }\r
1058                 prettyPrintIndent(indent+1); printf("\\raquo)\n");\r
1059 \r
1060                 prettyPrintIndent(indent); printf(")\n");\r
1061                 }\r
1062         \r
1063         /* ** valori come espressioni ** */\r
1064         else if(cur->id==E_VALUE_BYTE)\r
1065                 { prettyPrintIndent(indent); printf("(PREAST_EXPR_BYTE8 "); prettyPrintByte(cur->byteValue); printf(")\n"); }\r
1066         else if(cur->id==E_VALUE_WORD)\r
1067                 { prettyPrintIndent(indent); printf("(PREAST_EXPR_WORD16 "); prettyPrintWord(cur->wordValue); printf(")\n"); }\r
1068         else if(cur->id==E_VALUE_DWORD)\r
1069                 { prettyPrintIndent(indent); printf("(PREAST_EXPR_WORD32 "); prettyPrintDword(cur->dwordValue); printf(")\n"); }\r
1070 \r
1071         /* ** variabili */\r
1072         else if(cur->id==E_VAR_ROOT)\r
1073                 { prettyPrintIndent(indent); printf("(PREAST_VAR_ID "); prettyPrintString(cur->param1->stringValue); printf(")\n"); }\r
1074         else if(cur->id==E_VAR_STRUCT)\r
1075                 {\r
1076                 prettyPrintIndent(indent); printf("(PREAST_VAR_STRUCT\n");\r
1077                 prettyPrint(cur->next,indent+1);\r
1078                 prettyPrint(cur->param1,indent+1);\r
1079                 prettyPrintIndent(indent); printf(")\n");\r
1080                 }\r
1081         else if(cur->id==E_VAR_ARRAY)\r
1082                 {\r
1083                 prettyPrintIndent(indent); printf("(PREAST_VAR_ARRAY\n");\r
1084                 prettyPrint(cur->next,indent+1);\r
1085                 prettyPrint(cur->param1,indent+1);\r
1086                 prettyPrintIndent(indent); printf(")\n");\r
1087                 }\r
1088 \r
1089         /* ** espressioni ** */\r
1090         else if(cur->id==E_EXPR_VAR)\r
1091                 {\r
1092                 prettyPrintIndent(indent); printf("(PREAST_EXPR_ID\n");\r
1093                 prettyPrint(cur->param1,indent+1);\r
1094                 prettyPrintIndent(indent); printf(")\n");\r
1095                 }\r
1096         else if(cur->id==E_EXPR_NOT)\r
1097                 {\r
1098                 prettyPrintIndent(indent); printf("(PREAST_EXPR_NOT\n");\r
1099                 prettyPrint(cur->param1,indent+1);\r
1100                 prettyPrintIndent(indent); printf(")\n");\r
1101                 }\r
1102         else if(cur->id==E_EXPR_COM)\r
1103                 {\r
1104                 prettyPrintIndent(indent); printf("(PREAST_EXPR_COM\n");\r
1105                 prettyPrint(cur->param1,indent+1);\r
1106                 prettyPrintIndent(indent); printf(")\n");\r
1107                 }\r
1108         else if(cur->id==E_EXPR_NEG)\r
1109                 {\r
1110                 prettyPrintIndent(indent); printf("(PREAST_EXPR_NEG\n");\r
1111                 prettyPrint(cur->param1,indent+1);\r
1112                 prettyPrintIndent(indent); printf(")\n");\r
1113                 }\r
1114         else if(cur->id==E_EXPR_B2W)\r
1115                 {\r
1116                 prettyPrintIndent(indent); printf("(PREAST_EXPR_B8toW16\n");\r
1117                 prettyPrint(cur->param1,indent+1);\r
1118                 prettyPrintIndent(indent); printf(")\n");\r
1119                 }\r
1120         else if(cur->id==E_EXPR_B2DW)\r
1121                 {\r
1122                 prettyPrintIndent(indent); printf("(PREAST_EXPR_B8toW32\n");\r
1123                 prettyPrint(cur->param1,indent+1);\r
1124                 prettyPrintIndent(indent); printf(")\n");\r
1125                 }\r
1126         else if(cur->id==E_EXPR_W2B)\r
1127                 {\r
1128                 prettyPrintIndent(indent); printf("(PREAST_EXPR_W16toB8\n");\r
1129                 prettyPrint(cur->param1,indent+1);\r
1130                 prettyPrintIndent(indent); printf(")\n");\r
1131                 }\r
1132         else if(cur->id==E_EXPR_W2DW)\r
1133                 {\r
1134                 prettyPrintIndent(indent); printf("(PREAST_EXPR_W16toW32\n");\r
1135                 prettyPrint(cur->param1,indent+1);\r
1136                 prettyPrintIndent(indent); printf(")\n");\r
1137                 }\r
1138         else if(cur->id==E_EXPR_DW2B)\r
1139                 {\r
1140                 prettyPrintIndent(indent); printf("(PREAST_EXPR_W32toB8\n");\r
1141                 prettyPrint(cur->param1,indent+1);\r
1142                 prettyPrintIndent(indent); printf(")\n");\r
1143                 }\r
1144         else if(cur->id==E_EXPR_DW2W)\r
1145                 {\r
1146                 prettyPrintIndent(indent); printf("(PREAST_EXPR_W32toW16\n");\r
1147                 prettyPrint(cur->param1,indent+1);\r
1148                 prettyPrintIndent(indent); printf(")\n");\r
1149                 }\r
1150         else if(cur->id==E_EXPR_ADD)\r
1151                 {\r
1152                 prettyPrintIndent(indent); printf("(PREAST_EXPR_ADD\n");\r
1153                 prettyPrint(cur->param1,indent+1);\r
1154                 prettyPrint(cur->param2,indent+1);\r
1155                 prettyPrintIndent(indent); printf(")\n");\r
1156                 }\r
1157         else if(cur->id==E_EXPR_SUB)\r
1158                 {\r
1159                 prettyPrintIndent(indent); printf("(PREAST_EXPR_SUB\n");\r
1160                 prettyPrint(cur->param1,indent+1);\r
1161                 prettyPrint(cur->param2,indent+1);\r
1162                 prettyPrintIndent(indent); printf(")\n");\r
1163                 }\r
1164         else if(cur->id==E_EXPR_MUL)\r
1165                 {\r
1166                 prettyPrintIndent(indent); printf("(PREAST_EXPR_MUL\n");\r
1167                 prettyPrint(cur->param1,indent+1);\r
1168                 prettyPrint(cur->param2,indent+1);\r
1169                 prettyPrintIndent(indent); printf(")\n");\r
1170                 }\r
1171         else if(cur->id==E_EXPR_DIV)\r
1172                 {\r
1173                 prettyPrintIndent(indent); printf("(PREAST_EXPR_DIV\n");\r
1174                 prettyPrint(cur->param1,indent+1);\r
1175                 prettyPrint(cur->param2,indent+1);\r
1176                 prettyPrintIndent(indent); printf(")\n");\r
1177                 }\r
1178         else if(cur->id==E_EXPR_SHL)\r
1179                 {\r
1180                 prettyPrintIndent(indent); printf("(PREAST_EXPR_SHL\n");\r
1181                 prettyPrint(cur->param1,indent+1);\r
1182                 prettyPrint(cur->param2,indent+1);\r
1183                 prettyPrintIndent(indent); printf(")\n");\r
1184                 }\r
1185         else if(cur->id==E_EXPR_SHR)\r
1186                 {\r
1187                 prettyPrintIndent(indent); printf("(PREAST_EXPR_SHR\n");\r
1188                 prettyPrint(cur->param1,indent+1);\r
1189                 prettyPrint(cur->param2,indent+1);\r
1190                 prettyPrintIndent(indent); printf(")\n");\r
1191                 }\r
1192         else if(cur->id==E_EXPR_AND)\r
1193                 {\r
1194                 prettyPrintIndent(indent); printf("(PREAST_EXPR_AND\n");\r
1195                 prettyPrint(cur->param1,indent+1);\r
1196                 prettyPrint(cur->param2,indent+1);\r
1197                 prettyPrintIndent(indent); printf(")\n");\r
1198                 }\r
1199         else if(cur->id==E_EXPR_OR)\r
1200                 {\r
1201                 prettyPrintIndent(indent); printf("(PREAST_EXPR_OR\n");\r
1202                 prettyPrint(cur->param1,indent+1);\r
1203                 prettyPrint(cur->param2,indent+1);\r
1204                 prettyPrintIndent(indent); printf(")\n");\r
1205                 }\r
1206         else if(cur->id==E_EXPR_XOR)\r
1207                 {\r
1208                 prettyPrintIndent(indent); printf("(PREAST_EXPR_XOR\n");\r
1209                 prettyPrint(cur->param1,indent+1);\r
1210                 prettyPrint(cur->param2,indent+1);\r
1211                 prettyPrintIndent(indent); printf(")\n");\r
1212                 }\r
1213         else if(cur->id==E_EXPR_LT)\r
1214                 {\r
1215                 prettyPrintIndent(indent); printf("(PREAST_EXPR_LT\n");\r
1216                 prettyPrint(cur->param1,indent+1);\r
1217                 prettyPrint(cur->param2,indent+1);\r
1218                 prettyPrintIndent(indent); printf(")\n");\r
1219                 }\r
1220         else if(cur->id==E_EXPR_LTE)\r
1221                 {\r
1222                 prettyPrintIndent(indent); printf("(PREAST_EXPR_LTE\n");\r
1223                 prettyPrint(cur->param1,indent+1);\r
1224                 prettyPrint(cur->param2,indent+1);\r
1225                 prettyPrintIndent(indent); printf(")\n");\r
1226                 }\r
1227         else if(cur->id==E_EXPR_GT)\r
1228                 {\r
1229                 prettyPrintIndent(indent); printf("(PREAST_EXPR_GT\n");\r
1230                 prettyPrint(cur->param1,indent+1);\r
1231                 prettyPrint(cur->param2,indent+1);\r
1232                 prettyPrintIndent(indent); printf(")\n");\r
1233                 }\r
1234         else if(cur->id==E_EXPR_GTE)\r
1235                 {\r
1236                 prettyPrintIndent(indent); printf("(PREAST_EXPR_GTE\n");\r
1237                 prettyPrint(cur->param1,indent+1);\r
1238                 prettyPrint(cur->param2,indent+1);\r
1239                 prettyPrintIndent(indent); printf(")\n");\r
1240                 }\r
1241         else if(cur->id==E_EXPR_EQ)\r
1242                 {\r
1243                 prettyPrintIndent(indent); printf("(PREAST_EXPR_EQ\n");\r
1244                 prettyPrint(cur->param1,indent+1);\r
1245                 prettyPrint(cur->param2,indent+1);\r
1246                 prettyPrintIndent(indent); printf(")\n");\r
1247                 }\r
1248         else if(cur->id==E_EXPR_NEQ)\r
1249                 {\r
1250                 prettyPrintIndent(indent); printf("(PREAST_EXPR_NEQ\n");\r
1251                 prettyPrint(cur->param1,indent+1);\r
1252                 prettyPrint(cur->param2,indent+1);\r
1253                 prettyPrintIndent(indent); printf(")\n");\r
1254                 }\r
1255 \r
1256         /* ** dichiarazioni ** */\r
1257         else if(cur->id==E_DECL_CONST)\r
1258                 {\r
1259                 prettyPrintIndent(indent); printf("(PREAST_CONST_DECL\n");\r
1260                 prettyPrint(cur->param2,indent+1);      //string\r
1261                 prettyPrint(cur->param1,indent+1);      //type\r
1262                 \r
1263                 if((cur->param3->id==E_VAR_ROOT)||(cur->param3->id==E_VAR_STRUCT)||(cur->param3->id==E_VAR_ARRAY))\r
1264                         {\r
1265                         prettyPrintIndent(indent+1); printf("(PREAST_INIT_VAR\n");\r
1266                         prettyPrint(cur->param3,indent+2);      //init\r
1267                         prettyPrintIndent(indent+1); printf(")\n");\r
1268                         }\r
1269                 else\r
1270                         {\r
1271                         prettyPrintIndent(indent+1); printf("(PREAST_INIT_VAL\n");\r
1272                         prettyPrintInit(cur->param3,indent+2);  //init\r
1273                         prettyPrintIndent(indent+1); printf(")\n");\r
1274                         }\r
1275 \r
1276                 if(cur->next)\r
1277                         {\r
1278                         if((cur->next->id==E_DECL_CONST)||(cur->next->id==E_DECL_VAR))\r
1279                                 { prettyPrint(cur->next,indent+1); }    //next decl\r
1280                         else\r
1281                                 {\r
1282                                 valueLeaf       *tmp=cur->next;\r
1283 \r
1284                                 prettyPrintIndent(indent+1); printf("(PREAST_NO_DECL\n");\r
1285 \r
1286                                 prettyPrintIndent(indent+2); printf("[\n");\r
1287                                 while(tmp)\r
1288                                         {\r
1289                                         prettyPrint(tmp,indent+3);\r
1290 \r
1291                                         if(tmp->next)\r
1292                                                 { prettyPrintIndent(indent+3); printf(";\n"); }\r
1293 \r
1294                                         tmp=tmp->next;\r
1295                                         }\r
1296                                 prettyPrintIndent(indent+2); printf("]\n");\r
1297 \r
1298                                 prettyPrintIndent(indent+1); printf(")\n");\r
1299                                 }\r
1300                         }\r
1301                 else\r
1302                         { prettyPrintIndent(indent+1); printf("(PREAST_NO_DECL [])\n"); }\r
1303                 \r
1304 \r
1305                 prettyPrintIndent(indent); printf(")\n");\r
1306                 }\r
1307         else if(cur->id==E_DECL_VAR)\r
1308                 {\r
1309                 prettyPrintIndent(indent); printf("(PREAST_VAR_DECL\n");\r
1310                 prettyPrint(cur->param2,indent+1);      //string\r
1311                 prettyPrint(cur->param1,indent+1);      //type\r
1312                 \r
1313                 if(cur->param3)\r
1314                         {\r
1315                         prettyPrintIndent(indent+1); printf("(Some ?\n");\r
1316 \r
1317                         if((cur->param3->id==E_VAR_ROOT)||(cur->param3->id==E_VAR_STRUCT)||(cur->param3->id==E_VAR_ARRAY))\r
1318                                 {\r
1319                                 prettyPrintIndent(indent+2); printf("(PREAST_INIT_VAR\n");\r
1320                                 prettyPrint(cur->param3,indent+3);      //init\r
1321                                 prettyPrintIndent(indent+2); printf(")\n");\r
1322                                 }\r
1323                         else\r
1324                                 {\r
1325                                 prettyPrintIndent(indent+2); printf("(PREAST_INIT_VAL\n");\r
1326                                 prettyPrintInit(cur->param3,indent+3);  //init\r
1327                                 prettyPrintIndent(indent+2); printf(")\n");\r
1328                                 }\r
1329 \r
1330                         prettyPrintIndent(indent+1); printf(")\n");\r
1331                         }\r
1332                 else\r
1333                         { prettyPrintIndent(indent+1); printf("(None ?)\n"); }\r
1334 \r
1335                 if(cur->next)\r
1336                         {\r
1337                         if((cur->next->id==E_DECL_CONST)||(cur->next->id==E_DECL_VAR))\r
1338                                 { prettyPrint(cur->next,indent+1); }    //next decl\r
1339                         else\r
1340                                 {\r
1341                                 valueLeaf       *tmp=cur->next;\r
1342 \r
1343                                 prettyPrintIndent(indent+1); printf("(PREAST_NO_DECL\n");\r
1344 \r
1345                                 prettyPrintIndent(indent+2); printf("[\n");\r
1346                                 while(tmp)\r
1347                                         {\r
1348                                         prettyPrint(tmp,indent+3);\r
1349 \r
1350                                         if(tmp->next)\r
1351                                                 { prettyPrintIndent(indent+3); printf(";\n"); }\r
1352 \r
1353                                         tmp=tmp->next;\r
1354                                         }\r
1355                                 prettyPrintIndent(indent+2); printf("]\n");\r
1356 \r
1357                                 prettyPrintIndent(indent+1); printf(")\n");\r
1358                                 }\r
1359                         }\r
1360                 else\r
1361                         { prettyPrintIndent(indent+1); printf("(PREAST_NO_DECL [])\n"); }\r
1362                 \r
1363 \r
1364                 prettyPrintIndent(indent); printf(")\n");\r
1365                 }\r
1366 \r
1367         /* ** statement ** */\r
1368         else if(cur->id==E_STM_ASG)\r
1369                 {\r
1370                 prettyPrintIndent(indent); printf("(PREAST_STM_ASG\n");\r
1371                 prettyPrint(cur->param1,indent+1);\r
1372                 prettyPrint(cur->param2,indent+1);\r
1373                 prettyPrintIndent(indent); printf(")\n");\r
1374                 }\r
1375         else if(cur->id==E_STM_WHILE)\r
1376                 {\r
1377                 prettyPrintIndent(indent); printf("(PREAST_STM_WHILE\n");\r
1378                 prettyPrint(cur->param1,indent+1);\r
1379                 prettyPrintBody(cur->param2,indent+1);\r
1380                 prettyPrintIndent(indent); printf(")\n");\r
1381                 }\r
1382         else if(cur->id==E_STM_IF)\r
1383                 {\r
1384                 valueLeaf       *tmp=cur->param1;\r
1385 \r
1386                 prettyPrintIndent(indent); printf("(PREAST_STM_IF\n");\r
1387 \r
1388                 prettyPrintIndent(indent+1); printf("(\\laquo\n");\r
1389                 if(!tmp->next)\r
1390                         { prettyPrintIndent(indent+2); printf("£\n"); }\r
1391                 while(tmp)\r
1392                         {\r
1393                         prettyPrintIndent(indent+2); printf("(pair ??\n");\r
1394                         prettyPrint(tmp->param1,indent+3);\r
1395                         prettyPrintBody(tmp->param2,indent+3);\r
1396                         prettyPrintIndent(indent+2); printf(")\n");\r
1397 \r
1398                         if(tmp->next)\r
1399                                 {\r
1400                                 if(tmp->next->next)\r
1401                                         { prettyPrintIndent(indent+2); printf(";\n"); }\r
1402                                 else\r
1403                                         { prettyPrintIndent(indent+2); printf("£\n"); }\r
1404                                 }\r
1405 \r
1406                         tmp=tmp->next;\r
1407                         }\r
1408                 prettyPrintIndent(indent+1); printf("\\raquo)\n");\r
1409 \r
1410                 // equivalenza: Some ? (PREAST_NO_DECL []) = None ?\r
1411                 if(cur->param2)\r
1412                         {\r
1413                         prettyPrintIndent(indent+1); printf("(Some ?\n");\r
1414                         prettyPrintBody(cur->param2,indent+2);  //body\r
1415                         prettyPrintIndent(indent+1); printf(")\n");\r
1416                         }\r
1417                 else\r
1418                         { prettyPrintIndent(indent+1); printf("(None ?)\n"); }\r
1419 \r
1420                 prettyPrintIndent(indent); printf(")\n");\r
1421                 }\r
1422 }\r
1423 \r
1424 int main(int argc,char **argv)\r
1425 {\r
1426         int             ret;\r
1427 \r
1428         /* ignora eventuali errori di parametri */\r
1429         if(argc>1)\r
1430                 { usage(argv[0]); }\r
1431 \r
1432         ret=yyparse(NULL);\r
1433 \r
1434         if((!ret)&&(!numErr))\r
1435                 {\r
1436                 printf("definition parsingResult \\def\n");\r
1437                 printf(" (PREAST_ROOT\n");\r
1438                 prettyPrint(&root,2);\r
1439                 printf(" ).");\r
1440                 }\r
1441 \r
1442         return(ret);\r
1443 }\r