Structure personne
{
        nom : chaine
        prenom : chaine
        grade : chaine
        email : chaine
        numero : chaine
        
        
}

procedure Recherche(E f:Fichier, E nom : chaine, E prenom : chaine)
{
        variable p, p1 :  personne
                 nbp : entier
                 tel : chaine
                 
         nbp <-- 0
         Decaler(f, Debut_Fichier, 0)
         
         Tant que (Non (Fin (f)))
         {
                Lire(f,p)
                Si ((p.nom = nom) ET (p.prenom = prenom))
                {
                        p1 <-- p
                        nbp <-- nbp +1
                }
         }
         
         Si (nbp=0) alors
         {
                Afficher("La personne n'est pas présente dans le fichier")
         }
         sinon
         {
                Si (nbp = 1) alors
                {
                        AfficherPersonne(p1)
                }
                sinon
                {
                        Afficher("Il y a des homonymes et veuillez saisir le numéro")
                        Saisir(tel)
                        
                        Decaler(f, Debut_Fichier, 0)
                         Repeter
                         {
                                Lire(f,p)
                         } jusqu'à (Fin(f) ET NON(p.nom =nom ET p.prenom = prenom ET p.numero = tel))
        
                        Si (p.nom =nom ET p.prenom = prenom ET p.numero = tel) alors
                        {
                                AfficherPersonne(p)
                        }
                        sinon
                        {
                                Afficher("Il n'y a personne qui ait ce nom, prnom et numero.\n")
                        }
                }
         }
         
         
}

procedure AfficherPersonne ( E p: personne)
{
        Afficher(p.nom, "\n")
        Afficher(p.prenom, "\n")
        Afficher(p.grade, "\n")
        Afficher(p.email, "\n")
        Afficher(p.numero, "\n")
}

procedure ConstructionTableaux(E f:Fichier, E/S MCFs : tableau de personne, S nbMCFs : entier,
                                            E/S PRs : tableau de personne, S nbPRs : entier)

{
        variable p : personne 

        nbMCFs <-- 0
        nbPRs <-- 0
        
         Decaler(f, Debut_Fichier, 0)

        Tant que (Non (Fin(f)))
        {
                Lire(f,p)
                
                Si (p.grade="MC") alors
                        nbMCFs <-- nbMCFs + 1
                sinon
                        nbPRs <-- nbPRs + 1 
        }
        
        // ICI on crée les tableaux
        MCFs <-- Allouer tableau de nbMCFs personne
        PRs <-- Allouer tableau de nbPRs personne

        nbMCFs <-- 0
        nbPRs <-- 0
        
         Decaler(f, Debut_Fichier, 0)

        Tant que (Non (Fin(f)))
        {
                Lire(f,p)
                
                Si (p.grade="MC") alors
                {
                        MCFs[nbMCFs] <-- p
                        nbMCFs <-- nbMCFs + 1
                }
                sinon
                {
                        PRs[nbPRs] <-- p
                        nbPRs <-- nbPRs + 1
                }
        }
}


fonction ComptageMCF(E f:Fichier) : entier
{
        variable p : personne
                nbMCFs : entier

        nbMCFs <-- 0
        
         Decaler(f, Debut_Fichier, 0)

        Tant que (Non (Fin(f)))
        {
                Lire(f,p)
                
                Si (p.grade="MC") alors
                        nbMCFs <-- nbMCFs + 1
        }
        
        retourne nbMCFs
}


// ON SUPPOSE CETTE FOIS QU'IL N'Y A PAS D'HOMONYME
procedure PROMOTION(E f:Fichier, E nom : chaine, E prenom : chaine)
{
        variable p :  personne
                 Trouve : booleen
                 
         Trouve <-- FAUX
                 
         Decaler(f, Debut_Fichier, 0)
        
         Tant que (Non (Fin (f)) ET NON (Trouve))
         {
                Lire(f,p)
                Si ((p.nom = nom) ET (p.prenom = prenom))
                {
                        Trouve <-- VRAI
                }
         }
         
         
         Si (Trouve) alors
         {
                p.grade <-- "PR"
                Decaler(f, Position_Courante, -1)
                Ecrire(f,p)
         }
         
}