1
/*===========================================================================
2
* Filename : sigscheme.h
3
* About : Public header file
5
* Copyright (C) 2005-2006 Kazuki Ohta <mover AT hct.zaq.ne.jp>
6
* Copyright (C) 2005-2006 Jun Inoue <jun.lambda AT gmail.com>
7
* Copyright (C) 2005-2006 YAMAMOTO Kengo <yamaken AT bp.iij4u.or.jp>
8
* Copyright (c) 2007 SigScheme Project <uim AT freedesktop.org>
10
* All rights reserved.
12
* Redistribution and use in source and binary forms, with or without
13
* modification, are permitted provided that the following conditions
16
* 1. Redistributions of source code must retain the above copyright
17
* notice, this list of conditions and the following disclaimer.
18
* 2. Redistributions in binary form must reproduce the above copyright
19
* notice, this list of conditions and the following disclaimer in the
20
* documentation and/or other materials provided with the distribution.
21
* 3. Neither the name of authors nor the names of its contributors
22
* may be used to endorse or promote products derived from this software
23
* without specific prior written permission.
25
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS
26
* IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
27
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
28
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
29
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
30
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
31
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
32
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
33
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
34
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
35
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36
===========================================================================*/
40
#include <sigscheme/config.h>
41
#define SCM_USE_VALUES_APPLIER 1
49
#if (GCROOTS_API_REVISION < 0)
50
#error "libgcroots that has API revision >= 0 is required"
55
#if SCM_USE_MULTIBYTE_CHAR
58
#include "encoding-dummy.h"
65
/*=======================================
67
=======================================*/
68
#define SSCM_VERSION_MAJOR (0)
69
#define SSCM_VERSION_MINOR (7)
70
#define SSCM_VERSION_PATCHLEVEL (5)
71
#define SSCM_VERSION_REQUIRE(major, minor, patchlevel) \
72
((major) < SSCM_VERSION_MAJOR \
73
|| ((major) == SSCM_VERSION_MAJOR && (minor) < SSCM_VERSION_MINOR) \
74
|| ((major) == SSCM_VERSION_MAJOR && (minor) == SSCM_VERSION_MINOR \
75
&& (patchlevel) <= SSCM_VERSION_PATCHLEVEL))
77
#define SCM_ERRMSG_MEMORY_EXHAUSTED "memory exhausted"
79
/* An empty definition is generally not a good idea. (Consider for
80
* example (FOO(), bar) where FOO() expands to only whitespaces.)
81
* Simply using 0 prompts warnings everywhere, so we cast it to void.
82
* There may be a better solution out there, so use this macro instead
83
* of crudely writing out the same expression. The idea is taken from
84
* glibc's assert.h but it's barely even a line of code so it should
85
* be OK as the copyright goes... anyone know for sure? */
86
#ifndef SCM_EMPTY_EXPR
87
#define SCM_EMPTY_EXPR ((void)0)
90
#if HAVE___ATTRIBUTE__
91
/* As a workaround for the noinline attribute vanishing bug on some Linux
92
* distributions, we use ((__noinline__)) instead of ((noinline)). */
93
#define SCM_NOINLINE __attribute__((__noinline__))
94
#define SCM_NORETURN __attribute__((__noreturn__))
95
#define SCM_UNUSED __attribute__((__unused__))
96
/* size-less ((__aligned__)) may not be sufficient for m68k */
97
#define SCM_SCMOBJ_ALIGNED __attribute__((__aligned__ (SIZEOF_SCMOBJ)))
98
#else /* HAVE___ATTRIBUTE__ */
102
#define SCM_SCMOBJ_ALIGNED
103
#endif /* HAVE___ATTRIBUTE__ */
105
/* RFC: better names for the debug printing */
106
/* SCM_DBG((a, b, c)) */
108
#define SCM_CDBG(args) (scm_categorized_debug args)
109
#define SCM_DBG(args) (scm_debug args)
110
#else /* SCM_DEBUG */
111
#define SCM_CDBG(args) SCM_EMPTY_EXPR
112
#define SCM_DBG(args) SCM_EMPTY_EXPR
113
#endif /* SCM_DEBUG */
118
* SigScheme uses these three types of condition testers.
120
* ASSERT: Asserts a condition that is expected as always true, as a contract
121
* programming. No actual check is performed when (!SCM_SOFT_ASSERT &&
124
* ENSURE: Mandatory runtime check involving uncertain data. An exception is
125
* raised if failed. Actual check is always performed regaradless of debug
128
* CHECK: Optional runtime check. Actual check is performed only when
129
* configured to do so. Since the behavior, codes that include a CHECK must be
130
* sane even if the condition is false with no actual check.
135
/* allows recovery from failed assertion */
137
#define SCM_ASSERTION_MSG(cond) ("assertion failed at " "'" #cond "'")
139
#define SCM_ASSERTION_MSG(cond) "assertion failed"
141
#define SCM_ASSERT(cond) \
142
((cond) || (scm_die(SCM_ASSERTION_MSG(cond), __FILE__, __LINE__), 1))
145
#define SCM_ASSERT(cond) (assert(cond))
147
#define SCM_ASSERT(cond) SCM_EMPTY_EXPR
150
#define SCM_ENSURE(cond) \
151
((cond) || (scm_die("invalid condition", __FILE__, __LINE__), 1))
153
#define SCM_ENSURE_ALLOCATED(p) \
154
((p) || (scm_fatal_error(SCM_ERRMSG_MEMORY_EXHAUSTED), 1))
156
#if (SCM_USE_WARNING_SUPPRESSOR \
157
&& !SCM_SOFT_ASSERT && (!HAVE_ASSERT_H || defined(NDEBUG)))
159
#define SCM_NOTREACHED (abort())
161
#define SCM_NOTREACHED SCM_ASSERT(scm_false)
165
#define SCM_VALID_ENVP(obj) (scm_valid_environmentp(env))
167
#define SCM_ERROBJP(obj) (TRUEP(scm_p_error_objectp(obj)))
169
#define SCM_SYMBOL_BOUNDP(sym) (!SCM_EQ(SCM_SYMBOL_VCELL(sym), SCM_UNBOUND))
171
#define SCM_CONS(kar, kdr) (SCM_MAKE_CONS((kar), (kdr)))
172
#define SCM_IMMUTABLE_CONS(kar, kdr) (SCM_MAKE_IMMUTABLE_CONS((kar), (kdr)))
173
#define SCM_CAR(kons) (SCM_CONS_CAR(kons))
174
#define SCM_CDR(kons) (SCM_CONS_CDR(kons))
175
#define SCM_CAAR(kons) (SCM_CAR(SCM_CAR(kons)))
176
#define SCM_CADR(kons) (SCM_CAR(SCM_CDR(kons)))
177
#define SCM_CDAR(kons) (SCM_CDR(SCM_CAR(kons)))
178
#define SCM_CDDR(kons) (SCM_CDR(SCM_CDR(kons)))
180
#define SCM_LIST_1(elm0) \
181
(SCM_CONS((elm0), SCM_NULL))
182
#define SCM_LIST_2(elm0, elm1) \
183
(SCM_CONS((elm0), SCM_LIST_1(elm1)))
184
#define SCM_LIST_3(elm0, elm1, elm2) \
185
(SCM_CONS((elm0), SCM_LIST_2((elm1), (elm2))))
186
#define SCM_LIST_4(elm0, elm1, elm2, elm3) \
187
(SCM_CONS((elm0), SCM_LIST_3((elm1), (elm2), (elm3))))
188
#define SCM_LIST_5(elm0, elm1, elm2, elm3, elm4) \
189
(SCM_CONS((elm0), SCM_LIST_4((elm1), (elm2), (elm3), (elm4))))
191
#define SCM_LISTP(obj) (SCM_CONSP(obj) || SCM_NULLP(obj))
192
#define SCM_LIST_1_P(lst) (SCM_CONSP(lst) && SCM_NULLP(SCM_CDR(lst)))
193
#define SCM_LIST_2_P(lst) (SCM_CONSP(lst) && SCM_LIST_1_P(SCM_CDR(lst)))
194
#define SCM_LIST_3_P(lst) (SCM_CONSP(lst) && SCM_LIST_2_P(SCM_CDR(lst)))
195
#define SCM_LIST_4_P(lst) (SCM_CONSP(lst) && SCM_LIST_3_P(SCM_CDR(lst)))
196
#define SCM_LIST_5_P(lst) (SCM_CONSP(lst) && SCM_LIST_4_P(SCM_CDR(lst)))
198
#define SCM_PROPER_LISTP(obj) (SCM_LISTLEN_PROPERP(scm_length(obj)))
199
#define SCM_DOTTED_LISTP(obj) (SCM_LISTLEN_DOTTEDP(scm_length(obj)))
200
#define SCM_CIRCULAR_LISTP(obj) (SCM_LISTLEN_CIRCULARP(scm_length(obj)))
202
/* result decoders for scm_length() */
204
* Dotted list length follows SRFI-1 definition as follows:
206
* list dotted length internal encoded length(don't use directly)
210
* '(1 2 3 . term) 3 -4
212
#define SCM_LISTLEN_PROPERP(len) (0 <= (len))
213
#define SCM_LISTLEN_CIRCULARP(len) ((len) == SCM_INT_T_MIN)
214
#define SCM_LISTLEN_ERRORP SCM_LISTLEN_CIRCULARP
215
#define SCM_LISTLEN_DOTTEDP(len) ((len) < 0 \
216
&& !SCM_LISTLEN_CIRCULARP(len))
217
#define SCM_LISTLEN_DOTTED(len) \
218
(SCM_ASSERT(SCM_LISTLEN_DOTTEDP(len)), ~(len)) /* -(len) - 1 */
220
#define SCM_LISTLEN_PROPER_MAX (SCM_INT_T_MAX)
221
#define SCM_LISTLEN_DOTTED_MAX (-(SCM_INT_T_MIN + 2))
222
#define SCM_LISTLEN_MAX \
223
((SCM_LISTLEN_DOTTED_MAX < SCM_LISTLEN_PROPER_MAX) \
224
? SCM_LISTLEN_PROPER_MAX : SCM_LISTLEN_DOTTED_MAX)
226
#define SCM_EVAL(obj, env) (scm_eval((obj), (env)))
228
#define SCM_ASSERT_FUNCTYPE(type, c_func) \
231
if (0) f = (c_func); /* compile-time type check */ \
232
} while (/* CONSTCOND */ 0)
235
#define SCM_REGISTER_FUNC(name, c_func, type) \
237
enum ScmFuncTypeCode typecode; \
239
SCM_ASSERT_FUNCTYPE(scm_##type, (c_func)); \
240
typecode = scm_funccode_##type; \
241
scm_register_func(name, c_func, typecode); \
242
} while (/* CONSTCOND */ 0)
246
#define SCM_ENSURE_LIVE_PORT(port) \
247
(SCM_PORT_IMPL(port) \
248
|| (scm_error_obj("(unknown)", "operated on closed port", (port)), 1))
252
#define SCM_WRITE_SS(port, obj) ((*scm_write_ss_func)((port), (obj)))
253
/* Assumes that scm_write_ss_func only holds either scm_write or
255
#define SCM_WRITE_SS_ENABLEDP() (scm_write_ss_func != scm_write)
258
/*===========================================================================
260
===========================================================================*/
261
/*=======================================
263
=======================================*/
264
enum ScmDebugCategory {
266
SCM_DBG_ERRMSG = 1 << 0, /* the "Error: foo bar" style msgs */
267
SCM_DBG_BACKTRACE = 1 << 1,
269
SCM_DBG_FILE = 1 << 3, /* file loading */
270
SCM_DBG_PARSER = 1 << 4,
271
SCM_DBG_READ = 1 << 5, /* print each parsed expression + misc */
272
SCM_DBG_MACRO = 1 << 6,
273
SCM_DBG_ARGS = 1 << 7, /* number of arguments, type and so on */
274
SCM_DBG_EVAL = 1 << 8, /* evaluation-related things */
275
SCM_DBG_CONTINUATION = 1 << 9,
276
SCM_DBG_EXCEPTION = 1 << 10,
277
SCM_DBG_EXPERIMENTAL = 1 << 11, /* developed but experimental features */
278
SCM_DBG_DEVEL = 1 << 12, /* under development */
279
SCM_DBG_COMPAT = 1 << 13, /* warns compatibility-sensitive code */
280
SCM_DBG_ENCODING = 1 << 14, /* multibyte handling */
281
SCM_DBG_OTHER = 1 << 30 /* all other messages */
285
/* sorted by majority to make immediate number encoding optimal */
300
ScmContinuation = 12,
305
/* Reserved for future extension of argument types-encoded
306
* ScmFuncTypeCode. The types for it should not exceed 4-bit. */
307
ScmNumber = ScmConstant,
308
ScmProc = ScmValuePacket,
309
ScmAny = ScmFreeCell,
316
ScmCFuncPointer = 30,
319
/* Classification tag for internal object validations */
320
ScmFirstClassObj = 0 /* intentionally zero */
326
* Function objects must tag themselves with proper information so
327
* that the evaluator can correctly invoke them.
329
#define SCM_FUNCTYPE_MAND_MAX 5
330
enum ScmFuncTypeCode {
331
SCM_FUNCTYPE_MAND_BITS = 4,
332
SCM_FUNCTYPE_MAND_MASK = (1 << SCM_FUNCTYPE_MAND_BITS) - 1,
333
SCM_FUNCTYPE_PROCEDURE = 0 << SCM_FUNCTYPE_MAND_BITS,
334
SCM_FUNCTYPE_SYNTAX = 1 << SCM_FUNCTYPE_MAND_BITS,
336
SCM_FUNCTYPE_FIXED = 0 << (SCM_FUNCTYPE_MAND_BITS + 1),
337
SCM_FUNCTYPE_VARIADIC = 1 << (SCM_FUNCTYPE_MAND_BITS + 1),
338
SCM_FUNCTYPE_TAILREC = 1 << (SCM_FUNCTYPE_MAND_BITS + 2),
340
SCM_FUNCTYPE_ODDBALL = 1 << (SCM_FUNCTYPE_MAND_BITS + 10),
342
/* Compound types. */
343
SCM_PROCEDURE_FIXED = SCM_FUNCTYPE_FIXED,
344
SCM_PROCEDURE_FIXED_TAILREC = SCM_FUNCTYPE_TAILREC,
345
SCM_PROCEDURE_VARIADIC = SCM_FUNCTYPE_VARIADIC,
346
SCM_PROCEDURE_VARIADIC_TAILREC = (SCM_FUNCTYPE_VARIADIC
347
| SCM_FUNCTYPE_TAILREC),
349
SCM_SYNTAX_FIXED = (SCM_FUNCTYPE_SYNTAX
350
| SCM_PROCEDURE_FIXED),
351
SCM_SYNTAX_FIXED_TAILREC = (SCM_FUNCTYPE_SYNTAX
352
| SCM_PROCEDURE_FIXED_TAILREC),
353
SCM_SYNTAX_VARIADIC = (SCM_FUNCTYPE_SYNTAX
354
| SCM_PROCEDURE_VARIADIC),
355
SCM_SYNTAX_VARIADIC_TAILREC = (SCM_FUNCTYPE_SYNTAX
356
| SCM_PROCEDURE_VARIADIC_TAILREC),
358
/* Proper combinations */
359
SCM_SYNTAX_FIXED_0 = (SCM_SYNTAX_FIXED | 0),
360
SCM_SYNTAX_FIXED_TAILREC_0 = (SCM_SYNTAX_FIXED_TAILREC | 0),
361
SCM_SYNTAX_VARIADIC_0 = (SCM_SYNTAX_VARIADIC | 0),
362
SCM_SYNTAX_VARIADIC_TAILREC_0 = (SCM_SYNTAX_VARIADIC_TAILREC | 0),
363
SCM_PROCEDURE_FIXED_0 = (SCM_PROCEDURE_FIXED | 0),
364
SCM_PROCEDURE_FIXED_TAILREC_0 = (SCM_PROCEDURE_FIXED_TAILREC | 0),
365
SCM_PROCEDURE_VARIADIC_0 = (SCM_PROCEDURE_VARIADIC | 0),
366
SCM_PROCEDURE_VARIADIC_TAILREC_0 = (SCM_PROCEDURE_VARIADIC_TAILREC | 0),
367
#if SCM_FUNCTYPE_MAND_MAX >= 1
368
SCM_SYNTAX_FIXED_1 = (SCM_SYNTAX_FIXED | 1),
369
SCM_SYNTAX_FIXED_TAILREC_1 = (SCM_SYNTAX_FIXED_TAILREC | 1),
370
SCM_SYNTAX_VARIADIC_1 = (SCM_SYNTAX_VARIADIC | 1),
371
SCM_SYNTAX_VARIADIC_TAILREC_1 = (SCM_SYNTAX_VARIADIC_TAILREC | 1),
372
SCM_PROCEDURE_FIXED_1 = (SCM_PROCEDURE_FIXED | 1),
373
SCM_PROCEDURE_FIXED_TAILREC_1 = (SCM_PROCEDURE_FIXED_TAILREC | 1),
374
SCM_PROCEDURE_VARIADIC_1 = (SCM_PROCEDURE_VARIADIC | 1),
375
SCM_PROCEDURE_VARIADIC_TAILREC_1 = (SCM_PROCEDURE_VARIADIC_TAILREC | 1),
377
#if SCM_FUNCTYPE_MAND_MAX >= 2
378
SCM_SYNTAX_FIXED_2 = (SCM_SYNTAX_FIXED | 2),
379
SCM_SYNTAX_FIXED_TAILREC_2 = (SCM_SYNTAX_FIXED_TAILREC | 2),
380
SCM_SYNTAX_VARIADIC_2 = (SCM_SYNTAX_VARIADIC | 2),
381
SCM_SYNTAX_VARIADIC_TAILREC_2 = (SCM_SYNTAX_VARIADIC_TAILREC | 2),
382
SCM_PROCEDURE_FIXED_2 = (SCM_PROCEDURE_FIXED | 2),
383
SCM_PROCEDURE_FIXED_TAILREC_2 = (SCM_PROCEDURE_FIXED_TAILREC | 2),
384
SCM_PROCEDURE_VARIADIC_2 = (SCM_PROCEDURE_VARIADIC | 2),
385
SCM_PROCEDURE_VARIADIC_TAILREC_2 = (SCM_PROCEDURE_VARIADIC_TAILREC | 2),
387
#if SCM_FUNCTYPE_MAND_MAX >= 3
388
SCM_SYNTAX_FIXED_3 = (SCM_SYNTAX_FIXED | 3),
389
SCM_SYNTAX_FIXED_TAILREC_3 = (SCM_SYNTAX_FIXED_TAILREC | 3),
390
SCM_SYNTAX_VARIADIC_3 = (SCM_SYNTAX_VARIADIC | 3),
391
SCM_SYNTAX_VARIADIC_TAILREC_3 = (SCM_SYNTAX_VARIADIC_TAILREC | 3),
392
SCM_PROCEDURE_FIXED_3 = (SCM_PROCEDURE_FIXED | 3),
393
SCM_PROCEDURE_FIXED_TAILREC_3 = (SCM_PROCEDURE_FIXED_TAILREC | 3),
394
SCM_PROCEDURE_VARIADIC_3 = (SCM_PROCEDURE_VARIADIC | 3),
395
SCM_PROCEDURE_VARIADIC_TAILREC_3 = (SCM_PROCEDURE_VARIADIC_TAILREC | 3),
397
#if SCM_FUNCTYPE_MAND_MAX >= 4
398
SCM_SYNTAX_FIXED_4 = (SCM_SYNTAX_FIXED | 4),
399
SCM_SYNTAX_FIXED_TAILREC_4 = (SCM_SYNTAX_FIXED_TAILREC | 4),
400
SCM_SYNTAX_VARIADIC_4 = (SCM_SYNTAX_VARIADIC | 4),
401
SCM_SYNTAX_VARIADIC_TAILREC_4 = (SCM_SYNTAX_VARIADIC_TAILREC | 4),
402
SCM_PROCEDURE_FIXED_4 = (SCM_PROCEDURE_FIXED | 4),
403
SCM_PROCEDURE_FIXED_TAILREC_4 = (SCM_PROCEDURE_FIXED_TAILREC | 4),
404
SCM_PROCEDURE_VARIADIC_4 = (SCM_PROCEDURE_VARIADIC | 4),
405
SCM_PROCEDURE_VARIADIC_TAILREC_4 = (SCM_PROCEDURE_VARIADIC_TAILREC | 4),
407
#if SCM_FUNCTYPE_MAND_MAX >= 5
408
SCM_SYNTAX_FIXED_5 = (SCM_SYNTAX_FIXED | 5),
409
SCM_SYNTAX_FIXED_TAILREC_5 = (SCM_SYNTAX_FIXED_TAILREC | 5),
410
SCM_SYNTAX_VARIADIC_5 = (SCM_SYNTAX_VARIADIC | 5),
411
SCM_SYNTAX_VARIADIC_TAILREC_5 = (SCM_SYNTAX_VARIADIC_TAILREC | 5),
412
SCM_PROCEDURE_FIXED_5 = (SCM_PROCEDURE_FIXED | 5),
413
SCM_PROCEDURE_FIXED_TAILREC_5 = (SCM_PROCEDURE_FIXED_TAILREC | 5),
414
SCM_PROCEDURE_VARIADIC_5 = (SCM_PROCEDURE_VARIADIC | 5),
415
SCM_PROCEDURE_VARIADIC_TAILREC_5 = (SCM_PROCEDURE_VARIADIC_TAILREC | 5),
417
#if SCM_FUNCTYPE_MAND_MAX >= 6
418
#error "SCM_FUNCTYPE_MAND_MAX must not exceed 5"
422
SCM_REDUCTION_OPERATOR = SCM_FUNCTYPE_ODDBALL,
424
SCM_FUNCTYPE_INVALID = (SCM_FUNCTYPE_ODDBALL | 1)
427
/* Where we are in a reduction process. */
428
enum ScmReductionState {
429
SCM_REDUCE_0, /* No argument was given. */
430
SCM_REDUCE_1, /* Only 1 argument was given. */
431
SCM_REDUCE_PARTWAY, /* We have more arguments pending. */
432
SCM_REDUCE_LAST, /* The callee must finalize. */
433
SCM_REDUCE_STOP /* Callee wants to stop. */
437
SCM_PORTFLAG_NONE = 0,
438
SCM_PORTFLAG_OUTPUT = 1 << 0,
439
SCM_PORTFLAG_INPUT = 1 << 1,
440
SCM_PORTFLAG_LIVE_OUTPUT = 1 << 2,
441
SCM_PORTFLAG_LIVE_INPUT = 1 << 3,
443
SCM_PORTFLAG_DIR_MASK = (SCM_PORTFLAG_INPUT | SCM_PORTFLAG_OUTPUT),
444
SCM_PORTFLAG_ALIVENESS_MASK = (SCM_PORTFLAG_LIVE_INPUT
445
| SCM_PORTFLAG_LIVE_OUTPUT)
448
typedef void (*ScmCFunc)(void);
449
typedef void *(*ScmGCGateFunc)(void *);
452
#if SCM_USE_HYGIENIC_MACRO
453
/* Environment for looking up a free variable inserted by a hygienic
454
* macro's template. References in syntax-rules are only looked up in
455
* environments enclosed by the definition's, so we need only record
456
* the number of frames. That doesn't work in the face of syntax-case
457
* though, so we abstract the representation here. */
458
typedef scm_int_t ScmPackedEnv;
459
#define SCM_PENV_EQ(x, y) ((x) == (y))
463
* 64-bit support of SigScheme
465
* SigScheme supports all data models of ILP32, LL64, LLP64, LP64 and
466
* ILP64. Default settings automatically configure both ABI and the underlying
467
* storage implementation appropriately, if the storage implementation is
468
* storage-fatty or storage-compact. On the case, the integer size Scheme can
469
* handle is determined by sizeof(long), and heap capacity and addressable
470
* space are determined by the pointer size.
472
* Other storage implementations (currently not exist) may need some manual
473
* settings to fit to the specified data model.
477
* Interface to an implementation for the Storage Abstraction Layer:
479
* A storage implementation defines following types:
481
* typedef <hidden> ScmCell;
482
* typedef <hidden> ScmObj;
483
* typedef <hidden> ScmRef;
485
* typedef ScmObj (*ScmFuncType)();
487
* And following macros:
493
#if SCM_USE_STORAGE_FATTY
494
#include "storage-fatty.h"
495
#elif SCM_USE_STORAGE_COMPACT
496
#include "storage-compact.h"
498
#error "specify a storage layer implementation"
501
typedef struct ScmStorageConf_ ScmStorageConf;
502
struct ScmStorageConf_ {
504
size_t heap_size; /* number of ScmCell in a heap */
505
size_t heap_alloc_threshold; /* minimum number of freecells after a GC */
506
size_t n_heaps_max; /* max number of heaps */
507
size_t n_heaps_init; /* initial number of heaps */
510
size_t symbol_hash_size; /* hash size of symbol table */
513
#define SCM_FULLY_ADDRESSABLEP \
514
(SCM_PTR_BITS == (sizeof(void *) * CHAR_BIT))
516
#ifndef SCM_DEFAULT_N_HEAPS_MAX
517
#define SCM_DEFAULT_N_HEAPS_MAX \
518
(((SCM_INT_BITS < SCM_PTR_BITS) \
520
: ((SCM_FULLY_ADDRESSABLEP) \
521
? ((size_t)(intptr_t)-1 >> 1) : ((size_t)1 << SCM_PTR_BITS) - 1)) \
522
/ SCM_DEFAULT_HEAP_SIZE)
525
/*=======================================
526
Object Representation Information
527
=======================================*/
528
#define SCM_HAS_CHAR SCM_SAL_HAS_CHAR
529
#define SCM_HAS_INT 1
530
#define SCM_HAS_RATIONAL SCM_SAL_HAS_RATIONAL
531
#define SCM_HAS_REAL SCM_SAL_HAS_REAL
532
#define SCM_HAS_COMPLEX SCM_SAL_HAS_COMPLEX
533
#define SCM_HAS_STRING SCM_SAL_HAS_STRING
534
#define SCM_HAS_VECTOR SCM_SAL_HAS_VECTOR
536
#define SCM_HAS_IMMUTABLE_CONS SCM_SAL_HAS_IMMUTABLE_CONS
537
#define SCM_HAS_IMMUTABLE_STRING SCM_SAL_HAS_IMMUTABLE_STRING
538
#define SCM_HAS_IMMUTABLE_VECTOR SCM_SAL_HAS_IMMUTABLE_VECTOR
540
/* for optimization */
541
#define SCM_HAS_IMMEDIATE_CHAR_ONLY SCM_SAL_HAS_IMMEDIATE_CHAR_ONLY
542
#define SCM_HAS_IMMEDIATE_NUMBER_ONLY SCM_SAL_HAS_IMMEDIATE_NUMBER_ONLY
543
#define SCM_HAS_IMMEDIATE_INT_ONLY SCM_SAL_HAS_IMMEDIATE_INT_ONLY
544
#define SCM_HAS_IMMEDIATE_RATIONAL_ONLY SCM_SAL_HAS_IMMEDIATE_RATIONAL_ONLY
545
#define SCM_HAS_IMMEDIATE_REAL_ONLY SCM_SAL_HAS_IMMEDIATE_REAL_ONLY
546
#define SCM_HAS_IMMEDIATE_COMPLEX_ONLY SCM_SAL_HAS_IMMEDIATE_COMPLEX_ONLY
548
/* addressable space: tag bits multiplexed in alignment part is also counted */
549
#define SCM_PTR_BITS SCM_SAL_PTR_BITS
551
#define SCM_CHAR_BITS SCM_SAL_CHAR_BITS
552
#define SCM_CHAR_MAX SCM_SAL_CHAR_MAX
553
#define SCM_CHAR_MIN 0
555
#define SCM_INT_BITS SCM_SAL_INT_BITS
556
#define SCM_INT_MAX SCM_SAL_INT_MAX
557
#define SCM_INT_MIN SCM_SAL_INT_MIN
560
#define SCM_STRLEN_BITS SCM_SAL_STRLEN_BITS
561
#define SCM_STRLEN_MAX SCM_SAL_STRLEN_MAX
562
#define SCM_STRLEN_MIN 0
565
#define SCM_VECLEN_BITS SCM_SAL_VECLEN_BITS
566
#define SCM_VECLEN_MAX SCM_SAL_VECLEN_MAX
567
#define SCM_VECLEN_MIN 0
570
#define SCM_HAS_EQVP SCM_SAL_HAS_EQVP
572
/*=======================================
574
=======================================*/
575
/* TODO: add this check to all accessor and creator macros. */
576
#define SCM_TYPESAFE_MACRO(macro, rettype, types, args) \
577
(0 ? (*(rettype (*)types)NULL)args \
578
: 0 ? ((*(rettype *)NULL) = macro args) \
581
/* For macros enclosed in do-while(0). */
582
#define SCM_TYPESAFE_MACRO_VOID(macro, types, args) \
585
(*(void (*)types)NULL) args; \
590
#define SCM_MAKE_BOOL(x) ((x) ? SCM_TRUE : SCM_FALSE)
592
#define SCM_MAKE_CONS(kar, kdr) \
593
SCM_TYPESAFE_MACRO(SCM_SAL_MAKE_CONS, \
598
#define SCM_MAKE_IMMUTABLE_CONS(kar, kdr) \
599
SCM_TYPESAFE_MACRO(SCM_SAL_MAKE_IMMUTABLE_CONS, \
605
#define SCM_MAKE_INT(val) \
606
SCM_TYPESAFE_MACRO(SCM_SAL_MAKE_INT, \
610
#endif /* SCM_USE_INT */
613
#define SCM_MAKE_CHAR(val) \
614
SCM_TYPESAFE_MACRO(SCM_SAL_MAKE_CHAR, \
618
#endif /* SCM_USE_CHAR */
620
#define SCM_MAKE_SYMBOL(name, val) \
621
SCM_TYPESAFE_MACRO(SCM_SAL_MAKE_SYMBOL, \
627
#define SCM_MAKE_STRING(str, len) \
628
SCM_TYPESAFE_MACRO(SCM_SAL_MAKE_STRING, \
630
(char *, scm_int_t), \
633
#define SCM_MAKE_STRING_COPYING(str, len) \
634
SCM_TYPESAFE_MACRO(SCM_SAL_MAKE_STRING_COPYING, \
636
(const char *, scm_int_t), \
639
#define SCM_MAKE_IMMUTABLE_STRING(str, len) \
640
SCM_TYPESAFE_MACRO(SCM_SAL_MAKE_IMMUTABLE_STRING, \
642
(char *, scm_int_t), \
645
#define SCM_MAKE_IMMUTABLE_STRING_COPYING(str, len) \
646
SCM_TYPESAFE_MACRO(SCM_SAL_MAKE_IMMUTABLE_STRING_COPYING, \
648
(const char *, scm_int_t), \
651
#define SCM_CONST_STRING(str) \
652
SCM_MAKE_IMMUTABLE_STRING_COPYING((str), SCM_STRLEN_UNKNOWN)
653
#define SCM_STRLEN_UNKNOWN (-1)
654
#endif /* SCM_USE_STRING */
656
#define SCM_MAKE_FUNC(type, func) \
657
SCM_TYPESAFE_MACRO(SCM_SAL_MAKE_FUNC, \
659
(enum ScmFuncTypeCode, ScmFuncType), \
662
#define SCM_MAKE_CLOSURE(exp, env) \
663
SCM_TYPESAFE_MACRO(SCM_SAL_MAKE_CLOSURE, \
669
#define SCM_MAKE_VECTOR(vec, len) \
670
SCM_TYPESAFE_MACRO(SCM_SAL_MAKE_VECTOR, \
672
(ScmObj *, scm_int_t), \
675
#define SCM_MAKE_IMMUTABLE_VECTOR(vec, len) \
676
SCM_TYPESAFE_MACRO(SCM_SAL_MAKE_IMMUTABLE_VECTOR, \
678
(ScmObj *, scm_int_t), \
680
#endif /* SCM_USE_VECTOR */
682
#if (SCM_USE_CONTINUATION || SCM_USE_VALUES_APPLIER)
683
#define SCM_MAKE_CONTINUATION() \
684
SCM_TYPESAFE_MACRO(SCM_SAL_MAKE_CONTINUATION, \
688
#endif /* (SCM_USE_CONTINUATION || SCM_USE_VALUES_APPLIER) */
690
#define SCM_MAKE_VALUEPACKET(vals) \
691
SCM_TYPESAFE_MACRO(SCM_SAL_MAKE_VALUEPACKET, \
697
#define SCM_MAKE_PORT(cport, flag) \
698
SCM_TYPESAFE_MACRO(SCM_SAL_MAKE_PORT, \
700
(struct ScmCharPort_ *, enum ScmPortFlag), \
702
#endif /* SCM_USE_PORT */
704
#if SCM_USE_HYGIENIC_MACRO
705
#define SCM_MAKE_HMACRO(r, e) \
706
SCM_TYPESAFE_MACRO(SCM_SAL_MAKE_HMACRO, \
711
#define SCM_MAKE_FARSYMBOL(s, e) \
712
SCM_TYPESAFE_MACRO(SCM_SAL_MAKE_FARSYMBOL, \
714
(ScmObj, ScmPackedEnv), \
717
#define SCM_MAKE_SUBPAT(x, m) \
718
SCM_TYPESAFE_MACRO(SCM_SAL_MAKE_SUBPAT, \
720
(ScmObj, scm_int_t), \
722
#endif /* SCM_USE_HYGIENIC_MACRO */
724
#if SCM_USE_SSCM_EXTENSIONS
725
#define SCM_MAKE_C_POINTER(ptr) \
726
SCM_TYPESAFE_MACRO(SCM_SAL_MAKE_C_POINTER, \
731
#define SCM_MAKE_C_FUNCPOINTER(ptr) \
732
SCM_TYPESAFE_MACRO(SCM_SAL_MAKE_C_FUNCPOINTER, \
736
#endif /* SCM_USE_SSCM_EXTENSIONS */
738
/*=======================================
740
=======================================*/
741
/* ScmObj Global Attribute */
742
#define SCM_TYPE(o) SCM_SAL_TYPE(o)
744
/* Type Confirmation */
745
#if SCM_ACCESSOR_ASSERT
746
#define SCM_ASSERT_TYPE(cond, o) (SCM_ASSERT(cond), (o))
747
#else /* SCM_ACCESSOR_ASSERT */
748
#define SCM_ASSERT_TYPE(cond, o) (o)
749
#endif /* SCM_ACCESSOR_ASSERT */
750
#define SCM_AS_NUMBER(o) (SCM_ASSERT_TYPE(SCM_NUMBERP(o), (o)))
751
#define SCM_AS_INT(o) (SCM_ASSERT_TYPE(SCM_INTP(o), (o)))
752
#define SCM_AS_CONS(o) (SCM_ASSERT_TYPE(SCM_CONSP(o), (o)))
753
#define SCM_AS_SYMBOL(o) (SCM_ASSERT_TYPE(SCM_SYMBOLP(o), (o)))
754
#define SCM_AS_CHAR(o) (SCM_ASSERT_TYPE(SCM_CHARP(o), (o)))
755
#define SCM_AS_STRING(o) (SCM_ASSERT_TYPE(SCM_STRINGP(o), (o)))
756
#define SCM_AS_FUNC(o) (SCM_ASSERT_TYPE(SCM_FUNCP(o), (o)))
757
#define SCM_AS_CLOSURE(o) (SCM_ASSERT_TYPE(SCM_CLOSUREP(o), (o)))
758
#define SCM_AS_VECTOR(o) (SCM_ASSERT_TYPE(SCM_VECTORP(o), (o)))
759
#define SCM_AS_PORT(o) (SCM_ASSERT_TYPE(SCM_PORTP(o), (o)))
760
#define SCM_AS_CONTINUATION(o) (SCM_ASSERT_TYPE(SCM_CONTINUATIONP(o), (o)))
761
#define SCM_AS_VALUEPACKET(o) (SCM_ASSERT_TYPE(SCM_VALUEPACKETP(o), (o)))
762
#define SCM_AS_C_POINTER(o) (SCM_ASSERT_TYPE(SCM_C_POINTERP(o), (o)))
763
#define SCM_AS_C_FUNCPOINTER(o) (SCM_ASSERT_TYPE(SCM_C_FUNCPOINTERP(o), (o)))
764
#define SCM_AS_HMACRO(o) (SCM_ASSERT_TYPE(SCM_HMACROP(o), (o)))
765
#define SCM_AS_FARSYMBOL(o) (SCM_ASSERT_TYPE(SCM_FARSYMBOLP(o), (o)))
766
#define SCM_AS_SUBPAT(o) (SCM_ASSERT_TYPE(SCM_SUBPATP(o), (o)))
769
#define SCM_NUMBERP(o) SCM_SAL_NUMBERP(o)
772
#define SCM_INTP(o) SCM_SAL_INTP(o)
773
#define SCM_INT_VALUE(o) SCM_SAL_INT_VALUE(o)
774
#define SCM_INT_SET_VALUE(o, val) SCM_SAL_INT_SET_VALUE((o), (val))
775
#endif /* SCM_USE_INT */
776
#endif /* SCM_USE_NUMBER */
778
#define SCM_CONSP(o) SCM_SAL_CONSP(o)
779
#define SCM_CONS_CAR(o) SCM_SAL_CONS_CAR(o)
780
#define SCM_CONS_CDR(o) SCM_SAL_CONS_CDR(o)
781
#define SCM_CONS_SET_CAR(o, kar) SCM_SAL_CONS_SET_CAR((o), (kar))
782
#define SCM_CONS_SET_CDR(o, kdr) SCM_SAL_CONS_SET_CDR((o), (kdr))
783
#define SCM_CONS_MUTABLEP(o) SCM_SAL_CONS_MUTABLEP(o)
784
#define SCM_CONS_SET_MUTABLE(o) SCM_SAL_CONS_SET_MUTABLE(o)
785
#define SCM_CONS_SET_IMMUTABLE(o) SCM_SAL_CONS_SET_IMMUTABLE(o)
787
#define SCM_SYMBOLP(o) SCM_SAL_SYMBOLP(o)
788
#define SCM_SYMBOL_NAME(o) SCM_SAL_SYMBOL_NAME(o)
789
#define SCM_SYMBOL_VCELL(o) SCM_SAL_SYMBOL_VCELL(o)
790
#define SCM_SYMBOL_SET_NAME(o, name) SCM_SAL_SYMBOL_SET_NAME((o), (name))
791
#define SCM_SYMBOL_SET_VCELL(o, val) SCM_SAL_SYMBOL_SET_VCELL((o), (val))
794
#define SCM_CHARP(o) SCM_SAL_CHARP(o)
795
#define SCM_CHAR_VALUE(o) SCM_SAL_CHAR_VALUE(o)
796
#define SCM_CHAR_SET_VALUE(o, val) SCM_SAL_CHAR_SET_VALUE((o), (val))
797
#endif /* SCM_USE_CHAR */
800
#define SCM_STRINGP(o) SCM_SAL_STRINGP(o)
801
#define SCM_STRING_STR(o) SCM_SAL_STRING_STR(o)
802
#define SCM_STRING_LEN(o) SCM_SAL_STRING_LEN(o)
803
#define SCM_STRING_SET_STR(o, str) SCM_SAL_STRING_SET_STR((o), (str))
804
#define SCM_STRING_SET_LEN(o, len) SCM_SAL_STRING_SET_LEN((o), (len))
805
#define SCM_STRING_MUTABLEP(o) SCM_SAL_STRING_MUTABLEP(o)
806
#define SCM_STRING_SET_MUTABLE(o) SCM_SAL_STRING_SET_MUTABLE(o)
807
#define SCM_STRING_SET_IMMUTABLE(o) SCM_SAL_STRING_SET_IMMUTABLE(o)
808
#endif /* SCM_USE_STRING */
810
#define SCM_FUNCP(o) SCM_SAL_FUNCP(o)
811
#define SCM_FUNC_TYPECODE(o) SCM_SAL_FUNC_TYPECODE(o)
812
#define SCM_FUNC_CFUNC(o) SCM_SAL_FUNC_CFUNC(o)
813
#define SCM_FUNC_SET_TYPECODE(o, type) SCM_SAL_FUNC_SET_TYPECODE((o), (type))
814
#define SCM_FUNC_SET_CFUNC(o, func) SCM_SAL_FUNC_SET_CFUNC((o), (func))
815
#define SCM_SYNTAXP(o) (SCM_FUNCP(o) \
816
&& (SCM_FUNC_TYPECODE(o) & SCM_FUNCTYPE_SYNTAX))
817
#define SCM_PROCEDUREP(o) ((SCM_FUNCP(o) \
818
&& !(SCM_FUNC_TYPECODE(o) & SCM_FUNCTYPE_SYNTAX)) \
820
|| SCM_CONTINUATIONP(o))
821
#if SCM_USE_HYGIENIC_MACRO
822
#define SCM_SYNTACTIC_OBJECTP(o) (SCM_SYNTAXP(o) || SCM_HMACROP(o))
824
#define SCM_SYNTACTIC_OBJECTP(o) (SCM_SYNTAXP(o))
827
#define SCM_CLOSUREP(o) SCM_SAL_CLOSUREP(o)
828
#define SCM_CLOSURE_EXP(o) SCM_SAL_CLOSURE_EXP(o)
829
#define SCM_CLOSURE_ENV(o) SCM_SAL_CLOSURE_ENV(o)
830
#define SCM_CLOSURE_SET_EXP(o, exp) SCM_SAL_CLOSURE_SET_EXP((o), (exp))
831
#define SCM_CLOSURE_SET_ENV(o, env) SCM_SAL_CLOSURE_SET_ENV((o), (env))
834
#define SCM_VECTORP(o) SCM_SAL_VECTORP(o)
835
#define SCM_VECTOR_VEC(o) SCM_SAL_VECTOR_VEC(o)
836
#define SCM_VECTOR_LEN(o) SCM_SAL_VECTOR_LEN(o)
837
#define SCM_VECTOR_SET_VEC(o, vec) SCM_SAL_VECTOR_SET_VEC((o), (vec))
838
#define SCM_VECTOR_SET_LEN(o, len) SCM_SAL_VECTOR_SET_LEN((o), (len))
839
#define SCM_VECTOR_MUTABLEP(o) SCM_SAL_VECTOR_MUTABLEP(o)
840
#define SCM_VECTOR_SET_MUTABLE(o) SCM_SAL_VECTOR_SET_MUTABLE(o)
841
#define SCM_VECTOR_SET_IMMUTABLE(o) SCM_SAL_VECTOR_SET_IMMUTABLE(o)
842
#define SCM_VECTOR_VALID_INDEXP(o, i) (0 <= (i) && (i) < SCM_VECTOR_LEN(o))
843
#endif /* SCM_USE_VECTOR */
846
#define SCM_PORTP(o) SCM_SAL_PORTP(o)
847
#define SCM_PORT_FLAG(o) SCM_SAL_PORT_FLAG(o)
848
#define SCM_PORT_IMPL(o) SCM_SAL_PORT_IMPL(o)
849
#define SCM_PORT_SET_FLAG(o, flag) SCM_SAL_PORT_SET_FLAG((o), (flag))
850
#define SCM_PORT_SET_IMPL(o, impl) SCM_SAL_PORT_SET_IMPL((o), (impl))
851
#endif /* SCM_USE_PORT */
853
#if (SCM_USE_CONTINUATION || SCM_USE_VALUES_APPLIER)
854
#define SCM_CONTINUATIONP(o) SCM_SAL_CONTINUATIONP(o)
855
#define SCM_CONTINUATION_OPAQUE(o) SCM_SAL_CONTINUATION_OPAQUE(o)
856
#define SCM_CONTINUATION_TAG(o) SCM_SAL_CONTINUATION_TAG(o)
857
#define SCM_CONTINUATION_SET_OPAQUE(o, val) \
858
SCM_SAL_CONTINUATION_SET_OPAQUE((o), (val))
859
#define SCM_CONTINUATION_SET_TAG(o, val) \
860
SCM_SAL_CONTINUATION_SET_TAG((o), (val))
861
#endif /* (SCM_USE_CONTINUATION || SCM_USE_VALUES_APPLIER) */
863
#define SCM_VALUEPACKETP(o) SCM_SAL_VALUEPACKETP(o)
865
#define SCM_CONSTANTP(o) SCM_SAL_CONSTANTP(o)
867
#if SCM_USE_SSCM_EXTENSIONS
868
#define SCM_C_POINTERP(o) SCM_SAL_C_POINTERP(o)
869
#define SCM_C_POINTER_VALUE(o) SCM_SAL_C_POINTER_VALUE(o)
870
#define SCM_C_POINTER_SET_VALUE(o, ptr) SCM_SAL_C_POINTER_SET_VALUE((o), (ptr))
872
#define SCM_C_FUNCPOINTERP(o) SCM_SAL_C_FUNCPOINTERP(o)
873
#define SCM_C_FUNCPOINTER_VALUE(o) SCM_SAL_C_FUNCPOINTER_VALUE(o)
874
#define SCM_C_FUNCPOINTER_SET_VALUE(o, funcptr) \
875
SCM_SAL_C_FUNCPOINTER_SET_VALUE((o), (funcptr))
876
#endif /* SCM_USE_SSCM_EXTENSIONS */
878
#if SCM_USE_HYGIENIC_MACRO
879
#define SCM_HMACROP(o) SCM_SAL_HMACROP(o)
880
#define SCM_HMACRO_RULES(o) SCM_SAL_HMACRO_RULES(o)
881
#define SCM_HMACRO_ENV(o) SCM_SAL_HMACRO_ENV(o)
882
#define SCM_HMACRO_SET_RULES(o, r) SCM_SAL_HMACRO_SET_RULES((o), (r))
883
#define SCM_HMACRO_SET_ENV(o, e) SCM_SAL_HMACRO_SET_ENV((o), (e))
884
#define SCM_FARSYMBOLP(o) SCM_SAL_FARSYMBOLP(o)
885
#define SCM_FARSYMBOL_SYM(o) SCM_SAL_FARSYMBOL_SYM(o)
886
#define SCM_FARSYMBOL_ENV(o) SCM_SAL_FARSYMBOL_ENV(o)
887
#define SCM_FARSYMBOL_SET_SYM(o, s) SCM_SAL_FARSYMBOL_SET_SYM((o), (s))
888
#define SCM_FARSYMBOL_SET_ENV(o, e) SCM_SAL_FARSYMBOL_SET_ENV((o), (e))
889
#define SCM_SUBPATP(o) SCM_SAL_SUBPATP(o)
890
#define SCM_SUBPAT_OBJ(o) SCM_SAL_SUBPAT_OBJ(o)
891
#define SCM_SUBPAT_META(o) SCM_SAL_SUBPAT_META(o)
892
#define SCM_SUBPAT_SET_OBJ(o, x) SCM_SAL_SUBPAT_SET_OBJ((o), (x))
893
#define SCM_SUBPAT_SET_META(o, m) SCM_SAL_SUBPAT_SET_META((o), (m))
896
/* Marks where pattern variable were present in the original pattern.
897
* Records the symbol and index of the pattern variable. See macro.c
898
* for the terminology. It's generally not a good idea to directly
899
* manipulate compiled macro bodies, though. */
901
#define SCM_SUBPAT_MAKE_PVAR(obj, idx) (MAKE_SUBPAT((obj), (idx)))
902
#else /* not SCM_DEBUG_MACRO */
903
#define SCM_SUBPAT_MAKE_PVAR(obj, idx) MAKE_SUBPAT(SCM_NULL, (idx))
904
#endif /* not SCM_DEBUG_MACRO */
905
#define SCM_SUBPAT_PVAR_INDEX(obj) SCM_SUBPAT_META(obj)
906
#define SCM_SUBPAT_PVARP(obj) (SCM_SUBPAT_PVAR_INDEX(obj) >= 0)
908
/* Repeatable subpattern. Contains the subpattern and the number of
909
* pattern variables within it. */
910
#define SCM_SUBPAT_MAKE_REPPAT(subpat, pvcount) \
911
(MAKE_SUBPAT((subpat), ~(pvcount)))
912
#define SCM_SUBPAT_REPPAT_PAT(subpat) SCM_SUBPAT_OBJ(subpat)
913
#define SCM_SUBPAT_REPPAT_PVCOUNT(subpat) (~(SCM_SUBPAT_META(subpat)))
914
#define SCM_SUBPAT_REPPATP(obj) (SCM_SUBPAT_PVAR_INDEX(obj) < 0)
916
#define SCM_IDENTIFIERP(o) (SCM_SYMBOLP(o) || SCM_FARSYMBOLP(o))
917
#else /* not SCM_USE_HYGIENIC_MACRO */
918
#define SCM_IDENTIFIERP(o) SCM_SYMBOLP(o)
919
#endif /* not SCM_USE_HYGIENIC_MACRO */
921
/*===========================================================================
923
===========================================================================*/
924
#if SCM_USE_HYGIENIC_MACRO
926
* Strips the argument of binding information. Syntaxes that take
927
* verbatim data as their argument (e.g. quote, case) must unwrap that
928
* argument before using it. UNWRAP_SYNTAX() may or may not
929
* destructively unwrap the input, so the return value must always be
930
* used. The caller shouldn't assume the input is equal? before and
933
#define SCM_UNWRAP_SYNTAX(o) scm_unwrap_syntaxx((o))
936
* If the argument is an identifier, it is stripped of binding
937
* information and returned. Otherwise, the argument is returned
938
* without any modification.
940
#define SCM_UNWRAP_KEYWORD(o) scm_unwrap_keyword(o)
941
#else /* not SCM_USE_HYGIENIC_MACRO */
942
#define SCM_UNWRAP_SYNTAX(o) (o)
943
#define SCM_UNWRAP_KEYWORD(o) (o)
946
/*===========================================================================
947
Environment Specifiers
948
===========================================================================*/
949
#define SCM_INTERACTION_ENV SCM_SAL_INTERACTION_ENV
951
* Current implementation cannot handle scheme-report-environment and
952
* null-environment properly. Be careful to use these environemnts.
954
#define SCM_R5RS_ENV SCM_SAL_R5RS_ENV
955
#define SCM_NULL_ENV SCM_SAL_NULL_ENV
957
#define SCM_ENVP(env) SCM_SAL_ENVP(env)
959
/*===========================================================================
960
Abstract ScmObj Reference For Storage-Representation Independent Efficient
962
===========================================================================*/
963
#define SCM_INVALID_REF SCM_SAL_INVALID_REF
965
/* refer car slot of a cons cell */
966
#define SCM_REF_CAR(kons) SCM_SAL_REF_CAR(kons)
967
/* refer cdr slot of a cons cell */
968
#define SCM_REF_CDR(kons) SCM_SAL_REF_CDR(kons)
969
/* refer an off-heap object */
970
#define SCM_REF_OFF_HEAP(obj) SCM_SAL_REF_OFF_HEAP(obj)
972
/* SCM_DEREF(ref) is not permitted to be used as lvalue */
973
#define SCM_DEREF(ref) SCM_SAL_DEREF(ref)
975
/* RFC: Is there a better name? */
976
#define SCM_SET(ref, obj) SCM_SAL_SET((ref), (obj))
978
/*===========================================================================
979
Special Constants and Predicates
980
===========================================================================*/
981
#define SCM_INVALID SCM_SAL_INVALID
982
#define SCM_NULL SCM_SAL_NULL
983
#define SCM_TRUE SCM_SAL_TRUE
984
#define SCM_FALSE SCM_SAL_FALSE
985
#define SCM_EOF SCM_SAL_EOF
986
#define SCM_UNBOUND SCM_SAL_UNBOUND
987
#define SCM_UNDEF SCM_SAL_UNDEF
989
#define SCM_EQ(a, b) (SCM_SAL_EQ((a), (b)))
990
#define SCM_NULLP(o) (SCM_EQ((o), SCM_NULL))
991
#define SCM_FALSEP(o) (SCM_EQ((o), SCM_FALSE))
992
#define SCM_TRUEP(o) (!SCM_FALSEP(o))
993
#define SCM_EOFP(o) (SCM_EQ((o), SCM_EOF))
996
#define SCM_EQVP(a, b) SCM_SAL_EQVP((a), (b))
997
#else /* don't have inlined eqv? */
998
#define SCM_EQVP(a, b) SCM_TRUEP(scm_p_eqvp((a), (b)))
999
#endif /* don't have inlined eqv? */
1001
/*===========================================================================
1003
===========================================================================*/
1004
/* for list construction */
1005
/* Don't use scm_sym_* directly. */
1006
#define SCM_SYM_QUOTE scm_sym_quote
1007
#define SCM_SYM_QUASIQUOTE scm_sym_quasiquote
1008
#define SCM_SYM_UNQUOTE scm_sym_unquote
1009
#define SCM_SYM_UNQUOTE_SPLICING scm_sym_unquote_splicing
1010
#define SCM_SYM_ELLIPSIS scm_sym_ellipsis
1012
/*=======================================
1014
=======================================*/
1016
SCM_VALTYPE_AS_IS = scm_false,
1017
SCM_VALTYPE_NEED_EVAL = scm_true
1021
* for strict top-level definitions
1023
* R5RS: 7.1.6 Programs and definitions
1025
* <program> --> <command or definition>*
1026
* <command or definition> --> <command>
1028
* | <syntax definition>
1029
* | (begin <command or definition>+)
1030
* <definition> --> (define <variable> <expression>)
1031
* | (define (<variable> <def formals>) <body>)
1032
* | (begin <definition>*)
1033
* <command> --> <expression>
1037
SCM_NEST_COMMAND_OR_DEFINITION,
1039
SCM_NEST_RETTYPE_BEGIN
1042
/* whether top-level 'define' can be performed */
1043
#if SCM_STRICT_TOPLEVEL_DEFINITIONS
1044
#define SCM_DEFINABLE_TOPLEVELP(eval_state) \
1045
(!EQ((eval_state)->env, SCM_INTERACTION_ENV_INDEFINABLE) \
1046
&& scm_toplevel_environmentp((eval_state)->env) \
1047
&& ((eval_state)->nest == SCM_NEST_PROGRAM \
1048
|| (eval_state)->nest == SCM_NEST_COMMAND_OR_DEFINITION))
1050
#define SCM_DEFINABLE_TOPLEVELP(eval_state) \
1051
(scm_toplevel_environmentp((eval_state)->env))
1054
typedef struct ScmEvalState_ ScmEvalState;
1055
struct ScmEvalState_ {
1057
enum ScmValueType ret_type;
1058
enum ScmNestState nest;
1061
/* Use these constructors instead of manually initialize each members because
1062
* another member may be added. Such member will implicitly be initialized
1063
* properly as long as the constructors are used. */
1064
#define SCM_EVAL_STATE_INIT(state) \
1065
SCM_EVAL_STATE_INIT1((state), SCM_INTERACTION_ENV)
1067
#define SCM_EVAL_STATE_INIT1(state, env) \
1068
SCM_EVAL_STATE_INIT2((state), (env), SCM_VALTYPE_NEED_EVAL)
1070
#define SCM_EVAL_STATE_INIT2(state, env, ret_type) \
1071
SCM_EVAL_STATE_INIT3((state), (env), (ret_type), \
1072
(SCM_EQ((env), SCM_INTERACTION_ENV)) \
1073
? SCM_NEST_PROGRAM : SCM_NEST_COMMAND)
1075
#define SCM_EVAL_STATE_INIT3(state, _env, _ret_type, _nest) \
1077
(state).env = (_env); \
1078
(state).ret_type = (_ret_type); \
1079
(state).nest = (_nest); \
1080
} while (/* CONSTCOND */ 0)
1082
#define SCM_FINISH_TAILREC_CALL(obj, eval_state) \
1083
(((eval_state)->ret_type == SCM_VALTYPE_NEED_EVAL) \
1084
? ((eval_state)->ret_type = SCM_VALTYPE_AS_IS, \
1085
EVAL((obj), (eval_state)->env)) \
1088
/*=======================================
1090
=======================================*/
1092
enum ScmFormatCapability {
1094
SCM_FMT_RAW_C = 1 << 0, /* take raw C values from va_list */
1095
SCM_FMT_SRFI28 = 1 << 1,
1096
SCM_FMT_SRFI48_ADDENDUM = 1 << 2,
1097
SCM_FMT_LEADING_ZEROS = 1 << 3, /* padding with zeros "00034" */
1098
SCM_FMT_PREFIXED_RADIX = 1 << 4, /* "8x" 65535 => " ffff" */
1100
SCM_FMT_SRFI48 = (SCM_FMT_SRFI28 | SCM_FMT_SRFI48_ADDENDUM),
1101
SCM_FMT_SSCM_ADDENDUM = (SCM_FMT_LEADING_ZEROS | SCM_FMT_PREFIXED_RADIX),
1102
SCM_FMT_SSCM = (SCM_FMT_SRFI48 | SCM_FMT_SSCM_ADDENDUM),
1103
SCM_FMT_INTERNAL = (SCM_FMT_RAW_C | SCM_FMT_SSCM)
1105
#endif /* SCM_USE_FORMAT */
1107
typedef struct ScmValueFormat_ ScmValueFormat;
1108
struct ScmValueFormat_ {
1109
signed char width; /* integer part width */
1110
signed char frac_width; /* fractional part width */
1111
char pad; /* char for padding prefix */
1115
#define SCM_VALUE_FORMAT_INIT(vfmt) \
1116
SCM_VALUE_FORMAT_INIT4((vfmt), -1, -1, ' ', scm_true)
1118
#define SCM_VALUE_FORMAT_INIT4(vfmt, w, fw, p, s) \
1120
(vfmt).width = (w); \
1121
(vfmt).frac_width = (fw); \
1123
(vfmt).signedp = (s); \
1124
} while (/* CONSTCOND */ 0)
1126
#define SCM_VALUE_FORMAT_SPECIFIEDP(vfmt) \
1127
((vfmt).width > 0 || (vfmt).frac_width > 0 || (vfmt).pad != ' ' \
1130
/*=======================================
1132
=======================================*/
1133
struct scm_func_registration_info {
1134
const char *funcname;
1136
enum ScmFuncTypeCode typecode;
1139
typedef ScmObj (*scm_reduction_operator)(ScmObj, ScmObj, enum ScmReductionState *);
1140
typedef ScmObj (*scm_syntax_fixed_0)(ScmObj);
1141
typedef ScmObj (*scm_syntax_fixed_tailrec_0)(ScmEvalState *);
1142
typedef ScmObj (*scm_syntax_variadic_0)(ScmObj, ScmObj);
1143
typedef ScmObj (*scm_syntax_variadic_tailrec_0)(ScmObj, ScmEvalState *);
1144
typedef ScmObj (*scm_procedure_fixed_0)(void);
1145
typedef ScmObj (*scm_procedure_fixed_tailrec_0)(ScmEvalState *);
1146
typedef ScmObj (*scm_procedure_variadic_0)(ScmObj);
1147
typedef ScmObj (*scm_procedure_variadic_tailrec_0)(ScmObj, ScmEvalState *);
1148
#if SCM_FUNCTYPE_MAND_MAX >= 1
1149
typedef ScmObj (*scm_syntax_fixed_1)(ScmObj, ScmObj);
1150
typedef ScmObj (*scm_syntax_fixed_tailrec_1)(ScmObj, ScmEvalState *);
1151
typedef ScmObj (*scm_syntax_variadic_1)(ScmObj, ScmObj, ScmObj);
1152
typedef ScmObj (*scm_syntax_variadic_tailrec_1)(ScmObj, ScmObj, ScmEvalState *);
1153
typedef ScmObj (*scm_procedure_fixed_1)(ScmObj);
1154
typedef ScmObj (*scm_procedure_fixed_tailrec_1)(ScmObj, ScmEvalState *);
1155
typedef ScmObj (*scm_procedure_variadic_1)(ScmObj, ScmObj);
1156
typedef ScmObj (*scm_procedure_variadic_tailrec_1)(ScmObj, ScmObj, ScmEvalState *);
1158
#if SCM_FUNCTYPE_MAND_MAX >= 2
1159
typedef ScmObj (*scm_syntax_fixed_2)(ScmObj, ScmObj, ScmObj);
1160
typedef ScmObj (*scm_syntax_fixed_tailrec_2)(ScmObj, ScmObj, ScmEvalState *);
1161
typedef ScmObj (*scm_syntax_variadic_2)(ScmObj, ScmObj, ScmObj, ScmObj);
1162
typedef ScmObj (*scm_syntax_variadic_tailrec_2)(ScmObj, ScmObj, ScmObj, ScmEvalState *);
1163
typedef ScmObj (*scm_procedure_fixed_2)(ScmObj, ScmObj);
1164
typedef ScmObj (*scm_procedure_fixed_tailrec_2)(ScmObj, ScmObj, ScmEvalState *);
1165
typedef ScmObj (*scm_procedure_variadic_2)(ScmObj, ScmObj, ScmObj);
1166
typedef ScmObj (*scm_procedure_variadic_tailrec_2)(ScmObj, ScmObj, ScmObj, ScmEvalState *);
1168
#if SCM_FUNCTYPE_MAND_MAX >= 3
1169
typedef ScmObj (*scm_syntax_fixed_3)(ScmObj, ScmObj, ScmObj, ScmObj);
1170
typedef ScmObj (*scm_syntax_fixed_tailrec_3)(ScmObj, ScmObj, ScmObj, ScmEvalState *);
1171
typedef ScmObj (*scm_syntax_variadic_3)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj);
1172
typedef ScmObj (*scm_syntax_variadic_tailrec_3)(ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState *);
1173
typedef ScmObj (*scm_procedure_fixed_3)(ScmObj, ScmObj, ScmObj);
1174
typedef ScmObj (*scm_procedure_fixed_tailrec_3)(ScmObj, ScmObj, ScmObj, ScmEvalState *);
1175
typedef ScmObj (*scm_procedure_variadic_3)(ScmObj, ScmObj, ScmObj, ScmObj);
1176
typedef ScmObj (*scm_procedure_variadic_tailrec_3)(ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState *);
1178
#if SCM_FUNCTYPE_MAND_MAX >= 4
1179
typedef ScmObj (*scm_syntax_fixed_4)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj);
1180
typedef ScmObj (*scm_syntax_fixed_tailrec_4)(ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState *);
1181
typedef ScmObj (*scm_syntax_variadic_4)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmObj);
1182
typedef ScmObj (*scm_syntax_variadic_tailrec_4)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState *);
1183
typedef ScmObj (*scm_procedure_fixed_4)(ScmObj, ScmObj, ScmObj, ScmObj);
1184
typedef ScmObj (*scm_procedure_fixed_tailrec_4)(ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState *);
1185
typedef ScmObj (*scm_procedure_variadic_4)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj);
1186
typedef ScmObj (*scm_procedure_variadic_tailrec_4)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState *);
1188
#if SCM_FUNCTYPE_MAND_MAX >= 5
1189
typedef ScmObj (*scm_syntax_fixed_5)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmObj);
1190
typedef ScmObj (*scm_syntax_fixed_tailrec_5)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState *);
1191
typedef ScmObj (*scm_syntax_variadic_5)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmObj);
1192
typedef ScmObj (*scm_syntax_variadic_tailrec_5)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState *);
1193
typedef ScmObj (*scm_procedure_fixed_5)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj);
1194
typedef ScmObj (*scm_procedure_fixed_tailrec_5)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState *);
1195
typedef ScmObj (*scm_procedure_variadic_5)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmObj);
1196
typedef ScmObj (*scm_procedure_variadic_tailrec_5)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState *);
1199
/*=======================================
1200
Variable Declarations
1201
=======================================*/
1203
/* Don't use scm_sym_* directly. Use SCM_SYM_* instead. */
1204
SCM_GLOBAL_VARS_BEGIN(syntax);
1205
ScmObj scm_sym_quote, scm_sym_quasiquote;
1206
ScmObj scm_sym_unquote, scm_sym_unquote_splicing;
1207
ScmObj scm_sym_ellipsis;
1208
SCM_GLOBAL_VARS_END(syntax);
1209
#define scm_sym_quote SCM_GLOBAL_VAR(syntax, scm_sym_quote)
1210
#define scm_sym_quasiquote SCM_GLOBAL_VAR(syntax, scm_sym_quasiquote)
1211
#define scm_sym_unquote SCM_GLOBAL_VAR(syntax, scm_sym_unquote)
1212
#define scm_sym_unquote_splicing SCM_GLOBAL_VAR(syntax, scm_sym_unquote_splicing)
1213
#define scm_sym_ellipsis SCM_GLOBAL_VAR(syntax, scm_sym_ellipsis)
1214
SCM_DECLARE_EXPORTED_VARS(syntax);
1216
/*=======================================
1217
Function Declarations
1218
=======================================*/
1219
/*===========================================================================
1220
SigScheme: Core Functions
1221
===========================================================================*/
1223
SCM_EXPORT void scm_initialize(const ScmStorageConf *storage_conf);
1224
SCM_EXPORT void scm_finalize(void);
1225
#if SCM_USE_EVAL_C_STRING
1226
SCM_EXPORT ScmObj scm_eval_c_string(const char *exp);
1230
SCM_EXPORT void scm_provide(ScmObj feature);
1231
SCM_EXPORT scm_bool scm_providedp(ScmObj feature);
1232
SCM_EXPORT scm_bool scm_use(const char *feature);
1233
SCM_EXPORT ScmObj scm_s_use(ScmObj feature, ScmObj env);
1234
SCM_EXPORT ScmObj scm_register_func(const char *name, ScmFuncType func,
1235
enum ScmFuncTypeCode type);
1236
SCM_EXPORT void scm_register_funcs(const struct scm_func_registration_info *table);
1237
SCM_EXPORT void scm_define_alias(const char *newsym, const char *sym);
1240
SCM_EXPORT void *scm_malloc_aligned(size_t size);
1241
SCM_EXPORT void *scm_malloc(size_t size);
1242
SCM_EXPORT void *scm_calloc(size_t number, size_t size);
1243
SCM_EXPORT void *scm_realloc(void *ptr, size_t size);
1244
SCM_EXPORT char *scm_strdup(const char *str);
1247
SCM_EXPORT void scm_gc_protect(ScmObj *var);
1248
SCM_EXPORT void scm_gc_protect_with_init(ScmObj *var, ScmObj init_val);
1249
SCM_EXPORT void scm_gc_unprotect(ScmObj *var);
1250
SCM_EXPORT void *scm_call_with_gc_ready_stack(ScmGCGateFunc func, void *arg);
1253
SCM_EXPORT ScmObj scm_intern(const char *name);
1254
SCM_EXPORT ScmObj scm_symbol_bound_to(ScmObj obj);
1257
SCM_EXPORT enum ScmDebugCategory scm_debug_categories(void);
1258
SCM_EXPORT void scm_set_debug_categories(enum ScmDebugCategory categories);
1259
SCM_EXPORT enum ScmDebugCategory scm_predefined_debug_categories(void);
1261
SCM_EXPORT void scm_categorized_debug(enum ScmDebugCategory category,
1262
const char *msg, ...);
1263
SCM_EXPORT void scm_debug(const char *msg, ...);
1264
#endif /* SCM_DEBUG */
1265
SCM_EXPORT void scm_die(const char *msg, const char *filename, int line) SCM_NORETURN;
1266
SCM_EXPORT void scm_plain_error(const char *msg, ...) SCM_NORETURN;
1267
SCM_EXPORT void scm_error(const char *funcname, const char *msg, ...) SCM_NORETURN;
1268
SCM_EXPORT void scm_error_obj(const char *funcname, const char *msg,
1269
ScmObj obj) SCM_NORETURN;
1270
SCM_EXPORT void scm_show_backtrace(ScmObj trace_stack);
1271
SCM_EXPORT ScmObj scm_make_error_obj(ScmObj reason, ScmObj objs);
1272
SCM_EXPORT void scm_raise_error(ScmObj err_obj) SCM_NORETURN;
1273
SCM_EXPORT void scm_fatal_error(const char *msg) SCM_NORETURN;
1274
SCM_EXPORT void scm_set_fatal_error_callback(void (*cb)(void));
1275
SCM_EXPORT ScmObj scm_p_error_objectp(ScmObj obj);
1276
SCM_EXPORT ScmObj scm_p_fatal_error(ScmObj err_obj) SCM_NORETURN;
1277
SCM_EXPORT ScmObj scm_p_inspect_error(ScmObj err_obj);
1278
SCM_EXPORT ScmObj scm_p_backtrace(void);
1281
SCM_EXPORT ScmObj scm_symbol_value(ScmObj var, ScmObj env);
1282
SCM_EXPORT ScmObj scm_eval(ScmObj obj, ScmObj env);
1283
SCM_EXPORT ScmObj scm_call(ScmObj proc, ScmObj args);
1284
SCM_EXPORT ScmObj scm_p_eval(ScmObj obj, ScmObj env);
1285
SCM_EXPORT ScmObj scm_p_apply(ScmObj proc, ScmObj arg0, ScmObj rest,
1286
ScmEvalState *eval_state);
1287
SCM_EXPORT ScmObj scm_p_scheme_report_environment(ScmObj version);
1288
SCM_EXPORT ScmObj scm_p_null_environment(ScmObj version);
1289
SCM_EXPORT ScmObj scm_p_interaction_environment(void);
1292
SCM_EXPORT ScmObj scm_s_quote(ScmObj datum, ScmObj env);
1293
SCM_EXPORT ScmObj scm_s_lambda(ScmObj formals, ScmObj body, ScmObj env);
1294
SCM_EXPORT ScmObj scm_s_if(ScmObj test, ScmObj conseq, ScmObj rest,
1295
ScmEvalState *eval_state);
1296
SCM_EXPORT ScmObj scm_s_setx(ScmObj var, ScmObj val, ScmObj env);
1297
SCM_EXPORT ScmObj scm_s_cond(ScmObj clauses, ScmEvalState *eval_state);
1298
SCM_EXPORT ScmObj scm_s_case(ScmObj key, ScmObj args,
1299
ScmEvalState *eval_state);
1300
SCM_EXPORT ScmObj scm_s_and(ScmObj args, ScmEvalState *eval_state);
1301
SCM_EXPORT ScmObj scm_s_or(ScmObj args, ScmEvalState *eval_state);
1302
SCM_EXPORT ScmObj scm_s_let(ScmObj bindings, ScmObj body,
1303
ScmEvalState *eval_state);
1304
SCM_EXPORT ScmObj scm_s_letstar(ScmObj bindings, ScmObj body,
1305
ScmEvalState *eval_state);
1306
SCM_EXPORT ScmObj scm_s_letrec(ScmObj bindings, ScmObj body,
1307
ScmEvalState *eval_state);
1308
SCM_EXPORT ScmObj scm_s_begin(ScmObj args, ScmEvalState *eval_state);
1309
SCM_EXPORT ScmObj scm_s_do(ScmObj bindings, ScmObj test_exps, ScmObj commands,
1310
ScmEvalState *eval_state);
1311
SCM_EXPORT ScmObj scm_s_define(ScmObj var, ScmObj rest,
1312
ScmEvalState *eval_state);
1315
#if SCM_USE_QUASIQUOTE
1316
SCM_EXPORT ScmObj scm_s_quasiquote(ScmObj datum, ScmObj env);
1317
SCM_EXPORT ScmObj scm_s_unquote(ScmObj dummy, ScmObj env);
1318
SCM_EXPORT ScmObj scm_s_unquote_splicing(ScmObj dummy, ScmObj env);
1319
#endif /* SCM_USE_QUASIQUOTE */
1323
SCM_EXPORT ScmObj scm_s_delay(ScmObj exp, ScmObj env);
1324
SCM_EXPORT ScmObj scm_p_force(ScmObj promise);
1325
#endif /* SCM_USE_PROMISE */
1328
SCM_EXPORT ScmObj scm_p_eqp(ScmObj obj1, ScmObj obj2);
1329
SCM_EXPORT ScmObj scm_p_eqvp(ScmObj obj1, ScmObj obj2);
1330
SCM_EXPORT ScmObj scm_p_equalp(ScmObj obj1, ScmObj obj2);
1331
SCM_EXPORT ScmObj scm_p_not(ScmObj obj);
1332
SCM_EXPORT ScmObj scm_p_booleanp(ScmObj obj);
1333
SCM_EXPORT ScmObj scm_p_symbolp(ScmObj obj);
1334
SCM_EXPORT ScmObj scm_p_symbol2string(ScmObj sym);
1335
SCM_EXPORT ScmObj scm_p_string2symbol(ScmObj str);
1336
SCM_EXPORT ScmObj scm_p_procedurep(ScmObj obj);
1337
SCM_EXPORT ScmObj scm_p_map(ScmObj proc, ScmObj args);
1338
SCM_EXPORT ScmObj scm_p_for_each(ScmObj proc, ScmObj args);
1339
#if SCM_USE_CONTINUATION
1340
SCM_EXPORT ScmObj scm_p_call_with_current_continuation(ScmObj proc, ScmEvalState *eval_state);
1342
SCM_EXPORT ScmObj scm_p_values(ScmObj args);
1343
SCM_EXPORT ScmObj scm_p_call_with_values(ScmObj producer, ScmObj consumer,
1344
ScmEvalState *eval_state);
1345
#if SCM_USE_CONTINUATION
1346
SCM_EXPORT ScmObj scm_p_dynamic_wind(ScmObj before, ScmObj thunk,
1351
SCM_EXPORT scm_int_t scm_length(ScmObj lst);
1352
SCM_EXPORT ScmObj scm_list_tail(ScmObj lst, scm_int_t k);
1353
SCM_EXPORT ScmObj scm_p_pairp(ScmObj obj);
1354
SCM_EXPORT ScmObj scm_p_cons(ScmObj car, ScmObj cdr);
1355
SCM_EXPORT ScmObj scm_p_car(ScmObj obj);
1356
SCM_EXPORT ScmObj scm_p_cdr(ScmObj obj);
1357
SCM_EXPORT ScmObj scm_p_set_carx(ScmObj pair, ScmObj car);
1358
SCM_EXPORT ScmObj scm_p_set_cdrx(ScmObj pair, ScmObj cdr);
1359
SCM_EXPORT ScmObj scm_p_caar(ScmObj lst);
1360
SCM_EXPORT ScmObj scm_p_cadr(ScmObj lst);
1361
SCM_EXPORT ScmObj scm_p_cdar(ScmObj lst);
1362
SCM_EXPORT ScmObj scm_p_cddr(ScmObj lst);
1363
SCM_EXPORT ScmObj scm_p_caddr(ScmObj lst);
1364
SCM_EXPORT ScmObj scm_p_cdddr(ScmObj lst);
1365
SCM_EXPORT ScmObj scm_p_nullp(ScmObj obj);
1366
SCM_EXPORT ScmObj scm_p_listp(ScmObj obj);
1367
SCM_EXPORT ScmObj scm_p_list(ScmObj args);
1368
SCM_EXPORT ScmObj scm_p_length(ScmObj obj);
1369
SCM_EXPORT ScmObj scm_p_append(ScmObj args);
1370
SCM_EXPORT ScmObj scm_p_reverse(ScmObj lst);
1371
SCM_EXPORT ScmObj scm_p_list_tail(ScmObj lst, ScmObj k);
1372
SCM_EXPORT ScmObj scm_p_list_ref(ScmObj lst, ScmObj k);
1373
SCM_EXPORT ScmObj scm_p_memq(ScmObj obj, ScmObj lst);
1374
SCM_EXPORT ScmObj scm_p_memv(ScmObj obj, ScmObj lst);
1375
SCM_EXPORT ScmObj scm_p_member(ScmObj obj, ScmObj lst);
1376
SCM_EXPORT ScmObj scm_p_assq(ScmObj obj, ScmObj alist);
1377
SCM_EXPORT ScmObj scm_p_assv(ScmObj obj, ScmObj alist);
1378
SCM_EXPORT ScmObj scm_p_assoc(ScmObj obj, ScmObj alist);
1382
SCM_EXPORT ScmObj scm_p_add(ScmObj left, ScmObj right,
1383
enum ScmReductionState *state);
1384
SCM_EXPORT ScmObj scm_p_subtract(ScmObj left, ScmObj right,
1385
enum ScmReductionState *state);
1386
SCM_EXPORT ScmObj scm_p_multiply(ScmObj left, ScmObj right,
1387
enum ScmReductionState *state);
1388
SCM_EXPORT ScmObj scm_p_divide(ScmObj left, ScmObj right,
1389
enum ScmReductionState *state);
1390
SCM_EXPORT ScmObj scm_p_equal(ScmObj left, ScmObj right,
1391
enum ScmReductionState *state);
1392
SCM_EXPORT ScmObj scm_p_less(ScmObj left, ScmObj right,
1393
enum ScmReductionState *state);
1394
SCM_EXPORT ScmObj scm_p_less_equal(ScmObj left, ScmObj right,
1395
enum ScmReductionState *state);
1396
SCM_EXPORT ScmObj scm_p_greater(ScmObj left, ScmObj right,
1397
enum ScmReductionState *state);
1398
SCM_EXPORT ScmObj scm_p_greater_equal(ScmObj left, ScmObj right,
1399
enum ScmReductionState *state);
1400
SCM_EXPORT ScmObj scm_p_numberp(ScmObj obj);
1401
SCM_EXPORT ScmObj scm_p_integerp(ScmObj obj);
1402
SCM_EXPORT ScmObj scm_p_zerop(ScmObj n);
1403
SCM_EXPORT ScmObj scm_p_positivep(ScmObj n);
1404
SCM_EXPORT ScmObj scm_p_negativep(ScmObj n);
1405
SCM_EXPORT ScmObj scm_p_oddp(ScmObj n);
1406
SCM_EXPORT ScmObj scm_p_evenp(ScmObj n);
1407
SCM_EXPORT ScmObj scm_p_max(ScmObj left, ScmObj right,
1408
enum ScmReductionState *state);
1409
SCM_EXPORT ScmObj scm_p_min(ScmObj left, ScmObj right,
1410
enum ScmReductionState *state);
1411
SCM_EXPORT ScmObj scm_p_abs(ScmObj _n);
1412
SCM_EXPORT ScmObj scm_p_quotient(ScmObj _n1, ScmObj _n2);
1413
SCM_EXPORT ScmObj scm_p_modulo(ScmObj _n1, ScmObj _n2);
1414
SCM_EXPORT ScmObj scm_p_remainder(ScmObj _n1, ScmObj _n2);
1415
#endif /* SCM_USE_NUMBER */
1418
#if SCM_USE_NUMBER_IO
1419
SCM_EXPORT scm_int_t scm_string2number(const char *str, int radix,
1422
SCM_EXPORT char *scm_int2string(ScmValueFormat vfmt, uintmax_t n, int radix);
1423
SCM_EXPORT ScmObj scm_p_number2string(ScmObj num, ScmObj args);
1424
SCM_EXPORT ScmObj scm_p_string2number(ScmObj str, ScmObj args);
1425
#endif /* SCM_USE_STRING */
1426
#endif /* SCM_USE_NUMBER_IO */
1430
SCM_EXPORT ScmObj scm_p_charp(ScmObj obj);
1431
SCM_EXPORT ScmObj scm_p_char_equalp(ScmObj ch1, ScmObj ch2);
1432
SCM_EXPORT ScmObj scm_p_char_lessp(ScmObj ch1, ScmObj ch2);
1433
SCM_EXPORT ScmObj scm_p_char_greaterp(ScmObj ch1, ScmObj ch2);
1434
SCM_EXPORT ScmObj scm_p_char_less_equalp(ScmObj ch1, ScmObj ch2);
1435
SCM_EXPORT ScmObj scm_p_char_greater_equalp(ScmObj ch1, ScmObj ch2);
1436
SCM_EXPORT ScmObj scm_p_char_ci_equalp(ScmObj ch1, ScmObj ch2);
1437
SCM_EXPORT ScmObj scm_p_char_ci_lessp(ScmObj ch1, ScmObj ch2);
1438
SCM_EXPORT ScmObj scm_p_char_ci_greaterp(ScmObj ch1, ScmObj ch2);
1439
SCM_EXPORT ScmObj scm_p_char_ci_less_equalp(ScmObj ch1, ScmObj ch2);
1440
SCM_EXPORT ScmObj scm_p_char_ci_greater_equalp(ScmObj ch1, ScmObj ch2);
1441
SCM_EXPORT ScmObj scm_p_char_alphabeticp(ScmObj ch);
1442
SCM_EXPORT ScmObj scm_p_char_numericp(ScmObj ch);
1443
SCM_EXPORT ScmObj scm_p_char_whitespacep(ScmObj ch);
1444
SCM_EXPORT ScmObj scm_p_char_upper_casep(ScmObj ch);
1445
SCM_EXPORT ScmObj scm_p_char_lower_casep(ScmObj ch);
1446
SCM_EXPORT ScmObj scm_p_char2integer(ScmObj ch);
1447
SCM_EXPORT ScmObj scm_p_integer2char(ScmObj n);
1448
SCM_EXPORT ScmObj scm_p_char_upcase(ScmObj ch);
1449
SCM_EXPORT ScmObj scm_p_char_downcase(ScmObj ch);
1450
#endif /* SCM_USE_CHAR */
1454
SCM_EXPORT ScmObj scm_p_stringp(ScmObj obj);
1455
SCM_EXPORT ScmObj scm_p_string_length(ScmObj str);
1456
SCM_EXPORT ScmObj scm_p_stringequalp(ScmObj str1, ScmObj str2);
1457
SCM_EXPORT ScmObj scm_p_string_append(ScmObj args);
1458
SCM_EXPORT ScmObj scm_p_string_copy(ScmObj str);
1459
#endif /* SCM_USE_STRING */
1461
/* string-procedure.c */
1462
#if SCM_USE_STRING_PROCEDURE
1463
SCM_EXPORT ScmObj scm_p_make_string(ScmObj length, ScmObj args);
1464
SCM_EXPORT ScmObj scm_p_string(ScmObj args);
1465
SCM_EXPORT ScmObj scm_p_string_ref(ScmObj str, ScmObj k);
1466
SCM_EXPORT ScmObj scm_p_string_setx(ScmObj str, ScmObj k, ScmObj ch);
1467
SCM_EXPORT ScmObj scm_p_string_ci_equalp(ScmObj str1, ScmObj str2);
1468
SCM_EXPORT ScmObj scm_p_string_greaterp(ScmObj str1, ScmObj str2);
1469
SCM_EXPORT ScmObj scm_p_string_lessp(ScmObj str1, ScmObj str2);
1470
SCM_EXPORT ScmObj scm_p_string_greater_equalp(ScmObj str1, ScmObj str2);
1471
SCM_EXPORT ScmObj scm_p_string_less_equalp(ScmObj str1, ScmObj str2);
1472
SCM_EXPORT ScmObj scm_p_string_ci_greaterp(ScmObj str1, ScmObj str2);
1473
SCM_EXPORT ScmObj scm_p_string_ci_lessp(ScmObj str1, ScmObj str2);
1474
SCM_EXPORT ScmObj scm_p_string_ci_greater_equalp(ScmObj str1, ScmObj str2);
1475
SCM_EXPORT ScmObj scm_p_string_ci_less_equalp(ScmObj str1, ScmObj str2);
1476
SCM_EXPORT ScmObj scm_p_substring(ScmObj str, ScmObj start, ScmObj end);
1477
SCM_EXPORT ScmObj scm_p_string2list(ScmObj str);
1478
SCM_EXPORT ScmObj scm_p_list2string(ScmObj lst);
1479
SCM_EXPORT ScmObj scm_p_string_fillx(ScmObj str, ScmObj ch);
1480
#endif /* SCM_USE_STRING_PROCEDURE */
1484
SCM_EXPORT ScmObj scm_p_vectorp(ScmObj obj);
1485
SCM_EXPORT ScmObj scm_p_make_vector(ScmObj scm_len, ScmObj args);
1486
SCM_EXPORT ScmObj scm_p_vector(ScmObj args);
1487
SCM_EXPORT ScmObj scm_p_vector_length(ScmObj vec);
1488
SCM_EXPORT ScmObj scm_p_vector_ref(ScmObj vec, ScmObj _k);
1489
SCM_EXPORT ScmObj scm_p_vector_setx(ScmObj vec, ScmObj _k, ScmObj obj);
1490
SCM_EXPORT ScmObj scm_p_vector2list(ScmObj vec);
1491
SCM_EXPORT ScmObj scm_p_list2vector(ScmObj lst);
1492
SCM_EXPORT ScmObj scm_p_vector_fillx(ScmObj vec, ScmObj fill);
1493
#endif /* SCM_USE_VECTOR */
1496
#if SCM_USE_DEEP_CADRS
1497
SCM_EXPORT ScmObj scm_p_caaar(ScmObj lst);
1498
SCM_EXPORT ScmObj scm_p_caadr(ScmObj lst);
1499
SCM_EXPORT ScmObj scm_p_cadar(ScmObj lst);
1500
SCM_EXPORT ScmObj scm_p_cdaar(ScmObj lst);
1501
SCM_EXPORT ScmObj scm_p_cdadr(ScmObj lst);
1502
SCM_EXPORT ScmObj scm_p_cddar(ScmObj lst);
1503
SCM_EXPORT ScmObj scm_p_caaaar(ScmObj lst);
1504
SCM_EXPORT ScmObj scm_p_caaadr(ScmObj lst);
1505
SCM_EXPORT ScmObj scm_p_caadar(ScmObj lst);
1506
SCM_EXPORT ScmObj scm_p_caaddr(ScmObj lst);
1507
SCM_EXPORT ScmObj scm_p_cadaar(ScmObj lst);
1508
SCM_EXPORT ScmObj scm_p_cadadr(ScmObj lst);
1509
SCM_EXPORT ScmObj scm_p_caddar(ScmObj lst);
1510
SCM_EXPORT ScmObj scm_p_cadddr(ScmObj lst);
1511
SCM_EXPORT ScmObj scm_p_cdaaar(ScmObj lst);
1512
SCM_EXPORT ScmObj scm_p_cdaadr(ScmObj lst);
1513
SCM_EXPORT ScmObj scm_p_cdadar(ScmObj lst);
1514
SCM_EXPORT ScmObj scm_p_cdaddr(ScmObj lst);
1515
SCM_EXPORT ScmObj scm_p_cddaar(ScmObj lst);
1516
SCM_EXPORT ScmObj scm_p_cddadr(ScmObj lst);
1517
SCM_EXPORT ScmObj scm_p_cdddar(ScmObj lst);
1518
SCM_EXPORT ScmObj scm_p_cddddr(ScmObj lst);
1519
#endif /* SCM_USE_DEEP_CADRS */
1522
#if SCM_USE_HYGIENIC_MACRO
1523
SCM_EXPORT ScmObj scm_s_match(ScmObj form, ScmObj patterns,
1524
ScmEvalState *state);
1525
SCM_EXPORT ScmObj scm_s_syntax_rules(ScmObj rules, ScmObj env);
1526
SCM_EXPORT ScmObj scm_s_expand_macro(ScmObj macro, ScmObj args,
1527
ScmEvalState *eval_state);
1528
SCM_EXPORT ScmObj scm_s_let_syntax(ScmObj bindings, ScmObj body,
1529
ScmEvalState *eval_state);
1530
SCM_EXPORT ScmObj scm_s_letrec_syntax(ScmObj bindings, ScmObj body,
1531
ScmEvalState *eval_state);
1532
SCM_EXPORT ScmObj scm_s_define_syntax(ScmObj var, ScmObj macro, ScmObj env);
1533
SCM_EXPORT ScmObj scm_unwrap_syntaxx(ScmObj obj);
1534
SCM_EXPORT ScmObj scm_unwrap_keyword(ScmObj obj);
1539
SCM_EXPORT ScmObj scm_make_shared_file_port(FILE *file, const char *aux_info,
1540
enum ScmPortFlag flag);
1541
SCM_EXPORT void scm_port_close(ScmObj port);
1542
SCM_EXPORT ScmCharCodec *scm_port_codec(ScmObj port);
1543
SCM_EXPORT char *scm_port_inspect(ScmObj port);
1544
SCM_EXPORT scm_ichar_t scm_port_get_char(ScmObj port);
1545
SCM_EXPORT scm_ichar_t scm_port_peek_char(ScmObj port);
1546
SCM_EXPORT scm_bool scm_port_char_readyp(ScmObj port);
1547
SCM_EXPORT void scm_port_puts(ScmObj port, const char *str);
1548
SCM_EXPORT void scm_port_put_char(ScmObj port, scm_ichar_t ch);
1549
SCM_EXPORT void scm_port_newline(ScmObj port);
1550
SCM_EXPORT void scm_port_flush(ScmObj port);
1551
SCM_EXPORT ScmObj scm_p_call_with_input_file(ScmObj filepath, ScmObj proc);
1552
SCM_EXPORT ScmObj scm_p_call_with_output_file(ScmObj filepath, ScmObj proc);
1553
SCM_EXPORT ScmObj scm_p_input_portp(ScmObj obj);
1554
SCM_EXPORT ScmObj scm_p_output_portp(ScmObj obj);
1555
SCM_EXPORT ScmObj scm_p_current_input_port(void);
1556
SCM_EXPORT ScmObj scm_p_current_output_port(void);
1557
SCM_EXPORT ScmObj scm_p_with_input_from_file(ScmObj filepath, ScmObj thunk);
1558
SCM_EXPORT ScmObj scm_p_with_output_to_file(ScmObj filepath, ScmObj thunk);
1559
SCM_EXPORT ScmObj scm_p_open_input_file(ScmObj filepath);
1560
SCM_EXPORT ScmObj scm_p_open_output_file(ScmObj filepath);
1561
SCM_EXPORT ScmObj scm_p_close_input_port(ScmObj port);
1562
SCM_EXPORT ScmObj scm_p_close_output_port(ScmObj port);
1564
SCM_EXPORT ScmObj scm_p_read_char(ScmObj args);
1565
SCM_EXPORT ScmObj scm_p_peek_char(ScmObj args);
1566
SCM_EXPORT ScmObj scm_p_char_readyp(ScmObj args);
1568
SCM_EXPORT ScmObj scm_p_eof_objectp(ScmObj obj);
1569
SCM_EXPORT ScmObj scm_p_newline(ScmObj args);
1571
SCM_EXPORT ScmObj scm_p_write_char(ScmObj obj, ScmObj args);
1573
#endif /* SCM_USE_PORT */
1577
SCM_EXPORT ScmObj scm_read(ScmObj port);
1578
SCM_EXPORT ScmObj scm_p_read(ScmObj args);
1579
#endif /* SCM_USE_READER */
1583
SCM_EXPORT void scm_write(ScmObj port, ScmObj obj);
1584
SCM_EXPORT void scm_display(ScmObj port, ScmObj obj);
1586
SCM_EXPORT void scm_write_ss(ScmObj port, ScmObj obj);
1587
#endif /* SCM_USE_SRFI38 */
1588
SCM_EXPORT ScmObj scm_p_write(ScmObj obj, ScmObj args);
1589
SCM_EXPORT ScmObj scm_p_display(ScmObj obj, ScmObj args);
1590
#endif /* SCM_USE_WRITER */
1594
SCM_EXPORT void scm_set_lib_path(const char *path);
1595
SCM_EXPORT void scm_load(const char *filename);
1596
SCM_EXPORT ScmObj scm_p_load_path(void);
1597
SCM_EXPORT ScmObj scm_p_load(ScmObj filename);
1598
#endif /* SCM_USE_LOAD */
1602
SCM_EXPORT ScmObj scm_lformat(ScmObj port, enum ScmFormatCapability fcap,
1603
const char *fmt, ScmObj scm_args);
1604
SCM_EXPORT ScmObj scm_vformat(ScmObj port, enum ScmFormatCapability fcap,
1605
const char *fmt, va_list c_args);
1606
SCM_EXPORT ScmObj scm_format(ScmObj port, enum ScmFormatCapability fcap,
1607
const char *fmt, ...);
1608
#endif /* SCM_USE_FORMAT */
1610
/*===========================================================================
1611
SigScheme: Optional Funtions
1612
===========================================================================*/
1613
/* module-sscm-ext.c */
1614
#if SCM_USE_SSCM_EXTENSIONS
1615
SCM_EXPORT void scm_require(const char *filename);
1616
SCM_EXPORT ScmObj scm_p_symbol_boundp(ScmObj sym, ScmObj rest);
1617
SCM_EXPORT ScmObj scm_p_current_environment(ScmEvalState *eval_state);
1618
SCM_EXPORT ScmObj scm_p_prealloc_heaps(ScmObj n);
1619
SCM_EXPORT ScmObj scm_p_fixnum_width(void);
1620
SCM_EXPORT ScmObj scm_p_least_fixnum(void);
1621
SCM_EXPORT ScmObj scm_p_greatest_fixnum(void);
1622
SCM_EXPORT ScmObj scm_p_require(ScmObj filename);
1623
SCM_EXPORT ScmObj scm_p_provide(ScmObj feature);
1624
SCM_EXPORT ScmObj scm_p_providedp(ScmObj feature);
1625
SCM_EXPORT ScmObj scm_p_lengthstar(ScmObj lst);
1626
SCM_EXPORT ScmObj scm_p_exit(ScmObj args) SCM_NORETURN;
1627
#endif /* SCM_USE_SSCM_EXTENSIONS */
1631
SCM_EXPORT ScmObj scm_p_symbol_value(ScmObj var);
1632
SCM_EXPORT ScmObj scm_p_set_symbol_valuex(ScmObj var, ScmObj val);
1633
SCM_EXPORT ScmObj scm_p_siod_equal(ScmObj obj1, ScmObj obj2);
1634
SCM_EXPORT ScmObj scm_p_closure_code(ScmObj closure);
1635
SCM_EXPORT ScmObj scm_p_verbose(ScmObj args);
1636
SCM_EXPORT ScmObj scm_p_eof_val(void);
1637
SCM_EXPORT ScmObj scm_s_undefine(ScmObj var, ScmObj env);
1638
SCM_EXPORT long scm_get_verbose_level(void);
1639
SCM_EXPORT void scm_set_verbose_level(long level);
1640
#endif /* SCM_COMPAT_SIOD */
1642
/* module-srfi1.c */
1644
SCM_EXPORT ScmObj scm_p_srfi1_xcons(ScmObj a, ScmObj b);
1645
SCM_EXPORT ScmObj scm_p_srfi1_consstar(ScmObj args);
1646
SCM_EXPORT ScmObj scm_p_srfi1_make_list(ScmObj length, ScmObj args);
1647
SCM_EXPORT ScmObj scm_p_srfi1_list_tabulate(ScmObj _n, ScmObj args);
1648
SCM_EXPORT ScmObj scm_p_srfi1_list_copy(ScmObj lst);
1649
SCM_EXPORT ScmObj scm_p_srfi1_circular_list(ScmObj args);
1650
SCM_EXPORT ScmObj scm_p_srfi1_iota(ScmObj scm_count, ScmObj args);
1651
SCM_EXPORT ScmObj scm_p_srfi1_proper_listp(ScmObj obj);
1652
SCM_EXPORT ScmObj scm_p_srfi1_circular_listp(ScmObj obj);
1653
SCM_EXPORT ScmObj scm_p_srfi1_dotted_listp(ScmObj obj);
1654
SCM_EXPORT ScmObj scm_p_srfi1_not_pairp(ScmObj obj);
1655
SCM_EXPORT ScmObj scm_p_srfi1_null_listp(ScmObj lst);
1656
SCM_EXPORT ScmObj scm_p_srfi1_listequal(ScmObj eqproc, ScmObj args);
1657
SCM_EXPORT ScmObj scm_p_srfi1_first(ScmObj lst);
1658
SCM_EXPORT ScmObj scm_p_srfi1_second(ScmObj lst);
1659
SCM_EXPORT ScmObj scm_p_srfi1_third(ScmObj lst);
1660
SCM_EXPORT ScmObj scm_p_srfi1_fourth(ScmObj lst);
1661
SCM_EXPORT ScmObj scm_p_srfi1_fifth(ScmObj lst);
1662
SCM_EXPORT ScmObj scm_p_srfi1_sixth(ScmObj lst);
1663
SCM_EXPORT ScmObj scm_p_srfi1_seventh(ScmObj lst);
1664
SCM_EXPORT ScmObj scm_p_srfi1_eighth(ScmObj lst);
1665
SCM_EXPORT ScmObj scm_p_srfi1_ninth(ScmObj lst);
1666
SCM_EXPORT ScmObj scm_p_srfi1_tenth(ScmObj lst);
1667
SCM_EXPORT ScmObj scm_p_srfi1_carpluscdr(ScmObj lst);
1668
SCM_EXPORT ScmObj scm_p_srfi1_take(ScmObj lst, ScmObj scm_idx);
1669
SCM_EXPORT ScmObj scm_p_srfi1_drop(ScmObj lst, ScmObj scm_idx);
1670
SCM_EXPORT ScmObj scm_p_srfi1_take_right(ScmObj lst, ScmObj scm_elem);
1671
SCM_EXPORT ScmObj scm_p_srfi1_drop_right(ScmObj lst, ScmObj scm_elem);
1672
SCM_EXPORT ScmObj scm_p_srfi1_takex(ScmObj lst, ScmObj scm_idx);
1673
SCM_EXPORT ScmObj scm_p_srfi1_drop_rightx(ScmObj lst, ScmObj scm_idx);
1674
SCM_EXPORT ScmObj scm_p_srfi1_split_at(ScmObj lst, ScmObj idx);
1675
SCM_EXPORT ScmObj scm_p_srfi1_split_atx(ScmObj lst, ScmObj idx);
1676
SCM_EXPORT ScmObj scm_p_srfi1_last(ScmObj lst);
1677
SCM_EXPORT ScmObj scm_p_srfi1_last_pair(ScmObj lst);
1678
SCM_EXPORT ScmObj scm_p_srfi1_lengthplus(ScmObj lst);
1679
SCM_EXPORT ScmObj scm_p_srfi1_concatenate(ScmObj args);
1680
#endif /* SCM_USE_SRFI1 */
1682
/* module-srfi2.c */
1684
SCM_EXPORT ScmObj scm_s_srfi2_and_letstar(ScmObj claws, ScmObj body,
1685
ScmEvalState *eval_state);
1688
/* module-srfi6.c */
1690
SCM_EXPORT ScmObj scm_p_srfi6_open_input_string(ScmObj str);
1691
SCM_EXPORT ScmObj scm_p_srfi6_open_output_string(void);
1692
SCM_EXPORT ScmObj scm_p_srfi6_get_output_string(ScmObj port);
1695
/* module-srfi8.c */
1697
SCM_EXPORT ScmObj scm_s_srfi8_receive(ScmObj formals, ScmObj expr, ScmObj body,
1698
ScmEvalState *eval_state);
1701
/* module-srfi23.c */
1703
SCM_EXPORT ScmObj scm_p_srfi23_error(ScmObj reason, ScmObj args);
1706
/* module-srfi28.c */
1708
SCM_EXPORT ScmObj scm_p_srfi28_format(ScmObj fmt, ScmObj objs);
1711
/* module-srfi34.c */
1713
SCM_EXPORT ScmObj scm_p_srfi34_with_exception_handler(ScmObj handler,
1715
SCM_EXPORT ScmObj scm_s_srfi34_guard(ScmObj cond_catch, ScmObj body,
1716
ScmEvalState *eval_state);
1717
SCM_EXPORT ScmObj scm_p_srfi34_raise(ScmObj obj);
1720
/* module-srfi38.c */
1722
SCM_EXPORT ScmObj scm_p_srfi38_write_with_shared_structure(ScmObj obj,
1726
/* module-srfi48.c */
1728
SCM_EXPORT ScmObj scm_p_srfi48_format(ScmObj fmt_or_port, ScmObj rest);
1729
SCM_EXPORT ScmObj scm_p_formatplus(ScmObj fmt_or_port, ScmObj rest);
1732
/* module-srfi60.c */
1734
SCM_EXPORT ScmObj scm_p_srfi60_logand(ScmObj left, ScmObj right,
1735
enum ScmReductionState *state);
1736
SCM_EXPORT ScmObj scm_p_srfi60_logior(ScmObj left, ScmObj right,
1737
enum ScmReductionState *state);
1738
SCM_EXPORT ScmObj scm_p_srfi60_logxor(ScmObj left, ScmObj right,
1739
enum ScmReductionState *state);
1740
SCM_EXPORT ScmObj scm_p_srfi60_lognot(ScmObj n);
1741
SCM_EXPORT ScmObj scm_p_srfi60_bitwise_if(ScmObj mask, ScmObj n0, ScmObj n1);
1742
SCM_EXPORT ScmObj scm_p_srfi60_logtest(ScmObj j, ScmObj k);
1749
#endif /* __SIGSCHEME_H */
added
removed
sigscheme/src/sigscheme.h
