Subversion Repositories openrisc

------------------------------------------------------------------------------
--                                                                          --
--                         GNAT COMPILER COMPONENTS                         --
--                                                                          --
--                 I N T E R F A C E S . C . S T R I N G S                  --
--                                                                          --
--                                 B o d y                                  --
--                                                                          --
--          Copyright (C) 1992-2010, 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.                                     --
--                                                                          --
-- 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.      --
--                                                                          --
------------------------------------------------------------------------------
 
with System; use System;
with System.Storage_Elements; use System.Storage_Elements;
 
with Ada.Unchecked_Conversion;
 
package body Interfaces.C.Strings is
 
   --  Note that the type chars_ptr has a pragma No_Strict_Aliasing in the
   --  spec, to prevent any assumptions about aliasing for values of this type,
   --  since arbitrary addresses can be converted, and it is quite likely that
   --  this type will in fact be used for aliasing values of other types.
 
   function To_chars_ptr is
      new Ada.Unchecked_Conversion (System.Parameters.C_Address, chars_ptr);
 
   function To_Address is
      new Ada.Unchecked_Conversion (chars_ptr, System.Parameters.C_Address);
 
   -----------------------
   -- Local Subprograms --
   -----------------------
 
   function Peek (From : chars_ptr) return char;
   pragma Inline (Peek);
   --  Given a chars_ptr value, obtain referenced character
 
   procedure Poke (Value : char; Into : chars_ptr);
   pragma Inline (Poke);
   --  Given a chars_ptr, modify referenced Character value
 
   function "+" (Left : chars_ptr; Right : size_t) return chars_ptr;
   pragma Inline ("+");
   --  Address arithmetic on chars_ptr value
 
   function Position_Of_Nul (Into : char_array) return size_t;
   --  Returns position of the first Nul in Into or Into'Last + 1 if none
 
   --  We can't use directly System.Memory because the categorization is not
   --  compatible, so we directly import here the malloc and free routines.
 
   function Memory_Alloc (Size : size_t) return chars_ptr;
   pragma Import (C, Memory_Alloc, System.Parameters.C_Malloc_Linkname);
 
   procedure Memory_Free (Address : chars_ptr);
   pragma Import (C, Memory_Free, "__gnat_free");
 
   ---------
   -- "+" --
   ---------
 
   function "+" (Left : chars_ptr; Right : size_t) return chars_ptr is
   begin
      return To_chars_ptr (To_Address (Left) + Storage_Offset (Right));
   end "+";
 
   ----------
   -- Free --
   ----------
 
   procedure Free (Item : in out chars_ptr) is
   begin
      if Item = Null_Ptr then
         return;
      end if;
 
      Memory_Free (Item);
      Item := Null_Ptr;
   end Free;
 
   --------------------
   -- New_Char_Array --
   --------------------
 
   function New_Char_Array (Chars : char_array) return chars_ptr is
      Index   : size_t;
      Pointer : chars_ptr;
 
   begin
      --  Get index of position of null. If Index > Chars'Last,
      --  nul is absent and must be added explicitly.
 
      Index := Position_Of_Nul (Into => Chars);
      Pointer := Memory_Alloc ((Index - Chars'First + 1));
 
      --  If nul is present, transfer string up to and including nul
 
      if Index <= Chars'Last then
         Update (Item   => Pointer,
                 Offset => 0,
                 Chars  => Chars (Chars'First .. Index),
                 Check  => False);
      else
         --  If original string has no nul, transfer whole string and add
         --  terminator explicitly.
 
         Update (Item   => Pointer,
                 Offset => 0,
                 Chars  => Chars,
                 Check  => False);
         Poke (nul, Into => Pointer + size_t'(Chars'Length));
      end if;
 
      return Pointer;
   end New_Char_Array;
 
   ----------------
   -- New_String --
   ----------------
 
   function New_String (Str : String) return chars_ptr is
 
      --  It's important that this subprogram uses the heap directly to compute
      --  the result, and doesn't copy the string on the stack, otherwise its
      --  use is limited when used from tasks on large strings.
 
      Result : constant chars_ptr := Memory_Alloc (Str'Length + 1);
 
      Result_Array : char_array  (1 .. Str'Length + 1);
      for Result_Array'Address use To_Address (Result);
      pragma Import (Ada, Result_Array);
 
      Count : size_t;
 
   begin
      To_C
        (Item       => Str,
         Target     => Result_Array,
         Count      => Count,
         Append_Nul => True);
      return Result;
   end New_String;
 
   ----------
   -- Peek --
   ----------
 
   function Peek (From : chars_ptr) return char is
   begin
      return char (From.all);
   end Peek;
 
   ----------
   -- Poke --
   ----------
 
   procedure Poke (Value : char; Into : chars_ptr) is
   begin
      Into.all := Character (Value);
   end Poke;
 
   ---------------------
   -- Position_Of_Nul --
   ---------------------
 
   function Position_Of_Nul (Into : char_array) return size_t is
   begin
      for J in Into'Range loop
         if Into (J) = nul then
            return J;
         end if;
      end loop;
 
      return Into'Last + 1;
   end Position_Of_Nul;
 
   ------------
   -- Strlen --
   ------------
 
   function Strlen (Item : chars_ptr) return size_t is
      Item_Index : size_t := 0;
 
   begin
      if Item = Null_Ptr then
         raise Dereference_Error;
      end if;
 
      loop
         if Peek (Item + Item_Index) = nul then
            return Item_Index;
         end if;
 
         Item_Index := Item_Index + 1;
      end loop;
   end Strlen;
 
   ------------------
   -- To_Chars_Ptr --
   ------------------
 
   function To_Chars_Ptr
     (Item      : char_array_access;
      Nul_Check : Boolean := False) return chars_ptr
   is
   begin
      if Item = null then
         return Null_Ptr;
      elsif Nul_Check
        and then Position_Of_Nul (Into => Item.all) > Item'Last
      then
         raise Terminator_Error;
      else
         return To_chars_ptr (Item (Item'First)'Address);
      end if;
   end To_Chars_Ptr;
 
   ------------
   -- Update --
   ------------
 
   procedure Update
     (Item   : chars_ptr;
      Offset : size_t;
      Chars  : char_array;
      Check  : Boolean := True)
   is
      Index : chars_ptr := Item + Offset;
 
   begin
      if Check and then Offset + Chars'Length  > Strlen (Item) then
         raise Update_Error;
      end if;
 
      for J in Chars'Range loop
         Poke (Chars (J), Into => Index);
         Index := Index + size_t'(1);
      end loop;
   end Update;
 
   procedure Update
     (Item   : chars_ptr;
      Offset : size_t;
      Str    : String;
      Check  : Boolean := True)
   is
   begin
      --  Note: in RM 95, the Append_Nul => False parameter is omitted. But
      --  this has the unintended consequence of truncating the string after
      --  an update. As discussed in Ada 2005 AI-242, this was unintended,
      --  and should be corrected. Since this is a clear error, it seems
      --  appropriate to apply the correction in Ada 95 mode as well.
 
      Update (Item, Offset, To_C (Str, Append_Nul => False), Check);
   end Update;
 
   -----------
   -- Value --
   -----------
 
   function Value (Item : chars_ptr) return char_array is
      Result : char_array (0 .. Strlen (Item));
 
   begin
      if Item = Null_Ptr then
         raise Dereference_Error;
      end if;
 
      --  Note that the following loop will also copy the terminating Nul
 
      for J in Result'Range loop
         Result (J) := Peek (Item + J);
      end loop;
 
      return Result;
   end Value;
 
   function Value
     (Item   : chars_ptr;
      Length : size_t) return char_array
   is
   begin
      if Item = Null_Ptr then
         raise Dereference_Error;
      end if;
 
      --  ACATS cxb3010 checks that Constraint_Error gets raised when Length
      --  is 0. Seems better to check that Length is not null before declaring
      --  an array with size_t bounds of 0 .. Length - 1 anyway.
 
      if Length = 0 then
         raise Constraint_Error;
      end if;
 
      declare
         Result : char_array (0 .. Length - 1);
 
      begin
         for J in Result'Range loop
            Result (J) := Peek (Item + J);
 
            if Result (J) = nul then
               return Result (0 .. J);
            end if;
         end loop;
 
         return Result;
      end;
   end Value;
 
   function Value (Item : chars_ptr) return String is
   begin
      return To_Ada (Value (Item));
   end Value;
 
   function Value (Item : chars_ptr; Length : size_t) return String is
      Result : char_array (0 .. Length);
 
   begin
      --  As per AI-00177, this is equivalent to:
 
      --    To_Ada (Value (Item, Length) & nul);
 
      if Item = Null_Ptr then
         raise Dereference_Error;
      end if;
 
      for J in 0 .. Length - 1 loop
         Result (J) := Peek (Item + J);
 
         if Result (J) = nul then
            return To_Ada (Result (0 .. J));
         end if;
      end loop;
 
      Result (Length) := nul;
      return To_Ada (Result);
   end Value;
 
end Interfaces.C.Strings;