Subversion Repositories openrisc

------------------------------------------------------------------------------

--                                                                          --

--                         GNAT COMPILER COMPONENTS                         --

--                                                                          --

--                   G N A T . D Y N A M I C _ T A B L E S                  --

--                                                                          --

--                                 B o d y                                  --

--                                                                          --

--                     Copyright (C) 2000-2010, 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.                                     --

--                                                                          --

-- As a special exception under Section 7 of GPL version 3, you are granted --

-- additional permissions described in the GCC Runtime Library Exception,   --

-- version 3.1, as published by the Free Software Foundation.               --

--                                                                          --

-- You should have received a copy of the GNU General Public License and    --

-- a copy of the GCC Runtime Library Exception along with this program;     --

-- see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see    --

-- <http://www.gnu.org/licenses/>.                                          --

--                                                                          --

-- GNAT was originally developed  by the GNAT team at  New York University. --

-- Extensive contributions were provided by Ada Core Technologies Inc.      --

--                                                                          --

------------------------------------------------------------------------------

pragma Compiler_Unit;

with GNAT.Heap_Sort_G;

with System;        use System;

with System.Memory; use System.Memory;

with Ada.Unchecked_Conversion;

package body GNAT.Dynamic_Tables is

   Min : constant Integer := Integer (Table_Low_Bound);

   --  Subscript of the minimum entry in the currently allocated table

   -----------------------

   -- Local Subprograms --

   -----------------------

   procedure Reallocate (T : in out Instance);

   --  Reallocate the existing table according to the current value stored

   --  in Max. Works correctly to do an initial allocation if the table

   --  is currently null.

   pragma Warnings (Off);

   --  These unchecked conversions are in fact safe, since they never

   --  generate improperly aliased pointer values.

   function To_Address is new Ada.Unchecked_Conversion (Table_Ptr, Address);

   function To_Pointer is new Ada.Unchecked_Conversion (Address, Table_Ptr);

   pragma Warnings (On);

   --------------

   -- Allocate --

   --------------

   procedure Allocate (T : in out Instance; Num : Integer := 1) is

   begin

      T.P.Last_Val := T.P.Last_Val + Num;

      if T.P.Last_Val > T.P.Max then

         Reallocate (T);

      end if;

   end Allocate;

   ------------

   -- Append --

   ------------

   procedure Append (T : in out Instance; New_Val : Table_Component_Type) is

   begin

      Set_Item (T, Table_Index_Type (T.P.Last_Val + 1), New_Val);

   end Append;

   ----------------

   -- Append_All --

   ----------------

   procedure Append_All (T : in out Instance; New_Vals : Table_Type) is

   begin

      for J in New_Vals'Range loop

         Append (T, New_Vals (J));

      end loop;

   end Append_All;

   --------------------

   -- Decrement_Last --

   --------------------

   procedure Decrement_Last (T : in out Instance) is

   begin

      T.P.Last_Val := T.P.Last_Val - 1;

   end Decrement_Last;

   --------------

   -- For_Each --

   --------------

   procedure For_Each (Table : Instance) is

      Quit : Boolean := False;

   begin

      for Index in Table_Low_Bound .. Table_Index_Type (Table.P.Last_Val) loop

         Action (Index, Table.Table (Index), Quit);

         exit when Quit;

      end loop;

   end For_Each;

   ----------

   -- Free --

   ----------

   procedure Free (T : in out Instance) is

   begin

      Free (To_Address (T.Table));

      T.Table := null;

      T.P.Length := 0;

   end Free;

   --------------------

   -- Increment_Last --

   --------------------

   procedure Increment_Last (T : in out Instance) is

   begin

      T.P.Last_Val := T.P.Last_Val + 1;

      if T.P.Last_Val > T.P.Max then

         Reallocate (T);

      end if;

   end Increment_Last;

   ----------

   -- Init --

   ----------

   procedure Init (T : in out Instance) is

      Old_Length : constant Integer := T.P.Length;

   begin

      T.P.Last_Val := Min - 1;

      T.P.Max      := Min + Table_Initial - 1;

      T.P.Length   := T.P.Max - Min + 1;

      --  If table is same size as before (happens when table is never

      --  expanded which is a common case), then simply reuse it. Note

      --  that this also means that an explicit Init call right after

      --  the implicit one in the package body is harmless.

      if Old_Length = T.P.Length then

         return;

      --  Otherwise we can use Reallocate to get a table of the right size.

      --  Note that Reallocate works fine to allocate a table of the right

      --  initial size when it is first allocated.

      else

         Reallocate (T);

      end if;

   end Init;

   ----------

   -- Last --

   ----------

   function Last (T : Instance) return Table_Index_Type is

   begin

      return Table_Index_Type (T.P.Last_Val);

   end Last;

   ----------------

   -- Reallocate --

   ----------------

   procedure Reallocate (T : in out Instance) is

      New_Length : Integer;

      New_Size   : size_t;

   begin

      if T.P.Max < T.P.Last_Val then

         while T.P.Max < T.P.Last_Val loop

            New_Length := T.P.Length * (100 + Table_Increment) / 100;

            if New_Length > T.P.Length then

               T.P.Length := New_Length;

            else

               T.P.Length := T.P.Length + 1;

            end if;

            T.P.Max := Min + T.P.Length - 1;

         end loop;

      end if;

      New_Size :=

        size_t ((T.P.Max - Min + 1) *

                (Table_Type'Component_Size / Storage_Unit));

      if T.Table = null then

         T.Table := To_Pointer (Alloc (New_Size));

      elsif New_Size > 0 then

         T.Table :=

           To_Pointer (Realloc (Ptr  => To_Address (T.Table),

                                Size => New_Size));

      end if;

      if T.P.Length /= 0 and then T.Table = null then

         raise Storage_Error;

      end if;

   end Reallocate;

   -------------

   -- Release --

   -------------

   procedure Release (T : in out Instance) is

   begin

      T.P.Length := T.P.Last_Val - Integer (Table_Low_Bound) + 1;

      T.P.Max    := T.P.Last_Val;

      Reallocate (T);

   end Release;

   --------------

   -- Set_Item --

   --------------

   procedure Set_Item

      (T     : in out Instance;

       Index : Table_Index_Type;

       Item  : Table_Component_Type)

   is

      --  If Item is a value within the current allocation, and we are going to

      --  reallocate, then we must preserve an intermediate copy here before

      --  calling Increment_Last. Otherwise, if Table_Component_Type is passed

      --  by reference, we are going to end up copying from storage that might

      --  have been deallocated from Increment_Last calling Reallocate.

      subtype Allocated_Table_T is

        Table_Type (T.Table'First .. Table_Index_Type (T.P.Max + 1));

      --  A constrained table subtype one element larger than the currently

      --  allocated table.

      Allocated_Table_Address : constant System.Address :=

                                  T.Table.all'Address;

      --  Used for address clause below (we can't use non-static expression

      --  Table.all'Address directly in the clause because some older versions

      --  of the compiler do not allow it).

      Allocated_Table : Allocated_Table_T;

      pragma Import (Ada, Allocated_Table);

      pragma Suppress (Range_Check, On => Allocated_Table);

      for Allocated_Table'Address use Allocated_Table_Address;

      --  Allocated_Table represents the currently allocated array, plus one

      --  element (the supplementary element is used to have a convenient way

      --  to the address just past the end of the current allocation). Range

      --  checks are suppressed because this unit uses direct calls to

      --  System.Memory for allocation, and this can yield misaligned storage

      --  (and we cannot rely on the bootstrap compiler supporting specifically

      --  disabling alignment checks, so we need to suppress all range checks).

      --  It is safe to suppress this check here because we know that a

      --  (possibly misaligned) object of that type does actually exist at that

      --  address.

      --  ??? We should really improve the allocation circuitry here to

      --  guarantee proper alignment.

      Need_Realloc : constant Boolean := Integer (Index) > T.P.Max;

      --  True if this operation requires storage reallocation (which may

      --  involve moving table contents around).

   begin

      --  If we're going to reallocate, check whether Item references an

      --  element of the currently allocated table.

      if Need_Realloc

        and then Allocated_Table'Address <= Item'Address

        and then Item'Address <

                   Allocated_Table (Table_Index_Type (T.P.Max + 1))'Address

      then

         --  If so, save a copy on the stack because Increment_Last will

         --  reallocate storage and might deallocate the current table.

         declare

            Item_Copy : constant Table_Component_Type := Item;

         begin

            Set_Last (T, Index);

            T.Table (Index) := Item_Copy;

         end;

      else

         --  Here we know that either we won't reallocate (case of Index < Max)

         --  or that Item is not in the currently allocated table.

         if Integer (Index) > T.P.Last_Val then

            Set_Last (T, Index);

         end if;

         T.Table (Index) := Item;

      end if;

   end Set_Item;

   --------------

   -- Set_Last --

   --------------

   procedure Set_Last (T : in out Instance; New_Val : Table_Index_Type) is

   begin

      if Integer (New_Val) < T.P.Last_Val then

         T.P.Last_Val := Integer (New_Val);

      else

         T.P.Last_Val := Integer (New_Val);

         if T.P.Last_Val > T.P.Max then

            Reallocate (T);

         end if;

      end if;

   end Set_Last;

   ----------------

   -- Sort_Table --

   ----------------

   procedure Sort_Table (Table : in out Instance) is

      Temp : Table_Component_Type;

      --  A temporary position to simulate index 0

      --  Local subprograms

      function Index_Of (Idx : Natural) return Table_Index_Type;

      --  Return index of Idx'th element of table

      function Lower_Than (Op1, Op2 : Natural) return Boolean;

      --  Compare two components

      procedure Move (From : Natural; To : Natural);

      --  Move one component

      package Heap_Sort is new GNAT.Heap_Sort_G (Move, Lower_Than);

      --------------

      -- Index_Of --

      --------------

      function Index_Of (Idx : Natural) return Table_Index_Type is

         J : constant Integer'Base :=

               Table_Index_Type'Pos (First) + Idx - 1;

      begin

         return Table_Index_Type'Val (J);

      end Index_Of;

      ----------

      -- Move --

      ----------

      procedure Move (From : Natural; To : Natural) is

      begin

         if From = 0 then

            Table.Table (Index_Of (To)) := Temp;

         elsif To = 0 then

            Temp := Table.Table (Index_Of (From));

         else

            Table.Table (Index_Of (To)) :=

              Table.Table (Index_Of (From));

         end if;

      end Move;

      ----------------

      -- Lower_Than --

      ----------------

      function Lower_Than (Op1, Op2 : Natural) return Boolean is

      begin

         if Op1 = 0 then

            return Lt (Temp, Table.Table (Index_Of (Op2)));

         elsif Op2 = 0 then

            return Lt (Table.Table (Index_Of (Op1)), Temp);

         else

            return

              Lt (Table.Table (Index_Of (Op1)),

                   Table.Table (Index_Of (Op2)));

         end if;

      end Lower_Than;

   --  Start of processing for Sort_Table

   begin

      Heap_Sort.Sort (Natural (Last (Table) - First) + 1);

   end Sort_Table;

end GNAT.Dynamic_Tables;