/* srfi-4.c --- Homogeneous numeric vector datatypes.
*
* Copyright (C) 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 the Free Software Foundation; either version 2, or (at
* your option) any later version.
- *
+ *
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
- *
+ *
* You should have received a copy of the GNU General Public License
* along with this software; see the file COPYING. If not, write to
* the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
make_uvec (const char * func_name, int type, int len)
{
void * p;
-
+
p = scm_gc_malloc (len * uvec_sizes[type], "uvec");
SCM_RETURN_NEWSMOB3 (scm_tc16_uvec, type, len, p);
}
/* ================================================================ */
-SCM_DEFINE (scm_u8vector_p, "u8vector?", 1, 0, 0,
+SCM_DEFINE (scm_u8vector_p, "u8vector?", 1, 0, 0,
(SCM obj),
"Return @code{#t} if @var{obj} is a vector of type u8,\n"
"@code{#f} otherwise.")
#undef FUNC_NAME
-SCM_DEFINE (scm_make_u8vector, "make-u8vector", 1, 1, 0,
+SCM_DEFINE (scm_make_u8vector, "make-u8vector", 1, 1, 0,
(SCM n, SCM fill),
"Create a newly allocated homogeneous numeric vector which can\n"
"hold @var{len} elements. If @var{fill} is given, it is used to\n"
#undef FUNC_NAME
-SCM_DEFINE (scm_u8vector, "u8vector", 0, 0, 1,
+SCM_DEFINE (scm_u8vector, "u8vector", 0, 0, 1,
(SCM l),
"Create a newly allocated homogeneous numeric vector containing\n"
"all argument values.")
#undef FUNC_NAME
-SCM_DEFINE (scm_u8vector_length, "u8vector-length", 1, 0, 0,
+SCM_DEFINE (scm_u8vector_length, "u8vector-length", 1, 0, 0,
(SCM uvec),
"Return the number of elements in the homogeneous numeric vector\n"
"@var{uvec}.")
#undef FUNC_NAME
-SCM_DEFINE (scm_u8vector_ref, "u8vector-ref", 2, 0, 0,
+SCM_DEFINE (scm_u8vector_ref, "u8vector-ref", 2, 0, 0,
(SCM uvec, SCM index),
"Return the element at @var{index} in the homogeneous numeric\n"
"vector @var{uvec}.")
#undef FUNC_NAME
-SCM_DEFINE (scm_u8vector_set_x, "u8vector-set!", 3, 0, 0,
+SCM_DEFINE (scm_u8vector_set_x, "u8vector-set!", 3, 0, 0,
(SCM uvec, SCM index, SCM value),
"Set the element at @var{index} in the homogeneous numeric\n"
"vector @var{uvec} to @var{value}. The return value is not\n"
#undef FUNC_NAME
-SCM_DEFINE (scm_u8vector_to_list, "u8vector->list", 1, 0, 0,
+SCM_DEFINE (scm_u8vector_to_list, "u8vector->list", 1, 0, 0,
(SCM uvec),
"Convert the homogeneous numeric vector @var{uvec} to a list.")
#define FUNC_NAME s_scm_u8vector_to_list
/* ================================================================ */
-SCM_DEFINE (scm_s8vector_p, "s8vector?", 1, 0, 0,
+SCM_DEFINE (scm_s8vector_p, "s8vector?", 1, 0, 0,
(SCM obj),
"Return @code{#t} if @var{obj} is a vector of type s8,\n"
"@code{#f} otherwise.")
#undef FUNC_NAME
-SCM_DEFINE (scm_make_s8vector, "make-s8vector", 1, 1, 0,
+SCM_DEFINE (scm_make_s8vector, "make-s8vector", 1, 1, 0,
(SCM n, SCM fill),
"Create a newly allocated homogeneous numeric vector which can\n"
"hold @var{len} elements. If @var{fill} is given, it is used to\n"
#undef FUNC_NAME
-SCM_DEFINE (scm_s8vector, "s8vector", 0, 0, 1,
+SCM_DEFINE (scm_s8vector, "s8vector", 0, 0, 1,
(SCM l),
"Create a newly allocated homogeneous numeric vector containing\n"
"all argument values.")
#undef FUNC_NAME
-SCM_DEFINE (scm_s8vector_length, "s8vector-length", 1, 0, 0,
+SCM_DEFINE (scm_s8vector_length, "s8vector-length", 1, 0, 0,
(SCM uvec),
"Return the number of elements in the homogeneous numeric vector\n"
"@var{uvec}.")
#undef FUNC_NAME
-SCM_DEFINE (scm_s8vector_ref, "s8vector-ref", 2, 0, 0,
+SCM_DEFINE (scm_s8vector_ref, "s8vector-ref", 2, 0, 0,
(SCM uvec, SCM index),
"Return the element at @var{index} in the homogeneous numeric\n"
"vector @var{uvec}.")
#undef FUNC_NAME
-SCM_DEFINE (scm_s8vector_set_x, "s8vector-set!", 3, 0, 0,
+SCM_DEFINE (scm_s8vector_set_x, "s8vector-set!", 3, 0, 0,
(SCM uvec, SCM index, SCM value),
"Set the element at @var{index} in the homogeneous numeric\n"
"vector @var{uvec} to @var{value}. The return value is not\n"
#undef FUNC_NAME
-SCM_DEFINE (scm_s8vector_to_list, "s8vector->list", 1, 0, 0,
+SCM_DEFINE (scm_s8vector_to_list, "s8vector->list", 1, 0, 0,
(SCM uvec),
"Convert the homogeneous numeric vector @var{uvec} to a list.")
#define FUNC_NAME s_scm_s8vector_to_list
/* ================================================================ */
-SCM_DEFINE (scm_u16vector_p, "u16vector?", 1, 0, 0,
+SCM_DEFINE (scm_u16vector_p, "u16vector?", 1, 0, 0,
(SCM obj),
"Return @code{#t} if @var{obj} is a vector of type u16,\n"
"@code{#f} otherwise.")
#undef FUNC_NAME
-SCM_DEFINE (scm_make_u16vector, "make-u16vector", 1, 1, 0,
+SCM_DEFINE (scm_make_u16vector, "make-u16vector", 1, 1, 0,
(SCM n, SCM fill),
"Create a newly allocated homogeneous numeric vector which can\n"
"hold @var{len} elements. If @var{fill} is given, it is used to\n"
#undef FUNC_NAME
-SCM_DEFINE (scm_u16vector, "u16vector", 0, 0, 1,
+SCM_DEFINE (scm_u16vector, "u16vector", 0, 0, 1,
(SCM l),
"Create a newly allocated homogeneous numeric vector containing\n"
"all argument values.")
#undef FUNC_NAME
-SCM_DEFINE (scm_u16vector_length, "u16vector-length", 1, 0, 0,
+SCM_DEFINE (scm_u16vector_length, "u16vector-length", 1, 0, 0,
(SCM uvec),
"Return the number of elements in the homogeneous numeric vector\n"
"@var{uvec}.")
#undef FUNC_NAME
-SCM_DEFINE (scm_u16vector_ref, "u16vector-ref", 2, 0, 0,
+SCM_DEFINE (scm_u16vector_ref, "u16vector-ref", 2, 0, 0,
(SCM uvec, SCM index),
"Return the element at @var{index} in the homogeneous numeric\n"
"vector @var{uvec}.")
#undef FUNC_NAME
-SCM_DEFINE (scm_u16vector_set_x, "u16vector-set!", 3, 0, 0,
+SCM_DEFINE (scm_u16vector_set_x, "u16vector-set!", 3, 0, 0,
(SCM uvec, SCM index, SCM value),
"Set the element at @var{index} in the homogeneous numeric\n"
"vector @var{uvec} to @var{value}. The return value is not\n"
#undef FUNC_NAME
-SCM_DEFINE (scm_u16vector_to_list, "u16vector->list", 1, 0, 0,
+SCM_DEFINE (scm_u16vector_to_list, "u16vector->list", 1, 0, 0,
(SCM uvec),
"Convert the homogeneous numeric vector @var{uvec} to a list.")
#define FUNC_NAME s_scm_u16vector_to_list
/* ================================================================ */
-SCM_DEFINE (scm_s16vector_p, "s16vector?", 1, 0, 0,
+SCM_DEFINE (scm_s16vector_p, "s16vector?", 1, 0, 0,
(SCM obj),
"Return @code{#t} if @var{obj} is a vector of type s16,\n"
"@code{#f} otherwise.")
#undef FUNC_NAME
-SCM_DEFINE (scm_make_s16vector, "make-s16vector", 1, 1, 0,
+SCM_DEFINE (scm_make_s16vector, "make-s16vector", 1, 1, 0,
(SCM n, SCM fill),
"Create a newly allocated homogeneous numeric vector which can\n"
"hold @var{len} elements. If @var{fill} is given, it is used to\n"
#undef FUNC_NAME
-SCM_DEFINE (scm_s16vector, "s16vector", 0, 0, 1,
+SCM_DEFINE (scm_s16vector, "s16vector", 0, 0, 1,
(SCM l),
"Create a newly allocated homogeneous numeric vector containing\n"
"all argument values.")
#undef FUNC_NAME
-SCM_DEFINE (scm_s16vector_length, "s16vector-length", 1, 0, 0,
+SCM_DEFINE (scm_s16vector_length, "s16vector-length", 1, 0, 0,
(SCM uvec),
"Return the number of elements in the homogeneous numeric vector\n"
"@var{uvec}.")
#undef FUNC_NAME
-SCM_DEFINE (scm_s16vector_ref, "s16vector-ref", 2, 0, 0,
+SCM_DEFINE (scm_s16vector_ref, "s16vector-ref", 2, 0, 0,
(SCM uvec, SCM index),
"Return the element at @var{index} in the homogeneous numeric\n"
"vector @var{uvec}.")
#undef FUNC_NAME
-SCM_DEFINE (scm_s16vector_set_x, "s16vector-set!", 3, 0, 0,
+SCM_DEFINE (scm_s16vector_set_x, "s16vector-set!", 3, 0, 0,
(SCM uvec, SCM index, SCM value),
"Set the element at @var{index} in the homogeneous numeric\n"
"vector @var{uvec} to @var{value}. The return value is not\n"
#undef FUNC_NAME
-SCM_DEFINE (scm_s16vector_to_list, "s16vector->list", 1, 0, 0,
+SCM_DEFINE (scm_s16vector_to_list, "s16vector->list", 1, 0, 0,
(SCM uvec),
"Convert the homogeneous numeric vector @var{uvec} to a list.")
#define FUNC_NAME s_scm_s16vector_to_list
/* ================================================================ */
-SCM_DEFINE (scm_u32vector_p, "u32vector?", 1, 0, 0,
+SCM_DEFINE (scm_u32vector_p, "u32vector?", 1, 0, 0,
(SCM obj),
"Return @code{#t} if @var{obj} is a vector of type u32,\n"
"@code{#f} otherwise.")
#undef FUNC_NAME
-SCM_DEFINE (scm_make_u32vector, "make-u32vector", 1, 1, 0,
+SCM_DEFINE (scm_make_u32vector, "make-u32vector", 1, 1, 0,
(SCM n, SCM fill),
"Create a newly allocated homogeneous numeric vector which can\n"
"hold @var{len} elements. If @var{fill} is given, it is used to\n"
#undef FUNC_NAME
-SCM_DEFINE (scm_u32vector, "u32vector", 0, 0, 1,
+SCM_DEFINE (scm_u32vector, "u32vector", 0, 0, 1,
(SCM l),
"Create a newly allocated homogeneous numeric vector containing\n"
"all argument values.")
#undef FUNC_NAME
-SCM_DEFINE (scm_u32vector_length, "u32vector-length", 1, 0, 0,
+SCM_DEFINE (scm_u32vector_length, "u32vector-length", 1, 0, 0,
(SCM uvec),
"Return the number of elements in the homogeneous numeric vector\n"
"@var{uvec}.")
#undef FUNC_NAME
-SCM_DEFINE (scm_u32vector_ref, "u32vector-ref", 2, 0, 0,
+SCM_DEFINE (scm_u32vector_ref, "u32vector-ref", 2, 0, 0,
(SCM uvec, SCM index),
"Return the element at @var{index} in the homogeneous numeric\n"
"vector @var{uvec}.")
#undef FUNC_NAME
-SCM_DEFINE (scm_u32vector_set_x, "u32vector-set!", 3, 0, 0,
+SCM_DEFINE (scm_u32vector_set_x, "u32vector-set!", 3, 0, 0,
(SCM uvec, SCM index, SCM value),
"Set the element at @var{index} in the homogeneous numeric\n"
"vector @var{uvec} to @var{value}. The return value is not\n"
#undef FUNC_NAME
-SCM_DEFINE (scm_u32vector_to_list, "u32vector->list", 1, 0, 0,
+SCM_DEFINE (scm_u32vector_to_list, "u32vector->list", 1, 0, 0,
(SCM uvec),
"Convert the homogeneous numeric vector @var{uvec} to a list.")
#define FUNC_NAME s_scm_u32vector_to_list
/* ================================================================ */
-SCM_DEFINE (scm_s32vector_p, "s32vector?", 1, 0, 0,
+SCM_DEFINE (scm_s32vector_p, "s32vector?", 1, 0, 0,
(SCM obj),
"Return @code{#t} if @var{obj} is a vector of type s32,\n"
"@code{#f} otherwise.")
#undef FUNC_NAME
-SCM_DEFINE (scm_make_s32vector, "make-s32vector", 1, 1, 0,
+SCM_DEFINE (scm_make_s32vector, "make-s32vector", 1, 1, 0,
(SCM n, SCM fill),
"Create a newly allocated homogeneous numeric vector which can\n"
"hold @var{len} elements. If @var{fill} is given, it is used to\n"
#undef FUNC_NAME
-SCM_DEFINE (scm_s32vector, "s32vector", 0, 0, 1,
+SCM_DEFINE (scm_s32vector, "s32vector", 0, 0, 1,
(SCM l),
"Create a newly allocated homogeneous numeric vector containing\n"
"all argument values.")
#undef FUNC_NAME
-SCM_DEFINE (scm_s32vector_length, "s32vector-length", 1, 0, 0,
+SCM_DEFINE (scm_s32vector_length, "s32vector-length", 1, 0, 0,
(SCM uvec),
"Return the number of elements in the homogeneous numeric vector\n"
"@var{uvec}.")
#undef FUNC_NAME
-SCM_DEFINE (scm_s32vector_ref, "s32vector-ref", 2, 0, 0,
+SCM_DEFINE (scm_s32vector_ref, "s32vector-ref", 2, 0, 0,
(SCM uvec, SCM index),
"Return the element at @var{index} in the homogeneous numeric\n"
"vector @var{uvec}.")
#undef FUNC_NAME
-SCM_DEFINE (scm_s32vector_set_x, "s32vector-set!", 3, 0, 0,
+SCM_DEFINE (scm_s32vector_set_x, "s32vector-set!", 3, 0, 0,
(SCM uvec, SCM index, SCM value),
"Set the element at @var{index} in the homogeneous numeric\n"
"vector @var{uvec} to @var{value}. The return value is not\n"
#undef FUNC_NAME
-SCM_DEFINE (scm_s32vector_to_list, "s32vector->list", 1, 0, 0,
+SCM_DEFINE (scm_s32vector_to_list, "s32vector->list", 1, 0, 0,
(SCM uvec),
"Convert the homogeneous numeric vector @var{uvec} to a list.")
#define FUNC_NAME s_scm_s32vector_to_list
/* ================================================================ */
-SCM_DEFINE (scm_u64vector_p, "u64vector?", 1, 0, 0,
+SCM_DEFINE (scm_u64vector_p, "u64vector?", 1, 0, 0,
(SCM obj),
"Return @code{#t} if @var{obj} is a vector of type u64,\n"
"@code{#f} otherwise.")
#undef FUNC_NAME
-SCM_DEFINE (scm_make_u64vector, "make-u64vector", 1, 1, 0,
+SCM_DEFINE (scm_make_u64vector, "make-u64vector", 1, 1, 0,
(SCM n, SCM fill),
"Create a newly allocated homogeneous numeric vector which can\n"
"hold @var{len} elements. If @var{fill} is given, it is used to\n"
#undef FUNC_NAME
-SCM_DEFINE (scm_u64vector, "u64vector", 0, 0, 1,
+SCM_DEFINE (scm_u64vector, "u64vector", 0, 0, 1,
(SCM l),
"Create a newly allocated homogeneous numeric vector containing\n"
"all argument values.")
#undef FUNC_NAME
-SCM_DEFINE (scm_u64vector_length, "u64vector-length", 1, 0, 0,
+SCM_DEFINE (scm_u64vector_length, "u64vector-length", 1, 0, 0,
(SCM uvec),
"Return the number of elements in the homogeneous numeric vector\n"
"@var{uvec}.")
#undef FUNC_NAME
-SCM_DEFINE (scm_u64vector_ref, "u64vector-ref", 2, 0, 0,
+SCM_DEFINE (scm_u64vector_ref, "u64vector-ref", 2, 0, 0,
(SCM uvec, SCM index),
"Return the element at @var{index} in the homogeneous numeric\n"
"vector @var{uvec}.")
#undef FUNC_NAME
-SCM_DEFINE (scm_u64vector_set_x, "u64vector-set!", 3, 0, 0,
+SCM_DEFINE (scm_u64vector_set_x, "u64vector-set!", 3, 0, 0,
(SCM uvec, SCM index, SCM value),
"Set the element at @var{index} in the homogeneous numeric\n"
"vector @var{uvec} to @var{value}. The return value is not\n"
#undef FUNC_NAME
-SCM_DEFINE (scm_u64vector_to_list, "u64vector->list", 1, 0, 0,
+SCM_DEFINE (scm_u64vector_to_list, "u64vector->list", 1, 0, 0,
(SCM uvec),
"Convert the homogeneous numeric vector @var{uvec} to a list.")
#define FUNC_NAME s_scm_u64vector_to_list
/* ================================================================ */
-SCM_DEFINE (scm_s64vector_p, "s64vector?", 1, 0, 0,
+SCM_DEFINE (scm_s64vector_p, "s64vector?", 1, 0, 0,
(SCM obj),
"Return @code{#t} if @var{obj} is a vector of type s64,\n"
"@code{#f} otherwise.")
#undef FUNC_NAME
-SCM_DEFINE (scm_make_s64vector, "make-s64vector", 1, 1, 0,
+SCM_DEFINE (scm_make_s64vector, "make-s64vector", 1, 1, 0,
(SCM n, SCM fill),
"Create a newly allocated homogeneous numeric vector which can\n"
"hold @var{len} elements. If @var{fill} is given, it is used to\n"
#undef FUNC_NAME
-SCM_DEFINE (scm_s64vector, "s64vector", 0, 0, 1,
+SCM_DEFINE (scm_s64vector, "s64vector", 0, 0, 1,
(SCM l),
"Create a newly allocated homogeneous numeric vector containing\n"
"all argument values.")
#undef FUNC_NAME
-SCM_DEFINE (scm_s64vector_length, "s64vector-length", 1, 0, 0,
+SCM_DEFINE (scm_s64vector_length, "s64vector-length", 1, 0, 0,
(SCM uvec),
"Return the number of elements in the homogeneous numeric vector\n"
"@var{uvec}.")
#undef FUNC_NAME
-SCM_DEFINE (scm_s64vector_ref, "s64vector-ref", 2, 0, 0,
+SCM_DEFINE (scm_s64vector_ref, "s64vector-ref", 2, 0, 0,
(SCM uvec, SCM index),
"Return the element at @var{index} in the homogeneous numeric\n"
"vector @var{uvec}.")
#undef FUNC_NAME
-SCM_DEFINE (scm_s64vector_set_x, "s64vector-set!", 3, 0, 0,
+SCM_DEFINE (scm_s64vector_set_x, "s64vector-set!", 3, 0, 0,
(SCM uvec, SCM index, SCM value),
"Set the element at @var{index} in the homogeneous numeric\n"
"vector @var{uvec} to @var{value}. The return value is not\n"
#undef FUNC_NAME
-SCM_DEFINE (scm_s64vector_to_list, "s64vector->list", 1, 0, 0,
+SCM_DEFINE (scm_s64vector_to_list, "s64vector->list", 1, 0, 0,
(SCM uvec),
"Convert the homogeneous numeric vector @var{uvec} to a list.")
#define FUNC_NAME s_scm_s64vector_to_list
/* ================================================================ */
-SCM_DEFINE (scm_f32vector_p, "f32vector?", 1, 0, 0,
+SCM_DEFINE (scm_f32vector_p, "f32vector?", 1, 0, 0,
(SCM obj),
"Return @code{#t} if @var{obj} is a vector of type f32,\n"
"@code{#f} otherwise.")
#undef FUNC_NAME
-SCM_DEFINE (scm_make_f32vector, "make-f32vector", 1, 1, 0,
+SCM_DEFINE (scm_make_f32vector, "make-f32vector", 1, 1, 0,
(SCM n, SCM fill),
"Create a newly allocated homogeneous numeric vector which can\n"
"hold @var{len} elements. If @var{fill} is given, it is used to\n"
#undef FUNC_NAME
-SCM_DEFINE (scm_f32vector, "f32vector", 0, 0, 1,
+SCM_DEFINE (scm_f32vector, "f32vector", 0, 0, 1,
(SCM l),
"Create a newly allocated homogeneous numeric vector containing\n"
"all argument values.")
#undef FUNC_NAME
-SCM_DEFINE (scm_f32vector_length, "f32vector-length", 1, 0, 0,
+SCM_DEFINE (scm_f32vector_length, "f32vector-length", 1, 0, 0,
(SCM uvec),
"Return the number of elements in the homogeneous numeric vector\n"
"@var{uvec}.")
#undef FUNC_NAME
-SCM_DEFINE (scm_f32vector_ref, "f32vector-ref", 2, 0, 0,
+SCM_DEFINE (scm_f32vector_ref, "f32vector-ref", 2, 0, 0,
(SCM uvec, SCM index),
"Return the element at @var{index} in the homogeneous numeric\n"
"vector @var{uvec}.")
#undef FUNC_NAME
-SCM_DEFINE (scm_f32vector_set_x, "f32vector-set!", 3, 0, 0,
+SCM_DEFINE (scm_f32vector_set_x, "f32vector-set!", 3, 0, 0,
(SCM uvec, SCM index, SCM value),
"Set the element at @var{index} in the homogeneous numeric\n"
"vector @var{uvec} to @var{value}. The return value is not\n"
#undef FUNC_NAME
-SCM_DEFINE (scm_f32vector_to_list, "f32vector->list", 1, 0, 0,
+SCM_DEFINE (scm_f32vector_to_list, "f32vector->list", 1, 0, 0,
(SCM uvec),
"Convert the homogeneous numeric vector @var{uvec} to a list.")
#define FUNC_NAME s_scm_f32vector_to_list
/* ================================================================ */
-SCM_DEFINE (scm_f64vector_p, "f64vector?", 1, 0, 0,
+SCM_DEFINE (scm_f64vector_p, "f64vector?", 1, 0, 0,
(SCM obj),
"Return @code{#t} if @var{obj} is a vector of type f64,\n"
"@code{#f} otherwise.")
#undef FUNC_NAME
-SCM_DEFINE (scm_make_f64vector, "make-f64vector", 1, 1, 0,
+SCM_DEFINE (scm_make_f64vector, "make-f64vector", 1, 1, 0,
(SCM n, SCM fill),
"Create a newly allocated homogeneous numeric vector which can\n"
"hold @var{len} elements. If @var{fill} is given, it is used to\n"
#undef FUNC_NAME
-SCM_DEFINE (scm_f64vector, "f64vector", 0, 0, 1,
+SCM_DEFINE (scm_f64vector, "f64vector", 0, 0, 1,
(SCM l),
"Create a newly allocated homogeneous numeric vector containing\n"
"all argument values.")
#undef FUNC_NAME
-SCM_DEFINE (scm_f64vector_length, "f64vector-length", 1, 0, 0,
+SCM_DEFINE (scm_f64vector_length, "f64vector-length", 1, 0, 0,
(SCM uvec),
"Return the number of elements in the homogeneous numeric vector\n"
"@var{uvec}.")
#undef FUNC_NAME
-SCM_DEFINE (scm_f64vector_ref, "f64vector-ref", 2, 0, 0,
+SCM_DEFINE (scm_f64vector_ref, "f64vector-ref", 2, 0, 0,
(SCM uvec, SCM index),
"Return the element at @var{index} in the homogeneous numeric\n"
"vector @var{uvec}.")
#undef FUNC_NAME
-SCM_DEFINE (scm_f64vector_set_x, "f64vector-set!", 3, 0, 0,
+SCM_DEFINE (scm_f64vector_set_x, "f64vector-set!", 3, 0, 0,
(SCM uvec, SCM index, SCM value),
"Set the element at @var{index} in the homogeneous numeric\n"
"vector @var{uvec} to @var{value}. The return value is not\n"
#undef FUNC_NAME
-SCM_DEFINE (scm_f64vector_to_list, "f64vector->list", 1, 0, 0,
+SCM_DEFINE (scm_f64vector_to_list, "f64vector->list", 1, 0, 0,
(SCM uvec),
"Convert the homogeneous numeric vector @var{uvec} to a list.")
#define FUNC_NAME s_scm_f64vector_to_list
scm_tc16_uvec = scm_make_smob_type ("uvec", 0);
scm_set_smob_free (scm_tc16_uvec, uvec_free);
scm_set_smob_print (scm_tc16_uvec, uvec_print);
-#ifndef SCM_MAGIC_SNARFER
#include "srfi/srfi-4.x"
-#endif
}
/* End of srfi-4.c. */