Ctypes_memory (docs.findlib-1.ctypes.Ctypes

module Stubs = Ctypes_memory_stubs

module Raw = Ctypes_ptr.Raw

module Fat = Ctypes_ptr.Fat

val castp : 
  'a Ctypes_static.typ ->
  ('b, [ `C ]) Ctypes_static.pointer ->
  ('a, [ `C ]) Ctypes_static.pointer

val make_unmanaged : reftyp:'a -> Ctypes_ptr.voidp -> ('b option, 'a) Fat.t

val build : 
  'a 'b. 'a Ctypes_static.typ ->
  ('c, 'b Ctypes_static.typ) Fat.t ->
  'a

val write : 'a 'b. 'a Ctypes_static.typ -> 'a -> ('c, 'b) Fat.t -> unit

val null : unit Ctypes_static.ptr

val (!@) : 'a. 'a Ctypes_static.ptr -> 'a

val ptr_diff : 
  'a 'b. ('a, 'b) Ctypes_static.pointer ->
  ('a, 'b) Ctypes_static.pointer ->
  int

val (+@) : 
  'a 'b. ('a, 'b) Ctypes_static.pointer ->
  int ->
  ('a, 'b) Ctypes_static.pointer

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

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

val from_voidp : 
  'a Ctypes_static.typ ->
  ('b, [ `C ]) Ctypes_static.pointer ->
  ('a, [ `C ]) Ctypes_static.pointer

val to_voidp : 
  ('a, [ `C ]) Ctypes_static.pointer ->
  (unit, [ `C ]) Ctypes_static.pointer

val allocate_n : 
  'a. ?finalise:('a Ctypes_static.ptr -> unit) ->
  'a Ctypes_static.typ ->
  count:int ->
  'a Ctypes_static.ptr

val allocate : 
  'a. ?finalise:('a Ctypes_static.ptr -> unit) ->
  'a Ctypes_static.typ ->
  'a ->
  'a Ctypes_static.ptr

val ptr_compare : 
  ('a, [ `C ]) Ctypes_static.pointer ->
  ('a, [ `C ]) Ctypes_static.pointer ->
  int

val reference_type : ('a, [ `C ]) Ctypes_static.pointer -> 'a Ctypes_static.typ

val ptr_of_raw_address : 
  Ctypes_ptr.voidp ->
  (unit, [ `C ]) Ctypes_static.pointer

val funptr_of_raw_address : 
  Ctypes_ptr.voidp ->
  (unit -> unit) Ctypes_static.static_funptr

val raw_address_of_ptr : ('a, [ `C ]) Ctypes_static.pointer -> Ctypes_ptr.voidp

module CArray : sig ... end

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

val (|->) : 
  ('a, [ `C ]) Ctypes_static.pointer ->
  ('b, 'c) Ctypes_static.field ->
  ('b, [ `C ]) Ctypes_static.pointer

val (@.) : 
  ('a, 'b) Ctypes_static.structured ->
  ('c, 'd) Ctypes_static.field ->
  ('c, [ `C ]) Ctypes_static.pointer

val setf : 
  ('a, 'b) Ctypes_static.structured ->
  ('c, 'd) Ctypes_static.field ->
  'c ->
  unit

val getf : 
  ('a, 'b) Ctypes_static.structured ->
  ('c, 'd) Ctypes_static.field ->
  'c

val addr : 
  ('a, 'b) Ctypes_static.structured ->
  ('a, 'b) Ctypes_static.structured Ctypes_static.ptr

val _bigarray_start : 
  ('a, 'b) Bigarray_compat.kind ->
  'c ->
  ('a, [ `C ]) Ctypes_static.pointer

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

val bigarray_start : 
  < ba_repr : 'a
    ; bigarray : 'b
    ; carray : 'c
    ; dims : 'd
    ; element : 'e
    ; layout : 'f >
    Ctypes_static.bigarray_class ->
  'b ->
  ('e, [ `C ]) Ctypes_static.pointer

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

val bigarray_elements : 
  'a 'b 'c 'd 'f 'l. < ba_repr : 'f
                       ; bigarray : 'b
                       ; carray : 'c
                       ; dims : 'd
                       ; element : 'a
                       ; layout : 'l >
                       Ctypes_static.bigarray_class ->
  'd ->
  int

val bigarray_of_ptr : 
  < ba_repr : 'a
    ; bigarray : 'b
    ; carray : 'c
    ; dims : 'd
    ; element : 'e
    ; layout : Bigarray_compat.c_layout >
    Ctypes_static.bigarray_class ->
  'd ->
  ('e, 'a) Bigarray_compat.kind ->
  ('f, [ `C ]) Ctypes_static.pointer ->
  'b

val fortran_bigarray_of_ptr : 
  < ba_repr : 'a
    ; bigarray : 'b
    ; carray : 'c
    ; dims : 'd
    ; element : 'e
    ; layout : Bigarray_compat.fortran_layout >
    Ctypes_static.bigarray_class ->
  'd ->
  ('e, 'a) Bigarray_compat.kind ->
  ('f, [ `C ]) Ctypes_static.pointer ->
  'b

val array_dims : 
  'a 'b 'c 'd 'f 'l. < ba_repr : 'f
                       ; bigarray : 'b
                       ; carray : 'c Ctypes_static.carray
                       ; dims : 'd
                       ; element : 'a
                       ; layout : 'l >
                       Ctypes_static.bigarray_class ->
  'c Ctypes_static.carray ->
  'd

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

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

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

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

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

val typ_of_bigarray_kind : 
  ('a, 'b) Bigarray_compat.kind ->
  'a Ctypes_static.typ

val string_from_ptr : 
  ('a, [ `C ]) Ctypes_static.pointer ->
  length:int ->
  string

val ocaml_string_start : string -> (string, [ `OCaml ]) Ctypes_static.pointer

val ocaml_bytes_start : bytes -> (bytes, [ `OCaml ]) Ctypes_static.pointer

val ocaml_float_array_start : 
  float array ->
  (float array, [ `OCaml ]) Ctypes_static.pointer

module Root : sig ... end

val is_null : ('a, [ `C ]) Ctypes_static.pointer -> bool