root/src/stdlib.c

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

DEFINITIONS

This source file includes following definitions.
  1. stdlib_eqvP
  2. stdlib_eqP
  3. stdlib_equalP
  4. stdlib_numberP
  5. stdlib_complexP
  6. stdlib_realP
  7. stdlib_rationalP
  8. stdlib_integerP
  9. stdlib_exactP
  10. stdlib_inexactP
  11. stdlib__3d
  12. stdlib__LT
  13. stdlib__LT_3d
  14. stdlib__GT
  15. stdlib__GT_3d
  16. stdlib_zeroP
  17. stdlib_positiveP
  18. stdlib_negativeP
  19. stdlib_oddP
  20. stdlib_evenP
  21. stdlib_max
  22. stdlib_min
  23. stdlib__2b
  24. stdlib__2a
  25. stdlib__
  26. stdlib__2f
  27. stdlib_abs
  28. stdlib_quotient
  29. stdlib_remainder
  30. stdlib_modulo
  31. stdlib_floor
  32. stdlib_ceiling
  33. stdlib_truncate
  34. stdlib_round
  35. stdlib__25exp
  36. stdlib__25log
  37. stdlib__25sin
  38. stdlib__25cos
  39. stdlib__25tan
  40. stdlib__25asin
  41. stdlib__25acos
  42. stdlib__25atan
  43. stdlib__25sinh
  44. stdlib__25cosh
  45. stdlib__25tanh
  46. stdlib__25sqrt
  47. stdlib__25expt
  48. stdlib_make_rectangular
  49. stdlib_make_polar
  50. stdlib__25complex_TOreal_2fimag
  51. stdlib_real_part
  52. stdlib_imag_part
  53. stdlib_magnitude
  54. stdlib_angle
  55. stdlib_exact_TOinexact
  56. stdlib_inexact_TOexact
  57. stdlib_number_TOstring
  58. stdlib_string_TOnumber
  59. stdlib_not
  60. stdlib_booleanP
  61. stdlib_pairP
  62. stdlib_cons
  63. stdlib_car
  64. stdlib_cdr
  65. stdlib_set_carX
  66. stdlib_set_cdrX
  67. stdlib_caar_SETTER
  68. stdlib_caar
  69. stdlib_cadr_SETTER
  70. stdlib_cadr
  71. stdlib_cdar_SETTER
  72. stdlib_cdar
  73. stdlib_cddr_SETTER
  74. stdlib_cddr
  75. stdlib_nullP
  76. stdlib_listP
  77. stdlib_list
  78. stdlib_length
  79. stdlib_length_2b
  80. stdlib_append
  81. stdlib_reverse
  82. stdlib_list_tail
  83. stdlib_list_ref
  84. stdlib_memq
  85. stdlib_memv
  86. stdlib_member
  87. stdlib_assq
  88. stdlib_assv
  89. stdlib_assoc
  90. stdlib_symbolP
  91. stdlib_symbol_TOstring
  92. stdlib_string_TOsymbol
  93. stdlib_charP
  94. stdlib_char_3dP
  95. stdlib_char_LTP
  96. stdlib_char_GTP
  97. stdlib_char_LT_3dP
  98. stdlib_char_GT_3dP
  99. stdlib_char_ci_3dP
  100. stdlib_char_ci_LTP
  101. stdlib_char_ci_LT_3dP
  102. stdlib_char_ci_GTP
  103. stdlib_char_ci_GT_3dP
  104. stdlib_char_alphabeticP
  105. stdlib_char_numericP
  106. stdlib_char_whitespaceP
  107. stdlib_char_upper_caseP
  108. stdlib_char_lower_caseP
  109. stdlib_char_TOinteger
  110. stdlib_integer_TOchar
  111. stdlib_char_upcase
  112. stdlib_char_downcase
  113. stdlib_stringP
  114. stdlib_make_string
  115. stdlib_string
  116. stdlib_string_length
  117. stdlib_string_ref
  118. stdlib_string_setX
  119. stdlib_string_3dP
  120. stdlib_string_LTP
  121. stdlib_string_LT_3dP
  122. stdlib_string_GTP
  123. stdlib_string_GT_3dP
  124. stdlib_string_ci_3dP
  125. stdlib_string_ci_LTP
  126. stdlib_string_ci_LT_3dP
  127. stdlib_string_ci_GTP
  128. stdlib_string_ci_GT_3dP
  129. stdlib_substring
  130. stdlib_string_append
  131. stdlib_string_TOlist
  132. stdlib_list_TOstring
  133. stdlib_string_copy
  134. stdlib_string_fillX
  135. stdlib_vectorP
  136. stdlib_make_vector
  137. stdlib_vector
  138. stdlib_vector_length
  139. stdlib_vector_ref
  140. stdlib_vector_setX
  141. stdlib_vector_TOlist
  142. stdlib_list_TOvector
  143. stdlib_vector_fillX
  144. stdlib_procedureP
  145. stdlib_apply
  146. stdlib_map
  147. stdlib_for_each
  148. stdlib_force
  149. stdlib_call_with_current_continuation
  150. stdlib_values
  151. stdlib_dynamic_wind
  152. stdlib_eval
  153. stdlib_null_environment
  154. stdlib_scheme_report_environment
  155. stdlib_interaction_environment
  156. stdlib_input_portP
  157. stdlib_output_portP
  158. stdlib_portP
  159. stdlib_current_input_port
  160. stdlib_current_output_port
  161. stdlib_close_input_port
  162. stdlib_close_output_port
  163. stdlib_read
  164. stdlib_read_char
  165. stdlib_peek_char
  166. stdlib_eof_objectP
  167. stdlib_char_readyP
  168. stdlib_write
  169. stdlib_display
  170. stdlib_newline
  171. stdlib_write_char
  172. Scm_Init_stdlib 
   1 /* Generated by genstub.  Do not edit. */
   2 #define LIBGAUCHE_BODY
   3 #include <gauche.h>
   4 #if defined(__CYGWIN__) || defined(__MINGW32__)
   5 #define SCM_CGEN_CONST /*empty*/
   6 #else
   7 #define SCM_CGEN_CONST const
   8 #endif
   9 
  10 #include <gauche/vminsn.h>
  11 #include <stdlib.h>
  12 #include <ctype.h>
  13 #include <math.h>
  14 
  15 #ifndef M_PI
  16 #define M_PI 3.1415926535897932384
  17 #endif
  18 
  19 static ScmObj stdlib_eqvP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
  20 {
  21   ScmObj obj1_scm;
  22   ScmObj obj1;
  23   ScmObj obj2_scm;
  24   ScmObj obj2;
  25   SCM_ENTER_SUBR("eqv?");
  26   obj1_scm = SCM_ARGREF(0);
  27   obj1 = (obj1_scm);
  28   obj2_scm = SCM_ARGREF(1);
  29   obj2 = (obj2_scm);
  30   {
  31 {
  32 int SCM_RESULT;
  33 SCM_RESULT = Scm_EqvP(obj1, obj2);
  34 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
  35 }
  36   }
  37 }
  38 
  39 static SCM_DEFINE_STRING_CONST(stdlib_eqvP__NAME, "eqv?", 4, 4);
  40 static SCM_DEFINE_SUBR(stdlib_eqvP__STUB, 2, 0, SCM_OBJ(&stdlib_eqvP__NAME), stdlib_eqvP, SCM_MAKE_INT(SCM_VM_EQV), NULL);
  41 
  42 static ScmObj stdlib_eqP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
  43 {
  44   ScmObj obj1_scm;
  45   ScmObj obj1;
  46   ScmObj obj2_scm;
  47   ScmObj obj2;
  48   SCM_ENTER_SUBR("eq?");
  49   obj1_scm = SCM_ARGREF(0);
  50   obj1 = (obj1_scm);
  51   obj2_scm = SCM_ARGREF(1);
  52   obj2 = (obj2_scm);
  53   {
  54 {
  55 int SCM_RESULT;
  56 SCM_RESULT = SCM_EQ(obj1, obj2);
  57 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
  58 }
  59   }
  60 }
  61 
  62 static SCM_DEFINE_STRING_CONST(stdlib_eqP__NAME, "eq?", 3, 3);
  63 static SCM_DEFINE_SUBR(stdlib_eqP__STUB, 2, 0, SCM_OBJ(&stdlib_eqP__NAME), stdlib_eqP, SCM_MAKE_INT(SCM_VM_EQ), NULL);
  64 
  65 static ScmObj stdlib_equalP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
  66 {
  67   ScmObj obj1_scm;
  68   ScmObj obj1;
  69   ScmObj obj2_scm;
  70   ScmObj obj2;
  71   SCM_ENTER_SUBR("equal?");
  72   obj1_scm = SCM_ARGREF(0);
  73   obj1 = (obj1_scm);
  74   obj2_scm = SCM_ARGREF(1);
  75   obj2 = (obj2_scm);
  76   {
  77 {
  78 int SCM_RESULT;
  79 SCM_RESULT = Scm_EqualP(obj1, obj2);
  80 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
  81 }
  82   }
  83 }
  84 
  85 static SCM_DEFINE_STRING_CONST(stdlib_equalP__NAME, "equal?", 6, 6);
  86 static SCM_DEFINE_SUBR(stdlib_equalP__STUB, 2, 0, SCM_OBJ(&stdlib_equalP__NAME), stdlib_equalP, NULL, NULL);
  87 
  88 static ScmObj stdlib_numberP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
  89 {
  90   ScmObj obj_scm;
  91   ScmObj obj;
  92   SCM_ENTER_SUBR("number?");
  93   obj_scm = SCM_ARGREF(0);
  94   obj = (obj_scm);
  95   {
  96 {
  97 int SCM_RESULT;
  98 SCM_RESULT = SCM_NUMBERP(obj);
  99 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
 100 }
 101   }
 102 }
 103 
 104 static SCM_DEFINE_STRING_CONST(stdlib_numberP__NAME, "number?", 7, 7);
 105 static SCM_DEFINE_SUBR(stdlib_numberP__STUB, 1, 0, SCM_OBJ(&stdlib_numberP__NAME), stdlib_numberP, NULL, NULL);
 106 
 107 static ScmObj stdlib_complexP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 108 {
 109   ScmObj obj_scm;
 110   ScmObj obj;
 111   SCM_ENTER_SUBR("complex?");
 112   obj_scm = SCM_ARGREF(0);
 113   obj = (obj_scm);
 114   {
 115 {
 116 int SCM_RESULT;
 117 SCM_RESULT = SCM_NUMBERP(obj);
 118 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
 119 }
 120   }
 121 }
 122 
 123 static SCM_DEFINE_STRING_CONST(stdlib_complexP__NAME, "complex?", 8, 8);
 124 static SCM_DEFINE_SUBR(stdlib_complexP__STUB, 1, 0, SCM_OBJ(&stdlib_complexP__NAME), stdlib_complexP, NULL, NULL);
 125 
 126 static ScmObj stdlib_realP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 127 {
 128   ScmObj obj_scm;
 129   ScmObj obj;
 130   SCM_ENTER_SUBR("real?");
 131   obj_scm = SCM_ARGREF(0);
 132   obj = (obj_scm);
 133   {
 134 {
 135 int SCM_RESULT;
 136 SCM_RESULT = SCM_REALP(obj);
 137 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
 138 }
 139   }
 140 }
 141 
 142 static SCM_DEFINE_STRING_CONST(stdlib_realP__NAME, "real?", 5, 5);
 143 static SCM_DEFINE_SUBR(stdlib_realP__STUB, 1, 0, SCM_OBJ(&stdlib_realP__NAME), stdlib_realP, NULL, NULL);
 144 
 145 static ScmObj stdlib_rationalP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 146 {
 147   ScmObj obj_scm;
 148   ScmObj obj;
 149   SCM_ENTER_SUBR("rational?");
 150   obj_scm = SCM_ARGREF(0);
 151   obj = (obj_scm);
 152   {
 153 {
 154 int SCM_RESULT;
 155 SCM_RESULT = SCM_REALP(obj);
 156 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
 157 }
 158   }
 159 }
 160 
 161 static SCM_DEFINE_STRING_CONST(stdlib_rationalP__NAME, "rational?", 9, 9);
 162 static SCM_DEFINE_SUBR(stdlib_rationalP__STUB, 1, 0, SCM_OBJ(&stdlib_rationalP__NAME), stdlib_rationalP, NULL, NULL);
 163 
 164 static ScmObj stdlib_integerP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 165 {
 166   ScmObj obj_scm;
 167   ScmObj obj;
 168   SCM_ENTER_SUBR("integer?");
 169   obj_scm = SCM_ARGREF(0);
 170   obj = (obj_scm);
 171   {
 172 {
 173 int SCM_RESULT;
 174 if (!SCM_NUMBERP(obj)) SCM_RESULT = FALSE;
 175 else SCM_RESULT = Scm_IntegerP(obj);
 176 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
 177 }
 178   }
 179 }
 180 
 181 static SCM_DEFINE_STRING_CONST(stdlib_integerP__NAME, "integer?", 8, 8);
 182 static SCM_DEFINE_SUBR(stdlib_integerP__STUB, 1, 0, SCM_OBJ(&stdlib_integerP__NAME), stdlib_integerP, NULL, NULL);
 183 
 184 static ScmObj stdlib_exactP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 185 {
 186   ScmObj obj_scm;
 187   ScmObj obj;
 188   SCM_ENTER_SUBR("exact?");
 189   obj_scm = SCM_ARGREF(0);
 190   obj = (obj_scm);
 191   {
 192 {
 193 int SCM_RESULT;
 194 SCM_RESULT = SCM_EXACTP(obj);
 195 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
 196 }
 197   }
 198 }
 199 
 200 static SCM_DEFINE_STRING_CONST(stdlib_exactP__NAME, "exact?", 6, 6);
 201 static SCM_DEFINE_SUBR(stdlib_exactP__STUB, 1, 0, SCM_OBJ(&stdlib_exactP__NAME), stdlib_exactP, NULL, NULL);
 202 
 203 static ScmObj stdlib_inexactP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 204 {
 205   ScmObj obj_scm;
 206   ScmObj obj;
 207   SCM_ENTER_SUBR("inexact?");
 208   obj_scm = SCM_ARGREF(0);
 209   obj = (obj_scm);
 210   {
 211 {
 212 int SCM_RESULT;
 213 SCM_RESULT = SCM_INEXACTP(obj);
 214 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
 215 }
 216   }
 217 }
 218 
 219 static SCM_DEFINE_STRING_CONST(stdlib_inexactP__NAME, "inexact?", 8, 8);
 220 static SCM_DEFINE_SUBR(stdlib_inexactP__STUB, 1, 0, SCM_OBJ(&stdlib_inexactP__NAME), stdlib_inexactP, NULL, NULL);
 221 
 222 static ScmObj stdlib__3d(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 223 {
 224   ScmObj arg0_scm;
 225   ScmObj arg0;
 226   ScmObj arg1_scm;
 227   ScmObj arg1;
 228   ScmObj args_scm;
 229   ScmObj args;
 230   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
 231   SCM_ENTER_SUBR("=");
 232   arg0_scm = SCM_ARGREF(0);
 233   arg0 = (arg0_scm);
 234   arg1_scm = SCM_ARGREF(1);
 235   arg1 = (arg1_scm);
 236   args_scm = SCM_OPTARGS;
 237   args = (args_scm);
 238   {
 239 for (;;) {
 240   if (!Scm_NumEq(arg0, arg1)) return SCM_FALSE;
 241   if (SCM_NULLP(args)) return SCM_TRUE;
 242   arg1 = SCM_CAR(args); args = SCM_CDR(args);
 243 }
 244   }
 245 }
 246 
 247 static SCM_DEFINE_STRING_CONST(stdlib__3d__NAME, "=", 1, 1);
 248 static SCM_DEFINE_SUBR(stdlib__3d__STUB, 2, 1, SCM_OBJ(&stdlib__3d__NAME), stdlib__3d, NULL, NULL);
 249 
 250 static ScmObj stdlib__LT(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 251 {
 252   ScmObj arg0_scm;
 253   ScmObj arg0;
 254   ScmObj arg1_scm;
 255   ScmObj arg1;
 256   ScmObj args_scm;
 257   ScmObj args;
 258   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
 259   SCM_ENTER_SUBR("<");
 260   arg0_scm = SCM_ARGREF(0);
 261   arg0 = (arg0_scm);
 262   arg1_scm = SCM_ARGREF(1);
 263   arg1 = (arg1_scm);
 264   args_scm = SCM_OPTARGS;
 265   args = (args_scm);
 266   {
 267 for (;;) {
 268   if (Scm_NumCmp(arg0, arg1) >= 0) return SCM_FALSE;
 269   if (SCM_NULLP(args)) return SCM_TRUE;
 270   arg0 = arg1;  arg1 = SCM_CAR(args);  args = SCM_CDR(args);
 271 }
 272   }
 273 }
 274 
 275 static SCM_DEFINE_STRING_CONST(stdlib__LT__NAME, "<", 1, 1);
 276 static SCM_DEFINE_SUBR(stdlib__LT__STUB, 2, 1, SCM_OBJ(&stdlib__LT__NAME), stdlib__LT, NULL, NULL);
 277 
 278 static ScmObj stdlib__LT_3d(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 279 {
 280   ScmObj arg0_scm;
 281   ScmObj arg0;
 282   ScmObj arg1_scm;
 283   ScmObj arg1;
 284   ScmObj args_scm;
 285   ScmObj args;
 286   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
 287   SCM_ENTER_SUBR("<=");
 288   arg0_scm = SCM_ARGREF(0);
 289   arg0 = (arg0_scm);
 290   arg1_scm = SCM_ARGREF(1);
 291   arg1 = (arg1_scm);
 292   args_scm = SCM_OPTARGS;
 293   args = (args_scm);
 294   {
 295 for (;;) {
 296   if (Scm_NumCmp(arg0, arg1) > 0) return SCM_FALSE;
 297   if (SCM_NULLP(args)) return SCM_TRUE;
 298   arg0 = arg1;  arg1 = SCM_CAR(args);  args = SCM_CDR(args);
 299 }
 300   }
 301 }
 302 
 303 static SCM_DEFINE_STRING_CONST(stdlib__LT_3d__NAME, "<=", 2, 2);
 304 static SCM_DEFINE_SUBR(stdlib__LT_3d__STUB, 2, 1, SCM_OBJ(&stdlib__LT_3d__NAME), stdlib__LT_3d, NULL, NULL);
 305 
 306 static ScmObj stdlib__GT(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 307 {
 308   ScmObj arg0_scm;
 309   ScmObj arg0;
 310   ScmObj arg1_scm;
 311   ScmObj arg1;
 312   ScmObj args_scm;
 313   ScmObj args;
 314   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
 315   SCM_ENTER_SUBR(">");
 316   arg0_scm = SCM_ARGREF(0);
 317   arg0 = (arg0_scm);
 318   arg1_scm = SCM_ARGREF(1);
 319   arg1 = (arg1_scm);
 320   args_scm = SCM_OPTARGS;
 321   args = (args_scm);
 322   {
 323 for (;;) {
 324   if (Scm_NumCmp(arg0, arg1) <= 0) return SCM_FALSE;
 325   if (SCM_NULLP(args)) return SCM_TRUE;
 326   arg0 = arg1;  arg1 = SCM_CAR(args);  args = SCM_CDR(args);
 327 }
 328   }
 329 }
 330 
 331 static SCM_DEFINE_STRING_CONST(stdlib__GT__NAME, ">", 1, 1);
 332 static SCM_DEFINE_SUBR(stdlib__GT__STUB, 2, 1, SCM_OBJ(&stdlib__GT__NAME), stdlib__GT, NULL, NULL);
 333 
 334 static ScmObj stdlib__GT_3d(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 335 {
 336   ScmObj arg0_scm;
 337   ScmObj arg0;
 338   ScmObj arg1_scm;
 339   ScmObj arg1;
 340   ScmObj args_scm;
 341   ScmObj args;
 342   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
 343   SCM_ENTER_SUBR(">=");
 344   arg0_scm = SCM_ARGREF(0);
 345   arg0 = (arg0_scm);
 346   arg1_scm = SCM_ARGREF(1);
 347   arg1 = (arg1_scm);
 348   args_scm = SCM_OPTARGS;
 349   args = (args_scm);
 350   {
 351 for (;;) {
 352   if (Scm_NumCmp(arg0, arg1) < 0) return SCM_FALSE;
 353   if (SCM_NULLP(args)) return SCM_TRUE;
 354   arg0 = arg1;  arg1 = SCM_CAR(args);  args = SCM_CDR(args);
 355 }
 356   }
 357 }
 358 
 359 static SCM_DEFINE_STRING_CONST(stdlib__GT_3d__NAME, ">=", 2, 2);
 360 static SCM_DEFINE_SUBR(stdlib__GT_3d__STUB, 2, 1, SCM_OBJ(&stdlib__GT_3d__NAME), stdlib__GT_3d, NULL, NULL);
 361 
 362 static ScmObj stdlib_zeroP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 363 {
 364   ScmObj obj_scm;
 365   ScmObj obj;
 366   SCM_ENTER_SUBR("zero?");
 367   obj_scm = SCM_ARGREF(0);
 368   obj = (obj_scm);
 369   {
 370 {
 371 int SCM_RESULT;
 372 if (SCM_COMPLEXP(obj)) {
 373   SCM_RESULT = (SCM_COMPLEX_REAL(obj) == 0.0
 374                 && SCM_COMPLEX_IMAG(obj) == 0.0);
 375 } else {
 376   SCM_RESULT = (Scm_Sign(obj) == 0);
 377 }
 378 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
 379 }
 380   }
 381 }
 382 
 383 static SCM_DEFINE_STRING_CONST(stdlib_zeroP__NAME, "zero?", 5, 5);
 384 static SCM_DEFINE_SUBR(stdlib_zeroP__STUB, 1, 0, SCM_OBJ(&stdlib_zeroP__NAME), stdlib_zeroP, NULL, NULL);
 385 
 386 static ScmObj stdlib_positiveP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 387 {
 388   ScmObj obj_scm;
 389   ScmObj obj;
 390   SCM_ENTER_SUBR("positive?");
 391   obj_scm = SCM_ARGREF(0);
 392   obj = (obj_scm);
 393   {
 394 {
 395 int SCM_RESULT;
 396 SCM_RESULT = (Scm_Sign(obj) > 0);
 397 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
 398 }
 399   }
 400 }
 401 
 402 static SCM_DEFINE_STRING_CONST(stdlib_positiveP__NAME, "positive?", 9, 9);
 403 static SCM_DEFINE_SUBR(stdlib_positiveP__STUB, 1, 0, SCM_OBJ(&stdlib_positiveP__NAME), stdlib_positiveP, NULL, NULL);
 404 
 405 static ScmObj stdlib_negativeP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 406 {
 407   ScmObj obj_scm;
 408   ScmObj obj;
 409   SCM_ENTER_SUBR("negative?");
 410   obj_scm = SCM_ARGREF(0);
 411   obj = (obj_scm);
 412   {
 413 {
 414 int SCM_RESULT;
 415 SCM_RESULT = (Scm_Sign(obj) < 0);
 416 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
 417 }
 418   }
 419 }
 420 
 421 static SCM_DEFINE_STRING_CONST(stdlib_negativeP__NAME, "negative?", 9, 9);
 422 static SCM_DEFINE_SUBR(stdlib_negativeP__STUB, 1, 0, SCM_OBJ(&stdlib_negativeP__NAME), stdlib_negativeP, NULL, NULL);
 423 
 424 static ScmObj stdlib_oddP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 425 {
 426   ScmObj obj_scm;
 427   ScmObj obj;
 428   SCM_ENTER_SUBR("odd?");
 429   obj_scm = SCM_ARGREF(0);
 430   obj = (obj_scm);
 431   {
 432 {
 433 int SCM_RESULT;
 434 SCM_RESULT = Scm_OddP(obj);
 435 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
 436 }
 437   }
 438 }
 439 
 440 static SCM_DEFINE_STRING_CONST(stdlib_oddP__NAME, "odd?", 4, 4);
 441 static SCM_DEFINE_SUBR(stdlib_oddP__STUB, 1, 0, SCM_OBJ(&stdlib_oddP__NAME), stdlib_oddP, NULL, NULL);
 442 
 443 static ScmObj stdlib_evenP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 444 {
 445   ScmObj obj_scm;
 446   ScmObj obj;
 447   SCM_ENTER_SUBR("even?");
 448   obj_scm = SCM_ARGREF(0);
 449   obj = (obj_scm);
 450   {
 451 {
 452 int SCM_RESULT;
 453 SCM_RESULT = !Scm_OddP(obj);
 454 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
 455 }
 456   }
 457 }
 458 
 459 static SCM_DEFINE_STRING_CONST(stdlib_evenP__NAME, "even?", 5, 5);
 460 static SCM_DEFINE_SUBR(stdlib_evenP__STUB, 1, 0, SCM_OBJ(&stdlib_evenP__NAME), stdlib_evenP, NULL, NULL);
 461 
 462 static ScmObj stdlib_max(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 463 {
 464   ScmObj arg0_scm;
 465   ScmObj arg0;
 466   ScmObj args_scm;
 467   ScmObj args;
 468   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
 469   SCM_ENTER_SUBR("max");
 470   arg0_scm = SCM_ARGREF(0);
 471   arg0 = (arg0_scm);
 472   args_scm = SCM_OPTARGS;
 473   args = (args_scm);
 474   {
 475 {
 476 ScmObj SCM_RESULT;
 477 Scm_MinMax(arg0, args, NULL, &SCM_RESULT);
 478 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
 479 }
 480   }
 481 }
 482 
 483 static SCM_DEFINE_STRING_CONST(stdlib_max__NAME, "max", 3, 3);
 484 static SCM_DEFINE_SUBR(stdlib_max__STUB, 1, 1, SCM_OBJ(&stdlib_max__NAME), stdlib_max, NULL, NULL);
 485 
 486 static ScmObj stdlib_min(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 487 {
 488   ScmObj arg0_scm;
 489   ScmObj arg0;
 490   ScmObj args_scm;
 491   ScmObj args;
 492   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
 493   SCM_ENTER_SUBR("min");
 494   arg0_scm = SCM_ARGREF(0);
 495   arg0 = (arg0_scm);
 496   args_scm = SCM_OPTARGS;
 497   args = (args_scm);
 498   {
 499 {
 500 ScmObj SCM_RESULT;
 501 Scm_MinMax(arg0, args, &SCM_RESULT, NULL);
 502 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
 503 }
 504   }
 505 }
 506 
 507 static SCM_DEFINE_STRING_CONST(stdlib_min__NAME, "min", 3, 3);
 508 static SCM_DEFINE_SUBR(stdlib_min__STUB, 1, 1, SCM_OBJ(&stdlib_min__NAME), stdlib_min, NULL, NULL);
 509 
 510 static ScmObj stdlib__2b(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 511 {
 512   ScmObj args_scm;
 513   ScmObj args;
 514   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
 515   SCM_ENTER_SUBR("+");
 516   args_scm = SCM_OPTARGS;
 517   args = (args_scm);
 518   {
 519 if (SCM_NULLP(args)) SCM_RETURN(SCM_MAKE_INT(0));
 520 if (!SCM_PAIRP(SCM_CDR(args))) {
 521   if (!SCM_NUMBERP(SCM_CAR(args)))
 522      Scm_Error("number required, but got %S", SCM_CAR(args));
 523   SCM_RETURN(SCM_CAR(args));
 524 } else {
 525   SCM_RETURN(Scm_Add(SCM_CAR(args), SCM_CADR(args), SCM_CDDR(args)));
 526 }
 527   }
 528 }
 529 
 530 static SCM_DEFINE_STRING_CONST(stdlib__2b__NAME, "+", 1, 1);
 531 static SCM_DEFINE_SUBR(stdlib__2b__STUB, 0, 1, SCM_OBJ(&stdlib__2b__NAME), stdlib__2b, NULL, NULL);
 532 
 533 static ScmObj stdlib__2a(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 534 {
 535   ScmObj args_scm;
 536   ScmObj args;
 537   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
 538   SCM_ENTER_SUBR("*");
 539   args_scm = SCM_OPTARGS;
 540   args = (args_scm);
 541   {
 542 if (!SCM_PAIRP(args)) return SCM_MAKE_INT(1);
 543 if (!SCM_PAIRP(SCM_CDR(args))) {
 544   if (!SCM_NUMBERP(SCM_CAR(args)))
 545      Scm_Error("number required, but got %S", SCM_CAR(args));
 546   return SCM_CAR(args);
 547 }
 548 SCM_RETURN(Scm_Multiply(SCM_CAR(args), SCM_CADR(args), SCM_CDDR(args)));
 549   }
 550 }
 551 
 552 static SCM_DEFINE_STRING_CONST(stdlib__2a__NAME, "*", 1, 1);
 553 static SCM_DEFINE_SUBR(stdlib__2a__STUB, 0, 1, SCM_OBJ(&stdlib__2a__NAME), stdlib__2a, NULL, NULL);
 554 
 555 static ScmObj stdlib__(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 556 {
 557   ScmObj arg1_scm;
 558   ScmObj arg1;
 559   ScmObj args_scm;
 560   ScmObj args;
 561   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
 562   SCM_ENTER_SUBR("-");
 563   arg1_scm = SCM_ARGREF(0);
 564   arg1 = (arg1_scm);
 565   args_scm = SCM_OPTARGS;
 566   args = (args_scm);
 567   {
 568 {
 569 ScmObj SCM_RESULT;
 570 if (SCM_NULLP(args)) SCM_RESULT = Scm_Negate(arg1);
 571          else SCM_RESULT = Scm_Subtract(arg1, SCM_CAR(args), SCM_CDR(args));
 572 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
 573 }
 574   }
 575 }
 576 
 577 static SCM_DEFINE_STRING_CONST(stdlib____NAME, "-", 1, 1);
 578 static SCM_DEFINE_SUBR(stdlib____STUB, 1, 1, SCM_OBJ(&stdlib____NAME), stdlib__, NULL, NULL);
 579 
 580 static ScmObj stdlib__2f(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 581 {
 582   ScmObj arg1_scm;
 583   ScmObj arg1;
 584   ScmObj args_scm;
 585   ScmObj args;
 586   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
 587   SCM_ENTER_SUBR("/");
 588   arg1_scm = SCM_ARGREF(0);
 589   arg1 = (arg1_scm);
 590   args_scm = SCM_OPTARGS;
 591   args = (args_scm);
 592   {
 593 {
 594 ScmObj SCM_RESULT;
 595 if (SCM_NULLP(args)) SCM_RESULT = Scm_Reciprocal(arg1);
 596          else SCM_RESULT = Scm_Divide(arg1, SCM_CAR(args), SCM_CDR(args));
 597 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
 598 }
 599   }
 600 }
 601 
 602 static SCM_DEFINE_STRING_CONST(stdlib__2f__NAME, "/", 1, 1);
 603 static SCM_DEFINE_SUBR(stdlib__2f__STUB, 1, 1, SCM_OBJ(&stdlib__2f__NAME), stdlib__2f, NULL, NULL);
 604 
 605 static ScmObj stdlib_abs(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 606 {
 607   ScmObj obj_scm;
 608   ScmObj obj;
 609   SCM_ENTER_SUBR("abs");
 610   obj_scm = SCM_ARGREF(0);
 611   obj = (obj_scm);
 612   {
 613 {
 614 ScmObj SCM_RESULT;
 615 SCM_RESULT = Scm_Abs(obj);
 616 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
 617 }
 618   }
 619 }
 620 
 621 static SCM_DEFINE_STRING_CONST(stdlib_abs__NAME, "abs", 3, 3);
 622 static SCM_DEFINE_SUBR(stdlib_abs__STUB, 1, 0, SCM_OBJ(&stdlib_abs__NAME), stdlib_abs, NULL, NULL);
 623 
 624 static ScmObj stdlib_quotient(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 625 {
 626   ScmObj n1_scm;
 627   ScmObj n1;
 628   ScmObj n2_scm;
 629   ScmObj n2;
 630   SCM_ENTER_SUBR("quotient");
 631   n1_scm = SCM_ARGREF(0);
 632   n1 = (n1_scm);
 633   n2_scm = SCM_ARGREF(1);
 634   n2 = (n2_scm);
 635   {
 636 {
 637 ScmObj SCM_RESULT;
 638  SCM_RESULT = (Scm_Quotient(n1, n2, NULL));
 639 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
 640 }
 641   }
 642 }
 643 
 644 static SCM_DEFINE_STRING_CONST(stdlib_quotient__NAME, "quotient", 8, 8);
 645 static SCM_DEFINE_SUBR(stdlib_quotient__STUB, 2, 0, SCM_OBJ(&stdlib_quotient__NAME), stdlib_quotient, NULL, NULL);
 646 
 647 static ScmObj stdlib_remainder(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 648 {
 649   ScmObj n1_scm;
 650   ScmObj n1;
 651   ScmObj n2_scm;
 652   ScmObj n2;
 653   SCM_ENTER_SUBR("remainder");
 654   n1_scm = SCM_ARGREF(0);
 655   n1 = (n1_scm);
 656   n2_scm = SCM_ARGREF(1);
 657   n2 = (n2_scm);
 658   {
 659 {
 660 ScmObj SCM_RESULT;
 661  SCM_RESULT = (Scm_Modulo(n1, n2, TRUE));
 662 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
 663 }
 664   }
 665 }
 666 
 667 static SCM_DEFINE_STRING_CONST(stdlib_remainder__NAME, "remainder", 9, 9);
 668 static SCM_DEFINE_SUBR(stdlib_remainder__STUB, 2, 0, SCM_OBJ(&stdlib_remainder__NAME), stdlib_remainder, NULL, NULL);
 669 
 670 static ScmObj stdlib_modulo(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 671 {
 672   ScmObj n1_scm;
 673   ScmObj n1;
 674   ScmObj n2_scm;
 675   ScmObj n2;
 676   SCM_ENTER_SUBR("modulo");
 677   n1_scm = SCM_ARGREF(0);
 678   n1 = (n1_scm);
 679   n2_scm = SCM_ARGREF(1);
 680   n2 = (n2_scm);
 681   {
 682 {
 683 ScmObj SCM_RESULT;
 684  SCM_RESULT = (Scm_Modulo(n1, n2, FALSE));
 685 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
 686 }
 687   }
 688 }
 689 
 690 static SCM_DEFINE_STRING_CONST(stdlib_modulo__NAME, "modulo", 6, 6);
 691 static SCM_DEFINE_SUBR(stdlib_modulo__STUB, 2, 0, SCM_OBJ(&stdlib_modulo__NAME), stdlib_modulo, NULL, NULL);
 692 
 693 static ScmObj stdlib_floor(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 694 {
 695   ScmObj v_scm;
 696   ScmObj v;
 697   SCM_ENTER_SUBR("floor");
 698   v_scm = SCM_ARGREF(0);
 699   v = (v_scm);
 700   {
 701 {
 702 ScmObj SCM_RESULT;
 703  SCM_RESULT = (Scm_Round(v, SCM_ROUND_FLOOR));
 704 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
 705 }
 706   }
 707 }
 708 
 709 static SCM_DEFINE_STRING_CONST(stdlib_floor__NAME, "floor", 5, 5);
 710 static SCM_DEFINE_SUBR(stdlib_floor__STUB, 1, 0, SCM_OBJ(&stdlib_floor__NAME), stdlib_floor, NULL, NULL);
 711 
 712 static ScmObj stdlib_ceiling(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 713 {
 714   ScmObj v_scm;
 715   ScmObj v;
 716   SCM_ENTER_SUBR("ceiling");
 717   v_scm = SCM_ARGREF(0);
 718   v = (v_scm);
 719   {
 720 {
 721 ScmObj SCM_RESULT;
 722  SCM_RESULT = (Scm_Round(v, SCM_ROUND_CEIL));
 723 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
 724 }
 725   }
 726 }
 727 
 728 static SCM_DEFINE_STRING_CONST(stdlib_ceiling__NAME, "ceiling", 7, 7);
 729 static SCM_DEFINE_SUBR(stdlib_ceiling__STUB, 1, 0, SCM_OBJ(&stdlib_ceiling__NAME), stdlib_ceiling, NULL, NULL);
 730 
 731 static ScmObj stdlib_truncate(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 732 {
 733   ScmObj v_scm;
 734   ScmObj v;
 735   SCM_ENTER_SUBR("truncate");
 736   v_scm = SCM_ARGREF(0);
 737   v = (v_scm);
 738   {
 739 {
 740 ScmObj SCM_RESULT;
 741  SCM_RESULT = (Scm_Round(v, SCM_ROUND_TRUNC));
 742 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
 743 }
 744   }
 745 }
 746 
 747 static SCM_DEFINE_STRING_CONST(stdlib_truncate__NAME, "truncate", 8, 8);
 748 static SCM_DEFINE_SUBR(stdlib_truncate__STUB, 1, 0, SCM_OBJ(&stdlib_truncate__NAME), stdlib_truncate, NULL, NULL);
 749 
 750 static ScmObj stdlib_round(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 751 {
 752   ScmObj v_scm;
 753   ScmObj v;
 754   SCM_ENTER_SUBR("round");
 755   v_scm = SCM_ARGREF(0);
 756   v = (v_scm);
 757   {
 758 {
 759 ScmObj SCM_RESULT;
 760  SCM_RESULT = (Scm_Round(v, SCM_ROUND_ROUND));
 761 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
 762 }
 763   }
 764 }
 765 
 766 static SCM_DEFINE_STRING_CONST(stdlib_round__NAME, "round", 5, 5);
 767 static SCM_DEFINE_SUBR(stdlib_round__STUB, 1, 0, SCM_OBJ(&stdlib_round__NAME), stdlib_round, NULL, NULL);
 768 
 769 static ScmObj stdlib__25exp(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 770 {
 771   ScmObj x_scm;
 772   double x;
 773   SCM_ENTER_SUBR("%exp");
 774   x_scm = SCM_ARGREF(0);
 775   if (!SCM_REALP(x_scm)) Scm_Error("real number required, but got %S", x_scm);
 776   x = Scm_GetDouble(x_scm);
 777   {
 778 {
 779 double SCM_RESULT;
 780 SCM_RESULT = exp(x);
 781 SCM_RETURN(Scm_MakeFlonum(SCM_RESULT));
 782 }
 783   }
 784 }
 785 
 786 static SCM_DEFINE_STRING_CONST(stdlib__25exp__NAME, "%exp", 4, 4);
 787 static SCM_DEFINE_SUBR(stdlib__25exp__STUB, 1, 0, SCM_OBJ(&stdlib__25exp__NAME), stdlib__25exp, NULL, NULL);
 788 
 789 static ScmObj stdlib__25log(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 790 {
 791   ScmObj x_scm;
 792   ScmObj x;
 793   SCM_ENTER_SUBR("%log");
 794   x_scm = SCM_ARGREF(0);
 795   x = (x_scm);
 796   {
 797 {
 798 ScmObj SCM_RESULT;
 799 if (!SCM_REALP(x)) {
 800   Scm_Error("real number required, but got %S", x);
 801 }
 802 if (Scm_Sign(x) < 0) {
 803   SCM_RESULT = Scm_MakeComplex(log(-Scm_GetDouble(x)), M_PI);
 804 } else {
 805   /* NB: I intentionally delegate handling of the case x==0.0 to the
 806   system log() function.  Most systems should yield NaN or Inf. */
 807   SCM_RESULT = Scm_MakeFlonum(log(Scm_GetDouble(x)));
 808 }
 809 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
 810 }
 811   }
 812 }
 813 
 814 static SCM_DEFINE_STRING_CONST(stdlib__25log__NAME, "%log", 4, 4);
 815 static SCM_DEFINE_SUBR(stdlib__25log__STUB, 1, 0, SCM_OBJ(&stdlib__25log__NAME), stdlib__25log, NULL, NULL);
 816 
 817 static ScmObj stdlib__25sin(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 818 {
 819   ScmObj x_scm;
 820   double x;
 821   SCM_ENTER_SUBR("%sin");
 822   x_scm = SCM_ARGREF(0);
 823   if (!SCM_REALP(x_scm)) Scm_Error("real number required, but got %S", x_scm);
 824   x = Scm_GetDouble(x_scm);
 825   {
 826 {
 827 double SCM_RESULT;
 828 SCM_RESULT = sin(x);
 829 SCM_RETURN(Scm_MakeFlonum(SCM_RESULT));
 830 }
 831   }
 832 }
 833 
 834 static SCM_DEFINE_STRING_CONST(stdlib__25sin__NAME, "%sin", 4, 4);
 835 static SCM_DEFINE_SUBR(stdlib__25sin__STUB, 1, 0, SCM_OBJ(&stdlib__25sin__NAME), stdlib__25sin, NULL, NULL);
 836 
 837 static ScmObj stdlib__25cos(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 838 {
 839   ScmObj x_scm;
 840   double x;
 841   SCM_ENTER_SUBR("%cos");
 842   x_scm = SCM_ARGREF(0);
 843   if (!SCM_REALP(x_scm)) Scm_Error("real number required, but got %S", x_scm);
 844   x = Scm_GetDouble(x_scm);
 845   {
 846 {
 847 double SCM_RESULT;
 848 SCM_RESULT = cos(x);
 849 SCM_RETURN(Scm_MakeFlonum(SCM_RESULT));
 850 }
 851   }
 852 }
 853 
 854 static SCM_DEFINE_STRING_CONST(stdlib__25cos__NAME, "%cos", 4, 4);
 855 static SCM_DEFINE_SUBR(stdlib__25cos__STUB, 1, 0, SCM_OBJ(&stdlib__25cos__NAME), stdlib__25cos, NULL, NULL);
 856 
 857 static ScmObj stdlib__25tan(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 858 {
 859   ScmObj x_scm;
 860   double x;
 861   SCM_ENTER_SUBR("%tan");
 862   x_scm = SCM_ARGREF(0);
 863   if (!SCM_REALP(x_scm)) Scm_Error("real number required, but got %S", x_scm);
 864   x = Scm_GetDouble(x_scm);
 865   {
 866 {
 867 double SCM_RESULT;
 868 SCM_RESULT = tan(x);
 869 SCM_RETURN(Scm_MakeFlonum(SCM_RESULT));
 870 }
 871   }
 872 }
 873 
 874 static SCM_DEFINE_STRING_CONST(stdlib__25tan__NAME, "%tan", 4, 4);
 875 static SCM_DEFINE_SUBR(stdlib__25tan__STUB, 1, 0, SCM_OBJ(&stdlib__25tan__NAME), stdlib__25tan, NULL, NULL);
 876 
 877 static ScmObj stdlib__25asin(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 878 {
 879   ScmObj x_scm;
 880   double x;
 881   SCM_ENTER_SUBR("%asin");
 882   x_scm = SCM_ARGREF(0);
 883   if (!SCM_REALP(x_scm)) Scm_Error("real number required, but got %S", x_scm);
 884   x = Scm_GetDouble(x_scm);
 885   {
 886 {
 887 ScmObj SCM_RESULT;
 888 if (x > 1.0) {
 889   SCM_RESULT = Scm_MakeComplex(M_PI/2.0, -log(x + sqrt(x*x-1.0)));
 890 } else if (x < -1.0) {
 891   SCM_RESULT = Scm_MakeComplex(-M_PI/2.0, -log(-x - sqrt(x*x-1.0)));
 892 } else {
 893   SCM_RESULT = Scm_MakeFlonum(asin(x));
 894 }
 895 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
 896 }
 897   }
 898 }
 899 
 900 static SCM_DEFINE_STRING_CONST(stdlib__25asin__NAME, "%asin", 5, 5);
 901 static SCM_DEFINE_SUBR(stdlib__25asin__STUB, 1, 0, SCM_OBJ(&stdlib__25asin__NAME), stdlib__25asin, NULL, NULL);
 902 
 903 static ScmObj stdlib__25acos(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 904 {
 905   ScmObj x_scm;
 906   double x;
 907   SCM_ENTER_SUBR("%acos");
 908   x_scm = SCM_ARGREF(0);
 909   if (!SCM_REALP(x_scm)) Scm_Error("real number required, but got %S", x_scm);
 910   x = Scm_GetDouble(x_scm);
 911   {
 912 {
 913 ScmObj SCM_RESULT;
 914 if (x > 1.0) {
 915   SCM_RESULT = Scm_MakeComplex(0, log(x + sqrt(x*x-1.0)));
 916 } else if (x < -1.0) {
 917   SCM_RESULT = Scm_MakeComplex(M_PI, log(-x - sqrt(x*x-1.0)));
 918 } else {
 919   SCM_RESULT = Scm_MakeFlonum(acos(x));
 920 }
 921 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
 922 }
 923   }
 924 }
 925 
 926 static SCM_DEFINE_STRING_CONST(stdlib__25acos__NAME, "%acos", 5, 5);
 927 static SCM_DEFINE_SUBR(stdlib__25acos__STUB, 1, 0, SCM_OBJ(&stdlib__25acos__NAME), stdlib__25acos, NULL, NULL);
 928 
 929 static ScmObj stdlib__25atan(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 930 {
 931   ScmObj z_scm;
 932   double z;
 933   ScmObj x_scm;
 934   ScmObj x;
 935   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
 936   SCM_ENTER_SUBR("%atan");
 937   if (Scm_Length(SCM_OPTARGS) > 1)
 938     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
 939   z_scm = SCM_ARGREF(0);
 940   if (!SCM_REALP(z_scm)) Scm_Error("real number required, but got %S", z_scm);
 941   z = Scm_GetDouble(z_scm);
 942   if (SCM_NULLP(SCM_OPTARGS)) x_scm = SCM_UNBOUND;
 943   else {
 944     x_scm = SCM_CAR(SCM_OPTARGS);
 945     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
 946   }
 947   x = (x_scm);
 948   {
 949 {
 950 ScmObj SCM_RESULT;
 951 if (x == SCM_UNBOUND) {
 952   SCM_RESULT = Scm_MakeFlonum(atan(z));
 953 } else {
 954   if (!SCM_REALP(x)) Scm_Error("real number required for x, but got %S", x);
 955   SCM_RESULT = Scm_MakeFlonum(atan2(z, Scm_GetDouble(x)));
 956 }
 957 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
 958 }
 959   }
 960 }
 961 
 962 static SCM_DEFINE_STRING_CONST(stdlib__25atan__NAME, "%atan", 5, 5);
 963 static SCM_DEFINE_SUBR(stdlib__25atan__STUB, 1, 1, SCM_OBJ(&stdlib__25atan__NAME), stdlib__25atan, NULL, NULL);
 964 
 965 static ScmObj stdlib__25sinh(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 966 {
 967   ScmObj x_scm;
 968   double x;
 969   SCM_ENTER_SUBR("%sinh");
 970   x_scm = SCM_ARGREF(0);
 971   if (!SCM_REALP(x_scm)) Scm_Error("real number required, but got %S", x_scm);
 972   x = Scm_GetDouble(x_scm);
 973   {
 974 {
 975 double SCM_RESULT;
 976 SCM_RESULT = sinh(x);
 977 SCM_RETURN(Scm_MakeFlonum(SCM_RESULT));
 978 }
 979   }
 980 }
 981 
 982 static SCM_DEFINE_STRING_CONST(stdlib__25sinh__NAME, "%sinh", 5, 5);
 983 static SCM_DEFINE_SUBR(stdlib__25sinh__STUB, 1, 0, SCM_OBJ(&stdlib__25sinh__NAME), stdlib__25sinh, NULL, NULL);
 984 
 985 static ScmObj stdlib__25cosh(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
 986 {
 987   ScmObj x_scm;
 988   double x;
 989   SCM_ENTER_SUBR("%cosh");
 990   x_scm = SCM_ARGREF(0);
 991   if (!SCM_REALP(x_scm)) Scm_Error("real number required, but got %S", x_scm);
 992   x = Scm_GetDouble(x_scm);
 993   {
 994 {
 995 double SCM_RESULT;
 996 SCM_RESULT = cosh(x);
 997 SCM_RETURN(Scm_MakeFlonum(SCM_RESULT));
 998 }
 999   }
1000 }
1001 
1002 static SCM_DEFINE_STRING_CONST(stdlib__25cosh__NAME, "%cosh", 5, 5);
1003 static SCM_DEFINE_SUBR(stdlib__25cosh__STUB, 1, 0, SCM_OBJ(&stdlib__25cosh__NAME), stdlib__25cosh, NULL, NULL);
1004 
1005 static ScmObj stdlib__25tanh(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1006 {
1007   ScmObj x_scm;
1008   double x;
1009   SCM_ENTER_SUBR("%tanh");
1010   x_scm = SCM_ARGREF(0);
1011   if (!SCM_REALP(x_scm)) Scm_Error("real number required, but got %S", x_scm);
1012   x = Scm_GetDouble(x_scm);
1013   {
1014 {
1015 double SCM_RESULT;
1016 SCM_RESULT = tanh(x);
1017 SCM_RETURN(Scm_MakeFlonum(SCM_RESULT));
1018 }
1019   }
1020 }
1021 
1022 static SCM_DEFINE_STRING_CONST(stdlib__25tanh__NAME, "%tanh", 5, 5);
1023 static SCM_DEFINE_SUBR(stdlib__25tanh__STUB, 1, 0, SCM_OBJ(&stdlib__25tanh__NAME), stdlib__25tanh, NULL, NULL);
1024 
1025 static ScmObj stdlib__25sqrt(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1026 {
1027   ScmObj x_scm;
1028   double x;
1029   SCM_ENTER_SUBR("%sqrt");
1030   x_scm = SCM_ARGREF(0);
1031   if (!SCM_REALP(x_scm)) Scm_Error("real number required, but got %S", x_scm);
1032   x = Scm_GetDouble(x_scm);
1033   {
1034 if (x < 0) SCM_RETURN(Scm_MakeComplex(0.0, sqrt(-x)));
1035   else        SCM_RETURN(Scm_MakeFlonum(sqrt(x)));
1036   }
1037 }
1038 
1039 static SCM_DEFINE_STRING_CONST(stdlib__25sqrt__NAME, "%sqrt", 5, 5);
1040 static SCM_DEFINE_SUBR(stdlib__25sqrt__STUB, 1, 0, SCM_OBJ(&stdlib__25sqrt__NAME), stdlib__25sqrt, NULL, NULL);
1041 
1042 static ScmObj stdlib__25expt(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1043 {
1044   ScmObj x_scm;
1045   ScmObj x;
1046   ScmObj y_scm;
1047   ScmObj y;
1048   SCM_ENTER_SUBR("%expt");
1049   x_scm = SCM_ARGREF(0);
1050   x = (x_scm);
1051   y_scm = SCM_ARGREF(1);
1052   y = (y_scm);
1053   {
1054 {
1055 ScmObj SCM_RESULT;
1056 SCM_RESULT = Scm_Expt(x, y);
1057 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
1058 }
1059   }
1060 }
1061 
1062 static SCM_DEFINE_STRING_CONST(stdlib__25expt__NAME, "%expt", 5, 5);
1063 static SCM_DEFINE_SUBR(stdlib__25expt__STUB, 2, 0, SCM_OBJ(&stdlib__25expt__NAME), stdlib__25expt, NULL, NULL);
1064 
1065 static ScmObj stdlib_make_rectangular(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1066 {
1067   ScmObj a_scm;
1068   double a;
1069   ScmObj b_scm;
1070   double b;
1071   SCM_ENTER_SUBR("make-rectangular");
1072   a_scm = SCM_ARGREF(0);
1073   if (!SCM_REALP(a_scm)) Scm_Error("real number required, but got %S", a_scm);
1074   a = Scm_GetDouble(a_scm);
1075   b_scm = SCM_ARGREF(1);
1076   if (!SCM_REALP(b_scm)) Scm_Error("real number required, but got %S", b_scm);
1077   b = Scm_GetDouble(b_scm);
1078   {
1079 if (b == 0.0) SCM_RETURN(Scm_MakeFlonum(a));
1080   else SCM_RETURN(Scm_MakeComplex(a, b));
1081   }
1082 }
1083 
1084 static SCM_DEFINE_STRING_CONST(stdlib_make_rectangular__NAME, "make-rectangular", 16, 16);
1085 static SCM_DEFINE_SUBR(stdlib_make_rectangular__STUB, 2, 0, SCM_OBJ(&stdlib_make_rectangular__NAME), stdlib_make_rectangular, NULL, NULL);
1086 
1087 static ScmObj stdlib_make_polar(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1088 {
1089   ScmObj r_scm;
1090   double r;
1091   ScmObj t_scm;
1092   double t;
1093   SCM_ENTER_SUBR("make-polar");
1094   r_scm = SCM_ARGREF(0);
1095   if (!SCM_REALP(r_scm)) Scm_Error("real number required, but got %S", r_scm);
1096   r = Scm_GetDouble(r_scm);
1097   t_scm = SCM_ARGREF(1);
1098   if (!SCM_REALP(t_scm)) Scm_Error("real number required, but got %S", t_scm);
1099   t = Scm_GetDouble(t_scm);
1100   {
1101 {
1102 ScmObj SCM_RESULT;
1103 SCM_RESULT = Scm_MakeComplexPolar(r, t);
1104 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
1105 }
1106   }
1107 }
1108 
1109 static SCM_DEFINE_STRING_CONST(stdlib_make_polar__NAME, "make-polar", 10, 10);
1110 static SCM_DEFINE_SUBR(stdlib_make_polar__STUB, 2, 0, SCM_OBJ(&stdlib_make_polar__NAME), stdlib_make_polar, NULL, NULL);
1111 
1112 static ScmObj stdlib__25complex_TOreal_2fimag(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1113 {
1114   ScmObj z_scm;
1115   ScmObj z;
1116   SCM_ENTER_SUBR("%complex->real/imag");
1117   z_scm = SCM_ARGREF(0);
1118   z = (z_scm);
1119   {
1120   if (SCM_EXACTP(z)) { SCM_RETURN(Scm_Values2(z, SCM_MAKE_INT(0))); }
1121   else if (SCM_FLONUMP(z)) { SCM_RETURN(Scm_Values2(z, Scm_MakeFlonum(0.0))); }
1122   else if (!SCM_COMPLEXP(z)) {
1123     Scm_Error("number required, but got %S", z);
1124     SCM_RETURN(SCM_UNDEFINED);
1125   } else { SCM_RETURN(Scm_Values2(Scm_MakeFlonum(SCM_COMPLEX_REAL(z)), Scm_MakeFlonum(SCM_COMPLEX_IMAG(z))));}
1126   }
1127 }
1128 
1129 static SCM_DEFINE_STRING_CONST(stdlib__25complex_TOreal_2fimag__NAME, "%complex->real/imag", 19, 19);
1130 static SCM_DEFINE_SUBR(stdlib__25complex_TOreal_2fimag__STUB, 1, 0, SCM_OBJ(&stdlib__25complex_TOreal_2fimag__NAME), stdlib__25complex_TOreal_2fimag, NULL, NULL);
1131 
1132 static ScmObj stdlib_real_part(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1133 {
1134   ScmObj z_scm;
1135   ScmObj z;
1136   SCM_ENTER_SUBR("real-part");
1137   z_scm = SCM_ARGREF(0);
1138   if (!SCM_NUMBERP(z_scm)) Scm_Error("number required, but got %S", z_scm);
1139   z = (z_scm);
1140   {
1141 if (SCM_REALP(z)) SCM_RETURN(z);
1142    SCM_ASSERT(SCM_COMPLEXP(z));
1143    SCM_RETURN(Scm_MakeFlonum(SCM_COMPLEX_REAL(z)));
1144   }
1145 }
1146 
1147 static SCM_DEFINE_STRING_CONST(stdlib_real_part__NAME, "real-part", 9, 9);
1148 static SCM_DEFINE_SUBR(stdlib_real_part__STUB, 1, 0, SCM_OBJ(&stdlib_real_part__NAME), stdlib_real_part, NULL, NULL);
1149 
1150 static ScmObj stdlib_imag_part(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1151 {
1152   ScmObj z_scm;
1153   ScmObj z;
1154   SCM_ENTER_SUBR("imag-part");
1155   z_scm = SCM_ARGREF(0);
1156   if (!SCM_NUMBERP(z_scm)) Scm_Error("number required, but got %S", z_scm);
1157   z = (z_scm);
1158   {
1159 if (SCM_EXACTP(z)) SCM_RETURN(SCM_MAKE_INT(0));
1160    else if (SCM_REALP(z)) SCM_RETURN(Scm_MakeFlonum(0.0));
1161    SCM_ASSERT(SCM_COMPLEXP(z));
1162    SCM_RETURN(Scm_MakeFlonum(SCM_COMPLEX_IMAG(z)));
1163   }
1164 }
1165 
1166 static SCM_DEFINE_STRING_CONST(stdlib_imag_part__NAME, "imag-part", 9, 9);
1167 static SCM_DEFINE_SUBR(stdlib_imag_part__STUB, 1, 0, SCM_OBJ(&stdlib_imag_part__NAME), stdlib_imag_part, NULL, NULL);
1168 
1169 static ScmObj stdlib_magnitude(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1170 {
1171   ScmObj z_scm;
1172   ScmObj z;
1173   SCM_ENTER_SUBR("magnitude");
1174   z_scm = SCM_ARGREF(0);
1175   z = (z_scm);
1176   {
1177 {
1178 ScmObj SCM_RESULT;
1179 SCM_RESULT = Scm_Magnitude(z);
1180 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
1181 }
1182   }
1183 }
1184 
1185 static SCM_DEFINE_STRING_CONST(stdlib_magnitude__NAME, "magnitude", 9, 9);
1186 static SCM_DEFINE_SUBR(stdlib_magnitude__STUB, 1, 0, SCM_OBJ(&stdlib_magnitude__NAME), stdlib_magnitude, NULL, NULL);
1187 
1188 static ScmObj stdlib_angle(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1189 {
1190   ScmObj z_scm;
1191   ScmObj z;
1192   SCM_ENTER_SUBR("angle");
1193   z_scm = SCM_ARGREF(0);
1194   z = (z_scm);
1195   {
1196 {
1197 ScmObj SCM_RESULT;
1198 SCM_RESULT = Scm_Angle(z);
1199 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
1200 }
1201   }
1202 }
1203 
1204 static SCM_DEFINE_STRING_CONST(stdlib_angle__NAME, "angle", 5, 5);
1205 static SCM_DEFINE_SUBR(stdlib_angle__STUB, 1, 0, SCM_OBJ(&stdlib_angle__NAME), stdlib_angle, NULL, NULL);
1206 
1207 static ScmObj stdlib_exact_TOinexact(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1208 {
1209   ScmObj obj_scm;
1210   ScmObj obj;
1211   SCM_ENTER_SUBR("exact->inexact");
1212   obj_scm = SCM_ARGREF(0);
1213   obj = (obj_scm);
1214   {
1215 {
1216 ScmObj SCM_RESULT;
1217 SCM_RESULT = Scm_ExactToInexact(obj);
1218 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
1219 }
1220   }
1221 }
1222 
1223 static SCM_DEFINE_STRING_CONST(stdlib_exact_TOinexact__NAME, "exact->inexact", 14, 14);
1224 static SCM_DEFINE_SUBR(stdlib_exact_TOinexact__STUB, 1, 0, SCM_OBJ(&stdlib_exact_TOinexact__NAME), stdlib_exact_TOinexact, NULL, NULL);
1225 
1226 static ScmObj stdlib_inexact_TOexact(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1227 {
1228   ScmObj obj_scm;
1229   ScmObj obj;
1230   SCM_ENTER_SUBR("inexact->exact");
1231   obj_scm = SCM_ARGREF(0);
1232   obj = (obj_scm);
1233   {
1234 {
1235 ScmObj SCM_RESULT;
1236 SCM_RESULT = Scm_InexactToExact(obj);
1237 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
1238 }
1239   }
1240 }
1241 
1242 static SCM_DEFINE_STRING_CONST(stdlib_inexact_TOexact__NAME, "inexact->exact", 14, 14);
1243 static SCM_DEFINE_SUBR(stdlib_inexact_TOexact__STUB, 1, 0, SCM_OBJ(&stdlib_inexact_TOexact__NAME), stdlib_inexact_TOexact, NULL, NULL);
1244 
1245 static ScmObj stdlib_number_TOstring(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1246 {
1247   ScmObj obj_scm;
1248   ScmObj obj;
1249   ScmObj radix_scm;
1250   int radix;
1251   ScmObj use_upperP_scm;
1252   ScmObj use_upperP;
1253   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
1254   SCM_ENTER_SUBR("number->string");
1255   if (Scm_Length(SCM_OPTARGS) > 2)
1256     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
1257   obj_scm = SCM_ARGREF(0);
1258   obj = (obj_scm);
1259   if (SCM_NULLP(SCM_OPTARGS)) radix_scm = Scm_MakeInteger(10);
1260   else {
1261     radix_scm = SCM_CAR(SCM_OPTARGS);
1262     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1263   }
1264   if (!SCM_INTP(radix_scm)) Scm_Error("small integer required, but got %S", radix_scm);
1265   radix = SCM_INT_VALUE(radix_scm);
1266   if (SCM_NULLP(SCM_OPTARGS)) use_upperP_scm = SCM_FALSE;
1267   else {
1268     use_upperP_scm = SCM_CAR(SCM_OPTARGS);
1269     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1270   }
1271   use_upperP = (use_upperP_scm);
1272   {
1273 {
1274 ScmObj SCM_RESULT;
1275  SCM_RESULT = (Scm_NumberToString(obj, radix, !SCM_FALSEP(use_upperP)));
1276 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
1277 }
1278   }
1279 }
1280 
1281 static SCM_DEFINE_STRING_CONST(stdlib_number_TOstring__NAME, "number->string", 14, 14);
1282 static SCM_DEFINE_SUBR(stdlib_number_TOstring__STUB, 1, 1, SCM_OBJ(&stdlib_number_TOstring__NAME), stdlib_number_TOstring, NULL, NULL);
1283 
1284 static ScmObj stdlib_string_TOnumber(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1285 {
1286   ScmObj obj_scm;
1287   ScmString* obj;
1288   ScmObj radix_scm;
1289   int radix;
1290   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
1291   SCM_ENTER_SUBR("string->number");
1292   if (Scm_Length(SCM_OPTARGS) > 1)
1293     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
1294   obj_scm = SCM_ARGREF(0);
1295   if (!SCM_STRINGP(obj_scm)) Scm_Error("string required, but got %S", obj_scm);
1296   obj = SCM_STRING(obj_scm);
1297   if (SCM_NULLP(SCM_OPTARGS)) radix_scm = Scm_MakeInteger(10);
1298   else {
1299     radix_scm = SCM_CAR(SCM_OPTARGS);
1300     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1301   }
1302   if (!SCM_INTP(radix_scm)) Scm_Error("small integer required, but got %S", radix_scm);
1303   radix = SCM_INT_VALUE(radix_scm);
1304   {
1305 {
1306 ScmObj SCM_RESULT;
1307  SCM_RESULT = (Scm_StringToNumber(obj, radix, FALSE));
1308 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
1309 }
1310   }
1311 }
1312 
1313 static SCM_DEFINE_STRING_CONST(stdlib_string_TOnumber__NAME, "string->number", 14, 14);
1314 static SCM_DEFINE_SUBR(stdlib_string_TOnumber__STUB, 1, 1, SCM_OBJ(&stdlib_string_TOnumber__NAME), stdlib_string_TOnumber, NULL, NULL);
1315 
1316 static ScmObj stdlib_not(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1317 {
1318   ScmObj obj_scm;
1319   ScmObj obj;
1320   SCM_ENTER_SUBR("not");
1321   obj_scm = SCM_ARGREF(0);
1322   obj = (obj_scm);
1323   {
1324 {
1325 int SCM_RESULT;
1326 SCM_RESULT = SCM_FALSEP(obj);
1327 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
1328 }
1329   }
1330 }
1331 
1332 static SCM_DEFINE_STRING_CONST(stdlib_not__NAME, "not", 3, 3);
1333 static SCM_DEFINE_SUBR(stdlib_not__STUB, 1, 0, SCM_OBJ(&stdlib_not__NAME), stdlib_not, SCM_MAKE_INT(SCM_VM_NOT), NULL);
1334 
1335 static ScmObj stdlib_booleanP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1336 {
1337   ScmObj obj_scm;
1338   ScmObj obj;
1339   SCM_ENTER_SUBR("boolean?");
1340   obj_scm = SCM_ARGREF(0);
1341   obj = (obj_scm);
1342   {
1343 {
1344 int SCM_RESULT;
1345 SCM_RESULT = SCM_BOOLP(obj);
1346 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
1347 }
1348   }
1349 }
1350 
1351 static SCM_DEFINE_STRING_CONST(stdlib_booleanP__NAME, "boolean?", 8, 8);
1352 static SCM_DEFINE_SUBR(stdlib_booleanP__STUB, 1, 0, SCM_OBJ(&stdlib_booleanP__NAME), stdlib_booleanP, NULL, NULL);
1353 
1354 static ScmObj stdlib_pairP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1355 {
1356   ScmObj obj_scm;
1357   ScmObj obj;
1358   SCM_ENTER_SUBR("pair?");
1359   obj_scm = SCM_ARGREF(0);
1360   obj = (obj_scm);
1361   {
1362 {
1363 int SCM_RESULT;
1364 SCM_RESULT = SCM_PAIRP(obj);
1365 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
1366 }
1367   }
1368 }
1369 
1370 static SCM_DEFINE_STRING_CONST(stdlib_pairP__NAME, "pair?", 5, 5);
1371 static SCM_DEFINE_SUBR(stdlib_pairP__STUB, 1, 0, SCM_OBJ(&stdlib_pairP__NAME), stdlib_pairP, SCM_MAKE_INT(SCM_VM_PAIRP), NULL);
1372 
1373 static ScmObj stdlib_cons(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1374 {
1375   ScmObj obj1_scm;
1376   ScmObj obj1;
1377   ScmObj obj2_scm;
1378   ScmObj obj2;
1379   SCM_ENTER_SUBR("cons");
1380   obj1_scm = SCM_ARGREF(0);
1381   obj1 = (obj1_scm);
1382   obj2_scm = SCM_ARGREF(1);
1383   obj2 = (obj2_scm);
1384   {
1385 {
1386 ScmObj SCM_RESULT;
1387 SCM_RESULT = Scm_Cons(obj1, obj2);
1388 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
1389 }
1390   }
1391 }
1392 
1393 static SCM_DEFINE_STRING_CONST(stdlib_cons__NAME, "cons", 4, 4);
1394 static SCM_DEFINE_SUBR(stdlib_cons__STUB, 2, 0, SCM_OBJ(&stdlib_cons__NAME), stdlib_cons, SCM_MAKE_INT(SCM_VM_CONS), NULL);
1395 
1396 static ScmObj stdlib_car(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1397 {
1398   ScmObj obj_scm;
1399   ScmPair* obj;
1400   SCM_ENTER_SUBR("car");
1401   obj_scm = SCM_ARGREF(0);
1402   if (!SCM_PAIRP(obj_scm)) Scm_Error("pair required, but got %S", obj_scm);
1403   obj = SCM_PAIR(obj_scm);
1404   {
1405 {
1406 ScmObj SCM_RESULT;
1407 SCM_RESULT = SCM_CAR(obj);
1408 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
1409 }
1410   }
1411 }
1412 
1413 static SCM_DEFINE_STRING_CONST(stdlib_car__NAME, "car", 3, 3);
1414 static SCM_DEFINE_SUBR(stdlib_car__STUB, 1, 0, SCM_OBJ(&stdlib_car__NAME), stdlib_car, SCM_MAKE_INT(SCM_VM_CAR), NULL);
1415 
1416 static ScmObj stdlib_cdr(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1417 {
1418   ScmObj obj_scm;
1419   ScmPair* obj;
1420   SCM_ENTER_SUBR("cdr");
1421   obj_scm = SCM_ARGREF(0);
1422   if (!SCM_PAIRP(obj_scm)) Scm_Error("pair required, but got %S", obj_scm);
1423   obj = SCM_PAIR(obj_scm);
1424   {
1425 {
1426 ScmObj SCM_RESULT;
1427 SCM_RESULT = SCM_CDR(obj);
1428 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
1429 }
1430   }
1431 }
1432 
1433 static SCM_DEFINE_STRING_CONST(stdlib_cdr__NAME, "cdr", 3, 3);
1434 static SCM_DEFINE_SUBR(stdlib_cdr__STUB, 1, 0, SCM_OBJ(&stdlib_cdr__NAME), stdlib_cdr, SCM_MAKE_INT(SCM_VM_CDR), NULL);
1435 
1436 static ScmObj stdlib_set_carX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1437 {
1438   ScmObj obj_scm;
1439   ScmPair* obj;
1440   ScmObj value_scm;
1441   ScmObj value;
1442   SCM_ENTER_SUBR("set-car!");
1443   obj_scm = SCM_ARGREF(0);
1444   if (!SCM_PAIRP(obj_scm)) Scm_Error("pair required, but got %S", obj_scm);
1445   obj = SCM_PAIR(obj_scm);
1446   value_scm = SCM_ARGREF(1);
1447   value = (value_scm);
1448   {
1449 SCM_SET_CAR(obj, value);
1450 SCM_RETURN(SCM_UNDEFINED);
1451   }
1452 }
1453 
1454 static SCM_DEFINE_STRING_CONST(stdlib_set_carX__NAME, "set-car!", 8, 8);
1455 static SCM_DEFINE_SUBR(stdlib_set_carX__STUB, 2, 0, SCM_OBJ(&stdlib_set_carX__NAME), stdlib_set_carX, NULL, NULL);
1456 
1457 static ScmObj stdlib_set_cdrX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1458 {
1459   ScmObj obj_scm;
1460   ScmPair* obj;
1461   ScmObj value_scm;
1462   ScmObj value;
1463   SCM_ENTER_SUBR("set-cdr!");
1464   obj_scm = SCM_ARGREF(0);
1465   if (!SCM_PAIRP(obj_scm)) Scm_Error("pair required, but got %S", obj_scm);
1466   obj = SCM_PAIR(obj_scm);
1467   value_scm = SCM_ARGREF(1);
1468   value = (value_scm);
1469   {
1470 SCM_SET_CDR(obj, value);
1471 SCM_RETURN(SCM_UNDEFINED);
1472   }
1473 }
1474 
1475 static SCM_DEFINE_STRING_CONST(stdlib_set_cdrX__NAME, "set-cdr!", 8, 8);
1476 static SCM_DEFINE_SUBR(stdlib_set_cdrX__STUB, 2, 0, SCM_OBJ(&stdlib_set_cdrX__NAME), stdlib_set_cdrX, NULL, NULL);
1477 
1478 #define CXR_SETTER(PRE, pre, tail) \
1479   ScmObj cell = Scm_C##tail##r(obj); \
1480   if (!SCM_PAIRP(cell)) Scm_Error("can't set c" #pre #tail "r of %S", obj); \
1481   SCM_SET_C##PRE##R(cell, value); SCM_RETURN(SCM_UNDEFINED);
1482 
1483 static ScmObj stdlib_caar_SETTER(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1484 {
1485   ScmObj obj_scm;
1486   ScmObj obj;
1487   ScmObj value_scm;
1488   ScmObj value;
1489   SCM_ENTER_SUBR("(setter caar)");
1490   obj_scm = SCM_ARGREF(0);
1491   obj = (obj_scm);
1492   value_scm = SCM_ARGREF(1);
1493   value = (value_scm);
1494   {
1495 CXR_SETTER(A, a, a);
1496   }
1497 }
1498 
1499 static SCM_DEFINE_STRING_CONST(stdlib_caar_SETTER__NAME, "(setter caar)", 13, 13);
1500 static SCM_DEFINE_SUBR(stdlib_caar_SETTER__STUB, 2, 0, SCM_OBJ(&stdlib_caar_SETTER__NAME), stdlib_caar_SETTER, NULL, NULL);
1501 
1502 static ScmObj stdlib_caar(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1503 {
1504   ScmObj obj_scm;
1505   ScmObj obj;
1506   SCM_ENTER_SUBR("caar");
1507   obj_scm = SCM_ARGREF(0);
1508   obj = (obj_scm);
1509   {
1510 {
1511 ScmObj SCM_RESULT;
1512 SCM_RESULT = Scm_Caar(obj);
1513 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
1514 }
1515   }
1516 }
1517 
1518 static SCM_DEFINE_STRING_CONST(stdlib_caar__NAME, "caar", 4, 4);
1519 static SCM_DEFINE_SUBR(stdlib_caar__STUB, 1, 0, SCM_OBJ(&stdlib_caar__NAME), stdlib_caar, SCM_MAKE_INT(SCM_VM_CAAR), NULL);
1520 
1521 static ScmObj stdlib_cadr_SETTER(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1522 {
1523   ScmObj obj_scm;
1524   ScmObj obj;
1525   ScmObj value_scm;
1526   ScmObj value;
1527   SCM_ENTER_SUBR("(setter cadr)");
1528   obj_scm = SCM_ARGREF(0);
1529   obj = (obj_scm);
1530   value_scm = SCM_ARGREF(1);
1531   value = (value_scm);
1532   {
1533 CXR_SETTER(A, a, d);
1534   }
1535 }
1536 
1537 static SCM_DEFINE_STRING_CONST(stdlib_cadr_SETTER__NAME, "(setter cadr)", 13, 13);
1538 static SCM_DEFINE_SUBR(stdlib_cadr_SETTER__STUB, 2, 0, SCM_OBJ(&stdlib_cadr_SETTER__NAME), stdlib_cadr_SETTER, NULL, NULL);
1539 
1540 static ScmObj stdlib_cadr(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1541 {
1542   ScmObj obj_scm;
1543   ScmObj obj;
1544   SCM_ENTER_SUBR("cadr");
1545   obj_scm = SCM_ARGREF(0);
1546   obj = (obj_scm);
1547   {
1548 {
1549 ScmObj SCM_RESULT;
1550 SCM_RESULT = Scm_Cadr(obj);
1551 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
1552 }
1553   }
1554 }
1555 
1556 static SCM_DEFINE_STRING_CONST(stdlib_cadr__NAME, "cadr", 4, 4);
1557 static SCM_DEFINE_SUBR(stdlib_cadr__STUB, 1, 0, SCM_OBJ(&stdlib_cadr__NAME), stdlib_cadr, SCM_MAKE_INT(SCM_VM_CADR), NULL);
1558 
1559 static ScmObj stdlib_cdar_SETTER(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1560 {
1561   ScmObj obj_scm;
1562   ScmObj obj;
1563   ScmObj value_scm;
1564   ScmObj value;
1565   SCM_ENTER_SUBR("(setter cdar)");
1566   obj_scm = SCM_ARGREF(0);
1567   obj = (obj_scm);
1568   value_scm = SCM_ARGREF(1);
1569   value = (value_scm);
1570   {
1571 CXR_SETTER(D, d, a);
1572   }
1573 }
1574 
1575 static SCM_DEFINE_STRING_CONST(stdlib_cdar_SETTER__NAME, "(setter cdar)", 13, 13);
1576 static SCM_DEFINE_SUBR(stdlib_cdar_SETTER__STUB, 2, 0, SCM_OBJ(&stdlib_cdar_SETTER__NAME), stdlib_cdar_SETTER, NULL, NULL);
1577 
1578 static ScmObj stdlib_cdar(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1579 {
1580   ScmObj obj_scm;
1581   ScmObj obj;
1582   SCM_ENTER_SUBR("cdar");
1583   obj_scm = SCM_ARGREF(0);
1584   obj = (obj_scm);
1585   {
1586 {
1587 ScmObj SCM_RESULT;
1588 SCM_RESULT = Scm_Cdar(obj);
1589 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
1590 }
1591   }
1592 }
1593 
1594 static SCM_DEFINE_STRING_CONST(stdlib_cdar__NAME, "cdar", 4, 4);
1595 static SCM_DEFINE_SUBR(stdlib_cdar__STUB, 1, 0, SCM_OBJ(&stdlib_cdar__NAME), stdlib_cdar, SCM_MAKE_INT(SCM_VM_CDAR), NULL);
1596 
1597 static ScmObj stdlib_cddr_SETTER(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1598 {
1599   ScmObj obj_scm;
1600   ScmObj obj;
1601   ScmObj value_scm;
1602   ScmObj value;
1603   SCM_ENTER_SUBR("(setter cddr)");
1604   obj_scm = SCM_ARGREF(0);
1605   obj = (obj_scm);
1606   value_scm = SCM_ARGREF(1);
1607   value = (value_scm);
1608   {
1609 CXR_SETTER(D, d, d);
1610   }
1611 }
1612 
1613 static SCM_DEFINE_STRING_CONST(stdlib_cddr_SETTER__NAME, "(setter cddr)", 13, 13);
1614 static SCM_DEFINE_SUBR(stdlib_cddr_SETTER__STUB, 2, 0, SCM_OBJ(&stdlib_cddr_SETTER__NAME), stdlib_cddr_SETTER, NULL, NULL);
1615 
1616 static ScmObj stdlib_cddr(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1617 {
1618   ScmObj obj_scm;
1619   ScmObj obj;
1620   SCM_ENTER_SUBR("cddr");
1621   obj_scm = SCM_ARGREF(0);
1622   obj = (obj_scm);
1623   {
1624 {
1625 ScmObj SCM_RESULT;
1626 SCM_RESULT = Scm_Cddr(obj);
1627 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
1628 }
1629   }
1630 }
1631 
1632 static SCM_DEFINE_STRING_CONST(stdlib_cddr__NAME, "cddr", 4, 4);
1633 static SCM_DEFINE_SUBR(stdlib_cddr__STUB, 1, 0, SCM_OBJ(&stdlib_cddr__NAME), stdlib_cddr, SCM_MAKE_INT(SCM_VM_CDDR), NULL);
1634 
1635 static ScmObj stdlib_nullP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1636 {
1637   ScmObj obj_scm;
1638   ScmObj obj;
1639   SCM_ENTER_SUBR("null?");
1640   obj_scm = SCM_ARGREF(0);
1641   obj = (obj_scm);
1642   {
1643 {
1644 int SCM_RESULT;
1645 SCM_RESULT = SCM_NULLP(obj);
1646 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
1647 }
1648   }
1649 }
1650 
1651 static SCM_DEFINE_STRING_CONST(stdlib_nullP__NAME, "null?", 5, 5);
1652 static SCM_DEFINE_SUBR(stdlib_nullP__STUB, 1, 0, SCM_OBJ(&stdlib_nullP__NAME), stdlib_nullP, SCM_MAKE_INT(SCM_VM_NULLP), NULL);
1653 
1654 static ScmObj stdlib_listP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1655 {
1656   ScmObj obj_scm;
1657   ScmObj obj;
1658   SCM_ENTER_SUBR("list?");
1659   obj_scm = SCM_ARGREF(0);
1660   obj = (obj_scm);
1661   {
1662 {
1663 int SCM_RESULT;
1664 SCM_RESULT = SCM_PROPER_LIST_P(obj);
1665 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
1666 }
1667   }
1668 }
1669 
1670 static SCM_DEFINE_STRING_CONST(stdlib_listP__NAME, "list?", 5, 5);
1671 static SCM_DEFINE_SUBR(stdlib_listP__STUB, 1, 0, SCM_OBJ(&stdlib_listP__NAME), stdlib_listP, NULL, NULL);
1672 
1673 static ScmObj stdlib_list(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1674 {
1675   ScmObj args_scm;
1676   ScmObj args;
1677   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
1678   SCM_ENTER_SUBR("list");
1679   args_scm = SCM_OPTARGS;
1680   args = (args_scm);
1681   {
1682 {
1683 ScmObj SCM_RESULT;
1684  SCM_RESULT = (args);
1685 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
1686 }
1687   }
1688 }
1689 
1690 static SCM_DEFINE_STRING_CONST(stdlib_list__NAME, "list", 4, 4);
1691 static SCM_DEFINE_SUBR(stdlib_list__STUB, 0, 1, SCM_OBJ(&stdlib_list__NAME), stdlib_list, SCM_MAKE_INT(SCM_VM_LIST), NULL);
1692 
1693 static ScmObj stdlib_length(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1694 {
1695   ScmObj list_scm;
1696   ScmObj list;
1697   SCM_ENTER_SUBR("length");
1698   list_scm = SCM_ARGREF(0);
1699   list = (list_scm);
1700   {
1701 {
1702 long SCM_RESULT;
1703 SCM_RESULT = Scm_Length(list);
1704 if (SCM_RESULT < 0) Scm_Error("bad list: %S", list);
1705 SCM_RETURN(Scm_MakeInteger(SCM_RESULT));
1706 }
1707   }
1708 }
1709 
1710 static SCM_DEFINE_STRING_CONST(stdlib_length__NAME, "length", 6, 6);
1711 static SCM_DEFINE_SUBR(stdlib_length__STUB, 1, 0, SCM_OBJ(&stdlib_length__NAME), stdlib_length, SCM_MAKE_INT(SCM_VM_LENGTH), NULL);
1712 
1713 static ScmObj stdlib_length_2b(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1714 {
1715   ScmObj list_scm;
1716   ScmObj list;
1717   SCM_ENTER_SUBR("length+");
1718   list_scm = SCM_ARGREF(0);
1719   list = (list_scm);
1720   {
1721 {
1722 ScmObj SCM_RESULT;
1723 int i = Scm_Length(list);
1724 if (i<0) SCM_RESULT = SCM_FALSE;
1725 else SCM_RESULT = Scm_MakeInteger(i);
1726 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
1727 }
1728   }
1729 }
1730 
1731 static SCM_DEFINE_STRING_CONST(stdlib_length_2b__NAME, "length+", 7, 7);
1732 static SCM_DEFINE_SUBR(stdlib_length_2b__STUB, 1, 0, SCM_OBJ(&stdlib_length_2b__NAME), stdlib_length_2b, NULL, NULL);
1733 
1734 static ScmObj stdlib_append(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1735 {
1736   ScmObj lists_scm;
1737   ScmObj lists;
1738   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
1739   SCM_ENTER_SUBR("append");
1740   lists_scm = SCM_OPTARGS;
1741   lists = (lists_scm);
1742   {
1743 {
1744 ScmObj SCM_RESULT;
1745 SCM_RESULT = Scm_Append(lists);
1746 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
1747 }
1748   }
1749 }
1750 
1751 static SCM_DEFINE_STRING_CONST(stdlib_append__NAME, "append", 6, 6);
1752 static SCM_DEFINE_SUBR(stdlib_append__STUB, 0, 1, SCM_OBJ(&stdlib_append__NAME), stdlib_append, SCM_MAKE_INT(SCM_VM_APPEND), NULL);
1753 
1754 static ScmObj stdlib_reverse(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1755 {
1756   ScmObj list_scm;
1757   ScmObj list;
1758   SCM_ENTER_SUBR("reverse");
1759   list_scm = SCM_ARGREF(0);
1760   if (!SCM_LISTP(list_scm)) Scm_Error("list required, but got %S", list_scm);
1761   list = (list_scm);
1762   {
1763 {
1764 ScmObj SCM_RESULT;
1765 SCM_RESULT = Scm_Reverse(list);
1766 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
1767 }
1768   }
1769 }
1770 
1771 static SCM_DEFINE_STRING_CONST(stdlib_reverse__NAME, "reverse", 7, 7);
1772 static SCM_DEFINE_SUBR(stdlib_reverse__STUB, 1, 0, SCM_OBJ(&stdlib_reverse__NAME), stdlib_reverse, SCM_MAKE_INT(SCM_VM_REVERSE), NULL);
1773 
1774 static ScmObj stdlib_list_tail(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1775 {
1776   ScmObj list_scm;
1777   ScmObj list;
1778   ScmObj k_scm;
1779   int k;
1780   ScmObj fallback_scm;
1781   ScmObj fallback;
1782   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
1783   SCM_ENTER_SUBR("list-tail");
1784   if (Scm_Length(SCM_OPTARGS) > 1)
1785     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
1786   list_scm = SCM_ARGREF(0);
1787   list = (list_scm);
1788   k_scm = SCM_ARGREF(1);
1789   if (!SCM_INTP(k_scm)) Scm_Error("small integer required, but got %S", k_scm);
1790   k = SCM_INT_VALUE(k_scm);
1791   if (SCM_NULLP(SCM_OPTARGS)) fallback_scm = SCM_UNBOUND;
1792   else {
1793     fallback_scm = SCM_CAR(SCM_OPTARGS);
1794     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1795   }
1796   fallback = (fallback_scm);
1797   {
1798 {
1799 ScmObj SCM_RESULT;
1800 SCM_RESULT = Scm_ListTail(list, k, fallback);
1801 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
1802 }
1803   }
1804 }
1805 
1806 static SCM_DEFINE_STRING_CONST(stdlib_list_tail__NAME, "list-tail", 9, 9);
1807 static SCM_DEFINE_SUBR(stdlib_list_tail__STUB, 2, 1, SCM_OBJ(&stdlib_list_tail__NAME), stdlib_list_tail, NULL, NULL);
1808 
1809 static ScmObj stdlib_list_ref(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1810 {
1811   ScmObj list_scm;
1812   ScmObj list;
1813   ScmObj k_scm;
1814   int k;
1815   ScmObj fallback_scm;
1816   ScmObj fallback;
1817   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
1818   SCM_ENTER_SUBR("list-ref");
1819   if (Scm_Length(SCM_OPTARGS) > 1)
1820     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
1821   list_scm = SCM_ARGREF(0);
1822   list = (list_scm);
1823   k_scm = SCM_ARGREF(1);
1824   if (!SCM_INTP(k_scm)) Scm_Error("small integer required, but got %S", k_scm);
1825   k = SCM_INT_VALUE(k_scm);
1826   if (SCM_NULLP(SCM_OPTARGS)) fallback_scm = SCM_UNBOUND;
1827   else {
1828     fallback_scm = SCM_CAR(SCM_OPTARGS);
1829     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
1830   }
1831   fallback = (fallback_scm);
1832   {
1833 {
1834 ScmObj SCM_RESULT;
1835 SCM_RESULT = Scm_ListRef(list, k, fallback);
1836 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
1837 }
1838   }
1839 }
1840 
1841 static SCM_DEFINE_STRING_CONST(stdlib_list_ref__NAME, "list-ref", 8, 8);
1842 static SCM_DEFINE_SUBR(stdlib_list_ref__STUB, 2, 1, SCM_OBJ(&stdlib_list_ref__NAME), stdlib_list_ref, NULL, NULL);
1843 
1844 static ScmObj stdlib_memq(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1845 {
1846   ScmObj obj_scm;
1847   ScmObj obj;
1848   ScmObj list_scm;
1849   ScmObj list;
1850   SCM_ENTER_SUBR("memq");
1851   obj_scm = SCM_ARGREF(0);
1852   obj = (obj_scm);
1853   list_scm = SCM_ARGREF(1);
1854   if (!SCM_LISTP(list_scm)) Scm_Error("list required, but got %S", list_scm);
1855   list = (list_scm);
1856   {
1857 {
1858 ScmObj SCM_RESULT;
1859 SCM_RESULT = Scm_Memq(obj, list);
1860 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
1861 }
1862   }
1863 }
1864 
1865 static SCM_DEFINE_STRING_CONST(stdlib_memq__NAME, "memq", 4, 4);
1866 static SCM_DEFINE_SUBR(stdlib_memq__STUB, 2, 0, SCM_OBJ(&stdlib_memq__NAME), stdlib_memq, SCM_MAKE_INT(SCM_VM_MEMQ), NULL);
1867 
1868 static ScmObj stdlib_memv(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1869 {
1870   ScmObj obj_scm;
1871   ScmObj obj;
1872   ScmObj list_scm;
1873   ScmObj list;
1874   SCM_ENTER_SUBR("memv");
1875   obj_scm = SCM_ARGREF(0);
1876   obj = (obj_scm);
1877   list_scm = SCM_ARGREF(1);
1878   if (!SCM_LISTP(list_scm)) Scm_Error("list required, but got %S", list_scm);
1879   list = (list_scm);
1880   {
1881 {
1882 ScmObj SCM_RESULT;
1883 SCM_RESULT = Scm_Memv(obj, list);
1884 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
1885 }
1886   }
1887 }
1888 
1889 static SCM_DEFINE_STRING_CONST(stdlib_memv__NAME, "memv", 4, 4);
1890 static SCM_DEFINE_SUBR(stdlib_memv__STUB, 2, 0, SCM_OBJ(&stdlib_memv__NAME), stdlib_memv, SCM_MAKE_INT(SCM_VM_MEMV), NULL);
1891 
1892 static ScmObj stdlib_member(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1893 {
1894   ScmObj obj_scm;
1895   ScmObj obj;
1896   ScmObj list_scm;
1897   ScmObj list;
1898   SCM_ENTER_SUBR("member");
1899   obj_scm = SCM_ARGREF(0);
1900   obj = (obj_scm);
1901   list_scm = SCM_ARGREF(1);
1902   if (!SCM_LISTP(list_scm)) Scm_Error("list required, but got %S", list_scm);
1903   list = (list_scm);
1904   {
1905 {
1906 ScmObj SCM_RESULT;
1907  SCM_RESULT = (Scm_Member(obj, list, SCM_CMP_EQUAL));
1908 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
1909 }
1910   }
1911 }
1912 
1913 static SCM_DEFINE_STRING_CONST(stdlib_member__NAME, "member", 6, 6);
1914 static SCM_DEFINE_SUBR(stdlib_member__STUB, 2, 0, SCM_OBJ(&stdlib_member__NAME), stdlib_member, NULL, NULL);
1915 
1916 static ScmObj stdlib_assq(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1917 {
1918   ScmObj obj_scm;
1919   ScmObj obj;
1920   ScmObj alist_scm;
1921   ScmObj alist;
1922   SCM_ENTER_SUBR("assq");
1923   obj_scm = SCM_ARGREF(0);
1924   obj = (obj_scm);
1925   alist_scm = SCM_ARGREF(1);
1926   if (!SCM_LISTP(alist_scm)) Scm_Error("list required, but got %S", alist_scm);
1927   alist = (alist_scm);
1928   {
1929 {
1930 ScmObj SCM_RESULT;
1931 SCM_RESULT = Scm_Assq(obj, alist);
1932 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
1933 }
1934   }
1935 }
1936 
1937 static SCM_DEFINE_STRING_CONST(stdlib_assq__NAME, "assq", 4, 4);
1938 static SCM_DEFINE_SUBR(stdlib_assq__STUB, 2, 0, SCM_OBJ(&stdlib_assq__NAME), stdlib_assq, SCM_MAKE_INT(SCM_VM_ASSQ), NULL);
1939 
1940 static ScmObj stdlib_assv(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1941 {
1942   ScmObj obj_scm;
1943   ScmObj obj;
1944   ScmObj alist_scm;
1945   ScmObj alist;
1946   SCM_ENTER_SUBR("assv");
1947   obj_scm = SCM_ARGREF(0);
1948   obj = (obj_scm);
1949   alist_scm = SCM_ARGREF(1);
1950   if (!SCM_LISTP(alist_scm)) Scm_Error("list required, but got %S", alist_scm);
1951   alist = (alist_scm);
1952   {
1953 {
1954 ScmObj SCM_RESULT;
1955 SCM_RESULT = Scm_Assv(obj, alist);
1956 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
1957 }
1958   }
1959 }
1960 
1961 static SCM_DEFINE_STRING_CONST(stdlib_assv__NAME, "assv", 4, 4);
1962 static SCM_DEFINE_SUBR(stdlib_assv__STUB, 2, 0, SCM_OBJ(&stdlib_assv__NAME), stdlib_assv, SCM_MAKE_INT(SCM_VM_ASSV), NULL);
1963 
1964 static ScmObj stdlib_assoc(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1965 {
1966   ScmObj obj_scm;
1967   ScmObj obj;
1968   ScmObj alist_scm;
1969   ScmObj alist;
1970   SCM_ENTER_SUBR("assoc");
1971   obj_scm = SCM_ARGREF(0);
1972   obj = (obj_scm);
1973   alist_scm = SCM_ARGREF(1);
1974   if (!SCM_LISTP(alist_scm)) Scm_Error("list required, but got %S", alist_scm);
1975   alist = (alist_scm);
1976   {
1977 {
1978 ScmObj SCM_RESULT;
1979  SCM_RESULT = (Scm_Assoc(obj, alist, SCM_CMP_EQUAL));
1980 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
1981 }
1982   }
1983 }
1984 
1985 static SCM_DEFINE_STRING_CONST(stdlib_assoc__NAME, "assoc", 5, 5);
1986 static SCM_DEFINE_SUBR(stdlib_assoc__STUB, 2, 0, SCM_OBJ(&stdlib_assoc__NAME), stdlib_assoc, NULL, NULL);
1987 
1988 static ScmObj stdlib_symbolP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
1989 {
1990   ScmObj obj_scm;
1991   ScmObj obj;
1992   SCM_ENTER_SUBR("symbol?");
1993   obj_scm = SCM_ARGREF(0);
1994   obj = (obj_scm);
1995   {
1996 {
1997 int SCM_RESULT;
1998 SCM_RESULT = SCM_SYMBOLP(obj);
1999 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
2000 }
2001   }
2002 }
2003 
2004 static SCM_DEFINE_STRING_CONST(stdlib_symbolP__NAME, "symbol?", 7, 7);
2005 static SCM_DEFINE_SUBR(stdlib_symbolP__STUB, 1, 0, SCM_OBJ(&stdlib_symbolP__NAME), stdlib_symbolP, SCM_MAKE_INT(SCM_VM_SYMBOLP), NULL);
2006 
2007 static ScmObj stdlib_symbol_TOstring(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2008 {
2009   ScmObj obj_scm;
2010   ScmSymbol* obj;
2011   SCM_ENTER_SUBR("symbol->string");
2012   obj_scm = SCM_ARGREF(0);
2013   if (!SCM_SYMBOLP(obj_scm)) Scm_Error("symbol required, but got %S", obj_scm);
2014   obj = SCM_SYMBOL(obj_scm);
2015   {
2016 {
2017 ScmObj SCM_RESULT;
2018  SCM_RESULT = (SCM_OBJ(SCM_SYMBOL_NAME(obj)));
2019 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
2020 }
2021   }
2022 }
2023 
2024 static SCM_DEFINE_STRING_CONST(stdlib_symbol_TOstring__NAME, "symbol->string", 14, 14);
2025 static SCM_DEFINE_SUBR(stdlib_symbol_TOstring__STUB, 1, 0, SCM_OBJ(&stdlib_symbol_TOstring__NAME), stdlib_symbol_TOstring, NULL, NULL);
2026 
2027 static ScmObj stdlib_string_TOsymbol(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2028 {
2029   ScmObj obj_scm;
2030   ScmString* obj;
2031   SCM_ENTER_SUBR("string->symbol");
2032   obj_scm = SCM_ARGREF(0);
2033   if (!SCM_STRINGP(obj_scm)) Scm_Error("string required, but got %S", obj_scm);
2034   obj = SCM_STRING(obj_scm);
2035   {
2036 {
2037 ScmObj SCM_RESULT;
2038 SCM_RESULT = Scm_Intern(obj);
2039 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
2040 }
2041   }
2042 }
2043 
2044 static SCM_DEFINE_STRING_CONST(stdlib_string_TOsymbol__NAME, "string->symbol", 14, 14);
2045 static SCM_DEFINE_SUBR(stdlib_string_TOsymbol__STUB, 1, 0, SCM_OBJ(&stdlib_string_TOsymbol__NAME), stdlib_string_TOsymbol, NULL, NULL);
2046 
2047 static ScmObj stdlib_charP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2048 {
2049   ScmObj obj_scm;
2050   ScmObj obj;
2051   SCM_ENTER_SUBR("char?");
2052   obj_scm = SCM_ARGREF(0);
2053   obj = (obj_scm);
2054   {
2055 {
2056 int SCM_RESULT;
2057 SCM_RESULT = SCM_CHARP(obj);
2058 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
2059 }
2060   }
2061 }
2062 
2063 static SCM_DEFINE_STRING_CONST(stdlib_charP__NAME, "char?", 5, 5);
2064 static SCM_DEFINE_SUBR(stdlib_charP__STUB, 1, 0, SCM_OBJ(&stdlib_charP__NAME), stdlib_charP, SCM_MAKE_INT(SCM_VM_CHARP), NULL);
2065 
2066 static ScmObj stdlib_char_3dP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2067 {
2068   ScmObj c1_scm;
2069   ScmChar c1;
2070   ScmObj c2_scm;
2071   ScmChar c2;
2072   SCM_ENTER_SUBR("char=?");
2073   c1_scm = SCM_ARGREF(0);
2074   if (!SCM_CHARP(c1_scm)) Scm_Error("character required, but got %S", c1_scm);
2075   c1 = SCM_CHAR_VALUE(c1_scm);
2076   c2_scm = SCM_ARGREF(1);
2077   if (!SCM_CHARP(c2_scm)) Scm_Error("character required, but got %S", c2_scm);
2078   c2 = SCM_CHAR_VALUE(c2_scm);
2079   {
2080 {
2081 int SCM_RESULT;
2082  SCM_RESULT = (c1 == c2);
2083 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
2084 }
2085   }
2086 }
2087 
2088 static SCM_DEFINE_STRING_CONST(stdlib_char_3dP__NAME, "char=?", 6, 6);
2089 static SCM_DEFINE_SUBR(stdlib_char_3dP__STUB, 2, 0, SCM_OBJ(&stdlib_char_3dP__NAME), stdlib_char_3dP, NULL, NULL);
2090 
2091 static ScmObj stdlib_char_LTP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2092 {
2093   ScmObj c1_scm;
2094   ScmChar c1;
2095   ScmObj c2_scm;
2096   ScmChar c2;
2097   SCM_ENTER_SUBR("char<?");
2098   c1_scm = SCM_ARGREF(0);
2099   if (!SCM_CHARP(c1_scm)) Scm_Error("character required, but got %S", c1_scm);
2100   c1 = SCM_CHAR_VALUE(c1_scm);
2101   c2_scm = SCM_ARGREF(1);
2102   if (!SCM_CHARP(c2_scm)) Scm_Error("character required, but got %S", c2_scm);
2103   c2 = SCM_CHAR_VALUE(c2_scm);
2104   {
2105 {
2106 int SCM_RESULT;
2107  SCM_RESULT = (c1 < c2);
2108 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
2109 }
2110   }
2111 }
2112 
2113 static SCM_DEFINE_STRING_CONST(stdlib_char_LTP__NAME, "char<?", 6, 6);
2114 static SCM_DEFINE_SUBR(stdlib_char_LTP__STUB, 2, 0, SCM_OBJ(&stdlib_char_LTP__NAME), stdlib_char_LTP, NULL, NULL);
2115 
2116 static ScmObj stdlib_char_GTP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2117 {
2118   ScmObj c1_scm;
2119   ScmChar c1;
2120   ScmObj c2_scm;
2121   ScmChar c2;
2122   SCM_ENTER_SUBR("char>?");
2123   c1_scm = SCM_ARGREF(0);
2124   if (!SCM_CHARP(c1_scm)) Scm_Error("character required, but got %S", c1_scm);
2125   c1 = SCM_CHAR_VALUE(c1_scm);
2126   c2_scm = SCM_ARGREF(1);
2127   if (!SCM_CHARP(c2_scm)) Scm_Error("character required, but got %S", c2_scm);
2128   c2 = SCM_CHAR_VALUE(c2_scm);
2129   {
2130 {
2131 int SCM_RESULT;
2132  SCM_RESULT = (c1 > c2);
2133 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
2134 }
2135   }
2136 }
2137 
2138 static SCM_DEFINE_STRING_CONST(stdlib_char_GTP__NAME, "char>?", 6, 6);
2139 static SCM_DEFINE_SUBR(stdlib_char_GTP__STUB, 2, 0, SCM_OBJ(&stdlib_char_GTP__NAME), stdlib_char_GTP, NULL, NULL);
2140 
2141 static ScmObj stdlib_char_LT_3dP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2142 {
2143   ScmObj c1_scm;
2144   ScmChar c1;
2145   ScmObj c2_scm;
2146   ScmChar c2;
2147   SCM_ENTER_SUBR("char<=?");
2148   c1_scm = SCM_ARGREF(0);
2149   if (!SCM_CHARP(c1_scm)) Scm_Error("character required, but got %S", c1_scm);
2150   c1 = SCM_CHAR_VALUE(c1_scm);
2151   c2_scm = SCM_ARGREF(1);
2152   if (!SCM_CHARP(c2_scm)) Scm_Error("character required, but got %S", c2_scm);
2153   c2 = SCM_CHAR_VALUE(c2_scm);
2154   {
2155 {
2156 int SCM_RESULT;
2157  SCM_RESULT = (c1 <= c2);
2158 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
2159 }
2160   }
2161 }
2162 
2163 static SCM_DEFINE_STRING_CONST(stdlib_char_LT_3dP__NAME, "char<=?", 7, 7);
2164 static SCM_DEFINE_SUBR(stdlib_char_LT_3dP__STUB, 2, 0, SCM_OBJ(&stdlib_char_LT_3dP__NAME), stdlib_char_LT_3dP, NULL, NULL);
2165 
2166 static ScmObj stdlib_char_GT_3dP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2167 {
2168   ScmObj c1_scm;
2169   ScmChar c1;
2170   ScmObj c2_scm;
2171   ScmChar c2;
2172   SCM_ENTER_SUBR("char>=?");
2173   c1_scm = SCM_ARGREF(0);
2174   if (!SCM_CHARP(c1_scm)) Scm_Error("character required, but got %S", c1_scm);
2175   c1 = SCM_CHAR_VALUE(c1_scm);
2176   c2_scm = SCM_ARGREF(1);
2177   if (!SCM_CHARP(c2_scm)) Scm_Error("character required, but got %S", c2_scm);
2178   c2 = SCM_CHAR_VALUE(c2_scm);
2179   {
2180 {
2181 int SCM_RESULT;
2182  SCM_RESULT = (c1 >= c2);
2183 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
2184 }
2185   }
2186 }
2187 
2188 static SCM_DEFINE_STRING_CONST(stdlib_char_GT_3dP__NAME, "char>=?", 7, 7);
2189 static SCM_DEFINE_SUBR(stdlib_char_GT_3dP__STUB, 2, 0, SCM_OBJ(&stdlib_char_GT_3dP__NAME), stdlib_char_GT_3dP, NULL, NULL);
2190 
2191 static ScmObj stdlib_char_ci_3dP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2192 {
2193   ScmObj c1_scm;
2194   ScmChar c1;
2195   ScmObj c2_scm;
2196   ScmChar c2;
2197   SCM_ENTER_SUBR("char-ci=?");
2198   c1_scm = SCM_ARGREF(0);
2199   if (!SCM_CHARP(c1_scm)) Scm_Error("character required, but got %S", c1_scm);
2200   c1 = SCM_CHAR_VALUE(c1_scm);
2201   c2_scm = SCM_ARGREF(1);
2202   if (!SCM_CHARP(c2_scm)) Scm_Error("character required, but got %S", c2_scm);
2203   c2 = SCM_CHAR_VALUE(c2_scm);
2204   {
2205 {
2206 int SCM_RESULT;
2207  SCM_RESULT = (SCM_CHAR_UPCASE(c1) == SCM_CHAR_UPCASE(c2));
2208 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
2209 }
2210   }
2211 }
2212 
2213 static SCM_DEFINE_STRING_CONST(stdlib_char_ci_3dP__NAME, "char-ci=?", 9, 9);
2214 static SCM_DEFINE_SUBR(stdlib_char_ci_3dP__STUB, 2, 0, SCM_OBJ(&stdlib_char_ci_3dP__NAME), stdlib_char_ci_3dP, NULL, NULL);
2215 
2216 static ScmObj stdlib_char_ci_LTP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2217 {
2218   ScmObj c1_scm;
2219   ScmChar c1;
2220   ScmObj c2_scm;
2221   ScmChar c2;
2222   SCM_ENTER_SUBR("char-ci<?");
2223   c1_scm = SCM_ARGREF(0);
2224   if (!SCM_CHARP(c1_scm)) Scm_Error("character required, but got %S", c1_scm);
2225   c1 = SCM_CHAR_VALUE(c1_scm);
2226   c2_scm = SCM_ARGREF(1);
2227   if (!SCM_CHARP(c2_scm)) Scm_Error("character required, but got %S", c2_scm);
2228   c2 = SCM_CHAR_VALUE(c2_scm);
2229   {
2230 {
2231 int SCM_RESULT;
2232  SCM_RESULT = (SCM_CHAR_UPCASE(c1)<SCM_CHAR_UPCASE(c2));
2233 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
2234 }
2235   }
2236 }
2237 
2238 static SCM_DEFINE_STRING_CONST(stdlib_char_ci_LTP__NAME, "char-ci<?", 9, 9);
2239 static SCM_DEFINE_SUBR(stdlib_char_ci_LTP__STUB, 2, 0, SCM_OBJ(&stdlib_char_ci_LTP__NAME), stdlib_char_ci_LTP, NULL, NULL);
2240 
2241 static ScmObj stdlib_char_ci_LT_3dP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2242 {
2243   ScmObj c1_scm;
2244   ScmChar c1;
2245   ScmObj c2_scm;
2246   ScmChar c2;
2247   SCM_ENTER_SUBR("char-ci<=?");
2248   c1_scm = SCM_ARGREF(0);
2249   if (!SCM_CHARP(c1_scm)) Scm_Error("character required, but got %S", c1_scm);
2250   c1 = SCM_CHAR_VALUE(c1_scm);
2251   c2_scm = SCM_ARGREF(1);
2252   if (!SCM_CHARP(c2_scm)) Scm_Error("character required, but got %S", c2_scm);
2253   c2 = SCM_CHAR_VALUE(c2_scm);
2254   {
2255 {
2256 int SCM_RESULT;
2257  SCM_RESULT = (SCM_CHAR_UPCASE(c1)<=SCM_CHAR_UPCASE(c2));
2258 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
2259 }
2260   }
2261 }
2262 
2263 static SCM_DEFINE_STRING_CONST(stdlib_char_ci_LT_3dP__NAME, "char-ci<=?", 10, 10);
2264 static SCM_DEFINE_SUBR(stdlib_char_ci_LT_3dP__STUB, 2, 0, SCM_OBJ(&stdlib_char_ci_LT_3dP__NAME), stdlib_char_ci_LT_3dP, NULL, NULL);
2265 
2266 static ScmObj stdlib_char_ci_GTP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2267 {
2268   ScmObj c1_scm;
2269   ScmChar c1;
2270   ScmObj c2_scm;
2271   ScmChar c2;
2272   SCM_ENTER_SUBR("char-ci>?");
2273   c1_scm = SCM_ARGREF(0);
2274   if (!SCM_CHARP(c1_scm)) Scm_Error("character required, but got %S", c1_scm);
2275   c1 = SCM_CHAR_VALUE(c1_scm);
2276   c2_scm = SCM_ARGREF(1);
2277   if (!SCM_CHARP(c2_scm)) Scm_Error("character required, but got %S", c2_scm);
2278   c2 = SCM_CHAR_VALUE(c2_scm);
2279   {
2280 {
2281 int SCM_RESULT;
2282  SCM_RESULT = (SCM_CHAR_UPCASE(c1)>SCM_CHAR_UPCASE(c2));
2283 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
2284 }
2285   }
2286 }
2287 
2288 static SCM_DEFINE_STRING_CONST(stdlib_char_ci_GTP__NAME, "char-ci>?", 9, 9);
2289 static SCM_DEFINE_SUBR(stdlib_char_ci_GTP__STUB, 2, 0, SCM_OBJ(&stdlib_char_ci_GTP__NAME), stdlib_char_ci_GTP, NULL, NULL);
2290 
2291 static ScmObj stdlib_char_ci_GT_3dP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2292 {
2293   ScmObj c1_scm;
2294   ScmChar c1;
2295   ScmObj c2_scm;
2296   ScmChar c2;
2297   SCM_ENTER_SUBR("char-ci>=?");
2298   c1_scm = SCM_ARGREF(0);
2299   if (!SCM_CHARP(c1_scm)) Scm_Error("character required, but got %S", c1_scm);
2300   c1 = SCM_CHAR_VALUE(c1_scm);
2301   c2_scm = SCM_ARGREF(1);
2302   if (!SCM_CHARP(c2_scm)) Scm_Error("character required, but got %S", c2_scm);
2303   c2 = SCM_CHAR_VALUE(c2_scm);
2304   {
2305 {
2306 int SCM_RESULT;
2307  SCM_RESULT = (SCM_CHAR_UPCASE(c1)>=SCM_CHAR_UPCASE(c2));
2308 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
2309 }
2310   }
2311 }
2312 
2313 static SCM_DEFINE_STRING_CONST(stdlib_char_ci_GT_3dP__NAME, "char-ci>=?", 10, 10);
2314 static SCM_DEFINE_SUBR(stdlib_char_ci_GT_3dP__STUB, 2, 0, SCM_OBJ(&stdlib_char_ci_GT_3dP__NAME), stdlib_char_ci_GT_3dP, NULL, NULL);
2315 
2316 static ScmObj stdlib_char_alphabeticP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2317 {
2318   ScmObj c_scm;
2319   ScmChar c;
2320   SCM_ENTER_SUBR("char-alphabetic?");
2321   c_scm = SCM_ARGREF(0);
2322   if (!SCM_CHARP(c_scm)) Scm_Error("character required, but got %S", c_scm);
2323   c = SCM_CHAR_VALUE(c_scm);
2324   {
2325 {
2326 int SCM_RESULT;
2327  SCM_RESULT = (SCM_CHAR_ASCII_P(c)&&isalpha(c));
2328 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
2329 }
2330   }
2331 }
2332 
2333 static SCM_DEFINE_STRING_CONST(stdlib_char_alphabeticP__NAME, "char-alphabetic?", 16, 16);
2334 static SCM_DEFINE_SUBR(stdlib_char_alphabeticP__STUB, 1, 0, SCM_OBJ(&stdlib_char_alphabeticP__NAME), stdlib_char_alphabeticP, NULL, NULL);
2335 
2336 static ScmObj stdlib_char_numericP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2337 {
2338   ScmObj c_scm;
2339   ScmChar c;
2340   SCM_ENTER_SUBR("char-numeric?");
2341   c_scm = SCM_ARGREF(0);
2342   if (!SCM_CHARP(c_scm)) Scm_Error("character required, but got %S", c_scm);
2343   c = SCM_CHAR_VALUE(c_scm);
2344   {
2345 {
2346 int SCM_RESULT;
2347  SCM_RESULT = (SCM_CHAR_ASCII_P(c)&&isdigit(c));
2348 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
2349 }
2350   }
2351 }
2352 
2353 static SCM_DEFINE_STRING_CONST(stdlib_char_numericP__NAME, "char-numeric?", 13, 13);
2354 static SCM_DEFINE_SUBR(stdlib_char_numericP__STUB, 1, 0, SCM_OBJ(&stdlib_char_numericP__NAME), stdlib_char_numericP, NULL, NULL);
2355 
2356 static ScmObj stdlib_char_whitespaceP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2357 {
2358   ScmObj c_scm;
2359   ScmChar c;
2360   SCM_ENTER_SUBR("char-whitespace?");
2361   c_scm = SCM_ARGREF(0);
2362   if (!SCM_CHARP(c_scm)) Scm_Error("character required, but got %S", c_scm);
2363   c = SCM_CHAR_VALUE(c_scm);
2364   {
2365 {
2366 int SCM_RESULT;
2367  SCM_RESULT = (SCM_CHAR_ASCII_P(c)&&isspace(c));
2368 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
2369 }
2370   }
2371 }
2372 
2373 static SCM_DEFINE_STRING_CONST(stdlib_char_whitespaceP__NAME, "char-whitespace?", 16, 16);
2374 static SCM_DEFINE_SUBR(stdlib_char_whitespaceP__STUB, 1, 0, SCM_OBJ(&stdlib_char_whitespaceP__NAME), stdlib_char_whitespaceP, NULL, NULL);
2375 
2376 static ScmObj stdlib_char_upper_caseP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2377 {
2378   ScmObj c_scm;
2379   ScmChar c;
2380   SCM_ENTER_SUBR("char-upper-case?");
2381   c_scm = SCM_ARGREF(0);
2382   if (!SCM_CHARP(c_scm)) Scm_Error("character required, but got %S", c_scm);
2383   c = SCM_CHAR_VALUE(c_scm);
2384   {
2385 {
2386 int SCM_RESULT;
2387 SCM_RESULT = SCM_CHAR_UPPER_P(c);
2388 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
2389 }
2390   }
2391 }
2392 
2393 static SCM_DEFINE_STRING_CONST(stdlib_char_upper_caseP__NAME, "char-upper-case?", 16, 16);
2394 static SCM_DEFINE_SUBR(stdlib_char_upper_caseP__STUB, 1, 0, SCM_OBJ(&stdlib_char_upper_caseP__NAME), stdlib_char_upper_caseP, NULL, NULL);
2395 
2396 static ScmObj stdlib_char_lower_caseP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2397 {
2398   ScmObj c_scm;
2399   ScmChar c;
2400   SCM_ENTER_SUBR("char-lower-case?");
2401   c_scm = SCM_ARGREF(0);
2402   if (!SCM_CHARP(c_scm)) Scm_Error("character required, but got %S", c_scm);
2403   c = SCM_CHAR_VALUE(c_scm);
2404   {
2405 {
2406 int SCM_RESULT;
2407 SCM_RESULT = SCM_CHAR_LOWER_P(c);
2408 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
2409 }
2410   }
2411 }
2412 
2413 static SCM_DEFINE_STRING_CONST(stdlib_char_lower_caseP__NAME, "char-lower-case?", 16, 16);
2414 static SCM_DEFINE_SUBR(stdlib_char_lower_caseP__STUB, 1, 0, SCM_OBJ(&stdlib_char_lower_caseP__NAME), stdlib_char_lower_caseP, NULL, NULL);
2415 
2416 static ScmObj stdlib_char_TOinteger(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2417 {
2418   ScmObj c_scm;
2419   ScmChar c;
2420   SCM_ENTER_SUBR("char->integer");
2421   c_scm = SCM_ARGREF(0);
2422   if (!SCM_CHARP(c_scm)) Scm_Error("character required, but got %S", c_scm);
2423   c = SCM_CHAR_VALUE(c_scm);
2424   {
2425 {
2426 long SCM_RESULT;
2427  SCM_RESULT = ((signed long)c);
2428 SCM_RETURN(Scm_MakeInteger(SCM_RESULT));
2429 }
2430   }
2431 }
2432 
2433 static SCM_DEFINE_STRING_CONST(stdlib_char_TOinteger__NAME, "char->integer", 13, 13);
2434 static SCM_DEFINE_SUBR(stdlib_char_TOinteger__STUB, 1, 0, SCM_OBJ(&stdlib_char_TOinteger__NAME), stdlib_char_TOinteger, NULL, NULL);
2435 
2436 static ScmObj stdlib_integer_TOchar(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2437 {
2438   ScmObj c_scm;
2439   int c;
2440   SCM_ENTER_SUBR("integer->char");
2441   c_scm = SCM_ARGREF(0);
2442   if (!SCM_EXACTP(c_scm)) Scm_Error("C integer required, but got %S", c_scm);
2443   c = Scm_GetInteger(c_scm);
2444   {
2445 {
2446 ScmChar SCM_RESULT;
2447  SCM_RESULT = ((ScmChar)c);
2448 SCM_RETURN(SCM_MAKE_CHAR(SCM_RESULT));
2449 }
2450   }
2451 }
2452 
2453 static SCM_DEFINE_STRING_CONST(stdlib_integer_TOchar__NAME, "integer->char", 13, 13);
2454 static SCM_DEFINE_SUBR(stdlib_integer_TOchar__STUB, 1, 0, SCM_OBJ(&stdlib_integer_TOchar__NAME), stdlib_integer_TOchar, NULL, NULL);
2455 
2456 static ScmObj stdlib_char_upcase(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2457 {
2458   ScmObj c_scm;
2459   ScmChar c;
2460   SCM_ENTER_SUBR("char-upcase");
2461   c_scm = SCM_ARGREF(0);
2462   if (!SCM_CHARP(c_scm)) Scm_Error("character required, but got %S", c_scm);
2463   c = SCM_CHAR_VALUE(c_scm);
2464   {
2465 {
2466 ScmChar SCM_RESULT;
2467 SCM_RESULT = SCM_CHAR_UPCASE(c);
2468 SCM_RETURN(SCM_MAKE_CHAR(SCM_RESULT));
2469 }
2470   }
2471 }
2472 
2473 static SCM_DEFINE_STRING_CONST(stdlib_char_upcase__NAME, "char-upcase", 11, 11);
2474 static SCM_DEFINE_SUBR(stdlib_char_upcase__STUB, 1, 0, SCM_OBJ(&stdlib_char_upcase__NAME), stdlib_char_upcase, NULL, NULL);
2475 
2476 static ScmObj stdlib_char_downcase(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2477 {
2478   ScmObj c_scm;
2479   ScmChar c;
2480   SCM_ENTER_SUBR("char-downcase");
2481   c_scm = SCM_ARGREF(0);
2482   if (!SCM_CHARP(c_scm)) Scm_Error("character required, but got %S", c_scm);
2483   c = SCM_CHAR_VALUE(c_scm);
2484   {
2485 {
2486 ScmChar SCM_RESULT;
2487 SCM_RESULT = SCM_CHAR_DOWNCASE(c);
2488 SCM_RETURN(SCM_MAKE_CHAR(SCM_RESULT));
2489 }
2490   }
2491 }
2492 
2493 static SCM_DEFINE_STRING_CONST(stdlib_char_downcase__NAME, "char-downcase", 13, 13);
2494 static SCM_DEFINE_SUBR(stdlib_char_downcase__STUB, 1, 0, SCM_OBJ(&stdlib_char_downcase__NAME), stdlib_char_downcase, NULL, NULL);
2495 
2496 static ScmObj stdlib_stringP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2497 {
2498   ScmObj obj_scm;
2499   ScmObj obj;
2500   SCM_ENTER_SUBR("string?");
2501   obj_scm = SCM_ARGREF(0);
2502   obj = (obj_scm);
2503   {
2504 {
2505 int SCM_RESULT;
2506 SCM_RESULT = SCM_STRINGP(obj);
2507 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
2508 }
2509   }
2510 }
2511 
2512 static SCM_DEFINE_STRING_CONST(stdlib_stringP__NAME, "string?", 7, 7);
2513 static SCM_DEFINE_SUBR(stdlib_stringP__STUB, 1, 0, SCM_OBJ(&stdlib_stringP__NAME), stdlib_stringP, SCM_MAKE_INT(SCM_VM_STRINGP), NULL);
2514 
2515 static ScmObj stdlib_make_string(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2516 {
2517   ScmObj len_scm;
2518   int len;
2519   ScmObj c_scm;
2520   ScmChar c;
2521   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
2522   SCM_ENTER_SUBR("make-string");
2523   if (Scm_Length(SCM_OPTARGS) > 1)
2524     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
2525   len_scm = SCM_ARGREF(0);
2526   if (!SCM_INTP(len_scm)) Scm_Error("small integer required, but got %S", len_scm);
2527   len = SCM_INT_VALUE(len_scm);
2528   if (SCM_NULLP(SCM_OPTARGS)) c_scm = SCM_MAKE_CHAR(32) /* #\  */;
2529   else {
2530     c_scm = SCM_CAR(SCM_OPTARGS);
2531     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2532   }
2533   if (!SCM_CHARP(c_scm)) Scm_Error("character required, but got %S", c_scm);
2534   c = SCM_CHAR_VALUE(c_scm);
2535   {
2536 {
2537 ScmObj SCM_RESULT;
2538 SCM_RESULT = Scm_MakeFillString(len, c);
2539 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
2540 }
2541   }
2542 }
2543 
2544 static SCM_DEFINE_STRING_CONST(stdlib_make_string__NAME, "make-string", 11, 11);
2545 static SCM_DEFINE_SUBR(stdlib_make_string__STUB, 1, 1, SCM_OBJ(&stdlib_make_string__NAME), stdlib_make_string, NULL, NULL);
2546 
2547 static ScmObj stdlib_string(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2548 {
2549   ScmObj chars_scm;
2550   ScmObj chars;
2551   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
2552   SCM_ENTER_SUBR("string");
2553   chars_scm = SCM_OPTARGS;
2554   chars = (chars_scm);
2555   {
2556 {
2557 ScmObj SCM_RESULT;
2558 SCM_RESULT = Scm_ListToString(chars);
2559 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
2560 }
2561   }
2562 }
2563 
2564 static SCM_DEFINE_STRING_CONST(stdlib_string__NAME, "string", 6, 6);
2565 static SCM_DEFINE_SUBR(stdlib_string__STUB, 0, 1, SCM_OBJ(&stdlib_string__NAME), stdlib_string, NULL, NULL);
2566 
2567 static ScmObj stdlib_string_length(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2568 {
2569   ScmObj str_scm;
2570   ScmString* str;
2571   SCM_ENTER_SUBR("string-length");
2572   str_scm = SCM_ARGREF(0);
2573   if (!SCM_STRINGP(str_scm)) Scm_Error("string required, but got %S", str_scm);
2574   str = SCM_STRING(str_scm);
2575   {
2576 {
2577 int SCM_RESULT;
2578  SCM_RESULT = (SCM_STRING_BODY_LENGTH(SCM_STRING_BODY(str)));
2579 SCM_RETURN(SCM_MAKE_INT(SCM_RESULT));
2580 }
2581   }
2582 }
2583 
2584 static SCM_DEFINE_STRING_CONST(stdlib_string_length__NAME, "string-length", 13, 13);
2585 static SCM_DEFINE_SUBR(stdlib_string_length__STUB, 1, 0, SCM_OBJ(&stdlib_string_length__NAME), stdlib_string_length, NULL, NULL);
2586 
2587 static ScmObj stdlib_string_ref(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2588 {
2589   ScmObj str_scm;
2590   ScmString* str;
2591   ScmObj k_scm;
2592   int k;
2593   ScmObj fallback_scm;
2594   ScmObj fallback;
2595   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
2596   SCM_ENTER_SUBR("string-ref");
2597   if (Scm_Length(SCM_OPTARGS) > 1)
2598     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
2599   str_scm = SCM_ARGREF(0);
2600   if (!SCM_STRINGP(str_scm)) Scm_Error("string required, but got %S", str_scm);
2601   str = SCM_STRING(str_scm);
2602   k_scm = SCM_ARGREF(1);
2603   if (!SCM_INTP(k_scm)) Scm_Error("small integer required, but got %S", k_scm);
2604   k = SCM_INT_VALUE(k_scm);
2605   if (SCM_NULLP(SCM_OPTARGS)) fallback_scm = SCM_UNBOUND;
2606   else {
2607     fallback_scm = SCM_CAR(SCM_OPTARGS);
2608     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2609   }
2610   fallback = (fallback_scm);
2611   {
2612 {
2613 ScmObj SCM_RESULT;
2614 ScmChar r = Scm_StringRef(str, k, SCM_UNBOUNDP(fallback));
2615 SCM_RESULT = (r == SCM_CHAR_INVALID)? fallback : SCM_MAKE_CHAR(r);
2616 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
2617 }
2618   }
2619 }
2620 
2621 static SCM_DEFINE_STRING_CONST(stdlib_string_ref__NAME, "string-ref", 10, 10);
2622 static SCM_DEFINE_SUBR(stdlib_string_ref__STUB, 2, 1, SCM_OBJ(&stdlib_string_ref__NAME), stdlib_string_ref, NULL, NULL);
2623 
2624 static ScmObj stdlib_string_setX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2625 {
2626   ScmObj str_scm;
2627   ScmString* str;
2628   ScmObj k_scm;
2629   int k;
2630   ScmObj c_scm;
2631   ScmChar c;
2632   SCM_ENTER_SUBR("string-set!");
2633   str_scm = SCM_ARGREF(0);
2634   if (!SCM_STRINGP(str_scm)) Scm_Error("string required, but got %S", str_scm);
2635   str = SCM_STRING(str_scm);
2636   k_scm = SCM_ARGREF(1);
2637   if (!SCM_INTP(k_scm)) Scm_Error("small integer required, but got %S", k_scm);
2638   k = SCM_INT_VALUE(k_scm);
2639   c_scm = SCM_ARGREF(2);
2640   if (!SCM_CHARP(c_scm)) Scm_Error("character required, but got %S", c_scm);
2641   c = SCM_CHAR_VALUE(c_scm);
2642   {
2643 ScmObj r = Scm_StringSet(str, k, c);
2644 if (r == SCM_FALSE) Scm_Error("argument out of range: %d", k);
2645 SCM_RETURN(SCM_UNDEFINED);
2646   }
2647 }
2648 
2649 static SCM_DEFINE_STRING_CONST(stdlib_string_setX__NAME, "string-set!", 11, 11);
2650 static SCM_DEFINE_SUBR(stdlib_string_setX__STUB, 3, 0, SCM_OBJ(&stdlib_string_setX__NAME), stdlib_string_setX, NULL, NULL);
2651 
2652 static ScmObj stdlib_string_3dP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2653 {
2654   ScmObj s1_scm;
2655   ScmString* s1;
2656   ScmObj s2_scm;
2657   ScmString* s2;
2658   SCM_ENTER_SUBR("string=?");
2659   s1_scm = SCM_ARGREF(0);
2660   if (!SCM_STRINGP(s1_scm)) Scm_Error("string required, but got %S", s1_scm);
2661   s1 = SCM_STRING(s1_scm);
2662   s2_scm = SCM_ARGREF(1);
2663   if (!SCM_STRINGP(s2_scm)) Scm_Error("string required, but got %S", s2_scm);
2664   s2 = SCM_STRING(s2_scm);
2665   {
2666 {
2667 int SCM_RESULT;
2668 SCM_RESULT = Scm_StringEqual(s1, s2);
2669 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
2670 }
2671   }
2672 }
2673 
2674 static SCM_DEFINE_STRING_CONST(stdlib_string_3dP__NAME, "string=?", 8, 8);
2675 static SCM_DEFINE_SUBR(stdlib_string_3dP__STUB, 2, 0, SCM_OBJ(&stdlib_string_3dP__NAME), stdlib_string_3dP, NULL, NULL);
2676 
2677 static ScmObj stdlib_string_LTP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2678 {
2679   ScmObj s1_scm;
2680   ScmString* s1;
2681   ScmObj s2_scm;
2682   ScmString* s2;
2683   SCM_ENTER_SUBR("string<?");
2684   s1_scm = SCM_ARGREF(0);
2685   if (!SCM_STRINGP(s1_scm)) Scm_Error("string required, but got %S", s1_scm);
2686   s1 = SCM_STRING(s1_scm);
2687   s2_scm = SCM_ARGREF(1);
2688   if (!SCM_STRINGP(s2_scm)) Scm_Error("string required, but got %S", s2_scm);
2689   s2 = SCM_STRING(s2_scm);
2690   {
2691 {
2692 int SCM_RESULT;
2693  SCM_RESULT = (Scm_StringCmp(s1, s2) < 0);
2694 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
2695 }
2696   }
2697 }
2698 
2699 static SCM_DEFINE_STRING_CONST(stdlib_string_LTP__NAME, "string<?", 8, 8);
2700 static SCM_DEFINE_SUBR(stdlib_string_LTP__STUB, 2, 0, SCM_OBJ(&stdlib_string_LTP__NAME), stdlib_string_LTP, NULL, NULL);
2701 
2702 static ScmObj stdlib_string_LT_3dP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2703 {
2704   ScmObj s1_scm;
2705   ScmString* s1;
2706   ScmObj s2_scm;
2707   ScmString* s2;
2708   SCM_ENTER_SUBR("string<=?");
2709   s1_scm = SCM_ARGREF(0);
2710   if (!SCM_STRINGP(s1_scm)) Scm_Error("string required, but got %S", s1_scm);
2711   s1 = SCM_STRING(s1_scm);
2712   s2_scm = SCM_ARGREF(1);
2713   if (!SCM_STRINGP(s2_scm)) Scm_Error("string required, but got %S", s2_scm);
2714   s2 = SCM_STRING(s2_scm);
2715   {
2716 {
2717 int SCM_RESULT;
2718  SCM_RESULT = (Scm_StringCmp(s1, s2) <= 0);
2719 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
2720 }
2721   }
2722 }
2723 
2724 static SCM_DEFINE_STRING_CONST(stdlib_string_LT_3dP__NAME, "string<=?", 9, 9);
2725 static SCM_DEFINE_SUBR(stdlib_string_LT_3dP__STUB, 2, 0, SCM_OBJ(&stdlib_string_LT_3dP__NAME), stdlib_string_LT_3dP, NULL, NULL);
2726 
2727 static ScmObj stdlib_string_GTP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2728 {
2729   ScmObj s1_scm;
2730   ScmString* s1;
2731   ScmObj s2_scm;
2732   ScmString* s2;
2733   SCM_ENTER_SUBR("string>?");
2734   s1_scm = SCM_ARGREF(0);
2735   if (!SCM_STRINGP(s1_scm)) Scm_Error("string required, but got %S", s1_scm);
2736   s1 = SCM_STRING(s1_scm);
2737   s2_scm = SCM_ARGREF(1);
2738   if (!SCM_STRINGP(s2_scm)) Scm_Error("string required, but got %S", s2_scm);
2739   s2 = SCM_STRING(s2_scm);
2740   {
2741 {
2742 int SCM_RESULT;
2743  SCM_RESULT = (Scm_StringCmp(s1, s2) > 0);
2744 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
2745 }
2746   }
2747 }
2748 
2749 static SCM_DEFINE_STRING_CONST(stdlib_string_GTP__NAME, "string>?", 8, 8);
2750 static SCM_DEFINE_SUBR(stdlib_string_GTP__STUB, 2, 0, SCM_OBJ(&stdlib_string_GTP__NAME), stdlib_string_GTP, NULL, NULL);
2751 
2752 static ScmObj stdlib_string_GT_3dP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2753 {
2754   ScmObj s1_scm;
2755   ScmString* s1;
2756   ScmObj s2_scm;
2757   ScmString* s2;
2758   SCM_ENTER_SUBR("string>=?");
2759   s1_scm = SCM_ARGREF(0);
2760   if (!SCM_STRINGP(s1_scm)) Scm_Error("string required, but got %S", s1_scm);
2761   s1 = SCM_STRING(s1_scm);
2762   s2_scm = SCM_ARGREF(1);
2763   if (!SCM_STRINGP(s2_scm)) Scm_Error("string required, but got %S", s2_scm);
2764   s2 = SCM_STRING(s2_scm);
2765   {
2766 {
2767 int SCM_RESULT;
2768  SCM_RESULT = (Scm_StringCmp(s1, s2) >= 0);
2769 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
2770 }
2771   }
2772 }
2773 
2774 static SCM_DEFINE_STRING_CONST(stdlib_string_GT_3dP__NAME, "string>=?", 9, 9);
2775 static SCM_DEFINE_SUBR(stdlib_string_GT_3dP__STUB, 2, 0, SCM_OBJ(&stdlib_string_GT_3dP__NAME), stdlib_string_GT_3dP, NULL, NULL);
2776 
2777 static ScmObj stdlib_string_ci_3dP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2778 {
2779   ScmObj s1_scm;
2780   ScmString* s1;
2781   ScmObj s2_scm;
2782   ScmString* s2;
2783   SCM_ENTER_SUBR("string-ci=?");
2784   s1_scm = SCM_ARGREF(0);
2785   if (!SCM_STRINGP(s1_scm)) Scm_Error("string required, but got %S", s1_scm);
2786   s1 = SCM_STRING(s1_scm);
2787   s2_scm = SCM_ARGREF(1);
2788   if (!SCM_STRINGP(s2_scm)) Scm_Error("string required, but got %S", s2_scm);
2789   s2 = SCM_STRING(s2_scm);
2790   {
2791 {
2792 int SCM_RESULT;
2793  SCM_RESULT = (Scm_StringCiCmp(s1, s2) == 0);
2794 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
2795 }
2796   }
2797 }
2798 
2799 static SCM_DEFINE_STRING_CONST(stdlib_string_ci_3dP__NAME, "string-ci=?", 11, 11);
2800 static SCM_DEFINE_SUBR(stdlib_string_ci_3dP__STUB, 2, 0, SCM_OBJ(&stdlib_string_ci_3dP__NAME), stdlib_string_ci_3dP, NULL, NULL);
2801 
2802 static ScmObj stdlib_string_ci_LTP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2803 {
2804   ScmObj s1_scm;
2805   ScmString* s1;
2806   ScmObj s2_scm;
2807   ScmString* s2;
2808   SCM_ENTER_SUBR("string-ci<?");
2809   s1_scm = SCM_ARGREF(0);
2810   if (!SCM_STRINGP(s1_scm)) Scm_Error("string required, but got %S", s1_scm);
2811   s1 = SCM_STRING(s1_scm);
2812   s2_scm = SCM_ARGREF(1);
2813   if (!SCM_STRINGP(s2_scm)) Scm_Error("string required, but got %S", s2_scm);
2814   s2 = SCM_STRING(s2_scm);
2815   {
2816 {
2817 int SCM_RESULT;
2818  SCM_RESULT = (Scm_StringCiCmp(s1, s2) < 0);
2819 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
2820 }
2821   }
2822 }
2823 
2824 static SCM_DEFINE_STRING_CONST(stdlib_string_ci_LTP__NAME, "string-ci<?", 11, 11);
2825 static SCM_DEFINE_SUBR(stdlib_string_ci_LTP__STUB, 2, 0, SCM_OBJ(&stdlib_string_ci_LTP__NAME), stdlib_string_ci_LTP, NULL, NULL);
2826 
2827 static ScmObj stdlib_string_ci_LT_3dP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2828 {
2829   ScmObj s1_scm;
2830   ScmString* s1;
2831   ScmObj s2_scm;
2832   ScmString* s2;
2833   SCM_ENTER_SUBR("string-ci<=?");
2834   s1_scm = SCM_ARGREF(0);
2835   if (!SCM_STRINGP(s1_scm)) Scm_Error("string required, but got %S", s1_scm);
2836   s1 = SCM_STRING(s1_scm);
2837   s2_scm = SCM_ARGREF(1);
2838   if (!SCM_STRINGP(s2_scm)) Scm_Error("string required, but got %S", s2_scm);
2839   s2 = SCM_STRING(s2_scm);
2840   {
2841 {
2842 int SCM_RESULT;
2843  SCM_RESULT = (Scm_StringCiCmp(s1, s2) <= 0);
2844 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
2845 }
2846   }
2847 }
2848 
2849 static SCM_DEFINE_STRING_CONST(stdlib_string_ci_LT_3dP__NAME, "string-ci<=?", 12, 12);
2850 static SCM_DEFINE_SUBR(stdlib_string_ci_LT_3dP__STUB, 2, 0, SCM_OBJ(&stdlib_string_ci_LT_3dP__NAME), stdlib_string_ci_LT_3dP, NULL, NULL);
2851 
2852 static ScmObj stdlib_string_ci_GTP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2853 {
2854   ScmObj s1_scm;
2855   ScmString* s1;
2856   ScmObj s2_scm;
2857   ScmString* s2;
2858   SCM_ENTER_SUBR("string-ci>?");
2859   s1_scm = SCM_ARGREF(0);
2860   if (!SCM_STRINGP(s1_scm)) Scm_Error("string required, but got %S", s1_scm);
2861   s1 = SCM_STRING(s1_scm);
2862   s2_scm = SCM_ARGREF(1);
2863   if (!SCM_STRINGP(s2_scm)) Scm_Error("string required, but got %S", s2_scm);
2864   s2 = SCM_STRING(s2_scm);
2865   {
2866 {
2867 int SCM_RESULT;
2868  SCM_RESULT = (Scm_StringCiCmp(s1, s2) > 0);
2869 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
2870 }
2871   }
2872 }
2873 
2874 static SCM_DEFINE_STRING_CONST(stdlib_string_ci_GTP__NAME, "string-ci>?", 11, 11);
2875 static SCM_DEFINE_SUBR(stdlib_string_ci_GTP__STUB, 2, 0, SCM_OBJ(&stdlib_string_ci_GTP__NAME), stdlib_string_ci_GTP, NULL, NULL);
2876 
2877 static ScmObj stdlib_string_ci_GT_3dP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2878 {
2879   ScmObj s1_scm;
2880   ScmString* s1;
2881   ScmObj s2_scm;
2882   ScmString* s2;
2883   SCM_ENTER_SUBR("string-ci>=?");
2884   s1_scm = SCM_ARGREF(0);
2885   if (!SCM_STRINGP(s1_scm)) Scm_Error("string required, but got %S", s1_scm);
2886   s1 = SCM_STRING(s1_scm);
2887   s2_scm = SCM_ARGREF(1);
2888   if (!SCM_STRINGP(s2_scm)) Scm_Error("string required, but got %S", s2_scm);
2889   s2 = SCM_STRING(s2_scm);
2890   {
2891 {
2892 int SCM_RESULT;
2893  SCM_RESULT = (Scm_StringCiCmp(s1, s2) >= 0);
2894 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
2895 }
2896   }
2897 }
2898 
2899 static SCM_DEFINE_STRING_CONST(stdlib_string_ci_GT_3dP__NAME, "string-ci>=?", 12, 12);
2900 static SCM_DEFINE_SUBR(stdlib_string_ci_GT_3dP__STUB, 2, 0, SCM_OBJ(&stdlib_string_ci_GT_3dP__NAME), stdlib_string_ci_GT_3dP, NULL, NULL);
2901 
2902 static ScmObj stdlib_substring(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2903 {
2904   ScmObj str_scm;
2905   ScmString* str;
2906   ScmObj start_scm;
2907   int start;
2908   ScmObj end_scm;
2909   int end;
2910   SCM_ENTER_SUBR("substring");
2911   str_scm = SCM_ARGREF(0);
2912   if (!SCM_STRINGP(str_scm)) Scm_Error("string required, but got %S", str_scm);
2913   str = SCM_STRING(str_scm);
2914   start_scm = SCM_ARGREF(1);
2915   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
2916   start = SCM_INT_VALUE(start_scm);
2917   end_scm = SCM_ARGREF(2);
2918   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
2919   end = SCM_INT_VALUE(end_scm);
2920   {
2921 {
2922 ScmObj SCM_RESULT;
2923 SCM_RESULT = Scm_Substring(str, start, end);
2924 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
2925 }
2926   }
2927 }
2928 
2929 static SCM_DEFINE_STRING_CONST(stdlib_substring__NAME, "substring", 9, 9);
2930 static SCM_DEFINE_SUBR(stdlib_substring__STUB, 3, 0, SCM_OBJ(&stdlib_substring__NAME), stdlib_substring, NULL, NULL);
2931 
2932 static ScmObj stdlib_string_append(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2933 {
2934   ScmObj args_scm;
2935   ScmObj args;
2936   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
2937   SCM_ENTER_SUBR("string-append");
2938   args_scm = SCM_OPTARGS;
2939   args = (args_scm);
2940   {
2941 {
2942 ScmObj SCM_RESULT;
2943 SCM_RESULT = Scm_StringAppend(args);
2944 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
2945 }
2946   }
2947 }
2948 
2949 static SCM_DEFINE_STRING_CONST(stdlib_string_append__NAME, "string-append", 13, 13);
2950 static SCM_DEFINE_SUBR(stdlib_string_append__STUB, 0, 1, SCM_OBJ(&stdlib_string_append__NAME), stdlib_string_append, NULL, NULL);
2951 
2952 static ScmObj stdlib_string_TOlist(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2953 {
2954   ScmObj str_scm;
2955   ScmString* str;
2956   ScmObj start_scm;
2957   ScmObj start;
2958   ScmObj end_scm;
2959   ScmObj end;
2960   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
2961   SCM_ENTER_SUBR("string->list");
2962   if (Scm_Length(SCM_OPTARGS) > 2)
2963     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
2964   str_scm = SCM_ARGREF(0);
2965   if (!SCM_STRINGP(str_scm)) Scm_Error("string required, but got %S", str_scm);
2966   str = SCM_STRING(str_scm);
2967   if (SCM_NULLP(SCM_OPTARGS)) start_scm = SCM_UNBOUND;
2968   else {
2969     start_scm = SCM_CAR(SCM_OPTARGS);
2970     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2971   }
2972   start = (start_scm);
2973   if (SCM_NULLP(SCM_OPTARGS)) end_scm = SCM_UNBOUND;
2974   else {
2975     end_scm = SCM_CAR(SCM_OPTARGS);
2976     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
2977   }
2978   end = (end_scm);
2979   {
2980   ScmObj xstr = Scm_MaybeSubstring(str, start, end);
2981   SCM_RETURN(Scm_StringToList(SCM_STRING(xstr)));
2982   }
2983 }
2984 
2985 static SCM_DEFINE_STRING_CONST(stdlib_string_TOlist__NAME, "string->list", 12, 12);
2986 static SCM_DEFINE_SUBR(stdlib_string_TOlist__STUB, 1, 1, SCM_OBJ(&stdlib_string_TOlist__NAME), stdlib_string_TOlist, NULL, NULL);
2987 
2988 static ScmObj stdlib_list_TOstring(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
2989 {
2990   ScmObj list_scm;
2991   ScmObj list;
2992   SCM_ENTER_SUBR("list->string");
2993   list_scm = SCM_ARGREF(0);
2994   if (!SCM_LISTP(list_scm)) Scm_Error("list required, but got %S", list_scm);
2995   list = (list_scm);
2996   {
2997 {
2998 ScmObj SCM_RESULT;
2999 SCM_RESULT = Scm_ListToString(list);
3000 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
3001 }
3002   }
3003 }
3004 
3005 static SCM_DEFINE_STRING_CONST(stdlib_list_TOstring__NAME, "list->string", 12, 12);
3006 static SCM_DEFINE_SUBR(stdlib_list_TOstring__STUB, 1, 0, SCM_OBJ(&stdlib_list_TOstring__NAME), stdlib_list_TOstring, NULL, NULL);
3007 
3008 static ScmObj stdlib_string_copy(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3009 {
3010   ScmObj str_scm;
3011   ScmString* str;
3012   ScmObj start_scm;
3013   ScmObj start;
3014   ScmObj end_scm;
3015   ScmObj end;
3016   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3017   SCM_ENTER_SUBR("string-copy");
3018   if (Scm_Length(SCM_OPTARGS) > 2)
3019     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3020   str_scm = SCM_ARGREF(0);
3021   if (!SCM_STRINGP(str_scm)) Scm_Error("string required, but got %S", str_scm);
3022   str = SCM_STRING(str_scm);
3023   if (SCM_NULLP(SCM_OPTARGS)) start_scm = SCM_UNBOUND;
3024   else {
3025     start_scm = SCM_CAR(SCM_OPTARGS);
3026     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3027   }
3028   start = (start_scm);
3029   if (SCM_NULLP(SCM_OPTARGS)) end_scm = SCM_UNBOUND;
3030   else {
3031     end_scm = SCM_CAR(SCM_OPTARGS);
3032     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3033   }
3034   end = (end_scm);
3035   {
3036   ScmObj xstr = Scm_MaybeSubstring(str, start, end);
3037   SCM_RETURN(Scm_CopyString(SCM_STRING(xstr)));
3038   }
3039 }
3040 
3041 static SCM_DEFINE_STRING_CONST(stdlib_string_copy__NAME, "string-copy", 11, 11);
3042 static SCM_DEFINE_SUBR(stdlib_string_copy__STUB, 1, 1, SCM_OBJ(&stdlib_string_copy__NAME), stdlib_string_copy, NULL, NULL);
3043 
3044 static ScmObj stdlib_string_fillX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3045 {
3046   ScmObj str_scm;
3047   ScmString* str;
3048   ScmObj c_scm;
3049   ScmChar c;
3050   ScmObj start_scm;
3051   ScmObj start;
3052   ScmObj end_scm;
3053   ScmObj end;
3054   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3055   SCM_ENTER_SUBR("string-fill!");
3056   if (Scm_Length(SCM_OPTARGS) > 2)
3057     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3058   str_scm = SCM_ARGREF(0);
3059   if (!SCM_STRINGP(str_scm)) Scm_Error("string required, but got %S", str_scm);
3060   str = SCM_STRING(str_scm);
3061   c_scm = SCM_ARGREF(1);
3062   if (!SCM_CHARP(c_scm)) Scm_Error("character required, but got %S", c_scm);
3063   c = SCM_CHAR_VALUE(c_scm);
3064   if (SCM_NULLP(SCM_OPTARGS)) start_scm = SCM_UNBOUND;
3065   else {
3066     start_scm = SCM_CAR(SCM_OPTARGS);
3067     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3068   }
3069   start = (start_scm);
3070   if (SCM_NULLP(SCM_OPTARGS)) end_scm = SCM_UNBOUND;
3071   else {
3072     end_scm = SCM_CAR(SCM_OPTARGS);
3073     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3074   }
3075   end = (end_scm);
3076   {
3077 {
3078 ScmObj SCM_RESULT;
3079 SCM_RESULT = Scm_StringFill(str, c, start, end);
3080 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
3081 }
3082   }
3083 }
3084 
3085 static SCM_DEFINE_STRING_CONST(stdlib_string_fillX__NAME, "string-fill!", 12, 12);
3086 static SCM_DEFINE_SUBR(stdlib_string_fillX__STUB, 2, 1, SCM_OBJ(&stdlib_string_fillX__NAME), stdlib_string_fillX, NULL, NULL);
3087 
3088 static ScmObj stdlib_vectorP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3089 {
3090   ScmObj obj_scm;
3091   ScmObj obj;
3092   SCM_ENTER_SUBR("vector?");
3093   obj_scm = SCM_ARGREF(0);
3094   obj = (obj_scm);
3095   {
3096 {
3097 int SCM_RESULT;
3098 SCM_RESULT = SCM_VECTORP(obj);
3099 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
3100 }
3101   }
3102 }
3103 
3104 static SCM_DEFINE_STRING_CONST(stdlib_vectorP__NAME, "vector?", 7, 7);
3105 static SCM_DEFINE_SUBR(stdlib_vectorP__STUB, 1, 0, SCM_OBJ(&stdlib_vectorP__NAME), stdlib_vectorP, SCM_MAKE_INT(SCM_VM_VECTORP), NULL);
3106 
3107 static ScmObj stdlib_make_vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3108 {
3109   ScmObj k_scm;
3110   int k;
3111   ScmObj fill_scm;
3112   ScmObj fill;
3113   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3114   SCM_ENTER_SUBR("make-vector");
3115   if (Scm_Length(SCM_OPTARGS) > 1)
3116     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3117   k_scm = SCM_ARGREF(0);
3118   if (!SCM_INTP(k_scm)) Scm_Error("small integer required, but got %S", k_scm);
3119   k = SCM_INT_VALUE(k_scm);
3120   if (SCM_NULLP(SCM_OPTARGS)) fill_scm = SCM_UNBOUND;
3121   else {
3122     fill_scm = SCM_CAR(SCM_OPTARGS);
3123     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3124   }
3125   fill = (fill_scm);
3126   {
3127 {
3128 ScmObj SCM_RESULT;
3129 SCM_RESULT = Scm_MakeVector(k, fill);
3130 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
3131 }
3132   }
3133 }
3134 
3135 static SCM_DEFINE_STRING_CONST(stdlib_make_vector__NAME, "make-vector", 11, 11);
3136 static SCM_DEFINE_SUBR(stdlib_make_vector__STUB, 1, 1, SCM_OBJ(&stdlib_make_vector__NAME), stdlib_make_vector, NULL, NULL);
3137 
3138 static ScmObj stdlib_vector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3139 {
3140   ScmObj args_scm;
3141   ScmObj args;
3142   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3143   SCM_ENTER_SUBR("vector");
3144   args_scm = SCM_OPTARGS;
3145   args = (args_scm);
3146   {
3147 {
3148 ScmObj SCM_RESULT;
3149  SCM_RESULT = (Scm_ListToVector(args, 0, -1));
3150 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
3151 }
3152   }
3153 }
3154 
3155 static SCM_DEFINE_STRING_CONST(stdlib_vector__NAME, "vector", 6, 6);
3156 static SCM_DEFINE_SUBR(stdlib_vector__STUB, 0, 1, SCM_OBJ(&stdlib_vector__NAME), stdlib_vector, SCM_MAKE_INT(SCM_VM_VEC), NULL);
3157 
3158 static ScmObj stdlib_vector_length(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3159 {
3160   ScmObj vec_scm;
3161   ScmVector* vec;
3162   SCM_ENTER_SUBR("vector-length");
3163   vec_scm = SCM_ARGREF(0);
3164   if (!SCM_VECTORP(vec_scm)) Scm_Error("vector required, but got %S", vec_scm);
3165   vec = SCM_VECTOR(vec_scm);
3166   {
3167 {
3168 int SCM_RESULT;
3169 SCM_RESULT = SCM_VECTOR_SIZE(vec);
3170 SCM_RETURN(SCM_MAKE_INT(SCM_RESULT));
3171 }
3172   }
3173 }
3174 
3175 static SCM_DEFINE_STRING_CONST(stdlib_vector_length__NAME, "vector-length", 13, 13);
3176 static SCM_DEFINE_SUBR(stdlib_vector_length__STUB, 1, 0, SCM_OBJ(&stdlib_vector_length__NAME), stdlib_vector_length, SCM_MAKE_INT(SCM_VM_VEC_LEN), NULL);
3177 
3178 static ScmObj stdlib_vector_ref(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3179 {
3180   ScmObj vec_scm;
3181   ScmVector* vec;
3182   ScmObj k_scm;
3183   int k;
3184   ScmObj fallback_scm;
3185   ScmObj fallback;
3186   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3187   SCM_ENTER_SUBR("vector-ref");
3188   if (Scm_Length(SCM_OPTARGS) > 1)
3189     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3190   vec_scm = SCM_ARGREF(0);
3191   if (!SCM_VECTORP(vec_scm)) Scm_Error("vector required, but got %S", vec_scm);
3192   vec = SCM_VECTOR(vec_scm);
3193   k_scm = SCM_ARGREF(1);
3194   if (!SCM_INTP(k_scm)) Scm_Error("small integer required, but got %S", k_scm);
3195   k = SCM_INT_VALUE(k_scm);
3196   if (SCM_NULLP(SCM_OPTARGS)) fallback_scm = SCM_UNBOUND;
3197   else {
3198     fallback_scm = SCM_CAR(SCM_OPTARGS);
3199     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3200   }
3201   fallback = (fallback_scm);
3202   {
3203 {
3204 ScmObj SCM_RESULT;
3205 SCM_RESULT = Scm_VectorRef(vec, k, fallback);
3206 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
3207 }
3208   }
3209 }
3210 
3211 static SCM_DEFINE_STRING_CONST(stdlib_vector_ref__NAME, "vector-ref", 10, 10);
3212 static SCM_DEFINE_SUBR(stdlib_vector_ref__STUB, 2, 1, SCM_OBJ(&stdlib_vector_ref__NAME), stdlib_vector_ref, NULL, NULL);
3213 
3214 static ScmObj stdlib_vector_setX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3215 {
3216   ScmObj vec_scm;
3217   ScmVector* vec;
3218   ScmObj k_scm;
3219   int k;
3220   ScmObj obj_scm;
3221   ScmObj obj;
3222   SCM_ENTER_SUBR("vector-set!");
3223   vec_scm = SCM_ARGREF(0);
3224   if (!SCM_VECTORP(vec_scm)) Scm_Error("vector required, but got %S", vec_scm);
3225   vec = SCM_VECTOR(vec_scm);
3226   k_scm = SCM_ARGREF(1);
3227   if (!SCM_INTP(k_scm)) Scm_Error("small integer required, but got %S", k_scm);
3228   k = SCM_INT_VALUE(k_scm);
3229   obj_scm = SCM_ARGREF(2);
3230   obj = (obj_scm);
3231   {
3232 Scm_VectorSet(vec, k, obj);
3233 SCM_RETURN(SCM_UNDEFINED);
3234   }
3235 }
3236 
3237 static SCM_DEFINE_STRING_CONST(stdlib_vector_setX__NAME, "vector-set!", 11, 11);
3238 static SCM_DEFINE_SUBR(stdlib_vector_setX__STUB, 3, 0, SCM_OBJ(&stdlib_vector_setX__NAME), stdlib_vector_setX, NULL, NULL);
3239 
3240 static ScmObj stdlib_vector_TOlist(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3241 {
3242   ScmObj vec_scm;
3243   ScmVector* vec;
3244   ScmObj start_scm;
3245   int start;
3246   ScmObj end_scm;
3247   int end;
3248   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3249   SCM_ENTER_SUBR("vector->list");
3250   if (Scm_Length(SCM_OPTARGS) > 2)
3251     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3252   vec_scm = SCM_ARGREF(0);
3253   if (!SCM_VECTORP(vec_scm)) Scm_Error("vector required, but got %S", vec_scm);
3254   vec = SCM_VECTOR(vec_scm);
3255   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
3256   else {
3257     start_scm = SCM_CAR(SCM_OPTARGS);
3258     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3259   }
3260   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
3261   start = SCM_INT_VALUE(start_scm);
3262   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
3263   else {
3264     end_scm = SCM_CAR(SCM_OPTARGS);
3265     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3266   }
3267   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
3268   end = SCM_INT_VALUE(end_scm);
3269   {
3270 {
3271 ScmObj SCM_RESULT;
3272 SCM_RESULT = Scm_VectorToList(vec, start, end);
3273 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
3274 }
3275   }
3276 }
3277 
3278 static SCM_DEFINE_STRING_CONST(stdlib_vector_TOlist__NAME, "vector->list", 12, 12);
3279 static SCM_DEFINE_SUBR(stdlib_vector_TOlist__STUB, 1, 1, SCM_OBJ(&stdlib_vector_TOlist__NAME), stdlib_vector_TOlist, NULL, NULL);
3280 
3281 static ScmObj stdlib_list_TOvector(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3282 {
3283   ScmObj list_scm;
3284   ScmObj list;
3285   ScmObj start_scm;
3286   int start;
3287   ScmObj end_scm;
3288   int end;
3289   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3290   SCM_ENTER_SUBR("list->vector");
3291   if (Scm_Length(SCM_OPTARGS) > 2)
3292     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3293   list_scm = SCM_ARGREF(0);
3294   if (!SCM_LISTP(list_scm)) Scm_Error("list required, but got %S", list_scm);
3295   list = (list_scm);
3296   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
3297   else {
3298     start_scm = SCM_CAR(SCM_OPTARGS);
3299     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3300   }
3301   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
3302   start = SCM_INT_VALUE(start_scm);
3303   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
3304   else {
3305     end_scm = SCM_CAR(SCM_OPTARGS);
3306     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3307   }
3308   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
3309   end = SCM_INT_VALUE(end_scm);
3310   {
3311 {
3312 ScmObj SCM_RESULT;
3313 SCM_RESULT = Scm_ListToVector(list, start, end);
3314 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
3315 }
3316   }
3317 }
3318 
3319 static SCM_DEFINE_STRING_CONST(stdlib_list_TOvector__NAME, "list->vector", 12, 12);
3320 static SCM_DEFINE_SUBR(stdlib_list_TOvector__STUB, 1, 1, SCM_OBJ(&stdlib_list_TOvector__NAME), stdlib_list_TOvector, NULL, NULL);
3321 
3322 static ScmObj stdlib_vector_fillX(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3323 {
3324   ScmObj vec_scm;
3325   ScmVector* vec;
3326   ScmObj fill_scm;
3327   ScmObj fill;
3328   ScmObj start_scm;
3329   int start;
3330   ScmObj end_scm;
3331   int end;
3332   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3333   SCM_ENTER_SUBR("vector-fill!");
3334   if (Scm_Length(SCM_OPTARGS) > 2)
3335     Scm_Error("too many arguments: up to 2 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3336   vec_scm = SCM_ARGREF(0);
3337   if (!SCM_VECTORP(vec_scm)) Scm_Error("vector required, but got %S", vec_scm);
3338   vec = SCM_VECTOR(vec_scm);
3339   fill_scm = SCM_ARGREF(1);
3340   fill = (fill_scm);
3341   if (SCM_NULLP(SCM_OPTARGS)) start_scm = Scm_MakeInteger(0);
3342   else {
3343     start_scm = SCM_CAR(SCM_OPTARGS);
3344     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3345   }
3346   if (!SCM_INTP(start_scm)) Scm_Error("small integer required, but got %S", start_scm);
3347   start = SCM_INT_VALUE(start_scm);
3348   if (SCM_NULLP(SCM_OPTARGS)) end_scm = Scm_MakeInteger(-1);
3349   else {
3350     end_scm = SCM_CAR(SCM_OPTARGS);
3351     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3352   }
3353   if (!SCM_INTP(end_scm)) Scm_Error("small integer required, but got %S", end_scm);
3354   end = SCM_INT_VALUE(end_scm);
3355   {
3356 Scm_VectorFill(vec, fill, start, end);
3357 SCM_RETURN(SCM_UNDEFINED);
3358   }
3359 }
3360 
3361 static SCM_DEFINE_STRING_CONST(stdlib_vector_fillX__NAME, "vector-fill!", 12, 12);
3362 static SCM_DEFINE_SUBR(stdlib_vector_fillX__STUB, 2, 1, SCM_OBJ(&stdlib_vector_fillX__NAME), stdlib_vector_fillX, NULL, NULL);
3363 
3364 static ScmObj stdlib_procedureP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3365 {
3366   ScmObj obj_scm;
3367   ScmObj obj;
3368   SCM_ENTER_SUBR("procedure?");
3369   obj_scm = SCM_ARGREF(0);
3370   obj = (obj_scm);
3371   {
3372 {
3373 int SCM_RESULT;
3374 SCM_RESULT = SCM_PROCEDUREP(obj);
3375 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
3376 }
3377   }
3378 }
3379 
3380 static SCM_DEFINE_STRING_CONST(stdlib_procedureP__NAME, "procedure?", 10, 10);
3381 static SCM_DEFINE_SUBR(stdlib_procedureP__STUB, 1, 0, SCM_OBJ(&stdlib_procedureP__NAME), stdlib_procedureP, NULL, NULL);
3382 
3383 static ScmObj stdlib_apply(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3384 {
3385   ScmObj proc_scm;
3386   ScmObj proc;
3387   ScmObj arg1_scm;
3388   ScmObj arg1;
3389   ScmObj args_scm;
3390   ScmObj args;
3391   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3392   SCM_ENTER_SUBR("apply");
3393   proc_scm = SCM_ARGREF(0);
3394   proc = (proc_scm);
3395   arg1_scm = SCM_ARGREF(1);
3396   arg1 = (arg1_scm);
3397   args_scm = SCM_OPTARGS;
3398   args = (args_scm);
3399   {
3400   ScmObj head, tail, cp;
3401   if (SCM_NULLP(args)) return Scm_VMApply(proc, arg1);
3402   else {
3403     head = tail = Scm_Cons(arg1, SCM_NIL);
3404     SCM_FOR_EACH(cp, args) {
3405       if (SCM_NULLP(SCM_CDR(cp))) {
3406         SCM_APPEND(head, tail, SCM_CAR(cp));
3407         break;
3408       }
3409       if (!SCM_PAIRP(SCM_CDR(cp))) {
3410         Scm_Error("improper list not allowed: %S", SCM_CDR(cp));
3411       }
3412       SCM_APPEND1(head, tail, SCM_CAR(cp));
3413     }
3414   }
3415   return Scm_VMApply(proc, head);
3416   }
3417 }
3418 
3419 static SCM_DEFINE_STRING_CONST(stdlib_apply__NAME, "apply", 5, 5);
3420 static SCM_DEFINE_SUBR(stdlib_apply__STUB, 2, 1, SCM_OBJ(&stdlib_apply__NAME), stdlib_apply, SCM_MAKE_INT(SCM_VM_APPLY), NULL);
3421 
3422 static ScmObj stdlib_map(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3423 {
3424   ScmObj proc_scm;
3425   ScmObj proc;
3426   ScmObj args_scm;
3427   ScmObj args;
3428   ScmObj moreargs_scm;
3429   ScmObj moreargs;
3430   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3431   SCM_ENTER_SUBR("map");
3432   proc_scm = SCM_ARGREF(0);
3433   proc = (proc_scm);
3434   args_scm = SCM_ARGREF(1);
3435   if (!SCM_LISTP(args_scm)) Scm_Error("list required, but got %S", args_scm);
3436   args = (args_scm);
3437   moreargs_scm = SCM_OPTARGS;
3438   moreargs = (moreargs_scm);
3439   {
3440 {
3441 ScmObj SCM_RESULT;
3442 SCM_RESULT = Scm_Map(proc, args, moreargs);
3443 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
3444 }
3445   }
3446 }
3447 
3448 static SCM_DEFINE_STRING_CONST(stdlib_map__NAME, "map", 3, 3);
3449 static SCM_DEFINE_SUBR(stdlib_map__STUB, 2, 1, SCM_OBJ(&stdlib_map__NAME), stdlib_map, NULL, NULL);
3450 
3451 static ScmObj stdlib_for_each(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3452 {
3453   ScmObj proc_scm;
3454   ScmObj proc;
3455   ScmObj args_scm;
3456   ScmObj args;
3457   ScmObj moreargs_scm;
3458   ScmObj moreargs;
3459   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3460   SCM_ENTER_SUBR("for-each");
3461   proc_scm = SCM_ARGREF(0);
3462   proc = (proc_scm);
3463   args_scm = SCM_ARGREF(1);
3464   if (!SCM_LISTP(args_scm)) Scm_Error("list required, but got %S", args_scm);
3465   args = (args_scm);
3466   moreargs_scm = SCM_OPTARGS;
3467   moreargs = (moreargs_scm);
3468   {
3469 {
3470 ScmObj SCM_RESULT;
3471 SCM_RESULT = Scm_ForEach(proc, args, moreargs);
3472 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
3473 }
3474   }
3475 }
3476 
3477 static SCM_DEFINE_STRING_CONST(stdlib_for_each__NAME, "for-each", 8, 8);
3478 static SCM_DEFINE_SUBR(stdlib_for_each__STUB, 2, 1, SCM_OBJ(&stdlib_for_each__NAME), stdlib_for_each, NULL, NULL);
3479 
3480 static ScmObj stdlib_force(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3481 {
3482   ScmObj p_scm;
3483   ScmObj p;
3484   SCM_ENTER_SUBR("force");
3485   p_scm = SCM_ARGREF(0);
3486   p = (p_scm);
3487   {
3488 {
3489 ScmObj SCM_RESULT;
3490 SCM_RESULT = Scm_Force(p);
3491 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
3492 }
3493   }
3494 }
3495 
3496 static SCM_DEFINE_STRING_CONST(stdlib_force__NAME, "force", 5, 5);
3497 static SCM_DEFINE_SUBR(stdlib_force__STUB, 1, 0, SCM_OBJ(&stdlib_force__NAME), stdlib_force, NULL, NULL);
3498 
3499 static ScmObj stdlib_call_with_current_continuation(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3500 {
3501   ScmObj proc_scm;
3502   ScmObj proc;
3503   SCM_ENTER_SUBR("call-with-current-continuation");
3504   proc_scm = SCM_ARGREF(0);
3505   proc = (proc_scm);
3506   {
3507 {
3508 ScmObj SCM_RESULT;
3509 SCM_RESULT = Scm_VMCallCC(proc);
3510 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
3511 }
3512   }
3513 }
3514 
3515 static SCM_DEFINE_STRING_CONST(stdlib_call_with_current_continuation__NAME, "call-with-current-continuation", 30, 30);
3516 static SCM_DEFINE_SUBR(stdlib_call_with_current_continuation__STUB, 1, 0, SCM_OBJ(&stdlib_call_with_current_continuation__NAME), stdlib_call_with_current_continuation, NULL, NULL);
3517 
3518 static ScmObj stdlib_values(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3519 {
3520   ScmObj args_scm;
3521   ScmObj args;
3522   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3523   SCM_ENTER_SUBR("values");
3524   args_scm = SCM_OPTARGS;
3525   args = (args_scm);
3526   {
3527 {
3528 ScmObj SCM_RESULT;
3529 SCM_RESULT = Scm_Values(args);
3530 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
3531 }
3532   }
3533 }
3534 
3535 static SCM_DEFINE_STRING_CONST(stdlib_values__NAME, "values", 6, 6);
3536 static SCM_DEFINE_SUBR(stdlib_values__STUB, 0, 1, SCM_OBJ(&stdlib_values__NAME), stdlib_values, SCM_MAKE_INT(SCM_VM_VALUES), NULL);
3537 
3538 static ScmObj stdlib_dynamic_wind(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3539 {
3540   ScmObj pre_scm;
3541   ScmObj pre;
3542   ScmObj body_scm;
3543   ScmObj body;
3544   ScmObj post_scm;
3545   ScmObj post;
3546   SCM_ENTER_SUBR("dynamic-wind");
3547   pre_scm = SCM_ARGREF(0);
3548   pre = (pre_scm);
3549   body_scm = SCM_ARGREF(1);
3550   body = (body_scm);
3551   post_scm = SCM_ARGREF(2);
3552   post = (post_scm);
3553   {
3554 {
3555 ScmObj SCM_RESULT;
3556 SCM_RESULT = Scm_VMDynamicWind(pre, body, post);
3557 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
3558 }
3559   }
3560 }
3561 
3562 static SCM_DEFINE_STRING_CONST(stdlib_dynamic_wind__NAME, "dynamic-wind", 12, 12);
3563 static SCM_DEFINE_SUBR(stdlib_dynamic_wind__STUB, 3, 0, SCM_OBJ(&stdlib_dynamic_wind__NAME), stdlib_dynamic_wind, NULL, NULL);
3564 
3565 static ScmObj stdlib_eval(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3566 {
3567   ScmObj expr_scm;
3568   ScmObj expr;
3569   ScmObj env_scm;
3570   ScmObj env;
3571   SCM_ENTER_SUBR("eval");
3572   expr_scm = SCM_ARGREF(0);
3573   expr = (expr_scm);
3574   env_scm = SCM_ARGREF(1);
3575   env = (env_scm);
3576   {
3577 {
3578 ScmObj SCM_RESULT;
3579 SCM_RESULT = Scm_VMEval(expr, env);
3580 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
3581 }
3582   }
3583 }
3584 
3585 static SCM_DEFINE_STRING_CONST(stdlib_eval__NAME, "eval", 4, 4);
3586 static SCM_DEFINE_SUBR(stdlib_eval__STUB, 2, 0, SCM_OBJ(&stdlib_eval__NAME), stdlib_eval, NULL, NULL);
3587 
3588 static ScmObj stdlib_null_environment(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3589 {
3590   ScmObj version_scm;
3591   int version;
3592   SCM_ENTER_SUBR("null-environment");
3593   version_scm = SCM_ARGREF(0);
3594   if (!SCM_INTP(version_scm)) Scm_Error("small integer required, but got %S", version_scm);
3595   version = SCM_INT_VALUE(version_scm);
3596   {
3597 if (version != 5)
3598   Scm_Error("unknown rNrs version: %d", version);
3599 {
3600 ScmObj SCM_RESULT;
3601  SCM_RESULT = (SCM_OBJ(Scm_NullModule()));
3602 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
3603 }
3604   }
3605 }
3606 
3607 static SCM_DEFINE_STRING_CONST(stdlib_null_environment__NAME, "null-environment", 16, 16);
3608 static SCM_DEFINE_SUBR(stdlib_null_environment__STUB, 1, 0, SCM_OBJ(&stdlib_null_environment__NAME), stdlib_null_environment, NULL, NULL);
3609 
3610 static ScmObj stdlib_scheme_report_environment(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3611 {
3612   ScmObj version_scm;
3613   int version;
3614   SCM_ENTER_SUBR("scheme-report-environment");
3615   version_scm = SCM_ARGREF(0);
3616   if (!SCM_INTP(version_scm)) Scm_Error("small integer required, but got %S", version_scm);
3617   version = SCM_INT_VALUE(version_scm);
3618   {
3619 if (version != 5)
3620   Scm_Error("unknown rNrs version: %d", version);
3621 {
3622 ScmObj SCM_RESULT;
3623  SCM_RESULT = (SCM_OBJ(Scm_SchemeModule()));
3624 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
3625 }
3626   }
3627 }
3628 
3629 static SCM_DEFINE_STRING_CONST(stdlib_scheme_report_environment__NAME, "scheme-report-environment", 25, 25);
3630 static SCM_DEFINE_SUBR(stdlib_scheme_report_environment__STUB, 1, 0, SCM_OBJ(&stdlib_scheme_report_environment__NAME), stdlib_scheme_report_environment, NULL, NULL);
3631 
3632 static ScmObj stdlib_interaction_environment(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3633 {
3634   SCM_ENTER_SUBR("interaction-environment");
3635   {
3636 {
3637 ScmObj SCM_RESULT;
3638  SCM_RESULT = (SCM_OBJ(Scm_UserModule()));
3639 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
3640 }
3641   }
3642 }
3643 
3644 static SCM_DEFINE_STRING_CONST(stdlib_interaction_environment__NAME, "interaction-environment", 23, 23);
3645 static SCM_DEFINE_SUBR(stdlib_interaction_environment__STUB, 0, 0, SCM_OBJ(&stdlib_interaction_environment__NAME), stdlib_interaction_environment, NULL, NULL);
3646 
3647 static ScmObj stdlib_input_portP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3648 {
3649   ScmObj obj_scm;
3650   ScmObj obj;
3651   SCM_ENTER_SUBR("input-port?");
3652   obj_scm = SCM_ARGREF(0);
3653   obj = (obj_scm);
3654   {
3655 {
3656 int SCM_RESULT;
3657 SCM_RESULT = SCM_IPORTP(obj);
3658 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
3659 }
3660   }
3661 }
3662 
3663 static SCM_DEFINE_STRING_CONST(stdlib_input_portP__NAME, "input-port?", 11, 11);
3664 static SCM_DEFINE_SUBR(stdlib_input_portP__STUB, 1, 0, SCM_OBJ(&stdlib_input_portP__NAME), stdlib_input_portP, NULL, NULL);
3665 
3666 static ScmObj stdlib_output_portP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3667 {
3668   ScmObj obj_scm;
3669   ScmObj obj;
3670   SCM_ENTER_SUBR("output-port?");
3671   obj_scm = SCM_ARGREF(0);
3672   obj = (obj_scm);
3673   {
3674 {
3675 int SCM_RESULT;
3676 SCM_RESULT = SCM_OPORTP(obj);
3677 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
3678 }
3679   }
3680 }
3681 
3682 static SCM_DEFINE_STRING_CONST(stdlib_output_portP__NAME, "output-port?", 12, 12);
3683 static SCM_DEFINE_SUBR(stdlib_output_portP__STUB, 1, 0, SCM_OBJ(&stdlib_output_portP__NAME), stdlib_output_portP, NULL, NULL);
3684 
3685 static ScmObj stdlib_portP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3686 {
3687   ScmObj obj_scm;
3688   ScmObj obj;
3689   SCM_ENTER_SUBR("port?");
3690   obj_scm = SCM_ARGREF(0);
3691   obj = (obj_scm);
3692   {
3693 {
3694 int SCM_RESULT;
3695 SCM_RESULT = SCM_PORTP(obj);
3696 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
3697 }
3698   }
3699 }
3700 
3701 static SCM_DEFINE_STRING_CONST(stdlib_portP__NAME, "port?", 5, 5);
3702 static SCM_DEFINE_SUBR(stdlib_portP__STUB, 1, 0, SCM_OBJ(&stdlib_portP__NAME), stdlib_portP, NULL, NULL);
3703 
3704 static ScmObj stdlib_current_input_port(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3705 {
3706   SCM_ENTER_SUBR("current-input-port");
3707   {
3708 {
3709 ScmObj SCM_RESULT;
3710  SCM_RESULT = (SCM_OBJ(SCM_CURIN));
3711 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
3712 }
3713   }
3714 }
3715 
3716 static SCM_DEFINE_STRING_CONST(stdlib_current_input_port__NAME, "current-input-port", 18, 18);
3717 static SCM_DEFINE_SUBR(stdlib_current_input_port__STUB, 0, 0, SCM_OBJ(&stdlib_current_input_port__NAME), stdlib_current_input_port, SCM_MAKE_INT(SCM_VM_CURIN), NULL);
3718 
3719 static ScmObj stdlib_current_output_port(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3720 {
3721   SCM_ENTER_SUBR("current-output-port");
3722   {
3723 {
3724 ScmObj SCM_RESULT;
3725  SCM_RESULT = (SCM_OBJ(SCM_CUROUT));
3726 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
3727 }
3728   }
3729 }
3730 
3731 static SCM_DEFINE_STRING_CONST(stdlib_current_output_port__NAME, "current-output-port", 19, 19);
3732 static SCM_DEFINE_SUBR(stdlib_current_output_port__STUB, 0, 0, SCM_OBJ(&stdlib_current_output_port__NAME), stdlib_current_output_port, SCM_MAKE_INT(SCM_VM_CUROUT), NULL);
3733 
3734 static ScmObj stdlib_close_input_port(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3735 {
3736   ScmObj port_scm;
3737   ScmPort* port;
3738   SCM_ENTER_SUBR("close-input-port");
3739   port_scm = SCM_ARGREF(0);
3740   if (!SCM_PORTP(port_scm)) Scm_Error("port required, but got %S", port_scm);
3741   port = SCM_PORT(port_scm);
3742   {
3743 Scm_ClosePort(port);
3744 SCM_RETURN(SCM_UNDEFINED);
3745   }
3746 }
3747 
3748 static SCM_DEFINE_STRING_CONST(stdlib_close_input_port__NAME, "close-input-port", 16, 16);
3749 static SCM_DEFINE_SUBR(stdlib_close_input_port__STUB, 1, 0, SCM_OBJ(&stdlib_close_input_port__NAME), stdlib_close_input_port, NULL, NULL);
3750 
3751 static ScmObj stdlib_close_output_port(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3752 {
3753   ScmObj port_scm;
3754   ScmPort* port;
3755   SCM_ENTER_SUBR("close-output-port");
3756   port_scm = SCM_ARGREF(0);
3757   if (!SCM_PORTP(port_scm)) Scm_Error("port required, but got %S", port_scm);
3758   port = SCM_PORT(port_scm);
3759   {
3760 Scm_ClosePort(port);
3761 SCM_RETURN(SCM_UNDEFINED);
3762   }
3763 }
3764 
3765 static SCM_DEFINE_STRING_CONST(stdlib_close_output_port__NAME, "close-output-port", 17, 17);
3766 static SCM_DEFINE_SUBR(stdlib_close_output_port__STUB, 1, 0, SCM_OBJ(&stdlib_close_output_port__NAME), stdlib_close_output_port, NULL, NULL);
3767 
3768 static ScmObj stdlib_read(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3769 {
3770   ScmObj port_scm;
3771   ScmPort* port;
3772   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3773   SCM_ENTER_SUBR("read");
3774   if (Scm_Length(SCM_OPTARGS) > 1)
3775     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3776   if (SCM_NULLP(SCM_OPTARGS)) port_scm = SCM_OBJ(SCM_CURIN);
3777   else {
3778     port_scm = SCM_CAR(SCM_OPTARGS);
3779     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3780   }
3781   if (!SCM_IPORTP(port_scm)) Scm_Error("input port required, but got %S", port_scm);
3782   port = SCM_PORT(port_scm);
3783   {
3784 {
3785 ScmObj SCM_RESULT;
3786  SCM_RESULT = (Scm_Read(SCM_OBJ(port)));
3787 SCM_RETURN(SCM_OBJ_SAFE(SCM_RESULT));
3788 }
3789   }
3790 }
3791 
3792 static SCM_DEFINE_STRING_CONST(stdlib_read__NAME, "read", 4, 4);
3793 static SCM_DEFINE_SUBR(stdlib_read__STUB, 0, 1, SCM_OBJ(&stdlib_read__NAME), stdlib_read, NULL, NULL);
3794 
3795 static ScmObj stdlib_read_char(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3796 {
3797   ScmObj port_scm;
3798   ScmPort* port;
3799   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3800   SCM_ENTER_SUBR("read-char");
3801   if (Scm_Length(SCM_OPTARGS) > 1)
3802     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3803   if (SCM_NULLP(SCM_OPTARGS)) port_scm = SCM_OBJ(SCM_CURIN);
3804   else {
3805     port_scm = SCM_CAR(SCM_OPTARGS);
3806     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3807   }
3808   if (!SCM_IPORTP(port_scm)) Scm_Error("input port required, but got %S", port_scm);
3809   port = SCM_PORT(port_scm);
3810   {
3811   int ch = EOF;
3812   SCM_GETC(ch, port);
3813   if (ch == EOF) SCM_RETURN(SCM_EOF);
3814   else SCM_RETURN(SCM_MAKE_CHAR(ch));
3815   }
3816 }
3817 
3818 static SCM_DEFINE_STRING_CONST(stdlib_read_char__NAME, "read-char", 9, 9);
3819 static SCM_DEFINE_SUBR(stdlib_read_char__STUB, 0, 1, SCM_OBJ(&stdlib_read_char__NAME), stdlib_read_char, SCM_MAKE_INT(SCM_VM_READ_CHAR), NULL);
3820 
3821 static ScmObj stdlib_peek_char(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3822 {
3823   ScmObj port_scm;
3824   ScmPort* port;
3825   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3826   SCM_ENTER_SUBR("peek-char");
3827   if (Scm_Length(SCM_OPTARGS) > 1)
3828     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3829   if (SCM_NULLP(SCM_OPTARGS)) port_scm = SCM_OBJ(SCM_CURIN);
3830   else {
3831     port_scm = SCM_CAR(SCM_OPTARGS);
3832     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3833   }
3834   if (!SCM_IPORTP(port_scm)) Scm_Error("input port required, but got %S", port_scm);
3835   port = SCM_PORT(port_scm);
3836   {
3837   ScmChar ch = Scm_Peekc(port);
3838   ScmObj r = (ch == SCM_CHAR_INVALID)? SCM_EOF : SCM_MAKE_CHAR(ch);
3839   SCM_RETURN(r);
3840   }
3841 }
3842 
3843 static SCM_DEFINE_STRING_CONST(stdlib_peek_char__NAME, "peek-char", 9, 9);
3844 static SCM_DEFINE_SUBR(stdlib_peek_char__STUB, 0, 1, SCM_OBJ(&stdlib_peek_char__NAME), stdlib_peek_char, SCM_MAKE_INT(SCM_VM_PEEK_CHAR), NULL);
3845 
3846 static ScmObj stdlib_eof_objectP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3847 {
3848   ScmObj obj_scm;
3849   ScmObj obj;
3850   SCM_ENTER_SUBR("eof-object?");
3851   obj_scm = SCM_ARGREF(0);
3852   obj = (obj_scm);
3853   {
3854 {
3855 int SCM_RESULT;
3856 SCM_RESULT = SCM_EOFP(obj);
3857 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
3858 }
3859   }
3860 }
3861 
3862 static SCM_DEFINE_STRING_CONST(stdlib_eof_objectP__NAME, "eof-object?", 11, 11);
3863 static SCM_DEFINE_SUBR(stdlib_eof_objectP__STUB, 1, 0, SCM_OBJ(&stdlib_eof_objectP__NAME), stdlib_eof_objectP, SCM_MAKE_INT(SCM_VM_EOFP), NULL);
3864 
3865 static ScmObj stdlib_char_readyP(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3866 {
3867   ScmObj port_scm;
3868   ScmPort* port;
3869   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3870   SCM_ENTER_SUBR("char-ready?");
3871   if (Scm_Length(SCM_OPTARGS) > 1)
3872     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3873   if (SCM_NULLP(SCM_OPTARGS)) port_scm = SCM_OBJ(SCM_CURIN);
3874   else {
3875     port_scm = SCM_CAR(SCM_OPTARGS);
3876     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3877   }
3878   if (!SCM_IPORTP(port_scm)) Scm_Error("input port required, but got %S", port_scm);
3879   port = SCM_PORT(port_scm);
3880   {
3881 {
3882 int SCM_RESULT;
3883 SCM_RESULT = Scm_CharReady(port);
3884 SCM_RETURN(SCM_MAKE_BOOL(SCM_RESULT));
3885 }
3886   }
3887 }
3888 
3889 static SCM_DEFINE_STRING_CONST(stdlib_char_readyP__NAME, "char-ready?", 11, 11);
3890 static SCM_DEFINE_SUBR(stdlib_char_readyP__STUB, 0, 1, SCM_OBJ(&stdlib_char_readyP__NAME), stdlib_char_readyP, NULL, NULL);
3891 
3892 static ScmObj stdlib_write(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3893 {
3894   ScmObj obj_scm;
3895   ScmObj obj;
3896   ScmObj port_scm;
3897   ScmPort* port;
3898   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3899   SCM_ENTER_SUBR("write");
3900   if (Scm_Length(SCM_OPTARGS) > 1)
3901     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3902   obj_scm = SCM_ARGREF(0);
3903   obj = (obj_scm);
3904   if (SCM_NULLP(SCM_OPTARGS)) port_scm = SCM_OBJ(SCM_CUROUT);
3905   else {
3906     port_scm = SCM_CAR(SCM_OPTARGS);
3907     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3908   }
3909   if (!SCM_OPORTP(port_scm)) Scm_Error("output port required, but got %S", port_scm);
3910   port = SCM_PORT(port_scm);
3911   {
3912 Scm_Write(obj, SCM_OBJ(port), SCM_WRITE_WRITE);
3913 SCM_RETURN(SCM_UNDEFINED);
3914   }
3915 }
3916 
3917 static SCM_DEFINE_STRING_CONST(stdlib_write__NAME, "write", 5, 5);
3918 static SCM_DEFINE_SUBR(stdlib_write__STUB, 1, 1, SCM_OBJ(&stdlib_write__NAME), stdlib_write, NULL, NULL);
3919 
3920 static ScmObj stdlib_display(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3921 {
3922   ScmObj obj_scm;
3923   ScmObj obj;
3924   ScmObj port_scm;
3925   ScmPort* port;
3926   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3927   SCM_ENTER_SUBR("display");
3928   if (Scm_Length(SCM_OPTARGS) > 1)
3929     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3930   obj_scm = SCM_ARGREF(0);
3931   obj = (obj_scm);
3932   if (SCM_NULLP(SCM_OPTARGS)) port_scm = SCM_OBJ(SCM_CUROUT);
3933   else {
3934     port_scm = SCM_CAR(SCM_OPTARGS);
3935     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3936   }
3937   if (!SCM_OPORTP(port_scm)) Scm_Error("output port required, but got %S", port_scm);
3938   port = SCM_PORT(port_scm);
3939   {
3940 Scm_Write(obj, SCM_OBJ(port), SCM_WRITE_DISPLAY);
3941 SCM_RETURN(SCM_UNDEFINED);
3942   }
3943 }
3944 
3945 static SCM_DEFINE_STRING_CONST(stdlib_display__NAME, "display", 7, 7);
3946 static SCM_DEFINE_SUBR(stdlib_display__STUB, 1, 1, SCM_OBJ(&stdlib_display__NAME), stdlib_display, NULL, NULL);
3947 
3948 static ScmObj stdlib_newline(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3949 {
3950   ScmObj port_scm;
3951   ScmPort* port;
3952   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3953   SCM_ENTER_SUBR("newline");
3954   if (Scm_Length(SCM_OPTARGS) > 1)
3955     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3956   if (SCM_NULLP(SCM_OPTARGS)) port_scm = SCM_OBJ(SCM_CUROUT);
3957   else {
3958     port_scm = SCM_CAR(SCM_OPTARGS);
3959     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3960   }
3961   if (!SCM_OPORTP(port_scm)) Scm_Error("output port required, but got %S", port_scm);
3962   port = SCM_PORT(port_scm);
3963   {
3964 SCM_PUTC('\n', port);
3965 SCM_RETURN(SCM_UNDEFINED);
3966   }
3967 }
3968 
3969 static SCM_DEFINE_STRING_CONST(stdlib_newline__NAME, "newline", 7, 7);
3970 static SCM_DEFINE_SUBR(stdlib_newline__STUB, 0, 1, SCM_OBJ(&stdlib_newline__NAME), stdlib_newline, NULL, NULL);
3971 
3972 static ScmObj stdlib_write_char(ScmObj *SCM_FP, int SCM_ARGCNT, void *data_)
3973 {
3974   ScmObj ch_scm;
3975   ScmChar ch;
3976   ScmObj port_scm;
3977   ScmPort* port;
3978   ScmObj SCM_OPTARGS = SCM_ARGREF(SCM_ARGCNT-1);
3979   SCM_ENTER_SUBR("write-char");
3980   if (Scm_Length(SCM_OPTARGS) > 1)
3981     Scm_Error("too many arguments: up to 1 is expected, %d given.", Scm_Length(SCM_OPTARGS));
3982   ch_scm = SCM_ARGREF(0);
3983   if (!SCM_CHARP(ch_scm)) Scm_Error("character required, but got %S", ch_scm);
3984   ch = SCM_CHAR_VALUE(ch_scm);
3985   if (SCM_NULLP(SCM_OPTARGS)) port_scm = SCM_OBJ(SCM_CUROUT);
3986   else {
3987     port_scm = SCM_CAR(SCM_OPTARGS);
3988     SCM_OPTARGS = SCM_CDR(SCM_OPTARGS);
3989   }
3990   if (!SCM_OPORTP(port_scm)) Scm_Error("output port required, but got %S", port_scm);
3991   port = SCM_PORT(port_scm);
3992   {
3993 SCM_PUTC(ch, port);
3994 SCM_RETURN(SCM_UNDEFINED);
3995   }
3996 }
3997 
3998 static SCM_DEFINE_STRING_CONST(stdlib_write_char__NAME, "write-char", 10, 10);
3999 static SCM_DEFINE_SUBR(stdlib_write_char__STUB, 1, 1, SCM_OBJ(&stdlib_write_char__NAME), stdlib_write_char, SCM_MAKE_INT(SCM_VM_WRITE_CHAR), NULL);
4000 
4001 void Scm_Init_stdlib(ScmModule *module)
4002 {
4003 
4004   SCM_DEFINE(module, "write-char", SCM_OBJ(&stdlib_write_char__STUB));
4005   SCM_DEFINE(module, "newline", SCM_OBJ(&stdlib_newline__STUB));
4006   SCM_DEFINE(module, "display", SCM_OBJ(&stdlib_display__STUB));
4007   SCM_DEFINE(module, "write", SCM_OBJ(&stdlib_write__STUB));
4008   SCM_DEFINE(module, "char-ready?", SCM_OBJ(&stdlib_char_readyP__STUB));
4009   SCM_DEFINE(module, "eof-object?", SCM_OBJ(&stdlib_eof_objectP__STUB));
4010   SCM_DEFINE(module, "peek-char", SCM_OBJ(&stdlib_peek_char__STUB));
4011   SCM_DEFINE(module, "read-char", SCM_OBJ(&stdlib_read_char__STUB));
4012   SCM_DEFINE(module, "read", SCM_OBJ(&stdlib_read__STUB));
4013   SCM_DEFINE(module, "close-output-port", SCM_OBJ(&stdlib_close_output_port__STUB));
4014   SCM_DEFINE(module, "close-input-port", SCM_OBJ(&stdlib_close_input_port__STUB));
4015   SCM_DEFINE(module, "current-output-port", SCM_OBJ(&stdlib_current_output_port__STUB));
4016   SCM_DEFINE(module, "current-input-port", SCM_OBJ(&stdlib_current_input_port__STUB));
4017   SCM_DEFINE(module, "port?", SCM_OBJ(&stdlib_portP__STUB));
4018   SCM_DEFINE(module, "output-port?", SCM_OBJ(&stdlib_output_portP__STUB));
4019   SCM_DEFINE(module, "input-port?", SCM_OBJ(&stdlib_input_portP__STUB));
4020   SCM_DEFINE(module, "interaction-environment", SCM_OBJ(&stdlib_interaction_environment__STUB));
4021   SCM_DEFINE(module, "scheme-report-environment", SCM_OBJ(&stdlib_scheme_report_environment__STUB));
4022   SCM_DEFINE(module, "null-environment", SCM_OBJ(&stdlib_null_environment__STUB));
4023   SCM_DEFINE(module, "eval", SCM_OBJ(&stdlib_eval__STUB));
4024   SCM_DEFINE(module, "dynamic-wind", SCM_OBJ(&stdlib_dynamic_wind__STUB));
4025   SCM_DEFINE(module, "values", SCM_OBJ(&stdlib_values__STUB));
4026   SCM_DEFINE(module, "call-with-current-continuation", SCM_OBJ(&stdlib_call_with_current_continuation__STUB));
4027   SCM_DEFINE(module, "force", SCM_OBJ(&stdlib_force__STUB));
4028   SCM_DEFINE(module, "for-each", SCM_OBJ(&stdlib_for_each__STUB));
4029   SCM_DEFINE(module, "map", SCM_OBJ(&stdlib_map__STUB));
4030   SCM_DEFINE(module, "apply", SCM_OBJ(&stdlib_apply__STUB));
4031   SCM_DEFINE(module, "procedure?", SCM_OBJ(&stdlib_procedureP__STUB));
4032   SCM_DEFINE(module, "vector-fill!", SCM_OBJ(&stdlib_vector_fillX__STUB));
4033   SCM_DEFINE(module, "list->vector", SCM_OBJ(&stdlib_list_TOvector__STUB));
4034   SCM_DEFINE(module, "vector->list", SCM_OBJ(&stdlib_vector_TOlist__STUB));
4035   SCM_DEFINE(module, "vector-set!", SCM_OBJ(&stdlib_vector_setX__STUB));
4036   SCM_DEFINE(module, "vector-ref", SCM_OBJ(&stdlib_vector_ref__STUB));
4037   Scm_SetterSet(SCM_PROCEDURE(&stdlib_vector_ref__STUB), SCM_PROCEDURE(&stdlib_vector_setX__STUB), TRUE);
4038   SCM_DEFINE(module, "vector-length", SCM_OBJ(&stdlib_vector_length__STUB));
4039   SCM_DEFINE(module, "vector", SCM_OBJ(&stdlib_vector__STUB));
4040   SCM_DEFINE(module, "make-vector", SCM_OBJ(&stdlib_make_vector__STUB));
4041   SCM_DEFINE(module, "vector?", SCM_OBJ(&stdlib_vectorP__STUB));
4042   SCM_DEFINE(module, "string-fill!", SCM_OBJ(&stdlib_string_fillX__STUB));
4043   SCM_DEFINE(module, "string-copy", SCM_OBJ(&stdlib_string_copy__STUB));
4044   SCM_DEFINE(module, "list->string", SCM_OBJ(&stdlib_list_TOstring__STUB));
4045   SCM_DEFINE(module, "string->list", SCM_OBJ(&stdlib_string_TOlist__STUB));
4046   SCM_DEFINE(module, "string-append", SCM_OBJ(&stdlib_string_append__STUB));
4047   SCM_DEFINE(module, "substring", SCM_OBJ(&stdlib_substring__STUB));
4048   SCM_DEFINE(module, "string-ci>=?", SCM_OBJ(&stdlib_string_ci_GT_3dP__STUB));
4049   SCM_DEFINE(module, "string-ci>?", SCM_OBJ(&stdlib_string_ci_GTP__STUB));
4050   SCM_DEFINE(module, "string-ci<=?", SCM_OBJ(&stdlib_string_ci_LT_3dP__STUB));
4051   SCM_DEFINE(module, "string-ci<?", SCM_OBJ(&stdlib_string_ci_LTP__STUB));
4052   SCM_DEFINE(module, "string-ci=?", SCM_OBJ(&stdlib_string_ci_3dP__STUB));
4053   SCM_DEFINE(module, "string>=?", SCM_OBJ(&stdlib_string_GT_3dP__STUB));
4054   SCM_DEFINE(module, "string>?", SCM_OBJ(&stdlib_string_GTP__STUB));
4055   SCM_DEFINE(module, "string<=?", SCM_OBJ(&stdlib_string_LT_3dP__STUB));
4056   SCM_DEFINE(module, "string<?", SCM_OBJ(&stdlib_string_LTP__STUB));
4057   SCM_DEFINE(module, "string=?", SCM_OBJ(&stdlib_string_3dP__STUB));
4058   SCM_DEFINE(module, "string-set!", SCM_OBJ(&stdlib_string_setX__STUB));
4059   SCM_DEFINE(module, "string-ref", SCM_OBJ(&stdlib_string_ref__STUB));
4060   Scm_SetterSet(SCM_PROCEDURE(&stdlib_string_ref__STUB), SCM_PROCEDURE(&stdlib_string_setX__STUB), TRUE);
4061   SCM_DEFINE(module, "string-length", SCM_OBJ(&stdlib_string_length__STUB));
4062   SCM_DEFINE(module, "string", SCM_OBJ(&stdlib_string__STUB));
4063   SCM_DEFINE(module, "make-string", SCM_OBJ(&stdlib_make_string__STUB));
4064   SCM_DEFINE(module, "string?", SCM_OBJ(&stdlib_stringP__STUB));
4065   SCM_DEFINE(module, "char-downcase", SCM_OBJ(&stdlib_char_downcase__STUB));
4066   SCM_DEFINE(module, "char-upcase", SCM_OBJ(&stdlib_char_upcase__STUB));
4067   SCM_DEFINE(module, "integer->char", SCM_OBJ(&stdlib_integer_TOchar__STUB));
4068   SCM_DEFINE(module, "char->integer", SCM_OBJ(&stdlib_char_TOinteger__STUB));
4069   SCM_DEFINE(module, "char-lower-case?", SCM_OBJ(&stdlib_char_lower_caseP__STUB));
4070   SCM_DEFINE(module, "char-upper-case?", SCM_OBJ(&stdlib_char_upper_caseP__STUB));
4071   SCM_DEFINE(module, "char-whitespace?", SCM_OBJ(&stdlib_char_whitespaceP__STUB));
4072   SCM_DEFINE(module, "char-numeric?", SCM_OBJ(&stdlib_char_numericP__STUB));
4073   SCM_DEFINE(module, "char-alphabetic?", SCM_OBJ(&stdlib_char_alphabeticP__STUB));
4074   SCM_DEFINE(module, "char-ci>=?", SCM_OBJ(&stdlib_char_ci_GT_3dP__STUB));
4075   SCM_DEFINE(module, "char-ci>?", SCM_OBJ(&stdlib_char_ci_GTP__STUB));
4076   SCM_DEFINE(module, "char-ci<=?", SCM_OBJ(&stdlib_char_ci_LT_3dP__STUB));
4077   SCM_DEFINE(module, "char-ci<?", SCM_OBJ(&stdlib_char_ci_LTP__STUB));
4078   SCM_DEFINE(module, "char-ci=?", SCM_OBJ(&stdlib_char_ci_3dP__STUB));
4079   SCM_DEFINE(module, "char>=?", SCM_OBJ(&stdlib_char_GT_3dP__STUB));
4080   SCM_DEFINE(module, "char<=?", SCM_OBJ(&stdlib_char_LT_3dP__STUB));
4081   SCM_DEFINE(module, "char>?", SCM_OBJ(&stdlib_char_GTP__STUB));
4082   SCM_DEFINE(module, "char<?", SCM_OBJ(&stdlib_char_LTP__STUB));
4083   SCM_DEFINE(module, "char=?", SCM_OBJ(&stdlib_char_3dP__STUB));
4084   SCM_DEFINE(module, "char?", SCM_OBJ(&stdlib_charP__STUB));
4085   SCM_DEFINE(module, "string->symbol", SCM_OBJ(&stdlib_string_TOsymbol__STUB));
4086   SCM_DEFINE(module, "symbol->string", SCM_OBJ(&stdlib_symbol_TOstring__STUB));
4087   SCM_DEFINE(module, "symbol?", SCM_OBJ(&stdlib_symbolP__STUB));
4088   SCM_DEFINE(module, "assoc", SCM_OBJ(&stdlib_assoc__STUB));
4089   SCM_DEFINE(module, "assv", SCM_OBJ(&stdlib_assv__STUB));
4090   SCM_DEFINE(module, "assq", SCM_OBJ(&stdlib_assq__STUB));
4091   SCM_DEFINE(module, "member", SCM_OBJ(&stdlib_member__STUB));
4092   SCM_DEFINE(module, "memv", SCM_OBJ(&stdlib_memv__STUB));
4093   SCM_DEFINE(module, "memq", SCM_OBJ(&stdlib_memq__STUB));
4094   SCM_DEFINE(module, "list-ref", SCM_OBJ(&stdlib_list_ref__STUB));
4095   SCM_DEFINE(module, "list-tail", SCM_OBJ(&stdlib_list_tail__STUB));
4096   SCM_DEFINE(module, "reverse", SCM_OBJ(&stdlib_reverse__STUB));
4097   SCM_DEFINE(module, "append", SCM_OBJ(&stdlib_append__STUB));
4098   SCM_DEFINE(module, "length+", SCM_OBJ(&stdlib_length_2b__STUB));
4099   SCM_DEFINE(module, "length", SCM_OBJ(&stdlib_length__STUB));
4100   SCM_DEFINE(module, "list", SCM_OBJ(&stdlib_list__STUB));
4101   SCM_DEFINE(module, "list?", SCM_OBJ(&stdlib_listP__STUB));
4102   SCM_DEFINE(module, "null?", SCM_OBJ(&stdlib_nullP__STUB));
4103   SCM_DEFINE(module, "cddr", SCM_OBJ(&stdlib_cddr__STUB));
4104   Scm_SetterSet(SCM_PROCEDURE(&stdlib_cddr__STUB), SCM_PROCEDURE(&stdlib_cddr_SETTER__STUB), TRUE);
4105   SCM_DEFINE(module, "cdar", SCM_OBJ(&stdlib_cdar__STUB));
4106   Scm_SetterSet(SCM_PROCEDURE(&stdlib_cdar__STUB), SCM_PROCEDURE(&stdlib_cdar_SETTER__STUB), TRUE);
4107   SCM_DEFINE(module, "cadr", SCM_OBJ(&stdlib_cadr__STUB));
4108   Scm_SetterSet(SCM_PROCEDURE(&stdlib_cadr__STUB), SCM_PROCEDURE(&stdlib_cadr_SETTER__STUB), TRUE);
4109   SCM_DEFINE(module, "caar", SCM_OBJ(&stdlib_caar__STUB));
4110   Scm_SetterSet(SCM_PROCEDURE(&stdlib_caar__STUB), SCM_PROCEDURE(&stdlib_caar_SETTER__STUB), TRUE);
4111   SCM_DEFINE(module, "set-cdr!", SCM_OBJ(&stdlib_set_cdrX__STUB));
4112   SCM_DEFINE(module, "set-car!", SCM_OBJ(&stdlib_set_carX__STUB));
4113   SCM_DEFINE(module, "cdr", SCM_OBJ(&stdlib_cdr__STUB));
4114   Scm_SetterSet(SCM_PROCEDURE(&stdlib_cdr__STUB), SCM_PROCEDURE(&stdlib_set_cdrX__STUB), TRUE);
4115   SCM_DEFINE(module, "car", SCM_OBJ(&stdlib_car__STUB));
4116   Scm_SetterSet(SCM_PROCEDURE(&stdlib_car__STUB), SCM_PROCEDURE(&stdlib_set_carX__STUB), TRUE);
4117   SCM_DEFINE(module, "cons", SCM_OBJ(&stdlib_cons__STUB));
4118   SCM_DEFINE(module, "pair?", SCM_OBJ(&stdlib_pairP__STUB));
4119   SCM_DEFINE(module, "boolean?", SCM_OBJ(&stdlib_booleanP__STUB));
4120   SCM_DEFINE(module, "not", SCM_OBJ(&stdlib_not__STUB));
4121   SCM_DEFINE(module, "string->number", SCM_OBJ(&stdlib_string_TOnumber__STUB));
4122   SCM_DEFINE(module, "number->string", SCM_OBJ(&stdlib_number_TOstring__STUB));
4123   SCM_DEFINE(module, "inexact->exact", SCM_OBJ(&stdlib_inexact_TOexact__STUB));
4124   SCM_DEFINE(module, "exact->inexact", SCM_OBJ(&stdlib_exact_TOinexact__STUB));
4125   SCM_DEFINE(module, "angle", SCM_OBJ(&stdlib_angle__STUB));
4126   SCM_DEFINE(module, "magnitude", SCM_OBJ(&stdlib_magnitude__STUB));
4127   SCM_DEFINE(module, "imag-part", SCM_OBJ(&stdlib_imag_part__STUB));
4128   SCM_DEFINE(module, "real-part", SCM_OBJ(&stdlib_real_part__STUB));
4129   SCM_DEFINE(module, "%complex->real/imag", SCM_OBJ(&stdlib__25complex_TOreal_2fimag__STUB));
4130   SCM_DEFINE(module, "make-polar", SCM_OBJ(&stdlib_make_polar__STUB));
4131   SCM_DEFINE(module, "make-rectangular", SCM_OBJ(&stdlib_make_rectangular__STUB));
4132   SCM_DEFINE(module, "%expt", SCM_OBJ(&stdlib__25expt__STUB));
4133   SCM_DEFINE(module, "%sqrt", SCM_OBJ(&stdlib__25sqrt__STUB));
4134   SCM_DEFINE(module, "%tanh", SCM_OBJ(&stdlib__25tanh__STUB));
4135   SCM_DEFINE(module, "%cosh", SCM_OBJ(&stdlib__25cosh__STUB));
4136   SCM_DEFINE(module, "%sinh", SCM_OBJ(&stdlib__25sinh__STUB));
4137   SCM_DEFINE(module, "%atan", SCM_OBJ(&stdlib__25atan__STUB));
4138   SCM_DEFINE(module, "%acos", SCM_OBJ(&stdlib__25acos__STUB));
4139   SCM_DEFINE(module, "%asin", SCM_OBJ(&stdlib__25asin__STUB));
4140   SCM_DEFINE(module, "%tan", SCM_OBJ(&stdlib__25tan__STUB));
4141   SCM_DEFINE(module, "%cos", SCM_OBJ(&stdlib__25cos__STUB));
4142   SCM_DEFINE(module, "%sin", SCM_OBJ(&stdlib__25sin__STUB));
4143   SCM_DEFINE(module, "%log", SCM_OBJ(&stdlib__25log__STUB));
4144   SCM_DEFINE(module, "%exp", SCM_OBJ(&stdlib__25exp__STUB));
4145   SCM_DEFINE(module, "round", SCM_OBJ(&stdlib_round__STUB));
4146   SCM_DEFINE(module, "truncate", SCM_OBJ(&stdlib_truncate__STUB));
4147   SCM_DEFINE(module, "ceiling", SCM_OBJ(&stdlib_ceiling__STUB));
4148   SCM_DEFINE(module, "floor", SCM_OBJ(&stdlib_floor__STUB));
4149   SCM_DEFINE(module, "modulo", SCM_OBJ(&stdlib_modulo__STUB));
4150   SCM_DEFINE(module, "remainder", SCM_OBJ(&stdlib_remainder__STUB));
4151   SCM_DEFINE(module, "quotient", SCM_OBJ(&stdlib_quotient__STUB));
4152   SCM_DEFINE(module, "abs", SCM_OBJ(&stdlib_abs__STUB));
4153   SCM_DEFINE(module, "/", SCM_OBJ(&stdlib__2f__STUB));
4154   SCM_DEFINE(module, "-", SCM_OBJ(&stdlib____STUB));
4155   SCM_DEFINE(module, "*", SCM_OBJ(&stdlib__2a__STUB));
4156   SCM_DEFINE(module, "+", SCM_OBJ(&stdlib__2b__STUB));
4157   SCM_DEFINE(module, "min", SCM_OBJ(&stdlib_min__STUB));
4158   SCM_DEFINE(module, "max", SCM_OBJ(&stdlib_max__STUB));
4159   SCM_DEFINE(module, "even?", SCM_OBJ(&stdlib_evenP__STUB));
4160   SCM_DEFINE(module, "odd?", SCM_OBJ(&stdlib_oddP__STUB));
4161   SCM_DEFINE(module, "negative?", SCM_OBJ(&stdlib_negativeP__STUB));
4162   SCM_DEFINE(module, "positive?", SCM_OBJ(&stdlib_positiveP__STUB));
4163   SCM_DEFINE(module, "zero?", SCM_OBJ(&stdlib_zeroP__STUB));
4164   SCM_DEFINE(module, ">=", SCM_OBJ(&stdlib__GT_3d__STUB));
4165   SCM_DEFINE(module, ">", SCM_OBJ(&stdlib__GT__STUB));
4166   SCM_DEFINE(module, "<=", SCM_OBJ(&stdlib__LT_3d__STUB));
4167   SCM_DEFINE(module, "<", SCM_OBJ(&stdlib__LT__STUB));
4168   SCM_DEFINE(module, "=", SCM_OBJ(&stdlib__3d__STUB));
4169   SCM_DEFINE(module, "inexact?", SCM_OBJ(&stdlib_inexactP__STUB));
4170   SCM_DEFINE(module, "exact?", SCM_OBJ(&stdlib_exactP__STUB));
4171   SCM_DEFINE(module, "integer?", SCM_OBJ(&stdlib_integerP__STUB));
4172   SCM_DEFINE(module, "rational?", SCM_OBJ(&stdlib_rationalP__STUB));
4173   SCM_DEFINE(module, "real?", SCM_OBJ(&stdlib_realP__STUB));
4174   SCM_DEFINE(module, "complex?", SCM_OBJ(&stdlib_complexP__STUB));
4175   SCM_DEFINE(module, "number?", SCM_OBJ(&stdlib_numberP__STUB));
4176   SCM_DEFINE(module, "equal?", SCM_OBJ(&stdlib_equalP__STUB));
4177   SCM_DEFINE(module, "eq?", SCM_OBJ(&stdlib_eqP__STUB));
4178   SCM_DEFINE(module, "eqv?", SCM_OBJ(&stdlib_eqvP__STUB));
4179 }
/* [<][>][^][v][top][bottom][index][help] */