Next: , Previous: Foreign Variables, Up: Foreign Pointers

6.20.5.3 Void Pointers and Byte Access

Wrapped pointers are untyped, so they are essentially equivalent to C void pointers. As in C, the memory region pointed to by a pointer can be accessed at the byte level. This is achieved using bytevectors (see Bytevectors). The (rnrs bytevector) module contains procedures that can be used to convert byte sequences to Scheme objects such as strings, floating point numbers, or integers.

— Scheme Procedure: pointer->bytevector pointer len [offset [uvec_type]]
— C Function: scm_foreign_to_bytevector pointer len offset uvec_type

Return a bytevector aliasing the len bytes pointed to by pointer.

The user may specify an alternate default interpretation for the memory by passing the uvec_type argument, to indicate that the memory is an array of elements of that type. uvec_type should be something that uniform-vector-element-type would return, like f32 or s16.

When offset is passed, it specifies the offset in bytes relative to pointer of the memory region aliased by the returned bytevector.

Mutating the returned bytevector mutates the memory pointed to by pointer, so buckle your seatbelts.

— Scheme Procedure: bytevector->pointer bv [offset]
— C Function: scm_bytevector_to_pointer bv offset

Return a pointer pointer aliasing the memory pointed to by bv or offset bytes after bv when offset is passed.

In addition to these primitives, convenience procedures are available:

— Scheme Procedure: dereference-pointer pointer

Assuming pointer points to a memory region that holds a pointer, return this pointer.

— Scheme Procedure: string->pointer string

Return a foreign pointer to a nul-terminated copy of string in the current locale encoding. The C string is freed when the returned foreign pointer becomes unreachable.

This is the Scheme equivalent of scm_to_locale_string.

— Scheme Procedure: pointer->string pointer

Return the string representing the C nul-terminated string pointed to by pointer. The C string is assumed to be in the current locale encoding.

This is the Scheme equivalent of scm_from_locale_string.

Going back to the scm_numptob example above, here is how we can read its value as a C long integer: 

     (use-modules (rnrs bytevectors))
     
     (bytevector-uint-ref (pointer->bytevector numptob (sizeof long))
                          0 (native-endianness)
                          (sizeof long))
     ⇒ 8

If we wanted to corrupt Guile's internal state, we could set scm_numptob to another value; but we shouldn't, because that variable is not meant to be set. Indeed this point applies more widely: the C API is a dangerous place to be. Not only might setting a value crash your program, simply accessing the data pointed to by a dangling pointer or similar can prove equally disastrous.