This is an automated email from the git hooks/post-receive script. lloda pushed a commit to branch wip-vector-cleanup in repository guile.
The following commit(s) were added to refs/heads/wip-vector-cleanup by this push: new 25b45b3 Simplify interfaces to scm_bitvector_elements and scm_bitvector_writable_elements 25b45b3 is described below commit 25b45b3505abbc66e6bc3d5fd7ffa7e39ce2985e Author: Daniel Llorens <ll...@sarc.name> AuthorDate: Wed Feb 5 12:44:58 2020 +0100 Simplify interfaces to scm_bitvector_elements and scm_bitvector_writable_elements Doc fixes & tests TBD. * libguile/bitvector.h: As stated. * libguile/bitvector.c: Fix uses of scm_bitvector_elements, scm_bitvector_writable_elements. * libguile/array-handle.c: scm_array1_bit_elements, scm_array1_bit_writable_elements: New functions. * libguile/array-handle.h: Publish the new functions. * libguile/posix.c: Fix use of scm_bitvector_elements. --- NEWS-wip-vector-cleanup.txt | 35 +++--- libguile/array-handle.c | 66 +++++++++++ libguile/array-handle.h | 4 +- libguile/bitvectors.c | 265 ++++++++++++++------------------------------ libguile/bitvectors.h | 12 +- libguile/posix.c | 3 +- 6 files changed, 173 insertions(+), 212 deletions(-) diff --git a/NEWS-wip-vector-cleanup.txt b/NEWS-wip-vector-cleanup.txt index c492668..d7915bb 100644 --- a/NEWS-wip-vector-cleanup.txt +++ b/NEWS-wip-vector-cleanup.txt @@ -34,33 +34,36 @@ Use SCM_VECTOR_REF, SCM_VECTOR_SET and SCM_VECTOR_LENGTH instead. ** scm_vector_elements / scm_vector_writable_elements take a single argument that must be a vector. -Use scm_array_get_handle and scm_array_handle_elements / -scm_array_handle_writable_elements on general arrays. +Use scm_array_get_handle and scm_array_handle_elements / scm_array_handle_writable_elements on general arrays. Use scm_c_vector_length to get the length of a vector. +** scm_bitvector_elements / scm_bitvector_writable_elements take a single argument that must be a bitvector -* Rationale / TODO - -** Fix API for scm_VECTOR_TYPE_elements scm_VECTOR_TYPE_writable_elements to [(SCM v) -> pointer] +Use scm_array_get_handle and scm_array_handle_bit_elements / scm_array_handle_bit_writable_elements on bit arrays. +Use scm_array1_bit_elements (NEW) / scm_array1_bit_writable_elements (NEW) on rank-1 bit arrays. - - incp is always one on these types, so it isn't needed - - no need to release an array handle for VECTOR_TYPE - - remove the dependence of vector.c bitvector.c bytevector.c etc. on array-handle.h -** Fix API for scm_vector_elements scm_vector_writable_elements to [(SCM v) -> pointer] +* Rationale / TODO - - the matching functions for srfi-4 VECTOR_TYPEs have never allowed passing - non-VECTOR-TYPE rank-1 arrays. There is no reason for these to allow it; if - v is an array, use the array interface. +** Status as of 3.0.0 + + - The _elements functions require the array handle interface even for true vectors, even though the handle is unnecessary. This creates a burden (having to declare, release, etc). + - The srfi-4 _elements functions don't accept arbitrary rank-1 xxxarray even though they require the array handle interface (inc, handle are superfluous). -** Fix API for scm_bitvector_elements scm_bitvector_writable_elements to [(SCM v) -> pointer] +** Plan - - same as for scm_vector_elements scm_vector_writable_elements. + - Provide scm_VTYPE_(writable_)elements with signature [(SCM) -> pointer] for all vector types. + - Provide scm_array1_VTYPE_(writable_)elements with signature [(SCM, &handle, ...) -> pointer] for all vector types. These replace the old scm_VTYPE_(writable_)elements but will be available on the array API and not on the xxxvector APIs. + - remove the dependence of vector.c bitvector.c bytevector.c etc. on array-handle.h + - remove the double dependence of array-ref -> VECTOR-TYPE-ref -> array_handle + use seen in scm_array_get_handle. + - bug: scm_bitvector_elements doesn't select for type = bit + - bug: bit-set*! already requires second arg to be true bitvector + - bug: setaffinity in posix.c failed to release the mask handle -** Remove scm_is_simple_vector, fix scm_is_array_p, rename SIMPLE_VECTOR to VECTOR, etc. - - just cleaning house +* Other ** vector-move-right!, vector-move-left!, either diff --git a/libguile/array-handle.c b/libguile/array-handle.c index 4b69e67..6ca19cc 100644 --- a/libguile/array-handle.c +++ b/libguile/array-handle.c @@ -351,6 +351,72 @@ scm_array_handle_writable_elements (scm_t_array_handle *h) return (SCM *) scm_array_handle_elements (h); } +// ----------------------------------------------- +// FIXME adding scm_array1_xxx_(writable_)elements +// ----------------------------------------------- + +const uint32_t * +scm_array1_bit_elements (SCM vec, size_t *lenp, ssize_t *incp, size_t *offp) +{ + scm_t_array_handle h; + scm_array_get_handle (vec, &h); + if (1 != scm_array_handle_rank (&h)) + { + scm_array_handle_release (&h); + scm_wrong_type_arg_msg (NULL, 0, vec, "rank 1 bit array"); + } + else if (scm_is_bitvector (h.array)) + { + scm_t_array_dim *dim = scm_array_handle_dims (&h); + if (offp) + *offp = scm_array_handle_bit_elements_offset (&h); + if (lenp) + *lenp = dim->ubnd - dim->lbnd + 1; + if (incp) + *incp = dim->inc; + + const uint32_t * val = ((const uint32_t *) h.elements) + h.base/32; + scm_array_handle_release (&h); + return val; + } + else + { + scm_array_handle_release (&h); + scm_wrong_type_arg_msg (NULL, 0, vec, "rank 1 bit array"); + } +} + +uint32_t * +scm_array1_bit_writable_elements (SCM vec, size_t *lenp, ssize_t *incp, size_t *offp) +{ + scm_t_array_handle h; + scm_array_get_handle (vec, &h); + if (1 != scm_array_handle_rank (&h)) + { + scm_array_handle_release (&h); + scm_wrong_type_arg_msg (NULL, 0, vec, "rank 1 mutable bit array"); + } + else if (scm_i_is_mutable_bitvector (h.array)) + { + scm_t_array_dim *dim = scm_array_handle_dims (&h); + if (offp) + *offp = scm_array_handle_bit_elements_offset (&h); + if (lenp) + *lenp = dim->ubnd - dim->lbnd + 1; + if (incp) + *incp = dim->inc; + + uint32_t * val = ((uint32_t *) h.elements) + h.base/32; + scm_array_handle_release (&h); + return val; + } + else + { + scm_array_handle_release (&h); + scm_wrong_type_arg_msg (NULL, 0, vec, "rank 1 mutable bit array"); + } +} + void scm_init_array_handle (void) { diff --git a/libguile/array-handle.h b/libguile/array-handle.h index 137371e..4a97bc1 100644 --- a/libguile/array-handle.h +++ b/libguile/array-handle.h @@ -97,7 +97,6 @@ SCM_API void scm_array_handle_release (scm_t_array_handle *h); SCM_API const SCM* scm_array_handle_elements (scm_t_array_handle *h); SCM_API SCM* scm_array_handle_writable_elements (scm_t_array_handle *h); - SCM_INLINE SCM scm_array_handle_ref (scm_t_array_handle *h, ssize_t pos); SCM_INLINE void scm_array_handle_set (scm_t_array_handle *h, ssize_t pos, SCM val); @@ -126,8 +125,9 @@ scm_array_handle_set (scm_t_array_handle *h, ssize_t p, SCM v) #endif - SCM_INTERNAL void scm_init_array_handle (void); +SCM_API const uint32_t * scm_array1_bit_elements (SCM vec, size_t *lenp, ssize_t *incp, size_t *offp); +SCM_API uint32_t * scm_array1_bit_writable_elements (SCM vec, size_t *lenp, ssize_t *incp, size_t *offp); #endif /* SCM_ARRAY_HANDLE_H */ diff --git a/libguile/bitvectors.c b/libguile/bitvectors.c index 0bb4c1f..137262a 100644 --- a/libguile/bitvectors.c +++ b/libguile/bitvectors.c @@ -36,6 +36,7 @@ #include "pairs.h" #include "ports.h" #include "srfi-4.h" +#include <stdbool.h> #include "bitvectors.h" @@ -204,72 +205,55 @@ scm_array_handle_bit_elements_offset (scm_t_array_handle *h) return h->base % 32; } +#define SCM_VALIDATE_BITVECTOR(pos, v) \ + do { \ + SCM_ASSERT_TYPE (IS_BITVECTOR (v), v, pos, __func__, \ + "bitvector"); \ + } while (0) + +#define SCM_VALIDATE_MUTABLE_BITVECTOR(pos, v) \ + do { \ + SCM_ASSERT_TYPE (IS_MUTABLE_BITVECTOR (v), v, pos, __func__, \ + "mutable bitvector"); \ + } while (0) + const uint32_t * -scm_bitvector_elements (SCM vec, - scm_t_array_handle *h, - size_t *offp, - size_t *lenp, - ssize_t *incp) -{ - scm_array_get_handle (vec, h); - if (1 != scm_array_handle_rank (h)) - { - scm_array_handle_release (h); - scm_wrong_type_arg_msg (NULL, 0, vec, "rank 1 bit array"); - } - if (offp) - { - scm_t_array_dim *dim = scm_array_handle_dims (h); - *offp = scm_array_handle_bit_elements_offset (h); - *lenp = dim->ubnd - dim->lbnd + 1; - *incp = dim->inc; - } - return scm_array_handle_bit_elements (h); +scm_bitvector_elements (SCM vec) +{ + SCM_VALIDATE_BITVECTOR (1, vec); + return BITVECTOR_BITS (vec); } - uint32_t * -scm_bitvector_writable_elements (SCM vec, - scm_t_array_handle *h, - size_t *offp, - size_t *lenp, - ssize_t *incp) +scm_bitvector_writable_elements (SCM vec) { - const uint32_t *ret = scm_bitvector_elements (vec, h, offp, lenp, incp); - - if (h->writable_elements != h->elements) - scm_wrong_type_arg_msg (NULL, 0, h->array, "mutable bit array"); + SCM_VALIDATE_MUTABLE_BITVECTOR (1, vec); + return BITVECTOR_BITS (vec); +} - return (uint32_t *) ret; +static inline bool +bitref_ (const uint32_t *bits, size_t idx) +{ + return (bits[idx/32] & (1L << (idx%32))); +} + +static inline void +bitset_ (uint32_t *bits, size_t idx, bool b) +{ + uint32_t mask = 1L << (idx%32); + if (b) + bits[idx/32] |= mask; + else + bits[idx/32] &= ~mask; } SCM scm_c_bitvector_ref (SCM vec, size_t idx) { - scm_t_array_handle handle; - const uint32_t *bits; - - if (IS_BITVECTOR (vec)) - { - if (idx >= BITVECTOR_LENGTH (vec)) - scm_out_of_range (NULL, scm_from_size_t (idx)); - bits = BITVECTOR_BITS(vec); - return scm_from_bool (bits[idx/32] & (1L << (idx%32))); - } - else - { - SCM res; - size_t len, off; - ssize_t inc; - - bits = scm_bitvector_elements (vec, &handle, &off, &len, &inc); - if (idx >= len) - scm_out_of_range (NULL, scm_from_size_t (idx)); - idx = idx*inc + off; - res = scm_from_bool (bits[idx/32] & (1L << (idx%32))); - scm_array_handle_release (&handle); - return res; - } + const uint32_t *bits = scm_bitvector_elements (vec); + if (idx >= BITVECTOR_LENGTH (vec)) + scm_out_of_range (NULL, scm_from_size_t (idx)); + return scm_from_bool (bitref_(bits, idx)); } SCM_DEFINE (scm_bitvector_ref, "bitvector-ref", 2, 0, 0, @@ -285,34 +269,11 @@ SCM_DEFINE (scm_bitvector_ref, "bitvector-ref", 2, 0, 0, void scm_c_bitvector_set_x (SCM vec, size_t idx, SCM val) { - scm_t_array_handle handle; - uint32_t *bits, mask; - - if (IS_MUTABLE_BITVECTOR (vec)) - { - if (idx >= BITVECTOR_LENGTH (vec)) - scm_out_of_range (NULL, scm_from_size_t (idx)); - bits = BITVECTOR_BITS(vec); - } - else - { - size_t len, off; - ssize_t inc; - - bits = scm_bitvector_writable_elements (vec, &handle, &off, &len, &inc); - if (idx >= len) - scm_out_of_range (NULL, scm_from_size_t (idx)); - idx = idx*inc + off; - } - - mask = 1L << (idx%32); - if (scm_is_true (val)) - bits[idx/32] |= mask; - else - bits[idx/32] &= ~mask; + uint32_t *bits = scm_bitvector_writable_elements (vec); + if (idx >= BITVECTOR_LENGTH (vec)) + scm_out_of_range (NULL, scm_from_size_t (idx)); - if (!IS_MUTABLE_BITVECTOR (vec)) - scm_array_handle_release (&handle); + bitset_(bits, idx, scm_is_true (val)); } SCM_DEFINE (scm_bitvector_set_x, "bitvector-set!", 3, 0, 0, @@ -332,13 +293,9 @@ SCM_DEFINE (scm_bitvector_fill_x, "bitvector-fill!", 2, 0, 0, "@var{vec} when @var{val} is true, else clear them.") #define FUNC_NAME s_scm_bitvector_fill_x { - scm_t_array_handle handle; size_t off, len; ssize_t inc; - uint32_t *bits; - - bits = scm_bitvector_writable_elements (vec, &handle, - &off, &len, &inc); + uint32_t *bits = scm_array1_bit_writable_elements (vec, &len, &inc, &off); if (off == 0 && inc == 1 && len > 0) { @@ -362,11 +319,9 @@ SCM_DEFINE (scm_bitvector_fill_x, "bitvector-fill!", 2, 0, 0, { size_t i; for (i = 0; i < len; i++) - scm_array_handle_set (&handle, i*inc, val); + bitset_(bits, off+i*inc, scm_is_true(val)); } - scm_array_handle_release (&handle); - return SCM_UNSPECIFIED; } #undef FUNC_NAME @@ -380,9 +335,7 @@ SCM_DEFINE (scm_list_to_bitvector, "list->bitvector", 1, 0, 0, size_t bit_len = scm_to_size_t (scm_length (list)); SCM vec = scm_c_make_bitvector (bit_len, SCM_UNDEFINED); size_t word_len = (bit_len+31)/32; - scm_t_array_handle handle; - uint32_t *bits = scm_bitvector_writable_elements (vec, &handle, - NULL, NULL, NULL); + uint32_t *bits = scm_bitvector_writable_elements (vec); size_t i, j; for (i = 0; i < word_len && scm_is_pair (list); i++, bit_len -= 32) @@ -395,8 +348,6 @@ SCM_DEFINE (scm_list_to_bitvector, "list->bitvector", 1, 0, 0, bits[i] |= mask; } - scm_array_handle_release (&handle); - return vec; } #undef FUNC_NAME @@ -407,13 +358,11 @@ SCM_DEFINE (scm_bitvector_to_list, "bitvector->list", 1, 0, 0, "of the bitvector @var{vec}.") #define FUNC_NAME s_scm_bitvector_to_list { - scm_t_array_handle handle; size_t off, len; ssize_t inc; - const uint32_t *bits; SCM res = SCM_EOL; - bits = scm_bitvector_elements (vec, &handle, &off, &len, &inc); + const uint32_t *bits = scm_array1_bit_elements (vec, &len, &inc, &off); if (off == 0 && inc == 1) { @@ -433,11 +382,9 @@ SCM_DEFINE (scm_bitvector_to_list, "bitvector->list", 1, 0, 0, { size_t i; for (i = 0; i < len; i++) - res = scm_cons (scm_array_handle_ref (&handle, i*inc), res); + res = scm_cons (scm_from_bool (bitref_ (bits, off+i*inc)), res); } - scm_array_handle_release (&handle); - return scm_reverse_x (res, SCM_EOL); } #undef FUNC_NAME @@ -470,14 +417,12 @@ SCM_DEFINE (scm_bit_count, "bit-count", 2, 0, 0, "@var{bitvector}.") #define FUNC_NAME s_scm_bit_count { - scm_t_array_handle handle; size_t off, len; ssize_t inc; - const uint32_t *bits; int bit = scm_to_bool (b); size_t count = 0; - bits = scm_bitvector_elements (bitvector, &handle, &off, &len, &inc); + const uint32_t *bits = scm_array1_bit_elements (bitvector, &len, &inc, &off); if (off == 0 && inc == 1 && len > 0) { @@ -495,12 +440,10 @@ SCM_DEFINE (scm_bit_count, "bit-count", 2, 0, 0, { size_t i; for (i = 0; i < len; i++) - if (scm_is_true (scm_array_handle_ref (&handle, i*inc))) + if (bitref_ (bits, off+i*inc)) count++; } - scm_array_handle_release (&handle); - return scm_from_size_t (bit? count : len-count); } #undef FUNC_NAME @@ -538,26 +481,24 @@ SCM_DEFINE (scm_bit_position, "bit-position", 3, 0, 0, "@end example") #define FUNC_NAME s_scm_bit_position { - scm_t_array_handle handle; - size_t off, len, first_bit; + size_t off, len; ssize_t inc; - const uint32_t *bits; + + const uint32_t *bits = scm_array1_bit_elements (v, &len, &inc, &off); int bit = scm_to_bool (item); SCM res = SCM_BOOL_F; - - bits = scm_bitvector_elements (v, &handle, &off, &len, &inc); - first_bit = scm_to_unsigned_integer (k, 0, len); + size_t first_bit = scm_to_unsigned_integer (k, 0, len); if (off == 0 && inc == 1 && len > 0) { - size_t i, word_len = (len + 31) / 32; + size_t word_len = (len + 31) / 32; uint32_t last_mask = ((uint32_t)-1) >> (32*word_len - len); size_t first_word = first_bit / 32; uint32_t first_mask = ((uint32_t)-1) << (first_bit - 32*first_word); uint32_t w; - for (i = first_word; i < word_len; i++) + for (size_t i = first_word; i < word_len; i++) { w = (bit? bits[i] : ~bits[i]); if (i == first_word) @@ -573,11 +514,9 @@ SCM_DEFINE (scm_bit_position, "bit-position", 3, 0, 0, } else { - size_t i; - for (i = first_bit; i < len; i++) + for (size_t i = first_bit; i < len; i++) { - SCM elt = scm_array_handle_ref (&handle, i*inc); - if ((bit && scm_is_true (elt)) || (!bit && scm_is_false (elt))) + if (bit == bitref_ (bits, off+i*inc)) { res = scm_from_size_t (i); break; @@ -585,8 +524,6 @@ SCM_DEFINE (scm_bit_position, "bit-position", 3, 0, 0, } } - scm_array_handle_release (&handle); - return res; } #undef FUNC_NAME @@ -621,29 +558,22 @@ SCM_DEFINE (scm_bit_set_star_x, "bit-set*!", 3, 0, 0, "@end example") #define FUNC_NAME s_scm_bit_set_star_x { - scm_t_array_handle v_handle; size_t v_off, v_len; ssize_t v_inc; - uint32_t *v_bits; - int bit; /* Validate that OBJ is a boolean so this is done even if we don't need BIT. */ - bit = scm_to_bool (obj); + int bit = scm_to_bool (obj); - v_bits = scm_bitvector_writable_elements (v, &v_handle, - &v_off, &v_len, &v_inc); + uint32_t *v_bits = scm_array1_bit_writable_elements (v, &v_len, &v_inc, &v_off); if (scm_is_bitvector (kv)) { - scm_t_array_handle kv_handle; size_t kv_off, kv_len; ssize_t kv_inc; - const uint32_t *kv_bits; - - kv_bits = scm_bitvector_elements (kv, &kv_handle, - &kv_off, &kv_len, &kv_inc); + + const uint32_t *kv_bits = scm_array1_bit_elements (kv, &kv_len, &kv_inc, &kv_off); if (v_len < kv_len) scm_misc_error (NULL, @@ -673,13 +603,11 @@ SCM_DEFINE (scm_bit_set_star_x, "bit-set*!", 3, 0, 0, { size_t i; for (i = 0; i < kv_len; i++) - if (scm_is_true (scm_array_handle_ref (&kv_handle, i*kv_inc))) - scm_array_handle_set (&v_handle, i*v_inc, obj); + if (bitref_ (kv_bits, kv_off+i*kv_inc)) + bitset_ (v_bits, v_off+i*v_inc, bit); } - - scm_array_handle_release (&kv_handle); - } + /* FIXME This requires a true u32vector so handle, inc, etc. are superfluous */ else if (scm_is_true (scm_u32vector_p (kv))) { scm_t_array_handle kv_handle; @@ -689,15 +617,13 @@ SCM_DEFINE (scm_bit_set_star_x, "bit-set*!", 3, 0, 0, kv_elts = scm_u32vector_elements (kv, &kv_handle, &kv_len, &kv_inc); for (i = 0; i < kv_len; i++, kv_elts += kv_inc) - scm_array_handle_set (&v_handle, (*kv_elts)*v_inc, obj); + bitset_ (v_bits, v_off+(*kv_elts)*v_inc, bit); scm_array_handle_release (&kv_handle); } else scm_wrong_type_arg_msg (NULL, 0, kv, "bitvector or u32vector"); - scm_array_handle_release (&v_handle); - return SCM_UNSPECIFIED; } #undef FUNC_NAME @@ -724,30 +650,23 @@ SCM_DEFINE (scm_bit_count_star, "bit-count*", 3, 0, 0, "@end example") #define FUNC_NAME s_scm_bit_count_star { - scm_t_array_handle v_handle; size_t v_off, v_len; ssize_t v_inc; - const uint32_t *v_bits; size_t count = 0; - int bit; /* Validate that OBJ is a boolean so this is done even if we don't need BIT. */ - bit = scm_to_bool (obj); + int bit = scm_to_bool (obj); - v_bits = scm_bitvector_elements (v, &v_handle, - &v_off, &v_len, &v_inc); + const uint32_t *v_bits = scm_array1_bit_elements (v, &v_len, &v_inc, &v_off); if (scm_is_bitvector (kv)) { - scm_t_array_handle kv_handle; size_t kv_off, kv_len; ssize_t kv_inc; - const uint32_t *kv_bits; - - kv_bits = scm_bitvector_elements (kv, &kv_handle, - &kv_off, &kv_len, &kv_inc); + + const uint32_t *kv_bits = scm_array1_bit_elements (kv, &kv_len, &kv_inc, &kv_off); if (v_len != kv_len) scm_misc_error (NULL, @@ -760,25 +679,18 @@ SCM_DEFINE (scm_bit_count_star, "bit-count*", 3, 0, 0, uint32_t last_mask = ((uint32_t)-1) >> (32*word_len - kv_len); uint32_t xor_mask = bit? 0 : ((uint32_t)-1); - for (i = 0; i < word_len-1; i++) + for (i = 0; i+1 < word_len; i++) count += count_ones ((v_bits[i]^xor_mask) & kv_bits[i]); count += count_ones ((v_bits[i]^xor_mask) & kv_bits[i] & last_mask); } else { - size_t i; - for (i = 0; i < kv_len; i++) - if (scm_is_true (scm_array_handle_ref (&kv_handle, i))) - { - SCM elt = scm_array_handle_ref (&v_handle, i*v_inc); - if ((bit && scm_is_true (elt)) || (!bit && scm_is_false (elt))) - count++; - } + for (size_t i = 0; i < kv_len; i++) + if (bitref_ (kv_bits, kv_off+i*kv_inc) == bitref_ (v_bits, v_off+i*v_inc)) + count++; } - - scm_array_handle_release (&kv_handle); - } + /* FIXME This requires a true u32vector so handle, inc, etc. are superfluous */ else if (scm_is_true (scm_u32vector_p (kv))) { scm_t_array_handle kv_handle; @@ -789,8 +701,8 @@ SCM_DEFINE (scm_bit_count_star, "bit-count*", 3, 0, 0, kv_elts = scm_u32vector_elements (kv, &kv_handle, &kv_len, &kv_inc); for (i = 0; i < kv_len; i++, kv_elts += kv_inc) { - SCM elt = scm_array_handle_ref (&v_handle, (*kv_elts)*v_inc); - if ((bit && scm_is_true (elt)) || (!bit && scm_is_false (elt))) + bool elt = bitref_ (v_bits, v_off+(*kv_elts)*v_inc); + if ((bit && elt) || (!bit && !elt)) count++; } @@ -799,8 +711,6 @@ SCM_DEFINE (scm_bit_count_star, "bit-count*", 3, 0, 0, else scm_wrong_type_arg_msg (NULL, 0, kv, "bitvector or u32vector"); - scm_array_handle_release (&v_handle); - return scm_from_size_t (count); } #undef FUNC_NAME @@ -811,18 +721,15 @@ SCM_DEFINE (scm_bit_invert_x, "bit-invert!", 1, 0, 0, "its negation.") #define FUNC_NAME s_scm_bit_invert_x { - scm_t_array_handle handle; size_t off, len; ssize_t inc; - uint32_t *bits; + uint32_t *bits = scm_array1_bit_writable_elements (v, &len, &inc, &off); - bits = scm_bitvector_writable_elements (v, &handle, &off, &len, &inc); - + /* FIXME could easily deal with off!=0 here */ if (off == 0 && inc == 1 && len > 0) { - size_t word_len = (len + 31) / 32; + size_t i, word_len = (len + 31) / 32; uint32_t last_mask = ((uint32_t)-1) >> (32*word_len - len); - size_t i; for (i = 0; i < word_len-1; i++) bits[i] = ~bits[i]; @@ -830,14 +737,10 @@ SCM_DEFINE (scm_bit_invert_x, "bit-invert!", 1, 0, 0, } else { - size_t i; - for (i = 0; i < len; i++) - scm_array_handle_set (&handle, i*inc, - scm_not (scm_array_handle_ref (&handle, i*inc))); + for (size_t i = 0; i < len; i++) + bitset_ (bits, off+i*inc, !(bitref_ (bits, off+i*inc))); } - scm_array_handle_release (&handle); - return SCM_UNSPECIFIED; } #undef FUNC_NAME @@ -846,7 +749,6 @@ SCM_DEFINE (scm_bit_invert_x, "bit-invert!", 1, 0, 0, SCM scm_istr2bve (SCM str) { - scm_t_array_handle handle; size_t len = scm_i_string_length (str); SCM vec = scm_c_make_bitvector (len, SCM_UNDEFINED); SCM res = vec; @@ -856,7 +758,7 @@ scm_istr2bve (SCM str) const char *c_str; uint32_t *data; - data = scm_bitvector_writable_elements (vec, &handle, NULL, NULL, NULL); + data = scm_bitvector_writable_elements (vec); c_str = scm_i_string_chars (str); for (k = 0; k < (len + 31) / 32; k++) @@ -880,7 +782,6 @@ scm_istr2bve (SCM str) } exit: - scm_array_handle_release (&handle); scm_remember_upto_here_1 (str); return res; } diff --git a/libguile/bitvectors.h b/libguile/bitvectors.h index c3b0b43..8263907 100644 --- a/libguile/bitvectors.h +++ b/libguile/bitvectors.h @@ -57,16 +57,8 @@ SCM_API void scm_c_bitvector_set_x (SCM vec, size_t idx, SCM val); SCM_API const uint32_t *scm_array_handle_bit_elements (scm_t_array_handle *h); SCM_API uint32_t *scm_array_handle_bit_writable_elements (scm_t_array_handle *h); SCM_API size_t scm_array_handle_bit_elements_offset (scm_t_array_handle *h); -SCM_API const uint32_t *scm_bitvector_elements (SCM vec, - scm_t_array_handle *h, - size_t *offp, - size_t *lenp, - ssize_t *incp); -SCM_API uint32_t *scm_bitvector_writable_elements (SCM vec, - scm_t_array_handle *h, - size_t *offp, - size_t *lenp, - ssize_t *incp); +SCM_API const uint32_t *scm_bitvector_elements (SCM vec); +SCM_API uint32_t *scm_bitvector_writable_elements (SCM vec); SCM_INTERNAL uint32_t *scm_i_bitvector_bits (SCM vec); SCM_INTERNAL int scm_i_is_mutable_bitvector (SCM vec); diff --git a/libguile/posix.c b/libguile/posix.c index ab64b58..64649ab 100644 --- a/libguile/posix.c +++ b/libguile/posix.c @@ -2163,13 +2163,12 @@ SCM_DEFINE (scm_setaffinity, "setaffinity", 2, 0, 0, #define FUNC_NAME s_scm_setaffinity { cpu_set_t cs; - scm_t_array_handle handle; const uint32_t *c_mask; size_t len, off, cpu; ssize_t inc; int err; - c_mask = scm_bitvector_elements (mask, &handle, &off, &len, &inc); + c_mask = scm_array1_bit_elements (mask, &len, &inc, &off); CPU_ZERO (&cs); for (cpu = 0; cpu < len; cpu++)