Accessing externally defined data

For a list of the special forms that allow definition of Scheme procedures that access native C/C++ code, consult the documentation on the (chicken foreign) module. The remainder of this chapter merely explains a few special cases.

Returning large objects or chunks of memory to Scheme

When you call a C function which needs to return quantities of data, several issues arise:

• the size of the nursery is limited, so C_alloc can cause stack overflow
• if you malloc in C, and intend to leave it there, and directly access parts of that data from Scheme, you will need C accessor functions to pinpoint the parts you need and return them as Scheme objects; you will also need a finalizer if you intend for this data to be garbage-collected
• building up lists or other complex Scheme structures from individual pairs, or putting non-immediate objects into vectors, is cumbersome in C

So some would advise you to just return a pointer to Scheme, use memcpy or any other function(s) which you need to get the data into CHICKEN-managed memory and into the desired kind of data structure, then free the C data. For this example, we are trying to return an array of doubles into an f64vector; we can accomplish that by adding a specialized copy function to the C library being integrated:

void CopyResults(double* vector) {
    memcpy(vector, bezierBuffer, totalOutputPoints * sizeof(double));
}

// The original C function which takes an array of doubles, 
// does some sort of transmogrification,
// retains a new malloc'd array of the results
// and returns the count
int GenerateResults(double* vector, int count) {
    ... 
}

and the "egg" which calls the C functions can be implemented like this:

(module memcpy-demo (input->output)
    (import (chicken base) scheme (chicken foreign) srfi-4)

    (define CopyResults (foreign-lambda void "CopyResults" f64vector))

    (define GenerateResults (foreign-lambda integer "GenerateResults" f64vector integer))

    (define (input->output input)
        (let* ([size (GenerateResults input (f64vector-length input))] 
               [vect (make-f64vector size)])
            (printf "returned size ~a~%" size)
            (CopyResults vect)
            vect)))

The foreign-lambda takes care of the details in this case so that an f64vector allocated in the nursery can be treated as a plain old array of doubles in C (assuming your C compiler uses 64-bit values for double).

Various eggs provide other examples, and some of them do it more efficiently too, but this method is relatively clean and compact.

---

Previous: Interface to external functions and variables

Next: Foreign type specifiers