;;; Array operations

;;;; Create a pointer from the raw, unfixed value in a vector vec at index idx.
(define ptr-array-ref
  (foreign-primitive scheme-object ((scheme-pointer vec) (int idx)) #<<EOF
    C_word ab[C_SIZEOF_POINTER], *a = ab, ptr;
    void **v = (void **)vec;
    ptr = C_mpointer(&a, v[idx]);
    return(ptr);
EOF
))

;;;; p is a pointer to an array of void pointers.  Returns the void pointer at
;;;; index i.
(define pointer-ptr-ref
  (foreign-lambda* c-pointer (((pointer "void *") p) (int i)) "return(*(p+i));"))

;;;; Map a ptr-array into a list via PROC.  Each value passed to PROC
;;;; is first converted to a Scheme pointer.

(define (ptr-array-map->list proc v)
  (let loop ([L '()]
             [i (fx- (vector-length v) 1)])
    (if (fx<= i 0)
        L
        (loop (cons (proc (ptr-array-ref v i)) L)
                    (fx- i 1)))))


;;; These are not currently used.

;;;; Mutate an entire array (vector) of raw pointers into a vector of pointer objects.
(define (ptr-array->pointer-vector! array)
  (let ((n (vector-length array)))
    (let loop ((i 0))
      (when (< i n)
        (vector-set! array i (ptr-array-ref array i))
        (loop (+ i 1))))))

;;;; Map a vector directly into a list with no intermediate vector.
(define (vector-map->list p v)
  (let ((n (vector-length v)))
    (let loop ((i 0))
      (if (>= i n)
          '()
          (cons (p i (vector-ref v i))
                (loop (+ i 1)))))))