URL https://opencores.org/ocsvn/openrisc/openrisc/trunk
Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [gcc-4.5.1/] [gcc/] [ada/] [prj-env.adb] - Blame information for rev 826

Details | Compare with Previous | View Log

------------------------------------------------------------------------------
--                                                                          --
--                         GNAT COMPILER COMPONENTS                         --
--                                                                          --
--                              P R J . E N V                               --
--                                                                          --
--                                 B o d y                                  --
--                                                                          --
--          Copyright (C) 2001-2009, Free Software Foundation, Inc.         --
--                                                                          --
-- 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 Fmap;
with Opt;
with Osint;    use Osint;
with Output;   use Output;
with Prj.Com;  use Prj.Com;
with Tempdir;
 
package body Prj.Env is
 
   Buffer_Initial : constant := 1_000;
   --  Initial size of Buffer
 
   -----------------------
   -- Local Subprograms --
   -----------------------
 
   package Source_Path_Table is new GNAT.Dynamic_Tables
     (Table_Component_Type => Name_Id,
      Table_Index_Type     => Natural,
      Table_Low_Bound      => 1,
      Table_Initial        => 50,
      Table_Increment      => 100);
   --  A table to store the source dirs before creating the source path file
 
   package Object_Path_Table is new GNAT.Dynamic_Tables
     (Table_Component_Type => Path_Name_Type,
      Table_Index_Type     => Natural,
      Table_Low_Bound      => 1,
      Table_Initial        => 50,
      Table_Increment      => 100);
   --  A table to store the object dirs, before creating the object path file
 
   procedure Add_To_Buffer
     (S           : String;
      Buffer      : in out String_Access;
      Buffer_Last : in out Natural);
   --  Add a string to Buffer, extending Buffer if needed
 
   procedure Add_To_Path
     (Source_Dirs : String_List_Id;
      In_Tree     : Project_Tree_Ref;
      Buffer      : in out String_Access;
      Buffer_Last : in out Natural);
   --  Add to Ada_Path_Buffer all the source directories in string list
   --  Source_Dirs, if any.
 
   procedure Add_To_Path
     (Dir         : String;
      Buffer      : in out String_Access;
      Buffer_Last : in out Natural);
   --  If Dir is not already in the global variable Ada_Path_Buffer, add it.
   --  If Buffer_Last /= 0, prepend a Path_Separator character to Path.
 
   procedure Add_To_Source_Path
     (Source_Dirs  : String_List_Id;
      In_Tree      : Project_Tree_Ref;
      Source_Paths : in out Source_Path_Table.Instance);
   --  Add to Ada_Path_B all the source directories in string list
   --  Source_Dirs, if any. Increment Ada_Path_Length.
 
   procedure Add_To_Object_Path
     (Object_Dir   : Path_Name_Type;
      Object_Paths : in out Object_Path_Table.Instance);
   --  Add Object_Dir to object path table. Make sure it is not duplicate
   --  and it is the last one in the current table.
 
   procedure Set_Path_File_Var (Name : String; Value : String);
   --  Call Setenv, after calling To_Host_File_Spec
 
   function Ultimate_Extension_Of
     (Project : Project_Id) return Project_Id;
   --  Return a project that is either Project or an extended ancestor of
   --  Project that itself is not extended.
 
   ----------------------
   -- Ada_Include_Path --
   ----------------------
 
   function Ada_Include_Path
     (Project   : Project_Id;
      In_Tree   : Project_Tree_Ref;
      Recursive : Boolean := False) return String
   is
      Buffer      : String_Access;
      Buffer_Last : Natural := 0;
 
      procedure Add (Project : Project_Id; Dummy : in out Boolean);
      --  Add source dirs of Project to the path
 
      ---------
      -- Add --
      ---------
 
      procedure Add (Project : Project_Id; Dummy : in out Boolean) is
         pragma Unreferenced (Dummy);
      begin
         Add_To_Path (Project.Source_Dirs, In_Tree, Buffer, Buffer_Last);
      end Add;
 
      procedure For_All_Projects is
        new For_Every_Project_Imported (Boolean, Add);
 
      Dummy : Boolean := False;
 
   --  Start of processing for Ada_Include_Path
 
   begin
      if Recursive then
 
         --  If it is the first time we call this function for
         --  this project, compute the source path
 
         if Project.Ada_Include_Path = null then
            Buffer := new String (1 .. 4096);
            For_All_Projects (Project, Dummy);
            Project.Ada_Include_Path := new String'(Buffer (1 .. Buffer_Last));
            Free (Buffer);
         end if;
 
         return Project.Ada_Include_Path.all;
 
      else
         Buffer := new String (1 .. 4096);
         Add_To_Path (Project.Source_Dirs, In_Tree, Buffer, Buffer_Last);
 
         declare
            Result : constant String := Buffer (1 .. Buffer_Last);
         begin
            Free (Buffer);
            return Result;
         end;
      end if;
   end Ada_Include_Path;
 
   ----------------------
   -- Ada_Objects_Path --
   ----------------------
 
   function Ada_Objects_Path
     (Project             : Project_Id;
      Including_Libraries : Boolean := True) return String_Access
   is
      Buffer      : String_Access;
      Buffer_Last : Natural := 0;
 
      procedure Add (Project : Project_Id; Dummy : in out Boolean);
      --  Add all the object directories of a project to the path
 
      ---------
      -- Add --
      ---------
 
      procedure Add (Project : Project_Id; Dummy : in out Boolean) is
         pragma Unreferenced (Dummy);
         Path : constant Path_Name_Type :=
                  Get_Object_Directory
                    (Project,
                     Including_Libraries => Including_Libraries,
                     Only_If_Ada         => False);
      begin
         if Path /= No_Path then
            Add_To_Path (Get_Name_String (Path), Buffer, Buffer_Last);
         end if;
      end Add;
 
      procedure For_All_Projects is
        new For_Every_Project_Imported (Boolean, Add);
 
      Dummy : Boolean := False;
 
   --  Start of processing for Ada_Objects_Path
 
   begin
      --  If it is the first time we call this function for
      --  this project, compute the objects path
 
      if Project.Ada_Objects_Path = null then
         Buffer := new String (1 .. 4096);
         For_All_Projects (Project, Dummy);
 
         Project.Ada_Objects_Path := new String'(Buffer (1 .. Buffer_Last));
         Free (Buffer);
      end if;
 
      return Project.Ada_Objects_Path;
   end Ada_Objects_Path;
 
   -------------------
   -- Add_To_Buffer --
   -------------------
 
   procedure Add_To_Buffer
     (S           : String;
      Buffer      : in out String_Access;
      Buffer_Last : in out Natural)
   is
      Last : constant Natural := Buffer_Last + S'Length;
 
   begin
      while Last > Buffer'Last loop
         declare
            New_Buffer : constant String_Access :=
                           new String (1 .. 2 * Buffer'Last);
         begin
            New_Buffer (1 .. Buffer_Last) := Buffer (1 .. Buffer_Last);
            Free (Buffer);
            Buffer := New_Buffer;
         end;
      end loop;
 
      Buffer (Buffer_Last + 1 .. Last) := S;
      Buffer_Last := Last;
   end Add_To_Buffer;
 
   ------------------------
   -- Add_To_Object_Path --
   ------------------------
 
   procedure Add_To_Object_Path
     (Object_Dir   : Path_Name_Type;
      Object_Paths : in out Object_Path_Table.Instance)
   is
   begin
      --  Check if the directory is already in the table
 
      for Index in Object_Path_Table.First ..
                   Object_Path_Table.Last (Object_Paths)
      loop
 
         --  If it is, remove it, and add it as the last one
 
         if Object_Paths.Table (Index) = Object_Dir then
            for Index2 in Index + 1 ..
                          Object_Path_Table.Last (Object_Paths)
            loop
               Object_Paths.Table (Index2 - 1) := Object_Paths.Table (Index2);
            end loop;
 
            Object_Paths.Table
              (Object_Path_Table.Last (Object_Paths)) := Object_Dir;
            return;
         end if;
      end loop;
 
      --  The directory is not already in the table, add it
 
      Object_Path_Table.Append (Object_Paths, Object_Dir);
   end Add_To_Object_Path;
 
   -----------------
   -- Add_To_Path --
   -----------------
 
   procedure Add_To_Path
     (Source_Dirs : String_List_Id;
      In_Tree     : Project_Tree_Ref;
      Buffer      : in out String_Access;
      Buffer_Last : in out Natural)
   is
      Current    : String_List_Id := Source_Dirs;
      Source_Dir : String_Element;
   begin
      while Current /= Nil_String loop
         Source_Dir := In_Tree.String_Elements.Table (Current);
         Add_To_Path (Get_Name_String (Source_Dir.Display_Value),
                      Buffer, Buffer_Last);
         Current := Source_Dir.Next;
      end loop;
   end Add_To_Path;
 
   procedure Add_To_Path
     (Dir         : String;
      Buffer      : in out String_Access;
      Buffer_Last : in out Natural)
   is
      Len        : Natural;
      New_Buffer : String_Access;
      Min_Len    : Natural;
 
      function Is_Present (Path : String; Dir : String) return Boolean;
      --  Return True if Dir is part of Path
 
      ----------------
      -- Is_Present --
      ----------------
 
      function Is_Present (Path : String; Dir : String) return Boolean is
         Last : constant Integer := Path'Last - Dir'Length + 1;
 
      begin
         for J in Path'First .. Last loop
 
            --  Note: the order of the conditions below is important, since
            --  it ensures a minimal number of string comparisons.
 
            if (J = Path'First
                or else Path (J - 1) = Path_Separator)
              and then
                (J + Dir'Length > Path'Last
                 or else Path (J + Dir'Length) = Path_Separator)
              and then Dir = Path (J .. J + Dir'Length - 1)
            then
               return True;
            end if;
         end loop;
 
         return False;
      end Is_Present;
 
   --  Start of processing for Add_To_Path
 
   begin
      if Is_Present (Buffer (1 .. Buffer_Last), Dir) then
 
         --  Dir is already in the path, nothing to do
 
         return;
      end if;
 
      Min_Len := Buffer_Last + Dir'Length;
 
      if Buffer_Last > 0 then
 
         --  Add 1 for the Path_Separator character
 
         Min_Len := Min_Len + 1;
      end if;
 
      --  If Ada_Path_Buffer is too small, increase it
 
      Len := Buffer'Last;
 
      if Len < Min_Len then
         loop
            Len := Len * 2;
            exit when Len >= Min_Len;
         end loop;
 
         New_Buffer := new String (1 .. Len);
         New_Buffer (1 .. Buffer_Last) := Buffer (1 .. Buffer_Last);
         Free (Buffer);
         Buffer := New_Buffer;
      end if;
 
      if Buffer_Last > 0 then
         Buffer_Last := Buffer_Last + 1;
         Buffer (Buffer_Last) := Path_Separator;
      end if;
 
      Buffer (Buffer_Last + 1 .. Buffer_Last + Dir'Length) := Dir;
      Buffer_Last := Buffer_Last + Dir'Length;
   end Add_To_Path;
 
   ------------------------
   -- Add_To_Source_Path --
   ------------------------
 
   procedure Add_To_Source_Path
     (Source_Dirs  : String_List_Id;
      In_Tree      : Project_Tree_Ref;
      Source_Paths : in out Source_Path_Table.Instance)
   is
      Current    : String_List_Id := Source_Dirs;
      Source_Dir : String_Element;
      Add_It     : Boolean;
 
   begin
      --  Add each source directory
 
      while Current /= Nil_String loop
         Source_Dir := In_Tree.String_Elements.Table (Current);
         Add_It := True;
 
         --  Check if the source directory is already in the table
 
         for Index in Source_Path_Table.First ..
                      Source_Path_Table.Last (Source_Paths)
         loop
            --  If it is already, no need to add it
 
            if Source_Paths.Table (Index) = Source_Dir.Value then
               Add_It := False;
               exit;
            end if;
         end loop;
 
         if Add_It then
            Source_Path_Table.Append (Source_Paths, Source_Dir.Display_Value);
         end if;
 
         --  Next source directory
 
         Current := Source_Dir.Next;
      end loop;
   end Add_To_Source_Path;
 
   --------------------------------
   -- Create_Config_Pragmas_File --
   --------------------------------
 
   procedure Create_Config_Pragmas_File
     (For_Project : Project_Id;
      In_Tree     : Project_Tree_Ref)
   is
      type Naming_Id is new Nat;
      package Naming_Table is new GNAT.Dynamic_Tables
        (Table_Component_Type => Lang_Naming_Data,
         Table_Index_Type     => Naming_Id,
         Table_Low_Bound      => 1,
         Table_Initial        => 5,
         Table_Increment      => 100);
      Default_Naming : constant Naming_Id := Naming_Table.First;
      Namings        : Naming_Table.Instance;
      --  Table storing the naming data for gnatmake/gprmake
 
      Buffer      : String_Access := new String (1 .. Buffer_Initial);
      Buffer_Last : Natural := 0;
 
      File_Name : Path_Name_Type  := No_Path;
      File      : File_Descriptor := Invalid_FD;
 
      Current_Naming  : Naming_Id;
      Iter            : Source_Iterator;
      Source          : Source_Id;
 
      procedure Check (Project : Project_Id; State : in out Integer);
      --  Recursive procedure that put in the config pragmas file any non
      --  standard naming schemes, if it is not already in the file, then call
      --  itself for any imported project.
 
      procedure Put (Source : Source_Id);
      --  Put an SFN pragma in the temporary file
 
      procedure Put (S : String);
      procedure Put_Line (S : String);
      --  Output procedures, analogous to normal Text_IO procs of same name.
      --  The text is put in Buffer, then it will be writen into a temporary
      --  file with procedure Write_Temp_File below.
 
      procedure Write_Temp_File;
      --  Create a temporary file and put the content of the buffer in it
 
      -----------
      -- Check --
      -----------
 
      procedure Check (Project : Project_Id; State : in out Integer) is
         pragma Unreferenced (State);
         Lang   : constant Language_Ptr :=
                    Get_Language_From_Name (Project, "ada");
         Naming : Lang_Naming_Data;
 
      begin
         if Current_Verbosity = High then
            Write_Str ("Checking project file """);
            Write_Str (Namet.Get_Name_String (Project.Name));
            Write_Str (""".");
            Write_Eol;
         end if;
 
         if Lang = null then
            if Current_Verbosity = High then
               Write_Line ("   Languages does not contain Ada, nothing to do");
            end if;
 
            return;
         end if;
 
         Naming := Lang.Config.Naming_Data;
 
         --  Is the naming scheme of this project one that we know?
 
         Current_Naming := Default_Naming;
         while Current_Naming <= Naming_Table.Last (Namings)
           and then Namings.Table (Current_Naming).Dot_Replacement =
                                                    Naming.Dot_Replacement
           and then Namings.Table (Current_Naming).Casing =
                                                    Naming.Casing
           and then Namings.Table (Current_Naming).Separate_Suffix =
                                                    Naming.Separate_Suffix
         loop
            Current_Naming := Current_Naming + 1;
         end loop;
 
         --  If we don't know it, add it
 
         if Current_Naming > Naming_Table.Last (Namings) then
            Naming_Table.Increment_Last (Namings);
            Namings.Table (Naming_Table.Last (Namings)) := Naming;
 
            --  Put the SFN pragmas for the naming scheme
 
            --  Spec
 
            Put_Line
              ("pragma Source_File_Name_Project");
            Put_Line
              ("  (Spec_File_Name  => ""*" &
               Get_Name_String (Naming.Spec_Suffix) & """,");
            Put_Line
              ("   Casing          => " &
               Image (Naming.Casing) & ",");
            Put_Line
              ("   Dot_Replacement => """ &
               Get_Name_String (Naming.Dot_Replacement) & """);");
 
            --  and body
 
            Put_Line
              ("pragma Source_File_Name_Project");
            Put_Line
              ("  (Body_File_Name  => ""*" &
               Get_Name_String (Naming.Body_Suffix) & """,");
            Put_Line
              ("   Casing          => " &
               Image (Naming.Casing) & ",");
            Put_Line
              ("   Dot_Replacement => """ &
               Get_Name_String (Naming.Dot_Replacement) &
               """);");
 
            --  and maybe separate
 
            if Naming.Body_Suffix /= Naming.Separate_Suffix then
               Put_Line ("pragma Source_File_Name_Project");
               Put_Line
                 ("  (Subunit_File_Name  => ""*" &
                  Get_Name_String (Naming.Separate_Suffix) & """,");
               Put_Line
                 ("   Casing          => " &
                  Image (Naming.Casing) & ",");
               Put_Line
                 ("   Dot_Replacement => """ &
                  Get_Name_String (Naming.Dot_Replacement) &
                  """);");
            end if;
         end if;
      end Check;
 
      ---------
      -- Put --
      ---------
 
      procedure Put (Source : Source_Id) is
      begin
         --  Put the pragma SFN for the unit kind (spec or body)
 
         Put ("pragma Source_File_Name_Project (");
         Put (Namet.Get_Name_String (Source.Unit.Name));
 
         if Source.Kind = Spec then
            Put (", Spec_File_Name => """);
         else
            Put (", Body_File_Name => """);
         end if;
 
         Put (Namet.Get_Name_String (Source.File));
         Put ("""");
 
         if Source.Index /= 0 then
            Put (", Index =>");
            Put (Source.Index'Img);
         end if;
 
         Put_Line (");");
      end Put;
 
      procedure Put (S : String) is
      begin
         Add_To_Buffer (S, Buffer, Buffer_Last);
 
         if Current_Verbosity = High then
            Write_Str (S);
         end if;
      end Put;
 
      --------------
      -- Put_Line --
      --------------
 
      procedure Put_Line (S : String) is
      begin
         --  Add an ASCII.LF to the string. As this config file is supposed to
         --  be used only by the compiler, we don't care about the characters
         --  for the end of line. In fact we could have put a space, but
         --  it is more convenient to be able to read gnat.adc during
         --  development, for which the ASCII.LF is fine.
 
         Put (S);
         Put (S => (1 => ASCII.LF));
      end Put_Line;
 
      ---------------------
      -- Write_Temp_File --
      ---------------------
 
      procedure Write_Temp_File is
         Status : Boolean := False;
         Last   : Natural;
 
      begin
         Tempdir.Create_Temp_File (File, File_Name);
 
         if File /= Invalid_FD then
            Last := Write (File, Buffer (1)'Address, Buffer_Last);
 
            if Last = Buffer_Last then
               Close (File, Status);
            end if;
         end if;
 
         if not Status then
            Prj.Com.Fail ("unable to create temporary file");
         end if;
      end Write_Temp_File;
 
      procedure Check_Imported_Projects is
        new For_Every_Project_Imported (Integer, Check);
 
      Dummy : Integer := 0;
 
   --  Start of processing for Create_Config_Pragmas_File
 
   begin
      if not For_Project.Config_Checked then
         Naming_Table.Init (Namings);
 
         --  Check the naming schemes
 
         Check_Imported_Projects (For_Project, Dummy, Imported_First => False);
 
         --  Visit all the files and process those that need an SFN pragma
 
         Iter := For_Each_Source (In_Tree, For_Project);
         while Element (Iter) /= No_Source loop
            Source := Element (Iter);
 
            if Source.Index >= 1
              and then not Source.Locally_Removed
              and then Source.Unit /= null
            then
               Put (Source);
            end if;
 
            Next (Iter);
         end loop;
 
         --  If there are no non standard naming scheme, issue the GNAT
         --  standard naming scheme. This will tell the compiler that
         --  a project file is used and will forbid any pragma SFN.
 
         if Buffer_Last = 0 then
 
            Put_Line ("pragma Source_File_Name_Project");
            Put_Line ("   (Spec_File_Name  => ""*.ads"",");
            Put_Line ("    Dot_Replacement => ""-"",");
            Put_Line ("    Casing          => lowercase);");
 
            Put_Line ("pragma Source_File_Name_Project");
            Put_Line ("   (Body_File_Name  => ""*.adb"",");
            Put_Line ("    Dot_Replacement => ""-"",");
            Put_Line ("    Casing          => lowercase);");
         end if;
 
         --  Close the temporary file
 
         Write_Temp_File;
 
         if Opt.Verbose_Mode then
            Write_Str ("Created configuration file """);
            Write_Str (Get_Name_String (File_Name));
            Write_Line ("""");
         end if;
 
         For_Project.Config_File_Name := File_Name;
         For_Project.Config_File_Temp := True;
         For_Project.Config_Checked   := True;
      end if;
 
      Free (Buffer);
   end Create_Config_Pragmas_File;
 
   --------------------
   -- Create_Mapping --
   --------------------
 
   procedure Create_Mapping (In_Tree : Project_Tree_Ref) is
      Data : Source_Id;
      Iter : Source_Iterator;
 
   begin
      Fmap.Reset_Tables;
 
      Iter := For_Each_Source (In_Tree);
      loop
         Data := Element (Iter);
         exit when Data = No_Source;
 
         if Data.Unit /= No_Unit_Index then
            if Data.Locally_Removed then
               Fmap.Add_Forbidden_File_Name (Data.File);
            else
               Fmap.Add_To_File_Map
                 (Unit_Name => Unit_Name_Type (Data.Unit.Name),
                  File_Name => Data.File,
                  Path_Name => File_Name_Type (Data.Path.Name));
            end if;
         end if;
 
         Next (Iter);
      end loop;
   end Create_Mapping;
 
   -------------------------
   -- Create_Mapping_File --
   -------------------------
 
   procedure Create_Mapping_File
     (Project  : Project_Id;
      Language : Name_Id;
      In_Tree  : Project_Tree_Ref;
      Name     : out Path_Name_Type)
   is
      File   : File_Descriptor := Invalid_FD;
 
      Buffer : String_Access := new String (1 .. Buffer_Initial);
      Buffer_Last : Natural := 0;
 
      procedure Put_Name_Buffer;
      --  Put the line contained in the Name_Buffer in the global buffer
 
      procedure Process (Project : Project_Id; State : in out Integer);
      --  Generate the mapping file for Project (not recursively)
 
      ---------------------
      -- Put_Name_Buffer --
      ---------------------
 
      procedure Put_Name_Buffer is
      begin
         Name_Len := Name_Len + 1;
         Name_Buffer (Name_Len) := ASCII.LF;
 
         if Current_Verbosity = High then
            Write_Str ("Mapping file: " & Name_Buffer (1 .. Name_Len));
         end if;
 
         Add_To_Buffer (Name_Buffer (1 .. Name_Len), Buffer, Buffer_Last);
      end Put_Name_Buffer;
 
      -------------
      -- Process --
      -------------
 
      procedure Process (Project : Project_Id; State : in out Integer) is
         pragma Unreferenced (State);
         Source : Source_Id;
         Suffix : File_Name_Type;
         Iter   : Source_Iterator;
 
      begin
         Iter := For_Each_Source (In_Tree, Project, Language => Language);
 
         loop
            Source := Prj.Element (Iter);
            exit when Source = No_Source;
 
            if Source.Replaced_By = No_Source
              and then Source.Path.Name /= No_Path
              and then
                (Source.Language.Config.Kind = File_Based
                  or else Source.Unit /= No_Unit_Index)
            then
               if Source.Unit /= No_Unit_Index then
                  Get_Name_String (Source.Unit.Name);
 
                  if Source.Language.Config.Kind = Unit_Based then
 
                     --  ??? Mapping_Spec_Suffix could be set in the case of
                     --  gnatmake as well
 
                     Add_Char_To_Name_Buffer ('%');
 
                     if Source.Kind = Spec then
                        Add_Char_To_Name_Buffer ('s');
                     else
                        Add_Char_To_Name_Buffer ('b');
                     end if;
 
                  else
                     case Source.Kind is
                        when Spec =>
                           Suffix :=
                             Source.Language.Config.Mapping_Spec_Suffix;
                        when Impl | Sep =>
                           Suffix :=
                             Source.Language.Config.Mapping_Body_Suffix;
                     end case;
 
                     if Suffix /= No_File then
                        Add_Str_To_Name_Buffer
                          (Get_Name_String (Suffix));
                     end if;
                  end if;
 
                  Put_Name_Buffer;
               end if;
 
               Get_Name_String (Source.File);
               Put_Name_Buffer;
 
               if Source.Locally_Removed then
                  Name_Len := 1;
                  Name_Buffer (1) := '/';
               else
                  Get_Name_String (Source.Path.Name);
               end if;
 
               Put_Name_Buffer;
            end if;
 
            Next (Iter);
         end loop;
      end Process;
 
      procedure For_Every_Imported_Project is new
        For_Every_Project_Imported (State => Integer, Action => Process);
 
      Dummy : Integer := 0;
 
   --  Start of processing for Create_Mapping_File
 
   begin
      For_Every_Imported_Project (Project, Dummy);
 
      declare
         Last   : Natural;
         Status : Boolean := False;
 
      begin
         Create_Temp_File (In_Tree, File, Name, "mapping");
 
         if File /= Invalid_FD then
            Last := Write (File, Buffer (1)'Address, Buffer_Last);
 
            if Last = Buffer_Last then
               GNAT.OS_Lib.Close (File, Status);
            end if;
         end if;
 
         if not Status then
            Prj.Com.Fail ("could not write mapping file");
         end if;
      end;
 
      Free (Buffer);
   end Create_Mapping_File;
 
   ----------------------
   -- Create_Temp_File --
   ----------------------
 
   procedure Create_Temp_File
     (In_Tree   : Project_Tree_Ref;
      Path_FD   : out File_Descriptor;
      Path_Name : out Path_Name_Type;
      File_Use  : String)
   is
   begin
      Tempdir.Create_Temp_File (Path_FD, Path_Name);
 
      if Path_Name /= No_Path then
         if Current_Verbosity = High then
            Write_Line ("Create temp file (" & File_Use & ") "
                        & Get_Name_String (Path_Name));
         end if;
 
         Record_Temp_File (In_Tree, Path_Name);
 
      else
         Prj.Com.Fail
           ("unable to create temporary " & File_Use & " file");
      end if;
   end Create_Temp_File;
 
   --------------------------
   -- Create_New_Path_File --
   --------------------------
 
   procedure Create_New_Path_File
     (In_Tree   : Project_Tree_Ref;
      Path_FD   : out File_Descriptor;
      Path_Name : out Path_Name_Type)
   is
   begin
      Create_Temp_File (In_Tree, Path_FD, Path_Name, "path file");
   end Create_New_Path_File;
 
   ------------------------------------
   -- File_Name_Of_Library_Unit_Body --
   ------------------------------------
 
   function File_Name_Of_Library_Unit_Body
     (Name              : String;
      Project           : Project_Id;
      In_Tree           : Project_Tree_Ref;
      Main_Project_Only : Boolean := True;
      Full_Path         : Boolean := False) return String
   is
      The_Project   : Project_Id := Project;
      Original_Name : String := Name;
 
      Lang   : constant Language_Ptr :=
        Get_Language_From_Name (Project, "ada");
 
      Unit              : Unit_Index;
      The_Original_Name : Name_Id;
      The_Spec_Name     : Name_Id;
      The_Body_Name     : Name_Id;
 
   begin
      --  ??? Same block in Project_Of
      Canonical_Case_File_Name (Original_Name);
      Name_Len := Original_Name'Length;
      Name_Buffer (1 .. Name_Len) := Original_Name;
      The_Original_Name := Name_Find;
 
      if Lang /= null then
         declare
            Naming : constant Lang_Naming_Data := Lang.Config.Naming_Data;
            Extended_Spec_Name : String :=
                                   Name & Namet.Get_Name_String
                                            (Naming.Spec_Suffix);
            Extended_Body_Name : String :=
                                   Name & Namet.Get_Name_String
                                            (Naming.Body_Suffix);
 
         begin
            Canonical_Case_File_Name (Extended_Spec_Name);
            Name_Len := Extended_Spec_Name'Length;
            Name_Buffer (1 .. Name_Len) := Extended_Spec_Name;
            The_Spec_Name := Name_Find;
 
            Canonical_Case_File_Name (Extended_Body_Name);
            Name_Len := Extended_Body_Name'Length;
            Name_Buffer (1 .. Name_Len) := Extended_Body_Name;
            The_Body_Name := Name_Find;
         end;
 
      else
         Name_Len := Name'Length;
         Name_Buffer (1 .. Name_Len) := Name;
         Canonical_Case_File_Name (Name_Buffer);
         The_Spec_Name := Name_Find;
         The_Body_Name := The_Spec_Name;
      end if;
 
      if Current_Verbosity = High then
         Write_Str  ("Looking for file name of """);
         Write_Str  (Name);
         Write_Char ('"');
         Write_Eol;
         Write_Str  ("   Extended Spec Name = """);
         Write_Str  (Get_Name_String (The_Spec_Name));
         Write_Char ('"');
         Write_Eol;
         Write_Str  ("   Extended Body Name = """);
         Write_Str  (Get_Name_String (The_Body_Name));
         Write_Char ('"');
         Write_Eol;
      end if;
 
      --  For extending project, search in the extended project if the source
      --  is not found. For non extending projects, this loop will be run only
      --  once.
 
      loop
         --  Loop through units
 
         Unit := Units_Htable.Get_First (In_Tree.Units_HT);
         while Unit /= null loop
            --  Check for body
 
            if not Main_Project_Only
              or else
                (Unit.File_Names (Impl) /= null
                 and then Unit.File_Names (Impl).Project = The_Project)
            then
               declare
                  Current_Name : File_Name_Type;
               begin
                  --  Case of a body present
 
                  if Unit.File_Names (Impl) /= null then
                     Current_Name := Unit.File_Names (Impl).File;
 
                     if Current_Verbosity = High then
                        Write_Str  ("   Comparing with """);
                        Write_Str  (Get_Name_String (Current_Name));
                        Write_Char ('"');
                        Write_Eol;
                     end if;
 
                     --  If it has the name of the original name, return the
                     --  original name.
 
                     if Unit.Name = The_Original_Name
                       or else
                         Current_Name = File_Name_Type (The_Original_Name)
                     then
                        if Current_Verbosity = High then
                           Write_Line ("   OK");
                        end if;
 
                        if Full_Path then
                           return Get_Name_String
                             (Unit.File_Names (Impl).Path.Name);
 
                        else
                           return Get_Name_String (Current_Name);
                        end if;
 
                        --  If it has the name of the extended body name,
                        --  return the extended body name
 
                     elsif Current_Name = File_Name_Type (The_Body_Name) then
                        if Current_Verbosity = High then
                           Write_Line ("   OK");
                        end if;
 
                        if Full_Path then
                           return Get_Name_String
                             (Unit.File_Names (Impl).Path.Name);
 
                        else
                           return Get_Name_String (The_Body_Name);
                        end if;
 
                     else
                        if Current_Verbosity = High then
                           Write_Line ("   not good");
                        end if;
                     end if;
                  end if;
               end;
            end if;
 
            --  Check for spec
 
            if not Main_Project_Only
              or else
                (Unit.File_Names (Spec) /= null
                 and then Unit.File_Names (Spec).Project =
                   The_Project)
            then
               declare
                  Current_Name : File_Name_Type;
 
               begin
                  --  Case of spec present
 
                  if Unit.File_Names (Spec) /= null then
                     Current_Name := Unit.File_Names (Spec).File;
                     if Current_Verbosity = High then
                        Write_Str  ("   Comparing with """);
                        Write_Str  (Get_Name_String (Current_Name));
                        Write_Char ('"');
                        Write_Eol;
                     end if;
 
                     --  If name same as original name, return original name
 
                     if Unit.Name = The_Original_Name
                       or else
                         Current_Name = File_Name_Type (The_Original_Name)
                     then
                        if Current_Verbosity = High then
                           Write_Line ("   OK");
                        end if;
 
                        if Full_Path then
                           return Get_Name_String
                             (Unit.File_Names (Spec).Path.Name);
                        else
                           return Get_Name_String (Current_Name);
                        end if;
 
                        --  If it has the same name as the extended spec name,
                        --  return the extended spec name.
 
                     elsif Current_Name = File_Name_Type (The_Spec_Name) then
                        if Current_Verbosity = High then
                           Write_Line ("   OK");
                        end if;
 
                        if Full_Path then
                           return Get_Name_String
                             (Unit.File_Names (Spec).Path.Name);
                        else
                           return Get_Name_String (The_Spec_Name);
                        end if;
 
                     else
                        if Current_Verbosity = High then
                           Write_Line ("   not good");
                        end if;
                     end if;
                  end if;
               end;
            end if;
 
            Unit := Units_Htable.Get_Next (In_Tree.Units_HT);
         end loop;
 
         --  If we are not in an extending project, give up
 
         exit when not Main_Project_Only
           or else The_Project.Extends = No_Project;
 
         --  Otherwise, look in the project we are extending
 
         The_Project := The_Project.Extends;
      end loop;
 
      --  We don't know this file name, return an empty string
 
      return "";
   end File_Name_Of_Library_Unit_Body;
 
   -------------------------
   -- For_All_Object_Dirs --
   -------------------------
 
   procedure For_All_Object_Dirs (Project : Project_Id) is
      procedure For_Project (Prj : Project_Id; Dummy : in out Integer);
      --  Get all object directories of Prj
 
      -----------------
      -- For_Project --
      -----------------
 
      procedure For_Project (Prj : Project_Id; Dummy : in out Integer) is
         pragma Unreferenced (Dummy);
      begin
         --  ??? Set_Ada_Paths has a different behavior for library project
         --  files, should we have the same ?
 
         if Prj.Object_Directory /= No_Path_Information then
            Get_Name_String (Prj.Object_Directory.Display_Name);
            Action (Name_Buffer (1 .. Name_Len));
         end if;
      end For_Project;
 
      procedure Get_Object_Dirs is
        new For_Every_Project_Imported (Integer, For_Project);
      Dummy : Integer := 1;
 
   --  Start of processing for For_All_Object_Dirs
 
   begin
      Get_Object_Dirs (Project, Dummy);
   end For_All_Object_Dirs;
 
   -------------------------
   -- For_All_Source_Dirs --
   -------------------------
 
   procedure For_All_Source_Dirs
     (Project : Project_Id;
      In_Tree : Project_Tree_Ref)
   is
      procedure For_Project (Prj : Project_Id; Dummy : in out Integer);
      --  Get all object directories of Prj
 
      -----------------
      -- For_Project --
      -----------------
 
      procedure For_Project (Prj : Project_Id; Dummy : in out Integer) is
         pragma Unreferenced (Dummy);
         Current    : String_List_Id := Prj.Source_Dirs;
         The_String : String_Element;
 
      begin
         --  If there are Ada sources, call action with the name of every
         --  source directory.
 
         if Has_Ada_Sources (Project) then
            while Current /= Nil_String loop
               The_String := In_Tree.String_Elements.Table (Current);
               Action (Get_Name_String (The_String.Display_Value));
               Current := The_String.Next;
            end loop;
         end if;
      end For_Project;
 
      procedure Get_Source_Dirs is
        new For_Every_Project_Imported (Integer, For_Project);
      Dummy : Integer := 1;
 
   --  Start of processing for For_All_Source_Dirs
 
   begin
      Get_Source_Dirs (Project, Dummy);
   end For_All_Source_Dirs;
 
   -------------------
   -- Get_Reference --
   -------------------
 
   procedure Get_Reference
     (Source_File_Name : String;
      In_Tree          : Project_Tree_Ref;
      Project          : out Project_Id;
      Path             : out Path_Name_Type)
   is
   begin
      --  Body below could use some comments ???
 
      if Current_Verbosity > Default then
         Write_Str ("Getting Reference_Of (""");
         Write_Str (Source_File_Name);
         Write_Str (""") ... ");
      end if;
 
      declare
         Original_Name : String := Source_File_Name;
         Unit          : Unit_Index;
 
      begin
         Canonical_Case_File_Name (Original_Name);
         Unit := Units_Htable.Get_First (In_Tree.Units_HT);
 
         while Unit /= null loop
            if Unit.File_Names (Spec) /= null
              and then Unit.File_Names (Spec).File /= No_File
              and then
                (Namet.Get_Name_String
                     (Unit.File_Names (Spec).File) = Original_Name
                 or else (Unit.File_Names (Spec).Path /=
                            No_Path_Information
                          and then
                            Namet.Get_Name_String
                              (Unit.File_Names (Spec).Path.Name) =
                            Original_Name))
            then
               Project := Ultimate_Extension_Of
                          (Project => Unit.File_Names (Spec).Project);
               Path := Unit.File_Names (Spec).Path.Display_Name;
 
               if Current_Verbosity > Default then
                  Write_Str ("Done: Spec.");
                  Write_Eol;
               end if;
 
               return;
 
            elsif Unit.File_Names (Impl) /= null
              and then Unit.File_Names (Impl).File /= No_File
              and then
                (Namet.Get_Name_String
                   (Unit.File_Names (Impl).File) = Original_Name
                 or else (Unit.File_Names (Impl).Path /=
                            No_Path_Information
                          and then Namet.Get_Name_String
                            (Unit.File_Names (Impl).Path.Name) =
                            Original_Name))
            then
               Project := Ultimate_Extension_Of
                            (Project => Unit.File_Names (Impl).Project);
               Path := Unit.File_Names (Impl).Path.Display_Name;
 
               if Current_Verbosity > Default then
                  Write_Str ("Done: Body.");
                  Write_Eol;
               end if;
 
               return;
            end if;
 
            Unit := Units_Htable.Get_Next (In_Tree.Units_HT);
         end loop;
      end;
 
      Project := No_Project;
      Path    := No_Path;
 
      if Current_Verbosity > Default then
         Write_Str ("Cannot be found.");
         Write_Eol;
      end if;
   end Get_Reference;
 
   ----------------
   -- Initialize --
   ----------------
 
   procedure Initialize (In_Tree : Project_Tree_Ref) is
   begin
      In_Tree.Private_Part.Current_Source_Path_File := No_Path;
      In_Tree.Private_Part.Current_Object_Path_File := No_Path;
   end Initialize;
 
   -------------------
   -- Print_Sources --
   -------------------
 
   --  Could use some comments in this body ???
 
   procedure Print_Sources (In_Tree : Project_Tree_Ref) is
      Unit : Unit_Index;
 
   begin
      Write_Line ("List of Sources:");
 
      Unit := Units_Htable.Get_First (In_Tree.Units_HT);
 
      while Unit /= No_Unit_Index loop
         Write_Str  ("   ");
         Write_Line (Namet.Get_Name_String (Unit.Name));
 
         if Unit.File_Names (Spec).File /= No_File then
            if Unit.File_Names (Spec).Project = No_Project then
               Write_Line ("   No project");
 
            else
               Write_Str  ("   Project: ");
               Get_Name_String
                 (Unit.File_Names (Spec).Project.Path.Name);
               Write_Line (Name_Buffer (1 .. Name_Len));
            end if;
 
            Write_Str  ("      spec: ");
            Write_Line
              (Namet.Get_Name_String
               (Unit.File_Names (Spec).File));
         end if;
 
         if Unit.File_Names (Impl).File /= No_File then
            if Unit.File_Names (Impl).Project = No_Project then
               Write_Line ("   No project");
 
            else
               Write_Str  ("   Project: ");
               Get_Name_String
                 (Unit.File_Names (Impl).Project.Path.Name);
               Write_Line (Name_Buffer (1 .. Name_Len));
            end if;
 
            Write_Str  ("      body: ");
            Write_Line
              (Namet.Get_Name_String (Unit.File_Names (Impl).File));
         end if;
 
         Unit := Units_Htable.Get_Next (In_Tree.Units_HT);
      end loop;
 
      Write_Line ("end of List of Sources.");
   end Print_Sources;
 
   ----------------
   -- Project_Of --
   ----------------
 
   function Project_Of
     (Name         : String;
      Main_Project : Project_Id;
      In_Tree      : Project_Tree_Ref) return Project_Id
   is
      Result : Project_Id := No_Project;
 
      Original_Name : String := Name;
 
      Lang : constant Language_Ptr :=
               Get_Language_From_Name (Main_Project, "ada");
 
      Unit : Unit_Index;
 
      Current_Name      : File_Name_Type;
      The_Original_Name : File_Name_Type;
      The_Spec_Name     : File_Name_Type;
      The_Body_Name     : File_Name_Type;
 
   begin
      --  ??? Same block in File_Name_Of_Library_Unit_Body
      Canonical_Case_File_Name (Original_Name);
      Name_Len := Original_Name'Length;
      Name_Buffer (1 .. Name_Len) := Original_Name;
      The_Original_Name := Name_Find;
 
      if Lang /= null then
         declare
            Naming : Lang_Naming_Data renames Lang.Config.Naming_Data;
            Extended_Spec_Name : String :=
                                   Name & Namet.Get_Name_String
                                            (Naming.Spec_Suffix);
            Extended_Body_Name : String :=
                                   Name & Namet.Get_Name_String
                                            (Naming.Body_Suffix);
 
         begin
            Canonical_Case_File_Name (Extended_Spec_Name);
            Name_Len := Extended_Spec_Name'Length;
            Name_Buffer (1 .. Name_Len) := Extended_Spec_Name;
            The_Spec_Name := Name_Find;
 
            Canonical_Case_File_Name (Extended_Body_Name);
            Name_Len := Extended_Body_Name'Length;
            Name_Buffer (1 .. Name_Len) := Extended_Body_Name;
            The_Body_Name := Name_Find;
         end;
 
      else
         The_Spec_Name := The_Original_Name;
         The_Body_Name := The_Original_Name;
      end if;
 
      Unit := Units_Htable.Get_First (In_Tree.Units_HT);
      while Unit /= null loop
 
         --  Case of a body present
 
         if Unit.File_Names (Impl) /= null then
            Current_Name := Unit.File_Names (Impl).File;
 
            --  If it has the name of the original name or the body name,
            --  we have found the project.
 
            if Unit.Name = Name_Id (The_Original_Name)
              or else Current_Name = The_Original_Name
              or else Current_Name = The_Body_Name
            then
               Result := Unit.File_Names (Impl).Project;
               exit;
            end if;
         end if;
 
         --  Check for spec
 
         if Unit.File_Names (Spec) /= null then
            Current_Name := Unit.File_Names (Spec).File;
 
            --  If name same as the original name, or the spec name, we have
            --  found the project.
 
            if Unit.Name = Name_Id (The_Original_Name)
              or else Current_Name = The_Original_Name
              or else Current_Name = The_Spec_Name
            then
               Result := Unit.File_Names (Spec).Project;
               exit;
            end if;
         end if;
 
         Unit := Units_Htable.Get_Next (In_Tree.Units_HT);
      end loop;
 
      --  Get the ultimate extending project
 
      if Result /= No_Project then
         while Result.Extended_By /= No_Project loop
            Result := Result.Extended_By;
         end loop;
      end if;
 
      return Result;
   end Project_Of;
 
   -------------------
   -- Set_Ada_Paths --
   -------------------
 
   procedure Set_Ada_Paths
     (Project             : Project_Id;
      In_Tree             : Project_Tree_Ref;
      Including_Libraries : Boolean)
 
   is
      Source_Paths : Source_Path_Table.Instance;
      Object_Paths : Object_Path_Table.Instance;
      --  List of source or object dirs. Only computed the first time this
      --  procedure is called (since Source_FD is then reused)
 
      Source_FD : File_Descriptor := Invalid_FD;
      Object_FD : File_Descriptor := Invalid_FD;
      --  The temporary files to store the paths. These are only created the
      --  first time this procedure is called, and reused from then on.
 
      Process_Source_Dirs : Boolean := False;
      Process_Object_Dirs : Boolean := False;
 
      Status : Boolean;
      --  For calls to Close
 
      Last        : Natural;
      Buffer      : String_Access := new String (1 .. Buffer_Initial);
      Buffer_Last : Natural := 0;
 
      procedure Recursive_Add (Project : Project_Id; Dummy : in out Boolean);
      --  Recursive procedure to add the source/object paths of extended/
      --  imported projects.
 
      -------------------
      -- Recursive_Add --
      -------------------
 
      procedure Recursive_Add (Project : Project_Id; Dummy : in out Boolean) is
         pragma Unreferenced (Dummy);
 
         Path : Path_Name_Type;
 
      begin
         --  ??? This is almost the equivalent of For_All_Source_Dirs
 
         if Process_Source_Dirs then
 
            --  Add to path all source directories of this project if there are
            --  Ada sources.
 
            if Has_Ada_Sources (Project) then
               Add_To_Source_Path (Project.Source_Dirs, In_Tree, Source_Paths);
            end if;
         end if;
 
         if Process_Object_Dirs then
            Path := Get_Object_Directory
              (Project,
               Including_Libraries => Including_Libraries,
               Only_If_Ada         => True);
 
            if Path /= No_Path then
               Add_To_Object_Path (Path, Object_Paths);
            end if;
         end if;
      end Recursive_Add;
 
      procedure For_All_Projects is
        new For_Every_Project_Imported (Boolean, Recursive_Add);
 
      Dummy : Boolean := False;
 
   --  Start of processing for Set_Ada_Paths
 
   begin
      --  If it is the first time we call this procedure for this project,
      --  compute the source path and/or the object path.
 
      if Project.Include_Path_File = No_Path then
         Source_Path_Table.Init (Source_Paths);
         Process_Source_Dirs := True;
         Create_New_Path_File
           (In_Tree, Source_FD, Project.Include_Path_File);
      end if;
 
      --  For the object path, we make a distinction depending on
      --  Including_Libraries.
 
      if Including_Libraries then
         if Project.Objects_Path_File_With_Libs = No_Path then
            Object_Path_Table.Init (Object_Paths);
            Process_Object_Dirs := True;
            Create_New_Path_File
              (In_Tree, Object_FD, Project.Objects_Path_File_With_Libs);
         end if;
 
      else
         if Project.Objects_Path_File_Without_Libs = No_Path then
            Object_Path_Table.Init (Object_Paths);
            Process_Object_Dirs := True;
            Create_New_Path_File
              (In_Tree, Object_FD, Project.Objects_Path_File_Without_Libs);
         end if;
      end if;
 
      --  If there is something to do, set Seen to False for all projects,
      --  then call the recursive procedure Add for Project.
 
      if Process_Source_Dirs or Process_Object_Dirs then
         For_All_Projects (Project, Dummy);
      end if;
 
      --  Write and close any file that has been created. Source_FD is not set
      --  when this subprogram is called a second time or more, since we reuse
      --  the previous version of the file.
 
      if Source_FD /= Invalid_FD then
         Buffer_Last := 0;
 
         for Index in Source_Path_Table.First ..
                      Source_Path_Table.Last (Source_Paths)
         loop
            Get_Name_String (Source_Paths.Table (Index));
            Name_Len := Name_Len + 1;
            Name_Buffer (Name_Len) := ASCII.LF;
            Add_To_Buffer (Name_Buffer (1 .. Name_Len), Buffer, Buffer_Last);
         end loop;
 
         Last := Write (Source_FD, Buffer (1)'Address, Buffer_Last);
 
         if Last = Buffer_Last then
            Close (Source_FD, Status);
 
         else
            Status := False;
         end if;
 
         if not Status then
            Prj.Com.Fail ("could not write temporary file");
         end if;
      end if;
 
      if Object_FD /= Invalid_FD then
         Buffer_Last := 0;
 
         for Index in Object_Path_Table.First ..
                      Object_Path_Table.Last (Object_Paths)
         loop
            Get_Name_String (Object_Paths.Table (Index));
            Name_Len := Name_Len + 1;
            Name_Buffer (Name_Len) := ASCII.LF;
            Add_To_Buffer (Name_Buffer (1 .. Name_Len), Buffer, Buffer_Last);
         end loop;
 
         Last := Write (Object_FD, Buffer (1)'Address, Buffer_Last);
 
         if Last = Buffer_Last then
            Close (Object_FD, Status);
         else
            Status := False;
         end if;
 
         if not Status then
            Prj.Com.Fail ("could not write temporary file");
         end if;
      end if;
 
      --  Set the env vars, if they need to be changed, and set the
      --  corresponding flags.
 
      if In_Tree.Private_Part.Current_Source_Path_File /=
           Project.Include_Path_File
      then
         In_Tree.Private_Part.Current_Source_Path_File :=
           Project.Include_Path_File;
         Set_Path_File_Var
           (Project_Include_Path_File,
            Get_Name_String (In_Tree.Private_Part.Current_Source_Path_File));
      end if;
 
      if Including_Libraries then
         if In_Tree.Private_Part.Current_Object_Path_File /=
            Project.Objects_Path_File_With_Libs
         then
            In_Tree.Private_Part.Current_Object_Path_File :=
              Project.Objects_Path_File_With_Libs;
            Set_Path_File_Var
              (Project_Objects_Path_File,
               Get_Name_String
                 (In_Tree.Private_Part.Current_Object_Path_File));
         end if;
 
      else
         if In_Tree.Private_Part.Current_Object_Path_File /=
            Project.Objects_Path_File_Without_Libs
         then
            In_Tree.Private_Part.Current_Object_Path_File :=
              Project.Objects_Path_File_Without_Libs;
            Set_Path_File_Var
              (Project_Objects_Path_File,
               Get_Name_String
                 (In_Tree.Private_Part.Current_Object_Path_File));
         end if;
      end if;
 
      Free (Buffer);
   end Set_Ada_Paths;
 
   -----------------------
   -- Set_Path_File_Var --
   -----------------------
 
   procedure Set_Path_File_Var (Name : String; Value : String) is
      Host_Spec : String_Access := To_Host_File_Spec (Value);
   begin
      if Host_Spec = null then
         Prj.Com.Fail
           ("could not convert file name """ & Value & """ to host spec");
      else
         Setenv (Name, Host_Spec.all);
         Free (Host_Spec);
      end if;
   end Set_Path_File_Var;
 
   ---------------------------
   -- Ultimate_Extension_Of --
   ---------------------------
 
   function Ultimate_Extension_Of
     (Project : Project_Id) return Project_Id
   is
      Result : Project_Id;
 
   begin
      Result := Project;
      while Result.Extended_By /= No_Project loop
         Result := Result.Extended_By;
      end loop;
 
      return Result;
   end Ultimate_Extension_Of;
 
end Prj.Env;
Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [gcc-4.5.1/] [gcc/] [ada/] [prj-env.adb] - Blame information for rev 826

Line No.	Rev	Author	Line
1	281	jeremybenn	`------------------------------------------------------------------------------`
2			`-- --`
3			`-- GNAT COMPILER COMPONENTS --`
4			`-- --`
5			`-- P R J . E N V --`
6			`-- --`
7			`-- B o d y --`
8			`-- --`
9			`-- Copyright (C) 2001-2009, Free Software Foundation, Inc. --`
10			`-- --`
11			`-- GNAT is free software; you can redistribute it and/or modify it under --`
12			`-- terms of the GNU General Public License as published by the Free Soft- --`
13			`-- ware Foundation; either version 3, or (at your option) any later ver- --`
14			`-- sion. GNAT is distributed in the hope that it will be useful, but WITH- --`
15			`-- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --`
16			`-- or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License --`
17			`-- for more details. You should have received a copy of the GNU General --`
18			`-- Public License distributed with GNAT; see file COPYING3. If not, go to --`
19			`-- http://www.gnu.org/licenses for a complete copy of the license. --`
20			`-- --`
21			`-- GNAT was originally developed by the GNAT team at New York University. --`
22			`-- Extensive contributions were provided by Ada Core Technologies Inc. --`
23			`-- --`
24			`------------------------------------------------------------------------------`
25
26			`with Fmap;`
27			`with Opt;`
28			`with Osint; use Osint;`
29			`with Output; use Output;`
30			`with Prj.Com; use Prj.Com;`
31			`with Tempdir;`
32
33			`package body Prj.Env is`
34
35			`Buffer_Initial : constant := 1_000;`
36			`-- Initial size of Buffer`
37
38			`-----------------------`
39			`-- Local Subprograms --`
40			`-----------------------`