* Replace a bunch of calls to SCM_LENGTH.

libguile/ChangeLog

@@ -1,3 +1,24 @@
+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

libguile/continuations.c

@@ -92,12 +92,12 @@ scm_make_cont (SCM *answer)
   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;
@@ -135,7 +135,7 @@ copy_stack_and_call (SCM cont, SCM val,
 		     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);
@@ -158,10 +158,10 @@ scm_dynthrow (SCM cont, SCM val)
   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 */

libguile/environments.c

@@ -521,7 +521,7 @@ print_observer (SCM type, SCM port, scm_print_state *pstate)
 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;
@@ -537,7 +537,7 @@ obarray_enter (SCM obarray, SCM symbol, SCM data)
 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;
@@ -565,7 +565,7 @@ obarray_replace (SCM obarray, SCM symbol, SCM data)
 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))
@@ -586,7 +586,7 @@ obarray_retrieve (SCM obarray, SCM sym)
 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;
 
@@ -609,7 +609,7 @@ obarray_remove (SCM obarray, SCM sym)
 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++)
@@ -896,7 +896,7 @@ leaf_environment_fold (SCM env, scm_environment_folder proc, SCM data, SCM init)
   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))

libguile/fluids.c

@@ -72,7 +72,7 @@ grow_fluids (scm_root_state *root_state, int new_length)
   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)
@@ -92,7 +92,7 @@ grow_fluids (scm_root_state *root_state, int new_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
@@ -158,7 +158,7 @@ SCM_DEFINE (scm_fluid_ref, "fluid-ref", 1, 0, 0,
 
   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];
 }
@@ -174,7 +174,7 @@ SCM_DEFINE (scm_fluid_set_x, "fluid-set!", 2, 0, 0,
   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;

libguile/hash.c

@@ -119,7 +119,7 @@ scm_hasher(SCM obj, unsigned long n, scm_sizet d)
 	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:
@@ -127,7 +127,7 @@ scm_hasher(SCM obj, unsigned long n, scm_sizet d)
     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)
 	  {

libguile/hashtab.c

@@ -63,10 +63,10 @@ scm_hash_fn_get_handle (SCM table,SCM obj,unsigned int (*hash_fn)(),SCM (*assoc_
   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);
+  k = hash_fn (obj, SCM_VECTOR_LENGTH (table), closure);
-  if (k >= SCM_LENGTH (table))
+  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;
@@ -82,11 +82,11 @@ scm_hash_fn_create_handle_x (SCM table,SCM obj,SCM init,unsigned int (*hash_fn)(
   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);
+  k = hash_fn (obj, SCM_VECTOR_LENGTH (table), closure);
-  if (k >= SCM_LENGTH (table))
+  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);
@@ -147,10 +147,10 @@ scm_hash_fn_remove_x (SCM table,SCM obj,unsigned int (*hash_fn)(),SCM (*assoc_fn
   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);
+  k = hash_fn (obj, SCM_VECTOR_LENGTH (table), closure);
-  if (k >= SCM_LENGTH (table))
+  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]);
@@ -533,7 +533,7 @@ SCM_DEFINE (scm_hash_fold, "hash-fold", 3, 0, 0,
 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)
     {

libguile/ioext.c

@@ -96,7 +96,7 @@ SCM_DEFINE (scm_read_delimited_x, "%read-delimited!", 3, 3, 0,
   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

libguile/objects.c

@@ -262,7 +262,7 @@ scm_mcache_lookup_cmethod (SCM cache, SCM args)
       /* Prepare for linear search */
       mask = -1;
       i = 0;
-      end = SCM_LENGTH (methods);
+      end = SCM_VECTOR_LENGTH (methods);
     }
   else
     {
@@ -457,7 +457,7 @@ SCM_DEFINE (scm_make_subclass_object, "make-subclass-object", 2, 0, 0,
   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));

libguile/ports.c

@@ -1084,7 +1084,7 @@ SCM_DEFINE (scm_unread_string, "unread-string", 2, 0, 0,
   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;
 }

libguile/socket.c

@@ -709,7 +709,7 @@ SCM_DEFINE (scm_recv, "recv!", 2, 1, 0,
   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;
 
@@ -777,7 +777,7 @@ SCM_DEFINE (scm_recvfrom, "recvfrom!", 2, 3, 0,
 
   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;

libguile/stacks.c

@@ -438,7 +438,7 @@ SCM_DEFINE (scm_make_stack, "make-stack", 1, 0, 1,
 	  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);
 	}
@@ -522,7 +522,7 @@ SCM_DEFINE (scm_stack_id, "stack-id", 1, 0, 0,
 	  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);
 	}
@@ -592,7 +592,7 @@ SCM_DEFINE (scm_last_stack_frame, "last-stack-frame", 1, 0, 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);
     }

libguile/strings.c

@@ -242,7 +242,7 @@ SCM_DEFINE (scm_string_length, "string-length", 1, 0, 0,
 #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
 
@@ -268,7 +268,7 @@ SCM_DEFINE (scm_string_set_x, "string-set!", 3, 0, 0,
 #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;

libguile/strop.c

@@ -255,10 +255,10 @@ SCM_DEFINE (scm_substring_move_x, "substring-move!", 5, 0, 0,
   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 (2,start1,s1 <= SCM_STRING_LENGTH (str1) && s1 >= 0);
-  SCM_ASSERT_RANGE (5,start2,s2 <= SCM_LENGTH (str2) && s2 >= 0);
+  SCM_ASSERT_RANGE (5,start2,s2 <= SCM_STRING_LENGTH (str2) && s2 >= 0);
-  SCM_ASSERT_RANGE (3,end1,e <= SCM_LENGTH (str1) && e >= 0);
+  SCM_ASSERT_RANGE (3,end1,e <= SCM_STRING_LENGTH (str1) && e >= 0);
-  SCM_ASSERT_RANGE (5,start2,len+s2 <= SCM_LENGTH (str2));
+  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])),
@@ -288,8 +288,8 @@ SCM_DEFINE (scm_substring_fill_x, "substring-fill!", 4, 0, 0,
   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 (2,start,i <= SCM_STRING_LENGTH (str) && i >= 0);
-  SCM_ASSERT_RANGE (3,end,e <= SCM_LENGTH (str) && e >= 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;
 }
@@ -358,7 +358,7 @@ SCM_DEFINE (scm_string_fill_x, "string-fill!", 2, 0, 0,
   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
@@ -379,7 +379,7 @@ SCM_DEFINE (scm_string_upcase_x, "string-upcase!", 1, 0, 0,
 
   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;
@@ -413,7 +413,7 @@ SCM_DEFINE (scm_string_downcase_x, "string-downcase!", 1, 0, 0,
 
   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;
@@ -438,7 +438,7 @@ SCM_DEFINE (scm_string_capitalize_x, "string-capitalize!", 1, 0, 0,
   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])))) {

libguile/struct.c

@@ -153,7 +153,7 @@ scm_struct_init (SCM handle, SCM layout, scm_bits_t * mem, int tail_elts, SCM in
 {
   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)
@@ -256,11 +256,11 @@ SCM_DEFINE (scm_struct_vtable_p, "struct-vtable?", 1, 0, 0,
 
   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);
@@ -441,7 +441,7 @@ SCM_DEFINE (scm_make_struct, "make-struct", 2, 0, 1,
   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;
@@ -532,7 +532,7 @@ SCM_DEFINE (scm_make_vtable_vtable, "make-vtable-vtable", 2, 0, 1,
 					   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;
@@ -582,7 +582,7 @@ SCM_DEFINE (scm_struct_ref, "struct-ref", 2, 0, 0,
   
   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];
@@ -595,8 +595,8 @@ SCM_DEFINE (scm_struct_ref, "struct-ref", 2, 0, 0,
 	    SCM_ASSERT (0, pos, "ref denied", FUNC_NAME);
 	}
     }
-  else if (fields_desc[SCM_LENGTH (layout) - 1] != 'O')    
+  else if (fields_desc[SCM_SYMBOL_LENGTH (layout) - 1] != 'O')    
-    field_type = fields_desc[SCM_LENGTH (layout) - 2];
+    field_type = fields_desc[SCM_SYMBOL_LENGTH (layout) - 2];
   else
     {
       SCM_ASSERT (0, pos, "ref denied", FUNC_NAME);
@@ -659,7 +659,7 @@ SCM_DEFINE (scm_struct_set_x, "struct-set!", 3, 0, 0,
 
   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];
@@ -667,8 +667,8 @@ SCM_DEFINE (scm_struct_set_x, "struct-set!", 3, 0, 0,
       if (set_x != 'w')
 	SCM_ASSERT (0, pos, "set_x denied", FUNC_NAME);
     }
-  else if (fields_desc[SCM_LENGTH (layout) - 1] == 'W')    
+  else if (fields_desc[SCM_SYMBOL_LENGTH (layout) - 1] == 'W')    
-    field_type = fields_desc[SCM_LENGTH (layout) - 2];
+    field_type = fields_desc[SCM_SYMBOL_LENGTH (layout) - 2];
   else
     {
       SCM_ASSERT (0, pos, "set_x denied", FUNC_NAME);

libguile/weaks.c

@@ -230,7 +230,7 @@ scm_mark_weak_vector_spines (void *dummy1, void *dummy2, void *dummy3)
 
 	  obj = w;
 	  ptr = SCM_VELTS (w);
-	  n = SCM_LENGTH (w);
+	  n = SCM_VECTOR_LENGTH (w);
 	  for (j = 0; j < n; ++j)
 	    {
 	      SCM alist;
@@ -262,7 +262,7 @@ scm_scan_weak_vectors (void *dummy1, void *dummy2, void *dummy3)
 	  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;
@@ -270,7 +270,7 @@ scm_scan_weak_vectors (void *dummy1, void *dummy2, void *dummy3)
       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);