ctypes

Combinators for binding to C libraries without writing any C
Library ctypes
Module Ctypes_static
type abstract_type = {
aname : string;
asize : int;
aalignment : int;
}
type !_ ocaml_type =
| String : string ocaml_type
| Bytes : bytes ocaml_type
| FloatArray : float array ocaml_type
type incomplete_size = {
mutable isize : int;
}
type structured_spec = {
size : int;
align : int;
}
type !'a structspec =
| Incomplete of incomplete_size
| Complete of structured_spec
type !_ typ =
| Void : unit typ
| Primitive : 'a Ctypes_primitive_types.prim -> 'a typ
| Pointer : 'a0 typ -> 'a0 ptr typ
| Funptr : 'a1 fn -> 'a1 static_funptr typ
| Struct : 'a2 structure_type -> 'a2 structure typ
| Union : 'a3 union_type -> 'a3 union typ
| Abstract : abstract_type -> 'a4 abstract typ
| View : ( 'a5, 'b ) view -> 'a5 typ
| Array : 'a6 typ * int -> 'a6 carray typ
| Bigarray : ( 'c, 'a7, 'd ) Ctypes_bigarray.t -> 'a7 typ
| OCaml : 'a8 ocaml_type -> 'a8 ocaml typ
and !'a carray = {
astart : 'a ptr;
alength : int;
}
and (!'a, !'kind) structured = {
structured : ( 'a, 'kind ) structured ptr;
}
and !'a union = ( 'a, [ `Union ] ) structured
and !'a structure = ( 'a, [ `Struct ] ) structured
and !'a abstract = ( 'a, [ `Abstract ] ) structured
and (!_, !_) pointer =
| CPointer : ( Obj.t option, 'a typ ) Ctypes_ptr.Fat.t -> ( 'a, [ `C ] ) pointer
| OCamlRef : int * 'a0 * 'a0 ocaml_type -> ( 'a0, [ `OCaml ] ) pointer
and !'a ptr = ( 'a, [ `C ] ) pointer
and !'a ocaml = ( 'a, [ `OCaml ] ) pointer
and !'a0 static_funptr =
| Static_funptr : ( Obj.t option, 'a fn ) Ctypes_ptr.Fat.t -> 'a static_funptr
and (!'a, !'b) view = {
read : 'b -> 'a;
write : 'a -> 'b;
format_typ : ( ( Format.formatter -> unit ) -> Format.formatter -> unit ) option;
format : ( Format.formatter -> 'a -> unit ) option;
ty : 'b typ;
}
and (!'a, !'s) field = {
ftype : 'a typ;
foffset : int;
fname : string;
}
and !'a structure_type = {
tag : string;
mutable spec : 'a structspec;
mutable fields : 'a structure boxed_field list;
}
and !'a union_type = {
utag : string;
mutable uspec : structured_spec option;
mutable ufields : 'a union boxed_field list;
}
and !'s0 boxed_field =
| BoxedField : ( 'a, 's ) field -> 's boxed_field
and !_ fn =
| Returns : 'a typ -> 'a fn
| Function : 'a0 typ * 'b fn -> ( 'a0 -> 'b ) fn
type !_ bigarray_class =
| Genarray : < ba_repr : 'b ; bigarray : ( 'a, 'b, 'l ) Bigarray_compat.Genarray.t ; carray : 'a carray ; dims : int array ; element : 'a ; layout : 'l > bigarray_class
| Array1 : < ba_repr : 'b0 ; bigarray : ( 'a0, 'b0, 'l0 ) Bigarray_compat.Array1.t ; carray : 'a0 carray ; dims : int ; element : 'a0 ; layout : 'l0 > bigarray_class
| Array2 : < ba_repr : 'b1 ; bigarray : ( 'a1, 'b1, 'l1 ) Bigarray_compat.Array2.t ; carray : 'a1 carray carray ; dims : int * int ; element : 'a1 ; layout : 'l1 > bigarray_class
| Array3 : < ba_repr : 'b2 ; bigarray : ( 'a2, 'b2, 'l2 ) Bigarray_compat.Array3.t ; carray : 'a2 carray carray carray ; dims : int * int * int ; element : 'a2 ; layout : 'l2 > bigarray_class
type boxed_typ =
| BoxedType : 'a typ -> boxed_typ
val sizeof : 'a typ -> int
val alignment : 'a typ -> int
val passable : 'a typ -> bool
val ocaml_value : 'a typ -> bool
val has_ocaml_argument : 'a fn -> bool
val void : unit typ
val char : char typ
val schar : int typ
val float : float typ
val double : float typ
val ldouble : LDouble.t typ
val complex32 : Complex.t typ
val complex64 : Complex.t typ
val complexld : ComplexL.t typ
val short : int typ
val int : int typ
val sint : Signed.sint typ
val long : Signed.long typ
val llong : Signed.llong typ
val nativeint : nativeint typ
val int8_t : int typ
val int16_t : int typ
val int32_t : Signed.Int32.t typ
val int64_t : Signed.Int64.t typ
val camlint : int typ
val uchar : Unsigned.uchar typ
val bool : bool typ
val uint8_t : Unsigned.UInt8.t typ
val uint16_t : Unsigned.UInt16.t typ
val uint32_t : Unsigned.UInt32.t typ
val uint64_t : Unsigned.UInt64.t typ
val size_t : Unsigned.size_t typ
val ushort : Unsigned.ushort typ
val uint : Unsigned.uint typ
val ulong : Unsigned.ulong typ
val ullong : Unsigned.ullong typ
val array : int -> 'a typ -> 'a carray typ
val ocaml_string : string ocaml typ
val ocaml_bytes : bytes ocaml typ
val ocaml_float_array : float array ocaml typ
val ptr : 'a typ -> 'a ptr typ
val (@->) : 'a typ -> 'b fn -> ( 'a -> 'b ) fn
val abstract : name:string -> size:int -> alignment:int -> 'a abstract typ
val view : ?format_typ:( ( Format.formatter -> unit ) -> Format.formatter -> unit ) -> ?format:( Format.formatter -> 'b -> unit ) -> read:( 'a -> 'b ) -> write:( 'b -> 'a ) -> 'a typ -> 'b typ
val typedef : 'a typ -> string -> 'a typ
val bigarray : < ba_repr : 'c ; bigarray : 'd ; carray : 'e ; dims : 'b ; element : 'a ; layout : Bigarray_compat.c_layout > bigarray_class -> 'b -> ( 'a, 'c ) Bigarray_compat.kind -> 'd typ
val fortran_bigarray : < ba_repr : 'c ; bigarray : 'd ; carray : 'e ; dims : 'b ; element : 'a ; layout : Bigarray_compat.fortran_layout > bigarray_class -> 'b -> ( 'a, 'c ) Bigarray_compat.kind -> 'd typ
val returning : 'a typ -> 'a fn
val static_funptr : 'a fn -> 'a static_funptr typ
val structure : string -> 'a structure typ
val union : string -> 'a union typ
val offsetof : ( 'a, 'b ) field -> int
val field_type : ( 'a, 'b ) field -> 'a typ
val field_name : ( 'a, 'b ) field -> string
exception IncompleteType
exception ModifyingSealedType of string
exception Unsupported of string
val unsupported : ( 'a, unit, string, 'b ) format4 -> 'a
type arithmetic =
| Int8
| Int16
| Int32
| Int64
| Uint8
| Uint16
| Uint32
| Uint64
| Float
| Double