% ============================================================
Q2.

analyser = 
	Demarrer ;
	Rec_desc ;


Rec_desc = 
	Rec_liste_decl ; 
    si LC.nature = PVIRG alors Avancer sinon Erreur ; 
    Rec_expression ; 
    si LC.nature = FIN_SEQ alors Avancer sinon Erreur ; 

Rec_liste_decl = 
    si LC.nature = LETTRE alors Avancer sinon Erreur ; 
	Rec_suite_liste_decl ; 
	
Rec_suite_liste_decl =
	selon LC.nature
		cas VIRG : 
			Avancer ;  
    		si LC.nature = LETTRE alors Avancer sinon Erreur ; 
			Rec_suite_liste_decl ; 
		sinon : // ne rien faire

Rec_expression 
	selon LC.nature
		cas SIGMA : 
		cas PROD : 
			Avancer ;  
    		si LC.nature = PARO alors Avancer sinon Erreur ; 
			Rec_liste_exp ;
    		si LC.nature = PARF alors Avancer sinon Erreur ; 
		cas LETTRE :
			Avancer
		sinon : 
			Erreur

Rec_liste_exp = 
		Rec_expression ; 
		Rec_suite_liste_exp ;


Rec_suite_liste_exp =
	selon LC.nature
		cas VIRG : 
			Avancer ;  
    		Rec_expression ; 
			Rec_suite_liste_exp ; 
		sinon : // ne rien faire

% ============================================================

Q3.

analyser (TabSymb *T, Ast *A) = 
	Demarrer ;
	Rec_desc (T, A) ;


Rec_desc (TabSymb *T, Ast *A) = 
	Rec_liste_decl (T) ; 
    si LC.nature = PVIRG alors Avancer sinon Erreur ; 
    Rec_expression (A) ; 
    si LC.nature = FIN_SEQ alors Avancer sinon Erreur ; 

Rec_liste_decl (Tabsymb *T) = 
    si LC.nature = LETTRE alors inserer(LC.lettre, T) ; Avancer sinon Erreur ; 
	Rec_suite_liste_decl (T) ; 
	
Rec_suite_liste_decl(TabSymb *T) =
	selon LC.nature
		cas VIRG : 
			Avancer ;  
    		si LC.nature = LETTRE alors inserer(LC.lettre, T) ; Avancer sinon Erreur ; 
			Rec_suite_liste_decl (T) ; 
		sinon : // ne rien faire

Rec_expression (Ast *A)
	selon LC.nature
		cas SIGMA : 
		cas PROD : 
		    si LC.nature = SIGMA alors creer_SIGMA(A) sinon creer_PROD(A) ;
			Avancer ;  
    		si LC.nature = PARO alors Avancer sinon Erreur ; 
			Rec_liste_exp (A) ;
    		si LC.nature = PARF alors Avancer sinon Erreur ; 
		cas LETTRE :
            creer_Lettre (LC.lettre, A) ;
			Avancer
		sinon  
			Erreur

Rec_liste_exp (Ast *A) = 
		Ast A1 ;
		Rec_expression (&A1) ; ajouter_fils (A, A1) ; 
		Rec_suite_liste_exp (A) ;


Rec_suite_liste_exp (Ast *A) =
	Ast A1 ;
	selon LC.nature
		cas VIRG : 
			Avancer ;  
			Rec_expression (&A1) ; ajouter_fils (A, A1) ; 
			Rec_suite_liste_exp (A) ; 
		sinon : // ne rien faire

% ============================================================

Q4. 

creer_ensemble_entree (Ensemble *E2, Ast A) ;
 si A != NULL alors
	selon A.nature 	
		cas LETTRE : ajouter(E2, A->lettre)
		cas SIGMA, PROD :
			pour i parcourant 0..A->nb_fils-1
				creer_ensemble_entree (E2, A->fils[i])
 fsi 
   
verifier (TabSymb T, Ast A) =
	Ensemble E1 = Vide ;  // ensemble des entrees presentes dans T
    Ensemble E2 = Vide ;  // ensemble des entrees presentes dans A
    // constrution de E1 
	pour i parcourant 0 .. T.nb_idf -1 
		ajouter (&E1, T.tab[i]) 
    // construction de E2 
    creer_ensemble_entree (&E2, A) ; 	
    return egalite (E1, E2) ;

% ============================================================

Q5.

// ajoute le noeud A au niveau n de la liste L
ajouter(listeNiveau *L, int n, Noeud A) =
	L->liste[n][L->nb_noeud_niv[n]] = A ;
	L->nb_noeud_niv[n] ++ ;
   
    
// parcours recursif de A et construction de la structure L a partir du niveau n
GFI (Ast A, listeNiveaux *L, int n) =
  si A != NULL  alors
		cas LETTRE : 
			ajouter(L[n], A) 

		cas SIGMA, PROD :
			ajouter(L, n, A) 
			pour i parcourant 0..A->nb_fils-1
				GFI(E2, A.fils[i], n+1)
  fsi

GenFormInter (Ast A, listeNiveaux *L) =
	GFI (A, L, 0)  


% ============================================================

Q6.

On note nb_niv le nombre maximum de niveau dans L

afficher (fenetre f, listeNiveaux L) = 
   pour i parcourant 0 ... nb_niv -1 
		y = (i+1)*(H/nb_niv) ;
		pourj parcourant 0 .. (L.nb_noeud_niv - 1)
			x = (j+1)*(L/L.nb_noeud_niv)
			selon L[i][j].nature
				cas LETTRE : Ecrire ( L[i][j].lettre, x, y)

				cas PROD : Triangle(x, y, x+1, y+1, x-1, y+1)

				cas SIGMA : demiCercle(x-1, y, x+1, y)
			fselon