matitaB/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 valueLeaf       *typeRoot=NULL;         /* radice degli user type */\r
 162 \r
 163 int                     numErr=0;\r
 164 \r
 165 /* ************************************************************************* */\r
 166 \r
 167 int                     yylex(YYSTYPE *lvalp,YYLTYPE *llocp,void *p);\r
 168 void            yyerror(const YYLTYPE *locp,void *p,char const *msg);\r
 169 valueLeaf       *treeAlloc(\\r
 170                                 vEnum id,\\r
 171                                 _DWORD_ dwordValue,\\r
 172                                 _WORD_ wordValue,\\r
 173                                 _BYTE_ byteValue,\\r
 174                                 unsigned long int inumValue,\\r
 175                                 char *stringValue,\\r
 176                                 valueLeaf *param1,\\r
 177                                 valueLeaf *param2,\\r
 178                                 valueLeaf *param3,\\r
 179                                 const YYLTYPE *locp);\r
 180 \r
 181 valueLeaf       *treeDwordAlloc(_DWORD_ dwordValue,const YYLTYPE *locp);\r
 182 valueLeaf       *treeWordAlloc(_WORD_ wordValue,const YYLTYPE *locp);\r
 183 valueLeaf       *treeByteAlloc(_BYTE_ byteValue,const YYLTYPE *locp);\r
 184 valueLeaf       *treeInumAlloc(unsigned long int inumValue,const YYLTYPE *locp);\r
 185 valueLeaf       *treeStringAlloc(char *stringValue,const YYLTYPE *locp);\r
 186 valueLeaf       *treeId0Alloc(vEnum id,const YYLTYPE *locp);\r
 187 valueLeaf       *treeId1Alloc(vEnum id,valueLeaf *param1,const YYLTYPE *locp);\r
 188 valueLeaf       *treeId2Alloc(vEnum id,valueLeaf *param1,valueLeaf *param2,const YYLTYPE *locp);\r
 189 valueLeaf       *treeId3Alloc(vEnum id,valueLeaf *param1,valueLeaf *param2,valueLeaf *param3,const YYLTYPE *locp);\r
 190 \r
 191 int                     eqUserType(valueLeaf *type1,valueLeaf *type2);\r
 192 int                     getUserType(valueLeaf *type,valueLeaf **res);\r
 193 void            createUserType(valueLeaf *type);\r
 194 \r
 195 void prettyPrint(valueLeaf *cur,int indent);\r
 196 \r
 197 /* ************************************************************************* */\r
 198 \r
 199 %}\r
 200 \r
 201 %locations\r
 202 %pure-parser\r
 203 %lex-param              {void *p}\r
 204 %parse-param    {void *p}\r
 205 %error-verbose\r
 206 \r
 207 /* ************************************************************************* */\r
 208 \r
 209 /* keyword */\r
 210 %token          Keyword_STRUCT          Keyword_ARRAY           Keyword_OF                      \r
 211 %token          Keyword_IF                      Keyword_ELSIF           Keyword_ELSE            Keyword_WHILE           Keyword_CONST\r
 212 %token          Keyword_B2W                     Keyword_B2DW            Keyword_W2B                     Keyword_W2DW            Keyword_DW2B            Keyword_DW2W\r
 213 \r
 214 /* tipi nativi */\r
 215 %token          Type_BYTE                       Type_WORD                       Type_DWORD\r
 216 \r
 217 /* parentesi */\r
 218 %token          OpenBracket_BODY        CloseBracket_BODY\r
 219 %token          OpenBracket_SQUARE      CloseBracket_SQUARE\r
 220 %token          OpenBracket_ROUND       CloseBracket_ROUND\r
 221 \r
 222 /* operatori unari */\r
 223 %token          UnaryOperator_NOT       UnaryOperator_COM\r
 224 \r
 225 /* operatori duali */\r
 226 %token          DualOperator_AND        DualOperator_OR         DualOperator_XOR\r
 227 %token          DualOperator_ADD        DualOperator_SUB        DualOperator_MUL        DualOperator_DIV\r
 228 %token          DualOperator_NEQ        DualOperator_EQ         DualOperator_LT         DualOperator_GT         DualOperator_LTE        DualOperator_GTE\r
 229 %token          DualOperator_ASG        DualOperator_SHR        DualOperator_SHL\r
 230 \r
 231 /* separatori */\r
 232 %token          Separator_COLUMN        Separator_SELECT        Separator_COMMA\r
 233 \r
 234 /* valori */\r
 235 %token          Value_DWORD                     Value_WORD                      Value_BYTE                      Value_INUM                      Value_STRING\r
 236 \r
 237 /* ************************************************************************* */\r
 238 \r
 239 %start          _start_\r
 240 \r
 241 /* priorita' minima */\r
 242 \r
 243 %right          Separator_COMMA\r
 244 \r
 245 %nonassoc       DualOperator_ASG\r
 246 \r
 247 %nonassoc       Keyword_B2W                     Keyword_B2DW            Keyword_W2B             Keyword_W2DW            Keyword_DW2B            Keyword_DW2W\r
 248 \r
 249 %left           DualOperator_OR\r
 250 %left           DualOperator_XOR\r
 251 %left           DualOperator_AND\r
 252 \r
 253 %nonassoc       DualOperator_NEQ\r
 254 %nonassoc       DualOperator_EQ\r
 255 %nonassoc       DualOperator_GTE\r
 256 %nonassoc       DualOperator_GT\r
 257 %nonassoc       DualOperator_LTE\r
 258 %nonassoc       DualOperator_LT\r
 259 \r
 260 %left           DualOperator_SHR\r
 261 %left           DualOperator_SHL\r
 262 %left           DualOperator_SUB\r
 263 %left           DualOperator_ADD\r
 264 %left           DualOperator_DIV\r
 265 %left           DualOperator_MUL\r
 266 \r
 267 %nonassoc       UnaryOperator_SUB\r
 268 %nonassoc       UnaryOperator_COM\r
 269 %nonassoc       UnaryOperator_NOT\r
 270 \r
 271 %right          Separator_SELECT\r
 272 %right          Separator_COLUMN\r
 273 \r
 274 %nonassoc       OpenBracket_SQUARE      CloseBracket_SQUARE\r
 275 %nonassoc       OpenBracket_ROUND       CloseBracket_ROUND      \r
 276 %nonassoc       OpenBracket_BODY        CloseBracket_BODY\r
 277 \r
 278 /* priorita' massima */ \r
 279 \r
 280 /* ************************************************************************* */\r
 281 \r
 282 %%\r
 283 \r
 284 /* ** FUNZIONE PRINCIPALE ** */\r
 285 _start_                 :       OpenBracket_BODY _decl_lst_ CloseBracket_BODY\r
 286                                                 { memcpy(&root,$2,sizeof(valueLeaf)); };\r
 287 \r
 288 /* ** GESTIONE DICHIARAZIONI ** */\r
 289 _decl_lst_              :       Keyword_CONST _type_ Value_STRING DualOperator_ASG _init_choice_ Separator_COLUMN _decl_lst_\r
 290                                                 {\r
 291                                                 $$=treeId3Alloc(E_DECL_CONST,$2,$3,$5,&@1);\r
 292                                                 $$->next=$7;\r
 293                                                 }|\r
 294                                         _type_ Value_STRING _init_ Separator_COLUMN _decl_lst_\r
 295                                                 {\r
 296                                                 $$=treeId3Alloc(E_DECL_VAR,$1,$2,$3,&@1);\r
 297                                                 $$->next=$5;                                            \r
 298                                                 }|\r
 299                                         _stm_lst_\r
 300                                                 { $$=$1; };\r
 301 \r
 302 _type_                  :       Keyword_ARRAY OpenBracket_SQUARE Value_INUM CloseBracket_SQUARE Keyword_OF _type_\r
 303                                                 {\r
 304                                                 if(!($3->inumValue))\r
 305                                                         { yyerror(&@1,p,"unallowed empty array"); }\r
 306                                                 else\r
 307                                                         {\r
 308                                                         $$=treeId2Alloc(E_TYPE_ARRAY,$3,$6,&@1);\r
 309                                                         $3->inumValue--;\r
 310                                                         }\r
 311                                                 }|\r
 312                                         Keyword_STRUCT OpenBracket_BODY _type_ Separator_COLUMN _type_lst_ CloseBracket_BODY\r
 313                                                 {\r
 314                                                 $$=treeId1Alloc(E_TYPE_STRUCT,$3,&@1);\r
 315                                                 $3->next=$5;\r
 316 \r
 317                                                 createUserType($$);\r
 318                                                 }|\r
 319                                         Type_DWORD\r
 320                                                 { $$=treeId0Alloc(E_TYPE_DWORD,&@1); }|\r
 321                                         Type_WORD\r
 322                                                 { $$=treeId0Alloc(E_TYPE_WORD,&@1); }|\r
 323                                         Type_BYTE\r
 324                                                 { $$=treeId0Alloc(E_TYPE_BYTE,&@1); };\r
 325 \r
 326 _type_lst_              :       _type_ Separator_COLUMN _type_lst_\r
 327                                                 {\r
 328                                                 $1->next=$3;\r
 329                                                 $$=$1;\r
 330                                                 }|\r
 331                                         /* epsilon */\r
 332                                                 { $$=NULL; };\r
 333 \r
 334 _init_                  :       DualOperator_ASG _init_choice_\r
 335                                                 { $$=$2; }|\r
 336                                         /* epsilon */\r
 337                                                 { $$=NULL; };\r
 338 \r
 339 _init_choice_   :       _init_val_\r
 340                                                 { $$=$1; }|\r
 341                                         _var_\r
 342                                                 { $$=$1; };\r
 343 \r
 344 _init_val_              :       OpenBracket_SQUARE _init_val_ _init_val_lst_ CloseBracket_SQUARE\r
 345                                                 {\r
 346                                                 $$=treeId1Alloc(E_VALUE_ARRAY,$2,&@1);\r
 347                                                 $2->next=$3;\r
 348                                                 }|\r
 349                                         OpenBracket_BODY _init_val_ _init_val_lst_ CloseBracket_BODY\r
 350                                                 {\r
 351                                                 $$=treeId1Alloc(E_VALUE_STRUCT,$2,&@1);\r
 352                                                 $2->next=$3;\r
 353                                                 }|\r
 354                                         Value_DWORD\r
 355                                                 { $$=$1; }|\r
 356                                         Value_WORD\r
 357                                                 { $$=$1; }|\r
 358                                         Value_BYTE\r
 359                                                 { $$=$1; };\r
 360 \r
 361 _init_val_lst_  :       Separator_COMMA _init_val_ _init_val_lst_\r
 362                                                 {\r
 363                                                 $2->next=$3;\r
 364                                                 $$=$2;\r
 365                                                 }|\r
 366                                         /* epsilon */\r
 367                                                 { $$=NULL; };\r
 368 \r
 369 /* ** GESTIONE STATEMENT ** */\r
 370 _stm_lst_               :       _var_ DualOperator_ASG _expr_ Separator_COLUMN _stm_lst_\r
 371                                                 {\r
 372                                                 $$=treeId2Alloc(E_STM_ASG,$1,$3,&@1);\r
 373                                                 $$->next=$5;\r
 374                                                 }|\r
 375                                         Keyword_WHILE OpenBracket_ROUND _expr_ CloseBracket_ROUND OpenBracket_BODY _decl_lst_ CloseBracket_BODY _stm_lst_\r
 376                                                 {\r
 377                                                 $$=treeId2Alloc(E_STM_WHILE,$3,$6,&@1);\r
 378                                                 $$->next=$8;\r
 379                                                 }|\r
 380                                         Keyword_IF OpenBracket_ROUND _expr_ CloseBracket_ROUND OpenBracket_BODY _decl_lst_ CloseBracket_BODY _elsif_lst_ _else_ _stm_lst_\r
 381                                                 {\r
 382                                                 $$=treeId2Alloc(E_STM_IF,treeId2Alloc(E_STM_IFEXPRBODY,$3,$6,&@1),$9,&@1);\r
 383                                                 $$->param1->next=$8;\r
 384                                                 $$->next=$10;\r
 385                                                 }|\r
 386                                         /* epsilon */\r
 387                                                 { $$=NULL; };\r
 388 \r
 389 _elsif_lst_             :       Keyword_ELSIF OpenBracket_ROUND _expr_ CloseBracket_ROUND OpenBracket_BODY _decl_lst_ CloseBracket_BODY _elsif_lst_\r
 390                                                 {\r
 391                                                 $$=treeId2Alloc(E_STM_IFEXPRBODY,$3,$6,&@1);\r
 392                                                 $$->next=$8;\r
 393                                                 }|\r
 394                                         /* epsilon */\r
 395                                                 { $$=NULL; };\r
 396 \r
 397 _else_                  :       Keyword_ELSE OpenBracket_BODY _decl_lst_ CloseBracket_BODY\r
 398                                                 { $$=$3; }|\r
 399                                         /* epsilon */\r
 400                                                 { $$=NULL; }\r
 401 \r
 402 _expr_                  :       OpenBracket_ROUND _expr_ CloseBracket_ROUND\r
 403                                                 { $$=$2; }|\r
 404                                         UnaryOperator_NOT _expr_\r
 405                                                 { $$=treeId1Alloc(E_EXPR_NOT,$2,&@1); }|\r
 406                                         UnaryOperator_COM _expr_\r
 407                                                 { $$=treeId1Alloc(E_EXPR_COM,$2,&@1); }|\r
 408                                         DualOperator_SUB _expr_ %prec UnaryOperator_SUB\r
 409                                                 { $$=treeId1Alloc(E_EXPR_NEG,$2,&@1); }|\r
 410                                         Keyword_B2W OpenBracket_ROUND _expr_ CloseBracket_ROUND\r
 411                                                 { $$=treeId1Alloc(E_EXPR_B2W,$3,&@1); }|\r
 412                                         Keyword_B2DW OpenBracket_ROUND _expr_ CloseBracket_ROUND\r
 413                                                 { $$=treeId1Alloc(E_EXPR_B2DW,$3,&@1); }|\r
 414                                         Keyword_W2B OpenBracket_ROUND _expr_ CloseBracket_ROUND\r
 415                                                 { $$=treeId1Alloc(E_EXPR_W2B,$3,&@1); }|\r
 416                                         Keyword_W2DW OpenBracket_ROUND _expr_ CloseBracket_ROUND\r
 417                                                 { $$=treeId1Alloc(E_EXPR_W2DW,$3,&@1); }|\r
 418                                         Keyword_DW2B OpenBracket_ROUND _expr_ CloseBracket_ROUND\r
 419                                                 { $$=treeId1Alloc(E_EXPR_DW2B,$3,&@1); }|\r
 420                                         Keyword_DW2W OpenBracket_ROUND _expr_ CloseBracket_ROUND\r
 421                                                 { $$=treeId1Alloc(E_EXPR_DW2W,$3,&@1); }|\r
 422                                         _expr_ DualOperator_MUL _expr_\r
 423                                                 { $$=treeId2Alloc(E_EXPR_MUL,$1,$3,&@1); }|\r
 424                                         _expr_ DualOperator_DIV _expr_\r
 425                                                 { $$=treeId2Alloc(E_EXPR_DIV,$1,$3,&@1); }|\r
 426                                         _expr_ DualOperator_ADD _expr_\r
 427                                                 { $$=treeId2Alloc(E_EXPR_ADD,$1,$3,&@1); }|\r
 428                                         _expr_ DualOperator_SUB _expr_\r
 429                                                 { $$=treeId2Alloc(E_EXPR_SUB,$1,$3,&@1); }|\r
 430                                         _expr_ DualOperator_SHL _expr_\r
 431                                                 { $$=treeId2Alloc(E_EXPR_SHL,$1,$3,&@1); }|\r
 432                                         _expr_ DualOperator_SHR _expr_\r
 433                                                 { $$=treeId2Alloc(E_EXPR_SHR,$1,$3,&@1); }|\r
 434                                         _expr_ DualOperator_LT _expr_\r
 435                                                 { $$=treeId2Alloc(E_EXPR_LT,$1,$3,&@1); }|\r
 436                                         _expr_ DualOperator_LTE _expr_\r
 437                                                 { $$=treeId2Alloc(E_EXPR_LTE,$1,$3,&@1); }|\r
 438                                         _expr_ DualOperator_GT _expr_\r
 439                                                 { $$=treeId2Alloc(E_EXPR_GT,$1,$3,&@1); }|\r
 440                                         _expr_ DualOperator_GTE _expr_\r
 441                                                 { $$=treeId2Alloc(E_EXPR_GTE,$1,$3,&@1); }|\r
 442                                         _expr_ DualOperator_NEQ _expr_\r
 443                                                 { $$=treeId2Alloc(E_EXPR_NEQ,$1,$3,&@1); }|\r
 444                                         _expr_ DualOperator_EQ _expr_\r
 445                                                 { $$=treeId2Alloc(E_EXPR_EQ,$1,$3,&@1); }|\r
 446                                         _expr_ DualOperator_AND _expr_\r
 447                                                 { $$=treeId2Alloc(E_EXPR_AND,$1,$3,&@1); }|\r
 448                                         _expr_ DualOperator_OR _expr_\r
 449                                                 { $$=treeId2Alloc(E_EXPR_OR,$1,$3,&@1); }|\r
 450                                         _expr_ DualOperator_XOR _expr_\r
 451                                                 { $$=treeId2Alloc(E_EXPR_XOR,$1,$3,&@1); }|\r
 452                                         Value_DWORD\r
 453                                                 { $$=$1; }|\r
 454                                         Value_WORD\r
 455                                                 { $$=$1; }|\r
 456                                         Value_BYTE\r
 457                                                 { $$=$1; }|\r
 458                                         _var_\r
 459                                                 { $$=treeId1Alloc(E_EXPR_VAR,$1,&@1); };\r
 460 \r
 461 _var_                   :       Value_STRING _var_sub_\r
 462                                                 {\r
 463                                                 if($2)\r
 464                                                         {\r
 465                                                         $$=$2;\r
 466                                                         $$->last->next=treeId1Alloc(E_VAR_ROOT,$1,&@1);\r
 467                                                         }\r
 468                                                 else\r
 469                                                         { $$=treeId1Alloc(E_VAR_ROOT,$1,&@1); }\r
 470                                                 };\r
 471 \r
 472 _var_sub_               :       Separator_SELECT Value_INUM _var_sub_\r
 473                                                 {\r
 474                                                 if($3)\r
 475                                                         {\r
 476                                                         valueLeaf       *tmp=treeId1Alloc(E_VAR_STRUCT,$2,&@1);\r
 477 \r
 478                                                         $$=$3;\r
 479                                                         $$->last->next=tmp;\r
 480                                                         $$->last=tmp;\r
 481                                                         }\r
 482                                                 else\r
 483                                                         {\r
 484                                                         $$=treeId1Alloc(E_VAR_STRUCT,$2,&@1);\r
 485                                                         $$->last=$$;\r
 486                                                         }\r
 487                                                 }|\r
 488                                         OpenBracket_SQUARE _expr_ CloseBracket_SQUARE _var_sub_\r
 489                                                 {\r
 490                                                 if($4)\r
 491                                                         {\r
 492                                                         valueLeaf       *tmp=treeId1Alloc(E_VAR_ARRAY,$2,&@1);\r
 493 \r
 494                                                         $$=$4;\r
 495                                                         $$->last->next=tmp;\r
 496                                                         $$->last=tmp;\r
 497                                                         }\r
 498                                                 else\r
 499                                                         {\r
 500                                                         $$=treeId1Alloc(E_VAR_ARRAY,$2,&@1);\r
 501                                                         $$->last=$$;\r
 502                                                         }\r
 503                                                 }|\r
 504                                         /* epsilon */\r
 505                                                 { $$=NULL; };\r
 506 \r
 507 /* ************************************************************************* */\r
 508 \r
 509 %%\r
 510 \r
 511 void yyerror(const YYLTYPE *locp,void *p,char const *msg)\r
 512 {\r
 513         if(locp->first_line>=0)\r
 514                 { printf("%s:%d,%d\tParsError: %s%c",locp->source,locp->first_line,locp->first_column,msg,SEP); }\r
 515         else\r
 516                 { printf(":0,0\tParsError: %s%c",msg,SEP); }\r
 517 \r
 518         numErr++;\r
 519 \r
 520         return;\r
 521 }\r
 522 \r
 523 valueLeaf       *treeAlloc(\\r
 524                                 vEnum id,\\r
 525                                 _DWORD_ dwordValue,\\r
 526                                 _WORD_ wordValue,\\r
 527                                 _BYTE_ byteValue,\\r
 528                                 unsigned long int inumValue,\\r
 529                                 char *stringValue,\\r
 530                                 valueLeaf *param1,\\r
 531                                 valueLeaf *param2,\\r
 532                                 valueLeaf *param3,\\r
 533                                 const YYLTYPE *locp)\r
 534 {\r
 535         valueLeaf       *tmp;\r
 536 \r
 537         if(!(tmp=(valueLeaf *) myMalloc(sizeof(valueLeaf))))\r
 538                 {\r
 539                 printf("[%s:%d] ParsError:OutOfMemory%c",__FILE__,__LINE__,SEP);\r
 540                 exit(ERR_EXIT);\r
 541                 }\r
 542 \r
 543         memset(tmp,0,sizeof(valueLeaf));\r
 544 \r
 545         tmp->id=id;\r
 546         tmp->dwordValue=dwordValue;\r
 547         tmp->wordValue=wordValue;\r
 548         tmp->byteValue=byteValue;\r
 549         tmp->inumValue=inumValue;\r
 550         tmp->stringValue=stringValue;\r
 551         tmp->param1=param1;\r
 552         tmp->param2=param2;\r
 553         tmp->param3=param3;\r
 554 \r
 555         return(tmp);\r
 556 }\r
 557 \r
 558 valueLeaf *treeDwordAlloc(_DWORD_ dwordValue,const YYLTYPE *locp)\r
 559 { return(treeAlloc(E_VALUE_DWORD,dwordValue,0,0,0,NULL,NULL,NULL,NULL,locp)); }\r
 560 \r
 561 valueLeaf *treeWordAlloc(_WORD_ wordValue,const YYLTYPE *locp)\r
 562 { return(treeAlloc(E_VALUE_WORD,0,wordValue,0,0,NULL,NULL,NULL,NULL,locp)); }\r
 563 \r
 564 valueLeaf *treeByteAlloc(_BYTE_ byteValue,const YYLTYPE *locp)\r
 565 { return(treeAlloc(E_VALUE_BYTE,0,0,byteValue,0,NULL,NULL,NULL,NULL,locp)); }\r
 566 \r
 567 valueLeaf *treeInumAlloc(unsigned long int inumValue,const YYLTYPE *locp)\r
 568 { return(treeAlloc(E_VALUE_INUM,0,0,0,inumValue,NULL,NULL,NULL,NULL,locp)); }\r
 569 \r
 570 valueLeaf *treeStringAlloc(char *stringValue,const YYLTYPE *locp)\r
 571 { return(treeAlloc(E_VALUE_STRING,0,0,0,0,stringValue,NULL,NULL,NULL,locp)); }\r
 572 \r
 573 valueLeaf *treeId0Alloc(vEnum id,const YYLTYPE *locp)\r
 574 { return(treeAlloc(id,0,0,0,0,NULL,NULL,NULL,NULL,locp)); }\r
 575 \r
 576 valueLeaf *treeId1Alloc(vEnum id,valueLeaf *param1,const YYLTYPE *locp)\r
 577 { return(treeAlloc(id,0,0,0,0,NULL,param1,NULL,NULL,locp)); }\r
 578 \r
 579 valueLeaf *treeId2Alloc(vEnum id,valueLeaf *param1,valueLeaf *param2,const YYLTYPE *locp)\r
 580 { return(treeAlloc(id,0,0,0,0,NULL,param1,param2,NULL,locp)); }\r
 581 \r
 582 valueLeaf *treeId3Alloc(vEnum id,valueLeaf *param1,valueLeaf *param2,valueLeaf *param3,const YYLTYPE *locp)\r
 583 { return(treeAlloc(id,0,0,0,0,NULL,param1,param2,param3,locp)); }\r
 584 \r
 585 /* riconoscimento token da input */\r
 586 int yylex(YYSTYPE *lvalp,YYLTYPE *llocp,void *p)\r
 587 {\r
 588         char    bufLine[256];\r
 589         char    bufToken[256];\r
 590         char    bufString[256];\r
 591         char    *tmp1,*tmp2;\r
 592 \r
 593         /* riconoscimento di source:linea,colonna */\r
 594         fscanf(stdin,"%s%s%s\n",bufLine,bufToken,bufString,SEP);\r
 595 \r
 596         if(!strcmp(bufToken,"ERR"))\r
 597                 {\r
 598                 printf("%s\t%s%c",bufLine,bufString,SEP);\r
 599                 exit(ERR_EXIT);\r
 600                 }\r
 601 \r
 602         for(tmp1=bufLine;*tmp1!=':';tmp1++);\r
 603         *tmp1=0;\r
 604 \r
 605         for(tmp2=tmp1+1;*tmp2!=',';tmp2++);\r
 606         *tmp2=0;\r
 607 \r
 608         llocp->first_line=llocp->last_line=atoi(tmp1+1);\r
 609         llocp->first_column=llocp->last_column=atoi(tmp2+1);\r
 610 \r
 611         if(!(llocp->source=(char *) myMalloc(strlen(bufLine)+1)))\r
 612                 {\r
 613                 printf("[%s:%d] ParsError:OutOfMemory%c",__FILE__,__LINE__,SEP);\r
 614                 exit(ERR_EXIT);\r
 615                 }\r
 616 \r
 617         *llocp->source=0;\r
 618         strcpy(llocp->source,bufLine);\r
 619 \r
 620         *tmp1=':';\r
 621         *tmp2=',';\r
 622 \r
 623         /* analisi */\r
 624         if(!strcmp(bufToken,"OK"))\r
 625                 {\r
 626                 root.source=llocp->source;\r
 627                 root.fileLine=llocp->first_line;\r
 628                 root.fileRow=llocp->first_column;\r
 629 \r
 630                 return yylex(lvalp,llocp,p);\r
 631                 }\r
 632         else if(!strcmp(bufToken,"EOF"))\r
 633                 { return(0); }\r
 634 \r
 635         /* categoria keyword */\r
 636         if(!strcmp(bufToken,"KEW"))\r
 637                 {\r
 638                 if(!strcmp(bufString,"struct"))\r
 639                         { return(Keyword_STRUCT); }\r
 640                 else if(!strcmp(bufString,"array"))\r
 641                         { return(Keyword_ARRAY); }\r
 642                 else if(!strcmp(bufString,"of"))\r
 643                         { return(Keyword_OF); }\r
 644                 else if(!strcmp(bufString,"if"))\r
 645                         { return(Keyword_IF); }\r
 646                 else if(!strcmp(bufString,"elsif"))\r
 647                         { return(Keyword_ELSIF); }\r
 648                 else if(!strcmp(bufString,"else"))\r
 649                         { return(Keyword_ELSE); }\r
 650                 else if(!strcmp(bufString,"while"))\r
 651                         { return(Keyword_WHILE); }\r
 652                 else if(!strcmp(bufString,"const"))\r
 653                         { return(Keyword_CONST); }\r
 654                 else if(!strcmp(bufString,"b2w"))\r
 655                         { return(Keyword_B2W); }\r
 656                 else if(!strcmp(bufString,"b2dw"))\r
 657                         { return(Keyword_B2DW); }\r
 658                 else if(!strcmp(bufString,"w2b"))\r
 659                         { return(Keyword_W2B); }\r
 660                 else if(!strcmp(bufString,"w2dw"))\r
 661                         { return(Keyword_W2DW); }\r
 662                 else if(!strcmp(bufString,"dw2b"))\r
 663                         { return(Keyword_DW2B); }\r
 664                 else if(!strcmp(bufString,"dw2w"))\r
 665                         { return(Keyword_DW2W); }\r
 666                 else\r
 667                         {\r
 668                         printf("%s\tParsError:UnknownKeywordToken(%s)%c",bufLine,bufString,SEP);\r
 669                         exit(ERR_EXIT);\r
 670                         }\r
 671                 }\r
 672         /* categoria tipo nativo */\r
 673         else if(!strcmp(bufToken,"TYP"))\r
 674                 {\r
 675                 if(!strcmp(bufString,"dword"))\r
 676                         { return(Type_DWORD); }\r
 677                 else if(!strcmp(bufString,"word"))\r
 678                         { return(Type_WORD); }\r
 679                 else if(!strcmp(bufString,"byte"))\r
 680                         { return(Type_BYTE); }\r
 681                 else\r
 682                         {\r
 683                         printf("%s\tParsError:UnknownTypeToken(%s)%c",bufLine,bufString,SEP);\r
 684                         exit(ERR_EXIT);\r
 685                         }\r
 686                 }\r
 687         /* categoria parentesi */\r
 688         else if(!strcmp(bufToken,"BRK"))\r
 689                 {\r
 690                 if(!strcmp(bufString,"{"))\r
 691                         { return(OpenBracket_BODY); }\r
 692                 else if(!strcmp(bufString,"}"))\r
 693                         { return(CloseBracket_BODY); }\r
 694                 else if(!strcmp(bufString,"["))\r
 695                         { return(OpenBracket_SQUARE); }\r
 696                 else if(!strcmp(bufString,"]"))\r
 697                         { return(CloseBracket_SQUARE); }\r
 698                 else if(!strcmp(bufString,"("))\r
 699                         { return(OpenBracket_ROUND); }\r
 700                 else if(!strcmp(bufString,")"))\r
 701                         { return(CloseBracket_ROUND); }\r
 702                 else\r
 703                         {\r
 704                         printf("%s\tParsError:UnknownBracketToken(%s)%c",bufLine,bufString,SEP);\r
 705                         exit(ERR_EXIT);\r
 706                         }\r
 707                 }\r
 708         /* categoria operatore unario */\r
 709         else if(!strcmp(bufToken,"MOP"))\r
 710                 {\r
 711                 if(!strcmp(bufString,"!"))\r
 712                         { return(UnaryOperator_NOT); }\r
 713                 else if(!strcmp(bufString,"~"))\r
 714                         { return(UnaryOperator_COM); }\r
 715                 else\r
 716                         {\r
 717                         printf("%s\tParsError:UnknownUnaryOperatorToken(%s)%c",bufLine,bufString,SEP);\r
 718                         exit(ERR_EXIT);\r
 719                         }\r
 720                 }\r
 721         /* categoria operatore duale */\r
 722         else if(!strcmp(bufToken,"DOP"))\r
 723                 {\r
 724                 if(!strcmp(bufString,"&"))\r
 725                         { return(DualOperator_AND); }\r
 726                 else if(!strcmp(bufString,"|"))\r
 727                         { return(DualOperator_OR); }\r
 728                 else if(!strcmp(bufString,"^"))\r
 729                         { return(DualOperator_XOR); }\r
 730                 else if(!strcmp(bufString,"+"))\r
 731                         { return(DualOperator_ADD); }\r
 732                 else if(!strcmp(bufString,"-"))\r
 733                         { return(DualOperator_SUB); }\r
 734                 else if(!strcmp(bufString,"*"))\r
 735                         { return(DualOperator_MUL); }\r
 736                 else if(!strcmp(bufString,"/"))\r
 737                         { return(DualOperator_DIV); }\r
 738                 else if(!strcmp(bufString,"!="))\r
 739                         { return(DualOperator_NEQ); }\r
 740                 else if(!strcmp(bufString,"=="))\r
 741                         { return(DualOperator_EQ); }\r
 742                 else if(!strcmp(bufString,"<"))\r
 743                         { return(DualOperator_LT); }\r
 744                 else if(!strcmp(bufString,">"))\r
 745                         { return(DualOperator_GT); }\r
 746                 else if(!strcmp(bufString,"<="))\r
 747                         { return(DualOperator_LTE); }\r
 748                 else if(!strcmp(bufString,">="))\r
 749                         { return(DualOperator_GTE); }\r
 750                 else if(!strcmp(bufString,">>"))\r
 751                         { return(DualOperator_SHR); }\r
 752                 else if(!strcmp(bufString,"<<"))\r
 753                         { return(DualOperator_SHL); }\r
 754                 else if(!strcmp(bufString,"="))\r
 755                         { return(DualOperator_ASG); }\r
 756                 else\r
 757                         {\r
 758                         printf("%s\tParsError:UnknownDualOperatorToken(%s)%c",bufLine,bufString,SEP);\r
 759                         exit(ERR_EXIT);\r
 760                         }\r
 761                 }\r
 762         /* categoria separatore */\r
 763         else if(!strcmp(bufToken,"SEP"))\r
 764                 {\r
 765                 if(!strcmp(bufString,";"))\r
 766                         { return(Separator_COLUMN); }\r
 767                 else if(!strcmp(bufString,"."))\r
 768                         { return(Separator_SELECT); }\r
 769                 else if(!strcmp(bufString,","))\r
 770                         { return(Separator_COMMA); }\r
 771                 else\r
 772                         {\r
 773                         printf("%s\tParsError:UnknownSeparatorToken(%s)%c",bufLine,bufString,SEP);\r
 774                         exit(ERR_EXIT);\r
 775                         }\r
 776                 }\r
 777         /* categoria dword */\r
 778         else if(!strcmp(bufToken,"W32"))\r
 779                 {\r
 780                 unsigned long int       tmpI;\r
 781 \r
 782                 if(sscanf(bufString,"0x%lx",&tmpI)==1)\r
 783                         {\r
 784                         *lvalp=treeDwordAlloc((_DWORD_) (tmpI&0xFFFFFFFF),llocp);\r
 785                         return(Value_DWORD);\r
 786                         }\r
 787                 else\r
 788                         {\r
 789                         printf("%s\tParsError:UnknownIntToken(%s)%c",bufLine,bufString,SEP);\r
 790                         exit(ERR_EXIT);\r
 791                         }\r
 792                 }\r
 793         /* categoria word */\r
 794         else if(!strcmp(bufToken,"W16"))\r
 795                 {\r
 796                 unsigned long int       tmpI;\r
 797 \r
 798                 if(sscanf(bufString,"0x%lx",&tmpI)==1)\r
 799                         {\r
 800                         *lvalp=treeWordAlloc((_WORD_) (tmpI&0xFFFF),llocp);\r
 801                         return(Value_WORD);\r
 802                         }\r
 803                 else\r
 804                         {\r
 805                         printf("%s\tParsError:UnknownIntToken(%s)%c",bufLine,bufString,SEP);\r
 806                         exit(ERR_EXIT);\r
 807                         }\r
 808                 }\r
 809         /* categoria byte */\r
 810         else if(!strcmp(bufToken,"BY8"))\r
 811                 {\r
 812                 unsigned long int       tmpI;\r
 813 \r
 814                 if(sscanf(bufString,"0x%lx",&tmpI)==1)\r
 815                         {\r
 816                         *lvalp=treeByteAlloc((_BYTE_) (tmpI&0xFF),llocp);\r
 817                         return(Value_BYTE);\r
 818                         }\r
 819                 else\r
 820                         {\r
 821                         printf("%s\tParsError:UnknownIntToken(%s)%c",bufLine,bufString,SEP);\r
 822                         exit(ERR_EXIT);\r
 823                         }\r
 824                 }\r
 825         /* categoria numero intero */\r
 826         else if(!strcmp(bufToken,"INU"))\r
 827                 {\r
 828                 unsigned long int       tmpI;\r
 829 \r
 830                 if(sscanf(bufString,"%lu",&tmpI)==1)\r
 831                         {\r
 832                         *lvalp=treeInumAlloc(tmpI,llocp);\r
 833                         return(Value_INUM);\r
 834                         }\r
 835                 else\r
 836                         {\r
 837                         printf("%s\tParsError:UnknownIntToken(%s)%c",bufLine,bufString,SEP);\r
 838                         exit(ERR_EXIT);\r
 839                         }\r
 840                 }\r
 841         /* categoria ID == stringa */\r
 842         else if(!strcmp(bufToken,"IID"))\r
 843                 {\r
 844                 char            *tmpS;\r
 845 \r
 846                 if(!(tmpS=(char *) myMalloc(strlen(bufString)+1)))\r
 847                         {\r
 848                         printf("[%s:%d] ParsError:OutOfMemory%c",__FILE__,__LINE__,SEP);\r
 849                         exit(ERR_EXIT);\r
 850                         }\r
 851 \r
 852                 *tmpS=0;\r
 853                 strcpy(tmpS,bufString);\r
 854 \r
 855                 *lvalp=treeStringAlloc(tmpS,llocp);\r
 856                 return(Value_STRING);\r
 857                 }\r
 858         else\r
 859                 {\r
 860                 printf("%s\tParsError:UnknownToken(%s)%c",bufLine,bufString,SEP);\r
 861                 exit(ERR_EXIT);\r
 862                 }\r
 863 }\r
 864 \r
 865 void usage(char *name)\r
 866 {\r
 867         printf("\nC Parser - Cosimo Oliboni\n\n");\r
 868         printf("\"%s\" parsing da stdin\n\n",name);\r
 869 \r
 870         return;\r
 871 }\r
 872 \r
 873 /* *************************** gestione degli user type *********** */\r
 874 \r
 875 int eqUserType(valueLeaf *type1,valueLeaf *type2)\r
 876 {\r
 877         valueLeaf       *tmp1,*tmp2;\r
 878 \r
 879         if(type1->id!=type2->id)\r
 880                 { return(0); }\r
 881 \r
 882         switch(type1->id)\r
 883                 {\r
 884                 case E_TYPE_DWORD:\r
 885                 case E_TYPE_WORD:\r
 886                 case E_TYPE_BYTE:\r
 887                         return(1);\r
 888 \r
 889                 case E_TYPE_ARRAY:\r
 890                         if(type1->param1->inumValue!=type2->param1->inumValue)\r
 891                                 { return(0); }\r
 892 \r
 893                         return(eqUserType(type1->param2,type2->param2));\r
 894 \r
 895                 case E_TYPE_STRUCT:\r
 896                         tmp1=type1->param1;\r
 897                         tmp2=type2->param1;\r
 898 \r
 899                         while(tmp1&&tmp2)\r
 900                                 {\r
 901                                 if(!eqUserType(tmp1,tmp2))\r
 902                                         { return(0); }\r
 903 \r
 904                                 tmp1=tmp1->next;\r
 905                                 tmp2=tmp2->next;\r
 906                                 }\r
 907 \r
 908                         return(!(tmp1||tmp2));\r
 909 \r
 910                 /* dummy */\r
 911                 default:\r
 912                         return(0);\r
 913                 }\r
 914 }\r
 915 \r
 916 int getUserType(valueLeaf *type,valueLeaf **res)\r
 917 {\r
 918         valueLeaf       *tmpRes=typeRoot;\r
 919         valueLeaf       *lastRes;\r
 920         int                     index=1;\r
 921 \r
 922         while(tmpRes)\r
 923                 {\r
 924                 if(eqUserType(type,tmpRes))\r
 925                         {\r
 926                         if(res)\r
 927                                 { *res=tmpRes; }\r
 928                         return(index);\r
 929                         }\r
 930 \r
 931                 lastRes=tmpRes;\r
 932                 tmpRes=tmpRes->next;\r
 933                 index++;\r
 934                 }\r
 935 \r
 936         if(res)\r
 937                 { *res=lastRes; }\r
 938         return(0);\r
 939 }\r
 940 \r
 941 void createUserType(valueLeaf *type)\r
 942 {\r
 943         if(!typeRoot)\r
 944                 {\r
 945                 if(!(typeRoot=(valueLeaf *) myMalloc(sizeof(valueLeaf))))\r
 946                         {\r
 947                         printf("[%s:%d] ParsError:OutOfMemory%c",__FILE__,__LINE__,SEP);\r
 948                         exit(ERR_EXIT);\r
 949                         }\r
 950 \r
 951                 memcpy(typeRoot,type,sizeof(valueLeaf));\r
 952                 typeRoot->next=NULL;\r
 953                 }\r
 954         else\r
 955                 {\r
 956                 valueLeaf       *res;\r
 957 \r
 958                 if(!getUserType(type,&res))\r
 959                         {\r
 960                         if(!(res->next=(valueLeaf *) myMalloc(sizeof(valueLeaf))))\r
 961                                 {\r
 962                                 printf("[%s:%d] ParsError:OutOfMemory%c",__FILE__,__LINE__,SEP);\r
 963                                 exit(ERR_EXIT);\r
 964                                 }\r
 965 \r
 966                         memcpy(res->next,type,sizeof(valueLeaf));\r
 967                         res->next->next=NULL;\r
 968                         }\r
 969                 }\r
 970 }\r
 971 \r
 972 /* *************************** prettyPrint ************************ */\r
 973 \r
 974 void prettyPrintString(char *str)\r
 975 {\r
 976         printf("([");\r
 977 \r
 978         while(*str)\r
 979                 {\r
 980                 printf("ch_%c",*str);\r
 981 \r
 982                 if(*(str+1))\r
 983                         { printf(";"); }\r
 984 \r
 985                 str++;\r
 986                 }\r
 987 \r
 988         printf("])");\r
 989 }\r
 990 \r
 991 void prettyPrintByte(_BYTE_ num)\r
 992 {\r
 993         printf("(\\langle x%1X,x%1X \\rangle)",(unsigned int) (num>>4),(unsigned int) (num&0xF));\r
 994 }\r
 995 \r
 996 void prettyPrintWord(_WORD_ num)\r
 997 {\r
 998         printf("(\\langle \\langle x%1X,x%1X \\rangle : \\langle x%1X,x%1X \\rangle \\rangle)",\\r
 999                 (unsigned int) (num>>12),(unsigned int) ((num>>8)&0xF),\\r
1000                 (unsigned int) ((num>>4)&0xF),(unsigned int) (num&0xF));\r
1001 }\r
1002 \r
1003 void prettyPrintDword(_DWORD_ num)\r
1004 {\r
1005         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
1006                 (unsigned int) (num>>28),(unsigned int) ((num>>24)&0xF),\\r
1007                 (unsigned int) ((num>>20)&0xF),(unsigned int) ((num>>16)&0xF),\\r
1008                 (unsigned int) ((num>>12)&0xF),(unsigned int) ((num>>8)&0xF),\\r
1009                 (unsigned int) ((num>>4)&0xF),(unsigned int) (num&0xF));\r
1010 }\r
1011 \r
1012 void prettyPrintIndent(int indent)\r
1013 {\r
1014         int     index;\r
1015 \r
1016         for(index=0;index<indent;index++)\r
1017                 { printf(" "); }\r
1018 }\r
1019 \r
1020 void prettyPrintInum(unsigned long int num)\r
1021 {\r
1022         if(!num)\r
1023                 { printf("O\n"); }\r
1024         else\r
1025                 { printf("%lu\n",num); }\r
1026 }\r
1027 \r
1028 void prettyPrintInit(valueLeaf *cur,int indent)\r
1029 {\r
1030         if(cur->id==E_VALUE_BYTE)\r
1031                 { prettyPrintIndent(indent); printf("(PREAST_INIT_VAL_BYTE8 "); prettyPrintByte(cur->byteValue); printf(")\n"); }\r
1032         else if(cur->id==E_VALUE_WORD)\r
1033                 { prettyPrintIndent(indent); printf("(PREAST_INIT_VAL_WORD16 "); prettyPrintWord(cur->wordValue); printf(")\n"); }\r
1034         else if(cur->id==E_VALUE_DWORD)\r
1035                 { prettyPrintIndent(indent); printf("(PREAST_INIT_VAL_WORD32 "); prettyPrintDword(cur->dwordValue); printf(")\n"); }\r
1036         else if(cur->id==E_VALUE_ARRAY)\r
1037                 {\r
1038                 valueLeaf       *tmp=cur->param1;\r
1039 \r
1040                 prettyPrintIndent(indent); printf("(PREAST_INIT_VAL_ARRAY\n");\r
1041 \r
1042                 prettyPrintIndent(indent+1); printf("(\\laquo\n");\r
1043                 if(!tmp->next)\r
1044                         { prettyPrintIndent(indent+2); printf("£\n"); }\r
1045                 while(tmp)\r
1046                         {\r
1047                         prettyPrintInit(tmp,indent+2);\r
1048 \r
1049                         if(tmp->next)\r
1050                                 {\r
1051                                 if(tmp->next->next)\r
1052                                         { prettyPrintIndent(indent+2); printf(";\n"); }\r
1053                                 else\r
1054                                         { prettyPrintIndent(indent+2); printf("£\n"); }\r
1055                                 }\r
1056 \r
1057                         tmp=tmp->next;\r
1058                         }\r
1059                 prettyPrintIndent(indent+1); printf("\\raquo)\n");\r
1060 \r
1061                 prettyPrintIndent(indent); printf(")\n");\r
1062                 }\r
1063         else if(cur->id==E_VALUE_STRUCT)\r
1064                 {\r
1065                 valueLeaf       *tmp=cur->param1;\r
1066 \r
1067                 prettyPrintIndent(indent); printf("(PREAST_INIT_VAL_STRUCT\n");\r
1068 \r
1069                 prettyPrintIndent(indent+1); printf("(\\laquo\n");\r
1070                 if(!tmp->next)\r
1071                         { prettyPrintIndent(indent+2); printf("£\n"); }\r
1072                 while(tmp)\r
1073                         {\r
1074                         prettyPrintInit(tmp,indent+2);\r
1075 \r
1076                         if(tmp->next)\r
1077                                 {\r
1078                                 if(tmp->next->next)\r
1079                                         { prettyPrintIndent(indent+2); printf(";\n"); }\r
1080                                 else\r
1081                                         { prettyPrintIndent(indent+2); printf("£\n"); }\r
1082                                 }\r
1083 \r
1084                         tmp=tmp->next;\r
1085                         }\r
1086                 prettyPrintIndent(indent+1); printf("\\raquo)\n");\r
1087 \r
1088                 prettyPrintIndent(indent); printf(")\n");\r
1089                 }\r
1090 }\r
1091 \r
1092 void prettyPrintBody(valueLeaf *cur,int indent)\r
1093 {\r
1094         if(!cur)\r
1095                 { prettyPrintIndent(indent); printf("(PREAST_NO_DECL [])\n"); }\r
1096         else if((cur->id==E_DECL_CONST)||(cur->id==E_DECL_VAR))\r
1097                 { prettyPrint(cur,indent); }\r
1098         else\r
1099                 {\r
1100                 valueLeaf       *tmp=cur;\r
1101 \r
1102                 prettyPrintIndent(indent); printf("(PREAST_NO_DECL\n");\r
1103 \r
1104                 prettyPrintIndent(indent+1); printf("[\n");\r
1105                 while(tmp)\r
1106                         {\r
1107                         prettyPrint(tmp,indent+2);\r
1108 \r
1109                         if(tmp->next)\r
1110                                 { prettyPrintIndent(indent+2); printf(";\n"); }\r
1111 \r
1112                         tmp=tmp->next;\r
1113                         }\r
1114                 prettyPrintIndent(indent+1); printf("]\n");\r
1115 \r
1116                 prettyPrintIndent(indent); printf(")\n");\r
1117                 }\r
1118 \r
1119 }\r
1120 \r
1121 void prettyPrint(valueLeaf *cur,int indent)\r
1122 {\r
1123         /* ** misc ** */\r
1124         if(cur->id==E_VALUE_STRING)\r
1125                 { prettyPrintIndent(indent); prettyPrintString(cur->stringValue); printf("\n"); }\r
1126         else if(cur->id==E_VALUE_INUM)\r
1127                 { prettyPrintIndent(indent); prettyPrintInum(cur->inumValue); }\r
1128 \r
1129         /* ** tipi ** */\r
1130         else if(cur->id==E_TYPE_BYTE)\r
1131                 { prettyPrintIndent(indent); printf("(AST_TYPE_BASE AST_BASE_TYPE_BYTE8)\n"); }\r
1132         else if(cur->id==E_TYPE_WORD)\r
1133                 { prettyPrintIndent(indent); printf("(AST_TYPE_BASE AST_BASE_TYPE_WORD16)\n"); }\r
1134         else if(cur->id==E_TYPE_DWORD)\r
1135                 { prettyPrintIndent(indent); printf("(AST_TYPE_BASE AST_BASE_TYPE_WORD32)\n"); }\r
1136         else if(cur->id==E_TYPE_ARRAY)\r
1137                 {\r
1138                 prettyPrintIndent(indent); printf("(AST_TYPE_ARRAY\n");\r
1139                 prettyPrint(cur->param2,indent+1);      //type\r
1140                 prettyPrint(cur->param1,indent+1);      //size\r
1141                 prettyPrintIndent(indent); printf(")\n");\r
1142                 }\r
1143         else if(cur->id==E_TYPE_STRUCT)\r
1144                 {\r
1145                 valueLeaf       *tmp=cur->param1;\r
1146 \r
1147                 prettyPrintIndent(indent); printf("(AST_TYPE_STRUCT\n");\r
1148 \r
1149                 prettyPrintIndent(indent+1); printf("(\\laquo\n");\r
1150                 if(!tmp->next)\r
1151                         { prettyPrintIndent(indent+2); printf("£\n"); }\r
1152                 while(tmp)\r
1153                         {\r
1154                         prettyPrint(tmp,indent+2);\r
1155 \r
1156                         if(tmp->next)\r
1157                                 {\r
1158                                 if(tmp->next->next)\r
1159                                         { prettyPrintIndent(indent+2); printf(";\n"); }\r
1160                                 else\r
1161                                         { prettyPrintIndent(indent+2); printf("£\n"); }\r
1162                                 }\r
1163 \r
1164                         tmp=tmp->next;\r
1165                         }\r
1166                 prettyPrintIndent(indent+1); printf("\\raquo)\n");\r
1167 \r
1168                 prettyPrintIndent(indent); printf(")\n");\r
1169                 }\r
1170         \r
1171         /* ** valori come espressioni ** */\r
1172         else if(cur->id==E_VALUE_BYTE)\r
1173                 { prettyPrintIndent(indent); printf("(PREAST_EXPR_BYTE8 "); prettyPrintByte(cur->byteValue); printf(")\n"); }\r
1174         else if(cur->id==E_VALUE_WORD)\r
1175                 { prettyPrintIndent(indent); printf("(PREAST_EXPR_WORD16 "); prettyPrintWord(cur->wordValue); printf(")\n"); }\r
1176         else if(cur->id==E_VALUE_DWORD)\r
1177                 { prettyPrintIndent(indent); printf("(PREAST_EXPR_WORD32 "); prettyPrintDword(cur->dwordValue); printf(")\n"); }\r
1178 \r
1179         /* ** variabili */\r
1180         else if(cur->id==E_VAR_ROOT)\r
1181                 { prettyPrintIndent(indent); printf("(PREAST_VAR_ID "); prettyPrintString(cur->param1->stringValue); printf(")\n"); }\r
1182         else if(cur->id==E_VAR_STRUCT)\r
1183                 {\r
1184                 prettyPrintIndent(indent); printf("(PREAST_VAR_STRUCT\n");\r
1185                 prettyPrint(cur->next,indent+1);\r
1186                 prettyPrint(cur->param1,indent+1);\r
1187                 prettyPrintIndent(indent); printf(")\n");\r
1188                 }\r
1189         else if(cur->id==E_VAR_ARRAY)\r
1190                 {\r
1191                 prettyPrintIndent(indent); printf("(PREAST_VAR_ARRAY\n");\r
1192                 prettyPrint(cur->next,indent+1);\r
1193                 prettyPrint(cur->param1,indent+1);\r
1194                 prettyPrintIndent(indent); printf(")\n");\r
1195                 }\r
1196 \r
1197         /* ** espressioni ** */\r
1198         else if(cur->id==E_EXPR_VAR)\r
1199                 {\r
1200                 prettyPrintIndent(indent); printf("(PREAST_EXPR_ID\n");\r
1201                 prettyPrint(cur->param1,indent+1);\r
1202                 prettyPrintIndent(indent); printf(")\n");\r
1203                 }\r
1204         else if(cur->id==E_EXPR_NOT)\r
1205                 {\r
1206                 prettyPrintIndent(indent); printf("(PREAST_EXPR_NOT\n");\r
1207                 prettyPrint(cur->param1,indent+1);\r
1208                 prettyPrintIndent(indent); printf(")\n");\r
1209                 }\r
1210         else if(cur->id==E_EXPR_COM)\r
1211                 {\r
1212                 prettyPrintIndent(indent); printf("(PREAST_EXPR_COM\n");\r
1213                 prettyPrint(cur->param1,indent+1);\r
1214                 prettyPrintIndent(indent); printf(")\n");\r
1215                 }\r
1216         else if(cur->id==E_EXPR_NEG)\r
1217                 {\r
1218                 prettyPrintIndent(indent); printf("(PREAST_EXPR_NEG\n");\r
1219                 prettyPrint(cur->param1,indent+1);\r
1220                 prettyPrintIndent(indent); printf(")\n");\r
1221                 }\r
1222         else if(cur->id==E_EXPR_B2W)\r
1223                 {\r
1224                 prettyPrintIndent(indent); printf("(PREAST_EXPR_B8toW16\n");\r
1225                 prettyPrint(cur->param1,indent+1);\r
1226                 prettyPrintIndent(indent); printf(")\n");\r
1227                 }\r
1228         else if(cur->id==E_EXPR_B2DW)\r
1229                 {\r
1230                 prettyPrintIndent(indent); printf("(PREAST_EXPR_B8toW32\n");\r
1231                 prettyPrint(cur->param1,indent+1);\r
1232                 prettyPrintIndent(indent); printf(")\n");\r
1233                 }\r
1234         else if(cur->id==E_EXPR_W2B)\r
1235                 {\r
1236                 prettyPrintIndent(indent); printf("(PREAST_EXPR_W16toB8\n");\r
1237                 prettyPrint(cur->param1,indent+1);\r
1238                 prettyPrintIndent(indent); printf(")\n");\r
1239                 }\r
1240         else if(cur->id==E_EXPR_W2DW)\r
1241                 {\r
1242                 prettyPrintIndent(indent); printf("(PREAST_EXPR_W16toW32\n");\r
1243                 prettyPrint(cur->param1,indent+1);\r
1244                 prettyPrintIndent(indent); printf(")\n");\r
1245                 }\r
1246         else if(cur->id==E_EXPR_DW2B)\r
1247                 {\r
1248                 prettyPrintIndent(indent); printf("(PREAST_EXPR_W32toB8\n");\r
1249                 prettyPrint(cur->param1,indent+1);\r
1250                 prettyPrintIndent(indent); printf(")\n");\r
1251                 }\r
1252         else if(cur->id==E_EXPR_DW2W)\r
1253                 {\r
1254                 prettyPrintIndent(indent); printf("(PREAST_EXPR_W32toW16\n");\r
1255                 prettyPrint(cur->param1,indent+1);\r
1256                 prettyPrintIndent(indent); printf(")\n");\r
1257                 }\r
1258         else if(cur->id==E_EXPR_ADD)\r
1259                 {\r
1260                 prettyPrintIndent(indent); printf("(PREAST_EXPR_ADD\n");\r
1261                 prettyPrint(cur->param1,indent+1);\r
1262                 prettyPrint(cur->param2,indent+1);\r
1263                 prettyPrintIndent(indent); printf(")\n");\r
1264                 }\r
1265         else if(cur->id==E_EXPR_SUB)\r
1266                 {\r
1267                 prettyPrintIndent(indent); printf("(PREAST_EXPR_SUB\n");\r
1268                 prettyPrint(cur->param1,indent+1);\r
1269                 prettyPrint(cur->param2,indent+1);\r
1270                 prettyPrintIndent(indent); printf(")\n");\r
1271                 }\r
1272         else if(cur->id==E_EXPR_MUL)\r
1273                 {\r
1274                 prettyPrintIndent(indent); printf("(PREAST_EXPR_MUL\n");\r
1275                 prettyPrint(cur->param1,indent+1);\r
1276                 prettyPrint(cur->param2,indent+1);\r
1277                 prettyPrintIndent(indent); printf(")\n");\r
1278                 }\r
1279         else if(cur->id==E_EXPR_DIV)\r
1280                 {\r
1281                 prettyPrintIndent(indent); printf("(PREAST_EXPR_DIV\n");\r
1282                 prettyPrint(cur->param1,indent+1);\r
1283                 prettyPrint(cur->param2,indent+1);\r
1284                 prettyPrintIndent(indent); printf(")\n");\r
1285                 }\r
1286         else if(cur->id==E_EXPR_SHL)\r
1287                 {\r
1288                 prettyPrintIndent(indent); printf("(PREAST_EXPR_SHL\n");\r
1289                 prettyPrint(cur->param1,indent+1);\r
1290                 prettyPrint(cur->param2,indent+1);\r
1291                 prettyPrintIndent(indent); printf(")\n");\r
1292                 }\r
1293         else if(cur->id==E_EXPR_SHR)\r
1294                 {\r
1295                 prettyPrintIndent(indent); printf("(PREAST_EXPR_SHR\n");\r
1296                 prettyPrint(cur->param1,indent+1);\r
1297                 prettyPrint(cur->param2,indent+1);\r
1298                 prettyPrintIndent(indent); printf(")\n");\r
1299                 }\r
1300         else if(cur->id==E_EXPR_AND)\r
1301                 {\r
1302                 prettyPrintIndent(indent); printf("(PREAST_EXPR_AND\n");\r
1303                 prettyPrint(cur->param1,indent+1);\r
1304                 prettyPrint(cur->param2,indent+1);\r
1305                 prettyPrintIndent(indent); printf(")\n");\r
1306                 }\r
1307         else if(cur->id==E_EXPR_OR)\r
1308                 {\r
1309                 prettyPrintIndent(indent); printf("(PREAST_EXPR_OR\n");\r
1310                 prettyPrint(cur->param1,indent+1);\r
1311                 prettyPrint(cur->param2,indent+1);\r
1312                 prettyPrintIndent(indent); printf(")\n");\r
1313                 }\r
1314         else if(cur->id==E_EXPR_XOR)\r
1315                 {\r
1316                 prettyPrintIndent(indent); printf("(PREAST_EXPR_XOR\n");\r
1317                 prettyPrint(cur->param1,indent+1);\r
1318                 prettyPrint(cur->param2,indent+1);\r
1319                 prettyPrintIndent(indent); printf(")\n");\r
1320                 }\r
1321         else if(cur->id==E_EXPR_LT)\r
1322                 {\r
1323                 prettyPrintIndent(indent); printf("(PREAST_EXPR_LT\n");\r
1324                 prettyPrint(cur->param1,indent+1);\r
1325                 prettyPrint(cur->param2,indent+1);\r
1326                 prettyPrintIndent(indent); printf(")\n");\r
1327                 }\r
1328         else if(cur->id==E_EXPR_LTE)\r
1329                 {\r
1330                 prettyPrintIndent(indent); printf("(PREAST_EXPR_LTE\n");\r
1331                 prettyPrint(cur->param1,indent+1);\r
1332                 prettyPrint(cur->param2,indent+1);\r
1333                 prettyPrintIndent(indent); printf(")\n");\r
1334                 }\r
1335         else if(cur->id==E_EXPR_GT)\r
1336                 {\r
1337                 prettyPrintIndent(indent); printf("(PREAST_EXPR_GT\n");\r
1338                 prettyPrint(cur->param1,indent+1);\r
1339                 prettyPrint(cur->param2,indent+1);\r
1340                 prettyPrintIndent(indent); printf(")\n");\r
1341                 }\r
1342         else if(cur->id==E_EXPR_GTE)\r
1343                 {\r
1344                 prettyPrintIndent(indent); printf("(PREAST_EXPR_GTE\n");\r
1345                 prettyPrint(cur->param1,indent+1);\r
1346                 prettyPrint(cur->param2,indent+1);\r
1347                 prettyPrintIndent(indent); printf(")\n");\r
1348                 }\r
1349         else if(cur->id==E_EXPR_EQ)\r
1350                 {\r
1351                 prettyPrintIndent(indent); printf("(PREAST_EXPR_EQ\n");\r
1352                 prettyPrint(cur->param1,indent+1);\r
1353                 prettyPrint(cur->param2,indent+1);\r
1354                 prettyPrintIndent(indent); printf(")\n");\r
1355                 }\r
1356         else if(cur->id==E_EXPR_NEQ)\r
1357                 {\r
1358                 prettyPrintIndent(indent); printf("(PREAST_EXPR_NEQ\n");\r
1359                 prettyPrint(cur->param1,indent+1);\r
1360                 prettyPrint(cur->param2,indent+1);\r
1361                 prettyPrintIndent(indent); printf(")\n");\r
1362                 }\r
1363 \r
1364         /* ** dichiarazioni ** */\r
1365         else if(cur->id==E_DECL_CONST)\r
1366                 {\r
1367                 prettyPrintIndent(indent); printf("(PREAST_CONST_DECL\n");\r
1368                 prettyPrint(cur->param2,indent+1);      //string\r
1369                 prettyPrint(cur->param1,indent+1);      //type\r
1370                 \r
1371                 if((cur->param3->id==E_VAR_ROOT)||(cur->param3->id==E_VAR_STRUCT)||(cur->param3->id==E_VAR_ARRAY))\r
1372                         {\r
1373                         prettyPrintIndent(indent+1); printf("(PREAST_INIT_VAR\n");\r
1374                         prettyPrint(cur->param3,indent+2);      //init\r
1375                         prettyPrintIndent(indent+1); printf(")\n");\r
1376                         }\r
1377                 else\r
1378                         {\r
1379                         prettyPrintIndent(indent+1); printf("(PREAST_INIT_VAL\n");\r
1380                         prettyPrintInit(cur->param3,indent+2);  //init\r
1381                         prettyPrintIndent(indent+1); printf(")\n");\r
1382                         }\r
1383 \r
1384                 if(cur->next)\r
1385                         {\r
1386                         if((cur->next->id==E_DECL_CONST)||(cur->next->id==E_DECL_VAR))\r
1387                                 { prettyPrint(cur->next,indent+1); }    //next decl\r
1388                         else\r
1389                                 {\r
1390                                 valueLeaf       *tmp=cur->next;\r
1391 \r
1392                                 prettyPrintIndent(indent+1); printf("(PREAST_NO_DECL\n");\r
1393 \r
1394                                 prettyPrintIndent(indent+2); printf("[\n");\r
1395                                 while(tmp)\r
1396                                         {\r
1397                                         prettyPrint(tmp,indent+3);\r
1398 \r
1399                                         if(tmp->next)\r
1400                                                 { prettyPrintIndent(indent+3); printf(";\n"); }\r
1401 \r
1402                                         tmp=tmp->next;\r
1403                                         }\r
1404                                 prettyPrintIndent(indent+2); printf("]\n");\r
1405 \r
1406                                 prettyPrintIndent(indent+1); printf(")\n");\r
1407                                 }\r
1408                         }\r
1409                 else\r
1410                         { prettyPrintIndent(indent+1); printf("(PREAST_NO_DECL [])\n"); }\r
1411                 \r
1412 \r
1413                 prettyPrintIndent(indent); printf(")\n");\r
1414                 }\r
1415         else if(cur->id==E_DECL_VAR)\r
1416                 {\r
1417                 prettyPrintIndent(indent); printf("(PREAST_VAR_DECL\n");\r
1418                 prettyPrint(cur->param2,indent+1);      //string\r
1419                 prettyPrint(cur->param1,indent+1);      //type\r
1420                 \r
1421                 if(cur->param3)\r
1422                         {\r
1423                         prettyPrintIndent(indent+1); printf("(Some ?\n");\r
1424 \r
1425                         if((cur->param3->id==E_VAR_ROOT)||(cur->param3->id==E_VAR_STRUCT)||(cur->param3->id==E_VAR_ARRAY))\r
1426                                 {\r
1427                                 prettyPrintIndent(indent+2); printf("(PREAST_INIT_VAR\n");\r
1428                                 prettyPrint(cur->param3,indent+3);      //init\r
1429                                 prettyPrintIndent(indent+2); printf(")\n");\r
1430                                 }\r
1431                         else\r
1432                                 {\r
1433                                 prettyPrintIndent(indent+2); printf("(PREAST_INIT_VAL\n");\r
1434                                 prettyPrintInit(cur->param3,indent+3);  //init\r
1435                                 prettyPrintIndent(indent+2); printf(")\n");\r
1436                                 }\r
1437 \r
1438                         prettyPrintIndent(indent+1); printf(")\n");\r
1439                         }\r
1440                 else\r
1441                         { prettyPrintIndent(indent+1); printf("(None ?)\n"); }\r
1442 \r
1443                 if(cur->next)\r
1444                         {\r
1445                         if((cur->next->id==E_DECL_CONST)||(cur->next->id==E_DECL_VAR))\r
1446                                 { prettyPrint(cur->next,indent+1); }    //next decl\r
1447                         else\r
1448                                 {\r
1449                                 valueLeaf       *tmp=cur->next;\r
1450 \r
1451                                 prettyPrintIndent(indent+1); printf("(PREAST_NO_DECL\n");\r
1452 \r
1453                                 prettyPrintIndent(indent+2); printf("[\n");\r
1454                                 while(tmp)\r
1455                                         {\r
1456                                         prettyPrint(tmp,indent+3);\r
1457 \r
1458                                         if(tmp->next)\r
1459                                                 { prettyPrintIndent(indent+3); printf(";\n"); }\r
1460 \r
1461                                         tmp=tmp->next;\r
1462                                         }\r
1463                                 prettyPrintIndent(indent+2); printf("]\n");\r
1464 \r
1465                                 prettyPrintIndent(indent+1); printf(")\n");\r
1466                                 }\r
1467                         }\r
1468                 else\r
1469                         { prettyPrintIndent(indent+1); printf("(PREAST_NO_DECL [])\n"); }\r
1470                 \r
1471 \r
1472                 prettyPrintIndent(indent); printf(")\n");\r
1473                 }\r
1474 \r
1475         /* ** statement ** */\r
1476         else if(cur->id==E_STM_ASG)\r
1477                 {\r
1478                 prettyPrintIndent(indent); printf("(PREAST_STM_ASG\n");\r
1479                 prettyPrint(cur->param1,indent+1);\r
1480                 prettyPrint(cur->param2,indent+1);\r
1481                 prettyPrintIndent(indent); printf(")\n");\r
1482                 }\r
1483         else if(cur->id==E_STM_WHILE)\r
1484                 {\r
1485                 prettyPrintIndent(indent); printf("(PREAST_STM_WHILE\n");\r
1486                 prettyPrint(cur->param1,indent+1);\r
1487                 prettyPrintBody(cur->param2,indent+1);\r
1488                 prettyPrintIndent(indent); printf(")\n");\r
1489                 }\r
1490         else if(cur->id==E_STM_IF)\r
1491                 {\r
1492                 valueLeaf       *tmp=cur->param1;\r
1493 \r
1494                 prettyPrintIndent(indent); printf("(PREAST_STM_IF\n");\r
1495 \r
1496                 prettyPrintIndent(indent+1); printf("(\\laquo\n");\r
1497                 if(!tmp->next)\r
1498                         { prettyPrintIndent(indent+2); printf("£\n"); }\r
1499                 while(tmp)\r
1500                         {\r
1501                         prettyPrintIndent(indent+2); printf("(pair ??\n");\r
1502                         prettyPrint(tmp->param1,indent+3);\r
1503                         prettyPrintBody(tmp->param2,indent+3);\r
1504                         prettyPrintIndent(indent+2); printf(")\n");\r
1505 \r
1506                         if(tmp->next)\r
1507                                 {\r
1508                                 if(tmp->next->next)\r
1509                                         { prettyPrintIndent(indent+2); printf(";\n"); }\r
1510                                 else\r
1511                                         { prettyPrintIndent(indent+2); printf("£\n"); }\r
1512                                 }\r
1513 \r
1514                         tmp=tmp->next;\r
1515                         }\r
1516                 prettyPrintIndent(indent+1); printf("\\raquo)\n");\r
1517 \r
1518                 // equivalenza: Some ? (PREAST_NO_DECL []) = None ?\r
1519                 if(cur->param2)\r
1520                         {\r
1521                         prettyPrintIndent(indent+1); printf("(Some ?\n");\r
1522                         prettyPrintBody(cur->param2,indent+2);  //body\r
1523                         prettyPrintIndent(indent+1); printf(")\n");\r
1524                         }\r
1525                 else\r
1526                         { prettyPrintIndent(indent+1); printf("(None ?)\n"); }\r
1527 \r
1528                 prettyPrintIndent(indent); printf(")\n");\r
1529                 }\r
1530 }\r
1531 \r
1532 /* *************************** cPrint ***************************** */\r
1533 \r
1534 void cPrintIndent(int indent)\r
1535 {\r
1536         int     index;\r
1537 \r
1538         for(index=0;index<indent;index++)\r
1539                 { printf("\t"); }\r
1540 }\r
1541 \r
1542 void cPrintTypesAux(valueLeaf *type,int field)\r
1543 {\r
1544         if(type->id==E_TYPE_STRUCT)\r
1545                 { printf("\tuser%d_t\tfield%d;\n\n",getUserType(type,NULL),field); }\r
1546         else if(type->id==E_TYPE_ARRAY)\r
1547                 {\r
1548                 char            bufferDim[256];\r
1549                 valueLeaf       *tmp=type;\r
1550 \r
1551                 memset(bufferDim,0,256);\r
1552 \r
1553                 while(tmp->id==E_TYPE_ARRAY)\r
1554                         {\r
1555                         sprintf(&bufferDim[strlen(bufferDim)],"[%d]",tmp->param1->inumValue+1);\r
1556                         tmp=tmp->param2;\r
1557                         }\r
1558 \r
1559                 if(tmp->id==E_TYPE_STRUCT)\r
1560                         { printf("\tuser%d_t\tfield%d%s;\n\n",getUserType(tmp,NULL),field,bufferDim); }\r
1561                 else if(tmp->id==E_TYPE_DWORD)\r
1562                         { printf("\t_DWORD_\tfield%d%s;\n\n",field,bufferDim); }\r
1563                 else if(tmp->id==E_TYPE_WORD)\r
1564                         { printf("\t_WORD_\tfield%d%s;\n\n",field,bufferDim); }\r
1565                 else\r
1566                         { printf("\t_BYTE_\tfield%d%s;\n\n",field,bufferDim); }\r
1567                 }\r
1568         else if(type->id==E_TYPE_DWORD)\r
1569                 { printf("\t_DWORD_\tfield%d;\n\n",field); }\r
1570         else if(type->id==E_TYPE_WORD)\r
1571                 { printf("\t_WORD_\tfield%d;\n\n",field); }\r
1572         else\r
1573                 { printf("\t_BYTE_\tfield%d;\n\n",field); }\r
1574 \r
1575         if(type->next)\r
1576                 { cPrintTypesAux(type->next,field+1); }\r
1577 }\r
1578 \r
1579 void cPrintTypes(void)\r
1580 {\r
1581         int                     index=1;\r
1582         valueLeaf       *cur=typeRoot;\r
1583 \r
1584         while(cur)\r
1585                 {\r
1586                 printf("typedef struct\n");\r
1587                 printf("{\n");\r
1588                 cPrintTypesAux(cur->param1,0);\r
1589                 printf("} user%d_t;\n\n",index);\r
1590 \r
1591                 cur=cur->next;\r
1592                 index++;\r
1593                 }\r
1594 }\r
1595 \r
1596 void cPrint(valueLeaf *cur,int indent)\r
1597 {\r
1598         /* ** valori ** */\r
1599         if(cur->id==E_VALUE_INUM)\r
1600                 { printf("%lu",cur->inumValue); }\r
1601         else if(cur->id==E_VALUE_BYTE)\r
1602                 { printf("0x%02lX",(_DWORD_) cur->byteValue); }\r
1603         else if(cur->id==E_VALUE_WORD)\r
1604                 { printf("0x%04lX",(_DWORD_) cur->wordValue); }\r
1605         else if(cur->id==E_VALUE_DWORD)\r
1606                 { printf("0x%08lX",cur->dwordValue); }\r
1607         else if((cur->id==E_VALUE_ARRAY)||(cur->id==E_VALUE_STRUCT))\r
1608                 {\r
1609                 valueLeaf       *tmp=cur->param1;\r
1610 \r
1611                 printf("{ ");\r
1612                 while(tmp)\r
1613                         {\r
1614                         cPrint(tmp,indent);\r
1615                         tmp=tmp->next;\r
1616                         if(tmp)\r
1617                                 { printf(", "); }\r
1618                         }\r
1619                 printf(" }");\r
1620                 }\r
1621 \r
1622         /* ** variabili ** */\r
1623         else if((cur->id==E_VAR_ROOT)||(cur->id==E_VAR_STRUCT)||(cur->id==E_VAR_ARRAY))\r
1624                 {\r
1625                 valueLeaf       *tmp=cur;\r
1626 \r
1627                 while(tmp->id!=E_VAR_ROOT)\r
1628                         {\r
1629                         tmp->next->last=tmp;\r
1630                         tmp=tmp->next;\r
1631                         }\r
1632 \r
1633                 while(1)\r
1634                         {\r
1635                         if(tmp->id==E_VAR_ROOT)\r
1636                                 { printf("%s",tmp->param1->stringValue); }\r
1637                         else if(tmp->id==E_VAR_STRUCT)\r
1638                                 { printf(".field%lu",tmp->param1->inumValue); }\r
1639                         else if(tmp->id==E_VAR_ARRAY)\r
1640                                 { printf("["); cPrint(tmp->param1,indent); printf("]"); }\r
1641 \r
1642                         if(tmp==cur)\r
1643                                 { break; }\r
1644                         else\r
1645                                 { tmp=tmp->last; }\r
1646                         }\r
1647                 }\r
1648 \r
1649         /* ** espressioni ** */\r
1650         else if(cur->id==E_EXPR_VAR)\r
1651                 { cPrint(cur->param1,indent); }\r
1652         else if(cur->id==E_EXPR_NOT)\r
1653                 { printf("!("); cPrint(cur->param1,indent); printf(")"); }\r
1654         else if(cur->id==E_EXPR_COM)\r
1655                 { printf("~("); cPrint(cur->param1,indent); printf(")"); }\r
1656         else if(cur->id==E_EXPR_NEG)\r
1657                 { printf("-("); cPrint(cur->param1,indent); printf(")"); }\r
1658         else if((cur->id==E_EXPR_W2B)||(cur->id==E_EXPR_DW2B))\r
1659                 { printf("((_BYTE_) ("); cPrint(cur->param1,indent); printf("))"); }\r
1660         else if((cur->id==E_EXPR_B2W)||(cur->id==E_EXPR_DW2W))\r
1661                 { printf("((_WORD_) ("); cPrint(cur->param1,indent); printf("))"); }\r
1662         else if((cur->id==E_EXPR_B2DW)||(cur->id==E_EXPR_W2DW))\r
1663                 { printf("((_DWORD_) ("); cPrint(cur->param1,indent); printf("))"); }\r
1664         else if(cur->id==E_EXPR_ADD)\r
1665                 { printf("("); cPrint(cur->param1,indent); printf(") + ("); cPrint(cur->param2,indent); printf(")"); }\r
1666         else if(cur->id==E_EXPR_SUB)\r
1667                 { printf("("); cPrint(cur->param1,indent); printf(") - ("); cPrint(cur->param2,indent); printf(")"); }\r
1668         else if(cur->id==E_EXPR_MUL)\r
1669                 { printf("("); cPrint(cur->param1,indent); printf(") * ("); cPrint(cur->param2,indent); printf(")"); }\r
1670         else if(cur->id==E_EXPR_DIV)\r
1671                 { printf("("); cPrint(cur->param1,indent); printf(") / ("); cPrint(cur->param2,indent); printf(")"); }\r
1672         else if(cur->id==E_EXPR_SHL)\r
1673                 { printf("("); cPrint(cur->param1,indent); printf(") << ("); cPrint(cur->param2,indent); printf(")"); }\r
1674         else if(cur->id==E_EXPR_SHR)\r
1675                 { printf("("); cPrint(cur->param1,indent); printf(") >> ("); cPrint(cur->param2,indent); printf(")"); }\r
1676         else if(cur->id==E_EXPR_AND)\r
1677                 { printf("("); cPrint(cur->param1,indent); printf(") & ("); cPrint(cur->param2,indent); printf(")"); }\r
1678         else if(cur->id==E_EXPR_OR)\r
1679                 { printf("("); cPrint(cur->param1,indent); printf(") | ("); cPrint(cur->param2,indent); printf(")"); }\r
1680         else if(cur->id==E_EXPR_XOR)\r
1681                 { printf("("); cPrint(cur->param1,indent); printf(") ^ ("); cPrint(cur->param2,indent); printf(")"); }\r
1682         else if(cur->id==E_EXPR_LT)\r
1683                 { printf("("); cPrint(cur->param1,indent); printf(") < ("); cPrint(cur->param2,indent); printf(")"); }\r
1684         else if(cur->id==E_EXPR_LTE)\r
1685                 { printf("("); cPrint(cur->param1,indent); printf(") <= ("); cPrint(cur->param2,indent); printf(")"); }\r
1686         else if(cur->id==E_EXPR_GT)\r
1687                 { printf("("); cPrint(cur->param1,indent); printf(") > ("); cPrint(cur->param2,indent); printf(")"); }\r
1688         else if(cur->id==E_EXPR_GTE)\r
1689                 { printf("("); cPrint(cur->param1,indent); printf(") >= ("); cPrint(cur->param2,indent); printf(")"); }\r
1690         else if(cur->id==E_EXPR_EQ)\r
1691                 { printf("("); cPrint(cur->param1,indent); printf(") == ("); cPrint(cur->param2,indent); printf(")"); }\r
1692         else if(cur->id==E_EXPR_NEQ)\r
1693                 { printf("("); cPrint(cur->param1,indent); printf(") != ("); cPrint(cur->param2,indent); printf(")"); }\r
1694 \r
1695         /* ** statement ** */\r
1696         else if(cur->id==E_STM_ASG)\r
1697                 {\r
1698                 cPrintIndent(indent); cPrint(cur->param1,indent); printf(" = "); cPrint(cur->param2,indent); printf(";\n\n");\r
1699 \r
1700                 if(cur->next)\r
1701                         { cPrint(cur->next,indent); }\r
1702                 }\r
1703         else if(cur->id==E_STM_WHILE)\r
1704                 {\r
1705                 cPrintIndent(indent); printf("while("); cPrint(cur->param1,indent); printf(")\n");\r
1706                 cPrintIndent(indent+1); printf("{\n");\r
1707                 cPrint(cur->param2,indent+1);\r
1708                 cPrintIndent(indent+1); printf("}\n\n");\r
1709 \r
1710                 if(cur->next)\r
1711                         { cPrint(cur->next,indent); }\r
1712                 }\r
1713         else if(cur->id==E_STM_IF)\r
1714                 {\r
1715                 valueLeaf       *tmp=cur->param1;\r
1716 \r
1717                 while(tmp)\r
1718                         {\r
1719                         cPrintIndent(indent); printf("%s(",(tmp==cur->param1) ? "if" : "else if"); cPrint(tmp->param1,indent); printf(")\n");\r
1720                         cPrintIndent(indent+1); printf("{\n");\r
1721                         cPrint(tmp->param2,indent+1);\r
1722                         cPrintIndent(indent+1); printf("}\n");\r
1723 \r
1724                         tmp=tmp->next;\r
1725                         }\r
1726 \r
1727                 if(cur->param2)\r
1728                         {\r
1729                         cPrintIndent(indent); printf("else\n");\r
1730                         cPrintIndent(indent+1); printf("{\n");\r
1731                         cPrint(cur->param2,indent+1);\r
1732                         cPrintIndent(indent+1); printf("}\n");\r
1733                         }\r
1734 \r
1735                 printf("\n");\r
1736 \r
1737                 if(cur->next)\r
1738                         { cPrint(cur->next,indent); }\r
1739                 }\r
1740 \r
1741         /* ** dichiarazioni ** */\r
1742         else if((cur->id==E_DECL_CONST)||(cur->id==E_DECL_VAR))\r
1743                 {\r
1744                 valueLeaf       *tmp=cur->param1;\r
1745                 char            bufferDim[256];\r
1746 \r
1747                 memset(bufferDim,0,256);\r
1748 \r
1749                 while(tmp->id==E_TYPE_ARRAY)\r
1750                         {\r
1751                         sprintf(&bufferDim[strlen(bufferDim)],"[%d]",tmp->param1->inumValue+1);\r
1752                         tmp=tmp->param2;\r
1753                         }\r
1754 \r
1755                 cPrintIndent(indent);\r
1756                 if(cur->id==E_DECL_CONST)\r
1757                         { printf("const "); }\r
1758 \r
1759                 if(tmp->id==E_TYPE_STRUCT)\r
1760                         { printf("user%d_t\t",getUserType(tmp,NULL)); }\r
1761                 else if(tmp->id==E_TYPE_DWORD)\r
1762                         { printf("_DWORD_\t"); }\r
1763                 else if(tmp->id==E_TYPE_WORD)\r
1764                         { printf("_WORD_\t"); }\r
1765                 else\r
1766                         { printf("_BYTE_\t"); }\r
1767 \r
1768                 printf("%s%s",cur->param2->stringValue,bufferDim);\r
1769 \r
1770                 if(cur->param3)\r
1771                         { printf(" = "); cPrint(cur->param3,indent); }\r
1772                 printf(";\n\n");\r
1773 \r
1774                 if(cur->next)\r
1775                         { cPrint(cur->next,indent); }\r
1776                 }\r
1777 }\r
1778 \r
1779 /* *************************** main ******************************* */\r
1780 \r
1781 int main(int argc,char **argv)\r
1782 {\r
1783         int             ret;\r
1784 \r
1785         /* ignora eventuali errori di parametri */\r
1786         if(argc>1)\r
1787                 { usage(argv[0]); }\r
1788 \r
1789         ret=yyparse(NULL);\r
1790 \r
1791         if((!ret)&&(!numErr))\r
1792                 {\r
1793                 printf("(* matita language *)\n\n");\r
1794                 printf("definition parsingResult \\def\n");\r
1795                 printf(" (PREAST_ROOT\n");\r
1796                 prettyPrint(&root,2);\r
1797                 printf(" ).\n\n");\r
1798 \r
1799                 printf("(* C language\n\n");\r
1800                 printf("#ifndef\t__STDC__\n");\r
1801                 printf("typedef\tunsigned __int32\t_DWORD_;\n");\r
1802                 printf("typedef\tunsigned __int16\t_WORD_;\n");\r
1803                 printf("typedef\tunsigned __int8\t_BYTE_;\n");\r
1804                 printf("#else\n");\r
1805                 printf("typedef\t__uint32_t\t_DWORD_;\n");\r
1806                 printf("typedef\t__uint16_t\t_WORD_;\n");\r
1807                 printf("typedef\t__uint8_t\t_BYTE_;\n");\r
1808                 printf("#endif\n\n");\r
1809                 cPrintTypes();\r
1810                 printf("void main(void)\n");\r
1811                 printf("{\n");\r
1812                 cPrint(&root,1);\r
1813                 printf("\treturn;\n\n");\r
1814                 printf("}\n\n");\r
1815                 printf("*)");\r
1816                 }\r
1817 \r
1818         return(ret);\r
1819 }\r