/usr/lib/ocaml/lablgl/raw.mli is in liblablgl-ocaml-dev 1:1.05-1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 | (* $Id: raw.mli,v 1.10 2007-04-13 02:48:43 garrigue Exp $ *)
(* This module provides a direct way to access C arrays of basic types.
This is particularly useful when one wants to avoid costly
conversions between ML and C representations. *)
type (+'a) t
type kind =
[`bitmap|`byte|`double|`float|`int|`long|`short
|`ubyte|`uint|`ulong|`ushort]
(* Supported element types. [bitmap] is equivalent to [ubyte] but
allows user modules to distinguish between them *)
type fkind = [`double|`float]
type ikind = [`bitmap|`byte|`int|`long|`short|`ubyte|`uint|`ulong|`ushort]
type lkind = [`int|`long|`uint|`ulong]
val create : ([< kind] as 'a) -> len:int -> 'a t
(* [create t :len] returns a new raw array of C type t
and length len. This array is managed by the GC *)
val create_static : ([< kind] as 'a) -> len:int -> 'a t
(* [create_static t :len] returns a new raw array of C type t
and length len. This array is created through malloc.
You must free it explicitely *)
val free_static : 'a t -> unit
(* Free a raw array created through create_static *)
val kind : 'a t -> 'a
(* Returns the type of a free array. Beware of the influence on the
type system: you probably want to write [(kind raw :> kind)] *)
val byte_size : 'a t -> int
(* The size of the array in bytes. That is (sizeof t * len)
where t and len are the parameters to create *)
val static : 'a t -> bool
(* Wether this array was statically allocated or not *)
val cast : 'a t -> kind:([< kind] as 'b) -> 'b t
(* Change the type of a raw array *)
external sizeof : [< kind] -> int = "ml_raw_sizeof"
(* [sizeof t] returns the physical size of t in bytes *)
val length : [< kind] t -> int
(* [length raw] returns the length of raw array according to
its contents type *)
val sub : ([< kind] t as 'a) -> pos:int -> len:int -> 'a
(* returns the slice of length len starting at position pos *)
(* The following functions access raw arrays in the intuitive way.
They raise [Invalid_argument] when access is attempted out of
bounds *)
external get : [< ikind] t -> pos:int -> int = "ml_raw_get"
external set : [< ikind] t -> pos:int -> int -> unit = "ml_raw_set"
external get_float : [< fkind] t -> pos:int -> float = "ml_raw_get_float"
external set_float : [< fkind] t -> pos:int -> float -> unit
= "ml_raw_set_float"
external get_hi : [< lkind] t -> pos:int -> int = "ml_raw_get_hi"
external set_hi : [< lkind] t -> pos:int -> int -> unit = "ml_raw_set_hi"
external get_lo : [< lkind] t -> pos:int -> int = "ml_raw_get_lo"
external set_lo : [< lkind] t -> pos:int -> int -> unit = "ml_raw_set_lo"
external get_long : [< lkind] t -> pos:int -> nativeint = "ml_raw_get_long"
external set_long : [< lkind] t -> pos:int -> nativeint -> unit
= "ml_raw_set_long"
(* Simultaneous access versions are much more efficient than individual
access, the overhead being paid only once *)
val gets : [< ikind] t -> pos:int -> len:int -> int array
val sets : [< ikind] t -> pos:int -> int array -> unit
val gets_float : [< fkind] t -> pos:int -> len:int -> float array
val sets_float : [< fkind] t -> pos:int -> float array -> unit
(* Fastest version: simply copy the contents of the array to and from
a string *)
val gets_string : 'a t -> pos:int -> len:int -> string
val sets_string : 'a t -> pos:int -> string -> unit
(* Abbreviations to create raw arrays from ML arrays and strings *)
val of_array : int array -> kind:([< ikind] as 'a) -> 'a t
val of_float_array : float array -> kind:([< fkind] as 'a) -> 'a t
val of_string : string -> kind:([< kind] as 'a) -> 'a t
val of_matrix : float array array -> kind:([< fkind] as 'a) -> 'a t
|