2 /* ******************************** */
\r
3 /* PER UNA CORRETTA VISUALIZZAZIONE */
\r
5 /* ******************************** */
\r
12 #include <sys/types.h>
\r
14 /* ************************************************************************* */
\r
16 #define YYDEBUG 1 /* debug interno di bison */
\r
18 #define inline /* compatibilita' con l'opzione %glr-parser */
\r
19 #define YYLTYPE_IS_DECLARED 1 /* compatibilita' con VISUAL C */
\r
21 #define SEP '\n' /* formattazione in input */
\r
23 #define YYSTYPE valueLeaf * /* struttura puntata dai nodi/foglie */
\r
27 /* manipolazione della posizione nel sorgente (bison) */
\r
28 #define YYLLOC_DEFAULT(Current,Rhs,N) \
\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
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
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
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
63 /* ************************************************************************* */
\r
65 /* struttura per la posizione manipolata direttamente da YYLOC_DEFAULT (bison) */
\r
66 typedef struct YYLTYPE
\r
75 /* enumerazione delle etichette dei nodi/foglie */
\r
131 /* struttura polimorfa dei nodi/foglie */
\r
132 typedef struct _valueLeaf_
\r
137 _DWORD_ dwordValue;
\r
140 unsigned long int inumValue;
\r
143 struct _valueLeaf_ *param1;
\r
144 struct _valueLeaf_ *param2;
\r
145 struct _valueLeaf_ *param3;
\r
146 struct _valueLeaf_ *param4;
\r
149 struct _valueLeaf_ *next;
\r
150 struct _valueLeaf_ *last;
\r
152 /* posizione nel sorgente */
\r
158 /* ************************************************************************* */
\r
160 valueLeaf root; /* radice dell'AST */
\r
161 valueLeaf *typeRoot=NULL; /* radice degli user type */
\r
165 /* ************************************************************************* */
\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
171 _DWORD_ dwordValue,\
\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
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
191 int eqUserType(valueLeaf *type1,valueLeaf *type2);
\r
192 int getUserType(valueLeaf *type,valueLeaf **res);
\r
193 void createUserType(valueLeaf *type);
\r
195 void prettyPrint(valueLeaf *cur,int indent);
\r
197 /* ************************************************************************* */
\r
203 %lex-param {void *p}
\r
204 %parse-param {void *p}
\r
207 /* ************************************************************************* */
\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
215 %token Type_BYTE Type_WORD Type_DWORD
\r
218 %token OpenBracket_BODY CloseBracket_BODY
\r
219 %token OpenBracket_SQUARE CloseBracket_SQUARE
\r
220 %token OpenBracket_ROUND CloseBracket_ROUND
\r
222 /* operatori unari */
\r
223 %token UnaryOperator_NOT UnaryOperator_COM
\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
232 %token Separator_COLUMN Separator_SELECT Separator_COMMA
\r
235 %token Value_DWORD Value_WORD Value_BYTE Value_INUM Value_STRING
\r
237 /* ************************************************************************* */
\r
241 /* priorita' minima */
\r
243 %right Separator_COMMA
\r
245 %nonassoc DualOperator_ASG
\r
247 %nonassoc Keyword_B2W Keyword_B2DW Keyword_W2B Keyword_W2DW Keyword_DW2B Keyword_DW2W
\r
249 %left DualOperator_OR
\r
250 %left DualOperator_XOR
\r
251 %left DualOperator_AND
\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
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
267 %nonassoc UnaryOperator_SUB
\r
268 %nonassoc UnaryOperator_COM
\r
269 %nonassoc UnaryOperator_NOT
\r
271 %right Separator_SELECT
\r
272 %right Separator_COLUMN
\r
274 %nonassoc OpenBracket_SQUARE CloseBracket_SQUARE
\r
275 %nonassoc OpenBracket_ROUND CloseBracket_ROUND
\r
276 %nonassoc OpenBracket_BODY CloseBracket_BODY
\r
278 /* priorita' massima */
\r
280 /* ************************************************************************* */
\r
284 /* ** FUNZIONE PRINCIPALE ** */
\r
285 _start_ : OpenBracket_BODY _decl_lst_ CloseBracket_BODY
\r
286 { memcpy(&root,$2,sizeof(valueLeaf)); };
\r
288 /* ** GESTIONE DICHIARAZIONI ** */
\r
289 _decl_lst_ : Keyword_CONST _type_ Value_STRING DualOperator_ASG _init_choice_ Separator_COLUMN _decl_lst_
\r
291 $$=treeId3Alloc(E_DECL_CONST,$2,$3,$5,&@1);
\r
294 _type_ Value_STRING _init_ Separator_COLUMN _decl_lst_
\r
296 $$=treeId3Alloc(E_DECL_VAR,$1,$2,$3,&@1);
\r
302 _type_ : Keyword_ARRAY OpenBracket_SQUARE Value_INUM CloseBracket_SQUARE Keyword_OF _type_
\r
304 if(!($3->inumValue))
\r
305 { yyerror(&@1,p,"unallowed empty array"); }
\r
308 $$=treeId2Alloc(E_TYPE_ARRAY,$3,$6,&@1);
\r
312 Keyword_STRUCT OpenBracket_BODY _type_ Separator_COLUMN _type_lst_ CloseBracket_BODY
\r
314 $$=treeId1Alloc(E_TYPE_STRUCT,$3,&@1);
\r
317 createUserType($$);
\r
320 { $$=treeId0Alloc(E_TYPE_DWORD,&@1); }|
\r
322 { $$=treeId0Alloc(E_TYPE_WORD,&@1); }|
\r
324 { $$=treeId0Alloc(E_TYPE_BYTE,&@1); };
\r
326 _type_lst_ : _type_ Separator_COLUMN _type_lst_
\r
334 _init_ : DualOperator_ASG _init_choice_
\r
339 _init_choice_ : _init_val_
\r
344 _init_val_ : OpenBracket_SQUARE _init_val_ _init_val_lst_ CloseBracket_SQUARE
\r
346 $$=treeId1Alloc(E_VALUE_ARRAY,$2,&@1);
\r
349 OpenBracket_BODY _init_val_ _init_val_lst_ CloseBracket_BODY
\r
351 $$=treeId1Alloc(E_VALUE_STRUCT,$2,&@1);
\r
361 _init_val_lst_ : Separator_COMMA _init_val_ _init_val_lst_
\r
369 /* ** GESTIONE STATEMENT ** */
\r
370 _stm_lst_ : _var_ DualOperator_ASG _expr_ Separator_COLUMN _stm_lst_
\r
372 $$=treeId2Alloc(E_STM_ASG,$1,$3,&@1);
\r
375 Keyword_WHILE OpenBracket_ROUND _expr_ CloseBracket_ROUND OpenBracket_BODY _decl_lst_ CloseBracket_BODY _stm_lst_
\r
377 $$=treeId2Alloc(E_STM_WHILE,$3,$6,&@1);
\r
380 Keyword_IF OpenBracket_ROUND _expr_ CloseBracket_ROUND OpenBracket_BODY _decl_lst_ CloseBracket_BODY _elsif_lst_ _else_ _stm_lst_
\r
382 $$=treeId2Alloc(E_STM_IF,treeId2Alloc(E_STM_IFEXPRBODY,$3,$6,&@1),$9,&@1);
\r
383 $$->param1->next=$8;
\r
389 _elsif_lst_ : Keyword_ELSIF OpenBracket_ROUND _expr_ CloseBracket_ROUND OpenBracket_BODY _decl_lst_ CloseBracket_BODY _elsif_lst_
\r
391 $$=treeId2Alloc(E_STM_IFEXPRBODY,$3,$6,&@1);
\r
397 _else_ : Keyword_ELSE OpenBracket_BODY _decl_lst_ CloseBracket_BODY
\r
402 _expr_ : OpenBracket_ROUND _expr_ CloseBracket_ROUND
\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
459 { $$=treeId1Alloc(E_EXPR_VAR,$1,&@1); };
\r
461 _var_ : Value_STRING _var_sub_
\r
466 $$->last->next=treeId1Alloc(E_VAR_ROOT,$1,&@1);
\r
469 { $$=treeId1Alloc(E_VAR_ROOT,$1,&@1); }
\r
472 _var_sub_ : Separator_SELECT Value_INUM _var_sub_
\r
476 valueLeaf *tmp=treeId1Alloc(E_VAR_STRUCT,$2,&@1);
\r
479 $$->last->next=tmp;
\r
484 $$=treeId1Alloc(E_VAR_STRUCT,$2,&@1);
\r
488 OpenBracket_SQUARE _expr_ CloseBracket_SQUARE _var_sub_
\r
492 valueLeaf *tmp=treeId1Alloc(E_VAR_ARRAY,$2,&@1);
\r
495 $$->last->next=tmp;
\r
500 $$=treeId1Alloc(E_VAR_ARRAY,$2,&@1);
\r
507 /* ************************************************************************* */
\r
511 void yyerror(const YYLTYPE *locp,void *p,char const *msg)
\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
516 { printf(":0,0\tParsError: %s%c",msg,SEP); }
\r
523 valueLeaf *treeAlloc(\
\r
525 _DWORD_ dwordValue,\
\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
537 if(!(tmp=(valueLeaf *) myMalloc(sizeof(valueLeaf))))
\r
539 printf("[%s:%d] ParsError:OutOfMemory%c",__FILE__,__LINE__,SEP);
\r
543 memset(tmp,0,sizeof(valueLeaf));
\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
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
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
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
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
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
573 valueLeaf *treeId0Alloc(vEnum id,const YYLTYPE *locp)
\r
574 { return(treeAlloc(id,0,0,0,0,NULL,NULL,NULL,NULL,locp)); }
\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
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
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
585 /* riconoscimento token da input */
\r
586 int yylex(YYSTYPE *lvalp,YYLTYPE *llocp,void *p)
\r
589 char bufToken[256];
\r
590 char bufString[256];
\r
593 /* riconoscimento di source:linea,colonna */
\r
594 fscanf(stdin,"%s%s%s\n",bufLine,bufToken,bufString,SEP);
\r
596 if(!strcmp(bufToken,"ERR"))
\r
598 printf("%s\t%s%c",bufLine,bufString,SEP);
\r
602 for(tmp1=bufLine;*tmp1!=':';tmp1++);
\r
605 for(tmp2=tmp1+1;*tmp2!=',';tmp2++);
\r
608 llocp->first_line=llocp->last_line=atoi(tmp1+1);
\r
609 llocp->first_column=llocp->last_column=atoi(tmp2+1);
\r
611 if(!(llocp->source=(char *) myMalloc(strlen(bufLine)+1)))
\r
613 printf("[%s:%d] ParsError:OutOfMemory%c",__FILE__,__LINE__,SEP);
\r
618 strcpy(llocp->source,bufLine);
\r
624 if(!strcmp(bufToken,"OK"))
\r
626 root.source=llocp->source;
\r
627 root.fileLine=llocp->first_line;
\r
628 root.fileRow=llocp->first_column;
\r
630 return yylex(lvalp,llocp,p);
\r
632 else if(!strcmp(bufToken,"EOF"))
\r
635 /* categoria keyword */
\r
636 if(!strcmp(bufToken,"KEW"))
\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
668 printf("%s\tParsError:UnknownKeywordToken(%s)%c",bufLine,bufString,SEP);
\r
672 /* categoria tipo nativo */
\r
673 else if(!strcmp(bufToken,"TYP"))
\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
683 printf("%s\tParsError:UnknownTypeToken(%s)%c",bufLine,bufString,SEP);
\r
687 /* categoria parentesi */
\r
688 else if(!strcmp(bufToken,"BRK"))
\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
704 printf("%s\tParsError:UnknownBracketToken(%s)%c",bufLine,bufString,SEP);
\r
708 /* categoria operatore unario */
\r
709 else if(!strcmp(bufToken,"MOP"))
\r
711 if(!strcmp(bufString,"!"))
\r
712 { return(UnaryOperator_NOT); }
\r
713 else if(!strcmp(bufString,"~"))
\r
714 { return(UnaryOperator_COM); }
\r
717 printf("%s\tParsError:UnknownUnaryOperatorToken(%s)%c",bufLine,bufString,SEP);
\r
721 /* categoria operatore duale */
\r
722 else if(!strcmp(bufToken,"DOP"))
\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
758 printf("%s\tParsError:UnknownDualOperatorToken(%s)%c",bufLine,bufString,SEP);
\r
762 /* categoria separatore */
\r
763 else if(!strcmp(bufToken,"SEP"))
\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
773 printf("%s\tParsError:UnknownSeparatorToken(%s)%c",bufLine,bufString,SEP);
\r
777 /* categoria dword */
\r
778 else if(!strcmp(bufToken,"W32"))
\r
780 unsigned long int tmpI;
\r
782 if(sscanf(bufString,"0x%lx",&tmpI)==1)
\r
784 *lvalp=treeDwordAlloc((_DWORD_) (tmpI&0xFFFFFFFF),llocp);
\r
785 return(Value_DWORD);
\r
789 printf("%s\tParsError:UnknownIntToken(%s)%c",bufLine,bufString,SEP);
\r
793 /* categoria word */
\r
794 else if(!strcmp(bufToken,"W16"))
\r
796 unsigned long int tmpI;
\r
798 if(sscanf(bufString,"0x%lx",&tmpI)==1)
\r
800 *lvalp=treeWordAlloc((_WORD_) (tmpI&0xFFFF),llocp);
\r
801 return(Value_WORD);
\r
805 printf("%s\tParsError:UnknownIntToken(%s)%c",bufLine,bufString,SEP);
\r
809 /* categoria byte */
\r
810 else if(!strcmp(bufToken,"BY8"))
\r
812 unsigned long int tmpI;
\r
814 if(sscanf(bufString,"0x%lx",&tmpI)==1)
\r
816 *lvalp=treeByteAlloc((_BYTE_) (tmpI&0xFF),llocp);
\r
817 return(Value_BYTE);
\r
821 printf("%s\tParsError:UnknownIntToken(%s)%c",bufLine,bufString,SEP);
\r
825 /* categoria numero intero */
\r
826 else if(!strcmp(bufToken,"INU"))
\r
828 unsigned long int tmpI;
\r
830 if(sscanf(bufString,"%lu",&tmpI)==1)
\r
832 *lvalp=treeInumAlloc(tmpI,llocp);
\r
833 return(Value_INUM);
\r
837 printf("%s\tParsError:UnknownIntToken(%s)%c",bufLine,bufString,SEP);
\r
841 /* categoria ID == stringa */
\r
842 else if(!strcmp(bufToken,"IID"))
\r
846 if(!(tmpS=(char *) myMalloc(strlen(bufString)+1)))
\r
848 printf("[%s:%d] ParsError:OutOfMemory%c",__FILE__,__LINE__,SEP);
\r
853 strcpy(tmpS,bufString);
\r
855 *lvalp=treeStringAlloc(tmpS,llocp);
\r
856 return(Value_STRING);
\r
860 printf("%s\tParsError:UnknownToken(%s)%c",bufLine,bufString,SEP);
\r
865 void usage(char *name)
\r
867 printf("\nC Parser - Cosimo Oliboni\n\n");
\r
868 printf("\"%s\" parsing da stdin\n\n",name);
\r
873 /* *************************** gestione degli user type *********** */
\r
875 int eqUserType(valueLeaf *type1,valueLeaf *type2)
\r
877 valueLeaf *tmp1,*tmp2;
\r
879 if(type1->id!=type2->id)
\r
890 if(type1->param1->inumValue!=type2->param1->inumValue)
\r
893 return(eqUserType(type1->param2,type2->param2));
\r
895 case E_TYPE_STRUCT:
\r
896 tmp1=type1->param1;
\r
897 tmp2=type2->param1;
\r
901 if(!eqUserType(tmp1,tmp2))
\r
908 return(!(tmp1||tmp2));
\r
916 int getUserType(valueLeaf *type,valueLeaf **res)
\r
918 valueLeaf *tmpRes=typeRoot;
\r
919 valueLeaf *lastRes;
\r
924 if(eqUserType(type,tmpRes))
\r
932 tmpRes=tmpRes->next;
\r
941 void createUserType(valueLeaf *type)
\r
945 if(!(typeRoot=(valueLeaf *) myMalloc(sizeof(valueLeaf))))
\r
947 printf("[%s:%d] ParsError:OutOfMemory%c",__FILE__,__LINE__,SEP);
\r
951 memcpy(typeRoot,type,sizeof(valueLeaf));
\r
952 typeRoot->next=NULL;
\r
958 if(!getUserType(type,&res))
\r
960 if(!(res->next=(valueLeaf *) myMalloc(sizeof(valueLeaf))))
\r
962 printf("[%s:%d] ParsError:OutOfMemory%c",__FILE__,__LINE__,SEP);
\r
966 memcpy(res->next,type,sizeof(valueLeaf));
\r
967 res->next->next=NULL;
\r
972 /* *************************** prettyPrint ************************ */
\r
974 void prettyPrintString(char *str)
\r
980 printf("ch_%c",*str);
\r
991 void prettyPrintByte(_BYTE_ num)
\r
993 printf("(\\langle x%1X,x%1X \\rangle)",(unsigned int) (num>>4),(unsigned int) (num&0xF));
\r
996 void prettyPrintWord(_WORD_ num)
\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
1003 void prettyPrintDword(_DWORD_ num)
\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
1012 void prettyPrintIndent(int indent)
\r
1016 for(index=0;index<indent;index++)
\r
1020 void prettyPrintInum(unsigned long int num)
\r
1023 { printf("O\n"); }
\r
1025 { printf("%lu\n",num); }
\r
1028 void prettyPrintInit(valueLeaf *cur,int indent)
\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
1038 valueLeaf *tmp=cur->param1;
\r
1040 prettyPrintIndent(indent); printf("(PREAST_INIT_VAL_ARRAY\n");
\r
1042 prettyPrintIndent(indent+1); printf("(\\laquo\n");
\r
1044 { prettyPrintIndent(indent+2); printf("£\n"); }
\r
1047 prettyPrintInit(tmp,indent+2);
\r
1051 if(tmp->next->next)
\r
1052 { prettyPrintIndent(indent+2); printf(";\n"); }
\r
1054 { prettyPrintIndent(indent+2); printf("£\n"); }
\r
1059 prettyPrintIndent(indent+1); printf("\\raquo)\n");
\r
1061 prettyPrintIndent(indent); printf(")\n");
\r
1063 else if(cur->id==E_VALUE_STRUCT)
\r
1065 valueLeaf *tmp=cur->param1;
\r
1067 prettyPrintIndent(indent); printf("(PREAST_INIT_VAL_STRUCT\n");
\r
1069 prettyPrintIndent(indent+1); printf("(\\laquo\n");
\r
1071 { prettyPrintIndent(indent+2); printf("£\n"); }
\r
1074 prettyPrintInit(tmp,indent+2);
\r
1078 if(tmp->next->next)
\r
1079 { prettyPrintIndent(indent+2); printf(";\n"); }
\r
1081 { prettyPrintIndent(indent+2); printf("£\n"); }
\r
1086 prettyPrintIndent(indent+1); printf("\\raquo)\n");
\r
1088 prettyPrintIndent(indent); printf(")\n");
\r
1092 void prettyPrintBody(valueLeaf *cur,int indent)
\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
1100 valueLeaf *tmp=cur;
\r
1102 prettyPrintIndent(indent); printf("(PREAST_NO_DECL\n");
\r
1104 prettyPrintIndent(indent+1); printf("[\n");
\r
1107 prettyPrint(tmp,indent+2);
\r
1110 { prettyPrintIndent(indent+2); printf(";\n"); }
\r
1114 prettyPrintIndent(indent+1); printf("]\n");
\r
1116 prettyPrintIndent(indent); printf(")\n");
\r
1121 void prettyPrint(valueLeaf *cur,int indent)
\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
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
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
1143 else if(cur->id==E_TYPE_STRUCT)
\r
1145 valueLeaf *tmp=cur->param1;
\r
1147 prettyPrintIndent(indent); printf("(AST_TYPE_STRUCT\n");
\r
1149 prettyPrintIndent(indent+1); printf("(\\laquo\n");
\r
1151 { prettyPrintIndent(indent+2); printf("£\n"); }
\r
1154 prettyPrint(tmp,indent+2);
\r
1158 if(tmp->next->next)
\r
1159 { prettyPrintIndent(indent+2); printf(";\n"); }
\r
1161 { prettyPrintIndent(indent+2); printf("£\n"); }
\r
1166 prettyPrintIndent(indent+1); printf("\\raquo)\n");
\r
1168 prettyPrintIndent(indent); printf(")\n");
\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
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
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
1189 else if(cur->id==E_VAR_ARRAY)
\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
1197 /* ** espressioni ** */
\r
1198 else if(cur->id==E_EXPR_VAR)
\r
1200 prettyPrintIndent(indent); printf("(PREAST_EXPR_ID\n");
\r
1201 prettyPrint(cur->param1,indent+1);
\r
1202 prettyPrintIndent(indent); printf(")\n");
\r
1204 else if(cur->id==E_EXPR_NOT)
\r
1206 prettyPrintIndent(indent); printf("(PREAST_EXPR_NOT\n");
\r
1207 prettyPrint(cur->param1,indent+1);
\r
1208 prettyPrintIndent(indent); printf(")\n");
\r
1210 else if(cur->id==E_EXPR_COM)
\r
1212 prettyPrintIndent(indent); printf("(PREAST_EXPR_COM\n");
\r
1213 prettyPrint(cur->param1,indent+1);
\r
1214 prettyPrintIndent(indent); printf(")\n");
\r
1216 else if(cur->id==E_EXPR_NEG)
\r
1218 prettyPrintIndent(indent); printf("(PREAST_EXPR_NEG\n");
\r
1219 prettyPrint(cur->param1,indent+1);
\r
1220 prettyPrintIndent(indent); printf(")\n");
\r
1222 else if(cur->id==E_EXPR_B2W)
\r
1224 prettyPrintIndent(indent); printf("(PREAST_EXPR_B8toW16\n");
\r
1225 prettyPrint(cur->param1,indent+1);
\r
1226 prettyPrintIndent(indent); printf(")\n");
\r
1228 else if(cur->id==E_EXPR_B2DW)
\r
1230 prettyPrintIndent(indent); printf("(PREAST_EXPR_B8toW32\n");
\r
1231 prettyPrint(cur->param1,indent+1);
\r
1232 prettyPrintIndent(indent); printf(")\n");
\r
1234 else if(cur->id==E_EXPR_W2B)
\r
1236 prettyPrintIndent(indent); printf("(PREAST_EXPR_W16toB8\n");
\r
1237 prettyPrint(cur->param1,indent+1);
\r
1238 prettyPrintIndent(indent); printf(")\n");
\r
1240 else if(cur->id==E_EXPR_W2DW)
\r
1242 prettyPrintIndent(indent); printf("(PREAST_EXPR_W16toW32\n");
\r
1243 prettyPrint(cur->param1,indent+1);
\r
1244 prettyPrintIndent(indent); printf(")\n");
\r
1246 else if(cur->id==E_EXPR_DW2B)
\r
1248 prettyPrintIndent(indent); printf("(PREAST_EXPR_W32toB8\n");
\r
1249 prettyPrint(cur->param1,indent+1);
\r
1250 prettyPrintIndent(indent); printf(")\n");
\r
1252 else if(cur->id==E_EXPR_DW2W)
\r
1254 prettyPrintIndent(indent); printf("(PREAST_EXPR_W32toW16\n");
\r
1255 prettyPrint(cur->param1,indent+1);
\r
1256 prettyPrintIndent(indent); printf(")\n");
\r
1258 else if(cur->id==E_EXPR_ADD)
\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
1265 else if(cur->id==E_EXPR_SUB)
\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
1272 else if(cur->id==E_EXPR_MUL)
\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
1279 else if(cur->id==E_EXPR_DIV)
\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
1286 else if(cur->id==E_EXPR_SHL)
\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
1293 else if(cur->id==E_EXPR_SHR)
\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
1300 else if(cur->id==E_EXPR_AND)
\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
1307 else if(cur->id==E_EXPR_OR)
\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
1314 else if(cur->id==E_EXPR_XOR)
\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
1321 else if(cur->id==E_EXPR_LT)
\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
1328 else if(cur->id==E_EXPR_LTE)
\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
1335 else if(cur->id==E_EXPR_GT)
\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
1342 else if(cur->id==E_EXPR_GTE)
\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
1349 else if(cur->id==E_EXPR_EQ)
\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
1356 else if(cur->id==E_EXPR_NEQ)
\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
1364 /* ** dichiarazioni ** */
\r
1365 else if(cur->id==E_DECL_CONST)
\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
1371 if((cur->param3->id==E_VAR_ROOT)||(cur->param3->id==E_VAR_STRUCT)||(cur->param3->id==E_VAR_ARRAY))
\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
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
1386 if((cur->next->id==E_DECL_CONST)||(cur->next->id==E_DECL_VAR))
\r
1387 { prettyPrint(cur->next,indent+1); } //next decl
\r
1390 valueLeaf *tmp=cur->next;
\r
1392 prettyPrintIndent(indent+1); printf("(PREAST_NO_DECL\n");
\r
1394 prettyPrintIndent(indent+2); printf("[\n");
\r
1397 prettyPrint(tmp,indent+3);
\r
1400 { prettyPrintIndent(indent+3); printf(";\n"); }
\r
1404 prettyPrintIndent(indent+2); printf("]\n");
\r
1406 prettyPrintIndent(indent+1); printf(")\n");
\r
1410 { prettyPrintIndent(indent+1); printf("(PREAST_NO_DECL [])\n"); }
\r
1413 prettyPrintIndent(indent); printf(")\n");
\r
1415 else if(cur->id==E_DECL_VAR)
\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
1423 prettyPrintIndent(indent+1); printf("(Some ?\n");
\r
1425 if((cur->param3->id==E_VAR_ROOT)||(cur->param3->id==E_VAR_STRUCT)||(cur->param3->id==E_VAR_ARRAY))
\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
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
1438 prettyPrintIndent(indent+1); printf(")\n");
\r
1441 { prettyPrintIndent(indent+1); printf("(None ?)\n"); }
\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
1449 valueLeaf *tmp=cur->next;
\r
1451 prettyPrintIndent(indent+1); printf("(PREAST_NO_DECL\n");
\r
1453 prettyPrintIndent(indent+2); printf("[\n");
\r
1456 prettyPrint(tmp,indent+3);
\r
1459 { prettyPrintIndent(indent+3); printf(";\n"); }
\r
1463 prettyPrintIndent(indent+2); printf("]\n");
\r
1465 prettyPrintIndent(indent+1); printf(")\n");
\r
1469 { prettyPrintIndent(indent+1); printf("(PREAST_NO_DECL [])\n"); }
\r
1472 prettyPrintIndent(indent); printf(")\n");
\r
1475 /* ** statement ** */
\r
1476 else if(cur->id==E_STM_ASG)
\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
1483 else if(cur->id==E_STM_WHILE)
\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
1490 else if(cur->id==E_STM_IF)
\r
1492 valueLeaf *tmp=cur->param1;
\r
1494 prettyPrintIndent(indent); printf("(PREAST_STM_IF\n");
\r
1496 prettyPrintIndent(indent+1); printf("(\\laquo\n");
\r
1498 { prettyPrintIndent(indent+2); printf("£\n"); }
\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
1508 if(tmp->next->next)
\r
1509 { prettyPrintIndent(indent+2); printf(";\n"); }
\r
1511 { prettyPrintIndent(indent+2); printf("£\n"); }
\r
1516 prettyPrintIndent(indent+1); printf("\\raquo)\n");
\r
1518 // equivalenza: Some ? (PREAST_NO_DECL []) = None ?
\r
1521 prettyPrintIndent(indent+1); printf("(Some ?\n");
\r
1522 prettyPrintBody(cur->param2,indent+2); //body
\r
1523 prettyPrintIndent(indent+1); printf(")\n");
\r
1526 { prettyPrintIndent(indent+1); printf("(None ?)\n"); }
\r
1528 prettyPrintIndent(indent); printf(")\n");
\r
1532 /* *************************** cPrint ***************************** */
\r
1534 void cPrintIndent(int indent)
\r
1538 for(index=0;index<indent;index++)
\r
1542 void cPrintTypesAux(valueLeaf *type,int field)
\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
1548 char bufferDim[256];
\r
1549 valueLeaf *tmp=type;
\r
1551 memset(bufferDim,0,256);
\r
1553 while(tmp->id==E_TYPE_ARRAY)
\r
1555 sprintf(&bufferDim[strlen(bufferDim)],"[%d]",tmp->param1->inumValue+1);
\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
1566 { printf("\t_BYTE_\tfield%d%s;\n\n",field,bufferDim); }
\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
1573 { printf("\t_BYTE_\tfield%d;\n\n",field); }
\r
1576 { cPrintTypesAux(type->next,field+1); }
\r
1579 void cPrintTypes(void)
\r
1582 valueLeaf *cur=typeRoot;
\r
1586 printf("typedef struct\n");
\r
1588 cPrintTypesAux(cur->param1,0);
\r
1589 printf("} user%d_t;\n\n",index);
\r
1596 void cPrint(valueLeaf *cur,int indent)
\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
1609 valueLeaf *tmp=cur->param1;
\r
1614 cPrint(tmp,indent);
\r
1622 /* ** variabili ** */
\r
1623 else if((cur->id==E_VAR_ROOT)||(cur->id==E_VAR_STRUCT)||(cur->id==E_VAR_ARRAY))
\r
1625 valueLeaf *tmp=cur;
\r
1627 while(tmp->id!=E_VAR_ROOT)
\r
1629 tmp->next->last=tmp;
\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
1645 { tmp=tmp->last; }
\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
1695 /* ** statement ** */
\r
1696 else if(cur->id==E_STM_ASG)
\r
1698 cPrintIndent(indent); cPrint(cur->param1,indent); printf(" = "); cPrint(cur->param2,indent); printf(";\n\n");
\r
1701 { cPrint(cur->next,indent); }
\r
1703 else if(cur->id==E_STM_WHILE)
\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
1711 { cPrint(cur->next,indent); }
\r
1713 else if(cur->id==E_STM_IF)
\r
1715 valueLeaf *tmp=cur->param1;
\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
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
1738 { cPrint(cur->next,indent); }
\r
1741 /* ** dichiarazioni ** */
\r
1742 else if((cur->id==E_DECL_CONST)||(cur->id==E_DECL_VAR))
\r
1744 valueLeaf *tmp=cur->param1;
\r
1745 char bufferDim[256];
\r
1747 memset(bufferDim,0,256);
\r
1749 while(tmp->id==E_TYPE_ARRAY)
\r
1751 sprintf(&bufferDim[strlen(bufferDim)],"[%d]",tmp->param1->inumValue+1);
\r
1755 cPrintIndent(indent);
\r
1756 if(cur->id==E_DECL_CONST)
\r
1757 { printf("const "); }
\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
1766 { printf("_BYTE_\t"); }
\r
1768 printf("%s%s",cur->param2->stringValue,bufferDim);
\r
1771 { printf(" = "); cPrint(cur->param3,indent); }
\r
1775 { cPrint(cur->next,indent); }
\r
1779 /* *************************** main ******************************* */
\r
1781 int main(int argc,char **argv)
\r
1785 /* ignora eventuali errori di parametri */
\r
1787 { usage(argv[0]); }
\r
1789 ret=yyparse(NULL);
\r
1791 if((!ret)&&(!numErr))
\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
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
1810 printf("void main(void)\n");
\r
1813 printf("\treturn;\n\n");
\r