package posix-socket
Install
dune-project
Dependency
Authors
Maintainers
Sources
md5=2c186aa5161b72208a870d5710fb6208
sha512=d583c3d386865eab7575fc4f1976c17294bad2ee5037327cb5c3075965788170e652b7b9b9f660ef25f71558553fbcc47734b971e3c9f41627cc573d75d2fb54
doc/posix-socket.constants/Posix_socket_constants/Def/argument-1-S/index.html
Parameter Def.S
include Ctypes_types.TYPE
Values representing C types
The type of values representing C types. There are two types associated with each typ value: the C type used to store and pass values, and the corresponding OCaml type. The type parameter indicates the OCaml type, so a value of type t typ is used to read and write OCaml values of type t. There are various uses of typ values, including
- constructing function types for binding native functions using
Foreign.foreign
- constructing pointers for reading and writing locations in C-managed storage using
ptr
The void type
val void : unit typValue representing the C void type. Void values appear in OCaml as the unit type, so using void in an argument or result type specification produces a function which accepts or returns unit.
Dereferencing a pointer to void is an error, as in C, and will raise IncompleteType.
Scalar types
The scalar types consist of the Arithmetic types and the Pointer types.
Arithmetic types
The arithmetic types consist of the signed and unsigned integer types (including character types) and the floating types. There are values representing both exact-width integer types (of 8, 16, 32 and 64 bits) and types whose size depend on the platform (signed and unsigned short, int, long, long long).
val char : char typValue representing the C type char.
Signed integer types
val schar : int typValue representing the C type signed char.
val short : int typValue representing the C type (signed) short.
val int : int typValue representing the C type (signed) int.
val long : Signed.long typValue representing the C type (signed) long.
val llong : Signed.llong typValue representing the C type (signed) long long.
val nativeint : nativeint typValue representing the C type (signed) int.
val int8_t : int typValue representing an 8-bit signed integer C type.
val int16_t : int typValue representing a 16-bit signed integer C type.
val int32_t : int32 typValue representing a 32-bit signed integer C type.
val int64_t : int64 typValue representing a 64-bit signed integer C type.
val camlint : int typValue representing an integer type with the same storage requirements as an OCaml int.
Unsigned integer types
val uchar : Unsigned.uchar typValue representing the C type unsigned char.
val bool : bool typValue representing the C type bool.
val uint8_t : Unsigned.uint8 typValue representing an 8-bit unsigned integer C type.
val uint16_t : Unsigned.uint16 typValue representing a 16-bit unsigned integer C type.
val uint32_t : Unsigned.uint32 typValue representing a 32-bit unsigned integer C type.
val uint64_t : Unsigned.uint64 typValue representing a 64-bit unsigned integer C type.
val size_t : Unsigned.size_t typValue representing the C type size_t, an alias for one of the unsigned integer types. The actual size and alignment requirements for size_t vary between platforms.
val ushort : Unsigned.ushort typValue representing the C type unsigned short.
val sint : Signed.sint typValue representing the C type int.
val uint : Unsigned.uint typValue representing the C type unsigned int.
val ulong : Unsigned.ulong typValue representing the C type unsigned long.
val ullong : Unsigned.ullong typValue representing the C type unsigned long long.
module Uintptr : Unsigned.SFloating types
val float : float typValue representing the C single-precision float type.
val double : float typValue representing the C type double.
Complex types
val complexld : ComplexL.t typValue representing the C99 long-double-precision long double complex type.
Pointer types
C-compatible pointers
val ptr : 'a typ -> 'a Ctypes_static.ptr typConstruct a pointer type from an existing type (called the reference type).
val ptr_opt : 'a typ -> 'a Ctypes_static.ptr option typConstruct a pointer type from an existing type (called the reference type). This behaves like ptr, except that null pointers appear in OCaml as None.
val string : string typA high-level representation of the string type.
On the C side this behaves like char *; on the OCaml side values read and written using string are simply native OCaml strings.
To avoid problems with the garbage collector, values passed using string are copied into immovable C-managed storage before being passed to C.
The string type representation is suitable for use in function argument types such as the following:
string @-> returning int
where the lifetime of the C-managed storage does not need to extend beyond the duration of the function call. However, it is not suitable for use in struct or union fields
field s "x" string
because it does not provide a way to manage the lifetime of the C-managed storage.
val string_opt : string option typA high-level representation of the string type. This behaves like string, except that null pointers appear in OCaml as None.
OCaml pointers
val ocaml_string : string Ctypes_static.ocaml typValue representing the directly mapped storage of an OCaml string.
val ocaml_bytes : bytes Ctypes_static.ocaml typValue representing the directly mapped storage of an OCaml byte array.
Array types
C array types
val array : int -> 'a typ -> 'a Ctypes_static.carray typConstruct a sized array type from a length and an existing type (called the element type).
Bigarray types
val bigarray :
< element : 'a
; layout : Bigarray_compat.c_layout
; ba_repr : 'b
; dims : 'dims
; bigarray : 'bigarray
; carray : _ >
Ctypes_static.bigarray_class ->
'dims ->
('a, 'b) Bigarray_compat.kind ->
'bigarray typConstruct a sized C-layout bigarray type representation from a bigarray class, the dimensions, and the Bigarray_compat.kind.
val fortran_bigarray :
< element : 'a
; layout : Bigarray_compat.fortran_layout
; ba_repr : 'b
; dims : 'dims
; bigarray : 'bigarray
; carray : _ >
Ctypes_static.bigarray_class ->
'dims ->
('a, 'b) Bigarray_compat.kind ->
'bigarray typConstruct a sized Fortran-layout bigarray type representation from a bigarray class, the dimensions, and the Bigarray_compat.kind.
val typ_of_bigarray_kind : ('a, 'b) Bigarray_compat.kind -> 'a typtyp_of_bigarray_kind k is the type corresponding to the Bigarray kind k.
Struct and union types
val structure : string -> 's Ctypes_static.structure typConstruct a new structure type. The type value returned is incomplete and can be updated using field until it is passed to seal, at which point the set of fields is fixed.
The type ('_s structure typ) of the expression returned by the call structure tag includes a weak type variable, which can be explicitly instantiated to ensure that the OCaml values representing different C structure types have incompatible types. Typical usage is as follows:
type tagname
let tagname : tagname structure typ = structure "tagname"
val union : string -> 's Ctypes_static.union typval field :
't typ ->
string ->
'a typ ->
('a, ('s, [< `Struct | `Union ]) Ctypes_static.structured as 't) fieldfield ty label ty' adds a field of type ty' with label label to the structure or union type ty and returns a field value that can be used to read and write the field in structure or union instances (e.g. using getf and setf).
Attempting to add a field to a union type that has been sealed with seal is an error, and will raise ModifyingSealedType.
val seal : (_, [< `Struct | `Union ]) Ctypes_static.structured typ -> unitseal t completes the struct or union type t so that no further fields can be added. Struct and union types must be sealed before they can be used in a way that involves their size or alignment; see the documentation for IncompleteType for further details.
View types
val view :
?format_typ:((Format.formatter -> unit) -> Format.formatter -> unit) ->
?format:(Format.formatter -> 'b -> unit) ->
read:('a -> 'b) ->
write:('b -> 'a) ->
'a typ ->
'b typview ~read:r ~write:w t creates a C type representation t' which behaves like t except that values read using t' are subsequently transformed using the function r and values written using t' are first transformed using the function w.
For example, given suitable definitions of string_of_char_ptr and char_ptr_of_string, the type representation
view ~read:string_of_char_ptr ~write:char_ptr_of_string (ptr char)
can be used to pass OCaml strings directly to and from bound C functions, or to read and write string members in structs and arrays. (In fact, the string type representation is defined in exactly this way.)
The optional argument format_typ is used by the Ctypes.format_typ and string_of_typ functions to print the type at the top level and elsewhere. If format_typ is not supplied the printer for t is used instead.
The optional argument format is used by the Ctypes.format and string_of functions to print the values. If format_val is not supplied the printer for t is used instead.
typedef t name creates a C type representation t' which is equivalent to t except its name is printed as name.
This is useful when generating C stubs involving "anonymous" types, for example: typedef struct { int f } typedef_name;
Abstract types
val abstract :
name:string ->
size:int ->
alignment:int ->
'a Ctypes_static.abstract typCreate an abstract type specification from the size and alignment requirements for the type.
Injection of concrete types
val lift_typ : 'a Ctypes_static.typ -> 'a typlift_typ t turns a concrete type representation into an abstract type representation.
For example, retrieving struct layout from C involves working with an abstract representation of types which do not support operations such as sizeof. The lift_typ function makes it possible to use concrete type representations wherever such abstract type representations are needed.
Function types
Abstract interface to C function type descriptions
type 'a fn = 'a Ctypes_static.fnThe type of values representing C function types. A value of type t fn can be used to bind to C functions and to describe type of OCaml functions passed to C.
Construct a function type from a type and an existing function type. This corresponds to prepending a parameter to a C function parameter list. For example,
int @-> ptr void @-> returning float
describes a function type that accepts two arguments -- an integer and a pointer to void -- and returns a float.
type 'a static_funptr = 'a Ctypes_static.static_funptrFunction pointer types
The type of values representing C function pointer types.
val static_funptr : 'a fn -> 'a Ctypes_static.static_funptr typConstruct a function pointer type from an existing function type (called the reference type).
constant name typ retrieves the value of the compile-time constant name of type typ. It can be used to retrieve enum constants, #defined values and other integer constant expressions.
The type typ must be either an integer type such as bool, char, int, uint8, etc., or a view (or perhaps multiple views) where the underlying type is an integer type.
When the value of the constant cannot be represented in the type there will typically be a diagnostic from either the C compiler or the OCaml compiler. For example, gcc will say
warning: overflow in implicit constant conversion
val enum :
string ->
?typedef:bool ->
?unexpected:(int64 -> 'a) ->
('a * int64 const) list ->
'a typenum name ?unexpected alist builds a type representation for the enum named name. The size and alignment are retrieved so that the resulting type can be used everywhere an integer type can be used: as an array element or struct member, as an argument or return value, etc.
The value alist is an association list of OCaml values and values retrieved by the constant function. For example, to expose the enum
enum letters { A, B, C = 10, D };
you might first retrieve the values of the enumeration constants:
let a = constant "A" int64_t
and b = constant "B" int64_t
and c = constant "C" int64_t
and d = constant "D" int64_tand then build the enumeration type
let letters = enum "letters" [
`A, a;
`B, b;
`C, c;
`D, d;
] ~unexpected:(fun i -> `E i)The unexpected function specifies the value to return in the case that some unexpected value is encountered -- for example, if a function with the return type 'enum letters' actually returns the value -1.
The optional flag typedef specifies whether the first argument, name, indicates an tag or an alias. If typedef is false (the default) then name is treated as an enumeration tag:
enum letters { ... }
If typedef is true then name is instead treated as an alias:
typedef enum { ... } letters