+2000-10-09 Dirk Herrmann <D.Herrmann@tu-bs.de>
+
+ * continuations.c (scm_make_cont, copy_stack_and_call,
+ scm_dynthrow), environments.c (obarray_enter, obarray_replace,
+ obarray_retrieve, obarray_remove, obarray_remove_all,
+ leaf_environment_fold), fluids.c (grow_fluids, scm_copy_fluids,
+ scm_fluid_ref, scm_fluid_set_x), hash.c (scm_hasher), hashtab.c
+ (scm_hash_fn_get_handle, scm_hash_fn_create_handle_x,
+ scm_hash_fn_remove_x, scm_internal_hash_fold), ioext.c
+ (scm_read_delimited_x), objects.c (scm_mcache_lookup_cmethod,
+ scm_make_subclass_object), ports.c (scm_unread_string), socket.c
+ (scm_recv, scm_recvfrom), stacks.c (scm_make_stack, scm_stack_id,
+ scm_last_stack_frame), strings.c (scm_string_length,
+ scm_string_set_x), strop.c (scm_substring_move_x,
+ scm_substring_fill_x, scm_string_fill_x, scm_string_upcase_x,
+ scm_string_downcase_x, scm_string_capitalize_x), struct.c
+ (scm_struct_init, scm_struct_vtable_p, scm_make_struct,
+ scm_make_vtable_vtable, scm_struct_ref, scm_struct_set_x), weaks.c
+ (scm_mark_weak_vector_spines, scm_scan_weak_vectors): Replace
+ SCM_LENGTH with the appropriate SCM_<type>_LENGTH macro.
+
2000-10-09 Dirk Herrmann <D.Herrmann@tu-bs.de>
* print.c (make_print_state, scm_iprin1): Replace SCM_LENGTH with
SCM_SETLENGTH (cont, j, scm_tc7_contin);
SCM_EXIT_A_SECTION;
#ifndef SCM_STACK_GROWS_UP
- src -= SCM_LENGTH (cont);
+ src -= SCM_CONTINUATION_LENGTH (cont);
#endif /* ndef SCM_STACK_GROWS_UP */
dst = (SCM_STACKITEM *) ((char *) SCM_CONTREGS (cont) + sizeof (scm_contregs));
/* memcpy should be safe: src and dst will never overlap */
- memcpy (dst, src, sizeof (SCM_STACKITEM) * SCM_LENGTH (cont));
+ memcpy (dst, src, sizeof (SCM_STACKITEM) * SCM_CONTINUATION_LENGTH (cont));
#ifdef DEBUG_EXTENSIONS
SCM_DFRAME (cont) = scm_last_debug_frame;
SCM_STACKITEM * src, SCM_STACKITEM * dst)
{
/* memcpy should be safe: src and dst will never overlap */
- memcpy (dst, src, sizeof (SCM_STACKITEM) * SCM_LENGTH (cont));
+ memcpy (dst, src, sizeof (SCM_STACKITEM) * SCM_CONTINUATION_LENGTH (cont));
#ifdef DEBUG_EXTENSIONS
scm_last_debug_frame = SCM_DFRAME (cont);
SCM_STACKITEM stack_top_element;
#ifdef SCM_STACK_GROWS_UP
- if (SCM_PTR_GE (dst + SCM_LENGTH (cont), & stack_top_element))
+ if (SCM_PTR_GE (dst + SCM_CONTINUATION_LENGTH (cont), & stack_top_element))
grow_stack (cont, val);
#else
- dst -= SCM_LENGTH (cont);
+ dst -= SCM_CONTINUATION_LENGTH (cont);
if (SCM_PTR_LE (dst, & stack_top_element))
grow_stack (cont, val);
#endif /* def SCM_STACK_GROWS_UP */
static SCM
obarray_enter (SCM obarray, SCM symbol, SCM data)
{
- scm_sizet hash = SCM_SYMBOL_HASH (symbol) % SCM_LENGTH (obarray);
+ scm_sizet hash = SCM_SYMBOL_HASH (symbol) % SCM_VECTOR_LENGTH (obarray);
SCM entry = scm_cons (symbol, data);
SCM slot = scm_cons (entry, SCM_VELTS (obarray)[hash]);
SCM_VELTS (obarray)[hash] = slot;
static SCM
obarray_replace (SCM obarray, SCM symbol, SCM data)
{
- scm_sizet hash = SCM_SYMBOL_HASH (symbol) % SCM_LENGTH (obarray);
+ scm_sizet hash = SCM_SYMBOL_HASH (symbol) % SCM_VECTOR_LENGTH (obarray);
SCM new_entry = scm_cons (symbol, data);
SCM lsym;
SCM slot;
static SCM
obarray_retrieve (SCM obarray, SCM sym)
{
- scm_sizet hash = SCM_SYMBOL_HASH (sym) % SCM_LENGTH (obarray);
+ scm_sizet hash = SCM_SYMBOL_HASH (sym) % SCM_VECTOR_LENGTH (obarray);
SCM lsym;
for (lsym = SCM_VELTS (obarray)[hash]; !SCM_NULLP (lsym); lsym = SCM_CDR (lsym))
static SCM
obarray_remove (SCM obarray, SCM sym)
{
- scm_sizet hash = SCM_SYMBOL_HASH (sym) % SCM_LENGTH (obarray);
+ scm_sizet hash = SCM_SYMBOL_HASH (sym) % SCM_VECTOR_LENGTH (obarray);
SCM lsym;
SCM *lsymp;
static void
obarray_remove_all (SCM obarray)
{
- scm_sizet size = SCM_LENGTH (obarray);
+ scm_sizet size = SCM_VECTOR_LENGTH (obarray);
scm_sizet i;
for (i = 0; i < size; i++)
SCM result = init;
SCM obarray = LEAF_ENVIRONMENT (env)->obarray;
- for (i = 0; i < SCM_LENGTH (obarray); i++)
+ for (i = 0; i < SCM_VECTOR_LENGTH (obarray); i++)
{
SCM l;
for (l = SCM_VELTS (obarray)[i]; !SCM_NULLP (l); l = SCM_CDR (l))
int old_length, i;
old_fluids = root_state->fluids;
- old_length = SCM_LENGTH (old_fluids);
+ old_length = SCM_VECTOR_LENGTH (old_fluids);
new_fluids = scm_make_vector (SCM_MAKINUM (new_length), SCM_BOOL_F);
i = 0;
while (i < old_length)
void
scm_copy_fluids (scm_root_state *root_state)
{
- grow_fluids (root_state, SCM_LENGTH(root_state->fluids));
+ grow_fluids (root_state, SCM_VECTOR_LENGTH (root_state->fluids));
}
static int
n = SCM_FLUID_NUM (fluid);
- if (SCM_LENGTH (scm_root->fluids) <= n)
+ if (SCM_VECTOR_LENGTH (scm_root->fluids) <= n)
grow_fluids (scm_root, n+1);
return SCM_VELTS (scm_root->fluids)[n];
}
SCM_VALIDATE_FLUID (1, fluid);
n = SCM_FLUID_NUM (fluid);
- if (SCM_LENGTH (scm_root->fluids) <= n)
+ if (SCM_VECTOR_LENGTH (scm_root->fluids) <= n)
grow_fluids (scm_root, n+1);
SCM_VELTS (scm_root->fluids)[n] = value;
return SCM_UNSPECIFIED;
obj = scm_number_to_string(obj, SCM_MAKINUM(10));
}
case scm_tc7_string:
- return scm_string_hash (SCM_STRING_UCHARS (obj), SCM_LENGTH (obj)) % n;
+ return scm_string_hash (SCM_STRING_UCHARS (obj), SCM_STRING_LENGTH (obj)) % n;
case scm_tc7_substring:
return scm_string_hash (SCM_ROUCHARS (obj), SCM_ROLENGTH (obj)) % n;
case scm_tc7_symbol:
case scm_tc7_wvect:
case scm_tc7_vector:
{
- scm_sizet len = SCM_LENGTH(obj);
+ scm_sizet len = SCM_VECTOR_LENGTH(obj);
SCM *data = SCM_VELTS(obj);
if (len>5)
{
SCM h;
SCM_ASSERT (SCM_VECTORP (table), table, SCM_ARG1, "hash_fn_get_handle");
- if (SCM_LENGTH (table) == 0)
+ if (SCM_VECTOR_LENGTH (table) == 0)
return SCM_EOL;
- k = hash_fn (obj, SCM_LENGTH (table), closure);
- if (k >= SCM_LENGTH (table))
+ k = hash_fn (obj, SCM_VECTOR_LENGTH (table), closure);
+ if (k >= SCM_VECTOR_LENGTH (table))
scm_out_of_range ("hash_fn_get_handle", scm_ulong2num (k));
h = assoc_fn (obj, SCM_VELTS (table)[k], closure);
return h;
SCM it;
SCM_ASSERT (SCM_VECTORP (table), table, SCM_ARG1, "hash_fn_create_handle_x");
- if (SCM_LENGTH (table) == 0)
+ if (SCM_VECTOR_LENGTH (table) == 0)
SCM_MISC_ERROR ("void hashtable", SCM_EOL);
- k = hash_fn (obj, SCM_LENGTH (table), closure);
- if (k >= SCM_LENGTH (table))
+ k = hash_fn (obj, SCM_VECTOR_LENGTH (table), closure);
+ if (k >= SCM_VECTOR_LENGTH (table))
scm_out_of_range ("hash_fn_create_handle_x", scm_ulong2num (k));
SCM_REDEFER_INTS;
it = assoc_fn (obj, SCM_VELTS (table)[k], closure);
SCM h;
SCM_ASSERT (SCM_VECTORP (table), table, SCM_ARG1, "hash_fn_remove_x");
- if (SCM_LENGTH (table) == 0)
+ if (SCM_VECTOR_LENGTH (table) == 0)
return SCM_EOL;
- k = hash_fn (obj, SCM_LENGTH (table), closure);
- if (k >= SCM_LENGTH (table))
+ k = hash_fn (obj, SCM_VECTOR_LENGTH (table), closure);
+ if (k >= SCM_VECTOR_LENGTH (table))
scm_out_of_range ("hash_fn_remove_x", scm_ulong2num (k));
h = assoc_fn (obj, SCM_VELTS (table)[k], closure);
SCM_VELTS(table)[k] = delete_fn (h, SCM_VELTS(table)[k]);
SCM
scm_internal_hash_fold (SCM (*fn) (), void *closure, SCM init, SCM table)
{
- int i, n = SCM_LENGTH (table);
+ int i, n = SCM_VECTOR_LENGTH (table);
SCM result = init;
for (i = 0; i < n; ++i)
{
SCM_VALIDATE_ROSTRING_COPY (1,delims,cdelims);
num_delims = SCM_ROLENGTH (delims);
SCM_VALIDATE_STRING_COPY (2,buf,cbuf);
- cend = SCM_LENGTH (buf);
+ cend = SCM_STRING_LENGTH (buf);
if (SCM_UNBNDP (port))
port = scm_cur_inp;
else
/* Prepare for linear search */
mask = -1;
i = 0;
- end = SCM_LENGTH (methods);
+ end = SCM_VECTOR_LENGTH (methods);
}
else
{
SCM_VALIDATE_STRING (2,layout);
pl = SCM_PACK (SCM_STRUCT_DATA (class) [scm_vtable_index_layout]);
/* Convert symbol->string */
- pl = scm_makfromstr (SCM_SYMBOL_CHARS (pl), (scm_sizet) SCM_LENGTH (pl), 0);
+ pl = scm_makfromstr (SCM_SYMBOL_CHARS (pl), SCM_SYMBOL_LENGTH (pl), 0);
return scm_i_make_class_object (SCM_STRUCT_VTABLE (class),
scm_string_append (SCM_LIST2 (pl, layout)),
SCM_CLASS_FLAGS (class));
else
SCM_VALIDATE_OPINPORT (2,port);
- scm_ungets (SCM_ROCHARS (str), SCM_LENGTH (str), port);
+ scm_ungets (SCM_ROCHARS (str), SCM_STRING_LENGTH (str), port);
return str;
}
SCM_VALIDATE_INUM_DEF_COPY (3,flags,0,flg);
fd = SCM_FPORT_FDES (sock);
- SCM_SYSCALL (rv = recv (fd, SCM_STRING_CHARS (buf), SCM_LENGTH (buf), flg));
+ SCM_SYSCALL (rv = recv (fd, SCM_STRING_CHARS (buf), SCM_STRING_LENGTH (buf), flg));
if (rv == -1)
SCM_SYSERROR;
SCM_VALIDATE_OPFPORT (1,sock);
SCM_VALIDATE_STRING (2,buf);
- cend = SCM_LENGTH (buf);
+ cend = SCM_STRING_LENGTH (buf);
if (SCM_UNBNDP (flags))
flg = 0;
offset = ((SCM_STACKITEM *) ((char *) SCM_CONTREGS (obj) + sizeof (scm_contregs))
- SCM_BASE (obj));
#ifndef STACK_GROWS_UP
- offset += SCM_LENGTH (obj);
+ offset += SCM_CONTINUATION_LENGTH (obj);
#endif
dframe = RELOC_FRAME (SCM_DFRAME (obj), offset);
}
offset = ((SCM_STACKITEM *) ((char *) SCM_CONTREGS (stack) + sizeof (scm_contregs))
- SCM_BASE (stack));
#ifndef STACK_GROWS_UP
- offset += SCM_LENGTH (stack);
+ offset += SCM_CONTINUATION_LENGTH (stack);
#endif
dframe = RELOC_FRAME (SCM_DFRAME (stack), offset);
}
offset = ((SCM_STACKITEM *) ((char *) SCM_CONTREGS (obj) + sizeof (scm_contregs))
- SCM_BASE (obj));
#ifndef STACK_GROWS_UP
- offset += SCM_LENGTH (obj);
+ offset += SCM_CONTINUATION_LENGTH (obj);
#endif
dframe = RELOC_FRAME (SCM_DFRAME (obj), offset);
}
#define FUNC_NAME s_scm_string_length
{
SCM_VALIDATE_STRINGORSUBSTR (1, string);
- return SCM_MAKINUM (SCM_LENGTH (string));
+ return SCM_MAKINUM (SCM_STRING_LENGTH (string));
}
#undef FUNC_NAME
#define FUNC_NAME s_scm_string_set_x
{
SCM_VALIDATE_RWSTRING (1,str);
- SCM_VALIDATE_INUM_RANGE (2,k,0,SCM_LENGTH(str));
+ SCM_VALIDATE_INUM_RANGE (2,k,0,SCM_STRING_LENGTH(str));
SCM_VALIDATE_CHAR (3,chr);
SCM_STRING_UCHARS (str)[SCM_INUM (k)] = SCM_CHAR (chr);
return SCM_UNSPECIFIED;
SCM_VALIDATE_INUM_COPY (5,start2,s2);
len = e - s1;
SCM_ASSERT_RANGE (3,end1,len >= 0);
- SCM_ASSERT_RANGE (2,start1,s1 <= SCM_LENGTH (str1) && s1 >= 0);
- SCM_ASSERT_RANGE (5,start2,s2 <= SCM_LENGTH (str2) && s2 >= 0);
- SCM_ASSERT_RANGE (3,end1,e <= SCM_LENGTH (str1) && e >= 0);
- SCM_ASSERT_RANGE (5,start2,len+s2 <= SCM_LENGTH (str2));
+ SCM_ASSERT_RANGE (2,start1,s1 <= SCM_STRING_LENGTH (str1) && s1 >= 0);
+ SCM_ASSERT_RANGE (5,start2,s2 <= SCM_STRING_LENGTH (str2) && s2 >= 0);
+ SCM_ASSERT_RANGE (3,end1,e <= SCM_STRING_LENGTH (str1) && e >= 0);
+ SCM_ASSERT_RANGE (5,start2,len+s2 <= SCM_STRING_LENGTH (str2));
SCM_SYSCALL(memmove((void *)(&(SCM_STRING_CHARS(str2)[s2])),
(void *)(&(SCM_STRING_CHARS(str1)[s1])),
SCM_VALIDATE_INUM_COPY (2,start,i);
SCM_VALIDATE_INUM_COPY (3,end,e);
SCM_VALIDATE_CHAR_COPY (4,fill,c);
- SCM_ASSERT_RANGE (2,start,i <= SCM_LENGTH (str) && i >= 0);
- SCM_ASSERT_RANGE (3,end,e <= SCM_LENGTH (str) && e >= 0);
+ SCM_ASSERT_RANGE (2,start,i <= SCM_STRING_LENGTH (str) && i >= 0);
+ SCM_ASSERT_RANGE (3,end,e <= SCM_STRING_LENGTH (str) && e >= 0);
while (i<e) SCM_STRING_CHARS (str)[i++] = c;
return SCM_UNSPECIFIED;
}
register long k;
SCM_VALIDATE_STRING_COPY (1,str,dst);
SCM_VALIDATE_CHAR_COPY (2,chr,c);
- for (k = SCM_LENGTH (str)-1;k >= 0;k--) dst[k] = c;
+ for (k = SCM_STRING_LENGTH (str)-1;k >= 0;k--) dst[k] = c;
return SCM_UNSPECIFIED;
}
#undef FUNC_NAME
SCM_VALIDATE_STRING (1, v);
- for (k = 0; k < SCM_LENGTH (v); ++k)
+ for (k = 0; k < SCM_STRING_LENGTH (v); ++k)
SCM_STRING_UCHARS (v) [k] = scm_upcase (SCM_STRING_UCHARS (v) [k]);
return v;
SCM_VALIDATE_STRING (1, v);
- for (k = 0; k < SCM_LENGTH (v); ++k)
+ for (k = 0; k < SCM_STRING_LENGTH (v); ++k)
SCM_STRING_UCHARS (v) [k] = scm_downcase (SCM_STRING_UCHARS (v) [k]);
return v;
char *sz;
int i, len, in_word=0;
SCM_VALIDATE_STRING (1,str);
- len = SCM_LENGTH(str);
+ len = SCM_STRING_LENGTH(str);
sz = SCM_STRING_CHARS (str);
for(i=0; i<len; i++) {
if(SCM_NFALSEP(scm_char_alphabetic_p(SCM_MAKE_CHAR(sz[i])))) {
{
unsigned char * fields_desc = (unsigned char *) SCM_SYMBOL_CHARS (layout) - 2;
unsigned char prot = 0;
- int n_fields = SCM_LENGTH (layout) / 2;
+ int n_fields = SCM_SYMBOL_LENGTH (layout) / 2;
int tailp = 0;
while (n_fields)
layout = SCM_STRUCT_LAYOUT (x);
- if (SCM_LENGTH (layout) < SCM_LENGTH (required_vtable_fields))
+ if (SCM_SYMBOL_LENGTH (layout) < SCM_STRING_LENGTH (required_vtable_fields))
return SCM_BOOL_F;
if (strncmp (SCM_SYMBOL_CHARS (layout), SCM_STRING_CHARS (required_vtable_fields),
- SCM_LENGTH (required_vtable_fields)))
+ SCM_STRING_LENGTH (required_vtable_fields)))
return SCM_BOOL_F;
mem = SCM_STRUCT_DATA (x);
SCM_VALIDATE_REST_ARGUMENT (init);
layout = SCM_PACK (SCM_STRUCT_DATA (vtable) [scm_vtable_index_layout]);
- basic_size = SCM_LENGTH (layout) / 2;
+ basic_size = SCM_SYMBOL_LENGTH (layout) / 2;
tail_elts = SCM_INUM (tail_array_size);
SCM_NEWCELL2 (handle);
SCM_DEFER_INTS;
user_fields,
SCM_UNDEFINED));
layout = scm_make_struct_layout (fields);
- basic_size = SCM_LENGTH (layout) / 2;
+ basic_size = SCM_SYMBOL_LENGTH (layout) / 2;
tail_elts = SCM_INUM (tail_array_size);
SCM_NEWCELL2 (handle);
SCM_DEFER_INTS;
SCM_ASSERT_RANGE(1,pos, p < n_fields);
- if (p * 2 < SCM_LENGTH (layout))
+ if (p * 2 < SCM_SYMBOL_LENGTH (layout))
{
unsigned char ref;
field_type = fields_desc[p * 2];
SCM_ASSERT (0, pos, "ref denied", FUNC_NAME);
}
}
- else if (fields_desc[SCM_LENGTH (layout) - 1] != 'O')
- field_type = fields_desc[SCM_LENGTH (layout) - 2];
+ else if (fields_desc[SCM_SYMBOL_LENGTH (layout) - 1] != 'O')
+ field_type = fields_desc[SCM_SYMBOL_LENGTH (layout) - 2];
else
{
SCM_ASSERT (0, pos, "ref denied", FUNC_NAME);
SCM_ASSERT_RANGE (1,pos, p < n_fields);
- if (p * 2 < SCM_LENGTH (layout))
+ if (p * 2 < SCM_SYMBOL_LENGTH (layout))
{
unsigned char set_x;
field_type = fields_desc[p * 2];
if (set_x != 'w')
SCM_ASSERT (0, pos, "set_x denied", FUNC_NAME);
}
- else if (fields_desc[SCM_LENGTH (layout) - 1] == 'W')
- field_type = fields_desc[SCM_LENGTH (layout) - 2];
+ else if (fields_desc[SCM_SYMBOL_LENGTH (layout) - 1] == 'W')
+ field_type = fields_desc[SCM_SYMBOL_LENGTH (layout) - 2];
else
{
SCM_ASSERT (0, pos, "set_x denied", FUNC_NAME);
obj = w;
ptr = SCM_VELTS (w);
- n = SCM_LENGTH (w);
+ n = SCM_VECTOR_LENGTH (w);
for (j = 0; j < n; ++j)
{
SCM alist;
register long j, n;
ptr = SCM_VELTS (w);
- n = SCM_LENGTH (w);
+ n = SCM_VECTOR_LENGTH (w);
for (j = 0; j < n; ++j)
if (SCM_FREE_CELL_P (ptr[j]))
ptr[j] = SCM_BOOL_F;
else /* if (SCM_IS_WHVEC_ANY (scm_weak_vectors[i])) */
{
SCM obj = w;
- register long n = SCM_LENGTH (w);
+ register long n = SCM_VECTOR_LENGTH (w);
register long j;
ptr = SCM_VELTS (w);