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
164 /* ************************************************************************* */
\r
166 int yylex(YYSTYPE *lvalp,YYLTYPE *llocp,void *p);
\r
167 void yyerror(const YYLTYPE *locp,void *p,char const *msg);
\r
168 valueLeaf *treeAlloc(\
\r
170 _DWORD_ dwordValue,\
\r
173 unsigned long int inumValue,\
\r
174 char *stringValue,\
\r
175 valueLeaf *param1,\
\r
176 valueLeaf *param2,\
\r
177 valueLeaf *param3,\
\r
178 const YYLTYPE *locp);
\r
180 valueLeaf *treeDwordAlloc(_DWORD_ dwordValue,const YYLTYPE *locp);
\r
181 valueLeaf *treeWordAlloc(_WORD_ wordValue,const YYLTYPE *locp);
\r
182 valueLeaf *treeByteAlloc(_BYTE_ byteValue,const YYLTYPE *locp);
\r
183 valueLeaf *treeInumAlloc(unsigned long int inumValue,const YYLTYPE *locp);
\r
184 valueLeaf *treeStringAlloc(char *stringValue,const YYLTYPE *locp);
\r
185 valueLeaf *treeId0Alloc(vEnum id,const YYLTYPE *locp);
\r
186 valueLeaf *treeId1Alloc(vEnum id,valueLeaf *param1,const YYLTYPE *locp);
\r
187 valueLeaf *treeId2Alloc(vEnum id,valueLeaf *param1,valueLeaf *param2,const YYLTYPE *locp);
\r
188 valueLeaf *treeId3Alloc(vEnum id,valueLeaf *param1,valueLeaf *param2,valueLeaf *param3,const YYLTYPE *locp);
\r
190 void prettyPrint(valueLeaf *cur,int indent);
\r
192 /* ************************************************************************* */
\r
198 %lex-param {void *p}
\r
199 %parse-param {void *p}
\r
202 /* ************************************************************************* */
\r
205 %token Keyword_STRUCT Keyword_ARRAY Keyword_OF
\r
206 %token Keyword_IF Keyword_ELSIF Keyword_ELSE Keyword_WHILE Keyword_CONST
\r
207 %token Keyword_B2W Keyword_B2DW Keyword_W2B Keyword_W2DW Keyword_DW2B Keyword_DW2W
\r
210 %token Type_BYTE Type_WORD Type_DWORD
\r
213 %token OpenBracket_BODY CloseBracket_BODY
\r
214 %token OpenBracket_SQUARE CloseBracket_SQUARE
\r
215 %token OpenBracket_ROUND CloseBracket_ROUND
\r
217 /* operatori unari */
\r
218 %token UnaryOperator_NOT UnaryOperator_COM
\r
220 /* operatori duali */
\r
221 %token DualOperator_AND DualOperator_OR DualOperator_XOR
\r
222 %token DualOperator_ADD DualOperator_SUB DualOperator_MUL DualOperator_DIV
\r
223 %token DualOperator_NEQ DualOperator_EQ DualOperator_LT DualOperator_GT DualOperator_LTE DualOperator_GTE
\r
224 %token DualOperator_ASG DualOperator_SHR DualOperator_SHL
\r
227 %token Separator_COLUMN Separator_SELECT Separator_COMMA
\r
230 %token Value_DWORD Value_WORD Value_BYTE Value_INUM Value_STRING
\r
232 /* ************************************************************************* */
\r
236 /* priorita' minima */
\r
238 %right Separator_COMMA
\r
240 %nonassoc DualOperator_ASG
\r
242 %nonassoc Keyword_B2W Keyword_B2DW Keyword_W2B Keyword_W2DW Keyword_DW2B Keyword_DW2W
\r
244 %left DualOperator_OR
\r
245 %left DualOperator_XOR
\r
246 %left DualOperator_AND
\r
248 %nonassoc DualOperator_NEQ
\r
249 %nonassoc DualOperator_EQ
\r
250 %nonassoc DualOperator_GTE
\r
251 %nonassoc DualOperator_GT
\r
252 %nonassoc DualOperator_LTE
\r
253 %nonassoc DualOperator_LT
\r
255 %left DualOperator_SHR
\r
256 %left DualOperator_SHL
\r
257 %left DualOperator_SUB
\r
258 %left DualOperator_ADD
\r
259 %left DualOperator_DIV
\r
260 %left DualOperator_MUL
\r
262 %nonassoc UnaryOperator_SUB
\r
263 %nonassoc UnaryOperator_COM
\r
264 %nonassoc UnaryOperator_NOT
\r
266 %right Separator_SELECT
\r
267 %right Separator_COLUMN
\r
269 %nonassoc OpenBracket_SQUARE CloseBracket_SQUARE
\r
270 %nonassoc OpenBracket_ROUND CloseBracket_ROUND
\r
271 %nonassoc OpenBracket_BODY CloseBracket_BODY
\r
273 /* priorita' massima */
\r
275 /* ************************************************************************* */
\r
279 /* ** FUNZIONE PRINCIPALE ** */
\r
280 _start_ : OpenBracket_BODY _decl_lst_ CloseBracket_BODY
\r
281 { memcpy(&root,$2,sizeof(valueLeaf)); };
\r
283 /* ** GESTIONE DICHIARAZIONI ** */
\r
284 _decl_lst_ : Keyword_CONST _type_ Value_STRING DualOperator_ASG _init_choice_ Separator_COLUMN _decl_lst_
\r
286 $$=treeId3Alloc(E_DECL_CONST,$2,$3,$5,&@1);
\r
289 _type_ Value_STRING _init_ Separator_COLUMN _decl_lst_
\r
291 $$=treeId3Alloc(E_DECL_VAR,$1,$2,$3,&@1);
\r
297 _type_ : Keyword_ARRAY OpenBracket_SQUARE Value_INUM CloseBracket_SQUARE Keyword_OF _type_
\r
299 if(!($3->inumValue))
\r
300 { yyerror(&@1,p,"unallowed empty array"); }
\r
303 $$=treeId2Alloc(E_TYPE_ARRAY,$3,$6,&@1);
\r
307 Keyword_STRUCT OpenBracket_BODY _type_ Separator_COLUMN _type_lst_ CloseBracket_BODY
\r
309 $$=treeId1Alloc(E_TYPE_STRUCT,$3,&@1);
\r
313 { $$=treeId0Alloc(E_TYPE_DWORD,&@1); }|
\r
315 { $$=treeId0Alloc(E_TYPE_WORD,&@1); }|
\r
317 { $$=treeId0Alloc(E_TYPE_BYTE,&@1); };
\r
319 _type_lst_ : _type_ Separator_COLUMN _type_lst_
\r
327 _init_ : DualOperator_ASG _init_choice_
\r
332 _init_choice_ : _init_val_
\r
337 _init_val_ : OpenBracket_SQUARE _init_val_ _init_val_lst_ CloseBracket_SQUARE
\r
339 $$=treeId1Alloc(E_VALUE_ARRAY,$2,&@1);
\r
342 OpenBracket_BODY _init_val_ _init_val_lst_ CloseBracket_BODY
\r
344 $$=treeId1Alloc(E_VALUE_STRUCT,$2,&@1);
\r
354 _init_val_lst_ : Separator_COMMA _init_val_ _init_val_lst_
\r
362 /* ** GESTIONE STATEMENT ** */
\r
363 _stm_lst_ : _var_ DualOperator_ASG _expr_ Separator_COLUMN _stm_lst_
\r
365 $$=treeId2Alloc(E_STM_ASG,$1,$3,&@1);
\r
368 Keyword_WHILE OpenBracket_ROUND _expr_ CloseBracket_ROUND OpenBracket_BODY _decl_lst_ CloseBracket_BODY _stm_lst_
\r
370 $$=treeId2Alloc(E_STM_WHILE,$3,$6,&@1);
\r
373 Keyword_IF OpenBracket_ROUND _expr_ CloseBracket_ROUND OpenBracket_BODY _decl_lst_ CloseBracket_BODY _elsif_lst_ _else_ _stm_lst_
\r
375 $$=treeId2Alloc(E_STM_IF,treeId2Alloc(E_STM_IFEXPRBODY,$3,$6,&@1),$9,&@1);
\r
376 $$->param1->next=$8;
\r
382 _elsif_lst_ : Keyword_ELSIF OpenBracket_ROUND _expr_ CloseBracket_ROUND OpenBracket_BODY _decl_lst_ CloseBracket_BODY _elsif_lst_
\r
384 $$=treeId2Alloc(E_STM_IFEXPRBODY,$3,$6,&@1);
\r
390 _else_ : Keyword_ELSE OpenBracket_BODY _decl_lst_ CloseBracket_BODY
\r
395 _expr_ : OpenBracket_ROUND _expr_ CloseBracket_ROUND
\r
397 UnaryOperator_NOT _expr_
\r
398 { $$=treeId1Alloc(E_EXPR_NOT,$2,&@1); }|
\r
399 UnaryOperator_COM _expr_
\r
400 { $$=treeId1Alloc(E_EXPR_COM,$2,&@1); }|
\r
401 DualOperator_SUB _expr_ %prec UnaryOperator_SUB
\r
402 { $$=treeId1Alloc(E_EXPR_NEG,$2,&@1); }|
\r
403 Keyword_B2W OpenBracket_ROUND _expr_ CloseBracket_ROUND
\r
404 { $$=treeId1Alloc(E_EXPR_B2W,$3,&@1); }|
\r
405 Keyword_B2DW OpenBracket_ROUND _expr_ CloseBracket_ROUND
\r
406 { $$=treeId1Alloc(E_EXPR_B2DW,$3,&@1); }|
\r
407 Keyword_W2B OpenBracket_ROUND _expr_ CloseBracket_ROUND
\r
408 { $$=treeId1Alloc(E_EXPR_W2B,$3,&@1); }|
\r
409 Keyword_W2DW OpenBracket_ROUND _expr_ CloseBracket_ROUND
\r
410 { $$=treeId1Alloc(E_EXPR_W2DW,$3,&@1); }|
\r
411 Keyword_DW2B OpenBracket_ROUND _expr_ CloseBracket_ROUND
\r
412 { $$=treeId1Alloc(E_EXPR_DW2B,$3,&@1); }|
\r
413 Keyword_DW2W OpenBracket_ROUND _expr_ CloseBracket_ROUND
\r
414 { $$=treeId1Alloc(E_EXPR_DW2W,$3,&@1); }|
\r
415 _expr_ DualOperator_MUL _expr_
\r
416 { $$=treeId2Alloc(E_EXPR_MUL,$1,$3,&@1); }|
\r
417 _expr_ DualOperator_DIV _expr_
\r
418 { $$=treeId2Alloc(E_EXPR_DIV,$1,$3,&@1); }|
\r
419 _expr_ DualOperator_ADD _expr_
\r
420 { $$=treeId2Alloc(E_EXPR_ADD,$1,$3,&@1); }|
\r
421 _expr_ DualOperator_SUB _expr_
\r
422 { $$=treeId2Alloc(E_EXPR_SUB,$1,$3,&@1); }|
\r
423 _expr_ DualOperator_SHL _expr_
\r
424 { $$=treeId2Alloc(E_EXPR_SHL,$1,$3,&@1); }|
\r
425 _expr_ DualOperator_SHR _expr_
\r
426 { $$=treeId2Alloc(E_EXPR_SHR,$1,$3,&@1); }|
\r
427 _expr_ DualOperator_LT _expr_
\r
428 { $$=treeId2Alloc(E_EXPR_LT,$1,$3,&@1); }|
\r
429 _expr_ DualOperator_LTE _expr_
\r
430 { $$=treeId2Alloc(E_EXPR_LTE,$1,$3,&@1); }|
\r
431 _expr_ DualOperator_GT _expr_
\r
432 { $$=treeId2Alloc(E_EXPR_GT,$1,$3,&@1); }|
\r
433 _expr_ DualOperator_GTE _expr_
\r
434 { $$=treeId2Alloc(E_EXPR_GTE,$1,$3,&@1); }|
\r
435 _expr_ DualOperator_NEQ _expr_
\r
436 { $$=treeId2Alloc(E_EXPR_NEQ,$1,$3,&@1); }|
\r
437 _expr_ DualOperator_EQ _expr_
\r
438 { $$=treeId2Alloc(E_EXPR_EQ,$1,$3,&@1); }|
\r
439 _expr_ DualOperator_AND _expr_
\r
440 { $$=treeId2Alloc(E_EXPR_AND,$1,$3,&@1); }|
\r
441 _expr_ DualOperator_OR _expr_
\r
442 { $$=treeId2Alloc(E_EXPR_OR,$1,$3,&@1); }|
\r
443 _expr_ DualOperator_XOR _expr_
\r
444 { $$=treeId2Alloc(E_EXPR_XOR,$1,$3,&@1); }|
\r
452 { $$=treeId1Alloc(E_EXPR_VAR,$1,&@1); };
\r
454 _var_ : Value_STRING _var_sub_
\r
459 $$->last->next=treeId1Alloc(E_VAR_ROOT,$1,&@1);
\r
462 { $$=treeId1Alloc(E_VAR_ROOT,$1,&@1); }
\r
465 _var_sub_ : Separator_SELECT Value_INUM _var_sub_
\r
469 valueLeaf *tmp=treeId1Alloc(E_VAR_STRUCT,$2,&@1);
\r
472 $$->last->next=tmp;
\r
477 $$=treeId1Alloc(E_VAR_STRUCT,$2,&@1);
\r
481 OpenBracket_SQUARE _expr_ CloseBracket_SQUARE _var_sub_
\r
485 valueLeaf *tmp=treeId1Alloc(E_VAR_ARRAY,$2,&@1);
\r
488 $$->last->next=tmp;
\r
493 $$=treeId1Alloc(E_VAR_ARRAY,$2,&@1);
\r
500 /* ************************************************************************* */
\r
504 void yyerror(const YYLTYPE *locp,void *p,char const *msg)
\r
506 if(locp->first_line>=0)
\r
507 { printf("%s:%d,%d\tParsError: %s%c",locp->source,locp->first_line,locp->first_column,msg,SEP); }
\r
509 { printf(":0,0\tParsError: %s%c",msg,SEP); }
\r
516 valueLeaf *treeAlloc(\
\r
518 _DWORD_ dwordValue,\
\r
521 unsigned long int inumValue,\
\r
522 char *stringValue,\
\r
523 valueLeaf *param1,\
\r
524 valueLeaf *param2,\
\r
525 valueLeaf *param3,\
\r
526 const YYLTYPE *locp)
\r
530 if(!(tmp=(valueLeaf *) myMalloc(sizeof(valueLeaf))))
\r
532 printf("[%s:%d] ParsError:OutOfMemory%c",__FILE__,__LINE__,SEP);
\r
536 memset(tmp,0,sizeof(valueLeaf));
\r
539 tmp->dwordValue=dwordValue;
\r
540 tmp->wordValue=wordValue;
\r
541 tmp->byteValue=byteValue;
\r
542 tmp->inumValue=inumValue;
\r
543 tmp->stringValue=stringValue;
\r
544 tmp->param1=param1;
\r
545 tmp->param2=param2;
\r
546 tmp->param3=param3;
\r
551 valueLeaf *treeDwordAlloc(_DWORD_ dwordValue,const YYLTYPE *locp)
\r
552 { return(treeAlloc(E_VALUE_DWORD,dwordValue,0,0,0,NULL,NULL,NULL,NULL,locp)); }
\r
554 valueLeaf *treeWordAlloc(_WORD_ wordValue,const YYLTYPE *locp)
\r
555 { return(treeAlloc(E_VALUE_WORD,0,wordValue,0,0,NULL,NULL,NULL,NULL,locp)); }
\r
557 valueLeaf *treeByteAlloc(_BYTE_ byteValue,const YYLTYPE *locp)
\r
558 { return(treeAlloc(E_VALUE_BYTE,0,0,byteValue,0,NULL,NULL,NULL,NULL,locp)); }
\r
560 valueLeaf *treeInumAlloc(unsigned long int inumValue,const YYLTYPE *locp)
\r
561 { return(treeAlloc(E_VALUE_INUM,0,0,0,inumValue,NULL,NULL,NULL,NULL,locp)); }
\r
563 valueLeaf *treeStringAlloc(char *stringValue,const YYLTYPE *locp)
\r
564 { return(treeAlloc(E_VALUE_STRING,0,0,0,0,stringValue,NULL,NULL,NULL,locp)); }
\r
566 valueLeaf *treeId0Alloc(vEnum id,const YYLTYPE *locp)
\r
567 { return(treeAlloc(id,0,0,0,0,NULL,NULL,NULL,NULL,locp)); }
\r
569 valueLeaf *treeId1Alloc(vEnum id,valueLeaf *param1,const YYLTYPE *locp)
\r
570 { return(treeAlloc(id,0,0,0,0,NULL,param1,NULL,NULL,locp)); }
\r
572 valueLeaf *treeId2Alloc(vEnum id,valueLeaf *param1,valueLeaf *param2,const YYLTYPE *locp)
\r
573 { return(treeAlloc(id,0,0,0,0,NULL,param1,param2,NULL,locp)); }
\r
575 valueLeaf *treeId3Alloc(vEnum id,valueLeaf *param1,valueLeaf *param2,valueLeaf *param3,const YYLTYPE *locp)
\r
576 { return(treeAlloc(id,0,0,0,0,NULL,param1,param2,param3,locp)); }
\r
578 /* riconoscimento token da input */
\r
579 int yylex(YYSTYPE *lvalp,YYLTYPE *llocp,void *p)
\r
582 char bufToken[256];
\r
583 char bufString[256];
\r
586 /* riconoscimento di source:linea,colonna */
\r
587 fscanf(stdin,"%s%s%s\n",bufLine,bufToken,bufString,SEP);
\r
589 if(!strcmp(bufToken,"ERR"))
\r
591 printf("%s\t%s%c",bufLine,bufString,SEP);
\r
595 for(tmp1=bufLine;*tmp1!=':';tmp1++);
\r
598 for(tmp2=tmp1+1;*tmp2!=',';tmp2++);
\r
601 llocp->first_line=llocp->last_line=atoi(tmp1+1);
\r
602 llocp->first_column=llocp->last_column=atoi(tmp2+1);
\r
604 if(!(llocp->source=(char *) myMalloc(strlen(bufLine)+1)))
\r
606 printf("[%s:%d] ParsError:OutOfMemory%c",__FILE__,__LINE__,SEP);
\r
611 strcpy(llocp->source,bufLine);
\r
617 if(!strcmp(bufToken,"OK"))
\r
619 root.source=llocp->source;
\r
620 root.fileLine=llocp->first_line;
\r
621 root.fileRow=llocp->first_column;
\r
623 return yylex(lvalp,llocp,p);
\r
625 else if(!strcmp(bufToken,"EOF"))
\r
628 /* categoria keyword */
\r
629 if(!strcmp(bufToken,"KEW"))
\r
631 if(!strcmp(bufString,"struct"))
\r
632 { return(Keyword_STRUCT); }
\r
633 else if(!strcmp(bufString,"array"))
\r
634 { return(Keyword_ARRAY); }
\r
635 else if(!strcmp(bufString,"of"))
\r
636 { return(Keyword_OF); }
\r
637 else if(!strcmp(bufString,"if"))
\r
638 { return(Keyword_IF); }
\r
639 else if(!strcmp(bufString,"elsif"))
\r
640 { return(Keyword_ELSIF); }
\r
641 else if(!strcmp(bufString,"else"))
\r
642 { return(Keyword_ELSE); }
\r
643 else if(!strcmp(bufString,"while"))
\r
644 { return(Keyword_WHILE); }
\r
645 else if(!strcmp(bufString,"const"))
\r
646 { return(Keyword_CONST); }
\r
647 else if(!strcmp(bufString,"b2w"))
\r
648 { return(Keyword_B2W); }
\r
649 else if(!strcmp(bufString,"b2dw"))
\r
650 { return(Keyword_B2DW); }
\r
651 else if(!strcmp(bufString,"w2b"))
\r
652 { return(Keyword_W2B); }
\r
653 else if(!strcmp(bufString,"w2dw"))
\r
654 { return(Keyword_W2DW); }
\r
655 else if(!strcmp(bufString,"dw2b"))
\r
656 { return(Keyword_DW2B); }
\r
657 else if(!strcmp(bufString,"dw2w"))
\r
658 { return(Keyword_DW2W); }
\r
661 printf("%s\tParsError:UnknownKeywordToken(%s)%c",bufLine,bufString,SEP);
\r
665 /* categoria tipo nativo */
\r
666 else if(!strcmp(bufToken,"TYP"))
\r
668 if(!strcmp(bufString,"dword"))
\r
669 { return(Type_DWORD); }
\r
670 else if(!strcmp(bufString,"word"))
\r
671 { return(Type_WORD); }
\r
672 else if(!strcmp(bufString,"byte"))
\r
673 { return(Type_BYTE); }
\r
676 printf("%s\tParsError:UnknownTypeToken(%s)%c",bufLine,bufString,SEP);
\r
680 /* categoria parentesi */
\r
681 else if(!strcmp(bufToken,"BRK"))
\r
683 if(!strcmp(bufString,"{"))
\r
684 { return(OpenBracket_BODY); }
\r
685 else if(!strcmp(bufString,"}"))
\r
686 { return(CloseBracket_BODY); }
\r
687 else if(!strcmp(bufString,"["))
\r
688 { return(OpenBracket_SQUARE); }
\r
689 else if(!strcmp(bufString,"]"))
\r
690 { return(CloseBracket_SQUARE); }
\r
691 else if(!strcmp(bufString,"("))
\r
692 { return(OpenBracket_ROUND); }
\r
693 else if(!strcmp(bufString,")"))
\r
694 { return(CloseBracket_ROUND); }
\r
697 printf("%s\tParsError:UnknownBracketToken(%s)%c",bufLine,bufString,SEP);
\r
701 /* categoria operatore unario */
\r
702 else if(!strcmp(bufToken,"MOP"))
\r
704 if(!strcmp(bufString,"!"))
\r
705 { return(UnaryOperator_NOT); }
\r
706 else if(!strcmp(bufString,"~"))
\r
707 { return(UnaryOperator_COM); }
\r
710 printf("%s\tParsError:UnknownUnaryOperatorToken(%s)%c",bufLine,bufString,SEP);
\r
714 /* categoria operatore duale */
\r
715 else if(!strcmp(bufToken,"DOP"))
\r
717 if(!strcmp(bufString,"&"))
\r
718 { return(DualOperator_AND); }
\r
719 else if(!strcmp(bufString,"|"))
\r
720 { return(DualOperator_OR); }
\r
721 else if(!strcmp(bufString,"^"))
\r
722 { return(DualOperator_XOR); }
\r
723 else if(!strcmp(bufString,"+"))
\r
724 { return(DualOperator_ADD); }
\r
725 else if(!strcmp(bufString,"-"))
\r
726 { return(DualOperator_SUB); }
\r
727 else if(!strcmp(bufString,"*"))
\r
728 { return(DualOperator_MUL); }
\r
729 else if(!strcmp(bufString,"/"))
\r
730 { return(DualOperator_DIV); }
\r
731 else if(!strcmp(bufString,"!="))
\r
732 { return(DualOperator_NEQ); }
\r
733 else if(!strcmp(bufString,"=="))
\r
734 { return(DualOperator_EQ); }
\r
735 else if(!strcmp(bufString,"<"))
\r
736 { return(DualOperator_LT); }
\r
737 else if(!strcmp(bufString,">"))
\r
738 { return(DualOperator_GT); }
\r
739 else if(!strcmp(bufString,"<="))
\r
740 { return(DualOperator_LTE); }
\r
741 else if(!strcmp(bufString,">="))
\r
742 { return(DualOperator_GTE); }
\r
743 else if(!strcmp(bufString,">>"))
\r
744 { return(DualOperator_SHR); }
\r
745 else if(!strcmp(bufString,"<<"))
\r
746 { return(DualOperator_SHL); }
\r
747 else if(!strcmp(bufString,"="))
\r
748 { return(DualOperator_ASG); }
\r
751 printf("%s\tParsError:UnknownDualOperatorToken(%s)%c",bufLine,bufString,SEP);
\r
755 /* categoria separatore */
\r
756 else if(!strcmp(bufToken,"SEP"))
\r
758 if(!strcmp(bufString,";"))
\r
759 { return(Separator_COLUMN); }
\r
760 else if(!strcmp(bufString,"."))
\r
761 { return(Separator_SELECT); }
\r
762 else if(!strcmp(bufString,","))
\r
763 { return(Separator_COMMA); }
\r
766 printf("%s\tParsError:UnknownSeparatorToken(%s)%c",bufLine,bufString,SEP);
\r
770 /* categoria dword */
\r
771 else if(!strcmp(bufToken,"W32"))
\r
773 unsigned long int tmpI;
\r
775 if(sscanf(bufString,"0x%lx",&tmpI)==1)
\r
777 *lvalp=treeDwordAlloc((_DWORD_) (tmpI&0xFFFFFFFF),llocp);
\r
778 return(Value_DWORD);
\r
782 printf("%s\tParsError:UnknownIntToken(%s)%c",bufLine,bufString,SEP);
\r
786 /* categoria word */
\r
787 else if(!strcmp(bufToken,"W16"))
\r
789 unsigned long int tmpI;
\r
791 if(sscanf(bufString,"0x%lx",&tmpI)==1)
\r
793 *lvalp=treeWordAlloc((_WORD_) (tmpI&0xFFFF),llocp);
\r
794 return(Value_WORD);
\r
798 printf("%s\tParsError:UnknownIntToken(%s)%c",bufLine,bufString,SEP);
\r
802 /* categoria byte */
\r
803 else if(!strcmp(bufToken,"BY8"))
\r
805 unsigned long int tmpI;
\r
807 if(sscanf(bufString,"0x%lx",&tmpI)==1)
\r
809 *lvalp=treeByteAlloc((_BYTE_) (tmpI&0xFF),llocp);
\r
810 return(Value_BYTE);
\r
814 printf("%s\tParsError:UnknownIntToken(%s)%c",bufLine,bufString,SEP);
\r
818 /* categoria numero intero */
\r
819 else if(!strcmp(bufToken,"INU"))
\r
821 unsigned long int tmpI;
\r
823 if(sscanf(bufString,"%lu",&tmpI)==1)
\r
825 *lvalp=treeInumAlloc(tmpI,llocp);
\r
826 return(Value_INUM);
\r
830 printf("%s\tParsError:UnknownIntToken(%s)%c",bufLine,bufString,SEP);
\r
834 /* categoria ID == stringa */
\r
835 else if(!strcmp(bufToken,"IID"))
\r
839 if(!(tmpS=(char *) myMalloc(strlen(bufString)+1)))
\r
841 printf("[%s:%d] ParsError:OutOfMemory%c",__FILE__,__LINE__,SEP);
\r
846 strcpy(tmpS,bufString);
\r
848 *lvalp=treeStringAlloc(tmpS,llocp);
\r
849 return(Value_STRING);
\r
853 printf("%s\tParsError:UnknownToken(%s)%c",bufLine,bufString,SEP);
\r
858 void usage(char *name)
\r
860 printf("\nC Parser - Cosimo Oliboni\n\n");
\r
861 printf("\"%s\" parsing da stdin\n\n",name);
\r
866 void prettyPrintString(char *str)
\r
872 printf("ch_%c",*str);
\r
883 void prettyPrintByte(_BYTE_ num)
\r
885 printf("(\\langle x%1X,x%1X \\rangle)",(unsigned int) (num>>4),(unsigned int) (num&0xF));
\r
888 void prettyPrintWord(_WORD_ num)
\r
890 printf("(\\langle \\langle x%1X,x%1X \\rangle : \\langle x%1X,x%1X \\rangle \\rangle)",\
\r
891 (unsigned int) (num>>12),(unsigned int) ((num>>8)&0xF),\
\r
892 (unsigned int) ((num>>4)&0xF),(unsigned int) (num&0xF));
\r
895 void prettyPrintDword(_DWORD_ num)
\r
897 printf("(\\langle \\langle \\langle x%1X,x%1X \\rangle : \\langle x%1X,x%1X \\rangle \\rangle . \\langle \\langle x%1X,x%1X \\rangle : \\langle x%1X,x%1X \\rangle \\rangle \\rangle)",\
\r
898 (unsigned int) (num>>28),(unsigned int) ((num>>24)&0xF),\
\r
899 (unsigned int) ((num>>20)&0xF),(unsigned int) ((num>>16)&0xF),\
\r
900 (unsigned int) ((num>>12)&0xF),(unsigned int) ((num>>8)&0xF),\
\r
901 (unsigned int) ((num>>4)&0xF),(unsigned int) (num&0xF));
\r
904 void prettyPrintIndent(int indent)
\r
908 for(index=0;index<indent;index++)
\r
912 void prettyPrintInum(unsigned long int num)
\r
917 { printf("%lu\n",num); }
\r
920 void prettyPrintInit(valueLeaf *cur,int indent)
\r
922 if(cur->id==E_VALUE_BYTE)
\r
923 { prettyPrintIndent(indent); printf("(PREAST_INIT_VAL_BYTE8 "); prettyPrintByte(cur->byteValue); printf(")\n"); }
\r
924 else if(cur->id==E_VALUE_WORD)
\r
925 { prettyPrintIndent(indent); printf("(PREAST_INIT_VAL_WORD16 "); prettyPrintWord(cur->wordValue); printf(")\n"); }
\r
926 else if(cur->id==E_VALUE_DWORD)
\r
927 { prettyPrintIndent(indent); printf("(PREAST_INIT_VAL_WORD32 "); prettyPrintDword(cur->dwordValue); printf(")\n"); }
\r
928 else if(cur->id==E_VALUE_ARRAY)
\r
930 valueLeaf *tmp=cur->param1;
\r
932 prettyPrintIndent(indent); printf("(PREAST_INIT_VAL_ARRAY\n");
\r
934 prettyPrintIndent(indent+1); printf("(\\laquo\n");
\r
936 { prettyPrintIndent(indent+2); printf("£\n"); }
\r
939 prettyPrintInit(tmp,indent+2);
\r
943 if(tmp->next->next)
\r
944 { prettyPrintIndent(indent+2); printf(";\n"); }
\r
946 { prettyPrintIndent(indent+2); printf("£\n"); }
\r
951 prettyPrintIndent(indent+1); printf("\\raquo)\n");
\r
953 prettyPrintIndent(indent); printf(")\n");
\r
955 else if(cur->id==E_VALUE_STRUCT)
\r
957 valueLeaf *tmp=cur->param1;
\r
959 prettyPrintIndent(indent); printf("(PREAST_INIT_VAL_STRUCT\n");
\r
961 prettyPrintIndent(indent+1); printf("(\\laquo\n");
\r
963 { prettyPrintIndent(indent+2); printf("£\n"); }
\r
966 prettyPrintInit(tmp,indent+2);
\r
970 if(tmp->next->next)
\r
971 { prettyPrintIndent(indent+2); printf(";\n"); }
\r
973 { prettyPrintIndent(indent+2); printf("£\n"); }
\r
978 prettyPrintIndent(indent+1); printf("\\raquo)\n");
\r
980 prettyPrintIndent(indent); printf(")\n");
\r
984 void prettyPrintBody(valueLeaf *cur,int indent)
\r
987 { prettyPrintIndent(indent); printf("(PREAST_NO_DECL [])\n"); }
\r
988 else if((cur->id==E_DECL_CONST)||(cur->id==E_DECL_VAR))
\r
989 { prettyPrint(cur,indent); }
\r
992 valueLeaf *tmp=cur;
\r
994 prettyPrintIndent(indent); printf("(PREAST_NO_DECL\n");
\r
996 prettyPrintIndent(indent+1); printf("[\n");
\r
999 prettyPrint(tmp,indent+2);
\r
1002 { prettyPrintIndent(indent+2); printf(";\n"); }
\r
1006 prettyPrintIndent(indent+1); printf("]\n");
\r
1008 prettyPrintIndent(indent); printf(")\n");
\r
1013 void prettyPrint(valueLeaf *cur,int indent)
\r
1016 if(cur->id==E_VALUE_STRING)
\r
1017 { prettyPrintIndent(indent); prettyPrintString(cur->stringValue); printf("\n"); }
\r
1018 else if(cur->id==E_VALUE_INUM)
\r
1019 { prettyPrintIndent(indent); prettyPrintInum(cur->inumValue); }
\r
1022 else if(cur->id==E_TYPE_BYTE)
\r
1023 { prettyPrintIndent(indent); printf("(AST_TYPE_BASE AST_BASE_TYPE_BYTE8)\n"); }
\r
1024 else if(cur->id==E_TYPE_WORD)
\r
1025 { prettyPrintIndent(indent); printf("(AST_TYPE_BASE AST_BASE_TYPE_WORD16)\n"); }
\r
1026 else if(cur->id==E_TYPE_DWORD)
\r
1027 { prettyPrintIndent(indent); printf("(AST_TYPE_BASE AST_BASE_TYPE_WORD32)\n"); }
\r
1028 else if(cur->id==E_TYPE_ARRAY)
\r
1030 prettyPrintIndent(indent); printf("(AST_TYPE_ARRAY\n");
\r
1031 prettyPrint(cur->param2,indent+1); //type
\r
1032 prettyPrint(cur->param1,indent+1); //size
\r
1033 prettyPrintIndent(indent); printf(")\n");
\r
1035 else if(cur->id==E_TYPE_STRUCT)
\r
1037 valueLeaf *tmp=cur->param1;
\r
1039 prettyPrintIndent(indent); printf("(AST_TYPE_STRUCT\n");
\r
1041 prettyPrintIndent(indent+1); printf("(\\laquo\n");
\r
1043 { prettyPrintIndent(indent+2); printf("£\n"); }
\r
1046 prettyPrint(tmp,indent+2);
\r
1050 if(tmp->next->next)
\r
1051 { prettyPrintIndent(indent+2); printf(";\n"); }
\r
1053 { prettyPrintIndent(indent+2); printf("£\n"); }
\r
1058 prettyPrintIndent(indent+1); printf("\\raquo)\n");
\r
1060 prettyPrintIndent(indent); printf(")\n");
\r
1063 /* ** valori come espressioni ** */
\r
1064 else if(cur->id==E_VALUE_BYTE)
\r
1065 { prettyPrintIndent(indent); printf("(PREAST_EXPR_BYTE8 "); prettyPrintByte(cur->byteValue); printf(")\n"); }
\r
1066 else if(cur->id==E_VALUE_WORD)
\r
1067 { prettyPrintIndent(indent); printf("(PREAST_EXPR_WORD16 "); prettyPrintWord(cur->wordValue); printf(")\n"); }
\r
1068 else if(cur->id==E_VALUE_DWORD)
\r
1069 { prettyPrintIndent(indent); printf("(PREAST_EXPR_WORD32 "); prettyPrintDword(cur->dwordValue); printf(")\n"); }
\r
1071 /* ** variabili */
\r
1072 else if(cur->id==E_VAR_ROOT)
\r
1073 { prettyPrintIndent(indent); printf("(PREAST_VAR_ID "); prettyPrintString(cur->param1->stringValue); printf(")\n"); }
\r
1074 else if(cur->id==E_VAR_STRUCT)
\r
1076 prettyPrintIndent(indent); printf("(PREAST_VAR_STRUCT\n");
\r
1077 prettyPrint(cur->next,indent+1);
\r
1078 prettyPrint(cur->param1,indent+1);
\r
1079 prettyPrintIndent(indent); printf(")\n");
\r
1081 else if(cur->id==E_VAR_ARRAY)
\r
1083 prettyPrintIndent(indent); printf("(PREAST_VAR_ARRAY\n");
\r
1084 prettyPrint(cur->next,indent+1);
\r
1085 prettyPrint(cur->param1,indent+1);
\r
1086 prettyPrintIndent(indent); printf(")\n");
\r
1089 /* ** espressioni ** */
\r
1090 else if(cur->id==E_EXPR_VAR)
\r
1092 prettyPrintIndent(indent); printf("(PREAST_EXPR_ID\n");
\r
1093 prettyPrint(cur->param1,indent+1);
\r
1094 prettyPrintIndent(indent); printf(")\n");
\r
1096 else if(cur->id==E_EXPR_NOT)
\r
1098 prettyPrintIndent(indent); printf("(PREAST_EXPR_NOT\n");
\r
1099 prettyPrint(cur->param1,indent+1);
\r
1100 prettyPrintIndent(indent); printf(")\n");
\r
1102 else if(cur->id==E_EXPR_COM)
\r
1104 prettyPrintIndent(indent); printf("(PREAST_EXPR_COM\n");
\r
1105 prettyPrint(cur->param1,indent+1);
\r
1106 prettyPrintIndent(indent); printf(")\n");
\r
1108 else if(cur->id==E_EXPR_NEG)
\r
1110 prettyPrintIndent(indent); printf("(PREAST_EXPR_NEG\n");
\r
1111 prettyPrint(cur->param1,indent+1);
\r
1112 prettyPrintIndent(indent); printf(")\n");
\r
1114 else if(cur->id==E_EXPR_B2W)
\r
1116 prettyPrintIndent(indent); printf("(PREAST_EXPR_B8toW16\n");
\r
1117 prettyPrint(cur->param1,indent+1);
\r
1118 prettyPrintIndent(indent); printf(")\n");
\r
1120 else if(cur->id==E_EXPR_B2DW)
\r
1122 prettyPrintIndent(indent); printf("(PREAST_EXPR_B8toW32\n");
\r
1123 prettyPrint(cur->param1,indent+1);
\r
1124 prettyPrintIndent(indent); printf(")\n");
\r
1126 else if(cur->id==E_EXPR_W2B)
\r
1128 prettyPrintIndent(indent); printf("(PREAST_EXPR_W16toB8\n");
\r
1129 prettyPrint(cur->param1,indent+1);
\r
1130 prettyPrintIndent(indent); printf(")\n");
\r
1132 else if(cur->id==E_EXPR_W2DW)
\r
1134 prettyPrintIndent(indent); printf("(PREAST_EXPR_W16toW32\n");
\r
1135 prettyPrint(cur->param1,indent+1);
\r
1136 prettyPrintIndent(indent); printf(")\n");
\r
1138 else if(cur->id==E_EXPR_DW2B)
\r
1140 prettyPrintIndent(indent); printf("(PREAST_EXPR_W32toB8\n");
\r
1141 prettyPrint(cur->param1,indent+1);
\r
1142 prettyPrintIndent(indent); printf(")\n");
\r
1144 else if(cur->id==E_EXPR_DW2W)
\r
1146 prettyPrintIndent(indent); printf("(PREAST_EXPR_W32toW16\n");
\r
1147 prettyPrint(cur->param1,indent+1);
\r
1148 prettyPrintIndent(indent); printf(")\n");
\r
1150 else if(cur->id==E_EXPR_ADD)
\r
1152 prettyPrintIndent(indent); printf("(PREAST_EXPR_ADD\n");
\r
1153 prettyPrint(cur->param1,indent+1);
\r
1154 prettyPrint(cur->param2,indent+1);
\r
1155 prettyPrintIndent(indent); printf(")\n");
\r
1157 else if(cur->id==E_EXPR_SUB)
\r
1159 prettyPrintIndent(indent); printf("(PREAST_EXPR_SUB\n");
\r
1160 prettyPrint(cur->param1,indent+1);
\r
1161 prettyPrint(cur->param2,indent+1);
\r
1162 prettyPrintIndent(indent); printf(")\n");
\r
1164 else if(cur->id==E_EXPR_MUL)
\r
1166 prettyPrintIndent(indent); printf("(PREAST_EXPR_MUL\n");
\r
1167 prettyPrint(cur->param1,indent+1);
\r
1168 prettyPrint(cur->param2,indent+1);
\r
1169 prettyPrintIndent(indent); printf(")\n");
\r
1171 else if(cur->id==E_EXPR_DIV)
\r
1173 prettyPrintIndent(indent); printf("(PREAST_EXPR_DIV\n");
\r
1174 prettyPrint(cur->param1,indent+1);
\r
1175 prettyPrint(cur->param2,indent+1);
\r
1176 prettyPrintIndent(indent); printf(")\n");
\r
1178 else if(cur->id==E_EXPR_SHL)
\r
1180 prettyPrintIndent(indent); printf("(PREAST_EXPR_SHL\n");
\r
1181 prettyPrint(cur->param1,indent+1);
\r
1182 prettyPrint(cur->param2,indent+1);
\r
1183 prettyPrintIndent(indent); printf(")\n");
\r
1185 else if(cur->id==E_EXPR_SHR)
\r
1187 prettyPrintIndent(indent); printf("(PREAST_EXPR_SHR\n");
\r
1188 prettyPrint(cur->param1,indent+1);
\r
1189 prettyPrint(cur->param2,indent+1);
\r
1190 prettyPrintIndent(indent); printf(")\n");
\r
1192 else if(cur->id==E_EXPR_AND)
\r
1194 prettyPrintIndent(indent); printf("(PREAST_EXPR_AND\n");
\r
1195 prettyPrint(cur->param1,indent+1);
\r
1196 prettyPrint(cur->param2,indent+1);
\r
1197 prettyPrintIndent(indent); printf(")\n");
\r
1199 else if(cur->id==E_EXPR_OR)
\r
1201 prettyPrintIndent(indent); printf("(PREAST_EXPR_OR\n");
\r
1202 prettyPrint(cur->param1,indent+1);
\r
1203 prettyPrint(cur->param2,indent+1);
\r
1204 prettyPrintIndent(indent); printf(")\n");
\r
1206 else if(cur->id==E_EXPR_XOR)
\r
1208 prettyPrintIndent(indent); printf("(PREAST_EXPR_XOR\n");
\r
1209 prettyPrint(cur->param1,indent+1);
\r
1210 prettyPrint(cur->param2,indent+1);
\r
1211 prettyPrintIndent(indent); printf(")\n");
\r
1213 else if(cur->id==E_EXPR_LT)
\r
1215 prettyPrintIndent(indent); printf("(PREAST_EXPR_LT\n");
\r
1216 prettyPrint(cur->param1,indent+1);
\r
1217 prettyPrint(cur->param2,indent+1);
\r
1218 prettyPrintIndent(indent); printf(")\n");
\r
1220 else if(cur->id==E_EXPR_LTE)
\r
1222 prettyPrintIndent(indent); printf("(PREAST_EXPR_LTE\n");
\r
1223 prettyPrint(cur->param1,indent+1);
\r
1224 prettyPrint(cur->param2,indent+1);
\r
1225 prettyPrintIndent(indent); printf(")\n");
\r
1227 else if(cur->id==E_EXPR_GT)
\r
1229 prettyPrintIndent(indent); printf("(PREAST_EXPR_GT\n");
\r
1230 prettyPrint(cur->param1,indent+1);
\r
1231 prettyPrint(cur->param2,indent+1);
\r
1232 prettyPrintIndent(indent); printf(")\n");
\r
1234 else if(cur->id==E_EXPR_GTE)
\r
1236 prettyPrintIndent(indent); printf("(PREAST_EXPR_GTE\n");
\r
1237 prettyPrint(cur->param1,indent+1);
\r
1238 prettyPrint(cur->param2,indent+1);
\r
1239 prettyPrintIndent(indent); printf(")\n");
\r
1241 else if(cur->id==E_EXPR_EQ)
\r
1243 prettyPrintIndent(indent); printf("(PREAST_EXPR_EQ\n");
\r
1244 prettyPrint(cur->param1,indent+1);
\r
1245 prettyPrint(cur->param2,indent+1);
\r
1246 prettyPrintIndent(indent); printf(")\n");
\r
1248 else if(cur->id==E_EXPR_NEQ)
\r
1250 prettyPrintIndent(indent); printf("(PREAST_EXPR_NEQ\n");
\r
1251 prettyPrint(cur->param1,indent+1);
\r
1252 prettyPrint(cur->param2,indent+1);
\r
1253 prettyPrintIndent(indent); printf(")\n");
\r
1256 /* ** dichiarazioni ** */
\r
1257 else if(cur->id==E_DECL_CONST)
\r
1259 prettyPrintIndent(indent); printf("(PREAST_CONST_DECL\n");
\r
1260 prettyPrint(cur->param2,indent+1); //string
\r
1261 prettyPrint(cur->param1,indent+1); //type
\r
1263 if((cur->param3->id==E_VAR_ROOT)||(cur->param3->id==E_VAR_STRUCT)||(cur->param3->id==E_VAR_ARRAY))
\r
1265 prettyPrintIndent(indent+1); printf("(PREAST_INIT_VAR\n");
\r
1266 prettyPrint(cur->param3,indent+2); //init
\r
1267 prettyPrintIndent(indent+1); printf(")\n");
\r
1271 prettyPrintIndent(indent+1); printf("(PREAST_INIT_VAL\n");
\r
1272 prettyPrintInit(cur->param3,indent+2); //init
\r
1273 prettyPrintIndent(indent+1); printf(")\n");
\r
1278 if((cur->next->id==E_DECL_CONST)||(cur->next->id==E_DECL_VAR))
\r
1279 { prettyPrint(cur->next,indent+1); } //next decl
\r
1282 valueLeaf *tmp=cur->next;
\r
1284 prettyPrintIndent(indent+1); printf("(PREAST_NO_DECL\n");
\r
1286 prettyPrintIndent(indent+2); printf("[\n");
\r
1289 prettyPrint(tmp,indent+3);
\r
1292 { prettyPrintIndent(indent+3); printf(";\n"); }
\r
1296 prettyPrintIndent(indent+2); printf("]\n");
\r
1298 prettyPrintIndent(indent+1); printf(")\n");
\r
1302 { prettyPrintIndent(indent+1); printf("(PREAST_NO_DECL [])\n"); }
\r
1305 prettyPrintIndent(indent); printf(")\n");
\r
1307 else if(cur->id==E_DECL_VAR)
\r
1309 prettyPrintIndent(indent); printf("(PREAST_VAR_DECL\n");
\r
1310 prettyPrint(cur->param2,indent+1); //string
\r
1311 prettyPrint(cur->param1,indent+1); //type
\r
1315 prettyPrintIndent(indent+1); printf("(Some ?\n");
\r
1317 if((cur->param3->id==E_VAR_ROOT)||(cur->param3->id==E_VAR_STRUCT)||(cur->param3->id==E_VAR_ARRAY))
\r
1319 prettyPrintIndent(indent+2); printf("(PREAST_INIT_VAR\n");
\r
1320 prettyPrint(cur->param3,indent+3); //init
\r
1321 prettyPrintIndent(indent+2); printf(")\n");
\r
1325 prettyPrintIndent(indent+2); printf("(PREAST_INIT_VAL\n");
\r
1326 prettyPrintInit(cur->param3,indent+3); //init
\r
1327 prettyPrintIndent(indent+2); printf(")\n");
\r
1330 prettyPrintIndent(indent+1); printf(")\n");
\r
1333 { prettyPrintIndent(indent+1); printf("(None ?)\n"); }
\r
1337 if((cur->next->id==E_DECL_CONST)||(cur->next->id==E_DECL_VAR))
\r
1338 { prettyPrint(cur->next,indent+1); } //next decl
\r
1341 valueLeaf *tmp=cur->next;
\r
1343 prettyPrintIndent(indent+1); printf("(PREAST_NO_DECL\n");
\r
1345 prettyPrintIndent(indent+2); printf("[\n");
\r
1348 prettyPrint(tmp,indent+3);
\r
1351 { prettyPrintIndent(indent+3); printf(";\n"); }
\r
1355 prettyPrintIndent(indent+2); printf("]\n");
\r
1357 prettyPrintIndent(indent+1); printf(")\n");
\r
1361 { prettyPrintIndent(indent+1); printf("(PREAST_NO_DECL [])\n"); }
\r
1364 prettyPrintIndent(indent); printf(")\n");
\r
1367 /* ** statement ** */
\r
1368 else if(cur->id==E_STM_ASG)
\r
1370 prettyPrintIndent(indent); printf("(PREAST_STM_ASG\n");
\r
1371 prettyPrint(cur->param1,indent+1);
\r
1372 prettyPrint(cur->param2,indent+1);
\r
1373 prettyPrintIndent(indent); printf(")\n");
\r
1375 else if(cur->id==E_STM_WHILE)
\r
1377 prettyPrintIndent(indent); printf("(PREAST_STM_WHILE\n");
\r
1378 prettyPrint(cur->param1,indent+1);
\r
1379 prettyPrintBody(cur->param2,indent+1);
\r
1380 prettyPrintIndent(indent); printf(")\n");
\r
1382 else if(cur->id==E_STM_IF)
\r
1384 valueLeaf *tmp=cur->param1;
\r
1386 prettyPrintIndent(indent); printf("(PREAST_STM_IF\n");
\r
1388 prettyPrintIndent(indent+1); printf("(\\laquo\n");
\r
1390 { prettyPrintIndent(indent+2); printf("£\n"); }
\r
1393 prettyPrintIndent(indent+2); printf("(pair ??\n");
\r
1394 prettyPrint(tmp->param1,indent+3);
\r
1395 prettyPrintBody(tmp->param2,indent+3);
\r
1396 prettyPrintIndent(indent+2); printf(")\n");
\r
1400 if(tmp->next->next)
\r
1401 { prettyPrintIndent(indent+2); printf(";\n"); }
\r
1403 { prettyPrintIndent(indent+2); printf("£\n"); }
\r
1408 prettyPrintIndent(indent+1); printf("\\raquo)\n");
\r
1410 // equivalenza: Some ? (PREAST_NO_DECL []) = None ?
\r
1413 prettyPrintIndent(indent+1); printf("(Some ?\n");
\r
1414 prettyPrintBody(cur->param2,indent+2); //body
\r
1415 prettyPrintIndent(indent+1); printf(")\n");
\r
1418 { prettyPrintIndent(indent+1); printf("(None ?)\n"); }
\r
1420 prettyPrintIndent(indent); printf(")\n");
\r
1424 int main(int argc,char **argv)
\r
1428 /* ignora eventuali errori di parametri */
\r
1430 { usage(argv[0]); }
\r
1432 ret=yyparse(NULL);
\r
1434 if((!ret)&&(!numErr))
\r
1436 printf("definition parsingResult \\def\n");
\r
1437 printf(" (PREAST_ROOT\n");
\r
1438 prettyPrint(&root,2);
\r