-/* Copyright (C) 1995,1996,1997,1998 Free Software Foundation, Inc.
+/* Copyright (C) 1995,1996,1997,1998, 2000, 2001 Free Software Foundation, Inc.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
/* Software engineering face-lift by Greg J. Badros, 11-Dec-1999,
gjb@cs.washington.edu, http://www.cs.washington.edu/homes/gjb */
+/*
+ This file has code for arrays in lots of variants (double, integer,
+ unsigned etc. ). It suffers from hugely repetitive code because
+ there is similar (but different) code for every variant included. (urg.)
+
+ --hwn
+*/
\f
#include <stdio.h>
-#include "_scm.h"
-#include "chars.h"
-#include "eval.h"
-#include "fports.h"
-#include "smob.h"
-#include "strop.h"
-#include "feature.h"
-
-#include "scm_validate.h"
-#include "unif.h"
-#include "ramap.h"
+#include "libguile/_scm.h"
+#include "libguile/chars.h"
+#include "libguile/eval.h"
+#include "libguile/fports.h"
+#include "libguile/smob.h"
+#include "libguile/strop.h"
+#include "libguile/feature.h"
+#include "libguile/root.h"
+#include "libguile/strings.h"
+#include "libguile/vectors.h"
+
+#include "libguile/validate.h"
+#include "libguile/unif.h"
+#include "libguile/ramap.h"
#ifdef HAVE_UNISTD_H
#include <unistd.h>
* long long llvect
*/
-long scm_tc16_array;
+scm_bits_t scm_tc16_array;
/* return the size of an element in a uniform array or 0 if type not
found. */
break;
#endif
-#ifdef SCM_FLOATS
-#ifdef SCM_SINGLES
case scm_tc7_fvect:
result = sizeof (float);
break;
-#endif
case scm_tc7_dvect:
result = sizeof (double);
case scm_tc7_cvect:
result = 2 * sizeof (double);
break;
-#endif
default:
result = 0;
return result;
}
-
-#ifdef SCM_FLOATS
-#ifdef SCM_SINGLES
-
-
-SCM
-scm_makflo (float x)
+/* Silly function used not to modify the semantics of the silly
+ * prototype system in order to be backward compatible.
+ */
+static int
+singp (SCM obj)
{
- SCM z;
- if (x == 0.0)
- return scm_flo0;
- SCM_NEWCELL (z);
- SCM_DEFER_INTS;
- SCM_SETCAR (z, scm_tc_flo);
- SCM_FLO (z) = x;
- SCM_ALLOW_INTS;
- return z;
+ if (!SCM_SLOPPY_REALP (obj))
+ return 0;
+ else
+ {
+ double x = SCM_REAL_VALUE (obj);
+ float fx = x;
+ return (- SCM_FLTMAX < x) && (x < SCM_FLTMAX) && (fx == x);
+ }
}
-#endif
-#endif
-
SCM
scm_make_uve (long k, SCM prot)
+#define FUNC_NAME "scm_make_uve"
{
SCM v;
long i, type;
- if (SCM_BOOL_T == prot)
+
+ if (SCM_EQ_P (prot, SCM_BOOL_T))
{
- i = sizeof (long) * ((k + SCM_LONG_BIT - 1) / SCM_LONG_BIT);
- type = scm_tc7_bvect;
+ SCM_NEWCELL (v);
+ if (k > 0)
+ {
+ SCM_ASSERT_RANGE (1, scm_long2num (k), k <= SCM_BITVECTOR_MAX_LENGTH);
+ i = sizeof (long) * ((k + SCM_LONG_BIT - 1) / SCM_LONG_BIT);
+ SCM_SET_BITVECTOR_BASE (v, (char *) scm_must_malloc (i, "vector"));
+ SCM_SET_BITVECTOR_LENGTH (v, k);
+ }
+ else
+ {
+ SCM_SET_BITVECTOR_BASE (v, 0);
+ SCM_SET_BITVECTOR_LENGTH (v, 0);
+ }
+ return v;
}
- else if (SCM_ICHRP (prot) && (prot == SCM_MAKICHR ('\0')))
+ else if (SCM_CHARP (prot) && (SCM_CHAR (prot) == '\0'))
{
i = sizeof (char) * k;
type = scm_tc7_byvect;
- }
- else if (SCM_ICHRP (prot))
+ }
+ else if (SCM_CHARP (prot))
{
i = sizeof (char) * k;
- type = scm_tc7_string;
+ return scm_makstr (i, 0);
}
else if (SCM_INUMP (prot))
{
else
type = scm_tc7_ivect;
}
- else if (SCM_SYMBOLP (prot) && (1 == SCM_LENGTH (prot)))
+ else if (SCM_SYMBOLP (prot) && (1 == SCM_SYMBOL_LENGTH (prot)))
{
char s;
- s = SCM_CHARS (prot)[0];
+ s = SCM_SYMBOL_CHARS (prot)[0];
if (s == 's')
{
i = sizeof (short) * k;
#endif
else
{
- return scm_make_vector (SCM_MAKINUM (k), SCM_UNDEFINED);
+ return scm_c_make_vector (k, SCM_UNDEFINED);
}
}
- else
-#ifdef SCM_FLOATS
- if (SCM_IMP (prot) || !SCM_INEXP (prot))
-#endif
+ else if (!SCM_INEXACTP (prot))
/* Huge non-unif vectors are NOT supported. */
/* no special scm_vector */
- return scm_make_vector (SCM_MAKINUM (k), SCM_UNDEFINED);
-#ifdef SCM_FLOATS
-#ifdef SCM_SINGLES
- else if (SCM_SINGP (prot))
-
+ return scm_c_make_vector (k, SCM_UNDEFINED);
+ else if (singp (prot))
{
i = sizeof (float) * k;
type = scm_tc7_fvect;
}
-#endif
- else if (SCM_CPLXP (prot))
+ else if (SCM_COMPLEXP (prot))
{
i = 2 * sizeof (double) * k;
type = scm_tc7_cvect;
i = sizeof (double) * k;
type = scm_tc7_dvect;
}
-#endif
+
+ SCM_ASSERT_RANGE (1, scm_long2num (k), k <= SCM_UVECTOR_MAX_LENGTH);
SCM_NEWCELL (v);
SCM_DEFER_INTS;
- SCM_SETCHARS (v, (char *) scm_must_malloc (i ? i : 1, "vector"));
- SCM_SETLENGTH (v, (k < SCM_LENGTH_MAX ? k : SCM_LENGTH_MAX), type);
+ SCM_SET_UVECTOR_BASE (v, (char *) scm_must_malloc (i ? i : 1, "vector"));
+ SCM_SET_UVECTOR_LENGTH (v, k, type);
SCM_ALLOW_INTS;
return v;
}
+#undef FUNC_NAME
+
SCM_DEFINE (scm_uniform_vector_length, "uniform-vector-length", 1, 0, 0,
(SCM v),
#define FUNC_NAME s_scm_uniform_vector_length
{
SCM_ASRTGO (SCM_NIMP (v), badarg1);
- switch SCM_TYP7
- (v)
+ switch SCM_TYP7 (v)
{
default:
badarg1:SCM_WTA(1,v);
- case scm_tc7_bvect:
+ case scm_tc7_vector:
+ case scm_tc7_wvect:
+ return SCM_MAKINUM (SCM_VECTOR_LENGTH (v));
case scm_tc7_string:
+ return SCM_MAKINUM (SCM_STRING_LENGTH (v));
+ case scm_tc7_bvect:
+ return SCM_MAKINUM (SCM_BITVECTOR_LENGTH (v));
case scm_tc7_byvect:
case scm_tc7_uvect:
case scm_tc7_ivect:
case scm_tc7_fvect:
case scm_tc7_dvect:
case scm_tc7_cvect:
- case scm_tc7_vector:
- case scm_tc7_wvect:
case scm_tc7_svect:
#ifdef HAVE_LONG_LONGS
case scm_tc7_llvect:
#endif
- return SCM_MAKINUM (SCM_LENGTH (v));
+ return SCM_MAKINUM (SCM_UVECTOR_LENGTH (v));
}
}
#undef FUNC_NAME
enclosed = 0;
if (SCM_IMP (v))
return SCM_BOOL_F;
-loop:
- switch (SCM_TYP7 (v))
+
+ while (SCM_TYP7 (v) == scm_tc7_smob)
{
- case scm_tc7_smob:
if (!SCM_ARRAYP (v))
return SCM_BOOL_F;
if (nprot)
if (enclosed++)
return SCM_BOOL_F;
v = SCM_ARRAY_V (v);
- goto loop;
- case scm_tc7_bvect:
- return nprot || SCM_BOOL(SCM_BOOL_T==prot);
- case scm_tc7_string:
- return nprot || SCM_BOOL(SCM_ICHRP(prot) && (prot != SCM_MAKICHR('\0')));
- case scm_tc7_byvect:
- return nprot || SCM_BOOL(prot == SCM_MAKICHR('\0'));
- case scm_tc7_uvect:
- return nprot || SCM_BOOL(SCM_INUMP(prot) && SCM_INUM(prot)>0);
- case scm_tc7_ivect:
- return nprot || SCM_BOOL(SCM_INUMP(prot) && SCM_INUM(prot)<=0);
- case scm_tc7_svect:
- return ( nprot
- || (SCM_SYMBOLP (prot)
- && (1 == SCM_LENGTH (prot))
- && ('s' == SCM_CHARS (prot)[0])));
+ }
+ if (nprot)
+ return SCM_BOOL(nprot);
+ else
+ {
+ int protp = 0;
+
+ switch (SCM_TYP7 (v))
+ {
+ case scm_tc7_bvect:
+ protp = (SCM_EQ_P (prot, SCM_BOOL_T));
+ case scm_tc7_string:
+ protp = SCM_CHARP(prot) && (SCM_CHAR (prot) != '\0');
+ case scm_tc7_byvect:
+ protp = SCM_EQ_P (prot, SCM_MAKE_CHAR ('\0'));
+ case scm_tc7_uvect:
+ protp = SCM_INUMP(prot) && SCM_INUM(prot)>0;
+ case scm_tc7_ivect:
+ protp = SCM_INUMP(prot) && SCM_INUM(prot)<=0;
+
+ case scm_tc7_svect:
+ protp = SCM_SYMBOLP (prot)
+ && (1 == SCM_SYMBOL_LENGTH (prot))
+ && ('s' == SCM_SYMBOL_CHARS (prot)[0]);
#ifdef HAVE_LONG_LONGS
- case scm_tc7_llvect:
- return ( nprot
- || (SCM_SYMBOLP (prot)
- && (1 == SCM_LENGTH (prot))
- && ('s' == SCM_CHARS (prot)[0])));
+ case scm_tc7_llvect:
+ protp = SCM_SYMBOLP (prot)
+ && (1 == SCM_SYMBOL_LENGTH (prot))
+ && ('s' == SCM_SYMBOL_CHARS (prot)[0]);
#endif
-# ifdef SCM_FLOATS
-# ifdef SCM_SINGLES
- case scm_tc7_fvect:
- return nprot || SCM_BOOL(SCM_SINGP(prot));
-# endif
- case scm_tc7_dvect:
- return nprot || SCM_BOOL(SCM_REALP(prot));
- case scm_tc7_cvect:
- return nprot || SCM_BOOL(SCM_CPLXP(prot));
-# endif
- case scm_tc7_vector:
- case scm_tc7_wvect:
- return nprot || SCM_BOOL(SCM_NULLP(prot));
- default:;
+ case scm_tc7_fvect:
+ protp = singp (prot);
+ case scm_tc7_dvect:
+ protp = SCM_REALP(prot);
+ case scm_tc7_cvect:
+ protp = SCM_COMPLEXP(prot);
+ case scm_tc7_vector:
+ case scm_tc7_wvect:
+ protp = SCM_NULLP(prot);
+ default:
+ /* no default */
+ ;
+ }
+ return SCM_BOOL(protp);
}
- return SCM_BOOL_F;
}
#undef FUNC_NAME
#ifdef HAVE_LONG_LONGS
case scm_tc7_llvect:
#endif
- return scm_cons (SCM_MAKINUM (SCM_LENGTH (ra)), SCM_EOL);
+ return scm_cons (scm_uniform_vector_length (ra), SCM_EOL);
case scm_tc7_smob:
if (!SCM_ARRAYP (ra))
return SCM_BOOL_F;
k = SCM_ARRAY_NDIM (ra);
s = SCM_ARRAY_DIMS (ra);
while (k--)
- res = scm_cons (s[k].lbnd ? scm_cons2 (SCM_MAKINUM (s[k].lbnd), SCM_MAKINUM (s[k].ubnd), SCM_EOL) :
- SCM_MAKINUM (1 + (s[k].ubnd))
- , res);
+ res = scm_cons (s[k].lbnd
+ ? scm_cons2 (SCM_MAKINUM (s[k].lbnd),
+ SCM_MAKINUM (s[k].ubnd),
+ SCM_EOL)
+ : SCM_MAKINUM (1 + s[k].ubnd),
+ res);
return res;
}
}
#undef FUNC_NAME
+SCM_DEFINE (scm_shared_array_root, "shared-array-root", 1, 0, 0,
+ (SCM ra),
+ "Return the root vector of a shared array.")
+#define FUNC_NAME s_scm_shared_array_root
+{
+ SCM_ASSERT (SCM_ARRAYP (ra), ra, SCM_ARG1, FUNC_NAME);
+ return SCM_ARRAY_V (ra);
+}
+#undef FUNC_NAME
+
+
+SCM_DEFINE (scm_shared_array_offset, "shared-array-offset", 1, 0, 0,
+ (SCM ra),
+ "Return the root vector index of the first element in the array.")
+#define FUNC_NAME s_scm_shared_array_offset
+{
+ SCM_ASSERT (SCM_ARRAYP (ra), ra, SCM_ARG1, FUNC_NAME);
+ return SCM_MAKINUM (SCM_ARRAY_BASE (ra));
+}
+#undef FUNC_NAME
+
+
+SCM_DEFINE (scm_shared_array_increments, "shared-array-increments", 1, 0, 0,
+ (SCM ra),
+ "For each dimension, return the distance between elements in the root vector.")
+#define FUNC_NAME s_scm_shared_array_increments
+{
+ SCM res = SCM_EOL;
+ scm_sizet k;
+ scm_array_dim *s;
+ SCM_ASSERT (SCM_ARRAYP (ra), ra, SCM_ARG1, FUNC_NAME);
+ k = SCM_ARRAY_NDIM (ra);
+ s = SCM_ARRAY_DIMS (ra);
+ while (k--)
+ res = scm_cons (SCM_MAKINUM (s[k].inc), res);
+ return res;
+}
+#undef FUNC_NAME
+
+
static char s_bad_ind[] = "Bad scm_array index";
args = SCM_CDR (args);
SCM_ASSERT (SCM_INUMP (ind), ind, s_bad_ind, what);
j = SCM_INUM (ind);
- SCM_ASSERT (j >= (s->lbnd) && j <= (s->ubnd), ind, SCM_OUTOFRANGE, what);
+ if (j < s->lbnd || j > s->ubnd)
+ scm_out_of_range (what, ind);
pos += (j - s->lbnd) * (s->inc);
k--;
s++;
ra = scm_make_ra (ndim);
SCM_ARRAY_BASE (ra) = 0;
s = SCM_ARRAY_DIMS (ra);
- for (; SCM_NIMP (args); s++, args = SCM_CDR (args))
+ for (; !SCM_NULLP (args); s++, args = SCM_CDR (args))
{
spec = SCM_CAR (args);
- if (SCM_IMP (spec))
-
+ if (SCM_INUMP (spec))
{
- SCM_ASSERT (SCM_INUMP (spec) && SCM_INUM (spec) >= 0, spec,
- s_bad_spec, what);
+ SCM_ASSERT (SCM_INUM (spec) >= 0, spec, s_bad_spec, what);
s->lbnd = 0;
s->ubnd = SCM_INUM (spec) - 1;
s->inc = 1;
"@var{prototype} is used.")
#define FUNC_NAME s_scm_dimensions_to_uniform_array
{
- scm_sizet k, vlen = 1;
- long rlen = 1;
+ scm_sizet k;
+ unsigned long int rlen = 1;
scm_array_dim *s;
SCM ra;
if (SCM_INUMP (dims))
{
- if (SCM_INUM (dims) < SCM_LENGTH_MAX)
- {
- SCM answer = scm_make_uve (SCM_INUM (dims), prot);
-
- if (!SCM_UNBNDP (fill))
- scm_array_fill_x (answer, fill);
- else if (SCM_SYMBOLP (prot))
- scm_array_fill_x (answer, SCM_MAKINUM (0));
- else
- scm_array_fill_x (answer, prot);
- return answer;
- }
- else
- dims = scm_cons (dims, SCM_EOL);
+ SCM answer = scm_make_uve (SCM_INUM (dims), prot);
+ if (!SCM_UNBNDP (fill))
+ scm_array_fill_x (answer, fill);
+ else if (SCM_SYMBOLP (prot))
+ scm_array_fill_x (answer, SCM_MAKINUM (0));
+ else
+ scm_array_fill_x (answer, prot);
+ return answer;
}
SCM_ASSERT (SCM_NULLP (dims) || SCM_CONSP (dims),
dims, SCM_ARG1, FUNC_NAME);
k = SCM_ARRAY_NDIM (ra);
while (k--)
{
- s[k].inc = (rlen > 0 ? rlen : 0);
+ s[k].inc = rlen;
+ SCM_ASSERT_RANGE (1, dims, s[k].lbnd <= s[k].ubnd);
rlen = (s[k].ubnd - s[k].lbnd + 1) * s[k].inc;
- vlen *= (s[k].ubnd - s[k].lbnd + 1);
- }
- if (rlen < SCM_LENGTH_MAX)
- SCM_ARRAY_V (ra) = scm_make_uve ((rlen > 0 ? rlen : 0L), prot);
- else
- {
- scm_sizet bit;
- switch (SCM_TYP7 (scm_make_uve (0L, prot)))
- {
- default:
- bit = SCM_LONG_BIT;
- break;
- case scm_tc7_bvect:
- bit = 1;
- break;
- case scm_tc7_string:
- bit = SCM_CHAR_BIT;
- break;
- case scm_tc7_fvect:
- bit = sizeof (float) * SCM_CHAR_BIT / sizeof (char);
- break;
- case scm_tc7_dvect:
- bit = sizeof (double) * SCM_CHAR_BIT / sizeof (char);
- break;
- case scm_tc7_cvect:
- bit = 2 * sizeof (double) * SCM_CHAR_BIT / sizeof (char);
- break;
- }
- SCM_ARRAY_BASE (ra) = (SCM_LONG_BIT + bit - 1) / bit;
- rlen += SCM_ARRAY_BASE (ra);
- SCM_ARRAY_V (ra) = scm_make_uve (rlen, prot);
- *((long *) SCM_VELTS (SCM_ARRAY_V (ra))) = rlen;
}
+
+ SCM_ARRAY_V (ra) = scm_make_uve (rlen, prot);
+
if (!SCM_UNBNDP (fill))
- {
- scm_array_fill_x (ra, fill);
- }
+ scm_array_fill_x (ra, fill);
else if (SCM_SYMBOLP (prot))
scm_array_fill_x (ra, SCM_MAKINUM (0));
else
scm_array_fill_x (ra, prot);
+
if (1 == SCM_ARRAY_NDIM (ra) && 0 == SCM_ARRAY_BASE (ra))
if (s->ubnd < s->lbnd || (0 == s->lbnd && 1 == s->inc))
return SCM_ARRAY_V (ra);
{
SCM_ARRAY_V (ra) = oldra;
old_min = 0;
- old_max = (long) SCM_LENGTH (oldra) - 1;
+ old_max = SCM_INUM (scm_uniform_vector_length (oldra)) - 1;
}
inds = SCM_EOL;
s = SCM_ARRAY_DIMS (ra);
"mapping out of range", FUNC_NAME);
if (1 == SCM_ARRAY_NDIM (ra) && 0 == SCM_ARRAY_BASE (ra))
{
- if (1 == s->inc && 0 == s->lbnd
- && SCM_LENGTH (SCM_ARRAY_V (ra)) == 1 + s->ubnd)
- return SCM_ARRAY_V (ra);
+ SCM v = SCM_ARRAY_V (ra);
+ unsigned long int length = SCM_INUM (scm_uniform_vector_length (v));
+ if (1 == s->inc && 0 == s->lbnd && length == 1 + s->ubnd)
+ return v;
if (s->ubnd < s->lbnd)
return scm_make_uve (0L, scm_array_prototype (ra));
}
/* args are RA . DIMS */
-SCM_DEFINE (scm_transpose_array, "transpose-array", 0, 0, 1,
- (SCM args),
+SCM_DEFINE (scm_transpose_array, "transpose-array", 1, 0, 1,
+ (SCM ra, SCM args),
"Returns an array sharing contents with @var{array}, but with dimensions\n"
"arranged in a different order. There must be one @var{dim} argument for\n"
"each dimension of @var{array}. @var{dim0}, @var{dim1}, @dots{} should\n"
"@end example")
#define FUNC_NAME s_scm_transpose_array
{
- SCM ra, res, vargs, *ve = &vargs;
+ SCM res, vargs, *ve = &vargs;
scm_array_dim *s, *r;
int ndim, i, k;
- SCM_ASSERT (SCM_NNULLP (args), scm_makfrom0str (FUNC_NAME),
- SCM_WNA, NULL);
- ra = SCM_CAR (args);
+
SCM_ASSERT (SCM_NIMP (ra), ra, SCM_ARG1, FUNC_NAME);
- args = SCM_CDR (args);
switch (SCM_TYP7 (ra))
{
default:
#ifdef HAVE_LONG_LONGS
case scm_tc7_llvect:
#endif
- SCM_ASSERT (SCM_NIMP (args) && SCM_NULLP (SCM_CDR (args)),
+ SCM_ASSERT (!SCM_NULLP (args) && SCM_NULLP (SCM_CDR (args)),
scm_makfrom0str (FUNC_NAME), SCM_WNA, NULL);
SCM_ASSERT (SCM_INUMP (SCM_CAR (args)), SCM_CAR (args), SCM_ARG2,
FUNC_NAME);
- SCM_ASSERT (SCM_INUM0 == SCM_CAR (args), SCM_CAR (args), SCM_OUTOFRANGE,
- FUNC_NAME);
+ SCM_ASSERT_RANGE (SCM_ARG2, SCM_CAR (args),
+ SCM_EQ_P (SCM_INUM0, SCM_CAR (args)));
return ra;
case scm_tc7_smob:
SCM_ASRTGO (SCM_ARRAYP (ra), badarg);
vargs = scm_vector (args);
- SCM_ASSERT (SCM_LENGTH (vargs) == SCM_ARRAY_NDIM (ra),
+ SCM_ASSERT (SCM_VECTOR_LENGTH (vargs) == SCM_ARRAY_NDIM (ra),
scm_makfrom0str (FUNC_NAME), SCM_WNA, NULL);
ve = SCM_VELTS (vargs);
ndim = 0;
SCM_ASSERT (SCM_INUMP (ve[k]), ve[k], (SCM_ARG2 + k),
FUNC_NAME);
i = SCM_INUM (ve[k]);
- SCM_ASSERT (i >= 0 && i < SCM_ARRAY_NDIM (ra), ve[k],
- SCM_OUTOFRANGE, FUNC_NAME);
+ if (i < 0 || i >= SCM_ARRAY_NDIM (ra))
+ scm_out_of_range (FUNC_NAME, ve[k]);
if (ndim < i)
ndim = i;
}
#undef FUNC_NAME
/* args are RA . AXES */
-SCM_DEFINE (scm_enclose_array, "enclose-array", 0, 0, 1,
- (SCM axes),
+SCM_DEFINE (scm_enclose_array, "enclose-array", 1, 0, 1,
+ (SCM ra, SCM axes),
"@var{dim0}, @var{dim1} @dots{} should be nonnegative integers less than\n"
"the rank of @var{array}. @var{enclose-array} returns an array\n"
"resembling an array of shared arrays. The dimensions of each shared\n"
"@end example")
#define FUNC_NAME s_scm_enclose_array
{
- SCM axv, ra, res, ra_inr;
+ SCM axv, res, ra_inr;
scm_array_dim vdim, *s = &vdim;
int ndim, j, k, ninr, noutr;
- SCM_ASSERT (SCM_NIMP (axes), scm_makfrom0str (FUNC_NAME), SCM_WNA,
- NULL);
- ra = SCM_CAR (axes);
- axes = SCM_CDR (axes);
+
if (SCM_NULLP (axes))
axes = scm_cons ((SCM_ARRAYP (ra) ? SCM_MAKINUM (SCM_ARRAY_NDIM (ra) - 1) : SCM_INUM0), SCM_EOL);
ninr = scm_ilength (axes);
+ SCM_ASSERT (0 <= ninr, scm_makfrom0str (FUNC_NAME), SCM_WNA, NULL);
ra_inr = scm_make_ra (ninr);
SCM_ASRTGO (SCM_NIMP (ra), badarg1);
- switch SCM_TYP7
- (ra)
+ switch SCM_TYP7 (ra)
{
default:
badarg1:SCM_WTA (1,ra);
case scm_tc7_llvect:
#endif
s->lbnd = 0;
- s->ubnd = SCM_LENGTH (ra) - 1;
+ s->ubnd = SCM_INUM (scm_uniform_vector_length (ra)) - 1;
s->inc = 1;
SCM_ARRAY_V (ra_inr) = ra;
SCM_ARRAY_BASE (ra_inr) = 0;
break;
}
noutr = ndim - ninr;
- axv = scm_make_string (SCM_MAKINUM (ndim), SCM_MAKICHR (0));
- SCM_ASSERT (0 <= noutr && 0 <= ninr, scm_makfrom0str (FUNC_NAME),
- SCM_WNA, NULL);
+ axv = scm_make_string (SCM_MAKINUM (ndim), SCM_MAKE_CHAR (0));
+ SCM_ASSERT (0 <= noutr, scm_makfrom0str (FUNC_NAME), SCM_WNA, NULL);
res = scm_make_ra (noutr);
SCM_ARRAY_BASE (res) = SCM_ARRAY_BASE (ra_inr);
SCM_ARRAY_V (res) = ra_inr;
SCM_ARRAY_DIMS (ra_inr)[k].lbnd = s[j].lbnd;
SCM_ARRAY_DIMS (ra_inr)[k].ubnd = s[j].ubnd;
SCM_ARRAY_DIMS (ra_inr)[k].inc = s[j].inc;
- SCM_CHARS (axv)[j] = 1;
+ SCM_STRING_CHARS (axv)[j] = 1;
}
for (j = 0, k = 0; k < noutr; k++, j++)
{
- while (SCM_CHARS (axv)[j])
+ while (SCM_STRING_CHARS (axv)[j])
j++;
SCM_ARRAY_DIMS (res)[k].lbnd = s[j].lbnd;
SCM_ARRAY_DIMS (res)[k].ubnd = s[j].ubnd;
-SCM_DEFINE (scm_array_in_bounds_p, "array-in-bounds?", 0, 0, 1,
- (SCM args),
+SCM_DEFINE (scm_array_in_bounds_p, "array-in-bounds?", 1, 0, 1,
+ (SCM v, SCM args),
"Returns @code{#t} if its arguments would be acceptable to array-ref.")
#define FUNC_NAME s_scm_array_in_bounds_p
{
- SCM v, ind = SCM_EOL;
+ SCM ind = SCM_EOL;
long pos = 0;
register scm_sizet k;
register long j;
scm_array_dim *s;
- SCM_ASSERT (SCM_NIMP (args), scm_makfrom0str (FUNC_NAME),
- SCM_WNA, NULL);
- v = SCM_CAR (args);
- args = SCM_CDR (args);
+
SCM_ASRTGO (SCM_NIMP (v), badarg1);
if (SCM_NIMP (args))
pos = SCM_INUM (ind);
}
tail:
- switch SCM_TYP7
- (v)
+ switch SCM_TYP7 (v)
{
default:
badarg1:SCM_WTA (1,v);
#endif
case scm_tc7_vector:
case scm_tc7_wvect:
- SCM_ASRTGO (SCM_NULLP (args) && SCM_INUMP (ind), wna);
- return SCM_BOOL(pos >= 0 && pos < SCM_LENGTH (v));
+ {
+ unsigned long int length = SCM_INUM (scm_uniform_vector_length (v));
+ SCM_ASRTGO (SCM_NULLP (args) && SCM_INUMP (ind), wna);
+ return SCM_BOOL(pos >= 0 && pos < length);
+ }
}
}
#undef FUNC_NAME
SCM_DEFINE (scm_uniform_vector_ref, "uniform-vector-ref", 2, 0, 0,
(SCM v, SCM args),
+ "@deffnx primitive array-ref v . args\n"
"Returns the element at the @code{(index1, index2)} element in @var{array}.")
#define FUNC_NAME s_scm_uniform_vector_ref
{
}
else
{
+ unsigned long int length;
if (SCM_NIMP (args))
-
{
SCM_ASSERT (SCM_CONSP (args) && SCM_INUMP (SCM_CAR (args)), args, SCM_ARG2, FUNC_NAME);
pos = SCM_INUM (SCM_CAR (args));
SCM_VALIDATE_INUM (2,args);
pos = SCM_INUM (args);
}
- SCM_ASRTGO (pos >= 0 && pos < SCM_LENGTH (v), outrng);
+ length = SCM_INUM (scm_uniform_vector_length (v));
+ SCM_ASRTGO (pos >= 0 && pos < length, outrng);
}
- switch SCM_TYP7
- (v)
+ switch SCM_TYP7 (v)
{
default:
if (SCM_NULLP (args))
badarg:
SCM_WTA (1,v);
abort ();
- outrng:scm_out_of_range (FUNC_NAME, SCM_MAKINUM (pos));
- wna: scm_wrong_num_args (SCM_FUNC_NAME);
+
+ outrng:
+ scm_out_of_range (FUNC_NAME, SCM_MAKINUM (pos));
+ wna:
+ scm_wrong_num_args (SCM_FUNC_NAME);
case scm_tc7_smob:
{ /* enclosed */
int k = SCM_ARRAY_NDIM (v);
return res;
}
case scm_tc7_bvect:
- if (SCM_VELTS (v)[pos / SCM_LONG_BIT] & (1L << (pos % SCM_LONG_BIT)))
+ if (SCM_BITVEC_REF (v, pos))
return SCM_BOOL_T;
else
return SCM_BOOL_F;
case scm_tc7_string:
- return SCM_MAKICHR (SCM_UCHARS (v)[pos]);
+ return SCM_MAKE_CHAR (SCM_STRING_UCHARS (v)[pos]);
case scm_tc7_byvect:
- return SCM_MAKINUM (((char *)SCM_CHARS (v))[pos]);
-# ifdef SCM_INUMS_ONLY
- case scm_tc7_uvect:
- case scm_tc7_ivect:
- return SCM_MAKINUM (SCM_VELTS (v)[pos]);
-# else
+ return SCM_MAKINUM (((char *) SCM_UVECTOR_BASE (v))[pos]);
case scm_tc7_uvect:
- return scm_ulong2num(SCM_VELTS(v)[pos]);
+ return scm_ulong2num (((unsigned long *) SCM_VELTS (v))[pos]);
case scm_tc7_ivect:
- return scm_long2num(SCM_VELTS(v)[pos]);
-# endif
+ return scm_long2num(((signed long *) SCM_VELTS (v))[pos]);
case scm_tc7_svect:
- return SCM_MAKINUM (((short *) SCM_CDR (v))[pos]);
+ return SCM_MAKINUM (((short *) SCM_CELL_WORD_1 (v))[pos]);
#ifdef HAVE_LONG_LONGS
case scm_tc7_llvect:
- return scm_long_long2num (((long_long *) SCM_CDR (v))[pos]);
+ return scm_long_long2num (((long_long *) SCM_CELL_WORD_1 (v))[pos]);
#endif
-#ifdef SCM_FLOATS
-#ifdef SCM_SINGLES
case scm_tc7_fvect:
- return scm_makflo (((float *) SCM_CDR (v))[pos]);
-#endif
+ return scm_make_real (((float *) SCM_CELL_WORD_1 (v))[pos]);
case scm_tc7_dvect:
- return scm_makdbl (((double *) SCM_CDR (v))[pos], 0.0);
+ return scm_make_real (((double *) SCM_CELL_WORD_1 (v))[pos]);
case scm_tc7_cvect:
- return scm_makdbl (((double *) SCM_CDR (v))[2 * pos],
- ((double *) SCM_CDR (v))[2 * pos + 1]);
-#endif
+ return scm_make_complex (((double *) SCM_CELL_WORD_1 (v))[2 * pos],
+ ((double *) SCM_CELL_WORD_1 (v))[2 * pos + 1]);
case scm_tc7_vector:
case scm_tc7_wvect:
return SCM_VELTS (v)[pos];
SCM
scm_cvref (SCM v, scm_sizet pos, SCM last)
+#define FUNC_NAME "scm_cvref"
{
switch SCM_TYP7 (v)
{
default:
- scm_wta (v, (char *) SCM_ARG1, "PROGRAMMING ERROR: scm_cvref");
+ SCM_WRONG_TYPE_ARG (SCM_ARG1, v);
case scm_tc7_bvect:
- if (SCM_VELTS (v)[pos / SCM_LONG_BIT] & (1L << (pos % SCM_LONG_BIT)))
+ if (SCM_BITVEC_REF(v,pos))
return SCM_BOOL_T;
else
return SCM_BOOL_F;
case scm_tc7_string:
- return SCM_MAKICHR (SCM_UCHARS (v)[pos]);
+ return SCM_MAKE_CHAR (SCM_STRING_UCHARS (v)[pos]);
case scm_tc7_byvect:
- return SCM_MAKINUM (((char *)SCM_CHARS (v))[pos]);
-# ifdef SCM_INUMS_ONLY
+ return SCM_MAKINUM (((char *) SCM_UVECTOR_BASE (v))[pos]);
case scm_tc7_uvect:
+ return scm_ulong2num(((unsigned long *) SCM_VELTS (v))[pos]);
case scm_tc7_ivect:
- return SCM_MAKINUM (SCM_VELTS (v)[pos]);
-# else
- case scm_tc7_uvect:
- return scm_ulong2num(SCM_VELTS(v)[pos]);
- case scm_tc7_ivect:
- return scm_long2num(SCM_VELTS(v)[pos]);
-# endif
+ return scm_long2num(((signed long *) SCM_VELTS (v))[pos]);
case scm_tc7_svect:
- return SCM_MAKINUM (((short *) SCM_CDR (v))[pos]);
+ return SCM_MAKINUM (((short *) SCM_CELL_WORD_1 (v))[pos]);
#ifdef HAVE_LONG_LONGS
case scm_tc7_llvect:
- return scm_long_long2num (((long_long *) SCM_CDR (v))[pos]);
+ return scm_long_long2num (((long_long *) SCM_CELL_WORD_1 (v))[pos]);
#endif
-#ifdef SCM_FLOATS
-#ifdef SCM_SINGLES
case scm_tc7_fvect:
- if (SCM_NIMP (last) && (last != scm_flo0) && (scm_tc_flo == SCM_CAR (last)))
+ if (SCM_NIMP (last) && !SCM_EQ_P (last, scm_flo0) && SCM_SLOPPY_REALP (last))
{
- SCM_FLO (last) = ((float *) SCM_CDR (v))[pos];
+ SCM_REAL_VALUE (last) = ((float *) SCM_CELL_WORD_1 (v))[pos];
return last;
}
- return scm_makflo (((float *) SCM_CDR (v))[pos]);
-#endif
+ return scm_make_real (((float *) SCM_CELL_WORD_1 (v))[pos]);
case scm_tc7_dvect:
-#ifdef SCM_SINGLES
- if (SCM_NIMP (last) && scm_tc_dblr == SCM_CAR (last))
-#else
- if (SCM_NIMP (last) && (last != scm_flo0) && (scm_tc_dblr == SCM_CAR (last)))
-#endif
+ if (SCM_NIMP (last) && !SCM_EQ_P (last, scm_flo0) && SCM_SLOPPY_REALP (last))
{
- SCM_REAL (last) = ((double *) SCM_CDR (v))[pos];
+ SCM_REAL_VALUE (last) = ((double *) SCM_CELL_WORD_1 (v))[pos];
return last;
}
- return scm_makdbl (((double *) SCM_CDR (v))[pos], 0.0);
+ return scm_make_real (((double *) SCM_CELL_WORD_1 (v))[pos]);
case scm_tc7_cvect:
- if (SCM_NIMP (last) && scm_tc_dblc == SCM_CAR (last))
+ if (SCM_NIMP (last) && SCM_SLOPPY_COMPLEXP (last))
{
- SCM_REAL (last) = ((double *) SCM_CDR (v))[2 * pos];
- SCM_IMAG (last) = ((double *) SCM_CDR (v))[2 * pos + 1];
+ SCM_COMPLEX_REAL (last) = ((double *) SCM_CELL_WORD_1 (v))[2 * pos];
+ SCM_COMPLEX_IMAG (last) = ((double *) SCM_CELL_WORD_1 (v))[2 * pos + 1];
return last;
}
- return scm_makdbl (((double *) SCM_CDR (v))[2 * pos],
- ((double *) SCM_CDR (v))[2 * pos + 1]);
-#endif
+ return scm_make_complex (((double *) SCM_CELL_WORD_1 (v))[2 * pos],
+ ((double *) SCM_CELL_WORD_1 (v))[2 * pos + 1]);
case scm_tc7_vector:
case scm_tc7_wvect:
return SCM_VELTS (v)[pos];
}
}
}
+#undef FUNC_NAME
+
SCM_REGISTER_PROC(s_uniform_array_set1_x, "uniform-array-set1!", 3, 0, 0, scm_array_set_x);
PROC is used (and it's called from C too). */
SCM_DEFINE (scm_array_set_x, "array-set!", 2, 0, 1,
(SCM v, SCM obj, SCM args),
+ "@deffnx primitive uniform-array-set1! v obj args\n"
"Sets the element at the @code{(index1, index2)} element in @var{array} to\n"
"@var{new-value}. The value returned by array-set! is unspecified.")
#define FUNC_NAME s_scm_array_set_x
}
else
{
+ unsigned long int length;
if (SCM_NIMP (args))
{
SCM_ASSERT (SCM_CONSP(args) && SCM_INUMP (SCM_CAR (args)), args,
{
SCM_VALIDATE_INUM_COPY (3,args,pos);
}
- SCM_ASRTGO (pos >= 0 && pos < SCM_LENGTH (v), outrng);
+ length = SCM_INUM (scm_uniform_vector_length (v));
+ SCM_ASRTGO (pos >= 0 && pos < length, outrng);
}
switch (SCM_TYP7 (v))
{
default: badarg1:
SCM_WTA (1,v);
abort ();
- outrng:scm_out_of_range (FUNC_NAME, SCM_MAKINUM (pos));
- wna: scm_wrong_num_args (SCM_FUNC_NAME);
+ outrng:
+ scm_out_of_range (FUNC_NAME, SCM_MAKINUM (pos));
+ wna:
+ scm_wrong_num_args (SCM_FUNC_NAME);
case scm_tc7_smob: /* enclosed */
goto badarg1;
case scm_tc7_bvect:
- if (SCM_BOOL_F == obj)
- SCM_VELTS (v)[pos / SCM_LONG_BIT] &= ~(1L << (pos % SCM_LONG_BIT));
- else if (SCM_BOOL_T == obj)
- SCM_VELTS (v)[pos / SCM_LONG_BIT] |= (1L << (pos % SCM_LONG_BIT));
+ if (SCM_FALSEP (obj))
+ SCM_BITVEC_CLR(v,pos);
+ else if (SCM_EQ_P (obj, SCM_BOOL_T))
+ SCM_BITVEC_SET(v,pos);
else
badobj:SCM_WTA (2,obj);
break;
case scm_tc7_string:
- SCM_ASRTGO (SCM_ICHRP (obj), badobj);
- SCM_UCHARS (v)[pos] = SCM_ICHR (obj);
+ SCM_ASRTGO (SCM_CHARP (obj), badobj);
+ SCM_STRING_UCHARS (v)[pos] = SCM_CHAR (obj);
break;
case scm_tc7_byvect:
- if (SCM_ICHRP (obj))
- obj = SCM_MAKINUM ((char) SCM_ICHR (obj));
+ if (SCM_CHARP (obj))
+ obj = SCM_MAKINUM ((char) SCM_CHAR (obj));
SCM_ASRTGO (SCM_INUMP (obj), badobj);
- ((char *)SCM_CHARS (v))[pos] = SCM_INUM (obj);
+ ((char *) SCM_UVECTOR_BASE (v))[pos] = SCM_INUM (obj);
break;
-# ifdef SCM_INUMS_ONLY
- case scm_tc7_uvect:
- SCM_ASRTGO (SCM_INUM (obj) >= 0, badobj);
- /* fall through */
- case scm_tc7_ivect:
- SCM_ASRTGO(SCM_INUMP(obj), badobj); SCM_VELTS(v)[pos] = SCM_INUM(obj); break;
-# else
case scm_tc7_uvect:
- SCM_VELTS(v)[pos] = scm_num2ulong(obj, (char *)SCM_ARG2, FUNC_NAME); break;
+ SCM_VELTS(v)[pos] = SCM_PACK (scm_num2ulong(obj, (char *)SCM_ARG2, FUNC_NAME));
+ break;
case scm_tc7_ivect:
- SCM_VELTS(v)[pos] = scm_num2long(obj, (char *)SCM_ARG2, FUNC_NAME); break;
-# endif
+ SCM_VELTS(v)[pos] = SCM_PACK (scm_num2long(obj, (char *)SCM_ARG2, FUNC_NAME));
+ break;
case scm_tc7_svect:
SCM_ASRTGO (SCM_INUMP (obj), badobj);
- ((short *) SCM_CDR (v))[pos] = SCM_INUM (obj);
+ ((short *) SCM_CELL_WORD_1 (v))[pos] = SCM_INUM (obj);
break;
#ifdef HAVE_LONG_LONGS
case scm_tc7_llvect:
- ((long_long *) SCM_CDR (v))[pos] = scm_num2long_long (obj, (char *)SCM_ARG2, FUNC_NAME);
+ ((long_long *) SCM_CELL_WORD_1 (v))[pos] = scm_num2long_long (obj, (char *)SCM_ARG2, FUNC_NAME);
break;
#endif
-#ifdef SCM_FLOATS
-#ifdef SCM_SINGLES
case scm_tc7_fvect:
- ((float *) SCM_CDR (v))[pos] = (float)scm_num2dbl(obj, FUNC_NAME); break;
+ ((float *) SCM_CELL_WORD_1 (v))[pos] = (float) scm_num2dbl (obj, FUNC_NAME);
break;
-#endif
case scm_tc7_dvect:
- ((double *) SCM_CDR (v))[pos] = scm_num2dbl(obj, FUNC_NAME); break;
+ ((double *) SCM_CELL_WORD_1 (v))[pos] = scm_num2dbl (obj, FUNC_NAME);
break;
case scm_tc7_cvect:
- SCM_ASRTGO (SCM_INEXP (obj), badobj);
- ((double *) SCM_CDR (v))[2 * pos] = SCM_REALPART (obj);
- ((double *) SCM_CDR (v))[2 * pos + 1] = SCM_CPLXP (obj) ? SCM_IMAG (obj) : 0.0;
+ SCM_ASRTGO (SCM_INEXACTP (obj), badobj);
+ if (SCM_REALP (obj)) {
+ ((double *) SCM_CELL_WORD_1 (v))[2 * pos] = SCM_REAL_VALUE (obj);
+ ((double *) SCM_CELL_WORD_1 (v))[2 * pos + 1] = 0.0;
+ } else {
+ ((double *) SCM_CELL_WORD_1 (v))[2 * pos] = SCM_COMPLEX_REAL (obj);
+ ((double *) SCM_CELL_WORD_1 (v))[2 * pos + 1] = SCM_COMPLEX_IMAG (obj);
+ }
break;
-#endif
case scm_tc7_vector:
case scm_tc7_wvect:
SCM_VELTS (v)[pos] = obj;
return SCM_BOOL_F;
if (scm_tc7_bvect == SCM_TYP7 (SCM_ARRAY_V (ra)))
{
- if (len != SCM_LENGTH (SCM_ARRAY_V (ra)) ||
+ if (len != SCM_BITVECTOR_LENGTH (SCM_ARRAY_V (ra)) ||
SCM_ARRAY_BASE (ra) % SCM_LONG_BIT ||
len % SCM_LONG_BIT)
return SCM_BOOL_F;
}
}
- if ((len == SCM_LENGTH (SCM_ARRAY_V (ra))) && 0 == SCM_ARRAY_BASE (ra) && SCM_ARRAY_DIMS (ra)->inc)
- return SCM_ARRAY_V (ra);
+
+ {
+ SCM v = SCM_ARRAY_V (ra);
+ unsigned long int length = SCM_INUM (scm_uniform_vector_length (v));
+ if ((len == length) && 0 == SCM_ARRAY_BASE (ra) && SCM_ARRAY_DIMS (ra)->inc)
+ return v;
+ }
+
sra = scm_make_ra (1);
SCM_ARRAY_DIMS (sra)->lbnd = 0;
SCM_ARRAY_DIMS (sra)->ubnd = len - 1;
k = SCM_ARRAY_NDIM (ra);
if (SCM_ARRAY_CONTP (ra) && ((0 == k) || (1 == SCM_ARRAY_DIMS (ra)[k - 1].inc)))
{
- if (scm_tc7_bvect != SCM_TYP7 (ra))
+ if (scm_tc7_bvect != SCM_TYP7 (SCM_ARRAY_V (ra)))
return ra;
- if ((len == SCM_LENGTH (SCM_ARRAY_V (ra)) &&
+ if ((len == SCM_BITVECTOR_LENGTH (SCM_ARRAY_V (ra)) &&
0 == SCM_ARRAY_BASE (ra) % SCM_LONG_BIT &&
0 == len % SCM_LONG_BIT))
return ra;
long cstart = 0;
long cend;
long offset = 0;
+ char *base;
SCM_ASRTGO (SCM_NIMP (v), badarg1);
if (SCM_UNBNDP (port_or_fd))
SCM_ASSERT (SCM_INUMP (port_or_fd)
|| (SCM_OPINPORTP (port_or_fd)),
port_or_fd, SCM_ARG2, FUNC_NAME);
- vlen = SCM_LENGTH (v);
+ vlen = SCM_INUM (scm_uniform_vector_length (v));
loop:
switch SCM_TYP7 (v)
v = SCM_ARRAY_V (cra);
goto loop;
case scm_tc7_string:
- case scm_tc7_byvect:
+ base = SCM_STRING_CHARS (v);
sz = sizeof (char);
break;
case scm_tc7_bvect:
+ base = (char *) SCM_BITVECTOR_BASE (v);
vlen = (vlen + SCM_LONG_BIT - 1) / SCM_LONG_BIT;
cstart /= SCM_LONG_BIT;
+ sz = sizeof (long);
+ break;
+ case scm_tc7_byvect:
+ base = (char *) SCM_UVECTOR_BASE (v);
+ sz = sizeof (char);
+ break;
case scm_tc7_uvect:
case scm_tc7_ivect:
+ base = (char *) SCM_UVECTOR_BASE (v);
sz = sizeof (long);
break;
case scm_tc7_svect:
+ base = (char *) SCM_UVECTOR_BASE (v);
sz = sizeof (short);
break;
#ifdef HAVE_LONG_LONGS
case scm_tc7_llvect:
+ base = (char *) SCM_UVECTOR_BASE (v);
sz = sizeof (long_long);
break;
#endif
-#ifdef SCM_FLOATS
-#ifdef SCM_SINGLES
case scm_tc7_fvect:
+ base = (char *) SCM_UVECTOR_BASE (v);
sz = sizeof (float);
break;
-#endif
case scm_tc7_dvect:
+ base = (char *) SCM_UVECTOR_BASE (v);
sz = sizeof (double);
break;
case scm_tc7_cvect:
+ base = (char *) SCM_UVECTOR_BASE (v);
sz = 2 * sizeof (double);
break;
-#endif
}
-
+
cend = vlen;
if (!SCM_UNBNDP (start))
{
{
scm_port *pt = SCM_PTAB_ENTRY (port_or_fd);
int remaining = (cend - offset) * sz;
- char *dest = SCM_CHARS (v) + (cstart + offset) * sz;
+ char *dest = base + (cstart + offset) * sz;
if (pt->rw_active == SCM_PORT_WRITE)
scm_flush (port_or_fd);
else /* file descriptor. */
{
SCM_SYSCALL (ans = read (SCM_INUM (port_or_fd),
- SCM_CHARS (v) + (cstart + offset) * sz,
+ base + (cstart + offset) * sz,
(scm_sizet) (sz * (cend - offset))));
if (ans == -1)
SCM_SYSERROR;
if (SCM_TYP7 (v) == scm_tc7_bvect)
ans *= SCM_LONG_BIT;
- if (v != ra && cra != ra)
+ if (!SCM_EQ_P (v, ra) && !SCM_EQ_P (cra, ra))
scm_array_copy_x (cra, ra);
return SCM_MAKINUM (ans);
long offset = 0;
long cstart = 0;
long cend;
+ char *base;
port_or_fd = SCM_COERCE_OUTPORT (port_or_fd);
SCM_ASSERT (SCM_INUMP (port_or_fd)
|| (SCM_OPOUTPORTP (port_or_fd)),
port_or_fd, SCM_ARG2, FUNC_NAME);
- vlen = SCM_LENGTH (v);
+ vlen = SCM_INUM (scm_uniform_vector_length (v));
loop:
switch SCM_TYP7 (v)
v = SCM_ARRAY_V (v);
goto loop;
case scm_tc7_string:
- case scm_tc7_byvect:
+ base = SCM_STRING_CHARS (v);
sz = sizeof (char);
break;
case scm_tc7_bvect:
+ base = (char *) SCM_BITVECTOR_BASE (v);
vlen = (vlen + SCM_LONG_BIT - 1) / SCM_LONG_BIT;
cstart /= SCM_LONG_BIT;
+ sz = sizeof (long);
+ break;
+ case scm_tc7_byvect:
+ base = (char *) SCM_UVECTOR_BASE (v);
+ sz = sizeof (char);
+ break;
case scm_tc7_uvect:
case scm_tc7_ivect:
+ base = (char *) SCM_UVECTOR_BASE (v);
sz = sizeof (long);
break;
case scm_tc7_svect:
+ base = (char *) SCM_UVECTOR_BASE (v);
sz = sizeof (short);
break;
#ifdef HAVE_LONG_LONGS
case scm_tc7_llvect:
+ base = (char *) SCM_UVECTOR_BASE (v);
sz = sizeof (long_long);
break;
#endif
-#ifdef SCM_FLOATS
-#ifdef SCM_SINGLES
case scm_tc7_fvect:
+ base = (char *) SCM_UVECTOR_BASE (v);
sz = sizeof (float);
break;
-#endif
case scm_tc7_dvect:
+ base = (char *) SCM_UVECTOR_BASE (v);
sz = sizeof (double);
break;
case scm_tc7_cvect:
+ base = (char *) SCM_UVECTOR_BASE (v);
sz = 2 * sizeof (double);
break;
-#endif
}
cend = vlen;
if (SCM_NIMP (port_or_fd))
{
- char *source = SCM_CHARS (v) + (cstart + offset) * sz;
+ char *source = base + (cstart + offset) * sz;
ans = cend - offset;
scm_lfwrite (source, ans * sz, port_or_fd);
else /* file descriptor. */
{
SCM_SYSCALL (ans = write (SCM_INUM (port_or_fd),
- SCM_CHARS (v) + (cstart + offset) * sz,
+ base + (cstart + offset) * sz,
(scm_sizet) (sz * (cend - offset))));
if (ans == -1)
SCM_SYSERROR;
{0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
SCM_DEFINE (scm_bit_count, "bit-count", 2, 0, 0,
- (SCM item, SCM seq),
- "Returns the number occurrences of @var{bool} in @var{bv}.")
+ (SCM b, SCM bitvector),
+ "Returns the number of occurrences of the boolean @var{b} in\n"
+ "@var{bitvector}.")
#define FUNC_NAME s_scm_bit_count
{
- long i;
- register unsigned long cnt = 0, w;
- SCM_VALIDATE_INUM (2,seq);
- switch SCM_TYP7 (seq)
- {
- default:
- SCM_WTA (2,seq);
- case scm_tc7_bvect:
- if (0 == SCM_LENGTH (seq))
- return SCM_INUM0;
- i = (SCM_LENGTH (seq) - 1) / SCM_LONG_BIT;
- w = SCM_VELTS (seq)[i];
- if (SCM_FALSEP (item))
- w = ~w;
- w <<= SCM_LONG_BIT - 1 - ((SCM_LENGTH (seq) - 1) % SCM_LONG_BIT);
- while (!0)
- {
- for (; w; w >>= 4)
- cnt += cnt_tab[w & 0x0f];
- if (0 == i--)
- return SCM_MAKINUM (cnt);
- w = SCM_VELTS (seq)[i];
- if (SCM_FALSEP (item))
- w = ~w;
+ SCM_VALIDATE_BOOL (1, b);
+ SCM_ASSERT (SCM_BITVECTOR_P (bitvector), bitvector, 2, FUNC_NAME);
+ if (SCM_BITVECTOR_LENGTH (bitvector) == 0) {
+ return SCM_INUM0;
+ } else {
+ unsigned long int count = 0;
+ unsigned long int i = (SCM_BITVECTOR_LENGTH (bitvector) - 1) / SCM_LONG_BIT;
+ unsigned long int w = SCM_UNPACK (SCM_VELTS (bitvector)[i]);
+ if (SCM_FALSEP (b)) {
+ w = ~w;
+ };
+ w <<= SCM_LONG_BIT - 1 - ((SCM_BITVECTOR_LENGTH (bitvector) - 1) % SCM_LONG_BIT);
+ while (1) {
+ while (w) {
+ count += cnt_tab[w & 0x0f];
+ w >>= 4;
+ }
+ if (i == 0) {
+ return SCM_MAKINUM (count);
+ } else {
+ --i;
+ w = SCM_UNPACK (SCM_VELTS (bitvector)[i]);
+ if (SCM_FALSEP (b)) {
+ w = ~w;
}
+ }
}
+ }
}
#undef FUNC_NAME
{
long i, lenw, xbits, pos;
register unsigned long w;
- SCM_VALIDATE_NIM (2,v);
+
+ SCM_VALIDATE_BOOL (1, item);
+ SCM_ASSERT (SCM_BITVECTOR_P (v), v, SCM_ARG2, FUNC_NAME);
SCM_VALIDATE_INUM_COPY (3,k,pos);
- SCM_ASSERT ((pos <= SCM_LENGTH (v)) && (pos >= 0),
- k, SCM_OUTOFRANGE, FUNC_NAME);
- if (pos == SCM_LENGTH (v))
+ SCM_ASSERT_RANGE (3, k, (pos <= SCM_BITVECTOR_LENGTH (v)) && (pos >= 0));
+
+ if (pos == SCM_BITVECTOR_LENGTH (v))
return SCM_BOOL_F;
- switch SCM_TYP7 (v)
- {
- default:
- SCM_WTA (2,v);
- case scm_tc7_bvect:
- if (0 == SCM_LENGTH (v))
- return SCM_MAKINUM (-1L);
- lenw = (SCM_LENGTH (v) - 1) / SCM_LONG_BIT; /* watch for part words */
- i = pos / SCM_LONG_BIT;
- w = SCM_VELTS (v)[i];
+
+ lenw = (SCM_BITVECTOR_LENGTH (v) - 1) / SCM_LONG_BIT; /* watch for part words */
+ i = pos / SCM_LONG_BIT;
+ w = SCM_UNPACK (SCM_VELTS (v)[i]);
+ if (SCM_FALSEP (item))
+ w = ~w;
+ xbits = (pos % SCM_LONG_BIT);
+ pos -= xbits;
+ w = ((w >> xbits) << xbits);
+ xbits = SCM_LONG_BIT - 1 - (SCM_BITVECTOR_LENGTH (v) - 1) % SCM_LONG_BIT;
+ while (!0)
+ {
+ if (w && (i == lenw))
+ w = ((w << xbits) >> xbits);
+ if (w)
+ while (w)
+ switch (w & 0x0f)
+ {
+ default:
+ return SCM_MAKINUM (pos);
+ case 2:
+ case 6:
+ case 10:
+ case 14:
+ return SCM_MAKINUM (pos + 1);
+ case 4:
+ case 12:
+ return SCM_MAKINUM (pos + 2);
+ case 8:
+ return SCM_MAKINUM (pos + 3);
+ case 0:
+ pos += 4;
+ w >>= 4;
+ }
+ if (++i > lenw)
+ break;
+ pos += SCM_LONG_BIT;
+ w = SCM_UNPACK (SCM_VELTS (v)[i]);
if (SCM_FALSEP (item))
w = ~w;
- xbits = (pos % SCM_LONG_BIT);
- pos -= xbits;
- w = ((w >> xbits) << xbits);
- xbits = SCM_LONG_BIT - 1 - (SCM_LENGTH (v) - 1) % SCM_LONG_BIT;
- while (!0)
- {
- if (w && (i == lenw))
- w = ((w << xbits) >> xbits);
- if (w)
- while (w)
- switch (w & 0x0f)
- {
- default:
- return SCM_MAKINUM (pos);
- case 2:
- case 6:
- case 10:
- case 14:
- return SCM_MAKINUM (pos + 1);
- case 4:
- case 12:
- return SCM_MAKINUM (pos + 2);
- case 8:
- return SCM_MAKINUM (pos + 3);
- case 0:
- pos += 4;
- w >>= 4;
- }
- if (++i > lenw)
- break;
- pos += SCM_LONG_BIT;
- w = SCM_VELTS (v)[i];
- if (SCM_FALSEP (item))
- w = ~w;
- }
- return SCM_BOOL_F;
}
+ return SCM_BOOL_F;
}
#undef FUNC_NAME
SCM_DEFINE (scm_bit_set_star_x, "bit-set*!", 3, 0, 0,
- (SCM v, SCM kv, SCM obj),
- "If uve is a bit-vector @var{bv} and uve must be of the same length. If\n"
- "@var{bool} is @code{#t}, uve is OR'ed into @var{bv}; If @var{bool} is @code{#f}, the\n"
- "inversion of uve is AND'ed into @var{bv}.\n\n"
- "If uve is a unsigned integer vector all the elements of uve must be\n"
- "between 0 and the @code{LENGTH} of @var{bv}. The bits of @var{bv}\n"
- "corresponding to the indexes in uve are set to @var{bool}.\n\n"
- "The return value is unspecified.")
+ (SCM v, SCM kv, SCM obj),
+ "If uve is a bit-vector @var{bv} and uve must be of the same\n"
+ "length. If @var{bool} is @code{#t}, uve is OR'ed into\n"
+ "@var{bv}; If @var{bool} is @code{#f}, the inversion of uve is\n"
+ "AND'ed into @var{bv}.\n\n"
+ "If uve is a unsigned integer vector all the elements of uve\n"
+ "must be between 0 and the @code{length} of @var{bv}. The bits\n"
+ "of @var{bv} corresponding to the indexes in uve are set to\n"
+ "@var{bool}. The return value is unspecified.")
#define FUNC_NAME s_scm_bit_set_star_x
{
register long i, k, vlen;
- SCM_ASRTGO (SCM_NIMP (v), badarg1);
+ SCM_ASSERT (SCM_BITVECTOR_P (v), v, SCM_ARG1, FUNC_NAME);
SCM_ASRTGO (SCM_NIMP (kv), badarg2);
switch SCM_TYP7 (kv)
{
default:
badarg2:SCM_WTA (2,kv);
case scm_tc7_uvect:
- switch SCM_TYP7 (v)
- {
- default:
- badarg1:SCM_WTA (1,v);
- case scm_tc7_bvect:
- vlen = SCM_LENGTH (v);
- if (SCM_BOOL_F == obj)
- for (i = SCM_LENGTH (kv); i;)
- {
- k = SCM_VELTS (kv)[--i];
- SCM_ASSERT ((k < vlen), SCM_MAKINUM (k), SCM_OUTOFRANGE, FUNC_NAME);
- SCM_VELTS (v)[k / SCM_LONG_BIT] &= ~(1L << (k % SCM_LONG_BIT));
- }
- else if (SCM_BOOL_T == obj)
- for (i = SCM_LENGTH (kv); i;)
- {
- k = SCM_VELTS (kv)[--i];
- SCM_ASSERT ((k < vlen), SCM_MAKINUM (k), SCM_OUTOFRANGE, FUNC_NAME);
- SCM_VELTS (v)[k / SCM_LONG_BIT] |= (1L << (k % SCM_LONG_BIT));
- }
- else
- badarg3:SCM_WTA (3,obj);
- }
+ vlen = SCM_BITVECTOR_LENGTH (v);
+ if (SCM_FALSEP (obj))
+ for (i = SCM_UVECTOR_LENGTH (kv); i;)
+ {
+ k = SCM_UNPACK (SCM_VELTS (kv)[--i]);
+ if (k >= vlen)
+ scm_out_of_range (FUNC_NAME, SCM_MAKINUM (k));
+ SCM_BITVEC_CLR(v,k);
+ }
+ else if (SCM_EQ_P (obj, SCM_BOOL_T))
+ for (i = SCM_UVECTOR_LENGTH (kv); i;)
+ {
+ k = SCM_UNPACK (SCM_VELTS (kv)[--i]);
+ if (k >= vlen)
+ scm_out_of_range (FUNC_NAME, SCM_MAKINUM (k));
+ SCM_BITVEC_SET(v,k);
+ }
+ else
+ badarg3:SCM_WTA (3,obj);
break;
case scm_tc7_bvect:
- SCM_ASRTGO (SCM_TYP7 (v) == scm_tc7_bvect && SCM_LENGTH (v) == SCM_LENGTH (kv), badarg1);
- if (SCM_BOOL_F == obj)
- for (k = (SCM_LENGTH (v) + SCM_LONG_BIT - 1) / SCM_LONG_BIT; k--;)
- SCM_VELTS (v)[k] &= ~(SCM_VELTS (kv)[k]);
- else if (SCM_BOOL_T == obj)
- for (k = (SCM_LENGTH (v) + SCM_LONG_BIT - 1) / SCM_LONG_BIT; k--;)
- SCM_VELTS (v)[k] |= SCM_VELTS (kv)[k];
+ SCM_ASSERT (SCM_BITVECTOR_LENGTH (v) == SCM_BITVECTOR_LENGTH (kv), v, SCM_ARG1, FUNC_NAME);
+ if (SCM_FALSEP (obj))
+ for (k = (SCM_BITVECTOR_LENGTH (v) + SCM_LONG_BIT - 1) / SCM_LONG_BIT; k--;)
+ SCM_UNPACK (SCM_VELTS (v)[k]) &= ~ SCM_UNPACK(SCM_VELTS (kv)[k]);
+ else if (SCM_EQ_P (obj, SCM_BOOL_T))
+ for (k = (SCM_BITVECTOR_LENGTH (v) + SCM_LONG_BIT - 1) / SCM_LONG_BIT; k--;)
+ SCM_UNPACK (SCM_VELTS (v)[k]) |= SCM_UNPACK (SCM_VELTS (kv)[k]);
else
goto badarg3;
break;
{
register long i, vlen, count = 0;
register unsigned long k;
- SCM_ASRTGO (SCM_NIMP (v), badarg1);
+ int fObj = 0;
+
+ SCM_ASSERT (SCM_BITVECTOR_P (v), v, SCM_ARG1, FUNC_NAME);
SCM_ASRTGO (SCM_NIMP (kv), badarg2);
switch SCM_TYP7 (kv)
{
default:
- badarg2:SCM_WTA (2,kv);
+ badarg2:
+ SCM_WTA (2,kv);
case scm_tc7_uvect:
- switch SCM_TYP7
- (v)
- {
- default:
- badarg1:SCM_WTA (1,v);
- case scm_tc7_bvect:
- vlen = SCM_LENGTH (v);
- if (SCM_BOOL_F == obj)
- for (i = SCM_LENGTH (kv); i;)
- {
- k = SCM_VELTS (kv)[--i];
- SCM_ASSERT ((k < vlen), SCM_MAKINUM (k), SCM_OUTOFRANGE, FUNC_NAME);
- if (!(SCM_VELTS (v)[k / SCM_LONG_BIT] & (1L << (k % SCM_LONG_BIT))))
- count++;
- }
- else if (SCM_BOOL_T == obj)
- for (i = SCM_LENGTH (kv); i;)
- {
- k = SCM_VELTS (kv)[--i];
- SCM_ASSERT ((k < vlen), SCM_MAKINUM (k), SCM_OUTOFRANGE, FUNC_NAME);
- if (SCM_VELTS (v)[k / SCM_LONG_BIT] & (1L << (k % SCM_LONG_BIT)))
- count++;
- }
- else
- badarg3:SCM_WTA (3,obj);
- }
+ vlen = SCM_BITVECTOR_LENGTH (v);
+ if (SCM_FALSEP (obj))
+ for (i = SCM_UVECTOR_LENGTH (kv); i;)
+ {
+ k = SCM_UNPACK (SCM_VELTS (kv)[--i]);
+ if (k >= vlen)
+ scm_out_of_range (FUNC_NAME, SCM_MAKINUM (k));
+ if (!SCM_BITVEC_REF(v,k))
+ count++;
+ }
+ else if (SCM_EQ_P (obj, SCM_BOOL_T))
+ for (i = SCM_UVECTOR_LENGTH (kv); i;)
+ {
+ k = SCM_UNPACK (SCM_VELTS (kv)[--i]);
+ if (k >= vlen)
+ scm_out_of_range (FUNC_NAME, SCM_MAKINUM (k));
+ if (SCM_BITVEC_REF (v,k))
+ count++;
+ }
+ else
+ badarg3:SCM_WTA (3,obj);
break;
case scm_tc7_bvect:
- SCM_ASRTGO (SCM_TYP7 (v) == scm_tc7_bvect && SCM_LENGTH (v) == SCM_LENGTH (kv), badarg1);
- if (0 == SCM_LENGTH (v))
+ SCM_ASSERT (SCM_BITVECTOR_LENGTH (v) == SCM_BITVECTOR_LENGTH (kv), v, SCM_ARG1, FUNC_NAME);
+ if (0 == SCM_BITVECTOR_LENGTH (v))
return SCM_INUM0;
- SCM_ASRTGO (SCM_BOOL_T == obj || SCM_BOOL_F == obj, badarg3);
- obj = (SCM_BOOL_T == obj);
- i = (SCM_LENGTH (v) - 1) / SCM_LONG_BIT;
- k = SCM_VELTS (kv)[i] & (obj ? SCM_VELTS (v)[i] : ~SCM_VELTS (v)[i]);
- k <<= SCM_LONG_BIT - 1 - ((SCM_LENGTH (v) - 1) % SCM_LONG_BIT);
- while (!0)
+ SCM_ASRTGO (SCM_BOOLP (obj), badarg3);
+ fObj = SCM_EQ_P (obj, SCM_BOOL_T);
+ i = (SCM_BITVECTOR_LENGTH (v) - 1) / SCM_LONG_BIT;
+ k = SCM_UNPACK (SCM_VELTS (kv)[i]) & (fObj ? SCM_UNPACK (SCM_VELTS (v)[i]) : ~ SCM_UNPACK (SCM_VELTS (v)[i]));
+ k <<= SCM_LONG_BIT - 1 - ((SCM_BITVECTOR_LENGTH (v) - 1) % SCM_LONG_BIT);
+ while (1)
{
for (; k; k >>= 4)
count += cnt_tab[k & 0x0f];
if (0 == i--)
return SCM_MAKINUM (count);
- k = SCM_VELTS (kv)[i] & (obj ? SCM_VELTS (v)[i] : ~SCM_VELTS (v)[i]);
+
+ /* urg. repetitive (see above.) */
+ k = SCM_UNPACK (SCM_VELTS (kv)[i]) & (fObj ? SCM_UNPACK(SCM_VELTS (v)[i]) : ~SCM_UNPACK (SCM_VELTS (v)[i]));
}
}
return SCM_MAKINUM (count);
"Modifies @var{bv} by replacing each element with its negation.")
#define FUNC_NAME s_scm_bit_invert_x
{
- register long k;
- SCM_ASRTGO (SCM_NIMP (v), badarg1);
- k = SCM_LENGTH (v);
- switch SCM_TYP7
- (v)
- {
- case scm_tc7_bvect:
- for (k = (k + SCM_LONG_BIT - 1) / SCM_LONG_BIT; k--;)
- SCM_VELTS (v)[k] = ~SCM_VELTS (v)[k];
- break;
- default:
- badarg1:SCM_WTA (1,v);
- }
+ long int k;
+
+ SCM_ASSERT (SCM_BITVECTOR_P (v), v, SCM_ARG1, FUNC_NAME);
+
+ k = SCM_BITVECTOR_LENGTH (v);
+ for (k = (k + SCM_LONG_BIT - 1) / SCM_LONG_BIT; k--;)
+ SCM_UNPACK (SCM_VELTS (v)[k]) = ~SCM_UNPACK (SCM_VELTS (v)[k]);
+
return SCM_UNSPECIFIED;
}
#undef FUNC_NAME
SCM res = SCM_EOL;
register long k;
SCM_ASRTGO (SCM_NIMP (v), badarg1);
- switch SCM_TYP7
- (v)
+ switch SCM_TYP7 (v)
{
default:
badarg1:SCM_WTA (1,v);
{
long *data = (long *) SCM_VELTS (v);
register unsigned long mask;
- for (k = (SCM_LENGTH (v) - 1) / SCM_LONG_BIT; k > 0; k--)
+ for (k = (SCM_BITVECTOR_LENGTH (v) - 1) / SCM_LONG_BIT; k > 0; k--)
for (mask = 1UL << (SCM_LONG_BIT - 1); mask; mask >>= 1)
res = scm_cons (SCM_BOOL(((long *) data)[k] & mask), res);
- for (mask = 1L << ((SCM_LENGTH (v) % SCM_LONG_BIT) - 1); mask; mask >>= 1)
+ for (mask = 1L << ((SCM_BITVECTOR_LENGTH (v) % SCM_LONG_BIT) - 1); mask; mask >>= 1)
res = scm_cons (SCM_BOOL(((long *) data)[k] & mask), res);
return res;
}
-# ifdef SCM_INUMS_ONLY
- case scm_tc7_uvect:
- case scm_tc7_ivect:
- {
- long *data = (long *) SCM_VELTS (v);
- for (k = SCM_LENGTH (v) - 1; k >= 0; k--)
- res = scm_cons (SCM_MAKINUM (data[k]), res);
- return res;
- }
-# else
case scm_tc7_uvect: {
long *data = (long *)SCM_VELTS(v);
- for (k = SCM_LENGTH(v) - 1; k >= 0; k--)
+ for (k = SCM_UVECTOR_LENGTH(v) - 1; k >= 0; k--)
res = scm_cons(scm_ulong2num(data[k]), res);
return res;
}
case scm_tc7_ivect: {
long *data = (long *)SCM_VELTS(v);
- for (k = SCM_LENGTH(v) - 1; k >= 0; k--)
+ for (k = SCM_UVECTOR_LENGTH(v) - 1; k >= 0; k--)
res = scm_cons(scm_long2num(data[k]), res);
return res;
}
-# endif
case scm_tc7_svect: {
short *data;
data = (short *)SCM_VELTS(v);
- for (k = SCM_LENGTH(v) - 1; k >= 0; k--)
+ for (k = SCM_UVECTOR_LENGTH(v) - 1; k >= 0; k--)
res = scm_cons(SCM_MAKINUM (data[k]), res);
return res;
}
case scm_tc7_llvect: {
long_long *data;
data = (long_long *)SCM_VELTS(v);
- for (k = SCM_LENGTH(v) - 1; k >= 0; k--)
+ for (k = SCM_UVECTOR_LENGTH(v) - 1; k >= 0; k--)
res = scm_cons(scm_long_long2num(data[k]), res);
return res;
}
#endif
-#ifdef SCM_FLOATS
-#ifdef SCM_SINGLES
case scm_tc7_fvect:
{
float *data = (float *) SCM_VELTS (v);
- for (k = SCM_LENGTH (v) - 1; k >= 0; k--)
- res = scm_cons (scm_makflo (data[k]), res);
+ for (k = SCM_UVECTOR_LENGTH (v) - 1; k >= 0; k--)
+ res = scm_cons (scm_make_real (data[k]), res);
return res;
}
-#endif /*SCM_SINGLES*/
case scm_tc7_dvect:
{
double *data = (double *) SCM_VELTS (v);
- for (k = SCM_LENGTH (v) - 1; k >= 0; k--)
- res = scm_cons (scm_makdbl (data[k], 0.0), res);
+ for (k = SCM_UVECTOR_LENGTH (v) - 1; k >= 0; k--)
+ res = scm_cons (scm_make_real (data[k]), res);
return res;
}
case scm_tc7_cvect:
{
double (*data)[2] = (double (*)[2]) SCM_VELTS (v);
- for (k = SCM_LENGTH (v) - 1; k >= 0; k--)
- res = scm_cons (scm_makdbl (data[k][0], data[k][1]), res);
+ for (k = SCM_UVECTOR_LENGTH (v) - 1; k >= 0; k--)
+ res = scm_cons (scm_make_complex (data[k][0], data[k][1]), res);
return res;
}
-#endif /*SCM_FLOATS*/
}
}
#undef FUNC_NAME
}
if (!SCM_ARRAYP (ra))
{
- for (k = 0; k < SCM_LENGTH (ra); k++, lst = SCM_CDR (lst))
+ unsigned long int length = SCM_INUM (scm_uniform_vector_length (ra));
+ for (k = 0; k < length; k++, lst = SCM_CDR (lst))
scm_array_set_x (ra, SCM_CAR (lst), SCM_MAKINUM (k));
return ra;
}
register long n = (1 + SCM_ARRAY_DIMS (ra)[k].ubnd - SCM_ARRAY_DIMS (ra)[k].lbnd);
int ok = 1;
if (n <= 0)
- return (SCM_EOL == lst);
+ return (SCM_NULLP (lst));
if (k < SCM_ARRAY_NDIM (ra) - 1)
{
while (n--)
{
if (SCM_IMP (lst) || SCM_NCONSP (lst))
return 0;
- ok = ok && scm_array_set_x (SCM_ARRAY_V (ra), SCM_CAR (lst), SCM_MAKINUM (base));
+ scm_array_set_x (SCM_ARRAY_V (ra), SCM_CAR (lst), SCM_MAKINUM (base));
base += inc;
lst = SCM_CDR (lst);
}
if (SCM_NNULLP (lst))
- return 0;
+ return 0;
}
return ok;
}
rapr1 (SCM ra,scm_sizet j,scm_sizet k,SCM port,scm_print_state *pstate)
{
long inc = 1;
- long n = SCM_LENGTH (ra);
+ long n = (SCM_TYP7 (ra) == scm_tc7_smob
+ ? 0
+ : SCM_INUM (scm_uniform_vector_length (ra)));
int enclosed = 0;
tail:
switch SCM_TYP7 (ra)
break;
case scm_tc7_string:
if (n-- > 0)
- scm_iprin1 (SCM_MAKICHR (SCM_UCHARS (ra)[j]), port, pstate);
+ scm_iprin1 (SCM_MAKE_CHAR (SCM_STRING_UCHARS (ra)[j]), port, pstate);
if (SCM_WRITINGP (pstate))
for (j += inc; n-- > 0; j += inc)
{
scm_putc (' ', port);
- scm_iprin1 (SCM_MAKICHR (SCM_UCHARS (ra)[j]), port, pstate);
+ scm_iprin1 (SCM_MAKE_CHAR (SCM_STRING_UCHARS (ra)[j]), port, pstate);
}
else
for (j += inc; n-- > 0; j += inc)
- scm_putc (SCM_CHARS (ra)[j], port);
+ scm_putc (SCM_STRING_CHARS (ra)[j], port);
break;
case scm_tc7_byvect:
if (n-- > 0)
- scm_intprint (((char *)SCM_CDR (ra))[j], 10, port);
+ scm_intprint (((char *) SCM_CELL_WORD_1 (ra))[j], 10, port);
for (j += inc; n-- > 0; j += inc)
{
scm_putc (' ', port);
- scm_intprint (((char *)SCM_CDR (ra))[j], 10, port);
+ scm_intprint (((char *)SCM_CELL_WORD_1 (ra))[j], 10, port);
}
break;
if (n-- > 0)
{
/* intprint can't handle >= 2^31. */
- sprintf (str, "%lu", (unsigned long) SCM_VELTS (ra)[j]);
+ sprintf (str, "%lu", ((unsigned long *) SCM_VELTS (ra))[j]);
scm_puts (str, port);
}
for (j += inc; n-- > 0; j += inc)
{
scm_putc (' ', port);
- sprintf (str, "%lu", (unsigned long) SCM_VELTS (ra)[j]);
+ sprintf (str, "%lu", ((unsigned long *) SCM_VELTS (ra))[j]);
scm_puts (str, port);
}
}
case scm_tc7_ivect:
if (n-- > 0)
- scm_intprint (SCM_VELTS (ra)[j], 10, port);
+ scm_intprint (((signed long *) SCM_VELTS (ra))[j], 10, port);
for (j += inc; n-- > 0; j += inc)
{
scm_putc (' ', port);
- scm_intprint (SCM_VELTS (ra)[j], 10, port);
+ scm_intprint (((signed long *) SCM_VELTS (ra))[j], 10, port);
}
break;
case scm_tc7_svect:
if (n-- > 0)
- scm_intprint (((short *)SCM_CDR (ra))[j], 10, port);
+ scm_intprint (((short *) SCM_CELL_WORD_1 (ra))[j], 10, port);
for (j += inc; n-- > 0; j += inc)
{
scm_putc (' ', port);
- scm_intprint (((short *)SCM_CDR (ra))[j], 10, port);
+ scm_intprint (((short *) SCM_CELL_WORD_1 (ra))[j], 10, port);
}
break;
-#ifdef SCM_FLOATS
-#ifdef SCM_SINGLES
case scm_tc7_fvect:
if (n-- > 0)
{
- SCM z = scm_makflo (1.0);
- SCM_FLO (z) = ((float *) SCM_VELTS (ra))[j];
- scm_floprint (z, port, pstate);
+ SCM z = scm_make_real (1.0);
+ SCM_REAL_VALUE (z) = ((float *) SCM_VELTS (ra))[j];
+ scm_print_real (z, port, pstate);
for (j += inc; n-- > 0; j += inc)
{
scm_putc (' ', port);
- SCM_FLO (z) = ((float *) SCM_VELTS (ra))[j];
- scm_floprint (z, port, pstate);
+ SCM_REAL_VALUE (z) = ((float *) SCM_VELTS (ra))[j];
+ scm_print_real (z, port, pstate);
}
}
break;
-#endif /*SCM_SINGLES*/
case scm_tc7_dvect:
if (n-- > 0)
{
- SCM z = scm_makdbl (1.0 / 3.0, 0.0);
- SCM_REAL (z) = ((double *) SCM_VELTS (ra))[j];
- scm_floprint (z, port, pstate);
+ SCM z = scm_make_real (1.0 / 3.0);
+ SCM_REAL_VALUE (z) = ((double *) SCM_VELTS (ra))[j];
+ scm_print_real (z, port, pstate);
for (j += inc; n-- > 0; j += inc)
{
scm_putc (' ', port);
- SCM_REAL (z) = ((double *) SCM_VELTS (ra))[j];
- scm_floprint (z, port, pstate);
+ SCM_REAL_VALUE (z) = ((double *) SCM_VELTS (ra))[j];
+ scm_print_real (z, port, pstate);
}
}
break;
case scm_tc7_cvect:
if (n-- > 0)
{
- SCM cz = scm_makdbl (0.0, 1.0), z = scm_makdbl (1.0 / 3.0, 0.0);
- SCM_REAL (z) = SCM_REAL (cz) = (((double *) SCM_VELTS (ra))[2 * j]);
- SCM_IMAG (cz) = ((double *) SCM_VELTS (ra))[2 * j + 1];
- scm_floprint ((0.0 == SCM_IMAG (cz) ? z : cz), port, pstate);
+ SCM cz = scm_make_complex (0.0, 1.0), z = scm_make_real (1.0 / 3.0);
+ SCM_REAL_VALUE (z) =
+ SCM_COMPLEX_REAL (cz) = ((double *) SCM_VELTS (ra))[2 * j];
+ SCM_COMPLEX_IMAG (cz) = ((double *) SCM_VELTS (ra))[2 * j + 1];
+ scm_print_complex ((0.0 == SCM_COMPLEX_IMAG (cz) ? z : cz),
+ port, pstate);
for (j += inc; n-- > 0; j += inc)
{
scm_putc (' ', port);
- SCM_REAL (z) = SCM_REAL (cz) = ((double *) SCM_VELTS (ra))[2 * j];
- SCM_IMAG (cz) = ((double *) SCM_VELTS (ra))[2 * j + 1];
- scm_floprint ((0.0 == SCM_IMAG (cz) ? z : cz), port, pstate);
+ SCM_REAL_VALUE (z)
+ = SCM_COMPLEX_REAL (cz) = ((double *) SCM_VELTS (ra))[2 * j];
+ SCM_COMPLEX_IMAG (cz) = ((double *) SCM_VELTS (ra))[2 * j + 1];
+ scm_print_complex ((0.0 == SCM_COMPLEX_IMAG (cz) ? z : cz),
+ port, pstate);
}
}
break;
-#endif /*SCM_FLOATS*/
}
}
}
}
case scm_tc7_bvect:
- if (exp == v)
+ if (SCM_EQ_P (exp, v))
{ /* a uve, not an scm_array */
register long i, j, w;
scm_putc ('*', port);
- for (i = 0; i < (SCM_LENGTH (exp)) / SCM_LONG_BIT; i++)
+ for (i = 0; i < (SCM_BITVECTOR_LENGTH (exp)) / SCM_LONG_BIT; i++)
{
- w = SCM_VELTS (exp)[i];
+ scm_bits_t w = SCM_UNPACK (SCM_VELTS (exp)[i]);
for (j = SCM_LONG_BIT; j; j--)
{
scm_putc (w & 1 ? '1' : '0', port);
w >>= 1;
}
}
- j = SCM_LENGTH (exp) % SCM_LONG_BIT;
+ j = SCM_BITVECTOR_LENGTH (exp) % SCM_LONG_BIT;
if (j)
{
- w = SCM_VELTS (exp)[SCM_LENGTH (exp) / SCM_LONG_BIT];
+ w = SCM_UNPACK (SCM_VELTS (exp)[SCM_BITVECTOR_LENGTH (exp) / SCM_LONG_BIT]);
for (; j; j--)
{
scm_putc (w & 1 ? '1' : '0', port);
scm_putc ('l', port);
break;
#endif
-#ifdef SCM_FLOATS
-#ifdef SCM_SINGLES
case scm_tc7_fvect:
scm_putc ('s', port);
break;
-#endif /*SCM_SINGLES*/
case scm_tc7_dvect:
scm_putc ('i', port);
break;
case scm_tc7_cvect:
scm_putc ('c', port);
break;
-#endif /*SCM_FLOATS*/
}
scm_putc ('(', port);
rapr1 (exp, base, 0, port, pstate);
int enclosed = 0;
SCM_ASRTGO (SCM_NIMP (ra), badarg);
loop:
- switch SCM_TYP7
- (ra)
+ switch SCM_TYP7 (ra)
{
default:
badarg:SCM_WTA (1,ra);
case scm_tc7_bvect:
return SCM_BOOL_T;
case scm_tc7_string:
- return SCM_MAKICHR ('a');
+ return SCM_MAKE_CHAR ('a');
case scm_tc7_byvect:
- return SCM_MAKICHR ('\0');
+ return SCM_MAKE_CHAR ('\0');
case scm_tc7_uvect:
return SCM_MAKINUM (1L);
case scm_tc7_ivect:
return SCM_MAKINUM (-1L);
case scm_tc7_svect:
- return SCM_CDR (scm_intern ("s", 1));
+ return scm_str2symbol ("s");
#ifdef HAVE_LONG_LONGS
case scm_tc7_llvect:
- return SCM_CDR (scm_intern ("l", 1));
+ return scm_str2symbol ("l");
#endif
-#ifdef SCM_FLOATS
-#ifdef SCM_SINGLES
case scm_tc7_fvect:
- return scm_makflo (1.0);
-#endif
+ return scm_make_real (1.0);
case scm_tc7_dvect:
- return scm_makdbl (1.0 / 3.0, 0.0);
+ return scm_make_real (1.0 / 3.0);
case scm_tc7_cvect:
- return scm_makdbl (0.0, 1.0);
-#endif
+ return scm_make_complex (0.0, 1.0);
}
}
#undef FUNC_NAME
static SCM
-markra (SCM ptr)
+array_mark (SCM ptr)
{
return SCM_ARRAY_V (ptr);
}
static scm_sizet
-freera (SCM ptr)
+array_free (SCM ptr)
{
- scm_must_free (SCM_CHARS (ptr));
+ scm_must_free (SCM_ARRAY_MEM (ptr));
return sizeof (scm_array) + SCM_ARRAY_NDIM (ptr) * sizeof (scm_array_dim);
}
void
scm_init_unif ()
{
- scm_tc16_array = scm_make_smob_type_mfpe ("array", 0,
- markra,
- freera,
- scm_raprin1,
- scm_array_equal_p);
+ scm_tc16_array = scm_make_smob_type ("array", 0);
+ scm_set_smob_mark (scm_tc16_array, array_mark);
+ scm_set_smob_free (scm_tc16_array, array_free);
+ scm_set_smob_print (scm_tc16_array, scm_raprin1);
+ scm_set_smob_equalp (scm_tc16_array, scm_array_equal_p);
scm_add_feature ("array");
-#include "unif.x"
+#ifndef SCM_MAGIC_SNARFER
+#include "libguile/unif.x"
+#endif
}
+
+/*
+ Local Variables:
+ c-file-style: "gnu"
+ End:
+*/
HCoop / bpt / guile.git / blobdiff