Ctypes_static
type !_ ocaml_type =
| String : string ocaml_type |
| Bytes : bytes ocaml_type |
| FloatArray : float array ocaml_type |
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 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 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; |
}
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 |
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 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 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 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 static_funptr : 'a fn -> 'a static_funptr typ
val offsetof : ('a, 'b) field -> int
val field_name : ('a, 'b) field -> string
val unsupported : ('a, unit, string, 'b) format4 -> 'a