path: root/gcc/ada/s-stratt.adb

------------------------------------------------------------------------------
--                                                                          --
--                         GNAT RUNTIME COMPONENTS                          --
--                                                                          --
--             S Y S T E M . S T R E A M _ A T T R I B U T E S              --
--                                                                          --
--                                 B o d y                                  --
--                                                                          --
--                            $Revision: 1.7 $                              --
--                                                                          --
--          Copyright (C) 1992-1998, 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 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,  59 Temple Place - Suite 330,  Boston, --
-- MA 02111-1307, 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. --
-- It is now maintained by Ada Core Technologies Inc (http://www.gnat.com). --
--                                                                          --
------------------------------------------------------------------------------

with Ada.IO_Exceptions;
with Ada.Streams; use Ada.Streams;
with Unchecked_Conversion;

package body System.Stream_Attributes is

   Err : exception renames Ada.IO_Exceptions.End_Error;
   --  Exception raised if insufficient data read (note that the RM implies
   --  that Data_Error might be the appropriate choice, but AI195-00132
   --  decides with a binding interpretation that End_Error is preferred).

   SU : constant := System.Storage_Unit;

   subtype SEA is Ada.Streams.Stream_Element_Array;
   subtype SEO is Ada.Streams.Stream_Element_Offset;

   generic function UC renames Unchecked_Conversion;

   --  Subtypes used to define Stream_Element_Array values that map
   --  into the elementary types, using unchecked conversion.

   Thin_Pointer_Size : constant := System.Address'Size;
   Fat_Pointer_Size  : constant := System.Address'Size * 2;

   subtype S_AD  is SEA (1 .. (Fat_Pointer_Size              + SU - 1) / SU);
   subtype S_AS  is SEA (1 .. (Thin_Pointer_Size             + SU - 1) / SU);
   subtype S_B   is SEA (1 .. (Boolean'Size                  + SU - 1) / SU);
   subtype S_C   is SEA (1 .. (Character'Size                + SU - 1) / SU);
   subtype S_F   is SEA (1 .. (Float'Size                    + SU - 1) / SU);
   subtype S_I   is SEA (1 .. (Integer'Size                  + SU - 1) / SU);
   subtype S_LF  is SEA (1 .. (Long_Float'Size               + SU - 1) / SU);
   subtype S_LI  is SEA (1 .. (Long_Integer'Size             + SU - 1) / SU);
   subtype S_LLF is SEA (1 .. (Long_Long_Float'Size          + SU - 1) / SU);
   subtype S_LLI is SEA (1 .. (Long_Long_Integer'Size        + SU - 1) / SU);
   subtype S_LLU is SEA (1 .. (UST.Long_Long_Unsigned'Size   + SU - 1) / SU);
   subtype S_LU  is SEA (1 .. (UST.Long_Unsigned'Size        + SU - 1) / SU);
   subtype S_SF  is SEA (1 .. (Short_Float'Size              + SU - 1) / SU);
   subtype S_SI  is SEA (1 .. (Short_Integer'Size            + SU - 1) / SU);
   subtype S_SSI is SEA (1 .. (Short_Short_Integer'Size      + SU - 1) / SU);
   subtype S_SSU is SEA (1 .. (UST.Short_Short_Unsigned'Size + SU - 1) / SU);
   subtype S_SU  is SEA (1 .. (UST.Short_Unsigned'Size       + SU - 1) / SU);
   subtype S_U   is SEA (1 .. (UST.Unsigned'Size             + SU - 1) / SU);
   subtype S_WC  is SEA (1 .. (Wide_Character'Size           + SU - 1) / SU);

   --  Unchecked conversions from the elementary type to the stream type

   function From_AD  is new UC (Fat_Pointer,              S_AD);
   function From_AS  is new UC (Thin_Pointer,             S_AS);
   function From_C   is new UC (Character,                S_C);
   function From_F   is new UC (Float,                    S_F);
   function From_I   is new UC (Integer,                  S_I);
   function From_LF  is new UC (Long_Float,               S_LF);
   function From_LI  is new UC (Long_Integer,             S_LI);
   function From_LLF is new UC (Long_Long_Float,          S_LLF);
   function From_LLI is new UC (Long_Long_Integer,        S_LLI);
   function From_LLU is new UC (UST.Long_Long_Unsigned,   S_LLU);
   function From_LU  is new UC (UST.Long_Unsigned,        S_LU);
   function From_SF  is new UC (Short_Float,              S_SF);
   function From_SI  is new UC (Short_Integer,            S_SI);
   function From_SSI is new UC (Short_Short_Integer,      S_SSI);
   function From_SSU is new UC (UST.Short_Short_Unsigned, S_SSU);
   function From_SU  is new UC (UST.Short_Unsigned,       S_SU);
   function From_U   is new UC (UST.Unsigned,             S_U);
   function From_WC  is new UC (Wide_Character,           S_WC);

   --  Unchecked conversions from the stream type to elementary type

   function To_AD  is new UC (S_AD,  Fat_Pointer);
   function To_AS  is new UC (S_AS,  Thin_Pointer);
   function To_C   is new UC (S_C,   Character);
   function To_F   is new UC (S_F,   Float);
   function To_I   is new UC (S_I,   Integer);
   function To_LF  is new UC (S_LF,  Long_Float);
   function To_LI  is new UC (S_LI,  Long_Integer);
   function To_LLF is new UC (S_LLF, Long_Long_Float);
   function To_LLI is new UC (S_LLI, Long_Long_Integer);
   function To_LLU is new UC (S_LLU, UST.Long_Long_Unsigned);
   function To_LU  is new UC (S_LU,  UST.Long_Unsigned);
   function To_SF  is new UC (S_SF,  Short_Float);
   function To_SI  is new UC (S_SI,  Short_Integer);
   function To_SSI is new UC (S_SSI, Short_Short_Integer);
   function To_SSU is new UC (S_SSU, UST.Short_Short_Unsigned);
   function To_SU  is new UC (S_SU,  UST.Short_Unsigned);
   function To_U   is new UC (S_U,   UST.Unsigned);
   function To_WC  is new UC (S_WC,  Wide_Character);

   ----------
   -- I_AD --
   ----------

   function I_AD (Stream : access RST) return Fat_Pointer is
      T : S_AD;
      L : SEO;

   begin
      Ada.Streams.Read (Stream.all, T, L);

      if L < T'Last then
         raise Err;
      else
         return To_AD (T);
      end if;
   end I_AD;

   ----------
   -- I_AS --
   ----------

   function I_AS (Stream : access RST) return Thin_Pointer is
      T : S_AS;
      L : SEO;

   begin
      Ada.Streams.Read (Stream.all, T, L);

      if L < T'Last then
         raise Err;
      else
         return To_AS (T);
      end if;
   end I_AS;

   ---------
   -- I_B --
   ---------

   function I_B (Stream : access RST) return Boolean is
      T : S_B;
      L : SEO;

   begin
      Ada.Streams.Read (Stream.all, T, L);

      if L < T'Last then
         raise Err;
      else
         return Boolean'Val (T (1));
      end if;
   end I_B;

   ---------
   -- I_C --
   ---------

   function I_C (Stream : access RST) return Character is
      T : S_C;
      L : SEO;

   begin
      Ada.Streams.Read (Stream.all, T, L);

      if L < T'Last then
         raise Err;
      else
         return To_C (T);
      end if;
   end I_C;

   ---------
   -- I_F --
   ---------

   function I_F (Stream : access RST) return Float is
      T : S_F;
      L : SEO;

   begin
      Ada.Streams.Read (Stream.all, T, L);

      if L < T'Last then
         raise Err;
      else
         return To_F (T);
      end if;
   end I_F;

   ---------
   -- I_I --
   ---------

   function I_I (Stream : access RST) return Integer is
      T : S_I;
      L : SEO;

   begin
      Ada.Streams.Read (Stream.all, T, L);

      if L < T'Last then
         raise Err;
      else
         return To_I (T);
      end if;
   end I_I;

   ----------
   -- I_LF --
   ----------

   function I_LF (Stream : access RST) return Long_Float is
      T : S_LF;
      L : SEO;

   begin
      Ada.Streams.Read (Stream.all, T, L);

      if L < T'Last then
         raise Err;
      else
         return To_LF (T);
      end if;
   end I_LF;

   ----------
   -- I_LI --
   ----------

   function I_LI (Stream : access RST) return Long_Integer is
      T : S_LI;
      L : SEO;

   begin
      Ada.Streams.Read (Stream.all, T, L);

      if L < T'Last then
         raise Err;
      else
         return To_LI (T);
      end if;
   end I_LI;

   -----------
   -- I_LLF --
   -----------

   function I_LLF (Stream : access RST) return Long_Long_Float is
      T : S_LLF;
      L : SEO;

   begin
      Ada.Streams.Read (Stream.all, T, L);

      if L < T'Last then
         raise Err;
      else
         return To_LLF (T);
      end if;
   end I_LLF;

   -----------
   -- I_LLI --
   -----------

   function I_LLI (Stream : access RST) return Long_Long_Integer is
      T : S_LLI;
      L : SEO;

   begin
      Ada.Streams.Read (Stream.all, T, L);

      if L < T'Last then
         raise Err;
      else
         return To_LLI (T);
      end if;
   end I_LLI;

   -----------
   -- I_LLU --
   -----------

   function I_LLU (Stream : access RST) return UST.Long_Long_Unsigned is
      T : S_LLU;
      L : SEO;

   begin
      Ada.Streams.Read (Stream.all, T, L);

      if L < T'Last then
         raise Err;
      else
         return To_LLU (T);
      end if;
   end I_LLU;

   ----------
   -- I_LU --
   ----------

   function I_LU (Stream : access RST) return UST.Long_Unsigned is
      T : S_LU;
      L : SEO;

   begin
      Ada.Streams.Read (Stream.all, T, L);

      if L < T'Last then
         raise Err;
      else
         return To_LU (T);
      end if;
   end I_LU;

   ----------
   -- I_SF --
   ----------

   function I_SF (Stream : access RST) return Short_Float is
      T : S_SF;
      L : SEO;

   begin
      Ada.Streams.Read (Stream.all, T, L);

      if L < T'Last then
         raise Err;
      else
         return To_SF (T);
      end if;
   end I_SF;

   ----------
   -- I_SI --
   ----------

   function I_SI (Stream : access RST) return Short_Integer is
      T : S_SI;
      L : SEO;

   begin
      Ada.Streams.Read (Stream.all, T, L);

      if L < T'Last then
         raise Err;
      else
         return To_SI (T);
      end if;
   end I_SI;

   -----------
   -- I_SSI --
   -----------

   function I_SSI (Stream : access RST) return Short_Short_Integer is
      T : S_SSI;
      L : SEO;

   begin
      Ada.Streams.Read (Stream.all, T, L);

      if L < T'Last then
         raise Err;
      else
         return To_SSI (T);
      end if;
   end I_SSI;

   -----------
   -- I_SSU --
   -----------

   function I_SSU (Stream : access RST) return UST.Short_Short_Unsigned is
      T : S_SSU;
      L : SEO;

   begin
      Ada.Streams.Read (Stream.all, T, L);

      if L < T'Last then
         raise Err;
      else
         return To_SSU (T);
      end if;
   end I_SSU;

   ----------
   -- I_SU --
   ----------

   function I_SU (Stream : access RST) return UST.Short_Unsigned is
      T : S_SU;
      L : SEO;

   begin
      Ada.Streams.Read (Stream.all, T, L);

      if L < T'Last then
         raise Err;
      else
         return To_SU (T);
      end if;
   end I_SU;

   ---------
   -- I_U --
   ---------

   function I_U (Stream : access RST) return UST.Unsigned is
      T : S_U;
      L : SEO;

   begin
      Ada.Streams.Read (Stream.all, T, L);

      if L < T'Last then
         raise Err;
      else
         return To_U (T);
      end if;
   end I_U;

   ----------
   -- I_WC --
   ----------

   function I_WC (Stream : access RST) return Wide_Character is
      T : S_WC;
      L : SEO;

   begin
      Ada.Streams.Read (Stream.all, T, L);

      if L < T'Last then
         raise Err;
      else
         return To_WC (T);
      end if;
   end I_WC;

   ----------
   -- W_AD --
   ----------

   procedure W_AD (Stream : access RST; Item : in Fat_Pointer) is
      T : constant S_AD := From_AD (Item);

   begin
      Ada.Streams.Write (Stream.all, T);
   end W_AD;

   ----------
   -- W_AS --
   ----------

   procedure W_AS (Stream : access RST; Item : in Thin_Pointer) is
      T : constant S_AS := From_AS (Item);

   begin
      Ada.Streams.Write (Stream.all, T);
   end W_AS;

   ---------
   -- W_B --
   ---------

   procedure W_B (Stream : access RST; Item : in Boolean) is
      T : S_B;

   begin
      T (1) := Boolean'Pos (Item);
      Ada.Streams.Write (Stream.all, T);
   end W_B;

   ---------
   -- W_C --
   ---------

   procedure W_C (Stream : access RST; Item : in Character) is
      T : constant S_C := From_C (Item);

   begin
      Ada.Streams.Write (Stream.all, T);
   end W_C;

   ---------
   -- W_F --
   ---------

   procedure W_F (Stream : access RST; Item : in Float) is
      T : constant S_F := From_F (Item);

   begin
      Ada.Streams.Write (Stream.all, T);
   end W_F;

   ---------
   -- W_I --
   ---------

   procedure W_I (Stream : access RST; Item : in Integer) is
      T : constant S_I := From_I (Item);

   begin
      Ada.Streams.Write (Stream.all, T);
   end W_I;

   ----------
   -- W_LF --
   ----------

   procedure W_LF (Stream : access RST; Item : in Long_Float) is
      T : constant S_LF := From_LF (Item);

   begin
      Ada.Streams.Write (Stream.all, T);
   end W_LF;

   ----------
   -- W_LI --
   ----------

   procedure W_LI (Stream : access RST; Item : in Long_Integer) is
      T : constant S_LI := From_LI (Item);

   begin
      Ada.Streams.Write (Stream.all, T);
   end W_LI;

   -----------
   -- W_LLF --
   -----------

   procedure W_LLF (Stream : access RST; Item : in Long_Long_Float) is
      T : constant S_LLF := From_LLF (Item);

   begin
      Ada.Streams.Write (Stream.all, T);
   end W_LLF;

   -----------
   -- W_LLI --
   -----------

   procedure W_LLI (Stream : access RST; Item : in Long_Long_Integer) is
      T : constant S_LLI := From_LLI (Item);

   begin
      Ada.Streams.Write (Stream.all, T);
   end W_LLI;

   -----------
   -- W_LLU --
   -----------

   procedure W_LLU (Stream : access RST; Item : in UST.Long_Long_Unsigned) is
      T : constant S_LLU := From_LLU (Item);

   begin
      Ada.Streams.Write (Stream.all, T);
   end W_LLU;

   ----------
   -- W_LU --
   ----------

   procedure W_LU (Stream : access RST; Item : in UST.Long_Unsigned) is
      T : constant S_LU := From_LU (Item);

   begin
      Ada.Streams.Write (Stream.all, T);
   end W_LU;

   ----------
   -- W_SF --
   ----------

   procedure W_SF (Stream : access RST; Item : in Short_Float) is
      T : constant S_SF := From_SF (Item);

   begin
      Ada.Streams.Write (Stream.all, T);
   end W_SF;

   ----------
   -- W_SI --
   ----------

   procedure W_SI (Stream : access RST; Item : in Short_Integer) is
      T : constant S_SI := From_SI (Item);

   begin
      Ada.Streams.Write (Stream.all, T);
   end W_SI;

   -----------
   -- W_SSI --
   -----------

   procedure W_SSI (Stream : access RST; Item : in Short_Short_Integer) is
      T : constant S_SSI := From_SSI (Item);

   begin
      Ada.Streams.Write (Stream.all, T);
   end W_SSI;

   -----------
   -- W_SSU --
   -----------

   procedure W_SSU (Stream : access RST; Item : in UST.Short_Short_Unsigned) is
      T : constant S_SSU := From_SSU (Item);

   begin
      Ada.Streams.Write (Stream.all, T);
   end W_SSU;

   ----------
   -- W_SU --
   ----------

   procedure W_SU (Stream : access RST; Item : in UST.Short_Unsigned) is
      T : constant S_SU := From_SU (Item);

   begin
      Ada.Streams.Write (Stream.all, T);
   end W_SU;

   ---------
   -- W_U --
   ---------

   procedure W_U (Stream : access RST; Item : in UST.Unsigned) is
      T : constant S_U := From_U (Item);

   begin
      Ada.Streams.Write (Stream.all, T);
   end W_U;

   ----------
   -- W_WC --
   ----------

   procedure W_WC (Stream : access RST; Item : in Wide_Character) is
      T : constant S_WC := From_WC (Item);

   begin
      Ada.Streams.Write (Stream.all, T);
   end W_WC;

end System.Stream_Attributes;