Skip to content

Instantly share code, notes, and snippets.

@ytomino

ytomino/c-bits-mman.ads

Created June 15, 2021 11:29
Show Gist options
  • Save ytomino/e40850441f57dcbb0f1c6212877f65f5 to your computer and use it in GitHub Desktop.
Save ytomino/e40850441f57dcbb0f1c6212877f65f5 to your computer and use it in GitHub Desktop.
Download ZIP
Boehm GC in x86_64-linux-gnu
Raw
c-bits-mman.ads
-- This file is translated by "headmaster" version 0.30-e83b81d (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.bits.mman is
pragma Preelaborate;
MAP_32BIT : constant := 64;
MAP_DENYWRITE : constant := 2048;
MAP_EXECUTABLE : constant := 4096;
MAP_GROWSDOWN : constant := 256;
MAP_HUGETLB : constant := 262144;
MAP_LOCKED : constant := 8192;
MAP_NONBLOCK : constant := 65536;
MAP_NORESERVE : constant := 16384;
MAP_POPULATE : constant := 32768;
MAP_STACK : constant := 131072;
end C.bits.mman;
Raw
c-bits-mman_linux.ads
-- This file is translated by "headmaster" version 0.30-e83b81d (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.bits.mman_linux is
pragma Preelaborate;
MADV_DODUMP : constant := 17;
MADV_DOFORK : constant := 11;
MADV_DONTDUMP : constant := 16;
MADV_DONTFORK : constant := 10;
MADV_DONTNEED : constant := 4;
MADV_FREE : constant := 8;
MADV_HUGEPAGE : constant := 14;
MADV_HWPOISON : constant := 100;
MADV_MERGEABLE : constant := 12;
MADV_NOHUGEPAGE : constant := 15;
MADV_NORMAL : constant := 0;
MADV_RANDOM : constant := 1;
MADV_REMOVE : constant := 9;
MADV_SEQUENTIAL : constant := 2;
MADV_UNMERGEABLE : constant := 13;
MADV_WILLNEED : constant := 3;
MAP_ANON : constant := 32;
MAP_ANONYMOUS : constant := 32;
MAP_FILE : constant := 0;
MAP_FIXED : constant := 16;
MAP_HUGE_MASK : constant := 63;
MAP_HUGE_SHIFT : constant := 26;
MAP_PRIVATE : constant := 2;
MAP_SHARED : constant := 1;
MAP_TYPE : constant := 15;
MCL_CURRENT : constant := 1;
MCL_FUTURE : constant := 2;
MCL_ONFAULT : constant := 4;
MS_ASYNC : constant := 1;
MS_INVALIDATE : constant := 2;
MS_SYNC : constant := 4;
POSIX_MADV_DONTNEED : constant := 4;
POSIX_MADV_NORMAL : constant := 0;
POSIX_MADV_RANDOM : constant := 1;
POSIX_MADV_SEQUENTIAL : constant := 2;
POSIX_MADV_WILLNEED : constant := 3;
PROT_EXEC : constant := 4;
PROT_GROWSDOWN : constant := 16777216;
PROT_GROWSUP : constant := 33554432;
PROT_NONE : constant := 0;
PROT_READ : constant := 1;
PROT_WRITE : constant := 2;
end C.bits.mman_linux;
Raw
c-bits-types.ads
-- This file is translated by "headmaster" version 0.30-e83b81d (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.bits.types is
pragma Preelaborate;
subtype u_char is unsigned_char;
subtype u_short is unsigned_short;
subtype u_int is unsigned_int;
subtype u_long is unsigned_long;
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;
subtype uint64_t is unsigned_long;
subtype quad_t is signed_long;
subtype quad_t_ptr is signed_long_ptr;
subtype u_quad_t is unsigned_long;
subtype dev_t is unsigned_long;
subtype uid_t is unsigned_int;
subtype gid_t is unsigned_int;
subtype ino_t is unsigned_long;
subtype ino64_t is unsigned_long;
subtype mode_t is unsigned_int;
subtype nlink_t is unsigned_long;
subtype off_t is signed_long;
subtype off64_t is signed_long;
subtype pid_t is signed_int;
type struct_f3d82047 is record
val : aliased signed_int_array (0 .. 1);
end record;
pragma Convention (C_Pass_By_Copy, struct_f3d82047);
subtype fsid_t is struct_f3d82047;
subtype qqclock_t is signed_long;
subtype rlim_t is unsigned_long;
subtype rlim64_t is unsigned_long;
subtype id_t is unsigned_int;
subtype qqtime_t is signed_long;
subtype useconds_t is unsigned_int;
subtype suseconds_t is signed_long;
subtype daddr_t is signed_int;
subtype key_t is signed_int;
subtype qqclockid_t is signed_int;
subtype qqtimer_t is void_ptr;
subtype blksize_t is signed_long;
subtype blkcnt_t is signed_long;
subtype blkcnt64_t is signed_long;
subtype fsblkcnt_t is unsigned_long;
subtype fsblkcnt64_t is unsigned_long;
subtype fsfilcnt_t is unsigned_long;
subtype fsfilcnt64_t is unsigned_long;
subtype fsword_t is signed_long;
subtype ssize_t is signed_long;
subtype syscall_slong_t is signed_long;
subtype syscall_ulong_t is unsigned_long;
subtype loff_t is off64_t;
subtype qaddr_t is quad_t_ptr;
subtype caddr_t is char_ptr;
subtype intptr_t is signed_long;
subtype socklen_t is unsigned_int;
BITS_TYPES_H : constant := 1;
subtype S16_TYPE is signed_short;
subtype S32_TYPE is signed_int;
subtype S64_TYPE is signed_long;
subtype SLONG32_TYPE is signed_int;
subtype SLONGWORD_TYPE is signed_long;
subtype SQUAD_TYPE is signed_long;
subtype SWORD_TYPE is signed_long;
subtype U16_TYPE is unsigned_short;
subtype U32_TYPE is unsigned_int;
subtype U64_TYPE is unsigned_long;
subtype ULONG32_TYPE is unsigned_int;
subtype ULONGWORD_TYPE is unsigned_long;
subtype UQUAD_TYPE is unsigned_long;
subtype UWORD_TYPE is unsigned_long;
end C.bits.types;
Raw
c-bits-typesizes.ads
-- This file is translated by "headmaster" version 0.30-e83b81d (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.bits.typesizes is
pragma Preelaborate;
BITS_TYPESIZES_H : constant := 1;
subtype BLKCNT64_T_TYPE is signed_long;
subtype BLKCNT_T_TYPE is signed_long;
subtype BLKSIZE_T_TYPE is signed_long;
subtype CLOCKID_T_TYPE is signed_int;
subtype CLOCK_T_TYPE is signed_long;
subtype CPU_MASK_TYPE is unsigned_long;
subtype DADDR_T_TYPE is signed_int;
subtype DEV_T_TYPE is unsigned_long;
FD_SETSIZE : constant := 1024;
subtype FSBLKCNT64_T_TYPE is unsigned_long;
subtype FSBLKCNT_T_TYPE is unsigned_long;
subtype FSFILCNT64_T_TYPE is unsigned_long;
subtype FSFILCNT_T_TYPE is unsigned_long;
type struct_ad766d7a is record
val : aliased signed_int_array (0 .. 1);
end record;
pragma Convention (C_Pass_By_Copy, struct_ad766d7a);
subtype FSID_T_TYPE is struct_ad766d7a;
subtype FSWORD_T_TYPE is signed_long;
subtype GID_T_TYPE is unsigned_int;
subtype ID_T_TYPE is unsigned_int;
subtype INO64_T_TYPE is unsigned_long;
INO_T_MATCHES_INO64_T : constant := 1;
subtype INO_T_TYPE is unsigned_long;
subtype KEY_T_TYPE is signed_int;
subtype MODE_T_TYPE is unsigned_int;
subtype NLINK_T_TYPE is unsigned_long;
subtype OFF64_T_TYPE is signed_long;
OFF_T_MATCHES_OFF64_T : constant := 1;
subtype OFF_T_TYPE is signed_long;
subtype PID_T_TYPE is signed_int;
subtype RLIM64_T_TYPE is unsigned_long;
subtype RLIM_T_TYPE is unsigned_long;
subtype SSIZE_T_TYPE is signed_long;
subtype SUSECONDS_T_TYPE is signed_long;
subtype SYSCALL_SLONG_TYPE is signed_long;
subtype SYSCALL_ULONG_TYPE is unsigned_long;
-- __TIMER_T_TYPE (unparsible)
subtype TIME_T_TYPE is signed_long;
subtype UID_T_TYPE is unsigned_int;
subtype USECONDS_T_TYPE is unsigned_int;
end C.bits.typesizes;
Raw
c-bits-wordsize.ads
-- This file is translated by "headmaster" version 0.30-e83b81d (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.bits.wordsize is
pragma Preelaborate;
SYSCALL_WORDSIZE : constant := 64;
WORDSIZE : constant := 64;
WORDSIZE_TIME64_COMPAT32 : constant := 1;
end C.bits.wordsize;
Raw
c-bits.ads
-- This file is translated by "headmaster" version 0.30-e83b81d (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.bits is
pragma Preelaborate;
end C.bits;
Raw
c-features.ads
-- This file is translated by "headmaster" version 0.30-e83b81d (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.features is
pragma Preelaborate;
ATFILE_SOURCE : constant := 1;
DEFAULT_SOURCE : constant := 1;
FEATURES_H : constant := 1;
POSIX_C_SOURCE : constant := 200809;
POSIX_SOURCE : constant := 1;
qqGLIBC_MINORqq : constant := 24;
-- __GLIBC_PREREQ (function macro)
qqGLIBCqq : constant := 2;
-- __GNUC_PREREQ (function macro)
qqGNU_LIBRARYqq : constant := 6;
-- __KERNEL_STRICT_NAMES (empty)
USE_ATFILE : constant := 1;
USE_FORTIFY_LEVEL : constant := 0;
USE_ISOC95 : constant := 1;
USE_ISOC99 : constant := 1;
USE_MISC : constant := 1;
USE_POSIX : constant := 1;
USE_POSIX199309 : constant := 1;
USE_POSIX199506 : constant := 1;
USE_POSIX2 : constant := 1;
USE_POSIX_IMPLICITLY : constant := 1;
USE_XOPEN2K : constant := 1;
USE_XOPEN2K8 : constant := 1;
end C.features;
Raw
c-gc-gc.ads
-- This file is translated by "headmaster" version 0.30-e83b81d (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.stddef;
package C.gc.gc is
pragma Preelaborate;
subtype GC_PTR is void_ptr;
subtype GC_word is unsigned_long;
subtype GC_word_ptr is unsigned_long_ptr;
subtype GC_word_const_ptr is unsigned_long_const_ptr;
subtype GC_signed_word is signed_long;
function GC_get_version return unsigned_int;
pragma Import (C, GC_get_version, "GC_get_version");
GC_gc_no : aliased GC_word;
pragma Import (C, GC_gc_no, "GC_gc_no");
function GC_get_gc_no return GC_word;
pragma Import (C, GC_get_gc_no, "GC_get_gc_no");
type access_f10bbb0c is access function (a1 : stddef.size_t)
return void_ptr;
pragma Convention (C, access_f10bbb0c);
subtype GC_oom_func is access_f10bbb0c;
GC_oom_fn : aliased GC_oom_func;
pragma Import (C, GC_oom_fn, "GC_oom_fn");
procedure GC_set_oom_fn (a1 : GC_oom_func);
pragma Import (C, GC_set_oom_fn, "GC_set_oom_fn");
function GC_get_oom_fn return GC_oom_func;
pragma Import (C, GC_get_oom_fn, "GC_get_oom_fn");
type access_151fd588 is access procedure (a1 : GC_word);
pragma Convention (C, access_151fd588);
subtype GC_on_heap_resize_proc is access_151fd588;
GC_on_heap_resize : aliased GC_on_heap_resize_proc;
pragma Import (C, GC_on_heap_resize, "GC_on_heap_resize");
procedure GC_set_on_heap_resize (a1 : GC_on_heap_resize_proc);
pragma Import (C, GC_set_on_heap_resize, "GC_set_on_heap_resize");
function GC_get_on_heap_resize return GC_on_heap_resize_proc;
pragma Import (C, GC_get_on_heap_resize, "GC_get_on_heap_resize");
type enum_c081d20b is (GC_EVENT_START, GC_EVENT_MARK_START,
GC_EVENT_MARK_END, GC_EVENT_RECLAIM_START, GC_EVENT_RECLAIM_END,
GC_EVENT_END, GC_EVENT_PRE_STOP_WORLD, GC_EVENT_POST_STOP_WORLD,
GC_EVENT_PRE_START_WORLD, GC_EVENT_POST_START_WORLD,
GC_EVENT_THREAD_SUSPENDED, GC_EVENT_THREAD_UNSUSPENDED);
for enum_c081d20b use (GC_EVENT_START => 0, GC_EVENT_MARK_START => 1,
GC_EVENT_MARK_END => 2, GC_EVENT_RECLAIM_START => 3,
GC_EVENT_RECLAIM_END => 4, GC_EVENT_END => 5,
GC_EVENT_PRE_STOP_WORLD => 6, GC_EVENT_POST_STOP_WORLD => 7,
GC_EVENT_PRE_START_WORLD => 8, GC_EVENT_POST_START_WORLD => 9,
GC_EVENT_THREAD_SUSPENDED => 10, GC_EVENT_THREAD_UNSUSPENDED => 11);
pragma Convention (C, enum_c081d20b);
subtype GC_EventType is enum_c081d20b;
type access_0cea1c6d is access procedure (a1 : GC_EventType);
pragma Convention (C, access_0cea1c6d);
subtype GC_on_collection_event_proc is access_0cea1c6d;
procedure GC_set_on_collection_event (a1 : GC_on_collection_event_proc);
pragma Import (C, GC_set_on_collection_event,
"GC_set_on_collection_event");
function GC_get_on_collection_event return GC_on_collection_event_proc;
pragma Import (C, GC_get_on_collection_event,
"GC_get_on_collection_event");
GC_find_leak : aliased signed_int;
pragma Import (C, GC_find_leak, "GC_find_leak");
procedure GC_set_find_leak (a1 : signed_int);
pragma Import (C, GC_set_find_leak, "GC_set_find_leak");
type access_e83afa7d is access function return signed_int;
pragma Convention (C, access_e83afa7d);
function GC_get_find_leak return signed_int;
pragma Import (C, GC_get_find_leak, "GC_get_find_leak");
GC_all_interior_pointers : aliased signed_int;
pragma Import (C, GC_all_interior_pointers, "GC_all_interior_pointers");
procedure GC_set_all_interior_pointers (a1 : signed_int);
pragma Import (C, GC_set_all_interior_pointers,
"GC_set_all_interior_pointers");
function GC_get_all_interior_pointers return signed_int;
pragma Import (C, GC_get_all_interior_pointers,
"GC_get_all_interior_pointers");
GC_finalize_on_demand : aliased signed_int;
pragma Import (C, GC_finalize_on_demand, "GC_finalize_on_demand");
procedure GC_set_finalize_on_demand (a1 : signed_int);
pragma Import (C, GC_set_finalize_on_demand, "GC_set_finalize_on_demand");
function GC_get_finalize_on_demand return signed_int;
pragma Import (C, GC_get_finalize_on_demand, "GC_get_finalize_on_demand");
GC_java_finalization : aliased signed_int;
pragma Import (C, GC_java_finalization, "GC_java_finalization");
procedure GC_set_java_finalization (a1 : signed_int);
pragma Import (C, GC_set_java_finalization, "GC_set_java_finalization");
function GC_get_java_finalization return signed_int;
pragma Import (C, GC_get_java_finalization, "GC_get_java_finalization");
type access_e823f645 is access procedure;
pragma Convention (C, access_e823f645);
subtype GC_finalizer_notifier_proc is access_e823f645;
GC_finalizer_notifier : aliased GC_finalizer_notifier_proc;
pragma Import (C, GC_finalizer_notifier, "GC_finalizer_notifier");
procedure GC_set_finalizer_notifier (a1 : GC_finalizer_notifier_proc);
pragma Import (C, GC_set_finalizer_notifier, "GC_set_finalizer_notifier");
function GC_get_finalizer_notifier return GC_finalizer_notifier_proc;
pragma Import (C, GC_get_finalizer_notifier, "GC_get_finalizer_notifier");
GC_dont_gc : aliased signed_int;
pragma Import (C, GC_dont_gc, "GC_dont_gc");
GC_dont_expand : aliased signed_int;
pragma Import (C, GC_dont_expand, "GC_dont_expand");
procedure GC_set_dont_expand (a1 : signed_int);
pragma Import (C, GC_set_dont_expand, "GC_set_dont_expand");
function GC_get_dont_expand return signed_int;
pragma Import (C, GC_get_dont_expand, "GC_get_dont_expand");
GC_use_entire_heap : aliased signed_int;
pragma Import (C, GC_use_entire_heap, "GC_use_entire_heap");
GC_full_freq : aliased signed_int;
pragma Import (C, GC_full_freq, "GC_full_freq");
procedure GC_set_full_freq (a1 : signed_int);
pragma Import (C, GC_set_full_freq, "GC_set_full_freq");
function GC_get_full_freq return signed_int;
pragma Import (C, GC_get_full_freq, "GC_get_full_freq");
GC_non_gc_bytes : aliased GC_word;
pragma Import (C, GC_non_gc_bytes, "GC_non_gc_bytes");
procedure GC_set_non_gc_bytes (a1 : GC_word);
pragma Import (C, GC_set_non_gc_bytes, "GC_set_non_gc_bytes");
function GC_get_non_gc_bytes return GC_word;
pragma Import (C, GC_get_non_gc_bytes, "GC_get_non_gc_bytes");
GC_no_dls : aliased signed_int;
pragma Import (C, GC_no_dls, "GC_no_dls");
procedure GC_set_no_dls (a1 : signed_int);
pragma Import (C, GC_set_no_dls, "GC_set_no_dls");
function GC_get_no_dls return signed_int;
pragma Import (C, GC_get_no_dls, "GC_get_no_dls");
GC_free_space_divisor : aliased GC_word;
pragma Import (C, GC_free_space_divisor, "GC_free_space_divisor");
procedure GC_set_free_space_divisor (a1 : GC_word);
pragma Import (C, GC_set_free_space_divisor, "GC_set_free_space_divisor");
function GC_get_free_space_divisor return GC_word;
pragma Import (C, GC_get_free_space_divisor, "GC_get_free_space_divisor");
GC_max_retries : aliased GC_word;
pragma Import (C, GC_max_retries, "GC_max_retries");
procedure GC_set_max_retries (a1 : GC_word);
pragma Import (C, GC_set_max_retries, "GC_set_max_retries");
function GC_get_max_retries return GC_word;
pragma Import (C, GC_get_max_retries, "GC_get_max_retries");
GC_stackbottom : aliased char_ptr;
pragma Import (C, GC_stackbottom, "GC_stackbottom");
GC_dont_precollect : aliased signed_int;
pragma Import (C, GC_dont_precollect, "GC_dont_precollect");
procedure GC_set_dont_precollect (a1 : signed_int);
pragma Import (C, GC_set_dont_precollect, "GC_set_dont_precollect");
function GC_get_dont_precollect return signed_int;
pragma Import (C, GC_get_dont_precollect, "GC_get_dont_precollect");
GC_time_limit : aliased unsigned_long;
pragma Import (C, GC_time_limit, "GC_time_limit");
procedure GC_set_time_limit (a1 : unsigned_long);
pragma Import (C, GC_set_time_limit, "GC_set_time_limit");
function GC_get_time_limit return unsigned_long;
pragma Import (C, GC_get_time_limit, "GC_get_time_limit");
procedure GC_set_pages_executable (a1 : signed_int);
pragma Import (C, GC_set_pages_executable, "GC_set_pages_executable");
function GC_get_pages_executable return signed_int;
pragma Import (C, GC_get_pages_executable, "GC_get_pages_executable");
procedure GC_set_handle_fork (a1 : signed_int);
pragma Import (C, GC_set_handle_fork, "GC_set_handle_fork");
procedure GC_atfork_prepare;
pragma Import (C, GC_atfork_prepare, "GC_atfork_prepare");
procedure GC_atfork_parent;
pragma Import (C, GC_atfork_parent, "GC_atfork_parent");
procedure GC_atfork_child;
pragma Import (C, GC_atfork_child, "GC_atfork_child");
procedure GC_init;
pragma Import (C, GC_init, "GC_init");
function GC_is_init_called return signed_int;
pragma Import (C, GC_is_init_called, "GC_is_init_called");
function GC_malloc (a1 : stddef.size_t) return void_ptr;
pragma Import (C, GC_malloc, "GC_malloc");
function GC_malloc_atomic (a1 : stddef.size_t) return void_ptr;
pragma Import (C, GC_malloc_atomic, "GC_malloc_atomic");
function GC_strdup (a1 : access constant char) return char_ptr;
pragma Import (C, GC_strdup, "GC_strdup");
function GC_strndup (a1 : access constant char; a2 : stddef.size_t)
return char_ptr;
pragma Import (C, GC_strndup, "GC_strndup");
function GC_malloc_uncollectable (a1 : stddef.size_t) return void_ptr;
pragma Import (C, GC_malloc_uncollectable, "GC_malloc_uncollectable");
function GC_malloc_stubborn (a1 : stddef.size_t) return void_ptr;
pragma Import (C, GC_malloc_stubborn, "GC_malloc_stubborn");
function GC_memalign (a1 : stddef.size_t; a2 : stddef.size_t)
return void_ptr;
pragma Import (C, GC_memalign, "GC_memalign");
function GC_posix_memalign (a1 : access void_ptr; a2 : stddef.size_t;
a3 : stddef.size_t) return signed_int;
pragma Import (C, GC_posix_memalign, "GC_posix_memalign");
type access_15c277d4 is access procedure (a1 : void_ptr);
pragma Convention (C, access_15c277d4);
procedure GC_free (a1 : void_ptr);
pragma Import (C, GC_free, "GC_free");
procedure GC_change_stubborn (a1 : void_const_ptr);
pragma Import (C, GC_change_stubborn, "GC_change_stubborn");
procedure GC_end_stubborn_change (a1 : void_const_ptr);
pragma Import (C, GC_end_stubborn_change, "GC_end_stubborn_change");
type access_336fa8d4 is access function (a1 : void_ptr) return void_ptr;
pragma Convention (C, access_336fa8d4);
function GC_base (a1 : void_ptr) return void_ptr;
pragma Import (C, GC_base, "GC_base");
function GC_is_heap_ptr (a1 : void_const_ptr) return signed_int;
pragma Import (C, GC_is_heap_ptr, "GC_is_heap_ptr");
function GC_size (a1 : void_const_ptr) return stddef.size_t;
pragma Import (C, GC_size, "GC_size");
function GC_realloc (a1 : void_ptr; a2 : stddef.size_t) return void_ptr;
pragma Import (C, GC_realloc, "GC_realloc");
function GC_expand_hp (a1 : stddef.size_t) return signed_int;
pragma Import (C, GC_expand_hp, "GC_expand_hp");
procedure GC_set_max_heap_size (a1 : GC_word);
pragma Import (C, GC_set_max_heap_size, "GC_set_max_heap_size");
type access_4b44b147 is access procedure (a1 : void_ptr; a2 : void_ptr);
pragma Convention (C, access_4b44b147);
type access_4b44b147_ptr is access all access_4b44b147;
for access_4b44b147_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (access_4b44b147_ptr);
pragma Convention (C, access_4b44b147_ptr);
procedure GC_exclude_static_roots (a1 : void_ptr; a2 : void_ptr);
pragma Import (C, GC_exclude_static_roots, "GC_exclude_static_roots");
procedure GC_clear_roots;
pragma Import (C, GC_clear_roots, "GC_clear_roots");
procedure GC_add_roots (a1 : void_ptr; a2 : void_ptr);
pragma Import (C, GC_add_roots, "GC_add_roots");
procedure GC_remove_roots (a1 : void_ptr; a2 : void_ptr);
pragma Import (C, GC_remove_roots, "GC_remove_roots");
procedure GC_register_displacement (a1 : stddef.size_t);
pragma Import (C, GC_register_displacement, "GC_register_displacement");
procedure GC_debug_register_displacement (a1 : stddef.size_t);
pragma Import (C, GC_debug_register_displacement,
"GC_debug_register_displacement");
procedure GC_gcollect;
pragma Import (C, GC_gcollect, "GC_gcollect");
procedure GC_gcollect_and_unmap;
pragma Import (C, GC_gcollect_and_unmap, "GC_gcollect_and_unmap");
subtype GC_stop_func is access_e83afa7d;
function GC_try_to_collect (a1 : GC_stop_func) return signed_int;
pragma Import (C, GC_try_to_collect, "GC_try_to_collect");
procedure GC_set_stop_func (a1 : GC_stop_func);
pragma Import (C, GC_set_stop_func, "GC_set_stop_func");
function GC_get_stop_func return GC_stop_func;
pragma Import (C, GC_get_stop_func, "GC_get_stop_func");
function GC_get_heap_size return stddef.size_t;
pragma Import (C, GC_get_heap_size, "GC_get_heap_size");
function GC_get_free_bytes return stddef.size_t;
pragma Import (C, GC_get_free_bytes, "GC_get_free_bytes");
function GC_get_unmapped_bytes return stddef.size_t;
pragma Import (C, GC_get_unmapped_bytes, "GC_get_unmapped_bytes");
function GC_get_bytes_since_gc return stddef.size_t;
pragma Import (C, GC_get_bytes_since_gc, "GC_get_bytes_since_gc");
function GC_get_total_bytes return stddef.size_t;
pragma Import (C, GC_get_total_bytes, "GC_get_total_bytes");
procedure GC_get_heap_usage_safe (a1 : access GC_word;
a2 : access GC_word; a3 : access GC_word; a4 : access GC_word;
a5 : access GC_word);
pragma Import (C, GC_get_heap_usage_safe, "GC_get_heap_usage_safe");
type struct_GC_prof_stats_s;
type struct_GC_prof_stats_s is record
heapsize_full : aliased GC_word;
free_bytes_full : aliased GC_word;
unmapped_bytes : aliased GC_word;
bytes_allocd_since_gc : aliased GC_word;
allocd_bytes_before_gc : aliased GC_word;
non_gc_bytes : aliased GC_word;
gc_no : aliased GC_word;
markers_m1 : aliased GC_word;
bytes_reclaimed_since_gc : aliased GC_word;
reclaimed_bytes_before_gc : aliased GC_word;
end record;
pragma Convention (C_Pass_By_Copy, struct_GC_prof_stats_s);
type struct_GC_prof_stats_s_ptr is access all struct_GC_prof_stats_s;
for struct_GC_prof_stats_s_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_GC_prof_stats_s_ptr);
pragma Convention (C, struct_GC_prof_stats_s_ptr);
function GC_get_prof_stats (a1 : access struct_GC_prof_stats_s;
a2 : stddef.size_t) return stddef.size_t;
pragma Import (C, GC_get_prof_stats, "GC_get_prof_stats");
function GC_get_memory_use return stddef.size_t;
pragma Import (C, GC_get_memory_use, "GC_get_memory_use");
procedure GC_disable;
pragma Import (C, GC_disable, "GC_disable");
function GC_is_disabled return signed_int;
pragma Import (C, GC_is_disabled, "GC_is_disabled");
procedure GC_enable;
pragma Import (C, GC_enable, "GC_enable");
procedure GC_enable_incremental;
pragma Import (C, GC_enable_incremental, "GC_enable_incremental");
function GC_incremental_protection_needs return signed_int;
pragma Import (C, GC_incremental_protection_needs,
"GC_incremental_protection_needs");
function GC_collect_a_little return signed_int;
pragma Import (C, GC_collect_a_little, "GC_collect_a_little");
function GC_malloc_ignore_off_page (a1 : stddef.size_t) return void_ptr;
pragma Import (C, GC_malloc_ignore_off_page, "GC_malloc_ignore_off_page");
function GC_malloc_atomic_ignore_off_page (a1 : stddef.size_t)
return void_ptr;
pragma Import (C, GC_malloc_atomic_ignore_off_page,
"GC_malloc_atomic_ignore_off_page");
function GC_malloc_atomic_uncollectable (a1 : stddef.size_t)
return void_ptr;
pragma Import (C, GC_malloc_atomic_uncollectable,
"GC_malloc_atomic_uncollectable");
function GC_debug_malloc_atomic_uncollectable (a1 : stddef.size_t;
s : access constant char; i : signed_int) return void_ptr;
pragma Import (C, GC_debug_malloc_atomic_uncollectable,
"GC_debug_malloc_atomic_uncollectable");
function GC_debug_malloc (a1 : stddef.size_t; s : access constant char;
i : signed_int) return void_ptr;
pragma Import (C, GC_debug_malloc, "GC_debug_malloc");
function GC_debug_malloc_atomic (a1 : stddef.size_t;
s : access constant char; i : signed_int) return void_ptr;
pragma Import (C, GC_debug_malloc_atomic, "GC_debug_malloc_atomic");
function GC_debug_strdup (a1 : access constant char;
s : access constant char; i : signed_int) return char_ptr;
pragma Import (C, GC_debug_strdup, "GC_debug_strdup");
function GC_debug_strndup (a1 : access constant char; a2 : stddef.size_t;
s : access constant char; i : signed_int) return char_ptr;
pragma Import (C, GC_debug_strndup, "GC_debug_strndup");
function GC_debug_malloc_uncollectable (a1 : stddef.size_t;
s : access constant char; i : signed_int) return void_ptr;
pragma Import (C, GC_debug_malloc_uncollectable,
"GC_debug_malloc_uncollectable");
function GC_debug_malloc_stubborn (a1 : stddef.size_t;
s : access constant char; i : signed_int) return void_ptr;
pragma Import (C, GC_debug_malloc_stubborn, "GC_debug_malloc_stubborn");
function GC_debug_malloc_ignore_off_page (a1 : stddef.size_t;
s : access constant char; i : signed_int) return void_ptr;
pragma Import (C, GC_debug_malloc_ignore_off_page,
"GC_debug_malloc_ignore_off_page");
function GC_debug_malloc_atomic_ignore_off_page (a1 : stddef.size_t;
s : access constant char; i : signed_int) return void_ptr;
pragma Import (C, GC_debug_malloc_atomic_ignore_off_page,
"GC_debug_malloc_atomic_ignore_off_page");
procedure GC_debug_free (a1 : void_ptr);
pragma Import (C, GC_debug_free, "GC_debug_free");
function GC_debug_realloc (a1 : void_ptr; a2 : stddef.size_t;
s : access constant char; i : signed_int) return void_ptr;
pragma Import (C, GC_debug_realloc, "GC_debug_realloc");
procedure GC_debug_change_stubborn (a1 : void_const_ptr);
pragma Import (C, GC_debug_change_stubborn, "GC_debug_change_stubborn");
procedure GC_debug_end_stubborn_change (a1 : void_const_ptr);
pragma Import (C, GC_debug_end_stubborn_change,
"GC_debug_end_stubborn_change");
function GC_debug_malloc_replacement (a1 : stddef.size_t) return void_ptr;
pragma Import (C, GC_debug_malloc_replacement,
"GC_debug_malloc_replacement");
function GC_debug_realloc_replacement (a1 : void_ptr; a2 : stddef.size_t)
return void_ptr;
pragma Import (C, GC_debug_realloc_replacement,
"GC_debug_realloc_replacement");
subtype GC_finalization_proc is access_4b44b147;
subtype GC_finalization_proc_ptr is access_4b44b147_ptr;
procedure GC_register_finalizer (a1 : void_ptr; a2 : GC_finalization_proc;
a3 : void_ptr; a4 : access GC_finalization_proc; a5 : access void_ptr);
pragma Import (C, GC_register_finalizer, "GC_register_finalizer");
procedure GC_debug_register_finalizer (a1 : void_ptr;
a2 : GC_finalization_proc; a3 : void_ptr;
a4 : access GC_finalization_proc; a5 : access void_ptr);
pragma Import (C, GC_debug_register_finalizer,
"GC_debug_register_finalizer");
procedure GC_register_finalizer_ignore_self (a1 : void_ptr;
a2 : GC_finalization_proc; a3 : void_ptr;
a4 : access GC_finalization_proc; a5 : access void_ptr);
pragma Import (C, GC_register_finalizer_ignore_self,
"GC_register_finalizer_ignore_self");
procedure GC_debug_register_finalizer_ignore_self (a1 : void_ptr;
a2 : GC_finalization_proc; a3 : void_ptr;
a4 : access GC_finalization_proc; a5 : access void_ptr);
pragma Import (C, GC_debug_register_finalizer_ignore_self,
"GC_debug_register_finalizer_ignore_self");
procedure GC_register_finalizer_no_order (a1 : void_ptr;
a2 : GC_finalization_proc; a3 : void_ptr;
a4 : access GC_finalization_proc; a5 : access void_ptr);
pragma Import (C, GC_register_finalizer_no_order,
"GC_register_finalizer_no_order");
procedure GC_debug_register_finalizer_no_order (a1 : void_ptr;
a2 : GC_finalization_proc; a3 : void_ptr;
a4 : access GC_finalization_proc; a5 : access void_ptr);
pragma Import (C, GC_debug_register_finalizer_no_order,
"GC_debug_register_finalizer_no_order");
procedure GC_register_finalizer_unreachable (a1 : void_ptr;
a2 : GC_finalization_proc; a3 : void_ptr;
a4 : access GC_finalization_proc; a5 : access void_ptr);
pragma Import (C, GC_register_finalizer_unreachable,
"GC_register_finalizer_unreachable");
procedure GC_debug_register_finalizer_unreachable (a1 : void_ptr;
a2 : GC_finalization_proc; a3 : void_ptr;
a4 : access GC_finalization_proc; a5 : access void_ptr);
pragma Import (C, GC_debug_register_finalizer_unreachable,
"GC_debug_register_finalizer_unreachable");
function GC_register_disappearing_link (a1 : access void_ptr)
return signed_int;
pragma Import (C, GC_register_disappearing_link,
"GC_register_disappearing_link");
function GC_general_register_disappearing_link (a1 : access void_ptr;
a2 : void_const_ptr) return signed_int;
pragma Import (C, GC_general_register_disappearing_link,
"GC_general_register_disappearing_link");
function GC_move_disappearing_link (a1 : access void_ptr;
a2 : access void_ptr) return signed_int;
pragma Import (C, GC_move_disappearing_link, "GC_move_disappearing_link");
function GC_unregister_disappearing_link (a1 : access void_ptr)
return signed_int;
pragma Import (C, GC_unregister_disappearing_link,
"GC_unregister_disappearing_link");
function GC_register_long_link (a1 : access void_ptr; a2 : void_const_ptr)
return signed_int;
pragma Import (C, GC_register_long_link, "GC_register_long_link");
function GC_move_long_link (a1 : access void_ptr; a2 : access void_ptr)
return signed_int;
pragma Import (C, GC_move_long_link, "GC_move_long_link");
function GC_unregister_long_link (a1 : access void_ptr) return signed_int;
pragma Import (C, GC_unregister_long_link, "GC_unregister_long_link");
type enum_a39ac617 is (GC_TOGGLE_REF_DROP, GC_TOGGLE_REF_STRONG,
GC_TOGGLE_REF_WEAK);
for enum_a39ac617 use (GC_TOGGLE_REF_DROP => 0, GC_TOGGLE_REF_STRONG => 1,
GC_TOGGLE_REF_WEAK => 2);
pragma Convention (C, enum_a39ac617);
subtype GC_ToggleRefStatus is enum_a39ac617;
type access_e9efdbe8 is access function (a1 : void_ptr)
return GC_ToggleRefStatus;
pragma Convention (C, access_e9efdbe8);
subtype GC_toggleref_func is access_e9efdbe8;
procedure GC_set_toggleref_func (a1 : GC_toggleref_func);
pragma Import (C, GC_set_toggleref_func, "GC_set_toggleref_func");
function GC_get_toggleref_func return GC_toggleref_func;
pragma Import (C, GC_get_toggleref_func, "GC_get_toggleref_func");
function GC_toggleref_add (a1 : void_ptr; a2 : signed_int)
return signed_int;
pragma Import (C, GC_toggleref_add, "GC_toggleref_add");
subtype GC_await_finalize_proc is access_15c277d4;
procedure GC_set_await_finalize_proc (a1 : GC_await_finalize_proc);
pragma Import (C, GC_set_await_finalize_proc,
"GC_set_await_finalize_proc");
function GC_get_await_finalize_proc return GC_await_finalize_proc;
pragma Import (C, GC_get_await_finalize_proc,
"GC_get_await_finalize_proc");
function GC_should_invoke_finalizers return signed_int;
pragma Import (C, GC_should_invoke_finalizers,
"GC_should_invoke_finalizers");
function GC_invoke_finalizers return signed_int;
pragma Import (C, GC_invoke_finalizers, "GC_invoke_finalizers");
type access_112934b1 is access procedure (a1 : access char; a2 : GC_word);
pragma Convention (C, access_112934b1);
subtype GC_warn_proc is access_112934b1;
procedure GC_set_warn_proc (a1 : GC_warn_proc);
pragma Import (C, GC_set_warn_proc, "GC_set_warn_proc");
function GC_get_warn_proc return GC_warn_proc;
pragma Import (C, GC_get_warn_proc, "GC_get_warn_proc");
procedure GC_ignore_warn_proc (a1 : access char; a2 : GC_word);
pragma Import (C, GC_ignore_warn_proc, "GC_ignore_warn_proc");
procedure GC_set_log_fd (a1 : signed_int);
pragma Import (C, GC_set_log_fd, "GC_set_log_fd");
type access_83661e81 is access procedure (a1 : access constant char);
pragma Convention (C, access_83661e81);
subtype GC_abort_func is access_83661e81;
procedure GC_set_abort_func (a1 : GC_abort_func);
pragma Import (C, GC_set_abort_func, "GC_set_abort_func");
function GC_get_abort_func return GC_abort_func;
pragma Import (C, GC_get_abort_func, "GC_get_abort_func");
subtype GC_hidden_pointer is GC_word;
subtype GC_fn_type is access_336fa8d4;
function GC_call_with_alloc_lock (a1 : GC_fn_type; a2 : void_ptr)
return void_ptr;
pragma Import (C, GC_call_with_alloc_lock, "GC_call_with_alloc_lock");
type struct_GC_stack_base;
type struct_GC_stack_base is record
mem_base : aliased void_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_GC_stack_base);
type struct_GC_stack_base_ptr is access all struct_GC_stack_base;
for struct_GC_stack_base_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_GC_stack_base_ptr);
pragma Convention (C, struct_GC_stack_base_ptr);
type access_7de56a23 is access function (a1 : access struct_GC_stack_base;
a2 : void_ptr) return void_ptr;
pragma Convention (C, access_7de56a23);
subtype GC_stack_base_func is access_7de56a23;
function GC_call_with_stack_base (a1 : GC_stack_base_func; a2 : void_ptr)
return void_ptr;
pragma Import (C, GC_call_with_stack_base, "GC_call_with_stack_base");
function GC_do_blocking (a1 : GC_fn_type; a2 : void_ptr) return void_ptr;
pragma Import (C, GC_do_blocking, "GC_do_blocking");
function GC_call_with_gc_active (a1 : GC_fn_type; a2 : void_ptr)
return void_ptr;
pragma Import (C, GC_call_with_gc_active, "GC_call_with_gc_active");
function GC_get_stack_base (a1 : access struct_GC_stack_base)
return signed_int;
pragma Import (C, GC_get_stack_base, "GC_get_stack_base");
function GC_same_obj (a1 : void_ptr; a2 : void_ptr) return void_ptr;
pragma Import (C, GC_same_obj, "GC_same_obj");
function GC_pre_incr (a1 : access void_ptr; a2 : stddef.ptrdiff_t)
return void_ptr;
pragma Import (C, GC_pre_incr, "GC_pre_incr");
function GC_post_incr (a1 : access void_ptr; a2 : stddef.ptrdiff_t)
return void_ptr;
pragma Import (C, GC_post_incr, "GC_post_incr");
function GC_is_visible (a1 : void_ptr) return void_ptr;
pragma Import (C, GC_is_visible, "GC_is_visible");
function GC_is_valid_displacement (a1 : void_ptr) return void_ptr;
pragma Import (C, GC_is_valid_displacement, "GC_is_valid_displacement");
procedure GC_dump;
pragma Import (C, GC_dump, "GC_dump");
procedure GC_dump_regions;
pragma Import (C, GC_dump_regions, "GC_dump_regions");
procedure GC_dump_finalization;
pragma Import (C, GC_dump_finalization, "GC_dump_finalization");
GC_same_obj_print_proc : aliased access_4b44b147;
pragma Import (C, GC_same_obj_print_proc, "GC_same_obj_print_proc");
GC_is_valid_displacement_print_proc : aliased access_15c277d4;
pragma Import (C, GC_is_valid_displacement_print_proc,
"GC_is_valid_displacement_print_proc");
GC_is_visible_print_proc : aliased access_15c277d4;
pragma Import (C, GC_is_visible_print_proc, "GC_is_visible_print_proc");
function GC_malloc_many (a1 : stddef.size_t) return void_ptr;
pragma Import (C, GC_malloc_many, "GC_malloc_many");
type access_0137cb6c is access function (a1 : access constant char;
a2 : void_ptr; a3 : stddef.size_t) return signed_int;
pragma Convention (C, access_0137cb6c);
subtype GC_has_static_roots_func is access_0137cb6c;
procedure GC_register_has_static_roots_callback (
a1 : GC_has_static_roots_func);
pragma Import (C, GC_register_has_static_roots_callback,
"GC_register_has_static_roots_callback");
procedure GC_set_force_unmap_on_gcollect (a1 : signed_int);
pragma Import (C, GC_set_force_unmap_on_gcollect,
"GC_set_force_unmap_on_gcollect");
function GC_get_force_unmap_on_gcollect return signed_int;
pragma Import (C, GC_get_force_unmap_on_gcollect,
"GC_get_force_unmap_on_gcollect");
procedure GC_win32_free_heap;
pragma Import (C, GC_win32_free_heap, "GC_win32_free_heap");
-- GC_CHANGE_STUBBORN (function macro)
GC_DUPLICATE : constant := 1;
-- GC_END_STUBBORN_CHANGE (function macro)
-- GC_EXTRAS (unparsible)
-- GC_EXTRA_PARAMS (unparsible)
-- GC_FREE (function macro)
-- GC_GENERAL_REGISTER_DISAPPEARING_LINK (function macro)
-- GC_H (empty)
-- GC_HIDE_POINTER (function macro)
-- GC_INIT (function macro)
-- GC_INIT_CONF_DONT_EXPAND (empty)
-- GC_INIT_CONF_FORCE_UNMAP_ON_GCOLLECT (empty)
-- GC_INIT_CONF_FREE_SPACE_DIVISOR (empty)
-- GC_INIT_CONF_FULL_FREQ (empty)
-- GC_INIT_CONF_IGNORE_WARN (empty)
-- GC_INIT_CONF_INITIAL_HEAP_SIZE (empty)
-- GC_INIT_CONF_MAXIMUM_HEAP_SIZE (empty)
-- GC_INIT_CONF_MAX_RETRIES (empty)
-- GC_INIT_CONF_ROOTS (empty)
-- GC_INIT_CONF_SUSPEND_SIGNAL (empty)
-- GC_INIT_CONF_THR_RESTART_SIGNAL (empty)
-- GC_INIT_CONF_TIME_LIMIT (empty)
-- GC_MALLOC (function macro)
-- GC_MALLOC_ATOMIC (function macro)
-- GC_MALLOC_ATOMIC_IGNORE_OFF_PAGE (function macro)
-- GC_MALLOC_ATOMIC_UNCOLLECTABLE (function macro)
-- GC_MALLOC_IGNORE_OFF_PAGE (function macro)
-- GC_MALLOC_STUBBORN (function macro)
-- GC_MALLOC_UNCOLLECTABLE (function macro)
-- GC_NEW (function macro)
-- GC_NEW_ATOMIC (function macro)
-- GC_NEW_STUBBORN (function macro)
-- GC_NEW_UNCOLLECTABLE (function macro)
-- GC_NEXT (function macro)
GC_NOT_FOUND : constant := 4;
GC_NO_MEMORY : constant := 2;
GC_NO_THREADS : constant := 2;
-- GC_POST_DECR (function macro)
-- GC_POST_INCR (function macro)
-- GC_PRE_INCR (function macro)
GC_PROTECTS_NONE : constant := 0;
GC_PROTECTS_POINTER_HEAP : constant := 1;
GC_PROTECTS_PTRFREE_HEAP : constant := 2;
GC_PROTECTS_STACK : constant := 8;
GC_PROTECTS_STATIC_DATA : constant := 4;
-- GC_PTR_ADD (function macro)
-- GC_PTR_STORE (function macro)
-- GC_REALLOC (function macro)
-- GC_REGISTER_DISPLACEMENT (function macro)
-- GC_REGISTER_FINALIZER (function macro)
-- GC_REGISTER_FINALIZER_IGNORE_SELF (function macro)
-- GC_REGISTER_FINALIZER_NO_ORDER (function macro)
-- GC_REGISTER_FINALIZER_UNREACHABLE (function macro)
-- GC_REGISTER_LONG_LINK (function macro)
-- GC_REVEAL_POINTER (function macro)
-- GC_STRDUP (function macro)
-- GC_STRNDUP (function macro)
GC_SUCCESS : constant := 0;
GC_TIME_UNLIMITED : constant := 999999;
GC_UNIMPLEMENTED : constant := 3;
-- GC_reachable_here (function macro)
end C.gc.gc;
Raw
c-gc-gc_config_macros.ads
-- This file is translated by "headmaster" version 0.30-e83b81d (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.gc.gc_config_macros is
pragma Preelaborate;
-- GC_API (alias of extern)
-- GC_ATTR_ALLOC_SIZE (parameterized declaration-specifiers)
-- GC_ATTR_DEPRECATED (attribute)
-- GC_ATTR_MALLOC (attribute)
-- GC_ATTR_NONNULL (parameterized declaration-specifiers)
-- GC_CALL (empty)
-- GC_CALLBACK (empty)
-- GC_CAN_SAVE_CALL_STACKS (empty)
-- GC_HAVE_BUILTIN_BACKTRACE (empty)
-- __GC (empty)
end C.gc.gc_config_macros;
Raw
c-gc-gc_typed.ads
-- This file is translated by "headmaster" version 0.30-e83b81d (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.gc.gc;
with C.stddef;
package C.gc.gc_typed is
pragma Preelaborate;
subtype GC_bitmap is C.gc.gc.GC_word_ptr;
subtype GC_descr is C.gc.gc.GC_word;
function GC_make_descriptor (a1 : access constant C.gc.gc.GC_word;
a2 : stddef.size_t) return GC_descr;
pragma Import (C, GC_make_descriptor, "GC_make_descriptor");
function GC_malloc_explicitly_typed (a1 : stddef.size_t; a2 : GC_descr)
return void_ptr;
pragma Import (C, GC_malloc_explicitly_typed,
"GC_malloc_explicitly_typed");
function GC_malloc_explicitly_typed_ignore_off_page (a1 : stddef.size_t;
a2 : GC_descr) return void_ptr;
pragma Import (C, GC_malloc_explicitly_typed_ignore_off_page,
"GC_malloc_explicitly_typed_ignore_off_page");
function GC_calloc_explicitly_typed (a1 : stddef.size_t;
a2 : stddef.size_t; a3 : GC_descr) return void_ptr;
pragma Import (C, GC_calloc_explicitly_typed,
"GC_calloc_explicitly_typed");
-- GC_BITMAP_SIZE (function macro)
-- GC_CALLOC_EXPLICITLY_TYPED (function macro)
-- GC_MALLOC_EXPLICITLY_TYPED (function macro)
-- GC_TYPED_H (empty)
GC_WORDSZ : constant := 64;
-- GC_WORD_LEN (function macro)
-- GC_WORD_OFFSET (unparsible)
-- GC_get_bit (function macro)
-- GC_set_bit (function macro)
end C.gc.gc_typed;
Raw
c-gc-gc_version.ads
-- This file is translated by "headmaster" version 0.30-e83b81d (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.gc.gc_version is
pragma Preelaborate;
GC_TMP_VERSION_MAJOR : constant := 7;
GC_TMP_VERSION_MICRO : constant := 4;
GC_TMP_VERSION_MINOR : constant := 6;
GC_VERSION_MAJOR : constant := 7;
GC_VERSION_MICRO : constant := 4;
GC_VERSION_MINOR : constant := 6;
end C.gc.gc_version;
Raw
c-gc.ads
-- This file is translated by "headmaster" version 0.30-e83b81d (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.gc is
pragma Preelaborate;
end C.gc;
Raw
c-gnu-stubs_64.ads
-- This file is translated by "headmaster" version 0.30-e83b81d (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.gnu.stubs_64 is
pragma Preelaborate;
-- __stub___compat_bdflush (empty)
-- __stub_chflags (empty)
-- __stub_fattach (empty)
-- __stub_fchflags (empty)
-- __stub_fdetach (empty)
-- __stub_getmsg (empty)
-- __stub_gtty (empty)
-- __stub_lchmod (empty)
-- __stub_putmsg (empty)
-- __stub_revoke (empty)
-- __stub_setlogin (empty)
-- __stub_sigreturn (empty)
-- __stub_sstk (empty)
-- __stub_stty (empty)
end C.gnu.stubs_64;
Raw
c-gnu.ads
-- This file is translated by "headmaster" version 0.30-e83b81d (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.gnu is
pragma Preelaborate;
end C.gnu;
Raw
c-stddef.ads
-- This file is translated by "headmaster" version 0.30-e83b81d (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.stddef is
pragma Preelaborate;
subtype ptrdiff_t is Standard.C.ptrdiff_t;
subtype size_t is Standard.C.size_t;
subtype wchar_t is Standard.C.wchar_t;
C_NULL : constant void_ptr := void_ptr (System'To_Address (0));
-- _ANSI_STDDEF_H (empty)
-- _BSD_PTRDIFF_T_ (empty)
-- _BSD_SIZE_T_ (empty)
-- _BSD_SIZE_T_DEFINED_ (empty)
-- _GCC_PTRDIFF_T (empty)
-- _GCC_SIZE_T (empty)
-- _GCC_WCHAR_T (empty)
-- _PTRDIFF_T (empty)
-- _PTRDIFF_T_ (empty)
-- _PTRDIFF_T_DECLARED (empty)
-- _SIZET_ (empty)
-- _SIZE_T (empty)
-- _SIZE_T_ (empty)
-- _SIZE_T_DECLARED (empty)
-- _SIZE_T_DEFINED (empty)
-- _SIZE_T_DEFINED_ (empty)
-- _STDDEF_H (empty)
-- _STDDEF_H_ (empty)
-- _SYS_SIZE_T_H (empty)
-- _T_PTRDIFF (empty)
-- _T_PTRDIFF_ (empty)
-- _T_SIZE (empty)
-- _T_SIZE_ (empty)
-- _T_WCHAR (empty)
-- _T_WCHAR_ (empty)
-- _WCHAR_T (empty)
-- _WCHAR_T_ (empty)
-- _WCHAR_T_DECLARED (empty)
-- _WCHAR_T_DEFINED (empty)
-- _WCHAR_T_DEFINED_ (empty)
-- _WCHAR_T_H (empty)
-- __INT_WCHAR_T_H (empty)
-- __PTRDIFF_T (empty)
-- __SIZE_T (empty)
-- __SIZE_T__ (empty)
-- __WCHAR_T (empty)
-- __WCHAR_T__ (empty)
-- ___int_ptrdiff_t_h (empty)
-- ___int_size_t_h (empty)
-- ___int_wchar_t_h (empty)
-- __size_t (empty)
-- __size_t__ (empty)
-- __wchar_t__ (empty)
-- offsetof (unparsible)
end C.stddef;
Raw
c-sys-cdefs.ads
-- This file is translated by "headmaster" version 0.30-e83b81d (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.sys.cdefs is
pragma Preelaborate;
SYS_CDEFS_H : constant := 1;
-- __ASMNAME (unparsible)
-- __ASMNAME2 (unparsible)
-- __BEGIN_DECLS (empty)
-- __BEGIN_NAMESPACE_C99 (empty)
-- __BEGIN_NAMESPACE_STD (empty)
-- __CONCAT (has # or ##)
-- __END_DECLS (empty)
-- __END_NAMESPACE_C99 (empty)
-- __END_NAMESPACE_STD (empty)
-- __LDBL_REDIR (unparsible)
-- __LDBL_REDIR1 (unparsible)
-- __LDBL_REDIR1_NTH (unparsible)
-- __LDBL_REDIR_DECL (empty)
-- __LDBL_REDIR_NTH (unparsible)
-- __LEAF (unparsible)
-- __LEAF_ATTR (attribute)
-- __NTH (unparsible)
-- __P (function macro)
-- __PMT (function macro)
-- __REDIRECT (has # or ##)
-- __REDIRECT_LDBL (unparsible)
-- __REDIRECT_NTH (has # or ##)
-- __REDIRECT_NTHNL (has # or ##)
-- __REDIRECT_NTH_LDBL (unparsible)
-- __STRING (has # or ##)
-- __THROW (attribute)
-- __THROWNL (attribute)
-- __USING_NAMESPACE_C99 (empty)
-- __USING_NAMESPACE_STD (empty)
-- __always_inline (alias of inline)
-- __attribute_alloc_size__ (unparsible)
-- __attribute_artificial__ (attribute)
-- __attribute_const__ (attribute)
-- __attribute_deprecated__ (attribute)
-- __attribute_format_arg__ (parameterized declaration-specifiers)
-- __attribute_format_strfmon__ (parameterized declaration-specifiers)
-- __attribute_malloc__ (attribute)
-- __attribute_noinline__ (attribute)
-- __attribute_pure__ (attribute)
-- __attribute_used__ (attribute)
-- __attribute_warn_unused_result__ (attribute)
-- __bos (function macro)
-- __bos0 (function macro)
-- __errordecl (unparsible)
-- __extern_always_inline (unparsible)
-- __extern_inline (alias of inline)
-- __flexarr (unparsible)
-- __fortify_function (unparsible)
-- __glibc_likely (function macro)
-- __glibc_unlikely (function macro)
subtype long_double_t is long_double;
-- __nonnull (unparsible)
-- __ptr_t (unparsible)
-- __restrict_arr (alias of restrict)
-- __va_arg_pack (unparsible)
-- __va_arg_pack_len (unparsible)
-- __warnattr (unparsible)
-- __warndecl (unparsible)
-- __wur (empty)
end C.sys.cdefs;
Raw
c-sys-mman.ads
-- This file is translated by "headmaster" version 0.30-e83b81d (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.bits.mman_linux;
with C.bits.types;
with C.stddef;
package C.sys.mman is
pragma Preelaborate;
MADV_DODUMP : constant := bits.mman_linux.MADV_DODUMP;
MADV_DOFORK : constant := bits.mman_linux.MADV_DOFORK;
MADV_DONTDUMP : constant := bits.mman_linux.MADV_DONTDUMP;
MADV_DONTFORK : constant := bits.mman_linux.MADV_DONTFORK;
MADV_DONTNEED : constant := bits.mman_linux.MADV_DONTNEED;
MADV_FREE : constant := bits.mman_linux.MADV_FREE;
MADV_HUGEPAGE : constant := bits.mman_linux.MADV_HUGEPAGE;
MADV_HWPOISON : constant := bits.mman_linux.MADV_HWPOISON;
MADV_MERGEABLE : constant := bits.mman_linux.MADV_MERGEABLE;
MADV_NOHUGEPAGE : constant := bits.mman_linux.MADV_NOHUGEPAGE;
MADV_NORMAL : constant := bits.mman_linux.MADV_NORMAL;
MADV_RANDOM : constant := bits.mman_linux.MADV_RANDOM;
MADV_REMOVE : constant := bits.mman_linux.MADV_REMOVE;
MADV_SEQUENTIAL : constant := bits.mman_linux.MADV_SEQUENTIAL;
MADV_UNMERGEABLE : constant := bits.mman_linux.MADV_UNMERGEABLE;
MADV_WILLNEED : constant := bits.mman_linux.MADV_WILLNEED;
MAP_ANON : constant := bits.mman_linux.MAP_ANON;
MAP_ANONYMOUS : constant := bits.mman_linux.MAP_ANONYMOUS;
MAP_FILE : constant := bits.mman_linux.MAP_FILE;
MAP_FIXED : constant := bits.mman_linux.MAP_FIXED;
MAP_HUGE_MASK : constant := bits.mman_linux.MAP_HUGE_MASK;
MAP_HUGE_SHIFT : constant := bits.mman_linux.MAP_HUGE_SHIFT;
MAP_PRIVATE : constant := bits.mman_linux.MAP_PRIVATE;
MAP_SHARED : constant := bits.mman_linux.MAP_SHARED;
MAP_TYPE : constant := bits.mman_linux.MAP_TYPE;
MCL_CURRENT : constant := bits.mman_linux.MCL_CURRENT;
MCL_FUTURE : constant := bits.mman_linux.MCL_FUTURE;
MCL_ONFAULT : constant := bits.mman_linux.MCL_ONFAULT;
MS_ASYNC : constant := bits.mman_linux.MS_ASYNC;
MS_INVALIDATE : constant := bits.mman_linux.MS_INVALIDATE;
MS_SYNC : constant := bits.mman_linux.MS_SYNC;
POSIX_MADV_DONTNEED : constant := bits.mman_linux.POSIX_MADV_DONTNEED;
POSIX_MADV_NORMAL : constant := bits.mman_linux.POSIX_MADV_NORMAL;
POSIX_MADV_RANDOM : constant := bits.mman_linux.POSIX_MADV_RANDOM;
POSIX_MADV_SEQUENTIAL : constant := bits.mman_linux.POSIX_MADV_SEQUENTIAL;
POSIX_MADV_WILLNEED : constant := bits.mman_linux.POSIX_MADV_WILLNEED;
PROT_EXEC : constant := bits.mman_linux.PROT_EXEC;
PROT_GROWSDOWN : constant := bits.mman_linux.PROT_GROWSDOWN;
PROT_GROWSUP : constant := bits.mman_linux.PROT_GROWSUP;
PROT_NONE : constant := bits.mman_linux.PROT_NONE;
PROT_READ : constant := bits.mman_linux.PROT_READ;
PROT_WRITE : constant := bits.mman_linux.PROT_WRITE;
subtype off_t is bits.types.off_t;
subtype mode_t is bits.types.mode_t;
function mmap (addr : void_ptr; len : stddef.size_t; prot : signed_int;
flags : signed_int; fd : signed_int; offset : bits.types.off_t)
return void_ptr;
pragma Import (C, mmap, "mmap");
function munmap (addr : void_ptr; len : stddef.size_t) return signed_int;
pragma Import (C, munmap, "munmap");
function mprotect (addr : void_ptr; len : stddef.size_t;
prot : signed_int) return signed_int;
pragma Import (C, mprotect, "mprotect");
function msync (addr : void_ptr; len : stddef.size_t; flags : signed_int)
return signed_int;
pragma Import (C, msync, "msync");
function madvise (addr : void_ptr; len : stddef.size_t;
advice : signed_int) return signed_int;
pragma Import (C, madvise, "madvise");
function posix_madvise (addr : void_ptr; len : stddef.size_t;
advice : signed_int) return signed_int;
pragma Import (C, posix_madvise, "posix_madvise");
function mlock (addr : void_const_ptr; len : stddef.size_t)
return signed_int;
pragma Import (C, mlock, "mlock");
function munlock (addr : void_const_ptr; len : stddef.size_t)
return signed_int;
pragma Import (C, munlock, "munlock");
function mlockall (flags : signed_int) return signed_int;
pragma Import (C, mlockall, "mlockall");
function munlockall return signed_int;
pragma Import (C, munlockall, "munlockall");
function mincore (start : void_ptr; len : stddef.size_t;
vec : access unsigned_char) return signed_int;
pragma Import (C, mincore, "mincore");
function shm_open (name : access constant char; oflag : signed_int;
mode : mode_t) return signed_int;
pragma Import (C, shm_open, "shm_open");
function shm_unlink (name : access constant char) return signed_int;
pragma Import (C, shm_unlink, "shm_unlink");
MAP_FAILED : constant void_ptr := void_ptr (System'To_Address (-1));
SYS_MMAN_H : constant := 1;
-- __mode_t_defined (empty)
-- __off_t_defined (empty)
end C.sys.mman;
Raw
c-sys.ads
-- This file is translated by "headmaster" version 0.30-e83b81d (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.sys is
pragma Preelaborate;
end C.sys;
Raw
c.ads
-- This file is translated by "headmaster" version 0.30-e83b81d (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 System;
package C is
pragma Preelaborate;
-- type void (<>) is limited private;
type bool is new Boolean;
pragma Convention (C, bool);
type signed_char is new Short_Short_Integer;
pragma Convention (C, signed_char);
type unsigned_char is mod 2 ** signed_char'Size;
pragma Convention (C, unsigned_char);
type signed_short is new Short_Integer;
pragma Convention (C, signed_short);
type unsigned_short is mod 2 ** signed_short'Size;
pragma Convention (C, unsigned_short);
type signed_int is new Integer;
pragma Convention (C, signed_int);
type unsigned_int is mod 2 ** signed_int'Size;
pragma Convention (C, unsigned_int);
type signed_long is new Long_Integer;
pragma Convention (C, signed_long);
type unsigned_long is mod 2 ** signed_long'Size;
pragma Convention (C, unsigned_long);
type signed_long_long is new Long_Long_Integer;
pragma Convention (C, signed_long_long);
type unsigned_long_long is mod 2 ** signed_long_long'Size;
pragma Convention (C, unsigned_long_long);
type float is new Standard.Float;
pragma Convention (C, float);
type double is new Long_Float;
pragma Convention (C, double);
type long_double is new Long_Long_Float;
pragma Convention (C, long_double);
-- type Float32 is ...
-- type Float64 is ...
-- type Float128 is ...
-- type Float32x is ...
-- type Float64x is ...
-- type Decimal32 is ...
-- type Decimal64 is ...
-- type Decimal128 is ...
type float_imaginary is new float;
pragma Convention (C, float_imaginary);
type double_imaginary is new double;
pragma Convention (C, double_imaginary);
type long_double_imaginary is new long_double;
pragma Convention (C, long_double_imaginary);
-- type Float32_imaginary is ...
-- type Float32x_imaginary is ...
-- type Float64_imaginary is ...
-- type Float64x_imaginary is ...
-- type Float128_imaginary is ...
type float_complex is record
Re, Im : float'Base;
end record;
pragma Complex_Representation (float_complex);
pragma Convention (C, float_complex);
type double_complex is record
Re, Im : double'Base;
end record;
pragma Complex_Representation (double_complex);
pragma Convention (C, double_complex);
type long_double_complex is record
Re, Im : long_double'Base;
end record;
pragma Complex_Representation (long_double_complex);
pragma Convention (C, long_double_complex);
-- type Float32_complex is ...
-- type Float32x_complex is ...
-- type Float64_complex is ...
-- type Float64x_complex is ...
-- type Float128_complex is ...
type char is new Character;
type int128_t is record
Lo, Hi : unsigned_long_long;
end record;
pragma Convention (C_Pass_By_Copy, int128_t);
type uint128_t is record
Lo, Hi : unsigned_long_long;
end record;
pragma Convention (C_Pass_By_Copy, uint128_t);
subtype builtin_va_list is System.Address;
type ptrdiff_t is new signed_long;
type size_t is new unsigned_long;
type wchar_t is new signed_int;
subtype void_ptr is System.Address;
type void_ptr_ptr is access all void_ptr;
for void_ptr_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (void_ptr_ptr);
pragma Convention (C, void_ptr_ptr);
subtype void_const_ptr is System.Address;
type unsigned_char_ptr is access all unsigned_char;
for unsigned_char_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (unsigned_char_ptr);
pragma Convention (C, unsigned_char_ptr);
type signed_int_array is array (size_t range <>) of aliased signed_int;
pragma Convention (C, signed_int_array);
type signed_long_ptr is access all signed_long;
for signed_long_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (signed_long_ptr);
pragma Convention (C, signed_long_ptr);
type unsigned_long_ptr is access all unsigned_long;
for unsigned_long_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (unsigned_long_ptr);
pragma Convention (C, unsigned_long_ptr);
type unsigned_long_const_ptr is access constant unsigned_long;
for unsigned_long_const_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (unsigned_long_const_ptr);
pragma Convention (C, unsigned_long_const_ptr);
type char_ptr is access all char;
for char_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (char_ptr);
pragma Convention (C, char_ptr);
type char_const_ptr is access constant char;
for char_const_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (char_const_ptr);
pragma Convention (C, char_const_ptr);
type char_array is array (size_t range <>) of aliased char;
pragma Convention (C, char_array);
function "=" (Left, Right : System.Address) return Boolean
renames System."=";
function Shift_Left (Left : signed_char; Right : Natural)
return signed_char;
function Shift_Right_Arithmetic (Left : signed_char; Right : Natural)
return signed_char;
function Shift_Left (Left : unsigned_char; Right : Natural)
return unsigned_char;
function Shift_Right (Left : unsigned_char; Right : Natural)
return unsigned_char;
function Shift_Left (Left : signed_short; Right : Natural)
return signed_short;
function Shift_Right_Arithmetic (Left : signed_short; Right : Natural)
return signed_short;
function Shift_Left (Left : unsigned_short; Right : Natural)
return unsigned_short;
function Shift_Right (Left : unsigned_short; Right : Natural)
return unsigned_short;
function Shift_Left (Left : signed_int; Right : Natural)
return signed_int;
function Shift_Right_Arithmetic (Left : signed_int; Right : Natural)
return signed_int;
function Shift_Left (Left : unsigned_int; Right : Natural)
return unsigned_int;
function Shift_Right (Left : unsigned_int; Right : Natural)
return unsigned_int;
function Shift_Left (Left : signed_long; Right : Natural)
return signed_long;
function Shift_Right_Arithmetic (Left : signed_long; Right : Natural)
return signed_long;
function Shift_Left (Left : unsigned_long; Right : Natural)
return unsigned_long;
function Shift_Right (Left : unsigned_long; Right : Natural)
return unsigned_long;
function Shift_Left (Left : signed_long_long; Right : Natural)
return signed_long_long;
function Shift_Right_Arithmetic (Left : signed_long_long; Right : Natural)
return signed_long_long;
function Shift_Left (Left : unsigned_long_long; Right : Natural)
return unsigned_long_long;
function Shift_Right (Left : unsigned_long_long; Right : Natural)
return unsigned_long_long;
pragma Import (Intrinsic, Shift_Left);
pragma Import (Intrinsic, Shift_Right);
pragma Import (Intrinsic, Shift_Right_Arithmetic);
LP64 : constant := 1;
STDC_PREDEF_H : constant := 1;
ATOMIC_ACQUIRE : constant := 2;
ATOMIC_ACQ_REL : constant := 4;
ATOMIC_CONSUME : constant := 1;
ATOMIC_HLE_ACQUIRE : constant := 65536;
ATOMIC_HLE_RELEASE : constant := 131072;
ATOMIC_RELAXED : constant := 0;
ATOMIC_RELEASE : constant := 3;
ATOMIC_SEQ_CST : constant := 5;
qqBIGGEST_ALIGNMENTqq : constant := 16;
qqBYTE_ORDERqq : constant := 1234;
subtype qqCHAR16_TYPEqq is unsigned_short;
subtype qqCHAR32_TYPEqq is unsigned_int;
qqCHAR_BITqq : constant := 8;
qqDBL_DECIMAL_DIGqq : constant := 17;
qqDBL_DENORM_MINqq : constant := 16#0.40000000000000000#e-268;
qqDBL_DIGqq : constant := 15;
qqDBL_EPSILONqq : constant := 16#0.10000000000000000#e-12;
qqDBL_HAS_DENORMqq : constant := 1;
qqDBL_HAS_INFINITYqq : constant := 1;
qqDBL_HAS_QUIET_NANqq : constant := 1;
qqDBL_MANT_DIGqq : constant := 53;
qqDBL_MAX_10_EXPqq : constant := 308;
qqDBL_MAX_EXPqq : constant := 1024;
qqDBL_MAXqq : constant := 16#0.fffffffffffff8000#e+256;
qqDBL_MIN_10_EXPqq : constant := -307;
qqDBL_MIN_EXPqq : constant := -1021;
qqDBL_MINqq : constant := 16#0.40000000000000000#e-255;
-- qqDEC128_EPSILONqq (decimal)
qqDEC128_MANT_DIGqq : constant := 34;
qqDEC128_MAX_EXPqq : constant := 6145;
-- qqDEC128_MAXqq (decimal)
qqDEC128_MIN_EXPqq : constant := -6142;
-- qqDEC128_MINqq (decimal)
-- qqDEC128_SUBNORMAL_MINqq (decimal)
-- qqDEC32_EPSILONqq (decimal)
qqDEC32_MANT_DIGqq : constant := 7;
qqDEC32_MAX_EXPqq : constant := 97;
-- qqDEC32_MAXqq (decimal)
qqDEC32_MIN_EXPqq : constant := -94;
-- qqDEC32_MINqq (decimal)
-- qqDEC32_SUBNORMAL_MINqq (decimal)
-- qqDEC64_EPSILONqq (decimal)
qqDEC64_MANT_DIGqq : constant := 16;
qqDEC64_MAX_EXPqq : constant := 385;
-- qqDEC64_MAXqq (decimal)
qqDEC64_MIN_EXPqq : constant := -382;
-- qqDEC64_MINqq (decimal)
-- qqDEC64_SUBNORMAL_MINqq (decimal)
qqDECIMAL_BID_FORMATqq : constant := 1;
qqDECIMAL_DIGqq : constant := 21;
qqDEC_EVAL_METHODqq : constant := 2;
qqELFqq : constant := 1;
qqFINITE_MATH_ONLYqq : constant := 0;
qqFLOAT_WORD_ORDERqq : constant := 1234;
qqFLT_DECIMAL_DIGqq : constant := 9;
qqFLT_DENORM_MINqq : constant := 16#0.80000000000000000#e-37;
qqFLT_DIGqq : constant := 6;
qqFLT_EPSILONqq : constant := 16#0.20000000000000000#e-5;
qqFLT_EVAL_METHODqq : constant := 0;
qqFLT_HAS_DENORMqq : constant := 1;
qqFLT_HAS_INFINITYqq : constant := 1;
qqFLT_HAS_QUIET_NANqq : constant := 1;
qqFLT_MANT_DIGqq : constant := 24;
qqFLT_MAX_10_EXPqq : constant := 38;
qqFLT_MAX_EXPqq : constant := 128;
qqFLT_MAXqq : constant := 16#0.ffffff00000000000#e+32;
qqFLT_MIN_10_EXPqq : constant := -37;
qqFLT_MIN_EXPqq : constant := -125;
qqFLT_MINqq : constant := 16#0.40000000000000000#e-31;
qqFLT_RADIXqq : constant := 2;
qqFXSRqq : constant := 1;
qqGCC_ASM_FLAG_OUTPUTSqq : constant := 1;
GCC_ATOMIC_BOOL_LOCK_FREE : constant := 2;
GCC_ATOMIC_CHAR16_T_LOCK_FREE : constant := 2;
GCC_ATOMIC_CHAR32_T_LOCK_FREE : constant := 2;
GCC_ATOMIC_CHAR_LOCK_FREE : constant := 2;
GCC_ATOMIC_INT_LOCK_FREE : constant := 2;
GCC_ATOMIC_LLONG_LOCK_FREE : constant := 2;
GCC_ATOMIC_LONG_LOCK_FREE : constant := 2;
GCC_ATOMIC_POINTER_LOCK_FREE : constant := 2;
GCC_ATOMIC_SHORT_LOCK_FREE : constant := 2;
GCC_ATOMIC_TEST_AND_SET_TRUEVAL : constant := 1;
GCC_ATOMIC_WCHAR_T_LOCK_FREE : constant := 2;
GCC_HAVE_DWARF2_CFI_ASM : constant := 1;
GCC_HAVE_SYNC_COMPARE_AND_SWAP_1 : constant := 1;
GCC_HAVE_SYNC_COMPARE_AND_SWAP_16 : constant := 1;
GCC_HAVE_SYNC_COMPARE_AND_SWAP_2 : constant := 1;
GCC_HAVE_SYNC_COMPARE_AND_SWAP_4 : constant := 1;
GCC_HAVE_SYNC_COMPARE_AND_SWAP_8 : constant := 1;
GCC_IEC_559 : constant := 2;
GCC_IEC_559_COMPLEX : constant := 2;
qqGNUC_MINORqq : constant := 5;
qqGNUC_PATCHLEVELqq : constant := 0;
qqGNUC_STDC_INLINEqq : constant := 1;
qqGNUCqq : constant := 6;
GXX_ABI_VERSION : constant := 1010;
-- __INT16_C (function macro)
qqINT16_MAXqq : constant := 32767;
subtype qqINT16_TYPEqq is signed_short;
-- __INT32_C (function macro)
qqINT32_MAXqq : constant := 2147483647;
subtype qqINT32_TYPEqq is signed_int;
-- __INT64_C (has # or ##)
qqINT64_MAXqq : constant := 9223372036854775807;
subtype qqINT64_TYPEqq is signed_long;
-- __INT8_C (function macro)
qqINT8_MAXqq : constant := 127;
subtype qqINT8_TYPEqq is signed_char;
-- __INTMAX_C (has # or ##)
qqINTMAX_MAXqq : constant := 9223372036854775807;
subtype qqINTMAX_TYPEqq is signed_long;
qqINTPTR_MAXqq : constant := 9223372036854775807;
subtype qqINTPTR_TYPEqq is signed_long;
qqINT_FAST16_MAXqq : constant := 9223372036854775807;
subtype qqINT_FAST16_TYPEqq is signed_long;
qqINT_FAST32_MAXqq : constant := 9223372036854775807;
subtype qqINT_FAST32_TYPEqq is signed_long;
qqINT_FAST64_MAXqq : constant := 9223372036854775807;
subtype qqINT_FAST64_TYPEqq is signed_long;
qqINT_FAST8_MAXqq : constant := 127;
subtype qqINT_FAST8_TYPEqq is signed_char;
qqINT_LEAST16_MAXqq : constant := 32767;
subtype qqINT_LEAST16_TYPEqq is signed_short;
qqINT_LEAST32_MAXqq : constant := 2147483647;
subtype qqINT_LEAST32_TYPEqq is signed_int;
qqINT_LEAST64_MAXqq : constant := 9223372036854775807;
subtype qqINT_LEAST64_TYPEqq is signed_long;
qqINT_LEAST8_MAXqq : constant := 127;
subtype qqINT_LEAST8_TYPEqq is signed_char;
qqINT_MAXqq : constant := 2147483647;
qqLDBL_DENORM_MINqq : constant := 16#0.80000000000000000#e-4111;
qqLDBL_DIGqq : constant := 18;
qqLDBL_EPSILONqq : constant := 16#0.20000000000000000#e-15;
qqLDBL_HAS_DENORMqq : constant := 1;
qqLDBL_HAS_INFINITYqq : constant := 1;
qqLDBL_HAS_QUIET_NANqq : constant := 1;
qqLDBL_MANT_DIGqq : constant := 64;
qqLDBL_MAX_10_EXPqq : constant := 4932;
qqLDBL_MAX_EXPqq : constant := 16384;
qqLDBL_MAXqq : constant := 16#0.ffffffffffffffff0#e+4096;
qqLDBL_MIN_10_EXPqq : constant := -4931;
qqLDBL_MIN_EXPqq : constant := -16381;
qqLDBL_MINqq : constant := 16#0.40000000000000000#e-4095;
qqLONG_LONG_MAXqq : constant := 9223372036854775807;
qqLONG_MAXqq : constant := 9223372036854775807;
qqLP64qq : constant := 1;
qqMMXqq : constant := 1;
qqNO_INLINEqq : constant := 1;
qqORDER_BIG_ENDIANqq : constant := 4321;
qqORDER_LITTLE_ENDIANqq : constant := 1234;
qqORDER_PDP_ENDIANqq : constant := 3412;
PRAGMA_REDEFINE_EXTNAME : constant := 1;
qqPTRDIFF_MAXqq : constant := 9223372036854775807;
subtype qqPTRDIFF_TYPEqq is signed_long;
-- __REGISTER_PREFIX__ (empty)
qqSCHAR_MAXqq : constant := 127;
SEG_FS : constant := 1;
SEG_GS : constant := 1;
qqSHRT_MAXqq : constant := 32767;
qqSIG_ATOMIC_MAXqq : constant := 2147483647;
qqSIG_ATOMIC_MINqq : constant := -2147483648;
subtype qqSIG_ATOMIC_TYPEqq is signed_int;
qqSIZEOF_DOUBLEqq : constant := 8;
qqSIZEOF_FLOAT128qq : constant := 16;
qqSIZEOF_FLOAT80qq : constant := 16;
qqSIZEOF_FLOATqq : constant := 4;
qqSIZEOF_INT128qq : constant := 16;
qqSIZEOF_INTqq : constant := 4;
qqSIZEOF_LONG_DOUBLEqq : constant := 16;
qqSIZEOF_LONG_LONGqq : constant := 8;
qqSIZEOF_LONGqq : constant := 8;
qqSIZEOF_POINTERqq : constant := 8;
qqSIZEOF_PTRDIFF_Tqq : constant := 8;
qqSIZEOF_SHORTqq : constant := 2;
qqSIZEOF_SIZE_Tqq : constant := 8;
qqSIZEOF_WCHAR_Tqq : constant := 4;
qqSIZEOF_WINT_Tqq : constant := 4;
qqSIZE_MAXqq : constant := 18446744073709551615;
subtype qqSIZE_TYPEqq is unsigned_long;
qqSSE2_MATHqq : constant := 1;
qqSSE2qq : constant := 1;
qqSSE3qq : constant := 1;
qqSSE_MATHqq : constant := 1;
qqSSEqq : constant := 1;
qqSSSE3qq : constant := 1;
qqSTDC_HOSTEDqq : constant := 1;
qqSTDC_NO_THREADSqq : constant := 1;
qqSTDC_UTF_16qq : constant := 1;
qqSTDC_UTF_32qq : constant := 1;
-- __UINT16_C (function macro)
qqUINT16_MAXqq : constant := 65535;
subtype qqUINT16_TYPEqq is unsigned_short;
-- __UINT32_C (has # or ##)
qqUINT32_MAXqq : constant := 4294967295;
subtype qqUINT32_TYPEqq is unsigned_int;
-- __UINT64_C (has # or ##)
qqUINT64_MAXqq : constant := 18446744073709551615;
subtype qqUINT64_TYPEqq is unsigned_long;
-- __UINT8_C (function macro)
qqUINT8_MAXqq : constant := 255;
subtype qqUINT8_TYPEqq is unsigned_char;
-- __UINTMAX_C (has # or ##)
qqUINTMAX_MAXqq : constant := 18446744073709551615;
subtype qqUINTMAX_TYPEqq is unsigned_long;
qqUINTPTR_MAXqq : constant := 18446744073709551615;
subtype qqUINTPTR_TYPEqq is unsigned_long;
qqUINT_FAST16_MAXqq : constant := 18446744073709551615;
subtype qqUINT_FAST16_TYPEqq is unsigned_long;
qqUINT_FAST32_MAXqq : constant := 18446744073709551615;
subtype qqUINT_FAST32_TYPEqq is unsigned_long;
qqUINT_FAST64_MAXqq : constant := 18446744073709551615;
subtype qqUINT_FAST64_TYPEqq is unsigned_long;
qqUINT_FAST8_MAXqq : constant := 255;
subtype qqUINT_FAST8_TYPEqq is unsigned_char;
qqUINT_LEAST16_MAXqq : constant := 65535;
subtype qqUINT_LEAST16_TYPEqq is unsigned_short;
qqUINT_LEAST32_MAXqq : constant := 4294967295;
subtype qqUINT_LEAST32_TYPEqq is unsigned_int;
qqUINT_LEAST64_MAXqq : constant := 18446744073709551615;
subtype qqUINT_LEAST64_TYPEqq is unsigned_long;
qqUINT_LEAST8_MAXqq : constant := 255;
subtype qqUINT_LEAST8_TYPEqq is unsigned_char;
-- __USER_LABEL_PREFIX__ (empty)
qqVERSIONqq : constant char_array (0 .. 5) := "6.5.0" & char'Val (0);
qqWCHAR_MAXqq : constant := 2147483647;
qqWCHAR_MINqq : constant := -2147483648;
subtype qqWCHAR_TYPEqq is signed_int;
qqWINT_MAXqq : constant := 4294967295;
qqWINT_MINqq : constant := 0;
subtype qqWINT_TYPEqq is unsigned_int;
amd64 : constant := 1;
qqamd64qq : constant := 1;
qqcode_model_smallqq : constant := 1;
core2 : constant := 1;
qqcore2qq : constant := 1;
qqgnu_linuxqq : constant := 1;
-- __has_include (has __has_include__ or __has_include_next__)
-- __has_include_next (has __has_include__ or __has_include_next__)
defined_qqlinux : constant := 1;
qqlinuxqq : constant := 1;
qqunix : constant := 1;
qqunixqq : constant := 1;
x86_64 : constant := 1;
qqx86_64qq : constant := 1;
defined_linux : constant := 1;
unix : constant := 1;
function builtin_alloca (a1 : size_t) return char_ptr;
pragma Import (Intrinsic, builtin_alloca, "__builtin_alloca");
function builtin_bswap16 (a1 : unsigned_short) return unsigned_short;
pragma Import (Intrinsic, builtin_bswap16, "__builtin_bswap16");
function builtin_bswap32 (a1 : unsigned_int) return unsigned_int;
pragma Import (Intrinsic, builtin_bswap32, "__builtin_bswap32");
function builtin_bswap64 (a1 : unsigned_long_long)
return unsigned_long_long;
pragma Import (Intrinsic, builtin_bswap64, "__builtin_bswap64");
procedure builtin_bzero (a1 : access char; a2 : size_t);
pragma Import (Intrinsic, builtin_bzero, "__builtin_bzero");
function builtin_extract_return_addr (a1 : access char) return char_ptr;
pragma Import (Intrinsic, builtin_extract_return_addr,
"__builtin_extract_return_addr");
function builtin_fabsf (a1 : float) return float;
pragma Import (Intrinsic, builtin_fabsf, "__builtin_fabsf");
function builtin_fabs (a1 : double) return double;
pragma Import (Intrinsic, builtin_fabs, "__builtin_fabs");
function builtin_fabsl (a1 : long_double) return long_double;
pragma Import (Intrinsic, builtin_fabsl, "__builtin_fabsl");
function builtin_flt_rounds return signed_int;
pragma Import (Intrinsic, builtin_flt_rounds, "__builtin_flt_rounds");
function builtin_frame_address (a1 : unsigned_int) return char_ptr;
pragma Import (Intrinsic, builtin_frame_address,
"__builtin_frame_address");
function builtin_huge_valf return float;
pragma Import (Intrinsic, builtin_huge_valf, "__builtin_huge_valf");
function builtin_huge_val return double;
pragma Import (Intrinsic, builtin_huge_val, "__builtin_huge_val");
function builtin_huge_vall return long_double;
pragma Import (Intrinsic, builtin_huge_vall, "__builtin_huge_vall");
function builtin_inff return float;
pragma Import (Intrinsic, builtin_inff, "__builtin_inff");
function builtin_inf return double;
pragma Import (Intrinsic, builtin_inf, "__builtin_inf");
function builtin_infl return long_double;
pragma Import (Intrinsic, builtin_infl, "__builtin_infl");
function builtin_llabs (a1 : signed_long_long) return signed_long_long;
pragma Import (Intrinsic, builtin_llabs, "__builtin_llabs");
function builtin_memcmp (a1 : access char; a2 : access char; a3 : size_t)
return signed_int;
pragma Import (Intrinsic, builtin_memcmp, "__builtin_memcmp");
function builtin_memset (a1 : access char; a2 : signed_int; a3 : size_t)
return char_ptr;
pragma Import (Intrinsic, builtin_memset, "__builtin_memset");
function builtin_memcpy_chk (a1 : access char; a2 : access constant char;
a3 : size_t; a4 : size_t) return char_ptr;
pragma Import (Intrinsic, builtin_memcpy_chk, "__builtin___memcpy_chk");
function builtin_memmove_chk (a1 : access char; a2 : access constant char;
a3 : size_t; a4 : size_t) return char_ptr;
pragma Import (Intrinsic, builtin_memmove_chk, "__builtin___memmove_chk");
function builtin_memset_chk (a1 : access char; a2 : signed_int;
a3 : size_t; a4 : size_t) return char_ptr;
pragma Import (Intrinsic, builtin_memset_chk, "__builtin___memset_chk");
function builtin_nanf (a1 : access constant char) return float;
pragma Import (Intrinsic, builtin_nanf, "__builtin_nanf");
function builtin_nan (a1 : access constant char) return double;
pragma Import (Intrinsic, builtin_nan, "__builtin_nan");
function builtin_nanl (a1 : access constant char) return long_double;
pragma Import (Intrinsic, builtin_nanl, "__builtin_nanl");
function builtin_return_address (a1 : unsigned_int) return char_ptr;
pragma Import (Intrinsic, builtin_return_address,
"__builtin_return_address");
function builtin_stpcpy_chk (a1 : access char; a2 : access constant char;
a3 : size_t) return char_ptr;
pragma Import (Intrinsic, builtin_stpcpy_chk, "__builtin___stpcpy_chk");
function builtin_stpncpy_chk (a1 : access char; a2 : access constant char;
a3 : size_t; a4 : size_t) return char_ptr;
pragma Import (Intrinsic, builtin_stpncpy_chk, "__builtin___stpncpy_chk");
function builtin_strcat_chk (a1 : access char; a2 : access constant char;
a3 : size_t) return char_ptr;
pragma Import (Intrinsic, builtin_strcat_chk, "__builtin___strcat_chk");
function builtin_strcpy_chk (a1 : access char; a2 : access constant char;
a3 : size_t) return char_ptr;
pragma Import (Intrinsic, builtin_strcpy_chk, "__builtin___strcpy_chk");
function builtin_strncat_chk (a1 : access char; a2 : access constant char;
a3 : size_t; a4 : size_t) return char_ptr;
pragma Import (Intrinsic, builtin_strncat_chk, "__builtin___strncat_chk");
function builtin_strncpy_chk (a1 : access char; a2 : access constant char;
a3 : size_t; a4 : size_t) return char_ptr;
pragma Import (Intrinsic, builtin_strncpy_chk, "__builtin___strncpy_chk");
end C;
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment