// LA FONCTION ACCEPT QUI PERMET DE D'AFFICHER LA NATURE DE L'UNITE LEXICAL
        public static void accept(AFD AUTOM, string w)
        {
            int    cpt = 0;                      // COMPTEUR SUR LE CARACTERE DU FICHIER A INTERPRETER
            string mot = "";                     // CHAINE QUI CONTIENDERA LA VALEUR DU LEXEME
            int    q   = AUTOM.getEtatInitial(); // VARIABLE QUI DEFINIT L'ETAT

            // BOUCLE QUI PARCOUR LA CHAINE CONTENANT LE FICHIER A INTERPRETER
            while (w.Length != cpt)
            {
                q = transition(q, w[cpt], AUTOM); // APPEL DE LA FONCTION TRANSITION AVEC L'ETAT INITAL q ET LE SYMBOLE
                // ON TEST SI L'ETAT RETOURNER EXISTE DANS LE LA LISTE D'ETAT FINAUX DE L'AFD
                if (AUTOM.getEtatFinaux().Contains(q))
                {
                    switch (q)
                    {
                    // OPERATEUR RELATIONNEL EGAL
                    case 1:
                        Console.WriteLine("<REL,EGAL>");
                        cpt++;     // ON INCREMENTE LE COMPLTEUR CAR IL N'Y PAS D'AUTRE QUI INDIQUERAIT LA FIN DE L'UNITE
                        break;

                    // OPERATEUR RELATIONNEL SUPERIEUR
                    case 15:
                        Console.WriteLine("<REL,SUP>");
                        break;

                    // OPERATEUR RELATIONNEL SUPERIEUR OU EGAL
                    case 16:
                        Console.WriteLine("<REL,SUPEGAL>");
                        cpt++;
                        break;

                    // OPERATEUR RELATIONNEL INFERIEUR
                    case 17:
                        Console.WriteLine("<REL,INF>");
                        break;

                    // OPERATEUR RELATIONNEL INFERIEUR OU EGAL
                    case 18:
                        Console.WriteLine("<REL,INFEGAL>");
                        break;

                    // OPERATEUR RELATIONNEL DIFFERENCE
                    case 19:
                        Console.WriteLine("<REL,DIFF>");
                        cpt++;
                        break;


                    // POUR LES COMMENTAIRES : (**)
                    case 20:
                        cpt++;
                        break;

                    // MOT-CLE OU ID
                    case 21:
                        // ON CHERCHER SI LE MOT RETOURNE EXISTE DANS LA LISTE DE STRING, SI OUI C'EST UN MOT-CLE SINON C'EST UN ID
                        if (MOTCLE.Contains(mot))
                        {
                            Console.WriteLine("<MOTCLE,{0}>", mot);
                        }
                        else
                        {
                            Console.WriteLine("<ID,{0}>", mot);
                        }

                        break;

                    // CHAINE DE CARACTERES
                    case 23:
                        Console.WriteLine("<STRING,{0}>", mot + w[cpt++]);
                        break;

                    // ENTIER
                    case 24:
                        Console.WriteLine("<INT,{0}>", mot);
                        break;

                    // OPERATEUR ARITHMETIQUE : + OU - OU * OU /
                    case 25:
                        Console.WriteLine("<OP,{0}>", w[cpt++]);
                        break;

                    // FLOAT
                    case 26:
                        Console.WriteLine("<FLOAT,{0}>", mot);
                        break;

                    // REEL
                    case 27:
                        Console.WriteLine("<REAL,{0}>", mot);
                        break;

                    // UTILISATION DE DEFAULT N'A PAS D'INTERET CAR ON EST SUR QU'ON ENTRE DANS CE TEXTE SEULEMENT SI ON SORT AVEC UN ETAT FINAL LORS D'UNE TRANSITION
                    default:
                        break;
                    }
                    mot = "";                     // RENITIALISATION DU MOT RETOURNE POUR AFFICHIER LE NOUVEAU
                    q   = AUTOM.getEtatInitial(); // RENITIALISATION DE L'ETAT INITIAL
                }
                else
                {
                    // REMPLISSAGE DU MOT DE LA VALEUR DU LEXEME, EN NEGLIGEANT LES CARACTERES BLANCS
                    if (w[cpt] != ' ')
                    {
                        mot += w[cpt];
                    }
                    cpt++; // INCREME?TATION DU COMPTEUR QUI REPRESENTE LE CURSEUR SUR CHAQUE CARACTERE
                }
            }
        }
        //LA FONCTION PRINT QUI PERMET D'AFFICHER L'AUTOMATE AINSI QUE CES COMPOSANTS
        public static void print(AFD AUTOM)
        {
            // BOUCLE QUI PERMET D'AFFICHER LES DIFFERENTS ETATS (INITIAUX ET FINAUX)
            for (int i = 0; i < AUTOM.getNbrEtat(); i++)
            {
                if (i == 0)
                {
                    Console.Write("E=({0}", i); // LE PREMIER ETAT
                }
                else
                if (i == AUTOM.getNbrEtat() - 1)
                {
                    Console.WriteLine(",{0})", i); // LA DERNIERE ETAT
                }
                else
                {
                    Console.Write(",{0}", i); // LES AUTRES ETATS DU MILIEU
                }
            }
            // BOUCLE QUI PERMET D'AFFICHER L'ALPHABET DE L'AUTOMATE
            for (int i = 0; i < AUTOM.getAlphabet().Count; i++)
            {
                if (i == 0)
                {
                    Console.Write("A=({0}", AUTOM.getAlphabet()[i]); // LE PREMIER CARACTERE
                }
                else
                if (i == AUTOM.getAlphabet().Count - 1)
                {
                    Console.WriteLine(",{0})", AUTOM.getAlphabet()[i]); // LE DERNIER CARACTERE
                }
                else
                {
                    Console.Write(",{0}", AUTOM.getAlphabet()[i]); // LES AUTRES CARACTERES DE L'ALPHABET
                }
            }
            Console.WriteLine("Transactions:");
            // BOUCLE QUI PERMET D'AFFICHER LES TRANSACTIONS
            for (int i = 0; i < AUTOM.getTransitions().Count; i++)
            {
                Console.WriteLine("t({0},{1})={2}  ", AUTOM.getTransitions()[i].getEtatI(), AUTOM.getTransitions()[i].getSymbole(), AUTOM.getTransitions()[i].getEtatF());
            }

            // L'AFFICHAGE DE L'ETAT INITIAL
            Console.WriteLine("I= {0}", AUTOM.getEtatInitial());
            // L'AFFICHAGE DES ETATS FINAUX
            if (AUTOM.getNbrEtatFinal() == 1)
            {
                Console.WriteLine("F=({0})", AUTOM.getEtatFinaux()[0]); // SI IL S'AGIT D'UN SEUL ETAT FINAL
            }
            else
            {
                for (int i = 0; i < AUTOM.getNbrEtatFinal(); i++)
                {
                    if (i == 0)
                    {
                        Console.Write("F=( {0}", AUTOM.getEtatFinaux()[i]); // LE PREMIER ETAT FINAL
                    }
                    else
                    if (i == AUTOM.getNbrEtatFinal() - 1)
                    {
                        Console.WriteLine(", {0} )", AUTOM.getEtatFinaux()[i]); // LE DERNIER ETAT FINAL
                    }
                    else
                    {
                        Console.Write(", {0}", AUTOM.getEtatFinaux()[i]); // LES AUTRES ETATS FINAUX
                    }
                }
            }
            // L'AFFICHAGE DE NOMBRE DES TRANSACTIONS
            Console.WriteLine("Nombre de transactions : {0}", AUTOM.getTransitions().Count);
        }