diff --git a/header/affiche_table_symbole.h b/header/affiche_table_symbole.h
index 170fe97..70d2e76 100644
--- a/header/affiche_table_symbole.h
+++ b/header/affiche_table_symbole.h
@@ -15,7 +15,7 @@ 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);
-void affiche_t_l_exp(n_l_exp *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);
diff --git a/src/affiche_arbre_abstrait.c b/src/affiche_arbre_abstrait.c
index e954601..27bf654 100644
--- a/src/affiche_arbre_abstrait.c
+++ b/src/affiche_arbre_abstrait.c
@@ -77,27 +77,27 @@ void affiche_instr_tantque(n_instr *n)
 
 /*-------------------------------------------------------------------------*/
 
-void affiche_instr_faire(n_instr *n)          /* MODIFIE POUR EVAL */
-{                                             /* MODIFIE POUR EVAL */
-  char *fct = "instr_faire";                  /* MODIFIE POUR EVAL */
-  affiche_balise_ouvrante(fct, trace_abs);    /* MODIFIE POUR EVAL */
-  affiche_instr(n->u.faire_.faire);           /* MODIFIE POUR EVAL */
-  affiche_exp(n->u.faire_.test);              /* MODIFIE POUR EVAL */
-  affiche_balise_fermante(fct, trace_abs);    /* MODIFIE POUR EVAL */
-}                                             /* MODIFIE POUR EVAL */
+void affiche_instr_faire(n_instr *n)          
+{                                             
+  char *fct = "instr_faire";                  
+  affiche_balise_ouvrante(fct, trace_abs);    
+  affiche_instr(n->u.faire_.faire);           
+  affiche_exp(n->u.faire_.test);              
+  affiche_balise_fermante(fct, trace_abs);    
+}                                             
 
 /*-------------------------------------------------------------------------*/
 
-void affiche_instr_pour(n_instr *n)                /* MODIFIE POUR EVAL */
-{                                                  /* MODIFIE POUR EVAL */
-  char *fct = "instr_pour";                        /* MODIFIE POUR EVAL */
-  affiche_balise_ouvrante(fct, trace_abs);         /* MODIFIE POUR EVAL */
-  affiche_instr(n->u.pour_.init);                  /* MODIFIE POUR EVAL */
-  affiche_exp(n->u.pour_.test);                    /* MODIFIE POUR EVAL */
-  affiche_instr(n->u.pour_.faire);                 /* MODIFIE POUR EVAL */
-  affiche_instr(n->u.pour_.incr);                  /* MODIFIE POUR EVAL */
-  affiche_balise_fermante(fct, trace_abs);         /* MODIFIE POUR EVAL */
-}                                                  /* MODIFIE POUR EVAL */
+void affiche_instr_pour(n_instr *n)                
+{                                                  
+  char *fct = "instr_pour";                        
+  affiche_balise_ouvrante(fct, trace_abs);         
+  affiche_instr(n->u.pour_.init);                  
+  affiche_exp(n->u.pour_.test);                    
+  affiche_instr(n->u.pour_.faire);                 
+  affiche_instr(n->u.pour_.incr);                  
+  affiche_balise_fermante(fct, trace_abs);         
+}                                                  
 
 /*-------------------------------------------------------------------------*/
 
diff --git a/src/affiche_table_symbole.c b/src/affiche_table_symbole.c
index 2723a4e..64011d6 100644
--- a/src/affiche_table_symbole.c
+++ b/src/affiche_table_symbole.c
@@ -13,21 +13,24 @@ extern dico_ dico;
 
 void affiche_t_table(n_prog *n)
 {
-  char *fct = "prog";
-
   affiche_t_l_dec(n->variables);
   affiche_t_l_dec(n->fonctions); 
+
+  int id = rechercheExecutable("main");
+  if(id < 0 || dico.tab[id].complement != 0) {
+    printf("Fonction main non trouvé\n");
+    affiche_dico();
+    exit(1);
+  }
 }
 
-/*-------------------------------------------------------------------------*/
 /*-------------------------------------------------------------------------*/
 
 void affiche_t_l_instr(n_l_instr *n)
 {
-  char *fct = "l_instr";
-  if(n){
-  affiche_t_instr(n->tete);
-  affiche_t_l_instr(n->queue);
+  if(n) {
+    affiche_t_instr(n->tete);
+    affiche_t_l_instr(n->queue);
   }
 }
 
@@ -35,7 +38,7 @@ void affiche_t_l_instr(n_l_instr *n)
 
 void affiche_t_instr(n_instr *n)
 {
-  if(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);
@@ -52,8 +55,6 @@ void affiche_t_instr(n_instr *n)
 
 void affiche_t_instr_si(n_instr *n)
 {  
-  char *fct = "instr_si";
-
   affiche_t_exp(n->u.si_.test);
   affiche_t_instr(n->u.si_.alors);
   if(n->u.si_.sinon){
@@ -65,8 +66,6 @@ void affiche_t_instr_si(n_instr *n)
 
 void affiche_t_instr_tantque(n_instr *n)
 {
-  char *fct = "instr_tantque";
-
   affiche_t_exp(n->u.tantque_.test);
   affiche_t_instr(n->u.tantque_.faire);
 }
@@ -75,7 +74,6 @@ void affiche_t_instr_tantque(n_instr *n)
 
 void affiche_t_instr_faire(n_instr *n)          
 {                                             
-  char *fct = "instr_faire";                  
   affiche_t_instr(n->u.faire_.faire);           
   affiche_t_exp(n->u.faire_.test);              
 }                                             
@@ -84,7 +82,6 @@ void affiche_t_instr_faire(n_instr *n)
 
 void affiche_t_instr_pour(n_instr *n)                
 {                                                  
-  char *fct = "instr_pour";                        
   affiche_t_instr(n->u.pour_.init);                  
   affiche_t_exp(n->u.pour_.test);                    
   affiche_t_instr(n->u.pour_.faire);                 
@@ -95,9 +92,6 @@ void affiche_t_instr_pour(n_instr *n)
 
 void affiche_t_instr_affect(n_instr *n)
 {
-  char *fct = "instr_affect";
-
-
   affiche_t_var(n->u.affecte_.var);
   affiche_t_exp(n->u.affecte_.exp);
 }
@@ -106,47 +100,50 @@ void affiche_t_instr_affect(n_instr *n)
 
 void affiche_t_instr_appel(n_instr *n)
 {
-  char *fct = "instr_appel";
-
-
   affiche_t_appel(n->u.appel);
 }
 /*-------------------------------------------------------------------------*/
 
 void affiche_t_appel(n_appel *n)
 {
-  char *fct = "appel";
-  //affiche_t_texte( n->fonction, trace_abs);
-  affiche_t_l_exp(n->args);
+  int id = rechercheExecutable(n->fonction);
+  if(id < 0) {
+    printf("Fonction %s introuvable\n", n->fonction);
+    affiche_dico();
+    exit(1);
+  }
+
+  int nbArg = affiche_t_l_exp(n->args);
+  if(dico.tab[id].complement != nbArg) {
+    printf("Nombre Argument différent pour l'appel à %s\n", n->fonction);
+    affiche_dico();
+    exit(1);
+  }
 }
 
 /*-------------------------------------------------------------------------*/
 
 void affiche_t_instr_retour(n_instr *n)
 {
-  char *fct = "instr_retour";
   affiche_t_exp(n->u.retour_.expression);
-
 }
 
 /*-------------------------------------------------------------------------*/
 
 void affiche_t_instr_ecrire(n_instr *n)
 {
-  char *fct = "instr_ecrire";
   affiche_t_exp(n->u.ecrire_.expression);
 }
 
 /*-------------------------------------------------------------------------*/
 
-void affiche_t_l_exp(n_l_exp *n)
+int affiche_t_l_exp(n_l_exp *n)
 {
-  char *fct = "l_exp";
-
   if(n){
     affiche_t_exp(n->tete);
-    affiche_t_l_exp(n->queue);
+    return 1 + affiche_t_l_exp(n->queue);
   }
+  return 0;
 }
 
 /*-------------------------------------------------------------------------*/
@@ -165,31 +162,13 @@ void affiche_t_exp(n_exp *n)
 
 void affiche_t_varExp(n_exp *n)
 {
-  char *fct = "varExp";
   affiche_t_var(n->u.var);
 }
 
 /*-------------------------------------------------------------------------*/
-void affiche_t_opExp(n_exp *n)
+void affiche_t_opExp(n_exp *n) 
 {
-  char *fct = "opExp";
-  /*if(n->u.opExp_.op == plus) affiche_t_texte("plus", trace_abs);
-  else if(n->u.opExp_.op == moins) affiche_t_texte("moins", trace_abs);
-  else if(n->u.opExp_.op == fois) affiche_t_texte("fois", trace_abs);
-  else if(n->u.opExp_.op == divise) affiche_t_texte("divise", trace_abs);
-  else if(n->u.opExp_.op == egal) affiche_t_texte("egal", trace_abs);
-  else if(n->u.opExp_.op == diff) affiche_t_texte("diff", trace_abs);
-  else if(n->u.opExp_.op == inf) affiche_t_texte("inf", trace_abs);
-  else if(n->u.opExp_.op == infeg) affiche_t_texte("infeg", trace_abs);
-  else if(n->u.opExp_.op == ou) affiche_t_texte("ou", trace_abs);
-  else if(n->u.opExp_.op == et) affiche_t_texte("et", trace_abs);
-  else if(n->u.opExp_.op == non) affiche_t_texte("non", trace_abs);  
-  if( n->u.opExp_.op1 != NULL ) {
-    affiche_t_exp(n->u.opExp_.op1);
-  }
-  if( n->u.opExp_.op2 != NULL ) {
-    affiche_t_exp(n->u.opExp_.op2);
-  }*/
+
 }
 
 /*-------------------------------------------------------------------------*/
@@ -198,21 +177,17 @@ void affiche_t_intExp(n_exp *n)
 {
   char texte[ 50 ]; // Max. 50 chiffres
   sprintf(texte, "%d", n->u.entier);
-  //affiche_t_element( "intExp", texte, trace_abs );
 }
 
 /*-------------------------------------------------------------------------*/
 void affiche_t_lireExp(n_exp *n)
 {
-  char *fct = "lireExp";
-
 }
 
 /*-------------------------------------------------------------------------*/
 
 void affiche_t_appelExp(n_exp *n)
 {
-  char *fct = "appelExp";
   affiche_t_appel(n->u.appel);
 }
 
@@ -220,8 +195,6 @@ void affiche_t_appelExp(n_exp *n)
 
 void affiche_t_l_dec(n_l_dec *n)
 {
-  char *fct = "l_dec";
-
   if( n ){
     affiche_t_dec(n->tete);
     affiche_t_l_dec(n->queue);
@@ -250,8 +223,6 @@ void affiche_t_dec(n_dec *n)
 
 void affiche_t_foncDec(n_dec *n)
 {
-  char *fct = "foncDec";
-
   int i = rechercheExecutable(n->nom);
   if( i >= 0) {
     printf("Fonction %s déjà déclaré\n", n->nom);
@@ -284,7 +255,6 @@ void affiche_t_foncDec(n_dec *n)
 
 void affiche_t_varDec(n_dec *n)
 {
-  //affiche_t_element("varDec", n->nom, trace_abs);
   if(rechercheDeclarative(n->nom) >= 0) {
     printf("Variable %s déjà déclaré\n", n->nom);
     affiche_dico();
@@ -362,8 +332,6 @@ void affiche_t_var_simple(n_var *n)
 /*-------------------------------------------------------------------------*/
 void affiche_t_var_indicee(n_var *n)
 {
-  char *fct = "var_indicee";
-
   int i = rechercheExecutable(n->nom);
   if( i < 0) {
     printf("Tableau %s non déclaré\n", n->nom);