diff --git a/Lex_Yacc/ProgC b/Lex_Yacc/ProgC new file mode 100644 index 0000000..3b4e2e8 --- /dev/null +++ b/Lex_Yacc/ProgC @@ -0,0 +1,4 @@ +int main(int a, int b) +{ + int c; +} diff --git a/Lex_Yacc/a.exe b/Lex_Yacc/a.exe new file mode 100755 index 0000000..88f7a0d Binary files /dev/null and b/Lex_Yacc/a.exe differ diff --git a/Lex_Yacc/a.out b/Lex_Yacc/a.out deleted file mode 100755 index 5bacdb8..0000000 Binary files a/Lex_Yacc/a.out and /dev/null differ diff --git a/Lex_Yacc/al.lex b/Lex_Yacc/al.lex index 7d6de8b..8966d3a 100644 --- a/Lex_Yacc/al.lex +++ b/Lex_Yacc/al.lex @@ -1,6 +1,13 @@ %{ #include "as.tab.h" int yywrap(void){return 1;} +void +yyerror (char const *s) +{ + + fprintf (stderr, "%s\n", s); +} + %} %% diff --git a/Lex_Yacc/as.output b/Lex_Yacc/as.output index fabc4db..7c5fb20 100644 --- a/Lex_Yacc/as.output +++ b/Lex_Yacc/as.output @@ -1,6 +1,6 @@ Terminaux inutilisés dans la grammaire - tERROR + tERROR Grammaire @@ -12,7 +12,7 @@ Grammaire 2 Params: %empty 3 | Param SuiteParams - 4 Param: tINT tID + 4 Param: DeclType tID 5 SuiteParams: tCOMA Param SuiteParams 6 | %empty @@ -59,93 +59,126 @@ Grammaire 37 | E tLT E 38 | tNOT E - 39 Decl: tINT tID SuiteDecl FinDeclaration - 40 | tCONST tINT tID SuiteDecl tEQ E tPV + 39 DeclType: tINT - 41 SuiteDecl: tCOMA tID SuiteDecl - 42 | %empty + 40 Decl: DeclType SuiteDecl FinDecl + 41 | tCONST DeclType SuiteDeclConst FinDeclConst - 43 FinDeclaration: tEQ E tPV - 44 | tPV + 42 SuiteDecl: tID + 43 | tID tEQ E - 45 Invocation: tPRINTF tOBRACE tID tCBRACE + 44 FinDecl: tPV + 45 | tCOMA SuiteDecl FinDecl + + 46 SuiteDeclConst: tID tEQ E + + 47 FinDeclConst: tPV + 48 | tCOMA SuiteDeclConst FinDeclConst + + 49 Invocation: tPRINTF tOBRACE tID tCBRACE Terminaux, suivis des règles où ils apparaissent -$end (0) 0 -error (256) -tMAIN (258) 1 -tOBRACKET (259) 7 -tCBRACKET (260) 7 -tOBRACE (261) 1 15 19 33 45 -tCBRACE (262) 1 15 19 33 45 -tINT (263) 1 4 39 40 -tCONST (264) 40 -tPV (265) 12 24 40 43 44 -tCOMA (266) 5 41 -tMUL (267) 28 -tDIV (268) 29 -tADD (269) 31 -tSUB (270) 30 34 -tEQ (271) 24 40 43 -tNB (272) 25 -tNBEXP (273) 26 -tID (274) 4 24 27 39 40 41 45 -tPRINTF (275) 45 -tERROR (276) -tIF (277) 15 -tWHILE (278) 19 -tELSE (279) 16 17 -tLT (280) 37 -tGT (281) 36 -tEQCOND (282) 35 -tAND (283) 22 -tOR (284) 23 -tNOT (285) 38 + $end (0) 0 + error (256) + tMAIN (258) 1 + tOBRACKET (259) 7 + tCBRACKET (260) 7 + tOBRACE (261) 1 15 19 33 49 + tCBRACE (262) 1 15 19 33 49 + tINT (263) 1 39 + tCONST (264) 41 + tPV (265) 12 24 44 47 + tCOMA (266) 5 45 48 + tMUL (267) 28 + tDIV (268) 29 + tADD (269) 31 + tSUB (270) 30 34 + tEQ (271) 24 43 46 + tNB (272) 25 + tNBEXP (273) 26 + tID (274) 4 24 27 42 43 46 49 + tPRINTF (275) 49 + tERROR (276) + tIF (277) 15 + tWHILE (278) 19 + tELSE (279) 16 17 + tLT (280) 37 + tGT (281) 36 + tEQCOND (282) 35 + tAND (283) 22 + tOR (284) 23 + tNOT (285) 38 Non-terminaux, suivis des règles où ils apparaissent -$accept (31) - à gauche: 0 -Main (32) - à gauche: 1, à droite: 0 -Params (33) - à gauche: 2 3, à droite: 1 -Param (34) - à gauche: 4, à droite: 3 5 -SuiteParams (35) - à gauche: 5 6, à droite: 3 5 -Body (36) - à gauche: 7, à droite: 1 15 17 19 -Instructions (37) - à gauche: 8 9, à droite: 7 8 -Instruction (38) - à gauche: 10 11 12 13 14, à droite: 8 -If (39) - à gauche: 15, à droite: 13 16 -Else (40) - à gauche: 16 17 18, à droite: 15 -While (41) - à gauche: 19, à droite: 14 -Cond (42) - à gauche: 20, à droite: 15 19 -SuiteCond (43) - à gauche: 21 22 23, à droite: 20 22 23 -Aff (44) - à gauche: 24, à droite: 10 -E (45) - à gauche: 25 26 27 28 29 30 31 32 33 34 35 36 37 38, à droite: - 20 22 23 24 28 29 30 31 33 34 35 36 37 38 40 43 -Decl (46) - à gauche: 39 40, à droite: 11 -SuiteDecl (47) - à gauche: 41 42, à droite: 39 40 41 -FinDeclaration (48) - à gauche: 43 44, à droite: 39 -Invocation (49) - à gauche: 45, à droite: 12 32 + $accept (31) + à gauche: 0 + Main (32) + à gauche: 1 + à droite: 0 + Params (33) + à gauche: 2 3 + à droite: 1 + Param (34) + à gauche: 4 + à droite: 3 5 + SuiteParams (35) + à gauche: 5 6 + à droite: 3 5 + Body (36) + à gauche: 7 + à droite: 1 15 17 19 + Instructions (37) + à gauche: 8 9 + à droite: 7 8 + Instruction (38) + à gauche: 10 11 12 13 14 + à droite: 8 + If (39) + à gauche: 15 + à droite: 13 16 + Else (40) + à gauche: 16 17 18 + à droite: 15 + While (41) + à gauche: 19 + à droite: 14 + Cond (42) + à gauche: 20 + à droite: 15 19 + SuiteCond (43) + à gauche: 21 22 23 + à droite: 20 22 23 + Aff (44) + à gauche: 24 + à droite: 10 + E (45) + à gauche: 25 26 27 28 29 30 31 32 33 34 35 36 37 38 + à droite: 20 22 23 24 28 29 30 31 33 34 35 36 37 38 43 46 + DeclType (46) + à gauche: 39 + à droite: 4 40 41 + Decl (47) + à gauche: 40 41 + à droite: 11 + SuiteDecl (48) + à gauche: 42 43 + à droite: 40 45 + FinDecl (49) + à gauche: 44 45 + à droite: 40 45 + SuiteDeclConst (50) + à gauche: 46 + à droite: 41 48 + FinDeclConst (51) + à gauche: 47 48 + à droite: 41 48 + Invocation (52) + à gauche: 49 + à droite: 12 32 État 0 @@ -193,15 +226,16 @@ Invocation (49) $défaut réduction par utilisation de la règle 2 (Params) - Params aller à l'état 7 - Param aller à l'état 8 + Params aller à l'état 7 + Param aller à l'état 8 + DeclType aller à l'état 9 État 6 - 4 Param: tINT . tID + 39 DeclType: tINT . - tID décalage et aller à l'état 9 + $défaut réduction par utilisation de la règle 39 (DeclType) État 7 @@ -224,18 +258,18 @@ Invocation (49) État 9 - 4 Param: tINT tID . + 4 Param: DeclType . tID - $défaut réduction par utilisation de la règle 4 (Param) + tID décalage et aller à l'état 13 État 10 1 Main: tINT tMAIN tOBRACE Params tCBRACE . Body - tOBRACKET décalage et aller à l'état 13 + tOBRACKET décalage et aller à l'état 14 - Body aller à l'état 14 + Body aller à l'état 15 État 11 @@ -244,7 +278,8 @@ Invocation (49) tINT décalage et aller à l'état 6 - Param aller à l'état 15 + Param aller à l'état 16 + DeclType aller à l'état 9 État 12 @@ -256,9 +291,16 @@ Invocation (49) État 13 + 4 Param: DeclType tID . + + $défaut réduction par utilisation de la règle 4 (Param) + + +État 14 + 7 Body: tOBRACKET . Instructions tCBRACKET - tINT décalage et aller à l'état 16 + tINT décalage et aller à l'état 6 tCONST décalage et aller à l'état 17 tID décalage et aller à l'état 18 tPRINTF décalage et aller à l'état 19 @@ -272,18 +314,19 @@ Invocation (49) If aller à l'état 24 While aller à l'état 25 Aff aller à l'état 26 - Decl aller à l'état 27 - Invocation aller à l'état 28 + DeclType aller à l'état 27 + Decl aller à l'état 28 + Invocation aller à l'état 29 -État 14 +État 15 1 Main: tINT tMAIN tOBRACE Params tCBRACE Body . $défaut réduction par utilisation de la règle 1 (Main) -État 15 +État 16 5 SuiteParams: tCOMA Param . SuiteParams @@ -291,21 +334,16 @@ Invocation (49) $défaut réduction par utilisation de la règle 6 (SuiteParams) - SuiteParams aller à l'état 29 - - -État 16 - - 39 Decl: tINT . tID SuiteDecl FinDeclaration - - tID décalage et aller à l'état 30 + SuiteParams aller à l'état 30 État 17 - 40 Decl: tCONST . tINT tID SuiteDecl tEQ E tPV + 41 Decl: tCONST . DeclType SuiteDeclConst FinDeclConst - tINT décalage et aller à l'état 31 + tINT décalage et aller à l'état 6 + + DeclType aller à l'état 31 État 18 @@ -317,7 +355,7 @@ Invocation (49) État 19 - 45 Invocation: tPRINTF . tOBRACE tID tCBRACE + 49 Invocation: tPRINTF . tOBRACE tID tCBRACE tOBRACE décalage et aller à l'état 33 @@ -347,7 +385,7 @@ Invocation (49) 8 Instructions: Instruction . Instructions - tINT décalage et aller à l'état 16 + tINT décalage et aller à l'état 6 tCONST décalage et aller à l'état 17 tID décalage et aller à l'état 18 tPRINTF décalage et aller à l'état 19 @@ -361,8 +399,9 @@ Invocation (49) If aller à l'état 24 While aller à l'état 25 Aff aller à l'état 26 - Decl aller à l'état 27 - Invocation aller à l'état 28 + DeclType aller à l'état 27 + Decl aller à l'état 28 + Invocation aller à l'état 29 État 24 @@ -388,98 +427,98 @@ Invocation (49) État 27 + 40 Decl: DeclType . SuiteDecl FinDecl + + tID décalage et aller à l'état 38 + + SuiteDecl aller à l'état 39 + + +État 28 + 11 Instruction: Decl . $défaut réduction par utilisation de la règle 11 (Instruction) -État 28 +État 29 12 Instruction: Invocation . tPV - tPV décalage et aller à l'état 38 + tPV décalage et aller à l'état 40 -État 29 +État 30 5 SuiteParams: tCOMA Param SuiteParams . $défaut réduction par utilisation de la règle 5 (SuiteParams) -État 30 - - 39 Decl: tINT tID . SuiteDecl FinDeclaration - - tCOMA décalage et aller à l'état 39 - - $défaut réduction par utilisation de la règle 42 (SuiteDecl) - - SuiteDecl aller à l'état 40 - - État 31 - 40 Decl: tCONST tINT . tID SuiteDecl tEQ E tPV + 41 Decl: tCONST DeclType . SuiteDeclConst FinDeclConst tID décalage et aller à l'état 41 + SuiteDeclConst aller à l'état 42 + État 32 24 Aff: tID tEQ . E tPV - tOBRACE décalage et aller à l'état 42 - tSUB décalage et aller à l'état 43 - tNB décalage et aller à l'état 44 - tNBEXP décalage et aller à l'état 45 - tID décalage et aller à l'état 46 + tOBRACE décalage et aller à l'état 43 + tSUB décalage et aller à l'état 44 + tNB décalage et aller à l'état 45 + tNBEXP décalage et aller à l'état 46 + tID décalage et aller à l'état 47 tPRINTF décalage et aller à l'état 19 - tNOT décalage et aller à l'état 47 + tNOT décalage et aller à l'état 48 - E aller à l'état 48 - Invocation aller à l'état 49 + E aller à l'état 49 + Invocation aller à l'état 50 État 33 - 45 Invocation: tPRINTF tOBRACE . tID tCBRACE + 49 Invocation: tPRINTF tOBRACE . tID tCBRACE - tID décalage et aller à l'état 50 + tID décalage et aller à l'état 51 État 34 15 If: tIF tOBRACE . Cond tCBRACE Body Else - tOBRACE décalage et aller à l'état 42 - tSUB décalage et aller à l'état 43 - tNB décalage et aller à l'état 44 - tNBEXP décalage et aller à l'état 45 - tID décalage et aller à l'état 46 + tOBRACE décalage et aller à l'état 43 + tSUB décalage et aller à l'état 44 + tNB décalage et aller à l'état 45 + tNBEXP décalage et aller à l'état 46 + tID décalage et aller à l'état 47 tPRINTF décalage et aller à l'état 19 - tNOT décalage et aller à l'état 47 + tNOT décalage et aller à l'état 48 - Cond aller à l'état 51 - E aller à l'état 52 - Invocation aller à l'état 49 + Cond aller à l'état 52 + E aller à l'état 53 + Invocation aller à l'état 50 État 35 19 While: tWHILE tOBRACE . Cond tCBRACE Body - tOBRACE décalage et aller à l'état 42 - tSUB décalage et aller à l'état 43 - tNB décalage et aller à l'état 44 - tNBEXP décalage et aller à l'état 45 - tID décalage et aller à l'état 46 + tOBRACE décalage et aller à l'état 43 + tSUB décalage et aller à l'état 44 + tNB décalage et aller à l'état 45 + tNBEXP décalage et aller à l'état 46 + tID décalage et aller à l'état 47 tPRINTF décalage et aller à l'état 19 - tNOT décalage et aller à l'état 47 + tNOT décalage et aller à l'état 48 - Cond aller à l'état 53 - E aller à l'état 52 - Invocation aller à l'état 49 + Cond aller à l'état 54 + E aller à l'état 53 + Invocation aller à l'état 50 État 36 @@ -498,109 +537,118 @@ Invocation (49) État 38 + 42 SuiteDecl: tID . + 43 | tID . tEQ E + + tEQ décalage et aller à l'état 55 + + $défaut réduction par utilisation de la règle 42 (SuiteDecl) + + +État 39 + + 40 Decl: DeclType SuiteDecl . FinDecl + + tPV décalage et aller à l'état 56 + tCOMA décalage et aller à l'état 57 + + FinDecl aller à l'état 58 + + +État 40 + 12 Instruction: Invocation tPV . $défaut réduction par utilisation de la règle 12 (Instruction) -État 39 - - 41 SuiteDecl: tCOMA . tID SuiteDecl - - tID décalage et aller à l'état 54 - - -État 40 - - 39 Decl: tINT tID SuiteDecl . FinDeclaration - - tPV décalage et aller à l'état 55 - tEQ décalage et aller à l'état 56 - - FinDeclaration aller à l'état 57 - - État 41 - 40 Decl: tCONST tINT tID . SuiteDecl tEQ E tPV + 46 SuiteDeclConst: tID . tEQ E - tCOMA décalage et aller à l'état 39 - - $défaut réduction par utilisation de la règle 42 (SuiteDecl) - - SuiteDecl aller à l'état 58 + tEQ décalage et aller à l'état 59 État 42 - 33 E: tOBRACE . E tCBRACE + 41 Decl: tCONST DeclType SuiteDeclConst . FinDeclConst - tOBRACE décalage et aller à l'état 42 - tSUB décalage et aller à l'état 43 - tNB décalage et aller à l'état 44 - tNBEXP décalage et aller à l'état 45 - tID décalage et aller à l'état 46 - tPRINTF décalage et aller à l'état 19 - tNOT décalage et aller à l'état 47 + tPV décalage et aller à l'état 60 + tCOMA décalage et aller à l'état 61 - E aller à l'état 59 - Invocation aller à l'état 49 + FinDeclConst aller à l'état 62 État 43 - 34 E: tSUB . E + 33 E: tOBRACE . E tCBRACE - tOBRACE décalage et aller à l'état 42 - tSUB décalage et aller à l'état 43 - tNB décalage et aller à l'état 44 - tNBEXP décalage et aller à l'état 45 - tID décalage et aller à l'état 46 + tOBRACE décalage et aller à l'état 43 + tSUB décalage et aller à l'état 44 + tNB décalage et aller à l'état 45 + tNBEXP décalage et aller à l'état 46 + tID décalage et aller à l'état 47 tPRINTF décalage et aller à l'état 19 - tNOT décalage et aller à l'état 47 + tNOT décalage et aller à l'état 48 - E aller à l'état 60 - Invocation aller à l'état 49 + E aller à l'état 63 + Invocation aller à l'état 50 État 44 + 34 E: tSUB . E + + tOBRACE décalage et aller à l'état 43 + tSUB décalage et aller à l'état 44 + tNB décalage et aller à l'état 45 + tNBEXP décalage et aller à l'état 46 + tID décalage et aller à l'état 47 + tPRINTF décalage et aller à l'état 19 + tNOT décalage et aller à l'état 48 + + E aller à l'état 64 + Invocation aller à l'état 50 + + +État 45 + 25 E: tNB . $défaut réduction par utilisation de la règle 25 (E) -État 45 +État 46 26 E: tNBEXP . $défaut réduction par utilisation de la règle 26 (E) -État 46 +État 47 27 E: tID . $défaut réduction par utilisation de la règle 27 (E) -État 47 +État 48 38 E: tNOT . E - tOBRACE décalage et aller à l'état 42 - tSUB décalage et aller à l'état 43 - tNB décalage et aller à l'état 44 - tNBEXP décalage et aller à l'état 45 - tID décalage et aller à l'état 46 + tOBRACE décalage et aller à l'état 43 + tSUB décalage et aller à l'état 44 + tNB décalage et aller à l'état 45 + tNBEXP décalage et aller à l'état 46 + tID décalage et aller à l'état 47 tPRINTF décalage et aller à l'état 19 - tNOT décalage et aller à l'état 47 + tNOT décalage et aller à l'état 48 - E aller à l'état 61 - Invocation aller à l'état 49 + E aller à l'état 65 + Invocation aller à l'état 50 -État 48 +État 49 24 Aff: tID tEQ E . tPV 28 E: E . tMUL E @@ -611,39 +659,39 @@ Invocation (49) 36 | E . tGT E 37 | E . tLT E - tPV décalage et aller à l'état 62 - tMUL décalage et aller à l'état 63 - tDIV décalage et aller à l'état 64 - tADD décalage et aller à l'état 65 - tSUB décalage et aller à l'état 66 - tLT décalage et aller à l'état 67 - tGT décalage et aller à l'état 68 - tEQCOND décalage et aller à l'état 69 + tPV décalage et aller à l'état 66 + tMUL décalage et aller à l'état 67 + tDIV décalage et aller à l'état 68 + tADD décalage et aller à l'état 69 + tSUB décalage et aller à l'état 70 + tLT décalage et aller à l'état 71 + tGT décalage et aller à l'état 72 + tEQCOND décalage et aller à l'état 73 -État 49 +État 50 32 E: Invocation . $défaut réduction par utilisation de la règle 32 (E) -État 50 - - 45 Invocation: tPRINTF tOBRACE tID . tCBRACE - - tCBRACE décalage et aller à l'état 70 - - État 51 - 15 If: tIF tOBRACE Cond . tCBRACE Body Else + 49 Invocation: tPRINTF tOBRACE tID . tCBRACE - tCBRACE décalage et aller à l'état 71 + tCBRACE décalage et aller à l'état 74 État 52 + 15 If: tIF tOBRACE Cond . tCBRACE Body Else + + tCBRACE décalage et aller à l'état 75 + + +État 53 + 20 Cond: E . SuiteCond 28 E: E . tMUL E 29 | E . tDIV E @@ -653,78 +701,108 @@ Invocation (49) 36 | E . tGT E 37 | E . tLT E - tMUL décalage et aller à l'état 63 - tDIV décalage et aller à l'état 64 - tADD décalage et aller à l'état 65 - tSUB décalage et aller à l'état 66 - tLT décalage et aller à l'état 67 - tGT décalage et aller à l'état 68 - tEQCOND décalage et aller à l'état 69 - tAND décalage et aller à l'état 72 - tOR décalage et aller à l'état 73 + tMUL décalage et aller à l'état 67 + tDIV décalage et aller à l'état 68 + tADD décalage et aller à l'état 69 + tSUB décalage et aller à l'état 70 + tLT décalage et aller à l'état 71 + tGT décalage et aller à l'état 72 + tEQCOND décalage et aller à l'état 73 + tAND décalage et aller à l'état 76 + tOR décalage et aller à l'état 77 $défaut réduction par utilisation de la règle 21 (SuiteCond) - SuiteCond aller à l'état 74 - - -État 53 - - 19 While: tWHILE tOBRACE Cond . tCBRACE Body - - tCBRACE décalage et aller à l'état 75 + SuiteCond aller à l'état 78 État 54 - 41 SuiteDecl: tCOMA tID . SuiteDecl + 19 While: tWHILE tOBRACE Cond . tCBRACE Body - tCOMA décalage et aller à l'état 39 - - $défaut réduction par utilisation de la règle 42 (SuiteDecl) - - SuiteDecl aller à l'état 76 + tCBRACE décalage et aller à l'état 79 État 55 - 44 FinDeclaration: tPV . + 43 SuiteDecl: tID tEQ . E - $défaut réduction par utilisation de la règle 44 (FinDeclaration) + tOBRACE décalage et aller à l'état 43 + tSUB décalage et aller à l'état 44 + tNB décalage et aller à l'état 45 + tNBEXP décalage et aller à l'état 46 + tID décalage et aller à l'état 47 + tPRINTF décalage et aller à l'état 19 + tNOT décalage et aller à l'état 48 + + E aller à l'état 80 + Invocation aller à l'état 50 État 56 - 43 FinDeclaration: tEQ . E tPV + 44 FinDecl: tPV . - tOBRACE décalage et aller à l'état 42 - tSUB décalage et aller à l'état 43 - tNB décalage et aller à l'état 44 - tNBEXP décalage et aller à l'état 45 - tID décalage et aller à l'état 46 - tPRINTF décalage et aller à l'état 19 - tNOT décalage et aller à l'état 47 - - E aller à l'état 77 - Invocation aller à l'état 49 + $défaut réduction par utilisation de la règle 44 (FinDecl) État 57 - 39 Decl: tINT tID SuiteDecl FinDeclaration . + 45 FinDecl: tCOMA . SuiteDecl FinDecl - $défaut réduction par utilisation de la règle 39 (Decl) + tID décalage et aller à l'état 38 + + SuiteDecl aller à l'état 81 État 58 - 40 Decl: tCONST tINT tID SuiteDecl . tEQ E tPV + 40 Decl: DeclType SuiteDecl FinDecl . - tEQ décalage et aller à l'état 78 + $défaut réduction par utilisation de la règle 40 (Decl) État 59 + 46 SuiteDeclConst: tID tEQ . E + + tOBRACE décalage et aller à l'état 43 + tSUB décalage et aller à l'état 44 + tNB décalage et aller à l'état 45 + tNBEXP décalage et aller à l'état 46 + tID décalage et aller à l'état 47 + tPRINTF décalage et aller à l'état 19 + tNOT décalage et aller à l'état 48 + + E aller à l'état 82 + Invocation aller à l'état 50 + + +État 60 + + 47 FinDeclConst: tPV . + + $défaut réduction par utilisation de la règle 47 (FinDeclConst) + + +État 61 + + 48 FinDeclConst: tCOMA . SuiteDeclConst FinDeclConst + + tID décalage et aller à l'état 41 + + SuiteDeclConst aller à l'état 83 + + +État 62 + + 41 Decl: tCONST DeclType SuiteDeclConst FinDeclConst . + + $défaut réduction par utilisation de la règle 41 (Decl) + + +État 63 + 28 E: E . tMUL E 29 | E . tDIV E 30 | E . tSUB E @@ -734,17 +812,17 @@ Invocation (49) 36 | E . tGT E 37 | E . tLT E - tCBRACE décalage et aller à l'état 79 - tMUL décalage et aller à l'état 63 - tDIV décalage et aller à l'état 64 - tADD décalage et aller à l'état 65 - tSUB décalage et aller à l'état 66 - tLT décalage et aller à l'état 67 - tGT décalage et aller à l'état 68 - tEQCOND décalage et aller à l'état 69 + tCBRACE décalage et aller à l'état 84 + tMUL décalage et aller à l'état 67 + tDIV décalage et aller à l'état 68 + tADD décalage et aller à l'état 69 + tSUB décalage et aller à l'état 70 + tLT décalage et aller à l'état 71 + tGT décalage et aller à l'état 72 + tEQCOND décalage et aller à l'état 73 -État 60 +État 64 28 E: E . tMUL E 29 | E . tDIV E @@ -755,13 +833,13 @@ Invocation (49) 36 | E . tGT E 37 | E . tLT E - tMUL décalage et aller à l'état 63 - tDIV décalage et aller à l'état 64 + tMUL décalage et aller à l'état 67 + tDIV décalage et aller à l'état 68 $défaut réduction par utilisation de la règle 34 (E) -État 61 +État 65 28 E: E . tMUL E 29 | E . tDIV E @@ -772,208 +850,201 @@ Invocation (49) 37 | E . tLT E 38 | tNOT E . - tMUL décalage et aller à l'état 63 - tDIV décalage et aller à l'état 64 - tADD décalage et aller à l'état 65 - tSUB décalage et aller à l'état 66 - tLT décalage et aller à l'état 67 - tGT décalage et aller à l'état 68 - tEQCOND décalage et aller à l'état 69 + tMUL décalage et aller à l'état 67 + tDIV décalage et aller à l'état 68 + tADD décalage et aller à l'état 69 + tSUB décalage et aller à l'état 70 + tLT décalage et aller à l'état 71 + tGT décalage et aller à l'état 72 + tEQCOND décalage et aller à l'état 73 $défaut réduction par utilisation de la règle 38 (E) -État 62 +État 66 24 Aff: tID tEQ E tPV . $défaut réduction par utilisation de la règle 24 (Aff) -État 63 +État 67 28 E: E tMUL . E - tOBRACE décalage et aller à l'état 42 - tSUB décalage et aller à l'état 43 - tNB décalage et aller à l'état 44 - tNBEXP décalage et aller à l'état 45 - tID décalage et aller à l'état 46 + tOBRACE décalage et aller à l'état 43 + tSUB décalage et aller à l'état 44 + tNB décalage et aller à l'état 45 + tNBEXP décalage et aller à l'état 46 + tID décalage et aller à l'état 47 tPRINTF décalage et aller à l'état 19 - tNOT décalage et aller à l'état 47 + tNOT décalage et aller à l'état 48 - E aller à l'état 80 - Invocation aller à l'état 49 - - -État 64 - - 29 E: E tDIV . E - - tOBRACE décalage et aller à l'état 42 - tSUB décalage et aller à l'état 43 - tNB décalage et aller à l'état 44 - tNBEXP décalage et aller à l'état 45 - tID décalage et aller à l'état 46 - tPRINTF décalage et aller à l'état 19 - tNOT décalage et aller à l'état 47 - - E aller à l'état 81 - Invocation aller à l'état 49 - - -État 65 - - 31 E: E tADD . E - - tOBRACE décalage et aller à l'état 42 - tSUB décalage et aller à l'état 43 - tNB décalage et aller à l'état 44 - tNBEXP décalage et aller à l'état 45 - tID décalage et aller à l'état 46 - tPRINTF décalage et aller à l'état 19 - tNOT décalage et aller à l'état 47 - - E aller à l'état 82 - Invocation aller à l'état 49 - - -État 66 - - 30 E: E tSUB . E - - tOBRACE décalage et aller à l'état 42 - tSUB décalage et aller à l'état 43 - tNB décalage et aller à l'état 44 - tNBEXP décalage et aller à l'état 45 - tID décalage et aller à l'état 46 - tPRINTF décalage et aller à l'état 19 - tNOT décalage et aller à l'état 47 - - E aller à l'état 83 - Invocation aller à l'état 49 - - -État 67 - - 37 E: E tLT . E - - tOBRACE décalage et aller à l'état 42 - tSUB décalage et aller à l'état 43 - tNB décalage et aller à l'état 44 - tNBEXP décalage et aller à l'état 45 - tID décalage et aller à l'état 46 - tPRINTF décalage et aller à l'état 19 - tNOT décalage et aller à l'état 47 - - E aller à l'état 84 - Invocation aller à l'état 49 + E aller à l'état 85 + Invocation aller à l'état 50 État 68 - 36 E: E tGT . E + 29 E: E tDIV . E - tOBRACE décalage et aller à l'état 42 - tSUB décalage et aller à l'état 43 - tNB décalage et aller à l'état 44 - tNBEXP décalage et aller à l'état 45 - tID décalage et aller à l'état 46 + tOBRACE décalage et aller à l'état 43 + tSUB décalage et aller à l'état 44 + tNB décalage et aller à l'état 45 + tNBEXP décalage et aller à l'état 46 + tID décalage et aller à l'état 47 tPRINTF décalage et aller à l'état 19 - tNOT décalage et aller à l'état 47 + tNOT décalage et aller à l'état 48 - E aller à l'état 85 - Invocation aller à l'état 49 + E aller à l'état 86 + Invocation aller à l'état 50 État 69 - 35 E: E tEQCOND . E + 31 E: E tADD . E - tOBRACE décalage et aller à l'état 42 - tSUB décalage et aller à l'état 43 - tNB décalage et aller à l'état 44 - tNBEXP décalage et aller à l'état 45 - tID décalage et aller à l'état 46 + tOBRACE décalage et aller à l'état 43 + tSUB décalage et aller à l'état 44 + tNB décalage et aller à l'état 45 + tNBEXP décalage et aller à l'état 46 + tID décalage et aller à l'état 47 tPRINTF décalage et aller à l'état 19 - tNOT décalage et aller à l'état 47 + tNOT décalage et aller à l'état 48 - E aller à l'état 86 - Invocation aller à l'état 49 + E aller à l'état 87 + Invocation aller à l'état 50 État 70 - 45 Invocation: tPRINTF tOBRACE tID tCBRACE . + 30 E: E tSUB . E - $défaut réduction par utilisation de la règle 45 (Invocation) + tOBRACE décalage et aller à l'état 43 + tSUB décalage et aller à l'état 44 + tNB décalage et aller à l'état 45 + tNBEXP décalage et aller à l'état 46 + tID décalage et aller à l'état 47 + tPRINTF décalage et aller à l'état 19 + tNOT décalage et aller à l'état 48 + + E aller à l'état 88 + Invocation aller à l'état 50 État 71 - 15 If: tIF tOBRACE Cond tCBRACE . Body Else + 37 E: E tLT . E - tOBRACKET décalage et aller à l'état 13 + tOBRACE décalage et aller à l'état 43 + tSUB décalage et aller à l'état 44 + tNB décalage et aller à l'état 45 + tNBEXP décalage et aller à l'état 46 + tID décalage et aller à l'état 47 + tPRINTF décalage et aller à l'état 19 + tNOT décalage et aller à l'état 48 - Body aller à l'état 87 + E aller à l'état 89 + Invocation aller à l'état 50 État 72 - 22 SuiteCond: tAND . E SuiteCond + 36 E: E tGT . E - tOBRACE décalage et aller à l'état 42 - tSUB décalage et aller à l'état 43 - tNB décalage et aller à l'état 44 - tNBEXP décalage et aller à l'état 45 - tID décalage et aller à l'état 46 + tOBRACE décalage et aller à l'état 43 + tSUB décalage et aller à l'état 44 + tNB décalage et aller à l'état 45 + tNBEXP décalage et aller à l'état 46 + tID décalage et aller à l'état 47 tPRINTF décalage et aller à l'état 19 - tNOT décalage et aller à l'état 47 + tNOT décalage et aller à l'état 48 - E aller à l'état 88 - Invocation aller à l'état 49 + E aller à l'état 90 + Invocation aller à l'état 50 État 73 - 23 SuiteCond: tOR . E SuiteCond + 35 E: E tEQCOND . E - tOBRACE décalage et aller à l'état 42 - tSUB décalage et aller à l'état 43 - tNB décalage et aller à l'état 44 - tNBEXP décalage et aller à l'état 45 - tID décalage et aller à l'état 46 + tOBRACE décalage et aller à l'état 43 + tSUB décalage et aller à l'état 44 + tNB décalage et aller à l'état 45 + tNBEXP décalage et aller à l'état 46 + tID décalage et aller à l'état 47 tPRINTF décalage et aller à l'état 19 - tNOT décalage et aller à l'état 47 + tNOT décalage et aller à l'état 48 - E aller à l'état 89 - Invocation aller à l'état 49 + E aller à l'état 91 + Invocation aller à l'état 50 État 74 + 49 Invocation: tPRINTF tOBRACE tID tCBRACE . + + $défaut réduction par utilisation de la règle 49 (Invocation) + + +État 75 + + 15 If: tIF tOBRACE Cond tCBRACE . Body Else + + tOBRACKET décalage et aller à l'état 14 + + Body aller à l'état 92 + + +État 76 + + 22 SuiteCond: tAND . E SuiteCond + + tOBRACE décalage et aller à l'état 43 + tSUB décalage et aller à l'état 44 + tNB décalage et aller à l'état 45 + tNBEXP décalage et aller à l'état 46 + tID décalage et aller à l'état 47 + tPRINTF décalage et aller à l'état 19 + tNOT décalage et aller à l'état 48 + + E aller à l'état 93 + Invocation aller à l'état 50 + + +État 77 + + 23 SuiteCond: tOR . E SuiteCond + + tOBRACE décalage et aller à l'état 43 + tSUB décalage et aller à l'état 44 + tNB décalage et aller à l'état 45 + tNBEXP décalage et aller à l'état 46 + tID décalage et aller à l'état 47 + tPRINTF décalage et aller à l'état 19 + tNOT décalage et aller à l'état 48 + + E aller à l'état 94 + Invocation aller à l'état 50 + + +État 78 + 20 Cond: E SuiteCond . $défaut réduction par utilisation de la règle 20 (Cond) -État 75 +État 79 19 While: tWHILE tOBRACE Cond tCBRACE . Body - tOBRACKET décalage et aller à l'état 13 + tOBRACKET décalage et aller à l'état 14 - Body aller à l'état 90 + Body aller à l'état 95 -État 76 - - 41 SuiteDecl: tCOMA tID SuiteDecl . - - $défaut réduction par utilisation de la règle 41 (SuiteDecl) - - -État 77 +État 80 28 E: E . tMUL E 29 | E . tDIV E @@ -982,42 +1053,69 @@ Invocation (49) 35 | E . tEQCOND E 36 | E . tGT E 37 | E . tLT E - 43 FinDeclaration: tEQ E . tPV + 43 SuiteDecl: tID tEQ E . - tPV décalage et aller à l'état 91 - tMUL décalage et aller à l'état 63 - tDIV décalage et aller à l'état 64 - tADD décalage et aller à l'état 65 - tSUB décalage et aller à l'état 66 - tLT décalage et aller à l'état 67 - tGT décalage et aller à l'état 68 - tEQCOND décalage et aller à l'état 69 + tMUL décalage et aller à l'état 67 + tDIV décalage et aller à l'état 68 + tADD décalage et aller à l'état 69 + tSUB décalage et aller à l'état 70 + tLT décalage et aller à l'état 71 + tGT décalage et aller à l'état 72 + tEQCOND décalage et aller à l'état 73 + + $défaut réduction par utilisation de la règle 43 (SuiteDecl) -État 78 +État 81 - 40 Decl: tCONST tINT tID SuiteDecl tEQ . E tPV + 45 FinDecl: tCOMA SuiteDecl . FinDecl - tOBRACE décalage et aller à l'état 42 - tSUB décalage et aller à l'état 43 - tNB décalage et aller à l'état 44 - tNBEXP décalage et aller à l'état 45 - tID décalage et aller à l'état 46 - tPRINTF décalage et aller à l'état 19 - tNOT décalage et aller à l'état 47 + tPV décalage et aller à l'état 56 + tCOMA décalage et aller à l'état 57 - E aller à l'état 92 - Invocation aller à l'état 49 + FinDecl aller à l'état 96 -État 79 +État 82 + + 28 E: E . tMUL E + 29 | E . tDIV E + 30 | E . tSUB E + 31 | E . tADD E + 35 | E . tEQCOND E + 36 | E . tGT E + 37 | E . tLT E + 46 SuiteDeclConst: tID tEQ E . + + tMUL décalage et aller à l'état 67 + tDIV décalage et aller à l'état 68 + tADD décalage et aller à l'état 69 + tSUB décalage et aller à l'état 70 + tLT décalage et aller à l'état 71 + tGT décalage et aller à l'état 72 + tEQCOND décalage et aller à l'état 73 + + $défaut réduction par utilisation de la règle 46 (SuiteDeclConst) + + +État 83 + + 48 FinDeclConst: tCOMA SuiteDeclConst . FinDeclConst + + tPV décalage et aller à l'état 60 + tCOMA décalage et aller à l'état 61 + + FinDeclConst aller à l'état 97 + + +État 84 33 E: tOBRACE E tCBRACE . $défaut réduction par utilisation de la règle 33 (E) -État 80 +État 85 28 E: E . tMUL E 28 | E tMUL E . @@ -1031,7 +1129,7 @@ Invocation (49) $défaut réduction par utilisation de la règle 28 (E) -État 81 +État 86 28 E: E . tMUL E 29 | E . tDIV E @@ -1045,7 +1143,7 @@ Invocation (49) $défaut réduction par utilisation de la règle 29 (E) -État 82 +État 87 28 E: E . tMUL E 29 | E . tDIV E @@ -1056,13 +1154,13 @@ Invocation (49) 36 | E . tGT E 37 | E . tLT E - tMUL décalage et aller à l'état 63 - tDIV décalage et aller à l'état 64 + tMUL décalage et aller à l'état 67 + tDIV décalage et aller à l'état 68 $défaut réduction par utilisation de la règle 31 (E) -État 83 +État 88 28 E: E . tMUL E 29 | E . tDIV E @@ -1073,13 +1171,13 @@ Invocation (49) 36 | E . tGT E 37 | E . tLT E - tMUL décalage et aller à l'état 63 - tDIV décalage et aller à l'état 64 + tMUL décalage et aller à l'état 67 + tDIV décalage et aller à l'état 68 $défaut réduction par utilisation de la règle 30 (E) -État 84 +État 89 28 E: E . tMUL E 29 | E . tDIV E @@ -1090,16 +1188,16 @@ Invocation (49) 37 | E . tLT E 37 | E tLT E . - tMUL décalage et aller à l'état 63 - tDIV décalage et aller à l'état 64 - tADD décalage et aller à l'état 65 - tSUB décalage et aller à l'état 66 - tEQCOND décalage et aller à l'état 69 + tMUL décalage et aller à l'état 67 + tDIV décalage et aller à l'état 68 + tADD décalage et aller à l'état 69 + tSUB décalage et aller à l'état 70 + tEQCOND décalage et aller à l'état 73 $défaut réduction par utilisation de la règle 37 (E) -État 85 +État 90 28 E: E . tMUL E 29 | E . tDIV E @@ -1110,16 +1208,16 @@ Invocation (49) 36 | E tGT E . 37 | E . tLT E - tMUL décalage et aller à l'état 63 - tDIV décalage et aller à l'état 64 - tADD décalage et aller à l'état 65 - tSUB décalage et aller à l'état 66 - tEQCOND décalage et aller à l'état 69 + tMUL décalage et aller à l'état 67 + tDIV décalage et aller à l'état 68 + tADD décalage et aller à l'état 69 + tSUB décalage et aller à l'état 70 + tEQCOND décalage et aller à l'état 73 $défaut réduction par utilisation de la règle 36 (E) -État 86 +État 91 28 E: E . tMUL E 29 | E . tDIV E @@ -1130,26 +1228,26 @@ Invocation (49) 36 | E . tGT E 37 | E . tLT E - tMUL décalage et aller à l'état 63 - tDIV décalage et aller à l'état 64 - tADD décalage et aller à l'état 65 - tSUB décalage et aller à l'état 66 + tMUL décalage et aller à l'état 67 + tDIV décalage et aller à l'état 68 + tADD décalage et aller à l'état 69 + tSUB décalage et aller à l'état 70 $défaut réduction par utilisation de la règle 35 (E) -État 87 +État 92 15 If: tIF tOBRACE Cond tCBRACE Body . Else - tELSE décalage et aller à l'état 93 + tELSE décalage et aller à l'état 98 $défaut réduction par utilisation de la règle 18 (Else) - Else aller à l'état 94 + Else aller à l'état 99 -État 88 +État 93 22 SuiteCond: tAND E . SuiteCond 28 E: E . tMUL E @@ -1160,22 +1258,22 @@ Invocation (49) 36 | E . tGT E 37 | E . tLT E - tMUL décalage et aller à l'état 63 - tDIV décalage et aller à l'état 64 - tADD décalage et aller à l'état 65 - tSUB décalage et aller à l'état 66 - tLT décalage et aller à l'état 67 - tGT décalage et aller à l'état 68 - tEQCOND décalage et aller à l'état 69 - tAND décalage et aller à l'état 72 - tOR décalage et aller à l'état 73 + tMUL décalage et aller à l'état 67 + tDIV décalage et aller à l'état 68 + tADD décalage et aller à l'état 69 + tSUB décalage et aller à l'état 70 + tLT décalage et aller à l'état 71 + tGT décalage et aller à l'état 72 + tEQCOND décalage et aller à l'état 73 + tAND décalage et aller à l'état 76 + tOR décalage et aller à l'état 77 $défaut réduction par utilisation de la règle 21 (SuiteCond) - SuiteCond aller à l'état 95 + SuiteCond aller à l'état 100 -État 89 +État 94 23 SuiteCond: tOR E . SuiteCond 28 E: E . tMUL E @@ -1186,104 +1284,83 @@ Invocation (49) 36 | E . tGT E 37 | E . tLT E - tMUL décalage et aller à l'état 63 - tDIV décalage et aller à l'état 64 - tADD décalage et aller à l'état 65 - tSUB décalage et aller à l'état 66 - tLT décalage et aller à l'état 67 - tGT décalage et aller à l'état 68 - tEQCOND décalage et aller à l'état 69 - tAND décalage et aller à l'état 72 - tOR décalage et aller à l'état 73 + tMUL décalage et aller à l'état 67 + tDIV décalage et aller à l'état 68 + tADD décalage et aller à l'état 69 + tSUB décalage et aller à l'état 70 + tLT décalage et aller à l'état 71 + tGT décalage et aller à l'état 72 + tEQCOND décalage et aller à l'état 73 + tAND décalage et aller à l'état 76 + tOR décalage et aller à l'état 77 $défaut réduction par utilisation de la règle 21 (SuiteCond) - SuiteCond aller à l'état 96 + SuiteCond aller à l'état 101 -État 90 +État 95 19 While: tWHILE tOBRACE Cond tCBRACE Body . $défaut réduction par utilisation de la règle 19 (While) -État 91 +État 96 - 43 FinDeclaration: tEQ E tPV . + 45 FinDecl: tCOMA SuiteDecl FinDecl . - $défaut réduction par utilisation de la règle 43 (FinDeclaration) + $défaut réduction par utilisation de la règle 45 (FinDecl) -État 92 +État 97 - 28 E: E . tMUL E - 29 | E . tDIV E - 30 | E . tSUB E - 31 | E . tADD E - 35 | E . tEQCOND E - 36 | E . tGT E - 37 | E . tLT E - 40 Decl: tCONST tINT tID SuiteDecl tEQ E . tPV + 48 FinDeclConst: tCOMA SuiteDeclConst FinDeclConst . - tPV décalage et aller à l'état 97 - tMUL décalage et aller à l'état 63 - tDIV décalage et aller à l'état 64 - tADD décalage et aller à l'état 65 - tSUB décalage et aller à l'état 66 - tLT décalage et aller à l'état 67 - tGT décalage et aller à l'état 68 - tEQCOND décalage et aller à l'état 69 + $défaut réduction par utilisation de la règle 48 (FinDeclConst) -État 93 +État 98 16 Else: tELSE . If 17 | tELSE . Body - tOBRACKET décalage et aller à l'état 13 + tOBRACKET décalage et aller à l'état 14 tIF décalage et aller à l'état 20 - Body aller à l'état 98 - If aller à l'état 99 + Body aller à l'état 102 + If aller à l'état 103 -État 94 +État 99 15 If: tIF tOBRACE Cond tCBRACE Body Else . $défaut réduction par utilisation de la règle 15 (If) -État 95 +État 100 22 SuiteCond: tAND E SuiteCond . $défaut réduction par utilisation de la règle 22 (SuiteCond) -État 96 +État 101 23 SuiteCond: tOR E SuiteCond . $défaut réduction par utilisation de la règle 23 (SuiteCond) -État 97 - - 40 Decl: tCONST tINT tID SuiteDecl tEQ E tPV . - - $défaut réduction par utilisation de la règle 40 (Decl) - - -État 98 +État 102 17 Else: tELSE Body . $défaut réduction par utilisation de la règle 17 (Else) -État 99 +État 103 16 Else: tELSE If . diff --git a/Lex_Yacc/as.tab.c b/Lex_Yacc/as.tab.c index d268e6a..400db37 100644 --- a/Lex_Yacc/as.tab.c +++ b/Lex_Yacc/as.tab.c @@ -1,8 +1,9 @@ -/* A Bison parser, made by GNU Bison 3.0.4. */ +/* A Bison parser, made by GNU Bison 3.5.1. */ /* Bison implementation for Yacc-like parsers in C - Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc. + Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2020 Free Software Foundation, + Inc. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -40,11 +41,14 @@ define necessary library symbols; they are noted "INFRINGES ON USER NAME SPACE" below. */ +/* Undocumented macros, especially those whose name start with YY_, + are private implementation details. Do not rely on them. */ + /* Identify Bison output. */ #define YYBISON 1 /* Bison version. */ -#define YYBISON_VERSION "3.0.4" +#define YYBISON_VERSION "3.5.1" /* Skeleton name. */ #define YYSKELETON_NAME "yacc.c" @@ -61,15 +65,25 @@ -/* Copy the first part of user declarations. */ -#line 67 "as.tab.c" /* yacc.c:339 */ - -# ifndef YY_NULLPTR -# if defined __cplusplus && 201103L <= __cplusplus -# define YY_NULLPTR nullptr +# ifndef YY_CAST +# ifdef __cplusplus +# define YY_CAST(Type, Val) static_cast (Val) +# define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast (Val) # else -# define YY_NULLPTR 0 +# define YY_CAST(Type, Val) ((Type) (Val)) +# define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val)) +# endif +# endif +# ifndef YY_NULLPTR +# if defined __cplusplus +# if 201103L <= __cplusplus +# define YY_NULLPTR nullptr +# else +# define YY_NULLPTR 0 +# endif +# else +# define YY_NULLPTR ((void*)0) # endif # endif @@ -81,8 +95,8 @@ # define YYERROR_VERBOSE 0 #endif -/* In a future release of Bison, this section will be replaced - by #include "as.tab.h". */ +/* Use api.header.include to #include this header + instead of duplicating it here. */ #ifndef YY_YY_AS_TAB_H_INCLUDED # define YY_YY_AS_TAB_H_INCLUDED /* Debug traces. */ @@ -131,17 +145,16 @@ extern int yydebug; /* Value type. */ #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED - union YYSTYPE { -#line 1 "as.y" /* yacc.c:355 */ +#line 1 "as.y" int nombre; char id[30]; -#line 143 "as.tab.c" /* yacc.c:355 */ -}; +#line 156 "as.tab.c" +}; typedef union YYSTYPE YYSTYPE; # define YYSTYPE_IS_TRIVIAL 1 # define YYSTYPE_IS_DECLARED 1 @@ -154,42 +167,95 @@ int yyparse (void); #endif /* !YY_YY_AS_TAB_H_INCLUDED */ -/* Copy the second part of user declarations. */ -#line 5 "as.y" /* yacc.c:358 */ +/* Second part of user prologue. */ +#line 5 "as.y" #include "../Symboles/table_symboles.h" #include +#include +#include +#include "../Symboles/tab_instruc.h" +#define TAILLE 1024 -int addr = 0; +enum type_t type_courant; + + +#line 184 "as.tab.c" -#line 166 "as.tab.c" /* yacc.c:358 */ #ifdef short # undef short #endif -#ifdef YYTYPE_UINT8 -typedef YYTYPE_UINT8 yytype_uint8; -#else -typedef unsigned char yytype_uint8; +/* On compilers that do not define __PTRDIFF_MAX__ etc., make sure + and (if available) are included + so that the code can choose integer types of a good width. */ + +#ifndef __PTRDIFF_MAX__ +# include /* INFRINGES ON USER NAME SPACE */ +# if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__ +# include /* INFRINGES ON USER NAME SPACE */ +# define YY_STDINT_H +# endif #endif -#ifdef YYTYPE_INT8 -typedef YYTYPE_INT8 yytype_int8; +/* Narrow types that promote to a signed type and that can represent a + signed or unsigned integer of at least N bits. In tables they can + save space and decrease cache pressure. Promoting to a signed type + helps avoid bugs in integer arithmetic. */ + +#ifdef __INT_LEAST8_MAX__ +typedef __INT_LEAST8_TYPE__ yytype_int8; +#elif defined YY_STDINT_H +typedef int_least8_t yytype_int8; #else typedef signed char yytype_int8; #endif -#ifdef YYTYPE_UINT16 -typedef YYTYPE_UINT16 yytype_uint16; +#ifdef __INT_LEAST16_MAX__ +typedef __INT_LEAST16_TYPE__ yytype_int16; +#elif defined YY_STDINT_H +typedef int_least16_t yytype_int16; #else -typedef unsigned short int yytype_uint16; +typedef short yytype_int16; #endif -#ifdef YYTYPE_INT16 -typedef YYTYPE_INT16 yytype_int16; +#if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__ +typedef __UINT_LEAST8_TYPE__ yytype_uint8; +#elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \ + && UINT_LEAST8_MAX <= INT_MAX) +typedef uint_least8_t yytype_uint8; +#elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX +typedef unsigned char yytype_uint8; #else -typedef short int yytype_int16; +typedef short yytype_uint8; +#endif + +#if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__ +typedef __UINT_LEAST16_TYPE__ yytype_uint16; +#elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \ + && UINT_LEAST16_MAX <= INT_MAX) +typedef uint_least16_t yytype_uint16; +#elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX +typedef unsigned short yytype_uint16; +#else +typedef int yytype_uint16; +#endif + +#ifndef YYPTRDIFF_T +# if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__ +# define YYPTRDIFF_T __PTRDIFF_TYPE__ +# define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__ +# elif defined PTRDIFF_MAX +# ifndef ptrdiff_t +# include /* INFRINGES ON USER NAME SPACE */ +# endif +# define YYPTRDIFF_T ptrdiff_t +# define YYPTRDIFF_MAXIMUM PTRDIFF_MAX +# else +# define YYPTRDIFF_T long +# define YYPTRDIFF_MAXIMUM LONG_MAX +# endif #endif #ifndef YYSIZE_T @@ -197,15 +263,27 @@ typedef short int yytype_int16; # define YYSIZE_T __SIZE_TYPE__ # elif defined size_t # define YYSIZE_T size_t -# elif ! defined YYSIZE_T +# elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__ # include /* INFRINGES ON USER NAME SPACE */ # define YYSIZE_T size_t # else -# define YYSIZE_T unsigned int +# define YYSIZE_T unsigned # endif #endif -#define YYSIZE_MAXIMUM ((YYSIZE_T) -1) +#define YYSIZE_MAXIMUM \ + YY_CAST (YYPTRDIFF_T, \ + (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1) \ + ? YYPTRDIFF_MAXIMUM \ + : YY_CAST (YYSIZE_T, -1))) + +#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) + +/* Stored state numbers (used for stacks). */ +typedef yytype_int8 yy_state_t; + +/* State numbers in computations. */ +typedef int yy_state_fast_t; #ifndef YY_ # if defined YYENABLE_NLS && YYENABLE_NLS @@ -219,30 +297,19 @@ typedef short int yytype_int16; # endif #endif -#ifndef YY_ATTRIBUTE -# if (defined __GNUC__ \ - && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__))) \ - || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C -# define YY_ATTRIBUTE(Spec) __attribute__(Spec) +#ifndef YY_ATTRIBUTE_PURE +# if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__) +# define YY_ATTRIBUTE_PURE __attribute__ ((__pure__)) # else -# define YY_ATTRIBUTE(Spec) /* empty */ +# define YY_ATTRIBUTE_PURE # endif #endif -#ifndef YY_ATTRIBUTE_PURE -# define YY_ATTRIBUTE_PURE YY_ATTRIBUTE ((__pure__)) -#endif - #ifndef YY_ATTRIBUTE_UNUSED -# define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__)) -#endif - -#if !defined _Noreturn \ - && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112) -# if defined _MSC_VER && 1200 <= _MSC_VER -# define _Noreturn __declspec (noreturn) +# if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__) +# define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__)) # else -# define _Noreturn YY_ATTRIBUTE ((__noreturn__)) +# define YY_ATTRIBUTE_UNUSED # endif #endif @@ -253,13 +320,13 @@ typedef short int yytype_int16; # define YYUSE(E) /* empty */ #endif -#if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__ +#if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__ /* Suppress an incorrect diagnostic about yylval being uninitialized. */ -# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ - _Pragma ("GCC diagnostic push") \ - _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\ +# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ + _Pragma ("GCC diagnostic push") \ + _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \ _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"") -# define YY_IGNORE_MAYBE_UNINITIALIZED_END \ +# define YY_IGNORE_MAYBE_UNINITIALIZED_END \ _Pragma ("GCC diagnostic pop") #else # define YY_INITIAL_VALUE(Value) Value @@ -272,6 +339,20 @@ typedef short int yytype_int16; # define YY_INITIAL_VALUE(Value) /* Nothing. */ #endif +#if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__ +# define YY_IGNORE_USELESS_CAST_BEGIN \ + _Pragma ("GCC diagnostic push") \ + _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"") +# define YY_IGNORE_USELESS_CAST_END \ + _Pragma ("GCC diagnostic pop") +#endif +#ifndef YY_IGNORE_USELESS_CAST_BEGIN +# define YY_IGNORE_USELESS_CAST_BEGIN +# define YY_IGNORE_USELESS_CAST_END +#endif + + +#define YY_ASSERT(E) ((void) (0 && (E))) #if ! defined yyoverflow || YYERROR_VERBOSE @@ -348,17 +429,17 @@ void free (void *); /* INFRINGES ON USER NAME SPACE */ /* A type that is properly aligned for any stack member. */ union yyalloc { - yytype_int16 yyss_alloc; + yy_state_t yyss_alloc; YYSTYPE yyvs_alloc; }; /* The size of the maximum gap between one aligned stack and the next. */ -# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) +# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1) /* The size of an array large to enough to hold all stacks, each with N elements. */ # define YYSTACK_BYTES(N) \ - ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ + ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE)) \ + YYSTACK_GAP_MAXIMUM) # define YYCOPY_NEEDED 1 @@ -371,11 +452,11 @@ union yyalloc # define YYSTACK_RELOCATE(Stack_alloc, Stack) \ do \ { \ - YYSIZE_T yynewbytes; \ + YYPTRDIFF_T yynewbytes; \ YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ Stack = &yyptr->Stack_alloc; \ - yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ - yyptr += yynewbytes / sizeof (*yyptr); \ + yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ + yyptr += yynewbytes / YYSIZEOF (*yyptr); \ } \ while (0) @@ -387,12 +468,12 @@ union yyalloc # ifndef YYCOPY # if defined __GNUC__ && 1 < __GNUC__ # define YYCOPY(Dst, Src, Count) \ - __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src))) + __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src))) # else # define YYCOPY(Dst, Src, Count) \ do \ { \ - YYSIZE_T yyi; \ + YYPTRDIFF_T yyi; \ for (yyi = 0; yyi < (Count); yyi++) \ (Dst)[yyi] = (Src)[yyi]; \ } \ @@ -404,28 +485,29 @@ union yyalloc /* YYFINAL -- State number of the termination state. */ #define YYFINAL 4 /* YYLAST -- Last index in YYTABLE. */ -#define YYLAST 130 +#define YYLAST 119 /* YYNTOKENS -- Number of terminals. */ #define YYNTOKENS 31 /* YYNNTS -- Number of nonterminals. */ -#define YYNNTS 19 +#define YYNNTS 22 /* YYNRULES -- Number of rules. */ -#define YYNRULES 46 +#define YYNRULES 50 /* YYNSTATES -- Number of states. */ -#define YYNSTATES 100 +#define YYNSTATES 104 -/* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned - by yylex, with out-of-bounds checking. */ #define YYUNDEFTOK 2 #define YYMAXUTOK 285 + +/* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM + as returned by yylex, with out-of-bounds checking. */ #define YYTRANSLATE(YYX) \ - ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) + (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM - as returned by yylex, without out-of-bounds checking. */ -static const yytype_uint8 yytranslate[] = + as returned by yylex. */ +static const yytype_int8 yytranslate[] = { 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, @@ -462,11 +544,12 @@ static const yytype_uint8 yytranslate[] = /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ static const yytype_uint8 yyrline[] = { - 0, 40, 40, 42, 43, 44, 45, 46, 48, 51, - 52, 53, 54, 55, 56, 57, 60, 61, 62, 63, - 64, 66, 67, 68, 69, 72, 74, 75, 76, 77, - 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, - 90, 91, 92, 93, 94, 95, 97 + 0, 49, 49, 51, 52, 53, 54, 55, 57, 60, + 61, 62, 63, 64, 65, 66, 69, 70, 71, 72, + 73, 75, 76, 77, 78, 81, 83, 85, 86, 87, + 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, + 102, 104, 105, 107, 108, 109, 110, 112, 113, 114, + 133 }; #endif @@ -481,15 +564,15 @@ static const char *const yytname[] = "tIF", "tWHILE", "tELSE", "tLT", "tGT", "tEQCOND", "tAND", "tOR", "tNOT", "$accept", "Main", "Params", "Param", "SuiteParams", "Body", "Instructions", "Instruction", "If", "Else", "While", "Cond", - "SuiteCond", "Aff", "E", "Decl", "SuiteDecl", "FinDeclaration", - "Invocation", YY_NULLPTR + "SuiteCond", "Aff", "E", "DeclType", "Decl", "SuiteDecl", "FinDecl", + "SuiteDeclConst", "FinDeclConst", "Invocation", YY_NULLPTR }; #endif # ifdef YYPRINT /* YYTOKNUM[NUM] -- (External) token number corresponding to the (internal) symbol number NUM (which must be that of a token). */ -static const yytype_uint16 yytoknum[] = +static const yytype_int16 yytoknum[] = { 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, @@ -498,136 +581,139 @@ static const yytype_uint16 yytoknum[] = }; # endif -#define YYPACT_NINF -69 +#define YYPACT_NINF (-75) -#define yypact_value_is_default(Yystate) \ - (!!((Yystate) == (-69))) +#define yypact_value_is_default(Yyn) \ + ((Yyn) == YYPACT_NINF) -#define YYTABLE_NINF -1 +#define YYTABLE_NINF (-1) -#define yytable_value_is_error(Yytable_value) \ +#define yytable_value_is_error(Yyn) \ 0 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing STATE-NUM. */ static const yytype_int8 yypact[] = { - -7, 1, 9, 16, -69, 20, 11, 50, 32, -69, - 66, 20, -69, 36, -69, 32, 44, 68, 67, 75, - 76, 81, 84, 36, -69, -69, -69, -69, 78, -69, - 96, 92, -1, 97, -1, -1, -69, -69, -69, 98, - -4, 96, -1, -1, -69, -69, -69, -1, 59, -69, - 108, 116, 39, 117, 96, -69, -1, -69, 109, 35, - 14, 87, -69, -1, -1, -1, -1, -1, -1, -1, - -69, 66, -1, -1, -69, 66, -69, 65, -1, -69, - -69, -69, 14, 14, 91, 91, 107, 70, 39, 39, - -69, -69, 83, -2, -69, -69, -69, -69, -69, -69 + -6, 23, 14, 27, -75, 38, -75, 22, 32, 40, + 66, 38, -75, -75, 72, -75, 32, 38, 47, 73, + 81, 87, 95, 72, -75, -75, -75, 82, -75, 92, + -75, 84, 0, 85, 0, 0, -75, -75, 89, 21, + -75, 90, 86, 0, 0, -75, -75, -75, 0, 59, + -75, 100, 101, 39, 102, 0, -75, 82, -75, 0, + -75, 84, -75, 35, 70, 63, -75, 0, 0, 0, + 0, 0, 0, 0, -75, 66, 0, 0, -75, 66, + 63, 21, 63, 86, -75, -75, -75, 70, 70, -5, + -5, 43, 88, 39, 39, -75, -75, -75, -1, -75, + -75, -75, -75, -75 }; /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. Performed when YYTABLE does not specify something else to do. Zero means the default is an error. */ -static const yytype_uint8 yydefact[] = +static const yytype_int8 yydefact[] = { - 0, 0, 0, 0, 1, 3, 0, 0, 7, 5, - 0, 0, 4, 10, 2, 7, 0, 0, 0, 0, - 0, 0, 0, 10, 14, 15, 11, 12, 0, 6, - 43, 0, 0, 0, 0, 0, 8, 9, 13, 0, - 0, 43, 0, 0, 26, 27, 28, 0, 0, 33, - 0, 0, 22, 0, 43, 45, 0, 40, 0, 0, - 35, 39, 25, 0, 0, 0, 0, 0, 0, 0, - 46, 0, 0, 0, 21, 0, 42, 0, 0, 34, - 29, 30, 32, 31, 38, 37, 36, 19, 22, 22, - 20, 44, 0, 0, 16, 23, 24, 41, 18, 17 + 0, 0, 0, 0, 1, 3, 40, 0, 7, 0, + 0, 0, 4, 5, 10, 2, 7, 0, 0, 0, + 0, 0, 0, 10, 14, 15, 11, 0, 12, 0, + 6, 0, 0, 0, 0, 0, 8, 9, 43, 0, + 13, 0, 0, 0, 0, 26, 27, 28, 0, 0, + 33, 0, 0, 22, 0, 0, 45, 0, 41, 0, + 48, 0, 42, 0, 35, 39, 25, 0, 0, 0, + 0, 0, 0, 0, 50, 0, 0, 0, 21, 0, + 44, 0, 47, 0, 34, 29, 30, 32, 31, 38, + 37, 36, 19, 22, 22, 20, 46, 49, 0, 16, + 23, 24, 18, 17 }; /* YYPGOTO[NTERM-NUM]. */ static const yytype_int8 yypgoto[] = { - -69, -69, -69, 115, 112, -68, 105, -69, 37, -69, - -69, 94, -50, -69, -32, -69, -33, -69, 0 + -75, -75, -75, 99, 97, -74, 91, -75, 13, -75, + -75, 80, 5, -75, -32, 11, -75, 60, 37, 55, + 36, -10 }; /* YYDEFGOTO[NTERM-NUM]. */ static const yytype_int8 yydefgoto[] = { - -1, 2, 7, 8, 12, 14, 22, 23, 24, 94, - 25, 51, 74, 26, 52, 27, 40, 57, 49 + -1, 2, 7, 8, 12, 15, 22, 23, 24, 99, + 25, 52, 78, 26, 53, 9, 28, 39, 58, 42, + 62, 50 }; /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If positive, shift that token. If negative, reduce the rule whose number is the opposite. If YYTABLE_NINF, syntax error. */ -static const yytype_uint8 yytable[] = +static const yytype_int8 yytable[] = { - 48, 1, 13, 87, 3, 42, 55, 90, 58, 4, - 59, 60, 56, 28, 43, 61, 44, 45, 46, 19, - 20, 76, 5, 28, 77, 98, 63, 64, 6, 47, - 9, 80, 81, 82, 83, 84, 85, 86, 95, 96, - 88, 89, 79, 11, 16, 17, 92, 63, 64, 65, - 66, 63, 64, 65, 66, 18, 19, 10, 20, 21, - 67, 68, 69, 30, 67, 68, 69, 72, 73, 62, - 13, 63, 64, 65, 66, 91, 31, 63, 64, 65, - 66, 33, 34, 32, 67, 68, 69, 35, 38, 36, - 67, 68, 69, 97, 93, 63, 64, 65, 66, 63, - 64, 65, 66, 63, 64, 65, 66, 39, 67, 68, - 69, 41, 67, 68, 69, 70, 50, 54, 69, 63, - 64, 65, 66, 71, 75, 78, 15, 29, 37, 53, - 99 + 49, 92, 1, 14, 29, 95, 43, 67, 68, 69, + 70, 63, 64, 29, 4, 44, 65, 45, 46, 47, + 19, 20, 73, 80, 102, 27, 3, 82, 31, 10, + 48, 56, 57, 5, 27, 85, 86, 87, 88, 89, + 90, 91, 84, 11, 93, 94, 6, 67, 68, 69, + 70, 67, 68, 69, 70, 67, 68, 69, 70, 13, + 71, 72, 73, 32, 71, 72, 73, 76, 77, 66, + 14, 67, 68, 69, 70, 67, 68, 69, 70, 33, + 6, 17, 67, 68, 71, 72, 73, 34, 71, 72, + 73, 18, 19, 35, 20, 21, 60, 61, 100, 101, + 36, 38, 40, 41, 51, 55, 59, 74, 75, 79, + 16, 103, 98, 30, 37, 54, 83, 81, 96, 97 }; -static const yytype_uint8 yycheck[] = +static const yytype_int8 yycheck[] = { - 32, 8, 4, 71, 3, 6, 10, 75, 41, 0, - 42, 43, 16, 13, 15, 47, 17, 18, 19, 20, - 22, 54, 6, 23, 56, 93, 12, 13, 8, 30, - 19, 63, 64, 65, 66, 67, 68, 69, 88, 89, - 72, 73, 7, 11, 8, 9, 78, 12, 13, 14, - 15, 12, 13, 14, 15, 19, 20, 7, 22, 23, - 25, 26, 27, 19, 25, 26, 27, 28, 29, 10, - 4, 12, 13, 14, 15, 10, 8, 12, 13, 14, - 15, 6, 6, 16, 25, 26, 27, 6, 10, 5, - 25, 26, 27, 10, 24, 12, 13, 14, 15, 12, - 13, 14, 15, 12, 13, 14, 15, 11, 25, 26, - 27, 19, 25, 26, 27, 7, 19, 19, 27, 12, - 13, 14, 15, 7, 7, 16, 11, 15, 23, 35, - 93 + 32, 75, 8, 4, 14, 79, 6, 12, 13, 14, + 15, 43, 44, 23, 0, 15, 48, 17, 18, 19, + 20, 22, 27, 55, 98, 14, 3, 59, 17, 7, + 30, 10, 11, 6, 23, 67, 68, 69, 70, 71, + 72, 73, 7, 11, 76, 77, 8, 12, 13, 14, + 15, 12, 13, 14, 15, 12, 13, 14, 15, 19, + 25, 26, 27, 16, 25, 26, 27, 28, 29, 10, + 4, 12, 13, 14, 15, 12, 13, 14, 15, 6, + 8, 9, 12, 13, 25, 26, 27, 6, 25, 26, + 27, 19, 20, 6, 22, 23, 10, 11, 93, 94, + 5, 19, 10, 19, 19, 16, 16, 7, 7, 7, + 11, 98, 24, 16, 23, 35, 61, 57, 81, 83 }; /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing symbol of state STATE-NUM. */ -static const yytype_uint8 yystos[] = +static const yytype_int8 yystos[] = { - 0, 8, 32, 3, 0, 6, 8, 33, 34, 19, - 7, 11, 35, 4, 36, 34, 8, 9, 19, 20, - 22, 23, 37, 38, 39, 41, 44, 46, 49, 35, - 19, 8, 16, 6, 6, 6, 5, 37, 10, 11, - 47, 19, 6, 15, 17, 18, 19, 30, 45, 49, - 19, 42, 45, 42, 19, 10, 16, 48, 47, 45, - 45, 45, 10, 12, 13, 14, 15, 25, 26, 27, - 7, 7, 28, 29, 43, 7, 47, 45, 16, 7, - 45, 45, 45, 45, 45, 45, 45, 36, 45, 45, - 36, 10, 45, 24, 40, 43, 43, 10, 36, 39 + 0, 8, 32, 3, 0, 6, 8, 33, 34, 46, + 7, 11, 35, 19, 4, 36, 34, 9, 19, 20, + 22, 23, 37, 38, 39, 41, 44, 46, 47, 52, + 35, 46, 16, 6, 6, 6, 5, 37, 19, 48, + 10, 19, 50, 6, 15, 17, 18, 19, 30, 45, + 52, 19, 42, 45, 42, 16, 10, 11, 49, 16, + 10, 11, 51, 45, 45, 45, 10, 12, 13, 14, + 15, 25, 26, 27, 7, 7, 28, 29, 43, 7, + 45, 48, 45, 50, 7, 45, 45, 45, 45, 45, + 45, 45, 36, 45, 45, 36, 49, 51, 24, 40, + 43, 43, 36, 39 }; /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ -static const yytype_uint8 yyr1[] = +static const yytype_int8 yyr1[] = { 0, 31, 32, 33, 33, 34, 35, 35, 36, 37, 37, 38, 38, 38, 38, 38, 39, 40, 40, 40, 41, 42, 43, 43, 43, 44, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, - 46, 46, 47, 47, 48, 48, 49 + 46, 47, 47, 48, 48, 49, 49, 50, 51, 51, + 52 }; /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */ -static const yytype_uint8 yyr2[] = +static const yytype_int8 yyr2[] = { 0, 2, 6, 0, 2, 2, 3, 0, 3, 2, 0, 1, 1, 2, 1, 1, 6, 2, 2, 0, 5, 2, 0, 3, 3, 4, 1, 1, 1, 3, 3, 3, 3, 1, 3, 2, 3, 3, 3, 2, - 4, 7, 3, 0, 3, 1, 4 + 1, 3, 4, 1, 3, 1, 3, 3, 1, 3, + 4 }; @@ -643,22 +729,22 @@ static const yytype_uint8 yyr2[] = #define YYRECOVERING() (!!yyerrstatus) -#define YYBACKUP(Token, Value) \ -do \ - if (yychar == YYEMPTY) \ - { \ - yychar = (Token); \ - yylval = (Value); \ - YYPOPSTACK (yylen); \ - yystate = *yyssp; \ - goto yybackup; \ - } \ - else \ - { \ - yyerror (YY_("syntax error: cannot back up")); \ - YYERROR; \ - } \ -while (0) +#define YYBACKUP(Token, Value) \ + do \ + if (yychar == YYEMPTY) \ + { \ + yychar = (Token); \ + yylval = (Value); \ + YYPOPSTACK (yylen); \ + yystate = *yyssp; \ + goto yybackup; \ + } \ + else \ + { \ + yyerror (YY_("syntax error: cannot back up")); \ + YYERROR; \ + } \ + while (0) /* Error token number */ #define YYTERROR 1 @@ -698,37 +784,39 @@ do { \ } while (0) -/*----------------------------------------. -| Print this symbol's value on YYOUTPUT. | -`----------------------------------------*/ +/*-----------------------------------. +| Print this symbol's value on YYO. | +`-----------------------------------*/ static void -yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) +yy_symbol_value_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep) { - FILE *yyo = yyoutput; - YYUSE (yyo); + FILE *yyoutput = yyo; + YYUSE (yyoutput); if (!yyvaluep) return; # ifdef YYPRINT if (yytype < YYNTOKENS) - YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); + YYPRINT (yyo, yytoknum[yytype], *yyvaluep); # endif + YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN YYUSE (yytype); + YY_IGNORE_MAYBE_UNINITIALIZED_END } -/*--------------------------------. -| Print this symbol on YYOUTPUT. | -`--------------------------------*/ +/*---------------------------. +| Print this symbol on YYO. | +`---------------------------*/ static void -yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) +yy_symbol_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep) { - YYFPRINTF (yyoutput, "%s %s (", + YYFPRINTF (yyo, "%s %s (", yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]); - yy_symbol_value_print (yyoutput, yytype, yyvaluep); - YYFPRINTF (yyoutput, ")"); + yy_symbol_value_print (yyo, yytype, yyvaluep); + YYFPRINTF (yyo, ")"); } /*------------------------------------------------------------------. @@ -737,7 +825,7 @@ yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) `------------------------------------------------------------------*/ static void -yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop) +yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop) { YYFPRINTF (stderr, "Stack now"); for (; yybottom <= yytop; yybottom++) @@ -760,20 +848,20 @@ do { \ `------------------------------------------------*/ static void -yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule) +yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp, int yyrule) { - unsigned long int yylno = yyrline[yyrule]; + int yylno = yyrline[yyrule]; int yynrhs = yyr2[yyrule]; int yyi; - YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", + YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n", yyrule - 1, yylno); /* The symbols being reduced. */ for (yyi = 0; yyi < yynrhs; yyi++) { YYFPRINTF (stderr, " $%d = ", yyi + 1); yy_symbol_print (stderr, - yystos[yyssp[yyi + 1 - yynrhs]], - &(yyvsp[(yyi + 1) - (yynrhs)]) + yystos[+yyssp[yyi + 1 - yynrhs]], + &yyvsp[(yyi + 1) - (yynrhs)] ); YYFPRINTF (stderr, "\n"); } @@ -817,13 +905,13 @@ int yydebug; # ifndef yystrlen # if defined __GLIBC__ && defined _STRING_H -# define yystrlen strlen +# define yystrlen(S) (YY_CAST (YYPTRDIFF_T, strlen (S))) # else /* Return the length of YYSTR. */ -static YYSIZE_T +static YYPTRDIFF_T yystrlen (const char *yystr) { - YYSIZE_T yylen; + YYPTRDIFF_T yylen; for (yylen = 0; yystr[yylen]; yylen++) continue; return yylen; @@ -859,12 +947,12 @@ yystpcpy (char *yydest, const char *yysrc) backslash-backslash). YYSTR is taken from yytname. If YYRES is null, do not copy; instead, return the length of what the result would have been. */ -static YYSIZE_T +static YYPTRDIFF_T yytnamerr (char *yyres, const char *yystr) { if (*yystr == '"') { - YYSIZE_T yyn = 0; + YYPTRDIFF_T yyn = 0; char const *yyp = yystr; for (;;) @@ -877,7 +965,10 @@ yytnamerr (char *yyres, const char *yystr) case '\\': if (*++yyp != '\\') goto do_not_strip_quotes; - /* Fall through. */ + else + goto append; + + append: default: if (yyres) yyres[yyn] = *yyp; @@ -892,10 +983,10 @@ yytnamerr (char *yyres, const char *yystr) do_not_strip_quotes: ; } - if (! yyres) + if (yyres) + return yystpcpy (yyres, yystr) - yyres; + else return yystrlen (yystr); - - return yystpcpy (yyres, yystr) - yyres; } # endif @@ -908,19 +999,19 @@ yytnamerr (char *yyres, const char *yystr) *YYMSG_ALLOC to the required number of bytes. Return 2 if the required number of bytes is too large to store. */ static int -yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, - yytype_int16 *yyssp, int yytoken) +yysyntax_error (YYPTRDIFF_T *yymsg_alloc, char **yymsg, + yy_state_t *yyssp, int yytoken) { - YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]); - YYSIZE_T yysize = yysize0; enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; /* Internationalized format string. */ const char *yyformat = YY_NULLPTR; - /* Arguments of yyformat. */ + /* Arguments of yyformat: reported tokens (one for the "unexpected", + one per "expected"). */ char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; - /* Number of reported tokens (one for the "unexpected", one per - "expected"). */ + /* Actual size of YYARG. */ int yycount = 0; + /* Cumulated lengths of YYARG. */ + YYPTRDIFF_T yysize = 0; /* There are many possibilities here to consider: - If this state is a consistent state with a default action, then @@ -947,7 +1038,9 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, */ if (yytoken != YYEMPTY) { - int yyn = yypact[*yyssp]; + int yyn = yypact[+*yyssp]; + YYPTRDIFF_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]); + yysize = yysize0; yyarg[yycount++] = yytname[yytoken]; if (!yypact_value_is_default (yyn)) { @@ -972,11 +1065,12 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, } yyarg[yycount++] = yytname[yyx]; { - YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]); - if (! (yysize <= yysize1 - && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) + YYPTRDIFF_T yysize1 + = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]); + if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM) + yysize = yysize1; + else return 2; - yysize = yysize1; } } } @@ -988,6 +1082,7 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, case N: \ yyformat = S; \ break + default: /* Avoid compiler warnings. */ YYCASE_(0, YY_("syntax error")); YYCASE_(1, YY_("syntax error, unexpected %s")); YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); @@ -998,10 +1093,13 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, } { - YYSIZE_T yysize1 = yysize + yystrlen (yyformat); - if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) + /* Don't count the "%s"s in the final size, but reserve room for + the terminator. */ + YYPTRDIFF_T yysize1 = yysize + (yystrlen (yyformat) - 2 * yycount) + 1; + if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM) + yysize = yysize1; + else return 2; - yysize = yysize1; } if (*yymsg_alloc < yysize) @@ -1027,8 +1125,8 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, } else { - yyp++; - yyformat++; + ++yyp; + ++yyformat; } } return 0; @@ -1071,7 +1169,7 @@ int yynerrs; int yyparse (void) { - int yystate; + yy_state_fast_t yystate; /* Number of tokens to shift before error messages enabled. */ int yyerrstatus; @@ -1083,16 +1181,16 @@ yyparse (void) to reallocate them elsewhere. */ /* The state stack. */ - yytype_int16 yyssa[YYINITDEPTH]; - yytype_int16 *yyss; - yytype_int16 *yyssp; + yy_state_t yyssa[YYINITDEPTH]; + yy_state_t *yyss; + yy_state_t *yyssp; /* The semantic value stack. */ YYSTYPE yyvsa[YYINITDEPTH]; YYSTYPE *yyvs; YYSTYPE *yyvsp; - YYSIZE_T yystacksize; + YYPTRDIFF_T yystacksize; int yyn; int yyresult; @@ -1106,7 +1204,7 @@ yyparse (void) /* Buffer for error messages, and its allocated size. */ char yymsgbuf[128]; char *yymsg = yymsgbuf; - YYSIZE_T yymsg_alloc = sizeof yymsgbuf; + YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf; #endif #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) @@ -1127,46 +1225,54 @@ yyparse (void) yychar = YYEMPTY; /* Cause a token to be read. */ goto yysetstate; + /*------------------------------------------------------------. -| yynewstate -- Push a new state, which is found in yystate. | +| yynewstate -- push a new state, which is found in yystate. | `------------------------------------------------------------*/ - yynewstate: +yynewstate: /* In all cases, when you get here, the value and location stacks have just been pushed. So pushing a state here evens the stacks. */ yyssp++; - yysetstate: - *yyssp = yystate; + +/*--------------------------------------------------------------------. +| yysetstate -- set current state (the top of the stack) to yystate. | +`--------------------------------------------------------------------*/ +yysetstate: + YYDPRINTF ((stderr, "Entering state %d\n", yystate)); + YY_ASSERT (0 <= yystate && yystate < YYNSTATES); + YY_IGNORE_USELESS_CAST_BEGIN + *yyssp = YY_CAST (yy_state_t, yystate); + YY_IGNORE_USELESS_CAST_END if (yyss + yystacksize - 1 <= yyssp) +#if !defined yyoverflow && !defined YYSTACK_RELOCATE + goto yyexhaustedlab; +#else { /* Get the current used size of the three stacks, in elements. */ - YYSIZE_T yysize = yyssp - yyss + 1; + YYPTRDIFF_T yysize = yyssp - yyss + 1; -#ifdef yyoverflow +# if defined yyoverflow { /* Give user a chance to reallocate the stack. Use copies of these so that the &'s don't force the real ones into memory. */ + yy_state_t *yyss1 = yyss; YYSTYPE *yyvs1 = yyvs; - yytype_int16 *yyss1 = yyss; /* Each stack pointer address is followed by the size of the data in use in that stack, in bytes. This used to be a conditional around just the two extra args, but that might be undefined if yyoverflow is a macro. */ yyoverflow (YY_("memory exhausted"), - &yyss1, yysize * sizeof (*yyssp), - &yyvs1, yysize * sizeof (*yyvsp), + &yyss1, yysize * YYSIZEOF (*yyssp), + &yyvs1, yysize * YYSIZEOF (*yyvsp), &yystacksize); - yyss = yyss1; yyvs = yyvs1; } -#else /* no yyoverflow */ -# ifndef YYSTACK_RELOCATE - goto yyexhaustedlab; -# else +# else /* defined YYSTACK_RELOCATE */ /* Extend the stack our own way. */ if (YYMAXDEPTH <= yystacksize) goto yyexhaustedlab; @@ -1175,42 +1281,43 @@ yyparse (void) yystacksize = YYMAXDEPTH; { - yytype_int16 *yyss1 = yyss; + yy_state_t *yyss1 = yyss; union yyalloc *yyptr = - (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); + YY_CAST (union yyalloc *, + YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize)))); if (! yyptr) goto yyexhaustedlab; YYSTACK_RELOCATE (yyss_alloc, yyss); YYSTACK_RELOCATE (yyvs_alloc, yyvs); -# undef YYSTACK_RELOCATE +# undef YYSTACK_RELOCATE if (yyss1 != yyssa) YYSTACK_FREE (yyss1); } # endif -#endif /* no yyoverflow */ yyssp = yyss + yysize - 1; yyvsp = yyvs + yysize - 1; - YYDPRINTF ((stderr, "Stack size increased to %lu\n", - (unsigned long int) yystacksize)); + YY_IGNORE_USELESS_CAST_BEGIN + YYDPRINTF ((stderr, "Stack size increased to %ld\n", + YY_CAST (long, yystacksize))); + YY_IGNORE_USELESS_CAST_END if (yyss + yystacksize - 1 <= yyssp) YYABORT; } - - YYDPRINTF ((stderr, "Entering state %d\n", yystate)); +#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */ if (yystate == YYFINAL) YYACCEPT; goto yybackup; + /*-----------. | yybackup. | `-----------*/ yybackup: - /* Do appropriate processing given the current state. Read a lookahead token if we need one and don't already have one. */ @@ -1260,15 +1367,13 @@ yybackup: /* Shift the lookahead token. */ YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); - - /* Discard the shifted token. */ - yychar = YYEMPTY; - yystate = yyn; YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN *++yyvsp = yylval; YY_IGNORE_MAYBE_UNINITIALIZED_END + /* Discard the shifted token. */ + yychar = YYEMPTY; goto yynewstate; @@ -1283,7 +1388,7 @@ yydefault: /*-----------------------------. -| yyreduce -- Do a reduction. | +| yyreduce -- do a reduction. | `-----------------------------*/ yyreduce: /* yyn is the number of a rule to reduce with. */ @@ -1303,182 +1408,213 @@ yyreduce: YY_REDUCE_PRINT (yyn); switch (yyn) { - case 2: -#line 40 "as.y" /* yacc.c:1646 */ - { print(pile); printf("addr = %d\n",addr);} -#line 1310 "as.tab.c" /* yacc.c:1646 */ + case 2: +#line 49 "as.y" + { print(); create_asm();} +#line 1415 "as.tab.c" break; case 3: -#line 42 "as.y" /* yacc.c:1646 */ - { printf("Sans Params\n"); } -#line 1316 "as.tab.c" /* yacc.c:1646 */ +#line 51 "as.y" + { printf("Sans Params\n"); } +#line 1421 "as.tab.c" break; case 5: -#line 44 "as.y" /* yacc.c:1646 */ - { printf("Prametre : %s\n", (yyvsp[0].id)); } -#line 1322 "as.tab.c" /* yacc.c:1646 */ +#line 53 "as.y" + { printf("Prametre : %s\n", (yyvsp[0].id)); } +#line 1427 "as.tab.c" break; case 8: -#line 48 "as.y" /* yacc.c:1646 */ - { struct symbole_t symbole = {"Salut", 0x77b58af, INT, 1}; push(symbole, pile); } -#line 1328 "as.tab.c" /* yacc.c:1646 */ +#line 57 "as.y" + { } +#line 1433 "as.tab.c" + break; + + case 11: +#line 62 "as.y" + {reset_temp_vars();} +#line 1439 "as.tab.c" + break; + + case 12: +#line 63 "as.y" + {reset_temp_vars();} +#line 1445 "as.tab.c" + break; + + case 13: +#line 64 "as.y" + {reset_temp_vars();} +#line 1451 "as.tab.c" + break; + + case 14: +#line 65 "as.y" + {reset_temp_vars();} +#line 1457 "as.tab.c" + break; + + case 15: +#line 66 "as.y" + {reset_temp_vars();} +#line 1463 "as.tab.c" break; case 16: -#line 60 "as.y" /* yacc.c:1646 */ - { printf("If reconnu\n"); } -#line 1334 "as.tab.c" /* yacc.c:1646 */ +#line 69 "as.y" + { printf("If reconnu\n"); } +#line 1469 "as.tab.c" break; case 17: -#line 61 "as.y" /* yacc.c:1646 */ - { printf("Else if reconnu\n"); } -#line 1340 "as.tab.c" /* yacc.c:1646 */ +#line 70 "as.y" + { printf("Else if reconnu\n"); } +#line 1475 "as.tab.c" break; case 18: -#line 62 "as.y" /* yacc.c:1646 */ - { printf("Else reconnu\n"); } -#line 1346 "as.tab.c" /* yacc.c:1646 */ +#line 71 "as.y" + { printf("Else reconnu\n"); } +#line 1481 "as.tab.c" break; case 20: -#line 64 "as.y" /* yacc.c:1646 */ - { printf("While reconnu\n"); } -#line 1352 "as.tab.c" /* yacc.c:1646 */ +#line 73 "as.y" + { printf("While reconnu\n"); } +#line 1487 "as.tab.c" break; case 25: -#line 72 "as.y" /* yacc.c:1646 */ - { printf("%s prend une valeur\n", (yyvsp[-3].id)); } -#line 1358 "as.tab.c" /* yacc.c:1646 */ +#line 81 "as.y" + { printf("%s prend une valeur\n", (yyvsp[-3].id));} +#line 1493 "as.tab.c" break; case 26: -#line 74 "as.y" /* yacc.c:1646 */ - { printf("Nombre\n"); } -#line 1364 "as.tab.c" /* yacc.c:1646 */ +#line 83 "as.y" + { int addr = allocate_mem_temp_var(INT); add_operation(AFC, addr,(yyvsp[0].nombre),0); (yyval.nombre) = addr;} +#line 1499 "as.tab.c" break; case 27: -#line 75 "as.y" /* yacc.c:1646 */ - { printf("Nombre exp\n"); } -#line 1370 "as.tab.c" /* yacc.c:1646 */ +#line 85 "as.y" + { printf("Nombre exp\n"); int addr = allocate_mem_temp_var(INT); add_operation(AFC, addr,(yyvsp[0].nombre),0); (yyval.nombre) = addr;} +#line 1505 "as.tab.c" break; case 28: -#line 76 "as.y" /* yacc.c:1646 */ - { printf("Id\n"); } -#line 1376 "as.tab.c" /* yacc.c:1646 */ +#line 86 "as.y" + { printf("Id\n"); /*Faire un get_address sur la pile*/} +#line 1511 "as.tab.c" break; case 29: -#line 77 "as.y" /* yacc.c:1646 */ - { printf("Mul\n"); } -#line 1382 "as.tab.c" /* yacc.c:1646 */ +#line 87 "as.y" + { printf("Mul\n"); int addr = allocate_mem_temp_var(INT); add_operation(MUL, addr,(yyvsp[-2].nombre),(yyvsp[-1].nombre)); (yyval.nombre) = addr;} +#line 1517 "as.tab.c" break; case 30: -#line 78 "as.y" /* yacc.c:1646 */ - { printf("Div\n"); } -#line 1388 "as.tab.c" /* yacc.c:1646 */ +#line 88 "as.y" + { printf("Div\n"); int addr = allocate_mem_temp_var(INT); add_operation(DIV, addr,(yyvsp[-2].nombre),(yyvsp[-1].nombre)); (yyval.nombre) = addr;} +#line 1523 "as.tab.c" break; case 31: -#line 79 "as.y" /* yacc.c:1646 */ - { printf("Sub\n"); } -#line 1394 "as.tab.c" /* yacc.c:1646 */ +#line 89 "as.y" + { printf("Sub\n"); int addr = allocate_mem_temp_var(INT); add_operation(SOU, addr,(yyvsp[-2].nombre),(yyvsp[-1].nombre)); (yyval.nombre) = addr;} +#line 1529 "as.tab.c" break; case 32: -#line 80 "as.y" /* yacc.c:1646 */ - { printf("Add\n"); } -#line 1400 "as.tab.c" /* yacc.c:1646 */ +#line 90 "as.y" + { printf("Add\n"); int addr = allocate_mem_temp_var(INT); add_operation(ADD, addr,(yyvsp[-2].nombre),(yyvsp[-1].nombre)); (yyval.nombre) = addr;} +#line 1535 "as.tab.c" break; case 33: -#line 81 "as.y" /* yacc.c:1646 */ - { printf("Invoc\n"); } -#line 1406 "as.tab.c" /* yacc.c:1646 */ +#line 91 "as.y" + { printf("Invoc\n"); int addr = allocate_mem_temp_var(INT); add_operation(AFC, addr,(yyvsp[0].nombre),0); (yyval.nombre) = addr;} +#line 1541 "as.tab.c" break; case 34: -#line 82 "as.y" /* yacc.c:1646 */ - { printf("Parentheses\n"); } -#line 1412 "as.tab.c" /* yacc.c:1646 */ +#line 92 "as.y" + { printf("Parentheses\n"); (yyval.nombre)=(yyvsp[-1].nombre);} +#line 1547 "as.tab.c" break; case 35: -#line 83 "as.y" /* yacc.c:1646 */ - { printf("Moins\n"); } -#line 1418 "as.tab.c" /* yacc.c:1646 */ +#line 93 "as.y" + { printf("Moins\n"); int addr = allocate_mem_temp_var(INT); add_operation(SOU, 0,addr,0); (yyval.nombre) = addr;} +#line 1553 "as.tab.c" break; case 36: -#line 84 "as.y" /* yacc.c:1646 */ - { printf("==\n"); } -#line 1424 "as.tab.c" /* yacc.c:1646 */ +#line 94 "as.y" + { printf("==\n"); int addr = allocate_mem_temp_var(INT); add_operation(EQU, addr,(yyvsp[-2].nombre),(yyvsp[0].nombre)); (yyval.nombre) = addr;} +#line 1559 "as.tab.c" break; case 37: -#line 85 "as.y" /* yacc.c:1646 */ - { printf(">\n"); } -#line 1430 "as.tab.c" /* yacc.c:1646 */ +#line 95 "as.y" + { printf(">\n"); int addr = allocate_mem_temp_var(INT); add_operation(SUP, addr,(yyvsp[-2].nombre),(yyvsp[0].nombre)); (yyval.nombre) = addr;} +#line 1565 "as.tab.c" break; case 38: -#line 86 "as.y" /* yacc.c:1646 */ - { printf("<\n"); } -#line 1436 "as.tab.c" /* yacc.c:1646 */ +#line 96 "as.y" + { printf("<\n"); int addr = allocate_mem_temp_var(INT); add_operation(INF, addr,(yyvsp[-2].nombre),(yyvsp[0].nombre)); (yyval.nombre) = addr;} +#line 1571 "as.tab.c" break; case 39: -#line 87 "as.y" /* yacc.c:1646 */ - { printf("!\n"); } -#line 1442 "as.tab.c" /* yacc.c:1646 */ +#line 97 "as.y" + { printf("!\n"); } +#line 1577 "as.tab.c" break; case 40: -#line 90 "as.y" /* yacc.c:1646 */ - { printf("Declaration de %s\n", (yyvsp[-2].id)); } -#line 1448 "as.tab.c" /* yacc.c:1646 */ +#line 102 "as.y" + {type_courant = INT; printf("Type int\n");} +#line 1583 "as.tab.c" break; - case 41: -#line 91 "as.y" /* yacc.c:1646 */ - { printf("Declaration de %s (CONSTANTE)\n", (yyvsp[-4].id)); } -#line 1454 "as.tab.c" /* yacc.c:1646 */ - break; - - case 42: -#line 92 "as.y" /* yacc.c:1646 */ - { printf("Declaration de %s\n", (yyvsp[-1].id)); } -#line 1460 "as.tab.c" /* yacc.c:1646 */ + case 43: +#line 107 "as.y" + {push((yyvsp[0].id), 0, type_courant); printf("Suite Decl\n");} +#line 1589 "as.tab.c" break; case 44: -#line 94 "as.y" /* yacc.c:1646 */ - { printf("Declaration avec valeur\n"); } -#line 1466 "as.tab.c" /* yacc.c:1646 */ +#line 108 "as.y" + {int addr = push((yyvsp[-2].id),1, type_courant); add_operation(AFC, addr,(yyvsp[0].nombre),0);} +#line 1595 "as.tab.c" break; case 45: -#line 95 "as.y" /* yacc.c:1646 */ - { printf("Declaration sans valeur\n"); } -#line 1472 "as.tab.c" /* yacc.c:1646 */ +#line 109 "as.y" + { printf("Fin Decl\n");} +#line 1601 "as.tab.c" break; - case 46: -#line 97 "as.y" /* yacc.c:1646 */ - { printf("Appel de printf sur %s\n", (yyvsp[-1].id)); } -#line 1478 "as.tab.c" /* yacc.c:1646 */ + case 47: +#line 112 "as.y" + {int addr = push((yyvsp[-2].id),1, type_courant); add_operation(AFC, addr,(yyvsp[0].nombre),0);} +#line 1607 "as.tab.c" + break; + + case 50: +#line 133 "as.y" + { printf("Appel de printf sur %s\n", (yyvsp[-1].id)); } +#line 1613 "as.tab.c" break; -#line 1482 "as.tab.c" /* yacc.c:1646 */ +#line 1617 "as.tab.c" + default: break; } /* User semantic actions sometimes alter yychar, and that requires @@ -1503,14 +1639,13 @@ yyreduce: /* Now 'shift' the result of the reduction. Determine what state that goes to, based on the state we popped back to and the rule number reduced by. */ - - yyn = yyr1[yyn]; - - yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; - if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) - yystate = yytable[yystate]; - else - yystate = yydefgoto[yyn - YYNTOKENS]; + { + const int yylhs = yyr1[yyn] - YYNTOKENS; + const int yyi = yypgoto[yylhs] + *yyssp; + yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp + ? yytable[yyi] + : yydefgoto[yylhs]); + } goto yynewstate; @@ -1542,7 +1677,7 @@ yyerrlab: { if (yymsg != yymsgbuf) YYSTACK_FREE (yymsg); - yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc); + yymsg = YY_CAST (char *, YYSTACK_ALLOC (YY_CAST (YYSIZE_T, yymsg_alloc))); if (!yymsg) { yymsg = yymsgbuf; @@ -1593,12 +1728,10 @@ yyerrlab: | yyerrorlab -- error raised explicitly by YYERROR. | `---------------------------------------------------*/ yyerrorlab: - - /* Pacify compilers like GCC when the user code never invokes - YYERROR and the label yyerrorlab therefore never appears in user - code. */ - if (/*CONSTCOND*/ 0) - goto yyerrorlab; + /* Pacify compilers when the user code never invokes YYERROR and the + label yyerrorlab therefore never appears in user code. */ + if (0) + YYERROR; /* Do not reclaim the symbols of the rule whose action triggered this YYERROR. */ @@ -1660,6 +1793,7 @@ yyacceptlab: yyresult = 0; goto yyreturn; + /*-----------------------------------. | yyabortlab -- YYABORT comes here. | `-----------------------------------*/ @@ -1667,6 +1801,7 @@ yyabortlab: yyresult = 1; goto yyreturn; + #if !defined yyoverflow || YYERROR_VERBOSE /*-------------------------------------------------. | yyexhaustedlab -- memory exhaustion comes here. | @@ -1677,6 +1812,10 @@ yyexhaustedlab: /* Fall through. */ #endif + +/*-----------------------------------------------------. +| yyreturn -- parsing is finished, return the result. | +`-----------------------------------------------------*/ yyreturn: if (yychar != YYEMPTY) { @@ -1693,7 +1832,7 @@ yyreturn: while (yyssp != yyss) { yydestruct ("Cleanup: popping", - yystos[*yyssp], yyvsp); + yystos[+*yyssp], yyvsp); YYPOPSTACK (1); } #ifndef yyoverflow @@ -1706,7 +1845,7 @@ yyreturn: #endif return yyresult; } -#line 111 "as.y" /* yacc.c:1906 */ +#line 147 "as.y" void main(void) { init(); diff --git a/Lex_Yacc/as.tab.h b/Lex_Yacc/as.tab.h index 7635040..5fbf8d4 100644 --- a/Lex_Yacc/as.tab.h +++ b/Lex_Yacc/as.tab.h @@ -1,8 +1,9 @@ -/* A Bison parser, made by GNU Bison 3.0.4. */ +/* A Bison parser, made by GNU Bison 3.5.1. */ /* Bison interface for Yacc-like parsers in C - Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc. + Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2020 Free Software Foundation, + Inc. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -30,6 +31,9 @@ This special exception was added by the Free Software Foundation in version 2.2 of Bison. */ +/* Undocumented macros, especially those whose name start with YY_, + are private implementation details. Do not rely on them. */ + #ifndef YY_YY_AS_TAB_H_INCLUDED # define YY_YY_AS_TAB_H_INCLUDED /* Debug traces. */ @@ -78,17 +82,16 @@ extern int yydebug; /* Value type. */ #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED - union YYSTYPE { -#line 1 "as.y" /* yacc.c:1909 */ +#line 1 "as.y" int nombre; char id[30]; -#line 90 "as.tab.h" /* yacc.c:1909 */ -}; +#line 93 "as.tab.h" +}; typedef union YYSTYPE YYSTYPE; # define YYSTYPE_IS_TRIVIAL 1 # define YYSTYPE_IS_DECLARED 1 diff --git a/Lex_Yacc/as.y b/Lex_Yacc/as.y index e515647..0af178c 100644 --- a/Lex_Yacc/as.y +++ b/Lex_Yacc/as.y @@ -7,13 +7,10 @@ #include #include #include +#include "../Symboles/tab_instruc.h" #define TAILLE 1024 -int addr = 0; - enum type_t type_courant; -int * tab_instruc = malloc(sizeof(int)*TAILLE); -int index_instruc = 0; %} @@ -22,7 +19,7 @@ int index_instruc = 0; %token tOBRACE tCBRACE %token tINT %token tCONST -%token tPV tCOMA#include +%token tPV tCOMA %token tMUL tDIV tADD tSUB tEQ %token tNB tNBEXP %token tID @@ -39,6 +36,8 @@ int index_instruc = 0; %left tADD tSUB %left tMUL tDIV +%type E Invocation + //%type E @@ -47,7 +46,7 @@ int index_instruc = 0; %% -Main : tINT tMAIN tOBRACE Params tCBRACE Body { print(pile); printf("addr = %d\n",addr);} ; +Main : tINT tMAIN tOBRACE Params tCBRACE Body { print(); create_asm();} ; Params : { printf("Sans Params\n"); } ; Params : Param SuiteParams ; @@ -55,16 +54,16 @@ Param : DeclType tID { printf("Prametre : %s\n", $2); }; SuiteParams : tCOMA Param SuiteParams ; SuiteParams : ; -Body : tOBRACKET Instructions tCBRACKET { struct symbole_t symbole = {"Salut", 0x77b58af, INT, 1}; push(symbole, pile); } ; +Body : tOBRACKET Instructions tCBRACKET { } ; Instructions : Instruction Instructions ; Instructions : ; -Instruction : Aff ; -Instruction : Decl ; -Instruction : Invocation tPV ; -Instruction : If; -Instruction : While; +Instruction : Aff {reset_temp_vars();}; +Instruction : Decl {reset_temp_vars();}; +Instruction : Invocation tPV{reset_temp_vars();}; +Instruction : If {reset_temp_vars();}; +Instruction : While {reset_temp_vars();}; If : tIF tOBRACE Cond tCBRACE Body Else { printf("If reconnu\n"); }; @@ -81,44 +80,57 @@ SuiteCond : tOR E SuiteCond; Aff : tID tEQ E tPV { printf("%s prend une valeur\n", $1);} ; //besoin de get_address -E : tNB { printf("Nombre\n"); - struct symbole_t symbole = ("", addr, INT, 1}; - push(symbole, pile); -$$=addr; - addr++; - printf("AFC %d %d",addr,$1); } ; +E : tNB { int addr = allocate_mem_temp_var(INT); add_operation(AFC, addr,$1,0); $$ = addr;}; -E : tNBEXP { printf("Nombre exp\n"); struct symbole_t symbole = {"", addr, INT, 1}; push(symbole, pile); $$=addr; addr++; printf("AFC %d %d",addr,$1); }; +E : tNBEXP { printf("Nombre exp\n"); int addr = allocate_mem_temp_var(INT); add_operation(AFC, addr,$1,0); $$ = addr;}; E : tID { printf("Id\n"); /*Faire un get_address sur la pile*/}; -E : E tMUL E { printf("Mul\n"); struct symbole_t symbole = {"", addr, INT, 1}; push(symbole, pile); $$=addr; addr++; printf("MUL %d %d %d",addr, $1,$2);}; -E : E tDIV E { printf("Div\n"); struct symbole_t symbole = {"", addr, INT, 1}; push(symbole, pile); $$=addr; addr++; printf("DIV %d %d %d",addr, $1,$2);}; -E : E tSUB E { printf("Sub\n"); struct symbole_t symbole = {"", addr, INT, 1}; push(symbole, pile); $$=addr; addr++; printf("SOU %d %d %d",addr, $1,$2);}; -E : E tADD E { printf("Add\n"); struct symbole_t symbole = {"", addr, INT, 1}; push(symbole, pile); $$=addr; addr++; printf("ADD %d %d %d",addr, $1,$2);}}; -E : Invocation { printf("Invoc\n"); struct symbole_t symbole = {"", addr, INT, 1}; push(symbole, pile); $$=addr; addr++; printf("AFC %d %d",addr, $1);}; -E : tOBRACE E tCBRACE { printf("Parentheses\n"); $$=$2}; -E : tSUB E { printf("Moins\n"); printf("SUB %d 0 %d",addr,$2);}; -E : E tEQCOND E { printf("==\n"); struct symbole_t symbole = {"", addr, INT, 1}; push(symbole, pile); $$=addr; addr++; printf("EQU %d %d %d",addr, $1,$3);}; -E : E tGT E { printf(">\n"); struct symbole_t symbole = {"", addr, INT, 1}; push(symbole, pile); $$=addr; addr++; printf("SUP %d %d %d",addr, $1,$3);}; -E : E tLT E { printf("<\n"); struct symbole_t symbole = {"", addr, INT, 1}; push(symbole, pile); $$=addr; addr++; printf("SUP %d %d %d",addr, $1,$3);}; +E : E tMUL E { printf("Mul\n"); int addr = allocate_mem_temp_var(INT); add_operation(MUL, addr,$1,$2); $$ = addr;}; +E : E tDIV E { printf("Div\n"); int addr = allocate_mem_temp_var(INT); add_operation(DIV, addr,$1,$2); $$ = addr;}; +E : E tSUB E { printf("Sub\n"); int addr = allocate_mem_temp_var(INT); add_operation(SOU, addr,$1,$2); $$ = addr;}; +E : E tADD E { printf("Add\n"); int addr = allocate_mem_temp_var(INT); add_operation(ADD, addr,$1,$2); $$ = addr;}; +E : Invocation { printf("Invoc\n"); int addr = allocate_mem_temp_var(INT); add_operation(AFC, addr,$1,0); $$ = addr;}; +E : tOBRACE E tCBRACE { printf("Parentheses\n"); $$=$2;}; +E : tSUB E { printf("Moins\n"); int addr = allocate_mem_temp_var(INT); add_operation(SOU, 0,addr,0); $$ = addr;}; +E : E tEQCOND E { printf("==\n"); int addr = allocate_mem_temp_var(INT); add_operation(EQU, addr,$1,$3); $$ = addr;}; +E : E tGT E { printf(">\n"); int addr = allocate_mem_temp_var(INT); add_operation(SUP, addr,$1,$3); $$ = addr;}; +E : E tLT E { printf("<\n"); int addr = allocate_mem_temp_var(INT); add_operation(INF, addr,$1,$3); $$ = addr;}; E : tNOT E { printf("!\n"); }; //Créer un champ isConst dans la table des symboles +DeclType : tINT {type_courant = INT; printf("Type int\n");} ; + +Decl : DeclType SuiteDecl FinDecl ; +Decl : tCONST DeclType SuiteDeclConst FinDeclConst; + +SuiteDecl : tID {push($1, 0, type_courant); printf("Suite Decl\n");}; +SuiteDecl : tID tEQ E {int addr = push($1,1, type_courant); add_operation(AFC, addr,$3,0);}; +FinDecl : tPV { printf("Fin Decl\n");}; +FinDecl : tCOMA SuiteDecl FinDecl ; + +SuiteDeclConst : tID tEQ E {int addr = push($1,1, type_courant); add_operation(AFC, addr,$3,0);}; +FinDeclConst : tPV; +FinDeclConst : tCOMA SuiteDeclConst FinDeclConst; + + +/* //Créer un champ isConst dans la table des symboles +DeclType : tINT {type_courant = INT; printf("Type int\n");} ; + Decl : tCONST DeclType SuiteDeclConst { } ; SuiteDeclConst : tCOMA tID SuiteDeclConst ; SuiteDeclConst : tEQ E tPV { }; SuiteDeclConst : tPV { }; -DeclType : tINT {type_courant = INT;} ; Decl : DeclType Decl SuiteDecl { } ; Decl : tID {push($1, 0, type_courant);}; -Decl : tID tEQ E {push($1,1, type_courant);} ; +Decl : tID tEQ E {int addr = push($1,1, type_courant); add_operation(AFC, addr,$3,0);} ; SuiteDecl : tCOMA Decl SuiteDecl { }; SuiteDecl : tPV { }; +*/ -Invocation : tPRINTF tOBRACE tID tCBRACE { printf("Appel de printf sur %s\n", $3); } ; +Invocation : tPRINTF tOBRACE tID tCBRACE { printf("Appel de printf sur %s\n", $3); } ; /*S : E tPV { printf("RES: %d\n", $1); } diff --git a/Lex_Yacc/comp.sh b/Lex_Yacc/comp.sh index b63a0e4..ab84a81 100755 --- a/Lex_Yacc/comp.sh +++ b/Lex_Yacc/comp.sh @@ -1,5 +1,4 @@ bison -d -t as.y -v flex al.lex -gcc *.c ../Symboles/table_symboles.c -ly -cat ../Fichiers_Tests/progC | ./a.out - +gcc as.tab.c lex.yy.c ../Symboles/tab_instruc.c ../Symboles/table_symboles.c -ll -o a.exe +cat ./ProgC | ./a.exe diff --git a/Lex_Yacc/lex.yy.c b/Lex_Yacc/lex.yy.c index f1f2fb5..8089a6b 100644 --- a/Lex_Yacc/lex.yy.c +++ b/Lex_Yacc/lex.yy.c @@ -483,8 +483,15 @@ char *yytext; #line 2 "al.lex" #include "as.tab.h" int yywrap(void){return 1;} -#line 487 "lex.yy.c" -#line 488 "lex.yy.c" +void +yyerror (char const *s) +{ + + fprintf (stderr, "%s\n", s); +} + +#line 494 "lex.yy.c" +#line 495 "lex.yy.c" #define INITIAL 0 @@ -701,10 +708,10 @@ YY_DECL } { -#line 6 "al.lex" +#line 13 "al.lex" -#line 708 "lex.yy.c" +#line 715 "lex.yy.c" while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ { @@ -763,161 +770,161 @@ do_action: /* This label is used only to access EOF actions. */ case 1: YY_RULE_SETUP -#line 8 "al.lex" +#line 15 "al.lex" { return tMAIN ;} YY_BREAK case 2: YY_RULE_SETUP -#line 9 "al.lex" +#line 16 "al.lex" { return tOBRACKET;} YY_BREAK case 3: YY_RULE_SETUP -#line 10 "al.lex" +#line 17 "al.lex" { return tCBRACKET; } YY_BREAK case 4: YY_RULE_SETUP -#line 11 "al.lex" +#line 18 "al.lex" { return tOBRACE; } YY_BREAK case 5: YY_RULE_SETUP -#line 12 "al.lex" +#line 19 "al.lex" { return tCBRACE; } YY_BREAK case 6: YY_RULE_SETUP -#line 13 "al.lex" +#line 20 "al.lex" { return tCONST; } YY_BREAK case 7: YY_RULE_SETUP -#line 14 "al.lex" +#line 21 "al.lex" { return tINT; } YY_BREAK case 8: YY_RULE_SETUP -#line 15 "al.lex" +#line 22 "al.lex" { return tPRINTF; } //Degeu mais à degager YY_BREAK case 9: YY_RULE_SETUP -#line 16 "al.lex" +#line 23 "al.lex" { return tIF; } YY_BREAK case 10: YY_RULE_SETUP -#line 17 "al.lex" +#line 24 "al.lex" { return tWHILE; } YY_BREAK case 11: YY_RULE_SETUP -#line 18 "al.lex" +#line 25 "al.lex" { return tLT; } YY_BREAK case 12: YY_RULE_SETUP -#line 19 "al.lex" +#line 26 "al.lex" { return tGT; } YY_BREAK case 13: YY_RULE_SETUP -#line 20 "al.lex" +#line 27 "al.lex" { return tEQCOND; } YY_BREAK case 14: YY_RULE_SETUP -#line 21 "al.lex" +#line 28 "al.lex" { return tAND; } YY_BREAK case 15: YY_RULE_SETUP -#line 22 "al.lex" +#line 29 "al.lex" { return tOR; } YY_BREAK case 16: YY_RULE_SETUP -#line 23 "al.lex" +#line 30 "al.lex" { return tELSE;} YY_BREAK case 17: YY_RULE_SETUP -#line 26 "al.lex" +#line 33 "al.lex" { yylval.nombre = atoi(yytext); return tNB; } YY_BREAK case 18: YY_RULE_SETUP -#line 27 "al.lex" +#line 34 "al.lex" { yylval.nombre = -1; return tNBEXP; } //Renvoyer le token tNB et pas tNBEXP YY_BREAK case 19: YY_RULE_SETUP -#line 28 "al.lex" +#line 35 "al.lex" { return tADD; } YY_BREAK case 20: YY_RULE_SETUP -#line 29 "al.lex" +#line 36 "al.lex" { return tSUB; } YY_BREAK case 21: YY_RULE_SETUP -#line 30 "al.lex" +#line 37 "al.lex" { return tMUL; } YY_BREAK case 22: YY_RULE_SETUP -#line 31 "al.lex" +#line 38 "al.lex" { return tDIV; } YY_BREAK case 23: YY_RULE_SETUP -#line 32 "al.lex" +#line 39 "al.lex" { return tEQ; } YY_BREAK case 24: YY_RULE_SETUP -#line 33 "al.lex" +#line 40 "al.lex" { return tPV; } YY_BREAK case 25: YY_RULE_SETUP -#line 34 "al.lex" +#line 41 "al.lex" {} //Ne pas les retourner à Yacc YY_BREAK case 26: YY_RULE_SETUP -#line 35 "al.lex" +#line 42 "al.lex" {} //Ne pas les retourner à Yacc YY_BREAK case 27: YY_RULE_SETUP -#line 36 "al.lex" +#line 43 "al.lex" { return tCOMA; } YY_BREAK case 28: /* rule 28 can match eol */ YY_RULE_SETUP -#line 37 "al.lex" +#line 44 "al.lex" {} //Ne pas les retourner à Yacc YY_BREAK case 29: YY_RULE_SETUP -#line 38 "al.lex" +#line 45 "al.lex" { strcpy(yylval.id, yytext); return tID; } YY_BREAK case 30: YY_RULE_SETUP -#line 39 "al.lex" +#line 46 "al.lex" { return tERROR; } YY_BREAK case 31: YY_RULE_SETUP -#line 41 "al.lex" +#line 48 "al.lex" ECHO; YY_BREAK -#line 921 "lex.yy.c" +#line 928 "lex.yy.c" case YY_STATE_EOF(INITIAL): yyterminate(); @@ -1922,7 +1929,7 @@ void yyfree (void * ptr ) #define YYTABLES_NAME "yytables" -#line 41 "al.lex" +#line 48 "al.lex" diff --git a/Lex_Yacc/lex.yy.o b/Lex_Yacc/lex.yy.o new file mode 100644 index 0000000..77f1f61 Binary files /dev/null and b/Lex_Yacc/lex.yy.o differ diff --git a/Lex_Yacc/output.txt b/Lex_Yacc/output.txt new file mode 100644 index 0000000..e69de29 diff --git a/Symboles/tab_instruc.c b/Symboles/tab_instruc.c index e69de29..a08a36e 100644 --- a/Symboles/tab_instruc.c +++ b/Symboles/tab_instruc.c @@ -0,0 +1,68 @@ +#include "tab_instruc.h" +int current_index = 0; +struct operation_t tab_op[MAXTAILLE]; + +void add_operation(enum opcode_t opcode, int arg1, int arg2, int arg3){ + if (current_index == MAXTAILLE){ + printf("Taillemax tableau operations atteinte\n"); + } + else{ + struct operation_t new_op = {opcode, arg1, arg2, arg3}; + tab_op[current_index] = new_op; + current_index++; + } +} + + + +char * get_asm_line_from_op(struct operation_t op){ + char * buffer = malloc(sizeof(char)*200); + switch (op.opcode){ + case (ADD): + sprintf(buffer,"ADD %d %d %d\n",op.arg1, op.arg2, op.arg3); + break; + case (MUL): + sprintf(buffer,"MUL %d %d %d\n",op.arg1, op.arg2, op.arg3); + break; + case (SOU): + sprintf(buffer,"SOU %d %d %d\n",op.arg1, op.arg2, op.arg3); + break; + case (DIV): + sprintf(buffer,"DIV %d %d %d\n",op.arg1, op.arg2, op.arg3); + break; + case (COP): + sprintf(buffer,"COP %d %d\n",op.arg1, op.arg2); + break; + case (AFC): + sprintf(buffer,"AFC %d %d\n",op.arg1, op.arg2); + break; + case (JMP): + sprintf(buffer,"JMP %d\n",op.arg1); + break; + case (JMF): + sprintf(buffer,"JMF %d %d\n",op.arg1, op.arg2); + break; + case (INF): + sprintf(buffer,"INF %d %d %d\n",op.arg1, op.arg2, op.arg3); + break; + case (SUP): + sprintf(buffer,"SUP %d %d %d\n",op.arg1, op.arg2, op.arg3); + break; + case (EQU): + sprintf(buffer,"DIV %d %d %d\n",op.arg1, op.arg2, op.arg3); + break; + case (PRI): + sprintf(buffer,"PRI %d\n",op.arg1); + break; + } + return buffer; +} + +void create_asm(){ + FILE * output = fopen("output.txt","w"); + for (int i = 0; i < current_index; i++){ + char * line = get_asm_line_from_op(tab_op[i]); + fputs(line, output); + free(line); + } +} diff --git a/Symboles/tab_instruc.h b/Symboles/tab_instruc.h index 3495914..f6c0497 100644 --- a/Symboles/tab_instruc.h +++ b/Symboles/tab_instruc.h @@ -1,5 +1,19 @@ - -enum instructions_t {ADD,SUB} +#define MAXTAILLE 1024 +#include +#include +#include -void add_operation(struct instructions_t inst, int * argv, int argv); +enum opcode_t {ADD,MUL,SOU,DIV,COP,AFC,JMP,JMF,INF,SUP,EQU,PRI}; + +struct operation_t { + enum opcode_t opcode; + int arg1; + int arg2; + int arg3; +}; + +extern struct operation_t tab_op[MAXTAILLE]; + +void add_operation(enum opcode_t opcode, int arg1, int arg2, int arg3); +void create_asm(); diff --git a/Symboles/tab_instruc.o b/Symboles/tab_instruc.o new file mode 100644 index 0000000..c46c762 Binary files /dev/null and b/Symboles/tab_instruc.o differ diff --git a/Symboles/table_symboles.c b/Symboles/table_symboles.c index f327e90..5d9f6df 100644 --- a/Symboles/table_symboles.c +++ b/Symboles/table_symboles.c @@ -30,8 +30,12 @@ Opérations possible : #include #include #include +#define MAXADDR 1024*5 int last_addr = 0; +int temp_addr = MAXADDR; +int taille_types[] = {-1, 4}; +int profondeur = 0; struct element_t { struct symbole_t symbole; @@ -42,7 +46,6 @@ struct pile_t { int taille; struct element_t * first; }; -* struct pile_t * pile; char * type_to_string(enum type_t type) { @@ -67,16 +70,21 @@ void init (void) { pile->taille = 0; } -void push(char * nom, int isInit, enum type_t type) { +int push(char * nom, int isInit, enum type_t type) { struct element_t * aux = malloc(sizeof(struct element_t)); + struct symbole_t symbole = {"", last_addr, type, isInit,profondeur}; + strcpy(symbole.nom,nom); aux->symbole = symbole; aux->suivant = pile->first; pile->first = aux; pile->taille++; + int addr_var = last_addr; + last_addr += taille_types[type]; + return addr_var; } struct symbole_t pop() { - struct symbole_t retour = {"", 0, UNKNOWN, 0}; + struct symbole_t retour = {"", 0, UNKNOWN, 0, 0}; struct element_t * aux; if (pile->taille > 0) { aux = pile->first; @@ -84,6 +92,7 @@ struct symbole_t pop() { retour = aux->symbole; free(aux); pile->taille--; + last_addr -= taille_types[retour.type]; } return retour; } @@ -107,13 +116,13 @@ char status(char * nom) { return retour; } -struct symbole_t * getVariable(char * nom){ +struct symbole_t * get_variable(char * nom){ struct symbole_t * retour = NULL; struct element_t * aux = pile->first; int i; for (i=0; i < pile->taille; i++) { if (!strcmp(nom, aux->symbole.nom)) { - retour = element_t; + retour = &aux->symbole; break; } else { aux = aux->suivant; @@ -135,3 +144,19 @@ void print() { aux = aux->suivant; } } + + +int get_last_addr(){ + return last_addr; +} + + +int allocate_mem_temp_var(enum type_t type){ + temp_addr -= taille_types[type]; + return temp_addr; +} + +void reset_temp_vars(){ + temp_addr = MAXADDR; +} + diff --git a/Symboles/table_symboles.h b/Symboles/table_symboles.h index f101cd5..fa6ab00 100644 --- a/Symboles/table_symboles.h +++ b/Symboles/table_symboles.h @@ -28,9 +28,8 @@ Opérations possible : #include enum type_t {UNKNOWN, INT}; -int taille_types[] = {-1, 4}; - -char * tab_instructions[2] = {"ADD %d %d", "SUB %d %d"} +extern int taille_types[]; +extern int profondeur; struct symbole_t { char nom[30]; @@ -42,11 +41,14 @@ struct symbole_t { void print_symbole(struct symbole_t symbole); -int profondeur = 0; void init(void); -void push(struct symbole_t symbole, struct pile_t * pile); -struct symbole_t pop(struct pile_t * pile); +int push(char * nom, int isInit, enum type_t type); +struct symbole_t pop(); // renvoi 0 si nom n'existe pas, 2 si nom existe sans etre initialisée, 1 sinon -char status(char * nom, struct pile_t * pile); -void print(struct pile_t * pile); +char status(char * nom); +void print(); +int get_last_addr(); +struct symbole_t * get_variable(char * nom); +int allocate_mem_temp_var(enum type_t type); +void reset_temp_vars(); diff --git a/Symboles/table_symboles.o b/Symboles/table_symboles.o index 093f0a3..ef7d85a 100644 Binary files a/Symboles/table_symboles.o and b/Symboles/table_symboles.o differ