Ffi_generated_types (async_ssl.Async_ssl.Ffi_generated

include Ctypes

type ('a, 'b) pointer = ('a, 'b) Ctypes_static.pointer

type 'a ptr = ('a, [ `C ]) pointer

type 'a ocaml = 'a Ctypes_static.ocaml

type 'a carray = 'a Ctypes_static.carray

type 'a bigarray_class = 'a Ctypes_static.bigarray_class

val genarray : < ba_repr : 'b; bigarray : ('a, 'b, Bigarray.c_layout) Bigarray.Genarray.t; carray : 'a carray; dims : int array; element : 'a; > bigarray_class

val array1 : < ba_repr : 'b; bigarray : ('a, 'b, Bigarray.c_layout) Bigarray.Array1.t; carray : 'a carray; dims : int; element : 'a; > bigarray_class

val array2 : < ba_repr : 'b; bigarray : ('a, 'b, Bigarray.c_layout) Bigarray.Array2.t; carray : 'a carray carray; dims : int * int; element : 'a; > bigarray_class

val array3 : < ba_repr : 'b; bigarray : ('a, 'b, Bigarray.c_layout) Bigarray.Array3.t; carray : 'a carray carray carray; dims : int * int * int; element : 'a; > bigarray_class

type ('a, 'kind) structured = ('a, 'kind) Ctypes_static.structured

type 'a structure = ('a, [ `Struct ]) structured

type 'a union = ('a, [ `Union ]) structured

type ('a, 't) field = ('a, 't) Ctypes_static.field

type 'a abstract = 'a Ctypes_static.abstract

type 'a typ = 'a Ctypes_static.typ

val void : unit typ

val char : char typ

val schar : int typ

val short : int typ

val int : int 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 : int32 typ

val int64_t : int64 typ

module Intptr = Ctypes.Intptr

val intptr_t : Intptr.t typ

module Ptrdiff = Ctypes.Ptrdiff

val ptrdiff_t : Ptrdiff.t typ

val camlint : int typ

val uchar : Unsigned.uchar typ

val bool : bool typ

val uint8_t : Unsigned.uint8 typ

val uint16_t : Unsigned.uint16 typ

val uint32_t : Unsigned.uint32 typ

val uint64_t : Unsigned.uint64 typ

val size_t : Unsigned.size_t typ

val ushort : Unsigned.ushort typ

val sint : Signed.sint typ

val uint : Unsigned.uint typ

val ulong : Unsigned.ulong typ

val ullong : Unsigned.ullong typ

module Uintptr = Ctypes.Uintptr

val uintptr_t : Uintptr.t 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 ptr : 'a typ ‑> 'a Ctypes_static.ptr typ

val ptr_opt : 'a typ ‑> 'a Ctypes_static.ptr option typ

val string : string typ

val string_opt : string option typ

val ocaml_string : string Ctypes_static.ocaml typ

val ocaml_bytes : Bytes.t Ctypes_static.ocaml typ

val array : int ‑> 'a typ ‑> 'a Ctypes_static.carray typ

val bigarray : < ba_repr : 'b; bigarray : 'bigarray; carray : 'c; dims : 'dims; element : 'a; > Ctypes_static.bigarray_class ‑> 'dims ‑> ('a, 'b) Bigarray.kind ‑> 'bigarray typ

val typ_of_bigarray_kind : ('a, 'b) Bigarray.kind ‑> 'a typ

val structure : string ‑> 's Ctypes_static.structure typ

val union : string ‑> 's Ctypes_static.union typ

val field : ('s, [< `Struct | `Union ] as b) Ctypes_static.structured typ ‑> string ‑> 'a typ ‑> ('a, ('s, 'b) Ctypes_static.structured) field

val seal : ('a, [< `Struct | `Union ]) Ctypes_static.structured typ ‑> unit

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 abstract : name:string ‑> size:int ‑> alignment:int ‑> 'a Ctypes_static.abstract typ

val lift_typ : 'a Ctypes_static.typ ‑> 'a typ

type 'a fn = 'a Ctypes_static.fn

val (@->) : 'a typ ‑> 'b fn ‑> ('a ‑> 'b) fn

val returning : 'a typ ‑> 'a fn

type 'a static_funptr = 'a Ctypes_static.static_funptr

val static_funptr : 'a fn ‑> 'a Ctypes_static.static_funptr typ

val sizeof : 'a typ ‑> int

val alignment : 'a typ ‑> int

val format_typ : ?name:string ‑> Format.formatter ‑> 'a typ ‑> unit

val format_fn : ?name:string ‑> Format.formatter ‑> 'a fn ‑> unit

val string_of_typ : ?name:string ‑> 'a typ ‑> string

val string_of_fn : ?name:string ‑> 'a fn ‑> string

val format : 'a typ ‑> Format.formatter ‑> 'a ‑> unit

val string_of : 'a typ ‑> 'a ‑> string

val null : unit ptr

val (!@) : 'a ptr ‑> 'a

val (<-@) : 'a ptr ‑> 'a ‑> unit

val (+@) : ('a, 'b) pointer ‑> int ‑> ('a, 'b) pointer

val (-@) : ('a, 'b) pointer ‑> int ‑> ('a, 'b) pointer

val ptr_diff : ('a, 'b) pointer ‑> ('a, 'b) pointer ‑> int

val from_voidp : 'a typ ‑> unit ptr ‑> 'a ptr

val to_voidp : 'a ptr ‑> unit ptr

val allocate : ?finalise:('a ptr ‑> unit) ‑> 'a typ ‑> 'a ‑> 'a ptr

val allocate_n : ?finalise:('a ptr ‑> unit) ‑> 'a typ ‑> count:int ‑> 'a ptr

val ptr_compare : 'a ptr ‑> 'a ptr ‑> int

val is_null : 'a ptr ‑> bool

val reference_type : 'a ptr ‑> 'a typ

val ptr_of_raw_address : nativeint ‑> unit ptr

val funptr_of_raw_address : nativeint ‑> (unit ‑> unit) Ctypes_static.static_funptr

val raw_address_of_ptr : unit ptr ‑> nativeint

val string_from_ptr : char ptr ‑> length:int ‑> string

val ocaml_string_start : string ‑> string ocaml

val ocaml_bytes_start : Bytes.t ‑> Bytes.t ocaml

module CArray = Ctypes.CArray

val bigarray_start : < ba_repr : 'c; bigarray : 'b; carray : 'd; dims : 'e; element : 'a; > bigarray_class ‑> 'b ‑> 'a ptr

val bigarray_of_ptr : < ba_repr : 'f; bigarray : 'b; carray : 'c; dims : 'i; element : 'a; > bigarray_class ‑> 'i ‑> ('a, 'f) Bigarray.kind ‑> 'a ptr ‑> 'b

val array_of_bigarray : < ba_repr : 'a; bigarray : 'b; carray : 'c; dims : 'd; element : 'e; > bigarray_class ‑> 'b ‑> 'c

val bigarray_of_array : < ba_repr : 'f; bigarray : 'b; carray : 'c carray; dims : 'i; element : 'a; > bigarray_class ‑> ('a, 'f) Bigarray.kind ‑> 'c carray ‑> 'b

val make : ?finalise:(('a, 'b) structured ‑> unit) ‑> ('a, 'b) structured typ ‑> ('a, 'b) structured

val setf : ('b, 'c) structured ‑> ('a, ('b, 'c) structured) field ‑> 'a ‑> unit

val getf : ('b, 'c) structured ‑> ('a, ('b, 'c) structured) field ‑> 'a

val (@.) : ('b, 'c) structured ‑> ('a, ('b, 'c) structured) field ‑> 'a ptr

val (|->) : ('b, 'c) structured ptr ‑> ('a, ('b, 'c) structured) field ‑> 'a ptr

val offsetof : ('a, 'b structure) field ‑> int

val field_type : ('a, 'b) field ‑> 'a typ

val field_name : ('a, 'b) field ‑> string

val addr : ('a, 'b) structured ‑> ('a, 'b) structured ptr

val coerce : 'a typ ‑> 'b typ ‑> 'a ‑> 'b

val coerce_fn : 'a fn ‑> 'b fn ‑> 'a ‑> 'b

module Root = Ctypes.Root

exception Unsupported of string

exception ModifyingSealedType of string

exception IncompleteType

type uncoercible_info = Ctypes.uncoercible_info

exception Uncoercible of uncoercible_info