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-2008 SigScheme Project <uim-en AT googlegroups.com>
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 < 1)
50
#error "libgcroots that has API revision >= 1 is required"
55
#if SCM_USE_MULTIBYTE_CHAR
58
#include "encoding-dummy.h"
65
/*=======================================
67
=======================================*/
68
#define SSCM_VERSION_STRING "0.8.3"
69
#define SSCM_VERSION_MAJOR (0)
70
#define SSCM_VERSION_MINOR (8)
71
#define SSCM_VERSION_PATCHLEVEL (3)
72
#define SSCM_VERSION_REQUIRE(major, minor, patchlevel) \
73
((major) < SSCM_VERSION_MAJOR \
74
|| ((major) == SSCM_VERSION_MAJOR && (minor) < SSCM_VERSION_MINOR) \
75
|| ((major) == SSCM_VERSION_MAJOR && (minor) == SSCM_VERSION_MINOR \
76
&& (patchlevel) <= SSCM_VERSION_PATCHLEVEL))
78
#define SCM_ERRMSG_MEMORY_EXHAUSTED "memory exhausted"
80
/* An empty definition is generally not a good idea. (Consider for
81
* example (FOO(), bar) where FOO() expands to only whitespaces.)
82
* Simply using 0 prompts warnings everywhere, so we cast it to void.
83
* There may be a better solution out there, so use this macro instead
84
* of crudely writing out the same expression. The idea is taken from
85
* glibc's assert.h but it's barely even a line of code so it should
86
* be OK as the copyright goes... anyone know for sure? */
87
#ifndef SCM_EMPTY_EXPR
88
#define SCM_EMPTY_EXPR ((void)0)
91
#if HAVE___ATTRIBUTE__
92
/* As a workaround for the noinline attribute vanishing bug on some Linux
93
* distributions, we use ((__noinline__)) instead of ((noinline)). */
94
#define SCM_NOINLINE __attribute__((__noinline__))
95
#define SCM_NORETURN __attribute__((__noreturn__))
96
#define SCM_UNUSED __attribute__((__unused__))
97
/* size-less ((__aligned__)) may not be sufficient for m68k */
98
#define SCM_SCMOBJ_ALIGNED __attribute__((__aligned__ (SIZEOF_SCMOBJ)))
99
#else /* HAVE___ATTRIBUTE__ */
103
#define SCM_SCMOBJ_ALIGNED
104
#endif /* HAVE___ATTRIBUTE__ */
106
/* RFC: better names for the debug printing */
107
/* SCM_DBG((a, b, c)) */
109
#define SCM_CDBG(args) (scm_categorized_debug args)
110
#define SCM_DBG(args) (scm_debug args)
111
#else /* SCM_DEBUG */
112
#define SCM_CDBG(args) SCM_EMPTY_EXPR
113
#define SCM_DBG(args) SCM_EMPTY_EXPR
114
#endif /* SCM_DEBUG */
119
* SigScheme uses these three types of condition testers.
121
* ASSERT: Asserts a condition that is expected as always true, as a contract
122
* programming. No actual check is performed when (!SCM_SOFT_ASSERT &&
125
* ENSURE: Mandatory runtime check involving uncertain data. An exception is
126
* raised if failed. Actual check is always performed regaradless of debug
129
* CHECK: Optional runtime check. Actual check is performed only when
130
* configured to do so. Since the behavior, codes that include a CHECK must be
131
* sane even if the condition is false with no actual check.
136
/* allows recovery from failed assertion */
138
#define SCM_ASSERTION_MSG(cond) ("assertion failed at " "'" #cond "'")
140
#define SCM_ASSERTION_MSG(cond) "assertion failed"
142
#define SCM_ASSERT(cond) \
143
((cond) || (scm_die(SCM_ASSERTION_MSG(cond), __FILE__, __LINE__), 1))
146
#define SCM_ASSERT(cond) (assert(cond))
148
#define SCM_ASSERT(cond) SCM_EMPTY_EXPR
151
#define SCM_ENSURE(cond) \
152
((cond) || (scm_die("invalid condition", __FILE__, __LINE__), 1))
154
#define SCM_ENSURE_ALLOCATED(p) \
155
((p) || (scm_fatal_error(SCM_ERRMSG_MEMORY_EXHAUSTED), 1))
157
#if (SCM_USE_WARNING_SUPPRESSOR \
158
&& !SCM_SOFT_ASSERT && (!HAVE_ASSERT_H || defined(NDEBUG)))
160
#define SCM_NOTREACHED (abort())
162
#define SCM_NOTREACHED SCM_ASSERT(scm_false)
166
#define SCM_VALID_ENVP(obj) (scm_valid_environmentp(env))
168
#define SCM_ERROBJP(obj) (TRUEP(scm_p_error_objectp(obj)))
170
#define SCM_SYMBOL_BOUNDP(sym) (!SCM_EQ(SCM_SYMBOL_VCELL(sym), SCM_UNBOUND))
172
#define SCM_CONS(kar, kdr) (SCM_MAKE_CONS((kar), (kdr)))
173
#define SCM_IMMUTABLE_CONS(kar, kdr) (SCM_MAKE_IMMUTABLE_CONS((kar), (kdr)))
174
#define SCM_CAR(kons) (SCM_CONS_CAR(kons))
175
#define SCM_CDR(kons) (SCM_CONS_CDR(kons))
176
#define SCM_CAAR(kons) (SCM_CAR(SCM_CAR(kons)))
177
#define SCM_CADR(kons) (SCM_CAR(SCM_CDR(kons)))
178
#define SCM_CDAR(kons) (SCM_CDR(SCM_CAR(kons)))
179
#define SCM_CDDR(kons) (SCM_CDR(SCM_CDR(kons)))
181
#define SCM_LIST_1(elm0) \
182
(SCM_CONS((elm0), SCM_NULL))
183
#define SCM_LIST_2(elm0, elm1) \
184
(SCM_CONS((elm0), SCM_LIST_1(elm1)))
185
#define SCM_LIST_3(elm0, elm1, elm2) \
186
(SCM_CONS((elm0), SCM_LIST_2((elm1), (elm2))))
187
#define SCM_LIST_4(elm0, elm1, elm2, elm3) \
188
(SCM_CONS((elm0), SCM_LIST_3((elm1), (elm2), (elm3))))
189
#define SCM_LIST_5(elm0, elm1, elm2, elm3, elm4) \
190
(SCM_CONS((elm0), SCM_LIST_4((elm1), (elm2), (elm3), (elm4))))
192
#define SCM_LISTP(obj) (SCM_CONSP(obj) || SCM_NULLP(obj))
193
#define SCM_LIST_1_P(lst) (SCM_CONSP(lst) && SCM_NULLP(SCM_CDR(lst)))
194
#define SCM_LIST_2_P(lst) (SCM_CONSP(lst) && SCM_LIST_1_P(SCM_CDR(lst)))
195
#define SCM_LIST_3_P(lst) (SCM_CONSP(lst) && SCM_LIST_2_P(SCM_CDR(lst)))
196
#define SCM_LIST_4_P(lst) (SCM_CONSP(lst) && SCM_LIST_3_P(SCM_CDR(lst)))
197
#define SCM_LIST_5_P(lst) (SCM_CONSP(lst) && SCM_LIST_4_P(SCM_CDR(lst)))
199
#define SCM_PROPER_LISTP(obj) (SCM_LISTLEN_PROPERP(scm_length(obj)))
200
#define SCM_DOTTED_LISTP(obj) (SCM_LISTLEN_DOTTEDP(scm_length(obj)))
201
#define SCM_CIRCULAR_LISTP(obj) (SCM_LISTLEN_CIRCULARP(scm_length(obj)))
203
/* result decoders for scm_length() */
205
* Dotted list length follows SRFI-1 definition as follows:
207
* list dotted length internal encoded length(don't use directly)
211
* '(1 2 3 . term) 3 -4
213
#define SCM_LISTLEN_PROPERP(len) (0 <= (len))
214
#define SCM_LISTLEN_CIRCULARP(len) ((len) == SCM_INT_T_MIN)
215
#define SCM_LISTLEN_ERRORP SCM_LISTLEN_CIRCULARP
216
#define SCM_LISTLEN_DOTTEDP(len) ((len) < 0 \
217
&& !SCM_LISTLEN_CIRCULARP(len))
218
#define SCM_LISTLEN_DOTTED(len) \
219
(SCM_ASSERT(SCM_LISTLEN_DOTTEDP(len)), ~(len)) /* -(len) - 1 */
221
#define SCM_LISTLEN_PROPER_MAX (SCM_INT_T_MAX)
222
#define SCM_LISTLEN_DOTTED_MAX (-(SCM_INT_T_MIN + 2))
223
#define SCM_LISTLEN_MAX \
224
((SCM_LISTLEN_DOTTED_MAX < SCM_LISTLEN_PROPER_MAX) \
225
? SCM_LISTLEN_PROPER_MAX : SCM_LISTLEN_DOTTED_MAX)
227
#define SCM_EVAL(obj, env) (scm_eval((obj), (env)))
229
#define SCM_ASSERT_FUNCTYPE(type, c_func) \
232
if (0) f = (c_func); /* compile-time type check */ \
233
} while (/* CONSTCOND */ 0)
236
#define SCM_REGISTER_FUNC(name, c_func, type) \
238
enum ScmFuncTypeCode typecode; \
240
SCM_ASSERT_FUNCTYPE(scm_##type, (c_func)); \
241
typecode = scm_funccode_##type; \
242
scm_register_func(name, c_func, typecode); \
243
} while (/* CONSTCOND */ 0)
247
#define SCM_ENSURE_LIVE_PORT(port) \
248
(SCM_PORT_IMPL(port) \
249
|| (scm_error_obj("(unknown)", "operated on closed port", (port)), 1))
253
#define SCM_WRITE_SS(port, obj) ((*scm_write_ss_func)((port), (obj)))
254
/* Assumes that scm_write_ss_func only holds either scm_write or
256
#define SCM_WRITE_SS_ENABLEDP() (scm_write_ss_func != scm_write)
259
/*===========================================================================
261
===========================================================================*/
262
/*=======================================
264
=======================================*/
265
enum ScmDebugCategory {
267
SCM_DBG_ERRMSG = 1 << 0, /* the "Error: foo bar" style msgs */
268
SCM_DBG_BACKTRACE = 1 << 1,
270
SCM_DBG_FILE = 1 << 3, /* file loading */
271
SCM_DBG_PARSER = 1 << 4,
272
SCM_DBG_READ = 1 << 5, /* print each parsed expression + misc */
273
SCM_DBG_MACRO = 1 << 6,
274
SCM_DBG_ARGS = 1 << 7, /* number of arguments, type and so on */
275
SCM_DBG_EVAL = 1 << 8, /* evaluation-related things */
276
SCM_DBG_CONTINUATION = 1 << 9,
277
SCM_DBG_EXCEPTION = 1 << 10,
278
SCM_DBG_EXPERIMENTAL = 1 << 11, /* developed but experimental features */
279
SCM_DBG_DEVEL = 1 << 12, /* under development */
280
SCM_DBG_COMPAT = 1 << 13, /* warns compatibility-sensitive code */
281
SCM_DBG_ENCODING = 1 << 14, /* multibyte handling */
282
SCM_DBG_OTHER = 1 << 30 /* all other messages */
286
/* sorted by majority to make immediate number encoding optimal */
301
ScmContinuation = 12,
306
/* Reserved for future extension of argument types-encoded
307
* ScmFuncTypeCode. The types for it should not exceed 4-bit. */
308
ScmNumber = ScmConstant,
309
ScmProc = ScmValuePacket,
310
ScmAny = ScmFreeCell,
317
ScmCFuncPointer = 30,
320
/* Classification tag for internal object validations */
321
ScmFirstClassObj = 0 /* intentionally zero */
327
* Function objects must tag themselves with proper information so
328
* that the evaluator can correctly invoke them.
330
#define SCM_FUNCTYPE_MAND_MAX 5
331
enum ScmFuncTypeCode {
332
SCM_FUNCTYPE_MAND_BITS = 4,
333
SCM_FUNCTYPE_MAND_MASK = (1 << SCM_FUNCTYPE_MAND_BITS) - 1,
334
SCM_FUNCTYPE_PROCEDURE = 0 << SCM_FUNCTYPE_MAND_BITS,
335
SCM_FUNCTYPE_SYNTAX = 1 << SCM_FUNCTYPE_MAND_BITS,
337
SCM_FUNCTYPE_FIXED = 0 << (SCM_FUNCTYPE_MAND_BITS + 1),
338
SCM_FUNCTYPE_VARIADIC = 1 << (SCM_FUNCTYPE_MAND_BITS + 1),
339
SCM_FUNCTYPE_TAILREC = 1 << (SCM_FUNCTYPE_MAND_BITS + 2),
341
SCM_FUNCTYPE_ODDBALL = 1 << (SCM_FUNCTYPE_MAND_BITS + 10),
343
/* Compound types. */
344
SCM_PROCEDURE_FIXED = SCM_FUNCTYPE_FIXED,
345
SCM_PROCEDURE_FIXED_TAILREC = SCM_FUNCTYPE_TAILREC,
346
SCM_PROCEDURE_VARIADIC = SCM_FUNCTYPE_VARIADIC,
347
SCM_PROCEDURE_VARIADIC_TAILREC = (SCM_FUNCTYPE_VARIADIC
348
| SCM_FUNCTYPE_TAILREC),
350
SCM_SYNTAX_FIXED = (SCM_FUNCTYPE_SYNTAX
351
| SCM_PROCEDURE_FIXED),
352
SCM_SYNTAX_FIXED_TAILREC = (SCM_FUNCTYPE_SYNTAX
353
| SCM_PROCEDURE_FIXED_TAILREC),
354
SCM_SYNTAX_VARIADIC = (SCM_FUNCTYPE_SYNTAX
355
| SCM_PROCEDURE_VARIADIC),
356
SCM_SYNTAX_VARIADIC_TAILREC = (SCM_FUNCTYPE_SYNTAX
357
| SCM_PROCEDURE_VARIADIC_TAILREC),
359
/* Proper combinations */
360
SCM_SYNTAX_FIXED_0 = (SCM_SYNTAX_FIXED | 0),
361
SCM_SYNTAX_FIXED_TAILREC_0 = (SCM_SYNTAX_FIXED_TAILREC | 0),
362
SCM_SYNTAX_VARIADIC_0 = (SCM_SYNTAX_VARIADIC | 0),
363
SCM_SYNTAX_VARIADIC_TAILREC_0 = (SCM_SYNTAX_VARIADIC_TAILREC | 0),
364
SCM_PROCEDURE_FIXED_0 = (SCM_PROCEDURE_FIXED | 0),
365
SCM_PROCEDURE_FIXED_TAILREC_0 = (SCM_PROCEDURE_FIXED_TAILREC | 0),
366
SCM_PROCEDURE_VARIADIC_0 = (SCM_PROCEDURE_VARIADIC | 0),
367
SCM_PROCEDURE_VARIADIC_TAILREC_0 = (SCM_PROCEDURE_VARIADIC_TAILREC | 0),
368
#if SCM_FUNCTYPE_MAND_MAX >= 1
369
SCM_SYNTAX_FIXED_1 = (SCM_SYNTAX_FIXED | 1),
370
SCM_SYNTAX_FIXED_TAILREC_1 = (SCM_SYNTAX_FIXED_TAILREC | 1),
371
SCM_SYNTAX_VARIADIC_1 = (SCM_SYNTAX_VARIADIC | 1),
372
SCM_SYNTAX_VARIADIC_TAILREC_1 = (SCM_SYNTAX_VARIADIC_TAILREC | 1),
373
SCM_PROCEDURE_FIXED_1 = (SCM_PROCEDURE_FIXED | 1),
374
SCM_PROCEDURE_FIXED_TAILREC_1 = (SCM_PROCEDURE_FIXED_TAILREC | 1),
375
SCM_PROCEDURE_VARIADIC_1 = (SCM_PROCEDURE_VARIADIC | 1),
376
SCM_PROCEDURE_VARIADIC_TAILREC_1 = (SCM_PROCEDURE_VARIADIC_TAILREC | 1),
378
#if SCM_FUNCTYPE_MAND_MAX >= 2
379
SCM_SYNTAX_FIXED_2 = (SCM_SYNTAX_FIXED | 2),
380
SCM_SYNTAX_FIXED_TAILREC_2 = (SCM_SYNTAX_FIXED_TAILREC | 2),
381
SCM_SYNTAX_VARIADIC_2 = (SCM_SYNTAX_VARIADIC | 2),
382
SCM_SYNTAX_VARIADIC_TAILREC_2 = (SCM_SYNTAX_VARIADIC_TAILREC | 2),
383
SCM_PROCEDURE_FIXED_2 = (SCM_PROCEDURE_FIXED | 2),
384
SCM_PROCEDURE_FIXED_TAILREC_2 = (SCM_PROCEDURE_FIXED_TAILREC | 2),
385
SCM_PROCEDURE_VARIADIC_2 = (SCM_PROCEDURE_VARIADIC | 2),
386
SCM_PROCEDURE_VARIADIC_TAILREC_2 = (SCM_PROCEDURE_VARIADIC_TAILREC | 2),
388
#if SCM_FUNCTYPE_MAND_MAX >= 3
389
SCM_SYNTAX_FIXED_3 = (SCM_SYNTAX_FIXED | 3),
390
SCM_SYNTAX_FIXED_TAILREC_3 = (SCM_SYNTAX_FIXED_TAILREC | 3),
391
SCM_SYNTAX_VARIADIC_3 = (SCM_SYNTAX_VARIADIC | 3),
392
SCM_SYNTAX_VARIADIC_TAILREC_3 = (SCM_SYNTAX_VARIADIC_TAILREC | 3),
393
SCM_PROCEDURE_FIXED_3 = (SCM_PROCEDURE_FIXED | 3),
394
SCM_PROCEDURE_FIXED_TAILREC_3 = (SCM_PROCEDURE_FIXED_TAILREC | 3),
395
SCM_PROCEDURE_VARIADIC_3 = (SCM_PROCEDURE_VARIADIC | 3),
396
SCM_PROCEDURE_VARIADIC_TAILREC_3 = (SCM_PROCEDURE_VARIADIC_TAILREC | 3),
398
#if SCM_FUNCTYPE_MAND_MAX >= 4
399
SCM_SYNTAX_FIXED_4 = (SCM_SYNTAX_FIXED | 4),
400
SCM_SYNTAX_FIXED_TAILREC_4 = (SCM_SYNTAX_FIXED_TAILREC | 4),
401
SCM_SYNTAX_VARIADIC_4 = (SCM_SYNTAX_VARIADIC | 4),
402
SCM_SYNTAX_VARIADIC_TAILREC_4 = (SCM_SYNTAX_VARIADIC_TAILREC | 4),
403
SCM_PROCEDURE_FIXED_4 = (SCM_PROCEDURE_FIXED | 4),
404
SCM_PROCEDURE_FIXED_TAILREC_4 = (SCM_PROCEDURE_FIXED_TAILREC | 4),
405
SCM_PROCEDURE_VARIADIC_4 = (SCM_PROCEDURE_VARIADIC | 4),
406
SCM_PROCEDURE_VARIADIC_TAILREC_4 = (SCM_PROCEDURE_VARIADIC_TAILREC | 4),
408
#if SCM_FUNCTYPE_MAND_MAX >= 5
409
SCM_SYNTAX_FIXED_5 = (SCM_SYNTAX_FIXED | 5),
410
SCM_SYNTAX_FIXED_TAILREC_5 = (SCM_SYNTAX_FIXED_TAILREC | 5),
411
SCM_SYNTAX_VARIADIC_5 = (SCM_SYNTAX_VARIADIC | 5),
412
SCM_SYNTAX_VARIADIC_TAILREC_5 = (SCM_SYNTAX_VARIADIC_TAILREC | 5),
413
SCM_PROCEDURE_FIXED_5 = (SCM_PROCEDURE_FIXED | 5),
414
SCM_PROCEDURE_FIXED_TAILREC_5 = (SCM_PROCEDURE_FIXED_TAILREC | 5),
415
SCM_PROCEDURE_VARIADIC_5 = (SCM_PROCEDURE_VARIADIC | 5),
416
SCM_PROCEDURE_VARIADIC_TAILREC_5 = (SCM_PROCEDURE_VARIADIC_TAILREC | 5),
418
#if SCM_FUNCTYPE_MAND_MAX >= 6
419
#error "SCM_FUNCTYPE_MAND_MAX must not exceed 5"
423
SCM_REDUCTION_OPERATOR = SCM_FUNCTYPE_ODDBALL,
425
SCM_FUNCTYPE_INVALID = (SCM_FUNCTYPE_ODDBALL | 1)
428
/* Where we are in a reduction process. */
429
enum ScmReductionState {
430
SCM_REDUCE_0, /* No argument was given. */
431
SCM_REDUCE_1, /* Only 1 argument was given. */
432
SCM_REDUCE_PARTWAY, /* We have more arguments pending. */
433
SCM_REDUCE_LAST, /* The callee must finalize. */
434
SCM_REDUCE_STOP /* Callee wants to stop. */
438
SCM_PORTFLAG_NONE = 0,
439
SCM_PORTFLAG_OUTPUT = 1 << 0,
440
SCM_PORTFLAG_INPUT = 1 << 1,
441
SCM_PORTFLAG_LIVE_OUTPUT = 1 << 2,
442
SCM_PORTFLAG_LIVE_INPUT = 1 << 3,
444
SCM_PORTFLAG_DIR_MASK = (SCM_PORTFLAG_INPUT | SCM_PORTFLAG_OUTPUT),
445
SCM_PORTFLAG_ALIVENESS_MASK = (SCM_PORTFLAG_LIVE_INPUT
446
| SCM_PORTFLAG_LIVE_OUTPUT)
449
typedef void (*ScmCFunc)(void);
450
typedef void *(*ScmGCGateFunc)(void *);
453
#if SCM_USE_HYGIENIC_MACRO
454
/* Environment for looking up a free variable inserted by a hygienic
455
* macro's template. References in syntax-rules are only looked up in
456
* environments enclosed by the definition's, so we need only record
457
* the number of frames. That doesn't work in the face of syntax-case
458
* though, so we abstract the representation here. */
459
typedef scm_int_t ScmPackedEnv;
460
#define SCM_PENV_EQ(x, y) ((x) == (y))
464
* 64-bit support of SigScheme
466
* SigScheme supports all data models of ILP32, LL64, LLP64, LP64 and
467
* ILP64. Default settings automatically configure both ABI and the underlying
468
* storage implementation appropriately, if the storage implementation is
469
* storage-fatty or storage-compact. On the case, the integer size Scheme can
470
* handle is determined by sizeof(long), and heap capacity and addressable
471
* space are determined by the pointer size.
473
* Other storage implementations (currently not exist) may need some manual
474
* settings to fit to the specified data model.
478
* Interface to an implementation for the Storage Abstraction Layer:
480
* A storage implementation defines following types:
482
* typedef <hidden> ScmCell;
483
* typedef <hidden> ScmObj;
484
* typedef <hidden> ScmRef;
486
* typedef ScmObj (*ScmFuncType)();
488
* And following macros:
494
#if SCM_USE_STORAGE_FATTY
495
#include "storage-fatty.h"
496
#elif SCM_USE_STORAGE_COMPACT
497
#include "storage-compact.h"
499
#error "specify a storage layer implementation"
502
typedef struct ScmStorageConf_ ScmStorageConf;
503
struct ScmStorageConf_ {
505
size_t heap_size; /* number of ScmCell in a heap */
506
size_t heap_alloc_threshold; /* minimum number of freecells after a GC */
507
size_t n_heaps_max; /* max number of heaps */
508
size_t n_heaps_init; /* initial number of heaps */
511
size_t symbol_hash_size; /* hash size of symbol table */
514
#define SCM_FULLY_ADDRESSABLEP \
515
(SCM_PTR_BITS == (sizeof(void *) * CHAR_BIT))
517
#ifndef SCM_DEFAULT_N_HEAPS_MAX
518
#define SCM_DEFAULT_N_HEAPS_MAX \
519
(((SCM_INT_BITS < SCM_PTR_BITS) \
521
: ((SCM_FULLY_ADDRESSABLEP) \
522
? ((size_t)(intptr_t)-1 >> 1) : ((size_t)1 << SCM_PTR_BITS) - 1)) \
523
/ SCM_DEFAULT_HEAP_SIZE)
526
/*=======================================
527
Object Representation Information
528
=======================================*/
529
#define SCM_HAS_CHAR SCM_SAL_HAS_CHAR
530
#define SCM_HAS_INT 1
531
#define SCM_HAS_RATIONAL SCM_SAL_HAS_RATIONAL
532
#define SCM_HAS_REAL SCM_SAL_HAS_REAL
533
#define SCM_HAS_COMPLEX SCM_SAL_HAS_COMPLEX
534
#define SCM_HAS_STRING SCM_SAL_HAS_STRING
535
#define SCM_HAS_VECTOR SCM_SAL_HAS_VECTOR
537
#define SCM_HAS_IMMUTABLE_CONS SCM_SAL_HAS_IMMUTABLE_CONS
538
#define SCM_HAS_IMMUTABLE_STRING SCM_SAL_HAS_IMMUTABLE_STRING
539
#define SCM_HAS_IMMUTABLE_VECTOR SCM_SAL_HAS_IMMUTABLE_VECTOR
541
/* for optimization */
542
#define SCM_HAS_IMMEDIATE_CHAR_ONLY SCM_SAL_HAS_IMMEDIATE_CHAR_ONLY
543
#define SCM_HAS_IMMEDIATE_NUMBER_ONLY SCM_SAL_HAS_IMMEDIATE_NUMBER_ONLY
544
#define SCM_HAS_IMMEDIATE_INT_ONLY SCM_SAL_HAS_IMMEDIATE_INT_ONLY
545
#define SCM_HAS_IMMEDIATE_RATIONAL_ONLY SCM_SAL_HAS_IMMEDIATE_RATIONAL_ONLY
546
#define SCM_HAS_IMMEDIATE_REAL_ONLY SCM_SAL_HAS_IMMEDIATE_REAL_ONLY
547
#define SCM_HAS_IMMEDIATE_COMPLEX_ONLY SCM_SAL_HAS_IMMEDIATE_COMPLEX_ONLY
549
/* addressable space: tag bits multiplexed in alignment part is also counted */
550
#define SCM_PTR_BITS SCM_SAL_PTR_BITS
552
#define SCM_CHAR_BITS SCM_SAL_CHAR_BITS
553
#define SCM_CHAR_MAX SCM_SAL_CHAR_MAX
554
#define SCM_CHAR_MIN 0
556
#define SCM_INT_BITS SCM_SAL_INT_BITS
557
#define SCM_INT_MAX SCM_SAL_INT_MAX
558
#define SCM_INT_MIN SCM_SAL_INT_MIN
561
#define SCM_STRLEN_BITS SCM_SAL_STRLEN_BITS
562
#define SCM_STRLEN_MAX SCM_SAL_STRLEN_MAX
563
#define SCM_STRLEN_MIN 0
566
#define SCM_VECLEN_BITS SCM_SAL_VECLEN_BITS
567
#define SCM_VECLEN_MAX SCM_SAL_VECLEN_MAX
568
#define SCM_VECLEN_MIN 0
571
#define SCM_HAS_EQVP SCM_SAL_HAS_EQVP
573
/*=======================================
575
=======================================*/
576
/* TODO: add this check to all accessor and creator macros. */
577
#define SCM_TYPESAFE_MACRO(macro, rettype, types, args) \
578
(0 ? (*(rettype (*)types)NULL)args \
579
: 0 ? ((*(rettype *)NULL) = macro args) \
582
/* For macros enclosed in do-while(0). */
583
#define SCM_TYPESAFE_MACRO_VOID(macro, types, args) \
586
(*(void (*)types)NULL) args; \
591
#define SCM_MAKE_BOOL(x) ((x) ? SCM_TRUE : SCM_FALSE)
593
#define SCM_MAKE_CONS(kar, kdr) \
594
SCM_TYPESAFE_MACRO(SCM_SAL_MAKE_CONS, \
599
#define SCM_MAKE_IMMUTABLE_CONS(kar, kdr) \
600
SCM_TYPESAFE_MACRO(SCM_SAL_MAKE_IMMUTABLE_CONS, \
606
#define SCM_MAKE_INT(val) \
607
SCM_TYPESAFE_MACRO(SCM_SAL_MAKE_INT, \
611
#endif /* SCM_USE_INT */
614
#define SCM_MAKE_CHAR(val) \
615
SCM_TYPESAFE_MACRO(SCM_SAL_MAKE_CHAR, \
619
#endif /* SCM_USE_CHAR */
621
#define SCM_MAKE_SYMBOL(name, val) \
622
SCM_TYPESAFE_MACRO(SCM_SAL_MAKE_SYMBOL, \
628
#define SCM_MAKE_STRING(str, len) \
629
SCM_TYPESAFE_MACRO(SCM_SAL_MAKE_STRING, \
631
(char *, scm_int_t), \
634
#define SCM_MAKE_STRING_COPYING(str, len) \
635
SCM_TYPESAFE_MACRO(SCM_SAL_MAKE_STRING_COPYING, \
637
(const char *, scm_int_t), \
640
#define SCM_MAKE_IMMUTABLE_STRING(str, len) \
641
SCM_TYPESAFE_MACRO(SCM_SAL_MAKE_IMMUTABLE_STRING, \
643
(char *, scm_int_t), \
646
#define SCM_MAKE_IMMUTABLE_STRING_COPYING(str, len) \
647
SCM_TYPESAFE_MACRO(SCM_SAL_MAKE_IMMUTABLE_STRING_COPYING, \
649
(const char *, scm_int_t), \
652
#define SCM_CONST_STRING(str) \
653
SCM_MAKE_IMMUTABLE_STRING_COPYING((str), SCM_STRLEN_UNKNOWN)
654
#define SCM_STRLEN_UNKNOWN (-1)
655
#endif /* SCM_USE_STRING */
657
#define SCM_MAKE_FUNC(type, func) \
658
SCM_TYPESAFE_MACRO(SCM_SAL_MAKE_FUNC, \
660
(enum ScmFuncTypeCode, ScmFuncType), \
663
#define SCM_MAKE_CLOSURE(exp, env) \
664
SCM_TYPESAFE_MACRO(SCM_SAL_MAKE_CLOSURE, \
670
#define SCM_MAKE_VECTOR(vec, len) \
671
SCM_TYPESAFE_MACRO(SCM_SAL_MAKE_VECTOR, \
673
(ScmObj *, scm_int_t), \
676
#define SCM_MAKE_IMMUTABLE_VECTOR(vec, len) \
677
SCM_TYPESAFE_MACRO(SCM_SAL_MAKE_IMMUTABLE_VECTOR, \
679
(ScmObj *, scm_int_t), \
681
#endif /* SCM_USE_VECTOR */
683
#if (SCM_USE_CONTINUATION || SCM_USE_VALUES_APPLIER)
684
#define SCM_MAKE_CONTINUATION() \
685
SCM_TYPESAFE_MACRO(SCM_SAL_MAKE_CONTINUATION, \
689
#endif /* (SCM_USE_CONTINUATION || SCM_USE_VALUES_APPLIER) */
691
#define SCM_MAKE_VALUEPACKET(vals) \
692
SCM_TYPESAFE_MACRO(SCM_SAL_MAKE_VALUEPACKET, \
698
#define SCM_MAKE_PORT(cport, flag) \
699
SCM_TYPESAFE_MACRO(SCM_SAL_MAKE_PORT, \
701
(struct ScmCharPort_ *, enum ScmPortFlag), \
703
#endif /* SCM_USE_PORT */
705
#if SCM_USE_HYGIENIC_MACRO
706
#define SCM_MAKE_HMACRO(r, e) \
707
SCM_TYPESAFE_MACRO(SCM_SAL_MAKE_HMACRO, \
712
#define SCM_MAKE_FARSYMBOL(s, e) \
713
SCM_TYPESAFE_MACRO(SCM_SAL_MAKE_FARSYMBOL, \
715
(ScmObj, ScmPackedEnv), \
718
#define SCM_MAKE_SUBPAT(x, m) \
719
SCM_TYPESAFE_MACRO(SCM_SAL_MAKE_SUBPAT, \
721
(ScmObj, scm_int_t), \
723
#endif /* SCM_USE_HYGIENIC_MACRO */
725
#if SCM_USE_SSCM_EXTENSIONS
726
#define SCM_MAKE_C_POINTER(ptr) \
727
SCM_TYPESAFE_MACRO(SCM_SAL_MAKE_C_POINTER, \
732
#define SCM_MAKE_C_FUNCPOINTER(ptr) \
733
SCM_TYPESAFE_MACRO(SCM_SAL_MAKE_C_FUNCPOINTER, \
737
#endif /* SCM_USE_SSCM_EXTENSIONS */
739
/*=======================================
741
=======================================*/
742
/* ScmObj Global Attribute */
743
#define SCM_TYPE(o) SCM_SAL_TYPE(o)
745
/* Type Confirmation */
746
#if SCM_ACCESSOR_ASSERT
747
#define SCM_ASSERT_TYPE(cond, o) (SCM_ASSERT(cond), (o))
748
#else /* SCM_ACCESSOR_ASSERT */
749
#define SCM_ASSERT_TYPE(cond, o) (o)
750
#endif /* SCM_ACCESSOR_ASSERT */
751
#define SCM_AS_NUMBER(o) (SCM_ASSERT_TYPE(SCM_NUMBERP(o), (o)))
752
#define SCM_AS_INT(o) (SCM_ASSERT_TYPE(SCM_INTP(o), (o)))
753
#define SCM_AS_CONS(o) (SCM_ASSERT_TYPE(SCM_CONSP(o), (o)))
754
#define SCM_AS_SYMBOL(o) (SCM_ASSERT_TYPE(SCM_SYMBOLP(o), (o)))
755
#define SCM_AS_CHAR(o) (SCM_ASSERT_TYPE(SCM_CHARP(o), (o)))
756
#define SCM_AS_STRING(o) (SCM_ASSERT_TYPE(SCM_STRINGP(o), (o)))
757
#define SCM_AS_FUNC(o) (SCM_ASSERT_TYPE(SCM_FUNCP(o), (o)))
758
#define SCM_AS_CLOSURE(o) (SCM_ASSERT_TYPE(SCM_CLOSUREP(o), (o)))
759
#define SCM_AS_VECTOR(o) (SCM_ASSERT_TYPE(SCM_VECTORP(o), (o)))
760
#define SCM_AS_PORT(o) (SCM_ASSERT_TYPE(SCM_PORTP(o), (o)))
761
#define SCM_AS_CONTINUATION(o) (SCM_ASSERT_TYPE(SCM_CONTINUATIONP(o), (o)))
762
#define SCM_AS_VALUEPACKET(o) (SCM_ASSERT_TYPE(SCM_VALUEPACKETP(o), (o)))
763
#define SCM_AS_C_POINTER(o) (SCM_ASSERT_TYPE(SCM_C_POINTERP(o), (o)))
764
#define SCM_AS_C_FUNCPOINTER(o) (SCM_ASSERT_TYPE(SCM_C_FUNCPOINTERP(o), (o)))
765
#define SCM_AS_HMACRO(o) (SCM_ASSERT_TYPE(SCM_HMACROP(o), (o)))
766
#define SCM_AS_FARSYMBOL(o) (SCM_ASSERT_TYPE(SCM_FARSYMBOLP(o), (o)))
767
#define SCM_AS_SUBPAT(o) (SCM_ASSERT_TYPE(SCM_SUBPATP(o), (o)))
770
#define SCM_NUMBERP(o) SCM_SAL_NUMBERP(o)
773
#define SCM_INTP(o) SCM_SAL_INTP(o)
774
#define SCM_INT_VALUE(o) SCM_SAL_INT_VALUE(o)
775
#define SCM_INT_SET_VALUE(o, val) SCM_SAL_INT_SET_VALUE((o), (val))
776
#endif /* SCM_USE_INT */
777
#endif /* SCM_USE_NUMBER */
779
#define SCM_CONSP(o) SCM_SAL_CONSP(o)
780
#define SCM_CONS_CAR(o) SCM_SAL_CONS_CAR(o)
781
#define SCM_CONS_CDR(o) SCM_SAL_CONS_CDR(o)
782
#define SCM_CONS_SET_CAR(o, kar) SCM_SAL_CONS_SET_CAR((o), (kar))
783
#define SCM_CONS_SET_CDR(o, kdr) SCM_SAL_CONS_SET_CDR((o), (kdr))
784
#define SCM_CONS_MUTABLEP(o) SCM_SAL_CONS_MUTABLEP(o)
785
#define SCM_CONS_SET_MUTABLE(o) SCM_SAL_CONS_SET_MUTABLE(o)
786
#define SCM_CONS_SET_IMMUTABLE(o) SCM_SAL_CONS_SET_IMMUTABLE(o)
788
#define SCM_SYMBOLP(o) SCM_SAL_SYMBOLP(o)
789
#define SCM_SYMBOL_NAME(o) SCM_SAL_SYMBOL_NAME(o)
790
#define SCM_SYMBOL_VCELL(o) SCM_SAL_SYMBOL_VCELL(o)
791
#define SCM_SYMBOL_SET_NAME(o, name) SCM_SAL_SYMBOL_SET_NAME((o), (name))
792
#define SCM_SYMBOL_SET_VCELL(o, val) SCM_SAL_SYMBOL_SET_VCELL((o), (val))
795
#define SCM_CHARP(o) SCM_SAL_CHARP(o)
796
#define SCM_CHAR_VALUE(o) SCM_SAL_CHAR_VALUE(o)
797
#define SCM_CHAR_SET_VALUE(o, val) SCM_SAL_CHAR_SET_VALUE((o), (val))
798
#endif /* SCM_USE_CHAR */
801
#define SCM_STRINGP(o) SCM_SAL_STRINGP(o)
802
#define SCM_STRING_STR(o) SCM_SAL_STRING_STR(o)
803
#define SCM_STRING_LEN(o) SCM_SAL_STRING_LEN(o)
804
#define SCM_STRING_SET_STR(o, str) SCM_SAL_STRING_SET_STR((o), (str))
805
#define SCM_STRING_SET_LEN(o, len) SCM_SAL_STRING_SET_LEN((o), (len))
806
#define SCM_STRING_MUTABLEP(o) SCM_SAL_STRING_MUTABLEP(o)
807
#define SCM_STRING_SET_MUTABLE(o) SCM_SAL_STRING_SET_MUTABLE(o)
808
#define SCM_STRING_SET_IMMUTABLE(o) SCM_SAL_STRING_SET_IMMUTABLE(o)
809
#endif /* SCM_USE_STRING */
811
#define SCM_FUNCP(o) SCM_SAL_FUNCP(o)
812
#define SCM_FUNC_TYPECODE(o) SCM_SAL_FUNC_TYPECODE(o)
813
#define SCM_FUNC_CFUNC(o) SCM_SAL_FUNC_CFUNC(o)
814
#define SCM_FUNC_SET_TYPECODE(o, type) SCM_SAL_FUNC_SET_TYPECODE((o), (type))
815
#define SCM_FUNC_SET_CFUNC(o, func) SCM_SAL_FUNC_SET_CFUNC((o), (func))
816
#define SCM_SYNTAXP(o) (SCM_FUNCP(o) \
817
&& (SCM_FUNC_TYPECODE(o) & SCM_FUNCTYPE_SYNTAX))
818
#define SCM_PROCEDUREP(o) ((SCM_FUNCP(o) \
819
&& !(SCM_FUNC_TYPECODE(o) & SCM_FUNCTYPE_SYNTAX)) \
821
|| SCM_CONTINUATIONP(o))
823
#if (SCM_USE_HYGIENIC_MACRO && SCM_USE_LEGACY_MACRO)
824
#define SCM_SYNTACTIC_OBJECTP(o) (SCM_SYNTAXP(o) || SCM_HMACROP(o) \
825
|| SCM_SYNTACTIC_CLOSUREP(o))
826
#elif SCM_USE_HYGIENIC_MACRO
827
#define SCM_SYNTACTIC_OBJECTP(o) (SCM_SYNTAXP(o) || SCM_HMACROP(o))
828
#elif SCM_USE_LEGACY_MACRO
829
#define SCM_SYNTACTIC_OBJECTP(o) (SCM_SYNTAXP(o) || SCM_SYNTACTIC_CLOSUREP(o))
831
#define SCM_SYNTACTIC_OBJECTP(o) (SCM_SYNTAXP(o))
834
#if SCM_USE_LEGACY_MACRO
835
#define SCM_SYNTACTIC_CLOSURE_ENV scm_syntactic_closure_env
836
#define SCM_SYNTACTIC_CLOSUREP(o) \
838
&& SCM_EQ(SCM_CLOSURE_ENV(o), SCM_SYNTACTIC_CLOSURE_ENV))
841
#define SCM_CLOSUREP(o) SCM_SAL_CLOSUREP(o)
842
#define SCM_CLOSURE_EXP(o) SCM_SAL_CLOSURE_EXP(o)
843
#define SCM_CLOSURE_ENV(o) SCM_SAL_CLOSURE_ENV(o)
844
#define SCM_CLOSURE_SET_EXP(o, exp) SCM_SAL_CLOSURE_SET_EXP((o), (exp))
845
#define SCM_CLOSURE_SET_ENV(o, env) SCM_SAL_CLOSURE_SET_ENV((o), (env))
848
#define SCM_VECTORP(o) SCM_SAL_VECTORP(o)
849
#define SCM_VECTOR_VEC(o) SCM_SAL_VECTOR_VEC(o)
850
#define SCM_VECTOR_LEN(o) SCM_SAL_VECTOR_LEN(o)
851
#define SCM_VECTOR_SET_VEC(o, vec) SCM_SAL_VECTOR_SET_VEC((o), (vec))
852
#define SCM_VECTOR_SET_LEN(o, len) SCM_SAL_VECTOR_SET_LEN((o), (len))
853
#define SCM_VECTOR_MUTABLEP(o) SCM_SAL_VECTOR_MUTABLEP(o)
854
#define SCM_VECTOR_SET_MUTABLE(o) SCM_SAL_VECTOR_SET_MUTABLE(o)
855
#define SCM_VECTOR_SET_IMMUTABLE(o) SCM_SAL_VECTOR_SET_IMMUTABLE(o)
856
#define SCM_VECTOR_VALID_INDEXP(o, i) (0 <= (i) && (i) < SCM_VECTOR_LEN(o))
857
#endif /* SCM_USE_VECTOR */
860
#define SCM_PORTP(o) SCM_SAL_PORTP(o)
861
#define SCM_PORT_FLAG(o) SCM_SAL_PORT_FLAG(o)
862
#define SCM_PORT_IMPL(o) SCM_SAL_PORT_IMPL(o)
863
#define SCM_PORT_SET_FLAG(o, flag) SCM_SAL_PORT_SET_FLAG((o), (flag))
864
#define SCM_PORT_SET_IMPL(o, impl) SCM_SAL_PORT_SET_IMPL((o), (impl))
865
#endif /* SCM_USE_PORT */
867
#if (SCM_USE_CONTINUATION || SCM_USE_VALUES_APPLIER)
868
#define SCM_CONTINUATIONP(o) SCM_SAL_CONTINUATIONP(o)
869
#define SCM_CONTINUATION_OPAQUE(o) SCM_SAL_CONTINUATION_OPAQUE(o)
870
#define SCM_CONTINUATION_TAG(o) SCM_SAL_CONTINUATION_TAG(o)
871
#define SCM_CONTINUATION_SET_OPAQUE(o, val) \
872
SCM_SAL_CONTINUATION_SET_OPAQUE((o), (val))
873
#define SCM_CONTINUATION_SET_TAG(o, val) \
874
SCM_SAL_CONTINUATION_SET_TAG((o), (val))
875
#endif /* (SCM_USE_CONTINUATION || SCM_USE_VALUES_APPLIER) */
877
#define SCM_VALUEPACKETP(o) SCM_SAL_VALUEPACKETP(o)
879
#define SCM_CONSTANTP(o) SCM_SAL_CONSTANTP(o)
881
#if SCM_USE_SSCM_EXTENSIONS
882
#define SCM_C_POINTERP(o) SCM_SAL_C_POINTERP(o)
883
#define SCM_C_POINTER_VALUE(o) SCM_SAL_C_POINTER_VALUE(o)
884
#define SCM_C_POINTER_SET_VALUE(o, ptr) SCM_SAL_C_POINTER_SET_VALUE((o), (ptr))
886
#define SCM_C_FUNCPOINTERP(o) SCM_SAL_C_FUNCPOINTERP(o)
887
#define SCM_C_FUNCPOINTER_VALUE(o) SCM_SAL_C_FUNCPOINTER_VALUE(o)
888
#define SCM_C_FUNCPOINTER_SET_VALUE(o, funcptr) \
889
SCM_SAL_C_FUNCPOINTER_SET_VALUE((o), (funcptr))
890
#endif /* SCM_USE_SSCM_EXTENSIONS */
892
#if SCM_USE_HYGIENIC_MACRO
893
#define SCM_HMACROP(o) SCM_SAL_HMACROP(o)
894
#define SCM_HMACRO_RULES(o) SCM_SAL_HMACRO_RULES(o)
895
#define SCM_HMACRO_ENV(o) SCM_SAL_HMACRO_ENV(o)
896
#define SCM_HMACRO_SET_RULES(o, r) SCM_SAL_HMACRO_SET_RULES((o), (r))
897
#define SCM_HMACRO_SET_ENV(o, e) SCM_SAL_HMACRO_SET_ENV((o), (e))
898
#define SCM_FARSYMBOLP(o) SCM_SAL_FARSYMBOLP(o)
899
#define SCM_FARSYMBOL_SYM(o) SCM_SAL_FARSYMBOL_SYM(o)
900
#define SCM_FARSYMBOL_ENV(o) SCM_SAL_FARSYMBOL_ENV(o)
901
#define SCM_FARSYMBOL_SET_SYM(o, s) SCM_SAL_FARSYMBOL_SET_SYM((o), (s))
902
#define SCM_FARSYMBOL_SET_ENV(o, e) SCM_SAL_FARSYMBOL_SET_ENV((o), (e))
903
#define SCM_SUBPATP(o) SCM_SAL_SUBPATP(o)
904
#define SCM_SUBPAT_OBJ(o) SCM_SAL_SUBPAT_OBJ(o)
905
#define SCM_SUBPAT_META(o) SCM_SAL_SUBPAT_META(o)
906
#define SCM_SUBPAT_SET_OBJ(o, x) SCM_SAL_SUBPAT_SET_OBJ((o), (x))
907
#define SCM_SUBPAT_SET_META(o, m) SCM_SAL_SUBPAT_SET_META((o), (m))
910
/* Marks where pattern variable were present in the original pattern.
911
* Records the symbol and index of the pattern variable. See macro.c
912
* for the terminology. It's generally not a good idea to directly
913
* manipulate compiled macro bodies, though. */
915
#define SCM_SUBPAT_MAKE_PVAR(obj, idx) (MAKE_SUBPAT((obj), (idx)))
916
#else /* not SCM_DEBUG_MACRO */
917
#define SCM_SUBPAT_MAKE_PVAR(obj, idx) MAKE_SUBPAT(SCM_NULL, (idx))
918
#endif /* not SCM_DEBUG_MACRO */
919
#define SCM_SUBPAT_PVAR_INDEX(obj) SCM_SUBPAT_META(obj)
920
#define SCM_SUBPAT_PVARP(obj) (SCM_SUBPAT_PVAR_INDEX(obj) >= 0)
922
/* Repeatable subpattern. Contains the subpattern and the number of
923
* pattern variables within it. */
924
#define SCM_SUBPAT_MAKE_REPPAT(subpat, pvcount) \
925
(MAKE_SUBPAT((subpat), ~(pvcount)))
926
#define SCM_SUBPAT_REPPAT_PAT(subpat) SCM_SUBPAT_OBJ(subpat)
927
#define SCM_SUBPAT_REPPAT_PVCOUNT(subpat) (~(SCM_SUBPAT_META(subpat)))
928
#define SCM_SUBPAT_REPPATP(obj) (SCM_SUBPAT_PVAR_INDEX(obj) < 0)
930
#define SCM_IDENTIFIERP(o) (SCM_SYMBOLP(o) || SCM_FARSYMBOLP(o))
931
#else /* not SCM_USE_HYGIENIC_MACRO */
932
#define SCM_IDENTIFIERP(o) SCM_SYMBOLP(o)
933
#endif /* not SCM_USE_HYGIENIC_MACRO */
935
/*===========================================================================
937
===========================================================================*/
938
#if SCM_USE_HYGIENIC_MACRO
940
* Strips the argument of binding information. Syntaxes that take
941
* verbatim data as their argument (e.g. quote, case) must unwrap that
942
* argument before using it. UNWRAP_SYNTAX() may or may not
943
* destructively unwrap the input, so the return value must always be
944
* used. The caller shouldn't assume the input is equal? before and
947
#define SCM_UNWRAP_SYNTAX(o) scm_unwrap_syntaxx((o))
950
* If the argument is an identifier, it is stripped of binding
951
* information and returned. Otherwise, the argument is returned
952
* without any modification.
954
#define SCM_UNWRAP_KEYWORD(o) scm_unwrap_keyword(o)
955
#else /* not SCM_USE_HYGIENIC_MACRO */
956
#define SCM_UNWRAP_SYNTAX(o) (o)
957
#define SCM_UNWRAP_KEYWORD(o) (o)
960
/*===========================================================================
961
Environment Specifiers
962
===========================================================================*/
963
#define SCM_INTERACTION_ENV SCM_SAL_INTERACTION_ENV
965
* Current implementation cannot handle scheme-report-environment and
966
* null-environment properly. Be careful to use these environemnts.
968
#define SCM_R5RS_ENV SCM_SAL_R5RS_ENV
969
#define SCM_NULL_ENV SCM_SAL_NULL_ENV
971
#define SCM_ENVP(env) SCM_SAL_ENVP(env)
973
/*===========================================================================
974
Abstract ScmObj Reference For Storage-Representation Independent Efficient
976
===========================================================================*/
977
#define SCM_INVALID_REF SCM_SAL_INVALID_REF
979
/* refer car slot of a cons cell */
980
#define SCM_REF_CAR(kons) SCM_SAL_REF_CAR(kons)
981
/* refer cdr slot of a cons cell */
982
#define SCM_REF_CDR(kons) SCM_SAL_REF_CDR(kons)
983
/* refer an off-heap object */
984
#define SCM_REF_OFF_HEAP(obj) SCM_SAL_REF_OFF_HEAP(obj)
986
/* SCM_DEREF(ref) is not permitted to be used as lvalue */
987
#define SCM_DEREF(ref) SCM_SAL_DEREF(ref)
989
/* RFC: Is there a better name? */
990
#define SCM_SET(ref, obj) SCM_SAL_SET((ref), (obj))
992
/*===========================================================================
993
Special Constants and Predicates
994
===========================================================================*/
995
#define SCM_INVALID SCM_SAL_INVALID
996
#define SCM_NULL SCM_SAL_NULL
997
#define SCM_TRUE SCM_SAL_TRUE
998
#define SCM_FALSE SCM_SAL_FALSE
999
#define SCM_EOF SCM_SAL_EOF
1000
#define SCM_UNBOUND SCM_SAL_UNBOUND
1001
#define SCM_UNDEF SCM_SAL_UNDEF
1003
#define SCM_EQ(a, b) (SCM_SAL_EQ((a), (b)))
1004
#define SCM_NULLP(o) (SCM_EQ((o), SCM_NULL))
1005
#define SCM_FALSEP(o) (SCM_EQ((o), SCM_FALSE))
1006
#define SCM_TRUEP(o) (!SCM_FALSEP(o))
1007
#define SCM_EOFP(o) (SCM_EQ((o), SCM_EOF))
1010
#define SCM_EQVP(a, b) SCM_SAL_EQVP((a), (b))
1011
#else /* don't have inlined eqv? */
1012
#define SCM_EQVP(a, b) SCM_TRUEP(scm_p_eqvp((a), (b)))
1013
#endif /* don't have inlined eqv? */
1015
/*===========================================================================
1017
===========================================================================*/
1018
/* for list construction */
1019
/* Don't use scm_sym_* directly. */
1020
#define SCM_SYM_QUOTE scm_sym_quote
1021
#define SCM_SYM_QUASIQUOTE scm_sym_quasiquote
1022
#define SCM_SYM_UNQUOTE scm_sym_unquote
1023
#define SCM_SYM_UNQUOTE_SPLICING scm_sym_unquote_splicing
1024
#define SCM_SYM_ELLIPSIS scm_sym_ellipsis
1026
/*=======================================
1028
=======================================*/
1029
typedef ScmRef ScmQueue;
1030
#define SCM_QUEUE_INVALIDATE(_q) ((_q) = SCM_INVALID_REF)
1031
#define SCM_QUEUE_VALIDP(_q) ((_q) != SCM_INVALID_REF)
1032
#define SCM_QUEUE_POINT_TO(_q, _out) ((_q) = SCM_REF_OFF_HEAP(_out))
1033
#define SCM_QUEUE_ADD(_q, _dat) (SCM_SET((_q), SCM_LIST_1(_dat)), \
1034
(_q) = SCM_REF_CDR(SCM_DEREF(_q)))
1035
#define SCM_QUEUE_CONST_ADD(_q, _dat) \
1036
(SCM_SET((_q), SCM_IMMUTABLE_CONS((_dat), SCM_NULL)), \
1037
(_q) = SCM_REF_CDR(SCM_DEREF(_q)))
1038
#define SCM_QUEUE_APPEND(_q, _lst) \
1040
SCM_SET((_q), (_lst)); \
1041
while (SCM_CONSP(SCM_DEREF(_q))) \
1042
(_q) = SCM_REF_CDR(SCM_DEREF(_q)); \
1043
} while (/* CONSTCOND */ 0)
1044
#define SCM_QUEUE_TERMINATOR(_q) (SCM_DEREF(_q))
1045
#define SCM_QUEUE_SLOPPY_APPEND(_q, _lst) (SCM_SET((_q), (_lst)))
1047
/*=======================================
1049
=======================================*/
1051
SCM_VALTYPE_AS_IS = scm_false,
1052
SCM_VALTYPE_NEED_EVAL = scm_true
1056
* for strict top-level definitions
1058
* R5RS: 7.1.6 Programs and definitions
1060
* <program> --> <command or definition>*
1061
* <command or definition> --> <command>
1063
* | <syntax definition>
1064
* | (begin <command or definition>+)
1065
* <definition> --> (define <variable> <expression>)
1066
* | (define (<variable> <def formals>) <body>)
1067
* | (begin <definition>*)
1068
* <command> --> <expression>
1072
SCM_NEST_COMMAND_OR_DEFINITION,
1074
SCM_NEST_RETTYPE_BEGIN
1077
/* whether top-level 'define' can be performed */
1078
#if SCM_STRICT_TOPLEVEL_DEFINITIONS
1079
#define SCM_DEFINABLE_TOPLEVELP(eval_state) \
1080
(!EQ((eval_state)->env, SCM_INTERACTION_ENV_INDEFINABLE) \
1081
&& scm_toplevel_environmentp((eval_state)->env) \
1082
&& ((eval_state)->nest == SCM_NEST_PROGRAM \
1083
|| (eval_state)->nest == SCM_NEST_COMMAND_OR_DEFINITION))
1085
#define SCM_DEFINABLE_TOPLEVELP(eval_state) \
1086
(scm_toplevel_environmentp((eval_state)->env))
1089
typedef struct ScmEvalState_ ScmEvalState;
1090
struct ScmEvalState_ {
1092
enum ScmValueType ret_type;
1093
enum ScmNestState nest;
1096
/* Use these constructors instead of manually initialize each members because
1097
* another member may be added. Such member will implicitly be initialized
1098
* properly as long as the constructors are used. */
1099
#define SCM_EVAL_STATE_INIT(state) \
1100
SCM_EVAL_STATE_INIT1((state), SCM_INTERACTION_ENV)
1102
#define SCM_EVAL_STATE_INIT1(state, env) \
1103
SCM_EVAL_STATE_INIT2((state), (env), SCM_VALTYPE_NEED_EVAL)
1105
#define SCM_EVAL_STATE_INIT2(state, env, ret_type) \
1106
SCM_EVAL_STATE_INIT3((state), (env), (ret_type), \
1107
(SCM_EQ((env), SCM_INTERACTION_ENV)) \
1108
? SCM_NEST_PROGRAM : SCM_NEST_COMMAND)
1110
#define SCM_EVAL_STATE_INIT3(state, _env, _ret_type, _nest) \
1112
(state).env = (_env); \
1113
(state).ret_type = (_ret_type); \
1114
(state).nest = (_nest); \
1115
} while (/* CONSTCOND */ 0)
1117
#define SCM_FINISH_TAILREC_CALL(obj, eval_state) \
1118
(((eval_state)->ret_type == SCM_VALTYPE_NEED_EVAL) \
1119
? ((eval_state)->ret_type = SCM_VALTYPE_AS_IS, \
1120
EVAL((obj), (eval_state)->env)) \
1123
/*=======================================
1125
=======================================*/
1127
enum ScmFormatCapability {
1129
SCM_FMT_RAW_C = 1 << 0, /* take raw C values from va_list */
1130
SCM_FMT_SRFI28 = 1 << 1,
1131
SCM_FMT_SRFI48_ADDENDUM = 1 << 2,
1132
SCM_FMT_LEADING_ZEROS = 1 << 3, /* padding with zeros "00034" */
1133
SCM_FMT_PREFIXED_RADIX = 1 << 4, /* "8x" 65535 => " ffff" */
1135
SCM_FMT_SRFI48 = (SCM_FMT_SRFI28 | SCM_FMT_SRFI48_ADDENDUM),
1136
SCM_FMT_SSCM_ADDENDUM = (SCM_FMT_LEADING_ZEROS | SCM_FMT_PREFIXED_RADIX),
1137
SCM_FMT_SSCM = (SCM_FMT_SRFI48 | SCM_FMT_SSCM_ADDENDUM),
1138
SCM_FMT_INTERNAL = (SCM_FMT_RAW_C | SCM_FMT_SSCM)
1140
#endif /* SCM_USE_FORMAT */
1142
typedef struct ScmValueFormat_ ScmValueFormat;
1143
struct ScmValueFormat_ {
1144
signed char width; /* integer part width */
1145
signed char frac_width; /* fractional part width */
1146
char pad; /* char for padding prefix */
1150
#define SCM_VALUE_FORMAT_INIT(vfmt) \
1151
SCM_VALUE_FORMAT_INIT4((vfmt), -1, -1, ' ', scm_true)
1153
#define SCM_VALUE_FORMAT_INIT4(vfmt, w, fw, p, s) \
1155
(vfmt).width = (w); \
1156
(vfmt).frac_width = (fw); \
1158
(vfmt).signedp = (s); \
1159
} while (/* CONSTCOND */ 0)
1161
#define SCM_VALUE_FORMAT_SPECIFIEDP(vfmt) \
1162
((vfmt).width > 0 || (vfmt).frac_width > 0 || (vfmt).pad != ' ' \
1165
/*=======================================
1167
=======================================*/
1168
struct scm_func_registration_info {
1169
const char *funcname;
1171
enum ScmFuncTypeCode typecode;
1174
typedef ScmObj (*scm_reduction_operator)(ScmObj, ScmObj, enum ScmReductionState *);
1175
typedef ScmObj (*scm_syntax_fixed_0)(ScmObj);
1176
typedef ScmObj (*scm_syntax_fixed_tailrec_0)(ScmEvalState *);
1177
typedef ScmObj (*scm_syntax_variadic_0)(ScmObj, ScmObj);
1178
typedef ScmObj (*scm_syntax_variadic_tailrec_0)(ScmObj, ScmEvalState *);
1179
typedef ScmObj (*scm_procedure_fixed_0)(void);
1180
typedef ScmObj (*scm_procedure_fixed_tailrec_0)(ScmEvalState *);
1181
typedef ScmObj (*scm_procedure_variadic_0)(ScmObj);
1182
typedef ScmObj (*scm_procedure_variadic_tailrec_0)(ScmObj, ScmEvalState *);
1183
#if SCM_FUNCTYPE_MAND_MAX >= 1
1184
typedef ScmObj (*scm_syntax_fixed_1)(ScmObj, ScmObj);
1185
typedef ScmObj (*scm_syntax_fixed_tailrec_1)(ScmObj, ScmEvalState *);
1186
typedef ScmObj (*scm_syntax_variadic_1)(ScmObj, ScmObj, ScmObj);
1187
typedef ScmObj (*scm_syntax_variadic_tailrec_1)(ScmObj, ScmObj, ScmEvalState *);
1188
typedef ScmObj (*scm_procedure_fixed_1)(ScmObj);
1189
typedef ScmObj (*scm_procedure_fixed_tailrec_1)(ScmObj, ScmEvalState *);
1190
typedef ScmObj (*scm_procedure_variadic_1)(ScmObj, ScmObj);
1191
typedef ScmObj (*scm_procedure_variadic_tailrec_1)(ScmObj, ScmObj, ScmEvalState *);
1193
#if SCM_FUNCTYPE_MAND_MAX >= 2
1194
typedef ScmObj (*scm_syntax_fixed_2)(ScmObj, ScmObj, ScmObj);
1195
typedef ScmObj (*scm_syntax_fixed_tailrec_2)(ScmObj, ScmObj, ScmEvalState *);
1196
typedef ScmObj (*scm_syntax_variadic_2)(ScmObj, ScmObj, ScmObj, ScmObj);
1197
typedef ScmObj (*scm_syntax_variadic_tailrec_2)(ScmObj, ScmObj, ScmObj, ScmEvalState *);
1198
typedef ScmObj (*scm_procedure_fixed_2)(ScmObj, ScmObj);
1199
typedef ScmObj (*scm_procedure_fixed_tailrec_2)(ScmObj, ScmObj, ScmEvalState *);
1200
typedef ScmObj (*scm_procedure_variadic_2)(ScmObj, ScmObj, ScmObj);
1201
typedef ScmObj (*scm_procedure_variadic_tailrec_2)(ScmObj, ScmObj, ScmObj, ScmEvalState *);
1203
#if SCM_FUNCTYPE_MAND_MAX >= 3
1204
typedef ScmObj (*scm_syntax_fixed_3)(ScmObj, ScmObj, ScmObj, ScmObj);
1205
typedef ScmObj (*scm_syntax_fixed_tailrec_3)(ScmObj, ScmObj, ScmObj, ScmEvalState *);
1206
typedef ScmObj (*scm_syntax_variadic_3)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj);
1207
typedef ScmObj (*scm_syntax_variadic_tailrec_3)(ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState *);
1208
typedef ScmObj (*scm_procedure_fixed_3)(ScmObj, ScmObj, ScmObj);
1209
typedef ScmObj (*scm_procedure_fixed_tailrec_3)(ScmObj, ScmObj, ScmObj, ScmEvalState *);
1210
typedef ScmObj (*scm_procedure_variadic_3)(ScmObj, ScmObj, ScmObj, ScmObj);
1211
typedef ScmObj (*scm_procedure_variadic_tailrec_3)(ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState *);
1213
#if SCM_FUNCTYPE_MAND_MAX >= 4
1214
typedef ScmObj (*scm_syntax_fixed_4)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj);
1215
typedef ScmObj (*scm_syntax_fixed_tailrec_4)(ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState *);
1216
typedef ScmObj (*scm_syntax_variadic_4)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmObj);
1217
typedef ScmObj (*scm_syntax_variadic_tailrec_4)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState *);
1218
typedef ScmObj (*scm_procedure_fixed_4)(ScmObj, ScmObj, ScmObj, ScmObj);
1219
typedef ScmObj (*scm_procedure_fixed_tailrec_4)(ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState *);
1220
typedef ScmObj (*scm_procedure_variadic_4)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj);
1221
typedef ScmObj (*scm_procedure_variadic_tailrec_4)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState *);
1223
#if SCM_FUNCTYPE_MAND_MAX >= 5
1224
typedef ScmObj (*scm_syntax_fixed_5)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmObj);
1225
typedef ScmObj (*scm_syntax_fixed_tailrec_5)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState *);
1226
typedef ScmObj (*scm_syntax_variadic_5)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmObj);
1227
typedef ScmObj (*scm_syntax_variadic_tailrec_5)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState *);
1228
typedef ScmObj (*scm_procedure_fixed_5)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj);
1229
typedef ScmObj (*scm_procedure_fixed_tailrec_5)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState *);
1230
typedef ScmObj (*scm_procedure_variadic_5)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmObj);
1231
typedef ScmObj (*scm_procedure_variadic_tailrec_5)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState *);
1234
/*=======================================
1235
Variable Declarations
1236
=======================================*/
1238
/* Don't use scm_sym_* directly. Use SCM_SYM_* instead. */
1239
SCM_GLOBAL_VARS_BEGIN(syntax);
1240
ScmObj scm_sym_quote, scm_sym_quasiquote;
1241
ScmObj scm_sym_unquote, scm_sym_unquote_splicing;
1242
ScmObj scm_sym_ellipsis;
1243
SCM_GLOBAL_VARS_END(syntax);
1244
#define scm_sym_quote SCM_GLOBAL_VAR(syntax, scm_sym_quote)
1245
#define scm_sym_quasiquote SCM_GLOBAL_VAR(syntax, scm_sym_quasiquote)
1246
#define scm_sym_unquote SCM_GLOBAL_VAR(syntax, scm_sym_unquote)
1247
#define scm_sym_unquote_splicing SCM_GLOBAL_VAR(syntax, scm_sym_unquote_splicing)
1248
#define scm_sym_ellipsis SCM_GLOBAL_VAR(syntax, scm_sym_ellipsis)
1249
SCM_DECLARE_EXPORTED_VARS(syntax);
1251
/* legacy-macro.c */
1252
#if SCM_USE_LEGACY_MACRO
1253
/* Don't use scm_syntactic_closure_env directly. Use SCM_SYNTACTIC_CLOSURE_ENV
1255
SCM_GLOBAL_VARS_BEGIN(legacy_macro);
1256
ScmObj scm_syntactic_closure_env;
1257
SCM_GLOBAL_VARS_END(legacy_macro);
1258
#define scm_syntactic_closure_env \
1259
SCM_GLOBAL_VAR(legacy_macro, scm_syntactic_closure_env)
1260
SCM_DECLARE_EXPORTED_VARS(legacy_macro);
1261
#endif /* SCM_USE_LEGACY_MACRO */
1263
/*=======================================
1264
Function Declarations
1265
=======================================*/
1266
/*===========================================================================
1267
SigScheme: Core Functions
1268
===========================================================================*/
1270
SCM_EXPORT char **scm_initialize(const ScmStorageConf *storage_conf,
1271
const char *const *argv);
1272
SCM_EXPORT void scm_finalize(void);
1273
#if SCM_USE_EVAL_C_STRING
1274
SCM_EXPORT ScmObj scm_eval_c_string(const char *exp);
1276
SCM_EXPORT ScmObj scm_array2list(void **ary, size_t len,
1277
ScmObj (*conv)(void *));
1278
SCM_EXPORT void **scm_list2array(ScmObj lst, size_t *len,
1279
void *(*conv)(ScmObj));
1282
SCM_EXPORT void scm_provide(ScmObj feature);
1283
SCM_EXPORT scm_bool scm_providedp(ScmObj feature);
1284
#if 1 /* 'use' is deprecated and will be removed in SigScheme 0.9 */
1285
SCM_EXPORT scm_bool scm_use(const char *feature);
1286
SCM_EXPORT ScmObj scm_s_use(ScmObj feature, ScmObj env);
1288
SCM_EXPORT scm_bool scm_require_module(const char *name);
1289
SCM_EXPORT ScmObj scm_p_require_module(ScmObj name);
1290
SCM_EXPORT ScmObj scm_register_func(const char *name, ScmFuncType func,
1291
enum ScmFuncTypeCode type);
1292
SCM_EXPORT void scm_register_funcs(const struct scm_func_registration_info *table);
1293
SCM_EXPORT void scm_define_alias(const char *newsym, const char *sym);
1296
SCM_EXPORT void *scm_malloc_aligned(size_t size);
1297
SCM_EXPORT void *scm_malloc(size_t size);
1298
SCM_EXPORT void *scm_calloc(size_t number, size_t size);
1299
SCM_EXPORT void *scm_realloc(void *ptr, size_t size);
1300
SCM_EXPORT char *scm_strdup(const char *str);
1303
SCM_EXPORT void scm_gc_protect(ScmObj *var);
1304
SCM_EXPORT void scm_gc_protect_with_init(ScmObj *var, ScmObj init_val);
1305
SCM_EXPORT void scm_gc_unprotect(ScmObj *var);
1306
SCM_EXPORT scm_bool scm_gc_protectedp(ScmObj obj);
1307
SCM_EXPORT void *scm_call_with_gc_ready_stack(ScmGCGateFunc func, void *arg);
1308
SCM_EXPORT scm_bool scm_gc_protected_contextp(void);
1309
/* for semantic assertions */
1310
#define scm_gc_any_contextp() \
1311
(!scm_gc_protected_contextp() || scm_gc_protected_contextp())
1314
SCM_EXPORT ScmObj scm_intern(const char *name);
1315
SCM_EXPORT ScmObj scm_symbol_bound_to(ScmObj obj);
1318
SCM_EXPORT enum ScmDebugCategory scm_debug_categories(void);
1319
SCM_EXPORT void scm_set_debug_categories(enum ScmDebugCategory categories);
1320
SCM_EXPORT enum ScmDebugCategory scm_predefined_debug_categories(void);
1322
SCM_EXPORT void scm_categorized_debug(enum ScmDebugCategory category,
1323
const char *msg, ...);
1324
SCM_EXPORT void scm_debug(const char *msg, ...);
1325
#endif /* SCM_DEBUG */
1326
SCM_EXPORT void scm_die(const char *msg, const char *filename, int line) SCM_NORETURN;
1327
SCM_EXPORT void scm_plain_error(const char *msg, ...) SCM_NORETURN;
1328
SCM_EXPORT void scm_error(const char *funcname, const char *msg, ...) SCM_NORETURN;
1329
SCM_EXPORT void scm_error_obj(const char *funcname, const char *msg,
1330
ScmObj obj) SCM_NORETURN;
1331
SCM_EXPORT void scm_show_backtrace(ScmObj trace_stack);
1332
SCM_EXPORT ScmObj scm_make_error_obj(ScmObj reason, ScmObj objs);
1333
SCM_EXPORT void scm_raise_error(ScmObj err_obj) SCM_NORETURN;
1334
SCM_EXPORT void scm_fatal_error(const char *msg) SCM_NORETURN;
1335
SCM_EXPORT void scm_set_fatal_error_callback(void (*cb)(void));
1336
SCM_EXPORT ScmObj scm_p_error_objectp(ScmObj obj);
1337
SCM_EXPORT ScmObj scm_p_fatal_error(ScmObj err_obj) SCM_NORETURN;
1338
SCM_EXPORT ScmObj scm_p_inspect_error(ScmObj err_obj);
1339
SCM_EXPORT ScmObj scm_p_backtrace(void);
1342
SCM_EXPORT ScmObj scm_symbol_value(ScmObj var, ScmObj env);
1343
SCM_EXPORT ScmObj scm_eval(ScmObj obj, ScmObj env);
1344
SCM_EXPORT ScmObj scm_call(ScmObj proc, ScmObj args);
1345
SCM_EXPORT ScmObj scm_p_eval(ScmObj obj, ScmObj env);
1346
SCM_EXPORT ScmObj scm_p_apply(ScmObj proc, ScmObj arg0, ScmObj rest,
1347
ScmEvalState *eval_state);
1348
SCM_EXPORT ScmObj scm_p_scheme_report_environment(ScmObj version);
1349
SCM_EXPORT ScmObj scm_p_null_environment(ScmObj version);
1350
SCM_EXPORT ScmObj scm_p_interaction_environment(void);
1353
SCM_EXPORT ScmObj scm_s_quote(ScmObj datum, ScmObj env);
1354
SCM_EXPORT ScmObj scm_s_lambda(ScmObj formals, ScmObj body, ScmObj env);
1355
SCM_EXPORT ScmObj scm_s_if(ScmObj test, ScmObj conseq, ScmObj rest,
1356
ScmEvalState *eval_state);
1357
SCM_EXPORT ScmObj scm_s_setx(ScmObj var, ScmObj val, ScmObj env);
1358
SCM_EXPORT ScmObj scm_s_cond(ScmObj clauses, ScmEvalState *eval_state);
1359
SCM_EXPORT ScmObj scm_s_case(ScmObj key, ScmObj args,
1360
ScmEvalState *eval_state);
1361
SCM_EXPORT ScmObj scm_s_and(ScmObj args, ScmEvalState *eval_state);
1362
SCM_EXPORT ScmObj scm_s_or(ScmObj args, ScmEvalState *eval_state);
1363
SCM_EXPORT ScmObj scm_s_let(ScmObj bindings, ScmObj body,
1364
ScmEvalState *eval_state);
1365
SCM_EXPORT ScmObj scm_s_letstar(ScmObj bindings, ScmObj body,
1366
ScmEvalState *eval_state);
1367
SCM_EXPORT ScmObj scm_s_letrec(ScmObj bindings, ScmObj body,
1368
ScmEvalState *eval_state);
1369
SCM_EXPORT ScmObj scm_s_begin(ScmObj args, ScmEvalState *eval_state);
1370
SCM_EXPORT ScmObj scm_s_do(ScmObj bindings, ScmObj test_exps, ScmObj commands,
1371
ScmEvalState *eval_state);
1372
SCM_EXPORT ScmObj scm_s_define(ScmObj var, ScmObj rest,
1373
ScmEvalState *eval_state);
1376
#if SCM_USE_QUASIQUOTE
1377
SCM_EXPORT ScmObj scm_s_quasiquote(ScmObj datum, ScmObj env);
1378
SCM_EXPORT ScmObj scm_s_unquote(ScmObj dummy, ScmObj env);
1379
SCM_EXPORT ScmObj scm_s_unquote_splicing(ScmObj dummy, ScmObj env);
1380
#endif /* SCM_USE_QUASIQUOTE */
1384
SCM_EXPORT ScmObj scm_s_delay(ScmObj exp, ScmObj env);
1385
SCM_EXPORT ScmObj scm_p_force(ScmObj promise);
1386
#endif /* SCM_USE_PROMISE */
1389
SCM_EXPORT ScmObj scm_p_eqp(ScmObj obj1, ScmObj obj2);
1390
SCM_EXPORT ScmObj scm_p_eqvp(ScmObj obj1, ScmObj obj2);
1391
SCM_EXPORT ScmObj scm_p_equalp(ScmObj obj1, ScmObj obj2);
1392
SCM_EXPORT ScmObj scm_p_not(ScmObj obj);
1393
SCM_EXPORT ScmObj scm_p_booleanp(ScmObj obj);
1394
SCM_EXPORT ScmObj scm_p_symbolp(ScmObj obj);
1395
SCM_EXPORT ScmObj scm_p_symbol2string(ScmObj sym);
1396
SCM_EXPORT ScmObj scm_p_string2symbol(ScmObj str);
1397
SCM_EXPORT ScmObj scm_p_procedurep(ScmObj obj);
1398
SCM_EXPORT ScmObj scm_p_map(ScmObj proc, ScmObj args);
1399
SCM_EXPORT ScmObj scm_p_for_each(ScmObj proc, ScmObj args);
1400
#if SCM_USE_CONTINUATION
1401
SCM_EXPORT ScmObj scm_p_call_with_current_continuation(ScmObj proc, ScmEvalState *eval_state);
1403
SCM_EXPORT ScmObj scm_p_values(ScmObj args);
1404
SCM_EXPORT ScmObj scm_p_call_with_values(ScmObj producer, ScmObj consumer,
1405
ScmEvalState *eval_state);
1406
#if SCM_USE_CONTINUATION
1407
SCM_EXPORT ScmObj scm_p_dynamic_wind(ScmObj before, ScmObj thunk,
1412
SCM_EXPORT scm_int_t scm_length(ScmObj lst);
1413
SCM_EXPORT ScmObj scm_list_tail(ScmObj lst, scm_int_t k);
1414
SCM_EXPORT ScmObj scm_p_pairp(ScmObj obj);
1415
SCM_EXPORT ScmObj scm_p_cons(ScmObj car, ScmObj cdr);
1416
SCM_EXPORT ScmObj scm_p_car(ScmObj obj);
1417
SCM_EXPORT ScmObj scm_p_cdr(ScmObj obj);
1418
SCM_EXPORT ScmObj scm_p_set_carx(ScmObj pair, ScmObj car);
1419
SCM_EXPORT ScmObj scm_p_set_cdrx(ScmObj pair, ScmObj cdr);
1420
SCM_EXPORT ScmObj scm_p_caar(ScmObj lst);
1421
SCM_EXPORT ScmObj scm_p_cadr(ScmObj lst);
1422
SCM_EXPORT ScmObj scm_p_cdar(ScmObj lst);
1423
SCM_EXPORT ScmObj scm_p_cddr(ScmObj lst);
1424
SCM_EXPORT ScmObj scm_p_caddr(ScmObj lst);
1425
SCM_EXPORT ScmObj scm_p_cdddr(ScmObj lst);
1426
SCM_EXPORT ScmObj scm_p_nullp(ScmObj obj);
1427
SCM_EXPORT ScmObj scm_p_listp(ScmObj obj);
1428
SCM_EXPORT ScmObj scm_p_list(ScmObj args);
1429
SCM_EXPORT ScmObj scm_p_length(ScmObj obj);
1430
SCM_EXPORT ScmObj scm_p_append(ScmObj args);
1431
SCM_EXPORT ScmObj scm_p_reverse(ScmObj lst);
1432
SCM_EXPORT ScmObj scm_p_list_tail(ScmObj lst, ScmObj k);
1433
SCM_EXPORT ScmObj scm_p_list_ref(ScmObj lst, ScmObj k);
1434
SCM_EXPORT ScmObj scm_p_memq(ScmObj obj, ScmObj lst);
1435
SCM_EXPORT ScmObj scm_p_memv(ScmObj obj, ScmObj lst);
1436
SCM_EXPORT ScmObj scm_p_member(ScmObj obj, ScmObj lst);
1437
SCM_EXPORT ScmObj scm_p_assq(ScmObj obj, ScmObj alist);
1438
SCM_EXPORT ScmObj scm_p_assv(ScmObj obj, ScmObj alist);
1439
SCM_EXPORT ScmObj scm_p_assoc(ScmObj obj, ScmObj alist);
1443
SCM_EXPORT ScmObj scm_p_add(ScmObj left, ScmObj right,
1444
enum ScmReductionState *state);
1445
SCM_EXPORT ScmObj scm_p_subtract(ScmObj left, ScmObj right,
1446
enum ScmReductionState *state);
1447
SCM_EXPORT ScmObj scm_p_multiply(ScmObj left, ScmObj right,
1448
enum ScmReductionState *state);
1449
SCM_EXPORT ScmObj scm_p_divide(ScmObj left, ScmObj right,
1450
enum ScmReductionState *state);
1451
SCM_EXPORT ScmObj scm_p_equal(ScmObj left, ScmObj right,
1452
enum ScmReductionState *state);
1453
SCM_EXPORT ScmObj scm_p_less(ScmObj left, ScmObj right,
1454
enum ScmReductionState *state);
1455
SCM_EXPORT ScmObj scm_p_less_equal(ScmObj left, ScmObj right,
1456
enum ScmReductionState *state);
1457
SCM_EXPORT ScmObj scm_p_greater(ScmObj left, ScmObj right,
1458
enum ScmReductionState *state);
1459
SCM_EXPORT ScmObj scm_p_greater_equal(ScmObj left, ScmObj right,
1460
enum ScmReductionState *state);
1461
SCM_EXPORT ScmObj scm_p_numberp(ScmObj obj);
1462
SCM_EXPORT ScmObj scm_p_integerp(ScmObj obj);
1463
SCM_EXPORT ScmObj scm_p_zerop(ScmObj n);
1464
SCM_EXPORT ScmObj scm_p_positivep(ScmObj n);
1465
SCM_EXPORT ScmObj scm_p_negativep(ScmObj n);
1466
SCM_EXPORT ScmObj scm_p_oddp(ScmObj n);
1467
SCM_EXPORT ScmObj scm_p_evenp(ScmObj n);
1468
SCM_EXPORT ScmObj scm_p_max(ScmObj left, ScmObj right,
1469
enum ScmReductionState *state);
1470
SCM_EXPORT ScmObj scm_p_min(ScmObj left, ScmObj right,
1471
enum ScmReductionState *state);
1472
SCM_EXPORT ScmObj scm_p_abs(ScmObj _n);
1473
SCM_EXPORT ScmObj scm_p_quotient(ScmObj _n1, ScmObj _n2);
1474
SCM_EXPORT ScmObj scm_p_modulo(ScmObj _n1, ScmObj _n2);
1475
SCM_EXPORT ScmObj scm_p_remainder(ScmObj _n1, ScmObj _n2);
1476
#endif /* SCM_USE_NUMBER */
1479
#if SCM_USE_NUMBER_IO
1480
SCM_EXPORT scm_int_t scm_string2number(const char *str, int radix,
1483
SCM_EXPORT char *scm_int2string(ScmValueFormat vfmt, uintmax_t n, int radix);
1484
SCM_EXPORT ScmObj scm_p_number2string(ScmObj num, ScmObj args);
1485
SCM_EXPORT ScmObj scm_p_string2number(ScmObj str, ScmObj args);
1486
#endif /* SCM_USE_STRING */
1487
#endif /* SCM_USE_NUMBER_IO */
1491
SCM_EXPORT ScmObj scm_p_charp(ScmObj obj);
1492
SCM_EXPORT ScmObj scm_p_char_equalp(ScmObj ch1, ScmObj ch2);
1493
SCM_EXPORT ScmObj scm_p_char_lessp(ScmObj ch1, ScmObj ch2);
1494
SCM_EXPORT ScmObj scm_p_char_greaterp(ScmObj ch1, ScmObj ch2);
1495
SCM_EXPORT ScmObj scm_p_char_less_equalp(ScmObj ch1, ScmObj ch2);
1496
SCM_EXPORT ScmObj scm_p_char_greater_equalp(ScmObj ch1, ScmObj ch2);
1497
SCM_EXPORT ScmObj scm_p_char_ci_equalp(ScmObj ch1, ScmObj ch2);
1498
SCM_EXPORT ScmObj scm_p_char_ci_lessp(ScmObj ch1, ScmObj ch2);
1499
SCM_EXPORT ScmObj scm_p_char_ci_greaterp(ScmObj ch1, ScmObj ch2);
1500
SCM_EXPORT ScmObj scm_p_char_ci_less_equalp(ScmObj ch1, ScmObj ch2);
1501
SCM_EXPORT ScmObj scm_p_char_ci_greater_equalp(ScmObj ch1, ScmObj ch2);
1502
SCM_EXPORT ScmObj scm_p_char_alphabeticp(ScmObj ch);
1503
SCM_EXPORT ScmObj scm_p_char_numericp(ScmObj ch);
1504
SCM_EXPORT ScmObj scm_p_char_whitespacep(ScmObj ch);
1505
SCM_EXPORT ScmObj scm_p_char_upper_casep(ScmObj ch);
1506
SCM_EXPORT ScmObj scm_p_char_lower_casep(ScmObj ch);
1507
SCM_EXPORT ScmObj scm_p_char2integer(ScmObj ch);
1508
SCM_EXPORT ScmObj scm_p_integer2char(ScmObj n);
1509
SCM_EXPORT ScmObj scm_p_char_upcase(ScmObj ch);
1510
SCM_EXPORT ScmObj scm_p_char_downcase(ScmObj ch);
1511
#endif /* SCM_USE_CHAR */
1515
SCM_EXPORT ScmObj scm_p_stringp(ScmObj obj);
1516
SCM_EXPORT ScmObj scm_p_string_length(ScmObj str);
1517
SCM_EXPORT ScmObj scm_p_stringequalp(ScmObj str1, ScmObj str2);
1518
SCM_EXPORT ScmObj scm_p_string_append(ScmObj args);
1519
SCM_EXPORT ScmObj scm_p_string_copy(ScmObj str);
1520
#endif /* SCM_USE_STRING */
1522
/* string-procedure.c */
1523
#if SCM_USE_STRING_PROCEDURE
1524
SCM_EXPORT ScmObj scm_p_make_string(ScmObj length, ScmObj args);
1525
SCM_EXPORT ScmObj scm_p_string(ScmObj args);
1526
SCM_EXPORT ScmObj scm_p_string_ref(ScmObj str, ScmObj k);
1527
SCM_EXPORT ScmObj scm_p_string_setx(ScmObj str, ScmObj k, ScmObj ch);
1528
SCM_EXPORT ScmObj scm_p_string_ci_equalp(ScmObj str1, ScmObj str2);
1529
SCM_EXPORT ScmObj scm_p_string_greaterp(ScmObj str1, ScmObj str2);
1530
SCM_EXPORT ScmObj scm_p_string_lessp(ScmObj str1, ScmObj str2);
1531
SCM_EXPORT ScmObj scm_p_string_greater_equalp(ScmObj str1, ScmObj str2);
1532
SCM_EXPORT ScmObj scm_p_string_less_equalp(ScmObj str1, ScmObj str2);
1533
SCM_EXPORT ScmObj scm_p_string_ci_greaterp(ScmObj str1, ScmObj str2);
1534
SCM_EXPORT ScmObj scm_p_string_ci_lessp(ScmObj str1, ScmObj str2);
1535
SCM_EXPORT ScmObj scm_p_string_ci_greater_equalp(ScmObj str1, ScmObj str2);
1536
SCM_EXPORT ScmObj scm_p_string_ci_less_equalp(ScmObj str1, ScmObj str2);
1537
SCM_EXPORT ScmObj scm_p_substring(ScmObj str, ScmObj start, ScmObj end);
1538
SCM_EXPORT ScmObj scm_p_string2list(ScmObj str);
1539
SCM_EXPORT ScmObj scm_p_list2string(ScmObj lst);
1540
SCM_EXPORT ScmObj scm_p_string_fillx(ScmObj str, ScmObj ch);
1541
SCM_EXPORT ScmObj scm_p_string_mutablep(ScmObj str);
1542
SCM_EXPORT ScmObj scm_p_string_reconstructx(ScmObj str);
1543
#endif /* SCM_USE_STRING_PROCEDURE */
1547
SCM_EXPORT ScmObj scm_p_vectorp(ScmObj obj);
1548
SCM_EXPORT ScmObj scm_p_make_vector(ScmObj scm_len, ScmObj args);
1549
SCM_EXPORT ScmObj scm_p_vector(ScmObj args);
1550
SCM_EXPORT ScmObj scm_p_vector_length(ScmObj vec);
1551
SCM_EXPORT ScmObj scm_p_vector_ref(ScmObj vec, ScmObj _k);
1552
SCM_EXPORT ScmObj scm_p_vector_setx(ScmObj vec, ScmObj _k, ScmObj obj);
1553
SCM_EXPORT ScmObj scm_p_vector2list(ScmObj vec);
1554
SCM_EXPORT ScmObj scm_p_list2vector(ScmObj lst);
1555
SCM_EXPORT ScmObj scm_p_vector_fillx(ScmObj vec, ScmObj fill);
1556
SCM_EXPORT ScmObj scm_p_vector_mutablep(ScmObj vec);
1557
#endif /* SCM_USE_VECTOR */
1560
#if SCM_USE_DEEP_CADRS
1561
SCM_EXPORT ScmObj scm_p_caaar(ScmObj lst);
1562
SCM_EXPORT ScmObj scm_p_caadr(ScmObj lst);
1563
SCM_EXPORT ScmObj scm_p_cadar(ScmObj lst);
1564
SCM_EXPORT ScmObj scm_p_cdaar(ScmObj lst);
1565
SCM_EXPORT ScmObj scm_p_cdadr(ScmObj lst);
1566
SCM_EXPORT ScmObj scm_p_cddar(ScmObj lst);
1567
SCM_EXPORT ScmObj scm_p_caaaar(ScmObj lst);
1568
SCM_EXPORT ScmObj scm_p_caaadr(ScmObj lst);
1569
SCM_EXPORT ScmObj scm_p_caadar(ScmObj lst);
1570
SCM_EXPORT ScmObj scm_p_caaddr(ScmObj lst);
1571
SCM_EXPORT ScmObj scm_p_cadaar(ScmObj lst);
1572
SCM_EXPORT ScmObj scm_p_cadadr(ScmObj lst);
1573
SCM_EXPORT ScmObj scm_p_caddar(ScmObj lst);
1574
SCM_EXPORT ScmObj scm_p_cadddr(ScmObj lst);
1575
SCM_EXPORT ScmObj scm_p_cdaaar(ScmObj lst);
1576
SCM_EXPORT ScmObj scm_p_cdaadr(ScmObj lst);
1577
SCM_EXPORT ScmObj scm_p_cdadar(ScmObj lst);
1578
SCM_EXPORT ScmObj scm_p_cdaddr(ScmObj lst);
1579
SCM_EXPORT ScmObj scm_p_cddaar(ScmObj lst);
1580
SCM_EXPORT ScmObj scm_p_cddadr(ScmObj lst);
1581
SCM_EXPORT ScmObj scm_p_cdddar(ScmObj lst);
1582
SCM_EXPORT ScmObj scm_p_cddddr(ScmObj lst);
1583
#endif /* SCM_USE_DEEP_CADRS */
1586
#if SCM_USE_HYGIENIC_MACRO
1587
SCM_EXPORT ScmObj scm_s_match(ScmObj form, ScmObj patterns,
1588
ScmEvalState *state);
1589
SCM_EXPORT ScmObj scm_s_syntax_rules(ScmObj rules, ScmObj env);
1590
SCM_EXPORT ScmObj scm_s_expand_macro(ScmObj macro, ScmObj args,
1591
ScmEvalState *eval_state);
1592
SCM_EXPORT ScmObj scm_s_let_syntax(ScmObj bindings, ScmObj body,
1593
ScmEvalState *eval_state);
1594
SCM_EXPORT ScmObj scm_s_letrec_syntax(ScmObj bindings, ScmObj body,
1595
ScmEvalState *eval_state);
1596
SCM_EXPORT ScmObj scm_s_define_syntax(ScmObj var, ScmObj macro, ScmObj env);
1597
SCM_EXPORT ScmObj scm_unwrap_syntaxx(ScmObj obj);
1598
SCM_EXPORT ScmObj scm_unwrap_keyword(ScmObj obj);
1603
SCM_EXPORT ScmObj scm_make_shared_file_port(FILE *file, const char *aux_info,
1604
enum ScmPortFlag flag);
1605
SCM_EXPORT void scm_port_close(ScmObj port);
1606
SCM_EXPORT ScmCharCodec *scm_port_codec(ScmObj port);
1607
SCM_EXPORT char *scm_port_inspect(ScmObj port);
1608
SCM_EXPORT scm_ichar_t scm_port_get_char(ScmObj port);
1609
SCM_EXPORT scm_ichar_t scm_port_peek_char(ScmObj port);
1610
SCM_EXPORT scm_bool scm_port_char_readyp(ScmObj port);
1611
SCM_EXPORT void scm_port_puts(ScmObj port, const char *str);
1612
SCM_EXPORT void scm_port_put_char(ScmObj port, scm_ichar_t ch);
1613
SCM_EXPORT void scm_port_newline(ScmObj port);
1614
SCM_EXPORT void scm_port_flush(ScmObj port);
1615
SCM_EXPORT ScmObj scm_p_input_portp(ScmObj obj);
1616
SCM_EXPORT ScmObj scm_p_output_portp(ScmObj obj);
1617
SCM_EXPORT ScmObj scm_p_current_input_port(void);
1618
SCM_EXPORT ScmObj scm_p_current_output_port(void);
1619
SCM_EXPORT ScmObj scm_p_current_error_port(void);
1620
SCM_EXPORT ScmObj scm_p_set_current_input_portx(ScmObj newport);
1621
SCM_EXPORT ScmObj scm_p_set_current_output_portx(ScmObj newport);
1622
SCM_EXPORT ScmObj scm_p_set_current_error_portx(ScmObj newport);
1623
SCM_EXPORT ScmObj scm_p_open_input_file(ScmObj filepath);
1624
SCM_EXPORT ScmObj scm_p_open_output_file(ScmObj filepath);
1625
SCM_EXPORT ScmObj scm_p_close_input_port(ScmObj port);
1626
SCM_EXPORT ScmObj scm_p_close_output_port(ScmObj port);
1628
SCM_EXPORT ScmObj scm_p_read_char(ScmObj args);
1629
SCM_EXPORT ScmObj scm_p_peek_char(ScmObj args);
1630
SCM_EXPORT ScmObj scm_p_char_readyp(ScmObj args);
1632
SCM_EXPORT ScmObj scm_p_eof_objectp(ScmObj obj);
1633
SCM_EXPORT ScmObj scm_p_newline(ScmObj args);
1635
SCM_EXPORT ScmObj scm_p_write_char(ScmObj obj, ScmObj args);
1637
#endif /* SCM_USE_PORT */
1641
SCM_EXPORT ScmObj scm_read(ScmObj port);
1642
SCM_EXPORT ScmObj scm_p_read(ScmObj args);
1643
#endif /* SCM_USE_READER */
1647
SCM_EXPORT void scm_write(ScmObj port, ScmObj obj);
1648
SCM_EXPORT void scm_display(ScmObj port, ScmObj obj);
1650
SCM_EXPORT void scm_write_ss(ScmObj port, ScmObj obj);
1651
#endif /* SCM_USE_SRFI38 */
1652
SCM_EXPORT ScmObj scm_p_write(ScmObj obj, ScmObj args);
1653
SCM_EXPORT ScmObj scm_p_display(ScmObj obj, ScmObj args);
1654
#endif /* SCM_USE_WRITER */
1658
SCM_EXPORT void scm_set_lib_path(const char *path);
1659
SCM_EXPORT void scm_set_system_load_path(const char *path);
1660
SCM_EXPORT void scm_load(const char *filename);
1661
SCM_EXPORT ScmObj scm_p_load_path(void);
1662
SCM_EXPORT ScmObj scm_p_system_load_path(void);
1663
SCM_EXPORT ScmObj scm_p_load(ScmObj filename);
1664
#endif /* SCM_USE_LOAD */
1668
SCM_EXPORT ScmObj scm_lformat(ScmObj port, enum ScmFormatCapability fcap,
1669
const char *fmt, ScmObj scm_args);
1670
SCM_EXPORT ScmObj scm_vformat(ScmObj port, enum ScmFormatCapability fcap,
1671
const char *fmt, va_list c_args);
1672
SCM_EXPORT ScmObj scm_format(ScmObj port, enum ScmFormatCapability fcap,
1673
const char *fmt, ...);
1674
#endif /* SCM_USE_FORMAT */
1676
/*===========================================================================
1677
SigScheme: Optional Funtions
1678
===========================================================================*/
1679
/* legacy-macro.c */
1680
#if SCM_USE_LEGACY_MACRO
1681
SCM_EXPORT ScmObj scm_s_define_macro(ScmObj identifier, ScmObj rest,
1682
ScmEvalState *eval_state);
1683
#endif /* SCM_USE_LEGACY_MACRO */
1685
/* module-sscm-ext.c */
1686
#if SCM_USE_SSCM_EXTENSIONS
1687
SCM_EXPORT void scm_require(const char *filename);
1688
SCM_EXPORT ScmObj scm_p_symbol_boundp(ScmObj sym, ScmObj rest);
1689
SCM_EXPORT ScmObj scm_p_sscm_version(void);
1690
SCM_EXPORT ScmObj scm_p_current_environment(ScmEvalState *eval_state);
1691
SCM_EXPORT ScmObj scm_p_current_char_codec(void);
1692
SCM_EXPORT ScmObj scm_p_set_current_char_codecx(ScmObj encoding);
1693
SCM_EXPORT ScmObj scm_p_prealloc_heaps(ScmObj n);
1694
SCM_EXPORT ScmObj scm_p_pair_mutablep(ScmObj kons);
1695
SCM_EXPORT ScmObj scm_p_fixnum_width(void);
1696
SCM_EXPORT ScmObj scm_p_least_fixnum(void);
1697
SCM_EXPORT ScmObj scm_p_greatest_fixnum(void);
1698
SCM_EXPORT ScmObj scm_p_require(ScmObj filename);
1699
SCM_EXPORT ScmObj scm_p_provide(ScmObj feature);
1700
SCM_EXPORT ScmObj scm_p_providedp(ScmObj feature);
1701
SCM_EXPORT ScmObj scm_p_lengthstar(ScmObj lst);
1702
SCM_EXPORT ScmObj scm_p_exit(ScmObj args) SCM_NORETURN;
1703
SCM_EXPORT ScmObj scm_s_let_optionalsstar(ScmObj args,
1704
ScmObj bindings, ScmObj body,
1705
ScmEvalState *eval_state);
1706
#endif /* SCM_USE_SSCM_EXTENSIONS */
1710
SCM_EXPORT ScmObj scm_p_symbol_value(ScmObj var);
1711
SCM_EXPORT ScmObj scm_p_set_symbol_valuex(ScmObj var, ScmObj val);
1712
SCM_EXPORT ScmObj scm_p_siod_equal(ScmObj obj1, ScmObj obj2);
1713
SCM_EXPORT ScmObj scm_p_closure_code(ScmObj closure);
1714
SCM_EXPORT ScmObj scm_p_verbose(ScmObj args);
1715
SCM_EXPORT ScmObj scm_p_eof_val(void);
1716
SCM_EXPORT ScmObj scm_s_undefine(ScmObj var, ScmObj env);
1717
SCM_EXPORT long scm_get_verbose_level(void);
1718
SCM_EXPORT void scm_set_verbose_level(long level);
1719
#endif /* SCM_COMPAT_SIOD */
1721
/* module-srfi1.c */
1723
SCM_EXPORT ScmObj scm_p_srfi1_circular_listp(ScmObj obj);
1724
SCM_EXPORT ScmObj scm_p_srfi1_dotted_listp(ScmObj obj);
1725
SCM_EXPORT ScmObj scm_p_srfi1_last_pair(ScmObj lst);
1726
SCM_EXPORT ScmObj scm_p_srfi1_lengthplus(ScmObj lst);
1727
SCM_EXPORT ScmObj scm_p_srfi1_map_in_order(ScmObj proc, ScmObj args);
1728
SCM_EXPORT ScmObj scm_p_srfi1_find_tail(ScmObj pred, ScmObj lst);
1729
#endif /* SCM_USE_SRFI1 */
1731
/* module-srfi2.c */
1733
SCM_EXPORT ScmObj scm_s_srfi2_and_letstar(ScmObj claws, ScmObj body,
1734
ScmEvalState *eval_state);
1737
/* module-srfi6.c */
1739
SCM_EXPORT ScmObj scm_p_srfi6_open_input_string(ScmObj str);
1740
SCM_EXPORT ScmObj scm_p_srfi6_open_output_string(void);
1741
SCM_EXPORT ScmObj scm_p_srfi6_get_output_string(ScmObj port);
1744
/* module-srfi8.c */
1746
SCM_EXPORT ScmObj scm_s_srfi8_receive(ScmObj formals, ScmObj expr, ScmObj body,
1747
ScmEvalState *eval_state);
1750
/* module-srfi9.c */
1752
SCM_EXPORT ScmObj scm_s_srfi9_define_record_type(ScmObj type_name,
1756
ScmEvalState *eval_state);
1759
/* module-srfi23.c */
1761
SCM_EXPORT ScmObj scm_p_srfi23_error(ScmObj reason, ScmObj args);
1764
/* module-srfi28.c */
1766
SCM_EXPORT ScmObj scm_p_srfi28_format(ScmObj fmt, ScmObj objs);
1769
/* module-srfi34.c */
1771
SCM_EXPORT ScmObj scm_p_srfi34_with_exception_handler(ScmObj handler,
1773
SCM_EXPORT ScmObj scm_s_srfi34_guard(ScmObj cond_catch, ScmObj body,
1774
ScmEvalState *eval_state);
1775
SCM_EXPORT ScmObj scm_p_srfi34_raise(ScmObj obj);
1778
/* module-srfi38.c */
1780
SCM_EXPORT ScmObj scm_p_srfi38_write_with_shared_structure(ScmObj obj,
1784
/* module-srfi48.c */
1786
SCM_EXPORT ScmObj scm_p_srfi48_format(ScmObj fmt_or_port, ScmObj rest);
1787
SCM_EXPORT ScmObj scm_p_formatplus(ScmObj fmt_or_port, ScmObj rest);
1790
/* module-srfi55.c */
1792
SCM_EXPORT ScmObj scm_s_srfi55_require_extension(ScmObj clauses, ScmObj env);
1795
/* module-srfi60.c */
1797
SCM_EXPORT ScmObj scm_p_srfi60_logand(ScmObj left, ScmObj right,
1798
enum ScmReductionState *state);
1799
SCM_EXPORT ScmObj scm_p_srfi60_logior(ScmObj left, ScmObj right,
1800
enum ScmReductionState *state);
1801
SCM_EXPORT ScmObj scm_p_srfi60_logxor(ScmObj left, ScmObj right,
1802
enum ScmReductionState *state);
1803
SCM_EXPORT ScmObj scm_p_srfi60_lognot(ScmObj n);
1804
SCM_EXPORT ScmObj scm_p_srfi60_bitwise_if(ScmObj mask, ScmObj n0, ScmObj n1);
1805
SCM_EXPORT ScmObj scm_p_srfi60_logtest(ScmObj j, ScmObj k);
1812
#endif /* __SIGSCHEME_H */
added
removed
sigscheme/src/sigscheme.h
