Subversion Repositories openrisc_me

------------------------------------------------------------------------------
--                                                                          --
--                         GNAT COMPILER COMPONENTS                         --
--                                                                          --
--                             A L I . U T I L                              --
--                                                                          --
--                                 B o d y                                  --
--                                                                          --
--          Copyright (C) 1992-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 Debug;   use Debug;
with Binderr; use Binderr;
with Opt;     use Opt;
with Output;  use Output;
with Osint;   use Osint;
with Scans;   use Scans;
with Scng;
with Sinput.C;
with Snames;  use Snames;
with Styleg;
 
package body ALI.Util is
 
   --  Empty procedures needed to instantiate Scng. Error procedures are
   --  empty, because we don't want to report any errors when computing
   --  a source checksum.
 
   procedure Post_Scan;
 
   procedure Error_Msg (Msg : String; Flag_Location : Source_Ptr);
 
   procedure Error_Msg_S (Msg : String);
 
   procedure Error_Msg_SC (Msg : String);
 
   procedure Error_Msg_SP (Msg : String);
 
   procedure Obsolescent_Check (S : Source_Ptr);
 
   --  Instantiation of Styleg, needed to instantiate Scng
 
   package Style is new Styleg
     (Error_Msg, Error_Msg_S, Error_Msg_SC, Error_Msg_SP);
 
   --  A Scanner is needed to get checksum of a source (procedure
   --  Get_File_Checksum).
 
   package Scanner is new Scng
     (Post_Scan, Error_Msg, Error_Msg_S, Error_Msg_SC, Error_Msg_SP,
      Obsolescent_Check, Style);
 
   type Header_Num is range 0 .. 1_000;
 
   function Hash (F : File_Name_Type) return Header_Num;
   --  Function used to compute hash of ALI file name
 
   package Interfaces is new Simple_HTable (
     Header_Num => Header_Num,
     Element    => Boolean,
     No_Element => False,
     Key        => File_Name_Type,
     Hash       => Hash,
     Equal      => "=");
 
   ---------------------
   -- Checksums_Match --
   ---------------------
 
   function Checksums_Match (Checksum1, Checksum2 : Word) return Boolean is
   begin
      return Checksum1 = Checksum2 and then Checksum1 /= Checksum_Error;
   end Checksums_Match;
 
   ---------------
   -- Error_Msg --
   ---------------
 
   procedure Error_Msg (Msg : String; Flag_Location : Source_Ptr) is
      pragma Warnings (Off, Msg);
      pragma Warnings (Off, Flag_Location);
   begin
      null;
   end Error_Msg;
 
   -----------------
   -- Error_Msg_S --
   -----------------
 
   procedure Error_Msg_S (Msg : String) is
      pragma Warnings (Off, Msg);
   begin
      null;
   end Error_Msg_S;
 
   ------------------
   -- Error_Msg_SC --
   ------------------
 
   procedure Error_Msg_SC (Msg : String) is
      pragma Warnings (Off, Msg);
   begin
      null;
   end Error_Msg_SC;
 
   ------------------
   -- Error_Msg_SP --
   ------------------
 
   procedure Error_Msg_SP (Msg : String) is
      pragma Warnings (Off, Msg);
   begin
      null;
   end Error_Msg_SP;
 
   -----------------------
   -- Get_File_Checksum --
   -----------------------
 
   function Get_File_Checksum (Fname : File_Name_Type) return Word is
      Full_Name    : File_Name_Type;
      Source_Index : Source_File_Index;
 
   begin
      Full_Name := Find_File (Fname, Osint.Source);
 
      --  If we cannot find the file, then return an impossible checksum,
      --  impossible because checksums have the high order bit zero, so
      --  that checksums do not match.
 
      if Full_Name = No_File then
         return Checksum_Error;
      end if;
 
      Source_Index := Sinput.C.Load_File (Get_Name_String (Full_Name));
 
      if Source_Index = No_Source_File then
         return Checksum_Error;
      end if;
 
      Scanner.Initialize_Scanner (Source_Index);
 
      --  Make sure that the project language reserved words are not
      --  recognized as reserved words, but as identifiers. The byte info for
      --  those names have been set if we are in gnatmake.
 
      Set_Name_Table_Byte (Name_Project,  0);
      Set_Name_Table_Byte (Name_Extends,  0);
      Set_Name_Table_Byte (Name_External, 0);
 
      --  Scan the complete file to compute its checksum
 
      loop
         Scanner.Scan;
         exit when Token = Tok_EOF;
      end loop;
 
      return Scans.Checksum;
   end Get_File_Checksum;
 
   ----------
   -- Hash --
   ----------
 
   function Hash (F : File_Name_Type) return Header_Num is
   begin
      return Header_Num (Int (F) rem Header_Num'Range_Length);
   end Hash;
 
   ---------------------------
   -- Initialize_ALI_Source --
   ---------------------------
 
   procedure Initialize_ALI_Source is
   begin
      --  When (re)initializing ALI data structures the ALI user expects to
      --  get a fresh set of data structures. Thus we first need to erase the
      --  marks put in the name table by the previous set of ALI routine calls.
      --  This loop is empty and harmless the first time in.
 
      for J in Source.First .. Source.Last loop
         Set_Name_Table_Info (Source.Table (J).Sfile, 0);
         Source.Table (J).Source_Found := False;
      end loop;
 
      Source.Init;
      Interfaces.Reset;
   end Initialize_ALI_Source;
 
   -----------------------
   -- Obsolescent_Check --
   -----------------------
 
   procedure Obsolescent_Check (S : Source_Ptr) is
      pragma Warnings (Off, S);
   begin
      null;
   end Obsolescent_Check;
 
   ---------------
   -- Post_Scan --
   ---------------
 
   procedure Post_Scan is
   begin
      null;
   end Post_Scan;
 
   --------------
   -- Read_ALI --
   --------------
 
   procedure Read_ALI (Id : ALI_Id) is
      Afile  : File_Name_Type;
      Text   : Text_Buffer_Ptr;
      Idread : ALI_Id;
 
   begin
      --  Process all dependent units
 
      for U in ALIs.Table (Id).First_Unit .. ALIs.Table (Id).Last_Unit loop
         for
           W in Units.Table (U).First_With .. Units.Table (U).Last_With
         loop
            Afile := Withs.Table (W).Afile;
 
            --  Only process if not a generic (Afile /= No_File) and if
            --  file has not been processed already.
 
            if Afile /= No_File
              and then Get_Name_Table_Info (Afile) = 0
            then
               Text := Read_Library_Info (Afile);
 
               --  Return with an error if source cannot be found. We used to
               --  skip this check when we did not compile library generics
               --  separately, but we now always do, so there is no special
               --  case here anymore.
 
               if Text = null then
                  Error_Msg_File_1 := Afile;
                  Error_Msg_File_2 := Withs.Table (W).Sfile;
                  Error_Msg ("{ not found, { must be compiled");
                  Set_Name_Table_Info (Afile, Int (No_Unit_Id));
                  return;
               end if;
 
               --  Enter in ALIs table
 
               Idread :=
                 Scan_ALI
                   (F         => Afile,
                    T         => Text,
                    Ignore_ED => False,
                    Err       => False);
 
               Free (Text);
 
               if ALIs.Table (Idread).Compile_Errors then
                  Error_Msg_File_1 := Withs.Table (W).Sfile;
                  Error_Msg ("{ had errors, must be fixed, and recompiled");
                  Set_Name_Table_Info (Afile, Int (No_Unit_Id));
 
               elsif ALIs.Table (Idread).No_Object then
                  Error_Msg_File_1 := Withs.Table (W).Sfile;
                  Error_Msg ("{ must be recompiled");
                  Set_Name_Table_Info (Afile, Int (No_Unit_Id));
               end if;
 
               --  If the Unit is an Interface to a Stand-Alone Library,
               --  set the Interface flag in the Withs table, so that its
               --  dependant are not considered for elaboration order.
 
               if ALIs.Table (Idread).SAL_Interface then
                  Withs.Table (W).SAL_Interface  := True;
                  Interface_Library_Unit := True;
 
                  --  Set the entry in the Interfaces hash table, so that other
                  --  units that import this unit will set the flag in their
                  --  entry in the Withs table.
 
                  Interfaces.Set (Afile, True);
 
               else
                  --  Otherwise, recurse to get new dependents
 
                  Read_ALI (Idread);
               end if;
 
            --  If the ALI file has already been processed and is an interface,
            --  set the flag in the entry of the Withs table.
 
            elsif Interface_Library_Unit and then Interfaces.Get (Afile) then
               Withs.Table (W).SAL_Interface := True;
            end if;
         end loop;
      end loop;
   end Read_ALI;
 
   ----------------------
   -- Set_Source_Table --
   ----------------------
 
   procedure Set_Source_Table (A : ALI_Id) is
      F     : File_Name_Type;
      S     : Source_Id;
      Stamp : Time_Stamp_Type;
 
   begin
      Sdep_Loop : for D in
        ALIs.Table (A).First_Sdep .. ALIs.Table (A).Last_Sdep
      loop
         F := Sdep.Table (D).Sfile;
 
         if F /= No_File then
 
            --  If this is the first time we are seeing this source file,
            --  then make a new entry in the source table.
 
            if Get_Name_Table_Info (F) = 0 then
               Source.Increment_Last;
               S := Source.Last;
               Set_Name_Table_Info (F, Int (S));
               Source.Table (S).Sfile := F;
               Source.Table (S).All_Timestamps_Match := True;
 
               --  Initialize checksum fields
 
               Source.Table (S).Checksum := Sdep.Table (D).Checksum;
               Source.Table (S).All_Checksums_Match := True;
 
               --  In check source files mode, try to get time stamp from file
 
               if Opt.Check_Source_Files then
                  Stamp := Source_File_Stamp (F);
 
                  --  If we got the stamp, then set the stamp in the source
                  --  table entry and mark it as set from the source so that
                  --  it does not get subsequently changed.
 
                  if Stamp (Stamp'First) /= ' ' then
                     Source.Table (S).Stamp := Stamp;
                     Source.Table (S).Source_Found := True;
 
                  --  If we could not find the file, then the stamp is set
                  --  from the dependency table entry (to be possibly reset
                  --  if we find a later stamp in subsequent processing)
 
                  else
                     Source.Table (S).Stamp := Sdep.Table (D).Stamp;
                     Source.Table (S).Source_Found := False;
 
                     --  In All_Sources mode, flag error of file not found
 
                     if Opt.All_Sources then
                        Error_Msg_File_1 := F;
                        Error_Msg ("cannot locate {");
                     end if;
                  end if;
 
               --  First time for this source file, but Check_Source_Files
               --  is off, so simply initialize the stamp from the Sdep entry
 
               else
                  Source.Table (S).Source_Found := False;
                  Source.Table (S).Stamp := Sdep.Table (D).Stamp;
               end if;
 
            --  Here if this is not the first time for this source file,
            --  so that the source table entry is already constructed.
 
            else
               S := Source_Id (Get_Name_Table_Info (F));
 
               --  Update checksum flag
 
               if not Checksums_Match
                        (Sdep.Table (D).Checksum, Source.Table (S).Checksum)
               then
                  Source.Table (S).All_Checksums_Match := False;
               end if;
 
               --  Check for time stamp mismatch
 
               if Sdep.Table (D).Stamp /= Source.Table (S).Stamp then
                  Source.Table (S).All_Timestamps_Match := False;
 
                  --  When we have a time stamp mismatch, we go look for the
                  --  source file even if Check_Source_Files is false, since
                  --  if we find it, then we can use it to resolve which of the
                  --  two timestamps in the ALI files is likely to be correct.
 
                  if not Check_Source_Files then
                     Stamp := Source_File_Stamp (F);
 
                     if Stamp (Stamp'First) /= ' ' then
                        Source.Table (S).Stamp := Stamp;
                        Source.Table (S).Source_Found := True;
                     end if;
                  end if;
 
                  --  If the stamp in the source table entry was set from the
                  --  source file, then we do not change it (the stamp in the
                  --  source file is always taken as the "right" one).
 
                  if Source.Table (S).Source_Found then
                     null;
 
                  --  Otherwise, we have no source file available, so we guess
                  --  that the later of the two timestamps is the right one.
                  --  Note that this guess only affects which error messages
                  --  are issued later on, not correct functionality.
 
                  else
                     if Sdep.Table (D).Stamp > Source.Table (S).Stamp then
                        Source.Table (S).Stamp := Sdep.Table (D).Stamp;
                     end if;
                  end if;
               end if;
            end if;
 
            --  Set the checksum value in the source table
 
            S := Source_Id (Get_Name_Table_Info (F));
            Source.Table (S).Checksum := Sdep.Table (D).Checksum;
         end if;
 
      end loop Sdep_Loop;
   end Set_Source_Table;
 
   ----------------------
   -- Set_Source_Table --
   ----------------------
 
   procedure Set_Source_Table is
   begin
      for A in ALIs.First .. ALIs.Last loop
         Set_Source_Table (A);
      end loop;
   end Set_Source_Table;
 
   -------------------------
   -- Time_Stamp_Mismatch --
   -------------------------
 
   function Time_Stamp_Mismatch
     (A         : ALI_Id;
      Read_Only : Boolean := False) return File_Name_Type
   is
      Src : Source_Id;
      --  Source file Id for the current Sdep entry
 
   begin
      for D in ALIs.Table (A).First_Sdep .. ALIs.Table (A).Last_Sdep loop
         Src := Source_Id (Get_Name_Table_Info (Sdep.Table (D).Sfile));
 
         if Opt.Minimal_Recompilation
           and then Sdep.Table (D).Stamp /= Source.Table (Src).Stamp
         then
            --  If minimal recompilation is in action, replace the stamp
            --  of the source file in the table if checksums match.
 
            --  ??? It is probably worth updating the ALI file with a new
            --  field to avoid recomputing it each time.
 
            if Checksums_Match
                 (Get_File_Checksum (Sdep.Table (D).Sfile),
                  Source.Table (Src).Checksum)
            then
               Sdep.Table (D).Stamp := Source.Table (Src).Stamp;
            end if;
 
         end if;
 
         if (not Read_Only) or else Source.Table (Src).Source_Found then
            if not Source.Table (Src).Source_Found
              or else Sdep.Table (D).Stamp /= Source.Table (Src).Stamp
            then
               --  If -dt debug flag set, output time stamp found/expected
 
               if Source.Table (Src).Source_Found and then Debug_Flag_T then
                  Write_Str ("Source: """);
                  Get_Name_String (Sdep.Table (D).Sfile);
                  Write_Str (Name_Buffer (1 .. Name_Len));
                  Write_Line ("""");
 
                  Write_Str ("   time stamp expected: ");
                  Write_Line (String (Sdep.Table (D).Stamp));
 
                  Write_Str ("      time stamp found: ");
                  Write_Line (String (Source.Table (Src).Stamp));
               end if;
 
               --  Return the source file
 
               return Source.Table (Src).Sfile;
            end if;
         end if;
      end loop;
 
      return No_File;
   end Time_Stamp_Mismatch;
 
end ALI.Util;