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

* Removed further calls to SCM_LENGTH.

Browse source
This commit is contained in:
Dirk Herrmann 2000-10-10 09:22:31 +00:00
parent 4adc302894
commit b5c2579a34
7 changed files with 103 additions and 90 deletions
Download patch file Download diff file Expand all files Collapse all files

22
libguile/ChangeLog
View file

@ -1,3 +1,25 @@
2000-10-10 Dirk Herrmann <D.Herrmann@tu-bs.de>
* unif.h (SCM_BITVECTOR_P, SCM_BITVECTOR_BASE): Added.
* eval.c (iqq, SCM_CEVAL, SCM_APPLY, check_map_args, scm_map,
scm_for_each, scm_copy_tree), gc.c (scm_igc, scm_gc_mark,
scm_gc_sweep), gh_data.c (gh_scm2chars), sort.c
(scm_restricted_vector_sort_x, scm_sorted_p, scm_sort_x,
scm_sort, scm_stable_sort_x, scm_stable_sort), vectors.c
(scm_vector_length, scm_vector_ref, scm_vector_set_x,
scm_vector_to_list, scm_vector_fill_x, scm_vector_equal_p,
scm_vector_move_left_x, scm_vector_move_right_x, ): Replace
SCM_LENGTH with the appropriate SCM_<type>_LENGTH macro.
* gc.c (scm_gc_sweep): Use SCM_BITVECTOR_BASE for bitvectors.
* sort.c (scm_restricted_vector_sort_x, scm_sorted_p): Eliminated
dummy type dispatch.
(scm_sort_x, scm_sort, scm_stable_sort_x, scm_stable_sort):
Eliminated redundant NIM test.
2000-10-09 Dirk Herrmann <D.Herrmann@tu-bs.de>
* filesys.c (fill_select_type, retrieve_select_type, scm_select),

16
libguile/eval.c
View file

@ -811,7 +811,7 @@ iqq (SCM form,SCM env,int depth)
return form;
if (SCM_VECTORP (form))
{
long i = SCM_LENGTH (form);
long i = SCM_VECTOR_LENGTH (form);
SCM *data = SCM_VELTS (form);
tmp = SCM_EOL;
for (; --i >= 0;)
@ -2276,7 +2276,7 @@ dispatch:
/* Prepare for linear search */
mask = -1;
i = 0;
end = SCM_LENGTH (proc);
end = SCM_VECTOR_LENGTH (proc);
}
else
{
@ -2765,7 +2765,7 @@ evapply:
}
proc = SCM_SNAME (proc);
{
char *chrs = SCM_SYMBOL_CHARS (proc) + SCM_LENGTH (proc) - 1;
char *chrs = SCM_SYMBOL_CHARS (proc) + SCM_SYMBOL_LENGTH (proc) - 1;
while ('c' != *--chrs)
{
SCM_ASSERT (SCM_CONSP (t.arg1),
@ -3396,7 +3396,7 @@ tail:
}
proc = SCM_SNAME (proc);
{
char *chrs = SCM_SYMBOL_CHARS (proc) + SCM_LENGTH (proc) - 1;
char *chrs = SCM_SYMBOL_CHARS (proc) + SCM_SYMBOL_LENGTH (proc) - 1;
while ('c' != *--chrs)
{
SCM_ASSERT (SCM_CONSP (arg1),
@ -3604,7 +3604,7 @@ check_map_args (SCM argv,
SCM *ve = SCM_VELTS (argv);
int i;
for (i = SCM_LENGTH (argv) - 1; i >= 1; i--)
for (i = SCM_VECTOR_LENGTH (argv) - 1; i >= 1; i--)
{
int elt_len = scm_ilength (ve[i]);
@ -3665,7 +3665,7 @@ scm_map (SCM proc, SCM arg1, SCM args)
while (1)
{
arg1 = SCM_EOL;
for (i = SCM_LENGTH (args) - 1; i >= 0; i--)
for (i = SCM_VECTOR_LENGTH (args) - 1; i >= 0; i--)
{
if (SCM_IMP (ve[i]))
return res;
@ -3708,7 +3708,7 @@ scm_for_each (SCM proc, SCM arg1, SCM args)
while (1)
{
arg1 = SCM_EOL;
for (i = SCM_LENGTH (args) - 1; i >= 0; i--)
for (i = SCM_VECTOR_LENGTH (args) - 1; i >= 0; i--)
{
if SCM_IMP
(ve[i]) return SCM_UNSPECIFIED;
@ -3823,7 +3823,7 @@ SCM_DEFINE (scm_copy_tree, "copy-tree", 1, 0, 0,
return obj;
if (SCM_VECTORP (obj))
{
scm_sizet i = SCM_LENGTH (obj);
scm_sizet i = SCM_VECTOR_LENGTH (obj);
ans = scm_make_vector (SCM_MAKINUM (i), SCM_UNSPECIFIED);
while (i--)
SCM_VELTS (ans)[i] = scm_copy_tree (SCM_VELTS (obj)[i]);

41
libguile/gc.c
View file

@ -1010,7 +1010,7 @@ scm_igc (const char *what)
int bound;
SCM * elts;
elts = SCM_VELTS (scm_continuation_stack);
bound = SCM_LENGTH (scm_continuation_stack);
bound = SCM_VECTOR_LENGTH (scm_continuation_stack);
x = SCM_INUM (scm_continuation_stack_ptr);
while (x < bound)
{
@ -1172,7 +1172,7 @@ gc_mark_nimp:
{
/* ptr is a struct */
SCM layout = SCM_PACK (vtable_data [scm_vtable_index_layout]);
int len = SCM_LENGTH (layout);
int len = SCM_SYMBOL_LENGTH (layout);
char * fields_desc = SCM_SYMBOL_CHARS (layout);
scm_bits_t * struct_data = (scm_bits_t *) SCM_STRUCT_DATA (ptr);
@ -1213,10 +1213,7 @@ gc_mark_nimp:
ptr = SCM_CDR (ptr);
goto gc_mark_nimp;
case scm_tc7_vector:
#ifdef CCLO
case scm_tc7_cclo:
#endif
i = SCM_LENGTH (ptr);
i = SCM_VECTOR_LENGTH (ptr);
if (i == 0)
break;
while (--i > 0)
@ -1224,11 +1221,22 @@ gc_mark_nimp:
scm_gc_mark (SCM_VELTS (ptr)[i]);
ptr = SCM_VELTS (ptr)[0];
goto gc_mark_loop;
#ifdef CCLO
case scm_tc7_cclo:
i = SCM_CCLO_LENGTH (ptr);
if (i == 0)
break;
while (--i > 0)
if (SCM_NIMP (SCM_VELTS (ptr)[i]))
scm_gc_mark (SCM_VELTS (ptr)[i]);
ptr = SCM_VELTS (ptr)[0];
goto gc_mark_loop;
#endif
case scm_tc7_contin:
if (SCM_VELTS (ptr))
scm_mark_locations (SCM_VELTS_AS_STACKITEMS (ptr),
(scm_sizet)
(SCM_LENGTH (ptr) +
(SCM_CONTINUATION_LENGTH (ptr) +
(sizeof (SCM_STACKITEM) + -1 +
sizeof (scm_contregs)) /
sizeof (SCM_STACKITEM)));
@ -1263,7 +1271,7 @@ gc_mark_nimp:
int weak_keys;
int weak_values;
len = SCM_LENGTH (ptr);
len = SCM_VECTOR_LENGTH (ptr);
weak_keys = SCM_IS_WHVEC (ptr) || SCM_IS_WHVEC_B (ptr);
weak_values = SCM_IS_WHVEC_V (ptr) || SCM_IS_WHVEC_B (ptr);
@ -1603,23 +1611,23 @@ scm_gc_sweep ()
case scm_tc7_pws:
break;
case scm_tc7_wvect:
m += (2 + SCM_LENGTH (scmptr)) * sizeof (SCM);
m += (2 + SCM_VECTOR_LENGTH (scmptr)) * sizeof (SCM);
scm_must_free (SCM_VECTOR_BASE (scmptr) - 2);
break;
case scm_tc7_vector:
m += (SCM_LENGTH (scmptr) * sizeof (SCM));
m += (SCM_VECTOR_LENGTH (scmptr) * sizeof (SCM));
scm_must_free (SCM_VECTOR_BASE (scmptr));
break;
#ifdef CCLO
case scm_tc7_cclo:
m += (SCM_LENGTH (scmptr) * sizeof (SCM));
m += (SCM_CCLO_LENGTH (scmptr) * sizeof (SCM));
scm_must_free (SCM_CCLO_BASE (scmptr));
break;
#endif
#ifdef HAVE_ARRAYS
case scm_tc7_bvect:
m += sizeof (long) * ((SCM_HUGE_LENGTH (scmptr) + SCM_LONG_BIT - 1) / SCM_LONG_BIT);
scm_must_free (SCM_UVECTOR_BASE (scmptr));
m += sizeof (long) * ((SCM_BITVECTOR_LENGTH (scmptr) + SCM_LONG_BIT - 1) / SCM_LONG_BIT);
scm_must_free (SCM_BITVECTOR_BASE (scmptr));
break;
case scm_tc7_byvect:
case scm_tc7_ivect:
@ -1638,15 +1646,16 @@ scm_gc_sweep ()
case scm_tc7_substring:
break;
case scm_tc7_string:
m += SCM_HUGE_LENGTH (scmptr) + 1;
m += SCM_STRING_LENGTH (scmptr) + 1;
scm_must_free (SCM_STRING_CHARS (scmptr));
break;
case scm_tc7_symbol:
m += SCM_LENGTH (scmptr) + 1;
m += SCM_SYMBOL_LENGTH (scmptr) + 1;
scm_must_free (SCM_SYMBOL_CHARS (scmptr));
break;
case scm_tc7_contin:
m += SCM_LENGTH (scmptr) * sizeof (SCM_STACKITEM) + sizeof (scm_contregs);
m += SCM_CONTINUATION_LENGTH (scmptr) * sizeof (SCM_STACKITEM)
+ sizeof (scm_contregs);
if (SCM_CONTREGS (scmptr))
{
scm_must_free (SCM_CONTREGS (scmptr));

7
libguile/gh_data.c
View file

@ -297,10 +297,15 @@ gh_scm2chars (SCM obj, char *m)
break;
#ifdef HAVE_ARRAYS
case scm_tc7_byvect:
n = SCM_UVECTOR_LENGTH (obj);
if (m == 0)
m = (char *) malloc (n * sizeof (char));
memcpy (m, SCM_VELTS (obj), n * sizeof (char));
break;
#endif
case scm_tc7_string:
case scm_tc7_substring:
n = SCM_LENGTH (obj);
n = SCM_STRING_LENGTH (obj);
if (m == 0)
m = (char *) malloc (n * sizeof (char));
memcpy (m, SCM_VELTS (obj), n * sizeof (char));

77
libguile/sort.c
View file

@ -424,23 +424,11 @@ SCM_DEFINE (scm_restricted_vector_sort_x, "restricted-vector-sort!", 4, 0, 0,
size_t vlen, spos, len, size = sizeof (SCM);
SCM *vp;
SCM_VALIDATE_NIM (1,vec);
SCM_VALIDATE_VECTOR (1,vec);
SCM_VALIDATE_NIM (2,less);
switch (SCM_TYP7 (vec))
{
case scm_tc7_vector: /* the only type we manage is vector */
break;
#if 0 /* HAVE_ARRAYS */
case scm_tc7_ivect: /* long */
case scm_tc7_uvect: /* unsigned */
case scm_tc7_fvect: /* float */
case scm_tc7_dvect: /* double */
#endif
default:
SCM_WTA (1,vec);
}
vp = SCM_VELTS (vec); /* vector pointer */
vlen = SCM_LENGTH (vec);
vlen = SCM_VECTOR_LENGTH (vec);
SCM_VALIDATE_INUM_COPY (3,startpos,spos);
SCM_ASSERT_RANGE (3,startpos,(spos >= 0) && (spos <= vlen));
@ -470,7 +458,6 @@ SCM_DEFINE (scm_sorted_p, "sorted?", 2, 0, 0,
if (SCM_NULLP (items))
return SCM_BOOL_T;
SCM_VALIDATE_NIM (1,items);
SCM_VALIDATE_NIM (2,less);
if (SCM_CONSP (items))
@ -498,36 +485,24 @@ SCM_DEFINE (scm_sorted_p, "sorted?", 2, 0, 0,
}
else
{
switch (SCM_TYP7 (items))
SCM_VALIDATE_VECTOR (1, items);
vp = SCM_VELTS (items); /* vector pointer */
len = SCM_VECTOR_LENGTH (items);
j = len - 1;
while (j > 0)
{
case scm_tc7_vector:
{
vp = SCM_VELTS (items); /* vector pointer */
len = SCM_LENGTH (items);
j = len - 1;
while (j > 0)
{
if ((*cmp) (less, &vp[1], vp))
return SCM_BOOL_F;
else
{
vp++;
j--;
}
}
return SCM_BOOL_T;
}
break;
#if 0 /* HAVE_ARRAYS */
case scm_tc7_ivect: /* long */
case scm_tc7_uvect: /* unsigned */
case scm_tc7_fvect: /* float */
case scm_tc7_dvect: /* double */
#endif
default:
SCM_WTA (1,items);
if ((*cmp) (less, &vp[1], vp))
return SCM_BOOL_F;
else
{
vp++;
j--;
}
}
return SCM_BOOL_T;
}
return SCM_BOOL_F;
}
#undef FUNC_NAME
@ -724,7 +699,7 @@ SCM_DEFINE (scm_sort_x, "sort!", 2, 0, 0,
long len; /* list/vector length */
if (SCM_NULLP(items))
return SCM_EOL;
SCM_VALIDATE_NIM (1,items);
SCM_VALIDATE_NIM (2,less);
if (SCM_CONSP (items))
@ -734,7 +709,7 @@ SCM_DEFINE (scm_sort_x, "sort!", 2, 0, 0,
}
else if (SCM_VECTORP (items))
{
len = SCM_LENGTH (items);
len = SCM_VECTOR_LENGTH (items);
scm_restricted_vector_sort_x (items,
less,
SCM_MAKINUM (0L),
@ -757,7 +732,7 @@ SCM_DEFINE (scm_sort, "sort", 2, 0, 0,
long len; /* list/vector length */
if (SCM_NULLP(items))
return SCM_EOL;
SCM_VALIDATE_NIM (1,items);
SCM_VALIDATE_NIM (2,less);
if (SCM_CONSP (items))
{
@ -769,7 +744,7 @@ SCM_DEFINE (scm_sort, "sort", 2, 0, 0,
/* support ordinary vectors even if arrays not available? */
else if (SCM_VECTORP (items))
{
len = SCM_LENGTH (items);
len = SCM_VECTOR_LENGTH (items);
sortvec = scm_make_uve (len, scm_array_prototype (items));
scm_array_copy_x (items, sortvec);
scm_restricted_vector_sort_x (sortvec,
@ -848,7 +823,7 @@ SCM_DEFINE (scm_stable_sort_x, "stable-sort!", 2, 0, 0,
if (SCM_NULLP (items))
return SCM_EOL;
SCM_VALIDATE_NIM (1,items);
SCM_VALIDATE_NIM (2,less);
if (SCM_CONSP (items))
{
@ -858,7 +833,7 @@ SCM_DEFINE (scm_stable_sort_x, "stable-sort!", 2, 0, 0,
else if (SCM_VECTORP (items))
{
SCM *temp, *vp;
len = SCM_LENGTH (items);
len = SCM_VECTOR_LENGTH (items);
temp = malloc (len * sizeof(SCM));
vp = SCM_VELTS (items);
scm_merge_vector_step (vp,
@ -885,7 +860,7 @@ SCM_DEFINE (scm_stable_sort, "stable-sort", 2, 0, 0,
long len; /* list/vector length */
if (SCM_NULLP (items))
return SCM_EOL;
SCM_VALIDATE_NIM (1,items);
SCM_VALIDATE_NIM (2,less);
if (SCM_CONSP (items))
{
@ -899,7 +874,7 @@ SCM_DEFINE (scm_stable_sort, "stable-sort", 2, 0, 0,
{
SCM retvec;
SCM *temp, *vp;
len = SCM_LENGTH (items);
len = SCM_VECTOR_LENGTH (items);
retvec = scm_make_uve (len, scm_array_prototype (items));
scm_array_copy_x (items, retvec);
temp = malloc (len * sizeof (SCM));

2
libguile/unif.h
View file

@ -89,6 +89,8 @@ extern long scm_tc16_array;
#define SCM_UVECTOR_BASE(x) ((void *) (SCM_CELL_WORD_1 (x)))
#define SCM_UVECTOR_LENGTH(x) (((unsigned long) SCM_CELL_WORD_0 (x)) >> 8)
#define SCM_BITVECTOR_P(x) (!SCM_IMP (x) && (SCM_TYP7 (x) == scm_tc7_bvect))
#define SCM_BITVECTOR_BASE(x) ((void *) (SCM_CELL_WORD_1 (x)))
#define SCM_BITVECTOR_LENGTH(x) (((unsigned long) SCM_CELL_WORD_0 (x)) >> 8)
/* apparently it's possible to have more than SCM_LENGTH_MAX elements

28
libguile/vectors.c
View file

@ -147,7 +147,7 @@ scm_vector_length (SCM v)
{
SCM_GASSERT1 (SCM_VECTORP(v),
g_vector_length, v, SCM_ARG1, s_vector_length);
return SCM_MAKINUM (SCM_LENGTH (v));
return SCM_MAKINUM (SCM_VECTOR_LENGTH (v));
}
SCM_REGISTER_PROC (s_list_to_vector, "list->vector", 1, 0, 0, scm_vector);
@ -212,7 +212,7 @@ scm_vector_ref (SCM v, SCM k)
g_vector_ref, v, k, SCM_ARG1, s_vector_ref);
SCM_GASSERT2 (SCM_INUMP (k),
g_vector_ref, v, k, SCM_ARG2, s_vector_ref);
SCM_ASSERT_RANGE (2, k, SCM_INUM (k) < SCM_LENGTH (v) && SCM_INUM (k) >= 0);
SCM_ASSERT_RANGE (2, k, SCM_INUM (k) < SCM_VECTOR_LENGTH (v) && SCM_INUM (k) >= 0);
return SCM_VELTS (v)[(long) SCM_INUM (k)];
}
#undef FUNC_NAME
@ -248,7 +248,7 @@ scm_vector_set_x (SCM v, SCM k, SCM obj)
SCM_GASSERTn (SCM_INUMP (k),
g_vector_set_x, SCM_LIST3 (v, k, obj),
SCM_ARG2, s_vector_set_x);
SCM_ASSERT_RANGE (2, k, SCM_INUM (k) < SCM_LENGTH (v) && SCM_INUM (k) >= 0);
SCM_ASSERT_RANGE (2, k, SCM_INUM (k) < SCM_VECTOR_LENGTH (v) && SCM_INUM (k) >= 0);
SCM_VELTS(v)[(long) SCM_INUM(k)] = obj;
return SCM_UNSPECIFIED;
}
@ -302,7 +302,7 @@ SCM_DEFINE (scm_vector_to_list, "vector->list", 1, 0, 0,
SCM *data;
SCM_VALIDATE_VECTOR (1,v);
data = SCM_VELTS(v);
for(i = SCM_LENGTH(v)-1;i >= 0;i--) res = scm_cons(data[i], res);
for(i = SCM_VECTOR_LENGTH(v)-1;i >= 0;i--) res = scm_cons(data[i], res);
return res;
}
#undef FUNC_NAME
@ -318,7 +318,7 @@ SCM_DEFINE (scm_vector_fill_x, "vector-fill!", 2, 0, 0,
register SCM *data;
SCM_VALIDATE_VECTOR (1,v);
data = SCM_VELTS(v);
for(i = SCM_LENGTH(v) - 1; i >= 0; i--)
for(i = SCM_VECTOR_LENGTH(v) - 1; i >= 0; i--)
data[i] = fill_x;
return SCM_UNSPECIFIED;
}
@ -329,7 +329,7 @@ SCM
scm_vector_equal_p(SCM x, SCM y)
{
long i;
for(i = SCM_LENGTH(x)-1;i >= 0;i--)
for(i = SCM_VECTOR_LENGTH(x)-1;i >= 0;i--)
if (SCM_FALSEP(scm_equal_p(SCM_VELTS(x)[i], SCM_VELTS(y)[i])))
return SCM_BOOL_F;
return SCM_BOOL_T;
@ -350,10 +350,10 @@ SCM_DEFINE (scm_vector_move_left_x, "vector-move-left!", 5, 0, 0,
SCM_VALIDATE_INUM_COPY (3,end1,e);
SCM_VALIDATE_VECTOR (4,vec2);
SCM_VALIDATE_INUM_COPY (5,start2,j);
SCM_ASSERT_RANGE (2, start1, i <= SCM_LENGTH (vec1) && i >= 0);
SCM_ASSERT_RANGE (5, start2, j <= SCM_LENGTH (vec2) && j >= 0);
SCM_ASSERT_RANGE (3, end1, e <= SCM_LENGTH (vec1) && e >= 0);
SCM_ASSERT_RANGE (5, start2, e-i+j <= SCM_LENGTH (vec2));
SCM_ASSERT_RANGE (2, start1, i <= SCM_VECTOR_LENGTH (vec1) && i >= 0);
SCM_ASSERT_RANGE (5, start2, j <= SCM_VECTOR_LENGTH (vec2) && j >= 0);
SCM_ASSERT_RANGE (3, end1, e <= SCM_VECTOR_LENGTH (vec1) && e >= 0);
SCM_ASSERT_RANGE (5, start2, e-i+j <= SCM_VECTOR_LENGTH (vec2));
while (i<e) SCM_VELTS (vec2)[j++] = SCM_VELTS (vec1)[i++];
return SCM_UNSPECIFIED;
}
@ -373,11 +373,11 @@ SCM_DEFINE (scm_vector_move_right_x, "vector-move-right!", 5, 0, 0,
SCM_VALIDATE_INUM_COPY (3,end1,e);
SCM_VALIDATE_VECTOR (4,vec2);
SCM_VALIDATE_INUM_COPY (5,start2,j);
SCM_ASSERT_RANGE (2, start1, i <= SCM_LENGTH (vec1) && i >= 0);
SCM_ASSERT_RANGE (5, start2, j <= SCM_LENGTH (vec2) && j >= 0);
SCM_ASSERT_RANGE (3, end1, e <= SCM_LENGTH (vec1) && e >= 0);
SCM_ASSERT_RANGE (2, start1, i <= SCM_VECTOR_LENGTH (vec1) && i >= 0);
SCM_ASSERT_RANGE (5, start2, j <= SCM_VECTOR_LENGTH (vec2) && j >= 0);
SCM_ASSERT_RANGE (3, end1, e <= SCM_VECTOR_LENGTH (vec1) && e >= 0);
j = e - i + j;
SCM_ASSERT_RANGE (5, start2, j <= SCM_LENGTH (vec2));
SCM_ASSERT_RANGE (5, start2, j <= SCM_VECTOR_LENGTH (vec2));
while (i < e)
SCM_VELTS (vec2)[--j] = SCM_VELTS (vec1)[--e];
return SCM_UNSPECIFIED;