Xawirses/compilateur-l
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Panini 4 cancers

Browse Source
This commit is contained in:
Xawirses
2016-03-15 16:02:12 +01:00
parent bef11c0984
commit 876044dc6a
11 changed files with 202 additions and 146 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
header/affiche_table_symbole.h
View File

@@ -1,36 +0,0 @@
#ifndef __affiche_ARBRE_ABSTRAIT__
#define __affiche_ARBRE_ABSTRAIT__
#include "syntabs.h"
#include "dico.h"
void affiche_t_table(n_prog *n);
void affiche_t_l_instr(n_l_instr *n);
void affiche_t_instr(n_instr *n);
void affiche_t_instr_si(n_instr *n);
void affiche_t_instr_tantque(n_instr *n);
void affiche_t_instr_faire(n_instr *n);
void affiche_t_instr_pour(n_instr *n);
void affiche_t_instr_affect(n_instr *n);
void affiche_t_instr_appel(n_instr *n);
void affiche_t_instr_retour(n_instr *n);
void affiche_t_instr_ecrire(n_instr *n);
int affiche_t_l_exp(n_l_exp *n);
void affiche_t_exp(n_exp *n);
void affiche_t_varExp(n_exp *n);
void affiche_t_opExp(n_exp *n);
void affiche_t_intExp(n_exp *n);
void affiche_t_lireExp(n_exp *n);
void affiche_t_appelExp(n_exp *n);
void affiche_t_l_dec(n_l_dec *n);
void affiche_t_dec(n_dec *n);
void affiche_t_foncDec(n_dec *n);
void affiche_t_varDec(n_dec *n);
void affiche_t_tabDec(n_dec *n);
void affiche_t_var(n_var *n);
void affiche_t_var_simple(n_var *n);
void affiche_t_var_indicee(n_var *n);
void affiche_t_appel(n_appel *n);
#endif

38
header/parcours.h Normal file
View File

@@ -0,0 +1,38 @@
#ifndef __PARCOURS__
#define __PARCOURS__
#include "syntabs.h"
#include "dico.h"
void printMips( const char * msg );
void parcours_table(n_prog *n);
void parcours_l_instr(n_l_instr *n);
void parcours_instr(n_instr *n);
void parcours_instr_si(n_instr *n);
void parcours_instr_tantque(n_instr *n);
void parcours_instr_faire(n_instr *n);
void parcours_instr_pour(n_instr *n);
void parcours_instr_affect(n_instr *n);
void parcours_instr_appel(n_instr *n);
void parcours_instr_retour(n_instr *n);
void parcours_instr_ecrire(n_instr *n);
void parcours_l_exp(n_l_exp *n);
int parcours_exp(n_exp *n);
int parcours_varExp(n_exp *n);
int parcours_opExp(n_exp *n);
int parcours_intExp(n_exp *n);
int parcours_lireExp(n_exp *n);
int parcours_appelExp(n_exp *n);
void parcours_l_dec(n_l_dec *n);
void parcours_dec(n_dec *n);
void parcours_foncDec(n_dec *n);
void parcours_varDec(n_dec *n);
void parcours_tabDec(n_dec *n);
void parcours_var(n_var *n);
void parcours_var_simple(n_var *n);
void parcours_var_indicee(n_var *n);
void parcours_appel(n_appel *n);
#endif

24
src/compilateur-l.c
View File

@@ -3,16 +3,19 @@
#include "analyseur_lexical.h"
#include "analyseur_syntaxyque.h"
#include "affiche_arbre_abstrait.h"
#include "affiche_table_symbole.h"
#include "parcours.h"
#include "symboles.h"
#define A_LEXI 1
#define A_SYNT 2
#define A_ABST 3
#define A_SYMB 4
#define A_MIPS 5
extern int uniteCourante;
extern int afficheSyntaxyque;
extern int afficheDico;
extern int afficheMips;
char yytext[100];
FILE *yyin;
@@ -25,6 +28,7 @@ void usage()
printf("./compilateur-l -s fileName\n");
printf("./compilateur-l -a fileName\n");
printf("./compilateur-l -t fileName\n");
printf("./compilateur-l -m fileName\n");
printf("./compilateur-l fileName\n");
exit (8);
}
@@ -32,7 +36,7 @@ void usage()
int main(int argc, char **argv) {
int sortie = A_SYMB;
int sortie = A_MIPS;
while ((argc > 1) && (argv[1][0] == '-'))
{
switch (argv[1][1])
@@ -53,6 +57,10 @@ int main(int argc, char **argv) {
sortie = A_SYMB;
break;
case 'm':
sortie = A_MIPS;
break;
default:
printf("Wrong Argument: %s\n", argv[1]);
usage();
@@ -93,9 +101,19 @@ int main(int argc, char **argv) {
case A_SYMB:
initialise_premiers();
initialise_suivants();
afficheDico = 1;
uniteCourante = yylex();
p = programme();
affiche_t_table(p);
parcours_table(p);
break;
case A_MIPS:
initialise_premiers();
initialise_suivants();
afficheMips = 1;
uniteCourante = yylex();
p = programme();
parcours_table(p);
break;
default:

56
src/dico.c
View File

@@ -1,5 +1,7 @@
#include "dico.h"
int afficheDico = 0;
/*-------------------------------------------------------------------------*/
void entreeFonction(void){
@@ -65,33 +67,35 @@ int rechercheDeclarative(char *identif)
void affiche_dico(void)
{
int i;
printf("------------------------------------------\n");
printf("base = %d\n", dico.base);
printf("sommet = %d\n", dico.sommet);
for(i=0; i < dico.sommet; i++){
printf("%d ", i);
printf("%s ", dico.tab[i].identif);
if(dico.tab[i].classe == C_VARIABLE_GLOBALE)
printf("GLOBALE ");
else
if(dico.tab[i].classe == C_VARIABLE_LOCALE)
printf("LOCALE ");
else
if(dico.tab[i].classe == C_ARGUMENT)
printf("ARGUMENT ");
if(afficheDico) {
int i;
printf("------------------------------------------\n");
printf("base = %d\n", dico.base);
printf("sommet = %d\n", dico.sommet);
for(i=0; i < dico.sommet; i++){
printf("%d ", i);
printf("%s ", dico.tab[i].identif);
if(dico.tab[i].classe == C_VARIABLE_GLOBALE)
printf("GLOBALE ");
else
if(dico.tab[i].classe == C_VARIABLE_LOCALE)
printf("LOCALE ");
else
if(dico.tab[i].classe == C_ARGUMENT)
printf("ARGUMENT ");
if(dico.tab[i].type == T_ENTIER)
printf("ENTIER ");
else if(dico.tab[i].type == T_TABLEAU_ENTIER)
printf("TABLEAU ");
/* else if(dico.tab[i].type == _ARGUMENT) */
/* printf("ARGUMENT "); */
else if(dico.tab[i].type == T_FONCTION)
printf("FONCTION ");
if(dico.tab[i].type == T_ENTIER)
printf("ENTIER ");
else if(dico.tab[i].type == T_TABLEAU_ENTIER)
printf("TABLEAU ");
/* else if(dico.tab[i].type == _ARGUMENT) */
/* printf("ARGUMENT "); */
else if(dico.tab[i].type == T_FONCTION)
printf("FONCTION ");
printf("%d ", dico.tab[i].adresse);
printf("%d\n", dico.tab[i].complement);
printf("%d ", dico.tab[i].adresse);
printf("%d\n", dico.tab[i].complement);
}
printf("------------------------------------------\n");
}
printf("------------------------------------------\n");
}

188
src/affiche_table_symbole.c → src/parcours.c
View File

@@ -1,20 +1,34 @@
#include <stdio.h>
#include "affiche_table_symbole.h"
#include "parcours.h"
#include "syntabs.h"
#include "util.h"
#include "parcours.h"
int contexte = C_VARIABLE_GLOBALE;
int adresseGlobalCourante = 0;
int adresseLocaleCourante = 0;
int adresseArgumentCourant = 0;
int afficheMips = 0;
int creg = 0;
extern dico_ dico;
void printMips( const char * msg ) {
if(afficheMips)
printf("%s\n", msg);
}
int newReg() {
return creg++%10;
}
/*-------------------------------------------------------------------------*/
void affiche_t_table(n_prog *n)
void parcours_table(n_prog *n)
{
affiche_t_l_dec(n->variables);
affiche_t_l_dec(n->fonctions);
printMips(".data");
parcours_l_dec(n->variables);
printMips(".text");
parcours_l_dec(n->fonctions);
int id = rechercheExecutable("main");
if(id < 0 || dico.tab[id].complement != 0) {
@@ -26,85 +40,85 @@ void affiche_t_table(n_prog *n)
/*-------------------------------------------------------------------------*/
void affiche_t_l_instr(n_l_instr *n)
void parcours_l_instr(n_l_instr *n)
{
if(n) {
affiche_t_instr(n->tete);
affiche_t_l_instr(n->queue);
parcours_instr(n->tete);
parcours_l_instr(n->queue);
}
}
/*-------------------------------------------------------------------------*/
void affiche_t_instr(n_instr *n)
int parcours_instr(n_instr *n)
{
if(n) {
if(n->type == blocInst) affiche_t_l_instr(n->u.liste);
else if(n->type == affecteInst) affiche_t_instr_affect(n);
else if(n->type == siInst) affiche_t_instr_si(n);
else if(n->type == tantqueInst) affiche_t_instr_tantque(n);
else if(n->type == faireInst) affiche_t_instr_faire(n);
else if(n->type == pourInst) affiche_t_instr_pour(n);
else if(n->type == appelInst) affiche_t_instr_appel(n);
else if(n->type == retourInst) affiche_t_instr_retour(n);
else if(n->type == ecrireInst) affiche_t_instr_ecrire(n);
if(n->type == blocInst) parcours_l_instr(n->u.liste);
else if(n->type == affecteInst) parcours_instr_affect(n);
else if(n->type == siInst) parcours_instr_si(n);
else if(n->type == tantqueInst) parcours_instr_tantque(n);
else if(n->type == faireInst) parcours_instr_faire(n);
else if(n->type == pourInst) parcours_instr_pour(n);
else if(n->type == appelInst) parcours_instr_appel(n);
else if(n->type == retourInst) parcours_instr_retour(n);
else if(n->type == ecrireInst) parcours_instr_ecrire(n);
}
}
/*-------------------------------------------------------------------------*/
void affiche_t_instr_si(n_instr *n)
void parcours_instr_si(n_instr *n)
{
affiche_t_exp(n->u.si_.test);
affiche_t_instr(n->u.si_.alors);
parcours_exp(n->u.si_.test);
parcours_instr(n->u.si_.alors);
if(n->u.si_.sinon){
affiche_t_instr(n->u.si_.sinon);
parcours_instr(n->u.si_.sinon);
}
}
/*-------------------------------------------------------------------------*/
void affiche_t_instr_tantque(n_instr *n)
void parcours_instr_tantque(n_instr *n)
{
affiche_t_exp(n->u.tantque_.test);
affiche_t_instr(n->u.tantque_.faire);
parcours_exp(n->u.tantque_.test);
parcours_instr(n->u.tantque_.faire);
}
/*-------------------------------------------------------------------------*/
void affiche_t_instr_faire(n_instr *n)
void parcours_instr_faire(n_instr *n)
{
affiche_t_instr(n->u.faire_.faire);
affiche_t_exp(n->u.faire_.test);
parcours_instr(n->u.faire_.faire);
parcours_exp(n->u.faire_.test);
}
/*-------------------------------------------------------------------------*/
void affiche_t_instr_pour(n_instr *n)
void parcours_instr_pour(n_instr *n)
{
affiche_t_instr(n->u.pour_.init);
affiche_t_exp(n->u.pour_.test);
affiche_t_instr(n->u.pour_.faire);
affiche_t_instr(n->u.pour_.incr);
parcours_instr(n->u.pour_.init);
parcours_exp(n->u.pour_.test);
parcours_instr(n->u.pour_.faire);
parcours_instr(n->u.pour_.incr);
}
/*-------------------------------------------------------------------------*/
void affiche_t_instr_affect(n_instr *n)
void parcours_instr_affect(n_instr *n)
{
affiche_t_var(n->u.affecte_.var);
affiche_t_exp(n->u.affecte_.exp);
parcours_var(n->u.affecte_.var);
parcours_exp(n->u.affecte_.exp);
}
/*-------------------------------------------------------------------------*/
void affiche_t_instr_appel(n_instr *n)
void parcours_instr_appel(n_instr *n)
{
affiche_t_appel(n->u.appel);
parcours_appel(n->u.appel);
}
/*-------------------------------------------------------------------------*/
void affiche_t_appel(n_appel *n)
void parcours_appel(n_appel *n)
{
int id = rechercheExecutable(n->fonction);
if(id < 0) {
@@ -113,7 +127,7 @@ void affiche_t_appel(n_appel *n)
exit(1);
}
int nbArg = affiche_t_l_exp(n->args);
int nbArg = parcours_l_exp(n->args);
if(dico.tab[id].complement != nbArg) {
printf("Nombre Argument différent pour l'appel à %s\n", n->fonction);
affiche_dico();
@@ -123,105 +137,117 @@ void affiche_t_appel(n_appel *n)
/*-------------------------------------------------------------------------*/
void affiche_t_instr_retour(n_instr *n)
void parcours_instr_retour(n_instr *n)
{
affiche_t_exp(n->u.retour_.expression);
parcours_exp(n->u.retour_.expression);
}
/*-------------------------------------------------------------------------*/
void affiche_t_instr_ecrire(n_instr *n)
void parcours_instr_ecrire(n_instr *n)
{
affiche_t_exp(n->u.ecrire_.expression);
int tRegistre = parcours_exp(n->u.ecrire_.expression);
char tmp[250];
sprintf(tmp, "move $a0 $t%d", tRegistre);
printMips(tmp);
printMips("li $v0 1");
printMips("systcall");
}
/*-------------------------------------------------------------------------*/
int affiche_t_l_exp(n_l_exp *n)
int parcours_l_exp(n_l_exp *n)
{
if(n){
affiche_t_exp(n->tete);
return 1 + affiche_t_l_exp(n->queue);
parcours_exp(n->tete);
return 1 + parcours_l_exp(n->queue);
}
return 0;
}
/*-------------------------------------------------------------------------*/
void affiche_t_exp(n_exp *n)
int parcours_exp(n_exp *n)
{
if(n->type == varExp) affiche_t_varExp(n);
else if(n->type == opExp) affiche_t_opExp(n);
else if(n->type == intExp) affiche_t_intExp(n);
else if(n->type == appelExp) affiche_t_appelExp(n);
else if(n->type == lireExp) affiche_t_lireExp(n);
if(n->type == varExp) return parcours_varExp(n);
else if(n->type == opExp) return parcours_opExp(n);
else if(n->type == intExp) return parcours_intExp(n);
else if(n->type == appelExp) return parcours_appelExp(n);
else if(n->type == lireExp) return parcours_lireExp(n);
}
/*-------------------------------------------------------------------------*/
void affiche_t_varExp(n_exp *n)
int parcours_varExp(n_exp *n)
{
affiche_t_var(n->u.var);
parcours_var(n->u.var);
}
/*-------------------------------------------------------------------------*/
void affiche_t_opExp(n_exp *n)
int parcours_opExp(n_exp *n)
{
}
/*-------------------------------------------------------------------------*/
void affiche_t_intExp(n_exp *n)
int parcours_intExp(n_exp *n)
{
char texte[ 50 ]; // Max. 50 chiffres
sprintf(texte, "%d", n->u.entier);
}
/*-------------------------------------------------------------------------*/
void affiche_t_lireExp(n_exp *n)
int parcours_lireExp(n_exp *n)
{
printMips("li $v0 5");
printMips("systcall");
int iRegistre = newReg();
char tmp[250];
sprintf(tmp, "move $t%d $a0", iRegistre);
printMips(tmp);
return iRegistre;
}
/*-------------------------------------------------------------------------*/
void affiche_t_appelExp(n_exp *n)
int parcours_appelExp(n_exp *n)
{
affiche_t_appel(n->u.appel);
parcours_appel(n->u.appel);
}
/*-------------------------------------------------------------------------*/
void affiche_t_l_dec(n_l_dec *n)
void parcours_l_dec(n_l_dec *n)
{
if( n ){
affiche_t_dec(n->tete);
affiche_t_l_dec(n->queue);
parcours_dec(n->tete);
parcours_l_dec(n->queue);
}
}
/*-------------------------------------------------------------------------*/
void affiche_t_dec(n_dec *n)
void parcours_dec(n_dec *n)
{
if(n){
if(n->type == foncDec) {
affiche_t_foncDec(n);
parcours_foncDec(n);
}
else if(n->type == varDec) {
affiche_t_varDec(n);
parcours_varDec(n);
}
else if(n->type == tabDec) {
affiche_t_tabDec(n);
parcours_tabDec(n);
}
}
}
/*-------------------------------------------------------------------------*/
void affiche_t_foncDec(n_dec *n)
void parcours_foncDec(n_dec *n)
{
int i = rechercheExecutable(n->nom);
if( i >= 0) {
@@ -233,7 +259,7 @@ void affiche_t_foncDec(n_dec *n)
int id = ajouteIdentificateur(n->nom, contexte, T_FONCTION, 0, -1);
entreeFonction();
contexte = C_ARGUMENT;
affiche_t_l_dec(n->u.foncDec_.param);
parcours_l_dec(n->u.foncDec_.param);
int j = 0;
for(int i = dico.sommet - 1; i >= 0; i--){
@@ -245,15 +271,15 @@ void affiche_t_foncDec(n_dec *n)
dico.tab[id].complement = j;
contexte = C_VARIABLE_LOCALE;
affiche_t_l_dec(n->u.foncDec_.variables);
affiche_t_instr(n->u.foncDec_.corps);
parcours_l_dec(n->u.foncDec_.variables);
parcours_instr(n->u.foncDec_.corps);
affiche_dico();
sortieFonction();
}
/*-------------------------------------------------------------------------*/
void affiche_t_varDec(n_dec *n)
void parcours_varDec(n_dec *n)
{
if(rechercheDeclarative(n->nom) >= 0) {
printf("Variable %s déjà déclaré\n", n->nom);
@@ -263,6 +289,9 @@ void affiche_t_varDec(n_dec *n)
if (contexte == C_VARIABLE_GLOBALE) {
ajouteIdentificateur(n->nom, contexte, T_ENTIER, adresseGlobalCourante, -1);
char tmp[250];
sprintf(tmp, "$%s: .word", n->nom);
printMips(tmp);
adresseGlobalCourante += 4;
} else if (contexte == C_VARIABLE_LOCALE) {
ajouteIdentificateur(n->nom, contexte, T_ENTIER, adresseLocaleCourante, -1);
@@ -280,7 +309,7 @@ void affiche_t_varDec(n_dec *n)
/*-------------------------------------------------------------------------*/
void affiche_t_tabDec(n_dec *n)
void parcours_tabDec(n_dec *n)
{
char texte[100]; // Max. 100 chars nom tab + taille
sprintf(texte, "%s[%d]", n->nom, n->u.tabDec_.taille);
@@ -293,6 +322,9 @@ void affiche_t_tabDec(n_dec *n)
if (contexte == C_VARIABLE_GLOBALE) {
ajouteIdentificateur(n->nom, contexte, T_TABLEAU_ENTIER, adresseGlobalCourante, n->u.tabDec_.taille);
char tmp[250];
sprintf(tmp, "$%s: .space %d", n->nom, 4*n->u.tabDec_.taille);
printMips(tmp);
adresseGlobalCourante += 4*n->u.tabDec_.taille;
} else {
printf("Wtf ? %s\n", n->nom);
@@ -304,18 +336,18 @@ void affiche_t_tabDec(n_dec *n)
/*-------------------------------------------------------------------------*/
void affiche_t_var(n_var *n)
void parcours_var(n_var *n)
{
if(n->type == simple) {
affiche_t_var_simple(n);
parcours_var_simple(n);
}
else if(n->type == indicee) {
affiche_t_var_indicee(n);
parcours_var_indicee(n);
}
}
/*-------------------------------------------------------------------------*/
void affiche_t_var_simple(n_var *n)
void parcours_var_simple(n_var *n)
{
int i = rechercheExecutable(n->nom);
if( i < 0) {
@@ -330,7 +362,7 @@ void affiche_t_var_simple(n_var *n)
}
/*-------------------------------------------------------------------------*/
void affiche_t_var_indicee(n_var *n)
void parcours_var_indicee(n_var *n)
{
int i = rechercheExecutable(n->nom);
if( i < 0) {
@@ -343,6 +375,6 @@ void affiche_t_var_indicee(n_var *n)
exit(1);
}
affiche_t_exp( n->u.indicee_.indice );
parcours_exp( n->u.indicee_.indice );
}
/*-------------------------------------------------------------------------*/

0
test/output/affect.mips Normal file
View File

0
test/output/boucle.mips Normal file
View File

0
test/output/expression.mips Normal file
View File

0
test/output/max.mips Normal file
View File

0
test/output/tri.mips Normal file
View File

4
test/testAll.sh
View File

@@ -14,7 +14,7 @@ MYCOMPILOLEX="${MYCOMPILO} -l"
MYCOMPILOSYNT="${MYCOMPILO} -s"
MYCOMPILOASYNT="${MYCOMPILO} -a"
MYCOMPILOTAB="${MYCOMPILO} -t"
#MYCOMPILOMIPS="${MYCOMPILO} -m"
MYCOMPILOMIPS="${MYCOMPILO} -m"
################################################################################
@@ -72,7 +72,7 @@ function test_fichier_ok() {
diff_prog ${XMLDIFF} $input asynt
${MYCOMPILOTAB} input/$input.l > output/$input.tab
diff_prog "${REGDIFF}" $input tab
#${MYCOMPILOMIPS} input/$input.l > output/$input.mips
${MYCOMPILOMIPS} input/$input.l > output/$input.mips
#diff_prog "${REGDIFF}" $input mips
else
echo -e "\033[31minput/$input.l non trouvé\033[0m"