mirror of
https://git.savannah.gnu.org/git/guile.git
synced 2025-06-17 17:20:29 +02:00
Prefixed each each exported symbol with SCM_API.
This commit is contained in:
parent
1dcb9876f5
commit
33b001fd89
83 changed files with 1769 additions and 1744 deletions
|
@ -57,37 +57,37 @@
|
|||
|
||||
|
||||
|
||||
extern char *const scm_charnames[];
|
||||
extern int scm_n_charnames;
|
||||
extern const char scm_charnums[];
|
||||
SCM_API char *const scm_charnames[];
|
||||
SCM_API int scm_n_charnames;
|
||||
SCM_API const char scm_charnums[];
|
||||
|
||||
|
||||
|
||||
extern SCM scm_char_p (SCM x);
|
||||
extern SCM scm_char_eq_p (SCM x, SCM y);
|
||||
extern SCM scm_char_less_p (SCM x, SCM y);
|
||||
extern SCM scm_char_leq_p (SCM x, SCM y);
|
||||
extern SCM scm_char_gr_p (SCM x, SCM y);
|
||||
extern SCM scm_char_geq_p (SCM x, SCM y);
|
||||
extern SCM scm_char_ci_eq_p (SCM x, SCM y);
|
||||
extern SCM scm_char_ci_less_p (SCM x, SCM y);
|
||||
extern SCM scm_char_ci_leq_p (SCM x, SCM y);
|
||||
extern SCM scm_char_ci_gr_p (SCM x, SCM y);
|
||||
extern SCM scm_char_ci_geq_p (SCM x, SCM y);
|
||||
extern SCM scm_char_alphabetic_p (SCM chr);
|
||||
extern SCM scm_char_numeric_p (SCM chr);
|
||||
extern SCM scm_char_whitespace_p (SCM chr);
|
||||
extern SCM scm_char_upper_case_p (SCM chr);
|
||||
extern SCM scm_char_lower_case_p (SCM chr);
|
||||
extern SCM scm_char_is_both_p (SCM chr);
|
||||
extern SCM scm_char_to_integer (SCM chr);
|
||||
extern SCM scm_integer_to_char (SCM n);
|
||||
extern SCM scm_char_upcase (SCM chr);
|
||||
extern SCM scm_char_downcase (SCM chr);
|
||||
extern void scm_tables_prehistory (void);
|
||||
extern int scm_upcase (unsigned int c);
|
||||
extern int scm_downcase (unsigned int c);
|
||||
extern void scm_init_chars (void);
|
||||
SCM_API SCM scm_char_p (SCM x);
|
||||
SCM_API SCM scm_char_eq_p (SCM x, SCM y);
|
||||
SCM_API SCM scm_char_less_p (SCM x, SCM y);
|
||||
SCM_API SCM scm_char_leq_p (SCM x, SCM y);
|
||||
SCM_API SCM scm_char_gr_p (SCM x, SCM y);
|
||||
SCM_API SCM scm_char_geq_p (SCM x, SCM y);
|
||||
SCM_API SCM scm_char_ci_eq_p (SCM x, SCM y);
|
||||
SCM_API SCM scm_char_ci_less_p (SCM x, SCM y);
|
||||
SCM_API SCM scm_char_ci_leq_p (SCM x, SCM y);
|
||||
SCM_API SCM scm_char_ci_gr_p (SCM x, SCM y);
|
||||
SCM_API SCM scm_char_ci_geq_p (SCM x, SCM y);
|
||||
SCM_API SCM scm_char_alphabetic_p (SCM chr);
|
||||
SCM_API SCM scm_char_numeric_p (SCM chr);
|
||||
SCM_API SCM scm_char_whitespace_p (SCM chr);
|
||||
SCM_API SCM scm_char_upper_case_p (SCM chr);
|
||||
SCM_API SCM scm_char_lower_case_p (SCM chr);
|
||||
SCM_API SCM scm_char_is_both_p (SCM chr);
|
||||
SCM_API SCM scm_char_to_integer (SCM chr);
|
||||
SCM_API SCM scm_integer_to_char (SCM n);
|
||||
SCM_API SCM scm_char_upcase (SCM chr);
|
||||
SCM_API SCM scm_char_downcase (SCM chr);
|
||||
SCM_API void scm_tables_prehistory (void);
|
||||
SCM_API int scm_upcase (unsigned int c);
|
||||
SCM_API int scm_downcase (unsigned int c);
|
||||
SCM_API void scm_init_chars (void);
|
||||
|
||||
#endif /* SCM_CHARS_H */
|
||||
|
||||
|
|
|
@ -143,12 +143,12 @@ typedef int coop_mattr;
|
|||
|
||||
typedef coop_m scm_t_mutex;
|
||||
|
||||
extern int coop_mutex_init (coop_m*);
|
||||
extern int coop_new_mutex_init (coop_m*, coop_mattr*);
|
||||
extern int coop_mutex_lock (coop_m*);
|
||||
extern int coop_mutex_trylock (coop_m*);
|
||||
extern int coop_mutex_unlock (coop_m*);
|
||||
extern int coop_mutex_destroy (coop_m*);
|
||||
SCM_API int coop_mutex_init (coop_m*);
|
||||
SCM_API int coop_new_mutex_init (coop_m*, coop_mattr*);
|
||||
SCM_API int coop_mutex_lock (coop_m*);
|
||||
SCM_API int coop_mutex_trylock (coop_m*);
|
||||
SCM_API int coop_mutex_unlock (coop_m*);
|
||||
SCM_API int coop_mutex_destroy (coop_m*);
|
||||
#define scm_mutex_init coop_mutex_init
|
||||
#define scm_mutex_lock coop_mutex_lock
|
||||
#define scm_mutex_trylock coop_mutex_lock
|
||||
|
@ -176,14 +176,14 @@ struct timespec
|
|||
};
|
||||
#endif
|
||||
|
||||
extern int coop_condition_variable_init (coop_c*);
|
||||
extern int coop_new_condition_variable_init (coop_c*, coop_cattr*);
|
||||
extern int coop_condition_variable_wait_mutex (coop_c*, coop_m*);
|
||||
extern int coop_condition_variable_timed_wait_mutex (coop_c*,
|
||||
coop_m*,
|
||||
const struct timespec *abstime);
|
||||
extern int coop_condition_variable_signal (coop_c*);
|
||||
extern int coop_condition_variable_destroy (coop_c*);
|
||||
SCM_API int coop_condition_variable_init (coop_c*);
|
||||
SCM_API int coop_new_condition_variable_init (coop_c*, coop_cattr*);
|
||||
SCM_API int coop_condition_variable_wait_mutex (coop_c*, coop_m*);
|
||||
SCM_API int coop_condition_variable_timed_wait_mutex (coop_c*,
|
||||
coop_m*,
|
||||
const struct timespec *abstime);
|
||||
SCM_API int coop_condition_variable_signal (coop_c*);
|
||||
SCM_API int coop_condition_variable_destroy (coop_c*);
|
||||
#define scm_cond_init coop_new_condition_variable_init
|
||||
#define scm_cond_wait coop_condition_variable_wait_mutex
|
||||
#define scm_cond_timedwait coop_condition_variable_timed_wait_mutex
|
||||
|
@ -195,22 +195,22 @@ typedef int coop_k;
|
|||
|
||||
typedef coop_k scm_t_key;
|
||||
|
||||
extern int coop_key_create (coop_k *keyp, void (*destruktor) (void *value));
|
||||
extern int coop_setspecific (coop_k key, const void *value);
|
||||
extern void *coop_getspecific (coop_k key);
|
||||
extern int coop_key_delete (coop_k);
|
||||
SCM_API int coop_key_create (coop_k *keyp, void (*destruktor) (void *value));
|
||||
SCM_API int coop_setspecific (coop_k key, const void *value);
|
||||
SCM_API void *coop_getspecific (coop_k key);
|
||||
SCM_API int coop_key_delete (coop_k);
|
||||
#define scm_key_create coop_key_create
|
||||
#define scm_setspecific coop_setspecific
|
||||
#define scm_getspecific coop_getspecific
|
||||
#define scm_key_delete coop_key_delete
|
||||
|
||||
extern coop_t *coop_global_curr; /* Currently-executing thread. */
|
||||
SCM_API coop_t *coop_global_curr; /* Currently-executing thread. */
|
||||
|
||||
extern void coop_join (coop_t *t);
|
||||
extern void coop_yield (void);
|
||||
SCM_API void coop_join (coop_t *t);
|
||||
SCM_API void coop_yield (void);
|
||||
|
||||
extern size_t scm_switch_counter;
|
||||
extern size_t scm_thread_count;
|
||||
SCM_API size_t scm_switch_counter;
|
||||
SCM_API size_t scm_thread_count;
|
||||
|
||||
|
||||
/* Some iselect functions. */
|
||||
|
@ -222,11 +222,11 @@ extern size_t scm_thread_count;
|
|||
(and failing) attempt at modularity here, and I don't have time to
|
||||
rethink this at the moment. This code awaits a Hero. --JimB */
|
||||
#ifdef GUILE_ISELECT
|
||||
void coop_timeout_qinsert (coop_q_t *, coop_t *);
|
||||
SCM_API void coop_timeout_qinsert (coop_q_t *, coop_t *);
|
||||
#endif
|
||||
extern coop_t *coop_next_runnable_thread (void);
|
||||
extern coop_t *coop_wait_for_runnable_thread_now (struct timeval *);
|
||||
extern coop_t *coop_wait_for_runnable_thread (void);
|
||||
SCM_API coop_t *coop_next_runnable_thread (void);
|
||||
SCM_API coop_t *coop_wait_for_runnable_thread_now (struct timeval *);
|
||||
SCM_API coop_t *coop_wait_for_runnable_thread (void);
|
||||
|
||||
|
||||
|
||||
|
|
|
@ -81,46 +81,46 @@
|
|||
typedef void (coop_userf_t)(void *p0);
|
||||
|
||||
/* Call this before any other primitives. */
|
||||
extern void coop_init (void);
|
||||
SCM_API void coop_init (void);
|
||||
|
||||
/* When one or more threads are created by the main thread,
|
||||
the system goes multithread when this is called. It is done
|
||||
(no more runable threads) when this returns. */
|
||||
|
||||
extern void coop_start (void);
|
||||
SCM_API void coop_start (void);
|
||||
|
||||
/* Create a thread and make it runable. When the thread starts
|
||||
running it will call `f' with arguments `p0' and `p1'. */
|
||||
|
||||
extern coop_t *coop_create (coop_userf_t *f, void *p0);
|
||||
SCM_API coop_t *coop_create (coop_userf_t *f, void *p0);
|
||||
|
||||
/* The current thread stops running but stays runable.
|
||||
It is an error to call `coop_yield' before `coop_start'
|
||||
is called or after `coop_start' returns. */
|
||||
|
||||
extern void coop_yield (void);
|
||||
SCM_API void coop_yield (void);
|
||||
|
||||
/* Like `coop_yield' but the thread is discarded. Any intermediate
|
||||
state is lost. The thread can also terminate by simply
|
||||
returning. */
|
||||
|
||||
extern void coop_abort (void);
|
||||
SCM_API void coop_abort (void);
|
||||
|
||||
/* The following are needed in iselect.c */
|
||||
|
||||
extern coop_t *coop_qget (coop_q_t *);
|
||||
extern void coop_qput (coop_q_t *, coop_t *);
|
||||
extern void *coop_sleephelp (qt_t *, void *, void *);
|
||||
SCM_API coop_t *coop_qget (coop_q_t *);
|
||||
SCM_API void coop_qput (coop_q_t *, coop_t *);
|
||||
SCM_API void *coop_sleephelp (qt_t *, void *, void *);
|
||||
|
||||
#ifdef GUILE_ISELECT
|
||||
extern coop_t *coop_wait_for_runnable_thread ();
|
||||
SCM_API coop_t *coop_wait_for_runnable_thread ();
|
||||
#endif
|
||||
|
||||
extern coop_q_t coop_global_runq; /* A queue of runable threads. */
|
||||
extern coop_q_t coop_global_sleepq;
|
||||
extern coop_q_t coop_tmp_queue;
|
||||
extern coop_q_t coop_global_allq; /* A queue of all threads. */
|
||||
extern coop_t *coop_global_curr; /* Currently-executing thread. */
|
||||
SCM_API coop_q_t coop_global_runq; /* A queue of runable threads. */
|
||||
SCM_API coop_q_t coop_global_sleepq;
|
||||
SCM_API coop_q_t coop_tmp_queue;
|
||||
SCM_API coop_q_t coop_global_allq; /* A queue of all threads. */
|
||||
SCM_API coop_t *coop_global_curr; /* Currently-executing thread. */
|
||||
|
||||
#endif /* SCM_COOP_THREADS_H */
|
||||
|
||||
|
|
|
@ -50,14 +50,14 @@
|
|||
|
||||
|
||||
|
||||
extern void scm_malloc_register (void *obj, const char *what);
|
||||
extern void scm_malloc_unregister (void *obj);
|
||||
extern void scm_malloc_reregister (void *obj, void *new, const char *what);
|
||||
SCM_API void scm_malloc_register (void *obj, const char *what);
|
||||
SCM_API void scm_malloc_unregister (void *obj);
|
||||
SCM_API void scm_malloc_reregister (void *obj, void *new, const char *what);
|
||||
|
||||
extern SCM scm_malloc_stats (void);
|
||||
SCM_API SCM scm_malloc_stats (void);
|
||||
|
||||
extern void scm_debug_malloc_prehistory (void);
|
||||
extern void scm_init_debug_malloc (void);
|
||||
SCM_API void scm_debug_malloc_prehistory (void);
|
||||
SCM_API void scm_init_debug_malloc (void);
|
||||
|
||||
#endif /* SCM_DEBUG_MALLOC_H */
|
||||
|
||||
|
|
|
@ -68,7 +68,7 @@
|
|||
/* scm_debug_opts is defined in eval.c.
|
||||
*/
|
||||
|
||||
extern scm_t_option scm_debug_opts[];
|
||||
SCM_API scm_t_option scm_debug_opts[];
|
||||
|
||||
#define SCM_CHEAPTRAPS_P scm_debug_opts[0].val
|
||||
#define SCM_BREAKPOINTS_P scm_debug_opts[1].val
|
||||
|
@ -86,10 +86,12 @@ extern scm_t_option scm_debug_opts[];
|
|||
#define SCM_SHOW_FILE_NAME scm_debug_opts[13].val
|
||||
#define SCM_N_DEBUG_OPTIONS 14
|
||||
|
||||
extern SCM (*scm_ceval_ptr) (SCM exp, SCM env);
|
||||
SCM_API SCM (*scm_ceval_ptr) (SCM exp, SCM env);
|
||||
|
||||
extern int scm_debug_mode;
|
||||
extern int scm_check_entry_p, scm_check_apply_p, scm_check_exit_p;
|
||||
SCM_API int scm_debug_mode;
|
||||
SCM_API int scm_check_entry_p;
|
||||
SCM_API int scm_check_apply_p;
|
||||
SCM_API int scm_check_exit_p;
|
||||
|
||||
#define CHECK_ENTRY scm_check_entry_p
|
||||
#define CHECK_APPLY scm_check_apply_p
|
||||
|
@ -117,7 +119,7 @@ typedef union scm_t_debug_info
|
|||
SCM id;
|
||||
} scm_t_debug_info;
|
||||
|
||||
extern long scm_debug_eframe_size;
|
||||
SCM_API long scm_debug_eframe_size;
|
||||
|
||||
typedef struct scm_t_debug_frame
|
||||
{
|
||||
|
@ -128,7 +130,7 @@ typedef struct scm_t_debug_frame
|
|||
} scm_t_debug_frame;
|
||||
|
||||
#ifndef USE_THREADS
|
||||
extern scm_t_debug_frame *scm_last_debug_frame;
|
||||
SCM_API scm_t_debug_frame *scm_last_debug_frame;
|
||||
#endif
|
||||
|
||||
#define SCM_EVALFRAME (0L << 11)
|
||||
|
@ -165,7 +167,7 @@ extern scm_t_debug_frame *scm_last_debug_frame;
|
|||
/* {Debug Objects}
|
||||
*/
|
||||
|
||||
extern scm_t_bits scm_tc16_debugobj;
|
||||
SCM_API scm_t_bits scm_tc16_debugobj;
|
||||
|
||||
#define SCM_DEBUGOBJP(x) \
|
||||
SCM_TYP16_PREDICATE (scm_tc16_debugobj, x)
|
||||
|
@ -176,7 +178,7 @@ extern scm_t_bits scm_tc16_debugobj;
|
|||
/* {Memoized Source}
|
||||
*/
|
||||
|
||||
extern scm_t_bits scm_tc16_memoized;
|
||||
SCM_API scm_t_bits scm_tc16_memoized;
|
||||
|
||||
#define SCM_MEMOIZEDP(x) SCM_TYP16_PREDICATE (scm_tc16_memoized, x)
|
||||
#define SCM_MEMOIZED_EXP(x) SCM_CAR (SCM_CELL_OBJECT_1 (x))
|
||||
|
@ -184,32 +186,32 @@ extern scm_t_bits scm_tc16_memoized;
|
|||
|
||||
|
||||
|
||||
extern int scm_ready_p (void);
|
||||
extern void debug_print (SCM obj);
|
||||
extern SCM scm_debug_object_p (SCM obj);
|
||||
extern SCM scm_local_eval (SCM exp, SCM env);
|
||||
extern SCM scm_reverse_lookup (SCM env, SCM data);
|
||||
extern SCM scm_start_stack (SCM id, SCM exp, SCM env);
|
||||
extern SCM scm_procedure_environment (SCM proc);
|
||||
extern SCM scm_procedure_source (SCM proc);
|
||||
extern SCM scm_procedure_name (SCM proc);
|
||||
extern SCM scm_memoized_environment (SCM m);
|
||||
extern SCM scm_make_memoized (SCM exp, SCM env);
|
||||
extern SCM scm_memoized_p (SCM obj);
|
||||
extern SCM scm_with_traps (SCM thunk);
|
||||
extern SCM scm_evaluator_traps (SCM setting);
|
||||
extern SCM scm_debug_options (SCM setting);
|
||||
extern SCM scm_unmemoize (SCM memoized);
|
||||
extern SCM scm_make_debugobj (scm_t_debug_frame *debug);
|
||||
extern void scm_init_debug (void);
|
||||
SCM_API int scm_ready_p (void);
|
||||
SCM_API void debug_print (SCM obj);
|
||||
SCM_API SCM scm_debug_object_p (SCM obj);
|
||||
SCM_API SCM scm_local_eval (SCM exp, SCM env);
|
||||
SCM_API SCM scm_reverse_lookup (SCM env, SCM data);
|
||||
SCM_API SCM scm_start_stack (SCM id, SCM exp, SCM env);
|
||||
SCM_API SCM scm_procedure_environment (SCM proc);
|
||||
SCM_API SCM scm_procedure_source (SCM proc);
|
||||
SCM_API SCM scm_procedure_name (SCM proc);
|
||||
SCM_API SCM scm_memoized_environment (SCM m);
|
||||
SCM_API SCM scm_make_memoized (SCM exp, SCM env);
|
||||
SCM_API SCM scm_memoized_p (SCM obj);
|
||||
SCM_API SCM scm_with_traps (SCM thunk);
|
||||
SCM_API SCM scm_evaluator_traps (SCM setting);
|
||||
SCM_API SCM scm_debug_options (SCM setting);
|
||||
SCM_API SCM scm_unmemoize (SCM memoized);
|
||||
SCM_API SCM scm_make_debugobj (scm_t_debug_frame *debug);
|
||||
SCM_API void scm_init_debug (void);
|
||||
|
||||
#ifdef GUILE_DEBUG
|
||||
extern SCM scm_make_iloc (SCM frame, SCM binding, SCM cdrp);
|
||||
extern SCM scm_iloc_p (SCM obj);
|
||||
extern SCM scm_memcons (SCM car, SCM cdr, SCM env);
|
||||
extern SCM scm_mem_to_proc (SCM obj);
|
||||
extern SCM scm_proc_to_mem (SCM obj);
|
||||
extern SCM scm_debug_hang (SCM obj);
|
||||
SCM_API SCM scm_make_iloc (SCM frame, SCM binding, SCM cdrp);
|
||||
SCM_API SCM scm_iloc_p (SCM obj);
|
||||
SCM_API SCM scm_memcons (SCM car, SCM cdr, SCM env);
|
||||
SCM_API SCM scm_mem_to_proc (SCM obj);
|
||||
SCM_API SCM scm_proc_to_mem (SCM obj);
|
||||
SCM_API SCM scm_debug_hang (SCM obj);
|
||||
#endif /*GUILE_DEBUG*/
|
||||
|
||||
#endif /* SCM_DEBUG_H */
|
||||
|
|
|
@ -52,13 +52,13 @@
|
|||
|
||||
#if (SCM_ENABLE_DEPRECATED == 1)
|
||||
|
||||
void scm_c_issue_deprecation_warning (const char *msg);
|
||||
SCM scm_issue_deprecation_warning (SCM msgs);
|
||||
SCM_API void scm_c_issue_deprecation_warning (const char *msg);
|
||||
SCM_API SCM scm_issue_deprecation_warning (SCM msgs);
|
||||
|
||||
#endif
|
||||
|
||||
SCM scm_include_deprecated_features (void);
|
||||
void scm_init_deprecation (void);
|
||||
SCM_API SCM scm_include_deprecated_features (void);
|
||||
SCM_API void scm_init_deprecation (void);
|
||||
|
||||
#endif /* SCM_DEPRECATION_H */
|
||||
|
||||
|
|
|
@ -50,14 +50,14 @@
|
|||
|
||||
|
||||
|
||||
SCM scm_dynamic_link (SCM fname);
|
||||
SCM scm_dynamic_unlink (SCM dobj);
|
||||
SCM scm_dynamic_object_p (SCM obj);
|
||||
SCM scm_dynamic_func (SCM symb, SCM dobj);
|
||||
SCM scm_dynamic_call (SCM symb, SCM dobj);
|
||||
SCM scm_dynamic_args_call (SCM symb, SCM dobj, SCM args);
|
||||
SCM_API SCM scm_dynamic_link (SCM fname);
|
||||
SCM_API SCM scm_dynamic_unlink (SCM dobj);
|
||||
SCM_API SCM scm_dynamic_object_p (SCM obj);
|
||||
SCM_API SCM scm_dynamic_func (SCM symb, SCM dobj);
|
||||
SCM_API SCM scm_dynamic_call (SCM symb, SCM dobj);
|
||||
SCM_API SCM scm_dynamic_args_call (SCM symb, SCM dobj, SCM args);
|
||||
|
||||
void scm_init_dynamic_linking (void);
|
||||
SCM_API void scm_init_dynamic_linking (void);
|
||||
|
||||
#endif /* SCM_DYNL_H */
|
||||
|
||||
|
|
|
@ -53,19 +53,19 @@
|
|||
typedef void (*scm_t_guard) (void *);
|
||||
typedef SCM (*scm_t_inner) (void *);
|
||||
|
||||
extern SCM scm_dynamic_wind (SCM thunk1, SCM thunk2, SCM thunk3);
|
||||
extern SCM scm_internal_dynamic_wind (scm_t_guard before,
|
||||
scm_t_inner inner,
|
||||
scm_t_guard after,
|
||||
void *inner_data,
|
||||
void *guard_data);
|
||||
extern void scm_dowinds (SCM to, long delta);
|
||||
extern void scm_init_dynwind (void);
|
||||
SCM_API SCM scm_dynamic_wind (SCM thunk1, SCM thunk2, SCM thunk3);
|
||||
SCM_API SCM scm_internal_dynamic_wind (scm_t_guard before,
|
||||
scm_t_inner inner,
|
||||
scm_t_guard after,
|
||||
void *inner_data,
|
||||
void *guard_data);
|
||||
SCM_API void scm_dowinds (SCM to, long delta);
|
||||
SCM_API void scm_init_dynwind (void);
|
||||
|
||||
extern void scm_swap_bindings (SCM vars, SCM vals);
|
||||
SCM_API void scm_swap_bindings (SCM vars, SCM vals);
|
||||
|
||||
#ifdef GUILE_DEBUG
|
||||
extern SCM scm_wind_chain (void);
|
||||
SCM_API SCM scm_wind_chain (void);
|
||||
#endif /*GUILE_DEBUG*/
|
||||
|
||||
#endif /* SCM_DYNWIND_H */
|
||||
|
|
|
@ -87,7 +87,7 @@ struct scm_environment_funcs {
|
|||
#define SCM_ENVIRONMENT_LOCATION_IMMUTABLE SCM_MAKINUM (1)
|
||||
#define SCM_ENVIRONMENT_LOCATION_NO_CELL SCM_BOOL_F
|
||||
|
||||
extern scm_t_bits scm_tc16_environment;
|
||||
SCM_API scm_t_bits scm_tc16_environment;
|
||||
|
||||
#define SCM_ENVIRONMENT_P(x) \
|
||||
(!SCM_IMP (x) && SCM_CELL_TYPE (x) == scm_tc16_environment)
|
||||
|
@ -112,7 +112,7 @@ extern scm_t_bits scm_tc16_environment;
|
|||
#define SCM_ENVIRONMENT_UNOBSERVE(env, token) \
|
||||
((*(SCM_ENVIRONMENT_FUNCS (env)->unobserve)) (env, token))
|
||||
|
||||
extern scm_t_bits scm_tc16_observer;
|
||||
SCM_API scm_t_bits scm_tc16_observer;
|
||||
|
||||
#define SCM_OBSERVER_P(x) \
|
||||
(!SCM_IMP (x) && (SCM_CELL_TYPE (x) == scm_tc16_observer))
|
||||
|
@ -123,85 +123,85 @@ extern scm_t_bits scm_tc16_observer;
|
|||
#define SCM_OBSERVER_PROC(x) \
|
||||
((scm_environment_observer) SCM_CELL_WORD_3 (x))
|
||||
|
||||
extern SCM scm_system_environment;
|
||||
SCM_API SCM scm_system_environment;
|
||||
|
||||
extern void scm_error_environment_unbound (const char *, SCM, SCM) SCM_NORETURN;
|
||||
extern void scm_error_environment_immutable_binding (const char *, SCM, SCM) SCM_NORETURN;
|
||||
extern void scm_error_environment_immutable_location (const char *, SCM, SCM) SCM_NORETURN;
|
||||
SCM_API void scm_error_environment_unbound (const char *, SCM, SCM) SCM_NORETURN;
|
||||
SCM_API void scm_error_environment_immutable_binding (const char *, SCM, SCM) SCM_NORETURN;
|
||||
SCM_API void scm_error_environment_immutable_location (const char *, SCM, SCM) SCM_NORETURN;
|
||||
|
||||
extern SCM scm_make_environment (void *type);
|
||||
extern SCM scm_environment_p (SCM env);
|
||||
extern SCM scm_environment_bound_p (SCM env, SCM sym);
|
||||
extern SCM scm_environment_ref (SCM env, SCM sym);
|
||||
extern SCM scm_c_environment_ref (SCM env, SCM sym);
|
||||
extern SCM scm_environment_fold (SCM env, SCM proc, SCM init);
|
||||
extern SCM scm_c_environment_fold (SCM env, scm_environment_folder proc, SCM data, SCM init);
|
||||
extern SCM scm_environment_define (SCM env, SCM sym, SCM val);
|
||||
extern SCM scm_environment_undefine (SCM env, SCM sym);
|
||||
extern SCM scm_environment_set_x (SCM env, SCM sym, SCM val);
|
||||
extern SCM scm_environment_cell (SCM env, SCM sym, SCM for_write);
|
||||
extern SCM scm_c_environment_cell (SCM env, SCM sym, int for_write);
|
||||
extern SCM scm_environment_observe (SCM env, SCM proc);
|
||||
extern SCM scm_environment_observe_weak (SCM env, SCM proc);
|
||||
extern SCM scm_c_environment_observe (SCM env, scm_environment_observer proc, SCM data, int weak_p);
|
||||
extern SCM scm_environment_unobserve (SCM token);
|
||||
SCM_API SCM scm_make_environment (void *type);
|
||||
SCM_API SCM scm_environment_p (SCM env);
|
||||
SCM_API SCM scm_environment_bound_p (SCM env, SCM sym);
|
||||
SCM_API SCM scm_environment_ref (SCM env, SCM sym);
|
||||
SCM_API SCM scm_c_environment_ref (SCM env, SCM sym);
|
||||
SCM_API SCM scm_environment_fold (SCM env, SCM proc, SCM init);
|
||||
SCM_API SCM scm_c_environment_fold (SCM env, scm_environment_folder proc, SCM data, SCM init);
|
||||
SCM_API SCM scm_environment_define (SCM env, SCM sym, SCM val);
|
||||
SCM_API SCM scm_environment_undefine (SCM env, SCM sym);
|
||||
SCM_API SCM scm_environment_set_x (SCM env, SCM sym, SCM val);
|
||||
SCM_API SCM scm_environment_cell (SCM env, SCM sym, SCM for_write);
|
||||
SCM_API SCM scm_c_environment_cell (SCM env, SCM sym, int for_write);
|
||||
SCM_API SCM scm_environment_observe (SCM env, SCM proc);
|
||||
SCM_API SCM scm_environment_observe_weak (SCM env, SCM proc);
|
||||
SCM_API SCM scm_c_environment_observe (SCM env, scm_environment_observer proc, SCM data, int weak_p);
|
||||
SCM_API SCM scm_environment_unobserve (SCM token);
|
||||
|
||||
extern void scm_environments_prehistory (void);
|
||||
extern void scm_init_environments (void);
|
||||
SCM_API void scm_environments_prehistory (void);
|
||||
SCM_API void scm_init_environments (void);
|
||||
|
||||
|
||||
|
||||
extern void *scm_type_leaf_environment;
|
||||
SCM_API void *scm_type_leaf_environment;
|
||||
|
||||
#define SCM_LEAF_ENVIRONMENT_P(env) \
|
||||
(SCM_ENVIRONMENT_P (env) \
|
||||
&& SCM_ENVIRONMENT_FUNCS (env) == scm_type_leaf_environment)
|
||||
|
||||
extern SCM scm_make_leaf_environment (void);
|
||||
extern SCM scm_leaf_environment_p (SCM env);
|
||||
SCM_API SCM scm_make_leaf_environment (void);
|
||||
SCM_API SCM scm_leaf_environment_p (SCM env);
|
||||
|
||||
|
||||
|
||||
extern void *scm_type_eval_environment;
|
||||
SCM_API void *scm_type_eval_environment;
|
||||
|
||||
#define SCM_EVAL_ENVIRONMENT_P(env) \
|
||||
(SCM_ENVIRONMENT_P (env) \
|
||||
&& SCM_ENVIRONMENT_FUNCS (env) == scm_type_eval_environment)
|
||||
|
||||
extern SCM scm_make_eval_environment (SCM local, SCM imported);
|
||||
extern SCM scm_eval_environment_p (SCM env);
|
||||
extern SCM scm_eval_environment_local (SCM env);
|
||||
extern SCM scm_eval_environment_set_local_x (SCM env, SCM local);
|
||||
extern SCM scm_eval_environment_imported (SCM env);
|
||||
extern SCM scm_eval_environment_set_imported_x (SCM env, SCM imported);
|
||||
SCM_API SCM scm_make_eval_environment (SCM local, SCM imported);
|
||||
SCM_API SCM scm_eval_environment_p (SCM env);
|
||||
SCM_API SCM scm_eval_environment_local (SCM env);
|
||||
SCM_API SCM scm_eval_environment_set_local_x (SCM env, SCM local);
|
||||
SCM_API SCM scm_eval_environment_imported (SCM env);
|
||||
SCM_API SCM scm_eval_environment_set_imported_x (SCM env, SCM imported);
|
||||
|
||||
|
||||
|
||||
extern void *scm_type_import_environment;
|
||||
SCM_API void *scm_type_import_environment;
|
||||
|
||||
#define SCM_IMPORT_ENVIRONMENT_P(env) \
|
||||
(SCM_ENVIRONMENT_P (env) \
|
||||
&& SCM_ENVIRONMENT_FUNCS (env) == scm_type_import_environment)
|
||||
|
||||
extern SCM scm_make_import_environment (SCM imports, SCM conflict_proc);
|
||||
extern SCM scm_import_environment_p (SCM env);
|
||||
extern SCM scm_import_environment_imports (SCM env);
|
||||
extern SCM scm_import_environment_set_imports_x (SCM env, SCM imports);
|
||||
SCM_API SCM scm_make_import_environment (SCM imports, SCM conflict_proc);
|
||||
SCM_API SCM scm_import_environment_p (SCM env);
|
||||
SCM_API SCM scm_import_environment_imports (SCM env);
|
||||
SCM_API SCM scm_import_environment_set_imports_x (SCM env, SCM imports);
|
||||
|
||||
|
||||
|
||||
extern void *scm_type_export_environment;
|
||||
SCM_API void *scm_type_export_environment;
|
||||
|
||||
#define SCM_EXPORT_ENVIRONMENT_P(env) \
|
||||
(SCM_ENVIRONMENT_P (env) \
|
||||
&& SCM_ENVIRONMENT_FUNCS (env) == scm_type_export_environment)
|
||||
|
||||
extern SCM scm_make_export_environment (SCM private, SCM signature);
|
||||
extern SCM scm_export_environment_p (SCM env);
|
||||
extern SCM scm_export_environment_private (SCM env);
|
||||
extern SCM scm_export_environment_set_private_x (SCM env, SCM private);
|
||||
extern SCM scm_export_environment_signature (SCM env);
|
||||
extern SCM scm_export_environment_set_signature_x (SCM env, SCM signature);
|
||||
SCM_API SCM scm_make_export_environment (SCM private, SCM signature);
|
||||
SCM_API SCM scm_export_environment_p (SCM env);
|
||||
SCM_API SCM scm_export_environment_private (SCM env);
|
||||
SCM_API SCM scm_export_environment_set_private_x (SCM env, SCM private);
|
||||
SCM_API SCM scm_export_environment_signature (SCM env);
|
||||
SCM_API SCM scm_export_environment_set_signature_x (SCM env, SCM signature);
|
||||
|
||||
#endif /* SCM_ENVIRONMENTS_H */
|
||||
|
||||
|
|
|
@ -50,10 +50,10 @@
|
|||
|
||||
|
||||
|
||||
extern SCM scm_eq_p (SCM x, SCM y);
|
||||
extern SCM scm_eqv_p (SCM x, SCM y);
|
||||
extern SCM scm_equal_p (SCM x, SCM y);
|
||||
extern void scm_init_eq (void);
|
||||
SCM_API SCM scm_eq_p (SCM x, SCM y);
|
||||
SCM_API SCM scm_eqv_p (SCM x, SCM y);
|
||||
SCM_API SCM scm_equal_p (SCM x, SCM y);
|
||||
SCM_API void scm_init_eq (void);
|
||||
|
||||
#endif /* SCM_EQ_H */
|
||||
|
||||
|
|
|
@ -49,41 +49,41 @@
|
|||
#include "libguile/__scm.h"
|
||||
|
||||
|
||||
extern int scm_ints_disabled;
|
||||
SCM_API int scm_ints_disabled;
|
||||
|
||||
extern SCM scm_system_error_key;
|
||||
extern SCM scm_num_overflow_key;
|
||||
extern SCM scm_out_of_range_key;
|
||||
extern SCM scm_args_number_key;
|
||||
extern SCM scm_arg_type_key;
|
||||
extern SCM scm_memory_alloc_key;
|
||||
extern SCM scm_misc_error_key;
|
||||
SCM_API SCM scm_system_error_key;
|
||||
SCM_API SCM scm_num_overflow_key;
|
||||
SCM_API SCM scm_out_of_range_key;
|
||||
SCM_API SCM scm_args_number_key;
|
||||
SCM_API SCM scm_arg_type_key;
|
||||
SCM_API SCM scm_memory_alloc_key;
|
||||
SCM_API SCM scm_misc_error_key;
|
||||
|
||||
|
||||
|
||||
extern void scm_error (SCM key, const char *subr, const char *message,
|
||||
SCM args, SCM rest) SCM_NORETURN;
|
||||
extern SCM scm_error_scm (SCM key, SCM subr, SCM message,
|
||||
SCM args, SCM rest) SCM_NORETURN;
|
||||
extern SCM scm_strerror (SCM err);
|
||||
extern void scm_syserror (const char *subr) SCM_NORETURN;
|
||||
extern void scm_syserror_msg (const char *subr, const char *message,
|
||||
SCM args, int eno) SCM_NORETURN;
|
||||
extern void scm_num_overflow (const char *subr) SCM_NORETURN;
|
||||
extern void scm_out_of_range (const char *subr, SCM bad_value)
|
||||
SCM_API void scm_error (SCM key, const char *subr, const char *message,
|
||||
SCM args, SCM rest) SCM_NORETURN;
|
||||
SCM_API SCM scm_error_scm (SCM key, SCM subr, SCM message,
|
||||
SCM args, SCM rest) SCM_NORETURN;
|
||||
SCM_API SCM scm_strerror (SCM err);
|
||||
SCM_API void scm_syserror (const char *subr) SCM_NORETURN;
|
||||
SCM_API void scm_syserror_msg (const char *subr, const char *message,
|
||||
SCM args, int eno) SCM_NORETURN;
|
||||
SCM_API void scm_num_overflow (const char *subr) SCM_NORETURN;
|
||||
SCM_API void scm_out_of_range (const char *subr, SCM bad_value)
|
||||
SCM_NORETURN;
|
||||
extern void scm_out_of_range_pos (const char *subr, SCM bad_value, SCM pos)
|
||||
SCM_API void scm_out_of_range_pos (const char *subr, SCM bad_value, SCM pos)
|
||||
SCM_NORETURN;
|
||||
extern void scm_wrong_num_args (SCM proc) SCM_NORETURN;
|
||||
extern void scm_error_num_args_subr (const char* subr) SCM_NORETURN;
|
||||
extern void scm_wrong_type_arg (const char *subr, int pos,
|
||||
SCM bad_value) SCM_NORETURN;
|
||||
extern void scm_wrong_type_arg_msg (const char *subr, int pos,
|
||||
SCM bad_value, const char *sz) SCM_NORETURN;
|
||||
extern void scm_memory_error (const char *subr) SCM_NORETURN;
|
||||
extern void scm_misc_error (const char *subr, const char *message,
|
||||
SCM args) SCM_NORETURN;
|
||||
extern void scm_init_error (void);
|
||||
SCM_API void scm_wrong_num_args (SCM proc) SCM_NORETURN;
|
||||
SCM_API void scm_error_num_args_subr (const char* subr) SCM_NORETURN;
|
||||
SCM_API void scm_wrong_type_arg (const char *subr, int pos,
|
||||
SCM bad_value) SCM_NORETURN;
|
||||
SCM_API void scm_wrong_type_arg_msg (const char *subr, int pos,
|
||||
SCM bad_value, const char *sz) SCM_NORETURN;
|
||||
SCM_API void scm_memory_error (const char *subr) SCM_NORETURN;
|
||||
SCM_API void scm_misc_error (const char *subr, const char *message,
|
||||
SCM args) SCM_NORETURN;
|
||||
SCM_API void scm_init_error (void);
|
||||
|
||||
#endif /* SCM_ERROR_H */
|
||||
|
||||
|
|
214
libguile/eval.h
214
libguile/eval.h
|
@ -55,16 +55,16 @@
|
|||
/* {Options}
|
||||
*/
|
||||
|
||||
extern scm_t_option scm_eval_opts[];
|
||||
SCM_API scm_t_option scm_eval_opts[];
|
||||
|
||||
#define SCM_EVAL_STACK scm_eval_opts[0].val
|
||||
#define SCM_N_EVAL_OPTIONS 1
|
||||
|
||||
extern long scm_eval_stack;
|
||||
SCM_API long scm_eval_stack;
|
||||
|
||||
extern scm_t_option scm_evaluator_trap_table[];
|
||||
SCM_API scm_t_option scm_evaluator_trap_table[];
|
||||
|
||||
extern SCM scm_eval_options_interface (SCM setting);
|
||||
SCM_API SCM scm_eval_options_interface (SCM setting);
|
||||
|
||||
#define SCM_TRAPS_P scm_evaluator_trap_table[0].val
|
||||
#define SCM_ENTER_FRAME_P scm_evaluator_trap_table[1].val
|
||||
|
@ -137,116 +137,116 @@ extern SCM scm_eval_options_interface (SCM setting);
|
|||
#define SCM_TOP_LEVEL_LOOKUP_CLOSURE (scm_current_module_lookup_closure())
|
||||
|
||||
|
||||
extern const char scm_s_expression[];
|
||||
extern const char scm_s_test[];
|
||||
extern const char scm_s_body[];
|
||||
extern const char scm_s_bindings[];
|
||||
extern const char scm_s_variable[];
|
||||
extern const char scm_s_clauses[];
|
||||
extern const char scm_s_formals[];
|
||||
extern const char scm_s_set_x[];
|
||||
SCM_API const char scm_s_expression[];
|
||||
SCM_API const char scm_s_test[];
|
||||
SCM_API const char scm_s_body[];
|
||||
SCM_API const char scm_s_bindings[];
|
||||
SCM_API const char scm_s_variable[];
|
||||
SCM_API const char scm_s_clauses[];
|
||||
SCM_API const char scm_s_formals[];
|
||||
SCM_API const char scm_s_set_x[];
|
||||
|
||||
extern SCM scm_sym_and;
|
||||
extern SCM scm_sym_begin;
|
||||
extern SCM scm_sym_case;
|
||||
extern SCM scm_sym_cond;
|
||||
extern SCM scm_sym_define;
|
||||
extern SCM scm_sym_do;
|
||||
extern SCM scm_sym_if;
|
||||
extern SCM scm_sym_lambda;
|
||||
extern SCM scm_sym_let;
|
||||
extern SCM scm_sym_letstar;
|
||||
extern SCM scm_sym_letrec;
|
||||
extern SCM scm_sym_quote;
|
||||
extern SCM scm_sym_quasiquote;
|
||||
extern SCM scm_sym_unquote;
|
||||
extern SCM scm_sym_uq_splicing;
|
||||
SCM_API SCM scm_sym_and;
|
||||
SCM_API SCM scm_sym_begin;
|
||||
SCM_API SCM scm_sym_case;
|
||||
SCM_API SCM scm_sym_cond;
|
||||
SCM_API SCM scm_sym_define;
|
||||
SCM_API SCM scm_sym_do;
|
||||
SCM_API SCM scm_sym_if;
|
||||
SCM_API SCM scm_sym_lambda;
|
||||
SCM_API SCM scm_sym_let;
|
||||
SCM_API SCM scm_sym_letstar;
|
||||
SCM_API SCM scm_sym_letrec;
|
||||
SCM_API SCM scm_sym_quote;
|
||||
SCM_API SCM scm_sym_quasiquote;
|
||||
SCM_API SCM scm_sym_unquote;
|
||||
SCM_API SCM scm_sym_uq_splicing;
|
||||
|
||||
extern SCM scm_sym_dot;
|
||||
extern SCM scm_sym_atapply;
|
||||
extern SCM scm_sym_atcall_cc;
|
||||
extern SCM scm_sym_at_call_with_values;
|
||||
extern SCM scm_sym_delay;
|
||||
extern SCM scm_sym_arrow;
|
||||
extern SCM scm_sym_else;
|
||||
extern SCM scm_sym_apply;
|
||||
extern SCM scm_sym_set_x;
|
||||
extern SCM scm_sym_args;
|
||||
SCM_API SCM scm_sym_dot;
|
||||
SCM_API SCM scm_sym_atapply;
|
||||
SCM_API SCM scm_sym_atcall_cc;
|
||||
SCM_API SCM scm_sym_at_call_with_values;
|
||||
SCM_API SCM scm_sym_delay;
|
||||
SCM_API SCM scm_sym_arrow;
|
||||
SCM_API SCM scm_sym_else;
|
||||
SCM_API SCM scm_sym_apply;
|
||||
SCM_API SCM scm_sym_set_x;
|
||||
SCM_API SCM scm_sym_args;
|
||||
|
||||
extern SCM scm_f_apply;
|
||||
SCM_API SCM scm_f_apply;
|
||||
|
||||
|
||||
|
||||
extern SCM * scm_ilookup (SCM iloc, SCM env);
|
||||
extern SCM * scm_lookupcar (SCM vloc, SCM genv, int check);
|
||||
extern SCM scm_unmemocar (SCM form, SCM env);
|
||||
extern SCM scm_unmemocopy (SCM form, SCM env);
|
||||
extern SCM scm_eval_car (SCM pair, SCM env);
|
||||
extern SCM scm_eval_body (SCM code, SCM env);
|
||||
extern SCM scm_eval_args (SCM i, SCM env, SCM proc);
|
||||
extern SCM scm_deval_args (SCM l, SCM env, SCM proc, SCM *lloc);
|
||||
extern SCM scm_m_quote (SCM xorig, SCM env);
|
||||
extern SCM scm_m_begin (SCM xorig, SCM env);
|
||||
extern SCM scm_m_if (SCM xorig, SCM env);
|
||||
extern SCM scm_m_set_x (SCM xorig, SCM env);
|
||||
extern SCM scm_m_vref (SCM xorig, SCM env);
|
||||
extern SCM scm_m_vset (SCM xorig, SCM env);
|
||||
extern SCM scm_m_and (SCM xorig, SCM env);
|
||||
extern SCM scm_m_or (SCM xorig, SCM env);
|
||||
extern SCM scm_m_case (SCM xorig, SCM env);
|
||||
extern SCM scm_m_cond (SCM xorig, SCM env);
|
||||
extern SCM scm_m_lambda (SCM xorig, SCM env);
|
||||
extern SCM scm_m_letstar (SCM xorig, SCM env);
|
||||
extern SCM scm_m_do (SCM xorig, SCM env);
|
||||
extern SCM scm_m_quasiquote (SCM xorig, SCM env);
|
||||
extern SCM scm_m_delay (SCM xorig, SCM env);
|
||||
extern SCM scm_m_define (SCM x, SCM env);
|
||||
extern SCM scm_m_letrec (SCM xorig, SCM env);
|
||||
extern SCM scm_m_let (SCM xorig, SCM env);
|
||||
extern SCM scm_m_apply (SCM xorig, SCM env);
|
||||
extern SCM scm_m_cont (SCM xorig, SCM env);
|
||||
extern SCM scm_m_nil_cond (SCM xorig, SCM env);
|
||||
extern SCM scm_m_nil_ify (SCM xorig, SCM env);
|
||||
extern SCM scm_m_t_ify (SCM xorig, SCM env);
|
||||
extern SCM scm_m_0_cond (SCM xorig, SCM env);
|
||||
extern SCM scm_m_0_ify (SCM xorig, SCM env);
|
||||
extern SCM scm_m_1_ify (SCM xorig, SCM env);
|
||||
extern SCM scm_m_atfop (SCM xorig, SCM env);
|
||||
extern SCM scm_m_atbind (SCM xorig, SCM env);
|
||||
extern SCM scm_m_at_call_with_values (SCM xorig, SCM env);
|
||||
extern int scm_badargsp (SCM formals, SCM args);
|
||||
extern SCM scm_ceval (SCM x, SCM env);
|
||||
extern SCM scm_deval (SCM x, SCM env);
|
||||
extern SCM scm_call_0 (SCM proc);
|
||||
extern SCM scm_call_1 (SCM proc, SCM arg1);
|
||||
extern SCM scm_call_2 (SCM proc, SCM arg1, SCM arg2);
|
||||
extern SCM scm_call_3 (SCM proc, SCM arg1, SCM arg2, SCM arg3);
|
||||
extern SCM scm_call_4 (SCM proc, SCM arg1, SCM arg2, SCM arg3, SCM arg4);
|
||||
extern SCM scm_apply_0 (SCM proc, SCM args);
|
||||
extern SCM scm_apply_1 (SCM proc, SCM arg1, SCM args);
|
||||
extern SCM scm_apply_2 (SCM proc, SCM arg1, SCM arg2, SCM args);
|
||||
extern SCM scm_apply_3 (SCM proc, SCM arg1, SCM arg2, SCM arg3, SCM args);
|
||||
extern SCM scm_nconc2last (SCM lst);
|
||||
extern SCM scm_apply (SCM proc, SCM arg1, SCM args);
|
||||
extern SCM scm_dapply (SCM proc, SCM arg1, SCM args);
|
||||
extern SCM scm_m_expand_body (SCM xorig, SCM env);
|
||||
extern SCM scm_macroexp (SCM x, SCM env);
|
||||
extern SCM scm_map (SCM proc, SCM arg1, SCM args);
|
||||
extern SCM scm_for_each (SCM proc, SCM arg1, SCM args);
|
||||
extern SCM scm_closure (SCM code, SCM env);
|
||||
extern SCM scm_makprom (SCM code);
|
||||
extern SCM scm_force (SCM x);
|
||||
extern SCM scm_promise_p (SCM x);
|
||||
extern SCM scm_cons_source (SCM xorig, SCM x, SCM y);
|
||||
extern SCM scm_copy_tree (SCM obj);
|
||||
extern SCM scm_i_eval_x (SCM exp, SCM env);
|
||||
extern SCM scm_i_eval (SCM exp, SCM env);
|
||||
extern SCM scm_primitive_eval (SCM exp);
|
||||
extern SCM scm_primitive_eval_x (SCM exp);
|
||||
extern SCM scm_eval (SCM exp, SCM module);
|
||||
extern SCM scm_eval_x (SCM exp, SCM module);
|
||||
SCM_API SCM * scm_ilookup (SCM iloc, SCM env);
|
||||
SCM_API SCM * scm_lookupcar (SCM vloc, SCM genv, int check);
|
||||
SCM_API SCM scm_unmemocar (SCM form, SCM env);
|
||||
SCM_API SCM scm_unmemocopy (SCM form, SCM env);
|
||||
SCM_API SCM scm_eval_car (SCM pair, SCM env);
|
||||
SCM_API SCM scm_eval_body (SCM code, SCM env);
|
||||
SCM_API SCM scm_eval_args (SCM i, SCM env, SCM proc);
|
||||
SCM_API SCM scm_deval_args (SCM l, SCM env, SCM proc, SCM *lloc);
|
||||
SCM_API SCM scm_m_quote (SCM xorig, SCM env);
|
||||
SCM_API SCM scm_m_begin (SCM xorig, SCM env);
|
||||
SCM_API SCM scm_m_if (SCM xorig, SCM env);
|
||||
SCM_API SCM scm_m_set_x (SCM xorig, SCM env);
|
||||
SCM_API SCM scm_m_vref (SCM xorig, SCM env);
|
||||
SCM_API SCM scm_m_vset (SCM xorig, SCM env);
|
||||
SCM_API SCM scm_m_and (SCM xorig, SCM env);
|
||||
SCM_API SCM scm_m_or (SCM xorig, SCM env);
|
||||
SCM_API SCM scm_m_case (SCM xorig, SCM env);
|
||||
SCM_API SCM scm_m_cond (SCM xorig, SCM env);
|
||||
SCM_API SCM scm_m_lambda (SCM xorig, SCM env);
|
||||
SCM_API SCM scm_m_letstar (SCM xorig, SCM env);
|
||||
SCM_API SCM scm_m_do (SCM xorig, SCM env);
|
||||
SCM_API SCM scm_m_quasiquote (SCM xorig, SCM env);
|
||||
SCM_API SCM scm_m_delay (SCM xorig, SCM env);
|
||||
SCM_API SCM scm_m_define (SCM x, SCM env);
|
||||
SCM_API SCM scm_m_letrec (SCM xorig, SCM env);
|
||||
SCM_API SCM scm_m_let (SCM xorig, SCM env);
|
||||
SCM_API SCM scm_m_apply (SCM xorig, SCM env);
|
||||
SCM_API SCM scm_m_cont (SCM xorig, SCM env);
|
||||
SCM_API SCM scm_m_nil_cond (SCM xorig, SCM env);
|
||||
SCM_API SCM scm_m_nil_ify (SCM xorig, SCM env);
|
||||
SCM_API SCM scm_m_t_ify (SCM xorig, SCM env);
|
||||
SCM_API SCM scm_m_0_cond (SCM xorig, SCM env);
|
||||
SCM_API SCM scm_m_0_ify (SCM xorig, SCM env);
|
||||
SCM_API SCM scm_m_1_ify (SCM xorig, SCM env);
|
||||
SCM_API SCM scm_m_atfop (SCM xorig, SCM env);
|
||||
SCM_API SCM scm_m_atbind (SCM xorig, SCM env);
|
||||
SCM_API SCM scm_m_at_call_with_values (SCM xorig, SCM env);
|
||||
SCM_API int scm_badargsp (SCM formals, SCM args);
|
||||
SCM_API SCM scm_ceval (SCM x, SCM env);
|
||||
SCM_API SCM scm_deval (SCM x, SCM env);
|
||||
SCM_API SCM scm_call_0 (SCM proc);
|
||||
SCM_API SCM scm_call_1 (SCM proc, SCM arg1);
|
||||
SCM_API SCM scm_call_2 (SCM proc, SCM arg1, SCM arg2);
|
||||
SCM_API SCM scm_call_3 (SCM proc, SCM arg1, SCM arg2, SCM arg3);
|
||||
SCM_API SCM scm_call_4 (SCM proc, SCM arg1, SCM arg2, SCM arg3, SCM arg4);
|
||||
SCM_API SCM scm_apply_0 (SCM proc, SCM args);
|
||||
SCM_API SCM scm_apply_1 (SCM proc, SCM arg1, SCM args);
|
||||
SCM_API SCM scm_apply_2 (SCM proc, SCM arg1, SCM arg2, SCM args);
|
||||
SCM_API SCM scm_apply_3 (SCM proc, SCM arg1, SCM arg2, SCM arg3, SCM args);
|
||||
SCM_API SCM scm_nconc2last (SCM lst);
|
||||
SCM_API SCM scm_apply (SCM proc, SCM arg1, SCM args);
|
||||
SCM_API SCM scm_dapply (SCM proc, SCM arg1, SCM args);
|
||||
SCM_API SCM scm_m_expand_body (SCM xorig, SCM env);
|
||||
SCM_API SCM scm_macroexp (SCM x, SCM env);
|
||||
SCM_API SCM scm_map (SCM proc, SCM arg1, SCM args);
|
||||
SCM_API SCM scm_for_each (SCM proc, SCM arg1, SCM args);
|
||||
SCM_API SCM scm_closure (SCM code, SCM env);
|
||||
SCM_API SCM scm_makprom (SCM code);
|
||||
SCM_API SCM scm_force (SCM x);
|
||||
SCM_API SCM scm_promise_p (SCM x);
|
||||
SCM_API SCM scm_cons_source (SCM xorig, SCM x, SCM y);
|
||||
SCM_API SCM scm_copy_tree (SCM obj);
|
||||
SCM_API SCM scm_i_eval_x (SCM exp, SCM env);
|
||||
SCM_API SCM scm_i_eval (SCM exp, SCM env);
|
||||
SCM_API SCM scm_primitive_eval (SCM exp);
|
||||
SCM_API SCM scm_primitive_eval_x (SCM exp);
|
||||
SCM_API SCM scm_eval (SCM exp, SCM module);
|
||||
SCM_API SCM scm_eval_x (SCM exp, SCM module);
|
||||
|
||||
extern void scm_init_eval (void);
|
||||
SCM_API void scm_init_eval (void);
|
||||
|
||||
#endif /* SCM_EVAL_H */
|
||||
|
||||
|
|
|
@ -50,10 +50,10 @@
|
|||
|
||||
|
||||
|
||||
extern SCM scm_m_generalized_set_x (SCM xorig, SCM env);
|
||||
extern SCM scm_definedp (SCM sym, SCM env);
|
||||
extern SCM scm_m_undefine (SCM x, SCM env);
|
||||
extern void scm_init_evalext (void);
|
||||
SCM_API SCM scm_m_generalized_set_x (SCM xorig, SCM env);
|
||||
SCM_API SCM scm_definedp (SCM sym, SCM env);
|
||||
SCM_API SCM scm_m_undefine (SCM x, SCM env);
|
||||
SCM_API void scm_init_evalext (void);
|
||||
|
||||
#endif /* SCM_EVALEXT_H */
|
||||
|
||||
|
|
|
@ -50,13 +50,13 @@
|
|||
|
||||
|
||||
|
||||
extern void scm_c_register_extension (const char *lib, const char *init,
|
||||
void (*func) (void *), void *data);
|
||||
SCM_API void scm_c_register_extension (const char *lib, const char *init,
|
||||
void (*func) (void *), void *data);
|
||||
|
||||
extern void scm_c_load_extension (const char *lib, const char *init);
|
||||
extern SCM scm_load_extension (SCM lib, SCM init);
|
||||
SCM_API void scm_c_load_extension (const char *lib, const char *init);
|
||||
SCM_API SCM scm_load_extension (SCM lib, SCM init);
|
||||
|
||||
void scm_init_extensions (void);
|
||||
SCM_API void scm_init_extensions (void);
|
||||
|
||||
#endif /* SCM_EXTENSIONS_H */
|
||||
|
||||
|
|
|
@ -48,10 +48,10 @@
|
|||
|
||||
#include "libguile/__scm.h"
|
||||
|
||||
extern void scm_add_feature (const char* str);
|
||||
extern SCM scm_program_arguments (void);
|
||||
extern void scm_set_program_arguments (int argc, char **argv, char *first);
|
||||
extern void scm_init_feature (void);
|
||||
SCM_API void scm_add_feature (const char* str);
|
||||
SCM_API SCM scm_program_arguments (void);
|
||||
SCM_API void scm_set_program_arguments (int argc, char **argv, char *first);
|
||||
SCM_API void scm_init_feature (void);
|
||||
|
||||
#endif /* SCM_FEATURE_H */
|
||||
|
||||
|
|
|
@ -50,7 +50,7 @@
|
|||
|
||||
|
||||
|
||||
extern scm_t_bits scm_tc16_dir;
|
||||
SCM_API scm_t_bits scm_tc16_dir;
|
||||
|
||||
#define SCM_DIR_FLAG_OPEN (1L << 16)
|
||||
|
||||
|
@ -59,37 +59,37 @@ extern scm_t_bits scm_tc16_dir;
|
|||
|
||||
|
||||
|
||||
extern SCM scm_chown (SCM object, SCM owner, SCM group);
|
||||
extern SCM scm_chmod (SCM object, SCM mode);
|
||||
extern SCM scm_umask (SCM mode);
|
||||
extern SCM scm_open_fdes (SCM path, SCM flags, SCM mode);
|
||||
extern SCM scm_open (SCM path, SCM flags, SCM mode);
|
||||
extern SCM scm_close (SCM fd_or_port);
|
||||
extern SCM scm_close_fdes (SCM fd);
|
||||
extern SCM scm_stat (SCM object);
|
||||
extern SCM scm_link (SCM oldpath, SCM newpath);
|
||||
extern SCM scm_rename (SCM oldname, SCM newname);
|
||||
extern SCM scm_delete_file (SCM str);
|
||||
extern SCM scm_mkdir (SCM path, SCM mode);
|
||||
extern SCM scm_rmdir (SCM path);
|
||||
extern SCM scm_directory_stream_p (SCM obj);
|
||||
extern SCM scm_opendir (SCM dirname);
|
||||
extern SCM scm_readdir (SCM port);
|
||||
extern SCM scm_rewinddir (SCM port);
|
||||
extern SCM scm_closedir (SCM port);
|
||||
extern SCM scm_chdir (SCM str);
|
||||
extern SCM scm_getcwd (void);
|
||||
extern SCM scm_select (SCM reads, SCM writes, SCM excepts, SCM secs, SCM msecs);
|
||||
extern SCM scm_fcntl (SCM object, SCM cmd, SCM value);
|
||||
extern SCM scm_fsync (SCM object);
|
||||
extern SCM scm_symlink (SCM oldpath, SCM newpath);
|
||||
extern SCM scm_readlink (SCM path);
|
||||
extern SCM scm_lstat (SCM str);
|
||||
extern SCM scm_copy_file (SCM oldfile, SCM newfile);
|
||||
extern SCM scm_dirname (SCM filename);
|
||||
extern SCM scm_basename (SCM filename, SCM suffix);
|
||||
SCM_API SCM scm_chown (SCM object, SCM owner, SCM group);
|
||||
SCM_API SCM scm_chmod (SCM object, SCM mode);
|
||||
SCM_API SCM scm_umask (SCM mode);
|
||||
SCM_API SCM scm_open_fdes (SCM path, SCM flags, SCM mode);
|
||||
SCM_API SCM scm_open (SCM path, SCM flags, SCM mode);
|
||||
SCM_API SCM scm_close (SCM fd_or_port);
|
||||
SCM_API SCM scm_close_fdes (SCM fd);
|
||||
SCM_API SCM scm_stat (SCM object);
|
||||
SCM_API SCM scm_link (SCM oldpath, SCM newpath);
|
||||
SCM_API SCM scm_rename (SCM oldname, SCM newname);
|
||||
SCM_API SCM scm_delete_file (SCM str);
|
||||
SCM_API SCM scm_mkdir (SCM path, SCM mode);
|
||||
SCM_API SCM scm_rmdir (SCM path);
|
||||
SCM_API SCM scm_directory_stream_p (SCM obj);
|
||||
SCM_API SCM scm_opendir (SCM dirname);
|
||||
SCM_API SCM scm_readdir (SCM port);
|
||||
SCM_API SCM scm_rewinddir (SCM port);
|
||||
SCM_API SCM scm_closedir (SCM port);
|
||||
SCM_API SCM scm_chdir (SCM str);
|
||||
SCM_API SCM scm_getcwd (void);
|
||||
SCM_API SCM scm_select (SCM reads, SCM writes, SCM excepts, SCM secs, SCM msecs);
|
||||
SCM_API SCM scm_fcntl (SCM object, SCM cmd, SCM value);
|
||||
SCM_API SCM scm_fsync (SCM object);
|
||||
SCM_API SCM scm_symlink (SCM oldpath, SCM newpath);
|
||||
SCM_API SCM scm_readlink (SCM path);
|
||||
SCM_API SCM scm_lstat (SCM str);
|
||||
SCM_API SCM scm_copy_file (SCM oldfile, SCM newfile);
|
||||
SCM_API SCM scm_dirname (SCM filename);
|
||||
SCM_API SCM scm_basename (SCM filename, SCM suffix);
|
||||
|
||||
extern void scm_init_filesys (void);
|
||||
SCM_API void scm_init_filesys (void);
|
||||
|
||||
#endif /* SCM_FILESYS_H */
|
||||
|
||||
|
|
|
@ -72,7 +72,7 @@
|
|||
implement a more lightweight version of fluids on top of this basic
|
||||
mechanism. */
|
||||
|
||||
extern scm_t_bits scm_tc16_fluid;
|
||||
SCM_API scm_t_bits scm_tc16_fluid;
|
||||
|
||||
#define SCM_FLUIDP(x) (!SCM_IMP (x) && (SCM_CELL_TYPE (x) == scm_tc16_fluid))
|
||||
#define SCM_FLUID_NUM(x) (SCM_CELL_WORD_1 (x))
|
||||
|
@ -89,23 +89,23 @@ SCM_FLUID_NUM, not the fluid itself. */
|
|||
#define SCM_FAST_FLUID_REF(n) (SCM_VELTS(scm_root->fluids)[n])
|
||||
#define SCM_FAST_FLUID_SET_X(n, val) (SCM_VELTS(scm_root->fluids)[n] = val)
|
||||
|
||||
SCM scm_make_fluid (void);
|
||||
SCM scm_fluid_p (SCM fl);
|
||||
SCM scm_fluid_ref (SCM fluid);
|
||||
SCM scm_fluid_set_x (SCM fluid, SCM value);
|
||||
SCM_API SCM scm_make_fluid (void);
|
||||
SCM_API SCM scm_fluid_p (SCM fl);
|
||||
SCM_API SCM scm_fluid_ref (SCM fluid);
|
||||
SCM_API SCM scm_fluid_set_x (SCM fluid, SCM value);
|
||||
|
||||
SCM scm_c_with_fluids (SCM fluids, SCM vals,
|
||||
SCM (*cproc)(void *), void *cdata);
|
||||
SCM scm_c_with_fluid (SCM fluid, SCM val,
|
||||
SCM (*cproc)(void *), void *cdata);
|
||||
SCM scm_with_fluids (SCM fluids, SCM vals, SCM thunk);
|
||||
SCM_API SCM scm_c_with_fluids (SCM fluids, SCM vals,
|
||||
SCM (*cproc)(void *), void *cdata);
|
||||
SCM_API SCM scm_c_with_fluid (SCM fluid, SCM val,
|
||||
SCM (*cproc)(void *), void *cdata);
|
||||
SCM_API SCM scm_with_fluids (SCM fluids, SCM vals, SCM thunk);
|
||||
|
||||
SCM scm_make_initial_fluids (void);
|
||||
void scm_copy_fluids (scm_root_state *);
|
||||
void scm_swap_fluids (SCM fluids, SCM vals);
|
||||
void scm_swap_fluids_reverse (SCM fluids, SCM vals);
|
||||
SCM_API SCM scm_make_initial_fluids (void);
|
||||
SCM_API void scm_copy_fluids (scm_root_state *);
|
||||
SCM_API void scm_swap_fluids (SCM fluids, SCM vals);
|
||||
SCM_API void scm_swap_fluids_reverse (SCM fluids, SCM vals);
|
||||
|
||||
void scm_init_fluids (void);
|
||||
SCM_API void scm_init_fluids (void);
|
||||
|
||||
#endif /* SCM_FLUIDS_H */
|
||||
|
||||
|
|
|
@ -57,7 +57,7 @@ typedef struct scm_t_fport {
|
|||
int fdes; /* file descriptor. */
|
||||
} scm_t_fport;
|
||||
|
||||
extern scm_t_bits scm_tc16_fport;
|
||||
SCM_API scm_t_bits scm_tc16_fport;
|
||||
|
||||
#define SCM_FSTREAM(x) ((scm_t_fport *) SCM_STREAM (x))
|
||||
#define SCM_FPORT_FDES(x) (SCM_FSTREAM (x)->fdes)
|
||||
|
@ -71,13 +71,13 @@ extern scm_t_bits scm_tc16_fport;
|
|||
#define SCM_FDES_RANDOM_P(fdes) ((lseek (fdes, 0, SEEK_CUR) == -1) ? 0 : 1)
|
||||
|
||||
|
||||
extern SCM scm_setbuf0 (SCM port);
|
||||
extern SCM scm_setvbuf (SCM port, SCM mode, SCM size);
|
||||
extern void scm_evict_ports (int fd);
|
||||
extern SCM scm_open_file (SCM filename, SCM modes);
|
||||
extern SCM scm_fdes_to_port (int fdes, char *mode, SCM name);
|
||||
extern SCM scm_file_port_p (SCM obj);
|
||||
extern void scm_init_fports (void);
|
||||
SCM_API SCM scm_setbuf0 (SCM port);
|
||||
SCM_API SCM scm_setvbuf (SCM port, SCM mode, SCM size);
|
||||
SCM_API void scm_evict_ports (int fd);
|
||||
SCM_API SCM scm_open_file (SCM filename, SCM modes);
|
||||
SCM_API SCM scm_fdes_to_port (int fdes, char *mode, SCM name);
|
||||
SCM_API SCM scm_file_port_p (SCM obj);
|
||||
SCM_API void scm_init_fports (void);
|
||||
|
||||
#endif /* SCM_FPORTS_H */
|
||||
|
||||
|
|
150
libguile/gc.h
150
libguile/gc.h
|
@ -295,100 +295,100 @@ typedef unsigned long scm_t_c_bvec_limb;
|
|||
#define SCM_NMARKEDP(x) (!SCM_MARKEDP (x))
|
||||
|
||||
#if (SCM_DEBUG_CELL_ACCESSES == 1)
|
||||
extern scm_t_bits scm_tc16_allocated;
|
||||
extern unsigned int scm_debug_cell_accesses_p;
|
||||
SCM_API scm_t_bits scm_tc16_allocated;
|
||||
SCM_API unsigned int scm_debug_cell_accesses_p;
|
||||
#endif
|
||||
|
||||
extern struct scm_t_heap_seg_data *scm_heap_table;
|
||||
extern size_t scm_n_heap_segs;
|
||||
extern int scm_block_gc;
|
||||
extern int scm_gc_heap_lock;
|
||||
extern unsigned int scm_gc_running_p;
|
||||
SCM_API struct scm_t_heap_seg_data *scm_heap_table;
|
||||
SCM_API size_t scm_n_heap_segs;
|
||||
SCM_API int scm_block_gc;
|
||||
SCM_API int scm_gc_heap_lock;
|
||||
SCM_API unsigned int scm_gc_running_p;
|
||||
|
||||
|
||||
extern size_t scm_default_init_heap_size_1;
|
||||
extern int scm_default_min_yield_1;
|
||||
extern size_t scm_default_init_heap_size_2;
|
||||
extern int scm_default_min_yield_2;
|
||||
extern size_t scm_default_max_segment_size;
|
||||
SCM_API size_t scm_default_init_heap_size_1;
|
||||
SCM_API int scm_default_min_yield_1;
|
||||
SCM_API size_t scm_default_init_heap_size_2;
|
||||
SCM_API int scm_default_min_yield_2;
|
||||
SCM_API size_t scm_default_max_segment_size;
|
||||
|
||||
extern size_t scm_max_segment_size;
|
||||
extern SCM_CELLPTR scm_heap_org;
|
||||
extern SCM scm_freelist;
|
||||
extern struct scm_t_freelist scm_master_freelist;
|
||||
extern SCM scm_freelist2;
|
||||
extern struct scm_t_freelist scm_master_freelist2;
|
||||
extern unsigned long scm_gc_cells_collected;
|
||||
extern unsigned long scm_gc_yield;
|
||||
extern unsigned long scm_gc_malloc_collected;
|
||||
extern unsigned long scm_gc_ports_collected;
|
||||
extern unsigned long scm_cells_allocated;
|
||||
extern unsigned long scm_mallocated;
|
||||
extern unsigned long scm_mtrigger;
|
||||
SCM_API size_t scm_max_segment_size;
|
||||
SCM_API SCM_CELLPTR scm_heap_org;
|
||||
SCM_API SCM scm_freelist;
|
||||
SCM_API struct scm_t_freelist scm_master_freelist;
|
||||
SCM_API SCM scm_freelist2;
|
||||
SCM_API struct scm_t_freelist scm_master_freelist2;
|
||||
SCM_API unsigned long scm_gc_cells_collected;
|
||||
SCM_API unsigned long scm_gc_yield;
|
||||
SCM_API unsigned long scm_gc_malloc_collected;
|
||||
SCM_API unsigned long scm_gc_ports_collected;
|
||||
SCM_API unsigned long scm_cells_allocated;
|
||||
SCM_API unsigned long scm_mallocated;
|
||||
SCM_API unsigned long scm_mtrigger;
|
||||
|
||||
extern SCM scm_after_gc_hook;
|
||||
SCM_API SCM scm_after_gc_hook;
|
||||
|
||||
extern scm_t_c_hook scm_before_gc_c_hook;
|
||||
extern scm_t_c_hook scm_before_mark_c_hook;
|
||||
extern scm_t_c_hook scm_before_sweep_c_hook;
|
||||
extern scm_t_c_hook scm_after_sweep_c_hook;
|
||||
extern scm_t_c_hook scm_after_gc_c_hook;
|
||||
SCM_API scm_t_c_hook scm_before_gc_c_hook;
|
||||
SCM_API scm_t_c_hook scm_before_mark_c_hook;
|
||||
SCM_API scm_t_c_hook scm_before_sweep_c_hook;
|
||||
SCM_API scm_t_c_hook scm_after_sweep_c_hook;
|
||||
SCM_API scm_t_c_hook scm_after_gc_c_hook;
|
||||
|
||||
#if defined (GUILE_DEBUG) || defined (GUILE_DEBUG_FREELIST)
|
||||
extern SCM scm_map_free_list (void);
|
||||
extern SCM scm_free_list_length (void);
|
||||
SCM_API SCM scm_map_free_list (void);
|
||||
SCM_API SCM scm_free_list_length (void);
|
||||
#endif
|
||||
#ifdef GUILE_DEBUG_FREELIST
|
||||
extern SCM scm_debug_newcell (void);
|
||||
extern SCM scm_debug_newcell2 (void);
|
||||
extern SCM scm_gc_set_debug_check_freelist_x (SCM flag);
|
||||
SCM_API SCM scm_debug_newcell (void);
|
||||
SCM_API SCM scm_debug_newcell2 (void);
|
||||
SCM_API SCM scm_gc_set_debug_check_freelist_x (SCM flag);
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
#if (SCM_DEBUG_CELL_ACCESSES == 1)
|
||||
extern void scm_assert_cell_valid (SCM);
|
||||
extern SCM scm_set_debug_cell_accesses_x (SCM flag);
|
||||
SCM_API void scm_assert_cell_valid (SCM);
|
||||
SCM_API SCM scm_set_debug_cell_accesses_x (SCM flag);
|
||||
#endif
|
||||
extern SCM scm_object_address (SCM obj);
|
||||
extern SCM scm_unhash_name (SCM name);
|
||||
extern SCM scm_gc_stats (void);
|
||||
extern SCM scm_gc (void);
|
||||
extern void scm_gc_for_alloc (struct scm_t_freelist *freelist);
|
||||
extern SCM scm_gc_for_newcell (struct scm_t_freelist *master, SCM *freelist);
|
||||
SCM_API SCM scm_object_address (SCM obj);
|
||||
SCM_API SCM scm_unhash_name (SCM name);
|
||||
SCM_API SCM scm_gc_stats (void);
|
||||
SCM_API SCM scm_gc (void);
|
||||
SCM_API void scm_gc_for_alloc (struct scm_t_freelist *freelist);
|
||||
SCM_API SCM scm_gc_for_newcell (struct scm_t_freelist *master, SCM *freelist);
|
||||
#if 0
|
||||
extern void scm_alloc_cluster (struct scm_t_freelist *master);
|
||||
SCM_API void scm_alloc_cluster (struct scm_t_freelist *master);
|
||||
#endif
|
||||
extern void scm_igc (const char *what);
|
||||
extern void scm_gc_mark (SCM p);
|
||||
extern void scm_gc_mark_dependencies (SCM p);
|
||||
extern void scm_mark_locations (SCM_STACKITEM x[], unsigned long n);
|
||||
extern int scm_cellp (SCM value);
|
||||
extern void scm_gc_sweep (void);
|
||||
extern void * scm_must_malloc (size_t len, const char *what);
|
||||
extern void * scm_must_realloc (void *where,
|
||||
size_t olen, size_t len,
|
||||
const char *what);
|
||||
extern char *scm_must_strdup (const char *str);
|
||||
extern char *scm_must_strndup (const char *str, size_t n);
|
||||
extern void scm_done_malloc (long size);
|
||||
extern void scm_done_free (long size);
|
||||
extern void scm_must_free (void *obj);
|
||||
extern void scm_remember_upto_here_1 (SCM obj);
|
||||
extern void scm_remember_upto_here_2 (SCM obj1, SCM obj2);
|
||||
extern void scm_remember_upto_here (SCM obj1, ...);
|
||||
extern SCM scm_return_first (SCM elt, ...);
|
||||
extern int scm_return_first_int (int x, ...);
|
||||
extern SCM scm_permanent_object (SCM obj);
|
||||
extern SCM scm_gc_protect_object (SCM obj);
|
||||
extern SCM scm_gc_unprotect_object (SCM obj);
|
||||
extern void scm_gc_register_root (SCM *p);
|
||||
extern void scm_gc_unregister_root (SCM *p);
|
||||
extern void scm_gc_register_roots (SCM *b, unsigned long n);
|
||||
extern void scm_gc_unregister_roots (SCM *b, unsigned long n);
|
||||
extern int scm_init_storage (void);
|
||||
extern void *scm_get_stack_base (void);
|
||||
extern void scm_init_gc (void);
|
||||
SCM_API void scm_igc (const char *what);
|
||||
SCM_API void scm_gc_mark (SCM p);
|
||||
SCM_API void scm_gc_mark_dependencies (SCM p);
|
||||
SCM_API void scm_mark_locations (SCM_STACKITEM x[], unsigned long n);
|
||||
SCM_API int scm_cellp (SCM value);
|
||||
SCM_API void scm_gc_sweep (void);
|
||||
SCM_API void * scm_must_malloc (size_t len, const char *what);
|
||||
SCM_API void * scm_must_realloc (void *where,
|
||||
size_t olen, size_t len,
|
||||
const char *what);
|
||||
SCM_API char *scm_must_strdup (const char *str);
|
||||
SCM_API char *scm_must_strndup (const char *str, size_t n);
|
||||
SCM_API void scm_done_malloc (long size);
|
||||
SCM_API void scm_done_free (long size);
|
||||
SCM_API void scm_must_free (void *obj);
|
||||
SCM_API void scm_remember_upto_here_1 (SCM obj);
|
||||
SCM_API void scm_remember_upto_here_2 (SCM obj1, SCM obj2);
|
||||
SCM_API void scm_remember_upto_here (SCM obj1, ...);
|
||||
SCM_API SCM scm_return_first (SCM elt, ...);
|
||||
SCM_API int scm_return_first_int (int x, ...);
|
||||
SCM_API SCM scm_permanent_object (SCM obj);
|
||||
SCM_API SCM scm_gc_protect_object (SCM obj);
|
||||
SCM_API SCM scm_gc_unprotect_object (SCM obj);
|
||||
SCM_API void scm_gc_register_root (SCM *p);
|
||||
SCM_API void scm_gc_unregister_root (SCM *p);
|
||||
SCM_API void scm_gc_register_roots (SCM *b, unsigned long n);
|
||||
SCM_API void scm_gc_unregister_roots (SCM *b, unsigned long n);
|
||||
SCM_API int scm_init_storage (void);
|
||||
SCM_API void *scm_get_stack_base (void);
|
||||
SCM_API void scm_init_gc (void);
|
||||
|
||||
#endif /* SCM_GC_H */
|
||||
|
||||
|
|
|
@ -53,9 +53,9 @@
|
|||
|
||||
|
||||
|
||||
extern int scm_print_carefully_p;
|
||||
SCM_API int scm_print_carefully_p;
|
||||
|
||||
extern void scm_init_gdbint (void);
|
||||
SCM_API void scm_init_gdbint (void);
|
||||
|
||||
#endif /* SCM_GDBINT_H */
|
||||
|
||||
|
|
228
libguile/gh.h
228
libguile/gh.h
|
@ -58,107 +58,109 @@ extern "C" {
|
|||
#define EXTINL
|
||||
#endif /* __GNUC__ */
|
||||
|
||||
void gh_enter(int argc, char *argv[], void (*c_main_prog)(int, char **));
|
||||
SCM_API void gh_enter(int argc, char *argv[],
|
||||
void (*c_main_prog)(int, char **));
|
||||
#define gh_init () scm_init_guile ()
|
||||
void gh_repl(int argc, char *argv[]);
|
||||
SCM gh_catch(SCM tag, scm_t_catch_body body, void *body_data,
|
||||
scm_t_catch_handler handler, void *handler_data);
|
||||
SCM_API void gh_repl(int argc, char *argv[]);
|
||||
SCM_API SCM gh_catch(SCM tag, scm_t_catch_body body, void *body_data,
|
||||
scm_t_catch_handler handler, void *handler_data);
|
||||
|
||||
SCM gh_standard_handler(void *data, SCM tag, SCM throw_args);
|
||||
SCM_API SCM gh_standard_handler(void *data, SCM tag, SCM throw_args);
|
||||
|
||||
SCM gh_eval_str(const char *scheme_code);
|
||||
SCM gh_eval_str_with_catch(const char *scheme_code, scm_t_catch_handler handler);
|
||||
SCM gh_eval_str_with_standard_handler(const char *scheme_code);
|
||||
SCM gh_eval_str_with_stack_saving_handler(const char *scheme_code);
|
||||
SCM_API SCM gh_eval_str(const char *scheme_code);
|
||||
SCM_API SCM gh_eval_str_with_catch(const char *scheme_code, scm_t_catch_handler handler);
|
||||
SCM_API SCM gh_eval_str_with_standard_handler(const char *scheme_code);
|
||||
SCM_API SCM gh_eval_str_with_stack_saving_handler(const char *scheme_code);
|
||||
|
||||
SCM gh_eval_file(const char *fname);
|
||||
SCM_API SCM gh_eval_file(const char *fname);
|
||||
#define gh_load(fname) gh_eval_file(fname)
|
||||
SCM gh_eval_file_with_catch(const char *scheme_code, scm_t_catch_handler handler);
|
||||
SCM gh_eval_file_with_standard_handler(const char *scheme_code);
|
||||
SCM_API SCM gh_eval_file_with_catch(const char *scheme_code, scm_t_catch_handler handler);
|
||||
SCM_API SCM gh_eval_file_with_standard_handler(const char *scheme_code);
|
||||
|
||||
#define gh_defer_ints() SCM_DEFER_INTS
|
||||
#define gh_allow_ints() SCM_ALLOW_INTS
|
||||
|
||||
SCM gh_new_procedure(const char *proc_name, SCM (*fn)(),
|
||||
int n_required_args, int n_optional_args, int varp);
|
||||
SCM gh_new_procedure0_0(const char *proc_name, SCM (*fn)(void));
|
||||
SCM gh_new_procedure0_1(const char *proc_name, SCM (*fn)(SCM));
|
||||
SCM gh_new_procedure0_2(const char *proc_name, SCM (*fn)(SCM, SCM));
|
||||
SCM gh_new_procedure1_0(const char *proc_name, SCM (*fn)(SCM));
|
||||
SCM gh_new_procedure1_1(const char *proc_name, SCM (*fn)(SCM, SCM));
|
||||
SCM gh_new_procedure1_2(const char *proc_name, SCM (*fn)(SCM, SCM, SCM));
|
||||
SCM gh_new_procedure2_0(const char *proc_name, SCM (*fn)(SCM, SCM));
|
||||
SCM gh_new_procedure2_1(const char *proc_name, SCM (*fn)(SCM, SCM, SCM));
|
||||
SCM gh_new_procedure2_2(const char *proc_name, SCM (*fn)(SCM, SCM, SCM, SCM));
|
||||
SCM gh_new_procedure3_0(const char *proc_name, SCM (*fn)(SCM, SCM, SCM));
|
||||
SCM gh_new_procedure4_0(const char *proc_name, SCM (*fn)(SCM, SCM, SCM, SCM));
|
||||
SCM gh_new_procedure5_0(const char *proc_name, SCM (*fn)(SCM, SCM, SCM, SCM, SCM));
|
||||
SCM_API SCM gh_new_procedure(const char *proc_name, SCM (*fn)(),
|
||||
int n_required_args, int n_optional_args,
|
||||
int varp);
|
||||
SCM_API SCM gh_new_procedure0_0(const char *proc_name, SCM (*fn)(void));
|
||||
SCM_API SCM gh_new_procedure0_1(const char *proc_name, SCM (*fn)(SCM));
|
||||
SCM_API SCM gh_new_procedure0_2(const char *proc_name, SCM (*fn)(SCM, SCM));
|
||||
SCM_API SCM gh_new_procedure1_0(const char *proc_name, SCM (*fn)(SCM));
|
||||
SCM_API SCM gh_new_procedure1_1(const char *proc_name, SCM (*fn)(SCM, SCM));
|
||||
SCM_API SCM gh_new_procedure1_2(const char *proc_name, SCM (*fn)(SCM, SCM, SCM));
|
||||
SCM_API SCM gh_new_procedure2_0(const char *proc_name, SCM (*fn)(SCM, SCM));
|
||||
SCM_API SCM gh_new_procedure2_1(const char *proc_name, SCM (*fn)(SCM, SCM, SCM));
|
||||
SCM_API SCM gh_new_procedure2_2(const char *proc_name, SCM (*fn)(SCM, SCM, SCM, SCM));
|
||||
SCM_API SCM gh_new_procedure3_0(const char *proc_name, SCM (*fn)(SCM, SCM, SCM));
|
||||
SCM_API SCM gh_new_procedure4_0(const char *proc_name, SCM (*fn)(SCM, SCM, SCM, SCM));
|
||||
SCM_API SCM gh_new_procedure5_0(const char *proc_name, SCM (*fn)(SCM, SCM, SCM, SCM, SCM));
|
||||
|
||||
/* C to Scheme conversion */
|
||||
SCM gh_bool2scm(int x);
|
||||
SCM gh_int2scm(int x);
|
||||
SCM gh_ulong2scm(unsigned long x);
|
||||
SCM gh_long2scm(long x);
|
||||
SCM gh_double2scm(double x);
|
||||
SCM gh_char2scm(char c);
|
||||
SCM gh_str2scm(const char *s, size_t len);
|
||||
SCM gh_str02scm(const char *s);
|
||||
void gh_set_substr(char *src, SCM dst, long start, size_t len);
|
||||
SCM gh_symbol2scm(const char *symbol_str);
|
||||
SCM gh_ints2scm(const int *d, long n);
|
||||
SCM_API SCM gh_bool2scm(int x);
|
||||
SCM_API SCM gh_int2scm(int x);
|
||||
SCM_API SCM gh_ulong2scm(unsigned long x);
|
||||
SCM_API SCM gh_long2scm(long x);
|
||||
SCM_API SCM gh_double2scm(double x);
|
||||
SCM_API SCM gh_char2scm(char c);
|
||||
SCM_API SCM gh_str2scm(const char *s, size_t len);
|
||||
SCM_API SCM gh_str02scm(const char *s);
|
||||
SCM_API void gh_set_substr(char *src, SCM dst, long start, size_t len);
|
||||
SCM_API SCM gh_symbol2scm(const char *symbol_str);
|
||||
SCM_API SCM gh_ints2scm(const int *d, long n);
|
||||
|
||||
#ifdef HAVE_ARRAYS
|
||||
SCM gh_chars2byvect(const char *d, long n);
|
||||
SCM gh_shorts2svect(const short *d, long n);
|
||||
SCM gh_longs2ivect(const long *d, long n);
|
||||
SCM gh_ulongs2uvect(const unsigned long *d, long n);
|
||||
SCM gh_floats2fvect(const float *d, long n);
|
||||
SCM gh_doubles2dvect(const double *d, long n);
|
||||
SCM_API SCM gh_chars2byvect(const char *d, long n);
|
||||
SCM_API SCM gh_shorts2svect(const short *d, long n);
|
||||
SCM_API SCM gh_longs2ivect(const long *d, long n);
|
||||
SCM_API SCM gh_ulongs2uvect(const unsigned long *d, long n);
|
||||
SCM_API SCM gh_floats2fvect(const float *d, long n);
|
||||
SCM_API SCM gh_doubles2dvect(const double *d, long n);
|
||||
#endif
|
||||
|
||||
SCM gh_doubles2scm(const double *d, long n);
|
||||
SCM_API SCM gh_doubles2scm(const double *d, long n);
|
||||
|
||||
/* Scheme to C conversion */
|
||||
int gh_scm2bool(SCM obj);
|
||||
int gh_scm2int(SCM obj);
|
||||
unsigned long gh_scm2ulong(SCM obj);
|
||||
long gh_scm2long(SCM obj);
|
||||
char gh_scm2char(SCM obj);
|
||||
double gh_scm2double(SCM obj);
|
||||
char *gh_scm2newstr(SCM str, size_t *lenp);
|
||||
void gh_get_substr(SCM src, char *dst, long start, size_t len);
|
||||
char *gh_symbol2newstr(SCM sym, size_t *lenp);
|
||||
char *gh_scm2chars(SCM vector, char *result);
|
||||
short *gh_scm2shorts(SCM vector, short *result);
|
||||
long *gh_scm2longs(SCM vector, long *result);
|
||||
float *gh_scm2floats(SCM vector, float *result);
|
||||
double *gh_scm2doubles(SCM vector, double *result);
|
||||
SCM_API int gh_scm2bool(SCM obj);
|
||||
SCM_API int gh_scm2int(SCM obj);
|
||||
SCM_API unsigned long gh_scm2ulong(SCM obj);
|
||||
SCM_API long gh_scm2long(SCM obj);
|
||||
SCM_API char gh_scm2char(SCM obj);
|
||||
SCM_API double gh_scm2double(SCM obj);
|
||||
SCM_API char *gh_scm2newstr(SCM str, size_t *lenp);
|
||||
SCM_API void gh_get_substr(SCM src, char *dst, long start, size_t len);
|
||||
SCM_API char *gh_symbol2newstr(SCM sym, size_t *lenp);
|
||||
SCM_API char *gh_scm2chars(SCM vector, char *result);
|
||||
SCM_API short *gh_scm2shorts(SCM vector, short *result);
|
||||
SCM_API long *gh_scm2longs(SCM vector, long *result);
|
||||
SCM_API float *gh_scm2floats(SCM vector, float *result);
|
||||
SCM_API double *gh_scm2doubles(SCM vector, double *result);
|
||||
|
||||
/* type predicates: tell you if an SCM object has a given type */
|
||||
int gh_boolean_p(SCM val);
|
||||
int gh_symbol_p(SCM val);
|
||||
int gh_char_p(SCM val);
|
||||
int gh_vector_p(SCM val);
|
||||
int gh_pair_p(SCM val);
|
||||
int gh_number_p(SCM val);
|
||||
int gh_string_p(SCM val);
|
||||
int gh_procedure_p(SCM val);
|
||||
int gh_list_p(SCM val);
|
||||
int gh_inexact_p(SCM val);
|
||||
int gh_exact_p(SCM val);
|
||||
SCM_API int gh_boolean_p(SCM val);
|
||||
SCM_API int gh_symbol_p(SCM val);
|
||||
SCM_API int gh_char_p(SCM val);
|
||||
SCM_API int gh_vector_p(SCM val);
|
||||
SCM_API int gh_pair_p(SCM val);
|
||||
SCM_API int gh_number_p(SCM val);
|
||||
SCM_API int gh_string_p(SCM val);
|
||||
SCM_API int gh_procedure_p(SCM val);
|
||||
SCM_API int gh_list_p(SCM val);
|
||||
SCM_API int gh_inexact_p(SCM val);
|
||||
SCM_API int gh_exact_p(SCM val);
|
||||
|
||||
/* more predicates */
|
||||
int gh_eq_p(SCM x, SCM y);
|
||||
int gh_eqv_p(SCM x, SCM y);
|
||||
int gh_equal_p(SCM x, SCM y);
|
||||
int gh_string_equal_p(SCM s1, SCM s2);
|
||||
int gh_null_p(SCM l);
|
||||
SCM_API int gh_eq_p(SCM x, SCM y);
|
||||
SCM_API int gh_eqv_p(SCM x, SCM y);
|
||||
SCM_API int gh_equal_p(SCM x, SCM y);
|
||||
SCM_API int gh_string_equal_p(SCM s1, SCM s2);
|
||||
SCM_API int gh_null_p(SCM l);
|
||||
|
||||
/* standard Scheme procedures available from C */
|
||||
|
||||
#define gh_not(x) scm_not(x)
|
||||
|
||||
SCM gh_define(const char *name, SCM val);
|
||||
SCM_API SCM gh_define(const char *name, SCM val);
|
||||
|
||||
/* string manipulation routines */
|
||||
#define gh_make_string(k, chr) scm_make_string(k, chr)
|
||||
|
@ -175,25 +177,25 @@ SCM gh_define(const char *name, SCM val);
|
|||
data element by element, but rather as a list. thus, gh_vector()
|
||||
ends up being identical to gh_list_to_vector() */
|
||||
#define gh_vector(ls) scm_vector(ls)
|
||||
SCM gh_make_vector(SCM length, SCM val);
|
||||
SCM gh_vector_set_x(SCM vec, SCM pos, SCM val);
|
||||
SCM gh_vector_ref(SCM vec, SCM pos);
|
||||
unsigned long gh_vector_length (SCM v);
|
||||
unsigned long gh_uniform_vector_length (SCM v);
|
||||
SCM gh_uniform_vector_ref (SCM v, SCM ilist);
|
||||
SCM_API SCM gh_make_vector(SCM length, SCM val);
|
||||
SCM_API SCM gh_vector_set_x(SCM vec, SCM pos, SCM val);
|
||||
SCM_API SCM gh_vector_ref(SCM vec, SCM pos);
|
||||
SCM_API unsigned long gh_vector_length (SCM v);
|
||||
SCM_API unsigned long gh_uniform_vector_length (SCM v);
|
||||
SCM_API SCM gh_uniform_vector_ref (SCM v, SCM ilist);
|
||||
#define gh_list_to_vector(ls) scm_vector(ls)
|
||||
#define gh_vector_to_list(v) scm_vector_to_list(v)
|
||||
|
||||
SCM gh_lookup (const char *sname);
|
||||
SCM gh_module_lookup (SCM module, const char *sname);
|
||||
SCM_API SCM gh_lookup (const char *sname);
|
||||
SCM_API SCM gh_module_lookup (SCM module, const char *sname);
|
||||
|
||||
SCM gh_cons(SCM x, SCM y);
|
||||
SCM_API SCM gh_cons(SCM x, SCM y);
|
||||
#define gh_list scm_list_n
|
||||
unsigned long gh_length(SCM l);
|
||||
SCM gh_append(SCM args);
|
||||
SCM gh_append2(SCM l1, SCM l2);
|
||||
SCM gh_append3(SCM l1, SCM l2, SCM l3);
|
||||
SCM gh_append4(SCM l1, SCM l2, SCM l3, SCM l4);
|
||||
SCM_API unsigned long gh_length(SCM l);
|
||||
SCM_API SCM gh_append(SCM args);
|
||||
SCM_API SCM gh_append2(SCM l1, SCM l2);
|
||||
SCM_API SCM gh_append3(SCM l1, SCM l2, SCM l3);
|
||||
SCM_API SCM gh_append4(SCM l1, SCM l2, SCM l3, SCM l4);
|
||||
#define gh_reverse(ls) scm_reverse(ls)
|
||||
#define gh_list_tail(ls, k) scm_list_tail(ls, k)
|
||||
#define gh_list_ref(ls, k) scm_list_ref(ls, k)
|
||||
|
@ -204,38 +206,38 @@ SCM gh_append4(SCM l1, SCM l2, SCM l3, SCM l4);
|
|||
#define gh_assv(x, alist) scm_assv(x, alist)
|
||||
#define gh_assoc(x, alist) scm_assoc(x, alist)
|
||||
|
||||
SCM gh_car(SCM x);
|
||||
SCM gh_cdr(SCM x);
|
||||
SCM_API SCM gh_car(SCM x);
|
||||
SCM_API SCM gh_cdr(SCM x);
|
||||
|
||||
SCM gh_caar(SCM x);
|
||||
SCM gh_cadr(SCM x);
|
||||
SCM gh_cdar(SCM x);
|
||||
SCM gh_cddr(SCM x);
|
||||
SCM_API SCM gh_caar(SCM x);
|
||||
SCM_API SCM gh_cadr(SCM x);
|
||||
SCM_API SCM gh_cdar(SCM x);
|
||||
SCM_API SCM gh_cddr(SCM x);
|
||||
|
||||
SCM gh_caaar(SCM x);
|
||||
SCM gh_caadr(SCM x);
|
||||
SCM gh_cadar(SCM x);
|
||||
SCM gh_caddr(SCM x);
|
||||
SCM gh_cdaar(SCM x);
|
||||
SCM gh_cdadr(SCM x);
|
||||
SCM gh_cddar(SCM x);
|
||||
SCM gh_cdddr(SCM x);
|
||||
SCM_API SCM gh_caaar(SCM x);
|
||||
SCM_API SCM gh_caadr(SCM x);
|
||||
SCM_API SCM gh_cadar(SCM x);
|
||||
SCM_API SCM gh_caddr(SCM x);
|
||||
SCM_API SCM gh_cdaar(SCM x);
|
||||
SCM_API SCM gh_cdadr(SCM x);
|
||||
SCM_API SCM gh_cddar(SCM x);
|
||||
SCM_API SCM gh_cdddr(SCM x);
|
||||
|
||||
SCM gh_set_car_x(SCM pair, SCM value);
|
||||
SCM gh_set_cdr_x(SCM pair, SCM value);
|
||||
SCM_API SCM gh_set_car_x(SCM pair, SCM value);
|
||||
SCM_API SCM gh_set_cdr_x(SCM pair, SCM value);
|
||||
|
||||
|
||||
/* Calling Scheme functions from C. */
|
||||
SCM gh_apply (SCM proc, SCM ls);
|
||||
SCM gh_call0 (SCM proc);
|
||||
SCM gh_call1 (SCM proc, SCM arg);
|
||||
SCM gh_call2 (SCM proc, SCM arg1, SCM arg2);
|
||||
SCM gh_call3 (SCM proc, SCM arg1, SCM arg2, SCM arg3);
|
||||
SCM_API SCM gh_apply (SCM proc, SCM ls);
|
||||
SCM_API SCM gh_call0 (SCM proc);
|
||||
SCM_API SCM gh_call1 (SCM proc, SCM arg);
|
||||
SCM_API SCM gh_call2 (SCM proc, SCM arg1, SCM arg2);
|
||||
SCM_API SCM gh_call3 (SCM proc, SCM arg1, SCM arg2, SCM arg3);
|
||||
|
||||
/* reading and writing Scheme objects. */
|
||||
void gh_display (SCM x);
|
||||
void gh_write (SCM x);
|
||||
void gh_newline (void);
|
||||
SCM_API void gh_display (SCM x);
|
||||
SCM_API void gh_write (SCM x);
|
||||
SCM_API void gh_newline (void);
|
||||
|
||||
/* void gh_gc_mark(SCM) : mark an SCM as in use. */
|
||||
/* void gh_defer_ints() : don't interrupt code section. */
|
||||
|
|
204
libguile/goops.h
204
libguile/goops.h
|
@ -178,111 +178,127 @@ typedef struct scm_t_method {
|
|||
#define scm_si_code_table 3 /* offset of code. slot in a <method> */
|
||||
|
||||
/* C interface */
|
||||
extern SCM scm_class_top, scm_class_object, scm_class_class;
|
||||
extern SCM scm_class_entity, scm_class_entity_with_setter;
|
||||
extern SCM scm_class_generic, scm_class_generic_with_setter, scm_class_method;
|
||||
extern SCM scm_class_simple_method, scm_class_accessor;
|
||||
extern SCM scm_class_procedure_class;
|
||||
extern SCM scm_class_operator_class, scm_class_operator_with_setter_class;
|
||||
extern SCM scm_class_entity_class;
|
||||
extern SCM scm_class_number, scm_class_list;
|
||||
extern SCM scm_class_keyword;
|
||||
extern SCM scm_class_port, scm_class_input_output_port;
|
||||
extern SCM scm_class_input_port, scm_class_output_port;
|
||||
extern SCM scm_class_foreign_class, scm_class_foreign_object;
|
||||
extern SCM scm_class_foreign_slot;
|
||||
extern SCM scm_class_self, scm_class_protected;
|
||||
extern SCM scm_class_opaque, scm_class_read_only;
|
||||
extern SCM scm_class_protected_opaque, scm_class_protected_read_only;
|
||||
extern SCM scm_class_scm;
|
||||
extern SCM scm_class_int, scm_class_float, scm_class_double;
|
||||
extern const char *scm_s_slot_set_x;
|
||||
SCM_API SCM scm_class_top;
|
||||
SCM_API SCM scm_class_object;
|
||||
SCM_API SCM scm_class_class;
|
||||
SCM_API SCM scm_class_entity;
|
||||
SCM_API SCM scm_class_entity_with_setter;
|
||||
SCM_API SCM scm_class_generic;
|
||||
SCM_API SCM scm_class_generic_with_setter;
|
||||
SCM_API SCM scm_class_method;
|
||||
SCM_API SCM scm_class_simple_method;
|
||||
SCM_API SCM scm_class_accessor;
|
||||
SCM_API SCM scm_class_procedure_class;
|
||||
SCM_API SCM scm_class_operator_class;
|
||||
SCM_API SCM scm_class_operator_with_setter_class;
|
||||
SCM_API SCM scm_class_entity_class;
|
||||
SCM_API SCM scm_class_number;
|
||||
SCM_API SCM scm_class_list;
|
||||
SCM_API SCM scm_class_keyword;
|
||||
SCM_API SCM scm_class_port;
|
||||
SCM_API SCM scm_class_input_output_port;
|
||||
SCM_API SCM scm_class_input_port;
|
||||
SCM_API SCM scm_class_output_port;
|
||||
SCM_API SCM scm_class_foreign_class;
|
||||
SCM_API SCM scm_class_foreign_object;
|
||||
SCM_API SCM scm_class_foreign_slot;
|
||||
SCM_API SCM scm_class_self;
|
||||
SCM_API SCM scm_class_protected;
|
||||
SCM_API SCM scm_class_opaque;
|
||||
SCM_API SCM scm_class_read_only;
|
||||
SCM_API SCM scm_class_protected_opaque;
|
||||
SCM_API SCM scm_class_protected_read_only;
|
||||
SCM_API SCM scm_class_scm;
|
||||
SCM_API SCM scm_class_int;
|
||||
SCM_API SCM scm_class_float;
|
||||
SCM_API SCM scm_class_double;
|
||||
SCM_API const char *scm_s_slot_set_x;
|
||||
|
||||
extern SCM scm_module_goops;
|
||||
SCM_API SCM scm_module_goops;
|
||||
|
||||
SCM scm_goops_version (void);
|
||||
SCM scm_oldfmt (SCM);
|
||||
char *scm_c_oldfmt0 (char *);
|
||||
char *scm_c_oldfmt (char *, int n);
|
||||
void scm_load_goops (void);
|
||||
SCM scm_make_foreign_object (SCM cls, SCM initargs);
|
||||
SCM scm_make_class (SCM meta, char *s_name, SCM supers, size_t size,
|
||||
void * (*constructor) (SCM initargs),
|
||||
size_t (*destructor) (void *));
|
||||
void scm_add_slot (SCM c, char *slot, SCM slot_class,
|
||||
SCM (*getter) (SCM obj),
|
||||
SCM (*setter) (SCM obj, SCM x),
|
||||
char *accessor_name);
|
||||
SCM scm_wrap_object (SCM c, void *);
|
||||
SCM scm_wrap_component (SCM c, SCM obj, void *);
|
||||
SCM scm_ensure_accessor (SCM name);
|
||||
void scm_add_method (SCM gf, SCM m);
|
||||
SCM_API SCM scm_goops_version (void);
|
||||
SCM_API SCM scm_oldfmt (SCM);
|
||||
SCM_API char *scm_c_oldfmt0 (char *);
|
||||
SCM_API char *scm_c_oldfmt (char *, int n);
|
||||
SCM_API void scm_load_goops (void);
|
||||
SCM_API SCM scm_make_foreign_object (SCM cls, SCM initargs);
|
||||
SCM_API SCM scm_make_class (SCM meta, char *s_name, SCM supers, size_t size,
|
||||
void * (*constructor) (SCM initargs),
|
||||
size_t (*destructor) (void *));
|
||||
SCM_API void scm_add_slot (SCM c, char *slot, SCM slot_class,
|
||||
SCM (*getter) (SCM obj),
|
||||
SCM (*setter) (SCM obj, SCM x),
|
||||
char *accessor_name);
|
||||
SCM_API SCM scm_wrap_object (SCM c, void *);
|
||||
SCM_API SCM scm_wrap_component (SCM c, SCM obj, void *);
|
||||
SCM_API SCM scm_ensure_accessor (SCM name);
|
||||
SCM_API void scm_add_method (SCM gf, SCM m);
|
||||
|
||||
/* Low level functions exported */
|
||||
SCM scm_make_next_method (SCM methods, SCM args, SCM gf);
|
||||
SCM scm_basic_basic_make_class (SCM c, SCM name, SCM dsupers, SCM dslots);
|
||||
SCM scm_basic_make_class (SCM c, SCM name, SCM dsupers, SCM dslots);
|
||||
SCM_API SCM scm_make_next_method (SCM methods, SCM args, SCM gf);
|
||||
SCM_API SCM scm_basic_basic_make_class (SCM c, SCM name, SCM dsupers, SCM dslots);
|
||||
SCM_API SCM scm_basic_make_class (SCM c, SCM name, SCM dsupers, SCM dslots);
|
||||
|
||||
/* Primitives exported */
|
||||
SCM scm_sys_allocate_instance (SCM c, SCM initargs);
|
||||
SCM scm_sys_set_object_setter_x (SCM obj, SCM setter);
|
||||
SCM scm_slot_ref (SCM obj, SCM slot_name);
|
||||
SCM scm_slot_set_x (SCM obj, SCM slot_name, SCM value);
|
||||
SCM_API SCM scm_sys_allocate_instance (SCM c, SCM initargs);
|
||||
SCM_API SCM scm_sys_set_object_setter_x (SCM obj, SCM setter);
|
||||
SCM_API SCM scm_slot_ref (SCM obj, SCM slot_name);
|
||||
SCM_API SCM scm_slot_set_x (SCM obj, SCM slot_name, SCM value);
|
||||
|
||||
SCM scm_compute_applicable_methods (SCM gf, SCM args, long len, int scm_find_method);
|
||||
SCM scm_sys_compute_applicable_methods (SCM gf, SCM args);
|
||||
SCM scm_m_atslot_ref (SCM xorig, SCM env);
|
||||
SCM scm_m_atslot_set_x (SCM xorig, SCM env);
|
||||
SCM scm_m_atdispatch (SCM xorig, SCM env);
|
||||
SCM_API SCM scm_compute_applicable_methods (SCM gf, SCM args, long len, int scm_find_method);
|
||||
SCM_API SCM scm_sys_compute_applicable_methods (SCM gf, SCM args);
|
||||
SCM_API SCM scm_m_atslot_ref (SCM xorig, SCM env);
|
||||
SCM_API SCM scm_m_atslot_set_x (SCM xorig, SCM env);
|
||||
SCM_API SCM scm_m_atdispatch (SCM xorig, SCM env);
|
||||
#ifdef GUILE_DEBUG
|
||||
SCM scm_pure_generic_p (SCM obj);
|
||||
SCM_API SCM scm_pure_generic_p (SCM obj);
|
||||
#endif
|
||||
|
||||
SCM scm_sys_compute_slots (SCM c);
|
||||
SCM scm_i_get_keyword (SCM key, SCM l, long len, SCM default_value, const char *subr);
|
||||
SCM scm_get_keyword (SCM key, SCM l, SCM default_value);
|
||||
SCM scm_sys_initialize_object (SCM obj, SCM initargs);
|
||||
SCM scm_sys_prep_layout_x (SCM c);
|
||||
SCM scm_sys_inherit_magic_x (SCM c, SCM dsupers);
|
||||
SCM scm_instance_p (SCM obj);
|
||||
SCM scm_class_name (SCM obj);
|
||||
SCM scm_class_direct_supers (SCM obj);
|
||||
SCM scm_class_direct_slots (SCM obj);
|
||||
SCM scm_class_direct_subclasses (SCM obj);
|
||||
SCM scm_class_direct_methods (SCM obj);
|
||||
SCM scm_class_precedence_list (SCM obj);
|
||||
SCM scm_class_slots (SCM obj);
|
||||
SCM scm_class_environment (SCM obj);
|
||||
SCM scm_generic_function_name (SCM obj);
|
||||
SCM scm_generic_function_methods (SCM obj);
|
||||
SCM scm_method_generic_function (SCM obj);
|
||||
SCM scm_method_specializers (SCM obj);
|
||||
SCM scm_method_procedure (SCM obj);
|
||||
SCM scm_accessor_method_slot_definition (SCM obj);
|
||||
SCM scm_sys_tag_body (SCM body);
|
||||
SCM scm_sys_fast_slot_ref (SCM obj, SCM index);
|
||||
SCM scm_sys_fast_slot_set_x (SCM obj, SCM index, SCM value);
|
||||
SCM scm_slot_ref_using_class (SCM cls, SCM obj, SCM slot_name);
|
||||
SCM scm_slot_set_using_class_x (SCM cls, SCM obj, SCM slot_name, SCM value);
|
||||
SCM scm_slot_bound_using_class_p (SCM cls, SCM obj, SCM slot_name);
|
||||
SCM scm_slot_exists_using_class_p (SCM cls, SCM obj, SCM slot_name);
|
||||
SCM scm_slot_bound_p (SCM obj, SCM slot_name);
|
||||
SCM scm_slots_exists_p (SCM obj, SCM slot_name);
|
||||
SCM scm_sys_modify_instance (SCM old, SCM newinst);
|
||||
SCM scm_sys_modify_class (SCM old, SCM newcls);
|
||||
SCM scm_sys_invalidate_class (SCM cls);
|
||||
SCM scm_make_method_cache (SCM gf);
|
||||
SCM scm_sys_invalidate_method_cache_x (SCM gf);
|
||||
SCM scm_generic_capability_p (SCM proc);
|
||||
SCM scm_enable_primitive_generic_x (SCM subrs);
|
||||
SCM scm_primitive_generic_generic (SCM subr);
|
||||
SCM stklos_version (void);
|
||||
SCM scm_make (SCM args);
|
||||
SCM scm_find_method (SCM args);
|
||||
SCM scm_sys_method_more_specific_p (SCM m1, SCM m2, SCM targs);
|
||||
SCM_API SCM scm_sys_compute_slots (SCM c);
|
||||
SCM_API SCM scm_i_get_keyword (SCM key, SCM l, long len, SCM default_value, const char *subr);
|
||||
SCM_API SCM scm_get_keyword (SCM key, SCM l, SCM default_value);
|
||||
SCM_API SCM scm_sys_initialize_object (SCM obj, SCM initargs);
|
||||
SCM_API SCM scm_sys_prep_layout_x (SCM c);
|
||||
SCM_API SCM scm_sys_inherit_magic_x (SCM c, SCM dsupers);
|
||||
SCM_API SCM scm_instance_p (SCM obj);
|
||||
SCM_API SCM scm_class_name (SCM obj);
|
||||
SCM_API SCM scm_class_direct_supers (SCM obj);
|
||||
SCM_API SCM scm_class_direct_slots (SCM obj);
|
||||
SCM_API SCM scm_class_direct_subclasses (SCM obj);
|
||||
SCM_API SCM scm_class_direct_methods (SCM obj);
|
||||
SCM_API SCM scm_class_precedence_list (SCM obj);
|
||||
SCM_API SCM scm_class_slots (SCM obj);
|
||||
SCM_API SCM scm_class_environment (SCM obj);
|
||||
SCM_API SCM scm_generic_function_name (SCM obj);
|
||||
SCM_API SCM scm_generic_function_methods (SCM obj);
|
||||
SCM_API SCM scm_method_generic_function (SCM obj);
|
||||
SCM_API SCM scm_method_specializers (SCM obj);
|
||||
SCM_API SCM scm_method_procedure (SCM obj);
|
||||
SCM_API SCM scm_accessor_method_slot_definition (SCM obj);
|
||||
SCM_API SCM scm_sys_tag_body (SCM body);
|
||||
SCM_API SCM scm_sys_fast_slot_ref (SCM obj, SCM index);
|
||||
SCM_API SCM scm_sys_fast_slot_set_x (SCM obj, SCM index, SCM value);
|
||||
SCM_API SCM scm_slot_ref_using_class (SCM cls, SCM obj, SCM slot_name);
|
||||
SCM_API SCM scm_slot_set_using_class_x (SCM cls, SCM obj, SCM slot_name, SCM value);
|
||||
SCM_API SCM scm_slot_bound_using_class_p (SCM cls, SCM obj, SCM slot_name);
|
||||
SCM_API SCM scm_slot_exists_using_class_p (SCM cls, SCM obj, SCM slot_name);
|
||||
SCM_API SCM scm_slot_bound_p (SCM obj, SCM slot_name);
|
||||
SCM_API SCM scm_slots_exists_p (SCM obj, SCM slot_name);
|
||||
SCM_API SCM scm_sys_modify_instance (SCM old, SCM newinst);
|
||||
SCM_API SCM scm_sys_modify_class (SCM old, SCM newcls);
|
||||
SCM_API SCM scm_sys_invalidate_class (SCM cls);
|
||||
SCM_API SCM scm_make_method_cache (SCM gf);
|
||||
SCM_API SCM scm_sys_invalidate_method_cache_x (SCM gf);
|
||||
SCM_API SCM scm_generic_capability_p (SCM proc);
|
||||
SCM_API SCM scm_enable_primitive_generic_x (SCM subrs);
|
||||
SCM_API SCM scm_primitive_generic_generic (SCM subr);
|
||||
SCM_API SCM stklos_version (void);
|
||||
SCM_API SCM scm_make (SCM args);
|
||||
SCM_API SCM scm_find_method (SCM args);
|
||||
SCM_API SCM scm_sys_method_more_specific_p (SCM m1, SCM m2, SCM targs);
|
||||
|
||||
SCM scm_init_goops_builtins (void);
|
||||
void scm_init_goops (void);
|
||||
SCM_API SCM scm_init_goops_builtins (void);
|
||||
SCM_API void scm_init_goops (void);
|
||||
|
||||
#if (SCM_DEBUG_DEPRECATED == 0)
|
||||
|
||||
|
|
|
@ -61,21 +61,21 @@
|
|||
#define SCM_GSUBR_PROC(cclo) (SCM_CCLO_REF ((cclo), 2))
|
||||
#define SCM_SET_GSUBR_PROC(cclo, proc) (SCM_CCLO_SET ((cclo), 2, (proc)))
|
||||
|
||||
extern SCM scm_f_gsubr_apply;
|
||||
SCM_API SCM scm_f_gsubr_apply;
|
||||
|
||||
extern SCM scm_c_make_gsubr (const char *name,
|
||||
int req, int opt, int rst, SCM (*fcn) ());
|
||||
extern SCM scm_c_make_gsubr_with_generic (const char *name,
|
||||
int req, int opt, int rst,
|
||||
SCM (*fcn) (), SCM *gf);
|
||||
extern SCM scm_c_define_gsubr (const char *name,
|
||||
int req, int opt, int rst, SCM (*fcn) ());
|
||||
extern SCM scm_c_define_gsubr_with_generic (const char *name,
|
||||
int req, int opt, int rst,
|
||||
SCM (*fcn) (), SCM *gf);
|
||||
SCM_API SCM scm_c_make_gsubr (const char *name,
|
||||
int req, int opt, int rst, SCM (*fcn) ());
|
||||
SCM_API SCM scm_c_make_gsubr_with_generic (const char *name,
|
||||
int req, int opt, int rst,
|
||||
SCM (*fcn) (), SCM *gf);
|
||||
SCM_API SCM scm_c_define_gsubr (const char *name,
|
||||
int req, int opt, int rst, SCM (*fcn) ());
|
||||
SCM_API SCM scm_c_define_gsubr_with_generic (const char *name,
|
||||
int req, int opt, int rst,
|
||||
SCM (*fcn) (), SCM *gf);
|
||||
|
||||
extern SCM scm_gsubr_apply (SCM args);
|
||||
extern void scm_init_gsubr (void);
|
||||
SCM_API SCM scm_gsubr_apply (SCM args);
|
||||
SCM_API void scm_init_gsubr (void);
|
||||
|
||||
#endif /* SCM_GSUBR_H */
|
||||
|
||||
|
|
|
@ -48,17 +48,17 @@
|
|||
|
||||
#include "libguile/__scm.h"
|
||||
|
||||
SCM scm_make_guardian (SCM greedy_p);
|
||||
SCM scm_destroy_guardian_x (SCM guardian);
|
||||
SCM_API SCM scm_make_guardian (SCM greedy_p);
|
||||
SCM_API SCM scm_destroy_guardian_x (SCM guardian);
|
||||
|
||||
SCM scm_guardian_greedy_p (SCM guardian);
|
||||
SCM scm_guardian_destroyed_p (SCM guardian);
|
||||
SCM_API SCM scm_guardian_greedy_p (SCM guardian);
|
||||
SCM_API SCM scm_guardian_destroyed_p (SCM guardian);
|
||||
|
||||
/* these are to be called from C: */
|
||||
SCM scm_guard (SCM guardian, SCM obj, int throw_p);
|
||||
SCM scm_get_one_zombie (SCM guardian);
|
||||
SCM_API SCM scm_guard (SCM guardian, SCM obj, int throw_p);
|
||||
SCM_API SCM scm_get_one_zombie (SCM guardian);
|
||||
|
||||
void scm_init_guardians (void);
|
||||
SCM_API void scm_init_guardians (void);
|
||||
|
||||
#endif /* SCM_GUARDIANS_H */
|
||||
|
||||
|
|
|
@ -50,15 +50,15 @@
|
|||
|
||||
|
||||
|
||||
extern unsigned long scm_string_hash (const unsigned char *str, size_t len);
|
||||
extern unsigned long scm_hasher (SCM obj, unsigned long n, size_t d);
|
||||
extern unsigned long scm_ihashq (SCM obj, unsigned long n);
|
||||
extern SCM scm_hashq (SCM obj, SCM n);
|
||||
extern unsigned long scm_ihashv (SCM obj, unsigned long n);
|
||||
extern SCM scm_hashv (SCM obj, SCM n);
|
||||
extern unsigned long scm_ihash (SCM obj, unsigned long n);
|
||||
extern SCM scm_hash (SCM obj, SCM n);
|
||||
extern void scm_init_hash (void);
|
||||
SCM_API unsigned long scm_string_hash (const unsigned char *str, size_t len);
|
||||
SCM_API unsigned long scm_hasher (SCM obj, unsigned long n, size_t d);
|
||||
SCM_API unsigned long scm_ihashq (SCM obj, unsigned long n);
|
||||
SCM_API SCM scm_hashq (SCM obj, SCM n);
|
||||
SCM_API unsigned long scm_ihashv (SCM obj, unsigned long n);
|
||||
SCM_API SCM scm_hashv (SCM obj, SCM n);
|
||||
SCM_API unsigned long scm_ihash (SCM obj, unsigned long n);
|
||||
SCM_API SCM scm_hash (SCM obj, SCM n);
|
||||
SCM_API void scm_init_hash (void);
|
||||
|
||||
#endif /* SCM_HASH_H */
|
||||
|
||||
|
|
|
@ -56,37 +56,37 @@ typedef SCM scm_t_assoc_fn (SCM key, SCM alist, void *closure);
|
|||
typedef SCM scm_t_delete_fn (SCM elt, SCM list);
|
||||
#endif
|
||||
|
||||
extern SCM scm_c_make_hash_table (unsigned long k);
|
||||
SCM_API SCM scm_c_make_hash_table (unsigned long k);
|
||||
|
||||
extern SCM scm_hash_fn_get_handle (SCM table, SCM obj, unsigned long (*hash_fn) (), SCM (*assoc_fn) (), void * closure);
|
||||
extern SCM scm_hash_fn_create_handle_x (SCM table, SCM obj, SCM init, unsigned long (*hash_fn) (), SCM (*assoc_fn) (), void * closure);
|
||||
extern SCM scm_hash_fn_ref (SCM table, SCM obj, SCM dflt, unsigned long (*hash_fn) (), SCM (*assoc_fn) (), void * closure);
|
||||
extern SCM scm_hash_fn_set_x (SCM table, SCM obj, SCM val, unsigned long (*hash_fn) (), SCM (*assoc_fn) (), void * closure);
|
||||
extern SCM scm_hash_fn_remove_x (SCM table, SCM obj, unsigned long (*hash_fn) (), SCM (*assoc_fn) (), SCM (*delete_fn) (), void * closure);
|
||||
extern SCM scm_internal_hash_fold (SCM (*fn) (), void *closure, SCM init, SCM table);
|
||||
SCM_API SCM scm_hash_fn_get_handle (SCM table, SCM obj, unsigned long (*hash_fn) (), SCM (*assoc_fn) (), void * closure);
|
||||
SCM_API SCM scm_hash_fn_create_handle_x (SCM table, SCM obj, SCM init, unsigned long (*hash_fn) (), SCM (*assoc_fn) (), void * closure);
|
||||
SCM_API SCM scm_hash_fn_ref (SCM table, SCM obj, SCM dflt, unsigned long (*hash_fn) (), SCM (*assoc_fn) (), void * closure);
|
||||
SCM_API SCM scm_hash_fn_set_x (SCM table, SCM obj, SCM val, unsigned long (*hash_fn) (), SCM (*assoc_fn) (), void * closure);
|
||||
SCM_API SCM scm_hash_fn_remove_x (SCM table, SCM obj, unsigned long (*hash_fn) (), SCM (*assoc_fn) (), SCM (*delete_fn) (), void * closure);
|
||||
SCM_API SCM scm_internal_hash_fold (SCM (*fn) (), void *closure, SCM init, SCM table);
|
||||
|
||||
extern SCM scm_hashq_get_handle (SCM table, SCM obj);
|
||||
extern SCM scm_hashq_create_handle_x (SCM table, SCM obj, SCM init);
|
||||
extern SCM scm_hashq_ref (SCM table, SCM obj, SCM dflt);
|
||||
extern SCM scm_hashq_set_x (SCM table, SCM obj, SCM val);
|
||||
extern SCM scm_hashq_remove_x (SCM table, SCM obj);
|
||||
extern SCM scm_hashv_get_handle (SCM table, SCM obj);
|
||||
extern SCM scm_hashv_create_handle_x (SCM table, SCM obj, SCM init);
|
||||
extern SCM scm_hashv_ref (SCM table, SCM obj, SCM dflt);
|
||||
extern SCM scm_hashv_set_x (SCM table, SCM obj, SCM val);
|
||||
extern SCM scm_hashv_remove_x (SCM table, SCM obj);
|
||||
extern SCM scm_hash_get_handle (SCM table, SCM obj);
|
||||
extern SCM scm_hash_create_handle_x (SCM table, SCM obj, SCM init);
|
||||
extern SCM scm_hash_ref (SCM table, SCM obj, SCM dflt);
|
||||
extern SCM scm_hash_set_x (SCM table, SCM obj, SCM val);
|
||||
extern SCM scm_hash_remove_x (SCM table, SCM obj);
|
||||
extern SCM scm_hashx_get_handle (SCM hash, SCM assoc, SCM table, SCM obj);
|
||||
extern SCM scm_hashx_create_handle_x (SCM hash, SCM assoc, SCM table, SCM obj, SCM init);
|
||||
extern SCM scm_hashx_ref (SCM hash, SCM assoc, SCM table, SCM obj, SCM dflt);
|
||||
extern SCM scm_hashx_set_x (SCM hash, SCM assoc, SCM table, SCM obj, SCM val);
|
||||
extern SCM scm_hashx_remove_x (SCM hash, SCM assoc, SCM del, SCM table, SCM obj);
|
||||
extern SCM scm_hash_fold (SCM proc, SCM init, SCM hash);
|
||||
extern void scm_init_hashtab (void);
|
||||
SCM_API SCM scm_hashq_get_handle (SCM table, SCM obj);
|
||||
SCM_API SCM scm_hashq_create_handle_x (SCM table, SCM obj, SCM init);
|
||||
SCM_API SCM scm_hashq_ref (SCM table, SCM obj, SCM dflt);
|
||||
SCM_API SCM scm_hashq_set_x (SCM table, SCM obj, SCM val);
|
||||
SCM_API SCM scm_hashq_remove_x (SCM table, SCM obj);
|
||||
SCM_API SCM scm_hashv_get_handle (SCM table, SCM obj);
|
||||
SCM_API SCM scm_hashv_create_handle_x (SCM table, SCM obj, SCM init);
|
||||
SCM_API SCM scm_hashv_ref (SCM table, SCM obj, SCM dflt);
|
||||
SCM_API SCM scm_hashv_set_x (SCM table, SCM obj, SCM val);
|
||||
SCM_API SCM scm_hashv_remove_x (SCM table, SCM obj);
|
||||
SCM_API SCM scm_hash_get_handle (SCM table, SCM obj);
|
||||
SCM_API SCM scm_hash_create_handle_x (SCM table, SCM obj, SCM init);
|
||||
SCM_API SCM scm_hash_ref (SCM table, SCM obj, SCM dflt);
|
||||
SCM_API SCM scm_hash_set_x (SCM table, SCM obj, SCM val);
|
||||
SCM_API SCM scm_hash_remove_x (SCM table, SCM obj);
|
||||
SCM_API SCM scm_hashx_get_handle (SCM hash, SCM assoc, SCM table, SCM obj);
|
||||
SCM_API SCM scm_hashx_create_handle_x (SCM hash, SCM assoc, SCM table, SCM obj, SCM init);
|
||||
SCM_API SCM scm_hashx_ref (SCM hash, SCM assoc, SCM table, SCM obj, SCM dflt);
|
||||
SCM_API SCM scm_hashx_set_x (SCM hash, SCM assoc, SCM table, SCM obj, SCM val);
|
||||
SCM_API SCM scm_hashx_remove_x (SCM hash, SCM assoc, SCM del, SCM table, SCM obj);
|
||||
SCM_API SCM scm_hash_fold (SCM proc, SCM init, SCM hash);
|
||||
SCM_API void scm_init_hashtab (void);
|
||||
|
||||
#endif /* SCM_HASHTAB_H */
|
||||
|
||||
|
|
|
@ -79,39 +79,39 @@ typedef struct scm_t_c_hook {
|
|||
void *data;
|
||||
} scm_t_c_hook;
|
||||
|
||||
extern void scm_c_hook_init (scm_t_c_hook *hook,
|
||||
void *hook_data,
|
||||
scm_t_c_hookype_t type);
|
||||
extern void scm_c_hook_add (scm_t_c_hook *hook,
|
||||
scm_t_c_hook_function func,
|
||||
void *func_data,
|
||||
int appendp);
|
||||
extern void scm_c_hook_remove (scm_t_c_hook *hook,
|
||||
scm_t_c_hook_function func,
|
||||
void *func_data);
|
||||
extern void *scm_c_hook_run (scm_t_c_hook *hook, void *data);
|
||||
SCM_API void scm_c_hook_init (scm_t_c_hook *hook,
|
||||
void *hook_data,
|
||||
scm_t_c_hookype_t type);
|
||||
SCM_API void scm_c_hook_add (scm_t_c_hook *hook,
|
||||
scm_t_c_hook_function func,
|
||||
void *func_data,
|
||||
int appendp);
|
||||
SCM_API void scm_c_hook_remove (scm_t_c_hook *hook,
|
||||
scm_t_c_hook_function func,
|
||||
void *func_data);
|
||||
SCM_API void *scm_c_hook_run (scm_t_c_hook *hook, void *data);
|
||||
|
||||
/*
|
||||
* Scheme level hooks
|
||||
*/
|
||||
|
||||
extern scm_t_bits scm_tc16_hook;
|
||||
SCM_API scm_t_bits scm_tc16_hook;
|
||||
|
||||
#define SCM_HOOKP(x) SCM_TYP16_PREDICATE (scm_tc16_hook, x)
|
||||
#define SCM_HOOK_ARITY(hook) (SCM_CELL_WORD_0 (hook) >> 16)
|
||||
#define SCM_HOOK_PROCEDURES(hook) SCM_CELL_OBJECT_1 (hook)
|
||||
#define SCM_SET_HOOK_PROCEDURES(hook, procs) SCM_SET_CELL_OBJECT_1 ((hook), (procs))
|
||||
|
||||
extern SCM scm_make_hook (SCM n_args);
|
||||
extern SCM scm_hook_p (SCM x);
|
||||
extern SCM scm_hook_empty_p (SCM hook);
|
||||
extern SCM scm_add_hook_x (SCM hook, SCM thunk, SCM appendp);
|
||||
extern SCM scm_remove_hook_x (SCM hook, SCM thunk);
|
||||
extern SCM scm_reset_hook_x (SCM hook);
|
||||
extern SCM scm_run_hook (SCM hook, SCM args);
|
||||
extern void scm_c_run_hook (SCM hook, SCM args);
|
||||
extern SCM scm_hook_to_list (SCM hook);
|
||||
extern void scm_init_hooks (void);
|
||||
SCM_API SCM scm_make_hook (SCM n_args);
|
||||
SCM_API SCM scm_hook_p (SCM x);
|
||||
SCM_API SCM scm_hook_empty_p (SCM hook);
|
||||
SCM_API SCM scm_add_hook_x (SCM hook, SCM thunk, SCM appendp);
|
||||
SCM_API SCM scm_remove_hook_x (SCM hook, SCM thunk);
|
||||
SCM_API SCM scm_reset_hook_x (SCM hook);
|
||||
SCM_API SCM scm_run_hook (SCM hook, SCM args);
|
||||
SCM_API void scm_c_run_hook (SCM hook, SCM args);
|
||||
SCM_API SCM scm_hook_to_list (SCM hook);
|
||||
SCM_API void scm_init_hooks (void);
|
||||
|
||||
#endif /* SCM_HOOKS_H */
|
||||
|
||||
|
|
|
@ -49,17 +49,17 @@
|
|||
#include "libguile/__scm.h"
|
||||
|
||||
|
||||
extern int scm_initialized_p;
|
||||
SCM_API int scm_initialized_p;
|
||||
|
||||
extern void scm_init_guile (void);
|
||||
SCM_API void scm_init_guile (void);
|
||||
|
||||
extern void scm_boot_guile (int argc, char **argv,
|
||||
void (*main_func) (void *closure,
|
||||
int argc,
|
||||
char **argv),
|
||||
void *closure);
|
||||
SCM_API void scm_boot_guile (int argc, char **argv,
|
||||
void (*main_func) (void *closure,
|
||||
int argc,
|
||||
char **argv),
|
||||
void *closure);
|
||||
|
||||
extern void scm_load_startup_files (void);
|
||||
SCM_API void scm_load_startup_files (void);
|
||||
|
||||
#endif /* SCM_INIT_H */
|
||||
|
||||
|
|
|
@ -50,16 +50,16 @@
|
|||
|
||||
|
||||
|
||||
extern SCM scm_ftell (SCM object);
|
||||
extern SCM scm_redirect_port (SCM into_pt, SCM from_pt);
|
||||
extern SCM scm_dup_to_fdes (SCM fd_or_port, SCM newfd);
|
||||
extern SCM scm_dup2 (SCM oldfd, SCM newfd);
|
||||
extern SCM scm_fileno (SCM port);
|
||||
extern SCM scm_isatty_p (SCM port);
|
||||
extern SCM scm_fdopen (SCM fdes, SCM modes);
|
||||
extern SCM scm_primitive_move_to_fdes (SCM port, SCM fd);
|
||||
extern SCM scm_fdes_to_ports (SCM fd);
|
||||
extern void scm_init_ioext (void);
|
||||
SCM_API SCM scm_ftell (SCM object);
|
||||
SCM_API SCM scm_redirect_port (SCM into_pt, SCM from_pt);
|
||||
SCM_API SCM scm_dup_to_fdes (SCM fd_or_port, SCM newfd);
|
||||
SCM_API SCM scm_dup2 (SCM oldfd, SCM newfd);
|
||||
SCM_API SCM scm_fileno (SCM port);
|
||||
SCM_API SCM scm_isatty_p (SCM port);
|
||||
SCM_API SCM scm_fdopen (SCM fdes, SCM modes);
|
||||
SCM_API SCM scm_primitive_move_to_fdes (SCM port, SCM fd);
|
||||
SCM_API SCM scm_fdes_to_ports (SCM fd);
|
||||
SCM_API void scm_init_ioext (void);
|
||||
|
||||
#endif /* SCM_IOEXT_H */
|
||||
|
||||
|
|
|
@ -89,18 +89,18 @@
|
|||
|
||||
#endif /* no FD_SET */
|
||||
|
||||
extern int scm_internal_select (int fds,
|
||||
SELECT_TYPE *rfds,
|
||||
SELECT_TYPE *wfds,
|
||||
SELECT_TYPE *efds,
|
||||
struct timeval *timeout);
|
||||
SCM_API int scm_internal_select (int fds,
|
||||
SELECT_TYPE *rfds,
|
||||
SELECT_TYPE *wfds,
|
||||
SELECT_TYPE *efds,
|
||||
struct timeval *timeout);
|
||||
|
||||
#ifdef GUILE_ISELECT
|
||||
|
||||
extern int scm_I_am_dead;
|
||||
SCM_API int scm_I_am_dead;
|
||||
|
||||
extern void scm_error_revive_threads (void);
|
||||
extern void scm_init_iselect (void);
|
||||
SCM_API void scm_error_revive_threads (void);
|
||||
SCM_API void scm_init_iselect (void);
|
||||
|
||||
#endif /* GUILE_ISELECT */
|
||||
|
||||
|
|
|
@ -50,7 +50,7 @@
|
|||
|
||||
|
||||
|
||||
extern scm_t_bits scm_tc16_keyword;
|
||||
SCM_API scm_t_bits scm_tc16_keyword;
|
||||
|
||||
#define SCM_KEYWORDP(X) (!SCM_IMP (X) && (SCM_CELL_TYPE (X) == scm_tc16_keyword))
|
||||
#define SCM_KEYWORDSYM(X) (SCM_CELL_OBJECT_1 (X))
|
||||
|
@ -58,11 +58,11 @@ extern scm_t_bits scm_tc16_keyword;
|
|||
|
||||
|
||||
|
||||
extern SCM scm_make_keyword_from_dash_symbol (SCM symbol);
|
||||
extern SCM scm_c_make_keyword (char *s);
|
||||
extern SCM scm_keyword_p (SCM obj);
|
||||
extern SCM scm_keyword_dash_symbol (SCM keyword);
|
||||
extern void scm_init_keywords (void);
|
||||
SCM_API SCM scm_make_keyword_from_dash_symbol (SCM symbol);
|
||||
SCM_API SCM scm_c_make_keyword (char *s);
|
||||
SCM_API SCM scm_keyword_p (SCM obj);
|
||||
SCM_API SCM scm_keyword_dash_symbol (SCM keyword);
|
||||
SCM_API void scm_init_keywords (void);
|
||||
|
||||
#endif /* SCM_KEYWORDS_H */
|
||||
|
||||
|
|
|
@ -50,8 +50,8 @@
|
|||
|
||||
|
||||
|
||||
extern SCM scm_lisp_nil;
|
||||
extern SCM scm_lisp_t;
|
||||
SCM_API SCM scm_lisp_nil;
|
||||
SCM_API SCM scm_lisp_t;
|
||||
|
||||
#define SCM_NILP(x) (SCM_EQ_P ((x), scm_lisp_nil))
|
||||
#define SCM_NILNULLP(x) (SCM_NILP (x) || SCM_NULLP (x))
|
||||
|
@ -62,13 +62,13 @@ extern SCM scm_lisp_t;
|
|||
|
||||
|
||||
|
||||
extern SCM scm_nil_cons (SCM x, SCM y);
|
||||
extern SCM scm_nil_car (SCM x);
|
||||
extern SCM scm_nil_cdr (SCM x);
|
||||
extern SCM scm_null (SCM x);
|
||||
extern SCM scm_m_while (SCM exp, SCM env);
|
||||
extern SCM scm_nil_eq (SCM x, SCM y);
|
||||
extern void scm_init_lang (void);
|
||||
SCM_API SCM scm_nil_cons (SCM x, SCM y);
|
||||
SCM_API SCM scm_nil_car (SCM x);
|
||||
SCM_API SCM scm_nil_cdr (SCM x);
|
||||
SCM_API SCM scm_null (SCM x);
|
||||
SCM_API SCM scm_m_while (SCM exp, SCM env);
|
||||
SCM_API SCM scm_nil_eq (SCM x, SCM y);
|
||||
SCM_API void scm_init_lang (void);
|
||||
|
||||
#endif /* SCM_LANG_H */
|
||||
|
||||
|
|
|
@ -50,43 +50,43 @@
|
|||
|
||||
|
||||
|
||||
extern SCM scm_list_1 (SCM e1);
|
||||
extern SCM scm_list_2 (SCM e1, SCM e2);
|
||||
extern SCM scm_list_3 (SCM e1, SCM e2, SCM e3);
|
||||
extern SCM scm_list_4 (SCM e1, SCM e2, SCM e3, SCM e4);
|
||||
extern SCM scm_list_5 (SCM e1, SCM e2, SCM e3, SCM e4, SCM e5);
|
||||
extern SCM scm_list_n (SCM elt, ...);
|
||||
extern SCM scm_list_head (SCM lst, SCM k);
|
||||
extern SCM scm_list (SCM objs);
|
||||
extern SCM scm_cons_star (SCM arg, SCM objs);
|
||||
extern SCM scm_null_p (SCM x);
|
||||
extern SCM scm_list_p (SCM x);
|
||||
extern long scm_ilength (SCM sx);
|
||||
extern SCM scm_length (SCM x);
|
||||
extern SCM scm_append (SCM args);
|
||||
extern SCM scm_append_x (SCM args);
|
||||
extern SCM scm_reverse (SCM lst);
|
||||
extern SCM scm_reverse_x (SCM lst, SCM newtail);
|
||||
extern SCM scm_list_ref (SCM lst, SCM k);
|
||||
extern SCM scm_list_set_x (SCM lst, SCM k, SCM val);
|
||||
extern SCM scm_list_cdr_set_x (SCM lst, SCM k, SCM val);
|
||||
extern SCM scm_last_pair (SCM sx);
|
||||
extern SCM scm_list_tail (SCM lst, SCM k);
|
||||
extern SCM scm_c_memq (SCM x, SCM lst);
|
||||
extern SCM scm_memq (SCM x, SCM lst);
|
||||
extern SCM scm_memv (SCM x, SCM lst);
|
||||
extern SCM scm_member (SCM x, SCM lst);
|
||||
extern SCM scm_delq_x (SCM item, SCM lst);
|
||||
extern SCM scm_delv_x (SCM item, SCM lst);
|
||||
extern SCM scm_delete_x (SCM item, SCM lst);
|
||||
extern SCM scm_list_copy (SCM lst);
|
||||
extern SCM scm_delq (SCM item, SCM lst);
|
||||
extern SCM scm_delv (SCM item, SCM lst);
|
||||
extern SCM scm_delete (SCM item, SCM lst);
|
||||
extern SCM scm_delq1_x (SCM item, SCM lst);
|
||||
extern SCM scm_delv1_x (SCM item, SCM lst);
|
||||
extern SCM scm_delete1_x (SCM item, SCM lst);
|
||||
extern void scm_init_list (void);
|
||||
SCM_API SCM scm_list_1 (SCM e1);
|
||||
SCM_API SCM scm_list_2 (SCM e1, SCM e2);
|
||||
SCM_API SCM scm_list_3 (SCM e1, SCM e2, SCM e3);
|
||||
SCM_API SCM scm_list_4 (SCM e1, SCM e2, SCM e3, SCM e4);
|
||||
SCM_API SCM scm_list_5 (SCM e1, SCM e2, SCM e3, SCM e4, SCM e5);
|
||||
SCM_API SCM scm_list_n (SCM elt, ...);
|
||||
SCM_API SCM scm_list_head (SCM lst, SCM k);
|
||||
SCM_API SCM scm_list (SCM objs);
|
||||
SCM_API SCM scm_cons_star (SCM arg, SCM objs);
|
||||
SCM_API SCM scm_null_p (SCM x);
|
||||
SCM_API SCM scm_list_p (SCM x);
|
||||
SCM_API long scm_ilength (SCM sx);
|
||||
SCM_API SCM scm_length (SCM x);
|
||||
SCM_API SCM scm_append (SCM args);
|
||||
SCM_API SCM scm_append_x (SCM args);
|
||||
SCM_API SCM scm_reverse (SCM lst);
|
||||
SCM_API SCM scm_reverse_x (SCM lst, SCM newtail);
|
||||
SCM_API SCM scm_list_ref (SCM lst, SCM k);
|
||||
SCM_API SCM scm_list_set_x (SCM lst, SCM k, SCM val);
|
||||
SCM_API SCM scm_list_cdr_set_x (SCM lst, SCM k, SCM val);
|
||||
SCM_API SCM scm_last_pair (SCM sx);
|
||||
SCM_API SCM scm_list_tail (SCM lst, SCM k);
|
||||
SCM_API SCM scm_c_memq (SCM x, SCM lst);
|
||||
SCM_API SCM scm_memq (SCM x, SCM lst);
|
||||
SCM_API SCM scm_memv (SCM x, SCM lst);
|
||||
SCM_API SCM scm_member (SCM x, SCM lst);
|
||||
SCM_API SCM scm_delq_x (SCM item, SCM lst);
|
||||
SCM_API SCM scm_delv_x (SCM item, SCM lst);
|
||||
SCM_API SCM scm_delete_x (SCM item, SCM lst);
|
||||
SCM_API SCM scm_list_copy (SCM lst);
|
||||
SCM_API SCM scm_delq (SCM item, SCM lst);
|
||||
SCM_API SCM scm_delv (SCM item, SCM lst);
|
||||
SCM_API SCM scm_delete (SCM item, SCM lst);
|
||||
SCM_API SCM scm_delq1_x (SCM item, SCM lst);
|
||||
SCM_API SCM scm_delv1_x (SCM item, SCM lst);
|
||||
SCM_API SCM scm_delete1_x (SCM item, SCM lst);
|
||||
SCM_API void scm_init_list (void);
|
||||
|
||||
#endif /* SCM_LIST_H */
|
||||
|
||||
|
|
|
@ -49,19 +49,19 @@
|
|||
#include "libguile/__scm.h"
|
||||
|
||||
|
||||
extern SCM scm_internal_parse_path (char *path, SCM tail);
|
||||
extern SCM scm_parse_path (SCM path, SCM tail);
|
||||
extern void scm_init_load_path (void);
|
||||
extern SCM scm_primitive_load (SCM filename);
|
||||
extern SCM scm_c_primitive_load (const char *filename);
|
||||
extern SCM scm_sys_package_data_dir (void);
|
||||
extern SCM scm_sys_library_dir (void);
|
||||
extern SCM scm_sys_site_dir (void);
|
||||
extern SCM scm_search_path (SCM path, SCM filename, SCM exts);
|
||||
extern SCM scm_sys_search_load_path (SCM filename);
|
||||
extern SCM scm_primitive_load_path (SCM filename);
|
||||
extern SCM scm_c_primitive_load_path (const char *filename);
|
||||
extern void scm_init_load (void);
|
||||
SCM_API SCM scm_internal_parse_path (char *path, SCM tail);
|
||||
SCM_API SCM scm_parse_path (SCM path, SCM tail);
|
||||
SCM_API void scm_init_load_path (void);
|
||||
SCM_API SCM scm_primitive_load (SCM filename);
|
||||
SCM_API SCM scm_c_primitive_load (const char *filename);
|
||||
SCM_API SCM scm_sys_package_data_dir (void);
|
||||
SCM_API SCM scm_sys_library_dir (void);
|
||||
SCM_API SCM scm_sys_site_dir (void);
|
||||
SCM_API SCM scm_search_path (SCM path, SCM filename, SCM exts);
|
||||
SCM_API SCM scm_sys_search_load_path (SCM filename);
|
||||
SCM_API SCM scm_primitive_load_path (SCM filename);
|
||||
SCM_API SCM scm_c_primitive_load_path (const char *filename);
|
||||
SCM_API void scm_init_load (void);
|
||||
|
||||
#endif /* SCM_LOAD_H */
|
||||
|
||||
|
|
|
@ -57,19 +57,19 @@
|
|||
#define SCM_MACRO_TYPE(m) (SCM_CELL_WORD_0 (m) >> 16)
|
||||
#define SCM_MACRO_CODE(m) SCM_CELL_OBJECT_1 (m)
|
||||
|
||||
extern scm_t_bits scm_tc16_macro;
|
||||
SCM_API scm_t_bits scm_tc16_macro;
|
||||
|
||||
extern SCM scm_makacro (SCM code);
|
||||
extern SCM scm_makmacro (SCM code);
|
||||
extern SCM scm_makmmacro (SCM code);
|
||||
extern SCM scm_macro_p (SCM obj);
|
||||
extern SCM scm_macro_type (SCM m);
|
||||
extern SCM scm_macro_name (SCM m);
|
||||
extern SCM scm_macro_transformer (SCM m);
|
||||
extern SCM scm_make_synt (const char *name,
|
||||
SCM (*macroizer) (SCM),
|
||||
SCM (*fcn) ());
|
||||
extern void scm_init_macros (void);
|
||||
SCM_API SCM scm_makacro (SCM code);
|
||||
SCM_API SCM scm_makmacro (SCM code);
|
||||
SCM_API SCM scm_makmmacro (SCM code);
|
||||
SCM_API SCM scm_macro_p (SCM obj);
|
||||
SCM_API SCM scm_macro_type (SCM m);
|
||||
SCM_API SCM scm_macro_name (SCM m);
|
||||
SCM_API SCM scm_macro_transformer (SCM m);
|
||||
SCM_API SCM scm_make_synt (const char *name,
|
||||
SCM (*macroizer) (SCM),
|
||||
SCM (*fcn) ());
|
||||
SCM_API void scm_init_macros (void);
|
||||
|
||||
#endif /* SCM_MACROS_H */
|
||||
|
||||
|
|
|
@ -49,7 +49,7 @@
|
|||
#include "libguile/__scm.h"
|
||||
|
||||
|
||||
extern scm_t_bits scm_tc16_malloc;
|
||||
SCM_API scm_t_bits scm_tc16_malloc;
|
||||
|
||||
#define SCM_MALLOCP(X) (SCM_TYP16 (X) == scm_tc16_malloc)
|
||||
#define SCM_MALLOCDATA(obj) ((char *) SCM_CELL_WORD_1 (obj))
|
||||
|
@ -57,8 +57,8 @@ extern scm_t_bits scm_tc16_malloc;
|
|||
|
||||
|
||||
|
||||
extern SCM scm_malloc_obj (size_t n);
|
||||
extern void scm_init_mallocs (void);
|
||||
SCM_API SCM scm_malloc_obj (size_t n);
|
||||
SCM_API void scm_init_mallocs (void);
|
||||
|
||||
#endif /* SCM_MALLOCS_H */
|
||||
|
||||
|
|
|
@ -52,8 +52,8 @@
|
|||
|
||||
|
||||
|
||||
extern int scm_module_system_booted_p;
|
||||
extern scm_t_bits scm_module_tag;
|
||||
SCM_API int scm_module_system_booted_p;
|
||||
SCM_API scm_t_bits scm_module_tag;
|
||||
|
||||
#define SCM_MODULEP(OBJ) \
|
||||
(!SCM_IMP (OBJ) && SCM_CELL_TYPE (OBJ) == scm_module_tag)
|
||||
|
@ -81,56 +81,56 @@ extern scm_t_bits scm_module_tag;
|
|||
#define SCM_MODULE_TRANSFORMER(module) \
|
||||
SCM_PACK (SCM_STRUCT_DATA (module)[scm_module_index_transformer])
|
||||
|
||||
extern scm_t_bits scm_tc16_eval_closure;
|
||||
SCM_API scm_t_bits scm_tc16_eval_closure;
|
||||
|
||||
#define SCM_EVAL_CLOSURE_P(x) SCM_TYP16_PREDICATE (scm_tc16_eval_closure, x)
|
||||
|
||||
|
||||
|
||||
extern SCM scm_current_module (void);
|
||||
extern SCM scm_interaction_environment (void);
|
||||
extern SCM scm_set_current_module (SCM module);
|
||||
SCM_API SCM scm_current_module (void);
|
||||
SCM_API SCM scm_interaction_environment (void);
|
||||
SCM_API SCM scm_set_current_module (SCM module);
|
||||
|
||||
extern SCM scm_c_call_with_current_module (SCM module,
|
||||
SCM (*func)(void *), void *data);
|
||||
SCM_API SCM scm_c_call_with_current_module (SCM module,
|
||||
SCM (*func)(void *), void *data);
|
||||
|
||||
extern SCM scm_c_lookup (const char *name);
|
||||
extern SCM scm_c_define (const char *name, SCM val);
|
||||
extern SCM scm_lookup (SCM symbol);
|
||||
extern SCM scm_define (SCM symbol, SCM val);
|
||||
SCM_API SCM scm_c_lookup (const char *name);
|
||||
SCM_API SCM scm_c_define (const char *name, SCM val);
|
||||
SCM_API SCM scm_lookup (SCM symbol);
|
||||
SCM_API SCM scm_define (SCM symbol, SCM val);
|
||||
|
||||
extern SCM scm_c_module_lookup (SCM module, const char *name);
|
||||
extern SCM scm_c_module_define (SCM module, const char *name, SCM val);
|
||||
extern SCM scm_module_lookup (SCM module, SCM symbol);
|
||||
extern SCM scm_module_define (SCM module, SCM symbol, SCM val);
|
||||
extern SCM scm_module_reverse_lookup (SCM module, SCM variable);
|
||||
SCM_API SCM scm_c_module_lookup (SCM module, const char *name);
|
||||
SCM_API SCM scm_c_module_define (SCM module, const char *name, SCM val);
|
||||
SCM_API SCM scm_module_lookup (SCM module, SCM symbol);
|
||||
SCM_API SCM scm_module_define (SCM module, SCM symbol, SCM val);
|
||||
SCM_API SCM scm_module_reverse_lookup (SCM module, SCM variable);
|
||||
|
||||
extern SCM scm_c_resolve_module (const char *name);
|
||||
extern SCM scm_resolve_module (SCM name);
|
||||
extern SCM scm_c_define_module (const char *name,
|
||||
void (*init)(void *), void *data);
|
||||
extern void scm_c_use_module (const char *name);
|
||||
extern void scm_c_export (const char *name, ...);
|
||||
SCM_API SCM scm_c_resolve_module (const char *name);
|
||||
SCM_API SCM scm_resolve_module (SCM name);
|
||||
SCM_API SCM scm_c_define_module (const char *name,
|
||||
void (*init)(void *), void *data);
|
||||
SCM_API void scm_c_use_module (const char *name);
|
||||
SCM_API void scm_c_export (const char *name, ...);
|
||||
|
||||
extern SCM scm_sym2var (SCM sym, SCM thunk, SCM definep);
|
||||
SCM_API SCM scm_sym2var (SCM sym, SCM thunk, SCM definep);
|
||||
|
||||
extern SCM scm_module_lookup_closure (SCM module);
|
||||
extern SCM scm_module_transformer (SCM module);
|
||||
extern SCM scm_current_module_lookup_closure (void);
|
||||
extern SCM scm_current_module_transformer (void);
|
||||
extern SCM scm_eval_closure_lookup (SCM eclo, SCM sym, SCM definep);
|
||||
extern SCM scm_standard_eval_closure (SCM module);
|
||||
extern SCM scm_standard_interface_eval_closure (SCM module);
|
||||
extern SCM scm_get_pre_modules_obarray (void);
|
||||
extern SCM scm_lookup_closure_module (SCM proc);
|
||||
SCM_API SCM scm_module_lookup_closure (SCM module);
|
||||
SCM_API SCM scm_module_transformer (SCM module);
|
||||
SCM_API SCM scm_current_module_lookup_closure (void);
|
||||
SCM_API SCM scm_current_module_transformer (void);
|
||||
SCM_API SCM scm_eval_closure_lookup (SCM eclo, SCM sym, SCM definep);
|
||||
SCM_API SCM scm_standard_eval_closure (SCM module);
|
||||
SCM_API SCM scm_standard_interface_eval_closure (SCM module);
|
||||
SCM_API SCM scm_get_pre_modules_obarray (void);
|
||||
SCM_API SCM scm_lookup_closure_module (SCM proc);
|
||||
|
||||
extern SCM scm_env_top_level (SCM env);
|
||||
extern SCM scm_env_module (SCM env);
|
||||
extern SCM scm_top_level_env (SCM thunk);
|
||||
extern SCM scm_system_module_env_p (SCM env);
|
||||
SCM_API SCM scm_env_top_level (SCM env);
|
||||
SCM_API SCM scm_env_module (SCM env);
|
||||
SCM_API SCM scm_top_level_env (SCM thunk);
|
||||
SCM_API SCM scm_system_module_env_p (SCM env);
|
||||
|
||||
extern void scm_modules_prehistory (void);
|
||||
extern void scm_init_modules (void);
|
||||
SCM_API void scm_modules_prehistory (void);
|
||||
SCM_API void scm_init_modules (void);
|
||||
|
||||
#endif /* SCM_MODULES_H */
|
||||
|
||||
|
|
|
@ -50,15 +50,15 @@
|
|||
|
||||
|
||||
|
||||
extern SCM scm_gethost (SCM host);
|
||||
extern SCM scm_getnet (SCM name);
|
||||
extern SCM scm_getproto (SCM name);
|
||||
extern SCM scm_getserv (SCM name, SCM proto);
|
||||
extern SCM scm_sethost (SCM arg);
|
||||
extern SCM scm_setnet (SCM arg);
|
||||
extern SCM scm_setproto (SCM arg);
|
||||
extern SCM scm_setserv (SCM arg);
|
||||
extern void scm_init_net_db (void);
|
||||
SCM_API SCM scm_gethost (SCM host);
|
||||
SCM_API SCM scm_getnet (SCM name);
|
||||
SCM_API SCM scm_getproto (SCM name);
|
||||
SCM_API SCM scm_getserv (SCM name, SCM proto);
|
||||
SCM_API SCM scm_sethost (SCM arg);
|
||||
SCM_API SCM scm_setnet (SCM arg);
|
||||
SCM_API SCM scm_setproto (SCM arg);
|
||||
SCM_API SCM scm_setserv (SCM arg);
|
||||
SCM_API void scm_init_net_db (void);
|
||||
|
||||
#endif /* SCM_NET_DB_H */
|
||||
|
||||
|
|
|
@ -93,13 +93,13 @@ INTEGRAL2NUM (ITYPE n)
|
|||
#define NEED_CHECK
|
||||
#else
|
||||
#ifdef UNSIGNED
|
||||
#if MAX_VALUE > SCM_MOST_POSITIVE_FIXNUM
|
||||
/*#if MAX_VALUE > SCM_MOST_POSITIVE_FIXNUM*/
|
||||
#define NEED_CHECK
|
||||
#endif
|
||||
/*#endif*/
|
||||
#else
|
||||
#if MIN_VALUE<SCM_MOST_NEGATIVE_FIXNUM || MAX_VALUE>SCM_MOST_POSITIVE_FIXNUM
|
||||
/*#if MIN_VALUE<SCM_MOST_NEGATIVE_FIXNUM || MAX_VALUE>SCM_MOST_POSITIVE_FIXNUM*/
|
||||
#define NEED_CHECK
|
||||
#endif
|
||||
/*#endif*/
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
|
|
@ -4415,9 +4415,7 @@ check_sanity ()
|
|||
#ifdef HAVE_LONG_LONGS
|
||||
CHECK (long_long, 0LL);
|
||||
CHECK (ulong_long, 0ULL);
|
||||
|
||||
CHECK (long_long, -1LL);
|
||||
|
||||
CHECK (long_long, LLONG_MAX);
|
||||
CHECK (long_long, LLONG_MIN);
|
||||
CHECK (ulong_long, ULLONG_MAX);
|
||||
|
|
|
@ -198,142 +198,142 @@ typedef struct scm_t_complex
|
|||
|
||||
|
||||
|
||||
extern SCM scm_exact_p (SCM x);
|
||||
extern SCM scm_odd_p (SCM n);
|
||||
extern SCM scm_even_p (SCM n);
|
||||
extern SCM scm_abs (SCM x);
|
||||
extern SCM scm_quotient (SCM x, SCM y);
|
||||
extern SCM scm_remainder (SCM x, SCM y);
|
||||
extern SCM scm_modulo (SCM x, SCM y);
|
||||
extern SCM scm_gcd (SCM x, SCM y);
|
||||
extern SCM scm_lcm (SCM n1, SCM n2);
|
||||
extern SCM scm_logand (SCM n1, SCM n2);
|
||||
extern SCM scm_logior (SCM n1, SCM n2);
|
||||
extern SCM scm_logxor (SCM n1, SCM n2);
|
||||
extern SCM scm_logtest (SCM n1, SCM n2);
|
||||
extern SCM scm_logbit_p (SCM n1, SCM n2);
|
||||
extern SCM scm_lognot (SCM n);
|
||||
extern SCM scm_integer_expt (SCM z1, SCM z2);
|
||||
extern SCM scm_ash (SCM n, SCM cnt);
|
||||
extern SCM scm_bit_extract (SCM n, SCM start, SCM end);
|
||||
extern SCM scm_logcount (SCM n);
|
||||
extern SCM scm_integer_length (SCM n);
|
||||
extern SCM scm_i_mkbig (size_t nlen, int sign);
|
||||
extern SCM scm_i_big2inum (SCM b, size_t l);
|
||||
extern SCM scm_i_adjbig (SCM b, size_t nlen);
|
||||
extern SCM scm_i_normbig (SCM b);
|
||||
extern SCM scm_i_copybig (SCM b, int sign);
|
||||
extern SCM scm_i_short2big (short n);
|
||||
extern SCM scm_i_ushort2big (unsigned short n);
|
||||
extern SCM scm_i_int2big (int n);
|
||||
extern SCM scm_i_uint2big (unsigned int n);
|
||||
extern SCM scm_i_long2big (long n);
|
||||
extern SCM scm_i_ulong2big (unsigned long n);
|
||||
extern SCM scm_i_size2big (size_t n);
|
||||
extern SCM scm_i_ptrdiff2big (ptrdiff_t n);
|
||||
SCM_API SCM scm_exact_p (SCM x);
|
||||
SCM_API SCM scm_odd_p (SCM n);
|
||||
SCM_API SCM scm_even_p (SCM n);
|
||||
SCM_API SCM scm_abs (SCM x);
|
||||
SCM_API SCM scm_quotient (SCM x, SCM y);
|
||||
SCM_API SCM scm_remainder (SCM x, SCM y);
|
||||
SCM_API SCM scm_modulo (SCM x, SCM y);
|
||||
SCM_API SCM scm_gcd (SCM x, SCM y);
|
||||
SCM_API SCM scm_lcm (SCM n1, SCM n2);
|
||||
SCM_API SCM scm_logand (SCM n1, SCM n2);
|
||||
SCM_API SCM scm_logior (SCM n1, SCM n2);
|
||||
SCM_API SCM scm_logxor (SCM n1, SCM n2);
|
||||
SCM_API SCM scm_logtest (SCM n1, SCM n2);
|
||||
SCM_API SCM scm_logbit_p (SCM n1, SCM n2);
|
||||
SCM_API SCM scm_lognot (SCM n);
|
||||
SCM_API SCM scm_integer_expt (SCM z1, SCM z2);
|
||||
SCM_API SCM scm_ash (SCM n, SCM cnt);
|
||||
SCM_API SCM scm_bit_extract (SCM n, SCM start, SCM end);
|
||||
SCM_API SCM scm_logcount (SCM n);
|
||||
SCM_API SCM scm_integer_length (SCM n);
|
||||
SCM_API SCM scm_i_mkbig (size_t nlen, int sign);
|
||||
SCM_API SCM scm_i_big2inum (SCM b, size_t l);
|
||||
SCM_API SCM scm_i_adjbig (SCM b, size_t nlen);
|
||||
SCM_API SCM scm_i_normbig (SCM b);
|
||||
SCM_API SCM scm_i_copybig (SCM b, int sign);
|
||||
SCM_API SCM scm_i_short2big (short n);
|
||||
SCM_API SCM scm_i_ushort2big (unsigned short n);
|
||||
SCM_API SCM scm_i_int2big (int n);
|
||||
SCM_API SCM scm_i_uint2big (unsigned int n);
|
||||
SCM_API SCM scm_i_long2big (long n);
|
||||
SCM_API SCM scm_i_ulong2big (unsigned long n);
|
||||
SCM_API SCM scm_i_size2big (size_t n);
|
||||
SCM_API SCM scm_i_ptrdiff2big (ptrdiff_t n);
|
||||
|
||||
#ifdef HAVE_LONG_LONGS
|
||||
extern SCM scm_i_long_long2big (long long n);
|
||||
extern SCM scm_i_ulong_long2big (unsigned long long n);
|
||||
SCM_API SCM scm_i_long_long2big (long long n);
|
||||
SCM_API SCM scm_i_ulong_long2big (unsigned long long n);
|
||||
#endif
|
||||
|
||||
extern int scm_bigcomp (SCM x, SCM y);
|
||||
extern long scm_pseudolong (long x);
|
||||
extern void scm_longdigs (long x, SCM_BIGDIG digs[]);
|
||||
extern SCM scm_addbig (SCM_BIGDIG *x, size_t nx, int xsgn, SCM bigy, int sgny);
|
||||
extern SCM scm_mulbig (SCM_BIGDIG *x, size_t nx, SCM_BIGDIG *y, size_t ny, int sgn);
|
||||
extern unsigned int scm_divbigdig (SCM_BIGDIG *ds, size_t h, SCM_BIGDIG div);
|
||||
extern size_t scm_iint2str (long num, int rad, char *p);
|
||||
extern SCM scm_number_to_string (SCM x, SCM radix);
|
||||
extern int scm_print_real (SCM sexp, SCM port, scm_print_state *pstate);
|
||||
extern int scm_print_complex (SCM sexp, SCM port, scm_print_state *pstate);
|
||||
extern int scm_bigprint (SCM exp, SCM port, scm_print_state *pstate);
|
||||
extern SCM scm_i_mem2number (const char *mem, size_t len, unsigned int radix);
|
||||
extern SCM scm_string_to_number (SCM str, SCM radix);
|
||||
extern SCM scm_make_real (double x);
|
||||
extern SCM scm_make_complex (double x, double y);
|
||||
extern SCM scm_bigequal (SCM x, SCM y);
|
||||
extern SCM scm_real_equalp (SCM x, SCM y);
|
||||
extern SCM scm_complex_equalp (SCM x, SCM y);
|
||||
extern SCM scm_number_p (SCM x);
|
||||
extern SCM scm_real_p (SCM x);
|
||||
extern SCM scm_integer_p (SCM x);
|
||||
extern SCM scm_inexact_p (SCM x);
|
||||
extern SCM scm_num_eq_p (SCM x, SCM y);
|
||||
extern SCM scm_less_p (SCM x, SCM y);
|
||||
extern SCM scm_gr_p (SCM x, SCM y);
|
||||
extern SCM scm_leq_p (SCM x, SCM y);
|
||||
extern SCM scm_geq_p (SCM x, SCM y);
|
||||
extern SCM scm_zero_p (SCM z);
|
||||
extern SCM scm_positive_p (SCM x);
|
||||
extern SCM scm_negative_p (SCM x);
|
||||
extern SCM scm_max (SCM x, SCM y);
|
||||
extern SCM scm_min (SCM x, SCM y);
|
||||
extern SCM scm_sum (SCM x, SCM y);
|
||||
extern SCM scm_difference (SCM x, SCM y);
|
||||
extern SCM scm_product (SCM x, SCM y);
|
||||
extern double scm_num2dbl (SCM a, const char * why);
|
||||
extern SCM scm_divide (SCM x, SCM y);
|
||||
extern double scm_asinh (double x);
|
||||
extern double scm_acosh (double x);
|
||||
extern double scm_atanh (double x);
|
||||
extern double scm_truncate (double x);
|
||||
extern double scm_round (double x);
|
||||
extern SCM scm_sys_expt (SCM z1, SCM z2);
|
||||
extern SCM scm_sys_atan2 (SCM z1, SCM z2);
|
||||
extern SCM scm_make_rectangular (SCM z1, SCM z2);
|
||||
extern SCM scm_make_polar (SCM z1, SCM z2);
|
||||
extern SCM scm_real_part (SCM z);
|
||||
extern SCM scm_imag_part (SCM z);
|
||||
extern SCM scm_magnitude (SCM z);
|
||||
extern SCM scm_angle (SCM z);
|
||||
extern SCM scm_exact_to_inexact (SCM z);
|
||||
extern SCM scm_inexact_to_exact (SCM z);
|
||||
extern SCM scm_trunc (SCM x);
|
||||
extern SCM scm_i_dbl2big (double d);
|
||||
extern double scm_i_big2dbl (SCM b);
|
||||
SCM_API int scm_bigcomp (SCM x, SCM y);
|
||||
SCM_API long scm_pseudolong (long x);
|
||||
SCM_API void scm_longdigs (long x, SCM_BIGDIG digs[]);
|
||||
SCM_API SCM scm_addbig (SCM_BIGDIG *x, size_t nx, int xsgn, SCM bigy, int sgny);
|
||||
SCM_API SCM scm_mulbig (SCM_BIGDIG *x, size_t nx, SCM_BIGDIG *y, size_t ny, int sgn);
|
||||
SCM_API unsigned int scm_divbigdig (SCM_BIGDIG *ds, size_t h, SCM_BIGDIG div);
|
||||
SCM_API size_t scm_iint2str (long num, int rad, char *p);
|
||||
SCM_API SCM scm_number_to_string (SCM x, SCM radix);
|
||||
SCM_API int scm_print_real (SCM sexp, SCM port, scm_print_state *pstate);
|
||||
SCM_API int scm_print_complex (SCM sexp, SCM port, scm_print_state *pstate);
|
||||
SCM_API int scm_bigprint (SCM exp, SCM port, scm_print_state *pstate);
|
||||
SCM_API SCM scm_i_mem2number (const char *mem, size_t len, unsigned int radix);
|
||||
SCM_API SCM scm_string_to_number (SCM str, SCM radix);
|
||||
SCM_API SCM scm_make_real (double x);
|
||||
SCM_API SCM scm_make_complex (double x, double y);
|
||||
SCM_API SCM scm_bigequal (SCM x, SCM y);
|
||||
SCM_API SCM scm_real_equalp (SCM x, SCM y);
|
||||
SCM_API SCM scm_complex_equalp (SCM x, SCM y);
|
||||
SCM_API SCM scm_number_p (SCM x);
|
||||
SCM_API SCM scm_real_p (SCM x);
|
||||
SCM_API SCM scm_integer_p (SCM x);
|
||||
SCM_API SCM scm_inexact_p (SCM x);
|
||||
SCM_API SCM scm_num_eq_p (SCM x, SCM y);
|
||||
SCM_API SCM scm_less_p (SCM x, SCM y);
|
||||
SCM_API SCM scm_gr_p (SCM x, SCM y);
|
||||
SCM_API SCM scm_leq_p (SCM x, SCM y);
|
||||
SCM_API SCM scm_geq_p (SCM x, SCM y);
|
||||
SCM_API SCM scm_zero_p (SCM z);
|
||||
SCM_API SCM scm_positive_p (SCM x);
|
||||
SCM_API SCM scm_negative_p (SCM x);
|
||||
SCM_API SCM scm_max (SCM x, SCM y);
|
||||
SCM_API SCM scm_min (SCM x, SCM y);
|
||||
SCM_API SCM scm_sum (SCM x, SCM y);
|
||||
SCM_API SCM scm_difference (SCM x, SCM y);
|
||||
SCM_API SCM scm_product (SCM x, SCM y);
|
||||
SCM_API double scm_num2dbl (SCM a, const char * why);
|
||||
SCM_API SCM scm_divide (SCM x, SCM y);
|
||||
SCM_API double scm_asinh (double x);
|
||||
SCM_API double scm_acosh (double x);
|
||||
SCM_API double scm_atanh (double x);
|
||||
SCM_API double scm_truncate (double x);
|
||||
SCM_API double scm_round (double x);
|
||||
SCM_API SCM scm_sys_expt (SCM z1, SCM z2);
|
||||
SCM_API SCM scm_sys_atan2 (SCM z1, SCM z2);
|
||||
SCM_API SCM scm_make_rectangular (SCM z1, SCM z2);
|
||||
SCM_API SCM scm_make_polar (SCM z1, SCM z2);
|
||||
SCM_API SCM scm_real_part (SCM z);
|
||||
SCM_API SCM scm_imag_part (SCM z);
|
||||
SCM_API SCM scm_magnitude (SCM z);
|
||||
SCM_API SCM scm_angle (SCM z);
|
||||
SCM_API SCM scm_exact_to_inexact (SCM z);
|
||||
SCM_API SCM scm_inexact_to_exact (SCM z);
|
||||
SCM_API SCM scm_trunc (SCM x);
|
||||
SCM_API SCM scm_i_dbl2big (double d);
|
||||
SCM_API double scm_i_big2dbl (SCM b);
|
||||
|
||||
extern SCM scm_short2num (short n);
|
||||
extern SCM scm_ushort2num (unsigned short n);
|
||||
extern SCM scm_int2num (int n);
|
||||
extern SCM scm_uint2num (unsigned int n);
|
||||
extern SCM scm_long2num (long n);
|
||||
extern SCM scm_ulong2num (unsigned long n);
|
||||
extern SCM scm_size2num (size_t n);
|
||||
extern SCM scm_ptrdiff2num (ptrdiff_t n);
|
||||
extern short scm_num2short (SCM num, unsigned long int pos,
|
||||
const char *s_caller);
|
||||
extern unsigned short scm_num2ushort (SCM num, unsigned long int pos,
|
||||
const char *s_caller);
|
||||
extern int scm_num2int (SCM num, unsigned long int pos,
|
||||
const char *s_caller);
|
||||
extern unsigned int scm_num2uint (SCM num, unsigned long int pos,
|
||||
const char *s_caller);
|
||||
extern long scm_num2long (SCM num, unsigned long int pos,
|
||||
const char *s_caller);
|
||||
extern unsigned long scm_num2ulong (SCM num, unsigned long int pos,
|
||||
const char *s_caller);
|
||||
extern ptrdiff_t scm_num2ptrdiff (SCM num, unsigned long int pos,
|
||||
const char *s_caller);
|
||||
extern size_t scm_num2size (SCM num, unsigned long int pos,
|
||||
const char *s_caller);
|
||||
SCM_API SCM scm_short2num (short n);
|
||||
SCM_API SCM scm_ushort2num (unsigned short n);
|
||||
SCM_API SCM scm_int2num (int n);
|
||||
SCM_API SCM scm_uint2num (unsigned int n);
|
||||
SCM_API SCM scm_long2num (long n);
|
||||
SCM_API SCM scm_ulong2num (unsigned long n);
|
||||
SCM_API SCM scm_size2num (size_t n);
|
||||
SCM_API SCM scm_ptrdiff2num (ptrdiff_t n);
|
||||
SCM_API short scm_num2short (SCM num, unsigned long int pos,
|
||||
const char *s_caller);
|
||||
SCM_API unsigned short scm_num2ushort (SCM num, unsigned long int pos,
|
||||
const char *s_caller);
|
||||
SCM_API int scm_num2int (SCM num, unsigned long int pos,
|
||||
const char *s_caller);
|
||||
SCM_API unsigned int scm_num2uint (SCM num, unsigned long int pos,
|
||||
const char *s_caller);
|
||||
SCM_API long scm_num2long (SCM num, unsigned long int pos,
|
||||
const char *s_caller);
|
||||
SCM_API unsigned long scm_num2ulong (SCM num, unsigned long int pos,
|
||||
const char *s_caller);
|
||||
SCM_API ptrdiff_t scm_num2ptrdiff (SCM num, unsigned long int pos,
|
||||
const char *s_caller);
|
||||
SCM_API size_t scm_num2size (SCM num, unsigned long int pos,
|
||||
const char *s_caller);
|
||||
#ifdef HAVE_LONG_LONGS
|
||||
extern SCM scm_long_long2num (long long sl);
|
||||
extern SCM scm_ulong_long2num (unsigned long long sl);
|
||||
extern long long scm_num2long_long (SCM num, unsigned long int pos,
|
||||
const char *s_caller);
|
||||
extern unsigned long long scm_num2ulong_long (SCM num, unsigned long int pos,
|
||||
const char *s_caller);
|
||||
SCM_API SCM scm_long_long2num (long long sl);
|
||||
SCM_API SCM scm_ulong_long2num (unsigned long long sl);
|
||||
SCM_API long long scm_num2long_long (SCM num, unsigned long int pos,
|
||||
const char *s_caller);
|
||||
SCM_API unsigned long long scm_num2ulong_long (SCM num, unsigned long int pos,
|
||||
const char *s_caller);
|
||||
#endif
|
||||
|
||||
extern SCM scm_float2num (float n);
|
||||
extern SCM scm_double2num (double n);
|
||||
extern float scm_num2float (SCM num, unsigned long int pos,
|
||||
const char *s_caller);
|
||||
extern double scm_num2double (SCM num, unsigned long int pos,
|
||||
const char *s_caller);
|
||||
SCM_API SCM scm_float2num (float n);
|
||||
SCM_API SCM scm_double2num (double n);
|
||||
SCM_API float scm_num2float (SCM num, unsigned long int pos,
|
||||
const char *s_caller);
|
||||
SCM_API double scm_num2double (SCM num, unsigned long int pos,
|
||||
const char *s_caller);
|
||||
|
||||
extern void scm_init_numbers (void);
|
||||
SCM_API void scm_init_numbers (void);
|
||||
|
||||
#endif /* SCM_NUMBERS_H */
|
||||
|
||||
|
|
|
@ -198,48 +198,55 @@ typedef struct scm_effective_slot_definition {
|
|||
#define SCM_INOUT_PCLASS_INDEX 0x200
|
||||
|
||||
/* Plugin proxy classes for basic types. */
|
||||
extern SCM scm_metaclass_standard;
|
||||
extern SCM scm_metaclass_operator;
|
||||
extern SCM scm_class_boolean, scm_class_char, scm_class_pair;
|
||||
extern SCM scm_class_procedure, scm_class_string, scm_class_symbol;
|
||||
extern SCM scm_class_procedure_with_setter, scm_class_primitive_generic;
|
||||
extern SCM scm_class_vector, scm_class_null;
|
||||
extern SCM scm_class_real, scm_class_complex, scm_class_integer;
|
||||
extern SCM scm_class_unknown;
|
||||
extern SCM *scm_port_class;
|
||||
extern SCM *scm_smob_class;
|
||||
SCM_API SCM scm_metaclass_standard;
|
||||
SCM_API SCM scm_metaclass_operator;
|
||||
SCM_API SCM scm_class_boolean;
|
||||
SCM_API SCM scm_class_char;
|
||||
SCM_API SCM scm_class_pair;
|
||||
SCM_API SCM scm_class_procedure;
|
||||
SCM_API SCM scm_class_string;
|
||||
SCM_API SCM scm_class_symbol;
|
||||
SCM_API SCM scm_class_procedure_with_setter;
|
||||
SCM_API SCM scm_class_primitive_generic;
|
||||
SCM_API SCM scm_class_vector, scm_class_null;
|
||||
SCM_API SCM scm_class_real;
|
||||
SCM_API SCM scm_class_complex;
|
||||
SCM_API SCM scm_class_integer;
|
||||
SCM_API SCM scm_class_unknown;
|
||||
SCM_API SCM *scm_port_class;
|
||||
SCM_API SCM *scm_smob_class;
|
||||
|
||||
extern SCM scm_no_applicable_method;
|
||||
SCM_API SCM scm_no_applicable_method;
|
||||
|
||||
/* Goops functions. */
|
||||
extern SCM scm_make_extended_class (char *type_name);
|
||||
extern void scm_make_port_classes (long ptobnum, char *type_name);
|
||||
extern void scm_change_object_class (SCM, SCM, SCM);
|
||||
extern SCM scm_memoize_method (SCM x, SCM args);
|
||||
SCM_API SCM scm_make_extended_class (char *type_name);
|
||||
SCM_API void scm_make_port_classes (long ptobnum, char *type_name);
|
||||
SCM_API void scm_change_object_class (SCM, SCM, SCM);
|
||||
SCM_API SCM scm_memoize_method (SCM x, SCM args);
|
||||
|
||||
extern SCM scm_class_of (SCM obj);
|
||||
extern SCM scm_mcache_lookup_cmethod (SCM cache, SCM args);
|
||||
extern SCM scm_mcache_compute_cmethod (SCM cache, SCM args);
|
||||
SCM_API SCM scm_class_of (SCM obj);
|
||||
SCM_API SCM scm_mcache_lookup_cmethod (SCM cache, SCM args);
|
||||
SCM_API SCM scm_mcache_compute_cmethod (SCM cache, SCM args);
|
||||
/* The following are declared in __scm.h
|
||||
extern SCM scm_call_generic_0 (SCM gf);
|
||||
extern SCM scm_call_generic_1 (SCM gf, SCM a1);
|
||||
extern SCM scm_call_generic_2 (SCM gf, SCM a1, SCM a2);
|
||||
extern SCM scm_apply_generic (SCM gf, SCM args);
|
||||
SCM_API SCM scm_call_generic_0 (SCM gf);
|
||||
SCM_API SCM scm_call_generic_1 (SCM gf, SCM a1);
|
||||
SCM_API SCM scm_call_generic_2 (SCM gf, SCM a1, SCM a2);
|
||||
SCM_API SCM scm_apply_generic (SCM gf, SCM args);
|
||||
*/
|
||||
extern SCM scm_call_generic_3 (SCM gf, SCM a1, SCM a2, SCM a3);
|
||||
extern SCM scm_entity_p (SCM obj);
|
||||
extern SCM scm_operator_p (SCM obj);
|
||||
extern SCM scm_valid_object_procedure_p (SCM proc);
|
||||
extern SCM scm_set_object_procedure_x (SCM obj, SCM proc);
|
||||
SCM_API SCM scm_call_generic_3 (SCM gf, SCM a1, SCM a2, SCM a3);
|
||||
SCM_API SCM scm_entity_p (SCM obj);
|
||||
SCM_API SCM scm_operator_p (SCM obj);
|
||||
SCM_API SCM scm_valid_object_procedure_p (SCM proc);
|
||||
SCM_API SCM scm_set_object_procedure_x (SCM obj, SCM proc);
|
||||
#ifdef GUILE_DEBUG
|
||||
extern SCM scm_object_procedure (SCM obj);
|
||||
SCM_API SCM scm_object_procedure (SCM obj);
|
||||
#endif
|
||||
extern SCM scm_make_class_object (SCM metaclass, SCM layout);
|
||||
extern SCM scm_make_subclass_object (SCM c, SCM layout);
|
||||
SCM_API SCM scm_make_class_object (SCM metaclass, SCM layout);
|
||||
SCM_API SCM scm_make_subclass_object (SCM c, SCM layout);
|
||||
|
||||
extern SCM scm_i_make_class_object (SCM metaclass, SCM layout_string,
|
||||
unsigned long flags);
|
||||
extern void scm_init_objects (void);
|
||||
SCM_API SCM scm_i_make_class_object (SCM metaclass, SCM layout_string,
|
||||
unsigned long flags);
|
||||
SCM_API void scm_init_objects (void);
|
||||
|
||||
#endif /* SCM_OBJECTS_H */
|
||||
|
||||
|
|
|
@ -50,11 +50,11 @@
|
|||
|
||||
|
||||
|
||||
extern SCM scm_object_properties (SCM obj);
|
||||
extern SCM scm_set_object_properties_x (SCM obj, SCM plist);
|
||||
extern SCM scm_object_property (SCM obj, SCM key);
|
||||
extern SCM scm_set_object_property_x (SCM obj, SCM key, SCM val);
|
||||
extern void scm_init_objprop (void);
|
||||
SCM_API SCM scm_object_properties (SCM obj);
|
||||
SCM_API SCM scm_set_object_properties_x (SCM obj, SCM plist);
|
||||
SCM_API SCM scm_object_property (SCM obj, SCM key);
|
||||
SCM_API SCM scm_set_object_property_x (SCM obj, SCM key, SCM val);
|
||||
SCM_API void scm_init_objprop (void);
|
||||
|
||||
#endif /* SCM_OBJPROP_H */
|
||||
|
||||
|
|
|
@ -67,9 +67,9 @@ typedef struct scm_t_option
|
|||
#define SCM_OPTION_SCM 2
|
||||
|
||||
|
||||
extern SCM scm_options (SCM, scm_t_option [], unsigned int, const char*);
|
||||
extern void scm_init_opts (SCM (*) (SCM), scm_t_option [], unsigned int n);
|
||||
extern void scm_init_options (void);
|
||||
SCM_API SCM scm_options (SCM, scm_t_option [], unsigned int, const char*);
|
||||
SCM_API void scm_init_opts (SCM (*) (SCM), scm_t_option [], unsigned int n);
|
||||
SCM_API void scm_init_options (void);
|
||||
|
||||
#endif /* SCM_OPTIONS_H */
|
||||
|
||||
|
|
|
@ -101,14 +101,14 @@
|
|||
|
||||
|
||||
#if (SCM_DEBUG_PAIR_ACCESSES == 1)
|
||||
extern void scm_error_pair_access (SCM);
|
||||
SCM_API void scm_error_pair_access (SCM);
|
||||
#endif
|
||||
extern SCM scm_cons (SCM x, SCM y);
|
||||
extern SCM scm_cons2 (SCM w, SCM x, SCM y);
|
||||
extern SCM scm_pair_p (SCM x);
|
||||
extern SCM scm_set_car_x (SCM pair, SCM value);
|
||||
extern SCM scm_set_cdr_x (SCM pair, SCM value);
|
||||
extern void scm_init_pairs (void);
|
||||
SCM_API SCM scm_cons (SCM x, SCM y);
|
||||
SCM_API SCM scm_cons2 (SCM w, SCM x, SCM y);
|
||||
SCM_API SCM scm_pair_p (SCM x);
|
||||
SCM_API SCM scm_set_car_x (SCM pair, SCM value);
|
||||
SCM_API SCM scm_set_cdr_x (SCM pair, SCM value);
|
||||
SCM_API void scm_init_pairs (void);
|
||||
|
||||
#endif /* SCM_PAIRS_H */
|
||||
|
||||
|
|
188
libguile/ports.h
188
libguile/ports.h
|
@ -132,8 +132,8 @@ typedef struct
|
|||
size_t putback_buf_size; /* allocated size of putback_buf. */
|
||||
} scm_t_port;
|
||||
|
||||
extern scm_t_port **scm_port_table;
|
||||
extern long scm_port_table_size; /* Number of ports in scm_port_table. */
|
||||
SCM_API scm_t_port **scm_port_table;
|
||||
SCM_API long scm_port_table_size; /* Number of ports in scm_port_table. */
|
||||
|
||||
#define SCM_READ_BUFFER_EMPTY_P(c_port) (c_port->read_pos >= c_port->read_end)
|
||||
|
||||
|
@ -213,105 +213,105 @@ typedef struct scm_t_ptob_descriptor
|
|||
|
||||
|
||||
|
||||
extern scm_t_ptob_descriptor *scm_ptobs;
|
||||
extern long scm_numptob;
|
||||
extern long scm_port_table_room;
|
||||
SCM_API scm_t_ptob_descriptor *scm_ptobs;
|
||||
SCM_API long scm_numptob;
|
||||
SCM_API long scm_port_table_room;
|
||||
|
||||
|
||||
|
||||
extern SCM scm_markstream (SCM ptr);
|
||||
extern scm_t_bits scm_make_port_type (char *name,
|
||||
int (*fill_input) (SCM port),
|
||||
void (*write) (SCM port,
|
||||
const void *data,
|
||||
size_t size));
|
||||
extern void scm_set_port_mark (long tc, SCM (*mark) (SCM));
|
||||
extern void scm_set_port_free (long tc, size_t (*free) (SCM));
|
||||
extern void scm_set_port_print (long tc,
|
||||
int (*print) (SCM exp,
|
||||
SCM port,
|
||||
scm_print_state *pstate));
|
||||
extern void scm_set_port_equalp (long tc, SCM (*equalp) (SCM, SCM));
|
||||
extern void scm_set_port_close (long tc, int (*close) (SCM));
|
||||
SCM_API SCM scm_markstream (SCM ptr);
|
||||
SCM_API scm_t_bits scm_make_port_type (char *name,
|
||||
int (*fill_input) (SCM port),
|
||||
void (*write) (SCM port,
|
||||
const void *data,
|
||||
size_t size));
|
||||
SCM_API void scm_set_port_mark (long tc, SCM (*mark) (SCM));
|
||||
SCM_API void scm_set_port_free (long tc, size_t (*free) (SCM));
|
||||
SCM_API void scm_set_port_print (long tc,
|
||||
int (*print) (SCM exp,
|
||||
SCM port,
|
||||
scm_print_state *pstate));
|
||||
SCM_API void scm_set_port_equalp (long tc, SCM (*equalp) (SCM, SCM));
|
||||
SCM_API void scm_set_port_close (long tc, int (*close) (SCM));
|
||||
|
||||
extern void scm_set_port_flush (long tc,
|
||||
void (*flush) (SCM port));
|
||||
extern void scm_set_port_end_input (long tc,
|
||||
void (*end_input) (SCM port,
|
||||
int offset));
|
||||
extern void scm_set_port_seek (long tc,
|
||||
off_t (*seek) (SCM port,
|
||||
off_t OFFSET,
|
||||
int WHENCE));
|
||||
extern void scm_set_port_truncate (long tc,
|
||||
void (*truncate) (SCM port,
|
||||
off_t length));
|
||||
extern void scm_set_port_input_waiting (long tc, int (*input_waiting) (SCM));
|
||||
extern SCM scm_char_ready_p (SCM port);
|
||||
SCM_API void scm_set_port_flush (long tc,
|
||||
void (*flush) (SCM port));
|
||||
SCM_API void scm_set_port_end_input (long tc,
|
||||
void (*end_input) (SCM port,
|
||||
int offset));
|
||||
SCM_API void scm_set_port_seek (long tc,
|
||||
off_t (*seek) (SCM port,
|
||||
off_t OFFSET,
|
||||
int WHENCE));
|
||||
SCM_API void scm_set_port_truncate (long tc,
|
||||
void (*truncate) (SCM port,
|
||||
off_t length));
|
||||
SCM_API void scm_set_port_input_waiting (long tc, int (*input_waiting) (SCM));
|
||||
SCM_API SCM scm_char_ready_p (SCM port);
|
||||
size_t scm_take_from_input_buffers (SCM port, char *dest, size_t read_len);
|
||||
extern SCM scm_drain_input (SCM port);
|
||||
extern SCM scm_current_input_port (void);
|
||||
extern SCM scm_current_output_port (void);
|
||||
extern SCM scm_current_error_port (void);
|
||||
extern SCM scm_current_load_port (void);
|
||||
extern SCM scm_set_current_input_port (SCM port);
|
||||
extern SCM scm_set_current_output_port (SCM port);
|
||||
extern SCM scm_set_current_error_port (SCM port);
|
||||
extern scm_t_port * scm_add_to_port_table (SCM port);
|
||||
extern void scm_remove_from_port_table (SCM port);
|
||||
extern void scm_grow_port_cbuf (SCM port, size_t requested);
|
||||
extern SCM scm_pt_size (void);
|
||||
extern SCM scm_pt_member (SCM member);
|
||||
extern void scm_port_non_buffer (scm_t_port *pt);
|
||||
extern int scm_revealed_count (SCM port);
|
||||
extern SCM scm_port_revealed (SCM port);
|
||||
extern SCM scm_set_port_revealed_x (SCM port, SCM rcount);
|
||||
extern long scm_mode_bits (char *modes);
|
||||
extern SCM scm_port_mode (SCM port);
|
||||
extern SCM scm_close_input_port (SCM port);
|
||||
extern SCM scm_close_output_port (SCM port);
|
||||
extern SCM scm_close_port (SCM port);
|
||||
extern SCM scm_port_for_each (SCM proc);
|
||||
extern SCM scm_input_port_p (SCM x);
|
||||
extern SCM scm_output_port_p (SCM x);
|
||||
extern SCM scm_port_p (SCM x);
|
||||
extern SCM scm_port_closed_p (SCM port);
|
||||
extern SCM scm_eof_object_p (SCM x);
|
||||
extern SCM scm_force_output (SCM port);
|
||||
extern SCM scm_flush_all_ports (void);
|
||||
extern SCM scm_read_char (SCM port);
|
||||
extern void scm_putc (char c, SCM port);
|
||||
extern void scm_puts (const char *str_data, SCM port);
|
||||
extern size_t scm_c_read (SCM port, void *buffer, size_t size);
|
||||
extern void scm_c_write (SCM port, const void *buffer, size_t size);
|
||||
extern void scm_lfwrite (const char *ptr, size_t size, SCM port);
|
||||
extern void scm_flush (SCM port);
|
||||
extern void scm_end_input (SCM port);
|
||||
extern int scm_fill_input (SCM port);
|
||||
extern int scm_getc (SCM port);
|
||||
extern void scm_ungetc (int c, SCM port);
|
||||
extern void scm_ungets (const char *s, int n, SCM port);
|
||||
extern SCM scm_peek_char (SCM port);
|
||||
extern SCM scm_unread_char (SCM cobj, SCM port);
|
||||
extern SCM scm_unread_string (SCM str, SCM port);
|
||||
extern SCM scm_seek (SCM object, SCM offset, SCM whence);
|
||||
extern SCM scm_truncate_file (SCM object, SCM length);
|
||||
extern SCM scm_port_line (SCM port);
|
||||
extern SCM scm_set_port_line_x (SCM port, SCM line);
|
||||
extern SCM scm_port_column (SCM port);
|
||||
extern SCM scm_set_port_column_x (SCM port, SCM line);
|
||||
extern SCM scm_port_filename (SCM port);
|
||||
extern SCM scm_set_port_filename_x (SCM port, SCM filename);
|
||||
extern int scm_port_print (SCM exp, SCM port, scm_print_state *);
|
||||
extern void scm_print_port_mode (SCM exp, SCM port);
|
||||
extern void scm_ports_prehistory (void);
|
||||
extern SCM scm_void_port (char * mode_str);
|
||||
extern SCM scm_sys_make_void_port (SCM mode);
|
||||
extern void scm_init_ports (void);
|
||||
SCM_API SCM scm_drain_input (SCM port);
|
||||
SCM_API SCM scm_current_input_port (void);
|
||||
SCM_API SCM scm_current_output_port (void);
|
||||
SCM_API SCM scm_current_error_port (void);
|
||||
SCM_API SCM scm_current_load_port (void);
|
||||
SCM_API SCM scm_set_current_input_port (SCM port);
|
||||
SCM_API SCM scm_set_current_output_port (SCM port);
|
||||
SCM_API SCM scm_set_current_error_port (SCM port);
|
||||
SCM_API scm_t_port * scm_add_to_port_table (SCM port);
|
||||
SCM_API void scm_remove_from_port_table (SCM port);
|
||||
SCM_API void scm_grow_port_cbuf (SCM port, size_t requested);
|
||||
SCM_API SCM scm_pt_size (void);
|
||||
SCM_API SCM scm_pt_member (SCM member);
|
||||
SCM_API void scm_port_non_buffer (scm_t_port *pt);
|
||||
SCM_API int scm_revealed_count (SCM port);
|
||||
SCM_API SCM scm_port_revealed (SCM port);
|
||||
SCM_API SCM scm_set_port_revealed_x (SCM port, SCM rcount);
|
||||
SCM_API long scm_mode_bits (char *modes);
|
||||
SCM_API SCM scm_port_mode (SCM port);
|
||||
SCM_API SCM scm_close_input_port (SCM port);
|
||||
SCM_API SCM scm_close_output_port (SCM port);
|
||||
SCM_API SCM scm_close_port (SCM port);
|
||||
SCM_API SCM scm_port_for_each (SCM proc);
|
||||
SCM_API SCM scm_input_port_p (SCM x);
|
||||
SCM_API SCM scm_output_port_p (SCM x);
|
||||
SCM_API SCM scm_port_p (SCM x);
|
||||
SCM_API SCM scm_port_closed_p (SCM port);
|
||||
SCM_API SCM scm_eof_object_p (SCM x);
|
||||
SCM_API SCM scm_force_output (SCM port);
|
||||
SCM_API SCM scm_flush_all_ports (void);
|
||||
SCM_API SCM scm_read_char (SCM port);
|
||||
SCM_API void scm_putc (char c, SCM port);
|
||||
SCM_API void scm_puts (const char *str_data, SCM port);
|
||||
SCM_API size_t scm_c_read (SCM port, void *buffer, size_t size);
|
||||
SCM_API void scm_c_write (SCM port, const void *buffer, size_t size);
|
||||
SCM_API void scm_lfwrite (const char *ptr, size_t size, SCM port);
|
||||
SCM_API void scm_flush (SCM port);
|
||||
SCM_API void scm_end_input (SCM port);
|
||||
SCM_API int scm_fill_input (SCM port);
|
||||
SCM_API int scm_getc (SCM port);
|
||||
SCM_API void scm_ungetc (int c, SCM port);
|
||||
SCM_API void scm_ungets (const char *s, int n, SCM port);
|
||||
SCM_API SCM scm_peek_char (SCM port);
|
||||
SCM_API SCM scm_unread_char (SCM cobj, SCM port);
|
||||
SCM_API SCM scm_unread_string (SCM str, SCM port);
|
||||
SCM_API SCM scm_seek (SCM object, SCM offset, SCM whence);
|
||||
SCM_API SCM scm_truncate_file (SCM object, SCM length);
|
||||
SCM_API SCM scm_port_line (SCM port);
|
||||
SCM_API SCM scm_set_port_line_x (SCM port, SCM line);
|
||||
SCM_API SCM scm_port_column (SCM port);
|
||||
SCM_API SCM scm_set_port_column_x (SCM port, SCM line);
|
||||
SCM_API SCM scm_port_filename (SCM port);
|
||||
SCM_API SCM scm_set_port_filename_x (SCM port, SCM filename);
|
||||
SCM_API int scm_port_print (SCM exp, SCM port, scm_print_state *);
|
||||
SCM_API void scm_print_port_mode (SCM exp, SCM port);
|
||||
SCM_API void scm_ports_prehistory (void);
|
||||
SCM_API SCM scm_void_port (char * mode_str);
|
||||
SCM_API SCM scm_sys_make_void_port (SCM mode);
|
||||
SCM_API void scm_init_ports (void);
|
||||
|
||||
#ifdef GUILE_DEBUG
|
||||
extern SCM scm_pt_size (void);
|
||||
extern SCM scm_pt_member (SCM member);
|
||||
SCM_API SCM scm_pt_size (void);
|
||||
SCM_API SCM scm_pt_member (SCM member);
|
||||
#endif /* GUILE_DEBUG */
|
||||
|
||||
#endif /* SCM_PORTS_H */
|
||||
|
|
112
libguile/posix.h
112
libguile/posix.h
|
@ -53,62 +53,62 @@
|
|||
|
||||
|
||||
|
||||
extern SCM scm_tcsetpgrp (SCM port, SCM pgid);
|
||||
extern SCM scm_tcgetpgrp (SCM port);
|
||||
extern SCM scm_ctermid (void);
|
||||
extern SCM scm_setsid (void);
|
||||
extern SCM scm_setpgid (SCM pid, SCM pgid);
|
||||
extern SCM scm_pipe (void);
|
||||
extern SCM scm_getgroups (void);
|
||||
extern SCM scm_getpgrp (void);
|
||||
extern SCM scm_getpwuid (SCM user);
|
||||
extern SCM scm_setpwent (SCM arg);
|
||||
extern SCM scm_getgrgid (SCM name);
|
||||
extern SCM scm_setgrent (SCM arg);
|
||||
extern SCM scm_kill (SCM pid, SCM sig);
|
||||
extern SCM scm_waitpid (SCM pid, SCM options);
|
||||
extern SCM scm_status_exit_val (SCM status);
|
||||
extern SCM scm_status_term_sig (SCM status);
|
||||
extern SCM scm_status_stop_sig (SCM status);
|
||||
extern SCM scm_getppid (void);
|
||||
extern SCM scm_getuid (void);
|
||||
extern SCM scm_getgid (void);
|
||||
extern SCM scm_geteuid (void);
|
||||
extern SCM scm_getegid (void);
|
||||
extern SCM scm_setuid (SCM id);
|
||||
extern SCM scm_setgid (SCM id);
|
||||
extern SCM scm_seteuid (SCM id);
|
||||
extern SCM scm_setegid (SCM id);
|
||||
extern SCM scm_ttyname (SCM port);
|
||||
extern SCM scm_execl (SCM filename, SCM args);
|
||||
extern SCM scm_execlp (SCM filename, SCM args);
|
||||
extern SCM scm_execle (SCM filename, SCM env, SCM args);
|
||||
extern SCM scm_fork (void);
|
||||
extern SCM scm_uname (void);
|
||||
extern SCM scm_environ (SCM env);
|
||||
extern SCM scm_tmpnam (void);
|
||||
extern SCM scm_mkstemp (SCM tmpl);
|
||||
extern SCM scm_open_pipe (SCM pipestr, SCM modes);
|
||||
extern SCM scm_close_pipe (SCM port);
|
||||
extern SCM scm_utime (SCM pathname, SCM actime, SCM modtime);
|
||||
extern SCM scm_access (SCM path, SCM how);
|
||||
extern SCM scm_getpid (void);
|
||||
extern SCM scm_putenv (SCM str);
|
||||
extern SCM scm_setlocale (SCM category, SCM locale);
|
||||
extern SCM scm_mknod (SCM path, SCM type, SCM perms, SCM dev);
|
||||
extern SCM scm_nice (SCM incr);
|
||||
extern SCM scm_sync (void);
|
||||
extern SCM scm_crypt (SCM key, SCM salt);
|
||||
extern SCM scm_chroot (SCM path);
|
||||
extern SCM scm_getlogin (void);
|
||||
extern SCM scm_cuserid (void);
|
||||
extern SCM scm_getpriority (SCM which, SCM who);
|
||||
extern SCM scm_setpriority (SCM which, SCM who, SCM prio);
|
||||
extern SCM scm_getpass (SCM prompt);
|
||||
extern SCM scm_flock (SCM file, SCM operation);
|
||||
extern SCM scm_sethostname (SCM name);
|
||||
extern SCM scm_gethostname (void);
|
||||
extern void scm_init_posix (void);
|
||||
SCM_API SCM scm_tcsetpgrp (SCM port, SCM pgid);
|
||||
SCM_API SCM scm_tcgetpgrp (SCM port);
|
||||
SCM_API SCM scm_ctermid (void);
|
||||
SCM_API SCM scm_setsid (void);
|
||||
SCM_API SCM scm_setpgid (SCM pid, SCM pgid);
|
||||
SCM_API SCM scm_pipe (void);
|
||||
SCM_API SCM scm_getgroups (void);
|
||||
SCM_API SCM scm_getpgrp (void);
|
||||
SCM_API SCM scm_getpwuid (SCM user);
|
||||
SCM_API SCM scm_setpwent (SCM arg);
|
||||
SCM_API SCM scm_getgrgid (SCM name);
|
||||
SCM_API SCM scm_setgrent (SCM arg);
|
||||
SCM_API SCM scm_kill (SCM pid, SCM sig);
|
||||
SCM_API SCM scm_waitpid (SCM pid, SCM options);
|
||||
SCM_API SCM scm_status_exit_val (SCM status);
|
||||
SCM_API SCM scm_status_term_sig (SCM status);
|
||||
SCM_API SCM scm_status_stop_sig (SCM status);
|
||||
SCM_API SCM scm_getppid (void);
|
||||
SCM_API SCM scm_getuid (void);
|
||||
SCM_API SCM scm_getgid (void);
|
||||
SCM_API SCM scm_geteuid (void);
|
||||
SCM_API SCM scm_getegid (void);
|
||||
SCM_API SCM scm_setuid (SCM id);
|
||||
SCM_API SCM scm_setgid (SCM id);
|
||||
SCM_API SCM scm_seteuid (SCM id);
|
||||
SCM_API SCM scm_setegid (SCM id);
|
||||
SCM_API SCM scm_ttyname (SCM port);
|
||||
SCM_API SCM scm_execl (SCM filename, SCM args);
|
||||
SCM_API SCM scm_execlp (SCM filename, SCM args);
|
||||
SCM_API SCM scm_execle (SCM filename, SCM env, SCM args);
|
||||
SCM_API SCM scm_fork (void);
|
||||
SCM_API SCM scm_uname (void);
|
||||
SCM_API SCM scm_environ (SCM env);
|
||||
SCM_API SCM scm_tmpnam (void);
|
||||
SCM_API SCM scm_mkstemp (SCM tmpl);
|
||||
SCM_API SCM scm_open_pipe (SCM pipestr, SCM modes);
|
||||
SCM_API SCM scm_close_pipe (SCM port);
|
||||
SCM_API SCM scm_utime (SCM pathname, SCM actime, SCM modtime);
|
||||
SCM_API SCM scm_access (SCM path, SCM how);
|
||||
SCM_API SCM scm_getpid (void);
|
||||
SCM_API SCM scm_putenv (SCM str);
|
||||
SCM_API SCM scm_setlocale (SCM category, SCM locale);
|
||||
SCM_API SCM scm_mknod (SCM path, SCM type, SCM perms, SCM dev);
|
||||
SCM_API SCM scm_nice (SCM incr);
|
||||
SCM_API SCM scm_sync (void);
|
||||
SCM_API SCM scm_crypt (SCM key, SCM salt);
|
||||
SCM_API SCM scm_chroot (SCM path);
|
||||
SCM_API SCM scm_getlogin (void);
|
||||
SCM_API SCM scm_cuserid (void);
|
||||
SCM_API SCM scm_getpriority (SCM which, SCM who);
|
||||
SCM_API SCM scm_setpriority (SCM which, SCM who, SCM prio);
|
||||
SCM_API SCM scm_getpass (SCM prompt);
|
||||
SCM_API SCM scm_flock (SCM file, SCM operation);
|
||||
SCM_API SCM scm_sethostname (SCM name);
|
||||
SCM_API SCM scm_gethostname (void);
|
||||
SCM_API void scm_init_posix (void);
|
||||
|
||||
#endif /* SCM_POSIX_H */
|
||||
|
||||
|
|
|
@ -50,7 +50,7 @@
|
|||
|
||||
#include "libguile/options.h"
|
||||
|
||||
extern scm_t_option scm_print_opts[];
|
||||
SCM_API scm_t_option scm_print_opts[];
|
||||
|
||||
#define SCM_PRINT_CLOSURE (SCM_PACK (scm_print_opts[0].val))
|
||||
#define SCM_PRINT_SOURCE_P ((int) scm_print_opts[1].val)
|
||||
|
@ -96,32 +96,32 @@ typedef struct scm_print_state {
|
|||
SCM ref_vect;
|
||||
} scm_print_state;
|
||||
|
||||
extern SCM scm_print_state_vtable;
|
||||
SCM_API SCM scm_print_state_vtable;
|
||||
|
||||
extern scm_t_bits scm_tc16_port_with_ps;
|
||||
SCM_API scm_t_bits scm_tc16_port_with_ps;
|
||||
|
||||
extern SCM scm_print_options (SCM setting);
|
||||
SCM scm_make_print_state (void);
|
||||
void scm_free_print_state (SCM print_state);
|
||||
extern void scm_intprint (long n, int radix, SCM port);
|
||||
extern void scm_ipruk (char *hdr, SCM ptr, SCM port);
|
||||
extern void scm_iprlist (char *hdr, SCM exp, int tlr, SCM port, scm_print_state *pstate);
|
||||
extern void scm_print_symbol_name (const char *str, size_t len, SCM port);
|
||||
extern void scm_prin1 (SCM exp, SCM port, int writingp);
|
||||
extern void scm_iprin1 (SCM exp, SCM port, scm_print_state *pstate);
|
||||
extern SCM scm_write (SCM obj, SCM port);
|
||||
extern SCM scm_display (SCM obj, SCM port);
|
||||
extern SCM scm_simple_format (SCM port, SCM message, SCM args);
|
||||
extern SCM scm_newline (SCM port);
|
||||
extern SCM scm_write_char (SCM chr, SCM port);
|
||||
extern SCM scm_printer_apply (SCM proc, SCM exp, SCM port, scm_print_state *);
|
||||
extern SCM scm_port_with_print_state (SCM port, SCM pstate);
|
||||
extern SCM scm_get_print_state (SCM port);
|
||||
extern int scm_valid_oport_value_p (SCM val);
|
||||
extern void scm_init_print (void);
|
||||
SCM_API SCM scm_print_options (SCM setting);
|
||||
SCM_API SCM scm_make_print_state (void);
|
||||
SCM_API void scm_free_print_state (SCM print_state);
|
||||
SCM_API void scm_intprint (long n, int radix, SCM port);
|
||||
SCM_API void scm_ipruk (char *hdr, SCM ptr, SCM port);
|
||||
SCM_API void scm_iprlist (char *hdr, SCM exp, int tlr, SCM port, scm_print_state *pstate);
|
||||
SCM_API void scm_print_symbol_name (const char *str, size_t len, SCM port);
|
||||
SCM_API void scm_prin1 (SCM exp, SCM port, int writingp);
|
||||
SCM_API void scm_iprin1 (SCM exp, SCM port, scm_print_state *pstate);
|
||||
SCM_API SCM scm_write (SCM obj, SCM port);
|
||||
SCM_API SCM scm_display (SCM obj, SCM port);
|
||||
SCM_API SCM scm_simple_format (SCM port, SCM message, SCM args);
|
||||
SCM_API SCM scm_newline (SCM port);
|
||||
SCM_API SCM scm_write_char (SCM chr, SCM port);
|
||||
SCM_API SCM scm_printer_apply (SCM proc, SCM exp, SCM port, scm_print_state *);
|
||||
SCM_API SCM scm_port_with_print_state (SCM port, SCM pstate);
|
||||
SCM_API SCM scm_get_print_state (SCM port);
|
||||
SCM_API int scm_valid_oport_value_p (SCM val);
|
||||
SCM_API void scm_init_print (void);
|
||||
|
||||
#ifdef GUILE_DEBUG
|
||||
extern SCM scm_current_pstate (void);
|
||||
SCM_API SCM scm_current_pstate (void);
|
||||
#endif
|
||||
|
||||
#endif /* SCM_PRINT_H */
|
||||
|
|
|
@ -50,18 +50,18 @@
|
|||
|
||||
|
||||
|
||||
extern SCM scm_sym_name;
|
||||
extern SCM scm_sym_arity;
|
||||
extern SCM scm_sym_system_procedure;
|
||||
SCM_API SCM scm_sym_name;
|
||||
SCM_API SCM scm_sym_arity;
|
||||
SCM_API SCM scm_sym_system_procedure;
|
||||
|
||||
|
||||
|
||||
extern SCM scm_i_procedure_arity (SCM proc);
|
||||
extern SCM scm_procedure_properties (SCM proc);
|
||||
extern SCM scm_set_procedure_properties_x (SCM proc, SCM new_val);
|
||||
extern SCM scm_procedure_property (SCM p, SCM k);
|
||||
extern SCM scm_set_procedure_property_x (SCM p, SCM k, SCM v);
|
||||
extern void scm_init_procprop (void);
|
||||
SCM_API SCM scm_i_procedure_arity (SCM proc);
|
||||
SCM_API SCM scm_procedure_properties (SCM proc);
|
||||
SCM_API SCM scm_set_procedure_properties_x (SCM proc, SCM new_val);
|
||||
SCM_API SCM scm_procedure_property (SCM p, SCM k);
|
||||
SCM_API SCM scm_set_procedure_property_x (SCM p, SCM k, SCM v);
|
||||
SCM_API void scm_init_procprop (void);
|
||||
|
||||
#endif /* SCM_PROCPROP_H */
|
||||
|
||||
|
|
|
@ -152,35 +152,35 @@ typedef struct
|
|||
#define SCM_PROCEDURE(obj) SCM_CELL_OBJECT_1 (obj)
|
||||
#define SCM_SETTER(obj) SCM_CELL_OBJECT_2 (obj)
|
||||
|
||||
extern scm_t_subr_entry *scm_subr_table;
|
||||
extern long scm_subr_table_size;
|
||||
extern long scm_subr_table_room;
|
||||
SCM_API scm_t_subr_entry *scm_subr_table;
|
||||
SCM_API long scm_subr_table_size;
|
||||
SCM_API long scm_subr_table_room;
|
||||
|
||||
|
||||
|
||||
extern void scm_mark_subr_table (void);
|
||||
extern void scm_free_subr_entry (SCM subr);
|
||||
extern SCM scm_c_make_subr (const char *name, long type, SCM (*fcn)());
|
||||
extern SCM scm_c_make_subr_with_generic (const char *name, long type,
|
||||
SCM (*fcn)(), SCM *gf);
|
||||
extern SCM scm_c_define_subr (const char *name, long type, SCM (*fcn)());
|
||||
extern SCM scm_c_define_subr_with_generic (const char *name, long type,
|
||||
SCM (*fcn)(), SCM *gf);
|
||||
extern SCM scm_makcclo (SCM proc, size_t len);
|
||||
extern SCM scm_procedure_p (SCM obj);
|
||||
extern SCM scm_closure_p (SCM obj);
|
||||
extern SCM scm_thunk_p (SCM obj);
|
||||
extern int scm_subr_p (SCM obj);
|
||||
extern SCM scm_procedure_documentation (SCM proc);
|
||||
extern SCM scm_procedure_with_setter_p (SCM obj);
|
||||
extern SCM scm_make_procedure_with_setter (SCM procedure, SCM setter);
|
||||
extern SCM scm_procedure (SCM proc);
|
||||
extern SCM scm_setter (SCM proc);
|
||||
extern void scm_init_subr_table (void);
|
||||
extern void scm_init_procs (void);
|
||||
SCM_API void scm_mark_subr_table (void);
|
||||
SCM_API void scm_free_subr_entry (SCM subr);
|
||||
SCM_API SCM scm_c_make_subr (const char *name, long type, SCM (*fcn)());
|
||||
SCM_API SCM scm_c_make_subr_with_generic (const char *name, long type,
|
||||
SCM (*fcn)(), SCM *gf);
|
||||
SCM_API SCM scm_c_define_subr (const char *name, long type, SCM (*fcn)());
|
||||
SCM_API SCM scm_c_define_subr_with_generic (const char *name, long type,
|
||||
SCM (*fcn)(), SCM *gf);
|
||||
SCM_API SCM scm_makcclo (SCM proc, size_t len);
|
||||
SCM_API SCM scm_procedure_p (SCM obj);
|
||||
SCM_API SCM scm_closure_p (SCM obj);
|
||||
SCM_API SCM scm_thunk_p (SCM obj);
|
||||
SCM_API int scm_subr_p (SCM obj);
|
||||
SCM_API SCM scm_procedure_documentation (SCM proc);
|
||||
SCM_API SCM scm_procedure_with_setter_p (SCM obj);
|
||||
SCM_API SCM scm_make_procedure_with_setter (SCM procedure, SCM setter);
|
||||
SCM_API SCM scm_procedure (SCM proc);
|
||||
SCM_API SCM scm_setter (SCM proc);
|
||||
SCM_API void scm_init_subr_table (void);
|
||||
SCM_API void scm_init_procs (void);
|
||||
|
||||
#ifdef GUILE_DEBUG
|
||||
extern SCM scm_make_cclo (SCM proc, SCM len);
|
||||
SCM_API SCM scm_make_cclo (SCM proc, SCM len);
|
||||
#endif /*GUILE_DEBUG*/
|
||||
|
||||
#endif /* SCM_PROCS_H */
|
||||
|
|
|
@ -48,12 +48,12 @@
|
|||
|
||||
#include "libguile/__scm.h"
|
||||
|
||||
SCM scm_primitive_make_property (SCM not_found_proc);
|
||||
SCM scm_primitive_property_ref (SCM prop, SCM obj);
|
||||
SCM scm_primitive_property_set_x (SCM prop, SCM obj, SCM val);
|
||||
SCM scm_primitive_property_del_x (SCM prop, SCM obj);
|
||||
SCM_API SCM scm_primitive_make_property (SCM not_found_proc);
|
||||
SCM_API SCM scm_primitive_property_ref (SCM prop, SCM obj);
|
||||
SCM_API SCM scm_primitive_property_set_x (SCM prop, SCM obj, SCM val);
|
||||
SCM_API SCM scm_primitive_property_del_x (SCM prop, SCM obj);
|
||||
|
||||
void scm_init_properties (void);
|
||||
SCM_API void scm_init_properties (void);
|
||||
|
||||
#endif /* SCM_PROPERTIES_H */
|
||||
|
||||
|
|
|
@ -50,28 +50,28 @@
|
|||
|
||||
|
||||
|
||||
extern int scm_ra_matchp (SCM ra0, SCM ras);
|
||||
extern int scm_ramapc (int (*cproc) (), SCM data, SCM ra0, SCM lra,
|
||||
const char *what);
|
||||
extern int scm_array_fill_int (SCM ra, SCM fill, SCM ignore);
|
||||
extern SCM scm_array_fill_x (SCM ra, SCM fill);
|
||||
extern SCM scm_array_copy_x (SCM src, SCM dst);
|
||||
extern int scm_ra_eqp (SCM ra0, SCM ras);
|
||||
extern int scm_ra_lessp (SCM ra0, SCM ras);
|
||||
extern int scm_ra_leqp (SCM ra0, SCM ras);
|
||||
extern int scm_ra_grp (SCM ra0, SCM ras);
|
||||
extern int scm_ra_greqp (SCM ra0, SCM ras);
|
||||
extern int scm_ra_sum (SCM ra0, SCM ras);
|
||||
extern int scm_ra_difference (SCM ra0, SCM ras);
|
||||
extern int scm_ra_product (SCM ra0, SCM ras);
|
||||
extern int scm_ra_divide (SCM ra0, SCM ras);
|
||||
extern int scm_array_identity (SCM src, SCM dst);
|
||||
extern SCM scm_array_map_x (SCM ra0, SCM proc, SCM lra);
|
||||
extern SCM scm_array_for_each (SCM proc, SCM ra0, SCM lra);
|
||||
extern SCM scm_array_index_map_x (SCM ra, SCM proc);
|
||||
extern SCM scm_raequal (SCM ra0, SCM ra1);
|
||||
extern SCM scm_array_equal_p (SCM ra0, SCM ra1);
|
||||
extern void scm_init_ramap (void);
|
||||
SCM_API int scm_ra_matchp (SCM ra0, SCM ras);
|
||||
SCM_API int scm_ramapc (int (*cproc) (), SCM data, SCM ra0, SCM lra,
|
||||
const char *what);
|
||||
SCM_API int scm_array_fill_int (SCM ra, SCM fill, SCM ignore);
|
||||
SCM_API SCM scm_array_fill_x (SCM ra, SCM fill);
|
||||
SCM_API SCM scm_array_copy_x (SCM src, SCM dst);
|
||||
SCM_API int scm_ra_eqp (SCM ra0, SCM ras);
|
||||
SCM_API int scm_ra_lessp (SCM ra0, SCM ras);
|
||||
SCM_API int scm_ra_leqp (SCM ra0, SCM ras);
|
||||
SCM_API int scm_ra_grp (SCM ra0, SCM ras);
|
||||
SCM_API int scm_ra_greqp (SCM ra0, SCM ras);
|
||||
SCM_API int scm_ra_sum (SCM ra0, SCM ras);
|
||||
SCM_API int scm_ra_difference (SCM ra0, SCM ras);
|
||||
SCM_API int scm_ra_product (SCM ra0, SCM ras);
|
||||
SCM_API int scm_ra_divide (SCM ra0, SCM ras);
|
||||
SCM_API int scm_array_identity (SCM src, SCM dst);
|
||||
SCM_API SCM scm_array_map_x (SCM ra0, SCM proc, SCM lra);
|
||||
SCM_API SCM scm_array_for_each (SCM proc, SCM ra0, SCM lra);
|
||||
SCM_API SCM scm_array_index_map_x (SCM ra, SCM proc);
|
||||
SCM_API SCM scm_raequal (SCM ra0, SCM ra1);
|
||||
SCM_API SCM scm_array_equal_p (SCM ra0, SCM ra1);
|
||||
SCM_API void scm_init_ramap (void);
|
||||
|
||||
#endif /* SCM_RAMAP_H */
|
||||
|
||||
|
|
|
@ -74,7 +74,7 @@ typedef struct scm_t_rng {
|
|||
scm_t_rstate *(*copy_rstate) (scm_t_rstate *state);
|
||||
} scm_t_rng;
|
||||
|
||||
extern scm_t_rng scm_the_rng;
|
||||
SCM_API scm_t_rng scm_the_rng;
|
||||
|
||||
|
||||
/*
|
||||
|
@ -86,44 +86,44 @@ typedef struct scm_t_i_rstate {
|
|||
unsigned long c;
|
||||
} scm_t_i_rstate;
|
||||
|
||||
extern unsigned long scm_i_uniform32 (scm_t_i_rstate *);
|
||||
extern void scm_i_init_rstate (scm_t_i_rstate *, char *seed, int n);
|
||||
extern scm_t_i_rstate *scm_i_copy_rstate (scm_t_i_rstate *);
|
||||
SCM_API unsigned long scm_i_uniform32 (scm_t_i_rstate *);
|
||||
SCM_API void scm_i_init_rstate (scm_t_i_rstate *, char *seed, int n);
|
||||
SCM_API scm_t_i_rstate *scm_i_copy_rstate (scm_t_i_rstate *);
|
||||
|
||||
|
||||
/*
|
||||
* Random number library functions
|
||||
*/
|
||||
extern scm_t_rstate *scm_c_make_rstate (char *, int);
|
||||
extern scm_t_rstate *scm_c_default_rstate (void);
|
||||
SCM_API scm_t_rstate *scm_c_make_rstate (char *, int);
|
||||
SCM_API scm_t_rstate *scm_c_default_rstate (void);
|
||||
#define scm_c_uniform32(RSTATE) scm_the_rng.random_bits (RSTATE)
|
||||
extern double scm_c_uniform01 (scm_t_rstate *);
|
||||
extern double scm_c_normal01 (scm_t_rstate *);
|
||||
extern double scm_c_exp1 (scm_t_rstate *);
|
||||
extern unsigned long scm_c_random (scm_t_rstate *, unsigned long m);
|
||||
extern SCM scm_c_random_bignum (scm_t_rstate *, SCM m);
|
||||
SCM_API double scm_c_uniform01 (scm_t_rstate *);
|
||||
SCM_API double scm_c_normal01 (scm_t_rstate *);
|
||||
SCM_API double scm_c_exp1 (scm_t_rstate *);
|
||||
SCM_API unsigned long scm_c_random (scm_t_rstate *, unsigned long m);
|
||||
SCM_API SCM scm_c_random_bignum (scm_t_rstate *, SCM m);
|
||||
|
||||
|
||||
/*
|
||||
* Scheme level interface
|
||||
*/
|
||||
extern scm_t_bits scm_tc16_rstate;
|
||||
SCM_API scm_t_bits scm_tc16_rstate;
|
||||
#define SCM_RSTATEP(obj) SCM_TYP16_PREDICATE (scm_tc16_rstate, obj)
|
||||
#define SCM_RSTATE(obj) ((scm_t_rstate *) SCM_CELL_WORD_1 (obj))
|
||||
|
||||
extern unsigned char scm_masktab[256];
|
||||
SCM_API unsigned char scm_masktab[256];
|
||||
|
||||
extern SCM scm_var_random_state;
|
||||
extern SCM scm_random (SCM n, SCM state);
|
||||
extern SCM scm_copy_random_state (SCM state);
|
||||
extern SCM scm_seed_to_random_state (SCM seed);
|
||||
extern SCM scm_random_uniform (SCM state);
|
||||
extern SCM scm_random_solid_sphere_x (SCM v, SCM state);
|
||||
extern SCM scm_random_hollow_sphere_x (SCM v, SCM state);
|
||||
extern SCM scm_random_normal (SCM state);
|
||||
extern SCM scm_random_normal_vector_x (SCM v, SCM state);
|
||||
extern SCM scm_random_exp (SCM state);
|
||||
extern void scm_init_random (void);
|
||||
SCM_API SCM scm_var_random_state;
|
||||
SCM_API SCM scm_random (SCM n, SCM state);
|
||||
SCM_API SCM scm_copy_random_state (SCM state);
|
||||
SCM_API SCM scm_seed_to_random_state (SCM seed);
|
||||
SCM_API SCM scm_random_uniform (SCM state);
|
||||
SCM_API SCM scm_random_solid_sphere_x (SCM v, SCM state);
|
||||
SCM_API SCM scm_random_hollow_sphere_x (SCM v, SCM state);
|
||||
SCM_API SCM scm_random_normal (SCM state);
|
||||
SCM_API SCM scm_random_normal_vector_x (SCM v, SCM state);
|
||||
SCM_API SCM scm_random_exp (SCM state);
|
||||
SCM_API void scm_init_random (void);
|
||||
|
||||
#endif /* SCM_RANDOM_H */
|
||||
|
||||
|
|
|
@ -48,13 +48,13 @@
|
|||
|
||||
#include "libguile/__scm.h"
|
||||
|
||||
extern SCM scm_read_delimited_x (SCM delims, SCM buf, SCM gobble, SCM port,
|
||||
SCM offset, SCM length);
|
||||
extern SCM scm_read_line (SCM port);
|
||||
extern SCM scm_write_line (SCM obj, SCM port);
|
||||
extern SCM scm_init_rdelim_builtins (void);
|
||||
SCM_API SCM scm_read_delimited_x (SCM delims, SCM buf, SCM gobble, SCM port,
|
||||
SCM offset, SCM length);
|
||||
SCM_API SCM scm_read_line (SCM port);
|
||||
SCM_API SCM scm_write_line (SCM obj, SCM port);
|
||||
SCM_API SCM scm_init_rdelim_builtins (void);
|
||||
|
||||
void scm_init_rdelim (void);
|
||||
SCM_API void scm_init_rdelim (void);
|
||||
|
||||
#endif /* SCM_RDELIM_H */
|
||||
|
||||
|
|
|
@ -69,7 +69,7 @@
|
|||
|
||||
#define SCM_WHITE_SPACES SCM_SINGLE_SPACES: case '\t'
|
||||
|
||||
extern scm_t_option scm_read_opts[];
|
||||
SCM_API scm_t_option scm_read_opts[];
|
||||
|
||||
#define SCM_COPY_SOURCE_P scm_read_opts[0].val
|
||||
#define SCM_RECORD_POSITIONS_P scm_read_opts[1].val
|
||||
|
@ -79,17 +79,17 @@ extern scm_t_option scm_read_opts[];
|
|||
|
||||
|
||||
|
||||
extern SCM scm_read_options (SCM setting);
|
||||
extern SCM scm_read (SCM port);
|
||||
extern char * scm_grow_tok_buf (SCM * tok_buf);
|
||||
extern int scm_flush_ws (SCM port, const char *eoferr);
|
||||
extern int scm_casei_streq (char * s1, char * s2);
|
||||
extern SCM scm_lreadr (SCM * tok_buf, SCM port, SCM *copy);
|
||||
extern size_t scm_read_token (int ic, SCM * tok_buf, SCM port, int weird);
|
||||
extern SCM scm_lreadparen (SCM * tok_buf, SCM port, char *name, SCM *copy);
|
||||
extern SCM scm_lreadrecparen (SCM * tok_buf, SCM port, char *name, SCM *copy);
|
||||
extern SCM scm_read_hash_extend (SCM chr, SCM proc);
|
||||
extern void scm_init_read (void);
|
||||
SCM_API SCM scm_read_options (SCM setting);
|
||||
SCM_API SCM scm_read (SCM port);
|
||||
SCM_API char * scm_grow_tok_buf (SCM * tok_buf);
|
||||
SCM_API int scm_flush_ws (SCM port, const char *eoferr);
|
||||
SCM_API int scm_casei_streq (char * s1, char * s2);
|
||||
SCM_API SCM scm_lreadr (SCM * tok_buf, SCM port, SCM *copy);
|
||||
SCM_API size_t scm_read_token (int ic, SCM * tok_buf, SCM port, int weird);
|
||||
SCM_API SCM scm_lreadparen (SCM * tok_buf, SCM port, char *name, SCM *copy);
|
||||
SCM_API SCM scm_lreadrecparen (SCM * tok_buf, SCM port, char *name, SCM *copy);
|
||||
SCM_API SCM scm_read_hash_extend (SCM chr, SCM proc);
|
||||
SCM_API void scm_init_read (void);
|
||||
|
||||
#endif /* SCM_READ_H */
|
||||
|
||||
|
|
|
@ -48,14 +48,14 @@
|
|||
|
||||
#include "libguile/__scm.h"
|
||||
|
||||
extern scm_t_bits scm_tc16_regex;
|
||||
SCM_API scm_t_bits scm_tc16_regex;
|
||||
#define SCM_RGX(X) ((regex_t *) SCM_CELL_WORD_1 (X))
|
||||
#define SCM_RGXP(X) (!SCM_IMP (X) && (SCM_CELL_TYPE (X) == scm_tc16_regex))
|
||||
|
||||
extern SCM scm_make_regexp (SCM pat, SCM flags);
|
||||
SCM scm_regexp_p (SCM x);
|
||||
extern SCM scm_regexp_exec (SCM rx, SCM str, SCM start, SCM flags);
|
||||
extern void scm_init_regex_posix (void);
|
||||
SCM_API SCM scm_make_regexp (SCM pat, SCM flags);
|
||||
SCM_API SCM scm_regexp_p (SCM x);
|
||||
SCM_API SCM scm_regexp_exec (SCM rx, SCM str, SCM start, SCM flags);
|
||||
SCM_API void scm_init_regex_posix (void);
|
||||
|
||||
#endif /* SCM_REGEX_POSIX_H */
|
||||
|
||||
|
|
|
@ -72,11 +72,11 @@
|
|||
#define SCM_NUM_PROTECTS 13
|
||||
#endif
|
||||
|
||||
extern SCM scm_sys_protects[];
|
||||
SCM_API SCM scm_sys_protects[];
|
||||
|
||||
|
||||
|
||||
extern scm_t_bits scm_tc16_root;
|
||||
SCM_API scm_t_bits scm_tc16_root;
|
||||
|
||||
#define SCM_ROOTP(obj) SCM_TYP16_PREDICATE (scm_tc16_root, obj)
|
||||
#define SCM_ROOT_STATE(root) ((scm_root_state *) SCM_CELL_WORD_1 (root))
|
||||
|
@ -134,22 +134,22 @@ typedef struct scm_root_state
|
|||
#define scm_root ((scm_root_state *) SCM_THREAD_LOCAL_DATA)
|
||||
#define scm_set_root(new_root) SCM_SET_THREAD_LOCAL_DATA (new_root)
|
||||
#else /* USE_THREADS */
|
||||
extern struct scm_root_state *scm_root;
|
||||
SCM_API struct scm_root_state *scm_root;
|
||||
#define scm_set_root(new_root) (scm_root = (new_root))
|
||||
#endif /* USE_THREADS */
|
||||
|
||||
|
||||
|
||||
extern SCM scm_make_root (SCM parent);
|
||||
extern SCM scm_internal_cwdr (scm_t_catch_body body,
|
||||
void *body_data,
|
||||
scm_t_catch_handler handler,
|
||||
void *handler_data,
|
||||
SCM_STACKITEM *stack_start);
|
||||
extern SCM scm_call_with_dynamic_root (SCM thunk, SCM handler);
|
||||
extern SCM scm_dynamic_root (void);
|
||||
extern SCM scm_apply_with_dynamic_root (SCM proc, SCM a1, SCM args, SCM handler);
|
||||
extern void scm_init_root (void);
|
||||
SCM_API SCM scm_make_root (SCM parent);
|
||||
SCM_API SCM scm_internal_cwdr (scm_t_catch_body body,
|
||||
void *body_data,
|
||||
scm_t_catch_handler handler,
|
||||
void *handler_data,
|
||||
SCM_STACKITEM *stack_start);
|
||||
SCM_API SCM scm_call_with_dynamic_root (SCM thunk, SCM handler);
|
||||
SCM_API SCM scm_dynamic_root (void);
|
||||
SCM_API SCM scm_apply_with_dynamic_root (SCM proc, SCM a1, SCM args, SCM handler);
|
||||
SCM_API void scm_init_root (void);
|
||||
|
||||
#endif /* SCM_ROOT_H */
|
||||
|
||||
|
|
|
@ -48,13 +48,13 @@
|
|||
|
||||
#include "libguile/__scm.h"
|
||||
|
||||
extern SCM scm_read_string_x_partial (SCM str, SCM port_or_fdes, SCM start,
|
||||
SCM_API SCM scm_read_string_x_partial (SCM str, SCM port_or_fdes, SCM start,
|
||||
SCM end);
|
||||
SCM_API SCM scm_write_string_partial (SCM str, SCM port_or_fdes, SCM start,
|
||||
SCM end);
|
||||
extern SCM scm_write_string_partial (SCM str, SCM port_or_fdes, SCM start,
|
||||
SCM end);
|
||||
|
||||
SCM scm_init_rw_builtins (void);
|
||||
void scm_init_rw (void);
|
||||
SCM_API SCM scm_init_rw_builtins (void);
|
||||
SCM_API void scm_init_rw (void);
|
||||
|
||||
#endif /* SCM_RW_H */
|
||||
|
||||
|
|
|
@ -50,18 +50,18 @@
|
|||
|
||||
|
||||
|
||||
extern SCM scm_sigaction (SCM signum, SCM handler, SCM flags);
|
||||
extern SCM scm_restore_signals (void);
|
||||
extern SCM scm_alarm (SCM i);
|
||||
extern SCM scm_setitimer (SCM which_timer,
|
||||
SCM interval_seconds, SCM interval_microseconds,
|
||||
SCM value_seconds, SCM value_microseconds);
|
||||
extern SCM scm_getitimer (SCM which_timer);
|
||||
extern SCM scm_pause (void);
|
||||
extern SCM scm_sleep (SCM i);
|
||||
extern SCM scm_usleep (SCM i);
|
||||
extern SCM scm_raise (SCM sig);
|
||||
extern void scm_init_scmsigs (void);
|
||||
SCM_API SCM scm_sigaction (SCM signum, SCM handler, SCM flags);
|
||||
SCM_API SCM scm_restore_signals (void);
|
||||
SCM_API SCM scm_alarm (SCM i);
|
||||
SCM_API SCM scm_setitimer (SCM which_timer,
|
||||
SCM interval_seconds, SCM interval_microseconds,
|
||||
SCM value_seconds, SCM value_microseconds);
|
||||
SCM_API SCM scm_getitimer (SCM which_timer);
|
||||
SCM_API SCM scm_pause (void);
|
||||
SCM_API SCM scm_sleep (SCM i);
|
||||
SCM_API SCM scm_usleep (SCM i);
|
||||
SCM_API SCM scm_raise (SCM sig);
|
||||
SCM_API void scm_init_scmsigs (void);
|
||||
|
||||
#endif /* SCM_SCMSIGS_H */
|
||||
|
||||
|
|
|
@ -49,18 +49,18 @@
|
|||
#include "libguile/__scm.h"
|
||||
|
||||
|
||||
extern char *scm_find_executable (const char *name);
|
||||
extern char *scm_find_impl_file (char *exec_path,
|
||||
const char *generic_name,
|
||||
const char *initname,
|
||||
const char *sep);
|
||||
extern char **scm_get_meta_args (int argc, char **argv);
|
||||
extern int scm_count_argv (char **argv);
|
||||
extern void scm_shell_usage (int fatal, char *message);
|
||||
extern SCM scm_compile_shell_switches (int argc, char **argv);
|
||||
extern void scm_shell (int argc, char **argv);
|
||||
extern char *scm_usage_name;
|
||||
extern void scm_init_script (void);
|
||||
SCM_API char *scm_find_executable (const char *name);
|
||||
SCM_API char *scm_find_impl_file (char *exec_path,
|
||||
const char *generic_name,
|
||||
const char *initname,
|
||||
const char *sep);
|
||||
SCM_API char **scm_get_meta_args (int argc, char **argv);
|
||||
SCM_API int scm_count_argv (char **argv);
|
||||
SCM_API void scm_shell_usage (int fatal, char *message);
|
||||
SCM_API SCM scm_compile_shell_switches (int argc, char **argv);
|
||||
SCM_API void scm_shell (int argc, char **argv);
|
||||
SCM_API char *scm_usage_name;
|
||||
SCM_API void scm_init_script (void);
|
||||
|
||||
#endif /* SCM_SCRIPT_H */
|
||||
|
||||
|
|
|
@ -50,10 +50,10 @@
|
|||
|
||||
|
||||
|
||||
extern SCM scm_system (SCM cmd);
|
||||
extern SCM scm_getenv (SCM nam);
|
||||
extern SCM scm_primitive_exit (SCM status);
|
||||
extern void scm_init_simpos (void);
|
||||
SCM_API SCM scm_system (SCM cmd);
|
||||
SCM_API SCM scm_getenv (SCM nam);
|
||||
SCM_API SCM scm_primitive_exit (SCM status);
|
||||
SCM_API void scm_init_simpos (void);
|
||||
|
||||
#endif /* SCM_SIMPOS_H */
|
||||
|
||||
|
|
|
@ -127,16 +127,16 @@ do { \
|
|||
#define SCM_SMOB_APPLY_2(x,a1,a2) (SCM_SMOB_DESCRIPTOR (x).apply_2 (x, (a1), (a2)))
|
||||
#define SCM_SMOB_APPLY_3(x,a1,a2,rst) (SCM_SMOB_DESCRIPTOR (x).apply_3 (x, (a1), (a2), (rst)))
|
||||
|
||||
extern long scm_numsmob;
|
||||
extern scm_smob_descriptor scm_smobs[];
|
||||
SCM_API long scm_numsmob;
|
||||
SCM_API scm_smob_descriptor scm_smobs[];
|
||||
|
||||
|
||||
|
||||
extern SCM scm_mark0 (SCM ptr);
|
||||
extern SCM scm_markcdr (SCM ptr);
|
||||
extern size_t scm_free0 (SCM ptr);
|
||||
extern size_t scm_smob_free (SCM obj);
|
||||
extern int scm_smob_print (SCM exp, SCM port, scm_print_state *pstate);
|
||||
SCM_API SCM scm_mark0 (SCM ptr);
|
||||
SCM_API SCM scm_markcdr (SCM ptr);
|
||||
SCM_API size_t scm_free0 (SCM ptr);
|
||||
SCM_API size_t scm_smob_free (SCM obj);
|
||||
SCM_API int scm_smob_print (SCM exp, SCM port, scm_print_state *pstate);
|
||||
|
||||
/* The following set of functions is the standard way to create new
|
||||
* SMOB types.
|
||||
|
@ -146,23 +146,23 @@ extern int scm_smob_print (SCM exp, SCM port, scm_print_state *pstate);
|
|||
* values using `scm_set_smob_xxx'.
|
||||
*/
|
||||
|
||||
extern scm_t_bits scm_make_smob_type (char *name, size_t size);
|
||||
SCM_API scm_t_bits scm_make_smob_type (char *name, size_t size);
|
||||
|
||||
extern void scm_set_smob_mark (scm_t_bits tc, SCM (*mark) (SCM));
|
||||
extern void scm_set_smob_free (scm_t_bits tc, size_t (*free) (SCM));
|
||||
extern void scm_set_smob_print (scm_t_bits tc,
|
||||
int (*print) (SCM, SCM, scm_print_state*));
|
||||
extern void scm_set_smob_equalp (scm_t_bits tc, SCM (*equalp) (SCM, SCM));
|
||||
extern void scm_set_smob_apply (scm_t_bits tc,
|
||||
SCM (*apply) (),
|
||||
unsigned int req,
|
||||
unsigned int opt,
|
||||
unsigned int rst);
|
||||
SCM_API void scm_set_smob_mark (scm_t_bits tc, SCM (*mark) (SCM));
|
||||
SCM_API void scm_set_smob_free (scm_t_bits tc, size_t (*free) (SCM));
|
||||
SCM_API void scm_set_smob_print (scm_t_bits tc,
|
||||
int (*print) (SCM, SCM, scm_print_state*));
|
||||
SCM_API void scm_set_smob_equalp (scm_t_bits tc, SCM (*equalp) (SCM, SCM));
|
||||
SCM_API void scm_set_smob_apply (scm_t_bits tc,
|
||||
SCM (*apply) (),
|
||||
unsigned int req,
|
||||
unsigned int opt,
|
||||
unsigned int rst);
|
||||
|
||||
/* Function for creating smobs */
|
||||
|
||||
extern SCM scm_make_smob (scm_t_bits tc);
|
||||
extern void scm_smob_prehistory (void);
|
||||
SCM_API SCM scm_make_smob (scm_t_bits tc);
|
||||
SCM_API void scm_smob_prehistory (void);
|
||||
|
||||
#endif /* SCM_SMOB_H */
|
||||
|
||||
|
|
|
@ -50,34 +50,34 @@
|
|||
|
||||
|
||||
|
||||
extern SCM scm_htons (SCM in);
|
||||
extern SCM scm_ntohs (SCM in);
|
||||
extern SCM scm_htonl (SCM in);
|
||||
extern SCM scm_ntohl (SCM in);
|
||||
extern SCM scm_gethost (SCM name);
|
||||
extern SCM scm_inet_aton (SCM address);
|
||||
extern SCM scm_inet_ntoa (SCM inetid);
|
||||
extern SCM scm_inet_netof (SCM address);
|
||||
extern SCM scm_lnaof (SCM address);
|
||||
extern SCM scm_inet_makeaddr (SCM net, SCM lna);
|
||||
extern SCM scm_inet_pton (SCM family, SCM address);
|
||||
extern SCM scm_inet_ntop (SCM family, SCM address);
|
||||
extern SCM scm_socket (SCM family, SCM style, SCM proto);
|
||||
extern SCM scm_socketpair (SCM family, SCM style, SCM proto);
|
||||
extern SCM scm_getsockopt (SCM sfd, SCM level, SCM optname);
|
||||
extern SCM scm_setsockopt (SCM sfd, SCM level, SCM optname, SCM value);
|
||||
extern SCM scm_shutdown (SCM sfd, SCM how);
|
||||
extern SCM scm_connect (SCM sockfd, SCM fam, SCM address, SCM args);
|
||||
extern SCM scm_bind (SCM sockfd, SCM fam, SCM address, SCM args);
|
||||
extern SCM scm_listen (SCM sfd, SCM backlog);
|
||||
extern SCM scm_accept (SCM sockfd);
|
||||
extern SCM scm_getsockname (SCM sockfd);
|
||||
extern SCM scm_getpeername (SCM sockfd);
|
||||
extern SCM scm_recv (SCM sockfd, SCM buff_or_size, SCM flags);
|
||||
extern SCM scm_send (SCM sockfd, SCM message, SCM flags);
|
||||
extern SCM scm_recvfrom (SCM sockfd, SCM buff_or_size, SCM flags, SCM offset, SCM length);
|
||||
extern SCM scm_sendto (SCM sockfd, SCM message, SCM fam, SCM address, SCM args_and_flags);
|
||||
extern void scm_init_socket (void);
|
||||
SCM_API SCM scm_htons (SCM in);
|
||||
SCM_API SCM scm_ntohs (SCM in);
|
||||
SCM_API SCM scm_htonl (SCM in);
|
||||
SCM_API SCM scm_ntohl (SCM in);
|
||||
SCM_API SCM scm_gethost (SCM name);
|
||||
SCM_API SCM scm_inet_aton (SCM address);
|
||||
SCM_API SCM scm_inet_ntoa (SCM inetid);
|
||||
SCM_API SCM scm_inet_netof (SCM address);
|
||||
SCM_API SCM scm_lnaof (SCM address);
|
||||
SCM_API SCM scm_inet_makeaddr (SCM net, SCM lna);
|
||||
SCM_API SCM scm_inet_pton (SCM family, SCM address);
|
||||
SCM_API SCM scm_inet_ntop (SCM family, SCM address);
|
||||
SCM_API SCM scm_socket (SCM family, SCM style, SCM proto);
|
||||
SCM_API SCM scm_socketpair (SCM family, SCM style, SCM proto);
|
||||
SCM_API SCM scm_getsockopt (SCM sfd, SCM level, SCM optname);
|
||||
SCM_API SCM scm_setsockopt (SCM sfd, SCM level, SCM optname, SCM value);
|
||||
SCM_API SCM scm_shutdown (SCM sfd, SCM how);
|
||||
SCM_API SCM scm_connect (SCM sockfd, SCM fam, SCM address, SCM args);
|
||||
SCM_API SCM scm_bind (SCM sockfd, SCM fam, SCM address, SCM args);
|
||||
SCM_API SCM scm_listen (SCM sfd, SCM backlog);
|
||||
SCM_API SCM scm_accept (SCM sockfd);
|
||||
SCM_API SCM scm_getsockname (SCM sockfd);
|
||||
SCM_API SCM scm_getpeername (SCM sockfd);
|
||||
SCM_API SCM scm_recv (SCM sockfd, SCM buff_or_size, SCM flags);
|
||||
SCM_API SCM scm_send (SCM sockfd, SCM message, SCM flags);
|
||||
SCM_API SCM scm_recvfrom (SCM sockfd, SCM buff_or_size, SCM flags, SCM offset, SCM length);
|
||||
SCM_API SCM scm_sendto (SCM sockfd, SCM message, SCM fam, SCM address, SCM args_and_flags);
|
||||
SCM_API void scm_init_socket (void);
|
||||
|
||||
#endif /* SCM_SOCKET_H */
|
||||
|
||||
|
|
|
@ -50,20 +50,20 @@
|
|||
|
||||
|
||||
|
||||
extern SCM scm_restricted_vector_sort_x (SCM vec,
|
||||
SCM less,
|
||||
SCM startpos,
|
||||
SCM endpos);
|
||||
extern SCM scm_sorted_p (SCM ls, SCM less);
|
||||
extern SCM scm_merge (SCM ls1, SCM ls2, SCM less);
|
||||
extern SCM scm_merge_x (SCM ls1, SCM ls2, SCM less);
|
||||
extern SCM scm_sort (SCM ls, SCM less);
|
||||
extern SCM scm_sort_x (SCM ls, SCM less);
|
||||
extern SCM scm_stable_sort (SCM ls, SCM less);
|
||||
extern SCM scm_stable_sort_x (SCM ls, SCM less);
|
||||
extern SCM scm_sort_list (SCM ls, SCM less);
|
||||
extern SCM scm_sort_list_x (SCM ls, SCM less);
|
||||
extern void scm_init_sort (void);
|
||||
SCM_API SCM scm_restricted_vector_sort_x (SCM vec,
|
||||
SCM less,
|
||||
SCM startpos,
|
||||
SCM endpos);
|
||||
SCM_API SCM scm_sorted_p (SCM ls, SCM less);
|
||||
SCM_API SCM scm_merge (SCM ls1, SCM ls2, SCM less);
|
||||
SCM_API SCM scm_merge_x (SCM ls1, SCM ls2, SCM less);
|
||||
SCM_API SCM scm_sort (SCM ls, SCM less);
|
||||
SCM_API SCM scm_sort_x (SCM ls, SCM less);
|
||||
SCM_API SCM scm_stable_sort (SCM ls, SCM less);
|
||||
SCM_API SCM scm_stable_sort_x (SCM ls, SCM less);
|
||||
SCM_API SCM scm_sort_list (SCM ls, SCM less);
|
||||
SCM_API SCM scm_sort_list_x (SCM ls, SCM less);
|
||||
SCM_API void scm_init_sort (void);
|
||||
|
||||
#endif /* SCM_SORT_H */
|
||||
|
||||
|
|
|
@ -77,7 +77,7 @@ do { \
|
|||
/* {Source properties}
|
||||
*/
|
||||
|
||||
extern scm_t_bits scm_tc16_srcprops;
|
||||
SCM_API scm_t_bits scm_tc16_srcprops;
|
||||
|
||||
typedef struct scm_t_srcprops
|
||||
{
|
||||
|
@ -122,23 +122,23 @@ typedef struct scm_t_srcprops_chunk
|
|||
|
||||
#define PROCTRACEP(x) (!SCM_FALSEP (scm_procedure_property (x, scm_sym_trace)))
|
||||
|
||||
extern SCM scm_sym_filename;
|
||||
extern SCM scm_sym_copy;
|
||||
extern SCM scm_sym_line;
|
||||
extern SCM scm_sym_column;
|
||||
extern SCM scm_sym_breakpoint;
|
||||
SCM_API SCM scm_sym_filename;
|
||||
SCM_API SCM scm_sym_copy;
|
||||
SCM_API SCM scm_sym_line;
|
||||
SCM_API SCM scm_sym_column;
|
||||
SCM_API SCM scm_sym_breakpoint;
|
||||
|
||||
|
||||
|
||||
|
||||
extern SCM scm_srcprops_to_plist (SCM obj);
|
||||
extern SCM scm_make_srcprops (long line, int col, SCM fname, SCM copy, SCM plist);
|
||||
extern SCM scm_source_property (SCM obj, SCM key);
|
||||
extern SCM scm_set_source_property_x (SCM obj, SCM key, SCM datum);
|
||||
extern SCM scm_source_properties (SCM obj);
|
||||
extern SCM scm_set_source_properties_x (SCM obj, SCM props);
|
||||
extern void scm_finish_srcprop (void);
|
||||
extern void scm_init_srcprop (void);
|
||||
SCM_API SCM scm_srcprops_to_plist (SCM obj);
|
||||
SCM_API SCM scm_make_srcprops (long line, int col, SCM fname, SCM copy, SCM plist);
|
||||
SCM_API SCM scm_source_property (SCM obj, SCM key);
|
||||
SCM_API SCM scm_set_source_property_x (SCM obj, SCM key, SCM datum);
|
||||
SCM_API SCM scm_source_properties (SCM obj);
|
||||
SCM_API SCM scm_set_source_properties_x (SCM obj, SCM props);
|
||||
SCM_API void scm_finish_srcprop (void);
|
||||
SCM_API void scm_init_srcprop (void);
|
||||
|
||||
#endif /* SCM_SRCPROP_H */
|
||||
|
||||
|
|
|
@ -83,14 +83,14 @@
|
|||
# define SCM_CHECK_STACK /**/
|
||||
#endif /* STACK_CHECKING */
|
||||
|
||||
extern int scm_stack_checking_enabled_p;
|
||||
SCM_API int scm_stack_checking_enabled_p;
|
||||
|
||||
|
||||
|
||||
extern void scm_report_stack_overflow (void);
|
||||
extern long scm_stack_size (SCM_STACKITEM *start);
|
||||
extern void scm_stack_report (void);
|
||||
extern void scm_init_stackchk (void);
|
||||
SCM_API void scm_report_stack_overflow (void);
|
||||
SCM_API long scm_stack_size (SCM_STACKITEM *start);
|
||||
SCM_API void scm_stack_report (void);
|
||||
SCM_API void scm_init_stackchk (void);
|
||||
|
||||
#endif /* SCM_STACKCHK_H */
|
||||
|
||||
|
|
|
@ -73,7 +73,7 @@ typedef struct scm_t_stack {
|
|||
scm_t_info_frame tail[1];
|
||||
} scm_t_stack;
|
||||
|
||||
extern SCM scm_t_stackype;
|
||||
SCM_API SCM scm_t_stackype;
|
||||
|
||||
#define SCM_STACKP(obj) (SCM_STRUCTP (obj) && SCM_EQ_P (SCM_STRUCT_VTABLE (obj), scm_t_stackype))
|
||||
#define SCM_STACK_LENGTH(stack) (SCM_STACK (stack) -> length)
|
||||
|
@ -115,26 +115,26 @@ extern SCM scm_t_stackype;
|
|||
|
||||
|
||||
|
||||
SCM scm_stack_p (SCM obj);
|
||||
SCM scm_make_stack (SCM obj, SCM args);
|
||||
SCM scm_stack_id (SCM stack);
|
||||
SCM scm_stack_ref (SCM stack, SCM i);
|
||||
SCM scm_stack_length (SCM stack);
|
||||
SCM_API SCM scm_stack_p (SCM obj);
|
||||
SCM_API SCM scm_make_stack (SCM obj, SCM args);
|
||||
SCM_API SCM scm_stack_id (SCM stack);
|
||||
SCM_API SCM scm_stack_ref (SCM stack, SCM i);
|
||||
SCM_API SCM scm_stack_length (SCM stack);
|
||||
|
||||
SCM scm_frame_p (SCM obj);
|
||||
SCM scm_last_stack_frame (SCM obj);
|
||||
SCM scm_frame_number (SCM frame);
|
||||
SCM scm_frame_source (SCM frame);
|
||||
SCM scm_frame_procedure (SCM frame);
|
||||
SCM scm_frame_arguments (SCM frame);
|
||||
SCM scm_frame_previous (SCM frame);
|
||||
SCM scm_frame_next (SCM frame);
|
||||
SCM scm_frame_real_p (SCM frame);
|
||||
SCM scm_frame_procedure_p (SCM frame);
|
||||
SCM scm_frame_evaluating_args_p (SCM frame);
|
||||
SCM scm_frame_overflow_p (SCM frame);
|
||||
SCM_API SCM scm_frame_p (SCM obj);
|
||||
SCM_API SCM scm_last_stack_frame (SCM obj);
|
||||
SCM_API SCM scm_frame_number (SCM frame);
|
||||
SCM_API SCM scm_frame_source (SCM frame);
|
||||
SCM_API SCM scm_frame_procedure (SCM frame);
|
||||
SCM_API SCM scm_frame_arguments (SCM frame);
|
||||
SCM_API SCM scm_frame_previous (SCM frame);
|
||||
SCM_API SCM scm_frame_next (SCM frame);
|
||||
SCM_API SCM scm_frame_real_p (SCM frame);
|
||||
SCM_API SCM scm_frame_procedure_p (SCM frame);
|
||||
SCM_API SCM scm_frame_evaluating_args_p (SCM frame);
|
||||
SCM_API SCM scm_frame_overflow_p (SCM frame);
|
||||
|
||||
void scm_init_stacks (void);
|
||||
SCM_API void scm_init_stacks (void);
|
||||
|
||||
#endif /* SCM_STACKS_H */
|
||||
|
||||
|
|
|
@ -49,19 +49,19 @@
|
|||
#include "libguile/__scm.h"
|
||||
|
||||
|
||||
long scm_c_get_internal_run_time (void);
|
||||
extern SCM scm_get_internal_real_time (void);
|
||||
extern SCM scm_get_internal_run_time (void);
|
||||
extern SCM scm_current_time (void);
|
||||
extern SCM scm_gettimeofday (void);
|
||||
extern SCM scm_localtime (SCM time, SCM zone);
|
||||
extern SCM scm_gmtime (SCM time);
|
||||
extern SCM scm_mktime (SCM sbd_time, SCM zone);
|
||||
extern SCM scm_tzset (void);
|
||||
extern SCM scm_times (void);
|
||||
extern SCM scm_strftime (SCM format, SCM stime);
|
||||
extern SCM scm_strptime (SCM format, SCM string);
|
||||
extern void scm_init_stime (void);
|
||||
SCM_API long scm_c_get_internal_run_time (void);
|
||||
SCM_API SCM scm_get_internal_real_time (void);
|
||||
SCM_API SCM scm_get_internal_run_time (void);
|
||||
SCM_API SCM scm_current_time (void);
|
||||
SCM_API SCM scm_gettimeofday (void);
|
||||
SCM_API SCM scm_localtime (SCM time, SCM zone);
|
||||
SCM_API SCM scm_gmtime (SCM time);
|
||||
SCM_API SCM scm_mktime (SCM sbd_time, SCM zone);
|
||||
SCM_API SCM scm_tzset (void);
|
||||
SCM_API SCM scm_times (void);
|
||||
SCM_API SCM scm_strftime (SCM format, SCM stime);
|
||||
SCM_API SCM scm_strptime (SCM format, SCM string);
|
||||
SCM_API void scm_init_stime (void);
|
||||
|
||||
#endif /* SCM_STIME_H */
|
||||
|
||||
|
|
|
@ -60,23 +60,23 @@
|
|||
|
||||
|
||||
|
||||
extern SCM scm_string_p (SCM x);
|
||||
extern SCM scm_string (SCM chrs);
|
||||
extern SCM scm_makfromstrs (int argc, char **argv);
|
||||
extern SCM scm_take_str (char *s, size_t len);
|
||||
extern SCM scm_take0str (char *s);
|
||||
extern SCM scm_mem2string (const char *src, size_t len);
|
||||
extern SCM scm_str2string (const char *src);
|
||||
extern SCM scm_makfrom0str (const char *src);
|
||||
extern SCM scm_makfrom0str_opt (const char *src);
|
||||
extern SCM scm_allocate_string (size_t len);
|
||||
extern SCM scm_make_string (SCM k, SCM chr);
|
||||
extern SCM scm_string_length (SCM str);
|
||||
extern SCM scm_string_ref (SCM str, SCM k);
|
||||
extern SCM scm_string_set_x (SCM str, SCM k, SCM chr);
|
||||
extern SCM scm_substring (SCM str, SCM start, SCM end);
|
||||
extern SCM scm_string_append (SCM args);
|
||||
extern void scm_init_strings (void);
|
||||
SCM_API SCM scm_string_p (SCM x);
|
||||
SCM_API SCM scm_string (SCM chrs);
|
||||
SCM_API SCM scm_makfromstrs (int argc, char **argv);
|
||||
SCM_API SCM scm_take_str (char *s, size_t len);
|
||||
SCM_API SCM scm_take0str (char *s);
|
||||
SCM_API SCM scm_mem2string (const char *src, size_t len);
|
||||
SCM_API SCM scm_str2string (const char *src);
|
||||
SCM_API SCM scm_makfrom0str (const char *src);
|
||||
SCM_API SCM scm_makfrom0str_opt (const char *src);
|
||||
SCM_API SCM scm_allocate_string (size_t len);
|
||||
SCM_API SCM scm_make_string (SCM k, SCM chr);
|
||||
SCM_API SCM scm_string_length (SCM str);
|
||||
SCM_API SCM scm_string_ref (SCM str, SCM k);
|
||||
SCM_API SCM scm_string_set_x (SCM str, SCM k, SCM chr);
|
||||
SCM_API SCM scm_substring (SCM str, SCM start, SCM end);
|
||||
SCM_API SCM scm_string_append (SCM args);
|
||||
SCM_API void scm_init_strings (void);
|
||||
|
||||
|
||||
|
||||
|
|
|
@ -50,24 +50,24 @@
|
|||
|
||||
|
||||
|
||||
extern SCM scm_string_index (SCM str, SCM chr, SCM frm, SCM to);
|
||||
extern SCM scm_string_rindex (SCM str, SCM chr, SCM frm, SCM to);
|
||||
extern SCM scm_substring_move_x (SCM str1, SCM start1, SCM end1,
|
||||
SCM str2, SCM start2);
|
||||
extern SCM scm_substring_fill_x (SCM str, SCM start, SCM end, SCM fill);
|
||||
extern SCM scm_string_null_p (SCM str);
|
||||
extern SCM scm_string_to_list (SCM str);
|
||||
extern SCM scm_string_copy (SCM str);
|
||||
extern SCM scm_string_fill_x (SCM str, SCM chr);
|
||||
extern void scm_init_strop (void);
|
||||
extern SCM scm_string_upcase_x (SCM v);
|
||||
extern SCM scm_string_upcase (SCM v);
|
||||
extern SCM scm_string_downcase_x (SCM v);
|
||||
extern SCM scm_string_downcase (SCM v);
|
||||
extern SCM scm_string_capitalize_x (SCM v);
|
||||
extern SCM scm_string_capitalize (SCM v);
|
||||
extern SCM scm_string_split (SCM str, SCM chr);
|
||||
extern SCM scm_string_ci_to_symbol (SCM v);
|
||||
SCM_API SCM scm_string_index (SCM str, SCM chr, SCM frm, SCM to);
|
||||
SCM_API SCM scm_string_rindex (SCM str, SCM chr, SCM frm, SCM to);
|
||||
SCM_API SCM scm_substring_move_x (SCM str1, SCM start1, SCM end1,
|
||||
SCM str2, SCM start2);
|
||||
SCM_API SCM scm_substring_fill_x (SCM str, SCM start, SCM end, SCM fill);
|
||||
SCM_API SCM scm_string_null_p (SCM str);
|
||||
SCM_API SCM scm_string_to_list (SCM str);
|
||||
SCM_API SCM scm_string_copy (SCM str);
|
||||
SCM_API SCM scm_string_fill_x (SCM str, SCM chr);
|
||||
SCM_API void scm_init_strop (void);
|
||||
SCM_API SCM scm_string_upcase_x (SCM v);
|
||||
SCM_API SCM scm_string_upcase (SCM v);
|
||||
SCM_API SCM scm_string_downcase_x (SCM v);
|
||||
SCM_API SCM scm_string_downcase (SCM v);
|
||||
SCM_API SCM scm_string_capitalize_x (SCM v);
|
||||
SCM_API SCM scm_string_capitalize (SCM v);
|
||||
SCM_API SCM scm_string_split (SCM str, SCM chr);
|
||||
SCM_API SCM scm_string_ci_to_symbol (SCM v);
|
||||
|
||||
#define scm_substring_move_left_x scm_substring_move_x
|
||||
#define scm_substring_move_right_x scm_substring_move_x
|
||||
|
|
|
@ -50,17 +50,17 @@
|
|||
|
||||
|
||||
|
||||
extern SCM scm_string_equal_p (SCM s1, SCM s2);
|
||||
extern SCM scm_string_ci_equal_p (SCM s1, SCM s2);
|
||||
extern SCM scm_string_less_p (SCM s1, SCM s2);
|
||||
extern SCM scm_string_leq_p (SCM s1, SCM s2);
|
||||
extern SCM scm_string_gr_p (SCM s1, SCM s2);
|
||||
extern SCM scm_string_geq_p (SCM s1, SCM s2);
|
||||
extern SCM scm_string_ci_less_p (SCM s1, SCM s2);
|
||||
extern SCM scm_string_ci_leq_p (SCM s1, SCM s2);
|
||||
extern SCM scm_string_ci_gr_p (SCM s1, SCM s2);
|
||||
extern SCM scm_string_ci_geq_p (SCM s1, SCM s2);
|
||||
extern void scm_init_strorder (void);
|
||||
SCM_API SCM scm_string_equal_p (SCM s1, SCM s2);
|
||||
SCM_API SCM scm_string_ci_equal_p (SCM s1, SCM s2);
|
||||
SCM_API SCM scm_string_less_p (SCM s1, SCM s2);
|
||||
SCM_API SCM scm_string_leq_p (SCM s1, SCM s2);
|
||||
SCM_API SCM scm_string_gr_p (SCM s1, SCM s2);
|
||||
SCM_API SCM scm_string_geq_p (SCM s1, SCM s2);
|
||||
SCM_API SCM scm_string_ci_less_p (SCM s1, SCM s2);
|
||||
SCM_API SCM scm_string_ci_leq_p (SCM s1, SCM s2);
|
||||
SCM_API SCM scm_string_ci_gr_p (SCM s1, SCM s2);
|
||||
SCM_API SCM scm_string_ci_geq_p (SCM s1, SCM s2);
|
||||
SCM_API void scm_init_strorder (void);
|
||||
|
||||
#endif /* SCM_STRORDER_H */
|
||||
|
||||
|
|
|
@ -62,22 +62,22 @@
|
|||
|
||||
|
||||
|
||||
extern scm_t_bits scm_tc16_strport;
|
||||
SCM_API scm_t_bits scm_tc16_strport;
|
||||
|
||||
|
||||
|
||||
extern SCM scm_mkstrport (SCM pos, SCM str, long modes, const char * caller);
|
||||
extern SCM scm_strport_to_string (SCM port);
|
||||
extern SCM scm_object_to_string (SCM obj, SCM printer);
|
||||
extern SCM scm_call_with_output_string (SCM proc);
|
||||
extern SCM scm_call_with_input_string (SCM str, SCM proc);
|
||||
extern SCM scm_open_input_string (SCM str);
|
||||
extern SCM scm_open_output_string (void);
|
||||
extern SCM scm_get_output_string (SCM port);
|
||||
extern SCM scm_c_read_string (const char *expr);
|
||||
extern SCM scm_c_eval_string (const char *expr);
|
||||
extern SCM scm_eval_string (SCM string);
|
||||
extern void scm_init_strports (void);
|
||||
SCM_API SCM scm_mkstrport (SCM pos, SCM str, long modes, const char * caller);
|
||||
SCM_API SCM scm_strport_to_string (SCM port);
|
||||
SCM_API SCM scm_object_to_string (SCM obj, SCM printer);
|
||||
SCM_API SCM scm_call_with_output_string (SCM proc);
|
||||
SCM_API SCM scm_call_with_input_string (SCM str, SCM proc);
|
||||
SCM_API SCM scm_open_input_string (SCM str);
|
||||
SCM_API SCM scm_open_output_string (void);
|
||||
SCM_API SCM scm_get_output_string (SCM port);
|
||||
SCM_API SCM scm_c_read_string (const char *expr);
|
||||
SCM_API SCM scm_c_eval_string (const char *expr);
|
||||
SCM_API SCM scm_eval_string (SCM string);
|
||||
SCM_API void scm_init_strports (void);
|
||||
|
||||
#endif /* SCM_STRPORTS_H */
|
||||
|
||||
|
|
|
@ -99,35 +99,35 @@ typedef size_t (*scm_t_struct_free) (scm_t_bits * vtable, scm_t_bits * data);
|
|||
#define SCM_SET_STRUCT_TABLE_NAME(X, NAME) SCM_SETCAR (X, NAME)
|
||||
#define SCM_STRUCT_TABLE_CLASS(X) SCM_CDR (X)
|
||||
#define SCM_SET_STRUCT_TABLE_CLASS(X, CLASS) SCM_SETCDR (X, CLASS)
|
||||
extern SCM scm_struct_table;
|
||||
SCM_API SCM scm_struct_table;
|
||||
|
||||
#define SCM_STRUCT_GC_CHAIN(X) SCM_CELL_OBJECT_3 (X)
|
||||
#define SCM_SET_STRUCT_GC_CHAIN(X, Y) SCM_SET_CELL_OBJECT_3 (X, Y)
|
||||
extern SCM scm_structs_to_free;
|
||||
SCM_API SCM scm_structs_to_free;
|
||||
|
||||
|
||||
|
||||
extern scm_t_bits * scm_alloc_struct (int n_words, int n_extra, char * who);
|
||||
extern size_t scm_struct_free_0 (scm_t_bits * vtable, scm_t_bits * data);
|
||||
extern size_t scm_struct_free_light (scm_t_bits * vtable, scm_t_bits * data);
|
||||
extern size_t scm_struct_free_standard (scm_t_bits * vtable, scm_t_bits * data);
|
||||
extern size_t scm_struct_free_entity (scm_t_bits * vtable, scm_t_bits * data);
|
||||
extern SCM scm_make_struct_layout (SCM fields);
|
||||
extern SCM scm_struct_p (SCM x);
|
||||
extern SCM scm_struct_vtable_p (SCM x);
|
||||
extern SCM scm_make_struct (SCM vtable, SCM tail_array_size, SCM init);
|
||||
extern SCM scm_make_vtable_vtable (SCM extra_fields, SCM tail_array_size, SCM init);
|
||||
extern SCM scm_struct_ref (SCM handle, SCM pos);
|
||||
extern SCM scm_struct_set_x (SCM handle, SCM pos, SCM val);
|
||||
extern SCM scm_struct_vtable (SCM handle);
|
||||
extern SCM scm_struct_vtable_tag (SCM handle);
|
||||
extern unsigned long scm_struct_ihashq (SCM obj, unsigned long n);
|
||||
extern SCM scm_struct_create_handle (SCM obj);
|
||||
extern SCM scm_struct_vtable_name (SCM vtable);
|
||||
extern SCM scm_set_struct_vtable_name_x (SCM vtable, SCM name);
|
||||
extern void scm_print_struct (SCM exp, SCM port, scm_print_state *);
|
||||
extern void scm_struct_prehistory (void);
|
||||
extern void scm_init_struct (void);
|
||||
SCM_API scm_t_bits * scm_alloc_struct (int n_words, int n_extra, char * who);
|
||||
SCM_API size_t scm_struct_free_0 (scm_t_bits * vtable, scm_t_bits * data);
|
||||
SCM_API size_t scm_struct_free_light (scm_t_bits * vtable, scm_t_bits * data);
|
||||
SCM_API size_t scm_struct_free_standard (scm_t_bits * vtable, scm_t_bits * data);
|
||||
SCM_API size_t scm_struct_free_entity (scm_t_bits * vtable, scm_t_bits * data);
|
||||
SCM_API SCM scm_make_struct_layout (SCM fields);
|
||||
SCM_API SCM scm_struct_p (SCM x);
|
||||
SCM_API SCM scm_struct_vtable_p (SCM x);
|
||||
SCM_API SCM scm_make_struct (SCM vtable, SCM tail_array_size, SCM init);
|
||||
SCM_API SCM scm_make_vtable_vtable (SCM extra_fields, SCM tail_array_size, SCM init);
|
||||
SCM_API SCM scm_struct_ref (SCM handle, SCM pos);
|
||||
SCM_API SCM scm_struct_set_x (SCM handle, SCM pos, SCM val);
|
||||
SCM_API SCM scm_struct_vtable (SCM handle);
|
||||
SCM_API SCM scm_struct_vtable_tag (SCM handle);
|
||||
SCM_API unsigned long scm_struct_ihashq (SCM obj, unsigned long n);
|
||||
SCM_API SCM scm_struct_create_handle (SCM obj);
|
||||
SCM_API SCM scm_struct_vtable_name (SCM vtable);
|
||||
SCM_API SCM scm_set_struct_vtable_name_x (SCM vtable, SCM name);
|
||||
SCM_API void scm_print_struct (SCM exp, SCM port, scm_print_state *);
|
||||
SCM_API void scm_struct_prehistory (void);
|
||||
SCM_API void scm_init_struct (void);
|
||||
|
||||
#endif /* SCM_STRUCT_H */
|
||||
|
||||
|
|
|
@ -71,25 +71,25 @@
|
|||
|
||||
|
||||
#ifdef GUILE_DEBUG
|
||||
extern SCM scm_sys_symbols (void);
|
||||
SCM_API SCM scm_sys_symbols (void);
|
||||
#endif
|
||||
extern SCM scm_mem2symbol (const char*, size_t);
|
||||
extern SCM scm_str2symbol (const char*);
|
||||
SCM_API SCM scm_mem2symbol (const char*, size_t);
|
||||
SCM_API SCM scm_str2symbol (const char*);
|
||||
|
||||
extern SCM scm_symbol_p (SCM x);
|
||||
extern SCM scm_symbol_to_string (SCM s);
|
||||
extern SCM scm_string_to_symbol (SCM s);
|
||||
SCM_API SCM scm_symbol_p (SCM x);
|
||||
SCM_API SCM scm_symbol_to_string (SCM s);
|
||||
SCM_API SCM scm_string_to_symbol (SCM s);
|
||||
|
||||
extern SCM scm_symbol_fref (SCM s);
|
||||
extern SCM scm_symbol_pref (SCM s);
|
||||
extern SCM scm_symbol_fset_x (SCM s, SCM val);
|
||||
extern SCM scm_symbol_pset_x (SCM s, SCM val);
|
||||
SCM_API SCM scm_symbol_fref (SCM s);
|
||||
SCM_API SCM scm_symbol_pref (SCM s);
|
||||
SCM_API SCM scm_symbol_fset_x (SCM s, SCM val);
|
||||
SCM_API SCM scm_symbol_pset_x (SCM s, SCM val);
|
||||
|
||||
extern SCM scm_symbol_hash (SCM s);
|
||||
extern SCM scm_gensym (SCM prefix);
|
||||
SCM_API SCM scm_symbol_hash (SCM s);
|
||||
SCM_API SCM scm_gensym (SCM prefix);
|
||||
|
||||
extern void scm_symbols_prehistory (void);
|
||||
extern void scm_init_symbols (void);
|
||||
SCM_API void scm_symbols_prehistory (void);
|
||||
SCM_API void scm_init_symbols (void);
|
||||
|
||||
#endif /* SCM_SYMBOLS_H */
|
||||
|
||||
|
|
|
@ -417,7 +417,7 @@ enum scm_tags
|
|||
#define SCM_MAKISYM(n) SCM_PACK (((n) << 9) + 0x74L)
|
||||
#define SCM_MAKIFLAG(n) SCM_PACK (((n) << 9) + 0x174L)
|
||||
|
||||
extern char *scm_isymnames[]; /* defined in print.c */
|
||||
SCM_API char *scm_isymnames[]; /* defined in print.c */
|
||||
|
||||
/* This table must agree with the declarations
|
||||
* in repl.c: {Names of immediate symbols}.
|
||||
|
|
|
@ -53,9 +53,9 @@
|
|||
|
||||
|
||||
/* smob tags for the thread datatypes */
|
||||
extern scm_t_bits scm_tc16_thread;
|
||||
extern scm_t_bits scm_tc16_mutex;
|
||||
extern scm_t_bits scm_tc16_condvar;
|
||||
SCM_API scm_t_bits scm_tc16_thread;
|
||||
SCM_API scm_t_bits scm_tc16_mutex;
|
||||
SCM_API scm_t_bits scm_tc16_condvar;
|
||||
|
||||
#define SCM_THREADP(x) SCM_TYP16_PREDICATE (scm_tc16_thread, x)
|
||||
#define SCM_THREAD_DATA(x) ((void *) SCM_CELL_WORD_1 (x))
|
||||
|
@ -67,38 +67,38 @@ extern scm_t_bits scm_tc16_condvar;
|
|||
#define SCM_CONDVAR_DATA(x) ((void *) SCM_CELL_WORD_1 (x))
|
||||
|
||||
/* Initialize implementation specific details of the threads support */
|
||||
void scm_threads_init (SCM_STACKITEM *);
|
||||
void scm_threads_mark_stacks (void);
|
||||
void scm_init_threads (SCM_STACKITEM *);
|
||||
SCM_API void scm_threads_init (SCM_STACKITEM *);
|
||||
SCM_API void scm_threads_mark_stacks (void);
|
||||
SCM_API void scm_init_threads (SCM_STACKITEM *);
|
||||
|
||||
/* */
|
||||
SCM scm_threads_make_mutex (void);
|
||||
SCM scm_threads_lock_mutex (SCM);
|
||||
SCM scm_threads_unlock_mutex (SCM);
|
||||
SCM scm_threads_monitor (void);
|
||||
SCM_API SCM scm_threads_make_mutex (void);
|
||||
SCM_API SCM scm_threads_lock_mutex (SCM);
|
||||
SCM_API SCM scm_threads_unlock_mutex (SCM);
|
||||
SCM_API SCM scm_threads_monitor (void);
|
||||
|
||||
SCM scm_spawn_thread (scm_t_catch_body body, void *body_data,
|
||||
scm_t_catch_handler handler, void *handler_data);
|
||||
SCM_API SCM scm_spawn_thread (scm_t_catch_body body, void *body_data,
|
||||
scm_t_catch_handler handler, void *handler_data);
|
||||
|
||||
/* These are versions of the ordinary sleep and usleep functions,
|
||||
that play nicely with the thread system. */
|
||||
unsigned long scm_thread_sleep (unsigned long);
|
||||
unsigned long scm_thread_usleep (unsigned long);
|
||||
SCM_API unsigned long scm_thread_sleep (unsigned long);
|
||||
SCM_API unsigned long scm_thread_usleep (unsigned long);
|
||||
|
||||
|
||||
/* The C versions of the Scheme-visible thread functions. */
|
||||
#ifdef USE_COOP_THREADS
|
||||
extern SCM scm_single_thread_p (void);
|
||||
SCM_API SCM scm_single_thread_p (void);
|
||||
#endif
|
||||
extern SCM scm_yield (void);
|
||||
extern SCM scm_call_with_new_thread (SCM argl);
|
||||
extern SCM scm_join_thread (SCM t);
|
||||
extern SCM scm_make_mutex (void);
|
||||
extern SCM scm_lock_mutex (SCM m);
|
||||
extern SCM scm_unlock_mutex (SCM m);
|
||||
extern SCM scm_make_condition_variable (void);
|
||||
extern SCM scm_wait_condition_variable (SCM cond, SCM mutex);
|
||||
extern SCM scm_signal_condition_variable (SCM cond);
|
||||
SCM_API SCM scm_yield (void);
|
||||
SCM_API SCM scm_call_with_new_thread (SCM argl);
|
||||
SCM_API SCM scm_join_thread (SCM t);
|
||||
SCM_API SCM scm_make_mutex (void);
|
||||
SCM_API SCM scm_lock_mutex (SCM m);
|
||||
SCM_API SCM scm_unlock_mutex (SCM m);
|
||||
SCM_API SCM scm_make_condition_variable (void);
|
||||
SCM_API SCM scm_wait_condition_variable (SCM cond, SCM mutex);
|
||||
SCM_API SCM scm_signal_condition_variable (SCM cond);
|
||||
|
||||
#ifdef USE_COOP_THREADS
|
||||
#include "libguile/coop-defs.h"
|
||||
|
|
|
@ -54,23 +54,23 @@ typedef SCM (*scm_t_catch_body) (void *data);
|
|||
typedef SCM (*scm_t_catch_handler) (void *data,
|
||||
SCM tag, SCM throw_args);
|
||||
|
||||
extern SCM scm_internal_catch (SCM tag,
|
||||
scm_t_catch_body body,
|
||||
void *body_data,
|
||||
scm_t_catch_handler handler,
|
||||
void *handler_data);
|
||||
SCM_API SCM scm_internal_catch (SCM tag,
|
||||
scm_t_catch_body body,
|
||||
void *body_data,
|
||||
scm_t_catch_handler handler,
|
||||
void *handler_data);
|
||||
|
||||
extern SCM scm_internal_lazy_catch (SCM tag,
|
||||
scm_t_catch_body body,
|
||||
void *body_data,
|
||||
scm_t_catch_handler handler,
|
||||
void *handler_data);
|
||||
SCM_API SCM scm_internal_lazy_catch (SCM tag,
|
||||
scm_t_catch_body body,
|
||||
void *body_data,
|
||||
scm_t_catch_handler handler,
|
||||
void *handler_data);
|
||||
|
||||
extern SCM scm_internal_stack_catch (SCM tag,
|
||||
scm_t_catch_body body,
|
||||
void *body_data,
|
||||
scm_t_catch_handler handler,
|
||||
void *handler_data);
|
||||
SCM_API SCM scm_internal_stack_catch (SCM tag,
|
||||
scm_t_catch_body body,
|
||||
void *body_data,
|
||||
scm_t_catch_handler handler,
|
||||
void *handler_data);
|
||||
|
||||
/* The first argument to scm_body_thunk should be a pointer to one of
|
||||
these. See the implementation of catch in throw.c. */
|
||||
|
@ -86,22 +86,22 @@ struct scm_body_thunk_data
|
|||
SCM body_proc;
|
||||
};
|
||||
|
||||
extern SCM scm_body_thunk (void *);
|
||||
SCM_API SCM scm_body_thunk (void *);
|
||||
|
||||
|
||||
extern SCM scm_handle_by_proc (void *, SCM, SCM);
|
||||
extern SCM scm_handle_by_proc_catching_all (void *, SCM, SCM);
|
||||
extern SCM scm_handle_by_message (void *, SCM, SCM);
|
||||
extern SCM scm_handle_by_message_noexit (void *, SCM, SCM);
|
||||
extern SCM scm_handle_by_throw (void *, SCM, SCM);
|
||||
extern int scm_exit_status (SCM args);
|
||||
SCM_API SCM scm_handle_by_proc (void *, SCM, SCM);
|
||||
SCM_API SCM scm_handle_by_proc_catching_all (void *, SCM, SCM);
|
||||
SCM_API SCM scm_handle_by_message (void *, SCM, SCM);
|
||||
SCM_API SCM scm_handle_by_message_noexit (void *, SCM, SCM);
|
||||
SCM_API SCM scm_handle_by_throw (void *, SCM, SCM);
|
||||
SCM_API int scm_exit_status (SCM args);
|
||||
|
||||
extern SCM scm_catch (SCM tag, SCM thunk, SCM handler);
|
||||
extern SCM scm_lazy_catch (SCM tag, SCM thunk, SCM handler);
|
||||
extern SCM scm_ithrow (SCM key, SCM args, int noreturn);
|
||||
SCM_API SCM scm_catch (SCM tag, SCM thunk, SCM handler);
|
||||
SCM_API SCM scm_lazy_catch (SCM tag, SCM thunk, SCM handler);
|
||||
SCM_API SCM scm_ithrow (SCM key, SCM args, int noreturn);
|
||||
|
||||
extern SCM scm_throw (SCM key, SCM args);
|
||||
extern void scm_init_throw (void);
|
||||
SCM_API SCM scm_throw (SCM key, SCM args);
|
||||
SCM_API void scm_init_throw (void);
|
||||
|
||||
#endif /* SCM_THROW_H */
|
||||
|
||||
|
|
|
@ -73,7 +73,7 @@ typedef struct scm_t_array_dim
|
|||
long inc;
|
||||
} scm_t_array_dim;
|
||||
|
||||
extern scm_t_bits scm_tc16_array;
|
||||
SCM_API scm_t_bits scm_tc16_array;
|
||||
|
||||
#define SCM_ARRAY_FLAG_CONTIGUOUS (1 << 16)
|
||||
|
||||
|
@ -107,42 +107,42 @@ extern scm_t_bits scm_tc16_array;
|
|||
|
||||
|
||||
|
||||
extern size_t scm_uniform_element_size (SCM obj);
|
||||
extern SCM scm_make_uve (long k, SCM prot);
|
||||
extern SCM scm_uniform_vector_length (SCM v);
|
||||
extern SCM scm_array_p (SCM v, SCM prot);
|
||||
extern SCM scm_array_rank (SCM ra);
|
||||
extern SCM scm_array_dimensions (SCM ra);
|
||||
extern SCM scm_shared_array_root (SCM ra);
|
||||
extern SCM scm_shared_array_offset (SCM ra);
|
||||
extern SCM scm_shared_array_increments (SCM ra);
|
||||
extern long scm_aind (SCM ra, SCM args, const char *what);
|
||||
extern SCM scm_make_ra (int ndim);
|
||||
extern SCM scm_shap2ra (SCM args, const char *what);
|
||||
extern SCM scm_dimensions_to_uniform_array (SCM dims, SCM prot, SCM fill);
|
||||
extern void scm_ra_set_contp (SCM ra);
|
||||
extern SCM scm_make_shared_array (SCM oldra, SCM mapfunc, SCM dims);
|
||||
extern SCM scm_transpose_array (SCM ra, SCM args);
|
||||
extern SCM scm_enclose_array (SCM ra, SCM axes);
|
||||
extern SCM scm_array_in_bounds_p (SCM v, SCM args);
|
||||
extern SCM scm_uniform_vector_ref (SCM v, SCM args);
|
||||
extern SCM scm_cvref (SCM v, unsigned long pos, SCM last);
|
||||
extern SCM scm_array_set_x (SCM v, SCM obj, SCM args);
|
||||
extern SCM scm_array_contents (SCM ra, SCM strict);
|
||||
extern SCM scm_ra2contig (SCM ra, int copy);
|
||||
extern SCM scm_uniform_array_read_x (SCM ra, SCM port_or_fd, SCM start, SCM end);
|
||||
extern SCM scm_uniform_array_write (SCM v, SCM port_or_fd, SCM start, SCM end);
|
||||
extern SCM scm_bit_count (SCM item, SCM seq);
|
||||
extern SCM scm_bit_position (SCM item, SCM v, SCM k);
|
||||
extern SCM scm_bit_set_star_x (SCM v, SCM kv, SCM obj);
|
||||
extern SCM scm_bit_count_star (SCM v, SCM kv, SCM obj);
|
||||
extern SCM scm_bit_invert_x (SCM v);
|
||||
extern SCM scm_istr2bve (char *str, long len);
|
||||
extern SCM scm_t_arrayo_list (SCM v);
|
||||
extern SCM scm_list_to_uniform_array (SCM ndim, SCM prot, SCM lst);
|
||||
extern int scm_raprin1 (SCM exp, SCM port, scm_print_state *pstate);
|
||||
extern SCM scm_array_prototype (SCM ra);
|
||||
extern void scm_init_unif (void);
|
||||
SCM_API size_t scm_uniform_element_size (SCM obj);
|
||||
SCM_API SCM scm_make_uve (long k, SCM prot);
|
||||
SCM_API SCM scm_uniform_vector_length (SCM v);
|
||||
SCM_API SCM scm_array_p (SCM v, SCM prot);
|
||||
SCM_API SCM scm_array_rank (SCM ra);
|
||||
SCM_API SCM scm_array_dimensions (SCM ra);
|
||||
SCM_API SCM scm_shared_array_root (SCM ra);
|
||||
SCM_API SCM scm_shared_array_offset (SCM ra);
|
||||
SCM_API SCM scm_shared_array_increments (SCM ra);
|
||||
SCM_API long scm_aind (SCM ra, SCM args, const char *what);
|
||||
SCM_API SCM scm_make_ra (int ndim);
|
||||
SCM_API SCM scm_shap2ra (SCM args, const char *what);
|
||||
SCM_API SCM scm_dimensions_to_uniform_array (SCM dims, SCM prot, SCM fill);
|
||||
SCM_API void scm_ra_set_contp (SCM ra);
|
||||
SCM_API SCM scm_make_shared_array (SCM oldra, SCM mapfunc, SCM dims);
|
||||
SCM_API SCM scm_transpose_array (SCM ra, SCM args);
|
||||
SCM_API SCM scm_enclose_array (SCM ra, SCM axes);
|
||||
SCM_API SCM scm_array_in_bounds_p (SCM v, SCM args);
|
||||
SCM_API SCM scm_uniform_vector_ref (SCM v, SCM args);
|
||||
SCM_API SCM scm_cvref (SCM v, unsigned long pos, SCM last);
|
||||
SCM_API SCM scm_array_set_x (SCM v, SCM obj, SCM args);
|
||||
SCM_API SCM scm_array_contents (SCM ra, SCM strict);
|
||||
SCM_API SCM scm_ra2contig (SCM ra, int copy);
|
||||
SCM_API SCM scm_uniform_array_read_x (SCM ra, SCM port_or_fd, SCM start, SCM end);
|
||||
SCM_API SCM scm_uniform_array_write (SCM v, SCM port_or_fd, SCM start, SCM end);
|
||||
SCM_API SCM scm_bit_count (SCM item, SCM seq);
|
||||
SCM_API SCM scm_bit_position (SCM item, SCM v, SCM k);
|
||||
SCM_API SCM scm_bit_set_star_x (SCM v, SCM kv, SCM obj);
|
||||
SCM_API SCM scm_bit_count_star (SCM v, SCM kv, SCM obj);
|
||||
SCM_API SCM scm_bit_invert_x (SCM v);
|
||||
SCM_API SCM scm_istr2bve (char *str, long len);
|
||||
SCM_API SCM scm_t_arrayo_list (SCM v);
|
||||
SCM_API SCM scm_list_to_uniform_array (SCM ndim, SCM prot, SCM lst);
|
||||
SCM_API int scm_raprin1 (SCM exp, SCM port, scm_print_state *pstate);
|
||||
SCM_API SCM scm_array_prototype (SCM ra);
|
||||
SCM_API void scm_init_unif (void);
|
||||
|
||||
#endif /* SCM_UNIF_H */
|
||||
|
||||
|
|
|
@ -48,13 +48,13 @@
|
|||
|
||||
#include "libguile/__scm.h"
|
||||
|
||||
extern SCM scm_values_vtable;
|
||||
SCM_API SCM scm_values_vtable;
|
||||
|
||||
#define SCM_VALUESP(x) (SCM_STRUCTP (x)\
|
||||
&& SCM_EQ_P (scm_struct_vtable (x), scm_values_vtable))
|
||||
|
||||
extern SCM scm_values (SCM args);
|
||||
extern void scm_init_values (void);
|
||||
SCM_API SCM scm_values (SCM args);
|
||||
SCM_API void scm_init_values (void);
|
||||
|
||||
#endif /* SCM_VALUES_H */
|
||||
|
||||
|
|
|
@ -60,16 +60,16 @@
|
|||
|
||||
|
||||
|
||||
extern SCM scm_make_variable (SCM init);
|
||||
extern SCM scm_make_undefined_variable (void);
|
||||
extern SCM scm_variable_p (SCM obj);
|
||||
extern SCM scm_variable_ref (SCM var);
|
||||
extern SCM scm_variable_set_x (SCM var, SCM val);
|
||||
extern SCM scm_variable_bound_p (SCM var);
|
||||
SCM_API SCM scm_make_variable (SCM init);
|
||||
SCM_API SCM scm_make_undefined_variable (void);
|
||||
SCM_API SCM scm_variable_p (SCM obj);
|
||||
SCM_API SCM scm_variable_ref (SCM var);
|
||||
SCM_API SCM scm_variable_set_x (SCM var, SCM val);
|
||||
SCM_API SCM scm_variable_bound_p (SCM var);
|
||||
|
||||
extern void scm_i_variable_print (SCM var, SCM port, scm_print_state *pstate);
|
||||
SCM_API void scm_i_variable_print (SCM var, SCM port, scm_print_state *pstate);
|
||||
|
||||
extern void scm_init_variable (void);
|
||||
SCM_API void scm_init_variable (void);
|
||||
|
||||
#endif /* SCM_VARIABLE_H */
|
||||
|
||||
|
|
|
@ -73,22 +73,22 @@
|
|||
|
||||
|
||||
|
||||
extern SCM scm_c_make_vector (unsigned long int k, SCM fill);
|
||||
SCM_API SCM scm_c_make_vector (unsigned long int k, SCM fill);
|
||||
|
||||
extern SCM scm_vector_p (SCM x);
|
||||
extern SCM scm_vector_length (SCM v);
|
||||
extern SCM scm_vector (SCM l);
|
||||
extern SCM scm_vector_ref (SCM v, SCM k);
|
||||
extern SCM scm_vector_set_x (SCM v, SCM k, SCM obj);
|
||||
extern SCM scm_make_vector (SCM k, SCM fill);
|
||||
extern SCM scm_vector_to_list (SCM v);
|
||||
extern SCM scm_vector_fill_x (SCM v, SCM fill_x);
|
||||
extern SCM scm_vector_equal_p (SCM x, SCM y);
|
||||
extern SCM scm_vector_move_left_x (SCM vec1, SCM start1, SCM end1,
|
||||
SCM vec2, SCM start2);
|
||||
extern SCM scm_vector_move_right_x (SCM vec1, SCM start1, SCM end1,
|
||||
SCM vec2, SCM start2);
|
||||
extern void scm_init_vectors (void);
|
||||
SCM_API SCM scm_vector_p (SCM x);
|
||||
SCM_API SCM scm_vector_length (SCM v);
|
||||
SCM_API SCM scm_vector (SCM l);
|
||||
SCM_API SCM scm_vector_ref (SCM v, SCM k);
|
||||
SCM_API SCM scm_vector_set_x (SCM v, SCM k, SCM obj);
|
||||
SCM_API SCM scm_make_vector (SCM k, SCM fill);
|
||||
SCM_API SCM scm_vector_to_list (SCM v);
|
||||
SCM_API SCM scm_vector_fill_x (SCM v, SCM fill_x);
|
||||
SCM_API SCM scm_vector_equal_p (SCM x, SCM y);
|
||||
SCM_API SCM scm_vector_move_left_x (SCM vec1, SCM start1, SCM end1,
|
||||
SCM vec2, SCM start2);
|
||||
SCM_API SCM scm_vector_move_right_x (SCM vec1, SCM start1, SCM end1,
|
||||
SCM vec2, SCM start2);
|
||||
SCM_API void scm_init_vectors (void);
|
||||
|
||||
#endif /* SCM_VECTORS_H */
|
||||
|
||||
|
|
|
@ -50,8 +50,8 @@
|
|||
|
||||
|
||||
|
||||
extern SCM scm_make_soft_port (SCM pv, SCM modes);
|
||||
extern void scm_init_vports (void);
|
||||
SCM_API SCM scm_make_soft_port (SCM pv, SCM modes);
|
||||
SCM_API void scm_init_vports (void);
|
||||
|
||||
#endif /* SCM_VPORTS_H */
|
||||
|
||||
|
|
|
@ -60,21 +60,21 @@
|
|||
#define SCM_WVECT_GC_CHAIN(X) (SCM_CELL_OBJECT_3 (X))
|
||||
#define SCM_SET_WVECT_GC_CHAIN(X, o) (SCM_SET_CELL_OBJECT_3 ((X), (o)))
|
||||
|
||||
extern SCM scm_weak_vectors;
|
||||
SCM_API SCM scm_weak_vectors;
|
||||
|
||||
|
||||
|
||||
extern SCM scm_make_weak_vector (SCM k, SCM fill);
|
||||
extern SCM scm_weak_vector (SCM l);
|
||||
extern SCM scm_weak_vector_p (SCM x);
|
||||
extern SCM scm_make_weak_key_hash_table (SCM k);
|
||||
extern SCM scm_make_weak_value_hash_table (SCM k);
|
||||
extern SCM scm_make_doubly_weak_hash_table (SCM k);
|
||||
extern SCM scm_weak_key_hash_table_p (SCM x);
|
||||
extern SCM scm_weak_value_hash_table_p (SCM x);
|
||||
extern SCM scm_doubly_weak_hash_table_p (SCM x);
|
||||
extern void scm_weaks_prehistory (void);
|
||||
extern void scm_init_weaks (void);
|
||||
SCM_API SCM scm_make_weak_vector (SCM k, SCM fill);
|
||||
SCM_API SCM scm_weak_vector (SCM l);
|
||||
SCM_API SCM scm_weak_vector_p (SCM x);
|
||||
SCM_API SCM scm_make_weak_key_hash_table (SCM k);
|
||||
SCM_API SCM scm_make_weak_value_hash_table (SCM k);
|
||||
SCM_API SCM scm_make_doubly_weak_hash_table (SCM k);
|
||||
SCM_API SCM scm_weak_key_hash_table_p (SCM x);
|
||||
SCM_API SCM scm_weak_value_hash_table_p (SCM x);
|
||||
SCM_API SCM scm_doubly_weak_hash_table_p (SCM x);
|
||||
SCM_API void scm_weaks_prehistory (void);
|
||||
SCM_API void scm_init_weaks (void);
|
||||
|
||||
#endif /* SCM_WEAKS_H */
|
||||
|
||||
|
|
Loading…
Add table
Add a link
Reference in a new issue