From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-wr1-x436.google.com (mail-wr1-x436.google.com [IPv6:2a00:1450:4864:20::436]) by sourceware.org (Postfix) with ESMTPS id 31E0B3861852 for ; Tue, 26 Sep 2023 11:46:27 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 31E0B3861852 Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=adacore.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=adacore.com Received: by mail-wr1-x436.google.com with SMTP id ffacd0b85a97d-31fa15f4cc6so8193401f8f.2 for ; Tue, 26 Sep 2023 04:46:27 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=adacore.com; s=google; t=1695728786; x=1696333586; darn=gcc.gnu.org; h=content-transfer-encoding:mime-version:message-id:date:subject:cc :to:from:from:to:cc:subject:date:message-id:reply-to; bh=i7n1Du3i96+UADHtMBYHNdOo6Oelzf4GvGyA0ng8/Ik=; b=GPTkz9t0dwcMkjdv5cYfmh5pudm+/PsH6i7/IQzughkqn3AeLvSFxxW0piQGMKTYJT xCHy+mSjfHX96BfPZFxKX2E1DQTlIDCccyc0v6DTspFoIxCxXIerG7KHlTTVDFwMBlam IybZ2pAToQfdFCmATmQUQU7prLRv9ikQUGRT1kA60reJN5XhljbW/FlaQ8HEG/d6sV50 I1CLfN9ZU9322kRPJW3IyCd3QiRzCb5hXEbA0fODatVoI1XsLXINnl7RaqobBZLklysP 9ZC4fYBzJ8P5EBxQ6xlkmurq0CjFM8slVzr9xmjq9VvApbLov73Ycm990xlY3ldnRbEu HmuA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1695728786; x=1696333586; h=content-transfer-encoding:mime-version:message-id:date:subject:cc :to:from:x-gm-message-state:from:to:cc:subject:date:message-id :reply-to; bh=i7n1Du3i96+UADHtMBYHNdOo6Oelzf4GvGyA0ng8/Ik=; b=QeHt6qTapbcPja+7+7X604wpa01rJhwOSAgdXFtgHB3MvV011rrIJGAmvZy1zTARyC sutbYnGP7m8zIPRnTSuGmrBg3YNMCQZegxitqgf4oS2j2Uzpzt5jHE/TcdSCT5DVQ1Wm 2BnXjgMUNaTfrWBtLVPg6NsjZkIoFbLSAq7CbrB7D9Nh1/0NxaLieAb/rZxrDU/uvdNV QOE93L8bYUXZBeFFhvOn5NK/wEV1MtDKN1KfUrPgXZ3OVZbPNvA81aau4MTvKNvtaXKV 22zLrKY6rq0NG4Hr/XTmX2DnJ9ojNvE/SoLtCDVqbCNCD3ZXgvzwD37COZL0DFUvM2Cx LYYw== X-Gm-Message-State: AOJu0YyFTthLt4TkXzqBRsqaquqi8hd+rkBJ9oW0EvMRhjs7hnSpIXS7 R+t+CLFnJPSo6ADI9kBA4oqQEZ2AKj5Ib+2Al7JBLw== X-Google-Smtp-Source: AGHT+IFn6Q7krUI45tc2q52AgzrHzf2UgBrA0b9f8W7FfGmeHinS3uTmAIwTdlbVcAWymqXYCtxJxg== X-Received: by 2002:a5d:5943:0:b0:31f:e883:2ffc with SMTP id e3-20020a5d5943000000b0031fe8832ffcmr8671046wri.43.1695728785659; Tue, 26 Sep 2023 04:46:25 -0700 (PDT) Received: from localhost.localdomain ([2001:861:3382:1a90:27f0:a2f3:f97:f30e]) by smtp.gmail.com with ESMTPSA id l16-20020a5d4bd0000000b003216a068d2csm14455883wrt.24.2023.09.26.04.46.24 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 26 Sep 2023 04:46:25 -0700 (PDT) From: =?UTF-8?q?Marc=20Poulhi=C3=A8s?= To: gcc-patches@gcc.gnu.org Cc: Daniel King Subject: [COMMITTED] ada: Add CHERI variant of System.Stream_Attributes Date: Tue, 26 Sep 2023 13:46:24 +0200 Message-ID: <20230926114624.3272649-1-poulhies@adacore.com> X-Mailer: git-send-email 2.42.0 MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Spam-Status: No, score=-12.2 required=5.0 tests=BAYES_00,DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,GIT_PATCH_0,KAM_ASCII_DIVIDERS,KAM_SHORT,LIKELY_SPAM_BODY,RCVD_IN_DNSWL_NONE,SPF_HELO_NONE,SPF_PASS,TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org List-Id: From: Daniel King Reading and writing System.Address to a stream on CHERI targets does not preserve the capability tag; it will always be invalid since a valid capability cannot be created out of thin air. Reading an Address from a stream would therefore never yield a capability that can be dereferenced. This patch introduces a CHERI variant of System.Stream_Attributes that raises Program_Error when attempting to read a System.Address from a stream. gcc/ada/ * libgnat/s-stratt__cheri.adb: New file Tested on x86_64-pc-linux-gnu, committed on master. --- gcc/ada/libgnat/s-stratt__cheri.adb | 1019 +++++++++++++++++++++++++++ 1 file changed, 1019 insertions(+) create mode 100644 gcc/ada/libgnat/s-stratt__cheri.adb diff --git a/gcc/ada/libgnat/s-stratt__cheri.adb b/gcc/ada/libgnat/s-stratt__cheri.adb new file mode 100644 index 00000000000..f753cf3bf00 --- /dev/null +++ b/gcc/ada/libgnat/s-stratt__cheri.adb @@ -0,0 +1,1019 @@ +------------------------------------------------------------------------------ +-- -- +-- GNAT RUN-TIME 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 -- +-- -- +-- Copyright (C) 1992-2023, 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 -- +-- . -- +-- -- +-- GNAT was originally developed by the GNAT team at New York University. -- +-- Extensive contributions were provided by Ada Core Technologies Inc. -- +-- -- +------------------------------------------------------------------------------ + +-- This is the CHERI variant of this package + +with Ada.IO_Exceptions; +with Ada.Streams; use Ada.Streams; +with Ada.Unchecked_Conversion; +with System.Stream_Attributes.XDR; + +package body System.Stream_Attributes is + + XDR_Stream : constant Integer; + pragma Import (C, XDR_Stream, "__gl_xdr_stream"); + -- This imported value is used to determine whether the build had the + -- binder switch "-xdr" present which enables XDR streaming and sets this + -- flag to 1. + + function XDR_Support return Boolean is (XDR_Stream = 1); + pragma Inline (XDR_Support); + -- Return True if XDR streaming should be used. Note that 128-bit integers + -- are not supported by the XDR protocol and will raise Device_Error. + + 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 AI95-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 Ada.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_I24 is SEA (1 .. (Integer_24'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_LLLI is SEA (1 .. (Long_Long_Long_Integer'Size + SU - 1) / SU); + subtype S_LLLU is + SEA (1 .. (UST.Long_Long_Long_Unsigned'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_U24 is SEA (1 .. (Unsigned_24'Size + SU - 1) / SU); + subtype S_WC is SEA (1 .. (Wide_Character'Size + SU - 1) / SU); + subtype S_WWC is SEA (1 .. (Wide_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_F is new UC (Float, S_F); + function From_I is new UC (Integer, S_I); + function From_I24 is new UC (Integer_24, S_I24); + 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_LLLI is new UC (Long_Long_Long_Integer, S_LLLI); + function From_LLLU is new UC (UST.Long_Long_Long_Unsigned, S_LLLU); + 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_U24 is new UC (Unsigned_24, S_U24); + function From_WC is new UC (Wide_Character, S_WC); + function From_WWC is new UC (Wide_Wide_Character, S_WWC); + + -- Unchecked conversions from the stream type to elementary type + + function To_F is new UC (S_F, Float); + function To_I is new UC (S_I, Integer); + function To_I24 is new UC (S_I24, Integer_24); + 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_LLLI is new UC (S_LLLI, Long_Long_Long_Integer); + function To_LLLU is new UC (S_LLLU, UST.Long_Long_Long_Unsigned); + 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_U24 is new UC (S_U24, Unsigned_24); + function To_WC is new UC (S_WC, Wide_Character); + function To_WWC is new UC (S_WWC, Wide_Wide_Character); + + ----------------- + -- Block_IO_OK -- + ----------------- + + function Block_IO_OK return Boolean is + begin + return not XDR_Support; + end Block_IO_OK; + + ---------- + -- I_AD -- + ---------- + + function I_AD (Stream : not null access RST) return Fat_Pointer is + pragma Unreferenced (Stream); + begin + raise Program_Error with "Operation not supported on CHERI targets"; + + return Fat_Pointer'(Null_Address, Null_Address); + end I_AD; + + ---------- + -- I_AS -- + ---------- + + function I_AS (Stream : not null access RST) return Thin_Pointer is + pragma Unreferenced (Stream); + begin + raise Program_Error with "Operation not supported on CHERI targets"; + + return Null_Address; + end I_AS; + + --------- + -- I_B -- + --------- + + function I_B (Stream : not null access RST) return Boolean is + T : S_B; + L : SEO; + + begin + if XDR_Support then + return XDR.I_B (Stream); + end if; + + 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 : not null access RST) return Character is + T : S_C; + L : SEO; + + begin + if XDR_Support then + return XDR.I_C (Stream); + end if; + + Ada.Streams.Read (Stream.all, T, L); + + if L < T'Last then + raise Err; + else + return Character'Val (T (1)); + end if; + end I_C; + + --------- + -- I_F -- + --------- + + function I_F (Stream : not null access RST) return Float is + T : S_F; + L : SEO; + + begin + if XDR_Support then + return XDR.I_F (Stream); + end if; + + 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 : not null access RST) return Integer is + T : S_I; + L : SEO; + + begin + if XDR_Support then + return XDR.I_I (Stream); + end if; + + 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_I24 -- + ----------- + + function I_I24 (Stream : not null access RST) return Integer_24 is + T : S_I24; + L : SEO; + + begin + if XDR_Support then + return XDR.I_I24 (Stream); + end if; + + Ada.Streams.Read (Stream.all, T, L); + + if L < T'Last then + raise Err; + else + return To_I24 (T); + end if; + end I_I24; + + ---------- + -- I_LF -- + ---------- + + function I_LF (Stream : not null access RST) return Long_Float is + T : S_LF; + L : SEO; + + begin + if XDR_Support then + return XDR.I_LF (Stream); + end if; + + 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 : not null access RST) return Long_Integer is + T : S_LI; + L : SEO; + + begin + if XDR_Support then + return XDR.I_LI (Stream); + end if; + + 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 : not null access RST) return Long_Long_Float is + T : S_LLF; + L : SEO; + + begin + if XDR_Support then + return XDR.I_LLF (Stream); + end if; + + 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 : not null access RST) return Long_Long_Integer is + T : S_LLI; + L : SEO; + + begin + if XDR_Support then + return XDR.I_LLI (Stream); + end if; + + 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_LLLI -- + ------------ + + function I_LLLI (Stream : not null access RST) return Long_Long_Long_Integer + is + T : S_LLLI; + L : SEO; + + begin + if XDR_Support then + raise Ada.IO_Exceptions.Device_Error; + end if; + + Ada.Streams.Read (Stream.all, T, L); + + if L < T'Last then + raise Err; + else + return To_LLLI (T); + end if; + end I_LLLI; + + ------------ + -- I_LLLU -- + ------------ + + function I_LLLU + (Stream : not null access RST) return UST.Long_Long_Long_Unsigned + is + T : S_LLLU; + L : SEO; + + begin + if XDR_Support then + raise Ada.IO_Exceptions.Device_Error; + end if; + + Ada.Streams.Read (Stream.all, T, L); + + if L < T'Last then + raise Err; + else + return To_LLLU (T); + end if; + end I_LLLU; + + ----------- + -- I_LLU -- + ----------- + + function I_LLU + (Stream : not null access RST) return UST.Long_Long_Unsigned + is + T : S_LLU; + L : SEO; + + begin + if XDR_Support then + return XDR.I_LLU (Stream); + end if; + + 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 : not null access RST) return UST.Long_Unsigned is + T : S_LU; + L : SEO; + + begin + if XDR_Support then + return XDR.I_LU (Stream); + end if; + + 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 : not null access RST) return Short_Float is + T : S_SF; + L : SEO; + + begin + if XDR_Support then + return XDR.I_SF (Stream); + end if; + + 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 : not null access RST) return Short_Integer is + T : S_SI; + L : SEO; + + begin + if XDR_Support then + return XDR.I_SI (Stream); + end if; + + 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 : not null access RST) return Short_Short_Integer is + T : S_SSI; + L : SEO; + + begin + if XDR_Support then + return XDR.I_SSI (Stream); + end if; + + 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 : not null access RST) return UST.Short_Short_Unsigned + is + T : S_SSU; + L : SEO; + + begin + if XDR_Support then + return XDR.I_SSU (Stream); + end if; + + 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 : not null access RST) return UST.Short_Unsigned is + T : S_SU; + L : SEO; + + begin + if XDR_Support then + return XDR.I_SU (Stream); + end if; + + 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 : not null access RST) return UST.Unsigned is + T : S_U; + L : SEO; + + begin + if XDR_Support then + return XDR.I_U (Stream); + end if; + + 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_U24 -- + ----------- + + function I_U24 (Stream : not null access RST) return Unsigned_24 is + T : S_U24; + L : SEO; + + begin + if XDR_Support then + return XDR.I_U24 (Stream); + end if; + + Ada.Streams.Read (Stream.all, T, L); + + if L < T'Last then + raise Err; + else + return To_U24 (T); + end if; + end I_U24; + + ---------- + -- I_WC -- + ---------- + + function I_WC (Stream : not null access RST) return Wide_Character is + T : S_WC; + L : SEO; + + begin + if XDR_Support then + return XDR.I_WC (Stream); + end if; + + Ada.Streams.Read (Stream.all, T, L); + + if L < T'Last then + raise Err; + else + return To_WC (T); + end if; + end I_WC; + + ----------- + -- I_WWC -- + ----------- + + function I_WWC (Stream : not null access RST) return Wide_Wide_Character is + T : S_WWC; + L : SEO; + + begin + if XDR_Support then + return XDR.I_WWC (Stream); + end if; + + Ada.Streams.Read (Stream.all, T, L); + + if L < T'Last then + raise Err; + else + return To_WWC (T); + end if; + end I_WWC; + + ---------- + -- W_AD -- + ---------- + + procedure W_AD (Stream : not null access RST; Item : Fat_Pointer) is + T : constant S_AD := From_AD (Item); + begin + if XDR_Support then + XDR.W_AD (Stream, Item); + return; + end if; + + Ada.Streams.Write (Stream.all, T); + end W_AD; + + ---------- + -- W_AS -- + ---------- + + procedure W_AS (Stream : not null access RST; Item : Thin_Pointer) is + T : constant S_AS := From_AS (Item); + begin + if XDR_Support then + XDR.W_AS (Stream, Item); + return; + end if; + + Ada.Streams.Write (Stream.all, T); + end W_AS; + + --------- + -- W_B -- + --------- + + procedure W_B (Stream : not null access RST; Item : Boolean) is + T : S_B; + begin + if XDR_Support then + XDR.W_B (Stream, Item); + return; + end if; + + T (1) := Boolean'Pos (Item); + Ada.Streams.Write (Stream.all, T); + end W_B; + + --------- + -- W_C -- + --------- + + procedure W_C (Stream : not null access RST; Item : Character) is + T : S_C; + begin + if XDR_Support then + XDR.W_C (Stream, Item); + return; + end if; + + T (1) := Character'Pos (Item); + Ada.Streams.Write (Stream.all, T); + end W_C; + + --------- + -- W_F -- + --------- + + procedure W_F (Stream : not null access RST; Item : Float) is + begin + if XDR_Support then + XDR.W_F (Stream, Item); + return; + end if; + + Ada.Streams.Write (Stream.all, From_F (Item)); + end W_F; + + --------- + -- W_I -- + --------- + + procedure W_I (Stream : not null access RST; Item : Integer) is + begin + if XDR_Support then + XDR.W_I (Stream, Item); + return; + end if; + + Ada.Streams.Write (Stream.all, From_I (Item)); + end W_I; + + ----------- + -- W_I24 -- + ----------- + + procedure W_I24 (Stream : not null access RST; Item : Integer_24) is + begin + if XDR_Support then + XDR.W_I24 (Stream, Item); + return; + end if; + + Ada.Streams.Write (Stream.all, From_I24 (Item)); + end W_I24; + + ---------- + -- W_LF -- + ---------- + + procedure W_LF (Stream : not null access RST; Item : Long_Float) is + begin + if XDR_Support then + XDR.W_LF (Stream, Item); + return; + end if; + + Ada.Streams.Write (Stream.all, From_LF (Item)); + end W_LF; + + ---------- + -- W_LI -- + ---------- + + procedure W_LI (Stream : not null access RST; Item : Long_Integer) is + begin + if XDR_Support then + XDR.W_LI (Stream, Item); + return; + end if; + + Ada.Streams.Write (Stream.all, From_LI (Item)); + end W_LI; + + ----------- + -- W_LLF -- + ----------- + + procedure W_LLF (Stream : not null access RST; Item : Long_Long_Float) is + begin + if XDR_Support then + XDR.W_LLF (Stream, Item); + return; + end if; + + Ada.Streams.Write (Stream.all, From_LLF (Item)); + end W_LLF; + + ----------- + -- W_LLI -- + ----------- + + procedure W_LLI (Stream : not null access RST; Item : Long_Long_Integer) is + begin + if XDR_Support then + XDR.W_LLI (Stream, Item); + return; + end if; + + Ada.Streams.Write (Stream.all, From_LLI (Item)); + end W_LLI; + + ------------ + -- W_LLLI -- + ------------ + + procedure W_LLLI + (Stream : not null access RST; Item : Long_Long_Long_Integer) is + begin + if XDR_Support then + raise Ada.IO_Exceptions.Device_Error; + end if; + + Ada.Streams.Write (Stream.all, From_LLLI (Item)); + end W_LLLI; + + ------------ + -- W_LLLU -- + ------------ + + procedure W_LLLU + (Stream : not null access RST; Item : UST.Long_Long_Long_Unsigned) + is + begin + if XDR_Support then + raise Ada.IO_Exceptions.Device_Error; + end if; + + Ada.Streams.Write (Stream.all, From_LLLU (Item)); + end W_LLLU; + + ----------- + -- W_LLU -- + ----------- + + procedure W_LLU + (Stream : not null access RST; Item : UST.Long_Long_Unsigned) + is + begin + if XDR_Support then + XDR.W_LLU (Stream, Item); + return; + end if; + + Ada.Streams.Write (Stream.all, From_LLU (Item)); + end W_LLU; + + ---------- + -- W_LU -- + ---------- + + procedure W_LU (Stream : not null access RST; Item : UST.Long_Unsigned) is + begin + if XDR_Support then + XDR.W_LU (Stream, Item); + return; + end if; + + Ada.Streams.Write (Stream.all, From_LU (Item)); + end W_LU; + + ---------- + -- W_SF -- + ---------- + + procedure W_SF (Stream : not null access RST; Item : Short_Float) is + begin + if XDR_Support then + XDR.W_SF (Stream, Item); + return; + end if; + + Ada.Streams.Write (Stream.all, From_SF (Item)); + end W_SF; + + ---------- + -- W_SI -- + ---------- + + procedure W_SI (Stream : not null access RST; Item : Short_Integer) is + begin + if XDR_Support then + XDR.W_SI (Stream, Item); + return; + end if; + + Ada.Streams.Write (Stream.all, From_SI (Item)); + end W_SI; + + ----------- + -- W_SSI -- + ----------- + + procedure W_SSI + (Stream : not null access RST; Item : Short_Short_Integer) + is + begin + if XDR_Support then + XDR.W_SSI (Stream, Item); + return; + end if; + + Ada.Streams.Write (Stream.all, From_SSI (Item)); + end W_SSI; + + ----------- + -- W_SSU -- + ----------- + + procedure W_SSU + (Stream : not null access RST; Item : UST.Short_Short_Unsigned) + is + begin + if XDR_Support then + XDR.W_SSU (Stream, Item); + return; + end if; + + Ada.Streams.Write (Stream.all, From_SSU (Item)); + end W_SSU; + + ---------- + -- W_SU -- + ---------- + + procedure W_SU (Stream : not null access RST; Item : UST.Short_Unsigned) is + begin + if XDR_Support then + XDR.W_SU (Stream, Item); + return; + end if; + + Ada.Streams.Write (Stream.all, From_SU (Item)); + end W_SU; + + --------- + -- W_U -- + --------- + + procedure W_U (Stream : not null access RST; Item : UST.Unsigned) is + begin + if XDR_Support then + XDR.W_U (Stream, Item); + return; + end if; + + Ada.Streams.Write (Stream.all, From_U (Item)); + end W_U; + + ----------- + -- W_U24 -- + ----------- + + procedure W_U24 (Stream : not null access RST; Item : Unsigned_24) is + begin + if XDR_Support then + XDR.W_U24 (Stream, Item); + return; + end if; + + Ada.Streams.Write (Stream.all, From_U24 (Item)); + end W_U24; + + ---------- + -- W_WC -- + ---------- + + procedure W_WC (Stream : not null access RST; Item : Wide_Character) is + begin + if XDR_Support then + XDR.W_WC (Stream, Item); + return; + end if; + + Ada.Streams.Write (Stream.all, From_WC (Item)); + end W_WC; + + ----------- + -- W_WWC -- + ----------- + + procedure W_WWC + (Stream : not null access RST; Item : Wide_Wide_Character) + is + begin + if XDR_Support then + XDR.W_WWC (Stream, Item); + return; + end if; + + Ada.Streams.Write (Stream.all, From_WWC (Item)); + end W_WWC; + +end System.Stream_Attributes; -- 2.42.0