------------------------------------------------------------------------------
--                                                                          --
--                         GNAT COMPILER COMPONENTS                         --
--                                                                          --
--                            M L I B . P R J                               --
--                                                                          --
--                                 B o d y                                  --
--                                                                          --
--                     Copyright (C) 2001-2014, AdaCore                     --
--                                                                          --
-- GNAT is free software;  you can  redistribute it  and/or modify it under --
-- terms of the  GNU General Public License as published  by the Free Soft- --
-- ware  Foundation;  either version 3,  or (at your option) any later ver- --
-- sion.  GNAT is distributed in the hope that it will be useful, but WITH- --
-- OUT ANY WARRANTY;  without even the  implied warranty of MERCHANTABILITY --
-- or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License --
-- for  more details.  You should have  received  a copy of the GNU General --
-- Public License  distributed with GNAT; see file COPYING3.  If not, go to --
-- http://www.gnu.org/licenses for a complete copy of the license.          --
--                                                                          --
-- GNAT was originally developed  by the GNAT team at  New York University. --
-- Extensive contributions were provided by Ada Core Technologies Inc.      --
--                                                                          --
------------------------------------------------------------------------------

with ALI;      use ALI;
with Gnatvsn;  use Gnatvsn;
with Makeutl;  use Makeutl;
with MLib.Fil; use MLib.Fil;
with MLib.Tgt; use MLib.Tgt;
with MLib.Utl; use MLib.Utl;
with Opt;
with Output;   use Output;
with Prj.Com;  use Prj.Com;
with Prj.Env;  use Prj.Env;
with Prj.Util; use Prj.Util;
with Sinput.P;
with Snames;   use Snames;
with Switch;   use Switch;
with Table;
with Tempdir;
with Types;    use Types;

with Ada.Characters.Handling;

with GNAT.Directory_Operations; use GNAT.Directory_Operations;
with GNAT.HTable;
with Interfaces.C_Streams;      use Interfaces.C_Streams;
with System;                    use System;
with System.Case_Util;          use System.Case_Util;

package body MLib.Prj is

   Prj_Add_Obj_Files : Types.Int;
   pragma Import (C, Prj_Add_Obj_Files, "__gnat_prj_add_obj_files");
   Add_Object_Files : constant Boolean := Prj_Add_Obj_Files /= 0;
   --  Indicates if object files in pragmas Linker_Options (found in the
   --  binder generated file) should be taken when linking a stand-alone
   --  library. False for Windows, True for other platforms.

   ALI_Suffix : constant String := ".ali";

   B_Start : constant String := "b~";
   --  Prefix of bind file

   S_Osinte_Ads : File_Name_Type := No_File;
   --  Name_Id for "s-osinte.ads"

   S_Dec_Ads : File_Name_Type := No_File;
   --  Name_Id for "dec.ads"

   Arguments : String_List_Access := No_Argument;
   --  Used to accumulate arguments for the invocation of gnatbind and of the
   --  compiler. Also used to collect the interface ALI when copying the ALI
   --  files to the library directory.

   Argument_Number : Natural := 0;
   --  Index of the last argument in Arguments

   Initial_Argument_Max : constant := 10;
   --  Where does the magic constant 10 come from???

   No_Main_String        : aliased String         := "-n";
   No_Main               : constant String_Access := No_Main_String'Access;

   Output_Switch_String  : aliased String         := "-o";
   Output_Switch         : constant String_Access :=
                             Output_Switch_String'Access;

   Compile_Switch_String : aliased String         := "-c";
   Compile_Switch        : constant String_Access :=
                             Compile_Switch_String'Access;

   No_Warning_String     : aliased String         := "-gnatws";
   No_Warning            : constant String_Access := No_Warning_String'Access;

   Auto_Initialize : constant String := "-a";

   --  List of objects to put inside the library

   Object_Files : Argument_List_Access;

   package Objects is new Table.Table
     (Table_Name           => "Mlib.Prj.Objects",
      Table_Component_Type => String_Access,
      Table_Index_Type     => Natural,
      Table_Low_Bound      => 1,
      Table_Initial        => 50,
      Table_Increment      => 100);

   package Objects_Htable is new GNAT.HTable.Simple_HTable
     (Header_Num => Header_Num,
      Element    => Boolean,
      No_Element => False,
      Key        => Name_Id,
      Hash       => Hash,
      Equal      => "=");

   --  List of ALI files

   Ali_Files : Argument_List_Access;

   package ALIs is new Table.Table
     (Table_Name           => "Mlib.Prj.Alis",
      Table_Component_Type => String_Access,
      Table_Index_Type     => Natural,
      Table_Low_Bound      => 1,
      Table_Initial        => 50,
      Table_Increment      => 100);

   --  List of options set in the command line

   Options : Argument_List_Access;

   package Opts is new Table.Table
     (Table_Name           => "Mlib.Prj.Opts",
      Table_Component_Type => String_Access,
      Table_Index_Type     => Natural,
      Table_Low_Bound      => 1,
      Table_Initial        => 5,
      Table_Increment      => 100);

   --  All the ALI file in the library

   package Library_ALIs is new GNAT.HTable.Simple_HTable
     (Header_Num => Header_Num,
      Element    => Boolean,
      No_Element => False,
      Key        => File_Name_Type,
      Hash       => Hash,
      Equal      => "=");

   --  The ALI files in the interface sets

   package Interface_ALIs is new GNAT.HTable.Simple_HTable
     (Header_Num => Header_Num,
      Element    => Boolean,
      No_Element => False,
      Key        => File_Name_Type,
      Hash       => Hash,
      Equal      => "=");

   --  The ALI files that have been processed to check if the corresponding
   --  library unit is in the interface set.

   package Processed_ALIs is new GNAT.HTable.Simple_HTable
     (Header_Num => Header_Num,
      Element    => Boolean,
      No_Element => False,
      Key        => File_Name_Type,
      Hash       => Hash,
      Equal      => "=");

   --  The projects imported directly or indirectly

   package Processed_Projects is new GNAT.HTable.Simple_HTable
     (Header_Num => Header_Num,
      Element    => Boolean,
      No_Element => False,
      Key        => Name_Id,
      Hash       => Hash,
      Equal      => "=");

   --  The library projects imported directly or indirectly

   package Library_Projs is new Table.Table (
     Table_Component_Type => Project_Id,
     Table_Index_Type     => Integer,
     Table_Low_Bound      => 1,
     Table_Initial        => 10,
     Table_Increment      => 10,
     Table_Name           => "Make.Library_Projs");

   type Build_Mode_State is (None, Static, Dynamic, Relocatable);

   procedure Add_Argument (S : String);
   --  Add one argument to Arguments array, if array is full, double its size

   function ALI_File_Name (Source : String) return String;
   --  Return the ALI file name corresponding to a source

   procedure Check (Filename : String);
   --  Check if filename is a regular file. Fail if it is not

   procedure Check_Context;
   --  Check each object files in table Object_Files
   --  Fail if any of them is not a regular file

   procedure Copy_Interface_Sources
     (For_Project : Project_Id;
      In_Tree     : Project_Tree_Ref;
      Interfaces  : Argument_List;
      To_Dir      : Path_Name_Type);
   --  Copy the interface sources of a SAL to directory To_Dir

   procedure Display (Executable : String);
   --  Display invocation of gnatbind and of the compiler with the arguments
   --  in Arguments, except when Quiet_Output is True.

   function Index (S, Pattern : String) return Natural;
   --  Return the last occurrence of Pattern in S, or 0 if none

   procedure Process_Binder_File (Name : String);
   --  For Stand-Alone libraries, get the Linker Options in the binder
   --  generated file.

   procedure Reset_Tables;
   --  Make sure that all the above tables are empty
   --  (Objects, Ali_Files, Options).

   function SALs_Use_Constructors return Boolean;
   --  Indicate if Stand-Alone Libraries are automatically initialized using
   --  the constructor mechanism.

   ------------------
   -- Add_Argument --
   ------------------

   procedure Add_Argument (S : String) is
   begin
      if Argument_Number = Arguments'Last then
         declare
            New_Args : constant String_List_Access :=
              new String_List (1 .. 2 * Arguments'Last);

         begin
            --  Copy the String_Accesses and set them to null in Arguments
            --  so that they will not be deallocated by the call to
            --  Free (Arguments).

            New_Args (Arguments'Range) := Arguments.all;
            Arguments.all := (others => null);
            Free (Arguments);
            Arguments := New_Args;
         end;
      end if;

      Argument_Number := Argument_Number + 1;
      Arguments (Argument_Number) := new String'(S);
   end Add_Argument;

   -------------------
   -- ALI_File_Name --
   -------------------

   function ALI_File_Name (Source : String) return String is
   begin
      --  If the source name has an extension, then replace it with
      --  the ALI suffix.

      for Index in reverse Source'First + 1 .. Source'Last loop
         if Source (Index) = '.' then
            return Source (Source'First .. Index - 1) & ALI_Suffix;
         end if;
      end loop;

      --  If there is no dot, or if it is the first character, just add the
      --  ALI suffix.

      return Source & ALI_Suffix;
   end ALI_File_Name;

   -------------------
   -- Build_Library --
   -------------------

   procedure Build_Library
     (For_Project   : Project_Id;
      In_Tree       : Project_Tree_Ref;
      Gnatbind      : String;
      Gnatbind_Path : String_Access;
      Gcc           : String;
      Gcc_Path      : String_Access;
      Bind          : Boolean := True;
      Link          : Boolean := True)
   is
      Maximum_Size : Integer;
      pragma Import (C, Maximum_Size, "__gnat_link_max");
      --  Maximum number of bytes to put in an invocation of gnatbind

      Size : Integer;
      --  The number of bytes for the invocation of gnatbind

      Warning_For_Library : Boolean := False;
      --  Set True for first warning for a unit missing from the interface set

      Current_Proj : Project_Id;

      Libgnarl_Needed   : Yes_No_Unknown := For_Project.Libgnarl_Needed;
      --  Set True if library needs to be linked with libgnarl

      Object_Directory_Path : constant String :=
                                Get_Name_String
                                  (For_Project.Object_Directory.Display_Name);

      Standalone   : constant Boolean := For_Project.Standalone_Library /= No;

      Project_Name : constant String := Get_Name_String (For_Project.Name);

      Current_Dir  : constant String := Get_Current_Dir;

      Lib_Filename : String_Access;
      Lib_Dirpath  : String_Access;
      Lib_Version  : String_Access := new String'("");

      The_Build_Mode : Build_Mode_State := None;

      Success : Boolean := False;

      Library_Options : Variable_Value := Nil_Variable_Value;

      Driver_Name : Name_Id := No_Name;

      In_Main_Object_Directory : Boolean := True;

      Foreign_Sources : Boolean;

      Rpath : String_Access := null;
      --  Allocated only if Path Option is supported

      Rpath_Last : Natural := 0;
      --  Index of last valid character of Rpath

      Initial_Rpath_Length : constant := 200;
      --  Initial size of Rpath, when first allocated

      Path_Option : String_Access := Linker_Library_Path_Option;
      --  If null, Path Option is not supported. Not a constant so that it can
      --  be deallocated.

      First_ALI : File_Name_Type := No_File;
      --  Store the ALI file name of a source of the library (the first found)

      procedure Add_ALI_For (Source : File_Name_Type);
      --  Add name of the ALI file corresponding to Source to the Arguments

      procedure Add_Rpath (Path : String);
      --  Add a path name to Rpath

      function Check_Project (P : Project_Id) return Boolean;
      --  Returns True if P is For_Project or a project extended by For_Project

      procedure Check_Libs (ALI_File : String; Main_Project : Boolean);
      --  Set Libgnarl_Needed if the ALI_File indicates that there is a need
      --  to link with -lgnarl (this is the case when there is a dependency
      --  on s-osinte.ads).

      procedure Process (The_ALI : File_Name_Type);
      --  Check if the closure of a library unit which is or should be in the
      --  interface set is also in the interface set. Issue a warning for each
      --  missing library unit.

      procedure Process_Imported_Libraries;
      --  Add the -L and -l switches for the imported Library Project Files,
      --  and, if Path Option is supported, the library directory path names
      --  to Rpath.

      -----------------
      -- Add_ALI_For --
      -----------------

      procedure Add_ALI_For (Source : File_Name_Type) is
         ALI    : constant String := ALI_File_Name (Get_Name_String (Source));
         ALI_Id : File_Name_Type;

      begin
         if Bind then
            Add_Argument (ALI);
         end if;

         Name_Len := 0;
         Add_Str_To_Name_Buffer (S => ALI);
         ALI_Id := Name_Find;

         --  Add the ALI file name to the library ALIs

         if Bind then
            Library_ALIs.Set (ALI_Id, True);
         end if;

         --  Set First_ALI, if not already done

         if First_ALI = No_File then
            First_ALI := ALI_Id;
         end if;
      end Add_ALI_For;

      ---------------
      -- Add_Rpath --
      ---------------

      procedure Add_Rpath (Path : String) is

         procedure Double;
         --  Double Rpath size

         ------------
         -- Double --
         ------------

         procedure Double is
            New_Rpath : constant String_Access :=
                          new String (1 .. 2 * Rpath'Length);
         begin
            New_Rpath (1 .. Rpath_Last) := Rpath (1 .. Rpath_Last);
            Free (Rpath);
            Rpath := New_Rpath;
         end Double;

      --  Start of processing for Add_Rpath

      begin
         --  If first path, allocate initial Rpath

         if Rpath = null then
            Rpath := new String (1 .. Initial_Rpath_Length);
            Rpath_Last := 0;

         else
            --  Otherwise, add a path separator between two path names

            if Rpath_Last = Rpath'Last then
               Double;
            end if;

            Rpath_Last := Rpath_Last + 1;
            Rpath (Rpath_Last) := Path_Separator;
         end if;

         --  Increase Rpath size until it is large enough

         while Rpath_Last + Path'Length > Rpath'Last loop
            Double;
         end loop;

         --  Add the path name

         Rpath (Rpath_Last + 1 .. Rpath_Last + Path'Length) := Path;
         Rpath_Last := Rpath_Last + Path'Length;
      end Add_Rpath;

      -------------------
      -- Check_Project --
      -------------------

      function Check_Project (P : Project_Id) return Boolean is
      begin
         if P = For_Project then
            return True;

         elsif P /= No_Project then
            declare
               Proj : Project_Id;

            begin
               Proj := For_Project;
               while Proj.Extends /= No_Project loop
                  if P = Proj.Extends then
                     return True;
                  end if;

                  Proj := Proj.Extends;
               end loop;
            end;
         end if;

         return False;
      end Check_Project;

      ----------------
      -- Check_Libs --
      ----------------

      procedure Check_Libs (ALI_File : String; Main_Project : Boolean) is
         Lib_File : File_Name_Type;
         Text     : Text_Buffer_Ptr;
         Id       : ALI.ALI_Id;

      begin
         if Libgnarl_Needed /= Yes then

            --  Scan the ALI file

            Name_Len := ALI_File'Length;
            Name_Buffer (1 .. Name_Len) := ALI_File;
            Lib_File := Name_Find;
            Text := Read_Library_Info (Lib_File, True);

            Id := ALI.Scan_ALI
                    (F          => Lib_File,
                     T          => Text,
                     Ignore_ED  => False,
                     Err        => True,
                     Read_Lines => "D");
            Free (Text);

            --  Look for s-osinte.ads in the dependencies

            for Index in ALI.ALIs.Table (Id).First_Sdep ..
                         ALI.ALIs.Table (Id).Last_Sdep
            loop
               if ALI.Sdep.Table (Index).Sfile = S_Osinte_Ads then
                  Libgnarl_Needed := Yes;

                  if Main_Project then
                     For_Project.Libgnarl_Needed := Yes;
                  else
                     exit;
                  end if;
               end if;
            end loop;
         end if;
      end Check_Libs;

      -------------
      -- Process --
      -------------

      procedure Process (The_ALI : File_Name_Type) is
         Text       : Text_Buffer_Ptr;
         Idread     : ALI_Id;
         First_Unit : ALI.Unit_Id;
         Last_Unit  : ALI.Unit_Id;
         Unit_Data  : Unit_Record;
         Afile      : File_Name_Type;

      begin
         --  Nothing to do if the ALI file has already been processed.
         --  This happens if an interface imports another interface.

         if not Processed_ALIs.Get (The_ALI) then
            Processed_ALIs.Set (The_ALI, True);
            Text := Read_Library_Info (The_ALI);

            if Text /= null then
               Idread :=
                 Scan_ALI
                   (F         => The_ALI,
                    T         => Text,
                    Ignore_ED => False,
                    Err       => True);
               Free (Text);

               if Idread /= No_ALI_Id then
                  First_Unit := ALI.ALIs.Table (Idread).First_Unit;
                  Last_Unit  := ALI.ALIs.Table (Idread).Last_Unit;

                  --  Process both unit (spec and body) if the body is needed
                  --  by the spec (inline or generic). Otherwise, just process
                  --  the spec.

                  if First_Unit /= Last_Unit and then
                    not ALI.Units.Table (Last_Unit).Body_Needed_For_SAL
                  then
                     First_Unit := Last_Unit;
                  end if;

                  for Unit in First_Unit .. Last_Unit loop
                     Unit_Data := ALI.Units.Table (Unit);

                     --  Check if each withed unit which is in the library is
                     --  also in the interface set, if it has not yet been
                     --  processed.

                     for W in Unit_Data.First_With .. Unit_Data.Last_With loop
                        Afile := Withs.Table (W).Afile;

                        if Afile /= No_File and then Library_ALIs.Get (Afile)
                          and then not Processed_ALIs.Get (Afile)
                        then
                           if not Interface_ALIs.Get (Afile) then
                              if not Warning_For_Library then
                                 Write_Str ("Warning: In library project """);
                                 Get_Name_String (Current_Proj.Name);
                                 To_Mixed (Name_Buffer (1 .. Name_Len));
                                 Write_Str (Name_Buffer (1 .. Name_Len));
                                 Write_Line ("""");
                                 Warning_For_Library := True;
                              end if;

                              Write_Str ("         Unit """);
                              Get_Name_String (Withs.Table (W).Uname);
                              To_Mixed (Name_Buffer (1 .. Name_Len - 2));
                              Write_Str (Name_Buffer (1 .. Name_Len - 2));
                              Write_Line (""" is not in the interface set");
                              Write_Str ("         but it is needed by ");

                              case Unit_Data.Utype is
                                 when Is_Spec =>
                                    Write_Str ("the spec of ");

                                 when Is_Body =>
                                    Write_Str ("the body of ");

                                 when others =>
                                    null;
                              end case;

                              Write_Str ("""");
                              Get_Name_String (Unit_Data.Uname);
                              To_Mixed (Name_Buffer (1 .. Name_Len - 2));
                              Write_Str (Name_Buffer (1 .. Name_Len - 2));
                              Write_Line ("""");
                           end if;

                           --  Now, process this unit

                           Process (Afile);
                        end if;
                     end loop;
                  end loop;
               end if;
            end if;
         end if;
      end Process;

      --------------------------------
      -- Process_Imported_Libraries --
      --------------------------------

      procedure Process_Imported_Libraries is
         Current : Project_Id;

         procedure Process_Project (Project : Project_Id);
         --  Process Project and its imported projects recursively.
         --  Add any library projects to table Library_Projs.

         ---------------------
         -- Process_Project --
         ---------------------

         procedure Process_Project (Project : Project_Id) is
            Imported : Project_List;

         begin
            --  Nothing to do if process has already been processed

            if not Processed_Projects.Get (Project.Name) then
               Processed_Projects.Set (Project.Name, True);

               --  Call Process_Project recursively for any imported project.
               --  We first process the imported projects to guarantee that
               --  we have a proper reverse order for the libraries.

               Imported := Project.Imported_Projects;
               while Imported /= null loop
                  if Imported.Project /= No_Project then
                     Process_Project (Imported.Project);
                  end if;

                  Imported := Imported.Next;
               end loop;

               --  If it is a library project, add it to Library_Projs

               if Project /= For_Project and then Project.Library then
                  Library_Projs.Increment_Last;
                  Library_Projs.Table (Library_Projs.Last) := Project;

                  --  Check if because of this library we need to use libgnarl

                  if Libgnarl_Needed = Unknown then
                     if Project.Libgnarl_Needed = Unknown
                       and then Project.Object_Directory /= No_Path_Information
                     then
                        --  Check if libgnarl is needed for this library

                        declare
                           Object_Dir_Path : constant String :=
                                               Get_Name_String
                                                 (Project.Object_Directory.
                                                    Display_Name);
                           Object_Dir      : Dir_Type;
                           Filename        : String (1 .. 255);
                           Last            : Natural;

                        begin
                           Open (Object_Dir, Object_Dir_Path);

                           --  For all entries in the object directory

                           loop
                              Read (Object_Dir, Filename, Last);
                              exit when Last = 0;

                              --  Check if it is an object file

                              if Is_Obj (Filename (1 .. Last)) then
                                 declare
                                    Object_Path : constant String :=
                                                    Normalize_Pathname
                                                      (Object_Dir_Path &
                                                       Directory_Separator &
                                                       Filename (1 .. Last));
                                    ALI_File    : constant String :=
                                                    Ext_To
                                                      (Object_Path, "ali");

                                 begin
                                    if Is_Regular_File (ALI_File) then

                                       --  Find out if for this ALI file,
                                       --  libgnarl is necessary.

                                       Check_Libs
                                         (ALI_File, Main_Project => False);

                                       if Libgnarl_Needed = Yes then
                                          Project.Libgnarl_Needed := Yes;
                                          For_Project.Libgnarl_Needed := Yes;
                                          exit;
                                       end if;
                                    end if;
                                 end;
                              end if;
                           end loop;

                           Close (Object_Dir);
                        end;
                     end if;

                     if Project.Libgnarl_Needed = Yes then
                        Libgnarl_Needed := Yes;
                        For_Project.Libgnarl_Needed := Yes;
                     end if;
                  end if;
               end if;
            end if;
         end Process_Project;

      --  Start of processing for Process_Imported_Libraries

      begin
         --  Build list of library projects imported directly or indirectly,
         --  in the reverse order.

         Process_Project (For_Project);

         --  Add the -L and -l switches and, if the Rpath option is supported,
         --  add the directory to the Rpath. As the library projects are in the
         --  wrong order, process from the last to the first.

         for Index in reverse 1 .. Library_Projs.Last loop
            Current := Library_Projs.Table (Index);

            Get_Name_String (Current.Library_Dir.Display_Name);
            Opts.Increment_Last;
            Opts.Table (Opts.Last) :=
              new String'("-L" & Name_Buffer (1 .. Name_Len));

            if Path_Option /= null then
               Add_Rpath (Name_Buffer (1 .. Name_Len));
            end if;

            Opts.Increment_Last;
            Opts.Table (Opts.Last) :=
              new String'("-l" & Get_Name_String (Current.Library_Name));
         end loop;
      end Process_Imported_Libraries;

      Path_FD : File_Descriptor := Invalid_FD;
      --  Used for setting the source and object paths

   --  Start of processing for Build_Library

   begin
      Reset_Tables;

      --  Fail if project is not a library project

      if not For_Project.Library then
         Com.Fail ("project """ & Project_Name & """ has no library");
      end if;

      --  Do not attempt to build the library if it is externally built

      if For_Project.Externally_Built then
         return;
      end if;

      --  If this is the first time Build_Library is called, get the Name_Id
      --  of "s-osinte.ads".

      if S_Osinte_Ads = No_File then
         Name_Len := 0;
         Add_Str_To_Name_Buffer ("s-osinte.ads");
         S_Osinte_Ads := Name_Find;
      end if;

      if S_Dec_Ads = No_File then
         Name_Len := 0;
         Add_Str_To_Name_Buffer ("dec.ads");
         S_Dec_Ads := Name_Find;
      end if;

      --  We work in the object directory

      Change_Dir (Object_Directory_Path);

      if Standalone then

         --  Call gnatbind only if Bind is True

         if Bind then
            if Gnatbind_Path = null then
               Com.Fail ("unable to locate " & Gnatbind);
            end if;

            if Gcc_Path = null then
               Com.Fail ("unable to locate " & Gcc);
            end if;

            --  Allocate Arguments, if it is the first time we see a standalone
            --  library.

            if Arguments = No_Argument then
               Arguments := new String_List (1 .. Initial_Argument_Max);
            end if;

            --  Add "-n -o b~<lib>.adb -L<lib>_"

            Argument_Number := 2;
            Arguments (1) := No_Main;
            Arguments (2) := Output_Switch;

            Add_Argument
              (B_Start & Get_Name_String (For_Project.Library_Name) & ".adb");

            --  Make sure that the init procedure is never "adainit"

            Get_Name_String (For_Project.Library_Name);

            if Name_Buffer (1 .. Name_Len) = "ada" then
               Add_Argument ("-Lada_");
            else
               Add_Argument
                 ("-L" & Get_Name_String (For_Project.Library_Name));
            end if;

            if For_Project.Lib_Auto_Init and then SALs_Use_Constructors then
               Add_Argument (Auto_Initialize);
            end if;

            --  Check if Binder'Default_Switches ("Ada") is defined. If it is,
            --  add these switches to call gnatbind.

            declare
               Binder_Package : constant Package_Id :=
                                  Value_Of
                                    (Name        => Name_Binder,
                                     In_Packages => For_Project.Decl.Packages,
                                     Shared      => In_Tree.Shared);

            begin
               if Binder_Package /= No_Package then
                  declare
                     Defaults : constant Array_Element_Id :=
                                  Value_Of
                                    (Name      => Name_Default_Switches,
                                     In_Arrays =>
                                       In_Tree.Shared.Packages.Table
                                         (Binder_Package).Decl.Arrays,
                                     Shared    => In_Tree.Shared);

                     Switches : Variable_Value := Nil_Variable_Value;
                     Switch   : String_List_Id := Nil_String;

                  begin
                     if Defaults /= No_Array_Element then
                        Switches :=
                          Value_Of
                            (Index     => Name_Ada,
                             Src_Index => 0,
                             In_Array  => Defaults,
                             Shared    => In_Tree.Shared);

                        if not Switches.Default then
                           Switch := Switches.Values;

                           while Switch /= Nil_String loop
                              Add_Argument
                                (Get_Name_String
                                   (In_Tree.Shared.String_Elements.Table
                                      (Switch).Value));
                              Switch := In_Tree.Shared.String_Elements.
                                          Table (Switch).Next;
                           end loop;
                        end if;
                     end if;
                  end;
               end if;
            end;
         end if;

         --  Get all the ALI files of the project file. We do that even if
         --  Bind is False, so that First_ALI is set.

         declare
            Unit : Unit_Index;

         begin
            Library_ALIs.Reset;
            Interface_ALIs.Reset;
            Processed_ALIs.Reset;

            Unit := Units_Htable.Get_First (In_Tree.Units_HT);
            while Unit /= No_Unit_Index loop
               if Unit.File_Names (Impl) /= null
                 and then not Unit.File_Names (Impl).Locally_Removed
               then
                  if Check_Project (Unit.File_Names (Impl).Project) then
                     if Unit.File_Names (Spec) = null then

                        --  Add the ALI file only if it is not a subunit

                        declare
                           Src_Ind : constant Source_File_Index :=
                                       Sinput.P.Load_Project_File
                                         (Get_Name_String
                                           (Unit.File_Names (Impl).Path.Name));
                        begin
                           if not
                             Sinput.P.Source_File_Is_Subunit (Src_Ind)
                           then
                              Add_ALI_For (Unit.File_Names (Impl).File);
                              exit when not Bind;
                           end if;
                        end;

                     else
                        Add_ALI_For (Unit.File_Names (Impl).File);
                        exit when not Bind;
                     end if;
                  end if;

               elsif Unit.File_Names (Spec) /= null
                 and then not Unit.File_Names (Spec).Locally_Removed
                 and then Check_Project (Unit.File_Names (Spec).Project)
               then
                  Add_ALI_For (Unit.File_Names (Spec).File);
                  exit when not Bind;
               end if;

               Unit := Units_Htable.Get_Next (In_Tree.Units_HT);
            end loop;
         end;

         --  Continue setup and call gnatbind if Bind is True

         if Bind then

            --  Get an eventual --RTS from the ALI file

            if First_ALI /= No_File then
               declare
                  T : Text_Buffer_Ptr;
                  A : ALI_Id;

               begin
                  --  Load the ALI file

                  T := Read_Library_Info (First_ALI, True);

                  --  Read it

                  A := Scan_ALI
                         (First_ALI, T, Ignore_ED => False, Err => False);

                  if A /= No_ALI_Id then
                     for Index in
                       ALI.Units.Table
                         (ALI.ALIs.Table (A).First_Unit).First_Arg ..
                       ALI.Units.Table
                         (ALI.ALIs.Table (A).First_Unit).Last_Arg
                     loop
                        --  If --RTS found, add switch to call gnatbind

                        declare
                           Arg : String_Ptr renames Args.Table (Index);
                        begin
                           if Arg'Length >= 6 and then
                              Arg (Arg'First + 2 .. Arg'First + 5) = "RTS="
                           then
                              Add_Argument (Arg.all);
                              exit;
                           end if;
                        end;
                     end loop;
                  end if;
               end;
            end if;

            --  Set the paths

            --  First the source path

            if For_Project.Include_Path_File = No_Path then
               Get_Directories
                 (Project_Tree => In_Tree,
                  For_Project  => For_Project,
                  Activity     => Compilation,
                  Languages    => Ada_Only);

               Create_New_Path_File
                 (In_Tree.Shared, Path_FD, For_Project.Include_Path_File);

               Write_Path_File (Path_FD);
               Path_FD := Invalid_FD;
            end if;

            if Current_Source_Path_File_Of (In_Tree.Shared) /=
                                                For_Project.Include_Path_File
            then
               Set_Current_Source_Path_File_Of
                 (In_Tree.Shared, For_Project.Include_Path_File);
               Set_Path_File_Var
                 (Project_Include_Path_File,
                  Get_Name_String (For_Project.Include_Path_File));
            end if;

            --  Then, the object path

            Get_Directories
              (Project_Tree => In_Tree,
               For_Project  => For_Project,
               Activity     => SAL_Binding,
               Languages    => Ada_Only);

            declare
               Path_File_Name : Path_Name_Type;

            begin
               Create_New_Path_File (In_Tree.Shared, Path_FD, Path_File_Name);

               Write_Path_File (Path_FD);
               Path_FD := Invalid_FD;

               Set_Path_File_Var
                 (Project_Objects_Path_File, Get_Name_String (Path_File_Name));
               Set_Current_Source_Path_File_Of
                 (In_Tree.Shared, Path_File_Name);
            end;

            --  Display the gnatbind command, if not in quiet output

            Display (Gnatbind);

            Size := 0;
            for J in 1 .. Argument_Number loop
               Size := Size + Arguments (J)'Length + 1;
            end loop;

            --  Invoke gnatbind with the arguments if the size is not too large

            if Size <= Maximum_Size then
               Spawn
                 (Gnatbind_Path.all,
                  Arguments (1 .. Argument_Number),
                  Success);

            --  Otherwise create a temporary response file

            else
               declare
                  FD            : File_Descriptor;
                  Path          : Path_Name_Type;
                  Args          : Argument_List (1 .. 1);
                  EOL           : constant String (1 .. 1) := (1 => ASCII.LF);
                  Status        : Integer;
                  Succ          : Boolean;
                  Quotes_Needed : Boolean;
                  Last_Char     : Natural;
                  Ch            : Character;

               begin
                  Tempdir.Create_Temp_File (FD, Path);
                  Args (1) := new String'("@" & Get_Name_String (Path));

                  for J in 1 .. Argument_Number loop

                     --  Check if the argument should be quoted

                     Quotes_Needed := False;
                     Last_Char     := Arguments (J)'Length;

                     for K in Arguments (J)'Range loop
                        Ch := Arguments (J) (K);

                        if Ch = ' ' or else Ch = ASCII.HT or else Ch = '"' then
                           Quotes_Needed := True;
                           exit;
                        end if;
                     end loop;

                     if Quotes_Needed then

                        --  Quote the argument, doubling '"'

                        declare
                           Arg : String (1 .. Arguments (J)'Length * 2 + 2);

                        begin
                           Arg (1) := '"';
                           Last_Char := 1;

                           for K in Arguments (J)'Range loop
                              Ch := Arguments (J) (K);
                              Last_Char := Last_Char + 1;
                              Arg (Last_Char) := Ch;

                              if Ch = '"' then
                                 Last_Char := Last_Char + 1;
                                 Arg (Last_Char) := '"';
                              end if;
                           end loop;

                           Last_Char := Last_Char + 1;
                           Arg (Last_Char) := '"';

                           Status := Write (FD, Arg'Address, Last_Char);
                        end;

                     else
                        Status := Write
                          (FD,
                           Arguments (J) (Arguments (J)'First)'Address,
                           Last_Char);
                     end if;

                     if Status /= Last_Char then
                        Fail ("disk full");
                     end if;

                     Status := Write (FD, EOL (1)'Address, 1);

                     if Status /= 1 then
                        Fail ("disk full");
                     end if;
                  end loop;

                  Close (FD);

                  --  And invoke gnatbind with this response file

                  Spawn (Gnatbind_Path.all, Args, Success);

                  Delete_File (Get_Name_String (Path), Succ);

                  --  We ignore a failure in this Delete_File operation.
                  --  Is that OK??? If so, worth a comment as to why we
                  --  are OK with the operation failing
               end;
            end if;

            if not Success then
               Com.Fail ("could not bind standalone library "
                         & Get_Name_String (For_Project.Library_Name));
            end if;
         end if;

         --  Compile the binder generated file only if Link is true

         if Link then

            --  Set the paths

            Set_Ada_Paths
              (Project             => For_Project,
               In_Tree             => In_Tree,
               Including_Libraries => True);

            --  Invoke <gcc> -c b__<lib>.adb

            --  Allocate Arguments, if first time we see a standalone library

            if Arguments = No_Argument then
               Arguments := new String_List (1 .. Initial_Argument_Max);
            end if;

            Argument_Number := 2;
            Arguments (1) := Compile_Switch;
            Arguments (2) := No_Warning;

            Add_Argument
              (B_Start & Get_Name_String (For_Project.Library_Name) & ".adb");

            --  If necessary, add the PIC option

            if PIC_Option /= "" then
               Add_Argument (PIC_Option);
            end if;

            --  Get the back-end switches and --RTS from the ALI file

            if First_ALI /= No_File then
               declare
                  T : Text_Buffer_Ptr;
                  A : ALI_Id;

               begin
                  --  Load the ALI file

                  T := Read_Library_Info (First_ALI, True);

                  --  Read it

                  A :=
                    Scan_ALI (First_ALI, T, Ignore_ED => False, Err => False);

                  if A /= No_ALI_Id then
                     for Index in
                       ALI.Units.Table
                         (ALI.ALIs.Table (A).First_Unit).First_Arg ..
                       ALI.Units.Table
                         (ALI.ALIs.Table (A).First_Unit).Last_Arg
                     loop
                        --  Do not compile with the front end switches except
                        --  for --RTS.

                        declare
                           Arg : String_Ptr renames Args.Table (Index);
                        begin
                           if not Is_Front_End_Switch (Arg.all)
                             or else
                               Arg (Arg'First + 2 .. Arg'First + 5) = "RTS="
                           then
                              Add_Argument (Arg.all);
                           end if;
                        end;
                     end loop;
                  end if;
               end;
            end if;

            --  Now all the arguments are set, compile binder generated file

            Display (Gcc);
            Spawn
              (Gcc_Path.all, Arguments (1 .. Argument_Number), Success);

            if not Success then
               Com.Fail
                ("could not compile binder generated file for library "
                  & Get_Name_String (For_Project.Library_Name));
            end if;

            --  Process binder generated file for pragmas Linker_Options

            Process_Binder_File (Arguments (3).all & ASCII.NUL);
         end if;
      end if;

      --  Build the library only if Link is True

      if Link then

         --  If attributes Library_GCC or Linker'Driver were specified, get the
         --  driver name.

         if For_Project.Config.Shared_Lib_Driver /= No_File then
            Driver_Name := Name_Id (For_Project.Config.Shared_Lib_Driver);
         end if;

         --  If attribute Library_Options was specified, add these options

         Library_Options := Value_Of
           (Name_Library_Options, For_Project.Decl.Attributes,
            In_Tree.Shared);

         if not Library_Options.Default then
            declare
               Current : String_List_Id;
               Element : String_Element;

            begin
               Current := Library_Options.Values;
               while Current /= Nil_String loop
                  Element := In_Tree.Shared.String_Elements.Table (Current);
                  Get_Name_String (Element.Value);

                  if Name_Len /= 0 then
                     Opts.Increment_Last;
                     Opts.Table (Opts.Last) :=
                       new String'(Name_Buffer (1 .. Name_Len));
                  end if;

                  Current := Element.Next;
               end loop;
            end;
         end if;

         Lib_Dirpath  :=
           new String'(Get_Name_String (For_Project.Library_Dir.Display_Name));
         Lib_Filename :=
           new String'(Get_Name_String (For_Project.Library_Name));

         case For_Project.Library_Kind is
            when Static =>
               The_Build_Mode := Static;

            when Dynamic =>
               The_Build_Mode := Dynamic;

            when Relocatable =>
               The_Build_Mode := Relocatable;

               if PIC_Option /= "" then
                  Opts.Increment_Last;
                  Opts.Table (Opts.Last) := new String'(PIC_Option);
               end if;
         end case;

         --  Get the library version, if any

         if For_Project.Lib_Internal_Name /= No_Name then
            Lib_Version :=
              new String'(Get_Name_String (For_Project.Lib_Internal_Name));
         end if;

         --  Add the objects found in the object directory and the object
         --  directories of the extended files, if any, except for generated
         --  object files (b~.. or B__..) from extended projects.
         --  When there are one or more extended files, only add an object file
         --  if no object file with the same name have already been added.

         In_Main_Object_Directory := True;

         --  For gnatmake, when the project specifies more than just Ada as a
         --  language (even if course we could not find any source file for
         --  the other languages), we will take all object files found in the
         --  object directories. Since we know the project supports at least
         --  Ada, we just have to test whether it has at least two languages,
         --  and not care about the sources.

         Foreign_Sources := For_Project.Languages.Next /= null;
         Current_Proj := For_Project;
         loop
            if Current_Proj.Object_Directory /= No_Path_Information then

               --  The following code gets far too indented ... suggest some
               --  procedural abstraction here. How about making this declare
               --  block a named procedure???

               declare
                  Object_Dir_Path : constant String :=
                                      Get_Name_String
                                        (Current_Proj.Object_Directory
                                         .Display_Name);

                  Object_Dir : Dir_Type;
                  Filename   : String (1 .. 255);
                  Last       : Natural;
                  Id         : Name_Id;

               begin
                  Open (Dir => Object_Dir, Dir_Name => Object_Dir_Path);

                  --  For all entries in the object directory

                  loop
                     Read (Object_Dir, Filename, Last);

                     exit when Last = 0;

                     --  Check if it is an object file

                     if Is_Obj (Filename (1 .. Last)) then
                        declare
                           Object_Path  : constant String :=
                                            Normalize_Pathname
                                              (Object_Dir_Path
                                               & Directory_Separator
                                               & Filename (1 .. Last));
                           Object_File  : constant String :=
                                            Filename (1 .. Last);

                           C_Filename    : String := Object_File;

                        begin
                           Canonical_Case_File_Name (C_Filename);

                           --  If in the object directory of an extended
                           --  project, do not consider generated object files.

                           if In_Main_Object_Directory
                             or else Last < 5
                             or else
                               C_Filename (1 .. B_Start'Length) /= B_Start
                           then
                              Name_Len := 0;
                              Add_Str_To_Name_Buffer (C_Filename);
                              Id := Name_Find;

                              if not Objects_Htable.Get (Id) then
                                 declare
                                    ALI_File : constant String :=
                                                 Ext_To (C_Filename, "ali");

                                    ALI_Path : constant String :=
                                                 Ext_To (Object_Path, "ali");

                                    Add_It : Boolean;
                                    Fname  : File_Name_Type;
                                    Proj   : Project_Id;
                                    Index  : Unit_Index;

                                 begin
                                    --  The following assignment could use
                                    --  a comment ???

                                    Add_It :=
                                      Foreign_Sources
                                        or else
                                          (Last >= 5
                                             and then
                                               C_Filename (1 .. B_Start'Length)
                                                 = B_Start);

                                    if Is_Regular_File (ALI_Path) then

                                       --  If there is an ALI file, check if
                                       --  the object file should be added to
                                       --  the library. If there are foreign
                                       --  sources we put all object files in
                                       --  the library.

                                       if not Add_It then
                                          Index :=
                                            Units_Htable.Get_First
                                             (In_Tree.Units_HT);
                                          while Index /= null loop
                                             if Index.File_Names (Impl) /=
                                               null
                                             then
                                                Proj :=
                                                  Index.File_Names (Impl)
                                                  .Project;
                                                Fname :=
                                                  Index.File_Names (Impl).File;

                                             elsif Index.File_Names (Spec) /=
                                               null
                                             then
                                                Proj :=
                                                  Index.File_Names (Spec)
                                                  .Project;
                                                Fname :=
                                                  Index.File_Names (Spec).File;

                                             else
                                                Proj := No_Project;
                                             end if;

                                             Add_It := Proj /= No_Project;

                                             --  If the source is in the
                                             --  project or a project it
                                             --  extends, we may put it in
                                             --  the library.

                                             if Add_It then
                                                Add_It := Check_Project (Proj);
                                             end if;

                                             --  But we don't, if the ALI file
                                             --  does not correspond to the
                                             --  unit.

                                             if Add_It then
                                                declare
                                                   F : constant String :=
                                                         Ext_To
                                                           (Get_Name_String
                                                              (Fname), "ali");
                                                begin
                                                   Add_It := F = ALI_File;
                                                end;
                                             end if;

                                             exit when Add_It;

                                             Index :=
                                               Units_Htable.Get_Next
                                                 (In_Tree.Units_HT);
                                          end loop;
                                       end if;

                                       if Add_It then
                                          Objects_Htable.Set (Id, True);
                                          Objects.Append
                                            (new String'(Object_Path));

                                          --  Record the ALI file

                                          ALIs.Append (new String'(ALI_Path));

                                          --  Find out if for this ALI file,
                                          --  libgnarl is necessary.

                                          Check_Libs (ALI_Path, True);
                                       end if;

                                    elsif Foreign_Sources then
                                       Objects.Append
                                         (new String'(Object_Path));
                                    end if;
                                 end;
                              end if;
                           end if;
                        end;
                     end if;
                  end loop;

                  Close (Dir => Object_Dir);

               exception
                  when Directory_Error =>
                     Com.Fail ("cannot find object directory """
                               & Get_Name_String
                                  (Current_Proj.Object_Directory.Display_Name)
                               & """");
               end;
            end if;

            exit when Current_Proj.Extends = No_Project;

            In_Main_Object_Directory  := False;
            Current_Proj := Current_Proj.Extends;
         end loop;

         --  Add the -L and -l switches for the imported Library Project Files,
         --  and, if Path Option is supported, the library directory path names
         --  to Rpath.

         Process_Imported_Libraries;

         --  Link with libgnat and possibly libgnarl

         Opts.Increment_Last;
         Opts.Table (Opts.Last) := new String'("-L" & Lib_Directory);

         --  If Path Option supported, add libgnat directory path name to Rpath

         if Path_Option /= null then
            declare
               Libdir    : constant String := Lib_Directory;
               GCC_Index : Natural := 0;

            begin
               Add_Rpath (Libdir);

               --  For shared libraries, add to the Path Option the directory
               --  of the shared version of libgcc.

               if The_Build_Mode /= Static then
                  GCC_Index := Index (Libdir, "/lib/");

                  if GCC_Index = 0 then
                     GCC_Index :=
                       Index
                         (Libdir,
                          Directory_Separator & "lib" & Directory_Separator);
                  end if;

                  if GCC_Index /= 0 then
                     Add_Rpath (Libdir (Libdir'First .. GCC_Index + 3));
                  end if;
               end if;
            end;
         end if;

         if Libgnarl_Needed = Yes then
            Opts.Increment_Last;

            if The_Build_Mode = Static then
               Opts.Table (Opts.Last) := new String'("-lgnarl");
            else
               Opts.Table (Opts.Last) := new String'(Shared_Lib ("gnarl"));
            end if;
         end if;

         Opts.Increment_Last;

         if The_Build_Mode = Static then
            Opts.Table (Opts.Last) := new String'("-lgnat");
         else
            Opts.Table (Opts.Last) := new String'(Shared_Lib ("gnat"));
         end if;

         --  If Path Option is supported, add the necessary switch with the
         --  content of Rpath. As Rpath contains at least libgnat directory
         --  path name, it is guaranteed that it is not null.

         if Opt.Run_Path_Option and then Path_Option /= null then
            Opts.Increment_Last;
            Opts.Table (Opts.Last) :=
              new String'(Path_Option.all & Rpath (1 .. Rpath_Last));
            Free (Path_Option);
            Free (Rpath);
         end if;

         Object_Files :=
           new Argument_List'
             (Argument_List (Objects.Table (1 .. Objects.Last)));

         Ali_Files :=
           new Argument_List'(Argument_List (ALIs.Table (1 .. ALIs.Last)));

         Options :=
           new Argument_List'(Argument_List (Opts.Table (1 .. Opts.Last)));

         --  We fail if there are no object to put in the library
         --  (Ada or foreign objects).

         if Object_Files'Length = 0 then
            Com.Fail ("no object files for library """ &
                      Lib_Filename.all & '"');
         end if;

         if not Opt.Quiet_Output then
            Write_Eol;
            Write_Str  ("building ");
            Write_Str (Ada.Characters.Handling.To_Lower
                         (Build_Mode_State'Image (The_Build_Mode)));
            Write_Str  (" library for project ");
            Write_Line (Project_Name);

            --  Only output list of object files and ALI files in verbose mode

            if Opt.Verbose_Mode then
               Write_Eol;

               Write_Line ("object files:");

               for Index in Object_Files'Range loop
                  Write_Str  ("   ");
                  Write_Line (Object_Files (Index).all);
               end loop;

               Write_Eol;

               if Ali_Files'Length = 0 then
                  Write_Line ("NO ALI files");

               else
                  Write_Line ("ALI files:");

                  for Index in Ali_Files'Range loop
                     Write_Str  ("   ");
                     Write_Line (Ali_Files (Index).all);
                  end loop;
               end if;

               Write_Eol;
            end if;
         end if;

         --  We check that all object files are regular files

         Check_Context;

         --  Delete the existing library file, if it exists. Fail if the
         --  library file is not writable, or if it is not possible to delete
         --  the file.

         declare
            DLL_Name : aliased String :=
                         Lib_Dirpath.all & Directory_Separator & DLL_Prefix &
                           Lib_Filename.all & "." & DLL_Ext;

            Archive_Name : aliased String :=
                             Lib_Dirpath.all & Directory_Separator & "lib" &
                               Lib_Filename.all & "." & Archive_Ext;

            type Str_Ptr is access all String;
            --  This type is necessary to meet the accessibility rules of Ada.
            --  It is not possible to use String_Access here.

            Full_Lib_Name : Str_Ptr;
            --  Designates the full library path name. Either DLL_Name or
            --  Archive_Name, depending on the library kind.

            Success : Boolean;
            pragma Warnings (Off, Success);
            --  Used to call Delete_File

         begin
            if The_Build_Mode = Static then
               Full_Lib_Name := Archive_Name'Access;
            else
               Full_Lib_Name := DLL_Name'Access;
            end if;

            if Is_Regular_File (Full_Lib_Name.all) then
               if Is_Writable_File (Full_Lib_Name.all) then
                  Delete_File (Full_Lib_Name.all, Success);
               end if;

               if Is_Regular_File (Full_Lib_Name.all) then
                  Com.Fail ("could not delete """ & Full_Lib_Name.all & """");
               end if;
            end if;
         end;

         Argument_Number := 0;

         --  If we have a standalone library, gather all the interface ALI.
         --  They are flagged as Interface when we copy them to the library
         --  directory (by Copy_ALI_Files, below).

         if Standalone then
            Current_Proj := For_Project;

            declare
               Iface : String_List_Id := For_Project.Lib_Interface_ALIs;
               ALI   : File_Name_Type;

            begin
               while Iface /= Nil_String loop
                  ALI :=
                    File_Name_Type
                      (In_Tree.Shared.String_Elements.Table (Iface).Value);
                  Interface_ALIs.Set (ALI, True);
                  Get_Name_String
                    (In_Tree.Shared.String_Elements.Table (Iface).Value);
                  Add_Argument (Name_Buffer (1 .. Name_Len));
                  Iface := In_Tree.Shared.String_Elements.Table (Iface).Next;
               end loop;

               Iface := For_Project.Lib_Interface_ALIs;

               if not Opt.Quiet_Output then

                  --  Check that the interface set is complete: any unit in the
                  --  library that is needed by an interface should also be an
                  --  interface. If it is not the case, output a warning.

                  while Iface /= Nil_String loop
                     ALI :=
                       File_Name_Type
                         (In_Tree.Shared.String_Elements.Table (Iface).Value);
                     Process (ALI);
                     Iface :=
                       In_Tree.Shared.String_Elements.Table (Iface).Next;
                  end loop;
               end if;
            end;
         end if;

         declare
            Current_Dir  : constant String := Get_Current_Dir;
            Dir          : Dir_Type;

            Name : String (1 .. 200);
            Last : Natural;

            Disregard : Boolean;
            pragma Warnings (Off, Disregard);

            DLL_Name : aliased constant String :=
                         Lib_Filename.all & "." & DLL_Ext;

            Archive_Name : aliased constant String :=
                             Lib_Filename.all & "." & Archive_Ext;

            Delete : Boolean := False;

         begin
            --  Clean the library directory: remove any file with the name of
            --  the library file and any ALI file of a source of the project.

            begin
               Get_Name_String (For_Project.Library_Dir.Display_Name);
               Change_Dir (Name_Buffer (1 .. Name_Len));

            exception
               when others =>
                  Com.Fail
                    ("unable to access library directory """
                     & Name_Buffer (1 .. Name_Len)
                     & """");
            end;

            Open (Dir, ".");

            loop
               Read (Dir, Name, Last);
               exit when Last = 0;

               declare
                  Filename : constant String := Name (1 .. Last);

               begin
                  if Is_Regular_File (Filename) then
                     Canonical_Case_File_Name (Name (1 .. Last));
                     Delete := False;

                     if (The_Build_Mode = Static
                          and then Name (1 .. Last) =  Archive_Name)
                       or else
                         ((The_Build_Mode = Dynamic
                            or else
                           The_Build_Mode = Relocatable)
                          and then Name (1 .. Last) = DLL_Name)
                     then
                        Delete := True;

                     elsif Last > 4
                       and then Name (Last - 3 .. Last) = ".ali"
                     then
                        declare
                           Unit : Unit_Index;

                        begin
                           --  Compare with ALI file names of the project

                           Unit := Units_Htable.Get_First (In_Tree.Units_HT);
                           while Unit /= No_Unit_Index loop
                              if Unit.File_Names (Impl) /= null
                                and then Unit.File_Names (Impl).Project /=
                                                                 No_Project
                              then
                                 if Ultimate_Extending_Project_Of
                                      (Unit.File_Names (Impl).Project) =
                                                                 For_Project
                                 then
                                    Get_Name_String
                                      (Unit.File_Names (Impl).File);
                                    Name_Len :=
                                      Name_Len -
                                        File_Extension
                                          (Name (1 .. Name_Len))'Length;

                                    if Name_Buffer (1 .. Name_Len) =
                                      Name (1 .. Last - 4)
                                    then
                                       Delete := True;
                                       exit;
                                    end if;
                                 end if;

                              elsif Unit.File_Names (Spec) /= null
                                and then Ultimate_Extending_Project_Of
                                           (Unit.File_Names (Spec).Project) =
                                                                   For_Project
                              then
                                 Get_Name_String (Unit.File_Names (Spec).File);
                                 Name_Len :=
                                   Name_Len -
                                     File_Extension (Name (1 .. Last))'Length;

                                 if Name_Buffer (1 .. Name_Len) =
                                      Name (1 .. Last - 4)
                                 then
                                    Delete := True;
                                    exit;
                                 end if;
                              end if;

                              Unit := Units_Htable.Get_Next (In_Tree.Units_HT);
                           end loop;
                        end;
                     end if;

                     if Delete then
                        Set_Writable (Filename);
                        Delete_File (Filename, Disregard);
                     end if;
                  end if;
               end;
            end loop;

            Close (Dir);

            Change_Dir (Current_Dir);
         end;

         --  Call procedure to build the library, depending on the build mode

         case The_Build_Mode is
            when Dynamic | Relocatable =>
               Build_Dynamic_Library
                 (Ofiles        => Object_Files.all,
                  Options       => Options.all,
                  Interfaces    => Arguments (1 .. Argument_Number),
                  Lib_Filename  => Lib_Filename.all,
                  Lib_Dir       => Lib_Dirpath.all,
                  Symbol_Data   => Current_Proj.Symbol_Data,
                  Driver_Name   => Driver_Name,
                  Lib_Version   => Lib_Version.all,
                  Auto_Init     => Current_Proj.Lib_Auto_Init);

            when Static =>
               MLib.Build_Library
                 (Object_Files.all,
                  Lib_Filename.all,
                  Lib_Dirpath.all);

            when None =>
               null;
         end case;

         --  We need to copy the ALI files from the object directory to the
         --  library ALI directory, so that the linker find them there, and
         --  does not need to look in the object directory where it would also
         --  find the object files; and we don't want that: we want the linker
         --  to use the library.

         --  Copy the ALI files and make the copies read-only. For interfaces,
         --  mark the copies as interfaces.

         Copy_ALI_Files
           (Files      => Ali_Files.all,
            To         => For_Project.Library_ALI_Dir.Display_Name,
            Interfaces => Arguments (1 .. Argument_Number));

         --  Copy interface sources if Library_Src_Dir specified

         if Standalone
           and then For_Project.Library_Src_Dir /= No_Path_Information
         then
            --  Clean the interface copy directory: remove any source that
            --  could be a source of the project.

            begin
               Get_Name_String (For_Project.Library_Src_Dir.Display_Name);
               Change_Dir (Name_Buffer (1 .. Name_Len));

            exception
               when others =>
                  Com.Fail
                    ("unable to access library source copy directory """
                     & Name_Buffer (1 .. Name_Len)
                     & """");
            end;

            declare
               Dir    : Dir_Type;
               Delete : Boolean := False;
               Unit   : Unit_Index;

               Name : String (1 .. 200);
               Last : Natural;

               Disregard : Boolean;
               pragma Warnings (Off, Disregard);

            begin
               Open (Dir, ".");

               loop
                  Read (Dir, Name, Last);
                  exit when Last = 0;

                  if Is_Regular_File (Name (1 .. Last)) then
                     Canonical_Case_File_Name (Name (1 .. Last));
                     Delete := False;

                     --  Compare with source file names of the project

                     Unit := Units_Htable.Get_First (In_Tree.Units_HT);
                     while Unit /= No_Unit_Index loop
                        if Unit.File_Names (Impl) /= null
                          and then Ultimate_Extending_Project_Of
                            (Unit.File_Names (Impl).Project) = For_Project
                          and then
                            Get_Name_String
                              (Unit.File_Names (Impl).File) =
                            Name (1 .. Last)
                        then
                           Delete := True;
                           exit;
                        end if;

                        if Unit.File_Names (Spec) /= null
                          and then Ultimate_Extending_Project_Of
                            (Unit.File_Names (Spec).Project) =
                             For_Project
                          and then
                           Get_Name_String
                             (Unit.File_Names (Spec).File) =
                           Name (1 .. Last)
                        then
                           Delete := True;
                           exit;
                        end if;

                        Unit := Units_Htable.Get_Next (In_Tree.Units_HT);
                     end loop;
                  end if;

                  if Delete then
                     Set_Writable (Name (1 .. Last));
                     Delete_File (Name (1 .. Last), Disregard);
                  end if;
               end loop;

               Close (Dir);
            end;

            Copy_Interface_Sources
              (For_Project => For_Project,
               In_Tree     => In_Tree,
               Interfaces  => Arguments (1 .. Argument_Number),
               To_Dir      => For_Project.Library_Src_Dir.Display_Name);
         end if;
      end if;

      --  Reset the current working directory to its previous value

      Change_Dir (Current_Dir);
   end Build_Library;

   -----------
   -- Check --
   -----------

   procedure Check (Filename : String) is
   begin
      if not Is_Regular_File (Filename) then
         Com.Fail (Filename & " not found.");
      end if;
   end Check;

   -------------------
   -- Check_Context --
   -------------------

   procedure Check_Context is
   begin
      --  Check that each object file exists

      for F in Object_Files'Range loop
         Check (Object_Files (F).all);
      end loop;
   end Check_Context;

   -------------------
   -- Check_Library --
   -------------------

   procedure Check_Library
     (For_Project : Project_Id; In_Tree : Project_Tree_Ref)
   is
      Lib_TS  : Time_Stamp_Type;
      Current : constant Dir_Name_Str := Get_Current_Dir;

   begin
      --  No need to build the library if there is no object directory,
      --  hence no object files to build the library.

      if For_Project.Library then
         declare
            Lib_Name : constant File_Name_Type :=
                         Library_File_Name_For (For_Project, In_Tree);
         begin
            Change_Dir
              (Get_Name_String (For_Project.Library_Dir.Display_Name));
            Lib_TS := File_Stamp (Lib_Name);
            For_Project.Library_TS := Lib_TS;
         end;

         if not For_Project.Externally_Built
           and then not For_Project.Need_To_Build_Lib
           and then For_Project.Object_Directory /= No_Path_Information
         then
            declare
               Obj_TS     : Time_Stamp_Type;
               Object_Dir : Dir_Type;

            begin
               --  If the library file does not exist, then the time stamp will
               --  be Empty_Time_Stamp, earlier than any other time stamp.

               Change_Dir
                 (Get_Name_String (For_Project.Object_Directory.Display_Name));
               Open (Dir => Object_Dir, Dir_Name => ".");

               --  For all entries in the object directory

               loop
                  Read (Object_Dir, Name_Buffer, Name_Len);
                  exit when Name_Len = 0;

                  --  Check if it is an object file, but ignore any binder
                  --  generated file.

                  if Is_Obj (Name_Buffer (1 .. Name_Len))
                    and then Name_Buffer (1 .. B_Start'Length) /= B_Start
                  then
                     --  Get the object file time stamp

                     Obj_TS := File_Stamp (File_Name_Type'(Name_Find));

                     --  If library file time stamp is earlier, set
                     --  Need_To_Build_Lib and return. String comparison is
                     --  used, otherwise time stamps may be too close and the
                     --  comparison would return True, which would trigger
                     --  an unnecessary rebuild of the library.

                     if String (Lib_TS) < String (Obj_TS) then

                        --  Library must be rebuilt

                        For_Project.Need_To_Build_Lib := True;
                        exit;
                     end if;
                  end if;
               end loop;

               Close (Object_Dir);
            end;
         end if;

         Change_Dir (Current);
      end if;
   end Check_Library;

   ----------------------------
   -- Copy_Interface_Sources --
   ----------------------------

   procedure Copy_Interface_Sources
     (For_Project : Project_Id;
      In_Tree     : Project_Tree_Ref;
      Interfaces  : Argument_List;
      To_Dir      : Path_Name_Type)
   is
      Current : constant Dir_Name_Str := Get_Current_Dir;
      --  The current directory, where to return to at the end

      Target : constant Dir_Name_Str := Get_Name_String (To_Dir);
      --  The directory where to copy sources

      Text     : Text_Buffer_Ptr;
      The_ALI  : ALI.ALI_Id;
      Lib_File : File_Name_Type;

      First_Unit  : ALI.Unit_Id;
      Second_Unit : ALI.Unit_Id;

      Copy_Subunits : Boolean := False;
      --  When True, indicates that subunits, if any, need to be copied too

      procedure Copy (File_Name : File_Name_Type);
      --  Copy one source of the project to the target directory

      ----------
      -- Copy --
      ----------

      procedure Copy (File_Name : File_Name_Type) is
         Success : Boolean;
         pragma Warnings (Off, Success);

         Source : Standard.Prj.Source_Id;
      begin
         Source := Find_Source
           (In_Tree, For_Project,
            In_Extended_Only => True,
            Base_Name => File_Name);

         if Source /= No_Source
           and then not Source.Locally_Removed
           and then Source.Replaced_By = No_Source
         then
            Copy_File
              (Get_Name_String (Source.Path.Name),
               Target,
               Success,
               Mode     => Overwrite,
               Preserve => Preserve);
         end if;
      end Copy;

   --  Start of processing for Copy_Interface_Sources

   begin
      --  Change the working directory to the object directory

      Change_Dir (Get_Name_String (For_Project.Object_Directory.Display_Name));

      for Index in Interfaces'Range loop

         --  First, load the ALI file

         Name_Len := 0;
         Add_Str_To_Name_Buffer (Interfaces (Index).all);
         Lib_File := Name_Find;
         Text := Read_Library_Info (Lib_File);
         The_ALI := Scan_ALI (Lib_File, Text, Ignore_ED => False, Err => True);
         Free (Text);

         Second_Unit := No_Unit_Id;
         First_Unit := ALI.ALIs.Table (The_ALI).First_Unit;
         Copy_Subunits := True;

         --  If there is both a spec and a body, check if they are both needed

         if ALI.Units.Table (First_Unit).Utype = Is_Body then
            Second_Unit := ALI.ALIs.Table (The_ALI).Last_Unit;

            --  If the body is not needed, then reset First_Unit

            if not ALI.Units.Table (Second_Unit).Body_Needed_For_SAL then
               First_Unit := No_Unit_Id;
               Copy_Subunits := False;
            end if;

         elsif ALI.Units.Table (First_Unit).Utype = Is_Spec_Only then
            Copy_Subunits := False;
         end if;

         --  Copy the file(s) that need to be copied

         if First_Unit /= No_Unit_Id then
            Copy (File_Name => ALI.Units.Table (First_Unit).Sfile);
         end if;

         if Second_Unit /= No_Unit_Id then
            Copy (File_Name => ALI.Units.Table (Second_Unit).Sfile);
         end if;

         --  Copy all the separates, if any

         if Copy_Subunits then
            for Dep in ALI.ALIs.Table (The_ALI).First_Sdep ..
              ALI.ALIs.Table (The_ALI).Last_Sdep
            loop
               if Sdep.Table (Dep).Subunit_Name /= No_Name then
                  Copy (File_Name => Sdep.Table (Dep).Sfile);
               end if;
            end loop;
         end if;
      end loop;

      --  Restore the initial working directory

      Change_Dir (Current);
   end Copy_Interface_Sources;

   -------------
   -- Display --
   -------------

   procedure Display (Executable : String) is
   begin
      if not Opt.Quiet_Output then
         Write_Str (Executable);

         for Index in 1 .. Argument_Number loop
            Write_Char (' ');
            Write_Str (Arguments (Index).all);

            if not Opt.Verbose_Mode and then Index > 4 then
               Write_Str (" ...");
               exit;
            end if;
         end loop;

         Write_Eol;
      end if;
   end Display;

   -----------
   -- Index --
   -----------

   function Index (S, Pattern : String) return Natural is
      Len : constant Natural := Pattern'Length;

   begin
      for J in reverse S'First .. S'Last - Len + 1 loop
         if Pattern = S (J .. J + Len - 1) then
            return J;
         end if;
      end loop;

      return 0;
   end Index;

   -------------------------
   -- Process_Binder_File --
   -------------------------

   procedure Process_Binder_File (Name : String) is
      Fd : FILEs;
      --  Binder file's descriptor

      Read_Mode : constant String := "r" & ASCII.NUL;
      --  For fopen

      Status : Interfaces.C_Streams.int;
      pragma Unreferenced (Status);
      --  For fclose

      Begin_Info : constant String := "--  BEGIN Object file/option list";
      End_Info   : constant String := "--  END Object file/option list   ";

      Next_Line : String (1 .. 1000);
      --  Current line value
      --  Where does this odd constant 1000 come from, looks suspicious ???

      Nlast : Integer;
      --  End of line slice (the slice does not contain the line terminator)

      procedure Get_Next_Line;
      --  Read the next line from the binder file without the line terminator

      -------------------
      -- Get_Next_Line --
      -------------------

      procedure Get_Next_Line is
         Fchars : chars;

      begin
         Fchars := fgets (Next_Line'Address, Next_Line'Length, Fd);

         if Fchars = System.Null_Address then
            Fail ("Error reading binder output");
         end if;

         Nlast := 1;
         while Nlast <= Next_Line'Last
           and then Next_Line (Nlast) /= ASCII.LF
           and then Next_Line (Nlast) /= ASCII.CR
         loop
            Nlast := Nlast + 1;
         end loop;

         Nlast := Nlast - 1;
      end Get_Next_Line;

   --  Start of processing for Process_Binder_File

   begin
      Fd := fopen (Name'Address, Read_Mode'Address);

      if Fd = NULL_Stream then
         Fail ("Failed to open binder output");
      end if;

      --  Skip up to the Begin Info line

      loop
         Get_Next_Line;
         exit when Next_Line (1 .. Nlast) = Begin_Info;
      end loop;

      --  Find the first switch

      loop
         Get_Next_Line;

         exit when Next_Line (1 .. Nlast) = End_Info;

         --  As the binder generated file is in Ada, remove the first eight
         --  characters "   --   ".

         Next_Line (1 .. Nlast - 8) := Next_Line (9 .. Nlast);
         Nlast := Nlast - 8;

         --  Stop when the first switch is found

         exit when Next_Line (1) = '-';
      end loop;

      if Next_Line (1 .. Nlast) /= End_Info then
         loop
            --  Ignore -static and -shared, since -shared will be used
            --  in any case.

            --  Ignore -lgnat and -lgnarl as they will be added later,
            --  because they are also needed for non Stand-Alone shared
            --  libraries.

            --  Also ignore the shared libraries which are:

            --  -lgnat-<version>  (7 + version'length chars)
            --  -lgnarl-<version> (8 + version'length chars)

            if Next_Line (1 .. Nlast) /= "-static" and then
               Next_Line (1 .. Nlast) /= "-shared" and then
               Next_Line (1 .. Nlast) /= "-lgnarl" and then
               Next_Line (1 .. Nlast) /= "-lgnat"
              and then
                Next_Line
                  (1 .. Natural'Min (Nlast, 8 + Library_Version'Length)) /=
                    Shared_Lib ("gnarl")
              and then
                Next_Line
                  (1 .. Natural'Min (Nlast, 7 + Library_Version'Length)) /=
                    Shared_Lib ("gnat")
            then
               if Next_Line (1) /= '-' then

                  --  This is not an option, should we add it?

                  if Add_Object_Files then
                     Opts.Increment_Last;
                     Opts.Table (Opts.Last) :=
                       new String'(Next_Line (1 .. Nlast));
                  end if;

               else
                  --  Add all other options

                  Opts.Increment_Last;
                  Opts.Table (Opts.Last) :=
                    new String'(Next_Line (1 .. Nlast));
               end if;
            end if;

            --  Next option, if any

            Get_Next_Line;
            exit when Next_Line (1 .. Nlast) = End_Info;

            --  Remove first eight characters "   --   "

            Next_Line (1 .. Nlast - 8) := Next_Line (9 .. Nlast);
            Nlast := Nlast - 8;
         end loop;
      end if;

      Status := fclose (Fd);

      --  Is it really right to ignore any close error ???

   end Process_Binder_File;

   ------------------
   -- Reset_Tables --
   ------------------

   procedure Reset_Tables is
   begin
      Objects.Init;
      Objects_Htable.Reset;
      ALIs.Init;
      Opts.Init;
      Processed_Projects.Reset;
      Library_Projs.Init;
   end Reset_Tables;

   ---------------------------
   -- SALs_Use_Constructors --
   ---------------------------

   function SALs_Use_Constructors return Boolean is
      function C_SALs_Init_Using_Constructors return Integer;
      pragma Import (C, C_SALs_Init_Using_Constructors,
                     "__gnat_sals_init_using_constructors");
   begin
      return C_SALs_Init_Using_Constructors /= 0;
   end SALs_Use_Constructors;

end MLib.Prj;