task Ecran is
            entry First_Line(Message : String);
            entry Ajouter_output(Message : String);
            entry Ajouter_Input(Message : String);
            entry Clear_input;
            entry Clear_Output;
         end Ecran;
 
 
         task body Ecran is
            First : String(1..80) := (others => Ascii.Nul);
            Page_Input : String(1..920) := (others =>  ' ');
            Last_Input : positive := 1;
            Page_Output : String(1..920) := (others =>  ' ');
            Last_Output : Positive := 1;
 
         begin
            while not End_Of_Program.End_Of_Program loop
               select
                  accept First_Line(Message : String) do
                     First := Message(1..80);
                  end First_Line;
               or
                  accept Ajouter_output(Message : String) do
                     if Message'Length /= 0 then
                        Page_Output(Last_Output+2..Last_Output+2+Message'Length-1) := Message;
                        Last_Output := Last_Output+ Message'Length+1;
                     end if;
 
                  end Ajouter_Output;
               or
                  accept Ajouter_input(Message : String) do
                     Page_input(1..Message'Length) := Message;
                  end Ajouter_Input;
               or
                  accept Clear_input do
                     First := (others => Ascii.nul);
                     Page_Input := (others =>  ' ');
                  end Clear_input;
               or
                  accept Clear_Output do
                     Page_Output := (others =>  ' ');
                     Last_Output := 1;
                  end Clear_output;
 
               or
                  delay 0.0;
                  if Current_Mode = Mode_Ia then
                     Res := System("clear" & Ascii.Nul);
                     Put(First);
                     Put(Page_Output);
                     Put("--------------------------------------------------------------------------------" );
                     Put(Page_input);
                     delay 0.075;
                  else
                     delay 0.5;
                  end if;
               end select;
            end loop;
            Put_Line("exit ecran ..." );
         end Ecran;
 
 
         task type T_T_Ia(Id : T_Ia_Id) is
            entry Recevoir(Char : Character);
            entry recevoir(Msg : String);
         end T_T_Ia;
 
         task body T_T_Ia is
 
 
            task Server is
               entry Srv_Recevoir(Message : in string);
            end Server;
 
            task body Server is
               type Socket_Access is access Socket_Type;
 
               task type T_T_Pong(Socket : Socket_access) is
                  entry Get_Id(Id : out Task_Id);
               end T_T_Pong;
 
               task body T_T_Pong is
                  Channel  : Stream_Access;
               begin
                  accept Get_Id(Id : out Task_Id) do
                     Id := Current_Task;
                  end Get_Id;
                  Channel := Stream (Socket.all);
                  Srv_Recevoir(String'Input(Channel));
                  Ecran.Ajouter_Output("exit pong" );
               end T_T_Pong;
 
               type Pong_Task(Socket : Socket_access) is
                  record
                     Id : Task_Id := Null_Task_id;
                     Pong : T_T_Pong(Socket);
                  end record;
               type Pong_Access is access Pong_task;
 
               type T_Bliste is array(1..10) of Boolean;
 
 
 
 
               Serv_Socket,Client_socket : Socket_Type;
               Serv_Addr,Client_addr : Sock_Addr_type;
               Message : String_access;
               Liste : array(1..10) of Socket_access;
               Pong_Liste : array(1..10) of Pong_access;
               Bliste : T_Bliste;
               Reads,Write : Socket_Set_Type;
               Selector : Selector_Type;
               Status : Selector_Status;
               Ptr : Integer := 0;
               Channel_Client : Stream_Access;
 
 
               function Chercher return Natural is
               begin
                  for I in 1..10 loop
                     if bliste(I) and then
                       Pong_liste(I) /= null and then
                       Is_Terminated(Pong_liste(I).Id) then
                        Pong_liste(I) := null;
                        Pong_Liste(I).Id := Null_Task_Id;
                        return I;
                     else
                        return I;
                     end if;
                  end loop;
                  return 0;
               end Chercher;
 
 
            begin
               Serv_Addr.Addr := Addresses(Get_Host_By_Name("localhost" ));
               Serv_Addr.Port := 5876+Port_Type(Id);
               Create_Socket(Serv_socket);
               Bind_socket(Serv_Socket,Serv_addr);
               Listen_socket(Serv_Socket);
               Create_Selector(Selector);
               Set(Write,Serv_Socket);
               for I in 1..Liste'length loop
                  liste(I) := new Socket_Type;
               end loop;
               Bliste := (others => False);
               loop
                  Empty(Reads);
                  Set(Reads,Serv_Socket);
                  for I in 1..10 loop
                     if Bliste(I) then
                        Set(Reads,Liste(I).all);
                     end if;
                  end loop;
                  select
                     accept Srv_Recevoir(Message : String) do
                        Ecran.Ajouter_Output("Tita" );
                        Recevoir(Message);
                        Ecran.Ajouter_Output("Totu" );
                     end Srv_Recevoir;
                  or
                     delay(0.0);
                     Ecran.Ajouter_Output("TATA" );
                     Check_Selector(Selector,Reads,Write,Status);
                     Ecran.Ajouter_Output("TOTA" );
                     case Status is
                        when Completed =>
                           if Is_Set(Reads,Serv_Socket) then
                              Ptr := Chercher;
                              -------------
                              --   DEBUG --
                              Ecran.Ajouter_Output("A" );
                              Accept_Socket(Serv_Socket,Liste(Ptr).all,Serv_Addr);
                              Bliste(Ptr) := True;
 
                           else
                              for I in 1..Bliste'length loop
                                 if Bliste(I) then
                                    if Is_Set(Reads,Liste(i).all) then
                                       Ecran.Ajouter_Output("serveur 1." & Integer'Image(I));
                                       Pong_Liste(i) := new Pong_task(Liste(i));
                                       Ecran.Ajouter_Output("serveur 2." & Integer'Image(I));
                                       Pong_Liste(i).Pong.Get_Id(Pong_Liste(i).Id);
                                       Ecran.Ajouter_Output("serveur 3." & Integer'Image(I));
                                       Bliste(I) := False;
                                       Ecran.Ajouter_Output("B" );
                                    end if;
                                 end if;
                              end loop;
                           end if;
                        when Expired =>
                           null;
 
                        when Aborted =>
                           null;
 
                     end case;
                  end select;
               end loop;
            end Server;
 
            First_Line : String(1..80) := (others => Ascii.Nul);
            Line : String(1..880);
            Last : Natural := 0;
 
            type T_Cmd is (Null_Item, Help, Quit,Ia,Clear);
 
            function Value(Command : String) return T_Cmd is
               First_Space : positive := 1;
            begin
               while Command(First_Space) /= ' ' and then
                 First_space < Command'Length loop
                  First_Space := First_Space + 1;
               end loop;
               return T_Cmd'Value(Command(Index_Non_Blank(Command)..First_Space));
            exception
               when others =>
                  return Null_Item;
            end Value;
 
            Command : T_Cmd;
 
            Client_socket : Socket_Type;
            Client_addr : Sock_Addr_type;
            Channel_Client : Stream_Access;
         begin
            Create_Socket(Client_Socket);
--            Set_Socket_Option
--              (Client_Socket,
--               Socket_Level,
--               (Reuse_Address, ));
            Client_Addr.Port := 5876+Port_Type(Id);
            while not End_Of_Program.End_Of_Program loop
               select
                  when Current_Mode = Mode_ia and then
                    Current_Ia_Id = 0 =>
 
                     accept Recevoir(Char : Character) do
                        case Char is
                           when Character'Val(10) =>
                              if Last /= 0 then
                                 Command := Value(Line(1..Last));
                                 case Command is
                                    when Null_Item =>
                                       begin
                                          Ecran.Ajouter_Output("C" );
                                          Client_Addr.Addr := Addresses(Get_Host_By_Name("localhost" ));
                                          Ecran.Ajouter_Output("C.1" );
 
                                          Connect_Socket(Client_Socket, Client_Addr);
                                          Ecran.Ajouter_Output("C.2" );
                                          Channel_client := Stream (Client_Socket);
                                          Ecran.Ajouter_Output("C.3" );
                                          String'output(Channel_client,Line(1..Last));
                                          Ecran.Ajouter_Output("D" );
 
                                          Close_socket(Client_Socket);
                                       exception
                                          when others => raise;
                                       end;
                                    when Quit =>
                                       if Data /= null then
                                          P_Reel.Save(Data.all);
                                       end if;
                                       if prev /= null then
                                          P_Previsionnel.Save(Prev.all);
                                       end if;
                                       End_Of_Program.End_Of_Program := True;
                                    when Help =>
                                       declare
                                          Char : Character;
                                       begin
                                          New_Line;
                                          --Help;
                                          New_Line(12);
                                          Put("press any key to continue" );
                                          Get_Immediate(Char);
                                       end;
                                    when Ia =>
                                       Current_Ia_Id := T_Ia_Id'Value(Line(Index(Line," " )+1..last));
                                       Current_Mode := Mode_Ia;
                                    when Clear =>
                                       Ecran.Clear_output;
                                    when others =>
                                       Put(Ascii.Bel);
                                 end case;
                              end if;
                              Last := 0;
                              Line := (others => Ascii.Nul);
                           when Ascii.Del | Ascii.Bs =>
                              if last /= 0 then
                                 Line(last) := ' ' ;
                                   last := last - 1 ;
                              else
                                 Put(Ascii.Bel);
                              end if;
                           when others =>
                              Last := Last + 1;
                              Line(Last) := char;
                        end case;
 
                     end Recevoir;
               or
                  when Current_Mode = Mode_ia and then
                    Current_Ia_Id = Id =>
 
                    accept Recevoir(Char : Character) do
                        case Char is
                           when Character'Val(10) =>
                              if Last /= 0 then
                                 Command := Value(Line(1..Last));
                                 case Command is
                                    when Null_Item =>
                                       begin
                                          Ecran.Ajouter_Output("C" );
                                          Client_Addr.Addr := Addresses(Get_Host_By_Name("localhost" ));
 
                                          Ecran.Ajouter_Output("C.1" );
                                          Connect_Socket(Client_Socket, Client_Addr);
                                          Ecran.Ajouter_Output("C.2" );
                                          Channel_client := Stream (Client_Socket);
                                          Ecran.Ajouter_Output("C.3" );
                                          String'output(Channel_client,Line(1..Last));
                                          Ecran.Ajouter_Output("D" );
 
                                          Close_Socket(Client_Socket);
                                       exception
                                          when others => raise;
                                       end;
                                    when Quit =>
                                       if Data /= null then
                                          P_Reel.Save(Data.all);
                                       end if;
                                       if prev /= null then
                                          P_Previsionnel.Save(Prev.all);
                                       end if;
                                       End_Of_Program.End_Of_Program := True;
                                    when Help =>
                                       declare
                                          Char : Character;
                                       begin
                                          New_Line;
                                          --Help;
                                          New_Line(12);
                                          Put("press any key to continue" );
                                          Get_Immediate(Char);
                                       end;
                                    when Ia =>
                                       Current_Ia_Id := T_Ia_Id'Value(Line(Index(Line," " )+1..last));
                                       Current_Mode := Mode_Ia;
                                    when others =>
                                       Put(Ascii.Bel);
                                 end case;
                              end if;
                              Last := 0;
                              Line := (others => Ascii.Nul);
                           when Ascii.Del | Ascii.Bs =>
                              if last /= 0 then
                                 Line(last) := ' ' ;
                                   last := last - 1 ;
                              else
                                 Put(Ascii.Bel);
                              end if;
                           when others =>
                              Last := Last + 1;
                              Line(Last) := char;
                        end case;
 
                     end Recevoir;
               or
 
                  accept Recevoir(Msg : in String) do
                     Ecran.Ajouter_Output(Msg);
                  end Recevoir;
               or
                  delay 0.075;
 
                  if Current_Mode = Mode_ia then
                     Move(Full_Datify_String(Clock),First_Line,Error,Center);
                     if Current_Ia_Id = Id then
                        Insert(First_Line,60, "Ia_Id: " & T_Ia_Id'Image(Id),right);
                        Ecran.Clear_Input;
                        Ecran.first_Line(First_Line);
                        Ecran.Ajouter_Input(Line(1..Last));
 
                     elsif Current_Ia_Id = 0 then
 
 
                        if Id = 1 then
                           Insert(First_Line,60,"Ia GLOBAL",right);
                           Ecran.Clear_Input;
                           Ecran.first_Line(First_Line);
                           Ecran.Ajouter_Input(Line(1..Last));
                        end if;
                     end if;
                  end if;
                  delay 0.075;
               end select;
            end loop;
 
            Put_Line("exit ia" );
            abort Server;
         exception
            when others =>
               raise;
         end T_T_Ia;

with End_Of_Program;
with Alredy_Running;
 
with Erreurs_Types_Abstraits;
use Erreurs_Types_Abstraits;
 
with Ada.Command_Line;
 
with Text_Io;
use Text_Io;
with ada.strings, ada.strings.fixed;
use ada.strings, ada.strings.fixed;
 
 
with Gnat.Os_Lib;
use Gnat.Os_Lib;
 
with Calendar;
use Calendar;
with Time_To_Date, Split_heure;
use Time_To_Date, Split_heure;
 
 
with Gnat.Sockets;
use Gnat.Sockets;
with Ada.Exceptions;
use Ada.Exceptions;
 
with Ada.Task_Identification;
use Ada.Task_Identification;
 
with Ada.Unchecked_Deallocation;
 
with Ada.Command_Line;
use Ada.Command_Line;
 
with My_ai;
use My_ai;
 
procedure Ai_server is
   function System(Command : in String) return Integer;
   pragma Import(C, System, "system" );
   Res : Integer := 0;
 
 
   function Position(arg : String) return Natural is separate;
   Char : Character;
   begin
      if Ada.Command_Line.Argument_Count = 0 then
         Version.Version;
         Copyright.Copyright;
         License.License;
         Usage.Default_Message;
      else
         declare
            Pos_Gpl_Copy_Clause : Natural := Position("--copy_clause" );
            Pos_Gpl_Warranty_Clause : Natural := Position("--warranty_clause" );
      begin
         if Pos_Gpl_Copy_Clause /= 0 then
            Gpl_Copy_Clause.Gpl_Copy_Clause;
         end if;
         if Pos_Gpl_Warranty_Clause /= 0 then
            Gpl_Warranty_Clause.Gpl_Warranty_Clause;
         end if;
      end;
   end if;
   if not End_Of_Program.End_Of_program and Alredy_Running.Alredy_Running then
      loop
         declare
            Char : Character;
         begin
            Put_Line("Program alredy running ! 'q' or 'Q' to quit ; 'c' or 'C' to continu !" );
            Get_Immediate(Char);
            case Char is
               when 'q' | 'Q' =>
                 Raise Alredy_Running.Alredy_Running_Error;
               when 'c' | 'C' =>
                 Alredy_Running.Alredy_Running := True;
               when others =>
                  raise Erreur_Specification;
            end case;
            exit;
         exception
            when Erreur_specification =>
               null;
         end;
 
      end loop;
   else
      Alredy_Running.Alredy_Running := True;
   end if;
 
   while not End_Of_Program.End_Of_Program loop
      declare
         task ai is
            entry Recevoir(Char : in Character);
         end ai;
 
         task body ai is
 
 
            type T_Cmd is (Null_Item, Help, Quit);
 
            function Value(Command : String) return T_Cmd is
               First_Space : positive := 1;
            begin
               while Command(First_Space) /= ' ' and then
                 First_space < Command'Length loop
                  First_Space := First_Space + 1;
               end loop;
               return T_Cmd'Value(Command(Index_Non_Blank(Command)..First_Space));
            exception
               when others =>
                  return Null_Item;
            end Value;
 
            Command : T_Cmd;
            Line : String(1..880) := (others => Ascii.Nul);
            Last : Natural := 0;
 
 
 
 
 
 
 
            task Server is
               entry Start;
               entry Stop;
            end Server;
 
 
 
            task body Server is
 
               End_Of_Server : Boolean := False;
               type Socket_Access is access Socket_type;
 
               task type Thread_server(Socket : Socket_access) is
                  entry Get_Id(Id : out Task_Id);
               end Thread_server;
 
 
               task body Thread_server is
                  Channel  : Stream_Access;
 
 
                  Main_Mode : T_Main_Mode := Null_Item;
 
               begin
                  accept Get_Id(Id : out Task_Id) do
                     Id := Current_Task;
                  end Get_Id;
                  Channel := Stream (Socket.all);
                  Put_Line(" Message from " &
                           Image(Get_Address(channel)) & " ::=" );
                  New_Line;
                  Main_mode := T_Main_Mode'Input(Channel);
                  Put_Line("stop 5" );
                  case Main_Mode is
                     when Null_Item =>
                        null;
                     when Stop =>
                        Put_Line("stop 6" );
--                        String'Output(Channel,"Arret du serveur" );
                        Put_Line("stop 7" );
                        End_Of_Server := True;
                     when Login =>
                        null;
                     when Inscription =>
                        null;
                     when others =>
                        raise  Erreur_Specification;
                  end case;
 
                  Close_Socket(Socket.all);
               end Thread_Server;
 
 
               type Thread_Server_Access is access Thread_Server;
 
               type thread_server_Task is
                  record
                     Id : Task_Id := Null_Task_id;
                     thread_server : thread_server_access;
                  end record;
               type thread_server_Task_Access is access thread_server_task;
 
 
               procedure Unchecked_Deallocation_thread_server is
                  new Ada.Unchecked_Deallocation(thread_server,thread_server_Access);
               procedure Unchecked_Deallocation_thread_server_task is
                  new Ada.Unchecked_Deallocation(thread_server_Task,thread_server_Task_Access);
 
 
 
 
               Liste : array(1..10) of Socket_access;
               Thread_Server_Liste : array(1..1) of Thread_Server_Task_Access;
               Bliste : array(1..10) of Boolean;
               Reads,Write : Socket_Set_Type;
 
               Selector : Selector_Type;
               Srv_Adr,Adr : Sock_Addr_Type;
               Srv_Socket : Socket_Type;
               Status : Selector_Status;
               package Intio is new Text_Io.Integer_Io(Integer);
               Ptr : Integer := 0;
               C : Character;
 
 
 
               function Chercher return Natural is
               begin
                  for I in 1..10 loop
                     if liste(I) = null then
                        return I;
                     elsif Is_Terminated(Thread_Server_Liste(I).Id) then
                        Unchecked_Deallocation_Thread_Server(Thread_Server_Liste(I).Thread_Server);
                        Unchecked_Deallocation_Thread_Server_task(Thread_Server_Liste(I));
                        return I;
                     end if;
                  end loop;
                  return 0;
               end Chercher;
 
 
 
 
 
 
               Channel  : Stream_Access;
               Client_Suivant : Natural := 0;
            begin
               accept Start;
               Srv_Adr.Addr := Inet_addr("192.168.1.100" );
               Srv_Adr.Port := 5876;
               Create_Socket(Srv_Socket);
               Bind_Socket(Srv_Socket,Srv_Adr);
               Listen_Socket(Srv_Socket);
 
               -- Creation
               Create_Selector(Selector);
               Set(Write,Srv_Socket);
 
               for I in 1..10 loop
                  liste(I) := new Socket_Type;
               end loop;
               Bliste := (others => False);
 
 
               loop
 
                  Empty(Reads);
 
                  Set(Reads,Srv_Socket);
 
                  for I in 1..10 loop
                     if Bliste(I) then
                        Set(Reads,Liste(I).all);
                     end if;
                  end loop;
 
                  Check_Selector(Selector,Reads,Write,Status);
 
                  case Status is
                     when Completed =>
 
                        if Is_Set(Reads,Srv_Socket) then
                           Client_Suivant := Chercher;
                           if Client_Suivant /= 0 then
                              Ptr := Client_Suivant;
                              Put_Line("Connexion : "&Integer'Image(Ptr));
                              Accept_Socket(Srv_Socket,Liste(Ptr).all,Adr);
                              Bliste(Ptr) := True;
                           end if;
                        else
                           Put_Line("toto 6" );
                           for I in 1..10 loop
                              if Bliste(I) then
                                 if Is_Set(Reads,Liste(I).all) then
                                    thread_server_Liste(i) := new thread_server_task;
                                    thread_server_Liste(I).thread_server := new thread_server(Liste(i));
                                    thread_server_Liste(i).thread_server.Get_Id(thread_server_Liste(i).Id);
                                    Bliste(i) := false;
                                 end if;
                              end if;
                           end loop;
                        end if;
                     when Expired =>
                        Put_Line("expired" );
 
                     when Aborted =>
                        Put_Line("aborted" );
 
                  end case;
                  delay(0.2);
                  exit when End_Of_Server;
               end loop;
               Put_Line("exit server ..." );
               delay(1.0);
               accept Stop;
               Put_Line("end server ..." );
            end Server;
 
         begin
            Initialize;
            Server.Start;
            while not End_Of_Program.End_Of_Program Loop
               select
                  accept Recevoir(Char : in Character) do
                     case Char is
                        when Character'Val(10) =>
                           if Last /= 0 then
                              Command := Value(Line(1..Last));
                              case Command is
                                 when Null_Item =>
                                    Put(Ascii.Bel);
                                 when Quit =>
                                    --                            if Data /= null then
                                    --                               P_Reel.Save(Data.all);
                                    --                            end if;
                                    --                            if prev /= null then
                                    --                               P_Previsionnel.Save(Prev.all);
                                    --                            end if;
                                    --
 
                                    declare
                                       Client_socket : Socket_Type;
                                       Client_addr : Sock_Addr_type;
                                       Channel_Client : Stream_Access;
                                    begin
                                       Create_Socket(Client_Socket);
                                       Set_Socket_Option
                                         (Client_Socket,
                                          Socket_Level,
                                          (Reuse_Address, true));
                                       Client_Addr.Port := 5876;
                                       Client_Addr.Addr := Addresses(Get_Host_By_Name("localhost" ));
                                       Connect_Socket(Client_Socket, Client_Addr);
                                       Put_Line("stop 3" );
                                       Channel_client := Stream (Client_Socket);
                                       T_Main_mode'output(Channel_client,stop);
                                       Put_Line("stop 4" );
--                                       Put_Line(String'input(Channel_client));
                                       Put_Line("stop 4.1" );
                                       Close_socket(Client_Socket);
                                    exception
                                       when E: Gnat.Sockets.Socket_Error =>
                                          Put_Line
                                                  (Exception_Name (E) &
                                                   ": " &
                                                   Exception_Message (E));
                                    end;
                                    Put_Line("stop 1" );
                                    Server.Stop;
                                    Put_Line("stop 2" );
                                    Finalize;
                                    End_Of_Program.End_Of_Program := True;
                                 when Help =>
                                    declare
                                       Char : Character;
                                    begin
                                       New_Line;
                                       --Help;
                                       New_Line(12);
                                       Put("press any key to continue" );
                                       Get_Immediate(Char);
                                    end;
                                 when others =>
                                    Put(Ascii.Bel);
                              end case;
                           end if;
                           Last := 0;
                           Line := (others => Ascii.Nul);
                        when Ascii.Del | Ascii.Bs =>
                           if last /= 0 then
                              Line(last) := ' ' ;
                                last := last - 1 ;
                           else
                              Put(Ascii.Bel);
                           end if;
                        when others =>
                           Last := Last + 1;
                           Line(Last) := char;
                     end case;
                  end Recevoir;
               or
                  delay 0.0;
                  Res := System("clear" & Ascii.Nul);
                  New_Line(22);
                  Put_Line("                           Taper 'quit' pour quitter." );
                  Put(Line(1..Last));
                  delay 0.075;
               end select;
            end loop;
         end Ai;
 
 
 
 
 
 
 
 
 
 
 
      begin
         while not End_Of_Program.End_Of_Program loop
            Get_Immediate(Char);  -- Voila c'est plus clair ainsi.
            Ai.Recevoir(Char); -- 
 
         end loop;
      exception
         when others =>
            raise;
      end;
   end loop;
 
   Alredy_Running.Alredy_Running := False;
   Ada.Command_Line.Set_Exit_Status(Ada.Command_Line.Success);
exception
   when Alredy_Running.Alredy_Running_Error =>
      Put_Line("Real_Ia alredy running ... " );
end Ai_server;

......
 ......
                                       Status := T_Inscription'Input(Channel_Client);
                                       case Status is
                                          when My_ai.Success =>
                                          New_Line(12);
                                          Put_Line("                           Inscription terminee" );
                                          New_Line(11);
                                          delay 5.0;
                                       when My_Ai.Failure =>
                                          New_Line(12);
                                          Put_Line("                           Inscription abandonnée" );
                                          New_Line(11);
                                          delay 5.0;
                                       end case;
                                       Put_Line("Close socket .." );
                                       delay 3.0;
                                       Close_socket(Socket);
                                       Put_Line("Socket closed .." );
                                       delay 3.0;
 ....
 ....

T_Inscription'Output(Channel,My_Ai.success);
                           Put_Line("inscripton 6" );
                           delay 3.0;

procedure Init(Filename : String) is
 
      enregistrement : T_Enregistrement;
   begin
      Open(Fichier,in_File,Filename);
      while not End_Of_File(Fichier) loop
         Read(Fichier,enregistrement);
         if Liste.Tete = null then
            Liste.Tete :=  new T_Element'(Enregistrement,null);
            Liste.Courant := Liste.Tete;
            Liste.Taille := 1;
         else
            Liste.Courant.Suivant := new T_Element'(Enregistrement,null);
            Liste.Courant := Liste.Courant.Suivant;
            Liste.Taille := Liste.Taille+ 1;
         end if;
      end loop;
 
      Close(Fichier);
 
   end Init;

when Null_Item =>
                                    declare
                                       Commande : T_Commande := value(Line(1..last));
                                    begin
                                       if Logged then
                                          T_Commande'Output(Channel,commande);
                                          case Commande is
                                             when Logout =>
                                                Commande := T_Commande'Input(Channel);
                                                delay(2.0);
                                             when others =>
                                                Put(Ascii.Bel);
                                          end case;
                                       else
                                          Put(Ascii.Bel);
                                       end if;
                                    end;

loop
                              commande := T_commande'Input(Channel);
                              case commande is
                                 when Logout =>
                                    T_commande'Output(Channel,Logout);
                                    exit;
                                 when others =>
                                    null;
                              end case;
                           end loop;

procedure Init(Filename : String) is
 
      enregistrement : T_Enregistrement;
   begin
      Liste.Tete := null;
      Liste.Taille := 0;
      Open(Fichier,in_File,Filename);
      while not End_Of_File(Fichier) loop
         Read(Fichier,enregistrement);
         if Liste.Tete = null then
            Liste.Tete :=  new T_Element'(Enregistrement,null);
            Liste.Courant := Liste.Tete;
            Liste.Taille := 1;
         else
            Liste.Courant.Suivant := new T_Element'(Enregistrement,null);
            Liste.Courant := Liste.Courant.Suivant;
            Liste.Taille := Liste.Taille+ 1;
         end if;
      end loop;
 
      Close(Fichier);
   exception
         when End_Error =>
            null;
         when others =>
            raise;
      end Init;

with Gnat.Md5;
package Info_user is
 
    -- les types de l'element de bloc de liste
   subtype T_Email_Address is String(1..64);
   subtype T_Logname is String(1..32);
   subtype T_Passwd is String(1..10);
 
   type T_Enregistrement is -- l'element de bloc de liste
      record
         Email_Address : T_Email_Address := (others => ' ');
         Logname       : T_Logname := (others => Ascii.nul);
         Passwd        : Gnat.Md5.Message_Digest;
      end record;
 
 
   function Exist(Logname : T_Logname) return Boolean;
   function Alredy_registred(Email   : string) return Boolean;
   function Rechercher(Logname : T_logname) return Gnat.Md5.Message_Digest;
   procedure Inscrire(Nouveau : T_Enregistrement);
   procedure Init(Filename : String);
   procedure save(Filename : String);
 
 
 
end Info_user;

with direct_Io;
with Text_Io;
package body Info_User is
 
 
 
   Null_Message_Digest : Gnat.Md5.Message_Digest := (others => Ascii.Nul);
 
   package Enregistrement_Io is new direct_Io(T_Enregistrement);
   use Enregistrement_Io;
 
 
   type T_Element; -- Mes blocs de liste
   type T_Element_Access is access T_Element;
   type T_Element is
      record
         Element : T_Enregistrement;
         Suivant : T_Element_Access;
      end record;
 
 
   type T_Liste is
      record
         Tete : T_Element_Access;
         Courant : T_Element_Access;
         Taille : Natural := 0;
      end record;
 
 
   -- la liste --
   Liste : T_Liste;
 
   -- le fichier --
   Fichier : File_Type;
 
 
 
 
   procedure Init(Filename : String) is
 
      enregistrement : T_Enregistrement;
   begin
      Open(Fichier,inout_File,Filename);
      if Size(Fichier) /= 0 then
         Liste.Taille := 1;
 
         Read(Fichier,enregistrement);
         Liste.Tete :=  new T_Element'(Enregistrement,null);
         Liste.Courant := Liste.Tete;
         Liste.Taille := 1;
         if Size(Fichier) > 1 then
            for I in 2..Size(Fichier) loop
               Set_Index(Fichier,I);
               Liste.Courant.Suivant := new T_Element'(Enregistrement,null);
               Liste.Courant := Liste.Courant.Suivant;
               Liste.Taille := Liste.Taille+ 1;
            end loop;
            Liste.Courant := Liste.Tete;
         end if;
 
      end if;
      Close(Fichier);
   exception
      when others =>
         Close(Fichier);
         raise;
   end Init;
 
 
 
 
   procedure save(Filename : String) is
   begin
      if Liste.Taille > 0 then
         Text_Io.Put_Line("Save file ..." );
         Open(Fichier,inout_File,Filename);
         Text_Io.Put_Line("Save file ... open" );
 
         Liste.Courant := Liste.Tete;
         for I in 1..Liste.Taille loop
            Set_Index(Fichier,Count(I));
            Text_Io.Put_Line("Ok list.tete /= null" );
            Text_Io.Put_Line("Logname : " & liste.courant.element.logname);
            Text_Io.Put_Line("Passwd  : " & liste.courant.element.passwd);
            Write(Fichier, Liste.Courant.Element);
            Text_Io.Put_Line("Save file ...write" );
            Liste.Courant := Liste.Courant.Suivant;
         end loop;
         Close(Fichier);
      end if;
   exception
      when others =>
         Close(Fichier);
   end Save;
 
 
 
 
 
 
 
 
 
 
 
  
   function Exist(Logname : T_logname) return Boolean is
 
   begin
      if Liste.Courant /= null and then
        Liste.Courant.Element.Logname = Logname then
         return True;
      else
         Liste.Courant := Liste.Tete;
      end if;
      while Liste.Courant /= null and then
        Liste.Courant.Element.Logname /= Logname loop
         Liste.Courant := Liste.Courant.Suivant;
      end loop;
      if Liste.Courant /= null and then
        Liste.Courant.Element.Logname = Logname then
         return true;
      else
         return false;
      end if;
   end Exist;
 
   function Alredy_registred(Email   : string) return Boolean is
   begin
      if Liste.Courant /= null and then
        ( Liste.Courant.Element.Email_Address  = Email) then
         return True;
      else
         Liste.Courant := Liste.Tete;
      end if;
      while Liste.Courant /= null and then
        Liste.Courant.Element.Email_Address /= email loop
         Liste.Courant := Liste.Courant.Suivant;
      end loop;
      if Liste.Courant /= null and then
        Liste.Courant.Element.Email_Address = email then
         return true;
      else
         return false;
      end if;
   end Alredy_Registred;
 
 
 
   function Plus_Grand(Nouveau : T_Logname; Que : T_Logname) return Boolean is
      Index : Positive := 1;
   begin
      if Character'Pos(Nouveau(Index)) > Character'Pos(Que(Index)) then
         return True;
      else
         for I in 1.. T_Logname'Length Loop
            Index := Index + 1;
            if Character'Pos(Nouveau(Index)) < Character'Pos(Que(Index)) then
               return False;
            end if;
         end loop;
         return True;
      end if;
   end Plus_Grand;
 
 
 
   procedure Inscrire(Nouveau : T_Enregistrement) is
      Nouveau_Element : T_Element_access;
      Precedent : T_Element_Access := Liste.Tete;
 
   begin
      if Liste.Tete = null then
         Liste.Tete := new T_element ' (Nouveau,null);
         Text_Io.Put_Line("inscription tete" );
         delay(3.0);
      else
         Nouveau_Element := new T_element ' (Nouveau,null);
         if Liste.Tete /= null and then
           not Plus_Grand(Nouveau => Nouveau.Logname,
                          Que => Liste.Tete.Element.logname) then
            Nouveau_Element.Suivant := Liste.Tete;
            Liste.Tete := Nouveau_element;
         elsif Liste.Tete.suivant /= null then
            Liste.Courant := Liste.Tete.suivant;
            while Liste.Courant /= null and then
              Plus_Grand(Nouveau => Nouveau.Logname,
                         Que => Liste.Tete.Element.logname) loop
               Precedent := Liste.Courant;
               Liste.Courant := Liste.Courant.Suivant;
            end loop;
            Nouveau_element.Suivant := Liste.Courant.Suivant;
            precedent.Suivant := Nouveau_element;
         end if;
      end if;
      Liste.Taille := Liste.Taille+1;
   end Inscrire;
 
   function Rechercher(Logname : T_logname) return Gnat.Md5.Message_Digest is
   begin
      if Liste.tete /= null and then
        Liste.tete.Element.Logname = Logname then
         Text_Io.Put_Line("Ok logname return passwd" );
                        delay(3.0);
         return Liste.tete.Element.Passwd;
      else
         Liste.Courant := Liste.Tete;
      end if;
      while Liste.Courant /= null and then
        Liste.Courant.Element.Logname /= Logname loop
         Liste.Courant := Liste.Courant.Suivant;
      end loop;
      if Liste.Courant /= null and then
        Liste.Courant.Element.Logname = Logname then
         return Liste.Courant.Element.Passwd;
      else
 
         return Null_Message_Digest;
      end if;
   end Rechercher;
 
 
 
 
 
end Info_User;