Skip to content

Instantly share code, notes, and snippets.

@ytomino

ytomino/c-apisetcconv.ads

Last active June 11, 2016 10:03
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save ytomino/5ba9637ac95cd1abe77d to your computer and use it in GitHub Desktop.
Save ytomino/5ba9637ac95cd1abe77d to your computer and use it in GitHub Desktop.
Download ZIP
x86_64-w64-mingw32
Raw
c-apisetcconv.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.apisetcconv is
pragma Preelaborate;
-- CMAPI (attribute)
-- CREDUIAPI (attribute)
-- WINABLEAPI (attribute)
-- WINADVAPI (attribute)
-- WINBASEAPI (attribute)
-- WINCFGMGR32API (attribute)
-- WINDEVQUERYAPI (attribute)
-- WINPATHCCHAPI (attribute)
-- WINSWDEVICEAPI (attribute)
-- WINUSERAPI (attribute)
-- ZAWPROXYAPI (attribute)
-- _APISETCCONV_ (empty)
end C.apisetcconv;
Raw
c-basetsd.adb
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package body C.basetsd is
function HandleToULong (h : void_const_ptr) return unsigned_long is
begin
return unsigned_long (ULONG_PTR'(Cast (h)));
end HandleToULong;
function HandleToLong (h : void_const_ptr) return signed_long is
begin
return signed_long (LONG_PTR'(Cast (h)));
end HandleToLong;
function ULongToHandle (h : unsigned_long) return void_ptr is
begin
return void_ptr'(Cast (UINT_PTR (h)));
end ULongToHandle;
function LongToHandle (h : signed_long) return void_ptr is
begin
return void_ptr'(Cast (INT_PTR (h)));
end LongToHandle;
function PtrToUlong (p : void_const_ptr) return unsigned_long is
begin
return unsigned_long (ULONG_PTR'(Cast (p)));
end PtrToUlong;
function PtrToUint (p : void_const_ptr) return unsigned_int is
begin
return unsigned_int (UINT_PTR'(Cast (p)));
end PtrToUint;
function PtrToUshort (p : void_const_ptr) return unsigned_short is
begin
return unsigned_short (unsigned_long (ULONG_PTR'(Cast (p))));
end PtrToUshort;
function PtrToLong (p : void_const_ptr) return signed_long is
begin
return signed_long (LONG_PTR'(Cast (p)));
end PtrToLong;
function PtrToInt (p : void_const_ptr) return signed_int is
begin
return signed_int (INT_PTR'(Cast (p)));
end PtrToInt;
function PtrToShort (p : void_const_ptr) return signed_short is
begin
return signed_short (signed_long (LONG_PTR'(Cast (p))));
end PtrToShort;
function IntToPtr (i : signed_int) return void_ptr is
begin
return void_ptr'(Cast (INT_PTR (i)));
end IntToPtr;
function UIntToPtr (ui : unsigned_int) return void_ptr is
begin
return void_ptr'(Cast (UINT_PTR (ui)));
end UIntToPtr;
function LongToPtr (l : signed_long) return void_ptr is
begin
return void_ptr'(Cast (LONG_PTR (l)));
end LongToPtr;
function ULongToPtr (ul : unsigned_long) return void_ptr is
begin
return void_ptr'(Cast (ULONG_PTR (ul)));
end ULongToPtr;
function Ptr32ToPtr (p : void_const_ptr) return void_ptr is
begin
return void_ptr'(Cast (ULONG_PTR'(Cast (p))));
end Ptr32ToPtr;
function Handle32ToHandle (h : void_const_ptr) return void_ptr is
begin
return void_ptr'(Cast (ULONG_PTR'(Cast (h))));
end Handle32ToHandle;
function PtrToPtr32 (p : void_const_ptr) return void_ptr is
begin
return void_ptr'(Cast (ULONG_PTR'(Cast (p))));
end PtrToPtr32;
end C.basetsd;
Raw
c-basetsd.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
with Ada.Unchecked_Conversion;
package C.basetsd is
pragma Preelaborate;
function Cast is new Ada.Unchecked_Conversion (signed_long_long,
void_ptr);
function Cast is new Ada.Unchecked_Conversion (unsigned_long_long,
void_ptr);
function Cast is new Ada.Unchecked_Conversion (void_const_ptr,
signed_long_long);
function Cast is new Ada.Unchecked_Conversion (void_const_ptr,
unsigned_long_long);
subtype POINTER_64_INT is unsigned_long_long;
subtype INT8 is signed_char;
subtype PINT8 is signed_char_ptr;
subtype INT16 is signed_short;
subtype PINT16 is signed_short_ptr;
subtype INT32 is signed_int;
subtype PINT32 is signed_int_ptr;
subtype INT64 is signed_long_long;
subtype PINT64 is signed_long_long_ptr;
subtype UINT8 is unsigned_char;
subtype PUINT8 is unsigned_char_ptr;
subtype UINT16 is unsigned_short;
subtype PUINT16 is unsigned_short_ptr;
subtype UINT32 is unsigned_int;
subtype PUINT32 is unsigned_int_ptr;
subtype UINT64 is unsigned_long_long;
subtype PUINT64 is unsigned_long_long_ptr;
subtype LONG32 is signed_int;
subtype PLONG32 is signed_int_ptr;
subtype ULONG32 is unsigned_int;
subtype PULONG32 is unsigned_int_ptr;
subtype DWORD32 is unsigned_int;
subtype PDWORD32 is unsigned_int_ptr;
subtype INT_PTR is signed_long_long;
subtype PINT_PTR is signed_long_long_ptr;
subtype UINT_PTR is unsigned_long_long;
subtype UINT_PTR_array is unsigned_long_long_array;
subtype UINT_PTR_ptr is unsigned_long_long_ptr;
subtype PUINT_PTR is unsigned_long_long_ptr;
subtype LONG_PTR is signed_long_long;
subtype LONG_PTR_ptr is signed_long_long_ptr;
subtype PLONG_PTR is signed_long_long_ptr;
subtype ULONG_PTR is unsigned_long_long;
subtype ULONG_PTR_ptr is unsigned_long_long_ptr;
subtype ULONG_PTR_array is unsigned_long_long_array;
subtype ULONG_PTR_const_ptr is unsigned_long_long_const_ptr;
subtype PULONG_PTR is unsigned_long_long_ptr;
subtype SHANDLE_PTR is signed_long_long;
subtype HANDLE_PTR is unsigned_long_long;
subtype UHALF_PTR is unsigned_int;
subtype PUHALF_PTR is unsigned_int_ptr;
subtype HALF_PTR is signed_int;
subtype PHALF_PTR is signed_int_ptr;
function HandleToULong (h : void_const_ptr) return unsigned_long;
pragma Convention (C, HandleToULong);
pragma Inline (HandleToULong);
function HandleToLong (h : void_const_ptr) return signed_long;
pragma Convention (C, HandleToLong);
pragma Inline (HandleToLong);
function ULongToHandle (h : unsigned_long) return void_ptr;
pragma Convention (C, ULongToHandle);
pragma Inline (ULongToHandle);
function LongToHandle (h : signed_long) return void_ptr;
pragma Convention (C, LongToHandle);
pragma Inline (LongToHandle);
function PtrToUlong (p : void_const_ptr) return unsigned_long;
pragma Convention (C, PtrToUlong);
pragma Inline (PtrToUlong);
function PtrToUint (p : void_const_ptr) return unsigned_int;
pragma Convention (C, PtrToUint);
pragma Inline (PtrToUint);
function PtrToUshort (p : void_const_ptr) return unsigned_short;
pragma Convention (C, PtrToUshort);
pragma Inline (PtrToUshort);
function PtrToLong (p : void_const_ptr) return signed_long;
pragma Convention (C, PtrToLong);
pragma Inline (PtrToLong);
function PtrToInt (p : void_const_ptr) return signed_int;
pragma Convention (C, PtrToInt);
pragma Inline (PtrToInt);
function PtrToShort (p : void_const_ptr) return signed_short;
pragma Convention (C, PtrToShort);
pragma Inline (PtrToShort);
function IntToPtr (i : signed_int) return void_ptr;
pragma Convention (C, IntToPtr);
pragma Inline (IntToPtr);
function UIntToPtr (ui : unsigned_int) return void_ptr;
pragma Convention (C, UIntToPtr);
pragma Inline (UIntToPtr);
function LongToPtr (l : signed_long) return void_ptr;
pragma Convention (C, LongToPtr);
pragma Inline (LongToPtr);
function ULongToPtr (ul : unsigned_long) return void_ptr;
pragma Convention (C, ULongToPtr);
pragma Inline (ULongToPtr);
function Ptr32ToPtr (p : void_const_ptr) return void_ptr;
pragma Convention (C, Ptr32ToPtr);
pragma Inline (Ptr32ToPtr);
function Handle32ToHandle (h : void_const_ptr) return void_ptr;
pragma Convention (C, Handle32ToHandle);
pragma Inline (Handle32ToHandle);
function PtrToPtr32 (p : void_const_ptr) return void_ptr;
pragma Convention (C, PtrToPtr32);
pragma Inline (PtrToPtr32);
subtype SIZE_T is ULONG_PTR;
subtype SIZE_T_ptr is ULONG_PTR_ptr;
subtype SIZE_T_array is ULONG_PTR_array;
subtype PSIZE_T is ULONG_PTR_ptr;
subtype SSIZE_T is LONG_PTR;
subtype PSSIZE_T is LONG_PTR_ptr;
subtype DWORD_PTR is ULONG_PTR;
subtype PDWORD_PTR is ULONG_PTR_ptr;
subtype LONG64 is signed_long_long;
subtype LONG64_const_ptr is signed_long_long_const_ptr;
subtype LONG64_ptr is signed_long_long_ptr;
subtype LONG64_volatile is signed_long_long_volatile;
subtype LONG64_volatile_ptr is signed_long_long_volatile_ptr;
subtype PLONG64 is signed_long_long_ptr;
subtype ULONG64 is unsigned_long_long;
subtype PULONG64 is unsigned_long_long_ptr;
subtype PULONG64_array is unsigned_long_long_ptr_array;
subtype DWORD64 is unsigned_long_long;
subtype DWORD64_const_ptr is unsigned_long_long_const_ptr;
subtype DWORD64_ptr is unsigned_long_long_ptr;
subtype DWORD64_array is unsigned_long_long_array;
subtype PDWORD64 is unsigned_long_long_ptr;
subtype KAFFINITY is ULONG_PTR;
subtype KAFFINITY_ptr is ULONG_PTR_ptr;
subtype PKAFFINITY is KAFFINITY_ptr;
ADDRESS_TAG_BIT : constant := 4398046511104;
-- FIRMWARE_PTR (empty)
-- Handle64ToHandle (function macro)
-- HandleToHandle32 (function macro)
-- HandleToHandle64 (function macro)
-- HandleToUlong (function macro)
MAXHALF_PTR : constant := 2147483647;
MAXINT_PTR : constant := -1;
MAXLONG_PTR : constant := -1;
MAXUHALF_PTR : constant := 4294967295;
MAXUINT_PTR : constant := -1;
MAXULONG_PTR : constant := -1;
MINHALF_PTR : constant := -2147483648;
MININT_PTR : constant := 0;
MINLONG_PTR : constant := 0;
-- POINTER_32 (empty)
-- POINTER_64 (empty)
-- POINTER_SIGNED (empty)
-- POINTER_UNSIGNED (empty)
-- Ptr64ToPtr (function macro)
-- PtrToPtr64 (function macro)
-- SPOINTER_32 (empty)
-- UPOINTER_32 (empty)
-- UintToPtr (function macro)
-- UlongToHandle (function macro)
-- UlongToPtr (function macro)
-- _BASETSD_H_ (empty)
subtype int3264 is signed_long_long;
end C.basetsd;
Raw
c-bcrypt.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
with C.windef;
with C.winnt;
with C.winternl;
package C.bcrypt is
pragma Preelaborate;
type struct_BCRYPT_KEY_LENGTHS_STRUCT;
type struct_BCRYPT_KEY_LENGTHS_STRUCT is record
dwMinLength : aliased windef.ULONG;
dwMaxLength : aliased windef.ULONG;
dwIncrement : aliased windef.ULONG;
end record;
pragma Convention (C_Pass_By_Copy, struct_BCRYPT_KEY_LENGTHS_STRUCT);
subtype BCRYPT_KEY_LENGTHS_STRUCT is struct_BCRYPT_KEY_LENGTHS_STRUCT;
subtype BCRYPT_AUTH_TAG_LENGTHS_STRUCT is
struct_BCRYPT_KEY_LENGTHS_STRUCT;
type struct_BCRYPT_OID;
type struct_BCRYPT_OID is record
cbOID : aliased windef.ULONG;
pbOID : aliased windef.PUCHAR;
end record;
pragma Convention (C_Pass_By_Copy, struct_BCRYPT_OID);
type struct_BCRYPT_OID_ptr is access all struct_BCRYPT_OID;
for struct_BCRYPT_OID_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_BCRYPT_OID_ptr);
pragma Convention (C, struct_BCRYPT_OID_ptr);
subtype BCRYPT_OID is struct_BCRYPT_OID;
subtype BCRYPT_OID_ptr is struct_BCRYPT_OID_ptr;
type struct_BCRYPT_OID_LIST;
type struct_BCRYPT_OID_LIST is record
dwOIDCount : aliased windef.ULONG;
pOIDs : aliased BCRYPT_OID_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_BCRYPT_OID_LIST);
subtype BCRYPT_OID_LIST is struct_BCRYPT_OID_LIST;
type struct_BCRYPT_PKCS1_PADDING_INFO;
type struct_BCRYPT_PKCS1_PADDING_INFO is record
pszAlgId : aliased winnt.LPCWSTR;
end record;
pragma Convention (C_Pass_By_Copy, struct_BCRYPT_PKCS1_PADDING_INFO);
subtype BCRYPT_PKCS1_PADDING_INFO is struct_BCRYPT_PKCS1_PADDING_INFO;
type struct_BCRYPT_PSS_PADDING_INFO;
type struct_BCRYPT_PSS_PADDING_INFO is record
pszAlgId : aliased winnt.LPCWSTR;
cbSalt : aliased windef.ULONG;
end record;
pragma Convention (C_Pass_By_Copy, struct_BCRYPT_PSS_PADDING_INFO);
subtype BCRYPT_PSS_PADDING_INFO is struct_BCRYPT_PSS_PADDING_INFO;
type struct_BCRYPT_OAEP_PADDING_INFO;
type struct_BCRYPT_OAEP_PADDING_INFO is record
pszAlgId : aliased winnt.LPCWSTR;
pbLabel : aliased windef.PUCHAR;
cbLabel : aliased windef.ULONG;
end record;
pragma Convention (C_Pass_By_Copy, struct_BCRYPT_OAEP_PADDING_INFO);
subtype BCRYPT_OAEP_PADDING_INFO is struct_BCRYPT_OAEP_PADDING_INFO;
type struct_BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO;
type struct_BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO is record
cbSize : aliased windef.ULONG;
dwInfoVersion : aliased windef.ULONG;
pbNonce : aliased windef.PUCHAR;
cbNonce : aliased windef.ULONG;
pbAuthData : aliased windef.PUCHAR;
cbAuthData : aliased windef.ULONG;
pbTag : aliased windef.PUCHAR;
cbTag : aliased windef.ULONG;
pbMacContext : aliased windef.PUCHAR;
cbMacContext : aliased windef.ULONG;
cbAAD : aliased windef.ULONG;
cbData : aliased winnt.ULONGLONG;
dwFlags : aliased windef.ULONG;
end record;
pragma Convention (C_Pass_By_Copy,
struct_BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO);
type struct_BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO_ptr is
access all struct_BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO;
for struct_BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (
struct_BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO_ptr);
pragma Convention (C, struct_BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO_ptr);
subtype BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO is
struct_BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO;
subtype PBCRYPT_AUTHENTICATED_CIPHER_MODE_INFO is
struct_BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO_ptr;
type struct_BCryptBuffer;
type struct_BCryptBuffer is record
cbBuffer : aliased windef.ULONG;
BufferType : aliased windef.ULONG;
pvBuffer : aliased winnt.PVOID;
end record;
pragma Convention (C_Pass_By_Copy, struct_BCryptBuffer);
type struct_BCryptBuffer_ptr is access all struct_BCryptBuffer;
for struct_BCryptBuffer_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_BCryptBuffer_ptr);
pragma Convention (C, struct_BCryptBuffer_ptr);
subtype BCryptBuffer is struct_BCryptBuffer;
subtype PBCryptBuffer is struct_BCryptBuffer_ptr;
type struct_BCryptBufferDesc;
type struct_BCryptBufferDesc is record
ulVersion : aliased windef.ULONG;
cBuffers : aliased windef.ULONG;
pBuffers : aliased PBCryptBuffer;
end record;
pragma Convention (C_Pass_By_Copy, struct_BCryptBufferDesc);
type struct_BCryptBufferDesc_ptr is access all struct_BCryptBufferDesc;
for struct_BCryptBufferDesc_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_BCryptBufferDesc_ptr);
pragma Convention (C, struct_BCryptBufferDesc_ptr);
subtype BCryptBufferDesc is struct_BCryptBufferDesc;
subtype BCryptBufferDesc_ptr is struct_BCryptBufferDesc_ptr;
subtype PBCryptBufferDesc is struct_BCryptBufferDesc_ptr;
subtype BCRYPT_HANDLE is winnt.PVOID;
subtype BCRYPT_ALG_HANDLE is winnt.PVOID;
subtype BCRYPT_ALG_HANDLE_ptr is winnt.PVOID_ptr;
subtype BCRYPT_KEY_HANDLE is winnt.PVOID;
subtype BCRYPT_KEY_HANDLE_ptr is winnt.PVOID_ptr;
subtype BCRYPT_HASH_HANDLE is winnt.PVOID;
subtype BCRYPT_HASH_HANDLE_ptr is winnt.PVOID_ptr;
subtype BCRYPT_SECRET_HANDLE is winnt.PVOID;
subtype BCRYPT_SECRET_HANDLE_ptr is winnt.PVOID_ptr;
type struct_BCRYPT_KEY_BLOB;
type struct_BCRYPT_KEY_BLOB is record
Magic : aliased windef.ULONG;
end record;
pragma Convention (C_Pass_By_Copy, struct_BCRYPT_KEY_BLOB);
subtype BCRYPT_KEY_BLOB is struct_BCRYPT_KEY_BLOB;
type struct_BCRYPT_RSAKEY_BLOB;
type struct_BCRYPT_RSAKEY_BLOB is record
Magic : aliased windef.ULONG;
BitLength : aliased windef.ULONG;
cbPublicExp : aliased windef.ULONG;
cbModulus : aliased windef.ULONG;
cbPrime1 : aliased windef.ULONG;
cbPrime2 : aliased windef.ULONG;
end record;
pragma Convention (C_Pass_By_Copy, struct_BCRYPT_RSAKEY_BLOB);
subtype BCRYPT_RSAKEY_BLOB is struct_BCRYPT_RSAKEY_BLOB;
type struct_BCRYPT_ECCKEY_BLOB;
type struct_BCRYPT_ECCKEY_BLOB is record
dwMagic : aliased windef.ULONG;
cbKey : aliased windef.ULONG;
end record;
pragma Convention (C_Pass_By_Copy, struct_BCRYPT_ECCKEY_BLOB);
type struct_BCRYPT_ECCKEY_BLOB_ptr is
access all struct_BCRYPT_ECCKEY_BLOB;
for struct_BCRYPT_ECCKEY_BLOB_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_BCRYPT_ECCKEY_BLOB_ptr);
pragma Convention (C, struct_BCRYPT_ECCKEY_BLOB_ptr);
subtype BCRYPT_ECCKEY_BLOB is struct_BCRYPT_ECCKEY_BLOB;
subtype PBCRYPT_ECCKEY_BLOB is struct_BCRYPT_ECCKEY_BLOB_ptr;
type struct_BCRYPT_DH_KEY_BLOB;
type struct_BCRYPT_DH_KEY_BLOB is record
dwMagic : aliased windef.ULONG;
cbKey : aliased windef.ULONG;
end record;
pragma Convention (C_Pass_By_Copy, struct_BCRYPT_DH_KEY_BLOB);
type struct_BCRYPT_DH_KEY_BLOB_ptr is
access all struct_BCRYPT_DH_KEY_BLOB;
for struct_BCRYPT_DH_KEY_BLOB_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_BCRYPT_DH_KEY_BLOB_ptr);
pragma Convention (C, struct_BCRYPT_DH_KEY_BLOB_ptr);
subtype BCRYPT_DH_KEY_BLOB is struct_BCRYPT_DH_KEY_BLOB;
subtype PBCRYPT_DH_KEY_BLOB is struct_BCRYPT_DH_KEY_BLOB_ptr;
type struct_BCRYPT_DH_PARAMETER_HEADER;
type struct_BCRYPT_DH_PARAMETER_HEADER is record
cbLength : aliased windef.ULONG;
dwMagic : aliased windef.ULONG;
cbKeyLength : aliased windef.ULONG;
end record;
pragma Convention (C_Pass_By_Copy, struct_BCRYPT_DH_PARAMETER_HEADER);
subtype BCRYPT_DH_PARAMETER_HEADER is struct_BCRYPT_DH_PARAMETER_HEADER;
type struct_BCRYPT_DSA_KEY_BLOB;
type struct_BCRYPT_DSA_KEY_BLOB is record
dwMagic : aliased windef.ULONG;
cbKey : aliased windef.ULONG;
Count : aliased windef.UCHAR_array (0 .. 3);
Seed : aliased windef.UCHAR_array (0 .. 19);
q : aliased windef.UCHAR_array (0 .. 19);
end record;
pragma Convention (C_Pass_By_Copy, struct_BCRYPT_DSA_KEY_BLOB);
type struct_BCRYPT_DSA_KEY_BLOB_ptr is
access all struct_BCRYPT_DSA_KEY_BLOB;
for struct_BCRYPT_DSA_KEY_BLOB_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_BCRYPT_DSA_KEY_BLOB_ptr);
pragma Convention (C, struct_BCRYPT_DSA_KEY_BLOB_ptr);
subtype BCRYPT_DSA_KEY_BLOB is struct_BCRYPT_DSA_KEY_BLOB;
subtype PBCRYPT_DSA_KEY_BLOB is struct_BCRYPT_DSA_KEY_BLOB_ptr;
type enum_ad2a5d56 is (DSA_HASH_ALGORITHM_SHA1, DSA_HASH_ALGORITHM_SHA256,
DSA_HASH_ALGORITHM_SHA512);
for enum_ad2a5d56 use (DSA_HASH_ALGORITHM_SHA1 => 0,
DSA_HASH_ALGORITHM_SHA256 => 1, DSA_HASH_ALGORITHM_SHA512 => 2);
pragma Convention (C, enum_ad2a5d56);
subtype HASHALGORITHM_ENUM is enum_ad2a5d56;
type enum_4915a235 is (DSA_FIPS186_2, DSA_FIPS186_3);
for enum_4915a235 use (DSA_FIPS186_2 => 0, DSA_FIPS186_3 => 1);
pragma Convention (C, enum_4915a235);
subtype DSAFIPSVERSION_ENUM is enum_4915a235;
type struct_BCRYPT_DSA_KEY_BLOB_V2;
type struct_BCRYPT_DSA_KEY_BLOB_V2 is record
dwMagic : aliased windef.ULONG;
cbKey : aliased windef.ULONG;
hashAlgorithm : aliased HASHALGORITHM_ENUM;
standardVersion : aliased DSAFIPSVERSION_ENUM;
cbSeedLength : aliased windef.ULONG;
cbGroupSize : aliased windef.ULONG;
Count : aliased windef.UCHAR_array (0 .. 3);
end record;
pragma Convention (C_Pass_By_Copy, struct_BCRYPT_DSA_KEY_BLOB_V2);
type struct_BCRYPT_DSA_KEY_BLOB_V2_ptr is
access all struct_BCRYPT_DSA_KEY_BLOB_V2;
for struct_BCRYPT_DSA_KEY_BLOB_V2_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_BCRYPT_DSA_KEY_BLOB_V2_ptr);
pragma Convention (C, struct_BCRYPT_DSA_KEY_BLOB_V2_ptr);
subtype BCRYPT_DSA_KEY_BLOB_V2 is struct_BCRYPT_DSA_KEY_BLOB_V2;
subtype PBCRYPT_DSA_KEY_BLOB_V2 is struct_BCRYPT_DSA_KEY_BLOB_V2_ptr;
type struct_BCRYPT_KEY_DATA_BLOB_HEADER;
type struct_BCRYPT_KEY_DATA_BLOB_HEADER is record
dwMagic : aliased windef.ULONG;
dwVersion : aliased windef.ULONG;
cbKeyData : aliased windef.ULONG;
end record;
pragma Convention (C_Pass_By_Copy, struct_BCRYPT_KEY_DATA_BLOB_HEADER);
type struct_BCRYPT_KEY_DATA_BLOB_HEADER_ptr is
access all struct_BCRYPT_KEY_DATA_BLOB_HEADER;
for struct_BCRYPT_KEY_DATA_BLOB_HEADER_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_BCRYPT_KEY_DATA_BLOB_HEADER_ptr);
pragma Convention (C, struct_BCRYPT_KEY_DATA_BLOB_HEADER_ptr);
subtype BCRYPT_KEY_DATA_BLOB_HEADER is struct_BCRYPT_KEY_DATA_BLOB_HEADER;
subtype PBCRYPT_KEY_DATA_BLOB_HEADER is
struct_BCRYPT_KEY_DATA_BLOB_HEADER_ptr;
type struct_BCRYPT_DSA_PARAMETER_HEADER;
type struct_BCRYPT_DSA_PARAMETER_HEADER is record
cbLength : aliased windef.ULONG;
dwMagic : aliased windef.ULONG;
cbKeyLength : aliased windef.ULONG;
Count : aliased windef.UCHAR_array (0 .. 3);
Seed : aliased windef.UCHAR_array (0 .. 19);
q : aliased windef.UCHAR_array (0 .. 19);
end record;
pragma Convention (C_Pass_By_Copy, struct_BCRYPT_DSA_PARAMETER_HEADER);
subtype BCRYPT_DSA_PARAMETER_HEADER is struct_BCRYPT_DSA_PARAMETER_HEADER;
type struct_BCRYPT_DSA_PARAMETER_HEADER_V2;
type struct_BCRYPT_DSA_PARAMETER_HEADER_V2 is record
cbLength : aliased windef.ULONG;
dwMagic : aliased windef.ULONG;
cbKeyLength : aliased windef.ULONG;
hashAlgorithm : aliased HASHALGORITHM_ENUM;
standardVersion : aliased DSAFIPSVERSION_ENUM;
cbSeedLength : aliased windef.ULONG;
cbGroupSize : aliased windef.ULONG;
Count : aliased windef.UCHAR_array (0 .. 3);
end record;
pragma Convention (C_Pass_By_Copy, struct_BCRYPT_DSA_PARAMETER_HEADER_V2);
subtype BCRYPT_DSA_PARAMETER_HEADER_V2 is
struct_BCRYPT_DSA_PARAMETER_HEADER_V2;
type struct_BCRYPT_ALGORITHM_IDENTIFIER;
type struct_BCRYPT_ALGORITHM_IDENTIFIER is record
pszName : aliased winnt.LPWSTR;
dwClass : aliased windef.ULONG;
dwFlags : aliased windef.ULONG;
end record;
pragma Convention (C_Pass_By_Copy, struct_BCRYPT_ALGORITHM_IDENTIFIER);
type struct_BCRYPT_ALGORITHM_IDENTIFIER_ptr is
access all struct_BCRYPT_ALGORITHM_IDENTIFIER;
for struct_BCRYPT_ALGORITHM_IDENTIFIER_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_BCRYPT_ALGORITHM_IDENTIFIER_ptr);
pragma Convention (C, struct_BCRYPT_ALGORITHM_IDENTIFIER_ptr);
type struct_BCRYPT_ALGORITHM_IDENTIFIER_ptr_ptr is
access all struct_BCRYPT_ALGORITHM_IDENTIFIER_ptr;
for struct_BCRYPT_ALGORITHM_IDENTIFIER_ptr_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_BCRYPT_ALGORITHM_IDENTIFIER_ptr_ptr);
pragma Convention (C, struct_BCRYPT_ALGORITHM_IDENTIFIER_ptr_ptr);
subtype BCRYPT_ALGORITHM_IDENTIFIER is struct_BCRYPT_ALGORITHM_IDENTIFIER;
subtype BCRYPT_ALGORITHM_IDENTIFIER_ptr is
struct_BCRYPT_ALGORITHM_IDENTIFIER_ptr;
subtype BCRYPT_ALGORITHM_IDENTIFIER_ptr_ptr is
struct_BCRYPT_ALGORITHM_IDENTIFIER_ptr_ptr;
type struct_BCRYPT_PROVIDER_NAME;
type struct_BCRYPT_PROVIDER_NAME is record
pszProviderName : aliased winnt.LPWSTR;
end record;
pragma Convention (C_Pass_By_Copy, struct_BCRYPT_PROVIDER_NAME);
type struct_BCRYPT_PROVIDER_NAME_ptr is
access all struct_BCRYPT_PROVIDER_NAME;
for struct_BCRYPT_PROVIDER_NAME_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_BCRYPT_PROVIDER_NAME_ptr);
pragma Convention (C, struct_BCRYPT_PROVIDER_NAME_ptr);
type struct_BCRYPT_PROVIDER_NAME_ptr_ptr is
access all struct_BCRYPT_PROVIDER_NAME_ptr;
for struct_BCRYPT_PROVIDER_NAME_ptr_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_BCRYPT_PROVIDER_NAME_ptr_ptr);
pragma Convention (C, struct_BCRYPT_PROVIDER_NAME_ptr_ptr);
subtype BCRYPT_PROVIDER_NAME is struct_BCRYPT_PROVIDER_NAME;
subtype BCRYPT_PROVIDER_NAME_ptr is struct_BCRYPT_PROVIDER_NAME_ptr;
subtype BCRYPT_PROVIDER_NAME_ptr_ptr is
struct_BCRYPT_PROVIDER_NAME_ptr_ptr;
type struct_BCRYPT_INTERFACE_VERSION;
type struct_BCRYPT_INTERFACE_VERSION is record
MajorVersion : aliased windef.USHORT;
MinorVersion : aliased windef.USHORT;
end record;
pragma Convention (C_Pass_By_Copy, struct_BCRYPT_INTERFACE_VERSION);
type struct_BCRYPT_INTERFACE_VERSION_ptr is
access all struct_BCRYPT_INTERFACE_VERSION;
for struct_BCRYPT_INTERFACE_VERSION_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_BCRYPT_INTERFACE_VERSION_ptr);
pragma Convention (C, struct_BCRYPT_INTERFACE_VERSION_ptr);
subtype BCRYPT_INTERFACE_VERSION is struct_BCRYPT_INTERFACE_VERSION;
subtype PBCRYPT_INTERFACE_VERSION is struct_BCRYPT_INTERFACE_VERSION_ptr;
type struct_CRYPT_INTERFACE_REG;
type struct_CRYPT_INTERFACE_REG is record
dwInterface : aliased windef.ULONG;
dwFlags : aliased windef.ULONG;
cFunctions : aliased windef.ULONG;
rgpszFunctions : aliased winnt.PWSTR_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_CRYPT_INTERFACE_REG);
type struct_CRYPT_INTERFACE_REG_ptr is
access all struct_CRYPT_INTERFACE_REG;
for struct_CRYPT_INTERFACE_REG_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_INTERFACE_REG_ptr);
pragma Convention (C, struct_CRYPT_INTERFACE_REG_ptr);
type struct_CRYPT_INTERFACE_REG_ptr_ptr is
access all struct_CRYPT_INTERFACE_REG_ptr;
for struct_CRYPT_INTERFACE_REG_ptr_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_INTERFACE_REG_ptr_ptr);
pragma Convention (C, struct_CRYPT_INTERFACE_REG_ptr_ptr);
subtype CRYPT_INTERFACE_REG is struct_CRYPT_INTERFACE_REG;
subtype PCRYPT_INTERFACE_REG is struct_CRYPT_INTERFACE_REG_ptr;
subtype PCRYPT_INTERFACE_REG_ptr is struct_CRYPT_INTERFACE_REG_ptr_ptr;
type struct_CRYPT_IMAGE_REG;
type struct_CRYPT_IMAGE_REG is record
pszImage : aliased winnt.PWSTR;
cInterfaces : aliased windef.ULONG;
rgpInterfaces : aliased PCRYPT_INTERFACE_REG_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_CRYPT_IMAGE_REG);
type struct_CRYPT_IMAGE_REG_ptr is access all struct_CRYPT_IMAGE_REG;
for struct_CRYPT_IMAGE_REG_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_IMAGE_REG_ptr);
pragma Convention (C, struct_CRYPT_IMAGE_REG_ptr);
subtype CRYPT_IMAGE_REG is struct_CRYPT_IMAGE_REG;
subtype PCRYPT_IMAGE_REG is struct_CRYPT_IMAGE_REG_ptr;
type struct_CRYPT_PROVIDER_REG;
type struct_CRYPT_PROVIDER_REG is record
cAliases : aliased windef.ULONG;
rgpszAliases : aliased winnt.PWSTR_ptr;
pUM : aliased PCRYPT_IMAGE_REG;
pKM : aliased PCRYPT_IMAGE_REG;
end record;
pragma Convention (C_Pass_By_Copy, struct_CRYPT_PROVIDER_REG);
type struct_CRYPT_PROVIDER_REG_ptr is
access all struct_CRYPT_PROVIDER_REG;
for struct_CRYPT_PROVIDER_REG_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_PROVIDER_REG_ptr);
pragma Convention (C, struct_CRYPT_PROVIDER_REG_ptr);
type struct_CRYPT_PROVIDER_REG_ptr_ptr is
access all struct_CRYPT_PROVIDER_REG_ptr;
for struct_CRYPT_PROVIDER_REG_ptr_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_PROVIDER_REG_ptr_ptr);
pragma Convention (C, struct_CRYPT_PROVIDER_REG_ptr_ptr);
subtype CRYPT_PROVIDER_REG is struct_CRYPT_PROVIDER_REG;
subtype PCRYPT_PROVIDER_REG is struct_CRYPT_PROVIDER_REG_ptr;
subtype PCRYPT_PROVIDER_REG_ptr is struct_CRYPT_PROVIDER_REG_ptr_ptr;
type struct_CRYPT_PROVIDERS;
type struct_CRYPT_PROVIDERS is record
cProviders : aliased windef.ULONG;
rgpszProviders : aliased winnt.PWSTR_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_CRYPT_PROVIDERS);
type struct_CRYPT_PROVIDERS_ptr is access all struct_CRYPT_PROVIDERS;
for struct_CRYPT_PROVIDERS_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_PROVIDERS_ptr);
pragma Convention (C, struct_CRYPT_PROVIDERS_ptr);
type struct_CRYPT_PROVIDERS_ptr_ptr is
access all struct_CRYPT_PROVIDERS_ptr;
for struct_CRYPT_PROVIDERS_ptr_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_PROVIDERS_ptr_ptr);
pragma Convention (C, struct_CRYPT_PROVIDERS_ptr_ptr);
subtype CRYPT_PROVIDERS is struct_CRYPT_PROVIDERS;
subtype PCRYPT_PROVIDERS is struct_CRYPT_PROVIDERS_ptr;
subtype PCRYPT_PROVIDERS_ptr is struct_CRYPT_PROVIDERS_ptr_ptr;
type struct_CRYPT_CONTEXT_CONFIG;
type struct_CRYPT_CONTEXT_CONFIG is record
dwFlags : aliased windef.ULONG;
dwReserved : aliased windef.ULONG;
end record;
pragma Convention (C_Pass_By_Copy, struct_CRYPT_CONTEXT_CONFIG);
type struct_CRYPT_CONTEXT_CONFIG_ptr is
access all struct_CRYPT_CONTEXT_CONFIG;
for struct_CRYPT_CONTEXT_CONFIG_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_CONTEXT_CONFIG_ptr);
pragma Convention (C, struct_CRYPT_CONTEXT_CONFIG_ptr);
type struct_CRYPT_CONTEXT_CONFIG_ptr_ptr is
access all struct_CRYPT_CONTEXT_CONFIG_ptr;
for struct_CRYPT_CONTEXT_CONFIG_ptr_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_CONTEXT_CONFIG_ptr_ptr);
pragma Convention (C, struct_CRYPT_CONTEXT_CONFIG_ptr_ptr);
subtype CRYPT_CONTEXT_CONFIG is struct_CRYPT_CONTEXT_CONFIG;
subtype PCRYPT_CONTEXT_CONFIG is struct_CRYPT_CONTEXT_CONFIG_ptr;
subtype PCRYPT_CONTEXT_CONFIG_ptr is struct_CRYPT_CONTEXT_CONFIG_ptr_ptr;
type struct_CRYPT_CONTEXT_FUNCTION_CONFIG;
type struct_CRYPT_CONTEXT_FUNCTION_CONFIG is record
dwFlags : aliased windef.ULONG;
dwReserved : aliased windef.ULONG;
end record;
pragma Convention (C_Pass_By_Copy, struct_CRYPT_CONTEXT_FUNCTION_CONFIG);
type struct_CRYPT_CONTEXT_FUNCTION_CONFIG_ptr is
access all struct_CRYPT_CONTEXT_FUNCTION_CONFIG;
for struct_CRYPT_CONTEXT_FUNCTION_CONFIG_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_CONTEXT_FUNCTION_CONFIG_ptr);
pragma Convention (C, struct_CRYPT_CONTEXT_FUNCTION_CONFIG_ptr);
type struct_CRYPT_CONTEXT_FUNCTION_CONFIG_ptr_ptr is
access all struct_CRYPT_CONTEXT_FUNCTION_CONFIG_ptr;
for struct_CRYPT_CONTEXT_FUNCTION_CONFIG_ptr_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_CONTEXT_FUNCTION_CONFIG_ptr_ptr);
pragma Convention (C, struct_CRYPT_CONTEXT_FUNCTION_CONFIG_ptr_ptr);
subtype CRYPT_CONTEXT_FUNCTION_CONFIG is
struct_CRYPT_CONTEXT_FUNCTION_CONFIG;
subtype PCRYPT_CONTEXT_FUNCTION_CONFIG is
struct_CRYPT_CONTEXT_FUNCTION_CONFIG_ptr;
subtype PCRYPT_CONTEXT_FUNCTION_CONFIG_ptr is
struct_CRYPT_CONTEXT_FUNCTION_CONFIG_ptr_ptr;
type struct_CRYPT_CONTEXTS;
type struct_CRYPT_CONTEXTS is record
cContexts : aliased windef.ULONG;
rgpszContexts : aliased winnt.PWSTR_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_CRYPT_CONTEXTS);
type struct_CRYPT_CONTEXTS_ptr is access all struct_CRYPT_CONTEXTS;
for struct_CRYPT_CONTEXTS_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_CONTEXTS_ptr);
pragma Convention (C, struct_CRYPT_CONTEXTS_ptr);
type struct_CRYPT_CONTEXTS_ptr_ptr is
access all struct_CRYPT_CONTEXTS_ptr;
for struct_CRYPT_CONTEXTS_ptr_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_CONTEXTS_ptr_ptr);
pragma Convention (C, struct_CRYPT_CONTEXTS_ptr_ptr);
subtype CRYPT_CONTEXTS is struct_CRYPT_CONTEXTS;
subtype PCRYPT_CONTEXTS is struct_CRYPT_CONTEXTS_ptr;
subtype PCRYPT_CONTEXTS_ptr is struct_CRYPT_CONTEXTS_ptr_ptr;
type struct_CRYPT_CONTEXT_FUNCTIONS;
type struct_CRYPT_CONTEXT_FUNCTIONS is record
cFunctions : aliased windef.ULONG;
rgpszFunctions : aliased winnt.PWSTR_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_CRYPT_CONTEXT_FUNCTIONS);
type struct_CRYPT_CONTEXT_FUNCTIONS_ptr is
access all struct_CRYPT_CONTEXT_FUNCTIONS;
for struct_CRYPT_CONTEXT_FUNCTIONS_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_CONTEXT_FUNCTIONS_ptr);
pragma Convention (C, struct_CRYPT_CONTEXT_FUNCTIONS_ptr);
type struct_CRYPT_CONTEXT_FUNCTIONS_ptr_ptr is
access all struct_CRYPT_CONTEXT_FUNCTIONS_ptr;
for struct_CRYPT_CONTEXT_FUNCTIONS_ptr_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_CONTEXT_FUNCTIONS_ptr_ptr);
pragma Convention (C, struct_CRYPT_CONTEXT_FUNCTIONS_ptr_ptr);
subtype CRYPT_CONTEXT_FUNCTIONS is struct_CRYPT_CONTEXT_FUNCTIONS;
subtype PCRYPT_CONTEXT_FUNCTIONS is struct_CRYPT_CONTEXT_FUNCTIONS_ptr;
subtype PCRYPT_CONTEXT_FUNCTIONS_ptr is
struct_CRYPT_CONTEXT_FUNCTIONS_ptr_ptr;
type struct_CRYPT_CONTEXT_FUNCTION_PROVIDERS;
type struct_CRYPT_CONTEXT_FUNCTION_PROVIDERS is record
cProviders : aliased windef.ULONG;
rgpszProviders : aliased winnt.PWSTR_ptr;
end record;
pragma Convention (C_Pass_By_Copy,
struct_CRYPT_CONTEXT_FUNCTION_PROVIDERS);
type struct_CRYPT_CONTEXT_FUNCTION_PROVIDERS_ptr is
access all struct_CRYPT_CONTEXT_FUNCTION_PROVIDERS;
for struct_CRYPT_CONTEXT_FUNCTION_PROVIDERS_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_CONTEXT_FUNCTION_PROVIDERS_ptr);
pragma Convention (C, struct_CRYPT_CONTEXT_FUNCTION_PROVIDERS_ptr);
type struct_CRYPT_CONTEXT_FUNCTION_PROVIDERS_ptr_ptr is
access all struct_CRYPT_CONTEXT_FUNCTION_PROVIDERS_ptr;
for struct_CRYPT_CONTEXT_FUNCTION_PROVIDERS_ptr_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (
struct_CRYPT_CONTEXT_FUNCTION_PROVIDERS_ptr_ptr);
pragma Convention (C, struct_CRYPT_CONTEXT_FUNCTION_PROVIDERS_ptr_ptr);
subtype CRYPT_CONTEXT_FUNCTION_PROVIDERS is
struct_CRYPT_CONTEXT_FUNCTION_PROVIDERS;
subtype PCRYPT_CONTEXT_FUNCTION_PROVIDERS is
struct_CRYPT_CONTEXT_FUNCTION_PROVIDERS_ptr;
subtype PCRYPT_CONTEXT_FUNCTION_PROVIDERS_ptr is
struct_CRYPT_CONTEXT_FUNCTION_PROVIDERS_ptr_ptr;
type struct_CRYPT_PROPERTY_REF;
type struct_CRYPT_PROPERTY_REF is record
pszProperty : aliased winnt.PWSTR;
cbValue : aliased windef.ULONG;
pbValue : aliased windef.PUCHAR;
end record;
pragma Convention (C_Pass_By_Copy, struct_CRYPT_PROPERTY_REF);
type struct_CRYPT_PROPERTY_REF_ptr is
access all struct_CRYPT_PROPERTY_REF;
for struct_CRYPT_PROPERTY_REF_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_PROPERTY_REF_ptr);
pragma Convention (C, struct_CRYPT_PROPERTY_REF_ptr);
type struct_CRYPT_PROPERTY_REF_ptr_ptr is
access all struct_CRYPT_PROPERTY_REF_ptr;
for struct_CRYPT_PROPERTY_REF_ptr_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_PROPERTY_REF_ptr_ptr);
pragma Convention (C, struct_CRYPT_PROPERTY_REF_ptr_ptr);
subtype CRYPT_PROPERTY_REF is struct_CRYPT_PROPERTY_REF;
subtype PCRYPT_PROPERTY_REF is struct_CRYPT_PROPERTY_REF_ptr;
subtype PCRYPT_PROPERTY_REF_ptr is struct_CRYPT_PROPERTY_REF_ptr_ptr;
type struct_CRYPT_IMAGE_REF;
type struct_CRYPT_IMAGE_REF is record
pszImage : aliased winnt.PWSTR;
dwFlags : aliased windef.ULONG;
end record;
pragma Convention (C_Pass_By_Copy, struct_CRYPT_IMAGE_REF);
type struct_CRYPT_IMAGE_REF_ptr is access all struct_CRYPT_IMAGE_REF;
for struct_CRYPT_IMAGE_REF_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_IMAGE_REF_ptr);
pragma Convention (C, struct_CRYPT_IMAGE_REF_ptr);
subtype CRYPT_IMAGE_REF is struct_CRYPT_IMAGE_REF;
subtype PCRYPT_IMAGE_REF is struct_CRYPT_IMAGE_REF_ptr;
type struct_CRYPT_PROVIDER_REF;
type struct_CRYPT_PROVIDER_REF is record
dwInterface : aliased windef.ULONG;
pszFunction : aliased winnt.PWSTR;
pszProvider : aliased winnt.PWSTR;
cProperties : aliased windef.ULONG;
rgpProperties : aliased PCRYPT_PROPERTY_REF_ptr;
pUM : aliased PCRYPT_IMAGE_REF;
pKM : aliased PCRYPT_IMAGE_REF;
end record;
pragma Convention (C_Pass_By_Copy, struct_CRYPT_PROVIDER_REF);
type struct_CRYPT_PROVIDER_REF_ptr is
access all struct_CRYPT_PROVIDER_REF;
for struct_CRYPT_PROVIDER_REF_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_PROVIDER_REF_ptr);
pragma Convention (C, struct_CRYPT_PROVIDER_REF_ptr);
type struct_CRYPT_PROVIDER_REF_ptr_ptr is
access all struct_CRYPT_PROVIDER_REF_ptr;
for struct_CRYPT_PROVIDER_REF_ptr_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_PROVIDER_REF_ptr_ptr);
pragma Convention (C, struct_CRYPT_PROVIDER_REF_ptr_ptr);
subtype CRYPT_PROVIDER_REF is struct_CRYPT_PROVIDER_REF;
subtype PCRYPT_PROVIDER_REF is struct_CRYPT_PROVIDER_REF_ptr;
subtype PCRYPT_PROVIDER_REF_ptr is struct_CRYPT_PROVIDER_REF_ptr_ptr;
type struct_CRYPT_PROVIDER_REFS;
type struct_CRYPT_PROVIDER_REFS is record
cProviders : aliased windef.ULONG;
rgpProviders : aliased PCRYPT_PROVIDER_REF_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_CRYPT_PROVIDER_REFS);
type struct_CRYPT_PROVIDER_REFS_ptr is
access all struct_CRYPT_PROVIDER_REFS;
for struct_CRYPT_PROVIDER_REFS_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_PROVIDER_REFS_ptr);
pragma Convention (C, struct_CRYPT_PROVIDER_REFS_ptr);
type struct_CRYPT_PROVIDER_REFS_ptr_ptr is
access all struct_CRYPT_PROVIDER_REFS_ptr;
for struct_CRYPT_PROVIDER_REFS_ptr_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_PROVIDER_REFS_ptr_ptr);
pragma Convention (C, struct_CRYPT_PROVIDER_REFS_ptr_ptr);
subtype CRYPT_PROVIDER_REFS is struct_CRYPT_PROVIDER_REFS;
subtype PCRYPT_PROVIDER_REFS is struct_CRYPT_PROVIDER_REFS_ptr;
subtype PCRYPT_PROVIDER_REFS_ptr is struct_CRYPT_PROVIDER_REFS_ptr_ptr;
function BCryptOpenAlgorithmProvider (
phAlgorithm : access BCRYPT_ALG_HANDLE;
pszAlgId : access constant winnt.WCHAR;
pszImplementation : access constant winnt.WCHAR;
dwFlags : windef.ULONG) return winternl.NTSTATUS;
pragma Import (C, BCryptOpenAlgorithmProvider,
"BCryptOpenAlgorithmProvider");
function BCryptEnumAlgorithms (dwAlgOperations : windef.ULONG;
pAlgCount : access windef.ULONG;
ppAlgList : access BCRYPT_ALGORITHM_IDENTIFIER_ptr;
dwFlags : windef.ULONG) return winternl.NTSTATUS;
pragma Import (C, BCryptEnumAlgorithms, "BCryptEnumAlgorithms");
function BCryptEnumProviders (pszAlgId : access constant winnt.WCHAR;
pImplCount : access windef.ULONG;
ppImplList : access BCRYPT_PROVIDER_NAME_ptr; dwFlags : windef.ULONG)
return winternl.NTSTATUS;
pragma Import (C, BCryptEnumProviders, "BCryptEnumProviders");
function BCryptGetProperty (hObject : BCRYPT_HANDLE;
pszProperty : access constant winnt.WCHAR;
pbOutput : access windef.UCHAR; cbOutput : windef.ULONG;
pcbResult : access windef.ULONG; dwFlags : windef.ULONG)
return winternl.NTSTATUS;
pragma Import (C, BCryptGetProperty, "BCryptGetProperty");
function BCryptSetProperty (hObject : BCRYPT_HANDLE;
pszProperty : access constant winnt.WCHAR;
pbInput : access windef.UCHAR; cbInput : windef.ULONG;
dwFlags : windef.ULONG) return winternl.NTSTATUS;
pragma Import (C, BCryptSetProperty, "BCryptSetProperty");
function BCryptCloseAlgorithmProvider (hAlgorithm : BCRYPT_ALG_HANDLE;
dwFlags : windef.ULONG) return winternl.NTSTATUS;
pragma Import (C, BCryptCloseAlgorithmProvider,
"BCryptCloseAlgorithmProvider");
procedure BCryptFreeBuffer (pvBuffer : winnt.PVOID);
pragma Import (C, BCryptFreeBuffer, "BCryptFreeBuffer");
function BCryptGenerateSymmetricKey (hAlgorithm : BCRYPT_ALG_HANDLE;
phKey : access BCRYPT_KEY_HANDLE; pbKeyObject : access windef.UCHAR;
cbKeyObject : windef.ULONG; pbSecret : access windef.UCHAR;
cbSecret : windef.ULONG; dwFlags : windef.ULONG)
return winternl.NTSTATUS;
pragma Import (C, BCryptGenerateSymmetricKey,
"BCryptGenerateSymmetricKey");
function BCryptGenerateKeyPair (hAlgorithm : BCRYPT_ALG_HANDLE;
phKey : access BCRYPT_KEY_HANDLE; dwLength : windef.ULONG;
dwFlags : windef.ULONG) return winternl.NTSTATUS;
pragma Import (C, BCryptGenerateKeyPair, "BCryptGenerateKeyPair");
function BCryptEncrypt (hKey : BCRYPT_KEY_HANDLE;
pbInput : access windef.UCHAR; cbInput : windef.ULONG;
pPaddingInfo : void_ptr; pbIV : access windef.UCHAR;
cbIV : windef.ULONG; pbOutput : access windef.UCHAR;
cbOutput : windef.ULONG; pcbResult : access windef.ULONG;
dwFlags : windef.ULONG) return winternl.NTSTATUS;
pragma Import (C, BCryptEncrypt, "BCryptEncrypt");
function BCryptDecrypt (hKey : BCRYPT_KEY_HANDLE;
pbInput : access windef.UCHAR; cbInput : windef.ULONG;
pPaddingInfo : void_ptr; pbIV : access windef.UCHAR;
cbIV : windef.ULONG; pbOutput : access windef.UCHAR;
cbOutput : windef.ULONG; pcbResult : access windef.ULONG;
dwFlags : windef.ULONG) return winternl.NTSTATUS;
pragma Import (C, BCryptDecrypt, "BCryptDecrypt");
function BCryptExportKey (hKey : BCRYPT_KEY_HANDLE;
hExportKey : BCRYPT_KEY_HANDLE;
pszBlobType : access constant winnt.WCHAR;
pbOutput : access windef.UCHAR; cbOutput : windef.ULONG;
pcbResult : access windef.ULONG; dwFlags : windef.ULONG)
return winternl.NTSTATUS;
pragma Import (C, BCryptExportKey, "BCryptExportKey");
function BCryptImportKey (hAlgorithm : BCRYPT_ALG_HANDLE;
hImportKey : BCRYPT_KEY_HANDLE;
pszBlobType : access constant winnt.WCHAR;
phKey : access BCRYPT_KEY_HANDLE; pbKeyObject : access windef.UCHAR;
cbKeyObject : windef.ULONG; pbInput : access windef.UCHAR;
cbInput : windef.ULONG; dwFlags : windef.ULONG)
return winternl.NTSTATUS;
pragma Import (C, BCryptImportKey, "BCryptImportKey");
function BCryptImportKeyPair (hAlgorithm : BCRYPT_ALG_HANDLE;
hImportKey : BCRYPT_KEY_HANDLE;
pszBlobType : access constant winnt.WCHAR;
phKey : access BCRYPT_KEY_HANDLE; pbInput : access windef.UCHAR;
cbInput : windef.ULONG; dwFlags : windef.ULONG)
return winternl.NTSTATUS;
pragma Import (C, BCryptImportKeyPair, "BCryptImportKeyPair");
function BCryptDuplicateKey (hKey : BCRYPT_KEY_HANDLE;
phNewKey : access BCRYPT_KEY_HANDLE; pbKeyObject : access windef.UCHAR;
cbKeyObject : windef.ULONG; dwFlags : windef.ULONG)
return winternl.NTSTATUS;
pragma Import (C, BCryptDuplicateKey, "BCryptDuplicateKey");
function BCryptFinalizeKeyPair (hKey : BCRYPT_KEY_HANDLE;
dwFlags : windef.ULONG) return winternl.NTSTATUS;
pragma Import (C, BCryptFinalizeKeyPair, "BCryptFinalizeKeyPair");
function BCryptDestroyKey (hKey : BCRYPT_KEY_HANDLE)
return winternl.NTSTATUS;
pragma Import (C, BCryptDestroyKey, "BCryptDestroyKey");
function BCryptDestroySecret (hSecret : BCRYPT_SECRET_HANDLE)
return winternl.NTSTATUS;
pragma Import (C, BCryptDestroySecret, "BCryptDestroySecret");
function BCryptSignHash (hKey : BCRYPT_KEY_HANDLE;
pPaddingInfo : void_ptr; pbInput : access windef.UCHAR;
cbInput : windef.ULONG; pbOutput : access windef.UCHAR;
cbOutput : windef.ULONG; pcbResult : access windef.ULONG;
dwFlags : windef.ULONG) return winternl.NTSTATUS;
pragma Import (C, BCryptSignHash, "BCryptSignHash");
function BCryptVerifySignature (hKey : BCRYPT_KEY_HANDLE;
pPaddingInfo : void_ptr; pbHash : access windef.UCHAR;
cbHash : windef.ULONG; pbSignature : access windef.UCHAR;
cbSignature : windef.ULONG; dwFlags : windef.ULONG)
return winternl.NTSTATUS;
pragma Import (C, BCryptVerifySignature, "BCryptVerifySignature");
function BCryptSecretAgreement (hPrivKey : BCRYPT_KEY_HANDLE;
hPubKey : BCRYPT_KEY_HANDLE;
phAgreedSecret : access BCRYPT_SECRET_HANDLE; dwFlags : windef.ULONG)
return winternl.NTSTATUS;
pragma Import (C, BCryptSecretAgreement, "BCryptSecretAgreement");
function BCryptDeriveKey (hSharedSecret : BCRYPT_SECRET_HANDLE;
pwszKDF : access constant winnt.WCHAR;
pParameterList : access BCryptBufferDesc;
pbDerivedKey : access windef.UCHAR; cbDerivedKey : windef.ULONG;
pcbResult : access windef.ULONG; dwFlags : windef.ULONG)
return winternl.NTSTATUS;
pragma Import (C, BCryptDeriveKey, "BCryptDeriveKey");
function BCryptKeyDerivation (hKey : BCRYPT_KEY_HANDLE;
pParameterList : access BCryptBufferDesc;
pbDerivedKey : access windef.UCHAR; cbDerivedKey : windef.ULONG;
pcbResult : access windef.ULONG; dwFlags : windef.ULONG)
return winternl.NTSTATUS;
pragma Import (C, BCryptKeyDerivation, "BCryptKeyDerivation");
function BCryptCreateHash (hAlgorithm : BCRYPT_ALG_HANDLE;
phHash : access BCRYPT_HASH_HANDLE; pbHashObject : access windef.UCHAR;
cbHashObject : windef.ULONG; pbSecret : access windef.UCHAR;
cbSecret : windef.ULONG; dwFlags : windef.ULONG)
return winternl.NTSTATUS;
pragma Import (C, BCryptCreateHash, "BCryptCreateHash");
function BCryptHashData (hHash : BCRYPT_HASH_HANDLE;
pbInput : access windef.UCHAR; cbInput : windef.ULONG;
dwFlags : windef.ULONG) return winternl.NTSTATUS;
pragma Import (C, BCryptHashData, "BCryptHashData");
function BCryptFinishHash (hHash : BCRYPT_HASH_HANDLE;
pbOutput : access windef.UCHAR; cbOutput : windef.ULONG;
dwFlags : windef.ULONG) return winternl.NTSTATUS;
pragma Import (C, BCryptFinishHash, "BCryptFinishHash");
function BCryptDuplicateHash (hHash : BCRYPT_HASH_HANDLE;
phNewHash : access BCRYPT_HASH_HANDLE;
pbHashObject : access windef.UCHAR; cbHashObject : windef.ULONG;
dwFlags : windef.ULONG) return winternl.NTSTATUS;
pragma Import (C, BCryptDuplicateHash, "BCryptDuplicateHash");
function BCryptDestroyHash (hHash : BCRYPT_HASH_HANDLE)
return winternl.NTSTATUS;
pragma Import (C, BCryptDestroyHash, "BCryptDestroyHash");
function BCryptGenRandom (hAlgorithm : BCRYPT_ALG_HANDLE;
pbBuffer : access windef.UCHAR; cbBuffer : windef.ULONG;
dwFlags : windef.ULONG) return winternl.NTSTATUS;
pragma Import (C, BCryptGenRandom, "BCryptGenRandom");
function BCryptDeriveKeyCapi (hHash : BCRYPT_HASH_HANDLE;
hTargetAlg : BCRYPT_ALG_HANDLE; pbDerivedKey : access windef.UCHAR;
cbDerivedKey : windef.ULONG; dwFlags : windef.ULONG)
return winternl.NTSTATUS;
pragma Import (C, BCryptDeriveKeyCapi, "BCryptDeriveKeyCapi");
function BCryptDeriveKeyPBKDF2 (hPrf : BCRYPT_ALG_HANDLE;
pbPassword : access windef.UCHAR; cbPassword : windef.ULONG;
pbSalt : access windef.UCHAR; cbSalt : windef.ULONG;
cIterations : winnt.ULONGLONG; pbDerivedKey : access windef.UCHAR;
cbDerivedKey : windef.ULONG; dwFlags : windef.ULONG)
return winternl.NTSTATUS;
pragma Import (C, BCryptDeriveKeyPBKDF2, "BCryptDeriveKeyPBKDF2");
function BCryptResolveProviders (pszContext : access constant winnt.WCHAR;
dwInterface : windef.ULONG; pszFunction : access constant winnt.WCHAR;
pszProvider : access constant winnt.WCHAR; dwMode : windef.ULONG;
dwFlags : windef.ULONG; pcbBuffer : access windef.ULONG;
ppBuffer : access PCRYPT_PROVIDER_REFS) return winternl.NTSTATUS;
pragma Import (C, BCryptResolveProviders, "BCryptResolveProviders");
function BCryptGetFipsAlgorithmMode (pfEnabled : access winnt.BOOLEAN)
return winternl.NTSTATUS;
pragma Import (C, BCryptGetFipsAlgorithmMode,
"BCryptGetFipsAlgorithmMode");
function BCryptQueryProviderRegistration (
pszProvider : access constant winnt.WCHAR; dwMode : windef.ULONG;
dwInterface : windef.ULONG; pcbBuffer : access windef.ULONG;
ppBuffer : access PCRYPT_PROVIDER_REG) return winternl.NTSTATUS;
pragma Import (C, BCryptQueryProviderRegistration,
"BCryptQueryProviderRegistration");
function BCryptEnumRegisteredProviders (pcbBuffer : access windef.ULONG;
ppBuffer : access PCRYPT_PROVIDERS) return winternl.NTSTATUS;
pragma Import (C, BCryptEnumRegisteredProviders,
"BCryptEnumRegisteredProviders");
function BCryptCreateContext (dwTable : windef.ULONG;
pszContext : access constant winnt.WCHAR;
pConfig : access struct_CRYPT_CONTEXT_CONFIG) return winternl.NTSTATUS;
pragma Import (C, BCryptCreateContext, "BCryptCreateContext");
function BCryptDeleteContext (dwTable : windef.ULONG;
pszContext : access constant winnt.WCHAR) return winternl.NTSTATUS;
pragma Import (C, BCryptDeleteContext, "BCryptDeleteContext");
function BCryptEnumContexts (dwTable : windef.ULONG;
pcbBuffer : access windef.ULONG; ppBuffer : access PCRYPT_CONTEXTS)
return winternl.NTSTATUS;
pragma Import (C, BCryptEnumContexts, "BCryptEnumContexts");
function BCryptConfigureContext (dwTable : windef.ULONG;
pszContext : access constant winnt.WCHAR;
pConfig : access struct_CRYPT_CONTEXT_CONFIG) return winternl.NTSTATUS;
pragma Import (C, BCryptConfigureContext, "BCryptConfigureContext");
function BCryptQueryContextConfiguration (dwTable : windef.ULONG;
pszContext : access constant winnt.WCHAR;
pcbBuffer : access windef.ULONG;
ppBuffer : access PCRYPT_CONTEXT_CONFIG) return winternl.NTSTATUS;
pragma Import (C, BCryptQueryContextConfiguration,
"BCryptQueryContextConfiguration");
function BCryptAddContextFunction (dwTable : windef.ULONG;
pszContext : access constant winnt.WCHAR; dwInterface : windef.ULONG;
pszFunction : access constant winnt.WCHAR; dwPosition : windef.ULONG)
return winternl.NTSTATUS;
pragma Import (C, BCryptAddContextFunction, "BCryptAddContextFunction");
function BCryptRemoveContextFunction (dwTable : windef.ULONG;
pszContext : access constant winnt.WCHAR; dwInterface : windef.ULONG;
pszFunction : access constant winnt.WCHAR) return winternl.NTSTATUS;
pragma Import (C, BCryptRemoveContextFunction,
"BCryptRemoveContextFunction");
function BCryptEnumContextFunctions (dwTable : windef.ULONG;
pszContext : access constant winnt.WCHAR; dwInterface : windef.ULONG;
pcbBuffer : access windef.ULONG;
ppBuffer : access PCRYPT_CONTEXT_FUNCTIONS) return winternl.NTSTATUS;
pragma Import (C, BCryptEnumContextFunctions,
"BCryptEnumContextFunctions");
function BCryptConfigureContextFunction (dwTable : windef.ULONG;
pszContext : access constant winnt.WCHAR; dwInterface : windef.ULONG;
pszFunction : access constant winnt.WCHAR;
pConfig : access struct_CRYPT_CONTEXT_FUNCTION_CONFIG)
return winternl.NTSTATUS;
pragma Import (C, BCryptConfigureContextFunction,
"BCryptConfigureContextFunction");
function BCryptQueryContextFunctionConfiguration (dwTable : windef.ULONG;
pszContext : access constant winnt.WCHAR; dwInterface : windef.ULONG;
pszFunction : access constant winnt.WCHAR;
pcbBuffer : access windef.ULONG;
ppBuffer : access PCRYPT_CONTEXT_FUNCTION_CONFIG)
return winternl.NTSTATUS;
pragma Import (C, BCryptQueryContextFunctionConfiguration,
"BCryptQueryContextFunctionConfiguration");
function BCryptEnumContextFunctionProviders (dwTable : windef.ULONG;
pszContext : access constant winnt.WCHAR; dwInterface : windef.ULONG;
pszFunction : access constant winnt.WCHAR;
pcbBuffer : access windef.ULONG;
ppBuffer : access PCRYPT_CONTEXT_FUNCTION_PROVIDERS)
return winternl.NTSTATUS;
pragma Import (C, BCryptEnumContextFunctionProviders,
"BCryptEnumContextFunctionProviders");
function BCryptSetContextFunctionProperty (dwTable : windef.ULONG;
pszContext : access constant winnt.WCHAR; dwInterface : windef.ULONG;
pszFunction : access constant winnt.WCHAR;
pszProperty : access constant winnt.WCHAR; cbValue : windef.ULONG;
pbValue : access windef.UCHAR) return winternl.NTSTATUS;
pragma Import (C, BCryptSetContextFunctionProperty,
"BCryptSetContextFunctionProperty");
function BCryptQueryContextFunctionProperty (dwTable : windef.ULONG;
pszContext : access constant winnt.WCHAR; dwInterface : windef.ULONG;
pszFunction : access constant winnt.WCHAR;
pszProperty : access constant winnt.WCHAR;
pcbValue : access windef.ULONG; ppbValue : access windef.PUCHAR)
return winternl.NTSTATUS;
pragma Import (C, BCryptQueryContextFunctionProperty,
"BCryptQueryContextFunctionProperty");
function BCryptRegisterConfigChangeNotify (phEvent : access winnt.HANDLE)
return winternl.NTSTATUS;
pragma Import (C, BCryptRegisterConfigChangeNotify,
"BCryptRegisterConfigChangeNotify");
function BCryptUnregisterConfigChangeNotify (hEvent : winnt.HANDLE)
return winternl.NTSTATUS;
pragma Import (C, BCryptUnregisterConfigChangeNotify,
"BCryptUnregisterConfigChangeNotify");
BCRYPTBUFFER_VERSION : constant := 0;
BCRYPT_3DES_112_ALGORITHM : constant wchar_t_array (0 .. 8) := (
wchar_t'Val (51), wchar_t'Val (68), wchar_t'Val (69), wchar_t'Val (83),
wchar_t'Val (95), wchar_t'Val (49), wchar_t'Val (49), wchar_t'Val (50),
wchar_t'Val (0));
BCRYPT_3DES_ALGORITHM : constant wchar_t_array (0 .. 4) := (
wchar_t'Val (51), wchar_t'Val (68), wchar_t'Val (69), wchar_t'Val (83),
wchar_t'Val (0));
BCRYPT_AES_ALGORITHM : constant wchar_t_array (0 .. 3) := (
wchar_t'Val (65), wchar_t'Val (69), wchar_t'Val (83), wchar_t'Val (0));
BCRYPT_AES_CMAC_ALGORITHM : constant wchar_t_array (0 .. 8) := (
wchar_t'Val (65), wchar_t'Val (69), wchar_t'Val (83), wchar_t'Val (45),
wchar_t'Val (67), wchar_t'Val (77), wchar_t'Val (65), wchar_t'Val (67),
wchar_t'Val (0));
BCRYPT_AES_GMAC_ALGORITHM : constant wchar_t_array (0 .. 8) := (
wchar_t'Val (65), wchar_t'Val (69), wchar_t'Val (83), wchar_t'Val (45),
wchar_t'Val (71), wchar_t'Val (77), wchar_t'Val (65), wchar_t'Val (67),
wchar_t'Val (0));
BCRYPT_AES_WRAP_KEY_BLOB : constant wchar_t_array (0 .. 18) := (
wchar_t'Val (82), wchar_t'Val (102), wchar_t'Val (99),
wchar_t'Val (51), wchar_t'Val (53), wchar_t'Val (54), wchar_t'Val (53),
wchar_t'Val (75), wchar_t'Val (101), wchar_t'Val (121),
wchar_t'Val (87), wchar_t'Val (114), wchar_t'Val (97),
wchar_t'Val (112), wchar_t'Val (66), wchar_t'Val (108),
wchar_t'Val (111), wchar_t'Val (98), wchar_t'Val (0));
BCRYPT_ALGORITHM_NAME : constant wchar_t_array (0 .. 13) := (
wchar_t'Val (65), wchar_t'Val (108), wchar_t'Val (103),
wchar_t'Val (111), wchar_t'Val (114), wchar_t'Val (105),
wchar_t'Val (116), wchar_t'Val (104), wchar_t'Val (109),
wchar_t'Val (78), wchar_t'Val (97), wchar_t'Val (109),
wchar_t'Val (101), wchar_t'Val (0));
BCRYPT_ALG_HANDLE_HMAC_FLAG : constant := 8;
BCRYPT_ASYMMETRIC_ENCRYPTION_INTERFACE : constant := 3;
-- BCRYPT_ASYMMETRIC_ENCRYPTION_INTER... (plase type with #pragma instance)
BCRYPT_ASYMMETRIC_ENCRYPTION_OPERATION : constant := 4;
BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO_VERSION : constant := 1;
BCRYPT_AUTH_MODE_CHAIN_CALLS_FLAG : constant := 1;
BCRYPT_AUTH_MODE_IN_PROGRESS_FLAG : constant := 2;
BCRYPT_AUTH_TAG_LENGTH : constant wchar_t_array (0 .. 13) := (
wchar_t'Val (65), wchar_t'Val (117), wchar_t'Val (116),
wchar_t'Val (104), wchar_t'Val (84), wchar_t'Val (97),
wchar_t'Val (103), wchar_t'Val (76), wchar_t'Val (101),
wchar_t'Val (110), wchar_t'Val (103), wchar_t'Val (116),
wchar_t'Val (104), wchar_t'Val (0));
BCRYPT_BLOCK_LENGTH : constant wchar_t_array (0 .. 11) := (
wchar_t'Val (66), wchar_t'Val (108), wchar_t'Val (111),
wchar_t'Val (99), wchar_t'Val (107), wchar_t'Val (76),
wchar_t'Val (101), wchar_t'Val (110), wchar_t'Val (103),
wchar_t'Val (116), wchar_t'Val (104), wchar_t'Val (0));
BCRYPT_BLOCK_PADDING : constant := 1;
BCRYPT_BLOCK_SIZE_LIST : constant wchar_t_array (0 .. 13) := (
wchar_t'Val (66), wchar_t'Val (108), wchar_t'Val (111),
wchar_t'Val (99), wchar_t'Val (107), wchar_t'Val (83),
wchar_t'Val (105), wchar_t'Val (122), wchar_t'Val (101),
wchar_t'Val (76), wchar_t'Val (105), wchar_t'Val (115),
wchar_t'Val (116), wchar_t'Val (0));
BCRYPT_BUFFERS_LOCKED_FLAG : constant := 64;
BCRYPT_CAPI_AES_FLAG : constant := 16;
BCRYPT_CAPI_KDF_ALGORITHM : constant wchar_t_array (0 .. 8) := (
wchar_t'Val (67), wchar_t'Val (65), wchar_t'Val (80), wchar_t'Val (73),
wchar_t'Val (95), wchar_t'Val (75), wchar_t'Val (68), wchar_t'Val (70),
wchar_t'Val (0));
BCRYPT_CHAINING_MODE : constant wchar_t_array (0 .. 12) := (
wchar_t'Val (67), wchar_t'Val (104), wchar_t'Val (97),
wchar_t'Val (105), wchar_t'Val (110), wchar_t'Val (105),
wchar_t'Val (110), wchar_t'Val (103), wchar_t'Val (77),
wchar_t'Val (111), wchar_t'Val (100), wchar_t'Val (101),
wchar_t'Val (0));
BCRYPT_CHAIN_MODE_CBC : constant wchar_t_array (0 .. 15) := (
wchar_t'Val (67), wchar_t'Val (104), wchar_t'Val (97),
wchar_t'Val (105), wchar_t'Val (110), wchar_t'Val (105),
wchar_t'Val (110), wchar_t'Val (103), wchar_t'Val (77),
wchar_t'Val (111), wchar_t'Val (100), wchar_t'Val (101),
wchar_t'Val (67), wchar_t'Val (66), wchar_t'Val (67), wchar_t'Val (0));
BCRYPT_CHAIN_MODE_CCM : constant wchar_t_array (0 .. 15) := (
wchar_t'Val (67), wchar_t'Val (104), wchar_t'Val (97),
wchar_t'Val (105), wchar_t'Val (110), wchar_t'Val (105),
wchar_t'Val (110), wchar_t'Val (103), wchar_t'Val (77),
wchar_t'Val (111), wchar_t'Val (100), wchar_t'Val (101),
wchar_t'Val (67), wchar_t'Val (67), wchar_t'Val (77), wchar_t'Val (0));
BCRYPT_CHAIN_MODE_CFB : constant wchar_t_array (0 .. 15) := (
wchar_t'Val (67), wchar_t'Val (104), wchar_t'Val (97),
wchar_t'Val (105), wchar_t'Val (110), wchar_t'Val (105),
wchar_t'Val (110), wchar_t'Val (103), wchar_t'Val (77),
wchar_t'Val (111), wchar_t'Val (100), wchar_t'Val (101),
wchar_t'Val (67), wchar_t'Val (70), wchar_t'Val (66), wchar_t'Val (0));
BCRYPT_CHAIN_MODE_ECB : constant wchar_t_array (0 .. 15) := (
wchar_t'Val (67), wchar_t'Val (104), wchar_t'Val (97),
wchar_t'Val (105), wchar_t'Val (110), wchar_t'Val (105),
wchar_t'Val (110), wchar_t'Val (103), wchar_t'Val (77),
wchar_t'Val (111), wchar_t'Val (100), wchar_t'Val (101),
wchar_t'Val (69), wchar_t'Val (67), wchar_t'Val (66), wchar_t'Val (0));
BCRYPT_CHAIN_MODE_GCM : constant wchar_t_array (0 .. 15) := (
wchar_t'Val (67), wchar_t'Val (104), wchar_t'Val (97),
wchar_t'Val (105), wchar_t'Val (110), wchar_t'Val (105),
wchar_t'Val (110), wchar_t'Val (103), wchar_t'Val (77),
wchar_t'Val (111), wchar_t'Val (100), wchar_t'Val (101),
wchar_t'Val (71), wchar_t'Val (67), wchar_t'Val (77), wchar_t'Val (0));
BCRYPT_CHAIN_MODE_NA : constant wchar_t_array (0 .. 15) := (
wchar_t'Val (67), wchar_t'Val (104), wchar_t'Val (97),
wchar_t'Val (105), wchar_t'Val (110), wchar_t'Val (105),
wchar_t'Val (110), wchar_t'Val (103), wchar_t'Val (77),
wchar_t'Val (111), wchar_t'Val (100), wchar_t'Val (101),
wchar_t'Val (78), wchar_t'Val (47), wchar_t'Val (65), wchar_t'Val (0));
BCRYPT_CIPHER_INTERFACE : constant := 1;
-- BCRYPT_CIPHER_INTERFACE_VERSION_1 (plase type with #pragma instance)
BCRYPT_CIPHER_OPERATION : constant := 1;
BCRYPT_DESX_ALGORITHM : constant wchar_t_array (0 .. 4) := (
wchar_t'Val (68), wchar_t'Val (69), wchar_t'Val (83), wchar_t'Val (88),
wchar_t'Val (0));
BCRYPT_DES_ALGORITHM : constant wchar_t_array (0 .. 3) := (
wchar_t'Val (68), wchar_t'Val (69), wchar_t'Val (83), wchar_t'Val (0));
BCRYPT_DH_ALGORITHM : constant wchar_t_array (0 .. 2) := (
wchar_t'Val (68), wchar_t'Val (72), wchar_t'Val (0));
BCRYPT_DH_PARAMETERS : constant wchar_t_array (0 .. 12) := (
wchar_t'Val (68), wchar_t'Val (72), wchar_t'Val (80), wchar_t'Val (97),
wchar_t'Val (114), wchar_t'Val (97), wchar_t'Val (109),
wchar_t'Val (101), wchar_t'Val (116), wchar_t'Val (101),
wchar_t'Val (114), wchar_t'Val (115), wchar_t'Val (0));
BCRYPT_DH_PARAMETERS_MAGIC : constant := 1297107012;
BCRYPT_DH_PRIVATE_BLOB : constant wchar_t_array (0 .. 13) := (
wchar_t'Val (68), wchar_t'Val (72), wchar_t'Val (80), wchar_t'Val (82),
wchar_t'Val (73), wchar_t'Val (86), wchar_t'Val (65), wchar_t'Val (84),
wchar_t'Val (69), wchar_t'Val (66), wchar_t'Val (76), wchar_t'Val (79),
wchar_t'Val (66), wchar_t'Val (0));
BCRYPT_DH_PRIVATE_MAGIC : constant := 1448101956;
BCRYPT_DH_PUBLIC_BLOB : constant wchar_t_array (0 .. 12) := (
wchar_t'Val (68), wchar_t'Val (72), wchar_t'Val (80), wchar_t'Val (85),
wchar_t'Val (66), wchar_t'Val (76), wchar_t'Val (73), wchar_t'Val (67),
wchar_t'Val (66), wchar_t'Val (76), wchar_t'Val (79), wchar_t'Val (66),
wchar_t'Val (0));
BCRYPT_DH_PUBLIC_MAGIC : constant := 1112557636;
BCRYPT_DSA_ALGORITHM : constant wchar_t_array (0 .. 3) := (
wchar_t'Val (68), wchar_t'Val (83), wchar_t'Val (65), wchar_t'Val (0));
BCRYPT_DSA_PARAMETERS : constant wchar_t_array (0 .. 13) := (
wchar_t'Val (68), wchar_t'Val (83), wchar_t'Val (65), wchar_t'Val (80),
wchar_t'Val (97), wchar_t'Val (114), wchar_t'Val (97),
wchar_t'Val (109), wchar_t'Val (101), wchar_t'Val (116),
wchar_t'Val (101), wchar_t'Val (114), wchar_t'Val (115),
wchar_t'Val (0));
BCRYPT_DSA_PARAMETERS_MAGIC : constant := 1297109828;
BCRYPT_DSA_PARAMETERS_MAGIC_V2 : constant := 843927620;
BCRYPT_DSA_PRIVATE_BLOB : constant wchar_t_array (0 .. 14) := (
wchar_t'Val (68), wchar_t'Val (83), wchar_t'Val (65), wchar_t'Val (80),
wchar_t'Val (82), wchar_t'Val (73), wchar_t'Val (86), wchar_t'Val (65),
wchar_t'Val (84), wchar_t'Val (69), wchar_t'Val (66), wchar_t'Val (76),
wchar_t'Val (79), wchar_t'Val (66), wchar_t'Val (0));
BCRYPT_DSA_PRIVATE_MAGIC : constant := 1448104772;
BCRYPT_DSA_PRIVATE_MAGIC_V2 : constant := 844517444;
BCRYPT_DSA_PUBLIC_BLOB : constant wchar_t_array (0 .. 13) := (
wchar_t'Val (68), wchar_t'Val (83), wchar_t'Val (65), wchar_t'Val (80),
wchar_t'Val (85), wchar_t'Val (66), wchar_t'Val (76), wchar_t'Val (73),
wchar_t'Val (67), wchar_t'Val (66), wchar_t'Val (76), wchar_t'Val (79),
wchar_t'Val (66), wchar_t'Val (0));
BCRYPT_DSA_PUBLIC_MAGIC : constant := 1112560452;
BCRYPT_DSA_PUBLIC_MAGIC_V2 : constant := 843206724;
BCRYPT_ECCPRIVATE_BLOB : constant wchar_t_array (0 .. 14) := (
wchar_t'Val (69), wchar_t'Val (67), wchar_t'Val (67), wchar_t'Val (80),
wchar_t'Val (82), wchar_t'Val (73), wchar_t'Val (86), wchar_t'Val (65),
wchar_t'Val (84), wchar_t'Val (69), wchar_t'Val (66), wchar_t'Val (76),
wchar_t'Val (79), wchar_t'Val (66), wchar_t'Val (0));
BCRYPT_ECCPUBLIC_BLOB : constant wchar_t_array (0 .. 13) := (
wchar_t'Val (69), wchar_t'Val (67), wchar_t'Val (67), wchar_t'Val (80),
wchar_t'Val (85), wchar_t'Val (66), wchar_t'Val (76), wchar_t'Val (73),
wchar_t'Val (67), wchar_t'Val (66), wchar_t'Val (76), wchar_t'Val (79),
wchar_t'Val (66), wchar_t'Val (0));
BCRYPT_ECDH_P256_ALGORITHM : constant wchar_t_array (0 .. 9) := (
wchar_t'Val (69), wchar_t'Val (67), wchar_t'Val (68), wchar_t'Val (72),
wchar_t'Val (95), wchar_t'Val (80), wchar_t'Val (50), wchar_t'Val (53),
wchar_t'Val (54), wchar_t'Val (0));
BCRYPT_ECDH_P384_ALGORITHM : constant wchar_t_array (0 .. 9) := (
wchar_t'Val (69), wchar_t'Val (67), wchar_t'Val (68), wchar_t'Val (72),
wchar_t'Val (95), wchar_t'Val (80), wchar_t'Val (51), wchar_t'Val (56),
wchar_t'Val (52), wchar_t'Val (0));
BCRYPT_ECDH_P521_ALGORITHM : constant wchar_t_array (0 .. 9) := (
wchar_t'Val (69), wchar_t'Val (67), wchar_t'Val (68), wchar_t'Val (72),
wchar_t'Val (95), wchar_t'Val (80), wchar_t'Val (53), wchar_t'Val (50),
wchar_t'Val (49), wchar_t'Val (0));
BCRYPT_ECDH_PRIVATE_P256_MAGIC : constant := 843793221;
BCRYPT_ECDH_PRIVATE_P384_MAGIC : constant := 877347653;
BCRYPT_ECDH_PRIVATE_P521_MAGIC : constant := 910902085;
BCRYPT_ECDH_PUBLIC_P256_MAGIC : constant := 827016005;
BCRYPT_ECDH_PUBLIC_P384_MAGIC : constant := 860570437;
BCRYPT_ECDH_PUBLIC_P521_MAGIC : constant := 894124869;
BCRYPT_ECDSA_P256_ALGORITHM : constant wchar_t_array (0 .. 10) := (
wchar_t'Val (69), wchar_t'Val (67), wchar_t'Val (68), wchar_t'Val (83),
wchar_t'Val (65), wchar_t'Val (95), wchar_t'Val (80), wchar_t'Val (50),
wchar_t'Val (53), wchar_t'Val (54), wchar_t'Val (0));
BCRYPT_ECDSA_P384_ALGORITHM : constant wchar_t_array (0 .. 10) := (
wchar_t'Val (69), wchar_t'Val (67), wchar_t'Val (68), wchar_t'Val (83),
wchar_t'Val (65), wchar_t'Val (95), wchar_t'Val (80), wchar_t'Val (51),
wchar_t'Val (56), wchar_t'Val (52), wchar_t'Val (0));
BCRYPT_ECDSA_P521_ALGORITHM : constant wchar_t_array (0 .. 10) := (
wchar_t'Val (69), wchar_t'Val (67), wchar_t'Val (68), wchar_t'Val (83),
wchar_t'Val (65), wchar_t'Val (95), wchar_t'Val (80), wchar_t'Val (53),
wchar_t'Val (50), wchar_t'Val (49), wchar_t'Val (0));
BCRYPT_ECDSA_PRIVATE_P256_MAGIC : constant := 844317509;
BCRYPT_ECDSA_PRIVATE_P384_MAGIC : constant := 877871941;
BCRYPT_ECDSA_PRIVATE_P521_MAGIC : constant := 911426373;
BCRYPT_ECDSA_PUBLIC_P256_MAGIC : constant := 827540293;
BCRYPT_ECDSA_PUBLIC_P384_MAGIC : constant := 861094725;
BCRYPT_ECDSA_PUBLIC_P521_MAGIC : constant := 894649157;
BCRYPT_EFFECTIVE_KEY_LENGTH : constant wchar_t_array (0 .. 18) := (
wchar_t'Val (69), wchar_t'Val (102), wchar_t'Val (102),
wchar_t'Val (101), wchar_t'Val (99), wchar_t'Val (116),
wchar_t'Val (105), wchar_t'Val (118), wchar_t'Val (101),
wchar_t'Val (75), wchar_t'Val (101), wchar_t'Val (121),
wchar_t'Val (76), wchar_t'Val (101), wchar_t'Val (110),
wchar_t'Val (103), wchar_t'Val (116), wchar_t'Val (104),
wchar_t'Val (0));
BCRYPT_GLOBAL_PARAMETERS : constant wchar_t_array (0 .. 20) := (
wchar_t'Val (83), wchar_t'Val (101), wchar_t'Val (99),
wchar_t'Val (114), wchar_t'Val (101), wchar_t'Val (116),
wchar_t'Val (65), wchar_t'Val (103), wchar_t'Val (114),
wchar_t'Val (101), wchar_t'Val (101), wchar_t'Val (109),
wchar_t'Val (101), wchar_t'Val (110), wchar_t'Val (116),
wchar_t'Val (80), wchar_t'Val (97), wchar_t'Val (114),
wchar_t'Val (97), wchar_t'Val (109), wchar_t'Val (0));
BCRYPT_HASH_BLOCK_LENGTH : constant wchar_t_array (0 .. 15) := (
wchar_t'Val (72), wchar_t'Val (97), wchar_t'Val (115),
wchar_t'Val (104), wchar_t'Val (66), wchar_t'Val (108),
wchar_t'Val (111), wchar_t'Val (99), wchar_t'Val (107),
wchar_t'Val (76), wchar_t'Val (101), wchar_t'Val (110),
wchar_t'Val (103), wchar_t'Val (116), wchar_t'Val (104),
wchar_t'Val (0));
BCRYPT_HASH_INTERFACE : constant := 2;
-- BCRYPT_HASH_INTERFACE_VERSION_1 (plase type with #pragma instance)
BCRYPT_HASH_LENGTH : constant wchar_t_array (0 .. 16) := (
wchar_t'Val (72), wchar_t'Val (97), wchar_t'Val (115),
wchar_t'Val (104), wchar_t'Val (68), wchar_t'Val (105),
wchar_t'Val (103), wchar_t'Val (101), wchar_t'Val (115),
wchar_t'Val (116), wchar_t'Val (76), wchar_t'Val (101),
wchar_t'Val (110), wchar_t'Val (103), wchar_t'Val (116),
wchar_t'Val (104), wchar_t'Val (0));
BCRYPT_HASH_OID_LIST : constant wchar_t_array (0 .. 11) := (
wchar_t'Val (72), wchar_t'Val (97), wchar_t'Val (115),
wchar_t'Val (104), wchar_t'Val (79), wchar_t'Val (73),
wchar_t'Val (68), wchar_t'Val (76), wchar_t'Val (105),
wchar_t'Val (115), wchar_t'Val (116), wchar_t'Val (0));
BCRYPT_HASH_OPERATION : constant := 2;
BCRYPT_HASH_REUSABLE_FLAG : constant := 32;
BCRYPT_INITIALIZATION_VECTOR : constant wchar_t_array (0 .. 2) := (
wchar_t'Val (73), wchar_t'Val (86), wchar_t'Val (0));
-- BCRYPT_INIT_AUTH_MODE_INFO (unparsible)
-- BCRYPT_IS_INTERFACE_VERSION_COMPATIBLE (uninterpretable)
BCRYPT_IS_KEYED_HASH : constant wchar_t_array (0 .. 11) := (
wchar_t'Val (73), wchar_t'Val (115), wchar_t'Val (75),
wchar_t'Val (101), wchar_t'Val (121), wchar_t'Val (101),
wchar_t'Val (100), wchar_t'Val (72), wchar_t'Val (97),
wchar_t'Val (115), wchar_t'Val (104), wchar_t'Val (0));
BCRYPT_IS_REUSABLE_HASH : constant wchar_t_array (0 .. 14) := (
wchar_t'Val (73), wchar_t'Val (115), wchar_t'Val (82),
wchar_t'Val (101), wchar_t'Val (117), wchar_t'Val (115),
wchar_t'Val (97), wchar_t'Val (98), wchar_t'Val (108),
wchar_t'Val (101), wchar_t'Val (72), wchar_t'Val (97),
wchar_t'Val (115), wchar_t'Val (104), wchar_t'Val (0));
BCRYPT_KDF_HASH : constant wchar_t_array (0 .. 4) := (wchar_t'Val (72),
wchar_t'Val (65), wchar_t'Val (83), wchar_t'Val (72), wchar_t'Val (0));
BCRYPT_KDF_HMAC : constant wchar_t_array (0 .. 4) := (wchar_t'Val (72),
wchar_t'Val (77), wchar_t'Val (65), wchar_t'Val (67), wchar_t'Val (0));
BCRYPT_KDF_SP80056A_CONCAT : constant wchar_t_array (0 .. 16) := (
wchar_t'Val (83), wchar_t'Val (80), wchar_t'Val (56), wchar_t'Val (48),
wchar_t'Val (48), wchar_t'Val (95), wchar_t'Val (53), wchar_t'Val (54),
wchar_t'Val (65), wchar_t'Val (95), wchar_t'Val (67), wchar_t'Val (79),
wchar_t'Val (78), wchar_t'Val (67), wchar_t'Val (65), wchar_t'Val (84),
wchar_t'Val (0));
BCRYPT_KDF_TLS_PRF : constant wchar_t_array (0 .. 7) := (wchar_t'Val (84),
wchar_t'Val (76), wchar_t'Val (83), wchar_t'Val (95), wchar_t'Val (80),
wchar_t'Val (82), wchar_t'Val (70), wchar_t'Val (0));
BCRYPT_KEY_DATA_BLOB : constant wchar_t_array (0 .. 11) := (
wchar_t'Val (75), wchar_t'Val (101), wchar_t'Val (121),
wchar_t'Val (68), wchar_t'Val (97), wchar_t'Val (116),
wchar_t'Val (97), wchar_t'Val (66), wchar_t'Val (108),
wchar_t'Val (111), wchar_t'Val (98), wchar_t'Val (0));
BCRYPT_KEY_DATA_BLOB_MAGIC : constant := 1296188491;
BCRYPT_KEY_DATA_BLOB_VERSION1 : constant := 1;
BCRYPT_KEY_DERIVATION_INTERFACE : constant := 7;
BCRYPT_KEY_DERIVATION_OPERATION : constant := 64;
BCRYPT_KEY_LENGTH : constant wchar_t_array (0 .. 9) := (wchar_t'Val (75),
wchar_t'Val (101), wchar_t'Val (121), wchar_t'Val (76),
wchar_t'Val (101), wchar_t'Val (110), wchar_t'Val (103),
wchar_t'Val (116), wchar_t'Val (104), wchar_t'Val (0));
BCRYPT_KEY_LENGTHS : constant wchar_t_array (0 .. 10) := (
wchar_t'Val (75), wchar_t'Val (101), wchar_t'Val (121),
wchar_t'Val (76), wchar_t'Val (101), wchar_t'Val (110),
wchar_t'Val (103), wchar_t'Val (116), wchar_t'Val (104),
wchar_t'Val (115), wchar_t'Val (0));
BCRYPT_KEY_OBJECT_LENGTH : constant wchar_t_array (0 .. 15) := (
wchar_t'Val (75), wchar_t'Val (101), wchar_t'Val (121),
wchar_t'Val (79), wchar_t'Val (98), wchar_t'Val (106),
wchar_t'Val (101), wchar_t'Val (99), wchar_t'Val (116),
wchar_t'Val (76), wchar_t'Val (101), wchar_t'Val (110),
wchar_t'Val (103), wchar_t'Val (116), wchar_t'Val (104),
wchar_t'Val (0));
BCRYPT_KEY_STRENGTH : constant wchar_t_array (0 .. 11) := (
wchar_t'Val (75), wchar_t'Val (101), wchar_t'Val (121),
wchar_t'Val (83), wchar_t'Val (116), wchar_t'Val (114),
wchar_t'Val (101), wchar_t'Val (110), wchar_t'Val (103),
wchar_t'Val (116), wchar_t'Val (104), wchar_t'Val (0));
-- BCRYPT_MAKE_INTERFACE_VERSION (unparsible)
BCRYPT_MD2_ALGORITHM : constant wchar_t_array (0 .. 3) := (
wchar_t'Val (77), wchar_t'Val (68), wchar_t'Val (50), wchar_t'Val (0));
BCRYPT_MD4_ALGORITHM : constant wchar_t_array (0 .. 3) := (
wchar_t'Val (77), wchar_t'Val (68), wchar_t'Val (52), wchar_t'Val (0));
BCRYPT_MD5_ALGORITHM : constant wchar_t_array (0 .. 3) := (
wchar_t'Val (77), wchar_t'Val (68), wchar_t'Val (53), wchar_t'Val (0));
BCRYPT_MESSAGE_BLOCK_LENGTH : constant wchar_t_array (0 .. 18) := (
wchar_t'Val (77), wchar_t'Val (101), wchar_t'Val (115),
wchar_t'Val (115), wchar_t'Val (97), wchar_t'Val (103),
wchar_t'Val (101), wchar_t'Val (66), wchar_t'Val (108),
wchar_t'Val (111), wchar_t'Val (99), wchar_t'Val (107),
wchar_t'Val (76), wchar_t'Val (101), wchar_t'Val (110),
wchar_t'Val (103), wchar_t'Val (116), wchar_t'Val (104),
wchar_t'Val (0));
BCRYPT_NO_KEY_VALIDATION : constant := 8;
BCRYPT_OBJECT_ALIGNMENT : constant := 16;
BCRYPT_OBJECT_LENGTH : constant wchar_t_array (0 .. 12) := (
wchar_t'Val (79), wchar_t'Val (98), wchar_t'Val (106),
wchar_t'Val (101), wchar_t'Val (99), wchar_t'Val (116),
wchar_t'Val (76), wchar_t'Val (101), wchar_t'Val (110),
wchar_t'Val (103), wchar_t'Val (116), wchar_t'Val (104),
wchar_t'Val (0));
BCRYPT_OPAQUE_KEY_BLOB : constant wchar_t_array (0 .. 13) := (
wchar_t'Val (79), wchar_t'Val (112), wchar_t'Val (97),
wchar_t'Val (113), wchar_t'Val (117), wchar_t'Val (101),
wchar_t'Val (75), wchar_t'Val (101), wchar_t'Val (121),
wchar_t'Val (66), wchar_t'Val (108), wchar_t'Val (111),
wchar_t'Val (98), wchar_t'Val (0));
BCRYPT_PADDING_SCHEMES : constant wchar_t_array (0 .. 14) := (
wchar_t'Val (80), wchar_t'Val (97), wchar_t'Val (100),
wchar_t'Val (100), wchar_t'Val (105), wchar_t'Val (110),
wchar_t'Val (103), wchar_t'Val (83), wchar_t'Val (99),
wchar_t'Val (104), wchar_t'Val (101), wchar_t'Val (109),
wchar_t'Val (101), wchar_t'Val (115), wchar_t'Val (0));
BCRYPT_PAD_NONE : constant := 1;
BCRYPT_PAD_OAEP : constant := 4;
BCRYPT_PAD_PKCS1 : constant := 2;
BCRYPT_PAD_PSS : constant := 8;
BCRYPT_PBKDF2_ALGORITHM : constant wchar_t_array (0 .. 6) := (
wchar_t'Val (80), wchar_t'Val (66), wchar_t'Val (75), wchar_t'Val (68),
wchar_t'Val (70), wchar_t'Val (50), wchar_t'Val (0));
BCRYPT_PCP_PLATFORM_TYPE_PROPERTY : constant wchar_t_array (0 .. 17) := (
wchar_t'Val (80), wchar_t'Val (67), wchar_t'Val (80), wchar_t'Val (95),
wchar_t'Val (80), wchar_t'Val (76), wchar_t'Val (65), wchar_t'Val (84),
wchar_t'Val (70), wchar_t'Val (79), wchar_t'Val (82), wchar_t'Val (77),
wchar_t'Val (95), wchar_t'Val (84), wchar_t'Val (89), wchar_t'Val (80),
wchar_t'Val (69), wchar_t'Val (0));
BCRYPT_PCP_PROVIDER_VERSION_PROPERTY : constant wchar_t_array (0 .. 20) :=
(wchar_t'Val (80), wchar_t'Val (67), wchar_t'Val (80),
wchar_t'Val (95), wchar_t'Val (80), wchar_t'Val (82), wchar_t'Val (79),
wchar_t'Val (86), wchar_t'Val (73), wchar_t'Val (68), wchar_t'Val (69),
wchar_t'Val (82), wchar_t'Val (95), wchar_t'Val (86), wchar_t'Val (69),
wchar_t'Val (82), wchar_t'Val (83), wchar_t'Val (73), wchar_t'Val (79),
wchar_t'Val (78), wchar_t'Val (0));
BCRYPT_PRIMITIVE_TYPE : constant wchar_t_array (0 .. 13) := (
wchar_t'Val (80), wchar_t'Val (114), wchar_t'Val (105),
wchar_t'Val (109), wchar_t'Val (105), wchar_t'Val (116),
wchar_t'Val (105), wchar_t'Val (118), wchar_t'Val (101),
wchar_t'Val (84), wchar_t'Val (121), wchar_t'Val (112),
wchar_t'Val (101), wchar_t'Val (0));
BCRYPT_PRIVATE_KEY : constant wchar_t_array (0 .. 10) := (
wchar_t'Val (80), wchar_t'Val (114), wchar_t'Val (105),
wchar_t'Val (118), wchar_t'Val (75), wchar_t'Val (101),
wchar_t'Val (121), wchar_t'Val (86), wchar_t'Val (97),
wchar_t'Val (108), wchar_t'Val (0));
BCRYPT_PRIVATE_KEY_BLOB : constant wchar_t_array (0 .. 11) := (
wchar_t'Val (80), wchar_t'Val (82), wchar_t'Val (73), wchar_t'Val (86),
wchar_t'Val (65), wchar_t'Val (84), wchar_t'Val (69), wchar_t'Val (66),
wchar_t'Val (76), wchar_t'Val (79), wchar_t'Val (66), wchar_t'Val (0));
BCRYPT_PRIVATE_KEY_FLAG : constant := 2;
BCRYPT_PROVIDER_HANDLE : constant wchar_t_array (0 .. 14) := (
wchar_t'Val (80), wchar_t'Val (114), wchar_t'Val (111),
wchar_t'Val (118), wchar_t'Val (105), wchar_t'Val (100),
wchar_t'Val (101), wchar_t'Val (114), wchar_t'Val (72),
wchar_t'Val (97), wchar_t'Val (110), wchar_t'Val (100),
wchar_t'Val (108), wchar_t'Val (101), wchar_t'Val (0));
BCRYPT_PROV_DISPATCH : constant := 1;
BCRYPT_PUBLIC_KEY_BLOB : constant wchar_t_array (0 .. 10) := (
wchar_t'Val (80), wchar_t'Val (85), wchar_t'Val (66), wchar_t'Val (76),
wchar_t'Val (73), wchar_t'Val (67), wchar_t'Val (66), wchar_t'Val (76),
wchar_t'Val (79), wchar_t'Val (66), wchar_t'Val (0));
BCRYPT_PUBLIC_KEY_FLAG : constant := 1;
BCRYPT_RC2_ALGORITHM : constant wchar_t_array (0 .. 3) := (
wchar_t'Val (82), wchar_t'Val (67), wchar_t'Val (50), wchar_t'Val (0));
BCRYPT_RC4_ALGORITHM : constant wchar_t_array (0 .. 3) := (
wchar_t'Val (82), wchar_t'Val (67), wchar_t'Val (52), wchar_t'Val (0));
BCRYPT_RNG_ALGORITHM : constant wchar_t_array (0 .. 3) := (
wchar_t'Val (82), wchar_t'Val (78), wchar_t'Val (71), wchar_t'Val (0));
BCRYPT_RNG_DUAL_EC_ALGORITHM : constant wchar_t_array (0 .. 9) := (
wchar_t'Val (68), wchar_t'Val (85), wchar_t'Val (65), wchar_t'Val (76),
wchar_t'Val (69), wchar_t'Val (67), wchar_t'Val (82), wchar_t'Val (78),
wchar_t'Val (71), wchar_t'Val (0));
BCRYPT_RNG_FIPS186_DSA_ALGORITHM : constant wchar_t_array (0 .. 13) := (
wchar_t'Val (70), wchar_t'Val (73), wchar_t'Val (80), wchar_t'Val (83),
wchar_t'Val (49), wchar_t'Val (56), wchar_t'Val (54), wchar_t'Val (68),
wchar_t'Val (83), wchar_t'Val (65), wchar_t'Val (82), wchar_t'Val (78),
wchar_t'Val (71), wchar_t'Val (0));
BCRYPT_RNG_INTERFACE : constant := 6;
-- BCRYPT_RNG_INTERFACE_VERSION_1 (plase type with #pragma instance)
BCRYPT_RNG_OPERATION : constant := 32;
BCRYPT_RNG_USE_ENTROPY_IN_BUFFER : constant := 1;
BCRYPT_RSAFULLPRIVATE_BLOB : constant wchar_t_array (0 .. 18) := (
wchar_t'Val (82), wchar_t'Val (83), wchar_t'Val (65), wchar_t'Val (70),
wchar_t'Val (85), wchar_t'Val (76), wchar_t'Val (76), wchar_t'Val (80),
wchar_t'Val (82), wchar_t'Val (73), wchar_t'Val (86), wchar_t'Val (65),
wchar_t'Val (84), wchar_t'Val (69), wchar_t'Val (66), wchar_t'Val (76),
wchar_t'Val (79), wchar_t'Val (66), wchar_t'Val (0));
BCRYPT_RSAFULLPRIVATE_MAGIC : constant := 859919186;
BCRYPT_RSAPRIVATE_BLOB : constant wchar_t_array (0 .. 14) := (
wchar_t'Val (82), wchar_t'Val (83), wchar_t'Val (65), wchar_t'Val (80),
wchar_t'Val (82), wchar_t'Val (73), wchar_t'Val (86), wchar_t'Val (65),
wchar_t'Val (84), wchar_t'Val (69), wchar_t'Val (66), wchar_t'Val (76),
wchar_t'Val (79), wchar_t'Val (66), wchar_t'Val (0));
BCRYPT_RSAPRIVATE_MAGIC : constant := 843141970;
BCRYPT_RSAPUBLIC_BLOB : constant wchar_t_array (0 .. 13) := (
wchar_t'Val (82), wchar_t'Val (83), wchar_t'Val (65), wchar_t'Val (80),
wchar_t'Val (85), wchar_t'Val (66), wchar_t'Val (76), wchar_t'Val (73),
wchar_t'Val (67), wchar_t'Val (66), wchar_t'Val (76), wchar_t'Val (79),
wchar_t'Val (66), wchar_t'Val (0));
BCRYPT_RSAPUBLIC_MAGIC : constant := 826364754;
BCRYPT_RSA_ALGORITHM : constant wchar_t_array (0 .. 3) := (
wchar_t'Val (82), wchar_t'Val (83), wchar_t'Val (65), wchar_t'Val (0));
BCRYPT_RSA_SIGN_ALGORITHM : constant wchar_t_array (0 .. 8) := (
wchar_t'Val (82), wchar_t'Val (83), wchar_t'Val (65), wchar_t'Val (95),
wchar_t'Val (83), wchar_t'Val (73), wchar_t'Val (71), wchar_t'Val (78),
wchar_t'Val (0));
BCRYPT_SECRET_AGREEMENT_INTERFACE : constant := 4;
-- BCRYPT_SECRET_AGREEMENT_INTERFACE_... (plase type with #pragma instance)
BCRYPT_SECRET_AGREEMENT_OPERATION : constant := 8;
BCRYPT_SHA1_ALGORITHM : constant wchar_t_array (0 .. 4) := (
wchar_t'Val (83), wchar_t'Val (72), wchar_t'Val (65), wchar_t'Val (49),
wchar_t'Val (0));
BCRYPT_SHA256_ALGORITHM : constant wchar_t_array (0 .. 6) := (
wchar_t'Val (83), wchar_t'Val (72), wchar_t'Val (65), wchar_t'Val (50),
wchar_t'Val (53), wchar_t'Val (54), wchar_t'Val (0));
BCRYPT_SHA384_ALGORITHM : constant wchar_t_array (0 .. 6) := (
wchar_t'Val (83), wchar_t'Val (72), wchar_t'Val (65), wchar_t'Val (51),
wchar_t'Val (56), wchar_t'Val (52), wchar_t'Val (0));
BCRYPT_SHA512_ALGORITHM : constant wchar_t_array (0 .. 6) := (
wchar_t'Val (83), wchar_t'Val (72), wchar_t'Val (65), wchar_t'Val (53),
wchar_t'Val (49), wchar_t'Val (50), wchar_t'Val (0));
BCRYPT_SIGNATURE_INTERFACE : constant := 5;
-- BCRYPT_SIGNATURE_INTERFACE_VERSION_1 (plase type with #pragma instance)
BCRYPT_SIGNATURE_LENGTH : constant wchar_t_array (0 .. 15) := (
wchar_t'Val (83), wchar_t'Val (105), wchar_t'Val (103),
wchar_t'Val (110), wchar_t'Val (97), wchar_t'Val (116),
wchar_t'Val (117), wchar_t'Val (114), wchar_t'Val (101),
wchar_t'Val (76), wchar_t'Val (101), wchar_t'Val (110),
wchar_t'Val (103), wchar_t'Val (116), wchar_t'Val (104),
wchar_t'Val (0));
BCRYPT_SIGNATURE_OPERATION : constant := 16;
BCRYPT_SP800108_CTR_HMAC_ALGORITHM : constant wchar_t_array (0 .. 18) := (
wchar_t'Val (83), wchar_t'Val (80), wchar_t'Val (56), wchar_t'Val (48),
wchar_t'Val (48), wchar_t'Val (95), wchar_t'Val (49), wchar_t'Val (48),
wchar_t'Val (56), wchar_t'Val (95), wchar_t'Val (67), wchar_t'Val (84),
wchar_t'Val (82), wchar_t'Val (95), wchar_t'Val (72), wchar_t'Val (77),
wchar_t'Val (65), wchar_t'Val (67), wchar_t'Val (0));
BCRYPT_SP80056A_CONCAT_ALGORITHM : constant wchar_t_array (0 .. 16) := (
wchar_t'Val (83), wchar_t'Val (80), wchar_t'Val (56), wchar_t'Val (48),
wchar_t'Val (48), wchar_t'Val (95), wchar_t'Val (53), wchar_t'Val (54),
wchar_t'Val (65), wchar_t'Val (95), wchar_t'Val (67), wchar_t'Val (79),
wchar_t'Val (78), wchar_t'Val (67), wchar_t'Val (65), wchar_t'Val (84),
wchar_t'Val (0));
-- BCRYPT_STRUCT_ALIGNMENT (empty)
-- BCRYPT_SUCCESS (function macro)
BCRYPT_SUPPORTED_PAD_OAEP : constant := 8;
BCRYPT_SUPPORTED_PAD_PKCS1_ENC : constant := 2;
BCRYPT_SUPPORTED_PAD_PKCS1_SIG : constant := 4;
BCRYPT_SUPPORTED_PAD_PSS : constant := 16;
BCRYPT_SUPPORTED_PAD_ROUTER : constant := 1;
BCRYPT_USE_SYSTEM_PREFERRED_RNG : constant := 2;
CRYPT_ALL_FUNCTIONS : constant := 1;
CRYPT_ALL_PROVIDERS : constant := 2;
CRYPT_ANY : constant := 4;
CRYPT_DEFAULT_CONTEXT : constant wchar_t_array (0 .. 7) := (
wchar_t'Val (68), wchar_t'Val (101), wchar_t'Val (102),
wchar_t'Val (97), wchar_t'Val (117), wchar_t'Val (108),
wchar_t'Val (116), wchar_t'Val (0));
CRYPT_DOMAIN : constant := 2;
CRYPT_EXCLUSIVE : constant := 1;
CRYPT_KM : constant := 2;
CRYPT_LOCAL : constant := 1;
CRYPT_MIN_DEPENDENCIES : constant := 1;
CRYPT_MM : constant := 3;
CRYPT_OVERRIDE : constant := 65536;
CRYPT_OVERWRITE : constant := 1;
CRYPT_PRIORITY_BOTTOM : constant := -1;
CRYPT_PRIORITY_TOP : constant := 0;
CRYPT_PROCESS_ISOLATE : constant := 65536;
CRYPT_UM : constant := 1;
KDF_ALGORITHMID : constant := 8;
KDF_CONTEXT : constant := 14;
KDF_GENERIC_PARAMETER : constant := 17;
KDF_HASH_ALGORITHM : constant := 0;
KDF_HMAC_KEY : constant := 3;
KDF_ITERATION_COUNT : constant := 16;
KDF_KEYBITLENGTH : constant := 18;
KDF_LABEL : constant := 13;
KDF_PARTYUINFO : constant := 9;
KDF_PARTYVINFO : constant := 10;
KDF_SALT : constant := 15;
KDF_SECRET_APPEND : constant := 2;
KDF_SECRET_HANDL : constant := 6;
KDF_SECRET_PREPEND : constant := 1;
KDF_SUPPPRIVINFO : constant := 12;
KDF_SUPPPUBINFO : constant := 11;
KDF_TLS_PRF_LABEL : constant := 4;
KDF_TLS_PRF_PROTOCOL : constant := 7;
KDF_TLS_PRF_SEED : constant := 5;
KDF_USE_SECRET_AS_HMAC_KEY_FLAG : constant := 1;
LEGACY_DH_PRIVATE_BLOB : constant wchar_t_array (0 .. 17) := (
wchar_t'Val (67), wchar_t'Val (65), wchar_t'Val (80), wchar_t'Val (73),
wchar_t'Val (68), wchar_t'Val (72), wchar_t'Val (80), wchar_t'Val (82),
wchar_t'Val (73), wchar_t'Val (86), wchar_t'Val (65), wchar_t'Val (84),
wchar_t'Val (69), wchar_t'Val (66), wchar_t'Val (76), wchar_t'Val (79),
wchar_t'Val (66), wchar_t'Val (0));
LEGACY_DH_PUBLIC_BLOB : constant wchar_t_array (0 .. 16) := (
wchar_t'Val (67), wchar_t'Val (65), wchar_t'Val (80), wchar_t'Val (73),
wchar_t'Val (68), wchar_t'Val (72), wchar_t'Val (80), wchar_t'Val (85),
wchar_t'Val (66), wchar_t'Val (76), wchar_t'Val (73), wchar_t'Val (67),
wchar_t'Val (66), wchar_t'Val (76), wchar_t'Val (79), wchar_t'Val (66),
wchar_t'Val (0));
LEGACY_DSA_PRIVATE_BLOB : constant wchar_t_array (0 .. 18) := (
wchar_t'Val (67), wchar_t'Val (65), wchar_t'Val (80), wchar_t'Val (73),
wchar_t'Val (68), wchar_t'Val (83), wchar_t'Val (65), wchar_t'Val (80),
wchar_t'Val (82), wchar_t'Val (73), wchar_t'Val (86), wchar_t'Val (65),
wchar_t'Val (84), wchar_t'Val (69), wchar_t'Val (66), wchar_t'Val (76),
wchar_t'Val (79), wchar_t'Val (66), wchar_t'Val (0));
LEGACY_DSA_PUBLIC_BLOB : constant wchar_t_array (0 .. 17) := (
wchar_t'Val (67), wchar_t'Val (65), wchar_t'Val (80), wchar_t'Val (73),
wchar_t'Val (68), wchar_t'Val (83), wchar_t'Val (65), wchar_t'Val (80),
wchar_t'Val (85), wchar_t'Val (66), wchar_t'Val (76), wchar_t'Val (73),
wchar_t'Val (67), wchar_t'Val (66), wchar_t'Val (76), wchar_t'Val (79),
wchar_t'Val (66), wchar_t'Val (0));
LEGACY_DSA_V2_PRIVATE_BLOB : constant wchar_t_array (0 .. 20) := (
wchar_t'Val (86), wchar_t'Val (50), wchar_t'Val (67), wchar_t'Val (65),
wchar_t'Val (80), wchar_t'Val (73), wchar_t'Val (68), wchar_t'Val (83),
wchar_t'Val (65), wchar_t'Val (80), wchar_t'Val (82), wchar_t'Val (73),
wchar_t'Val (86), wchar_t'Val (65), wchar_t'Val (84), wchar_t'Val (69),
wchar_t'Val (66), wchar_t'Val (76), wchar_t'Val (79), wchar_t'Val (66),
wchar_t'Val (0));
LEGACY_DSA_V2_PUBLIC_BLOB : constant wchar_t_array (0 .. 19) := (
wchar_t'Val (86), wchar_t'Val (50), wchar_t'Val (67), wchar_t'Val (65),
wchar_t'Val (80), wchar_t'Val (73), wchar_t'Val (68), wchar_t'Val (83),
wchar_t'Val (65), wchar_t'Val (80), wchar_t'Val (85), wchar_t'Val (66),
wchar_t'Val (76), wchar_t'Val (73), wchar_t'Val (67), wchar_t'Val (66),
wchar_t'Val (76), wchar_t'Val (79), wchar_t'Val (66), wchar_t'Val (0));
LEGACY_RSAPRIVATE_BLOB : constant wchar_t_array (0 .. 15) := (
wchar_t'Val (67), wchar_t'Val (65), wchar_t'Val (80), wchar_t'Val (73),
wchar_t'Val (80), wchar_t'Val (82), wchar_t'Val (73), wchar_t'Val (86),
wchar_t'Val (65), wchar_t'Val (84), wchar_t'Val (69), wchar_t'Val (66),
wchar_t'Val (76), wchar_t'Val (79), wchar_t'Val (66), wchar_t'Val (0));
LEGACY_RSAPUBLIC_BLOB : constant wchar_t_array (0 .. 14) := (
wchar_t'Val (67), wchar_t'Val (65), wchar_t'Val (80), wchar_t'Val (73),
wchar_t'Val (80), wchar_t'Val (85), wchar_t'Val (66), wchar_t'Val (76),
wchar_t'Val (73), wchar_t'Val (67), wchar_t'Val (66), wchar_t'Val (76),
wchar_t'Val (79), wchar_t'Val (66), wchar_t'Val (0));
MS_PLATFORM_CRYPTO_PROVIDER : constant wchar_t_array (0 .. 34) := (
wchar_t'Val (77), wchar_t'Val (105), wchar_t'Val (99),
wchar_t'Val (114), wchar_t'Val (111), wchar_t'Val (115),
wchar_t'Val (111), wchar_t'Val (102), wchar_t'Val (116),
wchar_t'Val (32), wchar_t'Val (80), wchar_t'Val (108),
wchar_t'Val (97), wchar_t'Val (116), wchar_t'Val (102),
wchar_t'Val (111), wchar_t'Val (114), wchar_t'Val (109),
wchar_t'Val (32), wchar_t'Val (67), wchar_t'Val (114),
wchar_t'Val (121), wchar_t'Val (112), wchar_t'Val (116),
wchar_t'Val (111), wchar_t'Val (32), wchar_t'Val (80),
wchar_t'Val (114), wchar_t'Val (111), wchar_t'Val (118),
wchar_t'Val (105), wchar_t'Val (100), wchar_t'Val (101),
wchar_t'Val (114), wchar_t'Val (0));
MS_PRIMITIVE_PROVIDER : constant wchar_t_array (0 .. 28) := (
wchar_t'Val (77), wchar_t'Val (105), wchar_t'Val (99),
wchar_t'Val (114), wchar_t'Val (111), wchar_t'Val (115),
wchar_t'Val (111), wchar_t'Val (102), wchar_t'Val (116),
wchar_t'Val (32), wchar_t'Val (80), wchar_t'Val (114),
wchar_t'Val (105), wchar_t'Val (109), wchar_t'Val (105),
wchar_t'Val (116), wchar_t'Val (105), wchar_t'Val (118),
wchar_t'Val (101), wchar_t'Val (32), wchar_t'Val (80),
wchar_t'Val (114), wchar_t'Val (111), wchar_t'Val (118),
wchar_t'Val (105), wchar_t'Val (100), wchar_t'Val (101),
wchar_t'Val (114), wchar_t'Val (0));
-- _INC_BCRYPT (empty)
end C.bcrypt;
Raw
c-crtdefs.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
with C.qmingw;
package C.crtdefs is
pragma Preelaborate;
subtype rsize_t is qmingw.size_t;
type struct_threadlocaleinfostruct;
type struct_threadlocaleinfostruct_ptr is
access all struct_threadlocaleinfostruct;
for struct_threadlocaleinfostruct_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_threadlocaleinfostruct_ptr);
pragma Convention (C, struct_threadlocaleinfostruct_ptr);
type struct_threadmbcinfostruct (<>) is limited private;
type struct_threadmbcinfostruct_ptr is
access all struct_threadmbcinfostruct;
for struct_threadmbcinfostruct_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_threadmbcinfostruct_ptr);
pragma Convention (C, struct_threadmbcinfostruct_ptr);
subtype pthreadlocinfo is struct_threadlocaleinfostruct_ptr;
subtype pthreadmbcinfo is struct_threadmbcinfostruct_ptr;
type struct_lc_time_data (<>) is limited private;
type struct_lc_time_data_ptr is access all struct_lc_time_data;
for struct_lc_time_data_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_lc_time_data_ptr);
pragma Convention (C, struct_lc_time_data_ptr);
type struct_localeinfo_struct;
type struct_localeinfo_struct is record
locinfo : aliased pthreadlocinfo;
mbcinfo : aliased pthreadmbcinfo;
end record;
pragma Convention (C_Pass_By_Copy, struct_localeinfo_struct);
type struct_localeinfo_struct_ptr is access all struct_localeinfo_struct;
for struct_localeinfo_struct_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_localeinfo_struct_ptr);
pragma Convention (C, struct_localeinfo_struct_ptr);
subtype locale_tstruct is struct_localeinfo_struct;
subtype locale_t is struct_localeinfo_struct_ptr;
type struct_tagLC_ID;
type struct_tagLC_ID is record
wLanguage : aliased unsigned_short;
wCountry : aliased unsigned_short;
wCodePage : aliased unsigned_short;
end record;
pragma Convention (C_Pass_By_Copy, struct_tagLC_ID);
type struct_tagLC_ID_ptr is access all struct_tagLC_ID;
for struct_tagLC_ID_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_tagLC_ID_ptr);
pragma Convention (C, struct_tagLC_ID_ptr);
type struct_tagLC_ID_array is array (size_t range <>) of
aliased struct_tagLC_ID;
pragma Convention (C, struct_tagLC_ID_array);
subtype LC_ID is struct_tagLC_ID;
subtype LC_ID_array is struct_tagLC_ID_array;
subtype LPLC_ID is struct_tagLC_ID_ptr;
type struct_3f1cf042 is record
locale : aliased char_ptr;
wlocale : aliased qmingw.wchar_t_ptr;
refcount : aliased signed_int_ptr;
wrefcount : aliased signed_int_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_3f1cf042);
type struct_3f1cf042_array is array (size_t range <>) of
aliased struct_3f1cf042;
pragma Convention (C, struct_3f1cf042_array);
type struct_lconv (<>) is limited private;
type struct_lconv_ptr is access all struct_lconv;
for struct_lconv_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_lconv_ptr);
pragma Convention (C, struct_lconv_ptr);
type struct_threadlocaleinfostruct is record
refcount : aliased signed_int;
lc_codepage : aliased unsigned_int;
lc_collate_cp : aliased unsigned_int;
lc_handle : aliased unsigned_long_array (0 .. 5);
lc_id : aliased LC_ID_array (0 .. 5);
lc_category : aliased struct_3f1cf042_array (0 .. 5);
lc_clike : aliased signed_int;
mb_cur_max : aliased signed_int;
lconv_intl_refcount : aliased signed_int_ptr;
lconv_num_refcount : aliased signed_int_ptr;
lconv_mon_refcount : aliased signed_int_ptr;
lconv : aliased struct_lconv_ptr;
ctype1_refcount : aliased signed_int_ptr;
ctype1 : aliased unsigned_short_ptr;
pctype : aliased unsigned_short_const_ptr;
pclmap : aliased unsigned_char_const_ptr;
pcumap : aliased unsigned_char_const_ptr;
lc_time_curr : aliased struct_lc_time_data_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_threadlocaleinfostruct);
subtype threadlocinfo is struct_threadlocaleinfostruct;
-- _CRTNOALIAS (empty)
-- _CRTRESTRICT (empty)
-- _INC_CRTDEFS (empty)
-- _RSIZE_T_DEFINED (empty)
-- _TAGLC_ID_DEFINED (empty)
-- _THREADLOCALEINFO (empty)
-- __DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_0 (empty)
-- __DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_1 (empty)
-- __DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_1_ARGLIST (empty)
-- __DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_2 (empty)
-- __DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_2_ARGLIST (empty)
-- __DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_3 (empty)
-- __DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_4 (empty)
-- __DEFINE_CPP_OVERLOAD_SECURE_FUNC_1_1 (empty)
-- __DEFINE_CPP_OVERLOAD_SECURE_FUNC_1_2 (empty)
-- __DEFINE_CPP_OVERLOAD_SECURE_FUNC_1_3 (empty)
-- __DEFINE_CPP_OVERLOAD_SECURE_FUNC_2_0 (empty)
-- __DEFINE_CPP_OVERLOAD_SECURE_FUNC_SPLITPATH (empty)
-- __crt_typefix (empty)
private
type struct_threadmbcinfostruct is null record;
type struct_lc_time_data is null record;
type struct_lconv is null record;
end C.crtdefs;
Raw
c-ctype.adb
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package body C.ctype is
function MB_CUR_MAX return signed_int is
begin
return imp_mb_cur_max.all;
end MB_CUR_MAX;
function qqPCTYPE_FUNC return unsigned_short_ptr is
begin
return imp_pctype.all;
end qqPCTYPE_FUNC;
function qqmb_cur_max return signed_int is
begin
return imp_mb_cur_max.all;
end qqmb_cur_max;
function pctype return unsigned_short_ptr is
begin
return imp_pctype.all;
end pctype;
function pwctype return unsigned_short_ptr is
begin
return imp_pwctype.all;
end pwctype;
function wctype return unsigned_short_ptr is
begin
return imp_wctype.all;
end wctype;
end C.ctype;
Raw
c-ctype.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
with C.crtdefs;
with C.qmingw;
package C.ctype is
pragma Preelaborate;
imp_pctype : aliased unsigned_short_ptr_ptr;
pragma Import (C, imp_pctype, "__imp__pctype");
imp_wctype : aliased unsigned_short_ptr_ptr;
pragma Import (C, imp_wctype, "__imp__wctype");
imp_pwctype : aliased unsigned_short_ptr_ptr;
pragma Import (C, imp_pwctype, "__imp__pwctype");
newclmap : aliased unsigned_char_array (size_t);
pragma Import (C, newclmap, "__newclmap");
newcumap : aliased unsigned_char_array (size_t);
pragma Import (C, newcumap, "__newcumap");
ptlocinfo : aliased crtdefs.pthreadlocinfo;
pragma Import (C, ptlocinfo, "__ptlocinfo");
ptmbcinfo : aliased crtdefs.pthreadmbcinfo;
pragma Import (C, ptmbcinfo, "__ptmbcinfo");
globallocalestatus : aliased signed_int;
pragma Import (C, globallocalestatus, "__globallocalestatus");
locale_changed : aliased signed_int;
pragma Import (C, locale_changed, "__locale_changed");
initiallocinfo : aliased crtdefs.struct_threadlocaleinfostruct;
pragma Import (C, initiallocinfo, "__initiallocinfo");
initiallocalestructinfo : aliased crtdefs.locale_tstruct;
pragma Import (C, initiallocalestructinfo, "__initiallocalestructinfo");
function updatetlocinfo return crtdefs.pthreadlocinfo;
pragma Import (C, updatetlocinfo, "__updatetlocinfo");
function updatetmbcinfo return crtdefs.pthreadmbcinfo;
pragma Import (C, updatetmbcinfo, "__updatetmbcinfo");
function isctype (C : signed_int; A_Type : signed_int) return signed_int;
pragma Import (C, isctype, "_isctype");
function isctype_l (C : signed_int; A_Type : signed_int;
Locale : access crtdefs.struct_localeinfo_struct) return signed_int;
pragma Import (C, isctype_l, "_isctype_l");
function isalpha (C : signed_int) return signed_int;
pragma Import (C, isalpha, "isalpha");
function qisalpha_l (C : signed_int;
Locale : access crtdefs.struct_localeinfo_struct) return signed_int;
pragma Import (C, qisalpha_l, "_isalpha_l");
function isupper (C : signed_int) return signed_int;
pragma Import (C, isupper, "isupper");
function isupper_l (C : signed_int;
Locale : access crtdefs.struct_localeinfo_struct) return signed_int;
pragma Import (C, isupper_l, "_isupper_l");
function islower (C : signed_int) return signed_int;
pragma Import (C, islower, "islower");
function islower_l (C : signed_int;
Locale : access crtdefs.struct_localeinfo_struct) return signed_int;
pragma Import (C, islower_l, "_islower_l");
function isdigit (C : signed_int) return signed_int;
pragma Import (C, isdigit, "isdigit");
function isdigit_l (C : signed_int;
Locale : access crtdefs.struct_localeinfo_struct) return signed_int;
pragma Import (C, isdigit_l, "_isdigit_l");
function isxdigit (C : signed_int) return signed_int;
pragma Import (C, isxdigit, "isxdigit");
function isxdigit_l (C : signed_int;
Locale : access crtdefs.struct_localeinfo_struct) return signed_int;
pragma Import (C, isxdigit_l, "_isxdigit_l");
function isspace (C : signed_int) return signed_int;
pragma Import (C, isspace, "isspace");
function isspace_l (C : signed_int;
Locale : access crtdefs.struct_localeinfo_struct) return signed_int;
pragma Import (C, isspace_l, "_isspace_l");
function ispunct (C : signed_int) return signed_int;
pragma Import (C, ispunct, "ispunct");
function ispunct_l (C : signed_int;
Locale : access crtdefs.struct_localeinfo_struct) return signed_int;
pragma Import (C, ispunct_l, "_ispunct_l");
function isalnum (C : signed_int) return signed_int;
pragma Import (C, isalnum, "isalnum");
function qisalnum_l (C : signed_int;
Locale : access crtdefs.struct_localeinfo_struct) return signed_int;
pragma Import (C, qisalnum_l, "_isalnum_l");
function isprint (C : signed_int) return signed_int;
pragma Import (C, isprint, "isprint");
function isprint_l (C : signed_int;
Locale : access crtdefs.struct_localeinfo_struct) return signed_int;
pragma Import (C, isprint_l, "_isprint_l");
function isgraph (C : signed_int) return signed_int;
pragma Import (C, isgraph, "isgraph");
function isgraph_l (C : signed_int;
Locale : access crtdefs.struct_localeinfo_struct) return signed_int;
pragma Import (C, isgraph_l, "_isgraph_l");
function iscntrl (C : signed_int) return signed_int;
pragma Import (C, iscntrl, "iscntrl");
function iscntrl_l (C : signed_int;
Locale : access crtdefs.struct_localeinfo_struct) return signed_int;
pragma Import (C, iscntrl_l, "_iscntrl_l");
function toupper (C : signed_int) return signed_int;
pragma Import (C, toupper, "toupper");
function tolower (C : signed_int) return signed_int;
pragma Import (C, tolower, "tolower");
function qtolower (C : signed_int) return signed_int;
pragma Import (C, qtolower, "_tolower");
function tolower_l (C : signed_int;
Locale : access crtdefs.struct_localeinfo_struct) return signed_int;
pragma Import (C, tolower_l, "_tolower_l");
function qtoupper (C : signed_int) return signed_int;
pragma Import (C, qtoupper, "_toupper");
function toupper_l (C : signed_int;
Locale : access crtdefs.struct_localeinfo_struct) return signed_int;
pragma Import (C, toupper_l, "_toupper_l");
function qqisascii (C : signed_int) return signed_int;
pragma Import (C, qqisascii, "__isascii");
function qqtoascii (C : signed_int) return signed_int;
pragma Import (C, qqtoascii, "__toascii");
function qqiscsymf (C : signed_int) return signed_int;
pragma Import (C, qqiscsymf, "__iscsymf");
function qqiscsym (C : signed_int) return signed_int;
pragma Import (C, qqiscsym, "__iscsym");
function isblank (C : signed_int) return signed_int;
pragma Import (C, isblank, "isblank");
function iswalpha (C : qmingw.wint_t) return signed_int;
pragma Import (C, iswalpha, "iswalpha");
function iswalpha_l (C : qmingw.wint_t;
Locale : access crtdefs.struct_localeinfo_struct) return signed_int;
pragma Import (C, iswalpha_l, "_iswalpha_l");
function iswupper (C : qmingw.wint_t) return signed_int;
pragma Import (C, iswupper, "iswupper");
function iswupper_l (C : qmingw.wint_t;
Locale : access crtdefs.struct_localeinfo_struct) return signed_int;
pragma Import (C, iswupper_l, "_iswupper_l");
function iswlower (C : qmingw.wint_t) return signed_int;
pragma Import (C, iswlower, "iswlower");
function iswlower_l (C : qmingw.wint_t;
Locale : access crtdefs.struct_localeinfo_struct) return signed_int;
pragma Import (C, iswlower_l, "_iswlower_l");
function iswdigit (C : qmingw.wint_t) return signed_int;
pragma Import (C, iswdigit, "iswdigit");
function iswdigit_l (C : qmingw.wint_t;
Locale : access crtdefs.struct_localeinfo_struct) return signed_int;
pragma Import (C, iswdigit_l, "_iswdigit_l");
function iswxdigit (C : qmingw.wint_t) return signed_int;
pragma Import (C, iswxdigit, "iswxdigit");
function iswxdigit_l (C : qmingw.wint_t;
Locale : access crtdefs.struct_localeinfo_struct) return signed_int;
pragma Import (C, iswxdigit_l, "_iswxdigit_l");
function iswspace (C : qmingw.wint_t) return signed_int;
pragma Import (C, iswspace, "iswspace");
function iswspace_l (C : qmingw.wint_t;
Locale : access crtdefs.struct_localeinfo_struct) return signed_int;
pragma Import (C, iswspace_l, "_iswspace_l");
function iswpunct (C : qmingw.wint_t) return signed_int;
pragma Import (C, iswpunct, "iswpunct");
function iswpunct_l (C : qmingw.wint_t;
Locale : access crtdefs.struct_localeinfo_struct) return signed_int;
pragma Import (C, iswpunct_l, "_iswpunct_l");
function iswalnum (C : qmingw.wint_t) return signed_int;
pragma Import (C, iswalnum, "iswalnum");
function iswalnum_l (C : qmingw.wint_t;
Locale : access crtdefs.struct_localeinfo_struct) return signed_int;
pragma Import (C, iswalnum_l, "_iswalnum_l");
function iswprint (C : qmingw.wint_t) return signed_int;
pragma Import (C, iswprint, "iswprint");
function iswprint_l (C : qmingw.wint_t;
Locale : access crtdefs.struct_localeinfo_struct) return signed_int;
pragma Import (C, iswprint_l, "_iswprint_l");
function iswgraph (C : qmingw.wint_t) return signed_int;
pragma Import (C, iswgraph, "iswgraph");
function iswgraph_l (C : qmingw.wint_t;
Locale : access crtdefs.struct_localeinfo_struct) return signed_int;
pragma Import (C, iswgraph_l, "_iswgraph_l");
function iswcntrl (C : qmingw.wint_t) return signed_int;
pragma Import (C, iswcntrl, "iswcntrl");
function iswcntrl_l (C : qmingw.wint_t;
Locale : access crtdefs.struct_localeinfo_struct) return signed_int;
pragma Import (C, iswcntrl_l, "_iswcntrl_l");
function iswascii (C : qmingw.wint_t) return signed_int;
pragma Import (C, iswascii, "iswascii");
function isleadbyte (C : signed_int) return signed_int;
pragma Import (C, isleadbyte, "isleadbyte");
function isleadbyte_l (C : signed_int;
Locale : access crtdefs.struct_localeinfo_struct) return signed_int;
pragma Import (C, isleadbyte_l, "_isleadbyte_l");
function towupper (C : qmingw.wint_t) return qmingw.wint_t;
pragma Import (C, towupper, "towupper");
function towupper_l (C : qmingw.wint_t;
Locale : access crtdefs.struct_localeinfo_struct) return qmingw.wint_t;
pragma Import (C, towupper_l, "_towupper_l");
function towlower (C : qmingw.wint_t) return qmingw.wint_t;
pragma Import (C, towlower, "towlower");
function towlower_l (C : qmingw.wint_t;
Locale : access crtdefs.struct_localeinfo_struct) return qmingw.wint_t;
pragma Import (C, towlower_l, "_towlower_l");
function iswctype (C : qmingw.wint_t; A_Type : qmingw.wctype_t)
return signed_int;
pragma Import (C, iswctype, "iswctype");
function iswctype_l (C : qmingw.wint_t; A_Type : qmingw.wctype_t;
Locale : access crtdefs.struct_localeinfo_struct) return signed_int;
pragma Import (C, iswctype_l, "_iswctype_l");
function iswcsymf (C : qmingw.wint_t) return signed_int;
pragma Import (C, iswcsymf, "__iswcsymf");
function iswcsymf_l (C : qmingw.wint_t;
Locale : access crtdefs.struct_localeinfo_struct) return signed_int;
pragma Import (C, iswcsymf_l, "_iswcsymf_l");
function iswcsym (C : qmingw.wint_t) return signed_int;
pragma Import (C, iswcsym, "__iswcsym");
function iswcsym_l (C : qmingw.wint_t;
Locale : access crtdefs.struct_localeinfo_struct) return signed_int;
pragma Import (C, iswcsym_l, "_iswcsym_l");
function is_wctype (C : qmingw.wint_t; A_Type : qmingw.wctype_t)
return signed_int;
pragma Import (C, is_wctype, "is_wctype");
function iswblank (C : qmingw.wint_t) return signed_int;
pragma Import (C, iswblank, "iswblank");
imp_mb_cur_max : aliased signed_int_ptr;
pragma Import (C, imp_mb_cur_max, "__imp___mb_cur_max");
function MB_CUR_MAX return signed_int;
pragma Inline_Always (MB_CUR_MAX);
WEOF : constant := 65535;
ALPHA : constant := 259;
BLANK : constant := 64;
CONTROL : constant := 32;
-- _CRT_CTYPEDATA_DEFINED (empty)
-- _CRT_WCTYPEDATA_DEFINED (empty)
-- _CTYPE_DEFINED (empty)
DIGIT : constant := 4;
HEX : constant := 128;
-- _INC_CTYPE (empty)
LEADBYTE : constant := 32768;
LOWER : constant := 2;
PUNCT : constant := 16;
SPACE : constant := 8;
UPPER : constant := 1;
-- _WCTYPE_DEFINED (empty)
-- _WCTYPE_INLINE_DEFINED (empty)
function qqPCTYPE_FUNC return unsigned_short_ptr;
pragma Inline_Always (qqPCTYPE_FUNC);
-- ___mb_cur_max_func (function macro)
-- __chvalidchk (function macro)
function qqmb_cur_max return signed_int;
pragma Inline_Always (qqmb_cur_max);
-- __pctype_func (function macro)
-- __pwctype_func (function macro)
-- _chvalidchk_l (unparsible)
-- _isalnum_l (unparsible)
-- _isalpha_l (unparsible)
-- _ischartype_l (unparsible)
-- _iscsym_l (unparsible)
-- _iscsymf_l (unparsible)
function pctype return unsigned_short_ptr;
pragma Inline_Always (pctype);
function pwctype return unsigned_short_ptr;
pragma Inline_Always (pwctype);
function wctype return unsigned_short_ptr;
pragma Inline_Always (wctype);
-- isascii (function macro)
-- iscsym (function macro)
-- iscsymf (function macro)
-- toascii (function macro)
end C.ctype;
Raw
c-errno.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
with C.qmingw;
with C.stddef;
package C.errno is
pragma Preelaborate;
C_NULL : void_ptr renames stddef.C_NULL;
-- ANSI_STDDEF_H renames stddef.ANSI_STDDEF_H (empty)
-- qSTDDEF_H renames stddef.qSTDDEF_H (empty)
-- qSTDDEF_Hq renames stddef.qSTDDEF_Hq (empty)
-- offsetof renames stddef.offsetof (unparsible)
function qerrno return signed_int_ptr renames stddef.qerrno;
function set_errno (Value : signed_int) return qmingw.errno_t
renames stddef.set_errno;
function get_errno (Value : access signed_int) return qmingw.errno_t
renames stddef.get_errno;
function qqthreadid return unsigned_long renames stddef.qqthreadid;
function threadhandle return qmingw.uintptr_t renames stddef.threadhandle;
-- CRT_ERRNO_DEFINED renames stddef.CRT_ERRNO_DEFINED (empty)
-- INC_STDDEF renames stddef.INC_STDDEF (empty)
function qthreadid return unsigned_long renames stddef.qthreadid;
function errno return signed_int renames stddef.errno;
E2BIG : constant := 7;
EACCES : constant := 13;
EADDRINUSE : constant := 100;
EADDRNOTAVAIL : constant := 101;
EAFNOSUPPORT : constant := 102;
EAGAIN : constant := 11;
EALREADY : constant := 103;
EBADF : constant := 9;
EBUSY : constant := 16;
ECANCELED : constant := 105;
ECHILD : constant := 10;
ECONNABORTED : constant := 106;
ECONNREFUSED : constant := 107;
ECONNRESET : constant := 108;
EDEADLK : constant := 36;
EDEADLOCK : constant := 36;
EDESTADDRREQ : constant := 109;
EDOM : constant := 33;
EEXIST : constant := 17;
EFAULT : constant := 14;
EFBIG : constant := 27;
EHOSTUNREACH : constant := 110;
EILSEQ : constant := 42;
EINPROGRESS : constant := 112;
EINTR : constant := 4;
EINVAL : constant := 22;
EIO : constant := 5;
EISCONN : constant := 113;
EISDIR : constant := 21;
ELOOP : constant := 114;
EMFILE : constant := 24;
EMLINK : constant := 31;
EMSGSIZE : constant := 115;
ENAMETOOLONG : constant := 38;
ENETDOWN : constant := 116;
ENETRESET : constant := 117;
ENETUNREACH : constant := 118;
ENFILE : constant := 23;
ENOBUFS : constant := 119;
ENODEV : constant := 19;
ENOENT : constant := 2;
ENOEXEC : constant := 8;
ENOFILE : constant := 2;
ENOLCK : constant := 39;
ENOMEM : constant := 12;
ENOPROTOOPT : constant := 123;
ENOSPC : constant := 28;
ENOSYS : constant := 40;
ENOTCONN : constant := 126;
ENOTDIR : constant := 20;
ENOTEMPTY : constant := 41;
ENOTSOCK : constant := 128;
ENOTSUP : constant := 129;
ENOTTY : constant := 25;
ENXIO : constant := 6;
EOPNOTSUPP : constant := 130;
EOVERFLOW : constant := 132;
EOWNERDEAD : constant := 133;
EPERM : constant := 1;
EPIPE : constant := 32;
EPROTO : constant := 134;
EPROTONOSUPPORT : constant := 135;
EPROTOTYPE : constant := 136;
ERANGE : constant := 34;
EROFS : constant := 30;
ESPIPE : constant := 29;
ESRCH : constant := 3;
ETIMEDOUT : constant := 138;
EWOULDBLOCK : constant := 140;
EXDEV : constant := 18;
STRUNCATE : constant := 80;
-- _INC_ERRNO (empty)
-- _SECURECRT_ERRCODE_VALUES_DEFINED (empty)
end C.errno;
Raw
c-excpt.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
limited with C.winnt;
package C.excpt is
pragma Preelaborate;
-- subtype struct_EXCEPTION_POINTERS is winnt.struct_EXCEPTION_POINTERS;
type struct_EXCEPTION_POINTERS_ptr is
access all winnt.struct_EXCEPTION_POINTERS;
for struct_EXCEPTION_POINTERS_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_EXCEPTION_POINTERS_ptr);
pragma Convention (C, struct_EXCEPTION_POINTERS_ptr);
-- subtype struct_EXCEPTION_RECORD is winnt.struct_EXCEPTION_RECORD;
type struct_EXCEPTION_RECORD_ptr is
access all winnt.struct_EXCEPTION_RECORD;
for struct_EXCEPTION_RECORD_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_EXCEPTION_RECORD_ptr);
pragma Convention (C, struct_EXCEPTION_RECORD_ptr);
-- subtype struct_CONTEXT is winnt.struct_CONTEXT;
type struct_CONTEXT_ptr is access all winnt.struct_CONTEXT;
for struct_CONTEXT_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CONTEXT_ptr);
pragma Convention (C, struct_CONTEXT_ptr);
function qexception_code return unsigned_long;
pragma Import (C, qexception_code, "_exception_code");
function qexception_info return void_ptr;
pragma Import (C, qexception_info, "_exception_info");
function qabnormal_termination return signed_int;
pragma Import (C, qabnormal_termination, "_abnormal_termination");
type access_8775e920 is access procedure (a1 : signed_int);
pragma Convention (C, access_8775e920);
subtype PHNDLR is access_8775e920;
type struct_XCPT_ACTION;
type struct_XCPT_ACTION is record
XcptNum : aliased unsigned_long;
SigNum : aliased signed_int;
XcptAction : aliased PHNDLR;
end record;
for struct_XCPT_ACTION'Alignment use 8;
pragma Convention (C_Pass_By_Copy, struct_XCPT_ACTION);
type struct_XCPT_ACTION_array is array (size_t range <>) of
aliased struct_XCPT_ACTION;
pragma Convention (C, struct_XCPT_ACTION_array);
XcptActTab : aliased struct_XCPT_ACTION_array (size_t);
pragma Import (C, XcptActTab, "_XcptActTab");
XcptActTabCount : aliased signed_int;
pragma Import (C, XcptActTabCount, "_XcptActTabCount");
XcptActTabSize : aliased signed_int;
pragma Import (C, XcptActTabSize, "_XcptActTabSize");
First_FPE_Indx : aliased signed_int;
pragma Import (C, First_FPE_Indx, "_First_FPE_Indx");
Num_FPE : aliased signed_int;
pragma Import (C, Num_FPE, "_Num_FPE");
function CppXcptFilter (ExceptionNum : unsigned_long;
ExceptionPtr : access winnt.struct_EXCEPTION_POINTERS)
return signed_int;
pragma Import (C, CppXcptFilter, "__CppXcptFilter");
function XcptFilter (ExceptionNum : unsigned_long;
ExceptionPtr : access winnt.struct_EXCEPTION_POINTERS)
return signed_int;
pragma Import (C, XcptFilter, "_XcptFilter");
type access_b726efab is access function (
a1 : access winnt.struct_EXCEPTION_RECORD; a2 : void_ptr;
a3 : access winnt.struct_CONTEXT; a4 : void_ptr) return signed_int;
pragma Convention (C, access_b726efab);
subtype PEXCEPTION_HANDLER is access_b726efab;
type struct_EXCEPTION_REGISTRATION;
type struct_EXCEPTION_REGISTRATION_ptr is
access all struct_EXCEPTION_REGISTRATION;
for struct_EXCEPTION_REGISTRATION_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_EXCEPTION_REGISTRATION_ptr);
pragma Convention (C, struct_EXCEPTION_REGISTRATION_ptr);
type access_f5b164a5 is access function (
a1 : access winnt.struct_EXCEPTION_RECORD; a2 : void_ptr;
a3 : access winnt.struct_CONTEXT; a4 : void_ptr) return signed_int;
pragma Convention (C, access_f5b164a5);
type struct_EXCEPTION_REGISTRATION is record
prev : aliased struct_EXCEPTION_REGISTRATION_ptr;
handler : aliased access_f5b164a5;
end record;
for struct_EXCEPTION_REGISTRATION'Alignment use 8;
pragma Convention (C_Pass_By_Copy, struct_EXCEPTION_REGISTRATION);
subtype EXCEPTION_REGISTRATION is struct_EXCEPTION_REGISTRATION;
subtype PEXCEPTION_REGISTRATION is struct_EXCEPTION_REGISTRATION_ptr;
subtype EXCEPTION_REGISTRATION_RECORD is EXCEPTION_REGISTRATION;
subtype PEXCEPTION_REGISTRATION_RECORD is PEXCEPTION_REGISTRATION;
function AbnormalTermination return signed_int
renames qabnormal_termination;
EXCEPTION_CONTINUE_EXECUTION : constant := -1;
EXCEPTION_CONTINUE_SEARCH : constant := 0;
subtype EXCEPTION_DISPOSITION is signed_int;
EXCEPTION_EXECUTE_HANDLER : constant := 1;
ExceptionCollidedUnwind : constant := 3;
ExceptionContinueExecution : constant := 0;
ExceptionContinueSearch : constant := 1;
ExceptionExecuteHandler : constant := 4;
ExceptionNestedException : constant := 2;
function GetExceptionCode return unsigned_long renames qexception_code;
-- GetExceptionInformation (unparsible)
-- _INC_EXCPT (empty)
-- __except1 (unparsible)
-- __try1 (function macro)
function abnormal_termination return signed_int
renames qabnormal_termination;
function exception_code return unsigned_long renames qexception_code;
-- exception_info (unparsible)
end C.excpt;
Raw
c-fltwinerror.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.fltwinerror is
pragma Preelaborate;
ERROR_FLT_ALREADY_ENLISTED : constant := -2145452005;
ERROR_FLT_CBDQ_DISABLED : constant := -2145452018;
ERROR_FLT_CONTEXT_ALLOCATION_NOT_FOUND : constant := -2145452010;
ERROR_FLT_CONTEXT_ALREADY_DEFINED : constant := -2145452030;
ERROR_FLT_CONTEXT_ALREADY_LINKED : constant := -2145452004;
ERROR_FLT_DELETING_OBJECT : constant := -2145452021;
ERROR_FLT_DISALLOW_FAST_IO : constant := -2145452028;
ERROR_FLT_DO_NOT_ATTACH : constant := -2145452017;
ERROR_FLT_DO_NOT_DETACH : constant := -2145452016;
ERROR_FLT_DUPLICATE_ENTRY : constant := -2145452019;
ERROR_FLT_FILTER_NOT_FOUND : constant := -2145452013;
ERROR_FLT_FILTER_NOT_READY : constant := -2145452024;
ERROR_FLT_INSTANCE_ALTITUDE_COLLISION : constant := -2145452015;
ERROR_FLT_INSTANCE_NAME_COLLISION : constant := -2145452014;
ERROR_FLT_INSTANCE_NOT_FOUND : constant := -2145452011;
ERROR_FLT_INTERNAL_ERROR : constant := -2145452022;
ERROR_FLT_INVALID_ASYNCHRONOUS_REQUEST : constant := -2145452029;
ERROR_FLT_INVALID_CONTEXT_REGISTRATION : constant := -2145452009;
ERROR_FLT_INVALID_NAME_REQUEST : constant := -2145452027;
ERROR_FLT_IO_COMPLETE : constant := 2031617;
ERROR_FLT_MUST_BE_NONPAGED_POOL : constant := -2145452020;
ERROR_FLT_NAME_CACHE_MISS : constant := -2145452008;
ERROR_FLT_NOT_INITIALIZED : constant := -2145452025;
ERROR_FLT_NOT_SAFE_TO_POST_OPERATION : constant := -2145452026;
ERROR_FLT_NO_DEVICE_OBJECT : constant := -2145452007;
ERROR_FLT_NO_HANDLER_DEFINED : constant := -2145452031;
ERROR_FLT_NO_WAITER_FOR_REPLY : constant := -2145452000;
ERROR_FLT_POST_OPERATION_CLEANUP : constant := -2145452023;
ERROR_FLT_REGISTRATION_BUSY : constant := -2145451997;
ERROR_FLT_VOLUME_ALREADY_MOUNTED : constant := -2145452006;
ERROR_FLT_VOLUME_NOT_FOUND : constant := -2145452012;
FACILITY_USERMODE_FILTER_MANAGER : constant := 31;
-- FILTER_HRESULT_FROM_FLT_NTSTATUS (uninterpretable)
-- _FLT_WINERROR_ (empty)
end C.fltwinerror;
Raw
c-guiddef.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.guiddef is
pragma Preelaborate;
type struct_GUID;
type struct_GUID is record
Data1 : aliased unsigned_long;
Data2 : aliased unsigned_short;
Data3 : aliased unsigned_short;
Data4 : aliased unsigned_char_array (0 .. 7);
end record;
pragma Convention (C_Pass_By_Copy, struct_GUID);
type struct_GUID_ptr is access all struct_GUID;
for struct_GUID_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_GUID_ptr);
pragma Convention (C, struct_GUID_ptr);
type struct_GUID_ptr_ptr is access all struct_GUID_ptr;
for struct_GUID_ptr_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_GUID_ptr_ptr);
pragma Convention (C, struct_GUID_ptr_ptr);
type struct_GUID_const_ptr is access constant struct_GUID;
for struct_GUID_const_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_GUID_const_ptr);
pragma Convention (C, struct_GUID_const_ptr);
subtype GUID is struct_GUID;
subtype GUID_ptr is struct_GUID_ptr;
subtype GUID_ptr_ptr is struct_GUID_ptr_ptr;
subtype GUID_const_ptr is struct_GUID_const_ptr;
subtype LPGUID is GUID_ptr;
subtype LPCGUID is GUID_const_ptr;
subtype IID is GUID;
subtype IID_ptr is GUID_ptr;
subtype LPIID is IID_ptr;
subtype CLSID is GUID;
subtype CLSID_ptr is GUID_ptr;
subtype LPCLSID is CLSID_ptr;
subtype FMTID is GUID;
subtype FMTID_ptr is GUID_ptr;
subtype LPFMTID is FMTID_ptr;
-- CLSID_DEFINED (empty)
-- CLSID_NULL (unparsible)
-- DEFINE_GUID (unparsible)
-- DEFINE_OLEGUID (unparsible)
-- FMTID_NULL (unparsible)
-- GUID_DEFINED (empty)
-- IID_NULL (unparsible)
-- InlineIsEqualGUID (function macro)
-- IsEqualCLSID (function macro)
-- IsEqualFMTID (function macro)
-- IsEqualGUID (function macro)
-- IsEqualIID (function macro)
-- REFCLSID (unparsible)
-- REFFMTID (unparsible)
-- REFGUID (unparsible)
-- REFIID (unparsible)
-- _GUIDDEF_H_ (empty)
-- _REFCLSID_DEFINED (empty)
-- _REFFMTID_DEFINED (empty)
-- _REFGUID_DEFINED (empty)
-- _REFIID_DEFINED (empty)
-- _SYS_GUID_OPERATORS_ (empty)
-- _SYS_GUID_OPERATOR_EQ_ (empty)
-- __IID_DEFINED__ (empty)
-- __LPCGUID_DEFINED__ (empty)
-- __LPGUID_DEFINED__ (empty)
-- __MIDL_CONST (alias of const)
end C.guiddef;
Raw
c-imm.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
with C.windef;
with C.wingdi;
with C.winnt;
package C.imm is
pragma Preelaborate;
type struct_HIMC;
type struct_HIMC is record
unused : aliased signed_int;
end record;
pragma Convention (C_Pass_By_Copy, struct_HIMC);
type struct_HIMC_ptr is access all struct_HIMC;
for struct_HIMC_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_HIMC_ptr);
pragma Convention (C, struct_HIMC_ptr);
subtype HIMC is struct_HIMC_ptr;
type struct_HIMCC;
type struct_HIMCC is record
unused : aliased signed_int;
end record;
pragma Convention (C_Pass_By_Copy, struct_HIMCC);
type struct_HIMCC_ptr is access all struct_HIMCC;
for struct_HIMCC_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_HIMCC_ptr);
pragma Convention (C, struct_HIMCC_ptr);
subtype HIMCC is struct_HIMCC_ptr;
subtype LPHKL is windef.HKL_ptr;
subtype LPUINT is windef.UINT_ptr;
type struct_tagCOMPOSITIONFORM;
type struct_tagCOMPOSITIONFORM is record
dwStyle : aliased windef.DWORD;
ptCurrentPos : aliased windef.POINT;
rcArea : aliased windef.RECT;
end record;
pragma Convention (C_Pass_By_Copy, struct_tagCOMPOSITIONFORM);
type struct_tagCOMPOSITIONFORM_ptr is
access all struct_tagCOMPOSITIONFORM;
for struct_tagCOMPOSITIONFORM_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_tagCOMPOSITIONFORM_ptr);
pragma Convention (C, struct_tagCOMPOSITIONFORM_ptr);
subtype COMPOSITIONFORM is struct_tagCOMPOSITIONFORM;
subtype PCOMPOSITIONFORM is struct_tagCOMPOSITIONFORM_ptr;
subtype NPCOMPOSITIONFORM is struct_tagCOMPOSITIONFORM_ptr;
subtype LPCOMPOSITIONFORM is struct_tagCOMPOSITIONFORM_ptr;
type struct_tagCANDIDATEFORM;
type struct_tagCANDIDATEFORM is record
dwIndex : aliased windef.DWORD;
dwStyle : aliased windef.DWORD;
ptCurrentPos : aliased windef.POINT;
rcArea : aliased windef.RECT;
end record;
pragma Convention (C_Pass_By_Copy, struct_tagCANDIDATEFORM);
type struct_tagCANDIDATEFORM_ptr is access all struct_tagCANDIDATEFORM;
for struct_tagCANDIDATEFORM_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_tagCANDIDATEFORM_ptr);
pragma Convention (C, struct_tagCANDIDATEFORM_ptr);
subtype CANDIDATEFORM is struct_tagCANDIDATEFORM;
subtype PCANDIDATEFORM is struct_tagCANDIDATEFORM_ptr;
subtype NPCANDIDATEFORM is struct_tagCANDIDATEFORM_ptr;
subtype LPCANDIDATEFORM is struct_tagCANDIDATEFORM_ptr;
type struct_tagCANDIDATELIST;
type struct_tagCANDIDATELIST is record
dwSize : aliased windef.DWORD;
dwStyle : aliased windef.DWORD;
dwCount : aliased windef.DWORD;
dwSelection : aliased windef.DWORD;
dwPageStart : aliased windef.DWORD;
dwPageSize : aliased windef.DWORD;
dwOffset : aliased windef.DWORD_array (0 .. 0);
end record;
pragma Convention (C_Pass_By_Copy, struct_tagCANDIDATELIST);
type struct_tagCANDIDATELIST_ptr is access all struct_tagCANDIDATELIST;
for struct_tagCANDIDATELIST_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_tagCANDIDATELIST_ptr);
pragma Convention (C, struct_tagCANDIDATELIST_ptr);
subtype CANDIDATELIST is struct_tagCANDIDATELIST;
subtype PCANDIDATELIST is struct_tagCANDIDATELIST_ptr;
subtype NPCANDIDATELIST is struct_tagCANDIDATELIST_ptr;
subtype LPCANDIDATELIST is struct_tagCANDIDATELIST_ptr;
type struct_tagREGISTERWORDA;
type struct_tagREGISTERWORDA is record
lpReading : aliased winnt.LPSTR;
lpWord : aliased winnt.LPSTR;
end record;
pragma Convention (C_Pass_By_Copy, struct_tagREGISTERWORDA);
type struct_tagREGISTERWORDA_ptr is access all struct_tagREGISTERWORDA;
for struct_tagREGISTERWORDA_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_tagREGISTERWORDA_ptr);
pragma Convention (C, struct_tagREGISTERWORDA_ptr);
subtype REGISTERWORDA is struct_tagREGISTERWORDA;
subtype PREGISTERWORDA is struct_tagREGISTERWORDA_ptr;
subtype NPREGISTERWORDA is struct_tagREGISTERWORDA_ptr;
subtype LPREGISTERWORDA is struct_tagREGISTERWORDA_ptr;
type struct_tagREGISTERWORDW;
type struct_tagREGISTERWORDW is record
lpReading : aliased winnt.LPWSTR;
lpWord : aliased winnt.LPWSTR;
end record;
pragma Convention (C_Pass_By_Copy, struct_tagREGISTERWORDW);
type struct_tagREGISTERWORDW_ptr is access all struct_tagREGISTERWORDW;
for struct_tagREGISTERWORDW_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_tagREGISTERWORDW_ptr);
pragma Convention (C, struct_tagREGISTERWORDW_ptr);
subtype REGISTERWORDW is struct_tagREGISTERWORDW;
subtype PREGISTERWORDW is struct_tagREGISTERWORDW_ptr;
subtype NPREGISTERWORDW is struct_tagREGISTERWORDW_ptr;
subtype LPREGISTERWORDW is struct_tagREGISTERWORDW_ptr;
subtype REGISTERWORD is REGISTERWORDW;
subtype PREGISTERWORD is PREGISTERWORDW;
subtype NPREGISTERWORD is NPREGISTERWORDW;
subtype LPREGISTERWORD is LPREGISTERWORDW;
type struct_tagRECONVERTSTRING;
type struct_tagRECONVERTSTRING is record
dwSize : aliased windef.DWORD;
dwVersion : aliased windef.DWORD;
dwStrLen : aliased windef.DWORD;
dwStrOffset : aliased windef.DWORD;
dwCompStrLen : aliased windef.DWORD;
dwCompStrOffset : aliased windef.DWORD;
dwTargetStrLen : aliased windef.DWORD;
dwTargetStrOffset : aliased windef.DWORD;
end record;
pragma Convention (C_Pass_By_Copy, struct_tagRECONVERTSTRING);
type struct_tagRECONVERTSTRING_ptr is
access all struct_tagRECONVERTSTRING;
for struct_tagRECONVERTSTRING_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_tagRECONVERTSTRING_ptr);
pragma Convention (C, struct_tagRECONVERTSTRING_ptr);
subtype RECONVERTSTRING is struct_tagRECONVERTSTRING;
subtype PRECONVERTSTRING is struct_tagRECONVERTSTRING_ptr;
subtype NPRECONVERTSTRING is struct_tagRECONVERTSTRING_ptr;
subtype LPRECONVERTSTRING is struct_tagRECONVERTSTRING_ptr;
type struct_tagSTYLEBUFA;
type struct_tagSTYLEBUFA is record
dwStyle : aliased windef.DWORD;
szDescription : aliased winnt.C_CHAR_array (0 .. 31);
end record;
pragma Convention (C_Pass_By_Copy, struct_tagSTYLEBUFA);
type struct_tagSTYLEBUFA_ptr is access all struct_tagSTYLEBUFA;
for struct_tagSTYLEBUFA_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_tagSTYLEBUFA_ptr);
pragma Convention (C, struct_tagSTYLEBUFA_ptr);
subtype STYLEBUFA is struct_tagSTYLEBUFA;
subtype PSTYLEBUFA is struct_tagSTYLEBUFA_ptr;
subtype NPSTYLEBUFA is struct_tagSTYLEBUFA_ptr;
subtype LPSTYLEBUFA is struct_tagSTYLEBUFA_ptr;
type struct_tagSTYLEBUFW;
type struct_tagSTYLEBUFW is record
dwStyle : aliased windef.DWORD;
szDescription : aliased winnt.WCHAR_array (0 .. 31);
end record;
pragma Convention (C_Pass_By_Copy, struct_tagSTYLEBUFW);
type struct_tagSTYLEBUFW_ptr is access all struct_tagSTYLEBUFW;
for struct_tagSTYLEBUFW_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_tagSTYLEBUFW_ptr);
pragma Convention (C, struct_tagSTYLEBUFW_ptr);
subtype STYLEBUFW is struct_tagSTYLEBUFW;
subtype PSTYLEBUFW is struct_tagSTYLEBUFW_ptr;
subtype NPSTYLEBUFW is struct_tagSTYLEBUFW_ptr;
subtype LPSTYLEBUFW is struct_tagSTYLEBUFW_ptr;
subtype STYLEBUF is STYLEBUFW;
subtype PSTYLEBUF is PSTYLEBUFW;
subtype NPSTYLEBUF is NPSTYLEBUFW;
subtype LPSTYLEBUF is LPSTYLEBUFW;
type struct_tagIMEMENUITEMINFOA;
type struct_tagIMEMENUITEMINFOA is record
cbSize : aliased windef.UINT;
fType : aliased windef.UINT;
fState : aliased windef.UINT;
wID : aliased windef.UINT;
hbmpChecked : aliased windef.HBITMAP;
hbmpUnchecked : aliased windef.HBITMAP;
dwItemData : aliased windef.DWORD;
szString : aliased winnt.C_CHAR_array (0 .. 79);
hbmpItem : aliased windef.HBITMAP;
end record;
pragma Convention (C_Pass_By_Copy, struct_tagIMEMENUITEMINFOA);
type struct_tagIMEMENUITEMINFOA_ptr is
access all struct_tagIMEMENUITEMINFOA;
for struct_tagIMEMENUITEMINFOA_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_tagIMEMENUITEMINFOA_ptr);
pragma Convention (C, struct_tagIMEMENUITEMINFOA_ptr);
subtype IMEMENUITEMINFOA is struct_tagIMEMENUITEMINFOA;
subtype PIMEMENUITEMINFOA is struct_tagIMEMENUITEMINFOA_ptr;
subtype NPIMEMENUITEMINFOA is struct_tagIMEMENUITEMINFOA_ptr;
subtype LPIMEMENUITEMINFOA is struct_tagIMEMENUITEMINFOA_ptr;
type struct_tagIMEMENUITEMINFOW;
type struct_tagIMEMENUITEMINFOW is record
cbSize : aliased windef.UINT;
fType : aliased windef.UINT;
fState : aliased windef.UINT;
wID : aliased windef.UINT;
hbmpChecked : aliased windef.HBITMAP;
hbmpUnchecked : aliased windef.HBITMAP;
dwItemData : aliased windef.DWORD;
szString : aliased winnt.WCHAR_array (0 .. 79);
hbmpItem : aliased windef.HBITMAP;
end record;
pragma Convention (C_Pass_By_Copy, struct_tagIMEMENUITEMINFOW);
type struct_tagIMEMENUITEMINFOW_ptr is
access all struct_tagIMEMENUITEMINFOW;
for struct_tagIMEMENUITEMINFOW_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_tagIMEMENUITEMINFOW_ptr);
pragma Convention (C, struct_tagIMEMENUITEMINFOW_ptr);
subtype IMEMENUITEMINFOW is struct_tagIMEMENUITEMINFOW;
subtype PIMEMENUITEMINFOW is struct_tagIMEMENUITEMINFOW_ptr;
subtype NPIMEMENUITEMINFOW is struct_tagIMEMENUITEMINFOW_ptr;
subtype LPIMEMENUITEMINFOW is struct_tagIMEMENUITEMINFOW_ptr;
subtype IMEMENUITEMINFO is IMEMENUITEMINFOW;
subtype PIMEMENUITEMINFO is PIMEMENUITEMINFOW;
subtype NPIMEMENUITEMINFO is NPIMEMENUITEMINFOW;
subtype LPIMEMENUITEMINFO is LPIMEMENUITEMINFOW;
type struct_tagIMECHARPOSITION;
type struct_tagIMECHARPOSITION is record
dwSize : aliased windef.DWORD;
dwCharPos : aliased windef.DWORD;
pt : aliased windef.POINT;
cLineHeight : aliased windef.UINT;
rcDocument : aliased windef.RECT;
end record;
pragma Convention (C_Pass_By_Copy, struct_tagIMECHARPOSITION);
type struct_tagIMECHARPOSITION_ptr is
access all struct_tagIMECHARPOSITION;
for struct_tagIMECHARPOSITION_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_tagIMECHARPOSITION_ptr);
pragma Convention (C, struct_tagIMECHARPOSITION_ptr);
subtype IMECHARPOSITION is struct_tagIMECHARPOSITION;
subtype PIMECHARPOSITION is struct_tagIMECHARPOSITION_ptr;
subtype NPIMECHARPOSITION is struct_tagIMECHARPOSITION_ptr;
subtype LPIMECHARPOSITION is struct_tagIMECHARPOSITION_ptr;
type access_2f314dc0 is access function (a1 : access struct_HIMC;
a2 : windef.LPARAM) return windef.WINBOOL;
pragma Convention (C, access_2f314dc0);
subtype IMCENUMPROC is access_2f314dc0;
function ImmInstallIMEA (lpszIMEFileName : access constant winnt.C_CHAR;
lpszLayoutText : access constant winnt.C_CHAR) return windef.HKL;
pragma Import (C, ImmInstallIMEA, "ImmInstallIMEA");
function ImmInstallIMEW (lpszIMEFileName : access constant winnt.WCHAR;
lpszLayoutText : access constant winnt.WCHAR) return windef.HKL;
pragma Import (C, ImmInstallIMEW, "ImmInstallIMEW");
function ImmGetDefaultIMEWnd (a1 : access windef.struct_HWND)
return windef.HWND;
pragma Import (C, ImmGetDefaultIMEWnd, "ImmGetDefaultIMEWnd");
function ImmGetDescriptionA (a1 : access windef.struct_HKL;
a2 : access winnt.C_CHAR; uBufLen : windef.UINT) return windef.UINT;
pragma Import (C, ImmGetDescriptionA, "ImmGetDescriptionA");
function ImmGetDescriptionW (a1 : access windef.struct_HKL;
a2 : access winnt.WCHAR; uBufLen : windef.UINT) return windef.UINT;
pragma Import (C, ImmGetDescriptionW, "ImmGetDescriptionW");
function ImmGetIMEFileNameA (a1 : access windef.struct_HKL;
a2 : access winnt.C_CHAR; uBufLen : windef.UINT) return windef.UINT;
pragma Import (C, ImmGetIMEFileNameA, "ImmGetIMEFileNameA");
function ImmGetIMEFileNameW (a1 : access windef.struct_HKL;
a2 : access winnt.WCHAR; uBufLen : windef.UINT) return windef.UINT;
pragma Import (C, ImmGetIMEFileNameW, "ImmGetIMEFileNameW");
function ImmGetProperty (a1 : access windef.struct_HKL; a2 : windef.DWORD)
return windef.DWORD;
pragma Import (C, ImmGetProperty, "ImmGetProperty");
function ImmIsIME (a1 : access windef.struct_HKL) return windef.WINBOOL;
pragma Import (C, ImmIsIME, "ImmIsIME");
function ImmSimulateHotKey (a1 : access windef.struct_HWND;
a2 : windef.DWORD) return windef.WINBOOL;
pragma Import (C, ImmSimulateHotKey, "ImmSimulateHotKey");
function ImmCreateContext return HIMC;
pragma Import (C, ImmCreateContext, "ImmCreateContext");
function ImmDestroyContext (a1 : access struct_HIMC)
return windef.WINBOOL;
pragma Import (C, ImmDestroyContext, "ImmDestroyContext");
function ImmGetContext (a1 : access windef.struct_HWND) return HIMC;
pragma Import (C, ImmGetContext, "ImmGetContext");
function ImmReleaseContext (a1 : access windef.struct_HWND;
a2 : access struct_HIMC) return windef.WINBOOL;
pragma Import (C, ImmReleaseContext, "ImmReleaseContext");
function ImmAssociateContext (a1 : access windef.struct_HWND;
a2 : access struct_HIMC) return HIMC;
pragma Import (C, ImmAssociateContext, "ImmAssociateContext");
function ImmAssociateContextEx (a1 : access windef.struct_HWND;
a2 : access struct_HIMC; a3 : windef.DWORD) return windef.WINBOOL;
pragma Import (C, ImmAssociateContextEx, "ImmAssociateContextEx");
function ImmGetCompositionStringA (a1 : access struct_HIMC;
a2 : windef.DWORD; a3 : windef.LPVOID; a4 : windef.DWORD)
return winnt.LONG;
pragma Import (C, ImmGetCompositionStringA, "ImmGetCompositionStringA");
function ImmGetCompositionStringW (a1 : access struct_HIMC;
a2 : windef.DWORD; a3 : windef.LPVOID; a4 : windef.DWORD)
return winnt.LONG;
pragma Import (C, ImmGetCompositionStringW, "ImmGetCompositionStringW");
function ImmSetCompositionStringA (a1 : access struct_HIMC;
dwIndex : windef.DWORD; lpComp : windef.LPVOID; a4 : windef.DWORD;
lpRead : windef.LPVOID; a6 : windef.DWORD) return windef.WINBOOL;
pragma Import (C, ImmSetCompositionStringA, "ImmSetCompositionStringA");
function ImmSetCompositionStringW (a1 : access struct_HIMC;
dwIndex : windef.DWORD; lpComp : windef.LPVOID; a4 : windef.DWORD;
lpRead : windef.LPVOID; a6 : windef.DWORD) return windef.WINBOOL;
pragma Import (C, ImmSetCompositionStringW, "ImmSetCompositionStringW");
function ImmGetCandidateListCountA (a1 : access struct_HIMC;
lpdwListCount : access windef.DWORD) return windef.DWORD;
pragma Import (C, ImmGetCandidateListCountA, "ImmGetCandidateListCountA");
function ImmGetCandidateListCountW (a1 : access struct_HIMC;
lpdwListCount : access windef.DWORD) return windef.DWORD;
pragma Import (C, ImmGetCandidateListCountW, "ImmGetCandidateListCountW");
function ImmGetCandidateListA (a1 : access struct_HIMC;
deIndex : windef.DWORD; a3 : access struct_tagCANDIDATELIST;
dwBufLen : windef.DWORD) return windef.DWORD;
pragma Import (C, ImmGetCandidateListA, "ImmGetCandidateListA");
function ImmGetCandidateListW (a1 : access struct_HIMC;
deIndex : windef.DWORD; a3 : access struct_tagCANDIDATELIST;
dwBufLen : windef.DWORD) return windef.DWORD;
pragma Import (C, ImmGetCandidateListW, "ImmGetCandidateListW");
function ImmGetGuideLineA (a1 : access struct_HIMC;
dwIndex : windef.DWORD; a3 : access winnt.C_CHAR;
dwBufLen : windef.DWORD) return windef.DWORD;
pragma Import (C, ImmGetGuideLineA, "ImmGetGuideLineA");
function ImmGetGuideLineW (a1 : access struct_HIMC;
dwIndex : windef.DWORD; a3 : access winnt.WCHAR;
dwBufLen : windef.DWORD) return windef.DWORD;
pragma Import (C, ImmGetGuideLineW, "ImmGetGuideLineW");
function ImmGetConversionStatus (a1 : access struct_HIMC;
a2 : access windef.DWORD; a3 : access windef.DWORD)
return windef.WINBOOL;
pragma Import (C, ImmGetConversionStatus, "ImmGetConversionStatus");
function ImmSetConversionStatus (a1 : access struct_HIMC;
a2 : windef.DWORD; a3 : windef.DWORD) return windef.WINBOOL;
pragma Import (C, ImmSetConversionStatus, "ImmSetConversionStatus");
function ImmGetOpenStatus (a1 : access struct_HIMC) return windef.WINBOOL;
pragma Import (C, ImmGetOpenStatus, "ImmGetOpenStatus");
function ImmSetOpenStatus (a1 : access struct_HIMC; a2 : windef.WINBOOL)
return windef.WINBOOL;
pragma Import (C, ImmSetOpenStatus, "ImmSetOpenStatus");
function ImmGetCompositionFontA (a1 : access struct_HIMC;
a2 : access wingdi.struct_tagLOGFONTA) return windef.WINBOOL;
pragma Import (C, ImmGetCompositionFontA, "ImmGetCompositionFontA");
function ImmGetCompositionFontW (a1 : access struct_HIMC;
a2 : access wingdi.struct_tagLOGFONTW) return windef.WINBOOL;
pragma Import (C, ImmGetCompositionFontW, "ImmGetCompositionFontW");
function ImmSetCompositionFontA (a1 : access struct_HIMC;
a2 : access wingdi.struct_tagLOGFONTA) return windef.WINBOOL;
pragma Import (C, ImmSetCompositionFontA, "ImmSetCompositionFontA");
function ImmSetCompositionFontW (a1 : access struct_HIMC;
a2 : access wingdi.struct_tagLOGFONTW) return windef.WINBOOL;
pragma Import (C, ImmSetCompositionFontW, "ImmSetCompositionFontW");
type access_c481ef12 is access function (
a1 : access constant winnt.C_CHAR; a2 : windef.DWORD;
a3 : access constant winnt.C_CHAR; a4 : windef.LPVOID)
return signed_int;
pragma Convention (C, access_c481ef12);
subtype REGISTERWORDENUMPROCA is access_c481ef12;
type access_b0368f86 is access function (a1 : access constant winnt.WCHAR;
a2 : windef.DWORD; a3 : access constant winnt.WCHAR;
a4 : windef.LPVOID) return signed_int;
pragma Convention (C, access_b0368f86);
subtype REGISTERWORDENUMPROCW is access_b0368f86;
function ImmConfigureIMEA (a1 : access windef.struct_HKL;
a2 : access windef.struct_HWND; a3 : windef.DWORD; a4 : windef.LPVOID)
return windef.WINBOOL;
pragma Import (C, ImmConfigureIMEA, "ImmConfigureIMEA");
function ImmConfigureIMEW (a1 : access windef.struct_HKL;
a2 : access windef.struct_HWND; a3 : windef.DWORD; a4 : windef.LPVOID)
return windef.WINBOOL;
pragma Import (C, ImmConfigureIMEW, "ImmConfigureIMEW");
function ImmEscapeA (a1 : access windef.struct_HKL;
a2 : access struct_HIMC; a3 : windef.UINT; a4 : windef.LPVOID)
return windef.LRESULT;
pragma Import (C, ImmEscapeA, "ImmEscapeA");
function ImmEscapeW (a1 : access windef.struct_HKL;
a2 : access struct_HIMC; a3 : windef.UINT; a4 : windef.LPVOID)
return windef.LRESULT;
pragma Import (C, ImmEscapeW, "ImmEscapeW");
function ImmGetConversionListA (a1 : access windef.struct_HKL;
a2 : access struct_HIMC; a3 : access constant winnt.C_CHAR;
a4 : access struct_tagCANDIDATELIST; dwBufLen : windef.DWORD;
uFlag : windef.UINT) return windef.DWORD;
pragma Import (C, ImmGetConversionListA, "ImmGetConversionListA");
function ImmGetConversionListW (a1 : access windef.struct_HKL;
a2 : access struct_HIMC; a3 : access constant winnt.WCHAR;
a4 : access struct_tagCANDIDATELIST; dwBufLen : windef.DWORD;
uFlag : windef.UINT) return windef.DWORD;
pragma Import (C, ImmGetConversionListW, "ImmGetConversionListW");
function ImmNotifyIME (a1 : access struct_HIMC; dwAction : windef.DWORD;
dwIndex : windef.DWORD; dwValue : windef.DWORD) return windef.WINBOOL;
pragma Import (C, ImmNotifyIME, "ImmNotifyIME");
function ImmGetStatusWindowPos (a1 : access struct_HIMC;
a2 : access windef.struct_tagPOINT) return windef.WINBOOL;
pragma Import (C, ImmGetStatusWindowPos, "ImmGetStatusWindowPos");
function ImmSetStatusWindowPos (a1 : access struct_HIMC;
a2 : access windef.struct_tagPOINT) return windef.WINBOOL;
pragma Import (C, ImmSetStatusWindowPos, "ImmSetStatusWindowPos");
function ImmGetCompositionWindow (a1 : access struct_HIMC;
a2 : access struct_tagCOMPOSITIONFORM) return windef.WINBOOL;
pragma Import (C, ImmGetCompositionWindow, "ImmGetCompositionWindow");
function ImmSetCompositionWindow (a1 : access struct_HIMC;
a2 : access struct_tagCOMPOSITIONFORM) return windef.WINBOOL;
pragma Import (C, ImmSetCompositionWindow, "ImmSetCompositionWindow");
function ImmGetCandidateWindow (a1 : access struct_HIMC;
a2 : windef.DWORD; a3 : access struct_tagCANDIDATEFORM)
return windef.WINBOOL;
pragma Import (C, ImmGetCandidateWindow, "ImmGetCandidateWindow");
function ImmSetCandidateWindow (a1 : access struct_HIMC;
a2 : access struct_tagCANDIDATEFORM) return windef.WINBOOL;
pragma Import (C, ImmSetCandidateWindow, "ImmSetCandidateWindow");
function ImmIsUIMessageA (a1 : access windef.struct_HWND;
a2 : windef.UINT; a3 : windef.WPARAM; a4 : windef.LPARAM)
return windef.WINBOOL;
pragma Import (C, ImmIsUIMessageA, "ImmIsUIMessageA");
function ImmIsUIMessageW (a1 : access windef.struct_HWND;
a2 : windef.UINT; a3 : windef.WPARAM; a4 : windef.LPARAM)
return windef.WINBOOL;
pragma Import (C, ImmIsUIMessageW, "ImmIsUIMessageW");
function ImmGetVirtualKey (a1 : access windef.struct_HWND)
return windef.UINT;
pragma Import (C, ImmGetVirtualKey, "ImmGetVirtualKey");
function ImmRegisterWordA (a1 : access windef.struct_HKL;
lpszReading : access constant winnt.C_CHAR; a3 : windef.DWORD;
lpszRegister : access constant winnt.C_CHAR) return windef.WINBOOL;
pragma Import (C, ImmRegisterWordA, "ImmRegisterWordA");
function ImmRegisterWordW (a1 : access windef.struct_HKL;
lpszReading : access constant winnt.WCHAR; a3 : windef.DWORD;
lpszRegister : access constant winnt.WCHAR) return windef.WINBOOL;
pragma Import (C, ImmRegisterWordW, "ImmRegisterWordW");
function ImmUnregisterWordA (a1 : access windef.struct_HKL;
lpszReading : access constant winnt.C_CHAR; a3 : windef.DWORD;
lpszUnregister : access constant winnt.C_CHAR) return windef.WINBOOL;
pragma Import (C, ImmUnregisterWordA, "ImmUnregisterWordA");
function ImmUnregisterWordW (a1 : access windef.struct_HKL;
lpszReading : access constant winnt.WCHAR; a3 : windef.DWORD;
lpszUnregister : access constant winnt.WCHAR) return windef.WINBOOL;
pragma Import (C, ImmUnregisterWordW, "ImmUnregisterWordW");
function ImmGetRegisterWordStyleA (a1 : access windef.struct_HKL;
nItem : windef.UINT; a3 : access struct_tagSTYLEBUFA)
return windef.UINT;
pragma Import (C, ImmGetRegisterWordStyleA, "ImmGetRegisterWordStyleA");
function ImmGetRegisterWordStyleW (a1 : access windef.struct_HKL;
nItem : windef.UINT; a3 : access struct_tagSTYLEBUFW)
return windef.UINT;
pragma Import (C, ImmGetRegisterWordStyleW, "ImmGetRegisterWordStyleW");
function ImmEnumRegisterWordA (a1 : access windef.struct_HKL;
a2 : REGISTERWORDENUMPROCA; lpszReading : access constant winnt.C_CHAR;
a4 : windef.DWORD; lpszRegister : access constant winnt.C_CHAR;
a6 : windef.LPVOID) return windef.UINT;
pragma Import (C, ImmEnumRegisterWordA, "ImmEnumRegisterWordA");
function ImmEnumRegisterWordW (a1 : access windef.struct_HKL;
a2 : REGISTERWORDENUMPROCW; lpszReading : access constant winnt.WCHAR;
a4 : windef.DWORD; lpszRegister : access constant winnt.WCHAR;
a6 : windef.LPVOID) return windef.UINT;
pragma Import (C, ImmEnumRegisterWordW, "ImmEnumRegisterWordW");
function ImmDisableIME (a1 : windef.DWORD) return windef.WINBOOL;
pragma Import (C, ImmDisableIME, "ImmDisableIME");
function ImmEnumInputContext (idThread : windef.DWORD; lpfn : IMCENUMPROC;
lParam : windef.LPARAM) return windef.WINBOOL;
pragma Import (C, ImmEnumInputContext, "ImmEnumInputContext");
function ImmGetImeMenuItemsA (a1 : access struct_HIMC; a2 : windef.DWORD;
a3 : windef.DWORD; a4 : access struct_tagIMEMENUITEMINFOA;
a5 : access struct_tagIMEMENUITEMINFOA; a6 : windef.DWORD)
return windef.DWORD;
pragma Import (C, ImmGetImeMenuItemsA, "ImmGetImeMenuItemsA");
function ImmGetImeMenuItemsW (a1 : access struct_HIMC; a2 : windef.DWORD;
a3 : windef.DWORD; a4 : access struct_tagIMEMENUITEMINFOW;
a5 : access struct_tagIMEMENUITEMINFOW; a6 : windef.DWORD)
return windef.DWORD;
pragma Import (C, ImmGetImeMenuItemsW, "ImmGetImeMenuItemsW");
function ImmDisableTextFrameService (idThread : windef.DWORD)
return windef.WINBOOL;
pragma Import (C, ImmDisableTextFrameService,
"ImmDisableTextFrameService");
ATTR_CONVERTED : constant := 2;
ATTR_FIXEDCONVERTED : constant := 5;
ATTR_INPUT : constant := 0;
ATTR_INPUT_ERROR : constant := 4;
ATTR_TARGET_CONVERTED : constant := 1;
ATTR_TARGET_NOTCONVERTED : constant := 3;
CFS_CANDIDATEPOS : constant := 64;
CFS_DEFAULT : constant := 0;
CFS_EXCLUDE : constant := 128;
CFS_FORCE_POSITION : constant := 32;
CFS_POINT : constant := 2;
CFS_RECT : constant := 1;
CPS_CANCEL : constant := 4;
CPS_COMPLETE : constant := 1;
CPS_CONVERT : constant := 2;
CPS_REVERT : constant := 3;
CS_INSERTCHAR : constant := 8192;
CS_NOMOVECARET : constant := 16384;
-- DEFINED_LPUINT (empty)
GCL_CONVERSION : constant := 1;
GCL_REVERSECONVERSION : constant := 2;
GCL_REVERSE_LENGTH : constant := 3;
GCS_COMPATTR : constant := 16;
GCS_COMPCLAUSE : constant := 32;
GCS_COMPREADATTR : constant := 2;
GCS_COMPREADCLAUSE : constant := 4;
GCS_COMPREADSTR : constant := 1;
GCS_COMPSTR : constant := 8;
GCS_CURSORPOS : constant := 128;
GCS_DELTASTART : constant := 256;
GCS_RESULTCLAUSE : constant := 4096;
GCS_RESULTREADCLAUSE : constant := 1024;
GCS_RESULTREADSTR : constant := 512;
GCS_RESULTSTR : constant := 2048;
GGL_INDEX : constant := 2;
GGL_LEVEL : constant := 1;
GGL_PRIVATE : constant := 4;
GGL_STRING : constant := 3;
GL_ID_CANNOTSAVE : constant := 17;
GL_ID_CHOOSECANDIDATE : constant := 40;
GL_ID_INPUTCODE : constant := 38;
GL_ID_INPUTRADICAL : constant := 37;
GL_ID_INPUTREADING : constant := 36;
GL_ID_INPUTSYMBOL : constant := 39;
GL_ID_NOCONVERT : constant := 32;
GL_ID_NODICTIONARY : constant := 16;
GL_ID_NOMODULE : constant := 1;
GL_ID_PRIVATE_FIRST : constant := 32768;
GL_ID_PRIVATE_LAST : constant := 65535;
GL_ID_READINGCONFLICT : constant := 35;
GL_ID_REVERSECONVERSION : constant := 41;
GL_ID_TOOMANYSTROKE : constant := 34;
GL_ID_TYPINGERROR : constant := 33;
GL_ID_UNKNOWN : constant := 0;
GL_LEVEL_ERROR : constant := 2;
GL_LEVEL_FATAL : constant := 1;
GL_LEVEL_INFORMATION : constant := 4;
GL_LEVEL_NOGUIDELINE : constant := 0;
GL_LEVEL_WARNING : constant := 3;
IACE_CHILDREN : constant := 1;
IACE_DEFAULT : constant := 16;
IACE_IGNORENOCONTEXT : constant := 32;
IGIMIF_RIGHTMENU : constant := 1;
IGIMII_CMODE : constant := 1;
IGIMII_CONFIGURE : constant := 4;
IGIMII_HELP : constant := 16;
IGIMII_INPUTTOOLS : constant := 64;
IGIMII_OTHER : constant := 32;
IGIMII_SMODE : constant := 2;
IGIMII_TOOLS : constant := 8;
IGP_CONVERSION : constant := 8;
IGP_GETIMEVERSION : constant := 4294967292;
IGP_PROPERTY : constant := 4;
IGP_SELECT : constant := 24;
IGP_SENTENCE : constant := 12;
IGP_SETCOMPSTR : constant := 20;
IGP_UI : constant := 16;
IMC_CLOSESTATUSWINDOW : constant := 33;
IMC_GETCANDIDATEPOS : constant := 7;
IMC_GETCOMPOSITIONFONT : constant := 9;
IMC_GETCOMPOSITIONWINDOW : constant := 11;
IMC_GETSTATUSWINDOWPOS : constant := 15;
IMC_OPENSTATUSWINDOW : constant := 34;
IMC_SETCANDIDATEPOS : constant := 8;
IMC_SETCOMPOSITIONFONT : constant := 10;
IMC_SETCOMPOSITIONWINDOW : constant := 12;
IMC_SETSTATUSWINDOWPOS : constant := 16;
IMEMENUITEM_STRING_SIZE : constant := 80;
IMEVER_0310 : constant := 196618;
IMEVER_0400 : constant := 262144;
IME_CAND_CODE : constant := 2;
IME_CAND_MEANING : constant := 3;
IME_CAND_RADICAL : constant := 4;
IME_CAND_READ : constant := 1;
IME_CAND_STROKE : constant := 5;
IME_CAND_UNKNOWN : constant := 0;
IME_CHOTKEY_IME_NONIME_TOGGLE : constant := 16;
IME_CHOTKEY_SHAPE_TOGGLE : constant := 17;
IME_CHOTKEY_SYMBOL_TOGGLE : constant := 18;
IME_CMODE_ALPHANUMERIC : constant := 0;
IME_CMODE_CHARCODE : constant := 32;
IME_CMODE_CHINESE : constant := 1;
IME_CMODE_EUDC : constant := 512;
IME_CMODE_FIXED : constant := 2048;
IME_CMODE_FULLSHAPE : constant := 8;
IME_CMODE_HANGEUL : constant := 1;
IME_CMODE_HANGUL : constant := 1;
IME_CMODE_HANJACONVERT : constant := 64;
IME_CMODE_JAPANESE : constant := 1;
IME_CMODE_KATAKANA : constant := 2;
IME_CMODE_LANGUAGE : constant := 3;
IME_CMODE_NATIVE : constant := 1;
IME_CMODE_NOCONVERSION : constant := 256;
IME_CMODE_RESERVED : constant := -268435456;
IME_CMODE_ROMAN : constant := 16;
IME_CMODE_SOFTKBD : constant := 128;
IME_CMODE_SYMBOL : constant := 1024;
IME_CONFIG_GENERAL : constant := 1;
IME_CONFIG_REGISTERWORD : constant := 2;
IME_CONFIG_SELECTDICTIONARY : constant := 3;
IME_ESC_AUTOMATA : constant := 4105;
IME_ESC_GETHELPFILENAME : constant := 4107;
IME_ESC_GET_EUDC_DICTIONARY : constant := 4099;
IME_ESC_HANJA_MODE : constant := 4104;
IME_ESC_IME_NAME : constant := 4102;
IME_ESC_MAX_KEY : constant := 4101;
IME_ESC_PRIVATE_FIRST : constant := 2048;
IME_ESC_PRIVATE_HOTKEY : constant := 4106;
IME_ESC_PRIVATE_LAST : constant := 4095;
IME_ESC_QUERY_SUPPORT : constant := 3;
IME_ESC_RESERVED_FIRST : constant := 4;
IME_ESC_RESERVED_LAST : constant := 2047;
IME_ESC_SEQUENCE_TO_INTERNAL : constant := 4097;
IME_ESC_SET_EUDC_DICTIONARY : constant := 4100;
IME_ESC_SYNC_HOTKEY : constant := 4103;
IME_HOTKEY_DSWITCH_FIRST : constant := 256;
IME_HOTKEY_DSWITCH_LAST : constant := 287;
IME_HOTKEY_PRIVATE_FIRST : constant := 512;
IME_HOTKEY_PRIVATE_LAST : constant := 543;
IME_ITHOTKEY_PREVIOUS_COMPOSITION : constant := 513;
IME_ITHOTKEY_RECONVERTSTRING : constant := 515;
IME_ITHOTKEY_RESEND_RESULTSTR : constant := 512;
IME_ITHOTKEY_UISTYLE_TOGGLE : constant := 514;
IME_JHOTKEY_CLOSE_OPEN : constant := 48;
IME_KHOTKEY_ENGLISH : constant := 82;
IME_KHOTKEY_HANJACONVERT : constant := 81;
IME_KHOTKEY_SHAPE_TOGGLE : constant := 80;
IME_PROP_AT_CARET : constant := 65536;
IME_PROP_CANDLIST_START_FROM_1 : constant := 262144;
IME_PROP_COMPLETE_ON_UNSELECT : constant := 1048576;
IME_PROP_SPECIAL_UI : constant := 131072;
IME_PROP_UNICODE : constant := 524288;
IME_REGWORD_STYLE_EUDC : constant := 1;
IME_REGWORD_STYLE_USER_FIRST : constant := -2147483648;
IME_REGWORD_STYLE_USER_LAST : constant := -1;
IME_SMODE_AUTOMATIC : constant := 4;
IME_SMODE_CONVERSATION : constant := 16;
IME_SMODE_NONE : constant := 0;
IME_SMODE_PHRASEPREDICT : constant := 8;
IME_SMODE_PLAURALCLAUSE : constant := 1;
IME_SMODE_RESERVED : constant := 61440;
IME_SMODE_SINGLECONVERT : constant := 2;
IME_THOTKEY_IME_NONIME_TOGGLE : constant := 112;
IME_THOTKEY_SHAPE_TOGGLE : constant := 113;
IME_THOTKEY_SYMBOL_TOGGLE : constant := 114;
IMFS_CHECKED : constant := 8;
IMFS_DEFAULT : constant := 4096;
IMFS_DISABLED : constant := 3;
IMFS_ENABLED : constant := 0;
IMFS_GRAYED : constant := 3;
IMFS_HILITE : constant := 128;
IMFS_UNCHECKED : constant := 0;
IMFS_UNHILITE : constant := 0;
IMFT_RADIOCHECK : constant := 1;
IMFT_SEPARATOR : constant := 2;
IMFT_SUBMENU : constant := 4;
IMM_ERROR_GENERAL : constant := -2;
IMM_ERROR_NODATA : constant := -1;
IMN_CHANGECANDIDATE : constant := 3;
IMN_CLOSECANDIDATE : constant := 4;
IMN_CLOSESTATUSWINDOW : constant := 1;
IMN_GUIDELINE : constant := 13;
IMN_OPENCANDIDATE : constant := 5;
IMN_OPENSTATUSWINDOW : constant := 2;
IMN_PRIVATE : constant := 14;
IMN_SETCANDIDATEPOS : constant := 9;
IMN_SETCOMPOSITIONFONT : constant := 10;
IMN_SETCOMPOSITIONWINDOW : constant := 11;
IMN_SETCONVERSIONMODE : constant := 6;
IMN_SETOPENSTATUS : constant := 8;
IMN_SETSENTENCEMODE : constant := 7;
IMN_SETSTATUSWINDOWPOS : constant := 12;
IMR_CANDIDATEWINDOW : constant := 2;
IMR_COMPOSITIONFONT : constant := 3;
IMR_COMPOSITIONWINDOW : constant := 1;
IMR_CONFIRMRECONVERTSTRING : constant := 5;
IMR_DOCUMENTFEED : constant := 7;
IMR_QUERYCHARPOSITION : constant := 6;
IMR_RECONVERTSTRING : constant := 4;
ISC_SHOWUIALL : constant := -1073741809;
ISC_SHOWUIALLCANDIDATEWINDOW : constant := 15;
ISC_SHOWUICANDIDATEWINDOW : constant := 1;
ISC_SHOWUICOMPOSITIONWINDOW : constant := -2147483648;
ISC_SHOWUIGUIDELINE : constant := 1073741824;
function ImmConfigureIME (a1 : access windef.struct_HKL;
a2 : access windef.struct_HWND; a3 : windef.DWORD; a4 : windef.LPVOID)
return windef.WINBOOL renames ImmConfigureIMEW;
function ImmEnumRegisterWord (a1 : access windef.struct_HKL;
a2 : REGISTERWORDENUMPROCW; lpszReading : access constant winnt.WCHAR;
a4 : windef.DWORD; lpszRegister : access constant winnt.WCHAR;
a6 : windef.LPVOID) return windef.UINT renames ImmEnumRegisterWordW;
function ImmEscape (a1 : access windef.struct_HKL;
a2 : access struct_HIMC; a3 : windef.UINT; a4 : windef.LPVOID)
return windef.LRESULT renames ImmEscapeW;
function ImmGetCandidateList (a1 : access struct_HIMC;
deIndex : windef.DWORD; a3 : access struct_tagCANDIDATELIST;
dwBufLen : windef.DWORD) return windef.DWORD
renames ImmGetCandidateListW;
function ImmGetCandidateListCount (a1 : access struct_HIMC;
lpdwListCount : access windef.DWORD) return windef.DWORD
renames ImmGetCandidateListCountW;
function ImmGetCompositionFont (a1 : access struct_HIMC;
a2 : access wingdi.struct_tagLOGFONTW) return windef.WINBOOL
renames ImmGetCompositionFontW;
function ImmGetCompositionString (a1 : access struct_HIMC;
a2 : windef.DWORD; a3 : windef.LPVOID; a4 : windef.DWORD)
return winnt.LONG renames ImmGetCompositionStringW;
function ImmGetConversionList (a1 : access windef.struct_HKL;
a2 : access struct_HIMC; a3 : access constant winnt.WCHAR;
a4 : access struct_tagCANDIDATELIST; dwBufLen : windef.DWORD;
uFlag : windef.UINT) return windef.DWORD renames ImmGetConversionListW;
function ImmGetDescription (a1 : access windef.struct_HKL;
a2 : access winnt.WCHAR; uBufLen : windef.UINT) return windef.UINT
renames ImmGetDescriptionW;
function ImmGetGuideLine (a1 : access struct_HIMC; dwIndex : windef.DWORD;
a3 : access winnt.WCHAR; dwBufLen : windef.DWORD) return windef.DWORD
renames ImmGetGuideLineW;
function ImmGetIMEFileName (a1 : access windef.struct_HKL;
a2 : access winnt.WCHAR; uBufLen : windef.UINT) return windef.UINT
renames ImmGetIMEFileNameW;
function ImmGetImeMenuItems (a1 : access struct_HIMC; a2 : windef.DWORD;
a3 : windef.DWORD; a4 : access struct_tagIMEMENUITEMINFOW;
a5 : access struct_tagIMEMENUITEMINFOW; a6 : windef.DWORD)
return windef.DWORD renames ImmGetImeMenuItemsW;
function ImmGetRegisterWordStyle (a1 : access windef.struct_HKL;
nItem : windef.UINT; a3 : access struct_tagSTYLEBUFW)
return windef.UINT renames ImmGetRegisterWordStyleW;
function ImmInstallIME (lpszIMEFileName : access constant winnt.WCHAR;
lpszLayoutText : access constant winnt.WCHAR) return windef.HKL
renames ImmInstallIMEW;
function ImmIsUIMessage (a1 : access windef.struct_HWND; a2 : windef.UINT;
a3 : windef.WPARAM; a4 : windef.LPARAM) return windef.WINBOOL
renames ImmIsUIMessageW;
function ImmRegisterWord (a1 : access windef.struct_HKL;
lpszReading : access constant winnt.WCHAR; a3 : windef.DWORD;
lpszRegister : access constant winnt.WCHAR) return windef.WINBOOL
renames ImmRegisterWordW;
function ImmSetCompositionFont (a1 : access struct_HIMC;
a2 : access wingdi.struct_tagLOGFONTW) return windef.WINBOOL
renames ImmSetCompositionFontW;
function ImmSetCompositionString (a1 : access struct_HIMC;
dwIndex : windef.DWORD; lpComp : windef.LPVOID; a4 : windef.DWORD;
lpRead : windef.LPVOID; a6 : windef.DWORD) return windef.WINBOOL
renames ImmSetCompositionStringW;
function ImmUnregisterWord (a1 : access windef.struct_HKL;
lpszReading : access constant winnt.WCHAR; a3 : windef.DWORD;
lpszUnregister : access constant winnt.WCHAR) return windef.WINBOOL
renames ImmUnregisterWordW;
MOD_IGNORE_ALL_MODIFIER : constant := 1024;
MOD_LEFT : constant := 32768;
MOD_ON_KEYUP : constant := 2048;
MOD_RIGHT : constant := 16384;
NI_CHANGECANDIDATELIST : constant := 19;
NI_CLOSECANDIDATE : constant := 17;
NI_COMPOSITIONSTR : constant := 21;
NI_FINALIZECONVERSIONRESULT : constant := 20;
NI_IMEMENUSELECTED : constant := 24;
NI_OPENCANDIDATE : constant := 16;
NI_SELECTCANDIDATESTR : constant := 18;
NI_SETCANDIDATE_PAGESIZE : constant := 23;
NI_SETCANDIDATE_PAGESTART : constant := 22;
subtype REGISTERWORDENUMPROC is REGISTERWORDENUMPROCW;
SCS_CAP_COMPSTR : constant := 1;
SCS_CAP_MAKEREAD : constant := 2;
SCS_CAP_SETRECONVERTSTRING : constant := 4;
SCS_CHANGEATTR : constant := 18;
SCS_CHANGECLAUSE : constant := 36;
SCS_QUERYRECONVERTSTRING : constant := 131072;
SCS_SETRECONVERTSTRING : constant := 65536;
SCS_SETSTR : constant := 9;
SELECT_CAP_CONVERSION : constant := 1;
SELECT_CAP_SENTENCE : constant := 2;
SOFTKEYBOARD_TYPE_C1 : constant := 2;
SOFTKEYBOARD_TYPE_T1 : constant := 1;
STYLE_DESCRIPTION_SIZE : constant := 32;
UI_CAP_2700 : constant := 1;
UI_CAP_ROT90 : constant := 2;
UI_CAP_ROTANY : constant := 4;
-- _IMM_ (empty)
-- _IMM_SDK_DEFINED_ (empty)
end C.imm;
Raw
c-in6addr.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
with C.qbsd_types;
package C.in6addr is
pragma Preelaborate;
subtype u_short_array8 is qbsd_types.u_short_array (0 .. 7);
subtype u_char_array16 is qbsd_types.u_char_array (0 .. 15);
type struct_in6_addr;
type union_ddc67b37 (Unchecked_Tag : unsigned_int := 0) is record
case Unchecked_Tag is
when 0 =>
Byte : qbsd_types.u_char_array (0 .. 15);
when others =>
Word : qbsd_types.u_short_array (0 .. 7);
end case;
end record;
pragma Unchecked_Union (union_ddc67b37);
pragma Convention (C_Pass_By_Copy, union_ddc67b37);
type struct_in6_addr is record
u : aliased union_ddc67b37;
end record;
pragma Convention (C_Pass_By_Copy, struct_in6_addr);
type struct_in6_addr_ptr is access all struct_in6_addr;
for struct_in6_addr_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_in6_addr_ptr);
pragma Convention (C, struct_in6_addr_ptr);
type struct_in6_addr_const_ptr is access constant struct_in6_addr;
for struct_in6_addr_const_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_in6_addr_const_ptr);
pragma Convention (C, struct_in6_addr_const_ptr);
subtype IN6_ADDR is struct_in6_addr;
subtype IN6_ADDR_const_ptr is struct_in6_addr_const_ptr;
subtype IN6_ADDR_ptr is struct_in6_addr_ptr;
subtype PIN6_ADDR is struct_in6_addr_ptr;
subtype LPIN6_ADDR is struct_in6_addr_ptr;
-- ._S6_u8 renames .Byte (accessor)
-- subtype in_addr6 is struct in6_addr;
-- .s6_bytes renames .u.Byte (accessor)
-- .s6_words renames .u.Word (accessor)
end C.in6addr;
Raw
c-inaddr.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
with C.qbsd_types;
package C.inaddr is
pragma Preelaborate;
type struct_in_addr;
type struct_8dead967 is record
s_b1 : aliased qbsd_types.u_char;
s_b2 : aliased qbsd_types.u_char;
s_b3 : aliased qbsd_types.u_char;
s_b4 : aliased qbsd_types.u_char;
end record;
pragma Convention (C_Pass_By_Copy, struct_8dead967);
type struct_78b6e561 is record
s_w1 : aliased qbsd_types.u_short;
s_w2 : aliased qbsd_types.u_short;
end record;
pragma Convention (C_Pass_By_Copy, struct_78b6e561);
type union_ab5bac53 (Unchecked_Tag : unsigned_int := 0) is record
case Unchecked_Tag is
when 0 =>
S_un_b : struct_8dead967;
when 1 =>
S_un_w : struct_78b6e561;
when others =>
S_addr : qbsd_types.u_long;
end case;
end record;
pragma Unchecked_Union (union_ab5bac53);
pragma Convention (C_Pass_By_Copy, union_ab5bac53);
type struct_in_addr is record
S_un : aliased union_ab5bac53;
end record;
pragma Convention (C_Pass_By_Copy, struct_in_addr);
type struct_in_addr_ptr is access all struct_in_addr;
for struct_in_addr_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_in_addr_ptr);
pragma Convention (C, struct_in_addr_ptr);
type struct_in_addr_array is array (size_t range <>) of
aliased struct_in_addr;
pragma Convention (C, struct_in_addr_array);
type struct_in_addr_const_ptr is access constant struct_in_addr;
for struct_in_addr_const_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_in_addr_const_ptr);
pragma Convention (C, struct_in_addr_const_ptr);
subtype IN_ADDR is struct_in_addr;
subtype IN_ADDR_const_ptr is struct_in_addr_const_ptr;
subtype IN_ADDR_ptr is struct_in_addr_ptr;
subtype PIN_ADDR is struct_in_addr_ptr;
subtype LPIN_ADDR is struct_in_addr_ptr;
-- .s_addr renames .S_un.S_addr (accessor)
-- .s_host renames .S_un.S_un_b.s_b2 (accessor)
-- .s_imp renames .S_un.S_un_w.s_w2 (accessor)
-- .s_impno renames .S_un.S_un_b.s_b4 (accessor)
-- .s_lh renames .S_un.S_un_b.s_b3 (accessor)
-- .s_net renames .S_un.S_un_b.s_b1 (accessor)
end C.inaddr;
Raw
c-limits.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.limits is
pragma Preelaborate;
CHAR_BIT : constant := 8;
CHAR_MAX : constant := 127;
CHAR_MIN : constant := -128;
INT_MAX : constant := 2147483647;
INT_MIN : constant := -2147483648;
LLONG_MAX : constant := 9223372036854775807;
LLONG_MIN : constant := -9223372036854775808;
LONG_LONG_MAX : constant := 9223372036854775807;
LONG_LONG_MIN : constant := -9223372036854775808;
LONG_MAX : constant := 2147483647;
LONG_MIN : constant := -2147483648;
SCHAR_MAX : constant := 127;
SCHAR_MIN : constant := -128;
SHRT_MAX : constant := 32767;
SHRT_MIN : constant := -32768;
UCHAR_MAX : constant := 255;
UINT_MAX : constant := 4294967295;
ULLONG_MAX : constant := 18446744073709551615;
ULONG_LONG_MAX : constant := 18446744073709551615;
ULONG_MAX : constant := 4294967295;
USHRT_MAX : constant := 65535;
-- _GCC_LIMITS_H_ (empty)
-- _LIMITS_H___ (empty)
MB_LEN_MAX : constant := 5;
PATH_MAX : constant := 260;
SSIZE_MAX : constant := 9223372036854775807;
I16_MAX : constant := 32767;
I16_MIN : constant := -32768;
I32_MAX : constant := 2147483647;
I32_MIN : constant := -2147483648;
I64_MAX : constant := 9223372036854775807;
I64_MIN : constant := -9223372036854775808;
I8_MAX : constant := 127;
I8_MIN : constant := -128;
-- _INC_LIMITS (empty)
UI16_MAX : constant := 65535;
UI32_MAX : constant := 4294967295;
UI64_MAX : constant := 18446744073709551615;
UI8_MAX : constant := 255;
end C.limits;
Raw
c-malloc.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
with C.qmingw;
package C.malloc is
pragma Preelaborate;
type struct_heapinfo;
type struct_heapinfo is record
pentry : aliased signed_int_ptr;
size : aliased qmingw.size_t;
useflag : aliased signed_int;
end record;
for struct_heapinfo'Alignment use 8;
pragma Convention (C_Pass_By_Copy, struct_heapinfo);
type struct_heapinfo_ptr is access all struct_heapinfo;
for struct_heapinfo_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_heapinfo_ptr);
pragma Convention (C, struct_heapinfo_ptr);
subtype HEAPINFO is struct_heapinfo;
subtype HEAPINFO_ptr is struct_heapinfo_ptr;
amblksiz : aliased unsigned_int;
pragma Import (C, amblksiz, "_amblksiz");
function calloc (NumOfElements : qmingw.size_t;
SizeOfElements : qmingw.size_t) return void_ptr;
pragma Import (C, calloc, "calloc");
procedure free (Memory : void_ptr);
pragma Import (C, free, "free");
function malloc (Size : qmingw.size_t) return void_ptr;
pragma Import (C, malloc, "malloc");
function realloc (Memory : void_ptr; NewSize : qmingw.size_t)
return void_ptr;
pragma Import (C, realloc, "realloc");
function recalloc (Memory : void_ptr; Count : qmingw.size_t;
Size : qmingw.size_t) return void_ptr;
pragma Import (C, recalloc, "_recalloc");
procedure aligned_free (Memory : void_ptr);
pragma Import (C, aligned_free, "_aligned_free");
function aligned_malloc (Size : qmingw.size_t; Alignment : qmingw.size_t)
return void_ptr;
pragma Import (C, aligned_malloc, "_aligned_malloc");
function aligned_offset_malloc (Size : qmingw.size_t;
Alignment : qmingw.size_t; Offset : qmingw.size_t) return void_ptr;
pragma Import (C, aligned_offset_malloc, "_aligned_offset_malloc");
function aligned_realloc (Memory : void_ptr; Size : qmingw.size_t;
Alignment : qmingw.size_t) return void_ptr;
pragma Import (C, aligned_realloc, "_aligned_realloc");
function aligned_recalloc (Memory : void_ptr; Count : qmingw.size_t;
Size : qmingw.size_t; Alignment : qmingw.size_t) return void_ptr;
pragma Import (C, aligned_recalloc, "_aligned_recalloc");
function aligned_offset_realloc (Memory : void_ptr; Size : qmingw.size_t;
Alignment : qmingw.size_t; Offset : qmingw.size_t) return void_ptr;
pragma Import (C, aligned_offset_realloc, "_aligned_offset_realloc");
function aligned_offset_recalloc (Memory : void_ptr;
Count : qmingw.size_t; Size : qmingw.size_t; Alignment : qmingw.size_t;
Offset : qmingw.size_t) return void_ptr;
pragma Import (C, aligned_offset_recalloc, "_aligned_offset_recalloc");
function mingw_aligned_malloc (Size : qmingw.size_t;
Alignment : qmingw.size_t) return void_ptr;
pragma Import (C, mingw_aligned_malloc, "__mingw_aligned_malloc");
procedure mingw_aligned_free (Memory : void_ptr);
pragma Import (C, mingw_aligned_free, "__mingw_aligned_free");
function mingw_aligned_offset_realloc (Memory : void_ptr;
Size : qmingw.size_t; Alignment : qmingw.size_t;
Offset : qmingw.size_t) return void_ptr;
pragma Import (C, mingw_aligned_offset_realloc,
"__mingw_aligned_offset_realloc");
function mingw_aligned_realloc (Memory : void_ptr; Size : qmingw.size_t;
Offset : qmingw.size_t) return void_ptr;
pragma Import (C, mingw_aligned_realloc, "__mingw_aligned_realloc");
function resetstkoflw return signed_int;
pragma Import (C, resetstkoflw, "_resetstkoflw");
function set_malloc_crt_max_wait (NewValue : unsigned_long)
return unsigned_long;
pragma Import (C, set_malloc_crt_max_wait, "_set_malloc_crt_max_wait");
function expand (Memory : void_ptr; NewSize : qmingw.size_t)
return void_ptr;
pragma Import (C, expand, "_expand");
function msize (Memory : void_ptr) return qmingw.size_t;
pragma Import (C, msize, "_msize");
function get_sbh_threshold return qmingw.size_t;
pragma Import (C, get_sbh_threshold, "_get_sbh_threshold");
function set_sbh_threshold (NewValue : qmingw.size_t) return signed_int;
pragma Import (C, set_sbh_threshold, "_set_sbh_threshold");
function set_amblksiz (Value : qmingw.size_t) return qmingw.errno_t;
pragma Import (C, set_amblksiz, "_set_amblksiz");
function get_amblksiz (Value : access qmingw.size_t)
return qmingw.errno_t;
pragma Import (C, get_amblksiz, "_get_amblksiz");
function heapadd (Memory : void_ptr; Size : qmingw.size_t)
return signed_int;
pragma Import (C, heapadd, "_heapadd");
function heapchk return signed_int;
pragma Import (C, heapchk, "_heapchk");
function heapmin return signed_int;
pragma Import (C, heapmin, "_heapmin");
function heapset (Fill : unsigned_int) return signed_int;
pragma Import (C, heapset, "_heapset");
function heapwalk (EntryInfo : access HEAPINFO) return signed_int;
pragma Import (C, heapwalk, "_heapwalk");
function heapused (Used : access qmingw.size_t;
Commit : access qmingw.size_t) return qmingw.size_t;
pragma Import (C, heapused, "_heapused");
function get_heap_handle return qmingw.intptr_t;
pragma Import (C, get_heap_handle, "_get_heap_handle");
ALLOCA_S_HEAP_MARKER : constant := 56797;
ALLOCA_S_MARKER_SIZE : constant := 16;
ALLOCA_S_STACK_MARKER : constant := 52428;
ALLOCA_S_THRESHOLD : constant := 1024;
-- _CRT_ALLOCATION_DEFINED (empty)
-- _FREEA_INLINE (empty)
FREEENTRY : constant := 0;
HEAPBADBEGIN : constant := -3;
HEAPBADNODE : constant := -4;
HEAPBADPTR : constant := -6;
HEAPEMPTY : constant := -1;
HEAPEND : constant := -5;
-- _HEAPINFO_DEFINED (empty)
HEAPOK : constant := -2;
HEAP_MAXREQ : constant := -32;
-- _MALLOC_H_ (empty)
MAX_WAIT_MALLOC_CRT : constant := 60000;
-- _MM_MALLOC_H_INCLUDED (empty)
-- _STATIC_ASSERT (unparsible)
USEDENTRY : constant := 1;
-- _alloca (function macro)
-- _malloca (unparsible)
-- _mm_free (uninterpretable)
-- _mm_malloc (uninterpretable)
-- alloca (function macro)
end C.malloc;
Raw
c-mcx.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
with C.windef;
package C.mcx is
pragma Preelaborate;
type struct_MODEMDEVCAPS;
type struct_MODEMDEVCAPS is record
dwActualSize : aliased windef.DWORD;
dwRequiredSize : aliased windef.DWORD;
dwDevSpecificOffset : aliased windef.DWORD;
dwDevSpecificSize : aliased windef.DWORD;
dwModemProviderVersion : aliased windef.DWORD;
dwModemManufacturerOffset : aliased windef.DWORD;
dwModemManufacturerSize : aliased windef.DWORD;
dwModemModelOffset : aliased windef.DWORD;
dwModemModelSize : aliased windef.DWORD;
dwModemVersionOffset : aliased windef.DWORD;
dwModemVersionSize : aliased windef.DWORD;
dwDialOptions : aliased windef.DWORD;
dwCallSetupFailTimer : aliased windef.DWORD;
dwInactivityTimeout : aliased windef.DWORD;
dwSpeakerVolume : aliased windef.DWORD;
dwSpeakerMode : aliased windef.DWORD;
dwModemOptions : aliased windef.DWORD;
dwMaxDTERate : aliased windef.DWORD;
dwMaxDCERate : aliased windef.DWORD;
abVariablePortion : aliased windef.BYTE_array (0 .. 0);
end record;
pragma Convention (C_Pass_By_Copy, struct_MODEMDEVCAPS);
type struct_MODEMDEVCAPS_ptr is access all struct_MODEMDEVCAPS;
for struct_MODEMDEVCAPS_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_MODEMDEVCAPS_ptr);
pragma Convention (C, struct_MODEMDEVCAPS_ptr);
subtype MODEMDEVCAPS is struct_MODEMDEVCAPS;
subtype PMODEMDEVCAPS is struct_MODEMDEVCAPS_ptr;
subtype LPMODEMDEVCAPS is struct_MODEMDEVCAPS_ptr;
type struct_MODEMSETTINGS;
type struct_MODEMSETTINGS is record
dwActualSize : aliased windef.DWORD;
dwRequiredSize : aliased windef.DWORD;
dwDevSpecificOffset : aliased windef.DWORD;
dwDevSpecificSize : aliased windef.DWORD;
dwCallSetupFailTimer : aliased windef.DWORD;
dwInactivityTimeout : aliased windef.DWORD;
dwSpeakerVolume : aliased windef.DWORD;
dwSpeakerMode : aliased windef.DWORD;
dwPreferredModemOptions : aliased windef.DWORD;
dwNegotiatedModemOptions : aliased windef.DWORD;
dwNegotiatedDCERate : aliased windef.DWORD;
abVariablePortion : aliased windef.BYTE_array (0 .. 0);
end record;
pragma Convention (C_Pass_By_Copy, struct_MODEMSETTINGS);
type struct_MODEMSETTINGS_ptr is access all struct_MODEMSETTINGS;
for struct_MODEMSETTINGS_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_MODEMSETTINGS_ptr);
pragma Convention (C, struct_MODEMSETTINGS_ptr);
subtype MODEMSETTINGS is struct_MODEMSETTINGS;
subtype PMODEMSETTINGS is struct_MODEMSETTINGS_ptr;
subtype LPMODEMSETTINGS is struct_MODEMSETTINGS_ptr;
DIALOPTION_BILLING : constant := 64;
DIALOPTION_DIALTONE : constant := 256;
DIALOPTION_QUIET : constant := 128;
MDMSPKRFLAG_CALLSETUP : constant := 8;
MDMSPKRFLAG_DIAL : constant := 2;
MDMSPKRFLAG_OFF : constant := 1;
MDMSPKRFLAG_ON : constant := 4;
MDMSPKR_CALLSETUP : constant := 3;
MDMSPKR_DIAL : constant := 1;
MDMSPKR_OFF : constant := 0;
MDMSPKR_ON : constant := 2;
MDMVOLFLAG_HIGH : constant := 4;
MDMVOLFLAG_LOW : constant := 1;
MDMVOLFLAG_MEDIUM : constant := 2;
MDMVOL_HIGH : constant := 2;
MDMVOL_LOW : constant := 0;
MDMVOL_MEDIUM : constant := 1;
MDM_ANALOG_RLP_OFF : constant := 1;
MDM_ANALOG_RLP_ON : constant := 0;
MDM_ANALOG_V34 : constant := 2;
MDM_AUTO_ML_2 : constant := 2;
MDM_AUTO_ML_DEFAULT : constant := 0;
MDM_AUTO_ML_NONE : constant := 1;
MDM_AUTO_SPEED_DEFAULT : constant := 0;
MDM_BEARERMODE_ANALOG : constant := 0;
MDM_BEARERMODE_GSM : constant := 2;
MDM_BEARERMODE_ISDN : constant := 1;
MDM_BLIND_DIAL : constant := 512;
MDM_CCITT_OVERRIDE : constant := 64;
MDM_CELLULAR : constant := 8;
MDM_COMPRESSION : constant := 1;
MDM_DIAGNOSTICS : constant := 2048;
MDM_ERROR_CONTROL : constant := 2;
MDM_FLOWCONTROL_HARD : constant := 16;
MDM_FLOWCONTROL_SOFT : constant := 32;
MDM_FORCED_EC : constant := 4;
-- MDM_GEN_ANALOG_PROTOCOL_DATA (function macro)
-- MDM_GEN_AUTO_PROTOCOL_DATA (function macro)
-- MDM_GEN_EXTENDEDINFO (function macro)
-- MDM_GEN_HDLCPPP_PROTOCOL_DATA (function macro)
-- MDM_GEN_PROTOCOLINFO (function macro)
-- MDM_GEN_V110_PROTOCOL_DATA (function macro)
-- MDM_GEN_V120_PROTOCOL_DATA (function macro)
-- MDM_GEN_X75_PROTOCOL_DATA (function macro)
-- MDM_GET_BEARERMODE (function macro)
-- MDM_GET_EXTENDEDINFO (function macro)
-- MDM_GET_PROTOCOLDATA (function macro)
-- MDM_GET_PROTOCOLID (function macro)
-- MDM_GET_PROTOCOLINFO (function macro)
MDM_HDLCPPP_AUTH_CHAP : constant := 3;
MDM_HDLCPPP_AUTH_DEFAULT : constant := 0;
MDM_HDLCPPP_AUTH_MSCHAP : constant := 4;
MDM_HDLCPPP_AUTH_NONE : constant := 1;
MDM_HDLCPPP_AUTH_PAP : constant := 2;
MDM_HDLCPPP_ML_2 : constant := 2;
MDM_HDLCPPP_ML_DEFAULT : constant := 0;
MDM_HDLCPPP_ML_NONE : constant := 1;
MDM_HDLCPPP_SPEED_56K : constant := 2;
MDM_HDLCPPP_SPEED_64K : constant := 1;
MDM_HDLCPPP_SPEED_DEFAULT : constant := 0;
MDM_MASK_AUTO_ML : constant := 192;
MDM_MASK_AUTO_SPEED : constant := 7;
MDM_MASK_BEARERMODE : constant := 61440;
MDM_MASK_EXTENDEDINFO : constant := 268431360;
MDM_MASK_HDLCPPP_AUTH : constant := 56;
MDM_MASK_HDLCPPP_ML : constant := 192;
MDM_MASK_HDLCPPP_SPEED : constant := 7;
MDM_MASK_PROTOCOLDATA : constant := 267386880;
MDM_MASK_PROTOCOLID : constant := 983040;
MDM_MASK_PROTOCOLINFO : constant := 268369920;
MDM_MASK_V110_SPEED : constant := 15;
MDM_MASK_V120_ML : constant := 192;
MDM_MASK_V120_SPEED : constant := 7;
MDM_MASK_X75_DATA : constant := 7;
MDM_PIAFS_INCOMING : constant := 0;
MDM_PIAFS_OUTGOING : constant := 1;
MDM_PROTOCOLID_ANALOG : constant := 7;
MDM_PROTOCOLID_AUTO : constant := 6;
MDM_PROTOCOLID_DEFAULT : constant := 0;
MDM_PROTOCOLID_GPRS : constant := 8;
MDM_PROTOCOLID_HDLCPPP : constant := 1;
MDM_PROTOCOLID_PIAFS : constant := 9;
MDM_PROTOCOLID_V110 : constant := 4;
MDM_PROTOCOLID_V120 : constant := 5;
MDM_PROTOCOLID_V128 : constant := 2;
MDM_PROTOCOLID_X75 : constant := 3;
MDM_PROTOCOL_ANALOG_NRLP : constant := 1507328;
MDM_PROTOCOL_ANALOG_RLP : constant := 458752;
MDM_PROTOCOL_ANALOG_V34 : constant := 2555904;
MDM_PROTOCOL_AUTO_1CH : constant := 67502080;
MDM_PROTOCOL_AUTO_2CH : constant := 134610944;
MDM_PROTOCOL_GPRS : constant := 524288;
MDM_PROTOCOL_HDLCPPP_112K : constant := 136380416;
MDM_PROTOCOL_HDLCPPP_112K_CHAP : constant := 161546240;
MDM_PROTOCOL_HDLCPPP_112K_MSCHAP : constant := 169934848;
MDM_PROTOCOL_HDLCPPP_112K_PAP : constant := 153157632;
MDM_PROTOCOL_HDLCPPP_128K : constant := 135331840;
MDM_PROTOCOL_HDLCPPP_128K_CHAP : constant := 160497664;
MDM_PROTOCOL_HDLCPPP_128K_MSCHAP : constant := 168886272;
MDM_PROTOCOL_HDLCPPP_128K_PAP : constant := 152109056;
MDM_PROTOCOL_HDLCPPP_56K : constant := 2162688;
MDM_PROTOCOL_HDLCPPP_64K : constant := 1114112;
MDM_PROTOCOL_PIAFS_INCOMING : constant := 589824;
MDM_PROTOCOL_PIAFS_OUTGOING : constant := 1638400;
MDM_PROTOCOL_V110_12DOT0K : constant := 5505024;
MDM_PROTOCOL_V110_14DOT4K : constant := 6553600;
MDM_PROTOCOL_V110_19DOT2K : constant := 7602176;
MDM_PROTOCOL_V110_1DOT2K : constant := 1310720;
MDM_PROTOCOL_V110_28DOT8K : constant := 8650752;
MDM_PROTOCOL_V110_2DOT4K : constant := 2359296;
MDM_PROTOCOL_V110_38DOT4K : constant := 9699328;
MDM_PROTOCOL_V110_4DOT8K : constant := 3407872;
MDM_PROTOCOL_V110_57DOT6K : constant := 10747904;
MDM_PROTOCOL_V110_9DOT6K : constant := 4456448;
MDM_PROTOCOL_V120_112K : constant := 136642560;
MDM_PROTOCOL_V120_128K : constant := 135593984;
MDM_PROTOCOL_V120_56K : constant := 69533696;
MDM_PROTOCOL_V120_64K : constant := 68485120;
MDM_PROTOCOL_X75_128K : constant := 2293760;
MDM_PROTOCOL_X75_64K : constant := 1245184;
MDM_PROTOCOL_X75_BTX : constant := 4390912;
MDM_PROTOCOL_X75_T_70 : constant := 3342336;
-- MDM_SET_BEARERMODE (function macro)
-- MDM_SET_EXTENDEDINFO (function macro)
-- MDM_SET_PROTOCOLDATA (function macro)
-- MDM_SET_PROTOCOLID (function macro)
-- MDM_SET_PROTOCOLINFO (function macro)
MDM_SHIFT_AUTO_ML : constant := 6;
MDM_SHIFT_AUTO_SPEED : constant := 0;
MDM_SHIFT_BEARERMODE : constant := 12;
MDM_SHIFT_EXTENDEDINFO : constant := 12;
MDM_SHIFT_HDLCPPP_AUTH : constant := 3;
MDM_SHIFT_HDLCPPP_ML : constant := 6;
MDM_SHIFT_HDLCPPP_SPEED : constant := 0;
MDM_SHIFT_PROTOCOLDATA : constant := 20;
MDM_SHIFT_PROTOCOLID : constant := 16;
MDM_SHIFT_PROTOCOLINFO : constant := 16;
MDM_SHIFT_V110_SPEED : constant := 0;
MDM_SHIFT_V120_ML : constant := 6;
MDM_SHIFT_V120_SPEED : constant := 0;
MDM_SHIFT_X75_DATA : constant := 0;
MDM_SPEED_ADJUST : constant := 128;
MDM_TONE_DIAL : constant := 256;
MDM_V110_SPEED_12DOT0K : constant := 5;
MDM_V110_SPEED_14DOT4K : constant := 6;
MDM_V110_SPEED_19DOT2K : constant := 7;
MDM_V110_SPEED_1DOT2K : constant := 1;
MDM_V110_SPEED_28DOT8K : constant := 8;
MDM_V110_SPEED_2DOT4K : constant := 2;
MDM_V110_SPEED_38DOT4K : constant := 9;
MDM_V110_SPEED_4DOT8K : constant := 3;
MDM_V110_SPEED_57DOT6K : constant := 10;
MDM_V110_SPEED_9DOT6K : constant := 4;
MDM_V110_SPEED_DEFAULT : constant := 0;
MDM_V120_ML_2 : constant := 2;
MDM_V120_ML_DEFAULT : constant := 0;
MDM_V120_ML_NONE : constant := 1;
MDM_V120_SPEED_56K : constant := 2;
MDM_V120_SPEED_64K : constant := 1;
MDM_V120_SPEED_DEFAULT : constant := 0;
MDM_V23_OVERRIDE : constant := 1024;
MDM_X75_DATA_128K : constant := 2;
MDM_X75_DATA_64K : constant := 1;
MDM_X75_DATA_BTX : constant := 4;
MDM_X75_DATA_DEFAULT : constant := 0;
MDM_X75_DATA_T_70 : constant := 3;
-- _MCX_H_ (empty)
end C.mcx;
Raw
c-mstcpip.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
with C.basetsd;
with C.guiddef;
with C.in6addr;
with C.inaddr;
with C.qbsd_types;
with C.qmingw;
with C.windef;
with C.winnt;
with C.winsock2;
package C.mstcpip is
pragma Preelaborate;
type struct_tcp_keepalive;
type struct_tcp_keepalive is record
onoff : aliased qbsd_types.u_long;
keepalivetime : aliased qbsd_types.u_long;
keepaliveinterval : aliased qbsd_types.u_long;
end record;
pragma Convention (C_Pass_By_Copy, struct_tcp_keepalive);
type enum_SOCKET_SECURITY_PROTOCOL;
type enum_SOCKET_SECURITY_PROTOCOL is (SOCKET_SECURITY_PROTOCOL_DEFAULT,
SOCKET_SECURITY_PROTOCOL_IPSEC, SOCKET_SECURITY_PROTOCOL_INVALID);
for enum_SOCKET_SECURITY_PROTOCOL use (
SOCKET_SECURITY_PROTOCOL_DEFAULT => 0,
SOCKET_SECURITY_PROTOCOL_IPSEC => 1,
SOCKET_SECURITY_PROTOCOL_INVALID => 2);
pragma Convention (C, enum_SOCKET_SECURITY_PROTOCOL);
subtype SOCKET_SECURITY_PROTOCOL is enum_SOCKET_SECURITY_PROTOCOL;
type enum_SOCKET_USAGE_TYPE;
type enum_SOCKET_USAGE_TYPE is (SYSTEM_CRITICAL_SOCKET);
for enum_SOCKET_USAGE_TYPE use (SYSTEM_CRITICAL_SOCKET => 1);
pragma Convention (C, enum_SOCKET_USAGE_TYPE);
subtype SOCKET_USAGE_TYPE is enum_SOCKET_USAGE_TYPE;
type struct_SOCKET_PEER_TARGET_NAME;
type struct_SOCKET_PEER_TARGET_NAME is record
SecurityProtocol : aliased SOCKET_SECURITY_PROTOCOL;
PeerAddress : aliased winsock2.SOCKADDR_STORAGE;
PeerTargetNameStringLen : aliased windef.ULONG;
AllStrings : aliased qmingw.wchar_t_array (0 .. -1);
end record;
pragma Convention (C_Pass_By_Copy, struct_SOCKET_PEER_TARGET_NAME);
subtype SOCKET_PEER_TARGET_NAME is struct_SOCKET_PEER_TARGET_NAME;
type struct_SOCKET_SECURITY_QUERY_INFO;
type struct_SOCKET_SECURITY_QUERY_INFO is record
SecurityProtocol : aliased SOCKET_SECURITY_PROTOCOL;
Flags : aliased windef.ULONG;
PeerApplicationAccessTokenHandle : aliased basetsd.UINT64;
PeerMachineAccessTokenHandle : aliased basetsd.UINT64;
end record;
pragma Convention (C_Pass_By_Copy, struct_SOCKET_SECURITY_QUERY_INFO);
subtype SOCKET_SECURITY_QUERY_INFO is struct_SOCKET_SECURITY_QUERY_INFO;
type struct_SOCKET_SECURITY_QUERY_TEMPLATE;
type struct_SOCKET_SECURITY_QUERY_TEMPLATE is record
SecurityProtocol : aliased SOCKET_SECURITY_PROTOCOL;
PeerAddress : aliased winsock2.SOCKADDR_STORAGE;
PeerTokenAccessMask : aliased windef.ULONG;
end record;
pragma Convention (C_Pass_By_Copy, struct_SOCKET_SECURITY_QUERY_TEMPLATE);
subtype SOCKET_SECURITY_QUERY_TEMPLATE is
struct_SOCKET_SECURITY_QUERY_TEMPLATE;
type struct_SOCKET_SECURITY_SETTINGS;
type struct_SOCKET_SECURITY_SETTINGS is record
SecurityProtocol : aliased SOCKET_SECURITY_PROTOCOL;
SecurityFlags : aliased windef.ULONG;
end record;
pragma Convention (C_Pass_By_Copy, struct_SOCKET_SECURITY_SETTINGS);
subtype SOCKET_SECURITY_SETTINGS is struct_SOCKET_SECURITY_SETTINGS;
type struct_SOCKET_SECURITY_SETTINGS_IPSEC;
type struct_SOCKET_SECURITY_SETTINGS_IPSEC is record
SecurityProtocol : aliased SOCKET_SECURITY_PROTOCOL;
SecurityFlags : aliased windef.ULONG;
IpsecFlags : aliased windef.ULONG;
AuthipMMPolicyKey : aliased guiddef.GUID;
AuthipQMPolicyKey : aliased guiddef.GUID;
Reserved : aliased guiddef.GUID;
Reserved2 : aliased basetsd.UINT64;
UserNameStringLen : aliased windef.ULONG;
DomainNameStringLen : aliased windef.ULONG;
PasswordStringLen : aliased windef.ULONG;
AllStrings : aliased qmingw.wchar_t_array (0 .. -1);
end record;
pragma Convention (C_Pass_By_Copy, struct_SOCKET_SECURITY_SETTINGS_IPSEC);
subtype SOCKET_SECURITY_SETTINGS_IPSEC is
struct_SOCKET_SECURITY_SETTINGS_IPSEC;
function RtlIpv6AddressToStringA (Addr : access constant in6addr.IN6_ADDR;
S : access winnt.C_CHAR) return winnt.LPSTR;
pragma Import (C, RtlIpv6AddressToStringA, "RtlIpv6AddressToStringA");
function RtlIpv6AddressToStringW (Addr : access constant in6addr.IN6_ADDR;
S : access winnt.WCHAR) return winnt.LPWSTR;
pragma Import (C, RtlIpv6AddressToStringW, "RtlIpv6AddressToStringW");
function RtlIpv6AddressToStringExA (
Address : access constant in6addr.IN6_ADDR; ScopeId : windef.ULONG;
Port : windef.USHORT; AddressString : access winnt.C_CHAR;
AddressStringLength : access windef.ULONG) return winnt.LONG;
pragma Import (C, RtlIpv6AddressToStringExA, "RtlIpv6AddressToStringExA");
function RtlIpv6AddressToStringExW (
Address : access constant in6addr.IN6_ADDR; ScopeId : windef.ULONG;
Port : windef.USHORT; AddressString : access winnt.WCHAR;
AddressStringLength : access windef.ULONG) return winnt.LONG;
pragma Import (C, RtlIpv6AddressToStringExW, "RtlIpv6AddressToStringExW");
function RtlIpv4AddressToStringA (Addr : access constant inaddr.IN_ADDR;
S : access winnt.C_CHAR) return winnt.LPSTR;
pragma Import (C, RtlIpv4AddressToStringA, "RtlIpv4AddressToStringA");
function RtlIpv4AddressToStringW (Addr : access constant inaddr.IN_ADDR;
S : access winnt.WCHAR) return winnt.LPWSTR;
pragma Import (C, RtlIpv4AddressToStringW, "RtlIpv4AddressToStringW");
function RtlIpv4AddressToStringExA (
Address : access constant inaddr.IN_ADDR; Port : windef.USHORT;
AddressString : access winnt.C_CHAR;
AddressStringLength : access windef.ULONG) return winnt.LONG;
pragma Import (C, RtlIpv4AddressToStringExA, "RtlIpv4AddressToStringExA");
function RtlIpv4AddressToStringExW (
Address : access constant inaddr.IN_ADDR; Port : windef.USHORT;
AddressString : access winnt.WCHAR;
AddressStringLength : access windef.ULONG) return winnt.LONG;
pragma Import (C, RtlIpv4AddressToStringExW, "RtlIpv4AddressToStringExW");
function RtlIpv4StringToAddressA (S : access constant winnt.C_CHAR;
Strict : winnt.BOOLEAN; Terminator : access winnt.LPSTR;
Addr : access inaddr.IN_ADDR) return winnt.LONG;
pragma Import (C, RtlIpv4StringToAddressA, "RtlIpv4StringToAddressA");
function RtlIpv4StringToAddressW (S : access constant winnt.WCHAR;
Strict : winnt.BOOLEAN; Terminator : access winnt.LPWSTR;
Addr : access inaddr.IN_ADDR) return winnt.LONG;
pragma Import (C, RtlIpv4StringToAddressW, "RtlIpv4StringToAddressW");
function RtlIpv4StringToAddressExA (
AddressString : access constant winnt.C_CHAR; Strict : winnt.BOOLEAN;
Address : access inaddr.IN_ADDR; Port : access windef.USHORT)
return winnt.LONG;
pragma Import (C, RtlIpv4StringToAddressExA, "RtlIpv4StringToAddressExA");
function RtlIpv4StringToAddressExW (
AddressString : access constant winnt.WCHAR; Strict : winnt.BOOLEAN;
Address : access inaddr.IN_ADDR; Port : access windef.USHORT)
return winnt.LONG;
pragma Import (C, RtlIpv4StringToAddressExW, "RtlIpv4StringToAddressExW");
function RtlIpv6StringToAddressExA (
AddressString : access constant winnt.C_CHAR;
Address : access in6addr.IN6_ADDR; ScopeId : access windef.ULONG;
Port : access windef.USHORT) return winnt.LONG;
pragma Import (C, RtlIpv6StringToAddressExA, "RtlIpv6StringToAddressExA");
function RtlIpv6StringToAddressExW (
AddressString : access constant winnt.WCHAR;
Address : access in6addr.IN6_ADDR; ScopeId : access windef.ULONG;
Port : access windef.USHORT) return winnt.LONG;
pragma Import (C, RtlIpv6StringToAddressExW, "RtlIpv6StringToAddressExW");
RCVALL_OFF : constant := 0;
RCVALL_ON : constant := 1;
RCVALL_SOCKETLEVELONLY : constant := 2;
function RtlIpv4AddressToString (Addr : access constant inaddr.IN_ADDR;
S : access winnt.WCHAR) return winnt.LPWSTR
renames RtlIpv4AddressToStringW;
function RtlIpv4AddressToStringEx (
Address : access constant inaddr.IN_ADDR; Port : windef.USHORT;
AddressString : access winnt.WCHAR;
AddressStringLength : access windef.ULONG) return winnt.LONG
renames RtlIpv4AddressToStringExW;
function RtlIpv4StringToAddress (S : access constant winnt.WCHAR;
Strict : winnt.BOOLEAN; Terminator : access winnt.LPWSTR;
Addr : access inaddr.IN_ADDR) return winnt.LONG
renames RtlIpv4StringToAddressW;
function RtlIpv4StringToAddressEx (
AddressString : access constant winnt.WCHAR; Strict : winnt.BOOLEAN;
Address : access inaddr.IN_ADDR; Port : access windef.USHORT)
return winnt.LONG renames RtlIpv4StringToAddressExW;
function RtlIpv6AddressToString (Addr : access constant in6addr.IN6_ADDR;
S : access winnt.WCHAR) return winnt.LPWSTR
renames RtlIpv6AddressToStringW;
function RtlIpv6AddressToStringEx (
Address : access constant in6addr.IN6_ADDR; ScopeId : windef.ULONG;
Port : windef.USHORT; AddressString : access winnt.WCHAR;
AddressStringLength : access windef.ULONG) return winnt.LONG
renames RtlIpv6AddressToStringExW;
function RtlIpv6StringToAddressEx (
AddressString : access constant winnt.WCHAR;
Address : access in6addr.IN6_ADDR; ScopeId : access windef.ULONG;
Port : access windef.USHORT) return winnt.LONG
renames RtlIpv6StringToAddressExW;
SIO_ABSORB_RTRALERT : constant := -1744830459;
SIO_INDEX_ADD_MCAST : constant := -1744830454;
SIO_INDEX_BIND : constant := -1744830456;
SIO_INDEX_DEL_MCAST : constant := -1744830453;
SIO_INDEX_MCASTIF : constant := -1744830455;
SIO_KEEPALIVE_VALS : constant := -1744830460;
SIO_LIMIT_BROADCASTS : constant := -1744830457;
SIO_RCVALL : constant := -1744830463;
SIO_RCVALL_IGMPMCAST : constant := -1744830461;
SIO_RCVALL_MCAST : constant := -1744830462;
SIO_UCAST_IF : constant := -1744830458;
SOCKET_INFO_CONNECTION_ENCRYPTED : constant := 2;
SOCKET_INFO_CONNECTION_IMPERSONATED : constant := 4;
SOCKET_INFO_CONNECTION_SECURED : constant := 1;
SOCKET_SETTINGS_ALLOW_INSECURE : constant := 2;
SOCKET_SETTINGS_GUARANTEE_ENCRYPTION : constant := 1;
SOCKET_SETTINGS_IPSEC_SKIP_FILTER_INSTANTIATION : constant := 1;
-- _MSTCPIP_ (empty)
end C.mstcpip;
Raw
c-ncrypt.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.ncrypt is
pragma Preelaborate;
-- _INC_NCRYPT (empty)
end C.ncrypt;
Raw
c-poppack.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.poppack is
pragma Preelaborate;
-- #include <pshpack4.h>
-- #include <pshpack2.h>
-- #include <winnt.h>
-- #include <pshpack2.h>
-- #include <winnt.h>
-- #include <winnt.h>
-- #include <pshpack8.h>
-- #include <winnt.h>
-- #include <winnt.h>
-- #include <winnt.h>
-- #include <winbase.h>
-- #include <pshpack1.h>
-- #include <wingdi.h>
-- #include <pshpack2.h>
-- #include <wingdi.h>
-- #include <pshpack2.h>
-- #include <wingdi.h>
-- #include <pshpack4.h>
-- #include <wingdi.h>
-- #include <pshpack4.h>
-- #include <wingdi.h>
-- #include <wingdi.h>
-- #include <pshpack2.h>
-- #include <winuser.h>
end C.poppack;
Raw
c-psdk_inc-intrin_mac.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.psdk_inc.intrin_mac is
pragma Preelaborate;
-- _INTRIN_MAC_ (empty)
-- __buildbittesti (unparsible)
-- __buildlogicali (has # or ##)
-- __buildstos (unparsible)
end C.psdk_inc.intrin_mac;
Raw
c-psdk_inc-qfd_types.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
with C.psdk_inc.qsocket_types;
with C.qbsd_types;
package C.psdk_inc.qfd_types is
pragma Preelaborate;
type struct_fd_set;
type struct_fd_set is record
fd_count : aliased qbsd_types.u_int;
fd_array : aliased psdk_inc.qsocket_types.SOCKET_array (0 .. 63);
end record;
pragma Convention (C_Pass_By_Copy, struct_fd_set);
type struct_fd_set_ptr is access all struct_fd_set;
for struct_fd_set_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_fd_set_ptr);
pragma Convention (C, struct_fd_set_ptr);
subtype fd_set is struct_fd_set;
subtype fd_set_ptr is struct_fd_set_ptr;
function WSAFDIsSet (a1 : psdk_inc.qsocket_types.SOCKET;
a2 : access fd_set) return signed_int;
pragma Import (C, WSAFDIsSet, "__WSAFDIsSet");
subtype FD_SET_uppercase is struct_fd_set;
subtype PFD_SET is struct_fd_set_ptr;
subtype LPFD_SET is struct_fd_set_ptr;
-- FD_CLR (function macro)
-- FD_ISSET (function macro)
-- FD_SET (function macro)
FD_SETSIZE : constant := 64;
-- FD_ZERO (function macro)
-- ___WSA_FD_TYPES_H (empty)
end C.psdk_inc.qfd_types;
Raw
c-psdk_inc-qip_mreq1.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
with C.inaddr;
package C.psdk_inc.qip_mreq1 is
pragma Preelaborate;
type struct_ip_mreq;
type struct_ip_mreq is record
imr_multiaddr : aliased inaddr.struct_in_addr;
imr_interface : aliased inaddr.struct_in_addr;
end record;
pragma Convention (C_Pass_By_Copy, struct_ip_mreq);
-- _MINGW_IP_MREQ1_H (empty)
end C.psdk_inc.qip_mreq1;
Raw
c-psdk_inc-qip_types.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
with C.inaddr;
with C.qbsd_types;
with C.qtimeval;
package C.psdk_inc.qip_types is
pragma Preelaborate;
type struct_hostent;
type struct_hostent is record
h_name : aliased char_ptr;
h_aliases : aliased char_ptr_ptr;
h_addrtype : aliased signed_short;
h_length : aliased signed_short;
h_addr_list : aliased char_ptr_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_hostent);
type struct_hostent_ptr is access all struct_hostent;
for struct_hostent_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_hostent_ptr);
pragma Convention (C, struct_hostent_ptr);
type struct_netent;
type struct_netent is record
n_name : aliased char_ptr;
n_aliases : aliased char_ptr_ptr;
n_addrtype : aliased signed_short;
n_net : aliased qbsd_types.u_long;
end record;
pragma Convention (C_Pass_By_Copy, struct_netent);
type struct_servent;
type struct_servent is record
s_name : aliased char_ptr;
s_aliases : aliased char_ptr_ptr;
s_proto : aliased char_ptr;
s_port : aliased signed_short;
end record;
pragma Convention (C_Pass_By_Copy, struct_servent);
type struct_servent_ptr is access all struct_servent;
for struct_servent_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_servent_ptr);
pragma Convention (C, struct_servent_ptr);
type struct_protoent;
type struct_protoent is record
p_name : aliased char_ptr;
p_aliases : aliased char_ptr_ptr;
p_proto : aliased signed_short;
end record;
pragma Convention (C_Pass_By_Copy, struct_protoent);
type struct_protoent_ptr is access all struct_protoent;
for struct_protoent_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_protoent_ptr);
pragma Convention (C, struct_protoent_ptr);
type struct_sockproto;
type struct_sockproto is record
sp_family : aliased qbsd_types.u_short;
sp_protocol : aliased qbsd_types.u_short;
end record;
pragma Convention (C_Pass_By_Copy, struct_sockproto);
type struct_linger;
type struct_linger is record
l_onoff : aliased qbsd_types.u_short;
l_linger : aliased qbsd_types.u_short;
end record;
pragma Convention (C_Pass_By_Copy, struct_linger);
type struct_linger_ptr is access all struct_linger;
for struct_linger_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_linger_ptr);
pragma Convention (C, struct_linger_ptr);
type struct_sockaddr;
type struct_sockaddr is record
sa_family : aliased qbsd_types.u_short;
sa_data : aliased char_array (0 .. 13);
end record;
pragma Convention (C_Pass_By_Copy, struct_sockaddr);
type struct_sockaddr_ptr is access all struct_sockaddr;
for struct_sockaddr_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_sockaddr_ptr);
pragma Convention (C, struct_sockaddr_ptr);
type struct_sockaddr_const_ptr is access constant struct_sockaddr;
for struct_sockaddr_const_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_sockaddr_const_ptr);
pragma Convention (C, struct_sockaddr_const_ptr);
type struct_sockaddr_in;
type struct_sockaddr_in is record
sin_family : aliased signed_short;
sin_port : aliased qbsd_types.u_short;
sin_addr : aliased inaddr.struct_in_addr;
sin_zero : aliased char_array (0 .. 7);
end record;
pragma Convention (C_Pass_By_Copy, struct_sockaddr_in);
type struct_sockaddr_in_ptr is access all struct_sockaddr_in;
for struct_sockaddr_in_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_sockaddr_in_ptr);
pragma Convention (C, struct_sockaddr_in_ptr);
subtype HOSTENT is struct_hostent;
subtype PHOSTENT is struct_hostent_ptr;
subtype LPHOSTENT is struct_hostent_ptr;
subtype SERVENT is struct_servent;
subtype PSERVENT is struct_servent_ptr;
subtype LPSERVENT is struct_servent_ptr;
subtype PROTOENT is struct_protoent;
subtype PPROTOENT is struct_protoent_ptr;
subtype LPPROTOENT is struct_protoent_ptr;
subtype SOCKADDR is struct_sockaddr;
subtype SOCKADDR_const_ptr is struct_sockaddr_const_ptr;
subtype PSOCKADDR is struct_sockaddr_ptr;
subtype LPSOCKADDR is struct_sockaddr_ptr;
subtype SOCKADDR_IN is struct_sockaddr_in;
subtype PSOCKADDR_IN is struct_sockaddr_in_ptr;
subtype LPSOCKADDR_IN is struct_sockaddr_in_ptr;
subtype LINGER is struct_linger;
subtype PLINGER is struct_linger_ptr;
subtype LPLINGER is struct_linger_ptr;
subtype TIMEVAL is qtimeval.struct_timeval;
subtype PTIMEVAL is qtimeval.struct_timeval_ptr;
subtype LPTIMEVAL is qtimeval.struct_timeval_ptr;
-- _MINGW_IP_TYPES_H (empty)
-- h_addr (unparsible)
end C.psdk_inc.qip_types;
Raw
c-psdk_inc-qsocket_types.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
with C.basetsd;
package C.psdk_inc.qsocket_types is
pragma Preelaborate;
subtype SOCKET is basetsd.UINT_PTR;
subtype SOCKET_array is basetsd.UINT_PTR_array;
subtype SOCKET_ptr is basetsd.UINT_PTR_ptr;
INVALID_SOCKET : constant := 18446744073709551615;
SOCKET_ERROR : constant := -1;
-- ___WSA_SOCKET_TYPES_H (empty)
end C.psdk_inc.qsocket_types;
Raw
c-psdk_inc-qwsa_errnos.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.psdk_inc.qwsa_errnos is
pragma Preelaborate;
HOST_NOT_FOUND : constant := 11001;
NO_ADDRESS : constant := 11004;
NO_DATA : constant := 11004;
NO_RECOVERY : constant := 11003;
TRY_AGAIN : constant := 11002;
WSANO_ADDRESS : constant := 11004;
-- __WSA_ERR_MACROS_DEFINED (empty)
end C.psdk_inc.qwsa_errnos;
Raw
c-psdk_inc-qwsadata.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
with C.windef;
package C.psdk_inc.qwsadata is
pragma Preelaborate;
type struct_WSAData;
type struct_WSAData is record
wVersion : aliased windef.WORD;
wHighVersion : aliased windef.WORD;
iMaxSockets : aliased unsigned_short;
iMaxUdpDg : aliased unsigned_short;
lpVendorInfo : aliased char_ptr;
szDescription : aliased char_array (0 .. 256);
szSystemStatus : aliased char_array (0 .. 128);
end record;
pragma Convention (C_Pass_By_Copy, struct_WSAData);
type struct_WSAData_ptr is access all struct_WSAData;
for struct_WSAData_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_WSAData_ptr);
pragma Convention (C, struct_WSAData_ptr);
subtype WSADATA is struct_WSAData;
subtype LPWSADATA is struct_WSAData_ptr;
WSADESCRIPTION_LEN : constant := 256;
WSASYS_STATUS_LEN : constant := 128;
-- __MINGW_WSADATA_H (empty)
end C.psdk_inc.qwsadata;
Raw
c-psdk_inc.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.psdk_inc is
pragma Preelaborate;
end C.psdk_inc;
Raw
c-pshpack2.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.pshpack2 is
pragma Preelaborate;
-- #include <poppack.h>
-- #include <winnt.h>
-- #include <winnt.h>
-- #include <pshpack8.h>
-- #include <winnt.h>
-- #include <winbase.h>
-- #include <pshpack1.h>
-- #include <poppack.h>
-- #include <wingdi.h>
-- #include <poppack.h>
-- #include <wingdi.h>
-- #include <pshpack4.h>
-- #include <poppack.h>
-- #include <wingdi.h>
-- #include <winuser.h>
end C.pshpack2;
Raw
c-pshpack4.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.pshpack4 is
pragma Preelaborate;
-- #include <poppack.h>
-- #include <winnt.h>
-- #include <pshpack8.h>
-- #include <winnt.h>
-- #include <winbase.h>
-- #include <pshpack1.h>
-- #include <pshpack2.h>
-- #include <poppack.h>
-- #include <wingdi.h>
-- #include <wingdi.h>
-- #include <poppack.h>
end C.pshpack4;
Raw
c-qbsd_types.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.qbsd_types is
pragma Preelaborate;
subtype u_char is unsigned_char;
subtype u_char_array is unsigned_char_array;
subtype u_char_ptr is unsigned_char_ptr;
subtype u_short is unsigned_short;
subtype u_short_ptr is unsigned_short_ptr;
subtype u_short_array is unsigned_short_array;
subtype u_int is unsigned_int;
subtype u_long is unsigned_long;
subtype u_long_ptr is unsigned_long_ptr;
subtype u_int64 is unsigned_long_long;
-- _BSDTYPES_DEFINED (empty)
end C.qbsd_types;
Raw
c-qmingw.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.qmingw is
pragma Preelaborate;
subtype size_t is Standard.C.size_t;
subtype size_t_ptr is Standard.C.size_t_ptr;
subtype ssize_t is signed_long_long;
subtype intptr_t is signed_long_long;
subtype uintptr_t is unsigned_long_long;
subtype ptrdiff_t is Standard.C.ptrdiff_t;
subtype wchar_t is Standard.C.wchar_t;
subtype wchar_t_ptr is Standard.C.wchar_t_ptr;
subtype wchar_t_ptr_ptr is Standard.C.wchar_t_ptr_ptr;
subtype wchar_t_ptr_ptr_ptr is Standard.C.wchar_t_ptr_ptr_ptr;
subtype wchar_t_ptr_const_ptr is Standard.C.wchar_t_ptr_const_ptr;
subtype wchar_t_const_ptr is Standard.C.wchar_t_const_ptr;
subtype wchar_t_const_ptr_ptr is Standard.C.wchar_t_const_ptr_ptr;
subtype wchar_t_const_ptr_array is Standard.C.wchar_t_const_ptr_array;
subtype wchar_t_array is Standard.C.wchar_t_array;
subtype wint_t is unsigned_short;
subtype wctype_t is unsigned_short;
subtype errno_t is signed_int;
subtype time32_t is signed_long;
subtype time64_t is signed_long_long;
subtype time_t is time64_t;
procedure qqdebugbreak;
pragma Import (C, qqdebugbreak, "__debugbreak");
function mingw_get_crt_info return char_const_ptr;
pragma Import (C, mingw_get_crt_info, "__mingw_get_crt_info");
-- DUMMYSTRUCTNAME (empty)
-- DUMMYSTRUCTNAME1 (empty)
-- DUMMYSTRUCTNAME2 (empty)
-- DUMMYSTRUCTNAME3 (empty)
-- DUMMYSTRUCTNAME4 (empty)
-- DUMMYSTRUCTNAME5 (empty)
-- DUMMYUNIONNAME (empty)
-- DUMMYUNIONNAME1 (empty)
-- DUMMYUNIONNAME2 (empty)
-- DUMMYUNIONNAME3 (empty)
-- DUMMYUNIONNAME4 (empty)
-- DUMMYUNIONNAME5 (empty)
-- DUMMYUNIONNAME6 (empty)
-- DUMMYUNIONNAME7 (empty)
-- DUMMYUNIONNAME8 (empty)
-- DUMMYUNIONNAME9 (empty)
-- MINGW_SDK_INIT (empty)
USE_UUIDOF : constant := 0;
WINVER : constant := 1282;
-- _AGLOBAL (empty)
pragma Convention_Identifier (ANONYMOUS_STRUCT, C);
pragma Convention_Identifier (ANONYMOUS_UNION, C);
ARGMAX : constant := 100;
-- _CONST_RETURN (empty)
-- _CRTIMP (attribute)
-- _CRTIMP2 (attribute)
-- _CRTIMP_ALTERNATIVE (attribute)
-- _CRTIMP_NOIA64 (attribute)
-- _CRTIMP_PURE (attribute)
-- _CRT_ALIGN (parameterized declaration-specifiers)
-- _CRT_ALTERNATIVE_IMPORTED (empty)
-- _CRT_DEPRECATE_TEXT (unparsible)
-- _CRT_INSECURE_DEPRECATE_GLOBALS (empty)
-- _CRT_INSECURE_DEPRECATE_MEMORY (empty)
-- _CRT_MANAGED_HEAP_DEPRECATE (empty)
-- _CRT_OBSOLETE (empty)
CRT_PACKING : constant := 8;
-- _CRT_STRINGIZE (function macro)
-- _CRT_UNUSED (function macro)
-- _CRT_WIDE (unparsible)
-- _CRT_glob (unparsible)
-- _DLL (empty)
-- _ERRCODE_DEFINED (empty)
-- _INC__MINGW_H (empty)
-- _INT128_DEFINED (empty)
-- _INTPTR_T_DEFINED (empty)
-- _MCRTIMP (attribute)
-- _MRTIMP2 (attribute)
-- _MT (empty)
-- _PGLOBAL (empty)
-- _PTRDIFF_T_ (empty)
-- _PTRDIFF_T_DEFINED (empty)
SECURECRT_FILL_BUFFER_PATTERN : constant := 253;
-- _SIZE_T_DEFINED (empty)
-- _SSIZE_T_DEFINED (empty)
-- _STRUCT_NAME (empty)
-- _TIME32_T_DEFINED (empty)
-- _TIME64_T_DEFINED (empty)
-- _TIME_T_DEFINED (empty)
TRUNCATE : constant := 18446744073709551615;
-- _UINTPTR_T_DEFINED (empty)
-- _UNION_NAME (empty)
-- _W64 (empty)
-- _WCHAR_T_DEFINED (empty)
-- _WCTYPE_T_DEFINED (empty)
WIN32_WINNT : constant := 1282;
-- _WINT_T (empty)
-- __ANONYMOUS_DEFINED (empty)
pragma Convention_Identifier (CRTDECL, C);
-- __CRT_INLINE (alias of inline)
-- __CRT_STRINGIZE (has # or ##)
-- __CRT_UUID_DECL (empty)
-- __CRT_WIDE (has # or ##)
CRT_NO_INLINE : constant := 1;
-- __DECLSPEC_SUPPORTED (empty)
subtype LONG32 is signed_long;
-- __MINGW_ATTRIB_CONST (attribute)
-- __MINGW_ATTRIB_DEPRECATED (attribute)
-- __MINGW_ATTRIB_MALLOC (attribute)
-- __MINGW_ATTRIB_NONNULL (parameterized declaration-specifiers)
-- __MINGW_ATTRIB_NORETURN (attribute)
-- __MINGW_ATTRIB_NO_OPTIMIZE (attribute)
-- __MINGW_ATTRIB_PURE (attribute)
-- __MINGW_ATTRIB_UNUSED (attribute)
-- __MINGW_ATTRIB_USED (attribute)
-- __MINGW_BROKEN_INTERFACE (unparsible)
-- __MINGW_IMPORT (alias of extern)
-- __MINGW_INTRIN_INLINE (alias of inline)
-- __MINGW_NOTHROW (attribute)
-- __MINGW_PRAGMA_PARAM (has # or ##)
MSVCRT_VERSION : constant := 1792;
-- __UNUSED_PARAM (unparsible)
USE_CRTIMP : constant := 1;
-- __forceinline (alias of inline)
subtype int16 is signed_short;
subtype int32 is signed_int;
subtype int8 is char;
-- __intptr_t_defined (empty)
-- __nothrow (empty)
-- __ptr32 (empty)
-- __ptr64 (empty)
-- __restrict_arr (alias of restrict)
-- __stdcall (empty)
-- __uintptr_t_defined (empty)
-- __unaligned (empty)
-- __w64 (empty)
-- _inline (alias of inline)
end C.qmingw;
Raw
c-qmingw_mac.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.qmingw_mac is
pragma Preelaborate;
-- _INC_CRTDEFS_MACRO (empty)
M_AMD64 : constant := 100;
M_X64 : constant := 100;
pragma Convention_Identifier (C89_NAMELESS, C);
-- __C89_NAMELESSSTRUCTNAME (empty)
-- __C89_NAMELESSSTRUCTNAME1 (empty)
-- __C89_NAMELESSSTRUCTNAME2 (empty)
-- __C89_NAMELESSSTRUCTNAME3 (empty)
-- __C89_NAMELESSSTRUCTNAME4 (empty)
-- __C89_NAMELESSSTRUCTNAME5 (empty)
-- __C89_NAMELESSUNIONNAME (empty)
-- __C89_NAMELESSUNIONNAME1 (empty)
-- __C89_NAMELESSUNIONNAME2 (empty)
-- __C89_NAMELESSUNIONNAME3 (empty)
-- __C89_NAMELESSUNIONNAME4 (empty)
-- __C89_NAMELESSUNIONNAME5 (empty)
-- __C89_NAMELESSUNIONNAME6 (empty)
-- __C89_NAMELESSUNIONNAME7 (empty)
-- __C89_NAMELESSUNIONNAME8 (empty)
pragma Convention_Identifier (GNU_EXTENSION, C);
MINGW32_MAJOR_VERSION : constant := 3;
MINGW32_MINOR_VERSION : constant := 11;
-- __MINGW64_STRINGIFY (function macro)
MINGW64_VERSION_MAJOR : constant := 3;
MINGW64_VERSION_MINOR : constant := 0;
MINGW64_VERSION_RC : constant := 1;
MINGW64_VERSION_STATE : constant char_array (0 .. 5) := "alpha"
& char'Val (0);
MINGW64_VERSION_STR : constant char_array (0 .. 3) := "3.0"
& char'Val (0);
-- __MINGW_ATTRIB_DEPRECATED_MSVC2005 (empty)
-- __MINGW_ATTRIB_DEPRECATED_SEC_WARN (empty)
-- __MINGW_ATTRIB_DEPRECATED_STR (empty)
pragma Convention_Identifier (MINGW_EXTENSION, C);
MINGW_GCC_VERSION : constant := 50300;
-- __MINGW_GNUC_PREREQ (function macro)
-- __MINGW_GNU_PRINTF (parameterized declaration-specifiers)
-- __MINGW_GNU_SCANF (parameterized declaration-specifiers)
MINGW_HAVE_ANSI_C99_PRINTF : constant := 1;
MINGW_HAVE_ANSI_C99_SCANF : constant := 1;
MINGW_HAVE_WIDE_C99_PRINTF : constant := 1;
MINGW_HAVE_WIDE_C99_SCANF : constant := 1;
-- __MINGW_IMP_LSYMBOL (has # or ##)
-- __MINGW_IMP_SYMBOL (has # or ##)
-- __MINGW_LSYMBOL (has # or ##)
-- __MINGW_MSC_PREREQ (function macro)
MINGW_MSVC2005_DEPREC_STR : constant char_array (0 .. 116) :=
"This POSIX function is deprecated beginning in Visual C++ 2005, use _CR"
& "T_NONSTDC_NO_DEPRECATE to disable deprecation" & char'Val (0);
-- __MINGW_MS_PRINTF (parameterized declaration-specifiers)
-- __MINGW_MS_SCANF (parameterized declaration-specifiers)
-- __MINGW_POISON_NAME (has # or ##)
MINGW_SEC_WARN_STR : constant char_array (0 .. 91) :=
"This function or variable may be unsafe, use _CRT_SECURE_NO_WARNINGS to"
& " disable deprecation" & char'Val (0);
MINGW_USE_UNDERSCORE_PREFIX : constant := 0;
-- __MINGW_USYMBOL (function macro)
-- __MSABI_LONG (has # or ##)
-- __STRINGIFY (has # or ##)
USE_MINGW_OUTPUT_FORMAT_EMU : constant := 1;
-- __mingw_ovr (alias of static inline)
end C.qmingw_mac;
Raw
c-qmingw_secapi.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.qmingw_secapi is
pragma Preelaborate;
CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES : constant := 0;
CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES_MEMORY : constant := 0;
CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES : constant := 0;
CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_COUNT : constant := 0;
CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_MEMORY : constant := 0;
-- _INC_MINGW_SECAPI (empty)
-- __CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES_0_2_ (unparsible)
-- __CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES_MEMORY_0_3_ (unparsible)
-- __CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_0_2_ (unparsible)
-- __CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_COUNT_0_3_ (unparsible)
-- __CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_COUNT_1_4_ (unparsible)
-- __CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_MEMORY_0_3_ (unparsible)
-- __MINGW_CRT_NAME_CONCAT1 (unparsible)
-- __MINGW_CRT_NAME_CONCAT2 (has # or ##)
-- __MINGW_CRT_NAME_INSECURE (has # or ##)
-- __MINGW_CRT_NAME_INSECURE_DEF (has # or ##)
end C.qmingw_secapi;
Raw
c-qmingw_stdarg.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.qmingw_stdarg is
pragma Preelaborate;
-- _INC_STDARG (empty)
end C.qmingw_stdarg;
Raw
c-qmingw_unicode.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.qmingw_unicode is
pragma Preelaborate;
INC_CRT_UNICODE_MACROS : constant := 1;
-- __MINGW_NAME_AW (has # or ##)
-- __MINGW_NAME_AW_EXT (has # or ##)
-- __MINGW_NAME_UAW (has # or ##)
-- __MINGW_NAME_UAW_EXT (has # or ##)
MINGW_PROCNAMEEXT_AW : constant char_array (0 .. 1) := "W" & char'Val (0);
-- __MINGW_STRING_AW (has # or ##)
-- __MINGW_TYPEDEF_AW (unparsible)
-- __MINGW_TYPEDEF_UAW (unparsible)
end C.qmingw_unicode;
Raw
c-qos.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
with C.windef;
package C.qos is
pragma Preelaborate;
subtype SERVICETYPE is windef.ULONG;
type struct_flowspec;
type struct_flowspec is record
TokenRate : aliased windef.ULONG;
TokenBucketSize : aliased windef.ULONG;
PeakBandwidth : aliased windef.ULONG;
Latency : aliased windef.ULONG;
DelayVariation : aliased windef.ULONG;
ServiceType : aliased qos.SERVICETYPE;
MaxSduSize : aliased windef.ULONG;
MinimumPolicedSize : aliased windef.ULONG;
end record;
pragma Convention (C_Pass_By_Copy, struct_flowspec);
type struct_flowspec_ptr is access all struct_flowspec;
for struct_flowspec_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_flowspec_ptr);
pragma Convention (C, struct_flowspec_ptr);
subtype FLOWSPEC is struct_flowspec;
subtype PFLOWSPEC is struct_flowspec_ptr;
subtype LPFLOWSPEC is struct_flowspec_ptr;
type struct_QOS_OBJECT_HDR;
type struct_QOS_OBJECT_HDR is record
ObjectType : aliased windef.ULONG;
ObjectLength : aliased windef.ULONG;
end record;
pragma Convention (C_Pass_By_Copy, struct_QOS_OBJECT_HDR);
type struct_QOS_OBJECT_HDR_ptr is access all struct_QOS_OBJECT_HDR;
for struct_QOS_OBJECT_HDR_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_QOS_OBJECT_HDR_ptr);
pragma Convention (C, struct_QOS_OBJECT_HDR_ptr);
subtype QOS_OBJECT_HDR is struct_QOS_OBJECT_HDR;
subtype LPQOS_OBJECT_HDR is struct_QOS_OBJECT_HDR_ptr;
type struct_QOS_SD_MODE;
type struct_QOS_SD_MODE is record
ObjectHdr : aliased QOS_OBJECT_HDR;
ShapeDiscardMode : aliased windef.ULONG;
end record;
pragma Convention (C_Pass_By_Copy, struct_QOS_SD_MODE);
type struct_QOS_SD_MODE_ptr is access all struct_QOS_SD_MODE;
for struct_QOS_SD_MODE_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_QOS_SD_MODE_ptr);
pragma Convention (C, struct_QOS_SD_MODE_ptr);
subtype QOS_SD_MODE is struct_QOS_SD_MODE;
subtype LPQOS_SD_MODE is struct_QOS_SD_MODE_ptr;
type struct_QOS_SHAPING_RATE;
type struct_QOS_SHAPING_RATE is record
ObjectHdr : aliased QOS_OBJECT_HDR;
ShapingRate : aliased windef.ULONG;
end record;
pragma Convention (C_Pass_By_Copy, struct_QOS_SHAPING_RATE);
type struct_QOS_SHAPING_RATE_ptr is access all struct_QOS_SHAPING_RATE;
for struct_QOS_SHAPING_RATE_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_QOS_SHAPING_RATE_ptr);
pragma Convention (C, struct_QOS_SHAPING_RATE_ptr);
subtype QOS_SHAPING_RATE is struct_QOS_SHAPING_RATE;
subtype LPQOS_SHAPING_RATE is struct_QOS_SHAPING_RATE_ptr;
POSITIVE_INFINITY_RATE : constant := -2;
QOS_GENERAL_ID_BASE : constant := 2000;
QOS_NOT_SPECIFIED : constant := -1;
QOS_OBJECT_DESTADDR : constant := 2004;
QOS_OBJECT_END_OF_LIST : constant := 2001;
QOS_OBJECT_SD_MODE : constant := 2002;
QOS_OBJECT_SHAPING_RATE : constant := 2003;
SERVICETYPE_BESTEFFORT : constant := 1;
SERVICETYPE_CONTROLLEDLOAD : constant := 2;
SERVICETYPE_GENERAL_INFORMATION : constant := 5;
SERVICETYPE_GUARANTEED : constant := 3;
SERVICETYPE_NETWORK_CONTROL : constant := 10;
SERVICETYPE_NETWORK_UNAVAILABLE : constant := 4;
SERVICETYPE_NOCHANGE : constant := 6;
SERVICETYPE_NONCONFORMING : constant := 9;
SERVICETYPE_NOTRAFFIC : constant := 0;
SERVICETYPE_QUALITATIVE : constant := 13;
SERVICE_BESTEFFORT : constant := -2147418112;
SERVICE_CONTROLLEDLOAD : constant := -2147352576;
SERVICE_GUARANTEED : constant := -2147221504;
SERVICE_NO_QOS_SIGNALING : constant := 1073741824;
SERVICE_NO_TRAFFIC_CONTROL : constant := -2130706432;
SERVICE_QUALITATIVE : constant := -2145386496;
TC_NONCONF_BORROW : constant := 0;
TC_NONCONF_BORROW_PLUS : constant := 3;
TC_NONCONF_DISCARD : constant := 2;
TC_NONCONF_SHAPE : constant := 1;
-- __QOS_H_ (empty)
end C.qos;
Raw
c-qtimeval.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.qtimeval is
pragma Preelaborate;
type struct_timeval;
type struct_timeval is record
tv_sec : aliased signed_long;
tv_usec : aliased signed_long;
end record;
pragma Convention (C_Pass_By_Copy, struct_timeval);
type struct_timeval_ptr is access all struct_timeval;
for struct_timeval_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_timeval_ptr);
pragma Convention (C, struct_timeval_ptr);
-- _TIMEVAL_DEFINED (empty)
-- timerclear (uninterpretable)
-- timercmp (unparsible)
-- timerisset (uninterpretable)
end C.qtimeval;
Raw
c-reason.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.reason is
pragma Preelaborate;
MAX_NUM_REASONS : constant := 256;
MAX_REASON_BUGID_LEN : constant := 32;
MAX_REASON_COMMENT_LEN : constant := 512;
MAX_REASON_DESC_LEN : constant := 256;
MAX_REASON_NAME_LEN : constant := 64;
PCLEANUI : constant := -2080374784;
PDIRTYUI : constant := -2013265920;
POLICY_SHOWREASONUI_ALWAYS : constant := 1;
POLICY_SHOWREASONUI_NEVER : constant := 0;
POLICY_SHOWREASONUI_SERVERONLY : constant := 3;
POLICY_SHOWREASONUI_WORKSTATIONONLY : constant := 2;
-- SENTINEL_Reason (empty)
SHTDN_REASON_FLAG_CLEAN_UI : constant := 67108864;
SHTDN_REASON_FLAG_COMMENT_REQUIRED : constant := 16777216;
SHTDN_REASON_FLAG_DIRTY_PROBLEM_ID_REQUIRED : constant := 33554432;
SHTDN_REASON_FLAG_DIRTY_UI : constant := 134217728;
SHTDN_REASON_FLAG_PLANNED : constant := -2147483648;
SHTDN_REASON_FLAG_USER_DEFINED : constant := 1073741824;
SHTDN_REASON_LEGACY_API : constant := -2147024896;
SHTDN_REASON_MAJOR_APPLICATION : constant := 262144;
SHTDN_REASON_MAJOR_HARDWARE : constant := 65536;
SHTDN_REASON_MAJOR_LEGACY_API : constant := 458752;
SHTDN_REASON_MAJOR_NONE : constant := 0;
SHTDN_REASON_MAJOR_OPERATINGSYSTEM : constant := 131072;
SHTDN_REASON_MAJOR_OTHER : constant := 0;
SHTDN_REASON_MAJOR_POWER : constant := 393216;
SHTDN_REASON_MAJOR_SOFTWARE : constant := 196608;
SHTDN_REASON_MAJOR_SYSTEM : constant := 327680;
SHTDN_REASON_MINOR_BLUESCREEN : constant := 15;
SHTDN_REASON_MINOR_CORDUNPLUGGED : constant := 11;
SHTDN_REASON_MINOR_DC_DEMOTION : constant := 34;
SHTDN_REASON_MINOR_DC_PROMOTION : constant := 33;
SHTDN_REASON_MINOR_DISK : constant := 7;
SHTDN_REASON_MINOR_ENVIRONMENT : constant := 12;
SHTDN_REASON_MINOR_HARDWARE_DRIVER : constant := 13;
SHTDN_REASON_MINOR_HOTFIX : constant := 17;
SHTDN_REASON_MINOR_HOTFIX_UNINSTALL : constant := 23;
SHTDN_REASON_MINOR_HUNG : constant := 5;
SHTDN_REASON_MINOR_INSTALLATION : constant := 2;
SHTDN_REASON_MINOR_MAINTENANCE : constant := 1;
SHTDN_REASON_MINOR_MMC : constant := 25;
SHTDN_REASON_MINOR_NETWORKCARD : constant := 9;
SHTDN_REASON_MINOR_NETWORK_CONNECTIVITY : constant := 20;
SHTDN_REASON_MINOR_NONE : constant := 255;
SHTDN_REASON_MINOR_OTHER : constant := 0;
SHTDN_REASON_MINOR_OTHERDRIVER : constant := 14;
SHTDN_REASON_MINOR_POWER_SUPPLY : constant := 10;
SHTDN_REASON_MINOR_PROCESSOR : constant := 8;
SHTDN_REASON_MINOR_RECONFIG : constant := 4;
SHTDN_REASON_MINOR_SECURITY : constant := 19;
SHTDN_REASON_MINOR_SECURITYFIX : constant := 18;
SHTDN_REASON_MINOR_SECURITYFIX_UNINSTALL : constant := 24;
SHTDN_REASON_MINOR_SERVICEPACK : constant := 16;
SHTDN_REASON_MINOR_SERVICEPACK_UNINSTALL : constant := 22;
SHTDN_REASON_MINOR_SYSTEMRESTORE : constant := 26;
SHTDN_REASON_MINOR_TERMSRV : constant := 32;
SHTDN_REASON_MINOR_UNSTABLE : constant := 6;
SHTDN_REASON_MINOR_UPGRADE : constant := 3;
SHTDN_REASON_MINOR_WMI : constant := 21;
SHTDN_REASON_UNKNOWN : constant := 255;
SHTDN_REASON_VALID_BIT_MASK : constant := -1056964609;
SHUTDOWN_TYPE_LEN : constant := 32;
SNAPSHOT_POLICY_ALWAYS : constant := 1;
SNAPSHOT_POLICY_NEVER : constant := 0;
SNAPSHOT_POLICY_UNPLANNED : constant := 2;
UCLEANUI : constant := 67108864;
UDIRTYUI : constant := 134217728;
end C.reason;
Raw
c-sal.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.sal is
pragma Preelaborate;
-- SAL_HXX (empty)
-- _In_ (empty)
-- _In_opt_ (empty)
-- _Out_ (empty)
-- __checkReturn (attribute)
-- __inner_checkReturn (attribute)
end C.sal;
Raw
c-sdkddkver.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.sdkddkver is
pragma Preelaborate;
NTDDI_LONGHORN : constant := 100663296;
NTDDI_VERSION : constant := 84017152;
-- NTDDI_VERSION_FROM_WIN32_WINNT (unparsible)
-- NTDDI_VERSION_FROM_WIN32_WINNT2 (has # or ##)
NTDDI_VISTA : constant := 100663296;
NTDDI_VISTASP1 : constant := 100663552;
NTDDI_VISTASP2 : constant := 100663808;
NTDDI_VISTASP3 : constant := 100664064;
NTDDI_VISTASP4 : constant := 100664320;
NTDDI_WIN2K : constant := 83886080;
NTDDI_WIN2KSP1 : constant := 83886336;
NTDDI_WIN2KSP2 : constant := 83886592;
NTDDI_WIN2KSP3 : constant := 83886848;
NTDDI_WIN2KSP4 : constant := 83887104;
NTDDI_WIN6 : constant := 100663296;
NTDDI_WIN6SP1 : constant := 100663552;
NTDDI_WIN6SP2 : constant := 100663808;
NTDDI_WIN6SP3 : constant := 100664064;
NTDDI_WIN6SP4 : constant := 100664320;
NTDDI_WIN7 : constant := 100728832;
NTDDI_WIN8 : constant := 100794368;
NTDDI_WINXP : constant := 83951616;
NTDDI_WINXPSP1 : constant := 83951872;
NTDDI_WINXPSP2 : constant := 83952128;
NTDDI_WINXPSP3 : constant := 83952384;
NTDDI_WINXPSP4 : constant := 83952640;
NTDDI_WS03 : constant := 84017152;
NTDDI_WS03SP1 : constant := 84017408;
NTDDI_WS03SP2 : constant := 84017664;
NTDDI_WS03SP3 : constant := 84017920;
NTDDI_WS03SP4 : constant := 84018176;
NTDDI_WS08 : constant := 100663552;
NTDDI_WS08SP2 : constant := 100663808;
NTDDI_WS08SP3 : constant := 100664064;
NTDDI_WS08SP4 : constant := 100664320;
-- OSVER (function macro)
OSVERSION_MASK : constant := -65536;
-- SPVER (function macro)
SPVERSION_MASK : constant := 65280;
-- SUBVER (function macro)
SUBVERSION_MASK : constant := 255;
-- _INC_SDKDDKVER (empty)
WIN32_IE : constant := 1538;
WIN32_IE_IE20 : constant := 512;
WIN32_IE_IE30 : constant := 768;
WIN32_IE_IE302 : constant := 770;
WIN32_IE_IE40 : constant := 1024;
WIN32_IE_IE401 : constant := 1025;
WIN32_IE_IE50 : constant := 1280;
WIN32_IE_IE501 : constant := 1281;
WIN32_IE_IE55 : constant := 1360;
WIN32_IE_IE60 : constant := 1536;
WIN32_IE_IE60SP1 : constant := 1537;
WIN32_IE_IE60SP2 : constant := 1539;
WIN32_IE_IE70 : constant := 1792;
WIN32_IE_IE80 : constant := 2048;
WIN32_IE_LONGHORN : constant := 1792;
WIN32_IE_NT4 : constant := 512;
WIN32_IE_NT4SP1 : constant := 512;
WIN32_IE_NT4SP2 : constant := 512;
WIN32_IE_NT4SP3 : constant := 770;
WIN32_IE_NT4SP4 : constant := 1025;
WIN32_IE_NT4SP5 : constant := 1025;
WIN32_IE_NT4SP6 : constant := 1280;
WIN32_IE_WIN2K : constant := 1281;
WIN32_IE_WIN2KSP1 : constant := 1281;
WIN32_IE_WIN2KSP2 : constant := 1281;
WIN32_IE_WIN2KSP3 : constant := 1281;
WIN32_IE_WIN2KSP4 : constant := 1281;
WIN32_IE_WIN6 : constant := 1792;
WIN32_IE_WIN7 : constant := 2048;
WIN32_IE_WIN98 : constant := 1025;
WIN32_IE_WIN98SE : constant := 1280;
WIN32_IE_WINME : constant := 1360;
WIN32_IE_WS03 : constant := 1538;
WIN32_IE_WS03SP1 : constant := 1539;
WIN32_IE_XP : constant := 1536;
WIN32_IE_XPSP1 : constant := 1537;
WIN32_IE_XPSP2 : constant := 1539;
WIN32_WINNT_LONGHORN : constant := 1536;
WIN32_WINNT_NT4 : constant := 1024;
WIN32_WINNT_VISTA : constant := 1536;
WIN32_WINNT_WIN2K : constant := 1280;
WIN32_WINNT_WIN6 : constant := 1536;
WIN32_WINNT_WIN7 : constant := 1537;
WIN32_WINNT_WIN8 : constant := 1538;
WIN32_WINNT_WINXP : constant := 1281;
WIN32_WINNT_WS03 : constant := 1282;
WIN32_WINNT_WS08 : constant := 1536;
end C.sdkddkver;
Raw
c-sdks-qmingw_ddk.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.sdks.qmingw_ddk is
pragma Preelaborate;
-- MINGW_DDK_H (empty)
MINGW_HAS_DDK_H : constant := 1;
end C.sdks.qmingw_ddk;
Raw
c-sdks-qmingw_directx.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.sdks.qmingw_directx is
pragma Preelaborate;
MINGW_DDRAW_VERSION : constant := 7;
MINGW_HAS_DDRAW_H : constant := 1;
MINGW_HAS_DXSDK : constant := 1;
end C.sdks.qmingw_directx;
Raw
c-sdks.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.sdks is
pragma Preelaborate;
end C.sdks;
Raw
c-sec_api-stdlib_s.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.sec_api.stdlib_s is
pragma Preelaborate;
-- _INC_STDLIB_S (empty)
end C.sec_api.stdlib_s;
Raw
c-sec_api-stralign_s.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.sec_api.stralign_s is
pragma Preelaborate;
-- __STRALIGN_H_S_ (empty)
end C.sec_api.stralign_s;
Raw
c-sec_api-string_s.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.sec_api.string_s is
pragma Preelaborate;
-- _INC_STRING_S (empty)
end C.sec_api.string_s;
Raw
c-sec_api.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.sec_api is
pragma Preelaborate;
end C.sec_api;
Raw
c-signal.adb
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package body C.signal is
function qpxcptinfoptrs return void_ptr is
begin
return qqpxcptinfoptrs.all;
end qpxcptinfoptrs;
end C.signal;
Raw
c-signal.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
with Ada.Unchecked_Conversion;
package C.signal is
pragma Preelaborate;
subtype sig_atomic_t is signed_int;
type access_0bf470ec is access procedure (a1 : signed_int);
pragma Convention (C, access_0bf470ec);
subtype p_sig_fn_t is access_0bf470ec;
function Cast is new Ada.Unchecked_Conversion (signed_long_long,
p_sig_fn_t);
function qqpxcptinfoptrs return void_ptr_ptr;
pragma Import (C, qqpxcptinfoptrs, "__pxcptinfoptrs");
function signal (SigNum : signed_int; Func : p_sig_fn_t)
return p_sig_fn_t;
pragma Import (C, signal, "signal");
function C_raise (SigNum : signed_int) return signed_int;
pragma Import (C, C_raise, "raise");
NSIG : constant := 23;
SIGABRT : constant := 22;
SIGABRT2 : constant := 22;
SIGABRT_COMPAT : constant := 6;
SIGBREAK : constant := 21;
SIGFPE : constant := 8;
SIGILL : constant := 4;
SIGINT : constant := 2;
SIGSEGV : constant := 11;
SIGTERM : constant := 15;
function SIG_ACK (Value : signed_long_long := signed_long_long'(4))
return p_sig_fn_t renames Cast;
function SIG_DFL (Value : signed_long_long := signed_long_long'(0))
return p_sig_fn_t renames Cast;
function SIG_ERR (Value : signed_long_long := signed_long_long'(-1))
return p_sig_fn_t renames Cast;
function SIG_GET (Value : signed_long_long := signed_long_long'(2))
return p_sig_fn_t renames Cast;
function SIG_IGN (Value : signed_long_long := signed_long_long'(1))
return p_sig_fn_t renames Cast;
function SIG_SGE (Value : signed_long_long := signed_long_long'(3))
return p_sig_fn_t renames Cast;
-- _INC_SIGNAL (empty)
-- _SIG_ATOMIC_T_DEFINED (empty)
function qpxcptinfoptrs return void_ptr;
pragma Inline_Always (qpxcptinfoptrs);
end C.signal;
Raw
c-specstrings.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.specstrings is
pragma Preelaborate;
-- DECLSPEC_ADDRSAFE (empty)
-- SAL__bcount (empty)
-- SAL__bcount_opt (empty)
-- SAL__blocksOn (empty)
-- SAL__byte_readableTo (empty)
-- SAL__byte_writableTo (empty)
-- SAL__callback (empty)
-- SAL__checkReturn (empty)
-- SAL__control_entrypoint (empty)
-- SAL__data_entrypoint (empty)
-- SAL__deref (empty)
-- SAL__deref_bcount (empty)
-- SAL__deref_bcount_opt (empty)
-- SAL__deref_ecount (empty)
-- SAL__deref_ecount_opt (empty)
-- SAL__deref_in (empty)
-- SAL__deref_in_bcount (empty)
-- SAL__deref_in_bcount_opt (empty)
-- SAL__deref_in_ecount (empty)
-- SAL__deref_in_ecount_opt (empty)
-- SAL__deref_in_opt (empty)
-- SAL__deref_inout (empty)
-- SAL__deref_inout_bcount (empty)
-- SAL__deref_inout_bcount_full (empty)
-- SAL__deref_inout_bcount_full_opt (empty)
-- SAL__deref_inout_bcount_nz (empty)
-- SAL__deref_inout_bcount_nz_opt (empty)
-- SAL__deref_inout_bcount_opt (empty)
-- SAL__deref_inout_bcount_part (empty)
-- SAL__deref_inout_bcount_part_opt (empty)
-- SAL__deref_inout_bcount_z (empty)
-- SAL__deref_inout_bcount_z_opt (empty)
-- SAL__deref_inout_ecount (empty)
-- SAL__deref_inout_ecount_full (empty)
-- SAL__deref_inout_ecount_full_opt (empty)
-- SAL__deref_inout_ecount_nz (empty)
-- SAL__deref_inout_ecount_nz_opt (empty)
-- SAL__deref_inout_ecount_opt (empty)
-- SAL__deref_inout_ecount_part (empty)
-- SAL__deref_inout_ecount_part_opt (empty)
-- SAL__deref_inout_ecount_z (empty)
-- SAL__deref_inout_ecount_z_opt (empty)
-- SAL__deref_inout_nz (empty)
-- SAL__deref_inout_nz_opt (empty)
-- SAL__deref_inout_opt (empty)
-- SAL__deref_inout_z (empty)
-- SAL__deref_inout_z_opt (empty)
-- SAL__deref_opt_bcount (empty)
-- SAL__deref_opt_bcount_opt (empty)
-- SAL__deref_opt_ecount (empty)
-- SAL__deref_opt_ecount_opt (empty)
-- SAL__deref_opt_in (empty)
-- SAL__deref_opt_in_bcount (empty)
-- SAL__deref_opt_in_bcount_opt (empty)
-- SAL__deref_opt_in_ecount (empty)
-- SAL__deref_opt_in_ecount_opt (empty)
-- SAL__deref_opt_in_opt (empty)
-- SAL__deref_opt_inout (empty)
-- SAL__deref_opt_inout_bcount (empty)
-- SAL__deref_opt_inout_bcount_full (empty)
-- SAL__deref_opt_inout_bcount_full_opt (empty)
-- SAL__deref_opt_inout_bcount_nz (empty)
-- SAL__deref_opt_inout_bcount_nz_opt (empty)
-- SAL__deref_opt_inout_bcount_opt (empty)
-- SAL__deref_opt_inout_bcount_part (empty)
-- SAL__deref_opt_inout_bcount_part_opt (empty)
-- SAL__deref_opt_inout_bcount_z (empty)
-- SAL__deref_opt_inout_bcount_z_opt (empty)
-- SAL__deref_opt_inout_ecount (empty)
-- SAL__deref_opt_inout_ecount_full (empty)
-- SAL__deref_opt_inout_ecount_full_opt (empty)
-- SAL__deref_opt_inout_ecount_nz (empty)
-- SAL__deref_opt_inout_ecount_nz_opt (empty)
-- SAL__deref_opt_inout_ecount_opt (empty)
-- SAL__deref_opt_inout_ecount_part (empty)
-- SAL__deref_opt_inout_ecount_part_opt (empty)
-- SAL__deref_opt_inout_ecount_z (empty)
-- SAL__deref_opt_inout_ecount_z_opt (empty)
-- SAL__deref_opt_inout_nz (empty)
-- SAL__deref_opt_inout_nz_opt (empty)
-- SAL__deref_opt_inout_opt (empty)
-- SAL__deref_opt_inout_z (empty)
-- SAL__deref_opt_inout_z_opt (empty)
-- SAL__deref_opt_out (empty)
-- SAL__deref_opt_out_bcount (empty)
-- SAL__deref_opt_out_bcount_full (empty)
-- SAL__deref_opt_out_bcount_full_opt (empty)
-- SAL__deref_opt_out_bcount_nz_opt (empty)
-- SAL__deref_opt_out_bcount_opt (empty)
-- SAL__deref_opt_out_bcount_part (empty)
-- SAL__deref_opt_out_bcount_part_opt (empty)
-- SAL__deref_opt_out_bcount_z_opt (empty)
-- SAL__deref_opt_out_ecount (empty)
-- SAL__deref_opt_out_ecount_full (empty)
-- SAL__deref_opt_out_ecount_full_opt (empty)
-- SAL__deref_opt_out_ecount_nz_opt (empty)
-- SAL__deref_opt_out_ecount_opt (empty)
-- SAL__deref_opt_out_ecount_part (empty)
-- SAL__deref_opt_out_ecount_part_opt (empty)
-- SAL__deref_opt_out_ecount_z_opt (empty)
-- SAL__deref_opt_out_nz_opt (empty)
-- SAL__deref_opt_out_opt (empty)
-- SAL__deref_opt_out_z (empty)
-- SAL__deref_opt_out_z_opt (empty)
-- SAL__deref_out (empty)
-- SAL__deref_out_bcount (empty)
-- SAL__deref_out_bcount_full (empty)
-- SAL__deref_out_bcount_full_opt (empty)
-- SAL__deref_out_bcount_nz (empty)
-- SAL__deref_out_bcount_nz_opt (empty)
-- SAL__deref_out_bcount_opt (empty)
-- SAL__deref_out_bcount_part (empty)
-- SAL__deref_out_bcount_part_opt (empty)
-- SAL__deref_out_bcount_z (empty)
-- SAL__deref_out_bcount_z_opt (empty)
-- SAL__deref_out_ecount (empty)
-- SAL__deref_out_ecount_full (empty)
-- SAL__deref_out_ecount_full_opt (empty)
-- SAL__deref_out_ecount_nz (empty)
-- SAL__deref_out_ecount_nz_opt (empty)
-- SAL__deref_out_ecount_opt (empty)
-- SAL__deref_out_ecount_part (empty)
-- SAL__deref_out_ecount_part_opt (empty)
-- SAL__deref_out_ecount_z (empty)
-- SAL__deref_out_ecount_z_opt (empty)
-- SAL__deref_out_nz (empty)
-- SAL__deref_out_nz_opt (empty)
-- SAL__deref_out_opt (empty)
-- SAL__deref_out_z (empty)
-- SAL__deref_out_z_opt (empty)
-- SAL__ecount (empty)
-- SAL__ecount_opt (empty)
-- SAL__elem_readableTo (empty)
-- SAL__elem_writableTo (empty)
-- SAL__exceptthat (empty)
-- SAL__execeptthat (empty)
-- SAL__format_string (empty)
-- SAL__in (empty)
-- SAL__in_awcount (empty)
-- SAL__in_bcount (empty)
-- SAL__in_bcount_nz (empty)
-- SAL__in_bcount_nz_opt (empty)
-- SAL__in_bcount_opt (empty)
-- SAL__in_bcount_z (empty)
-- SAL__in_bcount_z_opt (empty)
-- SAL__in_ecount (empty)
-- SAL__in_ecount_nz (empty)
-- SAL__in_ecount_nz_opt (empty)
-- SAL__in_ecount_opt (empty)
-- SAL__in_ecount_z (empty)
-- SAL__in_ecount_z_opt (empty)
-- SAL__in_nz (empty)
-- SAL__in_nz_opt (empty)
-- SAL__in_opt (empty)
-- SAL__in_z (empty)
-- SAL__in_z_opt (empty)
-- SAL__inner_blocksOn (empty)
-- SAL__inner_callback (empty)
-- SAL__inner_checkReturn (empty)
-- SAL__inner_control_entrypoint (empty)
-- SAL__inner_data_entrypoint (empty)
-- SAL__inner_fallthrough (empty)
-- SAL__inner_fallthrough_dec (empty)
-- SAL__inner_override (empty)
-- SAL__inner_success (empty)
-- SAL__inner_typefix (empty)
-- SAL__inout (empty)
-- SAL__inout_bcount (empty)
-- SAL__inout_bcount_full (empty)
-- SAL__inout_bcount_full_opt (empty)
-- SAL__inout_bcount_nz (empty)
-- SAL__inout_bcount_nz_opt (empty)
-- SAL__inout_bcount_opt (empty)
-- SAL__inout_bcount_part (empty)
-- SAL__inout_bcount_part_opt (empty)
-- SAL__inout_bcount_z (empty)
-- SAL__inout_bcount_z_opt (empty)
-- SAL__inout_ecount (empty)
-- SAL__inout_ecount_full (empty)
-- SAL__inout_ecount_full_opt (empty)
-- SAL__inout_ecount_nz (empty)
-- SAL__inout_ecount_nz_opt (empty)
-- SAL__inout_ecount_opt (empty)
-- SAL__inout_ecount_part (empty)
-- SAL__inout_ecount_part_opt (empty)
-- SAL__inout_ecount_z (empty)
-- SAL__inout_ecount_z_opt (empty)
-- SAL__inout_nz (empty)
-- SAL__inout_nz_opt (empty)
-- SAL__inout_opt (empty)
-- SAL__inout_z (empty)
-- SAL__inout_z_opt (empty)
-- SAL__maybenull (empty)
-- SAL__maybereadonly (empty)
-- SAL__maybevalid (empty)
-- SAL__notnull (empty)
-- SAL__notreadonly (empty)
-- SAL__notvalid (empty)
-- SAL__null (empty)
-- SAL__nullnullterminated (empty)
-- SAL__nullterminated (empty)
-- SAL__out (empty)
-- SAL__out_awcount (empty)
-- SAL__out_bcount (empty)
-- SAL__out_bcount_full (empty)
-- SAL__out_bcount_full_opt (empty)
-- SAL__out_bcount_full_z (empty)
-- SAL__out_bcount_full_z_opt (empty)
-- SAL__out_bcount_nz (empty)
-- SAL__out_bcount_nz_opt (empty)
-- SAL__out_bcount_opt (empty)
-- SAL__out_bcount_part (empty)
-- SAL__out_bcount_part_opt (empty)
-- SAL__out_bcount_part_z (empty)
-- SAL__out_bcount_part_z_opt (empty)
-- SAL__out_bcount_z (empty)
-- SAL__out_bcount_z_opt (empty)
-- SAL__out_ecount (empty)
-- SAL__out_ecount_full (empty)
-- SAL__out_ecount_full_opt (empty)
-- SAL__out_ecount_full_z (empty)
-- SAL__out_ecount_full_z_opt (empty)
-- SAL__out_ecount_nz (empty)
-- SAL__out_ecount_nz_opt (empty)
-- SAL__out_ecount_opt (empty)
-- SAL__out_ecount_part (empty)
-- SAL__out_ecount_part_opt (empty)
-- SAL__out_ecount_part_z (empty)
-- SAL__out_ecount_part_z_opt (empty)
-- SAL__out_ecount_z (empty)
-- SAL__out_ecount_z_opt (empty)
-- SAL__out_nz (empty)
-- SAL__out_nz_opt (empty)
-- SAL__out_opt (empty)
-- SAL__out_z (empty)
-- SAL__out_z_opt (empty)
-- SAL__override (empty)
-- SAL__post (empty)
-- SAL__postcond (empty)
-- SAL__pre (empty)
-- SAL__precond (empty)
-- SAL__readableTo (empty)
-- SAL__readonly (empty)
-- SAL__reserved (empty)
-- SAL__success (empty)
-- SAL__typefix (empty)
-- SAL__valid (empty)
-- SAL__writableTo (empty)
-- _CRT_SECURE_NO_DEPRECATE (empty)
pragma Convention_Identifier (CLRCALL_OR_CDECL, C);
-- __CLR_OR_THIS_CALL (empty)
STDC_WANT_SECURE_LIB : constant := 0;
-- __analysis_assume (empty)
-- __fallthrough (empty)
-- __refparam (empty)
-- __specstrings (empty)
end C.specstrings;
Raw
c-stdarg.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.stdarg is
pragma Preelaborate;
-- _ANSI_STDARG_H_ (empty)
-- _STDARG_H (empty)
-- _VA_LIST (empty)
-- _VA_LIST_ (empty)
-- _VA_LIST_T_H (empty)
-- __va_copy (function macro)
-- __va_list__ (empty)
-- va_arg (function macro)
-- va_copy (function macro)
-- va_end (function macro)
-- va_start (function macro)
end C.stdarg;
Raw
c-stddef.adb
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package body C.stddef is
function qthreadid return unsigned_long is
begin
return qqthreadid;
end qthreadid;
function errno return signed_int is
begin
return qerrno.all;
end errno;
end C.stddef;
Raw
c-stddef.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
with C.qmingw;
package C.stddef is
pragma Preelaborate;
C_NULL : constant void_ptr := void_ptr (System'To_Address (0));
-- _ANSI_STDDEF_H (empty)
-- _STDDEF_H (empty)
-- _STDDEF_H_ (empty)
-- offsetof (unparsible)
function qerrno return signed_int_ptr;
pragma Import (C, qerrno, "_errno");
function set_errno (Value : signed_int) return qmingw.errno_t;
pragma Import (C, set_errno, "_set_errno");
function get_errno (Value : access signed_int) return qmingw.errno_t;
pragma Import (C, get_errno, "_get_errno");
function qqthreadid return unsigned_long;
pragma Import (C, qqthreadid, "__threadid");
function threadhandle return qmingw.uintptr_t;
pragma Import (C, threadhandle, "__threadhandle");
-- _CRT_ERRNO_DEFINED (empty)
-- _INC_STDDEF (empty)
function qthreadid return unsigned_long;
pragma Inline_Always (qthreadid);
function errno return signed_int;
pragma Inline_Always (errno);
end C.stddef;
Raw
c-stdint.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.stdint is
pragma Preelaborate;
-- _GCC_WRAP_STDINT_H (empty)
subtype int8_t is signed_char;
subtype uint8_t is unsigned_char;
subtype int16_t is signed_short;
subtype uint16_t is unsigned_short;
subtype int32_t is signed_int;
subtype uint32_t is unsigned_int;
subtype int64_t is signed_long_long;
subtype uint64_t is unsigned_long_long;
subtype int_least8_t is signed_char;
subtype uint_least8_t is unsigned_char;
subtype int_least16_t is signed_short;
subtype uint_least16_t is unsigned_short;
subtype int_least32_t is signed_int;
subtype uint_least32_t is unsigned_int;
subtype int_least64_t is signed_long_long;
subtype uint_least64_t is unsigned_long_long;
subtype int_fast8_t is signed_char;
subtype uint_fast8_t is unsigned_char;
subtype int_fast16_t is signed_short;
subtype uint_fast16_t is unsigned_short;
subtype int_fast32_t is signed_int;
subtype uint_fast32_t is unsigned_int;
subtype int_fast64_t is signed_long_long;
subtype uint_fast64_t is unsigned_long_long;
subtype intmax_t is signed_long_long;
subtype uintmax_t is unsigned_long_long;
-- INT16_C (function macro)
INT16_MAX : constant := 32767;
INT16_MIN : constant := -32768;
-- INT32_C (function macro)
INT32_MAX : constant := 2147483647;
INT32_MIN : constant := -2147483648;
-- INT64_C (has # or ##)
INT64_MAX : constant := 9223372036854775807;
INT64_MIN : constant := -9223372036854775808;
-- INT8_C (function macro)
INT8_MAX : constant := 127;
INT8_MIN : constant := -128;
-- INTMAX_C (has # or ##)
INTMAX_MAX : constant := 9223372036854775807;
INTMAX_MIN : constant := -9223372036854775808;
INTPTR_MAX : constant := 9223372036854775807;
INTPTR_MIN : constant := -9223372036854775808;
INT_FAST16_MAX : constant := 32767;
INT_FAST16_MIN : constant := -32768;
INT_FAST32_MAX : constant := 2147483647;
INT_FAST32_MIN : constant := -2147483648;
INT_FAST64_MAX : constant := 9223372036854775807;
INT_FAST64_MIN : constant := -9223372036854775808;
INT_FAST8_MAX : constant := 127;
INT_FAST8_MIN : constant := -128;
INT_LEAST16_MAX : constant := 32767;
INT_LEAST16_MIN : constant := -32768;
INT_LEAST32_MAX : constant := 2147483647;
INT_LEAST32_MIN : constant := -2147483648;
INT_LEAST64_MAX : constant := 9223372036854775807;
INT_LEAST64_MIN : constant := -9223372036854775808;
INT_LEAST8_MAX : constant := 127;
INT_LEAST8_MIN : constant := -128;
PTRDIFF_MAX : constant := 9223372036854775807;
PTRDIFF_MIN : constant := -9223372036854775808;
SIG_ATOMIC_MAX : constant := 2147483647;
SIG_ATOMIC_MIN : constant := -2147483648;
SIZE_MAX : constant := 18446744073709551615;
-- UINT16_C (function macro)
UINT16_MAX : constant := 65535;
-- UINT32_C (has # or ##)
UINT32_MAX : constant := 4294967295;
-- UINT64_C (has # or ##)
UINT64_MAX : constant := 18446744073709551615;
-- UINT8_C (function macro)
UINT8_MAX : constant := 255;
-- UINTMAX_C (has # or ##)
UINTMAX_MAX : constant := 18446744073709551615;
UINTPTR_MAX : constant := 18446744073709551615;
UINT_FAST16_MAX : constant := 65535;
UINT_FAST32_MAX : constant := 4294967295;
UINT_FAST64_MAX : constant := 18446744073709551615;
UINT_FAST8_MAX : constant := 255;
UINT_LEAST16_MAX : constant := 65535;
UINT_LEAST32_MAX : constant := 4294967295;
UINT_LEAST64_MAX : constant := 18446744073709551615;
UINT_LEAST8_MAX : constant := 255;
WCHAR_MAX : constant := 65535;
WCHAR_MIN : constant := 0;
WINT_MAX : constant := 65535;
WINT_MIN : constant := 0;
-- _STDINT_H (empty)
end C.stdint;
Raw
c-stdlib.adb
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package body C.stdlib is
function argc return signed_int is
begin
return imp_argc.all;
end argc;
function argv return char_ptr_ptr is
begin
return imp_argv.all;
end argv;
function wargv return qmingw.wchar_t_ptr_ptr is
begin
return imp_wargv.all;
end wargv;
function qdoserrno return unsigned_long is
begin
return qqdoserrno.all;
end qdoserrno;
function qenviron return char_ptr_ptr is
begin
return imp_environ.all;
end qenviron;
function fmode return signed_int is
begin
return imp_fmode.all;
end fmode;
function osplatform return unsigned_int is
begin
return imp_osplatform.all;
end osplatform;
function osver return unsigned_int is
begin
return imp_osver.all;
end osver;
function pgmptr return char_ptr is
begin
return imp_pgmptr.all;
end pgmptr;
function wenviron return qmingw.wchar_t_ptr_ptr is
begin
return imp_wenviron.all;
end wenviron;
function winmajor return unsigned_int is
begin
return imp_winmajor.all;
end winmajor;
function winminor return unsigned_int is
begin
return imp_winminor.all;
end winminor;
function winver return unsigned_int is
begin
return imp_winver.all;
end winver;
function wpgmptr return qmingw.wchar_t_ptr is
begin
return imp_wpgmptr.all;
end wpgmptr;
function environ return char_ptr_ptr is
begin
return imp_environ.all;
end environ;
end C.stdlib;
Raw
c-stdlib.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
with C.crtdefs;
with C.malloc;
with C.qmingw;
package C.stdlib is
pragma Preelaborate;
subtype struct_heapinfo is malloc.struct_heapinfo;
subtype HEAPINFO is malloc.HEAPINFO;
amblksiz : unsigned_int renames malloc.amblksiz;
function calloc (NumOfElements : qmingw.size_t;
SizeOfElements : qmingw.size_t) return void_ptr renames malloc.calloc;
procedure free (Memory : void_ptr) renames malloc.free;
function malloc (Size : qmingw.size_t) return void_ptr
renames Standard.C.malloc.malloc;
function realloc (Memory : void_ptr; NewSize : qmingw.size_t)
return void_ptr renames Standard.C.malloc.realloc;
function recalloc (Memory : void_ptr; Count : qmingw.size_t;
Size : qmingw.size_t) return void_ptr
renames Standard.C.malloc.recalloc;
procedure aligned_free (Memory : void_ptr)
renames Standard.C.malloc.aligned_free;
function aligned_malloc (Size : qmingw.size_t; Alignment : qmingw.size_t)
return void_ptr renames Standard.C.malloc.aligned_malloc;
function aligned_offset_malloc (Size : qmingw.size_t;
Alignment : qmingw.size_t; Offset : qmingw.size_t) return void_ptr
renames Standard.C.malloc.aligned_offset_malloc;
function aligned_realloc (Memory : void_ptr; Size : qmingw.size_t;
Alignment : qmingw.size_t) return void_ptr
renames Standard.C.malloc.aligned_realloc;
function aligned_recalloc (Memory : void_ptr; Count : qmingw.size_t;
Size : qmingw.size_t; Alignment : qmingw.size_t) return void_ptr
renames Standard.C.malloc.aligned_recalloc;
function aligned_offset_realloc (Memory : void_ptr; Size : qmingw.size_t;
Alignment : qmingw.size_t; Offset : qmingw.size_t) return void_ptr
renames Standard.C.malloc.aligned_offset_realloc;
function aligned_offset_recalloc (Memory : void_ptr;
Count : qmingw.size_t; Size : qmingw.size_t; Alignment : qmingw.size_t;
Offset : qmingw.size_t) return void_ptr
renames Standard.C.malloc.aligned_offset_recalloc;
function mingw_aligned_malloc (Size : qmingw.size_t;
Alignment : qmingw.size_t) return void_ptr
renames Standard.C.malloc.mingw_aligned_malloc;
procedure mingw_aligned_free (Memory : void_ptr)
renames Standard.C.malloc.mingw_aligned_free;
function mingw_aligned_offset_realloc (Memory : void_ptr;
Size : qmingw.size_t; Alignment : qmingw.size_t;
Offset : qmingw.size_t) return void_ptr
renames Standard.C.malloc.mingw_aligned_offset_realloc;
function mingw_aligned_realloc (Memory : void_ptr; Size : qmingw.size_t;
Offset : qmingw.size_t) return void_ptr
renames Standard.C.malloc.mingw_aligned_realloc;
function resetstkoflw return signed_int
renames Standard.C.malloc.resetstkoflw;
function set_malloc_crt_max_wait (NewValue : unsigned_long)
return unsigned_long renames Standard.C.malloc.set_malloc_crt_max_wait;
function expand (Memory : void_ptr; NewSize : qmingw.size_t)
return void_ptr renames Standard.C.malloc.expand;
function msize (Memory : void_ptr) return qmingw.size_t
renames Standard.C.malloc.msize;
function get_sbh_threshold return qmingw.size_t
renames Standard.C.malloc.get_sbh_threshold;
function set_sbh_threshold (NewValue : qmingw.size_t) return signed_int
renames Standard.C.malloc.set_sbh_threshold;
function set_amblksiz (Value : qmingw.size_t) return qmingw.errno_t
renames Standard.C.malloc.set_amblksiz;
function get_amblksiz (Value : access qmingw.size_t) return qmingw.errno_t
renames Standard.C.malloc.get_amblksiz;
function heapadd (Memory : void_ptr; Size : qmingw.size_t)
return signed_int renames Standard.C.malloc.heapadd;
function heapchk return signed_int renames Standard.C.malloc.heapchk;
function heapmin return signed_int renames Standard.C.malloc.heapmin;
function heapset (Fill : unsigned_int) return signed_int
renames Standard.C.malloc.heapset;
function heapwalk (EntryInfo : access Standard.C.malloc.HEAPINFO)
return signed_int renames Standard.C.malloc.heapwalk;
function heapused (Used : access qmingw.size_t;
Commit : access qmingw.size_t) return qmingw.size_t
renames Standard.C.malloc.heapused;
function get_heap_handle return qmingw.intptr_t
renames Standard.C.malloc.get_heap_handle;
ALLOCA_S_HEAP_MARKER : constant := Standard.C.malloc.ALLOCA_S_HEAP_MARKER;
ALLOCA_S_MARKER_SIZE : constant := Standard.C.malloc.ALLOCA_S_MARKER_SIZE;
ALLOCA_S_STACK_MARKER : constant :=
Standard.C.malloc.ALLOCA_S_STACK_MARKER;
ALLOCA_S_THRESHOLD : constant := Standard.C.malloc.ALLOCA_S_THRESHOLD;
-- CRT_ALLOCATION_DEFINED renames Standard.C.malloc.CRT_ALLOCATI... (empty)
-- FREEA_INLINE renames Standard.C.malloc.FREEA_INLINE (empty)
FREEENTRY : constant := Standard.C.malloc.FREEENTRY;
HEAPBADBEGIN : constant := Standard.C.malloc.HEAPBADBEGIN;
HEAPBADNODE : constant := Standard.C.malloc.HEAPBADNODE;
HEAPBADPTR : constant := Standard.C.malloc.HEAPBADPTR;
HEAPEMPTY : constant := Standard.C.malloc.HEAPEMPTY;
HEAPEND : constant := Standard.C.malloc.HEAPEND;
-- HEAPINFO_DEFINED renames Standard.C.malloc.HEAPINFO_DEFINED (empty)
HEAPOK : constant := Standard.C.malloc.HEAPOK;
HEAP_MAXREQ : constant := Standard.C.malloc.HEAP_MAXREQ;
-- MALLOC_H renames Standard.C.malloc.MALLOC_H (empty)
MAX_WAIT_MALLOC_CRT : constant := Standard.C.malloc.MAX_WAIT_MALLOC_CRT;
-- MM_MALLOC_H_INCLUDED renames Standard.C.malloc.MM_MALLOC_H_IN... (empty)
-- STATIC_ASSERT renames Standard.C.malloc.STATIC_ASSERT (unparsible)
USEDENTRY : constant := Standard.C.malloc.USEDENTRY;
-- qalloca renames Standard.C.malloc.qalloca (function macro)
-- malloca renames Standard.C.malloc.malloca (unparsible)
-- mm_free renames Standard.C.malloc.mm_free (uninterpretable)
-- mm_malloc renames Standard.C.malloc.mm_malloc (uninterpretable)
-- alloca renames Standard.C.malloc.alloca (function macro)
type access_e83afa7d is access function return signed_int;
pragma Convention (C, access_e83afa7d);
subtype qonexit_t is access_e83afa7d;
type struct_div_t;
type struct_div_t is record
quot : aliased signed_int;
F_rem : aliased signed_int;
end record;
for struct_div_t'Alignment use 8;
pragma Convention (C_Pass_By_Copy, struct_div_t);
subtype div_t is struct_div_t;
type struct_ldiv_t;
type struct_ldiv_t is record
quot : aliased signed_long;
F_rem : aliased signed_long;
end record;
for struct_ldiv_t'Alignment use 8;
pragma Convention (C_Pass_By_Copy, struct_ldiv_t);
subtype ldiv_t is struct_ldiv_t;
type struct_aa488d82 is record
ld : aliased unsigned_char_array (0 .. 9);
end record;
for struct_aa488d82'Alignment use 4;
pragma Convention (C_Pass_By_Copy, struct_aa488d82);
type struct_aa488d82_ptr is access all struct_aa488d82;
for struct_aa488d82_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_aa488d82_ptr);
pragma Convention (C, struct_aa488d82_ptr);
subtype LDOUBLE is struct_aa488d82;
subtype LDOUBLE_ptr is struct_aa488d82_ptr;
type struct_b19d9df0 is record
x : aliased double;
end record;
pragma Convention (C_Pass_By_Copy, struct_b19d9df0);
type struct_b19d9df0_ptr is access all struct_b19d9df0;
for struct_b19d9df0_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_b19d9df0_ptr);
pragma Convention (C, struct_b19d9df0_ptr);
subtype CRT_DOUBLE is struct_b19d9df0;
subtype CRT_DOUBLE_ptr is struct_b19d9df0_ptr;
type struct_dd07d4b3 is record
f : aliased float;
end record;
pragma Convention (C_Pass_By_Copy, struct_dd07d4b3);
type struct_dd07d4b3_ptr is access all struct_dd07d4b3;
for struct_dd07d4b3_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_dd07d4b3_ptr);
pragma Convention (C, struct_dd07d4b3_ptr);
subtype CRT_FLOAT is struct_dd07d4b3;
subtype CRT_FLOAT_ptr is struct_dd07d4b3_ptr;
type struct_382e3479 is record
x : aliased long_double;
end record;
pragma Convention (C_Pass_By_Copy, struct_382e3479);
subtype LONGDOUBLE is struct_382e3479;
type struct_94da4874 is record
ld12 : aliased unsigned_char_array (0 .. 11);
end record;
for struct_94da4874'Alignment use 4;
pragma Convention (C_Pass_By_Copy, struct_94da4874);
subtype LDBL12 is struct_94da4874;
type access_e823f645 is access procedure;
pragma Convention (C, access_e823f645);
subtype purecall_handler is access_e823f645;
function set_purecall_handler (Handler : purecall_handler)
return purecall_handler;
pragma Import (C, set_purecall_handler, "_set_purecall_handler");
function get_purecall_handler return purecall_handler;
pragma Import (C, get_purecall_handler, "_get_purecall_handler");
type access_49536999 is access procedure (
a1 : access constant qmingw.wchar_t;
a2 : access constant qmingw.wchar_t;
a3 : access constant qmingw.wchar_t; a4 : unsigned_int;
a5 : qmingw.uintptr_t);
pragma Convention (C, access_49536999);
subtype invalid_parameter_handler is access_49536999;
function set_invalid_parameter_handler (
Handler : invalid_parameter_handler) return invalid_parameter_handler;
pragma Import (C, set_invalid_parameter_handler,
"_set_invalid_parameter_handler");
function get_invalid_parameter_handler return invalid_parameter_handler;
pragma Import (C, get_invalid_parameter_handler,
"_get_invalid_parameter_handler");
function qqdoserrno return unsigned_long_ptr;
pragma Import (C, qqdoserrno, "__doserrno");
function set_doserrno (Value : unsigned_long) return qmingw.errno_t;
pragma Import (C, set_doserrno, "_set_doserrno");
function get_doserrno (Value : access unsigned_long)
return qmingw.errno_t;
pragma Import (C, get_doserrno, "_get_doserrno");
qsys_errlist : aliased char_ptr_array (0 .. 0);
pragma Import (C, qsys_errlist, "_sys_errlist");
qsys_nerr : aliased signed_int;
pragma Import (C, qsys_nerr, "_sys_nerr");
imp_argc : aliased signed_int_ptr;
pragma Import (C, imp_argc, "__imp___argc");
imp_argv : aliased char_ptr_ptr_ptr;
pragma Import (C, imp_argv, "__imp___argv");
imp_wargv : aliased qmingw.wchar_t_ptr_ptr_ptr;
pragma Import (C, imp_wargv, "__imp___wargv");
imp_environ : aliased char_ptr_ptr_ptr;
pragma Import (C, imp_environ, "__imp__environ");
imp_wenviron : aliased qmingw.wchar_t_ptr_ptr_ptr;
pragma Import (C, imp_wenviron, "__imp__wenviron");
imp_pgmptr : aliased char_ptr_ptr;
pragma Import (C, imp_pgmptr, "__imp__pgmptr");
imp_wpgmptr : aliased qmingw.wchar_t_ptr_ptr;
pragma Import (C, imp_wpgmptr, "__imp__wpgmptr");
function get_pgmptr (Value : access char_ptr) return qmingw.errno_t;
pragma Import (C, get_pgmptr, "_get_pgmptr");
function get_wpgmptr (Value : access qmingw.wchar_t_ptr)
return qmingw.errno_t;
pragma Import (C, get_wpgmptr, "_get_wpgmptr");
imp_fmode : aliased signed_int_ptr;
pragma Import (C, imp_fmode, "__imp__fmode");
function set_fmode (Mode : signed_int) return qmingw.errno_t;
pragma Import (C, set_fmode, "_set_fmode");
function get_fmode (PMode : access signed_int) return qmingw.errno_t;
pragma Import (C, get_fmode, "_get_fmode");
imp_osplatform : aliased unsigned_int_ptr;
pragma Import (C, imp_osplatform, "__imp__osplatform");
imp_osver : aliased unsigned_int_ptr;
pragma Import (C, imp_osver, "__imp__osver");
imp_winver : aliased unsigned_int_ptr;
pragma Import (C, imp_winver, "__imp__winver");
imp_winmajor : aliased unsigned_int_ptr;
pragma Import (C, imp_winmajor, "__imp__winmajor");
imp_winminor : aliased unsigned_int_ptr;
pragma Import (C, imp_winminor, "__imp__winminor");
function get_osplatform (Value : access unsigned_int)
return qmingw.errno_t;
pragma Import (C, get_osplatform, "_get_osplatform");
function get_osver (Value : access unsigned_int) return qmingw.errno_t;
pragma Import (C, get_osver, "_get_osver");
function get_winver (Value : access unsigned_int) return qmingw.errno_t;
pragma Import (C, get_winver, "_get_winver");
function get_winmajor (Value : access unsigned_int) return qmingw.errno_t;
pragma Import (C, get_winmajor, "_get_winmajor");
function get_winminor (Value : access unsigned_int) return qmingw.errno_t;
pragma Import (C, get_winminor, "_get_winminor");
procedure C_exit (Code : signed_int);
pragma No_Return (C_exit);
pragma Import (C, C_exit, "exit");
procedure C_qexit (Code : signed_int);
pragma No_Return (C_qexit);
pragma Import (C, C_qexit, "_exit");
procedure C_qExit2 (a1 : signed_int);
pragma No_Return (C_qExit2);
pragma Import (C, C_qExit2, "_Exit");
procedure C_abort;
pragma No_Return (C_abort);
pragma Import (C, C_abort, "abort");
function set_abort_behavior (Flags : unsigned_int; Mask : unsigned_int)
return unsigned_int;
pragma Import (C, set_abort_behavior, "_set_abort_behavior");
function C_abs (X : signed_int) return signed_int;
pragma Import (C, C_abs, "abs");
function labs (X : signed_long) return signed_long;
pragma Import (C, labs, "labs");
function qabs64 (a1 : signed_long_long) return signed_long_long;
pragma Import (C, qabs64, "_abs64");
function atexit (a1 : access_e823f645) return signed_int;
pragma Import (C, atexit, "atexit");
function atof (String : access constant char) return double;
pragma Import (C, atof, "atof");
function atof_l (String : access constant char;
Locale : access crtdefs.struct_localeinfo_struct) return double;
pragma Import (C, atof_l, "_atof_l");
function atoi (Str : access constant char) return signed_int;
pragma Import (C, atoi, "atoi");
function atoi_l (Str : access constant char;
Locale : access crtdefs.struct_localeinfo_struct) return signed_int;
pragma Import (C, atoi_l, "_atoi_l");
function atol (Str : access constant char) return signed_long;
pragma Import (C, atol, "atol");
function atol_l (Str : access constant char;
Locale : access crtdefs.struct_localeinfo_struct) return signed_long;
pragma Import (C, atol_l, "_atol_l");
type access_e6f41017 is access function (a1 : void_const_ptr;
a2 : void_const_ptr) return signed_int;
pragma Convention (C, access_e6f41017);
function bsearch (Key : void_const_ptr; Base : void_const_ptr;
NumOfElements : qmingw.size_t; SizeOfElements : qmingw.size_t;
PtFuncCompare : access_e6f41017) return void_ptr;
pragma Import (C, bsearch, "bsearch");
procedure qsort (Base : void_ptr; NumOfElements : qmingw.size_t;
SizeOfElements : qmingw.size_t; PtFuncCompare : access_e6f41017);
pragma Import (C, qsort, "qsort");
function byteswap_ushort (Short : unsigned_short) return unsigned_short;
pragma Import (C, byteswap_ushort, "_byteswap_ushort");
function byteswap_ulong (Long : unsigned_long) return unsigned_long;
pragma Import (C, byteswap_ulong, "_byteswap_ulong");
function byteswap_uint64 (Int64 : unsigned_long_long)
return unsigned_long_long;
pragma Import (C, byteswap_uint64, "_byteswap_uint64");
function div (Numerator : signed_int; Denominator : signed_int)
return div_t;
pragma Import (C, div, "div");
function getenv (VarName : access constant char) return char_ptr;
pragma Import (C, getenv, "getenv");
function qitoa (Value : signed_int; Dest : access char;
Radix : signed_int) return char_ptr;
pragma Import (C, qitoa, "_itoa");
function i64toa (Val : signed_long_long; DstBuf : access char;
Radix : signed_int) return char_ptr;
pragma Import (C, i64toa, "_i64toa");
function ui64toa (Val : unsigned_long_long; DstBuf : access char;
Radix : signed_int) return char_ptr;
pragma Import (C, ui64toa, "_ui64toa");
function atoi64 (String : access constant char) return signed_long_long;
pragma Import (C, atoi64, "_atoi64");
function atoi64_l (String : access constant char;
Locale : access crtdefs.struct_localeinfo_struct)
return signed_long_long;
pragma Import (C, atoi64_l, "_atoi64_l");
function strtoi64 (String : access constant char;
EndPtr : access char_ptr; Radix : signed_int) return signed_long_long;
pragma Import (C, strtoi64, "_strtoi64");
function strtoi64_l (String : access constant char;
EndPtr : access char_ptr; Radix : signed_int;
Locale : access crtdefs.struct_localeinfo_struct)
return signed_long_long;
pragma Import (C, strtoi64_l, "_strtoi64_l");
function strtoui64 (String : access constant char;
EndPtr : access char_ptr; Radix : signed_int)
return unsigned_long_long;
pragma Import (C, strtoui64, "_strtoui64");
function strtoui64_l (String : access constant char;
EndPtr : access char_ptr; Radix : signed_int;
Locale : access crtdefs.struct_localeinfo_struct)
return unsigned_long_long;
pragma Import (C, strtoui64_l, "_strtoui64_l");
function ldiv (Numerator : signed_long; Denominator : signed_long)
return ldiv_t;
pragma Import (C, ldiv, "ldiv");
function qltoa (Value : signed_long; Dest : access char;
Radix : signed_int) return char_ptr;
pragma Import (C, qltoa, "_ltoa");
function mblen (Ch : access constant char; MaxCount : qmingw.size_t)
return signed_int;
pragma Import (C, mblen, "mblen");
function mblen_l (Ch : access constant char; MaxCount : qmingw.size_t;
Locale : access crtdefs.struct_localeinfo_struct) return signed_int;
pragma Import (C, mblen_l, "_mblen_l");
function mbstrlen (Str : access constant char) return qmingw.size_t;
pragma Import (C, mbstrlen, "_mbstrlen");
function mbstrlen_l (Str : access constant char;
Locale : access crtdefs.struct_localeinfo_struct) return qmingw.size_t;
pragma Import (C, mbstrlen_l, "_mbstrlen_l");
function mbstrnlen (Str : access constant char; MaxCount : qmingw.size_t)
return qmingw.size_t;
pragma Import (C, mbstrnlen, "_mbstrnlen");
function mbstrnlen_l (Str : access constant char;
MaxCount : qmingw.size_t;
Locale : access crtdefs.struct_localeinfo_struct) return qmingw.size_t;
pragma Import (C, mbstrnlen_l, "_mbstrnlen_l");
function mbtowc (DstCh : access qmingw.wchar_t;
SrcCh : access constant char; SrcSizeInBytes : qmingw.size_t)
return signed_int;
pragma Import (C, mbtowc, "mbtowc");
function mbtowc_l (DstCh : access qmingw.wchar_t;
SrcCh : access constant char; SrcSizeInBytes : qmingw.size_t;
Locale : access crtdefs.struct_localeinfo_struct) return signed_int;
pragma Import (C, mbtowc_l, "_mbtowc_l");
function mbstowcs (Dest : access qmingw.wchar_t;
Source : access constant char; MaxCount : qmingw.size_t)
return qmingw.size_t;
pragma Import (C, mbstowcs, "mbstowcs");
function mbstowcs_l (Dest : access qmingw.wchar_t;
Source : access constant char; MaxCount : qmingw.size_t;
Locale : access crtdefs.struct_localeinfo_struct) return qmingw.size_t;
pragma Import (C, mbstowcs_l, "_mbstowcs_l");
function rand return signed_int;
pragma Import (C, rand, "rand");
function set_error_mode (Mode : signed_int) return signed_int;
pragma Import (C, set_error_mode, "_set_error_mode");
procedure srand (Seed : unsigned_int);
pragma Import (C, srand, "srand");
-- function strtod ... (hidden by macro)
function strtof (nptr : access constant char; endptr : access char_ptr)
return float;
pragma Import (C, strtof, "strtof");
function strtold (a1 : access constant char; a2 : access char_ptr)
return long_double;
pragma Import (C, strtold, "strtold");
function qqstrtod (a1 : access constant char; a2 : access char_ptr)
return double;
pragma Import (C, qqstrtod, "__strtod");
function mingw_strtof (a1 : access constant char; a2 : access char_ptr)
return float;
pragma Import (C, mingw_strtof, "__mingw_strtof");
function mingw_strtod (a1 : access constant char; a2 : access char_ptr)
return double;
pragma Import (C, mingw_strtod, "__mingw_strtod");
function mingw_strtold (a1 : access constant char; a2 : access char_ptr)
return long_double;
pragma Import (C, mingw_strtold, "__mingw_strtold");
function strtod_l (Str : access constant char; EndPtr : access char_ptr;
Locale : access crtdefs.struct_localeinfo_struct) return double;
pragma Import (C, strtod_l, "_strtod_l");
function strtol (Str : access constant char; EndPtr : access char_ptr;
Radix : signed_int) return signed_long;
pragma Import (C, strtol, "strtol");
function strtol_l (Str : access constant char; EndPtr : access char_ptr;
Radix : signed_int; Locale : access crtdefs.struct_localeinfo_struct)
return signed_long;
pragma Import (C, strtol_l, "_strtol_l");
function strtoul (Str : access constant char; EndPtr : access char_ptr;
Radix : signed_int) return unsigned_long;
pragma Import (C, strtoul, "strtoul");
function strtoul_l (Str : access constant char; EndPtr : access char_ptr;
Radix : signed_int; Locale : access crtdefs.struct_localeinfo_struct)
return unsigned_long;
pragma Import (C, strtoul_l, "_strtoul_l");
function C_system (Command : access constant char) return signed_int;
pragma Import (C, C_system, "system");
function qultoa (Value : unsigned_long; Dest : access char;
Radix : signed_int) return char_ptr;
pragma Import (C, qultoa, "_ultoa");
function wctomb (MbCh : access char; WCh : qmingw.wchar_t)
return signed_int;
pragma Import (C, wctomb, "wctomb");
function wctomb_l (MbCh : access char; WCh : qmingw.wchar_t;
Locale : access crtdefs.struct_localeinfo_struct) return signed_int;
pragma Import (C, wctomb_l, "_wctomb_l");
function wcstombs (Dest : access char;
Source : access constant qmingw.wchar_t; MaxCount : qmingw.size_t)
return qmingw.size_t;
pragma Import (C, wcstombs, "wcstombs");
function wcstombs_l (Dest : access char;
Source : access constant qmingw.wchar_t; MaxCount : qmingw.size_t;
Locale : access crtdefs.struct_localeinfo_struct) return qmingw.size_t;
pragma Import (C, wcstombs_l, "_wcstombs_l");
function itow (Value : signed_int; Dest : access qmingw.wchar_t;
Radix : signed_int) return qmingw.wchar_t_ptr;
pragma Import (C, itow, "_itow");
function ltow (Value : signed_long; Dest : access qmingw.wchar_t;
Radix : signed_int) return qmingw.wchar_t_ptr;
pragma Import (C, ltow, "_ltow");
function ultow (Value : unsigned_long; Dest : access qmingw.wchar_t;
Radix : signed_int) return qmingw.wchar_t_ptr;
pragma Import (C, ultow, "_ultow");
function mingw_wcstod (Str : access constant qmingw.wchar_t;
EndPtr : access qmingw.wchar_t_ptr) return double;
pragma Import (C, mingw_wcstod, "__mingw_wcstod");
function mingw_wcstof (nptr : access constant qmingw.wchar_t;
endptr : access qmingw.wchar_t_ptr) return float;
pragma Import (C, mingw_wcstof, "__mingw_wcstof");
function mingw_wcstold (a1 : access constant qmingw.wchar_t;
a2 : access qmingw.wchar_t_ptr) return long_double;
pragma Import (C, mingw_wcstold, "__mingw_wcstold");
function wcstod (Str : access constant qmingw.wchar_t;
EndPtr : access qmingw.wchar_t_ptr) return double;
pragma Import (C, wcstod, "wcstod");
function wcstof (nptr : access constant qmingw.wchar_t;
endptr : access qmingw.wchar_t_ptr) return float;
pragma Import (C, wcstof, "wcstof");
function wcstold (a1 : access constant qmingw.wchar_t;
a2 : access qmingw.wchar_t_ptr) return long_double;
pragma Import (C, wcstold, "wcstold");
function wcstod_l (Str : access constant qmingw.wchar_t;
EndPtr : access qmingw.wchar_t_ptr;
Locale : access crtdefs.struct_localeinfo_struct) return double;
pragma Import (C, wcstod_l, "_wcstod_l");
function wcstol (Str : access constant qmingw.wchar_t;
EndPtr : access qmingw.wchar_t_ptr; Radix : signed_int)
return signed_long;
pragma Import (C, wcstol, "wcstol");
function wcstol_l (Str : access constant qmingw.wchar_t;
EndPtr : access qmingw.wchar_t_ptr; Radix : signed_int;
Locale : access crtdefs.struct_localeinfo_struct) return signed_long;
pragma Import (C, wcstol_l, "_wcstol_l");
function wcstoul (Str : access constant qmingw.wchar_t;
EndPtr : access qmingw.wchar_t_ptr; Radix : signed_int)
return unsigned_long;
pragma Import (C, wcstoul, "wcstoul");
function wcstoul_l (Str : access constant qmingw.wchar_t;
EndPtr : access qmingw.wchar_t_ptr; Radix : signed_int;
Locale : access crtdefs.struct_localeinfo_struct) return unsigned_long;
pragma Import (C, wcstoul_l, "_wcstoul_l");
function wgetenv (VarName : access constant qmingw.wchar_t)
return qmingw.wchar_t_ptr;
pragma Import (C, wgetenv, "_wgetenv");
function wsystem (Command : access constant qmingw.wchar_t)
return signed_int;
pragma Import (C, wsystem, "_wsystem");
function wtof (Str : access constant qmingw.wchar_t) return double;
pragma Import (C, wtof, "_wtof");
function wtof_l (Str : access constant qmingw.wchar_t;
Locale : access crtdefs.struct_localeinfo_struct) return double;
pragma Import (C, wtof_l, "_wtof_l");
function wtoi (Str : access constant qmingw.wchar_t) return signed_int;
pragma Import (C, wtoi, "_wtoi");
function wtoi_l (Str : access constant qmingw.wchar_t;
Locale : access crtdefs.struct_localeinfo_struct) return signed_int;
pragma Import (C, wtoi_l, "_wtoi_l");
function wtol (Str : access constant qmingw.wchar_t) return signed_long;
pragma Import (C, wtol, "_wtol");
function wtol_l (Str : access constant qmingw.wchar_t;
Locale : access crtdefs.struct_localeinfo_struct) return signed_long;
pragma Import (C, wtol_l, "_wtol_l");
function i64tow (Val : signed_long_long; DstBuf : access qmingw.wchar_t;
Radix : signed_int) return qmingw.wchar_t_ptr;
pragma Import (C, i64tow, "_i64tow");
function ui64tow (Val : unsigned_long_long;
DstBuf : access qmingw.wchar_t; Radix : signed_int)
return qmingw.wchar_t_ptr;
pragma Import (C, ui64tow, "_ui64tow");
function wtoi64 (Str : access constant qmingw.wchar_t)
return signed_long_long;
pragma Import (C, wtoi64, "_wtoi64");
function wtoi64_l (Str : access constant qmingw.wchar_t;
Locale : access crtdefs.struct_localeinfo_struct)
return signed_long_long;
pragma Import (C, wtoi64_l, "_wtoi64_l");
function wcstoi64 (Str : access constant qmingw.wchar_t;
EndPtr : access qmingw.wchar_t_ptr; Radix : signed_int)
return signed_long_long;
pragma Import (C, wcstoi64, "_wcstoi64");
function wcstoi64_l (Str : access constant qmingw.wchar_t;
EndPtr : access qmingw.wchar_t_ptr; Radix : signed_int;
Locale : access crtdefs.struct_localeinfo_struct)
return signed_long_long;
pragma Import (C, wcstoi64_l, "_wcstoi64_l");
function wcstoui64 (Str : access constant qmingw.wchar_t;
EndPtr : access qmingw.wchar_t_ptr; Radix : signed_int)
return unsigned_long_long;
pragma Import (C, wcstoui64, "_wcstoui64");
function wcstoui64_l (Str : access constant qmingw.wchar_t;
EndPtr : access qmingw.wchar_t_ptr; Radix : signed_int;
Locale : access crtdefs.struct_localeinfo_struct)
return unsigned_long_long;
pragma Import (C, wcstoui64_l, "_wcstoui64_l");
function fullpath (FullPath : access char; Path : access constant char;
SizeInBytes : qmingw.size_t) return char_ptr;
pragma Import (C, fullpath, "_fullpath");
function qecvt (Val : double; NumOfDigits : signed_int;
PtDec : access signed_int; PtSign : access signed_int) return char_ptr;
pragma Import (C, qecvt, "_ecvt");
function qfcvt (Val : double; NumOfDec : signed_int;
PtDec : access signed_int; PtSign : access signed_int) return char_ptr;
pragma Import (C, qfcvt, "_fcvt");
function qgcvt (Val : double; NumOfDigits : signed_int;
DstBuf : access char) return char_ptr;
pragma Import (C, qgcvt, "_gcvt");
function atodbl (Result : access CRT_DOUBLE; Str : access char)
return signed_int;
pragma Import (C, atodbl, "_atodbl");
function atoldbl (Result : access LDOUBLE; Str : access char)
return signed_int;
pragma Import (C, atoldbl, "_atoldbl");
function atoflt (Result : access CRT_FLOAT; Str : access char)
return signed_int;
pragma Import (C, atoflt, "_atoflt");
function atodbl_l (Result : access CRT_DOUBLE; Str : access char;
Locale : access crtdefs.struct_localeinfo_struct) return signed_int;
pragma Import (C, atodbl_l, "_atodbl_l");
function atoldbl_l (Result : access LDOUBLE; Str : access char;
Locale : access crtdefs.struct_localeinfo_struct) return signed_int;
pragma Import (C, atoldbl_l, "_atoldbl_l");
function atoflt_l (Result : access CRT_FLOAT; Str : access char;
Locale : access crtdefs.struct_localeinfo_struct) return signed_int;
pragma Import (C, atoflt_l, "_atoflt_l");
function lrotl (Val : unsigned_long_long; Shift : signed_int)
return unsigned_long_long;
pragma Import (C, lrotl, "_lrotl");
function lrotr (Val : unsigned_long_long; Shift : signed_int)
return unsigned_long_long;
pragma Import (C, lrotr, "_lrotr");
procedure makepath (Path : access char; Drive : access constant char;
Dir : access constant char; Filename : access constant char;
Ext : access constant char);
pragma Import (C, makepath, "_makepath");
function qonexit (Func : qonexit_t) return qonexit_t;
pragma Import (C, qonexit, "_onexit");
procedure perror (ErrMsg : access constant char);
pragma Import (C, perror, "perror");
function qputenv (EnvString : access constant char) return signed_int;
pragma Import (C, qputenv, "_putenv");
procedure searchenv (Filename : access constant char;
EnvVar : access constant char; ResultPath : access char);
pragma Import (C, searchenv, "_searchenv");
procedure splitpath (FullPath : access constant char; Drive : access char;
Dir : access char; Filename : access char; Ext : access char);
pragma Import (C, splitpath, "_splitpath");
procedure qswab (Buf1 : access char; Buf2 : access char;
SizeInBytes : signed_int);
pragma Import (C, qswab, "_swab");
function wfullpath (FullPath : access qmingw.wchar_t;
Path : access constant qmingw.wchar_t; SizeInWords : qmingw.size_t)
return qmingw.wchar_t_ptr;
pragma Import (C, wfullpath, "_wfullpath");
procedure wmakepath (ResultPath : access qmingw.wchar_t;
Drive : access constant qmingw.wchar_t;
Dir : access constant qmingw.wchar_t;
Filename : access constant qmingw.wchar_t;
Ext : access constant qmingw.wchar_t);
pragma Import (C, wmakepath, "_wmakepath");
procedure wperror (ErrMsg : access constant qmingw.wchar_t);
pragma Import (C, wperror, "_wperror");
function wputenv (EnvString : access constant qmingw.wchar_t)
return signed_int;
pragma Import (C, wputenv, "_wputenv");
procedure wsearchenv (Filename : access constant qmingw.wchar_t;
EnvVar : access constant qmingw.wchar_t;
ResultPath : access qmingw.wchar_t);
pragma Import (C, wsearchenv, "_wsearchenv");
procedure wsplitpath (FullPath : access constant qmingw.wchar_t;
Drive : access qmingw.wchar_t; Dir : access qmingw.wchar_t;
Filename : access qmingw.wchar_t; Ext : access qmingw.wchar_t);
pragma Import (C, wsplitpath, "_wsplitpath");
procedure beep (Frequency : unsigned_int; Duration : unsigned_int);
pragma Import (C, beep, "_beep");
procedure seterrormode (Mode : signed_int);
pragma Import (C, seterrormode, "_seterrormode");
procedure sleep (Duration : unsigned_long);
pragma Import (C, sleep, "_sleep");
function ecvt (Val : double; NumOfDigits : signed_int;
PtDec : access signed_int; PtSign : access signed_int) return char_ptr;
pragma Import (C, ecvt, "ecvt");
function fcvt (Val : double; NumOfDec : signed_int;
PtDec : access signed_int; PtSign : access signed_int) return char_ptr;
pragma Import (C, fcvt, "fcvt");
function gcvt (Val : double; NumOfDigits : signed_int;
DstBuf : access char) return char_ptr;
pragma Import (C, gcvt, "gcvt");
function itoa (Val : signed_int; DstBuf : access char; Radix : signed_int)
return char_ptr;
pragma Import (C, itoa, "itoa");
function ltoa (Val : signed_long; DstBuf : access char;
Radix : signed_int) return char_ptr;
pragma Import (C, ltoa, "ltoa");
function putenv (EnvString : access constant char) return signed_int;
pragma Import (C, putenv, "putenv");
procedure swab (Buf1 : access char; Buf2 : access char;
SizeInBytes : signed_int);
pragma Import (C, swab, "swab");
function ultoa (Val : unsigned_long; Dstbuf : access char;
Radix : signed_int) return char_ptr;
pragma Import (C, ultoa, "ultoa");
function onexit (Func : qonexit_t) return qonexit_t;
pragma Import (C, onexit, "onexit");
type struct_bb99b450 is record
quot : aliased signed_long_long;
F_rem : aliased signed_long_long;
end record;
pragma Convention (C_Pass_By_Copy, struct_bb99b450);
subtype lldiv_t is struct_bb99b450;
function lldiv (a1 : signed_long_long; a2 : signed_long_long)
return lldiv_t;
pragma Import (C, lldiv, "lldiv");
function llabs (a1 : signed_long_long) return signed_long_long;
pragma Import (C, llabs, "llabs");
function strtoll (a1 : access constant char; a2 : access char_ptr;
a3 : signed_int) return signed_long_long;
pragma Import (C, strtoll, "strtoll");
function strtoull (a1 : access constant char; a2 : access char_ptr;
a3 : signed_int) return unsigned_long_long;
pragma Import (C, strtoull, "strtoull");
function atoll (a1 : access constant char) return signed_long_long;
pragma Import (C, atoll, "atoll");
function wtoll (a1 : access constant qmingw.wchar_t)
return signed_long_long;
pragma Import (C, wtoll, "wtoll");
function lltoa (a1 : signed_long_long; a2 : access char; a3 : signed_int)
return char_ptr;
pragma Import (C, lltoa, "lltoa");
function ulltoa (a1 : unsigned_long_long; a2 : access char;
a3 : signed_int) return char_ptr;
pragma Import (C, ulltoa, "ulltoa");
function lltow (a1 : signed_long_long; a2 : access qmingw.wchar_t;
a3 : signed_int) return qmingw.wchar_t_ptr;
pragma Import (C, lltow, "lltow");
function ulltow (a1 : unsigned_long_long; a2 : access qmingw.wchar_t;
a3 : signed_int) return qmingw.wchar_t_ptr;
pragma Import (C, ulltow, "ulltow");
EXIT_FAILURE : constant := 1;
EXIT_SUCCESS : constant := 0;
RAND_MAX : constant := 32767;
CALL_REPORTFAULT : constant := 2;
-- _CRT_ABS_DEFINED (empty)
-- _CRT_ALGO_DEFINED (empty)
-- _CRT_ATOF_DEFINED (empty)
-- _CRT_DOUBLE_DEC (empty)
-- _CRT_PERROR_DEFINED (empty)
-- _CRT_SWAB_DEFINED (empty)
-- _CRT_SYSTEM_DEFINED (empty)
-- _CRT_TERMINATE_DEFINED (empty)
-- _CRT_WPERROR_DEFINED (empty)
-- _CRT_WSYSTEM_DEFINED (empty)
CVTBUFSIZE : constant := 349;
-- _DIV_T_DEFINED (empty)
-- _INC_STDLIB (empty)
MAX_DIR : constant := 256;
MAX_DRIVE : constant := 3;
MAX_ENV : constant := 32767;
MAX_EXT : constant := 256;
MAX_FNAME : constant := 256;
MAX_PATH : constant := 260;
-- _ONEXIT_T_DEFINED (empty)
OUT_TO_DEFAULT : constant := 0;
OUT_TO_MSGBOX : constant := 2;
OUT_TO_STDERR : constant := 1;
-- _PTR_LD (uninterpretable)
REPORT_ERRMODE : constant := 3;
WRITE_ABORT_MSG : constant := 1;
-- _WSTDLIBP_DEFINED (empty)
-- _WSTDLIB_DEFINED (empty)
function argc return signed_int;
pragma Inline_Always (argc);
function argv return char_ptr_ptr;
pragma Inline_Always (argv);
-- __max (function macro)
-- __min (function macro)
function wargv return qmingw.wchar_t_ptr_ptr;
pragma Inline_Always (wargv);
-- _countof (function macro)
function qdoserrno return unsigned_long;
pragma Inline_Always (qdoserrno);
function qenviron return char_ptr_ptr;
pragma Inline_Always (qenviron);
function fmode return signed_int;
pragma Inline_Always (fmode);
function osplatform return unsigned_int;
pragma Inline_Always (osplatform);
function osver return unsigned_int;
pragma Inline_Always (osver);
function pgmptr return char_ptr;
pragma Inline_Always (pgmptr);
function wenviron return qmingw.wchar_t_ptr_ptr;
pragma Inline_Always (wenviron);
function winmajor return unsigned_int;
pragma Inline_Always (winmajor);
function winminor return unsigned_int;
pragma Inline_Always (winminor);
function winver return unsigned_int;
pragma Inline_Always (winver);
function wpgmptr return qmingw.wchar_t_ptr;
pragma Inline_Always (wpgmptr);
function environ return char_ptr_ptr;
pragma Inline_Always (environ);
subtype onexit_t is qonexit_t;
function strtod (a1 : access constant char; a2 : access char_ptr)
return double renames qqstrtod;
sys_errlist : char_ptr_array renames qsys_errlist;
sys_nerr : signed_int renames qsys_nerr;
end C.stdlib;
Raw
c-stralign.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
with C.qmingw;
with C.winnt;
package C.stralign is
pragma Preelaborate;
function uaw_CharUpperW (String : access winnt.WCHAR)
return winnt.LPUWSTR;
pragma Import (C, uaw_CharUpperW, "uaw_CharUpperW");
function uaw_lstrcmpW (String1 : access constant winnt.WCHAR;
String2 : access constant winnt.WCHAR) return signed_int;
pragma Import (C, uaw_lstrcmpW, "uaw_lstrcmpW");
function uaw_lstrcmpiW (String1 : access constant winnt.WCHAR;
String2 : access constant winnt.WCHAR) return signed_int;
pragma Import (C, uaw_lstrcmpiW, "uaw_lstrcmpiW");
function uaw_lstrlenW (String : access constant winnt.WCHAR)
return signed_int;
pragma Import (C, uaw_lstrlenW, "uaw_lstrlenW");
function uaw_wcschr (String : access constant winnt.WCHAR;
Character : winnt.WCHAR) return winnt.PUWSTR;
pragma Import (C, uaw_wcschr, "uaw_wcschr");
function uaw_wcscpy (Destination : access winnt.WCHAR;
Source : access constant winnt.WCHAR) return winnt.PUWSTR;
pragma Import (C, uaw_wcscpy, "uaw_wcscpy");
function uaw_wcsicmp (String1 : access constant winnt.WCHAR;
String2 : access constant winnt.WCHAR) return signed_int;
pragma Import (C, uaw_wcsicmp, "uaw_wcsicmp");
function uaw_wcslen (String : access constant winnt.WCHAR)
return qmingw.size_t;
pragma Import (C, uaw_wcslen, "uaw_wcslen");
function uaw_wcsrchr (String : access constant winnt.WCHAR;
Character : winnt.WCHAR) return winnt.PUWSTR;
pragma Import (C, uaw_wcsrchr, "uaw_wcsrchr");
function ua_CharUpperW (String : access winnt.WCHAR) return winnt.LPUWSTR;
pragma Import (C, ua_CharUpperW, "ua_CharUpperW");
function ua_lstrcmpW (String1 : access constant winnt.WCHAR;
String2 : access constant winnt.WCHAR) return signed_int;
pragma Import (C, ua_lstrcmpW, "ua_lstrcmpW");
function ua_lstrcmpiW (String1 : access constant winnt.WCHAR;
String2 : access constant winnt.WCHAR) return signed_int;
pragma Import (C, ua_lstrcmpiW, "ua_lstrcmpiW");
function ua_lstrlenW (String : access constant winnt.WCHAR)
return signed_int;
pragma Import (C, ua_lstrlenW, "ua_lstrlenW");
subtype PUWSTR_C is winnt.WCHAR_ptr;
function ua_wcschr (String : access constant winnt.WCHAR;
Character : winnt.WCHAR) return PUWSTR_C;
pragma Import (C, ua_wcschr, "ua_wcschr");
function ua_wcsrchr (String : access constant winnt.WCHAR;
Character : winnt.WCHAR) return PUWSTR_C;
pragma Import (C, ua_wcsrchr, "ua_wcsrchr");
function ua_wcscpy (Destination : access winnt.WCHAR;
Source : access constant winnt.WCHAR) return winnt.PUWSTR;
pragma Import (C, ua_wcscpy, "ua_wcscpy");
function ua_wcslen (String : access constant winnt.WCHAR)
return qmingw.size_t;
pragma Import (C, ua_wcslen, "ua_wcslen");
function ua_wcsicmp (String1 : access constant winnt.WCHAR;
String2 : access constant winnt.WCHAR) return signed_int;
pragma Import (C, ua_wcsicmp, "ua_wcsicmp");
-- ASTR_ALIGNED_STACK_COPY (function macro)
-- STRUC_ALIGNED_STACK_COPY (function macro)
-- TSTR_ALIGNED (function macro)
-- TSTR_ALIGNED_STACK_COPY (function macro)
-- WSTR_ALIGNED (function macro)
-- WSTR_ALIGNED_STACK_COPY (function macro)
STRALIGN_USE_SECURE_CRT : constant := 0;
-- __STRALIGN_H_ (empty)
-- __UA_STACKCOPY (unparsible)
function qqUA_WCSLEN (String : access constant winnt.WCHAR)
return qmingw.size_t renames ua_wcslen;
-- __UA_WSTRSIZE (function macro)
function ua_CharUpper (String : access winnt.WCHAR) return winnt.LPUWSTR
renames ua_CharUpperW;
function ua_lstrcmp (String1 : access constant winnt.WCHAR;
String2 : access constant winnt.WCHAR) return signed_int
renames ua_lstrcmpW;
function ua_lstrcmpi (String1 : access constant winnt.WCHAR;
String2 : access constant winnt.WCHAR) return signed_int
renames ua_lstrcmpiW;
function ua_lstrlen (String : access constant winnt.WCHAR)
return signed_int renames ua_lstrlenW;
function ua_tcscpy (Destination : access winnt.WCHAR;
Source : access constant winnt.WCHAR) return winnt.PUWSTR
renames ua_wcscpy;
end C.stralign;
Raw
c-string.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
with C.crtdefs;
with C.qmingw;
package C.string is
pragma Preelaborate;
function qmemccpy (Dst : void_ptr; Src : void_const_ptr; Val : signed_int;
MaxCount : qmingw.size_t) return void_ptr;
pragma Import (C, qmemccpy, "_memccpy");
function memchr (Buf : void_const_ptr; Val : signed_int;
MaxCount : qmingw.size_t) return void_ptr;
pragma Import (C, memchr, "memchr");
function qmemicmp (Buf1 : void_const_ptr; Buf2 : void_const_ptr;
Size : qmingw.size_t) return signed_int;
pragma Import (C, qmemicmp, "_memicmp");
function memicmp_l (Buf1 : void_const_ptr; Buf2 : void_const_ptr;
Size : qmingw.size_t; Locale : access crtdefs.struct_localeinfo_struct)
return signed_int;
pragma Import (C, memicmp_l, "_memicmp_l");
function memcmp (Buf1 : void_const_ptr; Buf2 : void_const_ptr;
Size : qmingw.size_t) return signed_int;
pragma Import (C, memcmp, "memcmp");
function memcpy (Dst : void_ptr; Src : void_const_ptr;
Size : qmingw.size_t) return void_ptr;
pragma Import (C, memcpy, "memcpy");
function mempcpy (Dst : void_ptr; Src : void_const_ptr;
Size : qmingw.size_t) return void_ptr;
pragma Import (C, mempcpy, "mempcpy");
function memset (Dst : void_ptr; Val : signed_int; Size : qmingw.size_t)
return void_ptr;
pragma Import (C, memset, "memset");
function memccpy (Dst : void_ptr; Src : void_const_ptr; Val : signed_int;
Size : qmingw.size_t) return void_ptr;
pragma Import (C, memccpy, "memccpy");
function memicmp (Buf1 : void_const_ptr; Buf2 : void_const_ptr;
Size : qmingw.size_t) return signed_int;
pragma Import (C, memicmp, "memicmp");
function qstrset (Str : access char; Val : signed_int) return char_ptr;
pragma Import (C, qstrset, "_strset");
function strset_l (Str : access char; Val : signed_int;
Locale : access crtdefs.struct_localeinfo_struct) return char_ptr;
pragma Import (C, strset_l, "_strset_l");
function strcpy (Dest : access char; Source : access constant char)
return char_ptr;
pragma Import (C, strcpy, "strcpy");
function strcat (Dest : access char; Source : access constant char)
return char_ptr;
pragma Import (C, strcat, "strcat");
function strcmp (Str1 : access constant char; Str2 : access constant char)
return signed_int;
pragma Import (C, strcmp, "strcmp");
function strlen (Str : access constant char) return qmingw.size_t;
pragma Import (C, strlen, "strlen");
function strnlen (Str : access constant char; MaxCount : qmingw.size_t)
return qmingw.size_t;
pragma Import (C, strnlen, "strnlen");
function memmove (Dst : void_ptr; Src : void_const_ptr;
Size : qmingw.size_t) return void_ptr;
pragma Import (C, memmove, "memmove");
function qstrdup (Src : access constant char) return char_ptr;
pragma Import (C, qstrdup, "_strdup");
function strchr (Str : access constant char; Val : signed_int)
return char_ptr;
pragma Import (C, strchr, "strchr");
function qstricmp (Str1 : access constant char;
Str2 : access constant char) return signed_int;
pragma Import (C, qstricmp, "_stricmp");
function qstrcmpi (Str1 : access constant char;
Str2 : access constant char) return signed_int;
pragma Import (C, qstrcmpi, "_strcmpi");
function stricmp_l (Str1 : access constant char;
Str2 : access constant char;
Locale : access crtdefs.struct_localeinfo_struct) return signed_int;
pragma Import (C, stricmp_l, "_stricmp_l");
function strcoll (Str1 : access constant char;
Str2 : access constant char) return signed_int;
pragma Import (C, strcoll, "strcoll");
function strcoll_l (Str1 : access constant char;
Str2 : access constant char;
Locale : access crtdefs.struct_localeinfo_struct) return signed_int;
pragma Import (C, strcoll_l, "_strcoll_l");
function stricoll (Str1 : access constant char;
Str2 : access constant char) return signed_int;
pragma Import (C, stricoll, "_stricoll");
function stricoll_l (Str1 : access constant char;
Str2 : access constant char;
Locale : access crtdefs.struct_localeinfo_struct) return signed_int;
pragma Import (C, stricoll_l, "_stricoll_l");
function strncoll (Str1 : access constant char;
Str2 : access constant char; MaxCount : qmingw.size_t)
return signed_int;
pragma Import (C, strncoll, "_strncoll");
function strncoll_l (Str1 : access constant char;
Str2 : access constant char; MaxCount : qmingw.size_t;
Locale : access crtdefs.struct_localeinfo_struct) return signed_int;
pragma Import (C, strncoll_l, "_strncoll_l");
function strnicoll (Str1 : access constant char;
Str2 : access constant char; MaxCount : qmingw.size_t)
return signed_int;
pragma Import (C, strnicoll, "_strnicoll");
function strnicoll_l (Str1 : access constant char;
Str2 : access constant char; MaxCount : qmingw.size_t;
Locale : access crtdefs.struct_localeinfo_struct) return signed_int;
pragma Import (C, strnicoll_l, "_strnicoll_l");
function strcspn (Str : access constant char;
Control : access constant char) return qmingw.size_t;
pragma Import (C, strcspn, "strcspn");
function qstrerror (ErrMsg : access constant char) return char_ptr;
pragma Import (C, qstrerror, "_strerror");
function strerror (a1 : signed_int) return char_ptr;
pragma Import (C, strerror, "strerror");
function qstrlwr (String : access char) return char_ptr;
pragma Import (C, qstrlwr, "_strlwr");
function strlwr_l (String : access char;
Locale : access crtdefs.struct_localeinfo_struct) return char_ptr;
pragma Import (C, strlwr_l, "strlwr_l");
function strncat (Dest : access char; Source : access constant char;
Count : qmingw.size_t) return char_ptr;
pragma Import (C, strncat, "strncat");
function strncmp (Str1 : access constant char;
Str2 : access constant char; MaxCount : qmingw.size_t)
return signed_int;
pragma Import (C, strncmp, "strncmp");
function qstrnicmp (Str1 : access constant char;
Str2 : access constant char; MaxCount : qmingw.size_t)
return signed_int;
pragma Import (C, qstrnicmp, "_strnicmp");
function strnicmp_l (Str1 : access constant char;
Str2 : access constant char; MaxCount : qmingw.size_t;
Locale : access crtdefs.struct_localeinfo_struct) return signed_int;
pragma Import (C, strnicmp_l, "_strnicmp_l");
function strncpy (Dest : access char; Source : access constant char;
Count : qmingw.size_t) return char_ptr;
pragma Import (C, strncpy, "strncpy");
function qstrnset (Str : access char; Val : signed_int;
MaxCount : qmingw.size_t) return char_ptr;
pragma Import (C, qstrnset, "_strnset");
function strnset_l (str : access char; c : signed_int;
count : qmingw.size_t;
Locale : access crtdefs.struct_localeinfo_struct) return char_ptr;
pragma Import (C, strnset_l, "_strnset_l");
function strpbrk (Str : access constant char;
Control : access constant char) return char_ptr;
pragma Import (C, strpbrk, "strpbrk");
function strrchr (Str : access constant char; Ch : signed_int)
return char_ptr;
pragma Import (C, strrchr, "strrchr");
function qstrrev (Str : access char) return char_ptr;
pragma Import (C, qstrrev, "_strrev");
function strspn (Str : access constant char;
Control : access constant char) return qmingw.size_t;
pragma Import (C, strspn, "strspn");
function strstr (Str : access constant char;
SubStr : access constant char) return char_ptr;
pragma Import (C, strstr, "strstr");
function strtok (Str : access char; Delim : access constant char)
return char_ptr;
pragma Import (C, strtok, "strtok");
function qstrupr (String : access char) return char_ptr;
pragma Import (C, qstrupr, "_strupr");
function strupr_l (String : access char;
Locale : access crtdefs.struct_localeinfo_struct) return char_ptr;
pragma Import (C, strupr_l, "_strupr_l");
function strxfrm (Dst : access char; Src : access constant char;
MaxCount : qmingw.size_t) return qmingw.size_t;
pragma Import (C, strxfrm, "strxfrm");
function strxfrm_l (Dst : access char; Src : access constant char;
MaxCount : qmingw.size_t;
Locale : access crtdefs.struct_localeinfo_struct) return qmingw.size_t;
pragma Import (C, strxfrm_l, "_strxfrm_l");
function strdup (Src : access constant char) return char_ptr;
pragma Import (C, strdup, "strdup");
function strcmpi (Str1 : access constant char;
Str2 : access constant char) return signed_int;
pragma Import (C, strcmpi, "strcmpi");
function stricmp (Str1 : access constant char;
Str2 : access constant char) return signed_int;
pragma Import (C, stricmp, "stricmp");
function strlwr (Str : access char) return char_ptr;
pragma Import (C, strlwr, "strlwr");
function strnicmp (Str1 : access constant char;
Str : access constant char; MaxCount : qmingw.size_t)
return signed_int;
pragma Import (C, strnicmp, "strnicmp");
-- function strncasecmp ... (hidden by macro)
-- function strcasecmp ... (hidden by macro)
function strnset (Str : access char; Val : signed_int;
MaxCount : qmingw.size_t) return char_ptr;
pragma Import (C, strnset, "strnset");
function strrev (Str : access char) return char_ptr;
pragma Import (C, strrev, "strrev");
function strset (Str : access char; Val : signed_int) return char_ptr;
pragma Import (C, strset, "strset");
function strupr (Str : access char) return char_ptr;
pragma Import (C, strupr, "strupr");
function qwcsdup (Str : access constant qmingw.wchar_t)
return qmingw.wchar_t_ptr;
pragma Import (C, qwcsdup, "_wcsdup");
function wcscat (Dest : access qmingw.wchar_t;
Source : access constant qmingw.wchar_t) return qmingw.wchar_t_ptr;
pragma Import (C, wcscat, "wcscat");
function wcschr (Str : access constant qmingw.wchar_t;
Ch : qmingw.wchar_t) return qmingw.wchar_t_ptr;
pragma Import (C, wcschr, "wcschr");
function wcscmp (Str1 : access constant qmingw.wchar_t;
Str2 : access constant qmingw.wchar_t) return signed_int;
pragma Import (C, wcscmp, "wcscmp");
function wcscpy (Dest : access qmingw.wchar_t;
Source : access constant qmingw.wchar_t) return qmingw.wchar_t_ptr;
pragma Import (C, wcscpy, "wcscpy");
function wcscspn (Str : access constant qmingw.wchar_t;
Control : access constant qmingw.wchar_t) return qmingw.size_t;
pragma Import (C, wcscspn, "wcscspn");
function wcslen (Str : access constant qmingw.wchar_t)
return qmingw.size_t;
pragma Import (C, wcslen, "wcslen");
function wcsnlen (Src : access constant qmingw.wchar_t;
MaxCount : qmingw.size_t) return qmingw.size_t;
pragma Import (C, wcsnlen, "wcsnlen");
function wcsncat (Dest : access qmingw.wchar_t;
Source : access constant qmingw.wchar_t; Count : qmingw.size_t)
return qmingw.wchar_t_ptr;
pragma Import (C, wcsncat, "wcsncat");
function wcsncmp (Str1 : access constant qmingw.wchar_t;
Str2 : access constant qmingw.wchar_t; MaxCount : qmingw.size_t)
return signed_int;
pragma Import (C, wcsncmp, "wcsncmp");
function wcsncpy (Dest : access qmingw.wchar_t;
Source : access constant qmingw.wchar_t; Count : qmingw.size_t)
return qmingw.wchar_t_ptr;
pragma Import (C, wcsncpy, "wcsncpy");
function wcsncpy_l (Dest : access qmingw.wchar_t;
Source : access constant qmingw.wchar_t; Count : qmingw.size_t;
Locale : access crtdefs.struct_localeinfo_struct)
return qmingw.wchar_t_ptr;
pragma Import (C, wcsncpy_l, "_wcsncpy_l");
function wcspbrk (Str : access constant qmingw.wchar_t;
Control : access constant qmingw.wchar_t) return qmingw.wchar_t_ptr;
pragma Import (C, wcspbrk, "wcspbrk");
function wcsrchr (Str : access constant qmingw.wchar_t;
Ch : qmingw.wchar_t) return qmingw.wchar_t_ptr;
pragma Import (C, wcsrchr, "wcsrchr");
function wcsspn (Str : access constant qmingw.wchar_t;
Control : access constant qmingw.wchar_t) return qmingw.size_t;
pragma Import (C, wcsspn, "wcsspn");
function wcsstr (Str : access constant qmingw.wchar_t;
SubStr : access constant qmingw.wchar_t) return qmingw.wchar_t_ptr;
pragma Import (C, wcsstr, "wcsstr");
function wcstok (Str : access qmingw.wchar_t;
Delim : access constant qmingw.wchar_t) return qmingw.wchar_t_ptr;
pragma Import (C, wcstok, "wcstok");
function qwcserror (ErrNum : signed_int) return qmingw.wchar_t_ptr;
pragma Import (C, qwcserror, "_wcserror");
function qqwcserror (Str : access constant qmingw.wchar_t)
return qmingw.wchar_t_ptr;
pragma Import (C, qqwcserror, "__wcserror");
function qwcsicmp (Str1 : access constant qmingw.wchar_t;
Str2 : access constant qmingw.wchar_t) return signed_int;
pragma Import (C, qwcsicmp, "_wcsicmp");
function wcsicmp_l (Str1 : access constant qmingw.wchar_t;
Str2 : access constant qmingw.wchar_t;
Locale : access crtdefs.struct_localeinfo_struct) return signed_int;
pragma Import (C, wcsicmp_l, "_wcsicmp_l");
function qwcsnicmp (Str1 : access constant qmingw.wchar_t;
Str2 : access constant qmingw.wchar_t; MaxCount : qmingw.size_t)
return signed_int;
pragma Import (C, qwcsnicmp, "_wcsnicmp");
function wcsnicmp_l (Str1 : access constant qmingw.wchar_t;
Str2 : access constant qmingw.wchar_t; MaxCount : qmingw.size_t;
Locale : access crtdefs.struct_localeinfo_struct) return signed_int;
pragma Import (C, wcsnicmp_l, "_wcsnicmp_l");
function qwcsnset (Str : access qmingw.wchar_t; Val : qmingw.wchar_t;
MaxCount : qmingw.size_t) return qmingw.wchar_t_ptr;
pragma Import (C, qwcsnset, "_wcsnset");
function qwcsrev (Str : access qmingw.wchar_t) return qmingw.wchar_t_ptr;
pragma Import (C, qwcsrev, "_wcsrev");
function qwcsset (Str : access qmingw.wchar_t; Val : qmingw.wchar_t)
return qmingw.wchar_t_ptr;
pragma Import (C, qwcsset, "_wcsset");
function qwcslwr (String : access qmingw.wchar_t)
return qmingw.wchar_t_ptr;
pragma Import (C, qwcslwr, "_wcslwr");
function wcslwr_l (String : access qmingw.wchar_t;
Locale : access crtdefs.struct_localeinfo_struct)
return qmingw.wchar_t_ptr;
pragma Import (C, wcslwr_l, "_wcslwr_l");
function qwcsupr (String : access qmingw.wchar_t)
return qmingw.wchar_t_ptr;
pragma Import (C, qwcsupr, "_wcsupr");
function wcsupr_l (String : access qmingw.wchar_t;
Locale : access crtdefs.struct_localeinfo_struct)
return qmingw.wchar_t_ptr;
pragma Import (C, wcsupr_l, "_wcsupr_l");
function wcsxfrm (Dst : access qmingw.wchar_t;
Src : access constant qmingw.wchar_t; MaxCount : qmingw.size_t)
return qmingw.size_t;
pragma Import (C, wcsxfrm, "wcsxfrm");
function wcsxfrm_l (Dst : access qmingw.wchar_t;
Src : access constant qmingw.wchar_t; MaxCount : qmingw.size_t;
Locale : access crtdefs.struct_localeinfo_struct) return qmingw.size_t;
pragma Import (C, wcsxfrm_l, "_wcsxfrm_l");
function wcscoll (Str1 : access constant qmingw.wchar_t;
Str2 : access constant qmingw.wchar_t) return signed_int;
pragma Import (C, wcscoll, "wcscoll");
function wcscoll_l (Str1 : access constant qmingw.wchar_t;
Str2 : access constant qmingw.wchar_t;
Locale : access crtdefs.struct_localeinfo_struct) return signed_int;
pragma Import (C, wcscoll_l, "_wcscoll_l");
function qwcsicoll (Str1 : access constant qmingw.wchar_t;
Str2 : access constant qmingw.wchar_t) return signed_int;
pragma Import (C, qwcsicoll, "_wcsicoll");
function wcsicoll_l (Str1 : access constant qmingw.wchar_t;
Str2 : access constant qmingw.wchar_t;
Locale : access crtdefs.struct_localeinfo_struct) return signed_int;
pragma Import (C, wcsicoll_l, "_wcsicoll_l");
function wcsncoll (Str1 : access constant qmingw.wchar_t;
Str2 : access constant qmingw.wchar_t; MaxCount : qmingw.size_t)
return signed_int;
pragma Import (C, wcsncoll, "_wcsncoll");
function wcsncoll_l (Str1 : access constant qmingw.wchar_t;
Str2 : access constant qmingw.wchar_t; MaxCount : qmingw.size_t;
Locale : access crtdefs.struct_localeinfo_struct) return signed_int;
pragma Import (C, wcsncoll_l, "_wcsncoll_l");
function wcsnicoll (Str1 : access constant qmingw.wchar_t;
Str2 : access constant qmingw.wchar_t; MaxCount : qmingw.size_t)
return signed_int;
pragma Import (C, wcsnicoll, "_wcsnicoll");
function wcsnicoll_l (Str1 : access constant qmingw.wchar_t;
Str2 : access constant qmingw.wchar_t; MaxCount : qmingw.size_t;
Locale : access crtdefs.struct_localeinfo_struct) return signed_int;
pragma Import (C, wcsnicoll_l, "_wcsnicoll_l");
function wcsdup (Str : access constant qmingw.wchar_t)
return qmingw.wchar_t_ptr;
pragma Import (C, wcsdup, "wcsdup");
function wcsicmp (Str1 : access constant qmingw.wchar_t;
Str2 : access constant qmingw.wchar_t) return signed_int;
pragma Import (C, wcsicmp, "wcsicmp");
function wcsnicmp (Str1 : access constant qmingw.wchar_t;
Str2 : access constant qmingw.wchar_t; MaxCount : qmingw.size_t)
return signed_int;
pragma Import (C, wcsnicmp, "wcsnicmp");
function wcsnset (Str : access qmingw.wchar_t; Val : qmingw.wchar_t;
MaxCount : qmingw.size_t) return qmingw.wchar_t_ptr;
pragma Import (C, wcsnset, "wcsnset");
function wcsrev (Str : access qmingw.wchar_t) return qmingw.wchar_t_ptr;
pragma Import (C, wcsrev, "wcsrev");
function wcsset (Str : access qmingw.wchar_t; Val : qmingw.wchar_t)
return qmingw.wchar_t_ptr;
pragma Import (C, wcsset, "wcsset");
function wcslwr (Str : access qmingw.wchar_t) return qmingw.wchar_t_ptr;
pragma Import (C, wcslwr, "wcslwr");
function wcsupr (Str : access qmingw.wchar_t) return qmingw.wchar_t_ptr;
pragma Import (C, wcsupr, "wcsupr");
function wcsicoll (Str1 : access constant qmingw.wchar_t;
Str2 : access constant qmingw.wchar_t) return signed_int;
pragma Import (C, wcsicoll, "wcsicoll");
-- _CRT_MEMORY_DEFINED (empty)
-- _INC_STRING (empty)
NLSCMPERROR : constant := 2147483647;
-- _NLSCMP_DEFINED (empty)
-- _WConst_return (empty)
-- _WSTRING_DEFINED (empty)
function strcasecmp (Str1 : access constant char;
Str2 : access constant char) return signed_int renames qstricmp;
function strncasecmp (Str1 : access constant char;
Str2 : access constant char; MaxCount : qmingw.size_t)
return signed_int renames qstrnicmp;
function wcswcs (Str : access constant qmingw.wchar_t;
SubStr : access constant qmingw.wchar_t) return qmingw.wchar_t_ptr
renames wcsstr;
end C.string;
Raw
c-tvout.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
with C.guiddef;
with C.windef;
package C.tvout is
pragma Preelaborate;
type struct_VIDEOPARAMETERS;
type struct_VIDEOPARAMETERS is record
Guid : aliased guiddef.GUID;
dwOffset : aliased windef.ULONG;
dwCommand : aliased windef.ULONG;
dwFlags : aliased windef.ULONG;
dwMode : aliased windef.ULONG;
dwTVStandard : aliased windef.ULONG;
dwAvailableModes : aliased windef.ULONG;
dwAvailableTVStandard : aliased windef.ULONG;
dwFlickerFilter : aliased windef.ULONG;
dwOverScanX : aliased windef.ULONG;
dwOverScanY : aliased windef.ULONG;
dwMaxUnscaledX : aliased windef.ULONG;
dwMaxUnscaledY : aliased windef.ULONG;
dwPositionX : aliased windef.ULONG;
dwPositionY : aliased windef.ULONG;
dwBrightness : aliased windef.ULONG;
dwContrast : aliased windef.ULONG;
dwCPType : aliased windef.ULONG;
dwCPCommand : aliased windef.ULONG;
dwCPStandard : aliased windef.ULONG;
dwCPKey : aliased windef.ULONG;
bCP_APSTriggerBits : aliased windef.ULONG;
bOEMCopyProtection : aliased windef.UCHAR_array (0 .. 255);
end record;
pragma Convention (C_Pass_By_Copy, struct_VIDEOPARAMETERS);
type struct_VIDEOPARAMETERS_ptr is access all struct_VIDEOPARAMETERS;
for struct_VIDEOPARAMETERS_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_VIDEOPARAMETERS_ptr);
pragma Convention (C, struct_VIDEOPARAMETERS_ptr);
subtype VIDEOPARAMETERS is struct_VIDEOPARAMETERS;
subtype PVIDEOPARAMETERS is struct_VIDEOPARAMETERS_ptr;
subtype LPVIDEOPARAMETERS is struct_VIDEOPARAMETERS_ptr;
VP_COMMAND_GET : constant := 1;
VP_COMMAND_SET : constant := 2;
VP_CP_CMD_ACTIVATE : constant := 1;
VP_CP_CMD_CHANGE : constant := 4;
VP_CP_CMD_DEACTIVATE : constant := 2;
VP_CP_TYPE_APS_TRIGGER : constant := 1;
VP_CP_TYPE_MACROVISION : constant := 2;
VP_FLAGS_BRIGHTNESS : constant := 64;
VP_FLAGS_CONTRAST : constant := 128;
VP_FLAGS_COPYPROTECT : constant := 256;
VP_FLAGS_FLICKER : constant := 4;
VP_FLAGS_MAX_UNSCALED : constant := 16;
VP_FLAGS_OVERSCAN : constant := 8;
VP_FLAGS_POSITION : constant := 32;
VP_FLAGS_TV_MODE : constant := 1;
VP_FLAGS_TV_STANDARD : constant := 2;
VP_MODE_TV_PLAYBACK : constant := 2;
VP_MODE_WIN_GRAPHICS : constant := 1;
VP_TV_STANDARD_NTSC_433 : constant := 65536;
VP_TV_STANDARD_NTSC_M : constant := 1;
VP_TV_STANDARD_NTSC_M_J : constant := 2;
VP_TV_STANDARD_PAL_60 : constant := 262144;
VP_TV_STANDARD_PAL_B : constant := 4;
VP_TV_STANDARD_PAL_D : constant := 8;
VP_TV_STANDARD_PAL_G : constant := 131072;
VP_TV_STANDARD_PAL_H : constant := 16;
VP_TV_STANDARD_PAL_I : constant := 32;
VP_TV_STANDARD_PAL_M : constant := 64;
VP_TV_STANDARD_PAL_N : constant := 128;
VP_TV_STANDARD_SECAM_B : constant := 256;
VP_TV_STANDARD_SECAM_D : constant := 512;
VP_TV_STANDARD_SECAM_G : constant := 1024;
VP_TV_STANDARD_SECAM_H : constant := 2048;
VP_TV_STANDARD_SECAM_K : constant := 4096;
VP_TV_STANDARD_SECAM_K1 : constant := 8192;
VP_TV_STANDARD_SECAM_L : constant := 16384;
VP_TV_STANDARD_SECAM_L1 : constant := 524288;
VP_TV_STANDARD_WIN_VGA : constant := 32768;
-- __TVOUT__ (empty)
end C.tvout;
Raw
c-unwind.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
with C.winnt;
package C.unwind is
pragma Preelaborate;
subtype Unwind_Word is unsigned_long_long;
subtype Unwind_Word_array is unsigned_long_long_array;
subtype Unwind_Sword is signed_long_long;
subtype Unwind_Ptr is unsigned_long_long;
subtype Unwind_Internal_Ptr is unsigned_long_long;
subtype Unwind_Exception_Class is unsigned_long_long;
type enum_b295e210 is (URC_NO_REASON, URC_FOREIGN_EXCEPTION_CAUGHT,
URC_FATAL_PHASE2_ERROR, URC_FATAL_PHASE1_ERROR, URC_NORMAL_STOP,
URC_END_OF_STACK, URC_HANDLER_FOUND, URC_INSTALL_CONTEXT,
URC_CONTINUE_UNWIND);
for enum_b295e210 use (URC_NO_REASON => 0,
URC_FOREIGN_EXCEPTION_CAUGHT => 1, URC_FATAL_PHASE2_ERROR => 2,
URC_FATAL_PHASE1_ERROR => 3, URC_NORMAL_STOP => 4,
URC_END_OF_STACK => 5, URC_HANDLER_FOUND => 6,
URC_INSTALL_CONTEXT => 7, URC_CONTINUE_UNWIND => 8);
pragma Convention (C, enum_b295e210);
subtype Unwind_Reason_Code is enum_b295e210;
type struct_Unwind_Exception;
type struct_Unwind_Exception_ptr is access all struct_Unwind_Exception;
for struct_Unwind_Exception_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_Unwind_Exception_ptr);
pragma Convention (C, struct_Unwind_Exception_ptr);
type access_7c1832b6 is access procedure (a1 : Unwind_Reason_Code;
a2 : access struct_Unwind_Exception);
pragma Convention (C, access_7c1832b6);
subtype Unwind_Exception_Cleanup_Fn is access_7c1832b6;
type struct_Unwind_Exception is record
exception_class : aliased Unwind_Exception_Class;
exception_cleanup : aliased Unwind_Exception_Cleanup_Fn;
F_private : aliased Unwind_Word_array (0 .. 5);
end record;
for struct_Unwind_Exception'Alignment use Standard'Maximum_Alignment;
pragma Convention (C_Pass_By_Copy, struct_Unwind_Exception);
subtype Unwind_Action is signed_int;
type struct_Unwind_Context (<>) is limited private;
type struct_Unwind_Context_ptr is access all struct_Unwind_Context;
for struct_Unwind_Context_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_Unwind_Context_ptr);
pragma Convention (C, struct_Unwind_Context_ptr);
function Unwind_RaiseException (a1 : access struct_Unwind_Exception)
return Unwind_Reason_Code;
pragma Import (C, Unwind_RaiseException, "_Unwind_RaiseException");
type access_080b8106 is access function (a1 : signed_int;
a2 : Unwind_Action; a3 : Unwind_Exception_Class;
a4 : access struct_Unwind_Exception; a5 : access struct_Unwind_Context;
a6 : void_ptr) return Unwind_Reason_Code;
pragma Convention (C, access_080b8106);
subtype Unwind_Stop_Fn is access_080b8106;
function Unwind_ForcedUnwind (a1 : access struct_Unwind_Exception;
a2 : Unwind_Stop_Fn; a3 : void_ptr) return Unwind_Reason_Code;
pragma Import (C, Unwind_ForcedUnwind, "_Unwind_ForcedUnwind");
procedure Unwind_DeleteException (a1 : access struct_Unwind_Exception);
pragma Import (C, Unwind_DeleteException, "_Unwind_DeleteException");
procedure Unwind_Resume (a1 : access struct_Unwind_Exception);
pragma Import (C, Unwind_Resume, "_Unwind_Resume");
function Unwind_Resume_or_Rethrow (a1 : access struct_Unwind_Exception)
return Unwind_Reason_Code;
pragma Import (C, Unwind_Resume_or_Rethrow, "_Unwind_Resume_or_Rethrow");
type access_b69c3a1f is access function (
a1 : access struct_Unwind_Context; a2 : void_ptr)
return Unwind_Reason_Code;
pragma Convention (C, access_b69c3a1f);
subtype Unwind_Trace_Fn is access_b69c3a1f;
function Unwind_Backtrace (a1 : Unwind_Trace_Fn; a2 : void_ptr)
return Unwind_Reason_Code;
pragma Import (C, Unwind_Backtrace, "_Unwind_Backtrace");
function Unwind_GetGR (a1 : access struct_Unwind_Context; a2 : signed_int)
return Unwind_Word;
pragma Import (C, Unwind_GetGR, "_Unwind_GetGR");
procedure Unwind_SetGR (a1 : access struct_Unwind_Context;
a2 : signed_int; a3 : Unwind_Word);
pragma Import (C, Unwind_SetGR, "_Unwind_SetGR");
function Unwind_GetIP (a1 : access struct_Unwind_Context)
return Unwind_Ptr;
pragma Import (C, Unwind_GetIP, "_Unwind_GetIP");
function Unwind_GetIPInfo (a1 : access struct_Unwind_Context;
a2 : access signed_int) return Unwind_Ptr;
pragma Import (C, Unwind_GetIPInfo, "_Unwind_GetIPInfo");
procedure Unwind_SetIP (a1 : access struct_Unwind_Context;
a2 : Unwind_Ptr);
pragma Import (C, Unwind_SetIP, "_Unwind_SetIP");
function Unwind_GetCFA (a1 : access struct_Unwind_Context)
return Unwind_Word;
pragma Import (C, Unwind_GetCFA, "_Unwind_GetCFA");
function Unwind_GetLanguageSpecificData (
a1 : access struct_Unwind_Context) return void_ptr;
pragma Import (C, Unwind_GetLanguageSpecificData,
"_Unwind_GetLanguageSpecificData");
function Unwind_GetRegionStart (a1 : access struct_Unwind_Context)
return Unwind_Ptr;
pragma Import (C, Unwind_GetRegionStart, "_Unwind_GetRegionStart");
type access_e0e08ff1 is access function (a1 : signed_int;
a2 : Unwind_Action; a3 : Unwind_Exception_Class;
a4 : access struct_Unwind_Exception; a5 : access struct_Unwind_Context)
return Unwind_Reason_Code;
pragma Convention (C, access_e0e08ff1);
subtype Unwind_Personality_Fn is access_e0e08ff1;
type struct_SjLj_Function_Context (<>) is limited private;
type struct_SjLj_Function_Context_ptr is
access all struct_SjLj_Function_Context;
for struct_SjLj_Function_Context_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_SjLj_Function_Context_ptr);
pragma Convention (C, struct_SjLj_Function_Context_ptr);
procedure Unwind_SjLj_Register (a1 : access struct_SjLj_Function_Context);
pragma Import (C, Unwind_SjLj_Register, "_Unwind_SjLj_Register");
procedure Unwind_SjLj_Unregister (
a1 : access struct_SjLj_Function_Context);
pragma Import (C, Unwind_SjLj_Unregister, "_Unwind_SjLj_Unregister");
function Unwind_SjLj_RaiseException (a1 : access struct_Unwind_Exception)
return Unwind_Reason_Code;
pragma Import (C, Unwind_SjLj_RaiseException,
"_Unwind_SjLj_RaiseException");
function Unwind_SjLj_ForcedUnwind (a1 : access struct_Unwind_Exception;
a2 : Unwind_Stop_Fn; a3 : void_ptr) return Unwind_Reason_Code;
pragma Import (C, Unwind_SjLj_ForcedUnwind, "_Unwind_SjLj_ForcedUnwind");
procedure Unwind_SjLj_Resume (a1 : access struct_Unwind_Exception);
pragma Import (C, Unwind_SjLj_Resume, "_Unwind_SjLj_Resume");
function Unwind_SjLj_Resume_or_Rethrow (
a1 : access struct_Unwind_Exception) return Unwind_Reason_Code;
pragma Import (C, Unwind_SjLj_Resume_or_Rethrow,
"_Unwind_SjLj_Resume_or_Rethrow");
function Unwind_GetDataRelBase (a1 : access struct_Unwind_Context)
return Unwind_Ptr;
pragma Import (C, Unwind_GetDataRelBase, "_Unwind_GetDataRelBase");
function Unwind_GetTextRelBase (a1 : access struct_Unwind_Context)
return Unwind_Ptr;
pragma Import (C, Unwind_GetTextRelBase, "_Unwind_GetTextRelBase");
function Unwind_FindEnclosingFunction (pc : void_ptr) return void_ptr;
pragma Import (C, Unwind_FindEnclosingFunction,
"_Unwind_FindEnclosingFunction");
subtype sleb128_t is signed_long_long;
subtype uleb128_t is unsigned_long_long;
function GCC_specific_handler (a1 : access winnt.EXCEPTION_RECORD;
a2 : void_ptr; a3 : access winnt.struct_CONTEXT;
a4 : access winnt.struct_DISPATCHER_CONTEXT;
a5 : Unwind_Personality_Fn) return signed_int;
pragma Import (C, GCC_specific_handler, "_GCC_specific_handler");
-- LIBGCC2_UNWIND_ATTRIBUTE (empty)
UA_CLEANUP_PHASE : constant := 2;
UA_END_OF_STACK : constant := 16;
UA_FORCE_UNWIND : constant := 8;
UA_HANDLER_FRAME : constant := 4;
UA_SEARCH_PHASE : constant := 1;
-- _UNWIND_H (empty)
private
type struct_Unwind_Context is null record;
type struct_SjLj_Function_Context is null record;
end C.unwind;
Raw
c-vadefs.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.vadefs is
pragma Preelaborate;
subtype qqgnuc_va_list is builtin_va_list;
subtype qqgnuc_va_list_ptr is builtin_va_list_ptr;
subtype va_list is qqgnuc_va_list;
subtype va_list_ptr is qqgnuc_va_list_ptr;
-- _ADDRESSOF (function macro)
-- _INC_VADEFS (empty)
-- _VA_LIST_DEFINED (empty)
-- __GNUC_VA_LIST (empty)
-- _crt_va_arg (function macro)
-- _crt_va_copy (function macro)
-- _crt_va_end (function macro)
-- _crt_va_start (function macro)
end C.vadefs;
Raw
c-virtdisk.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.virtdisk is
pragma Preelaborate;
-- _INC_VIRTDISK (empty)
end C.virtdisk;
Raw
c-winapifamily.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.winapifamily is
pragma Preelaborate;
WINAPI_FAMILY : constant := 3;
WINAPI_FAMILY_APP : constant := 2;
WINAPI_FAMILY_DESKTOP_APP : constant := 3;
-- WINAPI_FAMILY_ONE_PARTITION (function macro)
-- WINAPI_FAMILY_PARTITION (function macro)
WINAPI_PARTITION_APP : constant := 2;
WINAPI_PARTITION_DESKTOP : constant := 1;
-- _INC_WINAPIFAMILY (empty)
end C.winapifamily;
Raw
c-winbase.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
with C.basetsd;
with C.guiddef;
with C.vadefs;
with C.windef;
with C.winnt;
package C.winbase is
pragma Preelaborate;
type struct_OVERLAPPED;
type struct_81618b4c is record
Offset : aliased windef.DWORD;
OffsetHigh : aliased windef.DWORD;
end record;
pragma Convention (C_Pass_By_Copy, struct_81618b4c);
type union_7850cbb3 (Unchecked_Tag : unsigned_int := 0) is record
case Unchecked_Tag is
when 0 =>
Offset : aliased windef.DWORD;
OffsetHigh : aliased windef.DWORD;
when others =>
Pointer : winnt.PVOID;
end case;
end record;
pragma Unchecked_Union (union_7850cbb3);
pragma Convention (C_Pass_By_Copy, union_7850cbb3);
type struct_OVERLAPPED is record
Internal : aliased basetsd.ULONG_PTR;
InternalHigh : aliased basetsd.ULONG_PTR;
anonymous_1 : aliased union_7850cbb3;
hEvent : aliased winnt.HANDLE;
end record;
pragma Convention (C_Pass_By_Copy, struct_OVERLAPPED);
type struct_OVERLAPPED_ptr is access all struct_OVERLAPPED;
for struct_OVERLAPPED_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_OVERLAPPED_ptr);
pragma Convention (C, struct_OVERLAPPED_ptr);
type struct_OVERLAPPED_ptr_ptr is access all struct_OVERLAPPED_ptr;
for struct_OVERLAPPED_ptr_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_OVERLAPPED_ptr_ptr);
pragma Convention (C, struct_OVERLAPPED_ptr_ptr);
subtype OVERLAPPED is struct_OVERLAPPED;
subtype LPOVERLAPPED is struct_OVERLAPPED_ptr;
subtype LPOVERLAPPED_ptr is struct_OVERLAPPED_ptr_ptr;
type struct_SECURITY_ATTRIBUTES;
type struct_SECURITY_ATTRIBUTES is record
nLength : aliased windef.DWORD;
lpSecurityDescriptor : aliased windef.LPVOID;
bInheritHandle : aliased windef.WINBOOL;
end record;
pragma Convention (C_Pass_By_Copy, struct_SECURITY_ATTRIBUTES);
type struct_SECURITY_ATTRIBUTES_ptr is
access all struct_SECURITY_ATTRIBUTES;
for struct_SECURITY_ATTRIBUTES_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_SECURITY_ATTRIBUTES_ptr);
pragma Convention (C, struct_SECURITY_ATTRIBUTES_ptr);
type struct_SECURITY_ATTRIBUTES_const_ptr is
access constant struct_SECURITY_ATTRIBUTES;
for struct_SECURITY_ATTRIBUTES_const_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_SECURITY_ATTRIBUTES_const_ptr);
pragma Convention (C, struct_SECURITY_ATTRIBUTES_const_ptr);
subtype SECURITY_ATTRIBUTES is struct_SECURITY_ATTRIBUTES;
subtype SECURITY_ATTRIBUTES_const_ptr is
struct_SECURITY_ATTRIBUTES_const_ptr;
subtype PSECURITY_ATTRIBUTES is struct_SECURITY_ATTRIBUTES_ptr;
subtype LPSECURITY_ATTRIBUTES is struct_SECURITY_ATTRIBUTES_ptr;
type struct_PROCESS_INFORMATION;
type struct_PROCESS_INFORMATION is record
hProcess : aliased winnt.HANDLE;
hThread : aliased winnt.HANDLE;
dwProcessId : aliased windef.DWORD;
dwThreadId : aliased windef.DWORD;
end record;
pragma Convention (C_Pass_By_Copy, struct_PROCESS_INFORMATION);
type struct_PROCESS_INFORMATION_ptr is
access all struct_PROCESS_INFORMATION;
for struct_PROCESS_INFORMATION_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_PROCESS_INFORMATION_ptr);
pragma Convention (C, struct_PROCESS_INFORMATION_ptr);
subtype PROCESS_INFORMATION is struct_PROCESS_INFORMATION;
subtype PPROCESS_INFORMATION is struct_PROCESS_INFORMATION_ptr;
subtype LPPROCESS_INFORMATION is struct_PROCESS_INFORMATION_ptr;
type struct_SYSTEMTIME;
type struct_SYSTEMTIME is record
wYear : aliased windef.WORD;
wMonth : aliased windef.WORD;
wDayOfWeek : aliased windef.WORD;
wDay : aliased windef.WORD;
wHour : aliased windef.WORD;
wMinute : aliased windef.WORD;
wSecond : aliased windef.WORD;
wMilliseconds : aliased windef.WORD;
end record;
pragma Convention (C_Pass_By_Copy, struct_SYSTEMTIME);
type struct_SYSTEMTIME_ptr is access all struct_SYSTEMTIME;
for struct_SYSTEMTIME_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_SYSTEMTIME_ptr);
pragma Convention (C, struct_SYSTEMTIME_ptr);
type struct_SYSTEMTIME_const_ptr is access constant struct_SYSTEMTIME;
for struct_SYSTEMTIME_const_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_SYSTEMTIME_const_ptr);
pragma Convention (C, struct_SYSTEMTIME_const_ptr);
subtype SYSTEMTIME is struct_SYSTEMTIME;
subtype SYSTEMTIME_const_ptr is struct_SYSTEMTIME_const_ptr;
subtype PSYSTEMTIME is struct_SYSTEMTIME_ptr;
subtype LPSYSTEMTIME is struct_SYSTEMTIME_ptr;
type access_b546b3db is access function (
lpThreadParameter : windef.LPVOID) return windef.DWORD;
pragma Convention (C, access_b546b3db);
subtype PTHREAD_START_ROUTINE is access_b546b3db;
subtype LPTHREAD_START_ROUTINE is PTHREAD_START_ROUTINE;
type access_e10edc4b is access procedure (
lpFiberParameter : windef.LPVOID);
pragma Convention (C, access_e10edc4b);
subtype PFIBER_START_ROUTINE is access_e10edc4b;
subtype LPFIBER_START_ROUTINE is PFIBER_START_ROUTINE;
subtype CRITICAL_SECTION is winnt.RTL_CRITICAL_SECTION;
subtype PCRITICAL_SECTION is winnt.PRTL_CRITICAL_SECTION;
subtype LPCRITICAL_SECTION is winnt.PRTL_CRITICAL_SECTION;
subtype CRITICAL_SECTION_DEBUG is winnt.RTL_CRITICAL_SECTION_DEBUG;
subtype PCRITICAL_SECTION_DEBUG is winnt.PRTL_CRITICAL_SECTION_DEBUG;
subtype LPCRITICAL_SECTION_DEBUG is winnt.PRTL_CRITICAL_SECTION_DEBUG;
function EncodePointer (Ptr : winnt.PVOID) return winnt.PVOID;
pragma Import (C, EncodePointer, "EncodePointer");
function DecodePointer (Ptr : winnt.PVOID) return winnt.PVOID;
pragma Import (C, DecodePointer, "DecodePointer");
function EncodeSystemPointer (Ptr : winnt.PVOID) return winnt.PVOID;
pragma Import (C, EncodeSystemPointer, "EncodeSystemPointer");
function DecodeSystemPointer (Ptr : winnt.PVOID) return winnt.PVOID;
pragma Import (C, DecodeSystemPointer, "DecodeSystemPointer");
subtype LPLDT_ENTRY is windef.LPVOID;
type struct_COMMPROP;
type struct_COMMPROP is record
wPacketLength : aliased windef.WORD;
wPacketVersion : aliased windef.WORD;
dwServiceMask : aliased windef.DWORD;
dwReserved1 : aliased windef.DWORD;
dwMaxTxQueue : aliased windef.DWORD;
dwMaxRxQueue : aliased windef.DWORD;
dwMaxBaud : aliased windef.DWORD;
dwProvSubType : aliased windef.DWORD;
dwProvCapabilities : aliased windef.DWORD;
dwSettableParams : aliased windef.DWORD;
dwSettableBaud : aliased windef.DWORD;
wSettableData : aliased windef.WORD;
wSettableStopParity : aliased windef.WORD;
dwCurrentTxQueue : aliased windef.DWORD;
dwCurrentRxQueue : aliased windef.DWORD;
dwProvSpec1 : aliased windef.DWORD;
dwProvSpec2 : aliased windef.DWORD;
wcProvChar : aliased winnt.WCHAR_array (0 .. 0);
end record;
pragma Convention (C_Pass_By_Copy, struct_COMMPROP);
type struct_COMMPROP_ptr is access all struct_COMMPROP;
for struct_COMMPROP_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_COMMPROP_ptr);
pragma Convention (C, struct_COMMPROP_ptr);
subtype COMMPROP is struct_COMMPROP;
subtype LPCOMMPROP is struct_COMMPROP_ptr;
type struct_COMSTAT;
type struct_COMSTAT is record
fCtsHold : windef.DWORD range 0 .. 1;
fDsrHold : windef.DWORD range 0 .. 1;
fRlsdHold : windef.DWORD range 0 .. 1;
fXoffHold : windef.DWORD range 0 .. 1;
fXoffSent : windef.DWORD range 0 .. 1;
fEof : windef.DWORD range 0 .. 1;
fTxim : windef.DWORD range 0 .. 1;
fReserved : windef.DWORD range 0 .. 33554431;
cbInQue : aliased windef.DWORD;
cbOutQue : aliased windef.DWORD;
end record;
for struct_COMSTAT use record
fCtsHold at 0 range 0 .. 0;
fDsrHold at 0 range 1 .. 1;
fRlsdHold at 0 range 2 .. 2;
fXoffHold at 0 range 3 .. 3;
fXoffSent at 0 range 4 .. 4;
fEof at 0 range 5 .. 5;
fTxim at 0 range 6 .. 6;
fReserved at 0 range 7 .. 31;
cbInQue at 0 range 32 .. 63;
cbOutQue at 0 range 64 .. 95;
end record;
pragma Convention (C_Pass_By_Copy, struct_COMSTAT);
type struct_COMSTAT_ptr is access all struct_COMSTAT;
for struct_COMSTAT_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_COMSTAT_ptr);
pragma Convention (C, struct_COMSTAT_ptr);
subtype COMSTAT is struct_COMSTAT;
subtype LPCOMSTAT is struct_COMSTAT_ptr;
type struct_DCB;
type struct_DCB is record
DCBlength : aliased windef.DWORD;
BaudRate : aliased windef.DWORD;
fBinary : windef.DWORD range 0 .. 1;
fParity : windef.DWORD range 0 .. 1;
fOutxCtsFlow : windef.DWORD range 0 .. 1;
fOutxDsrFlow : windef.DWORD range 0 .. 1;
fDtrControl : windef.DWORD range 0 .. 3;
fDsrSensitivity : windef.DWORD range 0 .. 1;
fTXContinueOnXoff : windef.DWORD range 0 .. 1;
fOutX : windef.DWORD range 0 .. 1;
fInX : windef.DWORD range 0 .. 1;
fErrorChar : windef.DWORD range 0 .. 1;
fNull : windef.DWORD range 0 .. 1;
fRtsControl : windef.DWORD range 0 .. 3;
fAbortOnError : windef.DWORD range 0 .. 1;
fDummy2 : windef.DWORD range 0 .. 131071;
wReserved : aliased windef.WORD;
XonLim : aliased windef.WORD;
XoffLim : aliased windef.WORD;
ByteSize : aliased windef.BYTE;
Parity : aliased windef.BYTE;
StopBits : aliased windef.BYTE;
XonChar : aliased char;
XoffChar : aliased char;
ErrorChar : aliased char;
EofChar : aliased char;
EvtChar : aliased char;
wReserved1 : aliased windef.WORD;
end record;
for struct_DCB use record
DCBlength at 0 range 0 .. 31;
BaudRate at 0 range 32 .. 63;
fBinary at 0 range 64 .. 64;
fParity at 0 range 65 .. 65;
fOutxCtsFlow at 0 range 66 .. 66;
fOutxDsrFlow at 0 range 67 .. 67;
fDtrControl at 0 range 68 .. 69;
fDsrSensitivity at 0 range 70 .. 70;
fTXContinueOnXoff at 0 range 71 .. 71;
fOutX at 0 range 72 .. 72;
fInX at 0 range 73 .. 73;
fErrorChar at 0 range 74 .. 74;
fNull at 0 range 75 .. 75;
fRtsControl at 0 range 76 .. 77;
fAbortOnError at 0 range 78 .. 78;
fDummy2 at 0 range 79 .. 95;
wReserved at 0 range 96 .. 111;
XonLim at 0 range 112 .. 127;
XoffLim at 0 range 128 .. 143;
ByteSize at 0 range 144 .. 151;
Parity at 0 range 152 .. 159;
StopBits at 0 range 160 .. 167;
XonChar at 0 range 168 .. 175;
XoffChar at 0 range 176 .. 183;
ErrorChar at 0 range 184 .. 191;
EofChar at 0 range 192 .. 199;
EvtChar at 0 range 200 .. 207;
wReserved1 at 0 range 208 .. 223;
end record;
pragma Convention (C_Pass_By_Copy, struct_DCB);
type struct_DCB_ptr is access all struct_DCB;
for struct_DCB_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_DCB_ptr);
pragma Convention (C, struct_DCB_ptr);
subtype DCB is struct_DCB;
subtype LPDCB is struct_DCB_ptr;
type struct_COMMTIMEOUTS;
type struct_COMMTIMEOUTS is record
ReadIntervalTimeout : aliased windef.DWORD;
ReadTotalTimeoutMultiplier : aliased windef.DWORD;
ReadTotalTimeoutConstant : aliased windef.DWORD;
WriteTotalTimeoutMultiplier : aliased windef.DWORD;
WriteTotalTimeoutConstant : aliased windef.DWORD;
end record;
pragma Convention (C_Pass_By_Copy, struct_COMMTIMEOUTS);
type struct_COMMTIMEOUTS_ptr is access all struct_COMMTIMEOUTS;
for struct_COMMTIMEOUTS_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_COMMTIMEOUTS_ptr);
pragma Convention (C, struct_COMMTIMEOUTS_ptr);
subtype COMMTIMEOUTS is struct_COMMTIMEOUTS;
subtype LPCOMMTIMEOUTS is struct_COMMTIMEOUTS_ptr;
type struct_COMMCONFIG;
type struct_COMMCONFIG is record
dwSize : aliased windef.DWORD;
wVersion : aliased windef.WORD;
wReserved : aliased windef.WORD;
dcb : aliased winbase.DCB;
dwProviderSubType : aliased windef.DWORD;
dwProviderOffset : aliased windef.DWORD;
dwProviderSize : aliased windef.DWORD;
wcProviderData : aliased winnt.WCHAR_array (0 .. 0);
end record;
pragma Convention (C_Pass_By_Copy, struct_COMMCONFIG);
type struct_COMMCONFIG_ptr is access all struct_COMMCONFIG;
for struct_COMMCONFIG_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_COMMCONFIG_ptr);
pragma Convention (C, struct_COMMCONFIG_ptr);
subtype COMMCONFIG is struct_COMMCONFIG;
subtype LPCOMMCONFIG is struct_COMMCONFIG_ptr;
type struct_SYSTEM_INFO;
type struct_79911a9e is record
wProcessorArchitecture : aliased windef.WORD;
wReserved : aliased windef.WORD;
end record;
pragma Convention (C_Pass_By_Copy, struct_79911a9e);
type union_96c76d00 (Unchecked_Tag : unsigned_int := 0) is record
case Unchecked_Tag is
when 0 =>
dwOemId : windef.DWORD;
when others =>
wProcessorArchitecture : aliased windef.WORD;
wReserved : aliased windef.WORD;
end case;
end record;
pragma Unchecked_Union (union_96c76d00);
pragma Convention (C_Pass_By_Copy, union_96c76d00);
type struct_SYSTEM_INFO is record
anonymous_1 : aliased union_96c76d00;
dwPageSize : aliased windef.DWORD;
lpMinimumApplicationAddress : aliased windef.LPVOID;
lpMaximumApplicationAddress : aliased windef.LPVOID;
dwActiveProcessorMask : aliased basetsd.DWORD_PTR;
dwNumberOfProcessors : aliased windef.DWORD;
dwProcessorType : aliased windef.DWORD;
dwAllocationGranularity : aliased windef.DWORD;
wProcessorLevel : aliased windef.WORD;
wProcessorRevision : aliased windef.WORD;
end record;
pragma Convention (C_Pass_By_Copy, struct_SYSTEM_INFO);
type struct_SYSTEM_INFO_ptr is access all struct_SYSTEM_INFO;
for struct_SYSTEM_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_SYSTEM_INFO_ptr);
pragma Convention (C, struct_SYSTEM_INFO_ptr);
subtype SYSTEM_INFO is struct_SYSTEM_INFO;
subtype LPSYSTEM_INFO is struct_SYSTEM_INFO_ptr;
type struct_MEMORYSTATUS;
type struct_MEMORYSTATUS is record
dwLength : aliased windef.DWORD;
dwMemoryLoad : aliased windef.DWORD;
dwTotalPhys : aliased basetsd.SIZE_T;
dwAvailPhys : aliased basetsd.SIZE_T;
dwTotalPageFile : aliased basetsd.SIZE_T;
dwAvailPageFile : aliased basetsd.SIZE_T;
dwTotalVirtual : aliased basetsd.SIZE_T;
dwAvailVirtual : aliased basetsd.SIZE_T;
end record;
pragma Convention (C_Pass_By_Copy, struct_MEMORYSTATUS);
type struct_MEMORYSTATUS_ptr is access all struct_MEMORYSTATUS;
for struct_MEMORYSTATUS_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_MEMORYSTATUS_ptr);
pragma Convention (C, struct_MEMORYSTATUS_ptr);
subtype MEMORYSTATUS is struct_MEMORYSTATUS;
subtype LPMEMORYSTATUS is struct_MEMORYSTATUS_ptr;
type struct_EXCEPTION_DEBUG_INFO;
type struct_EXCEPTION_DEBUG_INFO is record
ExceptionRecord : aliased winnt.EXCEPTION_RECORD;
dwFirstChance : aliased windef.DWORD;
end record;
pragma Convention (C_Pass_By_Copy, struct_EXCEPTION_DEBUG_INFO);
type struct_EXCEPTION_DEBUG_INFO_ptr is
access all struct_EXCEPTION_DEBUG_INFO;
for struct_EXCEPTION_DEBUG_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_EXCEPTION_DEBUG_INFO_ptr);
pragma Convention (C, struct_EXCEPTION_DEBUG_INFO_ptr);
subtype EXCEPTION_DEBUG_INFO is struct_EXCEPTION_DEBUG_INFO;
subtype LPEXCEPTION_DEBUG_INFO is struct_EXCEPTION_DEBUG_INFO_ptr;
type struct_CREATE_THREAD_DEBUG_INFO;
type struct_CREATE_THREAD_DEBUG_INFO is record
hThread : aliased winnt.HANDLE;
lpThreadLocalBase : aliased windef.LPVOID;
lpStartAddress : aliased LPTHREAD_START_ROUTINE;
end record;
pragma Convention (C_Pass_By_Copy, struct_CREATE_THREAD_DEBUG_INFO);
type struct_CREATE_THREAD_DEBUG_INFO_ptr is
access all struct_CREATE_THREAD_DEBUG_INFO;
for struct_CREATE_THREAD_DEBUG_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CREATE_THREAD_DEBUG_INFO_ptr);
pragma Convention (C, struct_CREATE_THREAD_DEBUG_INFO_ptr);
subtype CREATE_THREAD_DEBUG_INFO is struct_CREATE_THREAD_DEBUG_INFO;
subtype LPCREATE_THREAD_DEBUG_INFO is struct_CREATE_THREAD_DEBUG_INFO_ptr;
type struct_CREATE_PROCESS_DEBUG_INFO;
type struct_CREATE_PROCESS_DEBUG_INFO is record
hFile : aliased winnt.HANDLE;
hProcess : aliased winnt.HANDLE;
hThread : aliased winnt.HANDLE;
lpBaseOfImage : aliased windef.LPVOID;
dwDebugInfoFileOffset : aliased windef.DWORD;
nDebugInfoSize : aliased windef.DWORD;
lpThreadLocalBase : aliased windef.LPVOID;
lpStartAddress : aliased LPTHREAD_START_ROUTINE;
lpImageName : aliased windef.LPVOID;
fUnicode : aliased windef.WORD;
end record;
pragma Convention (C_Pass_By_Copy, struct_CREATE_PROCESS_DEBUG_INFO);
type struct_CREATE_PROCESS_DEBUG_INFO_ptr is
access all struct_CREATE_PROCESS_DEBUG_INFO;
for struct_CREATE_PROCESS_DEBUG_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CREATE_PROCESS_DEBUG_INFO_ptr);
pragma Convention (C, struct_CREATE_PROCESS_DEBUG_INFO_ptr);
subtype CREATE_PROCESS_DEBUG_INFO is struct_CREATE_PROCESS_DEBUG_INFO;
subtype LPCREATE_PROCESS_DEBUG_INFO is
struct_CREATE_PROCESS_DEBUG_INFO_ptr;
type struct_EXIT_THREAD_DEBUG_INFO;
type struct_EXIT_THREAD_DEBUG_INFO is record
dwExitCode : aliased windef.DWORD;
end record;
pragma Convention (C_Pass_By_Copy, struct_EXIT_THREAD_DEBUG_INFO);
type struct_EXIT_THREAD_DEBUG_INFO_ptr is
access all struct_EXIT_THREAD_DEBUG_INFO;
for struct_EXIT_THREAD_DEBUG_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_EXIT_THREAD_DEBUG_INFO_ptr);
pragma Convention (C, struct_EXIT_THREAD_DEBUG_INFO_ptr);
subtype EXIT_THREAD_DEBUG_INFO is struct_EXIT_THREAD_DEBUG_INFO;
subtype LPEXIT_THREAD_DEBUG_INFO is struct_EXIT_THREAD_DEBUG_INFO_ptr;
type struct_EXIT_PROCESS_DEBUG_INFO;
type struct_EXIT_PROCESS_DEBUG_INFO is record
dwExitCode : aliased windef.DWORD;
end record;
pragma Convention (C_Pass_By_Copy, struct_EXIT_PROCESS_DEBUG_INFO);
type struct_EXIT_PROCESS_DEBUG_INFO_ptr is
access all struct_EXIT_PROCESS_DEBUG_INFO;
for struct_EXIT_PROCESS_DEBUG_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_EXIT_PROCESS_DEBUG_INFO_ptr);
pragma Convention (C, struct_EXIT_PROCESS_DEBUG_INFO_ptr);
subtype EXIT_PROCESS_DEBUG_INFO is struct_EXIT_PROCESS_DEBUG_INFO;
subtype LPEXIT_PROCESS_DEBUG_INFO is struct_EXIT_PROCESS_DEBUG_INFO_ptr;
type struct_LOAD_DLL_DEBUG_INFO;
type struct_LOAD_DLL_DEBUG_INFO is record
hFile : aliased winnt.HANDLE;
lpBaseOfDll : aliased windef.LPVOID;
dwDebugInfoFileOffset : aliased windef.DWORD;
nDebugInfoSize : aliased windef.DWORD;
lpImageName : aliased windef.LPVOID;
fUnicode : aliased windef.WORD;
end record;
pragma Convention (C_Pass_By_Copy, struct_LOAD_DLL_DEBUG_INFO);
type struct_LOAD_DLL_DEBUG_INFO_ptr is
access all struct_LOAD_DLL_DEBUG_INFO;
for struct_LOAD_DLL_DEBUG_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_LOAD_DLL_DEBUG_INFO_ptr);
pragma Convention (C, struct_LOAD_DLL_DEBUG_INFO_ptr);
subtype LOAD_DLL_DEBUG_INFO is struct_LOAD_DLL_DEBUG_INFO;
subtype LPLOAD_DLL_DEBUG_INFO is struct_LOAD_DLL_DEBUG_INFO_ptr;
type struct_UNLOAD_DLL_DEBUG_INFO;
type struct_UNLOAD_DLL_DEBUG_INFO is record
lpBaseOfDll : aliased windef.LPVOID;
end record;
pragma Convention (C_Pass_By_Copy, struct_UNLOAD_DLL_DEBUG_INFO);
type struct_UNLOAD_DLL_DEBUG_INFO_ptr is
access all struct_UNLOAD_DLL_DEBUG_INFO;
for struct_UNLOAD_DLL_DEBUG_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_UNLOAD_DLL_DEBUG_INFO_ptr);
pragma Convention (C, struct_UNLOAD_DLL_DEBUG_INFO_ptr);
subtype UNLOAD_DLL_DEBUG_INFO is struct_UNLOAD_DLL_DEBUG_INFO;
subtype LPUNLOAD_DLL_DEBUG_INFO is struct_UNLOAD_DLL_DEBUG_INFO_ptr;
type struct_OUTPUT_DEBUG_STRING_INFO;
type struct_OUTPUT_DEBUG_STRING_INFO is record
lpDebugStringData : aliased winnt.LPSTR;
fUnicode : aliased windef.WORD;
nDebugStringLength : aliased windef.WORD;
end record;
pragma Convention (C_Pass_By_Copy, struct_OUTPUT_DEBUG_STRING_INFO);
type struct_OUTPUT_DEBUG_STRING_INFO_ptr is
access all struct_OUTPUT_DEBUG_STRING_INFO;
for struct_OUTPUT_DEBUG_STRING_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_OUTPUT_DEBUG_STRING_INFO_ptr);
pragma Convention (C, struct_OUTPUT_DEBUG_STRING_INFO_ptr);
subtype OUTPUT_DEBUG_STRING_INFO is struct_OUTPUT_DEBUG_STRING_INFO;
subtype LPOUTPUT_DEBUG_STRING_INFO is struct_OUTPUT_DEBUG_STRING_INFO_ptr;
type struct_RIP_INFO;
type struct_RIP_INFO is record
dwError : aliased windef.DWORD;
dwType : aliased windef.DWORD;
end record;
pragma Convention (C_Pass_By_Copy, struct_RIP_INFO);
type struct_RIP_INFO_ptr is access all struct_RIP_INFO;
for struct_RIP_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_RIP_INFO_ptr);
pragma Convention (C, struct_RIP_INFO_ptr);
subtype RIP_INFO is struct_RIP_INFO;
subtype LPRIP_INFO is struct_RIP_INFO_ptr;
type struct_DEBUG_EVENT;
type union_c1f1efc7 (Unchecked_Tag : unsigned_int := 0) is record
case Unchecked_Tag is
when 0 =>
F_Exception : EXCEPTION_DEBUG_INFO;
when 1 =>
CreateThread : CREATE_THREAD_DEBUG_INFO;
when 2 =>
CreateProcessInfo : CREATE_PROCESS_DEBUG_INFO;
when 3 =>
ExitThread : EXIT_THREAD_DEBUG_INFO;
when 4 =>
ExitProcess : EXIT_PROCESS_DEBUG_INFO;
when 5 =>
LoadDll : LOAD_DLL_DEBUG_INFO;
when 6 =>
UnloadDll : UNLOAD_DLL_DEBUG_INFO;
when 7 =>
DebugString : OUTPUT_DEBUG_STRING_INFO;
when others =>
RipInfo : RIP_INFO;
end case;
end record;
pragma Unchecked_Union (union_c1f1efc7);
pragma Convention (C_Pass_By_Copy, union_c1f1efc7);
type struct_DEBUG_EVENT is record
dwDebugEventCode : aliased windef.DWORD;
dwProcessId : aliased windef.DWORD;
dwThreadId : aliased windef.DWORD;
u : aliased union_c1f1efc7;
end record;
pragma Convention (C_Pass_By_Copy, struct_DEBUG_EVENT);
type struct_DEBUG_EVENT_ptr is access all struct_DEBUG_EVENT;
for struct_DEBUG_EVENT_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_DEBUG_EVENT_ptr);
pragma Convention (C, struct_DEBUG_EVENT_ptr);
subtype DEBUG_EVENT is struct_DEBUG_EVENT;
subtype LPDEBUG_EVENT is struct_DEBUG_EVENT_ptr;
subtype LPCONTEXT is winnt.PCONTEXT;
subtype LPEXCEPTION_RECORD is winnt.PEXCEPTION_RECORD;
subtype LPEXCEPTION_POINTERS is winnt.PEXCEPTION_POINTERS;
type struct_OFSTRUCT;
type struct_OFSTRUCT is record
cBytes : aliased windef.BYTE;
fFixedDisk : aliased windef.BYTE;
nErrCode : aliased windef.WORD;
Reserved1 : aliased windef.WORD;
Reserved2 : aliased windef.WORD;
szPathName : aliased winnt.C_CHAR_array (0 .. 127);
end record;
pragma Convention (C_Pass_By_Copy, struct_OFSTRUCT);
type struct_OFSTRUCT_ptr is access all struct_OFSTRUCT;
for struct_OFSTRUCT_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_OFSTRUCT_ptr);
pragma Convention (C, struct_OFSTRUCT_ptr);
subtype OFSTRUCT is struct_OFSTRUCT;
subtype LPOFSTRUCT is struct_OFSTRUCT_ptr;
subtype POFSTRUCT is struct_OFSTRUCT_ptr;
procedure InitializeSListHead (
ListHead : access winnt.struct_SLIST_HEADER);
pragma Import (C, InitializeSListHead, "InitializeSListHead");
function InterlockedPopEntrySList (
ListHead : access winnt.struct_SLIST_HEADER) return winnt.PSLIST_ENTRY;
pragma Import (C, InterlockedPopEntrySList, "InterlockedPopEntrySList");
function InterlockedPushEntrySList (
ListHead : access winnt.struct_SLIST_HEADER;
ListEntry : access winnt.struct_SLIST_ENTRY) return winnt.PSLIST_ENTRY;
pragma Import (C, InterlockedPushEntrySList, "InterlockedPushEntrySList");
function InterlockedFlushSList (
ListHead : access winnt.struct_SLIST_HEADER) return winnt.PSLIST_ENTRY;
pragma Import (C, InterlockedFlushSList, "InterlockedFlushSList");
function QueryDepthSList (ListHead : access winnt.struct_SLIST_HEADER)
return windef.USHORT;
pragma Import (C, QueryDepthSList, "QueryDepthSList");
function FreeResource (hResData : windef.HGLOBAL) return windef.WINBOOL;
pragma Import (C, FreeResource, "FreeResource");
function LockResource (hResData : windef.HGLOBAL) return windef.LPVOID;
pragma Import (C, LockResource, "LockResource");
function WinMain (hInstance : access windef.struct_HINSTANCE;
hPrevInstance : access windef.struct_HINSTANCE;
lpCmdLine : access winnt.C_CHAR; nShowCmd : signed_int)
return signed_int;
pragma Import (C, WinMain, "WinMain");
function wWinMain (hInstance : access windef.struct_HINSTANCE;
hPrevInstance : access windef.struct_HINSTANCE;
lpCmdLine : access winnt.WCHAR; nShowCmd : signed_int)
return signed_int;
pragma Import (C, wWinMain, "wWinMain");
function FreeLibrary (hLibModule : access windef.struct_HINSTANCE)
return windef.WINBOOL;
pragma Import (C, FreeLibrary, "FreeLibrary");
procedure FreeLibraryAndExitThread (
hLibModule : access windef.struct_HINSTANCE;
dwExitCode : windef.DWORD);
pragma No_Return (FreeLibraryAndExitThread);
pragma Import (C, FreeLibraryAndExitThread, "FreeLibraryAndExitThread");
function DisableThreadLibraryCalls (
hLibModule : access windef.struct_HINSTANCE) return windef.WINBOOL;
pragma Import (C, DisableThreadLibraryCalls, "DisableThreadLibraryCalls");
function GetProcAddress (hModule : access windef.struct_HINSTANCE;
lpProcName : access constant winnt.C_CHAR) return windef.FARPROC;
pragma Import (C, GetProcAddress, "GetProcAddress");
function GetVersion return windef.DWORD;
pragma Import (C, GetVersion, "GetVersion");
function GlobalAlloc (uFlags : windef.UINT; dwBytes : basetsd.SIZE_T)
return windef.HGLOBAL;
pragma Import (C, GlobalAlloc, "GlobalAlloc");
function GlobalReAlloc (hMem : windef.HGLOBAL; dwBytes : basetsd.SIZE_T;
uFlags : windef.UINT) return windef.HGLOBAL;
pragma Import (C, GlobalReAlloc, "GlobalReAlloc");
function GlobalSize (hMem : windef.HGLOBAL) return basetsd.SIZE_T;
pragma Import (C, GlobalSize, "GlobalSize");
function GlobalFlags (hMem : windef.HGLOBAL) return windef.UINT;
pragma Import (C, GlobalFlags, "GlobalFlags");
function GlobalLock (hMem : windef.HGLOBAL) return windef.LPVOID;
pragma Import (C, GlobalLock, "GlobalLock");
function GlobalHandle (pMem : windef.LPCVOID) return windef.HGLOBAL;
pragma Import (C, GlobalHandle, "GlobalHandle");
function GlobalUnlock (hMem : windef.HGLOBAL) return windef.WINBOOL;
pragma Import (C, GlobalUnlock, "GlobalUnlock");
function GlobalFree (hMem : windef.HGLOBAL) return windef.HGLOBAL;
pragma Import (C, GlobalFree, "GlobalFree");
function GlobalCompact (dwMinFree : windef.DWORD) return basetsd.SIZE_T;
pragma Import (C, GlobalCompact, "GlobalCompact");
procedure GlobalFix (hMem : windef.HGLOBAL);
pragma Import (C, GlobalFix, "GlobalFix");
procedure GlobalUnfix (hMem : windef.HGLOBAL);
pragma Import (C, GlobalUnfix, "GlobalUnfix");
function GlobalWire (hMem : windef.HGLOBAL) return windef.LPVOID;
pragma Import (C, GlobalWire, "GlobalWire");
function GlobalUnWire (hMem : windef.HGLOBAL) return windef.WINBOOL;
pragma Import (C, GlobalUnWire, "GlobalUnWire");
procedure GlobalMemoryStatus (lpBuffer : access struct_MEMORYSTATUS);
pragma Import (C, GlobalMemoryStatus, "GlobalMemoryStatus");
type struct_MEMORYSTATUSEX;
type struct_MEMORYSTATUSEX is record
dwLength : aliased windef.DWORD;
dwMemoryLoad : aliased windef.DWORD;
ullTotalPhys : aliased winnt.DWORDLONG;
ullAvailPhys : aliased winnt.DWORDLONG;
ullTotalPageFile : aliased winnt.DWORDLONG;
ullAvailPageFile : aliased winnt.DWORDLONG;
ullTotalVirtual : aliased winnt.DWORDLONG;
ullAvailVirtual : aliased winnt.DWORDLONG;
ullAvailExtendedVirtual : aliased winnt.DWORDLONG;
end record;
pragma Convention (C_Pass_By_Copy, struct_MEMORYSTATUSEX);
type struct_MEMORYSTATUSEX_ptr is access all struct_MEMORYSTATUSEX;
for struct_MEMORYSTATUSEX_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_MEMORYSTATUSEX_ptr);
pragma Convention (C, struct_MEMORYSTATUSEX_ptr);
subtype MEMORYSTATUSEX is struct_MEMORYSTATUSEX;
subtype LPMEMORYSTATUSEX is struct_MEMORYSTATUSEX_ptr;
function GlobalMemoryStatusEx (lpBuffer : access struct_MEMORYSTATUSEX)
return windef.WINBOOL;
pragma Import (C, GlobalMemoryStatusEx, "GlobalMemoryStatusEx");
function LocalAlloc (uFlags : windef.UINT; uBytes : basetsd.SIZE_T)
return windef.HLOCAL;
pragma Import (C, LocalAlloc, "LocalAlloc");
function LocalReAlloc (hMem : windef.HLOCAL; uBytes : basetsd.SIZE_T;
uFlags : windef.UINT) return windef.HLOCAL;
pragma Import (C, LocalReAlloc, "LocalReAlloc");
function LocalLock (hMem : windef.HLOCAL) return windef.LPVOID;
pragma Import (C, LocalLock, "LocalLock");
function LocalHandle (pMem : windef.LPCVOID) return windef.HLOCAL;
pragma Import (C, LocalHandle, "LocalHandle");
function LocalUnlock (hMem : windef.HLOCAL) return windef.WINBOOL;
pragma Import (C, LocalUnlock, "LocalUnlock");
function LocalSize (hMem : windef.HLOCAL) return basetsd.SIZE_T;
pragma Import (C, LocalSize, "LocalSize");
function LocalFlags (hMem : windef.HLOCAL) return windef.UINT;
pragma Import (C, LocalFlags, "LocalFlags");
function LocalFree (hMem : windef.HLOCAL) return windef.HLOCAL;
pragma Import (C, LocalFree, "LocalFree");
function LocalShrink (hMem : windef.HLOCAL; cbNewSize : windef.UINT)
return basetsd.SIZE_T;
pragma Import (C, LocalShrink, "LocalShrink");
function LocalCompact (uMinFree : windef.UINT) return basetsd.SIZE_T;
pragma Import (C, LocalCompact, "LocalCompact");
function FlushInstructionCache (hProcess : winnt.HANDLE;
lpBaseAddress : windef.LPCVOID; dwSize : basetsd.SIZE_T)
return windef.WINBOOL;
pragma Import (C, FlushInstructionCache, "FlushInstructionCache");
function VirtualAlloc (lpAddress : windef.LPVOID; dwSize : basetsd.SIZE_T;
flAllocationType : windef.DWORD; flProtect : windef.DWORD)
return windef.LPVOID;
pragma Import (C, VirtualAlloc, "VirtualAlloc");
function VirtualFree (lpAddress : windef.LPVOID; dwSize : basetsd.SIZE_T;
dwFreeType : windef.DWORD) return windef.WINBOOL;
pragma Import (C, VirtualFree, "VirtualFree");
function VirtualProtect (lpAddress : windef.LPVOID;
dwSize : basetsd.SIZE_T; flNewProtect : windef.DWORD;
lpflOldProtect : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, VirtualProtect, "VirtualProtect");
function VirtualQuery (lpAddress : windef.LPCVOID;
lpBuffer : access winnt.struct_MEMORY_BASIC_INFORMATION;
dwLength : basetsd.SIZE_T) return basetsd.SIZE_T;
pragma Import (C, VirtualQuery, "VirtualQuery");
function VirtualAllocEx (hProcess : winnt.HANDLE;
lpAddress : windef.LPVOID; dwSize : basetsd.SIZE_T;
flAllocationType : windef.DWORD; flProtect : windef.DWORD)
return windef.LPVOID;
pragma Import (C, VirtualAllocEx, "VirtualAllocEx");
function GetWriteWatch (dwFlags : windef.DWORD;
lpBaseAddress : winnt.PVOID; dwRegionSize : basetsd.SIZE_T;
lpAddresses : access winnt.PVOID; lpdwCount : access basetsd.ULONG_PTR;
lpdwGranularity : access windef.ULONG) return windef.UINT;
pragma Import (C, GetWriteWatch, "GetWriteWatch");
function ResetWriteWatch (lpBaseAddress : windef.LPVOID;
dwRegionSize : basetsd.SIZE_T) return windef.UINT;
pragma Import (C, ResetWriteWatch, "ResetWriteWatch");
function GetLargePageMinimum return basetsd.SIZE_T;
pragma Import (C, GetLargePageMinimum, "GetLargePageMinimum");
function EnumSystemFirmwareTables (
FirmwareTableProviderSignature : windef.DWORD;
pFirmwareTableEnumBuffer : winnt.PVOID; BufferSize : windef.DWORD)
return windef.UINT;
pragma Import (C, EnumSystemFirmwareTables, "EnumSystemFirmwareTables");
function GetSystemFirmwareTable (
FirmwareTableProviderSignature : windef.DWORD;
FirmwareTableID : windef.DWORD; pFirmwareTableBuffer : winnt.PVOID;
BufferSize : windef.DWORD) return windef.UINT;
pragma Import (C, GetSystemFirmwareTable, "GetSystemFirmwareTable");
function VirtualFreeEx (hProcess : winnt.HANDLE;
lpAddress : windef.LPVOID; dwSize : basetsd.SIZE_T;
dwFreeType : windef.DWORD) return windef.WINBOOL;
pragma Import (C, VirtualFreeEx, "VirtualFreeEx");
function VirtualProtectEx (hProcess : winnt.HANDLE;
lpAddress : windef.LPVOID; dwSize : basetsd.SIZE_T;
flNewProtect : windef.DWORD; lpflOldProtect : access windef.DWORD)
return windef.WINBOOL;
pragma Import (C, VirtualProtectEx, "VirtualProtectEx");
function VirtualQueryEx (hProcess : winnt.HANDLE;
lpAddress : windef.LPCVOID;
lpBuffer : access winnt.struct_MEMORY_BASIC_INFORMATION;
dwLength : basetsd.SIZE_T) return basetsd.SIZE_T;
pragma Import (C, VirtualQueryEx, "VirtualQueryEx");
function HeapCreate (flOptions : windef.DWORD;
dwInitialSize : basetsd.SIZE_T; dwMaximumSize : basetsd.SIZE_T)
return winnt.HANDLE;
pragma Import (C, HeapCreate, "HeapCreate");
function HeapDestroy (hHeap : winnt.HANDLE) return windef.WINBOOL;
pragma Import (C, HeapDestroy, "HeapDestroy");
function HeapAlloc (hHeap : winnt.HANDLE; dwFlags : windef.DWORD;
dwBytes : basetsd.SIZE_T) return windef.LPVOID;
pragma Import (C, HeapAlloc, "HeapAlloc");
function HeapReAlloc (hHeap : winnt.HANDLE; dwFlags : windef.DWORD;
lpMem : windef.LPVOID; dwBytes : basetsd.SIZE_T) return windef.LPVOID;
pragma Import (C, HeapReAlloc, "HeapReAlloc");
function HeapFree (hHeap : winnt.HANDLE; dwFlags : windef.DWORD;
lpMem : windef.LPVOID) return windef.WINBOOL;
pragma Import (C, HeapFree, "HeapFree");
function HeapSize (hHeap : winnt.HANDLE; dwFlags : windef.DWORD;
lpMem : windef.LPCVOID) return basetsd.SIZE_T;
pragma Import (C, HeapSize, "HeapSize");
function HeapValidate (hHeap : winnt.HANDLE; dwFlags : windef.DWORD;
lpMem : windef.LPCVOID) return windef.WINBOOL;
pragma Import (C, HeapValidate, "HeapValidate");
function HeapCompact (hHeap : winnt.HANDLE; dwFlags : windef.DWORD)
return basetsd.SIZE_T;
pragma Import (C, HeapCompact, "HeapCompact");
function GetProcessHeap return winnt.HANDLE;
pragma Import (C, GetProcessHeap, "GetProcessHeap");
function GetProcessHeaps (NumberOfHeaps : windef.DWORD;
ProcessHeaps : access winnt.HANDLE) return windef.DWORD;
pragma Import (C, GetProcessHeaps, "GetProcessHeaps");
type struct_PROCESS_HEAP_ENTRY;
type struct_63b604b6 is record
hMem : aliased winnt.HANDLE;
dwReserved : aliased windef.DWORD_array (0 .. 2);
end record;
pragma Convention (C_Pass_By_Copy, struct_63b604b6);
type struct_a84abacf is record
dwCommittedSize : aliased windef.DWORD;
dwUnCommittedSize : aliased windef.DWORD;
lpFirstBlock : aliased windef.LPVOID;
lpLastBlock : aliased windef.LPVOID;
end record;
pragma Convention (C_Pass_By_Copy, struct_a84abacf);
type union_72c593ba (Unchecked_Tag : unsigned_int := 0) is record
case Unchecked_Tag is
when 0 =>
Block : struct_63b604b6;
when others =>
Region : struct_a84abacf;
end case;
end record;
pragma Unchecked_Union (union_72c593ba);
pragma Convention (C_Pass_By_Copy, union_72c593ba);
type struct_PROCESS_HEAP_ENTRY is record
lpData : aliased winnt.PVOID;
cbData : aliased windef.DWORD;
cbOverhead : aliased windef.BYTE;
iRegionIndex : aliased windef.BYTE;
wFlags : aliased windef.WORD;
anonymous_1 : aliased union_72c593ba;
end record;
pragma Convention (C_Pass_By_Copy, struct_PROCESS_HEAP_ENTRY);
type struct_PROCESS_HEAP_ENTRY_ptr is
access all struct_PROCESS_HEAP_ENTRY;
for struct_PROCESS_HEAP_ENTRY_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_PROCESS_HEAP_ENTRY_ptr);
pragma Convention (C, struct_PROCESS_HEAP_ENTRY_ptr);
subtype PROCESS_HEAP_ENTRY is struct_PROCESS_HEAP_ENTRY;
subtype LPPROCESS_HEAP_ENTRY is struct_PROCESS_HEAP_ENTRY_ptr;
subtype PPROCESS_HEAP_ENTRY is struct_PROCESS_HEAP_ENTRY_ptr;
function HeapLock (hHeap : winnt.HANDLE) return windef.WINBOOL;
pragma Import (C, HeapLock, "HeapLock");
function HeapUnlock (hHeap : winnt.HANDLE) return windef.WINBOOL;
pragma Import (C, HeapUnlock, "HeapUnlock");
function HeapWalk (hHeap : winnt.HANDLE;
lpEntry : access struct_PROCESS_HEAP_ENTRY) return windef.WINBOOL;
pragma Import (C, HeapWalk, "HeapWalk");
function HeapSetInformation (HeapHandle : winnt.HANDLE;
HeapInformationClass : winnt.HEAP_INFORMATION_CLASS;
HeapInformation : winnt.PVOID; HeapInformationLength : basetsd.SIZE_T)
return windef.WINBOOL;
pragma Import (C, HeapSetInformation, "HeapSetInformation");
function HeapQueryInformation (HeapHandle : winnt.HANDLE;
HeapInformationClass : winnt.HEAP_INFORMATION_CLASS;
HeapInformation : winnt.PVOID; HeapInformationLength : basetsd.SIZE_T;
ReturnLength : access basetsd.ULONG_PTR) return windef.WINBOOL;
pragma Import (C, HeapQueryInformation, "HeapQueryInformation");
function GetBinaryTypeA (lpApplicationName : access constant winnt.C_CHAR;
lpBinaryType : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, GetBinaryTypeA, "GetBinaryTypeA");
function GetBinaryTypeW (lpApplicationName : access constant winnt.WCHAR;
lpBinaryType : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, GetBinaryTypeW, "GetBinaryTypeW");
function GetShortPathNameA (lpszLongPath : access constant winnt.C_CHAR;
lpszShortPath : access winnt.C_CHAR; cchBuffer : windef.DWORD)
return windef.DWORD;
pragma Import (C, GetShortPathNameA, "GetShortPathNameA");
function GetShortPathNameW (lpszLongPath : access constant winnt.WCHAR;
lpszShortPath : access winnt.WCHAR; cchBuffer : windef.DWORD)
return windef.DWORD;
pragma Import (C, GetShortPathNameW, "GetShortPathNameW");
function GetLongPathNameA (lpszShortPath : access constant winnt.C_CHAR;
lpszLongPath : access winnt.C_CHAR; cchBuffer : windef.DWORD)
return windef.DWORD;
pragma Import (C, GetLongPathNameA, "GetLongPathNameA");
function GetLongPathNameW (lpszShortPath : access constant winnt.WCHAR;
lpszLongPath : access winnt.WCHAR; cchBuffer : windef.DWORD)
return windef.DWORD;
pragma Import (C, GetLongPathNameW, "GetLongPathNameW");
function GetProcessAffinityMask (hProcess : winnt.HANDLE;
lpProcessAffinityMask : access basetsd.ULONG_PTR;
lpSystemAffinityMask : access basetsd.ULONG_PTR) return windef.WINBOOL;
pragma Import (C, GetProcessAffinityMask, "GetProcessAffinityMask");
function SetProcessAffinityMask (hProcess : winnt.HANDLE;
dwProcessAffinityMask : basetsd.DWORD_PTR) return windef.WINBOOL;
pragma Import (C, SetProcessAffinityMask, "SetProcessAffinityMask");
function GetProcessDEPPolicy (hProcess : winnt.HANDLE;
lpFlags : access windef.DWORD; lpPermanent : access windef.WINBOOL)
return windef.WINBOOL;
pragma Import (C, GetProcessDEPPolicy, "GetProcessDEPPolicy");
function SetProcessDEPPolicy (dwFlags : windef.DWORD)
return windef.WINBOOL;
pragma Import (C, SetProcessDEPPolicy, "SetProcessDEPPolicy");
function GetProcessHandleCount (hProcess : winnt.HANDLE;
pdwHandleCount : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, GetProcessHandleCount, "GetProcessHandleCount");
function GetProcessTimes (hProcess : winnt.HANDLE;
lpCreationTime : access windef.struct_FILETIME;
lpExitTime : access windef.struct_FILETIME;
lpKernelTime : access windef.struct_FILETIME;
lpUserTime : access windef.struct_FILETIME) return windef.WINBOOL;
pragma Import (C, GetProcessTimes, "GetProcessTimes");
function GetProcessIoCounters (hProcess : winnt.HANDLE;
lpIoCounters : access winnt.IO_COUNTERS) return windef.WINBOOL;
pragma Import (C, GetProcessIoCounters, "GetProcessIoCounters");
function GetProcessWorkingSetSize (hProcess : winnt.HANDLE;
lpMinimumWorkingSetSize : access basetsd.ULONG_PTR;
lpMaximumWorkingSetSize : access basetsd.ULONG_PTR)
return windef.WINBOOL;
pragma Import (C, GetProcessWorkingSetSize, "GetProcessWorkingSetSize");
function GetProcessWorkingSetSizeEx (hProcess : winnt.HANDLE;
lpMinimumWorkingSetSize : access basetsd.ULONG_PTR;
lpMaximumWorkingSetSize : access basetsd.ULONG_PTR;
Flags : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, GetProcessWorkingSetSizeEx,
"GetProcessWorkingSetSizeEx");
function SetProcessWorkingSetSize (hProcess : winnt.HANDLE;
dwMinimumWorkingSetSize : basetsd.SIZE_T;
dwMaximumWorkingSetSize : basetsd.SIZE_T) return windef.WINBOOL;
pragma Import (C, SetProcessWorkingSetSize, "SetProcessWorkingSetSize");
function SetProcessWorkingSetSizeEx (hProcess : winnt.HANDLE;
dwMinimumWorkingSetSize : basetsd.SIZE_T;
dwMaximumWorkingSetSize : basetsd.SIZE_T; Flags : windef.DWORD)
return windef.WINBOOL;
pragma Import (C, SetProcessWorkingSetSizeEx,
"SetProcessWorkingSetSizeEx");
function OpenProcess (dwDesiredAccess : windef.DWORD;
bInheritHandle : windef.WINBOOL; dwProcessId : windef.DWORD)
return winnt.HANDLE;
pragma Import (C, OpenProcess, "OpenProcess");
function GetCurrentProcess return winnt.HANDLE;
pragma Import (C, GetCurrentProcess, "GetCurrentProcess");
function GetCurrentProcessId return windef.DWORD;
pragma Import (C, GetCurrentProcessId, "GetCurrentProcessId");
procedure ExitProcess (uExitCode : windef.UINT);
pragma No_Return (ExitProcess);
pragma Import (C, ExitProcess, "ExitProcess");
function TerminateProcess (hProcess : winnt.HANDLE;
uExitCode : windef.UINT) return windef.WINBOOL;
pragma Import (C, TerminateProcess, "TerminateProcess");
function GetExitCodeProcess (hProcess : winnt.HANDLE;
lpExitCode : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, GetExitCodeProcess, "GetExitCodeProcess");
procedure FatalExit (ExitCode : signed_int);
pragma Import (C, FatalExit, "FatalExit");
function GetEnvironmentStrings return winnt.LPCH;
pragma Import (C, GetEnvironmentStrings, "GetEnvironmentStrings");
function GetEnvironmentStringsW return winnt.LPWCH;
pragma Import (C, GetEnvironmentStringsW, "GetEnvironmentStringsW");
function SetEnvironmentStringsA (NewEnvironment : access winnt.C_CHAR)
return windef.WINBOOL;
pragma Import (C, SetEnvironmentStringsA, "SetEnvironmentStringsA");
function SetEnvironmentStringsW (NewEnvironment : access winnt.WCHAR)
return windef.WINBOOL;
pragma Import (C, SetEnvironmentStringsW, "SetEnvironmentStringsW");
function FreeEnvironmentStringsA (a1 : access winnt.C_CHAR)
return windef.WINBOOL;
pragma Import (C, FreeEnvironmentStringsA, "FreeEnvironmentStringsA");
function FreeEnvironmentStringsW (a1 : access winnt.WCHAR)
return windef.WINBOOL;
pragma Import (C, FreeEnvironmentStringsW, "FreeEnvironmentStringsW");
procedure RaiseException (dwExceptionCode : windef.DWORD;
dwExceptionFlags : windef.DWORD; nNumberOfArguments : windef.DWORD;
lpArguments : access constant basetsd.ULONG_PTR);
pragma Import (C, RaiseException, "RaiseException");
function UnhandledExceptionFilter (
ExceptionInfo : access winnt.struct_EXCEPTION_POINTERS)
return winnt.LONG;
pragma Import (C, UnhandledExceptionFilter, "UnhandledExceptionFilter");
type access_78f39ebe is access function (
ExceptionInfo : access winnt.struct_EXCEPTION_POINTERS)
return winnt.LONG;
pragma Convention (C, access_78f39ebe);
subtype PTOP_LEVEL_EXCEPTION_FILTER is access_78f39ebe;
subtype LPTOP_LEVEL_EXCEPTION_FILTER is PTOP_LEVEL_EXCEPTION_FILTER;
function SetUnhandledExceptionFilter (
lpTopLevelExceptionFilter : LPTOP_LEVEL_EXCEPTION_FILTER)
return LPTOP_LEVEL_EXCEPTION_FILTER;
pragma Import (C, SetUnhandledExceptionFilter,
"SetUnhandledExceptionFilter");
function CreateFiber (dwStackSize : basetsd.SIZE_T;
lpStartAddress : LPFIBER_START_ROUTINE; lpParameter : windef.LPVOID)
return windef.LPVOID;
pragma Import (C, CreateFiber, "CreateFiber");
function CreateFiberEx (dwStackCommitSize : basetsd.SIZE_T;
dwStackReserveSize : basetsd.SIZE_T; dwFlags : windef.DWORD;
lpStartAddress : LPFIBER_START_ROUTINE; lpParameter : windef.LPVOID)
return windef.LPVOID;
pragma Import (C, CreateFiberEx, "CreateFiberEx");
procedure DeleteFiber (lpFiber : windef.LPVOID);
pragma Import (C, DeleteFiber, "DeleteFiber");
function ConvertThreadToFiber (lpParameter : windef.LPVOID)
return windef.LPVOID;
pragma Import (C, ConvertThreadToFiber, "ConvertThreadToFiber");
function ConvertThreadToFiberEx (lpParameter : windef.LPVOID;
dwFlags : windef.DWORD) return windef.LPVOID;
pragma Import (C, ConvertThreadToFiberEx, "ConvertThreadToFiberEx");
function ConvertFiberToThread return windef.WINBOOL;
pragma Import (C, ConvertFiberToThread, "ConvertFiberToThread");
procedure SwitchToFiber (lpFiber : windef.LPVOID);
pragma Import (C, SwitchToFiber, "SwitchToFiber");
function SwitchToThread return windef.WINBOOL;
pragma Import (C, SwitchToThread, "SwitchToThread");
function CreateThread (
lpThreadAttributes : access struct_SECURITY_ATTRIBUTES;
dwStackSize : basetsd.SIZE_T; lpStartAddress : LPTHREAD_START_ROUTINE;
lpParameter : windef.LPVOID; dwCreationFlags : windef.DWORD;
lpThreadId : access windef.DWORD) return winnt.HANDLE;
pragma Import (C, CreateThread, "CreateThread");
function CreateRemoteThread (hProcess : winnt.HANDLE;
lpThreadAttributes : access struct_SECURITY_ATTRIBUTES;
dwStackSize : basetsd.SIZE_T; lpStartAddress : LPTHREAD_START_ROUTINE;
lpParameter : windef.LPVOID; dwCreationFlags : windef.DWORD;
lpThreadId : access windef.DWORD) return winnt.HANDLE;
pragma Import (C, CreateRemoteThread, "CreateRemoteThread");
function GetCurrentThread return winnt.HANDLE;
pragma Import (C, GetCurrentThread, "GetCurrentThread");
function GetCurrentThreadId return windef.DWORD;
pragma Import (C, GetCurrentThreadId, "GetCurrentThreadId");
function SetThreadStackGuarantee (StackSizeInBytes : access windef.ULONG)
return windef.WINBOOL;
pragma Import (C, SetThreadStackGuarantee, "SetThreadStackGuarantee");
function GetProcessIdOfThread (Thread : winnt.HANDLE) return windef.DWORD;
pragma Import (C, GetProcessIdOfThread, "GetProcessIdOfThread");
function GetThreadId (Thread : winnt.HANDLE) return windef.DWORD;
pragma Import (C, GetThreadId, "GetThreadId");
function GetProcessId (Process : winnt.HANDLE) return windef.DWORD;
pragma Import (C, GetProcessId, "GetProcessId");
function GetCurrentProcessorNumber return windef.DWORD;
pragma Import (C, GetCurrentProcessorNumber, "GetCurrentProcessorNumber");
function SetThreadAffinityMask (hThread : winnt.HANDLE;
dwThreadAffinityMask : basetsd.DWORD_PTR) return basetsd.DWORD_PTR;
pragma Import (C, SetThreadAffinityMask, "SetThreadAffinityMask");
function SetThreadIdealProcessor (hThread : winnt.HANDLE;
dwIdealProcessor : windef.DWORD) return windef.DWORD;
pragma Import (C, SetThreadIdealProcessor, "SetThreadIdealProcessor");
function SetProcessPriorityBoost (hProcess : winnt.HANDLE;
bDisablePriorityBoost : windef.WINBOOL) return windef.WINBOOL;
pragma Import (C, SetProcessPriorityBoost, "SetProcessPriorityBoost");
function GetProcessPriorityBoost (hProcess : winnt.HANDLE;
pDisablePriorityBoost : access windef.WINBOOL) return windef.WINBOOL;
pragma Import (C, GetProcessPriorityBoost, "GetProcessPriorityBoost");
function RequestWakeupLatency (latency : winnt.LATENCY_TIME)
return windef.WINBOOL;
pragma Import (C, RequestWakeupLatency, "RequestWakeupLatency");
function IsSystemResumeAutomatic return windef.WINBOOL;
pragma Import (C, IsSystemResumeAutomatic, "IsSystemResumeAutomatic");
function OpenThread (dwDesiredAccess : windef.DWORD;
bInheritHandle : windef.WINBOOL; dwThreadId : windef.DWORD)
return winnt.HANDLE;
pragma Import (C, OpenThread, "OpenThread");
function SetThreadPriority (hThread : winnt.HANDLE;
nPriority : signed_int) return windef.WINBOOL;
pragma Import (C, SetThreadPriority, "SetThreadPriority");
function SetThreadPriorityBoost (hThread : winnt.HANDLE;
bDisablePriorityBoost : windef.WINBOOL) return windef.WINBOOL;
pragma Import (C, SetThreadPriorityBoost, "SetThreadPriorityBoost");
function GetThreadPriorityBoost (hThread : winnt.HANDLE;
pDisablePriorityBoost : access windef.WINBOOL) return windef.WINBOOL;
pragma Import (C, GetThreadPriorityBoost, "GetThreadPriorityBoost");
function GetThreadPriority (hThread : winnt.HANDLE) return signed_int;
pragma Import (C, GetThreadPriority, "GetThreadPriority");
function GetThreadTimes (hThread : winnt.HANDLE;
lpCreationTime : access windef.struct_FILETIME;
lpExitTime : access windef.struct_FILETIME;
lpKernelTime : access windef.struct_FILETIME;
lpUserTime : access windef.struct_FILETIME) return windef.WINBOOL;
pragma Import (C, GetThreadTimes, "GetThreadTimes");
function GetThreadIOPendingFlag (hThread : winnt.HANDLE;
lpIOIsPending : access windef.WINBOOL) return windef.WINBOOL;
pragma Import (C, GetThreadIOPendingFlag, "GetThreadIOPendingFlag");
procedure ExitThread (dwExitCode : windef.DWORD);
pragma No_Return (ExitThread);
pragma Import (C, ExitThread, "ExitThread");
function TerminateThread (hThread : winnt.HANDLE;
dwExitCode : windef.DWORD) return windef.WINBOOL;
pragma Import (C, TerminateThread, "TerminateThread");
function GetExitCodeThread (hThread : winnt.HANDLE;
lpExitCode : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, GetExitCodeThread, "GetExitCodeThread");
function GetThreadSelectorEntry (hThread : winnt.HANDLE;
dwSelector : windef.DWORD; lpSelectorEntry : LPLDT_ENTRY)
return windef.WINBOOL;
pragma Import (C, GetThreadSelectorEntry, "GetThreadSelectorEntry");
function SetThreadExecutionState (esFlags : winnt.EXECUTION_STATE)
return winnt.EXECUTION_STATE;
pragma Import (C, SetThreadExecutionState, "SetThreadExecutionState");
function GetLastError return windef.DWORD;
pragma Import (C, GetLastError, "GetLastError");
procedure SetLastError (dwErrCode : windef.DWORD);
pragma Import (C, SetLastError, "SetLastError");
function GetOverlappedResult (hFile : winnt.HANDLE;
lpOverlapped : access struct_OVERLAPPED;
lpNumberOfBytesTransferred : access windef.DWORD;
bWait : windef.WINBOOL) return windef.WINBOOL;
pragma Import (C, GetOverlappedResult, "GetOverlappedResult");
function CreateIoCompletionPort (FileHandle : winnt.HANDLE;
ExistingCompletionPort : winnt.HANDLE;
CompletionKey : basetsd.ULONG_PTR;
NumberOfConcurrentThreads : windef.DWORD) return winnt.HANDLE;
pragma Import (C, CreateIoCompletionPort, "CreateIoCompletionPort");
function GetQueuedCompletionStatus (CompletionPort : winnt.HANDLE;
lpNumberOfBytesTransferred : access windef.DWORD;
lpCompletionKey : access unsigned_long_long;
lpOverlapped : access winbase.LPOVERLAPPED;
dwMilliseconds : windef.DWORD) return windef.WINBOOL;
pragma Import (C, GetQueuedCompletionStatus, "GetQueuedCompletionStatus");
function PostQueuedCompletionStatus (CompletionPort : winnt.HANDLE;
dwNumberOfBytesTransferred : windef.DWORD;
dwCompletionKey : basetsd.ULONG_PTR;
lpOverlapped : access struct_OVERLAPPED) return windef.WINBOOL;
pragma Import (C, PostQueuedCompletionStatus,
"PostQueuedCompletionStatus");
function SetErrorMode (uMode : windef.UINT) return windef.UINT;
pragma Import (C, SetErrorMode, "SetErrorMode");
function ReadProcessMemory (hProcess : winnt.HANDLE;
lpBaseAddress : windef.LPCVOID; lpBuffer : windef.LPVOID;
nSize : basetsd.SIZE_T; lpNumberOfBytesRead : access basetsd.SIZE_T)
return windef.WINBOOL;
pragma Import (C, ReadProcessMemory, "ReadProcessMemory");
function WriteProcessMemory (hProcess : winnt.HANDLE;
lpBaseAddress : windef.LPVOID; lpBuffer : windef.LPCVOID;
nSize : basetsd.SIZE_T; lpNumberOfBytesWritten : access basetsd.SIZE_T)
return windef.WINBOOL;
pragma Import (C, WriteProcessMemory, "WriteProcessMemory");
function GetThreadContext (hThread : winnt.HANDLE;
lpContext : access winnt.struct_CONTEXT) return windef.WINBOOL;
pragma Import (C, GetThreadContext, "GetThreadContext");
function SetThreadContext (hThread : winnt.HANDLE;
lpContext : access constant winnt.CONTEXT) return windef.WINBOOL;
pragma Import (C, SetThreadContext, "SetThreadContext");
function SuspendThread (hThread : winnt.HANDLE) return windef.DWORD;
pragma Import (C, SuspendThread, "SuspendThread");
function ResumeThread (hThread : winnt.HANDLE) return windef.DWORD;
pragma Import (C, ResumeThread, "ResumeThread");
type access_5721ea3c is access procedure (dwParam : basetsd.ULONG_PTR);
pragma Convention (C, access_5721ea3c);
subtype PAPCFUNC is access_5721ea3c;
function QueueUserAPC (pfnAPC : PAPCFUNC; hThread : winnt.HANDLE;
dwData : basetsd.ULONG_PTR) return windef.DWORD;
pragma Import (C, QueueUserAPC, "QueueUserAPC");
function IsDebuggerPresent return windef.WINBOOL;
pragma Import (C, IsDebuggerPresent, "IsDebuggerPresent");
function CheckRemoteDebuggerPresent (hProcess : winnt.HANDLE;
pbDebuggerPresent : access windef.WINBOOL) return windef.WINBOOL;
pragma Import (C, CheckRemoteDebuggerPresent,
"CheckRemoteDebuggerPresent");
procedure DebugBreak;
pragma Import (C, DebugBreak, "DebugBreak");
function WaitForDebugEvent (lpDebugEvent : access struct_DEBUG_EVENT;
dwMilliseconds : windef.DWORD) return windef.WINBOOL;
pragma Import (C, WaitForDebugEvent, "WaitForDebugEvent");
function ContinueDebugEvent (dwProcessId : windef.DWORD;
dwThreadId : windef.DWORD; dwContinueStatus : windef.DWORD)
return windef.WINBOOL;
pragma Import (C, ContinueDebugEvent, "ContinueDebugEvent");
function DebugActiveProcess (dwProcessId : windef.DWORD)
return windef.WINBOOL;
pragma Import (C, DebugActiveProcess, "DebugActiveProcess");
function DebugActiveProcessStop (dwProcessId : windef.DWORD)
return windef.WINBOOL;
pragma Import (C, DebugActiveProcessStop, "DebugActiveProcessStop");
function DebugSetProcessKillOnExit (KillOnExit : windef.WINBOOL)
return windef.WINBOOL;
pragma Import (C, DebugSetProcessKillOnExit, "DebugSetProcessKillOnExit");
function DebugBreakProcess (Process : winnt.HANDLE) return windef.WINBOOL;
pragma Import (C, DebugBreakProcess, "DebugBreakProcess");
procedure InitializeCriticalSection (
lpCriticalSection : access winnt.struct_RTL_CRITICAL_SECTION);
pragma Import (C, InitializeCriticalSection, "InitializeCriticalSection");
procedure EnterCriticalSection (
lpCriticalSection : access winnt.struct_RTL_CRITICAL_SECTION);
pragma Import (C, EnterCriticalSection, "EnterCriticalSection");
procedure LeaveCriticalSection (
lpCriticalSection : access winnt.struct_RTL_CRITICAL_SECTION);
pragma Import (C, LeaveCriticalSection, "LeaveCriticalSection");
function InitializeCriticalSectionAndSpinCount (
lpCriticalSection : access winnt.struct_RTL_CRITICAL_SECTION;
dwSpinCount : windef.DWORD) return windef.WINBOOL;
pragma Import (C, InitializeCriticalSectionAndSpinCount,
"InitializeCriticalSectionAndSpinCount");
function SetCriticalSectionSpinCount (
lpCriticalSection : access winnt.struct_RTL_CRITICAL_SECTION;
dwSpinCount : windef.DWORD) return windef.DWORD;
pragma Import (C, SetCriticalSectionSpinCount,
"SetCriticalSectionSpinCount");
function TryEnterCriticalSection (
lpCriticalSection : access winnt.struct_RTL_CRITICAL_SECTION)
return windef.WINBOOL;
pragma Import (C, TryEnterCriticalSection, "TryEnterCriticalSection");
procedure DeleteCriticalSection (
lpCriticalSection : access winnt.struct_RTL_CRITICAL_SECTION);
pragma Import (C, DeleteCriticalSection, "DeleteCriticalSection");
function SetEvent (hEvent : winnt.HANDLE) return windef.WINBOOL;
pragma Import (C, SetEvent, "SetEvent");
function ResetEvent (hEvent : winnt.HANDLE) return windef.WINBOOL;
pragma Import (C, ResetEvent, "ResetEvent");
function PulseEvent (hEvent : winnt.HANDLE) return windef.WINBOOL;
pragma Import (C, PulseEvent, "PulseEvent");
function ReleaseSemaphore (hSemaphore : winnt.HANDLE;
lReleaseCount : winnt.LONG; lpPreviousCount : access signed_long)
return windef.WINBOOL;
pragma Import (C, ReleaseSemaphore, "ReleaseSemaphore");
function ReleaseMutex (hMutex : winnt.HANDLE) return windef.WINBOOL;
pragma Import (C, ReleaseMutex, "ReleaseMutex");
function WaitForSingleObject (hHandle : winnt.HANDLE;
dwMilliseconds : windef.DWORD) return windef.DWORD;
pragma Import (C, WaitForSingleObject, "WaitForSingleObject");
function WaitForMultipleObjects (nCount : windef.DWORD;
lpHandles : access constant winnt.HANDLE; bWaitAll : windef.WINBOOL;
dwMilliseconds : windef.DWORD) return windef.DWORD;
pragma Import (C, WaitForMultipleObjects, "WaitForMultipleObjects");
procedure Sleep (dwMilliseconds : windef.DWORD);
pragma Import (C, Sleep, "Sleep");
function LoadResource (hModule : access windef.struct_HINSTANCE;
hResInfo : access windef.struct_HRSRC) return windef.HGLOBAL;
pragma Import (C, LoadResource, "LoadResource");
function SizeofResource (hModule : access windef.struct_HINSTANCE;
hResInfo : access windef.struct_HRSRC) return windef.DWORD;
pragma Import (C, SizeofResource, "SizeofResource");
function GlobalDeleteAtom (nAtom : windef.ATOM) return windef.ATOM;
pragma Import (C, GlobalDeleteAtom, "GlobalDeleteAtom");
function InitAtomTable (nSize : windef.DWORD) return windef.WINBOOL;
pragma Import (C, InitAtomTable, "InitAtomTable");
function DeleteAtom (nAtom : windef.ATOM) return windef.ATOM;
pragma Import (C, DeleteAtom, "DeleteAtom");
function SetHandleCount (uNumber : windef.UINT) return windef.UINT;
pragma Import (C, SetHandleCount, "SetHandleCount");
function GetLogicalDrives return windef.DWORD;
pragma Import (C, GetLogicalDrives, "GetLogicalDrives");
function LockFile (hFile : winnt.HANDLE; dwFileOffsetLow : windef.DWORD;
dwFileOffsetHigh : windef.DWORD;
nNumberOfBytesToLockLow : windef.DWORD;
nNumberOfBytesToLockHigh : windef.DWORD) return windef.WINBOOL;
pragma Import (C, LockFile, "LockFile");
function UnlockFile (hFile : winnt.HANDLE; dwFileOffsetLow : windef.DWORD;
dwFileOffsetHigh : windef.DWORD;
nNumberOfBytesToUnlockLow : windef.DWORD;
nNumberOfBytesToUnlockHigh : windef.DWORD) return windef.WINBOOL;
pragma Import (C, UnlockFile, "UnlockFile");
function LockFileEx (hFile : winnt.HANDLE; dwFlags : windef.DWORD;
dwReserved : windef.DWORD; nNumberOfBytesToLockLow : windef.DWORD;
nNumberOfBytesToLockHigh : windef.DWORD;
lpOverlapped : access struct_OVERLAPPED) return windef.WINBOOL;
pragma Import (C, LockFileEx, "LockFileEx");
function UnlockFileEx (hFile : winnt.HANDLE; dwReserved : windef.DWORD;
nNumberOfBytesToUnlockLow : windef.DWORD;
nNumberOfBytesToUnlockHigh : windef.DWORD;
lpOverlapped : access struct_OVERLAPPED) return windef.WINBOOL;
pragma Import (C, UnlockFileEx, "UnlockFileEx");
type struct_BY_HANDLE_FILE_INFORMATION;
type struct_BY_HANDLE_FILE_INFORMATION is record
dwFileAttributes : aliased windef.DWORD;
ftCreationTime : aliased windef.FILETIME;
ftLastAccessTime : aliased windef.FILETIME;
ftLastWriteTime : aliased windef.FILETIME;
dwVolumeSerialNumber : aliased windef.DWORD;
nFileSizeHigh : aliased windef.DWORD;
nFileSizeLow : aliased windef.DWORD;
nNumberOfLinks : aliased windef.DWORD;
nFileIndexHigh : aliased windef.DWORD;
nFileIndexLow : aliased windef.DWORD;
end record;
pragma Convention (C_Pass_By_Copy, struct_BY_HANDLE_FILE_INFORMATION);
type struct_BY_HANDLE_FILE_INFORMATION_ptr is
access all struct_BY_HANDLE_FILE_INFORMATION;
for struct_BY_HANDLE_FILE_INFORMATION_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_BY_HANDLE_FILE_INFORMATION_ptr);
pragma Convention (C, struct_BY_HANDLE_FILE_INFORMATION_ptr);
subtype BY_HANDLE_FILE_INFORMATION is struct_BY_HANDLE_FILE_INFORMATION;
subtype PBY_HANDLE_FILE_INFORMATION is
struct_BY_HANDLE_FILE_INFORMATION_ptr;
subtype LPBY_HANDLE_FILE_INFORMATION is
struct_BY_HANDLE_FILE_INFORMATION_ptr;
function GetFileInformationByHandle (hFile : winnt.HANDLE;
lpFileInformation : access struct_BY_HANDLE_FILE_INFORMATION)
return windef.WINBOOL;
pragma Import (C, GetFileInformationByHandle,
"GetFileInformationByHandle");
function GetFileType (hFile : winnt.HANDLE) return windef.DWORD;
pragma Import (C, GetFileType, "GetFileType");
function GetFileSize (hFile : winnt.HANDLE;
lpFileSizeHigh : access windef.DWORD) return windef.DWORD;
pragma Import (C, GetFileSize, "GetFileSize");
function GetFileSizeEx (hFile : winnt.HANDLE;
lpFileSize : access winnt.LARGE_INTEGER) return windef.WINBOOL;
pragma Import (C, GetFileSizeEx, "GetFileSizeEx");
function GetStdHandle (nStdHandle : windef.DWORD) return winnt.HANDLE;
pragma Import (C, GetStdHandle, "GetStdHandle");
function SetStdHandle (nStdHandle : windef.DWORD; hHandle : winnt.HANDLE)
return windef.WINBOOL;
pragma Import (C, SetStdHandle, "SetStdHandle");
function WriteFile (hFile : winnt.HANDLE; lpBuffer : windef.LPCVOID;
nNumberOfBytesToWrite : windef.DWORD;
lpNumberOfBytesWritten : access windef.DWORD;
lpOverlapped : access struct_OVERLAPPED) return windef.WINBOOL;
pragma Import (C, WriteFile, "WriteFile");
function ReadFile (hFile : winnt.HANDLE; lpBuffer : windef.LPVOID;
nNumberOfBytesToRead : windef.DWORD;
lpNumberOfBytesRead : access windef.DWORD;
lpOverlapped : access struct_OVERLAPPED) return windef.WINBOOL;
pragma Import (C, ReadFile, "ReadFile");
function FlushFileBuffers (hFile : winnt.HANDLE) return windef.WINBOOL;
pragma Import (C, FlushFileBuffers, "FlushFileBuffers");
function DeviceIoControl (hDevice : winnt.HANDLE;
dwIoControlCode : windef.DWORD; lpInBuffer : windef.LPVOID;
nInBufferSize : windef.DWORD; lpOutBuffer : windef.LPVOID;
nOutBufferSize : windef.DWORD; lpBytesReturned : access windef.DWORD;
lpOverlapped : access struct_OVERLAPPED) return windef.WINBOOL;
pragma Import (C, DeviceIoControl, "DeviceIoControl");
function RequestDeviceWakeup (hDevice : winnt.HANDLE)
return windef.WINBOOL;
pragma Import (C, RequestDeviceWakeup, "RequestDeviceWakeup");
function CancelDeviceWakeupRequest (hDevice : winnt.HANDLE)
return windef.WINBOOL;
pragma Import (C, CancelDeviceWakeupRequest, "CancelDeviceWakeupRequest");
function GetDevicePowerState (hDevice : winnt.HANDLE;
pfOn : access windef.WINBOOL) return windef.WINBOOL;
pragma Import (C, GetDevicePowerState, "GetDevicePowerState");
function SetMessageWaitingIndicator (hMsgIndicator : winnt.HANDLE;
ulMsgCount : windef.ULONG) return windef.WINBOOL;
pragma Import (C, SetMessageWaitingIndicator,
"SetMessageWaitingIndicator");
function SetEndOfFile (hFile : winnt.HANDLE) return windef.WINBOOL;
pragma Import (C, SetEndOfFile, "SetEndOfFile");
function SetFilePointer (hFile : winnt.HANDLE;
lDistanceToMove : winnt.LONG; lpDistanceToMoveHigh : access winnt.LONG;
dwMoveMethod : windef.DWORD) return windef.DWORD;
pragma Import (C, SetFilePointer, "SetFilePointer");
function SetFilePointerEx (hFile : winnt.HANDLE;
liDistanceToMove : winnt.LARGE_INTEGER;
lpNewFilePointer : access winnt.LARGE_INTEGER;
dwMoveMethod : windef.DWORD) return windef.WINBOOL;
pragma Import (C, SetFilePointerEx, "SetFilePointerEx");
function FindClose (hFindFile : winnt.HANDLE) return windef.WINBOOL;
pragma Import (C, FindClose, "FindClose");
function GetFileTime (hFile : winnt.HANDLE;
lpCreationTime : access windef.struct_FILETIME;
lpLastAccessTime : access windef.struct_FILETIME;
lpLastWriteTime : access windef.struct_FILETIME) return windef.WINBOOL;
pragma Import (C, GetFileTime, "GetFileTime");
function SetFileTime (hFile : winnt.HANDLE;
lpCreationTime : access constant windef.FILETIME;
lpLastAccessTime : access constant windef.FILETIME;
lpLastWriteTime : access constant windef.FILETIME)
return windef.WINBOOL;
pragma Import (C, SetFileTime, "SetFileTime");
function SetFileValidData (hFile : winnt.HANDLE;
ValidDataLength : winnt.LONGLONG) return windef.WINBOOL;
pragma Import (C, SetFileValidData, "SetFileValidData");
function SetFileShortNameA (hFile : winnt.HANDLE;
lpShortName : access constant winnt.C_CHAR) return windef.WINBOOL;
pragma Import (C, SetFileShortNameA, "SetFileShortNameA");
function SetFileShortNameW (hFile : winnt.HANDLE;
lpShortName : access constant winnt.WCHAR) return windef.WINBOOL;
pragma Import (C, SetFileShortNameW, "SetFileShortNameW");
function CloseHandle (hObject : winnt.HANDLE) return windef.WINBOOL;
pragma Import (C, CloseHandle, "CloseHandle");
function DuplicateHandle (hSourceProcessHandle : winnt.HANDLE;
hSourceHandle : winnt.HANDLE; hTargetProcessHandle : winnt.HANDLE;
lpTargetHandle : access void_ptr; dwDesiredAccess : windef.DWORD;
bInheritHandle : windef.WINBOOL; dwOptions : windef.DWORD)
return windef.WINBOOL;
pragma Import (C, DuplicateHandle, "DuplicateHandle");
function GetHandleInformation (hObject : winnt.HANDLE;
lpdwFlags : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, GetHandleInformation, "GetHandleInformation");
function SetHandleInformation (hObject : winnt.HANDLE;
dwMask : windef.DWORD; dwFlags : windef.DWORD) return windef.WINBOOL;
pragma Import (C, SetHandleInformation, "SetHandleInformation");
function LoadModule (lpModuleName : access constant winnt.C_CHAR;
lpParameterBlock : windef.LPVOID) return windef.DWORD;
pragma Import (C, LoadModule, "LoadModule");
function WinExec (lpCmdLine : access constant winnt.C_CHAR;
uCmdShow : windef.UINT) return windef.UINT;
pragma Import (C, WinExec, "WinExec");
function ClearCommBreak (hFile : winnt.HANDLE) return windef.WINBOOL;
pragma Import (C, ClearCommBreak, "ClearCommBreak");
function ClearCommError (hFile : winnt.HANDLE;
lpErrors : access windef.DWORD; lpStat : access struct_COMSTAT)
return windef.WINBOOL;
pragma Import (C, ClearCommError, "ClearCommError");
function SetupComm (hFile : winnt.HANDLE; dwInQueue : windef.DWORD;
dwOutQueue : windef.DWORD) return windef.WINBOOL;
pragma Import (C, SetupComm, "SetupComm");
function EscapeCommFunction (hFile : winnt.HANDLE; dwFunc : windef.DWORD)
return windef.WINBOOL;
pragma Import (C, EscapeCommFunction, "EscapeCommFunction");
function GetCommConfig (hCommDev : winnt.HANDLE;
lpCC : access struct_COMMCONFIG; lpdwSize : access windef.DWORD)
return windef.WINBOOL;
pragma Import (C, GetCommConfig, "GetCommConfig");
function GetCommMask (hFile : winnt.HANDLE;
lpEvtMask : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, GetCommMask, "GetCommMask");
function GetCommProperties (hFile : winnt.HANDLE;
lpCommProp : access struct_COMMPROP) return windef.WINBOOL;
pragma Import (C, GetCommProperties, "GetCommProperties");
function GetCommModemStatus (hFile : winnt.HANDLE;
lpModemStat : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, GetCommModemStatus, "GetCommModemStatus");
function GetCommState (hFile : winnt.HANDLE; lpDCB : access struct_DCB)
return windef.WINBOOL;
pragma Import (C, GetCommState, "GetCommState");
function GetCommTimeouts (hFile : winnt.HANDLE;
lpCommTimeouts : access struct_COMMTIMEOUTS) return windef.WINBOOL;
pragma Import (C, GetCommTimeouts, "GetCommTimeouts");
function PurgeComm (hFile : winnt.HANDLE; dwFlags : windef.DWORD)
return windef.WINBOOL;
pragma Import (C, PurgeComm, "PurgeComm");
function SetCommBreak (hFile : winnt.HANDLE) return windef.WINBOOL;
pragma Import (C, SetCommBreak, "SetCommBreak");
function SetCommConfig (hCommDev : winnt.HANDLE;
lpCC : access struct_COMMCONFIG; dwSize : windef.DWORD)
return windef.WINBOOL;
pragma Import (C, SetCommConfig, "SetCommConfig");
function SetCommMask (hFile : winnt.HANDLE; dwEvtMask : windef.DWORD)
return windef.WINBOOL;
pragma Import (C, SetCommMask, "SetCommMask");
function SetCommState (hFile : winnt.HANDLE; lpDCB : access struct_DCB)
return windef.WINBOOL;
pragma Import (C, SetCommState, "SetCommState");
function SetCommTimeouts (hFile : winnt.HANDLE;
lpCommTimeouts : access struct_COMMTIMEOUTS) return windef.WINBOOL;
pragma Import (C, SetCommTimeouts, "SetCommTimeouts");
function TransmitCommChar (hFile : winnt.HANDLE; cChar : char)
return windef.WINBOOL;
pragma Import (C, TransmitCommChar, "TransmitCommChar");
function WaitCommEvent (hFile : winnt.HANDLE;
lpEvtMask : access windef.DWORD;
lpOverlapped : access struct_OVERLAPPED) return windef.WINBOOL;
pragma Import (C, WaitCommEvent, "WaitCommEvent");
function SetTapePosition (hDevice : winnt.HANDLE;
dwPositionMethod : windef.DWORD; dwPartition : windef.DWORD;
dwOffsetLow : windef.DWORD; dwOffsetHigh : windef.DWORD;
bImmediate : windef.WINBOOL) return windef.DWORD;
pragma Import (C, SetTapePosition, "SetTapePosition");
function GetTapePosition (hDevice : winnt.HANDLE;
dwPositionType : windef.DWORD; lpdwPartition : access windef.DWORD;
lpdwOffsetLow : access windef.DWORD;
lpdwOffsetHigh : access windef.DWORD) return windef.DWORD;
pragma Import (C, GetTapePosition, "GetTapePosition");
function PrepareTape (hDevice : winnt.HANDLE; dwOperation : windef.DWORD;
bImmediate : windef.WINBOOL) return windef.DWORD;
pragma Import (C, PrepareTape, "PrepareTape");
function EraseTape (hDevice : winnt.HANDLE; dwEraseType : windef.DWORD;
bImmediate : windef.WINBOOL) return windef.DWORD;
pragma Import (C, EraseTape, "EraseTape");
function CreateTapePartition (hDevice : winnt.HANDLE;
dwPartitionMethod : windef.DWORD; dwCount : windef.DWORD;
dwSize : windef.DWORD) return windef.DWORD;
pragma Import (C, CreateTapePartition, "CreateTapePartition");
function WriteTapemark (hDevice : winnt.HANDLE;
dwTapemarkType : windef.DWORD; dwTapemarkCount : windef.DWORD;
bImmediate : windef.WINBOOL) return windef.DWORD;
pragma Import (C, WriteTapemark, "WriteTapemark");
function GetTapeStatus (hDevice : winnt.HANDLE) return windef.DWORD;
pragma Import (C, GetTapeStatus, "GetTapeStatus");
function GetTapeParameters (hDevice : winnt.HANDLE;
dwOperation : windef.DWORD; lpdwSize : access windef.DWORD;
lpTapeInformation : windef.LPVOID) return windef.DWORD;
pragma Import (C, GetTapeParameters, "GetTapeParameters");
function SetTapeParameters (hDevice : winnt.HANDLE;
dwOperation : windef.DWORD; lpTapeInformation : windef.LPVOID)
return windef.DWORD;
pragma Import (C, SetTapeParameters, "SetTapeParameters");
function Beep (dwFreq : windef.DWORD; dwDuration : windef.DWORD)
return windef.WINBOOL;
pragma Import (C, Beep, "Beep");
function MulDiv (nNumber : signed_int; nNumerator : signed_int;
nDenominator : signed_int) return signed_int;
pragma Import (C, MulDiv, "MulDiv");
procedure GetSystemTime (lpSystemTime : access struct_SYSTEMTIME);
pragma Import (C, GetSystemTime, "GetSystemTime");
procedure GetSystemTimeAsFileTime (
lpSystemTimeAsFileTime : access windef.struct_FILETIME);
pragma Import (C, GetSystemTimeAsFileTime, "GetSystemTimeAsFileTime");
function SetSystemTime (lpSystemTime : access constant SYSTEMTIME)
return windef.WINBOOL;
pragma Import (C, SetSystemTime, "SetSystemTime");
procedure GetLocalTime (lpSystemTime : access struct_SYSTEMTIME);
pragma Import (C, GetLocalTime, "GetLocalTime");
function SetLocalTime (lpSystemTime : access constant SYSTEMTIME)
return windef.WINBOOL;
pragma Import (C, SetLocalTime, "SetLocalTime");
procedure GetSystemInfo (lpSystemInfo : access struct_SYSTEM_INFO);
pragma Import (C, GetSystemInfo, "GetSystemInfo");
function SetSystemFileCacheSize (MinimumFileCacheSize : basetsd.SIZE_T;
MaximumFileCacheSize : basetsd.SIZE_T; Flags : windef.DWORD)
return windef.WINBOOL;
pragma Import (C, SetSystemFileCacheSize, "SetSystemFileCacheSize");
function GetSystemFileCacheSize (
lpMinimumFileCacheSize : access basetsd.ULONG_PTR;
lpMaximumFileCacheSize : access basetsd.ULONG_PTR;
lpFlags : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, GetSystemFileCacheSize, "GetSystemFileCacheSize");
function GetSystemRegistryQuota (pdwQuotaAllowed : access windef.DWORD;
pdwQuotaUsed : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, GetSystemRegistryQuota, "GetSystemRegistryQuota");
function GetSystemTimes (lpIdleTime : access windef.struct_FILETIME;
lpKernelTime : access windef.struct_FILETIME;
lpUserTime : access windef.struct_FILETIME) return windef.WINBOOL;
pragma Import (C, GetSystemTimes, "GetSystemTimes");
procedure GetNativeSystemInfo (lpSystemInfo : access struct_SYSTEM_INFO);
pragma Import (C, GetNativeSystemInfo, "GetNativeSystemInfo");
function IsProcessorFeaturePresent (ProcessorFeature : windef.DWORD)
return windef.WINBOOL;
pragma Import (C, IsProcessorFeaturePresent, "IsProcessorFeaturePresent");
type struct_TIME_ZONE_INFORMATION;
type struct_TIME_ZONE_INFORMATION is record
Bias : aliased winnt.LONG;
StandardName : aliased winnt.WCHAR_array (0 .. 31);
StandardDate : aliased SYSTEMTIME;
StandardBias : aliased winnt.LONG;
DaylightName : aliased winnt.WCHAR_array (0 .. 31);
DaylightDate : aliased SYSTEMTIME;
DaylightBias : aliased winnt.LONG;
end record;
pragma Convention (C_Pass_By_Copy, struct_TIME_ZONE_INFORMATION);
type struct_TIME_ZONE_INFORMATION_ptr is
access all struct_TIME_ZONE_INFORMATION;
for struct_TIME_ZONE_INFORMATION_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_TIME_ZONE_INFORMATION_ptr);
pragma Convention (C, struct_TIME_ZONE_INFORMATION_ptr);
type struct_TIME_ZONE_INFORMATION_const_ptr is
access constant struct_TIME_ZONE_INFORMATION;
for struct_TIME_ZONE_INFORMATION_const_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_TIME_ZONE_INFORMATION_const_ptr);
pragma Convention (C, struct_TIME_ZONE_INFORMATION_const_ptr);
subtype TIME_ZONE_INFORMATION is struct_TIME_ZONE_INFORMATION;
subtype TIME_ZONE_INFORMATION_const_ptr is
struct_TIME_ZONE_INFORMATION_const_ptr;
subtype PTIME_ZONE_INFORMATION is struct_TIME_ZONE_INFORMATION_ptr;
subtype LPTIME_ZONE_INFORMATION is struct_TIME_ZONE_INFORMATION_ptr;
function SystemTimeToTzSpecificLocalTime (
lpTimeZoneInformation : access struct_TIME_ZONE_INFORMATION;
lpUniversalTime : access struct_SYSTEMTIME;
lpLocalTime : access struct_SYSTEMTIME) return windef.WINBOOL;
pragma Import (C, SystemTimeToTzSpecificLocalTime,
"SystemTimeToTzSpecificLocalTime");
function TzSpecificLocalTimeToSystemTime (
lpTimeZoneInformation : access struct_TIME_ZONE_INFORMATION;
lpLocalTime : access struct_SYSTEMTIME;
lpUniversalTime : access struct_SYSTEMTIME) return windef.WINBOOL;
pragma Import (C, TzSpecificLocalTimeToSystemTime,
"TzSpecificLocalTimeToSystemTime");
function GetTimeZoneInformation (
lpTimeZoneInformation : access struct_TIME_ZONE_INFORMATION)
return windef.DWORD;
pragma Import (C, GetTimeZoneInformation, "GetTimeZoneInformation");
function SetTimeZoneInformation (
lpTimeZoneInformation : access constant TIME_ZONE_INFORMATION)
return windef.WINBOOL;
pragma Import (C, SetTimeZoneInformation, "SetTimeZoneInformation");
function SystemTimeToFileTime (lpSystemTime : access constant SYSTEMTIME;
lpFileTime : access windef.struct_FILETIME) return windef.WINBOOL;
pragma Import (C, SystemTimeToFileTime, "SystemTimeToFileTime");
function FileTimeToLocalFileTime (
lpFileTime : access constant windef.FILETIME;
lpLocalFileTime : access windef.struct_FILETIME) return windef.WINBOOL;
pragma Import (C, FileTimeToLocalFileTime, "FileTimeToLocalFileTime");
function LocalFileTimeToFileTime (
lpLocalFileTime : access constant windef.FILETIME;
lpFileTime : access windef.struct_FILETIME) return windef.WINBOOL;
pragma Import (C, LocalFileTimeToFileTime, "LocalFileTimeToFileTime");
function FileTimeToSystemTime (
lpFileTime : access constant windef.FILETIME;
lpSystemTime : access struct_SYSTEMTIME) return windef.WINBOOL;
pragma Import (C, FileTimeToSystemTime, "FileTimeToSystemTime");
function CompareFileTime (lpFileTime1 : access constant windef.FILETIME;
lpFileTime2 : access constant windef.FILETIME) return winnt.LONG;
pragma Import (C, CompareFileTime, "CompareFileTime");
function FileTimeToDosDateTime (
lpFileTime : access constant windef.FILETIME;
lpFatDate : access windef.WORD; lpFatTime : access windef.WORD)
return windef.WINBOOL;
pragma Import (C, FileTimeToDosDateTime, "FileTimeToDosDateTime");
function DosDateTimeToFileTime (wFatDate : windef.WORD;
wFatTime : windef.WORD; lpFileTime : access windef.struct_FILETIME)
return windef.WINBOOL;
pragma Import (C, DosDateTimeToFileTime, "DosDateTimeToFileTime");
function SetSystemTimeAdjustment (dwTimeAdjustment : windef.DWORD;
bTimeAdjustmentDisabled : windef.WINBOOL) return windef.WINBOOL;
pragma Import (C, SetSystemTimeAdjustment, "SetSystemTimeAdjustment");
function GetSystemTimeAdjustment (lpTimeAdjustment : access windef.DWORD;
lpTimeIncrement : access windef.DWORD;
lpTimeAdjustmentDisabled : access windef.WINBOOL)
return windef.WINBOOL;
pragma Import (C, GetSystemTimeAdjustment, "GetSystemTimeAdjustment");
function FormatMessageA (dwFlags : windef.DWORD;
lpSource : windef.LPCVOID; dwMessageId : windef.DWORD;
dwLanguageId : windef.DWORD; lpBuffer : access winnt.C_CHAR;
nSize : windef.DWORD; Arguments : access vadefs.va_list)
return windef.DWORD;
pragma Import (C, FormatMessageA, "FormatMessageA");
function FormatMessageW (dwFlags : windef.DWORD;
lpSource : windef.LPCVOID; dwMessageId : windef.DWORD;
dwLanguageId : windef.DWORD; lpBuffer : access winnt.WCHAR;
nSize : windef.DWORD; Arguments : access vadefs.va_list)
return windef.DWORD;
pragma Import (C, FormatMessageW, "FormatMessageW");
function GetTickCount return windef.DWORD;
pragma Import (C, GetTickCount, "GetTickCount");
function CreatePipe (hReadPipe : access winnt.HANDLE;
hWritePipe : access winnt.HANDLE;
lpPipeAttributes : access struct_SECURITY_ATTRIBUTES;
nSize : windef.DWORD) return windef.WINBOOL;
pragma Import (C, CreatePipe, "CreatePipe");
function ConnectNamedPipe (hNamedPipe : winnt.HANDLE;
lpOverlapped : access struct_OVERLAPPED) return windef.WINBOOL;
pragma Import (C, ConnectNamedPipe, "ConnectNamedPipe");
function DisconnectNamedPipe (hNamedPipe : winnt.HANDLE)
return windef.WINBOOL;
pragma Import (C, DisconnectNamedPipe, "DisconnectNamedPipe");
function SetNamedPipeHandleState (hNamedPipe : winnt.HANDLE;
lpMode : access windef.DWORD;
lpMaxCollectionCount : access windef.DWORD;
lpCollectDataTimeout : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, SetNamedPipeHandleState, "SetNamedPipeHandleState");
function GetNamedPipeInfo (hNamedPipe : winnt.HANDLE;
lpFlags : access windef.DWORD; lpOutBufferSize : access windef.DWORD;
lpInBufferSize : access windef.DWORD;
lpMaxInstances : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, GetNamedPipeInfo, "GetNamedPipeInfo");
function PeekNamedPipe (hNamedPipe : winnt.HANDLE;
lpBuffer : windef.LPVOID; nBufferSize : windef.DWORD;
lpBytesRead : access windef.DWORD;
lpTotalBytesAvail : access windef.DWORD;
lpBytesLeftThisMessage : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, PeekNamedPipe, "PeekNamedPipe");
function TransactNamedPipe (hNamedPipe : winnt.HANDLE;
lpInBuffer : windef.LPVOID; nInBufferSize : windef.DWORD;
lpOutBuffer : windef.LPVOID; nOutBufferSize : windef.DWORD;
lpBytesRead : access windef.DWORD;
lpOverlapped : access struct_OVERLAPPED) return windef.WINBOOL;
pragma Import (C, TransactNamedPipe, "TransactNamedPipe");
function CreateMailslotA (lpName : access constant winnt.C_CHAR;
nMaxMessageSize : windef.DWORD; lReadTimeout : windef.DWORD;
lpSecurityAttributes : access struct_SECURITY_ATTRIBUTES)
return winnt.HANDLE;
pragma Import (C, CreateMailslotA, "CreateMailslotA");
function CreateMailslotW (lpName : access constant winnt.WCHAR;
nMaxMessageSize : windef.DWORD; lReadTimeout : windef.DWORD;
lpSecurityAttributes : access struct_SECURITY_ATTRIBUTES)
return winnt.HANDLE;
pragma Import (C, CreateMailslotW, "CreateMailslotW");
function GetMailslotInfo (hMailslot : winnt.HANDLE;
lpMaxMessageSize : access windef.DWORD;
lpNextSize : access windef.DWORD; lpMessageCount : access windef.DWORD;
lpReadTimeout : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, GetMailslotInfo, "GetMailslotInfo");
function SetMailslotInfo (hMailslot : winnt.HANDLE;
lReadTimeout : windef.DWORD) return windef.WINBOOL;
pragma Import (C, SetMailslotInfo, "SetMailslotInfo");
function MapViewOfFile (hFileMappingObject : winnt.HANDLE;
dwDesiredAccess : windef.DWORD; dwFileOffsetHigh : windef.DWORD;
dwFileOffsetLow : windef.DWORD; dwNumberOfBytesToMap : basetsd.SIZE_T)
return windef.LPVOID;
pragma Import (C, MapViewOfFile, "MapViewOfFile");
function FlushViewOfFile (lpBaseAddress : windef.LPCVOID;
dwNumberOfBytesToFlush : basetsd.SIZE_T) return windef.WINBOOL;
pragma Import (C, FlushViewOfFile, "FlushViewOfFile");
function UnmapViewOfFile (lpBaseAddress : windef.LPCVOID)
return windef.WINBOOL;
pragma Import (C, UnmapViewOfFile, "UnmapViewOfFile");
function EncryptFileA (lpFileName : access constant winnt.C_CHAR)
return windef.WINBOOL;
pragma Import (C, EncryptFileA, "EncryptFileA");
function EncryptFileW (lpFileName : access constant winnt.WCHAR)
return windef.WINBOOL;
pragma Import (C, EncryptFileW, "EncryptFileW");
function DecryptFileA (lpFileName : access constant winnt.C_CHAR;
dwReserved : windef.DWORD) return windef.WINBOOL;
pragma Import (C, DecryptFileA, "DecryptFileA");
function DecryptFileW (lpFileName : access constant winnt.WCHAR;
dwReserved : windef.DWORD) return windef.WINBOOL;
pragma Import (C, DecryptFileW, "DecryptFileW");
function FileEncryptionStatusA (lpFileName : access constant winnt.C_CHAR;
lpStatus : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, FileEncryptionStatusA, "FileEncryptionStatusA");
function FileEncryptionStatusW (lpFileName : access constant winnt.WCHAR;
lpStatus : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, FileEncryptionStatusW, "FileEncryptionStatusW");
type access_caa279d4 is access function (pbData : access windef.BYTE;
pvCallbackContext : winnt.PVOID; ulLength : windef.ULONG)
return windef.DWORD;
pragma Convention (C, access_caa279d4);
subtype PFE_EXPORT_FUNC is access_caa279d4;
type access_89013870 is access function (pbData : access windef.BYTE;
pvCallbackContext : winnt.PVOID; ulLength : access windef.ULONG)
return windef.DWORD;
pragma Convention (C, access_89013870);
subtype PFE_IMPORT_FUNC is access_89013870;
function OpenEncryptedFileRawA (lpFileName : access constant winnt.C_CHAR;
ulFlags : windef.ULONG; pvContext : access winnt.PVOID)
return windef.DWORD;
pragma Import (C, OpenEncryptedFileRawA, "OpenEncryptedFileRawA");
function OpenEncryptedFileRawW (lpFileName : access constant winnt.WCHAR;
ulFlags : windef.ULONG; pvContext : access winnt.PVOID)
return windef.DWORD;
pragma Import (C, OpenEncryptedFileRawW, "OpenEncryptedFileRawW");
function ReadEncryptedFileRaw (pfExportCallback : PFE_EXPORT_FUNC;
pvCallbackContext : winnt.PVOID; pvContext : winnt.PVOID)
return windef.DWORD;
pragma Import (C, ReadEncryptedFileRaw, "ReadEncryptedFileRaw");
function WriteEncryptedFileRaw (pfImportCallback : PFE_IMPORT_FUNC;
pvCallbackContext : winnt.PVOID; pvContext : winnt.PVOID)
return windef.DWORD;
pragma Import (C, WriteEncryptedFileRaw, "WriteEncryptedFileRaw");
procedure CloseEncryptedFileRaw (pvContext : winnt.PVOID);
pragma Import (C, CloseEncryptedFileRaw, "CloseEncryptedFileRaw");
function lstrcmpA (lpString1 : access constant winnt.C_CHAR;
lpString2 : access constant winnt.C_CHAR) return signed_int;
pragma Import (C, lstrcmpA, "lstrcmpA");
function lstrcmpW (lpString1 : access constant winnt.WCHAR;
lpString2 : access constant winnt.WCHAR) return signed_int;
pragma Import (C, lstrcmpW, "lstrcmpW");
function lstrcmpiA (lpString1 : access constant winnt.C_CHAR;
lpString2 : access constant winnt.C_CHAR) return signed_int;
pragma Import (C, lstrcmpiA, "lstrcmpiA");
function lstrcmpiW (lpString1 : access constant winnt.WCHAR;
lpString2 : access constant winnt.WCHAR) return signed_int;
pragma Import (C, lstrcmpiW, "lstrcmpiW");
function lstrcpynA (lpString1 : access winnt.C_CHAR;
lpString2 : access constant winnt.C_CHAR; iMaxLength : signed_int)
return winnt.LPSTR;
pragma Import (C, lstrcpynA, "lstrcpynA");
function lstrcpynW (lpString1 : access winnt.WCHAR;
lpString2 : access constant winnt.WCHAR; iMaxLength : signed_int)
return winnt.LPWSTR;
pragma Import (C, lstrcpynW, "lstrcpynW");
function lstrcpyA (lpString1 : access winnt.C_CHAR;
lpString2 : access constant winnt.C_CHAR) return winnt.LPSTR;
pragma Import (C, lstrcpyA, "lstrcpyA");
function lstrcpyW (lpString1 : access winnt.WCHAR;
lpString2 : access constant winnt.WCHAR) return winnt.LPWSTR;
pragma Import (C, lstrcpyW, "lstrcpyW");
function lstrcatA (lpString1 : access winnt.C_CHAR;
lpString2 : access constant winnt.C_CHAR) return winnt.LPSTR;
pragma Import (C, lstrcatA, "lstrcatA");
function lstrcatW (lpString1 : access winnt.WCHAR;
lpString2 : access constant winnt.WCHAR) return winnt.LPWSTR;
pragma Import (C, lstrcatW, "lstrcatW");
function lstrlenA (lpString : access constant winnt.C_CHAR)
return signed_int;
pragma Import (C, lstrlenA, "lstrlenA");
function lstrlenW (lpString : access constant winnt.WCHAR)
return signed_int;
pragma Import (C, lstrlenW, "lstrlenW");
function OpenFile (lpFileName : access constant winnt.C_CHAR;
lpReOpenBuff : access struct_OFSTRUCT; uStyle : windef.UINT)
return windef.HFILE;
pragma Import (C, OpenFile, "OpenFile");
function lopen (lpPathName : access constant winnt.C_CHAR;
iReadWrite : signed_int) return windef.HFILE;
pragma Import (C, lopen, "_lopen");
function lcreat (lpPathName : access constant winnt.C_CHAR;
iAttribute : signed_int) return windef.HFILE;
pragma Import (C, lcreat, "_lcreat");
function lread (hFile : windef.HFILE; lpBuffer : windef.LPVOID;
uBytes : windef.UINT) return windef.UINT;
pragma Import (C, lread, "_lread");
function lwrite (hFile : windef.HFILE;
lpBuffer : access constant winnt.C_CHAR; uBytes : windef.UINT)
return windef.UINT;
pragma Import (C, lwrite, "_lwrite");
function hread (hFile : windef.HFILE; lpBuffer : windef.LPVOID;
lBytes : signed_long) return signed_long;
pragma Import (C, hread, "_hread");
function hwrite (hFile : windef.HFILE;
lpBuffer : access constant winnt.C_CHAR; lBytes : signed_long)
return signed_long;
pragma Import (C, hwrite, "_hwrite");
function lclose (hFile : windef.HFILE) return windef.HFILE;
pragma Import (C, lclose, "_lclose");
function llseek (hFile : windef.HFILE; lOffset : winnt.LONG;
iOrigin : signed_int) return winnt.LONG;
pragma Import (C, llseek, "_llseek");
function IsTextUnicode (lpv : void_const_ptr; iSize : signed_int;
lpiResult : access signed_int) return windef.WINBOOL;
pragma Import (C, IsTextUnicode, "IsTextUnicode");
function FlsAlloc (lpCallback : winnt.PFLS_CALLBACK_FUNCTION)
return windef.DWORD;
pragma Import (C, FlsAlloc, "FlsAlloc");
function FlsGetValue (dwFlsIndex : windef.DWORD) return winnt.PVOID;
pragma Import (C, FlsGetValue, "FlsGetValue");
function FlsSetValue (dwFlsIndex : windef.DWORD; lpFlsData : winnt.PVOID)
return windef.WINBOOL;
pragma Import (C, FlsSetValue, "FlsSetValue");
function FlsFree (dwFlsIndex : windef.DWORD) return windef.WINBOOL;
pragma Import (C, FlsFree, "FlsFree");
function TlsAlloc return windef.DWORD;
pragma Import (C, TlsAlloc, "TlsAlloc");
function TlsGetValue (dwTlsIndex : windef.DWORD) return windef.LPVOID;
pragma Import (C, TlsGetValue, "TlsGetValue");
function TlsSetValue (dwTlsIndex : windef.DWORD;
lpTlsValue : windef.LPVOID) return windef.WINBOOL;
pragma Import (C, TlsSetValue, "TlsSetValue");
function TlsFree (dwTlsIndex : windef.DWORD) return windef.WINBOOL;
pragma Import (C, TlsFree, "TlsFree");
type access_bbc61e52 is access procedure (dwErrorCode : windef.DWORD;
dwNumberOfBytesTransfered : windef.DWORD;
lpOverlapped : access struct_OVERLAPPED);
pragma Convention (C, access_bbc61e52);
subtype LPOVERLAPPED_COMPLETION_ROUTINE is access_bbc61e52;
function SleepEx (dwMilliseconds : windef.DWORD;
bAlertable : windef.WINBOOL) return windef.DWORD;
pragma Import (C, SleepEx, "SleepEx");
function WaitForSingleObjectEx (hHandle : winnt.HANDLE;
dwMilliseconds : windef.DWORD; bAlertable : windef.WINBOOL)
return windef.DWORD;
pragma Import (C, WaitForSingleObjectEx, "WaitForSingleObjectEx");
function WaitForMultipleObjectsEx (nCount : windef.DWORD;
lpHandles : access constant winnt.HANDLE; bWaitAll : windef.WINBOOL;
dwMilliseconds : windef.DWORD; bAlertable : windef.WINBOOL)
return windef.DWORD;
pragma Import (C, WaitForMultipleObjectsEx, "WaitForMultipleObjectsEx");
function SignalObjectAndWait (hObjectToSignal : winnt.HANDLE;
hObjectToWaitOn : winnt.HANDLE; dwMilliseconds : windef.DWORD;
bAlertable : windef.WINBOOL) return windef.DWORD;
pragma Import (C, SignalObjectAndWait, "SignalObjectAndWait");
function ReadFileEx (hFile : winnt.HANDLE; lpBuffer : windef.LPVOID;
nNumberOfBytesToRead : windef.DWORD;
lpOverlapped : access struct_OVERLAPPED;
lpCompletionRoutine : LPOVERLAPPED_COMPLETION_ROUTINE)
return windef.WINBOOL;
pragma Import (C, ReadFileEx, "ReadFileEx");
function WriteFileEx (hFile : winnt.HANDLE; lpBuffer : windef.LPCVOID;
nNumberOfBytesToWrite : windef.DWORD;
lpOverlapped : access struct_OVERLAPPED;
lpCompletionRoutine : LPOVERLAPPED_COMPLETION_ROUTINE)
return windef.WINBOOL;
pragma Import (C, WriteFileEx, "WriteFileEx");
function BackupRead (hFile : winnt.HANDLE; lpBuffer : access windef.BYTE;
nNumberOfBytesToRead : windef.DWORD;
lpNumberOfBytesRead : access windef.DWORD; bAbort : windef.WINBOOL;
bProcessSecurity : windef.WINBOOL; lpContext : access windef.LPVOID)
return windef.WINBOOL;
pragma Import (C, BackupRead, "BackupRead");
function BackupSeek (hFile : winnt.HANDLE;
dwLowBytesToSeek : windef.DWORD; dwHighBytesToSeek : windef.DWORD;
lpdwLowByteSeeked : access windef.DWORD;
lpdwHighByteSeeked : access windef.DWORD;
lpContext : access windef.LPVOID) return windef.WINBOOL;
pragma Import (C, BackupSeek, "BackupSeek");
function BackupWrite (hFile : winnt.HANDLE; lpBuffer : access windef.BYTE;
nNumberOfBytesToWrite : windef.DWORD;
lpNumberOfBytesWritten : access windef.DWORD; bAbort : windef.WINBOOL;
bProcessSecurity : windef.WINBOOL; lpContext : access windef.LPVOID)
return windef.WINBOOL;
pragma Import (C, BackupWrite, "BackupWrite");
type struct_WIN32_STREAM_ID;
type struct_WIN32_STREAM_ID is record
dwStreamId : aliased windef.DWORD;
dwStreamAttributes : aliased windef.DWORD;
Size : aliased winnt.LARGE_INTEGER;
dwStreamNameSize : aliased windef.DWORD;
cStreamName : aliased winnt.WCHAR_array (0 .. 0);
end record;
pragma Convention (C_Pass_By_Copy, struct_WIN32_STREAM_ID);
type struct_WIN32_STREAM_ID_ptr is access all struct_WIN32_STREAM_ID;
for struct_WIN32_STREAM_ID_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_WIN32_STREAM_ID_ptr);
pragma Convention (C, struct_WIN32_STREAM_ID_ptr);
subtype WIN32_STREAM_ID is struct_WIN32_STREAM_ID;
subtype LPWIN32_STREAM_ID is struct_WIN32_STREAM_ID_ptr;
function ReadFileScatter (hFile : winnt.HANDLE;
aSegmentArray : access winnt.FILE_SEGMENT_ELEMENT;
nNumberOfBytesToRead : windef.DWORD; lpReserved : access windef.DWORD;
lpOverlapped : access struct_OVERLAPPED) return windef.WINBOOL;
pragma Import (C, ReadFileScatter, "ReadFileScatter");
function WriteFileGather (hFile : winnt.HANDLE;
aSegmentArray : access winnt.FILE_SEGMENT_ELEMENT;
nNumberOfBytesToWrite : windef.DWORD; lpReserved : access windef.DWORD;
lpOverlapped : access struct_OVERLAPPED) return windef.WINBOOL;
pragma Import (C, WriteFileGather, "WriteFileGather");
type struct_STARTUPINFOA;
type struct_STARTUPINFOA is record
cb : aliased windef.DWORD;
lpReserved : aliased winnt.LPSTR;
lpDesktop : aliased winnt.LPSTR;
lpTitle : aliased winnt.LPSTR;
dwX : aliased windef.DWORD;
dwY : aliased windef.DWORD;
dwXSize : aliased windef.DWORD;
dwYSize : aliased windef.DWORD;
dwXCountChars : aliased windef.DWORD;
dwYCountChars : aliased windef.DWORD;
dwFillAttribute : aliased windef.DWORD;
dwFlags : aliased windef.DWORD;
wShowWindow : aliased windef.WORD;
cbReserved2 : aliased windef.WORD;
lpReserved2 : aliased windef.LPBYTE;
hStdInput : aliased winnt.HANDLE;
hStdOutput : aliased winnt.HANDLE;
hStdError : aliased winnt.HANDLE;
end record;
pragma Convention (C_Pass_By_Copy, struct_STARTUPINFOA);
type struct_STARTUPINFOA_ptr is access all struct_STARTUPINFOA;
for struct_STARTUPINFOA_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_STARTUPINFOA_ptr);
pragma Convention (C, struct_STARTUPINFOA_ptr);
subtype STARTUPINFOA is struct_STARTUPINFOA;
subtype LPSTARTUPINFOA is struct_STARTUPINFOA_ptr;
type struct_STARTUPINFOW;
type struct_STARTUPINFOW is record
cb : aliased windef.DWORD;
lpReserved : aliased winnt.LPWSTR;
lpDesktop : aliased winnt.LPWSTR;
lpTitle : aliased winnt.LPWSTR;
dwX : aliased windef.DWORD;
dwY : aliased windef.DWORD;
dwXSize : aliased windef.DWORD;
dwYSize : aliased windef.DWORD;
dwXCountChars : aliased windef.DWORD;
dwYCountChars : aliased windef.DWORD;
dwFillAttribute : aliased windef.DWORD;
dwFlags : aliased windef.DWORD;
wShowWindow : aliased windef.WORD;
cbReserved2 : aliased windef.WORD;
lpReserved2 : aliased windef.LPBYTE;
hStdInput : aliased winnt.HANDLE;
hStdOutput : aliased winnt.HANDLE;
hStdError : aliased winnt.HANDLE;
end record;
pragma Convention (C_Pass_By_Copy, struct_STARTUPINFOW);
type struct_STARTUPINFOW_ptr is access all struct_STARTUPINFOW;
for struct_STARTUPINFOW_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_STARTUPINFOW_ptr);
pragma Convention (C, struct_STARTUPINFOW_ptr);
subtype STARTUPINFOW is struct_STARTUPINFOW;
subtype LPSTARTUPINFOW is struct_STARTUPINFOW_ptr;
subtype STARTUPINFO is STARTUPINFOW;
subtype LPSTARTUPINFO is LPSTARTUPINFOW;
type struct_WIN32_FIND_DATAA;
type struct_WIN32_FIND_DATAA is record
dwFileAttributes : aliased windef.DWORD;
ftCreationTime : aliased windef.FILETIME;
ftLastAccessTime : aliased windef.FILETIME;
ftLastWriteTime : aliased windef.FILETIME;
nFileSizeHigh : aliased windef.DWORD;
nFileSizeLow : aliased windef.DWORD;
dwReserved0 : aliased windef.DWORD;
dwReserved1 : aliased windef.DWORD;
cFileName : aliased winnt.C_CHAR_array (0 .. 259);
cAlternateFileName : aliased winnt.C_CHAR_array (0 .. 13);
end record;
pragma Convention (C_Pass_By_Copy, struct_WIN32_FIND_DATAA);
type struct_WIN32_FIND_DATAA_ptr is access all struct_WIN32_FIND_DATAA;
for struct_WIN32_FIND_DATAA_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_WIN32_FIND_DATAA_ptr);
pragma Convention (C, struct_WIN32_FIND_DATAA_ptr);
subtype WIN32_FIND_DATAA is struct_WIN32_FIND_DATAA;
subtype PWIN32_FIND_DATAA is struct_WIN32_FIND_DATAA_ptr;
subtype LPWIN32_FIND_DATAA is struct_WIN32_FIND_DATAA_ptr;
type struct_WIN32_FIND_DATAW;
type struct_WIN32_FIND_DATAW is record
dwFileAttributes : aliased windef.DWORD;
ftCreationTime : aliased windef.FILETIME;
ftLastAccessTime : aliased windef.FILETIME;
ftLastWriteTime : aliased windef.FILETIME;
nFileSizeHigh : aliased windef.DWORD;
nFileSizeLow : aliased windef.DWORD;
dwReserved0 : aliased windef.DWORD;
dwReserved1 : aliased windef.DWORD;
cFileName : aliased winnt.WCHAR_array (0 .. 259);
cAlternateFileName : aliased winnt.WCHAR_array (0 .. 13);
end record;
pragma Convention (C_Pass_By_Copy, struct_WIN32_FIND_DATAW);
type struct_WIN32_FIND_DATAW_ptr is access all struct_WIN32_FIND_DATAW;
for struct_WIN32_FIND_DATAW_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_WIN32_FIND_DATAW_ptr);
pragma Convention (C, struct_WIN32_FIND_DATAW_ptr);
subtype WIN32_FIND_DATAW is struct_WIN32_FIND_DATAW;
subtype PWIN32_FIND_DATAW is struct_WIN32_FIND_DATAW_ptr;
subtype LPWIN32_FIND_DATAW is struct_WIN32_FIND_DATAW_ptr;
subtype WIN32_FIND_DATA is WIN32_FIND_DATAW;
subtype PWIN32_FIND_DATA is PWIN32_FIND_DATAW;
subtype LPWIN32_FIND_DATA is LPWIN32_FIND_DATAW;
type struct_WIN32_FILE_ATTRIBUTE_DATA;
type struct_WIN32_FILE_ATTRIBUTE_DATA is record
dwFileAttributes : aliased windef.DWORD;
ftCreationTime : aliased windef.FILETIME;
ftLastAccessTime : aliased windef.FILETIME;
ftLastWriteTime : aliased windef.FILETIME;
nFileSizeHigh : aliased windef.DWORD;
nFileSizeLow : aliased windef.DWORD;
end record;
pragma Convention (C_Pass_By_Copy, struct_WIN32_FILE_ATTRIBUTE_DATA);
type struct_WIN32_FILE_ATTRIBUTE_DATA_ptr is
access all struct_WIN32_FILE_ATTRIBUTE_DATA;
for struct_WIN32_FILE_ATTRIBUTE_DATA_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_WIN32_FILE_ATTRIBUTE_DATA_ptr);
pragma Convention (C, struct_WIN32_FILE_ATTRIBUTE_DATA_ptr);
subtype WIN32_FILE_ATTRIBUTE_DATA is struct_WIN32_FILE_ATTRIBUTE_DATA;
subtype LPWIN32_FILE_ATTRIBUTE_DATA is
struct_WIN32_FILE_ATTRIBUTE_DATA_ptr;
function CreateMutexA (
lpMutexAttributes : access struct_SECURITY_ATTRIBUTES;
bInitialOwner : windef.WINBOOL; lpName : access constant winnt.C_CHAR)
return winnt.HANDLE;
pragma Import (C, CreateMutexA, "CreateMutexA");
function CreateMutexW (
lpMutexAttributes : access struct_SECURITY_ATTRIBUTES;
bInitialOwner : windef.WINBOOL; lpName : access constant winnt.WCHAR)
return winnt.HANDLE;
pragma Import (C, CreateMutexW, "CreateMutexW");
function OpenMutexA (dwDesiredAccess : windef.DWORD;
bInheritHandle : windef.WINBOOL; lpName : access constant winnt.C_CHAR)
return winnt.HANDLE;
pragma Import (C, OpenMutexA, "OpenMutexA");
function OpenMutexW (dwDesiredAccess : windef.DWORD;
bInheritHandle : windef.WINBOOL; lpName : access constant winnt.WCHAR)
return winnt.HANDLE;
pragma Import (C, OpenMutexW, "OpenMutexW");
function CreateEventA (
lpEventAttributes : access struct_SECURITY_ATTRIBUTES;
bManualReset : windef.WINBOOL; bInitialState : windef.WINBOOL;
lpName : access constant winnt.C_CHAR) return winnt.HANDLE;
pragma Import (C, CreateEventA, "CreateEventA");
function CreateEventW (
lpEventAttributes : access struct_SECURITY_ATTRIBUTES;
bManualReset : windef.WINBOOL; bInitialState : windef.WINBOOL;
lpName : access constant winnt.WCHAR) return winnt.HANDLE;
pragma Import (C, CreateEventW, "CreateEventW");
function OpenEventA (dwDesiredAccess : windef.DWORD;
bInheritHandle : windef.WINBOOL; lpName : access constant winnt.C_CHAR)
return winnt.HANDLE;
pragma Import (C, OpenEventA, "OpenEventA");
function OpenEventW (dwDesiredAccess : windef.DWORD;
bInheritHandle : windef.WINBOOL; lpName : access constant winnt.WCHAR)
return winnt.HANDLE;
pragma Import (C, OpenEventW, "OpenEventW");
function CreateSemaphoreA (
lpSemaphoreAttributes : access struct_SECURITY_ATTRIBUTES;
lInitialCount : winnt.LONG; lMaximumCount : winnt.LONG;
lpName : access constant winnt.C_CHAR) return winnt.HANDLE;
pragma Import (C, CreateSemaphoreA, "CreateSemaphoreA");
function CreateSemaphoreW (
lpSemaphoreAttributes : access struct_SECURITY_ATTRIBUTES;
lInitialCount : winnt.LONG; lMaximumCount : winnt.LONG;
lpName : access constant winnt.WCHAR) return winnt.HANDLE;
pragma Import (C, CreateSemaphoreW, "CreateSemaphoreW");
function OpenSemaphoreA (dwDesiredAccess : windef.DWORD;
bInheritHandle : windef.WINBOOL; lpName : access constant winnt.C_CHAR)
return winnt.HANDLE;
pragma Import (C, OpenSemaphoreA, "OpenSemaphoreA");
function OpenSemaphoreW (dwDesiredAccess : windef.DWORD;
bInheritHandle : windef.WINBOOL; lpName : access constant winnt.WCHAR)
return winnt.HANDLE;
pragma Import (C, OpenSemaphoreW, "OpenSemaphoreW");
type access_7cef0c42 is access procedure (
lpArgToCompletionRoutine : windef.LPVOID;
dwTimerLowValue : windef.DWORD; dwTimerHighValue : windef.DWORD);
pragma Convention (C, access_7cef0c42);
subtype PTIMERAPCROUTINE is access_7cef0c42;
function CreateWaitableTimerA (
lpTimerAttributes : access struct_SECURITY_ATTRIBUTES;
bManualReset : windef.WINBOOL;
lpTimerName : access constant winnt.C_CHAR) return winnt.HANDLE;
pragma Import (C, CreateWaitableTimerA, "CreateWaitableTimerA");
function CreateWaitableTimerW (
lpTimerAttributes : access struct_SECURITY_ATTRIBUTES;
bManualReset : windef.WINBOOL;
lpTimerName : access constant winnt.WCHAR) return winnt.HANDLE;
pragma Import (C, CreateWaitableTimerW, "CreateWaitableTimerW");
function OpenWaitableTimerA (dwDesiredAccess : windef.DWORD;
bInheritHandle : windef.WINBOOL;
lpTimerName : access constant winnt.C_CHAR) return winnt.HANDLE;
pragma Import (C, OpenWaitableTimerA, "OpenWaitableTimerA");
function OpenWaitableTimerW (dwDesiredAccess : windef.DWORD;
bInheritHandle : windef.WINBOOL;
lpTimerName : access constant winnt.WCHAR) return winnt.HANDLE;
pragma Import (C, OpenWaitableTimerW, "OpenWaitableTimerW");
function SetWaitableTimer (hTimer : winnt.HANDLE;
lpDueTime : access constant winnt.LARGE_INTEGER; lPeriod : winnt.LONG;
pfnCompletionRoutine : PTIMERAPCROUTINE;
lpArgToCompletionRoutine : windef.LPVOID; fResume : windef.WINBOOL)
return windef.WINBOOL;
pragma Import (C, SetWaitableTimer, "SetWaitableTimer");
function CancelWaitableTimer (hTimer : winnt.HANDLE)
return windef.WINBOOL;
pragma Import (C, CancelWaitableTimer, "CancelWaitableTimer");
function CreateFileMappingA (hFile : winnt.HANDLE;
lpFileMappingAttributes : access struct_SECURITY_ATTRIBUTES;
flProtect : windef.DWORD; dwMaximumSizeHigh : windef.DWORD;
dwMaximumSizeLow : windef.DWORD; lpName : access constant winnt.C_CHAR)
return winnt.HANDLE;
pragma Import (C, CreateFileMappingA, "CreateFileMappingA");
function CreateFileMappingW (hFile : winnt.HANDLE;
lpFileMappingAttributes : access struct_SECURITY_ATTRIBUTES;
flProtect : windef.DWORD; dwMaximumSizeHigh : windef.DWORD;
dwMaximumSizeLow : windef.DWORD; lpName : access constant winnt.WCHAR)
return winnt.HANDLE;
pragma Import (C, CreateFileMappingW, "CreateFileMappingW");
function OpenFileMappingA (dwDesiredAccess : windef.DWORD;
bInheritHandle : windef.WINBOOL; lpName : access constant winnt.C_CHAR)
return winnt.HANDLE;
pragma Import (C, OpenFileMappingA, "OpenFileMappingA");
function OpenFileMappingW (dwDesiredAccess : windef.DWORD;
bInheritHandle : windef.WINBOOL; lpName : access constant winnt.WCHAR)
return winnt.HANDLE;
pragma Import (C, OpenFileMappingW, "OpenFileMappingW");
function GetLogicalDriveStringsA (nBufferLength : windef.DWORD;
lpBuffer : access winnt.C_CHAR) return windef.DWORD;
pragma Import (C, GetLogicalDriveStringsA, "GetLogicalDriveStringsA");
function GetLogicalDriveStringsW (nBufferLength : windef.DWORD;
lpBuffer : access winnt.WCHAR) return windef.DWORD;
pragma Import (C, GetLogicalDriveStringsW, "GetLogicalDriveStringsW");
type enum_MEMORY_RESOURCE_NOTIFICATION_TYPE;
type enum_MEMORY_RESOURCE_NOTIFICATION_TYPE is (
LowMemoryResourceNotification, HighMemoryResourceNotification);
for enum_MEMORY_RESOURCE_NOTIFICATION_TYPE use (
LowMemoryResourceNotification => 0,
HighMemoryResourceNotification => 1);
pragma Convention (C, enum_MEMORY_RESOURCE_NOTIFICATION_TYPE);
subtype MEMORY_RESOURCE_NOTIFICATION_TYPE is
enum_MEMORY_RESOURCE_NOTIFICATION_TYPE;
function CreateMemoryResourceNotification (
NotificationType : MEMORY_RESOURCE_NOTIFICATION_TYPE)
return winnt.HANDLE;
pragma Import (C, CreateMemoryResourceNotification,
"CreateMemoryResourceNotification");
function QueryMemoryResourceNotification (
ResourceNotificationHandle : winnt.HANDLE;
ResourceState : access windef.WINBOOL) return windef.WINBOOL;
pragma Import (C, QueryMemoryResourceNotification,
"QueryMemoryResourceNotification");
function LoadLibraryA (lpLibFileName : access constant winnt.C_CHAR)
return windef.HMODULE;
pragma Import (C, LoadLibraryA, "LoadLibraryA");
function LoadLibraryW (lpLibFileName : access constant winnt.WCHAR)
return windef.HMODULE;
pragma Import (C, LoadLibraryW, "LoadLibraryW");
function LoadLibraryExA (lpLibFileName : access constant winnt.C_CHAR;
hFile : winnt.HANDLE; dwFlags : windef.DWORD) return windef.HMODULE;
pragma Import (C, LoadLibraryExA, "LoadLibraryExA");
function LoadLibraryExW (lpLibFileName : access constant winnt.WCHAR;
hFile : winnt.HANDLE; dwFlags : windef.DWORD) return windef.HMODULE;
pragma Import (C, LoadLibraryExW, "LoadLibraryExW");
function GetModuleFileNameA (hModule : access windef.struct_HINSTANCE;
lpFilename : access winnt.C_CHAR; nSize : windef.DWORD)
return windef.DWORD;
pragma Import (C, GetModuleFileNameA, "GetModuleFileNameA");
function GetModuleFileNameW (hModule : access windef.struct_HINSTANCE;
lpFilename : access winnt.WCHAR; nSize : windef.DWORD)
return windef.DWORD;
pragma Import (C, GetModuleFileNameW, "GetModuleFileNameW");
function GetModuleHandleA (lpModuleName : access constant winnt.C_CHAR)
return windef.HMODULE;
pragma Import (C, GetModuleHandleA, "GetModuleHandleA");
function GetModuleHandleW (lpModuleName : access constant winnt.WCHAR)
return windef.HMODULE;
pragma Import (C, GetModuleHandleW, "GetModuleHandleW");
type access_dcc5155b is access function (dwFlags : windef.DWORD;
lpModuleName : access constant winnt.C_CHAR;
phModule : access windef.HMODULE) return windef.WINBOOL;
pragma Convention (C, access_dcc5155b);
subtype PGET_MODULE_HANDLE_EXA is access_dcc5155b;
type access_68230c1a is access function (dwFlags : windef.DWORD;
lpModuleName : access constant winnt.WCHAR;
phModule : access windef.HMODULE) return windef.WINBOOL;
pragma Convention (C, access_68230c1a);
subtype PGET_MODULE_HANDLE_EXW is access_68230c1a;
function GetModuleHandleExA (dwFlags : windef.DWORD;
lpModuleName : access constant winnt.C_CHAR;
phModule : access windef.HMODULE) return windef.WINBOOL;
pragma Import (C, GetModuleHandleExA, "GetModuleHandleExA");
function GetModuleHandleExW (dwFlags : windef.DWORD;
lpModuleName : access constant winnt.WCHAR;
phModule : access windef.HMODULE) return windef.WINBOOL;
pragma Import (C, GetModuleHandleExW, "GetModuleHandleExW");
function NeedCurrentDirectoryForExePathA (
ExeName : access constant winnt.C_CHAR) return windef.WINBOOL;
pragma Import (C, NeedCurrentDirectoryForExePathA,
"NeedCurrentDirectoryForExePathA");
function NeedCurrentDirectoryForExePathW (
ExeName : access constant winnt.WCHAR) return windef.WINBOOL;
pragma Import (C, NeedCurrentDirectoryForExePathW,
"NeedCurrentDirectoryForExePathW");
function CreateProcessA (lpApplicationName : access constant winnt.C_CHAR;
lpCommandLine : access winnt.C_CHAR;
lpProcessAttributes : access struct_SECURITY_ATTRIBUTES;
lpThreadAttributes : access struct_SECURITY_ATTRIBUTES;
bInheritHandles : windef.WINBOOL; dwCreationFlags : windef.DWORD;
lpEnvironment : windef.LPVOID;
lpCurrentDirectory : access constant winnt.C_CHAR;
lpStartupInfo : access struct_STARTUPINFOA;
lpProcessInformation : access struct_PROCESS_INFORMATION)
return windef.WINBOOL;
pragma Import (C, CreateProcessA, "CreateProcessA");
function CreateProcessW (lpApplicationName : access constant winnt.WCHAR;
lpCommandLine : access winnt.WCHAR;
lpProcessAttributes : access struct_SECURITY_ATTRIBUTES;
lpThreadAttributes : access struct_SECURITY_ATTRIBUTES;
bInheritHandles : windef.WINBOOL; dwCreationFlags : windef.DWORD;
lpEnvironment : windef.LPVOID;
lpCurrentDirectory : access constant winnt.WCHAR;
lpStartupInfo : access struct_STARTUPINFOW;
lpProcessInformation : access struct_PROCESS_INFORMATION)
return windef.WINBOOL;
pragma Import (C, CreateProcessW, "CreateProcessW");
function AddLocalAlternateComputerNameA (
lpDnsFQHostname : access constant winnt.C_CHAR; ulFlags : windef.ULONG)
return windef.DWORD;
pragma Import (C, AddLocalAlternateComputerNameA,
"AddLocalAlternateComputerNameA");
function AddLocalAlternateComputerNameW (
lpDnsFQHostname : access constant winnt.WCHAR; ulFlags : windef.ULONG)
return windef.DWORD;
pragma Import (C, AddLocalAlternateComputerNameW,
"AddLocalAlternateComputerNameW");
function SetProcessShutdownParameters (dwLevel : windef.DWORD;
dwFlags : windef.DWORD) return windef.WINBOOL;
pragma Import (C, SetProcessShutdownParameters,
"SetProcessShutdownParameters");
function GetProcessShutdownParameters (lpdwLevel : access windef.DWORD;
lpdwFlags : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, GetProcessShutdownParameters,
"GetProcessShutdownParameters");
function GetProcessVersion (ProcessId : windef.DWORD) return windef.DWORD;
pragma Import (C, GetProcessVersion, "GetProcessVersion");
procedure FatalAppExitA (uAction : windef.UINT;
lpMessageText : access constant winnt.C_CHAR);
pragma Import (C, FatalAppExitA, "FatalAppExitA");
procedure FatalAppExitW (uAction : windef.UINT;
lpMessageText : access constant winnt.WCHAR);
pragma Import (C, FatalAppExitW, "FatalAppExitW");
procedure GetStartupInfoA (lpStartupInfo : access struct_STARTUPINFOA);
pragma Import (C, GetStartupInfoA, "GetStartupInfoA");
procedure GetStartupInfoW (lpStartupInfo : access struct_STARTUPINFOW);
pragma Import (C, GetStartupInfoW, "GetStartupInfoW");
function GetCommandLineA return winnt.LPSTR;
pragma Import (C, GetCommandLineA, "GetCommandLineA");
function GetCommandLineW return winnt.LPWSTR;
pragma Import (C, GetCommandLineW, "GetCommandLineW");
function GetEnvironmentVariableA (lpName : access constant winnt.C_CHAR;
lpBuffer : access winnt.C_CHAR; nSize : windef.DWORD)
return windef.DWORD;
pragma Import (C, GetEnvironmentVariableA, "GetEnvironmentVariableA");
function GetEnvironmentVariableW (lpName : access constant winnt.WCHAR;
lpBuffer : access winnt.WCHAR; nSize : windef.DWORD)
return windef.DWORD;
pragma Import (C, GetEnvironmentVariableW, "GetEnvironmentVariableW");
function SetEnvironmentVariableA (lpName : access constant winnt.C_CHAR;
lpValue : access constant winnt.C_CHAR) return windef.WINBOOL;
pragma Import (C, SetEnvironmentVariableA, "SetEnvironmentVariableA");
function SetEnvironmentVariableW (lpName : access constant winnt.WCHAR;
lpValue : access constant winnt.WCHAR) return windef.WINBOOL;
pragma Import (C, SetEnvironmentVariableW, "SetEnvironmentVariableW");
function ExpandEnvironmentStringsA (lpSrc : access constant winnt.C_CHAR;
lpDst : access winnt.C_CHAR; nSize : windef.DWORD) return windef.DWORD;
pragma Import (C, ExpandEnvironmentStringsA, "ExpandEnvironmentStringsA");
function ExpandEnvironmentStringsW (lpSrc : access constant winnt.WCHAR;
lpDst : access winnt.WCHAR; nSize : windef.DWORD) return windef.DWORD;
pragma Import (C, ExpandEnvironmentStringsW, "ExpandEnvironmentStringsW");
function GetFirmwareEnvironmentVariableA (
lpName : access constant winnt.C_CHAR;
lpGuid : access constant winnt.C_CHAR; pBuffer : winnt.PVOID;
nSize : windef.DWORD) return windef.DWORD;
pragma Import (C, GetFirmwareEnvironmentVariableA,
"GetFirmwareEnvironmentVariableA");
function GetFirmwareEnvironmentVariableW (
lpName : access constant winnt.WCHAR;
lpGuid : access constant winnt.WCHAR; pBuffer : winnt.PVOID;
nSize : windef.DWORD) return windef.DWORD;
pragma Import (C, GetFirmwareEnvironmentVariableW,
"GetFirmwareEnvironmentVariableW");
function SetFirmwareEnvironmentVariableA (
lpName : access constant winnt.C_CHAR;
lpGuid : access constant winnt.C_CHAR; pValue : winnt.PVOID;
nSize : windef.DWORD) return windef.WINBOOL;
pragma Import (C, SetFirmwareEnvironmentVariableA,
"SetFirmwareEnvironmentVariableA");
function SetFirmwareEnvironmentVariableW (
lpName : access constant winnt.WCHAR;
lpGuid : access constant winnt.WCHAR; pValue : winnt.PVOID;
nSize : windef.DWORD) return windef.WINBOOL;
pragma Import (C, SetFirmwareEnvironmentVariableW,
"SetFirmwareEnvironmentVariableW");
procedure OutputDebugStringA (
lpOutputString : access constant winnt.C_CHAR);
pragma Import (C, OutputDebugStringA, "OutputDebugStringA");
procedure OutputDebugStringW (
lpOutputString : access constant winnt.WCHAR);
pragma Import (C, OutputDebugStringW, "OutputDebugStringW");
function FindResourceA (hModule : access windef.struct_HINSTANCE;
lpName : access constant winnt.C_CHAR;
lpType : access constant winnt.C_CHAR) return windef.HRSRC;
pragma Import (C, FindResourceA, "FindResourceA");
function FindResourceW (hModule : access windef.struct_HINSTANCE;
lpName : access constant winnt.WCHAR;
lpType : access constant winnt.WCHAR) return windef.HRSRC;
pragma Import (C, FindResourceW, "FindResourceW");
function FindResourceExA (hModule : access windef.struct_HINSTANCE;
lpType : access constant winnt.C_CHAR;
lpName : access constant winnt.C_CHAR; wLanguage : windef.WORD)
return windef.HRSRC;
pragma Import (C, FindResourceExA, "FindResourceExA");
function FindResourceExW (hModule : access windef.struct_HINSTANCE;
lpType : access constant winnt.WCHAR;
lpName : access constant winnt.WCHAR; wLanguage : windef.WORD)
return windef.HRSRC;
pragma Import (C, FindResourceExW, "FindResourceExW");
type enum_DEP_SYSTEM_POLICY_TYPE;
type enum_DEP_SYSTEM_POLICY_TYPE is (AlwaysOff, AlwaysOn, OptIn, OptOut);
for enum_DEP_SYSTEM_POLICY_TYPE use (AlwaysOff => 0, AlwaysOn => 1,
OptIn => 2, OptOut => 3);
pragma Convention (C, enum_DEP_SYSTEM_POLICY_TYPE);
subtype DEP_SYSTEM_POLICY_TYPE is enum_DEP_SYSTEM_POLICY_TYPE;
function GetSystemDEPPolicy return DEP_SYSTEM_POLICY_TYPE;
pragma Import (C, GetSystemDEPPolicy, "GetSystemDEPPolicy");
type access_4e4e4eb2 is access function (
hModule : access windef.struct_HINSTANCE; lpType : access winnt.C_CHAR;
lParam : basetsd.LONG_PTR) return windef.WINBOOL;
pragma Convention (C, access_4e4e4eb2);
subtype ENUMRESTYPEPROCA is access_4e4e4eb2;
type access_eb2ee8a2 is access function (
hModule : access windef.struct_HINSTANCE; lpType : access winnt.WCHAR;
lParam : basetsd.LONG_PTR) return windef.WINBOOL;
pragma Convention (C, access_eb2ee8a2);
subtype ENUMRESTYPEPROCW is access_eb2ee8a2;
type access_89c895df is access function (
hModule : access windef.struct_HINSTANCE;
lpType : access constant winnt.C_CHAR; lpName : access winnt.C_CHAR;
lParam : basetsd.LONG_PTR) return windef.WINBOOL;
pragma Convention (C, access_89c895df);
subtype ENUMRESNAMEPROCA is access_89c895df;
type access_cd986f6d is access function (
hModule : access windef.struct_HINSTANCE;
lpType : access constant winnt.WCHAR; lpName : access winnt.WCHAR;
lParam : basetsd.LONG_PTR) return windef.WINBOOL;
pragma Convention (C, access_cd986f6d);
subtype ENUMRESNAMEPROCW is access_cd986f6d;
type access_ee11c478 is access function (
hModule : access windef.struct_HINSTANCE;
lpType : access constant winnt.C_CHAR;
lpName : access constant winnt.C_CHAR; wLanguage : windef.WORD;
lParam : basetsd.LONG_PTR) return windef.WINBOOL;
pragma Convention (C, access_ee11c478);
subtype ENUMRESLANGPROCA is access_ee11c478;
type access_c907b4c9 is access function (
hModule : access windef.struct_HINSTANCE;
lpType : access constant winnt.WCHAR;
lpName : access constant winnt.WCHAR; wLanguage : windef.WORD;
lParam : basetsd.LONG_PTR) return windef.WINBOOL;
pragma Convention (C, access_c907b4c9);
subtype ENUMRESLANGPROCW is access_c907b4c9;
function EnumResourceTypesA (hModule : access windef.struct_HINSTANCE;
lpEnumFunc : ENUMRESTYPEPROCA; lParam : basetsd.LONG_PTR)
return windef.WINBOOL;
pragma Import (C, EnumResourceTypesA, "EnumResourceTypesA");
function EnumResourceTypesW (hModule : access windef.struct_HINSTANCE;
lpEnumFunc : ENUMRESTYPEPROCW; lParam : basetsd.LONG_PTR)
return windef.WINBOOL;
pragma Import (C, EnumResourceTypesW, "EnumResourceTypesW");
function EnumResourceNamesA (hModule : access windef.struct_HINSTANCE;
lpType : access constant winnt.C_CHAR; lpEnumFunc : ENUMRESNAMEPROCA;
lParam : basetsd.LONG_PTR) return windef.WINBOOL;
pragma Import (C, EnumResourceNamesA, "EnumResourceNamesA");
function EnumResourceNamesW (hModule : access windef.struct_HINSTANCE;
lpType : access constant winnt.WCHAR; lpEnumFunc : ENUMRESNAMEPROCW;
lParam : basetsd.LONG_PTR) return windef.WINBOOL;
pragma Import (C, EnumResourceNamesW, "EnumResourceNamesW");
function EnumResourceLanguagesA (hModule : access windef.struct_HINSTANCE;
lpType : access constant winnt.C_CHAR;
lpName : access constant winnt.C_CHAR; lpEnumFunc : ENUMRESLANGPROCA;
lParam : basetsd.LONG_PTR) return windef.WINBOOL;
pragma Import (C, EnumResourceLanguagesA, "EnumResourceLanguagesA");
function EnumResourceLanguagesW (hModule : access windef.struct_HINSTANCE;
lpType : access constant winnt.WCHAR;
lpName : access constant winnt.WCHAR; lpEnumFunc : ENUMRESLANGPROCW;
lParam : basetsd.LONG_PTR) return windef.WINBOOL;
pragma Import (C, EnumResourceLanguagesW, "EnumResourceLanguagesW");
function BeginUpdateResourceA (pFileName : access constant winnt.C_CHAR;
bDeleteExistingResources : windef.WINBOOL) return winnt.HANDLE;
pragma Import (C, BeginUpdateResourceA, "BeginUpdateResourceA");
function BeginUpdateResourceW (pFileName : access constant winnt.WCHAR;
bDeleteExistingResources : windef.WINBOOL) return winnt.HANDLE;
pragma Import (C, BeginUpdateResourceW, "BeginUpdateResourceW");
function UpdateResourceA (hUpdate : winnt.HANDLE;
lpType : access constant winnt.C_CHAR;
lpName : access constant winnt.C_CHAR; wLanguage : windef.WORD;
lpData : windef.LPVOID; cb : windef.DWORD) return windef.WINBOOL;
pragma Import (C, UpdateResourceA, "UpdateResourceA");
function UpdateResourceW (hUpdate : winnt.HANDLE;
lpType : access constant winnt.WCHAR;
lpName : access constant winnt.WCHAR; wLanguage : windef.WORD;
lpData : windef.LPVOID; cb : windef.DWORD) return windef.WINBOOL;
pragma Import (C, UpdateResourceW, "UpdateResourceW");
function EndUpdateResourceA (hUpdate : winnt.HANDLE;
fDiscard : windef.WINBOOL) return windef.WINBOOL;
pragma Import (C, EndUpdateResourceA, "EndUpdateResourceA");
function EndUpdateResourceW (hUpdate : winnt.HANDLE;
fDiscard : windef.WINBOOL) return windef.WINBOOL;
pragma Import (C, EndUpdateResourceW, "EndUpdateResourceW");
function GlobalAddAtomA (lpString : access constant winnt.C_CHAR)
return windef.ATOM;
pragma Import (C, GlobalAddAtomA, "GlobalAddAtomA");
function GlobalAddAtomW (lpString : access constant winnt.WCHAR)
return windef.ATOM;
pragma Import (C, GlobalAddAtomW, "GlobalAddAtomW");
function GlobalFindAtomA (lpString : access constant winnt.C_CHAR)
return windef.ATOM;
pragma Import (C, GlobalFindAtomA, "GlobalFindAtomA");
function GlobalFindAtomW (lpString : access constant winnt.WCHAR)
return windef.ATOM;
pragma Import (C, GlobalFindAtomW, "GlobalFindAtomW");
function GlobalGetAtomNameA (nAtom : windef.ATOM;
lpBuffer : access winnt.C_CHAR; nSize : signed_int) return windef.UINT;
pragma Import (C, GlobalGetAtomNameA, "GlobalGetAtomNameA");
function GlobalGetAtomNameW (nAtom : windef.ATOM;
lpBuffer : access winnt.WCHAR; nSize : signed_int) return windef.UINT;
pragma Import (C, GlobalGetAtomNameW, "GlobalGetAtomNameW");
function AddAtomA (lpString : access constant winnt.C_CHAR)
return windef.ATOM;
pragma Import (C, AddAtomA, "AddAtomA");
function AddAtomW (lpString : access constant winnt.WCHAR)
return windef.ATOM;
pragma Import (C, AddAtomW, "AddAtomW");
function FindAtomA (lpString : access constant winnt.C_CHAR)
return windef.ATOM;
pragma Import (C, FindAtomA, "FindAtomA");
function FindAtomW (lpString : access constant winnt.WCHAR)
return windef.ATOM;
pragma Import (C, FindAtomW, "FindAtomW");
function GetAtomNameA (nAtom : windef.ATOM;
lpBuffer : access winnt.C_CHAR; nSize : signed_int) return windef.UINT;
pragma Import (C, GetAtomNameA, "GetAtomNameA");
function GetAtomNameW (nAtom : windef.ATOM; lpBuffer : access winnt.WCHAR;
nSize : signed_int) return windef.UINT;
pragma Import (C, GetAtomNameW, "GetAtomNameW");
function GetProfileIntA (lpAppName : access constant winnt.C_CHAR;
lpKeyName : access constant winnt.C_CHAR; nDefault : windef.INT)
return windef.UINT;
pragma Import (C, GetProfileIntA, "GetProfileIntA");
function GetProfileIntW (lpAppName : access constant winnt.WCHAR;
lpKeyName : access constant winnt.WCHAR; nDefault : windef.INT)
return windef.UINT;
pragma Import (C, GetProfileIntW, "GetProfileIntW");
function GetProfileStringA (lpAppName : access constant winnt.C_CHAR;
lpKeyName : access constant winnt.C_CHAR;
lpDefault : access constant winnt.C_CHAR;
lpReturnedString : access winnt.C_CHAR; nSize : windef.DWORD)
return windef.DWORD;
pragma Import (C, GetProfileStringA, "GetProfileStringA");
function GetProfileStringW (lpAppName : access constant winnt.WCHAR;
lpKeyName : access constant winnt.WCHAR;
lpDefault : access constant winnt.WCHAR;
lpReturnedString : access winnt.WCHAR; nSize : windef.DWORD)
return windef.DWORD;
pragma Import (C, GetProfileStringW, "GetProfileStringW");
function WriteProfileStringA (lpAppName : access constant winnt.C_CHAR;
lpKeyName : access constant winnt.C_CHAR;
lpString : access constant winnt.C_CHAR) return windef.WINBOOL;
pragma Import (C, WriteProfileStringA, "WriteProfileStringA");
function WriteProfileStringW (lpAppName : access constant winnt.WCHAR;
lpKeyName : access constant winnt.WCHAR;
lpString : access constant winnt.WCHAR) return windef.WINBOOL;
pragma Import (C, WriteProfileStringW, "WriteProfileStringW");
function GetProfileSectionA (lpAppName : access constant winnt.C_CHAR;
lpReturnedString : access winnt.C_CHAR; nSize : windef.DWORD)
return windef.DWORD;
pragma Import (C, GetProfileSectionA, "GetProfileSectionA");
function GetProfileSectionW (lpAppName : access constant winnt.WCHAR;
lpReturnedString : access winnt.WCHAR; nSize : windef.DWORD)
return windef.DWORD;
pragma Import (C, GetProfileSectionW, "GetProfileSectionW");
function WriteProfileSectionA (lpAppName : access constant winnt.C_CHAR;
lpString : access constant winnt.C_CHAR) return windef.WINBOOL;
pragma Import (C, WriteProfileSectionA, "WriteProfileSectionA");
function WriteProfileSectionW (lpAppName : access constant winnt.WCHAR;
lpString : access constant winnt.WCHAR) return windef.WINBOOL;
pragma Import (C, WriteProfileSectionW, "WriteProfileSectionW");
function GetPrivateProfileIntA (lpAppName : access constant winnt.C_CHAR;
lpKeyName : access constant winnt.C_CHAR; nDefault : windef.INT;
lpFileName : access constant winnt.C_CHAR) return windef.UINT;
pragma Import (C, GetPrivateProfileIntA, "GetPrivateProfileIntA");
function GetPrivateProfileIntW (lpAppName : access constant winnt.WCHAR;
lpKeyName : access constant winnt.WCHAR; nDefault : windef.INT;
lpFileName : access constant winnt.WCHAR) return windef.UINT;
pragma Import (C, GetPrivateProfileIntW, "GetPrivateProfileIntW");
function GetPrivateProfileStringA (
lpAppName : access constant winnt.C_CHAR;
lpKeyName : access constant winnt.C_CHAR;
lpDefault : access constant winnt.C_CHAR;
lpReturnedString : access winnt.C_CHAR; nSize : windef.DWORD;
lpFileName : access constant winnt.C_CHAR) return windef.DWORD;
pragma Import (C, GetPrivateProfileStringA, "GetPrivateProfileStringA");
function GetPrivateProfileStringW (
lpAppName : access constant winnt.WCHAR;
lpKeyName : access constant winnt.WCHAR;
lpDefault : access constant winnt.WCHAR;
lpReturnedString : access winnt.WCHAR; nSize : windef.DWORD;
lpFileName : access constant winnt.WCHAR) return windef.DWORD;
pragma Import (C, GetPrivateProfileStringW, "GetPrivateProfileStringW");
function WritePrivateProfileStringA (
lpAppName : access constant winnt.C_CHAR;
lpKeyName : access constant winnt.C_CHAR;
lpString : access constant winnt.C_CHAR;
lpFileName : access constant winnt.C_CHAR) return windef.WINBOOL;
pragma Import (C, WritePrivateProfileStringA,
"WritePrivateProfileStringA");
function WritePrivateProfileStringW (
lpAppName : access constant winnt.WCHAR;
lpKeyName : access constant winnt.WCHAR;
lpString : access constant winnt.WCHAR;
lpFileName : access constant winnt.WCHAR) return windef.WINBOOL;
pragma Import (C, WritePrivateProfileStringW,
"WritePrivateProfileStringW");
function GetPrivateProfileSectionA (
lpAppName : access constant winnt.C_CHAR;
lpReturnedString : access winnt.C_CHAR; nSize : windef.DWORD;
lpFileName : access constant winnt.C_CHAR) return windef.DWORD;
pragma Import (C, GetPrivateProfileSectionA, "GetPrivateProfileSectionA");
function GetPrivateProfileSectionW (
lpAppName : access constant winnt.WCHAR;
lpReturnedString : access winnt.WCHAR; nSize : windef.DWORD;
lpFileName : access constant winnt.WCHAR) return windef.DWORD;
pragma Import (C, GetPrivateProfileSectionW, "GetPrivateProfileSectionW");
function WritePrivateProfileSectionA (
lpAppName : access constant winnt.C_CHAR;
lpString : access constant winnt.C_CHAR;
lpFileName : access constant winnt.C_CHAR) return windef.WINBOOL;
pragma Import (C, WritePrivateProfileSectionA,
"WritePrivateProfileSectionA");
function WritePrivateProfileSectionW (
lpAppName : access constant winnt.WCHAR;
lpString : access constant winnt.WCHAR;
lpFileName : access constant winnt.WCHAR) return windef.WINBOOL;
pragma Import (C, WritePrivateProfileSectionW,
"WritePrivateProfileSectionW");
function GetPrivateProfileSectionNamesA (
lpszReturnBuffer : access winnt.C_CHAR; nSize : windef.DWORD;
lpFileName : access constant winnt.C_CHAR) return windef.DWORD;
pragma Import (C, GetPrivateProfileSectionNamesA,
"GetPrivateProfileSectionNamesA");
function GetPrivateProfileSectionNamesW (
lpszReturnBuffer : access winnt.WCHAR; nSize : windef.DWORD;
lpFileName : access constant winnt.WCHAR) return windef.DWORD;
pragma Import (C, GetPrivateProfileSectionNamesW,
"GetPrivateProfileSectionNamesW");
function GetPrivateProfileStructA (
lpszSection : access constant winnt.C_CHAR;
lpszKey : access constant winnt.C_CHAR; lpStruct : windef.LPVOID;
uSizeStruct : windef.UINT; szFile : access constant winnt.C_CHAR)
return windef.WINBOOL;
pragma Import (C, GetPrivateProfileStructA, "GetPrivateProfileStructA");
function GetPrivateProfileStructW (
lpszSection : access constant winnt.WCHAR;
lpszKey : access constant winnt.WCHAR; lpStruct : windef.LPVOID;
uSizeStruct : windef.UINT; szFile : access constant winnt.WCHAR)
return windef.WINBOOL;
pragma Import (C, GetPrivateProfileStructW, "GetPrivateProfileStructW");
function WritePrivateProfileStructA (
lpszSection : access constant winnt.C_CHAR;
lpszKey : access constant winnt.C_CHAR; lpStruct : windef.LPVOID;
uSizeStruct : windef.UINT; szFile : access constant winnt.C_CHAR)
return windef.WINBOOL;
pragma Import (C, WritePrivateProfileStructA,
"WritePrivateProfileStructA");
function WritePrivateProfileStructW (
lpszSection : access constant winnt.WCHAR;
lpszKey : access constant winnt.WCHAR; lpStruct : windef.LPVOID;
uSizeStruct : windef.UINT; szFile : access constant winnt.WCHAR)
return windef.WINBOOL;
pragma Import (C, WritePrivateProfileStructW,
"WritePrivateProfileStructW");
function GetDriveTypeA (lpRootPathName : access constant winnt.C_CHAR)
return windef.UINT;
pragma Import (C, GetDriveTypeA, "GetDriveTypeA");
function GetDriveTypeW (lpRootPathName : access constant winnt.WCHAR)
return windef.UINT;
pragma Import (C, GetDriveTypeW, "GetDriveTypeW");
function GetSystemDirectoryA (lpBuffer : access winnt.C_CHAR;
uSize : windef.UINT) return windef.UINT;
pragma Import (C, GetSystemDirectoryA, "GetSystemDirectoryA");
function GetSystemDirectoryW (lpBuffer : access winnt.WCHAR;
uSize : windef.UINT) return windef.UINT;
pragma Import (C, GetSystemDirectoryW, "GetSystemDirectoryW");
function GetTempPathA (nBufferLength : windef.DWORD;
lpBuffer : access winnt.C_CHAR) return windef.DWORD;
pragma Import (C, GetTempPathA, "GetTempPathA");
function GetTempPathW (nBufferLength : windef.DWORD;
lpBuffer : access winnt.WCHAR) return windef.DWORD;
pragma Import (C, GetTempPathW, "GetTempPathW");
function GetTempFileNameA (lpPathName : access constant winnt.C_CHAR;
lpPrefixString : access constant winnt.C_CHAR; uUnique : windef.UINT;
lpTempFileName : access winnt.C_CHAR) return windef.UINT;
pragma Import (C, GetTempFileNameA, "GetTempFileNameA");
function GetTempFileNameW (lpPathName : access constant winnt.WCHAR;
lpPrefixString : access constant winnt.WCHAR; uUnique : windef.UINT;
lpTempFileName : access winnt.WCHAR) return windef.UINT;
pragma Import (C, GetTempFileNameW, "GetTempFileNameW");
function GetWindowsDirectoryA (lpBuffer : access winnt.C_CHAR;
uSize : windef.UINT) return windef.UINT;
pragma Import (C, GetWindowsDirectoryA, "GetWindowsDirectoryA");
function GetWindowsDirectoryW (lpBuffer : access winnt.WCHAR;
uSize : windef.UINT) return windef.UINT;
pragma Import (C, GetWindowsDirectoryW, "GetWindowsDirectoryW");
function GetSystemWindowsDirectoryA (lpBuffer : access winnt.C_CHAR;
uSize : windef.UINT) return windef.UINT;
pragma Import (C, GetSystemWindowsDirectoryA,
"GetSystemWindowsDirectoryA");
function GetSystemWindowsDirectoryW (lpBuffer : access winnt.WCHAR;
uSize : windef.UINT) return windef.UINT;
pragma Import (C, GetSystemWindowsDirectoryW,
"GetSystemWindowsDirectoryW");
function GetSystemWow64DirectoryA (lpBuffer : access winnt.C_CHAR;
uSize : windef.UINT) return windef.UINT;
pragma Import (C, GetSystemWow64DirectoryA, "GetSystemWow64DirectoryA");
function GetSystemWow64DirectoryW (lpBuffer : access winnt.WCHAR;
uSize : windef.UINT) return windef.UINT;
pragma Import (C, GetSystemWow64DirectoryW, "GetSystemWow64DirectoryW");
function Wow64EnableWow64FsRedirection (
Wow64FsEnableRedirection : winnt.BOOLEAN) return winnt.BOOLEAN;
pragma Import (C, Wow64EnableWow64FsRedirection,
"Wow64EnableWow64FsRedirection");
function Wow64DisableWow64FsRedirection (OldValue : access winnt.PVOID)
return windef.WINBOOL;
pragma Import (C, Wow64DisableWow64FsRedirection,
"Wow64DisableWow64FsRedirection");
function Wow64RevertWow64FsRedirection (OlValue : winnt.PVOID)
return windef.WINBOOL;
pragma Import (C, Wow64RevertWow64FsRedirection,
"Wow64RevertWow64FsRedirection");
type access_f2a7f439 is access function (lpBuffer : access winnt.C_CHAR;
uSize : windef.UINT) return windef.UINT;
pragma Convention (C, access_f2a7f439);
subtype PGET_SYSTEM_WOW64_DIRECTORY_A is access_f2a7f439;
type access_0c922a5f is access function (lpBuffer : access winnt.WCHAR;
uSize : windef.UINT) return windef.UINT;
pragma Convention (C, access_0c922a5f);
subtype PGET_SYSTEM_WOW64_DIRECTORY_W is access_0c922a5f;
function SetCurrentDirectoryA (lpPathName : access constant winnt.C_CHAR)
return windef.WINBOOL;
pragma Import (C, SetCurrentDirectoryA, "SetCurrentDirectoryA");
function SetCurrentDirectoryW (lpPathName : access constant winnt.WCHAR)
return windef.WINBOOL;
pragma Import (C, SetCurrentDirectoryW, "SetCurrentDirectoryW");
function GetCurrentDirectoryA (nBufferLength : windef.DWORD;
lpBuffer : access winnt.C_CHAR) return windef.DWORD;
pragma Import (C, GetCurrentDirectoryA, "GetCurrentDirectoryA");
function GetCurrentDirectoryW (nBufferLength : windef.DWORD;
lpBuffer : access winnt.WCHAR) return windef.DWORD;
pragma Import (C, GetCurrentDirectoryW, "GetCurrentDirectoryW");
function SetDllDirectoryA (lpPathName : access constant winnt.C_CHAR)
return windef.WINBOOL;
pragma Import (C, SetDllDirectoryA, "SetDllDirectoryA");
function SetDllDirectoryW (lpPathName : access constant winnt.WCHAR)
return windef.WINBOOL;
pragma Import (C, SetDllDirectoryW, "SetDllDirectoryW");
function GetDllDirectoryA (nBufferLength : windef.DWORD;
lpBuffer : access winnt.C_CHAR) return windef.DWORD;
pragma Import (C, GetDllDirectoryA, "GetDllDirectoryA");
function GetDllDirectoryW (nBufferLength : windef.DWORD;
lpBuffer : access winnt.WCHAR) return windef.DWORD;
pragma Import (C, GetDllDirectoryW, "GetDllDirectoryW");
function GetDiskFreeSpaceA (lpRootPathName : access constant winnt.C_CHAR;
lpSectorsPerCluster : access windef.DWORD;
lpBytesPerSector : access windef.DWORD;
lpNumberOfFreeClusters : access windef.DWORD;
lpTotalNumberOfClusters : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, GetDiskFreeSpaceA, "GetDiskFreeSpaceA");
function GetDiskFreeSpaceW (lpRootPathName : access constant winnt.WCHAR;
lpSectorsPerCluster : access windef.DWORD;
lpBytesPerSector : access windef.DWORD;
lpNumberOfFreeClusters : access windef.DWORD;
lpTotalNumberOfClusters : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, GetDiskFreeSpaceW, "GetDiskFreeSpaceW");
function GetDiskFreeSpaceExA (
lpDirectoryName : access constant winnt.C_CHAR;
lpFreeBytesAvailableToCaller : access winnt.ULARGE_INTEGER;
lpTotalNumberOfBytes : access winnt.ULARGE_INTEGER;
lpTotalNumberOfFreeBytes : access winnt.ULARGE_INTEGER)
return windef.WINBOOL;
pragma Import (C, GetDiskFreeSpaceExA, "GetDiskFreeSpaceExA");
function GetDiskFreeSpaceExW (
lpDirectoryName : access constant winnt.WCHAR;
lpFreeBytesAvailableToCaller : access winnt.ULARGE_INTEGER;
lpTotalNumberOfBytes : access winnt.ULARGE_INTEGER;
lpTotalNumberOfFreeBytes : access winnt.ULARGE_INTEGER)
return windef.WINBOOL;
pragma Import (C, GetDiskFreeSpaceExW, "GetDiskFreeSpaceExW");
function CreateDirectoryA (lpPathName : access constant winnt.C_CHAR;
lpSecurityAttributes : access struct_SECURITY_ATTRIBUTES)
return windef.WINBOOL;
pragma Import (C, CreateDirectoryA, "CreateDirectoryA");
function CreateDirectoryW (lpPathName : access constant winnt.WCHAR;
lpSecurityAttributes : access struct_SECURITY_ATTRIBUTES)
return windef.WINBOOL;
pragma Import (C, CreateDirectoryW, "CreateDirectoryW");
function CreateDirectoryExA (
lpTemplateDirectory : access constant winnt.C_CHAR;
lpNewDirectory : access constant winnt.C_CHAR;
lpSecurityAttributes : access struct_SECURITY_ATTRIBUTES)
return windef.WINBOOL;
pragma Import (C, CreateDirectoryExA, "CreateDirectoryExA");
function CreateDirectoryExW (
lpTemplateDirectory : access constant winnt.WCHAR;
lpNewDirectory : access constant winnt.WCHAR;
lpSecurityAttributes : access struct_SECURITY_ATTRIBUTES)
return windef.WINBOOL;
pragma Import (C, CreateDirectoryExW, "CreateDirectoryExW");
function RemoveDirectoryA (lpPathName : access constant winnt.C_CHAR)
return windef.WINBOOL;
pragma Import (C, RemoveDirectoryA, "RemoveDirectoryA");
function RemoveDirectoryW (lpPathName : access constant winnt.WCHAR)
return windef.WINBOOL;
pragma Import (C, RemoveDirectoryW, "RemoveDirectoryW");
function GetFullPathNameA (lpFileName : access constant winnt.C_CHAR;
nBufferLength : windef.DWORD; lpBuffer : access winnt.C_CHAR;
lpFilePart : access winnt.LPSTR) return windef.DWORD;
pragma Import (C, GetFullPathNameA, "GetFullPathNameA");
function GetFullPathNameW (lpFileName : access constant winnt.WCHAR;
nBufferLength : windef.DWORD; lpBuffer : access winnt.WCHAR;
lpFilePart : access winnt.LPWSTR) return windef.DWORD;
pragma Import (C, GetFullPathNameW, "GetFullPathNameW");
function SetSearchPathMode (dwFlags : windef.DWORD) return windef.WINBOOL;
pragma Import (C, SetSearchPathMode, "SetSearchPathMode");
function DefineDosDeviceA (dwFlags : windef.DWORD;
lpDeviceName : access constant winnt.C_CHAR;
lpTargetPath : access constant winnt.C_CHAR) return windef.WINBOOL;
pragma Import (C, DefineDosDeviceA, "DefineDosDeviceA");
function DefineDosDeviceW (dwFlags : windef.DWORD;
lpDeviceName : access constant winnt.WCHAR;
lpTargetPath : access constant winnt.WCHAR) return windef.WINBOOL;
pragma Import (C, DefineDosDeviceW, "DefineDosDeviceW");
function QueryDosDeviceA (lpDeviceName : access constant winnt.C_CHAR;
lpTargetPath : access winnt.C_CHAR; ucchMax : windef.DWORD)
return windef.DWORD;
pragma Import (C, QueryDosDeviceA, "QueryDosDeviceA");
function QueryDosDeviceW (lpDeviceName : access constant winnt.WCHAR;
lpTargetPath : access winnt.WCHAR; ucchMax : windef.DWORD)
return windef.DWORD;
pragma Import (C, QueryDosDeviceW, "QueryDosDeviceW");
function CreateFileA (lpFileName : access constant winnt.C_CHAR;
dwDesiredAccess : windef.DWORD; dwShareMode : windef.DWORD;
lpSecurityAttributes : access struct_SECURITY_ATTRIBUTES;
dwCreationDisposition : windef.DWORD;
dwFlagsAndAttributes : windef.DWORD; hTemplateFile : winnt.HANDLE)
return winnt.HANDLE;
pragma Import (C, CreateFileA, "CreateFileA");
function CreateFileW (lpFileName : access constant winnt.WCHAR;
dwDesiredAccess : windef.DWORD; dwShareMode : windef.DWORD;
lpSecurityAttributes : access struct_SECURITY_ATTRIBUTES;
dwCreationDisposition : windef.DWORD;
dwFlagsAndAttributes : windef.DWORD; hTemplateFile : winnt.HANDLE)
return winnt.HANDLE;
pragma Import (C, CreateFileW, "CreateFileW");
function ReOpenFile (hOriginalFile : winnt.HANDLE;
dwDesiredAccess : windef.DWORD; dwShareMode : windef.DWORD;
dwFlagsAndAttributes : windef.DWORD) return winnt.HANDLE;
pragma Import (C, ReOpenFile, "ReOpenFile");
function SetFileAttributesA (lpFileName : access constant winnt.C_CHAR;
dwFileAttributes : windef.DWORD) return windef.WINBOOL;
pragma Import (C, SetFileAttributesA, "SetFileAttributesA");
function SetFileAttributesW (lpFileName : access constant winnt.WCHAR;
dwFileAttributes : windef.DWORD) return windef.WINBOOL;
pragma Import (C, SetFileAttributesW, "SetFileAttributesW");
function GetFileAttributesA (lpFileName : access constant winnt.C_CHAR)
return windef.DWORD;
pragma Import (C, GetFileAttributesA, "GetFileAttributesA");
function GetFileAttributesW (lpFileName : access constant winnt.WCHAR)
return windef.DWORD;
pragma Import (C, GetFileAttributesW, "GetFileAttributesW");
type enum_GET_FILEEX_INFO_LEVELS;
type enum_GET_FILEEX_INFO_LEVELS is (GetFileExInfoStandard,
GetFileExMaxInfoLevel);
for enum_GET_FILEEX_INFO_LEVELS use (GetFileExInfoStandard => 0,
GetFileExMaxInfoLevel => 1);
pragma Convention (C, enum_GET_FILEEX_INFO_LEVELS);
subtype GET_FILEEX_INFO_LEVELS is enum_GET_FILEEX_INFO_LEVELS;
function GetFileAttributesExA (lpFileName : access constant winnt.C_CHAR;
fInfoLevelId : GET_FILEEX_INFO_LEVELS;
lpFileInformation : windef.LPVOID) return windef.WINBOOL;
pragma Import (C, GetFileAttributesExA, "GetFileAttributesExA");
function GetFileAttributesExW (lpFileName : access constant winnt.WCHAR;
fInfoLevelId : GET_FILEEX_INFO_LEVELS;
lpFileInformation : windef.LPVOID) return windef.WINBOOL;
pragma Import (C, GetFileAttributesExW, "GetFileAttributesExW");
function GetCompressedFileSizeA (
lpFileName : access constant winnt.C_CHAR;
lpFileSizeHigh : access windef.DWORD) return windef.DWORD;
pragma Import (C, GetCompressedFileSizeA, "GetCompressedFileSizeA");
function GetCompressedFileSizeW (lpFileName : access constant winnt.WCHAR;
lpFileSizeHigh : access windef.DWORD) return windef.DWORD;
pragma Import (C, GetCompressedFileSizeW, "GetCompressedFileSizeW");
function DeleteFileA (lpFileName : access constant winnt.C_CHAR)
return windef.WINBOOL;
pragma Import (C, DeleteFileA, "DeleteFileA");
function DeleteFileW (lpFileName : access constant winnt.WCHAR)
return windef.WINBOOL;
pragma Import (C, DeleteFileW, "DeleteFileW");
function CheckNameLegalDOS8Dot3A (lpName : access constant winnt.C_CHAR;
lpOemName : access winnt.C_CHAR; OemNameSize : windef.DWORD;
pbNameContainsSpaces : access windef.WINBOOL;
pbNameLegal : access windef.WINBOOL) return windef.WINBOOL;
pragma Import (C, CheckNameLegalDOS8Dot3A, "CheckNameLegalDOS8Dot3A");
function CheckNameLegalDOS8Dot3W (lpName : access constant winnt.WCHAR;
lpOemName : access winnt.C_CHAR; OemNameSize : windef.DWORD;
pbNameContainsSpaces : access windef.WINBOOL;
pbNameLegal : access windef.WINBOOL) return windef.WINBOOL;
pragma Import (C, CheckNameLegalDOS8Dot3W, "CheckNameLegalDOS8Dot3W");
type enum_FINDEX_INFO_LEVELS;
type enum_FINDEX_INFO_LEVELS is (FindExInfoStandard,
FindExInfoMaxInfoLevel);
for enum_FINDEX_INFO_LEVELS use (FindExInfoStandard => 0,
FindExInfoMaxInfoLevel => 1);
pragma Convention (C, enum_FINDEX_INFO_LEVELS);
subtype FINDEX_INFO_LEVELS is enum_FINDEX_INFO_LEVELS;
type enum_FINDEX_SEARCH_OPS;
type enum_FINDEX_SEARCH_OPS is (FindExSearchNameMatch,
FindExSearchLimitToDirectories, FindExSearchLimitToDevices,
FindExSearchMaxSearchOp);
for enum_FINDEX_SEARCH_OPS use (FindExSearchNameMatch => 0,
FindExSearchLimitToDirectories => 1, FindExSearchLimitToDevices => 2,
FindExSearchMaxSearchOp => 3);
pragma Convention (C, enum_FINDEX_SEARCH_OPS);
subtype FINDEX_SEARCH_OPS is enum_FINDEX_SEARCH_OPS;
function FindFirstFileExA (lpFileName : access constant winnt.C_CHAR;
fInfoLevelId : FINDEX_INFO_LEVELS; lpFindFileData : windef.LPVOID;
fSearchOp : FINDEX_SEARCH_OPS; lpSearchFilter : windef.LPVOID;
dwAdditionalFlags : windef.DWORD) return winnt.HANDLE;
pragma Import (C, FindFirstFileExA, "FindFirstFileExA");
function FindFirstFileExW (lpFileName : access constant winnt.WCHAR;
fInfoLevelId : FINDEX_INFO_LEVELS; lpFindFileData : windef.LPVOID;
fSearchOp : FINDEX_SEARCH_OPS; lpSearchFilter : windef.LPVOID;
dwAdditionalFlags : windef.DWORD) return winnt.HANDLE;
pragma Import (C, FindFirstFileExW, "FindFirstFileExW");
function FindFirstFileA (lpFileName : access constant winnt.C_CHAR;
lpFindFileData : access struct_WIN32_FIND_DATAA) return winnt.HANDLE;
pragma Import (C, FindFirstFileA, "FindFirstFileA");
function FindFirstFileW (lpFileName : access constant winnt.WCHAR;
lpFindFileData : access struct_WIN32_FIND_DATAW) return winnt.HANDLE;
pragma Import (C, FindFirstFileW, "FindFirstFileW");
function FindNextFileA (hFindFile : winnt.HANDLE;
lpFindFileData : access struct_WIN32_FIND_DATAA) return windef.WINBOOL;
pragma Import (C, FindNextFileA, "FindNextFileA");
function FindNextFileW (hFindFile : winnt.HANDLE;
lpFindFileData : access struct_WIN32_FIND_DATAW) return windef.WINBOOL;
pragma Import (C, FindNextFileW, "FindNextFileW");
function SearchPathA (lpPath : access constant winnt.C_CHAR;
lpFileName : access constant winnt.C_CHAR;
lpExtension : access constant winnt.C_CHAR;
nBufferLength : windef.DWORD; lpBuffer : access winnt.C_CHAR;
lpFilePart : access winnt.LPSTR) return windef.DWORD;
pragma Import (C, SearchPathA, "SearchPathA");
function SearchPathW (lpPath : access constant winnt.WCHAR;
lpFileName : access constant winnt.WCHAR;
lpExtension : access constant winnt.WCHAR;
nBufferLength : windef.DWORD; lpBuffer : access winnt.WCHAR;
lpFilePart : access winnt.LPWSTR) return windef.DWORD;
pragma Import (C, SearchPathW, "SearchPathW");
function CopyFileA (lpExistingFileName : access constant winnt.C_CHAR;
lpNewFileName : access constant winnt.C_CHAR;
bFailIfExists : windef.WINBOOL) return windef.WINBOOL;
pragma Import (C, CopyFileA, "CopyFileA");
function CopyFileW (lpExistingFileName : access constant winnt.WCHAR;
lpNewFileName : access constant winnt.WCHAR;
bFailIfExists : windef.WINBOOL) return windef.WINBOOL;
pragma Import (C, CopyFileW, "CopyFileW");
type access_21eca440 is access function (
TotalFileSize : winnt.LARGE_INTEGER;
TotalBytesTransferred : winnt.LARGE_INTEGER;
StreamSize : winnt.LARGE_INTEGER;
StreamBytesTransferred : winnt.LARGE_INTEGER;
dwStreamNumber : windef.DWORD; dwCallbackReason : windef.DWORD;
hSourceFile : winnt.HANDLE; hDestinationFile : winnt.HANDLE;
lpData : windef.LPVOID) return windef.DWORD;
pragma Convention (C, access_21eca440);
subtype LPPROGRESS_ROUTINE is access_21eca440;
function CopyFileExA (lpExistingFileName : access constant winnt.C_CHAR;
lpNewFileName : access constant winnt.C_CHAR;
lpProgressRoutine : LPPROGRESS_ROUTINE; lpData : windef.LPVOID;
pbCancel : access windef.WINBOOL; dwCopyFlags : windef.DWORD)
return windef.WINBOOL;
pragma Import (C, CopyFileExA, "CopyFileExA");
function CopyFileExW (lpExistingFileName : access constant winnt.WCHAR;
lpNewFileName : access constant winnt.WCHAR;
lpProgressRoutine : LPPROGRESS_ROUTINE; lpData : windef.LPVOID;
pbCancel : access windef.WINBOOL; dwCopyFlags : windef.DWORD)
return windef.WINBOOL;
pragma Import (C, CopyFileExW, "CopyFileExW");
function MoveFileA (lpExistingFileName : access constant winnt.C_CHAR;
lpNewFileName : access constant winnt.C_CHAR) return windef.WINBOOL;
pragma Import (C, MoveFileA, "MoveFileA");
function MoveFileW (lpExistingFileName : access constant winnt.WCHAR;
lpNewFileName : access constant winnt.WCHAR) return windef.WINBOOL;
pragma Import (C, MoveFileW, "MoveFileW");
function MoveFileExA (lpExistingFileName : access constant winnt.C_CHAR;
lpNewFileName : access constant winnt.C_CHAR; dwFlags : windef.DWORD)
return windef.WINBOOL;
pragma Import (C, MoveFileExA, "MoveFileExA");
function MoveFileExW (lpExistingFileName : access constant winnt.WCHAR;
lpNewFileName : access constant winnt.WCHAR; dwFlags : windef.DWORD)
return windef.WINBOOL;
pragma Import (C, MoveFileExW, "MoveFileExW");
function MoveFileWithProgressA (
lpExistingFileName : access constant winnt.C_CHAR;
lpNewFileName : access constant winnt.C_CHAR;
lpProgressRoutine : LPPROGRESS_ROUTINE; lpData : windef.LPVOID;
dwFlags : windef.DWORD) return windef.WINBOOL;
pragma Import (C, MoveFileWithProgressA, "MoveFileWithProgressA");
function MoveFileWithProgressW (
lpExistingFileName : access constant winnt.WCHAR;
lpNewFileName : access constant winnt.WCHAR;
lpProgressRoutine : LPPROGRESS_ROUTINE; lpData : windef.LPVOID;
dwFlags : windef.DWORD) return windef.WINBOOL;
pragma Import (C, MoveFileWithProgressW, "MoveFileWithProgressW");
function ReplaceFileA (lpReplacedFileName : access constant winnt.C_CHAR;
lpReplacementFileName : access constant winnt.C_CHAR;
lpBackupFileName : access constant winnt.C_CHAR;
dwReplaceFlags : windef.DWORD; lpExclude : windef.LPVOID;
lpReserved : windef.LPVOID) return windef.WINBOOL;
pragma Import (C, ReplaceFileA, "ReplaceFileA");
function ReplaceFileW (lpReplacedFileName : access constant winnt.WCHAR;
lpReplacementFileName : access constant winnt.WCHAR;
lpBackupFileName : access constant winnt.WCHAR;
dwReplaceFlags : windef.DWORD; lpExclude : windef.LPVOID;
lpReserved : windef.LPVOID) return windef.WINBOOL;
pragma Import (C, ReplaceFileW, "ReplaceFileW");
function CreateHardLinkA (lpFileName : access constant winnt.C_CHAR;
lpExistingFileName : access constant winnt.C_CHAR;
lpSecurityAttributes : access struct_SECURITY_ATTRIBUTES)
return windef.WINBOOL;
pragma Import (C, CreateHardLinkA, "CreateHardLinkA");
function CreateHardLinkW (lpFileName : access constant winnt.WCHAR;
lpExistingFileName : access constant winnt.WCHAR;
lpSecurityAttributes : access struct_SECURITY_ATTRIBUTES)
return windef.WINBOOL;
pragma Import (C, CreateHardLinkW, "CreateHardLinkW");
type enum_STREAM_INFO_LEVELS;
type enum_STREAM_INFO_LEVELS is (FindStreamInfoStandard,
FindStreamInfoMaxInfoLevel);
for enum_STREAM_INFO_LEVELS use (FindStreamInfoStandard => 0,
FindStreamInfoMaxInfoLevel => 1);
pragma Convention (C, enum_STREAM_INFO_LEVELS);
subtype STREAM_INFO_LEVELS is enum_STREAM_INFO_LEVELS;
type struct_WIN32_FIND_STREAM_DATA;
type struct_WIN32_FIND_STREAM_DATA is record
StreamSize : aliased winnt.LARGE_INTEGER;
cStreamName : aliased winnt.WCHAR_array (0 .. 295);
end record;
pragma Convention (C_Pass_By_Copy, struct_WIN32_FIND_STREAM_DATA);
type struct_WIN32_FIND_STREAM_DATA_ptr is
access all struct_WIN32_FIND_STREAM_DATA;
for struct_WIN32_FIND_STREAM_DATA_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_WIN32_FIND_STREAM_DATA_ptr);
pragma Convention (C, struct_WIN32_FIND_STREAM_DATA_ptr);
subtype WIN32_FIND_STREAM_DATA is struct_WIN32_FIND_STREAM_DATA;
subtype PWIN32_FIND_STREAM_DATA is struct_WIN32_FIND_STREAM_DATA_ptr;
function FindFirstStreamW (lpFileName : access constant winnt.WCHAR;
InfoLevel : STREAM_INFO_LEVELS; lpFindStreamData : windef.LPVOID;
dwFlags : windef.DWORD) return winnt.HANDLE;
pragma Import (C, FindFirstStreamW, "FindFirstStreamW");
function FindNextStreamW (hFindStream : winnt.HANDLE;
lpFindStreamData : windef.LPVOID) return windef.WINBOOL;
pragma Import (C, FindNextStreamW, "FindNextStreamW");
function CreateNamedPipeA (lpName : access constant winnt.C_CHAR;
dwOpenMode : windef.DWORD; dwPipeMode : windef.DWORD;
nMaxInstances : windef.DWORD; nOutBufferSize : windef.DWORD;
nInBufferSize : windef.DWORD; nDefaultTimeOut : windef.DWORD;
lpSecurityAttributes : access struct_SECURITY_ATTRIBUTES)
return winnt.HANDLE;
pragma Import (C, CreateNamedPipeA, "CreateNamedPipeA");
function CreateNamedPipeW (lpName : access constant winnt.WCHAR;
dwOpenMode : windef.DWORD; dwPipeMode : windef.DWORD;
nMaxInstances : windef.DWORD; nOutBufferSize : windef.DWORD;
nInBufferSize : windef.DWORD; nDefaultTimeOut : windef.DWORD;
lpSecurityAttributes : access struct_SECURITY_ATTRIBUTES)
return winnt.HANDLE;
pragma Import (C, CreateNamedPipeW, "CreateNamedPipeW");
function GetNamedPipeHandleStateA (hNamedPipe : winnt.HANDLE;
lpState : access windef.DWORD; lpCurInstances : access windef.DWORD;
lpMaxCollectionCount : access windef.DWORD;
lpCollectDataTimeout : access windef.DWORD;
lpUserName : access winnt.C_CHAR; nMaxUserNameSize : windef.DWORD)
return windef.WINBOOL;
pragma Import (C, GetNamedPipeHandleStateA, "GetNamedPipeHandleStateA");
function GetNamedPipeHandleStateW (hNamedPipe : winnt.HANDLE;
lpState : access windef.DWORD; lpCurInstances : access windef.DWORD;
lpMaxCollectionCount : access windef.DWORD;
lpCollectDataTimeout : access windef.DWORD;
lpUserName : access winnt.WCHAR; nMaxUserNameSize : windef.DWORD)
return windef.WINBOOL;
pragma Import (C, GetNamedPipeHandleStateW, "GetNamedPipeHandleStateW");
function CallNamedPipeA (lpNamedPipeName : access constant winnt.C_CHAR;
lpInBuffer : windef.LPVOID; nInBufferSize : windef.DWORD;
lpOutBuffer : windef.LPVOID; nOutBufferSize : windef.DWORD;
lpBytesRead : access windef.DWORD; nTimeOut : windef.DWORD)
return windef.WINBOOL;
pragma Import (C, CallNamedPipeA, "CallNamedPipeA");
function CallNamedPipeW (lpNamedPipeName : access constant winnt.WCHAR;
lpInBuffer : windef.LPVOID; nInBufferSize : windef.DWORD;
lpOutBuffer : windef.LPVOID; nOutBufferSize : windef.DWORD;
lpBytesRead : access windef.DWORD; nTimeOut : windef.DWORD)
return windef.WINBOOL;
pragma Import (C, CallNamedPipeW, "CallNamedPipeW");
function WaitNamedPipeA (lpNamedPipeName : access constant winnt.C_CHAR;
nTimeOut : windef.DWORD) return windef.WINBOOL;
pragma Import (C, WaitNamedPipeA, "WaitNamedPipeA");
function WaitNamedPipeW (lpNamedPipeName : access constant winnt.WCHAR;
nTimeOut : windef.DWORD) return windef.WINBOOL;
pragma Import (C, WaitNamedPipeW, "WaitNamedPipeW");
function SetVolumeLabelA (lpRootPathName : access constant winnt.C_CHAR;
lpVolumeName : access constant winnt.C_CHAR) return windef.WINBOOL;
pragma Import (C, SetVolumeLabelA, "SetVolumeLabelA");
function SetVolumeLabelW (lpRootPathName : access constant winnt.WCHAR;
lpVolumeName : access constant winnt.WCHAR) return windef.WINBOOL;
pragma Import (C, SetVolumeLabelW, "SetVolumeLabelW");
procedure SetFileApisToOEM;
pragma Import (C, SetFileApisToOEM, "SetFileApisToOEM");
procedure SetFileApisToANSI;
pragma Import (C, SetFileApisToANSI, "SetFileApisToANSI");
function AreFileApisANSI return windef.WINBOOL;
pragma Import (C, AreFileApisANSI, "AreFileApisANSI");
function GetVolumeInformationA (
lpRootPathName : access constant winnt.C_CHAR;
lpVolumeNameBuffer : access winnt.C_CHAR;
nVolumeNameSize : windef.DWORD;
lpVolumeSerialNumber : access windef.DWORD;
lpMaximumComponentLength : access windef.DWORD;
lpFileSystemFlags : access windef.DWORD;
lpFileSystemNameBuffer : access winnt.C_CHAR;
nFileSystemNameSize : windef.DWORD) return windef.WINBOOL;
pragma Import (C, GetVolumeInformationA, "GetVolumeInformationA");
function GetVolumeInformationW (
lpRootPathName : access constant winnt.WCHAR;
lpVolumeNameBuffer : access winnt.WCHAR;
nVolumeNameSize : windef.DWORD;
lpVolumeSerialNumber : access windef.DWORD;
lpMaximumComponentLength : access windef.DWORD;
lpFileSystemFlags : access windef.DWORD;
lpFileSystemNameBuffer : access winnt.WCHAR;
nFileSystemNameSize : windef.DWORD) return windef.WINBOOL;
pragma Import (C, GetVolumeInformationW, "GetVolumeInformationW");
function CancelIo (hFile : winnt.HANDLE) return windef.WINBOOL;
pragma Import (C, CancelIo, "CancelIo");
function ClearEventLogA (hEventLog : winnt.HANDLE;
lpBackupFileName : access constant winnt.C_CHAR) return windef.WINBOOL;
pragma Import (C, ClearEventLogA, "ClearEventLogA");
function ClearEventLogW (hEventLog : winnt.HANDLE;
lpBackupFileName : access constant winnt.WCHAR) return windef.WINBOOL;
pragma Import (C, ClearEventLogW, "ClearEventLogW");
function BackupEventLogA (hEventLog : winnt.HANDLE;
lpBackupFileName : access constant winnt.C_CHAR) return windef.WINBOOL;
pragma Import (C, BackupEventLogA, "BackupEventLogA");
function BackupEventLogW (hEventLog : winnt.HANDLE;
lpBackupFileName : access constant winnt.WCHAR) return windef.WINBOOL;
pragma Import (C, BackupEventLogW, "BackupEventLogW");
function CloseEventLog (hEventLog : winnt.HANDLE) return windef.WINBOOL;
pragma Import (C, CloseEventLog, "CloseEventLog");
function DeregisterEventSource (hEventLog : winnt.HANDLE)
return windef.WINBOOL;
pragma Import (C, DeregisterEventSource, "DeregisterEventSource");
function NotifyChangeEventLog (hEventLog : winnt.HANDLE;
hEvent : winnt.HANDLE) return windef.WINBOOL;
pragma Import (C, NotifyChangeEventLog, "NotifyChangeEventLog");
function GetNumberOfEventLogRecords (hEventLog : winnt.HANDLE;
NumberOfRecords : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, GetNumberOfEventLogRecords,
"GetNumberOfEventLogRecords");
function GetOldestEventLogRecord (hEventLog : winnt.HANDLE;
OldestRecord : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, GetOldestEventLogRecord, "GetOldestEventLogRecord");
function OpenEventLogA (lpUNCServerName : access constant winnt.C_CHAR;
lpSourceName : access constant winnt.C_CHAR) return winnt.HANDLE;
pragma Import (C, OpenEventLogA, "OpenEventLogA");
function OpenEventLogW (lpUNCServerName : access constant winnt.WCHAR;
lpSourceName : access constant winnt.WCHAR) return winnt.HANDLE;
pragma Import (C, OpenEventLogW, "OpenEventLogW");
function RegisterEventSourceA (
lpUNCServerName : access constant winnt.C_CHAR;
lpSourceName : access constant winnt.C_CHAR) return winnt.HANDLE;
pragma Import (C, RegisterEventSourceA, "RegisterEventSourceA");
function RegisterEventSourceW (
lpUNCServerName : access constant winnt.WCHAR;
lpSourceName : access constant winnt.WCHAR) return winnt.HANDLE;
pragma Import (C, RegisterEventSourceW, "RegisterEventSourceW");
function OpenBackupEventLogA (
lpUNCServerName : access constant winnt.C_CHAR;
lpFileName : access constant winnt.C_CHAR) return winnt.HANDLE;
pragma Import (C, OpenBackupEventLogA, "OpenBackupEventLogA");
function OpenBackupEventLogW (
lpUNCServerName : access constant winnt.WCHAR;
lpFileName : access constant winnt.WCHAR) return winnt.HANDLE;
pragma Import (C, OpenBackupEventLogW, "OpenBackupEventLogW");
function ReadEventLogA (hEventLog : winnt.HANDLE;
dwReadFlags : windef.DWORD; dwRecordOffset : windef.DWORD;
lpBuffer : windef.LPVOID; nNumberOfBytesToRead : windef.DWORD;
pnBytesRead : access windef.DWORD;
pnMinNumberOfBytesNeeded : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, ReadEventLogA, "ReadEventLogA");
function ReadEventLogW (hEventLog : winnt.HANDLE;
dwReadFlags : windef.DWORD; dwRecordOffset : windef.DWORD;
lpBuffer : windef.LPVOID; nNumberOfBytesToRead : windef.DWORD;
pnBytesRead : access windef.DWORD;
pnMinNumberOfBytesNeeded : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, ReadEventLogW, "ReadEventLogW");
function ReportEventA (hEventLog : winnt.HANDLE; wType : windef.WORD;
wCategory : windef.WORD; dwEventID : windef.DWORD;
lpUserSid : winnt.PSID; wNumStrings : windef.WORD;
dwDataSize : windef.DWORD; lpStrings : access winnt.LPCSTR;
lpRawData : windef.LPVOID) return windef.WINBOOL;
pragma Import (C, ReportEventA, "ReportEventA");
function ReportEventW (hEventLog : winnt.HANDLE; wType : windef.WORD;
wCategory : windef.WORD; dwEventID : windef.DWORD;
lpUserSid : winnt.PSID; wNumStrings : windef.WORD;
dwDataSize : windef.DWORD; lpStrings : access winnt.LPCWSTR;
lpRawData : windef.LPVOID) return windef.WINBOOL;
pragma Import (C, ReportEventW, "ReportEventW");
type struct_EVENTLOG_FULL_INFORMATION;
type struct_EVENTLOG_FULL_INFORMATION is record
dwFull : aliased windef.DWORD;
end record;
pragma Convention (C_Pass_By_Copy, struct_EVENTLOG_FULL_INFORMATION);
type struct_EVENTLOG_FULL_INFORMATION_ptr is
access all struct_EVENTLOG_FULL_INFORMATION;
for struct_EVENTLOG_FULL_INFORMATION_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_EVENTLOG_FULL_INFORMATION_ptr);
pragma Convention (C, struct_EVENTLOG_FULL_INFORMATION_ptr);
subtype EVENTLOG_FULL_INFORMATION is struct_EVENTLOG_FULL_INFORMATION;
subtype LPEVENTLOG_FULL_INFORMATION is
struct_EVENTLOG_FULL_INFORMATION_ptr;
function GetEventLogInformation (hEventLog : winnt.HANDLE;
dwInfoLevel : windef.DWORD; lpBuffer : windef.LPVOID;
cbBufSize : windef.DWORD; pcbBytesNeeded : access windef.DWORD)
return windef.WINBOOL;
pragma Import (C, GetEventLogInformation, "GetEventLogInformation");
function DuplicateToken (ExistingTokenHandle : winnt.HANDLE;
ImpersonationLevel : winnt.SECURITY_IMPERSONATION_LEVEL;
DuplicateTokenHandle : access winnt.HANDLE) return windef.WINBOOL;
pragma Import (C, DuplicateToken, "DuplicateToken");
function GetKernelObjectSecurity (Handle : winnt.HANDLE;
RequestedInformation : winnt.SECURITY_INFORMATION;
pSecurityDescriptor : winnt.PSECURITY_DESCRIPTOR;
nLength : windef.DWORD; lpnLengthNeeded : access windef.DWORD)
return windef.WINBOOL;
pragma Import (C, GetKernelObjectSecurity, "GetKernelObjectSecurity");
function ImpersonateNamedPipeClient (hNamedPipe : winnt.HANDLE)
return windef.WINBOOL;
pragma Import (C, ImpersonateNamedPipeClient,
"ImpersonateNamedPipeClient");
function ImpersonateSelf (
ImpersonationLevel : winnt.SECURITY_IMPERSONATION_LEVEL)
return windef.WINBOOL;
pragma Import (C, ImpersonateSelf, "ImpersonateSelf");
function RevertToSelf return windef.WINBOOL;
pragma Import (C, RevertToSelf, "RevertToSelf");
function SetThreadToken (Thread : access winnt.HANDLE;
Token : winnt.HANDLE) return windef.WINBOOL;
pragma Import (C, SetThreadToken, "SetThreadToken");
function AccessCheck (pSecurityDescriptor : winnt.PSECURITY_DESCRIPTOR;
ClientToken : winnt.HANDLE; DesiredAccess : windef.DWORD;
GenericMapping : access winnt.GENERIC_MAPPING;
PrivilegeSet : access winnt.struct_PRIVILEGE_SET;
PrivilegeSetLength : access windef.DWORD;
GrantedAccess : access windef.DWORD;
AccessStatus : access windef.WINBOOL) return windef.WINBOOL;
pragma Import (C, AccessCheck, "AccessCheck");
function AccessCheckByType (
pSecurityDescriptor : winnt.PSECURITY_DESCRIPTOR;
PrincipalSelfSid : winnt.PSID; ClientToken : winnt.HANDLE;
DesiredAccess : windef.DWORD;
ObjectTypeList : access winnt.struct_OBJECT_TYPE_LIST;
ObjectTypeListLength : windef.DWORD;
GenericMapping : access winnt.GENERIC_MAPPING;
PrivilegeSet : access winnt.struct_PRIVILEGE_SET;
PrivilegeSetLength : access windef.DWORD;
GrantedAccess : access windef.DWORD;
AccessStatus : access windef.WINBOOL) return windef.WINBOOL;
pragma Import (C, AccessCheckByType, "AccessCheckByType");
function AccessCheckByTypeResultList (
pSecurityDescriptor : winnt.PSECURITY_DESCRIPTOR;
PrincipalSelfSid : winnt.PSID; ClientToken : winnt.HANDLE;
DesiredAccess : windef.DWORD;
ObjectTypeList : access winnt.struct_OBJECT_TYPE_LIST;
ObjectTypeListLength : windef.DWORD;
GenericMapping : access winnt.GENERIC_MAPPING;
PrivilegeSet : access winnt.struct_PRIVILEGE_SET;
PrivilegeSetLength : access windef.DWORD;
GrantedAccessList : access windef.DWORD;
AccessStatusList : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, AccessCheckByTypeResultList,
"AccessCheckByTypeResultList");
function OpenProcessToken (ProcessHandle : winnt.HANDLE;
DesiredAccess : windef.DWORD; TokenHandle : access winnt.HANDLE)
return windef.WINBOOL;
pragma Import (C, OpenProcessToken, "OpenProcessToken");
function OpenThreadToken (ThreadHandle : winnt.HANDLE;
DesiredAccess : windef.DWORD; OpenAsSelf : windef.WINBOOL;
TokenHandle : access winnt.HANDLE) return windef.WINBOOL;
pragma Import (C, OpenThreadToken, "OpenThreadToken");
function GetTokenInformation (TokenHandle : winnt.HANDLE;
TokenInformationClass : winnt.TOKEN_INFORMATION_CLASS;
TokenInformation : windef.LPVOID;
TokenInformationLength : windef.DWORD;
ReturnLength : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, GetTokenInformation, "GetTokenInformation");
function SetTokenInformation (TokenHandle : winnt.HANDLE;
TokenInformationClass : winnt.TOKEN_INFORMATION_CLASS;
TokenInformation : windef.LPVOID;
TokenInformationLength : windef.DWORD) return windef.WINBOOL;
pragma Import (C, SetTokenInformation, "SetTokenInformation");
function AdjustTokenPrivileges (TokenHandle : winnt.HANDLE;
DisableAllPrivileges : windef.WINBOOL;
NewState : access winnt.struct_TOKEN_PRIVILEGES;
BufferLength : windef.DWORD;
PreviousState : access winnt.struct_TOKEN_PRIVILEGES;
ReturnLength : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, AdjustTokenPrivileges, "AdjustTokenPrivileges");
function AdjustTokenGroups (TokenHandle : winnt.HANDLE;
ResetToDefault : windef.WINBOOL;
NewState : access winnt.struct_TOKEN_GROUPS;
BufferLength : windef.DWORD;
PreviousState : access winnt.struct_TOKEN_GROUPS;
ReturnLength : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, AdjustTokenGroups, "AdjustTokenGroups");
function PrivilegeCheck (ClientToken : winnt.HANDLE;
RequiredPrivileges : access winnt.struct_PRIVILEGE_SET;
pfResult : access windef.WINBOOL) return windef.WINBOOL;
pragma Import (C, PrivilegeCheck, "PrivilegeCheck");
function AccessCheckAndAuditAlarmA (
SubsystemName : access constant winnt.C_CHAR; HandleId : windef.LPVOID;
ObjectTypeName : access winnt.C_CHAR; ObjectName : access winnt.C_CHAR;
SecurityDescriptor : winnt.PSECURITY_DESCRIPTOR;
DesiredAccess : windef.DWORD;
GenericMapping : access winnt.GENERIC_MAPPING;
ObjectCreation : windef.WINBOOL; GrantedAccess : access windef.DWORD;
AccessStatus : access windef.WINBOOL;
pfGenerateOnClose : access windef.WINBOOL) return windef.WINBOOL;
pragma Import (C, AccessCheckAndAuditAlarmA, "AccessCheckAndAuditAlarmA");
function AccessCheckAndAuditAlarmW (
SubsystemName : access constant winnt.WCHAR; HandleId : windef.LPVOID;
ObjectTypeName : access winnt.WCHAR; ObjectName : access winnt.WCHAR;
SecurityDescriptor : winnt.PSECURITY_DESCRIPTOR;
DesiredAccess : windef.DWORD;
GenericMapping : access winnt.GENERIC_MAPPING;
ObjectCreation : windef.WINBOOL; GrantedAccess : access windef.DWORD;
AccessStatus : access windef.WINBOOL;
pfGenerateOnClose : access windef.WINBOOL) return windef.WINBOOL;
pragma Import (C, AccessCheckAndAuditAlarmW, "AccessCheckAndAuditAlarmW");
function AccessCheckByTypeAndAuditAlarmA (
SubsystemName : access constant winnt.C_CHAR; HandleId : windef.LPVOID;
ObjectTypeName : access constant winnt.C_CHAR;
ObjectName : access constant winnt.C_CHAR;
SecurityDescriptor : winnt.PSECURITY_DESCRIPTOR;
PrincipalSelfSid : winnt.PSID; DesiredAccess : windef.DWORD;
AuditType : winnt.AUDIT_EVENT_TYPE; Flags : windef.DWORD;
ObjectTypeList : access winnt.struct_OBJECT_TYPE_LIST;
ObjectTypeListLength : windef.DWORD;
GenericMapping : access winnt.GENERIC_MAPPING;
ObjectCreation : windef.WINBOOL; GrantedAccess : access windef.DWORD;
AccessStatus : access windef.WINBOOL;
pfGenerateOnClose : access windef.WINBOOL) return windef.WINBOOL;
pragma Import (C, AccessCheckByTypeAndAuditAlarmA,
"AccessCheckByTypeAndAuditAlarmA");
function AccessCheckByTypeAndAuditAlarmW (
SubsystemName : access constant winnt.WCHAR; HandleId : windef.LPVOID;
ObjectTypeName : access constant winnt.WCHAR;
ObjectName : access constant winnt.WCHAR;
SecurityDescriptor : winnt.PSECURITY_DESCRIPTOR;
PrincipalSelfSid : winnt.PSID; DesiredAccess : windef.DWORD;
AuditType : winnt.AUDIT_EVENT_TYPE; Flags : windef.DWORD;
ObjectTypeList : access winnt.struct_OBJECT_TYPE_LIST;
ObjectTypeListLength : windef.DWORD;
GenericMapping : access winnt.GENERIC_MAPPING;
ObjectCreation : windef.WINBOOL; GrantedAccess : access windef.DWORD;
AccessStatus : access windef.WINBOOL;
pfGenerateOnClose : access windef.WINBOOL) return windef.WINBOOL;
pragma Import (C, AccessCheckByTypeAndAuditAlarmW,
"AccessCheckByTypeAndAuditAlarmW");
function AccessCheckByTypeResultListAndAuditAlarmA (
SubsystemName : access constant winnt.C_CHAR; HandleId : windef.LPVOID;
ObjectTypeName : access constant winnt.C_CHAR;
ObjectName : access constant winnt.C_CHAR;
SecurityDescriptor : winnt.PSECURITY_DESCRIPTOR;
PrincipalSelfSid : winnt.PSID; DesiredAccess : windef.DWORD;
AuditType : winnt.AUDIT_EVENT_TYPE; Flags : windef.DWORD;
ObjectTypeList : access winnt.struct_OBJECT_TYPE_LIST;
ObjectTypeListLength : windef.DWORD;
GenericMapping : access winnt.GENERIC_MAPPING;
ObjectCreation : windef.WINBOOL; GrantedAccess : access windef.DWORD;
AccessStatusList : access windef.DWORD;
pfGenerateOnClose : access windef.WINBOOL) return windef.WINBOOL;
pragma Import (C, AccessCheckByTypeResultListAndAuditAlarmA,
"AccessCheckByTypeResultListAndAuditAlarmA");
function AccessCheckByTypeResultListAndAuditAlarmW (
SubsystemName : access constant winnt.WCHAR; HandleId : windef.LPVOID;
ObjectTypeName : access constant winnt.WCHAR;
ObjectName : access constant winnt.WCHAR;
SecurityDescriptor : winnt.PSECURITY_DESCRIPTOR;
PrincipalSelfSid : winnt.PSID; DesiredAccess : windef.DWORD;
AuditType : winnt.AUDIT_EVENT_TYPE; Flags : windef.DWORD;
ObjectTypeList : access winnt.struct_OBJECT_TYPE_LIST;
ObjectTypeListLength : windef.DWORD;
GenericMapping : access winnt.GENERIC_MAPPING;
ObjectCreation : windef.WINBOOL; GrantedAccess : access windef.DWORD;
AccessStatusList : access windef.DWORD;
pfGenerateOnClose : access windef.WINBOOL) return windef.WINBOOL;
pragma Import (C, AccessCheckByTypeResultListAndAuditAlarmW,
"AccessCheckByTypeResultListAndAuditAlarmW");
function AccessCheckByTypeResultListAndAuditAlarmByHandleA (
SubsystemName : access constant winnt.C_CHAR; HandleId : windef.LPVOID;
ClientToken : winnt.HANDLE;
ObjectTypeName : access constant winnt.C_CHAR;
ObjectName : access constant winnt.C_CHAR;
SecurityDescriptor : winnt.PSECURITY_DESCRIPTOR;
PrincipalSelfSid : winnt.PSID; DesiredAccess : windef.DWORD;
AuditType : winnt.AUDIT_EVENT_TYPE; Flags : windef.DWORD;
ObjectTypeList : access winnt.struct_OBJECT_TYPE_LIST;
ObjectTypeListLength : windef.DWORD;
GenericMapping : access winnt.GENERIC_MAPPING;
ObjectCreation : windef.WINBOOL; GrantedAccess : access windef.DWORD;
AccessStatusList : access windef.DWORD;
pfGenerateOnClose : access windef.WINBOOL) return windef.WINBOOL;
pragma Import (C, AccessCheckByTypeResultListAndAuditAlarmByHandleA,
"AccessCheckByTypeResultListAndAuditAlarmByHandleA");
function AccessCheckByTypeResultListAndAuditAlarmByHandleW (
SubsystemName : access constant winnt.WCHAR; HandleId : windef.LPVOID;
ClientToken : winnt.HANDLE;
ObjectTypeName : access constant winnt.WCHAR;
ObjectName : access constant winnt.WCHAR;
SecurityDescriptor : winnt.PSECURITY_DESCRIPTOR;
PrincipalSelfSid : winnt.PSID; DesiredAccess : windef.DWORD;
AuditType : winnt.AUDIT_EVENT_TYPE; Flags : windef.DWORD;
ObjectTypeList : access winnt.struct_OBJECT_TYPE_LIST;
ObjectTypeListLength : windef.DWORD;
GenericMapping : access winnt.GENERIC_MAPPING;
ObjectCreation : windef.WINBOOL; GrantedAccess : access windef.DWORD;
AccessStatusList : access windef.DWORD;
pfGenerateOnClose : access windef.WINBOOL) return windef.WINBOOL;
pragma Import (C, AccessCheckByTypeResultListAndAuditAlarmByHandleW,
"AccessCheckByTypeResultListAndAuditAlarmByHandleW");
function ObjectOpenAuditAlarmA (
SubsystemName : access constant winnt.C_CHAR; HandleId : windef.LPVOID;
ObjectTypeName : access winnt.C_CHAR; ObjectName : access winnt.C_CHAR;
pSecurityDescriptor : winnt.PSECURITY_DESCRIPTOR;
ClientToken : winnt.HANDLE; DesiredAccess : windef.DWORD;
GrantedAccess : windef.DWORD;
Privileges : access winnt.struct_PRIVILEGE_SET;
ObjectCreation : windef.WINBOOL; AccessGranted : windef.WINBOOL;
GenerateOnClose : access windef.WINBOOL) return windef.WINBOOL;
pragma Import (C, ObjectOpenAuditAlarmA, "ObjectOpenAuditAlarmA");
function ObjectOpenAuditAlarmW (
SubsystemName : access constant winnt.WCHAR; HandleId : windef.LPVOID;
ObjectTypeName : access winnt.WCHAR; ObjectName : access winnt.WCHAR;
pSecurityDescriptor : winnt.PSECURITY_DESCRIPTOR;
ClientToken : winnt.HANDLE; DesiredAccess : windef.DWORD;
GrantedAccess : windef.DWORD;
Privileges : access winnt.struct_PRIVILEGE_SET;
ObjectCreation : windef.WINBOOL; AccessGranted : windef.WINBOOL;
GenerateOnClose : access windef.WINBOOL) return windef.WINBOOL;
pragma Import (C, ObjectOpenAuditAlarmW, "ObjectOpenAuditAlarmW");
function ObjectPrivilegeAuditAlarmA (
SubsystemName : access constant winnt.C_CHAR; HandleId : windef.LPVOID;
ClientToken : winnt.HANDLE; DesiredAccess : windef.DWORD;
Privileges : access winnt.struct_PRIVILEGE_SET;
AccessGranted : windef.WINBOOL) return windef.WINBOOL;
pragma Import (C, ObjectPrivilegeAuditAlarmA,
"ObjectPrivilegeAuditAlarmA");
function ObjectPrivilegeAuditAlarmW (
SubsystemName : access constant winnt.WCHAR; HandleId : windef.LPVOID;
ClientToken : winnt.HANDLE; DesiredAccess : windef.DWORD;
Privileges : access winnt.struct_PRIVILEGE_SET;
AccessGranted : windef.WINBOOL) return windef.WINBOOL;
pragma Import (C, ObjectPrivilegeAuditAlarmW,
"ObjectPrivilegeAuditAlarmW");
function ObjectCloseAuditAlarmA (
SubsystemName : access constant winnt.C_CHAR; HandleId : windef.LPVOID;
GenerateOnClose : windef.WINBOOL) return windef.WINBOOL;
pragma Import (C, ObjectCloseAuditAlarmA, "ObjectCloseAuditAlarmA");
function ObjectCloseAuditAlarmW (
SubsystemName : access constant winnt.WCHAR; HandleId : windef.LPVOID;
GenerateOnClose : windef.WINBOOL) return windef.WINBOOL;
pragma Import (C, ObjectCloseAuditAlarmW, "ObjectCloseAuditAlarmW");
function ObjectDeleteAuditAlarmA (
SubsystemName : access constant winnt.C_CHAR; HandleId : windef.LPVOID;
GenerateOnClose : windef.WINBOOL) return windef.WINBOOL;
pragma Import (C, ObjectDeleteAuditAlarmA, "ObjectDeleteAuditAlarmA");
function ObjectDeleteAuditAlarmW (
SubsystemName : access constant winnt.WCHAR; HandleId : windef.LPVOID;
GenerateOnClose : windef.WINBOOL) return windef.WINBOOL;
pragma Import (C, ObjectDeleteAuditAlarmW, "ObjectDeleteAuditAlarmW");
function PrivilegedServiceAuditAlarmA (
SubsystemName : access constant winnt.C_CHAR;
ServiceName : access constant winnt.C_CHAR; ClientToken : winnt.HANDLE;
Privileges : access winnt.struct_PRIVILEGE_SET;
AccessGranted : windef.WINBOOL) return windef.WINBOOL;
pragma Import (C, PrivilegedServiceAuditAlarmA,
"PrivilegedServiceAuditAlarmA");
function PrivilegedServiceAuditAlarmW (
SubsystemName : access constant winnt.WCHAR;
ServiceName : access constant winnt.WCHAR; ClientToken : winnt.HANDLE;
Privileges : access winnt.struct_PRIVILEGE_SET;
AccessGranted : windef.WINBOOL) return windef.WINBOOL;
pragma Import (C, PrivilegedServiceAuditAlarmW,
"PrivilegedServiceAuditAlarmW");
function IsWellKnownSid (pSid : winnt.PSID;
WellKnownSidType : winnt.WELL_KNOWN_SID_TYPE) return windef.WINBOOL;
pragma Import (C, IsWellKnownSid, "IsWellKnownSid");
function CreateWellKnownSid (WellKnownSidType : winnt.WELL_KNOWN_SID_TYPE;
DomainSid : winnt.PSID; pSid : winnt.PSID; cbSid : access windef.DWORD)
return windef.WINBOOL;
pragma Import (C, CreateWellKnownSid, "CreateWellKnownSid");
function EqualDomainSid (pSid1 : winnt.PSID; pSid2 : winnt.PSID;
pfEqual : access windef.WINBOOL) return windef.WINBOOL;
pragma Import (C, EqualDomainSid, "EqualDomainSid");
function GetWindowsAccountDomainSid (pSid : winnt.PSID;
pDomainSid : winnt.PSID; cbDomainSid : access windef.DWORD)
return windef.WINBOOL;
pragma Import (C, GetWindowsAccountDomainSid,
"GetWindowsAccountDomainSid");
function IsValidSid (pSid : winnt.PSID) return windef.WINBOOL;
pragma Import (C, IsValidSid, "IsValidSid");
function EqualSid (pSid1 : winnt.PSID; pSid2 : winnt.PSID)
return windef.WINBOOL;
pragma Import (C, EqualSid, "EqualSid");
function EqualPrefixSid (pSid1 : winnt.PSID; pSid2 : winnt.PSID)
return windef.WINBOOL;
pragma Import (C, EqualPrefixSid, "EqualPrefixSid");
function GetSidLengthRequired (nSubAuthorityCount : windef.UCHAR)
return windef.DWORD;
pragma Import (C, GetSidLengthRequired, "GetSidLengthRequired");
function AllocateAndInitializeSid (
pIdentifierAuthority : access winnt.struct_SID_IDENTIFIER_AUTHORITY;
nSubAuthorityCount : windef.BYTE; nSubAuthority0 : windef.DWORD;
nSubAuthority1 : windef.DWORD; nSubAuthority2 : windef.DWORD;
nSubAuthority3 : windef.DWORD; nSubAuthority4 : windef.DWORD;
nSubAuthority5 : windef.DWORD; nSubAuthority6 : windef.DWORD;
nSubAuthority7 : windef.DWORD; pSid : access winnt.PSID)
return windef.WINBOOL;
pragma Import (C, AllocateAndInitializeSid, "AllocateAndInitializeSid");
function FreeSid (pSid : winnt.PSID) return winnt.PVOID;
pragma Import (C, FreeSid, "FreeSid");
function InitializeSid (Sid : winnt.PSID;
pIdentifierAuthority : access winnt.struct_SID_IDENTIFIER_AUTHORITY;
nSubAuthorityCount : windef.BYTE) return windef.WINBOOL;
pragma Import (C, InitializeSid, "InitializeSid");
function GetSidIdentifierAuthority (pSid : winnt.PSID)
return winnt.PSID_IDENTIFIER_AUTHORITY;
pragma Import (C, GetSidIdentifierAuthority, "GetSidIdentifierAuthority");
function GetSidSubAuthority (pSid : winnt.PSID;
nSubAuthority : windef.DWORD) return windef.PDWORD;
pragma Import (C, GetSidSubAuthority, "GetSidSubAuthority");
function GetSidSubAuthorityCount (pSid : winnt.PSID) return windef.PUCHAR;
pragma Import (C, GetSidSubAuthorityCount, "GetSidSubAuthorityCount");
function GetLengthSid (pSid : winnt.PSID) return windef.DWORD;
pragma Import (C, GetLengthSid, "GetLengthSid");
function CopySid (nDestinationSidLength : windef.DWORD;
pDestinationSid : winnt.PSID; pSourceSid : winnt.PSID)
return windef.WINBOOL;
pragma Import (C, CopySid, "CopySid");
function AreAllAccessesGranted (GrantedAccess : windef.DWORD;
DesiredAccess : windef.DWORD) return windef.WINBOOL;
pragma Import (C, AreAllAccessesGranted, "AreAllAccessesGranted");
function AreAnyAccessesGranted (GrantedAccess : windef.DWORD;
DesiredAccess : windef.DWORD) return windef.WINBOOL;
pragma Import (C, AreAnyAccessesGranted, "AreAnyAccessesGranted");
procedure MapGenericMask (AccessMask : access windef.DWORD;
GenericMapping : access winnt.GENERIC_MAPPING);
pragma Import (C, MapGenericMask, "MapGenericMask");
function IsValidAcl (pAcl : access winnt.ACL) return windef.WINBOOL;
pragma Import (C, IsValidAcl, "IsValidAcl");
function InitializeAcl (pAcl : access winnt.ACL;
nAclLength : windef.DWORD; dwAclRevision : windef.DWORD)
return windef.WINBOOL;
pragma Import (C, InitializeAcl, "InitializeAcl");
function GetAclInformation (pAcl : access winnt.ACL;
pAclInformation : windef.LPVOID; nAclInformationLength : windef.DWORD;
dwAclInformationClass : winnt.ACL_INFORMATION_CLASS)
return windef.WINBOOL;
pragma Import (C, GetAclInformation, "GetAclInformation");
function SetAclInformation (pAcl : access winnt.ACL;
pAclInformation : windef.LPVOID; nAclInformationLength : windef.DWORD;
dwAclInformationClass : winnt.ACL_INFORMATION_CLASS)
return windef.WINBOOL;
pragma Import (C, SetAclInformation, "SetAclInformation");
function AddAce (pAcl : access winnt.ACL; dwAceRevision : windef.DWORD;
dwStartingAceIndex : windef.DWORD; pAceList : windef.LPVOID;
nAceListLength : windef.DWORD) return windef.WINBOOL;
pragma Import (C, AddAce, "AddAce");
function DeleteAce (pAcl : access winnt.ACL; dwAceIndex : windef.DWORD)
return windef.WINBOOL;
pragma Import (C, DeleteAce, "DeleteAce");
function GetAce (pAcl : access winnt.ACL; dwAceIndex : windef.DWORD;
pAce : access windef.LPVOID) return windef.WINBOOL;
pragma Import (C, GetAce, "GetAce");
function AddAccessAllowedAce (pAcl : access winnt.ACL;
dwAceRevision : windef.DWORD; AccessMask : windef.DWORD;
pSid : winnt.PSID) return windef.WINBOOL;
pragma Import (C, AddAccessAllowedAce, "AddAccessAllowedAce");
function AddAccessAllowedAceEx (pAcl : access winnt.ACL;
dwAceRevision : windef.DWORD; AceFlags : windef.DWORD;
AccessMask : windef.DWORD; pSid : winnt.PSID) return windef.WINBOOL;
pragma Import (C, AddAccessAllowedAceEx, "AddAccessAllowedAceEx");
function AddAccessDeniedAce (pAcl : access winnt.ACL;
dwAceRevision : windef.DWORD; AccessMask : windef.DWORD;
pSid : winnt.PSID) return windef.WINBOOL;
pragma Import (C, AddAccessDeniedAce, "AddAccessDeniedAce");
function AddAccessDeniedAceEx (pAcl : access winnt.ACL;
dwAceRevision : windef.DWORD; AceFlags : windef.DWORD;
AccessMask : windef.DWORD; pSid : winnt.PSID) return windef.WINBOOL;
pragma Import (C, AddAccessDeniedAceEx, "AddAccessDeniedAceEx");
function AddAuditAccessAce (pAcl : access winnt.ACL;
dwAceRevision : windef.DWORD; dwAccessMask : windef.DWORD;
pSid : winnt.PSID; bAuditSuccess : windef.WINBOOL;
bAuditFailure : windef.WINBOOL) return windef.WINBOOL;
pragma Import (C, AddAuditAccessAce, "AddAuditAccessAce");
function AddAuditAccessAceEx (pAcl : access winnt.ACL;
dwAceRevision : windef.DWORD; AceFlags : windef.DWORD;
dwAccessMask : windef.DWORD; pSid : winnt.PSID;
bAuditSuccess : windef.WINBOOL; bAuditFailure : windef.WINBOOL)
return windef.WINBOOL;
pragma Import (C, AddAuditAccessAceEx, "AddAuditAccessAceEx");
function AddAccessAllowedObjectAce (pAcl : access winnt.ACL;
dwAceRevision : windef.DWORD; AceFlags : windef.DWORD;
AccessMask : windef.DWORD; ObjectTypeGuid : access guiddef.GUID;
InheritedObjectTypeGuid : access guiddef.GUID; pSid : winnt.PSID)
return windef.WINBOOL;
pragma Import (C, AddAccessAllowedObjectAce, "AddAccessAllowedObjectAce");
function AddAccessDeniedObjectAce (pAcl : access winnt.ACL;
dwAceRevision : windef.DWORD; AceFlags : windef.DWORD;
AccessMask : windef.DWORD; ObjectTypeGuid : access guiddef.GUID;
InheritedObjectTypeGuid : access guiddef.GUID; pSid : winnt.PSID)
return windef.WINBOOL;
pragma Import (C, AddAccessDeniedObjectAce, "AddAccessDeniedObjectAce");
function AddAuditAccessObjectAce (pAcl : access winnt.ACL;
dwAceRevision : windef.DWORD; AceFlags : windef.DWORD;
AccessMask : windef.DWORD; ObjectTypeGuid : access guiddef.GUID;
InheritedObjectTypeGuid : access guiddef.GUID; pSid : winnt.PSID;
bAuditSuccess : windef.WINBOOL; bAuditFailure : windef.WINBOOL)
return windef.WINBOOL;
pragma Import (C, AddAuditAccessObjectAce, "AddAuditAccessObjectAce");
function FindFirstFreeAce (pAcl : access winnt.ACL;
pAce : access windef.LPVOID) return windef.WINBOOL;
pragma Import (C, FindFirstFreeAce, "FindFirstFreeAce");
function InitializeSecurityDescriptor (
pSecurityDescriptor : winnt.PSECURITY_DESCRIPTOR;
dwRevision : windef.DWORD) return windef.WINBOOL;
pragma Import (C, InitializeSecurityDescriptor,
"InitializeSecurityDescriptor");
function IsValidSecurityDescriptor (
pSecurityDescriptor : winnt.PSECURITY_DESCRIPTOR)
return windef.WINBOOL;
pragma Import (C, IsValidSecurityDescriptor, "IsValidSecurityDescriptor");
function GetSecurityDescriptorLength (
pSecurityDescriptor : winnt.PSECURITY_DESCRIPTOR) return windef.DWORD;
pragma Import (C, GetSecurityDescriptorLength,
"GetSecurityDescriptorLength");
function GetSecurityDescriptorControl (
pSecurityDescriptor : winnt.PSECURITY_DESCRIPTOR;
pControl : access windef.WORD; lpdwRevision : access windef.DWORD)
return windef.WINBOOL;
pragma Import (C, GetSecurityDescriptorControl,
"GetSecurityDescriptorControl");
function SetSecurityDescriptorControl (
pSecurityDescriptor : winnt.PSECURITY_DESCRIPTOR;
ControlBitsOfInterest : winnt.SECURITY_DESCRIPTOR_CONTROL;
ControlBitsToSet : winnt.SECURITY_DESCRIPTOR_CONTROL)
return windef.WINBOOL;
pragma Import (C, SetSecurityDescriptorControl,
"SetSecurityDescriptorControl");
function SetSecurityDescriptorDacl (
pSecurityDescriptor : winnt.PSECURITY_DESCRIPTOR;
bDaclPresent : windef.WINBOOL; pDacl : access winnt.ACL;
bDaclDefaulted : windef.WINBOOL) return windef.WINBOOL;
pragma Import (C, SetSecurityDescriptorDacl, "SetSecurityDescriptorDacl");
function GetSecurityDescriptorDacl (
pSecurityDescriptor : winnt.PSECURITY_DESCRIPTOR;
lpbDaclPresent : access windef.WINBOOL; pDacl : access winnt.PACL;
lpbDaclDefaulted : access windef.WINBOOL) return windef.WINBOOL;
pragma Import (C, GetSecurityDescriptorDacl, "GetSecurityDescriptorDacl");
function SetSecurityDescriptorSacl (
pSecurityDescriptor : winnt.PSECURITY_DESCRIPTOR;
bSaclPresent : windef.WINBOOL; pSacl : access winnt.ACL;
bSaclDefaulted : windef.WINBOOL) return windef.WINBOOL;
pragma Import (C, SetSecurityDescriptorSacl, "SetSecurityDescriptorSacl");
function GetSecurityDescriptorSacl (
pSecurityDescriptor : winnt.PSECURITY_DESCRIPTOR;
lpbSaclPresent : access windef.WINBOOL; pSacl : access winnt.PACL;
lpbSaclDefaulted : access windef.WINBOOL) return windef.WINBOOL;
pragma Import (C, GetSecurityDescriptorSacl, "GetSecurityDescriptorSacl");
function SetSecurityDescriptorOwner (
pSecurityDescriptor : winnt.PSECURITY_DESCRIPTOR; pOwner : winnt.PSID;
bOwnerDefaulted : windef.WINBOOL) return windef.WINBOOL;
pragma Import (C, SetSecurityDescriptorOwner,
"SetSecurityDescriptorOwner");
function GetSecurityDescriptorOwner (
pSecurityDescriptor : winnt.PSECURITY_DESCRIPTOR;
pOwner : access winnt.PSID; lpbOwnerDefaulted : access windef.WINBOOL)
return windef.WINBOOL;
pragma Import (C, GetSecurityDescriptorOwner,
"GetSecurityDescriptorOwner");
function SetSecurityDescriptorGroup (
pSecurityDescriptor : winnt.PSECURITY_DESCRIPTOR; pGroup : winnt.PSID;
bGroupDefaulted : windef.WINBOOL) return windef.WINBOOL;
pragma Import (C, SetSecurityDescriptorGroup,
"SetSecurityDescriptorGroup");
function GetSecurityDescriptorGroup (
pSecurityDescriptor : winnt.PSECURITY_DESCRIPTOR;
pGroup : access winnt.PSID; lpbGroupDefaulted : access windef.WINBOOL)
return windef.WINBOOL;
pragma Import (C, GetSecurityDescriptorGroup,
"GetSecurityDescriptorGroup");
function SetSecurityDescriptorRMControl (
SecurityDescriptor : winnt.PSECURITY_DESCRIPTOR;
RMControl : access windef.UCHAR) return windef.DWORD;
pragma Import (C, SetSecurityDescriptorRMControl,
"SetSecurityDescriptorRMControl");
function GetSecurityDescriptorRMControl (
SecurityDescriptor : winnt.PSECURITY_DESCRIPTOR;
RMControl : access windef.UCHAR) return windef.DWORD;
pragma Import (C, GetSecurityDescriptorRMControl,
"GetSecurityDescriptorRMControl");
function CreatePrivateObjectSecurity (
ParentDescriptor : winnt.PSECURITY_DESCRIPTOR;
CreatorDescriptor : winnt.PSECURITY_DESCRIPTOR;
NewDescriptor : access winnt.PSECURITY_DESCRIPTOR;
IsDirectoryObject : windef.WINBOOL; Token : winnt.HANDLE;
GenericMapping : access winnt.GENERIC_MAPPING) return windef.WINBOOL;
pragma Import (C, CreatePrivateObjectSecurity,
"CreatePrivateObjectSecurity");
function ConvertToAutoInheritPrivateObjectSecurity (
ParentDescriptor : winnt.PSECURITY_DESCRIPTOR;
CurrentSecurityDescriptor : winnt.PSECURITY_DESCRIPTOR;
NewSecurityDescriptor : access winnt.PSECURITY_DESCRIPTOR;
ObjectType : access guiddef.GUID; IsDirectoryObject : winnt.BOOLEAN;
GenericMapping : access winnt.GENERIC_MAPPING) return windef.WINBOOL;
pragma Import (C, ConvertToAutoInheritPrivateObjectSecurity,
"ConvertToAutoInheritPrivateObjectSecurity");
function CreatePrivateObjectSecurityEx (
ParentDescriptor : winnt.PSECURITY_DESCRIPTOR;
CreatorDescriptor : winnt.PSECURITY_DESCRIPTOR;
NewDescriptor : access winnt.PSECURITY_DESCRIPTOR;
ObjectType : access guiddef.GUID; IsContainerObject : windef.WINBOOL;
AutoInheritFlags : windef.ULONG; Token : winnt.HANDLE;
GenericMapping : access winnt.GENERIC_MAPPING) return windef.WINBOOL;
pragma Import (C, CreatePrivateObjectSecurityEx,
"CreatePrivateObjectSecurityEx");
function CreatePrivateObjectSecurityWithMultipleInheritance (
ParentDescriptor : winnt.PSECURITY_DESCRIPTOR;
CreatorDescriptor : winnt.PSECURITY_DESCRIPTOR;
NewDescriptor : access winnt.PSECURITY_DESCRIPTOR;
ObjectTypes : access guiddef.GUID_ptr; GuidCount : windef.ULONG;
IsContainerObject : windef.WINBOOL; AutoInheritFlags : windef.ULONG;
Token : winnt.HANDLE; GenericMapping : access winnt.GENERIC_MAPPING)
return windef.WINBOOL;
pragma Import (C, CreatePrivateObjectSecurityWithMultipleInheritance,
"CreatePrivateObjectSecurityWithMultipleInheritance");
function SetPrivateObjectSecurity (
SecurityInformation : winnt.SECURITY_INFORMATION;
ModificationDescriptor : winnt.PSECURITY_DESCRIPTOR;
ObjectsSecurityDescriptor : access winnt.PSECURITY_DESCRIPTOR;
GenericMapping : access winnt.GENERIC_MAPPING; Token : winnt.HANDLE)
return windef.WINBOOL;
pragma Import (C, SetPrivateObjectSecurity, "SetPrivateObjectSecurity");
function SetPrivateObjectSecurityEx (
SecurityInformation : winnt.SECURITY_INFORMATION;
ModificationDescriptor : winnt.PSECURITY_DESCRIPTOR;
ObjectsSecurityDescriptor : access winnt.PSECURITY_DESCRIPTOR;
AutoInheritFlags : windef.ULONG;
GenericMapping : access winnt.GENERIC_MAPPING; Token : winnt.HANDLE)
return windef.WINBOOL;
pragma Import (C, SetPrivateObjectSecurityEx,
"SetPrivateObjectSecurityEx");
function GetPrivateObjectSecurity (
ObjectDescriptor : winnt.PSECURITY_DESCRIPTOR;
SecurityInformation : winnt.SECURITY_INFORMATION;
ResultantDescriptor : winnt.PSECURITY_DESCRIPTOR;
DescriptorLength : windef.DWORD; ReturnLength : access windef.DWORD)
return windef.WINBOOL;
pragma Import (C, GetPrivateObjectSecurity, "GetPrivateObjectSecurity");
function DestroyPrivateObjectSecurity (
ObjectDescriptor : access winnt.PSECURITY_DESCRIPTOR)
return windef.WINBOOL;
pragma Import (C, DestroyPrivateObjectSecurity,
"DestroyPrivateObjectSecurity");
function MakeSelfRelativeSD (
pAbsoluteSecurityDescriptor : winnt.PSECURITY_DESCRIPTOR;
pSelfRelativeSecurityDescriptor : winnt.PSECURITY_DESCRIPTOR;
lpdwBufferLength : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, MakeSelfRelativeSD, "MakeSelfRelativeSD");
function MakeAbsoluteSD (
pSelfRelativeSecurityDescriptor : winnt.PSECURITY_DESCRIPTOR;
pAbsoluteSecurityDescriptor : winnt.PSECURITY_DESCRIPTOR;
lpdwAbsoluteSecurityDescriptorSize : access windef.DWORD;
pDacl : access winnt.ACL; lpdwDaclSize : access windef.DWORD;
pSacl : access winnt.ACL; lpdwSaclSize : access windef.DWORD;
pOwner : winnt.PSID; lpdwOwnerSize : access windef.DWORD;
pPrimaryGroup : winnt.PSID; lpdwPrimaryGroupSize : access windef.DWORD)
return windef.WINBOOL;
pragma Import (C, MakeAbsoluteSD, "MakeAbsoluteSD");
function MakeAbsoluteSD2 (
pSelfRelativeSecurityDescriptor : winnt.PSECURITY_DESCRIPTOR;
lpdwBufferSize : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, MakeAbsoluteSD2, "MakeAbsoluteSD2");
function SetFileSecurityA (lpFileName : access constant winnt.C_CHAR;
SecurityInformation : winnt.SECURITY_INFORMATION;
pSecurityDescriptor : winnt.PSECURITY_DESCRIPTOR)
return windef.WINBOOL;
pragma Import (C, SetFileSecurityA, "SetFileSecurityA");
function SetFileSecurityW (lpFileName : access constant winnt.WCHAR;
SecurityInformation : winnt.SECURITY_INFORMATION;
pSecurityDescriptor : winnt.PSECURITY_DESCRIPTOR)
return windef.WINBOOL;
pragma Import (C, SetFileSecurityW, "SetFileSecurityW");
function GetFileSecurityA (lpFileName : access constant winnt.C_CHAR;
RequestedInformation : winnt.SECURITY_INFORMATION;
pSecurityDescriptor : winnt.PSECURITY_DESCRIPTOR;
nLength : windef.DWORD; lpnLengthNeeded : access windef.DWORD)
return windef.WINBOOL;
pragma Import (C, GetFileSecurityA, "GetFileSecurityA");
function GetFileSecurityW (lpFileName : access constant winnt.WCHAR;
RequestedInformation : winnt.SECURITY_INFORMATION;
pSecurityDescriptor : winnt.PSECURITY_DESCRIPTOR;
nLength : windef.DWORD; lpnLengthNeeded : access windef.DWORD)
return windef.WINBOOL;
pragma Import (C, GetFileSecurityW, "GetFileSecurityW");
function SetKernelObjectSecurity (Handle : winnt.HANDLE;
SecurityInformation : winnt.SECURITY_INFORMATION;
SecurityDescriptor : winnt.PSECURITY_DESCRIPTOR) return windef.WINBOOL;
pragma Import (C, SetKernelObjectSecurity, "SetKernelObjectSecurity");
function FindFirstChangeNotificationA (
lpPathName : access constant winnt.C_CHAR;
bWatchSubtree : windef.WINBOOL; dwNotifyFilter : windef.DWORD)
return winnt.HANDLE;
pragma Import (C, FindFirstChangeNotificationA,
"FindFirstChangeNotificationA");
function FindFirstChangeNotificationW (
lpPathName : access constant winnt.WCHAR;
bWatchSubtree : windef.WINBOOL; dwNotifyFilter : windef.DWORD)
return winnt.HANDLE;
pragma Import (C, FindFirstChangeNotificationW,
"FindFirstChangeNotificationW");
function FindNextChangeNotification (hChangeHandle : winnt.HANDLE)
return windef.WINBOOL;
pragma Import (C, FindNextChangeNotification,
"FindNextChangeNotification");
function FindCloseChangeNotification (hChangeHandle : winnt.HANDLE)
return windef.WINBOOL;
pragma Import (C, FindCloseChangeNotification,
"FindCloseChangeNotification");
function ReadDirectoryChangesW (hDirectory : winnt.HANDLE;
lpBuffer : windef.LPVOID; nBufferLength : windef.DWORD;
bWatchSubtree : windef.WINBOOL; dwNotifyFilter : windef.DWORD;
lpBytesReturned : access windef.DWORD;
lpOverlapped : access struct_OVERLAPPED;
lpCompletionRoutine : LPOVERLAPPED_COMPLETION_ROUTINE)
return windef.WINBOOL;
pragma Import (C, ReadDirectoryChangesW, "ReadDirectoryChangesW");
function VirtualLock (lpAddress : windef.LPVOID; dwSize : basetsd.SIZE_T)
return windef.WINBOOL;
pragma Import (C, VirtualLock, "VirtualLock");
function VirtualUnlock (lpAddress : windef.LPVOID;
dwSize : basetsd.SIZE_T) return windef.WINBOOL;
pragma Import (C, VirtualUnlock, "VirtualUnlock");
function MapViewOfFileEx (hFileMappingObject : winnt.HANDLE;
dwDesiredAccess : windef.DWORD; dwFileOffsetHigh : windef.DWORD;
dwFileOffsetLow : windef.DWORD; dwNumberOfBytesToMap : basetsd.SIZE_T;
lpBaseAddress : windef.LPVOID) return windef.LPVOID;
pragma Import (C, MapViewOfFileEx, "MapViewOfFileEx");
function SetPriorityClass (hProcess : winnt.HANDLE;
dwPriorityClass : windef.DWORD) return windef.WINBOOL;
pragma Import (C, SetPriorityClass, "SetPriorityClass");
function GetPriorityClass (hProcess : winnt.HANDLE) return windef.DWORD;
pragma Import (C, GetPriorityClass, "GetPriorityClass");
function IsBadReadPtr (lp : void_const_ptr; ucb : basetsd.UINT_PTR)
return windef.WINBOOL;
pragma Import (C, IsBadReadPtr, "IsBadReadPtr");
function IsBadWritePtr (lp : windef.LPVOID; ucb : basetsd.UINT_PTR)
return windef.WINBOOL;
pragma Import (C, IsBadWritePtr, "IsBadWritePtr");
function IsBadHugeReadPtr (lp : void_const_ptr; ucb : basetsd.UINT_PTR)
return windef.WINBOOL;
pragma Import (C, IsBadHugeReadPtr, "IsBadHugeReadPtr");
function IsBadHugeWritePtr (lp : windef.LPVOID; ucb : basetsd.UINT_PTR)
return windef.WINBOOL;
pragma Import (C, IsBadHugeWritePtr, "IsBadHugeWritePtr");
function IsBadCodePtr (lpfn : windef.FARPROC) return windef.WINBOOL;
pragma Import (C, IsBadCodePtr, "IsBadCodePtr");
function IsBadStringPtrA (lpsz : access constant winnt.C_CHAR;
ucchMax : basetsd.UINT_PTR) return windef.WINBOOL;
pragma Import (C, IsBadStringPtrA, "IsBadStringPtrA");
function IsBadStringPtrW (lpsz : access constant winnt.WCHAR;
ucchMax : basetsd.UINT_PTR) return windef.WINBOOL;
pragma Import (C, IsBadStringPtrW, "IsBadStringPtrW");
function LookupAccountSidA (lpSystemName : access constant winnt.C_CHAR;
Sid : winnt.PSID; Name : access winnt.C_CHAR;
cchName : access windef.DWORD;
ReferencedDomainName : access winnt.C_CHAR;
cchReferencedDomainName : access windef.DWORD;
peUse : access winnt.enum_SID_NAME_USE) return windef.WINBOOL;
pragma Import (C, LookupAccountSidA, "LookupAccountSidA");
function LookupAccountSidW (lpSystemName : access constant winnt.WCHAR;
Sid : winnt.PSID; Name : access winnt.WCHAR;
cchName : access windef.DWORD;
ReferencedDomainName : access winnt.WCHAR;
cchReferencedDomainName : access windef.DWORD;
peUse : access winnt.enum_SID_NAME_USE) return windef.WINBOOL;
pragma Import (C, LookupAccountSidW, "LookupAccountSidW");
function LookupAccountNameA (lpSystemName : access constant winnt.C_CHAR;
lpAccountName : access constant winnt.C_CHAR; Sid : winnt.PSID;
cbSid : access windef.DWORD;
ReferencedDomainName : access winnt.C_CHAR;
cchReferencedDomainName : access windef.DWORD;
peUse : access winnt.enum_SID_NAME_USE) return windef.WINBOOL;
pragma Import (C, LookupAccountNameA, "LookupAccountNameA");
function LookupAccountNameW (lpSystemName : access constant winnt.WCHAR;
lpAccountName : access constant winnt.WCHAR; Sid : winnt.PSID;
cbSid : access windef.DWORD; ReferencedDomainName : access winnt.WCHAR;
cchReferencedDomainName : access windef.DWORD;
peUse : access winnt.enum_SID_NAME_USE) return windef.WINBOOL;
pragma Import (C, LookupAccountNameW, "LookupAccountNameW");
function LookupPrivilegeValueA (
lpSystemName : access constant winnt.C_CHAR;
lpName : access constant winnt.C_CHAR;
lpLuid : access winnt.struct_LUID) return windef.WINBOOL;
pragma Import (C, LookupPrivilegeValueA, "LookupPrivilegeValueA");
function LookupPrivilegeValueW (
lpSystemName : access constant winnt.WCHAR;
lpName : access constant winnt.WCHAR;
lpLuid : access winnt.struct_LUID) return windef.WINBOOL;
pragma Import (C, LookupPrivilegeValueW, "LookupPrivilegeValueW");
function LookupPrivilegeNameA (
lpSystemName : access constant winnt.C_CHAR;
lpLuid : access winnt.struct_LUID; lpName : access winnt.C_CHAR;
cchName : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, LookupPrivilegeNameA, "LookupPrivilegeNameA");
function LookupPrivilegeNameW (lpSystemName : access constant winnt.WCHAR;
lpLuid : access winnt.struct_LUID; lpName : access winnt.WCHAR;
cchName : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, LookupPrivilegeNameW, "LookupPrivilegeNameW");
function LookupPrivilegeDisplayNameA (
lpSystemName : access constant winnt.C_CHAR;
lpName : access constant winnt.C_CHAR;
lpDisplayName : access winnt.C_CHAR;
cchDisplayName : access windef.DWORD;
lpLanguageId : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, LookupPrivilegeDisplayNameA,
"LookupPrivilegeDisplayNameA");
function LookupPrivilegeDisplayNameW (
lpSystemName : access constant winnt.WCHAR;
lpName : access constant winnt.WCHAR;
lpDisplayName : access winnt.WCHAR;
cchDisplayName : access windef.DWORD;
lpLanguageId : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, LookupPrivilegeDisplayNameW,
"LookupPrivilegeDisplayNameW");
function AllocateLocallyUniqueId (Luid : access winnt.struct_LUID)
return windef.WINBOOL;
pragma Import (C, AllocateLocallyUniqueId, "AllocateLocallyUniqueId");
function BuildCommDCBA (lpDef : access constant winnt.C_CHAR;
lpDCB : access struct_DCB) return windef.WINBOOL;
pragma Import (C, BuildCommDCBA, "BuildCommDCBA");
function BuildCommDCBW (lpDef : access constant winnt.WCHAR;
lpDCB : access struct_DCB) return windef.WINBOOL;
pragma Import (C, BuildCommDCBW, "BuildCommDCBW");
function BuildCommDCBAndTimeoutsA (lpDef : access constant winnt.C_CHAR;
lpDCB : access struct_DCB; lpCommTimeouts : access struct_COMMTIMEOUTS)
return windef.WINBOOL;
pragma Import (C, BuildCommDCBAndTimeoutsA, "BuildCommDCBAndTimeoutsA");
function BuildCommDCBAndTimeoutsW (lpDef : access constant winnt.WCHAR;
lpDCB : access struct_DCB; lpCommTimeouts : access struct_COMMTIMEOUTS)
return windef.WINBOOL;
pragma Import (C, BuildCommDCBAndTimeoutsW, "BuildCommDCBAndTimeoutsW");
function CommConfigDialogA (lpszName : access constant winnt.C_CHAR;
hWnd : access windef.struct_HWND; lpCC : access struct_COMMCONFIG)
return windef.WINBOOL;
pragma Import (C, CommConfigDialogA, "CommConfigDialogA");
function CommConfigDialogW (lpszName : access constant winnt.WCHAR;
hWnd : access windef.struct_HWND; lpCC : access struct_COMMCONFIG)
return windef.WINBOOL;
pragma Import (C, CommConfigDialogW, "CommConfigDialogW");
function GetDefaultCommConfigA (lpszName : access constant winnt.C_CHAR;
lpCC : access struct_COMMCONFIG; lpdwSize : access windef.DWORD)
return windef.WINBOOL;
pragma Import (C, GetDefaultCommConfigA, "GetDefaultCommConfigA");
function GetDefaultCommConfigW (lpszName : access constant winnt.WCHAR;
lpCC : access struct_COMMCONFIG; lpdwSize : access windef.DWORD)
return windef.WINBOOL;
pragma Import (C, GetDefaultCommConfigW, "GetDefaultCommConfigW");
function SetDefaultCommConfigA (lpszName : access constant winnt.C_CHAR;
lpCC : access struct_COMMCONFIG; dwSize : windef.DWORD)
return windef.WINBOOL;
pragma Import (C, SetDefaultCommConfigA, "SetDefaultCommConfigA");
function SetDefaultCommConfigW (lpszName : access constant winnt.WCHAR;
lpCC : access struct_COMMCONFIG; dwSize : windef.DWORD)
return windef.WINBOOL;
pragma Import (C, SetDefaultCommConfigW, "SetDefaultCommConfigW");
function GetComputerNameA (lpBuffer : access winnt.C_CHAR;
nSize : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, GetComputerNameA, "GetComputerNameA");
function GetComputerNameW (lpBuffer : access winnt.WCHAR;
nSize : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, GetComputerNameW, "GetComputerNameW");
function SetComputerNameA (lpComputerName : access constant winnt.C_CHAR)
return windef.WINBOOL;
pragma Import (C, SetComputerNameA, "SetComputerNameA");
function SetComputerNameW (lpComputerName : access constant winnt.WCHAR)
return windef.WINBOOL;
pragma Import (C, SetComputerNameW, "SetComputerNameW");
type enum_COMPUTER_NAME_FORMAT;
type enum_COMPUTER_NAME_FORMAT is (ComputerNameNetBIOS,
ComputerNameDnsHostname, ComputerNameDnsDomain,
ComputerNameDnsFullyQualified, ComputerNamePhysicalNetBIOS,
ComputerNamePhysicalDnsHostname, ComputerNamePhysicalDnsDomain,
ComputerNamePhysicalDnsFullyQualified, ComputerNameMax);
for enum_COMPUTER_NAME_FORMAT use (ComputerNameNetBIOS => 0,
ComputerNameDnsHostname => 1, ComputerNameDnsDomain => 2,
ComputerNameDnsFullyQualified => 3, ComputerNamePhysicalNetBIOS => 4,
ComputerNamePhysicalDnsHostname => 5,
ComputerNamePhysicalDnsDomain => 6,
ComputerNamePhysicalDnsFullyQualified => 7, ComputerNameMax => 8);
pragma Convention (C, enum_COMPUTER_NAME_FORMAT);
subtype COMPUTER_NAME_FORMAT is enum_COMPUTER_NAME_FORMAT;
function GetComputerNameExA (NameType : COMPUTER_NAME_FORMAT;
lpBuffer : access winnt.C_CHAR; nSize : access windef.DWORD)
return windef.WINBOOL;
pragma Import (C, GetComputerNameExA, "GetComputerNameExA");
function GetComputerNameExW (NameType : COMPUTER_NAME_FORMAT;
lpBuffer : access winnt.WCHAR; nSize : access windef.DWORD)
return windef.WINBOOL;
pragma Import (C, GetComputerNameExW, "GetComputerNameExW");
function SetComputerNameExA (NameType : COMPUTER_NAME_FORMAT;
lpBuffer : access constant winnt.C_CHAR) return windef.WINBOOL;
pragma Import (C, SetComputerNameExA, "SetComputerNameExA");
function SetComputerNameExW (NameType : COMPUTER_NAME_FORMAT;
lpBuffer : access constant winnt.WCHAR) return windef.WINBOOL;
pragma Import (C, SetComputerNameExW, "SetComputerNameExW");
function DnsHostnameToComputerNameA (
Hostname : access constant winnt.C_CHAR;
ComputerName : access winnt.C_CHAR; nSize : access windef.DWORD)
return windef.WINBOOL;
pragma Import (C, DnsHostnameToComputerNameA,
"DnsHostnameToComputerNameA");
function DnsHostnameToComputerNameW (
Hostname : access constant winnt.WCHAR;
ComputerName : access winnt.WCHAR; nSize : access windef.DWORD)
return windef.WINBOOL;
pragma Import (C, DnsHostnameToComputerNameW,
"DnsHostnameToComputerNameW");
function GetUserNameA (lpBuffer : access winnt.C_CHAR;
pcbBuffer : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, GetUserNameA, "GetUserNameA");
function GetUserNameW (lpBuffer : access winnt.WCHAR;
pcbBuffer : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, GetUserNameW, "GetUserNameW");
function LogonUserA (lpszUsername : access constant winnt.C_CHAR;
lpszDomain : access constant winnt.C_CHAR;
lpszPassword : access constant winnt.C_CHAR;
dwLogonType : windef.DWORD; dwLogonProvider : windef.DWORD;
phToken : access winnt.HANDLE) return windef.WINBOOL;
pragma Import (C, LogonUserA, "LogonUserA");
function LogonUserW (lpszUsername : access constant winnt.WCHAR;
lpszDomain : access constant winnt.WCHAR;
lpszPassword : access constant winnt.WCHAR; dwLogonType : windef.DWORD;
dwLogonProvider : windef.DWORD; phToken : access winnt.HANDLE)
return windef.WINBOOL;
pragma Import (C, LogonUserW, "LogonUserW");
function LogonUserExA (lpszUsername : access constant winnt.C_CHAR;
lpszDomain : access constant winnt.C_CHAR;
lpszPassword : access constant winnt.C_CHAR;
dwLogonType : windef.DWORD; dwLogonProvider : windef.DWORD;
phToken : access winnt.HANDLE; ppLogonSid : access winnt.PSID;
ppProfileBuffer : access winnt.PVOID;
pdwProfileLength : access windef.DWORD;
pQuotaLimits : access winnt.struct_QUOTA_LIMITS) return windef.WINBOOL;
pragma Import (C, LogonUserExA, "LogonUserExA");
function LogonUserExW (lpszUsername : access constant winnt.WCHAR;
lpszDomain : access constant winnt.WCHAR;
lpszPassword : access constant winnt.WCHAR; dwLogonType : windef.DWORD;
dwLogonProvider : windef.DWORD; phToken : access winnt.HANDLE;
ppLogonSid : access winnt.PSID; ppProfileBuffer : access winnt.PVOID;
pdwProfileLength : access windef.DWORD;
pQuotaLimits : access winnt.struct_QUOTA_LIMITS) return windef.WINBOOL;
pragma Import (C, LogonUserExW, "LogonUserExW");
function ImpersonateLoggedOnUser (hToken : winnt.HANDLE)
return windef.WINBOOL;
pragma Import (C, ImpersonateLoggedOnUser, "ImpersonateLoggedOnUser");
function CreateProcessAsUserA (hToken : winnt.HANDLE;
lpApplicationName : access constant winnt.C_CHAR;
lpCommandLine : access winnt.C_CHAR;
lpProcessAttributes : access struct_SECURITY_ATTRIBUTES;
lpThreadAttributes : access struct_SECURITY_ATTRIBUTES;
bInheritHandles : windef.WINBOOL; dwCreationFlags : windef.DWORD;
lpEnvironment : windef.LPVOID;
lpCurrentDirectory : access constant winnt.C_CHAR;
lpStartupInfo : access struct_STARTUPINFOA;
lpProcessInformation : access struct_PROCESS_INFORMATION)
return windef.WINBOOL;
pragma Import (C, CreateProcessAsUserA, "CreateProcessAsUserA");
function CreateProcessAsUserW (hToken : winnt.HANDLE;
lpApplicationName : access constant winnt.WCHAR;
lpCommandLine : access winnt.WCHAR;
lpProcessAttributes : access struct_SECURITY_ATTRIBUTES;
lpThreadAttributes : access struct_SECURITY_ATTRIBUTES;
bInheritHandles : windef.WINBOOL; dwCreationFlags : windef.DWORD;
lpEnvironment : windef.LPVOID;
lpCurrentDirectory : access constant winnt.WCHAR;
lpStartupInfo : access struct_STARTUPINFOW;
lpProcessInformation : access struct_PROCESS_INFORMATION)
return windef.WINBOOL;
pragma Import (C, CreateProcessAsUserW, "CreateProcessAsUserW");
function CreateProcessWithLogonW (
lpUsername : access constant winnt.WCHAR;
lpDomain : access constant winnt.WCHAR;
lpPassword : access constant winnt.WCHAR; dwLogonFlags : windef.DWORD;
lpApplicationName : access constant winnt.WCHAR;
lpCommandLine : access winnt.WCHAR; dwCreationFlags : windef.DWORD;
lpEnvironment : windef.LPVOID;
lpCurrentDirectory : access constant winnt.WCHAR;
lpStartupInfo : access struct_STARTUPINFOW;
lpProcessInformation : access struct_PROCESS_INFORMATION)
return windef.WINBOOL;
pragma Import (C, CreateProcessWithLogonW, "CreateProcessWithLogonW");
function CreateProcessWithTokenW (hToken : winnt.HANDLE;
dwLogonFlags : windef.DWORD;
lpApplicationName : access constant winnt.WCHAR;
lpCommandLine : access winnt.WCHAR; dwCreationFlags : windef.DWORD;
lpEnvironment : windef.LPVOID;
lpCurrentDirectory : access constant winnt.WCHAR;
lpStartupInfo : access struct_STARTUPINFOW;
lpProcessInformation : access struct_PROCESS_INFORMATION)
return windef.WINBOOL;
pragma Import (C, CreateProcessWithTokenW, "CreateProcessWithTokenW");
function ImpersonateAnonymousToken (ThreadHandle : winnt.HANDLE)
return windef.WINBOOL;
pragma Import (C, ImpersonateAnonymousToken, "ImpersonateAnonymousToken");
function DuplicateTokenEx (hExistingToken : winnt.HANDLE;
dwDesiredAccess : windef.DWORD;
lpTokenAttributes : access struct_SECURITY_ATTRIBUTES;
ImpersonationLevel : winnt.SECURITY_IMPERSONATION_LEVEL;
TokenType : winnt.TOKEN_TYPE; phNewToken : access winnt.HANDLE)
return windef.WINBOOL;
pragma Import (C, DuplicateTokenEx, "DuplicateTokenEx");
function CreateRestrictedToken (ExistingTokenHandle : winnt.HANDLE;
Flags : windef.DWORD; DisableSidCount : windef.DWORD;
SidsToDisable : access winnt.struct_SID_AND_ATTRIBUTES;
DeletePrivilegeCount : windef.DWORD;
PrivilegesToDelete : access winnt.struct_LUID_AND_ATTRIBUTES;
RestrictedSidCount : windef.DWORD;
SidsToRestrict : access winnt.struct_SID_AND_ATTRIBUTES;
NewTokenHandle : access winnt.HANDLE) return windef.WINBOOL;
pragma Import (C, CreateRestrictedToken, "CreateRestrictedToken");
function IsTokenRestricted (TokenHandle : winnt.HANDLE)
return windef.WINBOOL;
pragma Import (C, IsTokenRestricted, "IsTokenRestricted");
function IsTokenUntrusted (TokenHandle : winnt.HANDLE)
return windef.WINBOOL;
pragma Import (C, IsTokenUntrusted, "IsTokenUntrusted");
function CheckTokenMembership (TokenHandle : winnt.HANDLE;
SidToCheck : winnt.PSID; IsMember : access windef.WINBOOL)
return windef.WINBOOL;
pragma Import (C, CheckTokenMembership, "CheckTokenMembership");
subtype WAITORTIMERCALLBACK is winnt.WAITORTIMERCALLBACKFUNC;
function RegisterWaitForSingleObject (
phNewWaitObject : access winnt.HANDLE; hObject : winnt.HANDLE;
Callback : WAITORTIMERCALLBACK; Context : winnt.PVOID;
dwMilliseconds : windef.ULONG; dwFlags : windef.ULONG)
return windef.WINBOOL;
pragma Import (C, RegisterWaitForSingleObject,
"RegisterWaitForSingleObject");
function RegisterWaitForSingleObjectEx (hObject : winnt.HANDLE;
Callback : WAITORTIMERCALLBACK; Context : winnt.PVOID;
dwMilliseconds : windef.ULONG; dwFlags : windef.ULONG)
return winnt.HANDLE;
pragma Import (C, RegisterWaitForSingleObjectEx,
"RegisterWaitForSingleObjectEx");
function UnregisterWait (WaitHandle : winnt.HANDLE) return windef.WINBOOL;
pragma Import (C, UnregisterWait, "UnregisterWait");
function UnregisterWaitEx (WaitHandle : winnt.HANDLE;
CompletionEvent : winnt.HANDLE) return windef.WINBOOL;
pragma Import (C, UnregisterWaitEx, "UnregisterWaitEx");
function QueueUserWorkItem (A_Function : LPTHREAD_START_ROUTINE;
Context : winnt.PVOID; Flags : windef.ULONG) return windef.WINBOOL;
pragma Import (C, QueueUserWorkItem, "QueueUserWorkItem");
function BindIoCompletionCallback (FileHandle : winnt.HANDLE;
A_Function : LPOVERLAPPED_COMPLETION_ROUTINE; Flags : windef.ULONG)
return windef.WINBOOL;
pragma Import (C, BindIoCompletionCallback, "BindIoCompletionCallback");
function CreateTimerQueue return winnt.HANDLE;
pragma Import (C, CreateTimerQueue, "CreateTimerQueue");
function CreateTimerQueueTimer (phNewTimer : access winnt.HANDLE;
TimerQueue : winnt.HANDLE; Callback : WAITORTIMERCALLBACK;
Parameter : winnt.PVOID; DueTime : windef.DWORD; Period : windef.DWORD;
Flags : windef.ULONG) return windef.WINBOOL;
pragma Import (C, CreateTimerQueueTimer, "CreateTimerQueueTimer");
function ChangeTimerQueueTimer (TimerQueue : winnt.HANDLE;
Timer : winnt.HANDLE; DueTime : windef.ULONG; Period : windef.ULONG)
return windef.WINBOOL;
pragma Import (C, ChangeTimerQueueTimer, "ChangeTimerQueueTimer");
function DeleteTimerQueueTimer (TimerQueue : winnt.HANDLE;
Timer : winnt.HANDLE; CompletionEvent : winnt.HANDLE)
return windef.WINBOOL;
pragma Import (C, DeleteTimerQueueTimer, "DeleteTimerQueueTimer");
function DeleteTimerQueueEx (TimerQueue : winnt.HANDLE;
CompletionEvent : winnt.HANDLE) return windef.WINBOOL;
pragma Import (C, DeleteTimerQueueEx, "DeleteTimerQueueEx");
function SetTimerQueueTimer (TimerQueue : winnt.HANDLE;
Callback : WAITORTIMERCALLBACK; Parameter : winnt.PVOID;
DueTime : windef.DWORD; Period : windef.DWORD;
PreferIo : windef.WINBOOL) return winnt.HANDLE;
pragma Import (C, SetTimerQueueTimer, "SetTimerQueueTimer");
function CancelTimerQueueTimer (TimerQueue : winnt.HANDLE;
Timer : winnt.HANDLE) return windef.WINBOOL;
pragma Import (C, CancelTimerQueueTimer, "CancelTimerQueueTimer");
function DeleteTimerQueue (TimerQueue : winnt.HANDLE)
return windef.WINBOOL;
pragma Import (C, DeleteTimerQueue, "DeleteTimerQueue");
type struct_tagHW_PROFILE_INFOA;
type struct_tagHW_PROFILE_INFOA is record
dwDockInfo : aliased windef.DWORD;
szHwProfileGuid : aliased winnt.C_CHAR_array (0 .. 38);
szHwProfileName : aliased winnt.C_CHAR_array (0 .. 79);
end record;
pragma Convention (C_Pass_By_Copy, struct_tagHW_PROFILE_INFOA);
type struct_tagHW_PROFILE_INFOA_ptr is
access all struct_tagHW_PROFILE_INFOA;
for struct_tagHW_PROFILE_INFOA_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_tagHW_PROFILE_INFOA_ptr);
pragma Convention (C, struct_tagHW_PROFILE_INFOA_ptr);
subtype HW_PROFILE_INFOA is struct_tagHW_PROFILE_INFOA;
subtype LPHW_PROFILE_INFOA is struct_tagHW_PROFILE_INFOA_ptr;
type struct_tagHW_PROFILE_INFOW;
type struct_tagHW_PROFILE_INFOW is record
dwDockInfo : aliased windef.DWORD;
szHwProfileGuid : aliased winnt.WCHAR_array (0 .. 38);
szHwProfileName : aliased winnt.WCHAR_array (0 .. 79);
end record;
pragma Convention (C_Pass_By_Copy, struct_tagHW_PROFILE_INFOW);
type struct_tagHW_PROFILE_INFOW_ptr is
access all struct_tagHW_PROFILE_INFOW;
for struct_tagHW_PROFILE_INFOW_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_tagHW_PROFILE_INFOW_ptr);
pragma Convention (C, struct_tagHW_PROFILE_INFOW_ptr);
subtype HW_PROFILE_INFOW is struct_tagHW_PROFILE_INFOW;
subtype LPHW_PROFILE_INFOW is struct_tagHW_PROFILE_INFOW_ptr;
subtype HW_PROFILE_INFO is HW_PROFILE_INFOW;
subtype LPHW_PROFILE_INFO is LPHW_PROFILE_INFOW;
function GetCurrentHwProfileA (
lpHwProfileInfo : access struct_tagHW_PROFILE_INFOA)
return windef.WINBOOL;
pragma Import (C, GetCurrentHwProfileA, "GetCurrentHwProfileA");
function GetCurrentHwProfileW (
lpHwProfileInfo : access struct_tagHW_PROFILE_INFOW)
return windef.WINBOOL;
pragma Import (C, GetCurrentHwProfileW, "GetCurrentHwProfileW");
function QueryPerformanceCounter (
lpPerformanceCount : access winnt.LARGE_INTEGER) return windef.WINBOOL;
pragma Import (C, QueryPerformanceCounter, "QueryPerformanceCounter");
function QueryPerformanceFrequency (
lpFrequency : access winnt.LARGE_INTEGER) return windef.WINBOOL;
pragma Import (C, QueryPerformanceFrequency, "QueryPerformanceFrequency");
function GetVersionExA (
lpVersionInformation : access winnt.struct_OSVERSIONINFOA)
return windef.WINBOOL;
pragma Import (C, GetVersionExA, "GetVersionExA");
function GetVersionExW (
lpVersionInformation : access winnt.struct_OSVERSIONINFOW)
return windef.WINBOOL;
pragma Import (C, GetVersionExW, "GetVersionExW");
function VerifyVersionInfoA (
lpVersionInformation : access winnt.struct_OSVERSIONINFOEXA;
dwTypeMask : windef.DWORD; dwlConditionMask : winnt.DWORDLONG)
return windef.WINBOOL;
pragma Import (C, VerifyVersionInfoA, "VerifyVersionInfoA");
function VerifyVersionInfoW (
lpVersionInformation : access winnt.struct_OSVERSIONINFOEXW;
dwTypeMask : windef.DWORD; dwlConditionMask : winnt.DWORDLONG)
return windef.WINBOOL;
pragma Import (C, VerifyVersionInfoW, "VerifyVersionInfoW");
type struct_SYSTEM_POWER_STATUS;
type struct_SYSTEM_POWER_STATUS is record
ACLineStatus : aliased windef.BYTE;
BatteryFlag : aliased windef.BYTE;
BatteryLifePercent : aliased windef.BYTE;
Reserved1 : aliased windef.BYTE;
BatteryLifeTime : aliased windef.DWORD;
BatteryFullLifeTime : aliased windef.DWORD;
end record;
pragma Convention (C_Pass_By_Copy, struct_SYSTEM_POWER_STATUS);
type struct_SYSTEM_POWER_STATUS_ptr is
access all struct_SYSTEM_POWER_STATUS;
for struct_SYSTEM_POWER_STATUS_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_SYSTEM_POWER_STATUS_ptr);
pragma Convention (C, struct_SYSTEM_POWER_STATUS_ptr);
subtype SYSTEM_POWER_STATUS is struct_SYSTEM_POWER_STATUS;
subtype LPSYSTEM_POWER_STATUS is struct_SYSTEM_POWER_STATUS_ptr;
function GetSystemPowerStatus (
lpSystemPowerStatus : access struct_SYSTEM_POWER_STATUS)
return windef.WINBOOL;
pragma Import (C, GetSystemPowerStatus, "GetSystemPowerStatus");
function SetSystemPowerState (fSuspend : windef.WINBOOL;
fForce : windef.WINBOOL) return windef.WINBOOL;
pragma Import (C, SetSystemPowerState, "SetSystemPowerState");
function AllocateUserPhysicalPages (hProcess : winnt.HANDLE;
NumberOfPages : access unsigned_long_long;
PageArray : access unsigned_long_long) return windef.WINBOOL;
pragma Import (C, AllocateUserPhysicalPages, "AllocateUserPhysicalPages");
function FreeUserPhysicalPages (hProcess : winnt.HANDLE;
NumberOfPages : access unsigned_long_long;
PageArray : access unsigned_long_long) return windef.WINBOOL;
pragma Import (C, FreeUserPhysicalPages, "FreeUserPhysicalPages");
function MapUserPhysicalPages (VirtualAddress : winnt.PVOID;
NumberOfPages : basetsd.ULONG_PTR;
PageArray : access unsigned_long_long) return windef.WINBOOL;
pragma Import (C, MapUserPhysicalPages, "MapUserPhysicalPages");
function MapUserPhysicalPagesScatter (
VirtualAddresses : access winnt.PVOID;
NumberOfPages : basetsd.ULONG_PTR;
PageArray : access unsigned_long_long) return windef.WINBOOL;
pragma Import (C, MapUserPhysicalPagesScatter,
"MapUserPhysicalPagesScatter");
function CreateJobObjectA (
lpJobAttributes : access struct_SECURITY_ATTRIBUTES;
lpName : access constant winnt.C_CHAR) return winnt.HANDLE;
pragma Import (C, CreateJobObjectA, "CreateJobObjectA");
function CreateJobObjectW (
lpJobAttributes : access struct_SECURITY_ATTRIBUTES;
lpName : access constant winnt.WCHAR) return winnt.HANDLE;
pragma Import (C, CreateJobObjectW, "CreateJobObjectW");
function OpenJobObjectA (dwDesiredAccess : windef.DWORD;
bInheritHandle : windef.WINBOOL; lpName : access constant winnt.C_CHAR)
return winnt.HANDLE;
pragma Import (C, OpenJobObjectA, "OpenJobObjectA");
function OpenJobObjectW (dwDesiredAccess : windef.DWORD;
bInheritHandle : windef.WINBOOL; lpName : access constant winnt.WCHAR)
return winnt.HANDLE;
pragma Import (C, OpenJobObjectW, "OpenJobObjectW");
function AssignProcessToJobObject (hJob : winnt.HANDLE;
hProcess : winnt.HANDLE) return windef.WINBOOL;
pragma Import (C, AssignProcessToJobObject, "AssignProcessToJobObject");
function TerminateJobObject (hJob : winnt.HANDLE; uExitCode : windef.UINT)
return windef.WINBOOL;
pragma Import (C, TerminateJobObject, "TerminateJobObject");
function QueryInformationJobObject (hJob : winnt.HANDLE;
JobObjectInformationClass : winnt.JOBOBJECTINFOCLASS;
lpJobObjectInformation : windef.LPVOID;
cbJobObjectInformationLength : windef.DWORD;
lpReturnLength : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, QueryInformationJobObject, "QueryInformationJobObject");
function SetInformationJobObject (hJob : winnt.HANDLE;
JobObjectInformationClass : winnt.JOBOBJECTINFOCLASS;
lpJobObjectInformation : windef.LPVOID;
cbJobObjectInformationLength : windef.DWORD) return windef.WINBOOL;
pragma Import (C, SetInformationJobObject, "SetInformationJobObject");
function IsProcessInJob (ProcessHandle : winnt.HANDLE;
JobHandle : winnt.HANDLE; Result : access windef.WINBOOL)
return windef.WINBOOL;
pragma Import (C, IsProcessInJob, "IsProcessInJob");
function CreateJobSet (NumJob : windef.ULONG;
UserJobSet : access winnt.struct_JOB_SET_ARRAY; Flags : windef.ULONG)
return windef.WINBOOL;
pragma Import (C, CreateJobSet, "CreateJobSet");
function AddVectoredExceptionHandler (First : windef.ULONG;
Handler : winnt.PVECTORED_EXCEPTION_HANDLER) return winnt.PVOID;
pragma Import (C, AddVectoredExceptionHandler,
"AddVectoredExceptionHandler");
function RemoveVectoredExceptionHandler (Handle : winnt.PVOID)
return windef.ULONG;
pragma Import (C, RemoveVectoredExceptionHandler,
"RemoveVectoredExceptionHandler");
function AddVectoredContinueHandler (First : windef.ULONG;
Handler : winnt.PVECTORED_EXCEPTION_HANDLER) return winnt.PVOID;
pragma Import (C, AddVectoredContinueHandler,
"AddVectoredContinueHandler");
function RemoveVectoredContinueHandler (Handle : winnt.PVOID)
return windef.ULONG;
pragma Import (C, RemoveVectoredContinueHandler,
"RemoveVectoredContinueHandler");
function FindFirstVolumeA (lpszVolumeName : access winnt.C_CHAR;
cchBufferLength : windef.DWORD) return winnt.HANDLE;
pragma Import (C, FindFirstVolumeA, "FindFirstVolumeA");
function FindFirstVolumeW (lpszVolumeName : access winnt.WCHAR;
cchBufferLength : windef.DWORD) return winnt.HANDLE;
pragma Import (C, FindFirstVolumeW, "FindFirstVolumeW");
function FindNextVolumeA (hFindVolume : winnt.HANDLE;
lpszVolumeName : access winnt.C_CHAR; cchBufferLength : windef.DWORD)
return windef.WINBOOL;
pragma Import (C, FindNextVolumeA, "FindNextVolumeA");
function FindNextVolumeW (hFindVolume : winnt.HANDLE;
lpszVolumeName : access winnt.WCHAR; cchBufferLength : windef.DWORD)
return windef.WINBOOL;
pragma Import (C, FindNextVolumeW, "FindNextVolumeW");
function FindVolumeClose (hFindVolume : winnt.HANDLE)
return windef.WINBOOL;
pragma Import (C, FindVolumeClose, "FindVolumeClose");
function FindFirstVolumeMountPointA (
lpszRootPathName : access constant winnt.C_CHAR;
lpszVolumeMountPoint : access winnt.C_CHAR;
cchBufferLength : windef.DWORD) return winnt.HANDLE;
pragma Import (C, FindFirstVolumeMountPointA,
"FindFirstVolumeMountPointA");
function FindFirstVolumeMountPointW (
lpszRootPathName : access constant winnt.WCHAR;
lpszVolumeMountPoint : access winnt.WCHAR;
cchBufferLength : windef.DWORD) return winnt.HANDLE;
pragma Import (C, FindFirstVolumeMountPointW,
"FindFirstVolumeMountPointW");
function FindNextVolumeMountPointA (hFindVolumeMountPoint : winnt.HANDLE;
lpszVolumeMountPoint : access winnt.C_CHAR;
cchBufferLength : windef.DWORD) return windef.WINBOOL;
pragma Import (C, FindNextVolumeMountPointA, "FindNextVolumeMountPointA");
function FindNextVolumeMountPointW (hFindVolumeMountPoint : winnt.HANDLE;
lpszVolumeMountPoint : access winnt.WCHAR;
cchBufferLength : windef.DWORD) return windef.WINBOOL;
pragma Import (C, FindNextVolumeMountPointW, "FindNextVolumeMountPointW");
function FindVolumeMountPointClose (hFindVolumeMountPoint : winnt.HANDLE)
return windef.WINBOOL;
pragma Import (C, FindVolumeMountPointClose, "FindVolumeMountPointClose");
function SetVolumeMountPointA (
lpszVolumeMountPoint : access constant winnt.C_CHAR;
lpszVolumeName : access constant winnt.C_CHAR) return windef.WINBOOL;
pragma Import (C, SetVolumeMountPointA, "SetVolumeMountPointA");
function SetVolumeMountPointW (
lpszVolumeMountPoint : access constant winnt.WCHAR;
lpszVolumeName : access constant winnt.WCHAR) return windef.WINBOOL;
pragma Import (C, SetVolumeMountPointW, "SetVolumeMountPointW");
function DeleteVolumeMountPointA (
lpszVolumeMountPoint : access constant winnt.C_CHAR)
return windef.WINBOOL;
pragma Import (C, DeleteVolumeMountPointA, "DeleteVolumeMountPointA");
function DeleteVolumeMountPointW (
lpszVolumeMountPoint : access constant winnt.WCHAR)
return windef.WINBOOL;
pragma Import (C, DeleteVolumeMountPointW, "DeleteVolumeMountPointW");
function GetVolumeNameForVolumeMountPointA (
lpszVolumeMountPoint : access constant winnt.C_CHAR;
lpszVolumeName : access winnt.C_CHAR; cchBufferLength : windef.DWORD)
return windef.WINBOOL;
pragma Import (C, GetVolumeNameForVolumeMountPointA,
"GetVolumeNameForVolumeMountPointA");
function GetVolumeNameForVolumeMountPointW (
lpszVolumeMountPoint : access constant winnt.WCHAR;
lpszVolumeName : access winnt.WCHAR; cchBufferLength : windef.DWORD)
return windef.WINBOOL;
pragma Import (C, GetVolumeNameForVolumeMountPointW,
"GetVolumeNameForVolumeMountPointW");
function GetVolumePathNameA (lpszFileName : access constant winnt.C_CHAR;
lpszVolumePathName : access winnt.C_CHAR;
cchBufferLength : windef.DWORD) return windef.WINBOOL;
pragma Import (C, GetVolumePathNameA, "GetVolumePathNameA");
function GetVolumePathNameW (lpszFileName : access constant winnt.WCHAR;
lpszVolumePathName : access winnt.WCHAR;
cchBufferLength : windef.DWORD) return windef.WINBOOL;
pragma Import (C, GetVolumePathNameW, "GetVolumePathNameW");
function GetVolumePathNamesForVolumeNameA (
lpszVolumeName : access constant winnt.C_CHAR;
lpszVolumePathNames : access winnt.C_CHAR;
cchBufferLength : windef.DWORD;
lpcchReturnLength : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, GetVolumePathNamesForVolumeNameA,
"GetVolumePathNamesForVolumeNameA");
function GetVolumePathNamesForVolumeNameW (
lpszVolumeName : access constant winnt.WCHAR;
lpszVolumePathNames : access winnt.WCHAR;
cchBufferLength : windef.DWORD;
lpcchReturnLength : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, GetVolumePathNamesForVolumeNameW,
"GetVolumePathNamesForVolumeNameW");
type struct_tagACTCTXA;
type struct_tagACTCTXA is record
cbSize : aliased windef.ULONG;
dwFlags : aliased windef.DWORD;
lpSource : aliased winnt.LPCSTR;
wProcessorArchitecture : aliased windef.USHORT;
wLangId : aliased winnt.LANGID;
lpAssemblyDirectory : aliased winnt.LPCSTR;
lpResourceName : aliased winnt.LPCSTR;
lpApplicationName : aliased winnt.LPCSTR;
hModule : aliased windef.HMODULE;
end record;
pragma Convention (C_Pass_By_Copy, struct_tagACTCTXA);
type struct_tagACTCTXA_ptr is access all struct_tagACTCTXA;
for struct_tagACTCTXA_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_tagACTCTXA_ptr);
pragma Convention (C, struct_tagACTCTXA_ptr);
type struct_tagACTCTXA_const_ptr is access constant struct_tagACTCTXA;
for struct_tagACTCTXA_const_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_tagACTCTXA_const_ptr);
pragma Convention (C, struct_tagACTCTXA_const_ptr);
subtype ACTCTXA is struct_tagACTCTXA;
subtype ACTCTXA_const_ptr is struct_tagACTCTXA_const_ptr;
subtype PACTCTXA is struct_tagACTCTXA_ptr;
type struct_tagACTCTXW;
type struct_tagACTCTXW is record
cbSize : aliased windef.ULONG;
dwFlags : aliased windef.DWORD;
lpSource : aliased winnt.LPCWSTR;
wProcessorArchitecture : aliased windef.USHORT;
wLangId : aliased winnt.LANGID;
lpAssemblyDirectory : aliased winnt.LPCWSTR;
lpResourceName : aliased winnt.LPCWSTR;
lpApplicationName : aliased winnt.LPCWSTR;
hModule : aliased windef.HMODULE;
end record;
pragma Convention (C_Pass_By_Copy, struct_tagACTCTXW);
type struct_tagACTCTXW_ptr is access all struct_tagACTCTXW;
for struct_tagACTCTXW_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_tagACTCTXW_ptr);
pragma Convention (C, struct_tagACTCTXW_ptr);
type struct_tagACTCTXW_const_ptr is access constant struct_tagACTCTXW;
for struct_tagACTCTXW_const_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_tagACTCTXW_const_ptr);
pragma Convention (C, struct_tagACTCTXW_const_ptr);
subtype ACTCTXW is struct_tagACTCTXW;
subtype ACTCTXW_const_ptr is struct_tagACTCTXW_const_ptr;
subtype PACTCTXW is struct_tagACTCTXW_ptr;
subtype PCACTCTXA is ACTCTXA_const_ptr;
subtype PCACTCTXW is ACTCTXW_const_ptr;
subtype ACTCTX is ACTCTXW;
subtype PACTCTX is PACTCTXW;
subtype PCACTCTX is PCACTCTXW;
function CreateActCtxA (pActCtx : access constant ACTCTXA)
return winnt.HANDLE;
pragma Import (C, CreateActCtxA, "CreateActCtxA");
function CreateActCtxW (pActCtx : access constant ACTCTXW)
return winnt.HANDLE;
pragma Import (C, CreateActCtxW, "CreateActCtxW");
procedure AddRefActCtx (hActCtx : winnt.HANDLE);
pragma Import (C, AddRefActCtx, "AddRefActCtx");
procedure ReleaseActCtx (hActCtx : winnt.HANDLE);
pragma Import (C, ReleaseActCtx, "ReleaseActCtx");
function ZombifyActCtx (hActCtx : winnt.HANDLE) return windef.WINBOOL;
pragma Import (C, ZombifyActCtx, "ZombifyActCtx");
function ActivateActCtx (hActCtx : winnt.HANDLE;
lpCookie : access basetsd.ULONG_PTR) return windef.WINBOOL;
pragma Import (C, ActivateActCtx, "ActivateActCtx");
function DeactivateActCtx (dwFlags : windef.DWORD;
ulCookie : basetsd.ULONG_PTR) return windef.WINBOOL;
pragma Import (C, DeactivateActCtx, "DeactivateActCtx");
function GetCurrentActCtx (lphActCtx : access winnt.HANDLE)
return windef.WINBOOL;
pragma Import (C, GetCurrentActCtx, "GetCurrentActCtx");
type struct_tagACTCTX_SECTION_KEYED_DATA_2600;
type struct_tagACTCTX_SECTION_KEYED_DATA_2600 is record
cbSize : aliased windef.ULONG;
ulDataFormatVersion : aliased windef.ULONG;
lpData : aliased winnt.PVOID;
ulLength : aliased windef.ULONG;
lpSectionGlobalData : aliased winnt.PVOID;
ulSectionGlobalDataLength : aliased windef.ULONG;
lpSectionBase : aliased winnt.PVOID;
ulSectionTotalLength : aliased windef.ULONG;
hActCtx : aliased winnt.HANDLE;
ulAssemblyRosterIndex : aliased windef.ULONG;
end record;
pragma Convention (C_Pass_By_Copy,
struct_tagACTCTX_SECTION_KEYED_DATA_2600);
type struct_tagACTCTX_SECTION_KEYED_DATA_2600_ptr is
access all struct_tagACTCTX_SECTION_KEYED_DATA_2600;
for struct_tagACTCTX_SECTION_KEYED_DATA_2600_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_tagACTCTX_SECTION_KEYED_DATA_2600_ptr);
pragma Convention (C, struct_tagACTCTX_SECTION_KEYED_DATA_2600_ptr);
type struct_tagACTCTX_SECTION_KEYED_DATA_2600_const_ptr is
access constant struct_tagACTCTX_SECTION_KEYED_DATA_2600;
for struct_tagACTCTX_SECTION_KEYED_DATA_2600_const_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (
struct_tagACTCTX_SECTION_KEYED_DATA_2600_const_ptr);
pragma Convention (C, struct_tagACTCTX_SECTION_KEYED_DATA_2600_const_ptr);
subtype ACTCTX_SECTION_KEYED_DATA_2600 is
struct_tagACTCTX_SECTION_KEYED_DATA_2600;
subtype ACTCTX_SECTION_KEYED_DATA_2600_const_ptr is
struct_tagACTCTX_SECTION_KEYED_DATA_2600_const_ptr;
subtype PACTCTX_SECTION_KEYED_DATA_2600 is
struct_tagACTCTX_SECTION_KEYED_DATA_2600_ptr;
subtype PCACTCTX_SECTION_KEYED_DATA_2600 is
ACTCTX_SECTION_KEYED_DATA_2600_const_ptr;
type struct_tagACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA;
type struct_tagACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA is record
lpInformation : aliased winnt.PVOID;
lpSectionBase : aliased winnt.PVOID;
ulSectionLength : aliased windef.ULONG;
lpSectionGlobalDataBase : aliased winnt.PVOID;
ulSectionGlobalDataLength : aliased windef.ULONG;
end record;
pragma Convention (C_Pass_By_Copy,
struct_tagACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA);
type struct_tagACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA_ptr is
access all struct_tagACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA;
for struct_tagACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA_ptr'Storage_Size
use 0;
pragma No_Strict_Aliasing (
struct_tagACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA_ptr);
pragma Convention (C,
struct_tagACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA_ptr);
type struct_tagACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA_const_ptr is
access constant struct_tagACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA;
for struct_tagACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA_const_ptr'
Storage_Size use 0;
pragma No_Strict_Aliasing (
struct_tagACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA_const_ptr);
pragma Convention (C,
struct_tagACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA_const_ptr);
subtype ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA is
struct_tagACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA;
subtype ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA_const_ptr is
struct_tagACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA_const_ptr;
subtype PACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA is
struct_tagACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA_ptr;
subtype PCACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA is
ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA_const_ptr;
type struct_tagACTCTX_SECTION_KEYED_DATA;
type struct_tagACTCTX_SECTION_KEYED_DATA is record
cbSize : aliased windef.ULONG;
ulDataFormatVersion : aliased windef.ULONG;
lpData : aliased winnt.PVOID;
ulLength : aliased windef.ULONG;
lpSectionGlobalData : aliased winnt.PVOID;
ulSectionGlobalDataLength : aliased windef.ULONG;
lpSectionBase : aliased winnt.PVOID;
ulSectionTotalLength : aliased windef.ULONG;
hActCtx : aliased winnt.HANDLE;
ulAssemblyRosterIndex : aliased windef.ULONG;
ulFlags : aliased windef.ULONG;
AssemblyMetadata : aliased ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA;
end record;
pragma Convention (C_Pass_By_Copy, struct_tagACTCTX_SECTION_KEYED_DATA);
type struct_tagACTCTX_SECTION_KEYED_DATA_ptr is
access all struct_tagACTCTX_SECTION_KEYED_DATA;
for struct_tagACTCTX_SECTION_KEYED_DATA_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_tagACTCTX_SECTION_KEYED_DATA_ptr);
pragma Convention (C, struct_tagACTCTX_SECTION_KEYED_DATA_ptr);
type struct_tagACTCTX_SECTION_KEYED_DATA_const_ptr is
access constant struct_tagACTCTX_SECTION_KEYED_DATA;
for struct_tagACTCTX_SECTION_KEYED_DATA_const_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_tagACTCTX_SECTION_KEYED_DATA_const_ptr);
pragma Convention (C, struct_tagACTCTX_SECTION_KEYED_DATA_const_ptr);
subtype ACTCTX_SECTION_KEYED_DATA is struct_tagACTCTX_SECTION_KEYED_DATA;
subtype ACTCTX_SECTION_KEYED_DATA_const_ptr is
struct_tagACTCTX_SECTION_KEYED_DATA_const_ptr;
subtype PACTCTX_SECTION_KEYED_DATA is
struct_tagACTCTX_SECTION_KEYED_DATA_ptr;
subtype PCACTCTX_SECTION_KEYED_DATA is
ACTCTX_SECTION_KEYED_DATA_const_ptr;
function FindActCtxSectionStringA (dwFlags : windef.DWORD;
lpExtensionGuid : access constant guiddef.GUID;
ulSectionId : windef.ULONG;
lpStringToFind : access constant winnt.C_CHAR;
ReturnedData : access struct_tagACTCTX_SECTION_KEYED_DATA)
return windef.WINBOOL;
pragma Import (C, FindActCtxSectionStringA, "FindActCtxSectionStringA");
function FindActCtxSectionStringW (dwFlags : windef.DWORD;
lpExtensionGuid : access constant guiddef.GUID;
ulSectionId : windef.ULONG;
lpStringToFind : access constant winnt.WCHAR;
ReturnedData : access struct_tagACTCTX_SECTION_KEYED_DATA)
return windef.WINBOOL;
pragma Import (C, FindActCtxSectionStringW, "FindActCtxSectionStringW");
function FindActCtxSectionGuid (dwFlags : windef.DWORD;
lpExtensionGuid : access constant guiddef.GUID;
ulSectionId : windef.ULONG;
lpGuidToFind : access constant guiddef.GUID;
ReturnedData : access struct_tagACTCTX_SECTION_KEYED_DATA)
return windef.WINBOOL;
pragma Import (C, FindActCtxSectionGuid, "FindActCtxSectionGuid");
type struct_ACTIVATION_CONTEXT_BASIC_INFORMATION;
type struct_ACTIVATION_CONTEXT_BASIC_INFORMATION is record
hActCtx : aliased winnt.HANDLE;
dwFlags : aliased windef.DWORD;
end record;
pragma Convention (C_Pass_By_Copy,
struct_ACTIVATION_CONTEXT_BASIC_INFORMATION);
type struct_ACTIVATION_CONTEXT_BASIC_INFORMATION_ptr is
access all struct_ACTIVATION_CONTEXT_BASIC_INFORMATION;
for struct_ACTIVATION_CONTEXT_BASIC_INFORMATION_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (
struct_ACTIVATION_CONTEXT_BASIC_INFORMATION_ptr);
pragma Convention (C, struct_ACTIVATION_CONTEXT_BASIC_INFORMATION_ptr);
type struct_ACTIVATION_CONTEXT_BASIC_INFORMATION_const_ptr is
access constant struct_ACTIVATION_CONTEXT_BASIC_INFORMATION;
for struct_ACTIVATION_CONTEXT_BASIC_INFORMATION_const_ptr'Storage_Size
use 0;
pragma No_Strict_Aliasing (
struct_ACTIVATION_CONTEXT_BASIC_INFORMATION_const_ptr);
pragma Convention (C,
struct_ACTIVATION_CONTEXT_BASIC_INFORMATION_const_ptr);
subtype ACTIVATION_CONTEXT_BASIC_INFORMATION is
struct_ACTIVATION_CONTEXT_BASIC_INFORMATION;
subtype PACTIVATION_CONTEXT_BASIC_INFORMATION is
struct_ACTIVATION_CONTEXT_BASIC_INFORMATION_ptr;
subtype PCACTIVATION_CONTEXT_BASIC_INFORMATION is
struct_ACTIVATION_CONTEXT_BASIC_INFORMATION_const_ptr;
function QueryActCtxW (dwFlags : windef.DWORD; hActCtx : winnt.HANDLE;
pvSubInstance : winnt.PVOID; ulInfoClass : windef.ULONG;
pvBuffer : winnt.PVOID; cbBuffer : basetsd.SIZE_T;
pcbWrittenOrRequired : access basetsd.SIZE_T) return windef.WINBOOL;
pragma Import (C, QueryActCtxW, "QueryActCtxW");
type access_f6714456 is access function (dwFlags : windef.DWORD;
hActCtx : winnt.HANDLE; pvSubInstance : winnt.PVOID;
ulInfoClass : windef.ULONG; pvBuffer : winnt.PVOID;
cbBuffer : basetsd.SIZE_T;
pcbWrittenOrRequired : access basetsd.SIZE_T) return windef.WINBOOL;
pragma Convention (C, access_f6714456);
subtype PQUERYACTCTXW_FUNC is access_f6714456;
function ProcessIdToSessionId (dwProcessId : windef.DWORD;
pSessionId : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, ProcessIdToSessionId, "ProcessIdToSessionId");
function WTSGetActiveConsoleSessionId return windef.DWORD;
pragma Import (C, WTSGetActiveConsoleSessionId,
"WTSGetActiveConsoleSessionId");
function IsWow64Process (hProcess : winnt.HANDLE;
Wow64Process : access windef.WINBOOL) return windef.WINBOOL;
pragma Import (C, IsWow64Process, "IsWow64Process");
function GetLogicalProcessorInformation (
Buffer : access winnt.struct_SYSTEM_LOGICAL_PROCESSOR_INFORMATION;
ReturnedLength : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, GetLogicalProcessorInformation,
"GetLogicalProcessorInformation");
function GetNumaHighestNodeNumber (
HighestNodeNumber : access windef.ULONG) return windef.WINBOOL;
pragma Import (C, GetNumaHighestNodeNumber, "GetNumaHighestNodeNumber");
function GetNumaProcessorNode (Processor : windef.UCHAR;
NodeNumber : access windef.UCHAR) return windef.WINBOOL;
pragma Import (C, GetNumaProcessorNode, "GetNumaProcessorNode");
function GetNumaNodeProcessorMask (Node : windef.UCHAR;
ProcessorMask : access winnt.ULONGLONG) return windef.WINBOOL;
pragma Import (C, GetNumaNodeProcessorMask, "GetNumaNodeProcessorMask");
function GetNumaAvailableMemoryNode (Node : windef.UCHAR;
AvailableBytes : access winnt.ULONGLONG) return windef.WINBOOL;
pragma Import (C, GetNumaAvailableMemoryNode,
"GetNumaAvailableMemoryNode");
ABOVE_NORMAL_PRIORITY_CLASS : constant := 32768;
ACTCTX_FLAG_APPLICATION_NAME_VALID : constant := 32;
ACTCTX_FLAG_ASSEMBLY_DIRECTORY_VALID : constant := 4;
ACTCTX_FLAG_HMODULE_VALID : constant := 128;
ACTCTX_FLAG_LANGID_VALID : constant := 2;
ACTCTX_FLAG_PROCESSOR_ARCHITECTURE_VALID : constant := 1;
ACTCTX_FLAG_RESOURCE_NAME_VALID : constant := 8;
ACTCTX_FLAG_SET_PROCESS_DEFAULT : constant := 16;
ACTCTX_FLAG_SOURCE_IS_ASSEMBLYREF : constant := 64;
ACTIVATION_CONTEXT_BASIC_INFORMATION_DEFINED : constant := 1;
AC_LINE_BACKUP_POWER : constant := 2;
AC_LINE_OFFLINE : constant := 0;
AC_LINE_ONLINE : constant := 1;
AC_LINE_UNKNOWN : constant := 255;
function AccessCheckAndAuditAlarm (
SubsystemName : access constant winnt.WCHAR; HandleId : windef.LPVOID;
ObjectTypeName : access winnt.WCHAR; ObjectName : access winnt.WCHAR;
SecurityDescriptor : winnt.PSECURITY_DESCRIPTOR;
DesiredAccess : windef.DWORD;
GenericMapping : access winnt.GENERIC_MAPPING;
ObjectCreation : windef.WINBOOL; GrantedAccess : access windef.DWORD;
AccessStatus : access windef.WINBOOL;
pfGenerateOnClose : access windef.WINBOOL) return windef.WINBOOL
renames AccessCheckAndAuditAlarmW;
function AccessCheckByTypeAndAuditAlarm (
SubsystemName : access constant winnt.WCHAR; HandleId : windef.LPVOID;
ObjectTypeName : access constant winnt.WCHAR;
ObjectName : access constant winnt.WCHAR;
SecurityDescriptor : winnt.PSECURITY_DESCRIPTOR;
PrincipalSelfSid : winnt.PSID; DesiredAccess : windef.DWORD;
AuditType : winnt.AUDIT_EVENT_TYPE; Flags : windef.DWORD;
ObjectTypeList : access winnt.struct_OBJECT_TYPE_LIST;
ObjectTypeListLength : windef.DWORD;
GenericMapping : access winnt.GENERIC_MAPPING;
ObjectCreation : windef.WINBOOL; GrantedAccess : access windef.DWORD;
AccessStatus : access windef.WINBOOL;
pfGenerateOnClose : access windef.WINBOOL) return windef.WINBOOL
renames AccessCheckByTypeAndAuditAlarmW;
function AccessCheckByTypeResultListAndAuditAlarm (
SubsystemName : access constant winnt.WCHAR; HandleId : windef.LPVOID;
ObjectTypeName : access constant winnt.WCHAR;
ObjectName : access constant winnt.WCHAR;
SecurityDescriptor : winnt.PSECURITY_DESCRIPTOR;
PrincipalSelfSid : winnt.PSID; DesiredAccess : windef.DWORD;
AuditType : winnt.AUDIT_EVENT_TYPE; Flags : windef.DWORD;
ObjectTypeList : access winnt.struct_OBJECT_TYPE_LIST;
ObjectTypeListLength : windef.DWORD;
GenericMapping : access winnt.GENERIC_MAPPING;
ObjectCreation : windef.WINBOOL; GrantedAccess : access windef.DWORD;
AccessStatusList : access windef.DWORD;
pfGenerateOnClose : access windef.WINBOOL) return windef.WINBOOL
renames AccessCheckByTypeResultListAndAuditAlarmW;
function AccessCheckByTypeResultListAndAuditAlarmByHandle (
SubsystemName : access constant winnt.WCHAR; HandleId : windef.LPVOID;
ClientToken : winnt.HANDLE;
ObjectTypeName : access constant winnt.WCHAR;
ObjectName : access constant winnt.WCHAR;
SecurityDescriptor : winnt.PSECURITY_DESCRIPTOR;
PrincipalSelfSid : winnt.PSID; DesiredAccess : windef.DWORD;
AuditType : winnt.AUDIT_EVENT_TYPE; Flags : windef.DWORD;
ObjectTypeList : access winnt.struct_OBJECT_TYPE_LIST;
ObjectTypeListLength : windef.DWORD;
GenericMapping : access winnt.GENERIC_MAPPING;
ObjectCreation : windef.WINBOOL; GrantedAccess : access windef.DWORD;
AccessStatusList : access windef.DWORD;
pfGenerateOnClose : access windef.WINBOOL) return windef.WINBOOL
renames AccessCheckByTypeResultListAndAuditAlarmByHandleW;
function AddAtom (lpString : access constant winnt.WCHAR)
return windef.ATOM renames AddAtomW;
function AddLocalAlternateComputerName (
lpDnsFQHostname : access constant winnt.WCHAR; ulFlags : windef.ULONG)
return windef.DWORD renames AddLocalAlternateComputerNameW;
BACKUP_ALTERNATE_DATA : constant := 4;
BACKUP_DATA : constant := 1;
BACKUP_EA_DATA : constant := 2;
BACKUP_INVALID : constant := 0;
BACKUP_LINK : constant := 5;
BACKUP_OBJECT_ID : constant := 7;
BACKUP_PROPERTY_DATA : constant := 6;
BACKUP_REPARSE_DATA : constant := 8;
BACKUP_SECURITY_DATA : constant := 3;
BACKUP_SPARSE_BLOCK : constant := 9;
BASE_SEARCH_PATH_DISABLE_SAFE_SEARCHMODE : constant := 65536;
BASE_SEARCH_PATH_ENABLE_SAFE_SEARCHMODE : constant := 1;
BASE_SEARCH_PATH_PERMANENT : constant := 32768;
BATTERY_FLAG_CHARGING : constant := 8;
BATTERY_FLAG_CRITICAL : constant := 4;
BATTERY_FLAG_HIGH : constant := 1;
BATTERY_FLAG_LOW : constant := 2;
BATTERY_FLAG_NO_BATTERY : constant := 128;
BATTERY_FLAG_UNKNOWN : constant := 255;
BATTERY_LIFE_UNKNOWN : constant := -1;
BATTERY_PERCENTAGE_UNKNOWN : constant := 255;
BAUD_075 : constant := 1;
BAUD_110 : constant := 2;
BAUD_115200 : constant := 131072;
BAUD_1200 : constant := 64;
BAUD_128K : constant := 65536;
BAUD_134_5 : constant := 4;
BAUD_14400 : constant := 4096;
BAUD_150 : constant := 8;
BAUD_1800 : constant := 128;
BAUD_19200 : constant := 8192;
BAUD_2400 : constant := 256;
BAUD_300 : constant := 16;
BAUD_38400 : constant := 16384;
BAUD_4800 : constant := 512;
BAUD_56K : constant := 32768;
BAUD_57600 : constant := 262144;
BAUD_600 : constant := 32;
BAUD_7200 : constant := 1024;
BAUD_9600 : constant := 2048;
BAUD_USER : constant := 268435456;
BELOW_NORMAL_PRIORITY_CLASS : constant := 16384;
function BackupEventLog (hEventLog : winnt.HANDLE;
lpBackupFileName : access constant winnt.WCHAR) return windef.WINBOOL
renames BackupEventLogW;
function BeginUpdateResource (pFileName : access constant winnt.WCHAR;
bDeleteExistingResources : windef.WINBOOL) return winnt.HANDLE
renames BeginUpdateResourceW;
function BuildCommDCB (lpDef : access constant winnt.WCHAR;
lpDCB : access struct_DCB) return windef.WINBOOL renames BuildCommDCBW;
function BuildCommDCBAndTimeouts (lpDef : access constant winnt.WCHAR;
lpDCB : access struct_DCB; lpCommTimeouts : access struct_COMMTIMEOUTS)
return windef.WINBOOL renames BuildCommDCBAndTimeoutsW;
CALLBACK_CHUNK_FINISHED : constant := 0;
CALLBACK_STREAM_SWITCH : constant := 1;
CBR_110 : constant := 110;
CBR_115200 : constant := 115200;
CBR_1200 : constant := 1200;
CBR_128000 : constant := 128000;
CBR_14400 : constant := 14400;
CBR_19200 : constant := 19200;
CBR_2400 : constant := 2400;
CBR_256000 : constant := 256000;
CBR_300 : constant := 300;
CBR_38400 : constant := 38400;
CBR_4800 : constant := 4800;
CBR_56000 : constant := 56000;
CBR_57600 : constant := 57600;
CBR_600 : constant := 600;
CBR_9600 : constant := 9600;
CE_BREAK : constant := 16;
CE_DNS : constant := 2048;
CE_FRAME : constant := 8;
CE_IOE : constant := 1024;
CE_MODE : constant := 32768;
CE_OOP : constant := 4096;
CE_OVERRUN : constant := 2;
CE_PTO : constant := 512;
CE_RXOVER : constant := 1;
CE_RXPARITY : constant := 4;
CE_TXFULL : constant := 256;
CLRBREAK : constant := 9;
CLRDTR : constant := 6;
CLRRTS : constant := 4;
COMMPROP_INITIALIZED : constant := 3879531822;
CONTROL_C_EXIT : constant := 3221225786;
COPY_FILE_ALLOW_DECRYPTED_DESTINATION : constant := 8;
COPY_FILE_COPY_SYMLINK : constant := 2048;
COPY_FILE_FAIL_IF_EXISTS : constant := 1;
COPY_FILE_NO_BUFFERING : constant := 4096;
COPY_FILE_OPEN_SOURCE_FOR_WRITE : constant := 4;
COPY_FILE_RESTARTABLE : constant := 2;
CREATE_ALWAYS : constant := 2;
CREATE_BREAKAWAY_FROM_JOB : constant := 16777216;
CREATE_DEFAULT_ERROR_MODE : constant := 67108864;
CREATE_FORCEDOS : constant := 8192;
CREATE_FOR_DIR : constant := 2;
CREATE_FOR_IMPORT : constant := 1;
CREATE_IGNORE_SYSTEM_DEFAULT : constant := -2147483648;
CREATE_NEW : constant := 1;
CREATE_NEW_CONSOLE : constant := 16;
CREATE_NEW_PROCESS_GROUP : constant := 512;
CREATE_NO_WINDOW : constant := 134217728;
CREATE_PRESERVE_CODE_AUTHZ_LEVEL : constant := 33554432;
CREATE_PROCESS_DEBUG_EVENT : constant := 3;
CREATE_SEPARATE_WOW_VDM : constant := 2048;
CREATE_SHARED_WOW_VDM : constant := 4096;
CREATE_SUSPENDED : constant := 4;
CREATE_THREAD_DEBUG_EVENT : constant := 2;
CREATE_UNICODE_ENVIRONMENT : constant := 1024;
CRITICAL_SECTION_NO_DEBUG_INFO : constant := 16777216;
function CallNamedPipe (lpNamedPipeName : access constant winnt.WCHAR;
lpInBuffer : windef.LPVOID; nInBufferSize : windef.DWORD;
lpOutBuffer : windef.LPVOID; nOutBufferSize : windef.DWORD;
lpBytesRead : access windef.DWORD; nTimeOut : windef.DWORD)
return windef.WINBOOL renames CallNamedPipeW;
function CaptureStackBackTrace (FramesToSkip : windef.DWORD;
FramesToCapture : windef.DWORD; BackTrace : access winnt.PVOID;
BackTraceHash : access windef.DWORD) return windef.WORD
renames winnt.RtlCaptureStackBackTrace;
function CheckNameLegalDOS8Dot3 (lpName : access constant winnt.WCHAR;
lpOemName : access winnt.C_CHAR; OemNameSize : windef.DWORD;
pbNameContainsSpaces : access windef.WINBOOL;
pbNameLegal : access windef.WINBOOL) return windef.WINBOOL
renames CheckNameLegalDOS8Dot3W;
function ClearEventLog (hEventLog : winnt.HANDLE;
lpBackupFileName : access constant winnt.WCHAR) return windef.WINBOOL
renames ClearEventLogW;
function CommConfigDialog (lpszName : access constant winnt.WCHAR;
hWnd : access windef.struct_HWND; lpCC : access struct_COMMCONFIG)
return windef.WINBOOL renames CommConfigDialogW;
function CopyFile (lpExistingFileName : access constant winnt.WCHAR;
lpNewFileName : access constant winnt.WCHAR;
bFailIfExists : windef.WINBOOL) return windef.WINBOOL
renames CopyFileW;
function CopyFileEx (lpExistingFileName : access constant winnt.WCHAR;
lpNewFileName : access constant winnt.WCHAR;
lpProgressRoutine : LPPROGRESS_ROUTINE; lpData : windef.LPVOID;
pbCancel : access windef.WINBOOL; dwCopyFlags : windef.DWORD)
return windef.WINBOOL renames CopyFileExW;
-- CopyMemory (function macro)
function CreateActCtx (pActCtx : access constant ACTCTXW)
return winnt.HANDLE renames CreateActCtxW;
function CreateDirectory (lpPathName : access constant winnt.WCHAR;
lpSecurityAttributes : access struct_SECURITY_ATTRIBUTES)
return windef.WINBOOL renames CreateDirectoryW;
function CreateDirectoryEx (
lpTemplateDirectory : access constant winnt.WCHAR;
lpNewDirectory : access constant winnt.WCHAR;
lpSecurityAttributes : access struct_SECURITY_ATTRIBUTES)
return windef.WINBOOL renames CreateDirectoryExW;
function CreateEvent (
lpEventAttributes : access struct_SECURITY_ATTRIBUTES;
bManualReset : windef.WINBOOL; bInitialState : windef.WINBOOL;
lpName : access constant winnt.WCHAR) return winnt.HANDLE
renames CreateEventW;
function CreateFile (lpFileName : access constant winnt.WCHAR;
dwDesiredAccess : windef.DWORD; dwShareMode : windef.DWORD;
lpSecurityAttributes : access struct_SECURITY_ATTRIBUTES;
dwCreationDisposition : windef.DWORD;
dwFlagsAndAttributes : windef.DWORD; hTemplateFile : winnt.HANDLE)
return winnt.HANDLE renames CreateFileW;
function CreateFileMapping (hFile : winnt.HANDLE;
lpFileMappingAttributes : access struct_SECURITY_ATTRIBUTES;
flProtect : windef.DWORD; dwMaximumSizeHigh : windef.DWORD;
dwMaximumSizeLow : windef.DWORD; lpName : access constant winnt.WCHAR)
return winnt.HANDLE renames CreateFileMappingW;
function CreateHardLink (lpFileName : access constant winnt.WCHAR;
lpExistingFileName : access constant winnt.WCHAR;
lpSecurityAttributes : access struct_SECURITY_ATTRIBUTES)
return windef.WINBOOL renames CreateHardLinkW;
function CreateJobObject (
lpJobAttributes : access struct_SECURITY_ATTRIBUTES;
lpName : access constant winnt.WCHAR) return winnt.HANDLE
renames CreateJobObjectW;
function CreateMailslot (lpName : access constant winnt.WCHAR;
nMaxMessageSize : windef.DWORD; lReadTimeout : windef.DWORD;
lpSecurityAttributes : access struct_SECURITY_ATTRIBUTES)
return winnt.HANDLE renames CreateMailslotW;
function CreateMutex (
lpMutexAttributes : access struct_SECURITY_ATTRIBUTES;
bInitialOwner : windef.WINBOOL; lpName : access constant winnt.WCHAR)
return winnt.HANDLE renames CreateMutexW;
function CreateNamedPipe (lpName : access constant winnt.WCHAR;
dwOpenMode : windef.DWORD; dwPipeMode : windef.DWORD;
nMaxInstances : windef.DWORD; nOutBufferSize : windef.DWORD;
nInBufferSize : windef.DWORD; nDefaultTimeOut : windef.DWORD;
lpSecurityAttributes : access struct_SECURITY_ATTRIBUTES)
return winnt.HANDLE renames CreateNamedPipeW;
function CreateProcess (lpApplicationName : access constant winnt.WCHAR;
lpCommandLine : access winnt.WCHAR;
lpProcessAttributes : access struct_SECURITY_ATTRIBUTES;
lpThreadAttributes : access struct_SECURITY_ATTRIBUTES;
bInheritHandles : windef.WINBOOL; dwCreationFlags : windef.DWORD;
lpEnvironment : windef.LPVOID;
lpCurrentDirectory : access constant winnt.WCHAR;
lpStartupInfo : access struct_STARTUPINFOW;
lpProcessInformation : access struct_PROCESS_INFORMATION)
return windef.WINBOOL renames CreateProcessW;
function CreateProcessAsUser (hToken : winnt.HANDLE;
lpApplicationName : access constant winnt.WCHAR;
lpCommandLine : access winnt.WCHAR;
lpProcessAttributes : access struct_SECURITY_ATTRIBUTES;
lpThreadAttributes : access struct_SECURITY_ATTRIBUTES;
bInheritHandles : windef.WINBOOL; dwCreationFlags : windef.DWORD;
lpEnvironment : windef.LPVOID;
lpCurrentDirectory : access constant winnt.WCHAR;
lpStartupInfo : access struct_STARTUPINFOW;
lpProcessInformation : access struct_PROCESS_INFORMATION)
return windef.WINBOOL renames CreateProcessAsUserW;
function CreateSemaphore (
lpSemaphoreAttributes : access struct_SECURITY_ATTRIBUTES;
lInitialCount : winnt.LONG; lMaximumCount : winnt.LONG;
lpName : access constant winnt.WCHAR) return winnt.HANDLE
renames CreateSemaphoreW;
function CreateWaitableTimer (
lpTimerAttributes : access struct_SECURITY_ATTRIBUTES;
bManualReset : windef.WINBOOL;
lpTimerName : access constant winnt.WCHAR) return winnt.HANDLE
renames CreateWaitableTimerW;
DATABITS_16 : constant := 16;
DATABITS_16X : constant := 32;
DATABITS_5 : constant := 1;
DATABITS_6 : constant := 2;
DATABITS_7 : constant := 4;
DATABITS_8 : constant := 8;
DDD_EXACT_MATCH_ON_REMOVE : constant := 4;
DDD_LUID_BROADCAST_DRIVE : constant := 16;
DDD_NO_BROADCAST_SYSTEM : constant := 8;
DDD_RAW_TARGET_PATH : constant := 1;
DDD_REMOVE_DEFINITION : constant := 2;
DEACTIVATE_ACTCTX_FLAG_FORCE_EARLY_DEACTIVATION : constant := 1;
DEBUG_ONLY_THIS_PROCESS : constant := 2;
DEBUG_PROCESS : constant := 1;
DETACHED_PROCESS : constant := 8;
DOCKINFO_DOCKED : constant := 2;
DOCKINFO_UNDOCKED : constant := 1;
DOCKINFO_USER_DOCKED : constant := 6;
DOCKINFO_USER_SUPPLIED : constant := 4;
DOCKINFO_USER_UNDOCKED : constant := 5;
DONT_RESOLVE_DLL_REFERENCES : constant := 1;
DRIVE_CDROM : constant := 5;
DRIVE_FIXED : constant := 3;
DRIVE_NO_ROOT_DIR : constant := 1;
DRIVE_RAMDISK : constant := 6;
DRIVE_REMOTE : constant := 4;
DRIVE_REMOVABLE : constant := 2;
DRIVE_UNKNOWN : constant := 0;
DTR_CONTROL_DISABLE : constant := 0;
DTR_CONTROL_ENABLE : constant := 1;
DTR_CONTROL_HANDSHAKE : constant := 2;
function DecryptFile (lpFileName : access constant winnt.WCHAR;
dwReserved : windef.DWORD) return windef.WINBOOL renames DecryptFileW;
function DefineDosDevice (dwFlags : windef.DWORD;
lpDeviceName : access constant winnt.WCHAR;
lpTargetPath : access constant winnt.WCHAR) return windef.WINBOOL
renames DefineDosDeviceW;
-- DefineHandleTable (function macro)
function DeleteFile (lpFileName : access constant winnt.WCHAR)
return windef.WINBOOL renames DeleteFileW;
function DeleteVolumeMountPoint (
lpszVolumeMountPoint : access constant winnt.WCHAR)
return windef.WINBOOL renames DeleteVolumeMountPointW;
function DnsHostnameToComputerName (
Hostname : access constant winnt.WCHAR;
ComputerName : access winnt.WCHAR; nSize : access windef.DWORD)
return windef.WINBOOL renames DnsHostnameToComputerNameW;
EFS_USE_RECOVERY_KEYS : constant := 1;
subtype ENUMRESLANGPROC is ENUMRESLANGPROCW;
subtype ENUMRESNAMEPROC is ENUMRESNAMEPROCW;
subtype ENUMRESTYPEPROC is ENUMRESTYPEPROCW;
EVENPARITY : constant := 2;
EVENTLOG_FULL_INFO : constant := 0;
EV_BREAK : constant := 64;
EV_CTS : constant := 8;
EV_DSR : constant := 16;
EV_ERR : constant := 128;
EV_EVENT1 : constant := 2048;
EV_EVENT2 : constant := 4096;
EV_PERR : constant := 512;
EV_RING : constant := 256;
EV_RLSD : constant := 32;
EV_RX80FULL : constant := 1024;
EV_RXCHAR : constant := 1;
EV_RXFLAG : constant := 2;
EV_TXEMPTY : constant := 4;
EXCEPTION_ACCESS_VIOLATION : constant := 3221225477;
EXCEPTION_ARRAY_BOUNDS_EXCEEDED : constant := 3221225612;
EXCEPTION_BREAKPOINT : constant := 2147483651;
EXCEPTION_DATATYPE_MISALIGNMENT : constant := 2147483650;
EXCEPTION_DEBUG_EVENT : constant := 1;
EXCEPTION_FLT_DENORMAL_OPERAND : constant := 3221225613;
EXCEPTION_FLT_DIVIDE_BY_ZERO : constant := 3221225614;
EXCEPTION_FLT_INEXACT_RESULT : constant := 3221225615;
EXCEPTION_FLT_INVALID_OPERATION : constant := 3221225616;
EXCEPTION_FLT_OVERFLOW : constant := 3221225617;
EXCEPTION_FLT_STACK_CHECK : constant := 3221225618;
EXCEPTION_FLT_UNDERFLOW : constant := 3221225619;
EXCEPTION_GUARD_PAGE : constant := 2147483649;
EXCEPTION_ILLEGAL_INSTRUCTION : constant := 3221225501;
EXCEPTION_INT_DIVIDE_BY_ZERO : constant := 3221225620;
EXCEPTION_INT_OVERFLOW : constant := 3221225621;
EXCEPTION_INVALID_DISPOSITION : constant := 3221225510;
EXCEPTION_INVALID_HANDLE : constant := 3221225480;
EXCEPTION_IN_PAGE_ERROR : constant := 3221225478;
EXCEPTION_NONCONTINUABLE_EXCEPTION : constant := 3221225509;
-- EXCEPTION_POSSIBLE_DEADLOCK (unparsible)
EXCEPTION_PRIV_INSTRUCTION : constant := 3221225622;
EXCEPTION_SINGLE_STEP : constant := 2147483652;
EXCEPTION_STACK_OVERFLOW : constant := 3221225725;
EXIT_PROCESS_DEBUG_EVENT : constant := 5;
EXIT_THREAD_DEBUG_EVENT : constant := 4;
-- EXPAND_LOCAL_DRIVES (empty)
function EncryptFile (lpFileName : access constant winnt.WCHAR)
return windef.WINBOOL renames EncryptFileW;
function EndUpdateResource (hUpdate : winnt.HANDLE;
fDiscard : windef.WINBOOL) return windef.WINBOOL
renames EndUpdateResourceW;
function EnumResourceLanguages (hModule : access windef.struct_HINSTANCE;
lpType : access constant winnt.WCHAR;
lpName : access constant winnt.WCHAR; lpEnumFunc : ENUMRESLANGPROCW;
lParam : basetsd.LONG_PTR) return windef.WINBOOL
renames EnumResourceLanguagesW;
function EnumResourceNames (hModule : access windef.struct_HINSTANCE;
lpType : access constant winnt.WCHAR; lpEnumFunc : ENUMRESNAMEPROCW;
lParam : basetsd.LONG_PTR) return windef.WINBOOL
renames EnumResourceNamesW;
function EnumResourceTypes (hModule : access windef.struct_HINSTANCE;
lpEnumFunc : ENUMRESTYPEPROCW; lParam : basetsd.LONG_PTR)
return windef.WINBOOL renames EnumResourceTypesW;
function ExpandEnvironmentStrings (lpSrc : access constant winnt.WCHAR;
lpDst : access winnt.WCHAR; nSize : windef.DWORD) return windef.DWORD
renames ExpandEnvironmentStringsW;
FIBER_FLAG_FLOAT_SWITCH : constant := 1;
FILE_BEGIN : constant := 0;
FILE_CURRENT : constant := 1;
FILE_DIR_DISALLOWED : constant := 9;
FILE_ENCRYPTABLE : constant := 0;
FILE_END : constant := 2;
FILE_FLAG_BACKUP_SEMANTICS : constant := 33554432;
FILE_FLAG_DELETE_ON_CLOSE : constant := 67108864;
FILE_FLAG_FIRST_PIPE_INSTANCE : constant := 524288;
FILE_FLAG_NO_BUFFERING : constant := 536870912;
FILE_FLAG_OPEN_NO_RECALL : constant := 1048576;
FILE_FLAG_OPEN_REPARSE_POINT : constant := 2097152;
FILE_FLAG_OVERLAPPED : constant := 1073741824;
FILE_FLAG_POSIX_SEMANTICS : constant := 16777216;
FILE_FLAG_RANDOM_ACCESS : constant := 268435456;
FILE_FLAG_SEQUENTIAL_SCAN : constant := 134217728;
FILE_FLAG_WRITE_THROUGH : constant := -2147483648;
FILE_IS_ENCRYPTED : constant := 1;
FILE_MAP_ALL_ACCESS : constant := 983071;
FILE_MAP_COPY : constant := 1;
FILE_MAP_EXECUTE : constant := 32;
FILE_MAP_READ : constant := 4;
FILE_MAP_WRITE : constant := 2;
FILE_READ_ONLY : constant := 8;
FILE_ROOT_DIR : constant := 3;
FILE_SYSTEM_ATTR : constant := 2;
FILE_SYSTEM_DIR : constant := 4;
FILE_SYSTEM_NOT_SUPPORT : constant := 6;
FILE_TYPE_CHAR : constant := 2;
FILE_TYPE_DISK : constant := 1;
FILE_TYPE_PIPE : constant := 3;
FILE_TYPE_REMOTE : constant := 32768;
FILE_TYPE_UNKNOWN : constant := 0;
FILE_UNKNOWN : constant := 5;
FILE_USER_DISALLOWED : constant := 7;
FIND_ACTCTX_SECTION_KEY_RETURN_ASSEMBLY_METADATA : constant := 4;
FIND_ACTCTX_SECTION_KEY_RETURN_FLAGS : constant := 2;
FIND_ACTCTX_SECTION_KEY_RETURN_HACTCTX : constant := 1;
FIND_FIRST_EX_CASE_SENSITIVE : constant := 1;
FLS_OUT_OF_INDEXES : constant := 4294967295;
FORMAT_MESSAGE_ALLOCATE_BUFFER : constant := 256;
FORMAT_MESSAGE_ARGUMENT_ARRAY : constant := 8192;
FORMAT_MESSAGE_FROM_HMODULE : constant := 2048;
FORMAT_MESSAGE_FROM_STRING : constant := 1024;
FORMAT_MESSAGE_FROM_SYSTEM : constant := 4096;
FORMAT_MESSAGE_IGNORE_INSERTS : constant := 512;
FORMAT_MESSAGE_MAX_WIDTH_MASK : constant := 255;
FS_CASE_IS_PRESERVED : constant := 2;
FS_CASE_SENSITIVE : constant := 1;
FS_FILE_COMPRESSION : constant := 16;
FS_FILE_ENCRYPTION : constant := 131072;
FS_PERSISTENT_ACLS : constant := 8;
FS_UNICODE_STORED_ON_DISK : constant := 4;
FS_VOL_IS_COMPRESSED : constant := 32768;
procedure FatalAppExit (uAction : windef.UINT;
lpMessageText : access constant winnt.WCHAR) renames FatalAppExitW;
function FileEncryptionStatus (lpFileName : access constant winnt.WCHAR;
lpStatus : access windef.DWORD) return windef.WINBOOL
renames FileEncryptionStatusW;
-- FillMemory (function macro)
function FindActCtxSectionString (dwFlags : windef.DWORD;
lpExtensionGuid : access constant guiddef.GUID;
ulSectionId : windef.ULONG;
lpStringToFind : access constant winnt.WCHAR;
ReturnedData : access struct_tagACTCTX_SECTION_KEYED_DATA)
return windef.WINBOOL renames FindActCtxSectionStringW;
function FindAtom (lpString : access constant winnt.WCHAR)
return windef.ATOM renames FindAtomW;
function FindFirstChangeNotification (
lpPathName : access constant winnt.WCHAR;
bWatchSubtree : windef.WINBOOL; dwNotifyFilter : windef.DWORD)
return winnt.HANDLE renames FindFirstChangeNotificationW;
function FindFirstFile (lpFileName : access constant winnt.WCHAR;
lpFindFileData : access struct_WIN32_FIND_DATAW) return winnt.HANDLE
renames FindFirstFileW;
function FindFirstFileEx (lpFileName : access constant winnt.WCHAR;
fInfoLevelId : FINDEX_INFO_LEVELS; lpFindFileData : windef.LPVOID;
fSearchOp : FINDEX_SEARCH_OPS; lpSearchFilter : windef.LPVOID;
dwAdditionalFlags : windef.DWORD) return winnt.HANDLE
renames FindFirstFileExW;
function FindFirstVolume (lpszVolumeName : access winnt.WCHAR;
cchBufferLength : windef.DWORD) return winnt.HANDLE
renames FindFirstVolumeW;
function FindFirstVolumeMountPoint (
lpszRootPathName : access constant winnt.WCHAR;
lpszVolumeMountPoint : access winnt.WCHAR;
cchBufferLength : windef.DWORD) return winnt.HANDLE
renames FindFirstVolumeMountPointW;
function FindNextFile (hFindFile : winnt.HANDLE;
lpFindFileData : access struct_WIN32_FIND_DATAW) return windef.WINBOOL
renames FindNextFileW;
function FindNextVolume (hFindVolume : winnt.HANDLE;
lpszVolumeName : access winnt.WCHAR; cchBufferLength : windef.DWORD)
return windef.WINBOOL renames FindNextVolumeW;
function FindNextVolumeMountPoint (hFindVolumeMountPoint : winnt.HANDLE;
lpszVolumeMountPoint : access winnt.WCHAR;
cchBufferLength : windef.DWORD) return windef.WINBOOL
renames FindNextVolumeMountPointW;
function FindResource (hModule : access windef.struct_HINSTANCE;
lpName : access constant winnt.WCHAR;
lpType : access constant winnt.WCHAR) return windef.HRSRC
renames FindResourceW;
function FindResourceEx (hModule : access windef.struct_HINSTANCE;
lpType : access constant winnt.WCHAR;
lpName : access constant winnt.WCHAR; wLanguage : windef.WORD)
return windef.HRSRC renames FindResourceExW;
function FormatMessage (dwFlags : windef.DWORD; lpSource : windef.LPCVOID;
dwMessageId : windef.DWORD; dwLanguageId : windef.DWORD;
lpBuffer : access winnt.WCHAR; nSize : windef.DWORD;
Arguments : access vadefs.va_list) return windef.DWORD
renames FormatMessageW;
function FreeEnvironmentStrings (a1 : access winnt.WCHAR)
return windef.WINBOOL renames FreeEnvironmentStringsW;
-- FreeModule (function macro)
-- FreeProcInstance (function macro)
GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS : constant := 4;
GET_MODULE_HANDLE_EX_FLAG_PIN : constant := 1;
GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT : constant := 2;
GET_SYSTEM_WOW64_DIRECTORY_NAME_A_A : constant char_array (0 .. 24) :=
"GetSystemWow64DirectoryA" & char'Val (0);
GET_SYSTEM_WOW64_DIRECTORY_NAME_A_T : constant wchar_t_array (0 .. 24) :=
(wchar_t'Val (71), wchar_t'Val (101), wchar_t'Val (116),
wchar_t'Val (83), wchar_t'Val (121), wchar_t'Val (115),
wchar_t'Val (116), wchar_t'Val (101), wchar_t'Val (109),
wchar_t'Val (87), wchar_t'Val (111), wchar_t'Val (119),
wchar_t'Val (54), wchar_t'Val (52), wchar_t'Val (68),
wchar_t'Val (105), wchar_t'Val (114), wchar_t'Val (101),
wchar_t'Val (99), wchar_t'Val (116), wchar_t'Val (111),
wchar_t'Val (114), wchar_t'Val (121), wchar_t'Val (65),
wchar_t'Val (0));
GET_SYSTEM_WOW64_DIRECTORY_NAME_A_W : constant wchar_t_array (0 .. 24) :=
(wchar_t'Val (71), wchar_t'Val (101), wchar_t'Val (116),
wchar_t'Val (83), wchar_t'Val (121), wchar_t'Val (115),
wchar_t'Val (116), wchar_t'Val (101), wchar_t'Val (109),
wchar_t'Val (87), wchar_t'Val (111), wchar_t'Val (119),
wchar_t'Val (54), wchar_t'Val (52), wchar_t'Val (68),
wchar_t'Val (105), wchar_t'Val (114), wchar_t'Val (101),
wchar_t'Val (99), wchar_t'Val (116), wchar_t'Val (111),
wchar_t'Val (114), wchar_t'Val (121), wchar_t'Val (65),
wchar_t'Val (0));
GET_SYSTEM_WOW64_DIRECTORY_NAME_T_A : constant char_array (0 .. 24) :=
"GetSystemWow64DirectoryW" & char'Val (0);
GET_SYSTEM_WOW64_DIRECTORY_NAME_T_T : constant wchar_t_array (0 .. 24) :=
(wchar_t'Val (71), wchar_t'Val (101), wchar_t'Val (116),
wchar_t'Val (83), wchar_t'Val (121), wchar_t'Val (115),
wchar_t'Val (116), wchar_t'Val (101), wchar_t'Val (109),
wchar_t'Val (87), wchar_t'Val (111), wchar_t'Val (119),
wchar_t'Val (54), wchar_t'Val (52), wchar_t'Val (68),
wchar_t'Val (105), wchar_t'Val (114), wchar_t'Val (101),
wchar_t'Val (99), wchar_t'Val (116), wchar_t'Val (111),
wchar_t'Val (114), wchar_t'Val (121), wchar_t'Val (87),
wchar_t'Val (0));
GET_SYSTEM_WOW64_DIRECTORY_NAME_T_W : constant wchar_t_array (0 .. 24) :=
(wchar_t'Val (71), wchar_t'Val (101), wchar_t'Val (116),
wchar_t'Val (83), wchar_t'Val (121), wchar_t'Val (115),
wchar_t'Val (116), wchar_t'Val (101), wchar_t'Val (109),
wchar_t'Val (87), wchar_t'Val (111), wchar_t'Val (119),
wchar_t'Val (54), wchar_t'Val (52), wchar_t'Val (68),
wchar_t'Val (105), wchar_t'Val (114), wchar_t'Val (101),
wchar_t'Val (99), wchar_t'Val (116), wchar_t'Val (111),
wchar_t'Val (114), wchar_t'Val (121), wchar_t'Val (87),
wchar_t'Val (0));
GET_SYSTEM_WOW64_DIRECTORY_NAME_W_A : constant char_array (0 .. 24) :=
"GetSystemWow64DirectoryW" & char'Val (0);
GET_SYSTEM_WOW64_DIRECTORY_NAME_W_T : constant wchar_t_array (0 .. 24) :=
(wchar_t'Val (71), wchar_t'Val (101), wchar_t'Val (116),
wchar_t'Val (83), wchar_t'Val (121), wchar_t'Val (115),
wchar_t'Val (116), wchar_t'Val (101), wchar_t'Val (109),
wchar_t'Val (87), wchar_t'Val (111), wchar_t'Val (119),
wchar_t'Val (54), wchar_t'Val (52), wchar_t'Val (68),
wchar_t'Val (105), wchar_t'Val (114), wchar_t'Val (101),
wchar_t'Val (99), wchar_t'Val (116), wchar_t'Val (111),
wchar_t'Val (114), wchar_t'Val (121), wchar_t'Val (87),
wchar_t'Val (0));
GET_SYSTEM_WOW64_DIRECTORY_NAME_W_W : constant wchar_t_array (0 .. 24) :=
(wchar_t'Val (71), wchar_t'Val (101), wchar_t'Val (116),
wchar_t'Val (83), wchar_t'Val (121), wchar_t'Val (115),
wchar_t'Val (116), wchar_t'Val (101), wchar_t'Val (109),
wchar_t'Val (87), wchar_t'Val (111), wchar_t'Val (119),
wchar_t'Val (54), wchar_t'Val (52), wchar_t'Val (68),
wchar_t'Val (105), wchar_t'Val (114), wchar_t'Val (101),
wchar_t'Val (99), wchar_t'Val (116), wchar_t'Val (111),
wchar_t'Val (114), wchar_t'Val (121), wchar_t'Val (87),
wchar_t'Val (0));
GET_TAPE_DRIVE_INFORMATION : constant := 1;
GET_TAPE_MEDIA_INFORMATION : constant := 0;
GHND : constant := 66;
GMEM_DDESHARE : constant := 8192;
GMEM_DISCARDABLE : constant := 256;
GMEM_DISCARDED : constant := 16384;
GMEM_FIXED : constant := 0;
GMEM_INVALID_HANDLE : constant := 32768;
GMEM_LOCKCOUNT : constant := 255;
GMEM_LOWER : constant := 4096;
GMEM_MODIFY : constant := 128;
GMEM_MOVEABLE : constant := 2;
GMEM_NOCOMPACT : constant := 16;
GMEM_NODISCARD : constant := 32;
GMEM_NOTIFY : constant := 16384;
GMEM_NOT_BANKED : constant := 4096;
GMEM_SHARE : constant := 8192;
GMEM_VALID_FLAGS : constant := 32626;
GMEM_ZEROINIT : constant := 64;
GPTR : constant := 64;
function GetAtomName (nAtom : windef.ATOM; lpBuffer : access winnt.WCHAR;
nSize : signed_int) return windef.UINT renames GetAtomNameW;
function GetBinaryType (lpApplicationName : access constant winnt.WCHAR;
lpBinaryType : access windef.DWORD) return windef.WINBOOL
renames GetBinaryTypeW;
function GetCommandLine return winnt.LPWSTR renames GetCommandLineW;
function GetCompressedFileSize (lpFileName : access constant winnt.WCHAR;
lpFileSizeHigh : access windef.DWORD) return windef.DWORD
renames GetCompressedFileSizeW;
function GetComputerName (lpBuffer : access winnt.WCHAR;
nSize : access windef.DWORD) return windef.WINBOOL
renames GetComputerNameW;
function GetComputerNameEx (NameType : COMPUTER_NAME_FORMAT;
lpBuffer : access winnt.WCHAR; nSize : access windef.DWORD)
return windef.WINBOOL renames GetComputerNameExW;
function GetCurrentDirectory (nBufferLength : windef.DWORD;
lpBuffer : access winnt.WCHAR) return windef.DWORD
renames GetCurrentDirectoryW;
function GetCurrentHwProfile (
lpHwProfileInfo : access struct_tagHW_PROFILE_INFOW)
return windef.WINBOOL renames GetCurrentHwProfileW;
-- GetCurrentTime (function macro)
function GetDefaultCommConfig (lpszName : access constant winnt.WCHAR;
lpCC : access struct_COMMCONFIG; lpdwSize : access windef.DWORD)
return windef.WINBOOL renames GetDefaultCommConfigW;
function GetDiskFreeSpace (lpRootPathName : access constant winnt.WCHAR;
lpSectorsPerCluster : access windef.DWORD;
lpBytesPerSector : access windef.DWORD;
lpNumberOfFreeClusters : access windef.DWORD;
lpTotalNumberOfClusters : access windef.DWORD) return windef.WINBOOL
renames GetDiskFreeSpaceW;
function GetDiskFreeSpaceEx (
lpDirectoryName : access constant winnt.WCHAR;
lpFreeBytesAvailableToCaller : access winnt.ULARGE_INTEGER;
lpTotalNumberOfBytes : access winnt.ULARGE_INTEGER;
lpTotalNumberOfFreeBytes : access winnt.ULARGE_INTEGER)
return windef.WINBOOL renames GetDiskFreeSpaceExW;
function GetDllDirectory (nBufferLength : windef.DWORD;
lpBuffer : access winnt.WCHAR) return windef.DWORD
renames GetDllDirectoryW;
function GetDriveType (lpRootPathName : access constant winnt.WCHAR)
return windef.UINT renames GetDriveTypeW;
function GetEnvironmentStringsA return winnt.LPCH
renames GetEnvironmentStrings;
function GetEnvironmentVariable (lpName : access constant winnt.WCHAR;
lpBuffer : access winnt.WCHAR; nSize : windef.DWORD)
return windef.DWORD renames GetEnvironmentVariableW;
function GetFileAttributes (lpFileName : access constant winnt.WCHAR)
return windef.DWORD renames GetFileAttributesW;
function GetFileAttributesEx (lpFileName : access constant winnt.WCHAR;
fInfoLevelId : GET_FILEEX_INFO_LEVELS;
lpFileInformation : windef.LPVOID) return windef.WINBOOL
renames GetFileAttributesExW;
function GetFileSecurity (lpFileName : access constant winnt.WCHAR;
RequestedInformation : winnt.SECURITY_INFORMATION;
pSecurityDescriptor : winnt.PSECURITY_DESCRIPTOR;
nLength : windef.DWORD; lpnLengthNeeded : access windef.DWORD)
return windef.WINBOOL renames GetFileSecurityW;
function GetFirmwareEnvironmentVariable (
lpName : access constant winnt.WCHAR;
lpGuid : access constant winnt.WCHAR; pBuffer : winnt.PVOID;
nSize : windef.DWORD) return windef.DWORD
renames GetFirmwareEnvironmentVariableW;
-- GetFreeSpace (function macro)
function GetFullPathName (lpFileName : access constant winnt.WCHAR;
nBufferLength : windef.DWORD; lpBuffer : access winnt.WCHAR;
lpFilePart : access winnt.LPWSTR) return windef.DWORD
renames GetFullPathNameW;
function GetLogicalDriveStrings (nBufferLength : windef.DWORD;
lpBuffer : access winnt.WCHAR) return windef.DWORD
renames GetLogicalDriveStringsW;
function GetLongPathName (lpszShortPath : access constant winnt.WCHAR;
lpszLongPath : access winnt.WCHAR; cchBuffer : windef.DWORD)
return windef.DWORD renames GetLongPathNameW;
function GetModuleFileName (hModule : access windef.struct_HINSTANCE;
lpFilename : access winnt.WCHAR; nSize : windef.DWORD)
return windef.DWORD renames GetModuleFileNameW;
function GetModuleHandle (lpModuleName : access constant winnt.WCHAR)
return windef.HMODULE renames GetModuleHandleW;
function GetModuleHandleEx (dwFlags : windef.DWORD;
lpModuleName : access constant winnt.WCHAR;
phModule : access windef.HMODULE) return windef.WINBOOL
renames GetModuleHandleExW;
function GetNamedPipeHandleState (hNamedPipe : winnt.HANDLE;
lpState : access windef.DWORD; lpCurInstances : access windef.DWORD;
lpMaxCollectionCount : access windef.DWORD;
lpCollectDataTimeout : access windef.DWORD;
lpUserName : access winnt.WCHAR; nMaxUserNameSize : windef.DWORD)
return windef.WINBOOL renames GetNamedPipeHandleStateW;
function GetPrivateProfileInt (lpAppName : access constant winnt.WCHAR;
lpKeyName : access constant winnt.WCHAR; nDefault : windef.INT;
lpFileName : access constant winnt.WCHAR) return windef.UINT
renames GetPrivateProfileIntW;
function GetPrivateProfileSection (
lpAppName : access constant winnt.WCHAR;
lpReturnedString : access winnt.WCHAR; nSize : windef.DWORD;
lpFileName : access constant winnt.WCHAR) return windef.DWORD
renames GetPrivateProfileSectionW;
function GetPrivateProfileSectionNames (
lpszReturnBuffer : access winnt.WCHAR; nSize : windef.DWORD;
lpFileName : access constant winnt.WCHAR) return windef.DWORD
renames GetPrivateProfileSectionNamesW;
function GetPrivateProfileString (lpAppName : access constant winnt.WCHAR;
lpKeyName : access constant winnt.WCHAR;
lpDefault : access constant winnt.WCHAR;
lpReturnedString : access winnt.WCHAR; nSize : windef.DWORD;
lpFileName : access constant winnt.WCHAR) return windef.DWORD
renames GetPrivateProfileStringW;
function GetPrivateProfileStruct (
lpszSection : access constant winnt.WCHAR;
lpszKey : access constant winnt.WCHAR; lpStruct : windef.LPVOID;
uSizeStruct : windef.UINT; szFile : access constant winnt.WCHAR)
return windef.WINBOOL renames GetPrivateProfileStructW;
function GetProfileInt (lpAppName : access constant winnt.WCHAR;
lpKeyName : access constant winnt.WCHAR; nDefault : windef.INT)
return windef.UINT renames GetProfileIntW;
function GetProfileSection (lpAppName : access constant winnt.WCHAR;
lpReturnedString : access winnt.WCHAR; nSize : windef.DWORD)
return windef.DWORD renames GetProfileSectionW;
function GetProfileString (lpAppName : access constant winnt.WCHAR;
lpKeyName : access constant winnt.WCHAR;
lpDefault : access constant winnt.WCHAR;
lpReturnedString : access winnt.WCHAR; nSize : windef.DWORD)
return windef.DWORD renames GetProfileStringW;
function GetShortPathName (lpszLongPath : access constant winnt.WCHAR;
lpszShortPath : access winnt.WCHAR; cchBuffer : windef.DWORD)
return windef.DWORD renames GetShortPathNameW;
procedure GetStartupInfo (lpStartupInfo : access struct_STARTUPINFOW)
renames GetStartupInfoW;
function GetSystemDirectory (lpBuffer : access winnt.WCHAR;
uSize : windef.UINT) return windef.UINT renames GetSystemDirectoryW;
function GetSystemWindowsDirectory (lpBuffer : access winnt.WCHAR;
uSize : windef.UINT) return windef.UINT
renames GetSystemWindowsDirectoryW;
function GetSystemWow64Directory (lpBuffer : access winnt.WCHAR;
uSize : windef.UINT) return windef.UINT
renames GetSystemWow64DirectoryW;
function GetTempFileName (lpPathName : access constant winnt.WCHAR;
lpPrefixString : access constant winnt.WCHAR; uUnique : windef.UINT;
lpTempFileName : access winnt.WCHAR) return windef.UINT
renames GetTempFileNameW;
function GetTempPath (nBufferLength : windef.DWORD;
lpBuffer : access winnt.WCHAR) return windef.DWORD
renames GetTempPathW;
function GetUserName (lpBuffer : access winnt.WCHAR;
pcbBuffer : access windef.DWORD) return windef.WINBOOL
renames GetUserNameW;
function GetVersionEx (
lpVersionInformation : access winnt.struct_OSVERSIONINFOW)
return windef.WINBOOL renames GetVersionExW;
function GetVolumeInformation (
lpRootPathName : access constant winnt.WCHAR;
lpVolumeNameBuffer : access winnt.WCHAR;
nVolumeNameSize : windef.DWORD;
lpVolumeSerialNumber : access windef.DWORD;
lpMaximumComponentLength : access windef.DWORD;
lpFileSystemFlags : access windef.DWORD;
lpFileSystemNameBuffer : access winnt.WCHAR;
nFileSystemNameSize : windef.DWORD) return windef.WINBOOL
renames GetVolumeInformationW;
function GetVolumeNameForVolumeMountPoint (
lpszVolumeMountPoint : access constant winnt.WCHAR;
lpszVolumeName : access winnt.WCHAR; cchBufferLength : windef.DWORD)
return windef.WINBOOL renames GetVolumeNameForVolumeMountPointW;
function GetVolumePathName (lpszFileName : access constant winnt.WCHAR;
lpszVolumePathName : access winnt.WCHAR;
cchBufferLength : windef.DWORD) return windef.WINBOOL
renames GetVolumePathNameW;
function GetVolumePathNamesForVolumeName (
lpszVolumeName : access constant winnt.WCHAR;
lpszVolumePathNames : access winnt.WCHAR;
cchBufferLength : windef.DWORD;
lpcchReturnLength : access windef.DWORD) return windef.WINBOOL
renames GetVolumePathNamesForVolumeNameW;
function GetWindowsDirectory (lpBuffer : access winnt.WCHAR;
uSize : windef.UINT) return windef.UINT renames GetWindowsDirectoryW;
function GlobalAddAtom (lpString : access constant winnt.WCHAR)
return windef.ATOM renames GlobalAddAtomW;
-- GlobalDiscard (function macro)
function GlobalFindAtom (lpString : access constant winnt.WCHAR)
return windef.ATOM renames GlobalFindAtomW;
function GlobalGetAtomName (nAtom : windef.ATOM;
lpBuffer : access winnt.WCHAR; nSize : signed_int) return windef.UINT
renames GlobalGetAtomNameW;
-- GlobalLRUNewest (function macro)
-- GlobalLRUOldest (function macro)
HANDLE_FLAG_INHERIT : constant := 1;
HANDLE_FLAG_PROTECT_FROM_CLOSE : constant := 2;
HIGH_PRIORITY_CLASS : constant := 128;
HINSTANCE_ERROR : constant := 32;
HW_PROFILE_GUIDLEN : constant := 39;
-- HasOverlappedIoCompleted (uninterpretable)
IDLE_PRIORITY_CLASS : constant := 64;
IE_BADID : constant := -1;
IE_BAUDRATE : constant := -12;
IE_BYTESIZE : constant := -11;
IE_DEFAULT : constant := -5;
IE_HARDWARE : constant := -10;
IE_MEMORY : constant := -4;
IE_NOPEN : constant := -3;
IE_OPEN : constant := -2;
IGNORE : constant := 0;
INFINITE : constant windef.DWORD := windef.DWORD'Mod (-1);
INVALID_ATOM : constant := 0;
INVALID_FILE_ATTRIBUTES : constant := 4294967295;
INVALID_FILE_SIZE : constant := 4294967295;
INVALID_HANDLE_VALUE : constant winnt.HANDLE := void_ptr (
System'To_Address (-1));
INVALID_SET_FILE_POINTER : constant := 4294967295;
function IsBadStringPtr (lpsz : access constant winnt.WCHAR;
ucchMax : basetsd.UINT_PTR) return windef.WINBOOL
renames IsBadStringPtrW;
LHND : constant := 66;
LMEM_DISCARDABLE : constant := 3840;
LMEM_DISCARDED : constant := 16384;
LMEM_FIXED : constant := 0;
LMEM_INVALID_HANDLE : constant := 32768;
LMEM_LOCKCOUNT : constant := 255;
LMEM_MODIFY : constant := 128;
LMEM_MOVEABLE : constant := 2;
LMEM_NOCOMPACT : constant := 16;
LMEM_NODISCARD : constant := 32;
LMEM_VALID_FLAGS : constant := 3954;
LMEM_ZEROINIT : constant := 64;
LOAD_DLL_DEBUG_EVENT : constant := 6;
LOAD_IGNORE_CODE_AUTHZ_LEVEL : constant := 16;
LOAD_LIBRARY_AS_DATAFILE : constant := 2;
LOAD_LIBRARY_AS_DATAFILE_EXCLUSIVE : constant := 64;
LOAD_LIBRARY_AS_IMAGE_RESOURCE : constant := 32;
LOAD_WITH_ALTERED_SEARCH_PATH : constant := 8;
LOCKFILE_EXCLUSIVE_LOCK : constant := 2;
LOCKFILE_FAIL_IMMEDIATELY : constant := 1;
LOGON32_LOGON_BATCH : constant := 4;
LOGON32_LOGON_INTERACTIVE : constant := 2;
LOGON32_LOGON_NETWORK : constant := 3;
LOGON32_LOGON_NETWORK_CLEARTEXT : constant := 8;
LOGON32_LOGON_NEW_CREDENTIALS : constant := 9;
LOGON32_LOGON_SERVICE : constant := 5;
LOGON32_LOGON_UNLOCK : constant := 7;
LOGON32_PROVIDER_DEFAULT : constant := 0;
LOGON32_PROVIDER_WINNT35 : constant := 1;
LOGON32_PROVIDER_WINNT40 : constant := 2;
LOGON32_PROVIDER_WINNT50 : constant := 3;
LOGON_NETCREDENTIALS_ONLY : constant := 2;
LOGON_WITH_PROFILE : constant := 1;
LOGON_ZERO_PASSWORD_BUFFER : constant := -2147483648;
LPTR : constant := 64;
LPTx : constant := 128;
-- LimitEmsPages (empty)
function LoadLibrary (lpLibFileName : access constant winnt.WCHAR)
return windef.HMODULE renames LoadLibraryW;
function LoadLibraryEx (lpLibFileName : access constant winnt.WCHAR;
hFile : winnt.HANDLE; dwFlags : windef.DWORD) return windef.HMODULE
renames LoadLibraryExW;
-- LocalDiscard (function macro)
-- LockSegment (function macro)
function LogonUser (lpszUsername : access constant winnt.WCHAR;
lpszDomain : access constant winnt.WCHAR;
lpszPassword : access constant winnt.WCHAR; dwLogonType : windef.DWORD;
dwLogonProvider : windef.DWORD; phToken : access winnt.HANDLE)
return windef.WINBOOL renames LogonUserW;
function LogonUserEx (lpszUsername : access constant winnt.WCHAR;
lpszDomain : access constant winnt.WCHAR;
lpszPassword : access constant winnt.WCHAR; dwLogonType : windef.DWORD;
dwLogonProvider : windef.DWORD; phToken : access winnt.HANDLE;
ppLogonSid : access winnt.PSID; ppProfileBuffer : access winnt.PVOID;
pdwProfileLength : access windef.DWORD;
pQuotaLimits : access winnt.struct_QUOTA_LIMITS) return windef.WINBOOL
renames LogonUserExW;
function LookupAccountName (lpSystemName : access constant winnt.WCHAR;
lpAccountName : access constant winnt.WCHAR; Sid : winnt.PSID;
cbSid : access windef.DWORD; ReferencedDomainName : access winnt.WCHAR;
cchReferencedDomainName : access windef.DWORD;
peUse : access winnt.enum_SID_NAME_USE) return windef.WINBOOL
renames LookupAccountNameW;
function LookupAccountSid (lpSystemName : access constant winnt.WCHAR;
Sid : winnt.PSID; Name : access winnt.WCHAR;
cchName : access windef.DWORD;
ReferencedDomainName : access winnt.WCHAR;
cchReferencedDomainName : access windef.DWORD;
peUse : access winnt.enum_SID_NAME_USE) return windef.WINBOOL
renames LookupAccountSidW;
function LookupPrivilegeDisplayName (
lpSystemName : access constant winnt.WCHAR;
lpName : access constant winnt.WCHAR;
lpDisplayName : access winnt.WCHAR;
cchDisplayName : access windef.DWORD;
lpLanguageId : access windef.DWORD) return windef.WINBOOL
renames LookupPrivilegeDisplayNameW;
function LookupPrivilegeName (lpSystemName : access constant winnt.WCHAR;
lpLuid : access winnt.struct_LUID; lpName : access winnt.WCHAR;
cchName : access windef.DWORD) return windef.WINBOOL
renames LookupPrivilegeNameW;
function LookupPrivilegeValue (lpSystemName : access constant winnt.WCHAR;
lpName : access constant winnt.WCHAR;
lpLuid : access winnt.struct_LUID) return windef.WINBOOL
renames LookupPrivilegeValueW;
-- MAKEINTATOM (function macro)
MARKPARITY : constant := 3;
MAXINTATOM : constant := 49152;
MAX_COMPUTERNAME_LENGTH : constant := 15;
MAX_PROFILE_LEN : constant := 80;
-- MICROSOFT_WINDOWS_WINBASE_INTERLOCKED_CPLUSPLUS_H_INCLUDED (empty)
MOVEFILE_COPY_ALLOWED : constant := 2;
MOVEFILE_CREATE_HARDLINK : constant := 16;
MOVEFILE_DELAY_UNTIL_REBOOT : constant := 4;
MOVEFILE_FAIL_IF_NOT_TRACKABLE : constant := 32;
MOVEFILE_REPLACE_EXISTING : constant := 1;
MOVEFILE_WRITE_THROUGH : constant := 8;
MS_CTS_ON : constant := 16;
MS_DSR_ON : constant := 32;
MS_RING_ON : constant := 64;
MS_RLSD_ON : constant := 128;
MUTEX_ALL_ACCESS : constant := 2031617;
MUTEX_MODIFY_STATE : constant := 1;
-- MakeProcInstance (function macro)
function MoveFile (lpExistingFileName : access constant winnt.WCHAR;
lpNewFileName : access constant winnt.WCHAR) return windef.WINBOOL
renames MoveFileW;
function MoveFileEx (lpExistingFileName : access constant winnt.WCHAR;
lpNewFileName : access constant winnt.WCHAR; dwFlags : windef.DWORD)
return windef.WINBOOL renames MoveFileExW;
function MoveFileWithProgress (
lpExistingFileName : access constant winnt.WCHAR;
lpNewFileName : access constant winnt.WCHAR;
lpProgressRoutine : LPPROGRESS_ROUTINE; lpData : windef.LPVOID;
dwFlags : windef.DWORD) return windef.WINBOOL
renames MoveFileWithProgressW;
-- MoveMemory (function macro)
NMPWAIT_NOWAIT : constant := 1;
NMPWAIT_USE_DEFAULT_WAIT : constant := 0;
NMPWAIT_WAIT_FOREVER : constant := -1;
NONZEROLHND : constant := 2;
NONZEROLPTR : constant := 0;
NOPARITY : constant := 0;
NORMAL_PRIORITY_CLASS : constant := 32;
function NeedCurrentDirectoryForExePath (
ExeName : access constant winnt.WCHAR) return windef.WINBOOL
renames NeedCurrentDirectoryForExePathW;
ODDPARITY : constant := 1;
OFS_MAXPATHNAME : constant := 128;
OF_CANCEL : constant := 2048;
OF_CREATE : constant := 4096;
OF_DELETE : constant := 512;
OF_EXIST : constant := 16384;
OF_PARSE : constant := 256;
OF_PROMPT : constant := 8192;
OF_READ : constant := 0;
OF_READWRITE : constant := 2;
OF_REOPEN : constant := 32768;
OF_SHARE_COMPAT : constant := 0;
OF_SHARE_DENY_NONE : constant := 64;
OF_SHARE_DENY_READ : constant := 48;
OF_SHARE_DENY_WRITE : constant := 32;
OF_SHARE_EXCLUSIVE : constant := 16;
OF_VERIFY : constant := 1024;
OF_WRITE : constant := 1;
ONE5STOPBITS : constant := 1;
ONESTOPBIT : constant := 0;
OPEN_ALWAYS : constant := 4;
OPEN_EXISTING : constant := 3;
OUTPUT_DEBUG_STRING_EVENT : constant := 8;
OVERWRITE_HIDDEN : constant := 4;
function ObjectCloseAuditAlarm (
SubsystemName : access constant winnt.WCHAR; HandleId : windef.LPVOID;
GenerateOnClose : windef.WINBOOL) return windef.WINBOOL
renames ObjectCloseAuditAlarmW;
function ObjectDeleteAuditAlarm (
SubsystemName : access constant winnt.WCHAR; HandleId : windef.LPVOID;
GenerateOnClose : windef.WINBOOL) return windef.WINBOOL
renames ObjectDeleteAuditAlarmW;
function ObjectOpenAuditAlarm (
SubsystemName : access constant winnt.WCHAR; HandleId : windef.LPVOID;
ObjectTypeName : access winnt.WCHAR; ObjectName : access winnt.WCHAR;
pSecurityDescriptor : winnt.PSECURITY_DESCRIPTOR;
ClientToken : winnt.HANDLE; DesiredAccess : windef.DWORD;
GrantedAccess : windef.DWORD;
Privileges : access winnt.struct_PRIVILEGE_SET;
ObjectCreation : windef.WINBOOL; AccessGranted : windef.WINBOOL;
GenerateOnClose : access windef.WINBOOL) return windef.WINBOOL
renames ObjectOpenAuditAlarmW;
function ObjectPrivilegeAuditAlarm (
SubsystemName : access constant winnt.WCHAR; HandleId : windef.LPVOID;
ClientToken : winnt.HANDLE; DesiredAccess : windef.DWORD;
Privileges : access winnt.struct_PRIVILEGE_SET;
AccessGranted : windef.WINBOOL) return windef.WINBOOL
renames ObjectPrivilegeAuditAlarmW;
function OpenBackupEventLog (
lpUNCServerName : access constant winnt.WCHAR;
lpFileName : access constant winnt.WCHAR) return winnt.HANDLE
renames OpenBackupEventLogW;
function OpenEncryptedFileRaw (lpFileName : access constant winnt.WCHAR;
ulFlags : windef.ULONG; pvContext : access winnt.PVOID)
return windef.DWORD renames OpenEncryptedFileRawW;
function OpenEvent (dwDesiredAccess : windef.DWORD;
bInheritHandle : windef.WINBOOL; lpName : access constant winnt.WCHAR)
return winnt.HANDLE renames OpenEventW;
function OpenEventLog (lpUNCServerName : access constant winnt.WCHAR;
lpSourceName : access constant winnt.WCHAR) return winnt.HANDLE
renames OpenEventLogW;
function OpenFileMapping (dwDesiredAccess : windef.DWORD;
bInheritHandle : windef.WINBOOL; lpName : access constant winnt.WCHAR)
return winnt.HANDLE renames OpenFileMappingW;
function OpenJobObject (dwDesiredAccess : windef.DWORD;
bInheritHandle : windef.WINBOOL; lpName : access constant winnt.WCHAR)
return winnt.HANDLE renames OpenJobObjectW;
function OpenMutex (dwDesiredAccess : windef.DWORD;
bInheritHandle : windef.WINBOOL; lpName : access constant winnt.WCHAR)
return winnt.HANDLE renames OpenMutexW;
function OpenSemaphore (dwDesiredAccess : windef.DWORD;
bInheritHandle : windef.WINBOOL; lpName : access constant winnt.WCHAR)
return winnt.HANDLE renames OpenSemaphoreW;
function OpenWaitableTimer (dwDesiredAccess : windef.DWORD;
bInheritHandle : windef.WINBOOL;
lpTimerName : access constant winnt.WCHAR) return winnt.HANDLE
renames OpenWaitableTimerW;
procedure OutputDebugString (lpOutputString : access constant winnt.WCHAR)
renames OutputDebugStringW;
PARITY_EVEN : constant := 1024;
PARITY_MARK : constant := 2048;
PARITY_NONE : constant := 256;
PARITY_ODD : constant := 512;
PARITY_SPACE : constant := 4096;
PCF_16BITMODE : constant := 512;
PCF_DTRDSR : constant := 1;
PCF_INTTIMEOUTS : constant := 128;
PCF_PARITY_CHECK : constant := 8;
PCF_RLSD : constant := 4;
PCF_RTSCTS : constant := 2;
PCF_SETXCHAR : constant := 32;
PCF_SPECIALCHARS : constant := 256;
PCF_TOTALTIMEOUTS : constant := 64;
PCF_XONXOFF : constant := 16;
subtype PGET_MODULE_HANDLE_EX is PGET_MODULE_HANDLE_EXW;
PIPE_ACCESS_DUPLEX : constant := 3;
PIPE_ACCESS_INBOUND : constant := 1;
PIPE_ACCESS_OUTBOUND : constant := 2;
PIPE_CLIENT_END : constant := 0;
PIPE_NOWAIT : constant := 1;
PIPE_READMODE_BYTE : constant := 0;
PIPE_READMODE_MESSAGE : constant := 2;
PIPE_SERVER_END : constant := 1;
PIPE_TYPE_BYTE : constant := 0;
PIPE_TYPE_MESSAGE : constant := 4;
PIPE_UNLIMITED_INSTANCES : constant := 255;
PIPE_WAIT : constant := 0;
PROCESS_HEAP_ENTRY_BUSY : constant := 4;
PROCESS_HEAP_ENTRY_DDESHARE : constant := 32;
PROCESS_HEAP_ENTRY_MOVEABLE : constant := 16;
PROCESS_HEAP_REGION : constant := 1;
PROCESS_HEAP_UNCOMMITTED_RANGE : constant := 2;
PROFILE_KERNEL : constant := 536870912;
PROFILE_SERVER : constant := 1073741824;
PROFILE_USER : constant := 268435456;
PROGRESS_CANCEL : constant := 1;
PROGRESS_CONTINUE : constant := 0;
PROGRESS_QUIET : constant := 3;
PROGRESS_STOP : constant := 2;
PST_FAX : constant := 33;
PST_LAT : constant := 257;
PST_MODEM : constant := 6;
PST_NETWORK_BRIDGE : constant := 256;
PST_PARALLELPORT : constant := 2;
PST_RS232 : constant := 1;
PST_RS422 : constant := 3;
PST_RS423 : constant := 4;
PST_RS449 : constant := 5;
PST_SCANNER : constant := 34;
PST_TCPIP_TELNET : constant := 258;
PST_UNSPECIFIED : constant := 0;
PST_X25 : constant := 259;
PURGE_RXABORT : constant := 2;
PURGE_RXCLEAR : constant := 8;
PURGE_TXABORT : constant := 1;
PURGE_TXCLEAR : constant := 4;
function PrivilegedServiceAuditAlarm (
SubsystemName : access constant winnt.WCHAR;
ServiceName : access constant winnt.WCHAR; ClientToken : winnt.HANDLE;
Privileges : access winnt.struct_PRIVILEGE_SET;
AccessGranted : windef.WINBOOL) return windef.WINBOOL
renames PrivilegedServiceAuditAlarmW;
QUERY_ACTCTX_FLAG_ACTCTX_IS_ADDRESS : constant := 16;
QUERY_ACTCTX_FLAG_ACTCTX_IS_HMODULE : constant := 8;
QUERY_ACTCTX_FLAG_NO_ADDREF : constant := -2147483648;
QUERY_ACTCTX_FLAG_USE_ACTIVE_ACTCTX : constant := 4;
function QueryDosDevice (lpDeviceName : access constant winnt.WCHAR;
lpTargetPath : access winnt.WCHAR; ucchMax : windef.DWORD)
return windef.DWORD renames QueryDosDeviceW;
REALTIME_PRIORITY_CLASS : constant := 256;
REPLACEFILE_IGNORE_MERGE_ERRORS : constant := 2;
REPLACEFILE_WRITE_THROUGH : constant := 1;
RESETDEV : constant := 7;
RIP_EVENT : constant := 9;
RTS_CONTROL_DISABLE : constant := 0;
RTS_CONTROL_ENABLE : constant := 1;
RTS_CONTROL_HANDSHAKE : constant := 2;
RTS_CONTROL_TOGGLE : constant := 3;
function ReadEventLog (hEventLog : winnt.HANDLE;
dwReadFlags : windef.DWORD; dwRecordOffset : windef.DWORD;
lpBuffer : windef.LPVOID; nNumberOfBytesToRead : windef.DWORD;
pnBytesRead : access windef.DWORD;
pnMinNumberOfBytesNeeded : access windef.DWORD) return windef.WINBOOL
renames ReadEventLogW;
function RegisterEventSource (
lpUNCServerName : access constant winnt.WCHAR;
lpSourceName : access constant winnt.WCHAR) return winnt.HANDLE
renames RegisterEventSourceW;
function RemoveDirectory (lpPathName : access constant winnt.WCHAR)
return windef.WINBOOL renames RemoveDirectoryW;
function ReplaceFile (lpReplacedFileName : access constant winnt.WCHAR;
lpReplacementFileName : access constant winnt.WCHAR;
lpBackupFileName : access constant winnt.WCHAR;
dwReplaceFlags : windef.DWORD; lpExclude : windef.LPVOID;
lpReserved : windef.LPVOID) return windef.WINBOOL renames ReplaceFileW;
function ReportEvent (hEventLog : winnt.HANDLE; wType : windef.WORD;
wCategory : windef.WORD; dwEventID : windef.DWORD;
lpUserSid : winnt.PSID; wNumStrings : windef.WORD;
dwDataSize : windef.DWORD; lpStrings : access winnt.LPCWSTR;
lpRawData : windef.LPVOID) return windef.WINBOOL renames ReportEventW;
SCS_32BIT_BINARY : constant := 0;
SCS_64BIT_BINARY : constant := 6;
SCS_DOS_BINARY : constant := 1;
SCS_OS216_BINARY : constant := 5;
SCS_PIF_BINARY : constant := 3;
SCS_POSIX_BINARY : constant := 4;
SCS_THIS_PLATFORM_BINARY : constant := 6;
SCS_WOW_BINARY : constant := 2;
SECURITY_ANONYMOUS : constant := 0;
SECURITY_CONTEXT_TRACKING : constant := 262144;
SECURITY_DELEGATION : constant := 196608;
SECURITY_EFFECTIVE_ONLY : constant := 524288;
SECURITY_IDENTIFICATION : constant := 65536;
SECURITY_IMPERSONATION : constant := 131072;
SECURITY_SQOS_PRESENT : constant := 1048576;
SECURITY_VALID_SQOS_FLAGS : constant := 2031616;
SEM_FAILCRITICALERRORS : constant := 1;
SEM_NOALIGNMENTFAULTEXCEPT : constant := 4;
SEM_NOGPFAULTERRORBOX : constant := 2;
SEM_NOOPENFILEERRORBOX : constant := 32768;
SETBREAK : constant := 8;
SETDTR : constant := 5;
SETRTS : constant := 3;
SETXOFF : constant := 1;
SETXON : constant := 2;
SET_TAPE_DRIVE_INFORMATION : constant := 1;
SET_TAPE_MEDIA_INFORMATION : constant := 0;
SHUTDOWN_NORETRY : constant := 1;
SPACEPARITY : constant := 4;
SP_BAUD : constant := 2;
SP_DATABITS : constant := 4;
SP_HANDSHAKING : constant := 16;
SP_PARITY : constant := 1;
SP_PARITY_CHECK : constant := 32;
SP_RLSD : constant := 64;
SP_SERIALCOMM : constant := 1;
SP_STOPBITS : constant := 8;
STACK_SIZE_PARAM_IS_A_RESERVATION : constant := 65536;
STARTF_FORCEOFFFEEDBACK : constant := 128;
STARTF_FORCEONFEEDBACK : constant := 64;
STARTF_RUNFULLSCREEN : constant := 32;
STARTF_USECOUNTCHARS : constant := 8;
STARTF_USEFILLATTRIBUTE : constant := 16;
STARTF_USEHOTKEY : constant := 512;
STARTF_USEPOSITION : constant := 4;
STARTF_USESHOWWINDOW : constant := 1;
STARTF_USESIZE : constant := 2;
STARTF_USESTDHANDLES : constant := 256;
STD_ERROR_HANDLE : constant := 4294967284;
STD_INPUT_HANDLE : constant := 4294967286;
STD_OUTPUT_HANDLE : constant := 4294967285;
STILL_ACTIVE : constant := 259;
STOPBITS_10 : constant := 1;
STOPBITS_15 : constant := 2;
STOPBITS_20 : constant := 4;
STREAM_CONTAINS_PROPERTIES : constant := 4;
STREAM_CONTAINS_SECURITY : constant := 2;
STREAM_MODIFIED_WHEN_READ : constant := 1;
STREAM_NORMAL_ATTRIBUTE : constant := 0;
STREAM_SPARSE_ATTRIBUTE : constant := 8;
S_ALLTHRESHOLD : constant := 2;
S_LEGATO : constant := 1;
S_NORMAL : constant := 0;
S_PERIOD1024 : constant := 1;
S_PERIOD2048 : constant := 2;
S_PERIOD512 : constant := 0;
S_PERIODVOICE : constant := 3;
S_QUEUEEMPTY : constant := 0;
S_SERBDNT : constant := -5;
S_SERDCC : constant := -7;
S_SERDDR : constant := -14;
S_SERDFQ : constant := -13;
S_SERDLN : constant := -6;
S_SERDMD : constant := -10;
S_SERDPT : constant := -12;
S_SERDSH : constant := -11;
S_SERDSR : constant := -15;
S_SERDST : constant := -16;
S_SERDTP : constant := -8;
S_SERDVL : constant := -9;
S_SERDVNA : constant := -1;
S_SERMACT : constant := -3;
S_SEROFM : constant := -2;
S_SERQFUL : constant := -4;
S_STACCATO : constant := 2;
S_THRESHOLD : constant := 1;
S_WHITE1024 : constant := 5;
S_WHITE2048 : constant := 6;
S_WHITE512 : constant := 4;
S_WHITEVOICE : constant := 7;
function SearchPath (lpPath : access constant winnt.WCHAR;
lpFileName : access constant winnt.WCHAR;
lpExtension : access constant winnt.WCHAR;
nBufferLength : windef.DWORD; lpBuffer : access winnt.WCHAR;
lpFilePart : access winnt.LPWSTR) return windef.DWORD
renames SearchPathW;
function SecureZeroMemory (ptr : winnt.PVOID; cnt : basetsd.SIZE_T)
return winnt.PVOID renames winnt.RtlSecureZeroMemory;
function SetComputerName (lpComputerName : access constant winnt.WCHAR)
return windef.WINBOOL renames SetComputerNameW;
function SetComputerNameEx (NameType : COMPUTER_NAME_FORMAT;
lpBuffer : access constant winnt.WCHAR) return windef.WINBOOL
renames SetComputerNameExW;
function SetCurrentDirectory (lpPathName : access constant winnt.WCHAR)
return windef.WINBOOL renames SetCurrentDirectoryW;
function SetDefaultCommConfig (lpszName : access constant winnt.WCHAR;
lpCC : access struct_COMMCONFIG; dwSize : windef.DWORD)
return windef.WINBOOL renames SetDefaultCommConfigW;
function SetDllDirectory (lpPathName : access constant winnt.WCHAR)
return windef.WINBOOL renames SetDllDirectoryW;
function SetEnvironmentStrings (NewEnvironment : access winnt.WCHAR)
return windef.WINBOOL renames SetEnvironmentStringsW;
function SetEnvironmentVariable (lpName : access constant winnt.WCHAR;
lpValue : access constant winnt.WCHAR) return windef.WINBOOL
renames SetEnvironmentVariableW;
function SetFileAttributes (lpFileName : access constant winnt.WCHAR;
dwFileAttributes : windef.DWORD) return windef.WINBOOL
renames SetFileAttributesW;
function SetFileSecurity (lpFileName : access constant winnt.WCHAR;
SecurityInformation : winnt.SECURITY_INFORMATION;
pSecurityDescriptor : winnt.PSECURITY_DESCRIPTOR) return windef.WINBOOL
renames SetFileSecurityW;
function SetFileShortName (hFile : winnt.HANDLE;
lpShortName : access constant winnt.WCHAR) return windef.WINBOOL
renames SetFileShortNameW;
function SetFirmwareEnvironmentVariable (
lpName : access constant winnt.WCHAR;
lpGuid : access constant winnt.WCHAR; pValue : winnt.PVOID;
nSize : windef.DWORD) return windef.WINBOOL
renames SetFirmwareEnvironmentVariableW;
-- SetSwapAreaSize (function macro)
function SetVolumeLabel (lpRootPathName : access constant winnt.WCHAR;
lpVolumeName : access constant winnt.WCHAR) return windef.WINBOOL
renames SetVolumeLabelW;
function SetVolumeMountPoint (
lpszVolumeMountPoint : access constant winnt.WCHAR;
lpszVolumeName : access constant winnt.WCHAR) return windef.WINBOOL
renames SetVolumeMountPointW;
TC_GP_TRAP : constant := 2;
TC_HARDERR : constant := 1;
TC_NORMAL : constant := 0;
TC_SIGNAL : constant := 3;
THREAD_MODE_BACKGROUND_BEGIN : constant := 65536;
THREAD_MODE_BACKGROUND_END : constant := 131072;
THREAD_PRIORITY_ABOVE_NORMAL : constant := 1;
THREAD_PRIORITY_BELOW_NORMAL : constant := -1;
THREAD_PRIORITY_ERROR_RETURN : constant := 2147483647;
THREAD_PRIORITY_HIGHEST : constant := 2;
THREAD_PRIORITY_IDLE : constant := -15;
THREAD_PRIORITY_LOWEST : constant := -2;
THREAD_PRIORITY_NORMAL : constant := 0;
THREAD_PRIORITY_TIME_CRITICAL : constant := 15;
TIME_ZONE_ID_INVALID : constant := 4294967295;
TLS_OUT_OF_INDEXES : constant := 4294967295;
TRUNCATE_EXISTING : constant := 5;
TWOSTOPBITS : constant := 2;
UNLOAD_DLL_DEBUG_EVENT : constant := 7;
-- UnlockResource (function macro)
-- UnlockSegment (function macro)
function UpdateResource (hUpdate : winnt.HANDLE;
lpType : access constant winnt.WCHAR;
lpName : access constant winnt.WCHAR; wLanguage : windef.WORD;
lpData : windef.LPVOID; cb : windef.DWORD) return windef.WINBOOL
renames UpdateResourceW;
function VerifyVersionInfo (
lpVersionInformation : access winnt.struct_OSVERSIONINFOEXW;
dwTypeMask : windef.DWORD; dwlConditionMask : winnt.DWORDLONG)
return windef.WINBOOL renames VerifyVersionInfoW;
WAIT_ABANDONED : constant := 128;
WAIT_ABANDONED_0 : constant := 128;
WAIT_FAILED : constant := 4294967295;
WAIT_IO_COMPLETION : constant := 192;
WAIT_OBJECT_0 : constant := 0;
function WaitNamedPipe (lpNamedPipeName : access constant winnt.WCHAR;
nTimeOut : windef.DWORD) return windef.WINBOOL renames WaitNamedPipeW;
function WritePrivateProfileSection (
lpAppName : access constant winnt.WCHAR;
lpString : access constant winnt.WCHAR;
lpFileName : access constant winnt.WCHAR) return windef.WINBOOL
renames WritePrivateProfileSectionW;
function WritePrivateProfileString (
lpAppName : access constant winnt.WCHAR;
lpKeyName : access constant winnt.WCHAR;
lpString : access constant winnt.WCHAR;
lpFileName : access constant winnt.WCHAR) return windef.WINBOOL
renames WritePrivateProfileStringW;
function WritePrivateProfileStruct (
lpszSection : access constant winnt.WCHAR;
lpszKey : access constant winnt.WCHAR; lpStruct : windef.LPVOID;
uSizeStruct : windef.UINT; szFile : access constant winnt.WCHAR)
return windef.WINBOOL renames WritePrivateProfileStructW;
function WriteProfileSection (lpAppName : access constant winnt.WCHAR;
lpString : access constant winnt.WCHAR) return windef.WINBOOL
renames WriteProfileSectionW;
function WriteProfileString (lpAppName : access constant winnt.WCHAR;
lpKeyName : access constant winnt.WCHAR;
lpString : access constant winnt.WCHAR) return windef.WINBOOL
renames WriteProfileStringW;
-- Yield (empty)
-- ZeroMemory (function macro)
-- _SYSTEMTIME_ (empty)
-- _WINBASE_ (empty)
function lstrcat (lpString1 : access winnt.WCHAR;
lpString2 : access constant winnt.WCHAR) return winnt.LPWSTR
renames lstrcatW;
function lstrcmp (lpString1 : access constant winnt.WCHAR;
lpString2 : access constant winnt.WCHAR) return signed_int
renames lstrcmpW;
function lstrcmpi (lpString1 : access constant winnt.WCHAR;
lpString2 : access constant winnt.WCHAR) return signed_int
renames lstrcmpiW;
function lstrcpy (lpString1 : access winnt.WCHAR;
lpString2 : access constant winnt.WCHAR) return winnt.LPWSTR
renames lstrcpyW;
function lstrcpyn (lpString1 : access winnt.WCHAR;
lpString2 : access constant winnt.WCHAR; iMaxLength : signed_int)
return winnt.LPWSTR renames lstrcpynW;
function lstrlen (lpString : access constant winnt.WCHAR)
return signed_int renames lstrlenW;
end C.winbase;
Raw
c-wincon.ads
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
with C.winbase;
with C.windef;
with C.winnt;
package C.wincon is
pragma Preelaborate;
type struct_COORD;
type struct_COORD is record
X : aliased winnt.SHORT;
Y : aliased winnt.SHORT;
end record;
pragma Convention (C_Pass_By_Copy, struct_COORD);
type struct_COORD_ptr is access all struct_COORD;
for struct_COORD_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_COORD_ptr);
pragma Convention (C, struct_COORD_ptr);
subtype COORD is struct_COORD;
subtype PCOORD is struct_COORD_ptr;
type struct_SMALL_RECT;
type struct_SMALL_RECT is record
Left : aliased winnt.SHORT;
Top : aliased winnt.SHORT;
Right : aliased winnt.SHORT;
Bottom : aliased winnt.SHORT;
end record;
pragma Convention (C_Pass_By_Copy, struct_SMALL_RECT);
type struct_SMALL_RECT_ptr is access all struct_SMALL_RECT;
for struct_SMALL_RECT_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_SMALL_RECT_ptr);
pragma Convention (C, struct_SMALL_RECT_ptr);
type struct_SMALL_RECT_const_ptr is access constant struct_SMALL_RECT;
for struct_SMALL_RECT_const_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_SMALL_RECT_const_ptr);
pragma Convention (C, struct_SMALL_RECT_const_ptr);
subtype SMALL_RECT is struct_SMALL_RECT;
subtype SMALL_RECT_const_ptr is struct_SMALL_RECT_const_ptr;
subtype PSMALL_RECT is struct_SMALL_RECT_ptr;
type struct_KEY_EVENT_RECORD;
type union_d059ff5e (Unchecked_Tag : unsigned_int := 0) is record
case Unchecked_Tag is
when 0 =>
UnicodeChar : winnt.WCHAR;
when others =>
AsciiChar : winnt.C_CHAR;
end case;
end record;
pragma Unchecked_Union (union_d059ff5e);
pragma Convention (C_Pass_By_Copy, union_d059ff5e);
type struct_KEY_EVENT_RECORD is record
bKeyDown : aliased windef.WINBOOL;
wRepeatCount : aliased windef.WORD;
wVirtualKeyCode : aliased windef.WORD;
wVirtualScanCode : aliased windef.WORD;
uChar : aliased union_d059ff5e;
dwControlKeyState : aliased windef.DWORD;
end record;
pragma Convention (C_Pass_By_Copy, struct_KEY_EVENT_RECORD);
type struct_KEY_EVENT_RECORD_ptr is access all struct_KEY_EVENT_RECORD;
for struct_KEY_EVENT_RECORD_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_KEY_EVENT_RECORD_ptr);
pragma Convention (C, struct_KEY_EVENT_RECORD_ptr);
subtype KEY_EVENT_RECORD is struct_KEY_EVENT_RECORD;
subtype PKEY_EVENT_RECORD is struct_KEY_EVENT_RECORD_ptr;
type struct_MOUSE_EVENT_RECORD;
type struct_MOUSE_EVENT_RECORD is record
dwMousePosition : aliased COORD;
dwButtonState : aliased windef.DWORD;
dwControlKeyState : aliased windef.DWORD;
dwEventFlags : aliased windef.DWORD;
end record;
pragma Convention (C_Pass_By_Copy, struct_MOUSE_EVENT_RECORD);
type struct_MOUSE_EVENT_RECORD_ptr is
access all struct_MOUSE_EVENT_RECORD;
for struct_MOUSE_EVENT_RECORD_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_MOUSE_EVENT_RECORD_ptr);
pragma Convention (C, struct_MOUSE_EVENT_RECORD_ptr);
subtype MOUSE_EVENT_RECORD is struct_MOUSE_EVENT_RECORD;
subtype PMOUSE_EVENT_RECORD is struct_MOUSE_EVENT_RECORD_ptr;
type struct_WINDOW_BUFFER_SIZE_RECORD;
type struct_WINDOW_BUFFER_SIZE_RECORD is record
dwSize : aliased COORD;
end record;
pragma Convention (C_Pass_By_Copy, struct_WINDOW_BUFFER_SIZE_RECORD);
type struct_WINDOW_BUFFER_SIZE_RECORD_ptr is
access all struct_WINDOW_BUFFER_SIZE_RECORD;
for struct_WINDOW_BUFFER_SIZE_RECORD_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_WINDOW_BUFFER_SIZE_RECORD_ptr);
pragma Convention (C, struct_WINDOW_BUFFER_SIZE_RECORD_ptr);
subtype WINDOW_BUFFER_SIZE_RECORD is struct_WINDOW_BUFFER_SIZE_RECORD;
subtype PWINDOW_BUFFER_SIZE_RECORD is
struct_WINDOW_BUFFER_SIZE_RECORD_ptr;
type struct_MENU_EVENT_RECORD;
type struct_MENU_EVENT_RECORD is record
dwCommandId : aliased windef.UINT;
end record;
pragma Convention (C_Pass_By_Copy, struct_MENU_EVENT_RECORD);
type struct_MENU_EVENT_RECORD_ptr is access all struct_MENU_EVENT_RECORD;
for struct_MENU_EVENT_RECORD_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_MENU_EVENT_RECORD_ptr);
pragma Convention (C, struct_MENU_EVENT_RECORD_ptr);
subtype MENU_EVENT_RECORD is struct_MENU_EVENT_RECORD;
subtype PMENU_EVENT_RECORD is struct_MENU_EVENT_RECORD_ptr;
type struct_FOCUS_EVENT_RECORD;
type struct_FOCUS_EVENT_RECORD is record
bSetFocus : aliased windef.WINBOOL;
end record;
pragma Convention (C_Pass_By_Copy, struct_FOCUS_EVENT_RECORD);
type struct_FOCUS_EVENT_RECORD_ptr is
access all struct_FOCUS_EVENT_RECORD;
for struct_FOCUS_EVENT_RECORD_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_FOCUS_EVENT_RECORD_ptr);
pragma Convention (C, struct_FOCUS_EVENT_RECORD_ptr);
subtype FOCUS_EVENT_RECORD is struct_FOCUS_EVENT_RECORD;
subtype PFOCUS_EVENT_RECORD is struct_FOCUS_EVENT_RECORD_ptr;
type struct_INPUT_RECORD;
type union_2288c64d (Unchecked_Tag : unsigned_int := 0) is record
case Unchecked_Tag is
when 0 =>
KeyEvent : KEY_EVENT_RECORD;
when 1 =>
MouseEvent : MOUSE_EVENT_RECORD;
when 2 =>
WindowBufferSizeEvent : WINDOW_BUFFER_SIZE_RECORD;
when 3 =>
MenuEvent : MENU_EVENT_RECORD;
when others =>
FocusEvent : FOCUS_EVENT_RECORD;
end case;
end record;
pragma Unchecked_Union (union_2288c64d);
pragma Convention (C_Pass_By_Copy, union_2288c64d);
type struct_INPUT_RECORD is record
EventType : aliased windef.WORD;
Event : aliased union_2288c64d;
end record;
pragma Convention (C_Pass_By_Copy, struct_INPUT_RECORD);
type struct_INPUT_RECORD_ptr is access all struct_INPUT_RECORD;
for struct_INPUT_RECORD_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_INPUT_RECORD_ptr);
pragma Convention (C, struct_INPUT_RECORD_ptr);
type struct_INPUT_RECORD_const_ptr is access constant struct_INPUT_RECORD;
for struct_INPUT_RECORD_const_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_INPUT_RECORD_const_ptr);
pragma Convention (C, struct_INPUT_RECORD_const_ptr);
subtype INPUT_RECORD is struct_INPUT_RECORD;
subtype INPUT_RECORD_const_ptr is struct_INPUT_RECORD_const_ptr;
subtype PINPUT_RECORD is struct_INPUT_RECORD_ptr;
type struct_CHAR_INFO;
type union_31090535 (Unchecked_Tag : unsigned_int := 0) is record
case Unchecked_Tag is
when 0 =>
UnicodeChar : winnt.WCHAR;
when others =>
AsciiChar : winnt.C_CHAR;
end case;
end record;
pragma Unchecked_Union (union_31090535);
pragma Convention (C_Pass_By_Copy, union_31090535);
type struct_CHAR_INFO is record
Char : aliased union_31090535;
Attributes : aliased windef.WORD;
end record;
pragma Convention (C_Pass_By_Copy, struct_CHAR_INFO);
type struct_CHAR_INFO_ptr is access all struct_CHAR_INFO;
for struct_CHAR_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CHAR_INFO_ptr);
pragma Convention (C, struct_CHAR_INFO_ptr);
type struct_CHAR_INFO_const_ptr is access constant struct_CHAR_INFO;
for struct_CHAR_INFO_const_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CHAR_INFO_const_ptr);
pragma Convention (C, struct_CHAR_INFO_const_ptr);
subtype CHAR_INFO is struct_CHAR_INFO;
subtype CHAR_INFO_const_ptr is struct_CHAR_INFO_const_ptr;
subtype PCHAR_INFO is struct_CHAR_INFO_ptr;
type struct_CONSOLE_SCREEN_BUFFER_INFO;
type struct_CONSOLE_SCREEN_BUFFER_INFO is record
dwSize : aliased COORD;
dwCursorPosition : aliased COORD;
wAttributes : aliased windef.WORD;
srWindow : aliased SMALL_RECT;
dwMaximumWindowSize : aliased COORD;
end record;
pragma Convention (C_Pass_By_Copy, struct_CONSOLE_SCREEN_BUFFER_INFO);
type struct_CONSOLE_SCREEN_BUFFER_INFO_ptr is
access all struct_CONSOLE_SCREEN_BUFFER_INFO;
for struct_CONSOLE_SCREEN_BUFFER_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CONSOLE_SCREEN_BUFFER_INFO_ptr);
pragma Convention (C, struct_CONSOLE_SCREEN_BUFFER_INFO_ptr);
subtype CONSOLE_SCREEN_BUFFER_INFO is struct_CONSOLE_SCREEN_BUFFER_INFO;
subtype PCONSOLE_SCREEN_BUFFER_INFO is
struct_CONSOLE_SCREEN_BUFFER_INFO_ptr;
type struct_CONSOLE_CURSOR_INFO;
type struct_CONSOLE_CURSOR_INFO is record
dwSize : aliased windef.DWORD;
bVisible : aliased windef.WINBOOL;
end record;
pragma Convention (C_Pass_By_Copy, struct_CONSOLE_CURSOR_INFO);
type struct_CONSOLE_CURSOR_INFO_ptr is
access all struct_CONSOLE_CURSOR_INFO;
for struct_CONSOLE_CURSOR_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CONSOLE_CURSOR_INFO_ptr);
pragma Convention (C, struct_CONSOLE_CURSOR_INFO_ptr);
type struct_CONSOLE_CURSOR_INFO_const_ptr is
access constant struct_CONSOLE_CURSOR_INFO;
for struct_CONSOLE_CURSOR_INFO_const_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CONSOLE_CURSOR_INFO_const_ptr);
pragma Convention (C, struct_CONSOLE_CURSOR_INFO_const_ptr);
subtype CONSOLE_CURSOR_INFO is struct_CONSOLE_CURSOR_INFO;
subtype CONSOLE_CURSOR_INFO_const_ptr is
struct_CONSOLE_CURSOR_INFO_const_ptr;
subtype PCONSOLE_CURSOR_INFO is struct_CONSOLE_CURSOR_INFO_ptr;
type struct_CONSOLE_FONT_INFO;
type struct_CONSOLE_FONT_INFO is record
nFont : aliased windef.DWORD;
dwFontSize : aliased COORD;
end record;
pragma Convention (C_Pass_By_Copy, struct_CONSOLE_FONT_INFO);
type struct_CONSOLE_FONT_INFO_ptr is access all struct_CONSOLE_FONT_INFO;
for struct_CONSOLE_FONT_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CONSOLE_FONT_INFO_ptr);
pragma Convention (C, struct_CONSOLE_FONT_INFO_ptr);
subtype CONSOLE_FONT_INFO is struct_CONSOLE_FONT_INFO;
subtype PCONSOLE_FONT_INFO is struct_CONSOLE_FONT_INFO_ptr;
type struct_CONSOLE_SELECTION_INFO;
type struct_CONSOLE_SELECTION_INFO is record
dwFlags : aliased windef.DWORD;
dwSelectionAnchor : aliased COORD;
srSelection : aliased SMALL_RECT;
end record;
pragma Convention (C_Pass_By_Copy, struct_CONSOLE_SELECTION_INFO);
type struct_CONSOLE_SELECTION_INFO_ptr is
access all struct_CONSOLE_SELECTION_INFO;
for struct_CONSOLE_SELECTION_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CONSOLE_SELECTION_INFO_ptr);
pragma Convention (C, struct_CONSOLE_SELECTION_INFO_ptr);
subtype CONSOLE_SELECTION_INFO is struct_CONSOLE_SELECTION_INFO;
subtype PCONSOLE_SELECTION_INFO is struct_CONSOLE_SELECTION_INFO_ptr;
type access_f304c0b7 is access function (CtrlType : windef.DWORD)
return windef.WINBOOL;
pragma Convention (C, access_f304c0b7);
subtype PHANDLER_ROUTINE is access_f304c0b7;
function PeekConsoleInputA (hConsoleInput : winnt.HANDLE;
lpBuffer : access struct_INPUT_RECORD; nLength : windef.DWORD;
lpNumberOfEventsRead : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, PeekConsoleInputA, "PeekConsoleInputA");
function PeekConsoleInputW (hConsoleInput : winnt.HANDLE;
lpBuffer : access struct_INPUT_RECORD; nLength : windef.DWORD;
lpNumberOfEventsRead : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, PeekConsoleInputW, "PeekConsoleInputW");
function ReadConsoleInputA (hConsoleInput : winnt.HANDLE;
lpBuffer : access struct_INPUT_RECORD; nLength : windef.DWORD;
lpNumberOfEventsRead : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, ReadConsoleInputA, "ReadConsoleInputA");
function ReadConsoleInputW (hConsoleInput : winnt.HANDLE;
lpBuffer : access struct_INPUT_RECORD; nLength : windef.DWORD;
lpNumberOfEventsRead : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, ReadConsoleInputW, "ReadConsoleInputW");
function WriteConsoleInputA (hConsoleInput : winnt.HANDLE;
lpBuffer : access constant INPUT_RECORD; nLength : windef.DWORD;
lpNumberOfEventsWritten : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, WriteConsoleInputA, "WriteConsoleInputA");
function WriteConsoleInputW (hConsoleInput : winnt.HANDLE;
lpBuffer : access constant INPUT_RECORD; nLength : windef.DWORD;
lpNumberOfEventsWritten : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, WriteConsoleInputW, "WriteConsoleInputW");
function ReadConsoleOutputA (hConsoleOutput : winnt.HANDLE;
lpBuffer : access struct_CHAR_INFO; dwBufferSize : COORD;
dwBufferCoord : COORD; lpReadRegion : access struct_SMALL_RECT)
return windef.WINBOOL;
pragma Import (C, ReadConsoleOutputA, "ReadConsoleOutputA");
function ReadConsoleOutputW (hConsoleOutput : winnt.HANDLE;
lpBuffer : access struct_CHAR_INFO; dwBufferSize : COORD;
dwBufferCoord : COORD; lpReadRegion : access struct_SMALL_RECT)
return windef.WINBOOL;
pragma Import (C, ReadConsoleOutputW, "ReadConsoleOutputW");
function WriteConsoleOutputA (hConsoleOutput : winnt.HANDLE;
lpBuffer : access constant CHAR_INFO; dwBufferSize : COORD;
dwBufferCoord : COORD; lpWriteRegion : access struct_SMALL_RECT)
return windef.WINBOOL;
pragma Import (C, WriteConsoleOutputA, "WriteConsoleOutputA");
function WriteConsoleOutputW (hConsoleOutput : winnt.HANDLE;
lpBuffer : access constant CHAR_INFO; dwBufferSize : COORD;
dwBufferCoord : COORD; lpWriteRegion : access struct_SMALL_RECT)
return windef.WINBOOL;
pragma Import (C, WriteConsoleOutputW, "WriteConsoleOutputW");
function ReadConsoleOutputCharacterA (hConsoleOutput : winnt.HANDLE;
lpCharacter : access winnt.C_CHAR; nLength : windef.DWORD;
dwReadCoord : COORD; lpNumberOfCharsRead : access windef.DWORD)
return windef.WINBOOL;
pragma Import (C, ReadConsoleOutputCharacterA,
"ReadConsoleOutputCharacterA");
function ReadConsoleOutputCharacterW (hConsoleOutput : winnt.HANDLE;
lpCharacter : access winnt.WCHAR; nLength : windef.DWORD;
dwReadCoord : COORD; lpNumberOfCharsRead : access windef.DWORD)
return windef.WINBOOL;
pragma Import (C, ReadConsoleOutputCharacterW,
"ReadConsoleOutputCharacterW");
function ReadConsoleOutputAttribute (hConsoleOutput : winnt.HANDLE;
lpAttribute : access windef.WORD; nLength : windef.DWORD;
dwReadCoord : COORD; lpNumberOfAttrsRead : access windef.DWORD)
return windef.WINBOOL;
pragma Import (C, ReadConsoleOutputAttribute,
"ReadConsoleOutputAttribute");
function WriteConsoleOutputCharacterA (hConsoleOutput : winnt.HANDLE;
lpCharacter : access constant winnt.C_CHAR; nLength : windef.DWORD;
dwWriteCoord : COORD; lpNumberOfCharsWritten : access windef.DWORD)
return windef.WINBOOL;
pragma Import (C, WriteConsoleOutputCharacterA,
"WriteConsoleOutputCharacterA");
function WriteConsoleOutputCharacterW (hConsoleOutput : winnt.HANDLE;
lpCharacter : access constant winnt.WCHAR; nLength : windef.DWORD;
dwWriteCoord : COORD; lpNumberOfCharsWritten : access windef.DWORD)
return windef.WINBOOL;
pragma Import (C, WriteConsoleOutputCharacterW,
"WriteConsoleOutputCharacterW");
function WriteConsoleOutputAttribute (hConsoleOutput : winnt.HANDLE;
lpAttribute : access constant windef.WORD; nLength : windef.DWORD;
dwWriteCoord : COORD; lpNumberOfAttrsWritten : access windef.DWORD)
return windef.WINBOOL;
pragma Import (C, WriteConsoleOutputAttribute,
"WriteConsoleOutputAttribute");
function FillConsoleOutputCharacterA (hConsoleOutput : winnt.HANDLE;
cCharacter : winnt.C_CHAR; nLength : windef.DWORD;
dwWriteCoord : COORD; lpNumberOfCharsWritten : access windef.DWORD)
return windef.WINBOOL;
pragma Import (C, FillConsoleOutputCharacterA,
"FillConsoleOutputCharacterA");
function FillConsoleOutputCharacterW (hConsoleOutput : winnt.HANDLE;
cCharacter : winnt.WCHAR; nLength : windef.DWORD; dwWriteCoord : COORD;
lpNumberOfCharsWritten : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, FillConsoleOutputCharacterW,
"FillConsoleOutputCharacterW");
function FillConsoleOutputAttribute (hConsoleOutput : winnt.HANDLE;
wAttribute : windef.WORD; nLength : windef.DWORD; dwWriteCoord : COORD;
lpNumberOfAttrsWritten : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, FillConsoleOutputAttribute,
"FillConsoleOutputAttribute");
function GetConsoleMode (hConsoleHandle : winnt.HANDLE;
lpMode : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, GetConsoleMode, "GetConsoleMode");
function GetNumberOfConsoleInputEvents (hConsoleInput : winnt.HANDLE;
lpNumberOfEvents : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, GetNumberOfConsoleInputEvents,
"GetNumberOfConsoleInputEvents");
function GetConsoleScreenBufferInfo (hConsoleOutput : winnt.HANDLE;
lpConsoleScreenBufferInfo : access struct_CONSOLE_SCREEN_BUFFER_INFO)
return windef.WINBOOL;
pragma Import (C, GetConsoleScreenBufferInfo,
"GetConsoleScreenBufferInfo");
function GetLargestConsoleWindowSize (hConsoleOutput : winnt.HANDLE)
return COORD;
pragma Import (C, GetLargestConsoleWindowSize,
"GetLargestConsoleWindowSize");
function GetConsoleCursorInfo (hConsoleOutput : winnt.HANDLE;
lpConsoleCursorInfo : access struct_CONSOLE_CURSOR_INFO)
return windef.WINBOOL;
pragma Import (C, GetConsoleCursorInfo, "GetConsoleCursorInfo");
function GetCurrentConsoleFont (hConsoleOutput : winnt.HANDLE;
bMaximumWindow : windef.WINBOOL;
lpConsoleCurrentFont : access struct_CONSOLE_FONT_INFO)
return windef.WINBOOL;
pragma Import (C, GetCurrentConsoleFont, "GetCurrentConsoleFont");
function GetConsoleFontSize (hConsoleOutput : winnt.HANDLE;
nFont : windef.DWORD) return COORD;
pragma Import (C, GetConsoleFontSize, "GetConsoleFontSize");
function GetConsoleSelectionInfo (
lpConsoleSelectionInfo : access struct_CONSOLE_SELECTION_INFO)
return windef.WINBOOL;
pragma Import (C, GetConsoleSelectionInfo, "GetConsoleSelectionInfo");
function GetNumberOfConsoleMouseButtons (
lpNumberOfMouseButtons : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, GetNumberOfConsoleMouseButtons,
"GetNumberOfConsoleMouseButtons");
function SetConsoleMode (hConsoleHandle : winnt.HANDLE;
dwMode : windef.DWORD) return windef.WINBOOL;
pragma Import (C, SetConsoleMode, "SetConsoleMode");
function SetConsoleActiveScreenBuffer (hConsoleOutput : winnt.HANDLE)
return windef.WINBOOL;
pragma Import (C, SetConsoleActiveScreenBuffer,
"SetConsoleActiveScreenBuffer");
function FlushConsoleInputBuffer (hConsoleInput : winnt.HANDLE)
return windef.WINBOOL;
pragma Import (C, FlushConsoleInputBuffer, "FlushConsoleInputBuffer");
function SetConsoleScreenBufferSize (hConsoleOutput : winnt.HANDLE;
dwSize : COORD) return windef.WINBOOL;
pragma Import (C, SetConsoleScreenBufferSize,
"SetConsoleScreenBufferSize");
function SetConsoleCursorPosition (hConsoleOutput : winnt.HANDLE;
dwCursorPosition : COORD) return windef.WINBOOL;
pragma Import (C, SetConsoleCursorPosition, "SetConsoleCursorPosition");
function SetConsoleCursorInfo (hConsoleOutput : winnt.HANDLE;
lpConsoleCursorInfo : access constant CONSOLE_CURSOR_INFO)
return windef.WINBOOL;
pragma Import (C, SetConsoleCursorInfo, "SetConsoleCursorInfo");
function ScrollConsoleScreenBufferA (hConsoleOutput : winnt.HANDLE;
lpScrollRectangle : access constant SMALL_RECT;
lpClipRectangle : access constant SMALL_RECT;
dwDestinationOrigin : COORD; lpFill : access constant CHAR_INFO)
return windef.WINBOOL;
pragma Import (C, ScrollConsoleScreenBufferA,
"ScrollConsoleScreenBufferA");
function ScrollConsoleScreenBufferW (hConsoleOutput : winnt.HANDLE;
lpScrollRectangle : access constant SMALL_RECT;
lpClipRectangle : access constant SMALL_RECT;
dwDestinationOrigin : COORD; lpFill : access constant CHAR_INFO)
return windef.WINBOOL;
pragma Import (C, ScrollConsoleScreenBufferW,
"ScrollConsoleScreenBufferW");
function SetConsoleWindowInfo (hConsoleOutput : winnt.HANDLE;
bAbsolute : windef.WINBOOL;
lpConsoleWindow : access constant SMALL_RECT) return windef.WINBOOL;
pragma Import (C, SetConsoleWindowInfo, "SetConsoleWindowInfo");
function SetConsoleTextAttribute (hConsoleOutput : winnt.HANDLE;
wAttributes : windef.WORD) return windef.WINBOOL;
pragma Import (C, SetConsoleTextAttribute, "SetConsoleTextAttribute");
function SetConsoleCtrlHandler (HandlerRoutine : PHANDLER_ROUTINE;
Add : windef.WINBOOL) return windef.WINBOOL;
pragma Import (C, SetConsoleCtrlHandler, "SetConsoleCtrlHandler");
function GenerateConsoleCtrlEvent (dwCtrlEvent : windef.DWORD;
dwProcessGroupId : windef.DWORD) return windef.WINBOOL;
pragma Import (C, GenerateConsoleCtrlEvent, "GenerateConsoleCtrlEvent");
function AllocConsole return windef.WINBOOL;
pragma Import (C, AllocConsole, "AllocConsole");
function FreeConsole return windef.WINBOOL;
pragma Import (C, FreeConsole, "FreeConsole");
function AttachConsole (dwProcessId : windef.DWORD) return windef.WINBOOL;
pragma Import (C, AttachConsole, "AttachConsole");
function GetConsoleTitleA (lpConsoleTitle : access winnt.C_CHAR;
nSize : windef.DWORD) return windef.DWORD;
pragma Import (C, GetConsoleTitleA, "GetConsoleTitleA");
function GetConsoleTitleW (lpConsoleTitle : access winnt.WCHAR;
nSize : windef.DWORD) return windef.DWORD;
pragma Import (C, GetConsoleTitleW, "GetConsoleTitleW");
function SetConsoleTitleA (lpConsoleTitle : access constant winnt.C_CHAR)
return windef.WINBOOL;
pragma Import (C, SetConsoleTitleA, "SetConsoleTitleA");
function SetConsoleTitleW (lpConsoleTitle : access constant winnt.WCHAR)
return windef.WINBOOL;
pragma Import (C, SetConsoleTitleW, "SetConsoleTitleW");
function ReadConsoleA (hConsoleInput : winnt.HANDLE;
lpBuffer : windef.LPVOID; nNumberOfCharsToRead : windef.DWORD;
lpNumberOfCharsRead : access windef.DWORD; lpReserved : windef.LPVOID)
return windef.WINBOOL;
pragma Import (C, ReadConsoleA, "ReadConsoleA");
function ReadConsoleW (hConsoleInput : winnt.HANDLE;
lpBuffer : windef.LPVOID; nNumberOfCharsToRead : windef.DWORD;
lpNumberOfCharsRead : access windef.DWORD; lpReserved : windef.LPVOID)
return windef.WINBOOL;
pragma Import (C, ReadConsoleW, "ReadConsoleW");
function WriteConsoleA (hConsoleOutput : winnt.HANDLE;
lpBuffer : void_const_ptr; nNumberOfCharsToWrite : windef.DWORD;
lpNumberOfCharsWritten : access windef.DWORD;
lpReserved : windef.LPVOID) return windef.WINBOOL;
pragma Import (C, WriteConsoleA, "WriteConsoleA");
function WriteConsoleW (hConsoleOutput : winnt.HANDLE;
lpBuffer : void_const_ptr; nNumberOfCharsToWrite : windef.DWORD;
lpNumberOfCharsWritten : access windef.DWORD;
lpReserved : windef.LPVOID) return windef.WINBOOL;
pragma Import (C, WriteConsoleW, "WriteConsoleW");
function CreateConsoleScreenBuffer (dwDesiredAccess : windef.DWORD;
dwShareMode : windef.DWORD;
lpSecurityAttributes : access constant winbase.SECURITY_ATTRIBUTES;
dwFlags : windef.DWORD; lpScreenBufferData : windef.LPVOID)
return winnt.HANDLE;
pragma Import (C, CreateConsoleScreenBuffer, "CreateConsoleScreenBuffer");
function GetConsoleCP return windef.UINT;
pragma Import (C, GetConsoleCP, "GetConsoleCP");
function SetConsoleCP (wCodePageID : windef.UINT) return windef.WINBOOL;
pragma Import (C, SetConsoleCP, "SetConsoleCP");
function GetConsoleOutputCP return windef.UINT;
pragma Import (C, GetConsoleOutputCP, "GetConsoleOutputCP");
function SetConsoleOutputCP (wCodePageID : windef.UINT)
return windef.WINBOOL;
pragma Import (C, SetConsoleOutputCP, "SetConsoleOutputCP");
function GetConsoleDisplayMode (lpModeFlags : access windef.DWORD)
return windef.WINBOOL;
pragma Import (C, GetConsoleDisplayMode, "GetConsoleDisplayMode");
function SetConsoleDisplayMode (hConsoleOutput : winnt.HANDLE;
dwFlags : windef.DWORD;
lpNewScreenBufferDimensions : access struct_COORD)
return windef.WINBOOL;
pragma Import (C, SetConsoleDisplayMode, "SetConsoleDisplayMode");
function GetConsoleWindow return windef.HWND;
pragma Import (C, GetConsoleWindow, "GetConsoleWindow");
function GetConsoleProcessList (lpdwProcessList : access windef.DWORD;
dwProcessCount : windef.DWORD) return windef.DWORD;
pragma Import (C, GetConsoleProcessList, "GetConsoleProcessList");
function AddConsoleAliasA (Source : access winnt.C_CHAR;
Target : access winnt.C_CHAR; ExeName : access winnt.C_CHAR)
return windef.WINBOOL;
pragma Import (C, AddConsoleAliasA, "AddConsoleAliasA");
function AddConsoleAliasW (Source : access winnt.WCHAR;
Target : access winnt.WCHAR; ExeName : access winnt.WCHAR)
return windef.WINBOOL;
pragma Import (C, AddConsoleAliasW, "AddConsoleAliasW");
function GetConsoleAliasA (Source : access winnt.C_CHAR;
TargetBuffer : access winnt.C_CHAR; TargetBufferLength : windef.DWORD;
ExeName : access winnt.C_CHAR) return windef.DWORD;
pragma Import (C, GetConsoleAliasA, "GetConsoleAliasA");
function GetConsoleAliasW (Source : access winnt.WCHAR;
TargetBuffer : access winnt.WCHAR; TargetBufferLength : windef.DWORD;
ExeName : access winnt.WCHAR) return windef.DWORD;
pragma Import (C, GetConsoleAliasW, "GetConsoleAliasW");
function GetConsoleAliasesLengthA (ExeName : access winnt.C_CHAR)
return windef.DWORD;
pragma Import (C, GetConsoleAliasesLengthA, "GetConsoleAliasesLengthA");
function GetConsoleAliasesLengthW (ExeName : access winnt.WCHAR)
return windef.DWORD;
pragma Import (C, GetConsoleAliasesLengthW, "GetConsoleAliasesLengthW");
function GetConsoleAliasExesLengthA return windef.DWORD;
pragma Import (C, GetConsoleAliasExesLengthA,
"GetConsoleAliasExesLengthA");
function GetConsoleAliasExesLengthW return windef.DWORD;
pragma Import (C, GetConsoleAliasExesLengthW,
"GetConsoleAliasExesLengthW");
function GetConsoleAliasesA (AliasBuffer : access winnt.C_CHAR;
AliasBufferLength : windef.DWORD; ExeName : access winnt.C_CHAR)
return windef.DWORD;
pragma Import (C, GetConsoleAliasesA, "GetConsoleAliasesA");
function GetConsoleAliasesW (AliasBuffer : access winnt.WCHAR;
AliasBufferLength : windef.DWORD; ExeName : access winnt.WCHAR)
return windef.DWORD;
pragma Import (C, GetConsoleAliasesW, "GetConsoleAliasesW");
function GetConsoleAliasExesA (ExeNameBuffer : access winnt.C_CHAR;
ExeNameBufferLength : windef.DWORD) return windef.DWORD;
pragma Import (C, GetConsoleAliasExesA, "GetConsoleAliasExesA");
function GetConsoleAliasExesW (ExeNameBuffer : access winnt.WCHAR;
ExeNameBufferLength : windef.DWORD) return windef.DWORD;
pragma Import (C, GetConsoleAliasExesW, "GetConsoleAliasExesW");
type struct_CONSOLE_FONT_INFOEX;
type struct_CONSOLE_FONT_INFOEX is record
cbSize : aliased windef.ULONG;
nFont : aliased windef.DWORD;
dwFontSize : aliased COORD;
FontFamily : aliased windef.UINT;
FontWeight : aliased windef.UINT;
FaceName : aliased winnt.WCHAR_array (0 .. 31);
end record;
pragma Convention (C_Pass_By_Copy, struct_CONSOLE_FONT_INFOEX);
type struct_CONSOLE_FONT_INFOEX_ptr is
access all struct_CONSOLE_FONT_INFOEX;
for struct_CONSOLE_FONT_INFOEX_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CONSOLE_FONT_INFOEX_ptr);
pragma Convention (C, struct_CONSOLE_FONT_INFOEX_ptr);
subtype CONSOLE_FONT_INFOEX is struct_CONSOLE_FONT_INFOEX;
subtype PCONSOLE_FONT_INFOEX is struct_CONSOLE_FONT_INFOEX_ptr;
type struct_CONSOLE_HISTORY_INFO;
type struct_CONSOLE_HISTORY_INFO is record
cbSize : aliased windef.UINT;
HistoryBufferSize : aliased windef.UINT;
NumberOfHistoryBuffers : aliased windef.UINT;
dwFlags : aliased windef.DWORD;
end record;
pragma Convention (C_Pass_By_Copy, struct_CONSOLE_HISTORY_INFO);
type struct_CONSOLE_HISTORY_INFO_ptr is
access all struct_CONSOLE_HISTORY_INFO;
for struct_CONSOLE_HISTORY_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CONSOLE_HISTORY_INFO_ptr);
pragma Convention (C, struct_CONSOLE_HISTORY_INFO_ptr);
subtype CONSOLE_HISTORY_INFO is struct_CONSOLE_HISTORY_INFO;
subtype PCONSOLE_HISTORY_INFO is struct_CONSOLE_HISTORY_INFO_ptr;
type struct_CONSOLE_READCONSOLE_CONTROL;
type struct_CONSOLE_READCONSOLE_CONTROL is record
nLength : aliased windef.ULONG;
nInitialChars : aliased windef.ULONG;
dwCtrlWakeupMask : aliased windef.ULONG;
dwControlKeyState : aliased windef.ULONG;
end record;
pragma Convention (C_Pass_By_Copy, struct_CONSOLE_READCONSOLE_CONTROL);
type struct_CONSOLE_READCONSOLE_CONTROL_ptr is
access all struct_CONSOLE_READCONSOLE_CONTROL;
for struct_CONSOLE_READCONSOLE_CONTROL_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CONSOLE_READCONSOLE_CONTROL_ptr);
pragma Convention (C, struct_CONSOLE_READCONSOLE_CONTROL_ptr);
subtype CONSOLE_READCONSOLE_CONTROL is struct_CONSOLE_READCONSOLE_CONTROL;
subtype PCONSOLE_READCONSOLE_CONTROL is
struct_CONSOLE_READCONSOLE_CONTROL_ptr;
type struct_CONSOLE_SCREEN_BUFFER_INFOEX;
type struct_CONSOLE_SCREEN_BUFFER_INFOEX is record
cbSize : aliased windef.ULONG;
dwSize : aliased COORD;
dwCursorPosition : aliased COORD;
wAttributes : aliased windef.WORD;
srWindow : aliased SMALL_RECT;
dwMaximumWindowSize : aliased COORD;
wPopupAttributes : aliased windef.WORD;
bFullscreenSupported : aliased windef.BOOL;
ColorTable : aliased windef.COLORREF_array (0 .. 15);
end record;
pragma Convention (C_Pass_By_Copy, struct_CONSOLE_SCREEN_BUFFER_INFOEX);
type struct_CONSOLE_SCREEN_BUFFER_INFOEX_ptr is
access all struct_CONSOLE_SCREEN_BUFFER_INFOEX;
for struct_CONSOLE_SCREEN_BUFFER_INFOEX_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CONSOLE_SCREEN_BUFFER_INFOEX_ptr);
pragma Convention (C, struct_CONSOLE_SCREEN_BUFFER_INFOEX_ptr);
subtype CONSOLE_SCREEN_BUFFER_INFOEX is
struct_CONSOLE_SCREEN_BUFFER_INFOEX;
subtype PCONSOLE_SCREEN_BUFFER_INFOEX is
struct_CONSOLE_SCREEN_BUFFER_INFOEX_ptr;
function GetConsoleHistoryInfo (
lpConsoleHistoryInfo : access struct_CONSOLE_HISTORY_INFO)
return windef.WINBOOL;
pragma Import (C, GetConsoleHistoryInfo, "GetConsoleHistoryInfo");
function GetConsoleScreenBufferInfoEx (hConsoleOutput : winnt.HANDLE;
lpConsoleScreenBufferInfoEx :
access struct_CONSOLE_SCREEN_BUFFER_INFOEX)
return windef.WINBOOL;
pragma Import (C, GetConsoleScreenBufferInfoEx,
"GetConsoleScreenBufferInfoEx");
function GetCurrentConsoleFontEx (hConsoleOutput : winnt.HANDLE;
bMaximumWindow : windef.WINBOOL;
lpConsoleCurrentFontEx : access struct_CONSOLE_FONT_INFOEX)
return windef.WINBOOL;
pragma Import (C, GetCurrentConsoleFontEx, "GetCurrentConsoleFontEx");
function SetConsoleHistoryInfo (
lpConsoleHistoryInfo : access struct_CONSOLE_HISTORY_INFO)
return windef.WINBOOL;
pragma Import (C, SetConsoleHistoryInfo, "SetConsoleHistoryInfo");
function SetConsoleScreenBufferInfoEx (hConsoleOutput : winnt.HANDLE;
lpConsoleScreenBufferInfoEx :
access struct_CONSOLE_SCREEN_BUFFER_INFOEX)
return windef.WINBOOL;
pragma Import (C, SetConsoleScreenBufferInfoEx,
"SetConsoleScreenBufferInfoEx");
function SetCurrentConsoleFontEx (hConsoleOutput : winnt.HANDLE;
bMaximumWindow : windef.WINBOOL;
lpConsoleCurrentFontEx : access struct_CONSOLE_FONT_INFOEX)
return windef.WINBOOL;
pragma Import (C, SetCurrentConsoleFontEx, "SetCurrentConsoleFontEx");
ATTACH_PARENT_PROCESS : constant := 4294967295;
function AddConsoleAlias (Source : access winnt.WCHAR;
Target : access winnt.WCHAR; ExeName : access winnt.WCHAR)
return windef.WINBOOL renames AddConsoleAliasW;
BACKGROUND_BLUE : constant := 16;
BACKGROUND_GREEN : constant := 32;
BACKGROUND_INTENSITY : constant := 128;
BACKGROUND_RED : constant := 64;
CAPSLOCK_ON : constant := 128;
COMMON_LVB_GRID_HORIZONTAL : constant := 1024;
COMMON_LVB_GRID_LVERTICAL : constant := 2048;
COMMON_LVB_GRID_RVERTICAL : constant := 4096;
COMMON_LVB_LEADING_BYTE : constant := 256;
COMMON_LVB_REVERSE_VIDEO : constant := 16384;
COMMON_LVB_SBCSDBCS : constant := 768;
COMMON_LVB_TRAILING_BYTE : constant := 512;
COMMON_LVB_UNDERSCORE : constant := 32768;
CONSOLE_FULLSCREEN : constant := 1;
CONSOLE_FULLSCREEN_HARDWARE : constant := 2;
CONSOLE_FULLSCREEN_MODE : constant := 1;
CONSOLE_MOUSE_DOWN : constant := 8;
CONSOLE_MOUSE_SELECTION : constant := 4;
CONSOLE_NO_SELECTION : constant := 0;
CONSOLE_SELECTION_IN_PROGRESS : constant := 1;
CONSOLE_SELECTION_NOT_EMPTY : constant := 2;
CONSOLE_TEXTMODE_BUFFER : constant := 1;
CONSOLE_WINDOWED_MODE : constant := 2;
CTRL_BREAK_EVENT : constant := 1;
CTRL_CLOSE_EVENT : constant := 2;
CTRL_C_EVENT : constant := 0;
CTRL_LOGOFF_EVENT : constant := 5;
CTRL_SHUTDOWN_EVENT : constant := 6;
DOUBLE_CLICK : constant := 2;
ENABLE_AUTO_POSITION : constant := 256;
ENABLE_ECHO_INPUT : constant := 4;
ENABLE_EXTENDED_FLAGS : constant := 128;
ENABLE_INSERT_MODE : constant := 32;
ENABLE_LINE_INPUT : constant := 2;
ENABLE_MOUSE_INPUT : constant := 16;
ENABLE_PROCESSED_INPUT : constant := 1;
ENABLE_PROCESSED_OUTPUT : constant := 1;
ENABLE_QUICK_EDIT_MODE : constant := 64;
ENABLE_WINDOW_INPUT : constant := 8;
ENABLE_WRAP_AT_EOL_OUTPUT : constant := 2;
ENHANCED_KEY : constant := 256;
FOCUS_EVENT : constant := 16;
FOREGROUND_BLUE : constant := 1;
FOREGROUND_GREEN : constant := 2;
FOREGROUND_INTENSITY : constant := 8;
FOREGROUND_RED : constant := 4;
FROM_LEFT_1ST_BUTTON_PRESSED : constant := 1;
FROM_LEFT_2ND_BUTTON_PRESSED : constant := 4;
FROM_LEFT_3RD_BUTTON_PRESSED : constant := 8;
FROM_LEFT_4TH_BUTTON_PRESSED : constant := 16;
function FillConsoleOutputCharacter (hConsoleOutput : winnt.HANDLE;
cCharacter : winnt.WCHAR; nLength : windef.DWORD; dwWriteCoord : COORD;
lpNumberOfCharsWritten : access windef.DWORD) return windef.WINBOOL
renames FillConsoleOutputCharacterW;
function GetConsoleAlias (Source : access winnt.WCHAR;
TargetBuffer : access winnt.WCHAR; TargetBufferLength : windef.DWORD;
ExeName : access winnt.WCHAR) return windef.DWORD
renames GetConsoleAliasW;
function GetConsoleAliasExes (ExeNameBuffer : access winnt.WCHAR;
ExeNameBufferLength : windef.DWORD) return windef.DWORD
renames GetConsoleAliasExesW;
function GetConsoleAliasExesLength return windef.DWORD
renames GetConsoleAliasExesLengthW;
function GetConsoleAliases (AliasBuffer : access winnt.WCHAR;
AliasBufferLength : windef.DWORD; ExeName : access winnt.WCHAR)
return windef.DWORD renames GetConsoleAliasesW;
function GetConsoleAliasesLength (ExeName : access winnt.WCHAR)
return windef.DWORD renames GetConsoleAliasesLengthW;
function GetConsoleTitle (lpConsoleTitle : access winnt.WCHAR;
nSize : windef.DWORD) return windef.DWORD renames GetConsoleTitleW;
KEY_EVENT : constant := 1;
LEFT_ALT_PRESSED : constant := 2;
LEFT_CTRL_PRESSED : constant := 8;
MENU_EVENT : constant := 8;
MOUSE_EVENT : constant := 2;
MOUSE_MOVED : constant := 1;
MOUSE_WHEELED : constant := 4;
NLS_ALPHANUMERIC : constant := 0;
NLS_DBCSCHAR : constant := 65536;
NLS_HIRAGANA : constant := 262144;
NLS_IME_CONVERSION : constant := 8388608;
NLS_IME_DISABLE : constant := 536870912;
NLS_KATAKANA : constant := 131072;
NLS_ROMAN : constant := 4194304;
NUMLOCK_ON : constant := 32;
function PeekConsoleInput (hConsoleInput : winnt.HANDLE;
lpBuffer : access struct_INPUT_RECORD; nLength : windef.DWORD;
lpNumberOfEventsRead : access windef.DWORD) return windef.WINBOOL
renames PeekConsoleInputW;
RIGHTMOST_BUTTON_PRESSED : constant := 2;
RIGHT_ALT_PRESSED : constant := 1;
RIGHT_CTRL_PRESSED : constant := 4;
function ReadConsole (hConsoleInput : winnt.HANDLE;
lpBuffer : windef.LPVOID; nNumberOfCharsToRead : windef.DWORD;
lpNumberOfCharsRead : access windef.DWORD; lpReserved : windef.LPVOID)
return windef.WINBOOL renames ReadConsoleW;
function ReadConsoleInput (hConsoleInput : winnt.HANDLE;
lpBuffer : access struct_INPUT_RECORD; nLength : windef.DWORD;
lpNumberOfEventsRead : access windef.DWORD) return windef.WINBOOL
renames ReadConsoleInputW;
function ReadConsoleOutput (hConsoleOutput : winnt.HANDLE;
lpBuffer : access struct_CHAR_INFO; dwBufferSize : COORD;
dwBufferCoord : COORD; lpReadRegion : access struct_SMALL_RECT)
return windef.WINBOOL renames ReadConsoleOutputW;
function ReadConsoleOutputCharacter (hConsoleOutput : winnt.HANDLE;
lpCharacter : access winnt.WCHAR; nLength : windef.DWORD;
dwReadCoord : COORD; lpNumberOfCharsRead : access windef.DWORD)
return windef.WINBOOL renames ReadConsoleOutputCharacterW;
SCROLLLOCK_ON : constant := 64;
SHIFT_PRESSED : constant := 16;
function ScrollConsoleScreenBuffer (hConsoleOutput : winnt.HANDLE;
lpScrollRectangle : access constant SMALL_RECT;
lpClipRectangle : access constant SMALL_RECT;
dwDestinationOrigin : COORD; lpFill : access constant CHAR_INFO)
return windef.WINBOOL renames ScrollConsoleScreenBufferW;
function SetConsoleTitle (lpConsoleTitle : access constant winnt.WCHAR)
return windef.WINBOOL renames SetConsoleTitleW;
WINDOW_BUFFER_SIZE_EVENT : constant := 4;
function WriteConsole (hConsoleOutput : winnt.HANDLE;
lpBuffer : void_const_ptr; nNumberOfCharsToWrite : windef.DWORD;
lpNumberOfCharsWritten : access windef.DWORD;
lpReserved : windef.LPVOID) return windef.WINBOOL
renames WriteConsoleW;
function WriteConsoleInput (hConsoleInput : winnt.HANDLE;
lpBuffer : access constant INPUT_RECORD; nLength : windef.DWORD;
lpNumberOfEventsWritten : access windef.DWORD) return windef.WINBOOL
renames WriteConsoleInputW;
function WriteConsoleOutput (hConsoleOutput : winnt.HANDLE;
lpBuffer : access constant CHAR_INFO; dwBufferSize : COORD;
dwBufferCoord : COORD; lpWriteRegion : access struct_SMALL_RECT)
return windef.WINBOOL renames WriteConsoleOutputW;
function WriteConsoleOutputCharacter (hConsoleOutput : winnt.HANDLE;
lpCharacter : access constant winnt.WCHAR; nLength : windef.DWORD;
dwWriteCoord : COORD; lpNumberOfCharsWritten : access windef.DWORD)
return windef.WINBOOL renames WriteConsoleOutputCharacterW;
-- _WINCON_ (empty)
end C.wincon;
Raw
c-wincrypt.ads
This file has been truncated, but you can view the full file.
-- This file is translated by "headmaster" version 0.27-2060155 (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
with Ada.Unchecked_Conversion;
with C.basetsd;
with C.guiddef;
with C.qmingw;
with C.winbase;
with C.windef;
with C.winnt;
package C.wincrypt is
pragma Preelaborate;
function Cast is new Ada.Unchecked_Conversion (void_ptr, void_ptr);
function Cast is new Ada.Unchecked_Conversion (signed_long_long,
winnt.C_CHAR_const_ptr);
subtype ALG_ID is unsigned_int;
subtype HCRYPTKEY is basetsd.ULONG_PTR;
subtype HCRYPTKEY_ptr is basetsd.ULONG_PTR_ptr;
subtype HCRYPTPROV is basetsd.ULONG_PTR;
subtype HCRYPTPROV_ptr is basetsd.ULONG_PTR_ptr;
subtype HCRYPTHASH is basetsd.ULONG_PTR;
subtype HCRYPTHASH_ptr is basetsd.ULONG_PTR_ptr;
type struct_CMS_KEY_INFO;
type struct_CMS_KEY_INFO is record
dwVersion : aliased windef.DWORD;
Algid : aliased ALG_ID;
pbOID : aliased windef.BYTE_ptr;
cbOID : aliased windef.DWORD;
end record;
pragma Convention (C_Pass_By_Copy, struct_CMS_KEY_INFO);
type struct_CMS_KEY_INFO_ptr is access all struct_CMS_KEY_INFO;
for struct_CMS_KEY_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CMS_KEY_INFO_ptr);
pragma Convention (C, struct_CMS_KEY_INFO_ptr);
subtype CMS_KEY_INFO is struct_CMS_KEY_INFO;
subtype PCMS_KEY_INFO is struct_CMS_KEY_INFO_ptr;
type struct_HMAC_Info;
type struct_HMAC_Info is record
HashAlgid : aliased ALG_ID;
pbInnerString : aliased windef.BYTE_ptr;
cbInnerString : aliased windef.DWORD;
pbOuterString : aliased windef.BYTE_ptr;
cbOuterString : aliased windef.DWORD;
end record;
pragma Convention (C_Pass_By_Copy, struct_HMAC_Info);
type struct_HMAC_Info_ptr is access all struct_HMAC_Info;
for struct_HMAC_Info_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_HMAC_Info_ptr);
pragma Convention (C, struct_HMAC_Info_ptr);
subtype HMAC_INFO is struct_HMAC_Info;
subtype PHMAC_INFO is struct_HMAC_Info_ptr;
type struct_SCHANNEL_ALG;
type struct_SCHANNEL_ALG is record
dwUse : aliased windef.DWORD;
Algid : aliased ALG_ID;
cBits : aliased windef.DWORD;
dwFlags : aliased windef.DWORD;
dwReserved : aliased windef.DWORD;
end record;
pragma Convention (C_Pass_By_Copy, struct_SCHANNEL_ALG);
type struct_SCHANNEL_ALG_ptr is access all struct_SCHANNEL_ALG;
for struct_SCHANNEL_ALG_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_SCHANNEL_ALG_ptr);
pragma Convention (C, struct_SCHANNEL_ALG_ptr);
subtype SCHANNEL_ALG is struct_SCHANNEL_ALG;
subtype PSCHANNEL_ALG is struct_SCHANNEL_ALG_ptr;
type struct_PROV_ENUMALGS;
type struct_PROV_ENUMALGS is record
aiAlgid : aliased ALG_ID;
dwBitLen : aliased windef.DWORD;
dwNameLen : aliased windef.DWORD;
szName : aliased winnt.C_CHAR_array (0 .. 19);
end record;
pragma Convention (C_Pass_By_Copy, struct_PROV_ENUMALGS);
subtype PROV_ENUMALGS is struct_PROV_ENUMALGS;
type struct_PROV_ENUMALGS_EX;
type struct_PROV_ENUMALGS_EX is record
aiAlgid : aliased ALG_ID;
dwDefaultLen : aliased windef.DWORD;
dwMinLen : aliased windef.DWORD;
dwMaxLen : aliased windef.DWORD;
dwProtocols : aliased windef.DWORD;
dwNameLen : aliased windef.DWORD;
szName : aliased winnt.C_CHAR_array (0 .. 19);
dwLongNameLen : aliased windef.DWORD;
szLongName : aliased winnt.C_CHAR_array (0 .. 39);
end record;
pragma Convention (C_Pass_By_Copy, struct_PROV_ENUMALGS_EX);
subtype PROV_ENUMALGS_EX is struct_PROV_ENUMALGS_EX;
type struct_PUBLICKEYSTRUC;
type struct_PUBLICKEYSTRUC is record
bType : aliased windef.BYTE;
bVersion : aliased windef.BYTE;
reserved : aliased windef.WORD;
aiKeyAlg : aliased ALG_ID;
end record;
pragma Convention (C_Pass_By_Copy, struct_PUBLICKEYSTRUC);
type struct_PUBLICKEYSTRUC_const_ptr is
access constant struct_PUBLICKEYSTRUC;
for struct_PUBLICKEYSTRUC_const_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_PUBLICKEYSTRUC_const_ptr);
pragma Convention (C, struct_PUBLICKEYSTRUC_const_ptr);
subtype BLOBHEADER is struct_PUBLICKEYSTRUC;
subtype PUBLICKEYSTRUC is struct_PUBLICKEYSTRUC;
subtype PUBLICKEYSTRUC_const_ptr is struct_PUBLICKEYSTRUC_const_ptr;
type struct_RSAPUBKEY;
type struct_RSAPUBKEY is record
magic : aliased windef.DWORD;
bitlen : aliased windef.DWORD;
pubexp : aliased windef.DWORD;
end record;
pragma Convention (C_Pass_By_Copy, struct_RSAPUBKEY);
subtype RSAPUBKEY is struct_RSAPUBKEY;
type struct_PUBKEY;
type struct_PUBKEY is record
magic : aliased windef.DWORD;
bitlen : aliased windef.DWORD;
end record;
pragma Convention (C_Pass_By_Copy, struct_PUBKEY);
subtype DHPUBKEY is struct_PUBKEY;
subtype DSSPUBKEY is struct_PUBKEY;
subtype KEAPUBKEY is struct_PUBKEY;
subtype TEKPUBKEY is struct_PUBKEY;
type struct_DSSSEED;
type struct_DSSSEED is record
counter : aliased windef.DWORD;
seed : aliased windef.BYTE_array (0 .. 19);
end record;
pragma Convention (C_Pass_By_Copy, struct_DSSSEED);
subtype DSSSEED is struct_DSSSEED;
type struct_PUBKEYVER3;
type struct_PUBKEYVER3 is record
magic : aliased windef.DWORD;
bitlenP : aliased windef.DWORD;
bitlenQ : aliased windef.DWORD;
bitlenJ : aliased windef.DWORD;
DSSSeed : aliased wincrypt.DSSSEED;
end record;
pragma Convention (C_Pass_By_Copy, struct_PUBKEYVER3);
subtype DHPUBKEY_VER3 is struct_PUBKEYVER3;
subtype DSSPUBKEY_VER3 is struct_PUBKEYVER3;
type struct_PRIVKEYVER3;
type struct_PRIVKEYVER3 is record
magic : aliased windef.DWORD;
bitlenP : aliased windef.DWORD;
bitlenQ : aliased windef.DWORD;
bitlenJ : aliased windef.DWORD;
bitlenX : aliased windef.DWORD;
DSSSeed : aliased wincrypt.DSSSEED;
end record;
pragma Convention (C_Pass_By_Copy, struct_PRIVKEYVER3);
subtype DHPRIVKEY_VER3 is struct_PRIVKEYVER3;
subtype DSSPRIVKEY_VER3 is struct_PRIVKEYVER3;
type struct_KEY_TYPE_SUBTYPE;
type struct_KEY_TYPE_SUBTYPE is record
dwKeySpec : aliased windef.DWORD;
F_Type : aliased guiddef.GUID;
F_Subtype : aliased guiddef.GUID;
end record;
pragma Convention (C_Pass_By_Copy, struct_KEY_TYPE_SUBTYPE);
type struct_KEY_TYPE_SUBTYPE_ptr is access all struct_KEY_TYPE_SUBTYPE;
for struct_KEY_TYPE_SUBTYPE_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_KEY_TYPE_SUBTYPE_ptr);
pragma Convention (C, struct_KEY_TYPE_SUBTYPE_ptr);
subtype KEY_TYPE_SUBTYPE is struct_KEY_TYPE_SUBTYPE;
subtype PKEY_TYPE_SUBTYPE is struct_KEY_TYPE_SUBTYPE_ptr;
type struct_CERT_FORTEZZA_DATA_PROP;
type struct_CERT_FORTEZZA_DATA_PROP is record
SerialNumber : aliased unsigned_char_array (0 .. 7);
CertIndex : aliased signed_int;
CertLabel : aliased unsigned_char_array (0 .. 35);
end record;
pragma Convention (C_Pass_By_Copy, struct_CERT_FORTEZZA_DATA_PROP);
subtype CERT_FORTEZZA_DATA_PROP is struct_CERT_FORTEZZA_DATA_PROP;
type struct_CRYPT_RC4_KEY_STATE;
type struct_CRYPT_RC4_KEY_STATE is record
Key : aliased unsigned_char_array (0 .. 15);
SBox : aliased unsigned_char_array (0 .. 255);
i : aliased unsigned_char;
j : aliased unsigned_char;
end record;
pragma Convention (C_Pass_By_Copy, struct_CRYPT_RC4_KEY_STATE);
type struct_CRYPT_RC4_KEY_STATE_ptr is
access all struct_CRYPT_RC4_KEY_STATE;
for struct_CRYPT_RC4_KEY_STATE_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_RC4_KEY_STATE_ptr);
pragma Convention (C, struct_CRYPT_RC4_KEY_STATE_ptr);
subtype CRYPT_RC4_KEY_STATE is struct_CRYPT_RC4_KEY_STATE;
subtype PCRYPT_RC4_KEY_STATE is struct_CRYPT_RC4_KEY_STATE_ptr;
type struct_CRYPT_DES_KEY_STATE;
type struct_CRYPT_DES_KEY_STATE is record
Key : aliased unsigned_char_array (0 .. 7);
IV : aliased unsigned_char_array (0 .. 7);
Feedback : aliased unsigned_char_array (0 .. 7);
end record;
pragma Convention (C_Pass_By_Copy, struct_CRYPT_DES_KEY_STATE);
type struct_CRYPT_DES_KEY_STATE_ptr is
access all struct_CRYPT_DES_KEY_STATE;
for struct_CRYPT_DES_KEY_STATE_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_DES_KEY_STATE_ptr);
pragma Convention (C, struct_CRYPT_DES_KEY_STATE_ptr);
subtype CRYPT_DES_KEY_STATE is struct_CRYPT_DES_KEY_STATE;
subtype PCRYPT_DES_KEY_STATE is struct_CRYPT_DES_KEY_STATE_ptr;
type struct_CRYPT_3DES_KEY_STATE;
type struct_CRYPT_3DES_KEY_STATE is record
Key : aliased unsigned_char_array (0 .. 23);
IV : aliased unsigned_char_array (0 .. 7);
Feedback : aliased unsigned_char_array (0 .. 7);
end record;
pragma Convention (C_Pass_By_Copy, struct_CRYPT_3DES_KEY_STATE);
type struct_CRYPT_3DES_KEY_STATE_ptr is
access all struct_CRYPT_3DES_KEY_STATE;
for struct_CRYPT_3DES_KEY_STATE_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_3DES_KEY_STATE_ptr);
pragma Convention (C, struct_CRYPT_3DES_KEY_STATE_ptr);
subtype CRYPT_3DES_KEY_STATE is struct_CRYPT_3DES_KEY_STATE;
subtype PCRYPT_3DES_KEY_STATE is struct_CRYPT_3DES_KEY_STATE_ptr;
type struct_CRYPTOAPI_BLOB;
type struct_CRYPTOAPI_BLOB is record
cbData : aliased windef.DWORD;
pbData : aliased windef.BYTE_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_CRYPTOAPI_BLOB);
type struct_CRYPTOAPI_BLOB_ptr is access all struct_CRYPTOAPI_BLOB;
for struct_CRYPTOAPI_BLOB_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPTOAPI_BLOB_ptr);
pragma Convention (C, struct_CRYPTOAPI_BLOB_ptr);
type struct_CRYPTOAPI_BLOB_const_ptr is
access constant struct_CRYPTOAPI_BLOB;
for struct_CRYPTOAPI_BLOB_const_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPTOAPI_BLOB_const_ptr);
pragma Convention (C, struct_CRYPTOAPI_BLOB_const_ptr);
subtype CRYPT_INTEGER_BLOB is struct_CRYPTOAPI_BLOB;
subtype PCRYPT_INTEGER_BLOB is struct_CRYPTOAPI_BLOB_ptr;
subtype CRYPT_UINT_BLOB is struct_CRYPTOAPI_BLOB;
subtype PCRYPT_UINT_BLOB is struct_CRYPTOAPI_BLOB_ptr;
subtype CRYPT_OBJID_BLOB is struct_CRYPTOAPI_BLOB;
subtype PCRYPT_OBJID_BLOB is struct_CRYPTOAPI_BLOB_ptr;
subtype CERT_NAME_BLOB is struct_CRYPTOAPI_BLOB;
subtype CERT_NAME_BLOB_ptr is struct_CRYPTOAPI_BLOB_ptr;
subtype PCERT_NAME_BLOB is struct_CRYPTOAPI_BLOB_ptr;
subtype CERT_RDN_VALUE_BLOB is struct_CRYPTOAPI_BLOB;
subtype PCERT_RDN_VALUE_BLOB is struct_CRYPTOAPI_BLOB_ptr;
subtype CERT_BLOB is struct_CRYPTOAPI_BLOB;
subtype PCERT_BLOB is struct_CRYPTOAPI_BLOB_ptr;
subtype CRL_BLOB is struct_CRYPTOAPI_BLOB;
subtype PCRL_BLOB is struct_CRYPTOAPI_BLOB_ptr;
subtype DATA_BLOB is struct_CRYPTOAPI_BLOB;
subtype DATA_BLOB_ptr is struct_CRYPTOAPI_BLOB_ptr;
subtype PDATA_BLOB is struct_CRYPTOAPI_BLOB_ptr;
subtype CRYPT_DATA_BLOB is struct_CRYPTOAPI_BLOB;
subtype CRYPT_DATA_BLOB_ptr is struct_CRYPTOAPI_BLOB_ptr;
subtype PCRYPT_DATA_BLOB is struct_CRYPTOAPI_BLOB_ptr;
subtype CRYPT_HASH_BLOB is struct_CRYPTOAPI_BLOB;
subtype CRYPT_HASH_BLOB_const_ptr is struct_CRYPTOAPI_BLOB_const_ptr;
subtype PCRYPT_HASH_BLOB is struct_CRYPTOAPI_BLOB_ptr;
subtype CRYPT_DIGEST_BLOB is struct_CRYPTOAPI_BLOB;
subtype PCRYPT_DIGEST_BLOB is struct_CRYPTOAPI_BLOB_ptr;
subtype CRYPT_DER_BLOB is struct_CRYPTOAPI_BLOB;
subtype PCRYPT_DER_BLOB is struct_CRYPTOAPI_BLOB_ptr;
subtype CRYPT_ATTR_BLOB is struct_CRYPTOAPI_BLOB;
subtype PCRYPT_ATTR_BLOB is struct_CRYPTOAPI_BLOB_ptr;
type struct_CMS_DH_KEY_INFO;
type struct_CMS_DH_KEY_INFO is record
dwVersion : aliased windef.DWORD;
Algid : aliased ALG_ID;
pszContentEncObjId : aliased winnt.LPSTR;
PubInfo : aliased CRYPT_DATA_BLOB;
pReserved : aliased void_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_CMS_DH_KEY_INFO);
type struct_CMS_DH_KEY_INFO_ptr is access all struct_CMS_DH_KEY_INFO;
for struct_CMS_DH_KEY_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CMS_DH_KEY_INFO_ptr);
pragma Convention (C, struct_CMS_DH_KEY_INFO_ptr);
subtype CMS_DH_KEY_INFO is struct_CMS_DH_KEY_INFO;
subtype PCMS_DH_KEY_INFO is struct_CMS_DH_KEY_INFO_ptr;
function CryptAcquireContextA (phProv : access HCRYPTPROV;
szContainer : access constant winnt.C_CHAR;
szProvider : access constant winnt.C_CHAR; dwProvType : windef.DWORD;
dwFlags : windef.DWORD) return windef.WINBOOL;
pragma Import (C, CryptAcquireContextA, "CryptAcquireContextA");
function CryptAcquireContextW (phProv : access HCRYPTPROV;
szContainer : access constant winnt.WCHAR;
szProvider : access constant winnt.WCHAR; dwProvType : windef.DWORD;
dwFlags : windef.DWORD) return windef.WINBOOL;
pragma Import (C, CryptAcquireContextW, "CryptAcquireContextW");
function CryptReleaseContext (hProv : HCRYPTPROV; dwFlags : windef.DWORD)
return windef.WINBOOL;
pragma Import (C, CryptReleaseContext, "CryptReleaseContext");
function CryptGenKey (hProv : HCRYPTPROV; Algid : ALG_ID;
dwFlags : windef.DWORD; phKey : access HCRYPTKEY)
return windef.WINBOOL;
pragma Import (C, CryptGenKey, "CryptGenKey");
function CryptDeriveKey (hProv : HCRYPTPROV; Algid : ALG_ID;
hBaseData : HCRYPTHASH; dwFlags : windef.DWORD;
phKey : access HCRYPTKEY) return windef.WINBOOL;
pragma Import (C, CryptDeriveKey, "CryptDeriveKey");
function CryptDestroyKey (hKey : HCRYPTKEY) return windef.WINBOOL;
pragma Import (C, CryptDestroyKey, "CryptDestroyKey");
function CryptSetKeyParam (hKey : HCRYPTKEY; dwParam : windef.DWORD;
pbData : access constant windef.BYTE; dwFlags : windef.DWORD)
return windef.WINBOOL;
pragma Import (C, CryptSetKeyParam, "CryptSetKeyParam");
function CryptGetKeyParam (hKey : HCRYPTKEY; dwParam : windef.DWORD;
pbData : access windef.BYTE; pdwDataLen : access windef.DWORD;
dwFlags : windef.DWORD) return windef.WINBOOL;
pragma Import (C, CryptGetKeyParam, "CryptGetKeyParam");
function CryptSetHashParam (hHash : HCRYPTHASH; dwParam : windef.DWORD;
pbData : access constant windef.BYTE; dwFlags : windef.DWORD)
return windef.WINBOOL;
pragma Import (C, CryptSetHashParam, "CryptSetHashParam");
function CryptGetHashParam (hHash : HCRYPTHASH; dwParam : windef.DWORD;
pbData : access windef.BYTE; pdwDataLen : access windef.DWORD;
dwFlags : windef.DWORD) return windef.WINBOOL;
pragma Import (C, CryptGetHashParam, "CryptGetHashParam");
function CryptSetProvParam (hProv : HCRYPTPROV; dwParam : windef.DWORD;
pbData : access constant windef.BYTE; dwFlags : windef.DWORD)
return windef.WINBOOL;
pragma Import (C, CryptSetProvParam, "CryptSetProvParam");
function CryptGetProvParam (hProv : HCRYPTPROV; dwParam : windef.DWORD;
pbData : access windef.BYTE; pdwDataLen : access windef.DWORD;
dwFlags : windef.DWORD) return windef.WINBOOL;
pragma Import (C, CryptGetProvParam, "CryptGetProvParam");
function CryptGenRandom (hProv : HCRYPTPROV; dwLen : windef.DWORD;
pbBuffer : access windef.BYTE) return windef.WINBOOL;
pragma Import (C, CryptGenRandom, "CryptGenRandom");
function CryptGetUserKey (hProv : HCRYPTPROV; dwKeySpec : windef.DWORD;
phUserKey : access HCRYPTKEY) return windef.WINBOOL;
pragma Import (C, CryptGetUserKey, "CryptGetUserKey");
function CryptExportKey (hKey : HCRYPTKEY; hExpKey : HCRYPTKEY;
dwBlobType : windef.DWORD; dwFlags : windef.DWORD;
pbData : access windef.BYTE; pdwDataLen : access windef.DWORD)
return windef.WINBOOL;
pragma Import (C, CryptExportKey, "CryptExportKey");
function CryptImportKey (hProv : HCRYPTPROV;
pbData : access constant windef.BYTE; dwDataLen : windef.DWORD;
hPubKey : HCRYPTKEY; dwFlags : windef.DWORD; phKey : access HCRYPTKEY)
return windef.WINBOOL;
pragma Import (C, CryptImportKey, "CryptImportKey");
function CryptEncrypt (hKey : HCRYPTKEY; hHash : HCRYPTHASH;
Final : windef.WINBOOL; dwFlags : windef.DWORD;
pbData : access windef.BYTE; pdwDataLen : access windef.DWORD;
dwBufLen : windef.DWORD) return windef.WINBOOL;
pragma Import (C, CryptEncrypt, "CryptEncrypt");
function CryptDecrypt (hKey : HCRYPTKEY; hHash : HCRYPTHASH;
Final : windef.WINBOOL; dwFlags : windef.DWORD;
pbData : access windef.BYTE; pdwDataLen : access windef.DWORD)
return windef.WINBOOL;
pragma Import (C, CryptDecrypt, "CryptDecrypt");
function CryptCreateHash (hProv : HCRYPTPROV; Algid : ALG_ID;
hKey : HCRYPTKEY; dwFlags : windef.DWORD; phHash : access HCRYPTHASH)
return windef.WINBOOL;
pragma Import (C, CryptCreateHash, "CryptCreateHash");
function CryptHashData (hHash : HCRYPTHASH;
pbData : access constant windef.BYTE; dwDataLen : windef.DWORD;
dwFlags : windef.DWORD) return windef.WINBOOL;
pragma Import (C, CryptHashData, "CryptHashData");
function CryptHashSessionKey (hHash : HCRYPTHASH; hKey : HCRYPTKEY;
dwFlags : windef.DWORD) return windef.WINBOOL;
pragma Import (C, CryptHashSessionKey, "CryptHashSessionKey");
function CryptDestroyHash (hHash : HCRYPTHASH) return windef.WINBOOL;
pragma Import (C, CryptDestroyHash, "CryptDestroyHash");
function CryptSignHashA (hHash : HCRYPTHASH; dwKeySpec : windef.DWORD;
szDescription : access constant winnt.C_CHAR; dwFlags : windef.DWORD;
pbSignature : access windef.BYTE; pdwSigLen : access windef.DWORD)
return windef.WINBOOL;
pragma Import (C, CryptSignHashA, "CryptSignHashA");
function CryptSignHashW (hHash : HCRYPTHASH; dwKeySpec : windef.DWORD;
szDescription : access constant winnt.WCHAR; dwFlags : windef.DWORD;
pbSignature : access windef.BYTE; pdwSigLen : access windef.DWORD)
return windef.WINBOOL;
pragma Import (C, CryptSignHashW, "CryptSignHashW");
function CryptVerifySignatureA (hHash : HCRYPTHASH;
pbSignature : access constant windef.BYTE; dwSigLen : windef.DWORD;
hPubKey : HCRYPTKEY; szDescription : access constant winnt.C_CHAR;
dwFlags : windef.DWORD) return windef.WINBOOL;
pragma Import (C, CryptVerifySignatureA, "CryptVerifySignatureA");
function CryptVerifySignatureW (hHash : HCRYPTHASH;
pbSignature : access constant windef.BYTE; dwSigLen : windef.DWORD;
hPubKey : HCRYPTKEY; szDescription : access constant winnt.WCHAR;
dwFlags : windef.DWORD) return windef.WINBOOL;
pragma Import (C, CryptVerifySignatureW, "CryptVerifySignatureW");
function CryptSetProviderA (pszProvName : access constant winnt.C_CHAR;
dwProvType : windef.DWORD) return windef.WINBOOL;
pragma Import (C, CryptSetProviderA, "CryptSetProviderA");
function CryptSetProviderW (pszProvName : access constant winnt.WCHAR;
dwProvType : windef.DWORD) return windef.WINBOOL;
pragma Import (C, CryptSetProviderW, "CryptSetProviderW");
function CryptSetProviderExA (pszProvName : access constant winnt.C_CHAR;
dwProvType : windef.DWORD; pdwReserved : access windef.DWORD;
dwFlags : windef.DWORD) return windef.WINBOOL;
pragma Import (C, CryptSetProviderExA, "CryptSetProviderExA");
function CryptSetProviderExW (pszProvName : access constant winnt.WCHAR;
dwProvType : windef.DWORD; pdwReserved : access windef.DWORD;
dwFlags : windef.DWORD) return windef.WINBOOL;
pragma Import (C, CryptSetProviderExW, "CryptSetProviderExW");
function CryptGetDefaultProviderA (dwProvType : windef.DWORD;
pdwReserved : access windef.DWORD; dwFlags : windef.DWORD;
pszProvName : access winnt.C_CHAR; pcbProvName : access windef.DWORD)
return windef.WINBOOL;
pragma Import (C, CryptGetDefaultProviderA, "CryptGetDefaultProviderA");
function CryptGetDefaultProviderW (dwProvType : windef.DWORD;
pdwReserved : access windef.DWORD; dwFlags : windef.DWORD;
pszProvName : access winnt.WCHAR; pcbProvName : access windef.DWORD)
return windef.WINBOOL;
pragma Import (C, CryptGetDefaultProviderW, "CryptGetDefaultProviderW");
function CryptEnumProviderTypesA (dwIndex : windef.DWORD;
pdwReserved : access windef.DWORD; dwFlags : windef.DWORD;
pdwProvType : access windef.DWORD; szTypeName : access winnt.C_CHAR;
pcbTypeName : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, CryptEnumProviderTypesA, "CryptEnumProviderTypesA");
function CryptEnumProviderTypesW (dwIndex : windef.DWORD;
pdwReserved : access windef.DWORD; dwFlags : windef.DWORD;
pdwProvType : access windef.DWORD; szTypeName : access winnt.WCHAR;
pcbTypeName : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, CryptEnumProviderTypesW, "CryptEnumProviderTypesW");
function CryptEnumProvidersA (dwIndex : windef.DWORD;
pdwReserved : access windef.DWORD; dwFlags : windef.DWORD;
pdwProvType : access windef.DWORD; szProvName : access winnt.C_CHAR;
pcbProvName : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, CryptEnumProvidersA, "CryptEnumProvidersA");
function CryptEnumProvidersW (dwIndex : windef.DWORD;
pdwReserved : access windef.DWORD; dwFlags : windef.DWORD;
pdwProvType : access windef.DWORD; szProvName : access winnt.WCHAR;
pcbProvName : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, CryptEnumProvidersW, "CryptEnumProvidersW");
function CryptContextAddRef (hProv : HCRYPTPROV;
pdwReserved : access windef.DWORD; dwFlags : windef.DWORD)
return windef.WINBOOL;
pragma Import (C, CryptContextAddRef, "CryptContextAddRef");
function CryptDuplicateKey (hKey : HCRYPTKEY;
pdwReserved : access windef.DWORD; dwFlags : windef.DWORD;
phKey : access HCRYPTKEY) return windef.WINBOOL;
pragma Import (C, CryptDuplicateKey, "CryptDuplicateKey");
function CryptDuplicateHash (hHash : HCRYPTHASH;
pdwReserved : access windef.DWORD; dwFlags : windef.DWORD;
phHash : access HCRYPTHASH) return windef.WINBOOL;
pragma Import (C, CryptDuplicateHash, "CryptDuplicateHash");
function GetEncSChannel (pData : access windef.BYTE_ptr;
dwDecSize : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, GetEncSChannel, "GetEncSChannel");
type struct_CRYPT_BIT_BLOB;
type struct_CRYPT_BIT_BLOB is record
cbData : aliased windef.DWORD;
pbData : aliased windef.BYTE_ptr;
cUnusedBits : aliased windef.DWORD;
end record;
pragma Convention (C_Pass_By_Copy, struct_CRYPT_BIT_BLOB);
type struct_CRYPT_BIT_BLOB_ptr is access all struct_CRYPT_BIT_BLOB;
for struct_CRYPT_BIT_BLOB_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_BIT_BLOB_ptr);
pragma Convention (C, struct_CRYPT_BIT_BLOB_ptr);
subtype CRYPT_BIT_BLOB is struct_CRYPT_BIT_BLOB;
subtype PCRYPT_BIT_BLOB is struct_CRYPT_BIT_BLOB_ptr;
type struct_CRYPT_ALGORITHM_IDENTIFIER;
type struct_CRYPT_ALGORITHM_IDENTIFIER is record
pszObjId : aliased winnt.LPSTR;
Parameters : aliased CRYPT_OBJID_BLOB;
end record;
pragma Convention (C_Pass_By_Copy, struct_CRYPT_ALGORITHM_IDENTIFIER);
type struct_CRYPT_ALGORITHM_IDENTIFIER_ptr is
access all struct_CRYPT_ALGORITHM_IDENTIFIER;
for struct_CRYPT_ALGORITHM_IDENTIFIER_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_ALGORITHM_IDENTIFIER_ptr);
pragma Convention (C, struct_CRYPT_ALGORITHM_IDENTIFIER_ptr);
subtype CRYPT_ALGORITHM_IDENTIFIER is struct_CRYPT_ALGORITHM_IDENTIFIER;
subtype CRYPT_ALGORITHM_IDENTIFIER_ptr is
struct_CRYPT_ALGORITHM_IDENTIFIER_ptr;
subtype PCRYPT_ALGORITHM_IDENTIFIER is
struct_CRYPT_ALGORITHM_IDENTIFIER_ptr;
type struct_CRYPT_OBJID_TABLE;
type struct_CRYPT_OBJID_TABLE is record
dwAlgId : aliased windef.DWORD;
pszObjId : aliased winnt.LPCSTR;
end record;
pragma Convention (C_Pass_By_Copy, struct_CRYPT_OBJID_TABLE);
type struct_CRYPT_OBJID_TABLE_ptr is access all struct_CRYPT_OBJID_TABLE;
for struct_CRYPT_OBJID_TABLE_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_OBJID_TABLE_ptr);
pragma Convention (C, struct_CRYPT_OBJID_TABLE_ptr);
subtype CRYPT_OBJID_TABLE is struct_CRYPT_OBJID_TABLE;
subtype PCRYPT_OBJID_TABLE is struct_CRYPT_OBJID_TABLE_ptr;
type struct_CRYPT_HASH_INFO;
type struct_CRYPT_HASH_INFO is record
HashAlgorithm : aliased CRYPT_ALGORITHM_IDENTIFIER;
Hash : aliased CRYPT_HASH_BLOB;
end record;
pragma Convention (C_Pass_By_Copy, struct_CRYPT_HASH_INFO);
type struct_CRYPT_HASH_INFO_ptr is access all struct_CRYPT_HASH_INFO;
for struct_CRYPT_HASH_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_HASH_INFO_ptr);
pragma Convention (C, struct_CRYPT_HASH_INFO_ptr);
subtype CRYPT_HASH_INFO is struct_CRYPT_HASH_INFO;
subtype PCRYPT_HASH_INFO is struct_CRYPT_HASH_INFO_ptr;
type struct_CERT_EXTENSION;
type struct_CERT_EXTENSION is record
pszObjId : aliased winnt.LPSTR;
fCritical : aliased windef.WINBOOL;
Value : aliased CRYPT_OBJID_BLOB;
end record;
pragma Convention (C_Pass_By_Copy, struct_CERT_EXTENSION);
type struct_CERT_EXTENSION_ptr is access all struct_CERT_EXTENSION;
for struct_CERT_EXTENSION_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_EXTENSION_ptr);
pragma Convention (C, struct_CERT_EXTENSION_ptr);
type struct_CERT_EXTENSION_array is array (size_t range <>) of
aliased struct_CERT_EXTENSION;
pragma Convention (C, struct_CERT_EXTENSION_array);
subtype CERT_EXTENSION is struct_CERT_EXTENSION;
subtype CERT_EXTENSION_array is struct_CERT_EXTENSION_array;
subtype CERT_EXTENSION_ptr is struct_CERT_EXTENSION_ptr;
subtype PCERT_EXTENSION is struct_CERT_EXTENSION_ptr;
type struct_CRYPT_ATTRIBUTE_TYPE_VALUE;
type struct_CRYPT_ATTRIBUTE_TYPE_VALUE is record
pszObjId : aliased winnt.LPSTR;
Value : aliased CRYPT_OBJID_BLOB;
end record;
pragma Convention (C_Pass_By_Copy, struct_CRYPT_ATTRIBUTE_TYPE_VALUE);
type struct_CRYPT_ATTRIBUTE_TYPE_VALUE_ptr is
access all struct_CRYPT_ATTRIBUTE_TYPE_VALUE;
for struct_CRYPT_ATTRIBUTE_TYPE_VALUE_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_ATTRIBUTE_TYPE_VALUE_ptr);
pragma Convention (C, struct_CRYPT_ATTRIBUTE_TYPE_VALUE_ptr);
subtype CRYPT_ATTRIBUTE_TYPE_VALUE is struct_CRYPT_ATTRIBUTE_TYPE_VALUE;
subtype PCRYPT_ATTRIBUTE_TYPE_VALUE is
struct_CRYPT_ATTRIBUTE_TYPE_VALUE_ptr;
type struct_CRYPT_ATTRIBUTE;
type struct_CRYPT_ATTRIBUTE is record
pszObjId : aliased winnt.LPSTR;
cValue : aliased windef.DWORD;
rgValue : aliased PCRYPT_ATTR_BLOB;
end record;
pragma Convention (C_Pass_By_Copy, struct_CRYPT_ATTRIBUTE);
type struct_CRYPT_ATTRIBUTE_ptr is access all struct_CRYPT_ATTRIBUTE;
for struct_CRYPT_ATTRIBUTE_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_ATTRIBUTE_ptr);
pragma Convention (C, struct_CRYPT_ATTRIBUTE_ptr);
type struct_CRYPT_ATTRIBUTE_array is array (size_t range <>) of
aliased struct_CRYPT_ATTRIBUTE;
pragma Convention (C, struct_CRYPT_ATTRIBUTE_array);
subtype CRYPT_ATTRIBUTE is struct_CRYPT_ATTRIBUTE;
subtype CRYPT_ATTRIBUTE_array is struct_CRYPT_ATTRIBUTE_array;
subtype CRYPT_ATTRIBUTE_ptr is struct_CRYPT_ATTRIBUTE_ptr;
subtype PCRYPT_ATTRIBUTE is struct_CRYPT_ATTRIBUTE_ptr;
type struct_CRYPT_ATTRIBUTES;
type struct_CRYPT_ATTRIBUTES is record
cAttr : aliased windef.DWORD;
rgAttr : aliased PCRYPT_ATTRIBUTE;
end record;
pragma Convention (C_Pass_By_Copy, struct_CRYPT_ATTRIBUTES);
type struct_CRYPT_ATTRIBUTES_ptr is access all struct_CRYPT_ATTRIBUTES;
for struct_CRYPT_ATTRIBUTES_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_ATTRIBUTES_ptr);
pragma Convention (C, struct_CRYPT_ATTRIBUTES_ptr);
subtype CRYPT_ATTRIBUTES is struct_CRYPT_ATTRIBUTES;
subtype CRYPT_ATTRIBUTES_ptr is struct_CRYPT_ATTRIBUTES_ptr;
subtype PCRYPT_ATTRIBUTES is struct_CRYPT_ATTRIBUTES_ptr;
type struct_CERT_RDN_ATTR;
type struct_CERT_RDN_ATTR is record
pszObjId : aliased winnt.LPSTR;
dwValueType : aliased windef.DWORD;
Value : aliased CERT_RDN_VALUE_BLOB;
end record;
pragma Convention (C_Pass_By_Copy, struct_CERT_RDN_ATTR);
type struct_CERT_RDN_ATTR_ptr is access all struct_CERT_RDN_ATTR;
for struct_CERT_RDN_ATTR_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_RDN_ATTR_ptr);
pragma Convention (C, struct_CERT_RDN_ATTR_ptr);
subtype CERT_RDN_ATTR is struct_CERT_RDN_ATTR;
subtype PCERT_RDN_ATTR is struct_CERT_RDN_ATTR_ptr;
type struct_CERT_RDN;
type struct_CERT_RDN is record
cRDNAttr : aliased windef.DWORD;
rgRDNAttr : aliased PCERT_RDN_ATTR;
end record;
pragma Convention (C_Pass_By_Copy, struct_CERT_RDN);
type struct_CERT_RDN_ptr is access all struct_CERT_RDN;
for struct_CERT_RDN_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_RDN_ptr);
pragma Convention (C, struct_CERT_RDN_ptr);
subtype CERT_RDN is struct_CERT_RDN;
subtype PCERT_RDN is struct_CERT_RDN_ptr;
type struct_CERT_NAME_INFO;
type struct_CERT_NAME_INFO is record
cRDN : aliased windef.DWORD;
rgRDN : aliased PCERT_RDN;
end record;
pragma Convention (C_Pass_By_Copy, struct_CERT_NAME_INFO);
type struct_CERT_NAME_INFO_ptr is access all struct_CERT_NAME_INFO;
for struct_CERT_NAME_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_NAME_INFO_ptr);
pragma Convention (C, struct_CERT_NAME_INFO_ptr);
subtype CERT_NAME_INFO is struct_CERT_NAME_INFO;
subtype PCERT_NAME_INFO is struct_CERT_NAME_INFO_ptr;
type struct_CERT_NAME_VALUE;
type struct_CERT_NAME_VALUE is record
dwValueType : aliased windef.DWORD;
Value : aliased CERT_RDN_VALUE_BLOB;
end record;
pragma Convention (C_Pass_By_Copy, struct_CERT_NAME_VALUE);
type struct_CERT_NAME_VALUE_ptr is access all struct_CERT_NAME_VALUE;
for struct_CERT_NAME_VALUE_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_NAME_VALUE_ptr);
pragma Convention (C, struct_CERT_NAME_VALUE_ptr);
subtype CERT_NAME_VALUE is struct_CERT_NAME_VALUE;
subtype PCERT_NAME_VALUE is struct_CERT_NAME_VALUE_ptr;
type struct_CERT_PUBLIC_KEY_INFO;
type struct_CERT_PUBLIC_KEY_INFO is record
Algorithm : aliased CRYPT_ALGORITHM_IDENTIFIER;
PublicKey : aliased CRYPT_BIT_BLOB;
end record;
pragma Convention (C_Pass_By_Copy, struct_CERT_PUBLIC_KEY_INFO);
type struct_CERT_PUBLIC_KEY_INFO_ptr is
access all struct_CERT_PUBLIC_KEY_INFO;
for struct_CERT_PUBLIC_KEY_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_PUBLIC_KEY_INFO_ptr);
pragma Convention (C, struct_CERT_PUBLIC_KEY_INFO_ptr);
subtype CERT_PUBLIC_KEY_INFO is struct_CERT_PUBLIC_KEY_INFO;
subtype PCERT_PUBLIC_KEY_INFO is struct_CERT_PUBLIC_KEY_INFO_ptr;
type struct_CRYPT_PRIVATE_KEY_INFO;
type struct_CRYPT_PRIVATE_KEY_INFO is record
Version : aliased windef.DWORD;
Algorithm : aliased CRYPT_ALGORITHM_IDENTIFIER;
PrivateKey : aliased CRYPT_DER_BLOB;
pAttributes : aliased PCRYPT_ATTRIBUTES;
end record;
pragma Convention (C_Pass_By_Copy, struct_CRYPT_PRIVATE_KEY_INFO);
type struct_CRYPT_PRIVATE_KEY_INFO_ptr is
access all struct_CRYPT_PRIVATE_KEY_INFO;
for struct_CRYPT_PRIVATE_KEY_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_PRIVATE_KEY_INFO_ptr);
pragma Convention (C, struct_CRYPT_PRIVATE_KEY_INFO_ptr);
subtype CRYPT_PRIVATE_KEY_INFO is struct_CRYPT_PRIVATE_KEY_INFO;
subtype CRYPT_PRIVATE_KEY_INFO_ptr is struct_CRYPT_PRIVATE_KEY_INFO_ptr;
subtype PCRYPT_PRIVATE_KEY_INFO is struct_CRYPT_PRIVATE_KEY_INFO_ptr;
type struct_CRYPT_ENCRYPTED_PRIVATE_KEY_INFO;
type struct_CRYPT_ENCRYPTED_PRIVATE_KEY_INFO is record
EncryptionAlgorithm : aliased CRYPT_ALGORITHM_IDENTIFIER;
EncryptedPrivateKey : aliased CRYPT_DATA_BLOB;
end record;
pragma Convention (C_Pass_By_Copy,
struct_CRYPT_ENCRYPTED_PRIVATE_KEY_INFO);
type struct_CRYPT_ENCRYPTED_PRIVATE_KEY_INFO_ptr is
access all struct_CRYPT_ENCRYPTED_PRIVATE_KEY_INFO;
for struct_CRYPT_ENCRYPTED_PRIVATE_KEY_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_ENCRYPTED_PRIVATE_KEY_INFO_ptr);
pragma Convention (C, struct_CRYPT_ENCRYPTED_PRIVATE_KEY_INFO_ptr);
subtype CRYPT_ENCRYPTED_PRIVATE_KEY_INFO is
struct_CRYPT_ENCRYPTED_PRIVATE_KEY_INFO;
subtype PCRYPT_ENCRYPTED_PRIVATE_KEY_INFO is
struct_CRYPT_ENCRYPTED_PRIVATE_KEY_INFO_ptr;
type access_36a73f10 is access function (
Algorithm : CRYPT_ALGORITHM_IDENTIFIER;
EncryptedPrivateKey : CRYPT_DATA_BLOB;
pbClearTextKey : access windef.BYTE;
pcbClearTextKey : access windef.DWORD;
pVoidDecryptFunc : windef.LPVOID) return windef.WINBOOL;
pragma Convention (C, access_36a73f10);
subtype PCRYPT_DECRYPT_PRIVATE_KEY_FUNC is access_36a73f10;
type access_07c955da is access function (
pAlgorithm : access CRYPT_ALGORITHM_IDENTIFIER;
pClearTextPrivateKey : access CRYPT_DATA_BLOB;
pbEncryptedKey : access windef.BYTE;
pcbEncryptedKey : access windef.DWORD;
pVoidEncryptFunc : windef.LPVOID) return windef.WINBOOL;
pragma Convention (C, access_07c955da);
subtype PCRYPT_ENCRYPT_PRIVATE_KEY_FUNC is access_07c955da;
type access_7cd5ed9c is access function (
pPrivateKeyInfo : access CRYPT_PRIVATE_KEY_INFO;
phCryptProv : access HCRYPTPROV; pVoidResolveFunc : windef.LPVOID)
return windef.WINBOOL;
pragma Convention (C, access_7cd5ed9c);
subtype PCRYPT_RESOLVE_HCRYPTPROV_FUNC is access_7cd5ed9c;
type struct_CRYPT_PKCS8_IMPORT_PARAMS;
type struct_CRYPT_PKCS8_IMPORT_PARAMS is record
PrivateKey : aliased CRYPT_DIGEST_BLOB;
pResolvehCryptProvFunc : aliased PCRYPT_RESOLVE_HCRYPTPROV_FUNC;
pVoidResolveFunc : aliased windef.LPVOID;
pDecryptPrivateKeyFunc : aliased PCRYPT_DECRYPT_PRIVATE_KEY_FUNC;
pVoidDecryptFunc : aliased windef.LPVOID;
end record;
pragma Convention (C_Pass_By_Copy, struct_CRYPT_PKCS8_IMPORT_PARAMS);
type struct_CRYPT_PKCS8_IMPORT_PARAMS_ptr is
access all struct_CRYPT_PKCS8_IMPORT_PARAMS;
for struct_CRYPT_PKCS8_IMPORT_PARAMS_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_PKCS8_IMPORT_PARAMS_ptr);
pragma Convention (C, struct_CRYPT_PKCS8_IMPORT_PARAMS_ptr);
subtype CRYPT_PKCS8_IMPORT_PARAMS is struct_CRYPT_PKCS8_IMPORT_PARAMS;
subtype PCRYPT_PKCS8_IMPORT_PARAMS is
struct_CRYPT_PKCS8_IMPORT_PARAMS_ptr;
subtype CRYPT_PRIVATE_KEY_BLOB_AND_PARAMS is
struct_CRYPT_PKCS8_IMPORT_PARAMS;
subtype PCRYPT_PRIVATE_KEY_BLOB_AND_PARAMS is
struct_CRYPT_PKCS8_IMPORT_PARAMS_ptr;
type struct_CRYPT_PKCS8_EXPORT_PARAMS;
type struct_CRYPT_PKCS8_EXPORT_PARAMS is record
hCryptProv : aliased wincrypt.HCRYPTPROV;
dwKeySpec : aliased windef.DWORD;
pszPrivateKeyObjId : aliased winnt.LPSTR;
pEncryptPrivateKeyFunc : aliased PCRYPT_ENCRYPT_PRIVATE_KEY_FUNC;
pVoidEncryptFunc : aliased windef.LPVOID;
end record;
pragma Convention (C_Pass_By_Copy, struct_CRYPT_PKCS8_EXPORT_PARAMS);
type struct_CRYPT_PKCS8_EXPORT_PARAMS_ptr is
access all struct_CRYPT_PKCS8_EXPORT_PARAMS;
for struct_CRYPT_PKCS8_EXPORT_PARAMS_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_PKCS8_EXPORT_PARAMS_ptr);
pragma Convention (C, struct_CRYPT_PKCS8_EXPORT_PARAMS_ptr);
subtype CRYPT_PKCS8_EXPORT_PARAMS is struct_CRYPT_PKCS8_EXPORT_PARAMS;
subtype CRYPT_PKCS8_EXPORT_PARAMS_ptr is
struct_CRYPT_PKCS8_EXPORT_PARAMS_ptr;
subtype PCRYPT_PKCS8_EXPORT_PARAMS is
struct_CRYPT_PKCS8_EXPORT_PARAMS_ptr;
type struct_CERT_INFO;
type struct_CERT_INFO is record
dwVersion : aliased windef.DWORD;
SerialNumber : aliased CRYPT_INTEGER_BLOB;
SignatureAlgorithm : aliased CRYPT_ALGORITHM_IDENTIFIER;
Issuer : aliased CERT_NAME_BLOB;
NotBefore : aliased windef.FILETIME;
NotAfter : aliased windef.FILETIME;
Subject : aliased CERT_NAME_BLOB;
SubjectPublicKeyInfo : aliased CERT_PUBLIC_KEY_INFO;
IssuerUniqueId : aliased CRYPT_BIT_BLOB;
SubjectUniqueId : aliased CRYPT_BIT_BLOB;
cExtension : aliased windef.DWORD;
rgExtension : aliased PCERT_EXTENSION;
end record;
pragma Convention (C_Pass_By_Copy, struct_CERT_INFO);
type struct_CERT_INFO_ptr is access all struct_CERT_INFO;
for struct_CERT_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_INFO_ptr);
pragma Convention (C, struct_CERT_INFO_ptr);
function Cast is new Ada.Unchecked_Conversion (signed_long_long,
struct_CERT_INFO_ptr);
type struct_CERT_INFO_ptr_ptr is access all struct_CERT_INFO_ptr;
for struct_CERT_INFO_ptr_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_INFO_ptr_ptr);
pragma Convention (C, struct_CERT_INFO_ptr_ptr);
subtype CERT_INFO is struct_CERT_INFO;
subtype PCERT_INFO is struct_CERT_INFO_ptr;
subtype PCERT_INFO_ptr is struct_CERT_INFO_ptr_ptr;
type struct_CRL_ENTRY;
type struct_CRL_ENTRY is record
SerialNumber : aliased CRYPT_INTEGER_BLOB;
RevocationDate : aliased windef.FILETIME;
cExtension : aliased windef.DWORD;
rgExtension : aliased PCERT_EXTENSION;
end record;
pragma Convention (C_Pass_By_Copy, struct_CRL_ENTRY);
type struct_CRL_ENTRY_ptr is access all struct_CRL_ENTRY;
for struct_CRL_ENTRY_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRL_ENTRY_ptr);
pragma Convention (C, struct_CRL_ENTRY_ptr);
type struct_CRL_ENTRY_ptr_ptr is access all struct_CRL_ENTRY_ptr;
for struct_CRL_ENTRY_ptr_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRL_ENTRY_ptr_ptr);
pragma Convention (C, struct_CRL_ENTRY_ptr_ptr);
subtype CRL_ENTRY is struct_CRL_ENTRY;
subtype PCRL_ENTRY is struct_CRL_ENTRY_ptr;
subtype PCRL_ENTRY_ptr is struct_CRL_ENTRY_ptr_ptr;
type struct_CRL_INFO;
type struct_CRL_INFO is record
dwVersion : aliased windef.DWORD;
SignatureAlgorithm : aliased CRYPT_ALGORITHM_IDENTIFIER;
Issuer : aliased CERT_NAME_BLOB;
ThisUpdate : aliased windef.FILETIME;
NextUpdate : aliased windef.FILETIME;
cCRLEntry : aliased windef.DWORD;
rgCRLEntry : aliased PCRL_ENTRY;
cExtension : aliased windef.DWORD;
rgExtension : aliased PCERT_EXTENSION;
end record;
pragma Convention (C_Pass_By_Copy, struct_CRL_INFO);
type struct_CRL_INFO_ptr is access all struct_CRL_INFO;
for struct_CRL_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRL_INFO_ptr);
pragma Convention (C, struct_CRL_INFO_ptr);
type struct_CRL_INFO_ptr_array is array (size_t range <>) of
aliased struct_CRL_INFO_ptr;
pragma Convention (C, struct_CRL_INFO_ptr_array);
type struct_CRL_INFO_ptr_ptr is access all struct_CRL_INFO_ptr;
for struct_CRL_INFO_ptr_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRL_INFO_ptr_ptr);
pragma Convention (C, struct_CRL_INFO_ptr_ptr);
subtype CRL_INFO is struct_CRL_INFO;
subtype PCRL_INFO is struct_CRL_INFO_ptr;
subtype PCRL_INFO_array is struct_CRL_INFO_ptr_array;
subtype PCRL_INFO_ptr is struct_CRL_INFO_ptr_ptr;
type struct_CERT_REQUEST_INFO;
type struct_CERT_REQUEST_INFO is record
dwVersion : aliased windef.DWORD;
Subject : aliased CERT_NAME_BLOB;
SubjectPublicKeyInfo : aliased CERT_PUBLIC_KEY_INFO;
cAttribute : aliased windef.DWORD;
rgAttribute : aliased PCRYPT_ATTRIBUTE;
end record;
pragma Convention (C_Pass_By_Copy, struct_CERT_REQUEST_INFO);
type struct_CERT_REQUEST_INFO_ptr is access all struct_CERT_REQUEST_INFO;
for struct_CERT_REQUEST_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_REQUEST_INFO_ptr);
pragma Convention (C, struct_CERT_REQUEST_INFO_ptr);
subtype CERT_REQUEST_INFO is struct_CERT_REQUEST_INFO;
subtype PCERT_REQUEST_INFO is struct_CERT_REQUEST_INFO_ptr;
type struct_CERT_KEYGEN_REQUEST_INFO;
type struct_CERT_KEYGEN_REQUEST_INFO is record
dwVersion : aliased windef.DWORD;
SubjectPublicKeyInfo : aliased CERT_PUBLIC_KEY_INFO;
pwszChallengeString : aliased winnt.LPWSTR;
end record;
pragma Convention (C_Pass_By_Copy, struct_CERT_KEYGEN_REQUEST_INFO);
type struct_CERT_KEYGEN_REQUEST_INFO_ptr is
access all struct_CERT_KEYGEN_REQUEST_INFO;
for struct_CERT_KEYGEN_REQUEST_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_KEYGEN_REQUEST_INFO_ptr);
pragma Convention (C, struct_CERT_KEYGEN_REQUEST_INFO_ptr);
subtype CERT_KEYGEN_REQUEST_INFO is struct_CERT_KEYGEN_REQUEST_INFO;
subtype PCERT_KEYGEN_REQUEST_INFO is struct_CERT_KEYGEN_REQUEST_INFO_ptr;
type struct_CERT_SIGNED_CONTENT_INFO;
type struct_CERT_SIGNED_CONTENT_INFO is record
ToBeSigned : aliased CRYPT_DER_BLOB;
SignatureAlgorithm : aliased CRYPT_ALGORITHM_IDENTIFIER;
Signature : aliased CRYPT_BIT_BLOB;
end record;
pragma Convention (C_Pass_By_Copy, struct_CERT_SIGNED_CONTENT_INFO);
type struct_CERT_SIGNED_CONTENT_INFO_ptr is
access all struct_CERT_SIGNED_CONTENT_INFO;
for struct_CERT_SIGNED_CONTENT_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_SIGNED_CONTENT_INFO_ptr);
pragma Convention (C, struct_CERT_SIGNED_CONTENT_INFO_ptr);
subtype CERT_SIGNED_CONTENT_INFO is struct_CERT_SIGNED_CONTENT_INFO;
subtype PCERT_SIGNED_CONTENT_INFO is struct_CERT_SIGNED_CONTENT_INFO_ptr;
type struct_CTL_USAGE;
type struct_CTL_USAGE is record
cUsageIdentifier : aliased windef.DWORD;
rgpszUsageIdentifier : aliased winnt.LPSTR_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_CTL_USAGE);
type struct_CTL_USAGE_ptr is access all struct_CTL_USAGE;
for struct_CTL_USAGE_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CTL_USAGE_ptr);
pragma Convention (C, struct_CTL_USAGE_ptr);
subtype CTL_USAGE is struct_CTL_USAGE;
subtype PCTL_USAGE is struct_CTL_USAGE_ptr;
subtype CERT_ENHKEY_USAGE is struct_CTL_USAGE;
subtype PCERT_ENHKEY_USAGE is struct_CTL_USAGE_ptr;
type struct_CTL_ENTRY;
type struct_CTL_ENTRY is record
SubjectIdentifier : aliased CRYPT_DATA_BLOB;
cAttribute : aliased windef.DWORD;
rgAttribute : aliased PCRYPT_ATTRIBUTE;
end record;
pragma Convention (C_Pass_By_Copy, struct_CTL_ENTRY);
type struct_CTL_ENTRY_ptr is access all struct_CTL_ENTRY;
for struct_CTL_ENTRY_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CTL_ENTRY_ptr);
pragma Convention (C, struct_CTL_ENTRY_ptr);
subtype CTL_ENTRY is struct_CTL_ENTRY;
subtype PCTL_ENTRY is struct_CTL_ENTRY_ptr;
type struct_CTL_INFO;
type struct_CTL_INFO is record
dwVersion : aliased windef.DWORD;
SubjectUsage : aliased CTL_USAGE;
ListIdentifier : aliased CRYPT_DATA_BLOB;
SequenceNumber : aliased CRYPT_INTEGER_BLOB;
ThisUpdate : aliased windef.FILETIME;
NextUpdate : aliased windef.FILETIME;
SubjectAlgorithm : aliased CRYPT_ALGORITHM_IDENTIFIER;
cCTLEntry : aliased windef.DWORD;
rgCTLEntry : aliased PCTL_ENTRY;
cExtension : aliased windef.DWORD;
rgExtension : aliased PCERT_EXTENSION;
end record;
pragma Convention (C_Pass_By_Copy, struct_CTL_INFO);
type struct_CTL_INFO_ptr is access all struct_CTL_INFO;
for struct_CTL_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CTL_INFO_ptr);
pragma Convention (C, struct_CTL_INFO_ptr);
subtype CTL_INFO is struct_CTL_INFO;
subtype PCTL_INFO is struct_CTL_INFO_ptr;
type struct_CRYPT_TIME_STAMP_REQUEST_INFO;
type struct_CRYPT_TIME_STAMP_REQUEST_INFO is record
pszTimeStampAlgorithm : aliased winnt.LPSTR;
pszContentType : aliased winnt.LPSTR;
Content : aliased CRYPT_OBJID_BLOB;
cAttribute : aliased windef.DWORD;
rgAttribute : aliased PCRYPT_ATTRIBUTE;
end record;
pragma Convention (C_Pass_By_Copy, struct_CRYPT_TIME_STAMP_REQUEST_INFO);
type struct_CRYPT_TIME_STAMP_REQUEST_INFO_ptr is
access all struct_CRYPT_TIME_STAMP_REQUEST_INFO;
for struct_CRYPT_TIME_STAMP_REQUEST_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_TIME_STAMP_REQUEST_INFO_ptr);
pragma Convention (C, struct_CRYPT_TIME_STAMP_REQUEST_INFO_ptr);
subtype CRYPT_TIME_STAMP_REQUEST_INFO is
struct_CRYPT_TIME_STAMP_REQUEST_INFO;
subtype PCRYPT_TIME_STAMP_REQUEST_INFO is
struct_CRYPT_TIME_STAMP_REQUEST_INFO_ptr;
type struct_CRYPT_ENROLLMENT_NAME_VALUE_PAIR;
type struct_CRYPT_ENROLLMENT_NAME_VALUE_PAIR is record
pwszName : aliased winnt.LPWSTR;
pwszValue : aliased winnt.LPWSTR;
end record;
pragma Convention (C_Pass_By_Copy,
struct_CRYPT_ENROLLMENT_NAME_VALUE_PAIR);
type struct_CRYPT_ENROLLMENT_NAME_VALUE_PAIR_ptr is
access all struct_CRYPT_ENROLLMENT_NAME_VALUE_PAIR;
for struct_CRYPT_ENROLLMENT_NAME_VALUE_PAIR_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_ENROLLMENT_NAME_VALUE_PAIR_ptr);
pragma Convention (C, struct_CRYPT_ENROLLMENT_NAME_VALUE_PAIR_ptr);
subtype CRYPT_ENROLLMENT_NAME_VALUE_PAIR is
struct_CRYPT_ENROLLMENT_NAME_VALUE_PAIR;
subtype PCRYPT_ENROLLMENT_NAME_VALUE_PAIR is
struct_CRYPT_ENROLLMENT_NAME_VALUE_PAIR_ptr;
type struct_CRYPT_CSP_PROVIDER;
type struct_CRYPT_CSP_PROVIDER is record
dwKeySpec : aliased windef.DWORD;
pwszProviderName : aliased winnt.LPWSTR;
Signature : aliased CRYPT_BIT_BLOB;
end record;
pragma Convention (C_Pass_By_Copy, struct_CRYPT_CSP_PROVIDER);
type struct_CRYPT_CSP_PROVIDER_ptr is
access all struct_CRYPT_CSP_PROVIDER;
for struct_CRYPT_CSP_PROVIDER_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_CSP_PROVIDER_ptr);
pragma Convention (C, struct_CRYPT_CSP_PROVIDER_ptr);
subtype CRYPT_CSP_PROVIDER is struct_CRYPT_CSP_PROVIDER;
subtype PCRYPT_CSP_PROVIDER is struct_CRYPT_CSP_PROVIDER_ptr;
function CryptFormatObject (dwCertEncodingType : windef.DWORD;
dwFormatType : windef.DWORD; dwFormatStrType : windef.DWORD;
pFormatStruct : void_ptr;
lpszStructType : access constant winnt.C_CHAR;
pbEncoded : access constant windef.BYTE; cbEncoded : windef.DWORD;
pbFormat : void_ptr; pcbFormat : access windef.DWORD)
return windef.WINBOOL;
pragma Import (C, CryptFormatObject, "CryptFormatObject");
type access_84256fd0 is access function (cbSize : qmingw.size_t)
return windef.LPVOID;
pragma Convention (C, access_84256fd0);
subtype PFN_CRYPT_ALLOC is access_84256fd0;
type access_2df0348c is access procedure (pv : windef.LPVOID);
pragma Convention (C, access_2df0348c);
subtype PFN_CRYPT_FREE is access_2df0348c;
type struct_CRYPT_ENCODE_PARA;
type struct_CRYPT_ENCODE_PARA is record
cbSize : aliased windef.DWORD;
pfnAlloc : aliased PFN_CRYPT_ALLOC;
pfnFree : aliased PFN_CRYPT_FREE;
end record;
pragma Convention (C_Pass_By_Copy, struct_CRYPT_ENCODE_PARA);
type struct_CRYPT_ENCODE_PARA_ptr is access all struct_CRYPT_ENCODE_PARA;
for struct_CRYPT_ENCODE_PARA_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_ENCODE_PARA_ptr);
pragma Convention (C, struct_CRYPT_ENCODE_PARA_ptr);
subtype CRYPT_ENCODE_PARA is struct_CRYPT_ENCODE_PARA;
subtype PCRYPT_ENCODE_PARA is struct_CRYPT_ENCODE_PARA_ptr;
function CryptEncodeObjectEx (dwCertEncodingType : windef.DWORD;
lpszStructType : access constant winnt.C_CHAR;
pvStructInfo : void_const_ptr; dwFlags : windef.DWORD;
pEncodePara : access struct_CRYPT_ENCODE_PARA; pvEncoded : void_ptr;
pcbEncoded : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, CryptEncodeObjectEx, "CryptEncodeObjectEx");
function CryptEncodeObject (dwCertEncodingType : windef.DWORD;
lpszStructType : access constant winnt.C_CHAR;
pvStructInfo : void_const_ptr; pbEncoded : access windef.BYTE;
pcbEncoded : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, CryptEncodeObject, "CryptEncodeObject");
type struct_CRYPT_DECODE_PARA;
type struct_CRYPT_DECODE_PARA is record
cbSize : aliased windef.DWORD;
pfnAlloc : aliased PFN_CRYPT_ALLOC;
pfnFree : aliased PFN_CRYPT_FREE;
end record;
pragma Convention (C_Pass_By_Copy, struct_CRYPT_DECODE_PARA);
type struct_CRYPT_DECODE_PARA_ptr is access all struct_CRYPT_DECODE_PARA;
for struct_CRYPT_DECODE_PARA_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_DECODE_PARA_ptr);
pragma Convention (C, struct_CRYPT_DECODE_PARA_ptr);
subtype CRYPT_DECODE_PARA is struct_CRYPT_DECODE_PARA;
subtype PCRYPT_DECODE_PARA is struct_CRYPT_DECODE_PARA_ptr;
function CryptDecodeObjectEx (dwCertEncodingType : windef.DWORD;
lpszStructType : access constant winnt.C_CHAR;
pbEncoded : access constant windef.BYTE; cbEncoded : windef.DWORD;
dwFlags : windef.DWORD; pDecodePara : access struct_CRYPT_DECODE_PARA;
pvStructInfo : void_ptr; pcbStructInfo : access windef.DWORD)
return windef.WINBOOL;
pragma Import (C, CryptDecodeObjectEx, "CryptDecodeObjectEx");
function CryptDecodeObject (dwCertEncodingType : windef.DWORD;
lpszStructType : access constant winnt.C_CHAR;
pbEncoded : access constant windef.BYTE; cbEncoded : windef.DWORD;
dwFlags : windef.DWORD; pvStructInfo : void_ptr;
pcbStructInfo : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, CryptDecodeObject, "CryptDecodeObject");
type struct_CERT_EXTENSIONS;
type struct_CERT_EXTENSIONS is record
cExtension : aliased windef.DWORD;
rgExtension : aliased PCERT_EXTENSION;
end record;
pragma Convention (C_Pass_By_Copy, struct_CERT_EXTENSIONS);
type struct_CERT_EXTENSIONS_ptr is access all struct_CERT_EXTENSIONS;
for struct_CERT_EXTENSIONS_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_EXTENSIONS_ptr);
pragma Convention (C, struct_CERT_EXTENSIONS_ptr);
subtype CERT_EXTENSIONS is struct_CERT_EXTENSIONS;
subtype PCERT_EXTENSIONS is struct_CERT_EXTENSIONS_ptr;
type struct_CERT_AUTHORITY_KEY_ID_INFO;
type struct_CERT_AUTHORITY_KEY_ID_INFO is record
KeyId : aliased CRYPT_DATA_BLOB;
CertIssuer : aliased CERT_NAME_BLOB;
CertSerialNumber : aliased CRYPT_INTEGER_BLOB;
end record;
pragma Convention (C_Pass_By_Copy, struct_CERT_AUTHORITY_KEY_ID_INFO);
type struct_CERT_AUTHORITY_KEY_ID_INFO_ptr is
access all struct_CERT_AUTHORITY_KEY_ID_INFO;
for struct_CERT_AUTHORITY_KEY_ID_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_AUTHORITY_KEY_ID_INFO_ptr);
pragma Convention (C, struct_CERT_AUTHORITY_KEY_ID_INFO_ptr);
subtype CERT_AUTHORITY_KEY_ID_INFO is struct_CERT_AUTHORITY_KEY_ID_INFO;
subtype PCERT_AUTHORITY_KEY_ID_INFO is
struct_CERT_AUTHORITY_KEY_ID_INFO_ptr;
type struct_CERT_PRIVATE_KEY_VALIDITY;
type struct_CERT_PRIVATE_KEY_VALIDITY is record
NotBefore : aliased windef.FILETIME;
NotAfter : aliased windef.FILETIME;
end record;
pragma Convention (C_Pass_By_Copy, struct_CERT_PRIVATE_KEY_VALIDITY);
type struct_CERT_PRIVATE_KEY_VALIDITY_ptr is
access all struct_CERT_PRIVATE_KEY_VALIDITY;
for struct_CERT_PRIVATE_KEY_VALIDITY_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_PRIVATE_KEY_VALIDITY_ptr);
pragma Convention (C, struct_CERT_PRIVATE_KEY_VALIDITY_ptr);
subtype CERT_PRIVATE_KEY_VALIDITY is struct_CERT_PRIVATE_KEY_VALIDITY;
subtype PCERT_PRIVATE_KEY_VALIDITY is
struct_CERT_PRIVATE_KEY_VALIDITY_ptr;
type struct_CERT_KEY_ATTRIBUTES_INFO;
type struct_CERT_KEY_ATTRIBUTES_INFO is record
KeyId : aliased CRYPT_DATA_BLOB;
IntendedKeyUsage : aliased CRYPT_BIT_BLOB;
pPrivateKeyUsagePeriod : aliased PCERT_PRIVATE_KEY_VALIDITY;
end record;
pragma Convention (C_Pass_By_Copy, struct_CERT_KEY_ATTRIBUTES_INFO);
type struct_CERT_KEY_ATTRIBUTES_INFO_ptr is
access all struct_CERT_KEY_ATTRIBUTES_INFO;
for struct_CERT_KEY_ATTRIBUTES_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_KEY_ATTRIBUTES_INFO_ptr);
pragma Convention (C, struct_CERT_KEY_ATTRIBUTES_INFO_ptr);
subtype CERT_KEY_ATTRIBUTES_INFO is struct_CERT_KEY_ATTRIBUTES_INFO;
subtype PCERT_KEY_ATTRIBUTES_INFO is struct_CERT_KEY_ATTRIBUTES_INFO_ptr;
type struct_CERT_POLICY_ID;
type struct_CERT_POLICY_ID is record
cCertPolicyElementId : aliased windef.DWORD;
rgpszCertPolicyElementId : aliased winnt.LPSTR_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_CERT_POLICY_ID);
type struct_CERT_POLICY_ID_ptr is access all struct_CERT_POLICY_ID;
for struct_CERT_POLICY_ID_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_POLICY_ID_ptr);
pragma Convention (C, struct_CERT_POLICY_ID_ptr);
subtype CERT_POLICY_ID is struct_CERT_POLICY_ID;
subtype PCERT_POLICY_ID is struct_CERT_POLICY_ID_ptr;
type struct_CERT_KEY_USAGE_RESTRICTION_INFO;
type struct_CERT_KEY_USAGE_RESTRICTION_INFO is record
cCertPolicyId : aliased windef.DWORD;
rgCertPolicyId : aliased PCERT_POLICY_ID;
RestrictedKeyUsage : aliased CRYPT_BIT_BLOB;
end record;
pragma Convention (C_Pass_By_Copy,
struct_CERT_KEY_USAGE_RESTRICTION_INFO);
type struct_CERT_KEY_USAGE_RESTRICTION_INFO_ptr is
access all struct_CERT_KEY_USAGE_RESTRICTION_INFO;
for struct_CERT_KEY_USAGE_RESTRICTION_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_KEY_USAGE_RESTRICTION_INFO_ptr);
pragma Convention (C, struct_CERT_KEY_USAGE_RESTRICTION_INFO_ptr);
subtype CERT_KEY_USAGE_RESTRICTION_INFO is
struct_CERT_KEY_USAGE_RESTRICTION_INFO;
subtype PCERT_KEY_USAGE_RESTRICTION_INFO is
struct_CERT_KEY_USAGE_RESTRICTION_INFO_ptr;
type struct_CERT_OTHER_NAME;
type struct_CERT_OTHER_NAME is record
pszObjId : aliased winnt.LPSTR;
Value : aliased CRYPT_OBJID_BLOB;
end record;
pragma Convention (C_Pass_By_Copy, struct_CERT_OTHER_NAME);
type struct_CERT_OTHER_NAME_ptr is access all struct_CERT_OTHER_NAME;
for struct_CERT_OTHER_NAME_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_OTHER_NAME_ptr);
pragma Convention (C, struct_CERT_OTHER_NAME_ptr);
subtype CERT_OTHER_NAME is struct_CERT_OTHER_NAME;
subtype PCERT_OTHER_NAME is struct_CERT_OTHER_NAME_ptr;
type struct_CERT_ALT_NAME_ENTRY;
type union_7d6ba6df (Unchecked_Tag : unsigned_int := 0) is record
case Unchecked_Tag is
when 0 =>
pOtherName : PCERT_OTHER_NAME;
when 1 =>
pwszRfc822Name : winnt.LPWSTR;
when 2 =>
pwszDNSName : winnt.LPWSTR;
when 3 =>
DirectoryName : CERT_NAME_BLOB;
when 4 =>
pwszURL : winnt.LPWSTR;
when 5 =>
IPAddress : CRYPT_DATA_BLOB;
when others =>
pszRegisteredID : winnt.LPSTR;
end case;
end record;
pragma Unchecked_Union (union_7d6ba6df);
pragma Convention (C_Pass_By_Copy, union_7d6ba6df);
type struct_CERT_ALT_NAME_ENTRY is record
dwAltNameChoice : aliased windef.DWORD;
anonymous_1 : aliased union_7d6ba6df;
end record;
pragma Convention (C_Pass_By_Copy, struct_CERT_ALT_NAME_ENTRY);
type struct_CERT_ALT_NAME_ENTRY_ptr is
access all struct_CERT_ALT_NAME_ENTRY;
for struct_CERT_ALT_NAME_ENTRY_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_ALT_NAME_ENTRY_ptr);
pragma Convention (C, struct_CERT_ALT_NAME_ENTRY_ptr);
subtype CERT_ALT_NAME_ENTRY is struct_CERT_ALT_NAME_ENTRY;
subtype PCERT_ALT_NAME_ENTRY is struct_CERT_ALT_NAME_ENTRY_ptr;
type struct_CERT_ALT_NAME_INFO;
type struct_CERT_ALT_NAME_INFO is record
cAltEntry : aliased windef.DWORD;
rgAltEntry : aliased PCERT_ALT_NAME_ENTRY;
end record;
pragma Convention (C_Pass_By_Copy, struct_CERT_ALT_NAME_INFO);
type struct_CERT_ALT_NAME_INFO_ptr is
access all struct_CERT_ALT_NAME_INFO;
for struct_CERT_ALT_NAME_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_ALT_NAME_INFO_ptr);
pragma Convention (C, struct_CERT_ALT_NAME_INFO_ptr);
subtype CERT_ALT_NAME_INFO is struct_CERT_ALT_NAME_INFO;
subtype PCERT_ALT_NAME_INFO is struct_CERT_ALT_NAME_INFO_ptr;
type struct_CERT_BASIC_CONSTRAINTS_INFO;
type struct_CERT_BASIC_CONSTRAINTS_INFO is record
SubjectType : aliased CRYPT_BIT_BLOB;
fPathLenConstraint : aliased windef.WINBOOL;
dwPathLenConstraint : aliased windef.DWORD;
cSubtreesConstraint : aliased windef.DWORD;
rgSubtreesConstraint : aliased CERT_NAME_BLOB_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_CERT_BASIC_CONSTRAINTS_INFO);
type struct_CERT_BASIC_CONSTRAINTS_INFO_ptr is
access all struct_CERT_BASIC_CONSTRAINTS_INFO;
for struct_CERT_BASIC_CONSTRAINTS_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_BASIC_CONSTRAINTS_INFO_ptr);
pragma Convention (C, struct_CERT_BASIC_CONSTRAINTS_INFO_ptr);
subtype CERT_BASIC_CONSTRAINTS_INFO is struct_CERT_BASIC_CONSTRAINTS_INFO;
subtype PCERT_BASIC_CONSTRAINTS_INFO is
struct_CERT_BASIC_CONSTRAINTS_INFO_ptr;
type struct_CERT_BASIC_CONSTRAINTS2_INFO;
type struct_CERT_BASIC_CONSTRAINTS2_INFO is record
fCA : aliased windef.WINBOOL;
fPathLenConstraint : aliased windef.WINBOOL;
dwPathLenConstraint : aliased windef.DWORD;
end record;
pragma Convention (C_Pass_By_Copy, struct_CERT_BASIC_CONSTRAINTS2_INFO);
type struct_CERT_BASIC_CONSTRAINTS2_INFO_ptr is
access all struct_CERT_BASIC_CONSTRAINTS2_INFO;
for struct_CERT_BASIC_CONSTRAINTS2_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_BASIC_CONSTRAINTS2_INFO_ptr);
pragma Convention (C, struct_CERT_BASIC_CONSTRAINTS2_INFO_ptr);
subtype CERT_BASIC_CONSTRAINTS2_INFO is
struct_CERT_BASIC_CONSTRAINTS2_INFO;
subtype PCERT_BASIC_CONSTRAINTS2_INFO is
struct_CERT_BASIC_CONSTRAINTS2_INFO_ptr;
type struct_CERT_POLICY_QUALIFIER_INFO;
type struct_CERT_POLICY_QUALIFIER_INFO is record
pszPolicyQualifierId : aliased winnt.LPSTR;
Qualifier : aliased CRYPT_OBJID_BLOB;
end record;
pragma Convention (C_Pass_By_Copy, struct_CERT_POLICY_QUALIFIER_INFO);
type struct_CERT_POLICY_QUALIFIER_INFO_ptr is
access all struct_CERT_POLICY_QUALIFIER_INFO;
for struct_CERT_POLICY_QUALIFIER_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_POLICY_QUALIFIER_INFO_ptr);
pragma Convention (C, struct_CERT_POLICY_QUALIFIER_INFO_ptr);
subtype CERT_POLICY_QUALIFIER_INFO is struct_CERT_POLICY_QUALIFIER_INFO;
subtype CERT_POLICY_QUALIFIER_INFO_ptr is
struct_CERT_POLICY_QUALIFIER_INFO_ptr;
subtype PCERT_POLICY_QUALIFIER_INFO is
struct_CERT_POLICY_QUALIFIER_INFO_ptr;
type struct_CERT_POLICY_INFO;
type struct_CERT_POLICY_INFO is record
pszPolicyIdentifier : aliased winnt.LPSTR;
cPolicyQualifier : aliased windef.DWORD;
rgPolicyQualifier : aliased CERT_POLICY_QUALIFIER_INFO_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_CERT_POLICY_INFO);
type struct_CERT_POLICY_INFO_ptr is access all struct_CERT_POLICY_INFO;
for struct_CERT_POLICY_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_POLICY_INFO_ptr);
pragma Convention (C, struct_CERT_POLICY_INFO_ptr);
subtype CERT_POLICY_INFO is struct_CERT_POLICY_INFO;
subtype CERT_POLICY_INFO_ptr is struct_CERT_POLICY_INFO_ptr;
subtype PCERT_POLICY_INFO is struct_CERT_POLICY_INFO_ptr;
type struct_CERT_POLICIES_INFO;
type struct_CERT_POLICIES_INFO is record
cPolicyInfo : aliased windef.DWORD;
rgPolicyInfo : aliased CERT_POLICY_INFO_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_CERT_POLICIES_INFO);
type struct_CERT_POLICIES_INFO_ptr is
access all struct_CERT_POLICIES_INFO;
for struct_CERT_POLICIES_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_POLICIES_INFO_ptr);
pragma Convention (C, struct_CERT_POLICIES_INFO_ptr);
subtype CERT_POLICIES_INFO is struct_CERT_POLICIES_INFO;
subtype PCERT_POLICIES_INFO is struct_CERT_POLICIES_INFO_ptr;
type struct_CERT_POLICY_QUALIFIER_NOTICE_REFERENCE;
type struct_CERT_POLICY_QUALIFIER_NOTICE_REFERENCE is record
pszOrganization : aliased winnt.LPSTR;
cNoticeNumbers : aliased windef.DWORD;
rgNoticeNumbers : aliased signed_int_ptr;
end record;
pragma Convention (C_Pass_By_Copy,
struct_CERT_POLICY_QUALIFIER_NOTICE_REFERENCE);
type struct_CERT_POLICY_QUALIFIER_NOTICE_REFERENCE_ptr is
access all struct_CERT_POLICY_QUALIFIER_NOTICE_REFERENCE;
for struct_CERT_POLICY_QUALIFIER_NOTICE_REFERENCE_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (
struct_CERT_POLICY_QUALIFIER_NOTICE_REFERENCE_ptr);
pragma Convention (C, struct_CERT_POLICY_QUALIFIER_NOTICE_REFERENCE_ptr);
subtype CERT_POLICY_QUALIFIER_NOTICE_REFERENCE is
struct_CERT_POLICY_QUALIFIER_NOTICE_REFERENCE;
subtype CERT_POLICY_QUALIFIER_NOTICE_REFERENCE_ptr is
struct_CERT_POLICY_QUALIFIER_NOTICE_REFERENCE_ptr;
subtype PCERT_POLICY_QUALIFIER_NOTICE_REFERENCE is
struct_CERT_POLICY_QUALIFIER_NOTICE_REFERENCE_ptr;
type struct_CERT_POLICY_QUALIFIER_USER_NOTICE;
type struct_CERT_POLICY_QUALIFIER_USER_NOTICE is record
pNoticeReference : aliased CERT_POLICY_QUALIFIER_NOTICE_REFERENCE_ptr;
pszDisplayText : aliased winnt.LPWSTR;
end record;
pragma Convention (C_Pass_By_Copy,
struct_CERT_POLICY_QUALIFIER_USER_NOTICE);
type struct_CERT_POLICY_QUALIFIER_USER_NOTICE_ptr is
access all struct_CERT_POLICY_QUALIFIER_USER_NOTICE;
for struct_CERT_POLICY_QUALIFIER_USER_NOTICE_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_POLICY_QUALIFIER_USER_NOTICE_ptr);
pragma Convention (C, struct_CERT_POLICY_QUALIFIER_USER_NOTICE_ptr);
subtype CERT_POLICY_QUALIFIER_USER_NOTICE is
struct_CERT_POLICY_QUALIFIER_USER_NOTICE;
subtype PCERT_POLICY_QUALIFIER_USER_NOTICE is
struct_CERT_POLICY_QUALIFIER_USER_NOTICE_ptr;
type struct_CPS_URLS;
type struct_CPS_URLS is record
pszURL : aliased winnt.LPWSTR;
pAlgorithm : aliased CRYPT_ALGORITHM_IDENTIFIER_ptr;
pDigest : aliased CRYPT_DATA_BLOB_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_CPS_URLS);
type struct_CPS_URLS_ptr is access all struct_CPS_URLS;
for struct_CPS_URLS_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CPS_URLS_ptr);
pragma Convention (C, struct_CPS_URLS_ptr);
subtype CPS_URLS is struct_CPS_URLS;
subtype CPS_URLS_ptr is struct_CPS_URLS_ptr;
subtype PCPS_URLS is struct_CPS_URLS_ptr;
type struct_CERT_POLICY95_QUALIFIER1;
type struct_CERT_POLICY95_QUALIFIER1 is record
pszPracticesReference : aliased winnt.LPWSTR;
pszNoticeIdentifier : aliased winnt.LPSTR;
pszNSINoticeIdentifier : aliased winnt.LPSTR;
cCPSURLs : aliased windef.DWORD;
rgCPSURLs : aliased CPS_URLS_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_CERT_POLICY95_QUALIFIER1);
type struct_CERT_POLICY95_QUALIFIER1_ptr is
access all struct_CERT_POLICY95_QUALIFIER1;
for struct_CERT_POLICY95_QUALIFIER1_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_POLICY95_QUALIFIER1_ptr);
pragma Convention (C, struct_CERT_POLICY95_QUALIFIER1_ptr);
subtype CERT_POLICY95_QUALIFIER1 is struct_CERT_POLICY95_QUALIFIER1;
subtype PCERT_POLICY95_QUALIFIER1 is struct_CERT_POLICY95_QUALIFIER1_ptr;
type struct_CERT_POLICY_MAPPING;
type struct_CERT_POLICY_MAPPING is record
pszIssuerDomainPolicy : aliased winnt.LPSTR;
pszSubjectDomainPolicy : aliased winnt.LPSTR;
end record;
pragma Convention (C_Pass_By_Copy, struct_CERT_POLICY_MAPPING);
type struct_CERT_POLICY_MAPPING_ptr is
access all struct_CERT_POLICY_MAPPING;
for struct_CERT_POLICY_MAPPING_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_POLICY_MAPPING_ptr);
pragma Convention (C, struct_CERT_POLICY_MAPPING_ptr);
subtype CERT_POLICY_MAPPING is struct_CERT_POLICY_MAPPING;
subtype PCERT_POLICY_MAPPING is struct_CERT_POLICY_MAPPING_ptr;
type struct_CERT_POLICY_MAPPINGS_INFO;
type struct_CERT_POLICY_MAPPINGS_INFO is record
cPolicyMapping : aliased windef.DWORD;
rgPolicyMapping : aliased PCERT_POLICY_MAPPING;
end record;
pragma Convention (C_Pass_By_Copy, struct_CERT_POLICY_MAPPINGS_INFO);
type struct_CERT_POLICY_MAPPINGS_INFO_ptr is
access all struct_CERT_POLICY_MAPPINGS_INFO;
for struct_CERT_POLICY_MAPPINGS_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_POLICY_MAPPINGS_INFO_ptr);
pragma Convention (C, struct_CERT_POLICY_MAPPINGS_INFO_ptr);
subtype CERT_POLICY_MAPPINGS_INFO is struct_CERT_POLICY_MAPPINGS_INFO;
subtype PCERT_POLICY_MAPPINGS_INFO is
struct_CERT_POLICY_MAPPINGS_INFO_ptr;
type struct_CERT_POLICY_CONSTRAINTS_INFO;
type struct_CERT_POLICY_CONSTRAINTS_INFO is record
fRequireExplicitPolicy : aliased windef.WINBOOL;
dwRequireExplicitPolicySkipCerts : aliased windef.DWORD;
fInhibitPolicyMapping : aliased windef.WINBOOL;
dwInhibitPolicyMappingSkipCerts : aliased windef.DWORD;
end record;
pragma Convention (C_Pass_By_Copy, struct_CERT_POLICY_CONSTRAINTS_INFO);
type struct_CERT_POLICY_CONSTRAINTS_INFO_ptr is
access all struct_CERT_POLICY_CONSTRAINTS_INFO;
for struct_CERT_POLICY_CONSTRAINTS_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_POLICY_CONSTRAINTS_INFO_ptr);
pragma Convention (C, struct_CERT_POLICY_CONSTRAINTS_INFO_ptr);
subtype CERT_POLICY_CONSTRAINTS_INFO is
struct_CERT_POLICY_CONSTRAINTS_INFO;
subtype PCERT_POLICY_CONSTRAINTS_INFO is
struct_CERT_POLICY_CONSTRAINTS_INFO_ptr;
type struct_CRYPT_CONTENT_INFO_SEQUENCE_OF_ANY;
type struct_CRYPT_CONTENT_INFO_SEQUENCE_OF_ANY is record
pszObjId : aliased winnt.LPSTR;
cValue : aliased windef.DWORD;
rgValue : aliased PCRYPT_DER_BLOB;
end record;
pragma Convention (C_Pass_By_Copy,
struct_CRYPT_CONTENT_INFO_SEQUENCE_OF_ANY);
type struct_CRYPT_CONTENT_INFO_SEQUENCE_OF_ANY_ptr is
access all struct_CRYPT_CONTENT_INFO_SEQUENCE_OF_ANY;
for struct_CRYPT_CONTENT_INFO_SEQUENCE_OF_ANY_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_CONTENT_INFO_SEQUENCE_OF_ANY_ptr);
pragma Convention (C, struct_CRYPT_CONTENT_INFO_SEQUENCE_OF_ANY_ptr);
subtype CRYPT_CONTENT_INFO_SEQUENCE_OF_ANY is
struct_CRYPT_CONTENT_INFO_SEQUENCE_OF_ANY;
subtype PCRYPT_CONTENT_INFO_SEQUENCE_OF_ANY is
struct_CRYPT_CONTENT_INFO_SEQUENCE_OF_ANY_ptr;
type struct_CRYPT_CONTENT_INFO;
type struct_CRYPT_CONTENT_INFO is record
pszObjId : aliased winnt.LPSTR;
Content : aliased CRYPT_DER_BLOB;
end record;
pragma Convention (C_Pass_By_Copy, struct_CRYPT_CONTENT_INFO);
type struct_CRYPT_CONTENT_INFO_ptr is
access all struct_CRYPT_CONTENT_INFO;
for struct_CRYPT_CONTENT_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_CONTENT_INFO_ptr);
pragma Convention (C, struct_CRYPT_CONTENT_INFO_ptr);
subtype CRYPT_CONTENT_INFO is struct_CRYPT_CONTENT_INFO;
subtype PCRYPT_CONTENT_INFO is struct_CRYPT_CONTENT_INFO_ptr;
type struct_CRYPT_SEQUENCE_OF_ANY;
type struct_CRYPT_SEQUENCE_OF_ANY is record
cValue : aliased windef.DWORD;
rgValue : aliased PCRYPT_DER_BLOB;
end record;
pragma Convention (C_Pass_By_Copy, struct_CRYPT_SEQUENCE_OF_ANY);
type struct_CRYPT_SEQUENCE_OF_ANY_ptr is
access all struct_CRYPT_SEQUENCE_OF_ANY;
for struct_CRYPT_SEQUENCE_OF_ANY_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_SEQUENCE_OF_ANY_ptr);
pragma Convention (C, struct_CRYPT_SEQUENCE_OF_ANY_ptr);
subtype CRYPT_SEQUENCE_OF_ANY is struct_CRYPT_SEQUENCE_OF_ANY;
subtype PCRYPT_SEQUENCE_OF_ANY is struct_CRYPT_SEQUENCE_OF_ANY_ptr;
type struct_CERT_AUTHORITY_KEY_ID2_INFO;
type struct_CERT_AUTHORITY_KEY_ID2_INFO is record
KeyId : aliased CRYPT_DATA_BLOB;
AuthorityCertIssuer : aliased CERT_ALT_NAME_INFO;
AuthorityCertSerialNumber : aliased CRYPT_INTEGER_BLOB;
end record;
pragma Convention (C_Pass_By_Copy, struct_CERT_AUTHORITY_KEY_ID2_INFO);
type struct_CERT_AUTHORITY_KEY_ID2_INFO_ptr is
access all struct_CERT_AUTHORITY_KEY_ID2_INFO;
for struct_CERT_AUTHORITY_KEY_ID2_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_AUTHORITY_KEY_ID2_INFO_ptr);
pragma Convention (C, struct_CERT_AUTHORITY_KEY_ID2_INFO_ptr);
subtype CERT_AUTHORITY_KEY_ID2_INFO is struct_CERT_AUTHORITY_KEY_ID2_INFO;
subtype PCERT_AUTHORITY_KEY_ID2_INFO is
struct_CERT_AUTHORITY_KEY_ID2_INFO_ptr;
type struct_CERT_ACCESS_DESCRIPTION;
type struct_CERT_ACCESS_DESCRIPTION is record
pszAccessMethod : aliased winnt.LPSTR;
AccessLocation : aliased CERT_ALT_NAME_ENTRY;
end record;
pragma Convention (C_Pass_By_Copy, struct_CERT_ACCESS_DESCRIPTION);
type struct_CERT_ACCESS_DESCRIPTION_ptr is
access all struct_CERT_ACCESS_DESCRIPTION;
for struct_CERT_ACCESS_DESCRIPTION_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_ACCESS_DESCRIPTION_ptr);
pragma Convention (C, struct_CERT_ACCESS_DESCRIPTION_ptr);
subtype CERT_ACCESS_DESCRIPTION is struct_CERT_ACCESS_DESCRIPTION;
subtype PCERT_ACCESS_DESCRIPTION is struct_CERT_ACCESS_DESCRIPTION_ptr;
type struct_CERT_AUTHORITY_INFO_ACCESS;
type struct_CERT_AUTHORITY_INFO_ACCESS is record
cAccDescr : aliased windef.DWORD;
rgAccDescr : aliased PCERT_ACCESS_DESCRIPTION;
end record;
pragma Convention (C_Pass_By_Copy, struct_CERT_AUTHORITY_INFO_ACCESS);
type struct_CERT_AUTHORITY_INFO_ACCESS_ptr is
access all struct_CERT_AUTHORITY_INFO_ACCESS;
for struct_CERT_AUTHORITY_INFO_ACCESS_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_AUTHORITY_INFO_ACCESS_ptr);
pragma Convention (C, struct_CERT_AUTHORITY_INFO_ACCESS_ptr);
subtype CERT_AUTHORITY_INFO_ACCESS is struct_CERT_AUTHORITY_INFO_ACCESS;
subtype PCERT_AUTHORITY_INFO_ACCESS is
struct_CERT_AUTHORITY_INFO_ACCESS_ptr;
type struct_CRL_DIST_POINT_NAME;
type union_f97f4704 (Unchecked_Tag : unsigned_int := 0) is record
case Unchecked_Tag is
when others =>
FullName : CERT_ALT_NAME_INFO;
end case;
end record;
pragma Unchecked_Union (union_f97f4704);
pragma Convention (C_Pass_By_Copy, union_f97f4704);
type struct_CRL_DIST_POINT_NAME is record
dwDistPointNameChoice : aliased windef.DWORD;
anonymous_1 : aliased union_f97f4704;
end record;
pragma Convention (C_Pass_By_Copy, struct_CRL_DIST_POINT_NAME);
type struct_CRL_DIST_POINT_NAME_ptr is
access all struct_CRL_DIST_POINT_NAME;
for struct_CRL_DIST_POINT_NAME_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRL_DIST_POINT_NAME_ptr);
pragma Convention (C, struct_CRL_DIST_POINT_NAME_ptr);
subtype CRL_DIST_POINT_NAME is struct_CRL_DIST_POINT_NAME;
subtype PCRL_DIST_POINT_NAME is struct_CRL_DIST_POINT_NAME_ptr;
type struct_CRL_DIST_POINT;
type struct_CRL_DIST_POINT is record
DistPointName : aliased CRL_DIST_POINT_NAME;
ReasonFlags : aliased CRYPT_BIT_BLOB;
CRLIssuer : aliased CERT_ALT_NAME_INFO;
end record;
pragma Convention (C_Pass_By_Copy, struct_CRL_DIST_POINT);
type struct_CRL_DIST_POINT_ptr is access all struct_CRL_DIST_POINT;
for struct_CRL_DIST_POINT_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRL_DIST_POINT_ptr);
pragma Convention (C, struct_CRL_DIST_POINT_ptr);
subtype CRL_DIST_POINT is struct_CRL_DIST_POINT;
subtype PCRL_DIST_POINT is struct_CRL_DIST_POINT_ptr;
type struct_CRL_DIST_POINTS_INFO;
type struct_CRL_DIST_POINTS_INFO is record
cDistPoint : aliased windef.DWORD;
rgDistPoint : aliased PCRL_DIST_POINT;
end record;
pragma Convention (C_Pass_By_Copy, struct_CRL_DIST_POINTS_INFO);
type struct_CRL_DIST_POINTS_INFO_ptr is
access all struct_CRL_DIST_POINTS_INFO;
for struct_CRL_DIST_POINTS_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRL_DIST_POINTS_INFO_ptr);
pragma Convention (C, struct_CRL_DIST_POINTS_INFO_ptr);
subtype CRL_DIST_POINTS_INFO is struct_CRL_DIST_POINTS_INFO;
subtype PCRL_DIST_POINTS_INFO is struct_CRL_DIST_POINTS_INFO_ptr;
type struct_CROSS_CERT_DIST_POINTS_INFO;
type struct_CROSS_CERT_DIST_POINTS_INFO is record
dwSyncDeltaTime : aliased windef.DWORD;
cDistPoint : aliased windef.DWORD;
rgDistPoint : aliased PCERT_ALT_NAME_INFO;
end record;
pragma Convention (C_Pass_By_Copy, struct_CROSS_CERT_DIST_POINTS_INFO);
type struct_CROSS_CERT_DIST_POINTS_INFO_ptr is
access all struct_CROSS_CERT_DIST_POINTS_INFO;
for struct_CROSS_CERT_DIST_POINTS_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CROSS_CERT_DIST_POINTS_INFO_ptr);
pragma Convention (C, struct_CROSS_CERT_DIST_POINTS_INFO_ptr);
subtype CROSS_CERT_DIST_POINTS_INFO is struct_CROSS_CERT_DIST_POINTS_INFO;
subtype PCROSS_CERT_DIST_POINTS_INFO is
struct_CROSS_CERT_DIST_POINTS_INFO_ptr;
type struct_CERT_PAIR;
type struct_CERT_PAIR is record
Forward : aliased CERT_BLOB;
F_Reverse : aliased CERT_BLOB;
end record;
pragma Convention (C_Pass_By_Copy, struct_CERT_PAIR);
type struct_CERT_PAIR_ptr is access all struct_CERT_PAIR;
for struct_CERT_PAIR_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_PAIR_ptr);
pragma Convention (C, struct_CERT_PAIR_ptr);
subtype CERT_PAIR is struct_CERT_PAIR;
subtype PCERT_PAIR is struct_CERT_PAIR_ptr;
type struct_CRL_ISSUING_DIST_POINT;
type struct_CRL_ISSUING_DIST_POINT is record
DistPointName : aliased CRL_DIST_POINT_NAME;
fOnlyContainsUserCerts : aliased windef.WINBOOL;
fOnlyContainsCACerts : aliased windef.WINBOOL;
OnlySomeReasonFlags : aliased CRYPT_BIT_BLOB;
fIndirectCRL : aliased windef.WINBOOL;
end record;
pragma Convention (C_Pass_By_Copy, struct_CRL_ISSUING_DIST_POINT);
type struct_CRL_ISSUING_DIST_POINT_ptr is
access all struct_CRL_ISSUING_DIST_POINT;
for struct_CRL_ISSUING_DIST_POINT_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRL_ISSUING_DIST_POINT_ptr);
pragma Convention (C, struct_CRL_ISSUING_DIST_POINT_ptr);
subtype CRL_ISSUING_DIST_POINT is struct_CRL_ISSUING_DIST_POINT;
subtype PCRL_ISSUING_DIST_POINT is struct_CRL_ISSUING_DIST_POINT_ptr;
type struct_CERT_GENERAL_SUBTREE;
type struct_CERT_GENERAL_SUBTREE is record
Base : aliased CERT_ALT_NAME_ENTRY;
dwMinimum : aliased windef.DWORD;
fMaximum : aliased windef.WINBOOL;
dwMaximum : aliased windef.DWORD;
end record;
pragma Convention (C_Pass_By_Copy, struct_CERT_GENERAL_SUBTREE);
type struct_CERT_GENERAL_SUBTREE_ptr is
access all struct_CERT_GENERAL_SUBTREE;
for struct_CERT_GENERAL_SUBTREE_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_GENERAL_SUBTREE_ptr);
pragma Convention (C, struct_CERT_GENERAL_SUBTREE_ptr);
subtype CERT_GENERAL_SUBTREE is struct_CERT_GENERAL_SUBTREE;
subtype PCERT_GENERAL_SUBTREE is struct_CERT_GENERAL_SUBTREE_ptr;
type struct_CERT_NAME_CONSTRAINTS_INFO;
type struct_CERT_NAME_CONSTRAINTS_INFO is record
cPermittedSubtree : aliased windef.DWORD;
rgPermittedSubtree : aliased PCERT_GENERAL_SUBTREE;
cExcludedSubtree : aliased windef.DWORD;
rgExcludedSubtree : aliased PCERT_GENERAL_SUBTREE;
end record;
pragma Convention (C_Pass_By_Copy, struct_CERT_NAME_CONSTRAINTS_INFO);
type struct_CERT_NAME_CONSTRAINTS_INFO_ptr is
access all struct_CERT_NAME_CONSTRAINTS_INFO;
for struct_CERT_NAME_CONSTRAINTS_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_NAME_CONSTRAINTS_INFO_ptr);
pragma Convention (C, struct_CERT_NAME_CONSTRAINTS_INFO_ptr);
subtype CERT_NAME_CONSTRAINTS_INFO is struct_CERT_NAME_CONSTRAINTS_INFO;
subtype PCERT_NAME_CONSTRAINTS_INFO is
struct_CERT_NAME_CONSTRAINTS_INFO_ptr;
type struct_CERT_DSS_PARAMETERS;
type struct_CERT_DSS_PARAMETERS is record
p : aliased CRYPT_UINT_BLOB;
q : aliased CRYPT_UINT_BLOB;
g : aliased CRYPT_UINT_BLOB;
end record;
pragma Convention (C_Pass_By_Copy, struct_CERT_DSS_PARAMETERS);
type struct_CERT_DSS_PARAMETERS_ptr is
access all struct_CERT_DSS_PARAMETERS;
for struct_CERT_DSS_PARAMETERS_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_DSS_PARAMETERS_ptr);
pragma Convention (C, struct_CERT_DSS_PARAMETERS_ptr);
subtype CERT_DSS_PARAMETERS is struct_CERT_DSS_PARAMETERS;
subtype PCERT_DSS_PARAMETERS is struct_CERT_DSS_PARAMETERS_ptr;
type struct_CERT_DH_PARAMETERS;
type struct_CERT_DH_PARAMETERS is record
p : aliased CRYPT_UINT_BLOB;
g : aliased CRYPT_UINT_BLOB;
end record;
pragma Convention (C_Pass_By_Copy, struct_CERT_DH_PARAMETERS);
type struct_CERT_DH_PARAMETERS_ptr is
access all struct_CERT_DH_PARAMETERS;
for struct_CERT_DH_PARAMETERS_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_DH_PARAMETERS_ptr);
pragma Convention (C, struct_CERT_DH_PARAMETERS_ptr);
subtype CERT_DH_PARAMETERS is struct_CERT_DH_PARAMETERS;
subtype PCERT_DH_PARAMETERS is struct_CERT_DH_PARAMETERS_ptr;
type struct_CERT_X942_DH_VALIDATION_PARAMS;
type struct_CERT_X942_DH_VALIDATION_PARAMS is record
seed : aliased CRYPT_BIT_BLOB;
pgenCounter : aliased windef.DWORD;
end record;
pragma Convention (C_Pass_By_Copy, struct_CERT_X942_DH_VALIDATION_PARAMS);
type struct_CERT_X942_DH_VALIDATION_PARAMS_ptr is
access all struct_CERT_X942_DH_VALIDATION_PARAMS;
for struct_CERT_X942_DH_VALIDATION_PARAMS_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_X942_DH_VALIDATION_PARAMS_ptr);
pragma Convention (C, struct_CERT_X942_DH_VALIDATION_PARAMS_ptr);
subtype CERT_X942_DH_VALIDATION_PARAMS is
struct_CERT_X942_DH_VALIDATION_PARAMS;
subtype PCERT_X942_DH_VALIDATION_PARAMS is
struct_CERT_X942_DH_VALIDATION_PARAMS_ptr;
type struct_CERT_X942_DH_PARAMETERS;
type struct_CERT_X942_DH_PARAMETERS is record
p : aliased CRYPT_UINT_BLOB;
g : aliased CRYPT_UINT_BLOB;
q : aliased CRYPT_UINT_BLOB;
j : aliased CRYPT_UINT_BLOB;
pValidationParams : aliased PCERT_X942_DH_VALIDATION_PARAMS;
end record;
pragma Convention (C_Pass_By_Copy, struct_CERT_X942_DH_PARAMETERS);
type struct_CERT_X942_DH_PARAMETERS_ptr is
access all struct_CERT_X942_DH_PARAMETERS;
for struct_CERT_X942_DH_PARAMETERS_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_X942_DH_PARAMETERS_ptr);
pragma Convention (C, struct_CERT_X942_DH_PARAMETERS_ptr);
subtype CERT_X942_DH_PARAMETERS is struct_CERT_X942_DH_PARAMETERS;
subtype PCERT_X942_DH_PARAMETERS is struct_CERT_X942_DH_PARAMETERS_ptr;
type struct_CRYPT_X942_OTHER_INFO;
type struct_CRYPT_X942_OTHER_INFO is record
pszContentEncryptionObjId : aliased winnt.LPSTR;
rgbCounter : aliased windef.BYTE_array (0 .. 3);
rgbKeyLength : aliased windef.BYTE_array (0 .. 3);
PubInfo : aliased CRYPT_DATA_BLOB;
end record;
pragma Convention (C_Pass_By_Copy, struct_CRYPT_X942_OTHER_INFO);
type struct_CRYPT_X942_OTHER_INFO_ptr is
access all struct_CRYPT_X942_OTHER_INFO;
for struct_CRYPT_X942_OTHER_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_X942_OTHER_INFO_ptr);
pragma Convention (C, struct_CRYPT_X942_OTHER_INFO_ptr);
subtype CRYPT_X942_OTHER_INFO is struct_CRYPT_X942_OTHER_INFO;
subtype PCRYPT_X942_OTHER_INFO is struct_CRYPT_X942_OTHER_INFO_ptr;
type struct_CRYPT_RC2_CBC_PARAMETERS;
type struct_CRYPT_RC2_CBC_PARAMETERS is record
dwVersion : aliased windef.DWORD;
fIV : aliased windef.WINBOOL;
rgbIV : aliased windef.BYTE_array (0 .. 7);
end record;
pragma Convention (C_Pass_By_Copy, struct_CRYPT_RC2_CBC_PARAMETERS);
type struct_CRYPT_RC2_CBC_PARAMETERS_ptr is
access all struct_CRYPT_RC2_CBC_PARAMETERS;
for struct_CRYPT_RC2_CBC_PARAMETERS_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_RC2_CBC_PARAMETERS_ptr);
pragma Convention (C, struct_CRYPT_RC2_CBC_PARAMETERS_ptr);
subtype CRYPT_RC2_CBC_PARAMETERS is struct_CRYPT_RC2_CBC_PARAMETERS;
subtype PCRYPT_RC2_CBC_PARAMETERS is struct_CRYPT_RC2_CBC_PARAMETERS_ptr;
type struct_CRYPT_SMIME_CAPABILITY;
type struct_CRYPT_SMIME_CAPABILITY is record
pszObjId : aliased winnt.LPSTR;
Parameters : aliased CRYPT_OBJID_BLOB;
end record;
pragma Convention (C_Pass_By_Copy, struct_CRYPT_SMIME_CAPABILITY);
type struct_CRYPT_SMIME_CAPABILITY_ptr is
access all struct_CRYPT_SMIME_CAPABILITY;
for struct_CRYPT_SMIME_CAPABILITY_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_SMIME_CAPABILITY_ptr);
pragma Convention (C, struct_CRYPT_SMIME_CAPABILITY_ptr);
subtype CRYPT_SMIME_CAPABILITY is struct_CRYPT_SMIME_CAPABILITY;
subtype PCRYPT_SMIME_CAPABILITY is struct_CRYPT_SMIME_CAPABILITY_ptr;
type struct_CRYPT_SMIME_CAPABILITIES;
type struct_CRYPT_SMIME_CAPABILITIES is record
cCapability : aliased windef.DWORD;
rgCapability : aliased PCRYPT_SMIME_CAPABILITY;
end record;
pragma Convention (C_Pass_By_Copy, struct_CRYPT_SMIME_CAPABILITIES);
type struct_CRYPT_SMIME_CAPABILITIES_ptr is
access all struct_CRYPT_SMIME_CAPABILITIES;
for struct_CRYPT_SMIME_CAPABILITIES_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_SMIME_CAPABILITIES_ptr);
pragma Convention (C, struct_CRYPT_SMIME_CAPABILITIES_ptr);
subtype CRYPT_SMIME_CAPABILITIES is struct_CRYPT_SMIME_CAPABILITIES;
subtype PCRYPT_SMIME_CAPABILITIES is struct_CRYPT_SMIME_CAPABILITIES_ptr;
type struct_CMC_TAGGED_ATTRIBUTE;
type struct_CMC_TAGGED_ATTRIBUTE is record
dwBodyPartID : aliased windef.DWORD;
Attribute : aliased CRYPT_ATTRIBUTE;
end record;
pragma Convention (C_Pass_By_Copy, struct_CMC_TAGGED_ATTRIBUTE);
type struct_CMC_TAGGED_ATTRIBUTE_ptr is
access all struct_CMC_TAGGED_ATTRIBUTE;
for struct_CMC_TAGGED_ATTRIBUTE_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CMC_TAGGED_ATTRIBUTE_ptr);
pragma Convention (C, struct_CMC_TAGGED_ATTRIBUTE_ptr);
subtype CMC_TAGGED_ATTRIBUTE is struct_CMC_TAGGED_ATTRIBUTE;
subtype PCMC_TAGGED_ATTRIBUTE is struct_CMC_TAGGED_ATTRIBUTE_ptr;
type struct_CMC_TAGGED_CERT_REQUEST;
type struct_CMC_TAGGED_CERT_REQUEST is record
dwBodyPartID : aliased windef.DWORD;
SignedCertRequest : aliased CRYPT_DER_BLOB;
end record;
pragma Convention (C_Pass_By_Copy, struct_CMC_TAGGED_CERT_REQUEST);
type struct_CMC_TAGGED_CERT_REQUEST_ptr is
access all struct_CMC_TAGGED_CERT_REQUEST;
for struct_CMC_TAGGED_CERT_REQUEST_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CMC_TAGGED_CERT_REQUEST_ptr);
pragma Convention (C, struct_CMC_TAGGED_CERT_REQUEST_ptr);
subtype CMC_TAGGED_CERT_REQUEST is struct_CMC_TAGGED_CERT_REQUEST;
subtype PCMC_TAGGED_CERT_REQUEST is struct_CMC_TAGGED_CERT_REQUEST_ptr;
type struct_CMC_TAGGED_REQUEST;
type union_041bd3a2 (Unchecked_Tag : unsigned_int := 0) is record
case Unchecked_Tag is
when others =>
pTaggedCertRequest : PCMC_TAGGED_CERT_REQUEST;
end case;
end record;
pragma Unchecked_Union (union_041bd3a2);
pragma Convention (C_Pass_By_Copy, union_041bd3a2);
type struct_CMC_TAGGED_REQUEST is record
dwTaggedRequestChoice : aliased windef.DWORD;
anonymous_1 : aliased union_041bd3a2;
end record;
pragma Convention (C_Pass_By_Copy, struct_CMC_TAGGED_REQUEST);
type struct_CMC_TAGGED_REQUEST_ptr is
access all struct_CMC_TAGGED_REQUEST;
for struct_CMC_TAGGED_REQUEST_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CMC_TAGGED_REQUEST_ptr);
pragma Convention (C, struct_CMC_TAGGED_REQUEST_ptr);
subtype CMC_TAGGED_REQUEST is struct_CMC_TAGGED_REQUEST;
subtype PCMC_TAGGED_REQUEST is struct_CMC_TAGGED_REQUEST_ptr;
type struct_CMC_TAGGED_CONTENT_INFO;
type struct_CMC_TAGGED_CONTENT_INFO is record
dwBodyPartID : aliased windef.DWORD;
EncodedContentInfo : aliased CRYPT_DER_BLOB;
end record;
pragma Convention (C_Pass_By_Copy, struct_CMC_TAGGED_CONTENT_INFO);
type struct_CMC_TAGGED_CONTENT_INFO_ptr is
access all struct_CMC_TAGGED_CONTENT_INFO;
for struct_CMC_TAGGED_CONTENT_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CMC_TAGGED_CONTENT_INFO_ptr);
pragma Convention (C, struct_CMC_TAGGED_CONTENT_INFO_ptr);
subtype CMC_TAGGED_CONTENT_INFO is struct_CMC_TAGGED_CONTENT_INFO;
subtype PCMC_TAGGED_CONTENT_INFO is struct_CMC_TAGGED_CONTENT_INFO_ptr;
type struct_CMC_TAGGED_OTHER_MSG;
type struct_CMC_TAGGED_OTHER_MSG is record
dwBodyPartID : aliased windef.DWORD;
pszObjId : aliased winnt.LPSTR;
Value : aliased CRYPT_OBJID_BLOB;
end record;
pragma Convention (C_Pass_By_Copy, struct_CMC_TAGGED_OTHER_MSG);
type struct_CMC_TAGGED_OTHER_MSG_ptr is
access all struct_CMC_TAGGED_OTHER_MSG;
for struct_CMC_TAGGED_OTHER_MSG_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CMC_TAGGED_OTHER_MSG_ptr);
pragma Convention (C, struct_CMC_TAGGED_OTHER_MSG_ptr);
subtype CMC_TAGGED_OTHER_MSG is struct_CMC_TAGGED_OTHER_MSG;
subtype PCMC_TAGGED_OTHER_MSG is struct_CMC_TAGGED_OTHER_MSG_ptr;
type struct_CMC_DATA_INFO;
type struct_CMC_DATA_INFO is record
cTaggedAttribute : aliased windef.DWORD;
rgTaggedAttribute : aliased PCMC_TAGGED_ATTRIBUTE;
cTaggedRequest : aliased windef.DWORD;
rgTaggedRequest : aliased PCMC_TAGGED_REQUEST;
cTaggedContentInfo : aliased windef.DWORD;
rgTaggedContentInfo : aliased PCMC_TAGGED_CONTENT_INFO;
cTaggedOtherMsg : aliased windef.DWORD;
rgTaggedOtherMsg : aliased PCMC_TAGGED_OTHER_MSG;
end record;
pragma Convention (C_Pass_By_Copy, struct_CMC_DATA_INFO);
type struct_CMC_DATA_INFO_ptr is access all struct_CMC_DATA_INFO;
for struct_CMC_DATA_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CMC_DATA_INFO_ptr);
pragma Convention (C, struct_CMC_DATA_INFO_ptr);
subtype CMC_DATA_INFO is struct_CMC_DATA_INFO;
subtype PCMC_DATA_INFO is struct_CMC_DATA_INFO_ptr;
type struct_CMC_RESPONSE_INFO;
type struct_CMC_RESPONSE_INFO is record
cTaggedAttribute : aliased windef.DWORD;
rgTaggedAttribute : aliased PCMC_TAGGED_ATTRIBUTE;
cTaggedContentInfo : aliased windef.DWORD;
rgTaggedContentInfo : aliased PCMC_TAGGED_CONTENT_INFO;
cTaggedOtherMsg : aliased windef.DWORD;
rgTaggedOtherMsg : aliased PCMC_TAGGED_OTHER_MSG;
end record;
pragma Convention (C_Pass_By_Copy, struct_CMC_RESPONSE_INFO);
type struct_CMC_RESPONSE_INFO_ptr is access all struct_CMC_RESPONSE_INFO;
for struct_CMC_RESPONSE_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CMC_RESPONSE_INFO_ptr);
pragma Convention (C, struct_CMC_RESPONSE_INFO_ptr);
subtype CMC_RESPONSE_INFO is struct_CMC_RESPONSE_INFO;
subtype PCMC_RESPONSE_INFO is struct_CMC_RESPONSE_INFO_ptr;
type struct_CMC_PEND_INFO;
type struct_CMC_PEND_INFO is record
PendToken : aliased CRYPT_DATA_BLOB;
PendTime : aliased windef.FILETIME;
end record;
pragma Convention (C_Pass_By_Copy, struct_CMC_PEND_INFO);
type struct_CMC_PEND_INFO_ptr is access all struct_CMC_PEND_INFO;
for struct_CMC_PEND_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CMC_PEND_INFO_ptr);
pragma Convention (C, struct_CMC_PEND_INFO_ptr);
subtype CMC_PEND_INFO is struct_CMC_PEND_INFO;
subtype PCMC_PEND_INFO is struct_CMC_PEND_INFO_ptr;
type struct_CMC_STATUS_INFO;
type union_f81ed9a8 (Unchecked_Tag : unsigned_int := 0) is record
case Unchecked_Tag is
when 0 =>
dwFailInfo : windef.DWORD;
when others =>
pPendInfo : PCMC_PEND_INFO;
end case;
end record;
pragma Unchecked_Union (union_f81ed9a8);
pragma Convention (C_Pass_By_Copy, union_f81ed9a8);
type struct_CMC_STATUS_INFO is record
dwStatus : aliased windef.DWORD;
cBodyList : aliased windef.DWORD;
rgdwBodyList : aliased windef.DWORD_ptr;
pwszStatusString : aliased winnt.LPWSTR;
dwOtherInfoChoice : aliased windef.DWORD;
anonymous_1 : aliased union_f81ed9a8;
end record;
pragma Convention (C_Pass_By_Copy, struct_CMC_STATUS_INFO);
type struct_CMC_STATUS_INFO_ptr is access all struct_CMC_STATUS_INFO;
for struct_CMC_STATUS_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CMC_STATUS_INFO_ptr);
pragma Convention (C, struct_CMC_STATUS_INFO_ptr);
subtype CMC_STATUS_INFO is struct_CMC_STATUS_INFO;
subtype PCMC_STATUS_INFO is struct_CMC_STATUS_INFO_ptr;
type struct_CMC_ADD_EXTENSIONS_INFO;
type struct_CMC_ADD_EXTENSIONS_INFO is record
dwCmcDataReference : aliased windef.DWORD;
cCertReference : aliased windef.DWORD;
rgdwCertReference : aliased windef.DWORD_ptr;
cExtension : aliased windef.DWORD;
rgExtension : aliased PCERT_EXTENSION;
end record;
pragma Convention (C_Pass_By_Copy, struct_CMC_ADD_EXTENSIONS_INFO);
type struct_CMC_ADD_EXTENSIONS_INFO_ptr is
access all struct_CMC_ADD_EXTENSIONS_INFO;
for struct_CMC_ADD_EXTENSIONS_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CMC_ADD_EXTENSIONS_INFO_ptr);
pragma Convention (C, struct_CMC_ADD_EXTENSIONS_INFO_ptr);
subtype CMC_ADD_EXTENSIONS_INFO is struct_CMC_ADD_EXTENSIONS_INFO;
subtype PCMC_ADD_EXTENSIONS_INFO is struct_CMC_ADD_EXTENSIONS_INFO_ptr;
type struct_CMC_ADD_ATTRIBUTES_INFO;
type struct_CMC_ADD_ATTRIBUTES_INFO is record
dwCmcDataReference : aliased windef.DWORD;
cCertReference : aliased windef.DWORD;
rgdwCertReference : aliased windef.DWORD_ptr;
cAttribute : aliased windef.DWORD;
rgAttribute : aliased PCRYPT_ATTRIBUTE;
end record;
pragma Convention (C_Pass_By_Copy, struct_CMC_ADD_ATTRIBUTES_INFO);
type struct_CMC_ADD_ATTRIBUTES_INFO_ptr is
access all struct_CMC_ADD_ATTRIBUTES_INFO;
for struct_CMC_ADD_ATTRIBUTES_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CMC_ADD_ATTRIBUTES_INFO_ptr);
pragma Convention (C, struct_CMC_ADD_ATTRIBUTES_INFO_ptr);
subtype CMC_ADD_ATTRIBUTES_INFO is struct_CMC_ADD_ATTRIBUTES_INFO;
subtype PCMC_ADD_ATTRIBUTES_INFO is struct_CMC_ADD_ATTRIBUTES_INFO_ptr;
type struct_CERT_TEMPLATE_EXT;
type struct_CERT_TEMPLATE_EXT is record
pszObjId : aliased winnt.LPSTR;
dwMajorVersion : aliased windef.DWORD;
fMinorVersion : aliased windef.WINBOOL;
dwMinorVersion : aliased windef.DWORD;
end record;
pragma Convention (C_Pass_By_Copy, struct_CERT_TEMPLATE_EXT);
type struct_CERT_TEMPLATE_EXT_ptr is access all struct_CERT_TEMPLATE_EXT;
for struct_CERT_TEMPLATE_EXT_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_TEMPLATE_EXT_ptr);
pragma Convention (C, struct_CERT_TEMPLATE_EXT_ptr);
subtype CERT_TEMPLATE_EXT is struct_CERT_TEMPLATE_EXT;
subtype PCERT_TEMPLATE_EXT is struct_CERT_TEMPLATE_EXT_ptr;
subtype HCRYPTOIDFUNCSET is void_ptr;
subtype HCRYPTOIDFUNCADDR is void_ptr;
subtype HCRYPTOIDFUNCADDR_ptr is void_ptr_ptr;
type struct_CRYPT_OID_FUNC_ENTRY;
type struct_CRYPT_OID_FUNC_ENTRY is record
pszOID : aliased winnt.LPCSTR;
pvFuncAddr : aliased void_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_CRYPT_OID_FUNC_ENTRY);
type struct_CRYPT_OID_FUNC_ENTRY_ptr is
access all struct_CRYPT_OID_FUNC_ENTRY;
for struct_CRYPT_OID_FUNC_ENTRY_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_OID_FUNC_ENTRY_ptr);
pragma Convention (C, struct_CRYPT_OID_FUNC_ENTRY_ptr);
type struct_CRYPT_OID_FUNC_ENTRY_array is array (size_t range <>) of
aliased struct_CRYPT_OID_FUNC_ENTRY;
pragma Convention (C, struct_CRYPT_OID_FUNC_ENTRY_array);
subtype CRYPT_OID_FUNC_ENTRY is struct_CRYPT_OID_FUNC_ENTRY;
subtype CRYPT_OID_FUNC_ENTRY_array is struct_CRYPT_OID_FUNC_ENTRY_array;
subtype CRYPT_OID_FUNC_ENTRY_ptr is struct_CRYPT_OID_FUNC_ENTRY_ptr;
subtype PCRYPT_OID_FUNC_ENTRY is struct_CRYPT_OID_FUNC_ENTRY_ptr;
function CryptInstallOIDFunctionAddress (
hModule : access windef.struct_HINSTANCE;
dwEncodingType : windef.DWORD;
pszFuncName : access constant winnt.C_CHAR; cFuncEntry : windef.DWORD;
rgFuncEntry : access CRYPT_OID_FUNC_ENTRY; dwFlags : windef.DWORD)
return windef.WINBOOL;
pragma Import (C, CryptInstallOIDFunctionAddress,
"CryptInstallOIDFunctionAddress");
function CryptInitOIDFunctionSet (
pszFuncName : access constant winnt.C_CHAR; dwFlags : windef.DWORD)
return HCRYPTOIDFUNCSET;
pragma Import (C, CryptInitOIDFunctionSet, "CryptInitOIDFunctionSet");
function CryptGetOIDFunctionAddress (hFuncSet : HCRYPTOIDFUNCSET;
dwEncodingType : windef.DWORD; pszOID : access constant winnt.C_CHAR;
dwFlags : windef.DWORD; ppvFuncAddr : access void_ptr;
phFuncAddr : access HCRYPTOIDFUNCADDR) return windef.WINBOOL;
pragma Import (C, CryptGetOIDFunctionAddress,
"CryptGetOIDFunctionAddress");
function CryptGetDefaultOIDDllList (hFuncSet : HCRYPTOIDFUNCSET;
dwEncodingType : windef.DWORD; pwszDllList : access winnt.WCHAR;
pcchDllList : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, CryptGetDefaultOIDDllList, "CryptGetDefaultOIDDllList");
function CryptGetDefaultOIDFunctionAddress (hFuncSet : HCRYPTOIDFUNCSET;
dwEncodingType : windef.DWORD; pwszDll : access constant winnt.WCHAR;
dwFlags : windef.DWORD; ppvFuncAddr : access void_ptr;
phFuncAddr : access HCRYPTOIDFUNCADDR) return windef.WINBOOL;
pragma Import (C, CryptGetDefaultOIDFunctionAddress,
"CryptGetDefaultOIDFunctionAddress");
function CryptFreeOIDFunctionAddress (hFuncAddr : HCRYPTOIDFUNCADDR;
dwFlags : windef.DWORD) return windef.WINBOOL;
pragma Import (C, CryptFreeOIDFunctionAddress,
"CryptFreeOIDFunctionAddress");
function CryptRegisterOIDFunction (dwEncodingType : windef.DWORD;
pszFuncName : access constant winnt.C_CHAR;
pszOID : access constant winnt.C_CHAR;
pwszDll : access constant winnt.WCHAR;
pszOverrideFuncName : access constant winnt.C_CHAR)
return windef.WINBOOL;
pragma Import (C, CryptRegisterOIDFunction, "CryptRegisterOIDFunction");
function CryptUnregisterOIDFunction (dwEncodingType : windef.DWORD;
pszFuncName : access constant winnt.C_CHAR;
pszOID : access constant winnt.C_CHAR) return windef.WINBOOL;
pragma Import (C, CryptUnregisterOIDFunction,
"CryptUnregisterOIDFunction");
function CryptRegisterDefaultOIDFunction (dwEncodingType : windef.DWORD;
pszFuncName : access constant winnt.C_CHAR; dwIndex : windef.DWORD;
pwszDll : access constant winnt.WCHAR) return windef.WINBOOL;
pragma Import (C, CryptRegisterDefaultOIDFunction,
"CryptRegisterDefaultOIDFunction");
function CryptUnregisterDefaultOIDFunction (dwEncodingType : windef.DWORD;
pszFuncName : access constant winnt.C_CHAR;
pwszDll : access constant winnt.WCHAR) return windef.WINBOOL;
pragma Import (C, CryptUnregisterDefaultOIDFunction,
"CryptUnregisterDefaultOIDFunction");
function CryptSetOIDFunctionValue (dwEncodingType : windef.DWORD;
pszFuncName : access constant winnt.C_CHAR;
pszOID : access constant winnt.C_CHAR;
pwszValueName : access constant winnt.WCHAR;
dwValueType : windef.DWORD; pbValueData : access constant windef.BYTE;
cbValueData : windef.DWORD) return windef.WINBOOL;
pragma Import (C, CryptSetOIDFunctionValue, "CryptSetOIDFunctionValue");
function CryptGetOIDFunctionValue (dwEncodingType : windef.DWORD;
pszFuncName : access constant winnt.C_CHAR;
pszOID : access constant winnt.C_CHAR;
pwszValueName : access constant winnt.WCHAR;
pdwValueType : access windef.DWORD; pbValueData : access windef.BYTE;
pcbValueData : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, CryptGetOIDFunctionValue, "CryptGetOIDFunctionValue");
type access_99e536e9 is access function (dwEncodingType : windef.DWORD;
pszFuncName : access constant winnt.C_CHAR;
pszOID : access constant winnt.C_CHAR; cValue : windef.DWORD;
rgdwValueType : access windef.DWORD;
rgpwszValueName : access winnt.LPCWSTR;
rgpbValueData : access windef.BYTE_const_ptr;
rgcbValueData : access windef.DWORD; pvArg : void_ptr)
return windef.WINBOOL;
pragma Convention (C, access_99e536e9);
subtype PFN_CRYPT_ENUM_OID_FUNC is access_99e536e9;
function CryptEnumOIDFunction (dwEncodingType : windef.DWORD;
pszFuncName : access constant winnt.C_CHAR;
pszOID : access constant winnt.C_CHAR; dwFlags : windef.DWORD;
pvArg : void_ptr; pfnEnumOIDFunc : PFN_CRYPT_ENUM_OID_FUNC)
return windef.WINBOOL;
pragma Import (C, CryptEnumOIDFunction, "CryptEnumOIDFunction");
type struct_CRYPT_OID_INFO;
type union_68e0b7b2 (Unchecked_Tag : unsigned_int := 0) is record
case Unchecked_Tag is
when 0 =>
dwValue : windef.DWORD;
when 1 =>
Algid : ALG_ID;
when others =>
dwLength : windef.DWORD;
end case;
end record;
pragma Unchecked_Union (union_68e0b7b2);
pragma Convention (C_Pass_By_Copy, union_68e0b7b2);
type struct_CRYPT_OID_INFO is record
cbSize : aliased windef.DWORD;
pszOID : aliased winnt.LPCSTR;
pwszName : aliased winnt.LPCWSTR;
dwGroupId : aliased windef.DWORD;
anonymous_1 : aliased union_68e0b7b2;
ExtraInfo : aliased CRYPT_DATA_BLOB;
end record;
pragma Convention (C_Pass_By_Copy, struct_CRYPT_OID_INFO);
type struct_CRYPT_OID_INFO_ptr is access all struct_CRYPT_OID_INFO;
for struct_CRYPT_OID_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_OID_INFO_ptr);
pragma Convention (C, struct_CRYPT_OID_INFO_ptr);
type struct_CRYPT_OID_INFO_const_ptr is
access constant struct_CRYPT_OID_INFO;
for struct_CRYPT_OID_INFO_const_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_OID_INFO_const_ptr);
pragma Convention (C, struct_CRYPT_OID_INFO_const_ptr);
subtype CRYPT_OID_INFO is struct_CRYPT_OID_INFO;
subtype CRYPT_OID_INFO_const_ptr is struct_CRYPT_OID_INFO_const_ptr;
subtype PCRYPT_OID_INFO is struct_CRYPT_OID_INFO_ptr;
subtype CCRYPT_OID_INFO is CRYPT_OID_INFO;
subtype PCCRYPT_OID_INFO is CRYPT_OID_INFO_const_ptr;
function CryptFindOIDInfo (dwKeyType : windef.DWORD; pvKey : void_ptr;
dwGroupId : windef.DWORD) return PCCRYPT_OID_INFO;
pragma Import (C, CryptFindOIDInfo, "CryptFindOIDInfo");
function CryptRegisterOIDInfo (pInfo : access constant CRYPT_OID_INFO;
dwFlags : windef.DWORD) return windef.WINBOOL;
pragma Import (C, CryptRegisterOIDInfo, "CryptRegisterOIDInfo");
function CryptUnregisterOIDInfo (pInfo : access constant CRYPT_OID_INFO)
return windef.WINBOOL;
pragma Import (C, CryptUnregisterOIDInfo, "CryptUnregisterOIDInfo");
type access_467cbed4 is access function (
pInfo : access constant CRYPT_OID_INFO; pvArg : void_ptr)
return windef.WINBOOL;
pragma Convention (C, access_467cbed4);
subtype PFN_CRYPT_ENUM_OID_INFO is access_467cbed4;
function CryptEnumOIDInfo (dwGroupId : windef.DWORD;
dwFlags : windef.DWORD; pvArg : void_ptr;
pfnEnumOIDInfo : PFN_CRYPT_ENUM_OID_INFO) return windef.WINBOOL;
pragma Import (C, CryptEnumOIDInfo, "CryptEnumOIDInfo");
function CryptFindLocalizedName (
pwszCryptName : access constant winnt.WCHAR) return winnt.LPCWSTR;
pragma Import (C, CryptFindLocalizedName, "CryptFindLocalizedName");
subtype HCRYPTMSG is void_ptr;
subtype HCRYPTMSG_ptr is void_ptr_ptr;
type struct_CERT_ISSUER_SERIAL_NUMBER;
type struct_CERT_ISSUER_SERIAL_NUMBER is record
Issuer : aliased CERT_NAME_BLOB;
SerialNumber : aliased CRYPT_INTEGER_BLOB;
end record;
pragma Convention (C_Pass_By_Copy, struct_CERT_ISSUER_SERIAL_NUMBER);
type struct_CERT_ISSUER_SERIAL_NUMBER_ptr is
access all struct_CERT_ISSUER_SERIAL_NUMBER;
for struct_CERT_ISSUER_SERIAL_NUMBER_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_ISSUER_SERIAL_NUMBER_ptr);
pragma Convention (C, struct_CERT_ISSUER_SERIAL_NUMBER_ptr);
subtype CERT_ISSUER_SERIAL_NUMBER is struct_CERT_ISSUER_SERIAL_NUMBER;
subtype PCERT_ISSUER_SERIAL_NUMBER is
struct_CERT_ISSUER_SERIAL_NUMBER_ptr;
type struct_CERT_ID;
type union_c74dee71 (Unchecked_Tag : unsigned_int := 0) is record
case Unchecked_Tag is
when 0 =>
IssuerSerialNumber : CERT_ISSUER_SERIAL_NUMBER;
when 1 =>
KeyId : CRYPT_HASH_BLOB;
when others =>
HashId : CRYPT_HASH_BLOB;
end case;
end record;
pragma Unchecked_Union (union_c74dee71);
pragma Convention (C_Pass_By_Copy, union_c74dee71);
type struct_CERT_ID is record
dwIdChoice : aliased windef.DWORD;
anonymous_1 : aliased union_c74dee71;
end record;
pragma Convention (C_Pass_By_Copy, struct_CERT_ID);
type struct_CERT_ID_ptr is access all struct_CERT_ID;
for struct_CERT_ID_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_ID_ptr);
pragma Convention (C, struct_CERT_ID_ptr);
subtype CERT_ID is struct_CERT_ID;
subtype PCERT_ID is struct_CERT_ID_ptr;
type struct_CMSG_SIGNER_ENCODE_INFO;
type struct_CMSG_SIGNER_ENCODE_INFO is record
cbSize : aliased windef.DWORD;
pCertInfo : aliased PCERT_INFO;
hCryptProv : aliased wincrypt.HCRYPTPROV;
dwKeySpec : aliased windef.DWORD;
HashAlgorithm : aliased CRYPT_ALGORITHM_IDENTIFIER;
pvHashAuxInfo : aliased void_ptr;
cAuthAttr : aliased windef.DWORD;
rgAuthAttr : aliased PCRYPT_ATTRIBUTE;
cUnauthAttr : aliased windef.DWORD;
rgUnauthAttr : aliased PCRYPT_ATTRIBUTE;
end record;
pragma Convention (C_Pass_By_Copy, struct_CMSG_SIGNER_ENCODE_INFO);
type struct_CMSG_SIGNER_ENCODE_INFO_ptr is
access all struct_CMSG_SIGNER_ENCODE_INFO;
for struct_CMSG_SIGNER_ENCODE_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CMSG_SIGNER_ENCODE_INFO_ptr);
pragma Convention (C, struct_CMSG_SIGNER_ENCODE_INFO_ptr);
subtype CMSG_SIGNER_ENCODE_INFO is struct_CMSG_SIGNER_ENCODE_INFO;
subtype PCMSG_SIGNER_ENCODE_INFO is struct_CMSG_SIGNER_ENCODE_INFO_ptr;
type struct_CMSG_SIGNED_ENCODE_INFO;
type struct_CMSG_SIGNED_ENCODE_INFO is record
cbSize : aliased windef.DWORD;
cSigners : aliased windef.DWORD;
rgSigners : aliased PCMSG_SIGNER_ENCODE_INFO;
cCertEncoded : aliased windef.DWORD;
rgCertEncoded : aliased PCERT_BLOB;
cCrlEncoded : aliased windef.DWORD;
rgCrlEncoded : aliased PCRL_BLOB;
end record;
pragma Convention (C_Pass_By_Copy, struct_CMSG_SIGNED_ENCODE_INFO);
type struct_CMSG_SIGNED_ENCODE_INFO_ptr is
access all struct_CMSG_SIGNED_ENCODE_INFO;
for struct_CMSG_SIGNED_ENCODE_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CMSG_SIGNED_ENCODE_INFO_ptr);
pragma Convention (C, struct_CMSG_SIGNED_ENCODE_INFO_ptr);
subtype CMSG_SIGNED_ENCODE_INFO is struct_CMSG_SIGNED_ENCODE_INFO;
subtype PCMSG_SIGNED_ENCODE_INFO is struct_CMSG_SIGNED_ENCODE_INFO_ptr;
type struct_CMSG_RECIPIENT_ENCODE_INFO;
type struct_CMSG_RECIPIENT_ENCODE_INFO_ptr is
access all struct_CMSG_RECIPIENT_ENCODE_INFO;
for struct_CMSG_RECIPIENT_ENCODE_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CMSG_RECIPIENT_ENCODE_INFO_ptr);
pragma Convention (C, struct_CMSG_RECIPIENT_ENCODE_INFO_ptr);
subtype CMSG_RECIPIENT_ENCODE_INFO is struct_CMSG_RECIPIENT_ENCODE_INFO;
subtype PCMSG_RECIPIENT_ENCODE_INFO is
struct_CMSG_RECIPIENT_ENCODE_INFO_ptr;
type struct_CMSG_ENVELOPED_ENCODE_INFO;
type struct_CMSG_ENVELOPED_ENCODE_INFO is record
cbSize : aliased windef.DWORD;
hCryptProv : aliased wincrypt.HCRYPTPROV;
ContentEncryptionAlgorithm : aliased CRYPT_ALGORITHM_IDENTIFIER;
pvEncryptionAuxInfo : aliased void_ptr;
cRecipients : aliased windef.DWORD;
rgpRecipients : aliased PCERT_INFO_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_CMSG_ENVELOPED_ENCODE_INFO);
type struct_CMSG_ENVELOPED_ENCODE_INFO_ptr is
access all struct_CMSG_ENVELOPED_ENCODE_INFO;
for struct_CMSG_ENVELOPED_ENCODE_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CMSG_ENVELOPED_ENCODE_INFO_ptr);
pragma Convention (C, struct_CMSG_ENVELOPED_ENCODE_INFO_ptr);
subtype CMSG_ENVELOPED_ENCODE_INFO is struct_CMSG_ENVELOPED_ENCODE_INFO;
subtype PCMSG_ENVELOPED_ENCODE_INFO is
struct_CMSG_ENVELOPED_ENCODE_INFO_ptr;
type struct_CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO;
type struct_CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO is record
cbSize : aliased windef.DWORD;
KeyEncryptionAlgorithm : aliased CRYPT_ALGORITHM_IDENTIFIER;
pvKeyEncryptionAuxInfo : aliased void_ptr;
hCryptProv : aliased wincrypt.HCRYPTPROV;
RecipientPublicKey : aliased CRYPT_BIT_BLOB;
RecipientId : aliased CERT_ID;
end record;
pragma Convention (C_Pass_By_Copy,
struct_CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO);
type struct_CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO_ptr is
access all struct_CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO;
for struct_CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (
struct_CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO_ptr);
pragma Convention (C, struct_CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO_ptr);
subtype CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO is
struct_CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO;
subtype PCMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO is
struct_CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO_ptr;
type struct_CMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO;
type struct_CMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO is record
cbSize : aliased windef.DWORD;
RecipientPublicKey : aliased CRYPT_BIT_BLOB;
RecipientId : aliased CERT_ID;
Date : aliased windef.FILETIME;
pOtherAttr : aliased PCRYPT_ATTRIBUTE_TYPE_VALUE;
end record;
pragma Convention (C_Pass_By_Copy,
struct_CMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO);
type struct_CMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO_ptr is
access all struct_CMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO;
for struct_CMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO_ptr'Storage_Size
use 0;
pragma No_Strict_Aliasing (
struct_CMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO_ptr);
pragma Convention (C,
struct_CMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO_ptr);
type struct_CMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO_ptr_ptr is
access all struct_CMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO_ptr;
for struct_CMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO_ptr_ptr'Storage_Size
use 0;
pragma No_Strict_Aliasing (
struct_CMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO_ptr_ptr);
pragma Convention (C,
struct_CMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO_ptr_ptr);
subtype CMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO is
struct_CMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO;
subtype PCMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO is
struct_CMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO_ptr;
subtype PCMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO_ptr is
struct_CMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO_ptr_ptr;
type struct_CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO;
type union_e7801507 (Unchecked_Tag : unsigned_int := 0) is record
case Unchecked_Tag is
when 0 =>
pEphemeralAlgorithm : PCRYPT_ALGORITHM_IDENTIFIER;
when others =>
pSenderId : PCERT_ID;
end case;
end record;
pragma Unchecked_Union (union_e7801507);
pragma Convention (C_Pass_By_Copy, union_e7801507);
type struct_CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO is record
cbSize : aliased windef.DWORD;
KeyEncryptionAlgorithm : aliased CRYPT_ALGORITHM_IDENTIFIER;
pvKeyEncryptionAuxInfo : aliased void_ptr;
KeyWrapAlgorithm : aliased CRYPT_ALGORITHM_IDENTIFIER;
pvKeyWrapAuxInfo : aliased void_ptr;
hCryptProv : aliased wincrypt.HCRYPTPROV;
dwKeySpec : aliased windef.DWORD;
dwKeyChoice : aliased windef.DWORD;
anonymous_1 : aliased union_e7801507;
UserKeyingMaterial : aliased CRYPT_DATA_BLOB;
cRecipientEncryptedKeys : aliased windef.DWORD;
rgpRecipientEncryptedKeys :
aliased PCMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO_ptr;
end record;
pragma Convention (C_Pass_By_Copy,
struct_CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO);
type struct_CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO_ptr is
access all struct_CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO;
for struct_CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (
struct_CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO_ptr);
pragma Convention (C, struct_CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO_ptr);
subtype CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO is
struct_CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO;
subtype PCMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO is
struct_CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO_ptr;
type struct_CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO;
type union_c4f0b946 (Unchecked_Tag : unsigned_int := 0) is record
case Unchecked_Tag is
when 0 =>
hKeyEncryptionKey : HCRYPTKEY;
when others =>
pvKeyEncryptionKey : void_ptr;
end case;
end record;
pragma Unchecked_Union (union_c4f0b946);
pragma Convention (C_Pass_By_Copy, union_c4f0b946);
type struct_CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO is record
cbSize : aliased windef.DWORD;
KeyEncryptionAlgorithm : aliased CRYPT_ALGORITHM_IDENTIFIER;
pvKeyEncryptionAuxInfo : aliased void_ptr;
hCryptProv : aliased wincrypt.HCRYPTPROV;
dwKeyChoice : aliased windef.DWORD;
anonymous_1 : aliased union_c4f0b946;
KeyId : aliased CRYPT_DATA_BLOB;
Date : aliased windef.FILETIME;
pOtherAttr : aliased PCRYPT_ATTRIBUTE_TYPE_VALUE;
end record;
pragma Convention (C_Pass_By_Copy,
struct_CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO);
type struct_CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO_ptr is
access all struct_CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO;
for struct_CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (
struct_CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO_ptr);
pragma Convention (C, struct_CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO_ptr);
subtype CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO is
struct_CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO;
subtype PCMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO is
struct_CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO_ptr;
type union_0d9bf9a5 (Unchecked_Tag : unsigned_int := 0) is record
case Unchecked_Tag is
when 0 =>
pKeyTrans : PCMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO;
when 1 =>
pKeyAgree : PCMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO;
when others =>
pMailList : PCMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO;
end case;
end record;
pragma Unchecked_Union (union_0d9bf9a5);
pragma Convention (C_Pass_By_Copy, union_0d9bf9a5);
type struct_CMSG_RECIPIENT_ENCODE_INFO is record
dwRecipientChoice : aliased windef.DWORD;
anonymous_1 : aliased union_0d9bf9a5;
end record;
pragma Convention (C_Pass_By_Copy, struct_CMSG_RECIPIENT_ENCODE_INFO);
type struct_CMSG_RC2_AUX_INFO;
type struct_CMSG_RC2_AUX_INFO is record
cbSize : aliased windef.DWORD;
dwBitLen : aliased windef.DWORD;
end record;
pragma Convention (C_Pass_By_Copy, struct_CMSG_RC2_AUX_INFO);
type struct_CMSG_RC2_AUX_INFO_ptr is access all struct_CMSG_RC2_AUX_INFO;
for struct_CMSG_RC2_AUX_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CMSG_RC2_AUX_INFO_ptr);
pragma Convention (C, struct_CMSG_RC2_AUX_INFO_ptr);
subtype CMSG_RC2_AUX_INFO is struct_CMSG_RC2_AUX_INFO;
subtype PCMSG_RC2_AUX_INFO is struct_CMSG_RC2_AUX_INFO_ptr;
type struct_CMSG_SP3_COMPATIBLE_AUX_INFO;
type struct_CMSG_SP3_COMPATIBLE_AUX_INFO is record
cbSize : aliased windef.DWORD;
dwFlags : aliased windef.DWORD;
end record;
pragma Convention (C_Pass_By_Copy, struct_CMSG_SP3_COMPATIBLE_AUX_INFO);
type struct_CMSG_SP3_COMPATIBLE_AUX_INFO_ptr is
access all struct_CMSG_SP3_COMPATIBLE_AUX_INFO;
for struct_CMSG_SP3_COMPATIBLE_AUX_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CMSG_SP3_COMPATIBLE_AUX_INFO_ptr);
pragma Convention (C, struct_CMSG_SP3_COMPATIBLE_AUX_INFO_ptr);
subtype CMSG_SP3_COMPATIBLE_AUX_INFO is
struct_CMSG_SP3_COMPATIBLE_AUX_INFO;
subtype PCMSG_SP3_COMPATIBLE_AUX_INFO is
struct_CMSG_SP3_COMPATIBLE_AUX_INFO_ptr;
type struct_CMSG_RC4_AUX_INFO;
type struct_CMSG_RC4_AUX_INFO is record
cbSize : aliased windef.DWORD;
dwBitLen : aliased windef.DWORD;
end record;
pragma Convention (C_Pass_By_Copy, struct_CMSG_RC4_AUX_INFO);
type struct_CMSG_RC4_AUX_INFO_ptr is access all struct_CMSG_RC4_AUX_INFO;
for struct_CMSG_RC4_AUX_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CMSG_RC4_AUX_INFO_ptr);
pragma Convention (C, struct_CMSG_RC4_AUX_INFO_ptr);
subtype CMSG_RC4_AUX_INFO is struct_CMSG_RC4_AUX_INFO;
subtype PCMSG_RC4_AUX_INFO is struct_CMSG_RC4_AUX_INFO_ptr;
type struct_CMSG_SIGNED_AND_ENVELOPED_ENCODE_INFO;
type struct_CMSG_SIGNED_AND_ENVELOPED_ENCODE_INFO is record
cbSize : aliased windef.DWORD;
SignedInfo : aliased CMSG_SIGNED_ENCODE_INFO;
EnvelopedInfo : aliased CMSG_ENVELOPED_ENCODE_INFO;
end record;
pragma Convention (C_Pass_By_Copy,
struct_CMSG_SIGNED_AND_ENVELOPED_ENCODE_INFO);
type struct_CMSG_SIGNED_AND_ENVELOPED_ENCODE_INFO_ptr is
access all struct_CMSG_SIGNED_AND_ENVELOPED_ENCODE_INFO;
for struct_CMSG_SIGNED_AND_ENVELOPED_ENCODE_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (
struct_CMSG_SIGNED_AND_ENVELOPED_ENCODE_INFO_ptr);
pragma Convention (C, struct_CMSG_SIGNED_AND_ENVELOPED_ENCODE_INFO_ptr);
subtype CMSG_SIGNED_AND_ENVELOPED_ENCODE_INFO is
struct_CMSG_SIGNED_AND_ENVELOPED_ENCODE_INFO;
subtype PCMSG_SIGNED_AND_ENVELOPED_ENCODE_INFO is
struct_CMSG_SIGNED_AND_ENVELOPED_ENCODE_INFO_ptr;
type struct_CMSG_HASHED_ENCODE_INFO;
type struct_CMSG_HASHED_ENCODE_INFO is record
cbSize : aliased windef.DWORD;
hCryptProv : aliased wincrypt.HCRYPTPROV;
HashAlgorithm : aliased CRYPT_ALGORITHM_IDENTIFIER;
pvHashAuxInfo : aliased void_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_CMSG_HASHED_ENCODE_INFO);
type struct_CMSG_HASHED_ENCODE_INFO_ptr is
access all struct_CMSG_HASHED_ENCODE_INFO;
for struct_CMSG_HASHED_ENCODE_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CMSG_HASHED_ENCODE_INFO_ptr);
pragma Convention (C, struct_CMSG_HASHED_ENCODE_INFO_ptr);
subtype CMSG_HASHED_ENCODE_INFO is struct_CMSG_HASHED_ENCODE_INFO;
subtype PCMSG_HASHED_ENCODE_INFO is struct_CMSG_HASHED_ENCODE_INFO_ptr;
type struct_CMSG_ENCRYPTED_ENCODE_INFO;
type struct_CMSG_ENCRYPTED_ENCODE_INFO is record
cbSize : aliased windef.DWORD;
ContentEncryptionAlgorithm : aliased CRYPT_ALGORITHM_IDENTIFIER;
pvEncryptionAuxInfo : aliased void_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_CMSG_ENCRYPTED_ENCODE_INFO);
type struct_CMSG_ENCRYPTED_ENCODE_INFO_ptr is
access all struct_CMSG_ENCRYPTED_ENCODE_INFO;
for struct_CMSG_ENCRYPTED_ENCODE_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CMSG_ENCRYPTED_ENCODE_INFO_ptr);
pragma Convention (C, struct_CMSG_ENCRYPTED_ENCODE_INFO_ptr);
subtype CMSG_ENCRYPTED_ENCODE_INFO is struct_CMSG_ENCRYPTED_ENCODE_INFO;
subtype PCMSG_ENCRYPTED_ENCODE_INFO is
struct_CMSG_ENCRYPTED_ENCODE_INFO_ptr;
type access_05c15392 is access function (pvArg : void_const_ptr;
pbData : access windef.BYTE; cbData : windef.DWORD;
fFinal : windef.WINBOOL) return windef.WINBOOL;
pragma Convention (C, access_05c15392);
subtype PFN_CMSG_STREAM_OUTPUT is access_05c15392;
type struct_CMSG_STREAM_INFO;
type struct_CMSG_STREAM_INFO is record
cbContent : aliased windef.DWORD;
pfnStreamOutput : aliased PFN_CMSG_STREAM_OUTPUT;
pvArg : aliased void_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_CMSG_STREAM_INFO);
type struct_CMSG_STREAM_INFO_ptr is access all struct_CMSG_STREAM_INFO;
for struct_CMSG_STREAM_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CMSG_STREAM_INFO_ptr);
pragma Convention (C, struct_CMSG_STREAM_INFO_ptr);
subtype CMSG_STREAM_INFO is struct_CMSG_STREAM_INFO;
subtype PCMSG_STREAM_INFO is struct_CMSG_STREAM_INFO_ptr;
function CryptMsgOpenToEncode (dwMsgEncodingType : windef.DWORD;
dwFlags : windef.DWORD; dwMsgType : windef.DWORD;
pvMsgEncodeInfo : void_const_ptr;
pszInnerContentObjID : access winnt.C_CHAR;
pStreamInfo : access struct_CMSG_STREAM_INFO) return HCRYPTMSG;
pragma Import (C, CryptMsgOpenToEncode, "CryptMsgOpenToEncode");
function CryptMsgCalculateEncodedLength (dwMsgEncodingType : windef.DWORD;
dwFlags : windef.DWORD; dwMsgType : windef.DWORD;
pvMsgEncodeInfo : void_const_ptr;
pszInnerContentObjID : access winnt.C_CHAR; cbData : windef.DWORD)
return windef.DWORD;
pragma Import (C, CryptMsgCalculateEncodedLength,
"CryptMsgCalculateEncodedLength");
function CryptMsgOpenToDecode (dwMsgEncodingType : windef.DWORD;
dwFlags : windef.DWORD; dwMsgType : windef.DWORD;
hCryptProv : wincrypt.HCRYPTPROV;
pRecipientInfo : access struct_CERT_INFO;
pStreamInfo : access struct_CMSG_STREAM_INFO) return HCRYPTMSG;
pragma Import (C, CryptMsgOpenToDecode, "CryptMsgOpenToDecode");
function CryptMsgDuplicate (hCryptMsg : wincrypt.HCRYPTMSG)
return wincrypt.HCRYPTMSG;
pragma Import (C, CryptMsgDuplicate, "CryptMsgDuplicate");
function CryptMsgClose (hCryptMsg : wincrypt.HCRYPTMSG)
return windef.WINBOOL;
pragma Import (C, CryptMsgClose, "CryptMsgClose");
function CryptMsgUpdate (hCryptMsg : wincrypt.HCRYPTMSG;
pbData : access constant windef.BYTE; cbData : windef.DWORD;
fFinal : windef.WINBOOL) return windef.WINBOOL;
pragma Import (C, CryptMsgUpdate, "CryptMsgUpdate");
function CryptMsgGetParam (hCryptMsg : wincrypt.HCRYPTMSG;
dwParamType : windef.DWORD; dwIndex : windef.DWORD; pvData : void_ptr;
pcbData : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, CryptMsgGetParam, "CryptMsgGetParam");
type struct_CMSG_SIGNER_INFO;
type struct_CMSG_SIGNER_INFO is record
dwVersion : aliased windef.DWORD;
Issuer : aliased CERT_NAME_BLOB;
SerialNumber : aliased CRYPT_INTEGER_BLOB;
HashAlgorithm : aliased CRYPT_ALGORITHM_IDENTIFIER;
HashEncryptionAlgorithm : aliased CRYPT_ALGORITHM_IDENTIFIER;
EncryptedHash : aliased CRYPT_DATA_BLOB;
AuthAttrs : aliased CRYPT_ATTRIBUTES;
UnauthAttrs : aliased CRYPT_ATTRIBUTES;
end record;
pragma Convention (C_Pass_By_Copy, struct_CMSG_SIGNER_INFO);
type struct_CMSG_SIGNER_INFO_ptr is access all struct_CMSG_SIGNER_INFO;
for struct_CMSG_SIGNER_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CMSG_SIGNER_INFO_ptr);
pragma Convention (C, struct_CMSG_SIGNER_INFO_ptr);
subtype CMSG_SIGNER_INFO is struct_CMSG_SIGNER_INFO;
subtype PCMSG_SIGNER_INFO is struct_CMSG_SIGNER_INFO_ptr;
type struct_CMSG_CMS_SIGNER_INFO;
type struct_CMSG_CMS_SIGNER_INFO is record
dwVersion : aliased windef.DWORD;
SignerId : aliased CERT_ID;
HashAlgorithm : aliased CRYPT_ALGORITHM_IDENTIFIER;
HashEncryptionAlgorithm : aliased CRYPT_ALGORITHM_IDENTIFIER;
EncryptedHash : aliased CRYPT_DATA_BLOB;
AuthAttrs : aliased CRYPT_ATTRIBUTES;
UnauthAttrs : aliased CRYPT_ATTRIBUTES;
end record;
pragma Convention (C_Pass_By_Copy, struct_CMSG_CMS_SIGNER_INFO);
type struct_CMSG_CMS_SIGNER_INFO_ptr is
access all struct_CMSG_CMS_SIGNER_INFO;
for struct_CMSG_CMS_SIGNER_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CMSG_CMS_SIGNER_INFO_ptr);
pragma Convention (C, struct_CMSG_CMS_SIGNER_INFO_ptr);
subtype CMSG_CMS_SIGNER_INFO is struct_CMSG_CMS_SIGNER_INFO;
subtype PCMSG_CMS_SIGNER_INFO is struct_CMSG_CMS_SIGNER_INFO_ptr;
subtype CMSG_ATTR is CRYPT_ATTRIBUTES;
subtype PCMSG_ATTR is CRYPT_ATTRIBUTES_ptr;
type struct_CMSG_KEY_TRANS_RECIPIENT_INFO;
type struct_CMSG_KEY_TRANS_RECIPIENT_INFO is record
dwVersion : aliased windef.DWORD;
RecipientId : aliased CERT_ID;
KeyEncryptionAlgorithm : aliased CRYPT_ALGORITHM_IDENTIFIER;
EncryptedKey : aliased CRYPT_DATA_BLOB;
end record;
pragma Convention (C_Pass_By_Copy, struct_CMSG_KEY_TRANS_RECIPIENT_INFO);
type struct_CMSG_KEY_TRANS_RECIPIENT_INFO_ptr is
access all struct_CMSG_KEY_TRANS_RECIPIENT_INFO;
for struct_CMSG_KEY_TRANS_RECIPIENT_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CMSG_KEY_TRANS_RECIPIENT_INFO_ptr);
pragma Convention (C, struct_CMSG_KEY_TRANS_RECIPIENT_INFO_ptr);
subtype CMSG_KEY_TRANS_RECIPIENT_INFO is
struct_CMSG_KEY_TRANS_RECIPIENT_INFO;
subtype PCMSG_KEY_TRANS_RECIPIENT_INFO is
struct_CMSG_KEY_TRANS_RECIPIENT_INFO_ptr;
type struct_CMSG_RECIPIENT_ENCRYPTED_KEY_INFO;
type struct_CMSG_RECIPIENT_ENCRYPTED_KEY_INFO is record
RecipientId : aliased CERT_ID;
EncryptedKey : aliased CRYPT_DATA_BLOB;
Date : aliased windef.FILETIME;
pOtherAttr : aliased PCRYPT_ATTRIBUTE_TYPE_VALUE;
end record;
pragma Convention (C_Pass_By_Copy,
struct_CMSG_RECIPIENT_ENCRYPTED_KEY_INFO);
type struct_CMSG_RECIPIENT_ENCRYPTED_KEY_INFO_ptr is
access all struct_CMSG_RECIPIENT_ENCRYPTED_KEY_INFO;
for struct_CMSG_RECIPIENT_ENCRYPTED_KEY_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CMSG_RECIPIENT_ENCRYPTED_KEY_INFO_ptr);
pragma Convention (C, struct_CMSG_RECIPIENT_ENCRYPTED_KEY_INFO_ptr);
type struct_CMSG_RECIPIENT_ENCRYPTED_KEY_INFO_ptr_ptr is
access all struct_CMSG_RECIPIENT_ENCRYPTED_KEY_INFO_ptr;
for struct_CMSG_RECIPIENT_ENCRYPTED_KEY_INFO_ptr_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (
struct_CMSG_RECIPIENT_ENCRYPTED_KEY_INFO_ptr_ptr);
pragma Convention (C, struct_CMSG_RECIPIENT_ENCRYPTED_KEY_INFO_ptr_ptr);
subtype CMSG_RECIPIENT_ENCRYPTED_KEY_INFO is
struct_CMSG_RECIPIENT_ENCRYPTED_KEY_INFO;
subtype PCMSG_RECIPIENT_ENCRYPTED_KEY_INFO is
struct_CMSG_RECIPIENT_ENCRYPTED_KEY_INFO_ptr;
subtype PCMSG_RECIPIENT_ENCRYPTED_KEY_INFO_ptr is
struct_CMSG_RECIPIENT_ENCRYPTED_KEY_INFO_ptr_ptr;
type struct_CMSG_KEY_AGREE_RECIPIENT_INFO;
type union_7e6faf4b (Unchecked_Tag : unsigned_int := 0) is record
case Unchecked_Tag is
when 0 =>
OriginatorCertId : CERT_ID;
when others =>
OriginatorPublicKeyInfo : CERT_PUBLIC_KEY_INFO;
end case;
end record;
pragma Unchecked_Union (union_7e6faf4b);
pragma Convention (C_Pass_By_Copy, union_7e6faf4b);
type struct_CMSG_KEY_AGREE_RECIPIENT_INFO is record
dwVersion : aliased windef.DWORD;
dwOriginatorChoice : aliased windef.DWORD;
anonymous_1 : aliased union_7e6faf4b;
UserKeyingMaterial : aliased CRYPT_DATA_BLOB;
KeyEncryptionAlgorithm : aliased CRYPT_ALGORITHM_IDENTIFIER;
cRecipientEncryptedKeys : aliased windef.DWORD;
rgpRecipientEncryptedKeys :
aliased PCMSG_RECIPIENT_ENCRYPTED_KEY_INFO_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_CMSG_KEY_AGREE_RECIPIENT_INFO);
type struct_CMSG_KEY_AGREE_RECIPIENT_INFO_ptr is
access all struct_CMSG_KEY_AGREE_RECIPIENT_INFO;
for struct_CMSG_KEY_AGREE_RECIPIENT_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CMSG_KEY_AGREE_RECIPIENT_INFO_ptr);
pragma Convention (C, struct_CMSG_KEY_AGREE_RECIPIENT_INFO_ptr);
subtype CMSG_KEY_AGREE_RECIPIENT_INFO is
struct_CMSG_KEY_AGREE_RECIPIENT_INFO;
subtype PCMSG_KEY_AGREE_RECIPIENT_INFO is
struct_CMSG_KEY_AGREE_RECIPIENT_INFO_ptr;
type struct_CMSG_MAIL_LIST_RECIPIENT_INFO;
type struct_CMSG_MAIL_LIST_RECIPIENT_INFO is record
dwVersion : aliased windef.DWORD;
KeyId : aliased CRYPT_DATA_BLOB;
KeyEncryptionAlgorithm : aliased CRYPT_ALGORITHM_IDENTIFIER;
EncryptedKey : aliased CRYPT_DATA_BLOB;
Date : aliased windef.FILETIME;
pOtherAttr : aliased PCRYPT_ATTRIBUTE_TYPE_VALUE;
end record;
pragma Convention (C_Pass_By_Copy, struct_CMSG_MAIL_LIST_RECIPIENT_INFO);
type struct_CMSG_MAIL_LIST_RECIPIENT_INFO_ptr is
access all struct_CMSG_MAIL_LIST_RECIPIENT_INFO;
for struct_CMSG_MAIL_LIST_RECIPIENT_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CMSG_MAIL_LIST_RECIPIENT_INFO_ptr);
pragma Convention (C, struct_CMSG_MAIL_LIST_RECIPIENT_INFO_ptr);
subtype CMSG_MAIL_LIST_RECIPIENT_INFO is
struct_CMSG_MAIL_LIST_RECIPIENT_INFO;
subtype PCMSG_MAIL_LIST_RECIPIENT_INFO is
struct_CMSG_MAIL_LIST_RECIPIENT_INFO_ptr;
type struct_CMSG_CMS_RECIPIENT_INFO;
type union_15978241 (Unchecked_Tag : unsigned_int := 0) is record
case Unchecked_Tag is
when 0 =>
pKeyTrans : PCMSG_KEY_TRANS_RECIPIENT_INFO;
when 1 =>
pKeyAgree : PCMSG_KEY_AGREE_RECIPIENT_INFO;
when others =>
pMailList : PCMSG_MAIL_LIST_RECIPIENT_INFO;
end case;
end record;
pragma Unchecked_Union (union_15978241);
pragma Convention (C_Pass_By_Copy, union_15978241);
type struct_CMSG_CMS_RECIPIENT_INFO is record
dwRecipientChoice : aliased windef.DWORD;
anonymous_1 : aliased union_15978241;
end record;
pragma Convention (C_Pass_By_Copy, struct_CMSG_CMS_RECIPIENT_INFO);
type struct_CMSG_CMS_RECIPIENT_INFO_ptr is
access all struct_CMSG_CMS_RECIPIENT_INFO;
for struct_CMSG_CMS_RECIPIENT_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CMSG_CMS_RECIPIENT_INFO_ptr);
pragma Convention (C, struct_CMSG_CMS_RECIPIENT_INFO_ptr);
subtype CMSG_CMS_RECIPIENT_INFO is struct_CMSG_CMS_RECIPIENT_INFO;
subtype PCMSG_CMS_RECIPIENT_INFO is struct_CMSG_CMS_RECIPIENT_INFO_ptr;
function CryptMsgControl (hCryptMsg : wincrypt.HCRYPTMSG;
dwFlags : windef.DWORD; dwCtrlType : windef.DWORD;
pvCtrlPara : void_const_ptr) return windef.WINBOOL;
pragma Import (C, CryptMsgControl, "CryptMsgControl");
type struct_CMSG_CTRL_VERIFY_SIGNATURE_EX_PARA;
type struct_CMSG_CTRL_VERIFY_SIGNATURE_EX_PARA is record
cbSize : aliased windef.DWORD;
hCryptProv : aliased wincrypt.HCRYPTPROV;
dwSignerIndex : aliased windef.DWORD;
dwSignerType : aliased windef.DWORD;
pvSigner : aliased void_ptr;
end record;
pragma Convention (C_Pass_By_Copy,
struct_CMSG_CTRL_VERIFY_SIGNATURE_EX_PARA);
type struct_CMSG_CTRL_VERIFY_SIGNATURE_EX_PARA_ptr is
access all struct_CMSG_CTRL_VERIFY_SIGNATURE_EX_PARA;
for struct_CMSG_CTRL_VERIFY_SIGNATURE_EX_PARA_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CMSG_CTRL_VERIFY_SIGNATURE_EX_PARA_ptr);
pragma Convention (C, struct_CMSG_CTRL_VERIFY_SIGNATURE_EX_PARA_ptr);
subtype CMSG_CTRL_VERIFY_SIGNATURE_EX_PARA is
struct_CMSG_CTRL_VERIFY_SIGNATURE_EX_PARA;
subtype PCMSG_CTRL_VERIFY_SIGNATURE_EX_PARA is
struct_CMSG_CTRL_VERIFY_SIGNATURE_EX_PARA_ptr;
type struct_CMSG_CTRL_DECRYPT_PARA;
type struct_CMSG_CTRL_DECRYPT_PARA is record
cbSize : aliased windef.DWORD;
hCryptProv : aliased wincrypt.HCRYPTPROV;
dwKeySpec : aliased windef.DWORD;
dwRecipientIndex : aliased windef.DWORD;
end record;
pragma Convention (C_Pass_By_Copy, struct_CMSG_CTRL_DECRYPT_PARA);
type struct_CMSG_CTRL_DECRYPT_PARA_ptr is
access all struct_CMSG_CTRL_DECRYPT_PARA;
for struct_CMSG_CTRL_DECRYPT_PARA_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CMSG_CTRL_DECRYPT_PARA_ptr);
pragma Convention (C, struct_CMSG_CTRL_DECRYPT_PARA_ptr);
subtype CMSG_CTRL_DECRYPT_PARA is struct_CMSG_CTRL_DECRYPT_PARA;
subtype PCMSG_CTRL_DECRYPT_PARA is struct_CMSG_CTRL_DECRYPT_PARA_ptr;
type struct_CMSG_CTRL_KEY_TRANS_DECRYPT_PARA;
type struct_CMSG_CTRL_KEY_TRANS_DECRYPT_PARA is record
cbSize : aliased windef.DWORD;
hCryptProv : aliased wincrypt.HCRYPTPROV;
dwKeySpec : aliased windef.DWORD;
pKeyTrans : aliased PCMSG_KEY_TRANS_RECIPIENT_INFO;
dwRecipientIndex : aliased windef.DWORD;
end record;
pragma Convention (C_Pass_By_Copy,
struct_CMSG_CTRL_KEY_TRANS_DECRYPT_PARA);
type struct_CMSG_CTRL_KEY_TRANS_DECRYPT_PARA_ptr is
access all struct_CMSG_CTRL_KEY_TRANS_DECRYPT_PARA;
for struct_CMSG_CTRL_KEY_TRANS_DECRYPT_PARA_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CMSG_CTRL_KEY_TRANS_DECRYPT_PARA_ptr);
pragma Convention (C, struct_CMSG_CTRL_KEY_TRANS_DECRYPT_PARA_ptr);
subtype CMSG_CTRL_KEY_TRANS_DECRYPT_PARA is
struct_CMSG_CTRL_KEY_TRANS_DECRYPT_PARA;
subtype PCMSG_CTRL_KEY_TRANS_DECRYPT_PARA is
struct_CMSG_CTRL_KEY_TRANS_DECRYPT_PARA_ptr;
type struct_CMSG_CTRL_KEY_AGREE_DECRYPT_PARA;
type struct_CMSG_CTRL_KEY_AGREE_DECRYPT_PARA is record
cbSize : aliased windef.DWORD;
hCryptProv : aliased wincrypt.HCRYPTPROV;
dwKeySpec : aliased windef.DWORD;
pKeyAgree : aliased PCMSG_KEY_AGREE_RECIPIENT_INFO;
dwRecipientIndex : aliased windef.DWORD;
dwRecipientEncryptedKeyIndex : aliased windef.DWORD;
OriginatorPublicKey : aliased CRYPT_BIT_BLOB;
end record;
pragma Convention (C_Pass_By_Copy,
struct_CMSG_CTRL_KEY_AGREE_DECRYPT_PARA);
type struct_CMSG_CTRL_KEY_AGREE_DECRYPT_PARA_ptr is
access all struct_CMSG_CTRL_KEY_AGREE_DECRYPT_PARA;
for struct_CMSG_CTRL_KEY_AGREE_DECRYPT_PARA_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CMSG_CTRL_KEY_AGREE_DECRYPT_PARA_ptr);
pragma Convention (C, struct_CMSG_CTRL_KEY_AGREE_DECRYPT_PARA_ptr);
subtype CMSG_CTRL_KEY_AGREE_DECRYPT_PARA is
struct_CMSG_CTRL_KEY_AGREE_DECRYPT_PARA;
subtype PCMSG_CTRL_KEY_AGREE_DECRYPT_PARA is
struct_CMSG_CTRL_KEY_AGREE_DECRYPT_PARA_ptr;
type struct_CMSG_CTRL_MAIL_LIST_DECRYPT_PARA;
type union_0580e51f (Unchecked_Tag : unsigned_int := 0) is record
case Unchecked_Tag is
when 0 =>
hKeyEncryptionKey : HCRYPTKEY;
when others =>
pvKeyEncryptionKey : void_ptr;
end case;
end record;
pragma Unchecked_Union (union_0580e51f);
pragma Convention (C_Pass_By_Copy, union_0580e51f);
type struct_CMSG_CTRL_MAIL_LIST_DECRYPT_PARA is record
cbSize : aliased windef.DWORD;
hCryptProv : aliased wincrypt.HCRYPTPROV;
pMailList : aliased PCMSG_MAIL_LIST_RECIPIENT_INFO;
dwRecipientIndex : aliased windef.DWORD;
dwKeyChoice : aliased windef.DWORD;
anonymous_1 : aliased union_0580e51f;
end record;
pragma Convention (C_Pass_By_Copy,
struct_CMSG_CTRL_MAIL_LIST_DECRYPT_PARA);
type struct_CMSG_CTRL_MAIL_LIST_DECRYPT_PARA_ptr is
access all struct_CMSG_CTRL_MAIL_LIST_DECRYPT_PARA;
for struct_CMSG_CTRL_MAIL_LIST_DECRYPT_PARA_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CMSG_CTRL_MAIL_LIST_DECRYPT_PARA_ptr);
pragma Convention (C, struct_CMSG_CTRL_MAIL_LIST_DECRYPT_PARA_ptr);
subtype CMSG_CTRL_MAIL_LIST_DECRYPT_PARA is
struct_CMSG_CTRL_MAIL_LIST_DECRYPT_PARA;
subtype PCMSG_CTRL_MAIL_LIST_DECRYPT_PARA is
struct_CMSG_CTRL_MAIL_LIST_DECRYPT_PARA_ptr;
type struct_CMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR_PARA;
type struct_CMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR_PARA is record
cbSize : aliased windef.DWORD;
dwSignerIndex : aliased windef.DWORD;
blob : aliased CRYPT_DATA_BLOB;
end record;
pragma Convention (C_Pass_By_Copy,
struct_CMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR_PARA);
type struct_CMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR_PARA_ptr is
access all struct_CMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR_PARA;
for struct_CMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR_PARA_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (
struct_CMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR_PARA_ptr);
pragma Convention (C, struct_CMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR_PARA_ptr);
subtype CMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR_PARA is
struct_CMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR_PARA;
subtype PCMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR_PARA is
struct_CMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR_PARA_ptr;
type struct_CMSG_CTRL_DEL_SIGNER_UNAUTH_ATTR_PARA;
type struct_CMSG_CTRL_DEL_SIGNER_UNAUTH_ATTR_PARA is record
cbSize : aliased windef.DWORD;
dwSignerIndex : aliased windef.DWORD;
dwUnauthAttrIndex : aliased windef.DWORD;
end record;
pragma Convention (C_Pass_By_Copy,
struct_CMSG_CTRL_DEL_SIGNER_UNAUTH_ATTR_PARA);
type struct_CMSG_CTRL_DEL_SIGNER_UNAUTH_ATTR_PARA_ptr is
access all struct_CMSG_CTRL_DEL_SIGNER_UNAUTH_ATTR_PARA;
for struct_CMSG_CTRL_DEL_SIGNER_UNAUTH_ATTR_PARA_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (
struct_CMSG_CTRL_DEL_SIGNER_UNAUTH_ATTR_PARA_ptr);
pragma Convention (C, struct_CMSG_CTRL_DEL_SIGNER_UNAUTH_ATTR_PARA_ptr);
subtype CMSG_CTRL_DEL_SIGNER_UNAUTH_ATTR_PARA is
struct_CMSG_CTRL_DEL_SIGNER_UNAUTH_ATTR_PARA;
subtype PCMSG_CTRL_DEL_SIGNER_UNAUTH_ATTR_PARA is
struct_CMSG_CTRL_DEL_SIGNER_UNAUTH_ATTR_PARA_ptr;
function CryptMsgVerifyCountersignatureEncoded (
hCryptProv : wincrypt.HCRYPTPROV; dwEncodingType : windef.DWORD;
pbSignerInfo : access windef.BYTE; cbSignerInfo : windef.DWORD;
pbSignerInfoCountersignature : access windef.BYTE;
cbSignerInfoCountersignature : windef.DWORD;
pciCountersigner : access struct_CERT_INFO) return windef.WINBOOL;
pragma Import (C, CryptMsgVerifyCountersignatureEncoded,
"CryptMsgVerifyCountersignatureEncoded");
function CryptMsgVerifyCountersignatureEncodedEx (
hCryptProv : wincrypt.HCRYPTPROV; dwEncodingType : windef.DWORD;
pbSignerInfo : access windef.BYTE; cbSignerInfo : windef.DWORD;
pbSignerInfoCountersignature : access windef.BYTE;
cbSignerInfoCountersignature : windef.DWORD;
dwSignerType : windef.DWORD; pvSigner : void_ptr;
dwFlags : windef.DWORD; pvReserved : void_ptr) return windef.WINBOOL;
pragma Import (C, CryptMsgVerifyCountersignatureEncodedEx,
"CryptMsgVerifyCountersignatureEncodedEx");
function CryptMsgCountersign (hCryptMsg : wincrypt.HCRYPTMSG;
dwIndex : windef.DWORD; cCountersigners : windef.DWORD;
rgCountersigners : access struct_CMSG_SIGNER_ENCODE_INFO)
return windef.WINBOOL;
pragma Import (C, CryptMsgCountersign, "CryptMsgCountersign");
function CryptMsgCountersignEncoded (dwEncodingType : windef.DWORD;
pbSignerInfo : access windef.BYTE; cbSignerInfo : windef.DWORD;
cCountersigners : windef.DWORD;
rgCountersigners : access struct_CMSG_SIGNER_ENCODE_INFO;
pbCountersignature : access windef.BYTE;
pcbCountersignature : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, CryptMsgCountersignEncoded,
"CryptMsgCountersignEncoded");
type access_91e334ed is access function (cb : qmingw.size_t)
return void_ptr;
pragma Convention (C, access_91e334ed);
subtype PFN_CMSG_ALLOC is access_91e334ed;
type access_a3f84266 is access procedure (pv : void_ptr);
pragma Convention (C, access_a3f84266);
subtype PFN_CMSG_FREE is access_a3f84266;
type access_bcd59e84 is access function (phCryptProv : access HCRYPTPROV;
paiEncrypt : access struct_CRYPT_ALGORITHM_IDENTIFIER;
pvEncryptAuxInfo : winnt.PVOID;
pPublicKeyInfo : access struct_CERT_PUBLIC_KEY_INFO;
pfnAlloc : PFN_CMSG_ALLOC; phEncryptKey : access HCRYPTKEY;
ppbEncryptParameters : access windef.PBYTE;
pcbEncryptParameters : access windef.DWORD) return windef.WINBOOL;
pragma Convention (C, access_bcd59e84);
subtype PFN_CMSG_GEN_ENCRYPT_KEY is access_bcd59e84;
type access_e4be8718 is access function (hCryptProv : wincrypt.HCRYPTPROV;
hEncryptKey : HCRYPTKEY;
pPublicKeyInfo : access struct_CERT_PUBLIC_KEY_INFO;
pbData : access windef.BYTE; pcbData : access windef.DWORD)
return windef.WINBOOL;
pragma Convention (C, access_e4be8718);
subtype PFN_CMSG_EXPORT_ENCRYPT_KEY is access_e4be8718;
type access_126deba2 is access function (hCryptProv : wincrypt.HCRYPTPROV;
dwKeySpec : windef.DWORD;
paiEncrypt : access struct_CRYPT_ALGORITHM_IDENTIFIER;
paiPubKey : access struct_CRYPT_ALGORITHM_IDENTIFIER;
pbEncodedKey : access windef.BYTE; cbEncodedKey : windef.DWORD;
phEncryptKey : access HCRYPTKEY) return windef.WINBOOL;
pragma Convention (C, access_126deba2);
subtype PFN_CMSG_IMPORT_ENCRYPT_KEY is access_126deba2;
type struct_CMSG_CONTENT_ENCRYPT_INFO;
type struct_CMSG_CONTENT_ENCRYPT_INFO is record
cbSize : aliased windef.DWORD;
hCryptProv : aliased wincrypt.HCRYPTPROV;
ContentEncryptionAlgorithm : aliased CRYPT_ALGORITHM_IDENTIFIER;
pvEncryptionAuxInfo : aliased void_ptr;
cRecipients : aliased windef.DWORD;
rgCmsRecipients : aliased PCMSG_RECIPIENT_ENCODE_INFO;
pfnAlloc : aliased PFN_CMSG_ALLOC;
pfnFree : aliased PFN_CMSG_FREE;
dwEncryptFlags : aliased windef.DWORD;
hContentEncryptKey : aliased HCRYPTKEY;
dwFlags : aliased windef.DWORD;
end record;
pragma Convention (C_Pass_By_Copy, struct_CMSG_CONTENT_ENCRYPT_INFO);
type struct_CMSG_CONTENT_ENCRYPT_INFO_ptr is
access all struct_CMSG_CONTENT_ENCRYPT_INFO;
for struct_CMSG_CONTENT_ENCRYPT_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CMSG_CONTENT_ENCRYPT_INFO_ptr);
pragma Convention (C, struct_CMSG_CONTENT_ENCRYPT_INFO_ptr);
subtype CMSG_CONTENT_ENCRYPT_INFO is struct_CMSG_CONTENT_ENCRYPT_INFO;
subtype PCMSG_CONTENT_ENCRYPT_INFO is
struct_CMSG_CONTENT_ENCRYPT_INFO_ptr;
type access_a0ed7f66 is access function (
pContentEncryptInfo : access struct_CMSG_CONTENT_ENCRYPT_INFO;
dwFlags : windef.DWORD; pvReserved : void_ptr) return windef.WINBOOL;
pragma Convention (C, access_a0ed7f66);
subtype PFN_CMSG_GEN_CONTENT_ENCRYPT_KEY is access_a0ed7f66;
type struct_CMSG_KEY_TRANS_ENCRYPT_INFO;
type struct_CMSG_KEY_TRANS_ENCRYPT_INFO is record
cbSize : aliased windef.DWORD;
dwRecipientIndex : aliased windef.DWORD;
KeyEncryptionAlgorithm : aliased CRYPT_ALGORITHM_IDENTIFIER;
EncryptedKey : aliased CRYPT_DATA_BLOB;
dwFlags : aliased windef.DWORD;
end record;
pragma Convention (C_Pass_By_Copy, struct_CMSG_KEY_TRANS_ENCRYPT_INFO);
type struct_CMSG_KEY_TRANS_ENCRYPT_INFO_ptr is
access all struct_CMSG_KEY_TRANS_ENCRYPT_INFO;
for struct_CMSG_KEY_TRANS_ENCRYPT_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CMSG_KEY_TRANS_ENCRYPT_INFO_ptr);
pragma Convention (C, struct_CMSG_KEY_TRANS_ENCRYPT_INFO_ptr);
subtype CMSG_KEY_TRANS_ENCRYPT_INFO is struct_CMSG_KEY_TRANS_ENCRYPT_INFO;
subtype PCMSG_KEY_TRANS_ENCRYPT_INFO is
struct_CMSG_KEY_TRANS_ENCRYPT_INFO_ptr;
type access_08df4d44 is access function (
pContentEncryptInfo : access struct_CMSG_CONTENT_ENCRYPT_INFO;
pKeyTransEncodeInfo :
access struct_CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO;
pKeyTransEncryptInfo : access struct_CMSG_KEY_TRANS_ENCRYPT_INFO;
dwFlags : windef.DWORD; pvReserved : void_ptr) return windef.WINBOOL;
pragma Convention (C, access_08df4d44);
subtype PFN_CMSG_EXPORT_KEY_TRANS is access_08df4d44;
type struct_CMSG_KEY_AGREE_KEY_ENCRYPT_INFO;
type struct_CMSG_KEY_AGREE_KEY_ENCRYPT_INFO is record
cbSize : aliased windef.DWORD;
EncryptedKey : aliased CRYPT_DATA_BLOB;
end record;
pragma Convention (C_Pass_By_Copy,
struct_CMSG_KEY_AGREE_KEY_ENCRYPT_INFO);
type struct_CMSG_KEY_AGREE_KEY_ENCRYPT_INFO_ptr is
access all struct_CMSG_KEY_AGREE_KEY_ENCRYPT_INFO;
for struct_CMSG_KEY_AGREE_KEY_ENCRYPT_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CMSG_KEY_AGREE_KEY_ENCRYPT_INFO_ptr);
pragma Convention (C, struct_CMSG_KEY_AGREE_KEY_ENCRYPT_INFO_ptr);
type struct_CMSG_KEY_AGREE_KEY_ENCRYPT_INFO_ptr_ptr is
access all struct_CMSG_KEY_AGREE_KEY_ENCRYPT_INFO_ptr;
for struct_CMSG_KEY_AGREE_KEY_ENCRYPT_INFO_ptr_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (
struct_CMSG_KEY_AGREE_KEY_ENCRYPT_INFO_ptr_ptr);
pragma Convention (C, struct_CMSG_KEY_AGREE_KEY_ENCRYPT_INFO_ptr_ptr);
subtype CMSG_KEY_AGREE_KEY_ENCRYPT_INFO is
struct_CMSG_KEY_AGREE_KEY_ENCRYPT_INFO;
subtype PCMSG_KEY_AGREE_KEY_ENCRYPT_INFO is
struct_CMSG_KEY_AGREE_KEY_ENCRYPT_INFO_ptr;
subtype PCMSG_KEY_AGREE_KEY_ENCRYPT_INFO_ptr is
struct_CMSG_KEY_AGREE_KEY_ENCRYPT_INFO_ptr_ptr;
type struct_CMSG_KEY_AGREE_ENCRYPT_INFO;
type union_7d70a0f6 (Unchecked_Tag : unsigned_int := 0) is record
case Unchecked_Tag is
when 0 =>
OriginatorCertId : CERT_ID;
when others =>
OriginatorPublicKeyInfo : CERT_PUBLIC_KEY_INFO;
end case;
end record;
pragma Unchecked_Union (union_7d70a0f6);
pragma Convention (C_Pass_By_Copy, union_7d70a0f6);
type struct_CMSG_KEY_AGREE_ENCRYPT_INFO is record
cbSize : aliased windef.DWORD;
dwRecipientIndex : aliased windef.DWORD;
KeyEncryptionAlgorithm : aliased CRYPT_ALGORITHM_IDENTIFIER;
UserKeyingMaterial : aliased CRYPT_DATA_BLOB;
dwOriginatorChoice : aliased windef.DWORD;
anonymous_1 : aliased union_7d70a0f6;
cKeyAgreeKeyEncryptInfo : aliased windef.DWORD;
rgpKeyAgreeKeyEncryptInfo :
aliased PCMSG_KEY_AGREE_KEY_ENCRYPT_INFO_ptr;
dwFlags : aliased windef.DWORD;
end record;
pragma Convention (C_Pass_By_Copy, struct_CMSG_KEY_AGREE_ENCRYPT_INFO);
type struct_CMSG_KEY_AGREE_ENCRYPT_INFO_ptr is
access all struct_CMSG_KEY_AGREE_ENCRYPT_INFO;
for struct_CMSG_KEY_AGREE_ENCRYPT_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CMSG_KEY_AGREE_ENCRYPT_INFO_ptr);
pragma Convention (C, struct_CMSG_KEY_AGREE_ENCRYPT_INFO_ptr);
subtype CMSG_KEY_AGREE_ENCRYPT_INFO is struct_CMSG_KEY_AGREE_ENCRYPT_INFO;
subtype PCMSG_KEY_AGREE_ENCRYPT_INFO is
struct_CMSG_KEY_AGREE_ENCRYPT_INFO_ptr;
type access_901c6a67 is access function (
pContentEncryptInfo : access struct_CMSG_CONTENT_ENCRYPT_INFO;
pKeyAgreeEncodeInfo :
access struct_CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO;
pKeyAgreeEncryptInfo : access struct_CMSG_KEY_AGREE_ENCRYPT_INFO;
dwFlags : windef.DWORD; pvReserved : void_ptr) return windef.WINBOOL;
pragma Convention (C, access_901c6a67);
subtype PFN_CMSG_EXPORT_KEY_AGREE is access_901c6a67;
type struct_CMSG_MAIL_LIST_ENCRYPT_INFO;
type struct_CMSG_MAIL_LIST_ENCRYPT_INFO is record
cbSize : aliased windef.DWORD;
dwRecipientIndex : aliased windef.DWORD;
KeyEncryptionAlgorithm : aliased CRYPT_ALGORITHM_IDENTIFIER;
EncryptedKey : aliased CRYPT_DATA_BLOB;
dwFlags : aliased windef.DWORD;
end record;
pragma Convention (C_Pass_By_Copy, struct_CMSG_MAIL_LIST_ENCRYPT_INFO);
type struct_CMSG_MAIL_LIST_ENCRYPT_INFO_ptr is
access all struct_CMSG_MAIL_LIST_ENCRYPT_INFO;
for struct_CMSG_MAIL_LIST_ENCRYPT_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CMSG_MAIL_LIST_ENCRYPT_INFO_ptr);
pragma Convention (C, struct_CMSG_MAIL_LIST_ENCRYPT_INFO_ptr);
subtype CMSG_MAIL_LIST_ENCRYPT_INFO is struct_CMSG_MAIL_LIST_ENCRYPT_INFO;
subtype PCMSG_MAIL_LIST_ENCRYPT_INFO is
struct_CMSG_MAIL_LIST_ENCRYPT_INFO_ptr;
type access_4185eda7 is access function (
pContentEncryptInfo : access struct_CMSG_CONTENT_ENCRYPT_INFO;
pMailListEncodeInfo :
access struct_CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO;
pMailListEncryptInfo : access struct_CMSG_MAIL_LIST_ENCRYPT_INFO;
dwFlags : windef.DWORD; pvReserved : void_ptr) return windef.WINBOOL;
pragma Convention (C, access_4185eda7);
subtype PFN_CMSG_EXPORT_MAIL_LIST is access_4185eda7;
type access_6d4b8ab4 is access function (
pContentEncryptionAlgorithm : access struct_CRYPT_ALGORITHM_IDENTIFIER;
pKeyTransDecryptPara : access struct_CMSG_CTRL_KEY_TRANS_DECRYPT_PARA;
dwFlags : windef.DWORD; pvReserved : void_ptr;
phContentEncryptKey : access HCRYPTKEY) return windef.WINBOOL;
pragma Convention (C, access_6d4b8ab4);
subtype PFN_CMSG_IMPORT_KEY_TRANS is access_6d4b8ab4;
type access_ca2efd81 is access function (
pContentEncryptionAlgorithm : access struct_CRYPT_ALGORITHM_IDENTIFIER;
pKeyAgreeDecryptPara : access struct_CMSG_CTRL_KEY_AGREE_DECRYPT_PARA;
dwFlags : windef.DWORD; pvReserved : void_ptr;
phContentEncryptKey : access HCRYPTKEY) return windef.WINBOOL;
pragma Convention (C, access_ca2efd81);
subtype PFN_CMSG_IMPORT_KEY_AGREE is access_ca2efd81;
type access_570ba9fe is access function (
pContentEncryptionAlgorithm : access struct_CRYPT_ALGORITHM_IDENTIFIER;
pMailListDecryptPara : access struct_CMSG_CTRL_MAIL_LIST_DECRYPT_PARA;
dwFlags : windef.DWORD; pvReserved : void_ptr;
phContentEncryptKey : access HCRYPTKEY) return windef.WINBOOL;
pragma Convention (C, access_570ba9fe);
subtype PFN_CMSG_IMPORT_MAIL_LIST is access_570ba9fe;
subtype HCERTSTORE is void_ptr;
subtype HCERTSTORE_ptr is void_ptr_ptr;
type struct_CERT_CONTEXT;
type struct_CERT_CONTEXT is record
dwCertEncodingType : aliased windef.DWORD;
pbCertEncoded : aliased windef.BYTE_ptr;
cbCertEncoded : aliased windef.DWORD;
pCertInfo : aliased PCERT_INFO;
hCertStore : aliased wincrypt.HCERTSTORE;
end record;
pragma Convention (C_Pass_By_Copy, struct_CERT_CONTEXT);
type struct_CERT_CONTEXT_ptr is access all struct_CERT_CONTEXT;
for struct_CERT_CONTEXT_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_CONTEXT_ptr);
pragma Convention (C, struct_CERT_CONTEXT_ptr);
type struct_CERT_CONTEXT_const_ptr is access constant struct_CERT_CONTEXT;
for struct_CERT_CONTEXT_const_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_CONTEXT_const_ptr);
pragma Convention (C, struct_CERT_CONTEXT_const_ptr);
type struct_CERT_CONTEXT_const_ptr_ptr is
access all struct_CERT_CONTEXT_const_ptr;
for struct_CERT_CONTEXT_const_ptr_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_CONTEXT_const_ptr_ptr);
pragma Convention (C, struct_CERT_CONTEXT_const_ptr_ptr);
type struct_CERT_CONTEXT_const_ptr_array is array (size_t range <>) of
aliased struct_CERT_CONTEXT_const_ptr;
pragma Convention (C, struct_CERT_CONTEXT_const_ptr_array);
subtype CERT_CONTEXT is struct_CERT_CONTEXT;
subtype CERT_CONTEXT_const_ptr is struct_CERT_CONTEXT_const_ptr;
subtype CERT_CONTEXT_const_ptr_ptr is struct_CERT_CONTEXT_const_ptr_ptr;
subtype CERT_CONTEXT_const_ptr_array is
struct_CERT_CONTEXT_const_ptr_array;
subtype PCERT_CONTEXT is struct_CERT_CONTEXT_ptr;
subtype PCCERT_CONTEXT is CERT_CONTEXT_const_ptr;
subtype PCCERT_CONTEXT_ptr is CERT_CONTEXT_const_ptr_ptr;
subtype PCCERT_CONTEXT_array is CERT_CONTEXT_const_ptr_array;
type struct_CRL_CONTEXT;
type struct_CRL_CONTEXT is record
dwCertEncodingType : aliased windef.DWORD;
pbCrlEncoded : aliased windef.BYTE_ptr;
cbCrlEncoded : aliased windef.DWORD;
pCrlInfo : aliased PCRL_INFO;
hCertStore : aliased wincrypt.HCERTSTORE;
end record;
pragma Convention (C_Pass_By_Copy, struct_CRL_CONTEXT);
type struct_CRL_CONTEXT_ptr is access all struct_CRL_CONTEXT;
for struct_CRL_CONTEXT_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRL_CONTEXT_ptr);
pragma Convention (C, struct_CRL_CONTEXT_ptr);
type struct_CRL_CONTEXT_const_ptr is access constant struct_CRL_CONTEXT;
for struct_CRL_CONTEXT_const_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRL_CONTEXT_const_ptr);
pragma Convention (C, struct_CRL_CONTEXT_const_ptr);
type struct_CRL_CONTEXT_const_ptr_ptr is
access all struct_CRL_CONTEXT_const_ptr;
for struct_CRL_CONTEXT_const_ptr_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRL_CONTEXT_const_ptr_ptr);
pragma Convention (C, struct_CRL_CONTEXT_const_ptr_ptr);
subtype CRL_CONTEXT is struct_CRL_CONTEXT;
subtype CRL_CONTEXT_const_ptr is struct_CRL_CONTEXT_const_ptr;
subtype CRL_CONTEXT_const_ptr_ptr is struct_CRL_CONTEXT_const_ptr_ptr;
subtype PCRL_CONTEXT is struct_CRL_CONTEXT_ptr;
subtype PCCRL_CONTEXT is CRL_CONTEXT_const_ptr;
subtype PCCRL_CONTEXT_ptr is CRL_CONTEXT_const_ptr_ptr;
type struct_CTL_CONTEXT;
type struct_CTL_CONTEXT is record
dwMsgAndCertEncodingType : aliased windef.DWORD;
pbCtlEncoded : aliased windef.BYTE_ptr;
cbCtlEncoded : aliased windef.DWORD;
pCtlInfo : aliased PCTL_INFO;
hCertStore : aliased wincrypt.HCERTSTORE;
hCryptMsg : aliased wincrypt.HCRYPTMSG;
pbCtlContent : aliased windef.BYTE_ptr;
cbCtlContent : aliased windef.DWORD;
end record;
pragma Convention (C_Pass_By_Copy, struct_CTL_CONTEXT);
type struct_CTL_CONTEXT_ptr is access all struct_CTL_CONTEXT;
for struct_CTL_CONTEXT_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CTL_CONTEXT_ptr);
pragma Convention (C, struct_CTL_CONTEXT_ptr);
type struct_CTL_CONTEXT_const_ptr is access constant struct_CTL_CONTEXT;
for struct_CTL_CONTEXT_const_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CTL_CONTEXT_const_ptr);
pragma Convention (C, struct_CTL_CONTEXT_const_ptr);
type struct_CTL_CONTEXT_const_ptr_ptr is
access all struct_CTL_CONTEXT_const_ptr;
for struct_CTL_CONTEXT_const_ptr_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CTL_CONTEXT_const_ptr_ptr);
pragma Convention (C, struct_CTL_CONTEXT_const_ptr_ptr);
subtype CTL_CONTEXT is struct_CTL_CONTEXT;
subtype CTL_CONTEXT_const_ptr is struct_CTL_CONTEXT_const_ptr;
subtype CTL_CONTEXT_const_ptr_ptr is struct_CTL_CONTEXT_const_ptr_ptr;
subtype PCTL_CONTEXT is struct_CTL_CONTEXT_ptr;
subtype PCCTL_CONTEXT is CTL_CONTEXT_const_ptr;
subtype PCCTL_CONTEXT_ptr is CTL_CONTEXT_const_ptr_ptr;
type struct_CRYPT_KEY_PROV_PARAM;
type struct_CRYPT_KEY_PROV_PARAM is record
dwParam : aliased windef.DWORD;
pbData : aliased windef.BYTE_ptr;
cbData : aliased windef.DWORD;
dwFlags : aliased windef.DWORD;
end record;
pragma Convention (C_Pass_By_Copy, struct_CRYPT_KEY_PROV_PARAM);
type struct_CRYPT_KEY_PROV_PARAM_ptr is
access all struct_CRYPT_KEY_PROV_PARAM;
for struct_CRYPT_KEY_PROV_PARAM_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_KEY_PROV_PARAM_ptr);
pragma Convention (C, struct_CRYPT_KEY_PROV_PARAM_ptr);
subtype CRYPT_KEY_PROV_PARAM is struct_CRYPT_KEY_PROV_PARAM;
subtype PCRYPT_KEY_PROV_PARAM is struct_CRYPT_KEY_PROV_PARAM_ptr;
type struct_CRYPT_KEY_PROV_INFO;
type struct_CRYPT_KEY_PROV_INFO is record
pwszContainerName : aliased winnt.LPWSTR;
pwszProvName : aliased winnt.LPWSTR;
dwProvType : aliased windef.DWORD;
dwFlags : aliased windef.DWORD;
cProvParam : aliased windef.DWORD;
rgProvParam : aliased PCRYPT_KEY_PROV_PARAM;
dwKeySpec : aliased windef.DWORD;
end record;
pragma Convention (C_Pass_By_Copy, struct_CRYPT_KEY_PROV_INFO);
type struct_CRYPT_KEY_PROV_INFO_ptr is
access all struct_CRYPT_KEY_PROV_INFO;
for struct_CRYPT_KEY_PROV_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_KEY_PROV_INFO_ptr);
pragma Convention (C, struct_CRYPT_KEY_PROV_INFO_ptr);
subtype CRYPT_KEY_PROV_INFO is struct_CRYPT_KEY_PROV_INFO;
subtype PCRYPT_KEY_PROV_INFO is struct_CRYPT_KEY_PROV_INFO_ptr;
type struct_CERT_KEY_CONTEXT;
type struct_CERT_KEY_CONTEXT is record
cbSize : aliased windef.DWORD;
hCryptProv : aliased wincrypt.HCRYPTPROV;
dwKeySpec : aliased windef.DWORD;
end record;
pragma Convention (C_Pass_By_Copy, struct_CERT_KEY_CONTEXT);
type struct_CERT_KEY_CONTEXT_ptr is access all struct_CERT_KEY_CONTEXT;
for struct_CERT_KEY_CONTEXT_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_KEY_CONTEXT_ptr);
pragma Convention (C, struct_CERT_KEY_CONTEXT_ptr);
subtype CERT_KEY_CONTEXT is struct_CERT_KEY_CONTEXT;
subtype PCERT_KEY_CONTEXT is struct_CERT_KEY_CONTEXT_ptr;
type struct_CERT_SYSTEM_STORE_RELOCATE_PARA;
type union_faa12c6e (Unchecked_Tag : unsigned_int := 0) is record
case Unchecked_Tag is
when 0 =>
hKeyBase : windef.HKEY;
when others =>
pvBase : void_ptr;
end case;
end record;
pragma Unchecked_Union (union_faa12c6e);
pragma Convention (C_Pass_By_Copy, union_faa12c6e);
type union_2c4394ea (Unchecked_Tag : unsigned_int := 0) is record
case Unchecked_Tag is
when 0 =>
pvSystemStore : void_ptr;
when 1 =>
pszSystemStore : winnt.LPCSTR;
when others =>
pwszSystemStore : winnt.LPCWSTR;
end case;
end record;
pragma Unchecked_Union (union_2c4394ea);
pragma Convention (C_Pass_By_Copy, union_2c4394ea);
type struct_CERT_SYSTEM_STORE_RELOCATE_PARA is record
anonymous_1 : aliased union_faa12c6e;
anonymous_2 : aliased union_2c4394ea;
end record;
pragma Convention (C_Pass_By_Copy,
struct_CERT_SYSTEM_STORE_RELOCATE_PARA);
type struct_CERT_SYSTEM_STORE_RELOCATE_PARA_ptr is
access all struct_CERT_SYSTEM_STORE_RELOCATE_PARA;
for struct_CERT_SYSTEM_STORE_RELOCATE_PARA_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_SYSTEM_STORE_RELOCATE_PARA_ptr);
pragma Convention (C, struct_CERT_SYSTEM_STORE_RELOCATE_PARA_ptr);
subtype CERT_SYSTEM_STORE_RELOCATE_PARA is
struct_CERT_SYSTEM_STORE_RELOCATE_PARA;
subtype PCERT_SYSTEM_STORE_RELOCATE_PARA is
struct_CERT_SYSTEM_STORE_RELOCATE_PARA_ptr;
type struct_CERT_REGISTRY_STORE_CLIENT_GPT_PARA;
type struct_CERT_REGISTRY_STORE_CLIENT_GPT_PARA is record
hKeyBase : aliased windef.HKEY;
pwszRegPath : aliased winnt.LPWSTR;
end record;
pragma Convention (C_Pass_By_Copy,
struct_CERT_REGISTRY_STORE_CLIENT_GPT_PARA);
type struct_CERT_REGISTRY_STORE_CLIENT_GPT_PARA_ptr is
access all struct_CERT_REGISTRY_STORE_CLIENT_GPT_PARA;
for struct_CERT_REGISTRY_STORE_CLIENT_GPT_PARA_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (
struct_CERT_REGISTRY_STORE_CLIENT_GPT_PARA_ptr);
pragma Convention (C, struct_CERT_REGISTRY_STORE_CLIENT_GPT_PARA_ptr);
subtype CERT_REGISTRY_STORE_CLIENT_GPT_PARA is
struct_CERT_REGISTRY_STORE_CLIENT_GPT_PARA;
subtype PCERT_REGISTRY_STORE_CLIENT_GPT_PARA is
struct_CERT_REGISTRY_STORE_CLIENT_GPT_PARA_ptr;
type struct_CERT_REGISTRY_STORE_ROAMING_PARA;
type struct_CERT_REGISTRY_STORE_ROAMING_PARA is record
hKey : aliased windef.HKEY;
pwszStoreDirectory : aliased winnt.LPWSTR;
end record;
pragma Convention (C_Pass_By_Copy,
struct_CERT_REGISTRY_STORE_ROAMING_PARA);
type struct_CERT_REGISTRY_STORE_ROAMING_PARA_ptr is
access all struct_CERT_REGISTRY_STORE_ROAMING_PARA;
for struct_CERT_REGISTRY_STORE_ROAMING_PARA_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_REGISTRY_STORE_ROAMING_PARA_ptr);
pragma Convention (C, struct_CERT_REGISTRY_STORE_ROAMING_PARA_ptr);
subtype CERT_REGISTRY_STORE_ROAMING_PARA is
struct_CERT_REGISTRY_STORE_ROAMING_PARA;
subtype PCERT_REGISTRY_STORE_ROAMING_PARA is
struct_CERT_REGISTRY_STORE_ROAMING_PARA_ptr;
type struct_CERT_LDAP_STORE_OPENED_PARA;
type struct_CERT_LDAP_STORE_OPENED_PARA is record
pvLdapSessionHandle : aliased void_ptr;
pwszLdapUrl : aliased winnt.LPCWSTR;
end record;
pragma Convention (C_Pass_By_Copy, struct_CERT_LDAP_STORE_OPENED_PARA);
type struct_CERT_LDAP_STORE_OPENED_PARA_ptr is
access all struct_CERT_LDAP_STORE_OPENED_PARA;
for struct_CERT_LDAP_STORE_OPENED_PARA_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_LDAP_STORE_OPENED_PARA_ptr);
pragma Convention (C, struct_CERT_LDAP_STORE_OPENED_PARA_ptr);
subtype CERT_LDAP_STORE_OPENED_PARA is struct_CERT_LDAP_STORE_OPENED_PARA;
subtype PCERT_LDAP_STORE_OPENED_PARA is
struct_CERT_LDAP_STORE_OPENED_PARA_ptr;
function CertOpenStore (lpszStoreProvider : access constant winnt.C_CHAR;
dwEncodingType : windef.DWORD; hCryptProv : wincrypt.HCRYPTPROV;
dwFlags : windef.DWORD; pvPara : void_const_ptr) return HCERTSTORE;
pragma Import (C, CertOpenStore, "CertOpenStore");
subtype HCERTSTOREPROV is void_ptr;
type struct_CERT_STORE_PROV_INFO;
type struct_CERT_STORE_PROV_INFO is record
cbSize : aliased windef.DWORD;
cStoreProvFunc : aliased windef.DWORD;
rgpvStoreProvFunc : aliased void_ptr_ptr;
hStoreProv : aliased HCERTSTOREPROV;
dwStoreProvFlags : aliased windef.DWORD;
hStoreProvFuncAddr2 : aliased HCRYPTOIDFUNCADDR;
end record;
pragma Convention (C_Pass_By_Copy, struct_CERT_STORE_PROV_INFO);
type struct_CERT_STORE_PROV_INFO_ptr is
access all struct_CERT_STORE_PROV_INFO;
for struct_CERT_STORE_PROV_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_STORE_PROV_INFO_ptr);
pragma Convention (C, struct_CERT_STORE_PROV_INFO_ptr);
subtype CERT_STORE_PROV_INFO is struct_CERT_STORE_PROV_INFO;
subtype PCERT_STORE_PROV_INFO is struct_CERT_STORE_PROV_INFO_ptr;
type access_c5856a85 is access function (
lpszStoreProvider : access constant winnt.C_CHAR;
dwEncodingType : windef.DWORD; hCryptProv : wincrypt.HCRYPTPROV;
dwFlags : windef.DWORD; pvPara : void_const_ptr;
hCertStore : wincrypt.HCERTSTORE;
pStoreProvInfo : access struct_CERT_STORE_PROV_INFO)
return windef.WINBOOL;
pragma Convention (C, access_c5856a85);
subtype PFN_CERT_DLL_OPEN_STORE_PROV_FUNC is access_c5856a85;
type access_176f730c is access procedure (hStoreProv : HCERTSTOREPROV;
dwFlags : windef.DWORD);
pragma Convention (C, access_176f730c);
subtype PFN_CERT_STORE_PROV_CLOSE is access_176f730c;
type access_26fc7a46 is access function (hStoreProv : HCERTSTOREPROV;
pStoreCertContext : access constant CERT_CONTEXT;
dwFlags : windef.DWORD; ppProvCertContext : access PCCERT_CONTEXT)
return windef.WINBOOL;
pragma Convention (C, access_26fc7a46);
subtype PFN_CERT_STORE_PROV_READ_CERT is access_26fc7a46;
type access_35557121 is access function (hStoreProv : HCERTSTOREPROV;
pCertContext : access constant CERT_CONTEXT; dwFlags : windef.DWORD)
return windef.WINBOOL;
pragma Convention (C, access_35557121);
subtype PFN_CERT_STORE_PROV_WRITE_CERT is access_35557121;
type access_630fb1da is access function (hStoreProv : HCERTSTOREPROV;
pCertContext : access constant CERT_CONTEXT; dwFlags : windef.DWORD)
return windef.WINBOOL;
pragma Convention (C, access_630fb1da);
subtype PFN_CERT_STORE_PROV_DELETE_CERT is access_630fb1da;
type access_1d1974e2 is access function (hStoreProv : HCERTSTOREPROV;
pCertContext : access constant CERT_CONTEXT; dwPropId : windef.DWORD;
dwFlags : windef.DWORD; pvData : void_const_ptr) return windef.WINBOOL;
pragma Convention (C, access_1d1974e2);
subtype PFN_CERT_STORE_PROV_SET_CERT_PROPERTY is access_1d1974e2;
type access_f91f376e is access function (hStoreProv : HCERTSTOREPROV;
pStoreCrlContext : access constant CRL_CONTEXT; dwFlags : windef.DWORD;
ppProvCrlContext : access PCCRL_CONTEXT) return windef.WINBOOL;
pragma Convention (C, access_f91f376e);
subtype PFN_CERT_STORE_PROV_READ_CRL is access_f91f376e;
type access_e5648ece is access function (hStoreProv : HCERTSTOREPROV;
pCrlContext : access constant CRL_CONTEXT; dwFlags : windef.DWORD)
return windef.WINBOOL;
pragma Convention (C, access_e5648ece);
subtype PFN_CERT_STORE_PROV_WRITE_CRL is access_e5648ece;
type access_4e1122e8 is access function (hStoreProv : HCERTSTOREPROV;
pCrlContext : access constant CRL_CONTEXT; dwFlags : windef.DWORD)
return windef.WINBOOL;
pragma Convention (C, access_4e1122e8);
subtype PFN_CERT_STORE_PROV_DELETE_CRL is access_4e1122e8;
type access_83a6b153 is access function (hStoreProv : HCERTSTOREPROV;
pCrlContext : access constant CRL_CONTEXT; dwPropId : windef.DWORD;
dwFlags : windef.DWORD; pvData : void_const_ptr) return windef.WINBOOL;
pragma Convention (C, access_83a6b153);
subtype PFN_CERT_STORE_PROV_SET_CRL_PROPERTY is access_83a6b153;
type access_a7a3501c is access function (hStoreProv : HCERTSTOREPROV;
pStoreCtlContext : access constant CTL_CONTEXT; dwFlags : windef.DWORD;
ppProvCtlContext : access PCCTL_CONTEXT) return windef.WINBOOL;
pragma Convention (C, access_a7a3501c);
subtype PFN_CERT_STORE_PROV_READ_CTL is access_a7a3501c;
type access_952b4112 is access function (hStoreProv : HCERTSTOREPROV;
pCtlContext : access constant CTL_CONTEXT; dwFlags : windef.DWORD)
return windef.WINBOOL;
pragma Convention (C, access_952b4112);
subtype PFN_CERT_STORE_PROV_WRITE_CTL is access_952b4112;
type access_c74f4f2d is access function (hStoreProv : HCERTSTOREPROV;
pCtlContext : access constant CTL_CONTEXT; dwFlags : windef.DWORD)
return windef.WINBOOL;
pragma Convention (C, access_c74f4f2d);
subtype PFN_CERT_STORE_PROV_DELETE_CTL is access_c74f4f2d;
type access_988e88fe is access function (hStoreProv : HCERTSTOREPROV;
pCtlContext : access constant CTL_CONTEXT; dwPropId : windef.DWORD;
dwFlags : windef.DWORD; pvData : void_const_ptr) return windef.WINBOOL;
pragma Convention (C, access_988e88fe);
subtype PFN_CERT_STORE_PROV_SET_CTL_PROPERTY is access_988e88fe;
type access_eafbe3b7 is access function (hStoreProv : HCERTSTOREPROV;
dwFlags : windef.DWORD; dwCtrlType : windef.DWORD;
pvCtrlPara : void_const_ptr) return windef.WINBOOL;
pragma Convention (C, access_eafbe3b7);
subtype PFN_CERT_STORE_PROV_CONTROL is access_eafbe3b7;
type struct_CERT_STORE_PROV_FIND_INFO;
type struct_CERT_STORE_PROV_FIND_INFO is record
cbSize : aliased windef.DWORD;
dwMsgAndCertEncodingType : aliased windef.DWORD;
dwFindFlags : aliased windef.DWORD;
dwFindType : aliased windef.DWORD;
pvFindPara : aliased void_const_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_CERT_STORE_PROV_FIND_INFO);
type struct_CERT_STORE_PROV_FIND_INFO_ptr is
access all struct_CERT_STORE_PROV_FIND_INFO;
for struct_CERT_STORE_PROV_FIND_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_STORE_PROV_FIND_INFO_ptr);
pragma Convention (C, struct_CERT_STORE_PROV_FIND_INFO_ptr);
type struct_CERT_STORE_PROV_FIND_INFO_const_ptr is
access constant struct_CERT_STORE_PROV_FIND_INFO;
for struct_CERT_STORE_PROV_FIND_INFO_const_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_STORE_PROV_FIND_INFO_const_ptr);
pragma Convention (C, struct_CERT_STORE_PROV_FIND_INFO_const_ptr);
subtype CERT_STORE_PROV_FIND_INFO is struct_CERT_STORE_PROV_FIND_INFO;
subtype CERT_STORE_PROV_FIND_INFO_const_ptr is
struct_CERT_STORE_PROV_FIND_INFO_const_ptr;
subtype PCERT_STORE_PROV_FIND_INFO is
struct_CERT_STORE_PROV_FIND_INFO_ptr;
subtype CCERT_STORE_PROV_FIND_INFO is CERT_STORE_PROV_FIND_INFO;
subtype PCCERT_STORE_PROV_FIND_INFO is
CERT_STORE_PROV_FIND_INFO_const_ptr;
type access_e0222fb1 is access function (hStoreProv : HCERTSTOREPROV;
pFindInfo : access constant CERT_STORE_PROV_FIND_INFO;
pPrevCertContext : access constant CERT_CONTEXT;
dwFlags : windef.DWORD; ppvStoreProvFindInfo : access void_ptr;
ppProvCertContext : access PCCERT_CONTEXT) return windef.WINBOOL;
pragma Convention (C, access_e0222fb1);
subtype PFN_CERT_STORE_PROV_FIND_CERT is access_e0222fb1;
type access_2bbafa9f is access function (hStoreProv : HCERTSTOREPROV;
pCertContext : access constant CERT_CONTEXT;
pvStoreProvFindInfo : void_ptr; dwFlags : windef.DWORD)
return windef.WINBOOL;
pragma Convention (C, access_2bbafa9f);
subtype PFN_CERT_STORE_PROV_FREE_FIND_CERT is access_2bbafa9f;
type access_73a035b6 is access function (hStoreProv : HCERTSTOREPROV;
pCertContext : access constant CERT_CONTEXT; dwPropId : windef.DWORD;
dwFlags : windef.DWORD; pvData : void_ptr;
pcbData : access windef.DWORD) return windef.WINBOOL;
pragma Convention (C, access_73a035b6);
subtype PFN_CERT_STORE_PROV_GET_CERT_PROPERTY is access_73a035b6;
type access_6d1205fc is access function (hStoreProv : HCERTSTOREPROV;
pFindInfo : access constant CERT_STORE_PROV_FIND_INFO;
pPrevCrlContext : access constant CRL_CONTEXT; dwFlags : windef.DWORD;
ppvStoreProvFindInfo : access void_ptr;
ppProvCrlContext : access PCCRL_CONTEXT) return windef.WINBOOL;
pragma Convention (C, access_6d1205fc);
subtype PFN_CERT_STORE_PROV_FIND_CRL is access_6d1205fc;
type access_34e77774 is access function (hStoreProv : HCERTSTOREPROV;
pCrlContext : access constant CRL_CONTEXT;
pvStoreProvFindInfo : void_ptr; dwFlags : windef.DWORD)
return windef.WINBOOL;
pragma Convention (C, access_34e77774);
subtype PFN_CERT_STORE_PROV_FREE_FIND_CRL is access_34e77774;
type access_25242645 is access function (hStoreProv : HCERTSTOREPROV;
pCrlContext : access constant CRL_CONTEXT; dwPropId : windef.DWORD;
dwFlags : windef.DWORD; pvData : void_ptr;
pcbData : access windef.DWORD) return windef.WINBOOL;
pragma Convention (C, access_25242645);
subtype PFN_CERT_STORE_PROV_GET_CRL_PROPERTY is access_25242645;
type access_32031801 is access function (hStoreProv : HCERTSTOREPROV;
pFindInfo : access constant CERT_STORE_PROV_FIND_INFO;
pPrevCtlContext : access constant CTL_CONTEXT; dwFlags : windef.DWORD;
ppvStoreProvFindInfo : access void_ptr;
ppProvCtlContext : access PCCTL_CONTEXT) return windef.WINBOOL;
pragma Convention (C, access_32031801);
subtype PFN_CERT_STORE_PROV_FIND_CTL is access_32031801;
type access_ee64cf9d is access function (hStoreProv : HCERTSTOREPROV;
pCtlContext : access constant CTL_CONTEXT;
pvStoreProvFindInfo : void_ptr; dwFlags : windef.DWORD)
return windef.WINBOOL;
pragma Convention (C, access_ee64cf9d);
subtype PFN_CERT_STORE_PROV_FREE_FIND_CTL is access_ee64cf9d;
type access_ebfc3970 is access function (hStoreProv : HCERTSTOREPROV;
pCtlContext : access constant CTL_CONTEXT; dwPropId : windef.DWORD;
dwFlags : windef.DWORD; pvData : void_ptr;
pcbData : access windef.DWORD) return windef.WINBOOL;
pragma Convention (C, access_ebfc3970);
subtype PFN_CERT_STORE_PROV_GET_CTL_PROPERTY is access_ebfc3970;
function CertDuplicateStore (hCertStore : wincrypt.HCERTSTORE)
return wincrypt.HCERTSTORE;
pragma Import (C, CertDuplicateStore, "CertDuplicateStore");
function CertSaveStore (hCertStore : wincrypt.HCERTSTORE;
dwEncodingType : windef.DWORD; dwSaveAs : windef.DWORD;
dwSaveTo : windef.DWORD; pvSaveToPara : void_ptr;
dwFlags : windef.DWORD) return windef.WINBOOL;
pragma Import (C, CertSaveStore, "CertSaveStore");
function CertCloseStore (hCertStore : wincrypt.HCERTSTORE;
dwFlags : windef.DWORD) return windef.WINBOOL;
pragma Import (C, CertCloseStore, "CertCloseStore");
function CertGetSubjectCertificateFromStore (
hCertStore : wincrypt.HCERTSTORE; dwCertEncodingType : windef.DWORD;
pCertId : access struct_CERT_INFO) return PCCERT_CONTEXT;
pragma Import (C, CertGetSubjectCertificateFromStore,
"CertGetSubjectCertificateFromStore");
function CertEnumCertificatesInStore (hCertStore : wincrypt.HCERTSTORE;
pPrevCertContext : access constant CERT_CONTEXT) return PCCERT_CONTEXT;
pragma Import (C, CertEnumCertificatesInStore,
"CertEnumCertificatesInStore");
function CertFindCertificateInStore (hCertStore : wincrypt.HCERTSTORE;
dwCertEncodingType : windef.DWORD; dwFindFlags : windef.DWORD;
dwFindType : windef.DWORD; pvFindPara : void_const_ptr;
pPrevCertContext : access constant CERT_CONTEXT) return PCCERT_CONTEXT;
pragma Import (C, CertFindCertificateInStore,
"CertFindCertificateInStore");
function CertGetIssuerCertificateFromStore (
hCertStore : wincrypt.HCERTSTORE;
pSubjectContext : access constant CERT_CONTEXT;
pPrevIssuerContext : access constant CERT_CONTEXT;
pdwFlags : access windef.DWORD) return PCCERT_CONTEXT;
pragma Import (C, CertGetIssuerCertificateFromStore,
"CertGetIssuerCertificateFromStore");
function CertVerifySubjectCertificateContext (
pSubject : access constant CERT_CONTEXT;
pIssuer : access constant CERT_CONTEXT; pdwFlags : access windef.DWORD)
return windef.WINBOOL;
pragma Import (C, CertVerifySubjectCertificateContext,
"CertVerifySubjectCertificateContext");
function CertDuplicateCertificateContext (
pCertContext : access constant CERT_CONTEXT) return PCCERT_CONTEXT;
pragma Import (C, CertDuplicateCertificateContext,
"CertDuplicateCertificateContext");
function CertCreateCertificateContext (dwCertEncodingType : windef.DWORD;
pbCertEncoded : access constant windef.BYTE;
cbCertEncoded : windef.DWORD) return PCCERT_CONTEXT;
pragma Import (C, CertCreateCertificateContext,
"CertCreateCertificateContext");
function CertFreeCertificateContext (
pCertContext : access constant CERT_CONTEXT) return windef.WINBOOL;
pragma Import (C, CertFreeCertificateContext,
"CertFreeCertificateContext");
function CertSetCertificateContextProperty (
pCertContext : access constant CERT_CONTEXT; dwPropId : windef.DWORD;
dwFlags : windef.DWORD; pvData : void_const_ptr) return windef.WINBOOL;
pragma Import (C, CertSetCertificateContextProperty,
"CertSetCertificateContextProperty");
function CertGetCertificateContextProperty (
pCertContext : access constant CERT_CONTEXT; dwPropId : windef.DWORD;
pvData : void_ptr; pcbData : access windef.DWORD)
return windef.WINBOOL;
pragma Import (C, CertGetCertificateContextProperty,
"CertGetCertificateContextProperty");
function CertEnumCertificateContextProperties (
pCertContext : access constant CERT_CONTEXT; dwPropId : windef.DWORD)
return windef.DWORD;
pragma Import (C, CertEnumCertificateContextProperties,
"CertEnumCertificateContextProperties");
function CertCreateCTLEntryFromCertificateContextProperties (
pCertContext : access constant CERT_CONTEXT; cOptAttr : windef.DWORD;
rgOptAttr : access struct_CRYPT_ATTRIBUTE; dwFlags : windef.DWORD;
pvReserved : void_ptr; pCtlEntry : access struct_CTL_ENTRY;
pcbCtlEntry : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, CertCreateCTLEntryFromCertificateContextProperties,
"CertCreateCTLEntryFromCertificateContextProperties");
function CertSetCertificateContextPropertiesFromCTLEntry (
pCertContext : access constant CERT_CONTEXT;
pCtlEntry : access struct_CTL_ENTRY; dwFlags : windef.DWORD)
return windef.WINBOOL;
pragma Import (C, CertSetCertificateContextPropertiesFromCTLEntry,
"CertSetCertificateContextPropertiesFromCTLEntry");
function CertGetCRLFromStore (hCertStore : wincrypt.HCERTSTORE;
pIssuerContext : access constant CERT_CONTEXT;
pPrevCrlContext : access constant CRL_CONTEXT;
pdwFlags : access windef.DWORD) return PCCRL_CONTEXT;
pragma Import (C, CertGetCRLFromStore, "CertGetCRLFromStore");
function CertEnumCRLsInStore (hCertStore : wincrypt.HCERTSTORE;
pPrevCrlContext : access constant CRL_CONTEXT) return PCCRL_CONTEXT;
pragma Import (C, CertEnumCRLsInStore, "CertEnumCRLsInStore");
function CertFindCRLInStore (hCertStore : wincrypt.HCERTSTORE;
dwCertEncodingType : windef.DWORD; dwFindFlags : windef.DWORD;
dwFindType : windef.DWORD; pvFindPara : void_const_ptr;
pPrevCrlContext : access constant CRL_CONTEXT) return PCCRL_CONTEXT;
pragma Import (C, CertFindCRLInStore, "CertFindCRLInStore");
type struct_CRL_FIND_ISSUED_FOR_PARA;
type struct_CRL_FIND_ISSUED_FOR_PARA is record
pSubjectCert : aliased PCCERT_CONTEXT;
pIssuerCert : aliased PCCERT_CONTEXT;
end record;
pragma Convention (C_Pass_By_Copy, struct_CRL_FIND_ISSUED_FOR_PARA);
type struct_CRL_FIND_ISSUED_FOR_PARA_ptr is
access all struct_CRL_FIND_ISSUED_FOR_PARA;
for struct_CRL_FIND_ISSUED_FOR_PARA_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRL_FIND_ISSUED_FOR_PARA_ptr);
pragma Convention (C, struct_CRL_FIND_ISSUED_FOR_PARA_ptr);
subtype CRL_FIND_ISSUED_FOR_PARA is struct_CRL_FIND_ISSUED_FOR_PARA;
subtype PCRL_FIND_ISSUED_FOR_PARA is struct_CRL_FIND_ISSUED_FOR_PARA_ptr;
function CertDuplicateCRLContext (
pCrlContext : access constant CRL_CONTEXT) return PCCRL_CONTEXT;
pragma Import (C, CertDuplicateCRLContext, "CertDuplicateCRLContext");
function CertCreateCRLContext (dwCertEncodingType : windef.DWORD;
pbCrlEncoded : access constant windef.BYTE;
cbCrlEncoded : windef.DWORD) return PCCRL_CONTEXT;
pragma Import (C, CertCreateCRLContext, "CertCreateCRLContext");
function CertFreeCRLContext (pCrlContext : access constant CRL_CONTEXT)
return windef.WINBOOL;
pragma Import (C, CertFreeCRLContext, "CertFreeCRLContext");
function CertSetCRLContextProperty (
pCrlContext : access constant CRL_CONTEXT; dwPropId : windef.DWORD;
dwFlags : windef.DWORD; pvData : void_const_ptr) return windef.WINBOOL;
pragma Import (C, CertSetCRLContextProperty, "CertSetCRLContextProperty");
function CertGetCRLContextProperty (
pCrlContext : access constant CRL_CONTEXT; dwPropId : windef.DWORD;
pvData : void_ptr; pcbData : access windef.DWORD)
return windef.WINBOOL;
pragma Import (C, CertGetCRLContextProperty, "CertGetCRLContextProperty");
function CertEnumCRLContextProperties (
pCrlContext : access constant CRL_CONTEXT; dwPropId : windef.DWORD)
return windef.DWORD;
pragma Import (C, CertEnumCRLContextProperties,
"CertEnumCRLContextProperties");
function CertFindCertificateInCRL (pCert : access constant CERT_CONTEXT;
pCrlContext : access constant CRL_CONTEXT; dwFlags : windef.DWORD;
pvReserved : void_ptr; ppCrlEntry : access PCRL_ENTRY)
return windef.WINBOOL;
pragma Import (C, CertFindCertificateInCRL, "CertFindCertificateInCRL");
function CertIsValidCRLForCertificate (
pCert : access constant CERT_CONTEXT;
pCrl : access constant CRL_CONTEXT; dwFlags : windef.DWORD;
pvReserved : void_ptr) return windef.WINBOOL;
pragma Import (C, CertIsValidCRLForCertificate,
"CertIsValidCRLForCertificate");
function CertAddEncodedCertificateToStore (
hCertStore : wincrypt.HCERTSTORE; dwCertEncodingType : windef.DWORD;
pbCertEncoded : access constant windef.BYTE;
cbCertEncoded : windef.DWORD; dwAddDisposition : windef.DWORD;
ppCertContext : access PCCERT_CONTEXT) return windef.WINBOOL;
pragma Import (C, CertAddEncodedCertificateToStore,
"CertAddEncodedCertificateToStore");
function CertAddCertificateContextToStore (
hCertStore : wincrypt.HCERTSTORE;
pCertContext : access constant CERT_CONTEXT;
dwAddDisposition : windef.DWORD;
ppStoreContext : access PCCERT_CONTEXT) return windef.WINBOOL;
pragma Import (C, CertAddCertificateContextToStore,
"CertAddCertificateContextToStore");
function CertAddSerializedElementToStore (
hCertStore : wincrypt.HCERTSTORE;
pbElement : access constant windef.BYTE; cbElement : windef.DWORD;
dwAddDisposition : windef.DWORD; dwFlags : windef.DWORD;
dwContextTypeFlags : windef.DWORD;
pdwContextType : access windef.DWORD;
ppvContext : access void_const_ptr) return windef.WINBOOL;
pragma Import (C, CertAddSerializedElementToStore,
"CertAddSerializedElementToStore");
function CertDeleteCertificateFromStore (
pCertContext : access constant CERT_CONTEXT) return windef.WINBOOL;
pragma Import (C, CertDeleteCertificateFromStore,
"CertDeleteCertificateFromStore");
function CertAddEncodedCRLToStore (hCertStore : wincrypt.HCERTSTORE;
dwCertEncodingType : windef.DWORD;
pbCrlEncoded : access constant windef.BYTE;
cbCrlEncoded : windef.DWORD; dwAddDisposition : windef.DWORD;
ppCrlContext : access PCCRL_CONTEXT) return windef.WINBOOL;
pragma Import (C, CertAddEncodedCRLToStore, "CertAddEncodedCRLToStore");
function CertAddCRLContextToStore (hCertStore : wincrypt.HCERTSTORE;
pCrlContext : access constant CRL_CONTEXT;
dwAddDisposition : windef.DWORD; ppStoreContext : access PCCRL_CONTEXT)
return windef.WINBOOL;
pragma Import (C, CertAddCRLContextToStore, "CertAddCRLContextToStore");
function CertDeleteCRLFromStore (
pCrlContext : access constant CRL_CONTEXT) return windef.WINBOOL;
pragma Import (C, CertDeleteCRLFromStore, "CertDeleteCRLFromStore");
function CertSerializeCertificateStoreElement (
pCertContext : access constant CERT_CONTEXT; dwFlags : windef.DWORD;
pbElement : access windef.BYTE; pcbElement : access windef.DWORD)
return windef.WINBOOL;
pragma Import (C, CertSerializeCertificateStoreElement,
"CertSerializeCertificateStoreElement");
function CertSerializeCRLStoreElement (
pCrlContext : access constant CRL_CONTEXT; dwFlags : windef.DWORD;
pbElement : access windef.BYTE; pcbElement : access windef.DWORD)
return windef.WINBOOL;
pragma Import (C, CertSerializeCRLStoreElement,
"CertSerializeCRLStoreElement");
function CertDuplicateCTLContext (
pCtlContext : access constant CTL_CONTEXT) return PCCTL_CONTEXT;
pragma Import (C, CertDuplicateCTLContext, "CertDuplicateCTLContext");
function CertCreateCTLContext (dwMsgAndCertEncodingType : windef.DWORD;
pbCtlEncoded : access constant windef.BYTE;
cbCtlEncoded : windef.DWORD) return PCCTL_CONTEXT;
pragma Import (C, CertCreateCTLContext, "CertCreateCTLContext");
function CertFreeCTLContext (pCtlContext : access constant CTL_CONTEXT)
return windef.WINBOOL;
pragma Import (C, CertFreeCTLContext, "CertFreeCTLContext");
function CertSetCTLContextProperty (
pCtlContext : access constant CTL_CONTEXT; dwPropId : windef.DWORD;
dwFlags : windef.DWORD; pvData : void_const_ptr) return windef.WINBOOL;
pragma Import (C, CertSetCTLContextProperty, "CertSetCTLContextProperty");
function CertGetCTLContextProperty (
pCtlContext : access constant CTL_CONTEXT; dwPropId : windef.DWORD;
pvData : void_ptr; pcbData : access windef.DWORD)
return windef.WINBOOL;
pragma Import (C, CertGetCTLContextProperty, "CertGetCTLContextProperty");
function CertEnumCTLContextProperties (
pCtlContext : access constant CTL_CONTEXT; dwPropId : windef.DWORD)
return windef.DWORD;
pragma Import (C, CertEnumCTLContextProperties,
"CertEnumCTLContextProperties");
function CertEnumCTLsInStore (hCertStore : wincrypt.HCERTSTORE;
pPrevCtlContext : access constant CTL_CONTEXT) return PCCTL_CONTEXT;
pragma Import (C, CertEnumCTLsInStore, "CertEnumCTLsInStore");
function CertFindSubjectInCTL (dwEncodingType : windef.DWORD;
dwSubjectType : windef.DWORD; pvSubject : void_ptr;
pCtlContext : access constant CTL_CONTEXT; dwFlags : windef.DWORD)
return PCTL_ENTRY;
pragma Import (C, CertFindSubjectInCTL, "CertFindSubjectInCTL");
type struct_CTL_ANY_SUBJECT_INFO;
type struct_CTL_ANY_SUBJECT_INFO is record
SubjectAlgorithm : aliased CRYPT_ALGORITHM_IDENTIFIER;
SubjectIdentifier : aliased CRYPT_DATA_BLOB;
end record;
pragma Convention (C_Pass_By_Copy, struct_CTL_ANY_SUBJECT_INFO);
type struct_CTL_ANY_SUBJECT_INFO_ptr is
access all struct_CTL_ANY_SUBJECT_INFO;
for struct_CTL_ANY_SUBJECT_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CTL_ANY_SUBJECT_INFO_ptr);
pragma Convention (C, struct_CTL_ANY_SUBJECT_INFO_ptr);
subtype CTL_ANY_SUBJECT_INFO is struct_CTL_ANY_SUBJECT_INFO;
subtype PCTL_ANY_SUBJECT_INFO is struct_CTL_ANY_SUBJECT_INFO_ptr;
function CertFindCTLInStore (hCertStore : wincrypt.HCERTSTORE;
dwMsgAndCertEncodingType : windef.DWORD; dwFindFlags : windef.DWORD;
dwFindType : windef.DWORD; pvFindPara : void_const_ptr;
pPrevCtlContext : access constant CTL_CONTEXT) return PCCTL_CONTEXT;
pragma Import (C, CertFindCTLInStore, "CertFindCTLInStore");
type struct_CTL_FIND_USAGE_PARA;
type struct_CTL_FIND_USAGE_PARA is record
cbSize : aliased windef.DWORD;
SubjectUsage : aliased CTL_USAGE;
ListIdentifier : aliased CRYPT_DATA_BLOB;
pSigner : aliased PCERT_INFO;
end record;
pragma Convention (C_Pass_By_Copy, struct_CTL_FIND_USAGE_PARA);
type struct_CTL_FIND_USAGE_PARA_ptr is
access all struct_CTL_FIND_USAGE_PARA;
for struct_CTL_FIND_USAGE_PARA_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CTL_FIND_USAGE_PARA_ptr);
pragma Convention (C, struct_CTL_FIND_USAGE_PARA_ptr);
subtype CTL_FIND_USAGE_PARA is struct_CTL_FIND_USAGE_PARA;
subtype PCTL_FIND_USAGE_PARA is struct_CTL_FIND_USAGE_PARA_ptr;
type struct_CTL_FIND_SUBJECT_PARA;
type struct_CTL_FIND_SUBJECT_PARA is record
cbSize : aliased windef.DWORD;
pUsagePara : aliased PCTL_FIND_USAGE_PARA;
dwSubjectType : aliased windef.DWORD;
pvSubject : aliased void_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_CTL_FIND_SUBJECT_PARA);
type struct_CTL_FIND_SUBJECT_PARA_ptr is
access all struct_CTL_FIND_SUBJECT_PARA;
for struct_CTL_FIND_SUBJECT_PARA_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CTL_FIND_SUBJECT_PARA_ptr);
pragma Convention (C, struct_CTL_FIND_SUBJECT_PARA_ptr);
subtype CTL_FIND_SUBJECT_PARA is struct_CTL_FIND_SUBJECT_PARA;
subtype PCTL_FIND_SUBJECT_PARA is struct_CTL_FIND_SUBJECT_PARA_ptr;
function CertAddEncodedCTLToStore (hCertStore : wincrypt.HCERTSTORE;
dwMsgAndCertEncodingType : windef.DWORD;
pbCtlEncoded : access constant windef.BYTE;
cbCtlEncoded : windef.DWORD; dwAddDisposition : windef.DWORD;
ppCtlContext : access PCCTL_CONTEXT) return windef.WINBOOL;
pragma Import (C, CertAddEncodedCTLToStore, "CertAddEncodedCTLToStore");
function CertAddCTLContextToStore (hCertStore : wincrypt.HCERTSTORE;
pCtlContext : access constant CTL_CONTEXT;
dwAddDisposition : windef.DWORD; ppStoreContext : access PCCTL_CONTEXT)
return windef.WINBOOL;
pragma Import (C, CertAddCTLContextToStore, "CertAddCTLContextToStore");
function CertSerializeCTLStoreElement (
pCtlContext : access constant CTL_CONTEXT; dwFlags : windef.DWORD;
pbElement : access windef.BYTE; pcbElement : access windef.DWORD)
return windef.WINBOOL;
pragma Import (C, CertSerializeCTLStoreElement,
"CertSerializeCTLStoreElement");
function CertDeleteCTLFromStore (
pCtlContext : access constant CTL_CONTEXT) return windef.WINBOOL;
pragma Import (C, CertDeleteCTLFromStore, "CertDeleteCTLFromStore");
function CertAddCertificateLinkToStore (hCertStore : wincrypt.HCERTSTORE;
pCertContext : access constant CERT_CONTEXT;
dwAddDisposition : windef.DWORD;
ppStoreContext : access PCCERT_CONTEXT) return windef.WINBOOL;
pragma Import (C, CertAddCertificateLinkToStore,
"CertAddCertificateLinkToStore");
function CertAddCRLLinkToStore (hCertStore : wincrypt.HCERTSTORE;
pCrlContext : access constant CRL_CONTEXT;
dwAddDisposition : windef.DWORD; ppStoreContext : access PCCRL_CONTEXT)
return windef.WINBOOL;
pragma Import (C, CertAddCRLLinkToStore, "CertAddCRLLinkToStore");
function CertAddCTLLinkToStore (hCertStore : wincrypt.HCERTSTORE;
pCtlContext : access constant CTL_CONTEXT;
dwAddDisposition : windef.DWORD; ppStoreContext : access PCCTL_CONTEXT)
return windef.WINBOOL;
pragma Import (C, CertAddCTLLinkToStore, "CertAddCTLLinkToStore");
function CertAddStoreToCollection (hCollectionStore : HCERTSTORE;
hSiblingStore : HCERTSTORE; dwUpdateFlags : windef.DWORD;
dwPriority : windef.DWORD) return windef.WINBOOL;
pragma Import (C, CertAddStoreToCollection, "CertAddStoreToCollection");
procedure CertRemoveStoreFromCollection (hCollectionStore : HCERTSTORE;
hSiblingStore : HCERTSTORE);
pragma Import (C, CertRemoveStoreFromCollection,
"CertRemoveStoreFromCollection");
function CertControlStore (hCertStore : wincrypt.HCERTSTORE;
dwFlags : windef.DWORD; dwCtrlType : windef.DWORD;
pvCtrlPara : void_const_ptr) return windef.WINBOOL;
pragma Import (C, CertControlStore, "CertControlStore");
function CertSetStoreProperty (hCertStore : wincrypt.HCERTSTORE;
dwPropId : windef.DWORD; dwFlags : windef.DWORD;
pvData : void_const_ptr) return windef.WINBOOL;
pragma Import (C, CertSetStoreProperty, "CertSetStoreProperty");
function CertGetStoreProperty (hCertStore : wincrypt.HCERTSTORE;
dwPropId : windef.DWORD; pvData : void_ptr;
pcbData : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, CertGetStoreProperty, "CertGetStoreProperty");
type struct_CERT_CREATE_CONTEXT_PARA;
type struct_CERT_CREATE_CONTEXT_PARA is record
cbSize : aliased windef.DWORD;
pfnFree : aliased PFN_CRYPT_FREE;
pvFree : aliased void_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_CERT_CREATE_CONTEXT_PARA);
type struct_CERT_CREATE_CONTEXT_PARA_ptr is
access all struct_CERT_CREATE_CONTEXT_PARA;
for struct_CERT_CREATE_CONTEXT_PARA_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_CREATE_CONTEXT_PARA_ptr);
pragma Convention (C, struct_CERT_CREATE_CONTEXT_PARA_ptr);
subtype CERT_CREATE_CONTEXT_PARA is struct_CERT_CREATE_CONTEXT_PARA;
subtype PCERT_CREATE_CONTEXT_PARA is struct_CERT_CREATE_CONTEXT_PARA_ptr;
function CertCreateContext (dwContextType : windef.DWORD;
dwEncodingType : windef.DWORD; pbEncoded : access constant windef.BYTE;
cbEncoded : windef.DWORD; dwFlags : windef.DWORD;
pCreatePara : access struct_CERT_CREATE_CONTEXT_PARA)
return void_const_ptr;
pragma Import (C, CertCreateContext, "CertCreateContext");
type struct_CERT_SYSTEM_STORE_INFO;
type struct_CERT_SYSTEM_STORE_INFO is record
cbSize : aliased windef.DWORD;
end record;
pragma Convention (C_Pass_By_Copy, struct_CERT_SYSTEM_STORE_INFO);
type struct_CERT_SYSTEM_STORE_INFO_ptr is
access all struct_CERT_SYSTEM_STORE_INFO;
for struct_CERT_SYSTEM_STORE_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_SYSTEM_STORE_INFO_ptr);
pragma Convention (C, struct_CERT_SYSTEM_STORE_INFO_ptr);
subtype CERT_SYSTEM_STORE_INFO is struct_CERT_SYSTEM_STORE_INFO;
subtype PCERT_SYSTEM_STORE_INFO is struct_CERT_SYSTEM_STORE_INFO_ptr;
type struct_CERT_PHYSICAL_STORE_INFO;
type struct_CERT_PHYSICAL_STORE_INFO is record
cbSize : aliased windef.DWORD;
pszOpenStoreProvider : aliased winnt.LPSTR;
dwOpenEncodingType : aliased windef.DWORD;
dwOpenFlags : aliased windef.DWORD;
OpenParameters : aliased CRYPT_DATA_BLOB;
dwFlags : aliased windef.DWORD;
dwPriority : aliased windef.DWORD;
end record;
pragma Convention (C_Pass_By_Copy, struct_CERT_PHYSICAL_STORE_INFO);
type struct_CERT_PHYSICAL_STORE_INFO_ptr is
access all struct_CERT_PHYSICAL_STORE_INFO;
for struct_CERT_PHYSICAL_STORE_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_PHYSICAL_STORE_INFO_ptr);
pragma Convention (C, struct_CERT_PHYSICAL_STORE_INFO_ptr);
subtype CERT_PHYSICAL_STORE_INFO is struct_CERT_PHYSICAL_STORE_INFO;
subtype PCERT_PHYSICAL_STORE_INFO is struct_CERT_PHYSICAL_STORE_INFO_ptr;
function CertRegisterSystemStore (pvSystemStore : void_const_ptr;
dwFlags : windef.DWORD;
pStoreInfo : access struct_CERT_SYSTEM_STORE_INFO;
pvReserved : void_ptr) return windef.WINBOOL;
pragma Import (C, CertRegisterSystemStore, "CertRegisterSystemStore");
function CertRegisterPhysicalStore (pvSystemStore : void_const_ptr;
dwFlags : windef.DWORD; pwszStoreName : access constant winnt.WCHAR;
pStoreInfo : access struct_CERT_PHYSICAL_STORE_INFO;
pvReserved : void_ptr) return windef.WINBOOL;
pragma Import (C, CertRegisterPhysicalStore, "CertRegisterPhysicalStore");
function CertUnregisterSystemStore (pvSystemStore : void_const_ptr;
dwFlags : windef.DWORD) return windef.WINBOOL;
pragma Import (C, CertUnregisterSystemStore, "CertUnregisterSystemStore");
function CertUnregisterPhysicalStore (pvSystemStore : void_const_ptr;
dwFlags : windef.DWORD; pwszStoreName : access constant winnt.WCHAR)
return windef.WINBOOL;
pragma Import (C, CertUnregisterPhysicalStore,
"CertUnregisterPhysicalStore");
type access_e18e2210 is access function (
pwszStoreLocation : access constant winnt.WCHAR;
dwFlags : windef.DWORD; pvReserved : void_ptr; pvArg : void_ptr)
return windef.WINBOOL;
pragma Convention (C, access_e18e2210);
subtype PFN_CERT_ENUM_SYSTEM_STORE_LOCATION is access_e18e2210;
type access_1e43aa76 is access function (pvSystemStore : void_const_ptr;
dwFlags : windef.DWORD;
pStoreInfo : access struct_CERT_SYSTEM_STORE_INFO;
pvReserved : void_ptr; pvArg : void_ptr) return windef.WINBOOL;
pragma Convention (C, access_1e43aa76);
subtype PFN_CERT_ENUM_SYSTEM_STORE is access_1e43aa76;
type access_22a3d141 is access function (pvSystemStore : void_const_ptr;
dwFlags : windef.DWORD; pwszStoreName : access constant winnt.WCHAR;
pStoreInfo : access struct_CERT_PHYSICAL_STORE_INFO;
pvReserved : void_ptr; pvArg : void_ptr) return windef.WINBOOL;
pragma Convention (C, access_22a3d141);
subtype PFN_CERT_ENUM_PHYSICAL_STORE is access_22a3d141;
function CertEnumSystemStoreLocation (dwFlags : windef.DWORD;
pvArg : void_ptr; pfnEnum : PFN_CERT_ENUM_SYSTEM_STORE_LOCATION)
return windef.WINBOOL;
pragma Import (C, CertEnumSystemStoreLocation,
"CertEnumSystemStoreLocation");
function CertEnumSystemStore (dwFlags : windef.DWORD;
pvSystemStoreLocationPara : void_ptr; pvArg : void_ptr;
pfnEnum : PFN_CERT_ENUM_SYSTEM_STORE) return windef.WINBOOL;
pragma Import (C, CertEnumSystemStore, "CertEnumSystemStore");
function CertEnumPhysicalStore (pvSystemStore : void_const_ptr;
dwFlags : windef.DWORD; pvArg : void_ptr;
pfnEnum : PFN_CERT_ENUM_PHYSICAL_STORE) return windef.WINBOOL;
pragma Import (C, CertEnumPhysicalStore, "CertEnumPhysicalStore");
function CertGetEnhancedKeyUsage (
pCertContext : access constant CERT_CONTEXT; dwFlags : windef.DWORD;
pUsage : access struct_CTL_USAGE; pcbUsage : access windef.DWORD)
return windef.WINBOOL;
pragma Import (C, CertGetEnhancedKeyUsage, "CertGetEnhancedKeyUsage");
function CertSetEnhancedKeyUsage (
pCertContext : access constant CERT_CONTEXT;
pUsage : access struct_CTL_USAGE) return windef.WINBOOL;
pragma Import (C, CertSetEnhancedKeyUsage, "CertSetEnhancedKeyUsage");
function CertAddEnhancedKeyUsageIdentifier (
pCertContext : access constant CERT_CONTEXT;
pszUsageIdentifier : access constant winnt.C_CHAR)
return windef.WINBOOL;
pragma Import (C, CertAddEnhancedKeyUsageIdentifier,
"CertAddEnhancedKeyUsageIdentifier");
function CertRemoveEnhancedKeyUsageIdentifier (
pCertContext : access constant CERT_CONTEXT;
pszUsageIdentifier : access constant winnt.C_CHAR)
return windef.WINBOOL;
pragma Import (C, CertRemoveEnhancedKeyUsageIdentifier,
"CertRemoveEnhancedKeyUsageIdentifier");
function CertGetValidUsages (cCerts : windef.DWORD;
rghCerts : access PCCERT_CONTEXT; cNumOIDs : access signed_int;
rghOIDs : access winnt.LPSTR; pcbOIDs : access windef.DWORD)
return windef.WINBOOL;
pragma Import (C, CertGetValidUsages, "CertGetValidUsages");
function CryptMsgGetAndVerifySigner (hCryptMsg : wincrypt.HCRYPTMSG;
cSignerStore : windef.DWORD; rghSignerStore : access HCERTSTORE;
dwFlags : windef.DWORD; ppSigner : access PCCERT_CONTEXT;
pdwSignerIndex : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, CryptMsgGetAndVerifySigner,
"CryptMsgGetAndVerifySigner");
function CryptMsgSignCTL (dwMsgEncodingType : windef.DWORD;
pbCtlContent : access windef.BYTE; cbCtlContent : windef.DWORD;
pSignInfo : access struct_CMSG_SIGNED_ENCODE_INFO;
dwFlags : windef.DWORD; pbEncoded : access windef.BYTE;
pcbEncoded : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, CryptMsgSignCTL, "CryptMsgSignCTL");
function CryptMsgEncodeAndSignCTL (dwMsgEncodingType : windef.DWORD;
pCtlInfo : access struct_CTL_INFO;
pSignInfo : access struct_CMSG_SIGNED_ENCODE_INFO;
dwFlags : windef.DWORD; pbEncoded : access windef.BYTE;
pcbEncoded : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, CryptMsgEncodeAndSignCTL, "CryptMsgEncodeAndSignCTL");
function CertFindSubjectInSortedCTL (
pSubjectIdentifier : access struct_CRYPTOAPI_BLOB;
pCtlContext : access constant CTL_CONTEXT; dwFlags : windef.DWORD;
pvReserved : void_ptr;
pEncodedAttributes : access struct_CRYPTOAPI_BLOB)
return windef.WINBOOL;
pragma Import (C, CertFindSubjectInSortedCTL,
"CertFindSubjectInSortedCTL");
function CertEnumSubjectInSortedCTL (
pCtlContext : access constant CTL_CONTEXT;
ppvNextSubject : access void_ptr;
pSubjectIdentifier : access struct_CRYPTOAPI_BLOB;
pEncodedAttributes : access struct_CRYPTOAPI_BLOB)
return windef.WINBOOL;
pragma Import (C, CertEnumSubjectInSortedCTL,
"CertEnumSubjectInSortedCTL");
type struct_CTL_VERIFY_USAGE_PARA;
type struct_CTL_VERIFY_USAGE_PARA is record
cbSize : aliased windef.DWORD;
ListIdentifier : aliased CRYPT_DATA_BLOB;
cCtlStore : aliased windef.DWORD;
rghCtlStore : aliased HCERTSTORE_ptr;
cSignerStore : aliased windef.DWORD;
rghSignerStore : aliased HCERTSTORE_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_CTL_VERIFY_USAGE_PARA);
type struct_CTL_VERIFY_USAGE_PARA_ptr is
access all struct_CTL_VERIFY_USAGE_PARA;
for struct_CTL_VERIFY_USAGE_PARA_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CTL_VERIFY_USAGE_PARA_ptr);
pragma Convention (C, struct_CTL_VERIFY_USAGE_PARA_ptr);
subtype CTL_VERIFY_USAGE_PARA is struct_CTL_VERIFY_USAGE_PARA;
subtype PCTL_VERIFY_USAGE_PARA is struct_CTL_VERIFY_USAGE_PARA_ptr;
type struct_CTL_VERIFY_USAGE_STATUS;
type struct_CTL_VERIFY_USAGE_STATUS is record
cbSize : aliased windef.DWORD;
dwError : aliased windef.DWORD;
dwFlags : aliased windef.DWORD;
ppCtl : aliased PCCTL_CONTEXT_ptr;
dwCtlEntryIndex : aliased windef.DWORD;
ppSigner : aliased PCCERT_CONTEXT_ptr;
dwSignerIndex : aliased windef.DWORD;
end record;
pragma Convention (C_Pass_By_Copy, struct_CTL_VERIFY_USAGE_STATUS);
type struct_CTL_VERIFY_USAGE_STATUS_ptr is
access all struct_CTL_VERIFY_USAGE_STATUS;
for struct_CTL_VERIFY_USAGE_STATUS_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CTL_VERIFY_USAGE_STATUS_ptr);
pragma Convention (C, struct_CTL_VERIFY_USAGE_STATUS_ptr);
subtype CTL_VERIFY_USAGE_STATUS is struct_CTL_VERIFY_USAGE_STATUS;
subtype PCTL_VERIFY_USAGE_STATUS is struct_CTL_VERIFY_USAGE_STATUS_ptr;
function CertVerifyCTLUsage (dwEncodingType : windef.DWORD;
dwSubjectType : windef.DWORD; pvSubject : void_ptr;
pSubjectUsage : access struct_CTL_USAGE; dwFlags : windef.DWORD;
pVerifyUsagePara : access struct_CTL_VERIFY_USAGE_PARA;
pVerifyUsageStatus : access struct_CTL_VERIFY_USAGE_STATUS)
return windef.WINBOOL;
pragma Import (C, CertVerifyCTLUsage, "CertVerifyCTLUsage");
type struct_CERT_REVOCATION_CRL_INFO;
type struct_CERT_REVOCATION_CRL_INFO is record
cbSize : aliased windef.DWORD;
pBaseCrlContext : aliased PCCRL_CONTEXT;
pDeltaCrlContext : aliased PCCRL_CONTEXT;
pCrlEntry : aliased PCRL_ENTRY;
fDeltaCrlEntry : aliased windef.WINBOOL;
end record;
pragma Convention (C_Pass_By_Copy, struct_CERT_REVOCATION_CRL_INFO);
type struct_CERT_REVOCATION_CRL_INFO_ptr is
access all struct_CERT_REVOCATION_CRL_INFO;
for struct_CERT_REVOCATION_CRL_INFO_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_REVOCATION_CRL_INFO_ptr);
pragma Convention (C, struct_CERT_REVOCATION_CRL_INFO_ptr);
subtype CERT_REVOCATION_CRL_INFO is struct_CERT_REVOCATION_CRL_INFO;
subtype PCERT_REVOCATION_CRL_INFO is struct_CERT_REVOCATION_CRL_INFO_ptr;
type struct_CERT_REVOCATION_PARA;
type struct_CERT_REVOCATION_PARA is record
cbSize : aliased windef.DWORD;
pIssuerCert : aliased PCCERT_CONTEXT;
cCertStore : aliased windef.DWORD;
rgCertStore : aliased HCERTSTORE_ptr;
hCrlStore : aliased HCERTSTORE;
pftTimeToUse : aliased windef.LPFILETIME;
end record;
pragma Convention (C_Pass_By_Copy, struct_CERT_REVOCATION_PARA);
type struct_CERT_REVOCATION_PARA_ptr is
access all struct_CERT_REVOCATION_PARA;
for struct_CERT_REVOCATION_PARA_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_REVOCATION_PARA_ptr);
pragma Convention (C, struct_CERT_REVOCATION_PARA_ptr);
subtype CERT_REVOCATION_PARA is struct_CERT_REVOCATION_PARA;
subtype PCERT_REVOCATION_PARA is struct_CERT_REVOCATION_PARA_ptr;
type struct_CERT_REVOCATION_STATUS;
type struct_CERT_REVOCATION_STATUS is record
cbSize : aliased windef.DWORD;
dwIndex : aliased windef.DWORD;
dwError : aliased windef.DWORD;
dwReason : aliased windef.DWORD;
fHasFreshnessTime : aliased windef.WINBOOL;
dwFreshnessTime : aliased windef.DWORD;
end record;
pragma Convention (C_Pass_By_Copy, struct_CERT_REVOCATION_STATUS);
type struct_CERT_REVOCATION_STATUS_ptr is
access all struct_CERT_REVOCATION_STATUS;
for struct_CERT_REVOCATION_STATUS_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CERT_REVOCATION_STATUS_ptr);
pragma Convention (C, struct_CERT_REVOCATION_STATUS_ptr);
subtype CERT_REVOCATION_STATUS is struct_CERT_REVOCATION_STATUS;
subtype PCERT_REVOCATION_STATUS is struct_CERT_REVOCATION_STATUS_ptr;
function CertVerifyRevocation (dwEncodingType : windef.DWORD;
dwRevType : windef.DWORD; cContext : windef.DWORD;
rgpvContext : access winnt.PVOID; dwFlags : windef.DWORD;
pRevPara : access struct_CERT_REVOCATION_PARA;
pRevStatus : access struct_CERT_REVOCATION_STATUS)
return windef.WINBOOL;
pragma Import (C, CertVerifyRevocation, "CertVerifyRevocation");
function CertCompareIntegerBlob (pInt1 : access struct_CRYPTOAPI_BLOB;
pInt2 : access struct_CRYPTOAPI_BLOB) return windef.WINBOOL;
pragma Import (C, CertCompareIntegerBlob, "CertCompareIntegerBlob");
function CertCompareCertificate (dwCertEncodingType : windef.DWORD;
pCertId1 : access struct_CERT_INFO; pCertId2 : access struct_CERT_INFO)
return windef.WINBOOL;
pragma Import (C, CertCompareCertificate, "CertCompareCertificate");
function CertCompareCertificateName (dwCertEncodingType : windef.DWORD;
pCertName1 : access struct_CRYPTOAPI_BLOB;
pCertName2 : access struct_CRYPTOAPI_BLOB) return windef.WINBOOL;
pragma Import (C, CertCompareCertificateName,
"CertCompareCertificateName");
function CertIsRDNAttrsInCertificateName (
dwCertEncodingType : windef.DWORD; dwFlags : windef.DWORD;
pCertName : access struct_CRYPTOAPI_BLOB;
pRDN : access struct_CERT_RDN) return windef.WINBOOL;
pragma Import (C, CertIsRDNAttrsInCertificateName,
"CertIsRDNAttrsInCertificateName");
function CertComparePublicKeyInfo (dwCertEncodingType : windef.DWORD;
pPublicKey1 : access struct_CERT_PUBLIC_KEY_INFO;
pPublicKey2 : access struct_CERT_PUBLIC_KEY_INFO)
return windef.WINBOOL;
pragma Import (C, CertComparePublicKeyInfo, "CertComparePublicKeyInfo");
function CertGetPublicKeyLength (dwCertEncodingType : windef.DWORD;
pPublicKey : access struct_CERT_PUBLIC_KEY_INFO) return windef.DWORD;
pragma Import (C, CertGetPublicKeyLength, "CertGetPublicKeyLength");
function CryptVerifyCertificateSignature (
hCryptProv : wincrypt.HCRYPTPROV; dwCertEncodingType : windef.DWORD;
pbEncoded : access constant windef.BYTE; cbEncoded : windef.DWORD;
pPublicKey : access struct_CERT_PUBLIC_KEY_INFO) return windef.WINBOOL;
pragma Import (C, CryptVerifyCertificateSignature,
"CryptVerifyCertificateSignature");
function CryptVerifyCertificateSignatureEx (
hCryptProv : wincrypt.HCRYPTPROV; dwCertEncodingType : windef.DWORD;
dwSubjectType : windef.DWORD; pvSubject : void_ptr;
dwIssuerType : windef.DWORD; pvIssuer : void_ptr;
dwFlags : windef.DWORD; pvReserved : void_ptr) return windef.WINBOOL;
pragma Import (C, CryptVerifyCertificateSignatureEx,
"CryptVerifyCertificateSignatureEx");
function CryptHashToBeSigned (hCryptProv : wincrypt.HCRYPTPROV;
dwCertEncodingType : windef.DWORD;
pbEncoded : access constant windef.BYTE; cbEncoded : windef.DWORD;
pbComputedHash : access windef.BYTE;
pcbComputedHash : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, CryptHashToBeSigned, "CryptHashToBeSigned");
function CryptHashCertificate (hCryptProv : wincrypt.HCRYPTPROV;
Algid : ALG_ID; dwFlags : windef.DWORD;
pbEncoded : access constant windef.BYTE; cbEncoded : windef.DWORD;
pbComputedHash : access windef.BYTE;
pcbComputedHash : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, CryptHashCertificate, "CryptHashCertificate");
function CryptSignCertificate (hCryptProv : wincrypt.HCRYPTPROV;
dwKeySpec : windef.DWORD; dwCertEncodingType : windef.DWORD;
pbEncodedToBeSigned : access constant windef.BYTE;
cbEncodedToBeSigned : windef.DWORD;
pSignatureAlgorithm : access struct_CRYPT_ALGORITHM_IDENTIFIER;
pvHashAuxInfo : void_const_ptr; pbSignature : access windef.BYTE;
pcbSignature : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, CryptSignCertificate, "CryptSignCertificate");
function CryptSignAndEncodeCertificate (hCryptProv : wincrypt.HCRYPTPROV;
dwKeySpec : windef.DWORD; dwCertEncodingType : windef.DWORD;
lpszStructType : access constant winnt.C_CHAR;
pvStructInfo : void_const_ptr;
pSignatureAlgorithm : access struct_CRYPT_ALGORITHM_IDENTIFIER;
pvHashAuxInfo : void_const_ptr; pbEncoded : access windef.BYTE;
pcbEncoded : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, CryptSignAndEncodeCertificate,
"CryptSignAndEncodeCertificate");
function CertVerifyTimeValidity (
pTimeToVerify : access windef.struct_FILETIME;
pCertInfo : access struct_CERT_INFO) return winnt.LONG;
pragma Import (C, CertVerifyTimeValidity, "CertVerifyTimeValidity");
function CertVerifyCRLTimeValidity (
pTimeToVerify : access windef.struct_FILETIME;
pCrlInfo : access struct_CRL_INFO) return winnt.LONG;
pragma Import (C, CertVerifyCRLTimeValidity, "CertVerifyCRLTimeValidity");
function CertVerifyValidityNesting (
pSubjectInfo : access struct_CERT_INFO;
pIssuerInfo : access struct_CERT_INFO) return windef.WINBOOL;
pragma Import (C, CertVerifyValidityNesting, "CertVerifyValidityNesting");
function CertVerifyCRLRevocation (dwCertEncodingType : windef.DWORD;
pCertId : access struct_CERT_INFO; cCrlInfo : windef.DWORD;
rgpCrlInfo : access PCRL_INFO) return windef.WINBOOL;
pragma Import (C, CertVerifyCRLRevocation, "CertVerifyCRLRevocation");
function CertAlgIdToOID (dwAlgId : windef.DWORD) return winnt.LPCSTR;
pragma Import (C, CertAlgIdToOID, "CertAlgIdToOID");
function CertOIDToAlgId (pszObjId : access constant winnt.C_CHAR)
return windef.DWORD;
pragma Import (C, CertOIDToAlgId, "CertOIDToAlgId");
function CertFindExtension (pszObjId : access constant winnt.C_CHAR;
cExtensions : windef.DWORD; rgExtensions : access CERT_EXTENSION)
return PCERT_EXTENSION;
pragma Import (C, CertFindExtension, "CertFindExtension");
function CertFindAttribute (pszObjId : access constant winnt.C_CHAR;
cAttr : windef.DWORD; rgAttr : access CRYPT_ATTRIBUTE)
return PCRYPT_ATTRIBUTE;
pragma Import (C, CertFindAttribute, "CertFindAttribute");
function CertFindRDNAttr (pszObjId : access constant winnt.C_CHAR;
pName : access struct_CERT_NAME_INFO) return PCERT_RDN_ATTR;
pragma Import (C, CertFindRDNAttr, "CertFindRDNAttr");
function CertGetIntendedKeyUsage (dwCertEncodingType : windef.DWORD;
pCertInfo : access struct_CERT_INFO; pbKeyUsage : access windef.BYTE;
cbKeyUsage : windef.DWORD) return windef.WINBOOL;
pragma Import (C, CertGetIntendedKeyUsage, "CertGetIntendedKeyUsage");
subtype HCRYPTDEFAULTCONTEXT is void_ptr;
subtype HCRYPTDEFAULTCONTEXT_ptr is void_ptr_ptr;
function CryptInstallDefaultContext (hCryptProv : wincrypt.HCRYPTPROV;
dwDefaultType : windef.DWORD; pvDefaultPara : void_const_ptr;
dwFlags : windef.DWORD; pvReserved : void_ptr;
phDefaultContext : access HCRYPTDEFAULTCONTEXT) return windef.WINBOOL;
pragma Import (C, CryptInstallDefaultContext,
"CryptInstallDefaultContext");
type struct_CRYPT_DEFAULT_CONTEXT_MULTI_OID_PARA;
type struct_CRYPT_DEFAULT_CONTEXT_MULTI_OID_PARA is record
cOID : aliased windef.DWORD;
rgpszOID : aliased winnt.LPSTR_ptr;
end record;
pragma Convention (C_Pass_By_Copy,
struct_CRYPT_DEFAULT_CONTEXT_MULTI_OID_PARA);
type struct_CRYPT_DEFAULT_CONTEXT_MULTI_OID_PARA_ptr is
access all struct_CRYPT_DEFAULT_CONTEXT_MULTI_OID_PARA;
for struct_CRYPT_DEFAULT_CONTEXT_MULTI_OID_PARA_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (
struct_CRYPT_DEFAULT_CONTEXT_MULTI_OID_PARA_ptr);
pragma Convention (C, struct_CRYPT_DEFAULT_CONTEXT_MULTI_OID_PARA_ptr);
subtype CRYPT_DEFAULT_CONTEXT_MULTI_OID_PARA is
struct_CRYPT_DEFAULT_CONTEXT_MULTI_OID_PARA;
subtype PCRYPT_DEFAULT_CONTEXT_MULTI_OID_PARA is
struct_CRYPT_DEFAULT_CONTEXT_MULTI_OID_PARA_ptr;
function CryptUninstallDefaultContext (
hDefaultContext : HCRYPTDEFAULTCONTEXT; dwFlags : windef.DWORD;
pvReserved : void_ptr) return windef.WINBOOL;
pragma Import (C, CryptUninstallDefaultContext,
"CryptUninstallDefaultContext");
function CryptExportPublicKeyInfo (hCryptProv : wincrypt.HCRYPTPROV;
dwKeySpec : windef.DWORD; dwCertEncodingType : windef.DWORD;
pInfo : access struct_CERT_PUBLIC_KEY_INFO;
pcbInfo : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, CryptExportPublicKeyInfo, "CryptExportPublicKeyInfo");
function CryptExportPublicKeyInfoEx (hCryptProv : wincrypt.HCRYPTPROV;
dwKeySpec : windef.DWORD; dwCertEncodingType : windef.DWORD;
pszPublicKeyObjId : access winnt.C_CHAR; dwFlags : windef.DWORD;
pvAuxInfo : void_ptr; pInfo : access struct_CERT_PUBLIC_KEY_INFO;
pcbInfo : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, CryptExportPublicKeyInfoEx,
"CryptExportPublicKeyInfoEx");
function CryptImportPublicKeyInfo (hCryptProv : wincrypt.HCRYPTPROV;
dwCertEncodingType : windef.DWORD;
pInfo : access struct_CERT_PUBLIC_KEY_INFO; phKey : access HCRYPTKEY)
return windef.WINBOOL;
pragma Import (C, CryptImportPublicKeyInfo, "CryptImportPublicKeyInfo");
function CryptImportPublicKeyInfoEx (hCryptProv : wincrypt.HCRYPTPROV;
dwCertEncodingType : windef.DWORD;
pInfo : access struct_CERT_PUBLIC_KEY_INFO; aiKeyAlg : ALG_ID;
dwFlags : windef.DWORD; pvAuxInfo : void_ptr; phKey : access HCRYPTKEY)
return windef.WINBOOL;
pragma Import (C, CryptImportPublicKeyInfoEx,
"CryptImportPublicKeyInfoEx");
function CryptAcquireCertificatePrivateKey (
pCert : access constant CERT_CONTEXT; dwFlags : windef.DWORD;
pvReserved : void_ptr; phCryptProv : access HCRYPTPROV;
pdwKeySpec : access windef.DWORD;
pfCallerFreeProv : access windef.WINBOOL) return windef.WINBOOL;
pragma Import (C, CryptAcquireCertificatePrivateKey,
"CryptAcquireCertificatePrivateKey");
function CryptFindCertificateKeyProvInfo (
pCert : access constant CERT_CONTEXT; dwFlags : windef.DWORD;
pvReserved : void_ptr) return windef.WINBOOL;
pragma Import (C, CryptFindCertificateKeyProvInfo,
"CryptFindCertificateKeyProvInfo");
type access_2fb1cdef is access function (hCryptProv : wincrypt.HCRYPTPROV;
pPrivateKeyInfo : access CRYPT_PRIVATE_KEY_INFO;
dwFlags : windef.DWORD; pvAuxInfo : void_ptr) return windef.WINBOOL;
pragma Convention (C, access_2fb1cdef);
subtype PFN_IMPORT_PRIV_KEY_FUNC is access_2fb1cdef;
function CryptImportPKCS8 (sImportParams : CRYPT_PKCS8_IMPORT_PARAMS;
dwFlags : windef.DWORD; phCryptProv : access HCRYPTPROV;
pvAuxInfo : void_ptr) return windef.WINBOOL;
pragma Import (C, CryptImportPKCS8, "CryptImportPKCS8");
type access_a7bb589e is access function (hCryptProv : wincrypt.HCRYPTPROV;
dwKeySpec : windef.DWORD; pszPrivateKeyObjId : access winnt.C_CHAR;
dwFlags : windef.DWORD; pvAuxInfo : void_ptr;
pPrivateKeyInfo : access CRYPT_PRIVATE_KEY_INFO;
pcbPrivateKeyBlob : access windef.DWORD) return windef.WINBOOL;
pragma Convention (C, access_a7bb589e);
subtype PFN_EXPORT_PRIV_KEY_FUNC is access_a7bb589e;
function CryptExportPKCS8 (hCryptProv : wincrypt.HCRYPTPROV;
dwKeySpec : windef.DWORD; pszPrivateKeyObjId : access winnt.C_CHAR;
dwFlags : windef.DWORD; pvAuxInfo : void_ptr;
pbPrivateKeyBlob : access windef.BYTE;
pcbPrivateKeyBlob : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, CryptExportPKCS8, "CryptExportPKCS8");
function CryptExportPKCS8Ex (
psExportParams : access CRYPT_PKCS8_EXPORT_PARAMS;
dwFlags : windef.DWORD; pvAuxInfo : void_ptr;
pbPrivateKeyBlob : access windef.BYTE;
pcbPrivateKeyBlob : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, CryptExportPKCS8Ex, "CryptExportPKCS8Ex");
function CryptHashPublicKeyInfo (hCryptProv : wincrypt.HCRYPTPROV;
Algid : ALG_ID; dwFlags : windef.DWORD;
dwCertEncodingType : windef.DWORD;
pInfo : access struct_CERT_PUBLIC_KEY_INFO;
pbComputedHash : access windef.BYTE;
pcbComputedHash : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, CryptHashPublicKeyInfo, "CryptHashPublicKeyInfo");
function CertRDNValueToStrA (dwValueType : windef.DWORD;
pValue : access struct_CRYPTOAPI_BLOB; psz : access winnt.C_CHAR;
csz : windef.DWORD) return windef.DWORD;
pragma Import (C, CertRDNValueToStrA, "CertRDNValueToStrA");
function CertRDNValueToStrW (dwValueType : windef.DWORD;
pValue : access struct_CRYPTOAPI_BLOB; psz : access winnt.WCHAR;
csz : windef.DWORD) return windef.DWORD;
pragma Import (C, CertRDNValueToStrW, "CertRDNValueToStrW");
function CertNameToStrA (dwCertEncodingType : windef.DWORD;
pName : access struct_CRYPTOAPI_BLOB; dwStrType : windef.DWORD;
psz : access winnt.C_CHAR; csz : windef.DWORD) return windef.DWORD;
pragma Import (C, CertNameToStrA, "CertNameToStrA");
function CertNameToStrW (dwCertEncodingType : windef.DWORD;
pName : access struct_CRYPTOAPI_BLOB; dwStrType : windef.DWORD;
psz : access winnt.WCHAR; csz : windef.DWORD) return windef.DWORD;
pragma Import (C, CertNameToStrW, "CertNameToStrW");
function CertStrToNameA (dwCertEncodingType : windef.DWORD;
pszX500 : access constant winnt.C_CHAR; dwStrType : windef.DWORD;
pvReserved : void_ptr; pbEncoded : access windef.BYTE;
pcbEncoded : access windef.DWORD; ppszError : access winnt.LPCSTR)
return windef.WINBOOL;
pragma Import (C, CertStrToNameA, "CertStrToNameA");
function CertStrToNameW (dwCertEncodingType : windef.DWORD;
pszX500 : access constant winnt.WCHAR; dwStrType : windef.DWORD;
pvReserved : void_ptr; pbEncoded : access windef.BYTE;
pcbEncoded : access windef.DWORD; ppszError : access winnt.LPCWSTR)
return windef.WINBOOL;
pragma Import (C, CertStrToNameW, "CertStrToNameW");
function CertGetNameStringA (pCertContext : access constant CERT_CONTEXT;
dwType : windef.DWORD; dwFlags : windef.DWORD; pvTypePara : void_ptr;
pszNameString : access winnt.C_CHAR; cchNameString : windef.DWORD)
return windef.DWORD;
pragma Import (C, CertGetNameStringA, "CertGetNameStringA");
function CertGetNameStringW (pCertContext : access constant CERT_CONTEXT;
dwType : windef.DWORD; dwFlags : windef.DWORD; pvTypePara : void_ptr;
pszNameString : access winnt.WCHAR; cchNameString : windef.DWORD)
return windef.DWORD;
pragma Import (C, CertGetNameStringW, "CertGetNameStringW");
type access_5368da8b is access function (pvGetArg : void_ptr;
dwCertEncodingType : windef.DWORD; pSignerId : access struct_CERT_INFO;
hMsgCertStore : HCERTSTORE) return PCCERT_CONTEXT;
pragma Convention (C, access_5368da8b);
subtype PFN_CRYPT_GET_SIGNER_CERTIFICATE is access_5368da8b;
type struct_CRYPT_SIGN_MESSAGE_PARA;
type struct_CRYPT_SIGN_MESSAGE_PARA is record
cbSize : aliased windef.DWORD;
dwMsgEncodingType : aliased windef.DWORD;
pSigningCert : aliased PCCERT_CONTEXT;
HashAlgorithm : aliased CRYPT_ALGORITHM_IDENTIFIER;
pvHashAuxInfo : aliased void_ptr;
cMsgCert : aliased windef.DWORD;
rgpMsgCert : aliased PCCERT_CONTEXT_ptr;
cMsgCrl : aliased windef.DWORD;
rgpMsgCrl : aliased PCCRL_CONTEXT_ptr;
cAuthAttr : aliased windef.DWORD;
rgAuthAttr : aliased PCRYPT_ATTRIBUTE;
cUnauthAttr : aliased windef.DWORD;
rgUnauthAttr : aliased PCRYPT_ATTRIBUTE;
dwFlags : aliased windef.DWORD;
dwInnerContentType : aliased windef.DWORD;
end record;
pragma Convention (C_Pass_By_Copy, struct_CRYPT_SIGN_MESSAGE_PARA);
type struct_CRYPT_SIGN_MESSAGE_PARA_ptr is
access all struct_CRYPT_SIGN_MESSAGE_PARA;
for struct_CRYPT_SIGN_MESSAGE_PARA_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_SIGN_MESSAGE_PARA_ptr);
pragma Convention (C, struct_CRYPT_SIGN_MESSAGE_PARA_ptr);
subtype CRYPT_SIGN_MESSAGE_PARA is struct_CRYPT_SIGN_MESSAGE_PARA;
subtype PCRYPT_SIGN_MESSAGE_PARA is struct_CRYPT_SIGN_MESSAGE_PARA_ptr;
type struct_CRYPT_VERIFY_MESSAGE_PARA;
type struct_CRYPT_VERIFY_MESSAGE_PARA is record
cbSize : aliased windef.DWORD;
dwMsgAndCertEncodingType : aliased windef.DWORD;
hCryptProv : aliased wincrypt.HCRYPTPROV;
pfnGetSignerCertificate : aliased PFN_CRYPT_GET_SIGNER_CERTIFICATE;
pvGetArg : aliased void_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_CRYPT_VERIFY_MESSAGE_PARA);
type struct_CRYPT_VERIFY_MESSAGE_PARA_ptr is
access all struct_CRYPT_VERIFY_MESSAGE_PARA;
for struct_CRYPT_VERIFY_MESSAGE_PARA_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_VERIFY_MESSAGE_PARA_ptr);
pragma Convention (C, struct_CRYPT_VERIFY_MESSAGE_PARA_ptr);
subtype CRYPT_VERIFY_MESSAGE_PARA is struct_CRYPT_VERIFY_MESSAGE_PARA;
subtype PCRYPT_VERIFY_MESSAGE_PARA is
struct_CRYPT_VERIFY_MESSAGE_PARA_ptr;
type struct_CRYPT_ENCRYPT_MESSAGE_PARA;
type struct_CRYPT_ENCRYPT_MESSAGE_PARA is record
cbSize : aliased windef.DWORD;
dwMsgEncodingType : aliased windef.DWORD;
hCryptProv : aliased wincrypt.HCRYPTPROV;
ContentEncryptionAlgorithm : aliased CRYPT_ALGORITHM_IDENTIFIER;
pvEncryptionAuxInfo : aliased void_ptr;
dwFlags : aliased windef.DWORD;
dwInnerContentType : aliased windef.DWORD;
end record;
pragma Convention (C_Pass_By_Copy, struct_CRYPT_ENCRYPT_MESSAGE_PARA);
type struct_CRYPT_ENCRYPT_MESSAGE_PARA_ptr is
access all struct_CRYPT_ENCRYPT_MESSAGE_PARA;
for struct_CRYPT_ENCRYPT_MESSAGE_PARA_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_ENCRYPT_MESSAGE_PARA_ptr);
pragma Convention (C, struct_CRYPT_ENCRYPT_MESSAGE_PARA_ptr);
subtype CRYPT_ENCRYPT_MESSAGE_PARA is struct_CRYPT_ENCRYPT_MESSAGE_PARA;
subtype PCRYPT_ENCRYPT_MESSAGE_PARA is
struct_CRYPT_ENCRYPT_MESSAGE_PARA_ptr;
type struct_CRYPT_DECRYPT_MESSAGE_PARA;
type struct_CRYPT_DECRYPT_MESSAGE_PARA is record
cbSize : aliased windef.DWORD;
dwMsgAndCertEncodingType : aliased windef.DWORD;
cCertStore : aliased windef.DWORD;
rghCertStore : aliased HCERTSTORE_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_CRYPT_DECRYPT_MESSAGE_PARA);
type struct_CRYPT_DECRYPT_MESSAGE_PARA_ptr is
access all struct_CRYPT_DECRYPT_MESSAGE_PARA;
for struct_CRYPT_DECRYPT_MESSAGE_PARA_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_DECRYPT_MESSAGE_PARA_ptr);
pragma Convention (C, struct_CRYPT_DECRYPT_MESSAGE_PARA_ptr);
subtype CRYPT_DECRYPT_MESSAGE_PARA is struct_CRYPT_DECRYPT_MESSAGE_PARA;
subtype PCRYPT_DECRYPT_MESSAGE_PARA is
struct_CRYPT_DECRYPT_MESSAGE_PARA_ptr;
type struct_CRYPT_HASH_MESSAGE_PARA;
type struct_CRYPT_HASH_MESSAGE_PARA is record
cbSize : aliased windef.DWORD;
dwMsgEncodingType : aliased windef.DWORD;
hCryptProv : aliased wincrypt.HCRYPTPROV;
HashAlgorithm : aliased CRYPT_ALGORITHM_IDENTIFIER;
pvHashAuxInfo : aliased void_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_CRYPT_HASH_MESSAGE_PARA);
type struct_CRYPT_HASH_MESSAGE_PARA_ptr is
access all struct_CRYPT_HASH_MESSAGE_PARA;
for struct_CRYPT_HASH_MESSAGE_PARA_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_HASH_MESSAGE_PARA_ptr);
pragma Convention (C, struct_CRYPT_HASH_MESSAGE_PARA_ptr);
subtype CRYPT_HASH_MESSAGE_PARA is struct_CRYPT_HASH_MESSAGE_PARA;
subtype PCRYPT_HASH_MESSAGE_PARA is struct_CRYPT_HASH_MESSAGE_PARA_ptr;
type struct_CRYPT_KEY_SIGN_MESSAGE_PARA;
type struct_CRYPT_KEY_SIGN_MESSAGE_PARA is record
cbSize : aliased windef.DWORD;
dwMsgAndCertEncodingType : aliased windef.DWORD;
hCryptProv : aliased wincrypt.HCRYPTPROV;
dwKeySpec : aliased windef.DWORD;
HashAlgorithm : aliased CRYPT_ALGORITHM_IDENTIFIER;
pvHashAuxInfo : aliased void_ptr;
PubKeyAlgorithm : aliased CRYPT_ALGORITHM_IDENTIFIER;
end record;
pragma Convention (C_Pass_By_Copy, struct_CRYPT_KEY_SIGN_MESSAGE_PARA);
type struct_CRYPT_KEY_SIGN_MESSAGE_PARA_ptr is
access all struct_CRYPT_KEY_SIGN_MESSAGE_PARA;
for struct_CRYPT_KEY_SIGN_MESSAGE_PARA_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_KEY_SIGN_MESSAGE_PARA_ptr);
pragma Convention (C, struct_CRYPT_KEY_SIGN_MESSAGE_PARA_ptr);
subtype CRYPT_KEY_SIGN_MESSAGE_PARA is struct_CRYPT_KEY_SIGN_MESSAGE_PARA;
subtype PCRYPT_KEY_SIGN_MESSAGE_PARA is
struct_CRYPT_KEY_SIGN_MESSAGE_PARA_ptr;
type struct_CRYPT_KEY_VERIFY_MESSAGE_PARA;
type struct_CRYPT_KEY_VERIFY_MESSAGE_PARA is record
cbSize : aliased windef.DWORD;
dwMsgEncodingType : aliased windef.DWORD;
hCryptProv : aliased wincrypt.HCRYPTPROV;
end record;
pragma Convention (C_Pass_By_Copy, struct_CRYPT_KEY_VERIFY_MESSAGE_PARA);
type struct_CRYPT_KEY_VERIFY_MESSAGE_PARA_ptr is
access all struct_CRYPT_KEY_VERIFY_MESSAGE_PARA;
for struct_CRYPT_KEY_VERIFY_MESSAGE_PARA_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_CRYPT_KEY_VERIFY_MESSAGE_PARA_ptr);
pragma Convention (C, struct_CRYPT_KEY_VERIFY_MESSAGE_PARA_ptr);
subtype CRYPT_KEY_VERIFY_MESSAGE_PARA is
struct_CRYPT_KEY_VERIFY_MESSAGE_PARA;
subtype PCRYPT_KEY_VERIFY_MESSAGE_PARA is
struct_CRYPT_KEY_VERIFY_MESSAGE_PARA_ptr;
function CryptSignMessage (
pSignPara : access struct_CRYPT_SIGN_MESSAGE_PARA;
fDetachedSignature : windef.WINBOOL; cToBeSigned : windef.DWORD;
rgpbToBeSigned : access windef.BYTE_const_ptr;
rgcbToBeSigned : access windef.DWORD;
pbSignedBlob : access windef.BYTE; pcbSignedBlob : access windef.DWORD)
return windef.WINBOOL;
pragma Import (C, CryptSignMessage, "CryptSignMessage");
function CryptVerifyMessageSignature (
pVerifyPara : access struct_CRYPT_VERIFY_MESSAGE_PARA;
dwSignerIndex : windef.DWORD;
pbSignedBlob : access constant windef.BYTE;
cbSignedBlob : windef.DWORD; pbDecoded : access windef.BYTE;
pcbDecoded : access windef.DWORD; ppSignerCert : access PCCERT_CONTEXT)
return windef.WINBOOL;
pragma Import (C, CryptVerifyMessageSignature,
"CryptVerifyMessageSignature");
function CryptGetMessageSignerCount (dwMsgEncodingType : windef.DWORD;
pbSignedBlob : access constant windef.BYTE;
cbSignedBlob : windef.DWORD) return winnt.LONG;
pragma Import (C, CryptGetMessageSignerCount,
"CryptGetMessageSignerCount");
function CryptGetMessageCertificates (
dwMsgAndCertEncodingType : windef.DWORD;
hCryptProv : wincrypt.HCRYPTPROV; dwFlags : windef.DWORD;
pbSignedBlob : access constant windef.BYTE;
cbSignedBlob : windef.DWORD) return HCERTSTORE;
pragma Import (C, CryptGetMessageCertificates,
"CryptGetMessageCertificates");
function CryptVerifyDetachedMessageSignature (
pVerifyPara : access struct_CRYPT_VERIFY_MESSAGE_PARA;
dwSignerIndex : windef.DWORD;
pbDetachedSignBlob : access constant windef.BYTE;
cbDetachedSignBlob : windef.DWORD; cToBeSigned : windef.DWORD;
rgpbToBeSigned : access windef.BYTE_const_ptr;
rgcbToBeSigned : access windef.DWORD;
ppSignerCert : access PCCERT_CONTEXT) return windef.WINBOOL;
pragma Import (C, CryptVerifyDetachedMessageSignature,
"CryptVerifyDetachedMessageSignature");
function CryptEncryptMessage (
pEncryptPara : access struct_CRYPT_ENCRYPT_MESSAGE_PARA;
cRecipientCert : windef.DWORD;
rgpRecipientCert : access PCCERT_CONTEXT;
pbToBeEncrypted : access constant windef.BYTE;
cbToBeEncrypted : windef.DWORD; pbEncryptedBlob : access windef.BYTE;
pcbEncryptedBlob : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, CryptEncryptMessage, "CryptEncryptMessage");
function CryptDecryptMessage (
pDecryptPara : access struct_CRYPT_DECRYPT_MESSAGE_PARA;
pbEncryptedBlob : access constant windef.BYTE;
cbEncryptedBlob : windef.DWORD; pbDecrypted : access windef.BYTE;
pcbDecrypted : access windef.DWORD; ppXchgCert : access PCCERT_CONTEXT)
return windef.WINBOOL;
pragma Import (C, CryptDecryptMessage, "CryptDecryptMessage");
function CryptSignAndEncryptMessage (
pSignPara : access struct_CRYPT_SIGN_MESSAGE_PARA;
pEncryptPara : access struct_CRYPT_ENCRYPT_MESSAGE_PARA;
cRecipientCert : windef.DWORD;
rgpRecipientCert : access PCCERT_CONTEXT;
pbToBeSignedAndEncrypted : access constant windef.BYTE;
cbToBeSignedAndEncrypted : windef.DWORD;
pbSignedAndEncryptedBlob : access windef.BYTE;
pcbSignedAndEncryptedBlob : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, CryptSignAndEncryptMessage,
"CryptSignAndEncryptMessage");
function CryptDecryptAndVerifyMessageSignature (
pDecryptPara : access struct_CRYPT_DECRYPT_MESSAGE_PARA;
pVerifyPara : access struct_CRYPT_VERIFY_MESSAGE_PARA;
dwSignerIndex : windef.DWORD;
pbEncryptedBlob : access constant windef.BYTE;
cbEncryptedBlob : windef.DWORD; pbDecrypted : access windef.BYTE;
pcbDecrypted : access windef.DWORD; ppXchgCert : access PCCERT_CONTEXT;
ppSignerCert : access PCCERT_CONTEXT) return windef.WINBOOL;
pragma Import (C, CryptDecryptAndVerifyMessageSignature,
"CryptDecryptAndVerifyMessageSignature");
function CryptDecodeMessage (dwMsgTypeFlags : windef.DWORD;
pDecryptPara : access struct_CRYPT_DECRYPT_MESSAGE_PARA;
pVerifyPara : access struct_CRYPT_VERIFY_MESSAGE_PARA;
dwSignerIndex : windef.DWORD;
pbEncodedBlob : access constant windef.BYTE;
cbEncodedBlob : windef.DWORD; dwPrevInnerContentType : windef.DWORD;
pdwMsgType : access windef.DWORD;
pdwInnerContentType : access windef.DWORD;
pbDecoded : access windef.BYTE; pcbDecoded : access windef.DWORD;
ppXchgCert : access PCCERT_CONTEXT;
ppSignerCert : access PCCERT_CONTEXT) return windef.WINBOOL;
pragma Import (C, CryptDecodeMessage, "CryptDecodeMessage");
function CryptHashMessage (
pHashPara : access struct_CRYPT_HASH_MESSAGE_PARA;
fDetachedHash : windef.WINBOOL; cToBeHashed : windef.DWORD;
rgpbToBeHashed : access windef.BYTE_const_ptr;
rgcbToBeHashed : access windef.DWORD;
pbHashedBlob : access windef.BYTE; pcbHashedBlob : access windef.DWORD;
pbComputedHash : access windef.BYTE;
pcbComputedHash : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, CryptHashMessage, "CryptHashMessage");
function CryptVerifyMessageHash (
pHashPara : access struct_CRYPT_HASH_MESSAGE_PARA;
pbHashedBlob : access windef.BYTE; cbHashedBlob : windef.DWORD;
pbToBeHashed : access windef.BYTE; pcbToBeHashed : access windef.DWORD;
pbComputedHash : access windef.BYTE;
pcbComputedHash : access windef.DWORD) return windef.WINBOOL;
pragma Import (C, CryptVerifyMessageHash, "CryptVerifyMessageHash");
function CryptVerifyDetachedMessageHash (
pHashPara : access struct_CRYPT_HASH_MESSAGE_PARA;
pbDetachedHashBlob : access windef.BYTE;
cbDetachedHashBlob : windef.DWORD; cToBeHashed : windef.DWORD;
rgpbToBeHashed : access windef.BYTE_const_ptr;
rgcbToBeHashed : access windef.DWORD;
pbComputedHash : access windef.BYTE;
pcbComputedHash
Raw
c-windef.ads
View raw

(Sorry about that, but we can’t show files that are this big right now.)

Raw
c-windows.ads
View raw

(Sorry about that, but we can’t show files that are this big right now.)

Raw
c-winerror.ads
View raw

(Sorry about that, but we can’t show files that are this big right now.)

Raw
c-wingdi.adb
View raw

(Sorry about that, but we can’t show files that are this big right now.)

Raw
c-wingdi.ads
View raw

(Sorry about that, but we can’t show files that are this big right now.)

Raw
c-winnetwk.ads
View raw

(Sorry about that, but we can’t show files that are this big right now.)

Raw
c-winnls.ads
View raw

(Sorry about that, but we can’t show files that are this big right now.)

Raw
c-winnt.ads
View raw

(Sorry about that, but we can’t show files that are this big right now.)

Raw
c-winreg.ads
View raw

(Sorry about that, but we can’t show files that are this big right now.)

Raw
c-winsock2.ads
View raw

(Sorry about that, but we can’t show files that are this big right now.)

Raw
c-winsvc.ads
View raw

(Sorry about that, but we can’t show files that are this big right now.)

Raw
c-winternl.ads
View raw

(Sorry about that, but we can’t show files that are this big right now.)

Raw
c-winuser.ads
View raw

(Sorry about that, but we can’t show files that are this big right now.)

Raw
c-winver.ads
View raw

(Sorry about that, but we can’t show files that are this big right now.)

Raw
c-wnnc.ads
View raw

(Sorry about that, but we can’t show files that are this big right now.)

Raw
c-ws2def.ads
View raw

(Sorry about that, but we can’t show files that are this big right now.)

Raw
c-ws2ipdef.ads
View raw

(Sorry about that, but we can’t show files that are this big right now.)

Raw
c-ws2tcpip.ads
View raw

(Sorry about that, but we can’t show files that are this big right now.)

Raw
c.ads
View raw

(Sorry about that, but we can’t show files that are this big right now.)

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment