[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Guile-commits] 05/27: Simple vectors are just vectors
From: |
Daniel Llorens |
Subject: |
[Guile-commits] 05/27: Simple vectors are just vectors |
Date: |
Thu, 20 Feb 2020 03:45:39 -0500 (EST) |
lloda pushed a commit to branch wip-vector-cleanup
in repository guile.
commit 7ce9de479339600f01d5f1a407c468b7ca111e50
Author: Daniel Llorens <address@hidden>
AuthorDate: Mon Feb 3 14:30:26 2020 +0100
Simple vectors are just vectors
* 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.
---
NEWS-array-fixes.txt | 36 +++++++++++++++++++++-
doc/ref/api-data.texi | 43 +++++++++-----------------
libguile/arrays.c | 6 ++--
libguile/eval.c | 6 ++--
libguile/filesys.c | 78 +++++++++++++++++++++++------------------------
libguile/hash.c | 2 +-
libguile/hashtab.c | 56 +++++++++++++++++-----------------
libguile/hashtab.h | 6 ++--
libguile/intrinsics.c | 12 ++++----
libguile/memoize.c | 6 ++--
libguile/net_db.c | 54 ++++++++++++++++----------------
libguile/poll.c | 6 ++--
libguile/ports-internal.h | 16 +++++-----
libguile/ports.c | 8 ++---
libguile/posix.c | 48 ++++++++++++++---------------
libguile/print.c | 12 ++++----
libguile/print.h | 2 +-
libguile/regex-posix.c | 6 ++--
libguile/scmsigs.c | 22 ++++++-------
libguile/socket.c | 52 +++++++++++++++----------------
libguile/srfi-1.c | 6 ++--
libguile/stime.c | 70 +++++++++++++++++++++---------------------
libguile/trees.c | 6 ++--
libguile/vectors.c | 12 ++------
libguile/vectors.h | 9 +++---
libguile/vports.c | 14 ++++-----
libguile/weak-vector.c | 4 +--
27 files changed, 306 insertions(+), 292 deletions(-)
diff --git a/NEWS-array-fixes.txt b/NEWS-array-fixes.txt
index 6d97a52..3cc1c97 100644
--- a/NEWS-array-fixes.txt
+++ b/NEWS-array-fixes.txt
@@ -1,10 +1,12 @@
+(vector-array-handle-plan for Guile 3.0) -*- coding: utf-8; mode: org; -*-
TBA to NEWS for this branch.
+
* Forward incompatible changes
Applying these changes will make your program work with this version of
-Guile and continue working with older versions.
+Guile and continue working with older versions, at least back to 2.2.
** vector->list and vector-copy require a true vector argument.
@@ -15,6 +17,11 @@ Use array->list and array-copy (from (ice-9 arrays)) on
general arrays.
Use scm_array_get_handle and scm_array_handle_elements /
scm_array_handle_writable_elements on general arrays.
+** scm_is_simple_vector has been removed.
+
+Use scm_is_vector instead.
+
+
* Backward incompatible changes
Applying these changes will make your program work with this version of
@@ -26,3 +33,30 @@ This function used to take a second unused argument for the
sake of
compatibility with older versions of Guile. Just remove this argument from your
calls.
+** SCM_SIMPLE_VECTOR_REF, SCM_SIMPLE_VECTOR_SET and SCM_SIMPLE_VECTOR_LENGTH
have been renamed.
+
+Use SCM_VECTOR_REF, SCM_VECTOR_SET and SCM_VECTOR_LENGTH instead.
+
+
+* Rationale / TODO
+
+** Fix API for scm_vector_elements scm_vector_writable_elements to [(SCM vec)
-> pointer]
+
+ - incp is always one on these types, so it isn't needed
+ - no need to acquire/release an array handle for VECTOR_TYPE
+ - remove the dependence of vector.c bitvector.c bytevector.c etc. on
array-handle.h
+
+** Remove scm_is_simple_vector, fix scm_is_array_p, rename SIMPLE_VECTOR to
VECTOR, etc.
+
+ - just cleaning house
+
+** vector-move-right!, vector-move-left!, either
+
+ - work only on vector type, use array-copy! and make-shared-array (or future
slicing facility) for general arrays
+ - rename to array-move... and make type generic
+ - remove entirely and just use array-copy!
+
+** basic rank-1 ops on VECTOR_TYPEs need (len begin inc) instead of (begin end)
+
+ - look at CBLAS/BLIS
+ - this is a problem because all the RnRS & SRFIs use (begin end) :-(
diff --git a/doc/ref/api-data.texi b/doc/ref/api-data.texi
index c70e3e2..805bb36 100644
--- a/doc/ref/api-data.texi
+++ b/doc/ref/api-data.texi
@@ -6420,38 +6420,25 @@ same vector, @code{vector-move-right!} is usually
appropriate when
A vector can be read and modified from C with the functions
@code{scm_c_vector_ref} and @code{scm_c_vector_set_x}, for example. In
addition to these functions, there are two more ways to access vectors
-from C that might be more efficient in certain situations: you can
-restrict yourself to @dfn{simple vectors} and then use the very fast
-@emph{simple vector macros}; or you can use the very general framework
-for accessing all kinds of arrays (@pxref{Accessing Arrays from C}),
-which is more verbose, but can deal efficiently with all kinds of
-vectors (and arrays). For vectors, you can use the
-@code{scm_vector_elements} and @code{scm_vector_writable_elements}
-functions as shortcuts.
-
-@deftypefn {C Function} int scm_is_simple_vector (SCM obj)
-Return non-zero if @var{obj} is a simple vector, else return zero. A
-simple vector is a vector that can be used with the @code{SCM_SIMPLE_*}
-macros below.
-
-The following functions are guaranteed to return simple vectors:
-@code{scm_make_vector}, @code{scm_c_make_vector}, @code{scm_vector},
-@code{scm_list_to_vector}.
+from C that might be more efficient in certain situations: you can use
+the very fast @emph{vector macros}, which assume that the arguments are
+actual vectors (in the sense of @code{vector?}) and do no type checking;
+or you can use the very general framework for accessing all kinds of
+arrays (@pxref{Accessing Arrays from C}).
+
+@deftypefn {C Macro} size_t SCM_VECTOR_LENGTH (SCM vec)
+Evaluates to the length of the vector @var{vec}. No type checking is
+done.
@end deftypefn
-@deftypefn {C Macro} size_t SCM_SIMPLE_VECTOR_LENGTH (SCM vec)
-Evaluates to the length of the simple vector @var{vec}. No type
-checking is done.
+@deftypefn {C Macro} SCM SCM_VECTOR_REF (SCM vec, size_t idx)
+Evaluates to the element at position @var{idx} in the vector @var{vec}.
+No type or range checking is done.
@end deftypefn
-@deftypefn {C Macro} SCM SCM_SIMPLE_VECTOR_REF (SCM vec, size_t idx)
-Evaluates to the element at position @var{idx} in the simple vector
-@var{vec}. No type or range checking is done.
-@end deftypefn
-
-@deftypefn {C Macro} void SCM_SIMPLE_VECTOR_SET (SCM vec, size_t idx, SCM val)
-Sets the element at position @var{idx} in the simple vector
-@var{vec} to @var{val}. No type or range checking is done.
+@deftypefn {C Macro} void SCM_VECTOR_SET (SCM vec, size_t idx, SCM val)
+Sets the element at position @var{idx} in the vector @var{vec} to
+@var{val}. No type or range checking is done.
@end deftypefn
@deftypefn {C Function} {const SCM *} scm_vector_elements (SCM vec,
scm_t_array_handle *handle, size_t *lenp, ssize_t *incp)
diff --git a/libguile/arrays.c b/libguile/arrays.c
index 0a91951..d5f4f6a 100644
--- a/libguile/arrays.c
+++ b/libguile/arrays.c
@@ -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)
diff --git a/libguile/eval.c b/libguile/eval.c
index db6d3a5..06e0e7b 100644
--- a/libguile/eval.c
+++ b/libguile/eval.c
@@ -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)
diff --git a/libguile/filesys.c b/libguile/filesys.c
index 4f71153..a7442b6 100644
--- a/libguile/filesys.c
+++ b/libguile/filesys.c
@@ -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
{
diff --git a/libguile/hash.c b/libguile/hash.c
index d6e93da..72d8577 100644
--- a/libguile/hash.c
+++ b/libguile/hash.c
@@ -312,7 +312,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)
diff --git a/libguile/hashtab.c b/libguile/hashtab.c
index b4f004c..6be1615 100644
--- a/libguile/hashtab.c
+++ b/libguile/hashtab.c
@@ -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))
diff --git a/libguile/hashtab.h b/libguile/hashtab.h
index 61e81b3..b314dab 100644
--- a/libguile/hashtab.h
+++ b/libguile/hashtab.h
@@ -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,
diff --git a/libguile/intrinsics.c b/libguile/intrinsics.c
index de03759..91b945b 100644
--- a/libguile/intrinsics.c
+++ b/libguile/intrinsics.c
@@ -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;
diff --git a/libguile/memoize.c b/libguile/memoize.c
index d9e614f..63672a0 100644
--- a/libguile/memoize.c
+++ b/libguile/memoize.c
@@ -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*");
diff --git a/libguile/net_db.c b/libguile/net_db.c
index dfb61e8..db20071 100644
--- a/libguile/net_db.c
+++ b/libguile/net_db.c
@@ -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;
}
diff --git a/libguile/poll.c b/libguile/poll.c
index 82281ff..eb31646 100644
--- a/libguile/poll.c
+++ b/libguile/poll.c
@@ -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))
diff --git a/libguile/ports-internal.h b/libguile/ports-internal.h
index 4e0a72f..a807565 100644
--- a/libguile/ports-internal.h
+++ b/libguile/ports-internal.h
@@ -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
diff --git a/libguile/ports.c b/libguile/ports.c
index 65823f9..cb1ae17 100644
--- a/libguile/ports.c
+++ b/libguile/ports.c
@@ -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;
diff --git a/libguile/posix.c b/libguile/posix.c
index a1520ab..ab64b58 100644
--- a/libguile/posix.c
+++ b/libguile/posix.c
@@ -279,7 +279,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;
@@ -306,18 +306,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);
@@ -325,7 +325,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 */
@@ -370,19 +370,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
@@ -436,10 +436,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
@@ -1553,14 +1553,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;
}
diff --git a/libguile/print.c b/libguile/print.c
index b10f0f8..a28987c 100644
--- a/libguile/print.c
+++ b/libguile/print.c
@@ -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;
diff --git a/libguile/print.h b/libguile/print.h
index b9cc20a..5874753 100644
--- a/libguile/print.h
+++ b/libguile/print.h
@@ -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;
diff --git a/libguile/regex-posix.c b/libguile/regex-posix.c
index a08da02..ac309c7 100644
--- a/libguile/regex-posix.c
+++ b/libguile/regex-posix.c
@@ -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)));
}
diff --git a/libguile/scmsigs.c b/libguile/scmsigs.c
index d1daf04..66f81d9 100644
--- a/libguile/scmsigs.c
+++ b/libguile/scmsigs.c
@@ -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
}
diff --git a/libguile/socket.c b/libguile/socket.c
index 64354f1..f903a96 100644
--- a/libguile/socket.c
+++ b/libguile/socket.c
@@ -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));
diff --git a/libguile/srfi-1.c b/libguile/srfi-1.c
index ca81293..c51ceec 100644
--- a/libguile/srfi-1.c
+++ b/libguile/srfi-1.c
@@ -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));
diff --git a/libguile/stime.c b/libguile/stime.c
index c0ce8dc..9c8e56c 100644
--- a/libguile/stime.c
+++ b/libguile/stime.c
@@ -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)
diff --git a/libguile/trees.c b/libguile/trees.c
index 32ff984..186982a 100644
--- a/libguile/trees.c
+++ b/libguile/trees.c
@@ -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;
diff --git a/libguile/vectors.c b/libguile/vectors.c
index c837d82..fc71fda 100644
--- a/libguile/vectors.c
+++ b/libguile/vectors.c
@@ -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
@@ -263,7 +257,7 @@ scm_c_make_vector (size_t k, SCM fill)
vector = scm_words ((k << 8) | scm_tc7_vector, k + 1);
for (j = 0; j < k; ++j)
- SCM_SIMPLE_VECTOR_SET (vector, j, fill);
+ SCM_VECTOR_SET (vector, j, fill);
return vector;
}
diff --git a/libguile/vectors.h b/libguile/vectors.h
index 41e2c89..48647a8 100644
--- a/libguile/vectors.h
+++ b/libguile/vectors.h
@@ -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 */
diff --git a/libguile/vports.c b/libguile/vports.c
index 7ec10dd..8bba683 100644
--- a/libguile/vports.c
+++ b/libguile/vports.c
@@ -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);
diff --git a/libguile/weak-vector.c b/libguile/weak-vector.c
index b087891..d056dab 100644
--- a/libguile/weak-vector.c
+++ b/libguile/weak-vector.c
@@ -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
- [Guile-commits] 07/27: Simplify interfaces to scm_bitvector_elements and scm_bitvector_writable_elements, (continued)
- [Guile-commits] 07/27: Simplify interfaces to scm_bitvector_elements and scm_bitvector_writable_elements, Daniel Llorens, 2020/02/20
- [Guile-commits] 11/27: Add lenp parameter back to scm_bitvector_(writable_)elements, Daniel Llorens, 2020/02/20
- [Guile-commits] 09/27: Simplify interfaces to scm_TYPEvector_(writable_)elements, Daniel Llorens, 2020/02/20
- [Guile-commits] 16/27: Pull generalized-vectors from under bitvector/string/vector, Daniel Llorens, 2020/02/20
- [Guile-commits] 18/27: Pull generalized-vectors from under bytevectors, Daniel Llorens, 2020/02/20
- [Guile-commits] 20/27: Update branch news file, Daniel Llorens, 2020/02/20
- [Guile-commits] 26/27: Simplify vector constructor, Daniel Llorens, 2020/02/20
- [Guile-commits] 24/27: Move uniform-array->bytevector from (rnrs bytevectors) to core, Daniel Llorens, 2020/02/20
- [Guile-commits] 17/27: Pull generalized-vectors from under typed vectors, Daniel Llorens, 2020/02/20
- [Guile-commits] 15/27: Rewrite vector-copy! using memmove, Daniel Llorens, 2020/02/20
- [Guile-commits] 05/27: Simple vectors are just vectors,
Daniel Llorens <=
- [Guile-commits] 23/27: Remove 'contiguous' flag in arrays, Daniel Llorens, 2020/02/20
- [Guile-commits] 27/27: Reuse SCM_ASSERT_RANGE in scm_c_vector_ref, scm_c_vector_set_x, Daniel Llorens, 2020/02/20
- [Guile-commits] 21/27: Merge generalized-arrays.[ch] in arrays.[ch], Daniel Llorens, 2020/02/20
- [Guile-commits] 19/27: Remove generalized-vectors.[hc], Daniel Llorens, 2020/02/20
- [Guile-commits] 25/27: Remove superfluous type check in bitvector->list, Daniel Llorens, 2020/02/20