--- /dev/null
+\r
+/* ******************************** */\r
+/* PER UNA CORRETTA VISUALIZZAZIONE */\r
+/* tab size=4 */\r
+/* ******************************** */\r
+\r
+%{\r
+\r
+#include <stdio.h>\r
+#include <stdlib.h>\r
+#include <string.h>\r
+#include <sys/types.h>\r
+\r
+/* ************************************************************************* */\r
+\r
+#define YYDEBUG 1 /* debug interno di bison */\r
+\r
+#define inline /* compatibilita' con l'opzione %glr-parser */\r
+#define YYLTYPE_IS_DECLARED 1 /* compatibilita' con VISUAL C */\r
+\r
+#define SEP '\n' /* formattazione in input */\r
+\r
+#define YYSTYPE valueLeaf * /* struttura puntata dai nodi/foglie */\r
+\r
+#define ERR_EXIT -1\r
+\r
+/* manipolazione della posizione nel sorgente (bison) */\r
+#define YYLLOC_DEFAULT(Current,Rhs,N) \\r
+ do \\r
+ if(N) \\r
+ { \\r
+ (Current).first_line=YYRHSLOC(Rhs,1).first_line; \\r
+ (Current).first_column=YYRHSLOC(Rhs,1).first_column; \\r
+ (Current).last_line=YYRHSLOC(Rhs,N).last_line; \\r
+ (Current).last_column=YYRHSLOC(Rhs,N).last_column; \\r
+ (Current).source=YYRHSLOC(Rhs,1).source; \\r
+ } \\r
+ else \\r
+ { \\r
+ (Current).first_line=(Current).last_line=YYRHSLOC(Rhs,0).last_line; \\r
+ (Current).first_column=(Current).last_column=YYRHSLOC(Rhs,0).last_column; \\r
+ (Current).source=YYRHSLOC(Rhs,0).source; \\r
+ } \\r
+ while(0)\r
+\r
+#ifndef __STDC__\r
+#define __STDC__\r
+\r
+#define myMalloc(x) malloc((x<512) ? 512 : x)\r
+typedef unsigned __int32 _DWORD_; /* definizione univoca DWORD */\r
+typedef unsigned __int16 _WORD_; /* definizione univoca WORD */\r
+typedef unsigned __int8 _BYTE_; /* definizione univoca BYTE */\r
+\r
+#else\r
+\r
+#define myMalloc(x) malloc((x<512) ? 512 : x)\r
+typedef __uint32_t _DWORD_; /* definizione univoca DWORD */\r
+typedef __uint16_t _WORD_; /* definizione univoca WORD */\r
+typedef __uint8_t _BYTE_; /* definizione univoca BYTE */\r
+\r
+#endif\r
+\r
+/* ************************************************************************* */\r
+\r
+/* struttura per la posizione manipolata direttamente da YYLOC_DEFAULT (bison) */\r
+typedef struct YYLTYPE\r
+ {\r
+ int first_line;\r
+ int first_column;\r
+ int last_line;\r
+ int last_column;\r
+ char *source;\r
+ } YYLTYPE;\r
+\r
+/* enumerazione delle etichette dei nodi/foglie */\r
+typedef enum {\r
+ E_VALUE_ARRAY,\r
+ E_VALUE_STRUCT,\r
+ E_VALUE_DWORD,\r
+ E_VALUE_WORD,\r
+ E_VALUE_BYTE,\r
+ E_VALUE_INUM,\r
+ E_VALUE_STRING,\r
+\r
+ E_DECL_CONST,\r
+ E_DECL_VAR,\r
+\r
+ E_STM_ASG,\r
+ E_STM_WHILE,\r
+ E_STM_IF,\r
+ E_STM_IFEXPRBODY,\r
+\r
+ E_EXPR_NEG,\r
+ E_EXPR_NOT,\r
+ E_EXPR_COM,\r
+ E_EXPR_MUL,\r
+ E_EXPR_DIV,\r
+ E_EXPR_ADD,\r
+ E_EXPR_SUB,\r
+ E_EXPR_SHL,\r
+ E_EXPR_SHR,\r
+ E_EXPR_LT,\r
+ E_EXPR_LTE,\r
+ E_EXPR_GT,\r
+ E_EXPR_GTE,\r
+ E_EXPR_NEQ,\r
+ E_EXPR_EQ,\r
+ E_EXPR_AND,\r
+ E_EXPR_OR,\r
+ E_EXPR_XOR,\r
+ E_EXPR_B2W,\r
+ E_EXPR_B2DW,\r
+ E_EXPR_W2B,\r
+ E_EXPR_W2DW,\r
+ E_EXPR_DW2B,\r
+ E_EXPR_DW2W,\r
+ E_EXPR_VAR,\r
+\r
+ E_VAR_ROOT,\r
+ E_VAR_STRUCT,\r
+ E_VAR_ARRAY,\r
+\r
+ E_TYPE_ARRAY,\r
+ E_TYPE_STRUCT,\r
+ E_TYPE_DWORD,\r
+ E_TYPE_WORD,\r
+ E_TYPE_BYTE,\r
+\r
+ } vEnum;\r
+\r
+/* struttura polimorfa dei nodi/foglie */\r
+typedef struct _valueLeaf_\r
+ {\r
+ /* etichetta */\r
+ vEnum id;\r
+\r
+ _DWORD_ dwordValue;\r
+ _WORD_ wordValue;\r
+ _BYTE_ byteValue;\r
+ unsigned long int inumValue;\r
+ char *stringValue;\r
+\r
+ struct _valueLeaf_ *param1;\r
+ struct _valueLeaf_ *param2;\r
+ struct _valueLeaf_ *param3;\r
+ struct _valueLeaf_ *param4;\r
+\r
+ /* per tutti */\r
+ struct _valueLeaf_ *next;\r
+ struct _valueLeaf_ *last;\r
+\r
+ /* posizione nel sorgente */\r
+ int fileLine;\r
+ int fileRow;\r
+ char *source;\r
+ } valueLeaf;\r
+\r
+/* ************************************************************************* */\r
+\r
+valueLeaf root; /* radice dell'AST */\r
+valueLeaf *typeRoot=NULL; /* radice degli user type */\r
+\r
+int numErr=0;\r
+\r
+/* ************************************************************************* */\r
+\r
+int yylex(YYSTYPE *lvalp,YYLTYPE *llocp,void *p);\r
+void yyerror(const YYLTYPE *locp,void *p,char const *msg);\r
+valueLeaf *treeAlloc(\\r
+ vEnum id,\\r
+ _DWORD_ dwordValue,\\r
+ _WORD_ wordValue,\\r
+ _BYTE_ byteValue,\\r
+ unsigned long int inumValue,\\r
+ char *stringValue,\\r
+ valueLeaf *param1,\\r
+ valueLeaf *param2,\\r
+ valueLeaf *param3,\\r
+ const YYLTYPE *locp);\r
+\r
+valueLeaf *treeDwordAlloc(_DWORD_ dwordValue,const YYLTYPE *locp);\r
+valueLeaf *treeWordAlloc(_WORD_ wordValue,const YYLTYPE *locp);\r
+valueLeaf *treeByteAlloc(_BYTE_ byteValue,const YYLTYPE *locp);\r
+valueLeaf *treeInumAlloc(unsigned long int inumValue,const YYLTYPE *locp);\r
+valueLeaf *treeStringAlloc(char *stringValue,const YYLTYPE *locp);\r
+valueLeaf *treeId0Alloc(vEnum id,const YYLTYPE *locp);\r
+valueLeaf *treeId1Alloc(vEnum id,valueLeaf *param1,const YYLTYPE *locp);\r
+valueLeaf *treeId2Alloc(vEnum id,valueLeaf *param1,valueLeaf *param2,const YYLTYPE *locp);\r
+valueLeaf *treeId3Alloc(vEnum id,valueLeaf *param1,valueLeaf *param2,valueLeaf *param3,const YYLTYPE *locp);\r
+\r
+int eqUserType(valueLeaf *type1,valueLeaf *type2);\r
+int getUserType(valueLeaf *type,valueLeaf **res);\r
+void createUserType(valueLeaf *type);\r
+\r
+void prettyPrint(valueLeaf *cur,int indent);\r
+\r
+/* ************************************************************************* */\r
+\r
+%}\r
+\r
+%locations\r
+%pure-parser\r
+%lex-param {void *p}\r
+%parse-param {void *p}\r
+%error-verbose\r
+\r
+/* ************************************************************************* */\r
+\r
+/* keyword */\r
+%token Keyword_STRUCT Keyword_ARRAY Keyword_OF \r
+%token Keyword_IF Keyword_ELSIF Keyword_ELSE Keyword_WHILE Keyword_CONST\r
+%token Keyword_B2W Keyword_B2DW Keyword_W2B Keyword_W2DW Keyword_DW2B Keyword_DW2W\r
+\r
+/* tipi nativi */\r
+%token Type_BYTE Type_WORD Type_DWORD\r
+\r
+/* parentesi */\r
+%token OpenBracket_BODY CloseBracket_BODY\r
+%token OpenBracket_SQUARE CloseBracket_SQUARE\r
+%token OpenBracket_ROUND CloseBracket_ROUND\r
+\r
+/* operatori unari */\r
+%token UnaryOperator_NOT UnaryOperator_COM\r
+\r
+/* operatori duali */\r
+%token DualOperator_AND DualOperator_OR DualOperator_XOR\r
+%token DualOperator_ADD DualOperator_SUB DualOperator_MUL DualOperator_DIV\r
+%token DualOperator_NEQ DualOperator_EQ DualOperator_LT DualOperator_GT DualOperator_LTE DualOperator_GTE\r
+%token DualOperator_ASG DualOperator_SHR DualOperator_SHL\r
+\r
+/* separatori */\r
+%token Separator_COLUMN Separator_SELECT Separator_COMMA\r
+\r
+/* valori */\r
+%token Value_DWORD Value_WORD Value_BYTE Value_INUM Value_STRING\r
+\r
+/* ************************************************************************* */\r
+\r
+%start _start_\r
+\r
+/* priorita' minima */\r
+\r
+%right Separator_COMMA\r
+\r
+%nonassoc DualOperator_ASG\r
+\r
+%nonassoc Keyword_B2W Keyword_B2DW Keyword_W2B Keyword_W2DW Keyword_DW2B Keyword_DW2W\r
+\r
+%left DualOperator_OR\r
+%left DualOperator_XOR\r
+%left DualOperator_AND\r
+\r
+%nonassoc DualOperator_NEQ\r
+%nonassoc DualOperator_EQ\r
+%nonassoc DualOperator_GTE\r
+%nonassoc DualOperator_GT\r
+%nonassoc DualOperator_LTE\r
+%nonassoc DualOperator_LT\r
+\r
+%left DualOperator_SHR\r
+%left DualOperator_SHL\r
+%left DualOperator_SUB\r
+%left DualOperator_ADD\r
+%left DualOperator_DIV\r
+%left DualOperator_MUL\r
+\r
+%nonassoc UnaryOperator_SUB\r
+%nonassoc UnaryOperator_COM\r
+%nonassoc UnaryOperator_NOT\r
+\r
+%right Separator_SELECT\r
+%right Separator_COLUMN\r
+\r
+%nonassoc OpenBracket_SQUARE CloseBracket_SQUARE\r
+%nonassoc OpenBracket_ROUND CloseBracket_ROUND \r
+%nonassoc OpenBracket_BODY CloseBracket_BODY\r
+\r
+/* priorita' massima */ \r
+\r
+/* ************************************************************************* */\r
+\r
+%%\r
+\r
+/* ** FUNZIONE PRINCIPALE ** */\r
+_start_ : OpenBracket_BODY _decl_lst_ CloseBracket_BODY\r
+ { memcpy(&root,$2,sizeof(valueLeaf)); };\r
+\r
+/* ** GESTIONE DICHIARAZIONI ** */\r
+_decl_lst_ : Keyword_CONST _type_ Value_STRING DualOperator_ASG _init_choice_ Separator_COLUMN _decl_lst_\r
+ {\r
+ $$=treeId3Alloc(E_DECL_CONST,$2,$3,$5,&@1);\r
+ $$->next=$7;\r
+ }|\r
+ _type_ Value_STRING _init_ Separator_COLUMN _decl_lst_\r
+ {\r
+ $$=treeId3Alloc(E_DECL_VAR,$1,$2,$3,&@1);\r
+ $$->next=$5; \r
+ }|\r
+ _stm_lst_\r
+ { $$=$1; };\r
+\r
+_type_ : Keyword_ARRAY OpenBracket_SQUARE Value_INUM CloseBracket_SQUARE Keyword_OF _type_\r
+ {\r
+ if(!($3->inumValue))\r
+ { yyerror(&@1,p,"unallowed empty array"); }\r
+ else\r
+ {\r
+ $$=treeId2Alloc(E_TYPE_ARRAY,$3,$6,&@1);\r
+ $3->inumValue--;\r
+ }\r
+ }|\r
+ Keyword_STRUCT OpenBracket_BODY _type_ Separator_COLUMN _type_lst_ CloseBracket_BODY\r
+ {\r
+ $$=treeId1Alloc(E_TYPE_STRUCT,$3,&@1);\r
+ $3->next=$5;\r
+\r
+ createUserType($$);\r
+ }|\r
+ Type_DWORD\r
+ { $$=treeId0Alloc(E_TYPE_DWORD,&@1); }|\r
+ Type_WORD\r
+ { $$=treeId0Alloc(E_TYPE_WORD,&@1); }|\r
+ Type_BYTE\r
+ { $$=treeId0Alloc(E_TYPE_BYTE,&@1); };\r
+\r
+_type_lst_ : _type_ Separator_COLUMN _type_lst_\r
+ {\r
+ $1->next=$3;\r
+ $$=$1;\r
+ }|\r
+ /* epsilon */\r
+ { $$=NULL; };\r
+\r
+_init_ : DualOperator_ASG _init_choice_\r
+ { $$=$2; }|\r
+ /* epsilon */\r
+ { $$=NULL; };\r
+\r
+_init_choice_ : _init_val_\r
+ { $$=$1; }|\r
+ _var_\r
+ { $$=$1; };\r
+\r
+_init_val_ : OpenBracket_SQUARE _init_val_ _init_val_lst_ CloseBracket_SQUARE\r
+ {\r
+ $$=treeId1Alloc(E_VALUE_ARRAY,$2,&@1);\r
+ $2->next=$3;\r
+ }|\r
+ OpenBracket_BODY _init_val_ _init_val_lst_ CloseBracket_BODY\r
+ {\r
+ $$=treeId1Alloc(E_VALUE_STRUCT,$2,&@1);\r
+ $2->next=$3;\r
+ }|\r
+ Value_DWORD\r
+ { $$=$1; }|\r
+ Value_WORD\r
+ { $$=$1; }|\r
+ Value_BYTE\r
+ { $$=$1; };\r
+\r
+_init_val_lst_ : Separator_COMMA _init_val_ _init_val_lst_\r
+ {\r
+ $2->next=$3;\r
+ $$=$2;\r
+ }|\r
+ /* epsilon */\r
+ { $$=NULL; };\r
+\r
+/* ** GESTIONE STATEMENT ** */\r
+_stm_lst_ : _var_ DualOperator_ASG _expr_ Separator_COLUMN _stm_lst_\r
+ {\r
+ $$=treeId2Alloc(E_STM_ASG,$1,$3,&@1);\r
+ $$->next=$5;\r
+ }|\r
+ Keyword_WHILE OpenBracket_ROUND _expr_ CloseBracket_ROUND OpenBracket_BODY _decl_lst_ CloseBracket_BODY _stm_lst_\r
+ {\r
+ $$=treeId2Alloc(E_STM_WHILE,$3,$6,&@1);\r
+ $$->next=$8;\r
+ }|\r
+ Keyword_IF OpenBracket_ROUND _expr_ CloseBracket_ROUND OpenBracket_BODY _decl_lst_ CloseBracket_BODY _elsif_lst_ _else_ _stm_lst_\r
+ {\r
+ $$=treeId2Alloc(E_STM_IF,treeId2Alloc(E_STM_IFEXPRBODY,$3,$6,&@1),$9,&@1);\r
+ $$->param1->next=$8;\r
+ $$->next=$10;\r
+ }|\r
+ /* epsilon */\r
+ { $$=NULL; };\r
+\r
+_elsif_lst_ : Keyword_ELSIF OpenBracket_ROUND _expr_ CloseBracket_ROUND OpenBracket_BODY _decl_lst_ CloseBracket_BODY _elsif_lst_\r
+ {\r
+ $$=treeId2Alloc(E_STM_IFEXPRBODY,$3,$6,&@1);\r
+ $$->next=$8;\r
+ }|\r
+ /* epsilon */\r
+ { $$=NULL; };\r
+\r
+_else_ : Keyword_ELSE OpenBracket_BODY _decl_lst_ CloseBracket_BODY\r
+ { $$=$3; }|\r
+ /* epsilon */\r
+ { $$=NULL; }\r
+\r
+_expr_ : OpenBracket_ROUND _expr_ CloseBracket_ROUND\r
+ { $$=$2; }|\r
+ UnaryOperator_NOT _expr_\r
+ { $$=treeId1Alloc(E_EXPR_NOT,$2,&@1); }|\r
+ UnaryOperator_COM _expr_\r
+ { $$=treeId1Alloc(E_EXPR_COM,$2,&@1); }|\r
+ DualOperator_SUB _expr_ %prec UnaryOperator_SUB\r
+ { $$=treeId1Alloc(E_EXPR_NEG,$2,&@1); }|\r
+ Keyword_B2W OpenBracket_ROUND _expr_ CloseBracket_ROUND\r
+ { $$=treeId1Alloc(E_EXPR_B2W,$3,&@1); }|\r
+ Keyword_B2DW OpenBracket_ROUND _expr_ CloseBracket_ROUND\r
+ { $$=treeId1Alloc(E_EXPR_B2DW,$3,&@1); }|\r
+ Keyword_W2B OpenBracket_ROUND _expr_ CloseBracket_ROUND\r
+ { $$=treeId1Alloc(E_EXPR_W2B,$3,&@1); }|\r
+ Keyword_W2DW OpenBracket_ROUND _expr_ CloseBracket_ROUND\r
+ { $$=treeId1Alloc(E_EXPR_W2DW,$3,&@1); }|\r
+ Keyword_DW2B OpenBracket_ROUND _expr_ CloseBracket_ROUND\r
+ { $$=treeId1Alloc(E_EXPR_DW2B,$3,&@1); }|\r
+ Keyword_DW2W OpenBracket_ROUND _expr_ CloseBracket_ROUND\r
+ { $$=treeId1Alloc(E_EXPR_DW2W,$3,&@1); }|\r
+ _expr_ DualOperator_MUL _expr_\r
+ { $$=treeId2Alloc(E_EXPR_MUL,$1,$3,&@1); }|\r
+ _expr_ DualOperator_DIV _expr_\r
+ { $$=treeId2Alloc(E_EXPR_DIV,$1,$3,&@1); }|\r
+ _expr_ DualOperator_ADD _expr_\r
+ { $$=treeId2Alloc(E_EXPR_ADD,$1,$3,&@1); }|\r
+ _expr_ DualOperator_SUB _expr_\r
+ { $$=treeId2Alloc(E_EXPR_SUB,$1,$3,&@1); }|\r
+ _expr_ DualOperator_SHL _expr_\r
+ { $$=treeId2Alloc(E_EXPR_SHL,$1,$3,&@1); }|\r
+ _expr_ DualOperator_SHR _expr_\r
+ { $$=treeId2Alloc(E_EXPR_SHR,$1,$3,&@1); }|\r
+ _expr_ DualOperator_LT _expr_\r
+ { $$=treeId2Alloc(E_EXPR_LT,$1,$3,&@1); }|\r
+ _expr_ DualOperator_LTE _expr_\r
+ { $$=treeId2Alloc(E_EXPR_LTE,$1,$3,&@1); }|\r
+ _expr_ DualOperator_GT _expr_\r
+ { $$=treeId2Alloc(E_EXPR_GT,$1,$3,&@1); }|\r
+ _expr_ DualOperator_GTE _expr_\r
+ { $$=treeId2Alloc(E_EXPR_GTE,$1,$3,&@1); }|\r
+ _expr_ DualOperator_NEQ _expr_\r
+ { $$=treeId2Alloc(E_EXPR_NEQ,$1,$3,&@1); }|\r
+ _expr_ DualOperator_EQ _expr_\r
+ { $$=treeId2Alloc(E_EXPR_EQ,$1,$3,&@1); }|\r
+ _expr_ DualOperator_AND _expr_\r
+ { $$=treeId2Alloc(E_EXPR_AND,$1,$3,&@1); }|\r
+ _expr_ DualOperator_OR _expr_\r
+ { $$=treeId2Alloc(E_EXPR_OR,$1,$3,&@1); }|\r
+ _expr_ DualOperator_XOR _expr_\r
+ { $$=treeId2Alloc(E_EXPR_XOR,$1,$3,&@1); }|\r
+ Value_DWORD\r
+ { $$=$1; }|\r
+ Value_WORD\r
+ { $$=$1; }|\r
+ Value_BYTE\r
+ { $$=$1; }|\r
+ _var_\r
+ { $$=treeId1Alloc(E_EXPR_VAR,$1,&@1); };\r
+\r
+_var_ : Value_STRING _var_sub_\r
+ {\r
+ if($2)\r
+ {\r
+ $$=$2;\r
+ $$->last->next=treeId1Alloc(E_VAR_ROOT,$1,&@1);\r
+ }\r
+ else\r
+ { $$=treeId1Alloc(E_VAR_ROOT,$1,&@1); }\r
+ };\r
+\r
+_var_sub_ : Separator_SELECT Value_INUM _var_sub_\r
+ {\r
+ if($3)\r
+ {\r
+ valueLeaf *tmp=treeId1Alloc(E_VAR_STRUCT,$2,&@1);\r
+\r
+ $$=$3;\r
+ $$->last->next=tmp;\r
+ $$->last=tmp;\r
+ }\r
+ else\r
+ {\r
+ $$=treeId1Alloc(E_VAR_STRUCT,$2,&@1);\r
+ $$->last=$$;\r
+ }\r
+ }|\r
+ OpenBracket_SQUARE _expr_ CloseBracket_SQUARE _var_sub_\r
+ {\r
+ if($4)\r
+ {\r
+ valueLeaf *tmp=treeId1Alloc(E_VAR_ARRAY,$2,&@1);\r
+\r
+ $$=$4;\r
+ $$->last->next=tmp;\r
+ $$->last=tmp;\r
+ }\r
+ else\r
+ {\r
+ $$=treeId1Alloc(E_VAR_ARRAY,$2,&@1);\r
+ $$->last=$$;\r
+ }\r
+ }|\r
+ /* epsilon */\r
+ { $$=NULL; };\r
+\r
+/* ************************************************************************* */\r
+\r
+%%\r
+\r
+void yyerror(const YYLTYPE *locp,void *p,char const *msg)\r
+{\r
+ if(locp->first_line>=0)\r
+ { printf("%s:%d,%d\tParsError: %s%c",locp->source,locp->first_line,locp->first_column,msg,SEP); }\r
+ else\r
+ { printf(":0,0\tParsError: %s%c",msg,SEP); }\r
+\r
+ numErr++;\r
+\r
+ return;\r
+}\r
+\r
+valueLeaf *treeAlloc(\\r
+ vEnum id,\\r
+ _DWORD_ dwordValue,\\r
+ _WORD_ wordValue,\\r
+ _BYTE_ byteValue,\\r
+ unsigned long int inumValue,\\r
+ char *stringValue,\\r
+ valueLeaf *param1,\\r
+ valueLeaf *param2,\\r
+ valueLeaf *param3,\\r
+ const YYLTYPE *locp)\r
+{\r
+ valueLeaf *tmp;\r
+\r
+ if(!(tmp=(valueLeaf *) myMalloc(sizeof(valueLeaf))))\r
+ {\r
+ printf("[%s:%d] ParsError:OutOfMemory%c",__FILE__,__LINE__,SEP);\r
+ exit(ERR_EXIT);\r
+ }\r
+\r
+ memset(tmp,0,sizeof(valueLeaf));\r
+\r
+ tmp->id=id;\r
+ tmp->dwordValue=dwordValue;\r
+ tmp->wordValue=wordValue;\r
+ tmp->byteValue=byteValue;\r
+ tmp->inumValue=inumValue;\r
+ tmp->stringValue=stringValue;\r
+ tmp->param1=param1;\r
+ tmp->param2=param2;\r
+ tmp->param3=param3;\r
+\r
+ return(tmp);\r
+}\r
+\r
+valueLeaf *treeDwordAlloc(_DWORD_ dwordValue,const YYLTYPE *locp)\r
+{ return(treeAlloc(E_VALUE_DWORD,dwordValue,0,0,0,NULL,NULL,NULL,NULL,locp)); }\r
+\r
+valueLeaf *treeWordAlloc(_WORD_ wordValue,const YYLTYPE *locp)\r
+{ return(treeAlloc(E_VALUE_WORD,0,wordValue,0,0,NULL,NULL,NULL,NULL,locp)); }\r
+\r
+valueLeaf *treeByteAlloc(_BYTE_ byteValue,const YYLTYPE *locp)\r
+{ return(treeAlloc(E_VALUE_BYTE,0,0,byteValue,0,NULL,NULL,NULL,NULL,locp)); }\r
+\r
+valueLeaf *treeInumAlloc(unsigned long int inumValue,const YYLTYPE *locp)\r
+{ return(treeAlloc(E_VALUE_INUM,0,0,0,inumValue,NULL,NULL,NULL,NULL,locp)); }\r
+\r
+valueLeaf *treeStringAlloc(char *stringValue,const YYLTYPE *locp)\r
+{ return(treeAlloc(E_VALUE_STRING,0,0,0,0,stringValue,NULL,NULL,NULL,locp)); }\r
+\r
+valueLeaf *treeId0Alloc(vEnum id,const YYLTYPE *locp)\r
+{ return(treeAlloc(id,0,0,0,0,NULL,NULL,NULL,NULL,locp)); }\r
+\r
+valueLeaf *treeId1Alloc(vEnum id,valueLeaf *param1,const YYLTYPE *locp)\r
+{ return(treeAlloc(id,0,0,0,0,NULL,param1,NULL,NULL,locp)); }\r
+\r
+valueLeaf *treeId2Alloc(vEnum id,valueLeaf *param1,valueLeaf *param2,const YYLTYPE *locp)\r
+{ return(treeAlloc(id,0,0,0,0,NULL,param1,param2,NULL,locp)); }\r
+\r
+valueLeaf *treeId3Alloc(vEnum id,valueLeaf *param1,valueLeaf *param2,valueLeaf *param3,const YYLTYPE *locp)\r
+{ return(treeAlloc(id,0,0,0,0,NULL,param1,param2,param3,locp)); }\r
+\r
+/* riconoscimento token da input */\r
+int yylex(YYSTYPE *lvalp,YYLTYPE *llocp,void *p)\r
+{\r
+ char bufLine[256];\r
+ char bufToken[256];\r
+ char bufString[256];\r
+ char *tmp1,*tmp2;\r
+\r
+ /* riconoscimento di source:linea,colonna */\r
+ fscanf(stdin,"%s%s%s\n",bufLine,bufToken,bufString,SEP);\r
+\r
+ if(!strcmp(bufToken,"ERR"))\r
+ {\r
+ printf("%s\t%s%c",bufLine,bufString,SEP);\r
+ exit(ERR_EXIT);\r
+ }\r
+\r
+ for(tmp1=bufLine;*tmp1!=':';tmp1++);\r
+ *tmp1=0;\r
+\r
+ for(tmp2=tmp1+1;*tmp2!=',';tmp2++);\r
+ *tmp2=0;\r
+\r
+ llocp->first_line=llocp->last_line=atoi(tmp1+1);\r
+ llocp->first_column=llocp->last_column=atoi(tmp2+1);\r
+\r
+ if(!(llocp->source=(char *) myMalloc(strlen(bufLine)+1)))\r
+ {\r
+ printf("[%s:%d] ParsError:OutOfMemory%c",__FILE__,__LINE__,SEP);\r
+ exit(ERR_EXIT);\r
+ }\r
+\r
+ *llocp->source=0;\r
+ strcpy(llocp->source,bufLine);\r
+\r
+ *tmp1=':';\r
+ *tmp2=',';\r
+\r
+ /* analisi */\r
+ if(!strcmp(bufToken,"OK"))\r
+ {\r
+ root.source=llocp->source;\r
+ root.fileLine=llocp->first_line;\r
+ root.fileRow=llocp->first_column;\r
+\r
+ return yylex(lvalp,llocp,p);\r
+ }\r
+ else if(!strcmp(bufToken,"EOF"))\r
+ { return(0); }\r
+\r
+ /* categoria keyword */\r
+ if(!strcmp(bufToken,"KEW"))\r
+ {\r
+ if(!strcmp(bufString,"struct"))\r
+ { return(Keyword_STRUCT); }\r
+ else if(!strcmp(bufString,"array"))\r
+ { return(Keyword_ARRAY); }\r
+ else if(!strcmp(bufString,"of"))\r
+ { return(Keyword_OF); }\r
+ else if(!strcmp(bufString,"if"))\r
+ { return(Keyword_IF); }\r
+ else if(!strcmp(bufString,"elsif"))\r
+ { return(Keyword_ELSIF); }\r
+ else if(!strcmp(bufString,"else"))\r
+ { return(Keyword_ELSE); }\r
+ else if(!strcmp(bufString,"while"))\r
+ { return(Keyword_WHILE); }\r
+ else if(!strcmp(bufString,"const"))\r
+ { return(Keyword_CONST); }\r
+ else if(!strcmp(bufString,"b2w"))\r
+ { return(Keyword_B2W); }\r
+ else if(!strcmp(bufString,"b2dw"))\r
+ { return(Keyword_B2DW); }\r
+ else if(!strcmp(bufString,"w2b"))\r
+ { return(Keyword_W2B); }\r
+ else if(!strcmp(bufString,"w2dw"))\r
+ { return(Keyword_W2DW); }\r
+ else if(!strcmp(bufString,"dw2b"))\r
+ { return(Keyword_DW2B); }\r
+ else if(!strcmp(bufString,"dw2w"))\r
+ { return(Keyword_DW2W); }\r
+ else\r
+ {\r
+ printf("%s\tParsError:UnknownKeywordToken(%s)%c",bufLine,bufString,SEP);\r
+ exit(ERR_EXIT);\r
+ }\r
+ }\r
+ /* categoria tipo nativo */\r
+ else if(!strcmp(bufToken,"TYP"))\r
+ {\r
+ if(!strcmp(bufString,"dword"))\r
+ { return(Type_DWORD); }\r
+ else if(!strcmp(bufString,"word"))\r
+ { return(Type_WORD); }\r
+ else if(!strcmp(bufString,"byte"))\r
+ { return(Type_BYTE); }\r
+ else\r
+ {\r
+ printf("%s\tParsError:UnknownTypeToken(%s)%c",bufLine,bufString,SEP);\r
+ exit(ERR_EXIT);\r
+ }\r
+ }\r
+ /* categoria parentesi */\r
+ else if(!strcmp(bufToken,"BRK"))\r
+ {\r
+ if(!strcmp(bufString,"{"))\r
+ { return(OpenBracket_BODY); }\r
+ else if(!strcmp(bufString,"}"))\r
+ { return(CloseBracket_BODY); }\r
+ else if(!strcmp(bufString,"["))\r
+ { return(OpenBracket_SQUARE); }\r
+ else if(!strcmp(bufString,"]"))\r
+ { return(CloseBracket_SQUARE); }\r
+ else if(!strcmp(bufString,"("))\r
+ { return(OpenBracket_ROUND); }\r
+ else if(!strcmp(bufString,")"))\r
+ { return(CloseBracket_ROUND); }\r
+ else\r
+ {\r
+ printf("%s\tParsError:UnknownBracketToken(%s)%c",bufLine,bufString,SEP);\r
+ exit(ERR_EXIT);\r
+ }\r
+ }\r
+ /* categoria operatore unario */\r
+ else if(!strcmp(bufToken,"MOP"))\r
+ {\r
+ if(!strcmp(bufString,"!"))\r
+ { return(UnaryOperator_NOT); }\r
+ else if(!strcmp(bufString,"~"))\r
+ { return(UnaryOperator_COM); }\r
+ else\r
+ {\r
+ printf("%s\tParsError:UnknownUnaryOperatorToken(%s)%c",bufLine,bufString,SEP);\r
+ exit(ERR_EXIT);\r
+ }\r
+ }\r
+ /* categoria operatore duale */\r
+ else if(!strcmp(bufToken,"DOP"))\r
+ {\r
+ if(!strcmp(bufString,"&"))\r
+ { return(DualOperator_AND); }\r
+ else if(!strcmp(bufString,"|"))\r
+ { return(DualOperator_OR); }\r
+ else if(!strcmp(bufString,"^"))\r
+ { return(DualOperator_XOR); }\r
+ else if(!strcmp(bufString,"+"))\r
+ { return(DualOperator_ADD); }\r
+ else if(!strcmp(bufString,"-"))\r
+ { return(DualOperator_SUB); }\r
+ else if(!strcmp(bufString,"*"))\r
+ { return(DualOperator_MUL); }\r
+ else if(!strcmp(bufString,"/"))\r
+ { return(DualOperator_DIV); }\r
+ else if(!strcmp(bufString,"!="))\r
+ { return(DualOperator_NEQ); }\r
+ else if(!strcmp(bufString,"=="))\r
+ { return(DualOperator_EQ); }\r
+ else if(!strcmp(bufString,"<"))\r
+ { return(DualOperator_LT); }\r
+ else if(!strcmp(bufString,">"))\r
+ { return(DualOperator_GT); }\r
+ else if(!strcmp(bufString,"<="))\r
+ { return(DualOperator_LTE); }\r
+ else if(!strcmp(bufString,">="))\r
+ { return(DualOperator_GTE); }\r
+ else if(!strcmp(bufString,">>"))\r
+ { return(DualOperator_SHR); }\r
+ else if(!strcmp(bufString,"<<"))\r
+ { return(DualOperator_SHL); }\r
+ else if(!strcmp(bufString,"="))\r
+ { return(DualOperator_ASG); }\r
+ else\r
+ {\r
+ printf("%s\tParsError:UnknownDualOperatorToken(%s)%c",bufLine,bufString,SEP);\r
+ exit(ERR_EXIT);\r
+ }\r
+ }\r
+ /* categoria separatore */\r
+ else if(!strcmp(bufToken,"SEP"))\r
+ {\r
+ if(!strcmp(bufString,";"))\r
+ { return(Separator_COLUMN); }\r
+ else if(!strcmp(bufString,"."))\r
+ { return(Separator_SELECT); }\r
+ else if(!strcmp(bufString,","))\r
+ { return(Separator_COMMA); }\r
+ else\r
+ {\r
+ printf("%s\tParsError:UnknownSeparatorToken(%s)%c",bufLine,bufString,SEP);\r
+ exit(ERR_EXIT);\r
+ }\r
+ }\r
+ /* categoria dword */\r
+ else if(!strcmp(bufToken,"W32"))\r
+ {\r
+ unsigned long int tmpI;\r
+\r
+ if(sscanf(bufString,"0x%lx",&tmpI)==1)\r
+ {\r
+ *lvalp=treeDwordAlloc((_DWORD_) (tmpI&0xFFFFFFFF),llocp);\r
+ return(Value_DWORD);\r
+ }\r
+ else\r
+ {\r
+ printf("%s\tParsError:UnknownIntToken(%s)%c",bufLine,bufString,SEP);\r
+ exit(ERR_EXIT);\r
+ }\r
+ }\r
+ /* categoria word */\r
+ else if(!strcmp(bufToken,"W16"))\r
+ {\r
+ unsigned long int tmpI;\r
+\r
+ if(sscanf(bufString,"0x%lx",&tmpI)==1)\r
+ {\r
+ *lvalp=treeWordAlloc((_WORD_) (tmpI&0xFFFF),llocp);\r
+ return(Value_WORD);\r
+ }\r
+ else\r
+ {\r
+ printf("%s\tParsError:UnknownIntToken(%s)%c",bufLine,bufString,SEP);\r
+ exit(ERR_EXIT);\r
+ }\r
+ }\r
+ /* categoria byte */\r
+ else if(!strcmp(bufToken,"BY8"))\r
+ {\r
+ unsigned long int tmpI;\r
+\r
+ if(sscanf(bufString,"0x%lx",&tmpI)==1)\r
+ {\r
+ *lvalp=treeByteAlloc((_BYTE_) (tmpI&0xFF),llocp);\r
+ return(Value_BYTE);\r
+ }\r
+ else\r
+ {\r
+ printf("%s\tParsError:UnknownIntToken(%s)%c",bufLine,bufString,SEP);\r
+ exit(ERR_EXIT);\r
+ }\r
+ }\r
+ /* categoria numero intero */\r
+ else if(!strcmp(bufToken,"INU"))\r
+ {\r
+ unsigned long int tmpI;\r
+\r
+ if(sscanf(bufString,"%lu",&tmpI)==1)\r
+ {\r
+ *lvalp=treeInumAlloc(tmpI,llocp);\r
+ return(Value_INUM);\r
+ }\r
+ else\r
+ {\r
+ printf("%s\tParsError:UnknownIntToken(%s)%c",bufLine,bufString,SEP);\r
+ exit(ERR_EXIT);\r
+ }\r
+ }\r
+ /* categoria ID == stringa */\r
+ else if(!strcmp(bufToken,"IID"))\r
+ {\r
+ char *tmpS;\r
+\r
+ if(!(tmpS=(char *) myMalloc(strlen(bufString)+1)))\r
+ {\r
+ printf("[%s:%d] ParsError:OutOfMemory%c",__FILE__,__LINE__,SEP);\r
+ exit(ERR_EXIT);\r
+ }\r
+\r
+ *tmpS=0;\r
+ strcpy(tmpS,bufString);\r
+\r
+ *lvalp=treeStringAlloc(tmpS,llocp);\r
+ return(Value_STRING);\r
+ }\r
+ else\r
+ {\r
+ printf("%s\tParsError:UnknownToken(%s)%c",bufLine,bufString,SEP);\r
+ exit(ERR_EXIT);\r
+ }\r
+}\r
+\r
+void usage(char *name)\r
+{\r
+ printf("\nC Parser - Cosimo Oliboni\n\n");\r
+ printf("\"%s\" parsing da stdin\n\n",name);\r
+\r
+ return;\r
+}\r
+\r
+/* *************************** gestione degli user type *********** */\r
+\r
+int eqUserType(valueLeaf *type1,valueLeaf *type2)\r
+{\r
+ valueLeaf *tmp1,*tmp2;\r
+\r
+ if(type1->id!=type2->id)\r
+ { return(0); }\r
+\r
+ switch(type1->id)\r
+ {\r
+ case E_TYPE_DWORD:\r
+ case E_TYPE_WORD:\r
+ case E_TYPE_BYTE:\r
+ return(1);\r
+\r
+ case E_TYPE_ARRAY:\r
+ if(type1->param1->inumValue!=type2->param1->inumValue)\r
+ { return(0); }\r
+\r
+ return(eqUserType(type1->param2,type2->param2));\r
+\r
+ case E_TYPE_STRUCT:\r
+ tmp1=type1->param1;\r
+ tmp2=type2->param1;\r
+\r
+ while(tmp1&&tmp2)\r
+ {\r
+ if(!eqUserType(tmp1,tmp2))\r
+ { return(0); }\r
+\r
+ tmp1=tmp1->next;\r
+ tmp2=tmp2->next;\r
+ }\r
+\r
+ return(!(tmp1||tmp2));\r
+\r
+ /* dummy */\r
+ default:\r
+ return(0);\r
+ }\r
+}\r
+\r
+int getUserType(valueLeaf *type,valueLeaf **res)\r
+{\r
+ valueLeaf *tmpRes=typeRoot;\r
+ valueLeaf *lastRes;\r
+ int index=1;\r
+\r
+ while(tmpRes)\r
+ {\r
+ if(eqUserType(type,tmpRes))\r
+ {\r
+ if(res)\r
+ { *res=tmpRes; }\r
+ return(index);\r
+ }\r
+\r
+ lastRes=tmpRes;\r
+ tmpRes=tmpRes->next;\r
+ index++;\r
+ }\r
+\r
+ if(res)\r
+ { *res=lastRes; }\r
+ return(0);\r
+}\r
+\r
+void createUserType(valueLeaf *type)\r
+{\r
+ if(!typeRoot)\r
+ {\r
+ if(!(typeRoot=(valueLeaf *) myMalloc(sizeof(valueLeaf))))\r
+ {\r
+ printf("[%s:%d] ParsError:OutOfMemory%c",__FILE__,__LINE__,SEP);\r
+ exit(ERR_EXIT);\r
+ }\r
+\r
+ memcpy(typeRoot,type,sizeof(valueLeaf));\r
+ typeRoot->next=NULL;\r
+ }\r
+ else\r
+ {\r
+ valueLeaf *res;\r
+\r
+ if(!getUserType(type,&res))\r
+ {\r
+ if(!(res->next=(valueLeaf *) myMalloc(sizeof(valueLeaf))))\r
+ {\r
+ printf("[%s:%d] ParsError:OutOfMemory%c",__FILE__,__LINE__,SEP);\r
+ exit(ERR_EXIT);\r
+ }\r
+\r
+ memcpy(res->next,type,sizeof(valueLeaf));\r
+ res->next->next=NULL;\r
+ }\r
+ }\r
+}\r
+\r
+/* *************************** prettyPrint ************************ */\r
+\r
+void prettyPrintString(char *str)\r
+{\r
+ printf("([");\r
+\r
+ while(*str)\r
+ {\r
+ printf("ch_%c",*str);\r
+\r
+ if(*(str+1))\r
+ { printf(";"); }\r
+\r
+ str++;\r
+ }\r
+\r
+ printf("])");\r
+}\r
+\r
+void prettyPrintByte(_BYTE_ num)\r
+{\r
+ printf("(\\langle x%1X,x%1X \\rangle)",(unsigned int) (num>>4),(unsigned int) (num&0xF));\r
+}\r
+\r
+void prettyPrintWord(_WORD_ num)\r
+{\r
+ printf("(\\langle \\langle x%1X,x%1X \\rangle : \\langle x%1X,x%1X \\rangle \\rangle)",\\r
+ (unsigned int) (num>>12),(unsigned int) ((num>>8)&0xF),\\r
+ (unsigned int) ((num>>4)&0xF),(unsigned int) (num&0xF));\r
+}\r
+\r
+void prettyPrintDword(_DWORD_ num)\r
+{\r
+ 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
+ (unsigned int) (num>>28),(unsigned int) ((num>>24)&0xF),\\r
+ (unsigned int) ((num>>20)&0xF),(unsigned int) ((num>>16)&0xF),\\r
+ (unsigned int) ((num>>12)&0xF),(unsigned int) ((num>>8)&0xF),\\r
+ (unsigned int) ((num>>4)&0xF),(unsigned int) (num&0xF));\r
+}\r
+\r
+void prettyPrintIndent(int indent)\r
+{\r
+ int index;\r
+\r
+ for(index=0;index<indent;index++)\r
+ { printf(" "); }\r
+}\r
+\r
+void prettyPrintInum(unsigned long int num)\r
+{\r
+ if(!num)\r
+ { printf("O\n"); }\r
+ else\r
+ { printf("%lu\n",num); }\r
+}\r
+\r
+void prettyPrintInit(valueLeaf *cur,int indent)\r
+{\r
+ if(cur->id==E_VALUE_BYTE)\r
+ { prettyPrintIndent(indent); printf("(PREAST_INIT_VAL_BYTE8 "); prettyPrintByte(cur->byteValue); printf(")\n"); }\r
+ else if(cur->id==E_VALUE_WORD)\r
+ { prettyPrintIndent(indent); printf("(PREAST_INIT_VAL_WORD16 "); prettyPrintWord(cur->wordValue); printf(")\n"); }\r
+ else if(cur->id==E_VALUE_DWORD)\r
+ { prettyPrintIndent(indent); printf("(PREAST_INIT_VAL_WORD32 "); prettyPrintDword(cur->dwordValue); printf(")\n"); }\r
+ else if(cur->id==E_VALUE_ARRAY)\r
+ {\r
+ valueLeaf *tmp=cur->param1;\r
+\r
+ prettyPrintIndent(indent); printf("(PREAST_INIT_VAL_ARRAY\n");\r
+\r
+ prettyPrintIndent(indent+1); printf("(\\laquo\n");\r
+ if(!tmp->next)\r
+ { prettyPrintIndent(indent+2); printf("£\n"); }\r
+ while(tmp)\r
+ {\r
+ prettyPrintInit(tmp,indent+2);\r
+\r
+ if(tmp->next)\r
+ {\r
+ if(tmp->next->next)\r
+ { prettyPrintIndent(indent+2); printf(";\n"); }\r
+ else\r
+ { prettyPrintIndent(indent+2); printf("£\n"); }\r
+ }\r
+\r
+ tmp=tmp->next;\r
+ }\r
+ prettyPrintIndent(indent+1); printf("\\raquo)\n");\r
+\r
+ prettyPrintIndent(indent); printf(")\n");\r
+ }\r
+ else if(cur->id==E_VALUE_STRUCT)\r
+ {\r
+ valueLeaf *tmp=cur->param1;\r
+\r
+ prettyPrintIndent(indent); printf("(PREAST_INIT_VAL_STRUCT\n");\r
+\r
+ prettyPrintIndent(indent+1); printf("(\\laquo\n");\r
+ if(!tmp->next)\r
+ { prettyPrintIndent(indent+2); printf("£\n"); }\r
+ while(tmp)\r
+ {\r
+ prettyPrintInit(tmp,indent+2);\r
+\r
+ if(tmp->next)\r
+ {\r
+ if(tmp->next->next)\r
+ { prettyPrintIndent(indent+2); printf(";\n"); }\r
+ else\r
+ { prettyPrintIndent(indent+2); printf("£\n"); }\r
+ }\r
+\r
+ tmp=tmp->next;\r
+ }\r
+ prettyPrintIndent(indent+1); printf("\\raquo)\n");\r
+\r
+ prettyPrintIndent(indent); printf(")\n");\r
+ }\r
+}\r
+\r
+void prettyPrintBody(valueLeaf *cur,int indent)\r
+{\r
+ if(!cur)\r
+ { prettyPrintIndent(indent); printf("(PREAST_NO_DECL [])\n"); }\r
+ else if((cur->id==E_DECL_CONST)||(cur->id==E_DECL_VAR))\r
+ { prettyPrint(cur,indent); }\r
+ else\r
+ {\r
+ valueLeaf *tmp=cur;\r
+\r
+ prettyPrintIndent(indent); printf("(PREAST_NO_DECL\n");\r
+\r
+ prettyPrintIndent(indent+1); printf("[\n");\r
+ while(tmp)\r
+ {\r
+ prettyPrint(tmp,indent+2);\r
+\r
+ if(tmp->next)\r
+ { prettyPrintIndent(indent+2); printf(";\n"); }\r
+\r
+ tmp=tmp->next;\r
+ }\r
+ prettyPrintIndent(indent+1); printf("]\n");\r
+\r
+ prettyPrintIndent(indent); printf(")\n");\r
+ }\r
+\r
+}\r
+\r
+void prettyPrint(valueLeaf *cur,int indent)\r
+{\r
+ /* ** misc ** */\r
+ if(cur->id==E_VALUE_STRING)\r
+ { prettyPrintIndent(indent); prettyPrintString(cur->stringValue); printf("\n"); }\r
+ else if(cur->id==E_VALUE_INUM)\r
+ { prettyPrintIndent(indent); prettyPrintInum(cur->inumValue); }\r
+\r
+ /* ** tipi ** */\r
+ else if(cur->id==E_TYPE_BYTE)\r
+ { prettyPrintIndent(indent); printf("(AST_TYPE_BASE AST_BASE_TYPE_BYTE8)\n"); }\r
+ else if(cur->id==E_TYPE_WORD)\r
+ { prettyPrintIndent(indent); printf("(AST_TYPE_BASE AST_BASE_TYPE_WORD16)\n"); }\r
+ else if(cur->id==E_TYPE_DWORD)\r
+ { prettyPrintIndent(indent); printf("(AST_TYPE_BASE AST_BASE_TYPE_WORD32)\n"); }\r
+ else if(cur->id==E_TYPE_ARRAY)\r
+ {\r
+ prettyPrintIndent(indent); printf("(AST_TYPE_ARRAY\n");\r
+ prettyPrint(cur->param2,indent+1); //type\r
+ prettyPrint(cur->param1,indent+1); //size\r
+ prettyPrintIndent(indent); printf(")\n");\r
+ }\r
+ else if(cur->id==E_TYPE_STRUCT)\r
+ {\r
+ valueLeaf *tmp=cur->param1;\r
+\r
+ prettyPrintIndent(indent); printf("(AST_TYPE_STRUCT\n");\r
+\r
+ prettyPrintIndent(indent+1); printf("(\\laquo\n");\r
+ if(!tmp->next)\r
+ { prettyPrintIndent(indent+2); printf("£\n"); }\r
+ while(tmp)\r
+ {\r
+ prettyPrint(tmp,indent+2);\r
+\r
+ if(tmp->next)\r
+ {\r
+ if(tmp->next->next)\r
+ { prettyPrintIndent(indent+2); printf(";\n"); }\r
+ else\r
+ { prettyPrintIndent(indent+2); printf("£\n"); }\r
+ }\r
+\r
+ tmp=tmp->next;\r
+ }\r
+ prettyPrintIndent(indent+1); printf("\\raquo)\n");\r
+\r
+ prettyPrintIndent(indent); printf(")\n");\r
+ }\r
+ \r
+ /* ** valori come espressioni ** */\r
+ else if(cur->id==E_VALUE_BYTE)\r
+ { prettyPrintIndent(indent); printf("(PREAST_EXPR_BYTE8 "); prettyPrintByte(cur->byteValue); printf(")\n"); }\r
+ else if(cur->id==E_VALUE_WORD)\r
+ { prettyPrintIndent(indent); printf("(PREAST_EXPR_WORD16 "); prettyPrintWord(cur->wordValue); printf(")\n"); }\r
+ else if(cur->id==E_VALUE_DWORD)\r
+ { prettyPrintIndent(indent); printf("(PREAST_EXPR_WORD32 "); prettyPrintDword(cur->dwordValue); printf(")\n"); }\r
+\r
+ /* ** variabili */\r
+ else if(cur->id==E_VAR_ROOT)\r
+ { prettyPrintIndent(indent); printf("(PREAST_VAR_ID "); prettyPrintString(cur->param1->stringValue); printf(")\n"); }\r
+ else if(cur->id==E_VAR_STRUCT)\r
+ {\r
+ prettyPrintIndent(indent); printf("(PREAST_VAR_STRUCT\n");\r
+ prettyPrint(cur->next,indent+1);\r
+ prettyPrint(cur->param1,indent+1);\r
+ prettyPrintIndent(indent); printf(")\n");\r
+ }\r
+ else if(cur->id==E_VAR_ARRAY)\r
+ {\r
+ prettyPrintIndent(indent); printf("(PREAST_VAR_ARRAY\n");\r
+ prettyPrint(cur->next,indent+1);\r
+ prettyPrint(cur->param1,indent+1);\r
+ prettyPrintIndent(indent); printf(")\n");\r
+ }\r
+\r
+ /* ** espressioni ** */\r
+ else if(cur->id==E_EXPR_VAR)\r
+ {\r
+ prettyPrintIndent(indent); printf("(PREAST_EXPR_ID\n");\r
+ prettyPrint(cur->param1,indent+1);\r
+ prettyPrintIndent(indent); printf(")\n");\r
+ }\r
+ else if(cur->id==E_EXPR_NOT)\r
+ {\r
+ prettyPrintIndent(indent); printf("(PREAST_EXPR_NOT\n");\r
+ prettyPrint(cur->param1,indent+1);\r
+ prettyPrintIndent(indent); printf(")\n");\r
+ }\r
+ else if(cur->id==E_EXPR_COM)\r
+ {\r
+ prettyPrintIndent(indent); printf("(PREAST_EXPR_COM\n");\r
+ prettyPrint(cur->param1,indent+1);\r
+ prettyPrintIndent(indent); printf(")\n");\r
+ }\r
+ else if(cur->id==E_EXPR_NEG)\r
+ {\r
+ prettyPrintIndent(indent); printf("(PREAST_EXPR_NEG\n");\r
+ prettyPrint(cur->param1,indent+1);\r
+ prettyPrintIndent(indent); printf(")\n");\r
+ }\r
+ else if(cur->id==E_EXPR_B2W)\r
+ {\r
+ prettyPrintIndent(indent); printf("(PREAST_EXPR_B8toW16\n");\r
+ prettyPrint(cur->param1,indent+1);\r
+ prettyPrintIndent(indent); printf(")\n");\r
+ }\r
+ else if(cur->id==E_EXPR_B2DW)\r
+ {\r
+ prettyPrintIndent(indent); printf("(PREAST_EXPR_B8toW32\n");\r
+ prettyPrint(cur->param1,indent+1);\r
+ prettyPrintIndent(indent); printf(")\n");\r
+ }\r
+ else if(cur->id==E_EXPR_W2B)\r
+ {\r
+ prettyPrintIndent(indent); printf("(PREAST_EXPR_W16toB8\n");\r
+ prettyPrint(cur->param1,indent+1);\r
+ prettyPrintIndent(indent); printf(")\n");\r
+ }\r
+ else if(cur->id==E_EXPR_W2DW)\r
+ {\r
+ prettyPrintIndent(indent); printf("(PREAST_EXPR_W16toW32\n");\r
+ prettyPrint(cur->param1,indent+1);\r
+ prettyPrintIndent(indent); printf(")\n");\r
+ }\r
+ else if(cur->id==E_EXPR_DW2B)\r
+ {\r
+ prettyPrintIndent(indent); printf("(PREAST_EXPR_W32toB8\n");\r
+ prettyPrint(cur->param1,indent+1);\r
+ prettyPrintIndent(indent); printf(")\n");\r
+ }\r
+ else if(cur->id==E_EXPR_DW2W)\r
+ {\r
+ prettyPrintIndent(indent); printf("(PREAST_EXPR_W32toW16\n");\r
+ prettyPrint(cur->param1,indent+1);\r
+ prettyPrintIndent(indent); printf(")\n");\r
+ }\r
+ else if(cur->id==E_EXPR_ADD)\r
+ {\r
+ prettyPrintIndent(indent); printf("(PREAST_EXPR_ADD\n");\r
+ prettyPrint(cur->param1,indent+1);\r
+ prettyPrint(cur->param2,indent+1);\r
+ prettyPrintIndent(indent); printf(")\n");\r
+ }\r
+ else if(cur->id==E_EXPR_SUB)\r
+ {\r
+ prettyPrintIndent(indent); printf("(PREAST_EXPR_SUB\n");\r
+ prettyPrint(cur->param1,indent+1);\r
+ prettyPrint(cur->param2,indent+1);\r
+ prettyPrintIndent(indent); printf(")\n");\r
+ }\r
+ else if(cur->id==E_EXPR_MUL)\r
+ {\r
+ prettyPrintIndent(indent); printf("(PREAST_EXPR_MUL\n");\r
+ prettyPrint(cur->param1,indent+1);\r
+ prettyPrint(cur->param2,indent+1);\r
+ prettyPrintIndent(indent); printf(")\n");\r
+ }\r
+ else if(cur->id==E_EXPR_DIV)\r
+ {\r
+ prettyPrintIndent(indent); printf("(PREAST_EXPR_DIV\n");\r
+ prettyPrint(cur->param1,indent+1);\r
+ prettyPrint(cur->param2,indent+1);\r
+ prettyPrintIndent(indent); printf(")\n");\r
+ }\r
+ else if(cur->id==E_EXPR_SHL)\r
+ {\r
+ prettyPrintIndent(indent); printf("(PREAST_EXPR_SHL\n");\r
+ prettyPrint(cur->param1,indent+1);\r
+ prettyPrint(cur->param2,indent+1);\r
+ prettyPrintIndent(indent); printf(")\n");\r
+ }\r
+ else if(cur->id==E_EXPR_SHR)\r
+ {\r
+ prettyPrintIndent(indent); printf("(PREAST_EXPR_SHR\n");\r
+ prettyPrint(cur->param1,indent+1);\r
+ prettyPrint(cur->param2,indent+1);\r
+ prettyPrintIndent(indent); printf(")\n");\r
+ }\r
+ else if(cur->id==E_EXPR_AND)\r
+ {\r
+ prettyPrintIndent(indent); printf("(PREAST_EXPR_AND\n");\r
+ prettyPrint(cur->param1,indent+1);\r
+ prettyPrint(cur->param2,indent+1);\r
+ prettyPrintIndent(indent); printf(")\n");\r
+ }\r
+ else if(cur->id==E_EXPR_OR)\r
+ {\r
+ prettyPrintIndent(indent); printf("(PREAST_EXPR_OR\n");\r
+ prettyPrint(cur->param1,indent+1);\r
+ prettyPrint(cur->param2,indent+1);\r
+ prettyPrintIndent(indent); printf(")\n");\r
+ }\r
+ else if(cur->id==E_EXPR_XOR)\r
+ {\r
+ prettyPrintIndent(indent); printf("(PREAST_EXPR_XOR\n");\r
+ prettyPrint(cur->param1,indent+1);\r
+ prettyPrint(cur->param2,indent+1);\r
+ prettyPrintIndent(indent); printf(")\n");\r
+ }\r
+ else if(cur->id==E_EXPR_LT)\r
+ {\r
+ prettyPrintIndent(indent); printf("(PREAST_EXPR_LT\n");\r
+ prettyPrint(cur->param1,indent+1);\r
+ prettyPrint(cur->param2,indent+1);\r
+ prettyPrintIndent(indent); printf(")\n");\r
+ }\r
+ else if(cur->id==E_EXPR_LTE)\r
+ {\r
+ prettyPrintIndent(indent); printf("(PREAST_EXPR_LTE\n");\r
+ prettyPrint(cur->param1,indent+1);\r
+ prettyPrint(cur->param2,indent+1);\r
+ prettyPrintIndent(indent); printf(")\n");\r
+ }\r
+ else if(cur->id==E_EXPR_GT)\r
+ {\r
+ prettyPrintIndent(indent); printf("(PREAST_EXPR_GT\n");\r
+ prettyPrint(cur->param1,indent+1);\r
+ prettyPrint(cur->param2,indent+1);\r
+ prettyPrintIndent(indent); printf(")\n");\r
+ }\r
+ else if(cur->id==E_EXPR_GTE)\r
+ {\r
+ prettyPrintIndent(indent); printf("(PREAST_EXPR_GTE\n");\r
+ prettyPrint(cur->param1,indent+1);\r
+ prettyPrint(cur->param2,indent+1);\r
+ prettyPrintIndent(indent); printf(")\n");\r
+ }\r
+ else if(cur->id==E_EXPR_EQ)\r
+ {\r
+ prettyPrintIndent(indent); printf("(PREAST_EXPR_EQ\n");\r
+ prettyPrint(cur->param1,indent+1);\r
+ prettyPrint(cur->param2,indent+1);\r
+ prettyPrintIndent(indent); printf(")\n");\r
+ }\r
+ else if(cur->id==E_EXPR_NEQ)\r
+ {\r
+ prettyPrintIndent(indent); printf("(PREAST_EXPR_NEQ\n");\r
+ prettyPrint(cur->param1,indent+1);\r
+ prettyPrint(cur->param2,indent+1);\r
+ prettyPrintIndent(indent); printf(")\n");\r
+ }\r
+\r
+ /* ** dichiarazioni ** */\r
+ else if(cur->id==E_DECL_CONST)\r
+ {\r
+ prettyPrintIndent(indent); printf("(PREAST_CONST_DECL\n");\r
+ prettyPrint(cur->param2,indent+1); //string\r
+ prettyPrint(cur->param1,indent+1); //type\r
+ \r
+ if((cur->param3->id==E_VAR_ROOT)||(cur->param3->id==E_VAR_STRUCT)||(cur->param3->id==E_VAR_ARRAY))\r
+ {\r
+ prettyPrintIndent(indent+1); printf("(PREAST_INIT_VAR\n");\r
+ prettyPrint(cur->param3,indent+2); //init\r
+ prettyPrintIndent(indent+1); printf(")\n");\r
+ }\r
+ else\r
+ {\r
+ prettyPrintIndent(indent+1); printf("(PREAST_INIT_VAL\n");\r
+ prettyPrintInit(cur->param3,indent+2); //init\r
+ prettyPrintIndent(indent+1); printf(")\n");\r
+ }\r
+\r
+ if(cur->next)\r
+ {\r
+ if((cur->next->id==E_DECL_CONST)||(cur->next->id==E_DECL_VAR))\r
+ { prettyPrint(cur->next,indent+1); } //next decl\r
+ else\r
+ {\r
+ valueLeaf *tmp=cur->next;\r
+\r
+ prettyPrintIndent(indent+1); printf("(PREAST_NO_DECL\n");\r
+\r
+ prettyPrintIndent(indent+2); printf("[\n");\r
+ while(tmp)\r
+ {\r
+ prettyPrint(tmp,indent+3);\r
+\r
+ if(tmp->next)\r
+ { prettyPrintIndent(indent+3); printf(";\n"); }\r
+\r
+ tmp=tmp->next;\r
+ }\r
+ prettyPrintIndent(indent+2); printf("]\n");\r
+\r
+ prettyPrintIndent(indent+1); printf(")\n");\r
+ }\r
+ }\r
+ else\r
+ { prettyPrintIndent(indent+1); printf("(PREAST_NO_DECL [])\n"); }\r
+ \r
+\r
+ prettyPrintIndent(indent); printf(")\n");\r
+ }\r
+ else if(cur->id==E_DECL_VAR)\r
+ {\r
+ prettyPrintIndent(indent); printf("(PREAST_VAR_DECL\n");\r
+ prettyPrint(cur->param2,indent+1); //string\r
+ prettyPrint(cur->param1,indent+1); //type\r
+ \r
+ if(cur->param3)\r
+ {\r
+ prettyPrintIndent(indent+1); printf("(Some ?\n");\r
+\r
+ if((cur->param3->id==E_VAR_ROOT)||(cur->param3->id==E_VAR_STRUCT)||(cur->param3->id==E_VAR_ARRAY))\r
+ {\r
+ prettyPrintIndent(indent+2); printf("(PREAST_INIT_VAR\n");\r
+ prettyPrint(cur->param3,indent+3); //init\r
+ prettyPrintIndent(indent+2); printf(")\n");\r
+ }\r
+ else\r
+ {\r
+ prettyPrintIndent(indent+2); printf("(PREAST_INIT_VAL\n");\r
+ prettyPrintInit(cur->param3,indent+3); //init\r
+ prettyPrintIndent(indent+2); printf(")\n");\r
+ }\r
+\r
+ prettyPrintIndent(indent+1); printf(")\n");\r
+ }\r
+ else\r
+ { prettyPrintIndent(indent+1); printf("(None ?)\n"); }\r
+\r
+ if(cur->next)\r
+ {\r
+ if((cur->next->id==E_DECL_CONST)||(cur->next->id==E_DECL_VAR))\r
+ { prettyPrint(cur->next,indent+1); } //next decl\r
+ else\r
+ {\r
+ valueLeaf *tmp=cur->next;\r
+\r
+ prettyPrintIndent(indent+1); printf("(PREAST_NO_DECL\n");\r
+\r
+ prettyPrintIndent(indent+2); printf("[\n");\r
+ while(tmp)\r
+ {\r
+ prettyPrint(tmp,indent+3);\r
+\r
+ if(tmp->next)\r
+ { prettyPrintIndent(indent+3); printf(";\n"); }\r
+\r
+ tmp=tmp->next;\r
+ }\r
+ prettyPrintIndent(indent+2); printf("]\n");\r
+\r
+ prettyPrintIndent(indent+1); printf(")\n");\r
+ }\r
+ }\r
+ else\r
+ { prettyPrintIndent(indent+1); printf("(PREAST_NO_DECL [])\n"); }\r
+ \r
+\r
+ prettyPrintIndent(indent); printf(")\n");\r
+ }\r
+\r
+ /* ** statement ** */\r
+ else if(cur->id==E_STM_ASG)\r
+ {\r
+ prettyPrintIndent(indent); printf("(PREAST_STM_ASG\n");\r
+ prettyPrint(cur->param1,indent+1);\r
+ prettyPrint(cur->param2,indent+1);\r
+ prettyPrintIndent(indent); printf(")\n");\r
+ }\r
+ else if(cur->id==E_STM_WHILE)\r
+ {\r
+ prettyPrintIndent(indent); printf("(PREAST_STM_WHILE\n");\r
+ prettyPrint(cur->param1,indent+1);\r
+ prettyPrintBody(cur->param2,indent+1);\r
+ prettyPrintIndent(indent); printf(")\n");\r
+ }\r
+ else if(cur->id==E_STM_IF)\r
+ {\r
+ valueLeaf *tmp=cur->param1;\r
+\r
+ prettyPrintIndent(indent); printf("(PREAST_STM_IF\n");\r
+\r
+ prettyPrintIndent(indent+1); printf("(\\laquo\n");\r
+ if(!tmp->next)\r
+ { prettyPrintIndent(indent+2); printf("£\n"); }\r
+ while(tmp)\r
+ {\r
+ prettyPrintIndent(indent+2); printf("(pair ??\n");\r
+ prettyPrint(tmp->param1,indent+3);\r
+ prettyPrintBody(tmp->param2,indent+3);\r
+ prettyPrintIndent(indent+2); printf(")\n");\r
+\r
+ if(tmp->next)\r
+ {\r
+ if(tmp->next->next)\r
+ { prettyPrintIndent(indent+2); printf(";\n"); }\r
+ else\r
+ { prettyPrintIndent(indent+2); printf("£\n"); }\r
+ }\r
+\r
+ tmp=tmp->next;\r
+ }\r
+ prettyPrintIndent(indent+1); printf("\\raquo)\n");\r
+\r
+ // equivalenza: Some ? (PREAST_NO_DECL []) = None ?\r
+ if(cur->param2)\r
+ {\r
+ prettyPrintIndent(indent+1); printf("(Some ?\n");\r
+ prettyPrintBody(cur->param2,indent+2); //body\r
+ prettyPrintIndent(indent+1); printf(")\n");\r
+ }\r
+ else\r
+ { prettyPrintIndent(indent+1); printf("(None ?)\n"); }\r
+\r
+ prettyPrintIndent(indent); printf(")\n");\r
+ }\r
+}\r
+\r
+/* *************************** cPrint ***************************** */\r
+\r
+void cPrintIndent(int indent)\r
+{\r
+ int index;\r
+\r
+ for(index=0;index<indent;index++)\r
+ { printf("\t"); }\r
+}\r
+\r
+void cPrintTypesAux(valueLeaf *type,int field)\r
+{\r
+ if(type->id==E_TYPE_STRUCT)\r
+ { printf("\tuser%d_t\tfield%d;\n\n",getUserType(type,NULL),field); }\r
+ else if(type->id==E_TYPE_ARRAY)\r
+ {\r
+ char bufferDim[256];\r
+ valueLeaf *tmp=type;\r
+\r
+ memset(bufferDim,0,256);\r
+\r
+ while(tmp->id==E_TYPE_ARRAY)\r
+ {\r
+ sprintf(&bufferDim[strlen(bufferDim)],"[%d]",tmp->param1->inumValue+1);\r
+ tmp=tmp->param2;\r
+ }\r
+\r
+ if(tmp->id==E_TYPE_STRUCT)\r
+ { printf("\tuser%d_t\tfield%d%s;\n\n",getUserType(tmp,NULL),field,bufferDim); }\r
+ else if(tmp->id==E_TYPE_DWORD)\r
+ { printf("\t_DWORD_\tfield%d%s;\n\n",field,bufferDim); }\r
+ else if(tmp->id==E_TYPE_WORD)\r
+ { printf("\t_WORD_\tfield%d%s;\n\n",field,bufferDim); }\r
+ else\r
+ { printf("\t_BYTE_\tfield%d%s;\n\n",field,bufferDim); }\r
+ }\r
+ else if(type->id==E_TYPE_DWORD)\r
+ { printf("\t_DWORD_\tfield%d;\n\n",field); }\r
+ else if(type->id==E_TYPE_WORD)\r
+ { printf("\t_WORD_\tfield%d;\n\n",field); }\r
+ else\r
+ { printf("\t_BYTE_\tfield%d;\n\n",field); }\r
+\r
+ if(type->next)\r
+ { cPrintTypesAux(type->next,field+1); }\r
+}\r
+\r
+void cPrintTypes(void)\r
+{\r
+ int index=1;\r
+ valueLeaf *cur=typeRoot;\r
+\r
+ while(cur)\r
+ {\r
+ printf("typedef struct\n");\r
+ printf("{\n");\r
+ cPrintTypesAux(cur->param1,0);\r
+ printf("} user%d_t;\n\n",index);\r
+\r
+ cur=cur->next;\r
+ index++;\r
+ }\r
+}\r
+\r
+void cPrint(valueLeaf *cur,int indent)\r
+{\r
+ /* ** valori ** */\r
+ if(cur->id==E_VALUE_INUM)\r
+ { printf("%lu",cur->inumValue); }\r
+ else if(cur->id==E_VALUE_BYTE)\r
+ { printf("0x%02lX",(_DWORD_) cur->byteValue); }\r
+ else if(cur->id==E_VALUE_WORD)\r
+ { printf("0x%04lX",(_DWORD_) cur->wordValue); }\r
+ else if(cur->id==E_VALUE_DWORD)\r
+ { printf("0x%08lX",cur->dwordValue); }\r
+ else if((cur->id==E_VALUE_ARRAY)||(cur->id==E_VALUE_STRUCT))\r
+ {\r
+ valueLeaf *tmp=cur->param1;\r
+\r
+ printf("{ ");\r
+ while(tmp)\r
+ {\r
+ cPrint(tmp,indent);\r
+ tmp=tmp->next;\r
+ if(tmp)\r
+ { printf(", "); }\r
+ }\r
+ printf(" }");\r
+ }\r
+\r
+ /* ** variabili ** */\r
+ else if((cur->id==E_VAR_ROOT)||(cur->id==E_VAR_STRUCT)||(cur->id==E_VAR_ARRAY))\r
+ {\r
+ valueLeaf *tmp=cur;\r
+\r
+ while(tmp->id!=E_VAR_ROOT)\r
+ {\r
+ tmp->next->last=tmp;\r
+ tmp=tmp->next;\r
+ }\r
+\r
+ while(1)\r
+ {\r
+ if(tmp->id==E_VAR_ROOT)\r
+ { printf("%s",tmp->param1->stringValue); }\r
+ else if(tmp->id==E_VAR_STRUCT)\r
+ { printf(".field%lu",tmp->param1->inumValue); }\r
+ else if(tmp->id==E_VAR_ARRAY)\r
+ { printf("["); cPrint(tmp->param1,indent); printf("]"); }\r
+\r
+ if(tmp==cur)\r
+ { break; }\r
+ else\r
+ { tmp=tmp->last; }\r
+ }\r
+ }\r
+\r
+ /* ** espressioni ** */\r
+ else if(cur->id==E_EXPR_VAR)\r
+ { cPrint(cur->param1,indent); }\r
+ else if(cur->id==E_EXPR_NOT)\r
+ { printf("!("); cPrint(cur->param1,indent); printf(")"); }\r
+ else if(cur->id==E_EXPR_COM)\r
+ { printf("~("); cPrint(cur->param1,indent); printf(")"); }\r
+ else if(cur->id==E_EXPR_NEG)\r
+ { printf("-("); cPrint(cur->param1,indent); printf(")"); }\r
+ else if((cur->id==E_EXPR_W2B)||(cur->id==E_EXPR_DW2B))\r
+ { printf("((_BYTE_) ("); cPrint(cur->param1,indent); printf("))"); }\r
+ else if((cur->id==E_EXPR_B2W)||(cur->id==E_EXPR_DW2W))\r
+ { printf("((_WORD_) ("); cPrint(cur->param1,indent); printf("))"); }\r
+ else if((cur->id==E_EXPR_B2DW)||(cur->id==E_EXPR_W2DW))\r
+ { printf("((_DWORD_) ("); cPrint(cur->param1,indent); printf("))"); }\r
+ else if(cur->id==E_EXPR_ADD)\r
+ { printf("("); cPrint(cur->param1,indent); printf(") + ("); cPrint(cur->param2,indent); printf(")"); }\r
+ else if(cur->id==E_EXPR_SUB)\r
+ { printf("("); cPrint(cur->param1,indent); printf(") - ("); cPrint(cur->param2,indent); printf(")"); }\r
+ else if(cur->id==E_EXPR_MUL)\r
+ { printf("("); cPrint(cur->param1,indent); printf(") * ("); cPrint(cur->param2,indent); printf(")"); }\r
+ else if(cur->id==E_EXPR_DIV)\r
+ { printf("("); cPrint(cur->param1,indent); printf(") / ("); cPrint(cur->param2,indent); printf(")"); }\r
+ else if(cur->id==E_EXPR_SHL)\r
+ { printf("("); cPrint(cur->param1,indent); printf(") << ("); cPrint(cur->param2,indent); printf(")"); }\r
+ else if(cur->id==E_EXPR_SHR)\r
+ { printf("("); cPrint(cur->param1,indent); printf(") >> ("); cPrint(cur->param2,indent); printf(")"); }\r
+ else if(cur->id==E_EXPR_AND)\r
+ { printf("("); cPrint(cur->param1,indent); printf(") & ("); cPrint(cur->param2,indent); printf(")"); }\r
+ else if(cur->id==E_EXPR_OR)\r
+ { printf("("); cPrint(cur->param1,indent); printf(") | ("); cPrint(cur->param2,indent); printf(")"); }\r
+ else if(cur->id==E_EXPR_XOR)\r
+ { printf("("); cPrint(cur->param1,indent); printf(") ^ ("); cPrint(cur->param2,indent); printf(")"); }\r
+ else if(cur->id==E_EXPR_LT)\r
+ { printf("("); cPrint(cur->param1,indent); printf(") < ("); cPrint(cur->param2,indent); printf(")"); }\r
+ else if(cur->id==E_EXPR_LTE)\r
+ { printf("("); cPrint(cur->param1,indent); printf(") <= ("); cPrint(cur->param2,indent); printf(")"); }\r
+ else if(cur->id==E_EXPR_GT)\r
+ { printf("("); cPrint(cur->param1,indent); printf(") > ("); cPrint(cur->param2,indent); printf(")"); }\r
+ else if(cur->id==E_EXPR_GTE)\r
+ { printf("("); cPrint(cur->param1,indent); printf(") >= ("); cPrint(cur->param2,indent); printf(")"); }\r
+ else if(cur->id==E_EXPR_EQ)\r
+ { printf("("); cPrint(cur->param1,indent); printf(") == ("); cPrint(cur->param2,indent); printf(")"); }\r
+ else if(cur->id==E_EXPR_NEQ)\r
+ { printf("("); cPrint(cur->param1,indent); printf(") != ("); cPrint(cur->param2,indent); printf(")"); }\r
+\r
+ /* ** statement ** */\r
+ else if(cur->id==E_STM_ASG)\r
+ {\r
+ cPrintIndent(indent); cPrint(cur->param1,indent); printf(" = "); cPrint(cur->param2,indent); printf(";\n\n");\r
+\r
+ if(cur->next)\r
+ { cPrint(cur->next,indent); }\r
+ }\r
+ else if(cur->id==E_STM_WHILE)\r
+ {\r
+ cPrintIndent(indent); printf("while("); cPrint(cur->param1,indent); printf(")\n");\r
+ cPrintIndent(indent+1); printf("{\n");\r
+ cPrint(cur->param2,indent+1);\r
+ cPrintIndent(indent+1); printf("}\n\n");\r
+\r
+ if(cur->next)\r
+ { cPrint(cur->next,indent); }\r
+ }\r
+ else if(cur->id==E_STM_IF)\r
+ {\r
+ valueLeaf *tmp=cur->param1;\r
+\r
+ while(tmp)\r
+ {\r
+ cPrintIndent(indent); printf("%s(",(tmp==cur->param1) ? "if" : "else if"); cPrint(tmp->param1,indent); printf(")\n");\r
+ cPrintIndent(indent+1); printf("{\n");\r
+ cPrint(tmp->param2,indent+1);\r
+ cPrintIndent(indent+1); printf("}\n");\r
+\r
+ tmp=tmp->next;\r
+ }\r
+\r
+ if(cur->param2)\r
+ {\r
+ cPrintIndent(indent); printf("else\n");\r
+ cPrintIndent(indent+1); printf("{\n");\r
+ cPrint(cur->param2,indent+1);\r
+ cPrintIndent(indent+1); printf("}\n");\r
+ }\r
+\r
+ printf("\n");\r
+\r
+ if(cur->next)\r
+ { cPrint(cur->next,indent); }\r
+ }\r
+\r
+ /* ** dichiarazioni ** */\r
+ else if((cur->id==E_DECL_CONST)||(cur->id==E_DECL_VAR))\r
+ {\r
+ valueLeaf *tmp=cur->param1;\r
+ char bufferDim[256];\r
+\r
+ memset(bufferDim,0,256);\r
+\r
+ while(tmp->id==E_TYPE_ARRAY)\r
+ {\r
+ sprintf(&bufferDim[strlen(bufferDim)],"[%d]",tmp->param1->inumValue+1);\r
+ tmp=tmp->param2;\r
+ }\r
+\r
+ cPrintIndent(indent);\r
+ if(cur->id==E_DECL_CONST)\r
+ { printf("const "); }\r
+\r
+ if(tmp->id==E_TYPE_STRUCT)\r
+ { printf("user%d_t\t",getUserType(tmp,NULL)); }\r
+ else if(tmp->id==E_TYPE_DWORD)\r
+ { printf("_DWORD_\t"); }\r
+ else if(tmp->id==E_TYPE_WORD)\r
+ { printf("_WORD_\t"); }\r
+ else\r
+ { printf("_BYTE_\t"); }\r
+\r
+ printf("%s%s",cur->param2->stringValue,bufferDim);\r
+\r
+ if(cur->param3)\r
+ { printf(" = "); cPrint(cur->param3,indent); }\r
+ printf(";\n\n");\r
+\r
+ if(cur->next)\r
+ { cPrint(cur->next,indent); }\r
+ }\r
+}\r
+\r
+/* *************************** main ******************************* */\r
+\r
+int main(int argc,char **argv)\r
+{\r
+ int ret;\r
+\r
+ /* ignora eventuali errori di parametri */\r
+ if(argc>1)\r
+ { usage(argv[0]); }\r
+\r
+ ret=yyparse(NULL);\r
+\r
+ if((!ret)&&(!numErr))\r
+ {\r
+ printf("(* matita language *)\n\n");\r
+ printf("definition parsingResult \\def\n");\r
+ printf(" (PREAST_ROOT\n");\r
+ prettyPrint(&root,2);\r
+ printf(" ).\n\n");\r
+\r
+ printf("(* C language\n\n");\r
+ printf("#ifndef\t__STDC__\n");\r
+ printf("typedef\tunsigned __int32\t_DWORD_;\n");\r
+ printf("typedef\tunsigned __int16\t_WORD_;\n");\r
+ printf("typedef\tunsigned __int8\t_BYTE_;\n");\r
+ printf("#else\n");\r
+ printf("typedef\t__uint32_t\t_DWORD_;\n");\r
+ printf("typedef\t__uint16_t\t_WORD_;\n");\r
+ printf("typedef\t__uint8_t\t_BYTE_;\n");\r
+ printf("#endif\n\n");\r
+ cPrintTypes();\r
+ printf("void main(void)\n");\r
+ printf("{\n");\r
+ cPrint(&root,1);\r
+ printf("\treturn;\n\n");\r
+ printf("}\n\n");\r
+ printf("*)");\r
+ }\r
+\r
+ return(ret);\r
+}\r
projects / helm.git / blobdiff