mirror/guile
mirror/guile
1
Fork 0
mirror of https://git.savannah.gnu.org/git/guile.git synced 2025-06-14 23:50:19 +02:00
Code Activity

Replace uses of scm_t_int8, scm_t_uintmax, etc with stdint types

Browse source 
* libguile/bitvectors.c:
* libguile/bitvectors.h:
* libguile/bytevectors.c:
* libguile/bytevectors.h:
* libguile/chars.c:
* libguile/continuations.c:
* libguile/control.c:
* libguile/conv-integer.i.c:
* libguile/conv-uinteger.i.c:
* libguile/dynstack.c:
* libguile/dynstack.h:
* libguile/foreign.c:
* libguile/frames.c:
* libguile/frames.h:
* libguile/gc-inline.h:
* libguile/gc.h:
* libguile/gsubr.c:
* libguile/gsubr.h:
* libguile/hash.c:
* libguile/i18n.c:
* libguile/instructions.c:
* libguile/intrinsics.c:
* libguile/intrinsics.h:
* libguile/loader.c:
* libguile/loader.h:
* libguile/numbers.c:
* libguile/numbers.h:
* libguile/pairs.c:
* libguile/ports-internal.h:
* libguile/ports.c:
* libguile/ports.h:
* libguile/posix.c:
* libguile/print.c:
* libguile/print.h:
* libguile/programs.c:
* libguile/programs.h:
* libguile/r6rs-ports.c:
* libguile/random.c:
* libguile/random.h:
* libguile/scm.h:
* libguile/socket.c:
* libguile/srfi-4.c:
* libguile/srfi-4.h:
* libguile/stacks.c:
* libguile/stime.c:
* libguile/strings.c:
* libguile/struct.c:
* libguile/struct.h:
* libguile/symbols.c:
* libguile/threads.c:
* libguile/threads.h:
* libguile/uniform.c:
* libguile/vm-engine.c:
* libguile/vm.c:
* libguile/vm.h:
* libguile/vports.c:
* test-suite/standalone/test-conversion.c:
* test-suite/standalone/test-ffi-lib.c:
* test-suite/standalone/test-scm-take-u8vector.c:
* test-suite/standalone/test-srfi-4.c: Replace e.g. scm_t_uint8 with
  uint8_t.
This commit is contained in:
Andy Wingo 2018-06-21 08:39:03 +02:00
parent 5e5afde06f
commit 16879cabed
59 changed files with 924 additions and 924 deletions
Download patch file Download diff file Expand all files Collapse all files

102
libguile/bitvectors.c
View file

@ -52,9 +52,9 @@
((SCM_CELL_TYPE (x) & (0x7f | SCM_F_BITVECTOR_IMMUTABLE)) \ ((SCM_CELL_TYPE (x) & (0x7f | SCM_F_BITVECTOR_IMMUTABLE)) \
== scm_tc7_bitvector)) == scm_tc7_bitvector))
#define BITVECTOR_LENGTH(obj) ((size_t)SCM_CELL_WORD_1(obj)) #define BITVECTOR_LENGTH(obj) ((size_t)SCM_CELL_WORD_1(obj))
#define BITVECTOR_BITS(obj) ((scm_t_uint32 *)SCM_CELL_WORD_2(obj)) #define BITVECTOR_BITS(obj) ((uint32_t *)SCM_CELL_WORD_2(obj))
scm_t_uint32 * uint32_t *
scm_i_bitvector_bits (SCM vec) scm_i_bitvector_bits (SCM vec)
{ {
if (!IS_BITVECTOR (vec)) if (!IS_BITVECTOR (vec))
@ -73,13 +73,13 @@ scm_i_print_bitvector (SCM vec, SCM port, scm_print_state *pstate)
{ {
size_t bit_len = BITVECTOR_LENGTH (vec); size_t bit_len = BITVECTOR_LENGTH (vec);
size_t word_len = (bit_len+31)/32; size_t word_len = (bit_len+31)/32;
scm_t_uint32 *bits = BITVECTOR_BITS (vec); uint32_t *bits = BITVECTOR_BITS (vec);
size_t i, j; size_t i, j;
scm_puts ("#*", port); scm_puts ("#*", port);
for (i = 0; i < word_len; i++, bit_len -= 32) for (i = 0; i < word_len; i++, bit_len -= 32)
{ {
scm_t_uint32 mask = 1; uint32_t mask = 1;
for (j = 0; j < 32 && j < bit_len; j++, mask <<= 1) for (j = 0; j < 32 && j < bit_len; j++, mask <<= 1)
scm_putc ((bits[i] & mask)? '1' : '0', port); scm_putc ((bits[i] & mask)? '1' : '0', port);
} }
@ -92,9 +92,9 @@ scm_i_bitvector_equal_p (SCM vec1, SCM vec2)
{ {
size_t bit_len = BITVECTOR_LENGTH (vec1); size_t bit_len = BITVECTOR_LENGTH (vec1);
size_t word_len = (bit_len + 31) / 32; size_t word_len = (bit_len + 31) / 32;
scm_t_uint32 last_mask = ((scm_t_uint32)-1) >> (32*word_len - bit_len); uint32_t last_mask = ((uint32_t)-1) >> (32*word_len - bit_len);
scm_t_uint32 *bits1 = BITVECTOR_BITS (vec1); uint32_t *bits1 = BITVECTOR_BITS (vec1);
scm_t_uint32 *bits2 = BITVECTOR_BITS (vec2); uint32_t *bits2 = BITVECTOR_BITS (vec2);
/* compare lengths */ /* compare lengths */
if (BITVECTOR_LENGTH (vec2) != bit_len) if (BITVECTOR_LENGTH (vec2) != bit_len)
@ -103,7 +103,7 @@ scm_i_bitvector_equal_p (SCM vec1, SCM vec2)
if (bit_len == 0) if (bit_len == 0)
return SCM_BOOL_T; return SCM_BOOL_T;
/* compare full words */ /* compare full words */
if (memcmp (bits1, bits2, sizeof (scm_t_uint32) * (word_len-1))) if (memcmp (bits1, bits2, sizeof (uint32_t) * (word_len-1)))
return SCM_BOOL_F; return SCM_BOOL_F;
/* compare partial last words */ /* compare partial last words */
if ((bits1[word_len-1] & last_mask) != (bits2[word_len-1] & last_mask)) if ((bits1[word_len-1] & last_mask) != (bits2[word_len-1] & last_mask))
@ -131,17 +131,17 @@ SCM
scm_c_make_bitvector (size_t len, SCM fill) scm_c_make_bitvector (size_t len, SCM fill)
{ {
size_t word_len = (len + 31) / 32; size_t word_len = (len + 31) / 32;
scm_t_uint32 *bits; uint32_t *bits;
SCM res; SCM res;
bits = scm_gc_malloc_pointerless (sizeof (scm_t_uint32) * word_len, bits = scm_gc_malloc_pointerless (sizeof (uint32_t) * word_len,
"bitvector"); "bitvector");
res = scm_double_cell (scm_tc7_bitvector, len, (scm_t_bits)bits, 0); res = scm_double_cell (scm_tc7_bitvector, len, (scm_t_bits)bits, 0);
if (!SCM_UNBNDP (fill)) if (!SCM_UNBNDP (fill))
scm_bitvector_fill_x (res, fill); scm_bitvector_fill_x (res, fill);
else else
memset (bits, 0, sizeof (scm_t_uint32) * word_len); memset (bits, 0, sizeof (uint32_t) * word_len);
return res; return res;
} }
@ -182,20 +182,20 @@ SCM_DEFINE (scm_bitvector_length, "bitvector-length", 1, 0, 0,
} }
#undef FUNC_NAME #undef FUNC_NAME
const scm_t_uint32 * const uint32_t *
scm_array_handle_bit_elements (scm_t_array_handle *h) scm_array_handle_bit_elements (scm_t_array_handle *h)
{ {
if (h->element_type != SCM_ARRAY_ELEMENT_TYPE_BIT) if (h->element_type != SCM_ARRAY_ELEMENT_TYPE_BIT)
scm_wrong_type_arg_msg (NULL, 0, h->array, "bit array"); scm_wrong_type_arg_msg (NULL, 0, h->array, "bit array");
return ((const scm_t_uint32 *) h->elements) + h->base/32; return ((const uint32_t *) h->elements) + h->base/32;
} }
scm_t_uint32 * uint32_t *
scm_array_handle_bit_writable_elements (scm_t_array_handle *h) scm_array_handle_bit_writable_elements (scm_t_array_handle *h)
{ {
if (h->writable_elements != h->elements) if (h->writable_elements != h->elements)
scm_wrong_type_arg_msg (NULL, 0, h->array, "mutable bit array"); scm_wrong_type_arg_msg (NULL, 0, h->array, "mutable bit array");
return (scm_t_uint32 *) scm_array_handle_bit_elements (h); return (uint32_t *) scm_array_handle_bit_elements (h);
} }
size_t size_t
@ -204,7 +204,7 @@ scm_array_handle_bit_elements_offset (scm_t_array_handle *h)
return h->base % 32; return h->base % 32;
} }
const scm_t_uint32 * const uint32_t *
scm_bitvector_elements (SCM vec, scm_bitvector_elements (SCM vec,
scm_t_array_handle *h, scm_t_array_handle *h,
size_t *offp, size_t *offp,
@ -228,26 +228,26 @@ scm_bitvector_elements (SCM vec,
} }
scm_t_uint32 * uint32_t *
scm_bitvector_writable_elements (SCM vec, scm_bitvector_writable_elements (SCM vec,
scm_t_array_handle *h, scm_t_array_handle *h,
size_t *offp, size_t *offp,
size_t *lenp, size_t *lenp,
ssize_t *incp) ssize_t *incp)
{ {
const scm_t_uint32 *ret = scm_bitvector_elements (vec, h, offp, lenp, incp); const uint32_t *ret = scm_bitvector_elements (vec, h, offp, lenp, incp);
if (h->writable_elements != h->elements) if (h->writable_elements != h->elements)
scm_wrong_type_arg_msg (NULL, 0, h->array, "mutable bit array"); scm_wrong_type_arg_msg (NULL, 0, h->array, "mutable bit array");
return (scm_t_uint32 *) ret; return (uint32_t *) ret;
} }
SCM SCM
scm_c_bitvector_ref (SCM vec, size_t idx) scm_c_bitvector_ref (SCM vec, size_t idx)
{ {
scm_t_array_handle handle; scm_t_array_handle handle;
const scm_t_uint32 *bits; const uint32_t *bits;
if (IS_BITVECTOR (vec)) if (IS_BITVECTOR (vec))
{ {
@ -286,7 +286,7 @@ void
scm_c_bitvector_set_x (SCM vec, size_t idx, SCM val) scm_c_bitvector_set_x (SCM vec, size_t idx, SCM val)
{ {
scm_t_array_handle handle; scm_t_array_handle handle;
scm_t_uint32 *bits, mask; uint32_t *bits, mask;
if (IS_MUTABLE_BITVECTOR (vec)) if (IS_MUTABLE_BITVECTOR (vec))
{ {
@ -335,7 +335,7 @@ SCM_DEFINE (scm_bitvector_fill_x, "bitvector-fill!", 2, 0, 0,
scm_t_array_handle handle; scm_t_array_handle handle;
size_t off, len; size_t off, len;
ssize_t inc; ssize_t inc;
scm_t_uint32 *bits; uint32_t *bits;
bits = scm_bitvector_writable_elements (vec, &handle, bits = scm_bitvector_writable_elements (vec, &handle,
&off, &len, &inc); &off, &len, &inc);
@ -345,16 +345,16 @@ SCM_DEFINE (scm_bitvector_fill_x, "bitvector-fill!", 2, 0, 0,
/* the usual case /* the usual case
*/ */
size_t word_len = (len + 31) / 32; size_t word_len = (len + 31) / 32;
scm_t_uint32 last_mask = ((scm_t_uint32)-1) >> (32*word_len - len); uint32_t last_mask = ((uint32_t)-1) >> (32*word_len - len);
if (scm_is_true (val)) if (scm_is_true (val))
{ {
memset (bits, 0xFF, sizeof(scm_t_uint32)*(word_len-1)); memset (bits, 0xFF, sizeof(uint32_t)*(word_len-1));
bits[word_len-1] |= last_mask; bits[word_len-1] |= last_mask;
} }
else else
{ {
memset (bits, 0x00, sizeof(scm_t_uint32)*(word_len-1)); memset (bits, 0x00, sizeof(uint32_t)*(word_len-1));
bits[word_len-1] &= ~last_mask; bits[word_len-1] &= ~last_mask;
} }
} }
@ -381,13 +381,13 @@ SCM_DEFINE (scm_list_to_bitvector, "list->bitvector", 1, 0, 0,
SCM vec = scm_c_make_bitvector (bit_len, SCM_UNDEFINED); SCM vec = scm_c_make_bitvector (bit_len, SCM_UNDEFINED);
size_t word_len = (bit_len+31)/32; size_t word_len = (bit_len+31)/32;
scm_t_array_handle handle; scm_t_array_handle handle;
scm_t_uint32 *bits = scm_bitvector_writable_elements (vec, &handle, uint32_t *bits = scm_bitvector_writable_elements (vec, &handle,
NULL, NULL, NULL); NULL, NULL, NULL);
size_t i, j; size_t i, j;
for (i = 0; i < word_len && scm_is_pair (list); i++, bit_len -= 32) for (i = 0; i < word_len && scm_is_pair (list); i++, bit_len -= 32)
{ {
scm_t_uint32 mask = 1; uint32_t mask = 1;
bits[i] = 0; bits[i] = 0;
for (j = 0; j < 32 && j < bit_len; for (j = 0; j < 32 && j < bit_len;
j++, mask <<= 1, list = SCM_CDR (list)) j++, mask <<= 1, list = SCM_CDR (list))
@ -410,7 +410,7 @@ SCM_DEFINE (scm_bitvector_to_list, "bitvector->list", 1, 0, 0,
scm_t_array_handle handle; scm_t_array_handle handle;
size_t off, len; size_t off, len;
ssize_t inc; ssize_t inc;
const scm_t_uint32 *bits; const uint32_t *bits;
SCM res = SCM_EOL; SCM res = SCM_EOL;
bits = scm_bitvector_elements (vec, &handle, &off, &len, &inc); bits = scm_bitvector_elements (vec, &handle, &off, &len, &inc);
@ -424,7 +424,7 @@ SCM_DEFINE (scm_bitvector_to_list, "bitvector->list", 1, 0, 0,
for (i = 0; i < word_len; i++, len -= 32) for (i = 0; i < word_len; i++, len -= 32)
{ {
scm_t_uint32 mask = 1; uint32_t mask = 1;
for (j = 0; j < 32 && j < len; j++, mask <<= 1) for (j = 0; j < 32 && j < len; j++, mask <<= 1)
res = scm_cons ((bits[i] & mask)? SCM_BOOL_T : SCM_BOOL_F, res); res = scm_cons ((bits[i] & mask)? SCM_BOOL_T : SCM_BOOL_F, res);
} }
@ -455,7 +455,7 @@ SCM_DEFINE (scm_bitvector_to_list, "bitvector->list", 1, 0, 0,
*/ */
static size_t static size_t
count_ones (scm_t_uint32 x) count_ones (uint32_t x)
{ {
x=x-((x>>1)&0x55555555); x=x-((x>>1)&0x55555555);
x=(x&0x33333333)+((x>>2)&0x33333333); x=(x&0x33333333)+((x>>2)&0x33333333);
@ -473,7 +473,7 @@ SCM_DEFINE (scm_bit_count, "bit-count", 2, 0, 0,
scm_t_array_handle handle; scm_t_array_handle handle;
size_t off, len; size_t off, len;
ssize_t inc; ssize_t inc;
const scm_t_uint32 *bits; const uint32_t *bits;
int bit = scm_to_bool (b); int bit = scm_to_bool (b);
size_t count = 0; size_t count = 0;
@ -484,7 +484,7 @@ SCM_DEFINE (scm_bit_count, "bit-count", 2, 0, 0,
/* the usual case /* the usual case
*/ */
size_t word_len = (len + 31) / 32; size_t word_len = (len + 31) / 32;
scm_t_uint32 last_mask = ((scm_t_uint32)-1) >> (32*word_len - len); uint32_t last_mask = ((uint32_t)-1) >> (32*word_len - len);
size_t i; size_t i;
for (i = 0; i < word_len-1; i++) for (i = 0; i < word_len-1; i++)
@ -508,7 +508,7 @@ SCM_DEFINE (scm_bit_count, "bit-count", 2, 0, 0,
/* returns 32 for x == 0. /* returns 32 for x == 0.
*/ */
static size_t static size_t
find_first_one (scm_t_uint32 x) find_first_one (uint32_t x)
{ {
size_t pos = 0; size_t pos = 0;
/* do a binary search in x. */ /* do a binary search in x. */
@ -541,7 +541,7 @@ SCM_DEFINE (scm_bit_position, "bit-position", 3, 0, 0,
scm_t_array_handle handle; scm_t_array_handle handle;
size_t off, len, first_bit; size_t off, len, first_bit;
ssize_t inc; ssize_t inc;
const scm_t_uint32 *bits; const uint32_t *bits;
int bit = scm_to_bool (item); int bit = scm_to_bool (item);
SCM res = SCM_BOOL_F; SCM res = SCM_BOOL_F;
@ -551,11 +551,11 @@ SCM_DEFINE (scm_bit_position, "bit-position", 3, 0, 0,
if (off == 0 && inc == 1 && len > 0) if (off == 0 && inc == 1 && len > 0)
{ {
size_t i, word_len = (len + 31) / 32; size_t i, word_len = (len + 31) / 32;
scm_t_uint32 last_mask = ((scm_t_uint32)-1) >> (32*word_len - len); uint32_t last_mask = ((uint32_t)-1) >> (32*word_len - len);
size_t first_word = first_bit / 32; size_t first_word = first_bit / 32;
scm_t_uint32 first_mask = uint32_t first_mask =
((scm_t_uint32)-1) << (first_bit - 32*first_word); ((uint32_t)-1) << (first_bit - 32*first_word);
scm_t_uint32 w; uint32_t w;
for (i = first_word; i < word_len; i++) for (i = first_word; i < word_len; i++)
{ {
@ -624,7 +624,7 @@ SCM_DEFINE (scm_bit_set_star_x, "bit-set*!", 3, 0, 0,
scm_t_array_handle v_handle; scm_t_array_handle v_handle;
size_t v_off, v_len; size_t v_off, v_len;
ssize_t v_inc; ssize_t v_inc;
scm_t_uint32 *v_bits; uint32_t *v_bits;
int bit; int bit;
/* Validate that OBJ is a boolean so this is done even if we don't /* Validate that OBJ is a boolean so this is done even if we don't
@ -640,7 +640,7 @@ SCM_DEFINE (scm_bit_set_star_x, "bit-set*!", 3, 0, 0,
scm_t_array_handle kv_handle; scm_t_array_handle kv_handle;
size_t kv_off, kv_len; size_t kv_off, kv_len;
ssize_t kv_inc; ssize_t kv_inc;
const scm_t_uint32 *kv_bits; const uint32_t *kv_bits;
kv_bits = scm_bitvector_elements (kv, &kv_handle, kv_bits = scm_bitvector_elements (kv, &kv_handle,
&kv_off, &kv_len, &kv_inc); &kv_off, &kv_len, &kv_inc);
@ -653,7 +653,7 @@ SCM_DEFINE (scm_bit_set_star_x, "bit-set*!", 3, 0, 0,
if (v_off == 0 && v_inc == 1 && kv_off == 0 && kv_inc == 1 && kv_len > 0) if (v_off == 0 && v_inc == 1 && kv_off == 0 && kv_inc == 1 && kv_len > 0)
{ {
size_t word_len = (kv_len + 31) / 32; size_t word_len = (kv_len + 31) / 32;
scm_t_uint32 last_mask = ((scm_t_uint32)-1) >> (32*word_len - kv_len); uint32_t last_mask = ((uint32_t)-1) >> (32*word_len - kv_len);
size_t i; size_t i;
if (bit == 0) if (bit == 0)
@ -685,7 +685,7 @@ SCM_DEFINE (scm_bit_set_star_x, "bit-set*!", 3, 0, 0,
scm_t_array_handle kv_handle; scm_t_array_handle kv_handle;
size_t i, kv_len; size_t i, kv_len;
ssize_t kv_inc; ssize_t kv_inc;
const scm_t_uint32 *kv_elts; const uint32_t *kv_elts;
kv_elts = scm_u32vector_elements (kv, &kv_handle, &kv_len, &kv_inc); kv_elts = scm_u32vector_elements (kv, &kv_handle, &kv_len, &kv_inc);
for (i = 0; i < kv_len; i++, kv_elts += kv_inc) for (i = 0; i < kv_len; i++, kv_elts += kv_inc)
@ -727,7 +727,7 @@ SCM_DEFINE (scm_bit_count_star, "bit-count*", 3, 0, 0,
scm_t_array_handle v_handle; scm_t_array_handle v_handle;
size_t v_off, v_len; size_t v_off, v_len;
ssize_t v_inc; ssize_t v_inc;
const scm_t_uint32 *v_bits; const uint32_t *v_bits;
size_t count = 0; size_t count = 0;
int bit; int bit;
@ -744,7 +744,7 @@ SCM_DEFINE (scm_bit_count_star, "bit-count*", 3, 0, 0,
scm_t_array_handle kv_handle; scm_t_array_handle kv_handle;
size_t kv_off, kv_len; size_t kv_off, kv_len;
ssize_t kv_inc; ssize_t kv_inc;
const scm_t_uint32 *kv_bits; const uint32_t *kv_bits;
kv_bits = scm_bitvector_elements (kv, &kv_handle, kv_bits = scm_bitvector_elements (kv, &kv_handle,
&kv_off, &kv_len, &kv_inc); &kv_off, &kv_len, &kv_inc);
@ -757,8 +757,8 @@ SCM_DEFINE (scm_bit_count_star, "bit-count*", 3, 0, 0,
if (v_off == 0 && v_inc == 1 && kv_off == 0 && kv_inc == 1 && kv_len > 0) if (v_off == 0 && v_inc == 1 && kv_off == 0 && kv_inc == 1 && kv_len > 0)
{ {
size_t i, word_len = (kv_len + 31) / 32; size_t i, word_len = (kv_len + 31) / 32;
scm_t_uint32 last_mask = ((scm_t_uint32)-1) >> (32*word_len - kv_len); uint32_t last_mask = ((uint32_t)-1) >> (32*word_len - kv_len);
scm_t_uint32 xor_mask = bit? 0 : ((scm_t_uint32)-1); uint32_t xor_mask = bit? 0 : ((uint32_t)-1);
for (i = 0; i < word_len-1; i++) for (i = 0; i < word_len-1; i++)
count += count_ones ((v_bits[i]^xor_mask) & kv_bits[i]); count += count_ones ((v_bits[i]^xor_mask) & kv_bits[i]);
@ -784,7 +784,7 @@ SCM_DEFINE (scm_bit_count_star, "bit-count*", 3, 0, 0,
scm_t_array_handle kv_handle; scm_t_array_handle kv_handle;
size_t i, kv_len; size_t i, kv_len;
ssize_t kv_inc; ssize_t kv_inc;
const scm_t_uint32 *kv_elts; const uint32_t *kv_elts;
kv_elts = scm_u32vector_elements (kv, &kv_handle, &kv_len, &kv_inc); kv_elts = scm_u32vector_elements (kv, &kv_handle, &kv_len, &kv_inc);
for (i = 0; i < kv_len; i++, kv_elts += kv_inc) for (i = 0; i < kv_len; i++, kv_elts += kv_inc)
@ -814,14 +814,14 @@ SCM_DEFINE (scm_bit_invert_x, "bit-invert!", 1, 0, 0,
scm_t_array_handle handle; scm_t_array_handle handle;
size_t off, len; size_t off, len;
ssize_t inc; ssize_t inc;
scm_t_uint32 *bits; uint32_t *bits;
bits = scm_bitvector_writable_elements (v, &handle, &off, &len, &inc); bits = scm_bitvector_writable_elements (v, &handle, &off, &len, &inc);
if (off == 0 && inc == 1 && len > 0) if (off == 0 && inc == 1 && len > 0)
{ {
size_t word_len = (len + 31) / 32; size_t word_len = (len + 31) / 32;
scm_t_uint32 last_mask = ((scm_t_uint32)-1) >> (32*word_len - len); uint32_t last_mask = ((uint32_t)-1) >> (32*word_len - len);
size_t i; size_t i;
for (i = 0; i < word_len-1; i++) for (i = 0; i < word_len-1; i++)
@ -851,10 +851,10 @@ scm_istr2bve (SCM str)
SCM vec = scm_c_make_bitvector (len, SCM_UNDEFINED); SCM vec = scm_c_make_bitvector (len, SCM_UNDEFINED);
SCM res = vec; SCM res = vec;
scm_t_uint32 mask; uint32_t mask;
size_t k, j; size_t k, j;
const char *c_str; const char *c_str;
scm_t_uint32 *data; uint32_t *data;
data = scm_bitvector_writable_elements (vec, &handle, NULL, NULL, NULL); data = scm_bitvector_writable_elements (vec, &handle, NULL, NULL, NULL);
c_str = scm_i_string_chars (str); c_str = scm_i_string_chars (str);

10
libguile/bitvectors.h
View file

@ -54,21 +54,21 @@ SCM_API SCM scm_c_make_bitvector (size_t len, SCM fill);
SCM_API size_t scm_c_bitvector_length (SCM vec); SCM_API size_t scm_c_bitvector_length (SCM vec);
SCM_API SCM scm_c_bitvector_ref (SCM vec, size_t idx); SCM_API SCM scm_c_bitvector_ref (SCM vec, size_t idx);
SCM_API void scm_c_bitvector_set_x (SCM vec, size_t idx, SCM val); SCM_API void scm_c_bitvector_set_x (SCM vec, size_t idx, SCM val);
SCM_API const scm_t_uint32 *scm_array_handle_bit_elements (scm_t_array_handle *h); SCM_API const uint32_t *scm_array_handle_bit_elements (scm_t_array_handle *h);
SCM_API scm_t_uint32 *scm_array_handle_bit_writable_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 size_t scm_array_handle_bit_elements_offset (scm_t_array_handle *h);
SCM_API const scm_t_uint32 *scm_bitvector_elements (SCM vec, SCM_API const uint32_t *scm_bitvector_elements (SCM vec,
scm_t_array_handle *h, scm_t_array_handle *h,
size_t *offp, size_t *offp,
size_t *lenp, size_t *lenp,
ssize_t *incp); ssize_t *incp);
SCM_API scm_t_uint32 *scm_bitvector_writable_elements (SCM vec, SCM_API uint32_t *scm_bitvector_writable_elements (SCM vec,
scm_t_array_handle *h, scm_t_array_handle *h,
size_t *offp, size_t *offp,
size_t *lenp, size_t *lenp,
ssize_t *incp); ssize_t *incp);
SCM_INTERNAL scm_t_uint32 *scm_i_bitvector_bits (SCM vec); SCM_INTERNAL uint32_t *scm_i_bitvector_bits (SCM vec);
SCM_INTERNAL int scm_i_is_mutable_bitvector (SCM vec); SCM_INTERNAL int scm_i_is_mutable_bitvector (SCM vec);
SCM_INTERNAL int scm_i_print_bitvector (SCM vec, SCM port, scm_print_state *pstate); SCM_INTERNAL int scm_i_print_bitvector (SCM vec, SCM port, scm_print_state *pstate);
SCM_INTERNAL SCM scm_i_bitvector_equal_p (SCM vec1, SCM vec2); SCM_INTERNAL SCM scm_i_bitvector_equal_p (SCM vec1, SCM vec2);

60
libguile/bytevectors.c
View file

@ -61,12 +61,12 @@
/* Convenience macros. These are used by the various templates (macros) that /* Convenience macros. These are used by the various templates (macros) that
are parameterized by integer signedness. */ are parameterized by integer signedness. */
#define INT8_T_signed scm_t_int8 #define INT8_T_signed int8_t
#define INT8_T_unsigned scm_t_uint8 #define INT8_T_unsigned uint8_t
#define INT16_T_signed scm_t_int16 #define INT16_T_signed int16_t
#define INT16_T_unsigned scm_t_uint16 #define INT16_T_unsigned uint16_t
#define INT32_T_signed scm_t_int32 #define INT32_T_signed int32_t
#define INT32_T_unsigned scm_t_uint32 #define INT32_T_unsigned uint32_t
#define is_signed_int8(_x) (((_x) >= -128L) && ((_x) <= 127L)) #define is_signed_int8(_x) (((_x) >= -128L) && ((_x) <= 127L))
#define is_unsigned_int8(_x) ((_x) <= 255UL) #define is_unsigned_int8(_x) ((_x) <= 255UL)
#define is_signed_int16(_x) (((_x) >= -32768L) && ((_x) <= 32767L)) #define is_signed_int16(_x) (((_x) >= -32768L) && ((_x) <= 32767L))
@ -374,17 +374,17 @@ scm_c_bytevector_length (SCM bv)
} }
#undef FUNC_NAME #undef FUNC_NAME
scm_t_uint8 uint8_t
scm_c_bytevector_ref (SCM bv, size_t index) scm_c_bytevector_ref (SCM bv, size_t index)
#define FUNC_NAME "scm_c_bytevector_ref" #define FUNC_NAME "scm_c_bytevector_ref"
{ {
size_t c_len; size_t c_len;
const scm_t_uint8 *c_bv; const uint8_t *c_bv;
SCM_VALIDATE_BYTEVECTOR (1, bv); SCM_VALIDATE_BYTEVECTOR (1, bv);
c_len = SCM_BYTEVECTOR_LENGTH (bv); c_len = SCM_BYTEVECTOR_LENGTH (bv);
c_bv = (scm_t_uint8 *) SCM_BYTEVECTOR_CONTENTS (bv); c_bv = (uint8_t *) SCM_BYTEVECTOR_CONTENTS (bv);
if (SCM_UNLIKELY (index >= c_len)) if (SCM_UNLIKELY (index >= c_len))
scm_out_of_range (FUNC_NAME, scm_from_size_t (index)); scm_out_of_range (FUNC_NAME, scm_from_size_t (index));
@ -394,16 +394,16 @@ scm_c_bytevector_ref (SCM bv, size_t index)
#undef FUNC_NAME #undef FUNC_NAME
void void
scm_c_bytevector_set_x (SCM bv, size_t index, scm_t_uint8 value) scm_c_bytevector_set_x (SCM bv, size_t index, uint8_t value)
#define FUNC_NAME "scm_c_bytevector_set_x" #define FUNC_NAME "scm_c_bytevector_set_x"
{ {
size_t c_len; size_t c_len;
scm_t_uint8 *c_bv; uint8_t *c_bv;
SCM_VALIDATE_MUTABLE_BYTEVECTOR (1, bv); SCM_VALIDATE_MUTABLE_BYTEVECTOR (1, bv);
c_len = SCM_BYTEVECTOR_LENGTH (bv); c_len = SCM_BYTEVECTOR_LENGTH (bv);
c_bv = (scm_t_uint8 *) SCM_BYTEVECTOR_CONTENTS (bv); c_bv = (uint8_t *) SCM_BYTEVECTOR_CONTENTS (bv);
if (SCM_UNLIKELY (index >= c_len)) if (SCM_UNLIKELY (index >= c_len))
scm_out_of_range (FUNC_NAME, scm_from_size_t (index)); scm_out_of_range (FUNC_NAME, scm_from_size_t (index));
@ -483,7 +483,7 @@ SCM_DEFINE (scm_make_bytevector, "make-bytevector", 1, 1, 0,
{ {
SCM bv; SCM bv;
size_t c_len; size_t c_len;
scm_t_uint8 c_fill = 0; uint8_t c_fill = 0;
SCM_VALIDATE_SIZE_COPY (1, len, c_len); SCM_VALIDATE_SIZE_COPY (1, len, c_len);
if (!scm_is_eq (fill, SCM_UNDEFINED)) if (!scm_is_eq (fill, SCM_UNDEFINED))
@ -493,16 +493,16 @@ SCM_DEFINE (scm_make_bytevector, "make-bytevector", 1, 1, 0,
value = scm_to_int (fill); value = scm_to_int (fill);
if (SCM_UNLIKELY ((value < -128) || (value > 255))) if (SCM_UNLIKELY ((value < -128) || (value > 255)))
scm_out_of_range (FUNC_NAME, fill); scm_out_of_range (FUNC_NAME, fill);
c_fill = (scm_t_uint8) value; c_fill = (uint8_t) value;
} }
bv = make_bytevector (c_len, SCM_ARRAY_ELEMENT_TYPE_VU8); bv = make_bytevector (c_len, SCM_ARRAY_ELEMENT_TYPE_VU8);
if (!scm_is_eq (fill, SCM_UNDEFINED)) if (!scm_is_eq (fill, SCM_UNDEFINED))
{ {
size_t i; size_t i;
scm_t_uint8 *contents; uint8_t *contents;
contents = (scm_t_uint8 *) SCM_BYTEVECTOR_CONTENTS (bv); contents = (uint8_t *) SCM_BYTEVECTOR_CONTENTS (bv);
for (i = 0; i < c_len; i++) for (i = 0; i < c_len; i++)
contents[i] = c_fill; contents[i] = c_fill;
} }
@ -558,7 +558,7 @@ SCM_DEFINE (scm_bytevector_fill_x, "bytevector-fill!", 2, 0, 0,
#define FUNC_NAME s_scm_bytevector_fill_x #define FUNC_NAME s_scm_bytevector_fill_x
{ {
size_t c_len, i; size_t c_len, i;
scm_t_uint8 *c_bv, c_fill; uint8_t *c_bv, c_fill;
int value; int value;
SCM_VALIDATE_MUTABLE_BYTEVECTOR (1, bv); SCM_VALIDATE_MUTABLE_BYTEVECTOR (1, bv);
@ -566,10 +566,10 @@ SCM_DEFINE (scm_bytevector_fill_x, "bytevector-fill!", 2, 0, 0,
value = scm_to_int (fill); value = scm_to_int (fill);
if (SCM_UNLIKELY ((value < -128) || (value > 255))) if (SCM_UNLIKELY ((value < -128) || (value > 255)))
scm_out_of_range (FUNC_NAME, fill); scm_out_of_range (FUNC_NAME, fill);
c_fill = (scm_t_uint8) value; c_fill = (uint8_t) value;
c_len = SCM_BYTEVECTOR_LENGTH (bv); c_len = SCM_BYTEVECTOR_LENGTH (bv);
c_bv = (scm_t_uint8 *) SCM_BYTEVECTOR_CONTENTS (bv); c_bv = (uint8_t *) SCM_BYTEVECTOR_CONTENTS (bv);
for (i = 0; i < c_len; i++) for (i = 0; i < c_len; i++)
c_bv[i] = c_fill; c_bv[i] = c_fill;
@ -726,12 +726,12 @@ SCM_DEFINE (scm_bytevector_to_u8_list, "bytevector->u8-list", 1, 0, 0,
{ {
SCM lst, pair; SCM lst, pair;
size_t c_len, i; size_t c_len, i;
scm_t_uint8 *c_bv; uint8_t *c_bv;
SCM_VALIDATE_BYTEVECTOR (1, bv); SCM_VALIDATE_BYTEVECTOR (1, bv);
c_len = SCM_BYTEVECTOR_LENGTH (bv); c_len = SCM_BYTEVECTOR_LENGTH (bv);
c_bv = (scm_t_uint8 *) SCM_BYTEVECTOR_CONTENTS (bv); c_bv = (uint8_t *) SCM_BYTEVECTOR_CONTENTS (bv);
lst = scm_make_list (scm_from_size_t (c_len), SCM_UNSPECIFIED); lst = scm_make_list (scm_from_size_t (c_len), SCM_UNSPECIFIED);
for (i = 0, pair = lst; for (i = 0, pair = lst;
@ -752,12 +752,12 @@ SCM_DEFINE (scm_u8_list_to_bytevector, "u8-list->bytevector", 1, 0, 0,
{ {
SCM bv, item; SCM bv, item;
size_t c_len, i; size_t c_len, i;
scm_t_uint8 *c_bv; uint8_t *c_bv;
SCM_VALIDATE_LIST_COPYLEN (1, lst, c_len); SCM_VALIDATE_LIST_COPYLEN (1, lst, c_len);
bv = make_bytevector (c_len, SCM_ARRAY_ELEMENT_TYPE_VU8); bv = make_bytevector (c_len, SCM_ARRAY_ELEMENT_TYPE_VU8);
c_bv = (scm_t_uint8 *) SCM_BYTEVECTOR_CONTENTS (bv); c_bv = (uint8_t *) SCM_BYTEVECTOR_CONTENTS (bv);
for (i = 0; i < c_len; lst = SCM_CDR (lst), i++) for (i = 0; i < c_len; lst = SCM_CDR (lst), i++)
{ {
@ -769,7 +769,7 @@ SCM_DEFINE (scm_u8_list_to_bytevector, "u8-list->bytevector", 1, 0, 0,
c_item = SCM_I_INUM (item); c_item = SCM_I_INUM (item);
if (SCM_LIKELY ((c_item >= 0) && (c_item < 256))) if (SCM_LIKELY ((c_item >= 0) && (c_item < 256)))
c_bv[i] = (scm_t_uint8) c_item; c_bv[i] = (uint8_t) c_item;
else else
goto type_error; goto type_error;
} }
@ -1605,13 +1605,13 @@ SCM_DEFINE (scm_bytevector_s64_native_set_x, "bytevector-s64-native-set!",
union scm_ieee754_float union scm_ieee754_float
{ {
float f; float f;
scm_t_uint32 i; uint32_t i;
}; };
union scm_ieee754_double union scm_ieee754_double
{ {
double d; double d;
scm_t_uint64 i; uint64_t i;
}; };
@ -1916,7 +1916,7 @@ utf_encoding_name (char *name, size_t utf_width, SCM endianness)
\ \
SCM_VALIDATE_STRING (1, str); \ SCM_VALIDATE_STRING (1, str); \
if (scm_is_eq (endianness, SCM_UNDEFINED)) \ if (scm_is_eq (endianness, SCM_UNDEFINED)) \
endianness = sym_big; \ endianness = sym_big; \
else \ else \
SCM_VALIDATE_SYMBOL (2, endianness); \ SCM_VALIDATE_SYMBOL (2, endianness); \
\ \
@ -1938,7 +1938,7 @@ utf_encoding_name (char *name, size_t utf_width, SCM endianness)
const scm_t_wchar *wbuf = scm_i_string_wide_chars (str); \ const scm_t_wchar *wbuf = scm_i_string_wide_chars (str); \
c_utf = u32_conv_to_encoding (c_utf_name, \ c_utf = u32_conv_to_encoding (c_utf_name, \
iconveh_question_mark, \ iconveh_question_mark, \
(scm_t_uint32 *) wbuf, \ (uint32_t *) wbuf, \
c_strlen, NULL, NULL, &c_utf_len); \ c_strlen, NULL, NULL, &c_utf_len); \
if (SCM_UNLIKELY (c_utf == NULL)) \ if (SCM_UNLIKELY (c_utf == NULL)) \
scm_syserror_msg (FUNC_NAME, "failed to convert string: ~A", \ scm_syserror_msg (FUNC_NAME, "failed to convert string: ~A", \
@ -1962,12 +1962,12 @@ SCM_DEFINE (scm_string_to_utf8, "string->utf8",
#define FUNC_NAME s_scm_string_to_utf8 #define FUNC_NAME s_scm_string_to_utf8
{ {
SCM utf; SCM utf;
scm_t_uint8 *c_utf; uint8_t *c_utf;
size_t c_utf_len = 0; size_t c_utf_len = 0;
SCM_VALIDATE_STRING (1, str); SCM_VALIDATE_STRING (1, str);
c_utf = (scm_t_uint8 *) scm_to_utf8_stringn (str, &c_utf_len); c_utf = (uint8_t *) scm_to_utf8_stringn (str, &c_utf_len);
utf = make_bytevector (c_utf_len, SCM_ARRAY_ELEMENT_TYPE_VU8); utf = make_bytevector (c_utf_len, SCM_ARRAY_ELEMENT_TYPE_VU8);
memcpy (SCM_BYTEVECTOR_CONTENTS (utf), c_utf, c_utf_len); memcpy (SCM_BYTEVECTOR_CONTENTS (utf), c_utf, c_utf_len);
free (c_utf); free (c_utf);

4
libguile/bytevectors.h
View file

@ -48,8 +48,8 @@ SCM_API SCM scm_endianness_little;
SCM_API SCM scm_c_make_bytevector (size_t); SCM_API SCM scm_c_make_bytevector (size_t);
SCM_API int scm_is_bytevector (SCM); SCM_API int scm_is_bytevector (SCM);
SCM_API size_t scm_c_bytevector_length (SCM); SCM_API size_t scm_c_bytevector_length (SCM);
SCM_API scm_t_uint8 scm_c_bytevector_ref (SCM, size_t); SCM_API uint8_t scm_c_bytevector_ref (SCM, size_t);
SCM_API void scm_c_bytevector_set_x (SCM, size_t, scm_t_uint8); SCM_API void scm_c_bytevector_set_x (SCM, size_t, uint8_t);
SCM_API SCM scm_make_bytevector (SCM, SCM); SCM_API SCM scm_make_bytevector (SCM, SCM);
SCM_API SCM scm_native_endianness (void); SCM_API SCM scm_native_endianness (void);

12
libguile/chars.c
View file

@ -542,7 +542,7 @@ static const char *const scm_r5rs_charnames[] = {
"space", "newline" "space", "newline"
}; };
static const scm_t_uint32 scm_r5rs_charnums[] = { static const uint32_t scm_r5rs_charnums[] = {
0x20, 0x0a 0x20, 0x0a
}; };
@ -554,7 +554,7 @@ static const char *const scm_r6rs_charnames[] = {
/* 'space' and 'newline' are already included from the R5RS list. */ /* 'space' and 'newline' are already included from the R5RS list. */
}; };
static const scm_t_uint32 scm_r6rs_charnums[] = { static const uint32_t scm_r6rs_charnums[] = {
0x00, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x00, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c,
0x0d, 0x1b, 0x7f 0x0d, 0x1b, 0x7f
}; };
@ -565,7 +565,7 @@ static const char *const scm_r7rs_charnames[] = {
"escape" "escape"
}; };
static const scm_t_uint32 scm_r7rs_charnums[] = { static const uint32_t scm_r7rs_charnums[] = {
0x1b 0x1b
}; };
@ -581,7 +581,7 @@ static const char *const scm_C0_control_charnames[] = {
"sp", "del" "sp", "del"
}; };
static const scm_t_uint32 scm_C0_control_charnums[] = { static const uint32_t scm_C0_control_charnums[] = {
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
@ -595,7 +595,7 @@ static const char *const scm_alt_charnames[] = {
"null", "nl", "np" "null", "nl", "np"
}; };
static const scm_t_uint32 scm_alt_charnums[] = { static const uint32_t scm_alt_charnums[] = {
0x00, 0x0a, 0x0c 0x00, 0x0a, 0x0c
}; };
@ -607,7 +607,7 @@ const char *
scm_i_charname (SCM chr) scm_i_charname (SCM chr)
{ {
size_t c; size_t c;
scm_t_uint32 i = SCM_CHAR (chr); uint32_t i = SCM_CHAR (chr);
for (c = 0; c < SCM_N_R5RS_CHARNAMES; c++) for (c = 0; c < SCM_N_R5RS_CHARNAMES; c++)
if (scm_r5rs_charnums[c] == i) if (scm_r5rs_charnums[c] == i)

2
libguile/continuations.c
View file

@ -75,7 +75,7 @@ static scm_t_bits tc16_continuation;
of that trampoline function. of that trampoline function.
*/ */
static const scm_t_uint32 continuation_stub_code[] = static const uint32_t continuation_stub_code[] =
{ {
SCM_PACK_OP_24 (continuation_call, 0) SCM_PACK_OP_24 (continuation_call, 0)
}; };

8
libguile/control.c
View file

@ -67,7 +67,7 @@ scm_i_prompt_pop_abort_args_x (struct scm_vm *vp,
} }
static const scm_t_uint32 compose_continuation_code[] = static const uint32_t compose_continuation_code[] =
{ {
SCM_PACK_OP_24 (compose_continuation, 0) SCM_PACK_OP_24 (compose_continuation, 0)
}; };
@ -91,13 +91,13 @@ static SCM
reify_partial_continuation (struct scm_vm *vp, reify_partial_continuation (struct scm_vm *vp,
union scm_vm_stack_element *saved_fp, union scm_vm_stack_element *saved_fp,
union scm_vm_stack_element *saved_sp, union scm_vm_stack_element *saved_sp,
scm_t_uint32 *saved_ip, uint32_t *saved_ip,
jmp_buf *saved_registers, jmp_buf *saved_registers,
scm_t_dynstack *dynstack, scm_t_dynstack *dynstack,
jmp_buf *current_registers) jmp_buf *current_registers)
{ {
SCM vm_cont; SCM vm_cont;
scm_t_uint32 flags; uint32_t flags;
union scm_vm_stack_element *base_fp; union scm_vm_stack_element *base_fp;
flags = SCM_F_VM_CONT_PARTIAL; flags = SCM_F_VM_CONT_PARTIAL;
@ -139,7 +139,7 @@ scm_c_abort (struct scm_vm *vp, SCM tag, size_t n, SCM *argv,
scm_t_dynstack_prompt_flags flags; scm_t_dynstack_prompt_flags flags;
scm_t_ptrdiff fp_offset, sp_offset; scm_t_ptrdiff fp_offset, sp_offset;
union scm_vm_stack_element *fp, *sp; union scm_vm_stack_element *fp, *sp;
scm_t_uint32 *ip; uint32_t *ip;
jmp_buf *registers; jmp_buf *registers;
size_t i; size_t i;

6
libguile/conv-integer.i.c
View file

@ -64,15 +64,15 @@ SCM_TO_TYPE_PROTO (SCM val)
} }
else else
{ {
scm_t_uintmax abs_n; uintmax_t abs_n;
TYPE n; TYPE n;
size_t count; size_t count;
if (mpz_sizeinbase (SCM_I_BIG_MPZ (val), 2) if (mpz_sizeinbase (SCM_I_BIG_MPZ (val), 2)
> CHAR_BIT*sizeof (scm_t_uintmax)) > CHAR_BIT*sizeof (uintmax_t))
goto out_of_range; goto out_of_range;
mpz_export (&abs_n, &count, 1, sizeof (scm_t_uintmax), 0, 0, mpz_export (&abs_n, &count, 1, sizeof (uintmax_t), 0, 0,
SCM_I_BIG_MPZ (val)); SCM_I_BIG_MPZ (val));
if (mpz_sgn (SCM_I_BIG_MPZ (val)) >= 0) if (mpz_sgn (SCM_I_BIG_MPZ (val)) >= 0)

4
libguile/conv-uinteger.i.c
View file

@ -30,7 +30,7 @@ SCM_TO_TYPE_PROTO (SCM val)
{ {
scm_t_signed_bits n = SCM_I_INUM (val); scm_t_signed_bits n = SCM_I_INUM (val);
if (n >= 0 if (n >= 0
&& ((scm_t_uintmax)n) >= TYPE_MIN && ((scm_t_uintmax)n) <= TYPE_MAX) && ((uintmax_t)n) >= TYPE_MIN && ((uintmax_t)n) <= TYPE_MAX)
return n; return n;
else else
{ {
@ -66,7 +66,7 @@ SCM_TO_TYPE_PROTO (SCM val)
} }
else else
{ {
scm_t_uintmax n; uintmax_t n;
size_t count; size_t count;
if (mpz_sgn (SCM_I_BIG_MPZ (val)) < 0) if (mpz_sgn (SCM_I_BIG_MPZ (val)) < 0)

6
libguile/dynstack.c
View file

@ -43,7 +43,7 @@
#define SET_PROMPT_FP(top, fp) do { top[1] = (scm_t_bits)(fp); } while (0) #define SET_PROMPT_FP(top, fp) do { top[1] = (scm_t_bits)(fp); } while (0)
#define PROMPT_SP(top) ((scm_t_ptrdiff) ((top)[2])) #define PROMPT_SP(top) ((scm_t_ptrdiff) ((top)[2]))
#define SET_PROMPT_SP(top, sp) do { top[2] = (scm_t_bits)(sp); } while (0) #define SET_PROMPT_SP(top, sp) do { top[2] = (scm_t_bits)(sp); } while (0)
#define PROMPT_IP(top) ((scm_t_uint32 *) ((top)[3])) #define PROMPT_IP(top) ((uint32_t *) ((top)[3]))
#define PROMPT_JMPBUF(top) ((jmp_buf *) ((top)[4])) #define PROMPT_JMPBUF(top) ((jmp_buf *) ((top)[4]))
#define WINDER_WORDS 2 #define WINDER_WORDS 2
@ -196,7 +196,7 @@ scm_dynstack_push_prompt (scm_t_dynstack *dynstack,
scm_t_dynstack_prompt_flags flags, scm_t_dynstack_prompt_flags flags,
SCM key, SCM key,
scm_t_ptrdiff fp_offset, scm_t_ptrdiff sp_offset, scm_t_ptrdiff fp_offset, scm_t_ptrdiff sp_offset,
scm_t_uint32 *ip, jmp_buf *registers) uint32_t *ip, jmp_buf *registers)
{ {
scm_t_bits *words; scm_t_bits *words;
@ -499,7 +499,7 @@ scm_t_bits*
scm_dynstack_find_prompt (scm_t_dynstack *dynstack, SCM key, scm_dynstack_find_prompt (scm_t_dynstack *dynstack, SCM key,
scm_t_dynstack_prompt_flags *flags, scm_t_dynstack_prompt_flags *flags,
scm_t_ptrdiff *fp_offset, scm_t_ptrdiff *sp_offset, scm_t_ptrdiff *fp_offset, scm_t_ptrdiff *sp_offset,
scm_t_uint32 **ip, jmp_buf **registers) uint32_t **ip, jmp_buf **registers)
{ {
scm_t_bits *walk; scm_t_bits *walk;

4
libguile/dynstack.h
View file

@ -160,7 +160,7 @@ SCM_INTERNAL void scm_dynstack_push_prompt (scm_t_dynstack *,
SCM key, SCM key,
scm_t_ptrdiff fp_offset, scm_t_ptrdiff fp_offset,
scm_t_ptrdiff sp_offset, scm_t_ptrdiff sp_offset,
scm_t_uint32 *ip, uint32_t *ip,
jmp_buf *registers); jmp_buf *registers);
SCM_INTERNAL void scm_dynstack_push_dynwind (scm_t_dynstack *, SCM_INTERNAL void scm_dynstack_push_dynwind (scm_t_dynstack *,
SCM enter, SCM leave); SCM enter, SCM leave);
@ -200,7 +200,7 @@ SCM_INTERNAL scm_t_bits* scm_dynstack_find_prompt (scm_t_dynstack *, SCM,
scm_t_dynstack_prompt_flags *, scm_t_dynstack_prompt_flags *,
scm_t_ptrdiff *, scm_t_ptrdiff *,
scm_t_ptrdiff *, scm_t_ptrdiff *,
scm_t_uint32 **, uint32_t **,
jmp_buf **); jmp_buf **);
SCM_INTERNAL SCM scm_dynstack_find_old_fluid_value (scm_t_dynstack *, SCM_INTERNAL SCM scm_dynstack_find_old_fluid_value (scm_t_dynstack *,

102
libguile/foreign.c
View file

@ -138,7 +138,7 @@ SCM_DEFINE (scm_make_pointer, "make-pointer", 1, 1, 0,
#define FUNC_NAME s_scm_make_pointer #define FUNC_NAME s_scm_make_pointer
{ {
void *c_finalizer; void *c_finalizer;
scm_t_uintptr c_address; uintptr_t c_address;
c_address = scm_to_uintptr_t (address); c_address = scm_to_uintptr_t (address);
if (SCM_UNBNDP (finalizer)) if (SCM_UNBNDP (finalizer))
@ -188,7 +188,7 @@ SCM_DEFINE (scm_pointer_address, "pointer-address", 1, 0, 0,
{ {
SCM_VALIDATE_POINTER (1, pointer); SCM_VALIDATE_POINTER (1, pointer);
return scm_from_uintptr_t ((scm_t_uintptr) SCM_POINTER_VALUE (pointer)); return scm_from_uintptr_t ((uintptr_t) SCM_POINTER_VALUE (pointer));
} }
#undef FUNC_NAME #undef FUNC_NAME
@ -236,7 +236,7 @@ SCM_DEFINE (scm_pointer_to_bytevector, "pointer->bytevector", 2, 2, 0,
#define FUNC_NAME s_scm_pointer_to_bytevector #define FUNC_NAME s_scm_pointer_to_bytevector
{ {
SCM ret; SCM ret;
scm_t_int8 *ptr; int8_t *ptr;
size_t boffset, blen; size_t boffset, blen;
scm_t_array_element_type btype; scm_t_array_element_type btype;
@ -469,21 +469,21 @@ SCM_DEFINE (scm_alignof, "alignof", 1, 0, 0, (SCM type),
case SCM_FOREIGN_TYPE_DOUBLE: case SCM_FOREIGN_TYPE_DOUBLE:
return scm_from_size_t (alignof_type (double)); return scm_from_size_t (alignof_type (double));
case SCM_FOREIGN_TYPE_UINT8: case SCM_FOREIGN_TYPE_UINT8:
return scm_from_size_t (alignof_type (scm_t_uint8)); return scm_from_size_t (alignof_type (uint8_t));
case SCM_FOREIGN_TYPE_INT8: case SCM_FOREIGN_TYPE_INT8:
return scm_from_size_t (alignof_type (scm_t_int8)); return scm_from_size_t (alignof_type (int8_t));
case SCM_FOREIGN_TYPE_UINT16: case SCM_FOREIGN_TYPE_UINT16:
return scm_from_size_t (alignof_type (scm_t_uint16)); return scm_from_size_t (alignof_type (uint16_t));
case SCM_FOREIGN_TYPE_INT16: case SCM_FOREIGN_TYPE_INT16:
return scm_from_size_t (alignof_type (scm_t_int16)); return scm_from_size_t (alignof_type (int16_t));
case SCM_FOREIGN_TYPE_UINT32: case SCM_FOREIGN_TYPE_UINT32:
return scm_from_size_t (alignof_type (scm_t_uint32)); return scm_from_size_t (alignof_type (uint32_t));
case SCM_FOREIGN_TYPE_INT32: case SCM_FOREIGN_TYPE_INT32:
return scm_from_size_t (alignof_type (scm_t_int32)); return scm_from_size_t (alignof_type (int32_t));
case SCM_FOREIGN_TYPE_UINT64: case SCM_FOREIGN_TYPE_UINT64:
return scm_from_size_t (alignof_type (scm_t_uint64)); return scm_from_size_t (alignof_type (uint64_t));
case SCM_FOREIGN_TYPE_INT64: case SCM_FOREIGN_TYPE_INT64:
return scm_from_size_t (alignof_type (scm_t_int64)); return scm_from_size_t (alignof_type (int64_t));
default: default:
scm_wrong_type_arg (FUNC_NAME, 1, type); scm_wrong_type_arg (FUNC_NAME, 1, type);
} }
@ -533,21 +533,21 @@ SCM_DEFINE (scm_sizeof, "sizeof", 1, 0, 0, (SCM type),
case SCM_FOREIGN_TYPE_DOUBLE: case SCM_FOREIGN_TYPE_DOUBLE:
return scm_from_size_t (sizeof (double)); return scm_from_size_t (sizeof (double));
case SCM_FOREIGN_TYPE_UINT8: case SCM_FOREIGN_TYPE_UINT8:
return scm_from_size_t (sizeof (scm_t_uint8)); return scm_from_size_t (sizeof (uint8_t));
case SCM_FOREIGN_TYPE_INT8: case SCM_FOREIGN_TYPE_INT8:
return scm_from_size_t (sizeof (scm_t_int8)); return scm_from_size_t (sizeof (int8_t));
case SCM_FOREIGN_TYPE_UINT16: case SCM_FOREIGN_TYPE_UINT16:
return scm_from_size_t (sizeof (scm_t_uint16)); return scm_from_size_t (sizeof (uint16_t));
case SCM_FOREIGN_TYPE_INT16: case SCM_FOREIGN_TYPE_INT16:
return scm_from_size_t (sizeof (scm_t_int16)); return scm_from_size_t (sizeof (int16_t));
case SCM_FOREIGN_TYPE_UINT32: case SCM_FOREIGN_TYPE_UINT32:
return scm_from_size_t (sizeof (scm_t_uint32)); return scm_from_size_t (sizeof (uint32_t));
case SCM_FOREIGN_TYPE_INT32: case SCM_FOREIGN_TYPE_INT32:
return scm_from_size_t (sizeof (scm_t_int32)); return scm_from_size_t (sizeof (int32_t));
case SCM_FOREIGN_TYPE_UINT64: case SCM_FOREIGN_TYPE_UINT64:
return scm_from_size_t (sizeof (scm_t_uint64)); return scm_from_size_t (sizeof (uint64_t));
case SCM_FOREIGN_TYPE_INT64: case SCM_FOREIGN_TYPE_INT64:
return scm_from_size_t (sizeof (scm_t_int64)); return scm_from_size_t (sizeof (int64_t));
default: default:
scm_wrong_type_arg (FUNC_NAME, 1, type); scm_wrong_type_arg (FUNC_NAME, 1, type);
} }
@ -824,14 +824,14 @@ SCM_DEFINE (scm_i_pointer_to_procedure, "pointer->procedure", 3, 0, 1,
static const scm_t_uint32 * static const uint32_t *
get_foreign_stub_code (unsigned int nargs, int with_errno) get_foreign_stub_code (unsigned int nargs, int with_errno)
{ {
size_t i; size_t i;
size_t code_len = with_errno ? 4 : 5; size_t code_len = with_errno ? 4 : 5;
scm_t_uint32 *code; uint32_t *code;
code = scm_gc_malloc_pointerless (code_len * sizeof (scm_t_uint32), code = scm_gc_malloc_pointerless (code_len * sizeof (uint32_t),
"foreign code"); "foreign code");
if (nargs >= (1 << 24) + 1) if (nargs >= (1 << 24) + 1)
@ -888,43 +888,43 @@ unpack (const ffi_type *type, void *loc, SCM x, int return_value_p)
if (return_value_p) if (return_value_p)
*(ffi_arg *) loc = scm_to_uint8 (x); *(ffi_arg *) loc = scm_to_uint8 (x);
else else
*(scm_t_uint8 *) loc = scm_to_uint8 (x); *(uint8_t *) loc = scm_to_uint8 (x);
break; break;
case FFI_TYPE_SINT8: case FFI_TYPE_SINT8:
if (return_value_p) if (return_value_p)
*(ffi_arg *) loc = scm_to_int8 (x); *(ffi_arg *) loc = scm_to_int8 (x);
else else
*(scm_t_int8 *) loc = scm_to_int8 (x); *(int8_t *) loc = scm_to_int8 (x);
break; break;
case FFI_TYPE_UINT16: case FFI_TYPE_UINT16:
if (return_value_p) if (return_value_p)
*(ffi_arg *) loc = scm_to_uint16 (x); *(ffi_arg *) loc = scm_to_uint16 (x);
else else
*(scm_t_uint16 *) loc = scm_to_uint16 (x); *(uint16_t *) loc = scm_to_uint16 (x);
break; break;
case FFI_TYPE_SINT16: case FFI_TYPE_SINT16:
if (return_value_p) if (return_value_p)
*(ffi_arg *) loc = scm_to_int16 (x); *(ffi_arg *) loc = scm_to_int16 (x);
else else
*(scm_t_int16 *) loc = scm_to_int16 (x); *(int16_t *) loc = scm_to_int16 (x);
break; break;
case FFI_TYPE_UINT32: case FFI_TYPE_UINT32:
if (return_value_p) if (return_value_p)
*(ffi_arg *) loc = scm_to_uint32 (x); *(ffi_arg *) loc = scm_to_uint32 (x);
else else
*(scm_t_uint32 *) loc = scm_to_uint32 (x); *(uint32_t *) loc = scm_to_uint32 (x);
break; break;
case FFI_TYPE_SINT32: case FFI_TYPE_SINT32:
if (return_value_p) if (return_value_p)
*(ffi_arg *) loc = scm_to_int32 (x); *(ffi_arg *) loc = scm_to_int32 (x);
else else
*(scm_t_int32 *) loc = scm_to_int32 (x); *(int32_t *) loc = scm_to_int32 (x);
break; break;
case FFI_TYPE_UINT64: case FFI_TYPE_UINT64:
*(scm_t_uint64 *) loc = scm_to_uint64 (x); *(uint64_t *) loc = scm_to_uint64 (x);
break; break;
case FFI_TYPE_SINT64: case FFI_TYPE_SINT64:
*(scm_t_int64 *) loc = scm_to_int64 (x); *(int64_t *) loc = scm_to_int64 (x);
break; break;
case FFI_TYPE_STRUCT: case FFI_TYPE_STRUCT:
SCM_VALIDATE_POINTER (1, x); SCM_VALIDATE_POINTER (1, x);
@ -967,38 +967,38 @@ pack (const ffi_type * type, const void *loc, int return_value_p)
case FFI_TYPE_UINT8: case FFI_TYPE_UINT8:
if (return_value_p) if (return_value_p)
return scm_from_uint8 ((scm_t_uint8) *(ffi_arg *) loc); return scm_from_uint8 ((uint8_t) *(ffi_arg *) loc);
else else
return scm_from_uint8 (* (scm_t_uint8 *) loc); return scm_from_uint8 (* (uint8_t *) loc);
case FFI_TYPE_SINT8: case FFI_TYPE_SINT8:
if (return_value_p) if (return_value_p)
return scm_from_int8 ((scm_t_int8) *(ffi_arg *) loc); return scm_from_int8 ((int8_t) *(ffi_arg *) loc);
else else
return scm_from_int8 (* (scm_t_int8 *) loc); return scm_from_int8 (* (int8_t *) loc);
case FFI_TYPE_UINT16: case FFI_TYPE_UINT16:
if (return_value_p) if (return_value_p)
return scm_from_uint16 ((scm_t_uint16) *(ffi_arg *) loc); return scm_from_uint16 ((uint16_t) *(ffi_arg *) loc);
else else
return scm_from_uint16 (* (scm_t_uint16 *) loc); return scm_from_uint16 (* (uint16_t *) loc);
case FFI_TYPE_SINT16: case FFI_TYPE_SINT16:
if (return_value_p) if (return_value_p)
return scm_from_int16 ((scm_t_int16) *(ffi_arg *) loc); return scm_from_int16 ((int16_t) *(ffi_arg *) loc);
else else
return scm_from_int16 (* (scm_t_int16 *) loc); return scm_from_int16 (* (int16_t *) loc);
case FFI_TYPE_UINT32: case FFI_TYPE_UINT32:
if (return_value_p) if (return_value_p)
return scm_from_uint32 ((scm_t_uint32) *(ffi_arg *) loc); return scm_from_uint32 ((uint32_t) *(ffi_arg *) loc);
else else
return scm_from_uint32 (* (scm_t_uint32 *) loc); return scm_from_uint32 (* (uint32_t *) loc);
case FFI_TYPE_SINT32: case FFI_TYPE_SINT32:
if (return_value_p) if (return_value_p)
return scm_from_int32 ((scm_t_int32) *(ffi_arg *) loc); return scm_from_int32 ((int32_t) *(ffi_arg *) loc);
else else
return scm_from_int32 (* (scm_t_int32 *) loc); return scm_from_int32 (* (int32_t *) loc);
case FFI_TYPE_UINT64: case FFI_TYPE_UINT64:
return scm_from_uint64 (*(scm_t_uint64 *) loc); return scm_from_uint64 (*(uint64_t *) loc);
case FFI_TYPE_SINT64: case FFI_TYPE_SINT64:
return scm_from_int64 (*(scm_t_int64 *) loc); return scm_from_int64 (*(int64_t *) loc);
case FFI_TYPE_STRUCT: case FFI_TYPE_STRUCT:
{ {
@ -1024,7 +1024,7 @@ scm_i_foreign_call (SCM cif_scm, SCM pointer_scm, int *errno_ret,
objtable. */ objtable. */
ffi_cif *cif; ffi_cif *cif;
void (*func) (void); void (*func) (void);
scm_t_uint8 *data; uint8_t *data;
void *rvalue; void *rvalue;
void **args; void **args;
unsigned i; unsigned i;
@ -1050,13 +1050,13 @@ scm_i_foreign_call (SCM cif_scm, SCM pointer_scm, int *errno_ret,
/* Unpack ARGV to native values, setting ARGV pointers. */ /* Unpack ARGV to native values, setting ARGV pointers. */
for (i = 0, off = 0; for (i = 0, off = 0;
i < cif->nargs; i < cif->nargs;
off = (scm_t_uint8 *) args[i] - data + cif->arg_types[i]->size, off = (uint8_t *) args[i] - data + cif->arg_types[i]->size,
i++) i++)
{ {
/* Suitably align the storage area for argument I. */ /* Suitably align the storage area for argument I. */
args[i] = (void *) ROUND_UP ((scm_t_uintptr) data + off, args[i] = (void *) ROUND_UP ((uintptr_t) data + off,
cif->arg_types[i]->alignment); cif->arg_types[i]->alignment);
assert ((scm_t_uintptr) args[i] % cif->arg_types[i]->alignment == 0); assert ((uintptr_t) args[i] % cif->arg_types[i]->alignment == 0);
unpack (cif->arg_types[i], args[i], argv[cif->nargs - i - 1].as_scm, 0); unpack (cif->arg_types[i], args[i], argv[cif->nargs - i - 1].as_scm, 0);
} }
@ -1064,7 +1064,7 @@ scm_i_foreign_call (SCM cif_scm, SCM pointer_scm, int *errno_ret,
`armv5tel-*-linux-gnueabi', the return value has to be at least `armv5tel-*-linux-gnueabi', the return value has to be at least
word-aligned, even if its type doesn't have any alignment requirement as is word-aligned, even if its type doesn't have any alignment requirement as is
the case with `char'. */ the case with `char'. */
rvalue = (void *) ROUND_UP ((scm_t_uintptr) data + off, rvalue = (void *) ROUND_UP ((uintptr_t) data + off,
MAX (sizeof (void *), cif->rtype->alignment)); MAX (sizeof (void *), cif->rtype->alignment));
/* off we go! */ /* off we go! */
@ -1280,7 +1280,7 @@ scm_init_foreign (void)
#elif SCM_SIZEOF_INTPTR_T == 4 #elif SCM_SIZEOF_INTPTR_T == 4
scm_from_uint8 (SCM_FOREIGN_TYPE_INT32) scm_from_uint8 (SCM_FOREIGN_TYPE_INT32)
#else #else
# error unsupported sizeof (scm_t_intptr) # error unsupported sizeof (intptr_t)
#endif #endif
); );
@ -1290,7 +1290,7 @@ scm_init_foreign (void)
#elif SCM_SIZEOF_UINTPTR_T == 4 #elif SCM_SIZEOF_UINTPTR_T == 4
scm_from_uint8 (SCM_FOREIGN_TYPE_UINT32) scm_from_uint8 (SCM_FOREIGN_TYPE_UINT32)
#else #else
# error unsupported sizeof (scm_t_uintptr) # error unsupported sizeof (uintptr_t)
#endif #endif
); );

6
libguile/frames.c
View file

@ -356,7 +356,7 @@ SCM_DEFINE (scm_frame_instruction_pointer, "frame-instruction-pointer", 1, 0, 0,
{ {
SCM_VALIDATE_VM_FRAME (1, frame); SCM_VALIDATE_VM_FRAME (1, frame);
return scm_from_uintptr_t ((scm_t_uintptr) SCM_VM_FRAME_IP (frame)); return scm_from_uintptr_t ((uintptr_t) SCM_VM_FRAME_IP (frame));
} }
#undef FUNC_NAME #undef FUNC_NAME
@ -366,7 +366,7 @@ SCM_DEFINE (scm_frame_return_address, "frame-return-address", 1, 0, 0,
#define FUNC_NAME s_scm_frame_return_address #define FUNC_NAME s_scm_frame_return_address
{ {
SCM_VALIDATE_VM_FRAME (1, frame); SCM_VALIDATE_VM_FRAME (1, frame);
return scm_from_uintptr_t ((scm_t_uintptr) (SCM_FRAME_RETURN_ADDRESS return scm_from_uintptr_t ((uintptr_t) (SCM_FRAME_RETURN_ADDRESS
(SCM_VM_FRAME_FP (frame)))); (SCM_VM_FRAME_FP (frame))));
} }
#undef FUNC_NAME #undef FUNC_NAME
@ -379,7 +379,7 @@ SCM_DEFINE (scm_frame_dynamic_link, "frame-dynamic-link", 1, 0, 0,
SCM_VALIDATE_VM_FRAME (1, frame); SCM_VALIDATE_VM_FRAME (1, frame);
/* fixme: munge fp if holder is a continuation */ /* fixme: munge fp if holder is a continuation */
return scm_from_uintptr_t return scm_from_uintptr_t
((scm_t_uintptr) ((uintptr_t)
SCM_FRAME_DYNAMIC_LINK (SCM_VM_FRAME_FP (frame))); SCM_FRAME_DYNAMIC_LINK (SCM_VM_FRAME_FP (frame)));
} }
#undef FUNC_NAME #undef FUNC_NAME

10
libguile/frames.h
View file

@ -89,12 +89,12 @@
/* Each element on the stack occupies the same amount of space. */ /* Each element on the stack occupies the same amount of space. */
union scm_vm_stack_element union scm_vm_stack_element
{ {
scm_t_uintptr as_uint; uintptr_t as_uint;
scm_t_uint32 *as_ip; uint32_t *as_ip;
SCM as_scm; SCM as_scm;
double as_f64; double as_f64;
scm_t_uint64 as_u64; uint64_t as_u64;
scm_t_int64 as_s64; int64_t as_s64;
/* For GC purposes. */ /* For GC purposes. */
void *as_ptr; void *as_ptr;
@ -122,7 +122,7 @@ struct scm_frame
void *stack_holder; void *stack_holder;
scm_t_ptrdiff fp_offset; scm_t_ptrdiff fp_offset;
scm_t_ptrdiff sp_offset; scm_t_ptrdiff sp_offset;
scm_t_uint32 *ip; uint32_t *ip;
}; };
enum scm_vm_frame_kind enum scm_vm_frame_kind

2
libguile/gc-inline.h
View file

@ -154,7 +154,7 @@ scm_inline_double_cell (scm_i_thread *thread, scm_t_bits car, scm_t_bits cbr,
} }
static inline SCM static inline SCM
scm_inline_words (scm_i_thread *thread, scm_t_bits car, scm_t_uint32 n_words) scm_inline_words (scm_i_thread *thread, scm_t_bits car, uint32_t n_words)
{ {
SCM obj = SCM_PACK_POINTER (scm_inline_gc_malloc_words (thread, n_words)); SCM obj = SCM_PACK_POINTER (scm_inline_gc_malloc_words (thread, n_words));

6
libguile/gc.h
View file

@ -150,8 +150,8 @@ SCM_API char *scm_gc_strndup (const char *str, size_t n, const char *what)
SCM_INLINE SCM scm_cell (scm_t_bits car, scm_t_bits cdr); SCM_INLINE SCM scm_cell (scm_t_bits car, scm_t_bits cdr);
SCM_INLINE SCM scm_double_cell (scm_t_bits car, scm_t_bits cbr, SCM_INLINE SCM scm_double_cell (scm_t_bits car, scm_t_bits cbr,
scm_t_bits ccr, scm_t_bits cdr); scm_t_bits ccr, scm_t_bits cdr);
SCM_INLINE SCM scm_words (scm_t_bits car, scm_t_uint32 n_words); SCM_INLINE SCM scm_words (scm_t_bits car, uint32_t n_words);
#if SCM_CAN_INLINE || defined SCM_INLINE_C_IMPLEMENTING_INLINES #if SCM_CAN_INLINE || defined SCM_INLINE_C_IMPLEMENTING_INLINES
@ -211,7 +211,7 @@ scm_double_cell (scm_t_bits car, scm_t_bits cbr,
} }
SCM_INLINE_IMPLEMENTATION SCM SCM_INLINE_IMPLEMENTATION SCM
scm_words (scm_t_bits car, scm_t_uint32 n_words) scm_words (scm_t_bits car, uint32_t n_words)
{ {
SCM z; SCM z;

14
libguile/gsubr.c
View file

@ -175,7 +175,7 @@
(generate-bytecode i) (generate-bytecode i)
(setq i (1+ i))))) (setq i (1+ i)))))
*/ */
static const scm_t_uint32 subr_stub_code[] = { static const uint32_t subr_stub_code[] = {
/* C-u 1 0 M-x generate-bytecodes RET */ /* C-u 1 0 M-x generate-bytecodes RET */
/* 0 arguments */ /* 0 arguments */
A(0), A(0),
@ -234,7 +234,7 @@ static const scm_t_uint32 subr_stub_code[] = {
&subr_stub_code[((nreq + nopt + rest) * (nreq + nopt + rest) \ &subr_stub_code[((nreq + nopt + rest) * (nreq + nopt + rest) \
+ nopt + rest * (nreq + nopt + rest + 1)) * 6] + nopt + rest * (nreq + nopt + rest + 1)) * 6]
static const scm_t_uint32* static const uint32_t*
get_subr_stub_code (unsigned int nreq, unsigned int nopt, unsigned int rest) get_subr_stub_code (unsigned int nreq, unsigned int nopt, unsigned int rest)
{ {
if (SCM_UNLIKELY (rest > 1 || nreq + nopt + rest > 10)) if (SCM_UNLIKELY (rest > 1 || nreq + nopt + rest > 10))
@ -272,28 +272,28 @@ create_subr (int define, const char *name,
} }
int int
scm_i_primitive_code_p (const scm_t_uint32 *code) scm_i_primitive_code_p (const uint32_t *code)
{ {
if (code < subr_stub_code) if (code < subr_stub_code)
return 0; return 0;
if (code > subr_stub_code + (sizeof(subr_stub_code) / sizeof(scm_t_uint32))) if (code > subr_stub_code + (sizeof(subr_stub_code) / sizeof(uint32_t)))
return 0; return 0;
return 1; return 1;
} }
scm_t_uintptr uintptr_t
scm_i_primitive_call_ip (SCM subr) scm_i_primitive_call_ip (SCM subr)
{ {
size_t i; size_t i;
const scm_t_uint32 *code = SCM_PROGRAM_CODE (subr); const uint32_t *code = SCM_PROGRAM_CODE (subr);
/* A stub is 6 32-bit words long, or 24 bytes. The call will be one /* A stub is 6 32-bit words long, or 24 bytes. The call will be one
instruction, in either the fourth, third, or second word. Return a instruction, in either the fourth, third, or second word. Return a
byte offset from the entry. */ byte offset from the entry. */
for (i = 1; i < 4; i++) for (i = 1; i < 4; i++)
if ((code[i] & 0xff) == scm_op_subr_call) if ((code[i] & 0xff) == scm_op_subr_call)
return (scm_t_uintptr) (code + i); return (uintptr_t) (code + i);
abort (); abort ();
} }

4
libguile/gsubr.h
View file

@ -52,8 +52,8 @@
SCM_INTERNAL int scm_i_primitive_code_p (const scm_t_uint32 *code); SCM_INTERNAL int scm_i_primitive_code_p (const uint32_t *code);
SCM_INTERNAL scm_t_uintptr scm_i_primitive_call_ip (SCM subr); SCM_INTERNAL uintptr_t scm_i_primitive_call_ip (SCM subr);
union scm_vm_stack_element; union scm_vm_stack_element;
SCM_INTERNAL SCM scm_apply_subr (union scm_vm_stack_element *sp, SCM_INTERNAL SCM scm_apply_subr (union scm_vm_stack_element *sp,

18
libguile/hash.c
View file

@ -82,10 +82,10 @@ extern double floor();
#define JENKINS_LOOKUP3_HASHWORD2(k, length, ret) \ #define JENKINS_LOOKUP3_HASHWORD2(k, length, ret) \
do { \ do { \
scm_t_uint32 a, b, c; \ uint32_t a, b, c; \
\ \
/* Set up the internal state. */ \ /* Set up the internal state. */ \
a = b = c = 0xdeadbeef + ((scm_t_uint32)(length<<2)) + 47; \ a = b = c = 0xdeadbeef + ((uint32_t)(length<<2)) + 47; \
\ \
/* Handle most of the key. */ \ /* Handle most of the key. */ \
while (length > 3) \ while (length > 3) \
@ -117,7 +117,7 @@ extern double floor();
static unsigned long static unsigned long
narrow_string_hash (const scm_t_uint8 *str, size_t len) narrow_string_hash (const uint8_t *str, size_t len)
{ {
unsigned long ret; unsigned long ret;
JENKINS_LOOKUP3_HASHWORD2 (str, len, ret); JENKINS_LOOKUP3_HASHWORD2 (str, len, ret);
@ -140,7 +140,7 @@ scm_i_string_hash (SCM str)
size_t len = scm_i_string_length (str); size_t len = scm_i_string_length (str);
if (scm_i_is_narrow_string (str)) if (scm_i_is_narrow_string (str))
return narrow_string_hash ((const scm_t_uint8 *) scm_i_string_chars (str), return narrow_string_hash ((const uint8_t *) scm_i_string_chars (str),
len); len);
else else
return wide_string_hash (scm_i_string_wide_chars (str), len); return wide_string_hash (scm_i_string_wide_chars (str), len);
@ -158,21 +158,21 @@ scm_i_latin1_string_hash (const char *str, size_t len)
if (len == (size_t) -1) if (len == (size_t) -1)
len = strlen (str); len = strlen (str);
return narrow_string_hash ((const scm_t_uint8 *) str, len); return narrow_string_hash ((const uint8_t *) str, len);
} }
/* A tricky optimization, but probably worth it. */ /* A tricky optimization, but probably worth it. */
unsigned long unsigned long
scm_i_utf8_string_hash (const char *str, size_t len) scm_i_utf8_string_hash (const char *str, size_t len)
{ {
const scm_t_uint8 *end, *ustr = (const scm_t_uint8 *) str; const uint8_t *end, *ustr = (const uint8_t *) str;
unsigned long ret; unsigned long ret;
/* The length of the string in characters. This name corresponds to /* The length of the string in characters. This name corresponds to
Jenkins' original name. */ Jenkins' original name. */
size_t length; size_t length;
scm_t_uint32 a, b, c, u32; uint32_t a, b, c, u32;
if (len == (size_t) -1) if (len == (size_t) -1)
len = strlen (str); len = strlen (str);
@ -186,7 +186,7 @@ scm_i_utf8_string_hash (const char *str, size_t len)
length = u8_strnlen (ustr, len); length = u8_strnlen (ustr, len);
/* Set up the internal state. */ /* Set up the internal state. */
a = b = c = 0xdeadbeef + ((scm_t_uint32)(length<<2)) + 47; a = b = c = 0xdeadbeef + ((uint32_t)(length<<2)) + 47;
/* Handle most of the key. */ /* Handle most of the key. */
while (length > 3) while (length > 3)
@ -308,7 +308,7 @@ scm_raw_ihash (SCM obj, size_t depth)
case scm_tc7_symbol: case scm_tc7_symbol:
return scm_i_symbol_hash (obj); return scm_i_symbol_hash (obj);
case scm_tc7_pointer: case scm_tc7_pointer:
return scm_raw_ihashq ((scm_t_uintptr) SCM_POINTER_VALUE (obj)); return scm_raw_ihashq ((uintptr_t) SCM_POINTER_VALUE (obj));
case scm_tc7_wvect: case scm_tc7_wvect:
case scm_tc7_vector: case scm_tc7_vector:
{ {

50
libguile/i18n.c
View file

@ -763,11 +763,11 @@ compare_u32_strings (SCM s1, SCM s2, SCM locale, const char *func_name)
if (c_locale) if (c_locale)
RUN_IN_LOCALE_SECTION (c_locale, RUN_IN_LOCALE_SECTION (c_locale,
result = u32_strcoll ((const scm_t_uint32 *) c_s1, result = u32_strcoll ((const uint32_t *) c_s1,
(const scm_t_uint32 *) c_s2)); (const uint32_t *) c_s2));
else else
result = u32_strcoll ((const scm_t_uint32 *) c_s1, result = u32_strcoll ((const uint32_t *) c_s1,
(const scm_t_uint32 *) c_s2); (const uint32_t *) c_s2);
scm_remember_upto_here_2 (s1, s2); scm_remember_upto_here_2 (s1, s2);
scm_remember_upto_here (locale); scm_remember_upto_here (locale);
@ -787,8 +787,8 @@ locale_language ()
} }
static inline int static inline int
u32_locale_casecoll (const char *func_name, const scm_t_uint32 *c_s1, u32_locale_casecoll (const char *func_name, const uint32_t *c_s1,
const scm_t_uint32 *c_s2, const uint32_t *c_s2,
int *result) int *result)
{ {
/* Note: Since this is called from `RUN_IN_LOCALE_SECTION', it must note /* Note: Since this is called from `RUN_IN_LOCALE_SECTION', it must note
@ -820,13 +820,13 @@ compare_u32_strings_ci (SCM s1, SCM s2, SCM locale, const char *func_name)
RUN_IN_LOCALE_SECTION RUN_IN_LOCALE_SECTION
(c_locale, (c_locale,
ret = u32_locale_casecoll (func_name, ret = u32_locale_casecoll (func_name,
(const scm_t_uint32 *) c_s1, (const uint32_t *) c_s1,
(const scm_t_uint32 *) c_s2, (const uint32_t *) c_s2,
&result)); &result));
else else
ret = u32_locale_casecoll (func_name, ret = u32_locale_casecoll (func_name,
(const scm_t_uint32 *) c_s1, (const uint32_t *) c_s1,
(const scm_t_uint32 *) c_s2, (const uint32_t *) c_s2,
&result); &result);
if (SCM_UNLIKELY (ret != 0)) if (SCM_UNLIKELY (ret != 0))
@ -1044,16 +1044,16 @@ SCM_DEFINE (scm_char_locale_ci_eq, "char-locale-ci=?", 2, 1, 0,
/* Locale-dependent alphabetic character mapping. */ /* Locale-dependent alphabetic character mapping. */
static inline int static inline int
u32_locale_tocase (const scm_t_uint32 *c_s1, size_t len, u32_locale_tocase (const uint32_t *c_s1, size_t len,
scm_t_uint32 **p_c_s2, size_t * p_len2, uint32_t **p_c_s2, size_t * p_len2,
scm_t_uint32 *(*func) (const scm_t_uint32 *, size_t, uint32_t *(*func) (const uint32_t *, size_t,
const char *, uninorm_t, const char *, uninorm_t,
scm_t_uint32 *, size_t *)) uint32_t *, size_t *))
{ {
/* Note: Since this is called from `RUN_IN_LOCALE_SECTION', it must not /* Note: Since this is called from `RUN_IN_LOCALE_SECTION', it must not
make any non-local exit. */ make any non-local exit. */
scm_t_uint32 *ret; uint32_t *ret;
const char *loc = locale_language (); const char *loc = locale_language ();
/* The first NULL here indicates that no NFC or NFKC normalization /* The first NULL here indicates that no NFC or NFKC normalization
@ -1063,7 +1063,7 @@ u32_locale_tocase (const scm_t_uint32 *c_s1, size_t len,
if (ret == NULL) if (ret == NULL)
{ {
*p_c_s2 = (scm_t_uint32 *) NULL; *p_c_s2 = (uint32_t *) NULL;
*p_len2 = 0; *p_len2 = 0;
return errno; return errno;
} }
@ -1075,15 +1075,15 @@ u32_locale_tocase (const scm_t_uint32 *c_s1, size_t len,
static SCM static SCM
chr_to_case (SCM chr, scm_t_locale c_locale, chr_to_case (SCM chr, scm_t_locale c_locale,
scm_t_uint32 *(*func) (const scm_t_uint32 *, size_t, const char *, uint32_t *(*func) (const uint32_t *, size_t, const char *,
uninorm_t, scm_t_uint32 *, size_t *), uninorm_t, uint32_t *, size_t *),
const char *func_name, const char *func_name,
int *err) int *err)
#define FUNC_NAME func_name #define FUNC_NAME func_name
{ {
int ret; int ret;
scm_t_uint32 c; uint32_t c;
scm_t_uint32 *convbuf; uint32_t *convbuf;
size_t convlen; size_t convlen;
SCM convchar; SCM convchar;
@ -1186,14 +1186,14 @@ SCM_DEFINE (scm_char_locale_titlecase, "char-locale-titlecase", 1, 1, 0,
static SCM static SCM
str_to_case (SCM str, scm_t_locale c_locale, str_to_case (SCM str, scm_t_locale c_locale,
scm_t_uint32 *(*func) (const scm_t_uint32 *, size_t, const char *, uint32_t *(*func) (const uint32_t *, size_t, const char *,
uninorm_t, scm_t_uint32 *, size_t *), uninorm_t, uint32_t *, size_t *),
const char *func_name, const char *func_name,
int *err) int *err)
#define FUNC_NAME func_name #define FUNC_NAME func_name
{ {
scm_t_wchar *c_str, *c_buf; scm_t_wchar *c_str, *c_buf;
scm_t_uint32 *c_convstr; uint32_t *c_convstr;
size_t len, convlen; size_t len, convlen;
int ret; int ret;
SCM convstr; SCM convstr;
@ -1205,12 +1205,12 @@ str_to_case (SCM str, scm_t_locale c_locale,
if (c_locale) if (c_locale)
RUN_IN_LOCALE_SECTION (c_locale, ret = RUN_IN_LOCALE_SECTION (c_locale, ret =
u32_locale_tocase ((scm_t_uint32 *) c_str, len, u32_locale_tocase ((uint32_t *) c_str, len,
&c_convstr, &c_convstr,
&convlen, func)); &convlen, func));
else else
ret = ret =
u32_locale_tocase ((scm_t_uint32 *) c_str, len, u32_locale_tocase ((uint32_t *) c_str, len,
&c_convstr, &convlen, func); &c_convstr, &convlen, func);
scm_remember_upto_here (str); scm_remember_upto_here (str);

2
libguile/instructions.c
View file

@ -127,7 +127,7 @@ static SCM word_type_symbols[] =
/* Scheme interface */ /* Scheme interface */
static SCM static SCM
parse_instruction (scm_t_uint8 opcode, const char *name, scm_t_uint64 meta) parse_instruction (uint8_t opcode, const char *name, uint64_t meta)
{ {
SCM tail = SCM_EOL; SCM tail = SCM_EOL;
int len; int len;

26
libguile/intrinsics.c
View file

@ -58,19 +58,19 @@ SCM_DEFINE (scm_intrinsic_list, "intrinsic-list", 0, 0, 0,
#undef FUNC_NAME #undef FUNC_NAME
static SCM static SCM
add_immediate (SCM a, scm_t_uint8 b) add_immediate (SCM a, uint8_t b)
{ {
return scm_sum (a, scm_from_uint8 (b)); return scm_sum (a, scm_from_uint8 (b));
} }
static SCM static SCM
sub_immediate (SCM a, scm_t_uint8 b) sub_immediate (SCM a, uint8_t b)
{ {
return scm_difference (a, scm_from_uint8 (b)); return scm_difference (a, scm_from_uint8 (b));
} }
static void static void
string_set_x (SCM str, scm_t_uint64 idx, scm_t_uint64 ch) string_set_x (SCM str, uint64_t idx, uint64_t ch)
{ {
str = scm_i_string_start_writing (str); str = scm_i_string_start_writing (str);
scm_i_string_set_x (str, idx, ch); scm_i_string_set_x (str, idx, ch);
@ -83,13 +83,13 @@ string_to_number (SCM str)
return scm_string_to_number (str, SCM_UNDEFINED /* radix = 10 */); return scm_string_to_number (str, SCM_UNDEFINED /* radix = 10 */);
} }
static scm_t_uint64 static uint64_t
scm_to_uint64_truncate (SCM x) scm_to_uint64_truncate (SCM x)
{ {
if (SCM_I_INUMP (x)) if (SCM_I_INUMP (x))
return (scm_t_uint64) SCM_I_INUM (x); return (uint64_t) SCM_I_INUM (x);
else else
return scm_to_uint64 (scm_logand (x, scm_from_uint64 ((scm_t_uint64) -1))); return scm_to_uint64 (scm_logand (x, scm_from_uint64 ((uint64_t) -1)));
} }
static SCM static SCM
@ -175,10 +175,10 @@ pop_dynamic_state (scm_i_thread *thread)
} }
static SCM static SCM
lsh (SCM a, scm_t_uint64 b) lsh (SCM a, uint64_t b)
{ {
if (SCM_LIKELY (SCM_I_INUMP (a)) if (SCM_LIKELY (SCM_I_INUMP (a))
&& b < (scm_t_uint64) (SCM_I_FIXNUM_BIT - 1) && b < (uint64_t) (SCM_I_FIXNUM_BIT - 1)
&& ((scm_t_bits) && ((scm_t_bits)
(SCM_SRS (SCM_I_INUM (a), (SCM_I_FIXNUM_BIT-1 - b)) + 1) (SCM_SRS (SCM_I_INUM (a), (SCM_I_FIXNUM_BIT-1 - b)) + 1)
<= 1)) <= 1))
@ -191,11 +191,11 @@ lsh (SCM a, scm_t_uint64 b)
} }
static SCM static SCM
rsh (SCM a, scm_t_uint64 b) rsh (SCM a, uint64_t b)
{ {
if (SCM_LIKELY (SCM_I_INUMP (a))) if (SCM_LIKELY (SCM_I_INUMP (a)))
{ {
if (b > (scm_t_uint64) (SCM_I_FIXNUM_BIT - 1)) if (b > (uint64_t) (SCM_I_FIXNUM_BIT - 1))
b = SCM_I_FIXNUM_BIT - 1; b = SCM_I_FIXNUM_BIT - 1;
return SCM_I_MAKINUM (SCM_SRS (SCM_I_INUM (a), b)); return SCM_I_MAKINUM (SCM_SRS (SCM_I_INUM (a), b));
} }
@ -204,13 +204,13 @@ rsh (SCM a, scm_t_uint64 b)
} }
static SCM static SCM
lsh_immediate (SCM a, scm_t_uint8 b) lsh_immediate (SCM a, uint8_t b)
{ {
return lsh (a, b); return lsh (a, b);
} }
static SCM static SCM
rsh_immediate (SCM a, scm_t_uint8 b) rsh_immediate (SCM a, uint8_t b)
{ {
return rsh (a, b); return rsh (a, b);
} }
@ -233,7 +233,7 @@ numerically_equal_p (SCM a, SCM b)
} }
static SCM static SCM
resolve_module (SCM name, scm_t_uint8 public_p) resolve_module (SCM name, uint8_t public_p)
{ {
SCM mod; SCM mod;

14
libguile/intrinsics.h
View file

@ -26,19 +26,19 @@
#include <libguile/vm.h> #include <libguile/vm.h>
typedef SCM (*scm_t_scm_from_scm_scm_intrinsic) (SCM, SCM); typedef SCM (*scm_t_scm_from_scm_scm_intrinsic) (SCM, SCM);
typedef SCM (*scm_t_scm_from_scm_uimm_intrinsic) (SCM, scm_t_uint8); typedef SCM (*scm_t_scm_from_scm_uimm_intrinsic) (SCM, uint8_t);
typedef void (*scm_t_scm_u64_u64_intrinsic) (SCM, scm_t_uint64, scm_t_uint64); typedef void (*scm_t_scm_u64_u64_intrinsic) (SCM, uint64_t, uint64_t);
typedef SCM (*scm_t_scm_from_scm_intrinsic) (SCM); typedef SCM (*scm_t_scm_from_scm_intrinsic) (SCM);
typedef double (*scm_t_f64_from_scm_intrinsic) (SCM); typedef double (*scm_t_f64_from_scm_intrinsic) (SCM);
typedef scm_t_uint64 (*scm_t_u64_from_scm_intrinsic) (SCM); typedef uint64_t (*scm_t_u64_from_scm_intrinsic) (SCM);
typedef scm_t_int64 (*scm_t_s64_from_scm_intrinsic) (SCM); typedef int64_t (*scm_t_s64_from_scm_intrinsic) (SCM);
typedef SCM (*scm_t_scm_from_u64_intrinsic) (scm_t_uint64); typedef SCM (*scm_t_scm_from_u64_intrinsic) (uint64_t);
typedef SCM (*scm_t_scm_from_s64_intrinsic) (scm_t_int64); typedef SCM (*scm_t_scm_from_s64_intrinsic) (int64_t);
typedef void (*scm_t_thread_intrinsic) (scm_i_thread*); typedef void (*scm_t_thread_intrinsic) (scm_i_thread*);
typedef void (*scm_t_thread_scm_intrinsic) (scm_i_thread*, SCM); typedef void (*scm_t_thread_scm_intrinsic) (scm_i_thread*, SCM);
typedef void (*scm_t_thread_scm_scm_intrinsic) (scm_i_thread*, SCM, SCM); typedef void (*scm_t_thread_scm_scm_intrinsic) (scm_i_thread*, SCM, SCM);
typedef SCM (*scm_t_scm_from_thread_scm_intrinsic) (scm_i_thread*, SCM); typedef SCM (*scm_t_scm_from_thread_scm_intrinsic) (scm_i_thread*, SCM);
typedef SCM (*scm_t_scm_from_scm_u64_intrinsic) (SCM, scm_t_uint64); typedef SCM (*scm_t_scm_from_scm_u64_intrinsic) (SCM, uint64_t);
typedef int (*scm_t_bool_from_scm_scm_intrinsic) (SCM, SCM); typedef int (*scm_t_bool_from_scm_scm_intrinsic) (SCM, SCM);
typedef enum scm_compare (*scm_t_compare_from_scm_scm_intrinsic) (SCM, SCM); typedef enum scm_compare (*scm_t_compare_from_scm_scm_intrinsic) (SCM, SCM);
typedef void (*scm_t_vp_sp_intrinsic) (struct scm_vm*, union scm_vm_stack_element*); typedef void (*scm_t_vp_sp_intrinsic) (struct scm_vm*, union scm_vm_stack_element*);

36
libguile/loader.c
View file

@ -105,7 +105,7 @@ pointer_to_procedure (enum bytecode_kind bytecode_kind, char *ptr)
{ {
case BYTECODE_KIND_GUILE_3_0: case BYTECODE_KIND_GUILE_3_0:
{ {
return scm_i_make_program ((scm_t_uint32 *) ptr); return scm_i_make_program ((uint32_t *) ptr);
} }
case BYTECODE_KIND_NONE: case BYTECODE_KIND_NONE:
default: default:
@ -178,7 +178,7 @@ elf_alignment (const char *data, size_t len)
Elf_Phdr *phdr; Elf_Phdr *phdr;
const char *phdr_addr = data + header->e_phoff + i * header->e_phentsize; const char *phdr_addr = data + header->e_phoff + i * header->e_phentsize;
if (!IS_ALIGNED ((scm_t_uintptr) phdr_addr, alignof_type (Elf_Phdr))) if (!IS_ALIGNED ((uintptr_t) phdr_addr, alignof_type (Elf_Phdr)))
return alignment; return alignment;
phdr = (Elf_Phdr *) phdr_addr; phdr = (Elf_Phdr *) phdr_addr;
@ -220,7 +220,7 @@ alloc_aligned (size_t len, unsigned alignment)
ret = malloc (len + alignment - 1); ret = malloc (len + alignment - 1);
if (!ret) if (!ret)
abort (); abort ();
ret = (char *) ALIGN ((scm_t_uintptr) ret, (scm_t_uintptr) alignment); ret = (char *) ALIGN ((uintptr_t) ret, (uintptr_t) alignment);
} }
return ret; return ret;
@ -298,8 +298,8 @@ process_dynamic_segment (char *base, Elf_Phdr *dyn_phdr,
if (bytecode_kind != BYTECODE_KIND_NONE) if (bytecode_kind != BYTECODE_KIND_NONE)
return "duplicate DT_GUILE_VM_VERSION"; return "duplicate DT_GUILE_VM_VERSION";
{ {
scm_t_uint16 major = dyn[i].d_un.d_val >> 16; uint16_t major = dyn[i].d_un.d_val >> 16;
scm_t_uint16 minor = dyn[i].d_un.d_val & 0xffff; uint16_t minor = dyn[i].d_un.d_val & 0xffff;
switch (major) switch (major)
{ {
case 0x0300: case 0x0300:
@ -328,9 +328,9 @@ process_dynamic_segment (char *base, Elf_Phdr *dyn_phdr,
switch (bytecode_kind) switch (bytecode_kind)
{ {
case BYTECODE_KIND_GUILE_3_0: case BYTECODE_KIND_GUILE_3_0:
if ((scm_t_uintptr) init % 4) if ((uintptr_t) init % 4)
return "unaligned DT_INIT"; return "unaligned DT_INIT";
if ((scm_t_uintptr) entry % 4) if ((uintptr_t) entry % 4)
return "unaligned DT_GUILE_ENTRY"; return "unaligned DT_GUILE_ENTRY";
break; break;
case BYTECODE_KIND_NONE: case BYTECODE_KIND_NONE:
@ -437,7 +437,7 @@ load_thunk_from_memory (char *data, size_t len, int is_read_only)
(for the mmap path) that the base _is_ page-aligned, we proceed (for the mmap path) that the base _is_ page-aligned, we proceed
ahead even if the image alignment is greater than the page ahead even if the image alignment is greater than the page
size. */ size. */
if (!IS_ALIGNED ((scm_t_uintptr) data, alignment) if (!IS_ALIGNED ((uintptr_t) data, alignment)
&& !IS_ALIGNED (alignment, page_size)) && !IS_ALIGNED (alignment, page_size))
ABORT ("incorrectly aligned base"); ABORT ("incorrectly aligned base");
@ -754,27 +754,27 @@ scm_all_mapped_elf_images (void)
struct frame_map_prefix struct frame_map_prefix
{ {
scm_t_uint32 text_offset; uint32_t text_offset;
scm_t_uint32 maps_offset; uint32_t maps_offset;
}; };
struct frame_map_header struct frame_map_header
{ {
scm_t_uint32 addr; uint32_t addr;
scm_t_uint32 map_offset; uint32_t map_offset;
}; };
verify (sizeof (struct frame_map_prefix) == 8); verify (sizeof (struct frame_map_prefix) == 8);
verify (sizeof (struct frame_map_header) == 8); verify (sizeof (struct frame_map_header) == 8);
const scm_t_uint8 * const uint8_t *
scm_find_slot_map_unlocked (const scm_t_uint32 *ip) scm_find_slot_map_unlocked (const uint32_t *ip)
{ {
struct mapped_elf_image *image; struct mapped_elf_image *image;
char *base; char *base;
struct frame_map_prefix *prefix; struct frame_map_prefix *prefix;
struct frame_map_header *headers; struct frame_map_header *headers;
scm_t_uintptr addr = (scm_t_uintptr) ip; uintptr_t addr = (uintptr_t) ip;
size_t start, end; size_t start, end;
image = find_mapped_elf_image_unlocked ((char *) ip); image = find_mapped_elf_image_unlocked ((char *) ip);
@ -785,9 +785,9 @@ scm_find_slot_map_unlocked (const scm_t_uint32 *ip)
prefix = (struct frame_map_prefix *) base; prefix = (struct frame_map_prefix *) base;
headers = (struct frame_map_header *) (base + sizeof (*prefix)); headers = (struct frame_map_header *) (base + sizeof (*prefix));
if (addr < ((scm_t_uintptr) image->start) + prefix->text_offset) if (addr < ((uintptr_t) image->start) + prefix->text_offset)
return NULL; return NULL;
addr -= ((scm_t_uintptr) image->start) + prefix->text_offset; addr -= ((uintptr_t) image->start) + prefix->text_offset;
start = 0; start = 0;
end = (prefix->maps_offset - sizeof (*prefix)) / sizeof (*headers); end = (prefix->maps_offset - sizeof (*prefix)) / sizeof (*headers);
@ -800,7 +800,7 @@ scm_find_slot_map_unlocked (const scm_t_uint32 *ip)
size_t n = start + (end - start) / 2; size_t n = start + (end - start) / 2;
if (addr == headers[n].addr) if (addr == headers[n].addr)
return (const scm_t_uint8*) (base + headers[n].map_offset); return (const uint8_t*) (base + headers[n].map_offset);
else if (addr < headers[n].addr) else if (addr < headers[n].addr)
end = n; end = n;
else else

4
libguile/loader.h
View file

@ -55,8 +55,8 @@
SCM_API SCM scm_load_thunk_from_file (SCM filename); SCM_API SCM scm_load_thunk_from_file (SCM filename);
SCM_API SCM scm_load_thunk_from_memory (SCM bv); SCM_API SCM scm_load_thunk_from_memory (SCM bv);
SCM_INTERNAL const scm_t_uint8 * SCM_INTERNAL const uint8_t *
scm_find_slot_map_unlocked (const scm_t_uint32 *ip); scm_find_slot_map_unlocked (const uint32_t *ip);
SCM_INTERNAL void scm_bootstrap_loader (void); SCM_INTERNAL void scm_bootstrap_loader (void);
SCM_INTERNAL void scm_init_loader (void); SCM_INTERNAL void scm_init_loader (void);

80
libguile/numbers.c
View file

@ -5557,12 +5557,12 @@ iflo2str (SCM flt, char *str, int radix)
return i; return i;
} }
/* convert a scm_t_intmax to a string (unterminated). returns the number of /* convert a intmax_t to a string (unterminated). returns the number of
characters in the result. characters in the result.
rad is output base rad is output base
p is destination: worst case (base 2) is SCM_INTBUFLEN */ p is destination: worst case (base 2) is SCM_INTBUFLEN */
size_t size_t
scm_iint2str (scm_t_intmax num, int rad, char *p) scm_iint2str (intmax_t num, int rad, char *p)
{ {
if (num < 0) if (num < 0)
{ {
@ -5573,16 +5573,16 @@ scm_iint2str (scm_t_intmax num, int rad, char *p)
return scm_iuint2str (num, rad, p); return scm_iuint2str (num, rad, p);
} }
/* convert a scm_t_intmax to a string (unterminated). returns the number of /* convert a intmax_t to a string (unterminated). returns the number of
characters in the result. characters in the result.
rad is output base rad is output base
p is destination: worst case (base 2) is SCM_INTBUFLEN */ p is destination: worst case (base 2) is SCM_INTBUFLEN */
size_t size_t
scm_iuint2str (scm_t_uintmax num, int rad, char *p) scm_iuint2str (uintmax_t num, int rad, char *p)
{ {
size_t j = 1; size_t j = 1;
size_t i; size_t i;
scm_t_uintmax n = num; uintmax_t n = num;
if (rad < 2 || rad > 36) if (rad < 2 || rad > 36)
scm_out_of_range ("scm_iuint2str", scm_from_int (rad)); scm_out_of_range ("scm_iuint2str", scm_from_int (rad));
@ -5771,10 +5771,10 @@ enum t_exactness {NO_EXACTNESS, INEXACT, EXACT};
/* Caller is responsible for checking that the return value is in range /* Caller is responsible for checking that the return value is in range
for the given radix, which should be <= 36. */ for the given radix, which should be <= 36. */
static unsigned int static unsigned int
char_decimal_value (scm_t_uint32 c) char_decimal_value (uint32_t c)
{ {
if (c >= (scm_t_uint32) '0' && c <= (scm_t_uint32) '9') if (c >= (uint32_t) '0' && c <= (uint32_t) '9')
return c - (scm_t_uint32) '0'; return c - (uint32_t) '0';
else else
{ {
/* uc_decimal_value returns -1 on error. When cast to an unsigned int, /* uc_decimal_value returns -1 on error. When cast to an unsigned int,
@ -5787,8 +5787,8 @@ char_decimal_value (scm_t_uint32 c)
if (d >= 10U) if (d >= 10U)
{ {
c = uc_tolower (c); c = uc_tolower (c);
if (c >= (scm_t_uint32) 'a') if (c >= (uint32_t) 'a')
d = c - (scm_t_uint32)'a' + 10U; d = c - (uint32_t)'a' + 10U;
} }
return d; return d;
} }
@ -5900,7 +5900,7 @@ mem2decimal_from_point (SCM result, SCM mem,
while (idx != len) while (idx != len)
{ {
scm_t_wchar c = scm_i_string_ref (mem, idx); scm_t_wchar c = scm_i_string_ref (mem, idx);
if (uc_is_property_decimal_digit ((scm_t_uint32) c)) if (uc_is_property_decimal_digit ((uint32_t) c))
{ {
if (x == INEXACT) if (x == INEXACT)
return SCM_BOOL_F; return SCM_BOOL_F;
@ -5990,7 +5990,7 @@ mem2decimal_from_point (SCM result, SCM mem,
else else
sign = 1; sign = 1;
if (!uc_is_property_decimal_digit ((scm_t_uint32) c)) if (!uc_is_property_decimal_digit ((uint32_t) c))
return SCM_BOOL_F; return SCM_BOOL_F;
idx++; idx++;
@ -5998,7 +5998,7 @@ mem2decimal_from_point (SCM result, SCM mem,
while (idx != len) while (idx != len)
{ {
scm_t_wchar c = scm_i_string_ref (mem, idx); scm_t_wchar c = scm_i_string_ref (mem, idx);
if (uc_is_property_decimal_digit ((scm_t_uint32) c)) if (uc_is_property_decimal_digit ((uint32_t) c))
{ {
idx++; idx++;
if (exponent <= SCM_MAXEXP) if (exponent <= SCM_MAXEXP)
@ -6105,7 +6105,7 @@ mem2ureal (SCM mem, unsigned int *p_idx,
return SCM_BOOL_F; return SCM_BOOL_F;
else if (idx + 1 == len) else if (idx + 1 == len)
return SCM_BOOL_F; return SCM_BOOL_F;
else if (!uc_is_property_decimal_digit ((scm_t_uint32) scm_i_string_ref (mem, idx+1))) else if (!uc_is_property_decimal_digit ((uint32_t) scm_i_string_ref (mem, idx+1)))
return SCM_BOOL_F; return SCM_BOOL_F;
else else
result = mem2decimal_from_point (SCM_INUM0, mem, result = mem2decimal_from_point (SCM_INUM0, mem,
@ -8017,7 +8017,7 @@ scm_product (SCM x, SCM y)
{ {
scm_t_inum yy = SCM_I_INUM (y); scm_t_inum yy = SCM_I_INUM (y);
#if SCM_I_FIXNUM_BIT < 32 && SCM_HAVE_T_INT64 #if SCM_I_FIXNUM_BIT < 32 && SCM_HAVE_T_INT64
scm_t_int64 kk = xx * (scm_t_int64) yy; int64_t kk = xx * (int64_t) yy;
if (SCM_FIXABLE (kk)) if (SCM_FIXABLE (kk))
return SCM_I_MAKINUM (kk); return SCM_I_MAKINUM (kk);
#else #else
@ -9608,7 +9608,7 @@ scm_is_exact_integer (SCM val)
} }
int int
scm_is_signed_integer (SCM val, scm_t_intmax min, scm_t_intmax max) scm_is_signed_integer (SCM val, intmax_t min, intmax_t max)
{ {
if (SCM_I_INUMP (val)) if (SCM_I_INUMP (val))
{ {
@ -9631,15 +9631,15 @@ scm_is_signed_integer (SCM val, scm_t_intmax min, scm_t_intmax max)
} }
else else
{ {
scm_t_uintmax abs_n; uintmax_t abs_n;
scm_t_intmax n; intmax_t n;
size_t count; size_t count;
if (mpz_sizeinbase (SCM_I_BIG_MPZ (val), 2) if (mpz_sizeinbase (SCM_I_BIG_MPZ (val), 2)
> CHAR_BIT*sizeof (scm_t_uintmax)) > CHAR_BIT*sizeof (uintmax_t))
return 0; return 0;
mpz_export (&abs_n, &count, 1, sizeof (scm_t_uintmax), 0, 0, mpz_export (&abs_n, &count, 1, sizeof (uintmax_t), 0, 0,
SCM_I_BIG_MPZ (val)); SCM_I_BIG_MPZ (val));
if (mpz_sgn (SCM_I_BIG_MPZ (val)) >= 0) if (mpz_sgn (SCM_I_BIG_MPZ (val)) >= 0)
@ -9653,7 +9653,7 @@ scm_is_signed_integer (SCM val, scm_t_intmax min, scm_t_intmax max)
{ {
/* Carefully avoid signed integer overflow. */ /* Carefully avoid signed integer overflow. */
if (min < 0 && abs_n - 1 <= -(min + 1)) if (min < 0 && abs_n - 1 <= -(min + 1))
n = -1 - (scm_t_intmax)(abs_n - 1); n = -1 - (intmax_t)(abs_n - 1);
else else
return 0; return 0;
} }
@ -9666,12 +9666,12 @@ scm_is_signed_integer (SCM val, scm_t_intmax min, scm_t_intmax max)
} }
int int
scm_is_unsigned_integer (SCM val, scm_t_uintmax min, scm_t_uintmax max) scm_is_unsigned_integer (SCM val, uintmax_t min, uintmax_t max)
{ {
if (SCM_I_INUMP (val)) if (SCM_I_INUMP (val))
{ {
scm_t_signed_bits n = SCM_I_INUM (val); scm_t_signed_bits n = SCM_I_INUM (val);
return n >= 0 && ((scm_t_uintmax)n) >= min && ((scm_t_uintmax)n) <= max; return n >= 0 && ((uintmax_t)n) >= min && ((uintmax_t)n) <= max;
} }
else if (SCM_BIGP (val)) else if (SCM_BIGP (val))
{ {
@ -9689,17 +9689,17 @@ scm_is_unsigned_integer (SCM val, scm_t_uintmax min, scm_t_uintmax max)
} }
else else
{ {
scm_t_uintmax n; uintmax_t n;
size_t count; size_t count;
if (mpz_sgn (SCM_I_BIG_MPZ (val)) < 0) if (mpz_sgn (SCM_I_BIG_MPZ (val)) < 0)
return 0; return 0;
if (mpz_sizeinbase (SCM_I_BIG_MPZ (val), 2) if (mpz_sizeinbase (SCM_I_BIG_MPZ (val), 2)
> CHAR_BIT*sizeof (scm_t_uintmax)) > CHAR_BIT*sizeof (uintmax_t))
return 0; return 0;
mpz_export (&n, &count, 1, sizeof (scm_t_uintmax), 0, 0, mpz_export (&n, &count, 1, sizeof (uintmax_t), 0, 0,
SCM_I_BIG_MPZ (val)); SCM_I_BIG_MPZ (val));
return n >= min && n <= max; return n >= min && n <= max;
@ -9719,23 +9719,23 @@ scm_i_range_error (SCM bad_val, SCM min, SCM max)
scm_list_1 (bad_val)); scm_list_1 (bad_val));
} }
#define TYPE scm_t_intmax #define TYPE intmax_t
#define TYPE_MIN min #define TYPE_MIN min
#define TYPE_MAX max #define TYPE_MAX max
#define SIZEOF_TYPE 0 #define SIZEOF_TYPE 0
#define SCM_TO_TYPE_PROTO(arg) scm_to_signed_integer (arg, scm_t_intmax min, scm_t_intmax max) #define SCM_TO_TYPE_PROTO(arg) scm_to_signed_integer (arg, intmax_t min, intmax_t max)
#define SCM_FROM_TYPE_PROTO(arg) scm_from_signed_integer (arg) #define SCM_FROM_TYPE_PROTO(arg) scm_from_signed_integer (arg)
#include "conv-integer.i.c" #include "conv-integer.i.c"
#define TYPE scm_t_uintmax #define TYPE uintmax_t
#define TYPE_MIN min #define TYPE_MIN min
#define TYPE_MAX max #define TYPE_MAX max
#define SIZEOF_TYPE 0 #define SIZEOF_TYPE 0
#define SCM_TO_TYPE_PROTO(arg) scm_to_unsigned_integer (arg, scm_t_uintmax min, scm_t_uintmax max) #define SCM_TO_TYPE_PROTO(arg) scm_to_unsigned_integer (arg, uintmax_t min, uintmax_t max)
#define SCM_FROM_TYPE_PROTO(arg) scm_from_unsigned_integer (arg) #define SCM_FROM_TYPE_PROTO(arg) scm_from_unsigned_integer (arg)
#include "conv-uinteger.i.c" #include "conv-uinteger.i.c"
#define TYPE scm_t_int8 #define TYPE int8_t
#define TYPE_MIN INT8_MIN #define TYPE_MIN INT8_MIN
#define TYPE_MAX INT8_MAX #define TYPE_MAX INT8_MAX
#define SIZEOF_TYPE 1 #define SIZEOF_TYPE 1
@ -9743,7 +9743,7 @@ scm_i_range_error (SCM bad_val, SCM min, SCM max)
#define SCM_FROM_TYPE_PROTO(arg) scm_from_int8 (arg) #define SCM_FROM_TYPE_PROTO(arg) scm_from_int8 (arg)
#include "conv-integer.i.c" #include "conv-integer.i.c"
#define TYPE scm_t_uint8 #define TYPE uint8_t
#define TYPE_MIN 0 #define TYPE_MIN 0
#define TYPE_MAX UINT8_MAX #define TYPE_MAX UINT8_MAX
#define SIZEOF_TYPE 1 #define SIZEOF_TYPE 1
@ -9751,7 +9751,7 @@ scm_i_range_error (SCM bad_val, SCM min, SCM max)
#define SCM_FROM_TYPE_PROTO(arg) scm_from_uint8 (arg) #define SCM_FROM_TYPE_PROTO(arg) scm_from_uint8 (arg)
#include "conv-uinteger.i.c" #include "conv-uinteger.i.c"
#define TYPE scm_t_int16 #define TYPE int16_t
#define TYPE_MIN INT16_MIN #define TYPE_MIN INT16_MIN
#define TYPE_MAX INT16_MAX #define TYPE_MAX INT16_MAX
#define SIZEOF_TYPE 2 #define SIZEOF_TYPE 2
@ -9759,7 +9759,7 @@ scm_i_range_error (SCM bad_val, SCM min, SCM max)
#define SCM_FROM_TYPE_PROTO(arg) scm_from_int16 (arg) #define SCM_FROM_TYPE_PROTO(arg) scm_from_int16 (arg)
#include "conv-integer.i.c" #include "conv-integer.i.c"
#define TYPE scm_t_uint16 #define TYPE uint16_t
#define TYPE_MIN 0 #define TYPE_MIN 0
#define TYPE_MAX UINT16_MAX #define TYPE_MAX UINT16_MAX
#define SIZEOF_TYPE 2 #define SIZEOF_TYPE 2
@ -9767,7 +9767,7 @@ scm_i_range_error (SCM bad_val, SCM min, SCM max)
#define SCM_FROM_TYPE_PROTO(arg) scm_from_uint16 (arg) #define SCM_FROM_TYPE_PROTO(arg) scm_from_uint16 (arg)
#include "conv-uinteger.i.c" #include "conv-uinteger.i.c"
#define TYPE scm_t_int32 #define TYPE int32_t
#define TYPE_MIN INT32_MIN #define TYPE_MIN INT32_MIN
#define TYPE_MAX INT32_MAX #define TYPE_MAX INT32_MAX
#define SIZEOF_TYPE 4 #define SIZEOF_TYPE 4
@ -9775,7 +9775,7 @@ scm_i_range_error (SCM bad_val, SCM min, SCM max)
#define SCM_FROM_TYPE_PROTO(arg) scm_from_int32 (arg) #define SCM_FROM_TYPE_PROTO(arg) scm_from_int32 (arg)
#include "conv-integer.i.c" #include "conv-integer.i.c"
#define TYPE scm_t_uint32 #define TYPE uint32_t
#define TYPE_MIN 0 #define TYPE_MIN 0
#define TYPE_MAX UINT32_MAX #define TYPE_MAX UINT32_MAX
#define SIZEOF_TYPE 4 #define SIZEOF_TYPE 4
@ -9784,14 +9784,14 @@ scm_i_range_error (SCM bad_val, SCM min, SCM max)
#include "conv-uinteger.i.c" #include "conv-uinteger.i.c"
#define TYPE scm_t_wchar #define TYPE scm_t_wchar
#define TYPE_MIN (scm_t_int32)-1 #define TYPE_MIN (int32_t)-1
#define TYPE_MAX (scm_t_int32)0x10ffff #define TYPE_MAX (int32_t)0x10ffff
#define SIZEOF_TYPE 4 #define SIZEOF_TYPE 4
#define SCM_TO_TYPE_PROTO(arg) scm_to_wchar (arg) #define SCM_TO_TYPE_PROTO(arg) scm_to_wchar (arg)
#define SCM_FROM_TYPE_PROTO(arg) scm_from_wchar (arg) #define SCM_FROM_TYPE_PROTO(arg) scm_from_wchar (arg)
#include "conv-integer.i.c" #include "conv-integer.i.c"
#define TYPE scm_t_int64 #define TYPE int64_t
#define TYPE_MIN INT64_MIN #define TYPE_MIN INT64_MIN
#define TYPE_MAX INT64_MAX #define TYPE_MAX INT64_MAX
#define SIZEOF_TYPE 8 #define SIZEOF_TYPE 8
@ -9799,7 +9799,7 @@ scm_i_range_error (SCM bad_val, SCM min, SCM max)
#define SCM_FROM_TYPE_PROTO(arg) scm_from_int64 (arg) #define SCM_FROM_TYPE_PROTO(arg) scm_from_int64 (arg)
#include "conv-integer.i.c" #include "conv-integer.i.c"
#define TYPE scm_t_uint64 #define TYPE uint64_t
#define TYPE_MIN 0 #define TYPE_MIN 0
#define TYPE_MAX UINT64_MAX #define TYPE_MAX UINT64_MAX
#define SIZEOF_TYPE 8 #define SIZEOF_TYPE 8

62
libguile/numbers.h
View file

@ -118,11 +118,11 @@ typedef long scm_t_inum;
/* SCM_INTBUFLEN is the maximum number of characters neccessary for /* SCM_INTBUFLEN is the maximum number of characters neccessary for
* the printed or scm_string representation of an scm_t_intmax in * the printed or scm_string representation of an intmax_t in
* radix 2. The buffer passed to scm_iint2str and scm_iuint2str must * radix 2. The buffer passed to scm_iint2str and scm_iuint2str must
* be of this size, for example. * be of this size, for example.
*/ */
#define SCM_INTBUFLEN (5 + SCM_CHAR_BIT*sizeof(scm_t_intmax)) #define SCM_INTBUFLEN (5 + SCM_CHAR_BIT*sizeof(intmax_t))
@ -245,8 +245,8 @@ SCM_INTERNAL SCM scm_i_logand (SCM x, SCM y, SCM rest);
SCM_INTERNAL SCM scm_i_logior (SCM x, SCM y, SCM rest); SCM_INTERNAL SCM scm_i_logior (SCM x, SCM y, SCM rest);
SCM_INTERNAL SCM scm_i_logxor (SCM x, SCM y, SCM rest); SCM_INTERNAL SCM scm_i_logxor (SCM x, SCM y, SCM rest);
SCM_API size_t scm_iint2str (scm_t_intmax num, int rad, char *p); SCM_API size_t scm_iint2str (intmax_t num, int rad, char *p);
SCM_API size_t scm_iuint2str (scm_t_uintmax num, int rad, char *p); SCM_API size_t scm_iuint2str (uintmax_t num, int rad, char *p);
SCM_API SCM scm_number_to_string (SCM x, SCM radix); SCM_API SCM scm_number_to_string (SCM x, SCM radix);
SCM_API int scm_print_real (SCM sexp, SCM port, scm_print_state *pstate); SCM_API int scm_print_real (SCM sexp, SCM port, scm_print_state *pstate);
SCM_API int scm_print_complex (SCM sexp, SCM port, scm_print_state *pstate); SCM_API int scm_print_complex (SCM sexp, SCM port, scm_print_state *pstate);
@ -355,46 +355,46 @@ SCM_INTERNAL void scm_i_print_complex (double real, double imag, SCM port);
SCM_API int scm_is_integer (SCM val); SCM_API int scm_is_integer (SCM val);
SCM_API int scm_is_exact_integer (SCM val); SCM_API int scm_is_exact_integer (SCM val);
SCM_API int scm_is_signed_integer (SCM val, SCM_API int scm_is_signed_integer (SCM val,
scm_t_intmax min, scm_t_intmax max); intmax_t min, intmax_t max);
SCM_API int scm_is_unsigned_integer (SCM val, SCM_API int scm_is_unsigned_integer (SCM val,
scm_t_uintmax min, scm_t_uintmax max); uintmax_t min, uintmax_t max);
SCM_API SCM scm_from_signed_integer (scm_t_intmax val); SCM_API SCM scm_from_signed_integer (intmax_t val);
SCM_API SCM scm_from_unsigned_integer (scm_t_uintmax val); SCM_API SCM scm_from_unsigned_integer (uintmax_t val);
SCM_API scm_t_intmax scm_to_signed_integer (SCM val, SCM_API intmax_t scm_to_signed_integer (SCM val,
scm_t_intmax min, intmax_t min,
scm_t_intmax max); intmax_t max);
SCM_API scm_t_uintmax scm_to_unsigned_integer (SCM val, SCM_API uintmax_t scm_to_unsigned_integer (SCM val,
scm_t_uintmax min, uintmax_t min,
scm_t_uintmax max); uintmax_t max);
SCM_API scm_t_int8 scm_to_int8 (SCM x); SCM_API int8_t scm_to_int8 (SCM x);
SCM_API SCM scm_from_int8 (scm_t_int8 x); SCM_API SCM scm_from_int8 (int8_t x);
SCM_API scm_t_uint8 scm_to_uint8 (SCM x); SCM_API uint8_t scm_to_uint8 (SCM x);
SCM_API SCM scm_from_uint8 (scm_t_uint8 x); SCM_API SCM scm_from_uint8 (uint8_t x);
SCM_API scm_t_int16 scm_to_int16 (SCM x); SCM_API int16_t scm_to_int16 (SCM x);
SCM_API SCM scm_from_int16 (scm_t_int16 x); SCM_API SCM scm_from_int16 (int16_t x);
SCM_API scm_t_uint16 scm_to_uint16 (SCM x); SCM_API uint16_t scm_to_uint16 (SCM x);
SCM_API SCM scm_from_uint16 (scm_t_uint16 x); SCM_API SCM scm_from_uint16 (uint16_t x);
SCM_API scm_t_int32 scm_to_int32 (SCM x); SCM_API int32_t scm_to_int32 (SCM x);
SCM_API SCM scm_from_int32 (scm_t_int32 x); SCM_API SCM scm_from_int32 (int32_t x);
SCM_API scm_t_uint32 scm_to_uint32 (SCM x); SCM_API uint32_t scm_to_uint32 (SCM x);
SCM_API SCM scm_from_uint32 (scm_t_uint32 x); SCM_API SCM scm_from_uint32 (uint32_t x);
SCM_API scm_t_wchar scm_to_wchar (SCM x); SCM_API scm_t_wchar scm_to_wchar (SCM x);
SCM_API SCM scm_from_wchar (scm_t_wchar x); SCM_API SCM scm_from_wchar (scm_t_wchar x);
SCM_API scm_t_int64 scm_to_int64 (SCM x); SCM_API int64_t scm_to_int64 (SCM x);
SCM_API SCM scm_from_int64 (scm_t_int64 x); SCM_API SCM scm_from_int64 (int64_t x);
SCM_API scm_t_uint64 scm_to_uint64 (SCM x); SCM_API uint64_t scm_to_uint64 (SCM x);
SCM_API SCM scm_from_uint64 (scm_t_uint64 x); SCM_API SCM scm_from_uint64 (uint64_t x);
SCM_API void scm_to_mpz (SCM x, mpz_t rop); SCM_API void scm_to_mpz (SCM x, mpz_t rop);
SCM_API SCM scm_from_mpz (mpz_t rop); SCM_API SCM scm_from_mpz (mpz_t rop);
@ -494,7 +494,7 @@ SCM_API SCM scm_from_mpz (mpz_t rop);
#define scm_to_uintmax scm_to_uint64 #define scm_to_uintmax scm_to_uint64
#define scm_from_uintmax scm_from_uint64 #define scm_from_uintmax scm_from_uint64
#else #else
#error sizeof(scm_t_intmax) is not 4 or 8. #error sizeof(intmax_t) is not 4 or 8.
#endif #endif
#endif #endif

2
libguile/pairs.c
View file

@ -120,7 +120,7 @@ SCM_DEFINE (scm_set_cdr_x, "set-cdr!", 2, 0, 0,
/* The compiler should unroll this. */ /* The compiler should unroll this. */
#define CHASE_PAIRS(tree, FUNC_NAME, pattern) \ #define CHASE_PAIRS(tree, FUNC_NAME, pattern) \
scm_t_uint32 pattern_var = pattern; \ uint32_t pattern_var = pattern; \
do \ do \
{ \ { \
if (!scm_is_pair (tree)) \ if (!scm_is_pair (tree)) \

22
libguile/ports-internal.h
View file

@ -260,22 +260,22 @@ scm_port_buffer_did_put (SCM buf, size_t prev_end, size_t count)
scm_port_buffer_set_end (buf, SCM_I_MAKINUM (prev_end + count)); scm_port_buffer_set_end (buf, SCM_I_MAKINUM (prev_end + count));
} }
static inline const scm_t_uint8 * static inline const uint8_t *
scm_port_buffer_take_pointer (SCM buf, size_t cur) scm_port_buffer_take_pointer (SCM buf, size_t cur)
{ {
signed char *ret = SCM_BYTEVECTOR_CONTENTS (scm_port_buffer_bytevector (buf)); signed char *ret = SCM_BYTEVECTOR_CONTENTS (scm_port_buffer_bytevector (buf));
return ((scm_t_uint8 *) ret) + cur; return ((uint8_t *) ret) + cur;
} }
static inline scm_t_uint8 * static inline uint8_t *
scm_port_buffer_put_pointer (SCM buf, size_t end) scm_port_buffer_put_pointer (SCM buf, size_t end)
{ {
signed char *ret = SCM_BYTEVECTOR_CONTENTS (scm_port_buffer_bytevector (buf)); signed char *ret = SCM_BYTEVECTOR_CONTENTS (scm_port_buffer_bytevector (buf));
return ((scm_t_uint8 *) ret) + end; return ((uint8_t *) ret) + end;
} }
static inline size_t static inline size_t
scm_port_buffer_take (SCM buf, scm_t_uint8 *dst, size_t count, scm_port_buffer_take (SCM buf, uint8_t *dst, size_t count,
size_t cur, size_t avail) size_t cur, size_t avail)
{ {
if (avail < count) if (avail < count)
@ -287,7 +287,7 @@ scm_port_buffer_take (SCM buf, scm_t_uint8 *dst, size_t count,
} }
static inline size_t static inline size_t
scm_port_buffer_put (SCM buf, const scm_t_uint8 *src, size_t count, scm_port_buffer_put (SCM buf, const uint8_t *src, size_t count,
size_t end, size_t avail) size_t end, size_t avail)
{ {
if (avail < count) if (avail < count)
@ -299,7 +299,7 @@ scm_port_buffer_put (SCM buf, const scm_t_uint8 *src, size_t count,
} }
static inline void static inline void
scm_port_buffer_putback (SCM buf, const scm_t_uint8 *src, size_t count, scm_port_buffer_putback (SCM buf, const uint8_t *src, size_t count,
size_t cur) size_t cur)
{ {
assert (count <= cur); assert (count <= cur);
@ -337,14 +337,14 @@ struct scm_t_port
a refcount which is positive if close has not yet been called. a refcount which is positive if close has not yet been called.
Reading, writing, and the like temporarily increments this Reading, writing, and the like temporarily increments this
refcount, provided it was nonzero to start with. */ refcount, provided it was nonzero to start with. */
scm_t_uint32 refcount; uint32_t refcount;
/* True if the port is random access. Implies that the buffers must /* True if the port is random access. Implies that the buffers must
be flushed before switching between reading and writing, seeking, be flushed before switching between reading and writing, seeking,
and so on. */ and so on. */
scm_t_uint32 rw_random : 1; uint32_t rw_random : 1;
scm_t_uint32 at_stream_start_for_bom_read : 1; uint32_t at_stream_start_for_bom_read : 1;
scm_t_uint32 at_stream_start_for_bom_write : 1; uint32_t at_stream_start_for_bom_write : 1;
/* Character encoding support. */ /* Character encoding support. */
SCM encoding; /* A symbol of upper-case ASCII. */ SCM encoding; /* A symbol of upper-case ASCII. */

106
libguile/ports.c
View file

@ -148,7 +148,7 @@ release_port (SCM port)
Otherwise if the refcount is higher we just subtract 1 and we're Otherwise if the refcount is higher we just subtract 1 and we're
done. However if the current refcount is 0 then the port has been done. However if the current refcount is 0 then the port has been
closed or is closing and we just return. */ closed or is closing and we just return. */
scm_t_uint32 cur = 1, next = 0; uint32_t cur = 1, next = 0;
while (!scm_atomic_compare_and_swap_uint32 (&pt->refcount, &cur, next)) while (!scm_atomic_compare_and_swap_uint32 (&pt->refcount, &cur, next))
{ {
if (cur == 0) if (cur == 0)
@ -187,7 +187,7 @@ scm_dynwind_acquire_port (SCM port)
there is someone else using it; that's fine, we just add our there is someone else using it; that's fine, we just add our
refcount. However if the current refcount is 0 then the port has refcount. However if the current refcount is 0 then the port has
been closed or is closing and we must throw an error. */ been closed or is closing and we must throw an error. */
scm_t_uint32 cur = 1, next = 2; uint32_t cur = 1, next = 2;
while (!scm_atomic_compare_and_swap_uint32 (&pt->refcount, &cur, next)) while (!scm_atomic_compare_and_swap_uint32 (&pt->refcount, &cur, next))
{ {
if (cur == 0) if (cur == 0)
@ -1479,7 +1479,7 @@ get_byte_or_eof (SCM port)
&& SCM_LIKELY (cur < SCM_I_INUM (buf_end)) && SCM_LIKELY (cur < SCM_I_INUM (buf_end))
&& SCM_LIKELY (cur < SCM_BYTEVECTOR_LENGTH (buf_bv))) && SCM_LIKELY (cur < SCM_BYTEVECTOR_LENGTH (buf_bv)))
{ {
scm_t_uint8 ret = SCM_BYTEVECTOR_CONTENTS (buf_bv)[cur]; uint8_t ret = SCM_BYTEVECTOR_CONTENTS (buf_bv)[cur];
scm_port_buffer_set_cur (buf, SCM_I_MAKINUM (cur + 1)); scm_port_buffer_set_cur (buf, SCM_I_MAKINUM (cur + 1));
return ret; return ret;
} }
@ -1488,7 +1488,7 @@ get_byte_or_eof (SCM port)
buf_bv = scm_port_buffer_bytevector (buf); buf_bv = scm_port_buffer_bytevector (buf);
if (avail > 0) if (avail > 0)
{ {
scm_t_uint8 ret = SCM_BYTEVECTOR_CONTENTS (buf_bv)[cur]; uint8_t ret = SCM_BYTEVECTOR_CONTENTS (buf_bv)[cur];
scm_port_buffer_set_cur (buf, SCM_I_MAKINUM (cur + 1)); scm_port_buffer_set_cur (buf, SCM_I_MAKINUM (cur + 1));
return ret; return ret;
} }
@ -1516,7 +1516,7 @@ peek_byte_or_eof (SCM port, SCM *buf_out, size_t *cur_out)
&& SCM_LIKELY (cur < SCM_I_INUM (buf_end)) && SCM_LIKELY (cur < SCM_I_INUM (buf_end))
&& SCM_LIKELY (cur < SCM_BYTEVECTOR_LENGTH (buf_bv))) && SCM_LIKELY (cur < SCM_BYTEVECTOR_LENGTH (buf_bv)))
{ {
scm_t_uint8 ret = SCM_BYTEVECTOR_CONTENTS (buf_bv)[cur]; uint8_t ret = SCM_BYTEVECTOR_CONTENTS (buf_bv)[cur];
*buf_out = buf; *buf_out = buf;
*cur_out = cur; *cur_out = cur;
return ret; return ret;
@ -1528,7 +1528,7 @@ peek_byte_or_eof (SCM port, SCM *buf_out, size_t *cur_out)
*cur_out = cur; *cur_out = cur;
if (avail > 0) if (avail > 0)
{ {
scm_t_uint8 ret = SCM_BYTEVECTOR_CONTENTS (buf_bv)[cur]; uint8_t ret = SCM_BYTEVECTOR_CONTENTS (buf_bv)[cur];
return ret; return ret;
} }
@ -1596,7 +1596,7 @@ scm_c_read_bytes (SCM port, SCM dst, size_t start, size_t count)
size_t to_read = count; size_t to_read = count;
scm_t_port *pt; scm_t_port *pt;
SCM read_buf; SCM read_buf;
scm_t_uint8 *dst_ptr = (scm_t_uint8 *) SCM_BYTEVECTOR_CONTENTS (dst) + start; uint8_t *dst_ptr = (uint8_t *) SCM_BYTEVECTOR_CONTENTS (dst) + start;
SCM_VALIDATE_OPINPORT (1, port); SCM_VALIDATE_OPINPORT (1, port);
@ -1666,7 +1666,7 @@ scm_c_read (SCM port, void *buffer, size_t size)
size_t copied = 0; size_t copied = 0;
scm_t_port *pt; scm_t_port *pt;
SCM read_buf; SCM read_buf;
scm_t_uint8 *dst = buffer; uint8_t *dst = buffer;
SCM_VALIDATE_OPINPORT (1, port); SCM_VALIDATE_OPINPORT (1, port);
@ -1733,7 +1733,7 @@ update_port_position (SCM position, scm_t_wchar c)
/* Convert the SIZE-byte UTF-8 sequence in UTF8_BUF to a codepoint. /* Convert the SIZE-byte UTF-8 sequence in UTF8_BUF to a codepoint.
UTF8_BUF is assumed to contain a valid UTF-8 sequence. */ UTF8_BUF is assumed to contain a valid UTF-8 sequence. */
static scm_t_wchar static scm_t_wchar
utf8_to_codepoint (const scm_t_uint8 *utf8_buf, size_t size) utf8_to_codepoint (const uint8_t *utf8_buf, size_t size)
{ {
scm_t_wchar codepoint; scm_t_wchar codepoint;
@ -1784,7 +1784,7 @@ peek_utf8_codepoint (SCM port, SCM *buf_out, size_t *cur_out, size_t *len_out)
SCM buf; SCM buf;
size_t cur, avail; size_t cur, avail;
int first_byte; int first_byte;
const scm_t_uint8 *ptr; const uint8_t *ptr;
first_byte = peek_byte_or_eof (port, &buf, &cur); first_byte = peek_byte_or_eof (port, &buf, &cur);
if (first_byte == EOF) if (first_byte == EOF)
@ -1875,7 +1875,7 @@ SCM_DEFINE (scm_port_decode_char, "port-decode-char", 4, 0, 0,
#define FUNC_NAME s_scm_port_decode_char #define FUNC_NAME s_scm_port_decode_char
{ {
char *input, *output; char *input, *output;
scm_t_uint8 utf8_buf[UTF8_BUFFER_SIZE]; uint8_t utf8_buf[UTF8_BUFFER_SIZE];
iconv_t input_cd; iconv_t input_cd;
size_t c_start, c_count; size_t c_start, c_count;
size_t input_left, output_left, done; size_t input_left, output_left, done;
@ -2044,7 +2044,7 @@ SCM_DEFINE (scm_read_char, "read-char", 0, 1, 0,
void void
scm_unget_bytes (const scm_t_uint8 *buf, size_t len, SCM port) scm_unget_bytes (const uint8_t *buf, size_t len, SCM port)
#define FUNC_NAME "scm_unget_bytes" #define FUNC_NAME "scm_unget_bytes"
{ {
scm_t_port *pt = SCM_PORT (port); scm_t_port *pt = SCM_PORT (port);
@ -2068,7 +2068,7 @@ scm_unget_bytes (const scm_t_uint8 *buf, size_t len, SCM port)
{ {
/* But they would fit if we shift the not-yet-read bytes from /* But they would fit if we shift the not-yet-read bytes from
the read_buf right. Let's do that. */ the read_buf right. Let's do that. */
const scm_t_uint8 *to_shift = scm_port_buffer_take_pointer (read_buf, cur); const uint8_t *to_shift = scm_port_buffer_take_pointer (read_buf, cur);
scm_port_buffer_reset_end (read_buf); scm_port_buffer_reset_end (read_buf);
scm_port_buffer_putback (read_buf, to_shift, buffered, size); scm_port_buffer_putback (read_buf, to_shift, buffered, size);
} }
@ -2366,7 +2366,7 @@ scm_take_from_input_buffers (SCM port, char *dest, size_t read_len)
SCM read_buf = SCM_PORT (port)->read_buf; SCM read_buf = SCM_PORT (port)->read_buf;
size_t cur, avail; size_t cur, avail;
avail = scm_port_buffer_can_take (read_buf, &cur); avail = scm_port_buffer_can_take (read_buf, &cur);
return scm_port_buffer_take (read_buf, (scm_t_uint8 *) dest, read_len, return scm_port_buffer_take (read_buf, (uint8_t *) dest, read_len,
cur, avail); cur, avail);
} }
@ -2397,7 +2397,7 @@ SCM_DEFINE (scm_drain_input, "drain-input", 1, 0, 0,
if (avail) if (avail)
{ {
const scm_t_uint8 *ptr = scm_port_buffer_take_pointer (read_buf, cur); const uint8_t *ptr = scm_port_buffer_take_pointer (read_buf, cur);
result = scm_from_port_stringn ((const char *) ptr, avail, port); result = scm_from_port_stringn ((const char *) ptr, avail, port);
scm_port_buffer_did_take (read_buf, cur, avail); scm_port_buffer_did_take (read_buf, cur, avail);
} }
@ -2467,7 +2467,7 @@ static size_t
maybe_consume_bom (SCM port, const unsigned char *bom, size_t bom_len) maybe_consume_bom (SCM port, const unsigned char *bom, size_t bom_len)
{ {
SCM read_buf; SCM read_buf;
const scm_t_uint8 *buf; const uint8_t *buf;
size_t cur, avail; size_t cur, avail;
if (peek_byte_or_eof (port, &read_buf, &cur) != bom[0]) if (peek_byte_or_eof (port, &read_buf, &cur) != bom[0])
@ -2677,7 +2677,7 @@ scm_fill_input (SCM port, size_t minimum_size, size_t *cur_out,
scm_port_buffer_reset (read_buf); scm_port_buffer_reset (read_buf);
else else
{ {
const scm_t_uint8 *to_shift; const uint8_t *to_shift;
to_shift = scm_port_buffer_take_pointer (read_buf, cur); to_shift = scm_port_buffer_take_pointer (read_buf, cur);
scm_port_buffer_reset (read_buf); scm_port_buffer_reset (read_buf);
memmove (scm_port_buffer_put_pointer (read_buf, 0), to_shift, buffered); memmove (scm_port_buffer_put_pointer (read_buf, 0), to_shift, buffered);
@ -2962,7 +2962,7 @@ scm_c_write_bytes (SCM port, SCM src, size_t start, size_t count)
{ {
signed char *src_ptr = SCM_BYTEVECTOR_CONTENTS (src) + start; signed char *src_ptr = SCM_BYTEVECTOR_CONTENTS (src) + start;
scm_port_buffer_put (write_buf, (scm_t_uint8 *) src_ptr, count, scm_port_buffer_put (write_buf, (uint8_t *) src_ptr, count,
end, count); end, count);
} }
@ -2994,7 +2994,7 @@ scm_c_write (SCM port, const void *ptr, size_t size)
SCM write_buf; SCM write_buf;
size_t end, avail, written = 0; size_t end, avail, written = 0;
int using_aux_buffer = 0; int using_aux_buffer = 0;
const scm_t_uint8 *src = ptr; const uint8_t *src = ptr;
SCM_VALIDATE_OPOUTPORT (1, port); SCM_VALIDATE_OPOUTPORT (1, port);
@ -3054,7 +3054,7 @@ scm_c_write (SCM port, const void *ptr, size_t size)
ASCII (so also valid ISO-8859-1 and UTF-8). Return the number of ASCII (so also valid ISO-8859-1 and UTF-8). Return the number of
bytes written. */ bytes written. */
static size_t static size_t
encode_escape_sequence (scm_t_wchar ch, scm_t_uint8 buf[ESCAPE_BUFFER_SIZE]) encode_escape_sequence (scm_t_wchar ch, uint8_t buf[ESCAPE_BUFFER_SIZE])
{ {
/* Represent CH using the in-string escape syntax. */ /* Represent CH using the in-string escape syntax. */
static const char hex[] = "0123456789abcdef"; static const char hex[] = "0123456789abcdef";
@ -3111,7 +3111,7 @@ encode_escape_sequence (scm_t_wchar ch, scm_t_uint8 buf[ESCAPE_BUFFER_SIZE])
void void
scm_c_put_escaped_char (SCM port, scm_t_wchar ch) scm_c_put_escaped_char (SCM port, scm_t_wchar ch)
{ {
scm_t_uint8 escape[ESCAPE_BUFFER_SIZE]; uint8_t escape[ESCAPE_BUFFER_SIZE];
size_t len = encode_escape_sequence (ch, escape); size_t len = encode_escape_sequence (ch, escape);
scm_c_put_latin1_chars (port, escape, len); scm_c_put_latin1_chars (port, escape, len);
} }
@ -3119,7 +3119,7 @@ scm_c_put_escaped_char (SCM port, scm_t_wchar ch)
/* Convert CODEPOINT to UTF-8 and store the result in UTF8. Return the /* Convert CODEPOINT to UTF-8 and store the result in UTF8. Return the
number of bytes of the UTF-8-encoded string. */ number of bytes of the UTF-8-encoded string. */
static size_t static size_t
codepoint_to_utf8 (scm_t_uint32 codepoint, scm_t_uint8 utf8[UTF8_BUFFER_SIZE]) codepoint_to_utf8 (uint32_t codepoint, uint8_t utf8[UTF8_BUFFER_SIZE])
{ {
size_t len; size_t len;
@ -3154,13 +3154,13 @@ codepoint_to_utf8 (scm_t_uint32 codepoint, scm_t_uint8 utf8[UTF8_BUFFER_SIZE])
} }
static size_t static size_t
try_encode_char_to_iconv_buf (SCM port, SCM buf, scm_t_uint32 ch) try_encode_char_to_iconv_buf (SCM port, SCM buf, uint32_t ch)
{ {
scm_t_uint8 utf8[UTF8_BUFFER_SIZE]; uint8_t utf8[UTF8_BUFFER_SIZE];
size_t utf8_len = codepoint_to_utf8 (ch, utf8); size_t utf8_len = codepoint_to_utf8 (ch, utf8);
size_t end; size_t end;
size_t can_put = scm_port_buffer_can_put (buf, &end); size_t can_put = scm_port_buffer_can_put (buf, &end);
scm_t_uint8 *aux = scm_port_buffer_put_pointer (buf, end); uint8_t *aux = scm_port_buffer_put_pointer (buf, end);
iconv_t output_cd; iconv_t output_cd;
int saved_errno; int saved_errno;
@ -3202,7 +3202,7 @@ try_encode_char_to_iconv_buf (SCM port, SCM buf, scm_t_uint32 ch)
if (scm_is_eq (SCM_PORT (port)->conversion_strategy, sym_escape)) if (scm_is_eq (SCM_PORT (port)->conversion_strategy, sym_escape))
{ {
scm_t_uint8 escape[ESCAPE_BUFFER_SIZE]; uint8_t escape[ESCAPE_BUFFER_SIZE];
input = (char *) escape; input = (char *) escape;
input_left = encode_escape_sequence (ch, escape); input_left = encode_escape_sequence (ch, escape);
scm_port_acquire_iconv_descriptors (port, NULL, &output_cd); scm_port_acquire_iconv_descriptors (port, NULL, &output_cd);
@ -3213,7 +3213,7 @@ try_encode_char_to_iconv_buf (SCM port, SCM buf, scm_t_uint32 ch)
} }
else if (scm_is_eq (SCM_PORT (port)->conversion_strategy, sym_substitute)) else if (scm_is_eq (SCM_PORT (port)->conversion_strategy, sym_substitute))
{ {
scm_t_uint8 substitute[2] = "?"; uint8_t substitute[2] = "?";
input = (char *) substitute; input = (char *) substitute;
input_left = 1; input_left = 1;
scm_port_acquire_iconv_descriptors (port, NULL, &output_cd); scm_port_acquire_iconv_descriptors (port, NULL, &output_cd);
@ -3237,7 +3237,7 @@ try_encode_char_to_iconv_buf (SCM port, SCM buf, scm_t_uint32 ch)
static size_t static size_t
encode_latin1_chars_to_latin1_buf (SCM port, SCM buf, encode_latin1_chars_to_latin1_buf (SCM port, SCM buf,
const scm_t_uint8 *chars, size_t count) const uint8_t *chars, size_t count)
{ {
size_t end; size_t end;
size_t avail = scm_port_buffer_can_put (buf, &end); size_t avail = scm_port_buffer_can_put (buf, &end);
@ -3246,11 +3246,11 @@ encode_latin1_chars_to_latin1_buf (SCM port, SCM buf,
static size_t static size_t
encode_latin1_chars_to_utf8_buf (SCM port, SCM buf, encode_latin1_chars_to_utf8_buf (SCM port, SCM buf,
const scm_t_uint8 *chars, size_t count) const uint8_t *chars, size_t count)
{ {
size_t end; size_t end;
size_t buf_size = scm_port_buffer_can_put (buf, &end); size_t buf_size = scm_port_buffer_can_put (buf, &end);
scm_t_uint8 *dst = scm_port_buffer_put_pointer (buf, end); uint8_t *dst = scm_port_buffer_put_pointer (buf, end);
size_t read, written; size_t read, written;
for (read = 0, written = 0; for (read = 0, written = 0;
read < count && written + UTF8_BUFFER_SIZE < buf_size; read < count && written + UTF8_BUFFER_SIZE < buf_size;
@ -3262,7 +3262,7 @@ encode_latin1_chars_to_utf8_buf (SCM port, SCM buf,
static size_t static size_t
encode_latin1_chars_to_iconv_buf (SCM port, SCM buf, encode_latin1_chars_to_iconv_buf (SCM port, SCM buf,
const scm_t_uint8 *chars, size_t count) const uint8_t *chars, size_t count)
{ {
size_t read; size_t read;
for (read = 0; read < count; read++) for (read = 0; read < count; read++)
@ -3272,7 +3272,7 @@ encode_latin1_chars_to_iconv_buf (SCM port, SCM buf,
} }
static size_t static size_t
encode_latin1_chars (SCM port, SCM buf, const scm_t_uint8 *chars, size_t count) encode_latin1_chars (SCM port, SCM buf, const uint8_t *chars, size_t count)
{ {
scm_t_port *pt = SCM_PORT (port); scm_t_port *pt = SCM_PORT (port);
SCM position; SCM position;
@ -3299,23 +3299,23 @@ encode_latin1_chars (SCM port, SCM buf, const scm_t_uint8 *chars, size_t count)
static size_t static size_t
encode_utf32_chars_to_latin1_buf (SCM port, SCM buf, encode_utf32_chars_to_latin1_buf (SCM port, SCM buf,
const scm_t_uint32 *chars, size_t count) const uint32_t *chars, size_t count)
{ {
scm_t_port *pt = SCM_PORT (port); scm_t_port *pt = SCM_PORT (port);
size_t end; size_t end;
size_t buf_size = scm_port_buffer_can_put (buf, &end); size_t buf_size = scm_port_buffer_can_put (buf, &end);
scm_t_uint8 *dst = scm_port_buffer_put_pointer (buf, end); uint8_t *dst = scm_port_buffer_put_pointer (buf, end);
size_t read, written; size_t read, written;
for (read = 0, written = 0; read < count && written < buf_size; read++) for (read = 0, written = 0; read < count && written < buf_size; read++)
{ {
scm_t_uint32 ch = chars[read]; uint32_t ch = chars[read];
if (ch <= 0xff) if (ch <= 0xff)
dst[written++] = ch; dst[written++] = ch;
else if (scm_is_eq (pt->conversion_strategy, sym_substitute)) else if (scm_is_eq (pt->conversion_strategy, sym_substitute))
dst[written++] = '?'; dst[written++] = '?';
else if (scm_is_eq (pt->conversion_strategy, sym_escape)) else if (scm_is_eq (pt->conversion_strategy, sym_escape))
{ {
scm_t_uint8 escape[ESCAPE_BUFFER_SIZE]; uint8_t escape[ESCAPE_BUFFER_SIZE];
size_t escape_len = encode_escape_sequence (ch, escape); size_t escape_len = encode_escape_sequence (ch, escape);
if (escape_len > buf_size - written) if (escape_len > buf_size - written)
break; break;
@ -3330,12 +3330,12 @@ encode_utf32_chars_to_latin1_buf (SCM port, SCM buf,
} }
static size_t static size_t
encode_utf32_chars_to_utf8_buf (SCM port, SCM buf, const scm_t_uint32 *chars, encode_utf32_chars_to_utf8_buf (SCM port, SCM buf, const uint32_t *chars,
size_t count) size_t count)
{ {
size_t end; size_t end;
size_t buf_size = scm_port_buffer_can_put (buf, &end); size_t buf_size = scm_port_buffer_can_put (buf, &end);
scm_t_uint8 *dst = scm_port_buffer_put_pointer (buf, end); uint8_t *dst = scm_port_buffer_put_pointer (buf, end);
size_t read, written; size_t read, written;
for (read = 0, written = 0; for (read = 0, written = 0;
read < count && written + UTF8_BUFFER_SIZE < buf_size; read < count && written + UTF8_BUFFER_SIZE < buf_size;
@ -3346,7 +3346,7 @@ encode_utf32_chars_to_utf8_buf (SCM port, SCM buf, const scm_t_uint32 *chars,
} }
static size_t static size_t
encode_utf32_chars_to_iconv_buf (SCM port, SCM buf, const scm_t_uint32 *chars, encode_utf32_chars_to_iconv_buf (SCM port, SCM buf, const uint32_t *chars,
size_t count) size_t count)
{ {
size_t read; size_t read;
@ -3357,7 +3357,7 @@ encode_utf32_chars_to_iconv_buf (SCM port, SCM buf, const scm_t_uint32 *chars,
} }
static size_t static size_t
encode_utf32_chars (SCM port, SCM buf, const scm_t_uint32 *chars, size_t count) encode_utf32_chars (SCM port, SCM buf, const uint32_t *chars, size_t count)
{ {
scm_t_port *pt = SCM_PORT (port); scm_t_port *pt = SCM_PORT (port);
SCM position; SCM position;
@ -3392,14 +3392,14 @@ port_encode_chars (SCM port, SCM buf, SCM str, size_t start, size_t count)
{ {
const char *chars = scm_i_string_chars (str); const char *chars = scm_i_string_chars (str);
return encode_latin1_chars (port, buf, return encode_latin1_chars (port, buf,
((const scm_t_uint8 *) chars) + start, ((const uint8_t *) chars) + start,
count); count);
} }
else else
{ {
const scm_t_wchar *chars = scm_i_string_wide_chars (str); const scm_t_wchar *chars = scm_i_string_wide_chars (str);
return encode_utf32_chars (port, buf, return encode_utf32_chars (port, buf,
((const scm_t_uint32 *) chars) + start, ((const uint32_t *) chars) + start,
count); count);
} }
} }
@ -3433,7 +3433,7 @@ SCM_DEFINE (scm_port_encode_char, "port-encode-char", 3, 0, 0,
"") "")
#define FUNC_NAME s_scm_port_encode_char #define FUNC_NAME s_scm_port_encode_char
{ {
scm_t_uint32 codepoint; uint32_t codepoint;
SCM_VALIDATE_OPOUTPORT (1, port); SCM_VALIDATE_OPOUTPORT (1, port);
SCM_VALIDATE_VECTOR (2, buf); SCM_VALIDATE_VECTOR (2, buf);
@ -3447,7 +3447,7 @@ SCM_DEFINE (scm_port_encode_char, "port-encode-char", 3, 0, 0,
#undef FUNC_NAME #undef FUNC_NAME
void void
scm_c_put_latin1_chars (SCM port, const scm_t_uint8 *chars, size_t len) scm_c_put_latin1_chars (SCM port, const uint8_t *chars, size_t len)
{ {
SCM aux_buf = scm_port_auxiliary_write_buffer (port); SCM aux_buf = scm_port_auxiliary_write_buffer (port);
SCM aux_bv = scm_port_buffer_bytevector (aux_buf); SCM aux_bv = scm_port_buffer_bytevector (aux_buf);
@ -3474,7 +3474,7 @@ scm_c_put_latin1_chars (SCM port, const scm_t_uint8 *chars, size_t len)
} }
void void
scm_c_put_utf32_chars (SCM port, const scm_t_uint32 *chars, size_t len) scm_c_put_utf32_chars (SCM port, const uint32_t *chars, size_t len)
{ {
SCM aux_buf = scm_port_auxiliary_write_buffer (port); SCM aux_buf = scm_port_auxiliary_write_buffer (port);
SCM aux_bv = scm_port_buffer_bytevector (aux_buf); SCM aux_bv = scm_port_buffer_bytevector (aux_buf);
@ -3505,12 +3505,12 @@ scm_c_put_char (SCM port, scm_t_wchar ch)
{ {
if (ch <= 0xff) if (ch <= 0xff)
{ {
scm_t_uint8 narrow_ch = ch; uint8_t narrow_ch = ch;
scm_c_put_latin1_chars (port, &narrow_ch, 1); scm_c_put_latin1_chars (port, &narrow_ch, 1);
} }
else else
{ {
scm_t_uint32 wide_ch = ch; uint32_t wide_ch = ch;
scm_c_put_utf32_chars (port, &wide_ch, 1); scm_c_put_utf32_chars (port, &wide_ch, 1);
} }
} }
@ -3534,7 +3534,7 @@ scm_c_can_put_char (SCM port, scm_t_wchar ch)
{ {
SCM bv = scm_port_buffer_bytevector (scm_port_auxiliary_write_buffer (port)); SCM bv = scm_port_buffer_bytevector (scm_port_auxiliary_write_buffer (port));
scm_t_uint8 buf[UTF8_BUFFER_SIZE]; uint8_t buf[UTF8_BUFFER_SIZE];
char *input = (char *) buf; char *input = (char *) buf;
size_t input_len; size_t input_len;
char *output = (char *) SCM_BYTEVECTOR_CONTENTS (bv); char *output = (char *) SCM_BYTEVECTOR_CONTENTS (bv);
@ -3560,12 +3560,12 @@ scm_c_put_string (SCM port, SCM string, size_t start, size_t count)
if (scm_i_is_narrow_string (string)) if (scm_i_is_narrow_string (string))
{ {
const char *ptr = scm_i_string_chars (string); const char *ptr = scm_i_string_chars (string);
scm_c_put_latin1_chars (port, ((const scm_t_uint8 *) ptr) + start, count); scm_c_put_latin1_chars (port, ((const uint8_t *) ptr) + start, count);
} }
else else
{ {
const scm_t_wchar *ptr = scm_i_string_wide_chars (string); const scm_t_wchar *ptr = scm_i_string_wide_chars (string);
scm_c_put_utf32_chars (port, ((const scm_t_uint32 *) ptr) + start, count); scm_c_put_utf32_chars (port, ((const uint32_t *) ptr) + start, count);
} }
} }
@ -3614,14 +3614,14 @@ void
scm_putc (char c, SCM port) scm_putc (char c, SCM port)
{ {
SCM_ASSERT_TYPE (SCM_OPOUTPORTP (port), port, 0, NULL, "output port"); SCM_ASSERT_TYPE (SCM_OPOUTPORTP (port), port, 0, NULL, "output port");
scm_c_put_char (port, (scm_t_uint8) c); scm_c_put_char (port, (uint8_t) c);
} }
void void
scm_puts (const char *s, SCM port) scm_puts (const char *s, SCM port)
{ {
SCM_ASSERT_TYPE (SCM_OPOUTPORTP (port), port, 0, NULL, "output port"); SCM_ASSERT_TYPE (SCM_OPOUTPORTP (port), port, 0, NULL, "output port");
scm_c_put_latin1_chars (port, (const scm_t_uint8 *) s, strlen (s)); scm_c_put_latin1_chars (port, (const uint8_t *) s, strlen (s));
} }
/* scm_lfwrite /* scm_lfwrite
@ -3631,7 +3631,7 @@ scm_puts (const char *s, SCM port)
void void
scm_lfwrite (const char *ptr, size_t size, SCM port) scm_lfwrite (const char *ptr, size_t size, SCM port)
{ {
scm_c_put_latin1_chars (port, (const scm_t_uint8 *) ptr, size); scm_c_put_latin1_chars (port, (const uint8_t *) ptr, size);
} }
/* Write STR to PORT from START inclusive to END exclusive. */ /* Write STR to PORT from START inclusive to END exclusive. */

4
libguile/ports.h
View file

@ -232,9 +232,9 @@ SCM_INTERNAL SCM scm_port_auxiliary_write_buffer (SCM port);
/* Output. */ /* Output. */
SCM_API void scm_c_write (SCM port, const void *buffer, size_t size); SCM_API void scm_c_write (SCM port, const void *buffer, size_t size);
SCM_API void scm_c_write_bytes (SCM port, SCM src, size_t start, size_t count); SCM_API void scm_c_write_bytes (SCM port, SCM src, size_t start, size_t count);
SCM_API void scm_c_put_latin1_chars (SCM port, const scm_t_uint8 *buf, SCM_API void scm_c_put_latin1_chars (SCM port, const uint8_t *buf,
size_t len); size_t len);
SCM_API void scm_c_put_utf32_chars (SCM port, const scm_t_uint32 *buf, SCM_API void scm_c_put_utf32_chars (SCM port, const uint32_t *buf,
size_t len); size_t len);
SCM_API void scm_c_put_string (SCM port, SCM str, size_t start, size_t count); SCM_API void scm_c_put_string (SCM port, SCM str, size_t start, size_t count);
SCM_API SCM scm_put_string (SCM port, SCM str, SCM start, SCM count); SCM_API SCM scm_put_string (SCM port, SCM str, SCM start, SCM count);

6
libguile/posix.c
View file

@ -1493,11 +1493,11 @@ SCM_DEFINE (scm_system_star, "system*", 0, 0, 1,
scm_dynwind_begin (0); scm_dynwind_begin (0);
/* Make sure the child can't kill us (as per normal system call). */ /* Make sure the child can't kill us (as per normal system call). */
scm_dynwind_sigaction (SIGINT, scm_dynwind_sigaction (SIGINT,
scm_from_uintptr_t ((scm_t_uintptr) SIG_IGN), scm_from_uintptr_t ((uintptr_t) SIG_IGN),
SCM_UNDEFINED); SCM_UNDEFINED);
#ifdef SIGQUIT #ifdef SIGQUIT
scm_dynwind_sigaction (SIGQUIT, scm_dynwind_sigaction (SIGQUIT,
scm_from_uintptr_t ((scm_t_uintptr) SIG_IGN), scm_from_uintptr_t ((uintptr_t) SIG_IGN),
SCM_UNDEFINED); SCM_UNDEFINED);
#endif #endif
@ -2113,7 +2113,7 @@ SCM_DEFINE (scm_setaffinity, "setaffinity", 2, 0, 0,
{ {
cpu_set_t cs; cpu_set_t cs;
scm_t_array_handle handle; scm_t_array_handle handle;
const scm_t_uint32 *c_mask; const uint32_t *c_mask;
size_t len, off, cpu; size_t len, off, cpu;
ssize_t inc; ssize_t inc;
int err; int err;

18
libguile/print.c
View file

@ -437,12 +437,12 @@ print_normal_symbol (SCM sym, SCM port)
if (scm_i_is_narrow_symbol (sym)) if (scm_i_is_narrow_symbol (sym))
{ {
const char *ptr = scm_i_symbol_chars (sym); const char *ptr = scm_i_symbol_chars (sym);
scm_c_put_latin1_chars (port, (const scm_t_uint8 *) ptr, len); scm_c_put_latin1_chars (port, (const uint8_t *) ptr, len);
} }
else else
{ {
const scm_t_wchar *ptr = scm_i_symbol_wide_chars (sym); const scm_t_wchar *ptr = scm_i_symbol_wide_chars (sym);
scm_c_put_utf32_chars (port, (const scm_t_uint32 *) ptr, len); scm_c_put_utf32_chars (port, (const uint32_t *) ptr, len);
} }
} }
@ -848,7 +848,7 @@ write_string (const void *str, int narrow_p, size_t len, SCM port)
{ {
size_t i; size_t i;
scm_c_put_char (port, (scm_t_uint8) '"'); scm_c_put_char (port, (uint8_t) '"');
for (i = 0; i < len; ++i) for (i = 0; i < len; ++i)
{ {
@ -862,11 +862,11 @@ write_string (const void *str, int narrow_p, size_t len, SCM port)
representable in PORT's encoding. If CH needs to be escaped, representable in PORT's encoding. If CH needs to be escaped,
it is escaped using the in-string escape syntax. */ it is escaped using the in-string escape syntax. */
if (ch == '"') if (ch == '"')
scm_c_put_latin1_chars (port, (const scm_t_uint8 *) "\\\"", 2); scm_c_put_latin1_chars (port, (const uint8_t *) "\\\"", 2);
else if (ch == '\\') else if (ch == '\\')
scm_c_put_latin1_chars (port, (const scm_t_uint8 *) "\\\\", 2); scm_c_put_latin1_chars (port, (const uint8_t *) "\\\\", 2);
else if (ch == '\n' && SCM_PRINT_ESCAPE_NEWLINES_P) else if (ch == '\n' && SCM_PRINT_ESCAPE_NEWLINES_P)
scm_c_put_latin1_chars (port, (const scm_t_uint8 *) "\\n", 2); scm_c_put_latin1_chars (port, (const uint8_t *) "\\n", 2);
else if (ch == ' ' || ch == '\n' else if (ch == ' ' || ch == '\n'
|| (uc_is_general_category_withtable (ch, || (uc_is_general_category_withtable (ch,
UC_CATEGORY_MASK_L | UC_CATEGORY_MASK_L |
@ -880,7 +880,7 @@ write_string (const void *str, int narrow_p, size_t len, SCM port)
scm_c_put_escaped_char (port, ch); scm_c_put_escaped_char (port, ch);
} }
scm_c_put_char (port, (scm_t_uint8) '"'); scm_c_put_char (port, (uint8_t) '"');
} }
/* Write CH to PORT, escaping it if it's non-graphic or not /* Write CH to PORT, escaping it if it's non-graphic or not
@ -933,14 +933,14 @@ write_character (scm_t_wchar ch, SCM port)
*/ */
void void
scm_intprint (scm_t_intmax n, int radix, SCM port) scm_intprint (intmax_t n, int radix, SCM port)
{ {
char num_buf[SCM_INTBUFLEN]; char num_buf[SCM_INTBUFLEN];
scm_lfwrite (num_buf, scm_iint2str (n, radix, num_buf), port); scm_lfwrite (num_buf, scm_iint2str (n, radix, num_buf), port);
} }
void void
scm_uintprint (scm_t_uintmax n, int radix, SCM port) scm_uintprint (uintmax_t n, int radix, SCM port)
{ {
char num_buf[SCM_INTBUFLEN]; char num_buf[SCM_INTBUFLEN];
scm_lfwrite (num_buf, scm_iuint2str (n, radix, num_buf), port); scm_lfwrite (num_buf, scm_iuint2str (n, radix, num_buf), port);

4
libguile/print.h
View file

@ -86,8 +86,8 @@ SCM_API SCM scm_print_options (SCM setting);
SCM_API SCM scm_make_print_state (void); SCM_API SCM scm_make_print_state (void);
SCM_API void scm_free_print_state (SCM print_state); SCM_API void scm_free_print_state (SCM print_state);
SCM_INTERNAL SCM scm_i_port_with_print_state (SCM port, SCM print_state); SCM_INTERNAL SCM scm_i_port_with_print_state (SCM port, SCM print_state);
SCM_API void scm_intprint (scm_t_intmax n, int radix, SCM port); SCM_API void scm_intprint (intmax_t n, int radix, SCM port);
SCM_API void scm_uintprint (scm_t_uintmax n, int radix, SCM port); SCM_API void scm_uintprint (uintmax_t n, int radix, SCM port);
SCM_API void scm_ipruk (char *hdr, SCM ptr, SCM port); SCM_API void scm_ipruk (char *hdr, SCM ptr, SCM port);
SCM_API void scm_iprlist (char *hdr, SCM exp, int tlr, SCM port, scm_print_state *pstate); SCM_API void scm_iprlist (char *hdr, SCM exp, int tlr, SCM port, scm_print_state *pstate);
SCM_API void scm_print_symbol_name (const char *str, size_t len, SCM port); SCM_API void scm_print_symbol_name (const char *str, size_t len, SCM port);

10
libguile/programs.c
View file

@ -49,7 +49,7 @@ SCM_DEFINE (scm_program_code, "program-code", 1, 0, 0,
{ {
SCM_VALIDATE_PROGRAM (1, program); SCM_VALIDATE_PROGRAM (1, program);
return scm_from_uintptr_t ((scm_t_uintptr) SCM_PROGRAM_CODE (program)); return scm_from_uintptr_t ((uintptr_t) SCM_PROGRAM_CODE (program));
} }
#undef FUNC_NAME #undef FUNC_NAME
@ -131,7 +131,7 @@ scm_i_program_print (SCM program, SCM port, scm_print_state *pstate)
scm_puts ("#<program ", port); scm_puts ("#<program ", port);
scm_uintprint (SCM_UNPACK (program), 16, port); scm_uintprint (SCM_UNPACK (program), 16, port);
scm_putc (' ', port); scm_putc (' ', port);
scm_uintprint ((scm_t_uintptr) SCM_PROGRAM_CODE (program), 16, port); scm_uintprint ((uintptr_t) SCM_PROGRAM_CODE (program), 16, port);
scm_putc ('>', port); scm_putc ('>', port);
} }
else else
@ -161,7 +161,7 @@ SCM_DEFINE (scm_primitive_code_p, "primitive-code?", 1, 0, 0,
"") "")
#define FUNC_NAME s_scm_primitive_code_p #define FUNC_NAME s_scm_primitive_code_p
{ {
const scm_t_uint32 * ptr = (const scm_t_uint32 *) scm_to_uintptr_t (code); const uint32_t * ptr = (const uint32_t *) scm_to_uintptr_t (code);
return scm_from_bool (scm_i_primitive_code_p (ptr)); return scm_from_bool (scm_i_primitive_code_p (ptr));
} }
@ -252,8 +252,8 @@ SCM_DEFINE (scm_program_free_variable_set_x, "program-free-variable-set!", 3, 0,
static int static int
try_parse_arity (SCM program, int *req, int *opt, int *rest) try_parse_arity (SCM program, int *req, int *opt, int *rest)
{ {
scm_t_uint32 *code = SCM_PROGRAM_CODE (program); uint32_t *code = SCM_PROGRAM_CODE (program);
scm_t_uint32 slots, min; uint32_t slots, min;
switch (code[0] & 0xff) { switch (code[0] & 0xff) {
case scm_op_assert_nargs_ee: case scm_op_assert_nargs_ee:

4
libguile/programs.h
View file

@ -27,7 +27,7 @@
*/ */
#define SCM_PROGRAM_P(x) (SCM_HAS_TYP7 (x, scm_tc7_program)) #define SCM_PROGRAM_P(x) (SCM_HAS_TYP7 (x, scm_tc7_program))
#define SCM_PROGRAM_CODE(x) ((scm_t_uint32 *) SCM_CELL_WORD_1 (x)) #define SCM_PROGRAM_CODE(x) ((uint32_t *) SCM_CELL_WORD_1 (x))
#define SCM_PROGRAM_FREE_VARIABLES(x) (SCM_CELL_OBJECT_LOC (x, 2)) #define SCM_PROGRAM_FREE_VARIABLES(x) (SCM_CELL_OBJECT_LOC (x, 2))
#define SCM_PROGRAM_FREE_VARIABLE_REF(x,i) (SCM_PROGRAM_FREE_VARIABLES (x)[i]) #define SCM_PROGRAM_FREE_VARIABLE_REF(x,i) (SCM_PROGRAM_FREE_VARIABLES (x)[i])
#define SCM_PROGRAM_FREE_VARIABLE_SET(x,i,v) (SCM_PROGRAM_FREE_VARIABLES (x)[i]=(v)) #define SCM_PROGRAM_FREE_VARIABLE_SET(x,i,v) (SCM_PROGRAM_FREE_VARIABLES (x)[i]=(v))
@ -50,7 +50,7 @@
#ifdef BUILDING_LIBGUILE #ifdef BUILDING_LIBGUILE
static inline SCM static inline SCM
scm_i_make_program (const scm_t_uint32 *code) scm_i_make_program (const uint32_t *code)
{ {
return scm_cell (scm_tc7_program, (scm_t_bits)code); return scm_cell (scm_tc7_program, (scm_t_bits)code);
} }

6
libguile/r6rs-ports.c
View file

@ -399,7 +399,7 @@ SCM_DEFINE (scm_lookahead_u8, "lookahead-u8", 1, 0, 0,
if (u8 == EOF) if (u8 == EOF)
result = SCM_EOF_VAL; result = SCM_EOF_VAL;
else else
result = SCM_I_MAKINUM ((scm_t_uint8) u8); result = SCM_I_MAKINUM ((uint8_t) u8);
return result; return result;
} }
@ -501,7 +501,7 @@ SCM_DEFINE (scm_get_bytevector_some, "get-bytevector-some", 1, 0, 0,
} }
bv = scm_c_make_bytevector (avail); bv = scm_c_make_bytevector (avail);
scm_port_buffer_take (buf, (scm_t_uint8 *) SCM_BYTEVECTOR_CONTENTS (bv), scm_port_buffer_take (buf, (uint8_t *) SCM_BYTEVECTOR_CONTENTS (bv),
avail, cur, avail); avail, cur, avail);
return bv; return bv;
@ -571,7 +571,7 @@ SCM_DEFINE (scm_put_u8, "put-u8", 2, 0, 0,
"Write @var{octet} to binary port @var{port}.") "Write @var{octet} to binary port @var{port}.")
#define FUNC_NAME s_scm_put_u8 #define FUNC_NAME s_scm_put_u8
{ {
scm_t_uint8 c_octet; uint8_t c_octet;
SCM_VALIDATE_BINARY_OUTPUT_PORT (1, port); SCM_VALIDATE_BINARY_OUTPUT_PORT (1, port);
c_octet = scm_to_uint8 (octet); c_octet = scm_to_uint8 (octet);

76
libguile/random.c
View file

@ -85,8 +85,8 @@ scm_t_rng scm_the_rng;
typedef struct scm_t_i_rstate { typedef struct scm_t_i_rstate {
scm_t_rstate rstate; scm_t_rstate rstate;
scm_t_uint32 w; uint32_t w;
scm_t_uint32 c; uint32_t c;
} scm_t_i_rstate; } scm_t_i_rstate;
@ -96,12 +96,12 @@ typedef struct scm_t_i_rstate {
#define M_PI 3.14159265359 #define M_PI 3.14159265359
#endif #endif
static scm_t_uint32 static uint32_t
scm_i_uniform32 (scm_t_rstate *state) scm_i_uniform32 (scm_t_rstate *state)
{ {
scm_t_i_rstate *istate = (scm_t_i_rstate*) state; scm_t_i_rstate *istate = (scm_t_i_rstate*) state;
scm_t_uint64 x = (scm_t_uint64) A * istate->w + istate->c; uint64_t x = (uint64_t) A * istate->w + istate->c;
scm_t_uint32 w = x & 0xffffffffUL; uint32_t w = x & 0xffffffffUL;
istate->w = w; istate->w = w;
istate->c = x >> 32L; istate->c = x >> 32L;
return w; return w;
@ -111,8 +111,8 @@ static void
scm_i_init_rstate (scm_t_rstate *state, const char *seed, int n) scm_i_init_rstate (scm_t_rstate *state, const char *seed, int n)
{ {
scm_t_i_rstate *istate = (scm_t_i_rstate*) state; scm_t_i_rstate *istate = (scm_t_i_rstate*) state;
scm_t_uint32 w = 0L; uint32_t w = 0L;
scm_t_uint32 c = 0L; uint32_t c = 0L;
int i, m; int i, m;
for (i = 0; i < n; ++i) for (i = 0; i < n; ++i)
{ {
@ -145,7 +145,7 @@ scm_i_rstate_from_datum (scm_t_rstate *state, SCM value)
#define FUNC_NAME "scm_i_rstate_from_datum" #define FUNC_NAME "scm_i_rstate_from_datum"
{ {
scm_t_i_rstate *istate = (scm_t_i_rstate*) state; scm_t_i_rstate *istate = (scm_t_i_rstate*) state;
scm_t_uint32 w, c; uint32_t w, c;
long length; long length;
SCM_VALIDATE_LIST_COPYLEN (SCM_ARG1, value, length); SCM_VALIDATE_LIST_COPYLEN (SCM_ARG1, value, length);
@ -253,8 +253,8 @@ scm_c_exp1 (scm_t_rstate *state)
unsigned char scm_masktab[256]; unsigned char scm_masktab[256];
static inline scm_t_uint32 static inline uint32_t
scm_i_mask32 (scm_t_uint32 m) scm_i_mask32 (uint32_t m)
{ {
return (m < 0x100 return (m < 0x100
? scm_masktab[m] ? scm_masktab[m]
@ -262,28 +262,28 @@ scm_i_mask32 (scm_t_uint32 m)
? scm_masktab[m >> 8] << 8 | 0xff ? scm_masktab[m >> 8] << 8 | 0xff
: (m < 0x1000000 : (m < 0x1000000
? scm_masktab[m >> 16] << 16 | 0xffff ? scm_masktab[m >> 16] << 16 | 0xffff
: ((scm_t_uint32) scm_masktab[m >> 24]) << 24 | 0xffffff))); : ((uint32_t) scm_masktab[m >> 24]) << 24 | 0xffffff)));
} }
scm_t_uint32 uint32_t
scm_c_random (scm_t_rstate *state, scm_t_uint32 m) scm_c_random (scm_t_rstate *state, uint32_t m)
{ {
scm_t_uint32 r, mask = scm_i_mask32 (m); uint32_t r, mask = scm_i_mask32 (m);
while ((r = state->rng->random_bits (state) & mask) >= m); while ((r = state->rng->random_bits (state) & mask) >= m);
return r; return r;
} }
scm_t_uint64 uint64_t
scm_c_random64 (scm_t_rstate *state, scm_t_uint64 m) scm_c_random64 (scm_t_rstate *state, uint64_t m)
{ {
scm_t_uint64 r; uint64_t r;
scm_t_uint32 mask; uint32_t mask;
if (m <= UINT32_MAX) if (m <= UINT32_MAX)
return scm_c_random (state, (scm_t_uint32) m); return scm_c_random (state, (uint32_t) m);
mask = scm_i_mask32 (m >> 32); mask = scm_i_mask32 (m >> 32);
while ((r = ((scm_t_uint64) (state->rng->random_bits (state) & mask) << 32) while ((r = ((uint64_t) (state->rng->random_bits (state) & mask) << 32)
| state->rng->random_bits (state)) >= m) | state->rng->random_bits (state)) >= m)
; ;
return r; return r;
@ -309,24 +309,24 @@ scm_c_random_bignum (scm_t_rstate *state, SCM m)
{ {
SCM result = scm_i_mkbig (); SCM result = scm_i_mkbig ();
const size_t m_bits = mpz_sizeinbase (SCM_I_BIG_MPZ (m), 2); const size_t m_bits = mpz_sizeinbase (SCM_I_BIG_MPZ (m), 2);
/* how many bits would only partially fill the last scm_t_uint32? */ /* how many bits would only partially fill the last uint32_t? */
const size_t end_bits = m_bits % (sizeof (scm_t_uint32) * SCM_CHAR_BIT); const size_t end_bits = m_bits % (sizeof (uint32_t) * SCM_CHAR_BIT);
scm_t_uint32 *random_chunks = NULL; uint32_t *random_chunks = NULL;
const scm_t_uint32 num_full_chunks = const uint32_t num_full_chunks =
m_bits / (sizeof (scm_t_uint32) * SCM_CHAR_BIT); m_bits / (sizeof (uint32_t) * SCM_CHAR_BIT);
const scm_t_uint32 num_chunks = num_full_chunks + ((end_bits) ? 1 : 0); const uint32_t num_chunks = num_full_chunks + ((end_bits) ? 1 : 0);
/* we know the result will be this big */ /* we know the result will be this big */
mpz_realloc2 (SCM_I_BIG_MPZ (result), m_bits); mpz_realloc2 (SCM_I_BIG_MPZ (result), m_bits);
random_chunks = random_chunks =
(scm_t_uint32 *) scm_gc_calloc (num_chunks * sizeof (scm_t_uint32), (uint32_t *) scm_gc_calloc (num_chunks * sizeof (uint32_t),
"random bignum chunks"); "random bignum chunks");
do do
{ {
scm_t_uint32 *current_chunk = random_chunks + (num_chunks - 1); uint32_t *current_chunk = random_chunks + (num_chunks - 1);
scm_t_uint32 chunks_left = num_chunks; uint32_t chunks_left = num_chunks;
mpz_set_ui (SCM_I_BIG_MPZ (result), 0); mpz_set_ui (SCM_I_BIG_MPZ (result), 0);
@ -334,24 +334,24 @@ scm_c_random_bignum (scm_t_rstate *state, SCM m)
{ {
/* generate a mask with ones in the end_bits position, i.e. if /* generate a mask with ones in the end_bits position, i.e. if
end_bits is 3, then we'd have a mask of ...0000000111 */ end_bits is 3, then we'd have a mask of ...0000000111 */
const scm_t_uint32 rndbits = state->rng->random_bits (state); const uint32_t rndbits = state->rng->random_bits (state);
int rshift = (sizeof (scm_t_uint32) * SCM_CHAR_BIT) - end_bits; int rshift = (sizeof (uint32_t) * SCM_CHAR_BIT) - end_bits;
scm_t_uint32 mask = ((scm_t_uint32)-1) >> rshift; uint32_t mask = ((uint32_t)-1) >> rshift;
scm_t_uint32 highest_bits = rndbits & mask; uint32_t highest_bits = rndbits & mask;
*current_chunk-- = highest_bits; *current_chunk-- = highest_bits;
chunks_left--; chunks_left--;
} }
while (chunks_left) while (chunks_left)
{ {
/* now fill in the remaining scm_t_uint32 sized chunks */ /* now fill in the remaining uint32_t sized chunks */
*current_chunk-- = state->rng->random_bits (state); *current_chunk-- = state->rng->random_bits (state);
chunks_left--; chunks_left--;
} }
mpz_import (SCM_I_BIG_MPZ (result), mpz_import (SCM_I_BIG_MPZ (result),
num_chunks, num_chunks,
-1, -1,
sizeof (scm_t_uint32), sizeof (uint32_t),
0, 0,
0, 0,
random_chunks); random_chunks);
@ -359,7 +359,7 @@ scm_c_random_bignum (scm_t_rstate *state, SCM m)
all bits in order not to get a distorted distribution) */ all bits in order not to get a distorted distribution) */
} while (mpz_cmp (SCM_I_BIG_MPZ (result), SCM_I_BIG_MPZ (m)) >= 0); } while (mpz_cmp (SCM_I_BIG_MPZ (result), SCM_I_BIG_MPZ (m)) >= 0);
scm_gc_free (random_chunks, scm_gc_free (random_chunks,
num_chunks * sizeof (scm_t_uint32), num_chunks * sizeof (uint32_t),
"random bignum chunks"); "random bignum chunks");
return scm_i_normbig (result); return scm_i_normbig (result);
} }
@ -408,10 +408,10 @@ SCM_DEFINE (scm_random, "random", 1, 1, 0,
SCM_ASSERT_RANGE (1, n, SCM_I_INUM (n) > 0); SCM_ASSERT_RANGE (1, n, SCM_I_INUM (n) > 0);
#if SCM_SIZEOF_UINTPTR_T <= 4 #if SCM_SIZEOF_UINTPTR_T <= 4
return scm_from_uint32 (scm_c_random (SCM_RSTATE (state), return scm_from_uint32 (scm_c_random (SCM_RSTATE (state),
(scm_t_uint32) m)); (uint32_t) m));
#elif SCM_SIZEOF_UINTPTR_T <= 8 #elif SCM_SIZEOF_UINTPTR_T <= 8
return scm_from_uint64 (scm_c_random64 (SCM_RSTATE (state), return scm_from_uint64 (scm_c_random64 (SCM_RSTATE (state),
(scm_t_uint64) m)); (uint64_t) m));
#else #else
#error "Cannot deal with this platform's scm_t_bits size" #error "Cannot deal with this platform's scm_t_bits size"
#endif #endif

6
libguile/random.h
View file

@ -45,7 +45,7 @@ typedef struct scm_t_rstate {
typedef struct scm_t_rng { typedef struct scm_t_rng {
size_t rstate_size; /* size of random state */ size_t rstate_size; /* size of random state */
scm_t_uint32 (*random_bits) (scm_t_rstate *state); /* gives 32 random bits */ uint32_t (*random_bits) (scm_t_rstate *state); /* gives 32 random bits */
void (*init_rstate) (scm_t_rstate *state, const char *seed, int n); void (*init_rstate) (scm_t_rstate *state, const char *seed, int n);
scm_t_rstate *(*copy_rstate) (scm_t_rstate *state); scm_t_rstate *(*copy_rstate) (scm_t_rstate *state);
void (*from_datum) (scm_t_rstate *state, SCM datum); void (*from_datum) (scm_t_rstate *state, SCM datum);
@ -65,8 +65,8 @@ SCM_API scm_t_rstate *scm_c_default_rstate (void);
SCM_API double scm_c_uniform01 (scm_t_rstate *); SCM_API double scm_c_uniform01 (scm_t_rstate *);
SCM_API double scm_c_normal01 (scm_t_rstate *); SCM_API double scm_c_normal01 (scm_t_rstate *);
SCM_API double scm_c_exp1 (scm_t_rstate *); SCM_API double scm_c_exp1 (scm_t_rstate *);
SCM_API scm_t_uint32 scm_c_random (scm_t_rstate *, scm_t_uint32 m); SCM_API uint32_t scm_c_random (scm_t_rstate *, uint32_t m);
SCM_API scm_t_uint64 scm_c_random64 (scm_t_rstate *state, scm_t_uint64 m); SCM_API uint64_t scm_c_random64 (scm_t_rstate *state, uint64_t m);
SCM_API SCM scm_c_random_bignum (scm_t_rstate *, SCM m); SCM_API SCM scm_c_random_bignum (scm_t_rstate *, SCM m);

6
libguile/scm.h
View file

@ -138,8 +138,8 @@
/* For dealing with the bit level representation of scheme objects we /* For dealing with the bit level representation of scheme objects we
define scm_t_bits. */ define scm_t_bits. */
typedef scm_t_intptr scm_t_signed_bits; typedef intptr_t scm_t_signed_bits;
typedef scm_t_uintptr scm_t_bits; typedef uintptr_t scm_t_bits;
#define SCM_T_SIGNED_BITS_MAX INTPTR_MAX #define SCM_T_SIGNED_BITS_MAX INTPTR_MAX
#define SCM_T_SIGNED_BITS_MIN INTPTR_MIN #define SCM_T_SIGNED_BITS_MIN INTPTR_MIN
@ -823,7 +823,7 @@ typedef void *scm_t_subr;
typedef struct scm_dynamic_state scm_t_dynamic_state; typedef struct scm_dynamic_state scm_t_dynamic_state;
typedef struct scm_print_state scm_print_state; typedef struct scm_print_state scm_print_state;
typedef struct scm_dynstack scm_t_dynstack; typedef struct scm_dynstack scm_t_dynstack;
typedef scm_t_int32 scm_t_wchar; typedef int32_t scm_t_wchar;

18
libguile/socket.c
View file

@ -163,7 +163,7 @@ SCM_DEFINE (scm_inet_makeaddr, "inet-makeaddr", 2, 0, 0,
\ \
for (i = 0; i < 8; i++)\ for (i = 0; i < 8; i++)\
{\ {\
scm_t_uint8 c = (addr)[i];\ uint8_t c = (addr)[i];\
\ \
(addr)[i] = (addr)[15 - i];\ (addr)[i] = (addr)[15 - i];\
(addr)[15 - i] = c;\ (addr)[15 - i] = c;\
@ -176,8 +176,8 @@ SCM_DEFINE (scm_inet_makeaddr, "inet-makeaddr", 2, 0, 0,
#else #else
#define FLIPCPY_NET_HOST_128(dest, src) \ #define FLIPCPY_NET_HOST_128(dest, src) \
{ \ { \
const scm_t_uint8 *tmp_srcp = (src) + 15; \ const uint8_t *tmp_srcp = (src) + 15; \
scm_t_uint8 *tmp_destp = (dest); \ uint8_t *tmp_destp = (dest); \
\ \
do { \ do { \
*tmp_destp++ = *tmp_srcp--; \ *tmp_destp++ = *tmp_srcp--; \
@ -201,7 +201,7 @@ SCM_DEFINE (scm_inet_makeaddr, "inet-makeaddr", 2, 0, 0,
/* convert a 128 bit IPv6 address in network order to a host ordered /* convert a 128 bit IPv6 address in network order to a host ordered
SCM integer. */ SCM integer. */
static SCM static SCM
scm_from_ipv6 (const scm_t_uint8 *src) scm_from_ipv6 (const uint8_t *src)
{ {
SCM result = scm_i_mkbig (); SCM result = scm_i_mkbig ();
mpz_import (SCM_I_BIG_MPZ (result), mpz_import (SCM_I_BIG_MPZ (result),
@ -217,7 +217,7 @@ scm_from_ipv6 (const scm_t_uint8 *src)
/* convert a host ordered SCM integer to a 128 bit IPv6 address in /* convert a host ordered SCM integer to a 128 bit IPv6 address in
network order. */ network order. */
static void static void
scm_to_ipv6 (scm_t_uint8 dst[16], SCM src) scm_to_ipv6 (uint8_t dst[16], SCM src)
{ {
if (SCM_I_INUMP (src)) if (SCM_I_INUMP (src))
{ {
@ -295,7 +295,7 @@ SCM_DEFINE (scm_inet_ntop, "inet-ntop", 2, 0, 0,
); );
if (af == AF_INET) if (af == AF_INET)
{ {
scm_t_uint32 addr4; uint32_t addr4;
addr4 = htonl (SCM_NUM2ULONG (2, address)); addr4 = htonl (SCM_NUM2ULONG (2, address));
result = inet_ntop (af, &addr4, dst, sizeof (dst)); result = inet_ntop (af, &addr4, dst, sizeof (dst));
@ -305,7 +305,7 @@ SCM_DEFINE (scm_inet_ntop, "inet-ntop", 2, 0, 0,
{ {
char addr6[16]; char addr6[16];
scm_to_ipv6 ((scm_t_uint8 *) addr6, address); scm_to_ipv6 ((uint8_t *) addr6, address);
result = inet_ntop (af, &addr6, dst, sizeof (dst)); result = inet_ntop (af, &addr6, dst, sizeof (dst));
} }
#endif #endif
@ -334,7 +334,7 @@ SCM_DEFINE (scm_inet_pton, "inet-pton", 2, 0, 0,
{ {
int af; int af;
char *src; char *src;
scm_t_uint32 dst[4]; uint32_t dst[4];
int rv, eno; int rv, eno;
af = scm_to_int (family); af = scm_to_int (family);
@ -359,7 +359,7 @@ SCM_DEFINE (scm_inet_pton, "inet-pton", 2, 0, 0,
return scm_from_ulong (ntohl (*dst)); return scm_from_ulong (ntohl (*dst));
#ifdef HAVE_IPV6 #ifdef HAVE_IPV6
else if (af == AF_INET6) else if (af == AF_INET6)
return scm_from_ipv6 ((scm_t_uint8 *) dst); return scm_from_ipv6 ((uint8_t *) dst);
#endif #endif
else else
SCM_MISC_ERROR ("unsupported address family", family); SCM_MISC_ERROR ("unsupported address family", family);

18
libguile/srfi-4.c
View file

@ -119,7 +119,7 @@
#define DEFINE_SRFI_4_C_FUNCS(TAG, tag, ctype, width) \ #define DEFINE_SRFI_4_C_FUNCS(TAG, tag, ctype, width) \
SCM scm_take_##tag##vector (ctype *data, size_t n) \ SCM scm_take_##tag##vector (ctype *data, size_t n) \
{ \ { \
return scm_c_take_typed_bytevector ((scm_t_int8*)data, n, ETYPE (TAG), \ return scm_c_take_typed_bytevector ((int8_t*)data, n, ETYPE (TAG), \
SCM_BOOL_F); \ SCM_BOOL_F); \
} \ } \
const ctype* scm_array_handle_##tag##_elements (scm_t_array_handle *h) \ const ctype* scm_array_handle_##tag##_elements (scm_t_array_handle *h) \
@ -163,28 +163,28 @@
#define MOD "srfi srfi-4" #define MOD "srfi srfi-4"
DEFINE_SRFI_4_PROXIES (u8); DEFINE_SRFI_4_PROXIES (u8);
DEFINE_SRFI_4_C_FUNCS (U8, u8, scm_t_uint8, 1); DEFINE_SRFI_4_C_FUNCS (U8, u8, uint8_t, 1);
DEFINE_SRFI_4_PROXIES (s8); DEFINE_SRFI_4_PROXIES (s8);
DEFINE_SRFI_4_C_FUNCS (S8, s8, scm_t_int8, 1); DEFINE_SRFI_4_C_FUNCS (S8, s8, int8_t, 1);
DEFINE_SRFI_4_PROXIES (u16); DEFINE_SRFI_4_PROXIES (u16);
DEFINE_SRFI_4_C_FUNCS (U16, u16, scm_t_uint16, 1); DEFINE_SRFI_4_C_FUNCS (U16, u16, uint16_t, 1);
DEFINE_SRFI_4_PROXIES (s16); DEFINE_SRFI_4_PROXIES (s16);
DEFINE_SRFI_4_C_FUNCS (S16, s16, scm_t_int16, 1); DEFINE_SRFI_4_C_FUNCS (S16, s16, int16_t, 1);
DEFINE_SRFI_4_PROXIES (u32); DEFINE_SRFI_4_PROXIES (u32);
DEFINE_SRFI_4_C_FUNCS (U32, u32, scm_t_uint32, 1); DEFINE_SRFI_4_C_FUNCS (U32, u32, uint32_t, 1);
DEFINE_SRFI_4_PROXIES (s32); DEFINE_SRFI_4_PROXIES (s32);
DEFINE_SRFI_4_C_FUNCS (S32, s32, scm_t_int32, 1); DEFINE_SRFI_4_C_FUNCS (S32, s32, int32_t, 1);
DEFINE_SRFI_4_PROXIES (u64); DEFINE_SRFI_4_PROXIES (u64);
DEFINE_SRFI_4_C_FUNCS (U64, u64, scm_t_uint64, 1); DEFINE_SRFI_4_C_FUNCS (U64, u64, uint64_t, 1);
DEFINE_SRFI_4_PROXIES (s64); DEFINE_SRFI_4_PROXIES (s64);
DEFINE_SRFI_4_C_FUNCS (S64, s64, scm_t_int64, 1); DEFINE_SRFI_4_C_FUNCS (S64, s64, int64_t, 1);
DEFINE_SRFI_4_PROXIES (f32); DEFINE_SRFI_4_PROXIES (f32);
DEFINE_SRFI_4_C_FUNCS (F32, f32, float, 1); DEFINE_SRFI_4_C_FUNCS (F32, f32, float, 1);

80
libguile/srfi-4.h
View file

@ -32,7 +32,7 @@ SCM_API SCM scm_make_srfi_4_vector (SCM type, SCM len, SCM fill);
SCM_API SCM scm_u8vector_p (SCM obj); SCM_API SCM scm_u8vector_p (SCM obj);
SCM_API SCM scm_make_u8vector (SCM n, SCM fill); SCM_API SCM scm_make_u8vector (SCM n, SCM fill);
SCM_API SCM scm_take_u8vector (scm_t_uint8 *data, size_t n); SCM_API SCM scm_take_u8vector (uint8_t *data, size_t n);
SCM_API SCM scm_u8vector (SCM l); SCM_API SCM scm_u8vector (SCM l);
SCM_API SCM scm_u8vector_length (SCM uvec); SCM_API SCM scm_u8vector_length (SCM uvec);
SCM_API SCM scm_u8vector_ref (SCM uvec, SCM index); SCM_API SCM scm_u8vector_ref (SCM uvec, SCM index);
@ -40,19 +40,19 @@ SCM_API SCM scm_u8vector_set_x (SCM uvec, SCM index, SCM value);
SCM_API SCM scm_u8vector_to_list (SCM uvec); SCM_API SCM scm_u8vector_to_list (SCM uvec);
SCM_API SCM scm_list_to_u8vector (SCM l); SCM_API SCM scm_list_to_u8vector (SCM l);
SCM_API SCM scm_any_to_u8vector (SCM obj); SCM_API SCM scm_any_to_u8vector (SCM obj);
SCM_API const scm_t_uint8 *scm_array_handle_u8_elements (scm_t_array_handle *h); SCM_API const uint8_t *scm_array_handle_u8_elements (scm_t_array_handle *h);
SCM_API scm_t_uint8 *scm_array_handle_u8_writable_elements (scm_t_array_handle *h); SCM_API uint8_t *scm_array_handle_u8_writable_elements (scm_t_array_handle *h);
SCM_API const scm_t_uint8 *scm_u8vector_elements (SCM uvec, SCM_API const uint8_t *scm_u8vector_elements (SCM uvec,
scm_t_array_handle *h, scm_t_array_handle *h,
size_t *lenp, ssize_t *incp); size_t *lenp, ssize_t *incp);
SCM_API scm_t_uint8 *scm_u8vector_writable_elements (SCM uvec, SCM_API uint8_t *scm_u8vector_writable_elements (SCM uvec,
scm_t_array_handle *h, scm_t_array_handle *h,
size_t *lenp, size_t *lenp,
ssize_t *incp); ssize_t *incp);
SCM_API SCM scm_s8vector_p (SCM obj); SCM_API SCM scm_s8vector_p (SCM obj);
SCM_API SCM scm_make_s8vector (SCM n, SCM fill); SCM_API SCM scm_make_s8vector (SCM n, SCM fill);
SCM_API SCM scm_take_s8vector (scm_t_int8 *data, size_t n); SCM_API SCM scm_take_s8vector (int8_t *data, size_t n);
SCM_API SCM scm_s8vector (SCM l); SCM_API SCM scm_s8vector (SCM l);
SCM_API SCM scm_s8vector_length (SCM uvec); SCM_API SCM scm_s8vector_length (SCM uvec);
SCM_API SCM scm_s8vector_ref (SCM uvec, SCM index); SCM_API SCM scm_s8vector_ref (SCM uvec, SCM index);
@ -60,19 +60,19 @@ SCM_API SCM scm_s8vector_set_x (SCM uvec, SCM index, SCM value);
SCM_API SCM scm_s8vector_to_list (SCM uvec); SCM_API SCM scm_s8vector_to_list (SCM uvec);
SCM_API SCM scm_list_to_s8vector (SCM l); SCM_API SCM scm_list_to_s8vector (SCM l);
SCM_API SCM scm_any_to_s8vector (SCM obj); SCM_API SCM scm_any_to_s8vector (SCM obj);
SCM_API const scm_t_int8 *scm_array_handle_s8_elements (scm_t_array_handle *h); SCM_API const int8_t *scm_array_handle_s8_elements (scm_t_array_handle *h);
SCM_API scm_t_int8 *scm_array_handle_s8_writable_elements (scm_t_array_handle *h); SCM_API int8_t *scm_array_handle_s8_writable_elements (scm_t_array_handle *h);
SCM_API const scm_t_int8 *scm_s8vector_elements (SCM uvec, SCM_API const int8_t *scm_s8vector_elements (SCM uvec,
scm_t_array_handle *h, scm_t_array_handle *h,
size_t *lenp, ssize_t *incp); size_t *lenp, ssize_t *incp);
SCM_API scm_t_int8 *scm_s8vector_writable_elements (SCM uvec, SCM_API int8_t *scm_s8vector_writable_elements (SCM uvec,
scm_t_array_handle *h, scm_t_array_handle *h,
size_t *lenp, size_t *lenp,
ssize_t *incp); ssize_t *incp);
SCM_API SCM scm_u16vector_p (SCM obj); SCM_API SCM scm_u16vector_p (SCM obj);
SCM_API SCM scm_make_u16vector (SCM n, SCM fill); SCM_API SCM scm_make_u16vector (SCM n, SCM fill);
SCM_API SCM scm_take_u16vector (scm_t_uint16 *data, size_t n); SCM_API SCM scm_take_u16vector (uint16_t *data, size_t n);
SCM_API SCM scm_u16vector (SCM l); SCM_API SCM scm_u16vector (SCM l);
SCM_API SCM scm_u16vector_length (SCM uvec); SCM_API SCM scm_u16vector_length (SCM uvec);
SCM_API SCM scm_u16vector_ref (SCM uvec, SCM index); SCM_API SCM scm_u16vector_ref (SCM uvec, SCM index);
@ -80,20 +80,20 @@ SCM_API SCM scm_u16vector_set_x (SCM uvec, SCM index, SCM value);
SCM_API SCM scm_u16vector_to_list (SCM uvec); SCM_API SCM scm_u16vector_to_list (SCM uvec);
SCM_API SCM scm_list_to_u16vector (SCM l); SCM_API SCM scm_list_to_u16vector (SCM l);
SCM_API SCM scm_any_to_u16vector (SCM obj); SCM_API SCM scm_any_to_u16vector (SCM obj);
SCM_API const scm_t_uint16 *scm_array_handle_u16_elements (scm_t_array_handle *h); SCM_API const uint16_t *scm_array_handle_u16_elements (scm_t_array_handle *h);
SCM_API scm_t_uint16 *scm_array_handle_u16_writable_elements (scm_t_array_handle *h); SCM_API uint16_t *scm_array_handle_u16_writable_elements (scm_t_array_handle *h);
SCM_API const scm_t_uint16 *scm_u16vector_elements (SCM uvec, SCM_API const uint16_t *scm_u16vector_elements (SCM uvec,
scm_t_array_handle *h, scm_t_array_handle *h,
size_t *lenp, size_t *lenp,
ssize_t *incp); ssize_t *incp);
SCM_API scm_t_uint16 *scm_u16vector_writable_elements (SCM uvec, SCM_API uint16_t *scm_u16vector_writable_elements (SCM uvec,
scm_t_array_handle *h, scm_t_array_handle *h,
size_t *lenp, size_t *lenp,
ssize_t *incp); ssize_t *incp);
SCM_API SCM scm_s16vector_p (SCM obj); SCM_API SCM scm_s16vector_p (SCM obj);
SCM_API SCM scm_make_s16vector (SCM n, SCM fill); SCM_API SCM scm_make_s16vector (SCM n, SCM fill);
SCM_API SCM scm_take_s16vector (scm_t_int16 *data, size_t n); SCM_API SCM scm_take_s16vector (int16_t *data, size_t n);
SCM_API SCM scm_s16vector (SCM l); SCM_API SCM scm_s16vector (SCM l);
SCM_API SCM scm_s16vector_length (SCM uvec); SCM_API SCM scm_s16vector_length (SCM uvec);
SCM_API SCM scm_s16vector_ref (SCM uvec, SCM index); SCM_API SCM scm_s16vector_ref (SCM uvec, SCM index);
@ -101,19 +101,19 @@ SCM_API SCM scm_s16vector_set_x (SCM uvec, SCM index, SCM value);
SCM_API SCM scm_s16vector_to_list (SCM uvec); SCM_API SCM scm_s16vector_to_list (SCM uvec);
SCM_API SCM scm_list_to_s16vector (SCM l); SCM_API SCM scm_list_to_s16vector (SCM l);
SCM_API SCM scm_any_to_s16vector (SCM obj); SCM_API SCM scm_any_to_s16vector (SCM obj);
SCM_API const scm_t_int16 *scm_array_handle_s16_elements (scm_t_array_handle *h); SCM_API const int16_t *scm_array_handle_s16_elements (scm_t_array_handle *h);
SCM_API scm_t_int16 *scm_array_handle_s16_writable_elements (scm_t_array_handle *h); SCM_API int16_t *scm_array_handle_s16_writable_elements (scm_t_array_handle *h);
SCM_API const scm_t_int16 *scm_s16vector_elements (SCM uvec, SCM_API const int16_t *scm_s16vector_elements (SCM uvec,
scm_t_array_handle *h, scm_t_array_handle *h,
size_t *lenp, ssize_t *incp); size_t *lenp, ssize_t *incp);
SCM_API scm_t_int16 *scm_s16vector_writable_elements (SCM uvec, SCM_API int16_t *scm_s16vector_writable_elements (SCM uvec,
scm_t_array_handle *h, scm_t_array_handle *h,
size_t *lenp, size_t *lenp,
ssize_t *incp); ssize_t *incp);
SCM_API SCM scm_u32vector_p (SCM obj); SCM_API SCM scm_u32vector_p (SCM obj);
SCM_API SCM scm_make_u32vector (SCM n, SCM fill); SCM_API SCM scm_make_u32vector (SCM n, SCM fill);
SCM_API SCM scm_take_u32vector (scm_t_uint32 *data, size_t n); SCM_API SCM scm_take_u32vector (uint32_t *data, size_t n);
SCM_API SCM scm_u32vector (SCM l); SCM_API SCM scm_u32vector (SCM l);
SCM_API SCM scm_u32vector_length (SCM uvec); SCM_API SCM scm_u32vector_length (SCM uvec);
SCM_API SCM scm_u32vector_ref (SCM uvec, SCM index); SCM_API SCM scm_u32vector_ref (SCM uvec, SCM index);
@ -121,20 +121,20 @@ SCM_API SCM scm_u32vector_set_x (SCM uvec, SCM index, SCM value);
SCM_API SCM scm_u32vector_to_list (SCM uvec); SCM_API SCM scm_u32vector_to_list (SCM uvec);
SCM_API SCM scm_list_to_u32vector (SCM l); SCM_API SCM scm_list_to_u32vector (SCM l);
SCM_API SCM scm_any_to_u32vector (SCM obj); SCM_API SCM scm_any_to_u32vector (SCM obj);
SCM_API const scm_t_uint32 *scm_array_handle_u32_elements (scm_t_array_handle *h); SCM_API const uint32_t *scm_array_handle_u32_elements (scm_t_array_handle *h);
SCM_API scm_t_uint32 *scm_array_handle_u32_writable_elements (scm_t_array_handle *h); SCM_API uint32_t *scm_array_handle_u32_writable_elements (scm_t_array_handle *h);
SCM_API const scm_t_uint32 *scm_u32vector_elements (SCM uvec, SCM_API const uint32_t *scm_u32vector_elements (SCM uvec,
scm_t_array_handle *h, scm_t_array_handle *h,
size_t *lenp, size_t *lenp,
ssize_t *incp); ssize_t *incp);
SCM_API scm_t_uint32 *scm_u32vector_writable_elements (SCM uvec, SCM_API uint32_t *scm_u32vector_writable_elements (SCM uvec,
scm_t_array_handle *h, scm_t_array_handle *h,
size_t *lenp, size_t *lenp,
ssize_t *incp); ssize_t *incp);
SCM_API SCM scm_s32vector_p (SCM obj); SCM_API SCM scm_s32vector_p (SCM obj);
SCM_API SCM scm_make_s32vector (SCM n, SCM fill); SCM_API SCM scm_make_s32vector (SCM n, SCM fill);
SCM_API SCM scm_take_s32vector (scm_t_int32 *data, size_t n); SCM_API SCM scm_take_s32vector (int32_t *data, size_t n);
SCM_API SCM scm_s32vector (SCM l); SCM_API SCM scm_s32vector (SCM l);
SCM_API SCM scm_s32vector_length (SCM uvec); SCM_API SCM scm_s32vector_length (SCM uvec);
SCM_API SCM scm_s32vector_ref (SCM uvec, SCM index); SCM_API SCM scm_s32vector_ref (SCM uvec, SCM index);
@ -142,12 +142,12 @@ SCM_API SCM scm_s32vector_set_x (SCM uvec, SCM index, SCM value);
SCM_API SCM scm_s32vector_to_list (SCM uvec); SCM_API SCM scm_s32vector_to_list (SCM uvec);
SCM_API SCM scm_list_to_s32vector (SCM l); SCM_API SCM scm_list_to_s32vector (SCM l);
SCM_API SCM scm_any_to_s32vector (SCM obj); SCM_API SCM scm_any_to_s32vector (SCM obj);
SCM_API const scm_t_int32 *scm_array_handle_s32_elements (scm_t_array_handle *h); SCM_API const int32_t *scm_array_handle_s32_elements (scm_t_array_handle *h);
SCM_API scm_t_int32 *scm_array_handle_s32_writable_elements (scm_t_array_handle *h); SCM_API int32_t *scm_array_handle_s32_writable_elements (scm_t_array_handle *h);
SCM_API const scm_t_int32 *scm_s32vector_elements (SCM uvec, SCM_API const int32_t *scm_s32vector_elements (SCM uvec,
scm_t_array_handle *h, scm_t_array_handle *h,
size_t *lenp, ssize_t *incp); size_t *lenp, ssize_t *incp);
SCM_API scm_t_int32 *scm_s32vector_writable_elements (SCM uvec, SCM_API int32_t *scm_s32vector_writable_elements (SCM uvec,
scm_t_array_handle *h, scm_t_array_handle *h,
size_t *lenp, size_t *lenp,
ssize_t *incp); ssize_t *incp);
@ -162,14 +162,14 @@ SCM_API SCM scm_u64vector_to_list (SCM uvec);
SCM_API SCM scm_list_to_u64vector (SCM l); SCM_API SCM scm_list_to_u64vector (SCM l);
SCM_API SCM scm_any_to_u64vector (SCM obj); SCM_API SCM scm_any_to_u64vector (SCM obj);
SCM_API SCM scm_take_u64vector (scm_t_uint64 *data, size_t n); SCM_API SCM scm_take_u64vector (uint64_t *data, size_t n);
SCM_API const scm_t_uint64 *scm_array_handle_u64_elements (scm_t_array_handle *h); SCM_API const uint64_t *scm_array_handle_u64_elements (scm_t_array_handle *h);
SCM_API scm_t_uint64 *scm_array_handle_u64_writable_elements (scm_t_array_handle *h); SCM_API uint64_t *scm_array_handle_u64_writable_elements (scm_t_array_handle *h);
SCM_API const scm_t_uint64 *scm_u64vector_elements (SCM uvec, SCM_API const uint64_t *scm_u64vector_elements (SCM uvec,
scm_t_array_handle *h, scm_t_array_handle *h,
size_t *lenp, size_t *lenp,
ssize_t *incp); ssize_t *incp);
SCM_API scm_t_uint64 *scm_u64vector_writable_elements (SCM uvec, SCM_API uint64_t *scm_u64vector_writable_elements (SCM uvec,
scm_t_array_handle *h, scm_t_array_handle *h,
size_t *lenp, size_t *lenp,
ssize_t *incp); ssize_t *incp);
@ -184,13 +184,13 @@ SCM_API SCM scm_s64vector_to_list (SCM uvec);
SCM_API SCM scm_list_to_s64vector (SCM l); SCM_API SCM scm_list_to_s64vector (SCM l);
SCM_API SCM scm_any_to_s64vector (SCM obj); SCM_API SCM scm_any_to_s64vector (SCM obj);
SCM_API SCM scm_take_s64vector (scm_t_int64 *data, size_t n); SCM_API SCM scm_take_s64vector (int64_t *data, size_t n);
SCM_API const scm_t_int64 *scm_array_handle_s64_elements (scm_t_array_handle *h); SCM_API const int64_t *scm_array_handle_s64_elements (scm_t_array_handle *h);
SCM_API scm_t_int64 *scm_array_handle_s64_writable_elements (scm_t_array_handle *h); SCM_API int64_t *scm_array_handle_s64_writable_elements (scm_t_array_handle *h);
SCM_API const scm_t_int64 *scm_s64vector_elements (SCM uvec, SCM_API const int64_t *scm_s64vector_elements (SCM uvec,
scm_t_array_handle *h, scm_t_array_handle *h,
size_t *lenp, ssize_t *incp); size_t *lenp, ssize_t *incp);
SCM_API scm_t_int64 *scm_s64vector_writable_elements (SCM uvec, SCM_API int64_t *scm_s64vector_writable_elements (SCM uvec,
scm_t_array_handle *h, scm_t_array_handle *h,
size_t *lenp, size_t *lenp,
ssize_t *incp); ssize_t *incp);

8
libguile/stacks.c
View file

@ -152,14 +152,14 @@ narrow_stack (long len, enum scm_vm_frame_kind kind, struct scm_frame *frame,
&& scm_is_integer (scm_cdr (inner_cut))) && scm_is_integer (scm_cdr (inner_cut)))
{ {
/* Cut until an IP within the given range is found. */ /* Cut until an IP within the given range is found. */
scm_t_uintptr low_pc, high_pc, pc; uintptr_t low_pc, high_pc, pc;
low_pc = scm_to_uintptr_t (scm_car (inner_cut)); low_pc = scm_to_uintptr_t (scm_car (inner_cut));
high_pc = scm_to_uintptr_t (scm_cdr (inner_cut)); high_pc = scm_to_uintptr_t (scm_cdr (inner_cut));
for (; len ;) for (; len ;)
{ {
pc = (scm_t_uintptr) frame->ip; pc = (uintptr_t) frame->ip;
len--; len--;
scm_c_frame_previous (kind, frame); scm_c_frame_previous (kind, frame);
if (low_pc <= pc && pc < high_pc) if (low_pc <= pc && pc < high_pc)
@ -206,7 +206,7 @@ narrow_stack (long len, enum scm_vm_frame_kind kind, struct scm_frame *frame,
&& scm_is_integer (scm_cdr (outer_cut))) && scm_is_integer (scm_cdr (outer_cut)))
{ {
/* Cut until an IP within the given range is found. */ /* Cut until an IP within the given range is found. */
scm_t_uintptr low_pc, high_pc, pc; uintptr_t low_pc, high_pc, pc;
long i, new_len; long i, new_len;
struct scm_frame tmp; struct scm_frame tmp;
@ -218,7 +218,7 @@ narrow_stack (long len, enum scm_vm_frame_kind kind, struct scm_frame *frame,
/* Cut until the given procedure is seen. */ /* Cut until the given procedure is seen. */
for (new_len = i = 0; i < len; i++, scm_c_frame_previous (kind, &tmp)) for (new_len = i = 0; i < len; i++, scm_c_frame_previous (kind, &tmp))
{ {
pc = (scm_t_uintptr) tmp.ip; pc = (uintptr_t) tmp.ip;
if (low_pc <= pc && pc < high_pc) if (low_pc <= pc && pc < high_pc)
new_len = i; new_len = i;
} }

4
libguile/stime.c
View file

@ -673,7 +673,7 @@ SCM_DEFINE (scm_strftime, "strftime", 2, 0, 0,
character to the format string, so that valid returns are always character to the format string, so that valid returns are always
nonzero. */ nonzero. */
myfmt = scm_malloc (len+2); myfmt = scm_malloc (len+2);
*myfmt = (scm_t_uint8) 'x'; *myfmt = (uint8_t) 'x';
strncpy (myfmt + 1, fmt, len); strncpy (myfmt + 1, fmt, len);
myfmt[len + 1] = 0; myfmt[len + 1] = 0;
scm_remember_upto_here_1 (format); scm_remember_upto_here_1 (format);
@ -809,7 +809,7 @@ SCM_DEFINE (scm_strptime, "strptime", 2, 0, 0,
#endif #endif
/* Compute the number of UTF-8 characters. */ /* Compute the number of UTF-8 characters. */
used_len = u8_strnlen ((scm_t_uint8*) str, rest-str); used_len = u8_strnlen ((uint8_t*) str, rest-str);
scm_remember_upto_here_2 (format, string); scm_remember_upto_here_2 (format, string);
free (str); free (str);
free (fmt); free (fmt);

58
libguile/strings.c
View file

@ -365,8 +365,8 @@ substring_with_immutable_stringbuf (SCM str, size_t start, size_t end,
if (STRINGBUF_WIDE (buf)) if (STRINGBUF_WIDE (buf))
{ {
new_buf = make_wide_stringbuf (len); new_buf = make_wide_stringbuf (len);
u32_cpy ((scm_t_uint32 *) STRINGBUF_WIDE_CHARS (new_buf), u32_cpy ((uint32_t *) STRINGBUF_WIDE_CHARS (new_buf),
(scm_t_uint32 *) (STRINGBUF_WIDE_CHARS (buf) + start), len); (uint32_t *) (STRINGBUF_WIDE_CHARS (buf) + start), len);
new_str = scm_double_cell (tag, SCM_UNPACK (new_buf), 0, len); new_str = scm_double_cell (tag, SCM_UNPACK (new_buf), 0, len);
scm_i_try_narrow_string (new_str); scm_i_try_narrow_string (new_str);
} }
@ -433,8 +433,8 @@ scm_i_string_ensure_mutable_x (SCM str)
if (STRINGBUF_WIDE (buf)) if (STRINGBUF_WIDE (buf))
{ {
new_buf = make_wide_stringbuf (len); new_buf = make_wide_stringbuf (len);
u32_cpy ((scm_t_uint32 *) STRINGBUF_WIDE_CHARS (new_buf), u32_cpy ((uint32_t *) STRINGBUF_WIDE_CHARS (new_buf),
(scm_t_uint32 *) STRINGBUF_WIDE_CHARS (buf), len); (uint32_t *) STRINGBUF_WIDE_CHARS (buf), len);
} }
else else
{ {
@ -920,8 +920,8 @@ SCM_DEFINE (scm_sys_string_dump, "%string-dump", 1, 0, 0, (SCM str),
size_t len = STRINGBUF_LENGTH (buf); size_t len = STRINGBUF_LENGTH (buf);
scm_t_wchar *cbuf; scm_t_wchar *cbuf;
SCM sbc = scm_i_make_wide_string (len, &cbuf, 0); SCM sbc = scm_i_make_wide_string (len, &cbuf, 0);
u32_cpy ((scm_t_uint32 *) cbuf, u32_cpy ((uint32_t *) cbuf,
(scm_t_uint32 *) STRINGBUF_WIDE_CHARS (buf), len); (uint32_t *) STRINGBUF_WIDE_CHARS (buf), len);
e6 = scm_cons (scm_from_latin1_symbol ("stringbuf-chars"), e6 = scm_cons (scm_from_latin1_symbol ("stringbuf-chars"),
sbc); sbc);
} }
@ -993,8 +993,8 @@ SCM_DEFINE (scm_sys_symbol_dump, "%symbol-dump", 1, 0, 0, (SCM sym),
size_t len = STRINGBUF_LENGTH (buf); size_t len = STRINGBUF_LENGTH (buf);
scm_t_wchar *cbuf; scm_t_wchar *cbuf;
SCM sbc = scm_i_make_wide_string (len, &cbuf, 0); SCM sbc = scm_i_make_wide_string (len, &cbuf, 0);
u32_cpy ((scm_t_uint32 *) cbuf, u32_cpy ((uint32_t *) cbuf,
(scm_t_uint32 *) STRINGBUF_WIDE_CHARS (buf), len); (uint32_t *) STRINGBUF_WIDE_CHARS (buf), len);
e4 = scm_cons (scm_from_latin1_symbol ("stringbuf-chars"), e4 = scm_cons (scm_from_latin1_symbol ("stringbuf-chars"),
sbc); sbc);
} }
@ -1423,8 +1423,8 @@ SCM_DEFINE (scm_string_append, "string-append", 0, 0, 1,
data.wide[i] = (unsigned char) src[i]; data.wide[i] = (unsigned char) src[i];
} }
else else
u32_cpy ((scm_t_uint32 *) data.wide, u32_cpy ((uint32_t *) data.wide,
(scm_t_uint32 *) scm_i_string_wide_chars (s), len); (uint32_t *) scm_i_string_wide_chars (s), len);
data.wide += len; data.wide += len;
} }
total -= len; total -= len;
@ -1542,7 +1542,7 @@ scm_from_stringn (const char *str, size_t len, const char *encoding,
{ {
scm_t_wchar *wdst; scm_t_wchar *wdst;
res = scm_i_make_wide_string (u32len, &wdst, 0); res = scm_i_make_wide_string (u32len, &wdst, 0);
u32_cpy ((scm_t_uint32 *) wdst, (scm_t_uint32 *) u32, u32len); u32_cpy ((uint32_t *) wdst, (uint32_t *) u32, u32len);
wdst[u32len] = 0; wdst[u32len] = 0;
} }
@ -1602,7 +1602,7 @@ SCM
scm_from_utf8_stringn (const char *str, size_t len) scm_from_utf8_stringn (const char *str, size_t len)
{ {
size_t i, char_len; size_t i, char_len;
const scm_t_uint8 *ustr = (const scm_t_uint8 *) str; const uint8_t *ustr = (const uint8_t *) str;
int ascii = 1, narrow = 1; int ascii = 1, narrow = 1;
SCM res; SCM res;
@ -1932,7 +1932,7 @@ scm_to_utf8_string (SCM str)
} }
static size_t static size_t
latin1_u8_strlen (const scm_t_uint8 *str, size_t len) latin1_u8_strlen (const uint8_t *str, size_t len)
{ {
size_t ret, i; size_t ret, i;
for (i = 0, ret = 0; i < len; i++) for (i = 0, ret = 0; i < len; i++)
@ -1940,9 +1940,9 @@ latin1_u8_strlen (const scm_t_uint8 *str, size_t len)
return ret; return ret;
} }
static scm_t_uint8* static uint8_t*
latin1_to_u8 (const scm_t_uint8 *str, size_t latin_len, latin1_to_u8 (const uint8_t *str, size_t latin_len,
scm_t_uint8 *u8_result, size_t *u8_lenp) uint8_t *u8_result, size_t *u8_lenp)
{ {
size_t i, n; size_t i, n;
size_t u8_len = latin1_u8_strlen (str, latin_len); size_t u8_len = latin1_u8_strlen (str, latin_len);
@ -1982,13 +1982,13 @@ latin1_to_u8 (const scm_t_uint8 *str, size_t latin_len,
*/ */
static size_t static size_t
u32_u8_length_in_bytes (const scm_t_uint32 *str, size_t len) u32_u8_length_in_bytes (const uint32_t *str, size_t len)
{ {
size_t ret, i; size_t ret, i;
for (i = 0, ret = 0; i < len; i++) for (i = 0, ret = 0; i < len; i++)
{ {
scm_t_uint32 c = str[i]; uint32_t c = str[i];
if (c <= 0x7f) if (c <= 0x7f)
ret += 1; ret += 1;
@ -2011,11 +2011,11 @@ static size_t
utf8_length (SCM str) utf8_length (SCM str)
{ {
if (scm_i_is_narrow_string (str)) if (scm_i_is_narrow_string (str))
return latin1_u8_strlen ((scm_t_uint8 *) scm_i_string_chars (str), return latin1_u8_strlen ((uint8_t *) scm_i_string_chars (str),
scm_i_string_length (str)); scm_i_string_length (str));
else else
return u32_u8_length_in_bytes return u32_u8_length_in_bytes
((scm_t_uint32 *) scm_i_string_wide_chars (str), ((uint32_t *) scm_i_string_wide_chars (str),
scm_i_string_length (str)); scm_i_string_length (str));
} }
@ -2046,13 +2046,13 @@ scm_to_utf8_stringn (SCM str, size_t *lenp)
SCM_VALIDATE_STRING (1, str); SCM_VALIDATE_STRING (1, str);
if (scm_i_is_narrow_string (str)) if (scm_i_is_narrow_string (str))
return (char *) latin1_to_u8 ((scm_t_uint8 *) scm_i_string_chars (str), return (char *) latin1_to_u8 ((uint8_t *) scm_i_string_chars (str),
scm_i_string_length (str), scm_i_string_length (str),
NULL, lenp); NULL, lenp);
else else
{ {
scm_t_uint32 *chars = (scm_t_uint32 *) scm_i_string_wide_chars (str); uint32_t *chars = (uint32_t *) scm_i_string_wide_chars (str);
scm_t_uint8 *buf, *ret; uint8_t *buf, *ret;
size_t num_chars = scm_i_string_length (str); size_t num_chars = scm_i_string_length (str);
size_t num_bytes_predicted, num_bytes_actual; size_t num_bytes_predicted, num_bytes_actual;
@ -2109,10 +2109,10 @@ scm_to_utf32_stringn (SCM str, size_t *lenp)
if (scm_i_is_narrow_string (str)) if (scm_i_is_narrow_string (str))
{ {
scm_t_uint8 *codepoints; uint8_t *codepoints;
size_t i, len; size_t i, len;
codepoints = (scm_t_uint8*) scm_i_string_chars (str); codepoints = (uint8_t*) scm_i_string_chars (str);
len = scm_i_string_length (str); len = scm_i_string_length (str);
if (lenp) if (lenp)
*lenp = len; *lenp = len;
@ -2240,7 +2240,7 @@ scm_to_stringn (SCM str, size_t *lenp, const char *encoding,
{ {
buf = u32_conv_to_encoding (enc, buf = u32_conv_to_encoding (enc,
(enum iconv_ilseq_handler) handler, (enum iconv_ilseq_handler) handler,
(scm_t_uint32 *) scm_i_string_wide_chars (str), (uint32_t *) scm_i_string_wide_chars (str),
ilen, ilen,
NULL, NULL,
NULL, &len); NULL, &len);
@ -2306,7 +2306,7 @@ static SCM
normalize_str (SCM string, uninorm_t form) normalize_str (SCM string, uninorm_t form)
{ {
SCM ret; SCM ret;
scm_t_uint32 *w_str; uint32_t *w_str;
scm_t_wchar *cbuf; scm_t_wchar *cbuf;
size_t rlen, len = scm_i_string_length (string); size_t rlen, len = scm_i_string_length (string);
@ -2322,12 +2322,12 @@ normalize_str (SCM string, uninorm_t form)
w_str[len] = 0; w_str[len] = 0;
} }
else else
w_str = (scm_t_uint32 *) scm_i_string_wide_chars (string); w_str = (uint32_t *) scm_i_string_wide_chars (string);
w_str = u32_normalize (form, w_str, len, NULL, &rlen); w_str = u32_normalize (form, w_str, len, NULL, &rlen);
ret = scm_i_make_wide_string (rlen, &cbuf, 0); ret = scm_i_make_wide_string (rlen, &cbuf, 0);
u32_cpy ((scm_t_uint32 *) cbuf, w_str, rlen); u32_cpy ((uint32_t *) cbuf, w_str, rlen);
free (w_str); free (w_str);
scm_i_try_narrow_string (ret); scm_i_try_narrow_string (ret);

4
libguile/struct.c
View file

@ -129,7 +129,7 @@ set_vtable_access_fields (SCM vtable)
size_t len, nfields, bitmask_size, field; size_t len, nfields, bitmask_size, field;
SCM layout; SCM layout;
const char *c_layout; const char *c_layout;
scm_t_uint32 *unboxed_fields; uint32_t *unboxed_fields;
layout = SCM_VTABLE_LAYOUT (vtable); layout = SCM_VTABLE_LAYOUT (vtable);
c_layout = scm_i_symbol_chars (layout); c_layout = scm_i_symbol_chars (layout);
@ -151,7 +151,7 @@ set_vtable_access_fields (SCM vtable)
SCM_SET_VTABLE_FLAGS (vtable, 0); SCM_SET_VTABLE_FLAGS (vtable, 0);
SCM_STRUCT_DATA_SET (vtable, scm_vtable_index_size, len / 2); SCM_STRUCT_DATA_SET (vtable, scm_vtable_index_size, len / 2);
SCM_STRUCT_DATA_SET (vtable, scm_vtable_index_unboxed_fields, SCM_STRUCT_DATA_SET (vtable, scm_vtable_index_unboxed_fields,
(scm_t_uintptr) unboxed_fields); (uintptr_t) unboxed_fields);
} }
static int static int

4
libguile/struct.h
View file

@ -70,7 +70,7 @@
#define scm_vtable_index_instance_printer 3 /* A printer for this struct type. */ #define scm_vtable_index_instance_printer 3 /* A printer for this struct type. */
#define scm_vtable_index_name 4 /* Name of this vtable. */ #define scm_vtable_index_name 4 /* Name of this vtable. */
#define scm_vtable_index_size 5 /* Number of fields, for simple structs. */ #define scm_vtable_index_size 5 /* Number of fields, for simple structs. */
#define scm_vtable_index_unboxed_fields 6 /* Raw scm_t_uint32* bitmask indicating unboxed fields. */ #define scm_vtable_index_unboxed_fields 6 /* Raw uint32_t* bitmask indicating unboxed fields. */
#define scm_vtable_index_reserved_7 7 #define scm_vtable_index_reserved_7 7
#define scm_vtable_offset_user 8 /* Where do user fields start in the vtable? */ #define scm_vtable_offset_user 8 /* Where do user fields start in the vtable? */
@ -139,7 +139,7 @@ typedef void (*scm_t_struct_finalize) (SCM obj);
#define SCM_VTABLE_NAME(X) (SCM_STRUCT_SLOT_REF (X, scm_vtable_index_name)) #define SCM_VTABLE_NAME(X) (SCM_STRUCT_SLOT_REF (X, scm_vtable_index_name))
#define SCM_SET_VTABLE_NAME(X,V) (SCM_STRUCT_SLOT_SET (X, scm_vtable_index_name, V)) #define SCM_SET_VTABLE_NAME(X,V) (SCM_STRUCT_SLOT_SET (X, scm_vtable_index_name, V))
#define SCM_VTABLE_SIZE(X) (SCM_STRUCT_DATA_REF (X, scm_vtable_index_size)) #define SCM_VTABLE_SIZE(X) (SCM_STRUCT_DATA_REF (X, scm_vtable_index_size))
#define SCM_VTABLE_UNBOXED_FIELDS(X) ((scm_t_uint32*) SCM_STRUCT_DATA_REF (X, scm_vtable_index_unboxed_fields)) #define SCM_VTABLE_UNBOXED_FIELDS(X) ((uint32_t*) SCM_STRUCT_DATA_REF (X, scm_vtable_index_unboxed_fields))
#define SCM_VTABLE_FIELD_IS_UNBOXED(X,F) (SCM_VTABLE_UNBOXED_FIELDS (X)[(F)>>5]&(1U<<((F)&31))) #define SCM_VTABLE_FIELD_IS_UNBOXED(X,F) (SCM_VTABLE_UNBOXED_FIELDS (X)[(F)>>5]&(1U<<((F)&31)))
#define SCM_STRUCT_VTABLE(X) (SCM_PACK (SCM_CELL_WORD_0 (X) - scm_tc3_struct)) #define SCM_STRUCT_VTABLE(X) (SCM_PACK (SCM_CELL_WORD_0 (X) - scm_tc3_struct))

4
libguile/symbols.c
View file

@ -154,7 +154,7 @@ struct utf8_lookup_data
}; };
static int static int
utf8_string_equals_wide_string (const scm_t_uint8 *narrow, size_t nlen, utf8_string_equals_wide_string (const uint8_t *narrow, size_t nlen,
const scm_t_wchar *wide, size_t wlen) const scm_t_wchar *wide, size_t wlen)
{ {
size_t byte_idx = 0, char_idx = 0; size_t byte_idx = 0, char_idx = 0;
@ -192,7 +192,7 @@ utf8_lookup_predicate_fn (SCM sym, void *closure)
return (scm_i_symbol_length (sym) == data->len return (scm_i_symbol_length (sym) == data->len
&& strncmp (scm_i_symbol_chars (sym), data->str, data->len) == 0); && strncmp (scm_i_symbol_chars (sym), data->str, data->len) == 0);
else else
return utf8_string_equals_wide_string ((const scm_t_uint8 *) data->str, return utf8_string_equals_wide_string ((const uint8_t *) data->str,
data->len, data->len,
scm_i_symbol_wide_chars (sym), scm_i_symbol_wide_chars (sym),
scm_i_symbol_length (sym)); scm_i_symbol_length (sym));

6
libguile/threads.c
View file

@ -80,7 +80,7 @@ thread_mark (GC_word *addr, struct GC_ms_entry *mark_stack_ptr,
struct GC_ms_entry *mark_stack_limit, GC_word env) struct GC_ms_entry *mark_stack_limit, GC_word env)
{ {
int word; int word;
const struct scm_i_thread *t = (struct scm_i_thread *) addr; struct scm_i_thread *t = (struct scm_i_thread *) addr;
if (SCM_UNPACK (t->handle) == 0) if (SCM_UNPACK (t->handle) == 0)
/* T must be on the free-list; ignore. (See warning in /* T must be on the free-list; ignore. (See warning in
@ -250,11 +250,11 @@ thread_print (SCM exp, SCM port, scm_print_state *pstate SCM_UNUSED)
unsigned short us; unsigned short us;
unsigned int ui; unsigned int ui;
unsigned long ul; unsigned long ul;
scm_t_uintmax um; uintmax_t um;
} u; } u;
scm_i_thread *t = SCM_I_THREAD_DATA (exp); scm_i_thread *t = SCM_I_THREAD_DATA (exp);
scm_i_pthread_t p = t->pthread; scm_i_pthread_t p = t->pthread;
scm_t_uintmax id; uintmax_t id;
u.p = p; u.p = p;
if (sizeof (p) == sizeof (unsigned short)) if (sizeof (p) == sizeof (unsigned short))
id = u.us; id = u.us;

4
libguile/uniform.c
View file

@ -66,10 +66,10 @@ const void *
scm_array_handle_uniform_elements (scm_t_array_handle *h) scm_array_handle_uniform_elements (scm_t_array_handle *h)
{ {
size_t esize; size_t esize;
const scm_t_uint8 *ret; const uint8_t *ret;
esize = scm_array_handle_uniform_element_size (h); esize = scm_array_handle_uniform_element_size (h);
ret = ((const scm_t_uint8 *) h->elements) + h->base * esize; ret = ((const uint8_t *) h->elements) + h->base * esize;
return ret; return ret;
} }

416
libguile/vm-engine.c
View file

File diff suppressed because it is too large Load diff

56
libguile/vm.c
View file

@ -164,8 +164,8 @@ scm_i_vm_cont_to_frame (SCM cont, struct scm_frame *frame)
SCM SCM
scm_i_vm_capture_stack (union scm_vm_stack_element *stack_top, scm_i_vm_capture_stack (union scm_vm_stack_element *stack_top,
union scm_vm_stack_element *fp, union scm_vm_stack_element *fp,
union scm_vm_stack_element *sp, scm_t_uint32 *ra, union scm_vm_stack_element *sp, uint32_t *ra,
scm_t_dynstack *dynstack, scm_t_uint32 flags) scm_t_dynstack *dynstack, uint32_t flags)
{ {
struct scm_vm_cont *p; struct scm_vm_cont *p;
@ -273,7 +273,7 @@ vm_dispatch_hook (struct scm_vm *vp, int hook_num,
struct scm_frame c_frame; struct scm_frame c_frame;
scm_t_cell *frame; scm_t_cell *frame;
int saved_trace_level; int saved_trace_level;
scm_t_uint8 saved_compare_result; uint8_t saved_compare_result;
hook = vp->hooks[hook_num]; hook = vp->hooks[hook_num];
@ -301,7 +301,7 @@ vm_dispatch_hook (struct scm_vm *vp, int hook_num,
/* Arrange for FRAME to be 8-byte aligned, like any other cell. */ /* Arrange for FRAME to be 8-byte aligned, like any other cell. */
frame = alloca (sizeof (*frame) + 8); frame = alloca (sizeof (*frame) + 8);
frame = (scm_t_cell *) ROUND_UP ((scm_t_uintptr) frame, 8UL); frame = (scm_t_cell *) ROUND_UP ((uintptr_t) frame, 8UL);
frame->word_0 = SCM_PACK (scm_tc7_frame | (SCM_VM_FRAME_KIND_VM << 8)); frame->word_0 = SCM_PACK (scm_tc7_frame | (SCM_VM_FRAME_KIND_VM << 8));
frame->word_1 = SCM_PACK_POINTER (&c_frame); frame->word_1 = SCM_PACK_POINTER (&c_frame);
@ -462,7 +462,7 @@ static void vm_throw_with_value (SCM val, SCM key_subr_and_message) SCM_NORETURN
static void vm_throw_with_value_and_data (SCM val, SCM key_subr_and_message) SCM_NORETURN SCM_NOINLINE; static void vm_throw_with_value_and_data (SCM val, SCM key_subr_and_message) SCM_NORETURN SCM_NOINLINE;
static void vm_error (const char *msg, SCM arg) SCM_NORETURN; static void vm_error (const char *msg, SCM arg) SCM_NORETURN;
static void vm_error_bad_instruction (scm_t_uint32 inst) SCM_NORETURN SCM_NOINLINE; static void vm_error_bad_instruction (uint32_t inst) SCM_NORETURN SCM_NOINLINE;
static void vm_error_apply_to_non_list (SCM x) SCM_NORETURN SCM_NOINLINE; static void vm_error_apply_to_non_list (SCM x) SCM_NORETURN SCM_NOINLINE;
static void vm_error_kwargs_missing_value (SCM proc, SCM kw) SCM_NORETURN SCM_NOINLINE; static void vm_error_kwargs_missing_value (SCM proc, SCM kw) SCM_NORETURN SCM_NOINLINE;
static void vm_error_kwargs_invalid_keyword (SCM proc, SCM obj) SCM_NORETURN SCM_NOINLINE; static void vm_error_kwargs_invalid_keyword (SCM proc, SCM obj) SCM_NORETURN SCM_NOINLINE;
@ -471,7 +471,7 @@ static void vm_error_wrong_num_args (SCM proc) SCM_NORETURN SCM_NOINLINE;
static void vm_error_wrong_type_apply (SCM proc) SCM_NORETURN SCM_NOINLINE; static void vm_error_wrong_type_apply (SCM proc) SCM_NORETURN SCM_NOINLINE;
static void vm_error_no_values (void) SCM_NORETURN SCM_NOINLINE; static void vm_error_no_values (void) SCM_NORETURN SCM_NOINLINE;
static void vm_error_not_enough_values (void) SCM_NORETURN SCM_NOINLINE; static void vm_error_not_enough_values (void) SCM_NORETURN SCM_NOINLINE;
static void vm_error_wrong_number_of_values (scm_t_uint32 expected) SCM_NORETURN SCM_NOINLINE; static void vm_error_wrong_number_of_values (uint32_t expected) SCM_NORETURN SCM_NOINLINE;
static void vm_error_continuation_not_rewindable (SCM cont) SCM_NORETURN SCM_NOINLINE; static void vm_error_continuation_not_rewindable (SCM cont) SCM_NORETURN SCM_NOINLINE;
static void static void
@ -518,7 +518,7 @@ vm_error (const char *msg, SCM arg)
} }
static void static void
vm_error_bad_instruction (scm_t_uint32 inst) vm_error_bad_instruction (uint32_t inst)
{ {
vm_error ("VM: Bad instruction: ~s", scm_from_uint32 (inst)); vm_error ("VM: Bad instruction: ~s", scm_from_uint32 (inst));
} }
@ -581,7 +581,7 @@ vm_error_not_enough_values (void)
} }
static void static void
vm_error_wrong_number_of_values (scm_t_uint32 expected) vm_error_wrong_number_of_values (uint32_t expected)
{ {
vm_error ("Wrong number of values returned to continuation (expected ~a)", vm_error ("Wrong number of values returned to continuation (expected ~a)",
scm_from_uint32 (expected)); scm_from_uint32 (expected));
@ -603,31 +603,31 @@ static SCM vm_builtin_abort_to_prompt;
static SCM vm_builtin_call_with_values; static SCM vm_builtin_call_with_values;
static SCM vm_builtin_call_with_current_continuation; static SCM vm_builtin_call_with_current_continuation;
static const scm_t_uint32 vm_boot_continuation_code[] = { static const uint32_t vm_boot_continuation_code[] = {
SCM_PACK_OP_24 (halt, 0) SCM_PACK_OP_24 (halt, 0)
}; };
static const scm_t_uint32 vm_apply_non_program_code[] = { static const uint32_t vm_apply_non_program_code[] = {
SCM_PACK_OP_24 (apply_non_program, 0) SCM_PACK_OP_24 (apply_non_program, 0)
}; };
static const scm_t_uint32 vm_builtin_apply_code[] = { static const uint32_t vm_builtin_apply_code[] = {
SCM_PACK_OP_24 (assert_nargs_ge, 3), SCM_PACK_OP_24 (assert_nargs_ge, 3),
SCM_PACK_OP_24 (tail_apply, 0), /* proc in r1, args from r2 */ SCM_PACK_OP_24 (tail_apply, 0), /* proc in r1, args from r2 */
}; };
static const scm_t_uint32 vm_builtin_values_code[] = { static const uint32_t vm_builtin_values_code[] = {
SCM_PACK_OP_24 (return_values, 0) /* vals from r1 */ SCM_PACK_OP_24 (return_values, 0) /* vals from r1 */
}; };
static const scm_t_uint32 vm_builtin_abort_to_prompt_code[] = { static const uint32_t vm_builtin_abort_to_prompt_code[] = {
SCM_PACK_OP_24 (assert_nargs_ge, 2), SCM_PACK_OP_24 (assert_nargs_ge, 2),
SCM_PACK_OP_24 (abort, 0), /* tag in r1, vals from r2 */ SCM_PACK_OP_24 (abort, 0), /* tag in r1, vals from r2 */
/* FIXME: Partial continuation should capture caller regs. */ /* FIXME: Partial continuation should capture caller regs. */
SCM_PACK_OP_24 (return_values, 0) /* vals from r1 */ SCM_PACK_OP_24 (return_values, 0) /* vals from r1 */
}; };
static const scm_t_uint32 vm_builtin_call_with_values_code[] = { static const uint32_t vm_builtin_call_with_values_code[] = {
SCM_PACK_OP_24 (assert_nargs_ee, 3), SCM_PACK_OP_24 (assert_nargs_ee, 3),
SCM_PACK_OP_24 (alloc_frame, 7), SCM_PACK_OP_24 (alloc_frame, 7),
SCM_PACK_OP_12_12 (mov, 0, 5), SCM_PACK_OP_12_12 (mov, 0, 5),
@ -636,12 +636,12 @@ static const scm_t_uint32 vm_builtin_call_with_values_code[] = {
SCM_PACK_OP_24 (tail_call_shuffle, 7) SCM_PACK_OP_24 (tail_call_shuffle, 7)
}; };
static const scm_t_uint32 vm_builtin_call_with_current_continuation_code[] = { static const uint32_t vm_builtin_call_with_current_continuation_code[] = {
SCM_PACK_OP_24 (assert_nargs_ee, 2), SCM_PACK_OP_24 (assert_nargs_ee, 2),
SCM_PACK_OP_24 (call_cc, 0) SCM_PACK_OP_24 (call_cc, 0)
}; };
static const scm_t_uint32 vm_handle_interrupt_code[] = { static const uint32_t vm_handle_interrupt_code[] = {
SCM_PACK_OP_24 (alloc_frame, 3), SCM_PACK_OP_24 (alloc_frame, 3),
SCM_PACK_OP_12_12 (mov, 0, 2), SCM_PACK_OP_12_12 (mov, 0, 2),
SCM_PACK_OP_24 (call, 2), SCM_PACK_OP_ARG_8_24 (0, 1), SCM_PACK_OP_24 (call, 2), SCM_PACK_OP_ARG_8_24 (0, 1),
@ -650,7 +650,7 @@ static const scm_t_uint32 vm_handle_interrupt_code[] = {
int int
scm_i_vm_is_boot_continuation_code (scm_t_uint32 *ip) scm_i_vm_is_boot_continuation_code (uint32_t *ip)
{ {
return ip == vm_boot_continuation_code; return ip == vm_boot_continuation_code;
} }
@ -863,11 +863,11 @@ static void
return_unused_stack_to_os (struct scm_vm *vp) return_unused_stack_to_os (struct scm_vm *vp)
{ {
#if HAVE_SYS_MMAN_H #if HAVE_SYS_MMAN_H
scm_t_uintptr lo = (scm_t_uintptr) vp->stack_bottom; uintptr_t lo = (uintptr_t) vp->stack_bottom;
scm_t_uintptr hi = (scm_t_uintptr) vp->sp; uintptr_t hi = (uintptr_t) vp->sp;
/* The second condition is needed to protect against wrap-around. */ /* The second condition is needed to protect against wrap-around. */
if (vp->sp_min_since_gc >= vp->stack_bottom && vp->sp >= vp->sp_min_since_gc) if (vp->sp_min_since_gc >= vp->stack_bottom && vp->sp >= vp->sp_min_since_gc)
lo = (scm_t_uintptr) vp->sp_min_since_gc; lo = (uintptr_t) vp->sp_min_since_gc;
lo &= ~(page_size - 1U); /* round down */ lo &= ~(page_size - 1U); /* round down */
hi &= ~(page_size - 1U); /* round down */ hi &= ~(page_size - 1U); /* round down */
@ -893,8 +893,8 @@ return_unused_stack_to_os (struct scm_vm *vp)
#define SLOT_MAP_CACHE_SIZE 32U #define SLOT_MAP_CACHE_SIZE 32U
struct slot_map_cache_entry struct slot_map_cache_entry
{ {
scm_t_uint32 *ip; uint32_t *ip;
const scm_t_uint8 *map; const uint8_t *map;
}; };
struct slot_map_cache struct slot_map_cache
@ -902,13 +902,13 @@ struct slot_map_cache
struct slot_map_cache_entry entries[SLOT_MAP_CACHE_SIZE]; struct slot_map_cache_entry entries[SLOT_MAP_CACHE_SIZE];
}; };
static const scm_t_uint8 * static const uint8_t *
find_slot_map (scm_t_uint32 *ip, struct slot_map_cache *cache) find_slot_map (uint32_t *ip, struct slot_map_cache *cache)
{ {
/* The lower two bits should be zero. FIXME: Use a better hash /* The lower two bits should be zero. FIXME: Use a better hash
function; we don't expose scm_raw_hashq currently. */ function; we don't expose scm_raw_hashq currently. */
size_t slot = (((scm_t_uintptr) ip) >> 2) % SLOT_MAP_CACHE_SIZE; size_t slot = (((uintptr_t) ip) >> 2) % SLOT_MAP_CACHE_SIZE;
const scm_t_uint8 *map; const uint8_t *map;
if (cache->entries[slot].ip == ip) if (cache->entries[slot].ip == ip)
map = cache->entries[slot].map; map = cache->entries[slot].map;
@ -941,7 +941,7 @@ scm_i_vm_mark_stack (struct scm_vm *vp, struct GC_ms_entry *mark_stack_ptr,
activation, due to multiple threads or per-instruction hooks, and activation, due to multiple threads or per-instruction hooks, and
providing slot maps for all points in a program would take a providing slot maps for all points in a program would take a
prohibitive amount of space. */ prohibitive amount of space. */
const scm_t_uint8 *slot_map = NULL; const uint8_t *slot_map = NULL;
void *upper = (void *) GC_greatest_plausible_heap_addr; void *upper = (void *) GC_greatest_plausible_heap_addr;
void *lower = (void *) GC_least_plausible_heap_addr; void *lower = (void *) GC_least_plausible_heap_addr;
struct slot_map_cache cache; struct slot_map_cache cache;
@ -1208,7 +1208,7 @@ scm_call_n (SCM proc, SCM *argv, size_t nargs)
SCM_FRAME_SET_DYNAMIC_LINK (return_fp, vp->fp); SCM_FRAME_SET_DYNAMIC_LINK (return_fp, vp->fp);
SCM_FRAME_LOCAL (return_fp, 0) = vm_boot_continuation; SCM_FRAME_LOCAL (return_fp, 0) = vm_boot_continuation;
vp->ip = (scm_t_uint32 *) vm_boot_continuation_code; vp->ip = (uint32_t *) vm_boot_continuation_code;
vp->fp = call_fp; vp->fp = call_fp;
SCM_FRAME_SET_RETURN_ADDRESS (call_fp, vp->ip); SCM_FRAME_SET_RETURN_ADDRESS (call_fp, vp->ip);

14
libguile/vm.h
View file

@ -45,10 +45,10 @@ enum scm_compare {
}; };
struct scm_vm { struct scm_vm {
scm_t_uint32 *ip; /* instruction pointer */ uint32_t *ip; /* instruction pointer */
union scm_vm_stack_element *sp; /* stack pointer */ union scm_vm_stack_element *sp; /* stack pointer */
union scm_vm_stack_element *fp; /* frame pointer */ union scm_vm_stack_element *fp; /* frame pointer */
scm_t_uint8 compare_result; /* flags register: a value from scm_compare */ uint8_t compare_result; /* flags register: a value from scm_compare */
union scm_vm_stack_element *stack_limit; /* stack limit address */ union scm_vm_stack_element *stack_limit; /* stack limit address */
int trace_level; /* traces enabled if trace_level > 0 */ int trace_level; /* traces enabled if trace_level > 0 */
union scm_vm_stack_element *sp_min_since_gc; /* deepest sp since last gc */ union scm_vm_stack_element *sp_min_since_gc; /* deepest sp since last gc */
@ -91,7 +91,7 @@ SCM_INTERNAL void scm_i_vm_free_stack (struct scm_vm *vp);
struct scm_vm_cont { struct scm_vm_cont {
/* IP of newest frame. */ /* IP of newest frame. */
scm_t_uint32 *ra; uint32_t *ra;
/* Offset of FP of newest frame, relative to stack top. */ /* Offset of FP of newest frame, relative to stack top. */
scm_t_ptrdiff fp_offset; scm_t_ptrdiff fp_offset;
/* Besides being the stack size, this is also the offset of the SP of /* Besides being the stack size, this is also the offset of the SP of
@ -103,7 +103,7 @@ struct scm_vm_cont {
offsets from the stack top of this scm_vm_cont. */ offsets from the stack top of this scm_vm_cont. */
scm_t_dynstack *dynstack; scm_t_dynstack *dynstack;
/* See the continuation is partial and/or rewindable. */ /* See the continuation is partial and/or rewindable. */
scm_t_uint32 flags; uint32_t flags;
}; };
#define SCM_VM_CONT_P(OBJ) (SCM_HAS_TYP7 (OBJ, scm_tc7_vm_cont)) #define SCM_VM_CONT_P(OBJ) (SCM_HAS_TYP7 (OBJ, scm_tc7_vm_cont))
@ -118,13 +118,13 @@ SCM_INTERNAL SCM scm_i_capture_current_stack (void);
SCM_INTERNAL SCM scm_i_vm_capture_stack (union scm_vm_stack_element *stack_top, SCM_INTERNAL SCM scm_i_vm_capture_stack (union scm_vm_stack_element *stack_top,
union scm_vm_stack_element *fp, union scm_vm_stack_element *fp,
union scm_vm_stack_element *sp, union scm_vm_stack_element *sp,
scm_t_uint32 *ra, uint32_t *ra,
scm_t_dynstack *dynstack, scm_t_dynstack *dynstack,
scm_t_uint32 flags); uint32_t flags);
SCM_INTERNAL int scm_i_vm_cont_to_frame (SCM cont, struct scm_frame *frame); SCM_INTERNAL int scm_i_vm_cont_to_frame (SCM cont, struct scm_frame *frame);
SCM_INTERNAL void scm_i_vm_cont_print (SCM x, SCM port, SCM_INTERNAL void scm_i_vm_cont_print (SCM x, SCM port,
scm_print_state *pstate); scm_print_state *pstate);
SCM_INTERNAL int scm_i_vm_is_boot_continuation_code (scm_t_uint32 *ip); SCM_INTERNAL int scm_i_vm_is_boot_continuation_code (uint32_t *ip);
SCM_INTERNAL void scm_bootstrap_vm (void); SCM_INTERNAL void scm_bootstrap_vm (void);
SCM_INTERNAL void scm_init_vm (void); SCM_INTERNAL void scm_init_vm (void);

2
libguile/vports.c
View file

@ -60,7 +60,7 @@ struct soft_port {
SCM read_char; SCM read_char;
SCM close; SCM close;
SCM input_waiting; SCM input_waiting;
scm_t_uint8 encode_buf[ENCODE_BUF_SIZE]; uint8_t encode_buf[ENCODE_BUF_SIZE];
size_t encode_cur; size_t encode_cur;
size_t encode_end; size_t encode_end;
}; };

72
test-suite/standalone/test-conversion.c
View file

@ -43,7 +43,7 @@
static void static void
test_1 (const char *str, scm_t_intmax min, scm_t_intmax max, test_1 (const char *str, intmax_t min, intmax_t max,
int result) int result)
{ {
int r = scm_is_signed_integer (scm_c_eval_string (str), min, max); int r = scm_is_signed_integer (scm_c_eval_string (str), min, max);
@ -83,7 +83,7 @@ test_is_signed_integer ()
test_1 ("(- most-negative-fixnum 1)", test_1 ("(- most-negative-fixnum 1)",
INTMAX_MIN, INTMAX_MAX, INTMAX_MIN, INTMAX_MAX,
1); 1);
if (sizeof (scm_t_intmax) == 8) if (sizeof (intmax_t) == 8)
{ {
test_1 ("(- (expt 2 63) 1)", test_1 ("(- (expt 2 63) 1)",
INTMAX_MIN, INTMAX_MAX, INTMAX_MIN, INTMAX_MAX,
@ -98,7 +98,7 @@ test_is_signed_integer ()
INTMAX_MIN, INTMAX_MAX, INTMAX_MIN, INTMAX_MAX,
0); 0);
} }
else if (sizeof (scm_t_intmax) == 4) else if (sizeof (intmax_t) == 4)
{ {
test_1 ("(- (expt 2 31) 1)", test_1 ("(- (expt 2 31) 1)",
INTMAX_MIN, INTMAX_MAX, INTMAX_MIN, INTMAX_MAX,
@ -129,7 +129,7 @@ test_is_signed_integer ()
} }
static void static void
test_2 (const char *str, scm_t_uintmax min, scm_t_uintmax max, test_2 (const char *str, uintmax_t min, uintmax_t max,
int result) int result)
{ {
int r = scm_is_unsigned_integer (scm_c_eval_string (str), min, max); int r = scm_is_unsigned_integer (scm_c_eval_string (str), min, max);
@ -169,7 +169,7 @@ test_is_unsigned_integer ()
test_2 ("(- most-negative-fixnum 1)", test_2 ("(- most-negative-fixnum 1)",
0, UINTMAX_MAX, 0, UINTMAX_MAX,
0); 0);
if (sizeof (scm_t_intmax) == 8) if (sizeof (intmax_t) == 8)
{ {
test_2 ("(- (expt 2 64) 1)", test_2 ("(- (expt 2 64) 1)",
0, UINTMAX_MAX, 0, UINTMAX_MAX,
@ -178,7 +178,7 @@ test_is_unsigned_integer ()
0, UINTMAX_MAX, 0, UINTMAX_MAX,
0); 0);
} }
else if (sizeof (scm_t_intmax) == 4) else if (sizeof (intmax_t) == 4)
{ {
test_2 ("(- (expt 2 32) 1)", test_2 ("(- (expt 2 32) 1)",
0, UINTMAX_MAX, 0, UINTMAX_MAX,
@ -204,8 +204,8 @@ test_is_unsigned_integer ()
typedef struct { typedef struct {
SCM val; SCM val;
scm_t_intmax min, max; intmax_t min, max;
scm_t_intmax result; intmax_t result;
} to_signed_data; } to_signed_data;
static SCM static SCM
@ -241,8 +241,8 @@ to_signed_integer_body (void *data)
} }
static void static void
test_3 (const char *str, scm_t_intmax min, scm_t_intmax max, test_3 (const char *str, intmax_t min, intmax_t max,
scm_t_intmax result, int range_error, int type_error) intmax_t result, int range_error, int type_error)
{ {
to_signed_data data; to_signed_data data;
data.val = scm_c_eval_string (str); data.val = scm_c_eval_string (str);
@ -321,7 +321,7 @@ test_to_signed_integer ()
test_3 ("(- most-negative-fixnum 1)", test_3 ("(- most-negative-fixnum 1)",
INTMAX_MIN, INTMAX_MAX, INTMAX_MIN, INTMAX_MAX,
SCM_MOST_NEGATIVE_FIXNUM-1, 0, 0); SCM_MOST_NEGATIVE_FIXNUM-1, 0, 0);
if (sizeof (scm_t_intmax) == 8) if (sizeof (intmax_t) == 8)
{ {
test_3 ("(- (expt 2 63) 1)", test_3 ("(- (expt 2 63) 1)",
INTMAX_MIN, INTMAX_MAX, INTMAX_MIN, INTMAX_MAX,
@ -339,7 +339,7 @@ test_to_signed_integer ()
INTMAX_MIN, INTMAX_MAX, INTMAX_MIN, INTMAX_MAX,
0, 1, 0); 0, 1, 0);
} }
else if (sizeof (scm_t_intmax) == 4) else if (sizeof (intmax_t) == 4)
{ {
test_3 ("(- (expt 2 31) 1)", test_3 ("(- (expt 2 31) 1)",
INTMAX_MIN, INTMAX_MAX, INTMAX_MIN, INTMAX_MAX,
@ -363,8 +363,8 @@ test_to_signed_integer ()
typedef struct { typedef struct {
SCM val; SCM val;
scm_t_uintmax min, max; uintmax_t min, max;
scm_t_uintmax result; uintmax_t result;
} to_unsigned_data; } to_unsigned_data;
static SCM static SCM
@ -376,8 +376,8 @@ to_unsigned_integer_body (void *data)
} }
static void static void
test_4 (const char *str, scm_t_uintmax min, scm_t_uintmax max, test_4 (const char *str, uintmax_t min, uintmax_t max,
scm_t_uintmax result, int range_error, int type_error) uintmax_t result, int range_error, int type_error)
{ {
to_unsigned_data data; to_unsigned_data data;
data.val = scm_c_eval_string (str); data.val = scm_c_eval_string (str);
@ -447,7 +447,7 @@ test_to_unsigned_integer ()
test_4 ("(+ most-positive-fixnum 1)", test_4 ("(+ most-positive-fixnum 1)",
0, UINTMAX_MAX, 0, UINTMAX_MAX,
SCM_MOST_POSITIVE_FIXNUM+1, 0, 0); SCM_MOST_POSITIVE_FIXNUM+1, 0, 0);
if (sizeof (scm_t_intmax) == 8) if (sizeof (intmax_t) == 8)
{ {
test_4 ("(- (expt 2 64) 1)", test_4 ("(- (expt 2 64) 1)",
0, UINTMAX_MAX, 0, UINTMAX_MAX,
@ -456,7 +456,7 @@ test_to_unsigned_integer ()
0, UINTMAX_MAX, 0, UINTMAX_MAX,
0, 1, 0); 0, 1, 0);
} }
else if (sizeof (scm_t_intmax) == 4) else if (sizeof (intmax_t) == 4)
{ {
test_4 ("(- (expt 2 32) 1)", test_4 ("(- (expt 2 32) 1)",
0, UINTMAX_MAX, 0, UINTMAX_MAX,
@ -470,7 +470,7 @@ test_to_unsigned_integer ()
} }
static void static void
test_5 (scm_t_intmax val, const char *result) test_5 (intmax_t val, const char *result)
{ {
SCM res = scm_c_eval_string (result); SCM res = scm_c_eval_string (result);
if (scm_is_false (scm_equal_p (scm_from_signed_integer (val), res))) if (scm_is_false (scm_equal_p (scm_from_signed_integer (val), res)))
@ -485,12 +485,12 @@ static void
test_from_signed_integer () test_from_signed_integer ()
{ {
test_5 (12, "12"); test_5 (12, "12");
if (sizeof (scm_t_intmax) == 8) if (sizeof (intmax_t) == 8)
{ {
test_5 (INTMAX_MAX, "(- (expt 2 63) 1)"); test_5 (INTMAX_MAX, "(- (expt 2 63) 1)");
test_5 (INTMAX_MIN, "(- (expt 2 63))"); test_5 (INTMAX_MIN, "(- (expt 2 63))");
} }
else if (sizeof (scm_t_intmax) == 4) else if (sizeof (intmax_t) == 4)
{ {
test_5 (INTMAX_MAX, "(- (expt 2 31) 1)"); test_5 (INTMAX_MAX, "(- (expt 2 31) 1)");
test_5 (INTMAX_MIN, "(- (expt 2 31))"); test_5 (INTMAX_MIN, "(- (expt 2 31))");
@ -502,7 +502,7 @@ test_from_signed_integer ()
} }
static void static void
test_6 (scm_t_uintmax val, const char *result) test_6 (uintmax_t val, const char *result)
{ {
SCM res = scm_c_eval_string (result); SCM res = scm_c_eval_string (result);
if (scm_is_false (scm_equal_p (scm_from_unsigned_integer (val), res))) if (scm_is_false (scm_equal_p (scm_from_unsigned_integer (val), res)))
@ -518,11 +518,11 @@ static void
test_from_unsigned_integer () test_from_unsigned_integer ()
{ {
test_6 (12, "12"); test_6 (12, "12");
if (sizeof (scm_t_intmax) == 8) if (sizeof (intmax_t) == 8)
{ {
test_6 (UINTMAX_MAX, "(- (expt 2 64) 1)"); test_6 (UINTMAX_MAX, "(- (expt 2 64) 1)");
} }
else if (sizeof (scm_t_intmax) == 4) else if (sizeof (intmax_t) == 4)
{ {
test_6 (UINTMAX_MAX, "(- (expt 2 32) 1)"); test_6 (UINTMAX_MAX, "(- (expt 2 32) 1)");
} }
@ -531,7 +531,7 @@ test_from_unsigned_integer ()
} }
static void static void
test_7s (SCM n, scm_t_intmax c_n, const char *result, const char *func) test_7s (SCM n, intmax_t c_n, const char *result, const char *func)
{ {
SCM r = scm_c_eval_string (result); SCM r = scm_c_eval_string (result);
@ -545,7 +545,7 @@ test_7s (SCM n, scm_t_intmax c_n, const char *result, const char *func)
#define TEST_7S(func,arg,res) test_7s (func(arg), arg, res, #func) #define TEST_7S(func,arg,res) test_7s (func(arg), arg, res, #func)
static void static void
test_7u (SCM n, scm_t_uintmax c_n, const char *result, const char *func) test_7u (SCM n, uintmax_t c_n, const char *result, const char *func)
{ {
SCM r = scm_c_eval_string (result); SCM r = scm_c_eval_string (result);
@ -560,8 +560,8 @@ test_7u (SCM n, scm_t_uintmax c_n, const char *result, const char *func)
typedef struct { typedef struct {
SCM val; SCM val;
scm_t_intmax (*func) (SCM); intmax_t (*func) (SCM);
scm_t_intmax result; intmax_t result;
} to_signed_func_data; } to_signed_func_data;
static SCM static SCM
@ -573,8 +573,8 @@ to_signed_func_body (void *data)
} }
static void static void
test_8s (const char *str, scm_t_intmax (*func) (SCM), const char *func_name, test_8s (const char *str, intmax_t (*func) (SCM), const char *func_name,
scm_t_intmax result, int range_error, int type_error) intmax_t result, int range_error, int type_error)
{ {
to_signed_func_data data; to_signed_func_data data;
data.val = scm_c_eval_string (str); data.val = scm_c_eval_string (str);
@ -618,8 +618,8 @@ test_8s (const char *str, scm_t_intmax (*func) (SCM), const char *func_name,
typedef struct { typedef struct {
SCM val; SCM val;
scm_t_uintmax (*func) (SCM); uintmax_t (*func) (SCM);
scm_t_uintmax result; uintmax_t result;
} to_unsigned_func_data; } to_unsigned_func_data;
static SCM static SCM
@ -631,8 +631,8 @@ to_unsigned_func_body (void *data)
} }
static void static void
test_8u (const char *str, scm_t_uintmax (*func) (SCM), const char *func_name, test_8u (const char *str, uintmax_t (*func) (SCM), const char *func_name,
scm_t_uintmax result, int range_error, int type_error) uintmax_t result, int range_error, int type_error)
{ {
to_unsigned_func_data data; to_unsigned_func_data data;
data.val = scm_c_eval_string (str); data.val = scm_c_eval_string (str);
@ -679,8 +679,8 @@ test_8u (const char *str, scm_t_uintmax (*func) (SCM), const char *func_name,
need to give them a common return type. need to give them a common return type.
*/ */
#define DEFSTST(f) static scm_t_intmax tst_##f (SCM x) { return f(x); } #define DEFSTST(f) static intmax_t tst_##f (SCM x) { return f(x); }
#define DEFUTST(f) static scm_t_uintmax tst_##f (SCM x) { return f(x); } #define DEFUTST(f) static uintmax_t tst_##f (SCM x) { return f(x); }
DEFSTST (scm_to_schar) DEFSTST (scm_to_schar)
DEFUTST (scm_to_uchar) DEFUTST (scm_to_uchar)

152
test-suite/standalone/test-ffi-lib.c
View file

@ -31,184 +31,184 @@ void test_ffi_v_ (void)
return; return;
} }
void test_ffi_v_u8 (scm_t_uint8 a); void test_ffi_v_u8 (uint8_t a);
void test_ffi_v_u8 (scm_t_uint8 a) void test_ffi_v_u8 (uint8_t a)
{ {
return; return;
} }
void test_ffi_v_s64 (scm_t_int64 a); void test_ffi_v_s64 (int64_t a);
void test_ffi_v_s64 (scm_t_int64 a) void test_ffi_v_s64 (int64_t a)
{ {
return; return;
} }
scm_t_int8 test_ffi_s8_ (void); int8_t test_ffi_s8_ (void);
scm_t_int8 test_ffi_s8_ (void) int8_t test_ffi_s8_ (void)
{ {
return -100; return -100;
} }
scm_t_int8 test_ffi_s8_u8 (scm_t_uint8 a); int8_t test_ffi_s8_u8 (uint8_t a);
scm_t_int8 test_ffi_s8_u8 (scm_t_uint8 a) int8_t test_ffi_s8_u8 (uint8_t a)
{ {
return -100 + a; return -100 + a;
} }
scm_t_int8 test_ffi_s8_s64 (scm_t_int64 a); int8_t test_ffi_s8_s64 (int64_t a);
scm_t_int8 test_ffi_s8_s64 (scm_t_int64 a) int8_t test_ffi_s8_s64 (int64_t a)
{ {
return -100 + a; return -100 + a;
} }
scm_t_uint8 test_ffi_u8_ (void); uint8_t test_ffi_u8_ (void);
scm_t_uint8 test_ffi_u8_ (void) uint8_t test_ffi_u8_ (void)
{ {
return 200; return 200;
} }
scm_t_uint8 test_ffi_u8_u8 (scm_t_uint8 a); uint8_t test_ffi_u8_u8 (uint8_t a);
scm_t_uint8 test_ffi_u8_u8 (scm_t_uint8 a) uint8_t test_ffi_u8_u8 (uint8_t a)
{ {
return 200 + a; return 200 + a;
} }
scm_t_uint8 test_ffi_u8_s64 (scm_t_int64 a); uint8_t test_ffi_u8_s64 (int64_t a);
scm_t_uint8 test_ffi_u8_s64 (scm_t_int64 a) uint8_t test_ffi_u8_s64 (int64_t a)
{ {
return 200 + a; return 200 + a;
} }
scm_t_int16 test_ffi_s16_ (void); int16_t test_ffi_s16_ (void);
scm_t_int16 test_ffi_s16_ (void) int16_t test_ffi_s16_ (void)
{ {
return -20000; return -20000;
} }
scm_t_int16 test_ffi_s16_u8 (scm_t_uint8 a); int16_t test_ffi_s16_u8 (uint8_t a);
scm_t_int16 test_ffi_s16_u8 (scm_t_uint8 a) int16_t test_ffi_s16_u8 (uint8_t a)
{ {
return -20000 + a; return -20000 + a;
} }
scm_t_int16 test_ffi_s16_s64 (scm_t_int64 a); int16_t test_ffi_s16_s64 (int64_t a);
scm_t_int16 test_ffi_s16_s64 (scm_t_int64 a) int16_t test_ffi_s16_s64 (int64_t a)
{ {
return -20000 + a; return -20000 + a;
} }
scm_t_uint16 test_ffi_u16_ (void); uint16_t test_ffi_u16_ (void);
scm_t_uint16 test_ffi_u16_ (void) uint16_t test_ffi_u16_ (void)
{ {
return 40000; return 40000;
} }
scm_t_uint16 test_ffi_u16_u8 (scm_t_uint8 a); uint16_t test_ffi_u16_u8 (uint8_t a);
scm_t_uint16 test_ffi_u16_u8 (scm_t_uint8 a) uint16_t test_ffi_u16_u8 (uint8_t a)
{ {
return 40000 + a; return 40000 + a;
} }
scm_t_uint16 test_ffi_u16_s64 (scm_t_int64 a); uint16_t test_ffi_u16_s64 (int64_t a);
scm_t_uint16 test_ffi_u16_s64 (scm_t_int64 a) uint16_t test_ffi_u16_s64 (int64_t a)
{ {
return 40000 + a; return 40000 + a;
} }
scm_t_int32 test_ffi_s32_ (void); int32_t test_ffi_s32_ (void);
scm_t_int32 test_ffi_s32_ (void) int32_t test_ffi_s32_ (void)
{ {
return -2000000000; return -2000000000;
} }
scm_t_int32 test_ffi_s32_u8 (scm_t_uint8 a); int32_t test_ffi_s32_u8 (uint8_t a);
scm_t_int32 test_ffi_s32_u8 (scm_t_uint8 a) int32_t test_ffi_s32_u8 (uint8_t a)
{ {
return -2000000000 + a; return -2000000000 + a;
} }
scm_t_int32 test_ffi_s32_s64 (scm_t_int64 a); int32_t test_ffi_s32_s64 (int64_t a);
scm_t_int32 test_ffi_s32_s64 (scm_t_int64 a) int32_t test_ffi_s32_s64 (int64_t a)
{ {
return -2000000000 + a; return -2000000000 + a;
} }
scm_t_uint32 test_ffi_u32_ (void); uint32_t test_ffi_u32_ (void);
scm_t_uint32 test_ffi_u32_ (void) uint32_t test_ffi_u32_ (void)
{ {
return 4000000000U; return 4000000000U;
} }
scm_t_uint32 test_ffi_u32_u8 (scm_t_uint8 a); uint32_t test_ffi_u32_u8 (uint8_t a);
scm_t_uint32 test_ffi_u32_u8 (scm_t_uint8 a) uint32_t test_ffi_u32_u8 (uint8_t a)
{ {
return 4000000000U + a; return 4000000000U + a;
} }
scm_t_uint32 test_ffi_u32_s64 (scm_t_int64 a); uint32_t test_ffi_u32_s64 (int64_t a);
scm_t_uint32 test_ffi_u32_s64 (scm_t_int64 a) uint32_t test_ffi_u32_s64 (int64_t a)
{ {
return 4000000000U + a; return 4000000000U + a;
} }
/* FIXME: use 64-bit literals */ /* FIXME: use 64-bit literals */
scm_t_int64 test_ffi_s64_ (void); int64_t test_ffi_s64_ (void);
scm_t_int64 test_ffi_s64_ (void) int64_t test_ffi_s64_ (void)
{ {
return -2000000000; return -2000000000;
} }
scm_t_int64 test_ffi_s64_u8 (scm_t_uint8 a); int64_t test_ffi_s64_u8 (uint8_t a);
scm_t_int64 test_ffi_s64_u8 (scm_t_uint8 a) int64_t test_ffi_s64_u8 (uint8_t a)
{ {
return -2000000000 + a; return -2000000000 + a;
} }
scm_t_int64 test_ffi_s64_s64 (scm_t_int64 a); int64_t test_ffi_s64_s64 (int64_t a);
scm_t_int64 test_ffi_s64_s64 (scm_t_int64 a) int64_t test_ffi_s64_s64 (int64_t a)
{ {
return -2000000000 + a; return -2000000000 + a;
} }
scm_t_uint64 test_ffi_u64_ (void); uint64_t test_ffi_u64_ (void);
scm_t_uint64 test_ffi_u64_ (void) uint64_t test_ffi_u64_ (void)
{ {
return 4000000000UL; return 4000000000UL;
} }
scm_t_uint64 test_ffi_u64_u8 (scm_t_uint8 a); uint64_t test_ffi_u64_u8 (uint8_t a);
scm_t_uint64 test_ffi_u64_u8 (scm_t_uint8 a) uint64_t test_ffi_u64_u8 (uint8_t a)
{ {
return 4000000000UL + a; return 4000000000UL + a;
} }
scm_t_uint64 test_ffi_u64_s64 (scm_t_int64 a); uint64_t test_ffi_u64_s64 (int64_t a);
scm_t_uint64 test_ffi_u64_s64 (scm_t_int64 a) uint64_t test_ffi_u64_s64 (int64_t a)
{ {
return 4000000000UL + a; return 4000000000UL + a;
} }
scm_t_int64 test_ffi_sum (scm_t_int8 a, scm_t_int16 b, int64_t test_ffi_sum (int8_t a, int16_t b,
scm_t_int32 c, scm_t_int64 d); int32_t c, int64_t d);
scm_t_int64 test_ffi_sum (scm_t_int8 a, scm_t_int16 b, int64_t test_ffi_sum (int8_t a, int16_t b,
scm_t_int32 c, scm_t_int64 d) int32_t c, int64_t d)
{ {
return d + c + b + a; return d + c + b + a;
} }
scm_t_int64 test_ffi_sum_many (scm_t_uint8 a, scm_t_uint16 b, int64_t test_ffi_sum_many (uint8_t a, uint16_t b,
scm_t_uint32 c, scm_t_uint64 d, uint32_t c, uint64_t d,
scm_t_int8 e, scm_t_int16 f, int8_t e, int16_t f,
scm_t_int32 g, scm_t_int64 h, int32_t g, int64_t h,
scm_t_int8 i, scm_t_int16 j, int8_t i, int16_t j,
scm_t_int32 k, scm_t_int64 l); int32_t k, int64_t l);
scm_t_int64 test_ffi_sum_many (scm_t_uint8 a, scm_t_uint16 b, int64_t test_ffi_sum_many (uint8_t a, uint16_t b,
scm_t_uint32 c, scm_t_uint64 d, uint32_t c, uint64_t d,
scm_t_int8 e, scm_t_int16 f, int8_t e, int16_t f,
scm_t_int32 g, scm_t_int64 h, int32_t g, int64_t h,
scm_t_int8 i, scm_t_int16 j, int8_t i, int16_t j,
scm_t_int32 k, scm_t_int64 l) int32_t k, int64_t l)
{ {
return l + k + j + i + h + g + f + e + d + c + b + a; return l + k + j + i + h + g + f + e + d + c + b + a;
} }
@ -216,20 +216,20 @@ scm_t_int64 test_ffi_sum_many (scm_t_uint8 a, scm_t_uint16 b,
struct foo struct foo
{ {
scm_t_int8 a; int8_t a;
scm_t_int16 b; int16_t b;
scm_t_int32 c; int32_t c;
scm_t_int64 d; int64_t d;
}; };
scm_t_int64 test_ffi_sum_struct (struct foo foo); int64_t test_ffi_sum_struct (struct foo foo);
scm_t_int64 test_ffi_sum_struct (struct foo foo) int64_t test_ffi_sum_struct (struct foo foo)
{ {
return foo.d + foo.c + foo.b + foo.a; return foo.d + foo.c + foo.b + foo.a;
} }
void* test_ffi_memcpy (void *dest, void *src, scm_t_int32 n); void* test_ffi_memcpy (void *dest, void *src, int32_t n);
void* test_ffi_memcpy (void *dest, void *src, scm_t_int32 n) void* test_ffi_memcpy (void *dest, void *src, int32_t n)
{ {
return memcpy (dest, src, n); return memcpy (dest, src, n);
} }

2
test-suite/standalone/test-scm-take-u8vector.c
View file

@ -35,7 +35,7 @@ do_test (void *result)
{ {
#define LEN 123 #define LEN 123
SCM u8v; SCM u8v;
scm_t_uint8 *data; uint8_t *data;
scm_t_array_handle handle; scm_t_array_handle handle;
data = scm_malloc (LEN); data = scm_malloc (LEN);

2
test-suite/standalone/test-srfi-4.c
View file

@ -40,7 +40,7 @@ test_writable_elements ()
size_t len; size_t len;
ssize_t inc; ssize_t inc;
scm_t_array_handle h; scm_t_array_handle h;
scm_t_uint32 *elts = scm_u32vector_writable_elements (v, &h, &len, &inc); uint32_t *elts = scm_u32vector_writable_elements (v, &h, &len, &inc);
assert (len == 4); assert (len == 4);
assert (inc == 1); assert (inc == 1);
assert (elts[0] == 1); assert (elts[0] == 1);