Skip to content

Instantly share code, notes, and snippets.

@ytomino

ytomino/c-alloca.ads

Last active June 10, 2021 15:27
Show Gist options
  • Save ytomino/583029fe302b5f19d2a6585dbec61a05 to your computer and use it in GitHub Desktop.
Save ytomino/583029fe302b5f19d2a6585dbec61a05 to your computer and use it in GitHub Desktop.
Download ZIP
libyaml in x86_64-linux-gnu
Raw
c-alloca.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.alloca is
pragma Preelaborate;
function alloca (size : stddef.size_t) return void_ptr;
pragma Import (C, alloca, "alloca");
ALLOCA_H : constant := 1;
end C.alloca;
Raw
c-bits-byteswap.adb
-- 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 body C.bits.byteswap is
function bswap_32 (bsx : unsigned_int) return unsigned_int is
begin
return builtin_bswap32 (bsx);
end bswap_32;
function bswap_64 (bsx : types.uint64_t) return types.uint64_t is
begin
return types.uint64_t (builtin_bswap64 (unsigned_long_long (bsx)));
end bswap_64;
end C.bits.byteswap;
Raw
c-bits-byteswap.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.types;
package C.bits.byteswap is
pragma Preelaborate;
function bswap_32 (bsx : unsigned_int) return unsigned_int;
pragma Convention (C, bswap_32);
pragma Inline (bswap_32);
function bswap_64 (bsx : types.uint64_t) return types.uint64_t;
pragma Convention (C, bswap_64);
pragma Inline (bswap_64);
BITS_BYTESWAP_H : constant := 1;
-- __bswap_constant_16 (function macro)
-- __bswap_constant_32 (function macro)
-- __bswap_constant_64 (function macro)
end C.bits.byteswap;
Raw
c-bits-byteswap_16.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.byteswap_16 is
pragma Preelaborate;
-- __bswap_16 (function macro)
end C.bits.byteswap_16;
Raw
c-bits-endian.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.endian is
pragma Preelaborate;
BYTE_ORDER : constant := 1234;
end C.bits.endian;
Raw
c-bits-pthreadtypes.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.pthreadtypes is
pragma Preelaborate;
subtype pthread_t is unsigned_long;
type union_pthread_attr_t;
type union_pthread_attr_t (Unchecked_Tag : unsigned_int := 0) is record
case Unchecked_Tag is
when 0 =>
size : char_array (0 .. 55);
when others =>
align : signed_long;
end case;
end record;
pragma Unchecked_Union (union_pthread_attr_t);
pragma Convention (C_Pass_By_Copy, union_pthread_attr_t);
subtype pthread_attr_t is union_pthread_attr_t;
type struct_pthread_internal_list;
type struct_pthread_internal_list_ptr is
access all struct_pthread_internal_list;
for struct_pthread_internal_list_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_pthread_internal_list_ptr);
pragma Convention (C, struct_pthread_internal_list_ptr);
type struct_pthread_internal_list is record
prev : aliased struct_pthread_internal_list_ptr;
next : aliased struct_pthread_internal_list_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_pthread_internal_list);
subtype pthread_list_t is struct_pthread_internal_list;
type struct_pthread_mutex_s;
type struct_pthread_mutex_s is record
lock : aliased signed_int;
count : aliased unsigned_int;
owner : aliased signed_int;
nusers : aliased unsigned_int;
kind : aliased signed_int;
spins : aliased signed_short;
elision : aliased signed_short;
list : aliased pthread_list_t;
end record;
pragma Convention (C_Pass_By_Copy, struct_pthread_mutex_s);
type union_d6251af3 (Unchecked_Tag : unsigned_int := 0) is record
case Unchecked_Tag is
when 0 =>
data : struct_pthread_mutex_s;
when 1 =>
size : char_array (0 .. 39);
when others =>
align : signed_long;
end case;
end record;
pragma Unchecked_Union (union_d6251af3);
pragma Convention (C_Pass_By_Copy, union_d6251af3);
subtype pthread_mutex_t is union_d6251af3;
type union_43f49c0e (Unchecked_Tag : unsigned_int := 0) is record
case Unchecked_Tag is
when 0 =>
size : char_array (0 .. 3);
when others =>
align : signed_int;
end case;
end record;
pragma Unchecked_Union (union_43f49c0e);
pragma Convention (C_Pass_By_Copy, union_43f49c0e);
subtype pthread_mutexattr_t is union_43f49c0e;
type struct_d1b5ad24 is record
lock : aliased signed_int;
futex : aliased unsigned_int;
total_seq : aliased unsigned_long_long;
wakeup_seq : aliased unsigned_long_long;
woken_seq : aliased unsigned_long_long;
mutex : aliased void_ptr;
nwaiters : aliased unsigned_int;
broadcast_seq : aliased unsigned_int;
end record;
pragma Convention (C_Pass_By_Copy, struct_d1b5ad24);
type union_5ebf2c7c (Unchecked_Tag : unsigned_int := 0) is record
case Unchecked_Tag is
when 0 =>
data : struct_d1b5ad24;
when 1 =>
size : char_array (0 .. 47);
when others =>
align : signed_long_long;
end case;
end record;
pragma Unchecked_Union (union_5ebf2c7c);
pragma Convention (C_Pass_By_Copy, union_5ebf2c7c);
subtype pthread_cond_t is union_5ebf2c7c;
type union_cbbe6c38 (Unchecked_Tag : unsigned_int := 0) is record
case Unchecked_Tag is
when 0 =>
size : char_array (0 .. 3);
when others =>
align : signed_int;
end case;
end record;
pragma Unchecked_Union (union_cbbe6c38);
pragma Convention (C_Pass_By_Copy, union_cbbe6c38);
subtype pthread_condattr_t is union_cbbe6c38;
subtype pthread_key_t is unsigned_int;
subtype pthread_once_t is signed_int;
type struct_10e47c77 is record
lock : aliased signed_int;
nr_readers : aliased unsigned_int;
readers_wakeup : aliased unsigned_int;
writer_wakeup : aliased unsigned_int;
nr_readers_queued : aliased unsigned_int;
nr_writers_queued : aliased unsigned_int;
writer : aliased signed_int;
shared : aliased signed_int;
rwelision : aliased signed_char;
pad1 : aliased unsigned_char_array (0 .. 6);
pad2 : aliased unsigned_long;
flags : aliased unsigned_int;
end record;
pragma Convention (C_Pass_By_Copy, struct_10e47c77);
type union_8ca156a2 (Unchecked_Tag : unsigned_int := 0) is record
case Unchecked_Tag is
when 0 =>
data : struct_10e47c77;
when 1 =>
size : char_array (0 .. 55);
when others =>
align : signed_long;
end case;
end record;
pragma Unchecked_Union (union_8ca156a2);
pragma Convention (C_Pass_By_Copy, union_8ca156a2);
subtype pthread_rwlock_t is union_8ca156a2;
type union_bb6f579a (Unchecked_Tag : unsigned_int := 0) is record
case Unchecked_Tag is
when 0 =>
size : char_array (0 .. 7);
when others =>
align : signed_long;
end case;
end record;
pragma Unchecked_Union (union_bb6f579a);
pragma Convention (C_Pass_By_Copy, union_bb6f579a);
subtype pthread_rwlockattr_t is union_bb6f579a;
subtype pthread_spinlock_t is signed_int_volatile;
type union_f4be611a (Unchecked_Tag : unsigned_int := 0) is record
case Unchecked_Tag is
when 0 =>
size : char_array (0 .. 31);
when others =>
align : signed_long;
end case;
end record;
pragma Unchecked_Union (union_f4be611a);
pragma Convention (C_Pass_By_Copy, union_f4be611a);
subtype pthread_barrier_t is union_f4be611a;
type union_770e9778 (Unchecked_Tag : unsigned_int := 0) is record
case Unchecked_Tag is
when 0 =>
size : char_array (0 .. 3);
when others =>
align : signed_int;
end case;
end record;
pragma Unchecked_Union (union_770e9778);
pragma Convention (C_Pass_By_Copy, union_770e9778);
subtype pthread_barrierattr_t is union_770e9778;
BITS_PTHREADTYPES_H : constant := 1;
PTHREAD_MUTEX_HAVE_PREV : constant := 1;
-- __PTHREAD_RWLOCK_ELISION_EXTRA (unparsible)
PTHREAD_RWLOCK_INT_FLAGS_SHARED : constant := 1;
-- __PTHREAD_SPINS (unparsible)
SIZEOF_PTHREAD_ATTR_T : constant := 56;
SIZEOF_PTHREAD_BARRIERATTR_T : constant := 4;
SIZEOF_PTHREAD_BARRIER_T : constant := 32;
SIZEOF_PTHREAD_CONDATTR_T : constant := 4;
SIZEOF_PTHREAD_COND_T : constant := 48;
SIZEOF_PTHREAD_MUTEXATTR_T : constant := 4;
SIZEOF_PTHREAD_MUTEX_T : constant := 40;
SIZEOF_PTHREAD_RWLOCKATTR_T : constant := 8;
SIZEOF_PTHREAD_RWLOCK_T : constant := 56;
have_pthread_attr_t : constant := 1;
end C.bits.pthreadtypes;
Raw
c-bits-select_h.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.select_h is
pragma Preelaborate;
-- __FD_CLR (uninterpretable)
-- __FD_ISSET (uninterpretable)
-- __FD_SET (uninterpretable)
-- __FD_ZERO (uninterpretable)
FD_ZERO_STOS : constant char_array (0 .. 5) := "stosq" & char'Val (0);
end C.bits.select_h;
Raw
c-bits-sigset.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.sigset is
pragma Preelaborate;
subtype sig_atomic_t is signed_int;
type struct_22570f8b is record
val : aliased unsigned_long_array (0 .. 15);
end record;
pragma Convention (C_Pass_By_Copy, struct_22570f8b);
type struct_22570f8b_const_ptr is access constant struct_22570f8b;
for struct_22570f8b_const_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_22570f8b_const_ptr);
pragma Convention (C, struct_22570f8b_const_ptr);
subtype sigset_t is struct_22570f8b;
subtype sigset_t_const_ptr is struct_22570f8b_const_ptr;
SIGSET_H_types : constant := 1;
SIGSET_NWORDS : constant := 16;
end C.bits.sigset;
Raw
c-bits-stdio_lim.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.stdio_lim is
pragma Preelaborate;
FILENAME_MAX : constant := 4096;
FOPEN_MAX : constant := 16;
L_ctermid : constant := 9;
L_tmpnam : constant := 20;
TMP_MAX : constant := 238328;
end C.bits.stdio_lim;
Raw
c-bits-sys_errlist.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.sys_errlist is
pragma Preelaborate;
sys_nerr : aliased signed_int;
pragma Import (C, sys_nerr, "sys_nerr");
sys_errlist : aliased char_const_ptr_array (0 .. 0);
pragma Import (C, sys_errlist, "sys_errlist");
end C.bits.sys_errlist;
Raw
c-bits-time.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.types;
package C.bits.time is
pragma Preelaborate;
type struct_timeval;
type struct_timeval is record
tv_sec : aliased types.qqtime_t;
tv_usec : aliased types.suseconds_t;
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);
qSTRUCT_TIMEVAL : constant := 1;
end C.bits.time;
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 off64_t_ptr is signed_long_ptr;
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-waitflags.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.waitflags is
pragma Preelaborate;
type enum_fc8537be is (P_ALL, P_PID, P_PGID);
for enum_fc8537be use (P_ALL => 0, P_PID => 1, P_PGID => 2);
pragma Convention (C, enum_fc8537be);
subtype idtype_t is enum_fc8537be;
WCONTINUED : constant := 8;
WEXITED : constant := 4;
WNOHANG : constant := 1;
WNOWAIT : constant := 16777216;
WSTOPPED : constant := 2;
WUNTRACED : constant := 2;
ENUM_IDTYPE_T : constant := 1;
WALL : constant := 1073741824;
WCLONE : constant := -2147483648;
WNOTHREAD : constant := 536870912;
end C.bits.waitflags;
Raw
c-bits-waitstatus.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.waitstatus is
pragma Preelaborate;
-- __WCOREDUMP (function macro)
WCOREFLAG : constant := 128;
-- __WEXITSTATUS (function macro)
-- __WIFCONTINUED (function macro)
-- __WIFEXITED (function macro)
-- __WIFSIGNALED (function macro)
-- __WIFSTOPPED (function macro)
-- __WSTOPSIG (function macro)
-- __WTERMSIG (function macro)
W_CONTINUED : constant := 65535;
-- __W_EXITCODE (function macro)
-- __W_STOPCODE (function macro)
end C.bits.waitstatus;
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-endian.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.endian is
pragma Preelaborate;
BIG_ENDIAN : constant := 4321;
BYTE_ORDER : constant := 1234;
LITTLE_ENDIAN : constant := 1234;
PDP_ENDIAN : constant := 3412;
ENDIAN_H : constant := 1;
qqBIG_ENDIAN : constant := 4321;
FLOAT_WORD_ORDER : constant := 1234;
qqLITTLE_ENDIAN : constant := 1234;
-- __LONG_LONG_PAIR (function macro)
qqPDP_ENDIAN : constant := 3412;
-- be16toh (function macro)
-- be32toh (function macro)
-- be64toh (function macro)
-- htobe16 (function macro)
-- htobe32 (function macro)
-- htobe64 (function macro)
-- htole16 (function macro)
-- htole32 (function macro)
-- htole64 (function macro)
-- le16toh (function macro)
-- le32toh (function macro)
-- le64toh (function macro)
end C.endian;
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-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-libio.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.types;
with C.qG_config;
with C.stdarg;
with C.stddef;
package C.libio is
pragma Preelaborate;
type struct_IO_jump_t (<>) is limited private;
type struct_IO_FILE;
type struct_IO_FILE_ptr is access all struct_IO_FILE;
for struct_IO_FILE_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_IO_FILE_ptr);
pragma Convention (C, struct_IO_FILE_ptr);
-- subtype _IO_lock_t is void (typedef)
subtype IO_lock_t_ptr is void_ptr;
type struct_IO_marker;
type struct_IO_marker_ptr is access all struct_IO_marker;
for struct_IO_marker_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_IO_marker_ptr);
pragma Convention (C, struct_IO_marker_ptr);
type struct_IO_marker is record
next : aliased struct_IO_marker_ptr;
sbuf : aliased struct_IO_FILE_ptr;
pos : aliased signed_int;
end record;
pragma Convention (C_Pass_By_Copy, struct_IO_marker);
type enum_codecvt_result;
type enum_codecvt_result is (codecvt_ok, codecvt_partial, codecvt_error,
codecvt_noconv);
for enum_codecvt_result use (codecvt_ok => 0, codecvt_partial => 1,
codecvt_error => 2, codecvt_noconv => 3);
pragma Convention (C, enum_codecvt_result);
type struct_IO_FILE is record
flags : aliased signed_int;
IO_read_ptr : aliased char_ptr;
IO_read_end : aliased char_ptr;
IO_read_base : aliased char_ptr;
IO_write_base : aliased char_ptr;
IO_write_ptr : aliased char_ptr;
IO_write_end : aliased char_ptr;
IO_buf_base : aliased char_ptr;
IO_buf_end : aliased char_ptr;
IO_save_base : aliased char_ptr;
IO_backup_base : aliased char_ptr;
IO_save_end : aliased char_ptr;
markers : aliased struct_IO_marker_ptr;
chain : aliased struct_IO_FILE_ptr;
fileno : aliased signed_int;
flags2 : aliased signed_int;
old_offset : aliased bits.types.off_t;
cur_column : aliased unsigned_short;
vtable_offset : aliased signed_char;
shortbuf : aliased char_array (0 .. 0);
lock : aliased IO_lock_t_ptr;
offset : aliased bits.types.off64_t;
pad1 : aliased void_ptr;
pad2 : aliased void_ptr;
pad3 : aliased void_ptr;
pad4 : aliased void_ptr;
pad5 : aliased stddef.size_t;
mode : aliased signed_int;
unused2 : aliased char_array (0 .. 19);
end record;
pragma Convention (C_Pass_By_Copy, struct_IO_FILE);
subtype IO_FILE is struct_IO_FILE;
subtype IO_FILE_ptr is struct_IO_FILE_ptr;
type struct_IO_FILE_plus (<>) is limited private;
-- extern _IO_2_1_stdin_ (opaque type)
-- extern _IO_2_1_stdout_ (opaque type)
-- extern _IO_2_1_stderr_ (opaque type)
-- subtype __io_read_fn is ... (function type)
-- subtype __io_write_fn is ... (function type)
-- subtype __io_seek_fn is ... (function type)
-- subtype __io_close_fn is ... (function type)
function underflow (a1 : access IO_FILE) return signed_int;
pragma Import (C, underflow, "__underflow");
function uflow (a1 : access IO_FILE) return signed_int;
pragma Import (C, uflow, "__uflow");
function overflow (a1 : access IO_FILE; a2 : signed_int)
return signed_int;
pragma Import (C, overflow, "__overflow");
function IO_getc (fp : access IO_FILE) return signed_int;
pragma Import (C, IO_getc, "_IO_getc");
function IO_putc (c : signed_int; fp : access IO_FILE) return signed_int;
pragma Import (C, IO_putc, "_IO_putc");
function IO_feof (fp : access IO_FILE) return signed_int;
pragma Import (C, IO_feof, "_IO_feof");
function IO_ferror (fp : access IO_FILE) return signed_int;
pragma Import (C, IO_ferror, "_IO_ferror");
function IO_peekc_locked (fp : access IO_FILE) return signed_int;
pragma Import (C, IO_peekc_locked, "_IO_peekc_locked");
procedure qIO_flockfile (a1 : access IO_FILE);
pragma Import (C, qIO_flockfile, "_IO_flockfile");
procedure qIO_funlockfile (a1 : access IO_FILE);
pragma Import (C, qIO_funlockfile, "_IO_funlockfile");
function qIO_ftrylockfile (a1 : access IO_FILE) return signed_int;
pragma Import (C, qIO_ftrylockfile, "_IO_ftrylockfile");
function IO_vfscanf (a1 : access IO_FILE; a2 : access constant char;
a3 : stdarg.qqgnuc_va_list; a4 : access signed_int) return signed_int;
pragma Import (C, IO_vfscanf, "_IO_vfscanf");
function IO_vfprintf (a1 : access IO_FILE; a2 : access constant char;
a3 : stdarg.qqgnuc_va_list) return signed_int;
pragma Import (C, IO_vfprintf, "_IO_vfprintf");
function IO_padn (a1 : access IO_FILE; a2 : signed_int;
a3 : bits.types.ssize_t) return bits.types.ssize_t;
pragma Import (C, IO_padn, "_IO_padn");
function IO_sgetn (a1 : access IO_FILE; a2 : void_ptr; a3 : stddef.size_t)
return stddef.size_t;
pragma Import (C, IO_sgetn, "_IO_sgetn");
function IO_seekoff (a1 : access IO_FILE; a2 : bits.types.off64_t;
a3 : signed_int; a4 : signed_int) return bits.types.off64_t;
pragma Import (C, IO_seekoff, "_IO_seekoff");
function IO_seekpos (a1 : access IO_FILE; a2 : bits.types.off64_t;
a3 : signed_int) return bits.types.off64_t;
pragma Import (C, IO_seekpos, "_IO_seekpos");
procedure IO_free_backup_area (a1 : access IO_FILE);
pragma Import (C, IO_free_backup_area, "_IO_free_backup_area");
EOF : constant := -1;
IOS_APPEND : constant := 8;
IOS_ATEND : constant := 4;
IOS_BIN : constant := 128;
IOS_INPUT : constant := 1;
IOS_NOCREATE : constant := 32;
IOS_NOREPLACE : constant := 64;
IOS_OUTPUT : constant := 2;
IOS_TRUNC : constant := 16;
IO_BAD_SEEN : constant := 16384;
-- _IO_BE (function macro)
IO_BOOLALPHA : constant := 65536;
IO_BUFSIZ : constant := 8192;
IO_CURRENTLY_PUTTING : constant := 2048;
IO_DEC : constant := 16;
IO_DELETE_DONT_CLOSE : constant := 64;
IO_DONT_CLOSE : constant := 32768;
IO_EOF_SEEN : constant := 16;
IO_ERR_SEEN : constant := 32;
IO_FIXED : constant := 4096;
IO_FLAGS2_MMAP : constant := 1;
IO_FLAGS2_NOTCANCEL : constant := 2;
IO_FLAGS2_USER_WBUF : constant := 8;
-- _IO_HAVE_ST_BLKSIZE (unparsible)
IO_HEX : constant := 64;
IO_INTERNAL : constant := 8;
IO_IN_BACKUP : constant := 256;
IO_IS_APPENDING : constant := 4096;
IO_IS_FILEBUF : constant := 8192;
IO_LEFT : constant := 2;
IO_LINE_BUF : constant := 512;
IO_LINKED : constant := 128;
IO_MAGIC : constant := -72548352;
IO_MAGIC_MASK : constant := -65536;
IO_NO_READS : constant := 4;
IO_NO_WRITES : constant := 8;
IO_OCT : constant := 32;
-- _IO_PENDING_OUTPUT_COUNT (uninterpretable)
IO_RIGHT : constant := 4;
IO_SCIENTIFIC : constant := 2048;
IO_SHOWBASE : constant := 128;
IO_SHOWPOINT : constant := 256;
IO_SHOWPOS : constant := 1024;
IO_SKIPWS : constant := 1;
IO_STDIO : constant := 16384;
-- _IO_STDIO_H (empty)
IO_TIED_PUT_GET : constant := 1024;
IO_UNBUFFERED : constant := 2;
IO_UNIFIED_JUMPTABLES : constant := 1;
IO_UNITBUF : constant := 8192;
IO_UPPERCASE : constant := 512;
IO_USER_BUF : constant := 1;
IO_USER_LOCK : constant := 32768;
-- _IO_cleanup_region_end (empty)
-- _IO_cleanup_region_start (empty)
-- _IO_feof_unlocked (uninterpretable)
-- _IO_ferror_unlocked (uninterpretable)
-- ._IO_file_flags renames ._flags (accessor)
-- _IO_flockfile (empty)
subtype IO_fpos64_t is qG_config.G_fpos64_t;
subtype IO_fpos_t is qG_config.G_fpos_t;
-- _IO_ftrylockfile (empty)
-- _IO_funlockfile (empty)
-- _IO_getc_unlocked (uninterpretable)
-- _IO_iconv_t (unparsible)
subtype IO_off64_t is bits.types.off64_t;
subtype IO_off_t is bits.types.off_t;
-- _IO_peekc (uninterpretable)
-- _IO_peekc_unlocked (uninterpretable)
subtype IO_pid_t is bits.types.pid_t;
-- _IO_putc_unlocked (uninterpretable)
subtype IO_size_t is stddef.size_t;
subtype IO_ssize_t is bits.types.ssize_t;
-- _IO_stderr (unparsible)
-- _IO_stdin (unparsible)
-- _IO_stdout (unparsible)
subtype IO_uid_t is bits.types.uid_t;
subtype IO_va_list is stdarg.qqgnuc_va_list;
-- _IO_wint_t (unparsible)
OLD_STDIO_MAGIC : constant := -88342528;
-- __HAVE_COLUMN (empty)
private
type struct_IO_jump_t is null record;
type struct_IO_FILE_plus is null record;
end C.libio;
Raw
c-qg_config.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.types;
with C.stdarg;
with C.wchar;
package C.qG_config is
pragma Preelaborate;
type struct_db248717 is record
pos : aliased bits.types.off_t;
state : aliased wchar.mbstate_t;
end record;
pragma Convention (C_Pass_By_Copy, struct_db248717);
type struct_db248717_ptr is access all struct_db248717;
for struct_db248717_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_db248717_ptr);
pragma Convention (C, struct_db248717_ptr);
type struct_db248717_const_ptr is access constant struct_db248717;
for struct_db248717_const_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_db248717_const_ptr);
pragma Convention (C, struct_db248717_const_ptr);
subtype G_fpos_t is struct_db248717;
subtype G_fpos_t_ptr is struct_db248717_ptr;
subtype G_fpos_t_const_ptr is struct_db248717_const_ptr;
type struct_eb9588dd is record
pos : aliased bits.types.off64_t;
state : aliased wchar.mbstate_t;
end record;
pragma Convention (C_Pass_By_Copy, struct_eb9588dd);
subtype G_fpos64_t is struct_eb9588dd;
G_BUFSIZ : constant := 8192;
G_HAVE_MMAP : constant := 1;
G_HAVE_MREMAP : constant := 1;
-- _G_HAVE_ST_BLKSIZE (unparsible)
G_IO_IO_FILE_VERSION : constant := 131073;
G_config_h : constant := 1;
subtype G_va_list is stdarg.qqgnuc_va_list;
end C.qG_config;
Raw
c-stdarg.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.stdarg is
pragma Preelaborate;
subtype qqgnuc_va_list is builtin_va_list;
-- __GNUC_VA_LIST (empty)
end C.stdarg;
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 size_t is Standard.C.size_t;
subtype size_t_ptr is Standard.C.size_t_ptr;
-- #include <wchar.h>
-- #include <_G_config.h>
-- #include <stdarg.h>
-- #include <libio.h>
subtype wchar_t is Standard.C.wchar_t;
subtype wchar_t_ptr is Standard.C.wchar_t_ptr;
subtype wchar_t_const_ptr is Standard.C.wchar_t_const_ptr;
C_NULL : constant void_ptr := void_ptr (System'To_Address (0));
-- _BSD_SIZE_T_ (empty)
-- _BSD_SIZE_T_DEFINED_ (empty)
-- _GCC_SIZE_T (empty)
-- _GCC_WCHAR_T (empty)
-- _SIZET_ (empty)
-- _SIZE_T (empty)
-- _SIZE_T_ (empty)
-- _SIZE_T_DECLARED (empty)
-- _SIZE_T_DEFINED (empty)
-- _SIZE_T_DEFINED_ (empty)
-- _SYS_SIZE_T_H (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)
-- __SIZE_T (empty)
-- __SIZE_T__ (empty)
-- __WCHAR_T (empty)
-- __WCHAR_T__ (empty)
-- ___int_size_t_h (empty)
-- ___int_wchar_t_h (empty)
-- __size_t (empty)
-- __size_t__ (empty)
-- __wchar_t__ (empty)
end C.stddef;
Raw
c-stdio.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.types;
with C.libio;
with C.qG_config;
with C.stdarg;
with C.stddef;
package C.stdio is
pragma Preelaborate;
subtype FILE is libio.struct_IO_FILE;
subtype FILE_ptr is libio.struct_IO_FILE_ptr;
subtype qqFILE is libio.struct_IO_FILE;
subtype va_list is stdarg.qqgnuc_va_list;
subtype fpos_t is qG_config.G_fpos_t;
subtype fpos_t_ptr is qG_config.G_fpos_t_ptr;
subtype fpos_t_const_ptr is qG_config.G_fpos_t_const_ptr;
stdin : aliased libio.struct_IO_FILE_ptr;
pragma Import (C, stdin, "stdin");
stdout : aliased libio.struct_IO_FILE_ptr;
pragma Import (C, stdout, "stdout");
stderr : aliased libio.struct_IO_FILE_ptr;
pragma Import (C, stderr, "stderr");
function remove (filename : access constant char) return signed_int;
pragma Import (C, remove, "remove");
function rename (old : access constant char; A_new : access constant char)
return signed_int;
pragma Import (C, rename, "rename");
function renameat (oldfd : signed_int; old : access constant char;
newfd : signed_int; A_new : access constant char) return signed_int;
pragma Import (C, renameat, "renameat");
function tmpfile return FILE_ptr;
pragma Import (C, tmpfile, "tmpfile");
function tmpnam (s : access char) return char_ptr;
pragma Import (C, tmpnam, "tmpnam");
function tmpnam_r (s : access char) return char_ptr;
pragma Import (C, tmpnam_r, "tmpnam_r");
function tempnam (dir : access constant char; pfx : access constant char)
return char_ptr;
pragma Import (C, tempnam, "tempnam");
function fclose (stream : access FILE) return signed_int;
pragma Import (C, fclose, "fclose");
function fflush (stream : access FILE) return signed_int;
pragma Import (C, fflush, "fflush");
function fflush_unlocked (stream : access FILE) return signed_int;
pragma Import (C, fflush_unlocked, "fflush_unlocked");
function fopen (filename : access constant char;
modes : access constant char) return FILE_ptr;
pragma Import (C, fopen, "fopen");
function freopen (filename : access constant char;
modes : access constant char; stream : access FILE) return FILE_ptr;
pragma Import (C, freopen, "freopen");
function fdopen (fd : signed_int; modes : access constant char)
return FILE_ptr;
pragma Import (C, fdopen, "fdopen");
function fmemopen (s : void_ptr; len : stddef.size_t;
modes : access constant char) return FILE_ptr;
pragma Import (C, fmemopen, "fmemopen");
function open_memstream (bufloc : access char_ptr;
sizeloc : access stddef.size_t) return FILE_ptr;
pragma Import (C, open_memstream, "open_memstream");
procedure setbuf (stream : access FILE; buf : access char);
pragma Import (C, setbuf, "setbuf");
function setvbuf (stream : access FILE; buf : access char;
modes : signed_int; n : stddef.size_t) return signed_int;
pragma Import (C, setvbuf, "setvbuf");
procedure setbuffer (stream : access FILE; buf : access char;
size : stddef.size_t);
pragma Import (C, setbuffer, "setbuffer");
procedure setlinebuf (stream : access FILE);
pragma Import (C, setlinebuf, "setlinebuf");
function fprintf (stream : access FILE; format : access constant char)
return signed_int;
pragma Import (C, fprintf, "fprintf");
function printf (format : access constant char) return signed_int;
pragma Import (C, printf, "printf");
function sprintf (s : access char; format : access constant char)
return signed_int;
pragma Import (C, sprintf, "sprintf");
function vfprintf (s : access FILE; format : access constant char;
arg : stdarg.qqgnuc_va_list) return signed_int;
pragma Import (C, vfprintf, "vfprintf");
function vprintf (format : access constant char;
arg : stdarg.qqgnuc_va_list) return signed_int;
pragma Import (C, vprintf, "vprintf");
function vsprintf (s : access char; format : access constant char;
arg : stdarg.qqgnuc_va_list) return signed_int;
pragma Import (C, vsprintf, "vsprintf");
function snprintf (s : access char; maxlen : stddef.size_t;
format : access constant char) return signed_int;
pragma Import (C, snprintf, "snprintf");
function vsnprintf (s : access char; maxlen : stddef.size_t;
format : access constant char; arg : stdarg.qqgnuc_va_list)
return signed_int;
pragma Import (C, vsnprintf, "vsnprintf");
function vdprintf (fd : signed_int; fmt : access constant char;
arg : stdarg.qqgnuc_va_list) return signed_int;
pragma Import (C, vdprintf, "vdprintf");
function dprintf (fd : signed_int; fmt : access constant char)
return signed_int;
pragma Import (C, dprintf, "dprintf");
function fscanf (stream : access FILE; format : access constant char)
return signed_int;
pragma Import (C, fscanf, "_isoc99_fscanf");
function scanf (format : access constant char) return signed_int;
pragma Import (C, scanf, "_isoc99_scanf");
function sscanf (s : access constant char; format : access constant char)
return signed_int;
pragma Import (C, sscanf, "_isoc99_sscanf");
function vfscanf (s : access FILE; format : access constant char;
arg : stdarg.qqgnuc_va_list) return signed_int;
pragma Import (C, vfscanf, "_isoc99_vfscanf");
function vscanf (format : access constant char;
arg : stdarg.qqgnuc_va_list) return signed_int;
pragma Import (C, vscanf, "_isoc99_vscanf");
function vsscanf (s : access constant char; format : access constant char;
arg : stdarg.qqgnuc_va_list) return signed_int;
pragma Import (C, vsscanf, "_isoc99_vsscanf");
function fgetc (stream : access FILE) return signed_int;
pragma Import (C, fgetc, "fgetc");
function getc (stream : access FILE) return signed_int;
pragma Import (C, getc, "getc");
function getchar return signed_int;
pragma Import (C, getchar, "getchar");
function getc_unlocked (stream : access FILE) return signed_int;
pragma Import (C, getc_unlocked, "getc_unlocked");
function getchar_unlocked return signed_int;
pragma Import (C, getchar_unlocked, "getchar_unlocked");
function fgetc_unlocked (stream : access FILE) return signed_int;
pragma Import (C, fgetc_unlocked, "fgetc_unlocked");
function fputc (c : signed_int; stream : access FILE) return signed_int;
pragma Import (C, fputc, "fputc");
function putc (c : signed_int; stream : access FILE) return signed_int;
pragma Import (C, putc, "putc");
function putchar (c : signed_int) return signed_int;
pragma Import (C, putchar, "putchar");
function fputc_unlocked (c : signed_int; stream : access FILE)
return signed_int;
pragma Import (C, fputc_unlocked, "fputc_unlocked");
function putc_unlocked (c : signed_int; stream : access FILE)
return signed_int;
pragma Import (C, putc_unlocked, "putc_unlocked");
function putchar_unlocked (c : signed_int) return signed_int;
pragma Import (C, putchar_unlocked, "putchar_unlocked");
function getw (stream : access FILE) return signed_int;
pragma Import (C, getw, "getw");
function putw (w : signed_int; stream : access FILE) return signed_int;
pragma Import (C, putw, "putw");
function fgets (s : access char; n : signed_int; stream : access FILE)
return char_ptr;
pragma Import (C, fgets, "fgets");
function gets (s : access char) return char_ptr;
pragma Import (C, gets, "gets");
function qqgetdelim (lineptr : access char_ptr; n : access stddef.size_t;
delimiter : signed_int; stream : access FILE)
return bits.types.ssize_t;
pragma Import (C, qqgetdelim, "__getdelim");
function getdelim (lineptr : access char_ptr; n : access stddef.size_t;
delimiter : signed_int; stream : access FILE)
return bits.types.ssize_t;
pragma Import (C, getdelim, "getdelim");
function getline (lineptr : access char_ptr; n : access stddef.size_t;
stream : access FILE) return bits.types.ssize_t;
pragma Import (C, getline, "getline");
function fputs (s : access constant char; stream : access FILE)
return signed_int;
pragma Import (C, fputs, "fputs");
function puts (s : access constant char) return signed_int;
pragma Import (C, puts, "puts");
function ungetc (c : signed_int; stream : access FILE) return signed_int;
pragma Import (C, ungetc, "ungetc");
function fread (ptr : void_ptr; size : stddef.size_t; n : stddef.size_t;
stream : access FILE) return stddef.size_t;
pragma Import (C, fread, "fread");
function fwrite (ptr : void_const_ptr; size : stddef.size_t;
n : stddef.size_t; s : access FILE) return stddef.size_t;
pragma Import (C, fwrite, "fwrite");
function fread_unlocked (ptr : void_ptr; size : stddef.size_t;
n : stddef.size_t; stream : access FILE) return stddef.size_t;
pragma Import (C, fread_unlocked, "fread_unlocked");
function fwrite_unlocked (ptr : void_const_ptr; size : stddef.size_t;
n : stddef.size_t; stream : access FILE) return stddef.size_t;
pragma Import (C, fwrite_unlocked, "fwrite_unlocked");
function fseek (stream : access FILE; off : signed_long;
whence : signed_int) return signed_int;
pragma Import (C, fseek, "fseek");
function ftell (stream : access FILE) return signed_long;
pragma Import (C, ftell, "ftell");
procedure rewind (stream : access FILE);
pragma Import (C, rewind, "rewind");
function fseeko (stream : access FILE; off : bits.types.off_t;
whence : signed_int) return signed_int;
pragma Import (C, fseeko, "fseeko");
function ftello (stream : access FILE) return bits.types.off_t;
pragma Import (C, ftello, "ftello");
function fgetpos (stream : access FILE; pos : access fpos_t)
return signed_int;
pragma Import (C, fgetpos, "fgetpos");
function fsetpos (stream : access FILE; pos : access constant fpos_t)
return signed_int;
pragma Import (C, fsetpos, "fsetpos");
procedure clearerr (stream : access FILE);
pragma Import (C, clearerr, "clearerr");
function feof (stream : access FILE) return signed_int;
pragma Import (C, feof, "feof");
function ferror (stream : access FILE) return signed_int;
pragma Import (C, ferror, "ferror");
procedure clearerr_unlocked (stream : access FILE);
pragma Import (C, clearerr_unlocked, "clearerr_unlocked");
function feof_unlocked (stream : access FILE) return signed_int;
pragma Import (C, feof_unlocked, "feof_unlocked");
function ferror_unlocked (stream : access FILE) return signed_int;
pragma Import (C, ferror_unlocked, "ferror_unlocked");
procedure perror (s : access constant char);
pragma Import (C, perror, "perror");
-- #include <bits/sys_errlist.h>
function fileno (stream : access FILE) return signed_int;
pragma Import (C, fileno, "fileno");
function fileno_unlocked (stream : access FILE) return signed_int;
pragma Import (C, fileno_unlocked, "fileno_unlocked");
function popen (command : access constant char;
modes : access constant char) return FILE_ptr;
pragma Import (C, popen, "popen");
function pclose (stream : access FILE) return signed_int;
pragma Import (C, pclose, "pclose");
function ctermid (s : access char) return char_ptr;
pragma Import (C, ctermid, "ctermid");
procedure flockfile (stream : access FILE);
pragma Import (C, flockfile, "flockfile");
function ftrylockfile (stream : access FILE) return signed_int;
pragma Import (C, ftrylockfile, "ftrylockfile");
procedure funlockfile (stream : access FILE);
pragma Import (C, funlockfile, "funlockfile");
BUFSIZ : constant := 8192;
P_tmpdir : constant char_array (0 .. 4) := "/tmp" & char'Val (0);
SEEK_CUR : constant := 1;
SEEK_END : constant := 2;
SEEK_SET : constant := 0;
IOFBF : constant := 0;
IOLBF : constant := 1;
IONBF : constant := 2;
STDIO_H : constant := 1;
-- _STDIO_USES_IOSTREAM (empty)
-- _VA_LIST_DEFINED (empty)
FILE_defined : constant := 1;
qqqqFILE_defined : constant := 1;
-- stderr (repeating itself)
-- stdin (repeating itself)
-- stdout (repeating itself)
end C.stdio;
Raw
c-stdlib.adb
-- 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 body C.stdlib is
function MB_CUR_MAX return stddef.size_t is
begin
return ctype_get_mb_cur_max;
end MB_CUR_MAX;
end C.stdlib;
Raw
c-stdlib.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;
with C.sys.types;
package C.stdlib is
pragma Preelaborate;
type struct_3210b632 is record
quot : aliased signed_int;
F_rem : aliased signed_int;
end record;
pragma Convention (C_Pass_By_Copy, struct_3210b632);
subtype div_t is struct_3210b632;
type struct_b762d41b is record
quot : aliased signed_long;
F_rem : aliased signed_long;
end record;
pragma Convention (C_Pass_By_Copy, struct_b762d41b);
subtype ldiv_t is struct_b762d41b;
type struct_b37d1920 is record
quot : aliased signed_long_long;
F_rem : aliased signed_long_long;
end record;
pragma Convention (C_Pass_By_Copy, struct_b37d1920);
subtype lldiv_t is struct_b37d1920;
function ctype_get_mb_cur_max return stddef.size_t;
pragma Import (C, ctype_get_mb_cur_max, "__ctype_get_mb_cur_max");
function atof (nptr : access constant char) return double;
pragma Import (C, atof, "atof");
function atoi (nptr : access constant char) return signed_int;
pragma Import (C, atoi, "atoi");
function atol (nptr : access constant char) return signed_long;
pragma Import (C, atol, "atol");
function atoll (nptr : access constant char) return signed_long_long;
pragma Import (C, atoll, "atoll");
function strtod (nptr : access constant char; endptr : access char_ptr)
return double;
pragma Import (C, strtod, "strtod");
function strtof (nptr : access constant char; endptr : access char_ptr)
return float;
pragma Import (C, strtof, "strtof");
function strtold (nptr : access constant char; endptr : access char_ptr)
return long_double;
pragma Import (C, strtold, "strtold");
function strtol (nptr : access constant char; endptr : access char_ptr;
base : signed_int) return signed_long;
pragma Import (C, strtol, "strtol");
function strtoul (nptr : access constant char; endptr : access char_ptr;
base : signed_int) return unsigned_long;
pragma Import (C, strtoul, "strtoul");
function strtoq (nptr : access constant char; endptr : access char_ptr;
base : signed_int) return signed_long_long;
pragma Import (C, strtoq, "strtoq");
function strtouq (nptr : access constant char; endptr : access char_ptr;
base : signed_int) return unsigned_long_long;
pragma Import (C, strtouq, "strtouq");
function strtoll (nptr : access constant char; endptr : access char_ptr;
base : signed_int) return signed_long_long;
pragma Import (C, strtoll, "strtoll");
function strtoull (nptr : access constant char; endptr : access char_ptr;
base : signed_int) return unsigned_long_long;
pragma Import (C, strtoull, "strtoull");
function l64a (n : signed_long) return char_ptr;
pragma Import (C, l64a, "l64a");
function a64l (s : access constant char) return signed_long;
pragma Import (C, a64l, "a64l");
-- #include <bits/byteswap.h>
-- #include <bits/sigset.h>
-- #include <time.h>
-- #include <bits/time.h>
-- #include <sys/select.h>
-- #include <sys/sysmacros.h>
-- #include <sys/types.h>
-- #include <bits/pthreadtypes.h>
function random return signed_long;
pragma Import (C, random, "random");
procedure srandom (seed : unsigned_int);
pragma Import (C, srandom, "srandom");
function initstate (seed : unsigned_int; statebuf : access char;
statelen : stddef.size_t) return char_ptr;
pragma Import (C, initstate, "initstate");
function setstate (statebuf : access char) return char_ptr;
pragma Import (C, setstate, "setstate");
type struct_random_data;
type struct_random_data is record
fptr : aliased sys.types.int32_t_ptr;
rptr : aliased sys.types.int32_t_ptr;
state : aliased sys.types.int32_t_ptr;
rand_type : aliased signed_int;
rand_deg : aliased signed_int;
rand_sep : aliased signed_int;
end_ptr : aliased sys.types.int32_t_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_random_data);
type struct_random_data_ptr is access all struct_random_data;
for struct_random_data_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_random_data_ptr);
pragma Convention (C, struct_random_data_ptr);
function random_r (buf : access struct_random_data;
result : access sys.types.int32_t) return signed_int;
pragma Import (C, random_r, "random_r");
function srandom_r (seed : unsigned_int; buf : access struct_random_data)
return signed_int;
pragma Import (C, srandom_r, "srandom_r");
function initstate_r (seed : unsigned_int; statebuf : access char;
statelen : stddef.size_t; buf : access struct_random_data)
return signed_int;
pragma Import (C, initstate_r, "initstate_r");
function setstate_r (statebuf : access char;
buf : access struct_random_data) return signed_int;
pragma Import (C, setstate_r, "setstate_r");
function rand return signed_int;
pragma Import (C, rand, "rand");
procedure srand (seed : unsigned_int);
pragma Import (C, srand, "srand");
function rand_r (seed : access unsigned_int) return signed_int;
pragma Import (C, rand_r, "rand_r");
function drand48 return double;
pragma Import (C, drand48, "drand48");
function erand48 (xsubi : access unsigned_short) return double;
pragma Import (C, erand48, "erand48");
function lrand48 return signed_long;
pragma Import (C, lrand48, "lrand48");
function nrand48 (xsubi : access unsigned_short) return signed_long;
pragma Import (C, nrand48, "nrand48");
function mrand48 return signed_long;
pragma Import (C, mrand48, "mrand48");
function jrand48 (xsubi : access unsigned_short) return signed_long;
pragma Import (C, jrand48, "jrand48");
procedure srand48 (seedval : signed_long);
pragma Import (C, srand48, "srand48");
function seed48 (seed16v : access unsigned_short)
return unsigned_short_ptr;
pragma Import (C, seed48, "seed48");
procedure lcong48 (param : access unsigned_short);
pragma Import (C, lcong48, "lcong48");
type struct_drand48_data;
type struct_drand48_data is record
x : aliased unsigned_short_array (0 .. 2);
old_x : aliased unsigned_short_array (0 .. 2);
c : aliased unsigned_short;
init : aliased unsigned_short;
a : aliased unsigned_long_long;
end record;
pragma Convention (C_Pass_By_Copy, struct_drand48_data);
type struct_drand48_data_ptr is access all struct_drand48_data;
for struct_drand48_data_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_drand48_data_ptr);
pragma Convention (C, struct_drand48_data_ptr);
function drand48_r (buffer : access struct_drand48_data;
result : access double) return signed_int;
pragma Import (C, drand48_r, "drand48_r");
function erand48_r (xsubi : access unsigned_short;
buffer : access struct_drand48_data; result : access double)
return signed_int;
pragma Import (C, erand48_r, "erand48_r");
function lrand48_r (buffer : access struct_drand48_data;
result : access signed_long) return signed_int;
pragma Import (C, lrand48_r, "lrand48_r");
function nrand48_r (xsubi : access unsigned_short;
buffer : access struct_drand48_data; result : access signed_long)
return signed_int;
pragma Import (C, nrand48_r, "nrand48_r");
function mrand48_r (buffer : access struct_drand48_data;
result : access signed_long) return signed_int;
pragma Import (C, mrand48_r, "mrand48_r");
function jrand48_r (xsubi : access unsigned_short;
buffer : access struct_drand48_data; result : access signed_long)
return signed_int;
pragma Import (C, jrand48_r, "jrand48_r");
function srand48_r (seedval : signed_long;
buffer : access struct_drand48_data) return signed_int;
pragma Import (C, srand48_r, "srand48_r");
function seed48_r (seed16v : access unsigned_short;
buffer : access struct_drand48_data) return signed_int;
pragma Import (C, seed48_r, "seed48_r");
function lcong48_r (param : access unsigned_short;
buffer : access struct_drand48_data) return signed_int;
pragma Import (C, lcong48_r, "lcong48_r");
function malloc (size : stddef.size_t) return void_ptr;
pragma Import (C, malloc, "malloc");
function calloc (nmemb : stddef.size_t; size : stddef.size_t)
return void_ptr;
pragma Import (C, calloc, "calloc");
function realloc (ptr : void_ptr; size : stddef.size_t) return void_ptr;
pragma Import (C, realloc, "realloc");
procedure free (ptr : void_ptr);
pragma Import (C, free, "free");
procedure cfree (ptr : void_ptr);
pragma Import (C, cfree, "cfree");
-- #include <alloca.h>
function valloc (size : stddef.size_t) return void_ptr;
pragma Import (C, valloc, "valloc");
function posix_memalign (memptr : access void_ptr;
alignment : stddef.size_t; size : stddef.size_t) return signed_int;
pragma Import (C, posix_memalign, "posix_memalign");
type access_e823f645 is access procedure;
pragma Convention (C, access_e823f645);
procedure C_abort;
pragma No_Return (C_abort);
pragma Import (C, C_abort, "abort");
function atexit (func : access_e823f645) return signed_int;
pragma Import (C, atexit, "atexit");
type access_e23946a4 is access procedure (status : signed_int;
arg : void_ptr);
pragma Convention (C, access_e23946a4);
function on_exit (func : access_e23946a4; arg : void_ptr)
return signed_int;
pragma Import (C, on_exit, "on_exit");
procedure C_exit (status : signed_int);
pragma No_Return (C_exit);
pragma Import (C, C_exit, "exit");
procedure C_qExit_U (status : signed_int);
pragma No_Return (C_qExit_U);
pragma Import (C, C_qExit_U, "_Exit");
function getenv (name : access constant char) return char_ptr;
pragma Import (C, getenv, "getenv");
function putenv (string : access char) return signed_int;
pragma Import (C, putenv, "putenv");
function setenv (name : access constant char;
value : access constant char; replace : signed_int) return signed_int;
pragma Import (C, setenv, "setenv");
function unsetenv (name : access constant char) return signed_int;
pragma Import (C, unsetenv, "unsetenv");
function clearenv return signed_int;
pragma Import (C, clearenv, "clearenv");
function mktemp (template : access char) return char_ptr;
pragma Import (C, mktemp, "mktemp");
function mkstemp (template : access char) return signed_int;
pragma Import (C, mkstemp, "mkstemp");
function mkstemps (template : access char; suffixlen : signed_int)
return signed_int;
pragma Import (C, mkstemps, "mkstemps");
function mkdtemp (template : access char) return char_ptr;
pragma Import (C, mkdtemp, "mkdtemp");
function C_system (command : access constant char) return signed_int;
pragma Import (C, C_system, "system");
function realpath (name : access constant char; resolved : access char)
return char_ptr;
pragma Import (C, realpath, "realpath");
type access_9017117e is access function (a1 : void_const_ptr;
a2 : void_const_ptr) return signed_int;
pragma Convention (C, access_9017117e);
subtype qqcompar_fn_t is access_9017117e;
function bsearch (key : void_const_ptr; base : void_const_ptr;
nmemb : stddef.size_t; size : stddef.size_t; compar : qqcompar_fn_t)
return void_ptr;
pragma Import (C, bsearch, "bsearch");
procedure qsort (base : void_ptr; nmemb : stddef.size_t;
size : stddef.size_t; compar : qqcompar_fn_t);
pragma Import (C, qsort, "qsort");
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 llabs (x : signed_long_long) return signed_long_long;
pragma Import (C, llabs, "llabs");
function div (numer : signed_int; denom : signed_int) return div_t;
pragma Import (C, div, "div");
function ldiv (numer : signed_long; denom : signed_long) return ldiv_t;
pragma Import (C, ldiv, "ldiv");
function lldiv (numer : signed_long_long; denom : signed_long_long)
return lldiv_t;
pragma Import (C, lldiv, "lldiv");
function ecvt (value : double; ndigit : signed_int;
decpt : access signed_int; sign : access signed_int) return char_ptr;
pragma Import (C, ecvt, "ecvt");
function fcvt (value : double; ndigit : signed_int;
decpt : access signed_int; sign : access signed_int) return char_ptr;
pragma Import (C, fcvt, "fcvt");
function gcvt (value : double; ndigit : signed_int; buf : access char)
return char_ptr;
pragma Import (C, gcvt, "gcvt");
function qecvt (value : long_double; ndigit : signed_int;
decpt : access signed_int; sign : access signed_int) return char_ptr;
pragma Import (C, qecvt, "qecvt");
function qfcvt (value : long_double; ndigit : signed_int;
decpt : access signed_int; sign : access signed_int) return char_ptr;
pragma Import (C, qfcvt, "qfcvt");
function qgcvt (value : long_double; ndigit : signed_int;
buf : access char) return char_ptr;
pragma Import (C, qgcvt, "qgcvt");
function ecvt_r (value : double; ndigit : signed_int;
decpt : access signed_int; sign : access signed_int; buf : access char;
len : stddef.size_t) return signed_int;
pragma Import (C, ecvt_r, "ecvt_r");
function fcvt_r (value : double; ndigit : signed_int;
decpt : access signed_int; sign : access signed_int; buf : access char;
len : stddef.size_t) return signed_int;
pragma Import (C, fcvt_r, "fcvt_r");
function qecvt_r (value : long_double; ndigit : signed_int;
decpt : access signed_int; sign : access signed_int; buf : access char;
len : stddef.size_t) return signed_int;
pragma Import (C, qecvt_r, "qecvt_r");
function qfcvt_r (value : long_double; ndigit : signed_int;
decpt : access signed_int; sign : access signed_int; buf : access char;
len : stddef.size_t) return signed_int;
pragma Import (C, qfcvt_r, "qfcvt_r");
function mblen (s : access constant char; n : stddef.size_t)
return signed_int;
pragma Import (C, mblen, "mblen");
function mbtowc (pwc : access stddef.wchar_t; s : access constant char;
n : stddef.size_t) return signed_int;
pragma Import (C, mbtowc, "mbtowc");
function wctomb (s : access char; wchar : stddef.wchar_t)
return signed_int;
pragma Import (C, wctomb, "wctomb");
function mbstowcs (pwcs : access stddef.wchar_t; s : access constant char;
n : stddef.size_t) return stddef.size_t;
pragma Import (C, mbstowcs, "mbstowcs");
function wcstombs (s : access char; pwcs : access constant stddef.wchar_t;
n : stddef.size_t) return stddef.size_t;
pragma Import (C, wcstombs, "wcstombs");
function rpmatch (response : access constant char) return signed_int;
pragma Import (C, rpmatch, "rpmatch");
function getsubopt (optionp : access char_ptr; tokens : access char_ptr;
valuep : access char_ptr) return signed_int;
pragma Import (C, getsubopt, "getsubopt");
function getloadavg (loadavg : access double; nelem : signed_int)
return signed_int;
pragma Import (C, getloadavg, "getloadavg");
EXIT_FAILURE : constant := 1;
EXIT_SUCCESS : constant := 0;
function MB_CUR_MAX return stddef.size_t;
pragma Inline_Always (MB_CUR_MAX);
RAND_MAX : constant := 2147483647;
-- WEXITSTATUS (unparsible)
-- WIFCONTINUED (unparsible)
-- WIFEXITED (unparsible)
-- WIFSIGNALED (unparsible)
-- WIFSTOPPED (unparsible)
-- WSTOPSIG (unparsible)
-- WTERMSIG (unparsible)
STDLIB_H : constant := 1;
-- __COMPAR_FN_T (empty)
ldiv_t_defined : constant := 1;
lldiv_t_defined : constant := 1;
-- __malloc_and_calloc_defined (empty)
end C.stdlib;
Raw
c-string.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;
with C.xlocale;
package C.string is
pragma Preelaborate;
function memcpy (dest : void_ptr; src : void_const_ptr; n : stddef.size_t)
return void_ptr;
pragma Import (C, memcpy, "memcpy");
function memmove (dest : void_ptr; src : void_const_ptr;
n : stddef.size_t) return void_ptr;
pragma Import (C, memmove, "memmove");
function memccpy (dest : void_ptr; src : void_const_ptr; c : signed_int;
n : stddef.size_t) return void_ptr;
pragma Import (C, memccpy, "memccpy");
function memset (s : void_ptr; c : signed_int; n : stddef.size_t)
return void_ptr;
pragma Import (C, memset, "memset");
function memcmp (s1 : void_const_ptr; s2 : void_const_ptr;
n : stddef.size_t) return signed_int;
pragma Import (C, memcmp, "memcmp");
function memchr (s : void_const_ptr; c : signed_int; n : stddef.size_t)
return void_ptr;
pragma Import (C, memchr, "memchr");
function strcpy (dest : access char; src : access constant char)
return char_ptr;
pragma Import (C, strcpy, "strcpy");
function strncpy (dest : access char; src : access constant char;
n : stddef.size_t) return char_ptr;
pragma Import (C, strncpy, "strncpy");
function strcat (dest : access char; src : access constant char)
return char_ptr;
pragma Import (C, strcat, "strcat");
function strncat (dest : access char; src : access constant char;
n : stddef.size_t) return char_ptr;
pragma Import (C, strncat, "strncat");
function strcmp (s1 : access constant char; s2 : access constant char)
return signed_int;
pragma Import (C, strcmp, "strcmp");
function strncmp (s1 : access constant char; s2 : access constant char;
n : stddef.size_t) return signed_int;
pragma Import (C, strncmp, "strncmp");
function strcoll (s1 : access constant char; s2 : access constant char)
return signed_int;
pragma Import (C, strcoll, "strcoll");
function strxfrm (dest : access char; src : access constant char;
n : stddef.size_t) return stddef.size_t;
pragma Import (C, strxfrm, "strxfrm");
-- #include <xlocale.h>
function strcoll_l (s1 : access constant char; s2 : access constant char;
l : access xlocale.struct_locale_struct) return signed_int;
pragma Import (C, strcoll_l, "strcoll_l");
function strxfrm_l (dest : access char; src : access constant char;
n : stddef.size_t; l : access xlocale.struct_locale_struct)
return stddef.size_t;
pragma Import (C, strxfrm_l, "strxfrm_l");
function strdup (s : access constant char) return char_ptr;
pragma Import (C, strdup, "strdup");
function strndup (string : access constant char; n : stddef.size_t)
return char_ptr;
pragma Import (C, strndup, "strndup");
function strchr (s : access constant char; c : signed_int)
return char_ptr;
pragma Import (C, strchr, "strchr");
function strrchr (s : access constant char; c : signed_int)
return char_ptr;
pragma Import (C, strrchr, "strrchr");
function strcspn (s : access constant char; reject : access constant char)
return stddef.size_t;
pragma Import (C, strcspn, "strcspn");
function strspn (s : access constant char;
A_accept : access constant char) return stddef.size_t;
pragma Import (C, strspn, "strspn");
function strpbrk (s : access constant char;
A_accept : access constant char) return char_ptr;
pragma Import (C, strpbrk, "strpbrk");
function strstr (haystack : access constant char;
needle : access constant char) return char_ptr;
pragma Import (C, strstr, "strstr");
function strtok (s : access char; delim : access constant char)
return char_ptr;
pragma Import (C, strtok, "strtok");
function qqstrtok_r (s : access char; delim : access constant char;
save_ptr : access char_ptr) return char_ptr;
pragma Import (C, qqstrtok_r, "__strtok_r");
function strtok_r (s : access char; delim : access constant char;
save_ptr : access char_ptr) return char_ptr;
pragma Import (C, strtok_r, "strtok_r");
function strlen (s : access constant char) return stddef.size_t;
pragma Import (C, strlen, "strlen");
function strnlen (string : access constant char; maxlen : stddef.size_t)
return stddef.size_t;
pragma Import (C, strnlen, "strnlen");
function strerror (errnum : signed_int) return char_ptr;
pragma Import (C, strerror, "strerror");
function strerror_r (errnum : signed_int; buf : access char;
buflen : stddef.size_t) return signed_int;
pragma Import (C, strerror_r, "_xpg_strerror_r");
function strerror_l (errnum : signed_int;
l : access xlocale.struct_locale_struct) return char_ptr;
pragma Import (C, strerror_l, "strerror_l");
procedure qqbzero (s : void_ptr; n : stddef.size_t);
pragma Import (C, qqbzero, "__bzero");
procedure bcopy (src : void_const_ptr; dest : void_ptr;
n : stddef.size_t);
pragma Import (C, bcopy, "bcopy");
procedure bzero (s : void_ptr; n : stddef.size_t);
pragma Import (C, bzero, "bzero");
function bcmp (s1 : void_const_ptr; s2 : void_const_ptr;
n : stddef.size_t) return signed_int;
pragma Import (C, bcmp, "bcmp");
function index (s : access constant char; c : signed_int) return char_ptr;
pragma Import (C, index, "index");
function rindex (s : access constant char; c : signed_int)
return char_ptr;
pragma Import (C, rindex, "rindex");
function ffs (i : signed_int) return signed_int;
pragma Import (C, ffs, "ffs");
function strcasecmp (s1 : access constant char; s2 : access constant char)
return signed_int;
pragma Import (C, strcasecmp, "strcasecmp");
function strncasecmp (s1 : access constant char;
s2 : access constant char; n : stddef.size_t) return signed_int;
pragma Import (C, strncasecmp, "strncasecmp");
function strsep (stringp : access char_ptr; delim : access constant char)
return char_ptr;
pragma Import (C, strsep, "strsep");
function strsignal (sig : signed_int) return char_ptr;
pragma Import (C, strsignal, "strsignal");
function qqstpcpy (dest : access char; src : access constant char)
return char_ptr;
pragma Import (C, qqstpcpy, "__stpcpy");
function stpcpy (dest : access char; src : access constant char)
return char_ptr;
pragma Import (C, stpcpy, "stpcpy");
function qqstpncpy (dest : access char; src : access constant char;
n : stddef.size_t) return char_ptr;
pragma Import (C, qqstpncpy, "__stpncpy");
function stpncpy (dest : access char; src : access constant char;
n : stddef.size_t) return char_ptr;
pragma Import (C, stpncpy, "stpncpy");
STRING_H : constant := 1;
end C.string;
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-select_h.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.sigset;
with C.bits.time;
with C.bits.types;
with C.time;
package C.sys.select_h is
pragma Preelaborate;
subtype sigset_t is bits.sigset.sigset_t;
-- #include <time.h>
-- #include <bits/time.h>
subtype suseconds_t is bits.types.suseconds_t;
subtype qqfd_mask is signed_long;
subtype qqfd_mask_array is signed_long_array;
type struct_8a2ace08 is record
fds_bits : aliased qqfd_mask_array (0 .. 15);
end record;
pragma Convention (C_Pass_By_Copy, struct_8a2ace08);
type struct_8a2ace08_ptr is access all struct_8a2ace08;
for struct_8a2ace08_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_8a2ace08_ptr);
pragma Convention (C, struct_8a2ace08_ptr);
subtype fd_set is struct_8a2ace08;
subtype fd_set_ptr is struct_8a2ace08_ptr;
subtype fd_mask is qqfd_mask;
function C_select (nfds : signed_int; readfds : access fd_set;
writefds : access fd_set; exceptfds : access fd_set;
timeout : access bits.time.struct_timeval) return signed_int;
pragma Import (C, C_select, "select");
function pselect (nfds : signed_int; readfds : access fd_set;
writefds : access fd_set; exceptfds : access fd_set;
timeout : access constant time.struct_timespec;
sigmask : access constant bits.sigset.sigset_t) return signed_int;
pragma Import (C, pselect, "pselect");
-- FD_CLR (uninterpretable)
-- FD_ISSET (uninterpretable)
-- FD_SET (uninterpretable)
FD_SETSIZE : constant := 1024;
-- FD_ZERO (uninterpretable)
NFDBITS : constant := 64;
SYS_SELECT_H : constant := 1;
-- __FDS_BITS (uninterpretable)
-- __FD_ELT (function macro)
-- __FD_MASK (function macro)
qqNFDBITS : constant := 64;
-- __sigset_t_defined (empty)
-- __suseconds_t_defined (empty)
end C.sys.select_h;
Raw
c-sys-sysmacros.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.sysmacros is
pragma Preelaborate;
function gnu_dev_major (dev : unsigned_long_long) return unsigned_int;
pragma Import (C, gnu_dev_major, "gnu_dev_major");
function gnu_dev_minor (dev : unsigned_long_long) return unsigned_int;
pragma Import (C, gnu_dev_minor, "gnu_dev_minor");
function gnu_dev_makedev (major : unsigned_int; minor : unsigned_int)
return unsigned_long_long;
pragma Import (C, gnu_dev_makedev, "gnu_dev_makedev");
SYS_SYSMACROS_H : constant := 1;
-- major (unparsible)
-- makedev (unparsible)
-- minor (unparsible)
end C.sys.sysmacros;
Raw
c-sys-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.
-------------------------------------------------------------------------------
with C.bits.types;
package C.sys.types is
pragma Preelaborate;
subtype u_char is bits.types.u_char;
subtype u_short is bits.types.u_short;
subtype u_int is bits.types.u_int;
subtype u_long is bits.types.u_long;
subtype quad_t is bits.types.quad_t;
subtype u_quad_t is bits.types.u_quad_t;
subtype fsid_t is bits.types.fsid_t;
subtype loff_t is bits.types.loff_t;
subtype ino_t is bits.types.ino_t;
subtype dev_t is bits.types.dev_t;
subtype gid_t is bits.types.gid_t;
subtype mode_t is bits.types.mode_t;
subtype nlink_t is bits.types.nlink_t;
subtype uid_t is bits.types.uid_t;
subtype off_t is bits.types.off_t;
subtype pid_t is bits.types.pid_t;
subtype id_t is bits.types.id_t;
subtype ssize_t is bits.types.ssize_t;
subtype daddr_t is bits.types.daddr_t;
subtype caddr_t is bits.types.caddr_t;
subtype key_t is bits.types.key_t;
-- #include <time.h>
subtype ulong is unsigned_long;
subtype ushort is unsigned_short;
subtype uint is unsigned_int;
subtype int8_t is signed_char;
subtype int16_t is signed_short;
subtype int32_t is signed_int;
subtype int32_t_ptr is signed_int_ptr;
subtype int64_t is signed_long;
subtype u_int8_t is unsigned_char;
subtype u_int16_t is unsigned_short;
subtype u_int32_t is unsigned_int;
subtype u_int64_t is unsigned_long;
subtype register_t is signed_long;
-- #include <bits/byteswap.h>
-- #include <bits/sigset.h>
-- #include <time.h>
-- #include <bits/time.h>
-- #include <sys/select.h>
-- #include <sys/sysmacros.h>
subtype blksize_t is bits.types.blksize_t;
subtype blkcnt_t is bits.types.blkcnt_t;
subtype fsblkcnt_t is bits.types.fsblkcnt_t;
subtype fsfilcnt_t is bits.types.fsfilcnt_t;
SYS_TYPES_H : constant := 1;
qqBIT_TYPES_DEFINEDqq : constant := 1;
-- __blkcnt_t_defined (empty)
-- __blksize_t_defined (empty)
-- __daddr_t_defined (empty)
-- __dev_t_defined (empty)
-- __fsblkcnt_t_defined (empty)
-- __fsfilcnt_t_defined (empty)
-- __gid_t_defined (empty)
-- __id_t_defined (empty)
-- __ino_t_defined (empty)
-- __int8_t_defined (empty)
-- __intN_t (has # or ##)
-- __key_t_defined (empty)
-- __mode_t_defined (empty)
-- __need_clockid_t (empty)
-- __nlink_t_defined (empty)
-- __off_t_defined (empty)
-- __pid_t_defined (empty)
-- __ssize_t_defined (empty)
-- __u_char_defined (empty)
-- __u_intN_t (has # or ##)
-- __uid_t_defined (empty)
end C.sys.types;
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-time.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.types;
package C.time is
pragma Preelaborate;
subtype clock_t is bits.types.qqclock_t;
subtype time_t is bits.types.qqtime_t;
subtype clockid_t is bits.types.qqclockid_t;
subtype timer_t is bits.types.qqtimer_t;
-- #include <sys/types.h>
-- #include <bits/byteswap.h>
-- #include <bits/sigset.h>
-- #include <sys/select.h>
type struct_timespec;
type struct_timespec is record
tv_sec : aliased bits.types.qqtime_t;
tv_nsec : aliased bits.types.syscall_slong_t;
end record;
pragma Convention (C_Pass_By_Copy, struct_timespec);
type struct_timespec_const_ptr is access constant struct_timespec;
for struct_timespec_const_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_timespec_const_ptr);
pragma Convention (C, struct_timespec_const_ptr);
clock_t_defined : constant := 1;
clockid_t_defined : constant := 1;
time_t_defined : constant := 1;
timer_t_defined : constant := 1;
timespec_defined : constant := 1;
end C.time;
Raw
c-wchar.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.wchar is
pragma Preelaborate;
type union_47e5c904 (Unchecked_Tag : unsigned_int := 0) is record
case Unchecked_Tag is
when 0 =>
wch : unsigned_int;
when others =>
wchb : char_array (0 .. 3);
end case;
end record;
pragma Unchecked_Union (union_47e5c904);
pragma Convention (C_Pass_By_Copy, union_47e5c904);
type struct_2acbcca7 is record
count : aliased signed_int;
value : aliased union_47e5c904;
end record;
pragma Convention (C_Pass_By_Copy, struct_2acbcca7);
subtype mbstate_t is struct_2acbcca7;
mbstate_t_defined : constant := 1;
end C.wchar;
Raw
c-xlocale.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.xlocale is
pragma Preelaborate;
type struct_locale_struct;
type struct_locale_data (<>) is limited private;
type struct_locale_data_ptr is access all struct_locale_data;
for struct_locale_data_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_locale_data_ptr);
pragma Convention (C, struct_locale_data_ptr);
type struct_locale_data_ptr_array is array (size_t range <>) of
aliased struct_locale_data_ptr;
pragma Convention (C, struct_locale_data_ptr_array);
type struct_locale_struct is record
locales : aliased struct_locale_data_ptr_array (0 .. 12);
ctype_b : aliased unsigned_short_const_ptr;
ctype_tolower : aliased signed_int_const_ptr;
ctype_toupper : aliased signed_int_const_ptr;
names : aliased char_const_ptr_array (0 .. 12);
end record;
pragma Convention (C_Pass_By_Copy, struct_locale_struct);
type struct_locale_struct_ptr is access all struct_locale_struct;
for struct_locale_struct_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_locale_struct_ptr);
pragma Convention (C, struct_locale_struct_ptr);
subtype qqlocale_t is struct_locale_struct_ptr;
subtype locale_t is qqlocale_t;
XLOCALE_H : constant := 1;
private
type struct_locale_data is null record;
end C.xlocale;
Raw
c-yaml.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;
with C.stdio;
package C.yaml is
pragma Preelaborate;
function yaml_get_version_string return char_const_ptr;
pragma Import (C, yaml_get_version_string, "yaml_get_version_string");
procedure yaml_get_version (major : access signed_int;
minor : access signed_int; patch : access signed_int);
pragma Import (C, yaml_get_version, "yaml_get_version");
subtype yaml_char_t is unsigned_char;
subtype yaml_char_t_ptr is unsigned_char_ptr;
type struct_yaml_version_directive_s;
type struct_yaml_version_directive_s is record
major : aliased signed_int;
minor : aliased signed_int;
end record;
pragma Convention (C_Pass_By_Copy, struct_yaml_version_directive_s);
type struct_yaml_version_directive_s_ptr is
access all struct_yaml_version_directive_s;
for struct_yaml_version_directive_s_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_yaml_version_directive_s_ptr);
pragma Convention (C, struct_yaml_version_directive_s_ptr);
subtype yaml_version_directive_t is struct_yaml_version_directive_s;
subtype yaml_version_directive_t_ptr is
struct_yaml_version_directive_s_ptr;
type struct_yaml_tag_directive_s;
type struct_yaml_tag_directive_s is record
handle : aliased yaml_char_t_ptr;
prefix : aliased yaml_char_t_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_yaml_tag_directive_s);
type struct_yaml_tag_directive_s_ptr is
access all struct_yaml_tag_directive_s;
for struct_yaml_tag_directive_s_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_yaml_tag_directive_s_ptr);
pragma Convention (C, struct_yaml_tag_directive_s_ptr);
subtype yaml_tag_directive_t is struct_yaml_tag_directive_s;
subtype yaml_tag_directive_t_ptr is struct_yaml_tag_directive_s_ptr;
type enum_yaml_encoding_e;
type enum_yaml_encoding_e is (YAML_ANY_ENCODING, YAML_UTF8_ENCODING,
YAML_UTF16LE_ENCODING, YAML_UTF16BE_ENCODING);
for enum_yaml_encoding_e use (YAML_ANY_ENCODING => 0,
YAML_UTF8_ENCODING => 1, YAML_UTF16LE_ENCODING => 2,
YAML_UTF16BE_ENCODING => 3);
pragma Convention (C, enum_yaml_encoding_e);
subtype yaml_encoding_t is enum_yaml_encoding_e;
type enum_yaml_break_e;
type enum_yaml_break_e is (YAML_ANY_BREAK, YAML_CR_BREAK, YAML_LN_BREAK,
YAML_CRLN_BREAK);
for enum_yaml_break_e use (YAML_ANY_BREAK => 0, YAML_CR_BREAK => 1,
YAML_LN_BREAK => 2, YAML_CRLN_BREAK => 3);
pragma Convention (C, enum_yaml_break_e);
subtype yaml_break_t is enum_yaml_break_e;
type enum_yaml_error_type_e;
type enum_yaml_error_type_e is (YAML_NO_ERROR, YAML_MEMORY_ERROR,
YAML_READER_ERROR, YAML_SCANNER_ERROR, YAML_PARSER_ERROR,
YAML_COMPOSER_ERROR, YAML_WRITER_ERROR, YAML_EMITTER_ERROR);
for enum_yaml_error_type_e use (YAML_NO_ERROR => 0,
YAML_MEMORY_ERROR => 1, YAML_READER_ERROR => 2,
YAML_SCANNER_ERROR => 3, YAML_PARSER_ERROR => 4,
YAML_COMPOSER_ERROR => 5, YAML_WRITER_ERROR => 6,
YAML_EMITTER_ERROR => 7);
pragma Convention (C, enum_yaml_error_type_e);
subtype yaml_error_type_t is enum_yaml_error_type_e;
type struct_yaml_mark_s;
type struct_yaml_mark_s is record
index : aliased stddef.size_t;
line : aliased stddef.size_t;
column : aliased stddef.size_t;
end record;
pragma Convention (C_Pass_By_Copy, struct_yaml_mark_s);
type struct_yaml_mark_s_ptr is access all struct_yaml_mark_s;
for struct_yaml_mark_s_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_yaml_mark_s_ptr);
pragma Convention (C, struct_yaml_mark_s_ptr);
subtype yaml_mark_t is struct_yaml_mark_s;
subtype yaml_mark_t_ptr is struct_yaml_mark_s_ptr;
type enum_yaml_scalar_style_e;
type enum_yaml_scalar_style_e is (YAML_ANY_SCALAR_STYLE,
YAML_PLAIN_SCALAR_STYLE, YAML_SINGLE_QUOTED_SCALAR_STYLE,
YAML_DOUBLE_QUOTED_SCALAR_STYLE, YAML_LITERAL_SCALAR_STYLE,
YAML_FOLDED_SCALAR_STYLE);
for enum_yaml_scalar_style_e use (YAML_ANY_SCALAR_STYLE => 0,
YAML_PLAIN_SCALAR_STYLE => 1, YAML_SINGLE_QUOTED_SCALAR_STYLE => 2,
YAML_DOUBLE_QUOTED_SCALAR_STYLE => 3, YAML_LITERAL_SCALAR_STYLE => 4,
YAML_FOLDED_SCALAR_STYLE => 5);
pragma Convention (C, enum_yaml_scalar_style_e);
subtype yaml_scalar_style_t is enum_yaml_scalar_style_e;
type enum_yaml_sequence_style_e;
type enum_yaml_sequence_style_e is (YAML_ANY_SEQUENCE_STYLE,
YAML_BLOCK_SEQUENCE_STYLE, YAML_FLOW_SEQUENCE_STYLE);
for enum_yaml_sequence_style_e use (YAML_ANY_SEQUENCE_STYLE => 0,
YAML_BLOCK_SEQUENCE_STYLE => 1, YAML_FLOW_SEQUENCE_STYLE => 2);
pragma Convention (C, enum_yaml_sequence_style_e);
subtype yaml_sequence_style_t is enum_yaml_sequence_style_e;
type enum_yaml_mapping_style_e;
type enum_yaml_mapping_style_e is (YAML_ANY_MAPPING_STYLE,
YAML_BLOCK_MAPPING_STYLE, YAML_FLOW_MAPPING_STYLE);
for enum_yaml_mapping_style_e use (YAML_ANY_MAPPING_STYLE => 0,
YAML_BLOCK_MAPPING_STYLE => 1, YAML_FLOW_MAPPING_STYLE => 2);
pragma Convention (C, enum_yaml_mapping_style_e);
subtype yaml_mapping_style_t is enum_yaml_mapping_style_e;
type enum_yaml_token_type_e;
type enum_yaml_token_type_e is (YAML_NO_TOKEN, YAML_STREAM_START_TOKEN,
YAML_STREAM_END_TOKEN, YAML_VERSION_DIRECTIVE_TOKEN,
YAML_TAG_DIRECTIVE_TOKEN, YAML_DOCUMENT_START_TOKEN,
YAML_DOCUMENT_END_TOKEN, YAML_BLOCK_SEQUENCE_START_TOKEN,
YAML_BLOCK_MAPPING_START_TOKEN, YAML_BLOCK_END_TOKEN,
YAML_FLOW_SEQUENCE_START_TOKEN, YAML_FLOW_SEQUENCE_END_TOKEN,
YAML_FLOW_MAPPING_START_TOKEN, YAML_FLOW_MAPPING_END_TOKEN,
YAML_BLOCK_ENTRY_TOKEN, YAML_FLOW_ENTRY_TOKEN, YAML_KEY_TOKEN,
YAML_VALUE_TOKEN, YAML_ALIAS_TOKEN, YAML_ANCHOR_TOKEN, YAML_TAG_TOKEN,
YAML_SCALAR_TOKEN);
for enum_yaml_token_type_e use (YAML_NO_TOKEN => 0,
YAML_STREAM_START_TOKEN => 1, YAML_STREAM_END_TOKEN => 2,
YAML_VERSION_DIRECTIVE_TOKEN => 3, YAML_TAG_DIRECTIVE_TOKEN => 4,
YAML_DOCUMENT_START_TOKEN => 5, YAML_DOCUMENT_END_TOKEN => 6,
YAML_BLOCK_SEQUENCE_START_TOKEN => 7,
YAML_BLOCK_MAPPING_START_TOKEN => 8, YAML_BLOCK_END_TOKEN => 9,
YAML_FLOW_SEQUENCE_START_TOKEN => 10,
YAML_FLOW_SEQUENCE_END_TOKEN => 11,
YAML_FLOW_MAPPING_START_TOKEN => 12, YAML_FLOW_MAPPING_END_TOKEN => 13,
YAML_BLOCK_ENTRY_TOKEN => 14, YAML_FLOW_ENTRY_TOKEN => 15,
YAML_KEY_TOKEN => 16, YAML_VALUE_TOKEN => 17, YAML_ALIAS_TOKEN => 18,
YAML_ANCHOR_TOKEN => 19, YAML_TAG_TOKEN => 20,
YAML_SCALAR_TOKEN => 21);
pragma Convention (C, enum_yaml_token_type_e);
subtype yaml_token_type_t is enum_yaml_token_type_e;
type struct_yaml_token_s;
type struct_f47f45c1 is record
encoding : aliased yaml_encoding_t;
end record;
pragma Convention (C_Pass_By_Copy, struct_f47f45c1);
type struct_27abe35f is record
value : aliased yaml_char_t_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_27abe35f);
type struct_ef4636b2 is record
value : aliased yaml_char_t_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_ef4636b2);
type struct_b79acd91 is record
handle : aliased yaml_char_t_ptr;
suffix : aliased yaml_char_t_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_b79acd91);
type struct_8c47665f is record
value : aliased yaml_char_t_ptr;
length : aliased stddef.size_t;
style : aliased yaml_scalar_style_t;
end record;
pragma Convention (C_Pass_By_Copy, struct_8c47665f);
type struct_770ff656 is record
major : aliased signed_int;
minor : aliased signed_int;
end record;
pragma Convention (C_Pass_By_Copy, struct_770ff656);
type struct_f3bc36bb is record
handle : aliased yaml_char_t_ptr;
prefix : aliased yaml_char_t_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_f3bc36bb);
type union_e720527d (Unchecked_Tag : unsigned_int := 0) is record
case Unchecked_Tag is
when 0 =>
stream_start : struct_f47f45c1;
when 1 =>
alias : struct_27abe35f;
when 2 =>
anchor : struct_ef4636b2;
when 3 =>
tag : struct_b79acd91;
when 4 =>
scalar : struct_8c47665f;
when 5 =>
version_directive : struct_770ff656;
when others =>
tag_directive : struct_f3bc36bb;
end case;
end record;
pragma Unchecked_Union (union_e720527d);
pragma Convention (C_Pass_By_Copy, union_e720527d);
type struct_yaml_token_s is record
F_type : aliased yaml_token_type_t;
data : aliased union_e720527d;
start_mark : aliased yaml_mark_t;
end_mark : aliased yaml_mark_t;
end record;
pragma Convention (C_Pass_By_Copy, struct_yaml_token_s);
type struct_yaml_token_s_ptr is access all struct_yaml_token_s;
for struct_yaml_token_s_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_yaml_token_s_ptr);
pragma Convention (C, struct_yaml_token_s_ptr);
subtype yaml_token_t is struct_yaml_token_s;
subtype yaml_token_t_ptr is struct_yaml_token_s_ptr;
procedure yaml_token_delete (token : access yaml_token_t);
pragma Import (C, yaml_token_delete, "yaml_token_delete");
type enum_yaml_event_type_e;
type enum_yaml_event_type_e is (YAML_NO_EVENT, YAML_STREAM_START_EVENT,
YAML_STREAM_END_EVENT, YAML_DOCUMENT_START_EVENT,
YAML_DOCUMENT_END_EVENT, YAML_ALIAS_EVENT, YAML_SCALAR_EVENT,
YAML_SEQUENCE_START_EVENT, YAML_SEQUENCE_END_EVENT,
YAML_MAPPING_START_EVENT, YAML_MAPPING_END_EVENT);
for enum_yaml_event_type_e use (YAML_NO_EVENT => 0,
YAML_STREAM_START_EVENT => 1, YAML_STREAM_END_EVENT => 2,
YAML_DOCUMENT_START_EVENT => 3, YAML_DOCUMENT_END_EVENT => 4,
YAML_ALIAS_EVENT => 5, YAML_SCALAR_EVENT => 6,
YAML_SEQUENCE_START_EVENT => 7, YAML_SEQUENCE_END_EVENT => 8,
YAML_MAPPING_START_EVENT => 9, YAML_MAPPING_END_EVENT => 10);
pragma Convention (C, enum_yaml_event_type_e);
subtype yaml_event_type_t is enum_yaml_event_type_e;
type struct_yaml_event_s;
type struct_fb571ff1 is record
encoding : aliased yaml_encoding_t;
end record;
pragma Convention (C_Pass_By_Copy, struct_fb571ff1);
type struct_93322409 is record
start : aliased yaml_tag_directive_t_ptr;
F_end : aliased yaml_tag_directive_t_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_93322409);
type struct_456a074d is record
version_directive : aliased yaml_version_directive_t_ptr;
tag_directives : aliased struct_93322409;
implicit : aliased signed_int;
end record;
pragma Convention (C_Pass_By_Copy, struct_456a074d);
type struct_8130e4fa is record
implicit : aliased signed_int;
end record;
pragma Convention (C_Pass_By_Copy, struct_8130e4fa);
type struct_a3308964 is record
anchor : aliased yaml_char_t_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_a3308964);
type struct_2f7fd6a1 is record
anchor : aliased yaml_char_t_ptr;
tag : aliased yaml_char_t_ptr;
value : aliased yaml_char_t_ptr;
length : aliased stddef.size_t;
plain_implicit : aliased signed_int;
quoted_implicit : aliased signed_int;
style : aliased yaml_scalar_style_t;
end record;
pragma Convention (C_Pass_By_Copy, struct_2f7fd6a1);
type struct_a619e610 is record
anchor : aliased yaml_char_t_ptr;
tag : aliased yaml_char_t_ptr;
implicit : aliased signed_int;
style : aliased yaml_sequence_style_t;
end record;
pragma Convention (C_Pass_By_Copy, struct_a619e610);
type struct_479e518a is record
anchor : aliased yaml_char_t_ptr;
tag : aliased yaml_char_t_ptr;
implicit : aliased signed_int;
style : aliased yaml_mapping_style_t;
end record;
pragma Convention (C_Pass_By_Copy, struct_479e518a);
type union_dc65d82c (Unchecked_Tag : unsigned_int := 0) is record
case Unchecked_Tag is
when 0 =>
stream_start : struct_fb571ff1;
when 1 =>
document_start : struct_456a074d;
when 2 =>
document_end : struct_8130e4fa;
when 3 =>
alias : struct_a3308964;
when 4 =>
scalar : struct_2f7fd6a1;
when 5 =>
sequence_start : struct_a619e610;
when others =>
mapping_start : struct_479e518a;
end case;
end record;
pragma Unchecked_Union (union_dc65d82c);
pragma Convention (C_Pass_By_Copy, union_dc65d82c);
type struct_yaml_event_s is record
F_type : aliased yaml_event_type_t;
data : aliased union_dc65d82c;
start_mark : aliased yaml_mark_t;
end_mark : aliased yaml_mark_t;
end record;
pragma Convention (C_Pass_By_Copy, struct_yaml_event_s);
type struct_yaml_event_s_ptr is access all struct_yaml_event_s;
for struct_yaml_event_s_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_yaml_event_s_ptr);
pragma Convention (C, struct_yaml_event_s_ptr);
subtype yaml_event_t is struct_yaml_event_s;
subtype yaml_event_t_ptr is struct_yaml_event_s_ptr;
function yaml_stream_start_event_initialize (event : access yaml_event_t;
encoding : yaml_encoding_t) return signed_int;
pragma Import (C, yaml_stream_start_event_initialize,
"yaml_stream_start_event_initialize");
function yaml_stream_end_event_initialize (event : access yaml_event_t)
return signed_int;
pragma Import (C, yaml_stream_end_event_initialize,
"yaml_stream_end_event_initialize");
function yaml_document_start_event_initialize (
event : access yaml_event_t;
version_directive : access yaml_version_directive_t;
tag_directives_start : access yaml_tag_directive_t;
tag_directives_end : access yaml_tag_directive_t;
implicit : signed_int) return signed_int;
pragma Import (C, yaml_document_start_event_initialize,
"yaml_document_start_event_initialize");
function yaml_document_end_event_initialize (event : access yaml_event_t;
implicit : signed_int) return signed_int;
pragma Import (C, yaml_document_end_event_initialize,
"yaml_document_end_event_initialize");
function yaml_alias_event_initialize (event : access yaml_event_t;
anchor : access yaml_char_t) return signed_int;
pragma Import (C, yaml_alias_event_initialize,
"yaml_alias_event_initialize");
function yaml_scalar_event_initialize (event : access yaml_event_t;
anchor : access yaml_char_t; tag : access yaml_char_t;
value : access yaml_char_t; length : signed_int;
plain_implicit : signed_int; quoted_implicit : signed_int;
style : yaml_scalar_style_t) return signed_int;
pragma Import (C, yaml_scalar_event_initialize,
"yaml_scalar_event_initialize");
function yaml_sequence_start_event_initialize (
event : access yaml_event_t; anchor : access yaml_char_t;
tag : access yaml_char_t; implicit : signed_int;
style : yaml_sequence_style_t) return signed_int;
pragma Import (C, yaml_sequence_start_event_initialize,
"yaml_sequence_start_event_initialize");
function yaml_sequence_end_event_initialize (event : access yaml_event_t)
return signed_int;
pragma Import (C, yaml_sequence_end_event_initialize,
"yaml_sequence_end_event_initialize");
function yaml_mapping_start_event_initialize (event : access yaml_event_t;
anchor : access yaml_char_t; tag : access yaml_char_t;
implicit : signed_int; style : yaml_mapping_style_t) return signed_int;
pragma Import (C, yaml_mapping_start_event_initialize,
"yaml_mapping_start_event_initialize");
function yaml_mapping_end_event_initialize (event : access yaml_event_t)
return signed_int;
pragma Import (C, yaml_mapping_end_event_initialize,
"yaml_mapping_end_event_initialize");
procedure yaml_event_delete (event : access yaml_event_t);
pragma Import (C, yaml_event_delete, "yaml_event_delete");
type enum_yaml_node_type_e;
type enum_yaml_node_type_e is (YAML_NO_NODE, YAML_SCALAR_NODE,
YAML_SEQUENCE_NODE, YAML_MAPPING_NODE);
for enum_yaml_node_type_e use (YAML_NO_NODE => 0, YAML_SCALAR_NODE => 1,
YAML_SEQUENCE_NODE => 2, YAML_MAPPING_NODE => 3);
pragma Convention (C, enum_yaml_node_type_e);
subtype yaml_node_type_t is enum_yaml_node_type_e;
type struct_yaml_node_s;
type struct_yaml_node_s_ptr is access all struct_yaml_node_s;
for struct_yaml_node_s_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_yaml_node_s_ptr);
pragma Convention (C, struct_yaml_node_s_ptr);
subtype yaml_node_t is struct_yaml_node_s;
subtype yaml_node_t_ptr is struct_yaml_node_s_ptr;
subtype yaml_node_item_t is signed_int;
subtype yaml_node_item_t_ptr is signed_int_ptr;
type struct_yaml_node_pair_s;
type struct_yaml_node_pair_s is record
key : aliased signed_int;
value : aliased signed_int;
end record;
pragma Convention (C_Pass_By_Copy, struct_yaml_node_pair_s);
type struct_yaml_node_pair_s_ptr is access all struct_yaml_node_pair_s;
for struct_yaml_node_pair_s_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_yaml_node_pair_s_ptr);
pragma Convention (C, struct_yaml_node_pair_s_ptr);
subtype yaml_node_pair_t is struct_yaml_node_pair_s;
subtype yaml_node_pair_t_ptr is struct_yaml_node_pair_s_ptr;
type struct_bb39eb73 is record
value : aliased yaml_char_t_ptr;
length : aliased stddef.size_t;
style : aliased yaml_scalar_style_t;
end record;
pragma Convention (C_Pass_By_Copy, struct_bb39eb73);
type struct_c0b4d5bc is record
start : aliased yaml_node_item_t_ptr;
F_end : aliased yaml_node_item_t_ptr;
top : aliased yaml_node_item_t_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_c0b4d5bc);
type struct_1e8f6069 is record
items : aliased struct_c0b4d5bc;
style : aliased yaml_sequence_style_t;
end record;
pragma Convention (C_Pass_By_Copy, struct_1e8f6069);
type struct_27ff5809 is record
start : aliased yaml_node_pair_t_ptr;
F_end : aliased yaml_node_pair_t_ptr;
top : aliased yaml_node_pair_t_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_27ff5809);
type struct_9fa6cf60 is record
pairs : aliased struct_27ff5809;
style : aliased yaml_mapping_style_t;
end record;
pragma Convention (C_Pass_By_Copy, struct_9fa6cf60);
type union_425eda57 (Unchecked_Tag : unsigned_int := 0) is record
case Unchecked_Tag is
when 0 =>
scalar : struct_bb39eb73;
when 1 =>
sequence : struct_1e8f6069;
when others =>
mapping : struct_9fa6cf60;
end case;
end record;
pragma Unchecked_Union (union_425eda57);
pragma Convention (C_Pass_By_Copy, union_425eda57);
type struct_yaml_node_s is record
F_type : aliased yaml_node_type_t;
tag : aliased yaml_char_t_ptr;
data : aliased union_425eda57;
start_mark : aliased yaml_mark_t;
end_mark : aliased yaml_mark_t;
end record;
pragma Convention (C_Pass_By_Copy, struct_yaml_node_s);
type struct_yaml_document_s;
type struct_8a11321e is record
start : aliased yaml_node_t_ptr;
F_end : aliased yaml_node_t_ptr;
top : aliased yaml_node_t_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_8a11321e);
type struct_bfefd048 is record
start : aliased yaml_tag_directive_t_ptr;
F_end : aliased yaml_tag_directive_t_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_bfefd048);
type struct_yaml_document_s is record
nodes : aliased struct_8a11321e;
version_directive : aliased yaml_version_directive_t_ptr;
tag_directives : aliased struct_bfefd048;
start_implicit : aliased signed_int;
end_implicit : aliased signed_int;
start_mark : aliased yaml_mark_t;
end_mark : aliased yaml_mark_t;
end record;
pragma Convention (C_Pass_By_Copy, struct_yaml_document_s);
type struct_yaml_document_s_ptr is access all struct_yaml_document_s;
for struct_yaml_document_s_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_yaml_document_s_ptr);
pragma Convention (C, struct_yaml_document_s_ptr);
subtype yaml_document_t is struct_yaml_document_s;
subtype yaml_document_t_ptr is struct_yaml_document_s_ptr;
function yaml_document_initialize (document : access yaml_document_t;
version_directive : access yaml_version_directive_t;
tag_directives_start : access yaml_tag_directive_t;
tag_directives_end : access yaml_tag_directive_t;
start_implicit : signed_int; end_implicit : signed_int)
return signed_int;
pragma Import (C, yaml_document_initialize, "yaml_document_initialize");
procedure yaml_document_delete (document : access yaml_document_t);
pragma Import (C, yaml_document_delete, "yaml_document_delete");
function yaml_document_get_node (document : access yaml_document_t;
index : signed_int) return yaml_node_t_ptr;
pragma Import (C, yaml_document_get_node, "yaml_document_get_node");
function yaml_document_get_root_node (document : access yaml_document_t)
return yaml_node_t_ptr;
pragma Import (C, yaml_document_get_root_node,
"yaml_document_get_root_node");
function yaml_document_add_scalar (document : access yaml_document_t;
tag : access yaml_char_t; value : access yaml_char_t;
length : signed_int; style : yaml_scalar_style_t) return signed_int;
pragma Import (C, yaml_document_add_scalar, "yaml_document_add_scalar");
function yaml_document_add_sequence (document : access yaml_document_t;
tag : access yaml_char_t; style : yaml_sequence_style_t)
return signed_int;
pragma Import (C, yaml_document_add_sequence,
"yaml_document_add_sequence");
function yaml_document_add_mapping (document : access yaml_document_t;
tag : access yaml_char_t; style : yaml_mapping_style_t)
return signed_int;
pragma Import (C, yaml_document_add_mapping, "yaml_document_add_mapping");
function yaml_document_append_sequence_item (
document : access yaml_document_t; sequence : signed_int;
item : signed_int) return signed_int;
pragma Import (C, yaml_document_append_sequence_item,
"yaml_document_append_sequence_item");
function yaml_document_append_mapping_pair (
document : access yaml_document_t; mapping : signed_int;
key : signed_int; value : signed_int) return signed_int;
pragma Import (C, yaml_document_append_mapping_pair,
"yaml_document_append_mapping_pair");
type access_a190acaa is access function (data : void_ptr;
buffer : access unsigned_char; size : stddef.size_t;
size_read : access stddef.size_t) return signed_int;
pragma Convention (C, access_a190acaa);
-- subtype yaml_read_handler_t is ... (function type)
subtype yaml_read_handler_t_ptr is access_a190acaa;
type struct_yaml_simple_key_s;
type struct_yaml_simple_key_s is record
possible : aliased signed_int;
required : aliased signed_int;
token_number : aliased stddef.size_t;
mark : aliased yaml_mark_t;
end record;
pragma Convention (C_Pass_By_Copy, struct_yaml_simple_key_s);
type struct_yaml_simple_key_s_ptr is access all struct_yaml_simple_key_s;
for struct_yaml_simple_key_s_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_yaml_simple_key_s_ptr);
pragma Convention (C, struct_yaml_simple_key_s_ptr);
subtype yaml_simple_key_t is struct_yaml_simple_key_s;
subtype yaml_simple_key_t_ptr is struct_yaml_simple_key_s_ptr;
type enum_yaml_parser_state_e;
type enum_yaml_parser_state_e is (YAML_PARSE_STREAM_START_STATE,
YAML_PARSE_IMPLICIT_DOCUMENT_START_STATE,
YAML_PARSE_DOCUMENT_START_STATE, YAML_PARSE_DOCUMENT_CONTENT_STATE,
YAML_PARSE_DOCUMENT_END_STATE, YAML_PARSE_BLOCK_NODE_STATE,
YAML_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE,
YAML_PARSE_FLOW_NODE_STATE,
YAML_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE,
YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE,
YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE,
YAML_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE,
YAML_PARSE_BLOCK_MAPPING_KEY_STATE,
YAML_PARSE_BLOCK_MAPPING_VALUE_STATE,
YAML_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE,
YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE,
YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE,
YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE,
YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE,
YAML_PARSE_FLOW_MAPPING_FIRST_KEY_STATE,
YAML_PARSE_FLOW_MAPPING_KEY_STATE, YAML_PARSE_FLOW_MAPPING_VALUE_STATE,
YAML_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE, YAML_PARSE_END_STATE);
for enum_yaml_parser_state_e use (YAML_PARSE_STREAM_START_STATE => 0,
YAML_PARSE_IMPLICIT_DOCUMENT_START_STATE => 1,
YAML_PARSE_DOCUMENT_START_STATE => 2,
YAML_PARSE_DOCUMENT_CONTENT_STATE => 3,
YAML_PARSE_DOCUMENT_END_STATE => 4, YAML_PARSE_BLOCK_NODE_STATE => 5,
YAML_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE => 6,
YAML_PARSE_FLOW_NODE_STATE => 7,
YAML_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE => 8,
YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE => 9,
YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE => 10,
YAML_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE => 11,
YAML_PARSE_BLOCK_MAPPING_KEY_STATE => 12,
YAML_PARSE_BLOCK_MAPPING_VALUE_STATE => 13,
YAML_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE => 14,
YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE => 15,
YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE => 16,
YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE => 17,
YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE => 18,
YAML_PARSE_FLOW_MAPPING_FIRST_KEY_STATE => 19,
YAML_PARSE_FLOW_MAPPING_KEY_STATE => 20,
YAML_PARSE_FLOW_MAPPING_VALUE_STATE => 21,
YAML_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE => 22,
YAML_PARSE_END_STATE => 23);
pragma Convention (C, enum_yaml_parser_state_e);
type enum_yaml_parser_state_e_ptr is access all enum_yaml_parser_state_e;
for enum_yaml_parser_state_e_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (enum_yaml_parser_state_e_ptr);
pragma Convention (C, enum_yaml_parser_state_e_ptr);
subtype yaml_parser_state_t is enum_yaml_parser_state_e;
subtype yaml_parser_state_t_ptr is enum_yaml_parser_state_e_ptr;
type struct_yaml_alias_data_s;
type struct_yaml_alias_data_s is record
anchor : aliased yaml_char_t_ptr;
index : aliased signed_int;
mark : aliased yaml_mark_t;
end record;
pragma Convention (C_Pass_By_Copy, struct_yaml_alias_data_s);
type struct_yaml_alias_data_s_ptr is access all struct_yaml_alias_data_s;
for struct_yaml_alias_data_s_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_yaml_alias_data_s_ptr);
pragma Convention (C, struct_yaml_alias_data_s_ptr);
subtype yaml_alias_data_t is struct_yaml_alias_data_s;
subtype yaml_alias_data_t_ptr is struct_yaml_alias_data_s_ptr;
type struct_yaml_parser_s;
type struct_6fb23e33 is record
start : aliased unsigned_char_const_ptr;
F_end : aliased unsigned_char_const_ptr;
current : aliased unsigned_char_const_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_6fb23e33);
type union_0206ae30 (Unchecked_Tag : unsigned_int := 0) is record
case Unchecked_Tag is
when 0 =>
string : struct_6fb23e33;
when others =>
file : stdio.FILE_ptr;
end case;
end record;
pragma Unchecked_Union (union_0206ae30);
pragma Convention (C_Pass_By_Copy, union_0206ae30);
type struct_c1bbaff3 is record
start : aliased yaml_char_t_ptr;
F_end : aliased yaml_char_t_ptr;
pointer : aliased yaml_char_t_ptr;
last : aliased yaml_char_t_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_c1bbaff3);
type struct_49a60013 is record
start : aliased unsigned_char_ptr;
F_end : aliased unsigned_char_ptr;
pointer : aliased unsigned_char_ptr;
last : aliased unsigned_char_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_49a60013);
type struct_28c7a211 is record
start : aliased yaml_token_t_ptr;
F_end : aliased yaml_token_t_ptr;
head : aliased yaml_token_t_ptr;
tail : aliased yaml_token_t_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_28c7a211);
type struct_80631006 is record
start : aliased signed_int_ptr;
F_end : aliased signed_int_ptr;
top : aliased signed_int_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_80631006);
type struct_0cb2899a is record
start : aliased yaml_simple_key_t_ptr;
F_end : aliased yaml_simple_key_t_ptr;
top : aliased yaml_simple_key_t_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_0cb2899a);
type struct_f4d68d71 is record
start : aliased yaml_parser_state_t_ptr;
F_end : aliased yaml_parser_state_t_ptr;
top : aliased yaml_parser_state_t_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_f4d68d71);
type struct_b103af9f is record
start : aliased yaml_mark_t_ptr;
F_end : aliased yaml_mark_t_ptr;
top : aliased yaml_mark_t_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_b103af9f);
type struct_7af2cfb2 is record
start : aliased yaml_tag_directive_t_ptr;
F_end : aliased yaml_tag_directive_t_ptr;
top : aliased yaml_tag_directive_t_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_7af2cfb2);
type struct_6a9a0745 is record
start : aliased yaml_alias_data_t_ptr;
F_end : aliased yaml_alias_data_t_ptr;
top : aliased yaml_alias_data_t_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_6a9a0745);
type struct_yaml_parser_s is record
error : aliased yaml_error_type_t;
problem : aliased char_const_ptr;
problem_offset : aliased stddef.size_t;
problem_value : aliased signed_int;
problem_mark : aliased yaml_mark_t;
context : aliased char_const_ptr;
context_mark : aliased yaml_mark_t;
read_handler : aliased yaml_read_handler_t_ptr;
read_handler_data : aliased void_ptr;
input : aliased union_0206ae30;
eof : aliased signed_int;
buffer : aliased struct_c1bbaff3;
unread : aliased stddef.size_t;
raw_buffer : aliased struct_49a60013;
encoding : aliased yaml_encoding_t;
offset : aliased stddef.size_t;
mark : aliased yaml_mark_t;
stream_start_produced : aliased signed_int;
stream_end_produced : aliased signed_int;
flow_level : aliased signed_int;
tokens : aliased struct_28c7a211;
tokens_parsed : aliased stddef.size_t;
token_available : aliased signed_int;
indents : aliased struct_80631006;
indent : aliased signed_int;
simple_key_allowed : aliased signed_int;
simple_keys : aliased struct_0cb2899a;
states : aliased struct_f4d68d71;
state : aliased yaml_parser_state_t;
marks : aliased struct_b103af9f;
tag_directives : aliased struct_7af2cfb2;
aliases : aliased struct_6a9a0745;
document : aliased yaml_document_t_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_yaml_parser_s);
type struct_yaml_parser_s_ptr is access all struct_yaml_parser_s;
for struct_yaml_parser_s_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_yaml_parser_s_ptr);
pragma Convention (C, struct_yaml_parser_s_ptr);
subtype yaml_parser_t is struct_yaml_parser_s;
subtype yaml_parser_t_ptr is struct_yaml_parser_s_ptr;
function yaml_parser_initialize (parser : access yaml_parser_t)
return signed_int;
pragma Import (C, yaml_parser_initialize, "yaml_parser_initialize");
procedure yaml_parser_delete (parser : access yaml_parser_t);
pragma Import (C, yaml_parser_delete, "yaml_parser_delete");
procedure yaml_parser_set_input_string (parser : access yaml_parser_t;
input : access constant unsigned_char; size : stddef.size_t);
pragma Import (C, yaml_parser_set_input_string,
"yaml_parser_set_input_string");
procedure yaml_parser_set_input_file (parser : access yaml_parser_t;
file : access stdio.FILE);
pragma Import (C, yaml_parser_set_input_file,
"yaml_parser_set_input_file");
procedure yaml_parser_set_input (parser : access yaml_parser_t;
handler : yaml_read_handler_t_ptr; data : void_ptr);
pragma Import (C, yaml_parser_set_input, "yaml_parser_set_input");
procedure yaml_parser_set_encoding (parser : access yaml_parser_t;
encoding : yaml_encoding_t);
pragma Import (C, yaml_parser_set_encoding, "yaml_parser_set_encoding");
function yaml_parser_scan (parser : access yaml_parser_t;
token : access yaml_token_t) return signed_int;
pragma Import (C, yaml_parser_scan, "yaml_parser_scan");
function yaml_parser_parse (parser : access yaml_parser_t;
event : access yaml_event_t) return signed_int;
pragma Import (C, yaml_parser_parse, "yaml_parser_parse");
function yaml_parser_load (parser : access yaml_parser_t;
document : access yaml_document_t) return signed_int;
pragma Import (C, yaml_parser_load, "yaml_parser_load");
type access_bd4d720b is access function (data : void_ptr;
buffer : access unsigned_char; size : stddef.size_t) return signed_int;
pragma Convention (C, access_bd4d720b);
-- subtype yaml_write_handler_t is ... (function type)
subtype yaml_write_handler_t_ptr is access_bd4d720b;
type enum_yaml_emitter_state_e;
type enum_yaml_emitter_state_e is (YAML_EMIT_STREAM_START_STATE,
YAML_EMIT_FIRST_DOCUMENT_START_STATE, YAML_EMIT_DOCUMENT_START_STATE,
YAML_EMIT_DOCUMENT_CONTENT_STATE, YAML_EMIT_DOCUMENT_END_STATE,
YAML_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE,
YAML_EMIT_FLOW_SEQUENCE_ITEM_STATE,
YAML_EMIT_FLOW_MAPPING_FIRST_KEY_STATE,
YAML_EMIT_FLOW_MAPPING_KEY_STATE,
YAML_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE,
YAML_EMIT_FLOW_MAPPING_VALUE_STATE,
YAML_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE,
YAML_EMIT_BLOCK_SEQUENCE_ITEM_STATE,
YAML_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE,
YAML_EMIT_BLOCK_MAPPING_KEY_STATE,
YAML_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE,
YAML_EMIT_BLOCK_MAPPING_VALUE_STATE, YAML_EMIT_END_STATE);
for enum_yaml_emitter_state_e use (YAML_EMIT_STREAM_START_STATE => 0,
YAML_EMIT_FIRST_DOCUMENT_START_STATE => 1,
YAML_EMIT_DOCUMENT_START_STATE => 2,
YAML_EMIT_DOCUMENT_CONTENT_STATE => 3,
YAML_EMIT_DOCUMENT_END_STATE => 4,
YAML_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE => 5,
YAML_EMIT_FLOW_SEQUENCE_ITEM_STATE => 6,
YAML_EMIT_FLOW_MAPPING_FIRST_KEY_STATE => 7,
YAML_EMIT_FLOW_MAPPING_KEY_STATE => 8,
YAML_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE => 9,
YAML_EMIT_FLOW_MAPPING_VALUE_STATE => 10,
YAML_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE => 11,
YAML_EMIT_BLOCK_SEQUENCE_ITEM_STATE => 12,
YAML_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE => 13,
YAML_EMIT_BLOCK_MAPPING_KEY_STATE => 14,
YAML_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE => 15,
YAML_EMIT_BLOCK_MAPPING_VALUE_STATE => 16, YAML_EMIT_END_STATE => 17);
pragma Convention (C, enum_yaml_emitter_state_e);
type enum_yaml_emitter_state_e_ptr is
access all enum_yaml_emitter_state_e;
for enum_yaml_emitter_state_e_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (enum_yaml_emitter_state_e_ptr);
pragma Convention (C, enum_yaml_emitter_state_e_ptr);
subtype yaml_emitter_state_t is enum_yaml_emitter_state_e;
subtype yaml_emitter_state_t_ptr is enum_yaml_emitter_state_e_ptr;
type struct_yaml_emitter_s;
type struct_a62ac790 is record
buffer : aliased unsigned_char_ptr;
size : aliased stddef.size_t;
size_written : aliased stddef.size_t_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_a62ac790);
type union_44e760a2 (Unchecked_Tag : unsigned_int := 0) is record
case Unchecked_Tag is
when 0 =>
string : struct_a62ac790;
when others =>
file : stdio.FILE_ptr;
end case;
end record;
pragma Unchecked_Union (union_44e760a2);
pragma Convention (C_Pass_By_Copy, union_44e760a2);
type struct_551cb869 is record
start : aliased yaml_char_t_ptr;
F_end : aliased yaml_char_t_ptr;
pointer : aliased yaml_char_t_ptr;
last : aliased yaml_char_t_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_551cb869);
type struct_01364ca5 is record
start : aliased unsigned_char_ptr;
F_end : aliased unsigned_char_ptr;
pointer : aliased unsigned_char_ptr;
last : aliased unsigned_char_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_01364ca5);
type struct_73f3adb7 is record
start : aliased yaml_emitter_state_t_ptr;
F_end : aliased yaml_emitter_state_t_ptr;
top : aliased yaml_emitter_state_t_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_73f3adb7);
type struct_a0aacc03 is record
start : aliased yaml_event_t_ptr;
F_end : aliased yaml_event_t_ptr;
head : aliased yaml_event_t_ptr;
tail : aliased yaml_event_t_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_a0aacc03);
type struct_c26f5e20 is record
start : aliased signed_int_ptr;
F_end : aliased signed_int_ptr;
top : aliased signed_int_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_c26f5e20);
type struct_9fdac2c3 is record
start : aliased yaml_tag_directive_t_ptr;
F_end : aliased yaml_tag_directive_t_ptr;
top : aliased yaml_tag_directive_t_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_9fdac2c3);
type struct_04737e83 is record
anchor : aliased yaml_char_t_ptr;
anchor_length : aliased stddef.size_t;
alias : aliased signed_int;
end record;
pragma Convention (C_Pass_By_Copy, struct_04737e83);
type struct_16277eb4 is record
handle : aliased yaml_char_t_ptr;
handle_length : aliased stddef.size_t;
suffix : aliased yaml_char_t_ptr;
suffix_length : aliased stddef.size_t;
end record;
pragma Convention (C_Pass_By_Copy, struct_16277eb4);
type struct_072d33df is record
value : aliased yaml_char_t_ptr;
length : aliased stddef.size_t;
multiline : aliased signed_int;
flow_plain_allowed : aliased signed_int;
block_plain_allowed : aliased signed_int;
single_quoted_allowed : aliased signed_int;
block_allowed : aliased signed_int;
style : aliased yaml_scalar_style_t;
end record;
pragma Convention (C_Pass_By_Copy, struct_072d33df);
type struct_003bfd05 is record
references : aliased signed_int;
anchor : aliased signed_int;
serialized : aliased signed_int;
end record;
pragma Convention (C_Pass_By_Copy, struct_003bfd05);
type struct_003bfd05_ptr is access all struct_003bfd05;
for struct_003bfd05_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_003bfd05_ptr);
pragma Convention (C, struct_003bfd05_ptr);
type struct_yaml_emitter_s is record
error : aliased yaml_error_type_t;
problem : aliased char_const_ptr;
write_handler : aliased yaml_write_handler_t_ptr;
write_handler_data : aliased void_ptr;
output : aliased union_44e760a2;
buffer : aliased struct_551cb869;
raw_buffer : aliased struct_01364ca5;
encoding : aliased yaml_encoding_t;
canonical : aliased signed_int;
best_indent : aliased signed_int;
best_width : aliased signed_int;
unicode : aliased signed_int;
line_break : aliased yaml_break_t;
states : aliased struct_73f3adb7;
state : aliased yaml_emitter_state_t;
events : aliased struct_a0aacc03;
indents : aliased struct_c26f5e20;
tag_directives : aliased struct_9fdac2c3;
indent : aliased signed_int;
flow_level : aliased signed_int;
root_context : aliased signed_int;
sequence_context : aliased signed_int;
mapping_context : aliased signed_int;
simple_key_context : aliased signed_int;
line : aliased signed_int;
column : aliased signed_int;
whitespace : aliased signed_int;
indention : aliased signed_int;
open_ended : aliased signed_int;
anchor_data : aliased struct_04737e83;
tag_data : aliased struct_16277eb4;
scalar_data : aliased struct_072d33df;
opened : aliased signed_int;
closed : aliased signed_int;
anchors : aliased struct_003bfd05_ptr;
last_anchor_id : aliased signed_int;
document : aliased yaml_document_t_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_yaml_emitter_s);
type struct_yaml_emitter_s_ptr is access all struct_yaml_emitter_s;
for struct_yaml_emitter_s_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_yaml_emitter_s_ptr);
pragma Convention (C, struct_yaml_emitter_s_ptr);
subtype yaml_emitter_t is struct_yaml_emitter_s;
subtype yaml_emitter_t_ptr is struct_yaml_emitter_s_ptr;
function yaml_emitter_initialize (emitter : access yaml_emitter_t)
return signed_int;
pragma Import (C, yaml_emitter_initialize, "yaml_emitter_initialize");
procedure yaml_emitter_delete (emitter : access yaml_emitter_t);
pragma Import (C, yaml_emitter_delete, "yaml_emitter_delete");
procedure yaml_emitter_set_output_string (emitter : access yaml_emitter_t;
output : access unsigned_char; size : stddef.size_t;
size_written : access stddef.size_t);
pragma Import (C, yaml_emitter_set_output_string,
"yaml_emitter_set_output_string");
procedure yaml_emitter_set_output_file (emitter : access yaml_emitter_t;
file : access stdio.FILE);
pragma Import (C, yaml_emitter_set_output_file,
"yaml_emitter_set_output_file");
procedure yaml_emitter_set_output (emitter : access yaml_emitter_t;
handler : yaml_write_handler_t_ptr; data : void_ptr);
pragma Import (C, yaml_emitter_set_output, "yaml_emitter_set_output");
procedure yaml_emitter_set_encoding (emitter : access yaml_emitter_t;
encoding : yaml_encoding_t);
pragma Import (C, yaml_emitter_set_encoding, "yaml_emitter_set_encoding");
procedure yaml_emitter_set_canonical (emitter : access yaml_emitter_t;
canonical : signed_int);
pragma Import (C, yaml_emitter_set_canonical,
"yaml_emitter_set_canonical");
procedure yaml_emitter_set_indent (emitter : access yaml_emitter_t;
indent : signed_int);
pragma Import (C, yaml_emitter_set_indent, "yaml_emitter_set_indent");
procedure yaml_emitter_set_width (emitter : access yaml_emitter_t;
width : signed_int);
pragma Import (C, yaml_emitter_set_width, "yaml_emitter_set_width");
procedure yaml_emitter_set_unicode (emitter : access yaml_emitter_t;
unicode : signed_int);
pragma Import (C, yaml_emitter_set_unicode, "yaml_emitter_set_unicode");
procedure yaml_emitter_set_break (emitter : access yaml_emitter_t;
line_break : yaml_break_t);
pragma Import (C, yaml_emitter_set_break, "yaml_emitter_set_break");
function yaml_emitter_emit (emitter : access yaml_emitter_t;
event : access yaml_event_t) return signed_int;
pragma Import (C, yaml_emitter_emit, "yaml_emitter_emit");
function yaml_emitter_open (emitter : access yaml_emitter_t)
return signed_int;
pragma Import (C, yaml_emitter_open, "yaml_emitter_open");
function yaml_emitter_close (emitter : access yaml_emitter_t)
return signed_int;
pragma Import (C, yaml_emitter_close, "yaml_emitter_close");
function yaml_emitter_dump (emitter : access yaml_emitter_t;
document : access yaml_document_t) return signed_int;
pragma Import (C, yaml_emitter_dump, "yaml_emitter_dump");
function yaml_emitter_flush (emitter : access yaml_emitter_t)
return signed_int;
pragma Import (C, yaml_emitter_flush, "yaml_emitter_flush");
YAML_BOOL_TAG : constant char_array (0 .. 22) := "tag:yaml.org,2002:bool"
& char'Val (0);
-- YAML_DECLARE (function macro)
YAML_DEFAULT_MAPPING_TAG : constant char_array (0 .. 21) :=
"tag:yaml.org,2002:map" & char'Val (0);
YAML_DEFAULT_SCALAR_TAG : constant char_array (0 .. 21) :=
"tag:yaml.org,2002:str" & char'Val (0);
YAML_DEFAULT_SEQUENCE_TAG : constant char_array (0 .. 21) :=
"tag:yaml.org,2002:seq" & char'Val (0);
YAML_FLOAT_TAG : constant char_array (0 .. 23) :=
"tag:yaml.org,2002:float" & char'Val (0);
-- YAML_H (empty)
YAML_INT_TAG : constant char_array (0 .. 21) := "tag:yaml.org,2002:int"
& char'Val (0);
YAML_MAP_TAG : constant char_array (0 .. 21) := "tag:yaml.org,2002:map"
& char'Val (0);
YAML_NULL_TAG : constant char_array (0 .. 22) := "tag:yaml.org,2002:null"
& char'Val (0);
YAML_SEQ_TAG : constant char_array (0 .. 21) := "tag:yaml.org,2002:seq"
& char'Val (0);
YAML_STR_TAG : constant char_array (0 .. 21) := "tag:yaml.org,2002:str"
& char'Val (0);
YAML_TIMESTAMP_TAG : constant char_array (0 .. 27) :=
"tag:yaml.org,2002:timestamp" & char'Val (0);
end C.yaml;
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_array is array (size_t range <>) of
aliased unsigned_char;
pragma Convention (C, unsigned_char_array);
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 unsigned_char_const_ptr is access constant unsigned_char;
for unsigned_char_const_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (unsigned_char_const_ptr);
pragma Convention (C, unsigned_char_const_ptr);
type unsigned_short_array is array (size_t range <>) of
aliased unsigned_short;
pragma Convention (C, unsigned_short_array);
type unsigned_short_ptr is access all unsigned_short;
for unsigned_short_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (unsigned_short_ptr);
pragma Convention (C, unsigned_short_ptr);
type unsigned_short_const_ptr is access constant unsigned_short;
for unsigned_short_const_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (unsigned_short_const_ptr);
pragma Convention (C, unsigned_short_const_ptr);
type signed_int_array is array (size_t range <>) of aliased signed_int;
pragma Convention (C, signed_int_array);
type signed_int_ptr is access all signed_int;
for signed_int_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (signed_int_ptr);
pragma Convention (C, signed_int_ptr);
type signed_int_volatile is new signed_int;
pragma Volatile (signed_int_volatile);
type signed_int_const_ptr is access constant signed_int;
for signed_int_const_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (signed_int_const_ptr);
pragma Convention (C, signed_int_const_ptr);
type unsigned_int_ptr is access all unsigned_int;
for unsigned_int_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (unsigned_int_ptr);
pragma Convention (C, unsigned_int_ptr);
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 signed_long_array is array (size_t range <>) of aliased signed_long;
pragma Convention (C, signed_long_array);
type unsigned_long_array is array (size_t range <>) of
aliased unsigned_long;
pragma Convention (C, unsigned_long_array);
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 double_ptr is access all double;
for double_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (double_ptr);
pragma Convention (C, double_ptr);
type double_array is array (size_t range <>) of aliased double;
pragma Convention (C, double_array);
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_ptr_ptr is access all char_ptr;
for char_ptr_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (char_ptr_ptr);
pragma Convention (C, char_ptr_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_const_ptr_array is array (size_t range <>) of
aliased char_const_ptr;
pragma Convention (C, char_const_ptr_array);
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."=";
type size_t_ptr is access all size_t;
for size_t_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (size_t_ptr);
pragma Convention (C, size_t_ptr);
type wchar_t_ptr is access all wchar_t;
for wchar_t_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (wchar_t_ptr);
pragma Convention (C, wchar_t_ptr);
type wchar_t_const_ptr is access constant wchar_t;
for wchar_t_const_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (wchar_t_const_ptr);
pragma Convention (C, wchar_t_const_ptr);
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