C (u.8d1f94410b9e31d0ea4b195f44beb6bb.yaml.3.2.0.doc.yaml.ffi.Yaml

Sourcetype (!'a, !'b) pointer = ('a, 'b) Ctypes_static.pointer

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

Sourcetype !'a ocaml = 'a Ctypes_static.ocaml

Sourcetype !'a carray = 'a Ctypes_static.carray

Sourcetype !'a bigarray_class = 'a Ctypes_static.bigarray_class

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

Source

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

Source

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

Source

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

Sourcetype (!'a, !'kind) structured = ('a, 'kind) Ctypes_static.structured

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

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

Sourcetype (!'a, !'t) field = ('a, 't) Ctypes_static.field

Sourcetype !'a abstract = 'a Ctypes_static.abstract

Sourcetype !'a typ = 'a Ctypes_static.typ

Sourceval void : unit typ

Sourceval char : char typ

Sourceval schar : int typ

Sourceval short : int typ

Sourceval int : int typ

Sourceval long : Signed.long typ

Sourceval llong : Signed.llong typ

Sourceval nativeint : nativeint typ

Sourceval int8_t : int typ

Sourceval int16_t : int typ

Sourceval int32_t : int32 typ

Sourceval int64_t : int64 typ

module Intptr = Ctypes.Intptr

Sourceval intptr_t : Intptr.t typ

module Ptrdiff = Ctypes.Ptrdiff

Sourceval ptrdiff_t : Ptrdiff.t typ

Sourceval camlint : int typ

Sourceval uchar : Unsigned.uchar typ

Sourceval bool : bool typ

Sourceval uint8_t : Unsigned.uint8 typ

Sourceval uint16_t : Unsigned.uint16 typ

Sourceval uint32_t : Unsigned.uint32 typ

Sourceval uint64_t : Unsigned.uint64 typ

Sourceval size_t : Unsigned.size_t typ

Sourceval ushort : Unsigned.ushort typ

Sourceval sint : Signed.sint typ

Sourceval uint : Unsigned.uint typ

Sourceval ulong : Unsigned.ulong typ

Sourceval ullong : Unsigned.ullong typ

module Uintptr = Ctypes.Uintptr

Sourceval uintptr_t : Uintptr.t typ

Sourceval float : float typ

Sourceval double : float typ

Sourceval ldouble : LDouble.t typ

Sourceval complex32 : Complex.t typ

Sourceval complex64 : Complex.t typ

Sourceval complexld : ComplexL.t typ

Sourceval ptr : 'a typ -> 'a Ctypes_static.ptr typ

Sourceval ptr_opt : 'a typ -> 'a Ctypes_static.ptr option typ

Sourceval string : string typ

Sourceval string_opt : string option typ

Sourceval ocaml_string : string Ctypes_static.ocaml typ

Sourceval ocaml_bytes : bytes Ctypes_static.ocaml typ

Sourceval array : int -> 'a typ -> 'a Ctypes_static.carray typ

Source

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

Source

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

Sourceval typ_of_bigarray_kind : ('a, 'b) Bigarray.kind -> 'a typ

Sourceval structure : string -> 's Ctypes_static.structure typ

Sourceval union : string -> 's Ctypes_static.union typ

Source

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

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

Source

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

Sourceval typedef : 'a typ -> string -> 'a typ

Source

val abstract : 
  name:string ->
  size:int ->
  alignment:int ->
  'a Ctypes_static.abstract typ

Sourceval lift_typ : 'a Ctypes_static.typ -> 'a typ

Sourcetype !'a fn = 'a Ctypes_static.fn

Sourcetype !'a static_funptr = 'a Ctypes_static.static_funptr

Sourceval static_funptr : 'a fn -> 'a Ctypes_static.static_funptr typ

Sourceval const : 'a typ -> 'a typ

Sourceval volatile : 'a typ -> 'a typ

Sourceval sizeof : 'a typ -> int

Sourceval alignment : 'a typ -> int

Sourceval format_typ : ?name:string -> Format.formatter -> 'a typ -> unit

Sourceval format_fn : ?name:string -> Format.formatter -> 'a fn -> unit

Sourceval string_of_typ : ?name:string -> 'a typ -> string

Sourceval string_of_fn : ?name:string -> 'a fn -> string

Sourceval format : 'a typ -> Format.formatter -> 'a -> unit

Sourceval string_of : 'a typ -> 'a -> string

Sourceval null : unit ptr

Sourceval (!@) : 'a ptr -> 'a

Sourceval (<-@) : 'a ptr -> 'a -> unit

Sourceval (+@) : ('a, 'b) pointer -> int -> ('a, 'b) pointer

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

Sourceval ptr_diff : ('a, 'b) pointer -> ('a, 'b) pointer -> int

Sourceval from_voidp : 'a typ -> unit ptr -> 'a ptr

Sourceval to_voidp : 'a ptr -> unit ptr

Sourceval allocate : ?finalise:('a ptr -> unit) -> 'a typ -> 'a -> 'a ptr

Sourceval allocate_n : ?finalise:('a ptr -> unit) -> 'a typ -> count:int -> 'a ptr

Sourceval ptr_compare : 'a ptr -> 'a ptr -> int

Sourceval is_null : 'a ptr -> bool

Sourceval reference_type : 'a ptr -> 'a typ

Sourceval ptr_of_raw_address : nativeint -> unit ptr

Source

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

Sourceval raw_address_of_ptr : unit ptr -> nativeint

Sourceval string_from_ptr : char ptr -> length:int -> string

Sourceval ocaml_string_start : string -> string ocaml

Sourceval ocaml_bytes_start : bytes -> bytes ocaml

Sourcemodule CArray = Ctypes.CArray

Source

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

Source

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

Source

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

Source

val array_of_bigarray : 
  < ba_repr : 'a
    ; bigarray : 'b
    ; carray : 'c
    ; dims : 'd
    ; element : 'e
    ; layout : Bigarray.c_layout >
    bigarray_class ->
  'b ->
  'c

Source

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

Source

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

Sourceval setf : ('b, 'c) structured -> ('a, ('b, 'c) structured) field -> 'a -> unit

Sourceval getf : ('b, 'c) structured -> ('a, ('b, 'c) structured) field -> 'a

Sourceval (@.) : ('b, 'c) structured -> ('a, ('b, 'c) structured) field -> 'a ptr

Source

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

Sourceval offsetof : ('a, 'b structure) field -> int

Sourceval field_type : ('a, 'b) field -> 'a typ

Sourceval field_name : ('a, 'b) field -> string

Sourceval addr : ('a, 'b) structured -> ('a, 'b) structured ptr

Sourceval coerce : 'a typ -> 'b typ -> 'a -> 'b

Sourceval coerce_fn : 'a fn -> 'b fn -> 'a -> 'b

Sourcemodule type FOREIGN = Ctypes.FOREIGN

Sourcemodule type TYPE = Ctypes.TYPE

Sourcemodule Root = Ctypes.Root

Sourceexception Unsupported of string

Sourceexception ModifyingSealedType of string

Sourceexception IncompleteType

Sourcetype uncoercible_info = Ctypes.uncoercible_info

Sourceexception Uncoercible of uncoercible_info

Sourceval (@->) : 'a Ctypes.typ -> 'b G.fn -> ('a -> 'b) G.fn

Sourceval returning : 'a Ctypes.typ -> 'a G.return G.fn