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

Simple vectors are just vectors

Browse source 
* doc/ref/api-data.texi: Remove references to 'simple vectors'.
* libguile/vectors.h (SCM_VECTOR_REF,SCM_VECTOR_SET, SCM_VECTOR_LENGHT):
  Renamed from SCM_SIMPLE_VECTOR_REF, SCM_SIMPLE_VECTOR_SET,
  SCM_SIMPLE_VECTOR_LENGTH.
  (scm_is_simple_vector): Remove.

Elsewhere fix uses of SCM_SIMPLE_VECTOR_xxx or scm_is_simple_vector.
This commit is contained in:
Daniel Llorens 2020-02-03 14:30:26 +01:00
parent 6c97c8108e
commit 40dbe69be5
27 changed files with 305 additions and 291 deletions
Download patch file Download diff file Expand all files Collapse all files

6
libguile/arrays.c
View file

@ -654,12 +654,12 @@ SCM_DEFINE (scm_transpose_array, "transpose-array", 1, 0, 1,
return ra;
default:
vargs = scm_vector (args);
if (SCM_SIMPLE_VECTOR_LENGTH (vargs) != SCM_I_ARRAY_NDIM (ra))
if (SCM_VECTOR_LENGTH (vargs) != SCM_I_ARRAY_NDIM (ra))
SCM_WRONG_NUM_ARGS ();
ndim = 0;
for (k = 0; k < SCM_I_ARRAY_NDIM (ra); k++)
{
i = scm_to_signed_integer (SCM_SIMPLE_VECTOR_REF (vargs, k),
i = scm_to_signed_integer (SCM_VECTOR_REF (vargs, k),
0, SCM_I_ARRAY_NDIM(ra));
if (ndim < i)
ndim = i;
@ -675,7 +675,7 @@ SCM_DEFINE (scm_transpose_array, "transpose-array", 1, 0, 1,
}
for (k = SCM_I_ARRAY_NDIM (ra); k--;)
{
i = scm_to_int (SCM_SIMPLE_VECTOR_REF (vargs, k));
i = scm_to_int (SCM_VECTOR_REF (vargs, k));
s = &(SCM_I_ARRAY_DIMS (ra)[k]);
r = &(SCM_I_ARRAY_DIMS (res)[i]);
if (r->ubnd < r->lbnd)

6
libguile/eval.c
View file

@ -157,9 +157,9 @@ static void prepare_boot_closure_env_for_eval (SCM proc, unsigned int argc,
#define CADDR(x) SCM_CADDR(x)
#define CDDDR(x) SCM_CDDDR(x)
#define VECTOR_REF(v, i) (SCM_SIMPLE_VECTOR_REF (v, i))
#define VECTOR_SET(v, i, x) (SCM_SIMPLE_VECTOR_SET (v, i, x))
#define VECTOR_LENGTH(v) (SCM_SIMPLE_VECTOR_LENGTH (v))
#define VECTOR_REF(v, i) (SCM_VECTOR_REF (v, i))
#define VECTOR_SET(v, i, x) (SCM_VECTOR_SET (v, i, x))
#define VECTOR_LENGTH(v) (SCM_VECTOR_LENGTH (v))
static SCM
make_env (int n, SCM init, SCM next)

78
libguile/filesys.c
View file

@ -346,57 +346,57 @@ scm_stat2scm (struct stat_or_stat64 *stat_temp)
{
SCM ans = scm_c_make_vector (18, SCM_UNSPECIFIED);
SCM_SIMPLE_VECTOR_SET(ans, 0, scm_from_ulong (stat_temp->st_dev));
SCM_SIMPLE_VECTOR_SET(ans, 1, scm_from_ino_t_or_ino64_t (stat_temp->st_ino));
SCM_SIMPLE_VECTOR_SET(ans, 2, scm_from_ulong (stat_temp->st_mode));
SCM_SIMPLE_VECTOR_SET(ans, 3, scm_from_ulong (stat_temp->st_nlink));
SCM_SIMPLE_VECTOR_SET(ans, 4, scm_from_ulong (stat_temp->st_uid));
SCM_SIMPLE_VECTOR_SET(ans, 5, scm_from_ulong (stat_temp->st_gid));
SCM_VECTOR_SET(ans, 0, scm_from_ulong (stat_temp->st_dev));
SCM_VECTOR_SET(ans, 1, scm_from_ino_t_or_ino64_t (stat_temp->st_ino));
SCM_VECTOR_SET(ans, 2, scm_from_ulong (stat_temp->st_mode));
SCM_VECTOR_SET(ans, 3, scm_from_ulong (stat_temp->st_nlink));
SCM_VECTOR_SET(ans, 4, scm_from_ulong (stat_temp->st_uid));
SCM_VECTOR_SET(ans, 5, scm_from_ulong (stat_temp->st_gid));
#ifdef HAVE_STRUCT_STAT_ST_RDEV
SCM_SIMPLE_VECTOR_SET(ans, 6, scm_from_ulong (stat_temp->st_rdev));
SCM_VECTOR_SET(ans, 6, scm_from_ulong (stat_temp->st_rdev));
#else
SCM_SIMPLE_VECTOR_SET(ans, 6, SCM_BOOL_F);
SCM_VECTOR_SET(ans, 6, SCM_BOOL_F);
#endif
SCM_SIMPLE_VECTOR_SET(ans, 7, scm_from_off_t_or_off64_t (stat_temp->st_size));
SCM_SIMPLE_VECTOR_SET(ans, 8, scm_from_ulong (stat_temp->st_atime));
SCM_SIMPLE_VECTOR_SET(ans, 9, scm_from_ulong (stat_temp->st_mtime));
SCM_SIMPLE_VECTOR_SET(ans, 10, scm_from_ulong (stat_temp->st_ctime));
SCM_VECTOR_SET(ans, 7, scm_from_off_t_or_off64_t (stat_temp->st_size));
SCM_VECTOR_SET(ans, 8, scm_from_ulong (stat_temp->st_atime));
SCM_VECTOR_SET(ans, 9, scm_from_ulong (stat_temp->st_mtime));
SCM_VECTOR_SET(ans, 10, scm_from_ulong (stat_temp->st_ctime));
#ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
SCM_SIMPLE_VECTOR_SET(ans, 11, scm_from_ulong (stat_temp->st_blksize));
SCM_VECTOR_SET(ans, 11, scm_from_ulong (stat_temp->st_blksize));
#else
SCM_SIMPLE_VECTOR_SET(ans, 11, scm_from_ulong (4096L));
SCM_VECTOR_SET(ans, 11, scm_from_ulong (4096L));
#endif
#ifdef HAVE_STRUCT_STAT_ST_BLOCKS
SCM_SIMPLE_VECTOR_SET(ans, 12, scm_from_blkcnt_t_or_blkcnt64_t (stat_temp->st_blocks));
SCM_VECTOR_SET(ans, 12, scm_from_blkcnt_t_or_blkcnt64_t (stat_temp->st_blocks));
#else
SCM_SIMPLE_VECTOR_SET(ans, 12, SCM_BOOL_F);
SCM_VECTOR_SET(ans, 12, SCM_BOOL_F);
#endif
{
int mode = stat_temp->st_mode;
if (S_ISREG (mode))
SCM_SIMPLE_VECTOR_SET(ans, 13, scm_sym_regular);
SCM_VECTOR_SET(ans, 13, scm_sym_regular);
else if (S_ISDIR (mode))
SCM_SIMPLE_VECTOR_SET(ans, 13, scm_sym_directory);
SCM_VECTOR_SET(ans, 13, scm_sym_directory);
#ifdef S_ISLNK
/* systems without symlinks probably don't have S_ISLNK */
else if (S_ISLNK (mode))
SCM_SIMPLE_VECTOR_SET(ans, 13, scm_sym_symlink);
SCM_VECTOR_SET(ans, 13, scm_sym_symlink);
#endif
else if (S_ISBLK (mode))
SCM_SIMPLE_VECTOR_SET(ans, 13, scm_sym_block_special);
SCM_VECTOR_SET(ans, 13, scm_sym_block_special);
else if (S_ISCHR (mode))
SCM_SIMPLE_VECTOR_SET(ans, 13, scm_sym_char_special);
SCM_VECTOR_SET(ans, 13, scm_sym_char_special);
else if (S_ISFIFO (mode))
SCM_SIMPLE_VECTOR_SET(ans, 13, scm_sym_fifo);
SCM_VECTOR_SET(ans, 13, scm_sym_fifo);
#ifdef S_ISSOCK
else if (S_ISSOCK (mode))
SCM_SIMPLE_VECTOR_SET(ans, 13, scm_sym_sock);
SCM_VECTOR_SET(ans, 13, scm_sym_sock);
#endif
else
SCM_SIMPLE_VECTOR_SET(ans, 13, scm_sym_unknown);
SCM_VECTOR_SET(ans, 13, scm_sym_unknown);
SCM_SIMPLE_VECTOR_SET(ans, 14, scm_from_int ((~S_IFMT) & mode));
SCM_VECTOR_SET(ans, 14, scm_from_int ((~S_IFMT) & mode));
/* the layout of the bits in ve[14] is intended to be portable.
If there are systems that don't follow the usual convention,
@ -425,24 +425,24 @@ scm_stat2scm (struct stat_or_stat64 *stat_temp)
tmp <<= 1;
if (S_IXOTH & mode) tmp += 1;
SCM_SIMPLE_VECTOR_SET(ans, 14, scm_from_int (tmp));
SCM_VECTOR_SET(ans, 14, scm_from_int (tmp));
*/
}
#ifdef HAVE_STRUCT_STAT_ST_ATIM
SCM_SIMPLE_VECTOR_SET(ans, 15, scm_from_long (stat_temp->st_atim.tv_nsec));
SCM_VECTOR_SET(ans, 15, scm_from_long (stat_temp->st_atim.tv_nsec));
#else
SCM_SIMPLE_VECTOR_SET(ans, 15, SCM_I_MAKINUM (0));
SCM_VECTOR_SET(ans, 15, SCM_I_MAKINUM (0));
#endif
#ifdef HAVE_STRUCT_STAT_ST_MTIM
SCM_SIMPLE_VECTOR_SET(ans, 16, scm_from_long (stat_temp->st_mtim.tv_nsec));
SCM_VECTOR_SET(ans, 16, scm_from_long (stat_temp->st_mtim.tv_nsec));
#else
SCM_SIMPLE_VECTOR_SET(ans, 16, SCM_I_MAKINUM (0));
SCM_VECTOR_SET(ans, 16, SCM_I_MAKINUM (0));
#endif
#ifdef HAVE_STRUCT_STAT_ST_CTIM
SCM_SIMPLE_VECTOR_SET(ans, 17, scm_from_ulong (stat_temp->st_ctim.tv_sec));
SCM_VECTOR_SET(ans, 17, scm_from_ulong (stat_temp->st_ctim.tv_sec));
#else
SCM_SIMPLE_VECTOR_SET(ans, 17, SCM_I_MAKINUM (0));
SCM_VECTOR_SET(ans, 17, SCM_I_MAKINUM (0));
#endif
return ans;
@ -690,12 +690,12 @@ fill_select_type (fd_set *set, SCM *ports_ready, SCM list_or_vec, int pos)
if (scm_is_vector (list_or_vec))
{
int i = SCM_SIMPLE_VECTOR_LENGTH (list_or_vec);
int i = SCM_VECTOR_LENGTH (list_or_vec);
while (--i >= 0)
{
int fd = set_element (set, ports_ready,
SCM_SIMPLE_VECTOR_REF (list_or_vec, i), pos);
SCM_VECTOR_REF (list_or_vec, i), pos);
if (fd > max_fd)
max_fd = fd;
@ -751,12 +751,12 @@ retrieve_select_type (fd_set *set, SCM ports_ready, SCM list_or_vec)
if (scm_is_vector (list_or_vec))
{
int i = SCM_SIMPLE_VECTOR_LENGTH (list_or_vec);
int i = SCM_VECTOR_LENGTH (list_or_vec);
while (--i >= 0)
{
answer_list = get_element (set,
SCM_SIMPLE_VECTOR_REF (list_or_vec, i),
SCM_VECTOR_REF (list_or_vec, i),
answer_list);
}
return scm_vector (answer_list);
@ -824,7 +824,7 @@ SCM_DEFINE (scm_select, "select", 3, 2, 0,
if (scm_is_vector (reads))
{
read_count = SCM_SIMPLE_VECTOR_LENGTH (reads);
read_count = SCM_VECTOR_LENGTH (reads);
}
else
{
@ -833,7 +833,7 @@ SCM_DEFINE (scm_select, "select", 3, 2, 0,
}
if (scm_is_vector (writes))
{
write_count = SCM_SIMPLE_VECTOR_LENGTH (writes);
write_count = SCM_VECTOR_LENGTH (writes);
}
else
{
@ -842,7 +842,7 @@ SCM_DEFINE (scm_select, "select", 3, 2, 0,
}
if (scm_is_vector (excepts))
{
except_count = SCM_SIMPLE_VECTOR_LENGTH (excepts);
except_count = SCM_VECTOR_LENGTH (excepts);
}
else
{

2
libguile/hash.c
View file

@ -315,7 +315,7 @@ scm_raw_ihash (SCM obj, size_t depth)
case scm_tc7_wvect:
case scm_tc7_vector:
{
size_t len = SCM_SIMPLE_VECTOR_LENGTH (obj);
size_t len = SCM_VECTOR_LENGTH (obj);
size_t i = depth / 2;
unsigned long h = scm_raw_ihashq (SCM_CELL_WORD_0 (obj));
if (len)

56
libguile/hashtab.c
View file

@ -143,13 +143,13 @@ scm_i_rehash (SCM table,
SCM_SET_HASHTABLE_VECTOR (table, new_buckets);
SCM_SET_HASHTABLE_N_ITEMS (table, 0);
old_size = SCM_SIMPLE_VECTOR_LENGTH (buckets);
old_size = SCM_VECTOR_LENGTH (buckets);
for (i = 0; i < old_size; ++i)
{
SCM ls, cell, handle;
ls = SCM_SIMPLE_VECTOR_REF (buckets, i);
SCM_SIMPLE_VECTOR_SET (buckets, i, SCM_EOL);
ls = SCM_VECTOR_REF (buckets, i);
SCM_VECTOR_SET (buckets, i, SCM_EOL);
while (scm_is_pair (ls))
{
@ -162,8 +162,8 @@ scm_i_rehash (SCM table,
h = hash_fn (SCM_CAR (handle), new_size, closure);
if (h >= new_size)
scm_out_of_range (func_name, scm_from_ulong (h));
SCM_SETCDR (cell, SCM_SIMPLE_VECTOR_REF (new_buckets, h));
SCM_SIMPLE_VECTOR_SET (new_buckets, h, cell);
SCM_SETCDR (cell, SCM_VECTOR_REF (new_buckets, h));
SCM_VECTOR_SET (new_buckets, h, cell);
SCM_HASHTABLE_INCREMENT (table);
}
}
@ -178,7 +178,7 @@ scm_i_hashtable_print (SCM exp, SCM port, scm_print_state *pstate)
scm_putc (' ', port);
scm_uintprint (SCM_HASHTABLE_N_ITEMS (exp), 10, port);
scm_putc ('/', port);
scm_uintprint (SCM_SIMPLE_VECTOR_LENGTH (SCM_HASHTABLE_VECTOR (exp)),
scm_uintprint (SCM_VECTOR_LENGTH (SCM_HASHTABLE_VECTOR (exp)),
10, port);
scm_puts (">", port);
}
@ -226,13 +226,13 @@ scm_hash_fn_get_handle (SCM table, SCM obj,
SCM_VALIDATE_HASHTABLE (SCM_ARG1, table);
buckets = SCM_HASHTABLE_VECTOR (table);
if (SCM_SIMPLE_VECTOR_LENGTH (buckets) == 0)
if (SCM_VECTOR_LENGTH (buckets) == 0)
return SCM_BOOL_F;
k = hash_fn (obj, SCM_SIMPLE_VECTOR_LENGTH (buckets), closure);
if (k >= SCM_SIMPLE_VECTOR_LENGTH (buckets))
k = hash_fn (obj, SCM_VECTOR_LENGTH (buckets), closure);
if (k >= SCM_VECTOR_LENGTH (buckets))
scm_out_of_range (FUNC_NAME, scm_from_ulong (k));
h = assoc_fn (obj, SCM_SIMPLE_VECTOR_REF (buckets, k), closure);
h = assoc_fn (obj, SCM_VECTOR_REF (buckets, k), closure);
return h;
}
@ -251,14 +251,14 @@ scm_hash_fn_create_handle_x (SCM table, SCM obj, SCM init,
SCM_VALIDATE_HASHTABLE (SCM_ARG1, table);
buckets = SCM_HASHTABLE_VECTOR (table);
if (SCM_SIMPLE_VECTOR_LENGTH (buckets) == 0)
if (SCM_VECTOR_LENGTH (buckets) == 0)
SCM_MISC_ERROR ("void hashtable", SCM_EOL);
k = hash_fn (obj, SCM_SIMPLE_VECTOR_LENGTH (buckets), closure);
if (k >= SCM_SIMPLE_VECTOR_LENGTH (buckets))
k = hash_fn (obj, SCM_VECTOR_LENGTH (buckets), closure);
if (k >= SCM_VECTOR_LENGTH (buckets))
scm_out_of_range ("hash_fn_create_handle_x", scm_from_ulong (k));
it = assoc_fn (obj, SCM_SIMPLE_VECTOR_REF (buckets, k), closure);
it = assoc_fn (obj, SCM_VECTOR_REF (buckets, k), closure);
if (scm_is_pair (it))
return it;
@ -274,12 +274,12 @@ scm_hash_fn_create_handle_x (SCM table, SCM obj, SCM init,
if (!scm_is_eq (SCM_HASHTABLE_VECTOR (table), buckets))
{
buckets = SCM_HASHTABLE_VECTOR (table);
k = hash_fn (obj, SCM_SIMPLE_VECTOR_LENGTH (buckets), closure);
if (k >= SCM_SIMPLE_VECTOR_LENGTH (buckets))
k = hash_fn (obj, SCM_VECTOR_LENGTH (buckets), closure);
if (k >= SCM_VECTOR_LENGTH (buckets))
scm_out_of_range ("hash_fn_create_handle_x", scm_from_ulong (k));
}
SCM_SETCDR (new_bucket, SCM_SIMPLE_VECTOR_REF (buckets, k));
SCM_SIMPLE_VECTOR_SET (buckets, k, new_bucket);
SCM_SETCDR (new_bucket, SCM_VECTOR_REF (buckets, k));
SCM_VECTOR_SET (buckets, k, new_bucket);
SCM_HASHTABLE_INCREMENT (table);
/* Maybe rehash the table. */
@ -335,19 +335,19 @@ scm_hash_fn_remove_x (SCM table, SCM obj,
buckets = SCM_HASHTABLE_VECTOR (table);
if (SCM_SIMPLE_VECTOR_LENGTH (buckets) == 0)
if (SCM_VECTOR_LENGTH (buckets) == 0)
return SCM_EOL;
k = hash_fn (obj, SCM_SIMPLE_VECTOR_LENGTH (buckets), closure);
if (k >= SCM_SIMPLE_VECTOR_LENGTH (buckets))
k = hash_fn (obj, SCM_VECTOR_LENGTH (buckets), closure);
if (k >= SCM_VECTOR_LENGTH (buckets))
scm_out_of_range (FUNC_NAME, scm_from_ulong (k));
h = assoc_fn (obj, SCM_SIMPLE_VECTOR_REF (buckets, k), closure);
h = assoc_fn (obj, SCM_VECTOR_REF (buckets, k), closure);
if (scm_is_true (h))
{
SCM_SIMPLE_VECTOR_SET
(buckets, k, scm_delq_x (h, SCM_SIMPLE_VECTOR_REF (buckets, k)));
SCM_VECTOR_SET
(buckets, k, scm_delq_x (h, SCM_VECTOR_REF (buckets, k)));
SCM_HASHTABLE_DECREMENT (table);
if (SCM_HASHTABLE_N_ITEMS (table) < SCM_HASHTABLE_LOWER (table))
scm_i_rehash (table, hash_fn, closure, FUNC_NAME);
@ -1017,12 +1017,12 @@ scm_internal_hash_fold (scm_t_hash_fold_fn fn, void *closure,
SCM_VALIDATE_HASHTABLE (0, table);
buckets = SCM_HASHTABLE_VECTOR (table);
n = SCM_SIMPLE_VECTOR_LENGTH (buckets);
n = SCM_VECTOR_LENGTH (buckets);
for (i = 0; i < n; ++i)
{
SCM ls, handle;
for (ls = SCM_SIMPLE_VECTOR_REF (buckets, i); !scm_is_null (ls);
for (ls = SCM_VECTOR_REF (buckets, i); !scm_is_null (ls);
ls = SCM_CDR (ls))
{
handle = SCM_CAR (ls);
@ -1050,11 +1050,11 @@ scm_internal_hash_for_each_handle (scm_t_hash_handle_fn fn, void *closure,
SCM_VALIDATE_HASHTABLE (0, table);
buckets = SCM_HASHTABLE_VECTOR (table);
n = SCM_SIMPLE_VECTOR_LENGTH (buckets);
n = SCM_VECTOR_LENGTH (buckets);
for (i = 0; i < n; ++i)
{
SCM ls = SCM_SIMPLE_VECTOR_REF (buckets, i), handle;
SCM ls = SCM_VECTOR_REF (buckets, i), handle;
while (!scm_is_null (ls))
{
if (!scm_is_pair (ls))

6
libguile/hashtab.h
View file

@ -40,11 +40,11 @@
#define SCM_HASHTABLE_LOWER(x) (SCM_HASHTABLE (x)->lower)
#define SCM_HASHTABLE_N_BUCKETS(h) \
SCM_SIMPLE_VECTOR_LENGTH (SCM_HASHTABLE_VECTOR (h))
SCM_VECTOR_LENGTH (SCM_HASHTABLE_VECTOR (h))
#define SCM_HASHTABLE_BUCKET(h, i) \
SCM_SIMPLE_VECTOR_REF (SCM_HASHTABLE_VECTOR (h), i)
SCM_VECTOR_REF (SCM_HASHTABLE_VECTOR (h), i)
#define SCM_SET_HASHTABLE_BUCKET(h, i, x) \
SCM_SIMPLE_VECTOR_SET (SCM_HASHTABLE_VECTOR (h), i, x)
SCM_VECTOR_SET (SCM_HASHTABLE_VECTOR (h), i, x)
/* Function that computes a hash of OBJ modulo MAX. */
typedef unsigned long (*scm_t_hash_fn) (SCM obj, unsigned long max,

12
libguile/intrinsics.c
View file

@ -358,9 +358,9 @@ throw_with_value (SCM val, SCM key_subr_and_message)
{
SCM key, subr, message, args, data;
key = SCM_SIMPLE_VECTOR_REF (key_subr_and_message, 0);
subr = SCM_SIMPLE_VECTOR_REF (key_subr_and_message, 1);
message = SCM_SIMPLE_VECTOR_REF (key_subr_and_message, 2);
key = SCM_VECTOR_REF (key_subr_and_message, 0);
subr = SCM_VECTOR_REF (key_subr_and_message, 1);
message = SCM_VECTOR_REF (key_subr_and_message, 2);
args = scm_list_1 (val);
data = SCM_BOOL_F;
@ -372,9 +372,9 @@ throw_with_value_and_data (SCM val, SCM key_subr_and_message)
{
SCM key, subr, message, args, data;
key = SCM_SIMPLE_VECTOR_REF (key_subr_and_message, 0);
subr = SCM_SIMPLE_VECTOR_REF (key_subr_and_message, 1);
message = SCM_SIMPLE_VECTOR_REF (key_subr_and_message, 2);
key = SCM_VECTOR_REF (key_subr_and_message, 0);
subr = SCM_VECTOR_REF (key_subr_and_message, 1);
message = SCM_VECTOR_REF (key_subr_and_message, 2);
args = scm_list_1 (val);
data = args;

6
libguile/memoize.c
View file

@ -64,9 +64,9 @@
#define CDDDR(x) SCM_CDDDR(x)
#define CADDDR(x) SCM_CADDDR(x)
#define VECTOR_REF(v, i) (SCM_SIMPLE_VECTOR_REF (v, i))
#define VECTOR_SET(v, i, x) (SCM_SIMPLE_VECTOR_SET (v, i, x))
#define VECTOR_LENGTH(v) (SCM_SIMPLE_VECTOR_LENGTH (v))
#define VECTOR_REF(v, i) (SCM_VECTOR_REF (v, i))
#define VECTOR_SET(v, i, x) (SCM_VECTOR_SET (v, i, x))
#define VECTOR_LENGTH(v) (SCM_VECTOR_LENGTH (v))
SCM_SYMBOL (sym_case_lambda_star, "case-lambda*");

54
libguile/net_db.c
View file

@ -178,13 +178,13 @@ SCM_DEFINE (scm_gethost, "gethost", 0, 1, 0,
if (!entry)
scm_resolv_error (FUNC_NAME, host);
SCM_SIMPLE_VECTOR_SET(result, 0, scm_from_locale_string (entry->h_name));
SCM_SIMPLE_VECTOR_SET(result, 1, scm_makfromstrs (-1, entry->h_aliases));
SCM_SIMPLE_VECTOR_SET(result, 2, scm_from_int (entry->h_addrtype));
SCM_SIMPLE_VECTOR_SET(result, 3, scm_from_int (entry->h_length));
SCM_VECTOR_SET(result, 0, scm_from_locale_string (entry->h_name));
SCM_VECTOR_SET(result, 1, scm_makfromstrs (-1, entry->h_aliases));
SCM_VECTOR_SET(result, 2, scm_from_int (entry->h_addrtype));
SCM_VECTOR_SET(result, 3, scm_from_int (entry->h_length));
if (sizeof (struct in_addr) != entry->h_length)
{
SCM_SIMPLE_VECTOR_SET(result, 4, SCM_BOOL_F);
SCM_VECTOR_SET(result, 4, SCM_BOOL_F);
return result;
}
for (argv = entry->h_addr_list; argv[i]; i++);
@ -193,7 +193,7 @@ SCM_DEFINE (scm_gethost, "gethost", 0, 1, 0,
inad = *(struct in_addr *) argv[i];
lst = scm_cons (scm_from_ulong (ntohl (inad.s_addr)), lst);
}
SCM_SIMPLE_VECTOR_SET(result, 4, lst);
SCM_VECTOR_SET(result, 4, lst);
return result;
}
#undef FUNC_NAME
@ -254,10 +254,10 @@ SCM_DEFINE (scm_getnet, "getnet", 0, 1, 0,
if (!entry)
SCM_SYSERROR_MSG ("no such network ~A", scm_list_1 (net), eno);
SCM_SIMPLE_VECTOR_SET(result, 0, scm_from_locale_string (entry->n_name));
SCM_SIMPLE_VECTOR_SET(result, 1, scm_makfromstrs (-1, entry->n_aliases));
SCM_SIMPLE_VECTOR_SET(result, 2, scm_from_int (entry->n_addrtype));
SCM_SIMPLE_VECTOR_SET(result, 3, scm_from_ulong (entry->n_net));
SCM_VECTOR_SET(result, 0, scm_from_locale_string (entry->n_name));
SCM_VECTOR_SET(result, 1, scm_makfromstrs (-1, entry->n_aliases));
SCM_VECTOR_SET(result, 2, scm_from_int (entry->n_addrtype));
SCM_VECTOR_SET(result, 3, scm_from_ulong (entry->n_net));
return result;
}
#undef FUNC_NAME
@ -306,9 +306,9 @@ SCM_DEFINE (scm_getproto, "getproto", 0, 1, 0,
if (!entry)
SCM_SYSERROR_MSG ("no such protocol ~A", scm_list_1 (protocol), eno);
SCM_SIMPLE_VECTOR_SET(result, 0, scm_from_locale_string (entry->p_name));
SCM_SIMPLE_VECTOR_SET(result, 1, scm_makfromstrs (-1, entry->p_aliases));
SCM_SIMPLE_VECTOR_SET(result, 2, scm_from_int (entry->p_proto));
SCM_VECTOR_SET(result, 0, scm_from_locale_string (entry->p_name));
SCM_VECTOR_SET(result, 1, scm_makfromstrs (-1, entry->p_aliases));
SCM_VECTOR_SET(result, 2, scm_from_int (entry->p_proto));
return result;
}
#undef FUNC_NAME
@ -320,10 +320,10 @@ scm_return_entry (struct servent *entry)
{
SCM result = scm_c_make_vector (4, SCM_UNSPECIFIED);
SCM_SIMPLE_VECTOR_SET(result, 0, scm_from_locale_string (entry->s_name));
SCM_SIMPLE_VECTOR_SET(result, 1, scm_makfromstrs (-1, entry->s_aliases));
SCM_SIMPLE_VECTOR_SET(result, 2, scm_from_uint16 (ntohs (entry->s_port)));
SCM_SIMPLE_VECTOR_SET(result, 3, scm_from_locale_string (entry->s_proto));
SCM_VECTOR_SET(result, 0, scm_from_locale_string (entry->s_name));
SCM_VECTOR_SET(result, 1, scm_makfromstrs (-1, entry->s_aliases));
SCM_VECTOR_SET(result, 2, scm_from_uint16 (ntohs (entry->s_port)));
SCM_VECTOR_SET(result, 3, scm_from_locale_string (entry->s_proto));
return result;
}
@ -478,16 +478,16 @@ scm_from_addrinfo (const struct addrinfo *c_ai)
`addrinfo:' procedures in `networking.scm'. */
ai = scm_c_make_vector (6, SCM_UNDEFINED);
SCM_SIMPLE_VECTOR_SET (ai, 0, scm_from_int (c_ai->ai_flags));
SCM_SIMPLE_VECTOR_SET (ai, 1, scm_from_int (c_ai->ai_family));
SCM_SIMPLE_VECTOR_SET (ai, 2, scm_from_int (c_ai->ai_socktype));
SCM_SIMPLE_VECTOR_SET (ai, 3, scm_from_int (c_ai->ai_protocol));
SCM_SIMPLE_VECTOR_SET (ai, 4,
scm_from_sockaddr (c_ai->ai_addr, c_ai->ai_addrlen));
SCM_SIMPLE_VECTOR_SET (ai, 5,
c_ai->ai_canonname != NULL
? scm_from_locale_string (c_ai->ai_canonname)
: SCM_BOOL_F);
SCM_VECTOR_SET (ai, 0, scm_from_int (c_ai->ai_flags));
SCM_VECTOR_SET (ai, 1, scm_from_int (c_ai->ai_family));
SCM_VECTOR_SET (ai, 2, scm_from_int (c_ai->ai_socktype));
SCM_VECTOR_SET (ai, 3, scm_from_int (c_ai->ai_protocol));
SCM_VECTOR_SET (ai, 4,
scm_from_sockaddr (c_ai->ai_addr, c_ai->ai_addrlen));
SCM_VECTOR_SET (ai, 5,
c_ai->ai_canonname != NULL
? scm_from_locale_string (c_ai->ai_canonname)
: SCM_BOOL_F);
return ai;
}

6
libguile/poll.c
View file

@ -99,14 +99,14 @@ scm_primitive_poll (SCM pollfds, SCM nfds, SCM ports, SCM timeout)
SCM_OUT_OF_RANGE (SCM_ARG2, nfds);
SCM_VALIDATE_VECTOR (SCM_ARG3, ports);
if (SCM_UNLIKELY (SCM_SIMPLE_VECTOR_LENGTH (ports) < c_nfds))
if (SCM_UNLIKELY (SCM_VECTOR_LENGTH (ports) < c_nfds))
SCM_OUT_OF_RANGE (SCM_ARG3, ports);
fds = (struct pollfd*)SCM_BYTEVECTOR_CONTENTS (pollfds);
for (i = 0; i < c_nfds; i++)
{
SCM port = SCM_SIMPLE_VECTOR_REF (ports, i);
SCM port = SCM_VECTOR_REF (ports, i);
short int revents = 0;
if (SCM_PORTP (port))
@ -145,7 +145,7 @@ scm_primitive_poll (SCM pollfds, SCM nfds, SCM ports, SCM timeout)
if (have_buffered_io)
for (i = 0; i < c_nfds; i++)
{
SCM port = SCM_SIMPLE_VECTOR_REF (ports, i);
SCM port = SCM_VECTOR_REF (ports, i);
short int revents = 0;
if (SCM_PORTP (port))

16
libguile/ports-internal.h
View file

@ -118,43 +118,43 @@ enum scm_port_buffer_field {
static inline SCM
scm_port_buffer_bytevector (SCM buf)
{
return SCM_SIMPLE_VECTOR_REF (buf, SCM_PORT_BUFFER_FIELD_BYTEVECTOR);
return SCM_VECTOR_REF (buf, SCM_PORT_BUFFER_FIELD_BYTEVECTOR);
}
static inline SCM
scm_port_buffer_cur (SCM buf)
{
return SCM_SIMPLE_VECTOR_REF (buf, SCM_PORT_BUFFER_FIELD_CUR);
return SCM_VECTOR_REF (buf, SCM_PORT_BUFFER_FIELD_CUR);
}
static inline void
scm_port_buffer_set_cur (SCM buf, SCM cur)
{
SCM_SIMPLE_VECTOR_SET (buf, SCM_PORT_BUFFER_FIELD_CUR, cur);
SCM_VECTOR_SET (buf, SCM_PORT_BUFFER_FIELD_CUR, cur);
}
static inline SCM
scm_port_buffer_end (SCM buf)
{
return SCM_SIMPLE_VECTOR_REF (buf, SCM_PORT_BUFFER_FIELD_END);
return SCM_VECTOR_REF (buf, SCM_PORT_BUFFER_FIELD_END);
}
static inline void
scm_port_buffer_set_end (SCM buf, SCM end)
{
SCM_SIMPLE_VECTOR_SET (buf, SCM_PORT_BUFFER_FIELD_END, end);
SCM_VECTOR_SET (buf, SCM_PORT_BUFFER_FIELD_END, end);
}
static inline SCM
scm_port_buffer_has_eof_p (SCM buf)
{
return SCM_SIMPLE_VECTOR_REF (buf, SCM_PORT_BUFFER_FIELD_HAS_EOF_P);
return SCM_VECTOR_REF (buf, SCM_PORT_BUFFER_FIELD_HAS_EOF_P);
}
static inline void
scm_port_buffer_set_has_eof_p (SCM buf, SCM has_eof_p)
{
SCM_SIMPLE_VECTOR_SET (buf, SCM_PORT_BUFFER_FIELD_HAS_EOF_P,
SCM_VECTOR_SET (buf, SCM_PORT_BUFFER_FIELD_HAS_EOF_P,
has_eof_p);
}
@ -164,7 +164,7 @@ scm_port_buffer_set_has_eof_p (SCM buf, SCM has_eof_p)
static inline SCM
scm_port_buffer_position (SCM buf)
{
return SCM_SIMPLE_VECTOR_REF (buf, SCM_PORT_BUFFER_FIELD_POSITION);
return SCM_VECTOR_REF (buf, SCM_PORT_BUFFER_FIELD_POSITION);
}
static inline SCM

8
libguile/ports.c
View file

@ -590,10 +590,10 @@ make_port_buffer (SCM port, size_t size)
{
SCM ret = scm_c_make_vector (SCM_PORT_BUFFER_FIELD_COUNT, SCM_INUM0);
SCM_SIMPLE_VECTOR_SET (ret, SCM_PORT_BUFFER_FIELD_BYTEVECTOR,
scm_c_make_bytevector (size));
SCM_SIMPLE_VECTOR_SET (ret, SCM_PORT_BUFFER_FIELD_POSITION,
SCM_PORT (port)->position);
SCM_VECTOR_SET (ret, SCM_PORT_BUFFER_FIELD_BYTEVECTOR,
scm_c_make_bytevector (size));
SCM_VECTOR_SET (ret, SCM_PORT_BUFFER_FIELD_POSITION,
SCM_PORT (port)->position);
scm_port_buffer_set_has_eof_p (ret, SCM_BOOL_F);
return ret;

48
libguile/posix.c
View file

@ -283,7 +283,7 @@ SCM_DEFINE (scm_getgroups, "getgroups", 0, 0, 0,
result = scm_c_make_vector (ngroups, SCM_BOOL_F);
while (--ngroups >= 0)
SCM_SIMPLE_VECTOR_SET (result, ngroups, scm_from_ulong (groups[ngroups]));
SCM_VECTOR_SET (result, ngroups, scm_from_ulong (groups[ngroups]));
free (groups);
return result;
@ -310,18 +310,18 @@ SCM_DEFINE (scm_setgroups, "setgroups", 1, 0, 0,
SCM_VALIDATE_VECTOR (SCM_ARG1, group_vec);
ngroups = SCM_SIMPLE_VECTOR_LENGTH (group_vec);
ngroups = SCM_VECTOR_LENGTH (group_vec);
/* validate before allocating, so we don't have to worry about leaks */
for (i = 0; i < ngroups; i++)
{
unsigned long ulong_gid;
GETGROUPS_T gid;
SCM_VALIDATE_ULONG_COPY (1, SCM_SIMPLE_VECTOR_REF (group_vec, i),
SCM_VALIDATE_ULONG_COPY (1, SCM_VECTOR_REF (group_vec, i),
ulong_gid);
gid = ulong_gid;
if (gid != ulong_gid)
SCM_OUT_OF_RANGE (1, SCM_SIMPLE_VECTOR_REF (group_vec, i));
SCM_OUT_OF_RANGE (1, SCM_VECTOR_REF (group_vec, i));
}
size = ngroups * sizeof (GETGROUPS_T);
@ -329,7 +329,7 @@ SCM_DEFINE (scm_setgroups, "setgroups", 1, 0, 0,
SCM_OUT_OF_RANGE (SCM_ARG1, scm_from_int (ngroups));
groups = scm_malloc (size);
for(i = 0; i < ngroups; i++)
groups [i] = SCM_NUM2ULONG (1, SCM_SIMPLE_VECTOR_REF (group_vec, i));
groups [i] = SCM_NUM2ULONG (1, SCM_VECTOR_REF (group_vec, i));
result = setgroups (ngroups, groups);
save_errno = errno; /* don't let free() touch errno */
@ -374,19 +374,19 @@ SCM_DEFINE (scm_getpwuid, "getpw", 0, 1, 0,
if (!entry)
SCM_MISC_ERROR ("entry not found", SCM_EOL);
SCM_SIMPLE_VECTOR_SET(result, 0, scm_from_locale_string (entry->pw_name));
SCM_SIMPLE_VECTOR_SET(result, 1, scm_from_locale_string (entry->pw_passwd));
SCM_SIMPLE_VECTOR_SET(result, 2, scm_from_ulong (entry->pw_uid));
SCM_SIMPLE_VECTOR_SET(result, 3, scm_from_ulong (entry->pw_gid));
SCM_SIMPLE_VECTOR_SET(result, 4, scm_from_locale_string (entry->pw_gecos));
SCM_VECTOR_SET(result, 0, scm_from_locale_string (entry->pw_name));
SCM_VECTOR_SET(result, 1, scm_from_locale_string (entry->pw_passwd));
SCM_VECTOR_SET(result, 2, scm_from_ulong (entry->pw_uid));
SCM_VECTOR_SET(result, 3, scm_from_ulong (entry->pw_gid));
SCM_VECTOR_SET(result, 4, scm_from_locale_string (entry->pw_gecos));
if (!entry->pw_dir)
SCM_SIMPLE_VECTOR_SET(result, 5, scm_from_utf8_string (""));
SCM_VECTOR_SET(result, 5, scm_from_utf8_string (""));
else
SCM_SIMPLE_VECTOR_SET(result, 5, scm_from_locale_string (entry->pw_dir));
SCM_VECTOR_SET(result, 5, scm_from_locale_string (entry->pw_dir));
if (!entry->pw_shell)
SCM_SIMPLE_VECTOR_SET(result, 6, scm_from_utf8_string (""));
SCM_VECTOR_SET(result, 6, scm_from_utf8_string (""));
else
SCM_SIMPLE_VECTOR_SET(result, 6, scm_from_locale_string (entry->pw_shell));
SCM_VECTOR_SET(result, 6, scm_from_locale_string (entry->pw_shell));
return result;
}
#undef FUNC_NAME
@ -440,10 +440,10 @@ SCM_DEFINE (scm_getgrgid, "getgr", 0, 1, 0,
if (!entry)
SCM_SYSERROR;
SCM_SIMPLE_VECTOR_SET(result, 0, scm_from_locale_string (entry->gr_name));
SCM_SIMPLE_VECTOR_SET(result, 1, scm_from_locale_string (entry->gr_passwd));
SCM_SIMPLE_VECTOR_SET(result, 2, scm_from_ulong (entry->gr_gid));
SCM_SIMPLE_VECTOR_SET(result, 3, scm_makfromstrs (-1, entry->gr_mem));
SCM_VECTOR_SET(result, 0, scm_from_locale_string (entry->gr_name));
SCM_VECTOR_SET(result, 1, scm_from_locale_string (entry->gr_passwd));
SCM_VECTOR_SET(result, 2, scm_from_ulong (entry->gr_gid));
SCM_VECTOR_SET(result, 3, scm_makfromstrs (-1, entry->gr_mem));
return result;
}
#undef FUNC_NAME
@ -1557,14 +1557,14 @@ SCM_DEFINE (scm_uname, "uname", 0, 0, 0,
SCM result = scm_c_make_vector (5, SCM_UNSPECIFIED);
if (uname (&buf) < 0)
SCM_SYSERROR;
SCM_SIMPLE_VECTOR_SET(result, 0, scm_from_locale_string (buf.sysname));
SCM_SIMPLE_VECTOR_SET(result, 1, scm_from_locale_string (buf.nodename));
SCM_SIMPLE_VECTOR_SET(result, 2, scm_from_locale_string (buf.release));
SCM_SIMPLE_VECTOR_SET(result, 3, scm_from_locale_string (buf.version));
SCM_SIMPLE_VECTOR_SET(result, 4, scm_from_locale_string (buf.machine));
SCM_VECTOR_SET(result, 0, scm_from_locale_string (buf.sysname));
SCM_VECTOR_SET(result, 1, scm_from_locale_string (buf.nodename));
SCM_VECTOR_SET(result, 2, scm_from_locale_string (buf.release));
SCM_VECTOR_SET(result, 3, scm_from_locale_string (buf.version));
SCM_VECTOR_SET(result, 4, scm_from_locale_string (buf.machine));
/*
a linux special?
SCM_SIMPLE_VECTOR_SET(result, 5, scm_from_locale_string (buf.domainname));
SCM_VECTOR_SET(result, 5, scm_from_locale_string (buf.domainname));
*/
return result;
}

12
libguile/print.c
View file

@ -215,7 +215,7 @@ make_print_state (void)
scm_print_state *pstate = SCM_PRINT_STATE (print_state);
pstate->handle = print_state;
pstate->ref_vect = scm_c_make_vector (PSTATE_SIZE, SCM_UNDEFINED);
pstate->ceiling = SCM_SIMPLE_VECTOR_LENGTH (pstate->ref_vect);
pstate->ceiling = SCM_VECTOR_LENGTH (pstate->ref_vect);
pstate->highlight_objects = SCM_EOL;
return print_state;
}
@ -277,20 +277,20 @@ static void
grow_ref_stack (scm_print_state *pstate)
{
SCM old_vect = pstate->ref_vect;
size_t old_size = SCM_SIMPLE_VECTOR_LENGTH (old_vect);
size_t old_size = SCM_VECTOR_LENGTH (old_vect);
size_t new_size = 2 * pstate->ceiling;
SCM new_vect = scm_c_make_vector (new_size, SCM_UNDEFINED);
unsigned long int i;
for (i = 0; i != old_size; ++i)
SCM_SIMPLE_VECTOR_SET (new_vect, i, SCM_SIMPLE_VECTOR_REF (old_vect, i));
SCM_VECTOR_SET (new_vect, i, SCM_VECTOR_REF (old_vect, i));
pstate->ref_vect = new_vect;
pstate->ceiling = new_size;
}
#define PSTATE_STACK_REF(p,i) SCM_SIMPLE_VECTOR_REF((p)->ref_vect, (i))
#define PSTATE_STACK_SET(p,i,v) SCM_SIMPLE_VECTOR_SET((p)->ref_vect, (i), (v))
#define PSTATE_STACK_REF(p,i) SCM_VECTOR_REF((p)->ref_vect, (i))
#define PSTATE_STACK_SET(p,i,v) SCM_VECTOR_SET((p)->ref_vect, (i), (v))
static void
print_circref (SCM port, scm_print_state *pstate, SCM ref)
@ -770,7 +770,7 @@ iprin1 (SCM exp, SCM port, scm_print_state *pstate)
case scm_tc7_vector:
ENTER_NESTED_DATA (pstate, exp, circref);
scm_puts ("#(", port);
print_vector_or_weak_vector (exp, SCM_SIMPLE_VECTOR_LENGTH (exp),
print_vector_or_weak_vector (exp, SCM_VECTOR_LENGTH (exp),
scm_c_vector_ref, port, pstate);
EXIT_NESTED_DATA (pstate);
break;

2
libguile/print.h
View file

@ -74,7 +74,7 @@ typedef struct scm_print_state {
unsigned long ceiling; /* Max size of reference stack */
SCM ref_vect; /* Stack of references used during
circular reference detection;
a simple vector. */
a vector. */
SCM highlight_objects; /* List of objects to be highlighted */
} scm_print_state;

6
libguile/regex-posix.c
View file

@ -293,13 +293,13 @@ SCM_DEFINE (scm_regexp_exec, "regexp-exec", 2, 2, 0,
/* The match vector must include a cell for the string that was matched,
so add 1. */
mvec = scm_c_make_vector (nmatches + 1, SCM_UNSPECIFIED);
SCM_SIMPLE_VECTOR_SET(mvec,0, str);
SCM_VECTOR_SET(mvec,0, str);
for (i = 0; i < nmatches; ++i)
if (matches[i].rm_so == -1)
SCM_SIMPLE_VECTOR_SET(mvec, i+1,
SCM_VECTOR_SET(mvec, i+1,
scm_cons (scm_from_int (-1), scm_from_int (-1)));
else
SCM_SIMPLE_VECTOR_SET(mvec, i+1,
SCM_VECTOR_SET(mvec, i+1,
scm_cons (scm_from_long (matches[i].rm_so + offset),
scm_from_long (matches[i].rm_eo + offset)));
}

22
libguile/scmsigs.c
View file

@ -199,8 +199,8 @@ signal_delivery_thread (void *data)
{
SCM h, t;
h = SCM_SIMPLE_VECTOR_REF (signal_handler_asyncs, sig);
t = SCM_SIMPLE_VECTOR_REF (signal_handler_threads, sig);
h = SCM_VECTOR_REF (signal_handler_asyncs, sig);
t = SCM_VECTOR_REF (signal_handler_threads, sig);
if (scm_is_true (h))
scm_system_async_mark_for_thread (h, t);
}
@ -242,7 +242,7 @@ scm_i_ensure_signal_delivery_thread ()
static SIGRETTYPE
take_signal (int signum)
{
SCM cell = SCM_SIMPLE_VECTOR_REF (signal_handler_asyncs, signum);
SCM cell = SCM_VECTOR_REF (signal_handler_asyncs, signum);
scm_thread *t = SCM_I_CURRENT_THREAD;
if (scm_is_false (SCM_CDR (cell)))
@ -269,8 +269,8 @@ install_handler (int signum, SCM thread, SCM handler)
{
if (scm_is_false (handler))
{
SCM_SIMPLE_VECTOR_SET (*signal_handlers, signum, SCM_BOOL_F);
SCM_SIMPLE_VECTOR_SET (signal_handler_asyncs, signum, SCM_BOOL_F);
SCM_VECTOR_SET (*signal_handlers, signum, SCM_BOOL_F);
SCM_VECTOR_SET (signal_handler_asyncs, signum, SCM_BOOL_F);
}
else
{
@ -278,11 +278,11 @@ install_handler (int signum, SCM thread, SCM handler)
#if !SCM_USE_PTHREAD_THREADS
async = scm_cons (async, SCM_BOOL_F);
#endif
SCM_SIMPLE_VECTOR_SET (*signal_handlers, signum, handler);
SCM_SIMPLE_VECTOR_SET (signal_handler_asyncs, signum, async);
SCM_VECTOR_SET (*signal_handlers, signum, handler);
SCM_VECTOR_SET (signal_handler_asyncs, signum, async);
}
SCM_SIMPLE_VECTOR_SET (signal_handler_threads, signum, thread);
SCM_VECTOR_SET (signal_handler_threads, signum, thread);
}
SCM
@ -353,7 +353,7 @@ SCM_DEFINE (scm_sigaction_for_thread, "sigaction", 1, 3, 0,
scm_i_dynwind_pthread_mutex_lock (&signal_handler_lock);
scm_dynwind_block_asyncs ();
old_handler = SCM_SIMPLE_VECTOR_REF (*signal_handlers, csig);
old_handler = SCM_VECTOR_REF (*signal_handlers, csig);
if (SCM_UNBNDP (handler))
query_only = 1;
else if (scm_is_integer (handler))
@ -501,7 +501,7 @@ SCM_DEFINE (scm_restore_signals, "restore-signals", 0, 0, 0,
if (sigaction (i, &orig_handlers[i], NULL) == -1)
SCM_SYSERROR;
orig_handlers[i].sa_handler = SIG_ERR;
SCM_SIMPLE_VECTOR_SET (*signal_handlers, i, SCM_BOOL_F);
SCM_VECTOR_SET (*signal_handlers, i, SCM_BOOL_F);
}
#else
if (orig_handlers[i] != SIG_ERR)
@ -509,7 +509,7 @@ SCM_DEFINE (scm_restore_signals, "restore-signals", 0, 0, 0,
if (signal (i, orig_handlers[i]) == SIG_ERR)
SCM_SYSERROR;
orig_handlers[i] = SIG_ERR;
SCM_SIMPLE_VECTOR_SET (*signal_handlers, i, SCM_BOOL_F);
SCM_VECTOR_SET (*signal_handlers, i, SCM_BOOL_F);
}
#endif
}

52
libguile/socket.c
View file

@ -986,12 +986,12 @@ _scm_from_sockaddr (const scm_t_max_sockaddr *address, unsigned addr_size,
result = scm_c_make_vector (3, SCM_UNSPECIFIED);
SCM_SIMPLE_VECTOR_SET(result, 0,
scm_from_short (fam));
SCM_SIMPLE_VECTOR_SET(result, 1,
scm_from_ulong (ntohl (nad->sin_addr.s_addr)));
SCM_SIMPLE_VECTOR_SET(result, 2,
scm_from_ushort (ntohs (nad->sin_port)));
SCM_VECTOR_SET(result, 0,
scm_from_short (fam));
SCM_VECTOR_SET(result, 1,
scm_from_ulong (ntohl (nad->sin_addr.s_addr)));
SCM_VECTOR_SET(result, 2,
scm_from_ushort (ntohs (nad->sin_port)));
}
break;
#ifdef HAVE_IPV6
@ -1000,14 +1000,14 @@ _scm_from_sockaddr (const scm_t_max_sockaddr *address, unsigned addr_size,
const struct sockaddr_in6 *nad = (struct sockaddr_in6 *) address;
result = scm_c_make_vector (5, SCM_UNSPECIFIED);
SCM_SIMPLE_VECTOR_SET(result, 0, scm_from_short (fam));
SCM_SIMPLE_VECTOR_SET(result, 1, scm_from_ipv6 (nad->sin6_addr.s6_addr));
SCM_SIMPLE_VECTOR_SET(result, 2, scm_from_ushort (ntohs (nad->sin6_port)));
SCM_SIMPLE_VECTOR_SET(result, 3, scm_from_uint32 (nad->sin6_flowinfo));
SCM_VECTOR_SET(result, 0, scm_from_short (fam));
SCM_VECTOR_SET(result, 1, scm_from_ipv6 (nad->sin6_addr.s6_addr));
SCM_VECTOR_SET(result, 2, scm_from_ushort (ntohs (nad->sin6_port)));
SCM_VECTOR_SET(result, 3, scm_from_uint32 (nad->sin6_flowinfo));
#ifdef HAVE_SIN6_SCOPE_ID
SCM_SIMPLE_VECTOR_SET(result, 4, scm_from_ulong (nad->sin6_scope_id));
SCM_VECTOR_SET(result, 4, scm_from_ulong (nad->sin6_scope_id));
#else
SCM_SIMPLE_VECTOR_SET(result, 4, SCM_INUM0);
SCM_VECTOR_SET(result, 4, SCM_INUM0);
#endif
}
break;
@ -1019,13 +1019,13 @@ _scm_from_sockaddr (const scm_t_max_sockaddr *address, unsigned addr_size,
result = scm_c_make_vector (2, SCM_UNSPECIFIED);
SCM_SIMPLE_VECTOR_SET(result, 0, scm_from_short (fam));
SCM_VECTOR_SET(result, 0, scm_from_short (fam));
/* When addr_size is not enough to cover sun_path, do not try
to access it. */
if (addr_size <= offsetof (struct sockaddr_un, sun_path))
SCM_SIMPLE_VECTOR_SET(result, 1, SCM_BOOL_F);
SCM_VECTOR_SET(result, 1, SCM_BOOL_F);
else
SCM_SIMPLE_VECTOR_SET(result, 1, scm_from_locale_string (nad->sun_path));
SCM_VECTOR_SET(result, 1, scm_from_locale_string (nad->sun_path));
}
break;
#endif
@ -1062,13 +1062,13 @@ scm_to_sockaddr (SCM address, size_t *address_size)
SCM_VALIDATE_VECTOR (1, address);
*address_size = 0;
family = scm_to_short (SCM_SIMPLE_VECTOR_REF (address, 0));
family = scm_to_short (SCM_VECTOR_REF (address, 0));
switch (family)
{
case AF_INET:
{
if (SCM_SIMPLE_VECTOR_LENGTH (address) != 3)
if (SCM_VECTOR_LENGTH (address) != 3)
scm_misc_error (FUNC_NAME,
"invalid inet address representation: ~A",
scm_list_1 (address));
@ -1083,9 +1083,9 @@ scm_to_sockaddr (SCM address, size_t *address_size)
#endif
c_inet.sin_addr.s_addr =
htonl (scm_to_ulong (SCM_SIMPLE_VECTOR_REF (address, 1)));
htonl (scm_to_ulong (SCM_VECTOR_REF (address, 1)));
c_inet.sin_port =
htons (scm_to_ushort (SCM_SIMPLE_VECTOR_REF (address, 2)));
htons (scm_to_ushort (SCM_VECTOR_REF (address, 2)));
c_inet.sin_family = AF_INET;
*address_size = sizeof (c_inet);
@ -1099,7 +1099,7 @@ scm_to_sockaddr (SCM address, size_t *address_size)
#ifdef HAVE_IPV6
case AF_INET6:
{
if (SCM_SIMPLE_VECTOR_LENGTH (address) != 5)
if (SCM_VECTOR_LENGTH (address) != 5)
scm_misc_error (FUNC_NAME, "invalid inet6 address representation: ~A",
scm_list_1 (address));
else
@ -1107,14 +1107,14 @@ scm_to_sockaddr (SCM address, size_t *address_size)
struct sockaddr_in6 c_inet6;
scm_to_ipv6 (c_inet6.sin6_addr.s6_addr,
SCM_SIMPLE_VECTOR_REF (address, 1));
SCM_VECTOR_REF (address, 1));
c_inet6.sin6_port =
htons (scm_to_ushort (SCM_SIMPLE_VECTOR_REF (address, 2)));
htons (scm_to_ushort (SCM_VECTOR_REF (address, 2)));
c_inet6.sin6_flowinfo =
scm_to_uint32 (SCM_SIMPLE_VECTOR_REF (address, 3));
scm_to_uint32 (SCM_VECTOR_REF (address, 3));
#ifdef HAVE_SIN6_SCOPE_ID
c_inet6.sin6_scope_id =
scm_to_ulong (SCM_SIMPLE_VECTOR_REF (address, 4));
scm_to_ulong (SCM_VECTOR_REF (address, 4));
#endif
c_inet6.sin6_family = AF_INET6;
@ -1131,7 +1131,7 @@ scm_to_sockaddr (SCM address, size_t *address_size)
#ifdef HAVE_UNIX_DOMAIN_SOCKETS
case AF_UNIX:
{
if (SCM_SIMPLE_VECTOR_LENGTH (address) != 2)
if (SCM_VECTOR_LENGTH (address) != 2)
scm_misc_error (FUNC_NAME, "invalid unix address representation: ~A",
scm_list_1 (address));
else
@ -1139,7 +1139,7 @@ scm_to_sockaddr (SCM address, size_t *address_size)
SCM path;
size_t path_len = 0;
path = SCM_SIMPLE_VECTOR_REF (address, 1);
path = SCM_VECTOR_REF (address, 1);
if (!scm_is_string (path) && !scm_is_false (path))
scm_misc_error (FUNC_NAME, "invalid unix address "
"path: ~A", scm_list_1 (path));

6
libguile/srfi-1.c
View file

@ -245,7 +245,7 @@ SCM_DEFINE (scm_srfi1_count, "count", 2, 0, 1,
/* vec is the list arguments */
vec = scm_vector (scm_cons (list1, rest));
len = SCM_SIMPLE_VECTOR_LENGTH (vec);
len = SCM_VECTOR_LENGTH (vec);
/* args is the argument list to pass to pred, same length as vec,
re-used for each call */
@ -259,11 +259,11 @@ SCM_DEFINE (scm_srfi1_count, "count", 2, 0, 1,
i < len;
i++, a = SCM_CDR (a), argnum++)
{
lst = SCM_SIMPLE_VECTOR_REF (vec, i); /* list argument */
lst = SCM_VECTOR_REF (vec, i); /* list argument */
if (! scm_is_pair (lst))
goto check_lst_and_done;
SCM_SETCAR (a, SCM_CAR (lst)); /* arg for pred */
SCM_SIMPLE_VECTOR_SET (vec, i, SCM_CDR (lst)); /* rest of lst */
SCM_VECTOR_SET (vec, i, SCM_CDR (lst)); /* rest of lst */
}
count += scm_is_true (scm_apply_0 (pred, args));

70
libguile/stime.c
View file

@ -227,16 +227,16 @@ SCM_DEFINE (scm_times, "times", 0, 0, 0,
factor = scm_quotient (scm_from_long (TIME_UNITS_PER_SECOND),
scm_from_long (ticks_per_second));
SCM_SIMPLE_VECTOR_SET (result, 0,
scm_product (scm_from_long (rv), factor));
SCM_SIMPLE_VECTOR_SET (result, 1,
scm_product (scm_from_long (t.tms_utime), factor));
SCM_SIMPLE_VECTOR_SET (result, 2,
scm_product (scm_from_long (t.tms_stime), factor));
SCM_SIMPLE_VECTOR_SET (result ,3,
scm_product (scm_from_long (t.tms_cutime), factor));
SCM_SIMPLE_VECTOR_SET (result, 4,
scm_product (scm_from_long (t.tms_cstime), factor));
SCM_VECTOR_SET (result, 0,
scm_product (scm_from_long (rv), factor));
SCM_VECTOR_SET (result, 1,
scm_product (scm_from_long (t.tms_utime), factor));
SCM_VECTOR_SET (result, 2,
scm_product (scm_from_long (t.tms_stime), factor));
SCM_VECTOR_SET (result ,3,
scm_product (scm_from_long (t.tms_cutime), factor));
SCM_VECTOR_SET (result, 4,
scm_product (scm_from_long (t.tms_cstime), factor));
return result;
}
#undef FUNC_NAME
@ -311,17 +311,17 @@ filltime (struct tm *bd_time, int zoff, const char *zname)
{
SCM result = scm_c_make_vector (11, SCM_UNDEFINED);
SCM_SIMPLE_VECTOR_SET (result,0, scm_from_int (bd_time->tm_sec));
SCM_SIMPLE_VECTOR_SET (result,1, scm_from_int (bd_time->tm_min));
SCM_SIMPLE_VECTOR_SET (result,2, scm_from_int (bd_time->tm_hour));
SCM_SIMPLE_VECTOR_SET (result,3, scm_from_int (bd_time->tm_mday));
SCM_SIMPLE_VECTOR_SET (result,4, scm_from_int (bd_time->tm_mon));
SCM_SIMPLE_VECTOR_SET (result,5, scm_from_int (bd_time->tm_year));
SCM_SIMPLE_VECTOR_SET (result,6, scm_from_int (bd_time->tm_wday));
SCM_SIMPLE_VECTOR_SET (result,7, scm_from_int (bd_time->tm_yday));
SCM_SIMPLE_VECTOR_SET (result,8, scm_from_int (bd_time->tm_isdst));
SCM_SIMPLE_VECTOR_SET (result,9, scm_from_int (zoff));
SCM_SIMPLE_VECTOR_SET (result,10, (zname
SCM_VECTOR_SET (result,0, scm_from_int (bd_time->tm_sec));
SCM_VECTOR_SET (result,1, scm_from_int (bd_time->tm_min));
SCM_VECTOR_SET (result,2, scm_from_int (bd_time->tm_hour));
SCM_VECTOR_SET (result,3, scm_from_int (bd_time->tm_mday));
SCM_VECTOR_SET (result,4, scm_from_int (bd_time->tm_mon));
SCM_VECTOR_SET (result,5, scm_from_int (bd_time->tm_year));
SCM_VECTOR_SET (result,6, scm_from_int (bd_time->tm_wday));
SCM_VECTOR_SET (result,7, scm_from_int (bd_time->tm_yday));
SCM_VECTOR_SET (result,8, scm_from_int (bd_time->tm_isdst));
SCM_VECTOR_SET (result,9, scm_from_int (zoff));
SCM_VECTOR_SET (result,10, (zname
? scm_from_locale_string (zname)
: SCM_BOOL_F));
return result;
@ -506,26 +506,26 @@ static void
bdtime2c (SCM sbd_time, struct tm *lt, int pos, const char *subr)
{
SCM_ASSERT (scm_is_vector (sbd_time)
&& SCM_SIMPLE_VECTOR_LENGTH (sbd_time) == 11,
&& SCM_VECTOR_LENGTH (sbd_time) == 11,
sbd_time, pos, subr);
lt->tm_sec = scm_to_int (SCM_SIMPLE_VECTOR_REF (sbd_time, 0));
lt->tm_min = scm_to_int (SCM_SIMPLE_VECTOR_REF (sbd_time, 1));
lt->tm_hour = scm_to_int (SCM_SIMPLE_VECTOR_REF (sbd_time, 2));
lt->tm_mday = scm_to_int (SCM_SIMPLE_VECTOR_REF (sbd_time, 3));
lt->tm_mon = scm_to_int (SCM_SIMPLE_VECTOR_REF (sbd_time, 4));
lt->tm_year = scm_to_int (SCM_SIMPLE_VECTOR_REF (sbd_time, 5));
lt->tm_wday = scm_to_int (SCM_SIMPLE_VECTOR_REF (sbd_time, 6));
lt->tm_yday = scm_to_int (SCM_SIMPLE_VECTOR_REF (sbd_time, 7));
lt->tm_isdst = scm_to_int (SCM_SIMPLE_VECTOR_REF (sbd_time, 8));
lt->tm_sec = scm_to_int (SCM_VECTOR_REF (sbd_time, 0));
lt->tm_min = scm_to_int (SCM_VECTOR_REF (sbd_time, 1));
lt->tm_hour = scm_to_int (SCM_VECTOR_REF (sbd_time, 2));
lt->tm_mday = scm_to_int (SCM_VECTOR_REF (sbd_time, 3));
lt->tm_mon = scm_to_int (SCM_VECTOR_REF (sbd_time, 4));
lt->tm_year = scm_to_int (SCM_VECTOR_REF (sbd_time, 5));
lt->tm_wday = scm_to_int (SCM_VECTOR_REF (sbd_time, 6));
lt->tm_yday = scm_to_int (SCM_VECTOR_REF (sbd_time, 7));
lt->tm_isdst = scm_to_int (SCM_VECTOR_REF (sbd_time, 8));
#if HAVE_STRUCT_TM_TM_GMTOFF
lt->tm_gmtoff = - scm_to_int (SCM_SIMPLE_VECTOR_REF (sbd_time, 9));
lt->tm_gmtoff = - scm_to_int (SCM_VECTOR_REF (sbd_time, 9));
#endif
#ifdef HAVE_STRUCT_TM_TM_ZONE
if (scm_is_false (SCM_SIMPLE_VECTOR_REF (sbd_time, 10)))
if (scm_is_false (SCM_VECTOR_REF (sbd_time, 10)))
lt->tm_zone = NULL;
else
lt->tm_zone = scm_to_locale_string (SCM_SIMPLE_VECTOR_REF (sbd_time, 10));
lt->tm_zone = scm_to_locale_string (SCM_VECTOR_REF (sbd_time, 10));
#endif
}
@ -688,7 +688,7 @@ SCM_DEFINE (scm_strftime, "strftime", 2, 0, 0,
environment. interrupts and thread switching must be deferred
until TZ is restored. */
char **oldenv = NULL;
SCM zone_spec = SCM_SIMPLE_VECTOR_REF (stime, 10);
SCM zone_spec = SCM_VECTOR_REF (stime, 10);
int have_zone = 0;
if (scm_is_true (zone_spec) && scm_c_string_length (zone_spec) > 0)

6
libguile/trees.c
View file

@ -130,7 +130,7 @@ copy_tree (struct t_trace *const hare,
if (scm_is_vector (hare->obj))
{
size_t length = SCM_SIMPLE_VECTOR_LENGTH (hare->obj);
size_t length = SCM_VECTOR_LENGTH (hare->obj);
SCM new_vector = scm_c_make_vector (length, SCM_UNSPECIFIED);
/* Each vector element is copied by recursing into copy_tree, having
@ -139,9 +139,9 @@ copy_tree (struct t_trace *const hare,
for (i = 0; i < length; ++i)
{
SCM new_element;
new_hare.obj = SCM_SIMPLE_VECTOR_REF (hare->obj, i);
new_hare.obj = SCM_VECTOR_REF (hare->obj, i);
new_element = copy_tree (&new_hare, tortoise, tortoise_delay);
SCM_SIMPLE_VECTOR_SET (new_vector, i, new_element);
SCM_VECTOR_SET (new_vector, i, new_element);
}
return new_vector;

12
libguile/vectors.c
View file

@ -55,12 +55,6 @@ scm_is_vector (SCM obj)
return SCM_I_IS_VECTOR (obj);
}
int
scm_is_simple_vector (SCM obj)
{
return SCM_I_IS_VECTOR (obj);
}
const SCM *
scm_vector_elements (SCM vec, scm_t_array_handle *h,
size_t *lenp, ssize_t *incp)
@ -198,7 +192,7 @@ scm_c_vector_ref (SCM v, size_t k)
if (k >= SCM_I_VECTOR_LENGTH (v))
scm_out_of_range (NULL, scm_from_size_t (k));
return SCM_SIMPLE_VECTOR_REF (v, k);
return SCM_VECTOR_REF (v, k);
}
#undef FUNC_NAME
@ -229,7 +223,7 @@ scm_c_vector_set_x (SCM v, size_t k, SCM obj)
if (k >= SCM_I_VECTOR_LENGTH (v))
scm_out_of_range (NULL, scm_from_size_t (k));
SCM_SIMPLE_VECTOR_SET (v, k, obj);
SCM_VECTOR_SET (v, k, obj);
}
#undef FUNC_NAME
@ -267,7 +261,7 @@ scm_c_make_vector (size_t k, SCM fill)
vector = make_vector (k);
for (j = 0; j < k; ++j)
SCM_SIMPLE_VECTOR_SET (vector, j, fill);
SCM_VECTOR_SET (vector, j, fill);
return vector;
}

9
libguile/vectors.h
View file

@ -43,7 +43,6 @@ SCM_API SCM scm_vector_move_right_x (SCM vec1, SCM start1, SCM end1,
SCM_API SCM scm_vector_copy (SCM vec);
SCM_API int scm_is_vector (SCM obj);
SCM_API int scm_is_simple_vector (SCM obj);
SCM_API SCM scm_c_make_vector (size_t len, SCM fill);
SCM_API size_t scm_c_vector_length (SCM vec);
SCM_API SCM scm_c_vector_ref (SCM vec, size_t k);
@ -65,11 +64,11 @@ SCM_API SCM *scm_vector_writable_elements (SCM vec,
SCM_ASSERT (scm_is_vector (v) && len == scm_c_vector_length (v), v, pos, FUNC_NAME); \
} while (0)
/* Fast, non-checking accessors for simple vectors.
/* Fast, non-checking accessors.
*/
#define SCM_SIMPLE_VECTOR_LENGTH(x) SCM_I_VECTOR_LENGTH(x)
#define SCM_SIMPLE_VECTOR_REF(x,idx) ((SCM_I_VECTOR_ELTS(x))[idx])
#define SCM_SIMPLE_VECTOR_SET(x,idx,val) ((SCM_I_VECTOR_WELTS(x))[idx]=(val))
#define SCM_VECTOR_LENGTH(x) SCM_I_VECTOR_LENGTH(x)
#define SCM_VECTOR_REF(x,idx) ((SCM_I_VECTOR_ELTS(x))[idx])
#define SCM_VECTOR_SET(x,idx,val) ((SCM_I_VECTOR_WELTS(x))[idx]=(val))
/* Internals */

14
libguile/vports.c
View file

@ -207,18 +207,18 @@ SCM_DEFINE (scm_make_soft_port, "make-soft-port", 2, 0, 0,
struct soft_port *stream;
SCM_VALIDATE_VECTOR (1, pv);
vlen = SCM_SIMPLE_VECTOR_LENGTH (pv);
vlen = SCM_VECTOR_LENGTH (pv);
SCM_ASSERT ((vlen == 5) || (vlen == 6), pv, 1, FUNC_NAME);
SCM_VALIDATE_STRING (2, modes);
stream = scm_gc_typed_calloc (struct soft_port);
stream->write_char = SCM_SIMPLE_VECTOR_REF (pv, 0);
stream->write_string = SCM_SIMPLE_VECTOR_REF (pv, 1);
stream->flush = SCM_SIMPLE_VECTOR_REF (pv, 2);
stream->read_char = SCM_SIMPLE_VECTOR_REF (pv, 3);
stream->close = SCM_SIMPLE_VECTOR_REF (pv, 4);
stream->write_char = SCM_VECTOR_REF (pv, 0);
stream->write_string = SCM_VECTOR_REF (pv, 1);
stream->flush = SCM_VECTOR_REF (pv, 2);
stream->read_char = SCM_VECTOR_REF (pv, 3);
stream->close = SCM_VECTOR_REF (pv, 4);
stream->input_waiting =
vlen == 6 ? SCM_SIMPLE_VECTOR_REF (pv, 5) : SCM_BOOL_F;
vlen == 6 ? SCM_VECTOR_REF (pv, 5) : SCM_BOOL_F;
return scm_c_make_port (scm_soft_port_type, scm_i_mode_bits (modes),
(scm_t_bits) stream);

4
libguile/weak-vector.c
View file

@ -69,7 +69,7 @@ scm_c_make_weak_vector (size_t len, SCM fill)
}
else
for (j = 0; j < len; j++)
SCM_SIMPLE_VECTOR_SET (wv, j, fill);
SCM_VECTOR_SET (wv, j, fill);
return wv;
}
@ -180,7 +180,7 @@ weak_vector_ref (void *data)
{
struct weak_vector_ref_data *d = data;
return (void *) SCM_UNPACK (SCM_SIMPLE_VECTOR_REF (d->wv, d->k));
return (void *) SCM_UNPACK (SCM_VECTOR_REF (d->wv, d->k));
}
SCM