Subversion Repositories openrisc

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

--                                                                          --

--                         GNAT RUN-TIME COMPONENTS                         --

--                                                                          --

--                            G N A T . T A B L E                           --

--                                                                          --

--                                 B o d y                                  --

--                                                                          --

--                     Copyright (C) 1998-2009, 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 2,  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 COPYING.  If not, write --

-- to  the  Free Software Foundation,  51  Franklin  Street,  Fifth  Floor, --

-- Boston, MA 02110-1301, USA.                                              --

--                                                                          --

-- As a special exception,  if other files  instantiate  generics from this --

-- unit, or you link  this unit with other files  to produce an executable, --

-- this  unit  does not  by itself cause  the resulting  executable  to  be --

-- covered  by the  GNU  General  Public  License.  This exception does not --

-- however invalidate  any other reasons why  the executable file  might be --

-- covered by the  GNU Public License.                                      --

--                                                                          --

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

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

--                                                                          --

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

with System;        use System;

with System.Memory; use System.Memory;

with Ada.Unchecked_Conversion;

package body GNAT.Table is

   Min : constant Integer := Integer (Table_Low_Bound);

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

   Max : Integer;

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

   Length : Integer := 0;

   --  Number of entries in currently allocated table. The value of zero

   --  ensures that we initially allocate the table.

   Last_Val : Integer;

   --  Current value of Last

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

   -- Local Subprograms --

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

   procedure Reallocate;

   --  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);

   --  Turn off warnings. The following unchecked conversions are only used

   --  internally in this package, and cannot never result in any instances

   --  of improperly aliased pointers for the client of the package.

   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 --

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

   function Allocate (Num : Integer := 1) return Table_Index_Type is

      Old_Last : constant Integer := Last_Val;

   begin

      Last_Val := Last_Val + Num;

      if Last_Val > Max then

         Reallocate;

      end if;

      return Table_Index_Type (Old_Last + 1);

   end Allocate;

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

   -- Append --

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

   procedure Append (New_Val : Table_Component_Type) is

   begin

      Set_Item (Table_Index_Type (Last_Val + 1), New_Val);

   end Append;

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

   -- Append_All --

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

   procedure Append_All (New_Vals : Table_Type) is

   begin

      for J in New_Vals'Range loop

         Append (New_Vals (J));

      end loop;

   end Append_All;

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

   -- Decrement_Last --

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

   procedure Decrement_Last is

   begin

      Last_Val := Last_Val - 1;

   end Decrement_Last;

   ----------

   -- Free --

   ----------

   procedure Free is

   begin

      Free (To_Address (Table));

      Table := null;

      Length := 0;

   end Free;

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

   -- Increment_Last --

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

   procedure Increment_Last is

   begin

      Last_Val := Last_Val + 1;

      if Last_Val > Max then

         Reallocate;

      end if;

   end Increment_Last;

   ----------

   -- Init --

   ----------

   procedure Init is

      Old_Length : constant Integer := Length;

   begin

      Last_Val := Min - 1;

      Max      := Min + Table_Initial - 1;

      Length   := 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 = 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;

      end if;

   end Init;

   ----------

   -- Last --

   ----------

   function Last return Table_Index_Type is

   begin

      return Table_Index_Type (Last_Val);

   end Last;

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

   -- Reallocate --

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

   procedure Reallocate is

      New_Size : size_t;

   begin

      if Max < Last_Val then

         pragma Assert (not Locked);

         while Max < Last_Val loop

            --  Increase length using the table increment factor, but make

            --  sure that we add at least ten elements (this avoids a loop

            --  for silly small increment values)

            Length := Integer'Max

                        (Length * (100 + Table_Increment) / 100,

                         Length + 10);

            Max := Min + Length - 1;

         end loop;

      end if;

      New_Size :=

        size_t ((Max - Min + 1) *

                (Table_Type'Component_Size / Storage_Unit));

      if Table = null then

         Table := To_Pointer (Alloc (New_Size));

      elsif New_Size > 0 then

         Table :=

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

                                Size => New_Size));

      end if;

      if Length /= 0 and then Table = null then

         raise Storage_Error;

      end if;

   end Reallocate;

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

   -- Release --

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

   procedure Release is

   begin

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

      Max    := Last_Val;

      Reallocate;

   end Release;

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

   -- Set_Item --

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

   procedure Set_Item

      (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 (Table'First .. Table_Index_Type (Max + 1));

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

      --  allocated table.

      Allocated_Table_Address : constant System.Address :=

                                  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 of computing 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) > 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 (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 (Index);

            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) > Last_Val then

            Set_Last (Index);

         end if;

         Table (Index) := Item;

      end if;

   end Set_Item;

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

   -- Set_Last --

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

   procedure Set_Last (New_Val : Table_Index_Type) is

   begin

      if Integer (New_Val) < Last_Val then

         Last_Val := Integer (New_Val);

      else

         Last_Val := Integer (New_Val);

         if Last_Val > Max then

            Reallocate;

         end if;

      end if;

   end Set_Last;

begin

   Init;

end GNAT.Table;