root/ext/uvector/uvlib.c

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. clamp_arg
  2. uvlib_s8vectorP
  3. uvlib_make_s8vector
  4. uvlib_s8vector
  5. uvlib_s8vector_length
  6. uvlib_s8vector_ref
  7. uvlib_s8vector_setX
  8. uvlib_s8vector_copy
  9. uvlib_s8vector_copyX
  10. uvlib_s8vector_TOlist
  11. uvlib_list_TOs8vector
  12. uvlib_s8vector_fillX
  13. uvlib_s8vector_TOvector
  14. uvlib_vector_TOs8vector
  15. uvlib_u8vectorP
  16. uvlib_make_u8vector
  17. uvlib_u8vector
  18. uvlib_u8vector_length
  19. uvlib_u8vector_ref
  20. uvlib_u8vector_setX
  21. uvlib_u8vector_copy
  22. uvlib_u8vector_copyX
  23. uvlib_u8vector_TOlist
  24. uvlib_list_TOu8vector
  25. uvlib_u8vector_fillX
  26. uvlib_u8vector_TOvector
  27. uvlib_vector_TOu8vector
  28. uvlib_s16vectorP
  29. uvlib_make_s16vector
  30. uvlib_s16vector
  31. uvlib_s16vector_length
  32. uvlib_s16vector_ref
  33. uvlib_s16vector_setX
  34. uvlib_s16vector_copy
  35. uvlib_s16vector_copyX
  36. uvlib_s16vector_TOlist
  37. uvlib_list_TOs16vector
  38. uvlib_s16vector_fillX
  39. uvlib_s16vector_TOvector
  40. uvlib_vector_TOs16vector
  41. uvlib_u16vectorP
  42. uvlib_make_u16vector
  43. uvlib_u16vector
  44. uvlib_u16vector_length
  45. uvlib_u16vector_ref
  46. uvlib_u16vector_setX
  47. uvlib_u16vector_copy
  48. uvlib_u16vector_copyX
  49. uvlib_u16vector_TOlist
  50. uvlib_list_TOu16vector
  51. uvlib_u16vector_fillX
  52. uvlib_u16vector_TOvector
  53. uvlib_vector_TOu16vector
  54. uvlib_s32vectorP
  55. uvlib_make_s32vector
  56. uvlib_s32vector
  57. uvlib_s32vector_length
  58. uvlib_s32vector_ref
  59. uvlib_s32vector_setX
  60. uvlib_s32vector_copy
  61. uvlib_s32vector_copyX
  62. uvlib_s32vector_TOlist
  63. uvlib_list_TOs32vector
  64. uvlib_s32vector_fillX
  65. uvlib_s32vector_TOvector
  66. uvlib_vector_TOs32vector
  67. uvlib_u32vectorP
  68. uvlib_make_u32vector
  69. uvlib_u32vector
  70. uvlib_u32vector_length
  71. uvlib_u32vector_ref
  72. uvlib_u32vector_setX
  73. uvlib_u32vector_copy
  74. uvlib_u32vector_copyX
  75. uvlib_u32vector_TOlist
  76. uvlib_list_TOu32vector
  77. uvlib_u32vector_fillX
  78. uvlib_u32vector_TOvector
  79. uvlib_vector_TOu32vector
  80. uvlib_s64vectorP
  81. uvlib_make_s64vector
  82. uvlib_s64vector
  83. uvlib_s64vector_length
  84. uvlib_s64vector_ref
  85. uvlib_s64vector_setX
  86. uvlib_s64vector_copy
  87. uvlib_s64vector_copyX
  88. uvlib_s64vector_TOlist
  89. uvlib_list_TOs64vector
  90. uvlib_s64vector_fillX
  91. uvlib_s64vector_TOvector
  92. uvlib_vector_TOs64vector
  93. uvlib_u64vectorP
  94. uvlib_make_u64vector
  95. uvlib_u64vector
  96. uvlib_u64vector_length
  97. uvlib_u64vector_ref
  98. uvlib_u64vector_setX
  99. uvlib_u64vector_copy
  100. uvlib_u64vector_copyX
  101. uvlib_u64vector_TOlist
  102. uvlib_list_TOu64vector
  103. uvlib_u64vector_fillX
  104. uvlib_u64vector_TOvector
  105. uvlib_vector_TOu64vector
  106. uvlib_f32vectorP
  107. uvlib_make_f32vector
  108. uvlib_f32vector
  109. uvlib_f32vector_length
  110. uvlib_f32vector_ref
  111. uvlib_f32vector_setX
  112. uvlib_f32vector_copy
  113. uvlib_f32vector_copyX
  114. uvlib_f32vector_TOlist
  115. uvlib_list_TOf32vector
  116. uvlib_f32vector_fillX
  117. uvlib_f32vector_TOvector
  118. uvlib_vector_TOf32vector
  119. uvlib_f64vectorP
  120. uvlib_make_f64vector
  121. uvlib_f64vector
  122. uvlib_f64vector_length
  123. uvlib_f64vector_ref
  124. uvlib_f64vector_setX
  125. uvlib_f64vector_copy
  126. uvlib_f64vector_copyX
  127. uvlib_f64vector_TOlist
  128. uvlib_list_TOf64vector
  129. uvlib_f64vector_fillX
  130. uvlib_f64vector_TOvector
  131. uvlib_vector_TOf64vector
  132. uvlib_s8vector_add
  133. uvlib_s8vector_addX
  134. uvlib_u8vector_add
  135. uvlib_u8vector_addX
  136. uvlib_s16vector_add
  137. uvlib_s16vector_addX
  138. uvlib_u16vector_add
  139. uvlib_u16vector_addX
  140. uvlib_s32vector_add
  141. uvlib_s32vector_addX
  142. uvlib_u32vector_add
  143. uvlib_u32vector_addX
  144. uvlib_s64vector_add
  145. uvlib_s64vector_addX
  146. uvlib_u64vector_add
  147. uvlib_u64vector_addX
  148. uvlib_f32vector_add
  149. uvlib_f32vector_addX
  150. uvlib_f64vector_add
  151. uvlib_f64vector_addX
  152. uvlib_s8vector_sub
  153. uvlib_s8vector_subX
  154. uvlib_u8vector_sub
  155. uvlib_u8vector_subX
  156. uvlib_s16vector_sub
  157. uvlib_s16vector_subX
  158. uvlib_u16vector_sub
  159. uvlib_u16vector_subX
  160. uvlib_s32vector_sub
  161. uvlib_s32vector_subX
  162. uvlib_u32vector_sub
  163. uvlib_u32vector_subX
  164. uvlib_s64vector_sub
  165. uvlib_s64vector_subX
  166. uvlib_u64vector_sub
  167. uvlib_u64vector_subX
  168. uvlib_f32vector_sub
  169. uvlib_f32vector_subX
  170. uvlib_f64vector_sub
  171. uvlib_f64vector_subX
  172. uvlib_s8vector_mul
  173. uvlib_s8vector_mulX
  174. uvlib_u8vector_mul
  175. uvlib_u8vector_mulX
  176. uvlib_s16vector_mul
  177. uvlib_s16vector_mulX
  178. uvlib_u16vector_mul
  179. uvlib_u16vector_mulX
  180. uvlib_s32vector_mul
  181. uvlib_s32vector_mulX
  182. uvlib_u32vector_mul
  183. uvlib_u32vector_mulX
  184. uvlib_s64vector_mul
  185. uvlib_s64vector_mulX
  186. uvlib_u64vector_mul
  187. uvlib_u64vector_mulX
  188. uvlib_f32vector_mul
  189. uvlib_f32vector_mulX
  190. uvlib_f64vector_mul
  191. uvlib_f64vector_mulX
  192. uvlib_f32vector_div
  193. uvlib_f32vector_divX
  194. uvlib_f64vector_div
  195. uvlib_f64vector_divX
  196. uvlib_s8vector_and
  197. uvlib_s8vector_andX
  198. uvlib_s8vector_ior
  199. uvlib_s8vector_iorX
  200. uvlib_s8vector_xor
  201. uvlib_s8vector_xorX
  202. uvlib_u8vector_and
  203. uvlib_u8vector_andX
  204. uvlib_u8vector_ior
  205. uvlib_u8vector_iorX
  206. uvlib_u8vector_xor
  207. uvlib_u8vector_xorX
  208. uvlib_s16vector_and
  209. uvlib_s16vector_andX
  210. uvlib_s16vector_ior
  211. uvlib_s16vector_iorX
  212. uvlib_s16vector_xor
  213. uvlib_s16vector_xorX
  214. uvlib_u16vector_and
  215. uvlib_u16vector_andX
  216. uvlib_u16vector_ior
  217. uvlib_u16vector_iorX
  218. uvlib_u16vector_xor
  219. uvlib_u16vector_xorX
  220. uvlib_s32vector_and
  221. uvlib_s32vector_andX
  222. uvlib_s32vector_ior
  223. uvlib_s32vector_iorX
  224. uvlib_s32vector_xor
  225. uvlib_s32vector_xorX
  226. uvlib_u32vector_and
  227. uvlib_u32vector_andX
  228. uvlib_u32vector_ior
  229. uvlib_u32vector_iorX
  230. uvlib_u32vector_xor
  231. uvlib_u32vector_xorX
  232. uvlib_s64vector_and
  233. uvlib_s64vector_andX
  234. uvlib_s64vector_ior
  235. uvlib_s64vector_iorX
  236. uvlib_s64vector_xor
  237. uvlib_s64vector_xorX
  238. uvlib_u64vector_and
  239. uvlib_u64vector_andX
  240. uvlib_u64vector_ior
  241. uvlib_u64vector_iorX
  242. uvlib_u64vector_xor
  243. uvlib_u64vector_xorX
  244. uvlib_s8vector_dot
  245. uvlib_u8vector_dot
  246. uvlib_s16vector_dot
  247. uvlib_u16vector_dot
  248. uvlib_s32vector_dot
  249. uvlib_u32vector_dot
  250. uvlib_s64vector_dot
  251. uvlib_u64vector_dot
  252. uvlib_f32vector_dot
  253. uvlib_f64vector_dot
  254. uvlib_s8vector_range_check
  255. uvlib_s8vector_clamp
  256. uvlib_s8vector_clampX
  257. uvlib_u8vector_range_check
  258. uvlib_u8vector_clamp
  259. uvlib_u8vector_clampX
  260. uvlib_s16vector_range_check
  261. uvlib_s16vector_clamp
  262. uvlib_s16vector_clampX
  263. uvlib_u16vector_range_check
  264. uvlib_u16vector_clamp
  265. uvlib_u16vector_clampX
  266. uvlib_s32vector_range_check
  267. uvlib_s32vector_clamp
  268. uvlib_s32vector_clampX
  269. uvlib_u32vector_range_check
  270. uvlib_u32vector_clamp
  271. uvlib_u32vector_clampX
  272. uvlib_s64vector_range_check
  273. uvlib_s64vector_clamp
  274. uvlib_s64vector_clampX
  275. uvlib_u64vector_range_check
  276. uvlib_u64vector_clamp
  277. uvlib_u64vector_clampX
  278. uvlib_f32vector_range_check
  279. uvlib_f32vector_clamp
  280. uvlib_f32vector_clampX
  281. uvlib_f64vector_range_check
  282. uvlib_f64vector_clamp
  283. uvlib_f64vector_clampX
  284. uvlib_s16vector_swap_bytes
  285. uvlib_s16vector_swap_bytesX
  286. uvlib_u16vector_swap_bytes
  287. uvlib_u16vector_swap_bytesX
  288. uvlib_s32vector_swap_bytes
  289. uvlib_s32vector_swap_bytesX
  290. uvlib_u32vector_swap_bytes
  291. uvlib_u32vector_swap_bytesX
  292. uvlib_s64vector_swap_bytes
  293. uvlib_s64vector_swap_bytesX
  294. uvlib_u64vector_swap_bytes
  295. uvlib_u64vector_swap_bytesX
  296. uvlib_f32vector_swap_bytes
  297. uvlib_f32vector_swap_bytesX
  298. uvlib_f64vector_swap_bytes
  299. uvlib_f64vector_swap_bytesX
  300. uvlib_uvector_alias
  301. uvlib_uvector_swap_bytes
  302. uvlib_uvector_swap_bytesX
  303. uvlib_read_blockX
  304. uvlib_write_block
  305. string_to_bytevector
  306. uvlib_string_TOs8vector
  307. uvlib_string_TOu8vector
  308. string_to_bytevectorX
  309. uvlib_string_TOs8vectorX
  310. uvlib_string_TOu8vectorX
  311. bytevector_to_string
  312. uvlib_s8vector_TOstring
  313. uvlib_u8vector_TOstring
  314. string_to_wordvector
  315. uvlib_string_TOs32vector
  316. uvlib_string_TOu32vector
  317. wordvector_to_string
  318. uvlib_s32vector_TOstring
  319. uvlib_u32vector_TOstring
  320. Scm_Init_uvlib

   1 /* Generated by genstub.  Do not edit. */
   2 #include <gauche.h>
   3 #if defined(__CYGWIN__) || defined(__MINGW32__)
   4 #define SCM_CGEN_CONST /*empty*/
   5 #else
   6 #define SCM_CGEN_CONST const
   7 #endif
   8 
   9 #include <math.h>
  10 #include "gauche/uvector.h"
  11 #include "uvectorP.h"
  12 
  13 static SCM_DEFINE_STRING_CONST(sym_both__NAME, "both", 4, 4);
  14 static ScmObj sym_both = SCM_UNBOUND;
  15 static SCM_DEFINE_STRING_CONST(sym_high__NAME, "high", 4, 4);
  16 static ScmObj sym_high = SCM_UNBOUND;
  17 static SCM_DEFINE_STRING_CONST(sym_low__NAME, "low", 3, 3);
  18 static ScmObj sym_low = SCM_UNBOUND;
  19 static int clamp_arg(ScmObj clamp)
  20  {
  21    if (SCM_EQ(clamp, sym_both)) return SCM_CLAMP_BOTH;
  22    else if (SCM_EQ(clamp, sym_low))  return SCM_CLAMP_LO;
  23    else if (SCM_EQ(clamp, sym_high)) return SCM_CLAMP_HI;
  24    if (!SCM_FALSEP(clamp) && !SCM_UNBOUNDP(clamp))
  25      Scm_Error("clamp argument must be either 'both, 'high, 'low or #f, but got %S", clamp);
  26    return SCM_CLAMP_ERROR;
  27  }
  28 
  29 static ScmObj uvlib_s8vectorP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
  30 {
  31   ScmObj obj_scm;
  32   ScmObj obj;
  33   SCM_ENTER_SUBR("s8vector?");
  34   obj_scm = SCM_ARGREF(0);
  35   obj = (obj_scm);
  36   {
  37 {
  38 int SCM_RESULT;
  39 SCM_RESULT = SCM_S8VECTORP(obj);
  40 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
  41 }
  42   }
  43 }
  44 
  45 static SCM_DEFINE_STRING_CONST(uvlib_s8vectorP__NAME, "s8vector?", 9, 9);
  46 static SCM_DEFINE_SUBR(uvlib_s8vectorP__STUB, 1, 0, SCM_OBJ(&uvlib_s8vectorP__NAME), uvlib_s8vectorP, NULL, NULL);
  47 
  48 static ScmObj uvlib_make_s8vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
  49 {
  50   ScmObj length_scm;
  51   int length;
  52   ScmObj fill_scm;
  53   ScmObj fill;
  54   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
  55   SCM_ENTER_SUBR("make-s8vector");
  56   if (Scm_Length(SCM_OPTARGS) > 1)
  57     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
  58   length_scm = SCM_ARGREF(0);
  59   if (!SCM_INTP(length_scm)) Scm_Error("small integer required, but got %S", length_scm);
  60   length = SCM_INT_VALUE(length_scm);
  61   if (SCM_NULLP(SCM_OPTARGS)) fill_scm = Scm_MakeInteger(0);
  62   else {
  63     fill_scm = SCM_CAR(SCM_OPTARGS);
  64     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
  65   }
  66   fill = (fill_scm);
  67   {
  68 signed char filler;
  69   filler = s8unbox(fill, SCM_CLAMP_ERROR);
  70   SCM_RETURN(Scm_MakeS8Vector(length, filler));
  71   }
  72 }
  73 
  74 static SCM_DEFINE_STRING_CONST(uvlib_make_s8vector__NAME, "make-s8vector", 13, 13);
  75 static SCM_DEFINE_SUBR(uvlib_make_s8vector__STUB, 1, 1, SCM_OBJ(&uvlib_make_s8vector__NAME), uvlib_make_s8vector, NULL, NULL);
  76 
  77 static ScmObj uvlib_s8vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
  78 {
  79   ScmObj args_scm;
  80   ScmObj args;
  81   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
  82   SCM_ENTER_SUBR("s8vector");
  83   args_scm = SCM_OPTARGS;
  84   args = (args_scm);
  85   {
  86 SCM_RETURN(Scm_ListToS8Vector(args, SCM_CLAMP_ERROR));
  87   }
  88 }
  89 
  90 static SCM_DEFINE_STRING_CONST(uvlib_s8vector__NAME, "s8vector", 8, 8);
  91 static SCM_DEFINE_SUBR(uvlib_s8vector__STUB, 0, 1, SCM_OBJ(&uvlib_s8vector__NAME), uvlib_s8vector, NULL, NULL);
  92 
  93 static ScmObj uvlib_s8vector_length(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
  94 {
  95   ScmObj v_scm;
  96   ScmS8Vector* v;
  97   SCM_ENTER_SUBR("s8vector-length");
  98   v_scm = SCM_ARGREF(0);
  99   if (!SCM_S8VECTORP(v_scm)) Scm_Error("<s8vector> required, but got %S", v_scm);
 100   v = SCM_S8VECTOR(v_scm);
 101   {
 102 SCM_RETURN(SCM_MAKE_INT(SCM_S8VECTOR_SIZE(v)));
 103   }
 104 }
 105 
 106 static SCM_DEFINE_STRING_CONST(uvlib_s8vector_length__NAME, "s8vector-length", 15, 15);
 107 static SCM_DEFINE_SUBR(uvlib_s8vector_length__STUB, 1, 0, SCM_OBJ(&uvlib_s8vector_length__NAME), uvlib_s8vector_length, NULL, NULL);
 108 
 109 static ScmObj uvlib_s8vector_ref(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 110 {
 111   ScmObj v_scm;
 112   ScmS8Vector* v;
 113   ScmObj i_scm;
 114   int i;
 115   ScmObj fallback_scm;
 116   ScmObj fallback;
 117   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
 118   SCM_ENTER_SUBR("s8vector-ref");
 119   if (Scm_Length(SCM_OPTARGS) > 1)
 120     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
 121   v_scm = SCM_ARGREF(0);
 122   if (!SCM_S8VECTORP(v_scm)) Scm_Error("<s8vector> required, but got %S", v_scm);
 123   v = SCM_S8VECTOR(v_scm);
 124   i_scm = SCM_ARGREF(1);
 125   if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
 126   i = SCM_INT_VALUE(i_scm);
 127   if (SCM_NULLP(SCM_OPTARGS)) fallback_scm = SCM_UNBOUND;
 128   else {
 129     fallback_scm = SCM_CAR(SCM_OPTARGS);
 130     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
 131   }
 132   fallback = (fallback_scm);
 133   {
 134 SCM_RETURN(Scm_S8VectorRef(v, i, fallback));
 135   }
 136 }
 137 
 138 static SCM_DEFINE_STRING_CONST(uvlib_s8vector_ref__NAME, "s8vector-ref", 12, 12);
 139 static SCM_DEFINE_SUBR(uvlib_s8vector_ref__STUB, 2, 1, SCM_OBJ(&uvlib_s8vector_ref__NAME), uvlib_s8vector_ref, NULL, NULL);
 140 
 141 static ScmObj uvlib_s8vector_setX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 142 {
 143   ScmObj v_scm;
 144   ScmS8Vector* v;
 145   ScmObj i_scm;
 146   int i;
 147   ScmObj val_scm;
 148   ScmObj val;
 149   ScmObj clamp_scm;
 150   ScmObj clamp;
 151   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
 152   SCM_ENTER_SUBR("s8vector-set!");
 153   if (Scm_Length(SCM_OPTARGS) > 1)
 154     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
 155   v_scm = SCM_ARGREF(0);
 156   if (!SCM_S8VECTORP(v_scm)) Scm_Error("<s8vector> required, but got %S", v_scm);
 157   v = SCM_S8VECTOR(v_scm);
 158   i_scm = SCM_ARGREF(1);
 159   if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
 160   i = SCM_INT_VALUE(i_scm);
 161   val_scm = SCM_ARGREF(2);
 162   val = (val_scm);
 163   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
 164   else {
 165     clamp_scm = SCM_CAR(SCM_OPTARGS);
 166     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
 167   }
 168   clamp = (clamp_scm);
 169   {
 170 SCM_RETURN(Scm_S8VectorSet(v, i, val, clamp_arg(clamp)));
 171   }
 172 }
 173 
 174 static SCM_DEFINE_STRING_CONST(uvlib_s8vector_setX__NAME, "s8vector-set!", 13, 13);
 175 static SCM_DEFINE_SUBR(uvlib_s8vector_setX__STUB, 3, 1, SCM_OBJ(&uvlib_s8vector_setX__NAME), uvlib_s8vector_setX, NULL, NULL);
 176 
 177 static ScmObj uvlib_s8vector_copy(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 178 {
 179   ScmObj v_scm;
 180   ScmS8Vector* v;
 181   ScmObj start_scm;
 182   int start;
 183   ScmObj end_scm;
 184   int end;
 185   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
 186   SCM_ENTER_SUBR("s8vector-copy");
 187   if (Scm_Length(SCM_OPTARGS) > 2)
 188     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
 189   v_scm = SCM_ARGREF(0);
 190   if (!SCM_S8VECTORP(v_scm)) Scm_Error("<s8vector> required, but got %S", v_scm);
 191   v = SCM_S8VECTOR(v_scm);
 192   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
 193   else {
 194     start_scm = SCM_CAR(SCM_OPTARGS);
 195     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
 196   }
 197   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
 198   start = SCM_INT_VALUE(start_scm);
 199   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
 200   else {
 201     end_scm = SCM_CAR(SCM_OPTARGS);
 202     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
 203   }
 204   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
 205   end = SCM_INT_VALUE(end_scm);
 206   {
 207 {
 208 ScmObj SCM_RESULT;
 209 SCM_RESULT = Scm_S8VectorCopy(v, start, end);
 210 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
 211 }
 212   }
 213 }
 214 
 215 static SCM_DEFINE_STRING_CONST(uvlib_s8vector_copy__NAME, "s8vector-copy", 13, 13);
 216 static SCM_DEFINE_SUBR(uvlib_s8vector_copy__STUB, 1, 1, SCM_OBJ(&uvlib_s8vector_copy__NAME), uvlib_s8vector_copy, NULL, NULL);
 217 
 218 static ScmObj uvlib_s8vector_copyX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 219 {
 220   ScmObj dst_scm;
 221   ScmS8Vector* dst;
 222   ScmObj dstart_scm;
 223   ScmObj dstart;
 224   ScmObj src_scm;
 225   ScmObj src;
 226   ScmObj sstart_scm;
 227   int sstart;
 228   ScmObj send_scm;
 229   int send;
 230   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
 231   SCM_ENTER_SUBR("s8vector-copy!");
 232   if (Scm_Length(SCM_OPTARGS) > 3)
 233     Scm_Error("too many arguments: up to 3 is expected, %d given.", Scm_Length(SCM_OPTARGS));
 234   dst_scm = SCM_ARGREF(0);
 235   if (!SCM_S8VECTORP(dst_scm)) Scm_Error("<s8vector> required, but got %S", dst_scm);
 236   dst = SCM_S8VECTOR(dst_scm);
 237   dstart_scm = SCM_ARGREF(1);
 238   dstart = (dstart_scm);
 239   if (SCM_NULLP(SCM_OPTARGS)) src_scm = SCM_UNBOUND;
 240   else {
 241     src_scm = SCM_CAR(SCM_OPTARGS);
 242     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
 243   }
 244   src = (src_scm);
 245   if (SCM_NULLP(SCM_OPTARGS)) sstart_scm = Scm_MakeInteger(0);
 246   else {
 247     sstart_scm = SCM_CAR(SCM_OPTARGS);
 248     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
 249   }
 250   if (!SCM_EXACTP(sstart_scm)) Scm_Error("C integer required, but got %S", sstart_scm);
 251   sstart = Scm_GetInteger(sstart_scm);
 252   if (SCM_NULLP(SCM_OPTARGS)) send_scm = Scm_MakeInteger(-1);
 253   else {
 254     send_scm = SCM_CAR(SCM_OPTARGS);
 255     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
 256   }
 257   if (!SCM_EXACTP(send_scm)) Scm_Error("C integer required, but got %S", send_scm);
 258   send = Scm_GetInteger(send_scm);
 259   {
 260 if (SCM_INTEGERP(dstart)) {
 261      /* new API */
 262      if (!SCM_S8VECTORP(src)) {
 263        Scm_Error("s8vector-copy!: argument is not a matching uvector: %S",
 264                  src);
 265      }
 266      SCM_RETURN(Scm_S8VectorCopyX(dst, Scm_GetInteger(dstart), 
 267                                     SCM_S8VECTOR(src), sstart, send));
 268   } else if (SCM_S8VECTORP(dstart)) {
 269     /* old API */
 270     SCM_RETURN(Scm_S8VectorCopyX(dst, 0, SCM_S8VECTOR(dstart), 0, -1));
 271   } else {
 272     Scm_Error("integer required, but got %S", dstart);
 273     SCM_RETURN(SCM_UNDEFINED);
 274   }
 275   }
 276 }
 277 
 278 static SCM_DEFINE_STRING_CONST(uvlib_s8vector_copyX__NAME, "s8vector-copy!", 14, 14);
 279 static SCM_DEFINE_SUBR(uvlib_s8vector_copyX__STUB, 2, 1, SCM_OBJ(&uvlib_s8vector_copyX__NAME), uvlib_s8vector_copyX, NULL, NULL);
 280 
 281 static ScmObj uvlib_s8vector_TOlist(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 282 {
 283   ScmObj v_scm;
 284   ScmS8Vector* v;
 285   ScmObj start_scm;
 286   int start;
 287   ScmObj end_scm;
 288   int end;
 289   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
 290   SCM_ENTER_SUBR("s8vector->list");
 291   if (Scm_Length(SCM_OPTARGS) > 2)
 292     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
 293   v_scm = SCM_ARGREF(0);
 294   if (!SCM_S8VECTORP(v_scm)) Scm_Error("<s8vector> required, but got %S", v_scm);
 295   v = SCM_S8VECTOR(v_scm);
 296   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
 297   else {
 298     start_scm = SCM_CAR(SCM_OPTARGS);
 299     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
 300   }
 301   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
 302   start = SCM_INT_VALUE(start_scm);
 303   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
 304   else {
 305     end_scm = SCM_CAR(SCM_OPTARGS);
 306     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
 307   }
 308   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
 309   end = SCM_INT_VALUE(end_scm);
 310   {
 311 {
 312 ScmObj SCM_RESULT;
 313 SCM_RESULT = Scm_S8VectorToList(v, start, end);
 314 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
 315 }
 316   }
 317 }
 318 
 319 static SCM_DEFINE_STRING_CONST(uvlib_s8vector_TOlist__NAME, "s8vector->list", 14, 14);
 320 static SCM_DEFINE_SUBR(uvlib_s8vector_TOlist__STUB, 1, 1, SCM_OBJ(&uvlib_s8vector_TOlist__NAME), uvlib_s8vector_TOlist, NULL, NULL);
 321 
 322 static ScmObj uvlib_list_TOs8vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 323 {
 324   ScmObj l_scm;
 325   ScmObj l;
 326   ScmObj clamp_scm;
 327   ScmObj clamp;
 328   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
 329   SCM_ENTER_SUBR("list->s8vector");
 330   if (Scm_Length(SCM_OPTARGS) > 1)
 331     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
 332   l_scm = SCM_ARGREF(0);
 333   if (!SCM_LISTP(l_scm)) Scm_Error("list required, but got %S", l_scm);
 334   l = (l_scm);
 335   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
 336   else {
 337     clamp_scm = SCM_CAR(SCM_OPTARGS);
 338     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
 339   }
 340   clamp = (clamp_scm);
 341   {
 342 SCM_RETURN(Scm_ListToS8Vector(l, clamp_arg(clamp)));
 343   }
 344 }
 345 
 346 static SCM_DEFINE_STRING_CONST(uvlib_list_TOs8vector__NAME, "list->s8vector", 14, 14);
 347 static SCM_DEFINE_SUBR(uvlib_list_TOs8vector__STUB, 1, 1, SCM_OBJ(&uvlib_list_TOs8vector__NAME), uvlib_list_TOs8vector, NULL, NULL);
 348 
 349 static ScmObj uvlib_s8vector_fillX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 350 {
 351   ScmObj v_scm;
 352   ScmS8Vector* v;
 353   ScmObj val_scm;
 354   ScmObj val;
 355   ScmObj start_scm;
 356   int start;
 357   ScmObj end_scm;
 358   int end;
 359   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
 360   SCM_ENTER_SUBR("s8vector-fill!");
 361   if (Scm_Length(SCM_OPTARGS) > 2)
 362     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
 363   v_scm = SCM_ARGREF(0);
 364   if (!SCM_S8VECTORP(v_scm)) Scm_Error("<s8vector> required, but got %S", v_scm);
 365   v = SCM_S8VECTOR(v_scm);
 366   val_scm = SCM_ARGREF(1);
 367   val = (val_scm);
 368   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
 369   else {
 370     start_scm = SCM_CAR(SCM_OPTARGS);
 371     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
 372   }
 373   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
 374   start = SCM_INT_VALUE(start_scm);
 375   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
 376   else {
 377     end_scm = SCM_CAR(SCM_OPTARGS);
 378     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
 379   }
 380   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
 381   end = SCM_INT_VALUE(end_scm);
 382   {
 383 signed char filler;
 384   filler = s8unbox(val, SCM_CLAMP_ERROR);
 385   SCM_RETURN(Scm_S8VectorFill(v, filler, start, end));
 386   }
 387 }
 388 
 389 static SCM_DEFINE_STRING_CONST(uvlib_s8vector_fillX__NAME, "s8vector-fill!", 14, 14);
 390 static SCM_DEFINE_SUBR(uvlib_s8vector_fillX__STUB, 2, 1, SCM_OBJ(&uvlib_s8vector_fillX__NAME), uvlib_s8vector_fillX, NULL, NULL);
 391 
 392 static ScmObj uvlib_s8vector_TOvector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 393 {
 394   ScmObj v_scm;
 395   ScmS8Vector* v;
 396   ScmObj start_scm;
 397   int start;
 398   ScmObj end_scm;
 399   int end;
 400   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
 401   SCM_ENTER_SUBR("s8vector->vector");
 402   if (Scm_Length(SCM_OPTARGS) > 2)
 403     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
 404   v_scm = SCM_ARGREF(0);
 405   if (!SCM_S8VECTORP(v_scm)) Scm_Error("<s8vector> required, but got %S", v_scm);
 406   v = SCM_S8VECTOR(v_scm);
 407   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
 408   else {
 409     start_scm = SCM_CAR(SCM_OPTARGS);
 410     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
 411   }
 412   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
 413   start = SCM_INT_VALUE(start_scm);
 414   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
 415   else {
 416     end_scm = SCM_CAR(SCM_OPTARGS);
 417     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
 418   }
 419   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
 420   end = SCM_INT_VALUE(end_scm);
 421   {
 422 {
 423 ScmObj SCM_RESULT;
 424 SCM_RESULT = Scm_S8VectorToVector(v, start, end);
 425 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
 426 }
 427   }
 428 }
 429 
 430 static SCM_DEFINE_STRING_CONST(uvlib_s8vector_TOvector__NAME, "s8vector->vector", 16, 16);
 431 static SCM_DEFINE_SUBR(uvlib_s8vector_TOvector__STUB, 1, 1, SCM_OBJ(&uvlib_s8vector_TOvector__NAME), uvlib_s8vector_TOvector, NULL, NULL);
 432 
 433 static ScmObj uvlib_vector_TOs8vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 434 {
 435   ScmObj v_scm;
 436   ScmVector* v;
 437   ScmObj start_scm;
 438   int start;
 439   ScmObj end_scm;
 440   int end;
 441   ScmObj clamp_scm;
 442   ScmObj clamp;
 443   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
 444   SCM_ENTER_SUBR("vector->s8vector");
 445   if (Scm_Length(SCM_OPTARGS) > 3)
 446     Scm_Error("too many arguments: up to 3 is expected, %d given.", Scm_Length(SCM_OPTARGS));
 447   v_scm = SCM_ARGREF(0);
 448   if (!SCM_VECTORP(v_scm)) Scm_Error("vector required, but got %S", v_scm);
 449   v = SCM_VECTOR(v_scm);
 450   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
 451   else {
 452     start_scm = SCM_CAR(SCM_OPTARGS);
 453     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
 454   }
 455   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
 456   start = SCM_INT_VALUE(start_scm);
 457   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
 458   else {
 459     end_scm = SCM_CAR(SCM_OPTARGS);
 460     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
 461   }
 462   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
 463   end = SCM_INT_VALUE(end_scm);
 464   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
 465   else {
 466     clamp_scm = SCM_CAR(SCM_OPTARGS);
 467     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
 468   }
 469   clamp = (clamp_scm);
 470   {
 471 SCM_RETURN(Scm_VectorToS8Vector(v, start, end, clamp_arg(clamp)));
 472   }
 473 }
 474 
 475 static SCM_DEFINE_STRING_CONST(uvlib_vector_TOs8vector__NAME, "vector->s8vector", 16, 16);
 476 static SCM_DEFINE_SUBR(uvlib_vector_TOs8vector__STUB, 1, 1, SCM_OBJ(&uvlib_vector_TOs8vector__NAME), uvlib_vector_TOs8vector, NULL, NULL);
 477 
 478 static ScmObj uvlib_u8vectorP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 479 {
 480   ScmObj obj_scm;
 481   ScmObj obj;
 482   SCM_ENTER_SUBR("u8vector?");
 483   obj_scm = SCM_ARGREF(0);
 484   obj = (obj_scm);
 485   {
 486 {
 487 int SCM_RESULT;
 488 SCM_RESULT = SCM_U8VECTORP(obj);
 489 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
 490 }
 491   }
 492 }
 493 
 494 static SCM_DEFINE_STRING_CONST(uvlib_u8vectorP__NAME, "u8vector?", 9, 9);
 495 static SCM_DEFINE_SUBR(uvlib_u8vectorP__STUB, 1, 0, SCM_OBJ(&uvlib_u8vectorP__NAME), uvlib_u8vectorP, NULL, NULL);
 496 
 497 static ScmObj uvlib_make_u8vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 498 {
 499   ScmObj length_scm;
 500   int length;
 501   ScmObj fill_scm;
 502   ScmObj fill;
 503   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
 504   SCM_ENTER_SUBR("make-u8vector");
 505   if (Scm_Length(SCM_OPTARGS) > 1)
 506     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
 507   length_scm = SCM_ARGREF(0);
 508   if (!SCM_INTP(length_scm)) Scm_Error("small integer required, but got %S", length_scm);
 509   length = SCM_INT_VALUE(length_scm);
 510   if (SCM_NULLP(SCM_OPTARGS)) fill_scm = Scm_MakeInteger(0);
 511   else {
 512     fill_scm = SCM_CAR(SCM_OPTARGS);
 513     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
 514   }
 515   fill = (fill_scm);
 516   {
 517 unsigned char filler;
 518   filler = u8unbox(fill, SCM_CLAMP_ERROR);
 519   SCM_RETURN(Scm_MakeU8Vector(length, filler));
 520   }
 521 }
 522 
 523 static SCM_DEFINE_STRING_CONST(uvlib_make_u8vector__NAME, "make-u8vector", 13, 13);
 524 static SCM_DEFINE_SUBR(uvlib_make_u8vector__STUB, 1, 1, SCM_OBJ(&uvlib_make_u8vector__NAME), uvlib_make_u8vector, NULL, NULL);
 525 
 526 static ScmObj uvlib_u8vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 527 {
 528   ScmObj args_scm;
 529   ScmObj args;
 530   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
 531   SCM_ENTER_SUBR("u8vector");
 532   args_scm = SCM_OPTARGS;
 533   args = (args_scm);
 534   {
 535 SCM_RETURN(Scm_ListToU8Vector(args, SCM_CLAMP_ERROR));
 536   }
 537 }
 538 
 539 static SCM_DEFINE_STRING_CONST(uvlib_u8vector__NAME, "u8vector", 8, 8);
 540 static SCM_DEFINE_SUBR(uvlib_u8vector__STUB, 0, 1, SCM_OBJ(&uvlib_u8vector__NAME), uvlib_u8vector, NULL, NULL);
 541 
 542 static ScmObj uvlib_u8vector_length(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 543 {
 544   ScmObj v_scm;
 545   ScmU8Vector* v;
 546   SCM_ENTER_SUBR("u8vector-length");
 547   v_scm = SCM_ARGREF(0);
 548   if (!SCM_U8VECTORP(v_scm)) Scm_Error("<u8vector> required, but got %S", v_scm);
 549   v = SCM_U8VECTOR(v_scm);
 550   {
 551 SCM_RETURN(SCM_MAKE_INT(SCM_U8VECTOR_SIZE(v)));
 552   }
 553 }
 554 
 555 static SCM_DEFINE_STRING_CONST(uvlib_u8vector_length__NAME, "u8vector-length", 15, 15);
 556 static SCM_DEFINE_SUBR(uvlib_u8vector_length__STUB, 1, 0, SCM_OBJ(&uvlib_u8vector_length__NAME), uvlib_u8vector_length, NULL, NULL);
 557 
 558 static ScmObj uvlib_u8vector_ref(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 559 {
 560   ScmObj v_scm;
 561   ScmU8Vector* v;
 562   ScmObj i_scm;
 563   int i;
 564   ScmObj fallback_scm;
 565   ScmObj fallback;
 566   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
 567   SCM_ENTER_SUBR("u8vector-ref");
 568   if (Scm_Length(SCM_OPTARGS) > 1)
 569     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
 570   v_scm = SCM_ARGREF(0);
 571   if (!SCM_U8VECTORP(v_scm)) Scm_Error("<u8vector> required, but got %S", v_scm);
 572   v = SCM_U8VECTOR(v_scm);
 573   i_scm = SCM_ARGREF(1);
 574   if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
 575   i = SCM_INT_VALUE(i_scm);
 576   if (SCM_NULLP(SCM_OPTARGS)) fallback_scm = SCM_UNBOUND;
 577   else {
 578     fallback_scm = SCM_CAR(SCM_OPTARGS);
 579     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
 580   }
 581   fallback = (fallback_scm);
 582   {
 583 SCM_RETURN(Scm_U8VectorRef(v, i, fallback));
 584   }
 585 }
 586 
 587 static SCM_DEFINE_STRING_CONST(uvlib_u8vector_ref__NAME, "u8vector-ref", 12, 12);
 588 static SCM_DEFINE_SUBR(uvlib_u8vector_ref__STUB, 2, 1, SCM_OBJ(&uvlib_u8vector_ref__NAME), uvlib_u8vector_ref, NULL, NULL);
 589 
 590 static ScmObj uvlib_u8vector_setX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 591 {
 592   ScmObj v_scm;
 593   ScmU8Vector* v;
 594   ScmObj i_scm;
 595   int i;
 596   ScmObj val_scm;
 597   ScmObj val;
 598   ScmObj clamp_scm;
 599   ScmObj clamp;
 600   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
 601   SCM_ENTER_SUBR("u8vector-set!");
 602   if (Scm_Length(SCM_OPTARGS) > 1)
 603     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
 604   v_scm = SCM_ARGREF(0);
 605   if (!SCM_U8VECTORP(v_scm)) Scm_Error("<u8vector> required, but got %S", v_scm);
 606   v = SCM_U8VECTOR(v_scm);
 607   i_scm = SCM_ARGREF(1);
 608   if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
 609   i = SCM_INT_VALUE(i_scm);
 610   val_scm = SCM_ARGREF(2);
 611   val = (val_scm);
 612   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
 613   else {
 614     clamp_scm = SCM_CAR(SCM_OPTARGS);
 615     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
 616   }
 617   clamp = (clamp_scm);
 618   {
 619 SCM_RETURN(Scm_U8VectorSet(v, i, val, clamp_arg(clamp)));
 620   }
 621 }
 622 
 623 static SCM_DEFINE_STRING_CONST(uvlib_u8vector_setX__NAME, "u8vector-set!", 13, 13);
 624 static SCM_DEFINE_SUBR(uvlib_u8vector_setX__STUB, 3, 1, SCM_OBJ(&uvlib_u8vector_setX__NAME), uvlib_u8vector_setX, NULL, NULL);
 625 
 626 static ScmObj uvlib_u8vector_copy(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 627 {
 628   ScmObj v_scm;
 629   ScmU8Vector* v;
 630   ScmObj start_scm;
 631   int start;
 632   ScmObj end_scm;
 633   int end;
 634   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
 635   SCM_ENTER_SUBR("u8vector-copy");
 636   if (Scm_Length(SCM_OPTARGS) > 2)
 637     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
 638   v_scm = SCM_ARGREF(0);
 639   if (!SCM_U8VECTORP(v_scm)) Scm_Error("<u8vector> required, but got %S", v_scm);
 640   v = SCM_U8VECTOR(v_scm);
 641   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
 642   else {
 643     start_scm = SCM_CAR(SCM_OPTARGS);
 644     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
 645   }
 646   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
 647   start = SCM_INT_VALUE(start_scm);
 648   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
 649   else {
 650     end_scm = SCM_CAR(SCM_OPTARGS);
 651     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
 652   }
 653   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
 654   end = SCM_INT_VALUE(end_scm);
 655   {
 656 {
 657 ScmObj SCM_RESULT;
 658 SCM_RESULT = Scm_U8VectorCopy(v, start, end);
 659 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
 660 }
 661   }
 662 }
 663 
 664 static SCM_DEFINE_STRING_CONST(uvlib_u8vector_copy__NAME, "u8vector-copy", 13, 13);
 665 static SCM_DEFINE_SUBR(uvlib_u8vector_copy__STUB, 1, 1, SCM_OBJ(&uvlib_u8vector_copy__NAME), uvlib_u8vector_copy, NULL, NULL);
 666 
 667 static ScmObj uvlib_u8vector_copyX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 668 {
 669   ScmObj dst_scm;
 670   ScmU8Vector* dst;
 671   ScmObj dstart_scm;
 672   ScmObj dstart;
 673   ScmObj src_scm;
 674   ScmObj src;
 675   ScmObj sstart_scm;
 676   int sstart;
 677   ScmObj send_scm;
 678   int send;
 679   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
 680   SCM_ENTER_SUBR("u8vector-copy!");
 681   if (Scm_Length(SCM_OPTARGS) > 3)
 682     Scm_Error("too many arguments: up to 3 is expected, %d given.", Scm_Length(SCM_OPTARGS));
 683   dst_scm = SCM_ARGREF(0);
 684   if (!SCM_U8VECTORP(dst_scm)) Scm_Error("<u8vector> required, but got %S", dst_scm);
 685   dst = SCM_U8VECTOR(dst_scm);
 686   dstart_scm = SCM_ARGREF(1);
 687   dstart = (dstart_scm);
 688   if (SCM_NULLP(SCM_OPTARGS)) src_scm = SCM_UNBOUND;
 689   else {
 690     src_scm = SCM_CAR(SCM_OPTARGS);
 691     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
 692   }
 693   src = (src_scm);
 694   if (SCM_NULLP(SCM_OPTARGS)) sstart_scm = Scm_MakeInteger(0);
 695   else {
 696     sstart_scm = SCM_CAR(SCM_OPTARGS);
 697     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
 698   }
 699   if (!SCM_EXACTP(sstart_scm)) Scm_Error("C integer required, but got %S", sstart_scm);
 700   sstart = Scm_GetInteger(sstart_scm);
 701   if (SCM_NULLP(SCM_OPTARGS)) send_scm = Scm_MakeInteger(-1);
 702   else {
 703     send_scm = SCM_CAR(SCM_OPTARGS);
 704     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
 705   }
 706   if (!SCM_EXACTP(send_scm)) Scm_Error("C integer required, but got %S", send_scm);
 707   send = Scm_GetInteger(send_scm);
 708   {
 709 if (SCM_INTEGERP(dstart)) {
 710      /* new API */
 711      if (!SCM_U8VECTORP(src)) {
 712        Scm_Error("u8vector-copy!: argument is not a matching uvector: %S",
 713                  src);
 714      }
 715      SCM_RETURN(Scm_U8VectorCopyX(dst, Scm_GetInteger(dstart), 
 716                                     SCM_U8VECTOR(src), sstart, send));
 717   } else if (SCM_U8VECTORP(dstart)) {
 718     /* old API */
 719     SCM_RETURN(Scm_U8VectorCopyX(dst, 0, SCM_U8VECTOR(dstart), 0, -1));
 720   } else {
 721     Scm_Error("integer required, but got %S", dstart);
 722     SCM_RETURN(SCM_UNDEFINED);
 723   }
 724   }
 725 }
 726 
 727 static SCM_DEFINE_STRING_CONST(uvlib_u8vector_copyX__NAME, "u8vector-copy!", 14, 14);
 728 static SCM_DEFINE_SUBR(uvlib_u8vector_copyX__STUB, 2, 1, SCM_OBJ(&uvlib_u8vector_copyX__NAME), uvlib_u8vector_copyX, NULL, NULL);
 729 
 730 static ScmObj uvlib_u8vector_TOlist(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 731 {
 732   ScmObj v_scm;
 733   ScmU8Vector* v;
 734   ScmObj start_scm;
 735   int start;
 736   ScmObj end_scm;
 737   int end;
 738   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
 739   SCM_ENTER_SUBR("u8vector->list");
 740   if (Scm_Length(SCM_OPTARGS) > 2)
 741     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
 742   v_scm = SCM_ARGREF(0);
 743   if (!SCM_U8VECTORP(v_scm)) Scm_Error("<u8vector> required, but got %S", v_scm);
 744   v = SCM_U8VECTOR(v_scm);
 745   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
 746   else {
 747     start_scm = SCM_CAR(SCM_OPTARGS);
 748     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
 749   }
 750   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
 751   start = SCM_INT_VALUE(start_scm);
 752   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
 753   else {
 754     end_scm = SCM_CAR(SCM_OPTARGS);
 755     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
 756   }
 757   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
 758   end = SCM_INT_VALUE(end_scm);
 759   {
 760 {
 761 ScmObj SCM_RESULT;
 762 SCM_RESULT = Scm_U8VectorToList(v, start, end);
 763 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
 764 }
 765   }
 766 }
 767 
 768 static SCM_DEFINE_STRING_CONST(uvlib_u8vector_TOlist__NAME, "u8vector->list", 14, 14);
 769 static SCM_DEFINE_SUBR(uvlib_u8vector_TOlist__STUB, 1, 1, SCM_OBJ(&uvlib_u8vector_TOlist__NAME), uvlib_u8vector_TOlist, NULL, NULL);
 770 
 771 static ScmObj uvlib_list_TOu8vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 772 {
 773   ScmObj l_scm;
 774   ScmObj l;
 775   ScmObj clamp_scm;
 776   ScmObj clamp;
 777   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
 778   SCM_ENTER_SUBR("list->u8vector");
 779   if (Scm_Length(SCM_OPTARGS) > 1)
 780     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
 781   l_scm = SCM_ARGREF(0);
 782   if (!SCM_LISTP(l_scm)) Scm_Error("list required, but got %S", l_scm);
 783   l = (l_scm);
 784   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
 785   else {
 786     clamp_scm = SCM_CAR(SCM_OPTARGS);
 787     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
 788   }
 789   clamp = (clamp_scm);
 790   {
 791 SCM_RETURN(Scm_ListToU8Vector(l, clamp_arg(clamp)));
 792   }
 793 }
 794 
 795 static SCM_DEFINE_STRING_CONST(uvlib_list_TOu8vector__NAME, "list->u8vector", 14, 14);
 796 static SCM_DEFINE_SUBR(uvlib_list_TOu8vector__STUB, 1, 1, SCM_OBJ(&uvlib_list_TOu8vector__NAME), uvlib_list_TOu8vector, NULL, NULL);
 797 
 798 static ScmObj uvlib_u8vector_fillX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 799 {
 800   ScmObj v_scm;
 801   ScmU8Vector* v;
 802   ScmObj val_scm;
 803   ScmObj val;
 804   ScmObj start_scm;
 805   int start;
 806   ScmObj end_scm;
 807   int end;
 808   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
 809   SCM_ENTER_SUBR("u8vector-fill!");
 810   if (Scm_Length(SCM_OPTARGS) > 2)
 811     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
 812   v_scm = SCM_ARGREF(0);
 813   if (!SCM_U8VECTORP(v_scm)) Scm_Error("<u8vector> required, but got %S", v_scm);
 814   v = SCM_U8VECTOR(v_scm);
 815   val_scm = SCM_ARGREF(1);
 816   val = (val_scm);
 817   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
 818   else {
 819     start_scm = SCM_CAR(SCM_OPTARGS);
 820     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
 821   }
 822   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
 823   start = SCM_INT_VALUE(start_scm);
 824   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
 825   else {
 826     end_scm = SCM_CAR(SCM_OPTARGS);
 827     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
 828   }
 829   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
 830   end = SCM_INT_VALUE(end_scm);
 831   {
 832 unsigned char filler;
 833   filler = u8unbox(val, SCM_CLAMP_ERROR);
 834   SCM_RETURN(Scm_U8VectorFill(v, filler, start, end));
 835   }
 836 }
 837 
 838 static SCM_DEFINE_STRING_CONST(uvlib_u8vector_fillX__NAME, "u8vector-fill!", 14, 14);
 839 static SCM_DEFINE_SUBR(uvlib_u8vector_fillX__STUB, 2, 1, SCM_OBJ(&uvlib_u8vector_fillX__NAME), uvlib_u8vector_fillX, NULL, NULL);
 840 
 841 static ScmObj uvlib_u8vector_TOvector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 842 {
 843   ScmObj v_scm;
 844   ScmU8Vector* v;
 845   ScmObj start_scm;
 846   int start;
 847   ScmObj end_scm;
 848   int end;
 849   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
 850   SCM_ENTER_SUBR("u8vector->vector");
 851   if (Scm_Length(SCM_OPTARGS) > 2)
 852     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
 853   v_scm = SCM_ARGREF(0);
 854   if (!SCM_U8VECTORP(v_scm)) Scm_Error("<u8vector> required, but got %S", v_scm);
 855   v = SCM_U8VECTOR(v_scm);
 856   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
 857   else {
 858     start_scm = SCM_CAR(SCM_OPTARGS);
 859     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
 860   }
 861   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
 862   start = SCM_INT_VALUE(start_scm);
 863   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
 864   else {
 865     end_scm = SCM_CAR(SCM_OPTARGS);
 866     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
 867   }
 868   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
 869   end = SCM_INT_VALUE(end_scm);
 870   {
 871 {
 872 ScmObj SCM_RESULT;
 873 SCM_RESULT = Scm_U8VectorToVector(v, start, end);
 874 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
 875 }
 876   }
 877 }
 878 
 879 static SCM_DEFINE_STRING_CONST(uvlib_u8vector_TOvector__NAME, "u8vector->vector", 16, 16);
 880 static SCM_DEFINE_SUBR(uvlib_u8vector_TOvector__STUB, 1, 1, SCM_OBJ(&uvlib_u8vector_TOvector__NAME), uvlib_u8vector_TOvector, NULL, NULL);
 881 
 882 static ScmObj uvlib_vector_TOu8vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 883 {
 884   ScmObj v_scm;
 885   ScmVector* v;
 886   ScmObj start_scm;
 887   int start;
 888   ScmObj end_scm;
 889   int end;
 890   ScmObj clamp_scm;
 891   ScmObj clamp;
 892   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
 893   SCM_ENTER_SUBR("vector->u8vector");
 894   if (Scm_Length(SCM_OPTARGS) > 3)
 895     Scm_Error("too many arguments: up to 3 is expected, %d given.", Scm_Length(SCM_OPTARGS));
 896   v_scm = SCM_ARGREF(0);
 897   if (!SCM_VECTORP(v_scm)) Scm_Error("vector required, but got %S", v_scm);
 898   v = SCM_VECTOR(v_scm);
 899   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
 900   else {
 901     start_scm = SCM_CAR(SCM_OPTARGS);
 902     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
 903   }
 904   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
 905   start = SCM_INT_VALUE(start_scm);
 906   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
 907   else {
 908     end_scm = SCM_CAR(SCM_OPTARGS);
 909     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
 910   }
 911   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
 912   end = SCM_INT_VALUE(end_scm);
 913   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
 914   else {
 915     clamp_scm = SCM_CAR(SCM_OPTARGS);
 916     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
 917   }
 918   clamp = (clamp_scm);
 919   {
 920 SCM_RETURN(Scm_VectorToU8Vector(v, start, end, clamp_arg(clamp)));
 921   }
 922 }
 923 
 924 static SCM_DEFINE_STRING_CONST(uvlib_vector_TOu8vector__NAME, "vector->u8vector", 16, 16);
 925 static SCM_DEFINE_SUBR(uvlib_vector_TOu8vector__STUB, 1, 1, SCM_OBJ(&uvlib_vector_TOu8vector__NAME), uvlib_vector_TOu8vector, NULL, NULL);
 926 
 927 static ScmObj uvlib_s16vectorP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 928 {
 929   ScmObj obj_scm;
 930   ScmObj obj;
 931   SCM_ENTER_SUBR("s16vector?");
 932   obj_scm = SCM_ARGREF(0);
 933   obj = (obj_scm);
 934   {
 935 {
 936 int SCM_RESULT;
 937 SCM_RESULT = SCM_S16VECTORP(obj);
 938 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
 939 }
 940   }
 941 }
 942 
 943 static SCM_DEFINE_STRING_CONST(uvlib_s16vectorP__NAME, "s16vector?", 10, 10);
 944 static SCM_DEFINE_SUBR(uvlib_s16vectorP__STUB, 1, 0, SCM_OBJ(&uvlib_s16vectorP__NAME), uvlib_s16vectorP, NULL, NULL);
 945 
 946 static ScmObj uvlib_make_s16vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 947 {
 948   ScmObj length_scm;
 949   int length;
 950   ScmObj fill_scm;
 951   ScmObj fill;
 952   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
 953   SCM_ENTER_SUBR("make-s16vector");
 954   if (Scm_Length(SCM_OPTARGS) > 1)
 955     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
 956   length_scm = SCM_ARGREF(0);
 957   if (!SCM_INTP(length_scm)) Scm_Error("small integer required, but got %S", length_scm);
 958   length = SCM_INT_VALUE(length_scm);
 959   if (SCM_NULLP(SCM_OPTARGS)) fill_scm = Scm_MakeInteger(0);
 960   else {
 961     fill_scm = SCM_CAR(SCM_OPTARGS);
 962     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
 963   }
 964   fill = (fill_scm);
 965   {
 966 short filler;
 967   filler = s16unbox(fill, SCM_CLAMP_ERROR);
 968   SCM_RETURN(Scm_MakeS16Vector(length, filler));
 969   }
 970 }
 971 
 972 static SCM_DEFINE_STRING_CONST(uvlib_make_s16vector__NAME, "make-s16vector", 14, 14);
 973 static SCM_DEFINE_SUBR(uvlib_make_s16vector__STUB, 1, 1, SCM_OBJ(&uvlib_make_s16vector__NAME), uvlib_make_s16vector, NULL, NULL);
 974 
 975 static ScmObj uvlib_s16vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 976 {
 977   ScmObj args_scm;
 978   ScmObj args;
 979   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
 980   SCM_ENTER_SUBR("s16vector");
 981   args_scm = SCM_OPTARGS;
 982   args = (args_scm);
 983   {
 984 SCM_RETURN(Scm_ListToS16Vector(args, SCM_CLAMP_ERROR));
 985   }
 986 }
 987 
 988 static SCM_DEFINE_STRING_CONST(uvlib_s16vector__NAME, "s16vector", 9, 9);
 989 static SCM_DEFINE_SUBR(uvlib_s16vector__STUB, 0, 1, SCM_OBJ(&uvlib_s16vector__NAME), uvlib_s16vector, NULL, NULL);
 990 
 991 static ScmObj uvlib_s16vector_length(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 992 {
 993   ScmObj v_scm;
 994   ScmS16Vector* v;
 995   SCM_ENTER_SUBR("s16vector-length");
 996   v_scm = SCM_ARGREF(0);
 997   if (!SCM_S16VECTORP(v_scm)) Scm_Error("<s16vector> required, but got %S", v_scm);
 998   v = SCM_S16VECTOR(v_scm);
 999   {
1000 SCM_RETURN(SCM_MAKE_INT(SCM_S16VECTOR_SIZE(v)));
1001   }
1002 }
1003 
1004 static SCM_DEFINE_STRING_CONST(uvlib_s16vector_length__NAME, "s16vector-length", 16, 16);
1005 static SCM_DEFINE_SUBR(uvlib_s16vector_length__STUB, 1, 0, SCM_OBJ(&uvlib_s16vector_length__NAME), uvlib_s16vector_length, NULL, NULL);
1006 
1007 static ScmObj uvlib_s16vector_ref(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1008 {
1009   ScmObj v_scm;
1010   ScmS16Vector* v;
1011   ScmObj i_scm;
1012   int i;
1013   ScmObj fallback_scm;
1014   ScmObj fallback;
1015   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
1016   SCM_ENTER_SUBR("s16vector-ref");
1017   if (Scm_Length(SCM_OPTARGS) > 1)
1018     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
1019   v_scm = SCM_ARGREF(0);
1020   if (!SCM_S16VECTORP(v_scm)) Scm_Error("<s16vector> required, but got %S", v_scm);
1021   v = SCM_S16VECTOR(v_scm);
1022   i_scm = SCM_ARGREF(1);
1023   if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
1024   i = SCM_INT_VALUE(i_scm);
1025   if (SCM_NULLP(SCM_OPTARGS)) fallback_scm = SCM_UNBOUND;
1026   else {
1027     fallback_scm = SCM_CAR(SCM_OPTARGS);
1028     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1029   }
1030   fallback = (fallback_scm);
1031   {
1032 SCM_RETURN(Scm_S16VectorRef(v, i, fallback));
1033   }
1034 }
1035 
1036 static SCM_DEFINE_STRING_CONST(uvlib_s16vector_ref__NAME, "s16vector-ref", 13, 13);
1037 static SCM_DEFINE_SUBR(uvlib_s16vector_ref__STUB, 2, 1, SCM_OBJ(&uvlib_s16vector_ref__NAME), uvlib_s16vector_ref, NULL, NULL);
1038 
1039 static ScmObj uvlib_s16vector_setX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1040 {
1041   ScmObj v_scm;
1042   ScmS16Vector* v;
1043   ScmObj i_scm;
1044   int i;
1045   ScmObj val_scm;
1046   ScmObj val;
1047   ScmObj clamp_scm;
1048   ScmObj clamp;
1049   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
1050   SCM_ENTER_SUBR("s16vector-set!");
1051   if (Scm_Length(SCM_OPTARGS) > 1)
1052     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
1053   v_scm = SCM_ARGREF(0);
1054   if (!SCM_S16VECTORP(v_scm)) Scm_Error("<s16vector> required, but got %S", v_scm);
1055   v = SCM_S16VECTOR(v_scm);
1056   i_scm = SCM_ARGREF(1);
1057   if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
1058   i = SCM_INT_VALUE(i_scm);
1059   val_scm = SCM_ARGREF(2);
1060   val = (val_scm);
1061   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
1062   else {
1063     clamp_scm = SCM_CAR(SCM_OPTARGS);
1064     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1065   }
1066   clamp = (clamp_scm);
1067   {
1068 SCM_RETURN(Scm_S16VectorSet(v, i, val, clamp_arg(clamp)));
1069   }
1070 }
1071 
1072 static SCM_DEFINE_STRING_CONST(uvlib_s16vector_setX__NAME, "s16vector-set!", 14, 14);
1073 static SCM_DEFINE_SUBR(uvlib_s16vector_setX__STUB, 3, 1, SCM_OBJ(&uvlib_s16vector_setX__NAME), uvlib_s16vector_setX, NULL, NULL);
1074 
1075 static ScmObj uvlib_s16vector_copy(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1076 {
1077   ScmObj v_scm;
1078   ScmS16Vector* v;
1079   ScmObj start_scm;
1080   int start;
1081   ScmObj end_scm;
1082   int end;
1083   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
1084   SCM_ENTER_SUBR("s16vector-copy");
1085   if (Scm_Length(SCM_OPTARGS) > 2)
1086     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
1087   v_scm = SCM_ARGREF(0);
1088   if (!SCM_S16VECTORP(v_scm)) Scm_Error("<s16vector> required, but got %S", v_scm);
1089   v = SCM_S16VECTOR(v_scm);
1090   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
1091   else {
1092     start_scm = SCM_CAR(SCM_OPTARGS);
1093     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1094   }
1095   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
1096   start = SCM_INT_VALUE(start_scm);
1097   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
1098   else {
1099     end_scm = SCM_CAR(SCM_OPTARGS);
1100     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1101   }
1102   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
1103   end = SCM_INT_VALUE(end_scm);
1104   {
1105 {
1106 ScmObj SCM_RESULT;
1107 SCM_RESULT = Scm_S16VectorCopy(v, start, end);
1108 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
1109 }
1110   }
1111 }
1112 
1113 static SCM_DEFINE_STRING_CONST(uvlib_s16vector_copy__NAME, "s16vector-copy", 14, 14);
1114 static SCM_DEFINE_SUBR(uvlib_s16vector_copy__STUB, 1, 1, SCM_OBJ(&uvlib_s16vector_copy__NAME), uvlib_s16vector_copy, NULL, NULL);
1115 
1116 static ScmObj uvlib_s16vector_copyX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1117 {
1118   ScmObj dst_scm;
1119   ScmS16Vector* dst;
1120   ScmObj dstart_scm;
1121   ScmObj dstart;
1122   ScmObj src_scm;
1123   ScmObj src;
1124   ScmObj sstart_scm;
1125   int sstart;
1126   ScmObj send_scm;
1127   int send;
1128   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
1129   SCM_ENTER_SUBR("s16vector-copy!");
1130   if (Scm_Length(SCM_OPTARGS) > 3)
1131     Scm_Error("too many arguments: up to 3 is expected, %d given.", Scm_Length(SCM_OPTARGS));
1132   dst_scm = SCM_ARGREF(0);
1133   if (!SCM_S16VECTORP(dst_scm)) Scm_Error("<s16vector> required, but got %S", dst_scm);
1134   dst = SCM_S16VECTOR(dst_scm);
1135   dstart_scm = SCM_ARGREF(1);
1136   dstart = (dstart_scm);
1137   if (SCM_NULLP(SCM_OPTARGS)) src_scm = SCM_UNBOUND;
1138   else {
1139     src_scm = SCM_CAR(SCM_OPTARGS);
1140     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1141   }
1142   src = (src_scm);
1143   if (SCM_NULLP(SCM_OPTARGS)) sstart_scm = Scm_MakeInteger(0);
1144   else {
1145     sstart_scm = SCM_CAR(SCM_OPTARGS);
1146     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1147   }
1148   if (!SCM_EXACTP(sstart_scm)) Scm_Error("C integer required, but got %S", sstart_scm);
1149   sstart = Scm_GetInteger(sstart_scm);
1150   if (SCM_NULLP(SCM_OPTARGS)) send_scm = Scm_MakeInteger(-1);
1151   else {
1152     send_scm = SCM_CAR(SCM_OPTARGS);
1153     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1154   }
1155   if (!SCM_EXACTP(send_scm)) Scm_Error("C integer required, but got %S", send_scm);
1156   send = Scm_GetInteger(send_scm);
1157   {
1158 if (SCM_INTEGERP(dstart)) {
1159      /* new API */
1160      if (!SCM_S16VECTORP(src)) {
1161        Scm_Error("s16vector-copy!: argument is not a matching uvector: %S",
1162                  src);
1163      }
1164      SCM_RETURN(Scm_S16VectorCopyX(dst, Scm_GetInteger(dstart), 
1165                                     SCM_S16VECTOR(src), sstart, send));
1166   } else if (SCM_S16VECTORP(dstart)) {
1167     /* old API */
1168     SCM_RETURN(Scm_S16VectorCopyX(dst, 0, SCM_S16VECTOR(dstart), 0, -1));
1169   } else {
1170     Scm_Error("integer required, but got %S", dstart);
1171     SCM_RETURN(SCM_UNDEFINED);
1172   }
1173   }
1174 }
1175 
1176 static SCM_DEFINE_STRING_CONST(uvlib_s16vector_copyX__NAME, "s16vector-copy!", 15, 15);
1177 static SCM_DEFINE_SUBR(uvlib_s16vector_copyX__STUB, 2, 1, SCM_OBJ(&uvlib_s16vector_copyX__NAME), uvlib_s16vector_copyX, NULL, NULL);
1178 
1179 static ScmObj uvlib_s16vector_TOlist(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1180 {
1181   ScmObj v_scm;
1182   ScmS16Vector* v;
1183   ScmObj start_scm;
1184   int start;
1185   ScmObj end_scm;
1186   int end;
1187   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
1188   SCM_ENTER_SUBR("s16vector->list");
1189   if (Scm_Length(SCM_OPTARGS) > 2)
1190     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
1191   v_scm = SCM_ARGREF(0);
1192   if (!SCM_S16VECTORP(v_scm)) Scm_Error("<s16vector> required, but got %S", v_scm);
1193   v = SCM_S16VECTOR(v_scm);
1194   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
1195   else {
1196     start_scm = SCM_CAR(SCM_OPTARGS);
1197     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1198   }
1199   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
1200   start = SCM_INT_VALUE(start_scm);
1201   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
1202   else {
1203     end_scm = SCM_CAR(SCM_OPTARGS);
1204     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1205   }
1206   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
1207   end = SCM_INT_VALUE(end_scm);
1208   {
1209 {
1210 ScmObj SCM_RESULT;
1211 SCM_RESULT = Scm_S16VectorToList(v, start, end);
1212 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
1213 }
1214   }
1215 }
1216 
1217 static SCM_DEFINE_STRING_CONST(uvlib_s16vector_TOlist__NAME, "s16vector->list", 15, 15);
1218 static SCM_DEFINE_SUBR(uvlib_s16vector_TOlist__STUB, 1, 1, SCM_OBJ(&uvlib_s16vector_TOlist__NAME), uvlib_s16vector_TOlist, NULL, NULL);
1219 
1220 static ScmObj uvlib_list_TOs16vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1221 {
1222   ScmObj l_scm;
1223   ScmObj l;
1224   ScmObj clamp_scm;
1225   ScmObj clamp;
1226   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
1227   SCM_ENTER_SUBR("list->s16vector");
1228   if (Scm_Length(SCM_OPTARGS) > 1)
1229     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
1230   l_scm = SCM_ARGREF(0);
1231   if (!SCM_LISTP(l_scm)) Scm_Error("list required, but got %S", l_scm);
1232   l = (l_scm);
1233   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
1234   else {
1235     clamp_scm = SCM_CAR(SCM_OPTARGS);
1236     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1237   }
1238   clamp = (clamp_scm);
1239   {
1240 SCM_RETURN(Scm_ListToS16Vector(l, clamp_arg(clamp)));
1241   }
1242 }
1243 
1244 static SCM_DEFINE_STRING_CONST(uvlib_list_TOs16vector__NAME, "list->s16vector", 15, 15);
1245 static SCM_DEFINE_SUBR(uvlib_list_TOs16vector__STUB, 1, 1, SCM_OBJ(&uvlib_list_TOs16vector__NAME), uvlib_list_TOs16vector, NULL, NULL);
1246 
1247 static ScmObj uvlib_s16vector_fillX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1248 {
1249   ScmObj v_scm;
1250   ScmS16Vector* v;
1251   ScmObj val_scm;
1252   ScmObj val;
1253   ScmObj start_scm;
1254   int start;
1255   ScmObj end_scm;
1256   int end;
1257   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
1258   SCM_ENTER_SUBR("s16vector-fill!");
1259   if (Scm_Length(SCM_OPTARGS) > 2)
1260     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
1261   v_scm = SCM_ARGREF(0);
1262   if (!SCM_S16VECTORP(v_scm)) Scm_Error("<s16vector> required, but got %S", v_scm);
1263   v = SCM_S16VECTOR(v_scm);
1264   val_scm = SCM_ARGREF(1);
1265   val = (val_scm);
1266   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
1267   else {
1268     start_scm = SCM_CAR(SCM_OPTARGS);
1269     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1270   }
1271   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
1272   start = SCM_INT_VALUE(start_scm);
1273   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
1274   else {
1275     end_scm = SCM_CAR(SCM_OPTARGS);
1276     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1277   }
1278   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
1279   end = SCM_INT_VALUE(end_scm);
1280   {
1281 short filler;
1282   filler = s16unbox(val, SCM_CLAMP_ERROR);
1283   SCM_RETURN(Scm_S16VectorFill(v, filler, start, end));
1284   }
1285 }
1286 
1287 static SCM_DEFINE_STRING_CONST(uvlib_s16vector_fillX__NAME, "s16vector-fill!", 15, 15);
1288 static SCM_DEFINE_SUBR(uvlib_s16vector_fillX__STUB, 2, 1, SCM_OBJ(&uvlib_s16vector_fillX__NAME), uvlib_s16vector_fillX, NULL, NULL);
1289 
1290 static ScmObj uvlib_s16vector_TOvector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1291 {
1292   ScmObj v_scm;
1293   ScmS16Vector* v;
1294   ScmObj start_scm;
1295   int start;
1296   ScmObj end_scm;
1297   int end;
1298   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
1299   SCM_ENTER_SUBR("s16vector->vector");
1300   if (Scm_Length(SCM_OPTARGS) > 2)
1301     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
1302   v_scm = SCM_ARGREF(0);
1303   if (!SCM_S16VECTORP(v_scm)) Scm_Error("<s16vector> required, but got %S", v_scm);
1304   v = SCM_S16VECTOR(v_scm);
1305   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
1306   else {
1307     start_scm = SCM_CAR(SCM_OPTARGS);
1308     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1309   }
1310   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
1311   start = SCM_INT_VALUE(start_scm);
1312   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
1313   else {
1314     end_scm = SCM_CAR(SCM_OPTARGS);
1315     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1316   }
1317   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
1318   end = SCM_INT_VALUE(end_scm);
1319   {
1320 {
1321 ScmObj SCM_RESULT;
1322 SCM_RESULT = Scm_S16VectorToVector(v, start, end);
1323 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
1324 }
1325   }
1326 }
1327 
1328 static SCM_DEFINE_STRING_CONST(uvlib_s16vector_TOvector__NAME, "s16vector->vector", 17, 17);
1329 static SCM_DEFINE_SUBR(uvlib_s16vector_TOvector__STUB, 1, 1, SCM_OBJ(&uvlib_s16vector_TOvector__NAME), uvlib_s16vector_TOvector, NULL, NULL);
1330 
1331 static ScmObj uvlib_vector_TOs16vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1332 {
1333   ScmObj v_scm;
1334   ScmVector* v;
1335   ScmObj start_scm;
1336   int start;
1337   ScmObj end_scm;
1338   int end;
1339   ScmObj clamp_scm;
1340   ScmObj clamp;
1341   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
1342   SCM_ENTER_SUBR("vector->s16vector");
1343   if (Scm_Length(SCM_OPTARGS) > 3)
1344     Scm_Error("too many arguments: up to 3 is expected, %d given.", Scm_Length(SCM_OPTARGS));
1345   v_scm = SCM_ARGREF(0);
1346   if (!SCM_VECTORP(v_scm)) Scm_Error("vector required, but got %S", v_scm);
1347   v = SCM_VECTOR(v_scm);
1348   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
1349   else {
1350     start_scm = SCM_CAR(SCM_OPTARGS);
1351     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1352   }
1353   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
1354   start = SCM_INT_VALUE(start_scm);
1355   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
1356   else {
1357     end_scm = SCM_CAR(SCM_OPTARGS);
1358     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1359   }
1360   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
1361   end = SCM_INT_VALUE(end_scm);
1362   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
1363   else {
1364     clamp_scm = SCM_CAR(SCM_OPTARGS);
1365     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1366   }
1367   clamp = (clamp_scm);
1368   {
1369 SCM_RETURN(Scm_VectorToS16Vector(v, start, end, clamp_arg(clamp)));
1370   }
1371 }
1372 
1373 static SCM_DEFINE_STRING_CONST(uvlib_vector_TOs16vector__NAME, "vector->s16vector", 17, 17);
1374 static SCM_DEFINE_SUBR(uvlib_vector_TOs16vector__STUB, 1, 1, SCM_OBJ(&uvlib_vector_TOs16vector__NAME), uvlib_vector_TOs16vector, NULL, NULL);
1375 
1376 static ScmObj uvlib_u16vectorP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1377 {
1378   ScmObj obj_scm;
1379   ScmObj obj;
1380   SCM_ENTER_SUBR("u16vector?");
1381   obj_scm = SCM_ARGREF(0);
1382   obj = (obj_scm);
1383   {
1384 {
1385 int SCM_RESULT;
1386 SCM_RESULT = SCM_U16VECTORP(obj);
1387 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
1388 }
1389   }
1390 }
1391 
1392 static SCM_DEFINE_STRING_CONST(uvlib_u16vectorP__NAME, "u16vector?", 10, 10);
1393 static SCM_DEFINE_SUBR(uvlib_u16vectorP__STUB, 1, 0, SCM_OBJ(&uvlib_u16vectorP__NAME), uvlib_u16vectorP, NULL, NULL);
1394 
1395 static ScmObj uvlib_make_u16vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1396 {
1397   ScmObj length_scm;
1398   int length;
1399   ScmObj fill_scm;
1400   ScmObj fill;
1401   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
1402   SCM_ENTER_SUBR("make-u16vector");
1403   if (Scm_Length(SCM_OPTARGS) > 1)
1404     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
1405   length_scm = SCM_ARGREF(0);
1406   if (!SCM_INTP(length_scm)) Scm_Error("small integer required, but got %S", length_scm);
1407   length = SCM_INT_VALUE(length_scm);
1408   if (SCM_NULLP(SCM_OPTARGS)) fill_scm = Scm_MakeInteger(0);
1409   else {
1410     fill_scm = SCM_CAR(SCM_OPTARGS);
1411     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1412   }
1413   fill = (fill_scm);
1414   {
1415 unsigned short filler;
1416   filler = u16unbox(fill, SCM_CLAMP_ERROR);
1417   SCM_RETURN(Scm_MakeU16Vector(length, filler));
1418   }
1419 }
1420 
1421 static SCM_DEFINE_STRING_CONST(uvlib_make_u16vector__NAME, "make-u16vector", 14, 14);
1422 static SCM_DEFINE_SUBR(uvlib_make_u16vector__STUB, 1, 1, SCM_OBJ(&uvlib_make_u16vector__NAME), uvlib_make_u16vector, NULL, NULL);
1423 
1424 static ScmObj uvlib_u16vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1425 {
1426   ScmObj args_scm;
1427   ScmObj args;
1428   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
1429   SCM_ENTER_SUBR("u16vector");
1430   args_scm = SCM_OPTARGS;
1431   args = (args_scm);
1432   {
1433 SCM_RETURN(Scm_ListToU16Vector(args, SCM_CLAMP_ERROR));
1434   }
1435 }
1436 
1437 static SCM_DEFINE_STRING_CONST(uvlib_u16vector__NAME, "u16vector", 9, 9);
1438 static SCM_DEFINE_SUBR(uvlib_u16vector__STUB, 0, 1, SCM_OBJ(&uvlib_u16vector__NAME), uvlib_u16vector, NULL, NULL);
1439 
1440 static ScmObj uvlib_u16vector_length(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1441 {
1442   ScmObj v_scm;
1443   ScmU16Vector* v;
1444   SCM_ENTER_SUBR("u16vector-length");
1445   v_scm = SCM_ARGREF(0);
1446   if (!SCM_U16VECTORP(v_scm)) Scm_Error("<u16vector> required, but got %S", v_scm);
1447   v = SCM_U16VECTOR(v_scm);
1448   {
1449 SCM_RETURN(SCM_MAKE_INT(SCM_U16VECTOR_SIZE(v)));
1450   }
1451 }
1452 
1453 static SCM_DEFINE_STRING_CONST(uvlib_u16vector_length__NAME, "u16vector-length", 16, 16);
1454 static SCM_DEFINE_SUBR(uvlib_u16vector_length__STUB, 1, 0, SCM_OBJ(&uvlib_u16vector_length__NAME), uvlib_u16vector_length, NULL, NULL);
1455 
1456 static ScmObj uvlib_u16vector_ref(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1457 {
1458   ScmObj v_scm;
1459   ScmU16Vector* v;
1460   ScmObj i_scm;
1461   int i;
1462   ScmObj fallback_scm;
1463   ScmObj fallback;
1464   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
1465   SCM_ENTER_SUBR("u16vector-ref");
1466   if (Scm_Length(SCM_OPTARGS) > 1)
1467     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
1468   v_scm = SCM_ARGREF(0);
1469   if (!SCM_U16VECTORP(v_scm)) Scm_Error("<u16vector> required, but got %S", v_scm);
1470   v = SCM_U16VECTOR(v_scm);
1471   i_scm = SCM_ARGREF(1);
1472   if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
1473   i = SCM_INT_VALUE(i_scm);
1474   if (SCM_NULLP(SCM_OPTARGS)) fallback_scm = SCM_UNBOUND;
1475   else {
1476     fallback_scm = SCM_CAR(SCM_OPTARGS);
1477     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1478   }
1479   fallback = (fallback_scm);
1480   {
1481 SCM_RETURN(Scm_U16VectorRef(v, i, fallback));
1482   }
1483 }
1484 
1485 static SCM_DEFINE_STRING_CONST(uvlib_u16vector_ref__NAME, "u16vector-ref", 13, 13);
1486 static SCM_DEFINE_SUBR(uvlib_u16vector_ref__STUB, 2, 1, SCM_OBJ(&uvlib_u16vector_ref__NAME), uvlib_u16vector_ref, NULL, NULL);
1487 
1488 static ScmObj uvlib_u16vector_setX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1489 {
1490   ScmObj v_scm;
1491   ScmU16Vector* v;
1492   ScmObj i_scm;
1493   int i;
1494   ScmObj val_scm;
1495   ScmObj val;
1496   ScmObj clamp_scm;
1497   ScmObj clamp;
1498   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
1499   SCM_ENTER_SUBR("u16vector-set!");
1500   if (Scm_Length(SCM_OPTARGS) > 1)
1501     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
1502   v_scm = SCM_ARGREF(0);
1503   if (!SCM_U16VECTORP(v_scm)) Scm_Error("<u16vector> required, but got %S", v_scm);
1504   v = SCM_U16VECTOR(v_scm);
1505   i_scm = SCM_ARGREF(1);
1506   if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
1507   i = SCM_INT_VALUE(i_scm);
1508   val_scm = SCM_ARGREF(2);
1509   val = (val_scm);
1510   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
1511   else {
1512     clamp_scm = SCM_CAR(SCM_OPTARGS);
1513     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1514   }
1515   clamp = (clamp_scm);
1516   {
1517 SCM_RETURN(Scm_U16VectorSet(v, i, val, clamp_arg(clamp)));
1518   }
1519 }
1520 
1521 static SCM_DEFINE_STRING_CONST(uvlib_u16vector_setX__NAME, "u16vector-set!", 14, 14);
1522 static SCM_DEFINE_SUBR(uvlib_u16vector_setX__STUB, 3, 1, SCM_OBJ(&uvlib_u16vector_setX__NAME), uvlib_u16vector_setX, NULL, NULL);
1523 
1524 static ScmObj uvlib_u16vector_copy(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1525 {
1526   ScmObj v_scm;
1527   ScmU16Vector* v;
1528   ScmObj start_scm;
1529   int start;
1530   ScmObj end_scm;
1531   int end;
1532   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
1533   SCM_ENTER_SUBR("u16vector-copy");
1534   if (Scm_Length(SCM_OPTARGS) > 2)
1535     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
1536   v_scm = SCM_ARGREF(0);
1537   if (!SCM_U16VECTORP(v_scm)) Scm_Error("<u16vector> required, but got %S", v_scm);
1538   v = SCM_U16VECTOR(v_scm);
1539   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
1540   else {
1541     start_scm = SCM_CAR(SCM_OPTARGS);
1542     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1543   }
1544   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
1545   start = SCM_INT_VALUE(start_scm);
1546   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
1547   else {
1548     end_scm = SCM_CAR(SCM_OPTARGS);
1549     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1550   }
1551   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
1552   end = SCM_INT_VALUE(end_scm);
1553   {
1554 {
1555 ScmObj SCM_RESULT;
1556 SCM_RESULT = Scm_U16VectorCopy(v, start, end);
1557 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
1558 }
1559   }
1560 }
1561 
1562 static SCM_DEFINE_STRING_CONST(uvlib_u16vector_copy__NAME, "u16vector-copy", 14, 14);
1563 static SCM_DEFINE_SUBR(uvlib_u16vector_copy__STUB, 1, 1, SCM_OBJ(&uvlib_u16vector_copy__NAME), uvlib_u16vector_copy, NULL, NULL);
1564 
1565 static ScmObj uvlib_u16vector_copyX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1566 {
1567   ScmObj dst_scm;
1568   ScmU16Vector* dst;
1569   ScmObj dstart_scm;
1570   ScmObj dstart;
1571   ScmObj src_scm;
1572   ScmObj src;
1573   ScmObj sstart_scm;
1574   int sstart;
1575   ScmObj send_scm;
1576   int send;
1577   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
1578   SCM_ENTER_SUBR("u16vector-copy!");
1579   if (Scm_Length(SCM_OPTARGS) > 3)
1580     Scm_Error("too many arguments: up to 3 is expected, %d given.", Scm_Length(SCM_OPTARGS));
1581   dst_scm = SCM_ARGREF(0);
1582   if (!SCM_U16VECTORP(dst_scm)) Scm_Error("<u16vector> required, but got %S", dst_scm);
1583   dst = SCM_U16VECTOR(dst_scm);
1584   dstart_scm = SCM_ARGREF(1);
1585   dstart = (dstart_scm);
1586   if (SCM_NULLP(SCM_OPTARGS)) src_scm = SCM_UNBOUND;
1587   else {
1588     src_scm = SCM_CAR(SCM_OPTARGS);
1589     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1590   }
1591   src = (src_scm);
1592   if (SCM_NULLP(SCM_OPTARGS)) sstart_scm = Scm_MakeInteger(0);
1593   else {
1594     sstart_scm = SCM_CAR(SCM_OPTARGS);
1595     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1596   }
1597   if (!SCM_EXACTP(sstart_scm)) Scm_Error("C integer required, but got %S", sstart_scm);
1598   sstart = Scm_GetInteger(sstart_scm);
1599   if (SCM_NULLP(SCM_OPTARGS)) send_scm = Scm_MakeInteger(-1);
1600   else {
1601     send_scm = SCM_CAR(SCM_OPTARGS);
1602     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1603   }
1604   if (!SCM_EXACTP(send_scm)) Scm_Error("C integer required, but got %S", send_scm);
1605   send = Scm_GetInteger(send_scm);
1606   {
1607 if (SCM_INTEGERP(dstart)) {
1608      /* new API */
1609      if (!SCM_U16VECTORP(src)) {
1610        Scm_Error("u16vector-copy!: argument is not a matching uvector: %S",
1611                  src);
1612      }
1613      SCM_RETURN(Scm_U16VectorCopyX(dst, Scm_GetInteger(dstart), 
1614                                     SCM_U16VECTOR(src), sstart, send));
1615   } else if (SCM_U16VECTORP(dstart)) {
1616     /* old API */
1617     SCM_RETURN(Scm_U16VectorCopyX(dst, 0, SCM_U16VECTOR(dstart), 0, -1));
1618   } else {
1619     Scm_Error("integer required, but got %S", dstart);
1620     SCM_RETURN(SCM_UNDEFINED);
1621   }
1622   }
1623 }
1624 
1625 static SCM_DEFINE_STRING_CONST(uvlib_u16vector_copyX__NAME, "u16vector-copy!", 15, 15);
1626 static SCM_DEFINE_SUBR(uvlib_u16vector_copyX__STUB, 2, 1, SCM_OBJ(&uvlib_u16vector_copyX__NAME), uvlib_u16vector_copyX, NULL, NULL);
1627 
1628 static ScmObj uvlib_u16vector_TOlist(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1629 {
1630   ScmObj v_scm;
1631   ScmU16Vector* v;
1632   ScmObj start_scm;
1633   int start;
1634   ScmObj end_scm;
1635   int end;
1636   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
1637   SCM_ENTER_SUBR("u16vector->list");
1638   if (Scm_Length(SCM_OPTARGS) > 2)
1639     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
1640   v_scm = SCM_ARGREF(0);
1641   if (!SCM_U16VECTORP(v_scm)) Scm_Error("<u16vector> required, but got %S", v_scm);
1642   v = SCM_U16VECTOR(v_scm);
1643   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
1644   else {
1645     start_scm = SCM_CAR(SCM_OPTARGS);
1646     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1647   }
1648   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
1649   start = SCM_INT_VALUE(start_scm);
1650   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
1651   else {
1652     end_scm = SCM_CAR(SCM_OPTARGS);
1653     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1654   }
1655   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
1656   end = SCM_INT_VALUE(end_scm);
1657   {
1658 {
1659 ScmObj SCM_RESULT;
1660 SCM_RESULT = Scm_U16VectorToList(v, start, end);
1661 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
1662 }
1663   }
1664 }
1665 
1666 static SCM_DEFINE_STRING_CONST(uvlib_u16vector_TOlist__NAME, "u16vector->list", 15, 15);
1667 static SCM_DEFINE_SUBR(uvlib_u16vector_TOlist__STUB, 1, 1, SCM_OBJ(&uvlib_u16vector_TOlist__NAME), uvlib_u16vector_TOlist, NULL, NULL);
1668 
1669 static ScmObj uvlib_list_TOu16vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1670 {
1671   ScmObj l_scm;
1672   ScmObj l;
1673   ScmObj clamp_scm;
1674   ScmObj clamp;
1675   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
1676   SCM_ENTER_SUBR("list->u16vector");
1677   if (Scm_Length(SCM_OPTARGS) > 1)
1678     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
1679   l_scm = SCM_ARGREF(0);
1680   if (!SCM_LISTP(l_scm)) Scm_Error("list required, but got %S", l_scm);
1681   l = (l_scm);
1682   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
1683   else {
1684     clamp_scm = SCM_CAR(SCM_OPTARGS);
1685     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1686   }
1687   clamp = (clamp_scm);
1688   {
1689 SCM_RETURN(Scm_ListToU16Vector(l, clamp_arg(clamp)));
1690   }
1691 }
1692 
1693 static SCM_DEFINE_STRING_CONST(uvlib_list_TOu16vector__NAME, "list->u16vector", 15, 15);
1694 static SCM_DEFINE_SUBR(uvlib_list_TOu16vector__STUB, 1, 1, SCM_OBJ(&uvlib_list_TOu16vector__NAME), uvlib_list_TOu16vector, NULL, NULL);
1695 
1696 static ScmObj uvlib_u16vector_fillX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1697 {
1698   ScmObj v_scm;
1699   ScmU16Vector* v;
1700   ScmObj val_scm;
1701   ScmObj val;
1702   ScmObj start_scm;
1703   int start;
1704   ScmObj end_scm;
1705   int end;
1706   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
1707   SCM_ENTER_SUBR("u16vector-fill!");
1708   if (Scm_Length(SCM_OPTARGS) > 2)
1709     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
1710   v_scm = SCM_ARGREF(0);
1711   if (!SCM_U16VECTORP(v_scm)) Scm_Error("<u16vector> required, but got %S", v_scm);
1712   v = SCM_U16VECTOR(v_scm);
1713   val_scm = SCM_ARGREF(1);
1714   val = (val_scm);
1715   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
1716   else {
1717     start_scm = SCM_CAR(SCM_OPTARGS);
1718     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1719   }
1720   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
1721   start = SCM_INT_VALUE(start_scm);
1722   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
1723   else {
1724     end_scm = SCM_CAR(SCM_OPTARGS);
1725     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1726   }
1727   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
1728   end = SCM_INT_VALUE(end_scm);
1729   {
1730 unsigned short filler;
1731   filler = u16unbox(val, SCM_CLAMP_ERROR);
1732   SCM_RETURN(Scm_U16VectorFill(v, filler, start, end));
1733   }
1734 }
1735 
1736 static SCM_DEFINE_STRING_CONST(uvlib_u16vector_fillX__NAME, "u16vector-fill!", 15, 15);
1737 static SCM_DEFINE_SUBR(uvlib_u16vector_fillX__STUB, 2, 1, SCM_OBJ(&uvlib_u16vector_fillX__NAME), uvlib_u16vector_fillX, NULL, NULL);
1738 
1739 static ScmObj uvlib_u16vector_TOvector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1740 {
1741   ScmObj v_scm;
1742   ScmU16Vector* v;
1743   ScmObj start_scm;
1744   int start;
1745   ScmObj end_scm;
1746   int end;
1747   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
1748   SCM_ENTER_SUBR("u16vector->vector");
1749   if (Scm_Length(SCM_OPTARGS) > 2)
1750     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
1751   v_scm = SCM_ARGREF(0);
1752   if (!SCM_U16VECTORP(v_scm)) Scm_Error("<u16vector> required, but got %S", v_scm);
1753   v = SCM_U16VECTOR(v_scm);
1754   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
1755   else {
1756     start_scm = SCM_CAR(SCM_OPTARGS);
1757     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1758   }
1759   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
1760   start = SCM_INT_VALUE(start_scm);
1761   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
1762   else {
1763     end_scm = SCM_CAR(SCM_OPTARGS);
1764     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1765   }
1766   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
1767   end = SCM_INT_VALUE(end_scm);
1768   {
1769 {
1770 ScmObj SCM_RESULT;
1771 SCM_RESULT = Scm_U16VectorToVector(v, start, end);
1772 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
1773 }
1774   }
1775 }
1776 
1777 static SCM_DEFINE_STRING_CONST(uvlib_u16vector_TOvector__NAME, "u16vector->vector", 17, 17);
1778 static SCM_DEFINE_SUBR(uvlib_u16vector_TOvector__STUB, 1, 1, SCM_OBJ(&uvlib_u16vector_TOvector__NAME), uvlib_u16vector_TOvector, NULL, NULL);
1779 
1780 static ScmObj uvlib_vector_TOu16vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1781 {
1782   ScmObj v_scm;
1783   ScmVector* v;
1784   ScmObj start_scm;
1785   int start;
1786   ScmObj end_scm;
1787   int end;
1788   ScmObj clamp_scm;
1789   ScmObj clamp;
1790   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
1791   SCM_ENTER_SUBR("vector->u16vector");
1792   if (Scm_Length(SCM_OPTARGS) > 3)
1793     Scm_Error("too many arguments: up to 3 is expected, %d given.", Scm_Length(SCM_OPTARGS));
1794   v_scm = SCM_ARGREF(0);
1795   if (!SCM_VECTORP(v_scm)) Scm_Error("vector required, but got %S", v_scm);
1796   v = SCM_VECTOR(v_scm);
1797   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
1798   else {
1799     start_scm = SCM_CAR(SCM_OPTARGS);
1800     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1801   }
1802   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
1803   start = SCM_INT_VALUE(start_scm);
1804   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
1805   else {
1806     end_scm = SCM_CAR(SCM_OPTARGS);
1807     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1808   }
1809   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
1810   end = SCM_INT_VALUE(end_scm);
1811   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
1812   else {
1813     clamp_scm = SCM_CAR(SCM_OPTARGS);
1814     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1815   }
1816   clamp = (clamp_scm);
1817   {
1818 SCM_RETURN(Scm_VectorToU16Vector(v, start, end, clamp_arg(clamp)));
1819   }
1820 }
1821 
1822 static SCM_DEFINE_STRING_CONST(uvlib_vector_TOu16vector__NAME, "vector->u16vector", 17, 17);
1823 static SCM_DEFINE_SUBR(uvlib_vector_TOu16vector__STUB, 1, 1, SCM_OBJ(&uvlib_vector_TOu16vector__NAME), uvlib_vector_TOu16vector, NULL, NULL);
1824 
1825 static ScmObj uvlib_s32vectorP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1826 {
1827   ScmObj obj_scm;
1828   ScmObj obj;
1829   SCM_ENTER_SUBR("s32vector?");
1830   obj_scm = SCM_ARGREF(0);
1831   obj = (obj_scm);
1832   {
1833 {
1834 int SCM_RESULT;
1835 SCM_RESULT = SCM_S32VECTORP(obj);
1836 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
1837 }
1838   }
1839 }
1840 
1841 static SCM_DEFINE_STRING_CONST(uvlib_s32vectorP__NAME, "s32vector?", 10, 10);
1842 static SCM_DEFINE_SUBR(uvlib_s32vectorP__STUB, 1, 0, SCM_OBJ(&uvlib_s32vectorP__NAME), uvlib_s32vectorP, NULL, NULL);
1843 
1844 static ScmObj uvlib_make_s32vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1845 {
1846   ScmObj length_scm;
1847   int length;
1848   ScmObj fill_scm;
1849   ScmObj fill;
1850   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
1851   SCM_ENTER_SUBR("make-s32vector");
1852   if (Scm_Length(SCM_OPTARGS) > 1)
1853     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
1854   length_scm = SCM_ARGREF(0);
1855   if (!SCM_INTP(length_scm)) Scm_Error("small integer required, but got %S", length_scm);
1856   length = SCM_INT_VALUE(length_scm);
1857   if (SCM_NULLP(SCM_OPTARGS)) fill_scm = Scm_MakeInteger(0);
1858   else {
1859     fill_scm = SCM_CAR(SCM_OPTARGS);
1860     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1861   }
1862   fill = (fill_scm);
1863   {
1864 ScmInt32 filler;
1865   filler = Scm_GetInteger32Clamp(fill, SCM_CLAMP_ERROR, NULL);
1866   SCM_RETURN(Scm_MakeS32Vector(length, filler));
1867   }
1868 }
1869 
1870 static SCM_DEFINE_STRING_CONST(uvlib_make_s32vector__NAME, "make-s32vector", 14, 14);
1871 static SCM_DEFINE_SUBR(uvlib_make_s32vector__STUB, 1, 1, SCM_OBJ(&uvlib_make_s32vector__NAME), uvlib_make_s32vector, NULL, NULL);
1872 
1873 static ScmObj uvlib_s32vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1874 {
1875   ScmObj args_scm;
1876   ScmObj args;
1877   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
1878   SCM_ENTER_SUBR("s32vector");
1879   args_scm = SCM_OPTARGS;
1880   args = (args_scm);
1881   {
1882 SCM_RETURN(Scm_ListToS32Vector(args, SCM_CLAMP_ERROR));
1883   }
1884 }
1885 
1886 static SCM_DEFINE_STRING_CONST(uvlib_s32vector__NAME, "s32vector", 9, 9);
1887 static SCM_DEFINE_SUBR(uvlib_s32vector__STUB, 0, 1, SCM_OBJ(&uvlib_s32vector__NAME), uvlib_s32vector, NULL, NULL);
1888 
1889 static ScmObj uvlib_s32vector_length(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1890 {
1891   ScmObj v_scm;
1892   ScmS32Vector* v;
1893   SCM_ENTER_SUBR("s32vector-length");
1894   v_scm = SCM_ARGREF(0);
1895   if (!SCM_S32VECTORP(v_scm)) Scm_Error("<s32vector> required, but got %S", v_scm);
1896   v = SCM_S32VECTOR(v_scm);
1897   {
1898 SCM_RETURN(SCM_MAKE_INT(SCM_S32VECTOR_SIZE(v)));
1899   }
1900 }
1901 
1902 static SCM_DEFINE_STRING_CONST(uvlib_s32vector_length__NAME, "s32vector-length", 16, 16);
1903 static SCM_DEFINE_SUBR(uvlib_s32vector_length__STUB, 1, 0, SCM_OBJ(&uvlib_s32vector_length__NAME), uvlib_s32vector_length, NULL, NULL);
1904 
1905 static ScmObj uvlib_s32vector_ref(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1906 {
1907   ScmObj v_scm;
1908   ScmS32Vector* v;
1909   ScmObj i_scm;
1910   int i;
1911   ScmObj fallback_scm;
1912   ScmObj fallback;
1913   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
1914   SCM_ENTER_SUBR("s32vector-ref");
1915   if (Scm_Length(SCM_OPTARGS) > 1)
1916     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
1917   v_scm = SCM_ARGREF(0);
1918   if (!SCM_S32VECTORP(v_scm)) Scm_Error("<s32vector> required, but got %S", v_scm);
1919   v = SCM_S32VECTOR(v_scm);
1920   i_scm = SCM_ARGREF(1);
1921   if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
1922   i = SCM_INT_VALUE(i_scm);
1923   if (SCM_NULLP(SCM_OPTARGS)) fallback_scm = SCM_UNBOUND;
1924   else {
1925     fallback_scm = SCM_CAR(SCM_OPTARGS);
1926     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1927   }
1928   fallback = (fallback_scm);
1929   {
1930 SCM_RETURN(Scm_S32VectorRef(v, i, fallback));
1931   }
1932 }
1933 
1934 static SCM_DEFINE_STRING_CONST(uvlib_s32vector_ref__NAME, "s32vector-ref", 13, 13);
1935 static SCM_DEFINE_SUBR(uvlib_s32vector_ref__STUB, 2, 1, SCM_OBJ(&uvlib_s32vector_ref__NAME), uvlib_s32vector_ref, NULL, NULL);
1936 
1937 static ScmObj uvlib_s32vector_setX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1938 {
1939   ScmObj v_scm;
1940   ScmS32Vector* v;
1941   ScmObj i_scm;
1942   int i;
1943   ScmObj val_scm;
1944   ScmObj val;
1945   ScmObj clamp_scm;
1946   ScmObj clamp;
1947   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
1948   SCM_ENTER_SUBR("s32vector-set!");
1949   if (Scm_Length(SCM_OPTARGS) > 1)
1950     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
1951   v_scm = SCM_ARGREF(0);
1952   if (!SCM_S32VECTORP(v_scm)) Scm_Error("<s32vector> required, but got %S", v_scm);
1953   v = SCM_S32VECTOR(v_scm);
1954   i_scm = SCM_ARGREF(1);
1955   if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
1956   i = SCM_INT_VALUE(i_scm);
1957   val_scm = SCM_ARGREF(2);
1958   val = (val_scm);
1959   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
1960   else {
1961     clamp_scm = SCM_CAR(SCM_OPTARGS);
1962     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1963   }
1964   clamp = (clamp_scm);
1965   {
1966 SCM_RETURN(Scm_S32VectorSet(v, i, val, clamp_arg(clamp)));
1967   }
1968 }
1969 
1970 static SCM_DEFINE_STRING_CONST(uvlib_s32vector_setX__NAME, "s32vector-set!", 14, 14);
1971 static SCM_DEFINE_SUBR(uvlib_s32vector_setX__STUB, 3, 1, SCM_OBJ(&uvlib_s32vector_setX__NAME), uvlib_s32vector_setX, NULL, NULL);
1972 
1973 static ScmObj uvlib_s32vector_copy(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1974 {
1975   ScmObj v_scm;
1976   ScmS32Vector* v;
1977   ScmObj start_scm;
1978   int start;
1979   ScmObj end_scm;
1980   int end;
1981   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
1982   SCM_ENTER_SUBR("s32vector-copy");
1983   if (Scm_Length(SCM_OPTARGS) > 2)
1984     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
1985   v_scm = SCM_ARGREF(0);
1986   if (!SCM_S32VECTORP(v_scm)) Scm_Error("<s32vector> required, but got %S", v_scm);
1987   v = SCM_S32VECTOR(v_scm);
1988   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
1989   else {
1990     start_scm = SCM_CAR(SCM_OPTARGS);
1991     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1992   }
1993   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
1994   start = SCM_INT_VALUE(start_scm);
1995   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
1996   else {
1997     end_scm = SCM_CAR(SCM_OPTARGS);
1998     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1999   }
2000   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
2001   end = SCM_INT_VALUE(end_scm);
2002   {
2003 {
2004 ScmObj SCM_RESULT;
2005 SCM_RESULT = Scm_S32VectorCopy(v, start, end);
2006 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
2007 }
2008   }
2009 }
2010 
2011 static SCM_DEFINE_STRING_CONST(uvlib_s32vector_copy__NAME, "s32vector-copy", 14, 14);
2012 static SCM_DEFINE_SUBR(uvlib_s32vector_copy__STUB, 1, 1, SCM_OBJ(&uvlib_s32vector_copy__NAME), uvlib_s32vector_copy, NULL, NULL);
2013 
2014 static ScmObj uvlib_s32vector_copyX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2015 {
2016   ScmObj dst_scm;
2017   ScmS32Vector* dst;
2018   ScmObj dstart_scm;
2019   ScmObj dstart;
2020   ScmObj src_scm;
2021   ScmObj src;
2022   ScmObj sstart_scm;
2023   int sstart;
2024   ScmObj send_scm;
2025   int send;
2026   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
2027   SCM_ENTER_SUBR("s32vector-copy!");
2028   if (Scm_Length(SCM_OPTARGS) > 3)
2029     Scm_Error("too many arguments: up to 3 is expected, %d given.", Scm_Length(SCM_OPTARGS));
2030   dst_scm = SCM_ARGREF(0);
2031   if (!SCM_S32VECTORP(dst_scm)) Scm_Error("<s32vector> required, but got %S", dst_scm);
2032   dst = SCM_S32VECTOR(dst_scm);
2033   dstart_scm = SCM_ARGREF(1);
2034   dstart = (dstart_scm);
2035   if (SCM_NULLP(SCM_OPTARGS)) src_scm = SCM_UNBOUND;
2036   else {
2037     src_scm = SCM_CAR(SCM_OPTARGS);
2038     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2039   }
2040   src = (src_scm);
2041   if (SCM_NULLP(SCM_OPTARGS)) sstart_scm = Scm_MakeInteger(0);
2042   else {
2043     sstart_scm = SCM_CAR(SCM_OPTARGS);
2044     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2045   }
2046   if (!SCM_EXACTP(sstart_scm)) Scm_Error("C integer required, but got %S", sstart_scm);
2047   sstart = Scm_GetInteger(sstart_scm);
2048   if (SCM_NULLP(SCM_OPTARGS)) send_scm = Scm_MakeInteger(-1);
2049   else {
2050     send_scm = SCM_CAR(SCM_OPTARGS);
2051     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2052   }
2053   if (!SCM_EXACTP(send_scm)) Scm_Error("C integer required, but got %S", send_scm);
2054   send = Scm_GetInteger(send_scm);
2055   {
2056 if (SCM_INTEGERP(dstart)) {
2057      /* new API */
2058      if (!SCM_S32VECTORP(src)) {
2059        Scm_Error("s32vector-copy!: argument is not a matching uvector: %S",
2060                  src);
2061      }
2062      SCM_RETURN(Scm_S32VectorCopyX(dst, Scm_GetInteger(dstart), 
2063                                     SCM_S32VECTOR(src), sstart, send));
2064   } else if (SCM_S32VECTORP(dstart)) {
2065     /* old API */
2066     SCM_RETURN(Scm_S32VectorCopyX(dst, 0, SCM_S32VECTOR(dstart), 0, -1));
2067   } else {
2068     Scm_Error("integer required, but got %S", dstart);
2069     SCM_RETURN(SCM_UNDEFINED);
2070   }
2071   }
2072 }
2073 
2074 static SCM_DEFINE_STRING_CONST(uvlib_s32vector_copyX__NAME, "s32vector-copy!", 15, 15);
2075 static SCM_DEFINE_SUBR(uvlib_s32vector_copyX__STUB, 2, 1, SCM_OBJ(&uvlib_s32vector_copyX__NAME), uvlib_s32vector_copyX, NULL, NULL);
2076 
2077 static ScmObj uvlib_s32vector_TOlist(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2078 {
2079   ScmObj v_scm;
2080   ScmS32Vector* v;
2081   ScmObj start_scm;
2082   int start;
2083   ScmObj end_scm;
2084   int end;
2085   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
2086   SCM_ENTER_SUBR("s32vector->list");
2087   if (Scm_Length(SCM_OPTARGS) > 2)
2088     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
2089   v_scm = SCM_ARGREF(0);
2090   if (!SCM_S32VECTORP(v_scm)) Scm_Error("<s32vector> required, but got %S", v_scm);
2091   v = SCM_S32VECTOR(v_scm);
2092   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
2093   else {
2094     start_scm = SCM_CAR(SCM_OPTARGS);
2095     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2096   }
2097   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
2098   start = SCM_INT_VALUE(start_scm);
2099   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
2100   else {
2101     end_scm = SCM_CAR(SCM_OPTARGS);
2102     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2103   }
2104   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
2105   end = SCM_INT_VALUE(end_scm);
2106   {
2107 {
2108 ScmObj SCM_RESULT;
2109 SCM_RESULT = Scm_S32VectorToList(v, start, end);
2110 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
2111 }
2112   }
2113 }
2114 
2115 static SCM_DEFINE_STRING_CONST(uvlib_s32vector_TOlist__NAME, "s32vector->list", 15, 15);
2116 static SCM_DEFINE_SUBR(uvlib_s32vector_TOlist__STUB, 1, 1, SCM_OBJ(&uvlib_s32vector_TOlist__NAME), uvlib_s32vector_TOlist, NULL, NULL);
2117 
2118 static ScmObj uvlib_list_TOs32vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2119 {
2120   ScmObj l_scm;
2121   ScmObj l;
2122   ScmObj clamp_scm;
2123   ScmObj clamp;
2124   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
2125   SCM_ENTER_SUBR("list->s32vector");
2126   if (Scm_Length(SCM_OPTARGS) > 1)
2127     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
2128   l_scm = SCM_ARGREF(0);
2129   if (!SCM_LISTP(l_scm)) Scm_Error("list required, but got %S", l_scm);
2130   l = (l_scm);
2131   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
2132   else {
2133     clamp_scm = SCM_CAR(SCM_OPTARGS);
2134     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2135   }
2136   clamp = (clamp_scm);
2137   {
2138 SCM_RETURN(Scm_ListToS32Vector(l, clamp_arg(clamp)));
2139   }
2140 }
2141 
2142 static SCM_DEFINE_STRING_CONST(uvlib_list_TOs32vector__NAME, "list->s32vector", 15, 15);
2143 static SCM_DEFINE_SUBR(uvlib_list_TOs32vector__STUB, 1, 1, SCM_OBJ(&uvlib_list_TOs32vector__NAME), uvlib_list_TOs32vector, NULL, NULL);
2144 
2145 static ScmObj uvlib_s32vector_fillX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2146 {
2147   ScmObj v_scm;
2148   ScmS32Vector* v;
2149   ScmObj val_scm;
2150   ScmObj val;
2151   ScmObj start_scm;
2152   int start;
2153   ScmObj end_scm;
2154   int end;
2155   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
2156   SCM_ENTER_SUBR("s32vector-fill!");
2157   if (Scm_Length(SCM_OPTARGS) > 2)
2158     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
2159   v_scm = SCM_ARGREF(0);
2160   if (!SCM_S32VECTORP(v_scm)) Scm_Error("<s32vector> required, but got %S", v_scm);
2161   v = SCM_S32VECTOR(v_scm);
2162   val_scm = SCM_ARGREF(1);
2163   val = (val_scm);
2164   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
2165   else {
2166     start_scm = SCM_CAR(SCM_OPTARGS);
2167     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2168   }
2169   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
2170   start = SCM_INT_VALUE(start_scm);
2171   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
2172   else {
2173     end_scm = SCM_CAR(SCM_OPTARGS);
2174     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2175   }
2176   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
2177   end = SCM_INT_VALUE(end_scm);
2178   {
2179 ScmInt32 filler;
2180   filler = Scm_GetInteger32Clamp(val, SCM_CLAMP_ERROR, NULL);
2181   SCM_RETURN(Scm_S32VectorFill(v, filler, start, end));
2182   }
2183 }
2184 
2185 static SCM_DEFINE_STRING_CONST(uvlib_s32vector_fillX__NAME, "s32vector-fill!", 15, 15);
2186 static SCM_DEFINE_SUBR(uvlib_s32vector_fillX__STUB, 2, 1, SCM_OBJ(&uvlib_s32vector_fillX__NAME), uvlib_s32vector_fillX, NULL, NULL);
2187 
2188 static ScmObj uvlib_s32vector_TOvector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2189 {
2190   ScmObj v_scm;
2191   ScmS32Vector* v;
2192   ScmObj start_scm;
2193   int start;
2194   ScmObj end_scm;
2195   int end;
2196   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
2197   SCM_ENTER_SUBR("s32vector->vector");
2198   if (Scm_Length(SCM_OPTARGS) > 2)
2199     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
2200   v_scm = SCM_ARGREF(0);
2201   if (!SCM_S32VECTORP(v_scm)) Scm_Error("<s32vector> required, but got %S", v_scm);
2202   v = SCM_S32VECTOR(v_scm);
2203   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
2204   else {
2205     start_scm = SCM_CAR(SCM_OPTARGS);
2206     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2207   }
2208   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
2209   start = SCM_INT_VALUE(start_scm);
2210   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
2211   else {
2212     end_scm = SCM_CAR(SCM_OPTARGS);
2213     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2214   }
2215   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
2216   end = SCM_INT_VALUE(end_scm);
2217   {
2218 {
2219 ScmObj SCM_RESULT;
2220 SCM_RESULT = Scm_S32VectorToVector(v, start, end);
2221 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
2222 }
2223   }
2224 }
2225 
2226 static SCM_DEFINE_STRING_CONST(uvlib_s32vector_TOvector__NAME, "s32vector->vector", 17, 17);
2227 static SCM_DEFINE_SUBR(uvlib_s32vector_TOvector__STUB, 1, 1, SCM_OBJ(&uvlib_s32vector_TOvector__NAME), uvlib_s32vector_TOvector, NULL, NULL);
2228 
2229 static ScmObj uvlib_vector_TOs32vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2230 {
2231   ScmObj v_scm;
2232   ScmVector* v;
2233   ScmObj start_scm;
2234   int start;
2235   ScmObj end_scm;
2236   int end;
2237   ScmObj clamp_scm;
2238   ScmObj clamp;
2239   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
2240   SCM_ENTER_SUBR("vector->s32vector");
2241   if (Scm_Length(SCM_OPTARGS) > 3)
2242     Scm_Error("too many arguments: up to 3 is expected, %d given.", Scm_Length(SCM_OPTARGS));
2243   v_scm = SCM_ARGREF(0);
2244   if (!SCM_VECTORP(v_scm)) Scm_Error("vector required, but got %S", v_scm);
2245   v = SCM_VECTOR(v_scm);
2246   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
2247   else {
2248     start_scm = SCM_CAR(SCM_OPTARGS);
2249     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2250   }
2251   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
2252   start = SCM_INT_VALUE(start_scm);
2253   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
2254   else {
2255     end_scm = SCM_CAR(SCM_OPTARGS);
2256     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2257   }
2258   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
2259   end = SCM_INT_VALUE(end_scm);
2260   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
2261   else {
2262     clamp_scm = SCM_CAR(SCM_OPTARGS);
2263     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2264   }
2265   clamp = (clamp_scm);
2266   {
2267 SCM_RETURN(Scm_VectorToS32Vector(v, start, end, clamp_arg(clamp)));
2268   }
2269 }
2270 
2271 static SCM_DEFINE_STRING_CONST(uvlib_vector_TOs32vector__NAME, "vector->s32vector", 17, 17);
2272 static SCM_DEFINE_SUBR(uvlib_vector_TOs32vector__STUB, 1, 1, SCM_OBJ(&uvlib_vector_TOs32vector__NAME), uvlib_vector_TOs32vector, NULL, NULL);
2273 
2274 static ScmObj uvlib_u32vectorP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2275 {
2276   ScmObj obj_scm;
2277   ScmObj obj;
2278   SCM_ENTER_SUBR("u32vector?");
2279   obj_scm = SCM_ARGREF(0);
2280   obj = (obj_scm);
2281   {
2282 {
2283 int SCM_RESULT;
2284 SCM_RESULT = SCM_U32VECTORP(obj);
2285 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
2286 }
2287   }
2288 }
2289 
2290 static SCM_DEFINE_STRING_CONST(uvlib_u32vectorP__NAME, "u32vector?", 10, 10);
2291 static SCM_DEFINE_SUBR(uvlib_u32vectorP__STUB, 1, 0, SCM_OBJ(&uvlib_u32vectorP__NAME), uvlib_u32vectorP, NULL, NULL);
2292 
2293 static ScmObj uvlib_make_u32vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2294 {
2295   ScmObj length_scm;
2296   int length;
2297   ScmObj fill_scm;
2298   ScmObj fill;
2299   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
2300   SCM_ENTER_SUBR("make-u32vector");
2301   if (Scm_Length(SCM_OPTARGS) > 1)
2302     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
2303   length_scm = SCM_ARGREF(0);
2304   if (!SCM_INTP(length_scm)) Scm_Error("small integer required, but got %S", length_scm);
2305   length = SCM_INT_VALUE(length_scm);
2306   if (SCM_NULLP(SCM_OPTARGS)) fill_scm = Scm_MakeInteger(0);
2307   else {
2308     fill_scm = SCM_CAR(SCM_OPTARGS);
2309     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2310   }
2311   fill = (fill_scm);
2312   {
2313 ScmUInt32 filler;
2314   filler = Scm_GetIntegerU32Clamp(fill, SCM_CLAMP_ERROR, NULL);
2315   SCM_RETURN(Scm_MakeU32Vector(length, filler));
2316   }
2317 }
2318 
2319 static SCM_DEFINE_STRING_CONST(uvlib_make_u32vector__NAME, "make-u32vector", 14, 14);
2320 static SCM_DEFINE_SUBR(uvlib_make_u32vector__STUB, 1, 1, SCM_OBJ(&uvlib_make_u32vector__NAME), uvlib_make_u32vector, NULL, NULL);
2321 
2322 static ScmObj uvlib_u32vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2323 {
2324   ScmObj args_scm;
2325   ScmObj args;
2326   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
2327   SCM_ENTER_SUBR("u32vector");
2328   args_scm = SCM_OPTARGS;
2329   args = (args_scm);
2330   {
2331 SCM_RETURN(Scm_ListToU32Vector(args, SCM_CLAMP_ERROR));
2332   }
2333 }
2334 
2335 static SCM_DEFINE_STRING_CONST(uvlib_u32vector__NAME, "u32vector", 9, 9);
2336 static SCM_DEFINE_SUBR(uvlib_u32vector__STUB, 0, 1, SCM_OBJ(&uvlib_u32vector__NAME), uvlib_u32vector, NULL, NULL);
2337 
2338 static ScmObj uvlib_u32vector_length(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2339 {
2340   ScmObj v_scm;
2341   ScmU32Vector* v;
2342   SCM_ENTER_SUBR("u32vector-length");
2343   v_scm = SCM_ARGREF(0);
2344   if (!SCM_U32VECTORP(v_scm)) Scm_Error("<u32vector> required, but got %S", v_scm);
2345   v = SCM_U32VECTOR(v_scm);
2346   {
2347 SCM_RETURN(SCM_MAKE_INT(SCM_U32VECTOR_SIZE(v)));
2348   }
2349 }
2350 
2351 static SCM_DEFINE_STRING_CONST(uvlib_u32vector_length__NAME, "u32vector-length", 16, 16);
2352 static SCM_DEFINE_SUBR(uvlib_u32vector_length__STUB, 1, 0, SCM_OBJ(&uvlib_u32vector_length__NAME), uvlib_u32vector_length, NULL, NULL);
2353 
2354 static ScmObj uvlib_u32vector_ref(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2355 {
2356   ScmObj v_scm;
2357   ScmU32Vector* v;
2358   ScmObj i_scm;
2359   int i;
2360   ScmObj fallback_scm;
2361   ScmObj fallback;
2362   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
2363   SCM_ENTER_SUBR("u32vector-ref");
2364   if (Scm_Length(SCM_OPTARGS) > 1)
2365     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
2366   v_scm = SCM_ARGREF(0);
2367   if (!SCM_U32VECTORP(v_scm)) Scm_Error("<u32vector> required, but got %S", v_scm);
2368   v = SCM_U32VECTOR(v_scm);
2369   i_scm = SCM_ARGREF(1);
2370   if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
2371   i = SCM_INT_VALUE(i_scm);
2372   if (SCM_NULLP(SCM_OPTARGS)) fallback_scm = SCM_UNBOUND;
2373   else {
2374     fallback_scm = SCM_CAR(SCM_OPTARGS);
2375     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2376   }
2377   fallback = (fallback_scm);
2378   {
2379 SCM_RETURN(Scm_U32VectorRef(v, i, fallback));
2380   }
2381 }
2382 
2383 static SCM_DEFINE_STRING_CONST(uvlib_u32vector_ref__NAME, "u32vector-ref", 13, 13);
2384 static SCM_DEFINE_SUBR(uvlib_u32vector_ref__STUB, 2, 1, SCM_OBJ(&uvlib_u32vector_ref__NAME), uvlib_u32vector_ref, NULL, NULL);
2385 
2386 static ScmObj uvlib_u32vector_setX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2387 {
2388   ScmObj v_scm;
2389   ScmU32Vector* v;
2390   ScmObj i_scm;
2391   int i;
2392   ScmObj val_scm;
2393   ScmObj val;
2394   ScmObj clamp_scm;
2395   ScmObj clamp;
2396   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
2397   SCM_ENTER_SUBR("u32vector-set!");
2398   if (Scm_Length(SCM_OPTARGS) > 1)
2399     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
2400   v_scm = SCM_ARGREF(0);
2401   if (!SCM_U32VECTORP(v_scm)) Scm_Error("<u32vector> required, but got %S", v_scm);
2402   v = SCM_U32VECTOR(v_scm);
2403   i_scm = SCM_ARGREF(1);
2404   if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
2405   i = SCM_INT_VALUE(i_scm);
2406   val_scm = SCM_ARGREF(2);
2407   val = (val_scm);
2408   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
2409   else {
2410     clamp_scm = SCM_CAR(SCM_OPTARGS);
2411     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2412   }
2413   clamp = (clamp_scm);
2414   {
2415 SCM_RETURN(Scm_U32VectorSet(v, i, val, clamp_arg(clamp)));
2416   }
2417 }
2418 
2419 static SCM_DEFINE_STRING_CONST(uvlib_u32vector_setX__NAME, "u32vector-set!", 14, 14);
2420 static SCM_DEFINE_SUBR(uvlib_u32vector_setX__STUB, 3, 1, SCM_OBJ(&uvlib_u32vector_setX__NAME), uvlib_u32vector_setX, NULL, NULL);
2421 
2422 static ScmObj uvlib_u32vector_copy(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2423 {
2424   ScmObj v_scm;
2425   ScmU32Vector* v;
2426   ScmObj start_scm;
2427   int start;
2428   ScmObj end_scm;
2429   int end;
2430   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
2431   SCM_ENTER_SUBR("u32vector-copy");
2432   if (Scm_Length(SCM_OPTARGS) > 2)
2433     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
2434   v_scm = SCM_ARGREF(0);
2435   if (!SCM_U32VECTORP(v_scm)) Scm_Error("<u32vector> required, but got %S", v_scm);
2436   v = SCM_U32VECTOR(v_scm);
2437   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
2438   else {
2439     start_scm = SCM_CAR(SCM_OPTARGS);
2440     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2441   }
2442   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
2443   start = SCM_INT_VALUE(start_scm);
2444   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
2445   else {
2446     end_scm = SCM_CAR(SCM_OPTARGS);
2447     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2448   }
2449   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
2450   end = SCM_INT_VALUE(end_scm);
2451   {
2452 {
2453 ScmObj SCM_RESULT;
2454 SCM_RESULT = Scm_U32VectorCopy(v, start, end);
2455 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
2456 }
2457   }
2458 }
2459 
2460 static SCM_DEFINE_STRING_CONST(uvlib_u32vector_copy__NAME, "u32vector-copy", 14, 14);
2461 static SCM_DEFINE_SUBR(uvlib_u32vector_copy__STUB, 1, 1, SCM_OBJ(&uvlib_u32vector_copy__NAME), uvlib_u32vector_copy, NULL, NULL);
2462 
2463 static ScmObj uvlib_u32vector_copyX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2464 {
2465   ScmObj dst_scm;
2466   ScmU32Vector* dst;
2467   ScmObj dstart_scm;
2468   ScmObj dstart;
2469   ScmObj src_scm;
2470   ScmObj src;
2471   ScmObj sstart_scm;
2472   int sstart;
2473   ScmObj send_scm;
2474   int send;
2475   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
2476   SCM_ENTER_SUBR("u32vector-copy!");
2477   if (Scm_Length(SCM_OPTARGS) > 3)
2478     Scm_Error("too many arguments: up to 3 is expected, %d given.", Scm_Length(SCM_OPTARGS));
2479   dst_scm = SCM_ARGREF(0);
2480   if (!SCM_U32VECTORP(dst_scm)) Scm_Error("<u32vector> required, but got %S", dst_scm);
2481   dst = SCM_U32VECTOR(dst_scm);
2482   dstart_scm = SCM_ARGREF(1);
2483   dstart = (dstart_scm);
2484   if (SCM_NULLP(SCM_OPTARGS)) src_scm = SCM_UNBOUND;
2485   else {
2486     src_scm = SCM_CAR(SCM_OPTARGS);
2487     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2488   }
2489   src = (src_scm);
2490   if (SCM_NULLP(SCM_OPTARGS)) sstart_scm = Scm_MakeInteger(0);
2491   else {
2492     sstart_scm = SCM_CAR(SCM_OPTARGS);
2493     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2494   }
2495   if (!SCM_EXACTP(sstart_scm)) Scm_Error("C integer required, but got %S", sstart_scm);
2496   sstart = Scm_GetInteger(sstart_scm);
2497   if (SCM_NULLP(SCM_OPTARGS)) send_scm = Scm_MakeInteger(-1);
2498   else {
2499     send_scm = SCM_CAR(SCM_OPTARGS);
2500     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2501   }
2502   if (!SCM_EXACTP(send_scm)) Scm_Error("C integer required, but got %S", send_scm);
2503   send = Scm_GetInteger(send_scm);
2504   {
2505 if (SCM_INTEGERP(dstart)) {
2506      /* new API */
2507      if (!SCM_U32VECTORP(src)) {
2508        Scm_Error("u32vector-copy!: argument is not a matching uvector: %S",
2509                  src);
2510      }
2511      SCM_RETURN(Scm_U32VectorCopyX(dst, Scm_GetInteger(dstart), 
2512                                     SCM_U32VECTOR(src), sstart, send));
2513   } else if (SCM_U32VECTORP(dstart)) {
2514     /* old API */
2515     SCM_RETURN(Scm_U32VectorCopyX(dst, 0, SCM_U32VECTOR(dstart), 0, -1));
2516   } else {
2517     Scm_Error("integer required, but got %S", dstart);
2518     SCM_RETURN(SCM_UNDEFINED);
2519   }
2520   }
2521 }
2522 
2523 static SCM_DEFINE_STRING_CONST(uvlib_u32vector_copyX__NAME, "u32vector-copy!", 15, 15);
2524 static SCM_DEFINE_SUBR(uvlib_u32vector_copyX__STUB, 2, 1, SCM_OBJ(&uvlib_u32vector_copyX__NAME), uvlib_u32vector_copyX, NULL, NULL);
2525 
2526 static ScmObj uvlib_u32vector_TOlist(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2527 {
2528   ScmObj v_scm;
2529   ScmU32Vector* v;
2530   ScmObj start_scm;
2531   int start;
2532   ScmObj end_scm;
2533   int end;
2534   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
2535   SCM_ENTER_SUBR("u32vector->list");
2536   if (Scm_Length(SCM_OPTARGS) > 2)
2537     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
2538   v_scm = SCM_ARGREF(0);
2539   if (!SCM_U32VECTORP(v_scm)) Scm_Error("<u32vector> required, but got %S", v_scm);
2540   v = SCM_U32VECTOR(v_scm);
2541   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
2542   else {
2543     start_scm = SCM_CAR(SCM_OPTARGS);
2544     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2545   }
2546   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
2547   start = SCM_INT_VALUE(start_scm);
2548   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
2549   else {
2550     end_scm = SCM_CAR(SCM_OPTARGS);
2551     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2552   }
2553   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
2554   end = SCM_INT_VALUE(end_scm);
2555   {
2556 {
2557 ScmObj SCM_RESULT;
2558 SCM_RESULT = Scm_U32VectorToList(v, start, end);
2559 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
2560 }
2561   }
2562 }
2563 
2564 static SCM_DEFINE_STRING_CONST(uvlib_u32vector_TOlist__NAME, "u32vector->list", 15, 15);
2565 static SCM_DEFINE_SUBR(uvlib_u32vector_TOlist__STUB, 1, 1, SCM_OBJ(&uvlib_u32vector_TOlist__NAME), uvlib_u32vector_TOlist, NULL, NULL);
2566 
2567 static ScmObj uvlib_list_TOu32vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2568 {
2569   ScmObj l_scm;
2570   ScmObj l;
2571   ScmObj clamp_scm;
2572   ScmObj clamp;
2573   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
2574   SCM_ENTER_SUBR("list->u32vector");
2575   if (Scm_Length(SCM_OPTARGS) > 1)
2576     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
2577   l_scm = SCM_ARGREF(0);
2578   if (!SCM_LISTP(l_scm)) Scm_Error("list required, but got %S", l_scm);
2579   l = (l_scm);
2580   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
2581   else {
2582     clamp_scm = SCM_CAR(SCM_OPTARGS);
2583     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2584   }
2585   clamp = (clamp_scm);
2586   {
2587 SCM_RETURN(Scm_ListToU32Vector(l, clamp_arg(clamp)));
2588   }
2589 }
2590 
2591 static SCM_DEFINE_STRING_CONST(uvlib_list_TOu32vector__NAME, "list->u32vector", 15, 15);
2592 static SCM_DEFINE_SUBR(uvlib_list_TOu32vector__STUB, 1, 1, SCM_OBJ(&uvlib_list_TOu32vector__NAME), uvlib_list_TOu32vector, NULL, NULL);
2593 
2594 static ScmObj uvlib_u32vector_fillX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2595 {
2596   ScmObj v_scm;
2597   ScmU32Vector* v;
2598   ScmObj val_scm;
2599   ScmObj val;
2600   ScmObj start_scm;
2601   int start;
2602   ScmObj end_scm;
2603   int end;
2604   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
2605   SCM_ENTER_SUBR("u32vector-fill!");
2606   if (Scm_Length(SCM_OPTARGS) > 2)
2607     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
2608   v_scm = SCM_ARGREF(0);
2609   if (!SCM_U32VECTORP(v_scm)) Scm_Error("<u32vector> required, but got %S", v_scm);
2610   v = SCM_U32VECTOR(v_scm);
2611   val_scm = SCM_ARGREF(1);
2612   val = (val_scm);
2613   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
2614   else {
2615     start_scm = SCM_CAR(SCM_OPTARGS);
2616     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2617   }
2618   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
2619   start = SCM_INT_VALUE(start_scm);
2620   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
2621   else {
2622     end_scm = SCM_CAR(SCM_OPTARGS);
2623     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2624   }
2625   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
2626   end = SCM_INT_VALUE(end_scm);
2627   {
2628 ScmUInt32 filler;
2629   filler = Scm_GetIntegerU32Clamp(val, SCM_CLAMP_ERROR, NULL);
2630   SCM_RETURN(Scm_U32VectorFill(v, filler, start, end));
2631   }
2632 }
2633 
2634 static SCM_DEFINE_STRING_CONST(uvlib_u32vector_fillX__NAME, "u32vector-fill!", 15, 15);
2635 static SCM_DEFINE_SUBR(uvlib_u32vector_fillX__STUB, 2, 1, SCM_OBJ(&uvlib_u32vector_fillX__NAME), uvlib_u32vector_fillX, NULL, NULL);
2636 
2637 static ScmObj uvlib_u32vector_TOvector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2638 {
2639   ScmObj v_scm;
2640   ScmU32Vector* v;
2641   ScmObj start_scm;
2642   int start;
2643   ScmObj end_scm;
2644   int end;
2645   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
2646   SCM_ENTER_SUBR("u32vector->vector");
2647   if (Scm_Length(SCM_OPTARGS) > 2)
2648     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
2649   v_scm = SCM_ARGREF(0);
2650   if (!SCM_U32VECTORP(v_scm)) Scm_Error("<u32vector> required, but got %S", v_scm);
2651   v = SCM_U32VECTOR(v_scm);
2652   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
2653   else {
2654     start_scm = SCM_CAR(SCM_OPTARGS);
2655     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2656   }
2657   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
2658   start = SCM_INT_VALUE(start_scm);
2659   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
2660   else {
2661     end_scm = SCM_CAR(SCM_OPTARGS);
2662     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2663   }
2664   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
2665   end = SCM_INT_VALUE(end_scm);
2666   {
2667 {
2668 ScmObj SCM_RESULT;
2669 SCM_RESULT = Scm_U32VectorToVector(v, start, end);
2670 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
2671 }
2672   }
2673 }
2674 
2675 static SCM_DEFINE_STRING_CONST(uvlib_u32vector_TOvector__NAME, "u32vector->vector", 17, 17);
2676 static SCM_DEFINE_SUBR(uvlib_u32vector_TOvector__STUB, 1, 1, SCM_OBJ(&uvlib_u32vector_TOvector__NAME), uvlib_u32vector_TOvector, NULL, NULL);
2677 
2678 static ScmObj uvlib_vector_TOu32vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2679 {
2680   ScmObj v_scm;
2681   ScmVector* v;
2682   ScmObj start_scm;
2683   int start;
2684   ScmObj end_scm;
2685   int end;
2686   ScmObj clamp_scm;
2687   ScmObj clamp;
2688   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
2689   SCM_ENTER_SUBR("vector->u32vector");
2690   if (Scm_Length(SCM_OPTARGS) > 3)
2691     Scm_Error("too many arguments: up to 3 is expected, %d given.", Scm_Length(SCM_OPTARGS));
2692   v_scm = SCM_ARGREF(0);
2693   if (!SCM_VECTORP(v_scm)) Scm_Error("vector required, but got %S", v_scm);
2694   v = SCM_VECTOR(v_scm);
2695   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
2696   else {
2697     start_scm = SCM_CAR(SCM_OPTARGS);
2698     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2699   }
2700   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
2701   start = SCM_INT_VALUE(start_scm);
2702   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
2703   else {
2704     end_scm = SCM_CAR(SCM_OPTARGS);
2705     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2706   }
2707   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
2708   end = SCM_INT_VALUE(end_scm);
2709   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
2710   else {
2711     clamp_scm = SCM_CAR(SCM_OPTARGS);
2712     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2713   }
2714   clamp = (clamp_scm);
2715   {
2716 SCM_RETURN(Scm_VectorToU32Vector(v, start, end, clamp_arg(clamp)));
2717   }
2718 }
2719 
2720 static SCM_DEFINE_STRING_CONST(uvlib_vector_TOu32vector__NAME, "vector->u32vector", 17, 17);
2721 static SCM_DEFINE_SUBR(uvlib_vector_TOu32vector__STUB, 1, 1, SCM_OBJ(&uvlib_vector_TOu32vector__NAME), uvlib_vector_TOu32vector, NULL, NULL);
2722 
2723 static ScmObj uvlib_s64vectorP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2724 {
2725   ScmObj obj_scm;
2726   ScmObj obj;
2727   SCM_ENTER_SUBR("s64vector?");
2728   obj_scm = SCM_ARGREF(0);
2729   obj = (obj_scm);
2730   {
2731 {
2732 int SCM_RESULT;
2733 SCM_RESULT = SCM_S64VECTORP(obj);
2734 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
2735 }
2736   }
2737 }
2738 
2739 static SCM_DEFINE_STRING_CONST(uvlib_s64vectorP__NAME, "s64vector?", 10, 10);
2740 static SCM_DEFINE_SUBR(uvlib_s64vectorP__STUB, 1, 0, SCM_OBJ(&uvlib_s64vectorP__NAME), uvlib_s64vectorP, NULL, NULL);
2741 
2742 static ScmObj uvlib_make_s64vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2743 {
2744   ScmObj length_scm;
2745   int length;
2746   ScmObj fill_scm;
2747   ScmObj fill;
2748   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
2749   SCM_ENTER_SUBR("make-s64vector");
2750   if (Scm_Length(SCM_OPTARGS) > 1)
2751     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
2752   length_scm = SCM_ARGREF(0);
2753   if (!SCM_INTP(length_scm)) Scm_Error("small integer required, but got %S", length_scm);
2754   length = SCM_INT_VALUE(length_scm);
2755   if (SCM_NULLP(SCM_OPTARGS)) fill_scm = Scm_MakeInteger(0);
2756   else {
2757     fill_scm = SCM_CAR(SCM_OPTARGS);
2758     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2759   }
2760   fill = (fill_scm);
2761   {
2762 ScmInt64 filler;
2763   filler = Scm_GetInteger64Clamp(fill, SCM_CLAMP_ERROR, NULL);
2764   SCM_RETURN(Scm_MakeS64Vector(length, filler));
2765   }
2766 }
2767 
2768 static SCM_DEFINE_STRING_CONST(uvlib_make_s64vector__NAME, "make-s64vector", 14, 14);
2769 static SCM_DEFINE_SUBR(uvlib_make_s64vector__STUB, 1, 1, SCM_OBJ(&uvlib_make_s64vector__NAME), uvlib_make_s64vector, NULL, NULL);
2770 
2771 static ScmObj uvlib_s64vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2772 {
2773   ScmObj args_scm;
2774   ScmObj args;
2775   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
2776   SCM_ENTER_SUBR("s64vector");
2777   args_scm = SCM_OPTARGS;
2778   args = (args_scm);
2779   {
2780 SCM_RETURN(Scm_ListToS64Vector(args, SCM_CLAMP_ERROR));
2781   }
2782 }
2783 
2784 static SCM_DEFINE_STRING_CONST(uvlib_s64vector__NAME, "s64vector", 9, 9);
2785 static SCM_DEFINE_SUBR(uvlib_s64vector__STUB, 0, 1, SCM_OBJ(&uvlib_s64vector__NAME), uvlib_s64vector, NULL, NULL);
2786 
2787 static ScmObj uvlib_s64vector_length(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2788 {
2789   ScmObj v_scm;
2790   ScmS64Vector* v;
2791   SCM_ENTER_SUBR("s64vector-length");
2792   v_scm = SCM_ARGREF(0);
2793   if (!SCM_S64VECTORP(v_scm)) Scm_Error("<s64vector> required, but got %S", v_scm);
2794   v = SCM_S64VECTOR(v_scm);
2795   {
2796 SCM_RETURN(SCM_MAKE_INT(SCM_S64VECTOR_SIZE(v)));
2797   }
2798 }
2799 
2800 static SCM_DEFINE_STRING_CONST(uvlib_s64vector_length__NAME, "s64vector-length", 16, 16);
2801 static SCM_DEFINE_SUBR(uvlib_s64vector_length__STUB, 1, 0, SCM_OBJ(&uvlib_s64vector_length__NAME), uvlib_s64vector_length, NULL, NULL);
2802 
2803 static ScmObj uvlib_s64vector_ref(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2804 {
2805   ScmObj v_scm;
2806   ScmS64Vector* v;
2807   ScmObj i_scm;
2808   int i;
2809   ScmObj fallback_scm;
2810   ScmObj fallback;
2811   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
2812   SCM_ENTER_SUBR("s64vector-ref");
2813   if (Scm_Length(SCM_OPTARGS) > 1)
2814     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
2815   v_scm = SCM_ARGREF(0);
2816   if (!SCM_S64VECTORP(v_scm)) Scm_Error("<s64vector> required, but got %S", v_scm);
2817   v = SCM_S64VECTOR(v_scm);
2818   i_scm = SCM_ARGREF(1);
2819   if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
2820   i = SCM_INT_VALUE(i_scm);
2821   if (SCM_NULLP(SCM_OPTARGS)) fallback_scm = SCM_UNBOUND;
2822   else {
2823     fallback_scm = SCM_CAR(SCM_OPTARGS);
2824     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2825   }
2826   fallback = (fallback_scm);
2827   {
2828 SCM_RETURN(Scm_S64VectorRef(v, i, fallback));
2829   }
2830 }
2831 
2832 static SCM_DEFINE_STRING_CONST(uvlib_s64vector_ref__NAME, "s64vector-ref", 13, 13);
2833 static SCM_DEFINE_SUBR(uvlib_s64vector_ref__STUB, 2, 1, SCM_OBJ(&uvlib_s64vector_ref__NAME), uvlib_s64vector_ref, NULL, NULL);
2834 
2835 static ScmObj uvlib_s64vector_setX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2836 {
2837   ScmObj v_scm;
2838   ScmS64Vector* v;
2839   ScmObj i_scm;
2840   int i;
2841   ScmObj val_scm;
2842   ScmObj val;
2843   ScmObj clamp_scm;
2844   ScmObj clamp;
2845   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
2846   SCM_ENTER_SUBR("s64vector-set!");
2847   if (Scm_Length(SCM_OPTARGS) > 1)
2848     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
2849   v_scm = SCM_ARGREF(0);
2850   if (!SCM_S64VECTORP(v_scm)) Scm_Error("<s64vector> required, but got %S", v_scm);
2851   v = SCM_S64VECTOR(v_scm);
2852   i_scm = SCM_ARGREF(1);
2853   if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
2854   i = SCM_INT_VALUE(i_scm);
2855   val_scm = SCM_ARGREF(2);
2856   val = (val_scm);
2857   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
2858   else {
2859     clamp_scm = SCM_CAR(SCM_OPTARGS);
2860     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2861   }
2862   clamp = (clamp_scm);
2863   {
2864 SCM_RETURN(Scm_S64VectorSet(v, i, val, clamp_arg(clamp)));
2865   }
2866 }
2867 
2868 static SCM_DEFINE_STRING_CONST(uvlib_s64vector_setX__NAME, "s64vector-set!", 14, 14);
2869 static SCM_DEFINE_SUBR(uvlib_s64vector_setX__STUB, 3, 1, SCM_OBJ(&uvlib_s64vector_setX__NAME), uvlib_s64vector_setX, NULL, NULL);
2870 
2871 static ScmObj uvlib_s64vector_copy(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2872 {
2873   ScmObj v_scm;
2874   ScmS64Vector* v;
2875   ScmObj start_scm;
2876   int start;
2877   ScmObj end_scm;
2878   int end;
2879   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
2880   SCM_ENTER_SUBR("s64vector-copy");
2881   if (Scm_Length(SCM_OPTARGS) > 2)
2882     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
2883   v_scm = SCM_ARGREF(0);
2884   if (!SCM_S64VECTORP(v_scm)) Scm_Error("<s64vector> required, but got %S", v_scm);
2885   v = SCM_S64VECTOR(v_scm);
2886   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
2887   else {
2888     start_scm = SCM_CAR(SCM_OPTARGS);
2889     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2890   }
2891   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
2892   start = SCM_INT_VALUE(start_scm);
2893   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
2894   else {
2895     end_scm = SCM_CAR(SCM_OPTARGS);
2896     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2897   }
2898   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
2899   end = SCM_INT_VALUE(end_scm);
2900   {
2901 {
2902 ScmObj SCM_RESULT;
2903 SCM_RESULT = Scm_S64VectorCopy(v, start, end);
2904 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
2905 }
2906   }
2907 }
2908 
2909 static SCM_DEFINE_STRING_CONST(uvlib_s64vector_copy__NAME, "s64vector-copy", 14, 14);
2910 static SCM_DEFINE_SUBR(uvlib_s64vector_copy__STUB, 1, 1, SCM_OBJ(&uvlib_s64vector_copy__NAME), uvlib_s64vector_copy, NULL, NULL);
2911 
2912 static ScmObj uvlib_s64vector_copyX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2913 {
2914   ScmObj dst_scm;
2915   ScmS64Vector* dst;
2916   ScmObj dstart_scm;
2917   ScmObj dstart;
2918   ScmObj src_scm;
2919   ScmObj src;
2920   ScmObj sstart_scm;
2921   int sstart;
2922   ScmObj send_scm;
2923   int send;
2924   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
2925   SCM_ENTER_SUBR("s64vector-copy!");
2926   if (Scm_Length(SCM_OPTARGS) > 3)
2927     Scm_Error("too many arguments: up to 3 is expected, %d given.", Scm_Length(SCM_OPTARGS));
2928   dst_scm = SCM_ARGREF(0);
2929   if (!SCM_S64VECTORP(dst_scm)) Scm_Error("<s64vector> required, but got %S", dst_scm);
2930   dst = SCM_S64VECTOR(dst_scm);
2931   dstart_scm = SCM_ARGREF(1);
2932   dstart = (dstart_scm);
2933   if (SCM_NULLP(SCM_OPTARGS)) src_scm = SCM_UNBOUND;
2934   else {
2935     src_scm = SCM_CAR(SCM_OPTARGS);
2936     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2937   }
2938   src = (src_scm);
2939   if (SCM_NULLP(SCM_OPTARGS)) sstart_scm = Scm_MakeInteger(0);
2940   else {
2941     sstart_scm = SCM_CAR(SCM_OPTARGS);
2942     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2943   }
2944   if (!SCM_EXACTP(sstart_scm)) Scm_Error("C integer required, but got %S", sstart_scm);
2945   sstart = Scm_GetInteger(sstart_scm);
2946   if (SCM_NULLP(SCM_OPTARGS)) send_scm = Scm_MakeInteger(-1);
2947   else {
2948     send_scm = SCM_CAR(SCM_OPTARGS);
2949     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2950   }
2951   if (!SCM_EXACTP(send_scm)) Scm_Error("C integer required, but got %S", send_scm);
2952   send = Scm_GetInteger(send_scm);
2953   {
2954 if (SCM_INTEGERP(dstart)) {
2955      /* new API */
2956      if (!SCM_S64VECTORP(src)) {
2957        Scm_Error("s64vector-copy!: argument is not a matching uvector: %S",
2958                  src);
2959      }
2960      SCM_RETURN(Scm_S64VectorCopyX(dst, Scm_GetInteger(dstart), 
2961                                     SCM_S64VECTOR(src), sstart, send));
2962   } else if (SCM_S64VECTORP(dstart)) {
2963     /* old API */
2964     SCM_RETURN(Scm_S64VectorCopyX(dst, 0, SCM_S64VECTOR(dstart), 0, -1));
2965   } else {
2966     Scm_Error("integer required, but got %S", dstart);
2967     SCM_RETURN(SCM_UNDEFINED);
2968   }
2969   }
2970 }
2971 
2972 static SCM_DEFINE_STRING_CONST(uvlib_s64vector_copyX__NAME, "s64vector-copy!", 15, 15);
2973 static SCM_DEFINE_SUBR(uvlib_s64vector_copyX__STUB, 2, 1, SCM_OBJ(&uvlib_s64vector_copyX__NAME), uvlib_s64vector_copyX, NULL, NULL);
2974 
2975 static ScmObj uvlib_s64vector_TOlist(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2976 {
2977   ScmObj v_scm;
2978   ScmS64Vector* v;
2979   ScmObj start_scm;
2980   int start;
2981   ScmObj end_scm;
2982   int end;
2983   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
2984   SCM_ENTER_SUBR("s64vector->list");
2985   if (Scm_Length(SCM_OPTARGS) > 2)
2986     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
2987   v_scm = SCM_ARGREF(0);
2988   if (!SCM_S64VECTORP(v_scm)) Scm_Error("<s64vector> required, but got %S", v_scm);
2989   v = SCM_S64VECTOR(v_scm);
2990   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
2991   else {
2992     start_scm = SCM_CAR(SCM_OPTARGS);
2993     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2994   }
2995   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
2996   start = SCM_INT_VALUE(start_scm);
2997   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
2998   else {
2999     end_scm = SCM_CAR(SCM_OPTARGS);
3000     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3001   }
3002   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
3003   end = SCM_INT_VALUE(end_scm);
3004   {
3005 {
3006 ScmObj SCM_RESULT;
3007 SCM_RESULT = Scm_S64VectorToList(v, start, end);
3008 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
3009 }
3010   }
3011 }
3012 
3013 static SCM_DEFINE_STRING_CONST(uvlib_s64vector_TOlist__NAME, "s64vector->list", 15, 15);
3014 static SCM_DEFINE_SUBR(uvlib_s64vector_TOlist__STUB, 1, 1, SCM_OBJ(&uvlib_s64vector_TOlist__NAME), uvlib_s64vector_TOlist, NULL, NULL);
3015 
3016 static ScmObj uvlib_list_TOs64vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3017 {
3018   ScmObj l_scm;
3019   ScmObj l;
3020   ScmObj clamp_scm;
3021   ScmObj clamp;
3022   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3023   SCM_ENTER_SUBR("list->s64vector");
3024   if (Scm_Length(SCM_OPTARGS) > 1)
3025     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3026   l_scm = SCM_ARGREF(0);
3027   if (!SCM_LISTP(l_scm)) Scm_Error("list required, but got %S", l_scm);
3028   l = (l_scm);
3029   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
3030   else {
3031     clamp_scm = SCM_CAR(SCM_OPTARGS);
3032     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3033   }
3034   clamp = (clamp_scm);
3035   {
3036 SCM_RETURN(Scm_ListToS64Vector(l, clamp_arg(clamp)));
3037   }
3038 }
3039 
3040 static SCM_DEFINE_STRING_CONST(uvlib_list_TOs64vector__NAME, "list->s64vector", 15, 15);
3041 static SCM_DEFINE_SUBR(uvlib_list_TOs64vector__STUB, 1, 1, SCM_OBJ(&uvlib_list_TOs64vector__NAME), uvlib_list_TOs64vector, NULL, NULL);
3042 
3043 static ScmObj uvlib_s64vector_fillX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3044 {
3045   ScmObj v_scm;
3046   ScmS64Vector* v;
3047   ScmObj val_scm;
3048   ScmObj val;
3049   ScmObj start_scm;
3050   int start;
3051   ScmObj end_scm;
3052   int end;
3053   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3054   SCM_ENTER_SUBR("s64vector-fill!");
3055   if (Scm_Length(SCM_OPTARGS) > 2)
3056     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3057   v_scm = SCM_ARGREF(0);
3058   if (!SCM_S64VECTORP(v_scm)) Scm_Error("<s64vector> required, but got %S", v_scm);
3059   v = SCM_S64VECTOR(v_scm);
3060   val_scm = SCM_ARGREF(1);
3061   val = (val_scm);
3062   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
3063   else {
3064     start_scm = SCM_CAR(SCM_OPTARGS);
3065     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3066   }
3067   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
3068   start = SCM_INT_VALUE(start_scm);
3069   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
3070   else {
3071     end_scm = SCM_CAR(SCM_OPTARGS);
3072     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3073   }
3074   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
3075   end = SCM_INT_VALUE(end_scm);
3076   {
3077 ScmInt64 filler;
3078   filler = Scm_GetInteger64Clamp(val, SCM_CLAMP_ERROR, NULL);
3079   SCM_RETURN(Scm_S64VectorFill(v, filler, start, end));
3080   }
3081 }
3082 
3083 static SCM_DEFINE_STRING_CONST(uvlib_s64vector_fillX__NAME, "s64vector-fill!", 15, 15);
3084 static SCM_DEFINE_SUBR(uvlib_s64vector_fillX__STUB, 2, 1, SCM_OBJ(&uvlib_s64vector_fillX__NAME), uvlib_s64vector_fillX, NULL, NULL);
3085 
3086 static ScmObj uvlib_s64vector_TOvector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3087 {
3088   ScmObj v_scm;
3089   ScmS64Vector* v;
3090   ScmObj start_scm;
3091   int start;
3092   ScmObj end_scm;
3093   int end;
3094   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3095   SCM_ENTER_SUBR("s64vector->vector");
3096   if (Scm_Length(SCM_OPTARGS) > 2)
3097     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3098   v_scm = SCM_ARGREF(0);
3099   if (!SCM_S64VECTORP(v_scm)) Scm_Error("<s64vector> required, but got %S", v_scm);
3100   v = SCM_S64VECTOR(v_scm);
3101   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
3102   else {
3103     start_scm = SCM_CAR(SCM_OPTARGS);
3104     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3105   }
3106   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
3107   start = SCM_INT_VALUE(start_scm);
3108   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
3109   else {
3110     end_scm = SCM_CAR(SCM_OPTARGS);
3111     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3112   }
3113   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
3114   end = SCM_INT_VALUE(end_scm);
3115   {
3116 {
3117 ScmObj SCM_RESULT;
3118 SCM_RESULT = Scm_S64VectorToVector(v, start, end);
3119 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
3120 }
3121   }
3122 }
3123 
3124 static SCM_DEFINE_STRING_CONST(uvlib_s64vector_TOvector__NAME, "s64vector->vector", 17, 17);
3125 static SCM_DEFINE_SUBR(uvlib_s64vector_TOvector__STUB, 1, 1, SCM_OBJ(&uvlib_s64vector_TOvector__NAME), uvlib_s64vector_TOvector, NULL, NULL);
3126 
3127 static ScmObj uvlib_vector_TOs64vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3128 {
3129   ScmObj v_scm;
3130   ScmVector* v;
3131   ScmObj start_scm;
3132   int start;
3133   ScmObj end_scm;
3134   int end;
3135   ScmObj clamp_scm;
3136   ScmObj clamp;
3137   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3138   SCM_ENTER_SUBR("vector->s64vector");
3139   if (Scm_Length(SCM_OPTARGS) > 3)
3140     Scm_Error("too many arguments: up to 3 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3141   v_scm = SCM_ARGREF(0);
3142   if (!SCM_VECTORP(v_scm)) Scm_Error("vector required, but got %S", v_scm);
3143   v = SCM_VECTOR(v_scm);
3144   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
3145   else {
3146     start_scm = SCM_CAR(SCM_OPTARGS);
3147     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3148   }
3149   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
3150   start = SCM_INT_VALUE(start_scm);
3151   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
3152   else {
3153     end_scm = SCM_CAR(SCM_OPTARGS);
3154     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3155   }
3156   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
3157   end = SCM_INT_VALUE(end_scm);
3158   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
3159   else {
3160     clamp_scm = SCM_CAR(SCM_OPTARGS);
3161     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3162   }
3163   clamp = (clamp_scm);
3164   {
3165 SCM_RETURN(Scm_VectorToS64Vector(v, start, end, clamp_arg(clamp)));
3166   }
3167 }
3168 
3169 static SCM_DEFINE_STRING_CONST(uvlib_vector_TOs64vector__NAME, "vector->s64vector", 17, 17);
3170 static SCM_DEFINE_SUBR(uvlib_vector_TOs64vector__STUB, 1, 1, SCM_OBJ(&uvlib_vector_TOs64vector__NAME), uvlib_vector_TOs64vector, NULL, NULL);
3171 
3172 static ScmObj uvlib_u64vectorP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3173 {
3174   ScmObj obj_scm;
3175   ScmObj obj;
3176   SCM_ENTER_SUBR("u64vector?");
3177   obj_scm = SCM_ARGREF(0);
3178   obj = (obj_scm);
3179   {
3180 {
3181 int SCM_RESULT;
3182 SCM_RESULT = SCM_U64VECTORP(obj);
3183 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
3184 }
3185   }
3186 }
3187 
3188 static SCM_DEFINE_STRING_CONST(uvlib_u64vectorP__NAME, "u64vector?", 10, 10);
3189 static SCM_DEFINE_SUBR(uvlib_u64vectorP__STUB, 1, 0, SCM_OBJ(&uvlib_u64vectorP__NAME), uvlib_u64vectorP, NULL, NULL);
3190 
3191 static ScmObj uvlib_make_u64vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3192 {
3193   ScmObj length_scm;
3194   int length;
3195   ScmObj fill_scm;
3196   ScmObj fill;
3197   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3198   SCM_ENTER_SUBR("make-u64vector");
3199   if (Scm_Length(SCM_OPTARGS) > 1)
3200     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3201   length_scm = SCM_ARGREF(0);
3202   if (!SCM_INTP(length_scm)) Scm_Error("small integer required, but got %S", length_scm);
3203   length = SCM_INT_VALUE(length_scm);
3204   if (SCM_NULLP(SCM_OPTARGS)) fill_scm = Scm_MakeInteger(0);
3205   else {
3206     fill_scm = SCM_CAR(SCM_OPTARGS);
3207     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3208   }
3209   fill = (fill_scm);
3210   {
3211 ScmUInt64 filler;
3212   filler = Scm_GetIntegerU64Clamp(fill, SCM_CLAMP_ERROR, NULL);
3213   SCM_RETURN(Scm_MakeU64Vector(length, filler));
3214   }
3215 }
3216 
3217 static SCM_DEFINE_STRING_CONST(uvlib_make_u64vector__NAME, "make-u64vector", 14, 14);
3218 static SCM_DEFINE_SUBR(uvlib_make_u64vector__STUB, 1, 1, SCM_OBJ(&uvlib_make_u64vector__NAME), uvlib_make_u64vector, NULL, NULL);
3219 
3220 static ScmObj uvlib_u64vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3221 {
3222   ScmObj args_scm;
3223   ScmObj args;
3224   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3225   SCM_ENTER_SUBR("u64vector");
3226   args_scm = SCM_OPTARGS;
3227   args = (args_scm);
3228   {
3229 SCM_RETURN(Scm_ListToU64Vector(args, SCM_CLAMP_ERROR));
3230   }
3231 }
3232 
3233 static SCM_DEFINE_STRING_CONST(uvlib_u64vector__NAME, "u64vector", 9, 9);
3234 static SCM_DEFINE_SUBR(uvlib_u64vector__STUB, 0, 1, SCM_OBJ(&uvlib_u64vector__NAME), uvlib_u64vector, NULL, NULL);
3235 
3236 static ScmObj uvlib_u64vector_length(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3237 {
3238   ScmObj v_scm;
3239   ScmU64Vector* v;
3240   SCM_ENTER_SUBR("u64vector-length");
3241   v_scm = SCM_ARGREF(0);
3242   if (!SCM_U64VECTORP(v_scm)) Scm_Error("<u64vector> required, but got %S", v_scm);
3243   v = SCM_U64VECTOR(v_scm);
3244   {
3245 SCM_RETURN(SCM_MAKE_INT(SCM_U64VECTOR_SIZE(v)));
3246   }
3247 }
3248 
3249 static SCM_DEFINE_STRING_CONST(uvlib_u64vector_length__NAME, "u64vector-length", 16, 16);
3250 static SCM_DEFINE_SUBR(uvlib_u64vector_length__STUB, 1, 0, SCM_OBJ(&uvlib_u64vector_length__NAME), uvlib_u64vector_length, NULL, NULL);
3251 
3252 static ScmObj uvlib_u64vector_ref(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3253 {
3254   ScmObj v_scm;
3255   ScmU64Vector* v;
3256   ScmObj i_scm;
3257   int i;
3258   ScmObj fallback_scm;
3259   ScmObj fallback;
3260   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3261   SCM_ENTER_SUBR("u64vector-ref");
3262   if (Scm_Length(SCM_OPTARGS) > 1)
3263     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3264   v_scm = SCM_ARGREF(0);
3265   if (!SCM_U64VECTORP(v_scm)) Scm_Error("<u64vector> required, but got %S", v_scm);
3266   v = SCM_U64VECTOR(v_scm);
3267   i_scm = SCM_ARGREF(1);
3268   if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
3269   i = SCM_INT_VALUE(i_scm);
3270   if (SCM_NULLP(SCM_OPTARGS)) fallback_scm = SCM_UNBOUND;
3271   else {
3272     fallback_scm = SCM_CAR(SCM_OPTARGS);
3273     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3274   }
3275   fallback = (fallback_scm);
3276   {
3277 SCM_RETURN(Scm_U64VectorRef(v, i, fallback));
3278   }
3279 }
3280 
3281 static SCM_DEFINE_STRING_CONST(uvlib_u64vector_ref__NAME, "u64vector-ref", 13, 13);
3282 static SCM_DEFINE_SUBR(uvlib_u64vector_ref__STUB, 2, 1, SCM_OBJ(&uvlib_u64vector_ref__NAME), uvlib_u64vector_ref, NULL, NULL);
3283 
3284 static ScmObj uvlib_u64vector_setX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3285 {
3286   ScmObj v_scm;
3287   ScmU64Vector* v;
3288   ScmObj i_scm;
3289   int i;
3290   ScmObj val_scm;
3291   ScmObj val;
3292   ScmObj clamp_scm;
3293   ScmObj clamp;
3294   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3295   SCM_ENTER_SUBR("u64vector-set!");
3296   if (Scm_Length(SCM_OPTARGS) > 1)
3297     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3298   v_scm = SCM_ARGREF(0);
3299   if (!SCM_U64VECTORP(v_scm)) Scm_Error("<u64vector> required, but got %S", v_scm);
3300   v = SCM_U64VECTOR(v_scm);
3301   i_scm = SCM_ARGREF(1);
3302   if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
3303   i = SCM_INT_VALUE(i_scm);
3304   val_scm = SCM_ARGREF(2);
3305   val = (val_scm);
3306   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
3307   else {
3308     clamp_scm = SCM_CAR(SCM_OPTARGS);
3309     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3310   }
3311   clamp = (clamp_scm);
3312   {
3313 SCM_RETURN(Scm_U64VectorSet(v, i, val, clamp_arg(clamp)));
3314   }
3315 }
3316 
3317 static SCM_DEFINE_STRING_CONST(uvlib_u64vector_setX__NAME, "u64vector-set!", 14, 14);
3318 static SCM_DEFINE_SUBR(uvlib_u64vector_setX__STUB, 3, 1, SCM_OBJ(&uvlib_u64vector_setX__NAME), uvlib_u64vector_setX, NULL, NULL);
3319 
3320 static ScmObj uvlib_u64vector_copy(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3321 {
3322   ScmObj v_scm;
3323   ScmU64Vector* v;
3324   ScmObj start_scm;
3325   int start;
3326   ScmObj end_scm;
3327   int end;
3328   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3329   SCM_ENTER_SUBR("u64vector-copy");
3330   if (Scm_Length(SCM_OPTARGS) > 2)
3331     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3332   v_scm = SCM_ARGREF(0);
3333   if (!SCM_U64VECTORP(v_scm)) Scm_Error("<u64vector> required, but got %S", v_scm);
3334   v = SCM_U64VECTOR(v_scm);
3335   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
3336   else {
3337     start_scm = SCM_CAR(SCM_OPTARGS);
3338     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3339   }
3340   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
3341   start = SCM_INT_VALUE(start_scm);
3342   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
3343   else {
3344     end_scm = SCM_CAR(SCM_OPTARGS);
3345     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3346   }
3347   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
3348   end = SCM_INT_VALUE(end_scm);
3349   {
3350 {
3351 ScmObj SCM_RESULT;
3352 SCM_RESULT = Scm_U64VectorCopy(v, start, end);
3353 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
3354 }
3355   }
3356 }
3357 
3358 static SCM_DEFINE_STRING_CONST(uvlib_u64vector_copy__NAME, "u64vector-copy", 14, 14);
3359 static SCM_DEFINE_SUBR(uvlib_u64vector_copy__STUB, 1, 1, SCM_OBJ(&uvlib_u64vector_copy__NAME), uvlib_u64vector_copy, NULL, NULL);
3360 
3361 static ScmObj uvlib_u64vector_copyX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3362 {
3363   ScmObj dst_scm;
3364   ScmU64Vector* dst;
3365   ScmObj dstart_scm;
3366   ScmObj dstart;
3367   ScmObj src_scm;
3368   ScmObj src;
3369   ScmObj sstart_scm;
3370   int sstart;
3371   ScmObj send_scm;
3372   int send;
3373   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3374   SCM_ENTER_SUBR("u64vector-copy!");
3375   if (Scm_Length(SCM_OPTARGS) > 3)
3376     Scm_Error("too many arguments: up to 3 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3377   dst_scm = SCM_ARGREF(0);
3378   if (!SCM_U64VECTORP(dst_scm)) Scm_Error("<u64vector> required, but got %S", dst_scm);
3379   dst = SCM_U64VECTOR(dst_scm);
3380   dstart_scm = SCM_ARGREF(1);
3381   dstart = (dstart_scm);
3382   if (SCM_NULLP(SCM_OPTARGS)) src_scm = SCM_UNBOUND;
3383   else {
3384     src_scm = SCM_CAR(SCM_OPTARGS);
3385     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3386   }
3387   src = (src_scm);
3388   if (SCM_NULLP(SCM_OPTARGS)) sstart_scm = Scm_MakeInteger(0);
3389   else {
3390     sstart_scm = SCM_CAR(SCM_OPTARGS);
3391     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3392   }
3393   if (!SCM_EXACTP(sstart_scm)) Scm_Error("C integer required, but got %S", sstart_scm);
3394   sstart = Scm_GetInteger(sstart_scm);
3395   if (SCM_NULLP(SCM_OPTARGS)) send_scm = Scm_MakeInteger(-1);
3396   else {
3397     send_scm = SCM_CAR(SCM_OPTARGS);
3398     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3399   }
3400   if (!SCM_EXACTP(send_scm)) Scm_Error("C integer required, but got %S", send_scm);
3401   send = Scm_GetInteger(send_scm);
3402   {
3403 if (SCM_INTEGERP(dstart)) {
3404      /* new API */
3405      if (!SCM_U64VECTORP(src)) {
3406        Scm_Error("u64vector-copy!: argument is not a matching uvector: %S",
3407                  src);
3408      }
3409      SCM_RETURN(Scm_U64VectorCopyX(dst, Scm_GetInteger(dstart), 
3410                                     SCM_U64VECTOR(src), sstart, send));
3411   } else if (SCM_U64VECTORP(dstart)) {
3412     /* old API */
3413     SCM_RETURN(Scm_U64VectorCopyX(dst, 0, SCM_U64VECTOR(dstart), 0, -1));
3414   } else {
3415     Scm_Error("integer required, but got %S", dstart);
3416     SCM_RETURN(SCM_UNDEFINED);
3417   }
3418   }
3419 }
3420 
3421 static SCM_DEFINE_STRING_CONST(uvlib_u64vector_copyX__NAME, "u64vector-copy!", 15, 15);
3422 static SCM_DEFINE_SUBR(uvlib_u64vector_copyX__STUB, 2, 1, SCM_OBJ(&uvlib_u64vector_copyX__NAME), uvlib_u64vector_copyX, NULL, NULL);
3423 
3424 static ScmObj uvlib_u64vector_TOlist(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3425 {
3426   ScmObj v_scm;
3427   ScmU64Vector* v;
3428   ScmObj start_scm;
3429   int start;
3430   ScmObj end_scm;
3431   int end;
3432   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3433   SCM_ENTER_SUBR("u64vector->list");
3434   if (Scm_Length(SCM_OPTARGS) > 2)
3435     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3436   v_scm = SCM_ARGREF(0);
3437   if (!SCM_U64VECTORP(v_scm)) Scm_Error("<u64vector> required, but got %S", v_scm);
3438   v = SCM_U64VECTOR(v_scm);
3439   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
3440   else {
3441     start_scm = SCM_CAR(SCM_OPTARGS);
3442     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3443   }
3444   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
3445   start = SCM_INT_VALUE(start_scm);
3446   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
3447   else {
3448     end_scm = SCM_CAR(SCM_OPTARGS);
3449     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3450   }
3451   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
3452   end = SCM_INT_VALUE(end_scm);
3453   {
3454 {
3455 ScmObj SCM_RESULT;
3456 SCM_RESULT = Scm_U64VectorToList(v, start, end);
3457 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
3458 }
3459   }
3460 }
3461 
3462 static SCM_DEFINE_STRING_CONST(uvlib_u64vector_TOlist__NAME, "u64vector->list", 15, 15);
3463 static SCM_DEFINE_SUBR(uvlib_u64vector_TOlist__STUB, 1, 1, SCM_OBJ(&uvlib_u64vector_TOlist__NAME), uvlib_u64vector_TOlist, NULL, NULL);
3464 
3465 static ScmObj uvlib_list_TOu64vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3466 {
3467   ScmObj l_scm;
3468   ScmObj l;
3469   ScmObj clamp_scm;
3470   ScmObj clamp;
3471   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3472   SCM_ENTER_SUBR("list->u64vector");
3473   if (Scm_Length(SCM_OPTARGS) > 1)
3474     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3475   l_scm = SCM_ARGREF(0);
3476   if (!SCM_LISTP(l_scm)) Scm_Error("list required, but got %S", l_scm);
3477   l = (l_scm);
3478   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
3479   else {
3480     clamp_scm = SCM_CAR(SCM_OPTARGS);
3481     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3482   }
3483   clamp = (clamp_scm);
3484   {
3485 SCM_RETURN(Scm_ListToU64Vector(l, clamp_arg(clamp)));
3486   }
3487 }
3488 
3489 static SCM_DEFINE_STRING_CONST(uvlib_list_TOu64vector__NAME, "list->u64vector", 15, 15);
3490 static SCM_DEFINE_SUBR(uvlib_list_TOu64vector__STUB, 1, 1, SCM_OBJ(&uvlib_list_TOu64vector__NAME), uvlib_list_TOu64vector, NULL, NULL);
3491 
3492 static ScmObj uvlib_u64vector_fillX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3493 {
3494   ScmObj v_scm;
3495   ScmU64Vector* v;
3496   ScmObj val_scm;
3497   ScmObj val;
3498   ScmObj start_scm;
3499   int start;
3500   ScmObj end_scm;
3501   int end;
3502   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3503   SCM_ENTER_SUBR("u64vector-fill!");
3504   if (Scm_Length(SCM_OPTARGS) > 2)
3505     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3506   v_scm = SCM_ARGREF(0);
3507   if (!SCM_U64VECTORP(v_scm)) Scm_Error("<u64vector> required, but got %S", v_scm);
3508   v = SCM_U64VECTOR(v_scm);
3509   val_scm = SCM_ARGREF(1);
3510   val = (val_scm);
3511   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
3512   else {
3513     start_scm = SCM_CAR(SCM_OPTARGS);
3514     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3515   }
3516   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
3517   start = SCM_INT_VALUE(start_scm);
3518   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
3519   else {
3520     end_scm = SCM_CAR(SCM_OPTARGS);
3521     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3522   }
3523   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
3524   end = SCM_INT_VALUE(end_scm);
3525   {
3526 ScmUInt64 filler;
3527   filler = Scm_GetIntegerU64Clamp(val, SCM_CLAMP_ERROR, NULL);
3528   SCM_RETURN(Scm_U64VectorFill(v, filler, start, end));
3529   }
3530 }
3531 
3532 static SCM_DEFINE_STRING_CONST(uvlib_u64vector_fillX__NAME, "u64vector-fill!", 15, 15);
3533 static SCM_DEFINE_SUBR(uvlib_u64vector_fillX__STUB, 2, 1, SCM_OBJ(&uvlib_u64vector_fillX__NAME), uvlib_u64vector_fillX, NULL, NULL);
3534 
3535 static ScmObj uvlib_u64vector_TOvector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3536 {
3537   ScmObj v_scm;
3538   ScmU64Vector* v;
3539   ScmObj start_scm;
3540   int start;
3541   ScmObj end_scm;
3542   int end;
3543   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3544   SCM_ENTER_SUBR("u64vector->vector");
3545   if (Scm_Length(SCM_OPTARGS) > 2)
3546     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3547   v_scm = SCM_ARGREF(0);
3548   if (!SCM_U64VECTORP(v_scm)) Scm_Error("<u64vector> required, but got %S", v_scm);
3549   v = SCM_U64VECTOR(v_scm);
3550   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
3551   else {
3552     start_scm = SCM_CAR(SCM_OPTARGS);
3553     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3554   }
3555   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
3556   start = SCM_INT_VALUE(start_scm);
3557   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
3558   else {
3559     end_scm = SCM_CAR(SCM_OPTARGS);
3560     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3561   }
3562   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
3563   end = SCM_INT_VALUE(end_scm);
3564   {
3565 {
3566 ScmObj SCM_RESULT;
3567 SCM_RESULT = Scm_U64VectorToVector(v, start, end);
3568 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
3569 }
3570   }
3571 }
3572 
3573 static SCM_DEFINE_STRING_CONST(uvlib_u64vector_TOvector__NAME, "u64vector->vector", 17, 17);
3574 static SCM_DEFINE_SUBR(uvlib_u64vector_TOvector__STUB, 1, 1, SCM_OBJ(&uvlib_u64vector_TOvector__NAME), uvlib_u64vector_TOvector, NULL, NULL);
3575 
3576 static ScmObj uvlib_vector_TOu64vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3577 {
3578   ScmObj v_scm;
3579   ScmVector* v;
3580   ScmObj start_scm;
3581   int start;
3582   ScmObj end_scm;
3583   int end;
3584   ScmObj clamp_scm;
3585   ScmObj clamp;
3586   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3587   SCM_ENTER_SUBR("vector->u64vector");
3588   if (Scm_Length(SCM_OPTARGS) > 3)
3589     Scm_Error("too many arguments: up to 3 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3590   v_scm = SCM_ARGREF(0);
3591   if (!SCM_VECTORP(v_scm)) Scm_Error("vector required, but got %S", v_scm);
3592   v = SCM_VECTOR(v_scm);
3593   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
3594   else {
3595     start_scm = SCM_CAR(SCM_OPTARGS);
3596     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3597   }
3598   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
3599   start = SCM_INT_VALUE(start_scm);
3600   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
3601   else {
3602     end_scm = SCM_CAR(SCM_OPTARGS);
3603     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3604   }
3605   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
3606   end = SCM_INT_VALUE(end_scm);
3607   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
3608   else {
3609     clamp_scm = SCM_CAR(SCM_OPTARGS);
3610     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3611   }
3612   clamp = (clamp_scm);
3613   {
3614 SCM_RETURN(Scm_VectorToU64Vector(v, start, end, clamp_arg(clamp)));
3615   }
3616 }
3617 
3618 static SCM_DEFINE_STRING_CONST(uvlib_vector_TOu64vector__NAME, "vector->u64vector", 17, 17);
3619 static SCM_DEFINE_SUBR(uvlib_vector_TOu64vector__STUB, 1, 1, SCM_OBJ(&uvlib_vector_TOu64vector__NAME), uvlib_vector_TOu64vector, NULL, NULL);
3620 
3621 static ScmObj uvlib_f32vectorP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3622 {
3623   ScmObj obj_scm;
3624   ScmObj obj;
3625   SCM_ENTER_SUBR("f32vector?");
3626   obj_scm = SCM_ARGREF(0);
3627   obj = (obj_scm);
3628   {
3629 {
3630 int SCM_RESULT;
3631 SCM_RESULT = SCM_F32VECTORP(obj);
3632 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
3633 }
3634   }
3635 }
3636 
3637 static SCM_DEFINE_STRING_CONST(uvlib_f32vectorP__NAME, "f32vector?", 10, 10);
3638 static SCM_DEFINE_SUBR(uvlib_f32vectorP__STUB, 1, 0, SCM_OBJ(&uvlib_f32vectorP__NAME), uvlib_f32vectorP, NULL, NULL);
3639 
3640 static ScmObj uvlib_make_f32vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3641 {
3642   ScmObj length_scm;
3643   int length;
3644   ScmObj fill_scm;
3645   ScmObj fill;
3646   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3647   SCM_ENTER_SUBR("make-f32vector");
3648   if (Scm_Length(SCM_OPTARGS) > 1)
3649     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3650   length_scm = SCM_ARGREF(0);
3651   if (!SCM_INTP(length_scm)) Scm_Error("small integer required, but got %S", length_scm);
3652   length = SCM_INT_VALUE(length_scm);
3653   if (SCM_NULLP(SCM_OPTARGS)) fill_scm = Scm_MakeInteger(0);
3654   else {
3655     fill_scm = SCM_CAR(SCM_OPTARGS);
3656     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3657   }
3658   fill = (fill_scm);
3659   {
3660 float filler;
3661   filler = (float)Scm_GetDouble(fill);
3662   SCM_RETURN(Scm_MakeF32Vector(length, filler));
3663   }
3664 }
3665 
3666 static SCM_DEFINE_STRING_CONST(uvlib_make_f32vector__NAME, "make-f32vector", 14, 14);
3667 static SCM_DEFINE_SUBR(uvlib_make_f32vector__STUB, 1, 1, SCM_OBJ(&uvlib_make_f32vector__NAME), uvlib_make_f32vector, NULL, NULL);
3668 
3669 static ScmObj uvlib_f32vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3670 {
3671   ScmObj args_scm;
3672   ScmObj args;
3673   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3674   SCM_ENTER_SUBR("f32vector");
3675   args_scm = SCM_OPTARGS;
3676   args = (args_scm);
3677   {
3678 SCM_RETURN(Scm_ListToF32Vector(args, SCM_CLAMP_ERROR));
3679   }
3680 }
3681 
3682 static SCM_DEFINE_STRING_CONST(uvlib_f32vector__NAME, "f32vector", 9, 9);
3683 static SCM_DEFINE_SUBR(uvlib_f32vector__STUB, 0, 1, SCM_OBJ(&uvlib_f32vector__NAME), uvlib_f32vector, NULL, NULL);
3684 
3685 static ScmObj uvlib_f32vector_length(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3686 {
3687   ScmObj v_scm;
3688   ScmF32Vector* v;
3689   SCM_ENTER_SUBR("f32vector-length");
3690   v_scm = SCM_ARGREF(0);
3691   if (!SCM_F32VECTORP(v_scm)) Scm_Error("<f32vector> required, but got %S", v_scm);
3692   v = SCM_F32VECTOR(v_scm);
3693   {
3694 SCM_RETURN(SCM_MAKE_INT(SCM_F32VECTOR_SIZE(v)));
3695   }
3696 }
3697 
3698 static SCM_DEFINE_STRING_CONST(uvlib_f32vector_length__NAME, "f32vector-length", 16, 16);
3699 static SCM_DEFINE_SUBR(uvlib_f32vector_length__STUB, 1, 0, SCM_OBJ(&uvlib_f32vector_length__NAME), uvlib_f32vector_length, NULL, NULL);
3700 
3701 static ScmObj uvlib_f32vector_ref(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3702 {
3703   ScmObj v_scm;
3704   ScmF32Vector* v;
3705   ScmObj i_scm;
3706   int i;
3707   ScmObj fallback_scm;
3708   ScmObj fallback;
3709   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3710   SCM_ENTER_SUBR("f32vector-ref");
3711   if (Scm_Length(SCM_OPTARGS) > 1)
3712     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3713   v_scm = SCM_ARGREF(0);
3714   if (!SCM_F32VECTORP(v_scm)) Scm_Error("<f32vector> required, but got %S", v_scm);
3715   v = SCM_F32VECTOR(v_scm);
3716   i_scm = SCM_ARGREF(1);
3717   if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
3718   i = SCM_INT_VALUE(i_scm);
3719   if (SCM_NULLP(SCM_OPTARGS)) fallback_scm = SCM_UNBOUND;
3720   else {
3721     fallback_scm = SCM_CAR(SCM_OPTARGS);
3722     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3723   }
3724   fallback = (fallback_scm);
3725   {
3726 SCM_RETURN(Scm_F32VectorRef(v, i, fallback));
3727   }
3728 }
3729 
3730 static SCM_DEFINE_STRING_CONST(uvlib_f32vector_ref__NAME, "f32vector-ref", 13, 13);
3731 static SCM_DEFINE_SUBR(uvlib_f32vector_ref__STUB, 2, 1, SCM_OBJ(&uvlib_f32vector_ref__NAME), uvlib_f32vector_ref, NULL, NULL);
3732 
3733 static ScmObj uvlib_f32vector_setX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3734 {
3735   ScmObj v_scm;
3736   ScmF32Vector* v;
3737   ScmObj i_scm;
3738   int i;
3739   ScmObj val_scm;
3740   ScmObj val;
3741   ScmObj clamp_scm;
3742   ScmObj clamp;
3743   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3744   SCM_ENTER_SUBR("f32vector-set!");
3745   if (Scm_Length(SCM_OPTARGS) > 1)
3746     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3747   v_scm = SCM_ARGREF(0);
3748   if (!SCM_F32VECTORP(v_scm)) Scm_Error("<f32vector> required, but got %S", v_scm);
3749   v = SCM_F32VECTOR(v_scm);
3750   i_scm = SCM_ARGREF(1);
3751   if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
3752   i = SCM_INT_VALUE(i_scm);
3753   val_scm = SCM_ARGREF(2);
3754   val = (val_scm);
3755   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
3756   else {
3757     clamp_scm = SCM_CAR(SCM_OPTARGS);
3758     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3759   }
3760   clamp = (clamp_scm);
3761   {
3762 SCM_RETURN(Scm_F32VectorSet(v, i, val, clamp_arg(clamp)));
3763   }
3764 }
3765 
3766 static SCM_DEFINE_STRING_CONST(uvlib_f32vector_setX__NAME, "f32vector-set!", 14, 14);
3767 static SCM_DEFINE_SUBR(uvlib_f32vector_setX__STUB, 3, 1, SCM_OBJ(&uvlib_f32vector_setX__NAME), uvlib_f32vector_setX, NULL, NULL);
3768 
3769 static ScmObj uvlib_f32vector_copy(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3770 {
3771   ScmObj v_scm;
3772   ScmF32Vector* v;
3773   ScmObj start_scm;
3774   int start;
3775   ScmObj end_scm;
3776   int end;
3777   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3778   SCM_ENTER_SUBR("f32vector-copy");
3779   if (Scm_Length(SCM_OPTARGS) > 2)
3780     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3781   v_scm = SCM_ARGREF(0);
3782   if (!SCM_F32VECTORP(v_scm)) Scm_Error("<f32vector> required, but got %S", v_scm);
3783   v = SCM_F32VECTOR(v_scm);
3784   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
3785   else {
3786     start_scm = SCM_CAR(SCM_OPTARGS);
3787     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3788   }
3789   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
3790   start = SCM_INT_VALUE(start_scm);
3791   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
3792   else {
3793     end_scm = SCM_CAR(SCM_OPTARGS);
3794     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3795   }
3796   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
3797   end = SCM_INT_VALUE(end_scm);
3798   {
3799 {
3800 ScmObj SCM_RESULT;
3801 SCM_RESULT = Scm_F32VectorCopy(v, start, end);
3802 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
3803 }
3804   }
3805 }
3806 
3807 static SCM_DEFINE_STRING_CONST(uvlib_f32vector_copy__NAME, "f32vector-copy", 14, 14);
3808 static SCM_DEFINE_SUBR(uvlib_f32vector_copy__STUB, 1, 1, SCM_OBJ(&uvlib_f32vector_copy__NAME), uvlib_f32vector_copy, NULL, NULL);
3809 
3810 static ScmObj uvlib_f32vector_copyX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3811 {
3812   ScmObj dst_scm;
3813   ScmF32Vector* dst;
3814   ScmObj dstart_scm;
3815   ScmObj dstart;
3816   ScmObj src_scm;
3817   ScmObj src;
3818   ScmObj sstart_scm;
3819   int sstart;
3820   ScmObj send_scm;
3821   int send;
3822   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3823   SCM_ENTER_SUBR("f32vector-copy!");
3824   if (Scm_Length(SCM_OPTARGS) > 3)
3825     Scm_Error("too many arguments: up to 3 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3826   dst_scm = SCM_ARGREF(0);
3827   if (!SCM_F32VECTORP(dst_scm)) Scm_Error("<f32vector> required, but got %S", dst_scm);
3828   dst = SCM_F32VECTOR(dst_scm);
3829   dstart_scm = SCM_ARGREF(1);
3830   dstart = (dstart_scm);
3831   if (SCM_NULLP(SCM_OPTARGS)) src_scm = SCM_UNBOUND;
3832   else {
3833     src_scm = SCM_CAR(SCM_OPTARGS);
3834     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3835   }
3836   src = (src_scm);
3837   if (SCM_NULLP(SCM_OPTARGS)) sstart_scm = Scm_MakeInteger(0);
3838   else {
3839     sstart_scm = SCM_CAR(SCM_OPTARGS);
3840     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3841   }
3842   if (!SCM_EXACTP(sstart_scm)) Scm_Error("C integer required, but got %S", sstart_scm);
3843   sstart = Scm_GetInteger(sstart_scm);
3844   if (SCM_NULLP(SCM_OPTARGS)) send_scm = Scm_MakeInteger(-1);
3845   else {
3846     send_scm = SCM_CAR(SCM_OPTARGS);
3847     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3848   }
3849   if (!SCM_EXACTP(send_scm)) Scm_Error("C integer required, but got %S", send_scm);
3850   send = Scm_GetInteger(send_scm);
3851   {
3852 if (SCM_INTEGERP(dstart)) {
3853      /* new API */
3854      if (!SCM_F32VECTORP(src)) {
3855        Scm_Error("f32vector-copy!: argument is not a matching uvector: %S",
3856                  src);
3857      }
3858      SCM_RETURN(Scm_F32VectorCopyX(dst, Scm_GetInteger(dstart), 
3859                                     SCM_F32VECTOR(src), sstart, send));
3860   } else if (SCM_F32VECTORP(dstart)) {
3861     /* old API */
3862     SCM_RETURN(Scm_F32VectorCopyX(dst, 0, SCM_F32VECTOR(dstart), 0, -1));
3863   } else {
3864     Scm_Error("integer required, but got %S", dstart);
3865     SCM_RETURN(SCM_UNDEFINED);
3866   }
3867   }
3868 }
3869 
3870 static SCM_DEFINE_STRING_CONST(uvlib_f32vector_copyX__NAME, "f32vector-copy!", 15, 15);
3871 static SCM_DEFINE_SUBR(uvlib_f32vector_copyX__STUB, 2, 1, SCM_OBJ(&uvlib_f32vector_copyX__NAME), uvlib_f32vector_copyX, NULL, NULL);
3872 
3873 static ScmObj uvlib_f32vector_TOlist(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3874 {
3875   ScmObj v_scm;
3876   ScmF32Vector* v;
3877   ScmObj start_scm;
3878   int start;
3879   ScmObj end_scm;
3880   int end;
3881   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3882   SCM_ENTER_SUBR("f32vector->list");
3883   if (Scm_Length(SCM_OPTARGS) > 2)
3884     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3885   v_scm = SCM_ARGREF(0);
3886   if (!SCM_F32VECTORP(v_scm)) Scm_Error("<f32vector> required, but got %S", v_scm);
3887   v = SCM_F32VECTOR(v_scm);
3888   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
3889   else {
3890     start_scm = SCM_CAR(SCM_OPTARGS);
3891     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3892   }
3893   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
3894   start = SCM_INT_VALUE(start_scm);
3895   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
3896   else {
3897     end_scm = SCM_CAR(SCM_OPTARGS);
3898     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3899   }
3900   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
3901   end = SCM_INT_VALUE(end_scm);
3902   {
3903 {
3904 ScmObj SCM_RESULT;
3905 SCM_RESULT = Scm_F32VectorToList(v, start, end);
3906 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
3907 }
3908   }
3909 }
3910 
3911 static SCM_DEFINE_STRING_CONST(uvlib_f32vector_TOlist__NAME, "f32vector->list", 15, 15);
3912 static SCM_DEFINE_SUBR(uvlib_f32vector_TOlist__STUB, 1, 1, SCM_OBJ(&uvlib_f32vector_TOlist__NAME), uvlib_f32vector_TOlist, NULL, NULL);
3913 
3914 static ScmObj uvlib_list_TOf32vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3915 {
3916   ScmObj l_scm;
3917   ScmObj l;
3918   ScmObj clamp_scm;
3919   ScmObj clamp;
3920   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3921   SCM_ENTER_SUBR("list->f32vector");
3922   if (Scm_Length(SCM_OPTARGS) > 1)
3923     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3924   l_scm = SCM_ARGREF(0);
3925   if (!SCM_LISTP(l_scm)) Scm_Error("list required, but got %S", l_scm);
3926   l = (l_scm);
3927   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
3928   else {
3929     clamp_scm = SCM_CAR(SCM_OPTARGS);
3930     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3931   }
3932   clamp = (clamp_scm);
3933   {
3934 SCM_RETURN(Scm_ListToF32Vector(l, clamp_arg(clamp)));
3935   }
3936 }
3937 
3938 static SCM_DEFINE_STRING_CONST(uvlib_list_TOf32vector__NAME, "list->f32vector", 15, 15);
3939 static SCM_DEFINE_SUBR(uvlib_list_TOf32vector__STUB, 1, 1, SCM_OBJ(&uvlib_list_TOf32vector__NAME), uvlib_list_TOf32vector, NULL, NULL);
3940 
3941 static ScmObj uvlib_f32vector_fillX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3942 {
3943   ScmObj v_scm;
3944   ScmF32Vector* v;
3945   ScmObj val_scm;
3946   ScmObj val;
3947   ScmObj start_scm;
3948   int start;
3949   ScmObj end_scm;
3950   int end;
3951   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3952   SCM_ENTER_SUBR("f32vector-fill!");
3953   if (Scm_Length(SCM_OPTARGS) > 2)
3954     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3955   v_scm = SCM_ARGREF(0);
3956   if (!SCM_F32VECTORP(v_scm)) Scm_Error("<f32vector> required, but got %S", v_scm);
3957   v = SCM_F32VECTOR(v_scm);
3958   val_scm = SCM_ARGREF(1);
3959   val = (val_scm);
3960   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
3961   else {
3962     start_scm = SCM_CAR(SCM_OPTARGS);
3963     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3964   }
3965   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
3966   start = SCM_INT_VALUE(start_scm);
3967   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
3968   else {
3969     end_scm = SCM_CAR(SCM_OPTARGS);
3970     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3971   }
3972   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
3973   end = SCM_INT_VALUE(end_scm);
3974   {
3975 float filler;
3976   filler = (float)Scm_GetDouble(val);
3977   SCM_RETURN(Scm_F32VectorFill(v, filler, start, end));
3978   }
3979 }
3980 
3981 static SCM_DEFINE_STRING_CONST(uvlib_f32vector_fillX__NAME, "f32vector-fill!", 15, 15);
3982 static SCM_DEFINE_SUBR(uvlib_f32vector_fillX__STUB, 2, 1, SCM_OBJ(&uvlib_f32vector_fillX__NAME), uvlib_f32vector_fillX, NULL, NULL);
3983 
3984 static ScmObj uvlib_f32vector_TOvector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3985 {
3986   ScmObj v_scm;
3987   ScmF32Vector* v;
3988   ScmObj start_scm;
3989   int start;
3990   ScmObj end_scm;
3991   int end;
3992   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3993   SCM_ENTER_SUBR("f32vector->vector");
3994   if (Scm_Length(SCM_OPTARGS) > 2)
3995     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3996   v_scm = SCM_ARGREF(0);
3997   if (!SCM_F32VECTORP(v_scm)) Scm_Error("<f32vector> required, but got %S", v_scm);
3998   v = SCM_F32VECTOR(v_scm);
3999   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
4000   else {
4001     start_scm = SCM_CAR(SCM_OPTARGS);
4002     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4003   }
4004   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
4005   start = SCM_INT_VALUE(start_scm);
4006   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
4007   else {
4008     end_scm = SCM_CAR(SCM_OPTARGS);
4009     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4010   }
4011   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
4012   end = SCM_INT_VALUE(end_scm);
4013   {
4014 {
4015 ScmObj SCM_RESULT;
4016 SCM_RESULT = Scm_F32VectorToVector(v, start, end);
4017 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
4018 }
4019   }
4020 }
4021 
4022 static SCM_DEFINE_STRING_CONST(uvlib_f32vector_TOvector__NAME, "f32vector->vector", 17, 17);
4023 static SCM_DEFINE_SUBR(uvlib_f32vector_TOvector__STUB, 1, 1, SCM_OBJ(&uvlib_f32vector_TOvector__NAME), uvlib_f32vector_TOvector, NULL, NULL);
4024 
4025 static ScmObj uvlib_vector_TOf32vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4026 {
4027   ScmObj v_scm;
4028   ScmVector* v;
4029   ScmObj start_scm;
4030   int start;
4031   ScmObj end_scm;
4032   int end;
4033   ScmObj clamp_scm;
4034   ScmObj clamp;
4035   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
4036   SCM_ENTER_SUBR("vector->f32vector");
4037   if (Scm_Length(SCM_OPTARGS) > 3)
4038     Scm_Error("too many arguments: up to 3 is expected, %d given.", Scm_Length(SCM_OPTARGS));
4039   v_scm = SCM_ARGREF(0);
4040   if (!SCM_VECTORP(v_scm)) Scm_Error("vector required, but got %S", v_scm);
4041   v = SCM_VECTOR(v_scm);
4042   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
4043   else {
4044     start_scm = SCM_CAR(SCM_OPTARGS);
4045     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4046   }
4047   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
4048   start = SCM_INT_VALUE(start_scm);
4049   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
4050   else {
4051     end_scm = SCM_CAR(SCM_OPTARGS);
4052     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4053   }
4054   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
4055   end = SCM_INT_VALUE(end_scm);
4056   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
4057   else {
4058     clamp_scm = SCM_CAR(SCM_OPTARGS);
4059     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4060   }
4061   clamp = (clamp_scm);
4062   {
4063 SCM_RETURN(Scm_VectorToF32Vector(v, start, end, clamp_arg(clamp)));
4064   }
4065 }
4066 
4067 static SCM_DEFINE_STRING_CONST(uvlib_vector_TOf32vector__NAME, "vector->f32vector", 17, 17);
4068 static SCM_DEFINE_SUBR(uvlib_vector_TOf32vector__STUB, 1, 1, SCM_OBJ(&uvlib_vector_TOf32vector__NAME), uvlib_vector_TOf32vector, NULL, NULL);
4069 
4070 static ScmObj uvlib_f64vectorP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4071 {
4072   ScmObj obj_scm;
4073   ScmObj obj;
4074   SCM_ENTER_SUBR("f64vector?");
4075   obj_scm = SCM_ARGREF(0);
4076   obj = (obj_scm);
4077   {
4078 {
4079 int SCM_RESULT;
4080 SCM_RESULT = SCM_F64VECTORP(obj);
4081 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
4082 }
4083   }
4084 }
4085 
4086 static SCM_DEFINE_STRING_CONST(uvlib_f64vectorP__NAME, "f64vector?", 10, 10);
4087 static SCM_DEFINE_SUBR(uvlib_f64vectorP__STUB, 1, 0, SCM_OBJ(&uvlib_f64vectorP__NAME), uvlib_f64vectorP, NULL, NULL);
4088 
4089 static ScmObj uvlib_make_f64vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4090 {
4091   ScmObj length_scm;
4092   int length;
4093   ScmObj fill_scm;
4094   ScmObj fill;
4095   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
4096   SCM_ENTER_SUBR("make-f64vector");
4097   if (Scm_Length(SCM_OPTARGS) > 1)
4098     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
4099   length_scm = SCM_ARGREF(0);
4100   if (!SCM_INTP(length_scm)) Scm_Error("small integer required, but got %S", length_scm);
4101   length = SCM_INT_VALUE(length_scm);
4102   if (SCM_NULLP(SCM_OPTARGS)) fill_scm = Scm_MakeInteger(0);
4103   else {
4104     fill_scm = SCM_CAR(SCM_OPTARGS);
4105     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4106   }
4107   fill = (fill_scm);
4108   {
4109 double filler;
4110   filler = Scm_GetDouble(fill);
4111   SCM_RETURN(Scm_MakeF64Vector(length, filler));
4112   }
4113 }
4114 
4115 static SCM_DEFINE_STRING_CONST(uvlib_make_f64vector__NAME, "make-f64vector", 14, 14);
4116 static SCM_DEFINE_SUBR(uvlib_make_f64vector__STUB, 1, 1, SCM_OBJ(&uvlib_make_f64vector__NAME), uvlib_make_f64vector, NULL, NULL);
4117 
4118 static ScmObj uvlib_f64vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4119 {
4120   ScmObj args_scm;
4121   ScmObj args;
4122   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
4123   SCM_ENTER_SUBR("f64vector");
4124   args_scm = SCM_OPTARGS;
4125   args = (args_scm);
4126   {
4127 SCM_RETURN(Scm_ListToF64Vector(args, SCM_CLAMP_ERROR));
4128   }
4129 }
4130 
4131 static SCM_DEFINE_STRING_CONST(uvlib_f64vector__NAME, "f64vector", 9, 9);
4132 static SCM_DEFINE_SUBR(uvlib_f64vector__STUB, 0, 1, SCM_OBJ(&uvlib_f64vector__NAME), uvlib_f64vector, NULL, NULL);
4133 
4134 static ScmObj uvlib_f64vector_length(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4135 {
4136   ScmObj v_scm;
4137   ScmF64Vector* v;
4138   SCM_ENTER_SUBR("f64vector-length");
4139   v_scm = SCM_ARGREF(0);
4140   if (!SCM_F64VECTORP(v_scm)) Scm_Error("<f64vector> required, but got %S", v_scm);
4141   v = SCM_F64VECTOR(v_scm);
4142   {
4143 SCM_RETURN(SCM_MAKE_INT(SCM_F64VECTOR_SIZE(v)));
4144   }
4145 }
4146 
4147 static SCM_DEFINE_STRING_CONST(uvlib_f64vector_length__NAME, "f64vector-length", 16, 16);
4148 static SCM_DEFINE_SUBR(uvlib_f64vector_length__STUB, 1, 0, SCM_OBJ(&uvlib_f64vector_length__NAME), uvlib_f64vector_length, NULL, NULL);
4149 
4150 static ScmObj uvlib_f64vector_ref(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4151 {
4152   ScmObj v_scm;
4153   ScmF64Vector* v;
4154   ScmObj i_scm;
4155   int i;
4156   ScmObj fallback_scm;
4157   ScmObj fallback;
4158   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
4159   SCM_ENTER_SUBR("f64vector-ref");
4160   if (Scm_Length(SCM_OPTARGS) > 1)
4161     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
4162   v_scm = SCM_ARGREF(0);
4163   if (!SCM_F64VECTORP(v_scm)) Scm_Error("<f64vector> required, but got %S", v_scm);
4164   v = SCM_F64VECTOR(v_scm);
4165   i_scm = SCM_ARGREF(1);
4166   if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
4167   i = SCM_INT_VALUE(i_scm);
4168   if (SCM_NULLP(SCM_OPTARGS)) fallback_scm = SCM_UNBOUND;
4169   else {
4170     fallback_scm = SCM_CAR(SCM_OPTARGS);
4171     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4172   }
4173   fallback = (fallback_scm);
4174   {
4175 SCM_RETURN(Scm_F64VectorRef(v, i, fallback));
4176   }
4177 }
4178 
4179 static SCM_DEFINE_STRING_CONST(uvlib_f64vector_ref__NAME, "f64vector-ref", 13, 13);
4180 static SCM_DEFINE_SUBR(uvlib_f64vector_ref__STUB, 2, 1, SCM_OBJ(&uvlib_f64vector_ref__NAME), uvlib_f64vector_ref, NULL, NULL);
4181 
4182 static ScmObj uvlib_f64vector_setX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4183 {
4184   ScmObj v_scm;
4185   ScmF64Vector* v;
4186   ScmObj i_scm;
4187   int i;
4188   ScmObj val_scm;
4189   ScmObj val;
4190   ScmObj clamp_scm;
4191   ScmObj clamp;
4192   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
4193   SCM_ENTER_SUBR("f64vector-set!");
4194   if (Scm_Length(SCM_OPTARGS) > 1)
4195     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
4196   v_scm = SCM_ARGREF(0);
4197   if (!SCM_F64VECTORP(v_scm)) Scm_Error("<f64vector> required, but got %S", v_scm);
4198   v = SCM_F64VECTOR(v_scm);
4199   i_scm = SCM_ARGREF(1);
4200   if (!SCM_INTP(i_scm)) Scm_Error("small integer required, but got %S", i_scm);
4201   i = SCM_INT_VALUE(i_scm);
4202   val_scm = SCM_ARGREF(2);
4203   val = (val_scm);
4204   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
4205   else {
4206     clamp_scm = SCM_CAR(SCM_OPTARGS);
4207     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4208   }
4209   clamp = (clamp_scm);
4210   {
4211 SCM_RETURN(Scm_F64VectorSet(v, i, val, clamp_arg(clamp)));
4212   }
4213 }
4214 
4215 static SCM_DEFINE_STRING_CONST(uvlib_f64vector_setX__NAME, "f64vector-set!", 14, 14);
4216 static SCM_DEFINE_SUBR(uvlib_f64vector_setX__STUB, 3, 1, SCM_OBJ(&uvlib_f64vector_setX__NAME), uvlib_f64vector_setX, NULL, NULL);
4217 
4218 static ScmObj uvlib_f64vector_copy(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4219 {
4220   ScmObj v_scm;
4221   ScmF64Vector* v;
4222   ScmObj start_scm;
4223   int start;
4224   ScmObj end_scm;
4225   int end;
4226   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
4227   SCM_ENTER_SUBR("f64vector-copy");
4228   if (Scm_Length(SCM_OPTARGS) > 2)
4229     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
4230   v_scm = SCM_ARGREF(0);
4231   if (!SCM_F64VECTORP(v_scm)) Scm_Error("<f64vector> required, but got %S", v_scm);
4232   v = SCM_F64VECTOR(v_scm);
4233   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
4234   else {
4235     start_scm = SCM_CAR(SCM_OPTARGS);
4236     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4237   }
4238   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
4239   start = SCM_INT_VALUE(start_scm);
4240   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
4241   else {
4242     end_scm = SCM_CAR(SCM_OPTARGS);
4243     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4244   }
4245   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
4246   end = SCM_INT_VALUE(end_scm);
4247   {
4248 {
4249 ScmObj SCM_RESULT;
4250 SCM_RESULT = Scm_F64VectorCopy(v, start, end);
4251 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
4252 }
4253   }
4254 }
4255 
4256 static SCM_DEFINE_STRING_CONST(uvlib_f64vector_copy__NAME, "f64vector-copy", 14, 14);
4257 static SCM_DEFINE_SUBR(uvlib_f64vector_copy__STUB, 1, 1, SCM_OBJ(&uvlib_f64vector_copy__NAME), uvlib_f64vector_copy, NULL, NULL);
4258 
4259 static ScmObj uvlib_f64vector_copyX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4260 {
4261   ScmObj dst_scm;
4262   ScmF64Vector* dst;
4263   ScmObj dstart_scm;
4264   ScmObj dstart;
4265   ScmObj src_scm;
4266   ScmObj src;
4267   ScmObj sstart_scm;
4268   int sstart;
4269   ScmObj send_scm;
4270   int send;
4271   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
4272   SCM_ENTER_SUBR("f64vector-copy!");
4273   if (Scm_Length(SCM_OPTARGS) > 3)
4274     Scm_Error("too many arguments: up to 3 is expected, %d given.", Scm_Length(SCM_OPTARGS));
4275   dst_scm = SCM_ARGREF(0);
4276   if (!SCM_F64VECTORP(dst_scm)) Scm_Error("<f64vector> required, but got %S", dst_scm);
4277   dst = SCM_F64VECTOR(dst_scm);
4278   dstart_scm = SCM_ARGREF(1);
4279   dstart = (dstart_scm);
4280   if (SCM_NULLP(SCM_OPTARGS)) src_scm = SCM_UNBOUND;
4281   else {
4282     src_scm = SCM_CAR(SCM_OPTARGS);
4283     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4284   }
4285   src = (src_scm);
4286   if (SCM_NULLP(SCM_OPTARGS)) sstart_scm = Scm_MakeInteger(0);
4287   else {
4288     sstart_scm = SCM_CAR(SCM_OPTARGS);
4289     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4290   }
4291   if (!SCM_EXACTP(sstart_scm)) Scm_Error("C integer required, but got %S", sstart_scm);
4292   sstart = Scm_GetInteger(sstart_scm);
4293   if (SCM_NULLP(SCM_OPTARGS)) send_scm = Scm_MakeInteger(-1);
4294   else {
4295     send_scm = SCM_CAR(SCM_OPTARGS);
4296     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4297   }
4298   if (!SCM_EXACTP(send_scm)) Scm_Error("C integer required, but got %S", send_scm);
4299   send = Scm_GetInteger(send_scm);
4300   {
4301 if (SCM_INTEGERP(dstart)) {
4302      /* new API */
4303      if (!SCM_F64VECTORP(src)) {
4304        Scm_Error("f64vector-copy!: argument is not a matching uvector: %S",
4305                  src);
4306      }
4307      SCM_RETURN(Scm_F64VectorCopyX(dst, Scm_GetInteger(dstart), 
4308                                     SCM_F64VECTOR(src), sstart, send));
4309   } else if (SCM_F64VECTORP(dstart)) {
4310     /* old API */
4311     SCM_RETURN(Scm_F64VectorCopyX(dst, 0, SCM_F64VECTOR(dstart), 0, -1));
4312   } else {
4313     Scm_Error("integer required, but got %S", dstart);
4314     SCM_RETURN(SCM_UNDEFINED);
4315   }
4316   }
4317 }
4318 
4319 static SCM_DEFINE_STRING_CONST(uvlib_f64vector_copyX__NAME, "f64vector-copy!", 15, 15);
4320 static SCM_DEFINE_SUBR(uvlib_f64vector_copyX__STUB, 2, 1, SCM_OBJ(&uvlib_f64vector_copyX__NAME), uvlib_f64vector_copyX, NULL, NULL);
4321 
4322 static ScmObj uvlib_f64vector_TOlist(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4323 {
4324   ScmObj v_scm;
4325   ScmF64Vector* v;
4326   ScmObj start_scm;
4327   int start;
4328   ScmObj end_scm;
4329   int end;
4330   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
4331   SCM_ENTER_SUBR("f64vector->list");
4332   if (Scm_Length(SCM_OPTARGS) > 2)
4333     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
4334   v_scm = SCM_ARGREF(0);
4335   if (!SCM_F64VECTORP(v_scm)) Scm_Error("<f64vector> required, but got %S", v_scm);
4336   v = SCM_F64VECTOR(v_scm);
4337   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
4338   else {
4339     start_scm = SCM_CAR(SCM_OPTARGS);
4340     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4341   }
4342   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
4343   start = SCM_INT_VALUE(start_scm);
4344   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
4345   else {
4346     end_scm = SCM_CAR(SCM_OPTARGS);
4347     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4348   }
4349   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
4350   end = SCM_INT_VALUE(end_scm);
4351   {
4352 {
4353 ScmObj SCM_RESULT;
4354 SCM_RESULT = Scm_F64VectorToList(v, start, end);
4355 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
4356 }
4357   }
4358 }
4359 
4360 static SCM_DEFINE_STRING_CONST(uvlib_f64vector_TOlist__NAME, "f64vector->list", 15, 15);
4361 static SCM_DEFINE_SUBR(uvlib_f64vector_TOlist__STUB, 1, 1, SCM_OBJ(&uvlib_f64vector_TOlist__NAME), uvlib_f64vector_TOlist, NULL, NULL);
4362 
4363 static ScmObj uvlib_list_TOf64vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4364 {
4365   ScmObj l_scm;
4366   ScmObj l;
4367   ScmObj clamp_scm;
4368   ScmObj clamp;
4369   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
4370   SCM_ENTER_SUBR("list->f64vector");
4371   if (Scm_Length(SCM_OPTARGS) > 1)
4372     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
4373   l_scm = SCM_ARGREF(0);
4374   if (!SCM_LISTP(l_scm)) Scm_Error("list required, but got %S", l_scm);
4375   l = (l_scm);
4376   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
4377   else {
4378     clamp_scm = SCM_CAR(SCM_OPTARGS);
4379     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4380   }
4381   clamp = (clamp_scm);
4382   {
4383 SCM_RETURN(Scm_ListToF64Vector(l, clamp_arg(clamp)));
4384   }
4385 }
4386 
4387 static SCM_DEFINE_STRING_CONST(uvlib_list_TOf64vector__NAME, "list->f64vector", 15, 15);
4388 static SCM_DEFINE_SUBR(uvlib_list_TOf64vector__STUB, 1, 1, SCM_OBJ(&uvlib_list_TOf64vector__NAME), uvlib_list_TOf64vector, NULL, NULL);
4389 
4390 static ScmObj uvlib_f64vector_fillX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4391 {
4392   ScmObj v_scm;
4393   ScmF64Vector* v;
4394   ScmObj val_scm;
4395   ScmObj val;
4396   ScmObj start_scm;
4397   int start;
4398   ScmObj end_scm;
4399   int end;
4400   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
4401   SCM_ENTER_SUBR("f64vector-fill!");
4402   if (Scm_Length(SCM_OPTARGS) > 2)
4403     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
4404   v_scm = SCM_ARGREF(0);
4405   if (!SCM_F64VECTORP(v_scm)) Scm_Error("<f64vector> required, but got %S", v_scm);
4406   v = SCM_F64VECTOR(v_scm);
4407   val_scm = SCM_ARGREF(1);
4408   val = (val_scm);
4409   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
4410   else {
4411     start_scm = SCM_CAR(SCM_OPTARGS);
4412     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4413   }
4414   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
4415   start = SCM_INT_VALUE(start_scm);
4416   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
4417   else {
4418     end_scm = SCM_CAR(SCM_OPTARGS);
4419     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4420   }
4421   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
4422   end = SCM_INT_VALUE(end_scm);
4423   {
4424 double filler;
4425   filler = Scm_GetDouble(val);
4426   SCM_RETURN(Scm_F64VectorFill(v, filler, start, end));
4427   }
4428 }
4429 
4430 static SCM_DEFINE_STRING_CONST(uvlib_f64vector_fillX__NAME, "f64vector-fill!", 15, 15);
4431 static SCM_DEFINE_SUBR(uvlib_f64vector_fillX__STUB, 2, 1, SCM_OBJ(&uvlib_f64vector_fillX__NAME), uvlib_f64vector_fillX, NULL, NULL);
4432 
4433 static ScmObj uvlib_f64vector_TOvector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4434 {
4435   ScmObj v_scm;
4436   ScmF64Vector* v;
4437   ScmObj start_scm;
4438   int start;
4439   ScmObj end_scm;
4440   int end;
4441   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
4442   SCM_ENTER_SUBR("f64vector->vector");
4443   if (Scm_Length(SCM_OPTARGS) > 2)
4444     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
4445   v_scm = SCM_ARGREF(0);
4446   if (!SCM_F64VECTORP(v_scm)) Scm_Error("<f64vector> required, but got %S", v_scm);
4447   v = SCM_F64VECTOR(v_scm);
4448   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
4449   else {
4450     start_scm = SCM_CAR(SCM_OPTARGS);
4451     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4452   }
4453   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
4454   start = SCM_INT_VALUE(start_scm);
4455   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
4456   else {
4457     end_scm = SCM_CAR(SCM_OPTARGS);
4458     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4459   }
4460   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
4461   end = SCM_INT_VALUE(end_scm);
4462   {
4463 {
4464 ScmObj SCM_RESULT;
4465 SCM_RESULT = Scm_F64VectorToVector(v, start, end);
4466 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
4467 }
4468   }
4469 }
4470 
4471 static SCM_DEFINE_STRING_CONST(uvlib_f64vector_TOvector__NAME, "f64vector->vector", 17, 17);
4472 static SCM_DEFINE_SUBR(uvlib_f64vector_TOvector__STUB, 1, 1, SCM_OBJ(&uvlib_f64vector_TOvector__NAME), uvlib_f64vector_TOvector, NULL, NULL);
4473 
4474 static ScmObj uvlib_vector_TOf64vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4475 {
4476   ScmObj v_scm;
4477   ScmVector* v;
4478   ScmObj start_scm;
4479   int start;
4480   ScmObj end_scm;
4481   int end;
4482   ScmObj clamp_scm;
4483   ScmObj clamp;
4484   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
4485   SCM_ENTER_SUBR("vector->f64vector");
4486   if (Scm_Length(SCM_OPTARGS) > 3)
4487     Scm_Error("too many arguments: up to 3 is expected, %d given.", Scm_Length(SCM_OPTARGS));
4488   v_scm = SCM_ARGREF(0);
4489   if (!SCM_VECTORP(v_scm)) Scm_Error("vector required, but got %S", v_scm);
4490   v = SCM_VECTOR(v_scm);
4491   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
4492   else {
4493     start_scm = SCM_CAR(SCM_OPTARGS);
4494     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4495   }
4496   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
4497   start = SCM_INT_VALUE(start_scm);
4498   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
4499   else {
4500     end_scm = SCM_CAR(SCM_OPTARGS);
4501     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4502   }
4503   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
4504   end = SCM_INT_VALUE(end_scm);
4505   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
4506   else {
4507     clamp_scm = SCM_CAR(SCM_OPTARGS);
4508     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4509   }
4510   clamp = (clamp_scm);
4511   {
4512 SCM_RETURN(Scm_VectorToF64Vector(v, start, end, clamp_arg(clamp)));
4513   }
4514 }
4515 
4516 static SCM_DEFINE_STRING_CONST(uvlib_vector_TOf64vector__NAME, "vector->f64vector", 17, 17);
4517 static SCM_DEFINE_SUBR(uvlib_vector_TOf64vector__STUB, 1, 1, SCM_OBJ(&uvlib_vector_TOf64vector__NAME), uvlib_vector_TOf64vector, NULL, NULL);
4518 
4519 static ScmObj uvlib_s8vector_add(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4520 {
4521   ScmObj v0_scm;
4522   ScmS8Vector* v0;
4523   ScmObj v1_scm;
4524   ScmObj v1;
4525   ScmObj clamp_scm;
4526   ScmObj clamp;
4527   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
4528   SCM_ENTER_SUBR("s8vector-add");
4529   if (Scm_Length(SCM_OPTARGS) > 1)
4530     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
4531   v0_scm = SCM_ARGREF(0);
4532   if (!SCM_S8VECTORP(v0_scm)) Scm_Error("<s8vector> required, but got %S", v0_scm);
4533   v0 = SCM_S8VECTOR(v0_scm);
4534   v1_scm = SCM_ARGREF(1);
4535   v1 = (v1_scm);
4536   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
4537   else {
4538     clamp_scm = SCM_CAR(SCM_OPTARGS);
4539     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4540   }
4541   clamp = (clamp_scm);
4542   {
4543 SCM_RETURN(Scm_S8VectorAdd(v0, v1, clamp_arg(clamp)));
4544   }
4545 }
4546 
4547 static SCM_DEFINE_STRING_CONST(uvlib_s8vector_add__NAME, "s8vector-add", 12, 12);
4548 static SCM_DEFINE_SUBR(uvlib_s8vector_add__STUB, 2, 1, SCM_OBJ(&uvlib_s8vector_add__NAME), uvlib_s8vector_add, NULL, NULL);
4549 
4550 static ScmObj uvlib_s8vector_addX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4551 {
4552   ScmObj v0_scm;
4553   ScmS8Vector* v0;
4554   ScmObj v1_scm;
4555   ScmObj v1;
4556   ScmObj clamp_scm;
4557   ScmObj clamp;
4558   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
4559   SCM_ENTER_SUBR("s8vector-add!");
4560   if (Scm_Length(SCM_OPTARGS) > 1)
4561     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
4562   v0_scm = SCM_ARGREF(0);
4563   if (!SCM_S8VECTORP(v0_scm)) Scm_Error("<s8vector> required, but got %S", v0_scm);
4564   v0 = SCM_S8VECTOR(v0_scm);
4565   v1_scm = SCM_ARGREF(1);
4566   v1 = (v1_scm);
4567   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
4568   else {
4569     clamp_scm = SCM_CAR(SCM_OPTARGS);
4570     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4571   }
4572   clamp = (clamp_scm);
4573   {
4574 SCM_RETURN(Scm_S8VectorAddX(v0, v1, clamp_arg(clamp)));
4575   }
4576 }
4577 
4578 static SCM_DEFINE_STRING_CONST(uvlib_s8vector_addX__NAME, "s8vector-add!", 13, 13);
4579 static SCM_DEFINE_SUBR(uvlib_s8vector_addX__STUB, 2, 1, SCM_OBJ(&uvlib_s8vector_addX__NAME), uvlib_s8vector_addX, NULL, NULL);
4580 
4581 static ScmObj uvlib_u8vector_add(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4582 {
4583   ScmObj v0_scm;
4584   ScmU8Vector* v0;
4585   ScmObj v1_scm;
4586   ScmObj v1;
4587   ScmObj clamp_scm;
4588   ScmObj clamp;
4589   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
4590   SCM_ENTER_SUBR("u8vector-add");
4591   if (Scm_Length(SCM_OPTARGS) > 1)
4592     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
4593   v0_scm = SCM_ARGREF(0);
4594   if (!SCM_U8VECTORP(v0_scm)) Scm_Error("<u8vector> required, but got %S", v0_scm);
4595   v0 = SCM_U8VECTOR(v0_scm);
4596   v1_scm = SCM_ARGREF(1);
4597   v1 = (v1_scm);
4598   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
4599   else {
4600     clamp_scm = SCM_CAR(SCM_OPTARGS);
4601     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4602   }
4603   clamp = (clamp_scm);
4604   {
4605 SCM_RETURN(Scm_U8VectorAdd(v0, v1, clamp_arg(clamp)));
4606   }
4607 }
4608 
4609 static SCM_DEFINE_STRING_CONST(uvlib_u8vector_add__NAME, "u8vector-add", 12, 12);
4610 static SCM_DEFINE_SUBR(uvlib_u8vector_add__STUB, 2, 1, SCM_OBJ(&uvlib_u8vector_add__NAME), uvlib_u8vector_add, NULL, NULL);
4611 
4612 static ScmObj uvlib_u8vector_addX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4613 {
4614   ScmObj v0_scm;
4615   ScmU8Vector* v0;
4616   ScmObj v1_scm;
4617   ScmObj v1;
4618   ScmObj clamp_scm;
4619   ScmObj clamp;
4620   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
4621   SCM_ENTER_SUBR("u8vector-add!");
4622   if (Scm_Length(SCM_OPTARGS) > 1)
4623     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
4624   v0_scm = SCM_ARGREF(0);
4625   if (!SCM_U8VECTORP(v0_scm)) Scm_Error("<u8vector> required, but got %S", v0_scm);
4626   v0 = SCM_U8VECTOR(v0_scm);
4627   v1_scm = SCM_ARGREF(1);
4628   v1 = (v1_scm);
4629   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
4630   else {
4631     clamp_scm = SCM_CAR(SCM_OPTARGS);
4632     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4633   }
4634   clamp = (clamp_scm);
4635   {
4636 SCM_RETURN(Scm_U8VectorAddX(v0, v1, clamp_arg(clamp)));
4637   }
4638 }
4639 
4640 static SCM_DEFINE_STRING_CONST(uvlib_u8vector_addX__NAME, "u8vector-add!", 13, 13);
4641 static SCM_DEFINE_SUBR(uvlib_u8vector_addX__STUB, 2, 1, SCM_OBJ(&uvlib_u8vector_addX__NAME), uvlib_u8vector_addX, NULL, NULL);
4642 
4643 static ScmObj uvlib_s16vector_add(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4644 {
4645   ScmObj v0_scm;
4646   ScmS16Vector* v0;
4647   ScmObj v1_scm;
4648   ScmObj v1;
4649   ScmObj clamp_scm;
4650   ScmObj clamp;
4651   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
4652   SCM_ENTER_SUBR("s16vector-add");
4653   if (Scm_Length(SCM_OPTARGS) > 1)
4654     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
4655   v0_scm = SCM_ARGREF(0);
4656   if (!SCM_S16VECTORP(v0_scm)) Scm_Error("<s16vector> required, but got %S", v0_scm);
4657   v0 = SCM_S16VECTOR(v0_scm);
4658   v1_scm = SCM_ARGREF(1);
4659   v1 = (v1_scm);
4660   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
4661   else {
4662     clamp_scm = SCM_CAR(SCM_OPTARGS);
4663     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4664   }
4665   clamp = (clamp_scm);
4666   {
4667 SCM_RETURN(Scm_S16VectorAdd(v0, v1, clamp_arg(clamp)));
4668   }
4669 }
4670 
4671 static SCM_DEFINE_STRING_CONST(uvlib_s16vector_add__NAME, "s16vector-add", 13, 13);
4672 static SCM_DEFINE_SUBR(uvlib_s16vector_add__STUB, 2, 1, SCM_OBJ(&uvlib_s16vector_add__NAME), uvlib_s16vector_add, NULL, NULL);
4673 
4674 static ScmObj uvlib_s16vector_addX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4675 {
4676   ScmObj v0_scm;
4677   ScmS16Vector* v0;
4678   ScmObj v1_scm;
4679   ScmObj v1;
4680   ScmObj clamp_scm;
4681   ScmObj clamp;
4682   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
4683   SCM_ENTER_SUBR("s16vector-add!");
4684   if (Scm_Length(SCM_OPTARGS) > 1)
4685     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
4686   v0_scm = SCM_ARGREF(0);
4687   if (!SCM_S16VECTORP(v0_scm)) Scm_Error("<s16vector> required, but got %S", v0_scm);
4688   v0 = SCM_S16VECTOR(v0_scm);
4689   v1_scm = SCM_ARGREF(1);
4690   v1 = (v1_scm);
4691   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
4692   else {
4693     clamp_scm = SCM_CAR(SCM_OPTARGS);
4694     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4695   }
4696   clamp = (clamp_scm);
4697   {
4698 SCM_RETURN(Scm_S16VectorAddX(v0, v1, clamp_arg(clamp)));
4699   }
4700 }
4701 
4702 static SCM_DEFINE_STRING_CONST(uvlib_s16vector_addX__NAME, "s16vector-add!", 14, 14);
4703 static SCM_DEFINE_SUBR(uvlib_s16vector_addX__STUB, 2, 1, SCM_OBJ(&uvlib_s16vector_addX__NAME), uvlib_s16vector_addX, NULL, NULL);
4704 
4705 static ScmObj uvlib_u16vector_add(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4706 {
4707   ScmObj v0_scm;
4708   ScmU16Vector* v0;
4709   ScmObj v1_scm;
4710   ScmObj v1;
4711   ScmObj clamp_scm;
4712   ScmObj clamp;
4713   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
4714   SCM_ENTER_SUBR("u16vector-add");
4715   if (Scm_Length(SCM_OPTARGS) > 1)
4716     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
4717   v0_scm = SCM_ARGREF(0);
4718   if (!SCM_U16VECTORP(v0_scm)) Scm_Error("<u16vector> required, but got %S", v0_scm);
4719   v0 = SCM_U16VECTOR(v0_scm);
4720   v1_scm = SCM_ARGREF(1);
4721   v1 = (v1_scm);
4722   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
4723   else {
4724     clamp_scm = SCM_CAR(SCM_OPTARGS);
4725     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4726   }
4727   clamp = (clamp_scm);
4728   {
4729 SCM_RETURN(Scm_U16VectorAdd(v0, v1, clamp_arg(clamp)));
4730   }
4731 }
4732 
4733 static SCM_DEFINE_STRING_CONST(uvlib_u16vector_add__NAME, "u16vector-add", 13, 13);
4734 static SCM_DEFINE_SUBR(uvlib_u16vector_add__STUB, 2, 1, SCM_OBJ(&uvlib_u16vector_add__NAME), uvlib_u16vector_add, NULL, NULL);
4735 
4736 static ScmObj uvlib_u16vector_addX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4737 {
4738   ScmObj v0_scm;
4739   ScmU16Vector* v0;
4740   ScmObj v1_scm;
4741   ScmObj v1;
4742   ScmObj clamp_scm;
4743   ScmObj clamp;
4744   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
4745   SCM_ENTER_SUBR("u16vector-add!");
4746   if (Scm_Length(SCM_OPTARGS) > 1)
4747     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
4748   v0_scm = SCM_ARGREF(0);
4749   if (!SCM_U16VECTORP(v0_scm)) Scm_Error("<u16vector> required, but got %S", v0_scm);
4750   v0 = SCM_U16VECTOR(v0_scm);
4751   v1_scm = SCM_ARGREF(1);
4752   v1 = (v1_scm);
4753   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
4754   else {
4755     clamp_scm = SCM_CAR(SCM_OPTARGS);
4756     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4757   }
4758   clamp = (clamp_scm);
4759   {
4760 SCM_RETURN(Scm_U16VectorAddX(v0, v1, clamp_arg(clamp)));
4761   }
4762 }
4763 
4764 static SCM_DEFINE_STRING_CONST(uvlib_u16vector_addX__NAME, "u16vector-add!", 14, 14);
4765 static SCM_DEFINE_SUBR(uvlib_u16vector_addX__STUB, 2, 1, SCM_OBJ(&uvlib_u16vector_addX__NAME), uvlib_u16vector_addX, NULL, NULL);
4766 
4767 static ScmObj uvlib_s32vector_add(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4768 {
4769   ScmObj v0_scm;
4770   ScmS32Vector* v0;
4771   ScmObj v1_scm;
4772   ScmObj v1;
4773   ScmObj clamp_scm;
4774   ScmObj clamp;
4775   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
4776   SCM_ENTER_SUBR("s32vector-add");
4777   if (Scm_Length(SCM_OPTARGS) > 1)
4778     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
4779   v0_scm = SCM_ARGREF(0);
4780   if (!SCM_S32VECTORP(v0_scm)) Scm_Error("<s32vector> required, but got %S", v0_scm);
4781   v0 = SCM_S32VECTOR(v0_scm);
4782   v1_scm = SCM_ARGREF(1);
4783   v1 = (v1_scm);
4784   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
4785   else {
4786     clamp_scm = SCM_CAR(SCM_OPTARGS);
4787     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4788   }
4789   clamp = (clamp_scm);
4790   {
4791 SCM_RETURN(Scm_S32VectorAdd(v0, v1, clamp_arg(clamp)));
4792   }
4793 }
4794 
4795 static SCM_DEFINE_STRING_CONST(uvlib_s32vector_add__NAME, "s32vector-add", 13, 13);
4796 static SCM_DEFINE_SUBR(uvlib_s32vector_add__STUB, 2, 1, SCM_OBJ(&uvlib_s32vector_add__NAME), uvlib_s32vector_add, NULL, NULL);
4797 
4798 static ScmObj uvlib_s32vector_addX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4799 {
4800   ScmObj v0_scm;
4801   ScmS32Vector* v0;
4802   ScmObj v1_scm;
4803   ScmObj v1;
4804   ScmObj clamp_scm;
4805   ScmObj clamp;
4806   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
4807   SCM_ENTER_SUBR("s32vector-add!");
4808   if (Scm_Length(SCM_OPTARGS) > 1)
4809     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
4810   v0_scm = SCM_ARGREF(0);
4811   if (!SCM_S32VECTORP(v0_scm)) Scm_Error("<s32vector> required, but got %S", v0_scm);
4812   v0 = SCM_S32VECTOR(v0_scm);
4813   v1_scm = SCM_ARGREF(1);
4814   v1 = (v1_scm);
4815   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
4816   else {
4817     clamp_scm = SCM_CAR(SCM_OPTARGS);
4818     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4819   }
4820   clamp = (clamp_scm);
4821   {
4822 SCM_RETURN(Scm_S32VectorAddX(v0, v1, clamp_arg(clamp)));
4823   }
4824 }
4825 
4826 static SCM_DEFINE_STRING_CONST(uvlib_s32vector_addX__NAME, "s32vector-add!", 14, 14);
4827 static SCM_DEFINE_SUBR(uvlib_s32vector_addX__STUB, 2, 1, SCM_OBJ(&uvlib_s32vector_addX__NAME), uvlib_s32vector_addX, NULL, NULL);
4828 
4829 static ScmObj uvlib_u32vector_add(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4830 {
4831   ScmObj v0_scm;
4832   ScmU32Vector* v0;
4833   ScmObj v1_scm;
4834   ScmObj v1;
4835   ScmObj clamp_scm;
4836   ScmObj clamp;
4837   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
4838   SCM_ENTER_SUBR("u32vector-add");
4839   if (Scm_Length(SCM_OPTARGS) > 1)
4840     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
4841   v0_scm = SCM_ARGREF(0);
4842   if (!SCM_U32VECTORP(v0_scm)) Scm_Error("<u32vector> required, but got %S", v0_scm);
4843   v0 = SCM_U32VECTOR(v0_scm);
4844   v1_scm = SCM_ARGREF(1);
4845   v1 = (v1_scm);
4846   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
4847   else {
4848     clamp_scm = SCM_CAR(SCM_OPTARGS);
4849     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4850   }
4851   clamp = (clamp_scm);
4852   {
4853 SCM_RETURN(Scm_U32VectorAdd(v0, v1, clamp_arg(clamp)));
4854   }
4855 }
4856 
4857 static SCM_DEFINE_STRING_CONST(uvlib_u32vector_add__NAME, "u32vector-add", 13, 13);
4858 static SCM_DEFINE_SUBR(uvlib_u32vector_add__STUB, 2, 1, SCM_OBJ(&uvlib_u32vector_add__NAME), uvlib_u32vector_add, NULL, NULL);
4859 
4860 static ScmObj uvlib_u32vector_addX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4861 {
4862   ScmObj v0_scm;
4863   ScmU32Vector* v0;
4864   ScmObj v1_scm;
4865   ScmObj v1;
4866   ScmObj clamp_scm;
4867   ScmObj clamp;
4868   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
4869   SCM_ENTER_SUBR("u32vector-add!");
4870   if (Scm_Length(SCM_OPTARGS) > 1)
4871     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
4872   v0_scm = SCM_ARGREF(0);
4873   if (!SCM_U32VECTORP(v0_scm)) Scm_Error("<u32vector> required, but got %S", v0_scm);
4874   v0 = SCM_U32VECTOR(v0_scm);
4875   v1_scm = SCM_ARGREF(1);
4876   v1 = (v1_scm);
4877   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
4878   else {
4879     clamp_scm = SCM_CAR(SCM_OPTARGS);
4880     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4881   }
4882   clamp = (clamp_scm);
4883   {
4884 SCM_RETURN(Scm_U32VectorAddX(v0, v1, clamp_arg(clamp)));
4885   }
4886 }
4887 
4888 static SCM_DEFINE_STRING_CONST(uvlib_u32vector_addX__NAME, "u32vector-add!", 14, 14);
4889 static SCM_DEFINE_SUBR(uvlib_u32vector_addX__STUB, 2, 1, SCM_OBJ(&uvlib_u32vector_addX__NAME), uvlib_u32vector_addX, NULL, NULL);
4890 
4891 static ScmObj uvlib_s64vector_add(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4892 {
4893   ScmObj v0_scm;
4894   ScmS64Vector* v0;
4895   ScmObj v1_scm;
4896   ScmObj v1;
4897   ScmObj clamp_scm;
4898   ScmObj clamp;
4899   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
4900   SCM_ENTER_SUBR("s64vector-add");
4901   if (Scm_Length(SCM_OPTARGS) > 1)
4902     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
4903   v0_scm = SCM_ARGREF(0);
4904   if (!SCM_S64VECTORP(v0_scm)) Scm_Error("<s64vector> required, but got %S", v0_scm);
4905   v0 = SCM_S64VECTOR(v0_scm);
4906   v1_scm = SCM_ARGREF(1);
4907   v1 = (v1_scm);
4908   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
4909   else {
4910     clamp_scm = SCM_CAR(SCM_OPTARGS);
4911     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4912   }
4913   clamp = (clamp_scm);
4914   {
4915 SCM_RETURN(Scm_S64VectorAdd(v0, v1, clamp_arg(clamp)));
4916   }
4917 }
4918 
4919 static SCM_DEFINE_STRING_CONST(uvlib_s64vector_add__NAME, "s64vector-add", 13, 13);
4920 static SCM_DEFINE_SUBR(uvlib_s64vector_add__STUB, 2, 1, SCM_OBJ(&uvlib_s64vector_add__NAME), uvlib_s64vector_add, NULL, NULL);
4921 
4922 static ScmObj uvlib_s64vector_addX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4923 {
4924   ScmObj v0_scm;
4925   ScmS64Vector* v0;
4926   ScmObj v1_scm;
4927   ScmObj v1;
4928   ScmObj clamp_scm;
4929   ScmObj clamp;
4930   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
4931   SCM_ENTER_SUBR("s64vector-add!");
4932   if (Scm_Length(SCM_OPTARGS) > 1)
4933     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
4934   v0_scm = SCM_ARGREF(0);
4935   if (!SCM_S64VECTORP(v0_scm)) Scm_Error("<s64vector> required, but got %S", v0_scm);
4936   v0 = SCM_S64VECTOR(v0_scm);
4937   v1_scm = SCM_ARGREF(1);
4938   v1 = (v1_scm);
4939   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
4940   else {
4941     clamp_scm = SCM_CAR(SCM_OPTARGS);
4942     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4943   }
4944   clamp = (clamp_scm);
4945   {
4946 SCM_RETURN(Scm_S64VectorAddX(v0, v1, clamp_arg(clamp)));
4947   }
4948 }
4949 
4950 static SCM_DEFINE_STRING_CONST(uvlib_s64vector_addX__NAME, "s64vector-add!", 14, 14);
4951 static SCM_DEFINE_SUBR(uvlib_s64vector_addX__STUB, 2, 1, SCM_OBJ(&uvlib_s64vector_addX__NAME), uvlib_s64vector_addX, NULL, NULL);
4952 
4953 static ScmObj uvlib_u64vector_add(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4954 {
4955   ScmObj v0_scm;
4956   ScmU64Vector* v0;
4957   ScmObj v1_scm;
4958   ScmObj v1;
4959   ScmObj clamp_scm;
4960   ScmObj clamp;
4961   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
4962   SCM_ENTER_SUBR("u64vector-add");
4963   if (Scm_Length(SCM_OPTARGS) > 1)
4964     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
4965   v0_scm = SCM_ARGREF(0);
4966   if (!SCM_U64VECTORP(v0_scm)) Scm_Error("<u64vector> required, but got %S", v0_scm);
4967   v0 = SCM_U64VECTOR(v0_scm);
4968   v1_scm = SCM_ARGREF(1);
4969   v1 = (v1_scm);
4970   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
4971   else {
4972     clamp_scm = SCM_CAR(SCM_OPTARGS);
4973     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
4974   }
4975   clamp = (clamp_scm);
4976   {
4977 SCM_RETURN(Scm_U64VectorAdd(v0, v1, clamp_arg(clamp)));
4978   }
4979 }
4980 
4981 static SCM_DEFINE_STRING_CONST(uvlib_u64vector_add__NAME, "u64vector-add", 13, 13);
4982 static SCM_DEFINE_SUBR(uvlib_u64vector_add__STUB, 2, 1, SCM_OBJ(&uvlib_u64vector_add__NAME), uvlib_u64vector_add, NULL, NULL);
4983 
4984 static ScmObj uvlib_u64vector_addX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
4985 {
4986   ScmObj v0_scm;
4987   ScmU64Vector* v0;
4988   ScmObj v1_scm;
4989   ScmObj v1;
4990   ScmObj clamp_scm;
4991   ScmObj clamp;
4992   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
4993   SCM_ENTER_SUBR("u64vector-add!");
4994   if (Scm_Length(SCM_OPTARGS) > 1)
4995     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
4996   v0_scm = SCM_ARGREF(0);
4997   if (!SCM_U64VECTORP(v0_scm)) Scm_Error("<u64vector> required, but got %S", v0_scm);
4998   v0 = SCM_U64VECTOR(v0_scm);
4999   v1_scm = SCM_ARGREF(1);
5000   v1 = (v1_scm);
5001   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5002   else {
5003     clamp_scm = SCM_CAR(SCM_OPTARGS);
5004     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5005   }
5006   clamp = (clamp_scm);
5007   {
5008 SCM_RETURN(Scm_U64VectorAddX(v0, v1, clamp_arg(clamp)));
5009   }
5010 }
5011 
5012 static SCM_DEFINE_STRING_CONST(uvlib_u64vector_addX__NAME, "u64vector-add!", 14, 14);
5013 static SCM_DEFINE_SUBR(uvlib_u64vector_addX__STUB, 2, 1, SCM_OBJ(&uvlib_u64vector_addX__NAME), uvlib_u64vector_addX, NULL, NULL);
5014 
5015 static ScmObj uvlib_f32vector_add(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5016 {
5017   ScmObj v0_scm;
5018   ScmF32Vector* v0;
5019   ScmObj v1_scm;
5020   ScmObj v1;
5021   ScmObj clamp_scm;
5022   ScmObj clamp;
5023   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5024   SCM_ENTER_SUBR("f32vector-add");
5025   if (Scm_Length(SCM_OPTARGS) > 1)
5026     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5027   v0_scm = SCM_ARGREF(0);
5028   if (!SCM_F32VECTORP(v0_scm)) Scm_Error("<f32vector> required, but got %S", v0_scm);
5029   v0 = SCM_F32VECTOR(v0_scm);
5030   v1_scm = SCM_ARGREF(1);
5031   v1 = (v1_scm);
5032   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5033   else {
5034     clamp_scm = SCM_CAR(SCM_OPTARGS);
5035     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5036   }
5037   clamp = (clamp_scm);
5038   {
5039 SCM_RETURN(Scm_F32VectorAdd(v0, v1, clamp_arg(clamp)));
5040   }
5041 }
5042 
5043 static SCM_DEFINE_STRING_CONST(uvlib_f32vector_add__NAME, "f32vector-add", 13, 13);
5044 static SCM_DEFINE_SUBR(uvlib_f32vector_add__STUB, 2, 1, SCM_OBJ(&uvlib_f32vector_add__NAME), uvlib_f32vector_add, NULL, NULL);
5045 
5046 static ScmObj uvlib_f32vector_addX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5047 {
5048   ScmObj v0_scm;
5049   ScmF32Vector* v0;
5050   ScmObj v1_scm;
5051   ScmObj v1;
5052   ScmObj clamp_scm;
5053   ScmObj clamp;
5054   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5055   SCM_ENTER_SUBR("f32vector-add!");
5056   if (Scm_Length(SCM_OPTARGS) > 1)
5057     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5058   v0_scm = SCM_ARGREF(0);
5059   if (!SCM_F32VECTORP(v0_scm)) Scm_Error("<f32vector> required, but got %S", v0_scm);
5060   v0 = SCM_F32VECTOR(v0_scm);
5061   v1_scm = SCM_ARGREF(1);
5062   v1 = (v1_scm);
5063   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5064   else {
5065     clamp_scm = SCM_CAR(SCM_OPTARGS);
5066     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5067   }
5068   clamp = (clamp_scm);
5069   {
5070 SCM_RETURN(Scm_F32VectorAddX(v0, v1, clamp_arg(clamp)));
5071   }
5072 }
5073 
5074 static SCM_DEFINE_STRING_CONST(uvlib_f32vector_addX__NAME, "f32vector-add!", 14, 14);
5075 static SCM_DEFINE_SUBR(uvlib_f32vector_addX__STUB, 2, 1, SCM_OBJ(&uvlib_f32vector_addX__NAME), uvlib_f32vector_addX, NULL, NULL);
5076 
5077 static ScmObj uvlib_f64vector_add(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5078 {
5079   ScmObj v0_scm;
5080   ScmF64Vector* v0;
5081   ScmObj v1_scm;
5082   ScmObj v1;
5083   ScmObj clamp_scm;
5084   ScmObj clamp;
5085   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5086   SCM_ENTER_SUBR("f64vector-add");
5087   if (Scm_Length(SCM_OPTARGS) > 1)
5088     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5089   v0_scm = SCM_ARGREF(0);
5090   if (!SCM_F64VECTORP(v0_scm)) Scm_Error("<f64vector> required, but got %S", v0_scm);
5091   v0 = SCM_F64VECTOR(v0_scm);
5092   v1_scm = SCM_ARGREF(1);
5093   v1 = (v1_scm);
5094   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5095   else {
5096     clamp_scm = SCM_CAR(SCM_OPTARGS);
5097     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5098   }
5099   clamp = (clamp_scm);
5100   {
5101 SCM_RETURN(Scm_F64VectorAdd(v0, v1, clamp_arg(clamp)));
5102   }
5103 }
5104 
5105 static SCM_DEFINE_STRING_CONST(uvlib_f64vector_add__NAME, "f64vector-add", 13, 13);
5106 static SCM_DEFINE_SUBR(uvlib_f64vector_add__STUB, 2, 1, SCM_OBJ(&uvlib_f64vector_add__NAME), uvlib_f64vector_add, NULL, NULL);
5107 
5108 static ScmObj uvlib_f64vector_addX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5109 {
5110   ScmObj v0_scm;
5111   ScmF64Vector* v0;
5112   ScmObj v1_scm;
5113   ScmObj v1;
5114   ScmObj clamp_scm;
5115   ScmObj clamp;
5116   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5117   SCM_ENTER_SUBR("f64vector-add!");
5118   if (Scm_Length(SCM_OPTARGS) > 1)
5119     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5120   v0_scm = SCM_ARGREF(0);
5121   if (!SCM_F64VECTORP(v0_scm)) Scm_Error("<f64vector> required, but got %S", v0_scm);
5122   v0 = SCM_F64VECTOR(v0_scm);
5123   v1_scm = SCM_ARGREF(1);
5124   v1 = (v1_scm);
5125   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5126   else {
5127     clamp_scm = SCM_CAR(SCM_OPTARGS);
5128     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5129   }
5130   clamp = (clamp_scm);
5131   {
5132 SCM_RETURN(Scm_F64VectorAddX(v0, v1, clamp_arg(clamp)));
5133   }
5134 }
5135 
5136 static SCM_DEFINE_STRING_CONST(uvlib_f64vector_addX__NAME, "f64vector-add!", 14, 14);
5137 static SCM_DEFINE_SUBR(uvlib_f64vector_addX__STUB, 2, 1, SCM_OBJ(&uvlib_f64vector_addX__NAME), uvlib_f64vector_addX, NULL, NULL);
5138 
5139 static ScmObj uvlib_s8vector_sub(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5140 {
5141   ScmObj v0_scm;
5142   ScmS8Vector* v0;
5143   ScmObj v1_scm;
5144   ScmObj v1;
5145   ScmObj clamp_scm;
5146   ScmObj clamp;
5147   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5148   SCM_ENTER_SUBR("s8vector-sub");
5149   if (Scm_Length(SCM_OPTARGS) > 1)
5150     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5151   v0_scm = SCM_ARGREF(0);
5152   if (!SCM_S8VECTORP(v0_scm)) Scm_Error("<s8vector> required, but got %S", v0_scm);
5153   v0 = SCM_S8VECTOR(v0_scm);
5154   v1_scm = SCM_ARGREF(1);
5155   v1 = (v1_scm);
5156   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5157   else {
5158     clamp_scm = SCM_CAR(SCM_OPTARGS);
5159     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5160   }
5161   clamp = (clamp_scm);
5162   {
5163 SCM_RETURN(Scm_S8VectorSub(v0, v1, clamp_arg(clamp)));
5164   }
5165 }
5166 
5167 static SCM_DEFINE_STRING_CONST(uvlib_s8vector_sub__NAME, "s8vector-sub", 12, 12);
5168 static SCM_DEFINE_SUBR(uvlib_s8vector_sub__STUB, 2, 1, SCM_OBJ(&uvlib_s8vector_sub__NAME), uvlib_s8vector_sub, NULL, NULL);
5169 
5170 static ScmObj uvlib_s8vector_subX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5171 {
5172   ScmObj v0_scm;
5173   ScmS8Vector* v0;
5174   ScmObj v1_scm;
5175   ScmObj v1;
5176   ScmObj clamp_scm;
5177   ScmObj clamp;
5178   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5179   SCM_ENTER_SUBR("s8vector-sub!");
5180   if (Scm_Length(SCM_OPTARGS) > 1)
5181     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5182   v0_scm = SCM_ARGREF(0);
5183   if (!SCM_S8VECTORP(v0_scm)) Scm_Error("<s8vector> required, but got %S", v0_scm);
5184   v0 = SCM_S8VECTOR(v0_scm);
5185   v1_scm = SCM_ARGREF(1);
5186   v1 = (v1_scm);
5187   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5188   else {
5189     clamp_scm = SCM_CAR(SCM_OPTARGS);
5190     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5191   }
5192   clamp = (clamp_scm);
5193   {
5194 SCM_RETURN(Scm_S8VectorSubX(v0, v1, clamp_arg(clamp)));
5195   }
5196 }
5197 
5198 static SCM_DEFINE_STRING_CONST(uvlib_s8vector_subX__NAME, "s8vector-sub!", 13, 13);
5199 static SCM_DEFINE_SUBR(uvlib_s8vector_subX__STUB, 2, 1, SCM_OBJ(&uvlib_s8vector_subX__NAME), uvlib_s8vector_subX, NULL, NULL);
5200 
5201 static ScmObj uvlib_u8vector_sub(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5202 {
5203   ScmObj v0_scm;
5204   ScmU8Vector* v0;
5205   ScmObj v1_scm;
5206   ScmObj v1;
5207   ScmObj clamp_scm;
5208   ScmObj clamp;
5209   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5210   SCM_ENTER_SUBR("u8vector-sub");
5211   if (Scm_Length(SCM_OPTARGS) > 1)
5212     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5213   v0_scm = SCM_ARGREF(0);
5214   if (!SCM_U8VECTORP(v0_scm)) Scm_Error("<u8vector> required, but got %S", v0_scm);
5215   v0 = SCM_U8VECTOR(v0_scm);
5216   v1_scm = SCM_ARGREF(1);
5217   v1 = (v1_scm);
5218   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5219   else {
5220     clamp_scm = SCM_CAR(SCM_OPTARGS);
5221     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5222   }
5223   clamp = (clamp_scm);
5224   {
5225 SCM_RETURN(Scm_U8VectorSub(v0, v1, clamp_arg(clamp)));
5226   }
5227 }
5228 
5229 static SCM_DEFINE_STRING_CONST(uvlib_u8vector_sub__NAME, "u8vector-sub", 12, 12);
5230 static SCM_DEFINE_SUBR(uvlib_u8vector_sub__STUB, 2, 1, SCM_OBJ(&uvlib_u8vector_sub__NAME), uvlib_u8vector_sub, NULL, NULL);
5231 
5232 static ScmObj uvlib_u8vector_subX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5233 {
5234   ScmObj v0_scm;
5235   ScmU8Vector* v0;
5236   ScmObj v1_scm;
5237   ScmObj v1;
5238   ScmObj clamp_scm;
5239   ScmObj clamp;
5240   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5241   SCM_ENTER_SUBR("u8vector-sub!");
5242   if (Scm_Length(SCM_OPTARGS) > 1)
5243     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5244   v0_scm = SCM_ARGREF(0);
5245   if (!SCM_U8VECTORP(v0_scm)) Scm_Error("<u8vector> required, but got %S", v0_scm);
5246   v0 = SCM_U8VECTOR(v0_scm);
5247   v1_scm = SCM_ARGREF(1);
5248   v1 = (v1_scm);
5249   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5250   else {
5251     clamp_scm = SCM_CAR(SCM_OPTARGS);
5252     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5253   }
5254   clamp = (clamp_scm);
5255   {
5256 SCM_RETURN(Scm_U8VectorSubX(v0, v1, clamp_arg(clamp)));
5257   }
5258 }
5259 
5260 static SCM_DEFINE_STRING_CONST(uvlib_u8vector_subX__NAME, "u8vector-sub!", 13, 13);
5261 static SCM_DEFINE_SUBR(uvlib_u8vector_subX__STUB, 2, 1, SCM_OBJ(&uvlib_u8vector_subX__NAME), uvlib_u8vector_subX, NULL, NULL);
5262 
5263 static ScmObj uvlib_s16vector_sub(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5264 {
5265   ScmObj v0_scm;
5266   ScmS16Vector* v0;
5267   ScmObj v1_scm;
5268   ScmObj v1;
5269   ScmObj clamp_scm;
5270   ScmObj clamp;
5271   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5272   SCM_ENTER_SUBR("s16vector-sub");
5273   if (Scm_Length(SCM_OPTARGS) > 1)
5274     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5275   v0_scm = SCM_ARGREF(0);
5276   if (!SCM_S16VECTORP(v0_scm)) Scm_Error("<s16vector> required, but got %S", v0_scm);
5277   v0 = SCM_S16VECTOR(v0_scm);
5278   v1_scm = SCM_ARGREF(1);
5279   v1 = (v1_scm);
5280   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5281   else {
5282     clamp_scm = SCM_CAR(SCM_OPTARGS);
5283     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5284   }
5285   clamp = (clamp_scm);
5286   {
5287 SCM_RETURN(Scm_S16VectorSub(v0, v1, clamp_arg(clamp)));
5288   }
5289 }
5290 
5291 static SCM_DEFINE_STRING_CONST(uvlib_s16vector_sub__NAME, "s16vector-sub", 13, 13);
5292 static SCM_DEFINE_SUBR(uvlib_s16vector_sub__STUB, 2, 1, SCM_OBJ(&uvlib_s16vector_sub__NAME), uvlib_s16vector_sub, NULL, NULL);
5293 
5294 static ScmObj uvlib_s16vector_subX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5295 {
5296   ScmObj v0_scm;
5297   ScmS16Vector* v0;
5298   ScmObj v1_scm;
5299   ScmObj v1;
5300   ScmObj clamp_scm;
5301   ScmObj clamp;
5302   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5303   SCM_ENTER_SUBR("s16vector-sub!");
5304   if (Scm_Length(SCM_OPTARGS) > 1)
5305     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5306   v0_scm = SCM_ARGREF(0);
5307   if (!SCM_S16VECTORP(v0_scm)) Scm_Error("<s16vector> required, but got %S", v0_scm);
5308   v0 = SCM_S16VECTOR(v0_scm);
5309   v1_scm = SCM_ARGREF(1);
5310   v1 = (v1_scm);
5311   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5312   else {
5313     clamp_scm = SCM_CAR(SCM_OPTARGS);
5314     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5315   }
5316   clamp = (clamp_scm);
5317   {
5318 SCM_RETURN(Scm_S16VectorSubX(v0, v1, clamp_arg(clamp)));
5319   }
5320 }
5321 
5322 static SCM_DEFINE_STRING_CONST(uvlib_s16vector_subX__NAME, "s16vector-sub!", 14, 14);
5323 static SCM_DEFINE_SUBR(uvlib_s16vector_subX__STUB, 2, 1, SCM_OBJ(&uvlib_s16vector_subX__NAME), uvlib_s16vector_subX, NULL, NULL);
5324 
5325 static ScmObj uvlib_u16vector_sub(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5326 {
5327   ScmObj v0_scm;
5328   ScmU16Vector* v0;
5329   ScmObj v1_scm;
5330   ScmObj v1;
5331   ScmObj clamp_scm;
5332   ScmObj clamp;
5333   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5334   SCM_ENTER_SUBR("u16vector-sub");
5335   if (Scm_Length(SCM_OPTARGS) > 1)
5336     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5337   v0_scm = SCM_ARGREF(0);
5338   if (!SCM_U16VECTORP(v0_scm)) Scm_Error("<u16vector> required, but got %S", v0_scm);
5339   v0 = SCM_U16VECTOR(v0_scm);
5340   v1_scm = SCM_ARGREF(1);
5341   v1 = (v1_scm);
5342   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5343   else {
5344     clamp_scm = SCM_CAR(SCM_OPTARGS);
5345     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5346   }
5347   clamp = (clamp_scm);
5348   {
5349 SCM_RETURN(Scm_U16VectorSub(v0, v1, clamp_arg(clamp)));
5350   }
5351 }
5352 
5353 static SCM_DEFINE_STRING_CONST(uvlib_u16vector_sub__NAME, "u16vector-sub", 13, 13);
5354 static SCM_DEFINE_SUBR(uvlib_u16vector_sub__STUB, 2, 1, SCM_OBJ(&uvlib_u16vector_sub__NAME), uvlib_u16vector_sub, NULL, NULL);
5355 
5356 static ScmObj uvlib_u16vector_subX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5357 {
5358   ScmObj v0_scm;
5359   ScmU16Vector* v0;
5360   ScmObj v1_scm;
5361   ScmObj v1;
5362   ScmObj clamp_scm;
5363   ScmObj clamp;
5364   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5365   SCM_ENTER_SUBR("u16vector-sub!");
5366   if (Scm_Length(SCM_OPTARGS) > 1)
5367     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5368   v0_scm = SCM_ARGREF(0);
5369   if (!SCM_U16VECTORP(v0_scm)) Scm_Error("<u16vector> required, but got %S", v0_scm);
5370   v0 = SCM_U16VECTOR(v0_scm);
5371   v1_scm = SCM_ARGREF(1);
5372   v1 = (v1_scm);
5373   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5374   else {
5375     clamp_scm = SCM_CAR(SCM_OPTARGS);
5376     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5377   }
5378   clamp = (clamp_scm);
5379   {
5380 SCM_RETURN(Scm_U16VectorSubX(v0, v1, clamp_arg(clamp)));
5381   }
5382 }
5383 
5384 static SCM_DEFINE_STRING_CONST(uvlib_u16vector_subX__NAME, "u16vector-sub!", 14, 14);
5385 static SCM_DEFINE_SUBR(uvlib_u16vector_subX__STUB, 2, 1, SCM_OBJ(&uvlib_u16vector_subX__NAME), uvlib_u16vector_subX, NULL, NULL);
5386 
5387 static ScmObj uvlib_s32vector_sub(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5388 {
5389   ScmObj v0_scm;
5390   ScmS32Vector* v0;
5391   ScmObj v1_scm;
5392   ScmObj v1;
5393   ScmObj clamp_scm;
5394   ScmObj clamp;
5395   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5396   SCM_ENTER_SUBR("s32vector-sub");
5397   if (Scm_Length(SCM_OPTARGS) > 1)
5398     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5399   v0_scm = SCM_ARGREF(0);
5400   if (!SCM_S32VECTORP(v0_scm)) Scm_Error("<s32vector> required, but got %S", v0_scm);
5401   v0 = SCM_S32VECTOR(v0_scm);
5402   v1_scm = SCM_ARGREF(1);
5403   v1 = (v1_scm);
5404   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5405   else {
5406     clamp_scm = SCM_CAR(SCM_OPTARGS);
5407     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5408   }
5409   clamp = (clamp_scm);
5410   {
5411 SCM_RETURN(Scm_S32VectorSub(v0, v1, clamp_arg(clamp)));
5412   }
5413 }
5414 
5415 static SCM_DEFINE_STRING_CONST(uvlib_s32vector_sub__NAME, "s32vector-sub", 13, 13);
5416 static SCM_DEFINE_SUBR(uvlib_s32vector_sub__STUB, 2, 1, SCM_OBJ(&uvlib_s32vector_sub__NAME), uvlib_s32vector_sub, NULL, NULL);
5417 
5418 static ScmObj uvlib_s32vector_subX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5419 {
5420   ScmObj v0_scm;
5421   ScmS32Vector* v0;
5422   ScmObj v1_scm;
5423   ScmObj v1;
5424   ScmObj clamp_scm;
5425   ScmObj clamp;
5426   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5427   SCM_ENTER_SUBR("s32vector-sub!");
5428   if (Scm_Length(SCM_OPTARGS) > 1)
5429     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5430   v0_scm = SCM_ARGREF(0);
5431   if (!SCM_S32VECTORP(v0_scm)) Scm_Error("<s32vector> required, but got %S", v0_scm);
5432   v0 = SCM_S32VECTOR(v0_scm);
5433   v1_scm = SCM_ARGREF(1);
5434   v1 = (v1_scm);
5435   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5436   else {
5437     clamp_scm = SCM_CAR(SCM_OPTARGS);
5438     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5439   }
5440   clamp = (clamp_scm);
5441   {
5442 SCM_RETURN(Scm_S32VectorSubX(v0, v1, clamp_arg(clamp)));
5443   }
5444 }
5445 
5446 static SCM_DEFINE_STRING_CONST(uvlib_s32vector_subX__NAME, "s32vector-sub!", 14, 14);
5447 static SCM_DEFINE_SUBR(uvlib_s32vector_subX__STUB, 2, 1, SCM_OBJ(&uvlib_s32vector_subX__NAME), uvlib_s32vector_subX, NULL, NULL);
5448 
5449 static ScmObj uvlib_u32vector_sub(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5450 {
5451   ScmObj v0_scm;
5452   ScmU32Vector* v0;
5453   ScmObj v1_scm;
5454   ScmObj v1;
5455   ScmObj clamp_scm;
5456   ScmObj clamp;
5457   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5458   SCM_ENTER_SUBR("u32vector-sub");
5459   if (Scm_Length(SCM_OPTARGS) > 1)
5460     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5461   v0_scm = SCM_ARGREF(0);
5462   if (!SCM_U32VECTORP(v0_scm)) Scm_Error("<u32vector> required, but got %S", v0_scm);
5463   v0 = SCM_U32VECTOR(v0_scm);
5464   v1_scm = SCM_ARGREF(1);
5465   v1 = (v1_scm);
5466   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5467   else {
5468     clamp_scm = SCM_CAR(SCM_OPTARGS);
5469     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5470   }
5471   clamp = (clamp_scm);
5472   {
5473 SCM_RETURN(Scm_U32VectorSub(v0, v1, clamp_arg(clamp)));
5474   }
5475 }
5476 
5477 static SCM_DEFINE_STRING_CONST(uvlib_u32vector_sub__NAME, "u32vector-sub", 13, 13);
5478 static SCM_DEFINE_SUBR(uvlib_u32vector_sub__STUB, 2, 1, SCM_OBJ(&uvlib_u32vector_sub__NAME), uvlib_u32vector_sub, NULL, NULL);
5479 
5480 static ScmObj uvlib_u32vector_subX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5481 {
5482   ScmObj v0_scm;
5483   ScmU32Vector* v0;
5484   ScmObj v1_scm;
5485   ScmObj v1;
5486   ScmObj clamp_scm;
5487   ScmObj clamp;
5488   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5489   SCM_ENTER_SUBR("u32vector-sub!");
5490   if (Scm_Length(SCM_OPTARGS) > 1)
5491     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5492   v0_scm = SCM_ARGREF(0);
5493   if (!SCM_U32VECTORP(v0_scm)) Scm_Error("<u32vector> required, but got %S", v0_scm);
5494   v0 = SCM_U32VECTOR(v0_scm);
5495   v1_scm = SCM_ARGREF(1);
5496   v1 = (v1_scm);
5497   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5498   else {
5499     clamp_scm = SCM_CAR(SCM_OPTARGS);
5500     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5501   }
5502   clamp = (clamp_scm);
5503   {
5504 SCM_RETURN(Scm_U32VectorSubX(v0, v1, clamp_arg(clamp)));
5505   }
5506 }
5507 
5508 static SCM_DEFINE_STRING_CONST(uvlib_u32vector_subX__NAME, "u32vector-sub!", 14, 14);
5509 static SCM_DEFINE_SUBR(uvlib_u32vector_subX__STUB, 2, 1, SCM_OBJ(&uvlib_u32vector_subX__NAME), uvlib_u32vector_subX, NULL, NULL);
5510 
5511 static ScmObj uvlib_s64vector_sub(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5512 {
5513   ScmObj v0_scm;
5514   ScmS64Vector* v0;
5515   ScmObj v1_scm;
5516   ScmObj v1;
5517   ScmObj clamp_scm;
5518   ScmObj clamp;
5519   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5520   SCM_ENTER_SUBR("s64vector-sub");
5521   if (Scm_Length(SCM_OPTARGS) > 1)
5522     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5523   v0_scm = SCM_ARGREF(0);
5524   if (!SCM_S64VECTORP(v0_scm)) Scm_Error("<s64vector> required, but got %S", v0_scm);
5525   v0 = SCM_S64VECTOR(v0_scm);
5526   v1_scm = SCM_ARGREF(1);
5527   v1 = (v1_scm);
5528   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5529   else {
5530     clamp_scm = SCM_CAR(SCM_OPTARGS);
5531     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5532   }
5533   clamp = (clamp_scm);
5534   {
5535 SCM_RETURN(Scm_S64VectorSub(v0, v1, clamp_arg(clamp)));
5536   }
5537 }
5538 
5539 static SCM_DEFINE_STRING_CONST(uvlib_s64vector_sub__NAME, "s64vector-sub", 13, 13);
5540 static SCM_DEFINE_SUBR(uvlib_s64vector_sub__STUB, 2, 1, SCM_OBJ(&uvlib_s64vector_sub__NAME), uvlib_s64vector_sub, NULL, NULL);
5541 
5542 static ScmObj uvlib_s64vector_subX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5543 {
5544   ScmObj v0_scm;
5545   ScmS64Vector* v0;
5546   ScmObj v1_scm;
5547   ScmObj v1;
5548   ScmObj clamp_scm;
5549   ScmObj clamp;
5550   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5551   SCM_ENTER_SUBR("s64vector-sub!");
5552   if (Scm_Length(SCM_OPTARGS) > 1)
5553     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5554   v0_scm = SCM_ARGREF(0);
5555   if (!SCM_S64VECTORP(v0_scm)) Scm_Error("<s64vector> required, but got %S", v0_scm);
5556   v0 = SCM_S64VECTOR(v0_scm);
5557   v1_scm = SCM_ARGREF(1);
5558   v1 = (v1_scm);
5559   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5560   else {
5561     clamp_scm = SCM_CAR(SCM_OPTARGS);
5562     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5563   }
5564   clamp = (clamp_scm);
5565   {
5566 SCM_RETURN(Scm_S64VectorSubX(v0, v1, clamp_arg(clamp)));
5567   }
5568 }
5569 
5570 static SCM_DEFINE_STRING_CONST(uvlib_s64vector_subX__NAME, "s64vector-sub!", 14, 14);
5571 static SCM_DEFINE_SUBR(uvlib_s64vector_subX__STUB, 2, 1, SCM_OBJ(&uvlib_s64vector_subX__NAME), uvlib_s64vector_subX, NULL, NULL);
5572 
5573 static ScmObj uvlib_u64vector_sub(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5574 {
5575   ScmObj v0_scm;
5576   ScmU64Vector* v0;
5577   ScmObj v1_scm;
5578   ScmObj v1;
5579   ScmObj clamp_scm;
5580   ScmObj clamp;
5581   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5582   SCM_ENTER_SUBR("u64vector-sub");
5583   if (Scm_Length(SCM_OPTARGS) > 1)
5584     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5585   v0_scm = SCM_ARGREF(0);
5586   if (!SCM_U64VECTORP(v0_scm)) Scm_Error("<u64vector> required, but got %S", v0_scm);
5587   v0 = SCM_U64VECTOR(v0_scm);
5588   v1_scm = SCM_ARGREF(1);
5589   v1 = (v1_scm);
5590   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5591   else {
5592     clamp_scm = SCM_CAR(SCM_OPTARGS);
5593     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5594   }
5595   clamp = (clamp_scm);
5596   {
5597 SCM_RETURN(Scm_U64VectorSub(v0, v1, clamp_arg(clamp)));
5598   }
5599 }
5600 
5601 static SCM_DEFINE_STRING_CONST(uvlib_u64vector_sub__NAME, "u64vector-sub", 13, 13);
5602 static SCM_DEFINE_SUBR(uvlib_u64vector_sub__STUB, 2, 1, SCM_OBJ(&uvlib_u64vector_sub__NAME), uvlib_u64vector_sub, NULL, NULL);
5603 
5604 static ScmObj uvlib_u64vector_subX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5605 {
5606   ScmObj v0_scm;
5607   ScmU64Vector* v0;
5608   ScmObj v1_scm;
5609   ScmObj v1;
5610   ScmObj clamp_scm;
5611   ScmObj clamp;
5612   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5613   SCM_ENTER_SUBR("u64vector-sub!");
5614   if (Scm_Length(SCM_OPTARGS) > 1)
5615     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5616   v0_scm = SCM_ARGREF(0);
5617   if (!SCM_U64VECTORP(v0_scm)) Scm_Error("<u64vector> required, but got %S", v0_scm);
5618   v0 = SCM_U64VECTOR(v0_scm);
5619   v1_scm = SCM_ARGREF(1);
5620   v1 = (v1_scm);
5621   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5622   else {
5623     clamp_scm = SCM_CAR(SCM_OPTARGS);
5624     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5625   }
5626   clamp = (clamp_scm);
5627   {
5628 SCM_RETURN(Scm_U64VectorSubX(v0, v1, clamp_arg(clamp)));
5629   }
5630 }
5631 
5632 static SCM_DEFINE_STRING_CONST(uvlib_u64vector_subX__NAME, "u64vector-sub!", 14, 14);
5633 static SCM_DEFINE_SUBR(uvlib_u64vector_subX__STUB, 2, 1, SCM_OBJ(&uvlib_u64vector_subX__NAME), uvlib_u64vector_subX, NULL, NULL);
5634 
5635 static ScmObj uvlib_f32vector_sub(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5636 {
5637   ScmObj v0_scm;
5638   ScmF32Vector* v0;
5639   ScmObj v1_scm;
5640   ScmObj v1;
5641   ScmObj clamp_scm;
5642   ScmObj clamp;
5643   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5644   SCM_ENTER_SUBR("f32vector-sub");
5645   if (Scm_Length(SCM_OPTARGS) > 1)
5646     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5647   v0_scm = SCM_ARGREF(0);
5648   if (!SCM_F32VECTORP(v0_scm)) Scm_Error("<f32vector> required, but got %S", v0_scm);
5649   v0 = SCM_F32VECTOR(v0_scm);
5650   v1_scm = SCM_ARGREF(1);
5651   v1 = (v1_scm);
5652   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5653   else {
5654     clamp_scm = SCM_CAR(SCM_OPTARGS);
5655     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5656   }
5657   clamp = (clamp_scm);
5658   {
5659 SCM_RETURN(Scm_F32VectorSub(v0, v1, clamp_arg(clamp)));
5660   }
5661 }
5662 
5663 static SCM_DEFINE_STRING_CONST(uvlib_f32vector_sub__NAME, "f32vector-sub", 13, 13);
5664 static SCM_DEFINE_SUBR(uvlib_f32vector_sub__STUB, 2, 1, SCM_OBJ(&uvlib_f32vector_sub__NAME), uvlib_f32vector_sub, NULL, NULL);
5665 
5666 static ScmObj uvlib_f32vector_subX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5667 {
5668   ScmObj v0_scm;
5669   ScmF32Vector* v0;
5670   ScmObj v1_scm;
5671   ScmObj v1;
5672   ScmObj clamp_scm;
5673   ScmObj clamp;
5674   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5675   SCM_ENTER_SUBR("f32vector-sub!");
5676   if (Scm_Length(SCM_OPTARGS) > 1)
5677     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5678   v0_scm = SCM_ARGREF(0);
5679   if (!SCM_F32VECTORP(v0_scm)) Scm_Error("<f32vector> required, but got %S", v0_scm);
5680   v0 = SCM_F32VECTOR(v0_scm);
5681   v1_scm = SCM_ARGREF(1);
5682   v1 = (v1_scm);
5683   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5684   else {
5685     clamp_scm = SCM_CAR(SCM_OPTARGS);
5686     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5687   }
5688   clamp = (clamp_scm);
5689   {
5690 SCM_RETURN(Scm_F32VectorSubX(v0, v1, clamp_arg(clamp)));
5691   }
5692 }
5693 
5694 static SCM_DEFINE_STRING_CONST(uvlib_f32vector_subX__NAME, "f32vector-sub!", 14, 14);
5695 static SCM_DEFINE_SUBR(uvlib_f32vector_subX__STUB, 2, 1, SCM_OBJ(&uvlib_f32vector_subX__NAME), uvlib_f32vector_subX, NULL, NULL);
5696 
5697 static ScmObj uvlib_f64vector_sub(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5698 {
5699   ScmObj v0_scm;
5700   ScmF64Vector* v0;
5701   ScmObj v1_scm;
5702   ScmObj v1;
5703   ScmObj clamp_scm;
5704   ScmObj clamp;
5705   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5706   SCM_ENTER_SUBR("f64vector-sub");
5707   if (Scm_Length(SCM_OPTARGS) > 1)
5708     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5709   v0_scm = SCM_ARGREF(0);
5710   if (!SCM_F64VECTORP(v0_scm)) Scm_Error("<f64vector> required, but got %S", v0_scm);
5711   v0 = SCM_F64VECTOR(v0_scm);
5712   v1_scm = SCM_ARGREF(1);
5713   v1 = (v1_scm);
5714   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5715   else {
5716     clamp_scm = SCM_CAR(SCM_OPTARGS);
5717     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5718   }
5719   clamp = (clamp_scm);
5720   {
5721 SCM_RETURN(Scm_F64VectorSub(v0, v1, clamp_arg(clamp)));
5722   }
5723 }
5724 
5725 static SCM_DEFINE_STRING_CONST(uvlib_f64vector_sub__NAME, "f64vector-sub", 13, 13);
5726 static SCM_DEFINE_SUBR(uvlib_f64vector_sub__STUB, 2, 1, SCM_OBJ(&uvlib_f64vector_sub__NAME), uvlib_f64vector_sub, NULL, NULL);
5727 
5728 static ScmObj uvlib_f64vector_subX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5729 {
5730   ScmObj v0_scm;
5731   ScmF64Vector* v0;
5732   ScmObj v1_scm;
5733   ScmObj v1;
5734   ScmObj clamp_scm;
5735   ScmObj clamp;
5736   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5737   SCM_ENTER_SUBR("f64vector-sub!");
5738   if (Scm_Length(SCM_OPTARGS) > 1)
5739     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5740   v0_scm = SCM_ARGREF(0);
5741   if (!SCM_F64VECTORP(v0_scm)) Scm_Error("<f64vector> required, but got %S", v0_scm);
5742   v0 = SCM_F64VECTOR(v0_scm);
5743   v1_scm = SCM_ARGREF(1);
5744   v1 = (v1_scm);
5745   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5746   else {
5747     clamp_scm = SCM_CAR(SCM_OPTARGS);
5748     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5749   }
5750   clamp = (clamp_scm);
5751   {
5752 SCM_RETURN(Scm_F64VectorSubX(v0, v1, clamp_arg(clamp)));
5753   }
5754 }
5755 
5756 static SCM_DEFINE_STRING_CONST(uvlib_f64vector_subX__NAME, "f64vector-sub!", 14, 14);
5757 static SCM_DEFINE_SUBR(uvlib_f64vector_subX__STUB, 2, 1, SCM_OBJ(&uvlib_f64vector_subX__NAME), uvlib_f64vector_subX, NULL, NULL);
5758 
5759 static ScmObj uvlib_s8vector_mul(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5760 {
5761   ScmObj v0_scm;
5762   ScmS8Vector* v0;
5763   ScmObj v1_scm;
5764   ScmObj v1;
5765   ScmObj clamp_scm;
5766   ScmObj clamp;
5767   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5768   SCM_ENTER_SUBR("s8vector-mul");
5769   if (Scm_Length(SCM_OPTARGS) > 1)
5770     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5771   v0_scm = SCM_ARGREF(0);
5772   if (!SCM_S8VECTORP(v0_scm)) Scm_Error("<s8vector> required, but got %S", v0_scm);
5773   v0 = SCM_S8VECTOR(v0_scm);
5774   v1_scm = SCM_ARGREF(1);
5775   v1 = (v1_scm);
5776   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5777   else {
5778     clamp_scm = SCM_CAR(SCM_OPTARGS);
5779     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5780   }
5781   clamp = (clamp_scm);
5782   {
5783 SCM_RETURN(Scm_S8VectorMul(v0, v1, clamp_arg(clamp)));
5784   }
5785 }
5786 
5787 static SCM_DEFINE_STRING_CONST(uvlib_s8vector_mul__NAME, "s8vector-mul", 12, 12);
5788 static SCM_DEFINE_SUBR(uvlib_s8vector_mul__STUB, 2, 1, SCM_OBJ(&uvlib_s8vector_mul__NAME), uvlib_s8vector_mul, NULL, NULL);
5789 
5790 static ScmObj uvlib_s8vector_mulX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5791 {
5792   ScmObj v0_scm;
5793   ScmS8Vector* v0;
5794   ScmObj v1_scm;
5795   ScmObj v1;
5796   ScmObj clamp_scm;
5797   ScmObj clamp;
5798   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5799   SCM_ENTER_SUBR("s8vector-mul!");
5800   if (Scm_Length(SCM_OPTARGS) > 1)
5801     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5802   v0_scm = SCM_ARGREF(0);
5803   if (!SCM_S8VECTORP(v0_scm)) Scm_Error("<s8vector> required, but got %S", v0_scm);
5804   v0 = SCM_S8VECTOR(v0_scm);
5805   v1_scm = SCM_ARGREF(1);
5806   v1 = (v1_scm);
5807   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5808   else {
5809     clamp_scm = SCM_CAR(SCM_OPTARGS);
5810     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5811   }
5812   clamp = (clamp_scm);
5813   {
5814 SCM_RETURN(Scm_S8VectorMulX(v0, v1, clamp_arg(clamp)));
5815   }
5816 }
5817 
5818 static SCM_DEFINE_STRING_CONST(uvlib_s8vector_mulX__NAME, "s8vector-mul!", 13, 13);
5819 static SCM_DEFINE_SUBR(uvlib_s8vector_mulX__STUB, 2, 1, SCM_OBJ(&uvlib_s8vector_mulX__NAME), uvlib_s8vector_mulX, NULL, NULL);
5820 
5821 static ScmObj uvlib_u8vector_mul(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5822 {
5823   ScmObj v0_scm;
5824   ScmU8Vector* v0;
5825   ScmObj v1_scm;
5826   ScmObj v1;
5827   ScmObj clamp_scm;
5828   ScmObj clamp;
5829   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5830   SCM_ENTER_SUBR("u8vector-mul");
5831   if (Scm_Length(SCM_OPTARGS) > 1)
5832     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5833   v0_scm = SCM_ARGREF(0);
5834   if (!SCM_U8VECTORP(v0_scm)) Scm_Error("<u8vector> required, but got %S", v0_scm);
5835   v0 = SCM_U8VECTOR(v0_scm);
5836   v1_scm = SCM_ARGREF(1);
5837   v1 = (v1_scm);
5838   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5839   else {
5840     clamp_scm = SCM_CAR(SCM_OPTARGS);
5841     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5842   }
5843   clamp = (clamp_scm);
5844   {
5845 SCM_RETURN(Scm_U8VectorMul(v0, v1, clamp_arg(clamp)));
5846   }
5847 }
5848 
5849 static SCM_DEFINE_STRING_CONST(uvlib_u8vector_mul__NAME, "u8vector-mul", 12, 12);
5850 static SCM_DEFINE_SUBR(uvlib_u8vector_mul__STUB, 2, 1, SCM_OBJ(&uvlib_u8vector_mul__NAME), uvlib_u8vector_mul, NULL, NULL);
5851 
5852 static ScmObj uvlib_u8vector_mulX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5853 {
5854   ScmObj v0_scm;
5855   ScmU8Vector* v0;
5856   ScmObj v1_scm;
5857   ScmObj v1;
5858   ScmObj clamp_scm;
5859   ScmObj clamp;
5860   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5861   SCM_ENTER_SUBR("u8vector-mul!");
5862   if (Scm_Length(SCM_OPTARGS) > 1)
5863     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5864   v0_scm = SCM_ARGREF(0);
5865   if (!SCM_U8VECTORP(v0_scm)) Scm_Error("<u8vector> required, but got %S", v0_scm);
5866   v0 = SCM_U8VECTOR(v0_scm);
5867   v1_scm = SCM_ARGREF(1);
5868   v1 = (v1_scm);
5869   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5870   else {
5871     clamp_scm = SCM_CAR(SCM_OPTARGS);
5872     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5873   }
5874   clamp = (clamp_scm);
5875   {
5876 SCM_RETURN(Scm_U8VectorMulX(v0, v1, clamp_arg(clamp)));
5877   }
5878 }
5879 
5880 static SCM_DEFINE_STRING_CONST(uvlib_u8vector_mulX__NAME, "u8vector-mul!", 13, 13);
5881 static SCM_DEFINE_SUBR(uvlib_u8vector_mulX__STUB, 2, 1, SCM_OBJ(&uvlib_u8vector_mulX__NAME), uvlib_u8vector_mulX, NULL, NULL);
5882 
5883 static ScmObj uvlib_s16vector_mul(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5884 {
5885   ScmObj v0_scm;
5886   ScmS16Vector* v0;
5887   ScmObj v1_scm;
5888   ScmObj v1;
5889   ScmObj clamp_scm;
5890   ScmObj clamp;
5891   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5892   SCM_ENTER_SUBR("s16vector-mul");
5893   if (Scm_Length(SCM_OPTARGS) > 1)
5894     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5895   v0_scm = SCM_ARGREF(0);
5896   if (!SCM_S16VECTORP(v0_scm)) Scm_Error("<s16vector> required, but got %S", v0_scm);
5897   v0 = SCM_S16VECTOR(v0_scm);
5898   v1_scm = SCM_ARGREF(1);
5899   v1 = (v1_scm);
5900   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5901   else {
5902     clamp_scm = SCM_CAR(SCM_OPTARGS);
5903     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5904   }
5905   clamp = (clamp_scm);
5906   {
5907 SCM_RETURN(Scm_S16VectorMul(v0, v1, clamp_arg(clamp)));
5908   }
5909 }
5910 
5911 static SCM_DEFINE_STRING_CONST(uvlib_s16vector_mul__NAME, "s16vector-mul", 13, 13);
5912 static SCM_DEFINE_SUBR(uvlib_s16vector_mul__STUB, 2, 1, SCM_OBJ(&uvlib_s16vector_mul__NAME), uvlib_s16vector_mul, NULL, NULL);
5913 
5914 static ScmObj uvlib_s16vector_mulX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5915 {
5916   ScmObj v0_scm;
5917   ScmS16Vector* v0;
5918   ScmObj v1_scm;
5919   ScmObj v1;
5920   ScmObj clamp_scm;
5921   ScmObj clamp;
5922   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5923   SCM_ENTER_SUBR("s16vector-mul!");
5924   if (Scm_Length(SCM_OPTARGS) > 1)
5925     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5926   v0_scm = SCM_ARGREF(0);
5927   if (!SCM_S16VECTORP(v0_scm)) Scm_Error("<s16vector> required, but got %S", v0_scm);
5928   v0 = SCM_S16VECTOR(v0_scm);
5929   v1_scm = SCM_ARGREF(1);
5930   v1 = (v1_scm);
5931   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5932   else {
5933     clamp_scm = SCM_CAR(SCM_OPTARGS);
5934     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5935   }
5936   clamp = (clamp_scm);
5937   {
5938 SCM_RETURN(Scm_S16VectorMulX(v0, v1, clamp_arg(clamp)));
5939   }
5940 }
5941 
5942 static SCM_DEFINE_STRING_CONST(uvlib_s16vector_mulX__NAME, "s16vector-mul!", 14, 14);
5943 static SCM_DEFINE_SUBR(uvlib_s16vector_mulX__STUB, 2, 1, SCM_OBJ(&uvlib_s16vector_mulX__NAME), uvlib_s16vector_mulX, NULL, NULL);
5944 
5945 static ScmObj uvlib_u16vector_mul(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5946 {
5947   ScmObj v0_scm;
5948   ScmU16Vector* v0;
5949   ScmObj v1_scm;
5950   ScmObj v1;
5951   ScmObj clamp_scm;
5952   ScmObj clamp;
5953   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5954   SCM_ENTER_SUBR("u16vector-mul");
5955   if (Scm_Length(SCM_OPTARGS) > 1)
5956     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5957   v0_scm = SCM_ARGREF(0);
5958   if (!SCM_U16VECTORP(v0_scm)) Scm_Error("<u16vector> required, but got %S", v0_scm);
5959   v0 = SCM_U16VECTOR(v0_scm);
5960   v1_scm = SCM_ARGREF(1);
5961   v1 = (v1_scm);
5962   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5963   else {
5964     clamp_scm = SCM_CAR(SCM_OPTARGS);
5965     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5966   }
5967   clamp = (clamp_scm);
5968   {
5969 SCM_RETURN(Scm_U16VectorMul(v0, v1, clamp_arg(clamp)));
5970   }
5971 }
5972 
5973 static SCM_DEFINE_STRING_CONST(uvlib_u16vector_mul__NAME, "u16vector-mul", 13, 13);
5974 static SCM_DEFINE_SUBR(uvlib_u16vector_mul__STUB, 2, 1, SCM_OBJ(&uvlib_u16vector_mul__NAME), uvlib_u16vector_mul, NULL, NULL);
5975 
5976 static ScmObj uvlib_u16vector_mulX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
5977 {
5978   ScmObj v0_scm;
5979   ScmU16Vector* v0;
5980   ScmObj v1_scm;
5981   ScmObj v1;
5982   ScmObj clamp_scm;
5983   ScmObj clamp;
5984   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
5985   SCM_ENTER_SUBR("u16vector-mul!");
5986   if (Scm_Length(SCM_OPTARGS) > 1)
5987     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
5988   v0_scm = SCM_ARGREF(0);
5989   if (!SCM_U16VECTORP(v0_scm)) Scm_Error("<u16vector> required, but got %S", v0_scm);
5990   v0 = SCM_U16VECTOR(v0_scm);
5991   v1_scm = SCM_ARGREF(1);
5992   v1 = (v1_scm);
5993   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
5994   else {
5995     clamp_scm = SCM_CAR(SCM_OPTARGS);
5996     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
5997   }
5998   clamp = (clamp_scm);
5999   {
6000 SCM_RETURN(Scm_U16VectorMulX(v0, v1, clamp_arg(clamp)));
6001   }
6002 }
6003 
6004 static SCM_DEFINE_STRING_CONST(uvlib_u16vector_mulX__NAME, "u16vector-mul!", 14, 14);
6005 static SCM_DEFINE_SUBR(uvlib_u16vector_mulX__STUB, 2, 1, SCM_OBJ(&uvlib_u16vector_mulX__NAME), uvlib_u16vector_mulX, NULL, NULL);
6006 
6007 static ScmObj uvlib_s32vector_mul(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6008 {
6009   ScmObj v0_scm;
6010   ScmS32Vector* v0;
6011   ScmObj v1_scm;
6012   ScmObj v1;
6013   ScmObj clamp_scm;
6014   ScmObj clamp;
6015   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
6016   SCM_ENTER_SUBR("s32vector-mul");
6017   if (Scm_Length(SCM_OPTARGS) > 1)
6018     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
6019   v0_scm = SCM_ARGREF(0);
6020   if (!SCM_S32VECTORP(v0_scm)) Scm_Error("<s32vector> required, but got %S", v0_scm);
6021   v0 = SCM_S32VECTOR(v0_scm);
6022   v1_scm = SCM_ARGREF(1);
6023   v1 = (v1_scm);
6024   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
6025   else {
6026     clamp_scm = SCM_CAR(SCM_OPTARGS);
6027     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
6028   }
6029   clamp = (clamp_scm);
6030   {
6031 SCM_RETURN(Scm_S32VectorMul(v0, v1, clamp_arg(clamp)));
6032   }
6033 }
6034 
6035 static SCM_DEFINE_STRING_CONST(uvlib_s32vector_mul__NAME, "s32vector-mul", 13, 13);
6036 static SCM_DEFINE_SUBR(uvlib_s32vector_mul__STUB, 2, 1, SCM_OBJ(&uvlib_s32vector_mul__NAME), uvlib_s32vector_mul, NULL, NULL);
6037 
6038 static ScmObj uvlib_s32vector_mulX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6039 {
6040   ScmObj v0_scm;
6041   ScmS32Vector* v0;
6042   ScmObj v1_scm;
6043   ScmObj v1;
6044   ScmObj clamp_scm;
6045   ScmObj clamp;
6046   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
6047   SCM_ENTER_SUBR("s32vector-mul!");
6048   if (Scm_Length(SCM_OPTARGS) > 1)
6049     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
6050   v0_scm = SCM_ARGREF(0);
6051   if (!SCM_S32VECTORP(v0_scm)) Scm_Error("<s32vector> required, but got %S", v0_scm);
6052   v0 = SCM_S32VECTOR(v0_scm);
6053   v1_scm = SCM_ARGREF(1);
6054   v1 = (v1_scm);
6055   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
6056   else {
6057     clamp_scm = SCM_CAR(SCM_OPTARGS);
6058     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
6059   }
6060   clamp = (clamp_scm);
6061   {
6062 SCM_RETURN(Scm_S32VectorMulX(v0, v1, clamp_arg(clamp)));
6063   }
6064 }
6065 
6066 static SCM_DEFINE_STRING_CONST(uvlib_s32vector_mulX__NAME, "s32vector-mul!", 14, 14);
6067 static SCM_DEFINE_SUBR(uvlib_s32vector_mulX__STUB, 2, 1, SCM_OBJ(&uvlib_s32vector_mulX__NAME), uvlib_s32vector_mulX, NULL, NULL);
6068 
6069 static ScmObj uvlib_u32vector_mul(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6070 {
6071   ScmObj v0_scm;
6072   ScmU32Vector* v0;
6073   ScmObj v1_scm;
6074   ScmObj v1;
6075   ScmObj clamp_scm;
6076   ScmObj clamp;
6077   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
6078   SCM_ENTER_SUBR("u32vector-mul");
6079   if (Scm_Length(SCM_OPTARGS) > 1)
6080     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
6081   v0_scm = SCM_ARGREF(0);
6082   if (!SCM_U32VECTORP(v0_scm)) Scm_Error("<u32vector> required, but got %S", v0_scm);
6083   v0 = SCM_U32VECTOR(v0_scm);
6084   v1_scm = SCM_ARGREF(1);
6085   v1 = (v1_scm);
6086   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
6087   else {
6088     clamp_scm = SCM_CAR(SCM_OPTARGS);
6089     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
6090   }
6091   clamp = (clamp_scm);
6092   {
6093 SCM_RETURN(Scm_U32VectorMul(v0, v1, clamp_arg(clamp)));
6094   }
6095 }
6096 
6097 static SCM_DEFINE_STRING_CONST(uvlib_u32vector_mul__NAME, "u32vector-mul", 13, 13);
6098 static SCM_DEFINE_SUBR(uvlib_u32vector_mul__STUB, 2, 1, SCM_OBJ(&uvlib_u32vector_mul__NAME), uvlib_u32vector_mul, NULL, NULL);
6099 
6100 static ScmObj uvlib_u32vector_mulX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6101 {
6102   ScmObj v0_scm;
6103   ScmU32Vector* v0;
6104   ScmObj v1_scm;
6105   ScmObj v1;
6106   ScmObj clamp_scm;
6107   ScmObj clamp;
6108   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
6109   SCM_ENTER_SUBR("u32vector-mul!");
6110   if (Scm_Length(SCM_OPTARGS) > 1)
6111     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
6112   v0_scm = SCM_ARGREF(0);
6113   if (!SCM_U32VECTORP(v0_scm)) Scm_Error("<u32vector> required, but got %S", v0_scm);
6114   v0 = SCM_U32VECTOR(v0_scm);
6115   v1_scm = SCM_ARGREF(1);
6116   v1 = (v1_scm);
6117   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
6118   else {
6119     clamp_scm = SCM_CAR(SCM_OPTARGS);
6120     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
6121   }
6122   clamp = (clamp_scm);
6123   {
6124 SCM_RETURN(Scm_U32VectorMulX(v0, v1, clamp_arg(clamp)));
6125   }
6126 }
6127 
6128 static SCM_DEFINE_STRING_CONST(uvlib_u32vector_mulX__NAME, "u32vector-mul!", 14, 14);
6129 static SCM_DEFINE_SUBR(uvlib_u32vector_mulX__STUB, 2, 1, SCM_OBJ(&uvlib_u32vector_mulX__NAME), uvlib_u32vector_mulX, NULL, NULL);
6130 
6131 static ScmObj uvlib_s64vector_mul(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6132 {
6133   ScmObj v0_scm;
6134   ScmS64Vector* v0;
6135   ScmObj v1_scm;
6136   ScmObj v1;
6137   ScmObj clamp_scm;
6138   ScmObj clamp;
6139   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
6140   SCM_ENTER_SUBR("s64vector-mul");
6141   if (Scm_Length(SCM_OPTARGS) > 1)
6142     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
6143   v0_scm = SCM_ARGREF(0);
6144   if (!SCM_S64VECTORP(v0_scm)) Scm_Error("<s64vector> required, but got %S", v0_scm);
6145   v0 = SCM_S64VECTOR(v0_scm);
6146   v1_scm = SCM_ARGREF(1);
6147   v1 = (v1_scm);
6148   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
6149   else {
6150     clamp_scm = SCM_CAR(SCM_OPTARGS);
6151     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
6152   }
6153   clamp = (clamp_scm);
6154   {
6155 SCM_RETURN(Scm_S64VectorMul(v0, v1, clamp_arg(clamp)));
6156   }
6157 }
6158 
6159 static SCM_DEFINE_STRING_CONST(uvlib_s64vector_mul__NAME, "s64vector-mul", 13, 13);
6160 static SCM_DEFINE_SUBR(uvlib_s64vector_mul__STUB, 2, 1, SCM_OBJ(&uvlib_s64vector_mul__NAME), uvlib_s64vector_mul, NULL, NULL);
6161 
6162 static ScmObj uvlib_s64vector_mulX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6163 {
6164   ScmObj v0_scm;
6165   ScmS64Vector* v0;
6166   ScmObj v1_scm;
6167   ScmObj v1;
6168   ScmObj clamp_scm;
6169   ScmObj clamp;
6170   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
6171   SCM_ENTER_SUBR("s64vector-mul!");
6172   if (Scm_Length(SCM_OPTARGS) > 1)
6173     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
6174   v0_scm = SCM_ARGREF(0);
6175   if (!SCM_S64VECTORP(v0_scm)) Scm_Error("<s64vector> required, but got %S", v0_scm);
6176   v0 = SCM_S64VECTOR(v0_scm);
6177   v1_scm = SCM_ARGREF(1);
6178   v1 = (v1_scm);
6179   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
6180   else {
6181     clamp_scm = SCM_CAR(SCM_OPTARGS);
6182     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
6183   }
6184   clamp = (clamp_scm);
6185   {
6186 SCM_RETURN(Scm_S64VectorMulX(v0, v1, clamp_arg(clamp)));
6187   }
6188 }
6189 
6190 static SCM_DEFINE_STRING_CONST(uvlib_s64vector_mulX__NAME, "s64vector-mul!", 14, 14);
6191 static SCM_DEFINE_SUBR(uvlib_s64vector_mulX__STUB, 2, 1, SCM_OBJ(&uvlib_s64vector_mulX__NAME), uvlib_s64vector_mulX, NULL, NULL);
6192 
6193 static ScmObj uvlib_u64vector_mul(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6194 {
6195   ScmObj v0_scm;
6196   ScmU64Vector* v0;
6197   ScmObj v1_scm;
6198   ScmObj v1;
6199   ScmObj clamp_scm;
6200   ScmObj clamp;
6201   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
6202   SCM_ENTER_SUBR("u64vector-mul");
6203   if (Scm_Length(SCM_OPTARGS) > 1)
6204     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
6205   v0_scm = SCM_ARGREF(0);
6206   if (!SCM_U64VECTORP(v0_scm)) Scm_Error("<u64vector> required, but got %S", v0_scm);
6207   v0 = SCM_U64VECTOR(v0_scm);
6208   v1_scm = SCM_ARGREF(1);
6209   v1 = (v1_scm);
6210   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
6211   else {
6212     clamp_scm = SCM_CAR(SCM_OPTARGS);
6213     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
6214   }
6215   clamp = (clamp_scm);
6216   {
6217 SCM_RETURN(Scm_U64VectorMul(v0, v1, clamp_arg(clamp)));
6218   }
6219 }
6220 
6221 static SCM_DEFINE_STRING_CONST(uvlib_u64vector_mul__NAME, "u64vector-mul", 13, 13);
6222 static SCM_DEFINE_SUBR(uvlib_u64vector_mul__STUB, 2, 1, SCM_OBJ(&uvlib_u64vector_mul__NAME), uvlib_u64vector_mul, NULL, NULL);
6223 
6224 static ScmObj uvlib_u64vector_mulX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6225 {
6226   ScmObj v0_scm;
6227   ScmU64Vector* v0;
6228   ScmObj v1_scm;
6229   ScmObj v1;
6230   ScmObj clamp_scm;
6231   ScmObj clamp;
6232   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
6233   SCM_ENTER_SUBR("u64vector-mul!");
6234   if (Scm_Length(SCM_OPTARGS) > 1)
6235     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
6236   v0_scm = SCM_ARGREF(0);
6237   if (!SCM_U64VECTORP(v0_scm)) Scm_Error("<u64vector> required, but got %S", v0_scm);
6238   v0 = SCM_U64VECTOR(v0_scm);
6239   v1_scm = SCM_ARGREF(1);
6240   v1 = (v1_scm);
6241   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
6242   else {
6243     clamp_scm = SCM_CAR(SCM_OPTARGS);
6244     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
6245   }
6246   clamp = (clamp_scm);
6247   {
6248 SCM_RETURN(Scm_U64VectorMulX(v0, v1, clamp_arg(clamp)));
6249   }
6250 }
6251 
6252 static SCM_DEFINE_STRING_CONST(uvlib_u64vector_mulX__NAME, "u64vector-mul!", 14, 14);
6253 static SCM_DEFINE_SUBR(uvlib_u64vector_mulX__STUB, 2, 1, SCM_OBJ(&uvlib_u64vector_mulX__NAME), uvlib_u64vector_mulX, NULL, NULL);
6254 
6255 static ScmObj uvlib_f32vector_mul(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6256 {
6257   ScmObj v0_scm;
6258   ScmF32Vector* v0;
6259   ScmObj v1_scm;
6260   ScmObj v1;
6261   ScmObj clamp_scm;
6262   ScmObj clamp;
6263   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
6264   SCM_ENTER_SUBR("f32vector-mul");
6265   if (Scm_Length(SCM_OPTARGS) > 1)
6266     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
6267   v0_scm = SCM_ARGREF(0);
6268   if (!SCM_F32VECTORP(v0_scm)) Scm_Error("<f32vector> required, but got %S", v0_scm);
6269   v0 = SCM_F32VECTOR(v0_scm);
6270   v1_scm = SCM_ARGREF(1);
6271   v1 = (v1_scm);
6272   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
6273   else {
6274     clamp_scm = SCM_CAR(SCM_OPTARGS);
6275     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
6276   }
6277   clamp = (clamp_scm);
6278   {
6279 SCM_RETURN(Scm_F32VectorMul(v0, v1, clamp_arg(clamp)));
6280   }
6281 }
6282 
6283 static SCM_DEFINE_STRING_CONST(uvlib_f32vector_mul__NAME, "f32vector-mul", 13, 13);
6284 static SCM_DEFINE_SUBR(uvlib_f32vector_mul__STUB, 2, 1, SCM_OBJ(&uvlib_f32vector_mul__NAME), uvlib_f32vector_mul, NULL, NULL);
6285 
6286 static ScmObj uvlib_f32vector_mulX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6287 {
6288   ScmObj v0_scm;
6289   ScmF32Vector* v0;
6290   ScmObj v1_scm;
6291   ScmObj v1;
6292   ScmObj clamp_scm;
6293   ScmObj clamp;
6294   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
6295   SCM_ENTER_SUBR("f32vector-mul!");
6296   if (Scm_Length(SCM_OPTARGS) > 1)
6297     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
6298   v0_scm = SCM_ARGREF(0);
6299   if (!SCM_F32VECTORP(v0_scm)) Scm_Error("<f32vector> required, but got %S", v0_scm);
6300   v0 = SCM_F32VECTOR(v0_scm);
6301   v1_scm = SCM_ARGREF(1);
6302   v1 = (v1_scm);
6303   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
6304   else {
6305     clamp_scm = SCM_CAR(SCM_OPTARGS);
6306     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
6307   }
6308   clamp = (clamp_scm);
6309   {
6310 SCM_RETURN(Scm_F32VectorMulX(v0, v1, clamp_arg(clamp)));
6311   }
6312 }
6313 
6314 static SCM_DEFINE_STRING_CONST(uvlib_f32vector_mulX__NAME, "f32vector-mul!", 14, 14);
6315 static SCM_DEFINE_SUBR(uvlib_f32vector_mulX__STUB, 2, 1, SCM_OBJ(&uvlib_f32vector_mulX__NAME), uvlib_f32vector_mulX, NULL, NULL);
6316 
6317 static ScmObj uvlib_f64vector_mul(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6318 {
6319   ScmObj v0_scm;
6320   ScmF64Vector* v0;
6321   ScmObj v1_scm;
6322   ScmObj v1;
6323   ScmObj clamp_scm;
6324   ScmObj clamp;
6325   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
6326   SCM_ENTER_SUBR("f64vector-mul");
6327   if (Scm_Length(SCM_OPTARGS) > 1)
6328     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
6329   v0_scm = SCM_ARGREF(0);
6330   if (!SCM_F64VECTORP(v0_scm)) Scm_Error("<f64vector> required, but got %S", v0_scm);
6331   v0 = SCM_F64VECTOR(v0_scm);
6332   v1_scm = SCM_ARGREF(1);
6333   v1 = (v1_scm);
6334   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
6335   else {
6336     clamp_scm = SCM_CAR(SCM_OPTARGS);
6337     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
6338   }
6339   clamp = (clamp_scm);
6340   {
6341 SCM_RETURN(Scm_F64VectorMul(v0, v1, clamp_arg(clamp)));
6342   }
6343 }
6344 
6345 static SCM_DEFINE_STRING_CONST(uvlib_f64vector_mul__NAME, "f64vector-mul", 13, 13);
6346 static SCM_DEFINE_SUBR(uvlib_f64vector_mul__STUB, 2, 1, SCM_OBJ(&uvlib_f64vector_mul__NAME), uvlib_f64vector_mul, NULL, NULL);
6347 
6348 static ScmObj uvlib_f64vector_mulX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6349 {
6350   ScmObj v0_scm;
6351   ScmF64Vector* v0;
6352   ScmObj v1_scm;
6353   ScmObj v1;
6354   ScmObj clamp_scm;
6355   ScmObj clamp;
6356   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
6357   SCM_ENTER_SUBR("f64vector-mul!");
6358   if (Scm_Length(SCM_OPTARGS) > 1)
6359     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
6360   v0_scm = SCM_ARGREF(0);
6361   if (!SCM_F64VECTORP(v0_scm)) Scm_Error("<f64vector> required, but got %S", v0_scm);
6362   v0 = SCM_F64VECTOR(v0_scm);
6363   v1_scm = SCM_ARGREF(1);
6364   v1 = (v1_scm);
6365   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
6366   else {
6367     clamp_scm = SCM_CAR(SCM_OPTARGS);
6368     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
6369   }
6370   clamp = (clamp_scm);
6371   {
6372 SCM_RETURN(Scm_F64VectorMulX(v0, v1, clamp_arg(clamp)));
6373   }
6374 }
6375 
6376 static SCM_DEFINE_STRING_CONST(uvlib_f64vector_mulX__NAME, "f64vector-mul!", 14, 14);
6377 static SCM_DEFINE_SUBR(uvlib_f64vector_mulX__STUB, 2, 1, SCM_OBJ(&uvlib_f64vector_mulX__NAME), uvlib_f64vector_mulX, NULL, NULL);
6378 
6379 static ScmObj uvlib_f32vector_div(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6380 {
6381   ScmObj v0_scm;
6382   ScmF32Vector* v0;
6383   ScmObj v1_scm;
6384   ScmObj v1;
6385   ScmObj clamp_scm;
6386   ScmObj clamp;
6387   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
6388   SCM_ENTER_SUBR("f32vector-div");
6389   if (Scm_Length(SCM_OPTARGS) > 1)
6390     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
6391   v0_scm = SCM_ARGREF(0);
6392   if (!SCM_F32VECTORP(v0_scm)) Scm_Error("<f32vector> required, but got %S", v0_scm);
6393   v0 = SCM_F32VECTOR(v0_scm);
6394   v1_scm = SCM_ARGREF(1);
6395   v1 = (v1_scm);
6396   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
6397   else {
6398     clamp_scm = SCM_CAR(SCM_OPTARGS);
6399     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
6400   }
6401   clamp = (clamp_scm);
6402   {
6403 SCM_RETURN(Scm_F32VectorDiv(v0, v1, clamp_arg(clamp)));
6404   }
6405 }
6406 
6407 static SCM_DEFINE_STRING_CONST(uvlib_f32vector_div__NAME, "f32vector-div", 13, 13);
6408 static SCM_DEFINE_SUBR(uvlib_f32vector_div__STUB, 2, 1, SCM_OBJ(&uvlib_f32vector_div__NAME), uvlib_f32vector_div, NULL, NULL);
6409 
6410 static ScmObj uvlib_f32vector_divX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6411 {
6412   ScmObj v0_scm;
6413   ScmF32Vector* v0;
6414   ScmObj v1_scm;
6415   ScmObj v1;
6416   ScmObj clamp_scm;
6417   ScmObj clamp;
6418   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
6419   SCM_ENTER_SUBR("f32vector-div!");
6420   if (Scm_Length(SCM_OPTARGS) > 1)
6421     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
6422   v0_scm = SCM_ARGREF(0);
6423   if (!SCM_F32VECTORP(v0_scm)) Scm_Error("<f32vector> required, but got %S", v0_scm);
6424   v0 = SCM_F32VECTOR(v0_scm);
6425   v1_scm = SCM_ARGREF(1);
6426   v1 = (v1_scm);
6427   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
6428   else {
6429     clamp_scm = SCM_CAR(SCM_OPTARGS);
6430     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
6431   }
6432   clamp = (clamp_scm);
6433   {
6434 SCM_RETURN(Scm_F32VectorDivX(v0, v1, clamp_arg(clamp)));
6435   }
6436 }
6437 
6438 static SCM_DEFINE_STRING_CONST(uvlib_f32vector_divX__NAME, "f32vector-div!", 14, 14);
6439 static SCM_DEFINE_SUBR(uvlib_f32vector_divX__STUB, 2, 1, SCM_OBJ(&uvlib_f32vector_divX__NAME), uvlib_f32vector_divX, NULL, NULL);
6440 
6441 static ScmObj uvlib_f64vector_div(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6442 {
6443   ScmObj v0_scm;
6444   ScmF64Vector* v0;
6445   ScmObj v1_scm;
6446   ScmObj v1;
6447   ScmObj clamp_scm;
6448   ScmObj clamp;
6449   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
6450   SCM_ENTER_SUBR("f64vector-div");
6451   if (Scm_Length(SCM_OPTARGS) > 1)
6452     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
6453   v0_scm = SCM_ARGREF(0);
6454   if (!SCM_F64VECTORP(v0_scm)) Scm_Error("<f64vector> required, but got %S", v0_scm);
6455   v0 = SCM_F64VECTOR(v0_scm);
6456   v1_scm = SCM_ARGREF(1);
6457   v1 = (v1_scm);
6458   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
6459   else {
6460     clamp_scm = SCM_CAR(SCM_OPTARGS);
6461     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
6462   }
6463   clamp = (clamp_scm);
6464   {
6465 SCM_RETURN(Scm_F64VectorDiv(v0, v1, clamp_arg(clamp)));
6466   }
6467 }
6468 
6469 static SCM_DEFINE_STRING_CONST(uvlib_f64vector_div__NAME, "f64vector-div", 13, 13);
6470 static SCM_DEFINE_SUBR(uvlib_f64vector_div__STUB, 2, 1, SCM_OBJ(&uvlib_f64vector_div__NAME), uvlib_f64vector_div, NULL, NULL);
6471 
6472 static ScmObj uvlib_f64vector_divX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6473 {
6474   ScmObj v0_scm;
6475   ScmF64Vector* v0;
6476   ScmObj v1_scm;
6477   ScmObj v1;
6478   ScmObj clamp_scm;
6479   ScmObj clamp;
6480   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
6481   SCM_ENTER_SUBR("f64vector-div!");
6482   if (Scm_Length(SCM_OPTARGS) > 1)
6483     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
6484   v0_scm = SCM_ARGREF(0);
6485   if (!SCM_F64VECTORP(v0_scm)) Scm_Error("<f64vector> required, but got %S", v0_scm);
6486   v0 = SCM_F64VECTOR(v0_scm);
6487   v1_scm = SCM_ARGREF(1);
6488   v1 = (v1_scm);
6489   if (SCM_NULLP(SCM_OPTARGS)) clamp_scm = SCM_UNBOUND;
6490   else {
6491     clamp_scm = SCM_CAR(SCM_OPTARGS);
6492     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
6493   }
6494   clamp = (clamp_scm);
6495   {
6496 SCM_RETURN(Scm_F64VectorDivX(v0, v1, clamp_arg(clamp)));
6497   }
6498 }
6499 
6500 static SCM_DEFINE_STRING_CONST(uvlib_f64vector_divX__NAME, "f64vector-div!", 14, 14);
6501 static SCM_DEFINE_SUBR(uvlib_f64vector_divX__STUB, 2, 1, SCM_OBJ(&uvlib_f64vector_divX__NAME), uvlib_f64vector_divX, NULL, NULL);
6502 
6503 static ScmObj uvlib_s8vector_and(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6504 {
6505   ScmObj v0_scm;
6506   ScmS8Vector* v0;
6507   ScmObj v1_scm;
6508   ScmObj v1;
6509   SCM_ENTER_SUBR("s8vector-and");
6510   v0_scm = SCM_ARGREF(0);
6511   if (!SCM_S8VECTORP(v0_scm)) Scm_Error("<s8vector> required, but got %S", v0_scm);
6512   v0 = SCM_S8VECTOR(v0_scm);
6513   v1_scm = SCM_ARGREF(1);
6514   v1 = (v1_scm);
6515   {
6516 SCM_RETURN(Scm_S8VectorAnd(v0, v1));
6517   }
6518 }
6519 
6520 static SCM_DEFINE_STRING_CONST(uvlib_s8vector_and__NAME, "s8vector-and", 12, 12);
6521 static SCM_DEFINE_SUBR(uvlib_s8vector_and__STUB, 2, 0, SCM_OBJ(&uvlib_s8vector_and__NAME), uvlib_s8vector_and, NULL, NULL);
6522 
6523 static ScmObj uvlib_s8vector_andX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6524 {
6525   ScmObj v0_scm;
6526   ScmS8Vector* v0;
6527   ScmObj v1_scm;
6528   ScmObj v1;
6529   SCM_ENTER_SUBR("s8vector-and!");
6530   v0_scm = SCM_ARGREF(0);
6531   if (!SCM_S8VECTORP(v0_scm)) Scm_Error("<s8vector> required, but got %S", v0_scm);
6532   v0 = SCM_S8VECTOR(v0_scm);
6533   v1_scm = SCM_ARGREF(1);
6534   v1 = (v1_scm);
6535   {
6536 SCM_RETURN(Scm_S8VectorAndX(v0, v1));
6537   }
6538 }
6539 
6540 static SCM_DEFINE_STRING_CONST(uvlib_s8vector_andX__NAME, "s8vector-and!", 13, 13);
6541 static SCM_DEFINE_SUBR(uvlib_s8vector_andX__STUB, 2, 0, SCM_OBJ(&uvlib_s8vector_andX__NAME), uvlib_s8vector_andX, NULL, NULL);
6542 
6543 static ScmObj uvlib_s8vector_ior(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6544 {
6545   ScmObj v0_scm;
6546   ScmS8Vector* v0;
6547   ScmObj v1_scm;
6548   ScmObj v1;
6549   SCM_ENTER_SUBR("s8vector-ior");
6550   v0_scm = SCM_ARGREF(0);
6551   if (!SCM_S8VECTORP(v0_scm)) Scm_Error("<s8vector> required, but got %S", v0_scm);
6552   v0 = SCM_S8VECTOR(v0_scm);
6553   v1_scm = SCM_ARGREF(1);
6554   v1 = (v1_scm);
6555   {
6556 SCM_RETURN(Scm_S8VectorIor(v0, v1));
6557   }
6558 }
6559 
6560 static SCM_DEFINE_STRING_CONST(uvlib_s8vector_ior__NAME, "s8vector-ior", 12, 12);
6561 static SCM_DEFINE_SUBR(uvlib_s8vector_ior__STUB, 2, 0, SCM_OBJ(&uvlib_s8vector_ior__NAME), uvlib_s8vector_ior, NULL, NULL);
6562 
6563 static ScmObj uvlib_s8vector_iorX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6564 {
6565   ScmObj v0_scm;
6566   ScmS8Vector* v0;
6567   ScmObj v1_scm;
6568   ScmObj v1;
6569   SCM_ENTER_SUBR("s8vector-ior!");
6570   v0_scm = SCM_ARGREF(0);
6571   if (!SCM_S8VECTORP(v0_scm)) Scm_Error("<s8vector> required, but got %S", v0_scm);
6572   v0 = SCM_S8VECTOR(v0_scm);
6573   v1_scm = SCM_ARGREF(1);
6574   v1 = (v1_scm);
6575   {
6576 SCM_RETURN(Scm_S8VectorIorX(v0, v1));
6577   }
6578 }
6579 
6580 static SCM_DEFINE_STRING_CONST(uvlib_s8vector_iorX__NAME, "s8vector-ior!", 13, 13);
6581 static SCM_DEFINE_SUBR(uvlib_s8vector_iorX__STUB, 2, 0, SCM_OBJ(&uvlib_s8vector_iorX__NAME), uvlib_s8vector_iorX, NULL, NULL);
6582 
6583 static ScmObj uvlib_s8vector_xor(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6584 {
6585   ScmObj v0_scm;
6586   ScmS8Vector* v0;
6587   ScmObj v1_scm;
6588   ScmObj v1;
6589   SCM_ENTER_SUBR("s8vector-xor");
6590   v0_scm = SCM_ARGREF(0);
6591   if (!SCM_S8VECTORP(v0_scm)) Scm_Error("<s8vector> required, but got %S", v0_scm);
6592   v0 = SCM_S8VECTOR(v0_scm);
6593   v1_scm = SCM_ARGREF(1);
6594   v1 = (v1_scm);
6595   {
6596 SCM_RETURN(Scm_S8VectorXor(v0, v1));
6597   }
6598 }
6599 
6600 static SCM_DEFINE_STRING_CONST(uvlib_s8vector_xor__NAME, "s8vector-xor", 12, 12);
6601 static SCM_DEFINE_SUBR(uvlib_s8vector_xor__STUB, 2, 0, SCM_OBJ(&uvlib_s8vector_xor__NAME), uvlib_s8vector_xor, NULL, NULL);
6602 
6603 static ScmObj uvlib_s8vector_xorX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6604 {
6605   ScmObj v0_scm;
6606   ScmS8Vector* v0;
6607   ScmObj v1_scm;
6608   ScmObj v1;
6609   SCM_ENTER_SUBR("s8vector-xor!");
6610   v0_scm = SCM_ARGREF(0);
6611   if (!SCM_S8VECTORP(v0_scm)) Scm_Error("<s8vector> required, but got %S", v0_scm);
6612   v0 = SCM_S8VECTOR(v0_scm);
6613   v1_scm = SCM_ARGREF(1);
6614   v1 = (v1_scm);
6615   {
6616 SCM_RETURN(Scm_S8VectorXorX(v0, v1));
6617   }
6618 }
6619 
6620 static SCM_DEFINE_STRING_CONST(uvlib_s8vector_xorX__NAME, "s8vector-xor!", 13, 13);
6621 static SCM_DEFINE_SUBR(uvlib_s8vector_xorX__STUB, 2, 0, SCM_OBJ(&uvlib_s8vector_xorX__NAME), uvlib_s8vector_xorX, NULL, NULL);
6622 
6623 static ScmObj uvlib_u8vector_and(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6624 {
6625   ScmObj v0_scm;
6626   ScmU8Vector* v0;
6627   ScmObj v1_scm;
6628   ScmObj v1;
6629   SCM_ENTER_SUBR("u8vector-and");
6630   v0_scm = SCM_ARGREF(0);
6631   if (!SCM_U8VECTORP(v0_scm)) Scm_Error("<u8vector> required, but got %S", v0_scm);
6632   v0 = SCM_U8VECTOR(v0_scm);
6633   v1_scm = SCM_ARGREF(1);
6634   v1 = (v1_scm);
6635   {
6636 SCM_RETURN(Scm_U8VectorAnd(v0, v1));
6637   }
6638 }
6639 
6640 static SCM_DEFINE_STRING_CONST(uvlib_u8vector_and__NAME, "u8vector-and", 12, 12);
6641 static SCM_DEFINE_SUBR(uvlib_u8vector_and__STUB, 2, 0, SCM_OBJ(&uvlib_u8vector_and__NAME), uvlib_u8vector_and, NULL, NULL);
6642 
6643 static ScmObj uvlib_u8vector_andX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6644 {
6645   ScmObj v0_scm;
6646   ScmU8Vector* v0;
6647   ScmObj v1_scm;
6648   ScmObj v1;
6649   SCM_ENTER_SUBR("u8vector-and!");
6650   v0_scm = SCM_ARGREF(0);
6651   if (!SCM_U8VECTORP(v0_scm)) Scm_Error("<u8vector> required, but got %S", v0_scm);
6652   v0 = SCM_U8VECTOR(v0_scm);
6653   v1_scm = SCM_ARGREF(1);
6654   v1 = (v1_scm);
6655   {
6656 SCM_RETURN(Scm_U8VectorAndX(v0, v1));
6657   }
6658 }
6659 
6660 static SCM_DEFINE_STRING_CONST(uvlib_u8vector_andX__NAME, "u8vector-and!", 13, 13);
6661 static SCM_DEFINE_SUBR(uvlib_u8vector_andX__STUB, 2, 0, SCM_OBJ(&uvlib_u8vector_andX__NAME), uvlib_u8vector_andX, NULL, NULL);
6662 
6663 static ScmObj uvlib_u8vector_ior(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6664 {
6665   ScmObj v0_scm;
6666   ScmU8Vector* v0;
6667   ScmObj v1_scm;
6668   ScmObj v1;
6669   SCM_ENTER_SUBR("u8vector-ior");
6670   v0_scm = SCM_ARGREF(0);
6671   if (!SCM_U8VECTORP(v0_scm)) Scm_Error("<u8vector> required, but got %S", v0_scm);
6672   v0 = SCM_U8VECTOR(v0_scm);
6673   v1_scm = SCM_ARGREF(1);
6674   v1 = (v1_scm);
6675   {
6676 SCM_RETURN(Scm_U8VectorIor(v0, v1));
6677   }
6678 }
6679 
6680 static SCM_DEFINE_STRING_CONST(uvlib_u8vector_ior__NAME, "u8vector-ior", 12, 12);
6681 static SCM_DEFINE_SUBR(uvlib_u8vector_ior__STUB, 2, 0, SCM_OBJ(&uvlib_u8vector_ior__NAME), uvlib_u8vector_ior, NULL, NULL);
6682 
6683 static ScmObj uvlib_u8vector_iorX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6684 {
6685   ScmObj v0_scm;
6686   ScmU8Vector* v0;
6687   ScmObj v1_scm;
6688   ScmObj v1;
6689   SCM_ENTER_SUBR("u8vector-ior!");
6690   v0_scm = SCM_ARGREF(0);
6691   if (!SCM_U8VECTORP(v0_scm)) Scm_Error("<u8vector> required, but got %S", v0_scm);
6692   v0 = SCM_U8VECTOR(v0_scm);
6693   v1_scm = SCM_ARGREF(1);
6694   v1 = (v1_scm);
6695   {
6696 SCM_RETURN(Scm_U8VectorIorX(v0, v1));
6697   }
6698 }
6699 
6700 static SCM_DEFINE_STRING_CONST(uvlib_u8vector_iorX__NAME, "u8vector-ior!", 13, 13);
6701 static SCM_DEFINE_SUBR(uvlib_u8vector_iorX__STUB, 2, 0, SCM_OBJ(&uvlib_u8vector_iorX__NAME), uvlib_u8vector_iorX, NULL, NULL);
6702 
6703 static ScmObj uvlib_u8vector_xor(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6704 {
6705   ScmObj v0_scm;
6706   ScmU8Vector* v0;
6707   ScmObj v1_scm;
6708   ScmObj v1;
6709   SCM_ENTER_SUBR("u8vector-xor");
6710   v0_scm = SCM_ARGREF(0);
6711   if (!SCM_U8VECTORP(v0_scm)) Scm_Error("<u8vector> required, but got %S", v0_scm);
6712   v0 = SCM_U8VECTOR(v0_scm);
6713   v1_scm = SCM_ARGREF(1);
6714   v1 = (v1_scm);
6715   {
6716 SCM_RETURN(Scm_U8VectorXor(v0, v1));
6717   }
6718 }
6719 
6720 static SCM_DEFINE_STRING_CONST(uvlib_u8vector_xor__NAME, "u8vector-xor", 12, 12);
6721 static SCM_DEFINE_SUBR(uvlib_u8vector_xor__STUB, 2, 0, SCM_OBJ(&uvlib_u8vector_xor__NAME), uvlib_u8vector_xor, NULL, NULL);
6722 
6723 static ScmObj uvlib_u8vector_xorX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6724 {
6725   ScmObj v0_scm;
6726   ScmU8Vector* v0;
6727   ScmObj v1_scm;
6728   ScmObj v1;
6729   SCM_ENTER_SUBR("u8vector-xor!");
6730   v0_scm = SCM_ARGREF(0);
6731   if (!SCM_U8VECTORP(v0_scm)) Scm_Error("<u8vector> required, but got %S", v0_scm);
6732   v0 = SCM_U8VECTOR(v0_scm);
6733   v1_scm = SCM_ARGREF(1);
6734   v1 = (v1_scm);
6735   {
6736 SCM_RETURN(Scm_U8VectorXorX(v0, v1));
6737   }
6738 }
6739 
6740 static SCM_DEFINE_STRING_CONST(uvlib_u8vector_xorX__NAME, "u8vector-xor!", 13, 13);
6741 static SCM_DEFINE_SUBR(uvlib_u8vector_xorX__STUB, 2, 0, SCM_OBJ(&uvlib_u8vector_xorX__NAME), uvlib_u8vector_xorX, NULL, NULL);
6742 
6743 static ScmObj uvlib_s16vector_and(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6744 {
6745   ScmObj v0_scm;
6746   ScmS16Vector* v0;
6747   ScmObj v1_scm;
6748   ScmObj v1;
6749   SCM_ENTER_SUBR("s16vector-and");
6750   v0_scm = SCM_ARGREF(0);
6751   if (!SCM_S16VECTORP(v0_scm)) Scm_Error("<s16vector> required, but got %S", v0_scm);
6752   v0 = SCM_S16VECTOR(v0_scm);
6753   v1_scm = SCM_ARGREF(1);
6754   v1 = (v1_scm);
6755   {
6756 SCM_RETURN(Scm_S16VectorAnd(v0, v1));
6757   }
6758 }
6759 
6760 static SCM_DEFINE_STRING_CONST(uvlib_s16vector_and__NAME, "s16vector-and", 13, 13);
6761 static SCM_DEFINE_SUBR(uvlib_s16vector_and__STUB, 2, 0, SCM_OBJ(&uvlib_s16vector_and__NAME), uvlib_s16vector_and, NULL, NULL);
6762 
6763 static ScmObj uvlib_s16vector_andX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6764 {
6765   ScmObj v0_scm;
6766   ScmS16Vector* v0;
6767   ScmObj v1_scm;
6768   ScmObj v1;
6769   SCM_ENTER_SUBR("s16vector-and!");
6770   v0_scm = SCM_ARGREF(0);
6771   if (!SCM_S16VECTORP(v0_scm)) Scm_Error("<s16vector> required, but got %S", v0_scm);
6772   v0 = SCM_S16VECTOR(v0_scm);
6773   v1_scm = SCM_ARGREF(1);
6774   v1 = (v1_scm);
6775   {
6776 SCM_RETURN(Scm_S16VectorAndX(v0, v1));
6777   }
6778 }
6779 
6780 static SCM_DEFINE_STRING_CONST(uvlib_s16vector_andX__NAME, "s16vector-and!", 14, 14);
6781 static SCM_DEFINE_SUBR(uvlib_s16vector_andX__STUB, 2, 0, SCM_OBJ(&uvlib_s16vector_andX__NAME), uvlib_s16vector_andX, NULL, NULL);
6782 
6783 static ScmObj uvlib_s16vector_ior(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6784 {
6785   ScmObj v0_scm;
6786   ScmS16Vector* v0;
6787   ScmObj v1_scm;
6788   ScmObj v1;
6789   SCM_ENTER_SUBR("s16vector-ior");
6790   v0_scm = SCM_ARGREF(0);
6791   if (!SCM_S16VECTORP(v0_scm)) Scm_Error("<s16vector> required, but got %S", v0_scm);
6792   v0 = SCM_S16VECTOR(v0_scm);
6793   v1_scm = SCM_ARGREF(1);
6794   v1 = (v1_scm);
6795   {
6796 SCM_RETURN(Scm_S16VectorIor(v0, v1));
6797   }
6798 }
6799 
6800 static SCM_DEFINE_STRING_CONST(uvlib_s16vector_ior__NAME, "s16vector-ior", 13, 13);
6801 static SCM_DEFINE_SUBR(uvlib_s16vector_ior__STUB, 2, 0, SCM_OBJ(&uvlib_s16vector_ior__NAME), uvlib_s16vector_ior, NULL, NULL);
6802 
6803 static ScmObj uvlib_s16vector_iorX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6804 {
6805   ScmObj v0_scm;
6806   ScmS16Vector* v0;
6807   ScmObj v1_scm;
6808   ScmObj v1;
6809   SCM_ENTER_SUBR("s16vector-ior!");
6810   v0_scm = SCM_ARGREF(0);
6811   if (!SCM_S16VECTORP(v0_scm)) Scm_Error("<s16vector> required, but got %S", v0_scm);
6812   v0 = SCM_S16VECTOR(v0_scm);
6813   v1_scm = SCM_ARGREF(1);
6814   v1 = (v1_scm);
6815   {
6816 SCM_RETURN(Scm_S16VectorIorX(v0, v1));
6817   }
6818 }
6819 
6820 static SCM_DEFINE_STRING_CONST(uvlib_s16vector_iorX__NAME, "s16vector-ior!", 14, 14);
6821 static SCM_DEFINE_SUBR(uvlib_s16vector_iorX__STUB, 2, 0, SCM_OBJ(&uvlib_s16vector_iorX__NAME), uvlib_s16vector_iorX, NULL, NULL);
6822 
6823 static ScmObj uvlib_s16vector_xor(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6824 {
6825   ScmObj v0_scm;
6826   ScmS16Vector* v0;
6827   ScmObj v1_scm;
6828   ScmObj v1;
6829   SCM_ENTER_SUBR("s16vector-xor");
6830   v0_scm = SCM_ARGREF(0);
6831   if (!SCM_S16VECTORP(v0_scm)) Scm_Error("<s16vector> required, but got %S", v0_scm);
6832   v0 = SCM_S16VECTOR(v0_scm);
6833   v1_scm = SCM_ARGREF(1);
6834   v1 = (v1_scm);
6835   {
6836 SCM_RETURN(Scm_S16VectorXor(v0, v1));
6837   }
6838 }
6839 
6840 static SCM_DEFINE_STRING_CONST(uvlib_s16vector_xor__NAME, "s16vector-xor", 13, 13);
6841 static SCM_DEFINE_SUBR(uvlib_s16vector_xor__STUB, 2, 0, SCM_OBJ(&uvlib_s16vector_xor__NAME), uvlib_s16vector_xor, NULL, NULL);
6842 
6843 static ScmObj uvlib_s16vector_xorX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6844 {
6845   ScmObj v0_scm;
6846   ScmS16Vector* v0;
6847   ScmObj v1_scm;
6848   ScmObj v1;
6849   SCM_ENTER_SUBR("s16vector-xor!");
6850   v0_scm = SCM_ARGREF(0);
6851   if (!SCM_S16VECTORP(v0_scm)) Scm_Error("<s16vector> required, but got %S", v0_scm);
6852   v0 = SCM_S16VECTOR(v0_scm);
6853   v1_scm = SCM_ARGREF(1);
6854   v1 = (v1_scm);
6855   {
6856 SCM_RETURN(Scm_S16VectorXorX(v0, v1));
6857   }
6858 }
6859 
6860 static SCM_DEFINE_STRING_CONST(uvlib_s16vector_xorX__NAME, "s16vector-xor!", 14, 14);
6861 static SCM_DEFINE_SUBR(uvlib_s16vector_xorX__STUB, 2, 0, SCM_OBJ(&uvlib_s16vector_xorX__NAME), uvlib_s16vector_xorX, NULL, NULL);
6862 
6863 static ScmObj uvlib_u16vector_and(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6864 {
6865   ScmObj v0_scm;
6866   ScmU16Vector* v0;
6867   ScmObj v1_scm;
6868   ScmObj v1;
6869   SCM_ENTER_SUBR("u16vector-and");
6870   v0_scm = SCM_ARGREF(0);
6871   if (!SCM_U16VECTORP(v0_scm)) Scm_Error("<u16vector> required, but got %S", v0_scm);
6872   v0 = SCM_U16VECTOR(v0_scm);
6873   v1_scm = SCM_ARGREF(1);
6874   v1 = (v1_scm);
6875   {
6876 SCM_RETURN(Scm_U16VectorAnd(v0, v1));
6877   }
6878 }
6879 
6880 static SCM_DEFINE_STRING_CONST(uvlib_u16vector_and__NAME, "u16vector-and", 13, 13);
6881 static SCM_DEFINE_SUBR(uvlib_u16vector_and__STUB, 2, 0, SCM_OBJ(&uvlib_u16vector_and__NAME), uvlib_u16vector_and, NULL, NULL);
6882 
6883 static ScmObj uvlib_u16vector_andX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6884 {
6885   ScmObj v0_scm;
6886   ScmU16Vector* v0;
6887   ScmObj v1_scm;
6888   ScmObj v1;
6889   SCM_ENTER_SUBR("u16vector-and!");
6890   v0_scm = SCM_ARGREF(0);
6891   if (!SCM_U16VECTORP(v0_scm)) Scm_Error("<u16vector> required, but got %S", v0_scm);
6892   v0 = SCM_U16VECTOR(v0_scm);
6893   v1_scm = SCM_ARGREF(1);
6894   v1 = (v1_scm);
6895   {
6896 SCM_RETURN(Scm_U16VectorAndX(v0, v1));
6897   }
6898 }
6899 
6900 static SCM_DEFINE_STRING_CONST(uvlib_u16vector_andX__NAME, "u16vector-and!", 14, 14);
6901 static SCM_DEFINE_SUBR(uvlib_u16vector_andX__STUB, 2, 0, SCM_OBJ(&uvlib_u16vector_andX__NAME), uvlib_u16vector_andX, NULL, NULL);
6902 
6903 static ScmObj uvlib_u16vector_ior(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6904 {
6905   ScmObj v0_scm;
6906   ScmU16Vector* v0;
6907   ScmObj v1_scm;
6908   ScmObj v1;
6909   SCM_ENTER_SUBR("u16vector-ior");
6910   v0_scm = SCM_ARGREF(0);
6911   if (!SCM_U16VECTORP(v0_scm)) Scm_Error("<u16vector> required, but got %S", v0_scm);
6912   v0 = SCM_U16VECTOR(v0_scm);
6913   v1_scm = SCM_ARGREF(1);
6914   v1 = (v1_scm);
6915   {
6916 SCM_RETURN(Scm_U16VectorIor(v0, v1));
6917   }
6918 }
6919 
6920 static SCM_DEFINE_STRING_CONST(uvlib_u16vector_ior__NAME, "u16vector-ior", 13, 13);
6921 static SCM_DEFINE_SUBR(uvlib_u16vector_ior__STUB, 2, 0, SCM_OBJ(&uvlib_u16vector_ior__NAME), uvlib_u16vector_ior, NULL, NULL);
6922 
6923 static ScmObj uvlib_u16vector_iorX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6924 {
6925   ScmObj v0_scm;
6926   ScmU16Vector* v0;
6927   ScmObj v1_scm;
6928   ScmObj v1;
6929   SCM_ENTER_SUBR("u16vector-ior!");
6930   v0_scm = SCM_ARGREF(0);
6931   if (!SCM_U16VECTORP(v0_scm)) Scm_Error("<u16vector> required, but got %S", v0_scm);
6932   v0 = SCM_U16VECTOR(v0_scm);
6933   v1_scm = SCM_ARGREF(1);
6934   v1 = (v1_scm);
6935   {
6936 SCM_RETURN(Scm_U16VectorIorX(v0, v1));
6937   }
6938 }
6939 
6940 static SCM_DEFINE_STRING_CONST(uvlib_u16vector_iorX__NAME, "u16vector-ior!", 14, 14);
6941 static SCM_DEFINE_SUBR(uvlib_u16vector_iorX__STUB, 2, 0, SCM_OBJ(&uvlib_u16vector_iorX__NAME), uvlib_u16vector_iorX, NULL, NULL);
6942 
6943 static ScmObj uvlib_u16vector_xor(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6944 {
6945   ScmObj v0_scm;
6946   ScmU16Vector* v0;
6947   ScmObj v1_scm;
6948   ScmObj v1;
6949   SCM_ENTER_SUBR("u16vector-xor");
6950   v0_scm = SCM_ARGREF(0);
6951   if (!SCM_U16VECTORP(v0_scm)) Scm_Error("<u16vector> required, but got %S", v0_scm);
6952   v0 = SCM_U16VECTOR(v0_scm);
6953   v1_scm = SCM_ARGREF(1);
6954   v1 = (v1_scm);
6955   {
6956 SCM_RETURN(Scm_U16VectorXor(v0, v1));
6957   }
6958 }
6959 
6960 static SCM_DEFINE_STRING_CONST(uvlib_u16vector_xor__NAME, "u16vector-xor", 13, 13);
6961 static SCM_DEFINE_SUBR(uvlib_u16vector_xor__STUB, 2, 0, SCM_OBJ(&uvlib_u16vector_xor__NAME), uvlib_u16vector_xor, NULL, NULL);
6962 
6963 static ScmObj uvlib_u16vector_xorX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6964 {
6965   ScmObj v0_scm;
6966   ScmU16Vector* v0;
6967   ScmObj v1_scm;
6968   ScmObj v1;
6969   SCM_ENTER_SUBR("u16vector-xor!");
6970   v0_scm = SCM_ARGREF(0);
6971   if (!SCM_U16VECTORP(v0_scm)) Scm_Error("<u16vector> required, but got %S", v0_scm);
6972   v0 = SCM_U16VECTOR(v0_scm);
6973   v1_scm = SCM_ARGREF(1);
6974   v1 = (v1_scm);
6975   {
6976 SCM_RETURN(Scm_U16VectorXorX(v0, v1));
6977   }
6978 }
6979 
6980 static SCM_DEFINE_STRING_CONST(uvlib_u16vector_xorX__NAME, "u16vector-xor!", 14, 14);
6981 static SCM_DEFINE_SUBR(uvlib_u16vector_xorX__STUB, 2, 0, SCM_OBJ(&uvlib_u16vector_xorX__NAME), uvlib_u16vector_xorX, NULL, NULL);
6982 
6983 static ScmObj uvlib_s32vector_and(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
6984 {
6985   ScmObj v0_scm;
6986   ScmS32Vector* v0;
6987   ScmObj v1_scm;
6988   ScmObj v1;
6989   SCM_ENTER_SUBR("s32vector-and");
6990   v0_scm = SCM_ARGREF(0);
6991   if (!SCM_S32VECTORP(v0_scm)) Scm_Error("<s32vector> required, but got %S", v0_scm);
6992   v0 = SCM_S32VECTOR(v0_scm);
6993   v1_scm = SCM_ARGREF(1);
6994   v1 = (v1_scm);
6995   {
6996 SCM_RETURN(Scm_S32VectorAnd(v0, v1));
6997   }
6998 }
6999 
7000 static SCM_DEFINE_STRING_CONST(uvlib_s32vector_and__NAME, "s32vector-and", 13, 13);
7001 static SCM_DEFINE_SUBR(uvlib_s32vector_and__STUB, 2, 0, SCM_OBJ(&uvlib_s32vector_and__NAME), uvlib_s32vector_and, NULL, NULL);
7002 
7003 static ScmObj uvlib_s32vector_andX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7004 {
7005   ScmObj v0_scm;
7006   ScmS32Vector* v0;
7007   ScmObj v1_scm;
7008   ScmObj v1;
7009   SCM_ENTER_SUBR("s32vector-and!");
7010   v0_scm = SCM_ARGREF(0);
7011   if (!SCM_S32VECTORP(v0_scm)) Scm_Error("<s32vector> required, but got %S", v0_scm);
7012   v0 = SCM_S32VECTOR(v0_scm);
7013   v1_scm = SCM_ARGREF(1);
7014   v1 = (v1_scm);
7015   {
7016 SCM_RETURN(Scm_S32VectorAndX(v0, v1));
7017   }
7018 }
7019 
7020 static SCM_DEFINE_STRING_CONST(uvlib_s32vector_andX__NAME, "s32vector-and!", 14, 14);
7021 static SCM_DEFINE_SUBR(uvlib_s32vector_andX__STUB, 2, 0, SCM_OBJ(&uvlib_s32vector_andX__NAME), uvlib_s32vector_andX, NULL, NULL);
7022 
7023 static ScmObj uvlib_s32vector_ior(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7024 {
7025   ScmObj v0_scm;
7026   ScmS32Vector* v0;
7027   ScmObj v1_scm;
7028   ScmObj v1;
7029   SCM_ENTER_SUBR("s32vector-ior");
7030   v0_scm = SCM_ARGREF(0);
7031   if (!SCM_S32VECTORP(v0_scm)) Scm_Error("<s32vector> required, but got %S", v0_scm);
7032   v0 = SCM_S32VECTOR(v0_scm);
7033   v1_scm = SCM_ARGREF(1);
7034   v1 = (v1_scm);
7035   {
7036 SCM_RETURN(Scm_S32VectorIor(v0, v1));
7037   }
7038 }
7039 
7040 static SCM_DEFINE_STRING_CONST(uvlib_s32vector_ior__NAME, "s32vector-ior", 13, 13);
7041 static SCM_DEFINE_SUBR(uvlib_s32vector_ior__STUB, 2, 0, SCM_OBJ(&uvlib_s32vector_ior__NAME), uvlib_s32vector_ior, NULL, NULL);
7042 
7043 static ScmObj uvlib_s32vector_iorX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7044 {
7045   ScmObj v0_scm;
7046   ScmS32Vector* v0;
7047   ScmObj v1_scm;
7048   ScmObj v1;
7049   SCM_ENTER_SUBR("s32vector-ior!");
7050   v0_scm = SCM_ARGREF(0);
7051   if (!SCM_S32VECTORP(v0_scm)) Scm_Error("<s32vector> required, but got %S", v0_scm);
7052   v0 = SCM_S32VECTOR(v0_scm);
7053   v1_scm = SCM_ARGREF(1);
7054   v1 = (v1_scm);
7055   {
7056 SCM_RETURN(Scm_S32VectorIorX(v0, v1));
7057   }
7058 }
7059 
7060 static SCM_DEFINE_STRING_CONST(uvlib_s32vector_iorX__NAME, "s32vector-ior!", 14, 14);
7061 static SCM_DEFINE_SUBR(uvlib_s32vector_iorX__STUB, 2, 0, SCM_OBJ(&uvlib_s32vector_iorX__NAME), uvlib_s32vector_iorX, NULL, NULL);
7062 
7063 static ScmObj uvlib_s32vector_xor(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7064 {
7065   ScmObj v0_scm;
7066   ScmS32Vector* v0;
7067   ScmObj v1_scm;
7068   ScmObj v1;
7069   SCM_ENTER_SUBR("s32vector-xor");
7070   v0_scm = SCM_ARGREF(0);
7071   if (!SCM_S32VECTORP(v0_scm)) Scm_Error("<s32vector> required, but got %S", v0_scm);
7072   v0 = SCM_S32VECTOR(v0_scm);
7073   v1_scm = SCM_ARGREF(1);
7074   v1 = (v1_scm);
7075   {
7076 SCM_RETURN(Scm_S32VectorXor(v0, v1));
7077   }
7078 }
7079 
7080 static SCM_DEFINE_STRING_CONST(uvlib_s32vector_xor__NAME, "s32vector-xor", 13, 13);
7081 static SCM_DEFINE_SUBR(uvlib_s32vector_xor__STUB, 2, 0, SCM_OBJ(&uvlib_s32vector_xor__NAME), uvlib_s32vector_xor, NULL, NULL);
7082 
7083 static ScmObj uvlib_s32vector_xorX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7084 {
7085   ScmObj v0_scm;
7086   ScmS32Vector* v0;
7087   ScmObj v1_scm;
7088   ScmObj v1;
7089   SCM_ENTER_SUBR("s32vector-xor!");
7090   v0_scm = SCM_ARGREF(0);
7091   if (!SCM_S32VECTORP(v0_scm)) Scm_Error("<s32vector> required, but got %S", v0_scm);
7092   v0 = SCM_S32VECTOR(v0_scm);
7093   v1_scm = SCM_ARGREF(1);
7094   v1 = (v1_scm);
7095   {
7096 SCM_RETURN(Scm_S32VectorXorX(v0, v1));
7097   }
7098 }
7099 
7100 static SCM_DEFINE_STRING_CONST(uvlib_s32vector_xorX__NAME, "s32vector-xor!", 14, 14);
7101 static SCM_DEFINE_SUBR(uvlib_s32vector_xorX__STUB, 2, 0, SCM_OBJ(&uvlib_s32vector_xorX__NAME), uvlib_s32vector_xorX, NULL, NULL);
7102 
7103 static ScmObj uvlib_u32vector_and(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7104 {
7105   ScmObj v0_scm;
7106   ScmU32Vector* v0;
7107   ScmObj v1_scm;
7108   ScmObj v1;
7109   SCM_ENTER_SUBR("u32vector-and");
7110   v0_scm = SCM_ARGREF(0);
7111   if (!SCM_U32VECTORP(v0_scm)) Scm_Error("<u32vector> required, but got %S", v0_scm);
7112   v0 = SCM_U32VECTOR(v0_scm);
7113   v1_scm = SCM_ARGREF(1);
7114   v1 = (v1_scm);
7115   {
7116 SCM_RETURN(Scm_U32VectorAnd(v0, v1));
7117   }
7118 }
7119 
7120 static SCM_DEFINE_STRING_CONST(uvlib_u32vector_and__NAME, "u32vector-and", 13, 13);
7121 static SCM_DEFINE_SUBR(uvlib_u32vector_and__STUB, 2, 0, SCM_OBJ(&uvlib_u32vector_and__NAME), uvlib_u32vector_and, NULL, NULL);
7122 
7123 static ScmObj uvlib_u32vector_andX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7124 {
7125   ScmObj v0_scm;
7126   ScmU32Vector* v0;
7127   ScmObj v1_scm;
7128   ScmObj v1;
7129   SCM_ENTER_SUBR("u32vector-and!");
7130   v0_scm = SCM_ARGREF(0);
7131   if (!SCM_U32VECTORP(v0_scm)) Scm_Error("<u32vector> required, but got %S", v0_scm);
7132   v0 = SCM_U32VECTOR(v0_scm);
7133   v1_scm = SCM_ARGREF(1);
7134   v1 = (v1_scm);
7135   {
7136 SCM_RETURN(Scm_U32VectorAndX(v0, v1));
7137   }
7138 }
7139 
7140 static SCM_DEFINE_STRING_CONST(uvlib_u32vector_andX__NAME, "u32vector-and!", 14, 14);
7141 static SCM_DEFINE_SUBR(uvlib_u32vector_andX__STUB, 2, 0, SCM_OBJ(&uvlib_u32vector_andX__NAME), uvlib_u32vector_andX, NULL, NULL);
7142 
7143 static ScmObj uvlib_u32vector_ior(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7144 {
7145   ScmObj v0_scm;
7146   ScmU32Vector* v0;
7147   ScmObj v1_scm;
7148   ScmObj v1;
7149   SCM_ENTER_SUBR("u32vector-ior");
7150   v0_scm = SCM_ARGREF(0);
7151   if (!SCM_U32VECTORP(v0_scm)) Scm_Error("<u32vector> required, but got %S", v0_scm);
7152   v0 = SCM_U32VECTOR(v0_scm);
7153   v1_scm = SCM_ARGREF(1);
7154   v1 = (v1_scm);
7155   {
7156 SCM_RETURN(Scm_U32VectorIor(v0, v1));
7157   }
7158 }
7159 
7160 static SCM_DEFINE_STRING_CONST(uvlib_u32vector_ior__NAME, "u32vector-ior", 13, 13);
7161 static SCM_DEFINE_SUBR(uvlib_u32vector_ior__STUB, 2, 0, SCM_OBJ(&uvlib_u32vector_ior__NAME), uvlib_u32vector_ior, NULL, NULL);
7162 
7163 static ScmObj uvlib_u32vector_iorX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7164 {
7165   ScmObj v0_scm;
7166   ScmU32Vector* v0;
7167   ScmObj v1_scm;
7168   ScmObj v1;
7169   SCM_ENTER_SUBR("u32vector-ior!");
7170   v0_scm = SCM_ARGREF(0);
7171   if (!SCM_U32VECTORP(v0_scm)) Scm_Error("<u32vector> required, but got %S", v0_scm);
7172   v0 = SCM_U32VECTOR(v0_scm);
7173   v1_scm = SCM_ARGREF(1);
7174   v1 = (v1_scm);
7175   {
7176 SCM_RETURN(Scm_U32VectorIorX(v0, v1));
7177   }
7178 }
7179 
7180 static SCM_DEFINE_STRING_CONST(uvlib_u32vector_iorX__NAME, "u32vector-ior!", 14, 14);
7181 static SCM_DEFINE_SUBR(uvlib_u32vector_iorX__STUB, 2, 0, SCM_OBJ(&uvlib_u32vector_iorX__NAME), uvlib_u32vector_iorX, NULL, NULL);
7182 
7183 static ScmObj uvlib_u32vector_xor(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7184 {
7185   ScmObj v0_scm;
7186   ScmU32Vector* v0;
7187   ScmObj v1_scm;
7188   ScmObj v1;
7189   SCM_ENTER_SUBR("u32vector-xor");
7190   v0_scm = SCM_ARGREF(0);
7191   if (!SCM_U32VECTORP(v0_scm)) Scm_Error("<u32vector> required, but got %S", v0_scm);
7192   v0 = SCM_U32VECTOR(v0_scm);
7193   v1_scm = SCM_ARGREF(1);
7194   v1 = (v1_scm);
7195   {
7196 SCM_RETURN(Scm_U32VectorXor(v0, v1));
7197   }
7198 }
7199 
7200 static SCM_DEFINE_STRING_CONST(uvlib_u32vector_xor__NAME, "u32vector-xor", 13, 13);
7201 static SCM_DEFINE_SUBR(uvlib_u32vector_xor__STUB, 2, 0, SCM_OBJ(&uvlib_u32vector_xor__NAME), uvlib_u32vector_xor, NULL, NULL);
7202 
7203 static ScmObj uvlib_u32vector_xorX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7204 {
7205   ScmObj v0_scm;
7206   ScmU32Vector* v0;
7207   ScmObj v1_scm;
7208   ScmObj v1;
7209   SCM_ENTER_SUBR("u32vector-xor!");
7210   v0_scm = SCM_ARGREF(0);
7211   if (!SCM_U32VECTORP(v0_scm)) Scm_Error("<u32vector> required, but got %S", v0_scm);
7212   v0 = SCM_U32VECTOR(v0_scm);
7213   v1_scm = SCM_ARGREF(1);
7214   v1 = (v1_scm);
7215   {
7216 SCM_RETURN(Scm_U32VectorXorX(v0, v1));
7217   }
7218 }
7219 
7220 static SCM_DEFINE_STRING_CONST(uvlib_u32vector_xorX__NAME, "u32vector-xor!", 14, 14);
7221 static SCM_DEFINE_SUBR(uvlib_u32vector_xorX__STUB, 2, 0, SCM_OBJ(&uvlib_u32vector_xorX__NAME), uvlib_u32vector_xorX, NULL, NULL);
7222 
7223 static ScmObj uvlib_s64vector_and(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7224 {
7225   ScmObj v0_scm;
7226   ScmS64Vector* v0;
7227   ScmObj v1_scm;
7228   ScmObj v1;
7229   SCM_ENTER_SUBR("s64vector-and");
7230   v0_scm = SCM_ARGREF(0);
7231   if (!SCM_S64VECTORP(v0_scm)) Scm_Error("<s64vector> required, but got %S", v0_scm);
7232   v0 = SCM_S64VECTOR(v0_scm);
7233   v1_scm = SCM_ARGREF(1);
7234   v1 = (v1_scm);
7235   {
7236 SCM_RETURN(Scm_S64VectorAnd(v0, v1));
7237   }
7238 }
7239 
7240 static SCM_DEFINE_STRING_CONST(uvlib_s64vector_and__NAME, "s64vector-and", 13, 13);
7241 static SCM_DEFINE_SUBR(uvlib_s64vector_and__STUB, 2, 0, SCM_OBJ(&uvlib_s64vector_and__NAME), uvlib_s64vector_and, NULL, NULL);
7242 
7243 static ScmObj uvlib_s64vector_andX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7244 {
7245   ScmObj v0_scm;
7246   ScmS64Vector* v0;
7247   ScmObj v1_scm;
7248   ScmObj v1;
7249   SCM_ENTER_SUBR("s64vector-and!");
7250   v0_scm = SCM_ARGREF(0);
7251   if (!SCM_S64VECTORP(v0_scm)) Scm_Error("<s64vector> required, but got %S", v0_scm);
7252   v0 = SCM_S64VECTOR(v0_scm);
7253   v1_scm = SCM_ARGREF(1);
7254   v1 = (v1_scm);
7255   {
7256 SCM_RETURN(Scm_S64VectorAndX(v0, v1));
7257   }
7258 }
7259 
7260 static SCM_DEFINE_STRING_CONST(uvlib_s64vector_andX__NAME, "s64vector-and!", 14, 14);
7261 static SCM_DEFINE_SUBR(uvlib_s64vector_andX__STUB, 2, 0, SCM_OBJ(&uvlib_s64vector_andX__NAME), uvlib_s64vector_andX, NULL, NULL);
7262 
7263 static ScmObj uvlib_s64vector_ior(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7264 {
7265   ScmObj v0_scm;
7266   ScmS64Vector* v0;
7267   ScmObj v1_scm;
7268   ScmObj v1;
7269   SCM_ENTER_SUBR("s64vector-ior");
7270   v0_scm = SCM_ARGREF(0);
7271   if (!SCM_S64VECTORP(v0_scm)) Scm_Error("<s64vector> required, but got %S", v0_scm);
7272   v0 = SCM_S64VECTOR(v0_scm);
7273   v1_scm = SCM_ARGREF(1);
7274   v1 = (v1_scm);
7275   {
7276 SCM_RETURN(Scm_S64VectorIor(v0, v1));
7277   }
7278 }
7279 
7280 static SCM_DEFINE_STRING_CONST(uvlib_s64vector_ior__NAME, "s64vector-ior", 13, 13);
7281 static SCM_DEFINE_SUBR(uvlib_s64vector_ior__STUB, 2, 0, SCM_OBJ(&uvlib_s64vector_ior__NAME), uvlib_s64vector_ior, NULL, NULL);
7282 
7283 static ScmObj uvlib_s64vector_iorX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7284 {
7285   ScmObj v0_scm;
7286   ScmS64Vector* v0;
7287   ScmObj v1_scm;
7288   ScmObj v1;
7289   SCM_ENTER_SUBR("s64vector-ior!");
7290   v0_scm = SCM_ARGREF(0);
7291   if (!SCM_S64VECTORP(v0_scm)) Scm_Error("<s64vector> required, but got %S", v0_scm);
7292   v0 = SCM_S64VECTOR(v0_scm);
7293   v1_scm = SCM_ARGREF(1);
7294   v1 = (v1_scm);
7295   {
7296 SCM_RETURN(Scm_S64VectorIorX(v0, v1));
7297   }
7298 }
7299 
7300 static SCM_DEFINE_STRING_CONST(uvlib_s64vector_iorX__NAME, "s64vector-ior!", 14, 14);
7301 static SCM_DEFINE_SUBR(uvlib_s64vector_iorX__STUB, 2, 0, SCM_OBJ(&uvlib_s64vector_iorX__NAME), uvlib_s64vector_iorX, NULL, NULL);
7302 
7303 static ScmObj uvlib_s64vector_xor(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7304 {
7305   ScmObj v0_scm;
7306   ScmS64Vector* v0;
7307   ScmObj v1_scm;
7308   ScmObj v1;
7309   SCM_ENTER_SUBR("s64vector-xor");
7310   v0_scm = SCM_ARGREF(0);
7311   if (!SCM_S64VECTORP(v0_scm)) Scm_Error("<s64vector> required, but got %S", v0_scm);
7312   v0 = SCM_S64VECTOR(v0_scm);
7313   v1_scm = SCM_ARGREF(1);
7314   v1 = (v1_scm);
7315   {
7316 SCM_RETURN(Scm_S64VectorXor(v0, v1));
7317   }
7318 }
7319 
7320 static SCM_DEFINE_STRING_CONST(uvlib_s64vector_xor__NAME, "s64vector-xor", 13, 13);
7321 static SCM_DEFINE_SUBR(uvlib_s64vector_xor__STUB, 2, 0, SCM_OBJ(&uvlib_s64vector_xor__NAME), uvlib_s64vector_xor, NULL, NULL);
7322 
7323 static ScmObj uvlib_s64vector_xorX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7324 {
7325   ScmObj v0_scm;
7326   ScmS64Vector* v0;
7327   ScmObj v1_scm;
7328   ScmObj v1;
7329   SCM_ENTER_SUBR("s64vector-xor!");
7330   v0_scm = SCM_ARGREF(0);
7331   if (!SCM_S64VECTORP(v0_scm)) Scm_Error("<s64vector> required, but got %S", v0_scm);
7332   v0 = SCM_S64VECTOR(v0_scm);
7333   v1_scm = SCM_ARGREF(1);
7334   v1 = (v1_scm);
7335   {
7336 SCM_RETURN(Scm_S64VectorXorX(v0, v1));
7337   }
7338 }
7339 
7340 static SCM_DEFINE_STRING_CONST(uvlib_s64vector_xorX__NAME, "s64vector-xor!", 14, 14);
7341 static SCM_DEFINE_SUBR(uvlib_s64vector_xorX__STUB, 2, 0, SCM_OBJ(&uvlib_s64vector_xorX__NAME), uvlib_s64vector_xorX, NULL, NULL);
7342 
7343 static ScmObj uvlib_u64vector_and(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7344 {
7345   ScmObj v0_scm;
7346   ScmU64Vector* v0;
7347   ScmObj v1_scm;
7348   ScmObj v1;
7349   SCM_ENTER_SUBR("u64vector-and");
7350   v0_scm = SCM_ARGREF(0);
7351   if (!SCM_U64VECTORP(v0_scm)) Scm_Error("<u64vector> required, but got %S", v0_scm);
7352   v0 = SCM_U64VECTOR(v0_scm);
7353   v1_scm = SCM_ARGREF(1);
7354   v1 = (v1_scm);
7355   {
7356 SCM_RETURN(Scm_U64VectorAnd(v0, v1));
7357   }
7358 }
7359 
7360 static SCM_DEFINE_STRING_CONST(uvlib_u64vector_and__NAME, "u64vector-and", 13, 13);
7361 static SCM_DEFINE_SUBR(uvlib_u64vector_and__STUB, 2, 0, SCM_OBJ(&uvlib_u64vector_and__NAME), uvlib_u64vector_and, NULL, NULL);
7362 
7363 static ScmObj uvlib_u64vector_andX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7364 {
7365   ScmObj v0_scm;
7366   ScmU64Vector* v0;
7367   ScmObj v1_scm;
7368   ScmObj v1;
7369   SCM_ENTER_SUBR("u64vector-and!");
7370   v0_scm = SCM_ARGREF(0);
7371   if (!SCM_U64VECTORP(v0_scm)) Scm_Error("<u64vector> required, but got %S", v0_scm);
7372   v0 = SCM_U64VECTOR(v0_scm);
7373   v1_scm = SCM_ARGREF(1);
7374   v1 = (v1_scm);
7375   {
7376 SCM_RETURN(Scm_U64VectorAndX(v0, v1));
7377   }
7378 }
7379 
7380 static SCM_DEFINE_STRING_CONST(uvlib_u64vector_andX__NAME, "u64vector-and!", 14, 14);
7381 static SCM_DEFINE_SUBR(uvlib_u64vector_andX__STUB, 2, 0, SCM_OBJ(&uvlib_u64vector_andX__NAME), uvlib_u64vector_andX, NULL, NULL);
7382 
7383 static ScmObj uvlib_u64vector_ior(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7384 {
7385   ScmObj v0_scm;
7386   ScmU64Vector* v0;
7387   ScmObj v1_scm;
7388   ScmObj v1;
7389   SCM_ENTER_SUBR("u64vector-ior");
7390   v0_scm = SCM_ARGREF(0);
7391   if (!SCM_U64VECTORP(v0_scm)) Scm_Error("<u64vector> required, but got %S", v0_scm);
7392   v0 = SCM_U64VECTOR(v0_scm);
7393   v1_scm = SCM_ARGREF(1);
7394   v1 = (v1_scm);
7395   {
7396 SCM_RETURN(Scm_U64VectorIor(v0, v1));
7397   }
7398 }
7399 
7400 static SCM_DEFINE_STRING_CONST(uvlib_u64vector_ior__NAME, "u64vector-ior", 13, 13);
7401 static SCM_DEFINE_SUBR(uvlib_u64vector_ior__STUB, 2, 0, SCM_OBJ(&uvlib_u64vector_ior__NAME), uvlib_u64vector_ior, NULL, NULL);
7402 
7403 static ScmObj uvlib_u64vector_iorX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7404 {
7405   ScmObj v0_scm;
7406   ScmU64Vector* v0;
7407   ScmObj v1_scm;
7408   ScmObj v1;
7409   SCM_ENTER_SUBR("u64vector-ior!");
7410   v0_scm = SCM_ARGREF(0);
7411   if (!SCM_U64VECTORP(v0_scm)) Scm_Error("<u64vector> required, but got %S", v0_scm);
7412   v0 = SCM_U64VECTOR(v0_scm);
7413   v1_scm = SCM_ARGREF(1);
7414   v1 = (v1_scm);
7415   {
7416 SCM_RETURN(Scm_U64VectorIorX(v0, v1));
7417   }
7418 }
7419 
7420 static SCM_DEFINE_STRING_CONST(uvlib_u64vector_iorX__NAME, "u64vector-ior!", 14, 14);
7421 static SCM_DEFINE_SUBR(uvlib_u64vector_iorX__STUB, 2, 0, SCM_OBJ(&uvlib_u64vector_iorX__NAME), uvlib_u64vector_iorX, NULL, NULL);
7422 
7423 static ScmObj uvlib_u64vector_xor(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7424 {
7425   ScmObj v0_scm;
7426   ScmU64Vector* v0;
7427   ScmObj v1_scm;
7428   ScmObj v1;
7429   SCM_ENTER_SUBR("u64vector-xor");
7430   v0_scm = SCM_ARGREF(0);
7431   if (!SCM_U64VECTORP(v0_scm)) Scm_Error("<u64vector> required, but got %S", v0_scm);
7432   v0 = SCM_U64VECTOR(v0_scm);
7433   v1_scm = SCM_ARGREF(1);
7434   v1 = (v1_scm);
7435   {
7436 SCM_RETURN(Scm_U64VectorXor(v0, v1));
7437   }
7438 }
7439 
7440 static SCM_DEFINE_STRING_CONST(uvlib_u64vector_xor__NAME, "u64vector-xor", 13, 13);
7441 static SCM_DEFINE_SUBR(uvlib_u64vector_xor__STUB, 2, 0, SCM_OBJ(&uvlib_u64vector_xor__NAME), uvlib_u64vector_xor, NULL, NULL);
7442 
7443 static ScmObj uvlib_u64vector_xorX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7444 {
7445   ScmObj v0_scm;
7446   ScmU64Vector* v0;
7447   ScmObj v1_scm;
7448   ScmObj v1;
7449   SCM_ENTER_SUBR("u64vector-xor!");
7450   v0_scm = SCM_ARGREF(0);
7451   if (!SCM_U64VECTORP(v0_scm)) Scm_Error("<u64vector> required, but got %S", v0_scm);
7452   v0 = SCM_U64VECTOR(v0_scm);
7453   v1_scm = SCM_ARGREF(1);
7454   v1 = (v1_scm);
7455   {
7456 SCM_RETURN(Scm_U64VectorXorX(v0, v1));
7457   }
7458 }
7459 
7460 static SCM_DEFINE_STRING_CONST(uvlib_u64vector_xorX__NAME, "u64vector-xor!", 14, 14);
7461 static SCM_DEFINE_SUBR(uvlib_u64vector_xorX__STUB, 2, 0, SCM_OBJ(&uvlib_u64vector_xorX__NAME), uvlib_u64vector_xorX, NULL, NULL);
7462 
7463 static ScmObj uvlib_s8vector_dot(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7464 {
7465   ScmObj v0_scm;
7466   ScmS8Vector* v0;
7467   ScmObj v1_scm;
7468   ScmObj v1;
7469   SCM_ENTER_SUBR("s8vector-dot");
7470   v0_scm = SCM_ARGREF(0);
7471   if (!SCM_S8VECTORP(v0_scm)) Scm_Error("<s8vector> required, but got %S", v0_scm);
7472   v0 = SCM_S8VECTOR(v0_scm);
7473   v1_scm = SCM_ARGREF(1);
7474   v1 = (v1_scm);
7475   {
7476 {
7477 ScmObj SCM_RESULT;
7478 SCM_RESULT = Scm_S8VectorDotProd(v0, v1);
7479 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
7480 }
7481   }
7482 }
7483 
7484 static SCM_DEFINE_STRING_CONST(uvlib_s8vector_dot__NAME, "s8vector-dot", 12, 12);
7485 static SCM_DEFINE_SUBR(uvlib_s8vector_dot__STUB, 2, 0, SCM_OBJ(&uvlib_s8vector_dot__NAME), uvlib_s8vector_dot, NULL, NULL);
7486 
7487 static ScmObj uvlib_u8vector_dot(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7488 {
7489   ScmObj v0_scm;
7490   ScmU8Vector* v0;
7491   ScmObj v1_scm;
7492   ScmObj v1;
7493   SCM_ENTER_SUBR("u8vector-dot");
7494   v0_scm = SCM_ARGREF(0);
7495   if (!SCM_U8VECTORP(v0_scm)) Scm_Error("<u8vector> required, but got %S", v0_scm);
7496   v0 = SCM_U8VECTOR(v0_scm);
7497   v1_scm = SCM_ARGREF(1);
7498   v1 = (v1_scm);
7499   {
7500 {
7501 ScmObj SCM_RESULT;
7502 SCM_RESULT = Scm_U8VectorDotProd(v0, v1);
7503 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
7504 }
7505   }
7506 }
7507 
7508 static SCM_DEFINE_STRING_CONST(uvlib_u8vector_dot__NAME, "u8vector-dot", 12, 12);
7509 static SCM_DEFINE_SUBR(uvlib_u8vector_dot__STUB, 2, 0, SCM_OBJ(&uvlib_u8vector_dot__NAME), uvlib_u8vector_dot, NULL, NULL);
7510 
7511 static ScmObj uvlib_s16vector_dot(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7512 {
7513   ScmObj v0_scm;
7514   ScmS16Vector* v0;
7515   ScmObj v1_scm;
7516   ScmObj v1;
7517   SCM_ENTER_SUBR("s16vector-dot");
7518   v0_scm = SCM_ARGREF(0);
7519   if (!SCM_S16VECTORP(v0_scm)) Scm_Error("<s16vector> required, but got %S", v0_scm);
7520   v0 = SCM_S16VECTOR(v0_scm);
7521   v1_scm = SCM_ARGREF(1);
7522   v1 = (v1_scm);
7523   {
7524 {
7525 ScmObj SCM_RESULT;
7526 SCM_RESULT = Scm_S16VectorDotProd(v0, v1);
7527 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
7528 }
7529   }
7530 }
7531 
7532 static SCM_DEFINE_STRING_CONST(uvlib_s16vector_dot__NAME, "s16vector-dot", 13, 13);
7533 static SCM_DEFINE_SUBR(uvlib_s16vector_dot__STUB, 2, 0, SCM_OBJ(&uvlib_s16vector_dot__NAME), uvlib_s16vector_dot, NULL, NULL);
7534 
7535 static ScmObj uvlib_u16vector_dot(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7536 {
7537   ScmObj v0_scm;
7538   ScmU16Vector* v0;
7539   ScmObj v1_scm;
7540   ScmObj v1;
7541   SCM_ENTER_SUBR("u16vector-dot");
7542   v0_scm = SCM_ARGREF(0);
7543   if (!SCM_U16VECTORP(v0_scm)) Scm_Error("<u16vector> required, but got %S", v0_scm);
7544   v0 = SCM_U16VECTOR(v0_scm);
7545   v1_scm = SCM_ARGREF(1);
7546   v1 = (v1_scm);
7547   {
7548 {
7549 ScmObj SCM_RESULT;
7550 SCM_RESULT = Scm_U16VectorDotProd(v0, v1);
7551 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
7552 }
7553   }
7554 }
7555 
7556 static SCM_DEFINE_STRING_CONST(uvlib_u16vector_dot__NAME, "u16vector-dot", 13, 13);
7557 static SCM_DEFINE_SUBR(uvlib_u16vector_dot__STUB, 2, 0, SCM_OBJ(&uvlib_u16vector_dot__NAME), uvlib_u16vector_dot, NULL, NULL);
7558 
7559 static ScmObj uvlib_s32vector_dot(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7560 {
7561   ScmObj v0_scm;
7562   ScmS32Vector* v0;
7563   ScmObj v1_scm;
7564   ScmObj v1;
7565   SCM_ENTER_SUBR("s32vector-dot");
7566   v0_scm = SCM_ARGREF(0);
7567   if (!SCM_S32VECTORP(v0_scm)) Scm_Error("<s32vector> required, but got %S", v0_scm);
7568   v0 = SCM_S32VECTOR(v0_scm);
7569   v1_scm = SCM_ARGREF(1);
7570   v1 = (v1_scm);
7571   {
7572 {
7573 ScmObj SCM_RESULT;
7574 SCM_RESULT = Scm_S32VectorDotProd(v0, v1);
7575 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
7576 }
7577   }
7578 }
7579 
7580 static SCM_DEFINE_STRING_CONST(uvlib_s32vector_dot__NAME, "s32vector-dot", 13, 13);
7581 static SCM_DEFINE_SUBR(uvlib_s32vector_dot__STUB, 2, 0, SCM_OBJ(&uvlib_s32vector_dot__NAME), uvlib_s32vector_dot, NULL, NULL);
7582 
7583 static ScmObj uvlib_u32vector_dot(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7584 {
7585   ScmObj v0_scm;
7586   ScmU32Vector* v0;
7587   ScmObj v1_scm;
7588   ScmObj v1;
7589   SCM_ENTER_SUBR("u32vector-dot");
7590   v0_scm = SCM_ARGREF(0);
7591   if (!SCM_U32VECTORP(v0_scm)) Scm_Error("<u32vector> required, but got %S", v0_scm);
7592   v0 = SCM_U32VECTOR(v0_scm);
7593   v1_scm = SCM_ARGREF(1);
7594   v1 = (v1_scm);
7595   {
7596 {
7597 ScmObj SCM_RESULT;
7598 SCM_RESULT = Scm_U32VectorDotProd(v0, v1);
7599 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
7600 }
7601   }
7602 }
7603 
7604 static SCM_DEFINE_STRING_CONST(uvlib_u32vector_dot__NAME, "u32vector-dot", 13, 13);
7605 static SCM_DEFINE_SUBR(uvlib_u32vector_dot__STUB, 2, 0, SCM_OBJ(&uvlib_u32vector_dot__NAME), uvlib_u32vector_dot, NULL, NULL);
7606 
7607 static ScmObj uvlib_s64vector_dot(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7608 {
7609   ScmObj v0_scm;
7610   ScmS64Vector* v0;
7611   ScmObj v1_scm;
7612   ScmObj v1;
7613   SCM_ENTER_SUBR("s64vector-dot");
7614   v0_scm = SCM_ARGREF(0);
7615   if (!SCM_S64VECTORP(v0_scm)) Scm_Error("<s64vector> required, but got %S", v0_scm);
7616   v0 = SCM_S64VECTOR(v0_scm);
7617   v1_scm = SCM_ARGREF(1);
7618   v1 = (v1_scm);
7619   {
7620 {
7621 ScmObj SCM_RESULT;
7622 SCM_RESULT = Scm_S64VectorDotProd(v0, v1);
7623 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
7624 }
7625   }
7626 }
7627 
7628 static SCM_DEFINE_STRING_CONST(uvlib_s64vector_dot__NAME, "s64vector-dot", 13, 13);
7629 static SCM_DEFINE_SUBR(uvlib_s64vector_dot__STUB, 2, 0, SCM_OBJ(&uvlib_s64vector_dot__NAME), uvlib_s64vector_dot, NULL, NULL);
7630 
7631 static ScmObj uvlib_u64vector_dot(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7632 {
7633   ScmObj v0_scm;
7634   ScmU64Vector* v0;
7635   ScmObj v1_scm;
7636   ScmObj v1;
7637   SCM_ENTER_SUBR("u64vector-dot");
7638   v0_scm = SCM_ARGREF(0);
7639   if (!SCM_U64VECTORP(v0_scm)) Scm_Error("<u64vector> required, but got %S", v0_scm);
7640   v0 = SCM_U64VECTOR(v0_scm);
7641   v1_scm = SCM_ARGREF(1);
7642   v1 = (v1_scm);
7643   {
7644 {
7645 ScmObj SCM_RESULT;
7646 SCM_RESULT = Scm_U64VectorDotProd(v0, v1);
7647 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
7648 }
7649   }
7650 }
7651 
7652 static SCM_DEFINE_STRING_CONST(uvlib_u64vector_dot__NAME, "u64vector-dot", 13, 13);
7653 static SCM_DEFINE_SUBR(uvlib_u64vector_dot__STUB, 2, 0, SCM_OBJ(&uvlib_u64vector_dot__NAME), uvlib_u64vector_dot, NULL, NULL);
7654 
7655 static ScmObj uvlib_f32vector_dot(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7656 {
7657   ScmObj v0_scm;
7658   ScmF32Vector* v0;
7659   ScmObj v1_scm;
7660   ScmObj v1;
7661   SCM_ENTER_SUBR("f32vector-dot");
7662   v0_scm = SCM_ARGREF(0);
7663   if (!SCM_F32VECTORP(v0_scm)) Scm_Error("<f32vector> required, but got %S", v0_scm);
7664   v0 = SCM_F32VECTOR(v0_scm);
7665   v1_scm = SCM_ARGREF(1);
7666   v1 = (v1_scm);
7667   {
7668 {
7669 ScmObj SCM_RESULT;
7670 SCM_RESULT = Scm_F32VectorDotProd(v0, v1);
7671 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
7672 }
7673   }
7674 }
7675 
7676 static SCM_DEFINE_STRING_CONST(uvlib_f32vector_dot__NAME, "f32vector-dot", 13, 13);
7677 static SCM_DEFINE_SUBR(uvlib_f32vector_dot__STUB, 2, 0, SCM_OBJ(&uvlib_f32vector_dot__NAME), uvlib_f32vector_dot, NULL, NULL);
7678 
7679 static ScmObj uvlib_f64vector_dot(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7680 {
7681   ScmObj v0_scm;
7682   ScmF64Vector* v0;
7683   ScmObj v1_scm;
7684   ScmObj v1;
7685   SCM_ENTER_SUBR("f64vector-dot");
7686   v0_scm = SCM_ARGREF(0);
7687   if (!SCM_F64VECTORP(v0_scm)) Scm_Error("<f64vector> required, but got %S", v0_scm);
7688   v0 = SCM_F64VECTOR(v0_scm);
7689   v1_scm = SCM_ARGREF(1);
7690   v1 = (v1_scm);
7691   {
7692 {
7693 ScmObj SCM_RESULT;
7694 SCM_RESULT = Scm_F64VectorDotProd(v0, v1);
7695 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
7696 }
7697   }
7698 }
7699 
7700 static SCM_DEFINE_STRING_CONST(uvlib_f64vector_dot__NAME, "f64vector-dot", 13, 13);
7701 static SCM_DEFINE_SUBR(uvlib_f64vector_dot__STUB, 2, 0, SCM_OBJ(&uvlib_f64vector_dot__NAME), uvlib_f64vector_dot, NULL, NULL);
7702 
7703 static ScmObj uvlib_s8vector_range_check(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7704 {
7705   ScmObj v0_scm;
7706   ScmS8Vector* v0;
7707   ScmObj min_scm;
7708   ScmObj min;
7709   ScmObj max_scm;
7710   ScmObj max;
7711   SCM_ENTER_SUBR("s8vector-range-check");
7712   v0_scm = SCM_ARGREF(0);
7713   if (!SCM_S8VECTORP(v0_scm)) Scm_Error("<s8vector> required, but got %S", v0_scm);
7714   v0 = SCM_S8VECTOR(v0_scm);
7715   min_scm = SCM_ARGREF(1);
7716   min = (min_scm);
7717   max_scm = SCM_ARGREF(2);
7718   max = (max_scm);
7719   {
7720 {
7721 ScmObj SCM_RESULT;
7722 SCM_RESULT = Scm_S8VectorRangeCheck(v0, min, max);
7723 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
7724 }
7725   }
7726 }
7727 
7728 static SCM_DEFINE_STRING_CONST(uvlib_s8vector_range_check__NAME, "s8vector-range-check", 20, 20);
7729 static SCM_DEFINE_SUBR(uvlib_s8vector_range_check__STUB, 3, 0, SCM_OBJ(&uvlib_s8vector_range_check__NAME), uvlib_s8vector_range_check, NULL, NULL);
7730 
7731 static ScmObj uvlib_s8vector_clamp(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7732 {
7733   ScmObj v0_scm;
7734   ScmS8Vector* v0;
7735   ScmObj min_scm;
7736   ScmObj min;
7737   ScmObj max_scm;
7738   ScmObj max;
7739   SCM_ENTER_SUBR("s8vector-clamp");
7740   v0_scm = SCM_ARGREF(0);
7741   if (!SCM_S8VECTORP(v0_scm)) Scm_Error("<s8vector> required, but got %S", v0_scm);
7742   v0 = SCM_S8VECTOR(v0_scm);
7743   min_scm = SCM_ARGREF(1);
7744   min = (min_scm);
7745   max_scm = SCM_ARGREF(2);
7746   max = (max_scm);
7747   {
7748 {
7749 ScmObj SCM_RESULT;
7750 SCM_RESULT = Scm_S8VectorClamp(v0, min, max);
7751 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
7752 }
7753   }
7754 }
7755 
7756 static SCM_DEFINE_STRING_CONST(uvlib_s8vector_clamp__NAME, "s8vector-clamp", 14, 14);
7757 static SCM_DEFINE_SUBR(uvlib_s8vector_clamp__STUB, 3, 0, SCM_OBJ(&uvlib_s8vector_clamp__NAME), uvlib_s8vector_clamp, NULL, NULL);
7758 
7759 static ScmObj uvlib_s8vector_clampX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7760 {
7761   ScmObj v0_scm;
7762   ScmS8Vector* v0;
7763   ScmObj min_scm;
7764   ScmObj min;
7765   ScmObj max_scm;
7766   ScmObj max;
7767   SCM_ENTER_SUBR("s8vector-clamp!");
7768   v0_scm = SCM_ARGREF(0);
7769   if (!SCM_S8VECTORP(v0_scm)) Scm_Error("<s8vector> required, but got %S", v0_scm);
7770   v0 = SCM_S8VECTOR(v0_scm);
7771   min_scm = SCM_ARGREF(1);
7772   min = (min_scm);
7773   max_scm = SCM_ARGREF(2);
7774   max = (max_scm);
7775   {
7776 {
7777 ScmObj SCM_RESULT;
7778 SCM_RESULT = Scm_S8VectorClampX(v0, min, max);
7779 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
7780 }
7781   }
7782 }
7783 
7784 static SCM_DEFINE_STRING_CONST(uvlib_s8vector_clampX__NAME, "s8vector-clamp!", 15, 15);
7785 static SCM_DEFINE_SUBR(uvlib_s8vector_clampX__STUB, 3, 0, SCM_OBJ(&uvlib_s8vector_clampX__NAME), uvlib_s8vector_clampX, NULL, NULL);
7786 
7787 static ScmObj uvlib_u8vector_range_check(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7788 {
7789   ScmObj v0_scm;
7790   ScmU8Vector* v0;
7791   ScmObj min_scm;
7792   ScmObj min;
7793   ScmObj max_scm;
7794   ScmObj max;
7795   SCM_ENTER_SUBR("u8vector-range-check");
7796   v0_scm = SCM_ARGREF(0);
7797   if (!SCM_U8VECTORP(v0_scm)) Scm_Error("<u8vector> required, but got %S", v0_scm);
7798   v0 = SCM_U8VECTOR(v0_scm);
7799   min_scm = SCM_ARGREF(1);
7800   min = (min_scm);
7801   max_scm = SCM_ARGREF(2);
7802   max = (max_scm);
7803   {
7804 {
7805 ScmObj SCM_RESULT;
7806 SCM_RESULT = Scm_U8VectorRangeCheck(v0, min, max);
7807 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
7808 }
7809   }
7810 }
7811 
7812 static SCM_DEFINE_STRING_CONST(uvlib_u8vector_range_check__NAME, "u8vector-range-check", 20, 20);
7813 static SCM_DEFINE_SUBR(uvlib_u8vector_range_check__STUB, 3, 0, SCM_OBJ(&uvlib_u8vector_range_check__NAME), uvlib_u8vector_range_check, NULL, NULL);
7814 
7815 static ScmObj uvlib_u8vector_clamp(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7816 {
7817   ScmObj v0_scm;
7818   ScmU8Vector* v0;
7819   ScmObj min_scm;
7820   ScmObj min;
7821   ScmObj max_scm;
7822   ScmObj max;
7823   SCM_ENTER_SUBR("u8vector-clamp");
7824   v0_scm = SCM_ARGREF(0);
7825   if (!SCM_U8VECTORP(v0_scm)) Scm_Error("<u8vector> required, but got %S", v0_scm);
7826   v0 = SCM_U8VECTOR(v0_scm);
7827   min_scm = SCM_ARGREF(1);
7828   min = (min_scm);
7829   max_scm = SCM_ARGREF(2);
7830   max = (max_scm);
7831   {
7832 {
7833 ScmObj SCM_RESULT;
7834 SCM_RESULT = Scm_U8VectorClamp(v0, min, max);
7835 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
7836 }
7837   }
7838 }
7839 
7840 static SCM_DEFINE_STRING_CONST(uvlib_u8vector_clamp__NAME, "u8vector-clamp", 14, 14);
7841 static SCM_DEFINE_SUBR(uvlib_u8vector_clamp__STUB, 3, 0, SCM_OBJ(&uvlib_u8vector_clamp__NAME), uvlib_u8vector_clamp, NULL, NULL);
7842 
7843 static ScmObj uvlib_u8vector_clampX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7844 {
7845   ScmObj v0_scm;
7846   ScmU8Vector* v0;
7847   ScmObj min_scm;
7848   ScmObj min;
7849   ScmObj max_scm;
7850   ScmObj max;
7851   SCM_ENTER_SUBR("u8vector-clamp!");
7852   v0_scm = SCM_ARGREF(0);
7853   if (!SCM_U8VECTORP(v0_scm)) Scm_Error("<u8vector> required, but got %S", v0_scm);
7854   v0 = SCM_U8VECTOR(v0_scm);
7855   min_scm = SCM_ARGREF(1);
7856   min = (min_scm);
7857   max_scm = SCM_ARGREF(2);
7858   max = (max_scm);
7859   {
7860 {
7861 ScmObj SCM_RESULT;
7862 SCM_RESULT = Scm_U8VectorClampX(v0, min, max);
7863 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
7864 }
7865   }
7866 }
7867 
7868 static SCM_DEFINE_STRING_CONST(uvlib_u8vector_clampX__NAME, "u8vector-clamp!", 15, 15);
7869 static SCM_DEFINE_SUBR(uvlib_u8vector_clampX__STUB, 3, 0, SCM_OBJ(&uvlib_u8vector_clampX__NAME), uvlib_u8vector_clampX, NULL, NULL);
7870 
7871 static ScmObj uvlib_s16vector_range_check(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7872 {
7873   ScmObj v0_scm;
7874   ScmS16Vector* v0;
7875   ScmObj min_scm;
7876   ScmObj min;
7877   ScmObj max_scm;
7878   ScmObj max;
7879   SCM_ENTER_SUBR("s16vector-range-check");
7880   v0_scm = SCM_ARGREF(0);
7881   if (!SCM_S16VECTORP(v0_scm)) Scm_Error("<s16vector> required, but got %S", v0_scm);
7882   v0 = SCM_S16VECTOR(v0_scm);
7883   min_scm = SCM_ARGREF(1);
7884   min = (min_scm);
7885   max_scm = SCM_ARGREF(2);
7886   max = (max_scm);
7887   {
7888 {
7889 ScmObj SCM_RESULT;
7890 SCM_RESULT = Scm_S16VectorRangeCheck(v0, min, max);
7891 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
7892 }
7893   }
7894 }
7895 
7896 static SCM_DEFINE_STRING_CONST(uvlib_s16vector_range_check__NAME, "s16vector-range-check", 21, 21);
7897 static SCM_DEFINE_SUBR(uvlib_s16vector_range_check__STUB, 3, 0, SCM_OBJ(&uvlib_s16vector_range_check__NAME), uvlib_s16vector_range_check, NULL, NULL);
7898 
7899 static ScmObj uvlib_s16vector_clamp(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7900 {
7901   ScmObj v0_scm;
7902   ScmS16Vector* v0;
7903   ScmObj min_scm;
7904   ScmObj min;
7905   ScmObj max_scm;
7906   ScmObj max;
7907   SCM_ENTER_SUBR("s16vector-clamp");
7908   v0_scm = SCM_ARGREF(0);
7909   if (!SCM_S16VECTORP(v0_scm)) Scm_Error("<s16vector> required, but got %S", v0_scm);
7910   v0 = SCM_S16VECTOR(v0_scm);
7911   min_scm = SCM_ARGREF(1);
7912   min = (min_scm);
7913   max_scm = SCM_ARGREF(2);
7914   max = (max_scm);
7915   {
7916 {
7917 ScmObj SCM_RESULT;
7918 SCM_RESULT = Scm_S16VectorClamp(v0, min, max);
7919 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
7920 }
7921   }
7922 }
7923 
7924 static SCM_DEFINE_STRING_CONST(uvlib_s16vector_clamp__NAME, "s16vector-clamp", 15, 15);
7925 static SCM_DEFINE_SUBR(uvlib_s16vector_clamp__STUB, 3, 0, SCM_OBJ(&uvlib_s16vector_clamp__NAME), uvlib_s16vector_clamp, NULL, NULL);
7926 
7927 static ScmObj uvlib_s16vector_clampX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7928 {
7929   ScmObj v0_scm;
7930   ScmS16Vector* v0;
7931   ScmObj min_scm;
7932   ScmObj min;
7933   ScmObj max_scm;
7934   ScmObj max;
7935   SCM_ENTER_SUBR("s16vector-clamp!");
7936   v0_scm = SCM_ARGREF(0);
7937   if (!SCM_S16VECTORP(v0_scm)) Scm_Error("<s16vector> required, but got %S", v0_scm);
7938   v0 = SCM_S16VECTOR(v0_scm);
7939   min_scm = SCM_ARGREF(1);
7940   min = (min_scm);
7941   max_scm = SCM_ARGREF(2);
7942   max = (max_scm);
7943   {
7944 {
7945 ScmObj SCM_RESULT;
7946 SCM_RESULT = Scm_S16VectorClampX(v0, min, max);
7947 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
7948 }
7949   }
7950 }
7951 
7952 static SCM_DEFINE_STRING_CONST(uvlib_s16vector_clampX__NAME, "s16vector-clamp!", 16, 16);
7953 static SCM_DEFINE_SUBR(uvlib_s16vector_clampX__STUB, 3, 0, SCM_OBJ(&uvlib_s16vector_clampX__NAME), uvlib_s16vector_clampX, NULL, NULL);
7954 
7955 static ScmObj uvlib_u16vector_range_check(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7956 {
7957   ScmObj v0_scm;
7958   ScmU16Vector* v0;
7959   ScmObj min_scm;
7960   ScmObj min;
7961   ScmObj max_scm;
7962   ScmObj max;
7963   SCM_ENTER_SUBR("u16vector-range-check");
7964   v0_scm = SCM_ARGREF(0);
7965   if (!SCM_U16VECTORP(v0_scm)) Scm_Error("<u16vector> required, but got %S", v0_scm);
7966   v0 = SCM_U16VECTOR(v0_scm);
7967   min_scm = SCM_ARGREF(1);
7968   min = (min_scm);
7969   max_scm = SCM_ARGREF(2);
7970   max = (max_scm);
7971   {
7972 {
7973 ScmObj SCM_RESULT;
7974 SCM_RESULT = Scm_U16VectorRangeCheck(v0, min, max);
7975 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
7976 }
7977   }
7978 }
7979 
7980 static SCM_DEFINE_STRING_CONST(uvlib_u16vector_range_check__NAME, "u16vector-range-check", 21, 21);
7981 static SCM_DEFINE_SUBR(uvlib_u16vector_range_check__STUB, 3, 0, SCM_OBJ(&uvlib_u16vector_range_check__NAME), uvlib_u16vector_range_check, NULL, NULL);
7982 
7983 static ScmObj uvlib_u16vector_clamp(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
7984 {
7985   ScmObj v0_scm;
7986   ScmU16Vector* v0;
7987   ScmObj min_scm;
7988   ScmObj min;
7989   ScmObj max_scm;
7990   ScmObj max;
7991   SCM_ENTER_SUBR("u16vector-clamp");
7992   v0_scm = SCM_ARGREF(0);
7993   if (!SCM_U16VECTORP(v0_scm)) Scm_Error("<u16vector> required, but got %S", v0_scm);
7994   v0 = SCM_U16VECTOR(v0_scm);
7995   min_scm = SCM_ARGREF(1);
7996   min = (min_scm);
7997   max_scm = SCM_ARGREF(2);
7998   max = (max_scm);
7999   {
8000 {
8001 ScmObj SCM_RESULT;
8002 SCM_RESULT = Scm_U16VectorClamp(v0, min, max);
8003 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8004 }
8005   }
8006 }
8007 
8008 static SCM_DEFINE_STRING_CONST(uvlib_u16vector_clamp__NAME, "u16vector-clamp", 15, 15);
8009 static SCM_DEFINE_SUBR(uvlib_u16vector_clamp__STUB, 3, 0, SCM_OBJ(&uvlib_u16vector_clamp__NAME), uvlib_u16vector_clamp, NULL, NULL);
8010 
8011 static ScmObj uvlib_u16vector_clampX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8012 {
8013   ScmObj v0_scm;
8014   ScmU16Vector* v0;
8015   ScmObj min_scm;
8016   ScmObj min;
8017   ScmObj max_scm;
8018   ScmObj max;
8019   SCM_ENTER_SUBR("u16vector-clamp!");
8020   v0_scm = SCM_ARGREF(0);
8021   if (!SCM_U16VECTORP(v0_scm)) Scm_Error("<u16vector> required, but got %S", v0_scm);
8022   v0 = SCM_U16VECTOR(v0_scm);
8023   min_scm = SCM_ARGREF(1);
8024   min = (min_scm);
8025   max_scm = SCM_ARGREF(2);
8026   max = (max_scm);
8027   {
8028 {
8029 ScmObj SCM_RESULT;
8030 SCM_RESULT = Scm_U16VectorClampX(v0, min, max);
8031 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8032 }
8033   }
8034 }
8035 
8036 static SCM_DEFINE_STRING_CONST(uvlib_u16vector_clampX__NAME, "u16vector-clamp!", 16, 16);
8037 static SCM_DEFINE_SUBR(uvlib_u16vector_clampX__STUB, 3, 0, SCM_OBJ(&uvlib_u16vector_clampX__NAME), uvlib_u16vector_clampX, NULL, NULL);
8038 
8039 static ScmObj uvlib_s32vector_range_check(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8040 {
8041   ScmObj v0_scm;
8042   ScmS32Vector* v0;
8043   ScmObj min_scm;
8044   ScmObj min;
8045   ScmObj max_scm;
8046   ScmObj max;
8047   SCM_ENTER_SUBR("s32vector-range-check");
8048   v0_scm = SCM_ARGREF(0);
8049   if (!SCM_S32VECTORP(v0_scm)) Scm_Error("<s32vector> required, but got %S", v0_scm);
8050   v0 = SCM_S32VECTOR(v0_scm);
8051   min_scm = SCM_ARGREF(1);
8052   min = (min_scm);
8053   max_scm = SCM_ARGREF(2);
8054   max = (max_scm);
8055   {
8056 {
8057 ScmObj SCM_RESULT;
8058 SCM_RESULT = Scm_S32VectorRangeCheck(v0, min, max);
8059 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8060 }
8061   }
8062 }
8063 
8064 static SCM_DEFINE_STRING_CONST(uvlib_s32vector_range_check__NAME, "s32vector-range-check", 21, 21);
8065 static SCM_DEFINE_SUBR(uvlib_s32vector_range_check__STUB, 3, 0, SCM_OBJ(&uvlib_s32vector_range_check__NAME), uvlib_s32vector_range_check, NULL, NULL);
8066 
8067 static ScmObj uvlib_s32vector_clamp(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8068 {
8069   ScmObj v0_scm;
8070   ScmS32Vector* v0;
8071   ScmObj min_scm;
8072   ScmObj min;
8073   ScmObj max_scm;
8074   ScmObj max;
8075   SCM_ENTER_SUBR("s32vector-clamp");
8076   v0_scm = SCM_ARGREF(0);
8077   if (!SCM_S32VECTORP(v0_scm)) Scm_Error("<s32vector> required, but got %S", v0_scm);
8078   v0 = SCM_S32VECTOR(v0_scm);
8079   min_scm = SCM_ARGREF(1);
8080   min = (min_scm);
8081   max_scm = SCM_ARGREF(2);
8082   max = (max_scm);
8083   {
8084 {
8085 ScmObj SCM_RESULT;
8086 SCM_RESULT = Scm_S32VectorClamp(v0, min, max);
8087 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8088 }
8089   }
8090 }
8091 
8092 static SCM_DEFINE_STRING_CONST(uvlib_s32vector_clamp__NAME, "s32vector-clamp", 15, 15);
8093 static SCM_DEFINE_SUBR(uvlib_s32vector_clamp__STUB, 3, 0, SCM_OBJ(&uvlib_s32vector_clamp__NAME), uvlib_s32vector_clamp, NULL, NULL);
8094 
8095 static ScmObj uvlib_s32vector_clampX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8096 {
8097   ScmObj v0_scm;
8098   ScmS32Vector* v0;
8099   ScmObj min_scm;
8100   ScmObj min;
8101   ScmObj max_scm;
8102   ScmObj max;
8103   SCM_ENTER_SUBR("s32vector-clamp!");
8104   v0_scm = SCM_ARGREF(0);
8105   if (!SCM_S32VECTORP(v0_scm)) Scm_Error("<s32vector> required, but got %S", v0_scm);
8106   v0 = SCM_S32VECTOR(v0_scm);
8107   min_scm = SCM_ARGREF(1);
8108   min = (min_scm);
8109   max_scm = SCM_ARGREF(2);
8110   max = (max_scm);
8111   {
8112 {
8113 ScmObj SCM_RESULT;
8114 SCM_RESULT = Scm_S32VectorClampX(v0, min, max);
8115 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8116 }
8117   }
8118 }
8119 
8120 static SCM_DEFINE_STRING_CONST(uvlib_s32vector_clampX__NAME, "s32vector-clamp!", 16, 16);
8121 static SCM_DEFINE_SUBR(uvlib_s32vector_clampX__STUB, 3, 0, SCM_OBJ(&uvlib_s32vector_clampX__NAME), uvlib_s32vector_clampX, NULL, NULL);
8122 
8123 static ScmObj uvlib_u32vector_range_check(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8124 {
8125   ScmObj v0_scm;
8126   ScmU32Vector* v0;
8127   ScmObj min_scm;
8128   ScmObj min;
8129   ScmObj max_scm;
8130   ScmObj max;
8131   SCM_ENTER_SUBR("u32vector-range-check");
8132   v0_scm = SCM_ARGREF(0);
8133   if (!SCM_U32VECTORP(v0_scm)) Scm_Error("<u32vector> required, but got %S", v0_scm);
8134   v0 = SCM_U32VECTOR(v0_scm);
8135   min_scm = SCM_ARGREF(1);
8136   min = (min_scm);
8137   max_scm = SCM_ARGREF(2);
8138   max = (max_scm);
8139   {
8140 {
8141 ScmObj SCM_RESULT;
8142 SCM_RESULT = Scm_U32VectorRangeCheck(v0, min, max);
8143 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8144 }
8145   }
8146 }
8147 
8148 static SCM_DEFINE_STRING_CONST(uvlib_u32vector_range_check__NAME, "u32vector-range-check", 21, 21);
8149 static SCM_DEFINE_SUBR(uvlib_u32vector_range_check__STUB, 3, 0, SCM_OBJ(&uvlib_u32vector_range_check__NAME), uvlib_u32vector_range_check, NULL, NULL);
8150 
8151 static ScmObj uvlib_u32vector_clamp(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8152 {
8153   ScmObj v0_scm;
8154   ScmU32Vector* v0;
8155   ScmObj min_scm;
8156   ScmObj min;
8157   ScmObj max_scm;
8158   ScmObj max;
8159   SCM_ENTER_SUBR("u32vector-clamp");
8160   v0_scm = SCM_ARGREF(0);
8161   if (!SCM_U32VECTORP(v0_scm)) Scm_Error("<u32vector> required, but got %S", v0_scm);
8162   v0 = SCM_U32VECTOR(v0_scm);
8163   min_scm = SCM_ARGREF(1);
8164   min = (min_scm);
8165   max_scm = SCM_ARGREF(2);
8166   max = (max_scm);
8167   {
8168 {
8169 ScmObj SCM_RESULT;
8170 SCM_RESULT = Scm_U32VectorClamp(v0, min, max);
8171 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8172 }
8173   }
8174 }
8175 
8176 static SCM_DEFINE_STRING_CONST(uvlib_u32vector_clamp__NAME, "u32vector-clamp", 15, 15);
8177 static SCM_DEFINE_SUBR(uvlib_u32vector_clamp__STUB, 3, 0, SCM_OBJ(&uvlib_u32vector_clamp__NAME), uvlib_u32vector_clamp, NULL, NULL);
8178 
8179 static ScmObj uvlib_u32vector_clampX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8180 {
8181   ScmObj v0_scm;
8182   ScmU32Vector* v0;
8183   ScmObj min_scm;
8184   ScmObj min;
8185   ScmObj max_scm;
8186   ScmObj max;
8187   SCM_ENTER_SUBR("u32vector-clamp!");
8188   v0_scm = SCM_ARGREF(0);
8189   if (!SCM_U32VECTORP(v0_scm)) Scm_Error("<u32vector> required, but got %S", v0_scm);
8190   v0 = SCM_U32VECTOR(v0_scm);
8191   min_scm = SCM_ARGREF(1);
8192   min = (min_scm);
8193   max_scm = SCM_ARGREF(2);
8194   max = (max_scm);
8195   {
8196 {
8197 ScmObj SCM_RESULT;
8198 SCM_RESULT = Scm_U32VectorClampX(v0, min, max);
8199 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8200 }
8201   }
8202 }
8203 
8204 static SCM_DEFINE_STRING_CONST(uvlib_u32vector_clampX__NAME, "u32vector-clamp!", 16, 16);
8205 static SCM_DEFINE_SUBR(uvlib_u32vector_clampX__STUB, 3, 0, SCM_OBJ(&uvlib_u32vector_clampX__NAME), uvlib_u32vector_clampX, NULL, NULL);
8206 
8207 static ScmObj uvlib_s64vector_range_check(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8208 {
8209   ScmObj v0_scm;
8210   ScmS64Vector* v0;
8211   ScmObj min_scm;
8212   ScmObj min;
8213   ScmObj max_scm;
8214   ScmObj max;
8215   SCM_ENTER_SUBR("s64vector-range-check");
8216   v0_scm = SCM_ARGREF(0);
8217   if (!SCM_S64VECTORP(v0_scm)) Scm_Error("<s64vector> required, but got %S", v0_scm);
8218   v0 = SCM_S64VECTOR(v0_scm);
8219   min_scm = SCM_ARGREF(1);
8220   min = (min_scm);
8221   max_scm = SCM_ARGREF(2);
8222   max = (max_scm);
8223   {
8224 {
8225 ScmObj SCM_RESULT;
8226 SCM_RESULT = Scm_S64VectorRangeCheck(v0, min, max);
8227 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8228 }
8229   }
8230 }
8231 
8232 static SCM_DEFINE_STRING_CONST(uvlib_s64vector_range_check__NAME, "s64vector-range-check", 21, 21);
8233 static SCM_DEFINE_SUBR(uvlib_s64vector_range_check__STUB, 3, 0, SCM_OBJ(&uvlib_s64vector_range_check__NAME), uvlib_s64vector_range_check, NULL, NULL);
8234 
8235 static ScmObj uvlib_s64vector_clamp(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8236 {
8237   ScmObj v0_scm;
8238   ScmS64Vector* v0;
8239   ScmObj min_scm;
8240   ScmObj min;
8241   ScmObj max_scm;
8242   ScmObj max;
8243   SCM_ENTER_SUBR("s64vector-clamp");
8244   v0_scm = SCM_ARGREF(0);
8245   if (!SCM_S64VECTORP(v0_scm)) Scm_Error("<s64vector> required, but got %S", v0_scm);
8246   v0 = SCM_S64VECTOR(v0_scm);
8247   min_scm = SCM_ARGREF(1);
8248   min = (min_scm);
8249   max_scm = SCM_ARGREF(2);
8250   max = (max_scm);
8251   {
8252 {
8253 ScmObj SCM_RESULT;
8254 SCM_RESULT = Scm_S64VectorClamp(v0, min, max);
8255 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8256 }
8257   }
8258 }
8259 
8260 static SCM_DEFINE_STRING_CONST(uvlib_s64vector_clamp__NAME, "s64vector-clamp", 15, 15);
8261 static SCM_DEFINE_SUBR(uvlib_s64vector_clamp__STUB, 3, 0, SCM_OBJ(&uvlib_s64vector_clamp__NAME), uvlib_s64vector_clamp, NULL, NULL);
8262 
8263 static ScmObj uvlib_s64vector_clampX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8264 {
8265   ScmObj v0_scm;
8266   ScmS64Vector* v0;
8267   ScmObj min_scm;
8268   ScmObj min;
8269   ScmObj max_scm;
8270   ScmObj max;
8271   SCM_ENTER_SUBR("s64vector-clamp!");
8272   v0_scm = SCM_ARGREF(0);
8273   if (!SCM_S64VECTORP(v0_scm)) Scm_Error("<s64vector> required, but got %S", v0_scm);
8274   v0 = SCM_S64VECTOR(v0_scm);
8275   min_scm = SCM_ARGREF(1);
8276   min = (min_scm);
8277   max_scm = SCM_ARGREF(2);
8278   max = (max_scm);
8279   {
8280 {
8281 ScmObj SCM_RESULT;
8282 SCM_RESULT = Scm_S64VectorClampX(v0, min, max);
8283 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8284 }
8285   }
8286 }
8287 
8288 static SCM_DEFINE_STRING_CONST(uvlib_s64vector_clampX__NAME, "s64vector-clamp!", 16, 16);
8289 static SCM_DEFINE_SUBR(uvlib_s64vector_clampX__STUB, 3, 0, SCM_OBJ(&uvlib_s64vector_clampX__NAME), uvlib_s64vector_clampX, NULL, NULL);
8290 
8291 static ScmObj uvlib_u64vector_range_check(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8292 {
8293   ScmObj v0_scm;
8294   ScmU64Vector* v0;
8295   ScmObj min_scm;
8296   ScmObj min;
8297   ScmObj max_scm;
8298   ScmObj max;
8299   SCM_ENTER_SUBR("u64vector-range-check");
8300   v0_scm = SCM_ARGREF(0);
8301   if (!SCM_U64VECTORP(v0_scm)) Scm_Error("<u64vector> required, but got %S", v0_scm);
8302   v0 = SCM_U64VECTOR(v0_scm);
8303   min_scm = SCM_ARGREF(1);
8304   min = (min_scm);
8305   max_scm = SCM_ARGREF(2);
8306   max = (max_scm);
8307   {
8308 {
8309 ScmObj SCM_RESULT;
8310 SCM_RESULT = Scm_U64VectorRangeCheck(v0, min, max);
8311 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8312 }
8313   }
8314 }
8315 
8316 static SCM_DEFINE_STRING_CONST(uvlib_u64vector_range_check__NAME, "u64vector-range-check", 21, 21);
8317 static SCM_DEFINE_SUBR(uvlib_u64vector_range_check__STUB, 3, 0, SCM_OBJ(&uvlib_u64vector_range_check__NAME), uvlib_u64vector_range_check, NULL, NULL);
8318 
8319 static ScmObj uvlib_u64vector_clamp(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8320 {
8321   ScmObj v0_scm;
8322   ScmU64Vector* v0;
8323   ScmObj min_scm;
8324   ScmObj min;
8325   ScmObj max_scm;
8326   ScmObj max;
8327   SCM_ENTER_SUBR("u64vector-clamp");
8328   v0_scm = SCM_ARGREF(0);
8329   if (!SCM_U64VECTORP(v0_scm)) Scm_Error("<u64vector> required, but got %S", v0_scm);
8330   v0 = SCM_U64VECTOR(v0_scm);
8331   min_scm = SCM_ARGREF(1);
8332   min = (min_scm);
8333   max_scm = SCM_ARGREF(2);
8334   max = (max_scm);
8335   {
8336 {
8337 ScmObj SCM_RESULT;
8338 SCM_RESULT = Scm_U64VectorClamp(v0, min, max);
8339 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8340 }
8341   }
8342 }
8343 
8344 static SCM_DEFINE_STRING_CONST(uvlib_u64vector_clamp__NAME, "u64vector-clamp", 15, 15);
8345 static SCM_DEFINE_SUBR(uvlib_u64vector_clamp__STUB, 3, 0, SCM_OBJ(&uvlib_u64vector_clamp__NAME), uvlib_u64vector_clamp, NULL, NULL);
8346 
8347 static ScmObj uvlib_u64vector_clampX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8348 {
8349   ScmObj v0_scm;
8350   ScmU64Vector* v0;
8351   ScmObj min_scm;
8352   ScmObj min;
8353   ScmObj max_scm;
8354   ScmObj max;
8355   SCM_ENTER_SUBR("u64vector-clamp!");
8356   v0_scm = SCM_ARGREF(0);
8357   if (!SCM_U64VECTORP(v0_scm)) Scm_Error("<u64vector> required, but got %S", v0_scm);
8358   v0 = SCM_U64VECTOR(v0_scm);
8359   min_scm = SCM_ARGREF(1);
8360   min = (min_scm);
8361   max_scm = SCM_ARGREF(2);
8362   max = (max_scm);
8363   {
8364 {
8365 ScmObj SCM_RESULT;
8366 SCM_RESULT = Scm_U64VectorClampX(v0, min, max);
8367 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8368 }
8369   }
8370 }
8371 
8372 static SCM_DEFINE_STRING_CONST(uvlib_u64vector_clampX__NAME, "u64vector-clamp!", 16, 16);
8373 static SCM_DEFINE_SUBR(uvlib_u64vector_clampX__STUB, 3, 0, SCM_OBJ(&uvlib_u64vector_clampX__NAME), uvlib_u64vector_clampX, NULL, NULL);
8374 
8375 static ScmObj uvlib_f32vector_range_check(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8376 {
8377   ScmObj v0_scm;
8378   ScmF32Vector* v0;
8379   ScmObj min_scm;
8380   ScmObj min;
8381   ScmObj max_scm;
8382   ScmObj max;
8383   SCM_ENTER_SUBR("f32vector-range-check");
8384   v0_scm = SCM_ARGREF(0);
8385   if (!SCM_F32VECTORP(v0_scm)) Scm_Error("<f32vector> required, but got %S", v0_scm);
8386   v0 = SCM_F32VECTOR(v0_scm);
8387   min_scm = SCM_ARGREF(1);
8388   min = (min_scm);
8389   max_scm = SCM_ARGREF(2);
8390   max = (max_scm);
8391   {
8392 {
8393 ScmObj SCM_RESULT;
8394 SCM_RESULT = Scm_F32VectorRangeCheck(v0, min, max);
8395 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8396 }
8397   }
8398 }
8399 
8400 static SCM_DEFINE_STRING_CONST(uvlib_f32vector_range_check__NAME, "f32vector-range-check", 21, 21);
8401 static SCM_DEFINE_SUBR(uvlib_f32vector_range_check__STUB, 3, 0, SCM_OBJ(&uvlib_f32vector_range_check__NAME), uvlib_f32vector_range_check, NULL, NULL);
8402 
8403 static ScmObj uvlib_f32vector_clamp(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8404 {
8405   ScmObj v0_scm;
8406   ScmF32Vector* v0;
8407   ScmObj min_scm;
8408   ScmObj min;
8409   ScmObj max_scm;
8410   ScmObj max;
8411   SCM_ENTER_SUBR("f32vector-clamp");
8412   v0_scm = SCM_ARGREF(0);
8413   if (!SCM_F32VECTORP(v0_scm)) Scm_Error("<f32vector> required, but got %S", v0_scm);
8414   v0 = SCM_F32VECTOR(v0_scm);
8415   min_scm = SCM_ARGREF(1);
8416   min = (min_scm);
8417   max_scm = SCM_ARGREF(2);
8418   max = (max_scm);
8419   {
8420 {
8421 ScmObj SCM_RESULT;
8422 SCM_RESULT = Scm_F32VectorClamp(v0, min, max);
8423 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8424 }
8425   }
8426 }
8427 
8428 static SCM_DEFINE_STRING_CONST(uvlib_f32vector_clamp__NAME, "f32vector-clamp", 15, 15);
8429 static SCM_DEFINE_SUBR(uvlib_f32vector_clamp__STUB, 3, 0, SCM_OBJ(&uvlib_f32vector_clamp__NAME), uvlib_f32vector_clamp, NULL, NULL);
8430 
8431 static ScmObj uvlib_f32vector_clampX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8432 {
8433   ScmObj v0_scm;
8434   ScmF32Vector* v0;
8435   ScmObj min_scm;
8436   ScmObj min;
8437   ScmObj max_scm;
8438   ScmObj max;
8439   SCM_ENTER_SUBR("f32vector-clamp!");
8440   v0_scm = SCM_ARGREF(0);
8441   if (!SCM_F32VECTORP(v0_scm)) Scm_Error("<f32vector> required, but got %S", v0_scm);
8442   v0 = SCM_F32VECTOR(v0_scm);
8443   min_scm = SCM_ARGREF(1);
8444   min = (min_scm);
8445   max_scm = SCM_ARGREF(2);
8446   max = (max_scm);
8447   {
8448 {
8449 ScmObj SCM_RESULT;
8450 SCM_RESULT = Scm_F32VectorClampX(v0, min, max);
8451 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8452 }
8453   }
8454 }
8455 
8456 static SCM_DEFINE_STRING_CONST(uvlib_f32vector_clampX__NAME, "f32vector-clamp!", 16, 16);
8457 static SCM_DEFINE_SUBR(uvlib_f32vector_clampX__STUB, 3, 0, SCM_OBJ(&uvlib_f32vector_clampX__NAME), uvlib_f32vector_clampX, NULL, NULL);
8458 
8459 static ScmObj uvlib_f64vector_range_check(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8460 {
8461   ScmObj v0_scm;
8462   ScmF64Vector* v0;
8463   ScmObj min_scm;
8464   ScmObj min;
8465   ScmObj max_scm;
8466   ScmObj max;
8467   SCM_ENTER_SUBR("f64vector-range-check");
8468   v0_scm = SCM_ARGREF(0);
8469   if (!SCM_F64VECTORP(v0_scm)) Scm_Error("<f64vector> required, but got %S", v0_scm);
8470   v0 = SCM_F64VECTOR(v0_scm);
8471   min_scm = SCM_ARGREF(1);
8472   min = (min_scm);
8473   max_scm = SCM_ARGREF(2);
8474   max = (max_scm);
8475   {
8476 {
8477 ScmObj SCM_RESULT;
8478 SCM_RESULT = Scm_F64VectorRangeCheck(v0, min, max);
8479 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8480 }
8481   }
8482 }
8483 
8484 static SCM_DEFINE_STRING_CONST(uvlib_f64vector_range_check__NAME, "f64vector-range-check", 21, 21);
8485 static SCM_DEFINE_SUBR(uvlib_f64vector_range_check__STUB, 3, 0, SCM_OBJ(&uvlib_f64vector_range_check__NAME), uvlib_f64vector_range_check, NULL, NULL);
8486 
8487 static ScmObj uvlib_f64vector_clamp(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8488 {
8489   ScmObj v0_scm;
8490   ScmF64Vector* v0;
8491   ScmObj min_scm;
8492   ScmObj min;
8493   ScmObj max_scm;
8494   ScmObj max;
8495   SCM_ENTER_SUBR("f64vector-clamp");
8496   v0_scm = SCM_ARGREF(0);
8497   if (!SCM_F64VECTORP(v0_scm)) Scm_Error("<f64vector> required, but got %S", v0_scm);
8498   v0 = SCM_F64VECTOR(v0_scm);
8499   min_scm = SCM_ARGREF(1);
8500   min = (min_scm);
8501   max_scm = SCM_ARGREF(2);
8502   max = (max_scm);
8503   {
8504 {
8505 ScmObj SCM_RESULT;
8506 SCM_RESULT = Scm_F64VectorClamp(v0, min, max);
8507 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8508 }
8509   }
8510 }
8511 
8512 static SCM_DEFINE_STRING_CONST(uvlib_f64vector_clamp__NAME, "f64vector-clamp", 15, 15);
8513 static SCM_DEFINE_SUBR(uvlib_f64vector_clamp__STUB, 3, 0, SCM_OBJ(&uvlib_f64vector_clamp__NAME), uvlib_f64vector_clamp, NULL, NULL);
8514 
8515 static ScmObj uvlib_f64vector_clampX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8516 {
8517   ScmObj v0_scm;
8518   ScmF64Vector* v0;
8519   ScmObj min_scm;
8520   ScmObj min;
8521   ScmObj max_scm;
8522   ScmObj max;
8523   SCM_ENTER_SUBR("f64vector-clamp!");
8524   v0_scm = SCM_ARGREF(0);
8525   if (!SCM_F64VECTORP(v0_scm)) Scm_Error("<f64vector> required, but got %S", v0_scm);
8526   v0 = SCM_F64VECTOR(v0_scm);
8527   min_scm = SCM_ARGREF(1);
8528   min = (min_scm);
8529   max_scm = SCM_ARGREF(2);
8530   max = (max_scm);
8531   {
8532 {
8533 ScmObj SCM_RESULT;
8534 SCM_RESULT = Scm_F64VectorClampX(v0, min, max);
8535 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8536 }
8537   }
8538 }
8539 
8540 static SCM_DEFINE_STRING_CONST(uvlib_f64vector_clampX__NAME, "f64vector-clamp!", 16, 16);
8541 static SCM_DEFINE_SUBR(uvlib_f64vector_clampX__STUB, 3, 0, SCM_OBJ(&uvlib_f64vector_clampX__NAME), uvlib_f64vector_clampX, NULL, NULL);
8542 
8543 static ScmObj uvlib_s16vector_swap_bytes(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8544 {
8545   ScmObj v0_scm;
8546   ScmS16Vector* v0;
8547   SCM_ENTER_SUBR("s16vector-swap-bytes");
8548   v0_scm = SCM_ARGREF(0);
8549   if (!SCM_S16VECTORP(v0_scm)) Scm_Error("<s16vector> required, but got %S", v0_scm);
8550   v0 = SCM_S16VECTOR(v0_scm);
8551   {
8552 {
8553 ScmObj SCM_RESULT;
8554 SCM_RESULT = Scm_S16VectorSwapBytes(v0);
8555 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8556 }
8557   }
8558 }
8559 
8560 static SCM_DEFINE_STRING_CONST(uvlib_s16vector_swap_bytes__NAME, "s16vector-swap-bytes", 20, 20);
8561 static SCM_DEFINE_SUBR(uvlib_s16vector_swap_bytes__STUB, 1, 0, SCM_OBJ(&uvlib_s16vector_swap_bytes__NAME), uvlib_s16vector_swap_bytes, NULL, NULL);
8562 
8563 static ScmObj uvlib_s16vector_swap_bytesX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8564 {
8565   ScmObj v0_scm;
8566   ScmS16Vector* v0;
8567   SCM_ENTER_SUBR("s16vector-swap-bytes!");
8568   v0_scm = SCM_ARGREF(0);
8569   if (!SCM_S16VECTORP(v0_scm)) Scm_Error("<s16vector> required, but got %S", v0_scm);
8570   v0 = SCM_S16VECTOR(v0_scm);
8571   {
8572 {
8573 ScmObj SCM_RESULT;
8574 SCM_RESULT = Scm_S16VectorSwapBytesX(v0);
8575 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8576 }
8577   }
8578 }
8579 
8580 static SCM_DEFINE_STRING_CONST(uvlib_s16vector_swap_bytesX__NAME, "s16vector-swap-bytes!", 21, 21);
8581 static SCM_DEFINE_SUBR(uvlib_s16vector_swap_bytesX__STUB, 1, 0, SCM_OBJ(&uvlib_s16vector_swap_bytesX__NAME), uvlib_s16vector_swap_bytesX, NULL, NULL);
8582 
8583 static ScmObj uvlib_u16vector_swap_bytes(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8584 {
8585   ScmObj v0_scm;
8586   ScmU16Vector* v0;
8587   SCM_ENTER_SUBR("u16vector-swap-bytes");
8588   v0_scm = SCM_ARGREF(0);
8589   if (!SCM_U16VECTORP(v0_scm)) Scm_Error("<u16vector> required, but got %S", v0_scm);
8590   v0 = SCM_U16VECTOR(v0_scm);
8591   {
8592 {
8593 ScmObj SCM_RESULT;
8594 SCM_RESULT = Scm_U16VectorSwapBytes(v0);
8595 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8596 }
8597   }
8598 }
8599 
8600 static SCM_DEFINE_STRING_CONST(uvlib_u16vector_swap_bytes__NAME, "u16vector-swap-bytes", 20, 20);
8601 static SCM_DEFINE_SUBR(uvlib_u16vector_swap_bytes__STUB, 1, 0, SCM_OBJ(&uvlib_u16vector_swap_bytes__NAME), uvlib_u16vector_swap_bytes, NULL, NULL);
8602 
8603 static ScmObj uvlib_u16vector_swap_bytesX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8604 {
8605   ScmObj v0_scm;
8606   ScmU16Vector* v0;
8607   SCM_ENTER_SUBR("u16vector-swap-bytes!");
8608   v0_scm = SCM_ARGREF(0);
8609   if (!SCM_U16VECTORP(v0_scm)) Scm_Error("<u16vector> required, but got %S", v0_scm);
8610   v0 = SCM_U16VECTOR(v0_scm);
8611   {
8612 {
8613 ScmObj SCM_RESULT;
8614 SCM_RESULT = Scm_U16VectorSwapBytesX(v0);
8615 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8616 }
8617   }
8618 }
8619 
8620 static SCM_DEFINE_STRING_CONST(uvlib_u16vector_swap_bytesX__NAME, "u16vector-swap-bytes!", 21, 21);
8621 static SCM_DEFINE_SUBR(uvlib_u16vector_swap_bytesX__STUB, 1, 0, SCM_OBJ(&uvlib_u16vector_swap_bytesX__NAME), uvlib_u16vector_swap_bytesX, NULL, NULL);
8622 
8623 static ScmObj uvlib_s32vector_swap_bytes(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8624 {
8625   ScmObj v0_scm;
8626   ScmS32Vector* v0;
8627   SCM_ENTER_SUBR("s32vector-swap-bytes");
8628   v0_scm = SCM_ARGREF(0);
8629   if (!SCM_S32VECTORP(v0_scm)) Scm_Error("<s32vector> required, but got %S", v0_scm);
8630   v0 = SCM_S32VECTOR(v0_scm);
8631   {
8632 {
8633 ScmObj SCM_RESULT;
8634 SCM_RESULT = Scm_S32VectorSwapBytes(v0);
8635 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8636 }
8637   }
8638 }
8639 
8640 static SCM_DEFINE_STRING_CONST(uvlib_s32vector_swap_bytes__NAME, "s32vector-swap-bytes", 20, 20);
8641 static SCM_DEFINE_SUBR(uvlib_s32vector_swap_bytes__STUB, 1, 0, SCM_OBJ(&uvlib_s32vector_swap_bytes__NAME), uvlib_s32vector_swap_bytes, NULL, NULL);
8642 
8643 static ScmObj uvlib_s32vector_swap_bytesX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8644 {
8645   ScmObj v0_scm;
8646   ScmS32Vector* v0;
8647   SCM_ENTER_SUBR("s32vector-swap-bytes!");
8648   v0_scm = SCM_ARGREF(0);
8649   if (!SCM_S32VECTORP(v0_scm)) Scm_Error("<s32vector> required, but got %S", v0_scm);
8650   v0 = SCM_S32VECTOR(v0_scm);
8651   {
8652 {
8653 ScmObj SCM_RESULT;
8654 SCM_RESULT = Scm_S32VectorSwapBytesX(v0);
8655 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8656 }
8657   }
8658 }
8659 
8660 static SCM_DEFINE_STRING_CONST(uvlib_s32vector_swap_bytesX__NAME, "s32vector-swap-bytes!", 21, 21);
8661 static SCM_DEFINE_SUBR(uvlib_s32vector_swap_bytesX__STUB, 1, 0, SCM_OBJ(&uvlib_s32vector_swap_bytesX__NAME), uvlib_s32vector_swap_bytesX, NULL, NULL);
8662 
8663 static ScmObj uvlib_u32vector_swap_bytes(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8664 {
8665   ScmObj v0_scm;
8666   ScmU32Vector* v0;
8667   SCM_ENTER_SUBR("u32vector-swap-bytes");
8668   v0_scm = SCM_ARGREF(0);
8669   if (!SCM_U32VECTORP(v0_scm)) Scm_Error("<u32vector> required, but got %S", v0_scm);
8670   v0 = SCM_U32VECTOR(v0_scm);
8671   {
8672 {
8673 ScmObj SCM_RESULT;
8674 SCM_RESULT = Scm_U32VectorSwapBytes(v0);
8675 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8676 }
8677   }
8678 }
8679 
8680 static SCM_DEFINE_STRING_CONST(uvlib_u32vector_swap_bytes__NAME, "u32vector-swap-bytes", 20, 20);
8681 static SCM_DEFINE_SUBR(uvlib_u32vector_swap_bytes__STUB, 1, 0, SCM_OBJ(&uvlib_u32vector_swap_bytes__NAME), uvlib_u32vector_swap_bytes, NULL, NULL);
8682 
8683 static ScmObj uvlib_u32vector_swap_bytesX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8684 {
8685   ScmObj v0_scm;
8686   ScmU32Vector* v0;
8687   SCM_ENTER_SUBR("u32vector-swap-bytes!");
8688   v0_scm = SCM_ARGREF(0);
8689   if (!SCM_U32VECTORP(v0_scm)) Scm_Error("<u32vector> required, but got %S", v0_scm);
8690   v0 = SCM_U32VECTOR(v0_scm);
8691   {
8692 {
8693 ScmObj SCM_RESULT;
8694 SCM_RESULT = Scm_U32VectorSwapBytesX(v0);
8695 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8696 }
8697   }
8698 }
8699 
8700 static SCM_DEFINE_STRING_CONST(uvlib_u32vector_swap_bytesX__NAME, "u32vector-swap-bytes!", 21, 21);
8701 static SCM_DEFINE_SUBR(uvlib_u32vector_swap_bytesX__STUB, 1, 0, SCM_OBJ(&uvlib_u32vector_swap_bytesX__NAME), uvlib_u32vector_swap_bytesX, NULL, NULL);
8702 
8703 static ScmObj uvlib_s64vector_swap_bytes(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8704 {
8705   ScmObj v0_scm;
8706   ScmS64Vector* v0;
8707   SCM_ENTER_SUBR("s64vector-swap-bytes");
8708   v0_scm = SCM_ARGREF(0);
8709   if (!SCM_S64VECTORP(v0_scm)) Scm_Error("<s64vector> required, but got %S", v0_scm);
8710   v0 = SCM_S64VECTOR(v0_scm);
8711   {
8712 {
8713 ScmObj SCM_RESULT;
8714 SCM_RESULT = Scm_S64VectorSwapBytes(v0);
8715 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8716 }
8717   }
8718 }
8719 
8720 static SCM_DEFINE_STRING_CONST(uvlib_s64vector_swap_bytes__NAME, "s64vector-swap-bytes", 20, 20);
8721 static SCM_DEFINE_SUBR(uvlib_s64vector_swap_bytes__STUB, 1, 0, SCM_OBJ(&uvlib_s64vector_swap_bytes__NAME), uvlib_s64vector_swap_bytes, NULL, NULL);
8722 
8723 static ScmObj uvlib_s64vector_swap_bytesX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8724 {
8725   ScmObj v0_scm;
8726   ScmS64Vector* v0;
8727   SCM_ENTER_SUBR("s64vector-swap-bytes!");
8728   v0_scm = SCM_ARGREF(0);
8729   if (!SCM_S64VECTORP(v0_scm)) Scm_Error("<s64vector> required, but got %S", v0_scm);
8730   v0 = SCM_S64VECTOR(v0_scm);
8731   {
8732 {
8733 ScmObj SCM_RESULT;
8734 SCM_RESULT = Scm_S64VectorSwapBytesX(v0);
8735 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8736 }
8737   }
8738 }
8739 
8740 static SCM_DEFINE_STRING_CONST(uvlib_s64vector_swap_bytesX__NAME, "s64vector-swap-bytes!", 21, 21);
8741 static SCM_DEFINE_SUBR(uvlib_s64vector_swap_bytesX__STUB, 1, 0, SCM_OBJ(&uvlib_s64vector_swap_bytesX__NAME), uvlib_s64vector_swap_bytesX, NULL, NULL);
8742 
8743 static ScmObj uvlib_u64vector_swap_bytes(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8744 {
8745   ScmObj v0_scm;
8746   ScmU64Vector* v0;
8747   SCM_ENTER_SUBR("u64vector-swap-bytes");
8748   v0_scm = SCM_ARGREF(0);
8749   if (!SCM_U64VECTORP(v0_scm)) Scm_Error("<u64vector> required, but got %S", v0_scm);
8750   v0 = SCM_U64VECTOR(v0_scm);
8751   {
8752 {
8753 ScmObj SCM_RESULT;
8754 SCM_RESULT = Scm_U64VectorSwapBytes(v0);
8755 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8756 }
8757   }
8758 }
8759 
8760 static SCM_DEFINE_STRING_CONST(uvlib_u64vector_swap_bytes__NAME, "u64vector-swap-bytes", 20, 20);
8761 static SCM_DEFINE_SUBR(uvlib_u64vector_swap_bytes__STUB, 1, 0, SCM_OBJ(&uvlib_u64vector_swap_bytes__NAME), uvlib_u64vector_swap_bytes, NULL, NULL);
8762 
8763 static ScmObj uvlib_u64vector_swap_bytesX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8764 {
8765   ScmObj v0_scm;
8766   ScmU64Vector* v0;
8767   SCM_ENTER_SUBR("u64vector-swap-bytes!");
8768   v0_scm = SCM_ARGREF(0);
8769   if (!SCM_U64VECTORP(v0_scm)) Scm_Error("<u64vector> required, but got %S", v0_scm);
8770   v0 = SCM_U64VECTOR(v0_scm);
8771   {
8772 {
8773 ScmObj SCM_RESULT;
8774 SCM_RESULT = Scm_U64VectorSwapBytesX(v0);
8775 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8776 }
8777   }
8778 }
8779 
8780 static SCM_DEFINE_STRING_CONST(uvlib_u64vector_swap_bytesX__NAME, "u64vector-swap-bytes!", 21, 21);
8781 static SCM_DEFINE_SUBR(uvlib_u64vector_swap_bytesX__STUB, 1, 0, SCM_OBJ(&uvlib_u64vector_swap_bytesX__NAME), uvlib_u64vector_swap_bytesX, NULL, NULL);
8782 
8783 static ScmObj uvlib_f32vector_swap_bytes(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8784 {
8785   ScmObj v0_scm;
8786   ScmF32Vector* v0;
8787   SCM_ENTER_SUBR("f32vector-swap-bytes");
8788   v0_scm = SCM_ARGREF(0);
8789   if (!SCM_F32VECTORP(v0_scm)) Scm_Error("<f32vector> required, but got %S", v0_scm);
8790   v0 = SCM_F32VECTOR(v0_scm);
8791   {
8792 {
8793 ScmObj SCM_RESULT;
8794 SCM_RESULT = Scm_F32VectorSwapBytes(v0);
8795 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8796 }
8797   }
8798 }
8799 
8800 static SCM_DEFINE_STRING_CONST(uvlib_f32vector_swap_bytes__NAME, "f32vector-swap-bytes", 20, 20);
8801 static SCM_DEFINE_SUBR(uvlib_f32vector_swap_bytes__STUB, 1, 0, SCM_OBJ(&uvlib_f32vector_swap_bytes__NAME), uvlib_f32vector_swap_bytes, NULL, NULL);
8802 
8803 static ScmObj uvlib_f32vector_swap_bytesX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8804 {
8805   ScmObj v0_scm;
8806   ScmF32Vector* v0;
8807   SCM_ENTER_SUBR("f32vector-swap-bytes!");
8808   v0_scm = SCM_ARGREF(0);
8809   if (!SCM_F32VECTORP(v0_scm)) Scm_Error("<f32vector> required, but got %S", v0_scm);
8810   v0 = SCM_F32VECTOR(v0_scm);
8811   {
8812 {
8813 ScmObj SCM_RESULT;
8814 SCM_RESULT = Scm_F32VectorSwapBytesX(v0);
8815 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8816 }
8817   }
8818 }
8819 
8820 static SCM_DEFINE_STRING_CONST(uvlib_f32vector_swap_bytesX__NAME, "f32vector-swap-bytes!", 21, 21);
8821 static SCM_DEFINE_SUBR(uvlib_f32vector_swap_bytesX__STUB, 1, 0, SCM_OBJ(&uvlib_f32vector_swap_bytesX__NAME), uvlib_f32vector_swap_bytesX, NULL, NULL);
8822 
8823 static ScmObj uvlib_f64vector_swap_bytes(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8824 {
8825   ScmObj v0_scm;
8826   ScmF64Vector* v0;
8827   SCM_ENTER_SUBR("f64vector-swap-bytes");
8828   v0_scm = SCM_ARGREF(0);
8829   if (!SCM_F64VECTORP(v0_scm)) Scm_Error("<f64vector> required, but got %S", v0_scm);
8830   v0 = SCM_F64VECTOR(v0_scm);
8831   {
8832 {
8833 ScmObj SCM_RESULT;
8834 SCM_RESULT = Scm_F64VectorSwapBytes(v0);
8835 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8836 }
8837   }
8838 }
8839 
8840 static SCM_DEFINE_STRING_CONST(uvlib_f64vector_swap_bytes__NAME, "f64vector-swap-bytes", 20, 20);
8841 static SCM_DEFINE_SUBR(uvlib_f64vector_swap_bytes__STUB, 1, 0, SCM_OBJ(&uvlib_f64vector_swap_bytes__NAME), uvlib_f64vector_swap_bytes, NULL, NULL);
8842 
8843 static ScmObj uvlib_f64vector_swap_bytesX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8844 {
8845   ScmObj v0_scm;
8846   ScmF64Vector* v0;
8847   SCM_ENTER_SUBR("f64vector-swap-bytes!");
8848   v0_scm = SCM_ARGREF(0);
8849   if (!SCM_F64VECTORP(v0_scm)) Scm_Error("<f64vector> required, but got %S", v0_scm);
8850   v0 = SCM_F64VECTOR(v0_scm);
8851   {
8852 {
8853 ScmObj SCM_RESULT;
8854 SCM_RESULT = Scm_F64VectorSwapBytesX(v0);
8855 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8856 }
8857   }
8858 }
8859 
8860 static SCM_DEFINE_STRING_CONST(uvlib_f64vector_swap_bytesX__NAME, "f64vector-swap-bytes!", 21, 21);
8861 static SCM_DEFINE_SUBR(uvlib_f64vector_swap_bytesX__STUB, 1, 0, SCM_OBJ(&uvlib_f64vector_swap_bytesX__NAME), uvlib_f64vector_swap_bytesX, NULL, NULL);
8862 
8863 static ScmObj uvlib_uvector_alias(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8864 {
8865   ScmObj klass_scm;
8866   ScmClass* klass;
8867   ScmObj v_scm;
8868   ScmUVector* v;
8869   ScmObj start_scm;
8870   int start;
8871   ScmObj end_scm;
8872   int end;
8873   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
8874   SCM_ENTER_SUBR("uvector-alias");
8875   if (Scm_Length(SCM_OPTARGS) > 2)
8876     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
8877   klass_scm = SCM_ARGREF(0);
8878   if (!SCM_CLASSP(klass_scm)) Scm_Error("class required, but got %S", klass_scm);
8879   klass = SCM_CLASS(klass_scm);
8880   v_scm = SCM_ARGREF(1);
8881   if (!SCM_UVECTORP(v_scm)) Scm_Error("<uvector> required, but got %S", v_scm);
8882   v = SCM_UVECTOR(v_scm);
8883   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
8884   else {
8885     start_scm = SCM_CAR(SCM_OPTARGS);
8886     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
8887   }
8888   if (!SCM_EXACTP(start_scm)) Scm_Error("C integer required, but got %S", start_scm);
8889   start = Scm_GetInteger(start_scm);
8890   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
8891   else {
8892     end_scm = SCM_CAR(SCM_OPTARGS);
8893     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
8894   }
8895   if (!SCM_EXACTP(end_scm)) Scm_Error("C integer required, but got %S", end_scm);
8896   end = Scm_GetInteger(end_scm);
8897   {
8898 {
8899 ScmObj SCM_RESULT;
8900 SCM_RESULT = Scm_UVectorAlias(klass, v, start, end);
8901 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8902 }
8903   }
8904 }
8905 
8906 static SCM_DEFINE_STRING_CONST(uvlib_uvector_alias__NAME, "uvector-alias", 13, 13);
8907 static SCM_DEFINE_SUBR(uvlib_uvector_alias__STUB, 2, 1, SCM_OBJ(&uvlib_uvector_alias__NAME), uvlib_uvector_alias, NULL, NULL);
8908 
8909 static ScmObj uvlib_uvector_swap_bytes(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8910 {
8911   ScmObj v_scm;
8912   ScmUVector* v;
8913   SCM_ENTER_SUBR("uvector-swap-bytes");
8914   v_scm = SCM_ARGREF(0);
8915   if (!SCM_UVECTORP(v_scm)) Scm_Error("<uvector> required, but got %S", v_scm);
8916   v = SCM_UVECTOR(v_scm);
8917   {
8918 {
8919 ScmObj SCM_RESULT;
8920 SCM_RESULT = Scm_UVectorSwapBytes(v);
8921 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8922 }
8923   }
8924 }
8925 
8926 static SCM_DEFINE_STRING_CONST(uvlib_uvector_swap_bytes__NAME, "uvector-swap-bytes", 18, 18);
8927 static SCM_DEFINE_SUBR(uvlib_uvector_swap_bytes__STUB, 1, 0, SCM_OBJ(&uvlib_uvector_swap_bytes__NAME), uvlib_uvector_swap_bytes, NULL, NULL);
8928 
8929 static ScmObj uvlib_uvector_swap_bytesX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8930 {
8931   ScmObj v_scm;
8932   ScmUVector* v;
8933   SCM_ENTER_SUBR("uvector-swap-bytes!");
8934   v_scm = SCM_ARGREF(0);
8935   if (!SCM_UVECTORP(v_scm)) Scm_Error("<uvector> required, but got %S", v_scm);
8936   v = SCM_UVECTOR(v_scm);
8937   {
8938 {
8939 ScmObj SCM_RESULT;
8940 SCM_RESULT = Scm_UVectorSwapBytesX(v);
8941 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
8942 }
8943   }
8944 }
8945 
8946 static SCM_DEFINE_STRING_CONST(uvlib_uvector_swap_bytesX__NAME, "uvector-swap-bytes!", 19, 19);
8947 static SCM_DEFINE_SUBR(uvlib_uvector_swap_bytesX__STUB, 1, 0, SCM_OBJ(&uvlib_uvector_swap_bytesX__NAME), uvlib_uvector_swap_bytesX, NULL, NULL);
8948 
8949 static ScmObj uvlib_read_blockX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
8950 {
8951   ScmObj v_scm;
8952   ScmUVector* v;
8953   ScmObj port_scm;
8954   ScmPort* port;
8955   ScmObj start_scm;
8956   int start;
8957   ScmObj end_scm;
8958   int end;
8959   ScmObj endian_scm;
8960   ScmObj endian;
8961   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
8962   SCM_ENTER_SUBR("read-block!");
8963   if (Scm_Length(SCM_OPTARGS) > 4)
8964     Scm_Error("too many arguments: up to 4 is expected, %d given.", Scm_Length(SCM_OPTARGS));
8965   v_scm = SCM_ARGREF(0);
8966   if (!SCM_UVECTORP(v_scm)) Scm_Error("<uvector> required, but got %S", v_scm);
8967   v = SCM_UVECTOR(v_scm);
8968   if (SCM_NULLP(SCM_OPTARGS)) port_scm = SCM_OBJ(SCM_CURIN);
8969   else {
8970     port_scm = SCM_CAR(SCM_OPTARGS);
8971     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
8972   }
8973   if (!SCM_IPORTP(port_scm)) Scm_Error("input port required, but got %S", port_scm);
8974   port = SCM_PORT(port_scm);
8975   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
8976   else {
8977     start_scm = SCM_CAR(SCM_OPTARGS);
8978     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
8979   }
8980   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
8981   start = SCM_INT_VALUE(start_scm);
8982   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
8983   else {
8984     end_scm = SCM_CAR(SCM_OPTARGS);
8985     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
8986   }
8987   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
8988   end = SCM_INT_VALUE(end_scm);
8989   if (SCM_NULLP(SCM_OPTARGS)) endian_scm = SCM_FALSE;
8990   else {
8991     endian_scm = SCM_CAR(SCM_OPTARGS);
8992     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
8993   }
8994   endian = (endian_scm);
8995   {
8996 {
8997 ScmObj SCM_RESULT;
8998 SCM_RESULT = Scm_ReadBlockX(v, port, start, end, endian);
8999 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
9000 }
9001   }
9002 }
9003 
9004 static SCM_DEFINE_STRING_CONST(uvlib_read_blockX__NAME, "read-block!", 11, 11);
9005 static SCM_DEFINE_SUBR(uvlib_read_blockX__STUB, 1, 1, SCM_OBJ(&uvlib_read_blockX__NAME), uvlib_read_blockX, NULL, NULL);
9006 
9007 static ScmObj uvlib_write_block(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
9008 {
9009   ScmObj v_scm;
9010   ScmUVector* v;
9011   ScmObj port_scm;
9012   ScmPort* port;
9013   ScmObj start_scm;
9014   int start;
9015   ScmObj end_scm;
9016   int end;
9017   ScmObj endian_scm;
9018   ScmObj endian;
9019   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
9020   SCM_ENTER_SUBR("write-block");
9021   if (Scm_Length(SCM_OPTARGS) > 4)
9022     Scm_Error("too many arguments: up to 4 is expected, %d given.", Scm_Length(SCM_OPTARGS));
9023   v_scm = SCM_ARGREF(0);
9024   if (!SCM_UVECTORP(v_scm)) Scm_Error("<uvector> required, but got %S", v_scm);
9025   v = SCM_UVECTOR(v_scm);
9026   if (SCM_NULLP(SCM_OPTARGS)) port_scm = SCM_OBJ(SCM_CUROUT);
9027   else {
9028     port_scm = SCM_CAR(SCM_OPTARGS);
9029     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
9030   }
9031   if (!SCM_OPORTP(port_scm)) Scm_Error("output port required, but got %S", port_scm);
9032   port = SCM_PORT(port_scm);
9033   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
9034   else {
9035     start_scm = SCM_CAR(SCM_OPTARGS);
9036     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
9037   }
9038   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
9039   start = SCM_INT_VALUE(start_scm);
9040   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
9041   else {
9042     end_scm = SCM_CAR(SCM_OPTARGS);
9043     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
9044   }
9045   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
9046   end = SCM_INT_VALUE(end_scm);
9047   if (SCM_NULLP(SCM_OPTARGS)) endian_scm = SCM_FALSE;
9048   else {
9049     endian_scm = SCM_CAR(SCM_OPTARGS);
9050     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
9051   }
9052   endian = (endian_scm);
9053   {
9054 {
9055 ScmObj SCM_RESULT;
9056 SCM_RESULT = Scm_WriteBlock(v, port, start, end, endian);
9057 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
9058 }
9059   }
9060 }
9061 
9062 static SCM_DEFINE_STRING_CONST(uvlib_write_block__NAME, "write-block", 11, 11);
9063 static SCM_DEFINE_SUBR(uvlib_write_block__STUB, 1, 1, SCM_OBJ(&uvlib_write_block__NAME), uvlib_write_block, NULL, NULL);
9064 
9065 static ScmObj string_to_bytevector(ScmClass *klass, ScmString *s, int start, int end)
9066  {
9067   u_int size, len; const char *ss, *sp, *ep; char *buf;
9068   ss = Scm_GetStringContent(s, &size, &len, NULL);
9069   SCM_CHECK_START_END(start, end, len);
9070   if (start == 0) sp = ss;
9071   else sp = Scm_StringPosition(s, start);
9072   if (end == len) ep = ss + size;
9073   else ep = Scm_StringPosition(s, end);
9074   buf = SCM_NEW_ATOMIC2(char *, ep-sp);
9075   memcpy(buf, sp, ep-sp);
9076   return Scm_MakeUVectorFull(klass, ep-sp, buf, FALSE, NULL);
9077  }
9078 static ScmObj uvlib_string_TOs8vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
9079 {
9080   ScmObj s_scm;
9081   ScmString* s;
9082   ScmObj start_scm;
9083   int start;
9084   ScmObj end_scm;
9085   int end;
9086   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
9087   SCM_ENTER_SUBR("string->s8vector");
9088   if (Scm_Length(SCM_OPTARGS) > 2)
9089     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
9090   s_scm = SCM_ARGREF(0);
9091   if (!SCM_STRINGP(s_scm)) Scm_Error("string required, but got %S", s_scm);
9092   s = SCM_STRING(s_scm);
9093   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
9094   else {
9095     start_scm = SCM_CAR(SCM_OPTARGS);
9096     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
9097   }
9098   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
9099   start = SCM_INT_VALUE(start_scm);
9100   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
9101   else {
9102     end_scm = SCM_CAR(SCM_OPTARGS);
9103     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
9104   }
9105   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
9106   end = SCM_INT_VALUE(end_scm);
9107   {
9108 SCM_RETURN(string_to_bytevector(SCM_CLASS_S8VECTOR, s, start, end));
9109   }
9110 }
9111 
9112 static SCM_DEFINE_STRING_CONST(uvlib_string_TOs8vector__NAME, "string->s8vector", 16, 16);
9113 static SCM_DEFINE_SUBR(uvlib_string_TOs8vector__STUB, 1, 1, SCM_OBJ(&uvlib_string_TOs8vector__NAME), uvlib_string_TOs8vector, NULL, NULL);
9114 
9115 static ScmObj uvlib_string_TOu8vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
9116 {
9117   ScmObj s_scm;
9118   ScmString* s;
9119   ScmObj start_scm;
9120   int start;
9121   ScmObj end_scm;
9122   int end;
9123   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
9124   SCM_ENTER_SUBR("string->u8vector");
9125   if (Scm_Length(SCM_OPTARGS) > 2)
9126     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
9127   s_scm = SCM_ARGREF(0);
9128   if (!SCM_STRINGP(s_scm)) Scm_Error("string required, but got %S", s_scm);
9129   s = SCM_STRING(s_scm);
9130   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
9131   else {
9132     start_scm = SCM_CAR(SCM_OPTARGS);
9133     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
9134   }
9135   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
9136   start = SCM_INT_VALUE(start_scm);
9137   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
9138   else {
9139     end_scm = SCM_CAR(SCM_OPTARGS);
9140     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
9141   }
9142   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
9143   end = SCM_INT_VALUE(end_scm);
9144   {
9145 SCM_RETURN(string_to_bytevector(SCM_CLASS_U8VECTOR, s, start, end));
9146   }
9147 }
9148 
9149 static SCM_DEFINE_STRING_CONST(uvlib_string_TOu8vector__NAME, "string->u8vector", 16, 16);
9150 static SCM_DEFINE_SUBR(uvlib_string_TOu8vector__STUB, 1, 1, SCM_OBJ(&uvlib_string_TOu8vector__NAME), uvlib_string_TOu8vector, NULL, NULL);
9151 
9152 static ScmObj string_to_bytevectorX(ScmUVector *v, int tstart, ScmString *s, int start, int end)
9153  {
9154    u_int size, len; const char *ss, *sp, *ep; char *buf;
9155    int tlen = SCM_UVECTOR_SIZE(v), i;
9156 
9157    if (tstart >= tlen || tstart < 0) return SCM_OBJ(v);
9158    SCM_UVECTOR_CHECK_MUTABLE(v);
9159    ss = Scm_GetStringContent(s, &size, &len, NULL);
9160    SCM_CHECK_START_END(start, end, len);
9161    if (start == 0) sp = ss;
9162    else sp = Scm_StringPosition(s, start);
9163    if (end == len) ep = ss+size;
9164    else ep = Scm_StringPosition(s, end);
9165 
9166    buf = (char *)SCM_UVECTOR_ELEMENTS(v) + tstart;
9167    if (tlen - tstart > ep - sp) {
9168      memcpy(buf, sp, ep - sp);
9169    } else {
9170      memcpy(buf, sp, tlen - tstart);
9171    }
9172    return SCM_OBJ(v);
9173  }
9174 static ScmObj uvlib_string_TOs8vectorX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
9175 {
9176   ScmObj v_scm;
9177   ScmS8Vector* v;
9178   ScmObj tstart_scm;
9179   int tstart;
9180   ScmObj s_scm;
9181   ScmString* s;
9182   ScmObj start_scm;
9183   int start;
9184   ScmObj end_scm;
9185   int end;
9186   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
9187   SCM_ENTER_SUBR("string->s8vector!");
9188   if (Scm_Length(SCM_OPTARGS) > 2)
9189     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
9190   v_scm = SCM_ARGREF(0);
9191   if (!SCM_S8VECTORP(v_scm)) Scm_Error("<s8vector> required, but got %S", v_scm);
9192   v = SCM_S8VECTOR(v_scm);
9193   tstart_scm = SCM_ARGREF(1);
9194   if (!SCM_EXACTP(tstart_scm)) Scm_Error("C integer required, but got %S", tstart_scm);
9195   tstart = Scm_GetInteger(tstart_scm);
9196   s_scm = SCM_ARGREF(2);
9197   if (!SCM_STRINGP(s_scm)) Scm_Error("string required, but got %S", s_scm);
9198   s = SCM_STRING(s_scm);
9199   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
9200   else {
9201     start_scm = SCM_CAR(SCM_OPTARGS);
9202     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
9203   }
9204   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
9205   start = SCM_INT_VALUE(start_scm);
9206   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
9207   else {
9208     end_scm = SCM_CAR(SCM_OPTARGS);
9209     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
9210   }
9211   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
9212   end = SCM_INT_VALUE(end_scm);
9213   {
9214 SCM_RETURN(string_to_bytevectorX(SCM_UVECTOR(v), tstart, s, start, end));
9215   }
9216 }
9217 
9218 static SCM_DEFINE_STRING_CONST(uvlib_string_TOs8vectorX__NAME, "string->s8vector!", 17, 17);
9219 static SCM_DEFINE_SUBR(uvlib_string_TOs8vectorX__STUB, 3, 1, SCM_OBJ(&uvlib_string_TOs8vectorX__NAME), uvlib_string_TOs8vectorX, NULL, NULL);
9220 
9221 static ScmObj uvlib_string_TOu8vectorX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
9222 {
9223   ScmObj v_scm;
9224   ScmU8Vector* v;
9225   ScmObj tstart_scm;
9226   int tstart;
9227   ScmObj s_scm;
9228   ScmString* s;
9229   ScmObj start_scm;
9230   int start;
9231   ScmObj end_scm;
9232   int end;
9233   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
9234   SCM_ENTER_SUBR("string->u8vector!");
9235   if (Scm_Length(SCM_OPTARGS) > 2)
9236     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
9237   v_scm = SCM_ARGREF(0);
9238   if (!SCM_U8VECTORP(v_scm)) Scm_Error("<u8vector> required, but got %S", v_scm);
9239   v = SCM_U8VECTOR(v_scm);
9240   tstart_scm = SCM_ARGREF(1);
9241   if (!SCM_EXACTP(tstart_scm)) Scm_Error("C integer required, but got %S", tstart_scm);
9242   tstart = Scm_GetInteger(tstart_scm);
9243   s_scm = SCM_ARGREF(2);
9244   if (!SCM_STRINGP(s_scm)) Scm_Error("string required, but got %S", s_scm);
9245   s = SCM_STRING(s_scm);
9246   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
9247   else {
9248     start_scm = SCM_CAR(SCM_OPTARGS);
9249     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
9250   }
9251   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
9252   start = SCM_INT_VALUE(start_scm);
9253   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
9254   else {
9255     end_scm = SCM_CAR(SCM_OPTARGS);
9256     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
9257   }
9258   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
9259   end = SCM_INT_VALUE(end_scm);
9260   {
9261 SCM_RETURN(string_to_bytevectorX(SCM_UVECTOR(v), tstart, s, start, end));
9262   }
9263 }
9264 
9265 static SCM_DEFINE_STRING_CONST(uvlib_string_TOu8vectorX__NAME, "string->u8vector!", 17, 17);
9266 static SCM_DEFINE_SUBR(uvlib_string_TOu8vectorX__STUB, 3, 1, SCM_OBJ(&uvlib_string_TOu8vectorX__NAME), uvlib_string_TOu8vectorX, NULL, NULL);
9267 
9268 static ScmObj bytevector_to_string(ScmUVector *v, int start, int end)
9269  {
9270    int len = SCM_UVECTOR_SIZE(v);
9271    SCM_CHECK_START_END(start, end, len);
9272    return Scm_MakeString((char *)(SCM_UVECTOR_ELEMENTS(v)+start),
9273                          end-start, -1, SCM_MAKSTR_COPYING);
9274  }
9275 static ScmObj uvlib_s8vector_TOstring(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
9276 {
9277   ScmObj v_scm;
9278   ScmS8Vector* v;
9279   ScmObj start_scm;
9280   int start;
9281   ScmObj end_scm;
9282   int end;
9283   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
9284   SCM_ENTER_SUBR("s8vector->string");
9285   if (Scm_Length(SCM_OPTARGS) > 2)
9286     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
9287   v_scm = SCM_ARGREF(0);
9288   if (!SCM_S8VECTORP(v_scm)) Scm_Error("<s8vector> required, but got %S", v_scm);
9289   v = SCM_S8VECTOR(v_scm);
9290   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
9291   else {
9292     start_scm = SCM_CAR(SCM_OPTARGS);
9293     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
9294   }
9295   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
9296   start = SCM_INT_VALUE(start_scm);
9297   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
9298   else {
9299     end_scm = SCM_CAR(SCM_OPTARGS);
9300     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
9301   }
9302   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
9303   end = SCM_INT_VALUE(end_scm);
9304   {
9305 SCM_RETURN(bytevector_to_string(SCM_UVECTOR(v), start, end));
9306   }
9307 }
9308 
9309 static SCM_DEFINE_STRING_CONST(uvlib_s8vector_TOstring__NAME, "s8vector->string", 16, 16);
9310 static SCM_DEFINE_SUBR(uvlib_s8vector_TOstring__STUB, 1, 1, SCM_OBJ(&uvlib_s8vector_TOstring__NAME), uvlib_s8vector_TOstring, NULL, NULL);
9311 
9312 static ScmObj uvlib_u8vector_TOstring(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
9313 {
9314   ScmObj v_scm;
9315   ScmU8Vector* v;
9316   ScmObj start_scm;
9317   int start;
9318   ScmObj end_scm;
9319   int end;
9320   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
9321   SCM_ENTER_SUBR("u8vector->string");
9322   if (Scm_Length(SCM_OPTARGS) > 2)
9323     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
9324   v_scm = SCM_ARGREF(0);
9325   if (!SCM_U8VECTORP(v_scm)) Scm_Error("<u8vector> required, but got %S", v_scm);
9326   v = SCM_U8VECTOR(v_scm);
9327   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
9328   else {
9329     start_scm = SCM_CAR(SCM_OPTARGS);
9330     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
9331   }
9332   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
9333   start = SCM_INT_VALUE(start_scm);
9334   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
9335   else {
9336     end_scm = SCM_CAR(SCM_OPTARGS);
9337     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
9338   }
9339   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
9340   end = SCM_INT_VALUE(end_scm);
9341   {
9342 SCM_RETURN(bytevector_to_string(SCM_UVECTOR(v), start, end));
9343   }
9344 }
9345 
9346 static SCM_DEFINE_STRING_CONST(uvlib_u8vector_TOstring__NAME, "u8vector->string", 16, 16);
9347 static SCM_DEFINE_SUBR(uvlib_u8vector_TOstring__STUB, 1, 1, SCM_OBJ(&uvlib_u8vector_TOstring__NAME), uvlib_u8vector_TOstring, NULL, NULL);
9348 
9349 static ScmObj string_to_wordvector(ScmClass *klass, ScmString *s, int start, int end)
9350  {
9351   u_int size, len, i; const char *ss, *sp, *ep;
9352   ScmObj v; ScmInt32 *eltp;
9353   ss = Scm_GetStringContent(s, &size, &len, NULL);
9354   SCM_CHECK_START_END(start, end, len);
9355   if (start == 0) sp = ss;
9356   else sp = Scm_StringPosition(s, start);
9357   if (end == len) ep = ss+size;
9358   else ep = Scm_StringPosition(s, end);
9359   v = Scm_MakeUVector(klass, end - start, NULL);
9360   eltp = (ScmInt32*)SCM_UVECTOR_ELEMENTS(v);
9361   for (i=0; sp<ep; i++) {
9362     ScmChar ch;
9363     SCM_CHAR_GET(sp, ch);
9364     eltp[i] = ch;
9365     sp += SCM_CHAR_NBYTES(ch);
9366   }
9367   SCM_RETURN(v);
9368  }
9369 static ScmObj uvlib_string_TOs32vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
9370 {
9371   ScmObj s_scm;
9372   ScmString* s;
9373   ScmObj start_scm;
9374   int start;
9375   ScmObj end_scm;
9376   int end;
9377   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
9378   SCM_ENTER_SUBR("string->s32vector");
9379   if (Scm_Length(SCM_OPTARGS) > 2)
9380     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
9381   s_scm = SCM_ARGREF(0);
9382   if (!SCM_STRINGP(s_scm)) Scm_Error("string required, but got %S", s_scm);
9383   s = SCM_STRING(s_scm);
9384   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
9385   else {
9386     start_scm = SCM_CAR(SCM_OPTARGS);
9387     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
9388   }
9389   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
9390   start = SCM_INT_VALUE(start_scm);
9391   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
9392   else {
9393     end_scm = SCM_CAR(SCM_OPTARGS);
9394     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
9395   }
9396   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
9397   end = SCM_INT_VALUE(end_scm);
9398   {
9399 SCM_RETURN(string_to_wordvector(SCM_CLASS_S32VECTOR, s, start, end));
9400   }
9401 }
9402 
9403 static SCM_DEFINE_STRING_CONST(uvlib_string_TOs32vector__NAME, "string->s32vector", 17, 17);
9404 static SCM_DEFINE_SUBR(uvlib_string_TOs32vector__STUB, 1, 1, SCM_OBJ(&uvlib_string_TOs32vector__NAME), uvlib_string_TOs32vector, NULL, NULL);
9405 
9406 static ScmObj uvlib_string_TOu32vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
9407 {
9408   ScmObj s_scm;
9409   ScmString* s;
9410   ScmObj start_scm;
9411   int start;
9412   ScmObj end_scm;
9413   int end;
9414   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
9415   SCM_ENTER_SUBR("string->u32vector");
9416   if (Scm_Length(SCM_OPTARGS) > 2)
9417     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
9418   s_scm = SCM_ARGREF(0);
9419   if (!SCM_STRINGP(s_scm)) Scm_Error("string required, but got %S", s_scm);
9420   s = SCM_STRING(s_scm);
9421   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
9422   else {
9423     start_scm = SCM_CAR(SCM_OPTARGS);
9424     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
9425   }
9426   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
9427   start = SCM_INT_VALUE(start_scm);
9428   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
9429   else {
9430     end_scm = SCM_CAR(SCM_OPTARGS);
9431     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
9432   }
9433   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
9434   end = SCM_INT_VALUE(end_scm);
9435   {
9436 SCM_RETURN(string_to_wordvector(SCM_CLASS_U32VECTOR, s, start, end));
9437   }
9438 }
9439 
9440 static SCM_DEFINE_STRING_CONST(uvlib_string_TOu32vector__NAME, "string->u32vector", 17, 17);
9441 static SCM_DEFINE_SUBR(uvlib_string_TOu32vector__STUB, 1, 1, SCM_OBJ(&uvlib_string_TOu32vector__NAME), uvlib_string_TOu32vector, NULL, NULL);
9442 
9443 static ScmObj wordvector_to_string(ScmUVector *v, int start, int end)
9444  {
9445   int len = SCM_UVECTOR_SIZE(v);
9446   ScmObj s = Scm_MakeOutputStringPort(FALSE);
9447   ScmInt32 *eltp;
9448   SCM_CHECK_START_END(start, end, len);
9449   eltp = (ScmInt32*)SCM_UVECTOR_ELEMENTS(v);
9450   for (; start < end; start++) {
9451     ScmChar ch = (ScmChar)eltp[start];
9452     Scm_PutcUnsafe(ch, SCM_PORT(s));
9453   }
9454   SCM_RETURN(Scm_GetOutputStringUnsafe(SCM_PORT(s)));
9455  }
9456 static ScmObj uvlib_s32vector_TOstring(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
9457 {
9458   ScmObj v_scm;
9459   ScmS32Vector* v;
9460   ScmObj start_scm;
9461   int start;
9462   ScmObj end_scm;
9463   int end;
9464   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
9465   SCM_ENTER_SUBR("s32vector->string");
9466   if (Scm_Length(SCM_OPTARGS) > 2)
9467     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
9468   v_scm = SCM_ARGREF(0);
9469   if (!SCM_S32VECTORP(v_scm)) Scm_Error("<s32vector> required, but got %S", v_scm);
9470   v = SCM_S32VECTOR(v_scm);
9471   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
9472   else {
9473     start_scm = SCM_CAR(SCM_OPTARGS);
9474     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
9475   }
9476   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
9477   start = SCM_INT_VALUE(start_scm);
9478   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
9479   else {
9480     end_scm = SCM_CAR(SCM_OPTARGS);
9481     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
9482   }
9483   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
9484   end = SCM_INT_VALUE(end_scm);
9485   {
9486 SCM_RETURN(wordvector_to_string(SCM_UVECTOR(v), start, end));
9487   }
9488 }
9489 
9490 static SCM_DEFINE_STRING_CONST(uvlib_s32vector_TOstring__NAME, "s32vector->string", 17, 17);
9491 static SCM_DEFINE_SUBR(uvlib_s32vector_TOstring__STUB, 1, 1, SCM_OBJ(&uvlib_s32vector_TOstring__NAME), uvlib_s32vector_TOstring, NULL, NULL);
9492 
9493 static ScmObj uvlib_u32vector_TOstring(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
9494 {
9495   ScmObj v_scm;
9496   ScmU32Vector* v;
9497   ScmObj start_scm;
9498   int start;
9499   ScmObj end_scm;
9500   int end;
9501   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
9502   SCM_ENTER_SUBR("u32vector->string");
9503   if (Scm_Length(SCM_OPTARGS) > 2)
9504     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
9505   v_scm = SCM_ARGREF(0);
9506   if (!SCM_U32VECTORP(v_scm)) Scm_Error("<u32vector> required, but got %S", v_scm);
9507   v = SCM_U32VECTOR(v_scm);
9508   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
9509   else {
9510     start_scm = SCM_CAR(SCM_OPTARGS);
9511     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
9512   }
9513   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
9514   start = SCM_INT_VALUE(start_scm);
9515   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
9516   else {
9517     end_scm = SCM_CAR(SCM_OPTARGS);
9518     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
9519   }
9520   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
9521   end = SCM_INT_VALUE(end_scm);
9522   {
9523 SCM_RETURN(wordvector_to_string(SCM_UVECTOR(v), start, end));
9524   }
9525 }
9526 
9527 static SCM_DEFINE_STRING_CONST(uvlib_u32vector_TOstring__NAME, "u32vector->string", 17, 17);
9528 static SCM_DEFINE_SUBR(uvlib_u32vector_TOstring__STUB, 1, 1, SCM_OBJ(&uvlib_u32vector_TOstring__NAME), uvlib_u32vector_TOstring, NULL, NULL);
9529 
9530 void Scm_Init_uvlib(ScmModule *module)
9531 {
9532 
9533   SCM_DEFINE(module, "u32vector->string", SCM_OBJ(&uvlib_u32vector_TOstring__STUB));
9534   SCM_DEFINE(module, "s32vector->string", SCM_OBJ(&uvlib_s32vector_TOstring__STUB));
9535   SCM_DEFINE(module, "string->u32vector", SCM_OBJ(&uvlib_string_TOu32vector__STUB));
9536   SCM_DEFINE(module, "string->s32vector", SCM_OBJ(&uvlib_string_TOs32vector__STUB));
9537   SCM_DEFINE(module, "u8vector->string", SCM_OBJ(&uvlib_u8vector_TOstring__STUB));
9538   SCM_DEFINE(module, "s8vector->string", SCM_OBJ(&uvlib_s8vector_TOstring__STUB));
9539   SCM_DEFINE(module, "string->u8vector!", SCM_OBJ(&uvlib_string_TOu8vectorX__STUB));
9540   SCM_DEFINE(module, "string->s8vector!", SCM_OBJ(&uvlib_string_TOs8vectorX__STUB));
9541   SCM_DEFINE(module, "string->u8vector", SCM_OBJ(&uvlib_string_TOu8vector__STUB));
9542   SCM_DEFINE(module, "string->s8vector", SCM_OBJ(&uvlib_string_TOs8vector__STUB));
9543   SCM_DEFINE(module, "write-block", SCM_OBJ(&uvlib_write_block__STUB));
9544   SCM_DEFINE(module, "read-block!", SCM_OBJ(&uvlib_read_blockX__STUB));
9545   SCM_DEFINE(module, "uvector-swap-bytes!", SCM_OBJ(&uvlib_uvector_swap_bytesX__STUB));
9546   SCM_DEFINE(module, "uvector-swap-bytes", SCM_OBJ(&uvlib_uvector_swap_bytes__STUB));
9547   SCM_DEFINE(module, "uvector-alias", SCM_OBJ(&uvlib_uvector_alias__STUB));
9548   SCM_DEFINE(module, "f64vector-swap-bytes!", SCM_OBJ(&uvlib_f64vector_swap_bytesX__STUB));
9549   SCM_DEFINE(module, "f64vector-swap-bytes", SCM_OBJ(&uvlib_f64vector_swap_bytes__STUB));
9550   SCM_DEFINE(module, "f32vector-swap-bytes!", SCM_OBJ(&uvlib_f32vector_swap_bytesX__STUB));
9551   SCM_DEFINE(module, "f32vector-swap-bytes", SCM_OBJ(&uvlib_f32vector_swap_bytes__STUB));
9552   SCM_DEFINE(module, "u64vector-swap-bytes!", SCM_OBJ(&uvlib_u64vector_swap_bytesX__STUB));
9553   SCM_DEFINE(module, "u64vector-swap-bytes", SCM_OBJ(&uvlib_u64vector_swap_bytes__STUB));
9554   SCM_DEFINE(module, "s64vector-swap-bytes!", SCM_OBJ(&uvlib_s64vector_swap_bytesX__STUB));
9555   SCM_DEFINE(module, "s64vector-swap-bytes", SCM_OBJ(&uvlib_s64vector_swap_bytes__STUB));
9556   SCM_DEFINE(module, "u32vector-swap-bytes!", SCM_OBJ(&uvlib_u32vector_swap_bytesX__STUB));
9557   SCM_DEFINE(module, "u32vector-swap-bytes", SCM_OBJ(&uvlib_u32vector_swap_bytes__STUB));
9558   SCM_DEFINE(module, "s32vector-swap-bytes!", SCM_OBJ(&uvlib_s32vector_swap_bytesX__STUB));
9559   SCM_DEFINE(module, "s32vector-swap-bytes", SCM_OBJ(&uvlib_s32vector_swap_bytes__STUB));
9560   SCM_DEFINE(module, "u16vector-swap-bytes!", SCM_OBJ(&uvlib_u16vector_swap_bytesX__STUB));
9561   SCM_DEFINE(module, "u16vector-swap-bytes", SCM_OBJ(&uvlib_u16vector_swap_bytes__STUB));
9562   SCM_DEFINE(module, "s16vector-swap-bytes!", SCM_OBJ(&uvlib_s16vector_swap_bytesX__STUB));
9563   SCM_DEFINE(module, "s16vector-swap-bytes", SCM_OBJ(&uvlib_s16vector_swap_bytes__STUB));
9564   SCM_DEFINE(module, "f64vector-clamp!", SCM_OBJ(&uvlib_f64vector_clampX__STUB));
9565   SCM_DEFINE(module, "f64vector-clamp", SCM_OBJ(&uvlib_f64vector_clamp__STUB));
9566   SCM_DEFINE(module, "f64vector-range-check", SCM_OBJ(&uvlib_f64vector_range_check__STUB));
9567   SCM_DEFINE(module, "f32vector-clamp!", SCM_OBJ(&uvlib_f32vector_clampX__STUB));
9568   SCM_DEFINE(module, "f32vector-clamp", SCM_OBJ(&uvlib_f32vector_clamp__STUB));
9569   SCM_DEFINE(module, "f32vector-range-check", SCM_OBJ(&uvlib_f32vector_range_check__STUB));
9570   SCM_DEFINE(module, "u64vector-clamp!", SCM_OBJ(&uvlib_u64vector_clampX__STUB));
9571   SCM_DEFINE(module, "u64vector-clamp", SCM_OBJ(&uvlib_u64vector_clamp__STUB));
9572   SCM_DEFINE(module, "u64vector-range-check", SCM_OBJ(&uvlib_u64vector_range_check__STUB));
9573   SCM_DEFINE(module, "s64vector-clamp!", SCM_OBJ(&uvlib_s64vector_clampX__STUB));
9574   SCM_DEFINE(module, "s64vector-clamp", SCM_OBJ(&uvlib_s64vector_clamp__STUB));
9575   SCM_DEFINE(module, "s64vector-range-check", SCM_OBJ(&uvlib_s64vector_range_check__STUB));
9576   SCM_DEFINE(module, "u32vector-clamp!", SCM_OBJ(&uvlib_u32vector_clampX__STUB));
9577   SCM_DEFINE(module, "u32vector-clamp", SCM_OBJ(&uvlib_u32vector_clamp__STUB));
9578   SCM_DEFINE(module, "u32vector-range-check", SCM_OBJ(&uvlib_u32vector_range_check__STUB));
9579   SCM_DEFINE(module, "s32vector-clamp!", SCM_OBJ(&uvlib_s32vector_clampX__STUB));
9580   SCM_DEFINE(module, "s32vector-clamp", SCM_OBJ(&uvlib_s32vector_clamp__STUB));
9581   SCM_DEFINE(module, "s32vector-range-check", SCM_OBJ(&uvlib_s32vector_range_check__STUB));
9582   SCM_DEFINE(module, "u16vector-clamp!", SCM_OBJ(&uvlib_u16vector_clampX__STUB));
9583   SCM_DEFINE(module, "u16vector-clamp", SCM_OBJ(&uvlib_u16vector_clamp__STUB));
9584   SCM_DEFINE(module, "u16vector-range-check", SCM_OBJ(&uvlib_u16vector_range_check__STUB));
9585   SCM_DEFINE(module, "s16vector-clamp!", SCM_OBJ(&uvlib_s16vector_clampX__STUB));
9586   SCM_DEFINE(module, "s16vector-clamp", SCM_OBJ(&uvlib_s16vector_clamp__STUB));
9587   SCM_DEFINE(module, "s16vector-range-check", SCM_OBJ(&uvlib_s16vector_range_check__STUB));
9588   SCM_DEFINE(module, "u8vector-clamp!", SCM_OBJ(&uvlib_u8vector_clampX__STUB));
9589   SCM_DEFINE(module, "u8vector-clamp", SCM_OBJ(&uvlib_u8vector_clamp__STUB));
9590   SCM_DEFINE(module, "u8vector-range-check", SCM_OBJ(&uvlib_u8vector_range_check__STUB));
9591   SCM_DEFINE(module, "s8vector-clamp!", SCM_OBJ(&uvlib_s8vector_clampX__STUB));
9592   SCM_DEFINE(module, "s8vector-clamp", SCM_OBJ(&uvlib_s8vector_clamp__STUB));
9593   SCM_DEFINE(module, "s8vector-range-check", SCM_OBJ(&uvlib_s8vector_range_check__STUB));
9594   SCM_DEFINE(module, "f64vector-dot", SCM_OBJ(&uvlib_f64vector_dot__STUB));
9595   SCM_DEFINE(module, "f32vector-dot", SCM_OBJ(&uvlib_f32vector_dot__STUB));
9596   SCM_DEFINE(module, "u64vector-dot", SCM_OBJ(&uvlib_u64vector_dot__STUB));
9597   SCM_DEFINE(module, "s64vector-dot", SCM_OBJ(&uvlib_s64vector_dot__STUB));
9598   SCM_DEFINE(module, "u32vector-dot", SCM_OBJ(&uvlib_u32vector_dot__STUB));
9599   SCM_DEFINE(module, "s32vector-dot", SCM_OBJ(&uvlib_s32vector_dot__STUB));
9600   SCM_DEFINE(module, "u16vector-dot", SCM_OBJ(&uvlib_u16vector_dot__STUB));
9601   SCM_DEFINE(module, "s16vector-dot", SCM_OBJ(&uvlib_s16vector_dot__STUB));
9602   SCM_DEFINE(module, "u8vector-dot", SCM_OBJ(&uvlib_u8vector_dot__STUB));
9603   SCM_DEFINE(module, "s8vector-dot", SCM_OBJ(&uvlib_s8vector_dot__STUB));
9604   SCM_DEFINE(module, "u64vector-xor!", SCM_OBJ(&uvlib_u64vector_xorX__STUB));
9605   SCM_DEFINE(module, "u64vector-xor", SCM_OBJ(&uvlib_u64vector_xor__STUB));
9606   SCM_DEFINE(module, "u64vector-ior!", SCM_OBJ(&uvlib_u64vector_iorX__STUB));
9607   SCM_DEFINE(module, "u64vector-ior", SCM_OBJ(&uvlib_u64vector_ior__STUB));
9608   SCM_DEFINE(module, "u64vector-and!", SCM_OBJ(&uvlib_u64vector_andX__STUB));
9609   SCM_DEFINE(module, "u64vector-and", SCM_OBJ(&uvlib_u64vector_and__STUB));
9610   SCM_DEFINE(module, "s64vector-xor!", SCM_OBJ(&uvlib_s64vector_xorX__STUB));
9611   SCM_DEFINE(module, "s64vector-xor", SCM_OBJ(&uvlib_s64vector_xor__STUB));
9612   SCM_DEFINE(module, "s64vector-ior!", SCM_OBJ(&uvlib_s64vector_iorX__STUB));
9613   SCM_DEFINE(module, "s64vector-ior", SCM_OBJ(&uvlib_s64vector_ior__STUB));
9614   SCM_DEFINE(module, "s64vector-and!", SCM_OBJ(&uvlib_s64vector_andX__STUB));
9615   SCM_DEFINE(module, "s64vector-and", SCM_OBJ(&uvlib_s64vector_and__STUB));
9616   SCM_DEFINE(module, "u32vector-xor!", SCM_OBJ(&uvlib_u32vector_xorX__STUB));
9617   SCM_DEFINE(module, "u32vector-xor", SCM_OBJ(&uvlib_u32vector_xor__STUB));
9618   SCM_DEFINE(module, "u32vector-ior!", SCM_OBJ(&uvlib_u32vector_iorX__STUB));
9619   SCM_DEFINE(module, "u32vector-ior", SCM_OBJ(&uvlib_u32vector_ior__STUB));
9620   SCM_DEFINE(module, "u32vector-and!", SCM_OBJ(&uvlib_u32vector_andX__STUB));
9621   SCM_DEFINE(module, "u32vector-and", SCM_OBJ(&uvlib_u32vector_and__STUB));
9622   SCM_DEFINE(module, "s32vector-xor!", SCM_OBJ(&uvlib_s32vector_xorX__STUB));
9623   SCM_DEFINE(module, "s32vector-xor", SCM_OBJ(&uvlib_s32vector_xor__STUB));
9624   SCM_DEFINE(module, "s32vector-ior!", SCM_OBJ(&uvlib_s32vector_iorX__STUB));
9625   SCM_DEFINE(module, "s32vector-ior", SCM_OBJ(&uvlib_s32vector_ior__STUB));
9626   SCM_DEFINE(module, "s32vector-and!", SCM_OBJ(&uvlib_s32vector_andX__STUB));
9627   SCM_DEFINE(module, "s32vector-and", SCM_OBJ(&uvlib_s32vector_and__STUB));
9628   SCM_DEFINE(module, "u16vector-xor!", SCM_OBJ(&uvlib_u16vector_xorX__STUB));
9629   SCM_DEFINE(module, "u16vector-xor", SCM_OBJ(&uvlib_u16vector_xor__STUB));
9630   SCM_DEFINE(module, "u16vector-ior!", SCM_OBJ(&uvlib_u16vector_iorX__STUB));
9631   SCM_DEFINE(module, "u16vector-ior", SCM_OBJ(&uvlib_u16vector_ior__STUB));
9632   SCM_DEFINE(module, "u16vector-and!", SCM_OBJ(&uvlib_u16vector_andX__STUB));
9633   SCM_DEFINE(module, "u16vector-and", SCM_OBJ(&uvlib_u16vector_and__STUB));
9634   SCM_DEFINE(module, "s16vector-xor!", SCM_OBJ(&uvlib_s16vector_xorX__STUB));
9635   SCM_DEFINE(module, "s16vector-xor", SCM_OBJ(&uvlib_s16vector_xor__STUB));
9636   SCM_DEFINE(module, "s16vector-ior!", SCM_OBJ(&uvlib_s16vector_iorX__STUB));
9637   SCM_DEFINE(module, "s16vector-ior", SCM_OBJ(&uvlib_s16vector_ior__STUB));
9638   SCM_DEFINE(module, "s16vector-and!", SCM_OBJ(&uvlib_s16vector_andX__STUB));
9639   SCM_DEFINE(module, "s16vector-and", SCM_OBJ(&uvlib_s16vector_and__STUB));
9640   SCM_DEFINE(module, "u8vector-xor!", SCM_OBJ(&uvlib_u8vector_xorX__STUB));
9641   SCM_DEFINE(module, "u8vector-xor", SCM_OBJ(&uvlib_u8vector_xor__STUB));
9642   SCM_DEFINE(module, "u8vector-ior!", SCM_OBJ(&uvlib_u8vector_iorX__STUB));
9643   SCM_DEFINE(module, "u8vector-ior", SCM_OBJ(&uvlib_u8vector_ior__STUB));
9644   SCM_DEFINE(module, "u8vector-and!", SCM_OBJ(&uvlib_u8vector_andX__STUB));
9645   SCM_DEFINE(module, "u8vector-and", SCM_OBJ(&uvlib_u8vector_and__STUB));
9646   SCM_DEFINE(module, "s8vector-xor!", SCM_OBJ(&uvlib_s8vector_xorX__STUB));
9647   SCM_DEFINE(module, "s8vector-xor", SCM_OBJ(&uvlib_s8vector_xor__STUB));
9648   SCM_DEFINE(module, "s8vector-ior!", SCM_OBJ(&uvlib_s8vector_iorX__STUB));
9649   SCM_DEFINE(module, "s8vector-ior", SCM_OBJ(&uvlib_s8vector_ior__STUB));
9650   SCM_DEFINE(module, "s8vector-and!", SCM_OBJ(&uvlib_s8vector_andX__STUB));
9651   SCM_DEFINE(module, "s8vector-and", SCM_OBJ(&uvlib_s8vector_and__STUB));
9652   SCM_DEFINE(module, "f64vector-div!", SCM_OBJ(&uvlib_f64vector_divX__STUB));
9653   SCM_DEFINE(module, "f64vector-div", SCM_OBJ(&uvlib_f64vector_div__STUB));
9654   SCM_DEFINE(module, "f32vector-div!", SCM_OBJ(&uvlib_f32vector_divX__STUB));
9655   SCM_DEFINE(module, "f32vector-div", SCM_OBJ(&uvlib_f32vector_div__STUB));
9656   SCM_DEFINE(module, "f64vector-mul!", SCM_OBJ(&uvlib_f64vector_mulX__STUB));
9657   SCM_DEFINE(module, "f64vector-mul", SCM_OBJ(&uvlib_f64vector_mul__STUB));
9658   SCM_DEFINE(module, "f32vector-mul!", SCM_OBJ(&uvlib_f32vector_mulX__STUB));
9659   SCM_DEFINE(module, "f32vector-mul", SCM_OBJ(&uvlib_f32vector_mul__STUB));
9660   SCM_DEFINE(module, "u64vector-mul!", SCM_OBJ(&uvlib_u64vector_mulX__STUB));
9661   SCM_DEFINE(module, "u64vector-mul", SCM_OBJ(&uvlib_u64vector_mul__STUB));
9662   SCM_DEFINE(module, "s64vector-mul!", SCM_OBJ(&uvlib_s64vector_mulX__STUB));
9663   SCM_DEFINE(module, "s64vector-mul", SCM_OBJ(&uvlib_s64vector_mul__STUB));
9664   SCM_DEFINE(module, "u32vector-mul!", SCM_OBJ(&uvlib_u32vector_mulX__STUB));
9665   SCM_DEFINE(module, "u32vector-mul", SCM_OBJ(&uvlib_u32vector_mul__STUB));
9666   SCM_DEFINE(module, "s32vector-mul!", SCM_OBJ(&uvlib_s32vector_mulX__STUB));
9667   SCM_DEFINE(module, "s32vector-mul", SCM_OBJ(&uvlib_s32vector_mul__STUB));
9668   SCM_DEFINE(module, "u16vector-mul!", SCM_OBJ(&uvlib_u16vector_mulX__STUB));
9669   SCM_DEFINE(module, "u16vector-mul", SCM_OBJ(&uvlib_u16vector_mul__STUB));
9670   SCM_DEFINE(module, "s16vector-mul!", SCM_OBJ(&uvlib_s16vector_mulX__STUB));
9671   SCM_DEFINE(module, "s16vector-mul", SCM_OBJ(&uvlib_s16vector_mul__STUB));
9672   SCM_DEFINE(module, "u8vector-mul!", SCM_OBJ(&uvlib_u8vector_mulX__STUB));
9673   SCM_DEFINE(module, "u8vector-mul", SCM_OBJ(&uvlib_u8vector_mul__STUB));
9674   SCM_DEFINE(module, "s8vector-mul!", SCM_OBJ(&uvlib_s8vector_mulX__STUB));
9675   SCM_DEFINE(module, "s8vector-mul", SCM_OBJ(&uvlib_s8vector_mul__STUB));
9676   SCM_DEFINE(module, "f64vector-sub!", SCM_OBJ(&uvlib_f64vector_subX__STUB));
9677   SCM_DEFINE(module, "f64vector-sub", SCM_OBJ(&uvlib_f64vector_sub__STUB));
9678   SCM_DEFINE(module, "f32vector-sub!", SCM_OBJ(&uvlib_f32vector_subX__STUB));
9679   SCM_DEFINE(module, "f32vector-sub", SCM_OBJ(&uvlib_f32vector_sub__STUB));
9680   SCM_DEFINE(module, "u64vector-sub!", SCM_OBJ(&uvlib_u64vector_subX__STUB));
9681   SCM_DEFINE(module, "u64vector-sub", SCM_OBJ(&uvlib_u64vector_sub__STUB));
9682   SCM_DEFINE(module, "s64vector-sub!", SCM_OBJ(&uvlib_s64vector_subX__STUB));
9683   SCM_DEFINE(module, "s64vector-sub", SCM_OBJ(&uvlib_s64vector_sub__STUB));
9684   SCM_DEFINE(module, "u32vector-sub!", SCM_OBJ(&uvlib_u32vector_subX__STUB));
9685   SCM_DEFINE(module, "u32vector-sub", SCM_OBJ(&uvlib_u32vector_sub__STUB));
9686   SCM_DEFINE(module, "s32vector-sub!", SCM_OBJ(&uvlib_s32vector_subX__STUB));
9687   SCM_DEFINE(module, "s32vector-sub", SCM_OBJ(&uvlib_s32vector_sub__STUB));
9688   SCM_DEFINE(module, "u16vector-sub!", SCM_OBJ(&uvlib_u16vector_subX__STUB));
9689   SCM_DEFINE(module, "u16vector-sub", SCM_OBJ(&uvlib_u16vector_sub__STUB));
9690   SCM_DEFINE(module, "s16vector-sub!", SCM_OBJ(&uvlib_s16vector_subX__STUB));
9691   SCM_DEFINE(module, "s16vector-sub", SCM_OBJ(&uvlib_s16vector_sub__STUB));
9692   SCM_DEFINE(module, "u8vector-sub!", SCM_OBJ(&uvlib_u8vector_subX__STUB));
9693   SCM_DEFINE(module, "u8vector-sub", SCM_OBJ(&uvlib_u8vector_sub__STUB));
9694   SCM_DEFINE(module, "s8vector-sub!", SCM_OBJ(&uvlib_s8vector_subX__STUB));
9695   SCM_DEFINE(module, "s8vector-sub", SCM_OBJ(&uvlib_s8vector_sub__STUB));
9696   SCM_DEFINE(module, "f64vector-add!", SCM_OBJ(&uvlib_f64vector_addX__STUB));
9697   SCM_DEFINE(module, "f64vector-add", SCM_OBJ(&uvlib_f64vector_add__STUB));
9698   SCM_DEFINE(module, "f32vector-add!", SCM_OBJ(&uvlib_f32vector_addX__STUB));
9699   SCM_DEFINE(module, "f32vector-add", SCM_OBJ(&uvlib_f32vector_add__STUB));
9700   SCM_DEFINE(module, "u64vector-add!", SCM_OBJ(&uvlib_u64vector_addX__STUB));
9701   SCM_DEFINE(module, "u64vector-add", SCM_OBJ(&uvlib_u64vector_add__STUB));
9702   SCM_DEFINE(module, "s64vector-add!", SCM_OBJ(&uvlib_s64vector_addX__STUB));
9703   SCM_DEFINE(module, "s64vector-add", SCM_OBJ(&uvlib_s64vector_add__STUB));
9704   SCM_DEFINE(module, "u32vector-add!", SCM_OBJ(&uvlib_u32vector_addX__STUB));
9705   SCM_DEFINE(module, "u32vector-add", SCM_OBJ(&uvlib_u32vector_add__STUB));
9706   SCM_DEFINE(module, "s32vector-add!", SCM_OBJ(&uvlib_s32vector_addX__STUB));
9707   SCM_DEFINE(module, "s32vector-add", SCM_OBJ(&uvlib_s32vector_add__STUB));
9708   SCM_DEFINE(module, "u16vector-add!", SCM_OBJ(&uvlib_u16vector_addX__STUB));
9709   SCM_DEFINE(module, "u16vector-add", SCM_OBJ(&uvlib_u16vector_add__STUB));
9710   SCM_DEFINE(module, "s16vector-add!", SCM_OBJ(&uvlib_s16vector_addX__STUB));
9711   SCM_DEFINE(module, "s16vector-add", SCM_OBJ(&uvlib_s16vector_add__STUB));
9712   SCM_DEFINE(module, "u8vector-add!", SCM_OBJ(&uvlib_u8vector_addX__STUB));
9713   SCM_DEFINE(module, "u8vector-add", SCM_OBJ(&uvlib_u8vector_add__STUB));
9714   SCM_DEFINE(module, "s8vector-add!", SCM_OBJ(&uvlib_s8vector_addX__STUB));
9715   SCM_DEFINE(module, "s8vector-add", SCM_OBJ(&uvlib_s8vector_add__STUB));
9716   SCM_DEFINE(module, "vector->f64vector", SCM_OBJ(&uvlib_vector_TOf64vector__STUB));
9717   SCM_DEFINE(module, "f64vector->vector", SCM_OBJ(&uvlib_f64vector_TOvector__STUB));
9718   SCM_DEFINE(module, "f64vector-fill!", SCM_OBJ(&uvlib_f64vector_fillX__STUB));
9719   SCM_DEFINE(module, "list->f64vector", SCM_OBJ(&uvlib_list_TOf64vector__STUB));
9720   SCM_DEFINE(module, "f64vector->list", SCM_OBJ(&uvlib_f64vector_TOlist__STUB));
9721   SCM_DEFINE(module, "f64vector-copy!", SCM_OBJ(&uvlib_f64vector_copyX__STUB));
9722   SCM_DEFINE(module, "f64vector-copy", SCM_OBJ(&uvlib_f64vector_copy__STUB));
9723   SCM_DEFINE(module, "f64vector-set!", SCM_OBJ(&uvlib_f64vector_setX__STUB));
9724   SCM_DEFINE(module, "f64vector-ref", SCM_OBJ(&uvlib_f64vector_ref__STUB));
9725   Scm_SetterSet(SCM_PROCEDURE(&uvlib_f64vector_ref__STUB), SCM_PROCEDURE(&uvlib_f64vector_setX__STUB), TRUE);
9726   SCM_DEFINE(module, "f64vector-length", SCM_OBJ(&uvlib_f64vector_length__STUB));
9727   SCM_DEFINE(module, "f64vector", SCM_OBJ(&uvlib_f64vector__STUB));
9728   SCM_DEFINE(module, "make-f64vector", SCM_OBJ(&uvlib_make_f64vector__STUB));
9729   SCM_DEFINE(module, "f64vector?", SCM_OBJ(&uvlib_f64vectorP__STUB));
9730   SCM_DEFINE(module, "vector->f32vector", SCM_OBJ(&uvlib_vector_TOf32vector__STUB));
9731   SCM_DEFINE(module, "f32vector->vector", SCM_OBJ(&uvlib_f32vector_TOvector__STUB));
9732   SCM_DEFINE(module, "f32vector-fill!", SCM_OBJ(&uvlib_f32vector_fillX__STUB));
9733   SCM_DEFINE(module, "list->f32vector", SCM_OBJ(&uvlib_list_TOf32vector__STUB));
9734   SCM_DEFINE(module, "f32vector->list", SCM_OBJ(&uvlib_f32vector_TOlist__STUB));
9735   SCM_DEFINE(module, "f32vector-copy!", SCM_OBJ(&uvlib_f32vector_copyX__STUB));
9736   SCM_DEFINE(module, "f32vector-copy", SCM_OBJ(&uvlib_f32vector_copy__STUB));
9737   SCM_DEFINE(module, "f32vector-set!", SCM_OBJ(&uvlib_f32vector_setX__STUB));
9738   SCM_DEFINE(module, "f32vector-ref", SCM_OBJ(&uvlib_f32vector_ref__STUB));
9739   Scm_SetterSet(SCM_PROCEDURE(&uvlib_f32vector_ref__STUB), SCM_PROCEDURE(&uvlib_f32vector_setX__STUB), TRUE);
9740   SCM_DEFINE(module, "f32vector-length", SCM_OBJ(&uvlib_f32vector_length__STUB));
9741   SCM_DEFINE(module, "f32vector", SCM_OBJ(&uvlib_f32vector__STUB));
9742   SCM_DEFINE(module, "make-f32vector", SCM_OBJ(&uvlib_make_f32vector__STUB));
9743   SCM_DEFINE(module, "f32vector?", SCM_OBJ(&uvlib_f32vectorP__STUB));
9744   SCM_DEFINE(module, "vector->u64vector", SCM_OBJ(&uvlib_vector_TOu64vector__STUB));
9745   SCM_DEFINE(module, "u64vector->vector", SCM_OBJ(&uvlib_u64vector_TOvector__STUB));
9746   SCM_DEFINE(module, "u64vector-fill!", SCM_OBJ(&uvlib_u64vector_fillX__STUB));
9747   SCM_DEFINE(module, "list->u64vector", SCM_OBJ(&uvlib_list_TOu64vector__STUB));
9748   SCM_DEFINE(module, "u64vector->list", SCM_OBJ(&uvlib_u64vector_TOlist__STUB));
9749   SCM_DEFINE(module, "u64vector-copy!", SCM_OBJ(&uvlib_u64vector_copyX__STUB));
9750   SCM_DEFINE(module, "u64vector-copy", SCM_OBJ(&uvlib_u64vector_copy__STUB));
9751   SCM_DEFINE(module, "u64vector-set!", SCM_OBJ(&uvlib_u64vector_setX__STUB));
9752   SCM_DEFINE(module, "u64vector-ref", SCM_OBJ(&uvlib_u64vector_ref__STUB));
9753   Scm_SetterSet(SCM_PROCEDURE(&uvlib_u64vector_ref__STUB), SCM_PROCEDURE(&uvlib_u64vector_setX__STUB), TRUE);
9754   SCM_DEFINE(module, "u64vector-length", SCM_OBJ(&uvlib_u64vector_length__STUB));
9755   SCM_DEFINE(module, "u64vector", SCM_OBJ(&uvlib_u64vector__STUB));
9756   SCM_DEFINE(module, "make-u64vector", SCM_OBJ(&uvlib_make_u64vector__STUB));
9757   SCM_DEFINE(module, "u64vector?", SCM_OBJ(&uvlib_u64vectorP__STUB));
9758   SCM_DEFINE(module, "vector->s64vector", SCM_OBJ(&uvlib_vector_TOs64vector__STUB));
9759   SCM_DEFINE(module, "s64vector->vector", SCM_OBJ(&uvlib_s64vector_TOvector__STUB));
9760   SCM_DEFINE(module, "s64vector-fill!", SCM_OBJ(&uvlib_s64vector_fillX__STUB));
9761   SCM_DEFINE(module, "list->s64vector", SCM_OBJ(&uvlib_list_TOs64vector__STUB));
9762   SCM_DEFINE(module, "s64vector->list", SCM_OBJ(&uvlib_s64vector_TOlist__STUB));
9763   SCM_DEFINE(module, "s64vector-copy!", SCM_OBJ(&uvlib_s64vector_copyX__STUB));
9764   SCM_DEFINE(module, "s64vector-copy", SCM_OBJ(&uvlib_s64vector_copy__STUB));
9765   SCM_DEFINE(module, "s64vector-set!", SCM_OBJ(&uvlib_s64vector_setX__STUB));
9766   SCM_DEFINE(module, "s64vector-ref", SCM_OBJ(&uvlib_s64vector_ref__STUB));
9767   Scm_SetterSet(SCM_PROCEDURE(&uvlib_s64vector_ref__STUB), SCM_PROCEDURE(&uvlib_s64vector_setX__STUB), TRUE);
9768   SCM_DEFINE(module, "s64vector-length", SCM_OBJ(&uvlib_s64vector_length__STUB));
9769   SCM_DEFINE(module, "s64vector", SCM_OBJ(&uvlib_s64vector__STUB));
9770   SCM_DEFINE(module, "make-s64vector", SCM_OBJ(&uvlib_make_s64vector__STUB));
9771   SCM_DEFINE(module, "s64vector?", SCM_OBJ(&uvlib_s64vectorP__STUB));
9772   SCM_DEFINE(module, "vector->u32vector", SCM_OBJ(&uvlib_vector_TOu32vector__STUB));
9773   SCM_DEFINE(module, "u32vector->vector", SCM_OBJ(&uvlib_u32vector_TOvector__STUB));
9774   SCM_DEFINE(module, "u32vector-fill!", SCM_OBJ(&uvlib_u32vector_fillX__STUB));
9775   SCM_DEFINE(module, "list->u32vector", SCM_OBJ(&uvlib_list_TOu32vector__STUB));
9776   SCM_DEFINE(module, "u32vector->list", SCM_OBJ(&uvlib_u32vector_TOlist__STUB));
9777   SCM_DEFINE(module, "u32vector-copy!", SCM_OBJ(&uvlib_u32vector_copyX__STUB));
9778   SCM_DEFINE(module, "u32vector-copy", SCM_OBJ(&uvlib_u32vector_copy__STUB));
9779   SCM_DEFINE(module, "u32vector-set!", SCM_OBJ(&uvlib_u32vector_setX__STUB));
9780   SCM_DEFINE(module, "u32vector-ref", SCM_OBJ(&uvlib_u32vector_ref__STUB));
9781   Scm_SetterSet(SCM_PROCEDURE(&uvlib_u32vector_ref__STUB), SCM_PROCEDURE(&uvlib_u32vector_setX__STUB), TRUE);
9782   SCM_DEFINE(module, "u32vector-length", SCM_OBJ(&uvlib_u32vector_length__STUB));
9783   SCM_DEFINE(module, "u32vector", SCM_OBJ(&uvlib_u32vector__STUB));
9784   SCM_DEFINE(module, "make-u32vector", SCM_OBJ(&uvlib_make_u32vector__STUB));
9785   SCM_DEFINE(module, "u32vector?", SCM_OBJ(&uvlib_u32vectorP__STUB));
9786   SCM_DEFINE(module, "vector->s32vector", SCM_OBJ(&uvlib_vector_TOs32vector__STUB));
9787   SCM_DEFINE(module, "s32vector->vector", SCM_OBJ(&uvlib_s32vector_TOvector__STUB));
9788   SCM_DEFINE(module, "s32vector-fill!", SCM_OBJ(&uvlib_s32vector_fillX__STUB));
9789   SCM_DEFINE(module, "list->s32vector", SCM_OBJ(&uvlib_list_TOs32vector__STUB));
9790   SCM_DEFINE(module, "s32vector->list", SCM_OBJ(&uvlib_s32vector_TOlist__STUB));
9791   SCM_DEFINE(module, "s32vector-copy!", SCM_OBJ(&uvlib_s32vector_copyX__STUB));
9792   SCM_DEFINE(module, "s32vector-copy", SCM_OBJ(&uvlib_s32vector_copy__STUB));
9793   SCM_DEFINE(module, "s32vector-set!", SCM_OBJ(&uvlib_s32vector_setX__STUB));
9794   SCM_DEFINE(module, "s32vector-ref", SCM_OBJ(&uvlib_s32vector_ref__STUB));
9795   Scm_SetterSet(SCM_PROCEDURE(&uvlib_s32vector_ref__STUB), SCM_PROCEDURE(&uvlib_s32vector_setX__STUB), TRUE);
9796   SCM_DEFINE(module, "s32vector-length", SCM_OBJ(&uvlib_s32vector_length__STUB));
9797   SCM_DEFINE(module, "s32vector", SCM_OBJ(&uvlib_s32vector__STUB));
9798   SCM_DEFINE(module, "make-s32vector", SCM_OBJ(&uvlib_make_s32vector__STUB));
9799   SCM_DEFINE(module, "s32vector?", SCM_OBJ(&uvlib_s32vectorP__STUB));
9800   SCM_DEFINE(module, "vector->u16vector", SCM_OBJ(&uvlib_vector_TOu16vector__STUB));
9801   SCM_DEFINE(module, "u16vector->vector", SCM_OBJ(&uvlib_u16vector_TOvector__STUB));
9802   SCM_DEFINE(module, "u16vector-fill!", SCM_OBJ(&uvlib_u16vector_fillX__STUB));
9803   SCM_DEFINE(module, "list->u16vector", SCM_OBJ(&uvlib_list_TOu16vector__STUB));
9804   SCM_DEFINE(module, "u16vector->list", SCM_OBJ(&uvlib_u16vector_TOlist__STUB));
9805   SCM_DEFINE(module, "u16vector-copy!", SCM_OBJ(&uvlib_u16vector_copyX__STUB));
9806   SCM_DEFINE(module, "u16vector-copy", SCM_OBJ(&uvlib_u16vector_copy__STUB));
9807   SCM_DEFINE(module, "u16vector-set!", SCM_OBJ(&uvlib_u16vector_setX__STUB));
9808   SCM_DEFINE(module, "u16vector-ref", SCM_OBJ(&uvlib_u16vector_ref__STUB));
9809   Scm_SetterSet(SCM_PROCEDURE(&uvlib_u16vector_ref__STUB), SCM_PROCEDURE(&uvlib_u16vector_setX__STUB), TRUE);
9810   SCM_DEFINE(module, "u16vector-length", SCM_OBJ(&uvlib_u16vector_length__STUB));
9811   SCM_DEFINE(module, "u16vector", SCM_OBJ(&uvlib_u16vector__STUB));
9812   SCM_DEFINE(module, "make-u16vector", SCM_OBJ(&uvlib_make_u16vector__STUB));
9813   SCM_DEFINE(module, "u16vector?", SCM_OBJ(&uvlib_u16vectorP__STUB));
9814   SCM_DEFINE(module, "vector->s16vector", SCM_OBJ(&uvlib_vector_TOs16vector__STUB));
9815   SCM_DEFINE(module, "s16vector->vector", SCM_OBJ(&uvlib_s16vector_TOvector__STUB));
9816   SCM_DEFINE(module, "s16vector-fill!", SCM_OBJ(&uvlib_s16vector_fillX__STUB));
9817   SCM_DEFINE(module, "list->s16vector", SCM_OBJ(&uvlib_list_TOs16vector__STUB));
9818   SCM_DEFINE(module, "s16vector->list", SCM_OBJ(&uvlib_s16vector_TOlist__STUB));
9819   SCM_DEFINE(module, "s16vector-copy!", SCM_OBJ(&uvlib_s16vector_copyX__STUB));
9820   SCM_DEFINE(module, "s16vector-copy", SCM_OBJ(&uvlib_s16vector_copy__STUB));
9821   SCM_DEFINE(module, "s16vector-set!", SCM_OBJ(&uvlib_s16vector_setX__STUB));
9822   SCM_DEFINE(module, "s16vector-ref", SCM_OBJ(&uvlib_s16vector_ref__STUB));
9823   Scm_SetterSet(SCM_PROCEDURE(&uvlib_s16vector_ref__STUB), SCM_PROCEDURE(&uvlib_s16vector_setX__STUB), TRUE);
9824   SCM_DEFINE(module, "s16vector-length", SCM_OBJ(&uvlib_s16vector_length__STUB));
9825   SCM_DEFINE(module, "s16vector", SCM_OBJ(&uvlib_s16vector__STUB));
9826   SCM_DEFINE(module, "make-s16vector", SCM_OBJ(&uvlib_make_s16vector__STUB));
9827   SCM_DEFINE(module, "s16vector?", SCM_OBJ(&uvlib_s16vectorP__STUB));
9828   SCM_DEFINE(module, "vector->u8vector", SCM_OBJ(&uvlib_vector_TOu8vector__STUB));
9829   SCM_DEFINE(module, "u8vector->vector", SCM_OBJ(&uvlib_u8vector_TOvector__STUB));
9830   SCM_DEFINE(module, "u8vector-fill!", SCM_OBJ(&uvlib_u8vector_fillX__STUB));
9831   SCM_DEFINE(module, "list->u8vector", SCM_OBJ(&uvlib_list_TOu8vector__STUB));
9832   SCM_DEFINE(module, "u8vector->list", SCM_OBJ(&uvlib_u8vector_TOlist__STUB));
9833   SCM_DEFINE(module, "u8vector-copy!", SCM_OBJ(&uvlib_u8vector_copyX__STUB));
9834   SCM_DEFINE(module, "u8vector-copy", SCM_OBJ(&uvlib_u8vector_copy__STUB));
9835   SCM_DEFINE(module, "u8vector-set!", SCM_OBJ(&uvlib_u8vector_setX__STUB));
9836   SCM_DEFINE(module, "u8vector-ref", SCM_OBJ(&uvlib_u8vector_ref__STUB));
9837   Scm_SetterSet(SCM_PROCEDURE(&uvlib_u8vector_ref__STUB), SCM_PROCEDURE(&uvlib_u8vector_setX__STUB), TRUE);
9838   SCM_DEFINE(module, "u8vector-length", SCM_OBJ(&uvlib_u8vector_length__STUB));
9839   SCM_DEFINE(module, "u8vector", SCM_OBJ(&uvlib_u8vector__STUB));
9840   SCM_DEFINE(module, "make-u8vector", SCM_OBJ(&uvlib_make_u8vector__STUB));
9841   SCM_DEFINE(module, "u8vector?", SCM_OBJ(&uvlib_u8vectorP__STUB));
9842   SCM_DEFINE(module, "vector->s8vector", SCM_OBJ(&uvlib_vector_TOs8vector__STUB));
9843   SCM_DEFINE(module, "s8vector->vector", SCM_OBJ(&uvlib_s8vector_TOvector__STUB));
9844   SCM_DEFINE(module, "s8vector-fill!", SCM_OBJ(&uvlib_s8vector_fillX__STUB));
9845   SCM_DEFINE(module, "list->s8vector", SCM_OBJ(&uvlib_list_TOs8vector__STUB));
9846   SCM_DEFINE(module, "s8vector->list", SCM_OBJ(&uvlib_s8vector_TOlist__STUB));
9847   SCM_DEFINE(module, "s8vector-copy!", SCM_OBJ(&uvlib_s8vector_copyX__STUB));
9848   SCM_DEFINE(module, "s8vector-copy", SCM_OBJ(&uvlib_s8vector_copy__STUB));
9849   SCM_DEFINE(module, "s8vector-set!", SCM_OBJ(&uvlib_s8vector_setX__STUB));
9850   SCM_DEFINE(module, "s8vector-ref", SCM_OBJ(&uvlib_s8vector_ref__STUB));
9851   Scm_SetterSet(SCM_PROCEDURE(&uvlib_s8vector_ref__STUB), SCM_PROCEDURE(&uvlib_s8vector_setX__STUB), TRUE);
9852   SCM_DEFINE(module, "s8vector-length", SCM_OBJ(&uvlib_s8vector_length__STUB));
9853   SCM_DEFINE(module, "s8vector", SCM_OBJ(&uvlib_s8vector__STUB));
9854   SCM_DEFINE(module, "make-s8vector", SCM_OBJ(&uvlib_make_s8vector__STUB));
9855   SCM_DEFINE(module, "s8vector?", SCM_OBJ(&uvlib_s8vectorP__STUB));
9856   sym_low = Scm_Intern(&sym_low__NAME);
9857   sym_high = Scm_Intern(&sym_high__NAME);
9858   sym_both = Scm_Intern(&sym_both__NAME);
9859 }

/* [<][>][^][v][top][bottom][index][help] */