PowerAda 78

From OC Systems Wiki!
Jump to: navigation, search

(78) The contents of the visible part of package Interfaces and its language-defined descendants.

See B.2(1).

Interfaces

PACKAGE Interfaces IS
  PRAGMA Pure(Interfaces);
  TYPE Integer_8 IS RANGE -2 ** 7 .. 2 ** 7 - 1;
         FOR Integer_8'Size USE 8;
  TYPE Integer_16 IS RANGE -2 ** 15 .. 2 ** 15 - 1;
         FOR Integer_16'Size USE 16;
  TYPE Integer_32 IS RANGE -2 ** 31 .. 2 ** 31 - 1;
         FOR Integer_32'Size USE 32;
  TYPE Unsigned_8 IS MOD 2**8;
         FOR Unsigned_8'Size USE 8;
  TYPE Unsigned_16 IS MOD 2**16;
         FOR Unsigned_16'Size USE 16;
  TYPE Unsigned_32 IS MOD 2**32;
         FOR Unsigned_32'Size USE 32;
  FUNCTION Shift_Left
 (Value : Unsigned_8; Amount : Natural) RETURN Unsigned_8;
  FUNCTION Shift_Right
 (Value : Unsigned_8; Amount : Natural) RETURN Unsigned_8;
  FUNCTION Shift_Right_Arithmetic
 (Value : Unsigned_8; Amount : Natural) RETURN Unsigned_8;
  FUNCTION Rotate_Left
 (Value : Unsigned_8; Amount : Natural) RETURN Unsigned_8;
  FUNCTION Rotate_Right
 (Value : Unsigned_8; Amount : Natural) RETURN Unsigned_8;
  FUNCTION Shift_Left
 (Value : Unsigned_16; Amount : Natural) RETURN Unsigned_16;
  FUNCTION Shift_Right
 (Value : Unsigned_16; Amount : Natural) RETURN Unsigned_16;
  FUNCTION Shift_Right_Arithmetic
 (Value : Unsigned_16; Amount : Natural) RETURN Unsigned_16;
  FUNCTION Rotate_Left
 (Value : Unsigned_16; Amount : Natural) RETURN Unsigned_16;
  FUNCTION Rotate_Right
 (Value : Unsigned_16; Amount : Natural) RETURN Unsigned_16;
  FUNCTION Shift_Left
 (Value : Unsigned_32; Amount : Natural) RETURN Unsigned_32;
  FUNCTION Shift_Right
 (Value : Unsigned_32; Amount : Natural) RETURN Unsigned_32;
  FUNCTION Shift_Right_Arithmetic
 (Value : Unsigned_32; Amount : Natural) RETURN Unsigned_32;
  FUNCTION Rotate_Left
 (Value : Unsigned_32; Amount : Natural) RETURN Unsigned_32;
  FUNCTION Rotate_Right
 (Value : Unsigned_32; Amount : Natural) RETURN Unsigned_32;
  TYPE IEEE_Float_32 IS NEW Float;
  TYPE IEEE_Float_64 IS NEW Long_Float;
PRIVATE
END Interfaces;

Interfaces.C

PACKAGE Interfaces.C IS
  PRAGMA Pure(C);
  -- Declarations based on C's <limits.h>
  CHAR_BIT  : CONSTANT := 8;
  SCHAR_MIN : CONSTANT := -128;
  SCHAR_MAX : CONSTANT := 127;
  UCHAR_MAX : CONSTANT := 255;
  -- Signed and Unsigned Integers
  TYPE intIS RANGE -(2**31) .. (2**31)-1;
  FOR int'Size USE 32;
  TYPE short IS RANGE -(2**15) .. (2**15)-1;
  FOR short'Size USE 16;
  TYPE long  IS RANGE -(2**31) .. (2**31)-1;
  FOR long'Size USE 32;
  TYPE signed_char IS RANGE SCHAR_MIN .. SCHAR_MAX;
  FOR signed_char'Size USE CHAR_BIT;
  TYPE unsigned IS MOD 2 ** 32;
  FOR unsigned'Size USE 32;
  TYPE unsigned_short IS MOD 2 ** 16;
  FOR unsigned_short'Size USE 16;
  TYPE unsigned_long  IS MOD 2 ** 32;
  FOR unsigned_long'Size USE 32;
  TYPE unsigned_char IS MOD (UCHAR_MAX+1);
  FOR unsigned_char'Size USE CHAR_BIT;
  SUBTYPE plain_char IS unsigned_char;
  TYPE ptrdiff_t IS RANGE -(2**31) .. (2**31)-1;
  FOR ptrdiff_t'Size USE 32;
  TYPE size_t IS MOD 2 ** 32;
  FOR size_t'Size USE 32;
  -- Floating Point
  TYPE C_float  IS DIGITS Float'Digits;
  FOR C_float'Size USE 32;
  TYPE doubleIS DIGITS Long_Float'Digits;
  FOR double'Size USE 64;
  TYPE long_double IS DIGITS Long_Float'Digits;
  FOR long_double'Size USE 64;
  -- Characters and Strings
  TYPE char IS NEW Character;
  FOR char'Size USE CHAR_BIT;
  nul : CONSTANT char := char'First;
  FUNCTION To_C(Item : IN Character) RETURN char;
  FUNCTION To_Ada (Item : IN char) RETURN Character;
  TYPE char_array IS ARRAY (size_t RANGE <>) OF ALIASED char;
  PRAGMA Pack(char_array);
  FOR char_array'Component_Size USE CHAR_BIT;
  FUNCTION Is_Nul_Terminated (Item : IN char_array) 
        RETURN Boolean;
  FUNCTION To_C(Item      : IN String;
                    Append_Nul : IN Boolean := True)
        RETURN char_array;
  FUNCTION To_Ada (Item     : IN char_array;
                       Trim_Nul : IN Boolean := True)
        RETURN String;
  PROCEDURE To_C 
  (Item : IN String;
        Target  : OUT char_array;
        Count: OUT size_t;
        Append_Nul : IN Boolean := True);
  PROCEDURE To_Ada 
  (Item  : IN char_array;
        Target: OUT String;
        Count : OUT Natural;
        Trim_Nul : IN Boolean := True);
  -- Wide Character and Wide String
  TYPE wchar_t IS NEW Wide_Character;
  wide_nul : CONSTANT wchar_t := wchar_t'First;
  FUNCTION To_C(Item : IN Wide_Character) RETURN wchar_t;
  FUNCTION To_Ada (Item : IN wchar_t ) RETURN Wide_Character;
  TYPE wchar_array IS ARRAY (size_t RANGE <>) 
        OF ALIASED wchar_t;
  PRAGMA Pack(wchar_array);
  FUNCTION Is_Nul_Terminated (Item : IN wchar_array) 
        RETURN Boolean;
  FUNCTION To_C(Item : IN Wide_String;
        Append_Nul : IN Boolean := True)
        RETURN wchar_array;
  FUNCTION To_Ada (Item  : IN wchar_array;
        Trim_Nul : IN Boolean := True)
        RETURN Wide_String;
  PROCEDURE To_C (Item : IN  Wide_String;
        Target  : OUT wchar_array;
        Count: OUT size_t;
        Append_Nul : IN  Boolean := True);
  PROCEDURE To_Ada (Item  : IN  wchar_array;
        Target: OUT Wide_String;
        Count : OUT Natural;
        Trim_Nul : IN  Boolean := True);
  Terminator_Error : exception;
END Interfaces.C;

Interfaces.C.Pointers

GENERIC
  TYPE Index IS (<>);
  TYPE Element IS PRIVATE;
  TYPE Element_Array IS ARRAY (Index RANGE <>) 
        OF ALIASED Element;
  Default_Terminator : Element;
PACKAGE Interfaces.C.Pointers IS
  PRAGMA Preelaborate(Pointers);
  TYPE Pointer IS ACCESS ALL Element;
  FUNCTION Value(Ref  : IN Pointer;
        Terminator : IN Element := Default_Terminator)
        RETURN Element_Array;
  FUNCTION Value(Ref : IN Pointer;
        Length : IN ptrdiff_t)
        RETURN Element_Array;
  Pointer_Error : EXCEPTION;
  -- C-style Pointer arithmetic
  FUNCTION "+" (Left : IN Pointer;Right : IN ptrdiff_t) 
        RETURN Pointer;
  FUNCTION "+" (Left : IN ptrdiff_t; Right : IN Pointer)
        RETURN Pointer;
  FUNCTION "-" (Left : IN Pointer;Right : IN ptrdiff_t) 
        RETURN Pointer;
  FUNCTION "-" (Left : IN Pointer;Right : IN Pointer)
        RETURN ptrdiff_t;
  PROCEDURE Increment (Ref : IN OUT Pointer);
  PROCEDURE Decrement (Ref : IN OUT Pointer);
  PRAGMA Convention (Intrinsic, "+");
  PRAGMA Convention (Intrinsic, "-");
  PRAGMA Convention (Intrinsic, Increment);
  PRAGMA Convention (Intrinsic, Decrement);
  FUNCTION Virtual_Length (Ref  : IN Pointer;
        Terminator : IN Element := Default_Terminator)
        RETURN ptrdiff_t;
  PROCEDURE Copy_Terminated_Array (Source  : IN Pointer;
        Target  : IN Pointer;
        Limit: IN ptrdiff_t := ptrdiff_t'Last;
        Terminator : IN Element := Default_Terminator);
  PROCEDURE Copy_Array (Source  : IN Pointer;
        Target  : IN Pointer;
        Length  : IN ptrdiff_t);
END Interfaces.C.Pointers;

Interfaces.C.Strings

WITH
  System.Storage_Elements;
PACKAGE Interfaces.C.Strings IS
  PRAGMA Preelaborate(Strings);
  TYPE char_array_access IS ACCESS ALL char_array;
  TYPE chars_ptr IS PRIVATE;
  TYPE chars_ptr_array IS ARRAY (size_t RANGE <>) 
        OF chars_ptr;
  Null_Ptr : CONSTANT chars_ptr;
  FUNCTION To_Chars_Ptr (Item: IN char_array_access;
        Nul_Check : IN Boolean := False)
        RETURN chars_ptr;
  FUNCTION New_Char_Array (Chars: IN char_array) 
        RETURN chars_ptr;
  FUNCTION New_String (Str : IN String) RETURN chars_ptr;
  PROCEDURE Free (Item : IN OUT chars_ptr);
  Dereference_Error : EXCEPTION;
  FUNCTION Value (Item : IN chars_ptr) RETURN char_array;
  FUNCTION Value (Item : IN chars_ptr; Length : IN size_t)
        RETURN char_array;
  FUNCTION Value (Item : IN chars_ptr) RETURN String;
  FUNCTION Value (Item : IN chars_ptr; Length : IN size_t)
        RETURN String;
  FUNCTION Strlen (Item : IN chars_ptr) RETURN size_t;
  PROCEDURE Update (Item: IN chars_ptr;
        Offset : IN size_t;
        Chars  : IN char_array;
        Check  : IN Boolean := True);
  PROCEDURE Update (Item: IN chars_ptr;
        Offset : IN size_t;
        Str : IN String;
        Check  : IN Boolean := True);
  Update_Error : EXCEPTION;
END Interfaces.C.Strings;