6 Miscellaneous Support

▼ |  | The Racket Foreign Interface

1 | Overview
2 | Loading Foreign Libraries
3 | C Types
4 | Pointer Functions
5 | Derived Utilities
6 | Miscellaneous Support
7 | Unexported Primitive Functions
| Bibliography
| Index

On this page:

list->cblock
vector->cblock
vector->cpointer
flvector->cpointer
saved-errno
lookup-errno
cast
cblock->list
cblock->vector

top ← prev up next →

### 6`` Miscellaneous Support

> procedure (list->cblock lst type) → any
> lst : list?
> type : ctype?

Allocates a memory block of an appropriate size, and initializes it using values from lst and the given type. The lst must hold values that can all be converted to C values according to the given type.

> procedure (vector->cblock vec type) → any
> vec : vector?
> type : type?

Like list->cblock, but for Racket vectors.

> procedure (vector->cpointer vec) → cpointer?
> vec : vector?

Returns a pointer to an array of _scheme values, which is the internal representation of vec.

> procedure (flvector->cpointer flvec) → cpointer?
> flvec : flvector?

Returns a pointer to an array of _double values, which is the internal representation of flvec.

> procedure (saved-errno) → exact-integer?
> (saved-errno new-value) → void?
> new-value : exact-integer?

Returns or sets the error code saved for the current Racket thread. The saved error code is set after a foreign call with a non-#f #:save-errno option (see _fun and _cprocedure), but it can also be set explicitly (for example, to create mock foreign functions for testing).

Changed in version 6.4.0.9 of package base: Added the one-argument variant.

> procedure (lookup-errno sym) → exact-integer?
> sym : (or/c 'EINTR 'EEXIST 'EAGAIN)

Returns a platform-specific value corresponding to a Posix errno symbol. The set of supported symbols is likely to expand in the future.

> procedure (cast v from-type to-type) → any/c
> v : any/c
> from-type : ctype?
> to-type : ctype?

Converts v from a value matching from-type to a value matching to-type, where (ctype-sizeof from-type) matches (ctype-sizeof to-type).

The conversion is roughly equivalent to

> (let ([p (malloc from-type)])
> (ptr-set! p from-type v)
> (ptr-ref p to-type))

If v is a cpointer, (cpointer-gcable? v) is true, and from-type and to-type are both based on _pointer or _gcpointer, then from-type is implicitly converted with _gcable to ensure that the result cpointer is treated as referring to memory that is managed by the garbage collector.

If v is a pointer with an offset component (e.g., from ptr-add), (cpointer-gcable? v) is true, and the result is a cpointer, then the result pointer has the same offset component as v. If (cpointer-gcable? v) is false, then any offset is folded into the pointer base for the result.

> procedure (cblock->list cblock type length) → list?
> cblock : any/c
> type : ctype?
> length : exact-nonnegative-integer?

Converts C cblock, which is a vector of types, to a Racket list. The arguments are the same as in the list->cblock. The length must be specified because there is no way to know where the block ends.

> procedure (cblock->vector cblock type length) → vector?
> cblock : any/c
> type : ctype?
> length : exact-nonnegative-integer?

Like cblock->vector, but for Racket vectors.
top ← prev up next →