No Description
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

analyse_syntaxique.y 5.3KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203
  1. %union {
  2. int nombre;
  3. char id[30];
  4. }
  5. %{
  6. #include <stdio.h>
  7. #include "table_symboles.h"
  8. #include "gen_assembleur.h"
  9. enum Initialised_Variable init;
  10. enum Symbole_Type type;
  11. Table_Symboles table;
  12. instructions_array array;
  13. int whileCondition;
  14. %}
  15. %token<nombre> tENTIER
  16. %token<nombre> tENTIEREXP
  17. %type<nombre> E
  18. %type<nombre> Return
  19. %type<nombre> Cond
  20. %type<nombre> While
  21. %token tADD
  22. %token tSUB
  23. %token tMUL
  24. %token tDIV
  25. %token<nombre> tPO
  26. %token tPF
  27. %token tAO
  28. %token tAF
  29. %token tERROR
  30. %token tPV
  31. %token tVIRGULE
  32. %token tAFFECTATION
  33. %token tEGAL
  34. %token tDIFF
  35. %token tLT
  36. %token tGT
  37. %token tGTE
  38. %token tLTE
  39. %token tMAIN
  40. %token tINT
  41. %token tPRINT
  42. %token tRETURN
  43. %token tOR
  44. %token tAND
  45. %token<nombre> tIF
  46. %token tELSE
  47. %token<nombre> tWHILE
  48. %token tCONST
  49. %token<id> tVAR
  50. %token tNOT
  51. %left tADD
  52. %left tSUB
  53. %left tMUL
  54. %left tDIV
  55. %right tEGAL
  56. %%
  57. //C : Fonctions Main ;
  58. //Fonctions : Fonction Fonctions | ;
  59. //Fonction : tINT tVAR tPO Params tPF Body;
  60. Main : tINT tMAIN tPO Params tPF Body {};
  61. Params : {printf("Sans params\n");} ;
  62. Params : Param SuiteParams ;
  63. Param : tINT tVAR {printf("Parametre : %s\n", $2);} ;
  64. SuiteParams : tVIRGULE Param SuiteParams tPV ;
  65. SuiteParams : ;
  66. Body : tAO Instructions Return tAF {printf("Dans body\n");} ;
  67. Instructions : Instruction Instructions ;
  68. Instructions : ;
  69. Instruction : Aff ;
  70. Instruction : If ;
  71. Instruction : While ;
  72. Instruction : Print ;
  73. Instruction : Decl ;
  74. Instruction : Invocation tPV ;
  75. Decl : Type Valeur SuiteDecl tPV ;
  76. SuiteDecl: tVIRGULE Valeur SuiteDecl ;
  77. SuiteDecl: ;
  78. Type : tINT {type = TYPE_INT;} ;
  79. Type : tCONST tINT {type = TYPE_CONST_INT;} ;
  80. Valeur : tVAR {add_symbole_top(&table, $1, type, INITIALISED, table.depth);} tAFFECTATION E {int varAddr = variable_exists(&table, $1); generate_instruction_2(&array, COP, $4, varAddr); free_temp(&table);};
  81. Valeur : tVAR {add_symbole_top(&table, $1, type, NOT_INITIALISED, table.depth);};
  82. Aff : tVAR tAFFECTATION E tPV {int varAddr = variable_exists(&table, $1); generate_instruction_2(&array, COP, $3, varAddr); free_temp(&table);};
  83. //E : tENTIER {int vt = gen_entier(&table, &array, $1); $$ = vt;};
  84. E : tENTIER {int vt = new_temp(&table); generate_instruction_2(&array, AFC, vt, $1); $$ = vt;};
  85. //E : tVAR {int vt = gen_var(&table, &array, $1); $$ = vt;};
  86. E : tVAR {int vt = new_temp(&table); int varAddr = variable_exists(&table, $1); generate_instruction_2(&array, COP, varAddr, vt); $$ = vt;};
  87. //E : E tADD E {gen_arithmetique(&array, ADD, $1, $3); free_temp(&table); $$ = $1;} ;
  88. E : E tADD E {generate_instruction_3(&array, ADD, $1, $1, $3); free_temp(&table); $$ = $1;} ;
  89. E : E tMUL E {generate_instruction_3(&array, MUL, $1, $1, $3); free_temp(&table); $$ = $1;} ;
  90. E : E tSUB E {generate_instruction_3(&array, SOU, $1, $1, $3); free_temp(&table); $$ = $1;} ;
  91. E : E tDIV E {generate_instruction_3(&array, DIV, $1, $1, $3); free_temp(&table); $$ = $1;} ;
  92. E : tSUB E {printf("Variable negative\n");} ;
  93. E : Invocation {$$ = 1234;};
  94. E : tPO E tPF {printf("Parenthèse\n"); $$ = $2; } ;
  95. Args : tVAR SuiteArgs ;
  96. Args : ;
  97. SuiteArgs : tVIRGULE tVAR SuiteArgs ;
  98. SuiteArgs : ;
  99. If : tIF tPO Cond tPF {
  100. //gen_jmpf(&table, &array, $3, -1);
  101. generate_instruction_2(&array, JMF, $3, -1);
  102. free_temp(&table);
  103. $1 = array.index;
  104. }
  105. tAO Instructions tAF
  106. {
  107. int adr_jmp = array.index;
  108. update_jmf(&array, $1, adr_jmp);
  109. }
  110. Else {};
  111. Else : tELSE tAO Instructions tAF {printf("else\n");} ;
  112. Else : ;
  113. Else : tELSE tIF tPO Cond tPF tAO Instructions tAF Else {printf("elsif\n");} ;
  114. While : tWHILE tPO {
  115. $2 = array.index ;
  116. } Cond tPF {
  117. //gen_jmpf(&table, &array, $4, -1);
  118. generate_instruction_2(&array, JMF, $4, -1);
  119. free_temp(&table);
  120. $1 = array.index;
  121. }
  122. tAO Instructions tAF {
  123. int adr_jmp = array.index;
  124. update_jmf(&array, $1, adr_jmp);
  125. //gen_jmpf(&table, &array, $1, $2);
  126. generate_instruction_1(&array, JMP, $2);
  127. };
  128. //Cond : E tEGAL E {int vt = gen_condition(&table, &array, EQ, $1, $3); $$ = vt;} ;
  129. Cond : E tEGAL E {generate_instruction_3(&array, EQ, $1, $1, $3); free_temp(&table); $$ = $3;};
  130. Cond : E tDIFF E {generate_instruction_3(&array, NEQ, $1, $1, $3); free_temp(&table); $$ = $3;} ;
  131. Cond : E tLT E {generate_instruction_3(&array, LT, $1, $1, $3); free_temp(&table); $$ = $3;} ;
  132. Cond : E tGT E {generate_instruction_3(&array, GT, $1, $1, $3); free_temp(&table); $$ = $3;} ;
  133. Cond : E tLTE E {generate_instruction_3(&array, LTE, $1, $1, $3); free_temp(&table); $$ = $3;} ;
  134. Cond : E tGTE E {generate_instruction_3(&array, GTE, $1, $1, $3); free_temp(&table); $$ = $3;} ;
  135. Cond : E tAND E {generate_instruction_3(&array, AND, $1, $1, $3); free_temp(&table); $$ = $3;} ;
  136. Cond : E tOR E {generate_instruction_3(&array, OR, $1, $1, $3); free_temp(&table); $$ = $3;} ;
  137. Cond : tNOT Cond {generate_instruction_2(&array, NOT, $2, $2); $$ = $2;} ;
  138. Cond : E {$$ = $1; };
  139. Invocation : tVAR tPO Args tPF {printf("Dans invocation\n");};
  140. //Print : tPRINT tPO E tPF tPV {gen_print(&table, &array, $3);};
  141. Print : tPRINT tPO E tPF tPV {generate_instruction_1(&array, PRI, $3); free_temp(&table);};
  142. //Return : tRETURN E tPV {$$ = gen_return(&table, &array, $2);};
  143. Return : tRETURN E tPV {$$ = generate_instruction_1(&array, RET, $2); free_temp(&table);};
  144. %%
  145. #include <stdio.h>
  146. void main(void){
  147. //TODO: rajouter gestion des erreurs
  148. initialise_table(&table);
  149. initialise_asm(&array);
  150. yyparse();
  151. print_table(&table);
  152. //remove_symboles(&table, 0);
  153. //print_table(&table);
  154. exportInstructions(&array);
  155. }