Skip to content

Instantly share code, notes, and snippets.

@ytomino

ytomino/c-alloca.ads

Last active June 10, 2021 15:03
Show Gist options
  • Save ytomino/fe32e2cd5abda8857d70b74c339efaed to your computer and use it in GitHub Desktop.
Save ytomino/fe32e2cd5abda8857d70b74c339efaed to your computer and use it in GitHub Desktop.
Download ZIP
libxml2 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-local_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.local_lim is
pragma Preelaborate;
AIO_PRIO_DELTA_MAX : constant := 20;
DELAYTIMER_MAX : constant := 2147483647;
HOST_NAME_MAX : constant := 64;
LOGIN_NAME_MAX : constant := 256;
MQ_PRIO_MAX : constant := 32768;
PTHREAD_DESTRUCTOR_ITERATIONS : constant := 4;
PTHREAD_KEYS_MAX : constant := 1024;
PTHREAD_STACK_MIN : constant := 16384;
SEM_VALUE_MAX : constant := 2147483647;
TTY_NAME_MAX : constant := 32;
POSIX_THREAD_DESTRUCTOR_ITERATIONS : constant := 4;
POSIX_THREAD_KEYS_MAX : constant := 128;
POSIX_THREAD_THREADS_MAX : constant := 64;
end C.bits.local_lim;
Raw
c-bits-posix1_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.posix1_lim is
pragma Preelaborate;
SSIZE_MAX : constant := 9223372036854775807;
BITS_POSIX1_LIM_H : constant := 1;
POSIX_AIO_LISTIO_MAX : constant := 2;
POSIX_AIO_MAX : constant := 1;
POSIX_ARG_MAX : constant := 4096;
POSIX_CHILD_MAX : constant := 25;
POSIX_CLOCKRES_MIN : constant := 20000000;
POSIX_DELAYTIMER_MAX : constant := 32;
POSIX_HOST_NAME_MAX : constant := 255;
POSIX_LINK_MAX : constant := 8;
POSIX_LOGIN_NAME_MAX : constant := 9;
POSIX_MAX_CANON : constant := 255;
POSIX_MAX_INPUT : constant := 255;
POSIX_MQ_OPEN_MAX : constant := 8;
POSIX_MQ_PRIO_MAX : constant := 32;
POSIX_NAME_MAX : constant := 14;
POSIX_NGROUPS_MAX : constant := 8;
POSIX_OPEN_MAX : constant := 20;
POSIX_PATH_MAX : constant := 256;
POSIX_PIPE_BUF : constant := 512;
POSIX_RE_DUP_MAX : constant := 255;
POSIX_RTSIG_MAX : constant := 8;
POSIX_SEM_NSEMS_MAX : constant := 256;
POSIX_SEM_VALUE_MAX : constant := 32767;
POSIX_SIGQUEUE_MAX : constant := 32;
POSIX_SSIZE_MAX : constant := 32767;
POSIX_STREAM_MAX : constant := 8;
POSIX_SYMLINK_MAX : constant := 255;
POSIX_SYMLOOP_MAX : constant := 8;
POSIX_TIMER_MAX : constant := 32;
POSIX_TTY_NAME_MAX : constant := 9;
POSIX_TZNAME_MAX : constant := 6;
end C.bits.posix1_lim;
Raw
c-bits-posix2_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.posix2_lim is
pragma Preelaborate;
BC_BASE_MAX : constant := 99;
BC_DIM_MAX : constant := 2048;
BC_SCALE_MAX : constant := 99;
BC_STRING_MAX : constant := 1000;
CHARCLASS_NAME_MAX : constant := 2048;
COLL_WEIGHTS_MAX : constant := 255;
EXPR_NEST_MAX : constant := 32;
LINE_MAX : constant := 2048;
RE_DUP_MAX : constant := 32767;
BITS_POSIX2_LIM_H : constant := 1;
POSIX2_BC_BASE_MAX : constant := 99;
POSIX2_BC_DIM_MAX : constant := 2048;
POSIX2_BC_SCALE_MAX : constant := 99;
POSIX2_BC_STRING_MAX : constant := 1000;
POSIX2_CHARCLASS_NAME_MAX : constant := 14;
POSIX2_COLL_WEIGHTS_MAX : constant := 2;
POSIX2_EXPR_NEST_MAX : constant := 32;
POSIX2_LINE_MAX : constant := 2048;
POSIX2_RE_DUP_MAX : constant := 255;
end C.bits.posix2_lim;
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-iconv.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.iconv is
pragma Preelaborate;
subtype iconv_t is void_ptr;
function iconv_open (tocode : access constant char;
fromcode : access constant char) return iconv_t;
pragma Import (C, iconv_open, "iconv_open");
function iconv (cd : iconv_t; inbuf : access char_ptr;
inbytesleft : access stddef.size_t; outbuf : access char_ptr;
outbytesleft : access stddef.size_t) return stddef.size_t;
pragma Import (C, iconv, "iconv");
function iconv_close (cd : iconv_t) return signed_int;
pragma Import (C, iconv_close, "iconv_close");
ICONV_H : constant := 1;
end C.iconv;
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-libxml-dict.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.libxml.xmlstring;
with C.stddef;
package C.libxml.dict is
pragma Preelaborate;
type struct_xmlDict (<>) is limited private;
type struct_xmlDict_ptr is access all struct_xmlDict;
for struct_xmlDict_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlDict_ptr);
pragma Convention (C, struct_xmlDict_ptr);
subtype xmlDict is struct_xmlDict;
subtype xmlDict_ptr is struct_xmlDict_ptr;
subtype xmlDictPtr is xmlDict_ptr;
function xmlInitializeDict return signed_int;
pragma Import (C, xmlInitializeDict, "xmlInitializeDict");
function xmlDictCreate return xmlDictPtr;
pragma Import (C, xmlDictCreate, "xmlDictCreate");
function xmlDictSetLimit (dict : access xmlDict; limit : stddef.size_t)
return stddef.size_t;
pragma Import (C, xmlDictSetLimit, "xmlDictSetLimit");
function xmlDictGetUsage (dict : access xmlDict) return stddef.size_t;
pragma Import (C, xmlDictGetUsage, "xmlDictGetUsage");
function xmlDictCreateSub (sub : access xmlDict) return xmlDictPtr;
pragma Import (C, xmlDictCreateSub, "xmlDictCreateSub");
function xmlDictReference (dict : access xmlDict) return signed_int;
pragma Import (C, xmlDictReference, "xmlDictReference");
procedure xmlDictFree (dict : access xmlDict);
pragma Import (C, xmlDictFree, "xmlDictFree");
function xmlDictLookup (dict : access xmlDict;
name : access constant xmlstring.xmlChar; len : signed_int)
return xmlstring.xmlChar_const_ptr;
pragma Import (C, xmlDictLookup, "xmlDictLookup");
function xmlDictExists (dict : access xmlDict;
name : access constant xmlstring.xmlChar; len : signed_int)
return xmlstring.xmlChar_const_ptr;
pragma Import (C, xmlDictExists, "xmlDictExists");
function xmlDictQLookup (dict : access xmlDict;
prefix : access constant xmlstring.xmlChar;
name : access constant xmlstring.xmlChar)
return xmlstring.xmlChar_const_ptr;
pragma Import (C, xmlDictQLookup, "xmlDictQLookup");
function xmlDictOwns (dict : access xmlDict;
str : access constant xmlstring.xmlChar) return signed_int;
pragma Import (C, xmlDictOwns, "xmlDictOwns");
function xmlDictSize (dict : access xmlDict) return signed_int;
pragma Import (C, xmlDictSize, "xmlDictSize");
procedure xmlDictCleanup;
pragma Import (C, xmlDictCleanup, "xmlDictCleanup");
-- __XML_DICT_H__ (empty)
-- __XML_EXTERNC (empty)
private
type struct_xmlDict is null record;
end C.libxml.dict;
Raw
c-libxml-encoding.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.iconv;
with C.libxml.tree;
package C.libxml.encoding is
pragma Preelaborate;
type enum_792010d5 is (XML_CHAR_ENCODING_ERROR, XML_CHAR_ENCODING_NONE,
XML_CHAR_ENCODING_UTF8, XML_CHAR_ENCODING_UTF16LE,
XML_CHAR_ENCODING_UTF16BE, XML_CHAR_ENCODING_UCS4LE,
XML_CHAR_ENCODING_UCS4BE, XML_CHAR_ENCODING_EBCDIC,
XML_CHAR_ENCODING_UCS4_2143, XML_CHAR_ENCODING_UCS4_3412,
XML_CHAR_ENCODING_UCS2, XML_CHAR_ENCODING_8859_1,
XML_CHAR_ENCODING_8859_2, XML_CHAR_ENCODING_8859_3,
XML_CHAR_ENCODING_8859_4, XML_CHAR_ENCODING_8859_5,
XML_CHAR_ENCODING_8859_6, XML_CHAR_ENCODING_8859_7,
XML_CHAR_ENCODING_8859_8, XML_CHAR_ENCODING_8859_9,
XML_CHAR_ENCODING_2022_JP, XML_CHAR_ENCODING_SHIFT_JIS,
XML_CHAR_ENCODING_EUC_JP, XML_CHAR_ENCODING_ASCII);
for enum_792010d5 use (XML_CHAR_ENCODING_ERROR => -1,
XML_CHAR_ENCODING_NONE => 0, XML_CHAR_ENCODING_UTF8 => 1,
XML_CHAR_ENCODING_UTF16LE => 2, XML_CHAR_ENCODING_UTF16BE => 3,
XML_CHAR_ENCODING_UCS4LE => 4, XML_CHAR_ENCODING_UCS4BE => 5,
XML_CHAR_ENCODING_EBCDIC => 6, XML_CHAR_ENCODING_UCS4_2143 => 7,
XML_CHAR_ENCODING_UCS4_3412 => 8, XML_CHAR_ENCODING_UCS2 => 9,
XML_CHAR_ENCODING_8859_1 => 10, XML_CHAR_ENCODING_8859_2 => 11,
XML_CHAR_ENCODING_8859_3 => 12, XML_CHAR_ENCODING_8859_4 => 13,
XML_CHAR_ENCODING_8859_5 => 14, XML_CHAR_ENCODING_8859_6 => 15,
XML_CHAR_ENCODING_8859_7 => 16, XML_CHAR_ENCODING_8859_8 => 17,
XML_CHAR_ENCODING_8859_9 => 18, XML_CHAR_ENCODING_2022_JP => 19,
XML_CHAR_ENCODING_SHIFT_JIS => 20, XML_CHAR_ENCODING_EUC_JP => 21,
XML_CHAR_ENCODING_ASCII => 22);
pragma Convention (C, enum_792010d5);
subtype xmlCharEncoding is enum_792010d5;
type access_ffe771b2 is access function (A_out : access unsigned_char;
outlen : access signed_int; A_in : access constant unsigned_char;
inlen : access signed_int) return signed_int;
pragma Convention (C, access_ffe771b2);
subtype xmlCharEncodingInputFunc is access_ffe771b2;
type access_8bffccd9 is access function (A_out : access unsigned_char;
outlen : access signed_int; A_in : access constant unsigned_char;
inlen : access signed_int) return signed_int;
pragma Convention (C, access_8bffccd9);
subtype xmlCharEncodingOutputFunc is access_8bffccd9;
type struct_xmlCharEncodingHandler;
type struct_xmlCharEncodingHandler_ptr is
access all struct_xmlCharEncodingHandler;
for struct_xmlCharEncodingHandler_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlCharEncodingHandler_ptr);
pragma Convention (C, struct_xmlCharEncodingHandler_ptr);
subtype xmlCharEncodingHandler is struct_xmlCharEncodingHandler;
subtype xmlCharEncodingHandler_ptr is struct_xmlCharEncodingHandler_ptr;
subtype xmlCharEncodingHandlerPtr is xmlCharEncodingHandler_ptr;
type struct_xmlCharEncodingHandler is record
name : aliased char_ptr;
input : aliased xmlCharEncodingInputFunc;
output : aliased xmlCharEncodingOutputFunc;
iconv_in : aliased iconv.iconv_t;
iconv_out : aliased iconv.iconv_t;
end record;
pragma Convention (C_Pass_By_Copy, struct_xmlCharEncodingHandler);
procedure xmlInitCharEncodingHandlers;
pragma Import (C, xmlInitCharEncodingHandlers,
"xmlInitCharEncodingHandlers");
procedure xmlCleanupCharEncodingHandlers;
pragma Import (C, xmlCleanupCharEncodingHandlers,
"xmlCleanupCharEncodingHandlers");
procedure xmlRegisterCharEncodingHandler (
handler : access xmlCharEncodingHandler);
pragma Import (C, xmlRegisterCharEncodingHandler,
"xmlRegisterCharEncodingHandler");
function xmlGetCharEncodingHandler (enc : xmlCharEncoding)
return xmlCharEncodingHandlerPtr;
pragma Import (C, xmlGetCharEncodingHandler, "xmlGetCharEncodingHandler");
function xmlFindCharEncodingHandler (name : access constant char)
return xmlCharEncodingHandlerPtr;
pragma Import (C, xmlFindCharEncodingHandler,
"xmlFindCharEncodingHandler");
function xmlNewCharEncodingHandler (name : access constant char;
input : xmlCharEncodingInputFunc; output : xmlCharEncodingOutputFunc)
return xmlCharEncodingHandlerPtr;
pragma Import (C, xmlNewCharEncodingHandler, "xmlNewCharEncodingHandler");
function xmlAddEncodingAlias (name : access constant char;
alias : access constant char) return signed_int;
pragma Import (C, xmlAddEncodingAlias, "xmlAddEncodingAlias");
function xmlDelEncodingAlias (alias : access constant char)
return signed_int;
pragma Import (C, xmlDelEncodingAlias, "xmlDelEncodingAlias");
function xmlGetEncodingAlias (alias : access constant char)
return char_const_ptr;
pragma Import (C, xmlGetEncodingAlias, "xmlGetEncodingAlias");
procedure xmlCleanupEncodingAliases;
pragma Import (C, xmlCleanupEncodingAliases, "xmlCleanupEncodingAliases");
function xmlParseCharEncoding (name : access constant char)
return xmlCharEncoding;
pragma Import (C, xmlParseCharEncoding, "xmlParseCharEncoding");
function xmlGetCharEncodingName (enc : xmlCharEncoding)
return char_const_ptr;
pragma Import (C, xmlGetCharEncodingName, "xmlGetCharEncodingName");
function xmlDetectCharEncoding (A_in : access constant unsigned_char;
len : signed_int) return xmlCharEncoding;
pragma Import (C, xmlDetectCharEncoding, "xmlDetectCharEncoding");
function xmlCharEncOutFunc (handler : access xmlCharEncodingHandler;
A_out : access tree.xmlBuffer; A_in : access tree.xmlBuffer)
return signed_int;
pragma Import (C, xmlCharEncOutFunc, "xmlCharEncOutFunc");
function xmlCharEncInFunc (handler : access xmlCharEncodingHandler;
A_out : access tree.xmlBuffer; A_in : access tree.xmlBuffer)
return signed_int;
pragma Import (C, xmlCharEncInFunc, "xmlCharEncInFunc");
function xmlCharEncFirstLine (handler : access xmlCharEncodingHandler;
A_out : access tree.xmlBuffer; A_in : access tree.xmlBuffer)
return signed_int;
pragma Import (C, xmlCharEncFirstLine, "xmlCharEncFirstLine");
function xmlCharEncCloseFunc (handler : access xmlCharEncodingHandler)
return signed_int;
pragma Import (C, xmlCharEncCloseFunc, "xmlCharEncCloseFunc");
function UTF8Toisolat1 (A_out : access unsigned_char;
outlen : access signed_int; A_in : access constant unsigned_char;
inlen : access signed_int) return signed_int;
pragma Import (C, UTF8Toisolat1, "UTF8Toisolat1");
function isolat1ToUTF8 (A_out : access unsigned_char;
outlen : access signed_int; A_in : access constant unsigned_char;
inlen : access signed_int) return signed_int;
pragma Import (C, isolat1ToUTF8, "isolat1ToUTF8");
-- __XML_CHAR_ENCODING_H__ (empty)
end C.libxml.encoding;
Raw
c-libxml-entities.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.libxml.hash;
with C.libxml.tree;
with C.libxml.xmlstring;
package C.libxml.entities is
pragma Preelaborate;
type struct_xmlEntity;
type enum_cd5e9fb6 is (XML_INTERNAL_GENERAL_ENTITY,
XML_EXTERNAL_GENERAL_PARSED_ENTITY,
XML_EXTERNAL_GENERAL_UNPARSED_ENTITY, XML_INTERNAL_PARAMETER_ENTITY,
XML_EXTERNAL_PARAMETER_ENTITY, XML_INTERNAL_PREDEFINED_ENTITY);
for enum_cd5e9fb6 use (XML_INTERNAL_GENERAL_ENTITY => 1,
XML_EXTERNAL_GENERAL_PARSED_ENTITY => 2,
XML_EXTERNAL_GENERAL_UNPARSED_ENTITY => 3,
XML_INTERNAL_PARAMETER_ENTITY => 4, XML_EXTERNAL_PARAMETER_ENTITY => 5,
XML_INTERNAL_PREDEFINED_ENTITY => 6);
pragma Convention (C, enum_cd5e9fb6);
subtype xmlEntityType is enum_cd5e9fb6;
type struct_xmlEntity is record
F_private : aliased void_ptr;
F_type : aliased tree.xmlElementType;
name : aliased xmlstring.xmlChar_const_ptr;
children : aliased tree.struct_xmlNode_ptr;
last : aliased tree.struct_xmlNode_ptr;
parent : aliased tree.struct_xmlDtd_ptr;
next : aliased tree.struct_xmlNode_ptr;
prev : aliased tree.struct_xmlNode_ptr;
doc : aliased tree.struct_xmlDoc_ptr;
orig : aliased xmlstring.xmlChar_ptr;
content : aliased xmlstring.xmlChar_ptr;
length : aliased signed_int;
etype : aliased xmlEntityType;
ExternalID : aliased xmlstring.xmlChar_const_ptr;
SystemID : aliased xmlstring.xmlChar_const_ptr;
nexte : aliased tree.struct_xmlEntity_ptr;
URI : aliased xmlstring.xmlChar_const_ptr;
owner : aliased signed_int;
checked : aliased signed_int;
end record;
pragma Convention (C_Pass_By_Copy, struct_xmlEntity);
subtype xmlEntitiesTable is hash.struct_xmlHashTable;
subtype xmlEntitiesTable_ptr is hash.struct_xmlHashTable_ptr;
subtype xmlEntitiesTablePtr is xmlEntitiesTable_ptr;
procedure xmlInitializePredefinedEntities;
pragma Import (C, xmlInitializePredefinedEntities,
"xmlInitializePredefinedEntities");
function xmlNewEntity (doc : access tree.xmlDoc;
name : access constant xmlstring.xmlChar; A_type : signed_int;
ExternalID : access constant xmlstring.xmlChar;
SystemID : access constant xmlstring.xmlChar;
content : access constant xmlstring.xmlChar) return tree.xmlEntityPtr;
pragma Import (C, xmlNewEntity, "xmlNewEntity");
function xmlAddDocEntity (doc : access tree.xmlDoc;
name : access constant xmlstring.xmlChar; A_type : signed_int;
ExternalID : access constant xmlstring.xmlChar;
SystemID : access constant xmlstring.xmlChar;
content : access constant xmlstring.xmlChar) return tree.xmlEntityPtr;
pragma Import (C, xmlAddDocEntity, "xmlAddDocEntity");
function xmlAddDtdEntity (doc : access tree.xmlDoc;
name : access constant xmlstring.xmlChar; A_type : signed_int;
ExternalID : access constant xmlstring.xmlChar;
SystemID : access constant xmlstring.xmlChar;
content : access constant xmlstring.xmlChar) return tree.xmlEntityPtr;
pragma Import (C, xmlAddDtdEntity, "xmlAddDtdEntity");
function xmlGetPredefinedEntity (name : access constant xmlstring.xmlChar)
return tree.xmlEntityPtr;
pragma Import (C, xmlGetPredefinedEntity, "xmlGetPredefinedEntity");
function xmlGetDocEntity (doc : access constant tree.xmlDoc;
name : access constant xmlstring.xmlChar) return tree.xmlEntityPtr;
pragma Import (C, xmlGetDocEntity, "xmlGetDocEntity");
function xmlGetDtdEntity (doc : access tree.xmlDoc;
name : access constant xmlstring.xmlChar) return tree.xmlEntityPtr;
pragma Import (C, xmlGetDtdEntity, "xmlGetDtdEntity");
function xmlGetParameterEntity (doc : access tree.xmlDoc;
name : access constant xmlstring.xmlChar) return tree.xmlEntityPtr;
pragma Import (C, xmlGetParameterEntity, "xmlGetParameterEntity");
function xmlEncodeEntities (doc : access tree.xmlDoc;
input : access constant xmlstring.xmlChar)
return xmlstring.xmlChar_const_ptr;
pragma Import (C, xmlEncodeEntities, "xmlEncodeEntities");
function xmlEncodeEntitiesReentrant (doc : access tree.xmlDoc;
input : access constant xmlstring.xmlChar)
return xmlstring.xmlChar_ptr;
pragma Import (C, xmlEncodeEntitiesReentrant,
"xmlEncodeEntitiesReentrant");
function xmlEncodeSpecialChars (doc : access constant tree.xmlDoc;
input : access constant xmlstring.xmlChar)
return xmlstring.xmlChar_ptr;
pragma Import (C, xmlEncodeSpecialChars, "xmlEncodeSpecialChars");
function xmlCreateEntitiesTable return xmlEntitiesTablePtr;
pragma Import (C, xmlCreateEntitiesTable, "xmlCreateEntitiesTable");
function xmlCopyEntitiesTable (table : access xmlEntitiesTable)
return xmlEntitiesTablePtr;
pragma Import (C, xmlCopyEntitiesTable, "xmlCopyEntitiesTable");
procedure xmlFreeEntitiesTable (table : access xmlEntitiesTable);
pragma Import (C, xmlFreeEntitiesTable, "xmlFreeEntitiesTable");
procedure xmlDumpEntitiesTable (buf : access tree.xmlBuffer;
table : access xmlEntitiesTable);
pragma Import (C, xmlDumpEntitiesTable, "xmlDumpEntitiesTable");
procedure xmlDumpEntityDecl (buf : access tree.xmlBuffer;
ent : access struct_xmlEntity);
pragma Import (C, xmlDumpEntityDecl, "xmlDumpEntityDecl");
procedure xmlCleanupPredefinedEntities;
pragma Import (C, xmlCleanupPredefinedEntities,
"xmlCleanupPredefinedEntities");
-- __XML_ENTITIES_H__ (empty)
end C.libxml.entities;
Raw
c-libxml-globals.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.libxml.globals is
function docbDefaultSAXHandler return parser.xmlSAXHandlerV1 is
begin
return qqdocbDefaultSAXHandler.all;
end docbDefaultSAXHandler;
function htmlDefaultSAXHandler return parser.xmlSAXHandlerV1 is
begin
return qqhtmlDefaultSAXHandler.all;
end htmlDefaultSAXHandler;
function oldXMLWDcompatibility return signed_int is
begin
return qqoldXMLWDcompatibility.all;
end oldXMLWDcompatibility;
function xmlBufferAllocScheme return tree.xmlBufferAllocationScheme is
begin
return qqxmlBufferAllocScheme.all;
end xmlBufferAllocScheme;
function xmlDefaultBufferSize return signed_int is
begin
return qqxmlDefaultBufferSize.all;
end xmlDefaultBufferSize;
function xmlDefaultSAXHandler return parser.xmlSAXHandlerV1 is
begin
return qqxmlDefaultSAXHandler.all;
end xmlDefaultSAXHandler;
function xmlDeregisterNodeDefaultValue return xmlDeregisterNodeFunc is
begin
return qqxmlDeregisterNodeDefaultValue.all;
end xmlDeregisterNodeDefaultValue;
function xmlDoValidityCheckingDefaultValue return signed_int is
begin
return qqxmlDoValidityCheckingDefaultValue.all;
end xmlDoValidityCheckingDefaultValue;
function xmlGenericError return xmlerror.xmlGenericErrorFunc is
begin
return qqxmlGenericError.all;
end xmlGenericError;
function xmlGenericErrorContext return void_ptr is
begin
return qqxmlGenericErrorContext.all;
end xmlGenericErrorContext;
function xmlGetWarningsDefaultValue return signed_int is
begin
return qqxmlGetWarningsDefaultValue.all;
end xmlGetWarningsDefaultValue;
function xmlIndentTreeOutput return signed_int is
begin
return qqxmlIndentTreeOutput.all;
end xmlIndentTreeOutput;
function xmlKeepBlanksDefaultValue return signed_int is
begin
return qqxmlKeepBlanksDefaultValue.all;
end xmlKeepBlanksDefaultValue;
function xmlLastError return xmlerror.xmlError is
begin
return qqxmlLastError.all;
end xmlLastError;
function xmlLineNumbersDefaultValue return signed_int is
begin
return qqxmlLineNumbersDefaultValue.all;
end xmlLineNumbersDefaultValue;
function xmlLoadExtDtdDefaultValue return signed_int is
begin
return qqxmlLoadExtDtdDefaultValue.all;
end xmlLoadExtDtdDefaultValue;
function xmlOutputBufferCreateFilenameValue
return xmlOutputBufferCreateFilenameFunc is
begin
return qqxmlOutputBufferCreateFilenameValue.all;
end xmlOutputBufferCreateFilenameValue;
function xmlParserDebugEntities return signed_int is
begin
return qqxmlParserDebugEntities.all;
end xmlParserDebugEntities;
function xmlParserInputBufferCreateFilenameValue
return xmlParserInputBufferCreateFilenameFunc is
begin
return qqxmlParserInputBufferCreateFilenameValue.all;
end xmlParserInputBufferCreateFilenameValue;
function xmlParserVersion return char_const_ptr is
begin
return qqxmlParserVersion.all;
end xmlParserVersion;
function xmlPedanticParserDefaultValue return signed_int is
begin
return qqxmlPedanticParserDefaultValue.all;
end xmlPedanticParserDefaultValue;
function xmlRegisterNodeDefaultValue return xmlRegisterNodeFunc is
begin
return qqxmlRegisterNodeDefaultValue.all;
end xmlRegisterNodeDefaultValue;
function xmlSaveNoEmptyTags return signed_int is
begin
return qqxmlSaveNoEmptyTags.all;
end xmlSaveNoEmptyTags;
function xmlStructuredError return xmlerror.xmlStructuredErrorFunc is
begin
return qqxmlStructuredError.all;
end xmlStructuredError;
function xmlStructuredErrorContext return void_ptr is
begin
return qqxmlStructuredErrorContext.all;
end xmlStructuredErrorContext;
function xmlSubstituteEntitiesDefaultValue return signed_int is
begin
return qqxmlSubstituteEntitiesDefaultValue.all;
end xmlSubstituteEntitiesDefaultValue;
function xmlTreeIndentString return char_const_ptr is
begin
return qqxmlTreeIndentString.all;
end xmlTreeIndentString;
end C.libxml.globals;
Raw
c-libxml-globals.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.libxml.encoding;
with C.libxml.parser;
with C.libxml.tree;
with C.libxml.xmlerror;
with C.libxml.xmlmemory;
package C.libxml.globals is
pragma Preelaborate;
procedure xmlInitGlobals;
pragma Import (C, xmlInitGlobals, "xmlInitGlobals");
procedure xmlCleanupGlobals;
pragma Import (C, xmlCleanupGlobals, "xmlCleanupGlobals");
type access_ea54fa47 is access function (URI : access constant char;
enc : encoding.xmlCharEncoding) return tree.xmlParserInputBufferPtr;
pragma Convention (C, access_ea54fa47);
type access_ea54fa47_ptr is access all access_ea54fa47;
for access_ea54fa47_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (access_ea54fa47_ptr);
pragma Convention (C, access_ea54fa47_ptr);
subtype xmlParserInputBufferCreateFilenameFunc is access_ea54fa47;
subtype xmlParserInputBufferCreateFilenameFunc_ptr is access_ea54fa47_ptr;
type access_324898d9 is access function (URI : access constant char;
encoder : access encoding.xmlCharEncodingHandler;
compression : signed_int) return tree.xmlOutputBufferPtr;
pragma Convention (C, access_324898d9);
type access_324898d9_ptr is access all access_324898d9;
for access_324898d9_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (access_324898d9_ptr);
pragma Convention (C, access_324898d9_ptr);
subtype xmlOutputBufferCreateFilenameFunc is access_324898d9;
subtype xmlOutputBufferCreateFilenameFunc_ptr is access_324898d9_ptr;
function xmlParserInputBufferCreateFilenameDefault (
func : xmlParserInputBufferCreateFilenameFunc)
return xmlParserInputBufferCreateFilenameFunc;
pragma Import (C, xmlParserInputBufferCreateFilenameDefault,
"xmlParserInputBufferCreateFilenameDefault");
function xmlOutputBufferCreateFilenameDefault (
func : xmlOutputBufferCreateFilenameFunc)
return xmlOutputBufferCreateFilenameFunc;
pragma Import (C, xmlOutputBufferCreateFilenameDefault,
"xmlOutputBufferCreateFilenameDefault");
type access_d145aa5d is access procedure (node : access tree.xmlNode);
pragma Convention (C, access_d145aa5d);
type access_d145aa5d_ptr is access all access_d145aa5d;
for access_d145aa5d_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (access_d145aa5d_ptr);
pragma Convention (C, access_d145aa5d_ptr);
subtype xmlRegisterNodeFunc is access_d145aa5d;
subtype xmlRegisterNodeFunc_ptr is access_d145aa5d_ptr;
type access_71009841 is access procedure (node : access tree.xmlNode);
pragma Convention (C, access_71009841);
type access_71009841_ptr is access all access_71009841;
for access_71009841_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (access_71009841_ptr);
pragma Convention (C, access_71009841_ptr);
subtype xmlDeregisterNodeFunc is access_71009841;
subtype xmlDeregisterNodeFunc_ptr is access_71009841_ptr;
type struct_xmlGlobalState;
type struct_xmlGlobalState_ptr is access all struct_xmlGlobalState;
for struct_xmlGlobalState_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlGlobalState_ptr);
pragma Convention (C, struct_xmlGlobalState_ptr);
subtype xmlGlobalState is struct_xmlGlobalState;
subtype xmlGlobalState_ptr is struct_xmlGlobalState_ptr;
subtype xmlGlobalStatePtr is xmlGlobalState_ptr;
type struct_xmlGlobalState is record
xmlParserVersion : aliased char_const_ptr;
xmlDefaultSAXLocator : aliased parser.struct_xmlSAXLocator;
xmlDefaultSAXHandler : aliased parser.xmlSAXHandlerV1;
docbDefaultSAXHandler : aliased parser.xmlSAXHandlerV1;
htmlDefaultSAXHandler : aliased parser.xmlSAXHandlerV1;
xmlFree : aliased xmlmemory.xmlFreeFunc;
xmlMalloc : aliased xmlmemory.xmlMallocFunc;
xmlMemStrdup : aliased xmlmemory.xmlStrdupFunc;
xmlRealloc : aliased xmlmemory.xmlReallocFunc;
xmlGenericError : aliased xmlerror.xmlGenericErrorFunc;
xmlStructuredError : aliased xmlerror.xmlStructuredErrorFunc;
xmlGenericErrorContext : aliased void_ptr;
oldXMLWDcompatibility : aliased signed_int;
xmlBufferAllocScheme : aliased tree.xmlBufferAllocationScheme;
xmlDefaultBufferSize : aliased signed_int;
xmlSubstituteEntitiesDefaultValue : aliased signed_int;
xmlDoValidityCheckingDefaultValue : aliased signed_int;
xmlGetWarningsDefaultValue : aliased signed_int;
xmlKeepBlanksDefaultValue : aliased signed_int;
xmlLineNumbersDefaultValue : aliased signed_int;
xmlLoadExtDtdDefaultValue : aliased signed_int;
xmlParserDebugEntities : aliased signed_int;
xmlPedanticParserDefaultValue : aliased signed_int;
xmlSaveNoEmptyTags : aliased signed_int;
xmlIndentTreeOutput : aliased signed_int;
xmlTreeIndentString : aliased char_const_ptr;
xmlRegisterNodeDefaultValue : aliased xmlRegisterNodeFunc;
xmlDeregisterNodeDefaultValue : aliased xmlDeregisterNodeFunc;
xmlMallocAtomic : aliased xmlmemory.xmlMallocFunc;
xmlLastError : aliased xmlerror.xmlError;
xmlParserInputBufferCreateFilenameValue :
aliased xmlParserInputBufferCreateFilenameFunc;
xmlOutputBufferCreateFilenameValue :
aliased xmlOutputBufferCreateFilenameFunc;
xmlStructuredErrorContext : aliased void_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_xmlGlobalState);
procedure xmlInitializeGlobalState (gs : access xmlGlobalState);
pragma Import (C, xmlInitializeGlobalState, "xmlInitializeGlobalState");
procedure xmlThrDefSetGenericErrorFunc (ctx : void_ptr;
handler : xmlerror.xmlGenericErrorFunc);
pragma Import (C, xmlThrDefSetGenericErrorFunc,
"xmlThrDefSetGenericErrorFunc");
procedure xmlThrDefSetStructuredErrorFunc (ctx : void_ptr;
handler : xmlerror.xmlStructuredErrorFunc);
pragma Import (C, xmlThrDefSetStructuredErrorFunc,
"xmlThrDefSetStructuredErrorFunc");
function xmlRegisterNodeDefault (func : xmlRegisterNodeFunc)
return xmlRegisterNodeFunc;
pragma Import (C, xmlRegisterNodeDefault, "xmlRegisterNodeDefault");
function xmlThrDefRegisterNodeDefault (func : xmlRegisterNodeFunc)
return xmlRegisterNodeFunc;
pragma Import (C, xmlThrDefRegisterNodeDefault,
"xmlThrDefRegisterNodeDefault");
function xmlDeregisterNodeDefault (func : xmlDeregisterNodeFunc)
return xmlDeregisterNodeFunc;
pragma Import (C, xmlDeregisterNodeDefault, "xmlDeregisterNodeDefault");
function xmlThrDefDeregisterNodeDefault (func : xmlDeregisterNodeFunc)
return xmlDeregisterNodeFunc;
pragma Import (C, xmlThrDefDeregisterNodeDefault,
"xmlThrDefDeregisterNodeDefault");
function xmlThrDefOutputBufferCreateFilenameDefault (
func : xmlOutputBufferCreateFilenameFunc)
return xmlOutputBufferCreateFilenameFunc;
pragma Import (C, xmlThrDefOutputBufferCreateFilenameDefault,
"xmlThrDefOutputBufferCreateFilenameDefault");
function xmlThrDefParserInputBufferCreateFilenameDefault (
func : xmlParserInputBufferCreateFilenameFunc)
return xmlParserInputBufferCreateFilenameFunc;
pragma Import (C, xmlThrDefParserInputBufferCreateFilenameDefault,
"xmlThrDefParserInputBufferCreateFilenameDefault");
xmlMalloc : aliased xmlmemory.xmlMallocFunc;
pragma Import (C, xmlMalloc, "xmlMalloc");
xmlMallocAtomic : aliased xmlmemory.xmlMallocFunc;
pragma Import (C, xmlMallocAtomic, "xmlMallocAtomic");
xmlRealloc : aliased xmlmemory.xmlReallocFunc;
pragma Import (C, xmlRealloc, "xmlRealloc");
xmlFree : aliased xmlmemory.xmlFreeFunc;
pragma Import (C, xmlFree, "xmlFree");
xmlMemStrdup : aliased xmlmemory.xmlStrdupFunc;
pragma Import (C, xmlMemStrdup, "xmlMemStrdup");
function qqdocbDefaultSAXHandler return parser.xmlSAXHandlerV1_ptr;
pragma Import (C, qqdocbDefaultSAXHandler, "__docbDefaultSAXHandler");
function qqhtmlDefaultSAXHandler return parser.xmlSAXHandlerV1_ptr;
pragma Import (C, qqhtmlDefaultSAXHandler, "__htmlDefaultSAXHandler");
function qqxmlLastError return xmlerror.xmlError_ptr;
pragma Import (C, qqxmlLastError, "__xmlLastError");
function qqoldXMLWDcompatibility return signed_int_ptr;
pragma Import (C, qqoldXMLWDcompatibility, "__oldXMLWDcompatibility");
function qqxmlBufferAllocScheme return tree.xmlBufferAllocationScheme_ptr;
pragma Import (C, qqxmlBufferAllocScheme, "__xmlBufferAllocScheme");
function xmlThrDefBufferAllocScheme (v : tree.xmlBufferAllocationScheme)
return tree.xmlBufferAllocationScheme;
pragma Import (C, xmlThrDefBufferAllocScheme,
"xmlThrDefBufferAllocScheme");
function qqxmlDefaultBufferSize return signed_int_ptr;
pragma Import (C, qqxmlDefaultBufferSize, "__xmlDefaultBufferSize");
function xmlThrDefDefaultBufferSize (v : signed_int) return signed_int;
pragma Import (C, xmlThrDefDefaultBufferSize,
"xmlThrDefDefaultBufferSize");
function qqxmlDefaultSAXHandler return parser.xmlSAXHandlerV1_ptr;
pragma Import (C, qqxmlDefaultSAXHandler, "__xmlDefaultSAXHandler");
function xmlDefaultSAXLocator return tree.xmlSAXLocator_ptr;
pragma Import (C, xmlDefaultSAXLocator, "__xmlDefaultSAXLocator");
function qqxmlDoValidityCheckingDefaultValue return signed_int_ptr;
pragma Import (C, qqxmlDoValidityCheckingDefaultValue,
"__xmlDoValidityCheckingDefaultValue");
function xmlThrDefDoValidityCheckingDefaultValue (v : signed_int)
return signed_int;
pragma Import (C, xmlThrDefDoValidityCheckingDefaultValue,
"xmlThrDefDoValidityCheckingDefaultValue");
function qqxmlGenericError return xmlerror.xmlGenericErrorFunc_ptr;
pragma Import (C, qqxmlGenericError, "__xmlGenericError");
function qqxmlStructuredError return xmlerror.xmlStructuredErrorFunc_ptr;
pragma Import (C, qqxmlStructuredError, "__xmlStructuredError");
function qqxmlGenericErrorContext return void_ptr_ptr;
pragma Import (C, qqxmlGenericErrorContext, "__xmlGenericErrorContext");
function qqxmlStructuredErrorContext return void_ptr_ptr;
pragma Import (C, qqxmlStructuredErrorContext,
"__xmlStructuredErrorContext");
function qqxmlGetWarningsDefaultValue return signed_int_ptr;
pragma Import (C, qqxmlGetWarningsDefaultValue,
"__xmlGetWarningsDefaultValue");
function xmlThrDefGetWarningsDefaultValue (v : signed_int)
return signed_int;
pragma Import (C, xmlThrDefGetWarningsDefaultValue,
"xmlThrDefGetWarningsDefaultValue");
function qqxmlIndentTreeOutput return signed_int_ptr;
pragma Import (C, qqxmlIndentTreeOutput, "__xmlIndentTreeOutput");
function xmlThrDefIndentTreeOutput (v : signed_int) return signed_int;
pragma Import (C, xmlThrDefIndentTreeOutput, "xmlThrDefIndentTreeOutput");
function qqxmlTreeIndentString return char_const_ptr_ptr;
pragma Import (C, qqxmlTreeIndentString, "__xmlTreeIndentString");
function xmlThrDefTreeIndentString (v : access constant char)
return char_const_ptr;
pragma Import (C, xmlThrDefTreeIndentString, "xmlThrDefTreeIndentString");
function qqxmlKeepBlanksDefaultValue return signed_int_ptr;
pragma Import (C, qqxmlKeepBlanksDefaultValue,
"__xmlKeepBlanksDefaultValue");
function xmlThrDefKeepBlanksDefaultValue (v : signed_int)
return signed_int;
pragma Import (C, xmlThrDefKeepBlanksDefaultValue,
"xmlThrDefKeepBlanksDefaultValue");
function qqxmlLineNumbersDefaultValue return signed_int_ptr;
pragma Import (C, qqxmlLineNumbersDefaultValue,
"__xmlLineNumbersDefaultValue");
function xmlThrDefLineNumbersDefaultValue (v : signed_int)
return signed_int;
pragma Import (C, xmlThrDefLineNumbersDefaultValue,
"xmlThrDefLineNumbersDefaultValue");
function qqxmlLoadExtDtdDefaultValue return signed_int_ptr;
pragma Import (C, qqxmlLoadExtDtdDefaultValue,
"__xmlLoadExtDtdDefaultValue");
function xmlThrDefLoadExtDtdDefaultValue (v : signed_int)
return signed_int;
pragma Import (C, xmlThrDefLoadExtDtdDefaultValue,
"xmlThrDefLoadExtDtdDefaultValue");
function qqxmlParserDebugEntities return signed_int_ptr;
pragma Import (C, qqxmlParserDebugEntities, "__xmlParserDebugEntities");
function xmlThrDefParserDebugEntities (v : signed_int) return signed_int;
pragma Import (C, xmlThrDefParserDebugEntities,
"xmlThrDefParserDebugEntities");
function qqxmlParserVersion return char_const_ptr_ptr;
pragma Import (C, qqxmlParserVersion, "__xmlParserVersion");
function qqxmlPedanticParserDefaultValue return signed_int_ptr;
pragma Import (C, qqxmlPedanticParserDefaultValue,
"__xmlPedanticParserDefaultValue");
function xmlThrDefPedanticParserDefaultValue (v : signed_int)
return signed_int;
pragma Import (C, xmlThrDefPedanticParserDefaultValue,
"xmlThrDefPedanticParserDefaultValue");
function qqxmlSaveNoEmptyTags return signed_int_ptr;
pragma Import (C, qqxmlSaveNoEmptyTags, "__xmlSaveNoEmptyTags");
function xmlThrDefSaveNoEmptyTags (v : signed_int) return signed_int;
pragma Import (C, xmlThrDefSaveNoEmptyTags, "xmlThrDefSaveNoEmptyTags");
function qqxmlSubstituteEntitiesDefaultValue return signed_int_ptr;
pragma Import (C, qqxmlSubstituteEntitiesDefaultValue,
"__xmlSubstituteEntitiesDefaultValue");
function xmlThrDefSubstituteEntitiesDefaultValue (v : signed_int)
return signed_int;
pragma Import (C, xmlThrDefSubstituteEntitiesDefaultValue,
"xmlThrDefSubstituteEntitiesDefaultValue");
function qqxmlRegisterNodeDefaultValue return xmlRegisterNodeFunc_ptr;
pragma Import (C, qqxmlRegisterNodeDefaultValue,
"__xmlRegisterNodeDefaultValue");
function qqxmlDeregisterNodeDefaultValue return xmlDeregisterNodeFunc_ptr;
pragma Import (C, qqxmlDeregisterNodeDefaultValue,
"__xmlDeregisterNodeDefaultValue");
function qqxmlParserInputBufferCreateFilenameValue
return xmlParserInputBufferCreateFilenameFunc_ptr;
pragma Import (C, qqxmlParserInputBufferCreateFilenameValue,
"__xmlParserInputBufferCreateFilenameValue");
function qqxmlOutputBufferCreateFilenameValue
return xmlOutputBufferCreateFilenameFunc_ptr;
pragma Import (C, qqxmlOutputBufferCreateFilenameValue,
"__xmlOutputBufferCreateFilenameValue");
-- __XML_GLOBALS_H (empty)
function docbDefaultSAXHandler return parser.xmlSAXHandlerV1;
pragma Inline_Always (docbDefaultSAXHandler);
function htmlDefaultSAXHandler return parser.xmlSAXHandlerV1;
pragma Inline_Always (htmlDefaultSAXHandler);
function oldXMLWDcompatibility return signed_int;
pragma Inline_Always (oldXMLWDcompatibility);
function xmlBufferAllocScheme return tree.xmlBufferAllocationScheme;
pragma Inline_Always (xmlBufferAllocScheme);
function xmlDefaultBufferSize return signed_int;
pragma Inline_Always (xmlDefaultBufferSize);
function xmlDefaultSAXHandler return parser.xmlSAXHandlerV1;
pragma Inline_Always (xmlDefaultSAXHandler);
function xmlDeregisterNodeDefaultValue return xmlDeregisterNodeFunc;
pragma Inline_Always (xmlDeregisterNodeDefaultValue);
function xmlDoValidityCheckingDefaultValue return signed_int;
pragma Inline_Always (xmlDoValidityCheckingDefaultValue);
function xmlGenericError return xmlerror.xmlGenericErrorFunc;
pragma Inline_Always (xmlGenericError);
function xmlGenericErrorContext return void_ptr;
pragma Inline_Always (xmlGenericErrorContext);
function xmlGetWarningsDefaultValue return signed_int;
pragma Inline_Always (xmlGetWarningsDefaultValue);
function xmlIndentTreeOutput return signed_int;
pragma Inline_Always (xmlIndentTreeOutput);
function xmlKeepBlanksDefaultValue return signed_int;
pragma Inline_Always (xmlKeepBlanksDefaultValue);
function xmlLastError return xmlerror.xmlError;
pragma Inline_Always (xmlLastError);
function xmlLineNumbersDefaultValue return signed_int;
pragma Inline_Always (xmlLineNumbersDefaultValue);
function xmlLoadExtDtdDefaultValue return signed_int;
pragma Inline_Always (xmlLoadExtDtdDefaultValue);
function xmlOutputBufferCreateFilenameValue
return xmlOutputBufferCreateFilenameFunc;
pragma Inline_Always (xmlOutputBufferCreateFilenameValue);
function xmlParserDebugEntities return signed_int;
pragma Inline_Always (xmlParserDebugEntities);
function xmlParserInputBufferCreateFilenameValue
return xmlParserInputBufferCreateFilenameFunc;
pragma Inline_Always (xmlParserInputBufferCreateFilenameValue);
function xmlParserVersion return char_const_ptr;
pragma Inline_Always (xmlParserVersion);
function xmlPedanticParserDefaultValue return signed_int;
pragma Inline_Always (xmlPedanticParserDefaultValue);
function xmlRegisterNodeDefaultValue return xmlRegisterNodeFunc;
pragma Inline_Always (xmlRegisterNodeDefaultValue);
function xmlSaveNoEmptyTags return signed_int;
pragma Inline_Always (xmlSaveNoEmptyTags);
function xmlStructuredError return xmlerror.xmlStructuredErrorFunc;
pragma Inline_Always (xmlStructuredError);
function xmlStructuredErrorContext return void_ptr;
pragma Inline_Always (xmlStructuredErrorContext);
function xmlSubstituteEntitiesDefaultValue return signed_int;
pragma Inline_Always (xmlSubstituteEntitiesDefaultValue);
function xmlTreeIndentString return char_const_ptr;
pragma Inline_Always (xmlTreeIndentString);
end C.libxml.globals;
Raw
c-libxml-hash.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.libxml.dict;
with C.libxml.xmlstring;
package C.libxml.hash is
pragma Preelaborate;
type struct_xmlHashTable (<>) is limited private;
type struct_xmlHashTable_ptr is access all struct_xmlHashTable;
for struct_xmlHashTable_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlHashTable_ptr);
pragma Convention (C, struct_xmlHashTable_ptr);
subtype xmlHashTable is struct_xmlHashTable;
subtype xmlHashTable_ptr is struct_xmlHashTable_ptr;
subtype xmlHashTablePtr is xmlHashTable_ptr;
type access_f3c034aa is access procedure (payload : void_ptr;
name : access xmlstring.xmlChar);
pragma Convention (C, access_f3c034aa);
subtype xmlHashDeallocator is access_f3c034aa;
type access_3cef0ca9 is access function (payload : void_ptr;
name : access xmlstring.xmlChar) return void_ptr;
pragma Convention (C, access_3cef0ca9);
subtype xmlHashCopier is access_3cef0ca9;
type access_d13181b4 is access procedure (payload : void_ptr;
data : void_ptr; name : access xmlstring.xmlChar);
pragma Convention (C, access_d13181b4);
subtype xmlHashScanner is access_d13181b4;
type access_a5b686e2 is access procedure (payload : void_ptr;
data : void_ptr; name : access constant xmlstring.xmlChar;
name2 : access constant xmlstring.xmlChar;
name3 : access constant xmlstring.xmlChar);
pragma Convention (C, access_a5b686e2);
subtype xmlHashScannerFull is access_a5b686e2;
function xmlHashCreate (size : signed_int) return xmlHashTablePtr;
pragma Import (C, xmlHashCreate, "xmlHashCreate");
function xmlHashCreateDict (size : signed_int;
dict : access libxml.dict.xmlDict) return xmlHashTablePtr;
pragma Import (C, xmlHashCreateDict, "xmlHashCreateDict");
procedure xmlHashFree (table : access xmlHashTable;
f : xmlHashDeallocator);
pragma Import (C, xmlHashFree, "xmlHashFree");
function xmlHashAddEntry (table : access xmlHashTable;
name : access constant xmlstring.xmlChar; userdata : void_ptr)
return signed_int;
pragma Import (C, xmlHashAddEntry, "xmlHashAddEntry");
function xmlHashUpdateEntry (table : access xmlHashTable;
name : access constant xmlstring.xmlChar; userdata : void_ptr;
f : xmlHashDeallocator) return signed_int;
pragma Import (C, xmlHashUpdateEntry, "xmlHashUpdateEntry");
function xmlHashAddEntry2 (table : access xmlHashTable;
name : access constant xmlstring.xmlChar;
name2 : access constant xmlstring.xmlChar; userdata : void_ptr)
return signed_int;
pragma Import (C, xmlHashAddEntry2, "xmlHashAddEntry2");
function xmlHashUpdateEntry2 (table : access xmlHashTable;
name : access constant xmlstring.xmlChar;
name2 : access constant xmlstring.xmlChar; userdata : void_ptr;
f : xmlHashDeallocator) return signed_int;
pragma Import (C, xmlHashUpdateEntry2, "xmlHashUpdateEntry2");
function xmlHashAddEntry3 (table : access xmlHashTable;
name : access constant xmlstring.xmlChar;
name2 : access constant xmlstring.xmlChar;
name3 : access constant xmlstring.xmlChar; userdata : void_ptr)
return signed_int;
pragma Import (C, xmlHashAddEntry3, "xmlHashAddEntry3");
function xmlHashUpdateEntry3 (table : access xmlHashTable;
name : access constant xmlstring.xmlChar;
name2 : access constant xmlstring.xmlChar;
name3 : access constant xmlstring.xmlChar; userdata : void_ptr;
f : xmlHashDeallocator) return signed_int;
pragma Import (C, xmlHashUpdateEntry3, "xmlHashUpdateEntry3");
function xmlHashRemoveEntry (table : access xmlHashTable;
name : access constant xmlstring.xmlChar; f : xmlHashDeallocator)
return signed_int;
pragma Import (C, xmlHashRemoveEntry, "xmlHashRemoveEntry");
function xmlHashRemoveEntry2 (table : access xmlHashTable;
name : access constant xmlstring.xmlChar;
name2 : access constant xmlstring.xmlChar; f : xmlHashDeallocator)
return signed_int;
pragma Import (C, xmlHashRemoveEntry2, "xmlHashRemoveEntry2");
function xmlHashRemoveEntry3 (table : access xmlHashTable;
name : access constant xmlstring.xmlChar;
name2 : access constant xmlstring.xmlChar;
name3 : access constant xmlstring.xmlChar; f : xmlHashDeallocator)
return signed_int;
pragma Import (C, xmlHashRemoveEntry3, "xmlHashRemoveEntry3");
function xmlHashLookup (table : access xmlHashTable;
name : access constant xmlstring.xmlChar) return void_ptr;
pragma Import (C, xmlHashLookup, "xmlHashLookup");
function xmlHashLookup2 (table : access xmlHashTable;
name : access constant xmlstring.xmlChar;
name2 : access constant xmlstring.xmlChar) return void_ptr;
pragma Import (C, xmlHashLookup2, "xmlHashLookup2");
function xmlHashLookup3 (table : access xmlHashTable;
name : access constant xmlstring.xmlChar;
name2 : access constant xmlstring.xmlChar;
name3 : access constant xmlstring.xmlChar) return void_ptr;
pragma Import (C, xmlHashLookup3, "xmlHashLookup3");
function xmlHashQLookup (table : access xmlHashTable;
name : access constant xmlstring.xmlChar;
prefix : access constant xmlstring.xmlChar) return void_ptr;
pragma Import (C, xmlHashQLookup, "xmlHashQLookup");
function xmlHashQLookup2 (table : access xmlHashTable;
name : access constant xmlstring.xmlChar;
prefix : access constant xmlstring.xmlChar;
name2 : access constant xmlstring.xmlChar;
prefix2 : access constant xmlstring.xmlChar) return void_ptr;
pragma Import (C, xmlHashQLookup2, "xmlHashQLookup2");
function xmlHashQLookup3 (table : access xmlHashTable;
name : access constant xmlstring.xmlChar;
prefix : access constant xmlstring.xmlChar;
name2 : access constant xmlstring.xmlChar;
prefix2 : access constant xmlstring.xmlChar;
name3 : access constant xmlstring.xmlChar;
prefix3 : access constant xmlstring.xmlChar) return void_ptr;
pragma Import (C, xmlHashQLookup3, "xmlHashQLookup3");
function xmlHashCopy (table : access xmlHashTable; f : xmlHashCopier)
return xmlHashTablePtr;
pragma Import (C, xmlHashCopy, "xmlHashCopy");
function xmlHashSize (table : access xmlHashTable) return signed_int;
pragma Import (C, xmlHashSize, "xmlHashSize");
procedure xmlHashScan (table : access xmlHashTable; f : xmlHashScanner;
data : void_ptr);
pragma Import (C, xmlHashScan, "xmlHashScan");
procedure xmlHashScan3 (table : access xmlHashTable;
name : access constant xmlstring.xmlChar;
name2 : access constant xmlstring.xmlChar;
name3 : access constant xmlstring.xmlChar; f : xmlHashScanner;
data : void_ptr);
pragma Import (C, xmlHashScan3, "xmlHashScan3");
procedure xmlHashScanFull (table : access xmlHashTable;
f : xmlHashScannerFull; data : void_ptr);
pragma Import (C, xmlHashScanFull, "xmlHashScanFull");
procedure xmlHashScanFull3 (table : access xmlHashTable;
name : access constant xmlstring.xmlChar;
name2 : access constant xmlstring.xmlChar;
name3 : access constant xmlstring.xmlChar; f : xmlHashScannerFull;
data : void_ptr);
pragma Import (C, xmlHashScanFull3, "xmlHashScanFull3");
-- XML_CAST_FPTR (function macro)
-- __XML_HASH_H__ (empty)
private
type struct_xmlHashTable is null record;
end C.libxml.hash;
Raw
c-libxml-list.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.libxml.list is
pragma Preelaborate;
type struct_xmlLink (<>) is limited private;
type struct_xmlLink_ptr is access all struct_xmlLink;
for struct_xmlLink_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlLink_ptr);
pragma Convention (C, struct_xmlLink_ptr);
subtype xmlLink is struct_xmlLink;
subtype xmlLink_ptr is struct_xmlLink_ptr;
subtype xmlLinkPtr is xmlLink_ptr;
type struct_xmlList (<>) is limited private;
type struct_xmlList_ptr is access all struct_xmlList;
for struct_xmlList_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlList_ptr);
pragma Convention (C, struct_xmlList_ptr);
subtype xmlList is struct_xmlList;
subtype xmlList_ptr is struct_xmlList_ptr;
subtype xmlListPtr is xmlList_ptr;
type access_90c3a9c0 is access procedure (lk : access xmlLink);
pragma Convention (C, access_90c3a9c0);
subtype xmlListDeallocator is access_90c3a9c0;
type access_8173d05a is access function (data0 : void_const_ptr;
data1 : void_const_ptr) return signed_int;
pragma Convention (C, access_8173d05a);
subtype xmlListDataCompare is access_8173d05a;
type access_313b2a89 is access function (data : void_const_ptr;
user : void_const_ptr) return signed_int;
pragma Convention (C, access_313b2a89);
subtype xmlListWalker is access_313b2a89;
function xmlListCreate (deallocator : xmlListDeallocator;
compare : xmlListDataCompare) return xmlListPtr;
pragma Import (C, xmlListCreate, "xmlListCreate");
procedure xmlListDelete (l : access xmlList);
pragma Import (C, xmlListDelete, "xmlListDelete");
function xmlListSearch (l : access xmlList; data : void_ptr)
return void_ptr;
pragma Import (C, xmlListSearch, "xmlListSearch");
function xmlListReverseSearch (l : access xmlList; data : void_ptr)
return void_ptr;
pragma Import (C, xmlListReverseSearch, "xmlListReverseSearch");
function xmlListInsert (l : access xmlList; data : void_ptr)
return signed_int;
pragma Import (C, xmlListInsert, "xmlListInsert");
function xmlListAppend (l : access xmlList; data : void_ptr)
return signed_int;
pragma Import (C, xmlListAppend, "xmlListAppend");
function xmlListRemoveFirst (l : access xmlList; data : void_ptr)
return signed_int;
pragma Import (C, xmlListRemoveFirst, "xmlListRemoveFirst");
function xmlListRemoveLast (l : access xmlList; data : void_ptr)
return signed_int;
pragma Import (C, xmlListRemoveLast, "xmlListRemoveLast");
function xmlListRemoveAll (l : access xmlList; data : void_ptr)
return signed_int;
pragma Import (C, xmlListRemoveAll, "xmlListRemoveAll");
procedure xmlListClear (l : access xmlList);
pragma Import (C, xmlListClear, "xmlListClear");
function xmlListEmpty (l : access xmlList) return signed_int;
pragma Import (C, xmlListEmpty, "xmlListEmpty");
function xmlListFront (l : access xmlList) return xmlLinkPtr;
pragma Import (C, xmlListFront, "xmlListFront");
function xmlListEnd (l : access xmlList) return xmlLinkPtr;
pragma Import (C, xmlListEnd, "xmlListEnd");
function xmlListSize (l : access xmlList) return signed_int;
pragma Import (C, xmlListSize, "xmlListSize");
procedure xmlListPopFront (l : access xmlList);
pragma Import (C, xmlListPopFront, "xmlListPopFront");
procedure xmlListPopBack (l : access xmlList);
pragma Import (C, xmlListPopBack, "xmlListPopBack");
function xmlListPushFront (l : access xmlList; data : void_ptr)
return signed_int;
pragma Import (C, xmlListPushFront, "xmlListPushFront");
function xmlListPushBack (l : access xmlList; data : void_ptr)
return signed_int;
pragma Import (C, xmlListPushBack, "xmlListPushBack");
procedure xmlListReverse (l : access xmlList);
pragma Import (C, xmlListReverse, "xmlListReverse");
procedure xmlListSort (l : access xmlList);
pragma Import (C, xmlListSort, "xmlListSort");
procedure xmlListWalk (l : access xmlList; walker : xmlListWalker;
user : void_const_ptr);
pragma Import (C, xmlListWalk, "xmlListWalk");
procedure xmlListReverseWalk (l : access xmlList; walker : xmlListWalker;
user : void_const_ptr);
pragma Import (C, xmlListReverseWalk, "xmlListReverseWalk");
procedure xmlListMerge (l1 : access xmlList; l2 : access xmlList);
pragma Import (C, xmlListMerge, "xmlListMerge");
function xmlListDup (old : access xmlList) return xmlListPtr;
pragma Import (C, xmlListDup, "xmlListDup");
function xmlListCopy (cur : access xmlList; old : access xmlList)
return signed_int;
pragma Import (C, xmlListCopy, "xmlListCopy");
function xmlLinkGetData (lk : access xmlLink) return void_ptr;
pragma Import (C, xmlLinkGetData, "xmlLinkGetData");
-- __XML_LINK_INCLUDE__ (empty)
private
type struct_xmlLink is null record;
type struct_xmlList is null record;
end C.libxml.list;
Raw
c-libxml-parser.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.libxml.dict;
with C.libxml.encoding;
with C.libxml.hash;
with C.libxml.tree;
with C.libxml.valid;
with C.libxml.xmlIO;
with C.libxml.xmlerror;
with C.libxml.xmlstring;
package C.libxml.parser is
pragma Preelaborate;
type struct_xmlParserInput;
type struct_xmlParserCtxt;
type struct_xmlSAXLocator;
type struct_xmlSAXHandler;
type access_5f142c5e is access procedure (str : access xmlstring.xmlChar);
pragma Convention (C, access_5f142c5e);
subtype xmlParserInputDeallocate is access_5f142c5e;
type struct_xmlParserInput is record
buf : aliased tree.xmlParserInputBufferPtr;
filename : aliased char_const_ptr;
directory : aliased char_const_ptr;
base : aliased xmlstring.xmlChar_const_ptr;
cur : aliased xmlstring.xmlChar_const_ptr;
F_end : aliased xmlstring.xmlChar_const_ptr;
length : aliased signed_int;
line : aliased signed_int;
col : aliased signed_int;
consumed : aliased unsigned_long;
free : aliased xmlParserInputDeallocate;
encoding : aliased xmlstring.xmlChar_const_ptr;
version : aliased xmlstring.xmlChar_const_ptr;
standalone : aliased signed_int;
id : aliased signed_int;
end record;
pragma Convention (C_Pass_By_Copy, struct_xmlParserInput);
type struct_xmlParserNodeInfo;
type struct_xmlParserNodeInfo_ptr is access all struct_xmlParserNodeInfo;
for struct_xmlParserNodeInfo_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlParserNodeInfo_ptr);
pragma Convention (C, struct_xmlParserNodeInfo_ptr);
type struct_xmlParserNodeInfo_const_ptr is
access constant struct_xmlParserNodeInfo;
for struct_xmlParserNodeInfo_const_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlParserNodeInfo_const_ptr);
pragma Convention (C, struct_xmlParserNodeInfo_const_ptr);
subtype xmlParserNodeInfo is struct_xmlParserNodeInfo;
subtype xmlParserNodeInfo_ptr is struct_xmlParserNodeInfo_ptr;
subtype xmlParserNodeInfo_const_ptr is struct_xmlParserNodeInfo_const_ptr;
subtype xmlParserNodeInfoPtr is xmlParserNodeInfo_ptr;
type struct_xmlParserNodeInfo is record
node : aliased tree.struct_xmlNode_const_ptr;
begin_pos : aliased unsigned_long;
begin_line : aliased unsigned_long;
end_pos : aliased unsigned_long;
end_line : aliased unsigned_long;
end record;
pragma Convention (C_Pass_By_Copy, struct_xmlParserNodeInfo);
type struct_xmlParserNodeInfoSeq;
type struct_xmlParserNodeInfoSeq_ptr is
access all struct_xmlParserNodeInfoSeq;
for struct_xmlParserNodeInfoSeq_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlParserNodeInfoSeq_ptr);
pragma Convention (C, struct_xmlParserNodeInfoSeq_ptr);
subtype xmlParserNodeInfoSeq is struct_xmlParserNodeInfoSeq;
subtype xmlParserNodeInfoSeq_ptr is struct_xmlParserNodeInfoSeq_ptr;
subtype xmlParserNodeInfoSeqPtr is xmlParserNodeInfoSeq_ptr;
type struct_xmlParserNodeInfoSeq is record
maximum : aliased unsigned_long;
length : aliased unsigned_long;
buffer : aliased xmlParserNodeInfo_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_xmlParserNodeInfoSeq);
type enum_22741c27 is (XML_PARSER_EOF, XML_PARSER_START, XML_PARSER_MISC,
XML_PARSER_PI, XML_PARSER_DTD, XML_PARSER_PROLOG, XML_PARSER_COMMENT,
XML_PARSER_START_TAG, XML_PARSER_CONTENT, XML_PARSER_CDATA_SECTION,
XML_PARSER_END_TAG, XML_PARSER_ENTITY_DECL, XML_PARSER_ENTITY_VALUE,
XML_PARSER_ATTRIBUTE_VALUE, XML_PARSER_SYSTEM_LITERAL,
XML_PARSER_EPILOG, XML_PARSER_IGNORE, XML_PARSER_PUBLIC_LITERAL);
for enum_22741c27 use (XML_PARSER_EOF => -1, XML_PARSER_START => 0,
XML_PARSER_MISC => 1, XML_PARSER_PI => 2, XML_PARSER_DTD => 3,
XML_PARSER_PROLOG => 4, XML_PARSER_COMMENT => 5,
XML_PARSER_START_TAG => 6, XML_PARSER_CONTENT => 7,
XML_PARSER_CDATA_SECTION => 8, XML_PARSER_END_TAG => 9,
XML_PARSER_ENTITY_DECL => 10, XML_PARSER_ENTITY_VALUE => 11,
XML_PARSER_ATTRIBUTE_VALUE => 12, XML_PARSER_SYSTEM_LITERAL => 13,
XML_PARSER_EPILOG => 14, XML_PARSER_IGNORE => 15,
XML_PARSER_PUBLIC_LITERAL => 16);
pragma Convention (C, enum_22741c27);
subtype xmlParserInputState is enum_22741c27;
type enum_dffb9120 is (XML_PARSE_UNKNOWN, XML_PARSE_DOM, XML_PARSE_SAX,
XML_PARSE_PUSH_DOM, XML_PARSE_PUSH_SAX, XML_PARSE_READER);
for enum_dffb9120 use (XML_PARSE_UNKNOWN => 0, XML_PARSE_DOM => 1,
XML_PARSE_SAX => 2, XML_PARSE_PUSH_DOM => 3, XML_PARSE_PUSH_SAX => 4,
XML_PARSE_READER => 5);
pragma Convention (C, enum_dffb9120);
subtype xmlParserMode is enum_dffb9120;
type struct_xmlParserCtxt is record
sax : aliased tree.struct_xmlSAXHandler_ptr;
userData : aliased void_ptr;
myDoc : aliased tree.xmlDocPtr;
wellFormed : aliased signed_int;
replaceEntities : aliased signed_int;
version : aliased xmlstring.xmlChar_const_ptr;
encoding : aliased xmlstring.xmlChar_const_ptr;
standalone : aliased signed_int;
html : aliased signed_int;
input : aliased tree.xmlParserInputPtr;
inputNr : aliased signed_int;
inputMax : aliased signed_int;
inputTab : aliased tree.xmlParserInputPtr_ptr;
node : aliased tree.xmlNodePtr;
nodeNr : aliased signed_int;
nodeMax : aliased signed_int;
nodeTab : aliased tree.xmlNodePtr_ptr;
record_info : aliased signed_int;
node_seq : aliased xmlParserNodeInfoSeq;
errNo : aliased signed_int;
hasExternalSubset : aliased signed_int;
hasPErefs : aliased signed_int;
external : aliased signed_int;
valid : aliased signed_int;
validate : aliased signed_int;
vctxt : aliased libxml.valid.xmlValidCtxt;
instate : aliased xmlParserInputState;
token : aliased signed_int;
directory : aliased char_ptr;
name : aliased xmlstring.xmlChar_const_ptr;
nameNr : aliased signed_int;
nameMax : aliased signed_int;
nameTab : aliased xmlstring.xmlChar_const_ptr_ptr;
nbChars : aliased signed_long;
checkIndex : aliased signed_long;
keepBlanks : aliased signed_int;
disableSAX : aliased signed_int;
inSubset : aliased signed_int;
intSubName : aliased xmlstring.xmlChar_const_ptr;
extSubURI : aliased xmlstring.xmlChar_ptr;
extSubSystem : aliased xmlstring.xmlChar_ptr;
space : aliased signed_int_ptr;
spaceNr : aliased signed_int;
spaceMax : aliased signed_int;
spaceTab : aliased signed_int_ptr;
depth : aliased signed_int;
entity : aliased tree.xmlParserInputPtr;
charset : aliased signed_int;
nodelen : aliased signed_int;
nodemem : aliased signed_int;
pedantic : aliased signed_int;
F_private : aliased void_ptr;
loadsubset : aliased signed_int;
linenumbers : aliased signed_int;
catalogs : aliased void_ptr;
recovery : aliased signed_int;
progressive : aliased signed_int;
dict : aliased libxml.dict.xmlDictPtr;
atts : aliased xmlstring.xmlChar_const_ptr_ptr;
maxatts : aliased signed_int;
docdict : aliased signed_int;
str_xml : aliased xmlstring.xmlChar_const_ptr;
str_xmlns : aliased xmlstring.xmlChar_const_ptr;
str_xml_ns : aliased xmlstring.xmlChar_const_ptr;
sax2 : aliased signed_int;
nsNr : aliased signed_int;
nsMax : aliased signed_int;
nsTab : aliased xmlstring.xmlChar_const_ptr_ptr;
attallocs : aliased signed_int_ptr;
pushTab : aliased void_ptr_ptr;
attsDefault : aliased hash.xmlHashTablePtr;
attsSpecial : aliased hash.xmlHashTablePtr;
nsWellFormed : aliased signed_int;
options : aliased signed_int;
dictNames : aliased signed_int;
freeElemsNr : aliased signed_int;
freeElems : aliased tree.xmlNodePtr;
freeAttrsNr : aliased signed_int;
freeAttrs : aliased tree.xmlAttrPtr;
lastError : aliased xmlerror.xmlError;
parseMode : aliased xmlParserMode;
nbentities : aliased unsigned_long;
sizeentities : aliased unsigned_long;
nodeInfo : aliased xmlParserNodeInfo_ptr;
nodeInfoNr : aliased signed_int;
nodeInfoMax : aliased signed_int;
nodeInfoTab : aliased xmlParserNodeInfo_ptr;
input_id : aliased signed_int;
sizeentcopy : aliased unsigned_long;
end record;
pragma Convention (C_Pass_By_Copy, struct_xmlParserCtxt);
type access_d48b9574 is access function (ctx : void_ptr)
return xmlstring.xmlChar_const_ptr;
pragma Convention (C, access_d48b9574);
type access_e834770a is access function (ctx : void_ptr)
return xmlstring.xmlChar_const_ptr;
pragma Convention (C, access_e834770a);
type access_6f175902 is access function (ctx : void_ptr)
return signed_int;
pragma Convention (C, access_6f175902);
type access_80de7be9 is access function (ctx : void_ptr)
return signed_int;
pragma Convention (C, access_80de7be9);
type struct_xmlSAXLocator is record
getPublicId : aliased access_d48b9574;
getSystemId : aliased access_e834770a;
getLineNumber : aliased access_6f175902;
getColumnNumber : aliased access_80de7be9;
end record;
pragma Convention (C_Pass_By_Copy, struct_xmlSAXLocator);
type access_7908630f is access function (ctx : void_ptr;
publicId : access constant xmlstring.xmlChar;
systemId : access constant xmlstring.xmlChar)
return tree.xmlParserInputPtr;
pragma Convention (C, access_7908630f);
subtype resolveEntitySAXFunc is access_7908630f;
type access_b30e7503 is access procedure (ctx : void_ptr;
name : access constant xmlstring.xmlChar;
ExternalID : access constant xmlstring.xmlChar;
SystemID : access constant xmlstring.xmlChar);
pragma Convention (C, access_b30e7503);
subtype internalSubsetSAXFunc is access_b30e7503;
type access_6b1014f0 is access procedure (ctx : void_ptr;
name : access constant xmlstring.xmlChar;
ExternalID : access constant xmlstring.xmlChar;
SystemID : access constant xmlstring.xmlChar);
pragma Convention (C, access_6b1014f0);
subtype externalSubsetSAXFunc is access_6b1014f0;
type access_23d5e20a is access function (ctx : void_ptr;
name : access constant xmlstring.xmlChar) return tree.xmlEntityPtr;
pragma Convention (C, access_23d5e20a);
subtype getEntitySAXFunc is access_23d5e20a;
type access_78fbaf2c is access function (ctx : void_ptr;
name : access constant xmlstring.xmlChar) return tree.xmlEntityPtr;
pragma Convention (C, access_78fbaf2c);
subtype getParameterEntitySAXFunc is access_78fbaf2c;
type access_b0e68695 is access procedure (ctx : void_ptr;
name : access constant xmlstring.xmlChar; A_type : signed_int;
publicId : access constant xmlstring.xmlChar;
systemId : access constant xmlstring.xmlChar;
content : access xmlstring.xmlChar);
pragma Convention (C, access_b0e68695);
subtype entityDeclSAXFunc is access_b0e68695;
type access_d457dfa7 is access procedure (ctx : void_ptr;
name : access constant xmlstring.xmlChar;
publicId : access constant xmlstring.xmlChar;
systemId : access constant xmlstring.xmlChar);
pragma Convention (C, access_d457dfa7);
subtype notationDeclSAXFunc is access_d457dfa7;
type access_0fb273c0 is access procedure (ctx : void_ptr;
elem : access constant xmlstring.xmlChar;
fullname : access constant xmlstring.xmlChar; A_type : signed_int;
def : signed_int; defaultValue : access constant xmlstring.xmlChar;
tree : access libxml.tree.xmlEnumeration);
pragma Convention (C, access_0fb273c0);
subtype attributeDeclSAXFunc is access_0fb273c0;
type access_f52fcc1b is access procedure (ctx : void_ptr;
name : access constant xmlstring.xmlChar; A_type : signed_int;
content : access tree.xmlElementContent);
pragma Convention (C, access_f52fcc1b);
subtype elementDeclSAXFunc is access_f52fcc1b;
type access_db7489d0 is access procedure (ctx : void_ptr;
name : access constant xmlstring.xmlChar;
publicId : access constant xmlstring.xmlChar;
systemId : access constant xmlstring.xmlChar;
notationName : access constant xmlstring.xmlChar);
pragma Convention (C, access_db7489d0);
subtype unparsedEntityDeclSAXFunc is access_db7489d0;
type access_2a30363b is access procedure (ctx : void_ptr;
loc : access struct_xmlSAXLocator);
pragma Convention (C, access_2a30363b);
subtype setDocumentLocatorSAXFunc is access_2a30363b;
type access_5c18d02a is access procedure (ctx : void_ptr);
pragma Convention (C, access_5c18d02a);
subtype startDocumentSAXFunc is access_5c18d02a;
type access_1e4aed5d is access procedure (ctx : void_ptr);
pragma Convention (C, access_1e4aed5d);
subtype endDocumentSAXFunc is access_1e4aed5d;
type access_64dade72 is access procedure (ctx : void_ptr;
name : access constant xmlstring.xmlChar;
atts : access xmlstring.xmlChar_const_ptr);
pragma Convention (C, access_64dade72);
subtype startElementSAXFunc is access_64dade72;
type access_372ed8ea is access procedure (ctx : void_ptr;
name : access constant xmlstring.xmlChar);
pragma Convention (C, access_372ed8ea);
subtype endElementSAXFunc is access_372ed8ea;
type access_c5f6613d is access procedure (ctx : void_ptr;
name : access constant xmlstring.xmlChar;
value : access constant xmlstring.xmlChar);
pragma Convention (C, access_c5f6613d);
subtype attributeSAXFunc is access_c5f6613d;
type access_637c73d8 is access procedure (ctx : void_ptr;
name : access constant xmlstring.xmlChar);
pragma Convention (C, access_637c73d8);
subtype referenceSAXFunc is access_637c73d8;
type access_7ee79d2b is access procedure (ctx : void_ptr;
ch : access constant xmlstring.xmlChar; len : signed_int);
pragma Convention (C, access_7ee79d2b);
subtype charactersSAXFunc is access_7ee79d2b;
type access_0b5ff8ce is access procedure (ctx : void_ptr;
ch : access constant xmlstring.xmlChar; len : signed_int);
pragma Convention (C, access_0b5ff8ce);
subtype ignorableWhitespaceSAXFunc is access_0b5ff8ce;
type access_f5c70ae8 is access procedure (ctx : void_ptr;
target : access constant xmlstring.xmlChar;
data : access constant xmlstring.xmlChar);
pragma Convention (C, access_f5c70ae8);
subtype processingInstructionSAXFunc is access_f5c70ae8;
type access_dc562853 is access procedure (ctx : void_ptr;
value : access constant xmlstring.xmlChar);
pragma Convention (C, access_dc562853);
subtype commentSAXFunc is access_dc562853;
type access_afe282f2 is access procedure (ctx : void_ptr;
value : access constant xmlstring.xmlChar; len : signed_int);
pragma Convention (C, access_afe282f2);
subtype cdataBlockSAXFunc is access_afe282f2;
type access_c9405356 is access procedure (ctx : void_ptr;
msg : access constant char);
pragma Convention (C, access_c9405356);
subtype warningSAXFunc is access_c9405356;
type access_71c8e5fd is access procedure (ctx : void_ptr;
msg : access constant char);
pragma Convention (C, access_71c8e5fd);
subtype errorSAXFunc is access_71c8e5fd;
type access_ad308847 is access procedure (ctx : void_ptr;
msg : access constant char);
pragma Convention (C, access_ad308847);
subtype fatalErrorSAXFunc is access_ad308847;
type access_8f55fda9 is access function (ctx : void_ptr)
return signed_int;
pragma Convention (C, access_8f55fda9);
subtype isStandaloneSAXFunc is access_8f55fda9;
type access_98501e58 is access function (ctx : void_ptr)
return signed_int;
pragma Convention (C, access_98501e58);
subtype hasInternalSubsetSAXFunc is access_98501e58;
type access_63da76cb is access function (ctx : void_ptr)
return signed_int;
pragma Convention (C, access_63da76cb);
subtype hasExternalSubsetSAXFunc is access_63da76cb;
type access_56021a9c is access procedure (ctx : void_ptr;
localname : access constant xmlstring.xmlChar;
prefix : access constant xmlstring.xmlChar;
URI : access constant xmlstring.xmlChar; nb_namespaces : signed_int;
namespaces : access xmlstring.xmlChar_const_ptr;
nb_attributes : signed_int; nb_defaulted : signed_int;
attributes : access xmlstring.xmlChar_const_ptr);
pragma Convention (C, access_56021a9c);
subtype startElementNsSAX2Func is access_56021a9c;
type access_0f3a5ffa is access procedure (ctx : void_ptr;
localname : access constant xmlstring.xmlChar;
prefix : access constant xmlstring.xmlChar;
URI : access constant xmlstring.xmlChar);
pragma Convention (C, access_0f3a5ffa);
subtype endElementNsSAX2Func is access_0f3a5ffa;
type struct_xmlSAXHandler is record
internalSubset : aliased internalSubsetSAXFunc;
isStandalone : aliased isStandaloneSAXFunc;
hasInternalSubset : aliased hasInternalSubsetSAXFunc;
hasExternalSubset : aliased hasExternalSubsetSAXFunc;
resolveEntity : aliased resolveEntitySAXFunc;
getEntity : aliased getEntitySAXFunc;
entityDecl : aliased entityDeclSAXFunc;
notationDecl : aliased notationDeclSAXFunc;
attributeDecl : aliased attributeDeclSAXFunc;
elementDecl : aliased elementDeclSAXFunc;
unparsedEntityDecl : aliased unparsedEntityDeclSAXFunc;
setDocumentLocator : aliased setDocumentLocatorSAXFunc;
startDocument : aliased startDocumentSAXFunc;
endDocument : aliased endDocumentSAXFunc;
startElement : aliased startElementSAXFunc;
endElement : aliased endElementSAXFunc;
reference : aliased referenceSAXFunc;
characters : aliased charactersSAXFunc;
ignorableWhitespace : aliased ignorableWhitespaceSAXFunc;
processingInstruction : aliased processingInstructionSAXFunc;
comment : aliased commentSAXFunc;
warning : aliased warningSAXFunc;
error : aliased errorSAXFunc;
fatalError : aliased fatalErrorSAXFunc;
getParameterEntity : aliased getParameterEntitySAXFunc;
cdataBlock : aliased cdataBlockSAXFunc;
externalSubset : aliased externalSubsetSAXFunc;
initialized : aliased unsigned_int;
F_private : aliased void_ptr;
startElementNs : aliased startElementNsSAX2Func;
endElementNs : aliased endElementNsSAX2Func;
serror : aliased xmlerror.xmlStructuredErrorFunc;
end record;
pragma Convention (C_Pass_By_Copy, struct_xmlSAXHandler);
type struct_xmlSAXHandlerV1;
type struct_xmlSAXHandlerV1_ptr is access all struct_xmlSAXHandlerV1;
for struct_xmlSAXHandlerV1_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlSAXHandlerV1_ptr);
pragma Convention (C, struct_xmlSAXHandlerV1_ptr);
subtype xmlSAXHandlerV1 is struct_xmlSAXHandlerV1;
subtype xmlSAXHandlerV1_ptr is struct_xmlSAXHandlerV1_ptr;
subtype xmlSAXHandlerV1Ptr is xmlSAXHandlerV1_ptr;
type struct_xmlSAXHandlerV1 is record
internalSubset : aliased internalSubsetSAXFunc;
isStandalone : aliased isStandaloneSAXFunc;
hasInternalSubset : aliased hasInternalSubsetSAXFunc;
hasExternalSubset : aliased hasExternalSubsetSAXFunc;
resolveEntity : aliased resolveEntitySAXFunc;
getEntity : aliased getEntitySAXFunc;
entityDecl : aliased entityDeclSAXFunc;
notationDecl : aliased notationDeclSAXFunc;
attributeDecl : aliased attributeDeclSAXFunc;
elementDecl : aliased elementDeclSAXFunc;
unparsedEntityDecl : aliased unparsedEntityDeclSAXFunc;
setDocumentLocator : aliased setDocumentLocatorSAXFunc;
startDocument : aliased startDocumentSAXFunc;
endDocument : aliased endDocumentSAXFunc;
startElement : aliased startElementSAXFunc;
endElement : aliased endElementSAXFunc;
reference : aliased referenceSAXFunc;
characters : aliased charactersSAXFunc;
ignorableWhitespace : aliased ignorableWhitespaceSAXFunc;
processingInstruction : aliased processingInstructionSAXFunc;
comment : aliased commentSAXFunc;
warning : aliased warningSAXFunc;
error : aliased errorSAXFunc;
fatalError : aliased fatalErrorSAXFunc;
getParameterEntity : aliased getParameterEntitySAXFunc;
cdataBlock : aliased cdataBlockSAXFunc;
externalSubset : aliased externalSubsetSAXFunc;
initialized : aliased unsigned_int;
end record;
pragma Convention (C_Pass_By_Copy, struct_xmlSAXHandlerV1);
type access_8541d8eb is access function (URL : access constant char;
ID : access constant char; context : access struct_xmlParserCtxt)
return tree.xmlParserInputPtr;
pragma Convention (C, access_8541d8eb);
subtype xmlExternalEntityLoader is access_8541d8eb;
-- #include <iconv.h>
-- #include <libxml/encoding.h>
-- #include <libxml/xmlIO.h>
procedure xmlInitParser;
pragma Import (C, xmlInitParser, "xmlInitParser");
procedure xmlCleanupParser;
pragma Import (C, xmlCleanupParser, "xmlCleanupParser");
function xmlParserInputRead (A_in : access struct_xmlParserInput;
len : signed_int) return signed_int;
pragma Import (C, xmlParserInputRead, "xmlParserInputRead");
function xmlParserInputGrow (A_in : access struct_xmlParserInput;
len : signed_int) return signed_int;
pragma Import (C, xmlParserInputGrow, "xmlParserInputGrow");
function xmlParseDoc (cur : access constant xmlstring.xmlChar)
return tree.xmlDocPtr;
pragma Import (C, xmlParseDoc, "xmlParseDoc");
function xmlParseFile (filename : access constant char)
return tree.xmlDocPtr;
pragma Import (C, xmlParseFile, "xmlParseFile");
function xmlParseMemory (buffer : access constant char; size : signed_int)
return tree.xmlDocPtr;
pragma Import (C, xmlParseMemory, "xmlParseMemory");
function xmlSubstituteEntitiesDefault (val : signed_int)
return signed_int;
pragma Import (C, xmlSubstituteEntitiesDefault,
"xmlSubstituteEntitiesDefault");
function xmlKeepBlanksDefault (val : signed_int) return signed_int;
pragma Import (C, xmlKeepBlanksDefault, "xmlKeepBlanksDefault");
procedure xmlStopParser (ctxt : access struct_xmlParserCtxt);
pragma Import (C, xmlStopParser, "xmlStopParser");
function xmlPedanticParserDefault (val : signed_int) return signed_int;
pragma Import (C, xmlPedanticParserDefault, "xmlPedanticParserDefault");
function xmlLineNumbersDefault (val : signed_int) return signed_int;
pragma Import (C, xmlLineNumbersDefault, "xmlLineNumbersDefault");
function xmlRecoverDoc (cur : access constant xmlstring.xmlChar)
return tree.xmlDocPtr;
pragma Import (C, xmlRecoverDoc, "xmlRecoverDoc");
function xmlRecoverMemory (buffer : access constant char;
size : signed_int) return tree.xmlDocPtr;
pragma Import (C, xmlRecoverMemory, "xmlRecoverMemory");
function xmlRecoverFile (filename : access constant char)
return tree.xmlDocPtr;
pragma Import (C, xmlRecoverFile, "xmlRecoverFile");
function xmlParseDocument (ctxt : access struct_xmlParserCtxt)
return signed_int;
pragma Import (C, xmlParseDocument, "xmlParseDocument");
function xmlParseExtParsedEnt (ctxt : access struct_xmlParserCtxt)
return signed_int;
pragma Import (C, xmlParseExtParsedEnt, "xmlParseExtParsedEnt");
function xmlSAXUserParseFile (sax : access struct_xmlSAXHandler;
user_data : void_ptr; filename : access constant char)
return signed_int;
pragma Import (C, xmlSAXUserParseFile, "xmlSAXUserParseFile");
function xmlSAXUserParseMemory (sax : access struct_xmlSAXHandler;
user_data : void_ptr; buffer : access constant char; size : signed_int)
return signed_int;
pragma Import (C, xmlSAXUserParseMemory, "xmlSAXUserParseMemory");
function xmlSAXParseDoc (sax : access struct_xmlSAXHandler;
cur : access constant xmlstring.xmlChar; recovery : signed_int)
return tree.xmlDocPtr;
pragma Import (C, xmlSAXParseDoc, "xmlSAXParseDoc");
function xmlSAXParseMemory (sax : access struct_xmlSAXHandler;
buffer : access constant char; size : signed_int;
recovery : signed_int) return tree.xmlDocPtr;
pragma Import (C, xmlSAXParseMemory, "xmlSAXParseMemory");
function xmlSAXParseMemoryWithData (sax : access struct_xmlSAXHandler;
buffer : access constant char; size : signed_int;
recovery : signed_int; data : void_ptr) return tree.xmlDocPtr;
pragma Import (C, xmlSAXParseMemoryWithData, "xmlSAXParseMemoryWithData");
function xmlSAXParseFile (sax : access struct_xmlSAXHandler;
filename : access constant char; recovery : signed_int)
return tree.xmlDocPtr;
pragma Import (C, xmlSAXParseFile, "xmlSAXParseFile");
function xmlSAXParseFileWithData (sax : access struct_xmlSAXHandler;
filename : access constant char; recovery : signed_int;
data : void_ptr) return tree.xmlDocPtr;
pragma Import (C, xmlSAXParseFileWithData, "xmlSAXParseFileWithData");
function xmlSAXParseEntity (sax : access struct_xmlSAXHandler;
filename : access constant char) return tree.xmlDocPtr;
pragma Import (C, xmlSAXParseEntity, "xmlSAXParseEntity");
function xmlParseEntity (filename : access constant char)
return tree.xmlDocPtr;
pragma Import (C, xmlParseEntity, "xmlParseEntity");
function xmlSAXParseDTD (sax : access struct_xmlSAXHandler;
ExternalID : access constant xmlstring.xmlChar;
SystemID : access constant xmlstring.xmlChar) return tree.xmlDtdPtr;
pragma Import (C, xmlSAXParseDTD, "xmlSAXParseDTD");
function xmlParseDTD (ExternalID : access constant xmlstring.xmlChar;
SystemID : access constant xmlstring.xmlChar) return tree.xmlDtdPtr;
pragma Import (C, xmlParseDTD, "xmlParseDTD");
function xmlIOParseDTD (sax : access struct_xmlSAXHandler;
input : access xmlIO.struct_xmlParserInputBuffer;
enc : encoding.xmlCharEncoding) return tree.xmlDtdPtr;
pragma Import (C, xmlIOParseDTD, "xmlIOParseDTD");
function xmlParseBalancedChunkMemory (doc : access tree.xmlDoc;
sax : access struct_xmlSAXHandler; user_data : void_ptr;
depth : signed_int; string : access constant xmlstring.xmlChar;
lst : access tree.xmlNodePtr) return signed_int;
pragma Import (C, xmlParseBalancedChunkMemory,
"xmlParseBalancedChunkMemory");
function xmlParseInNodeContext (node : access tree.xmlNode;
data : access constant char; datalen : signed_int;
options : signed_int; lst : access tree.xmlNodePtr)
return xmlerror.xmlParserErrors;
pragma Import (C, xmlParseInNodeContext, "xmlParseInNodeContext");
function xmlParseBalancedChunkMemoryRecover (doc : access tree.xmlDoc;
sax : access struct_xmlSAXHandler; user_data : void_ptr;
depth : signed_int; string : access constant xmlstring.xmlChar;
lst : access tree.xmlNodePtr; recover : signed_int) return signed_int;
pragma Import (C, xmlParseBalancedChunkMemoryRecover,
"xmlParseBalancedChunkMemoryRecover");
function xmlParseExternalEntity (doc : access tree.xmlDoc;
sax : access struct_xmlSAXHandler; user_data : void_ptr;
depth : signed_int; URL : access constant xmlstring.xmlChar;
ID : access constant xmlstring.xmlChar; lst : access tree.xmlNodePtr)
return signed_int;
pragma Import (C, xmlParseExternalEntity, "xmlParseExternalEntity");
function xmlParseCtxtExternalEntity (ctx : access struct_xmlParserCtxt;
URL : access constant xmlstring.xmlChar;
ID : access constant xmlstring.xmlChar; lst : access tree.xmlNodePtr)
return signed_int;
pragma Import (C, xmlParseCtxtExternalEntity,
"xmlParseCtxtExternalEntity");
function xmlNewParserCtxt return tree.xmlParserCtxtPtr;
pragma Import (C, xmlNewParserCtxt, "xmlNewParserCtxt");
function xmlInitParserCtxt (ctxt : access struct_xmlParserCtxt)
return signed_int;
pragma Import (C, xmlInitParserCtxt, "xmlInitParserCtxt");
procedure xmlClearParserCtxt (ctxt : access struct_xmlParserCtxt);
pragma Import (C, xmlClearParserCtxt, "xmlClearParserCtxt");
procedure xmlFreeParserCtxt (ctxt : access struct_xmlParserCtxt);
pragma Import (C, xmlFreeParserCtxt, "xmlFreeParserCtxt");
procedure xmlSetupParserForBuffer (ctxt : access struct_xmlParserCtxt;
buffer : access constant xmlstring.xmlChar;
filename : access constant char);
pragma Import (C, xmlSetupParserForBuffer, "xmlSetupParserForBuffer");
function xmlCreateDocParserCtxt (cur : access constant xmlstring.xmlChar)
return tree.xmlParserCtxtPtr;
pragma Import (C, xmlCreateDocParserCtxt, "xmlCreateDocParserCtxt");
function xmlGetFeaturesList (len : access signed_int;
result : access char_const_ptr) return signed_int;
pragma Import (C, xmlGetFeaturesList, "xmlGetFeaturesList");
function xmlGetFeature (ctxt : access struct_xmlParserCtxt;
name : access constant char; result : void_ptr) return signed_int;
pragma Import (C, xmlGetFeature, "xmlGetFeature");
function xmlSetFeature (ctxt : access struct_xmlParserCtxt;
name : access constant char; value : void_ptr) return signed_int;
pragma Import (C, xmlSetFeature, "xmlSetFeature");
function xmlCreatePushParserCtxt (sax : access struct_xmlSAXHandler;
user_data : void_ptr; chunk : access constant char; size : signed_int;
filename : access constant char) return tree.xmlParserCtxtPtr;
pragma Import (C, xmlCreatePushParserCtxt, "xmlCreatePushParserCtxt");
function xmlParseChunk (ctxt : access struct_xmlParserCtxt;
chunk : access constant char; size : signed_int;
A_terminate : signed_int) return signed_int;
pragma Import (C, xmlParseChunk, "xmlParseChunk");
function xmlCreateIOParserCtxt (sax : access struct_xmlSAXHandler;
user_data : void_ptr; ioread : xmlIO.xmlInputReadCallback;
ioclose : xmlIO.xmlInputCloseCallback; ioctx : void_ptr;
enc : encoding.xmlCharEncoding) return tree.xmlParserCtxtPtr;
pragma Import (C, xmlCreateIOParserCtxt, "xmlCreateIOParserCtxt");
function xmlNewIOInputStream (ctxt : access struct_xmlParserCtxt;
input : access xmlIO.struct_xmlParserInputBuffer;
enc : encoding.xmlCharEncoding) return tree.xmlParserInputPtr;
pragma Import (C, xmlNewIOInputStream, "xmlNewIOInputStream");
function xmlParserFindNodeInfo (ctxt : access struct_xmlParserCtxt;
node : access tree.xmlNode) return xmlParserNodeInfo_const_ptr;
pragma Import (C, xmlParserFindNodeInfo, "xmlParserFindNodeInfo");
procedure xmlInitNodeInfoSeq (seq : access xmlParserNodeInfoSeq);
pragma Import (C, xmlInitNodeInfoSeq, "xmlInitNodeInfoSeq");
procedure xmlClearNodeInfoSeq (seq : access xmlParserNodeInfoSeq);
pragma Import (C, xmlClearNodeInfoSeq, "xmlClearNodeInfoSeq");
function xmlParserFindNodeInfoIndex (seq : access xmlParserNodeInfoSeq;
node : access tree.xmlNode) return unsigned_long;
pragma Import (C, xmlParserFindNodeInfoIndex,
"xmlParserFindNodeInfoIndex");
procedure xmlParserAddNodeInfo (ctxt : access struct_xmlParserCtxt;
info : access xmlParserNodeInfo);
pragma Import (C, xmlParserAddNodeInfo, "xmlParserAddNodeInfo");
procedure xmlSetExternalEntityLoader (f : xmlExternalEntityLoader);
pragma Import (C, xmlSetExternalEntityLoader,
"xmlSetExternalEntityLoader");
function xmlGetExternalEntityLoader return xmlExternalEntityLoader;
pragma Import (C, xmlGetExternalEntityLoader,
"xmlGetExternalEntityLoader");
function xmlLoadExternalEntity (URL : access constant char;
ID : access constant char; ctxt : access struct_xmlParserCtxt)
return tree.xmlParserInputPtr;
pragma Import (C, xmlLoadExternalEntity, "xmlLoadExternalEntity");
function xmlByteConsumed (ctxt : access struct_xmlParserCtxt)
return signed_long;
pragma Import (C, xmlByteConsumed, "xmlByteConsumed");
type enum_c827aa94 is (XML_PARSE_RECOVER, XML_PARSE_NOENT,
XML_PARSE_DTDLOAD, XML_PARSE_DTDATTR, XML_PARSE_DTDVALID,
XML_PARSE_NOERROR, XML_PARSE_NOWARNING, XML_PARSE_PEDANTIC,
XML_PARSE_NOBLANKS, XML_PARSE_SAX1, XML_PARSE_XINCLUDE,
XML_PARSE_NONET, XML_PARSE_NODICT, XML_PARSE_NSCLEAN,
XML_PARSE_NOCDATA, XML_PARSE_NOXINCNODE, XML_PARSE_COMPACT,
XML_PARSE_OLD10, XML_PARSE_NOBASEFIX, XML_PARSE_HUGE, XML_PARSE_OLDSAX,
XML_PARSE_IGNORE_ENC, XML_PARSE_BIG_LINES);
for enum_c827aa94 use (XML_PARSE_RECOVER => 1, XML_PARSE_NOENT => 2,
XML_PARSE_DTDLOAD => 4, XML_PARSE_DTDATTR => 8,
XML_PARSE_DTDVALID => 16, XML_PARSE_NOERROR => 32,
XML_PARSE_NOWARNING => 64, XML_PARSE_PEDANTIC => 128,
XML_PARSE_NOBLANKS => 256, XML_PARSE_SAX1 => 512,
XML_PARSE_XINCLUDE => 1024, XML_PARSE_NONET => 2048,
XML_PARSE_NODICT => 4096, XML_PARSE_NSCLEAN => 8192,
XML_PARSE_NOCDATA => 16384, XML_PARSE_NOXINCNODE => 32768,
XML_PARSE_COMPACT => 65536, XML_PARSE_OLD10 => 131072,
XML_PARSE_NOBASEFIX => 262144, XML_PARSE_HUGE => 524288,
XML_PARSE_OLDSAX => 1048576, XML_PARSE_IGNORE_ENC => 2097152,
XML_PARSE_BIG_LINES => 4194304);
pragma Convention (C, enum_c827aa94);
subtype xmlParserOption is enum_c827aa94;
procedure xmlCtxtReset (ctxt : access struct_xmlParserCtxt);
pragma Import (C, xmlCtxtReset, "xmlCtxtReset");
function xmlCtxtResetPush (ctxt : access struct_xmlParserCtxt;
chunk : access constant char; size : signed_int;
filename : access constant char; encoding : access constant char)
return signed_int;
pragma Import (C, xmlCtxtResetPush, "xmlCtxtResetPush");
function xmlCtxtUseOptions (ctxt : access struct_xmlParserCtxt;
options : signed_int) return signed_int;
pragma Import (C, xmlCtxtUseOptions, "xmlCtxtUseOptions");
function xmlReadDoc (cur : access constant xmlstring.xmlChar;
URL : access constant char; encoding : access constant char;
options : signed_int) return tree.xmlDocPtr;
pragma Import (C, xmlReadDoc, "xmlReadDoc");
function xmlReadFile (URL : access constant char;
encoding : access constant char; options : signed_int)
return tree.xmlDocPtr;
pragma Import (C, xmlReadFile, "xmlReadFile");
function xmlReadMemory (buffer : access constant char; size : signed_int;
URL : access constant char; encoding : access constant char;
options : signed_int) return tree.xmlDocPtr;
pragma Import (C, xmlReadMemory, "xmlReadMemory");
function xmlReadFd (fd : signed_int; URL : access constant char;
encoding : access constant char; options : signed_int)
return tree.xmlDocPtr;
pragma Import (C, xmlReadFd, "xmlReadFd");
function xmlReadIO (ioread : xmlIO.xmlInputReadCallback;
ioclose : xmlIO.xmlInputCloseCallback; ioctx : void_ptr;
URL : access constant char; encoding : access constant char;
options : signed_int) return tree.xmlDocPtr;
pragma Import (C, xmlReadIO, "xmlReadIO");
function xmlCtxtReadDoc (ctxt : access struct_xmlParserCtxt;
cur : access constant xmlstring.xmlChar; URL : access constant char;
encoding : access constant char; options : signed_int)
return tree.xmlDocPtr;
pragma Import (C, xmlCtxtReadDoc, "xmlCtxtReadDoc");
function xmlCtxtReadFile (ctxt : access struct_xmlParserCtxt;
filename : access constant char; encoding : access constant char;
options : signed_int) return tree.xmlDocPtr;
pragma Import (C, xmlCtxtReadFile, "xmlCtxtReadFile");
function xmlCtxtReadMemory (ctxt : access struct_xmlParserCtxt;
buffer : access constant char; size : signed_int;
URL : access constant char; encoding : access constant char;
options : signed_int) return tree.xmlDocPtr;
pragma Import (C, xmlCtxtReadMemory, "xmlCtxtReadMemory");
function xmlCtxtReadFd (ctxt : access struct_xmlParserCtxt;
fd : signed_int; URL : access constant char;
encoding : access constant char; options : signed_int)
return tree.xmlDocPtr;
pragma Import (C, xmlCtxtReadFd, "xmlCtxtReadFd");
function xmlCtxtReadIO (ctxt : access struct_xmlParserCtxt;
ioread : xmlIO.xmlInputReadCallback;
ioclose : xmlIO.xmlInputCloseCallback; ioctx : void_ptr;
URL : access constant char; encoding : access constant char;
options : signed_int) return tree.xmlDocPtr;
pragma Import (C, xmlCtxtReadIO, "xmlCtxtReadIO");
type enum_b5877831 is (XML_WITH_THREAD, XML_WITH_TREE, XML_WITH_OUTPUT,
XML_WITH_PUSH, XML_WITH_READER, XML_WITH_PATTERN, XML_WITH_WRITER,
XML_WITH_SAX1, XML_WITH_FTP, XML_WITH_HTTP, XML_WITH_VALID,
XML_WITH_HTML, XML_WITH_LEGACY, XML_WITH_C14N, XML_WITH_CATALOG,
XML_WITH_XPATH, XML_WITH_XPTR, XML_WITH_XINCLUDE, XML_WITH_ICONV,
XML_WITH_ISO8859X, XML_WITH_UNICODE, XML_WITH_REGEXP,
XML_WITH_AUTOMATA, XML_WITH_EXPR, XML_WITH_SCHEMAS,
XML_WITH_SCHEMATRON, XML_WITH_MODULES, XML_WITH_DEBUG,
XML_WITH_DEBUG_MEM, XML_WITH_DEBUG_RUN, XML_WITH_ZLIB, XML_WITH_ICU,
XML_WITH_LZMA, XML_WITH_NONE);
for enum_b5877831 use (XML_WITH_THREAD => 1, XML_WITH_TREE => 2,
XML_WITH_OUTPUT => 3, XML_WITH_PUSH => 4, XML_WITH_READER => 5,
XML_WITH_PATTERN => 6, XML_WITH_WRITER => 7, XML_WITH_SAX1 => 8,
XML_WITH_FTP => 9, XML_WITH_HTTP => 10, XML_WITH_VALID => 11,
XML_WITH_HTML => 12, XML_WITH_LEGACY => 13, XML_WITH_C14N => 14,
XML_WITH_CATALOG => 15, XML_WITH_XPATH => 16, XML_WITH_XPTR => 17,
XML_WITH_XINCLUDE => 18, XML_WITH_ICONV => 19, XML_WITH_ISO8859X => 20,
XML_WITH_UNICODE => 21, XML_WITH_REGEXP => 22, XML_WITH_AUTOMATA => 23,
XML_WITH_EXPR => 24, XML_WITH_SCHEMAS => 25, XML_WITH_SCHEMATRON => 26,
XML_WITH_MODULES => 27, XML_WITH_DEBUG => 28, XML_WITH_DEBUG_MEM => 29,
XML_WITH_DEBUG_RUN => 30, XML_WITH_ZLIB => 31, XML_WITH_ICU => 32,
XML_WITH_LZMA => 33, XML_WITH_NONE => 99999);
pragma Convention (C, enum_b5877831);
subtype xmlFeature is enum_b5877831;
function xmlHasFeature (feature : xmlFeature) return signed_int;
pragma Import (C, xmlHasFeature, "xmlHasFeature");
XML_COMPLETE_ATTRS : constant := 4;
XML_DEFAULT_VERSION : constant char_array (0 .. 3) := "1.0"
& char'Val (0);
XML_DETECT_IDS : constant := 2;
XML_SAX2_MAGIC : constant := -554844497;
XML_SKIP_IDS : constant := 8;
-- __XML_PARSER_H__ (empty)
end C.libxml.parser;
Raw
c-libxml-relaxng.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.libxml.tree;
with C.libxml.xmlerror;
with C.libxml.xmlstring;
with C.stdio;
package C.libxml.relaxng is
pragma Preelaborate;
type struct_xmlRelaxNG (<>) is limited private;
type struct_xmlRelaxNG_ptr is access all struct_xmlRelaxNG;
for struct_xmlRelaxNG_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlRelaxNG_ptr);
pragma Convention (C, struct_xmlRelaxNG_ptr);
subtype xmlRelaxNG is struct_xmlRelaxNG;
subtype xmlRelaxNG_ptr is struct_xmlRelaxNG_ptr;
subtype xmlRelaxNGPtr is xmlRelaxNG_ptr;
type access_2eb27a46 is access procedure (ctx : void_ptr;
msg : access constant char);
pragma Convention (C, access_2eb27a46);
type access_2eb27a46_ptr is access all access_2eb27a46;
for access_2eb27a46_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (access_2eb27a46_ptr);
pragma Convention (C, access_2eb27a46_ptr);
subtype xmlRelaxNGValidityErrorFunc is access_2eb27a46;
subtype xmlRelaxNGValidityErrorFunc_ptr is access_2eb27a46_ptr;
type access_6dfe5282 is access procedure (ctx : void_ptr;
msg : access constant char);
pragma Convention (C, access_6dfe5282);
type access_6dfe5282_ptr is access all access_6dfe5282;
for access_6dfe5282_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (access_6dfe5282_ptr);
pragma Convention (C, access_6dfe5282_ptr);
subtype xmlRelaxNGValidityWarningFunc is access_6dfe5282;
subtype xmlRelaxNGValidityWarningFunc_ptr is access_6dfe5282_ptr;
type struct_xmlRelaxNGParserCtxt (<>) is limited private;
type struct_xmlRelaxNGParserCtxt_ptr is
access all struct_xmlRelaxNGParserCtxt;
for struct_xmlRelaxNGParserCtxt_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlRelaxNGParserCtxt_ptr);
pragma Convention (C, struct_xmlRelaxNGParserCtxt_ptr);
subtype xmlRelaxNGParserCtxt is struct_xmlRelaxNGParserCtxt;
subtype xmlRelaxNGParserCtxt_ptr is struct_xmlRelaxNGParserCtxt_ptr;
subtype xmlRelaxNGParserCtxtPtr is xmlRelaxNGParserCtxt_ptr;
type struct_xmlRelaxNGValidCtxt (<>) is limited private;
type struct_xmlRelaxNGValidCtxt_ptr is
access all struct_xmlRelaxNGValidCtxt;
for struct_xmlRelaxNGValidCtxt_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlRelaxNGValidCtxt_ptr);
pragma Convention (C, struct_xmlRelaxNGValidCtxt_ptr);
subtype xmlRelaxNGValidCtxt is struct_xmlRelaxNGValidCtxt;
subtype xmlRelaxNGValidCtxt_ptr is struct_xmlRelaxNGValidCtxt_ptr;
subtype xmlRelaxNGValidCtxtPtr is xmlRelaxNGValidCtxt_ptr;
type enum_68136a77 is (XML_RELAXNG_OK, XML_RELAXNG_ERR_MEMORY,
XML_RELAXNG_ERR_TYPE, XML_RELAXNG_ERR_TYPEVAL, XML_RELAXNG_ERR_DUPID,
XML_RELAXNG_ERR_TYPECMP, XML_RELAXNG_ERR_NOSTATE,
XML_RELAXNG_ERR_NODEFINE, XML_RELAXNG_ERR_LISTEXTRA,
XML_RELAXNG_ERR_LISTEMPTY, XML_RELAXNG_ERR_INTERNODATA,
XML_RELAXNG_ERR_INTERSEQ, XML_RELAXNG_ERR_INTEREXTRA,
XML_RELAXNG_ERR_ELEMNAME, XML_RELAXNG_ERR_ATTRNAME,
XML_RELAXNG_ERR_ELEMNONS, XML_RELAXNG_ERR_ATTRNONS,
XML_RELAXNG_ERR_ELEMWRONGNS, XML_RELAXNG_ERR_ATTRWRONGNS,
XML_RELAXNG_ERR_ELEMEXTRANS, XML_RELAXNG_ERR_ATTREXTRANS,
XML_RELAXNG_ERR_ELEMNOTEMPTY, XML_RELAXNG_ERR_NOELEM,
XML_RELAXNG_ERR_NOTELEM, XML_RELAXNG_ERR_ATTRVALID,
XML_RELAXNG_ERR_CONTENTVALID, XML_RELAXNG_ERR_EXTRACONTENT,
XML_RELAXNG_ERR_INVALIDATTR, XML_RELAXNG_ERR_DATAELEM,
XML_RELAXNG_ERR_VALELEM, XML_RELAXNG_ERR_LISTELEM,
XML_RELAXNG_ERR_DATATYPE, XML_RELAXNG_ERR_VALUE, XML_RELAXNG_ERR_LIST,
XML_RELAXNG_ERR_NOGRAMMAR, XML_RELAXNG_ERR_EXTRADATA,
XML_RELAXNG_ERR_LACKDATA, XML_RELAXNG_ERR_INTERNAL,
XML_RELAXNG_ERR_ELEMWRONG, XML_RELAXNG_ERR_TEXTWRONG);
for enum_68136a77 use (XML_RELAXNG_OK => 0, XML_RELAXNG_ERR_MEMORY => 1,
XML_RELAXNG_ERR_TYPE => 2, XML_RELAXNG_ERR_TYPEVAL => 3,
XML_RELAXNG_ERR_DUPID => 4, XML_RELAXNG_ERR_TYPECMP => 5,
XML_RELAXNG_ERR_NOSTATE => 6, XML_RELAXNG_ERR_NODEFINE => 7,
XML_RELAXNG_ERR_LISTEXTRA => 8, XML_RELAXNG_ERR_LISTEMPTY => 9,
XML_RELAXNG_ERR_INTERNODATA => 10, XML_RELAXNG_ERR_INTERSEQ => 11,
XML_RELAXNG_ERR_INTEREXTRA => 12, XML_RELAXNG_ERR_ELEMNAME => 13,
XML_RELAXNG_ERR_ATTRNAME => 14, XML_RELAXNG_ERR_ELEMNONS => 15,
XML_RELAXNG_ERR_ATTRNONS => 16, XML_RELAXNG_ERR_ELEMWRONGNS => 17,
XML_RELAXNG_ERR_ATTRWRONGNS => 18, XML_RELAXNG_ERR_ELEMEXTRANS => 19,
XML_RELAXNG_ERR_ATTREXTRANS => 20, XML_RELAXNG_ERR_ELEMNOTEMPTY => 21,
XML_RELAXNG_ERR_NOELEM => 22, XML_RELAXNG_ERR_NOTELEM => 23,
XML_RELAXNG_ERR_ATTRVALID => 24, XML_RELAXNG_ERR_CONTENTVALID => 25,
XML_RELAXNG_ERR_EXTRACONTENT => 26, XML_RELAXNG_ERR_INVALIDATTR => 27,
XML_RELAXNG_ERR_DATAELEM => 28, XML_RELAXNG_ERR_VALELEM => 29,
XML_RELAXNG_ERR_LISTELEM => 30, XML_RELAXNG_ERR_DATATYPE => 31,
XML_RELAXNG_ERR_VALUE => 32, XML_RELAXNG_ERR_LIST => 33,
XML_RELAXNG_ERR_NOGRAMMAR => 34, XML_RELAXNG_ERR_EXTRADATA => 35,
XML_RELAXNG_ERR_LACKDATA => 36, XML_RELAXNG_ERR_INTERNAL => 37,
XML_RELAXNG_ERR_ELEMWRONG => 38, XML_RELAXNG_ERR_TEXTWRONG => 39);
pragma Convention (C, enum_68136a77);
subtype xmlRelaxNGValidErr is enum_68136a77;
type enum_771fc1ef is (XML_RELAXNGP_NONE, XML_RELAXNGP_FREE_DOC,
XML_RELAXNGP_CRNG);
for enum_771fc1ef use (XML_RELAXNGP_NONE => 0, XML_RELAXNGP_FREE_DOC => 1,
XML_RELAXNGP_CRNG => 2);
pragma Convention (C, enum_771fc1ef);
subtype xmlRelaxNGParserFlag is enum_771fc1ef;
function xmlRelaxNGInitTypes return signed_int;
pragma Import (C, xmlRelaxNGInitTypes, "xmlRelaxNGInitTypes");
procedure xmlRelaxNGCleanupTypes;
pragma Import (C, xmlRelaxNGCleanupTypes, "xmlRelaxNGCleanupTypes");
function xmlRelaxNGNewParserCtxt (URL : access constant char)
return xmlRelaxNGParserCtxtPtr;
pragma Import (C, xmlRelaxNGNewParserCtxt, "xmlRelaxNGNewParserCtxt");
function xmlRelaxNGNewMemParserCtxt (buffer : access constant char;
size : signed_int) return xmlRelaxNGParserCtxtPtr;
pragma Import (C, xmlRelaxNGNewMemParserCtxt,
"xmlRelaxNGNewMemParserCtxt");
function xmlRelaxNGNewDocParserCtxt (doc : access tree.xmlDoc)
return xmlRelaxNGParserCtxtPtr;
pragma Import (C, xmlRelaxNGNewDocParserCtxt,
"xmlRelaxNGNewDocParserCtxt");
function xmlRelaxParserSetFlag (ctxt : access xmlRelaxNGParserCtxt;
flag : signed_int) return signed_int;
pragma Import (C, xmlRelaxParserSetFlag, "xmlRelaxParserSetFlag");
procedure xmlRelaxNGFreeParserCtxt (ctxt : access xmlRelaxNGParserCtxt);
pragma Import (C, xmlRelaxNGFreeParserCtxt, "xmlRelaxNGFreeParserCtxt");
procedure xmlRelaxNGSetParserErrors (ctxt : access xmlRelaxNGParserCtxt;
err : xmlRelaxNGValidityErrorFunc;
warn : xmlRelaxNGValidityWarningFunc; ctx : void_ptr);
pragma Import (C, xmlRelaxNGSetParserErrors, "xmlRelaxNGSetParserErrors");
function xmlRelaxNGGetParserErrors (ctxt : access xmlRelaxNGParserCtxt;
err : access xmlRelaxNGValidityErrorFunc;
warn : access xmlRelaxNGValidityWarningFunc; ctx : access void_ptr)
return signed_int;
pragma Import (C, xmlRelaxNGGetParserErrors, "xmlRelaxNGGetParserErrors");
procedure xmlRelaxNGSetParserStructuredErrors (
ctxt : access xmlRelaxNGParserCtxt;
serror : xmlerror.xmlStructuredErrorFunc; ctx : void_ptr);
pragma Import (C, xmlRelaxNGSetParserStructuredErrors,
"xmlRelaxNGSetParserStructuredErrors");
function xmlRelaxNGParse (ctxt : access xmlRelaxNGParserCtxt)
return xmlRelaxNGPtr;
pragma Import (C, xmlRelaxNGParse, "xmlRelaxNGParse");
procedure xmlRelaxNGFree (schema : access xmlRelaxNG);
pragma Import (C, xmlRelaxNGFree, "xmlRelaxNGFree");
procedure xmlRelaxNGDump (output : access stdio.FILE;
schema : access xmlRelaxNG);
pragma Import (C, xmlRelaxNGDump, "xmlRelaxNGDump");
procedure xmlRelaxNGDumpTree (output : access stdio.FILE;
schema : access xmlRelaxNG);
pragma Import (C, xmlRelaxNGDumpTree, "xmlRelaxNGDumpTree");
procedure xmlRelaxNGSetValidErrors (ctxt : access xmlRelaxNGValidCtxt;
err : xmlRelaxNGValidityErrorFunc;
warn : xmlRelaxNGValidityWarningFunc; ctx : void_ptr);
pragma Import (C, xmlRelaxNGSetValidErrors, "xmlRelaxNGSetValidErrors");
function xmlRelaxNGGetValidErrors (ctxt : access xmlRelaxNGValidCtxt;
err : access xmlRelaxNGValidityErrorFunc;
warn : access xmlRelaxNGValidityWarningFunc; ctx : access void_ptr)
return signed_int;
pragma Import (C, xmlRelaxNGGetValidErrors, "xmlRelaxNGGetValidErrors");
procedure xmlRelaxNGSetValidStructuredErrors (
ctxt : access xmlRelaxNGValidCtxt;
serror : xmlerror.xmlStructuredErrorFunc; ctx : void_ptr);
pragma Import (C, xmlRelaxNGSetValidStructuredErrors,
"xmlRelaxNGSetValidStructuredErrors");
function xmlRelaxNGNewValidCtxt (schema : access xmlRelaxNG)
return xmlRelaxNGValidCtxtPtr;
pragma Import (C, xmlRelaxNGNewValidCtxt, "xmlRelaxNGNewValidCtxt");
procedure xmlRelaxNGFreeValidCtxt (ctxt : access xmlRelaxNGValidCtxt);
pragma Import (C, xmlRelaxNGFreeValidCtxt, "xmlRelaxNGFreeValidCtxt");
function xmlRelaxNGValidateDoc (ctxt : access xmlRelaxNGValidCtxt;
doc : access tree.xmlDoc) return signed_int;
pragma Import (C, xmlRelaxNGValidateDoc, "xmlRelaxNGValidateDoc");
function xmlRelaxNGValidatePushElement (ctxt : access xmlRelaxNGValidCtxt;
doc : access tree.xmlDoc; elem : access tree.xmlNode)
return signed_int;
pragma Import (C, xmlRelaxNGValidatePushElement,
"xmlRelaxNGValidatePushElement");
function xmlRelaxNGValidatePushCData (ctxt : access xmlRelaxNGValidCtxt;
data : access constant xmlstring.xmlChar; len : signed_int)
return signed_int;
pragma Import (C, xmlRelaxNGValidatePushCData,
"xmlRelaxNGValidatePushCData");
function xmlRelaxNGValidatePopElement (ctxt : access xmlRelaxNGValidCtxt;
doc : access tree.xmlDoc; elem : access tree.xmlNode)
return signed_int;
pragma Import (C, xmlRelaxNGValidatePopElement,
"xmlRelaxNGValidatePopElement");
function xmlRelaxNGValidateFullElement (ctxt : access xmlRelaxNGValidCtxt;
doc : access tree.xmlDoc; elem : access tree.xmlNode)
return signed_int;
pragma Import (C, xmlRelaxNGValidateFullElement,
"xmlRelaxNGValidateFullElement");
-- __XML_RELAX_NG__ (empty)
private
type struct_xmlRelaxNG is null record;
type struct_xmlRelaxNGParserCtxt is null record;
type struct_xmlRelaxNGValidCtxt is null record;
end C.libxml.relaxng;
Raw
c-libxml-sax.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.libxml.parser;
with C.libxml.tree;
with C.libxml.xmlstring;
package C.libxml.SAX is
pragma Preelaborate;
function getPublicId (ctx : void_ptr) return xmlstring.xmlChar_const_ptr;
pragma Import (C, getPublicId, "getPublicId");
function getSystemId (ctx : void_ptr) return xmlstring.xmlChar_const_ptr;
pragma Import (C, getSystemId, "getSystemId");
procedure setDocumentLocator (ctx : void_ptr;
loc : access parser.struct_xmlSAXLocator);
pragma Import (C, setDocumentLocator, "setDocumentLocator");
function getLineNumber (ctx : void_ptr) return signed_int;
pragma Import (C, getLineNumber, "getLineNumber");
function getColumnNumber (ctx : void_ptr) return signed_int;
pragma Import (C, getColumnNumber, "getColumnNumber");
function isStandalone (ctx : void_ptr) return signed_int;
pragma Import (C, isStandalone, "isStandalone");
function hasInternalSubset (ctx : void_ptr) return signed_int;
pragma Import (C, hasInternalSubset, "hasInternalSubset");
function hasExternalSubset (ctx : void_ptr) return signed_int;
pragma Import (C, hasExternalSubset, "hasExternalSubset");
procedure internalSubset (ctx : void_ptr;
name : access constant xmlstring.xmlChar;
ExternalID : access constant xmlstring.xmlChar;
SystemID : access constant xmlstring.xmlChar);
pragma Import (C, internalSubset, "internalSubset");
procedure externalSubset (ctx : void_ptr;
name : access constant xmlstring.xmlChar;
ExternalID : access constant xmlstring.xmlChar;
SystemID : access constant xmlstring.xmlChar);
pragma Import (C, externalSubset, "externalSubset");
function getEntity (ctx : void_ptr;
name : access constant xmlstring.xmlChar) return tree.xmlEntityPtr;
pragma Import (C, getEntity, "getEntity");
function getParameterEntity (ctx : void_ptr;
name : access constant xmlstring.xmlChar) return tree.xmlEntityPtr;
pragma Import (C, getParameterEntity, "getParameterEntity");
function resolveEntity (ctx : void_ptr;
publicId : access constant xmlstring.xmlChar;
systemId : access constant xmlstring.xmlChar)
return tree.xmlParserInputPtr;
pragma Import (C, resolveEntity, "resolveEntity");
procedure entityDecl (ctx : void_ptr;
name : access constant xmlstring.xmlChar; A_type : signed_int;
publicId : access constant xmlstring.xmlChar;
systemId : access constant xmlstring.xmlChar;
content : access xmlstring.xmlChar);
pragma Import (C, entityDecl, "entityDecl");
procedure attributeDecl (ctx : void_ptr;
elem : access constant xmlstring.xmlChar;
fullname : access constant xmlstring.xmlChar; A_type : signed_int;
def : signed_int; defaultValue : access constant xmlstring.xmlChar;
tree : access libxml.tree.xmlEnumeration);
pragma Import (C, attributeDecl, "attributeDecl");
procedure elementDecl (ctx : void_ptr;
name : access constant xmlstring.xmlChar; A_type : signed_int;
content : access tree.xmlElementContent);
pragma Import (C, elementDecl, "elementDecl");
procedure notationDecl (ctx : void_ptr;
name : access constant xmlstring.xmlChar;
publicId : access constant xmlstring.xmlChar;
systemId : access constant xmlstring.xmlChar);
pragma Import (C, notationDecl, "notationDecl");
procedure unparsedEntityDecl (ctx : void_ptr;
name : access constant xmlstring.xmlChar;
publicId : access constant xmlstring.xmlChar;
systemId : access constant xmlstring.xmlChar;
notationName : access constant xmlstring.xmlChar);
pragma Import (C, unparsedEntityDecl, "unparsedEntityDecl");
procedure startDocument (ctx : void_ptr);
pragma Import (C, startDocument, "startDocument");
procedure endDocument (ctx : void_ptr);
pragma Import (C, endDocument, "endDocument");
procedure attribute (ctx : void_ptr;
fullname : access constant xmlstring.xmlChar;
value : access constant xmlstring.xmlChar);
pragma Import (C, attribute, "attribute");
procedure startElement (ctx : void_ptr;
fullname : access constant xmlstring.xmlChar;
atts : access xmlstring.xmlChar_const_ptr);
pragma Import (C, startElement, "startElement");
procedure endElement (ctx : void_ptr;
name : access constant xmlstring.xmlChar);
pragma Import (C, endElement, "endElement");
procedure reference (ctx : void_ptr;
name : access constant xmlstring.xmlChar);
pragma Import (C, reference, "reference");
procedure characters (ctx : void_ptr;
ch : access constant xmlstring.xmlChar; len : signed_int);
pragma Import (C, characters, "characters");
procedure ignorableWhitespace (ctx : void_ptr;
ch : access constant xmlstring.xmlChar; len : signed_int);
pragma Import (C, ignorableWhitespace, "ignorableWhitespace");
procedure processingInstruction (ctx : void_ptr;
target : access constant xmlstring.xmlChar;
data : access constant xmlstring.xmlChar);
pragma Import (C, processingInstruction, "processingInstruction");
procedure globalNamespace (ctx : void_ptr;
href : access constant xmlstring.xmlChar;
prefix : access constant xmlstring.xmlChar);
pragma Import (C, globalNamespace, "globalNamespace");
procedure setNamespace (ctx : void_ptr;
name : access constant xmlstring.xmlChar);
pragma Import (C, setNamespace, "setNamespace");
function getNamespace (ctx : void_ptr) return tree.xmlNsPtr;
pragma Import (C, getNamespace, "getNamespace");
function checkNamespace (ctx : void_ptr;
nameSpace : access xmlstring.xmlChar) return signed_int;
pragma Import (C, checkNamespace, "checkNamespace");
procedure namespaceDecl (ctx : void_ptr;
href : access constant xmlstring.xmlChar;
prefix : access constant xmlstring.xmlChar);
pragma Import (C, namespaceDecl, "namespaceDecl");
procedure comment (ctx : void_ptr;
value : access constant xmlstring.xmlChar);
pragma Import (C, comment, "comment");
procedure cdataBlock (ctx : void_ptr;
value : access constant xmlstring.xmlChar; len : signed_int);
pragma Import (C, cdataBlock, "cdataBlock");
procedure initxmlDefaultSAXHandler (hdlr : access parser.xmlSAXHandlerV1;
warning : signed_int);
pragma Import (C, initxmlDefaultSAXHandler, "initxmlDefaultSAXHandler");
procedure inithtmlDefaultSAXHandler (
hdlr : access parser.xmlSAXHandlerV1);
pragma Import (C, inithtmlDefaultSAXHandler, "inithtmlDefaultSAXHandler");
procedure initdocbDefaultSAXHandler (
hdlr : access parser.xmlSAXHandlerV1);
pragma Import (C, initdocbDefaultSAXHandler, "initdocbDefaultSAXHandler");
-- __XML_SAX_H__ (empty)
end C.libxml.SAX;
Raw
c-libxml-sax2.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.
-------------------------------------------------------------------------------
limited with C.libxml.parser;
with C.libxml.tree;
with C.libxml.xmlstring;
package C.libxml.SAX2 is
pragma Preelaborate;
function xmlSAX2GetPublicId (ctx : void_ptr)
return xmlstring.xmlChar_const_ptr;
pragma Import (C, xmlSAX2GetPublicId, "xmlSAX2GetPublicId");
function xmlSAX2GetSystemId (ctx : void_ptr)
return xmlstring.xmlChar_const_ptr;
pragma Import (C, xmlSAX2GetSystemId, "xmlSAX2GetSystemId");
procedure xmlSAX2SetDocumentLocator (ctx : void_ptr;
loc : access parser.struct_xmlSAXLocator);
pragma Import (C, xmlSAX2SetDocumentLocator, "xmlSAX2SetDocumentLocator");
function xmlSAX2GetLineNumber (ctx : void_ptr) return signed_int;
pragma Import (C, xmlSAX2GetLineNumber, "xmlSAX2GetLineNumber");
function xmlSAX2GetColumnNumber (ctx : void_ptr) return signed_int;
pragma Import (C, xmlSAX2GetColumnNumber, "xmlSAX2GetColumnNumber");
function xmlSAX2IsStandalone (ctx : void_ptr) return signed_int;
pragma Import (C, xmlSAX2IsStandalone, "xmlSAX2IsStandalone");
function xmlSAX2HasInternalSubset (ctx : void_ptr) return signed_int;
pragma Import (C, xmlSAX2HasInternalSubset, "xmlSAX2HasInternalSubset");
function xmlSAX2HasExternalSubset (ctx : void_ptr) return signed_int;
pragma Import (C, xmlSAX2HasExternalSubset, "xmlSAX2HasExternalSubset");
procedure xmlSAX2InternalSubset (ctx : void_ptr;
name : access constant xmlstring.xmlChar;
ExternalID : access constant xmlstring.xmlChar;
SystemID : access constant xmlstring.xmlChar);
pragma Import (C, xmlSAX2InternalSubset, "xmlSAX2InternalSubset");
procedure xmlSAX2ExternalSubset (ctx : void_ptr;
name : access constant xmlstring.xmlChar;
ExternalID : access constant xmlstring.xmlChar;
SystemID : access constant xmlstring.xmlChar);
pragma Import (C, xmlSAX2ExternalSubset, "xmlSAX2ExternalSubset");
function xmlSAX2GetEntity (ctx : void_ptr;
name : access constant xmlstring.xmlChar) return tree.xmlEntityPtr;
pragma Import (C, xmlSAX2GetEntity, "xmlSAX2GetEntity");
function xmlSAX2GetParameterEntity (ctx : void_ptr;
name : access constant xmlstring.xmlChar) return tree.xmlEntityPtr;
pragma Import (C, xmlSAX2GetParameterEntity, "xmlSAX2GetParameterEntity");
function xmlSAX2ResolveEntity (ctx : void_ptr;
publicId : access constant xmlstring.xmlChar;
systemId : access constant xmlstring.xmlChar)
return tree.xmlParserInputPtr;
pragma Import (C, xmlSAX2ResolveEntity, "xmlSAX2ResolveEntity");
procedure xmlSAX2EntityDecl (ctx : void_ptr;
name : access constant xmlstring.xmlChar; A_type : signed_int;
publicId : access constant xmlstring.xmlChar;
systemId : access constant xmlstring.xmlChar;
content : access xmlstring.xmlChar);
pragma Import (C, xmlSAX2EntityDecl, "xmlSAX2EntityDecl");
procedure xmlSAX2AttributeDecl (ctx : void_ptr;
elem : access constant xmlstring.xmlChar;
fullname : access constant xmlstring.xmlChar; A_type : signed_int;
def : signed_int; defaultValue : access constant xmlstring.xmlChar;
tree : access libxml.tree.xmlEnumeration);
pragma Import (C, xmlSAX2AttributeDecl, "xmlSAX2AttributeDecl");
procedure xmlSAX2ElementDecl (ctx : void_ptr;
name : access constant xmlstring.xmlChar; A_type : signed_int;
content : access tree.xmlElementContent);
pragma Import (C, xmlSAX2ElementDecl, "xmlSAX2ElementDecl");
procedure xmlSAX2NotationDecl (ctx : void_ptr;
name : access constant xmlstring.xmlChar;
publicId : access constant xmlstring.xmlChar;
systemId : access constant xmlstring.xmlChar);
pragma Import (C, xmlSAX2NotationDecl, "xmlSAX2NotationDecl");
procedure xmlSAX2UnparsedEntityDecl (ctx : void_ptr;
name : access constant xmlstring.xmlChar;
publicId : access constant xmlstring.xmlChar;
systemId : access constant xmlstring.xmlChar;
notationName : access constant xmlstring.xmlChar);
pragma Import (C, xmlSAX2UnparsedEntityDecl, "xmlSAX2UnparsedEntityDecl");
procedure xmlSAX2StartDocument (ctx : void_ptr);
pragma Import (C, xmlSAX2StartDocument, "xmlSAX2StartDocument");
procedure xmlSAX2EndDocument (ctx : void_ptr);
pragma Import (C, xmlSAX2EndDocument, "xmlSAX2EndDocument");
procedure xmlSAX2StartElement (ctx : void_ptr;
fullname : access constant xmlstring.xmlChar;
atts : access xmlstring.xmlChar_const_ptr);
pragma Import (C, xmlSAX2StartElement, "xmlSAX2StartElement");
procedure xmlSAX2EndElement (ctx : void_ptr;
name : access constant xmlstring.xmlChar);
pragma Import (C, xmlSAX2EndElement, "xmlSAX2EndElement");
procedure xmlSAX2StartElementNs (ctx : void_ptr;
localname : access constant xmlstring.xmlChar;
prefix : access constant xmlstring.xmlChar;
URI : access constant xmlstring.xmlChar; nb_namespaces : signed_int;
namespaces : access xmlstring.xmlChar_const_ptr;
nb_attributes : signed_int; nb_defaulted : signed_int;
attributes : access xmlstring.xmlChar_const_ptr);
pragma Import (C, xmlSAX2StartElementNs, "xmlSAX2StartElementNs");
procedure xmlSAX2EndElementNs (ctx : void_ptr;
localname : access constant xmlstring.xmlChar;
prefix : access constant xmlstring.xmlChar;
URI : access constant xmlstring.xmlChar);
pragma Import (C, xmlSAX2EndElementNs, "xmlSAX2EndElementNs");
procedure xmlSAX2Reference (ctx : void_ptr;
name : access constant xmlstring.xmlChar);
pragma Import (C, xmlSAX2Reference, "xmlSAX2Reference");
procedure xmlSAX2Characters (ctx : void_ptr;
ch : access constant xmlstring.xmlChar; len : signed_int);
pragma Import (C, xmlSAX2Characters, "xmlSAX2Characters");
procedure xmlSAX2IgnorableWhitespace (ctx : void_ptr;
ch : access constant xmlstring.xmlChar; len : signed_int);
pragma Import (C, xmlSAX2IgnorableWhitespace,
"xmlSAX2IgnorableWhitespace");
procedure xmlSAX2ProcessingInstruction (ctx : void_ptr;
target : access constant xmlstring.xmlChar;
data : access constant xmlstring.xmlChar);
pragma Import (C, xmlSAX2ProcessingInstruction,
"xmlSAX2ProcessingInstruction");
procedure xmlSAX2Comment (ctx : void_ptr;
value : access constant xmlstring.xmlChar);
pragma Import (C, xmlSAX2Comment, "xmlSAX2Comment");
procedure xmlSAX2CDataBlock (ctx : void_ptr;
value : access constant xmlstring.xmlChar; len : signed_int);
pragma Import (C, xmlSAX2CDataBlock, "xmlSAX2CDataBlock");
function xmlSAXDefaultVersion (version : signed_int) return signed_int;
pragma Import (C, xmlSAXDefaultVersion, "xmlSAXDefaultVersion");
function xmlSAXVersion (hdlr : access parser.struct_xmlSAXHandler;
version : signed_int) return signed_int;
pragma Import (C, xmlSAXVersion, "xmlSAXVersion");
procedure xmlSAX2InitDefaultSAXHandler (
hdlr : access parser.struct_xmlSAXHandler; warning : signed_int);
pragma Import (C, xmlSAX2InitDefaultSAXHandler,
"xmlSAX2InitDefaultSAXHandler");
procedure xmlSAX2InitHtmlDefaultSAXHandler (
hdlr : access parser.struct_xmlSAXHandler);
pragma Import (C, xmlSAX2InitHtmlDefaultSAXHandler,
"xmlSAX2InitHtmlDefaultSAXHandler");
procedure htmlDefaultSAXHandlerInit;
pragma Import (C, htmlDefaultSAXHandlerInit, "htmlDefaultSAXHandlerInit");
procedure xmlSAX2InitDocbDefaultSAXHandler (
hdlr : access parser.struct_xmlSAXHandler);
pragma Import (C, xmlSAX2InitDocbDefaultSAXHandler,
"xmlSAX2InitDocbDefaultSAXHandler");
procedure docbDefaultSAXHandlerInit;
pragma Import (C, docbDefaultSAXHandlerInit, "docbDefaultSAXHandlerInit");
procedure xmlDefaultSAXHandlerInit;
pragma Import (C, xmlDefaultSAXHandlerInit, "xmlDefaultSAXHandlerInit");
-- __XML_SAX2_H__ (empty)
end C.libxml.SAX2;
Raw
c-libxml-threads.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.libxml.globals;
package C.libxml.threads is
pragma Preelaborate;
type struct_xmlMutex (<>) is limited private;
type struct_xmlMutex_ptr is access all struct_xmlMutex;
for struct_xmlMutex_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlMutex_ptr);
pragma Convention (C, struct_xmlMutex_ptr);
subtype xmlMutex is struct_xmlMutex;
subtype xmlMutex_ptr is struct_xmlMutex_ptr;
subtype xmlMutexPtr is xmlMutex_ptr;
type struct_xmlRMutex (<>) is limited private;
type struct_xmlRMutex_ptr is access all struct_xmlRMutex;
for struct_xmlRMutex_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlRMutex_ptr);
pragma Convention (C, struct_xmlRMutex_ptr);
subtype xmlRMutex is struct_xmlRMutex;
subtype xmlRMutex_ptr is struct_xmlRMutex_ptr;
subtype xmlRMutexPtr is xmlRMutex_ptr;
-- #include <libxml/hash.h>
-- #include <libxml/xmlerror.h>
-- #include <libxml/list.h>
-- #include <libxml/xmlautomata.h>
-- #include <libxml/valid.h>
-- #include <libxml/entities.h>
-- #include <iconv.h>
-- #include <libxml/encoding.h>
-- #include <libxml/xmlIO.h>
-- #include <libxml/parser.h>
-- #include <stddef.h>
-- #include <bits/waitflags.h>
-- #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>
-- #include <alloca.h>
-- #include <stdlib.h>
-- #include <libxml/xlink.h>
-- #include <libxml/SAX.h>
-- #include <libxml/SAX2.h>
-- #include <libxml/globals.h>
function xmlNewMutex return xmlMutexPtr;
pragma Import (C, xmlNewMutex, "xmlNewMutex");
procedure xmlMutexLock (tok : access xmlMutex);
pragma Import (C, xmlMutexLock, "xmlMutexLock");
procedure xmlMutexUnlock (tok : access xmlMutex);
pragma Import (C, xmlMutexUnlock, "xmlMutexUnlock");
procedure xmlFreeMutex (tok : access xmlMutex);
pragma Import (C, xmlFreeMutex, "xmlFreeMutex");
function xmlNewRMutex return xmlRMutexPtr;
pragma Import (C, xmlNewRMutex, "xmlNewRMutex");
procedure xmlRMutexLock (tok : access xmlRMutex);
pragma Import (C, xmlRMutexLock, "xmlRMutexLock");
procedure xmlRMutexUnlock (tok : access xmlRMutex);
pragma Import (C, xmlRMutexUnlock, "xmlRMutexUnlock");
procedure xmlFreeRMutex (tok : access xmlRMutex);
pragma Import (C, xmlFreeRMutex, "xmlFreeRMutex");
procedure xmlInitThreads;
pragma Import (C, xmlInitThreads, "xmlInitThreads");
procedure xmlLockLibrary;
pragma Import (C, xmlLockLibrary, "xmlLockLibrary");
procedure xmlUnlockLibrary;
pragma Import (C, xmlUnlockLibrary, "xmlUnlockLibrary");
function xmlGetThreadId return signed_int;
pragma Import (C, xmlGetThreadId, "xmlGetThreadId");
function xmlIsMainThread return signed_int;
pragma Import (C, xmlIsMainThread, "xmlIsMainThread");
procedure xmlCleanupThreads;
pragma Import (C, xmlCleanupThreads, "xmlCleanupThreads");
function xmlGetGlobalState return globals.xmlGlobalStatePtr;
pragma Import (C, xmlGetGlobalState, "xmlGetGlobalState");
-- __XML_THREADS_H__ (empty)
private
type struct_xmlMutex is null record;
type struct_xmlRMutex is null record;
end C.libxml.threads;
Raw
c-libxml-tree.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 Ada.Unchecked_Conversion;
with C.libxml.dict;
limited with C.libxml.entities;
limited with C.libxml.parser;
limited with C.libxml.xmlIO;
with C.libxml.xmlregexp;
with C.libxml.xmlstring;
with C.stddef;
with C.stdio;
package C.libxml.tree is
pragma Preelaborate;
function Cast is new Ada.Unchecked_Conversion (char_array,
xmlstring.xmlChar_const_ptr);
-- subtype struct_xmlParserInputBuffer is xmlIO.struct_xmlParserInputBu...;
type struct_xmlParserInputBuffer_ptr is
access all xmlIO.struct_xmlParserInputBuffer;
for struct_xmlParserInputBuffer_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlParserInputBuffer_ptr);
pragma Convention (C, struct_xmlParserInputBuffer_ptr);
-- subtype xmlParserInputBuffer is xmlIO.struct_xmlParserInputBuffer;
subtype xmlParserInputBuffer_ptr is struct_xmlParserInputBuffer_ptr;
subtype xmlParserInputBufferPtr is xmlParserInputBuffer_ptr;
-- subtype struct_xmlOutputBuffer is xmlIO.struct_xmlOutputBuffer;
type struct_xmlOutputBuffer_ptr is
access all xmlIO.struct_xmlOutputBuffer;
for struct_xmlOutputBuffer_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlOutputBuffer_ptr);
pragma Convention (C, struct_xmlOutputBuffer_ptr);
-- subtype xmlOutputBuffer is xmlIO.struct_xmlOutputBuffer;
subtype xmlOutputBuffer_ptr is struct_xmlOutputBuffer_ptr;
subtype xmlOutputBufferPtr is xmlOutputBuffer_ptr;
-- subtype struct_xmlParserInput is parser.struct_xmlParserInput;
type struct_xmlParserInput_ptr is access all parser.struct_xmlParserInput;
for struct_xmlParserInput_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlParserInput_ptr);
pragma Convention (C, struct_xmlParserInput_ptr);
type struct_xmlParserInput_ptr_ptr is
access all struct_xmlParserInput_ptr;
for struct_xmlParserInput_ptr_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlParserInput_ptr_ptr);
pragma Convention (C, struct_xmlParserInput_ptr_ptr);
-- subtype xmlParserInput is parser.struct_xmlParserInput;
subtype xmlParserInput_ptr is struct_xmlParserInput_ptr;
subtype xmlParserInput_ptr_ptr is struct_xmlParserInput_ptr_ptr;
subtype xmlParserInputPtr is xmlParserInput_ptr;
subtype xmlParserInputPtr_ptr is xmlParserInput_ptr_ptr;
-- subtype struct_xmlParserCtxt is parser.struct_xmlParserCtxt;
type struct_xmlParserCtxt_ptr is access all parser.struct_xmlParserCtxt;
for struct_xmlParserCtxt_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlParserCtxt_ptr);
pragma Convention (C, struct_xmlParserCtxt_ptr);
-- subtype xmlParserCtxt is parser.struct_xmlParserCtxt;
subtype xmlParserCtxt_ptr is struct_xmlParserCtxt_ptr;
subtype xmlParserCtxtPtr is xmlParserCtxt_ptr;
-- subtype struct_xmlSAXLocator is parser.struct_xmlSAXLocator;
type struct_xmlSAXLocator_ptr is access all parser.struct_xmlSAXLocator;
for struct_xmlSAXLocator_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlSAXLocator_ptr);
pragma Convention (C, struct_xmlSAXLocator_ptr);
-- subtype xmlSAXLocator is parser.struct_xmlSAXLocator;
subtype xmlSAXLocator_ptr is struct_xmlSAXLocator_ptr;
subtype xmlSAXLocatorPtr is xmlSAXLocator_ptr;
-- subtype struct_xmlSAXHandler is parser.struct_xmlSAXHandler;
type struct_xmlSAXHandler_ptr is access all parser.struct_xmlSAXHandler;
for struct_xmlSAXHandler_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlSAXHandler_ptr);
pragma Convention (C, struct_xmlSAXHandler_ptr);
type struct_xmlSAXHandler_ptr_ptr is access all struct_xmlSAXHandler_ptr;
for struct_xmlSAXHandler_ptr_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlSAXHandler_ptr_ptr);
pragma Convention (C, struct_xmlSAXHandler_ptr_ptr);
-- subtype xmlSAXHandler is parser.struct_xmlSAXHandler;
subtype xmlSAXHandler_ptr is struct_xmlSAXHandler_ptr;
subtype xmlSAXHandler_ptr_ptr is struct_xmlSAXHandler_ptr_ptr;
subtype xmlSAXHandlerPtr is xmlSAXHandler_ptr;
subtype xmlSAXHandlerPtr_ptr is xmlSAXHandler_ptr_ptr;
-- subtype struct_xmlEntity is entities.struct_xmlEntity;
type struct_xmlEntity_ptr is access all entities.struct_xmlEntity;
for struct_xmlEntity_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlEntity_ptr);
pragma Convention (C, struct_xmlEntity_ptr);
-- subtype xmlEntity is entities.struct_xmlEntity;
subtype xmlEntity_ptr is struct_xmlEntity_ptr;
subtype xmlEntityPtr is xmlEntity_ptr;
type enum_c3a4d444 is (XML_BUFFER_ALLOC_DOUBLEIT, XML_BUFFER_ALLOC_EXACT,
XML_BUFFER_ALLOC_IMMUTABLE, XML_BUFFER_ALLOC_IO,
XML_BUFFER_ALLOC_HYBRID, XML_BUFFER_ALLOC_BOUNDED);
for enum_c3a4d444 use (XML_BUFFER_ALLOC_DOUBLEIT => 0,
XML_BUFFER_ALLOC_EXACT => 1, XML_BUFFER_ALLOC_IMMUTABLE => 2,
XML_BUFFER_ALLOC_IO => 3, XML_BUFFER_ALLOC_HYBRID => 4,
XML_BUFFER_ALLOC_BOUNDED => 5);
pragma Convention (C, enum_c3a4d444);
type enum_c3a4d444_ptr is access all enum_c3a4d444;
for enum_c3a4d444_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (enum_c3a4d444_ptr);
pragma Convention (C, enum_c3a4d444_ptr);
subtype xmlBufferAllocationScheme is enum_c3a4d444;
subtype xmlBufferAllocationScheme_ptr is enum_c3a4d444_ptr;
type struct_xmlBuffer;
type struct_xmlBuffer_ptr is access all struct_xmlBuffer;
for struct_xmlBuffer_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlBuffer_ptr);
pragma Convention (C, struct_xmlBuffer_ptr);
type struct_xmlBuffer_const_ptr is access constant struct_xmlBuffer;
for struct_xmlBuffer_const_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlBuffer_const_ptr);
pragma Convention (C, struct_xmlBuffer_const_ptr);
subtype xmlBuffer is struct_xmlBuffer;
subtype xmlBuffer_ptr is struct_xmlBuffer_ptr;
subtype xmlBuffer_const_ptr is struct_xmlBuffer_const_ptr;
subtype xmlBufferPtr is xmlBuffer_ptr;
type struct_xmlBuffer is record
content : aliased xmlstring.xmlChar_ptr;
F_use : aliased unsigned_int;
size : aliased unsigned_int;
alloc : aliased xmlBufferAllocationScheme;
contentIO : aliased xmlstring.xmlChar_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_xmlBuffer);
type struct_xmlBuf (<>) is limited private;
type struct_xmlBuf_ptr is access all struct_xmlBuf;
for struct_xmlBuf_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlBuf_ptr);
pragma Convention (C, struct_xmlBuf_ptr);
type struct_xmlBuf_const_ptr is access constant struct_xmlBuf;
for struct_xmlBuf_const_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlBuf_const_ptr);
pragma Convention (C, struct_xmlBuf_const_ptr);
subtype xmlBuf is struct_xmlBuf;
subtype xmlBuf_ptr is struct_xmlBuf_ptr;
subtype xmlBuf_const_ptr is struct_xmlBuf_const_ptr;
subtype xmlBufPtr is xmlBuf_ptr;
function xmlBufContent (buf : access constant xmlBuf)
return xmlstring.xmlChar_ptr;
pragma Import (C, xmlBufContent, "xmlBufContent");
function xmlBufEnd (buf : access xmlBuf) return xmlstring.xmlChar_ptr;
pragma Import (C, xmlBufEnd, "xmlBufEnd");
function xmlBufUse (buf : access xmlBuf) return stddef.size_t;
pragma Import (C, xmlBufUse, "xmlBufUse");
function xmlBufShrink (buf : access xmlBuf; len : stddef.size_t)
return stddef.size_t;
pragma Import (C, xmlBufShrink, "xmlBufShrink");
type enum_1b5c1861 is (XML_ELEMENT_NODE, XML_ATTRIBUTE_NODE,
XML_TEXT_NODE, XML_CDATA_SECTION_NODE, XML_ENTITY_REF_NODE,
XML_ENTITY_NODE, XML_PI_NODE, XML_COMMENT_NODE, XML_DOCUMENT_NODE,
XML_DOCUMENT_TYPE_NODE, XML_DOCUMENT_FRAG_NODE, XML_NOTATION_NODE,
XML_HTML_DOCUMENT_NODE, XML_DTD_NODE, XML_ELEMENT_DECL,
XML_ATTRIBUTE_DECL, XML_ENTITY_DECL, XML_NAMESPACE_DECL,
XML_XINCLUDE_START, XML_XINCLUDE_END, XML_DOCB_DOCUMENT_NODE);
for enum_1b5c1861 use (XML_ELEMENT_NODE => 1, XML_ATTRIBUTE_NODE => 2,
XML_TEXT_NODE => 3, XML_CDATA_SECTION_NODE => 4,
XML_ENTITY_REF_NODE => 5, XML_ENTITY_NODE => 6, XML_PI_NODE => 7,
XML_COMMENT_NODE => 8, XML_DOCUMENT_NODE => 9,
XML_DOCUMENT_TYPE_NODE => 10, XML_DOCUMENT_FRAG_NODE => 11,
XML_NOTATION_NODE => 12, XML_HTML_DOCUMENT_NODE => 13,
XML_DTD_NODE => 14, XML_ELEMENT_DECL => 15, XML_ATTRIBUTE_DECL => 16,
XML_ENTITY_DECL => 17, XML_NAMESPACE_DECL => 18,
XML_XINCLUDE_START => 19, XML_XINCLUDE_END => 20,
XML_DOCB_DOCUMENT_NODE => 21);
pragma Convention (C, enum_1b5c1861);
subtype xmlElementType is enum_1b5c1861;
type struct_xmlNotation;
type struct_xmlNotation_ptr is access all struct_xmlNotation;
for struct_xmlNotation_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlNotation_ptr);
pragma Convention (C, struct_xmlNotation_ptr);
subtype xmlNotation is struct_xmlNotation;
subtype xmlNotation_ptr is struct_xmlNotation_ptr;
subtype xmlNotationPtr is xmlNotation_ptr;
type struct_xmlNotation is record
name : aliased xmlstring.xmlChar_const_ptr;
PublicID : aliased xmlstring.xmlChar_const_ptr;
SystemID : aliased xmlstring.xmlChar_const_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_xmlNotation);
type enum_02a4d247 is (XML_ATTRIBUTE_CDATA, XML_ATTRIBUTE_ID,
XML_ATTRIBUTE_IDREF, XML_ATTRIBUTE_IDREFS, XML_ATTRIBUTE_ENTITY,
XML_ATTRIBUTE_ENTITIES, XML_ATTRIBUTE_NMTOKEN, XML_ATTRIBUTE_NMTOKENS,
XML_ATTRIBUTE_ENUMERATION, XML_ATTRIBUTE_NOTATION);
for enum_02a4d247 use (XML_ATTRIBUTE_CDATA => 1, XML_ATTRIBUTE_ID => 2,
XML_ATTRIBUTE_IDREF => 3, XML_ATTRIBUTE_IDREFS => 4,
XML_ATTRIBUTE_ENTITY => 5, XML_ATTRIBUTE_ENTITIES => 6,
XML_ATTRIBUTE_NMTOKEN => 7, XML_ATTRIBUTE_NMTOKENS => 8,
XML_ATTRIBUTE_ENUMERATION => 9, XML_ATTRIBUTE_NOTATION => 10);
pragma Convention (C, enum_02a4d247);
subtype xmlAttributeType is enum_02a4d247;
type enum_df312e2b is (XML_ATTRIBUTE_NONE, XML_ATTRIBUTE_REQUIRED,
XML_ATTRIBUTE_IMPLIED, XML_ATTRIBUTE_FIXED);
for enum_df312e2b use (XML_ATTRIBUTE_NONE => 1,
XML_ATTRIBUTE_REQUIRED => 2, XML_ATTRIBUTE_IMPLIED => 3,
XML_ATTRIBUTE_FIXED => 4);
pragma Convention (C, enum_df312e2b);
subtype xmlAttributeDefault is enum_df312e2b;
type struct_xmlEnumeration;
type struct_xmlEnumeration_ptr is access all struct_xmlEnumeration;
for struct_xmlEnumeration_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlEnumeration_ptr);
pragma Convention (C, struct_xmlEnumeration_ptr);
subtype xmlEnumeration is struct_xmlEnumeration;
subtype xmlEnumeration_ptr is struct_xmlEnumeration_ptr;
subtype xmlEnumerationPtr is xmlEnumeration_ptr;
type struct_xmlEnumeration is record
next : aliased struct_xmlEnumeration_ptr;
name : aliased xmlstring.xmlChar_const_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_xmlEnumeration);
type struct_xmlAttribute;
type struct_xmlAttribute_ptr is access all struct_xmlAttribute;
for struct_xmlAttribute_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlAttribute_ptr);
pragma Convention (C, struct_xmlAttribute_ptr);
subtype xmlAttribute is struct_xmlAttribute;
subtype xmlAttribute_ptr is struct_xmlAttribute_ptr;
subtype xmlAttributePtr is xmlAttribute_ptr;
type struct_xmlNode;
type struct_xmlNode_ptr is access all struct_xmlNode;
for struct_xmlNode_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlNode_ptr);
pragma Convention (C, struct_xmlNode_ptr);
type struct_xmlNode_ptr_ptr is access all struct_xmlNode_ptr;
for struct_xmlNode_ptr_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlNode_ptr_ptr);
pragma Convention (C, struct_xmlNode_ptr_ptr);
type struct_xmlNode_const_ptr is access constant struct_xmlNode;
for struct_xmlNode_const_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlNode_const_ptr);
pragma Convention (C, struct_xmlNode_const_ptr);
type struct_xmlDtd;
type struct_xmlDtd_ptr is access all struct_xmlDtd;
for struct_xmlDtd_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlDtd_ptr);
pragma Convention (C, struct_xmlDtd_ptr);
type struct_xmlDoc;
type struct_xmlDoc_ptr is access all struct_xmlDoc;
for struct_xmlDoc_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlDoc_ptr);
pragma Convention (C, struct_xmlDoc_ptr);
type struct_xmlDoc_ptr_ptr is access all struct_xmlDoc_ptr;
for struct_xmlDoc_ptr_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlDoc_ptr_ptr);
pragma Convention (C, struct_xmlDoc_ptr_ptr);
type struct_xmlDoc_const_ptr is access constant struct_xmlDoc;
for struct_xmlDoc_const_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlDoc_const_ptr);
pragma Convention (C, struct_xmlDoc_const_ptr);
type struct_xmlAttribute is record
F_private : aliased void_ptr;
F_type : aliased xmlElementType;
name : aliased xmlstring.xmlChar_const_ptr;
children : aliased struct_xmlNode_ptr;
last : aliased struct_xmlNode_ptr;
parent : aliased struct_xmlDtd_ptr;
next : aliased struct_xmlNode_ptr;
prev : aliased struct_xmlNode_ptr;
doc : aliased struct_xmlDoc_ptr;
nexth : aliased struct_xmlAttribute_ptr;
atype : aliased xmlAttributeType;
def : aliased xmlAttributeDefault;
defaultValue : aliased xmlstring.xmlChar_const_ptr;
tree : aliased xmlEnumerationPtr;
prefix : aliased xmlstring.xmlChar_const_ptr;
elem : aliased xmlstring.xmlChar_const_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_xmlAttribute);
type enum_8fcbf058 is (XML_ELEMENT_CONTENT_PCDATA,
XML_ELEMENT_CONTENT_ELEMENT, XML_ELEMENT_CONTENT_SEQ,
XML_ELEMENT_CONTENT_OR);
for enum_8fcbf058 use (XML_ELEMENT_CONTENT_PCDATA => 1,
XML_ELEMENT_CONTENT_ELEMENT => 2, XML_ELEMENT_CONTENT_SEQ => 3,
XML_ELEMENT_CONTENT_OR => 4);
pragma Convention (C, enum_8fcbf058);
subtype xmlElementContentType is enum_8fcbf058;
type enum_56f8eefb is (XML_ELEMENT_CONTENT_ONCE, XML_ELEMENT_CONTENT_OPT,
XML_ELEMENT_CONTENT_MULT, XML_ELEMENT_CONTENT_PLUS);
for enum_56f8eefb use (XML_ELEMENT_CONTENT_ONCE => 1,
XML_ELEMENT_CONTENT_OPT => 2, XML_ELEMENT_CONTENT_MULT => 3,
XML_ELEMENT_CONTENT_PLUS => 4);
pragma Convention (C, enum_56f8eefb);
subtype xmlElementContentOccur is enum_56f8eefb;
type struct_xmlElementContent;
type struct_xmlElementContent_ptr is access all struct_xmlElementContent;
for struct_xmlElementContent_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlElementContent_ptr);
pragma Convention (C, struct_xmlElementContent_ptr);
subtype xmlElementContent is struct_xmlElementContent;
subtype xmlElementContent_ptr is struct_xmlElementContent_ptr;
subtype xmlElementContentPtr is xmlElementContent_ptr;
type struct_xmlElementContent is record
F_type : aliased xmlElementContentType;
ocur : aliased xmlElementContentOccur;
name : aliased xmlstring.xmlChar_const_ptr;
c1 : aliased struct_xmlElementContent_ptr;
c2 : aliased struct_xmlElementContent_ptr;
parent : aliased struct_xmlElementContent_ptr;
prefix : aliased xmlstring.xmlChar_const_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_xmlElementContent);
type enum_0343e71b is (XML_ELEMENT_TYPE_UNDEFINED, XML_ELEMENT_TYPE_EMPTY,
XML_ELEMENT_TYPE_ANY, XML_ELEMENT_TYPE_MIXED,
XML_ELEMENT_TYPE_ELEMENT);
for enum_0343e71b use (XML_ELEMENT_TYPE_UNDEFINED => 0,
XML_ELEMENT_TYPE_EMPTY => 1, XML_ELEMENT_TYPE_ANY => 2,
XML_ELEMENT_TYPE_MIXED => 3, XML_ELEMENT_TYPE_ELEMENT => 4);
pragma Convention (C, enum_0343e71b);
subtype xmlElementTypeVal is enum_0343e71b;
-- #include <libxml/dict.h>
-- #include <libxml/xmlregexp.h>
type struct_xmlElement;
type struct_xmlElement_ptr is access all struct_xmlElement;
for struct_xmlElement_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlElement_ptr);
pragma Convention (C, struct_xmlElement_ptr);
subtype xmlElement is struct_xmlElement;
subtype xmlElement_ptr is struct_xmlElement_ptr;
subtype xmlElementPtr is xmlElement_ptr;
type struct_xmlElement is record
F_private : aliased void_ptr;
F_type : aliased xmlElementType;
name : aliased xmlstring.xmlChar_const_ptr;
children : aliased struct_xmlNode_ptr;
last : aliased struct_xmlNode_ptr;
parent : aliased struct_xmlDtd_ptr;
next : aliased struct_xmlNode_ptr;
prev : aliased struct_xmlNode_ptr;
doc : aliased struct_xmlDoc_ptr;
etype : aliased xmlElementTypeVal;
content : aliased xmlElementContentPtr;
attributes : aliased xmlAttributePtr;
prefix : aliased xmlstring.xmlChar_const_ptr;
contModel : aliased xmlregexp.xmlRegexpPtr;
end record;
pragma Convention (C_Pass_By_Copy, struct_xmlElement);
subtype xmlNsType is xmlElementType;
type struct_xmlNs;
type struct_xmlNs_ptr is access all struct_xmlNs;
for struct_xmlNs_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlNs_ptr);
pragma Convention (C, struct_xmlNs_ptr);
type struct_xmlNs_ptr_ptr is access all struct_xmlNs_ptr;
for struct_xmlNs_ptr_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlNs_ptr_ptr);
pragma Convention (C, struct_xmlNs_ptr_ptr);
subtype xmlNs is struct_xmlNs;
subtype xmlNs_ptr is struct_xmlNs_ptr;
subtype xmlNs_ptr_ptr is struct_xmlNs_ptr_ptr;
subtype xmlNsPtr is xmlNs_ptr;
subtype xmlNsPtr_ptr is xmlNs_ptr_ptr;
type struct_xmlNs is record
next : aliased struct_xmlNs_ptr;
F_type : aliased xmlNsType;
href : aliased xmlstring.xmlChar_const_ptr;
prefix : aliased xmlstring.xmlChar_const_ptr;
F_private : aliased void_ptr;
context : aliased struct_xmlDoc_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_xmlNs);
subtype xmlDtd is struct_xmlDtd;
subtype xmlDtd_ptr is struct_xmlDtd_ptr;
subtype xmlDtdPtr is xmlDtd_ptr;
type struct_xmlDtd is record
F_private : aliased void_ptr;
F_type : aliased xmlElementType;
name : aliased xmlstring.xmlChar_const_ptr;
children : aliased struct_xmlNode_ptr;
last : aliased struct_xmlNode_ptr;
parent : aliased struct_xmlDoc_ptr;
next : aliased struct_xmlNode_ptr;
prev : aliased struct_xmlNode_ptr;
doc : aliased struct_xmlDoc_ptr;
notations : aliased void_ptr;
elements : aliased void_ptr;
attributes : aliased void_ptr;
entities : aliased void_ptr;
ExternalID : aliased xmlstring.xmlChar_const_ptr;
SystemID : aliased xmlstring.xmlChar_const_ptr;
pentities : aliased void_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_xmlDtd);
type struct_xmlAttr;
type struct_xmlAttr_ptr is access all struct_xmlAttr;
for struct_xmlAttr_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlAttr_ptr);
pragma Convention (C, struct_xmlAttr_ptr);
subtype xmlAttr is struct_xmlAttr;
subtype xmlAttr_ptr is struct_xmlAttr_ptr;
subtype xmlAttrPtr is xmlAttr_ptr;
type struct_xmlAttr is record
F_private : aliased void_ptr;
F_type : aliased xmlElementType;
name : aliased xmlstring.xmlChar_const_ptr;
children : aliased struct_xmlNode_ptr;
last : aliased struct_xmlNode_ptr;
parent : aliased struct_xmlNode_ptr;
next : aliased struct_xmlAttr_ptr;
prev : aliased struct_xmlAttr_ptr;
doc : aliased struct_xmlDoc_ptr;
ns : aliased xmlNs_ptr;
atype : aliased xmlAttributeType;
psvi : aliased void_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_xmlAttr);
type struct_xmlID;
type struct_xmlID_ptr is access all struct_xmlID;
for struct_xmlID_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlID_ptr);
pragma Convention (C, struct_xmlID_ptr);
subtype xmlID is struct_xmlID;
subtype xmlID_ptr is struct_xmlID_ptr;
subtype xmlIDPtr is xmlID_ptr;
type struct_xmlID is record
next : aliased struct_xmlID_ptr;
value : aliased xmlstring.xmlChar_const_ptr;
attr : aliased xmlAttrPtr;
name : aliased xmlstring.xmlChar_const_ptr;
lineno : aliased signed_int;
doc : aliased struct_xmlDoc_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_xmlID);
type struct_xmlRef;
type struct_xmlRef_ptr is access all struct_xmlRef;
for struct_xmlRef_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlRef_ptr);
pragma Convention (C, struct_xmlRef_ptr);
subtype xmlRef is struct_xmlRef;
subtype xmlRef_ptr is struct_xmlRef_ptr;
subtype xmlRefPtr is xmlRef_ptr;
type struct_xmlRef is record
next : aliased struct_xmlRef_ptr;
value : aliased xmlstring.xmlChar_const_ptr;
attr : aliased xmlAttrPtr;
name : aliased xmlstring.xmlChar_const_ptr;
lineno : aliased signed_int;
end record;
pragma Convention (C_Pass_By_Copy, struct_xmlRef);
subtype xmlNode is struct_xmlNode;
subtype xmlNode_ptr is struct_xmlNode_ptr;
subtype xmlNode_ptr_ptr is struct_xmlNode_ptr_ptr;
subtype xmlNode_const_ptr is struct_xmlNode_const_ptr;
subtype xmlNodePtr is xmlNode_ptr;
subtype xmlNodePtr_ptr is xmlNode_ptr_ptr;
type struct_xmlNode is record
F_private : aliased void_ptr;
F_type : aliased xmlElementType;
name : aliased xmlstring.xmlChar_const_ptr;
children : aliased struct_xmlNode_ptr;
last : aliased struct_xmlNode_ptr;
parent : aliased struct_xmlNode_ptr;
next : aliased struct_xmlNode_ptr;
prev : aliased struct_xmlNode_ptr;
doc : aliased struct_xmlDoc_ptr;
ns : aliased xmlNs_ptr;
content : aliased xmlstring.xmlChar_ptr;
properties : aliased struct_xmlAttr_ptr;
nsDef : aliased xmlNs_ptr;
psvi : aliased void_ptr;
line : aliased unsigned_short;
extra : aliased unsigned_short;
end record;
pragma Convention (C_Pass_By_Copy, struct_xmlNode);
type enum_5ecea17a is (XML_DOC_WELLFORMED, XML_DOC_NSVALID, XML_DOC_OLD10,
XML_DOC_DTDVALID, XML_DOC_XINCLUDE, XML_DOC_USERBUILT,
XML_DOC_INTERNAL, XML_DOC_HTML);
for enum_5ecea17a use (XML_DOC_WELLFORMED => 1, XML_DOC_NSVALID => 2,
XML_DOC_OLD10 => 4, XML_DOC_DTDVALID => 8, XML_DOC_XINCLUDE => 16,
XML_DOC_USERBUILT => 32, XML_DOC_INTERNAL => 64, XML_DOC_HTML => 128);
pragma Convention (C, enum_5ecea17a);
subtype xmlDocProperties is enum_5ecea17a;
subtype xmlDoc is struct_xmlDoc;
subtype xmlDoc_ptr is struct_xmlDoc_ptr;
subtype xmlDoc_ptr_ptr is struct_xmlDoc_ptr_ptr;
subtype xmlDoc_const_ptr is struct_xmlDoc_const_ptr;
subtype xmlDocPtr is xmlDoc_ptr;
subtype xmlDocPtr_ptr is xmlDoc_ptr_ptr;
type struct_xmlDoc is record
F_private : aliased void_ptr;
F_type : aliased xmlElementType;
name : aliased char_ptr;
children : aliased struct_xmlNode_ptr;
last : aliased struct_xmlNode_ptr;
parent : aliased struct_xmlNode_ptr;
next : aliased struct_xmlNode_ptr;
prev : aliased struct_xmlNode_ptr;
doc : aliased struct_xmlDoc_ptr;
compression : aliased signed_int;
standalone : aliased signed_int;
intSubset : aliased struct_xmlDtd_ptr;
extSubset : aliased struct_xmlDtd_ptr;
oldNs : aliased struct_xmlNs_ptr;
version : aliased xmlstring.xmlChar_const_ptr;
encoding : aliased xmlstring.xmlChar_const_ptr;
ids : aliased void_ptr;
refs : aliased void_ptr;
URL : aliased xmlstring.xmlChar_const_ptr;
charset : aliased signed_int;
dict : aliased libxml.dict.struct_xmlDict_ptr;
psvi : aliased void_ptr;
parseFlags : aliased signed_int;
properties : aliased signed_int;
end record;
pragma Convention (C_Pass_By_Copy, struct_xmlDoc);
type struct_xmlDOMWrapCtxt;
type struct_xmlDOMWrapCtxt_ptr is access all struct_xmlDOMWrapCtxt;
for struct_xmlDOMWrapCtxt_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlDOMWrapCtxt_ptr);
pragma Convention (C, struct_xmlDOMWrapCtxt_ptr);
subtype xmlDOMWrapCtxt is struct_xmlDOMWrapCtxt;
subtype xmlDOMWrapCtxt_ptr is struct_xmlDOMWrapCtxt_ptr;
subtype xmlDOMWrapCtxtPtr is xmlDOMWrapCtxt_ptr;
type access_143f5c3e is access function (ctxt : access xmlDOMWrapCtxt;
node : access xmlNode; nsName : access constant xmlstring.xmlChar;
nsPrefix : access constant xmlstring.xmlChar) return xmlNsPtr;
pragma Convention (C, access_143f5c3e);
subtype xmlDOMWrapAcquireNsFunction is access_143f5c3e;
type struct_xmlDOMWrapCtxt is record
F_private : aliased void_ptr;
F_type : aliased signed_int;
namespaceMap : aliased void_ptr;
getNsForNodeFunc : aliased xmlDOMWrapAcquireNsFunction;
end record;
pragma Convention (C_Pass_By_Copy, struct_xmlDOMWrapCtxt);
function xmlValidateNCName (value : access constant xmlstring.xmlChar;
space : signed_int) return signed_int;
pragma Import (C, xmlValidateNCName, "xmlValidateNCName");
function xmlValidateQName (value : access constant xmlstring.xmlChar;
space : signed_int) return signed_int;
pragma Import (C, xmlValidateQName, "xmlValidateQName");
function xmlValidateName (value : access constant xmlstring.xmlChar;
space : signed_int) return signed_int;
pragma Import (C, xmlValidateName, "xmlValidateName");
function xmlValidateNMToken (value : access constant xmlstring.xmlChar;
space : signed_int) return signed_int;
pragma Import (C, xmlValidateNMToken, "xmlValidateNMToken");
function xmlBuildQName (ncname : access constant xmlstring.xmlChar;
prefix : access constant xmlstring.xmlChar;
memory : access xmlstring.xmlChar; len : signed_int)
return xmlstring.xmlChar_ptr;
pragma Import (C, xmlBuildQName, "xmlBuildQName");
function xmlSplitQName2 (name : access constant xmlstring.xmlChar;
prefix : access xmlstring.xmlChar_ptr) return xmlstring.xmlChar_ptr;
pragma Import (C, xmlSplitQName2, "xmlSplitQName2");
function xmlSplitQName3 (name : access constant xmlstring.xmlChar;
len : access signed_int) return xmlstring.xmlChar_const_ptr;
pragma Import (C, xmlSplitQName3, "xmlSplitQName3");
procedure xmlSetBufferAllocationScheme (
scheme : xmlBufferAllocationScheme);
pragma Import (C, xmlSetBufferAllocationScheme,
"xmlSetBufferAllocationScheme");
function xmlGetBufferAllocationScheme return xmlBufferAllocationScheme;
pragma Import (C, xmlGetBufferAllocationScheme,
"xmlGetBufferAllocationScheme");
function xmlBufferCreate return xmlBufferPtr;
pragma Import (C, xmlBufferCreate, "xmlBufferCreate");
function xmlBufferCreateSize (size : stddef.size_t) return xmlBufferPtr;
pragma Import (C, xmlBufferCreateSize, "xmlBufferCreateSize");
function xmlBufferCreateStatic (mem : void_ptr; size : stddef.size_t)
return xmlBufferPtr;
pragma Import (C, xmlBufferCreateStatic, "xmlBufferCreateStatic");
function xmlBufferResize (buf : access xmlBuffer; size : unsigned_int)
return signed_int;
pragma Import (C, xmlBufferResize, "xmlBufferResize");
procedure xmlBufferFree (buf : access xmlBuffer);
pragma Import (C, xmlBufferFree, "xmlBufferFree");
function xmlBufferDump (file : access stdio.FILE; buf : access xmlBuffer)
return signed_int;
pragma Import (C, xmlBufferDump, "xmlBufferDump");
function xmlBufferAdd (buf : access xmlBuffer;
str : access constant xmlstring.xmlChar; len : signed_int)
return signed_int;
pragma Import (C, xmlBufferAdd, "xmlBufferAdd");
function xmlBufferAddHead (buf : access xmlBuffer;
str : access constant xmlstring.xmlChar; len : signed_int)
return signed_int;
pragma Import (C, xmlBufferAddHead, "xmlBufferAddHead");
function xmlBufferCat (buf : access xmlBuffer;
str : access constant xmlstring.xmlChar) return signed_int;
pragma Import (C, xmlBufferCat, "xmlBufferCat");
function xmlBufferCCat (buf : access xmlBuffer;
str : access constant char) return signed_int;
pragma Import (C, xmlBufferCCat, "xmlBufferCCat");
function xmlBufferShrink (buf : access xmlBuffer; len : unsigned_int)
return signed_int;
pragma Import (C, xmlBufferShrink, "xmlBufferShrink");
function xmlBufferGrow (buf : access xmlBuffer; len : unsigned_int)
return signed_int;
pragma Import (C, xmlBufferGrow, "xmlBufferGrow");
procedure xmlBufferEmpty (buf : access xmlBuffer);
pragma Import (C, xmlBufferEmpty, "xmlBufferEmpty");
function xmlBufferContent (buf : access constant xmlBuffer)
return xmlstring.xmlChar_const_ptr;
pragma Import (C, xmlBufferContent, "xmlBufferContent");
function xmlBufferDetach (buf : access xmlBuffer)
return xmlstring.xmlChar_ptr;
pragma Import (C, xmlBufferDetach, "xmlBufferDetach");
procedure xmlBufferSetAllocationScheme (buf : access xmlBuffer;
scheme : xmlBufferAllocationScheme);
pragma Import (C, xmlBufferSetAllocationScheme,
"xmlBufferSetAllocationScheme");
function xmlBufferLength (buf : access constant xmlBuffer)
return signed_int;
pragma Import (C, xmlBufferLength, "xmlBufferLength");
function xmlCreateIntSubset (doc : access xmlDoc;
name : access constant xmlstring.xmlChar;
ExternalID : access constant xmlstring.xmlChar;
SystemID : access constant xmlstring.xmlChar) return xmlDtdPtr;
pragma Import (C, xmlCreateIntSubset, "xmlCreateIntSubset");
function xmlNewDtd (doc : access xmlDoc;
name : access constant xmlstring.xmlChar;
ExternalID : access constant xmlstring.xmlChar;
SystemID : access constant xmlstring.xmlChar) return xmlDtdPtr;
pragma Import (C, xmlNewDtd, "xmlNewDtd");
function xmlGetIntSubset (doc : access constant xmlDoc) return xmlDtdPtr;
pragma Import (C, xmlGetIntSubset, "xmlGetIntSubset");
procedure xmlFreeDtd (cur : access xmlDtd);
pragma Import (C, xmlFreeDtd, "xmlFreeDtd");
function xmlNewGlobalNs (doc : access xmlDoc;
href : access constant xmlstring.xmlChar;
prefix : access constant xmlstring.xmlChar) return xmlNsPtr;
pragma Import (C, xmlNewGlobalNs, "xmlNewGlobalNs");
function xmlNewNs (node : access xmlNode;
href : access constant xmlstring.xmlChar;
prefix : access constant xmlstring.xmlChar) return xmlNsPtr;
pragma Import (C, xmlNewNs, "xmlNewNs");
procedure xmlFreeNs (cur : access xmlNs);
pragma Import (C, xmlFreeNs, "xmlFreeNs");
procedure xmlFreeNsList (cur : access xmlNs);
pragma Import (C, xmlFreeNsList, "xmlFreeNsList");
function xmlNewDoc (version : access constant xmlstring.xmlChar)
return xmlDocPtr;
pragma Import (C, xmlNewDoc, "xmlNewDoc");
procedure xmlFreeDoc (cur : access xmlDoc);
pragma Import (C, xmlFreeDoc, "xmlFreeDoc");
function xmlNewDocProp (doc : access xmlDoc;
name : access constant xmlstring.xmlChar;
value : access constant xmlstring.xmlChar) return xmlAttrPtr;
pragma Import (C, xmlNewDocProp, "xmlNewDocProp");
function xmlNewProp (node : access xmlNode;
name : access constant xmlstring.xmlChar;
value : access constant xmlstring.xmlChar) return xmlAttrPtr;
pragma Import (C, xmlNewProp, "xmlNewProp");
function xmlNewNsProp (node : access xmlNode; ns : access xmlNs;
name : access constant xmlstring.xmlChar;
value : access constant xmlstring.xmlChar) return xmlAttrPtr;
pragma Import (C, xmlNewNsProp, "xmlNewNsProp");
function xmlNewNsPropEatName (node : access xmlNode; ns : access xmlNs;
name : access xmlstring.xmlChar;
value : access constant xmlstring.xmlChar) return xmlAttrPtr;
pragma Import (C, xmlNewNsPropEatName, "xmlNewNsPropEatName");
procedure xmlFreePropList (cur : access xmlAttr);
pragma Import (C, xmlFreePropList, "xmlFreePropList");
procedure xmlFreeProp (cur : access xmlAttr);
pragma Import (C, xmlFreeProp, "xmlFreeProp");
function xmlCopyProp (target : access xmlNode; cur : access xmlAttr)
return xmlAttrPtr;
pragma Import (C, xmlCopyProp, "xmlCopyProp");
function xmlCopyPropList (target : access xmlNode; cur : access xmlAttr)
return xmlAttrPtr;
pragma Import (C, xmlCopyPropList, "xmlCopyPropList");
function xmlCopyDtd (dtd : access xmlDtd) return xmlDtdPtr;
pragma Import (C, xmlCopyDtd, "xmlCopyDtd");
function xmlCopyDoc (doc : access xmlDoc; recursive : signed_int)
return xmlDocPtr;
pragma Import (C, xmlCopyDoc, "xmlCopyDoc");
function xmlNewDocNode (doc : access xmlDoc; ns : access xmlNs;
name : access constant xmlstring.xmlChar;
content : access constant xmlstring.xmlChar) return xmlNodePtr;
pragma Import (C, xmlNewDocNode, "xmlNewDocNode");
function xmlNewDocNodeEatName (doc : access xmlDoc; ns : access xmlNs;
name : access xmlstring.xmlChar;
content : access constant xmlstring.xmlChar) return xmlNodePtr;
pragma Import (C, xmlNewDocNodeEatName, "xmlNewDocNodeEatName");
function xmlNewNode (ns : access xmlNs;
name : access constant xmlstring.xmlChar) return xmlNodePtr;
pragma Import (C, xmlNewNode, "xmlNewNode");
function xmlNewNodeEatName (ns : access xmlNs;
name : access xmlstring.xmlChar) return xmlNodePtr;
pragma Import (C, xmlNewNodeEatName, "xmlNewNodeEatName");
function xmlNewChild (parent : access xmlNode; ns : access xmlNs;
name : access constant xmlstring.xmlChar;
content : access constant xmlstring.xmlChar) return xmlNodePtr;
pragma Import (C, xmlNewChild, "xmlNewChild");
function xmlNewDocText (doc : access constant xmlDoc;
content : access constant xmlstring.xmlChar) return xmlNodePtr;
pragma Import (C, xmlNewDocText, "xmlNewDocText");
function xmlNewText (content : access constant xmlstring.xmlChar)
return xmlNodePtr;
pragma Import (C, xmlNewText, "xmlNewText");
function xmlNewDocPI (doc : access xmlDoc;
name : access constant xmlstring.xmlChar;
content : access constant xmlstring.xmlChar) return xmlNodePtr;
pragma Import (C, xmlNewDocPI, "xmlNewDocPI");
function xmlNewPI (name : access constant xmlstring.xmlChar;
content : access constant xmlstring.xmlChar) return xmlNodePtr;
pragma Import (C, xmlNewPI, "xmlNewPI");
function xmlNewDocTextLen (doc : access xmlDoc;
content : access constant xmlstring.xmlChar; len : signed_int)
return xmlNodePtr;
pragma Import (C, xmlNewDocTextLen, "xmlNewDocTextLen");
function xmlNewTextLen (content : access constant xmlstring.xmlChar;
len : signed_int) return xmlNodePtr;
pragma Import (C, xmlNewTextLen, "xmlNewTextLen");
function xmlNewDocComment (doc : access xmlDoc;
content : access constant xmlstring.xmlChar) return xmlNodePtr;
pragma Import (C, xmlNewDocComment, "xmlNewDocComment");
function xmlNewComment (content : access constant xmlstring.xmlChar)
return xmlNodePtr;
pragma Import (C, xmlNewComment, "xmlNewComment");
function xmlNewCDataBlock (doc : access xmlDoc;
content : access constant xmlstring.xmlChar; len : signed_int)
return xmlNodePtr;
pragma Import (C, xmlNewCDataBlock, "xmlNewCDataBlock");
function xmlNewCharRef (doc : access xmlDoc;
name : access constant xmlstring.xmlChar) return xmlNodePtr;
pragma Import (C, xmlNewCharRef, "xmlNewCharRef");
function xmlNewReference (doc : access constant xmlDoc;
name : access constant xmlstring.xmlChar) return xmlNodePtr;
pragma Import (C, xmlNewReference, "xmlNewReference");
function xmlCopyNode (node : access xmlNode; recursive : signed_int)
return xmlNodePtr;
pragma Import (C, xmlCopyNode, "xmlCopyNode");
function xmlDocCopyNode (node : access xmlNode; doc : access xmlDoc;
recursive : signed_int) return xmlNodePtr;
pragma Import (C, xmlDocCopyNode, "xmlDocCopyNode");
function xmlDocCopyNodeList (doc : access xmlDoc; node : access xmlNode)
return xmlNodePtr;
pragma Import (C, xmlDocCopyNodeList, "xmlDocCopyNodeList");
function xmlCopyNodeList (node : access xmlNode) return xmlNodePtr;
pragma Import (C, xmlCopyNodeList, "xmlCopyNodeList");
function xmlNewTextChild (parent : access xmlNode; ns : access xmlNs;
name : access constant xmlstring.xmlChar;
content : access constant xmlstring.xmlChar) return xmlNodePtr;
pragma Import (C, xmlNewTextChild, "xmlNewTextChild");
function xmlNewDocRawNode (doc : access xmlDoc; ns : access xmlNs;
name : access constant xmlstring.xmlChar;
content : access constant xmlstring.xmlChar) return xmlNodePtr;
pragma Import (C, xmlNewDocRawNode, "xmlNewDocRawNode");
function xmlNewDocFragment (doc : access xmlDoc) return xmlNodePtr;
pragma Import (C, xmlNewDocFragment, "xmlNewDocFragment");
function xmlGetLineNo (node : access constant xmlNode) return signed_long;
pragma Import (C, xmlGetLineNo, "xmlGetLineNo");
function xmlGetNodePath (node : access constant xmlNode)
return xmlstring.xmlChar_ptr;
pragma Import (C, xmlGetNodePath, "xmlGetNodePath");
function xmlDocGetRootElement (doc : access constant xmlDoc)
return xmlNodePtr;
pragma Import (C, xmlDocGetRootElement, "xmlDocGetRootElement");
function xmlGetLastChild (parent : access constant xmlNode)
return xmlNodePtr;
pragma Import (C, xmlGetLastChild, "xmlGetLastChild");
function xmlNodeIsText (node : access constant xmlNode) return signed_int;
pragma Import (C, xmlNodeIsText, "xmlNodeIsText");
function xmlIsBlankNode (node : access constant xmlNode)
return signed_int;
pragma Import (C, xmlIsBlankNode, "xmlIsBlankNode");
function xmlDocSetRootElement (doc : access xmlDoc; root : access xmlNode)
return xmlNodePtr;
pragma Import (C, xmlDocSetRootElement, "xmlDocSetRootElement");
procedure xmlNodeSetName (cur : access xmlNode;
name : access constant xmlstring.xmlChar);
pragma Import (C, xmlNodeSetName, "xmlNodeSetName");
function xmlAddChild (parent : access xmlNode; cur : access xmlNode)
return xmlNodePtr;
pragma Import (C, xmlAddChild, "xmlAddChild");
function xmlAddChildList (parent : access xmlNode; cur : access xmlNode)
return xmlNodePtr;
pragma Import (C, xmlAddChildList, "xmlAddChildList");
function xmlReplaceNode (old : access xmlNode; cur : access xmlNode)
return xmlNodePtr;
pragma Import (C, xmlReplaceNode, "xmlReplaceNode");
function xmlAddPrevSibling (cur : access xmlNode; elem : access xmlNode)
return xmlNodePtr;
pragma Import (C, xmlAddPrevSibling, "xmlAddPrevSibling");
function xmlAddSibling (cur : access xmlNode; elem : access xmlNode)
return xmlNodePtr;
pragma Import (C, xmlAddSibling, "xmlAddSibling");
function xmlAddNextSibling (cur : access xmlNode; elem : access xmlNode)
return xmlNodePtr;
pragma Import (C, xmlAddNextSibling, "xmlAddNextSibling");
procedure xmlUnlinkNode (cur : access xmlNode);
pragma Import (C, xmlUnlinkNode, "xmlUnlinkNode");
function xmlTextMerge (first : access xmlNode; second : access xmlNode)
return xmlNodePtr;
pragma Import (C, xmlTextMerge, "xmlTextMerge");
function xmlTextConcat (node : access xmlNode;
content : access constant xmlstring.xmlChar; len : signed_int)
return signed_int;
pragma Import (C, xmlTextConcat, "xmlTextConcat");
procedure xmlFreeNodeList (cur : access xmlNode);
pragma Import (C, xmlFreeNodeList, "xmlFreeNodeList");
procedure xmlFreeNode (cur : access xmlNode);
pragma Import (C, xmlFreeNode, "xmlFreeNode");
procedure xmlSetTreeDoc (tree : access xmlNode; doc : access xmlDoc);
pragma Import (C, xmlSetTreeDoc, "xmlSetTreeDoc");
procedure xmlSetListDoc (list : access xmlNode; doc : access xmlDoc);
pragma Import (C, xmlSetListDoc, "xmlSetListDoc");
function xmlSearchNs (doc : access xmlDoc; node : access xmlNode;
nameSpace : access constant xmlstring.xmlChar) return xmlNsPtr;
pragma Import (C, xmlSearchNs, "xmlSearchNs");
function xmlSearchNsByHref (doc : access xmlDoc; node : access xmlNode;
href : access constant xmlstring.xmlChar) return xmlNsPtr;
pragma Import (C, xmlSearchNsByHref, "xmlSearchNsByHref");
function xmlGetNsList (doc : access constant xmlDoc;
node : access constant xmlNode) return xmlNsPtr_ptr;
pragma Import (C, xmlGetNsList, "xmlGetNsList");
procedure xmlSetNs (node : access xmlNode; ns : access xmlNs);
pragma Import (C, xmlSetNs, "xmlSetNs");
function xmlCopyNamespace (cur : access xmlNs) return xmlNsPtr;
pragma Import (C, xmlCopyNamespace, "xmlCopyNamespace");
function xmlCopyNamespaceList (cur : access xmlNs) return xmlNsPtr;
pragma Import (C, xmlCopyNamespaceList, "xmlCopyNamespaceList");
function xmlSetProp (node : access xmlNode;
name : access constant xmlstring.xmlChar;
value : access constant xmlstring.xmlChar) return xmlAttrPtr;
pragma Import (C, xmlSetProp, "xmlSetProp");
function xmlSetNsProp (node : access xmlNode; ns : access xmlNs;
name : access constant xmlstring.xmlChar;
value : access constant xmlstring.xmlChar) return xmlAttrPtr;
pragma Import (C, xmlSetNsProp, "xmlSetNsProp");
function xmlGetNoNsProp (node : access constant xmlNode;
name : access constant xmlstring.xmlChar) return xmlstring.xmlChar_ptr;
pragma Import (C, xmlGetNoNsProp, "xmlGetNoNsProp");
function xmlGetProp (node : access constant xmlNode;
name : access constant xmlstring.xmlChar) return xmlstring.xmlChar_ptr;
pragma Import (C, xmlGetProp, "xmlGetProp");
function xmlHasProp (node : access constant xmlNode;
name : access constant xmlstring.xmlChar) return xmlAttrPtr;
pragma Import (C, xmlHasProp, "xmlHasProp");
function xmlHasNsProp (node : access constant xmlNode;
name : access constant xmlstring.xmlChar;
nameSpace : access constant xmlstring.xmlChar) return xmlAttrPtr;
pragma Import (C, xmlHasNsProp, "xmlHasNsProp");
function xmlGetNsProp (node : access constant xmlNode;
name : access constant xmlstring.xmlChar;
nameSpace : access constant xmlstring.xmlChar)
return xmlstring.xmlChar_ptr;
pragma Import (C, xmlGetNsProp, "xmlGetNsProp");
function xmlStringGetNodeList (doc : access constant xmlDoc;
value : access constant xmlstring.xmlChar) return xmlNodePtr;
pragma Import (C, xmlStringGetNodeList, "xmlStringGetNodeList");
function xmlStringLenGetNodeList (doc : access constant xmlDoc;
value : access constant xmlstring.xmlChar; len : signed_int)
return xmlNodePtr;
pragma Import (C, xmlStringLenGetNodeList, "xmlStringLenGetNodeList");
function xmlNodeListGetString (doc : access xmlDoc;
list : access constant xmlNode; inLine : signed_int)
return xmlstring.xmlChar_ptr;
pragma Import (C, xmlNodeListGetString, "xmlNodeListGetString");
function xmlNodeListGetRawString (doc : access constant xmlDoc;
list : access constant xmlNode; inLine : signed_int)
return xmlstring.xmlChar_ptr;
pragma Import (C, xmlNodeListGetRawString, "xmlNodeListGetRawString");
procedure xmlNodeSetContent (cur : access xmlNode;
content : access constant xmlstring.xmlChar);
pragma Import (C, xmlNodeSetContent, "xmlNodeSetContent");
procedure xmlNodeSetContentLen (cur : access xmlNode;
content : access constant xmlstring.xmlChar; len : signed_int);
pragma Import (C, xmlNodeSetContentLen, "xmlNodeSetContentLen");
procedure xmlNodeAddContent (cur : access xmlNode;
content : access constant xmlstring.xmlChar);
pragma Import (C, xmlNodeAddContent, "xmlNodeAddContent");
procedure xmlNodeAddContentLen (cur : access xmlNode;
content : access constant xmlstring.xmlChar; len : signed_int);
pragma Import (C, xmlNodeAddContentLen, "xmlNodeAddContentLen");
function xmlNodeGetContent (cur : access constant xmlNode)
return xmlstring.xmlChar_ptr;
pragma Import (C, xmlNodeGetContent, "xmlNodeGetContent");
function xmlNodeBufGetContent (buffer : access xmlBuffer;
cur : access constant xmlNode) return signed_int;
pragma Import (C, xmlNodeBufGetContent, "xmlNodeBufGetContent");
function xmlBufGetNodeContent (buf : access xmlBuf;
cur : access constant xmlNode) return signed_int;
pragma Import (C, xmlBufGetNodeContent, "xmlBufGetNodeContent");
function xmlNodeGetLang (cur : access constant xmlNode)
return xmlstring.xmlChar_ptr;
pragma Import (C, xmlNodeGetLang, "xmlNodeGetLang");
function xmlNodeGetSpacePreserve (cur : access constant xmlNode)
return signed_int;
pragma Import (C, xmlNodeGetSpacePreserve, "xmlNodeGetSpacePreserve");
procedure xmlNodeSetLang (cur : access xmlNode;
lang : access constant xmlstring.xmlChar);
pragma Import (C, xmlNodeSetLang, "xmlNodeSetLang");
procedure xmlNodeSetSpacePreserve (cur : access xmlNode;
val : signed_int);
pragma Import (C, xmlNodeSetSpacePreserve, "xmlNodeSetSpacePreserve");
function xmlNodeGetBase (doc : access constant xmlDoc;
cur : access constant xmlNode) return xmlstring.xmlChar_ptr;
pragma Import (C, xmlNodeGetBase, "xmlNodeGetBase");
procedure xmlNodeSetBase (cur : access xmlNode;
uri : access constant xmlstring.xmlChar);
pragma Import (C, xmlNodeSetBase, "xmlNodeSetBase");
function xmlRemoveProp (cur : access xmlAttr) return signed_int;
pragma Import (C, xmlRemoveProp, "xmlRemoveProp");
function xmlUnsetNsProp (node : access xmlNode; ns : access xmlNs;
name : access constant xmlstring.xmlChar) return signed_int;
pragma Import (C, xmlUnsetNsProp, "xmlUnsetNsProp");
function xmlUnsetProp (node : access xmlNode;
name : access constant xmlstring.xmlChar) return signed_int;
pragma Import (C, xmlUnsetProp, "xmlUnsetProp");
procedure xmlBufferWriteCHAR_uppercase (buf : access xmlBuffer;
string : access constant xmlstring.xmlChar);
pragma Import (C, xmlBufferWriteCHAR_uppercase, "xmlBufferWriteCHAR");
procedure xmlBufferWriteChar (buf : access xmlBuffer;
string : access constant char);
pragma Import (C, xmlBufferWriteChar, "xmlBufferWriteChar");
procedure xmlBufferWriteQuotedString (buf : access xmlBuffer;
string : access constant xmlstring.xmlChar);
pragma Import (C, xmlBufferWriteQuotedString,
"xmlBufferWriteQuotedString");
procedure xmlAttrSerializeTxtContent (buf : access xmlBuffer;
doc : access xmlDoc; attr : access xmlAttr;
string : access constant xmlstring.xmlChar);
pragma Import (C, xmlAttrSerializeTxtContent,
"xmlAttrSerializeTxtContent");
function xmlReconciliateNs (doc : access xmlDoc; tree : access xmlNode)
return signed_int;
pragma Import (C, xmlReconciliateNs, "xmlReconciliateNs");
procedure xmlDocDumpFormatMemory (cur : access xmlDoc;
mem : access xmlstring.xmlChar_ptr; size : access signed_int;
format : signed_int);
pragma Import (C, xmlDocDumpFormatMemory, "xmlDocDumpFormatMemory");
procedure xmlDocDumpMemory (cur : access xmlDoc;
mem : access xmlstring.xmlChar_ptr; size : access signed_int);
pragma Import (C, xmlDocDumpMemory, "xmlDocDumpMemory");
procedure xmlDocDumpMemoryEnc (out_doc : access xmlDoc;
doc_txt_ptr : access xmlstring.xmlChar_ptr;
doc_txt_len : access signed_int; txt_encoding : access constant char);
pragma Import (C, xmlDocDumpMemoryEnc, "xmlDocDumpMemoryEnc");
procedure xmlDocDumpFormatMemoryEnc (out_doc : access xmlDoc;
doc_txt_ptr : access xmlstring.xmlChar_ptr;
doc_txt_len : access signed_int; txt_encoding : access constant char;
format : signed_int);
pragma Import (C, xmlDocDumpFormatMemoryEnc, "xmlDocDumpFormatMemoryEnc");
function xmlDocFormatDump (f : access stdio.FILE; cur : access xmlDoc;
format : signed_int) return signed_int;
pragma Import (C, xmlDocFormatDump, "xmlDocFormatDump");
function xmlDocDump (f : access stdio.FILE; cur : access xmlDoc)
return signed_int;
pragma Import (C, xmlDocDump, "xmlDocDump");
procedure xmlElemDump (f : access stdio.FILE; doc : access xmlDoc;
cur : access xmlNode);
pragma Import (C, xmlElemDump, "xmlElemDump");
function xmlSaveFile (filename : access constant char;
cur : access xmlDoc) return signed_int;
pragma Import (C, xmlSaveFile, "xmlSaveFile");
function xmlSaveFormatFile (filename : access constant char;
cur : access xmlDoc; format : signed_int) return signed_int;
pragma Import (C, xmlSaveFormatFile, "xmlSaveFormatFile");
function xmlBufNodeDump (buf : access xmlBuf; doc : access xmlDoc;
cur : access xmlNode; level : signed_int; format : signed_int)
return stddef.size_t;
pragma Import (C, xmlBufNodeDump, "xmlBufNodeDump");
function xmlNodeDump (buf : access xmlBuffer; doc : access xmlDoc;
cur : access xmlNode; level : signed_int; format : signed_int)
return signed_int;
pragma Import (C, xmlNodeDump, "xmlNodeDump");
function xmlSaveFileTo (buf : access xmlIO.struct_xmlOutputBuffer;
cur : access xmlDoc; encoding : access constant char)
return signed_int;
pragma Import (C, xmlSaveFileTo, "xmlSaveFileTo");
function xmlSaveFormatFileTo (buf : access xmlIO.struct_xmlOutputBuffer;
cur : access xmlDoc; encoding : access constant char;
format : signed_int) return signed_int;
pragma Import (C, xmlSaveFormatFileTo, "xmlSaveFormatFileTo");
procedure xmlNodeDumpOutput (buf : access xmlIO.struct_xmlOutputBuffer;
doc : access xmlDoc; cur : access xmlNode; level : signed_int;
format : signed_int; encoding : access constant char);
pragma Import (C, xmlNodeDumpOutput, "xmlNodeDumpOutput");
function xmlSaveFormatFileEnc (filename : access constant char;
cur : access xmlDoc; encoding : access constant char;
format : signed_int) return signed_int;
pragma Import (C, xmlSaveFormatFileEnc, "xmlSaveFormatFileEnc");
function xmlSaveFileEnc (filename : access constant char;
cur : access xmlDoc; encoding : access constant char)
return signed_int;
pragma Import (C, xmlSaveFileEnc, "xmlSaveFileEnc");
function xmlIsXHTML (systemID : access constant xmlstring.xmlChar;
publicID : access constant xmlstring.xmlChar) return signed_int;
pragma Import (C, xmlIsXHTML, "xmlIsXHTML");
function xmlGetDocCompressMode (doc : access constant xmlDoc)
return signed_int;
pragma Import (C, xmlGetDocCompressMode, "xmlGetDocCompressMode");
procedure xmlSetDocCompressMode (doc : access xmlDoc; mode : signed_int);
pragma Import (C, xmlSetDocCompressMode, "xmlSetDocCompressMode");
function xmlGetCompressMode return signed_int;
pragma Import (C, xmlGetCompressMode, "xmlGetCompressMode");
procedure xmlSetCompressMode (mode : signed_int);
pragma Import (C, xmlSetCompressMode, "xmlSetCompressMode");
function xmlDOMWrapNewCtxt return xmlDOMWrapCtxtPtr;
pragma Import (C, xmlDOMWrapNewCtxt, "xmlDOMWrapNewCtxt");
procedure xmlDOMWrapFreeCtxt (ctxt : access xmlDOMWrapCtxt);
pragma Import (C, xmlDOMWrapFreeCtxt, "xmlDOMWrapFreeCtxt");
function xmlDOMWrapReconcileNamespaces (ctxt : access xmlDOMWrapCtxt;
elem : access xmlNode; options : signed_int) return signed_int;
pragma Import (C, xmlDOMWrapReconcileNamespaces,
"xmlDOMWrapReconcileNamespaces");
function xmlDOMWrapAdoptNode (ctxt : access xmlDOMWrapCtxt;
sourceDoc : access xmlDoc; node : access xmlNode;
destDoc : access xmlDoc; destParent : access xmlNode;
options : signed_int) return signed_int;
pragma Import (C, xmlDOMWrapAdoptNode, "xmlDOMWrapAdoptNode");
function xmlDOMWrapRemoveNode (ctxt : access xmlDOMWrapCtxt;
doc : access xmlDoc; node : access xmlNode; options : signed_int)
return signed_int;
pragma Import (C, xmlDOMWrapRemoveNode, "xmlDOMWrapRemoveNode");
function xmlDOMWrapCloneNode (ctxt : access xmlDOMWrapCtxt;
sourceDoc : access xmlDoc; node : access xmlNode;
clonedNode : access xmlNodePtr; destDoc : access xmlDoc;
destParent : access xmlNode; deep : signed_int; options : signed_int)
return signed_int;
pragma Import (C, xmlDOMWrapCloneNode, "xmlDOMWrapCloneNode");
function xmlChildElementCount (parent : access xmlNode)
return unsigned_long;
pragma Import (C, xmlChildElementCount, "xmlChildElementCount");
function xmlNextElementSibling (node : access xmlNode) return xmlNodePtr;
pragma Import (C, xmlNextElementSibling, "xmlNextElementSibling");
function xmlFirstElementChild (parent : access xmlNode) return xmlNodePtr;
pragma Import (C, xmlFirstElementChild, "xmlFirstElementChild");
function xmlLastElementChild (parent : access xmlNode) return xmlNodePtr;
pragma Import (C, xmlLastElementChild, "xmlLastElementChild");
function xmlPreviousElementSibling (node : access xmlNode)
return xmlNodePtr;
pragma Import (C, xmlPreviousElementSibling, "xmlPreviousElementSibling");
BASE_BUFFER_SIZE : constant := 4096;
-- LIBXML2_NEW_BUFFER (empty)
-- XML_GET_CONTENT (uninterpretable)
-- XML_GET_LINE (function macro)
XML_LOCAL_NAMESPACE : constant enum_1b5c1861 := XML_NAMESPACE_DECL;
function XML_XML_ID (Value : char_array := "xml:id" & char'Val (0))
return xmlstring.xmlChar_const_ptr renames Cast;
function XML_XML_NAMESPACE (
Value : char_array := "http://www.w3.org/XML/1998/namespace"
& char'Val (0)) return xmlstring.xmlChar_const_ptr renames Cast;
-- __XML_TREE_H__ (empty)
-- .xmlChildrenNode renames .children (accessor)
-- .xmlRootNode renames .children (accessor)
private
type struct_xmlBuf is null record;
end C.libxml.tree;
Raw
c-libxml-valid.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.libxml.hash;
with C.libxml.list;
with C.libxml.tree;
with C.libxml.xmlautomata;
with C.libxml.xmlstring;
package C.libxml.valid is
pragma Preelaborate;
type struct_xmlValidState (<>) is limited private;
type struct_xmlValidState_ptr is access all struct_xmlValidState;
for struct_xmlValidState_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlValidState_ptr);
pragma Convention (C, struct_xmlValidState_ptr);
subtype xmlValidState is struct_xmlValidState;
subtype xmlValidState_ptr is struct_xmlValidState_ptr;
subtype xmlValidStatePtr is xmlValidState_ptr;
type access_2461f063 is access procedure (ctx : void_ptr;
msg : access constant char);
pragma Convention (C, access_2461f063);
subtype xmlValidityErrorFunc is access_2461f063;
type access_55d90ff8 is access procedure (ctx : void_ptr;
msg : access constant char);
pragma Convention (C, access_55d90ff8);
subtype xmlValidityWarningFunc is access_55d90ff8;
type struct_xmlValidCtxt;
type struct_xmlValidCtxt_ptr is access all struct_xmlValidCtxt;
for struct_xmlValidCtxt_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlValidCtxt_ptr);
pragma Convention (C, struct_xmlValidCtxt_ptr);
subtype xmlValidCtxt is struct_xmlValidCtxt;
subtype xmlValidCtxt_ptr is struct_xmlValidCtxt_ptr;
subtype xmlValidCtxtPtr is xmlValidCtxt_ptr;
type struct_xmlValidCtxt is record
userData : aliased void_ptr;
error : aliased xmlValidityErrorFunc;
warning : aliased xmlValidityWarningFunc;
node : aliased tree.xmlNodePtr;
nodeNr : aliased signed_int;
nodeMax : aliased signed_int;
nodeTab : aliased tree.xmlNodePtr_ptr;
finishDtd : aliased unsigned_int;
doc : aliased tree.xmlDocPtr;
valid : aliased signed_int;
vstate : aliased xmlValidState_ptr;
vstateNr : aliased signed_int;
vstateMax : aliased signed_int;
vstateTab : aliased xmlValidState_ptr;
am : aliased xmlautomata.xmlAutomataPtr;
state : aliased xmlautomata.xmlAutomataStatePtr;
end record;
pragma Convention (C_Pass_By_Copy, struct_xmlValidCtxt);
subtype xmlNotationTable is hash.struct_xmlHashTable;
subtype xmlNotationTable_ptr is hash.struct_xmlHashTable_ptr;
subtype xmlNotationTablePtr is xmlNotationTable_ptr;
subtype xmlElementTable is hash.struct_xmlHashTable;
subtype xmlElementTable_ptr is hash.struct_xmlHashTable_ptr;
subtype xmlElementTablePtr is xmlElementTable_ptr;
subtype xmlAttributeTable is hash.struct_xmlHashTable;
subtype xmlAttributeTable_ptr is hash.struct_xmlHashTable_ptr;
subtype xmlAttributeTablePtr is xmlAttributeTable_ptr;
subtype xmlIDTable is hash.struct_xmlHashTable;
subtype xmlIDTable_ptr is hash.struct_xmlHashTable_ptr;
subtype xmlIDTablePtr is xmlIDTable_ptr;
subtype xmlRefTable is hash.struct_xmlHashTable;
subtype xmlRefTable_ptr is hash.struct_xmlHashTable_ptr;
subtype xmlRefTablePtr is xmlRefTable_ptr;
function xmlAddNotationDecl (ctxt : access xmlValidCtxt;
dtd : access tree.xmlDtd; name : access constant xmlstring.xmlChar;
PublicID : access constant xmlstring.xmlChar;
SystemID : access constant xmlstring.xmlChar)
return tree.xmlNotationPtr;
pragma Import (C, xmlAddNotationDecl, "xmlAddNotationDecl");
function xmlCopyNotationTable (table : access xmlNotationTable)
return xmlNotationTablePtr;
pragma Import (C, xmlCopyNotationTable, "xmlCopyNotationTable");
procedure xmlFreeNotationTable (table : access xmlNotationTable);
pragma Import (C, xmlFreeNotationTable, "xmlFreeNotationTable");
procedure xmlDumpNotationDecl (buf : access tree.xmlBuffer;
nota : access tree.xmlNotation);
pragma Import (C, xmlDumpNotationDecl, "xmlDumpNotationDecl");
procedure xmlDumpNotationTable (buf : access tree.xmlBuffer;
table : access xmlNotationTable);
pragma Import (C, xmlDumpNotationTable, "xmlDumpNotationTable");
function xmlNewElementContent (name : access constant xmlstring.xmlChar;
A_type : tree.xmlElementContentType) return tree.xmlElementContentPtr;
pragma Import (C, xmlNewElementContent, "xmlNewElementContent");
function xmlCopyElementContent (content : access tree.xmlElementContent)
return tree.xmlElementContentPtr;
pragma Import (C, xmlCopyElementContent, "xmlCopyElementContent");
procedure xmlFreeElementContent (cur : access tree.xmlElementContent);
pragma Import (C, xmlFreeElementContent, "xmlFreeElementContent");
function xmlNewDocElementContent (doc : access tree.xmlDoc;
name : access constant xmlstring.xmlChar;
A_type : tree.xmlElementContentType) return tree.xmlElementContentPtr;
pragma Import (C, xmlNewDocElementContent, "xmlNewDocElementContent");
function xmlCopyDocElementContent (doc : access tree.xmlDoc;
content : access tree.xmlElementContent)
return tree.xmlElementContentPtr;
pragma Import (C, xmlCopyDocElementContent, "xmlCopyDocElementContent");
procedure xmlFreeDocElementContent (doc : access tree.xmlDoc;
cur : access tree.xmlElementContent);
pragma Import (C, xmlFreeDocElementContent, "xmlFreeDocElementContent");
procedure xmlSnprintfElementContent (buf : access char; size : signed_int;
content : access tree.xmlElementContent; englob : signed_int);
pragma Import (C, xmlSnprintfElementContent, "xmlSnprintfElementContent");
procedure xmlSprintfElementContent (buf : access char;
content : access tree.xmlElementContent; englob : signed_int);
pragma Import (C, xmlSprintfElementContent, "xmlSprintfElementContent");
function xmlAddElementDecl (ctxt : access xmlValidCtxt;
dtd : access tree.xmlDtd; name : access constant xmlstring.xmlChar;
A_type : tree.xmlElementTypeVal;
content : access tree.xmlElementContent) return tree.xmlElementPtr;
pragma Import (C, xmlAddElementDecl, "xmlAddElementDecl");
function xmlCopyElementTable (table : access xmlElementTable)
return xmlElementTablePtr;
pragma Import (C, xmlCopyElementTable, "xmlCopyElementTable");
procedure xmlFreeElementTable (table : access xmlElementTable);
pragma Import (C, xmlFreeElementTable, "xmlFreeElementTable");
procedure xmlDumpElementTable (buf : access tree.xmlBuffer;
table : access xmlElementTable);
pragma Import (C, xmlDumpElementTable, "xmlDumpElementTable");
procedure xmlDumpElementDecl (buf : access tree.xmlBuffer;
elem : access tree.xmlElement);
pragma Import (C, xmlDumpElementDecl, "xmlDumpElementDecl");
function xmlCreateEnumeration (name : access constant xmlstring.xmlChar)
return tree.xmlEnumerationPtr;
pragma Import (C, xmlCreateEnumeration, "xmlCreateEnumeration");
procedure xmlFreeEnumeration (cur : access tree.xmlEnumeration);
pragma Import (C, xmlFreeEnumeration, "xmlFreeEnumeration");
function xmlCopyEnumeration (cur : access tree.xmlEnumeration)
return tree.xmlEnumerationPtr;
pragma Import (C, xmlCopyEnumeration, "xmlCopyEnumeration");
function xmlAddAttributeDecl (ctxt : access xmlValidCtxt;
dtd : access libxml.tree.xmlDtd;
elem : access constant xmlstring.xmlChar;
name : access constant xmlstring.xmlChar;
ns : access constant xmlstring.xmlChar;
A_type : libxml.tree.xmlAttributeType;
def : libxml.tree.xmlAttributeDefault;
defaultValue : access constant xmlstring.xmlChar;
tree : access libxml.tree.xmlEnumeration)
return libxml.tree.xmlAttributePtr;
pragma Import (C, xmlAddAttributeDecl, "xmlAddAttributeDecl");
function xmlCopyAttributeTable (table : access xmlAttributeTable)
return xmlAttributeTablePtr;
pragma Import (C, xmlCopyAttributeTable, "xmlCopyAttributeTable");
procedure xmlFreeAttributeTable (table : access xmlAttributeTable);
pragma Import (C, xmlFreeAttributeTable, "xmlFreeAttributeTable");
procedure xmlDumpAttributeTable (buf : access tree.xmlBuffer;
table : access xmlAttributeTable);
pragma Import (C, xmlDumpAttributeTable, "xmlDumpAttributeTable");
procedure xmlDumpAttributeDecl (buf : access tree.xmlBuffer;
attr : access tree.xmlAttribute);
pragma Import (C, xmlDumpAttributeDecl, "xmlDumpAttributeDecl");
function xmlAddID (ctxt : access xmlValidCtxt; doc : access tree.xmlDoc;
value : access constant xmlstring.xmlChar; attr : access tree.xmlAttr)
return tree.xmlIDPtr;
pragma Import (C, xmlAddID, "xmlAddID");
procedure xmlFreeIDTable (table : access xmlIDTable);
pragma Import (C, xmlFreeIDTable, "xmlFreeIDTable");
function xmlGetID (doc : access tree.xmlDoc;
ID : access constant xmlstring.xmlChar) return tree.xmlAttrPtr;
pragma Import (C, xmlGetID, "xmlGetID");
function xmlIsID (doc : access tree.xmlDoc; elem : access tree.xmlNode;
attr : access tree.xmlAttr) return signed_int;
pragma Import (C, xmlIsID, "xmlIsID");
function xmlRemoveID (doc : access tree.xmlDoc;
attr : access tree.xmlAttr) return signed_int;
pragma Import (C, xmlRemoveID, "xmlRemoveID");
function xmlAddRef (ctxt : access xmlValidCtxt; doc : access tree.xmlDoc;
value : access constant xmlstring.xmlChar; attr : access tree.xmlAttr)
return tree.xmlRefPtr;
pragma Import (C, xmlAddRef, "xmlAddRef");
procedure xmlFreeRefTable (table : access xmlRefTable);
pragma Import (C, xmlFreeRefTable, "xmlFreeRefTable");
function xmlIsRef (doc : access tree.xmlDoc; elem : access tree.xmlNode;
attr : access tree.xmlAttr) return signed_int;
pragma Import (C, xmlIsRef, "xmlIsRef");
function xmlRemoveRef (doc : access tree.xmlDoc;
attr : access tree.xmlAttr) return signed_int;
pragma Import (C, xmlRemoveRef, "xmlRemoveRef");
function xmlGetRefs (doc : access tree.xmlDoc;
ID : access constant xmlstring.xmlChar) return list.xmlListPtr;
pragma Import (C, xmlGetRefs, "xmlGetRefs");
function xmlNewValidCtxt return xmlValidCtxtPtr;
pragma Import (C, xmlNewValidCtxt, "xmlNewValidCtxt");
procedure xmlFreeValidCtxt (a1 : access xmlValidCtxt);
pragma Import (C, xmlFreeValidCtxt, "xmlFreeValidCtxt");
function xmlValidateRoot (ctxt : access xmlValidCtxt;
doc : access tree.xmlDoc) return signed_int;
pragma Import (C, xmlValidateRoot, "xmlValidateRoot");
function xmlValidateElementDecl (ctxt : access xmlValidCtxt;
doc : access tree.xmlDoc; elem : access tree.xmlElement)
return signed_int;
pragma Import (C, xmlValidateElementDecl, "xmlValidateElementDecl");
function xmlValidNormalizeAttributeValue (doc : access tree.xmlDoc;
elem : access tree.xmlNode; name : access constant xmlstring.xmlChar;
value : access constant xmlstring.xmlChar)
return xmlstring.xmlChar_ptr;
pragma Import (C, xmlValidNormalizeAttributeValue,
"xmlValidNormalizeAttributeValue");
function xmlValidCtxtNormalizeAttributeValue (ctxt : access xmlValidCtxt;
doc : access tree.xmlDoc; elem : access tree.xmlNode;
name : access constant xmlstring.xmlChar;
value : access constant xmlstring.xmlChar)
return xmlstring.xmlChar_ptr;
pragma Import (C, xmlValidCtxtNormalizeAttributeValue,
"xmlValidCtxtNormalizeAttributeValue");
function xmlValidateAttributeDecl (ctxt : access xmlValidCtxt;
doc : access tree.xmlDoc; attr : access tree.xmlAttribute)
return signed_int;
pragma Import (C, xmlValidateAttributeDecl, "xmlValidateAttributeDecl");
function xmlValidateAttributeValue (A_type : tree.xmlAttributeType;
value : access constant xmlstring.xmlChar) return signed_int;
pragma Import (C, xmlValidateAttributeValue, "xmlValidateAttributeValue");
function xmlValidateNotationDecl (ctxt : access xmlValidCtxt;
doc : access tree.xmlDoc; nota : access tree.xmlNotation)
return signed_int;
pragma Import (C, xmlValidateNotationDecl, "xmlValidateNotationDecl");
function xmlValidateDtd (ctxt : access xmlValidCtxt;
doc : access tree.xmlDoc; dtd : access tree.xmlDtd) return signed_int;
pragma Import (C, xmlValidateDtd, "xmlValidateDtd");
function xmlValidateDtdFinal (ctxt : access xmlValidCtxt;
doc : access tree.xmlDoc) return signed_int;
pragma Import (C, xmlValidateDtdFinal, "xmlValidateDtdFinal");
function xmlValidateDocument (ctxt : access xmlValidCtxt;
doc : access tree.xmlDoc) return signed_int;
pragma Import (C, xmlValidateDocument, "xmlValidateDocument");
function xmlValidateElement (ctxt : access xmlValidCtxt;
doc : access tree.xmlDoc; elem : access tree.xmlNode)
return signed_int;
pragma Import (C, xmlValidateElement, "xmlValidateElement");
function xmlValidateOneElement (ctxt : access xmlValidCtxt;
doc : access tree.xmlDoc; elem : access tree.xmlNode)
return signed_int;
pragma Import (C, xmlValidateOneElement, "xmlValidateOneElement");
function xmlValidateOneAttribute (ctxt : access xmlValidCtxt;
doc : access tree.xmlDoc; elem : access tree.xmlNode;
attr : access tree.xmlAttr; value : access constant xmlstring.xmlChar)
return signed_int;
pragma Import (C, xmlValidateOneAttribute, "xmlValidateOneAttribute");
function xmlValidateOneNamespace (ctxt : access xmlValidCtxt;
doc : access tree.xmlDoc; elem : access tree.xmlNode;
prefix : access constant xmlstring.xmlChar; ns : access tree.xmlNs;
value : access constant xmlstring.xmlChar) return signed_int;
pragma Import (C, xmlValidateOneNamespace, "xmlValidateOneNamespace");
function xmlValidateDocumentFinal (ctxt : access xmlValidCtxt;
doc : access tree.xmlDoc) return signed_int;
pragma Import (C, xmlValidateDocumentFinal, "xmlValidateDocumentFinal");
function xmlValidateNotationUse (ctxt : access xmlValidCtxt;
doc : access tree.xmlDoc;
notationName : access constant xmlstring.xmlChar) return signed_int;
pragma Import (C, xmlValidateNotationUse, "xmlValidateNotationUse");
function xmlIsMixedElement (doc : access tree.xmlDoc;
name : access constant xmlstring.xmlChar) return signed_int;
pragma Import (C, xmlIsMixedElement, "xmlIsMixedElement");
function xmlGetDtdAttrDesc (dtd : access tree.xmlDtd;
elem : access constant xmlstring.xmlChar;
name : access constant xmlstring.xmlChar) return tree.xmlAttributePtr;
pragma Import (C, xmlGetDtdAttrDesc, "xmlGetDtdAttrDesc");
function xmlGetDtdQAttrDesc (dtd : access tree.xmlDtd;
elem : access constant xmlstring.xmlChar;
name : access constant xmlstring.xmlChar;
prefix : access constant xmlstring.xmlChar)
return tree.xmlAttributePtr;
pragma Import (C, xmlGetDtdQAttrDesc, "xmlGetDtdQAttrDesc");
function xmlGetDtdNotationDesc (dtd : access tree.xmlDtd;
name : access constant xmlstring.xmlChar) return tree.xmlNotationPtr;
pragma Import (C, xmlGetDtdNotationDesc, "xmlGetDtdNotationDesc");
function xmlGetDtdQElementDesc (dtd : access tree.xmlDtd;
name : access constant xmlstring.xmlChar;
prefix : access constant xmlstring.xmlChar) return tree.xmlElementPtr;
pragma Import (C, xmlGetDtdQElementDesc, "xmlGetDtdQElementDesc");
function xmlGetDtdElementDesc (dtd : access tree.xmlDtd;
name : access constant xmlstring.xmlChar) return tree.xmlElementPtr;
pragma Import (C, xmlGetDtdElementDesc, "xmlGetDtdElementDesc");
function xmlValidGetPotentialChildren (
ctree : access tree.xmlElementContent;
names : access xmlstring.xmlChar_const_ptr; len : access signed_int;
max : signed_int) return signed_int;
pragma Import (C, xmlValidGetPotentialChildren,
"xmlValidGetPotentialChildren");
function xmlValidGetValidElements (prev : access tree.xmlNode;
next : access tree.xmlNode; names : access xmlstring.xmlChar_const_ptr;
max : signed_int) return signed_int;
pragma Import (C, xmlValidGetValidElements, "xmlValidGetValidElements");
function xmlValidateNameValue (value : access constant xmlstring.xmlChar)
return signed_int;
pragma Import (C, xmlValidateNameValue, "xmlValidateNameValue");
function xmlValidateNamesValue (value : access constant xmlstring.xmlChar)
return signed_int;
pragma Import (C, xmlValidateNamesValue, "xmlValidateNamesValue");
function xmlValidateNmtokenValue (
value : access constant xmlstring.xmlChar) return signed_int;
pragma Import (C, xmlValidateNmtokenValue, "xmlValidateNmtokenValue");
function xmlValidateNmtokensValue (
value : access constant xmlstring.xmlChar) return signed_int;
pragma Import (C, xmlValidateNmtokensValue, "xmlValidateNmtokensValue");
function xmlValidBuildContentModel (ctxt : access xmlValidCtxt;
elem : access tree.xmlElement) return signed_int;
pragma Import (C, xmlValidBuildContentModel, "xmlValidBuildContentModel");
function xmlValidatePushElement (ctxt : access xmlValidCtxt;
doc : access tree.xmlDoc; elem : access tree.xmlNode;
qname : access constant xmlstring.xmlChar) return signed_int;
pragma Import (C, xmlValidatePushElement, "xmlValidatePushElement");
function xmlValidatePushCData (ctxt : access xmlValidCtxt;
data : access constant xmlstring.xmlChar; len : signed_int)
return signed_int;
pragma Import (C, xmlValidatePushCData, "xmlValidatePushCData");
function xmlValidatePopElement (ctxt : access xmlValidCtxt;
doc : access tree.xmlDoc; elem : access tree.xmlNode;
qname : access constant xmlstring.xmlChar) return signed_int;
pragma Import (C, xmlValidatePopElement, "xmlValidatePopElement");
-- __XML_VALID_H__ (empty)
private
type struct_xmlValidState is null record;
end C.libxml.valid;
Raw
c-libxml-xmlautomata.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.libxml.xmlregexp;
with C.libxml.xmlstring;
package C.libxml.xmlautomata is
pragma Preelaborate;
type struct_xmlAutomata (<>) is limited private;
type struct_xmlAutomata_ptr is access all struct_xmlAutomata;
for struct_xmlAutomata_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlAutomata_ptr);
pragma Convention (C, struct_xmlAutomata_ptr);
subtype xmlAutomata is struct_xmlAutomata;
subtype xmlAutomata_ptr is struct_xmlAutomata_ptr;
subtype xmlAutomataPtr is xmlAutomata_ptr;
type struct_xmlAutomataState (<>) is limited private;
type struct_xmlAutomataState_ptr is access all struct_xmlAutomataState;
for struct_xmlAutomataState_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlAutomataState_ptr);
pragma Convention (C, struct_xmlAutomataState_ptr);
subtype xmlAutomataState is struct_xmlAutomataState;
subtype xmlAutomataState_ptr is struct_xmlAutomataState_ptr;
subtype xmlAutomataStatePtr is xmlAutomataState_ptr;
function xmlNewAutomata return xmlAutomataPtr;
pragma Import (C, xmlNewAutomata, "xmlNewAutomata");
procedure xmlFreeAutomata (am : access xmlAutomata);
pragma Import (C, xmlFreeAutomata, "xmlFreeAutomata");
function xmlAutomataGetInitState (am : access xmlAutomata)
return xmlAutomataStatePtr;
pragma Import (C, xmlAutomataGetInitState, "xmlAutomataGetInitState");
function xmlAutomataSetFinalState (am : access xmlAutomata;
state : access xmlAutomataState) return signed_int;
pragma Import (C, xmlAutomataSetFinalState, "xmlAutomataSetFinalState");
function xmlAutomataNewState (am : access xmlAutomata)
return xmlAutomataStatePtr;
pragma Import (C, xmlAutomataNewState, "xmlAutomataNewState");
function xmlAutomataNewTransition (am : access xmlAutomata;
from : access xmlAutomataState; to : access xmlAutomataState;
token : access constant xmlstring.xmlChar; data : void_ptr)
return xmlAutomataStatePtr;
pragma Import (C, xmlAutomataNewTransition, "xmlAutomataNewTransition");
function xmlAutomataNewTransition2 (am : access xmlAutomata;
from : access xmlAutomataState; to : access xmlAutomataState;
token : access constant xmlstring.xmlChar;
token2 : access constant xmlstring.xmlChar; data : void_ptr)
return xmlAutomataStatePtr;
pragma Import (C, xmlAutomataNewTransition2, "xmlAutomataNewTransition2");
function xmlAutomataNewNegTrans (am : access xmlAutomata;
from : access xmlAutomataState; to : access xmlAutomataState;
token : access constant xmlstring.xmlChar;
token2 : access constant xmlstring.xmlChar; data : void_ptr)
return xmlAutomataStatePtr;
pragma Import (C, xmlAutomataNewNegTrans, "xmlAutomataNewNegTrans");
function xmlAutomataNewCountTrans (am : access xmlAutomata;
from : access xmlAutomataState; to : access xmlAutomataState;
token : access constant xmlstring.xmlChar; min : signed_int;
max : signed_int; data : void_ptr) return xmlAutomataStatePtr;
pragma Import (C, xmlAutomataNewCountTrans, "xmlAutomataNewCountTrans");
function xmlAutomataNewCountTrans2 (am : access xmlAutomata;
from : access xmlAutomataState; to : access xmlAutomataState;
token : access constant xmlstring.xmlChar;
token2 : access constant xmlstring.xmlChar; min : signed_int;
max : signed_int; data : void_ptr) return xmlAutomataStatePtr;
pragma Import (C, xmlAutomataNewCountTrans2, "xmlAutomataNewCountTrans2");
function xmlAutomataNewOnceTrans (am : access xmlAutomata;
from : access xmlAutomataState; to : access xmlAutomataState;
token : access constant xmlstring.xmlChar; min : signed_int;
max : signed_int; data : void_ptr) return xmlAutomataStatePtr;
pragma Import (C, xmlAutomataNewOnceTrans, "xmlAutomataNewOnceTrans");
function xmlAutomataNewOnceTrans2 (am : access xmlAutomata;
from : access xmlAutomataState; to : access xmlAutomataState;
token : access constant xmlstring.xmlChar;
token2 : access constant xmlstring.xmlChar; min : signed_int;
max : signed_int; data : void_ptr) return xmlAutomataStatePtr;
pragma Import (C, xmlAutomataNewOnceTrans2, "xmlAutomataNewOnceTrans2");
function xmlAutomataNewAllTrans (am : access xmlAutomata;
from : access xmlAutomataState; to : access xmlAutomataState;
lax : signed_int) return xmlAutomataStatePtr;
pragma Import (C, xmlAutomataNewAllTrans, "xmlAutomataNewAllTrans");
function xmlAutomataNewEpsilon (am : access xmlAutomata;
from : access xmlAutomataState; to : access xmlAutomataState)
return xmlAutomataStatePtr;
pragma Import (C, xmlAutomataNewEpsilon, "xmlAutomataNewEpsilon");
function xmlAutomataNewCountedTrans (am : access xmlAutomata;
from : access xmlAutomataState; to : access xmlAutomataState;
counter : signed_int) return xmlAutomataStatePtr;
pragma Import (C, xmlAutomataNewCountedTrans,
"xmlAutomataNewCountedTrans");
function xmlAutomataNewCounterTrans (am : access xmlAutomata;
from : access xmlAutomataState; to : access xmlAutomataState;
counter : signed_int) return xmlAutomataStatePtr;
pragma Import (C, xmlAutomataNewCounterTrans,
"xmlAutomataNewCounterTrans");
function xmlAutomataNewCounter (am : access xmlAutomata; min : signed_int;
max : signed_int) return signed_int;
pragma Import (C, xmlAutomataNewCounter, "xmlAutomataNewCounter");
function xmlAutomataCompile (am : access xmlAutomata)
return xmlregexp.xmlRegexpPtr;
pragma Import (C, xmlAutomataCompile, "xmlAutomataCompile");
function xmlAutomataIsDeterminist (am : access xmlAutomata)
return signed_int;
pragma Import (C, xmlAutomataIsDeterminist, "xmlAutomataIsDeterminist");
-- __XML_AUTOMATA_H__ (empty)
private
type struct_xmlAutomata is null record;
type struct_xmlAutomataState is null record;
end C.libxml.xmlautomata;
Raw
c-libxml-xmlerror.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.
-------------------------------------------------------------------------------
limited with C.libxml.parser;
package C.libxml.xmlerror is
pragma Preelaborate;
type enum_da0416db is (XML_ERR_NONE, XML_ERR_WARNING, XML_ERR_ERROR,
XML_ERR_FATAL);
for enum_da0416db use (XML_ERR_NONE => 0, XML_ERR_WARNING => 1,
XML_ERR_ERROR => 2, XML_ERR_FATAL => 3);
pragma Convention (C, enum_da0416db);
subtype xmlErrorLevel is enum_da0416db;
type enum_2569f396 is (XML_FROM_NONE, XML_FROM_PARSER, XML_FROM_TREE,
XML_FROM_NAMESPACE, XML_FROM_DTD, XML_FROM_HTML, XML_FROM_MEMORY,
XML_FROM_OUTPUT, XML_FROM_IO, XML_FROM_FTP, XML_FROM_HTTP,
XML_FROM_XINCLUDE, XML_FROM_XPATH, XML_FROM_XPOINTER, XML_FROM_REGEXP,
XML_FROM_DATATYPE, XML_FROM_SCHEMASP, XML_FROM_SCHEMASV,
XML_FROM_RELAXNGP, XML_FROM_RELAXNGV, XML_FROM_CATALOG, XML_FROM_C14N,
XML_FROM_XSLT, XML_FROM_VALID, XML_FROM_CHECK, XML_FROM_WRITER,
XML_FROM_MODULE, XML_FROM_I18N, XML_FROM_SCHEMATRONV, XML_FROM_BUFFER,
XML_FROM_URI);
for enum_2569f396 use (XML_FROM_NONE => 0, XML_FROM_PARSER => 1,
XML_FROM_TREE => 2, XML_FROM_NAMESPACE => 3, XML_FROM_DTD => 4,
XML_FROM_HTML => 5, XML_FROM_MEMORY => 6, XML_FROM_OUTPUT => 7,
XML_FROM_IO => 8, XML_FROM_FTP => 9, XML_FROM_HTTP => 10,
XML_FROM_XINCLUDE => 11, XML_FROM_XPATH => 12, XML_FROM_XPOINTER => 13,
XML_FROM_REGEXP => 14, XML_FROM_DATATYPE => 15,
XML_FROM_SCHEMASP => 16, XML_FROM_SCHEMASV => 17,
XML_FROM_RELAXNGP => 18, XML_FROM_RELAXNGV => 19,
XML_FROM_CATALOG => 20, XML_FROM_C14N => 21, XML_FROM_XSLT => 22,
XML_FROM_VALID => 23, XML_FROM_CHECK => 24, XML_FROM_WRITER => 25,
XML_FROM_MODULE => 26, XML_FROM_I18N => 27, XML_FROM_SCHEMATRONV => 28,
XML_FROM_BUFFER => 29, XML_FROM_URI => 30);
pragma Convention (C, enum_2569f396);
subtype xmlErrorDomain is enum_2569f396;
type struct_xmlError;
type struct_xmlError_ptr is access all struct_xmlError;
for struct_xmlError_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlError_ptr);
pragma Convention (C, struct_xmlError_ptr);
subtype xmlError is struct_xmlError;
subtype xmlError_ptr is struct_xmlError_ptr;
subtype xmlErrorPtr is xmlError_ptr;
type struct_xmlError is record
domain : aliased signed_int;
code : aliased signed_int;
message : aliased char_ptr;
level : aliased xmlErrorLevel;
file : aliased char_ptr;
line : aliased signed_int;
str1 : aliased char_ptr;
str2 : aliased char_ptr;
str3 : aliased char_ptr;
int1 : aliased signed_int;
int2 : aliased signed_int;
ctxt : aliased void_ptr;
node : aliased void_ptr;
end record;
pragma Convention (C_Pass_By_Copy, struct_xmlError);
type enum_e5ead1e1 is (XML_ERR_OK, XML_ERR_INTERNAL_ERROR,
XML_ERR_NO_MEMORY, XML_ERR_DOCUMENT_START, XML_ERR_DOCUMENT_EMPTY,
XML_ERR_DOCUMENT_END, XML_ERR_INVALID_HEX_CHARREF,
XML_ERR_INVALID_DEC_CHARREF, XML_ERR_INVALID_CHARREF,
XML_ERR_INVALID_CHAR, XML_ERR_CHARREF_AT_EOF,
XML_ERR_CHARREF_IN_PROLOG, XML_ERR_CHARREF_IN_EPILOG,
XML_ERR_CHARREF_IN_DTD, XML_ERR_ENTITYREF_AT_EOF,
XML_ERR_ENTITYREF_IN_PROLOG, XML_ERR_ENTITYREF_IN_EPILOG,
XML_ERR_ENTITYREF_IN_DTD, XML_ERR_PEREF_AT_EOF,
XML_ERR_PEREF_IN_PROLOG, XML_ERR_PEREF_IN_EPILOG,
XML_ERR_PEREF_IN_INT_SUBSET, XML_ERR_ENTITYREF_NO_NAME,
XML_ERR_ENTITYREF_SEMICOL_MISSING, XML_ERR_PEREF_NO_NAME,
XML_ERR_PEREF_SEMICOL_MISSING, XML_ERR_UNDECLARED_ENTITY,
XML_WAR_UNDECLARED_ENTITY, XML_ERR_UNPARSED_ENTITY,
XML_ERR_ENTITY_IS_EXTERNAL, XML_ERR_ENTITY_IS_PARAMETER,
XML_ERR_UNKNOWN_ENCODING, XML_ERR_UNSUPPORTED_ENCODING,
XML_ERR_STRING_NOT_STARTED, XML_ERR_STRING_NOT_CLOSED,
XML_ERR_NS_DECL_ERROR, XML_ERR_ENTITY_NOT_STARTED,
XML_ERR_ENTITY_NOT_FINISHED, XML_ERR_LT_IN_ATTRIBUTE,
XML_ERR_ATTRIBUTE_NOT_STARTED, XML_ERR_ATTRIBUTE_NOT_FINISHED,
XML_ERR_ATTRIBUTE_WITHOUT_VALUE, XML_ERR_ATTRIBUTE_REDEFINED,
XML_ERR_LITERAL_NOT_STARTED, XML_ERR_LITERAL_NOT_FINISHED,
XML_ERR_COMMENT_NOT_FINISHED, XML_ERR_PI_NOT_STARTED,
XML_ERR_PI_NOT_FINISHED, XML_ERR_NOTATION_NOT_STARTED,
XML_ERR_NOTATION_NOT_FINISHED, XML_ERR_ATTLIST_NOT_STARTED,
XML_ERR_ATTLIST_NOT_FINISHED, XML_ERR_MIXED_NOT_STARTED,
XML_ERR_MIXED_NOT_FINISHED, XML_ERR_ELEMCONTENT_NOT_STARTED,
XML_ERR_ELEMCONTENT_NOT_FINISHED, XML_ERR_XMLDECL_NOT_STARTED,
XML_ERR_XMLDECL_NOT_FINISHED, XML_ERR_CONDSEC_NOT_STARTED,
XML_ERR_CONDSEC_NOT_FINISHED, XML_ERR_EXT_SUBSET_NOT_FINISHED,
XML_ERR_DOCTYPE_NOT_FINISHED, XML_ERR_MISPLACED_CDATA_END,
XML_ERR_CDATA_NOT_FINISHED, XML_ERR_RESERVED_XML_NAME,
XML_ERR_SPACE_REQUIRED, XML_ERR_SEPARATOR_REQUIRED,
XML_ERR_NMTOKEN_REQUIRED, XML_ERR_NAME_REQUIRED,
XML_ERR_PCDATA_REQUIRED, XML_ERR_URI_REQUIRED, XML_ERR_PUBID_REQUIRED,
XML_ERR_LT_REQUIRED, XML_ERR_GT_REQUIRED, XML_ERR_LTSLASH_REQUIRED,
XML_ERR_EQUAL_REQUIRED, XML_ERR_TAG_NAME_MISMATCH,
XML_ERR_TAG_NOT_FINISHED, XML_ERR_STANDALONE_VALUE,
XML_ERR_ENCODING_NAME, XML_ERR_HYPHEN_IN_COMMENT,
XML_ERR_INVALID_ENCODING, XML_ERR_EXT_ENTITY_STANDALONE,
XML_ERR_CONDSEC_INVALID, XML_ERR_VALUE_REQUIRED,
XML_ERR_NOT_WELL_BALANCED, XML_ERR_EXTRA_CONTENT,
XML_ERR_ENTITY_CHAR_ERROR, XML_ERR_ENTITY_PE_INTERNAL,
XML_ERR_ENTITY_LOOP, XML_ERR_ENTITY_BOUNDARY, XML_ERR_INVALID_URI,
XML_ERR_URI_FRAGMENT, XML_WAR_CATALOG_PI, XML_ERR_NO_DTD,
XML_ERR_CONDSEC_INVALID_KEYWORD, XML_ERR_VERSION_MISSING,
XML_WAR_UNKNOWN_VERSION, XML_WAR_LANG_VALUE, XML_WAR_NS_URI,
XML_WAR_NS_URI_RELATIVE, XML_ERR_MISSING_ENCODING, XML_WAR_SPACE_VALUE,
XML_ERR_NOT_STANDALONE, XML_ERR_ENTITY_PROCESSING,
XML_ERR_NOTATION_PROCESSING, XML_WAR_NS_COLUMN,
XML_WAR_ENTITY_REDEFINED, XML_ERR_UNKNOWN_VERSION,
XML_ERR_VERSION_MISMATCH, XML_ERR_NAME_TOO_LONG, XML_ERR_USER_STOP,
XML_NS_ERR_XML_NAMESPACE, XML_NS_ERR_UNDEFINED_NAMESPACE,
XML_NS_ERR_QNAME, XML_NS_ERR_ATTRIBUTE_REDEFINED, XML_NS_ERR_EMPTY,
XML_NS_ERR_COLON, XML_DTD_ATTRIBUTE_DEFAULT,
XML_DTD_ATTRIBUTE_REDEFINED, XML_DTD_ATTRIBUTE_VALUE,
XML_DTD_CONTENT_ERROR, XML_DTD_CONTENT_MODEL,
XML_DTD_CONTENT_NOT_DETERMINIST, XML_DTD_DIFFERENT_PREFIX,
XML_DTD_ELEM_DEFAULT_NAMESPACE, XML_DTD_ELEM_NAMESPACE,
XML_DTD_ELEM_REDEFINED, XML_DTD_EMPTY_NOTATION, XML_DTD_ENTITY_TYPE,
XML_DTD_ID_FIXED, XML_DTD_ID_REDEFINED, XML_DTD_ID_SUBSET,
XML_DTD_INVALID_CHILD, XML_DTD_INVALID_DEFAULT, XML_DTD_LOAD_ERROR,
XML_DTD_MISSING_ATTRIBUTE, XML_DTD_MIXED_CORRUPT, XML_DTD_MULTIPLE_ID,
XML_DTD_NO_DOC, XML_DTD_NO_DTD, XML_DTD_NO_ELEM_NAME,
XML_DTD_NO_PREFIX, XML_DTD_NO_ROOT, XML_DTD_NOTATION_REDEFINED,
XML_DTD_NOTATION_VALUE, XML_DTD_NOT_EMPTY, XML_DTD_NOT_PCDATA,
XML_DTD_NOT_STANDALONE, XML_DTD_ROOT_NAME,
XML_DTD_STANDALONE_WHITE_SPACE, XML_DTD_UNKNOWN_ATTRIBUTE,
XML_DTD_UNKNOWN_ELEM, XML_DTD_UNKNOWN_ENTITY, XML_DTD_UNKNOWN_ID,
XML_DTD_UNKNOWN_NOTATION, XML_DTD_STANDALONE_DEFAULTED,
XML_DTD_XMLID_VALUE, XML_DTD_XMLID_TYPE, XML_DTD_DUP_TOKEN,
XML_HTML_STRUCURE_ERROR, XML_HTML_UNKNOWN_TAG,
XML_RNGP_ANYNAME_ATTR_ANCESTOR, XML_RNGP_ATTR_CONFLICT,
XML_RNGP_ATTRIBUTE_CHILDREN, XML_RNGP_ATTRIBUTE_CONTENT,
XML_RNGP_ATTRIBUTE_EMPTY, XML_RNGP_ATTRIBUTE_NOOP,
XML_RNGP_CHOICE_CONTENT, XML_RNGP_CHOICE_EMPTY,
XML_RNGP_CREATE_FAILURE, XML_RNGP_DATA_CONTENT,
XML_RNGP_DEF_CHOICE_AND_INTERLEAVE, XML_RNGP_DEFINE_CREATE_FAILED,
XML_RNGP_DEFINE_EMPTY, XML_RNGP_DEFINE_MISSING,
XML_RNGP_DEFINE_NAME_MISSING, XML_RNGP_ELEM_CONTENT_EMPTY,
XML_RNGP_ELEM_CONTENT_ERROR, XML_RNGP_ELEMENT_EMPTY,
XML_RNGP_ELEMENT_CONTENT, XML_RNGP_ELEMENT_NAME,
XML_RNGP_ELEMENT_NO_CONTENT, XML_RNGP_ELEM_TEXT_CONFLICT,
XML_RNGP_EMPTY, XML_RNGP_EMPTY_CONSTRUCT, XML_RNGP_EMPTY_CONTENT,
XML_RNGP_EMPTY_NOT_EMPTY, XML_RNGP_ERROR_TYPE_LIB,
XML_RNGP_EXCEPT_EMPTY, XML_RNGP_EXCEPT_MISSING,
XML_RNGP_EXCEPT_MULTIPLE, XML_RNGP_EXCEPT_NO_CONTENT,
XML_RNGP_EXTERNALREF_EMTPY, XML_RNGP_EXTERNAL_REF_FAILURE,
XML_RNGP_EXTERNALREF_RECURSE, XML_RNGP_FORBIDDEN_ATTRIBUTE,
XML_RNGP_FOREIGN_ELEMENT, XML_RNGP_GRAMMAR_CONTENT,
XML_RNGP_GRAMMAR_EMPTY, XML_RNGP_GRAMMAR_MISSING,
XML_RNGP_GRAMMAR_NO_START, XML_RNGP_GROUP_ATTR_CONFLICT,
XML_RNGP_HREF_ERROR, XML_RNGP_INCLUDE_EMPTY, XML_RNGP_INCLUDE_FAILURE,
XML_RNGP_INCLUDE_RECURSE, XML_RNGP_INTERLEAVE_ADD,
XML_RNGP_INTERLEAVE_CREATE_FAILED, XML_RNGP_INTERLEAVE_EMPTY,
XML_RNGP_INTERLEAVE_NO_CONTENT, XML_RNGP_INVALID_DEFINE_NAME,
XML_RNGP_INVALID_URI, XML_RNGP_INVALID_VALUE, XML_RNGP_MISSING_HREF,
XML_RNGP_NAME_MISSING, XML_RNGP_NEED_COMBINE,
XML_RNGP_NOTALLOWED_NOT_EMPTY, XML_RNGP_NSNAME_ATTR_ANCESTOR,
XML_RNGP_NSNAME_NO_NS, XML_RNGP_PARAM_FORBIDDEN,
XML_RNGP_PARAM_NAME_MISSING, XML_RNGP_PARENTREF_CREATE_FAILED,
XML_RNGP_PARENTREF_NAME_INVALID, XML_RNGP_PARENTREF_NO_NAME,
XML_RNGP_PARENTREF_NO_PARENT, XML_RNGP_PARENTREF_NOT_EMPTY,
XML_RNGP_PARSE_ERROR, XML_RNGP_PAT_ANYNAME_EXCEPT_ANYNAME,
XML_RNGP_PAT_ATTR_ATTR, XML_RNGP_PAT_ATTR_ELEM,
XML_RNGP_PAT_DATA_EXCEPT_ATTR, XML_RNGP_PAT_DATA_EXCEPT_ELEM,
XML_RNGP_PAT_DATA_EXCEPT_EMPTY, XML_RNGP_PAT_DATA_EXCEPT_GROUP,
XML_RNGP_PAT_DATA_EXCEPT_INTERLEAVE, XML_RNGP_PAT_DATA_EXCEPT_LIST,
XML_RNGP_PAT_DATA_EXCEPT_ONEMORE, XML_RNGP_PAT_DATA_EXCEPT_REF,
XML_RNGP_PAT_DATA_EXCEPT_TEXT, XML_RNGP_PAT_LIST_ATTR,
XML_RNGP_PAT_LIST_ELEM, XML_RNGP_PAT_LIST_INTERLEAVE,
XML_RNGP_PAT_LIST_LIST, XML_RNGP_PAT_LIST_REF, XML_RNGP_PAT_LIST_TEXT,
XML_RNGP_PAT_NSNAME_EXCEPT_ANYNAME, XML_RNGP_PAT_NSNAME_EXCEPT_NSNAME,
XML_RNGP_PAT_ONEMORE_GROUP_ATTR, XML_RNGP_PAT_ONEMORE_INTERLEAVE_ATTR,
XML_RNGP_PAT_START_ATTR, XML_RNGP_PAT_START_DATA,
XML_RNGP_PAT_START_EMPTY, XML_RNGP_PAT_START_GROUP,
XML_RNGP_PAT_START_INTERLEAVE, XML_RNGP_PAT_START_LIST,
XML_RNGP_PAT_START_ONEMORE, XML_RNGP_PAT_START_TEXT,
XML_RNGP_PAT_START_VALUE, XML_RNGP_PREFIX_UNDEFINED,
XML_RNGP_REF_CREATE_FAILED, XML_RNGP_REF_CYCLE,
XML_RNGP_REF_NAME_INVALID, XML_RNGP_REF_NO_DEF, XML_RNGP_REF_NO_NAME,
XML_RNGP_REF_NOT_EMPTY, XML_RNGP_START_CHOICE_AND_INTERLEAVE,
XML_RNGP_START_CONTENT, XML_RNGP_START_EMPTY, XML_RNGP_START_MISSING,
XML_RNGP_TEXT_EXPECTED, XML_RNGP_TEXT_HAS_CHILD, XML_RNGP_TYPE_MISSING,
XML_RNGP_TYPE_NOT_FOUND, XML_RNGP_TYPE_VALUE,
XML_RNGP_UNKNOWN_ATTRIBUTE, XML_RNGP_UNKNOWN_COMBINE,
XML_RNGP_UNKNOWN_CONSTRUCT, XML_RNGP_UNKNOWN_TYPE_LIB,
XML_RNGP_URI_FRAGMENT, XML_RNGP_URI_NOT_ABSOLUTE, XML_RNGP_VALUE_EMPTY,
XML_RNGP_VALUE_NO_CONTENT, XML_RNGP_XMLNS_NAME, XML_RNGP_XML_NS,
XML_XPATH_EXPRESSION_OK, XML_XPATH_NUMBER_ERROR,
XML_XPATH_UNFINISHED_LITERAL_ERROR, XML_XPATH_START_LITERAL_ERROR,
XML_XPATH_VARIABLE_REF_ERROR, XML_XPATH_UNDEF_VARIABLE_ERROR,
XML_XPATH_INVALID_PREDICATE_ERROR, XML_XPATH_EXPR_ERROR,
XML_XPATH_UNCLOSED_ERROR, XML_XPATH_UNKNOWN_FUNC_ERROR,
XML_XPATH_INVALID_OPERAND, XML_XPATH_INVALID_TYPE,
XML_XPATH_INVALID_ARITY, XML_XPATH_INVALID_CTXT_SIZE,
XML_XPATH_INVALID_CTXT_POSITION, XML_XPATH_MEMORY_ERROR,
XML_XPTR_SYNTAX_ERROR, XML_XPTR_RESOURCE_ERROR,
XML_XPTR_SUB_RESOURCE_ERROR, XML_XPATH_UNDEF_PREFIX_ERROR,
XML_XPATH_ENCODING_ERROR, XML_XPATH_INVALID_CHAR_ERROR,
XML_TREE_INVALID_HEX, XML_TREE_INVALID_DEC,
XML_TREE_UNTERMINATED_ENTITY, XML_TREE_NOT_UTF8, XML_SAVE_NOT_UTF8,
XML_SAVE_CHAR_INVALID, XML_SAVE_NO_DOCTYPE, XML_SAVE_UNKNOWN_ENCODING,
XML_REGEXP_COMPILE_ERROR, XML_IO_UNKNOWN, XML_IO_EACCES, XML_IO_EAGAIN,
XML_IO_EBADF, XML_IO_EBADMSG, XML_IO_EBUSY, XML_IO_ECANCELED,
XML_IO_ECHILD, XML_IO_EDEADLK, XML_IO_EDOM, XML_IO_EEXIST,
XML_IO_EFAULT, XML_IO_EFBIG, XML_IO_EINPROGRESS, XML_IO_EINTR,
XML_IO_EINVAL, XML_IO_EIO, XML_IO_EISDIR, XML_IO_EMFILE, XML_IO_EMLINK,
XML_IO_EMSGSIZE, XML_IO_ENAMETOOLONG, XML_IO_ENFILE, XML_IO_ENODEV,
XML_IO_ENOENT, XML_IO_ENOEXEC, XML_IO_ENOLCK, XML_IO_ENOMEM,
XML_IO_ENOSPC, XML_IO_ENOSYS, XML_IO_ENOTDIR, XML_IO_ENOTEMPTY,
XML_IO_ENOTSUP, XML_IO_ENOTTY, XML_IO_ENXIO, XML_IO_EPERM,
XML_IO_EPIPE, XML_IO_ERANGE, XML_IO_EROFS, XML_IO_ESPIPE, XML_IO_ESRCH,
XML_IO_ETIMEDOUT, XML_IO_EXDEV, XML_IO_NETWORK_ATTEMPT, XML_IO_ENCODER,
XML_IO_FLUSH, XML_IO_WRITE, XML_IO_NO_INPUT, XML_IO_BUFFER_FULL,
XML_IO_LOAD_ERROR, XML_IO_ENOTSOCK, XML_IO_EISCONN,
XML_IO_ECONNREFUSED, XML_IO_ENETUNREACH, XML_IO_EADDRINUSE,
XML_IO_EALREADY, XML_IO_EAFNOSUPPORT, XML_XINCLUDE_RECURSION,
XML_XINCLUDE_PARSE_VALUE, XML_XINCLUDE_ENTITY_DEF_MISMATCH,
XML_XINCLUDE_NO_HREF, XML_XINCLUDE_NO_FALLBACK, XML_XINCLUDE_HREF_URI,
XML_XINCLUDE_TEXT_FRAGMENT, XML_XINCLUDE_TEXT_DOCUMENT,
XML_XINCLUDE_INVALID_CHAR, XML_XINCLUDE_BUILD_FAILED,
XML_XINCLUDE_UNKNOWN_ENCODING, XML_XINCLUDE_MULTIPLE_ROOT,
XML_XINCLUDE_XPTR_FAILED, XML_XINCLUDE_XPTR_RESULT,
XML_XINCLUDE_INCLUDE_IN_INCLUDE, XML_XINCLUDE_FALLBACKS_IN_INCLUDE,
XML_XINCLUDE_FALLBACK_NOT_IN_INCLUDE, XML_XINCLUDE_DEPRECATED_NS,
XML_XINCLUDE_FRAGMENT_ID, XML_CATALOG_MISSING_ATTR,
XML_CATALOG_ENTRY_BROKEN, XML_CATALOG_PREFER_VALUE,
XML_CATALOG_NOT_CATALOG, XML_CATALOG_RECURSION,
XML_SCHEMAP_PREFIX_UNDEFINED, XML_SCHEMAP_ATTRFORMDEFAULT_VALUE,
XML_SCHEMAP_ATTRGRP_NONAME_NOREF, XML_SCHEMAP_ATTR_NONAME_NOREF,
XML_SCHEMAP_COMPLEXTYPE_NONAME_NOREF,
XML_SCHEMAP_ELEMFORMDEFAULT_VALUE, XML_SCHEMAP_ELEM_NONAME_NOREF,
XML_SCHEMAP_EXTENSION_NO_BASE, XML_SCHEMAP_FACET_NO_VALUE,
XML_SCHEMAP_FAILED_BUILD_IMPORT, XML_SCHEMAP_GROUP_NONAME_NOREF,
XML_SCHEMAP_IMPORT_NAMESPACE_NOT_URI,
XML_SCHEMAP_IMPORT_REDEFINE_NSNAME, XML_SCHEMAP_IMPORT_SCHEMA_NOT_URI,
XML_SCHEMAP_INVALID_BOOLEAN, XML_SCHEMAP_INVALID_ENUM,
XML_SCHEMAP_INVALID_FACET, XML_SCHEMAP_INVALID_FACET_VALUE,
XML_SCHEMAP_INVALID_MAXOCCURS, XML_SCHEMAP_INVALID_MINOCCURS,
XML_SCHEMAP_INVALID_REF_AND_SUBTYPE, XML_SCHEMAP_INVALID_WHITE_SPACE,
XML_SCHEMAP_NOATTR_NOREF, XML_SCHEMAP_NOTATION_NO_NAME,
XML_SCHEMAP_NOTYPE_NOREF, XML_SCHEMAP_REF_AND_SUBTYPE,
XML_SCHEMAP_RESTRICTION_NONAME_NOREF, XML_SCHEMAP_SIMPLETYPE_NONAME,
XML_SCHEMAP_TYPE_AND_SUBTYPE, XML_SCHEMAP_UNKNOWN_ALL_CHILD,
XML_SCHEMAP_UNKNOWN_ANYATTRIBUTE_CHILD, XML_SCHEMAP_UNKNOWN_ATTR_CHILD,
XML_SCHEMAP_UNKNOWN_ATTRGRP_CHILD, XML_SCHEMAP_UNKNOWN_ATTRIBUTE_GROUP,
XML_SCHEMAP_UNKNOWN_BASE_TYPE, XML_SCHEMAP_UNKNOWN_CHOICE_CHILD,
XML_SCHEMAP_UNKNOWN_COMPLEXCONTENT_CHILD,
XML_SCHEMAP_UNKNOWN_COMPLEXTYPE_CHILD, XML_SCHEMAP_UNKNOWN_ELEM_CHILD,
XML_SCHEMAP_UNKNOWN_EXTENSION_CHILD, XML_SCHEMAP_UNKNOWN_FACET_CHILD,
XML_SCHEMAP_UNKNOWN_FACET_TYPE, XML_SCHEMAP_UNKNOWN_GROUP_CHILD,
XML_SCHEMAP_UNKNOWN_IMPORT_CHILD, XML_SCHEMAP_UNKNOWN_LIST_CHILD,
XML_SCHEMAP_UNKNOWN_NOTATION_CHILD,
XML_SCHEMAP_UNKNOWN_PROCESSCONTENT_CHILD, XML_SCHEMAP_UNKNOWN_REF,
XML_SCHEMAP_UNKNOWN_RESTRICTION_CHILD,
XML_SCHEMAP_UNKNOWN_SCHEMAS_CHILD, XML_SCHEMAP_UNKNOWN_SEQUENCE_CHILD,
XML_SCHEMAP_UNKNOWN_SIMPLECONTENT_CHILD,
XML_SCHEMAP_UNKNOWN_SIMPLETYPE_CHILD, XML_SCHEMAP_UNKNOWN_TYPE,
XML_SCHEMAP_UNKNOWN_UNION_CHILD, XML_SCHEMAP_ELEM_DEFAULT_FIXED,
XML_SCHEMAP_REGEXP_INVALID, XML_SCHEMAP_FAILED_LOAD,
XML_SCHEMAP_NOTHING_TO_PARSE, XML_SCHEMAP_NOROOT,
XML_SCHEMAP_REDEFINED_GROUP, XML_SCHEMAP_REDEFINED_TYPE,
XML_SCHEMAP_REDEFINED_ELEMENT, XML_SCHEMAP_REDEFINED_ATTRGROUP,
XML_SCHEMAP_REDEFINED_ATTR, XML_SCHEMAP_REDEFINED_NOTATION,
XML_SCHEMAP_FAILED_PARSE, XML_SCHEMAP_UNKNOWN_PREFIX,
XML_SCHEMAP_DEF_AND_PREFIX, XML_SCHEMAP_UNKNOWN_INCLUDE_CHILD,
XML_SCHEMAP_INCLUDE_SCHEMA_NOT_URI, XML_SCHEMAP_INCLUDE_SCHEMA_NO_URI,
XML_SCHEMAP_NOT_SCHEMA, XML_SCHEMAP_UNKNOWN_MEMBER_TYPE,
XML_SCHEMAP_INVALID_ATTR_USE, XML_SCHEMAP_RECURSIVE,
XML_SCHEMAP_SUPERNUMEROUS_LIST_ITEM_TYPE,
XML_SCHEMAP_INVALID_ATTR_COMBINATION,
XML_SCHEMAP_INVALID_ATTR_INLINE_COMBINATION,
XML_SCHEMAP_MISSING_SIMPLETYPE_CHILD, XML_SCHEMAP_INVALID_ATTR_NAME,
XML_SCHEMAP_REF_AND_CONTENT, XML_SCHEMAP_CT_PROPS_CORRECT_1,
XML_SCHEMAP_CT_PROPS_CORRECT_2, XML_SCHEMAP_CT_PROPS_CORRECT_3,
XML_SCHEMAP_CT_PROPS_CORRECT_4, XML_SCHEMAP_CT_PROPS_CORRECT_5,
XML_SCHEMAP_DERIVATION_OK_RESTRICTION_1,
XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_1,
XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_2,
XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_2,
XML_SCHEMAP_DERIVATION_OK_RESTRICTION_3,
XML_SCHEMAP_WILDCARD_INVALID_NS_MEMBER,
XML_SCHEMAP_INTERSECTION_NOT_EXPRESSIBLE,
XML_SCHEMAP_UNION_NOT_EXPRESSIBLE, XML_SCHEMAP_SRC_IMPORT_3_1,
XML_SCHEMAP_SRC_IMPORT_3_2, XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_1,
XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_2,
XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_3,
XML_SCHEMAP_COS_CT_EXTENDS_1_3, XML_SCHEMAV_NOROOT,
XML_SCHEMAV_UNDECLAREDELEM, XML_SCHEMAV_NOTTOPLEVEL,
XML_SCHEMAV_MISSING, XML_SCHEMAV_WRONGELEM, XML_SCHEMAV_NOTYPE,
XML_SCHEMAV_NOROLLBACK, XML_SCHEMAV_ISABSTRACT, XML_SCHEMAV_NOTEMPTY,
XML_SCHEMAV_ELEMCONT, XML_SCHEMAV_HAVEDEFAULT, XML_SCHEMAV_NOTNILLABLE,
XML_SCHEMAV_EXTRACONTENT, XML_SCHEMAV_INVALIDATTR,
XML_SCHEMAV_INVALIDELEM, XML_SCHEMAV_NOTDETERMINIST,
XML_SCHEMAV_CONSTRUCT, XML_SCHEMAV_INTERNAL, XML_SCHEMAV_NOTSIMPLE,
XML_SCHEMAV_ATTRUNKNOWN, XML_SCHEMAV_ATTRINVALID, XML_SCHEMAV_VALUE,
XML_SCHEMAV_FACET, XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_1,
XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_2,
XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_3, XML_SCHEMAV_CVC_TYPE_3_1_1,
XML_SCHEMAV_CVC_TYPE_3_1_2, XML_SCHEMAV_CVC_FACET_VALID,
XML_SCHEMAV_CVC_LENGTH_VALID, XML_SCHEMAV_CVC_MINLENGTH_VALID,
XML_SCHEMAV_CVC_MAXLENGTH_VALID, XML_SCHEMAV_CVC_MININCLUSIVE_VALID,
XML_SCHEMAV_CVC_MAXINCLUSIVE_VALID, XML_SCHEMAV_CVC_MINEXCLUSIVE_VALID,
XML_SCHEMAV_CVC_MAXEXCLUSIVE_VALID, XML_SCHEMAV_CVC_TOTALDIGITS_VALID,
XML_SCHEMAV_CVC_FRACTIONDIGITS_VALID, XML_SCHEMAV_CVC_PATTERN_VALID,
XML_SCHEMAV_CVC_ENUMERATION_VALID, XML_SCHEMAV_CVC_COMPLEX_TYPE_2_1,
XML_SCHEMAV_CVC_COMPLEX_TYPE_2_2, XML_SCHEMAV_CVC_COMPLEX_TYPE_2_3,
XML_SCHEMAV_CVC_COMPLEX_TYPE_2_4, XML_SCHEMAV_CVC_ELT_1,
XML_SCHEMAV_CVC_ELT_2, XML_SCHEMAV_CVC_ELT_3_1,
XML_SCHEMAV_CVC_ELT_3_2_1, XML_SCHEMAV_CVC_ELT_3_2_2,
XML_SCHEMAV_CVC_ELT_4_1, XML_SCHEMAV_CVC_ELT_4_2,
XML_SCHEMAV_CVC_ELT_4_3, XML_SCHEMAV_CVC_ELT_5_1_1,
XML_SCHEMAV_CVC_ELT_5_1_2, XML_SCHEMAV_CVC_ELT_5_2_1,
XML_SCHEMAV_CVC_ELT_5_2_2_1, XML_SCHEMAV_CVC_ELT_5_2_2_2_1,
XML_SCHEMAV_CVC_ELT_5_2_2_2_2, XML_SCHEMAV_CVC_ELT_6,
XML_SCHEMAV_CVC_ELT_7, XML_SCHEMAV_CVC_ATTRIBUTE_1,
XML_SCHEMAV_CVC_ATTRIBUTE_2, XML_SCHEMAV_CVC_ATTRIBUTE_3,
XML_SCHEMAV_CVC_ATTRIBUTE_4, XML_SCHEMAV_CVC_COMPLEX_TYPE_3_1,
XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_1, XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_2,
XML_SCHEMAV_CVC_COMPLEX_TYPE_4, XML_SCHEMAV_CVC_COMPLEX_TYPE_5_1,
XML_SCHEMAV_CVC_COMPLEX_TYPE_5_2, XML_SCHEMAV_ELEMENT_CONTENT,
XML_SCHEMAV_DOCUMENT_ELEMENT_MISSING, XML_SCHEMAV_CVC_COMPLEX_TYPE_1,
XML_SCHEMAV_CVC_AU, XML_SCHEMAV_CVC_TYPE_1, XML_SCHEMAV_CVC_TYPE_2,
XML_SCHEMAV_CVC_IDC, XML_SCHEMAV_CVC_WILDCARD, XML_SCHEMAV_MISC,
XML_XPTR_UNKNOWN_SCHEME, XML_XPTR_CHILDSEQ_START, XML_XPTR_EVAL_FAILED,
XML_XPTR_EXTRA_OBJECTS, XML_C14N_CREATE_CTXT, XML_C14N_REQUIRES_UTF8,
XML_C14N_CREATE_STACK, XML_C14N_INVALID_NODE, XML_C14N_UNKNOW_NODE,
XML_C14N_RELATIVE_NAMESPACE, XML_FTP_PASV_ANSWER, XML_FTP_EPSV_ANSWER,
XML_FTP_ACCNT, XML_FTP_URL_SYNTAX, XML_HTTP_URL_SYNTAX,
XML_HTTP_USE_IP, XML_HTTP_UNKNOWN_HOST, XML_SCHEMAP_SRC_SIMPLE_TYPE_1,
XML_SCHEMAP_SRC_SIMPLE_TYPE_2, XML_SCHEMAP_SRC_SIMPLE_TYPE_3,
XML_SCHEMAP_SRC_SIMPLE_TYPE_4, XML_SCHEMAP_SRC_RESOLVE,
XML_SCHEMAP_SRC_RESTRICTION_BASE_OR_SIMPLETYPE,
XML_SCHEMAP_SRC_LIST_ITEMTYPE_OR_SIMPLETYPE,
XML_SCHEMAP_SRC_UNION_MEMBERTYPES_OR_SIMPLETYPES,
XML_SCHEMAP_ST_PROPS_CORRECT_1, XML_SCHEMAP_ST_PROPS_CORRECT_2,
XML_SCHEMAP_ST_PROPS_CORRECT_3, XML_SCHEMAP_COS_ST_RESTRICTS_1_1,
XML_SCHEMAP_COS_ST_RESTRICTS_1_2, XML_SCHEMAP_COS_ST_RESTRICTS_1_3_1,
XML_SCHEMAP_COS_ST_RESTRICTS_1_3_2, XML_SCHEMAP_COS_ST_RESTRICTS_2_1,
XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_1,
XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_2,
XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_1,
XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_2,
XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_3,
XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_4,
XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_5, XML_SCHEMAP_COS_ST_RESTRICTS_3_1,
XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1,
XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1_2,
XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_2,
XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_1,
XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_3,
XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_4,
XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_5,
XML_SCHEMAP_COS_ST_DERIVED_OK_2_1, XML_SCHEMAP_COS_ST_DERIVED_OK_2_2,
XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED, XML_SCHEMAP_S4S_ELEM_MISSING,
XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, XML_SCHEMAP_S4S_ATTR_MISSING,
XML_SCHEMAP_S4S_ATTR_INVALID_VALUE, XML_SCHEMAP_SRC_ELEMENT_1,
XML_SCHEMAP_SRC_ELEMENT_2_1, XML_SCHEMAP_SRC_ELEMENT_2_2,
XML_SCHEMAP_SRC_ELEMENT_3, XML_SCHEMAP_P_PROPS_CORRECT_1,
XML_SCHEMAP_P_PROPS_CORRECT_2_1, XML_SCHEMAP_P_PROPS_CORRECT_2_2,
XML_SCHEMAP_E_PROPS_CORRECT_2, XML_SCHEMAP_E_PROPS_CORRECT_3,
XML_SCHEMAP_E_PROPS_CORRECT_4, XML_SCHEMAP_E_PROPS_CORRECT_5,
XML_SCHEMAP_E_PROPS_CORRECT_6, XML_SCHEMAP_SRC_INCLUDE,
XML_SCHEMAP_SRC_ATTRIBUTE_1, XML_SCHEMAP_SRC_ATTRIBUTE_2,
XML_SCHEMAP_SRC_ATTRIBUTE_3_1, XML_SCHEMAP_SRC_ATTRIBUTE_3_2,
XML_SCHEMAP_SRC_ATTRIBUTE_4, XML_SCHEMAP_NO_XMLNS, XML_SCHEMAP_NO_XSI,
XML_SCHEMAP_COS_VALID_DEFAULT_1, XML_SCHEMAP_COS_VALID_DEFAULT_2_1,
XML_SCHEMAP_COS_VALID_DEFAULT_2_2_1,
XML_SCHEMAP_COS_VALID_DEFAULT_2_2_2, XML_SCHEMAP_CVC_SIMPLE_TYPE,
XML_SCHEMAP_COS_CT_EXTENDS_1_1, XML_SCHEMAP_SRC_IMPORT_1_1,
XML_SCHEMAP_SRC_IMPORT_1_2, XML_SCHEMAP_SRC_IMPORT_2,
XML_SCHEMAP_SRC_IMPORT_2_1, XML_SCHEMAP_SRC_IMPORT_2_2,
XML_SCHEMAP_INTERNAL, XML_SCHEMAP_NOT_DETERMINISTIC,
XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_1, XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_2,
XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_3, XML_SCHEMAP_MG_PROPS_CORRECT_1,
XML_SCHEMAP_MG_PROPS_CORRECT_2, XML_SCHEMAP_SRC_CT_1,
XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_3,
XML_SCHEMAP_AU_PROPS_CORRECT_2, XML_SCHEMAP_A_PROPS_CORRECT_2,
XML_SCHEMAP_C_PROPS_CORRECT, XML_SCHEMAP_SRC_REDEFINE,
XML_SCHEMAP_SRC_IMPORT, XML_SCHEMAP_WARN_SKIP_SCHEMA,
XML_SCHEMAP_WARN_UNLOCATED_SCHEMA, XML_SCHEMAP_WARN_ATTR_REDECL_PROH,
XML_SCHEMAP_WARN_ATTR_POINTLESS_PROH, XML_SCHEMAP_AG_PROPS_CORRECT,
XML_SCHEMAP_COS_CT_EXTENDS_1_2, XML_SCHEMAP_AU_PROPS_CORRECT,
XML_SCHEMAP_A_PROPS_CORRECT_3, XML_SCHEMAP_COS_ALL_LIMITED,
XML_SCHEMATRONV_ASSERT, XML_SCHEMATRONV_REPORT, XML_MODULE_OPEN,
XML_MODULE_CLOSE, XML_CHECK_FOUND_ELEMENT, XML_CHECK_FOUND_ATTRIBUTE,
XML_CHECK_FOUND_TEXT, XML_CHECK_FOUND_CDATA, XML_CHECK_FOUND_ENTITYREF,
XML_CHECK_FOUND_ENTITY, XML_CHECK_FOUND_PI, XML_CHECK_FOUND_COMMENT,
XML_CHECK_FOUND_DOCTYPE, XML_CHECK_FOUND_FRAGMENT,
XML_CHECK_FOUND_NOTATION, XML_CHECK_UNKNOWN_NODE,
XML_CHECK_ENTITY_TYPE, XML_CHECK_NO_PARENT, XML_CHECK_NO_DOC,
XML_CHECK_NO_NAME, XML_CHECK_NO_ELEM, XML_CHECK_WRONG_DOC,
XML_CHECK_NO_PREV, XML_CHECK_WRONG_PREV, XML_CHECK_NO_NEXT,
XML_CHECK_WRONG_NEXT, XML_CHECK_NOT_DTD, XML_CHECK_NOT_ATTR,
XML_CHECK_NOT_ATTR_DECL, XML_CHECK_NOT_ELEM_DECL,
XML_CHECK_NOT_ENTITY_DECL, XML_CHECK_NOT_NS_DECL, XML_CHECK_NO_HREF,
XML_CHECK_WRONG_PARENT, XML_CHECK_NS_SCOPE, XML_CHECK_NS_ANCESTOR,
XML_CHECK_NOT_UTF8, XML_CHECK_NO_DICT, XML_CHECK_NOT_NCNAME,
XML_CHECK_OUTSIDE_DICT, XML_CHECK_WRONG_NAME, XML_CHECK_NAME_NOT_NULL,
XML_I18N_NO_NAME, XML_I18N_NO_HANDLER, XML_I18N_EXCESS_HANDLER,
XML_I18N_CONV_FAILED, XML_I18N_NO_OUTPUT, XML_BUF_OVERFLOW);
for enum_e5ead1e1 use (XML_ERR_OK => 0, XML_ERR_INTERNAL_ERROR => 1,
XML_ERR_NO_MEMORY => 2, XML_ERR_DOCUMENT_START => 3,
XML_ERR_DOCUMENT_EMPTY => 4, XML_ERR_DOCUMENT_END => 5,
XML_ERR_INVALID_HEX_CHARREF => 6, XML_ERR_INVALID_DEC_CHARREF => 7,
XML_ERR_INVALID_CHARREF => 8, XML_ERR_INVALID_CHAR => 9,
XML_ERR_CHARREF_AT_EOF => 10, XML_ERR_CHARREF_IN_PROLOG => 11,
XML_ERR_CHARREF_IN_EPILOG => 12, XML_ERR_CHARREF_IN_DTD => 13,
XML_ERR_ENTITYREF_AT_EOF => 14, XML_ERR_ENTITYREF_IN_PROLOG => 15,
XML_ERR_ENTITYREF_IN_EPILOG => 16, XML_ERR_ENTITYREF_IN_DTD => 17,
XML_ERR_PEREF_AT_EOF => 18, XML_ERR_PEREF_IN_PROLOG => 19,
XML_ERR_PEREF_IN_EPILOG => 20, XML_ERR_PEREF_IN_INT_SUBSET => 21,
XML_ERR_ENTITYREF_NO_NAME => 22,
XML_ERR_ENTITYREF_SEMICOL_MISSING => 23, XML_ERR_PEREF_NO_NAME => 24,
XML_ERR_PEREF_SEMICOL_MISSING => 25, XML_ERR_UNDECLARED_ENTITY => 26,
XML_WAR_UNDECLARED_ENTITY => 27, XML_ERR_UNPARSED_ENTITY => 28,
XML_ERR_ENTITY_IS_EXTERNAL => 29, XML_ERR_ENTITY_IS_PARAMETER => 30,
XML_ERR_UNKNOWN_ENCODING => 31, XML_ERR_UNSUPPORTED_ENCODING => 32,
XML_ERR_STRING_NOT_STARTED => 33, XML_ERR_STRING_NOT_CLOSED => 34,
XML_ERR_NS_DECL_ERROR => 35, XML_ERR_ENTITY_NOT_STARTED => 36,
XML_ERR_ENTITY_NOT_FINISHED => 37, XML_ERR_LT_IN_ATTRIBUTE => 38,
XML_ERR_ATTRIBUTE_NOT_STARTED => 39,
XML_ERR_ATTRIBUTE_NOT_FINISHED => 40,
XML_ERR_ATTRIBUTE_WITHOUT_VALUE => 41,
XML_ERR_ATTRIBUTE_REDEFINED => 42, XML_ERR_LITERAL_NOT_STARTED => 43,
XML_ERR_LITERAL_NOT_FINISHED => 44, XML_ERR_COMMENT_NOT_FINISHED => 45,
XML_ERR_PI_NOT_STARTED => 46, XML_ERR_PI_NOT_FINISHED => 47,
XML_ERR_NOTATION_NOT_STARTED => 48,
XML_ERR_NOTATION_NOT_FINISHED => 49, XML_ERR_ATTLIST_NOT_STARTED => 50,
XML_ERR_ATTLIST_NOT_FINISHED => 51, XML_ERR_MIXED_NOT_STARTED => 52,
XML_ERR_MIXED_NOT_FINISHED => 53,
XML_ERR_ELEMCONTENT_NOT_STARTED => 54,
XML_ERR_ELEMCONTENT_NOT_FINISHED => 55,
XML_ERR_XMLDECL_NOT_STARTED => 56, XML_ERR_XMLDECL_NOT_FINISHED => 57,
XML_ERR_CONDSEC_NOT_STARTED => 58, XML_ERR_CONDSEC_NOT_FINISHED => 59,
XML_ERR_EXT_SUBSET_NOT_FINISHED => 60,
XML_ERR_DOCTYPE_NOT_FINISHED => 61, XML_ERR_MISPLACED_CDATA_END => 62,
XML_ERR_CDATA_NOT_FINISHED => 63, XML_ERR_RESERVED_XML_NAME => 64,
XML_ERR_SPACE_REQUIRED => 65, XML_ERR_SEPARATOR_REQUIRED => 66,
XML_ERR_NMTOKEN_REQUIRED => 67, XML_ERR_NAME_REQUIRED => 68,
XML_ERR_PCDATA_REQUIRED => 69, XML_ERR_URI_REQUIRED => 70,
XML_ERR_PUBID_REQUIRED => 71, XML_ERR_LT_REQUIRED => 72,
XML_ERR_GT_REQUIRED => 73, XML_ERR_LTSLASH_REQUIRED => 74,
XML_ERR_EQUAL_REQUIRED => 75, XML_ERR_TAG_NAME_MISMATCH => 76,
XML_ERR_TAG_NOT_FINISHED => 77, XML_ERR_STANDALONE_VALUE => 78,
XML_ERR_ENCODING_NAME => 79, XML_ERR_HYPHEN_IN_COMMENT => 80,
XML_ERR_INVALID_ENCODING => 81, XML_ERR_EXT_ENTITY_STANDALONE => 82,
XML_ERR_CONDSEC_INVALID => 83, XML_ERR_VALUE_REQUIRED => 84,
XML_ERR_NOT_WELL_BALANCED => 85, XML_ERR_EXTRA_CONTENT => 86,
XML_ERR_ENTITY_CHAR_ERROR => 87, XML_ERR_ENTITY_PE_INTERNAL => 88,
XML_ERR_ENTITY_LOOP => 89, XML_ERR_ENTITY_BOUNDARY => 90,
XML_ERR_INVALID_URI => 91, XML_ERR_URI_FRAGMENT => 92,
XML_WAR_CATALOG_PI => 93, XML_ERR_NO_DTD => 94,
XML_ERR_CONDSEC_INVALID_KEYWORD => 95, XML_ERR_VERSION_MISSING => 96,
XML_WAR_UNKNOWN_VERSION => 97, XML_WAR_LANG_VALUE => 98,
XML_WAR_NS_URI => 99, XML_WAR_NS_URI_RELATIVE => 100,
XML_ERR_MISSING_ENCODING => 101, XML_WAR_SPACE_VALUE => 102,
XML_ERR_NOT_STANDALONE => 103, XML_ERR_ENTITY_PROCESSING => 104,
XML_ERR_NOTATION_PROCESSING => 105, XML_WAR_NS_COLUMN => 106,
XML_WAR_ENTITY_REDEFINED => 107, XML_ERR_UNKNOWN_VERSION => 108,
XML_ERR_VERSION_MISMATCH => 109, XML_ERR_NAME_TOO_LONG => 110,
XML_ERR_USER_STOP => 111, XML_NS_ERR_XML_NAMESPACE => 200,
XML_NS_ERR_UNDEFINED_NAMESPACE => 201, XML_NS_ERR_QNAME => 202,
XML_NS_ERR_ATTRIBUTE_REDEFINED => 203, XML_NS_ERR_EMPTY => 204,
XML_NS_ERR_COLON => 205, XML_DTD_ATTRIBUTE_DEFAULT => 500,
XML_DTD_ATTRIBUTE_REDEFINED => 501, XML_DTD_ATTRIBUTE_VALUE => 502,
XML_DTD_CONTENT_ERROR => 503, XML_DTD_CONTENT_MODEL => 504,
XML_DTD_CONTENT_NOT_DETERMINIST => 505,
XML_DTD_DIFFERENT_PREFIX => 506, XML_DTD_ELEM_DEFAULT_NAMESPACE => 507,
XML_DTD_ELEM_NAMESPACE => 508, XML_DTD_ELEM_REDEFINED => 509,
XML_DTD_EMPTY_NOTATION => 510, XML_DTD_ENTITY_TYPE => 511,
XML_DTD_ID_FIXED => 512, XML_DTD_ID_REDEFINED => 513,
XML_DTD_ID_SUBSET => 514, XML_DTD_INVALID_CHILD => 515,
XML_DTD_INVALID_DEFAULT => 516, XML_DTD_LOAD_ERROR => 517,
XML_DTD_MISSING_ATTRIBUTE => 518, XML_DTD_MIXED_CORRUPT => 519,
XML_DTD_MULTIPLE_ID => 520, XML_DTD_NO_DOC => 521,
XML_DTD_NO_DTD => 522, XML_DTD_NO_ELEM_NAME => 523,
XML_DTD_NO_PREFIX => 524, XML_DTD_NO_ROOT => 525,
XML_DTD_NOTATION_REDEFINED => 526, XML_DTD_NOTATION_VALUE => 527,
XML_DTD_NOT_EMPTY => 528, XML_DTD_NOT_PCDATA => 529,
XML_DTD_NOT_STANDALONE => 530, XML_DTD_ROOT_NAME => 531,
XML_DTD_STANDALONE_WHITE_SPACE => 532,
XML_DTD_UNKNOWN_ATTRIBUTE => 533, XML_DTD_UNKNOWN_ELEM => 534,
XML_DTD_UNKNOWN_ENTITY => 535, XML_DTD_UNKNOWN_ID => 536,
XML_DTD_UNKNOWN_NOTATION => 537, XML_DTD_STANDALONE_DEFAULTED => 538,
XML_DTD_XMLID_VALUE => 539, XML_DTD_XMLID_TYPE => 540,
XML_DTD_DUP_TOKEN => 541, XML_HTML_STRUCURE_ERROR => 800,
XML_HTML_UNKNOWN_TAG => 801, XML_RNGP_ANYNAME_ATTR_ANCESTOR => 1000,
XML_RNGP_ATTR_CONFLICT => 1001, XML_RNGP_ATTRIBUTE_CHILDREN => 1002,
XML_RNGP_ATTRIBUTE_CONTENT => 1003, XML_RNGP_ATTRIBUTE_EMPTY => 1004,
XML_RNGP_ATTRIBUTE_NOOP => 1005, XML_RNGP_CHOICE_CONTENT => 1006,
XML_RNGP_CHOICE_EMPTY => 1007, XML_RNGP_CREATE_FAILURE => 1008,
XML_RNGP_DATA_CONTENT => 1009,
XML_RNGP_DEF_CHOICE_AND_INTERLEAVE => 1010,
XML_RNGP_DEFINE_CREATE_FAILED => 1011, XML_RNGP_DEFINE_EMPTY => 1012,
XML_RNGP_DEFINE_MISSING => 1013, XML_RNGP_DEFINE_NAME_MISSING => 1014,
XML_RNGP_ELEM_CONTENT_EMPTY => 1015,
XML_RNGP_ELEM_CONTENT_ERROR => 1016, XML_RNGP_ELEMENT_EMPTY => 1017,
XML_RNGP_ELEMENT_CONTENT => 1018, XML_RNGP_ELEMENT_NAME => 1019,
XML_RNGP_ELEMENT_NO_CONTENT => 1020,
XML_RNGP_ELEM_TEXT_CONFLICT => 1021, XML_RNGP_EMPTY => 1022,
XML_RNGP_EMPTY_CONSTRUCT => 1023, XML_RNGP_EMPTY_CONTENT => 1024,
XML_RNGP_EMPTY_NOT_EMPTY => 1025, XML_RNGP_ERROR_TYPE_LIB => 1026,
XML_RNGP_EXCEPT_EMPTY => 1027, XML_RNGP_EXCEPT_MISSING => 1028,
XML_RNGP_EXCEPT_MULTIPLE => 1029, XML_RNGP_EXCEPT_NO_CONTENT => 1030,
XML_RNGP_EXTERNALREF_EMTPY => 1031,
XML_RNGP_EXTERNAL_REF_FAILURE => 1032,
XML_RNGP_EXTERNALREF_RECURSE => 1033,
XML_RNGP_FORBIDDEN_ATTRIBUTE => 1034, XML_RNGP_FOREIGN_ELEMENT => 1035,
XML_RNGP_GRAMMAR_CONTENT => 1036, XML_RNGP_GRAMMAR_EMPTY => 1037,
XML_RNGP_GRAMMAR_MISSING => 1038, XML_RNGP_GRAMMAR_NO_START => 1039,
XML_RNGP_GROUP_ATTR_CONFLICT => 1040, XML_RNGP_HREF_ERROR => 1041,
XML_RNGP_INCLUDE_EMPTY => 1042, XML_RNGP_INCLUDE_FAILURE => 1043,
XML_RNGP_INCLUDE_RECURSE => 1044, XML_RNGP_INTERLEAVE_ADD => 1045,
XML_RNGP_INTERLEAVE_CREATE_FAILED => 1046,
XML_RNGP_INTERLEAVE_EMPTY => 1047,
XML_RNGP_INTERLEAVE_NO_CONTENT => 1048,
XML_RNGP_INVALID_DEFINE_NAME => 1049, XML_RNGP_INVALID_URI => 1050,
XML_RNGP_INVALID_VALUE => 1051, XML_RNGP_MISSING_HREF => 1052,
XML_RNGP_NAME_MISSING => 1053, XML_RNGP_NEED_COMBINE => 1054,
XML_RNGP_NOTALLOWED_NOT_EMPTY => 1055,
XML_RNGP_NSNAME_ATTR_ANCESTOR => 1056, XML_RNGP_NSNAME_NO_NS => 1057,
XML_RNGP_PARAM_FORBIDDEN => 1058, XML_RNGP_PARAM_NAME_MISSING => 1059,
XML_RNGP_PARENTREF_CREATE_FAILED => 1060,
XML_RNGP_PARENTREF_NAME_INVALID => 1061,
XML_RNGP_PARENTREF_NO_NAME => 1062,
XML_RNGP_PARENTREF_NO_PARENT => 1063,
XML_RNGP_PARENTREF_NOT_EMPTY => 1064, XML_RNGP_PARSE_ERROR => 1065,
XML_RNGP_PAT_ANYNAME_EXCEPT_ANYNAME => 1066,
XML_RNGP_PAT_ATTR_ATTR => 1067, XML_RNGP_PAT_ATTR_ELEM => 1068,
XML_RNGP_PAT_DATA_EXCEPT_ATTR => 1069,
XML_RNGP_PAT_DATA_EXCEPT_ELEM => 1070,
XML_RNGP_PAT_DATA_EXCEPT_EMPTY => 1071,
XML_RNGP_PAT_DATA_EXCEPT_GROUP => 1072,
XML_RNGP_PAT_DATA_EXCEPT_INTERLEAVE => 1073,
XML_RNGP_PAT_DATA_EXCEPT_LIST => 1074,
XML_RNGP_PAT_DATA_EXCEPT_ONEMORE => 1075,
XML_RNGP_PAT_DATA_EXCEPT_REF => 1076,
XML_RNGP_PAT_DATA_EXCEPT_TEXT => 1077, XML_RNGP_PAT_LIST_ATTR => 1078,
XML_RNGP_PAT_LIST_ELEM => 1079, XML_RNGP_PAT_LIST_INTERLEAVE => 1080,
XML_RNGP_PAT_LIST_LIST => 1081, XML_RNGP_PAT_LIST_REF => 1082,
XML_RNGP_PAT_LIST_TEXT => 1083,
XML_RNGP_PAT_NSNAME_EXCEPT_ANYNAME => 1084,
XML_RNGP_PAT_NSNAME_EXCEPT_NSNAME => 1085,
XML_RNGP_PAT_ONEMORE_GROUP_ATTR => 1086,
XML_RNGP_PAT_ONEMORE_INTERLEAVE_ATTR => 1087,
XML_RNGP_PAT_START_ATTR => 1088, XML_RNGP_PAT_START_DATA => 1089,
XML_RNGP_PAT_START_EMPTY => 1090, XML_RNGP_PAT_START_GROUP => 1091,
XML_RNGP_PAT_START_INTERLEAVE => 1092, XML_RNGP_PAT_START_LIST => 1093,
XML_RNGP_PAT_START_ONEMORE => 1094, XML_RNGP_PAT_START_TEXT => 1095,
XML_RNGP_PAT_START_VALUE => 1096, XML_RNGP_PREFIX_UNDEFINED => 1097,
XML_RNGP_REF_CREATE_FAILED => 1098, XML_RNGP_REF_CYCLE => 1099,
XML_RNGP_REF_NAME_INVALID => 1100, XML_RNGP_REF_NO_DEF => 1101,
XML_RNGP_REF_NO_NAME => 1102, XML_RNGP_REF_NOT_EMPTY => 1103,
XML_RNGP_START_CHOICE_AND_INTERLEAVE => 1104,
XML_RNGP_START_CONTENT => 1105, XML_RNGP_START_EMPTY => 1106,
XML_RNGP_START_MISSING => 1107, XML_RNGP_TEXT_EXPECTED => 1108,
XML_RNGP_TEXT_HAS_CHILD => 1109, XML_RNGP_TYPE_MISSING => 1110,
XML_RNGP_TYPE_NOT_FOUND => 1111, XML_RNGP_TYPE_VALUE => 1112,
XML_RNGP_UNKNOWN_ATTRIBUTE => 1113, XML_RNGP_UNKNOWN_COMBINE => 1114,
XML_RNGP_UNKNOWN_CONSTRUCT => 1115, XML_RNGP_UNKNOWN_TYPE_LIB => 1116,
XML_RNGP_URI_FRAGMENT => 1117, XML_RNGP_URI_NOT_ABSOLUTE => 1118,
XML_RNGP_VALUE_EMPTY => 1119, XML_RNGP_VALUE_NO_CONTENT => 1120,
XML_RNGP_XMLNS_NAME => 1121, XML_RNGP_XML_NS => 1122,
XML_XPATH_EXPRESSION_OK => 1200, XML_XPATH_NUMBER_ERROR => 1201,
XML_XPATH_UNFINISHED_LITERAL_ERROR => 1202,
XML_XPATH_START_LITERAL_ERROR => 1203,
XML_XPATH_VARIABLE_REF_ERROR => 1204,
XML_XPATH_UNDEF_VARIABLE_ERROR => 1205,
XML_XPATH_INVALID_PREDICATE_ERROR => 1206,
XML_XPATH_EXPR_ERROR => 1207, XML_XPATH_UNCLOSED_ERROR => 1208,
XML_XPATH_UNKNOWN_FUNC_ERROR => 1209,
XML_XPATH_INVALID_OPERAND => 1210, XML_XPATH_INVALID_TYPE => 1211,
XML_XPATH_INVALID_ARITY => 1212, XML_XPATH_INVALID_CTXT_SIZE => 1213,
XML_XPATH_INVALID_CTXT_POSITION => 1214,
XML_XPATH_MEMORY_ERROR => 1215, XML_XPTR_SYNTAX_ERROR => 1216,
XML_XPTR_RESOURCE_ERROR => 1217, XML_XPTR_SUB_RESOURCE_ERROR => 1218,
XML_XPATH_UNDEF_PREFIX_ERROR => 1219, XML_XPATH_ENCODING_ERROR => 1220,
XML_XPATH_INVALID_CHAR_ERROR => 1221, XML_TREE_INVALID_HEX => 1300,
XML_TREE_INVALID_DEC => 1301, XML_TREE_UNTERMINATED_ENTITY => 1302,
XML_TREE_NOT_UTF8 => 1303, XML_SAVE_NOT_UTF8 => 1400,
XML_SAVE_CHAR_INVALID => 1401, XML_SAVE_NO_DOCTYPE => 1402,
XML_SAVE_UNKNOWN_ENCODING => 1403, XML_REGEXP_COMPILE_ERROR => 1450,
XML_IO_UNKNOWN => 1500, XML_IO_EACCES => 1501, XML_IO_EAGAIN => 1502,
XML_IO_EBADF => 1503, XML_IO_EBADMSG => 1504, XML_IO_EBUSY => 1505,
XML_IO_ECANCELED => 1506, XML_IO_ECHILD => 1507,
XML_IO_EDEADLK => 1508, XML_IO_EDOM => 1509, XML_IO_EEXIST => 1510,
XML_IO_EFAULT => 1511, XML_IO_EFBIG => 1512,
XML_IO_EINPROGRESS => 1513, XML_IO_EINTR => 1514,
XML_IO_EINVAL => 1515, XML_IO_EIO => 1516, XML_IO_EISDIR => 1517,
XML_IO_EMFILE => 1518, XML_IO_EMLINK => 1519, XML_IO_EMSGSIZE => 1520,
XML_IO_ENAMETOOLONG => 1521, XML_IO_ENFILE => 1522,
XML_IO_ENODEV => 1523, XML_IO_ENOENT => 1524, XML_IO_ENOEXEC => 1525,
XML_IO_ENOLCK => 1526, XML_IO_ENOMEM => 1527, XML_IO_ENOSPC => 1528,
XML_IO_ENOSYS => 1529, XML_IO_ENOTDIR => 1530,
XML_IO_ENOTEMPTY => 1531, XML_IO_ENOTSUP => 1532,
XML_IO_ENOTTY => 1533, XML_IO_ENXIO => 1534, XML_IO_EPERM => 1535,
XML_IO_EPIPE => 1536, XML_IO_ERANGE => 1537, XML_IO_EROFS => 1538,
XML_IO_ESPIPE => 1539, XML_IO_ESRCH => 1540, XML_IO_ETIMEDOUT => 1541,
XML_IO_EXDEV => 1542, XML_IO_NETWORK_ATTEMPT => 1543,
XML_IO_ENCODER => 1544, XML_IO_FLUSH => 1545, XML_IO_WRITE => 1546,
XML_IO_NO_INPUT => 1547, XML_IO_BUFFER_FULL => 1548,
XML_IO_LOAD_ERROR => 1549, XML_IO_ENOTSOCK => 1550,
XML_IO_EISCONN => 1551, XML_IO_ECONNREFUSED => 1552,
XML_IO_ENETUNREACH => 1553, XML_IO_EADDRINUSE => 1554,
XML_IO_EALREADY => 1555, XML_IO_EAFNOSUPPORT => 1556,
XML_XINCLUDE_RECURSION => 1600, XML_XINCLUDE_PARSE_VALUE => 1601,
XML_XINCLUDE_ENTITY_DEF_MISMATCH => 1602, XML_XINCLUDE_NO_HREF => 1603,
XML_XINCLUDE_NO_FALLBACK => 1604, XML_XINCLUDE_HREF_URI => 1605,
XML_XINCLUDE_TEXT_FRAGMENT => 1606, XML_XINCLUDE_TEXT_DOCUMENT => 1607,
XML_XINCLUDE_INVALID_CHAR => 1608, XML_XINCLUDE_BUILD_FAILED => 1609,
XML_XINCLUDE_UNKNOWN_ENCODING => 1610,
XML_XINCLUDE_MULTIPLE_ROOT => 1611, XML_XINCLUDE_XPTR_FAILED => 1612,
XML_XINCLUDE_XPTR_RESULT => 1613,
XML_XINCLUDE_INCLUDE_IN_INCLUDE => 1614,
XML_XINCLUDE_FALLBACKS_IN_INCLUDE => 1615,
XML_XINCLUDE_FALLBACK_NOT_IN_INCLUDE => 1616,
XML_XINCLUDE_DEPRECATED_NS => 1617, XML_XINCLUDE_FRAGMENT_ID => 1618,
XML_CATALOG_MISSING_ATTR => 1650, XML_CATALOG_ENTRY_BROKEN => 1651,
XML_CATALOG_PREFER_VALUE => 1652, XML_CATALOG_NOT_CATALOG => 1653,
XML_CATALOG_RECURSION => 1654, XML_SCHEMAP_PREFIX_UNDEFINED => 1700,
XML_SCHEMAP_ATTRFORMDEFAULT_VALUE => 1701,
XML_SCHEMAP_ATTRGRP_NONAME_NOREF => 1702,
XML_SCHEMAP_ATTR_NONAME_NOREF => 1703,
XML_SCHEMAP_COMPLEXTYPE_NONAME_NOREF => 1704,
XML_SCHEMAP_ELEMFORMDEFAULT_VALUE => 1705,
XML_SCHEMAP_ELEM_NONAME_NOREF => 1706,
XML_SCHEMAP_EXTENSION_NO_BASE => 1707,
XML_SCHEMAP_FACET_NO_VALUE => 1708,
XML_SCHEMAP_FAILED_BUILD_IMPORT => 1709,
XML_SCHEMAP_GROUP_NONAME_NOREF => 1710,
XML_SCHEMAP_IMPORT_NAMESPACE_NOT_URI => 1711,
XML_SCHEMAP_IMPORT_REDEFINE_NSNAME => 1712,
XML_SCHEMAP_IMPORT_SCHEMA_NOT_URI => 1713,
XML_SCHEMAP_INVALID_BOOLEAN => 1714, XML_SCHEMAP_INVALID_ENUM => 1715,
XML_SCHEMAP_INVALID_FACET => 1716,
XML_SCHEMAP_INVALID_FACET_VALUE => 1717,
XML_SCHEMAP_INVALID_MAXOCCURS => 1718,
XML_SCHEMAP_INVALID_MINOCCURS => 1719,
XML_SCHEMAP_INVALID_REF_AND_SUBTYPE => 1720,
XML_SCHEMAP_INVALID_WHITE_SPACE => 1721,
XML_SCHEMAP_NOATTR_NOREF => 1722, XML_SCHEMAP_NOTATION_NO_NAME => 1723,
XML_SCHEMAP_NOTYPE_NOREF => 1724, XML_SCHEMAP_REF_AND_SUBTYPE => 1725,
XML_SCHEMAP_RESTRICTION_NONAME_NOREF => 1726,
XML_SCHEMAP_SIMPLETYPE_NONAME => 1727,
XML_SCHEMAP_TYPE_AND_SUBTYPE => 1728,
XML_SCHEMAP_UNKNOWN_ALL_CHILD => 1729,
XML_SCHEMAP_UNKNOWN_ANYATTRIBUTE_CHILD => 1730,
XML_SCHEMAP_UNKNOWN_ATTR_CHILD => 1731,
XML_SCHEMAP_UNKNOWN_ATTRGRP_CHILD => 1732,
XML_SCHEMAP_UNKNOWN_ATTRIBUTE_GROUP => 1733,
XML_SCHEMAP_UNKNOWN_BASE_TYPE => 1734,
XML_SCHEMAP_UNKNOWN_CHOICE_CHILD => 1735,
XML_SCHEMAP_UNKNOWN_COMPLEXCONTENT_CHILD => 1736,
XML_SCHEMAP_UNKNOWN_COMPLEXTYPE_CHILD => 1737,
XML_SCHEMAP_UNKNOWN_ELEM_CHILD => 1738,
XML_SCHEMAP_UNKNOWN_EXTENSION_CHILD => 1739,
XML_SCHEMAP_UNKNOWN_FACET_CHILD => 1740,
XML_SCHEMAP_UNKNOWN_FACET_TYPE => 1741,
XML_SCHEMAP_UNKNOWN_GROUP_CHILD => 1742,
XML_SCHEMAP_UNKNOWN_IMPORT_CHILD => 1743,
XML_SCHEMAP_UNKNOWN_LIST_CHILD => 1744,
XML_SCHEMAP_UNKNOWN_NOTATION_CHILD => 1745,
XML_SCHEMAP_UNKNOWN_PROCESSCONTENT_CHILD => 1746,
XML_SCHEMAP_UNKNOWN_REF => 1747,
XML_SCHEMAP_UNKNOWN_RESTRICTION_CHILD => 1748,
XML_SCHEMAP_UNKNOWN_SCHEMAS_CHILD => 1749,
XML_SCHEMAP_UNKNOWN_SEQUENCE_CHILD => 1750,
XML_SCHEMAP_UNKNOWN_SIMPLECONTENT_CHILD => 1751,
XML_SCHEMAP_UNKNOWN_SIMPLETYPE_CHILD => 1752,
XML_SCHEMAP_UNKNOWN_TYPE => 1753,
XML_SCHEMAP_UNKNOWN_UNION_CHILD => 1754,
XML_SCHEMAP_ELEM_DEFAULT_FIXED => 1755,
XML_SCHEMAP_REGEXP_INVALID => 1756, XML_SCHEMAP_FAILED_LOAD => 1757,
XML_SCHEMAP_NOTHING_TO_PARSE => 1758, XML_SCHEMAP_NOROOT => 1759,
XML_SCHEMAP_REDEFINED_GROUP => 1760,
XML_SCHEMAP_REDEFINED_TYPE => 1761,
XML_SCHEMAP_REDEFINED_ELEMENT => 1762,
XML_SCHEMAP_REDEFINED_ATTRGROUP => 1763,
XML_SCHEMAP_REDEFINED_ATTR => 1764,
XML_SCHEMAP_REDEFINED_NOTATION => 1765,
XML_SCHEMAP_FAILED_PARSE => 1766, XML_SCHEMAP_UNKNOWN_PREFIX => 1767,
XML_SCHEMAP_DEF_AND_PREFIX => 1768,
XML_SCHEMAP_UNKNOWN_INCLUDE_CHILD => 1769,
XML_SCHEMAP_INCLUDE_SCHEMA_NOT_URI => 1770,
XML_SCHEMAP_INCLUDE_SCHEMA_NO_URI => 1771,
XML_SCHEMAP_NOT_SCHEMA => 1772,
XML_SCHEMAP_UNKNOWN_MEMBER_TYPE => 1773,
XML_SCHEMAP_INVALID_ATTR_USE => 1774, XML_SCHEMAP_RECURSIVE => 1775,
XML_SCHEMAP_SUPERNUMEROUS_LIST_ITEM_TYPE => 1776,
XML_SCHEMAP_INVALID_ATTR_COMBINATION => 1777,
XML_SCHEMAP_INVALID_ATTR_INLINE_COMBINATION => 1778,
XML_SCHEMAP_MISSING_SIMPLETYPE_CHILD => 1779,
XML_SCHEMAP_INVALID_ATTR_NAME => 1780,
XML_SCHEMAP_REF_AND_CONTENT => 1781,
XML_SCHEMAP_CT_PROPS_CORRECT_1 => 1782,
XML_SCHEMAP_CT_PROPS_CORRECT_2 => 1783,
XML_SCHEMAP_CT_PROPS_CORRECT_3 => 1784,
XML_SCHEMAP_CT_PROPS_CORRECT_4 => 1785,
XML_SCHEMAP_CT_PROPS_CORRECT_5 => 1786,
XML_SCHEMAP_DERIVATION_OK_RESTRICTION_1 => 1787,
XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_1 => 1788,
XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_2 => 1789,
XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_2 => 1790,
XML_SCHEMAP_DERIVATION_OK_RESTRICTION_3 => 1791,
XML_SCHEMAP_WILDCARD_INVALID_NS_MEMBER => 1792,
XML_SCHEMAP_INTERSECTION_NOT_EXPRESSIBLE => 1793,
XML_SCHEMAP_UNION_NOT_EXPRESSIBLE => 1794,
XML_SCHEMAP_SRC_IMPORT_3_1 => 1795, XML_SCHEMAP_SRC_IMPORT_3_2 => 1796,
XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_1 => 1797,
XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_2 => 1798,
XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_3 => 1799,
XML_SCHEMAP_COS_CT_EXTENDS_1_3 => 1800, XML_SCHEMAV_NOROOT => 1801,
XML_SCHEMAV_UNDECLAREDELEM => 1802, XML_SCHEMAV_NOTTOPLEVEL => 1803,
XML_SCHEMAV_MISSING => 1804, XML_SCHEMAV_WRONGELEM => 1805,
XML_SCHEMAV_NOTYPE => 1806, XML_SCHEMAV_NOROLLBACK => 1807,
XML_SCHEMAV_ISABSTRACT => 1808, XML_SCHEMAV_NOTEMPTY => 1809,
XML_SCHEMAV_ELEMCONT => 1810, XML_SCHEMAV_HAVEDEFAULT => 1811,
XML_SCHEMAV_NOTNILLABLE => 1812, XML_SCHEMAV_EXTRACONTENT => 1813,
XML_SCHEMAV_INVALIDATTR => 1814, XML_SCHEMAV_INVALIDELEM => 1815,
XML_SCHEMAV_NOTDETERMINIST => 1816, XML_SCHEMAV_CONSTRUCT => 1817,
XML_SCHEMAV_INTERNAL => 1818, XML_SCHEMAV_NOTSIMPLE => 1819,
XML_SCHEMAV_ATTRUNKNOWN => 1820, XML_SCHEMAV_ATTRINVALID => 1821,
XML_SCHEMAV_VALUE => 1822, XML_SCHEMAV_FACET => 1823,
XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_1 => 1824,
XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_2 => 1825,
XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_3 => 1826,
XML_SCHEMAV_CVC_TYPE_3_1_1 => 1827, XML_SCHEMAV_CVC_TYPE_3_1_2 => 1828,
XML_SCHEMAV_CVC_FACET_VALID => 1829,
XML_SCHEMAV_CVC_LENGTH_VALID => 1830,
XML_SCHEMAV_CVC_MINLENGTH_VALID => 1831,
XML_SCHEMAV_CVC_MAXLENGTH_VALID => 1832,
XML_SCHEMAV_CVC_MININCLUSIVE_VALID => 1833,
XML_SCHEMAV_CVC_MAXINCLUSIVE_VALID => 1834,
XML_SCHEMAV_CVC_MINEXCLUSIVE_VALID => 1835,
XML_SCHEMAV_CVC_MAXEXCLUSIVE_VALID => 1836,
XML_SCHEMAV_CVC_TOTALDIGITS_VALID => 1837,
XML_SCHEMAV_CVC_FRACTIONDIGITS_VALID => 1838,
XML_SCHEMAV_CVC_PATTERN_VALID => 1839,
XML_SCHEMAV_CVC_ENUMERATION_VALID => 1840,
XML_SCHEMAV_CVC_COMPLEX_TYPE_2_1 => 1841,
XML_SCHEMAV_CVC_COMPLEX_TYPE_2_2 => 1842,
XML_SCHEMAV_CVC_COMPLEX_TYPE_2_3 => 1843,
XML_SCHEMAV_CVC_COMPLEX_TYPE_2_4 => 1844,
XML_SCHEMAV_CVC_ELT_1 => 1845, XML_SCHEMAV_CVC_ELT_2 => 1846,
XML_SCHEMAV_CVC_ELT_3_1 => 1847, XML_SCHEMAV_CVC_ELT_3_2_1 => 1848,
XML_SCHEMAV_CVC_ELT_3_2_2 => 1849, XML_SCHEMAV_CVC_ELT_4_1 => 1850,
XML_SCHEMAV_CVC_ELT_4_2 => 1851, XML_SCHEMAV_CVC_ELT_4_3 => 1852,
XML_SCHEMAV_CVC_ELT_5_1_1 => 1853, XML_SCHEMAV_CVC_ELT_5_1_2 => 1854,
XML_SCHEMAV_CVC_ELT_5_2_1 => 1855, XML_SCHEMAV_CVC_ELT_5_2_2_1 => 1856,
XML_SCHEMAV_CVC_ELT_5_2_2_2_1 => 1857,
XML_SCHEMAV_CVC_ELT_5_2_2_2_2 => 1858, XML_SCHEMAV_CVC_ELT_6 => 1859,
XML_SCHEMAV_CVC_ELT_7 => 1860, XML_SCHEMAV_CVC_ATTRIBUTE_1 => 1861,
XML_SCHEMAV_CVC_ATTRIBUTE_2 => 1862,
XML_SCHEMAV_CVC_ATTRIBUTE_3 => 1863,
XML_SCHEMAV_CVC_ATTRIBUTE_4 => 1864,
XML_SCHEMAV_CVC_COMPLEX_TYPE_3_1 => 1865,
XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_1 => 1866,
XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_2 => 1867,
XML_SCHEMAV_CVC_COMPLEX_TYPE_4 => 1868,
XML_SCHEMAV_CVC_COMPLEX_TYPE_5_1 => 1869,
XML_SCHEMAV_CVC_COMPLEX_TYPE_5_2 => 1870,
XML_SCHEMAV_ELEMENT_CONTENT => 1871,
XML_SCHEMAV_DOCUMENT_ELEMENT_MISSING => 1872,
XML_SCHEMAV_CVC_COMPLEX_TYPE_1 => 1873, XML_SCHEMAV_CVC_AU => 1874,
XML_SCHEMAV_CVC_TYPE_1 => 1875, XML_SCHEMAV_CVC_TYPE_2 => 1876,
XML_SCHEMAV_CVC_IDC => 1877, XML_SCHEMAV_CVC_WILDCARD => 1878,
XML_SCHEMAV_MISC => 1879, XML_XPTR_UNKNOWN_SCHEME => 1900,
XML_XPTR_CHILDSEQ_START => 1901, XML_XPTR_EVAL_FAILED => 1902,
XML_XPTR_EXTRA_OBJECTS => 1903, XML_C14N_CREATE_CTXT => 1950,
XML_C14N_REQUIRES_UTF8 => 1951, XML_C14N_CREATE_STACK => 1952,
XML_C14N_INVALID_NODE => 1953, XML_C14N_UNKNOW_NODE => 1954,
XML_C14N_RELATIVE_NAMESPACE => 1955, XML_FTP_PASV_ANSWER => 2000,
XML_FTP_EPSV_ANSWER => 2001, XML_FTP_ACCNT => 2002,
XML_FTP_URL_SYNTAX => 2003, XML_HTTP_URL_SYNTAX => 2020,
XML_HTTP_USE_IP => 2021, XML_HTTP_UNKNOWN_HOST => 2022,
XML_SCHEMAP_SRC_SIMPLE_TYPE_1 => 3000,
XML_SCHEMAP_SRC_SIMPLE_TYPE_2 => 3001,
XML_SCHEMAP_SRC_SIMPLE_TYPE_3 => 3002,
XML_SCHEMAP_SRC_SIMPLE_TYPE_4 => 3003, XML_SCHEMAP_SRC_RESOLVE => 3004,
XML_SCHEMAP_SRC_RESTRICTION_BASE_OR_SIMPLETYPE => 3005,
XML_SCHEMAP_SRC_LIST_ITEMTYPE_OR_SIMPLETYPE => 3006,
XML_SCHEMAP_SRC_UNION_MEMBERTYPES_OR_SIMPLETYPES => 3007,
XML_SCHEMAP_ST_PROPS_CORRECT_1 => 3008,
XML_SCHEMAP_ST_PROPS_CORRECT_2 => 3009,
XML_SCHEMAP_ST_PROPS_CORRECT_3 => 3010,
XML_SCHEMAP_COS_ST_RESTRICTS_1_1 => 3011,
XML_SCHEMAP_COS_ST_RESTRICTS_1_2 => 3012,
XML_SCHEMAP_COS_ST_RESTRICTS_1_3_1 => 3013,
XML_SCHEMAP_COS_ST_RESTRICTS_1_3_2 => 3014,
XML_SCHEMAP_COS_ST_RESTRICTS_2_1 => 3015,
XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_1 => 3016,
XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_2 => 3017,
XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_1 => 3018,
XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_2 => 3019,
XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_3 => 3020,
XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_4 => 3021,
XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_5 => 3022,
XML_SCHEMAP_COS_ST_RESTRICTS_3_1 => 3023,
XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1 => 3024,
XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1_2 => 3025,
XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_2 => 3026,
XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_1 => 3027,
XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_3 => 3028,
XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_4 => 3029,
XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_5 => 3030,
XML_SCHEMAP_COS_ST_DERIVED_OK_2_1 => 3031,
XML_SCHEMAP_COS_ST_DERIVED_OK_2_2 => 3032,
XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED => 3033,
XML_SCHEMAP_S4S_ELEM_MISSING => 3034,
XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED => 3035,
XML_SCHEMAP_S4S_ATTR_MISSING => 3036,
XML_SCHEMAP_S4S_ATTR_INVALID_VALUE => 3037,
XML_SCHEMAP_SRC_ELEMENT_1 => 3038, XML_SCHEMAP_SRC_ELEMENT_2_1 => 3039,
XML_SCHEMAP_SRC_ELEMENT_2_2 => 3040, XML_SCHEMAP_SRC_ELEMENT_3 => 3041,
XML_SCHEMAP_P_PROPS_CORRECT_1 => 3042,
XML_SCHEMAP_P_PROPS_CORRECT_2_1 => 3043,
XML_SCHEMAP_P_PROPS_CORRECT_2_2 => 3044,
XML_SCHEMAP_E_PROPS_CORRECT_2 => 3045,
XML_SCHEMAP_E_PROPS_CORRECT_3 => 3046,
XML_SCHEMAP_E_PROPS_CORRECT_4 => 3047,
XML_SCHEMAP_E_PROPS_CORRECT_5 => 3048,
XML_SCHEMAP_E_PROPS_CORRECT_6 => 3049, XML_SCHEMAP_SRC_INCLUDE => 3050,
XML_SCHEMAP_SRC_ATTRIBUTE_1 => 3051,
XML_SCHEMAP_SRC_ATTRIBUTE_2 => 3052,
XML_SCHEMAP_SRC_ATTRIBUTE_3_1 => 3053,
XML_SCHEMAP_SRC_ATTRIBUTE_3_2 => 3054,
XML_SCHEMAP_SRC_ATTRIBUTE_4 => 3055, XML_SCHEMAP_NO_XMLNS => 3056,
XML_SCHEMAP_NO_XSI => 3057, XML_SCHEMAP_COS_VALID_DEFAULT_1 => 3058,
XML_SCHEMAP_COS_VALID_DEFAULT_2_1 => 3059,
XML_SCHEMAP_COS_VALID_DEFAULT_2_2_1 => 3060,
XML_SCHEMAP_COS_VALID_DEFAULT_2_2_2 => 3061,
XML_SCHEMAP_CVC_SIMPLE_TYPE => 3062,
XML_SCHEMAP_COS_CT_EXTENDS_1_1 => 3063,
XML_SCHEMAP_SRC_IMPORT_1_1 => 3064, XML_SCHEMAP_SRC_IMPORT_1_2 => 3065,
XML_SCHEMAP_SRC_IMPORT_2 => 3066, XML_SCHEMAP_SRC_IMPORT_2_1 => 3067,
XML_SCHEMAP_SRC_IMPORT_2_2 => 3068, XML_SCHEMAP_INTERNAL => 3069,
XML_SCHEMAP_NOT_DETERMINISTIC => 3070,
XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_1 => 3071,
XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_2 => 3072,
XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_3 => 3073,
XML_SCHEMAP_MG_PROPS_CORRECT_1 => 3074,
XML_SCHEMAP_MG_PROPS_CORRECT_2 => 3075, XML_SCHEMAP_SRC_CT_1 => 3076,
XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_3 => 3077,
XML_SCHEMAP_AU_PROPS_CORRECT_2 => 3078,
XML_SCHEMAP_A_PROPS_CORRECT_2 => 3079,
XML_SCHEMAP_C_PROPS_CORRECT => 3080, XML_SCHEMAP_SRC_REDEFINE => 3081,
XML_SCHEMAP_SRC_IMPORT => 3082, XML_SCHEMAP_WARN_SKIP_SCHEMA => 3083,
XML_SCHEMAP_WARN_UNLOCATED_SCHEMA => 3084,
XML_SCHEMAP_WARN_ATTR_REDECL_PROH => 3085,
XML_SCHEMAP_WARN_ATTR_POINTLESS_PROH => 3086,
XML_SCHEMAP_AG_PROPS_CORRECT => 3087,
XML_SCHEMAP_COS_CT_EXTENDS_1_2 => 3088,
XML_SCHEMAP_AU_PROPS_CORRECT => 3089,
XML_SCHEMAP_A_PROPS_CORRECT_3 => 3090,
XML_SCHEMAP_COS_ALL_LIMITED => 3091, XML_SCHEMATRONV_ASSERT => 4000,
XML_SCHEMATRONV_REPORT => 4001, XML_MODULE_OPEN => 4900,
XML_MODULE_CLOSE => 4901, XML_CHECK_FOUND_ELEMENT => 5000,
XML_CHECK_FOUND_ATTRIBUTE => 5001, XML_CHECK_FOUND_TEXT => 5002,
XML_CHECK_FOUND_CDATA => 5003, XML_CHECK_FOUND_ENTITYREF => 5004,
XML_CHECK_FOUND_ENTITY => 5005, XML_CHECK_FOUND_PI => 5006,
XML_CHECK_FOUND_COMMENT => 5007, XML_CHECK_FOUND_DOCTYPE => 5008,
XML_CHECK_FOUND_FRAGMENT => 5009, XML_CHECK_FOUND_NOTATION => 5010,
XML_CHECK_UNKNOWN_NODE => 5011, XML_CHECK_ENTITY_TYPE => 5012,
XML_CHECK_NO_PARENT => 5013, XML_CHECK_NO_DOC => 5014,
XML_CHECK_NO_NAME => 5015, XML_CHECK_NO_ELEM => 5016,
XML_CHECK_WRONG_DOC => 5017, XML_CHECK_NO_PREV => 5018,
XML_CHECK_WRONG_PREV => 5019, XML_CHECK_NO_NEXT => 5020,
XML_CHECK_WRONG_NEXT => 5021, XML_CHECK_NOT_DTD => 5022,
XML_CHECK_NOT_ATTR => 5023, XML_CHECK_NOT_ATTR_DECL => 5024,
XML_CHECK_NOT_ELEM_DECL => 5025, XML_CHECK_NOT_ENTITY_DECL => 5026,
XML_CHECK_NOT_NS_DECL => 5027, XML_CHECK_NO_HREF => 5028,
XML_CHECK_WRONG_PARENT => 5029, XML_CHECK_NS_SCOPE => 5030,
XML_CHECK_NS_ANCESTOR => 5031, XML_CHECK_NOT_UTF8 => 5032,
XML_CHECK_NO_DICT => 5033, XML_CHECK_NOT_NCNAME => 5034,
XML_CHECK_OUTSIDE_DICT => 5035, XML_CHECK_WRONG_NAME => 5036,
XML_CHECK_NAME_NOT_NULL => 5037, XML_I18N_NO_NAME => 6000,
XML_I18N_NO_HANDLER => 6001, XML_I18N_EXCESS_HANDLER => 6002,
XML_I18N_CONV_FAILED => 6003, XML_I18N_NO_OUTPUT => 6004,
XML_BUF_OVERFLOW => 7000);
pragma Convention (C, enum_e5ead1e1);
subtype xmlParserErrors is enum_e5ead1e1;
type access_df044840 is access procedure (ctx : void_ptr;
msg : access constant char);
pragma Convention (C, access_df044840);
type access_df044840_ptr is access all access_df044840;
for access_df044840_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (access_df044840_ptr);
pragma Convention (C, access_df044840_ptr);
subtype xmlGenericErrorFunc is access_df044840;
subtype xmlGenericErrorFunc_ptr is access_df044840_ptr;
type access_644d42e6 is access procedure (userData : void_ptr;
error : access xmlError);
pragma Convention (C, access_644d42e6);
type access_644d42e6_ptr is access all access_644d42e6;
for access_644d42e6_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (access_644d42e6_ptr);
pragma Convention (C, access_644d42e6_ptr);
subtype xmlStructuredErrorFunc is access_644d42e6;
subtype xmlStructuredErrorFunc_ptr is access_644d42e6_ptr;
procedure xmlSetGenericErrorFunc (ctx : void_ptr;
handler : xmlGenericErrorFunc);
pragma Import (C, xmlSetGenericErrorFunc, "xmlSetGenericErrorFunc");
procedure initGenericErrorDefaultFunc (
handler : access xmlGenericErrorFunc);
pragma Import (C, initGenericErrorDefaultFunc,
"initGenericErrorDefaultFunc");
procedure xmlSetStructuredErrorFunc (ctx : void_ptr;
handler : xmlStructuredErrorFunc);
pragma Import (C, xmlSetStructuredErrorFunc, "xmlSetStructuredErrorFunc");
procedure xmlParserError (ctx : void_ptr; msg : access constant char);
pragma Import (C, xmlParserError, "xmlParserError");
procedure xmlParserWarning (ctx : void_ptr; msg : access constant char);
pragma Import (C, xmlParserWarning, "xmlParserWarning");
procedure xmlParserValidityError (ctx : void_ptr;
msg : access constant char);
pragma Import (C, xmlParserValidityError, "xmlParserValidityError");
procedure xmlParserValidityWarning (ctx : void_ptr;
msg : access constant char);
pragma Import (C, xmlParserValidityWarning, "xmlParserValidityWarning");
procedure xmlParserPrintFileInfo (
input : access parser.struct_xmlParserInput);
pragma Import (C, xmlParserPrintFileInfo, "xmlParserPrintFileInfo");
procedure xmlParserPrintFileContext (
input : access parser.struct_xmlParserInput);
pragma Import (C, xmlParserPrintFileContext, "xmlParserPrintFileContext");
function xmlGetLastError return xmlErrorPtr;
pragma Import (C, xmlGetLastError, "xmlGetLastError");
procedure xmlResetLastError;
pragma Import (C, xmlResetLastError, "xmlResetLastError");
function xmlCtxtGetLastError (ctx : void_ptr) return xmlErrorPtr;
pragma Import (C, xmlCtxtGetLastError, "xmlCtxtGetLastError");
procedure xmlCtxtResetLastError (ctx : void_ptr);
pragma Import (C, xmlCtxtResetLastError, "xmlCtxtResetLastError");
procedure xmlResetError (err : access xmlError);
pragma Import (C, xmlResetError, "xmlResetError");
function xmlCopyError (from : access xmlError; to : access xmlError)
return signed_int;
pragma Import (C, xmlCopyError, "xmlCopyError");
-- __XML_ERROR_H__ (empty)
end C.libxml.xmlerror;
Raw
c-libxml-xmlexports.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.libxml.xmlexports is
pragma Preelaborate;
-- LIBXML_DLL_IMPORT (alias of extern)
-- XMLCALL (empty)
-- XMLCDECL (empty)
-- XMLPUBFUN (empty)
-- XMLPUBVAR (alias of extern)
-- __XML_EXPORTS_H__ (empty)
end C.libxml.xmlexports;
Raw
c-libxml-xmlio.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.libxml.encoding;
limited with C.libxml.parser;
with C.libxml.tree;
with C.libxml.xmlstring;
with C.stddef;
with C.stdio;
package C.libxml.xmlIO is
pragma Preelaborate;
type struct_xmlParserInputBuffer;
type struct_xmlOutputBuffer;
type access_affc459f is access function (filename : access constant char)
return signed_int;
pragma Convention (C, access_affc459f);
subtype xmlInputMatchCallback is access_affc459f;
type access_40307040 is access function (filename : access constant char)
return void_ptr;
pragma Convention (C, access_40307040);
subtype xmlInputOpenCallback is access_40307040;
type access_1eedaad7 is access function (context : void_ptr;
buffer : access char; len : signed_int) return signed_int;
pragma Convention (C, access_1eedaad7);
subtype xmlInputReadCallback is access_1eedaad7;
type access_32289f49 is access function (context : void_ptr)
return signed_int;
pragma Convention (C, access_32289f49);
subtype xmlInputCloseCallback is access_32289f49;
type access_e82e95c5 is access function (filename : access constant char)
return signed_int;
pragma Convention (C, access_e82e95c5);
subtype xmlOutputMatchCallback is access_e82e95c5;
type access_838ca8af is access function (filename : access constant char)
return void_ptr;
pragma Convention (C, access_838ca8af);
subtype xmlOutputOpenCallback is access_838ca8af;
type access_5bd397a0 is access function (context : void_ptr;
buffer : access constant char; len : signed_int) return signed_int;
pragma Convention (C, access_5bd397a0);
subtype xmlOutputWriteCallback is access_5bd397a0;
type access_27272ef7 is access function (context : void_ptr)
return signed_int;
pragma Convention (C, access_27272ef7);
subtype xmlOutputCloseCallback is access_27272ef7;
type struct_xmlParserInputBuffer is record
context : aliased void_ptr;
readcallback : aliased xmlInputReadCallback;
closecallback : aliased xmlInputCloseCallback;
encoder : aliased encoding.xmlCharEncodingHandlerPtr;
buffer : aliased tree.xmlBufPtr;
raw : aliased tree.xmlBufPtr;
compressed : aliased signed_int;
error : aliased signed_int;
rawconsumed : aliased unsigned_long;
end record;
pragma Convention (C_Pass_By_Copy, struct_xmlParserInputBuffer);
type struct_xmlOutputBuffer is record
context : aliased void_ptr;
writecallback : aliased xmlOutputWriteCallback;
closecallback : aliased xmlOutputCloseCallback;
encoder : aliased encoding.xmlCharEncodingHandlerPtr;
buffer : aliased tree.xmlBufPtr;
conv : aliased tree.xmlBufPtr;
written : aliased signed_int;
error : aliased signed_int;
end record;
pragma Convention (C_Pass_By_Copy, struct_xmlOutputBuffer);
procedure xmlCleanupInputCallbacks;
pragma Import (C, xmlCleanupInputCallbacks, "xmlCleanupInputCallbacks");
function xmlPopInputCallbacks return signed_int;
pragma Import (C, xmlPopInputCallbacks, "xmlPopInputCallbacks");
procedure xmlRegisterDefaultInputCallbacks;
pragma Import (C, xmlRegisterDefaultInputCallbacks,
"xmlRegisterDefaultInputCallbacks");
function xmlAllocParserInputBuffer (enc : encoding.xmlCharEncoding)
return tree.xmlParserInputBufferPtr;
pragma Import (C, xmlAllocParserInputBuffer, "xmlAllocParserInputBuffer");
function xmlParserInputBufferCreateFilename (URI : access constant char;
enc : encoding.xmlCharEncoding) return tree.xmlParserInputBufferPtr;
pragma Import (C, xmlParserInputBufferCreateFilename,
"xmlParserInputBufferCreateFilename");
function xmlParserInputBufferCreateFile (file : access stdio.FILE;
enc : encoding.xmlCharEncoding) return tree.xmlParserInputBufferPtr;
pragma Import (C, xmlParserInputBufferCreateFile,
"xmlParserInputBufferCreateFile");
function xmlParserInputBufferCreateFd (fd : signed_int;
enc : encoding.xmlCharEncoding) return tree.xmlParserInputBufferPtr;
pragma Import (C, xmlParserInputBufferCreateFd,
"xmlParserInputBufferCreateFd");
function xmlParserInputBufferCreateMem (mem : access constant char;
size : signed_int; enc : encoding.xmlCharEncoding)
return tree.xmlParserInputBufferPtr;
pragma Import (C, xmlParserInputBufferCreateMem,
"xmlParserInputBufferCreateMem");
function xmlParserInputBufferCreateStatic (mem : access constant char;
size : signed_int; enc : encoding.xmlCharEncoding)
return tree.xmlParserInputBufferPtr;
pragma Import (C, xmlParserInputBufferCreateStatic,
"xmlParserInputBufferCreateStatic");
function xmlParserInputBufferCreateIO (ioread : xmlInputReadCallback;
ioclose : xmlInputCloseCallback; ioctx : void_ptr;
enc : encoding.xmlCharEncoding) return tree.xmlParserInputBufferPtr;
pragma Import (C, xmlParserInputBufferCreateIO,
"xmlParserInputBufferCreateIO");
function xmlParserInputBufferRead (
A_in : access struct_xmlParserInputBuffer; len : signed_int)
return signed_int;
pragma Import (C, xmlParserInputBufferRead, "xmlParserInputBufferRead");
function xmlParserInputBufferGrow (
A_in : access struct_xmlParserInputBuffer; len : signed_int)
return signed_int;
pragma Import (C, xmlParserInputBufferGrow, "xmlParserInputBufferGrow");
function xmlParserInputBufferPush (
A_in : access struct_xmlParserInputBuffer; len : signed_int;
buf : access constant char) return signed_int;
pragma Import (C, xmlParserInputBufferPush, "xmlParserInputBufferPush");
procedure xmlFreeParserInputBuffer (
A_in : access struct_xmlParserInputBuffer);
pragma Import (C, xmlFreeParserInputBuffer, "xmlFreeParserInputBuffer");
function xmlParserGetDirectory (filename : access constant char)
return char_ptr;
pragma Import (C, xmlParserGetDirectory, "xmlParserGetDirectory");
function xmlRegisterInputCallbacks (matchFunc : xmlInputMatchCallback;
openFunc : xmlInputOpenCallback; readFunc : xmlInputReadCallback;
closeFunc : xmlInputCloseCallback) return signed_int;
pragma Import (C, xmlRegisterInputCallbacks, "xmlRegisterInputCallbacks");
function qqxmlParserInputBufferCreateFilename (URI : access constant char;
enc : encoding.xmlCharEncoding) return tree.xmlParserInputBufferPtr;
pragma Import (C, qqxmlParserInputBufferCreateFilename,
"__xmlParserInputBufferCreateFilename");
procedure xmlCleanupOutputCallbacks;
pragma Import (C, xmlCleanupOutputCallbacks, "xmlCleanupOutputCallbacks");
procedure xmlRegisterDefaultOutputCallbacks;
pragma Import (C, xmlRegisterDefaultOutputCallbacks,
"xmlRegisterDefaultOutputCallbacks");
function xmlAllocOutputBuffer (
encoder : access encoding.xmlCharEncodingHandler)
return tree.xmlOutputBufferPtr;
pragma Import (C, xmlAllocOutputBuffer, "xmlAllocOutputBuffer");
function xmlOutputBufferCreateFilename (URI : access constant char;
encoder : access encoding.xmlCharEncodingHandler;
compression : signed_int) return tree.xmlOutputBufferPtr;
pragma Import (C, xmlOutputBufferCreateFilename,
"xmlOutputBufferCreateFilename");
function xmlOutputBufferCreateFile (file : access stdio.FILE;
encoder : access encoding.xmlCharEncodingHandler)
return tree.xmlOutputBufferPtr;
pragma Import (C, xmlOutputBufferCreateFile, "xmlOutputBufferCreateFile");
function xmlOutputBufferCreateBuffer (buffer : access tree.xmlBuffer;
encoder : access encoding.xmlCharEncodingHandler)
return tree.xmlOutputBufferPtr;
pragma Import (C, xmlOutputBufferCreateBuffer,
"xmlOutputBufferCreateBuffer");
function xmlOutputBufferCreateFd (fd : signed_int;
encoder : access encoding.xmlCharEncodingHandler)
return tree.xmlOutputBufferPtr;
pragma Import (C, xmlOutputBufferCreateFd, "xmlOutputBufferCreateFd");
function xmlOutputBufferCreateIO (iowrite : xmlOutputWriteCallback;
ioclose : xmlOutputCloseCallback; ioctx : void_ptr;
encoder : access encoding.xmlCharEncodingHandler)
return tree.xmlOutputBufferPtr;
pragma Import (C, xmlOutputBufferCreateIO, "xmlOutputBufferCreateIO");
function xmlOutputBufferGetContent (A_out : access struct_xmlOutputBuffer)
return xmlstring.xmlChar_const_ptr;
pragma Import (C, xmlOutputBufferGetContent, "xmlOutputBufferGetContent");
function xmlOutputBufferGetSize (A_out : access struct_xmlOutputBuffer)
return stddef.size_t;
pragma Import (C, xmlOutputBufferGetSize, "xmlOutputBufferGetSize");
function xmlOutputBufferWrite (A_out : access struct_xmlOutputBuffer;
len : signed_int; buf : access constant char) return signed_int;
pragma Import (C, xmlOutputBufferWrite, "xmlOutputBufferWrite");
function xmlOutputBufferWriteString (
A_out : access struct_xmlOutputBuffer; str : access constant char)
return signed_int;
pragma Import (C, xmlOutputBufferWriteString,
"xmlOutputBufferWriteString");
function xmlOutputBufferWriteEscape (
A_out : access struct_xmlOutputBuffer;
str : access constant xmlstring.xmlChar;
escaping : encoding.xmlCharEncodingOutputFunc) return signed_int;
pragma Import (C, xmlOutputBufferWriteEscape,
"xmlOutputBufferWriteEscape");
function xmlOutputBufferFlush (A_out : access struct_xmlOutputBuffer)
return signed_int;
pragma Import (C, xmlOutputBufferFlush, "xmlOutputBufferFlush");
function xmlOutputBufferClose (A_out : access struct_xmlOutputBuffer)
return signed_int;
pragma Import (C, xmlOutputBufferClose, "xmlOutputBufferClose");
function xmlRegisterOutputCallbacks (matchFunc : xmlOutputMatchCallback;
openFunc : xmlOutputOpenCallback; writeFunc : xmlOutputWriteCallback;
closeFunc : xmlOutputCloseCallback) return signed_int;
pragma Import (C, xmlRegisterOutputCallbacks,
"xmlRegisterOutputCallbacks");
function qqxmlOutputBufferCreateFilename (URI : access constant char;
encoder : access encoding.xmlCharEncodingHandler;
compression : signed_int) return tree.xmlOutputBufferPtr;
pragma Import (C, qqxmlOutputBufferCreateFilename,
"__xmlOutputBufferCreateFilename");
procedure xmlRegisterHTTPPostCallbacks;
pragma Import (C, xmlRegisterHTTPPostCallbacks,
"xmlRegisterHTTPPostCallbacks");
function xmlCheckHTTPInput (ctxt : access parser.struct_xmlParserCtxt;
ret : access parser.struct_xmlParserInput)
return tree.xmlParserInputPtr;
pragma Import (C, xmlCheckHTTPInput, "xmlCheckHTTPInput");
function xmlNoNetExternalEntityLoader (URL : access constant char;
ID : access constant char; ctxt : access parser.struct_xmlParserCtxt)
return tree.xmlParserInputPtr;
pragma Import (C, xmlNoNetExternalEntityLoader,
"xmlNoNetExternalEntityLoader");
function xmlNormalizeWindowsPath (
path : access constant xmlstring.xmlChar) return xmlstring.xmlChar_ptr;
pragma Import (C, xmlNormalizeWindowsPath, "xmlNormalizeWindowsPath");
function xmlCheckFilename (path : access constant char) return signed_int;
pragma Import (C, xmlCheckFilename, "xmlCheckFilename");
function xmlFileMatch (filename : access constant char) return signed_int;
pragma Import (C, xmlFileMatch, "xmlFileMatch");
function xmlFileOpen (filename : access constant char) return void_ptr;
pragma Import (C, xmlFileOpen, "xmlFileOpen");
function xmlFileRead (context : void_ptr; buffer : access char;
len : signed_int) return signed_int;
pragma Import (C, xmlFileRead, "xmlFileRead");
function xmlFileClose (context : void_ptr) return signed_int;
pragma Import (C, xmlFileClose, "xmlFileClose");
function xmlIOHTTPMatch (filename : access constant char)
return signed_int;
pragma Import (C, xmlIOHTTPMatch, "xmlIOHTTPMatch");
function xmlIOHTTPOpen (filename : access constant char) return void_ptr;
pragma Import (C, xmlIOHTTPOpen, "xmlIOHTTPOpen");
function xmlIOHTTPOpenW (post_uri : access constant char;
compression : signed_int) return void_ptr;
pragma Import (C, xmlIOHTTPOpenW, "xmlIOHTTPOpenW");
function xmlIOHTTPRead (context : void_ptr; buffer : access char;
len : signed_int) return signed_int;
pragma Import (C, xmlIOHTTPRead, "xmlIOHTTPRead");
function xmlIOHTTPClose (context : void_ptr) return signed_int;
pragma Import (C, xmlIOHTTPClose, "xmlIOHTTPClose");
function xmlIOFTPMatch (filename : access constant char)
return signed_int;
pragma Import (C, xmlIOFTPMatch, "xmlIOFTPMatch");
function xmlIOFTPOpen (filename : access constant char) return void_ptr;
pragma Import (C, xmlIOFTPOpen, "xmlIOFTPOpen");
function xmlIOFTPRead (context : void_ptr; buffer : access char;
len : signed_int) return signed_int;
pragma Import (C, xmlIOFTPRead, "xmlIOFTPRead");
function xmlIOFTPClose (context : void_ptr) return signed_int;
pragma Import (C, xmlIOFTPClose, "xmlIOFTPClose");
-- __XML_IO_H__ (empty)
end C.libxml.xmlIO;
Raw
c-libxml-xmlmemory.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.libxml.xmlmemory is
pragma Preelaborate;
type access_87c20fd2 is access procedure (mem : void_ptr);
pragma Convention (C, access_87c20fd2);
type access_87c20fd2_ptr is access all access_87c20fd2;
for access_87c20fd2_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (access_87c20fd2_ptr);
pragma Convention (C, access_87c20fd2_ptr);
subtype xmlFreeFunc is access_87c20fd2;
subtype xmlFreeFunc_ptr is access_87c20fd2_ptr;
type access_4470accf is access function (size : stddef.size_t)
return void_ptr;
pragma Convention (C, access_4470accf);
type access_4470accf_ptr is access all access_4470accf;
for access_4470accf_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (access_4470accf_ptr);
pragma Convention (C, access_4470accf_ptr);
subtype xmlMallocFunc is access_4470accf;
subtype xmlMallocFunc_ptr is access_4470accf_ptr;
type access_5f57ca02 is access function (mem : void_ptr;
size : stddef.size_t) return void_ptr;
pragma Convention (C, access_5f57ca02);
type access_5f57ca02_ptr is access all access_5f57ca02;
for access_5f57ca02_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (access_5f57ca02_ptr);
pragma Convention (C, access_5f57ca02_ptr);
subtype xmlReallocFunc is access_5f57ca02;
subtype xmlReallocFunc_ptr is access_5f57ca02_ptr;
type access_54816577 is access function (str : access constant char)
return char_ptr;
pragma Convention (C, access_54816577);
type access_54816577_ptr is access all access_54816577;
for access_54816577_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (access_54816577_ptr);
pragma Convention (C, access_54816577_ptr);
subtype xmlStrdupFunc is access_54816577;
subtype xmlStrdupFunc_ptr is access_54816577_ptr;
function xmlMemSetup (freeFunc : xmlFreeFunc; mallocFunc : xmlMallocFunc;
reallocFunc : xmlReallocFunc; strdupFunc : xmlStrdupFunc)
return signed_int;
pragma Import (C, xmlMemSetup, "xmlMemSetup");
function xmlMemGet (freeFunc : access xmlFreeFunc;
mallocFunc : access xmlMallocFunc; reallocFunc : access xmlReallocFunc;
strdupFunc : access xmlStrdupFunc) return signed_int;
pragma Import (C, xmlMemGet, "xmlMemGet");
function xmlGcMemSetup (freeFunc : xmlFreeFunc;
mallocFunc : xmlMallocFunc; mallocAtomicFunc : xmlMallocFunc;
reallocFunc : xmlReallocFunc; strdupFunc : xmlStrdupFunc)
return signed_int;
pragma Import (C, xmlGcMemSetup, "xmlGcMemSetup");
function xmlGcMemGet (freeFunc : access xmlFreeFunc;
mallocFunc : access xmlMallocFunc;
mallocAtomicFunc : access xmlMallocFunc;
reallocFunc : access xmlReallocFunc; strdupFunc : access xmlStrdupFunc)
return signed_int;
pragma Import (C, xmlGcMemGet, "xmlGcMemGet");
function xmlInitMemory return signed_int;
pragma Import (C, xmlInitMemory, "xmlInitMemory");
procedure xmlCleanupMemory;
pragma Import (C, xmlCleanupMemory, "xmlCleanupMemory");
function xmlMemUsed return signed_int;
pragma Import (C, xmlMemUsed, "xmlMemUsed");
function xmlMemBlocks return signed_int;
pragma Import (C, xmlMemBlocks, "xmlMemBlocks");
procedure xmlMemDisplay (fp : access stdio.FILE);
pragma Import (C, xmlMemDisplay, "xmlMemDisplay");
procedure xmlMemDisplayLast (fp : access stdio.FILE;
nbBytes : signed_long);
pragma Import (C, xmlMemDisplayLast, "xmlMemDisplayLast");
procedure xmlMemShow (fp : access stdio.FILE; nr : signed_int);
pragma Import (C, xmlMemShow, "xmlMemShow");
procedure xmlMemoryDump;
pragma Import (C, xmlMemoryDump, "xmlMemoryDump");
function xmlMemMalloc (size : stddef.size_t) return void_ptr;
pragma Import (C, xmlMemMalloc, "xmlMemMalloc");
function xmlMemRealloc (ptr : void_ptr; size : stddef.size_t)
return void_ptr;
pragma Import (C, xmlMemRealloc, "xmlMemRealloc");
procedure xmlMemFree (ptr : void_ptr);
pragma Import (C, xmlMemFree, "xmlMemFree");
function xmlMemoryStrdup (str : access constant char) return char_ptr;
pragma Import (C, xmlMemoryStrdup, "xmlMemoryStrdup");
function xmlMallocLoc (size : stddef.size_t; file : access constant char;
line : signed_int) return void_ptr;
pragma Import (C, xmlMallocLoc, "xmlMallocLoc");
function xmlReallocLoc (ptr : void_ptr; size : stddef.size_t;
file : access constant char; line : signed_int) return void_ptr;
pragma Import (C, xmlReallocLoc, "xmlReallocLoc");
function xmlMallocAtomicLoc (size : stddef.size_t;
file : access constant char; line : signed_int) return void_ptr;
pragma Import (C, xmlMallocAtomicLoc, "xmlMallocAtomicLoc");
function xmlMemStrdupLoc (str : access constant char;
file : access constant char; line : signed_int) return char_ptr;
pragma Import (C, xmlMemStrdupLoc, "xmlMemStrdupLoc");
-- __DEBUG_MEMORY_ALLOC__ (empty)
end C.libxml.xmlmemory;
Raw
c-libxml-xmlreader.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.libxml.relaxng;
with C.libxml.tree;
with C.libxml.xmlIO;
with C.libxml.xmlerror;
with C.libxml.xmlschemas;
with C.libxml.xmlstring;
package C.libxml.xmlreader is
pragma Preelaborate;
type enum_e169c960 is (XML_PARSER_SEVERITY_VALIDITY_WARNING,
XML_PARSER_SEVERITY_VALIDITY_ERROR, XML_PARSER_SEVERITY_WARNING,
XML_PARSER_SEVERITY_ERROR);
for enum_e169c960 use (XML_PARSER_SEVERITY_VALIDITY_WARNING => 1,
XML_PARSER_SEVERITY_VALIDITY_ERROR => 2,
XML_PARSER_SEVERITY_WARNING => 3, XML_PARSER_SEVERITY_ERROR => 4);
pragma Convention (C, enum_e169c960);
subtype xmlParserSeverities is enum_e169c960;
type enum_bd9fb2b0 is (XML_TEXTREADER_MODE_INITIAL,
XML_TEXTREADER_MODE_INTERACTIVE, XML_TEXTREADER_MODE_ERROR,
XML_TEXTREADER_MODE_EOF, XML_TEXTREADER_MODE_CLOSED,
XML_TEXTREADER_MODE_READING);
for enum_bd9fb2b0 use (XML_TEXTREADER_MODE_INITIAL => 0,
XML_TEXTREADER_MODE_INTERACTIVE => 1, XML_TEXTREADER_MODE_ERROR => 2,
XML_TEXTREADER_MODE_EOF => 3, XML_TEXTREADER_MODE_CLOSED => 4,
XML_TEXTREADER_MODE_READING => 5);
pragma Convention (C, enum_bd9fb2b0);
subtype xmlTextReaderMode is enum_bd9fb2b0;
type enum_c33c8973 is (XML_PARSER_LOADDTD, XML_PARSER_DEFAULTATTRS,
XML_PARSER_VALIDATE, XML_PARSER_SUBST_ENTITIES);
for enum_c33c8973 use (XML_PARSER_LOADDTD => 1,
XML_PARSER_DEFAULTATTRS => 2, XML_PARSER_VALIDATE => 3,
XML_PARSER_SUBST_ENTITIES => 4);
pragma Convention (C, enum_c33c8973);
subtype xmlParserProperties is enum_c33c8973;
type enum_a6de3859 is (XML_READER_TYPE_NONE, XML_READER_TYPE_ELEMENT,
XML_READER_TYPE_ATTRIBUTE, XML_READER_TYPE_TEXT, XML_READER_TYPE_CDATA,
XML_READER_TYPE_ENTITY_REFERENCE, XML_READER_TYPE_ENTITY,
XML_READER_TYPE_PROCESSING_INSTRUCTION, XML_READER_TYPE_COMMENT,
XML_READER_TYPE_DOCUMENT, XML_READER_TYPE_DOCUMENT_TYPE,
XML_READER_TYPE_DOCUMENT_FRAGMENT, XML_READER_TYPE_NOTATION,
XML_READER_TYPE_WHITESPACE, XML_READER_TYPE_SIGNIFICANT_WHITESPACE,
XML_READER_TYPE_END_ELEMENT, XML_READER_TYPE_END_ENTITY,
XML_READER_TYPE_XML_DECLARATION);
for enum_a6de3859 use (XML_READER_TYPE_NONE => 0,
XML_READER_TYPE_ELEMENT => 1, XML_READER_TYPE_ATTRIBUTE => 2,
XML_READER_TYPE_TEXT => 3, XML_READER_TYPE_CDATA => 4,
XML_READER_TYPE_ENTITY_REFERENCE => 5, XML_READER_TYPE_ENTITY => 6,
XML_READER_TYPE_PROCESSING_INSTRUCTION => 7,
XML_READER_TYPE_COMMENT => 8, XML_READER_TYPE_DOCUMENT => 9,
XML_READER_TYPE_DOCUMENT_TYPE => 10,
XML_READER_TYPE_DOCUMENT_FRAGMENT => 11,
XML_READER_TYPE_NOTATION => 12, XML_READER_TYPE_WHITESPACE => 13,
XML_READER_TYPE_SIGNIFICANT_WHITESPACE => 14,
XML_READER_TYPE_END_ELEMENT => 15, XML_READER_TYPE_END_ENTITY => 16,
XML_READER_TYPE_XML_DECLARATION => 17);
pragma Convention (C, enum_a6de3859);
subtype xmlReaderTypes is enum_a6de3859;
type struct_xmlTextReader (<>) is limited private;
type struct_xmlTextReader_ptr is access all struct_xmlTextReader;
for struct_xmlTextReader_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlTextReader_ptr);
pragma Convention (C, struct_xmlTextReader_ptr);
subtype xmlTextReader is struct_xmlTextReader;
subtype xmlTextReader_ptr is struct_xmlTextReader_ptr;
subtype xmlTextReaderPtr is xmlTextReader_ptr;
function xmlNewTextReader (
input : access xmlIO.struct_xmlParserInputBuffer;
URI : access constant char) return xmlTextReaderPtr;
pragma Import (C, xmlNewTextReader, "xmlNewTextReader");
function xmlNewTextReaderFilename (URI : access constant char)
return xmlTextReaderPtr;
pragma Import (C, xmlNewTextReaderFilename, "xmlNewTextReaderFilename");
procedure xmlFreeTextReader (reader : access xmlTextReader);
pragma Import (C, xmlFreeTextReader, "xmlFreeTextReader");
function xmlTextReaderSetup (reader : access xmlTextReader;
input : access xmlIO.struct_xmlParserInputBuffer;
URL : access constant char; encoding : access constant char;
options : signed_int) return signed_int;
pragma Import (C, xmlTextReaderSetup, "xmlTextReaderSetup");
function xmlTextReaderRead (reader : access xmlTextReader)
return signed_int;
pragma Import (C, xmlTextReaderRead, "xmlTextReaderRead");
function xmlTextReaderReadInnerXml (reader : access xmlTextReader)
return xmlstring.xmlChar_ptr;
pragma Import (C, xmlTextReaderReadInnerXml, "xmlTextReaderReadInnerXml");
function xmlTextReaderReadOuterXml (reader : access xmlTextReader)
return xmlstring.xmlChar_ptr;
pragma Import (C, xmlTextReaderReadOuterXml, "xmlTextReaderReadOuterXml");
function xmlTextReaderReadString (reader : access xmlTextReader)
return xmlstring.xmlChar_ptr;
pragma Import (C, xmlTextReaderReadString, "xmlTextReaderReadString");
function xmlTextReaderReadAttributeValue (reader : access xmlTextReader)
return signed_int;
pragma Import (C, xmlTextReaderReadAttributeValue,
"xmlTextReaderReadAttributeValue");
function xmlTextReaderAttributeCount (reader : access xmlTextReader)
return signed_int;
pragma Import (C, xmlTextReaderAttributeCount,
"xmlTextReaderAttributeCount");
function xmlTextReaderDepth (reader : access xmlTextReader)
return signed_int;
pragma Import (C, xmlTextReaderDepth, "xmlTextReaderDepth");
function xmlTextReaderHasAttributes (reader : access xmlTextReader)
return signed_int;
pragma Import (C, xmlTextReaderHasAttributes,
"xmlTextReaderHasAttributes");
function xmlTextReaderHasValue (reader : access xmlTextReader)
return signed_int;
pragma Import (C, xmlTextReaderHasValue, "xmlTextReaderHasValue");
function xmlTextReaderIsDefault (reader : access xmlTextReader)
return signed_int;
pragma Import (C, xmlTextReaderIsDefault, "xmlTextReaderIsDefault");
function xmlTextReaderIsEmptyElement (reader : access xmlTextReader)
return signed_int;
pragma Import (C, xmlTextReaderIsEmptyElement,
"xmlTextReaderIsEmptyElement");
function xmlTextReaderNodeType (reader : access xmlTextReader)
return signed_int;
pragma Import (C, xmlTextReaderNodeType, "xmlTextReaderNodeType");
function xmlTextReaderQuoteChar (reader : access xmlTextReader)
return signed_int;
pragma Import (C, xmlTextReaderQuoteChar, "xmlTextReaderQuoteChar");
function xmlTextReaderReadState (reader : access xmlTextReader)
return signed_int;
pragma Import (C, xmlTextReaderReadState, "xmlTextReaderReadState");
function xmlTextReaderIsNamespaceDecl (reader : access xmlTextReader)
return signed_int;
pragma Import (C, xmlTextReaderIsNamespaceDecl,
"xmlTextReaderIsNamespaceDecl");
function xmlTextReaderConstBaseUri (reader : access xmlTextReader)
return xmlstring.xmlChar_const_ptr;
pragma Import (C, xmlTextReaderConstBaseUri, "xmlTextReaderConstBaseUri");
function xmlTextReaderConstLocalName (reader : access xmlTextReader)
return xmlstring.xmlChar_const_ptr;
pragma Import (C, xmlTextReaderConstLocalName,
"xmlTextReaderConstLocalName");
function xmlTextReaderConstName (reader : access xmlTextReader)
return xmlstring.xmlChar_const_ptr;
pragma Import (C, xmlTextReaderConstName, "xmlTextReaderConstName");
function xmlTextReaderConstNamespaceUri (reader : access xmlTextReader)
return xmlstring.xmlChar_const_ptr;
pragma Import (C, xmlTextReaderConstNamespaceUri,
"xmlTextReaderConstNamespaceUri");
function xmlTextReaderConstPrefix (reader : access xmlTextReader)
return xmlstring.xmlChar_const_ptr;
pragma Import (C, xmlTextReaderConstPrefix, "xmlTextReaderConstPrefix");
function xmlTextReaderConstXmlLang (reader : access xmlTextReader)
return xmlstring.xmlChar_const_ptr;
pragma Import (C, xmlTextReaderConstXmlLang, "xmlTextReaderConstXmlLang");
function xmlTextReaderConstString (reader : access xmlTextReader;
str : access constant xmlstring.xmlChar)
return xmlstring.xmlChar_const_ptr;
pragma Import (C, xmlTextReaderConstString, "xmlTextReaderConstString");
function xmlTextReaderConstValue (reader : access xmlTextReader)
return xmlstring.xmlChar_const_ptr;
pragma Import (C, xmlTextReaderConstValue, "xmlTextReaderConstValue");
function xmlTextReaderBaseUri (reader : access xmlTextReader)
return xmlstring.xmlChar_ptr;
pragma Import (C, xmlTextReaderBaseUri, "xmlTextReaderBaseUri");
function xmlTextReaderLocalName (reader : access xmlTextReader)
return xmlstring.xmlChar_ptr;
pragma Import (C, xmlTextReaderLocalName, "xmlTextReaderLocalName");
function xmlTextReaderName (reader : access xmlTextReader)
return xmlstring.xmlChar_ptr;
pragma Import (C, xmlTextReaderName, "xmlTextReaderName");
function xmlTextReaderNamespaceUri (reader : access xmlTextReader)
return xmlstring.xmlChar_ptr;
pragma Import (C, xmlTextReaderNamespaceUri, "xmlTextReaderNamespaceUri");
function xmlTextReaderPrefix (reader : access xmlTextReader)
return xmlstring.xmlChar_ptr;
pragma Import (C, xmlTextReaderPrefix, "xmlTextReaderPrefix");
function xmlTextReaderXmlLang (reader : access xmlTextReader)
return xmlstring.xmlChar_ptr;
pragma Import (C, xmlTextReaderXmlLang, "xmlTextReaderXmlLang");
function xmlTextReaderValue (reader : access xmlTextReader)
return xmlstring.xmlChar_ptr;
pragma Import (C, xmlTextReaderValue, "xmlTextReaderValue");
function xmlTextReaderClose (reader : access xmlTextReader)
return signed_int;
pragma Import (C, xmlTextReaderClose, "xmlTextReaderClose");
function xmlTextReaderGetAttributeNo (reader : access xmlTextReader;
no : signed_int) return xmlstring.xmlChar_ptr;
pragma Import (C, xmlTextReaderGetAttributeNo,
"xmlTextReaderGetAttributeNo");
function xmlTextReaderGetAttribute (reader : access xmlTextReader;
name : access constant xmlstring.xmlChar) return xmlstring.xmlChar_ptr;
pragma Import (C, xmlTextReaderGetAttribute, "xmlTextReaderGetAttribute");
function xmlTextReaderGetAttributeNs (reader : access xmlTextReader;
localName : access constant xmlstring.xmlChar;
namespaceURI : access constant xmlstring.xmlChar)
return xmlstring.xmlChar_ptr;
pragma Import (C, xmlTextReaderGetAttributeNs,
"xmlTextReaderGetAttributeNs");
function xmlTextReaderGetRemainder (reader : access xmlTextReader)
return tree.xmlParserInputBufferPtr;
pragma Import (C, xmlTextReaderGetRemainder, "xmlTextReaderGetRemainder");
function xmlTextReaderLookupNamespace (reader : access xmlTextReader;
prefix : access constant xmlstring.xmlChar)
return xmlstring.xmlChar_ptr;
pragma Import (C, xmlTextReaderLookupNamespace,
"xmlTextReaderLookupNamespace");
function xmlTextReaderMoveToAttributeNo (reader : access xmlTextReader;
no : signed_int) return signed_int;
pragma Import (C, xmlTextReaderMoveToAttributeNo,
"xmlTextReaderMoveToAttributeNo");
function xmlTextReaderMoveToAttribute (reader : access xmlTextReader;
name : access constant xmlstring.xmlChar) return signed_int;
pragma Import (C, xmlTextReaderMoveToAttribute,
"xmlTextReaderMoveToAttribute");
function xmlTextReaderMoveToAttributeNs (reader : access xmlTextReader;
localName : access constant xmlstring.xmlChar;
namespaceURI : access constant xmlstring.xmlChar) return signed_int;
pragma Import (C, xmlTextReaderMoveToAttributeNs,
"xmlTextReaderMoveToAttributeNs");
function xmlTextReaderMoveToFirstAttribute (reader : access xmlTextReader)
return signed_int;
pragma Import (C, xmlTextReaderMoveToFirstAttribute,
"xmlTextReaderMoveToFirstAttribute");
function xmlTextReaderMoveToNextAttribute (reader : access xmlTextReader)
return signed_int;
pragma Import (C, xmlTextReaderMoveToNextAttribute,
"xmlTextReaderMoveToNextAttribute");
function xmlTextReaderMoveToElement (reader : access xmlTextReader)
return signed_int;
pragma Import (C, xmlTextReaderMoveToElement,
"xmlTextReaderMoveToElement");
function xmlTextReaderNormalization (reader : access xmlTextReader)
return signed_int;
pragma Import (C, xmlTextReaderNormalization,
"xmlTextReaderNormalization");
function xmlTextReaderConstEncoding (reader : access xmlTextReader)
return xmlstring.xmlChar_const_ptr;
pragma Import (C, xmlTextReaderConstEncoding,
"xmlTextReaderConstEncoding");
function xmlTextReaderSetParserProp (reader : access xmlTextReader;
prop : signed_int; value : signed_int) return signed_int;
pragma Import (C, xmlTextReaderSetParserProp,
"xmlTextReaderSetParserProp");
function xmlTextReaderGetParserProp (reader : access xmlTextReader;
prop : signed_int) return signed_int;
pragma Import (C, xmlTextReaderGetParserProp,
"xmlTextReaderGetParserProp");
function xmlTextReaderCurrentNode (reader : access xmlTextReader)
return tree.xmlNodePtr;
pragma Import (C, xmlTextReaderCurrentNode, "xmlTextReaderCurrentNode");
function xmlTextReaderGetParserLineNumber (reader : access xmlTextReader)
return signed_int;
pragma Import (C, xmlTextReaderGetParserLineNumber,
"xmlTextReaderGetParserLineNumber");
function xmlTextReaderGetParserColumnNumber (
reader : access xmlTextReader) return signed_int;
pragma Import (C, xmlTextReaderGetParserColumnNumber,
"xmlTextReaderGetParserColumnNumber");
function xmlTextReaderPreserve (reader : access xmlTextReader)
return tree.xmlNodePtr;
pragma Import (C, xmlTextReaderPreserve, "xmlTextReaderPreserve");
function xmlTextReaderPreservePattern (reader : access xmlTextReader;
pattern : access constant xmlstring.xmlChar;
namespaces : access xmlstring.xmlChar_const_ptr) return signed_int;
pragma Import (C, xmlTextReaderPreservePattern,
"xmlTextReaderPreservePattern");
function xmlTextReaderCurrentDoc (reader : access xmlTextReader)
return tree.xmlDocPtr;
pragma Import (C, xmlTextReaderCurrentDoc, "xmlTextReaderCurrentDoc");
function xmlTextReaderExpand (reader : access xmlTextReader)
return tree.xmlNodePtr;
pragma Import (C, xmlTextReaderExpand, "xmlTextReaderExpand");
function xmlTextReaderNext (reader : access xmlTextReader)
return signed_int;
pragma Import (C, xmlTextReaderNext, "xmlTextReaderNext");
function xmlTextReaderNextSibling (reader : access xmlTextReader)
return signed_int;
pragma Import (C, xmlTextReaderNextSibling, "xmlTextReaderNextSibling");
function xmlTextReaderIsValid (reader : access xmlTextReader)
return signed_int;
pragma Import (C, xmlTextReaderIsValid, "xmlTextReaderIsValid");
function xmlTextReaderRelaxNGValidate (reader : access xmlTextReader;
rng : access constant char) return signed_int;
pragma Import (C, xmlTextReaderRelaxNGValidate,
"xmlTextReaderRelaxNGValidate");
function xmlTextReaderRelaxNGValidateCtxt (reader : access xmlTextReader;
ctxt : access relaxng.xmlRelaxNGValidCtxt; options : signed_int)
return signed_int;
pragma Import (C, xmlTextReaderRelaxNGValidateCtxt,
"xmlTextReaderRelaxNGValidateCtxt");
function xmlTextReaderRelaxNGSetSchema (reader : access xmlTextReader;
schema : access relaxng.xmlRelaxNG) return signed_int;
pragma Import (C, xmlTextReaderRelaxNGSetSchema,
"xmlTextReaderRelaxNGSetSchema");
function xmlTextReaderSchemaValidate (reader : access xmlTextReader;
xsd : access constant char) return signed_int;
pragma Import (C, xmlTextReaderSchemaValidate,
"xmlTextReaderSchemaValidate");
function xmlTextReaderSchemaValidateCtxt (reader : access xmlTextReader;
ctxt : access xmlschemas.xmlSchemaValidCtxt; options : signed_int)
return signed_int;
pragma Import (C, xmlTextReaderSchemaValidateCtxt,
"xmlTextReaderSchemaValidateCtxt");
function xmlTextReaderSetSchema (reader : access xmlTextReader;
schema : access xmlschemas.xmlSchema) return signed_int;
pragma Import (C, xmlTextReaderSetSchema, "xmlTextReaderSetSchema");
function xmlTextReaderConstXmlVersion (reader : access xmlTextReader)
return xmlstring.xmlChar_const_ptr;
pragma Import (C, xmlTextReaderConstXmlVersion,
"xmlTextReaderConstXmlVersion");
function xmlTextReaderStandalone (reader : access xmlTextReader)
return signed_int;
pragma Import (C, xmlTextReaderStandalone, "xmlTextReaderStandalone");
function xmlTextReaderByteConsumed (reader : access xmlTextReader)
return signed_long;
pragma Import (C, xmlTextReaderByteConsumed, "xmlTextReaderByteConsumed");
function xmlReaderWalker (doc : access tree.xmlDoc)
return xmlTextReaderPtr;
pragma Import (C, xmlReaderWalker, "xmlReaderWalker");
function xmlReaderForDoc (cur : access constant xmlstring.xmlChar;
URL : access constant char; encoding : access constant char;
options : signed_int) return xmlTextReaderPtr;
pragma Import (C, xmlReaderForDoc, "xmlReaderForDoc");
function xmlReaderForFile (filename : access constant char;
encoding : access constant char; options : signed_int)
return xmlTextReaderPtr;
pragma Import (C, xmlReaderForFile, "xmlReaderForFile");
function xmlReaderForMemory (buffer : access constant char;
size : signed_int; URL : access constant char;
encoding : access constant char; options : signed_int)
return xmlTextReaderPtr;
pragma Import (C, xmlReaderForMemory, "xmlReaderForMemory");
function xmlReaderForFd (fd : signed_int; URL : access constant char;
encoding : access constant char; options : signed_int)
return xmlTextReaderPtr;
pragma Import (C, xmlReaderForFd, "xmlReaderForFd");
function xmlReaderForIO (ioread : xmlIO.xmlInputReadCallback;
ioclose : xmlIO.xmlInputCloseCallback; ioctx : void_ptr;
URL : access constant char; encoding : access constant char;
options : signed_int) return xmlTextReaderPtr;
pragma Import (C, xmlReaderForIO, "xmlReaderForIO");
function xmlReaderNewWalker (reader : access xmlTextReader;
doc : access tree.xmlDoc) return signed_int;
pragma Import (C, xmlReaderNewWalker, "xmlReaderNewWalker");
function xmlReaderNewDoc (reader : access xmlTextReader;
cur : access constant xmlstring.xmlChar; URL : access constant char;
encoding : access constant char; options : signed_int)
return signed_int;
pragma Import (C, xmlReaderNewDoc, "xmlReaderNewDoc");
function xmlReaderNewFile (reader : access xmlTextReader;
filename : access constant char; encoding : access constant char;
options : signed_int) return signed_int;
pragma Import (C, xmlReaderNewFile, "xmlReaderNewFile");
function xmlReaderNewMemory (reader : access xmlTextReader;
buffer : access constant char; size : signed_int;
URL : access constant char; encoding : access constant char;
options : signed_int) return signed_int;
pragma Import (C, xmlReaderNewMemory, "xmlReaderNewMemory");
function xmlReaderNewFd (reader : access xmlTextReader; fd : signed_int;
URL : access constant char; encoding : access constant char;
options : signed_int) return signed_int;
pragma Import (C, xmlReaderNewFd, "xmlReaderNewFd");
function xmlReaderNewIO (reader : access xmlTextReader;
ioread : xmlIO.xmlInputReadCallback;
ioclose : xmlIO.xmlInputCloseCallback; ioctx : void_ptr;
URL : access constant char; encoding : access constant char;
options : signed_int) return signed_int;
pragma Import (C, xmlReaderNewIO, "xmlReaderNewIO");
subtype xmlTextReaderLocatorPtr is void_ptr;
type access_2f39ad43 is access procedure (arg : void_ptr;
msg : access constant char; severity : xmlParserSeverities;
locator : xmlTextReaderLocatorPtr);
pragma Convention (C, access_2f39ad43);
type access_2f39ad43_ptr is access all access_2f39ad43;
for access_2f39ad43_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (access_2f39ad43_ptr);
pragma Convention (C, access_2f39ad43_ptr);
subtype xmlTextReaderErrorFunc is access_2f39ad43;
subtype xmlTextReaderErrorFunc_ptr is access_2f39ad43_ptr;
function xmlTextReaderLocatorLineNumber (
locator : xmlTextReaderLocatorPtr) return signed_int;
pragma Import (C, xmlTextReaderLocatorLineNumber,
"xmlTextReaderLocatorLineNumber");
function xmlTextReaderLocatorBaseURI (locator : xmlTextReaderLocatorPtr)
return xmlstring.xmlChar_ptr;
pragma Import (C, xmlTextReaderLocatorBaseURI,
"xmlTextReaderLocatorBaseURI");
procedure xmlTextReaderSetErrorHandler (reader : access xmlTextReader;
f : xmlTextReaderErrorFunc; arg : void_ptr);
pragma Import (C, xmlTextReaderSetErrorHandler,
"xmlTextReaderSetErrorHandler");
procedure xmlTextReaderSetStructuredErrorHandler (
reader : access xmlTextReader; f : xmlerror.xmlStructuredErrorFunc;
arg : void_ptr);
pragma Import (C, xmlTextReaderSetStructuredErrorHandler,
"xmlTextReaderSetStructuredErrorHandler");
procedure xmlTextReaderGetErrorHandler (reader : access xmlTextReader;
f : access xmlTextReaderErrorFunc; arg : access void_ptr);
pragma Import (C, xmlTextReaderGetErrorHandler,
"xmlTextReaderGetErrorHandler");
-- __XML_XMLREADER_H__ (empty)
private
type struct_xmlTextReader is null record;
end C.libxml.xmlreader;
Raw
c-libxml-xmlregexp.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.libxml.xmlstring;
with C.stdio;
package C.libxml.xmlregexp is
pragma Preelaborate;
type struct_xmlRegexp (<>) is limited private;
type struct_xmlRegexp_ptr is access all struct_xmlRegexp;
for struct_xmlRegexp_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlRegexp_ptr);
pragma Convention (C, struct_xmlRegexp_ptr);
subtype xmlRegexp is struct_xmlRegexp;
subtype xmlRegexp_ptr is struct_xmlRegexp_ptr;
subtype xmlRegexpPtr is xmlRegexp_ptr;
type struct_xmlRegExecCtxt (<>) is limited private;
type struct_xmlRegExecCtxt_ptr is access all struct_xmlRegExecCtxt;
for struct_xmlRegExecCtxt_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlRegExecCtxt_ptr);
pragma Convention (C, struct_xmlRegExecCtxt_ptr);
subtype xmlRegExecCtxt is struct_xmlRegExecCtxt;
subtype xmlRegExecCtxt_ptr is struct_xmlRegExecCtxt_ptr;
subtype xmlRegExecCtxtPtr is xmlRegExecCtxt_ptr;
-- #include <libxml/dict.h>
function xmlRegexpCompile (regexp : access constant xmlstring.xmlChar)
return xmlRegexpPtr;
pragma Import (C, xmlRegexpCompile, "xmlRegexpCompile");
procedure xmlRegFreeRegexp (regexp : access xmlRegexp);
pragma Import (C, xmlRegFreeRegexp, "xmlRegFreeRegexp");
function xmlRegexpExec (comp : access xmlRegexp;
value : access constant xmlstring.xmlChar) return signed_int;
pragma Import (C, xmlRegexpExec, "xmlRegexpExec");
procedure xmlRegexpPrint (output : access stdio.FILE;
regexp : access xmlRegexp);
pragma Import (C, xmlRegexpPrint, "xmlRegexpPrint");
function xmlRegexpIsDeterminist (comp : access xmlRegexp)
return signed_int;
pragma Import (C, xmlRegexpIsDeterminist, "xmlRegexpIsDeterminist");
type access_6b4a8a76 is access procedure (exec : access xmlRegExecCtxt;
token : access constant xmlstring.xmlChar; transdata : void_ptr;
inputdata : void_ptr);
pragma Convention (C, access_6b4a8a76);
subtype xmlRegExecCallbacks is access_6b4a8a76;
function xmlRegNewExecCtxt (comp : access xmlRegexp;
callback : xmlRegExecCallbacks; data : void_ptr)
return xmlRegExecCtxtPtr;
pragma Import (C, xmlRegNewExecCtxt, "xmlRegNewExecCtxt");
procedure xmlRegFreeExecCtxt (exec : access xmlRegExecCtxt);
pragma Import (C, xmlRegFreeExecCtxt, "xmlRegFreeExecCtxt");
function xmlRegExecPushString (exec : access xmlRegExecCtxt;
value : access constant xmlstring.xmlChar; data : void_ptr)
return signed_int;
pragma Import (C, xmlRegExecPushString, "xmlRegExecPushString");
function xmlRegExecPushString2 (exec : access xmlRegExecCtxt;
value : access constant xmlstring.xmlChar;
value2 : access constant xmlstring.xmlChar; data : void_ptr)
return signed_int;
pragma Import (C, xmlRegExecPushString2, "xmlRegExecPushString2");
function xmlRegExecNextValues (exec : access xmlRegExecCtxt;
nbval : access signed_int; nbneg : access signed_int;
values : access xmlstring.xmlChar_ptr; terminal : access signed_int)
return signed_int;
pragma Import (C, xmlRegExecNextValues, "xmlRegExecNextValues");
function xmlRegExecErrInfo (exec : access xmlRegExecCtxt;
string : access xmlstring.xmlChar_const_ptr; nbval : access signed_int;
nbneg : access signed_int; values : access xmlstring.xmlChar_ptr;
terminal : access signed_int) return signed_int;
pragma Import (C, xmlRegExecErrInfo, "xmlRegExecErrInfo");
-- __XML_REGEXP_H__ (empty)
private
type struct_xmlRegexp is null record;
type struct_xmlRegExecCtxt is null record;
end C.libxml.xmlregexp;
Raw
c-libxml-xmlschemas.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.libxml.encoding;
limited with C.libxml.parser;
with C.libxml.tree;
limited with C.libxml.xmlIO;
with C.libxml.xmlerror;
with C.stdio;
package C.libxml.xmlschemas is
pragma Preelaborate;
type enum_ed2b3269 is (XML_SCHEMAS_ERR_OK, XML_SCHEMAS_ERR_NOROOT,
XML_SCHEMAS_ERR_UNDECLAREDELEM, XML_SCHEMAS_ERR_NOTTOPLEVEL,
XML_SCHEMAS_ERR_MISSING, XML_SCHEMAS_ERR_WRONGELEM,
XML_SCHEMAS_ERR_NOTYPE, XML_SCHEMAS_ERR_NOROLLBACK,
XML_SCHEMAS_ERR_ISABSTRACT, XML_SCHEMAS_ERR_NOTEMPTY,
XML_SCHEMAS_ERR_ELEMCONT, XML_SCHEMAS_ERR_HAVEDEFAULT,
XML_SCHEMAS_ERR_NOTNILLABLE, XML_SCHEMAS_ERR_EXTRACONTENT,
XML_SCHEMAS_ERR_INVALIDATTR, XML_SCHEMAS_ERR_INVALIDELEM,
XML_SCHEMAS_ERR_NOTDETERMINIST, XML_SCHEMAS_ERR_CONSTRUCT,
XML_SCHEMAS_ERR_INTERNAL, XML_SCHEMAS_ERR_NOTSIMPLE,
XML_SCHEMAS_ERR_ATTRUNKNOWN, XML_SCHEMAS_ERR_ATTRINVALID,
XML_SCHEMAS_ERR_VALUE, XML_SCHEMAS_ERR_FACET, XML_SCHEMAS_ERR,
XML_SCHEMAS_ERR_XXX);
for enum_ed2b3269 use (XML_SCHEMAS_ERR_OK => 0,
XML_SCHEMAS_ERR_NOROOT => 1, XML_SCHEMAS_ERR_UNDECLAREDELEM => 2,
XML_SCHEMAS_ERR_NOTTOPLEVEL => 3, XML_SCHEMAS_ERR_MISSING => 4,
XML_SCHEMAS_ERR_WRONGELEM => 5, XML_SCHEMAS_ERR_NOTYPE => 6,
XML_SCHEMAS_ERR_NOROLLBACK => 7, XML_SCHEMAS_ERR_ISABSTRACT => 8,
XML_SCHEMAS_ERR_NOTEMPTY => 9, XML_SCHEMAS_ERR_ELEMCONT => 10,
XML_SCHEMAS_ERR_HAVEDEFAULT => 11, XML_SCHEMAS_ERR_NOTNILLABLE => 12,
XML_SCHEMAS_ERR_EXTRACONTENT => 13, XML_SCHEMAS_ERR_INVALIDATTR => 14,
XML_SCHEMAS_ERR_INVALIDELEM => 15,
XML_SCHEMAS_ERR_NOTDETERMINIST => 16, XML_SCHEMAS_ERR_CONSTRUCT => 17,
XML_SCHEMAS_ERR_INTERNAL => 18, XML_SCHEMAS_ERR_NOTSIMPLE => 19,
XML_SCHEMAS_ERR_ATTRUNKNOWN => 20, XML_SCHEMAS_ERR_ATTRINVALID => 21,
XML_SCHEMAS_ERR_VALUE => 22, XML_SCHEMAS_ERR_FACET => 23,
XML_SCHEMAS_ERR => 24, XML_SCHEMAS_ERR_XXX => 25);
pragma Convention (C, enum_ed2b3269);
subtype xmlSchemaValidError is enum_ed2b3269;
type enum_b859647d is (XML_SCHEMA_VAL_VC_I_CREATE);
for enum_b859647d use (XML_SCHEMA_VAL_VC_I_CREATE => 1);
pragma Convention (C, enum_b859647d);
subtype xmlSchemaValidOption is enum_b859647d;
type struct_xmlSchema (<>) is limited private;
type struct_xmlSchema_ptr is access all struct_xmlSchema;
for struct_xmlSchema_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlSchema_ptr);
pragma Convention (C, struct_xmlSchema_ptr);
subtype xmlSchema is struct_xmlSchema;
subtype xmlSchema_ptr is struct_xmlSchema_ptr;
subtype xmlSchemaPtr is xmlSchema_ptr;
type access_340fdc5c is access procedure (ctx : void_ptr;
msg : access constant char);
pragma Convention (C, access_340fdc5c);
type access_340fdc5c_ptr is access all access_340fdc5c;
for access_340fdc5c_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (access_340fdc5c_ptr);
pragma Convention (C, access_340fdc5c_ptr);
subtype xmlSchemaValidityErrorFunc is access_340fdc5c;
subtype xmlSchemaValidityErrorFunc_ptr is access_340fdc5c_ptr;
type access_320338a3 is access procedure (ctx : void_ptr;
msg : access constant char);
pragma Convention (C, access_320338a3);
type access_320338a3_ptr is access all access_320338a3;
for access_320338a3_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (access_320338a3_ptr);
pragma Convention (C, access_320338a3_ptr);
subtype xmlSchemaValidityWarningFunc is access_320338a3;
subtype xmlSchemaValidityWarningFunc_ptr is access_320338a3_ptr;
type struct_xmlSchemaParserCtxt (<>) is limited private;
type struct_xmlSchemaParserCtxt_ptr is
access all struct_xmlSchemaParserCtxt;
for struct_xmlSchemaParserCtxt_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlSchemaParserCtxt_ptr);
pragma Convention (C, struct_xmlSchemaParserCtxt_ptr);
subtype xmlSchemaParserCtxt is struct_xmlSchemaParserCtxt;
subtype xmlSchemaParserCtxt_ptr is struct_xmlSchemaParserCtxt_ptr;
subtype xmlSchemaParserCtxtPtr is xmlSchemaParserCtxt_ptr;
type struct_xmlSchemaValidCtxt (<>) is limited private;
type struct_xmlSchemaValidCtxt_ptr is
access all struct_xmlSchemaValidCtxt;
for struct_xmlSchemaValidCtxt_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlSchemaValidCtxt_ptr);
pragma Convention (C, struct_xmlSchemaValidCtxt_ptr);
subtype xmlSchemaValidCtxt is struct_xmlSchemaValidCtxt;
subtype xmlSchemaValidCtxt_ptr is struct_xmlSchemaValidCtxt_ptr;
subtype xmlSchemaValidCtxtPtr is xmlSchemaValidCtxt_ptr;
type access_1f54d218 is access function (ctx : void_ptr;
file : access char_const_ptr; line : access unsigned_long)
return signed_int;
pragma Convention (C, access_1f54d218);
subtype xmlSchemaValidityLocatorFunc is access_1f54d218;
function xmlSchemaNewParserCtxt (URL : access constant char)
return xmlSchemaParserCtxtPtr;
pragma Import (C, xmlSchemaNewParserCtxt, "xmlSchemaNewParserCtxt");
function xmlSchemaNewMemParserCtxt (buffer : access constant char;
size : signed_int) return xmlSchemaParserCtxtPtr;
pragma Import (C, xmlSchemaNewMemParserCtxt, "xmlSchemaNewMemParserCtxt");
function xmlSchemaNewDocParserCtxt (doc : access tree.xmlDoc)
return xmlSchemaParserCtxtPtr;
pragma Import (C, xmlSchemaNewDocParserCtxt, "xmlSchemaNewDocParserCtxt");
procedure xmlSchemaFreeParserCtxt (ctxt : access xmlSchemaParserCtxt);
pragma Import (C, xmlSchemaFreeParserCtxt, "xmlSchemaFreeParserCtxt");
procedure xmlSchemaSetParserErrors (ctxt : access xmlSchemaParserCtxt;
err : xmlSchemaValidityErrorFunc; warn : xmlSchemaValidityWarningFunc;
ctx : void_ptr);
pragma Import (C, xmlSchemaSetParserErrors, "xmlSchemaSetParserErrors");
procedure xmlSchemaSetParserStructuredErrors (
ctxt : access xmlSchemaParserCtxt;
serror : xmlerror.xmlStructuredErrorFunc; ctx : void_ptr);
pragma Import (C, xmlSchemaSetParserStructuredErrors,
"xmlSchemaSetParserStructuredErrors");
function xmlSchemaGetParserErrors (ctxt : access xmlSchemaParserCtxt;
err : access xmlSchemaValidityErrorFunc;
warn : access xmlSchemaValidityWarningFunc; ctx : access void_ptr)
return signed_int;
pragma Import (C, xmlSchemaGetParserErrors, "xmlSchemaGetParserErrors");
function xmlSchemaIsValid (ctxt : access xmlSchemaValidCtxt)
return signed_int;
pragma Import (C, xmlSchemaIsValid, "xmlSchemaIsValid");
function xmlSchemaParse (ctxt : access xmlSchemaParserCtxt)
return xmlSchemaPtr;
pragma Import (C, xmlSchemaParse, "xmlSchemaParse");
procedure xmlSchemaFree (schema : access xmlSchema);
pragma Import (C, xmlSchemaFree, "xmlSchemaFree");
procedure xmlSchemaDump (output : access stdio.FILE;
schema : access xmlSchema);
pragma Import (C, xmlSchemaDump, "xmlSchemaDump");
procedure xmlSchemaSetValidErrors (ctxt : access xmlSchemaValidCtxt;
err : xmlSchemaValidityErrorFunc; warn : xmlSchemaValidityWarningFunc;
ctx : void_ptr);
pragma Import (C, xmlSchemaSetValidErrors, "xmlSchemaSetValidErrors");
procedure xmlSchemaSetValidStructuredErrors (
ctxt : access xmlSchemaValidCtxt;
serror : xmlerror.xmlStructuredErrorFunc; ctx : void_ptr);
pragma Import (C, xmlSchemaSetValidStructuredErrors,
"xmlSchemaSetValidStructuredErrors");
function xmlSchemaGetValidErrors (ctxt : access xmlSchemaValidCtxt;
err : access xmlSchemaValidityErrorFunc;
warn : access xmlSchemaValidityWarningFunc; ctx : access void_ptr)
return signed_int;
pragma Import (C, xmlSchemaGetValidErrors, "xmlSchemaGetValidErrors");
function xmlSchemaSetValidOptions (ctxt : access xmlSchemaValidCtxt;
options : signed_int) return signed_int;
pragma Import (C, xmlSchemaSetValidOptions, "xmlSchemaSetValidOptions");
procedure xmlSchemaValidateSetFilename (vctxt : access xmlSchemaValidCtxt;
filename : access constant char);
pragma Import (C, xmlSchemaValidateSetFilename,
"xmlSchemaValidateSetFilename");
function xmlSchemaValidCtxtGetOptions (ctxt : access xmlSchemaValidCtxt)
return signed_int;
pragma Import (C, xmlSchemaValidCtxtGetOptions,
"xmlSchemaValidCtxtGetOptions");
function xmlSchemaNewValidCtxt (schema : access xmlSchema)
return xmlSchemaValidCtxtPtr;
pragma Import (C, xmlSchemaNewValidCtxt, "xmlSchemaNewValidCtxt");
procedure xmlSchemaFreeValidCtxt (ctxt : access xmlSchemaValidCtxt);
pragma Import (C, xmlSchemaFreeValidCtxt, "xmlSchemaFreeValidCtxt");
function xmlSchemaValidateDoc (ctxt : access xmlSchemaValidCtxt;
instance : access tree.xmlDoc) return signed_int;
pragma Import (C, xmlSchemaValidateDoc, "xmlSchemaValidateDoc");
function xmlSchemaValidateOneElement (ctxt : access xmlSchemaValidCtxt;
elem : access tree.xmlNode) return signed_int;
pragma Import (C, xmlSchemaValidateOneElement,
"xmlSchemaValidateOneElement");
function xmlSchemaValidateStream (ctxt : access xmlSchemaValidCtxt;
input : access xmlIO.struct_xmlParserInputBuffer;
enc : encoding.xmlCharEncoding;
sax : access parser.struct_xmlSAXHandler; user_data : void_ptr)
return signed_int;
pragma Import (C, xmlSchemaValidateStream, "xmlSchemaValidateStream");
function xmlSchemaValidateFile (ctxt : access xmlSchemaValidCtxt;
filename : access constant char; options : signed_int)
return signed_int;
pragma Import (C, xmlSchemaValidateFile, "xmlSchemaValidateFile");
function xmlSchemaValidCtxtGetParserCtxt (
ctxt : access xmlSchemaValidCtxt) return tree.xmlParserCtxtPtr;
pragma Import (C, xmlSchemaValidCtxtGetParserCtxt,
"xmlSchemaValidCtxtGetParserCtxt");
type struct_xmlSchemaSAXPlug (<>) is limited private;
type struct_xmlSchemaSAXPlug_ptr is access all struct_xmlSchemaSAXPlug;
for struct_xmlSchemaSAXPlug_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlSchemaSAXPlug_ptr);
pragma Convention (C, struct_xmlSchemaSAXPlug_ptr);
subtype xmlSchemaSAXPlugStruct is struct_xmlSchemaSAXPlug;
subtype xmlSchemaSAXPlugStruct_ptr is struct_xmlSchemaSAXPlug_ptr;
subtype xmlSchemaSAXPlugPtr is xmlSchemaSAXPlugStruct_ptr;
function xmlSchemaSAXPlug (ctxt : access xmlSchemaValidCtxt;
sax : access tree.xmlSAXHandlerPtr; user_data : access void_ptr)
return xmlSchemaSAXPlugPtr;
pragma Import (C, xmlSchemaSAXPlug, "xmlSchemaSAXPlug");
function xmlSchemaSAXUnplug (plug : access xmlSchemaSAXPlugStruct)
return signed_int;
pragma Import (C, xmlSchemaSAXUnplug, "xmlSchemaSAXUnplug");
procedure xmlSchemaValidateSetLocator (vctxt : access xmlSchemaValidCtxt;
f : xmlSchemaValidityLocatorFunc; ctxt : void_ptr);
pragma Import (C, xmlSchemaValidateSetLocator,
"xmlSchemaValidateSetLocator");
-- __XML_SCHEMA_H__ (empty)
private
type struct_xmlSchema is null record;
type struct_xmlSchemaParserCtxt is null record;
type struct_xmlSchemaValidCtxt is null record;
type struct_xmlSchemaSAXPlug is null record;
end C.libxml.xmlschemas;
Raw
c-libxml-xmlstring.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.stdio;
package C.libxml.xmlstring is
pragma Preelaborate;
subtype xmlChar is unsigned_char;
subtype xmlChar_ptr is unsigned_char_ptr;
subtype xmlChar_ptr_ptr is unsigned_char_ptr_ptr;
subtype xmlChar_ptr_const_ptr is unsigned_char_ptr_const_ptr;
subtype xmlChar_const_ptr is unsigned_char_const_ptr;
subtype xmlChar_const_ptr_ptr is unsigned_char_const_ptr_ptr;
function xmlStrdup (cur : access constant xmlChar) return xmlChar_ptr;
pragma Import (C, xmlStrdup, "xmlStrdup");
function xmlStrndup (cur : access constant xmlChar; len : signed_int)
return xmlChar_ptr;
pragma Import (C, xmlStrndup, "xmlStrndup");
function xmlCharStrndup (cur : access constant char; len : signed_int)
return xmlChar_ptr;
pragma Import (C, xmlCharStrndup, "xmlCharStrndup");
function xmlCharStrdup (cur : access constant char) return xmlChar_ptr;
pragma Import (C, xmlCharStrdup, "xmlCharStrdup");
function xmlStrsub (str : access constant xmlChar; start : signed_int;
len : signed_int) return xmlChar_ptr;
pragma Import (C, xmlStrsub, "xmlStrsub");
function xmlStrchr (str : access constant xmlChar; val : xmlChar)
return xmlChar_const_ptr;
pragma Import (C, xmlStrchr, "xmlStrchr");
function xmlStrstr (str : access constant xmlChar;
val : access constant xmlChar) return xmlChar_const_ptr;
pragma Import (C, xmlStrstr, "xmlStrstr");
function xmlStrcasestr (str : access constant xmlChar;
val : access constant xmlChar) return xmlChar_const_ptr;
pragma Import (C, xmlStrcasestr, "xmlStrcasestr");
function xmlStrcmp (str1 : access constant xmlChar;
str2 : access constant xmlChar) return signed_int;
pragma Import (C, xmlStrcmp, "xmlStrcmp");
function xmlStrncmp (str1 : access constant xmlChar;
str2 : access constant xmlChar; len : signed_int) return signed_int;
pragma Import (C, xmlStrncmp, "xmlStrncmp");
function xmlStrcasecmp (str1 : access constant xmlChar;
str2 : access constant xmlChar) return signed_int;
pragma Import (C, xmlStrcasecmp, "xmlStrcasecmp");
function xmlStrncasecmp (str1 : access constant xmlChar;
str2 : access constant xmlChar; len : signed_int) return signed_int;
pragma Import (C, xmlStrncasecmp, "xmlStrncasecmp");
function xmlStrEqual (str1 : access constant xmlChar;
str2 : access constant xmlChar) return signed_int;
pragma Import (C, xmlStrEqual, "xmlStrEqual");
function xmlStrQEqual (pref : access constant xmlChar;
name : access constant xmlChar; str : access constant xmlChar)
return signed_int;
pragma Import (C, xmlStrQEqual, "xmlStrQEqual");
function xmlStrlen (str : access constant xmlChar) return signed_int;
pragma Import (C, xmlStrlen, "xmlStrlen");
function xmlStrcat (cur : access xmlChar; add : access constant xmlChar)
return xmlChar_ptr;
pragma Import (C, xmlStrcat, "xmlStrcat");
function xmlStrncat (cur : access xmlChar; add : access constant xmlChar;
len : signed_int) return xmlChar_ptr;
pragma Import (C, xmlStrncat, "xmlStrncat");
function xmlStrncatNew (str1 : access constant xmlChar;
str2 : access constant xmlChar; len : signed_int) return xmlChar_ptr;
pragma Import (C, xmlStrncatNew, "xmlStrncatNew");
function xmlStrPrintf (buf : access xmlChar; len : signed_int;
msg : access constant char) return signed_int;
pragma Import (C, xmlStrPrintf, "xmlStrPrintf");
function xmlStrVPrintf (buf : access xmlChar; len : signed_int;
msg : access constant char; ap : stdio.va_list) return signed_int;
pragma Import (C, xmlStrVPrintf, "xmlStrVPrintf");
function xmlGetUTF8Char (utf : access constant unsigned_char;
len : access signed_int) return signed_int;
pragma Import (C, xmlGetUTF8Char, "xmlGetUTF8Char");
function xmlCheckUTF8 (utf : access constant unsigned_char)
return signed_int;
pragma Import (C, xmlCheckUTF8, "xmlCheckUTF8");
function xmlUTF8Strsize (utf : access constant xmlChar; len : signed_int)
return signed_int;
pragma Import (C, xmlUTF8Strsize, "xmlUTF8Strsize");
function xmlUTF8Strndup (utf : access constant xmlChar; len : signed_int)
return xmlChar_ptr;
pragma Import (C, xmlUTF8Strndup, "xmlUTF8Strndup");
function xmlUTF8Strpos (utf : access constant xmlChar; pos : signed_int)
return xmlChar_const_ptr;
pragma Import (C, xmlUTF8Strpos, "xmlUTF8Strpos");
function xmlUTF8Strloc (utf : access constant xmlChar;
utfchar : access constant xmlChar) return signed_int;
pragma Import (C, xmlUTF8Strloc, "xmlUTF8Strloc");
function xmlUTF8Strsub (utf : access constant xmlChar; start : signed_int;
len : signed_int) return xmlChar_ptr;
pragma Import (C, xmlUTF8Strsub, "xmlUTF8Strsub");
function xmlUTF8Strlen (utf : access constant xmlChar) return signed_int;
pragma Import (C, xmlUTF8Strlen, "xmlUTF8Strlen");
function xmlUTF8Size (utf : access constant xmlChar) return signed_int;
pragma Import (C, xmlUTF8Size, "xmlUTF8Size");
function xmlUTF8Charcmp (utf1 : access constant xmlChar;
utf2 : access constant xmlChar) return signed_int;
pragma Import (C, xmlUTF8Charcmp, "xmlUTF8Charcmp");
-- BAD_CAST (unparsible)
-- __XML_STRING_H__ (empty)
end C.libxml.xmlstring;
Raw
c-libxml-xmlversion.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.libxml.xmlversion is
pragma Preelaborate;
procedure xmlCheckVersion (version : signed_int);
pragma Import (C, xmlCheckVersion, "xmlCheckVersion");
-- ATTRIBUTE_UNUSED (attribute)
-- LIBXML_ATTR_ALLOC_SIZE (parameterized declaration-specifiers)
-- LIBXML_ATTR_FORMAT (parameterized declaration-specifiers)
-- LIBXML_AUTOMATA_ENABLED (empty)
-- LIBXML_C14N_ENABLED (empty)
-- LIBXML_CATALOG_ENABLED (empty)
-- LIBXML_DEBUG_ENABLED (empty)
-- LIBXML_DOCB_ENABLED (empty)
LIBXML_DOTTED_VERSION : constant char_array (0 .. 5) := "2.9.4"
& char'Val (0);
-- LIBXML_FTP_ENABLED (empty)
-- LIBXML_HTML_ENABLED (empty)
-- LIBXML_HTTP_ENABLED (empty)
-- LIBXML_ICONV_ENABLED (empty)
-- LIBXML_ISO8859X_ENABLED (empty)
-- LIBXML_LEGACY_ENABLED (empty)
-- LIBXML_LZMA_ENABLED (empty)
-- LIBXML_MODULES_ENABLED (empty)
LIBXML_MODULE_EXTENSION : constant char_array (0 .. 3) := ".so"
& char'Val (0);
-- LIBXML_OUTPUT_ENABLED (empty)
-- LIBXML_PATTERN_ENABLED (empty)
-- LIBXML_PUSH_ENABLED (empty)
-- LIBXML_READER_ENABLED (empty)
-- LIBXML_REGEXP_ENABLED (empty)
-- LIBXML_SAX1_ENABLED (empty)
-- LIBXML_SCHEMAS_ENABLED (empty)
-- LIBXML_SCHEMATRON_ENABLED (empty)
-- LIBXML_TEST_VERSION (unparsible)
-- LIBXML_THREAD_ENABLED (empty)
-- LIBXML_TREE_ENABLED (empty)
-- LIBXML_UNICODE_ENABLED (empty)
-- LIBXML_VALID_ENABLED (empty)
LIBXML_VERSION : constant := 20904;
LIBXML_VERSION_EXTRA : constant char_array (0 .. 0) :=
(0 => char'Val (0));
LIBXML_VERSION_STRING : constant char_array (0 .. 5) := "20904"
& char'Val (0);
-- LIBXML_WRITER_ENABLED (empty)
-- LIBXML_XINCLUDE_ENABLED (empty)
-- LIBXML_XPATH_ENABLED (empty)
-- LIBXML_XPTR_ENABLED (empty)
-- LIBXML_ZLIB_ENABLED (empty)
-- WITHOUT_TRIO (empty)
-- __XML_VERSION_H__ (empty)
end C.libxml.xmlversion;
Raw
c-libxml-xmlwriter.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.
-------------------------------------------------------------------------------
limited with C.libxml.parser;
with C.libxml.tree;
limited with C.libxml.xmlIO;
with C.libxml.xmlstring;
with C.stdio;
package C.libxml.xmlwriter is
pragma Preelaborate;
type struct_xmlTextWriter (<>) is limited private;
type struct_xmlTextWriter_ptr is access all struct_xmlTextWriter;
for struct_xmlTextWriter_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (struct_xmlTextWriter_ptr);
pragma Convention (C, struct_xmlTextWriter_ptr);
subtype xmlTextWriter is struct_xmlTextWriter;
subtype xmlTextWriter_ptr is struct_xmlTextWriter_ptr;
subtype xmlTextWriterPtr is xmlTextWriter_ptr;
function xmlNewTextWriter (A_out : access xmlIO.struct_xmlOutputBuffer)
return xmlTextWriterPtr;
pragma Import (C, xmlNewTextWriter, "xmlNewTextWriter");
function xmlNewTextWriterFilename (uri : access constant char;
compression : signed_int) return xmlTextWriterPtr;
pragma Import (C, xmlNewTextWriterFilename, "xmlNewTextWriterFilename");
function xmlNewTextWriterMemory (buf : access tree.xmlBuffer;
compression : signed_int) return xmlTextWriterPtr;
pragma Import (C, xmlNewTextWriterMemory, "xmlNewTextWriterMemory");
function xmlNewTextWriterPushParser (
ctxt : access parser.struct_xmlParserCtxt; compression : signed_int)
return xmlTextWriterPtr;
pragma Import (C, xmlNewTextWriterPushParser,
"xmlNewTextWriterPushParser");
function xmlNewTextWriterDoc (doc : access tree.xmlDocPtr;
compression : signed_int) return xmlTextWriterPtr;
pragma Import (C, xmlNewTextWriterDoc, "xmlNewTextWriterDoc");
function xmlNewTextWriterTree (doc : access tree.xmlDoc;
node : access tree.xmlNode; compression : signed_int)
return xmlTextWriterPtr;
pragma Import (C, xmlNewTextWriterTree, "xmlNewTextWriterTree");
procedure xmlFreeTextWriter (writer : access xmlTextWriter);
pragma Import (C, xmlFreeTextWriter, "xmlFreeTextWriter");
function xmlTextWriterStartDocument (writer : access xmlTextWriter;
version : access constant char; encoding : access constant char;
standalone : access constant char) return signed_int;
pragma Import (C, xmlTextWriterStartDocument,
"xmlTextWriterStartDocument");
function xmlTextWriterEndDocument (writer : access xmlTextWriter)
return signed_int;
pragma Import (C, xmlTextWriterEndDocument, "xmlTextWriterEndDocument");
function xmlTextWriterStartComment (writer : access xmlTextWriter)
return signed_int;
pragma Import (C, xmlTextWriterStartComment, "xmlTextWriterStartComment");
function xmlTextWriterEndComment (writer : access xmlTextWriter)
return signed_int;
pragma Import (C, xmlTextWriterEndComment, "xmlTextWriterEndComment");
function xmlTextWriterWriteFormatComment (writer : access xmlTextWriter;
format : access constant char) return signed_int;
pragma Import (C, xmlTextWriterWriteFormatComment,
"xmlTextWriterWriteFormatComment");
function xmlTextWriterWriteVFormatComment (writer : access xmlTextWriter;
format : access constant char; argptr : stdio.va_list)
return signed_int;
pragma Import (C, xmlTextWriterWriteVFormatComment,
"xmlTextWriterWriteVFormatComment");
function xmlTextWriterWriteComment (writer : access xmlTextWriter;
content : access constant xmlstring.xmlChar) return signed_int;
pragma Import (C, xmlTextWriterWriteComment, "xmlTextWriterWriteComment");
function xmlTextWriterStartElement (writer : access xmlTextWriter;
name : access constant xmlstring.xmlChar) return signed_int;
pragma Import (C, xmlTextWriterStartElement, "xmlTextWriterStartElement");
function xmlTextWriterStartElementNS (writer : access xmlTextWriter;
prefix : access constant xmlstring.xmlChar;
name : access constant xmlstring.xmlChar;
namespaceURI : access constant xmlstring.xmlChar) return signed_int;
pragma Import (C, xmlTextWriterStartElementNS,
"xmlTextWriterStartElementNS");
function xmlTextWriterEndElement (writer : access xmlTextWriter)
return signed_int;
pragma Import (C, xmlTextWriterEndElement, "xmlTextWriterEndElement");
function xmlTextWriterFullEndElement (writer : access xmlTextWriter)
return signed_int;
pragma Import (C, xmlTextWriterFullEndElement,
"xmlTextWriterFullEndElement");
function xmlTextWriterWriteFormatElement (writer : access xmlTextWriter;
name : access constant xmlstring.xmlChar;
format : access constant char) return signed_int;
pragma Import (C, xmlTextWriterWriteFormatElement,
"xmlTextWriterWriteFormatElement");
function xmlTextWriterWriteVFormatElement (writer : access xmlTextWriter;
name : access constant xmlstring.xmlChar;
format : access constant char; argptr : stdio.va_list)
return signed_int;
pragma Import (C, xmlTextWriterWriteVFormatElement,
"xmlTextWriterWriteVFormatElement");
function xmlTextWriterWriteElement (writer : access xmlTextWriter;
name : access constant xmlstring.xmlChar;
content : access constant xmlstring.xmlChar) return signed_int;
pragma Import (C, xmlTextWriterWriteElement, "xmlTextWriterWriteElement");
function xmlTextWriterWriteFormatElementNS (writer : access xmlTextWriter;
prefix : access constant xmlstring.xmlChar;
name : access constant xmlstring.xmlChar;
namespaceURI : access constant xmlstring.xmlChar;
format : access constant char) return signed_int;
pragma Import (C, xmlTextWriterWriteFormatElementNS,
"xmlTextWriterWriteFormatElementNS");
function xmlTextWriterWriteVFormatElementNS (
writer : access xmlTextWriter;
prefix : access constant xmlstring.xmlChar;
name : access constant xmlstring.xmlChar;
namespaceURI : access constant xmlstring.xmlChar;
format : access constant char; argptr : stdio.va_list)
return signed_int;
pragma Import (C, xmlTextWriterWriteVFormatElementNS,
"xmlTextWriterWriteVFormatElementNS");
function xmlTextWriterWriteElementNS (writer : access xmlTextWriter;
prefix : access constant xmlstring.xmlChar;
name : access constant xmlstring.xmlChar;
namespaceURI : access constant xmlstring.xmlChar;
content : access constant xmlstring.xmlChar) return signed_int;
pragma Import (C, xmlTextWriterWriteElementNS,
"xmlTextWriterWriteElementNS");
function xmlTextWriterWriteFormatRaw (writer : access xmlTextWriter;
format : access constant char) return signed_int;
pragma Import (C, xmlTextWriterWriteFormatRaw,
"xmlTextWriterWriteFormatRaw");
function xmlTextWriterWriteVFormatRaw (writer : access xmlTextWriter;
format : access constant char; argptr : stdio.va_list)
return signed_int;
pragma Import (C, xmlTextWriterWriteVFormatRaw,
"xmlTextWriterWriteVFormatRaw");
function xmlTextWriterWriteRawLen (writer : access xmlTextWriter;
content : access constant xmlstring.xmlChar; len : signed_int)
return signed_int;
pragma Import (C, xmlTextWriterWriteRawLen, "xmlTextWriterWriteRawLen");
function xmlTextWriterWriteRaw (writer : access xmlTextWriter;
content : access constant xmlstring.xmlChar) return signed_int;
pragma Import (C, xmlTextWriterWriteRaw, "xmlTextWriterWriteRaw");
function xmlTextWriterWriteFormatString (writer : access xmlTextWriter;
format : access constant char) return signed_int;
pragma Import (C, xmlTextWriterWriteFormatString,
"xmlTextWriterWriteFormatString");
function xmlTextWriterWriteVFormatString (writer : access xmlTextWriter;
format : access constant char; argptr : stdio.va_list)
return signed_int;
pragma Import (C, xmlTextWriterWriteVFormatString,
"xmlTextWriterWriteVFormatString");
function xmlTextWriterWriteString (writer : access xmlTextWriter;
content : access constant xmlstring.xmlChar) return signed_int;
pragma Import (C, xmlTextWriterWriteString, "xmlTextWriterWriteString");
function xmlTextWriterWriteBase64 (writer : access xmlTextWriter;
data : access constant char; start : signed_int; len : signed_int)
return signed_int;
pragma Import (C, xmlTextWriterWriteBase64, "xmlTextWriterWriteBase64");
function xmlTextWriterWriteBinHex (writer : access xmlTextWriter;
data : access constant char; start : signed_int; len : signed_int)
return signed_int;
pragma Import (C, xmlTextWriterWriteBinHex, "xmlTextWriterWriteBinHex");
function xmlTextWriterStartAttribute (writer : access xmlTextWriter;
name : access constant xmlstring.xmlChar) return signed_int;
pragma Import (C, xmlTextWriterStartAttribute,
"xmlTextWriterStartAttribute");
function xmlTextWriterStartAttributeNS (writer : access xmlTextWriter;
prefix : access constant xmlstring.xmlChar;
name : access constant xmlstring.xmlChar;
namespaceURI : access constant xmlstring.xmlChar) return signed_int;
pragma Import (C, xmlTextWriterStartAttributeNS,
"xmlTextWriterStartAttributeNS");
function xmlTextWriterEndAttribute (writer : access xmlTextWriter)
return signed_int;
pragma Import (C, xmlTextWriterEndAttribute, "xmlTextWriterEndAttribute");
function xmlTextWriterWriteFormatAttribute (writer : access xmlTextWriter;
name : access constant xmlstring.xmlChar;
format : access constant char) return signed_int;
pragma Import (C, xmlTextWriterWriteFormatAttribute,
"xmlTextWriterWriteFormatAttribute");
function xmlTextWriterWriteVFormatAttribute (
writer : access xmlTextWriter;
name : access constant xmlstring.xmlChar;
format : access constant char; argptr : stdio.va_list)
return signed_int;
pragma Import (C, xmlTextWriterWriteVFormatAttribute,
"xmlTextWriterWriteVFormatAttribute");
function xmlTextWriterWriteAttribute (writer : access xmlTextWriter;
name : access constant xmlstring.xmlChar;
content : access constant xmlstring.xmlChar) return signed_int;
pragma Import (C, xmlTextWriterWriteAttribute,
"xmlTextWriterWriteAttribute");
function xmlTextWriterWriteFormatAttributeNS (
writer : access xmlTextWriter;
prefix : access constant xmlstring.xmlChar;
name : access constant xmlstring.xmlChar;
namespaceURI : access constant xmlstring.xmlChar;
format : access constant char) return signed_int;
pragma Import (C, xmlTextWriterWriteFormatAttributeNS,
"xmlTextWriterWriteFormatAttributeNS");
function xmlTextWriterWriteVFormatAttributeNS (
writer : access xmlTextWriter;
prefix : access constant xmlstring.xmlChar;
name : access constant xmlstring.xmlChar;
namespaceURI : access constant xmlstring.xmlChar;
format : access constant char; argptr : stdio.va_list)
return signed_int;
pragma Import (C, xmlTextWriterWriteVFormatAttributeNS,
"xmlTextWriterWriteVFormatAttributeNS");
function xmlTextWriterWriteAttributeNS (writer : access xmlTextWriter;
prefix : access constant xmlstring.xmlChar;
name : access constant xmlstring.xmlChar;
namespaceURI : access constant xmlstring.xmlChar;
content : access constant xmlstring.xmlChar) return signed_int;
pragma Import (C, xmlTextWriterWriteAttributeNS,
"xmlTextWriterWriteAttributeNS");
function xmlTextWriterStartPI (writer : access xmlTextWriter;
target : access constant xmlstring.xmlChar) return signed_int;
pragma Import (C, xmlTextWriterStartPI, "xmlTextWriterStartPI");
function xmlTextWriterEndPI (writer : access xmlTextWriter)
return signed_int;
pragma Import (C, xmlTextWriterEndPI, "xmlTextWriterEndPI");
function xmlTextWriterWriteFormatPI (writer : access xmlTextWriter;
target : access constant xmlstring.xmlChar;
format : access constant char) return signed_int;
pragma Import (C, xmlTextWriterWriteFormatPI,
"xmlTextWriterWriteFormatPI");
function xmlTextWriterWriteVFormatPI (writer : access xmlTextWriter;
target : access constant xmlstring.xmlChar;
format : access constant char; argptr : stdio.va_list)
return signed_int;
pragma Import (C, xmlTextWriterWriteVFormatPI,
"xmlTextWriterWriteVFormatPI");
function xmlTextWriterWritePI (writer : access xmlTextWriter;
target : access constant xmlstring.xmlChar;
content : access constant xmlstring.xmlChar) return signed_int;
pragma Import (C, xmlTextWriterWritePI, "xmlTextWriterWritePI");
function xmlTextWriterStartCDATA (writer : access xmlTextWriter)
return signed_int;
pragma Import (C, xmlTextWriterStartCDATA, "xmlTextWriterStartCDATA");
function xmlTextWriterEndCDATA (writer : access xmlTextWriter)
return signed_int;
pragma Import (C, xmlTextWriterEndCDATA, "xmlTextWriterEndCDATA");
function xmlTextWriterWriteFormatCDATA (writer : access xmlTextWriter;
format : access constant char) return signed_int;
pragma Import (C, xmlTextWriterWriteFormatCDATA,
"xmlTextWriterWriteFormatCDATA");
function xmlTextWriterWriteVFormatCDATA (writer : access xmlTextWriter;
format : access constant char; argptr : stdio.va_list)
return signed_int;
pragma Import (C, xmlTextWriterWriteVFormatCDATA,
"xmlTextWriterWriteVFormatCDATA");
function xmlTextWriterWriteCDATA (writer : access xmlTextWriter;
content : access constant xmlstring.xmlChar) return signed_int;
pragma Import (C, xmlTextWriterWriteCDATA, "xmlTextWriterWriteCDATA");
function xmlTextWriterStartDTD (writer : access xmlTextWriter;
name : access constant xmlstring.xmlChar;
pubid : access constant xmlstring.xmlChar;
sysid : access constant xmlstring.xmlChar) return signed_int;
pragma Import (C, xmlTextWriterStartDTD, "xmlTextWriterStartDTD");
function xmlTextWriterEndDTD (writer : access xmlTextWriter)
return signed_int;
pragma Import (C, xmlTextWriterEndDTD, "xmlTextWriterEndDTD");
function xmlTextWriterWriteFormatDTD (writer : access xmlTextWriter;
name : access constant xmlstring.xmlChar;
pubid : access constant xmlstring.xmlChar;
sysid : access constant xmlstring.xmlChar;
format : access constant char) return signed_int;
pragma Import (C, xmlTextWriterWriteFormatDTD,
"xmlTextWriterWriteFormatDTD");
function xmlTextWriterWriteVFormatDTD (writer : access xmlTextWriter;
name : access constant xmlstring.xmlChar;
pubid : access constant xmlstring.xmlChar;
sysid : access constant xmlstring.xmlChar;
format : access constant char; argptr : stdio.va_list)
return signed_int;
pragma Import (C, xmlTextWriterWriteVFormatDTD,
"xmlTextWriterWriteVFormatDTD");
function xmlTextWriterWriteDTD (writer : access xmlTextWriter;
name : access constant xmlstring.xmlChar;
pubid : access constant xmlstring.xmlChar;
sysid : access constant xmlstring.xmlChar;
subset : access constant xmlstring.xmlChar) return signed_int;
pragma Import (C, xmlTextWriterWriteDTD, "xmlTextWriterWriteDTD");
function xmlTextWriterStartDTDElement (writer : access xmlTextWriter;
name : access constant xmlstring.xmlChar) return signed_int;
pragma Import (C, xmlTextWriterStartDTDElement,
"xmlTextWriterStartDTDElement");
function xmlTextWriterEndDTDElement (writer : access xmlTextWriter)
return signed_int;
pragma Import (C, xmlTextWriterEndDTDElement,
"xmlTextWriterEndDTDElement");
function xmlTextWriterWriteFormatDTDElement (
writer : access xmlTextWriter;
name : access constant xmlstring.xmlChar;
format : access constant char) return signed_int;
pragma Import (C, xmlTextWriterWriteFormatDTDElement,
"xmlTextWriterWriteFormatDTDElement");
function xmlTextWriterWriteVFormatDTDElement (
writer : access xmlTextWriter;
name : access constant xmlstring.xmlChar;
format : access constant char; argptr : stdio.va_list)
return signed_int;
pragma Import (C, xmlTextWriterWriteVFormatDTDElement,
"xmlTextWriterWriteVFormatDTDElement");
function xmlTextWriterWriteDTDElement (writer : access xmlTextWriter;
name : access constant xmlstring.xmlChar;
content : access constant xmlstring.xmlChar) return signed_int;
pragma Import (C, xmlTextWriterWriteDTDElement,
"xmlTextWriterWriteDTDElement");
function xmlTextWriterStartDTDAttlist (writer : access xmlTextWriter;
name : access constant xmlstring.xmlChar) return signed_int;
pragma Import (C, xmlTextWriterStartDTDAttlist,
"xmlTextWriterStartDTDAttlist");
function xmlTextWriterEndDTDAttlist (writer : access xmlTextWriter)
return signed_int;
pragma Import (C, xmlTextWriterEndDTDAttlist,
"xmlTextWriterEndDTDAttlist");
function xmlTextWriterWriteFormatDTDAttlist (
writer : access xmlTextWriter;
name : access constant xmlstring.xmlChar;
format : access constant char) return signed_int;
pragma Import (C, xmlTextWriterWriteFormatDTDAttlist,
"xmlTextWriterWriteFormatDTDAttlist");
function xmlTextWriterWriteVFormatDTDAttlist (
writer : access xmlTextWriter;
name : access constant xmlstring.xmlChar;
format : access constant char; argptr : stdio.va_list)
return signed_int;
pragma Import (C, xmlTextWriterWriteVFormatDTDAttlist,
"xmlTextWriterWriteVFormatDTDAttlist");
function xmlTextWriterWriteDTDAttlist (writer : access xmlTextWriter;
name : access constant xmlstring.xmlChar;
content : access constant xmlstring.xmlChar) return signed_int;
pragma Import (C, xmlTextWriterWriteDTDAttlist,
"xmlTextWriterWriteDTDAttlist");
function xmlTextWriterStartDTDEntity (writer : access xmlTextWriter;
pe : signed_int; name : access constant xmlstring.xmlChar)
return signed_int;
pragma Import (C, xmlTextWriterStartDTDEntity,
"xmlTextWriterStartDTDEntity");
function xmlTextWriterEndDTDEntity (writer : access xmlTextWriter)
return signed_int;
pragma Import (C, xmlTextWriterEndDTDEntity, "xmlTextWriterEndDTDEntity");
function xmlTextWriterWriteFormatDTDInternalEntity (
writer : access xmlTextWriter; pe : signed_int;
name : access constant xmlstring.xmlChar;
format : access constant char) return signed_int;
pragma Import (C, xmlTextWriterWriteFormatDTDInternalEntity,
"xmlTextWriterWriteFormatDTDInternalEntity");
function xmlTextWriterWriteVFormatDTDInternalEntity (
writer : access xmlTextWriter; pe : signed_int;
name : access constant xmlstring.xmlChar;
format : access constant char; argptr : stdio.va_list)
return signed_int;
pragma Import (C, xmlTextWriterWriteVFormatDTDInternalEntity,
"xmlTextWriterWriteVFormatDTDInternalEntity");
function xmlTextWriterWriteDTDInternalEntity (
writer : access xmlTextWriter; pe : signed_int;
name : access constant xmlstring.xmlChar;
content : access constant xmlstring.xmlChar) return signed_int;
pragma Import (C, xmlTextWriterWriteDTDInternalEntity,
"xmlTextWriterWriteDTDInternalEntity");
function xmlTextWriterWriteDTDExternalEntity (
writer : access xmlTextWriter; pe : signed_int;
name : access constant xmlstring.xmlChar;
pubid : access constant xmlstring.xmlChar;
sysid : access constant xmlstring.xmlChar;
ndataid : access constant xmlstring.xmlChar) return signed_int;
pragma Import (C, xmlTextWriterWriteDTDExternalEntity,
"xmlTextWriterWriteDTDExternalEntity");
function xmlTextWriterWriteDTDExternalEntityContents (
writer : access xmlTextWriter;
pubid : access constant xmlstring.xmlChar;
sysid : access constant xmlstring.xmlChar;
ndataid : access constant xmlstring.xmlChar) return signed_int;
pragma Import (C, xmlTextWriterWriteDTDExternalEntityContents,
"xmlTextWriterWriteDTDExternalEntityContents");
function xmlTextWriterWriteDTDEntity (writer : access xmlTextWriter;
pe : signed_int; name : access constant xmlstring.xmlChar;
pubid : access constant xmlstring.xmlChar;
sysid : access constant xmlstring.xmlChar;
ndataid : access constant xmlstring.xmlChar;
content : access constant xmlstring.xmlChar) return signed_int;
pragma Import (C, xmlTextWriterWriteDTDEntity,
"xmlTextWriterWriteDTDEntity");
function xmlTextWriterWriteDTDNotation (writer : access xmlTextWriter;
name : access constant xmlstring.xmlChar;
pubid : access constant xmlstring.xmlChar;
sysid : access constant xmlstring.xmlChar) return signed_int;
pragma Import (C, xmlTextWriterWriteDTDNotation,
"xmlTextWriterWriteDTDNotation");
function xmlTextWriterSetIndent (writer : access xmlTextWriter;
indent : signed_int) return signed_int;
pragma Import (C, xmlTextWriterSetIndent, "xmlTextWriterSetIndent");
function xmlTextWriterSetIndentString (writer : access xmlTextWriter;
str : access constant xmlstring.xmlChar) return signed_int;
pragma Import (C, xmlTextWriterSetIndentString,
"xmlTextWriterSetIndentString");
function xmlTextWriterSetQuoteChar (writer : access xmlTextWriter;
quotechar : xmlstring.xmlChar) return signed_int;
pragma Import (C, xmlTextWriterSetQuoteChar, "xmlTextWriterSetQuoteChar");
function xmlTextWriterFlush (writer : access xmlTextWriter)
return signed_int;
pragma Import (C, xmlTextWriterFlush, "xmlTextWriterFlush");
-- __XML_XMLWRITER_H__ (empty)
function xmlTextWriterWriteDocType (writer : access xmlTextWriter;
name : access constant xmlstring.xmlChar;
pubid : access constant xmlstring.xmlChar;
sysid : access constant xmlstring.xmlChar;
subset : access constant xmlstring.xmlChar) return signed_int
renames xmlTextWriterWriteDTD;
function xmlTextWriterWriteProcessingInstruction (
writer : access xmlTextWriter;
target : access constant xmlstring.xmlChar;
content : access constant xmlstring.xmlChar) return signed_int
renames xmlTextWriterWritePI;
private
type struct_xmlTextWriter is null record;
end C.libxml.xmlwriter;
Raw
c-libxml.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.libxml is
pragma Preelaborate;
end C.libxml;
Raw
c-limits.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.limits is
pragma Preelaborate;
MB_LEN_MAX : constant := 16;
LIBC_LIMITS_H : constant := 1;
CHAR_BIT : constant := 8;
CHAR_MAX : constant := 127;
CHAR_MIN : constant := -128;
INT_MAX : constant := 2147483647;
INT_MIN : constant := -2147483648;
LLONG_MAX : constant := 9223372036854775807;
LLONG_MIN : constant := -9223372036854775808;
LONG_MAX : constant := 9223372036854775807;
LONG_MIN : constant := -9223372036854775808;
SCHAR_MAX : constant := 127;
SCHAR_MIN : constant := -128;
SHRT_MAX : constant := 32767;
SHRT_MIN : constant := -32768;
UCHAR_MAX : constant := 255;
UINT_MAX : constant := 4294967295;
ULLONG_MAX : constant := 18446744073709551615;
ULONG_MAX : constant := 18446744073709551615;
USHRT_MAX : constant := 65535;
-- _GCC_LIMITS_H_ (empty)
-- _LIMITS_H___ (empty)
end C.limits;
Raw
c-linux-limits.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.linux.limits is
pragma Preelaborate;
MAX_CANON : constant := 255;
MAX_INPUT : constant := 255;
NAME_MAX : constant := 255;
NGROUPS_MAX : constant := 65536;
PATH_MAX : constant := 4096;
PIPE_BUF : constant := 4096;
RTSIG_MAX : constant := 32;
XATTR_LIST_MAX : constant := 65536;
XATTR_NAME_MAX : constant := 255;
XATTR_SIZE_MAX : constant := 65536;
-- _LINUX_LIMITS_H (empty)
end C.linux.limits;
Raw
c-linux.ads
-- This file is translated by "headmaster" version 0.30-e83b81d (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
package C.linux is
pragma Preelaborate;
end C.linux;
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;
-- _ANSI_STDARG_H_ (empty)
-- _STDARG_H (empty)
-- _VA_LIST (empty)
-- _VA_LIST_ (empty)
-- _VA_LIST_T_H (empty)
-- __GNUC_VA_LIST (empty)
-- __va_copy (function macro)
-- __va_list__ (empty)
-- va_arg (function macro)
-- va_copy (function macro)
-- va_end (function macro)
-- va_start (function macro)
end C.stdarg;
Raw
c-stddef.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 <xlocale.h>
-- #include <string.h>
-- #include <bits/types.h>
-- #include <wchar.h>
-- #include <_G_config.h>
-- #include <stdarg.h>
-- #include <libio.h>
-- #include <libxml/xmlversion.h>
-- #include <bits/sys_errlist.h>
-- #include <stdio.h>
-- #include <libxml/xmlstring.h>
-- #include <libxml/dict.h>
-- #include <libxml/xmlregexp.h>
-- #include <libxml/tree.h>
-- #include <libxml/xmlmemory.h>
-- #include <libxml/threads.h>
-- #include <libxml/hash.h>
-- #include <libxml/xmlerror.h>
-- #include <libxml/list.h>
-- #include <libxml/xmlautomata.h>
-- #include <libxml/valid.h>
-- #include <libxml/entities.h>
-- #include <iconv.h>
-- #include <libxml/encoding.h>
-- #include <libxml/xmlIO.h>
-- #include <libxml/parser.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 off_t is bits.types.off_t;
subtype ssize_t is bits.types.ssize_t;
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;
-- __off_t_defined (empty)
-- __ssize_t_defined (empty)
-- 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 pid_t is bits.types.pid_t;
subtype id_t is bits.types.id_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)
-- __pid_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.ads
-- This file is translated by "headmaster" version 0.30-e83b81d (devel).
-- The original C header's license should be applied to this file.
-- All conditional-directives are expanded for the exclusive use of your
-- environment, it is not recommended to commit this file to any repository.
-------------------------------------------------------------------------------
with System;
package C is
pragma Preelaborate;
-- type void (<>) is limited private;
type bool is new Boolean;
pragma Convention (C, bool);
type signed_char is new Short_Short_Integer;
pragma Convention (C, signed_char);
type unsigned_char is mod 2 ** signed_char'Size;
pragma Convention (C, unsigned_char);
type signed_short is new Short_Integer;
pragma Convention (C, signed_short);
type unsigned_short is mod 2 ** signed_short'Size;
pragma Convention (C, unsigned_short);
type signed_int is new Integer;
pragma Convention (C, signed_int);
type unsigned_int is mod 2 ** signed_int'Size;
pragma Convention (C, unsigned_int);
type signed_long is new Long_Integer;
pragma Convention (C, signed_long);
type unsigned_long is mod 2 ** signed_long'Size;
pragma Convention (C, unsigned_long);
type signed_long_long is new Long_Long_Integer;
pragma Convention (C, signed_long_long);
type unsigned_long_long is mod 2 ** signed_long_long'Size;
pragma Convention (C, unsigned_long_long);
type float is new Standard.Float;
pragma Convention (C, float);
type double is new Long_Float;
pragma Convention (C, double);
type long_double is new Long_Long_Float;
pragma Convention (C, long_double);
-- type Float32 is ...
-- type Float64 is ...
-- type Float128 is ...
-- type Float32x is ...
-- type Float64x is ...
-- type Decimal32 is ...
-- type Decimal64 is ...
-- type Decimal128 is ...
type float_imaginary is new float;
pragma Convention (C, float_imaginary);
type double_imaginary is new double;
pragma Convention (C, double_imaginary);
type long_double_imaginary is new long_double;
pragma Convention (C, long_double_imaginary);
-- type Float32_imaginary is ...
-- type Float32x_imaginary is ...
-- type Float64_imaginary is ...
-- type Float64x_imaginary is ...
-- type Float128_imaginary is ...
type float_complex is record
Re, Im : float'Base;
end record;
pragma Complex_Representation (float_complex);
pragma Convention (C, float_complex);
type double_complex is record
Re, Im : double'Base;
end record;
pragma Complex_Representation (double_complex);
pragma Convention (C, double_complex);
type long_double_complex is record
Re, Im : long_double'Base;
end record;
pragma Complex_Representation (long_double_complex);
pragma Convention (C, long_double_complex);
-- type Float32_complex is ...
-- type Float32x_complex is ...
-- type Float64_complex is ...
-- type Float64x_complex is ...
-- type Float128_complex is ...
type char is new Character;
type int128_t is record
Lo, Hi : unsigned_long_long;
end record;
pragma Convention (C_Pass_By_Copy, int128_t);
type uint128_t is record
Lo, Hi : unsigned_long_long;
end record;
pragma Convention (C_Pass_By_Copy, uint128_t);
subtype builtin_va_list is System.Address;
type ptrdiff_t is new signed_long;
type size_t is new unsigned_long;
type wchar_t is new signed_int;
subtype void_ptr is System.Address;
type void_ptr_ptr is access all void_ptr;
for void_ptr_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (void_ptr_ptr);
pragma Convention (C, void_ptr_ptr);
subtype void_const_ptr is System.Address;
type unsigned_char_ptr is access all unsigned_char;
for unsigned_char_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (unsigned_char_ptr);
pragma Convention (C, unsigned_char_ptr);
type unsigned_char_ptr_ptr is access all unsigned_char_ptr;
for unsigned_char_ptr_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (unsigned_char_ptr_ptr);
pragma Convention (C, unsigned_char_ptr_ptr);
type unsigned_char_ptr_const_ptr is access constant unsigned_char_ptr;
for unsigned_char_ptr_const_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (unsigned_char_ptr_const_ptr);
pragma Convention (C, unsigned_char_ptr_const_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_char_const_ptr_ptr is access all unsigned_char_const_ptr;
for unsigned_char_const_ptr_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (unsigned_char_const_ptr_ptr);
pragma Convention (C, unsigned_char_const_ptr_ptr);
type unsigned_char_array is array (size_t range <>) of
aliased unsigned_char;
pragma Convention (C, unsigned_char_array);
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 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 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 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 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_ptr is access all unsigned_long;
for unsigned_long_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (unsigned_long_ptr);
pragma Convention (C, unsigned_long_ptr);
type unsigned_long_array is array (size_t range <>) of
aliased unsigned_long;
pragma Convention (C, unsigned_long_array);
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_const_ptr_ptr is access all char_const_ptr;
for char_const_ptr_ptr'Storage_Size use 0;
pragma No_Strict_Aliasing (char_const_ptr_ptr);
pragma Convention (C, char_const_ptr_ptr);
type char_array is array (size_t range <>) of aliased char;
pragma Convention (C, char_array);
function "=" (Left, Right : System.Address) return Boolean
renames System."=";
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