[uim-commit] r2610 - in branches/r5rs: scm sigscheme
sigscheme/script uim
jun0 at freedesktop.org
jun0 at freedesktop.org
Fri Dec 16 01:06:55 PST 2005
Author: jun0
Date: 2005-12-16 01:06:42 -0800 (Fri, 16 Dec 2005)
New Revision: 2610
Modified:
branches/r5rs/scm/Makefile.am
branches/r5rs/scm/rk.scm
branches/r5rs/sigscheme/config.h
branches/r5rs/sigscheme/encoding.c
branches/r5rs/sigscheme/encoding.h
branches/r5rs/sigscheme/error.c
branches/r5rs/sigscheme/eval.c
branches/r5rs/sigscheme/fileport.c
branches/r5rs/sigscheme/fileport.h
branches/r5rs/sigscheme/io.c
branches/r5rs/sigscheme/main.c
branches/r5rs/sigscheme/mbcport.c
branches/r5rs/sigscheme/mbcport.h
branches/r5rs/sigscheme/nullport.c
branches/r5rs/sigscheme/nullport.h
branches/r5rs/sigscheme/operations-nonstd.c
branches/r5rs/sigscheme/operations-r5rs-deepcadrs.c
branches/r5rs/sigscheme/operations-siod.c
branches/r5rs/sigscheme/operations-srfi1.c
branches/r5rs/sigscheme/operations-srfi2.c
branches/r5rs/sigscheme/operations-srfi23.c
branches/r5rs/sigscheme/operations-srfi34.c
branches/r5rs/sigscheme/operations-srfi38.c
branches/r5rs/sigscheme/operations-srfi6.c
branches/r5rs/sigscheme/operations-srfi60.c
branches/r5rs/sigscheme/operations-srfi8.c
branches/r5rs/sigscheme/operations.c
branches/r5rs/sigscheme/print.c
branches/r5rs/sigscheme/read.c
branches/r5rs/sigscheme/sbcport.c
branches/r5rs/sigscheme/sbcport.h
branches/r5rs/sigscheme/script/scm_decl.rb
branches/r5rs/sigscheme/sigscheme.c
branches/r5rs/sigscheme/sigscheme.h
branches/r5rs/sigscheme/sigschemeinternal.h
branches/r5rs/sigscheme/sigschemetype-compact.h
branches/r5rs/sigscheme/sigschemetype.h
branches/r5rs/sigscheme/storage-continuation.c
branches/r5rs/sigscheme/storage-fatty.h
branches/r5rs/sigscheme/storage-gc.c
branches/r5rs/sigscheme/storage-protection.c
branches/r5rs/sigscheme/storage-symbol.c
branches/r5rs/sigscheme/storage.c
branches/r5rs/sigscheme/strport.c
branches/r5rs/sigscheme/strport.h
branches/r5rs/sigscheme/test-compact.c
branches/r5rs/uim/uim-compat-scm.c
branches/r5rs/uim/uim-scm.c
Log:
Grand rename from JavaStyle to c_style. Type names and function names
that contain type names are left untouched. Add a newline after the
return type in function definitions.
Noteworthy changes:
* sigscheme/sigscheme.c
- (scm_return_value): rename to scm_return_value_cache
- (Scm_return_value): rename to scm_return_value
* sigscheme/error.c
- (SigScm_ErrorObj): remove.
- (Scm_ErrorObj): rename to scm_error_obj
* sigscheme/sigscheme.h
- (SCM_ASSERT_LIVE_PORT): use scm_error_obj() without specifying
current function.
Systematic changes:
SigScm_ --> scm_
Scm_ --> scm_
ScmOp_ --> scm_p_
ScmExp_ --> scm_s_
JavaStyle --> c_style
* sigscheme/encoding.c
- (Scm_mb_bare_c_strlen): rename to scm_mb_bare_c_strlen
- (Scm_mb_find_codec): rename to scm_mb_find_codec
- (Scm_mb_strlen): rename to scm_mb_strlen
- (Scm_mb_substring): rename to scm_mb_substring
* sigscheme/error.c
- (ScmOp_backtrace): rename to scm_p_backtrace
- (ScmOp_error_objectp): rename to scm_p_error_objectp
- (ScmOp_fatal_error): rename to scm_p_fatal_error
- (ScmOp_inspect_error): rename to scm_p_inspect_error
- (Scm_ErrorObj): rename to scm_error_obj
- (Scm_FatalError): rename to scm_fatal_error
- (Scm_MakeErrorObj): rename to scm_make_error_obj
- (Scm_RaiseError): rename to scm_raise_error
- (SigScm_CategorizedDebug): rename to scm_categorized_debug
- (SigScm_Debug): rename to scm_debug
- (SigScm_DebugCategories): rename to scm_debug_categories
- (SigScm_Die): rename to scm_die
- (SigScm_Error): rename to scm_error
- (SigScm_ErrorObj): rename to scm_error_obj
- (SigScm_InitError): rename to scm_init_error
- (SigScm_PredefinedDebugCategories): rename to scm_predefined_debug_categories
- (SigScm_SetDebugCategories): rename to scm_set_debug_categories
- (SigScm_ShowBacktrace): rename to scm_show_backtrace
- (SigScm_ShowErrorHeader): rename to scm_show_error_header
* sigscheme/eval.c
- (ScmExp_and): rename to scm_s_and
- (ScmExp_begin): rename to scm_s_begin
- (ScmExp_case): rename to scm_s_case
- (ScmExp_cond): rename to scm_s_cond
- (ScmExp_cond_internal): rename to scm_s_cond_internal
- (ScmExp_define): rename to scm_s_define
- (ScmExp_delay): rename to scm_s_delay
- (ScmExp_do): rename to scm_s_do
- (ScmExp_if): rename to scm_s_if
- (ScmExp_lambda): rename to scm_s_lambda
- (ScmExp_let): rename to scm_s_let
- (ScmExp_letrec): rename to scm_s_letrec
- (ScmExp_letstar): rename to scm_s_letstar
- (ScmExp_or): rename to scm_s_or
- (ScmExp_quasiquote): rename to scm_s_quasiquote
- (ScmExp_quote): rename to scm_s_quote
- (ScmExp_setd): rename to scm_s_setd
- (ScmExp_unquote): rename to scm_s_unquote
- (ScmExp_unquote_splicing): rename to scm_s_unquote_splicing
- (ScmOp_apply): rename to scm_p_apply
- (ScmOp_eval): rename to scm_p_eval
- (ScmOp_interaction_environment): rename to scm_p_interaction_environment
- (ScmOp_null_environment): rename to scm_p_null_environment
- (ScmOp_scheme_report_environment): rename to scm_p_scheme_report_environment
- (Scm_AddEnvironment): rename to scm_add_environment
- (Scm_ExtendEnvironment): rename to scm_extend_environment
- (Scm_LookupEnvironment): rename to scm_lookup_environment
- (Scm_SymbolValue): rename to scm_symbol_value
- (Scm_call): rename to scm_call
- (Scm_eval): rename to scm_eval
- (Scm_tailcall): rename to scm_tailcall
* sigscheme/fileport.c
- (Scm_fileport_init): rename to scm_fileport_init
* sigscheme/io.c
- (ScmOp_call_with_input_file): rename to scm_p_call_with_input_file
- (ScmOp_call_with_output_file): rename to scm_p_call_with_output_file
- (ScmOp_char_readyp): rename to scm_p_char_readyp
- (ScmOp_close_input_port): rename to scm_p_close_input_port
- (ScmOp_close_output_port): rename to scm_p_close_output_port
- (ScmOp_current_input_port): rename to scm_p_current_input_port
- (ScmOp_current_output_port): rename to scm_p_current_output_port
- (ScmOp_display): rename to scm_p_display
- (ScmOp_eof_objectp): rename to scm_p_eof_objectp
- (ScmOp_input_portp): rename to scm_p_input_portp
- (ScmOp_load): rename to scm_p_load
- (ScmOp_newline): rename to scm_p_newline
- (ScmOp_open_input_file): rename to scm_p_open_input_file
- (ScmOp_open_output_file): rename to scm_p_open_output_file
- (ScmOp_output_portp): rename to scm_p_output_portp
- (ScmOp_peek_char): rename to scm_p_peek_char
- (ScmOp_read): rename to scm_p_read
- (ScmOp_read_char): rename to scm_p_read_char
- (ScmOp_with_input_from_file): rename to scm_p_with_input_from_file
- (ScmOp_with_output_to_file): rename to scm_p_with_output_to_file
- (ScmOp_write): rename to scm_p_write
- (ScmOp_write_char): rename to scm_p_write_char
- (Scm_InitIO): rename to scm_init_io
- (Scm_NewCharPort): rename to scm_make_char_port
- (SigScm_ErrorNewline): rename to scm_error_newline
- (SigScm_ErrorPrintf): rename to scm_error_printf
- (SigScm_PortNewline): rename to scm_port_newline
- (SigScm_PortPrintf): rename to scm_port_printf
- (SigScm_VErrorPrintf): rename to scm_error_vprintf
- (SigScm_VPortPrintf): rename to scm_port_vprintf
- (SigScm_load): rename to scm_load
- (SigScm_load_internal): rename to scm_load_internal
- (SigScm_set_lib_path): rename to scm_set_lib_path
* sigscheme/nullport.c
- (Scm_nullport_init): rename to scm_nullport_init
* sigscheme/operations-nonstd.c
- (ScmOp_delete_file): rename to scm_p_delete_file
- (ScmOp_file_existsp): rename to scm_p_file_existsp
- (ScmOp_load_path): rename to scm_p_load_path
- (ScmOp_provide): rename to scm_p_provide
- (ScmOp_providedp): rename to scm_p_providedp
- (ScmOp_require): rename to scm_p_require
- (ScmOp_symbol_boundp): rename to scm_p_symbol_boundp
- (SigScm_Initialize_NONSTD_FEATURES): rename to scm_initialize_nonstd_features
* sigscheme/operations-r5rs-deepcadrs.c
- (ScmOp_caaaar): rename to scm_p_caaaar
- (ScmOp_caaadr): rename to scm_p_caaadr
- (ScmOp_caaar): rename to scm_p_caaar
- (ScmOp_caadar): rename to scm_p_caadar
- (ScmOp_caaddr): rename to scm_p_caaddr
- (ScmOp_caadr): rename to scm_p_caadr
- (ScmOp_cadaar): rename to scm_p_cadaar
- (ScmOp_cadadr): rename to scm_p_cadadr
- (ScmOp_cadar): rename to scm_p_cadar
- (ScmOp_caddar): rename to scm_p_caddar
- (ScmOp_cadddr): rename to scm_p_cadddr
- (ScmOp_cdaaar): rename to scm_p_cdaaar
- (ScmOp_cdaadr): rename to scm_p_cdaadr
- (ScmOp_cdaar): rename to scm_p_cdaar
- (ScmOp_cdadar): rename to scm_p_cdadar
- (ScmOp_cdaddr): rename to scm_p_cdaddr
- (ScmOp_cdadr): rename to scm_p_cdadr
- (ScmOp_cddaar): rename to scm_p_cddaar
- (ScmOp_cddadr): rename to scm_p_cddadr
- (ScmOp_cddar): rename to scm_p_cddar
- (ScmOp_cdddar): rename to scm_p_cdddar
- (ScmOp_cddddr): rename to scm_p_cddddr
* sigscheme/operations-siod.c
- (ScmExp_undefine): rename to scm_s_undefine
- (ScmOp_SIOD_equal): rename to scm_p_siod_equal
- (ScmOp_closure_code): rename to scm_p_closure_code
- (ScmOp_eof_val): rename to scm_p_eof_val
- (ScmOp_set_symbol_valued): rename to scm_p_set_symbol_valued
- (ScmOp_symbol_value): rename to scm_p_symbol_value
- (ScmOp_the_environment): rename to scm_p_the_environment
- (ScmOp_verbose): rename to scm_p_verbose
- (SigScm_GetVerboseLevel): rename to scm_get_verbose_level
- (SigScm_Initialize_SIOD): rename to scm_initialize_siod
- (SigScm_SetVerboseLevel): rename to scm_set_verbose_level
* sigscheme/operations-srfi1.c
- (ScmOp_SRFI1_carpluscdr): rename to scm_p_srfi1_carpluscdr
- (ScmOp_SRFI1_circular_list): rename to scm_p_srfi1_circular_list
- (ScmOp_SRFI1_circular_listp): rename to scm_p_srfi1_circular_listp
- (ScmOp_SRFI1_concatenate): rename to scm_p_srfi1_concatenate
- (ScmOp_SRFI1_consstar): rename to scm_p_srfi1_consstar
- (ScmOp_SRFI1_dotted_listp): rename to scm_p_srfi1_dotted_listp
- (ScmOp_SRFI1_drop): rename to scm_p_srfi1_drop
- (ScmOp_SRFI1_drop_right): rename to scm_p_srfi1_drop_right
- (ScmOp_SRFI1_drop_rightd): rename to scm_p_srfi1_drop_rightd
- (ScmOp_SRFI1_eighth): rename to scm_p_srfi1_eighth
- (ScmOp_SRFI1_fifth): rename to scm_p_srfi1_fifth
- (ScmOp_SRFI1_first): rename to scm_p_srfi1_first
- (ScmOp_SRFI1_fourth): rename to scm_p_srfi1_fourth
- (ScmOp_SRFI1_iota): rename to scm_p_srfi1_iota
- (ScmOp_SRFI1_last): rename to scm_p_srfi1_last
- (ScmOp_SRFI1_last_pair): rename to scm_p_srfi1_last_pair
- (ScmOp_SRFI1_lengthplus): rename to scm_p_srfi1_lengthplus
- (ScmOp_SRFI1_list_copy): rename to scm_p_srfi1_list_copy
- (ScmOp_SRFI1_list_tabulate): rename to scm_p_srfi1_list_tabulate
- (ScmOp_SRFI1_listequal): rename to scm_p_srfi1_listequal
- (ScmOp_SRFI1_make_list): rename to scm_p_srfi1_make_list
- (ScmOp_SRFI1_ninth): rename to scm_p_srfi1_ninth
- (ScmOp_SRFI1_not_pairp): rename to scm_p_srfi1_not_pairp
- (ScmOp_SRFI1_null_listp): rename to scm_p_srfi1_null_listp
- (ScmOp_SRFI1_proper_listp): rename to scm_p_srfi1_proper_listp
- (ScmOp_SRFI1_second): rename to scm_p_srfi1_second
- (ScmOp_SRFI1_seventh): rename to scm_p_srfi1_seventh
- (ScmOp_SRFI1_sixth): rename to scm_p_srfi1_sixth
- (ScmOp_SRFI1_split_at): rename to scm_p_srfi1_split_at
- (ScmOp_SRFI1_split_atd): rename to scm_p_srfi1_split_atd
- (ScmOp_SRFI1_take): rename to scm_p_srfi1_take
- (ScmOp_SRFI1_take_right): rename to scm_p_srfi1_take_right
- (ScmOp_SRFI1_taked): rename to scm_p_srfi1_taked
- (ScmOp_SRFI1_tenth): rename to scm_p_srfi1_tenth
- (ScmOp_SRFI1_third): rename to scm_p_srfi1_third
- (ScmOp_SRFI1_xcons): rename to scm_p_srfi1_xcons
- (SigScm_Initialize_SRFI1): rename to scm_initialize_srfi1
* sigscheme/operations-srfi2.c
- (ScmExp_SRFI2_and_letstar): rename to scm_s_srfi2_and_letstar
- (SigScm_Initialize_SRFI2): rename to scm_initialize_srfi2
* sigscheme/operations-srfi23.c
- (ScmOp_SRFI23_error): rename to scm_p_srfi23_error
- (SigScm_Initialize_SRFI23): rename to scm_initialize_srfi23
* sigscheme/operations-srfi34.c
- (ScmOp_SRFI34_raise): rename to scm_p_srfi34_raise
- (ScmOp_SRFI34_with_exception_handler): rename to scm_p_srfi34_with_exception_handler
- (SigScm_Initialize_SRFI34): rename to scm_initialize_srfi34
* sigscheme/operations-srfi38.c
- (ScmOp_SRFI38_write_with_shared_structure): rename to scm_p_srfi38_write_with_shared_structure
- (SigScm_Initialize_SRFI38): rename to scm_initialize_srfi38
* sigscheme/operations-srfi6.c
- (ScmOp_SRFI6_get_output_string): rename to scm_p_srfi6_get_output_string
- (ScmOp_SRFI6_open_input_string): rename to scm_p_srfi6_open_input_string
- (ScmOp_SRFI6_open_output_string): rename to scm_p_srfi6_open_output_string
- (SigScm_Initialize_SRFI6): rename to scm_initialize_srfi6
* sigscheme/operations-srfi60.c
- (ScmOp_SRFI60_bitwise_if): rename to scm_p_srfi60_bitwise_if
- (ScmOp_SRFI60_lognot): rename to scm_p_srfi60_lognot
- (ScmOp_SRFI60_logtest): rename to scm_p_srfi60_logtest
- (SigScm_Initialize_SRFI60): rename to scm_initialize_srfi60
* sigscheme/operations-srfi8.c
- (ScmExp_SRFI8_receive): rename to scm_s_srfi8_receive
- (SigScm_Initialize_SRFI8): rename to scm_initialize_srfi8
* sigscheme/operations.c
- (ScmOp_abs): rename to scm_p_abs
- (ScmOp_add): rename to scm_p_add
- (ScmOp_append): rename to scm_p_append
- (ScmOp_assoc): rename to scm_p_assoc
- (ScmOp_assq): rename to scm_p_assq
- (ScmOp_assv): rename to scm_p_assv
- (ScmOp_booleanp): rename to scm_p_booleanp
- (ScmOp_c_length): rename to scm_p_c_length
- (ScmOp_caar): rename to scm_p_caar
- (ScmOp_caddr): rename to scm_p_caddr
- (ScmOp_cadr): rename to scm_p_cadr
- (ScmOp_call_with_current_continuation): rename to scm_p_call_with_current_continuation
- (ScmOp_car): rename to scm_p_car
- (ScmOp_cdar): rename to scm_p_cdar
- (ScmOp_cdddr): rename to scm_p_cdddr
- (ScmOp_cddr): rename to scm_p_cddr
- (ScmOp_cdr): rename to scm_p_cdr
- (ScmOp_char2integer): rename to scm_p_char2integer
- (ScmOp_char_alphabeticp): rename to scm_p_char_alphabeticp
- (ScmOp_char_downcase): rename to scm_p_char_downcase
- (ScmOp_char_lower_casep): rename to scm_p_char_lower_casep
- (ScmOp_char_numericp): rename to scm_p_char_numericp
- (ScmOp_char_upcase): rename to scm_p_char_upcase
- (ScmOp_char_upper_casep): rename to scm_p_char_upper_casep
- (ScmOp_char_whitespacep): rename to scm_p_char_whitespacep
- (ScmOp_charequalp): rename to scm_p_charequalp
- (ScmOp_charp): rename to scm_p_charp
- (ScmOp_cons): rename to scm_p_cons
- (ScmOp_divide): rename to scm_p_divide
- (ScmOp_dynamic_wind): rename to scm_p_dynamic_wind
- (ScmOp_eqp): rename to scm_p_eqp
- (ScmOp_equal): rename to scm_p_equal
- (ScmOp_equalp): rename to scm_p_equalp
- (ScmOp_eqvp): rename to scm_p_eqvp
- (ScmOp_evenp): rename to scm_p_evenp
- (ScmOp_for_each): rename to scm_p_for_each
- (ScmOp_force): rename to scm_p_force
- (ScmOp_greater): rename to scm_p_greater
- (ScmOp_greater_eq): rename to scm_p_greater_eq
- (ScmOp_integer2char): rename to scm_p_integer2char
- (ScmOp_length): rename to scm_p_length
- (ScmOp_less): rename to scm_p_less
- (ScmOp_less_eq): rename to scm_p_less_eq
- (ScmOp_list): rename to scm_p_list
- (ScmOp_list2string): rename to scm_p_list2string
- (ScmOp_list2vector): rename to scm_p_list2vector
- (ScmOp_list_ref): rename to scm_p_list_ref
- (ScmOp_list_tail): rename to scm_p_list_tail
- (ScmOp_listp): rename to scm_p_listp
- (ScmOp_listtail_internal): rename to scm_p_listtail_internal
- (ScmOp_make_string): rename to scm_p_make_string
- (ScmOp_make_vector): rename to scm_p_make_vector
- (ScmOp_map): rename to scm_p_map
- (ScmOp_max): rename to scm_p_max
- (ScmOp_member): rename to scm_p_member
- (ScmOp_memq): rename to scm_p_memq
- (ScmOp_memv): rename to scm_p_memv
- (ScmOp_min): rename to scm_p_min
- (ScmOp_modulo): rename to scm_p_modulo
- (ScmOp_multiply): rename to scm_p_multiply
- (ScmOp_negativep): rename to scm_p_negativep
- (ScmOp_not): rename to scm_p_not
- (ScmOp_nullp): rename to scm_p_nullp
- (ScmOp_number2string): rename to scm_p_number2string
- (ScmOp_numberp): rename to scm_p_numberp
- (ScmOp_oddp): rename to scm_p_oddp
- (ScmOp_pairp): rename to scm_p_pairp
- (ScmOp_positivep): rename to scm_p_positivep
- (ScmOp_procedurep): rename to scm_p_procedurep
- (ScmOp_quotient): rename to scm_p_quotient
- (ScmOp_remainder): rename to scm_p_remainder
- (ScmOp_reverse): rename to scm_p_reverse
- (ScmOp_set_card): rename to scm_p_set_card
- (ScmOp_set_cdrd): rename to scm_p_set_cdrd
- (ScmOp_string): rename to scm_p_string
- (ScmOp_string2list): rename to scm_p_string2list
- (ScmOp_string2number): rename to scm_p_string2number
- (ScmOp_string2symbol): rename to scm_p_string2symbol
- (ScmOp_string_append): rename to scm_p_string_append
- (ScmOp_string_copy): rename to scm_p_string_copy
- (ScmOp_string_filld): rename to scm_p_string_filld
- (ScmOp_string_length): rename to scm_p_string_length
- (ScmOp_string_ref): rename to scm_p_string_ref
- (ScmOp_string_setd): rename to scm_p_string_setd
- (ScmOp_stringequalp): rename to scm_p_stringequalp
- (ScmOp_stringp): rename to scm_p_stringp
- (ScmOp_substring): rename to scm_p_substring
- (ScmOp_subtract): rename to scm_p_subtract
- (ScmOp_symbol2string): rename to scm_p_symbol2string
- (ScmOp_symbolp): rename to scm_p_symbolp
- (ScmOp_values): rename to scm_p_values
- (ScmOp_vector): rename to scm_p_vector
- (ScmOp_vector2list): rename to scm_p_vector2list
- (ScmOp_vector_filld): rename to scm_p_vector_filld
- (ScmOp_vector_length): rename to scm_p_vector_length
- (ScmOp_vector_ref): rename to scm_p_vector_ref
- (ScmOp_vector_setd): rename to scm_p_vector_setd
- (ScmOp_vectorp): rename to scm_p_vectorp
- (ScmOp_zerop): rename to scm_p_zerop
* sigscheme/print.c
- (SigScm_Display): rename to scm_display
- (SigScm_DisplayToPort): rename to scm_display_to_port
- (SigScm_WriteToPort): rename to scm_write_to_port
- (SigScm_WriteToPortWithSharedStructure): rename to scm_write_to_port_with_shared_structure
* sigscheme/read.c
- (SigScm_Read): rename to scm_read
- (SigScm_Read_Char): rename to scm_read_char
* sigscheme/sigscheme.c
- (ScmExp_use): rename to scm_s_use
- (Scm_DefineAlias): rename to scm_define_alias
- (Scm_FreeArgv): rename to scm_free_argv
- (Scm_InterpretArgv): rename to scm_interpret_argv
- (Scm_Provide): rename to scm_provide
- (Scm_Providedp): rename to scm_providedp
- (Scm_RegisterFunc): rename to scm_register_func
- (Scm_Use): rename to scm_use
- (Scm_eval_c_string): rename to scm_eval_c_string
- (Scm_eval_c_string_internal): rename to scm_eval_c_string_internal
- (SigScm_Finalize): rename to scm_finalize
- (SigScm_Initialize): rename to scm_initialize
- (SigScm_Initialize_internal): rename to scm_initialize_internal
- (Scm_sym_else): rename to scm_sym_else
- (Scm_sym_quasiquote): rename to scm_sym_quasiquote
- (Scm_sym_quote): rename to scm_sym_quote
- (Scm_sym_unquote): rename to scm_sym_unquote
- (Scm_sym_unquote_splicing): rename to scm_sym_unquote_splicing
- (Scm_sym_yields): rename to scm_sym_yields
* sigscheme/storage-continuation.c
- (Scm_CallContinuation): rename to scm_call_continuation
- (Scm_CallWithCurrentContinuation): rename to scm_call_with_current_continuation
- (Scm_DestructContinuation): rename to scm_destruct_continuation
- (Scm_DynamicWind): rename to scm_dynamic_wind
- (Scm_PopTraceFrame): rename to scm_pop_trace_frame
- (Scm_PushTraceFrame): rename to scm_push_trace_frame
- (Scm_TraceStack): rename to scm_trace_stack
- (SigScm_FinalizeContinuation): rename to scm_finalize_continuation
- (SigScm_InitContinuation): rename to scm_init_continuation
* sigscheme/storage-gc.c
- (SigScm_FinalizeGC): rename to scm_finalize_gc
- (SigScm_GC_Protect): rename to scm_gc_protect
- (SigScm_GC_ProtectStack): rename to scm_gc_protect_stack
- (SigScm_GC_ProtectStackInternal): rename to scm_gc_protect_stack_internal
- (SigScm_GC_Unprotect): rename to scm_gc_unprotect
- (SigScm_GC_UnprotectStack): rename to scm_gc_unprotect_stack
- (SigScm_NewObjFromHeap): rename to scm_make_obj_from_heap
* sigscheme/storage-symbol.c
- (Scm_Intern): rename to scm_intern
- (Scm_SymbolBoundTo): rename to scm_symbol_bound_to
- (SigScm_FinalizeSymbol): rename to scm_finalize_symbol
- (SigScm_InitSymbol): rename to scm_init_symbol
* sigscheme/storage.c
- (SigScm_null_values): rename to scm_null_values
- (SigScm_null): rename to scm_null
- (SigScm_true): rename to scm_true
- (SigScm_false): rename to scm_false
- (SigScm_eof): rename to scm_eof
- (SigScm_unbound): rename to scm_unbound
- (SigScm_undef): rename to scm_undef
- (Scm_NewCFuncPointer): rename to scm_make_cfunc_pointer
- (Scm_NewCPointer): rename to scm_make_cpointer
- (Scm_NewChar): rename to scm_make_char
- (Scm_NewClosure): rename to scm_make_closure
- (Scm_NewCons): rename to scm_make_cons
- (Scm_NewContinuation): rename to scm_make_continuation
- (Scm_NewFunc): rename to scm_make_func
- (Scm_NewImmutableString): rename to scm_make_immutable_string
- (Scm_NewImmutableStringCopying): rename to scm_make_immutable_string_copying
- (Scm_NewInt): rename to scm_make_int
- (Scm_NewMutableString): rename to scm_make_mutable_string
- (Scm_NewMutableStringCopying): rename to scm_make_mutable_string_copying
- (Scm_NewPort): rename to scm_make_port
- (Scm_NewString): rename to scm_make_string
- (Scm_NewSymbol): rename to scm_make_symbol
- (Scm_NewValuePacket): rename to scm_make_value_packet
- (Scm_NewVector): rename to scm_make_vector
- (Scm_Type): rename to scm_type
- (SigScm_FinalizeStorage): rename to scm_finalize_storage
* sigscheme/strport.c
- (Scm_strport_init): rename to scm_strport_init
* sigscheme/test-compact.c
- (Scm_CheckCFuncPointer): rename to scm_check_cfunc_pointer
- (Scm_CheckCPointer): rename to scm_check_cpointer
- (Scm_CheckChar): rename to scm_check_char
- (Scm_CheckClosure): rename to scm_check_closure
- (Scm_CheckCons): rename to scm_check_cons
- (Scm_CheckConstant): rename to scm_check_constant
- (Scm_CheckContinuation): rename to scm_check_continuation
- (Scm_CheckFunc): rename to scm_check_func
- (Scm_CheckInt): rename to scm_check_int
- (Scm_CheckPort): rename to scm_check_port
- (Scm_CheckRef): rename to scm_check_ref
- (Scm_CheckStringCopying): rename to scm_check_string_copying
- (Scm_CheckSymbol): rename to scm_check_symbol
- (Scm_CheckValuePacket): rename to scm_check_value_packet
- (Scm_CheckVector): rename to scm_check_vector
Modified: branches/r5rs/scm/Makefile.am
===================================================================
--- branches/r5rs/scm/Makefile.am 2005-12-16 08:29:32 UTC (rev 2609)
+++ branches/r5rs/scm/Makefile.am 2005-12-16 09:06:42 UTC (rev 2610)
@@ -32,6 +32,8 @@
scim.scm \
uim-module-manager.scm
+ETAGS_ARGS=$(SCM_FILES) $(GENERATED_SCM_FILES)
+
if COMPAT_TABLE
SCM_FILES += hk.scm
endif
Modified: branches/r5rs/scm/rk.scm
===================================================================
--- branches/r5rs/scm/rk.scm 2005-12-16 08:29:32 UTC (rev 2609)
+++ branches/r5rs/scm/rk.scm 2005-12-16 09:06:42 UTC (rev 2610)
@@ -281,5 +281,4 @@
;; API
(define rk-pending
(lambda (c)
- (string-list-concat
- (rk-context-seq c))))
+ (string-list-concat (rk-context-seq c))))
Modified: branches/r5rs/sigscheme/config.h
===================================================================
--- branches/r5rs/sigscheme/config.h 2005-12-16 08:29:32 UTC (rev 2609)
+++ branches/r5rs/sigscheme/config.h 2005-12-16 09:06:42 UTC (rev 2610)
@@ -124,7 +124,7 @@
*/
#define HAVE_ASPRINTF 1
#define HAVE_VASPRINTF 1
-#define HAVE_POSIX_MEMALIGN 0
+#define HAVE_POSIX_MEMALIGN 1
/*===========================================================================
Dependency Resolution
@@ -177,7 +177,7 @@
#error "disabled character encoding is chosen as default"
#endif
-/* for Scm_eval_c_string_internal() */
+/* for scm_eval_c_string_internal() */
#undef SCM_USE_SRFI6
#define SCM_USE_SRFI6 1
Modified: branches/r5rs/sigscheme/encoding.c
===================================================================
--- branches/r5rs/sigscheme/encoding.c 2005-12-16 08:29:32 UTC (rev 2609)
+++ branches/r5rs/sigscheme/encoding.c 2005-12-16 09:06:42 UTC (rev 2610)
@@ -207,7 +207,7 @@
Global Variables
=======================================*/
/* temporary solution */
-ScmCharCodec *Scm_current_char_codec
+ScmCharCodec *scm_current_char_codec
#if SCM_USE_UTF8_AS_DEFAULT
= utf8_codec;
#elif SCM_USE_EUCJP_AS_DEFAULT
@@ -226,7 +226,8 @@
Public API
=======================================*/
-int Scm_mb_strlen(ScmMultibyteString mbs)
+int
+scm_mb_strlen(ScmMultibyteString mbs)
{
int len = 0;
ScmMultibyteCharInfo c;
@@ -235,7 +236,7 @@
SCM_MBS_GET_SIZE(mbs), SCM_MBS_GET_STR(mbs)));
while (SCM_MBS_GET_SIZE(mbs)) {
- c = SCM_CHARCODEC_SCAN_CHAR(Scm_current_char_codec, mbs);
+ c = SCM_CHARCODEC_SCAN_CHAR(scm_current_char_codec, mbs);
CDBG((SCM_DBG_ENCODING, "%d, %d;", SCM_MBCINFO_GET_SIZE(c), c.flag));
SCM_MBS_SKIP_CHAR(mbs, c);
len++;
@@ -246,16 +247,18 @@
}
/* FIXME: pick a better name. */
-int Scm_mb_bare_c_strlen(const char *s)
+int
+scm_mb_bare_c_strlen(const char *s)
{
ScmMultibyteString mbs;
SCM_MBS_INIT(mbs);
SCM_MBS_SET_STR(mbs, s);
SCM_MBS_SET_SIZE(mbs, strlen(s));
- return Scm_mb_strlen(mbs);
+ return scm_mb_strlen(mbs);
}
-ScmMultibyteString Scm_mb_substring(ScmMultibyteString mbs, int i, int len)
+ScmMultibyteString
+scm_mb_substring(ScmMultibyteString mbs, int i, int len)
{
ScmMultibyteString ret;
ScmMultibyteString end;
@@ -264,14 +267,14 @@
ret = mbs;
while (i--) {
- c = SCM_CHARCODEC_SCAN_CHAR(Scm_current_char_codec, ret);
+ c = SCM_CHARCODEC_SCAN_CHAR(scm_current_char_codec, ret);
SCM_MBS_SKIP_CHAR(ret, c);
}
end = ret;
while (len--) {
- c = SCM_CHARCODEC_SCAN_CHAR(Scm_current_char_codec, end);
+ c = SCM_CHARCODEC_SCAN_CHAR(scm_current_char_codec, end);
SCM_MBS_SKIP_CHAR(end, c);
}
@@ -280,7 +283,8 @@
}
/* TODO: support encoding name canonicalization */
-ScmCharCodec *Scm_mb_find_codec(const char *encoding)
+ScmCharCodec *
+scm_mb_find_codec(const char *encoding)
{
ScmCharCodec **codecp;
Modified: branches/r5rs/sigscheme/encoding.h
===================================================================
--- branches/r5rs/sigscheme/encoding.h 2005-12-16 08:29:32 UTC (rev 2609)
+++ branches/r5rs/sigscheme/encoding.h 2005-12-16 09:06:42 UTC (rev 2610)
@@ -153,16 +153,16 @@
/*=======================================
Variable Declarations
=======================================*/
-extern ScmCharCodec *Scm_current_char_codec;
+extern ScmCharCodec *scm_current_char_codec;
/*=======================================
Function Declarations
=======================================*/
-int Scm_mb_strlen(ScmMultibyteString mbs);
-int Scm_mb_bare_c_strlen(const char *str);
-ScmMultibyteString Scm_mb_substring(ScmMultibyteString str, int i, int len);
-#define Scm_mb_strref(str, i) (Scm_mb_substring((str), (i), 1))
-ScmCharCodec *Scm_mb_find_codec(const char *encoding);
+int scm_mb_strlen(ScmMultibyteString mbs);
+int scm_mb_bare_c_strlen(const char *str);
+ScmMultibyteString scm_mb_substring(ScmMultibyteString str, int i, int len);
+#define scm_mb_strref(str, i) (scm_mb_substring((str), (i), 1))
+ScmCharCodec *scm_mb_find_codec(const char *encoding);
#endif /* __SCM_ENCODING_H */
Modified: branches/r5rs/sigscheme/error.c
===================================================================
--- branches/r5rs/sigscheme/error.c 2005-12-16 08:29:32 UTC (rev 2609)
+++ branches/r5rs/sigscheme/error.c 2005-12-16 09:06:42 UTC (rev 2610)
@@ -74,15 +74,16 @@
/*=======================================
Function Implementations
=======================================*/
-void SigScm_InitError(void)
+void
+scm_init_error(void)
{
- SigScm_GC_Protect(&err_obj_tag);
- SigScm_GC_Protect(&str_srfi34);
+ scm_gc_protect(&err_obj_tag);
+ scm_gc_protect(&str_srfi34);
/* allocate a cons cell as unique ID */
err_obj_tag = CONS(SCM_UNDEF, SCM_UNDEF);
- str_srfi34 = Scm_NewImmutableStringCopying("srfi-34");
+ str_srfi34 = scm_make_immutable_string_copying("srfi-34");
srfi34_is_provided = FALSE;
cb_fatal_error = NULL;
@@ -91,17 +92,20 @@
REGISTER_FUNC_TABLE(scm_error_func_info_table);
}
-int SigScm_DebugCategories(void)
+int
+scm_debug_categories(void)
{
return debug_mask;
}
-void SigScm_SetDebugCategories(int categories)
+void
+scm_set_debug_categories(int categories)
{
debug_mask = categories;
}
-int SigScm_PredefinedDebugCategories(void)
+int
+scm_predefined_debug_categories(void)
{
#if SCM_DEBUG
return (SCM_DBG_DEVEL | SCM_DBG_COMPAT | SCM_DBG_OTHER
@@ -120,26 +124,28 @@
#endif /* SCM_DEBUG */
}
-void SigScm_CategorizedDebug(int category, const char *msg, ...)
+void
+scm_categorized_debug(int category, const char *msg, ...)
{
va_list va;
va_start(va, msg);
if (debug_mask & category) {
- SigScm_VErrorPrintf(msg, va);
- SigScm_ErrorNewline();
+ scm_error_vprintf(msg, va);
+ scm_error_newline();
}
va_end(va);
}
-void SigScm_Debug(const char *msg, ...)
+void
+scm_debug(const char *msg, ...)
{
va_list va;
va_start(va, msg);
if (debug_mask & SCM_DBG_DEVEL) {
- SigScm_VErrorPrintf(msg, va);
- SigScm_ErrorNewline();
+ scm_error_vprintf(msg, va);
+ scm_error_newline();
}
va_end(va);
}
@@ -149,24 +155,26 @@
{
if (!srfi34_is_provided) {
/* expensive */
- srfi34_is_provided = NFALSEP(ScmOp_providedp(str_srfi34));
+ srfi34_is_provided = NFALSEP(scm_p_providedp(str_srfi34));
}
return srfi34_is_provided;
}
#endif
/* The name 'error?' should be reserved for SRFI-35 */
-ScmObj ScmOp_error_objectp(ScmObj obj)
+ScmObj
+scm_p_error_objectp(ScmObj obj)
{
- DECLARE_FUNCTION("%%error-object?", ProcedureFixed1);
+ DECLARE_FUNCTION("%%error-object?", procedure_fixed_1);
return (CONSP(obj) && EQ(CAR(obj), err_obj_tag)) ? SCM_TRUE : SCM_FALSE;
}
/* FIXME: make (pair? err-obj) #f */
-ScmObj Scm_MakeErrorObj(ScmObj reason, ScmObj objs)
+ScmObj
+scm_make_error_obj(ScmObj reason, ScmObj objs)
{
- DECLARE_INTERNAL_FUNCTION("Scm_MakeErrorObj");
+ DECLARE_INTERNAL_FUNCTION("scm_make_error_obj");
ASSERT_LISTP(objs);
#if 0
@@ -174,25 +182,27 @@
ASSERT_STRINGP(reason);
#endif
- return LIST_4(err_obj_tag, reason, objs, Scm_TraceStack());
+ return LIST_4(err_obj_tag, reason, objs, scm_trace_stack());
}
-void Scm_RaiseError(ScmObj err_obj)
+void
+scm_raise_error(ScmObj err_obj)
{
- DECLARE_INTERNAL_FUNCTION("Scm_RaiseError");
+ DECLARE_INTERNAL_FUNCTION("scm_raise_error");
ASSERT_ERROBJP(err_obj);
#if SCM_USE_SRFI34
if (srfi34_providedp()) {
- ScmOp_SRFI34_raise(err_obj);
+ scm_p_srfi34_raise(err_obj);
/* NOTREACHED */
}
#endif
- ScmOp_fatal_error(err_obj);
+ scm_p_fatal_error(err_obj);
}
-void Scm_FatalError(const char *msg)
+void
+scm_fatal_error(const char *msg)
{
/* don't use Scheme-level ports here */
if (msg) {
@@ -208,15 +218,16 @@
/* NOTREACHED */
}
-void Scm_SetFatalErrorCallback(void (*cb)(void))
+void scm_set_fatal_error_callback(void (*cb)(void))
{
cb_fatal_error = cb;
}
-ScmObj ScmOp_fatal_error(ScmObj err_obj)
+ScmObj
+scm_p_fatal_error(ScmObj err_obj)
{
const char *msg;
- DECLARE_FUNCTION("%%fatal-error", ProcedureFixed1);
+ DECLARE_FUNCTION("%%fatal-error", procedure_fixed_1);
if (fatal_error_looped) {
/* to avoid infinite loop by implicit assertion, use no SCM macros */
@@ -224,18 +235,19 @@
} else {
fatal_error_looped = TRUE;
ASSERT_ERROBJP(err_obj);
- ScmOp_inspect_error(err_obj);
+ scm_p_inspect_error(err_obj);
msg = NULL;
}
- Scm_FatalError(msg);
+ scm_fatal_error(msg);
/* NOTREACHED */
}
-ScmObj ScmOp_inspect_error(ScmObj err_obj)
+ScmObj
+scm_p_inspect_error(ScmObj err_obj)
{
ScmObj rest, err_obj_tag, reason, objs, trace_stack;
- DECLARE_FUNCTION("%%inspect-error", ProcedureFixed1);
+ DECLARE_FUNCTION("%%inspect-error", procedure_fixed_1);
if (ERROBJP(err_obj)) {
rest = err_obj;
@@ -246,38 +258,40 @@
ASSERT_NO_MORE_ARG(rest);
}
- if (SigScm_DebugCategories() & SCM_DBG_ERRMSG) {
- SigScm_ShowErrorHeader();
+ if (scm_debug_categories() & SCM_DBG_ERRMSG) {
+ scm_show_error_header();
if (ERROBJP(err_obj)) {
- SigScm_DisplayToPort(scm_current_error_port, err_obj);
+ scm_display_to_port(scm_current_error_port, err_obj);
} else {
SCM_PORT_PUTS(scm_current_error_port,
SCM_ERRMSG_UNHANDLED_EXCEPTION);
SCM_PORT_PUTS(scm_current_error_port, ": ");
- SigScm_WriteToPort(scm_current_error_port, err_obj);
+ scm_write_to_port(scm_current_error_port, err_obj);
}
- SigScm_ErrorNewline();
+ scm_error_newline();
}
- if (SigScm_DebugCategories() & SCM_DBG_BACKTRACE) {
+ if (scm_debug_categories() & SCM_DBG_BACKTRACE) {
if (!ERROBJP(err_obj))
- trace_stack = Scm_TraceStack();
- SigScm_ShowBacktrace(trace_stack);
+ trace_stack = scm_trace_stack();
+ scm_show_backtrace(trace_stack);
}
return SCM_UNDEF;
}
-ScmObj ScmOp_backtrace(void)
+ScmObj
+scm_p_backtrace(void)
{
- DECLARE_FUNCTION("%%backtrace", ProcedureFixed0);
+ DECLARE_FUNCTION("%%backtrace", procedure_fixed_0);
- SigScm_ShowBacktrace(Scm_TraceStack());
+ scm_show_backtrace(scm_trace_stack());
return SCM_UNDEF;
}
-int SigScm_Die(const char *msg, const char *filename, int line)
+int
+scm_die(const char *msg, const char *filename, int line)
{
char *reason;
ScmObj reason_holder;
@@ -285,14 +299,15 @@
asprintf(&reason, "%s: (file : %s, line : %d)", msg, filename, line);
ASSERT_ALLOCATED(reason);
/* reason will implicitly be freed via the object on GC */
- reason_holder = Scm_NewImmutableString(reason);
+ reason_holder = scm_make_immutable_string(reason);
- Scm_FatalError(reason);
+ scm_fatal_error(reason);
/* NOTREACHED */
return 1; /* dummy value for boolean expression */
}
-void SigScm_Error(const char *msg, ...)
+void
+scm_error(const char *msg, ...)
{
va_list va;
char *reason;
@@ -303,68 +318,61 @@
va_end(va);
ASSERT_ALLOCATED(reason);
- err_obj = Scm_MakeErrorObj(Scm_NewImmutableString(reason), SCM_NULL);
- Scm_RaiseError(err_obj);
+ err_obj = scm_make_error_obj(scm_make_immutable_string(reason), SCM_NULL);
+ scm_raise_error(err_obj);
/* NOTREACHED */
}
-/* Obsolete. */
-void SigScm_ErrorObj(const char *msg, ScmObj obj)
+/* This function obsoletes scm_error_obj(). */
+void
+scm_error_obj(const char *func_name, const char *msg, ScmObj obj)
{
- ScmObj err_obj;
-
- err_obj = Scm_MakeErrorObj(Scm_NewImmutableStringCopying(msg), LIST_1(obj));
- Scm_RaiseError(err_obj);
- /* NOTREACHED */
-}
-
-/* This function obsoletes SigScm_ErrorObj(). */
-void Scm_ErrorObj(const char *func_name, const char *msg, ScmObj obj)
-{
char *reason;
ScmObj err_obj;
asprintf(&reason, "in %s: %s", func_name, msg);
ASSERT_ALLOCATED(reason);
- err_obj = Scm_MakeErrorObj(Scm_NewImmutableString(reason), LIST_1(obj));
- Scm_RaiseError(err_obj);
+ err_obj = scm_make_error_obj(scm_make_immutable_string(reason), LIST_1(obj));
+ scm_raise_error(err_obj);
/* NOTREACHED */
}
-void SigScm_ShowErrorHeader(void)
+void
+scm_show_error_header(void)
{
- SigScm_ErrorPrintf(SCM_ERR_HEADER);
+ scm_error_printf(SCM_ERR_HEADER);
}
#if (SCM_DEBUG && SCM_DEBUG_BACKTRACE_VAL)
static void show_arg(ScmObj arg, ScmObj env)
{
#define UNBOUNDP(var, env) \
- (Scm_LookupEnvironment(var, env) == SCM_INVALID_REF \
+ (scm_lookup_environment(var, env) == SCM_INVALID_REF \
&& !SCM_SYMBOL_BOUNDP(var))
if (SYMBOLP(arg) && !UNBOUNDP(arg, env)) {
- SigScm_ErrorPrintf(" - [%s]: ", SCM_SYMBOL_NAME(arg));
- SCM_WRITESS_TO_PORT(scm_current_error_port, Scm_SymbolValue(arg, env));
- SigScm_ErrorNewline();
+ scm_error_printf(" - [%s]: ", SCM_SYMBOL_NAME(arg));
+ SCM_WRITESS_TO_PORT(scm_current_error_port, scm_symbol_value(arg, env));
+ scm_error_newline();
}
#undef UNBOUNDP
}
#endif /* (SCM_DEBUG && SCM_DEBUG_BACKTRACE_VAL) */
-void SigScm_ShowBacktrace(ScmObj trace_stack)
+void
+scm_show_backtrace(ScmObj trace_stack)
{
#if SCM_DEBUG
ScmObj top, frame, env, obj;
- SigScm_ErrorPrintf(SCM_BACKTRACE_HEADER);
+ scm_error_printf(SCM_BACKTRACE_HEADER);
/* show each frame's obj */
for (top = trace_stack; !NULLP(top); top = CDR(top)) {
#if SCM_DEBUG_BACKTRACE_SEP
- SigScm_ErrorPrintf(SCM_BACKTRACE_SEP);
+ scm_error_printf(SCM_BACKTRACE_SEP);
#endif
frame = CAR(top);
@@ -372,7 +380,7 @@
obj = TRACE_FRAME_OBJ(frame);
SCM_WRITESS_TO_PORT(scm_current_error_port, obj);
- SigScm_ErrorNewline();
+ scm_error_newline();
#if SCM_DEBUG_BACKTRACE_VAL
switch (SCM_TYPE(obj)) {
@@ -394,7 +402,7 @@
#endif /* SCM_DEBUG_BACKTRACE_VAL */
}
#if SCM_DEBUG_BACKTRACE_SEP
- SigScm_ErrorPrintf(SCM_BACKTRACE_SEP);
+ scm_error_printf(SCM_BACKTRACE_SEP);
#endif /* SCM_DEBUG_BACKTRACE_SEP */
#endif /* SCM_DEBUG */
}
Modified: branches/r5rs/sigscheme/eval.c
===================================================================
--- branches/r5rs/sigscheme/eval.c 2005-12-16 08:29:32 UTC (rev 2609)
+++ branches/r5rs/sigscheme/eval.c 2005-12-16 09:06:42 UTC (rev 2610)
@@ -100,12 +100,13 @@
* @param vals Arbitrary Scheme object list as values of new frame. Side
* effect: destructively modifyies the vals when vars is a dot
* list.
- * @see Scm_eval()
+ * @see scm_eval()
*/
-ScmObj Scm_ExtendEnvironment(ScmObj vars, ScmObj vals, ScmObj env)
+ScmObj
+scm_extend_environment(ScmObj vars, ScmObj vals, ScmObj env)
{
ScmObj frame, rest_vars, rest_vals;
- DECLARE_INTERNAL_FUNCTION("Scm_ExtendEnvironment");
+ DECLARE_INTERNAL_FUNCTION("scm_extend_environment");
#if SCM_STRICT_ARGCHECK
if (!LISTP(env))
@@ -129,11 +130,12 @@
}
/** Add a binding to newest frame of an env */
-ScmObj Scm_AddEnvironment(ScmObj var, ScmObj val, ScmObj env)
+ScmObj
+scm_add_environment(ScmObj var, ScmObj val, ScmObj env)
{
ScmObj newest_frame;
ScmObj new_vars, new_vals;
- DECLARE_INTERNAL_FUNCTION("Scm_AddEnvironment");
+ DECLARE_INTERNAL_FUNCTION("scm_add_environment");
/* sanity check */
if (!SYMBOLP(var))
@@ -160,11 +162,12 @@
*
* @return Reference to the variable. SCM_INVALID_REF if not found.
*/
-ScmRef Scm_LookupEnvironment(ScmObj var, ScmObj env)
+ScmRef
+scm_lookup_environment(ScmObj var, ScmObj env)
{
ScmObj frame;
ScmRef ref;
- DECLARE_INTERNAL_FUNCTION("Scm_LookupEnvironment");
+ DECLARE_INTERNAL_FUNCTION("scm_lookup_environment");
/* lookup in frames */
for (; CONSP(env); env = CDR(env)) {
@@ -218,16 +221,18 @@
}
/* A wrapper for call() for internal proper tail recursion */
-ScmObj Scm_tailcall(ScmObj proc, ScmObj args, ScmEvalState *eval_state)
+ScmObj
+scm_tailcall(ScmObj proc, ScmObj args, ScmEvalState *eval_state)
{
eval_state->ret_type = SCM_RETTYPE_AS_IS;
return call(proc, args, eval_state, SUPPRESS_EVAL_ARGS);
}
-/* Wrapper for call(). Just like ScmOp_apply(), except ARGS is used
+/* Wrapper for call(). Just like scm_p_apply(), except ARGS is used
* as given---nothing special is done about the last item in the
* list. */
-ScmObj Scm_call(ScmObj proc, ScmObj args)
+ScmObj
+scm_call(ScmObj proc, ScmObj args)
{
ScmEvalState state;
ScmObj ret;
@@ -303,7 +308,7 @@
if (SYMBOLP(formals)) {
/* (1) : <variable> */
- eval_state->env = Scm_ExtendEnvironment(LIST_1(formals),
+ eval_state->env = scm_extend_environment(LIST_1(formals),
LIST_1(args),
SCM_CLOSURE_ENV(proc));
} else if (CONSP(formals)) {
@@ -313,7 +318,7 @@
*
* - dot list is handled in lookup_frame().
*/
- eval_state->env = Scm_ExtendEnvironment(formals,
+ eval_state->env = scm_extend_environment(formals,
args,
SCM_CLOSURE_ENV(proc));
} else if (NULLP(formals)) {
@@ -321,7 +326,7 @@
* (2') : <variable> is '()
*/
eval_state->env
- = Scm_ExtendEnvironment(SCM_NULL,
+ = scm_extend_environment(SCM_NULL,
SCM_NULL,
SCM_CLOSURE_ENV(proc));
} else {
@@ -329,7 +334,7 @@
}
eval_state->ret_type = SCM_RETTYPE_NEED_EVAL;
- return ScmExp_begin(CDR(SCM_CLOSURE_EXP(proc)), eval_state);
+ return scm_s_begin(CDR(SCM_CLOSURE_EXP(proc)), eval_state);
}
/**
@@ -370,7 +375,7 @@
case ScmContinuation:
if (!CONSP(args) || !NULLP(CDR(args)))
ERR("continuation takes exactly one argument");
- Scm_CallContinuation(proc,
+ scm_call_continuation(proc,
suppress_eval ? CAR(args) : EVAL(CAR(args), env));
/* NOTREACHED */
default:
@@ -460,22 +465,24 @@
/*===========================================================================
S-Expression Evaluation
===========================================================================*/
-ScmObj ScmOp_eval(ScmObj obj, ScmObj env)
+ScmObj
+scm_p_eval(ScmObj obj, ScmObj env)
{
- DECLARE_FUNCTION("eval", ProcedureFixed2);
+ DECLARE_FUNCTION("eval", procedure_fixed_2);
ASSERT_ENVP(env);
- return Scm_eval(obj, env);
+ return scm_eval(obj, env);
}
-ScmObj Scm_eval(ScmObj obj, ScmObj env)
+ScmObj
+scm_eval(ScmObj obj, ScmObj env)
{
ScmObj ret = SCM_NULL;
ScmEvalState state = {0};
#if SCM_DEBUG
- Scm_PushTraceFrame(obj, env);
+ scm_push_trace_frame(obj, env);
#endif
state.env = env;
@@ -488,7 +495,7 @@
#endif
switch (SCM_TYPE(obj)) {
case ScmSymbol:
- ret = Scm_SymbolValue(obj, state.env);
+ ret = scm_symbol_value(obj, state.env);
break;
case ScmCons:
@@ -502,16 +509,17 @@
}
#if SCM_DEBUG
- Scm_PopTraceFrame();
+ scm_pop_trace_frame();
#endif
return ret;
}
-ScmObj ScmOp_apply(ScmObj proc, ScmObj arg0, ScmObj rest, ScmEvalState *eval_state)
+ScmObj
+scm_p_apply(ScmObj proc, ScmObj arg0, ScmObj rest, ScmEvalState *eval_state)
{
ScmQueue q;
ScmObj args, arg, last;
- DECLARE_FUNCTION("apply", ProcedureVariadicTailRec2);
+ DECLARE_FUNCTION("apply", procedure_variadic_tailrec_2);
if (NULLP(rest)) {
args = last = arg0;
@@ -533,14 +541,15 @@
}
/* 'var' must be a symbol as precondition */
-ScmObj Scm_SymbolValue(ScmObj var, ScmObj env)
+ScmObj
+scm_symbol_value(ScmObj var, ScmObj env)
{
ScmRef ref;
ScmObj val;
- DECLARE_INTERNAL_FUNCTION("Scm_SymbolValue");
+ DECLARE_INTERNAL_FUNCTION("scm_symbol_value");
/* first, lookup the environment */
- ref = Scm_LookupEnvironment(var, env);
+ ref = scm_lookup_environment(var, env);
if (ref != SCM_INVALID_REF) {
/* variable is found in environment, so returns its value */
return DEREF(ref);
@@ -792,7 +801,7 @@
return (ScmObj)TRV_ENDP(*t);
case TR_MSG_SPLICE:
- splice_len = ScmOp_c_length(obj);
+ splice_len = scm_p_c_length(obj);
#if SCM_STRICT_R5RS
if (splice_len < 0)
ERR_OBJ("got bad splice list", obj);
@@ -805,7 +814,7 @@
change_index = t->u.vec.index;
record_change:
- SCM_QUEUE_ADD(t->u.vec.q, CONS(Scm_NewInt(change_index), obj));
+ SCM_QUEUE_ADD(t->u.vec.q, CONS(scm_make_int(change_index), obj));
break;
case TR_MSG_EXTRACT:
@@ -844,7 +853,7 @@
else
change_index = SCM_INT_VALUE(CAAR(diff));
}
- return Scm_NewVector(copy_buf, src_len + t->u.vec.growth);
+ return scm_make_vector(copy_buf, src_len + t->u.vec.growth);
}
break;
}
@@ -857,34 +866,37 @@
/*===========================================================================
R5RS : 4.1 Primitive expression types : 4.1.2 Literal expressions
===========================================================================*/
-ScmObj ScmExp_quote(ScmObj datum, ScmObj env)
+ScmObj
+scm_s_quote(ScmObj datum, ScmObj env)
{
- DECLARE_FUNCTION("quote", SyntaxFixed1);
+ DECLARE_FUNCTION("quote", syntax_fixed_1);
return datum;
}
/*===========================================================================
R5RS : 4.1 Primitive expression types : 4.1.4 Procedures
===========================================================================*/
-ScmObj ScmExp_lambda(ScmObj formals, ScmObj body, ScmObj env)
+ScmObj
+scm_s_lambda(ScmObj formals, ScmObj body, ScmObj env)
{
- DECLARE_FUNCTION("lambda", SyntaxVariadic1);
+ DECLARE_FUNCTION("lambda", syntax_variadic_1);
if (!CONSP(formals) && !NULLP(formals) && !SYMBOLP(formals))
ERR_OBJ("bad formals", formals);
if (!CONSP(body))
ERR_OBJ("at least one expression required", body);
- return Scm_NewClosure(CONS(formals, body), env);
+ return scm_make_closure(CONS(formals, body), env);
}
/*===========================================================================
R5RS : 4.1 Primitive expression types : 4.1.5 Conditionals
===========================================================================*/
-ScmObj ScmExp_if(ScmObj test, ScmObj conseq, ScmObj rest, ScmEvalState *eval_state)
+ScmObj
+scm_s_if(ScmObj test, ScmObj conseq, ScmObj rest, ScmEvalState *eval_state)
{
ScmObj env = eval_state->env;
ScmObj alt;
- DECLARE_FUNCTION("if", SyntaxVariadicTailRec2);
+ DECLARE_FUNCTION("if", syntax_variadic_tailrec_2);
/*========================================================================
(if <test> <consequent>)
@@ -912,14 +924,15 @@
/*===========================================================================
R5RS : 4.1 Primitive expression types : 4.1.6 Assignment
===========================================================================*/
-ScmObj ScmExp_setd(ScmObj sym, ScmObj exp, ScmObj env)
+ScmObj
+scm_s_setd(ScmObj sym, ScmObj exp, ScmObj env)
{
ScmObj evaled = SCM_FALSE;
ScmRef locally_bound;
- DECLARE_FUNCTION("set!", SyntaxFixed2);
+ DECLARE_FUNCTION("set!", syntax_fixed_2);
evaled = EVAL(exp, env);
- locally_bound = Scm_LookupEnvironment(sym, env);
+ locally_bound = scm_lookup_environment(sym, env);
if (locally_bound == SCM_INVALID_REF) {
if (!SYMBOLP(sym))
ERR_OBJ("symbol required but got", sym);
@@ -949,7 +962,8 @@
R5RS : 4.2 Derived expression types : 4.2.1 Conditionals
===========================================================================*/
/* body of 'cond' and also invoked from 'case' and 'guard' of SRFI-34 */
-ScmObj ScmExp_cond_internal(ScmObj args, ScmObj case_key, ScmEvalState *eval_state)
+ScmObj
+scm_s_cond_internal(ScmObj args, ScmObj case_key, ScmEvalState *eval_state)
{
/*
* (cond <clause1> <clause2> ...)
@@ -989,7 +1003,7 @@
ASSERT_NO_MORE_ARG(args);
} else {
if (VALIDP(case_key))
- test = (NFALSEP(ScmOp_memv(case_key, test))) ? case_key : SCM_FALSE;
+ test = (NFALSEP(scm_p_memv(case_key, test))) ? case_key : SCM_FALSE;
else
test = EVAL(test, env);
}
@@ -1035,10 +1049,10 @@
ERR_OBJ("exp after => must be the procedure but got", proc);
eval_state->ret_type = SCM_RETTYPE_AS_IS;
- return Scm_call(proc, LIST_1(test));
+ return scm_call(proc, LIST_1(test));
}
- return ScmExp_begin(exps, eval_state);
+ return scm_s_begin(exps, eval_state);
}
}
@@ -1049,31 +1063,34 @@
return SCM_INVALID;
}
-ScmObj ScmExp_cond(ScmObj args, ScmEvalState *eval_state)
+ScmObj
+scm_s_cond(ScmObj args, ScmEvalState *eval_state)
{
ScmObj ret;
- DECLARE_FUNCTION("cond", SyntaxVariadicTailRec0);
+ DECLARE_FUNCTION("cond", syntax_variadic_tailrec_0);
- ret = ScmExp_cond_internal(args, SCM_INVALID, eval_state);
+ ret = scm_s_cond_internal(args, SCM_INVALID, eval_state);
return (VALIDP(ret)) ? ret : SCM_UNDEF;
}
-ScmObj ScmExp_case(ScmObj key, ScmObj clauses, ScmEvalState *eval_state)
+ScmObj
+scm_s_case(ScmObj key, ScmObj clauses, ScmEvalState *eval_state)
{
ScmObj ret;
- DECLARE_FUNCTION("case", SyntaxVariadicTailRec1);
+ DECLARE_FUNCTION("case", syntax_variadic_tailrec_1);
key = EVAL(key, eval_state->env);
- ret = ScmExp_cond_internal(clauses, key, eval_state);
+ ret = scm_s_cond_internal(clauses, key, eval_state);
return (VALIDP(ret)) ? ret : SCM_UNDEF;
}
-ScmObj ScmExp_and(ScmObj args, ScmEvalState *eval_state)
+ScmObj
+scm_s_and(ScmObj args, ScmEvalState *eval_state)
{
ScmObj env = eval_state->env;
ScmObj expr = SCM_INVALID;
ScmObj val = SCM_FALSE;
- DECLARE_FUNCTION("and", SyntaxVariadicTailRec0);
+ DECLARE_FUNCTION("and", syntax_variadic_tailrec_0);
if (NO_MORE_ARG(args))
return SCM_TRUE;
@@ -1090,12 +1107,13 @@
return expr;
}
-ScmObj ScmExp_or(ScmObj args, ScmEvalState *eval_state)
+ScmObj
+scm_s_or(ScmObj args, ScmEvalState *eval_state)
{
ScmObj env = eval_state->env;
ScmObj expr = SCM_INVALID;
ScmObj val = SCM_INVALID;
- DECLARE_FUNCTION("or", SyntaxVariadicTailRec0);
+ DECLARE_FUNCTION("or", syntax_variadic_tailrec_0);
if (NO_MORE_ARG(args))
return SCM_FALSE;
@@ -1122,7 +1140,8 @@
* bound to the closure. <procname>'s scope must not penetrate to the
* surrounding environment.
*/
-ScmObj ScmExp_let(ScmObj args, ScmEvalState *eval_state)
+ScmObj
+scm_s_let(ScmObj args, ScmEvalState *eval_state)
{
ScmObj env = eval_state->env;
ScmObj named_let_sym = SCM_FALSE;
@@ -1135,7 +1154,7 @@
ScmObj vars = SCM_NULL;
ScmObj vals = SCM_NULL;
ScmQueue varq, valq;
- DECLARE_FUNCTION("let", SyntaxVariadicTailRec0);
+ DECLARE_FUNCTION("let", syntax_variadic_tailrec_0);
/*========================================================================
normal let:
@@ -1190,25 +1209,26 @@
if (!NULLP(bindings))
ERR_OBJ("invalid bindings form", bindings);
- env = Scm_ExtendEnvironment(vars, vals, env);
+ env = scm_extend_environment(vars, vals, env);
eval_state->env = env;
/* named let */
if (SYMBOLP(named_let_sym)) {
- proc = Scm_NewClosure(CONS(vars, body), env);
+ proc = scm_make_closure(CONS(vars, body), env);
define_internal(named_let_sym, proc, env);
}
- return ScmExp_begin(body, eval_state);
+ return scm_s_begin(body, eval_state);
}
-ScmObj ScmExp_letstar(ScmObj bindings, ScmObj body, ScmEvalState *eval_state)
+ScmObj
+scm_s_letstar(ScmObj bindings, ScmObj body, ScmEvalState *eval_state)
{
ScmObj env = eval_state->env;
ScmObj var = SCM_FALSE;
ScmObj val = SCM_FALSE;
ScmObj binding = SCM_FALSE;
- DECLARE_FUNCTION("let*", SyntaxVariadicTailRec1);
+ DECLARE_FUNCTION("let*", syntax_variadic_tailrec_1);
/*========================================================================
(let* <bindings> <body>)
@@ -1232,7 +1252,7 @@
val = EVAL(CADR(binding), env);
/* extend env for each variable */
- env = Scm_ExtendEnvironment(LIST_1(var), LIST_1(val), env);
+ env = scm_extend_environment(LIST_1(var), LIST_1(val), env);
}
if (!NULLP(bindings))
@@ -1241,10 +1261,11 @@
eval_state->env = env;
/* evaluate body */
- return ScmExp_begin(body, eval_state);
+ return scm_s_begin(body, eval_state);
}
-ScmObj ScmExp_letrec(ScmObj bindings, ScmObj body, ScmEvalState *eval_state)
+ScmObj
+scm_s_letrec(ScmObj bindings, ScmObj body, ScmEvalState *eval_state)
{
ScmObj env = eval_state->env;
ScmObj frame = SCM_FALSE;
@@ -1253,7 +1274,7 @@
ScmObj binding = SCM_FALSE;
ScmObj var = SCM_FALSE;
ScmObj val = SCM_FALSE;
- DECLARE_FUNCTION("letrec", SyntaxVariadicTailRec1);
+ DECLARE_FUNCTION("letrec", syntax_variadic_tailrec_1);
/*========================================================================
(letrec <bindings> <body>)
@@ -1295,18 +1316,19 @@
SET_CDR(frame, vals);
/* evaluate body */
- return ScmExp_begin(body, eval_state);
+ return scm_s_begin(body, eval_state);
}
/*===========================================================================
R5RS : 4.2 Derived expression types : 4.2.3 Sequencing
===========================================================================*/
-ScmObj ScmExp_begin(ScmObj args, ScmEvalState *eval_state)
+ScmObj
+scm_s_begin(ScmObj args, ScmEvalState *eval_state)
{
ScmObj env = eval_state->env;
ScmObj expr = SCM_INVALID;
- DECLARE_FUNCTION("begin", SyntaxVariadicTailRec0);
+ DECLARE_FUNCTION("begin", syntax_variadic_tailrec_0);
if (NO_MORE_ARG(args))
return SCM_UNDEF;
@@ -1321,7 +1343,8 @@
/*===========================================================================
R5RS : 4.2 Derived expression types : 4.2.4 Iteration
===========================================================================*/
-ScmObj ScmExp_do(ScmObj bindings, ScmObj testframe, ScmObj commands, ScmEvalState *eval_state)
+ScmObj
+scm_s_do(ScmObj bindings, ScmObj testframe, ScmObj commands, ScmEvalState *eval_state)
{
/*
* (do ((<variable1> <init1> <step1>)
@@ -1342,7 +1365,7 @@
ScmObj tmp_steps = SCM_FALSE;
ScmObj tmp_vars = SCM_FALSE;
ScmRef obj;
- DECLARE_FUNCTION("do", SyntaxVariadicTailRec2);
+ DECLARE_FUNCTION("do", syntax_variadic_tailrec_2);
/* construct Environment and steps */
for (; !NULLP(bindings); bindings = CDR(bindings)) {
@@ -1367,7 +1390,7 @@
}
/* now extend environment */
- env = Scm_ExtendEnvironment(vars, vals, env);
+ env = scm_extend_environment(vars, vals, env);
/* construct test */
if (NULLP(testframe))
@@ -1378,7 +1401,7 @@
/* now execution phase! */
while (FALSEP(EVAL(test, env))) {
/* execute commands */
- EVAL(ScmExp_begin(commands, eval_state), env);
+ EVAL(scm_s_begin(commands, eval_state), env);
/*
* Notice
@@ -1394,14 +1417,14 @@
{
vals = CONS(EVAL(CAR(tmp_steps), env), vals);
}
- vals = ScmOp_reverse(vals);
+ vals = scm_p_reverse(vals);
/* set it */
for (tmp_vars = vars;
!NULLP(tmp_vars) && !NULLP(vals);
tmp_vars = CDR(tmp_vars), vals = CDR(vals))
{
- obj = Scm_LookupEnvironment(CAR(tmp_vars), env);
+ obj = scm_lookup_environment(CAR(tmp_vars), env);
if (obj != SCM_INVALID_REF) {
SET(obj, CAR(vals));
} else {
@@ -1412,18 +1435,19 @@
eval_state->env = env;
- return NULLP(expression) ? EVAL(test, env) : ScmExp_begin(expression, eval_state);
+ return NULLP(expression) ? EVAL(test, env) : scm_s_begin(expression, eval_state);
}
/*===========================================================================
R5RS : 4.2 Derived expression types : 4.2.5 Delayed evaluation
===========================================================================*/
-ScmObj ScmExp_delay(ScmObj expr, ScmObj env)
+ScmObj
+scm_s_delay(ScmObj expr, ScmObj env)
{
- DECLARE_FUNCTION("delay", SyntaxFixed1);
+ DECLARE_FUNCTION("delay", syntax_fixed_1);
/* (lambda () exp) */
- return Scm_NewClosure(SCM_LIST_2(SCM_NULL, expr), env);
+ return scm_make_closure(SCM_LIST_2(SCM_NULL, expr), env);
}
/*===========================================================================
@@ -1519,10 +1543,11 @@
}
-ScmObj ScmExp_quasiquote(ScmObj datum, ScmObj env)
+ScmObj
+scm_s_quasiquote(ScmObj datum, ScmObj env)
{
qquote_result ret = qquote_internal(datum, env, 1);
- DECLARE_FUNCTION("quasiquote", SyntaxFixed1);
+ DECLARE_FUNCTION("quasiquote", syntax_fixed_1);
switch (ret.insn) {
case TR_MSG_NOP:
@@ -1539,17 +1564,19 @@
}
}
-ScmObj ScmExp_unquote(ScmObj dummy, ScmObj env)
+ScmObj
+scm_s_unquote(ScmObj dummy, ScmObj env)
{
- DECLARE_FUNCTION("unquote", SyntaxFixed1);
+ DECLARE_FUNCTION("unquote", syntax_fixed_1);
ERR("unquote outside quasiquote");
return SCM_NULL;
}
-ScmObj ScmExp_unquote_splicing(ScmObj dummy, ScmObj env)
+ScmObj
+scm_s_unquote_splicing(ScmObj dummy, ScmObj env)
{
- DECLARE_FUNCTION("unquote-splicing", SyntaxFixed1);
+ DECLARE_FUNCTION("unquote-splicing", syntax_fixed_1);
ERR("unquote-splicing outside quasiquote");
return SCM_NULL;
@@ -1566,16 +1593,17 @@
SCM_SYMBOL_SET_VCELL(var, EVAL(exp, env));
} else {
/* add val to the environment */
- env = Scm_AddEnvironment(var, EVAL(exp, env), env);
+ env = scm_add_environment(var, EVAL(exp, env), env);
}
}
-ScmObj ScmExp_define(ScmObj var, ScmObj rest, ScmObj env)
+ScmObj
+scm_s_define(ScmObj var, ScmObj rest, ScmObj env)
{
ScmObj procname = SCM_FALSE;
ScmObj body = SCM_FALSE;
ScmObj formals = SCM_FALSE;
- DECLARE_FUNCTION("define", SyntaxVariadic1);
+ DECLARE_FUNCTION("define", syntax_variadic_1);
/*========================================================================
(define <variable> <expression>)
@@ -1610,7 +1638,7 @@
ASSERT_SYMBOLP(procname);
define_internal(procname,
- Scm_NewClosure(CONS(formals, body), env),
+ scm_make_closure(CONS(formals, body), env),
env);
} else {
ERR_OBJ("syntax error", var);
@@ -1626,9 +1654,10 @@
/*=======================================
R5RS : 6.5 Eval
=======================================*/
-ScmObj ScmOp_scheme_report_environment(ScmObj version)
+ScmObj
+scm_p_scheme_report_environment(ScmObj version)
{
- DECLARE_FUNCTION("scheme-report-environment", ProcedureFixed1);
+ DECLARE_FUNCTION("scheme-report-environment", procedure_fixed_1);
/* sanity check */
ASSERT_INTP(version);
@@ -1645,9 +1674,10 @@
return SCM_INTERACTION_ENV;
}
-ScmObj ScmOp_null_environment(ScmObj version)
+ScmObj
+scm_p_null_environment(ScmObj version)
{
- DECLARE_FUNCTION("null-environment", ProcedureFixed1);
+ DECLARE_FUNCTION("null-environment", procedure_fixed_1);
/* sanity check */
ASSERT_INTP(version);
@@ -1664,8 +1694,9 @@
return SCM_INTERACTION_ENV;
}
-ScmObj ScmOp_interaction_environment(void)
+ScmObj
+scm_p_interaction_environment(void)
{
- DECLARE_FUNCTION("interaction-environment", ProcedureFixed0);
+ DECLARE_FUNCTION("interaction-environment", procedure_fixed_0);
return SCM_INTERACTION_ENV;
}
Modified: branches/r5rs/sigscheme/fileport.c
===================================================================
--- branches/r5rs/sigscheme/fileport.c 2005-12-16 08:29:32 UTC (rev 2609)
+++ branches/r5rs/sigscheme/fileport.c 2005-12-16 09:06:42 UTC (rev 2610)
@@ -122,7 +122,8 @@
* Client code must call this first even if current implementation does not
* contain actual code.
*/
-void Scm_fileport_init(void)
+void
+scm_fileport_init(void)
{
return;
}
Modified: branches/r5rs/sigscheme/fileport.h
===================================================================
--- branches/r5rs/sigscheme/fileport.h 2005-12-16 08:29:32 UTC (rev 2609)
+++ branches/r5rs/sigscheme/fileport.h 2005-12-16 09:06:42 UTC (rev 2610)
@@ -67,7 +67,7 @@
/*=======================================
Function Declarations
=======================================*/
-void Scm_fileport_init(void);
+void scm_fileport_init(void);
ScmBytePort *ScmFilePort_new(FILE *file, const char *aux_info);
ScmBytePort *ScmFilePort_new_shared(FILE *file, const char *aux_info);
Modified: branches/r5rs/sigscheme/io.c
===================================================================
--- branches/r5rs/sigscheme/io.c 2005-12-16 08:29:32 UTC (rev 2609)
+++ branches/r5rs/sigscheme/io.c 2005-12-16 09:06:42 UTC (rev 2610)
@@ -74,7 +74,7 @@
/*=======================================
File Local Function Declarations
=======================================*/
-static ScmObj SigScm_load_internal(const char *c_filename);
+static ScmObj scm_load_internal(const char *c_filename);
static char *find_path(const char *c_filename);
static int file_existsp(const char *filepath);
#if SCM_USE_SRFI22
@@ -85,60 +85,65 @@
/*=======================================
Function Implementations
=======================================*/
-void Scm_InitIO(void)
+void
+scm_init_io(void)
{
- Scm_fileport_init();
+ scm_fileport_init();
#if SCM_USE_MULTIBYTE_CHAR
- Scm_mbcport_init();
+ scm_mbcport_init();
#else
- Scm_sbcport_init();
+ scm_sbcport_init();
#endif
- scm_current_input_port = Scm_MakeSharedFilePort(stdin, "stdin",
+ scm_current_input_port = scm_make_shared_file_port(stdin, "stdin",
SCM_PORTFLAG_INPUT);
- scm_current_output_port = Scm_MakeSharedFilePort(stdout, "stdout",
+ scm_current_output_port = scm_make_shared_file_port(stdout, "stdout",
SCM_PORTFLAG_OUTPUT);
- scm_current_error_port = Scm_MakeSharedFilePort(stderr, "stderr",
+ scm_current_error_port = scm_make_shared_file_port(stderr, "stderr",
SCM_PORTFLAG_OUTPUT);
- SigScm_GC_Protect(&scm_current_input_port);
- SigScm_GC_Protect(&scm_current_output_port);
- SigScm_GC_Protect(&scm_current_error_port);
+ scm_gc_protect(&scm_current_input_port);
+ scm_gc_protect(&scm_current_output_port);
+ scm_gc_protect(&scm_current_error_port);
}
-void SigScm_set_lib_path(const char *path)
+void
+scm_set_lib_path(const char *path)
{
scm_lib_path = path;
}
-ScmCharPort *Scm_NewCharPort(ScmBytePort *bport)
+ScmCharPort *
+scm_make_char_port(ScmBytePort *bport)
{
#if SCM_USE_MULTIBYTE_CHAR
- return ScmMultiByteCharPort_new(bport, Scm_current_char_codec);
+ return ScmMultiByteCharPort_new(bport, scm_current_char_codec);
#else
return ScmSingleByteCharPort_new(bport);
#endif
}
-ScmObj Scm_MakeSharedFilePort(FILE *file, const char *aux_info,
+ScmObj scm_make_shared_file_port(FILE *file, const char *aux_info,
enum ScmPortFlag flag)
{
ScmBytePort *bport;
/* GC safe */
bport = ScmFilePort_new_shared(file, aux_info);
- return Scm_NewPort(Scm_NewCharPort(bport), flag);
+ return scm_make_port(scm_make_char_port(bport), flag);
}
-void SigScm_PortPrintf(ScmObj port, const char *fmt, ...)
+void
+scm_port_printf(ScmObj port, const char *fmt, ...)
{
va_list args;
va_start(args, fmt);
- SigScm_VPortPrintf(port, fmt, args);
+ scm_port_vprintf(port, fmt, args);
va_end(args);
}
-void SigScm_VPortPrintf(ScmObj port, const char *fmt, va_list args)
+void
+scm_port_vprintf(ScmObj port, const char *fmt, va_list args)
{
SCM_PORT_VPRINTF(port, fmt, args);
#if SCM_VOLATILE_OUTPUT
@@ -146,29 +151,33 @@
#endif
}
-void SigScm_PortNewline(ScmObj port)
+void
+scm_port_newline(ScmObj port)
{
SCM_PORT_PUTS(port, SCM_NEWLINE_STR);
SCM_PORT_FLUSH(port); /* required */
}
-void SigScm_ErrorPrintf(const char *fmt, ...)
+void
+scm_error_printf(const char *fmt, ...)
{
va_list args;
va_start(args, fmt);
- SigScm_VErrorPrintf(fmt, args);
+ scm_error_vprintf(fmt, args);
va_end(args);
}
-void SigScm_VErrorPrintf(const char *fmt, va_list args)
+void
+scm_error_vprintf(const char *fmt, va_list args)
{
- SigScm_VPortPrintf(scm_current_error_port, fmt, args);
+ scm_port_vprintf(scm_current_error_port, fmt, args);
}
-void SigScm_ErrorNewline(void)
+void
+scm_error_newline(void)
{
- SigScm_PortNewline(scm_current_error_port);
+ scm_port_newline(scm_current_error_port);
}
/*=======================================
@@ -177,114 +186,123 @@
/*===========================================================================
R5RS : 6.6 Input and Output : 6.6.1 Ports
===========================================================================*/
-ScmObj ScmOp_call_with_input_file(ScmObj filepath, ScmObj proc)
+ScmObj
+scm_p_call_with_input_file(ScmObj filepath, ScmObj proc)
{
ScmObj port, ret;
- DECLARE_FUNCTION("call-with-input-file", ProcedureFixed2);
+ DECLARE_FUNCTION("call-with-input-file", procedure_fixed_2);
ASSERT_STRINGP(filepath);
ASSERT_PROCEDUREP(proc);
- port = ScmOp_open_input_file(filepath);
+ port = scm_p_open_input_file(filepath);
- ret = Scm_call(proc, LIST_1(port));
+ ret = scm_call(proc, LIST_1(port));
- ScmOp_close_input_port(port);
+ scm_p_close_input_port(port);
return ret;
}
-ScmObj ScmOp_call_with_output_file(ScmObj filepath, ScmObj proc)
+ScmObj
+scm_p_call_with_output_file(ScmObj filepath, ScmObj proc)
{
ScmObj port, ret;
- DECLARE_FUNCTION("call-with-output-file", ProcedureFixed2);
+ DECLARE_FUNCTION("call-with-output-file", procedure_fixed_2);
ASSERT_STRINGP(filepath);
ASSERT_PROCEDUREP(proc);
- port = ScmOp_open_output_file(filepath);
+ port = scm_p_open_output_file(filepath);
- ret = Scm_call(proc, LIST_1(port));
+ ret = scm_call(proc, LIST_1(port));
- ScmOp_close_output_port(port);
+ scm_p_close_output_port(port);
return ret;
}
-ScmObj ScmOp_input_portp(ScmObj port)
+ScmObj
+scm_p_input_portp(ScmObj port)
{
- DECLARE_FUNCTION("input-port?", ProcedureFixed1);
+ DECLARE_FUNCTION("input-port?", procedure_fixed_1);
ASSERT_PORTP(port);
return (SCM_PORT_FLAG(port) & SCM_PORTFLAG_INPUT) ? SCM_TRUE : SCM_FALSE;
}
-ScmObj ScmOp_output_portp(ScmObj port)
+ScmObj
+scm_p_output_portp(ScmObj port)
{
- DECLARE_FUNCTION("output-port?", ProcedureFixed1);
+ DECLARE_FUNCTION("output-port?", procedure_fixed_1);
ASSERT_PORTP(port);
return (SCM_PORT_FLAG(port) & SCM_PORTFLAG_OUTPUT) ? SCM_TRUE : SCM_FALSE;
}
-ScmObj ScmOp_current_input_port(void)
+ScmObj
+scm_p_current_input_port(void)
{
- DECLARE_FUNCTION("current-input-port", ProcedureFixed0);
+ DECLARE_FUNCTION("current-input-port", procedure_fixed_0);
return scm_current_input_port;
}
-ScmObj ScmOp_current_output_port(void)
+ScmObj
+scm_p_current_output_port(void)
{
- DECLARE_FUNCTION("current-output-port", ProcedureFixed0);
+ DECLARE_FUNCTION("current-output-port", procedure_fixed_0);
return scm_current_output_port;
}
-ScmObj ScmOp_with_input_from_file(ScmObj filepath, ScmObj thunk)
+ScmObj
+scm_p_with_input_from_file(ScmObj filepath, ScmObj thunk)
{
ScmObj saved_port, ret;
- DECLARE_FUNCTION("with-input-from-file", ProcedureFixed2);
+ DECLARE_FUNCTION("with-input-from-file", procedure_fixed_2);
ASSERT_STRINGP(filepath);
ASSERT_PROCEDUREP(thunk);
saved_port = scm_current_input_port;
- scm_current_input_port = ScmOp_open_input_file(filepath);
+ scm_current_input_port = scm_p_open_input_file(filepath);
- ret = Scm_call(thunk, SCM_NULL);
+ ret = scm_call(thunk, SCM_NULL);
- ScmOp_close_input_port(scm_current_input_port);
+ scm_p_close_input_port(scm_current_input_port);
scm_current_input_port = saved_port;
return ret;
}
-ScmObj ScmOp_with_output_to_file(ScmObj filepath, ScmObj thunk)
+ScmObj
+scm_p_with_output_to_file(ScmObj filepath, ScmObj thunk)
{
ScmObj saved_port, ret;
- DECLARE_FUNCTION("with-output-to-file", ProcedureFixed2);
+ DECLARE_FUNCTION("with-output-to-file", procedure_fixed_2);
ASSERT_STRINGP(filepath);
ASSERT_PROCEDUREP(thunk);
saved_port = scm_current_output_port;
- scm_current_output_port = ScmOp_open_output_file(filepath);
+ scm_current_output_port = scm_p_open_output_file(filepath);
- ret = Scm_call(thunk, SCM_NULL);
+ ret = scm_call(thunk, SCM_NULL);
- ScmOp_close_output_port(scm_current_output_port);
+ scm_p_close_output_port(scm_current_output_port);
scm_current_output_port = saved_port;
return ret;
}
-ScmObj ScmOp_open_input_file(ScmObj filepath)
+ScmObj
+scm_p_open_input_file(ScmObj filepath)
{
ScmBytePort *bport;
- DECLARE_FUNCTION("open-input-file", ProcedureFixed1);
+ DECLARE_FUNCTION("open-input-file", procedure_fixed_1);
ASSERT_STRINGP(filepath);
@@ -292,13 +310,14 @@
if (!bport)
ERR_OBJ("cannot open file ", filepath);
- return Scm_NewPort(Scm_NewCharPort(bport), SCM_PORTFLAG_INPUT);
+ return scm_make_port(scm_make_char_port(bport), SCM_PORTFLAG_INPUT);
}
-ScmObj ScmOp_open_output_file(ScmObj filepath)
+ScmObj
+scm_p_open_output_file(ScmObj filepath)
{
ScmBytePort *bport;
- DECLARE_FUNCTION("open-output-file", ProcedureFixed1);
+ DECLARE_FUNCTION("open-output-file", procedure_fixed_1);
ASSERT_STRINGP(filepath);
@@ -306,13 +325,14 @@
if (!bport)
ERR_OBJ("cannot open file ", filepath);
- return Scm_NewPort(Scm_NewCharPort(bport), SCM_PORTFLAG_OUTPUT);
+ return scm_make_port(scm_make_char_port(bport), SCM_PORTFLAG_OUTPUT);
}
-ScmObj ScmOp_close_input_port(ScmObj port)
+ScmObj
+scm_p_close_input_port(ScmObj port)
{
int flag;
- DECLARE_FUNCTION("close-input-port", ProcedureFixed1);
+ DECLARE_FUNCTION("close-input-port", procedure_fixed_1);
ASSERT_PORTP(port);
@@ -324,10 +344,11 @@
return SCM_UNDEF;
}
-ScmObj ScmOp_close_output_port(ScmObj port)
+ScmObj
+scm_p_close_output_port(ScmObj port)
{
int flag;
- DECLARE_FUNCTION("close-output-port", ProcedureFixed1);
+ DECLARE_FUNCTION("close-output-port", procedure_fixed_1);
ASSERT_PORTP(port);
@@ -352,20 +373,22 @@
} while (/* CONSTCOND */ 0)
-ScmObj ScmOp_read(ScmObj args)
+ScmObj
+scm_p_read(ScmObj args)
{
ScmObj port;
- DECLARE_FUNCTION("read", ProcedureVariadic0);
+ DECLARE_FUNCTION("read", procedure_variadic_0);
PREPARE_PORT(port, args, scm_current_input_port);
- return SigScm_Read(port);
+ return scm_read(port);
}
-ScmObj ScmOp_read_char(ScmObj args)
+ScmObj
+scm_p_read_char(ScmObj args)
{
ScmObj port;
int ch;
- DECLARE_FUNCTION("read-char", ProcedureVariadic0);
+ DECLARE_FUNCTION("read-char", procedure_variadic_0);
PREPARE_PORT(port, args, scm_current_input_port);
@@ -373,14 +396,15 @@
if (ch == EOF)
return SCM_EOF;
- return Scm_NewChar(ch);
+ return scm_make_char(ch);
}
-ScmObj ScmOp_peek_char(ScmObj args)
+ScmObj
+scm_p_peek_char(ScmObj args)
{
ScmObj port;
int ch;
- DECLARE_FUNCTION("peek-char", ProcedureVariadic0);
+ DECLARE_FUNCTION("peek-char", procedure_variadic_0);
PREPARE_PORT(port, args, scm_current_input_port);
@@ -388,20 +412,22 @@
if (ch == EOF)
return SCM_EOF;
- return Scm_NewChar(ch);
+ return scm_make_char(ch);
}
-ScmObj ScmOp_eof_objectp(ScmObj obj)
+ScmObj
+scm_p_eof_objectp(ScmObj obj)
{
- DECLARE_FUNCTION("eof-object?", ProcedureFixed1);
+ DECLARE_FUNCTION("eof-object?", procedure_fixed_1);
return (EOFP(obj)) ? SCM_TRUE : SCM_FALSE;
}
-ScmObj ScmOp_char_readyp(ScmObj args)
+ScmObj
+scm_p_char_readyp(ScmObj args)
{
ScmObj port;
- DECLARE_FUNCTION("char-ready?", ProcedureVariadic0);
+ DECLARE_FUNCTION("char-ready?", procedure_variadic_0);
PREPARE_PORT(port, args, scm_current_input_port);
@@ -411,52 +437,57 @@
/*===========================================================================
R5RS : 6.6 Input and Output : 6.6.3 Output
===========================================================================*/
-ScmObj ScmOp_write(ScmObj obj, ScmObj args)
+ScmObj
+scm_p_write(ScmObj obj, ScmObj args)
{
ScmObj port;
- DECLARE_FUNCTION("write", ProcedureVariadic1);
+ DECLARE_FUNCTION("write", procedure_variadic_1);
PREPARE_PORT(port, args, scm_current_output_port);
- SigScm_WriteToPort(port, obj);
+ scm_write_to_port(port, obj);
return SCM_UNDEF;
}
-ScmObj ScmOp_display(ScmObj obj, ScmObj args)
+ScmObj
+scm_p_display(ScmObj obj, ScmObj args)
{
ScmObj port;
- DECLARE_FUNCTION("display", ProcedureVariadic1);
+ DECLARE_FUNCTION("display", procedure_variadic_1);
PREPARE_PORT(port, args, scm_current_output_port);
- SigScm_DisplayToPort(port, obj);
+ scm_display_to_port(port, obj);
return SCM_UNDEF;
}
-ScmObj ScmOp_newline(ScmObj args)
+ScmObj
+scm_p_newline(ScmObj args)
{
ScmObj port;
- DECLARE_FUNCTION("newline", ProcedureVariadic0);
+ DECLARE_FUNCTION("newline", procedure_variadic_0);
PREPARE_PORT(port, args, scm_current_output_port);
- SigScm_PortNewline(port);
+ scm_port_newline(port);
return SCM_UNDEF;
}
-ScmObj ScmOp_write_char(ScmObj obj, ScmObj args)
+ScmObj
+scm_p_write_char(ScmObj obj, ScmObj args)
{
ScmObj port;
- DECLARE_FUNCTION("write-char", ProcedureVariadic1);
+ DECLARE_FUNCTION("write-char", procedure_variadic_1);
ASSERT_CHARP(obj);
PREPARE_PORT(port, args, scm_current_output_port);
- SigScm_DisplayToPort(port, obj);
+ scm_display_to_port(port, obj);
return SCM_UNDEF;
}
/*===========================================================================
R5RS : 6.6 Input and Output : 6.6.4 System Interface
===========================================================================*/
-ScmObj SigScm_load(const char *c_filename)
+ScmObj
+scm_load(const char *c_filename)
{
#if !SCM_GCC4_READY_GC
ScmObj stack_start;
@@ -464,21 +495,22 @@
ScmObj succeeded;
#if SCM_GCC4_READY_GC
- SCM_GC_PROTECTED_CALL(succeeded, ScmObj, SigScm_load_internal, (c_filename));
+ SCM_GC_PROTECTED_CALL(succeeded, ScmObj, scm_load_internal, (c_filename));
#else
/* start protecting stack */
- SigScm_GC_ProtectStack(&stack_start);
+ scm_gc_protect_stack(&stack_start);
- succeeded = SigScm_load_internal(c_filename);
+ succeeded = scm_load_internal(c_filename);
/* now no need to protect stack */
- SigScm_GC_UnprotectStack(&stack_start);
+ scm_gc_unprotect_stack(&stack_start);
#endif
return succeeded;
}
-static ScmObj SigScm_load_internal(const char *c_filename)
+static ScmObj
+scm_load_internal(const char *c_filename)
{
ScmObj path, port, sexp;
char *c_path;
@@ -488,23 +520,23 @@
c_path = find_path(c_filename);
if (!c_path)
- ERR("SigScm_load_internal: file \"%s\" not found", c_filename);
+ ERR("scm_load_internal: file \"%s\" not found", c_filename);
- path = Scm_NewImmutableString(c_path);
- port = ScmOp_open_input_file(path);
+ path = scm_make_immutable_string(c_path);
+ port = scm_p_open_input_file(path);
- saved_codec = Scm_current_char_codec;
+ saved_codec = scm_current_char_codec;
#if SCM_USE_SRFI22
if (SCM_PORT_PEEK_CHAR(port) == '#')
interpret_script_prelude(port);
#endif
/* read & eval cycle */
- while (sexp = SigScm_Read(port), !EOFP(sexp))
+ while (sexp = scm_read(port), !EOFP(sexp))
EVAL(sexp, SCM_INTERACTION_ENV);
- ScmOp_close_input_port(port);
- Scm_current_char_codec = saved_codec;
+ scm_p_close_input_port(port);
+ scm_current_char_codec = saved_codec;
CDBG((SCM_DBG_FILE, "done."));
@@ -552,13 +584,14 @@
}
}
-ScmObj ScmOp_load(ScmObj filename)
+ScmObj
+scm_p_load(ScmObj filename)
{
- DECLARE_FUNCTION("load", ProcedureFixed1);
+ DECLARE_FUNCTION("load", procedure_fixed_1);
ASSERT_STRINGP(filename);
- SigScm_load_internal(SCM_STRING_STR(filename));
+ scm_load_internal(SCM_STRING_STR(filename));
return SCM_UNDEF;
}
@@ -569,14 +602,14 @@
char **argv;
argv = parse_script_prelude(port);
- Scm_InterpretArgv(argv);
+ scm_interpret_argv(argv);
#if SCM_USE_MULTIBYTE_CHAR
if (SCM_CHARPORT_DYNAMIC_CAST(ScmMultiByteCharPort, SCM_PORT_IMPL(port))) {
ScmMultiByteCharPort_set_codec(SCM_PORT_IMPL(port),
- Scm_current_char_codec);
+ scm_current_char_codec);
}
#endif
- Scm_FreeArgv(argv);
+ scm_free_argv(argv);
}
static char **parse_script_prelude(ScmObj port)
Modified: branches/r5rs/sigscheme/main.c
===================================================================
--- branches/r5rs/sigscheme/main.c 2005-12-16 08:29:32 UTC (rev 2609)
+++ branches/r5rs/sigscheme/main.c 2005-12-16 09:06:42 UTC (rev 2610)
@@ -79,13 +79,13 @@
#endif
#if !SCM_GCC4_READY_GC
- SigScm_GC_ProtectStack(&stack_start);
+ scm_gc_protect_stack(&stack_start);
#endif
repl_loop();
#if !SCM_GCC4_READY_GC
- SigScm_GC_UnprotectStack(&stack_start);
+ scm_gc_unprotect_stack(&stack_start);
#endif
}
@@ -95,15 +95,15 @@
#if SCM_USE_SRFI34
ScmObj sym_guard, cond_catch, proc_read, err;
- proc_read = Scm_SymbolValue(Scm_Intern("read"), SCM_INTERACTION_ENV);
+ proc_read = scm_symbol_value(scm_intern("read"), SCM_INTERACTION_ENV);
err = CONS(SCM_UNDEF, SCM_UNDEF); /* unique ID */
/* prepare the constant part of the form to get the loop fast */
- sym_guard = Scm_Intern("guard");
- cond_catch = LIST_2(Scm_Intern("err"),
+ sym_guard = scm_intern("guard");
+ cond_catch = LIST_2(scm_intern("err"),
LIST_3(SYM_ELSE,
- LIST_2(Scm_Intern("%%inspect-error"),
- Scm_Intern("err")),
+ LIST_2(scm_intern("%%inspect-error"),
+ scm_intern("err")),
LIST_2(SCM_SYM_QUOTE, err)));
#endif /* SCM_USE_SRFI34 */
@@ -136,7 +136,7 @@
result = EVAL(LIST_3(sym_guard, cond_catch, sexp),
SCM_INTERACTION_ENV);
#else /* SCM_USE_SRFI34 */
- sexp = SigScm_Read(scm_current_input_port)
+ sexp = scm_read(scm_current_input_port)
if (EOFP(sexp))
break;
@@ -145,7 +145,7 @@
if (!EQ(result, err)) {
SCM_WRITESS_TO_PORT(scm_current_output_port, result);
- SigScm_PortNewline(scm_current_output_port);
+ scm_port_newline(scm_current_output_port);
}
}
}
@@ -153,8 +153,8 @@
static int show_promptp(void)
{
#if SCM_COMPAT_SIOD
- return (FALSEP(ScmOp_providedp(feature_id_siod))
- || SigScm_GetVerboseLevel() >= 2);
+ return (FALSEP(scm_p_providedp(feature_id_siod))
+ || scm_get_verbose_level() >= 2);
#else
return TRUE;
#endif
@@ -165,23 +165,23 @@
const char *filename;
char **rest_argv;
- /* must be done before SigScm_Initialize() */
- rest_argv = Scm_InterpretArgv(argv);
+ /* must be done before scm_initialize() */
+ rest_argv = scm_interpret_argv(argv);
filename = rest_argv[0];
- SigScm_Initialize();
+ scm_initialize();
#if SCM_USE_SRFI34
- Scm_Use("srfi-34");
+ scm_use("srfi-34");
#endif
#if SCM_COMPAT_SIOD
- SigScm_GC_Protect(&feature_id_siod);
- feature_id_siod = Scm_NewImmutableStringCopying(FEATURE_ID_SIOD);
+ scm_gc_protect(&feature_id_siod);
+ feature_id_siod = scm_make_immutable_string_copying(FEATURE_ID_SIOD);
#endif
if (filename) {
- SigScm_load(filename);
+ scm_load(filename);
} else {
#if SCM_GCC4_READY_GC
SCM_GC_PROTECTED_CALL_VOID(repl, ());
@@ -191,6 +191,6 @@
/* ERR("usage: sscm <filename>"); */
}
- SigScm_Finalize();
+ scm_finalize();
return EXIT_SUCCESS;
}
Modified: branches/r5rs/sigscheme/mbcport.c
===================================================================
--- branches/r5rs/sigscheme/mbcport.c 2005-12-16 08:29:32 UTC (rev 2609)
+++ branches/r5rs/sigscheme/mbcport.c 2005-12-16 09:06:42 UTC (rev 2610)
@@ -102,7 +102,7 @@
Function Implementations
=======================================*/
void
-Scm_mbcport_init(void)
+scm_mbcport_init(void)
{
ScmCharPortVTbl *vptr;
Modified: branches/r5rs/sigscheme/mbcport.h
===================================================================
--- branches/r5rs/sigscheme/mbcport.h 2005-12-16 08:29:32 UTC (rev 2609)
+++ branches/r5rs/sigscheme/mbcport.h 2005-12-16 09:06:42 UTC (rev 2610)
@@ -71,7 +71,7 @@
/*=======================================
Function Declarations
=======================================*/
-void Scm_mbcport_init(void);
+void scm_mbcport_init(void);
void ScmMultiByteCharPort_construct(ScmMultiByteCharPort *port,
const ScmCharPortVTbl *vptr,
Modified: branches/r5rs/sigscheme/nullport.c
===================================================================
--- branches/r5rs/sigscheme/nullport.c 2005-12-16 08:29:32 UTC (rev 2609)
+++ branches/r5rs/sigscheme/nullport.c 2005-12-16 09:06:42 UTC (rev 2610)
@@ -103,7 +103,8 @@
* Client code must call this first even if current implementation does not
* contain actual code.
*/
-void Scm_nullport_init(void)
+void
+scm_nullport_init(void)
{
}
Modified: branches/r5rs/sigscheme/nullport.h
===================================================================
--- branches/r5rs/sigscheme/nullport.h 2005-12-16 08:29:32 UTC (rev 2609)
+++ branches/r5rs/sigscheme/nullport.h 2005-12-16 09:06:42 UTC (rev 2610)
@@ -65,7 +65,7 @@
/*=======================================
Function Declarations
=======================================*/
-void Scm_nullport_init(void);
+void scm_nullport_init(void);
ScmBytePort *ScmNullPort_new(void);
Modified: branches/r5rs/sigscheme/operations-nonstd.c
===================================================================
--- branches/r5rs/sigscheme/operations-nonstd.c 2005-12-16 08:29:32 UTC (rev 2609)
+++ branches/r5rs/sigscheme/operations-nonstd.c 2005-12-16 09:06:42 UTC (rev 2610)
@@ -62,10 +62,11 @@
/*=======================================
Function Implementations
=======================================*/
-void SigScm_Initialize_NONSTD_FEATURES(void)
+void
+scm_initialize_nonstd_features(void)
{
REGISTER_FUNC_TABLE(nonstd_func_info_table);
- Scm_DefineAlias("call/cc", "call-with-current-continuation");
+ scm_define_alias("call/cc", "call-with-current-continuation");
}
/*
@@ -77,10 +78,11 @@
* procedure with global-variable-bound?.
*/
/* The implementation is fully compatible with SIOD */
-ScmObj ScmOp_symbol_boundp(ScmObj sym, ScmObj rest)
+ScmObj
+scm_p_symbol_boundp(ScmObj sym, ScmObj rest)
{
ScmObj env = SCM_INVALID;
- DECLARE_FUNCTION("symbol-bound?", ProcedureVariadic1);
+ DECLARE_FUNCTION("symbol-bound?", procedure_variadic_1);
ASSERT_SYMBOLP(sym);
@@ -90,36 +92,38 @@
else
env = SCM_INTERACTION_ENV;
- return (Scm_LookupEnvironment(sym, env) != SCM_INVALID_REF
+ return (scm_lookup_environment(sym, env) != SCM_INVALID_REF
|| SCM_SYMBOL_BOUNDP(sym)) ? SCM_TRUE : SCM_FALSE;
}
/* SIOD compatible */
-ScmObj ScmOp_load_path(void)
+ScmObj
+scm_p_load_path(void)
{
- DECLARE_FUNCTION("load-path", ProcedureFixed0);
- return Scm_NewImmutableStringCopying(scm_lib_path);
+ DECLARE_FUNCTION("load-path", procedure_fixed_0);
+ return scm_make_immutable_string_copying(scm_lib_path);
}
-/* FIXME: add ScmObj SigScm_require(const char *c_filename) */
-ScmObj ScmOp_require(ScmObj filename)
+/* FIXME: add ScmObj scm_require(const char *c_filename) */
+ScmObj
+scm_p_require(ScmObj filename)
{
ScmObj loaded_str = SCM_FALSE;
#if SCM_COMPAT_SIOD
ScmObj retsym = SCM_FALSE;
#endif
- DECLARE_FUNCTION("require", ProcedureFixed1);
+ DECLARE_FUNCTION("require", procedure_fixed_1);
ASSERT_STRINGP(filename);
loaded_str = create_loaded_str(filename);
- if (FALSEP(ScmOp_providedp(loaded_str))) {
- ScmOp_load(filename);
- ScmOp_provide(loaded_str);
+ if (FALSEP(scm_p_providedp(loaded_str))) {
+ scm_p_load(filename);
+ scm_p_provide(loaded_str);
}
#if SCM_COMPAT_SIOD
- retsym = Scm_Intern(SCM_STRING_STR(loaded_str));
+ retsym = scm_intern(SCM_STRING_STR(loaded_str));
SCM_SYMBOL_SET_VCELL(retsym, SCM_TRUE);
return retsym;
@@ -138,20 +142,21 @@
loaded_str = scm_malloc(size);
snprintf(loaded_str, size, "*%s-loaded*", SCM_STRING_STR(filename));
- return Scm_NewImmutableString(loaded_str);
+ return scm_make_immutable_string(loaded_str);
}
/*
* TODO: replace original specification with a SRFI standard or other de facto
* standard
*/
-ScmObj ScmOp_provide(ScmObj feature)
+ScmObj
+scm_p_provide(ScmObj feature)
{
- DECLARE_FUNCTION("provide", ProcedureFixed1);
+ DECLARE_FUNCTION("provide", procedure_fixed_1);
ASSERT_STRINGP(feature);
- Scm_Provide(feature);
+ scm_provide(feature);
return SCM_TRUE;
}
@@ -160,23 +165,25 @@
* TODO: replace original specification with a SRFI standard or other de facto
* standard
*/
-ScmObj ScmOp_providedp(ScmObj feature)
+ScmObj
+scm_p_providedp(ScmObj feature)
{
- DECLARE_FUNCTION("provided?", ProcedureFixed1);
+ DECLARE_FUNCTION("provided?", procedure_fixed_1);
ASSERT_STRINGP(feature);
- return (Scm_Providedp(feature)) ? SCM_TRUE : SCM_FALSE;
+ return (scm_providedp(feature)) ? SCM_TRUE : SCM_FALSE;
}
/*
* TODO: describe compatibility with de facto standard of other Scheme
* implementations
*/
-ScmObj ScmOp_file_existsp(ScmObj filepath)
+ScmObj
+scm_p_file_existsp(ScmObj filepath)
{
FILE *f;
- DECLARE_FUNCTION("file-exists?", ProcedureFixed1);
+ DECLARE_FUNCTION("file-exists?", procedure_fixed_1);
ASSERT_STRINGP(filepath);
@@ -189,9 +196,10 @@
}
/* TODO: remove to ensure security */
-ScmObj ScmOp_delete_file(ScmObj filepath)
+ScmObj
+scm_p_delete_file(ScmObj filepath)
{
- DECLARE_FUNCTION("delete-file", ProcedureFixed1);
+ DECLARE_FUNCTION("delete-file", procedure_fixed_1);
ASSERT_STRINGP(filepath);
Modified: branches/r5rs/sigscheme/operations-r5rs-deepcadrs.c
===================================================================
--- branches/r5rs/sigscheme/operations-r5rs-deepcadrs.c 2005-12-16 08:29:32 UTC (rev 2609)
+++ branches/r5rs/sigscheme/operations-r5rs-deepcadrs.c 2005-12-16 09:06:42 UTC (rev 2610)
@@ -61,114 +61,136 @@
/*=======================================
Function Implementations
=======================================*/
-ScmObj ScmOp_caaar(ScmObj lst)
+ScmObj
+scm_p_caaar(ScmObj lst)
{
- DECLARE_FUNCTION("caaar", ProcedureFixed1);
- return ScmOp_car( ScmOp_car( ScmOp_car(lst) ));
+ DECLARE_FUNCTION("caaar", procedure_fixed_1);
+ return scm_p_car( scm_p_car( scm_p_car(lst) ));
}
-ScmObj ScmOp_caadr(ScmObj lst)
+ScmObj
+scm_p_caadr(ScmObj lst)
{
- DECLARE_FUNCTION("caadr", ProcedureFixed1);
- return ScmOp_car( ScmOp_car( ScmOp_cdr(lst) ));
+ DECLARE_FUNCTION("caadr", procedure_fixed_1);
+ return scm_p_car( scm_p_car( scm_p_cdr(lst) ));
}
-ScmObj ScmOp_cadar(ScmObj lst)
+ScmObj
+scm_p_cadar(ScmObj lst)
{
- DECLARE_FUNCTION("cadar", ProcedureFixed1);
- return ScmOp_car( ScmOp_cdr( ScmOp_car(lst) ));
+ DECLARE_FUNCTION("cadar", procedure_fixed_1);
+ return scm_p_car( scm_p_cdr( scm_p_car(lst) ));
}
-ScmObj ScmOp_cdaar(ScmObj lst)
+ScmObj
+scm_p_cdaar(ScmObj lst)
{
- DECLARE_FUNCTION("cdaar", ProcedureFixed1);
- return ScmOp_cdr( ScmOp_car( ScmOp_car(lst) ));
+ DECLARE_FUNCTION("cdaar", procedure_fixed_1);
+ return scm_p_cdr( scm_p_car( scm_p_car(lst) ));
}
-ScmObj ScmOp_cdadr(ScmObj lst)
+ScmObj
+scm_p_cdadr(ScmObj lst)
{
- DECLARE_FUNCTION("cdadr", ProcedureFixed1);
- return ScmOp_cdr( ScmOp_car( ScmOp_cdr(lst) ));
+ DECLARE_FUNCTION("cdadr", procedure_fixed_1);
+ return scm_p_cdr( scm_p_car( scm_p_cdr(lst) ));
}
-ScmObj ScmOp_cddar(ScmObj lst)
+ScmObj
+scm_p_cddar(ScmObj lst)
{
- DECLARE_FUNCTION("cddar", ProcedureFixed1);
- return ScmOp_cdr( ScmOp_cdr( ScmOp_car(lst) ));
+ DECLARE_FUNCTION("cddar", procedure_fixed_1);
+ return scm_p_cdr( scm_p_cdr( scm_p_car(lst) ));
}
-ScmObj ScmOp_caaaar(ScmObj lst)
+ScmObj
+scm_p_caaaar(ScmObj lst)
{
- DECLARE_FUNCTION("caaaar", ProcedureFixed1);
- return ScmOp_car( ScmOp_car( ScmOp_car( ScmOp_car(lst) )));
+ DECLARE_FUNCTION("caaaar", procedure_fixed_1);
+ return scm_p_car( scm_p_car( scm_p_car( scm_p_car(lst) )));
}
-ScmObj ScmOp_caaadr(ScmObj lst)
+ScmObj
+scm_p_caaadr(ScmObj lst)
{
- DECLARE_FUNCTION("caaadr", ProcedureFixed1);
- return ScmOp_car( ScmOp_car( ScmOp_car( ScmOp_cdr(lst) )));
+ DECLARE_FUNCTION("caaadr", procedure_fixed_1);
+ return scm_p_car( scm_p_car( scm_p_car( scm_p_cdr(lst) )));
}
-ScmObj ScmOp_caadar(ScmObj lst)
+ScmObj
+scm_p_caadar(ScmObj lst)
{
- DECLARE_FUNCTION("caadar", ProcedureFixed1);
- return ScmOp_car( ScmOp_car( ScmOp_cdr( ScmOp_car(lst) )));
+ DECLARE_FUNCTION("caadar", procedure_fixed_1);
+ return scm_p_car( scm_p_car( scm_p_cdr( scm_p_car(lst) )));
}
-ScmObj ScmOp_caaddr(ScmObj lst)
+ScmObj
+scm_p_caaddr(ScmObj lst)
{
- DECLARE_FUNCTION("caaddr", ProcedureFixed1);
- return ScmOp_car( ScmOp_car( ScmOp_cdr( ScmOp_cdr(lst) )));
+ DECLARE_FUNCTION("caaddr", procedure_fixed_1);
+ return scm_p_car( scm_p_car( scm_p_cdr( scm_p_cdr(lst) )));
}
-ScmObj ScmOp_cadaar(ScmObj lst)
+ScmObj
+scm_p_cadaar(ScmObj lst)
{
- DECLARE_FUNCTION("cadaar", ProcedureFixed1);
- return ScmOp_car( ScmOp_cdr( ScmOp_car( ScmOp_car(lst) )));
+ DECLARE_FUNCTION("cadaar", procedure_fixed_1);
+ return scm_p_car( scm_p_cdr( scm_p_car( scm_p_car(lst) )));
}
-ScmObj ScmOp_cadadr(ScmObj lst)
+ScmObj
+scm_p_cadadr(ScmObj lst)
{
- DECLARE_FUNCTION("cadadr", ProcedureFixed1);
- return ScmOp_car( ScmOp_cdr( ScmOp_car( ScmOp_cdr(lst) )));
+ DECLARE_FUNCTION("cadadr", procedure_fixed_1);
+ return scm_p_car( scm_p_cdr( scm_p_car( scm_p_cdr(lst) )));
}
-ScmObj ScmOp_caddar(ScmObj lst)
+ScmObj
+scm_p_caddar(ScmObj lst)
{
- DECLARE_FUNCTION("caddar", ProcedureFixed1);
- return ScmOp_car( ScmOp_cdr( ScmOp_cdr( ScmOp_car(lst) )));
+ DECLARE_FUNCTION("caddar", procedure_fixed_1);
+ return scm_p_car( scm_p_cdr( scm_p_cdr( scm_p_car(lst) )));
}
-ScmObj ScmOp_cadddr(ScmObj lst)
+ScmObj
+scm_p_cadddr(ScmObj lst)
{
- DECLARE_FUNCTION("cadddr", ProcedureFixed1);
- return ScmOp_car( ScmOp_cdr( ScmOp_cdr( ScmOp_cdr(lst) )));
+ DECLARE_FUNCTION("cadddr", procedure_fixed_1);
+ return scm_p_car( scm_p_cdr( scm_p_cdr( scm_p_cdr(lst) )));
}
-ScmObj ScmOp_cdaaar(ScmObj lst)
+ScmObj
+scm_p_cdaaar(ScmObj lst)
{
- DECLARE_FUNCTION("cdaaar", ProcedureFixed1);
- return ScmOp_cdr( ScmOp_car( ScmOp_car( ScmOp_car(lst) )));
+ DECLARE_FUNCTION("cdaaar", procedure_fixed_1);
+ return scm_p_cdr( scm_p_car( scm_p_car( scm_p_car(lst) )));
}
-ScmObj ScmOp_cdaadr(ScmObj lst)
+ScmObj
+scm_p_cdaadr(ScmObj lst)
{
- DECLARE_FUNCTION("cdaadr", ProcedureFixed1);
- return ScmOp_cdr( ScmOp_car( ScmOp_car( ScmOp_cdr(lst) )));
+ DECLARE_FUNCTION("cdaadr", procedure_fixed_1);
+ return scm_p_cdr( scm_p_car( scm_p_car( scm_p_cdr(lst) )));
}
-ScmObj ScmOp_cdadar(ScmObj lst)
+ScmObj
+scm_p_cdadar(ScmObj lst)
{
- DECLARE_FUNCTION("cdadar", ProcedureFixed1);
- return ScmOp_cdr( ScmOp_car( ScmOp_cdr( ScmOp_car(lst) )));
+ DECLARE_FUNCTION("cdadar", procedure_fixed_1);
+ return scm_p_cdr( scm_p_car( scm_p_cdr( scm_p_car(lst) )));
}
-ScmObj ScmOp_cdaddr(ScmObj lst)
+ScmObj
+scm_p_cdaddr(ScmObj lst)
{
- DECLARE_FUNCTION("cdaddr", ProcedureFixed1);
- return ScmOp_cdr( ScmOp_car( ScmOp_cdr( ScmOp_cdr(lst) )));
+ DECLARE_FUNCTION("cdaddr", procedure_fixed_1);
+ return scm_p_cdr( scm_p_car( scm_p_cdr( scm_p_cdr(lst) )));
}
-ScmObj ScmOp_cddaar(ScmObj lst)
+ScmObj
+scm_p_cddaar(ScmObj lst)
{
- DECLARE_FUNCTION("cddaar", ProcedureFixed1);
- return ScmOp_cdr( ScmOp_cdr( ScmOp_car( ScmOp_car(lst) )));
+ DECLARE_FUNCTION("cddaar", procedure_fixed_1);
+ return scm_p_cdr( scm_p_cdr( scm_p_car( scm_p_car(lst) )));
}
-ScmObj ScmOp_cddadr(ScmObj lst)
+ScmObj
+scm_p_cddadr(ScmObj lst)
{
- DECLARE_FUNCTION("cddadr", ProcedureFixed1);
- return ScmOp_cdr( ScmOp_cdr( ScmOp_car( ScmOp_cdr(lst) )));
+ DECLARE_FUNCTION("cddadr", procedure_fixed_1);
+ return scm_p_cdr( scm_p_cdr( scm_p_car( scm_p_cdr(lst) )));
}
-ScmObj ScmOp_cdddar(ScmObj lst)
+ScmObj
+scm_p_cdddar(ScmObj lst)
{
- DECLARE_FUNCTION("cdddar", ProcedureFixed1);
- return ScmOp_cdr( ScmOp_cdr( ScmOp_cdr( ScmOp_car(lst) )));
+ DECLARE_FUNCTION("cdddar", procedure_fixed_1);
+ return scm_p_cdr( scm_p_cdr( scm_p_cdr( scm_p_car(lst) )));
}
-ScmObj ScmOp_cddddr(ScmObj lst)
+ScmObj
+scm_p_cddddr(ScmObj lst)
{
- DECLARE_FUNCTION("cddddr", ProcedureFixed1);
- return ScmOp_cdr( ScmOp_cdr( ScmOp_cdr( ScmOp_cdr(lst) )));
+ DECLARE_FUNCTION("cddddr", procedure_fixed_1);
+ return scm_p_cdr( scm_p_cdr( scm_p_cdr( scm_p_cdr(lst) )));
}
Modified: branches/r5rs/sigscheme/operations-siod.c
===================================================================
--- branches/r5rs/sigscheme/operations-siod.c 2005-12-16 08:29:32 UTC (rev 2609)
+++ branches/r5rs/sigscheme/operations-siod.c 2005-12-16 09:06:42 UTC (rev 2610)
@@ -98,28 +98,29 @@
TODO : remove these functions!
=======================================*/
-void SigScm_Initialize_SIOD(void)
+void
+scm_initialize_siod(void)
{
REGISTER_FUNC_TABLE(siod_func_info_table);
- Scm_Use("srfi-60");
- Scm_DefineAlias("bit-and", "logand");
- Scm_DefineAlias("bit-or", "logior");
- Scm_DefineAlias("bit-xor", "logxor");
- Scm_DefineAlias("bit-not", "lognot");
+ scm_use("srfi-60");
+ scm_define_alias("bit-and", "logand");
+ scm_define_alias("bit-or", "logior");
+ scm_define_alias("bit-xor", "logxor");
+ scm_define_alias("bit-not", "lognot");
null_port = SCM_FALSE;
saved_output_port = SCM_FALSE;
saved_error_port = SCM_FALSE;
- SigScm_GC_Protect(&null_port);
- SigScm_GC_Protect(&saved_output_port);
- SigScm_GC_Protect(&saved_error_port);
+ scm_gc_protect(&null_port);
+ scm_gc_protect(&saved_output_port);
+ scm_gc_protect(&saved_error_port);
- Scm_nullport_init();
- null_port = Scm_NewPort(Scm_NewCharPort(ScmNullPort_new()),
+ scm_nullport_init();
+ null_port = scm_make_port(scm_make_char_port(ScmNullPort_new()),
SCM_PORTFLAG_INPUT | SCM_PORTFLAG_OUTPUT);
- SigScm_SetVerboseLevel(2);
+ scm_set_verbose_level(2);
}
/*
@@ -128,13 +129,14 @@
* - make the portable proc interface similar to a de facto standard of other
* Scheme implementations if existing
*/
-ScmObj ScmOp_symbol_value(ScmObj var)
+ScmObj
+scm_p_symbol_value(ScmObj var)
{
- DECLARE_FUNCTION("symbol-value", ProcedureFixed1);
+ DECLARE_FUNCTION("symbol-value", procedure_fixed_1);
ASSERT_SYMBOLP(var);
- return Scm_SymbolValue(var, SCM_NULL);
+ return scm_symbol_value(var, SCM_NULL);
}
/*
@@ -144,18 +146,20 @@
* - make the portable proc interface similar to a de facto standard of other
* Scheme implementations if existing
*/
-ScmObj ScmOp_set_symbol_valued(ScmObj var, ScmObj val)
+ScmObj
+scm_p_set_symbol_valued(ScmObj var, ScmObj val)
{
- DECLARE_FUNCTION("set-symbol-value!", ProcedureFixed2);
+ DECLARE_FUNCTION("set-symbol-value!", procedure_fixed_2);
ASSERT_SYMBOLP(var);
return SCM_SYMBOL_SET_VCELL(var, val);
}
-ScmObj ScmOp_SIOD_equal(ScmObj obj1, ScmObj obj2)
+ScmObj
+scm_p_siod_equal(ScmObj obj1, ScmObj obj2)
{
- DECLARE_FUNCTION("=", ProcedureFixed2);
+ DECLARE_FUNCTION("=", procedure_fixed_2);
if (EQ(obj1, obj2))
return SCM_TRUE;
@@ -167,19 +171,21 @@
return SCM_FALSE;
}
-ScmObj ScmOp_the_environment(ScmEvalState *eval_state)
+ScmObj
+scm_p_the_environment(ScmEvalState *eval_state)
{
- DECLARE_FUNCTION("the-environment", ProcedureFixedTailRec0);
+ DECLARE_FUNCTION("the-environment", procedure_fixed_tailrec_0);
eval_state->ret_type = SCM_RETTYPE_AS_IS;
return eval_state->env;
}
-ScmObj ScmOp_closure_code(ScmObj closure)
+ScmObj
+scm_p_closure_code(ScmObj closure)
{
ScmObj exp, body;
- DECLARE_FUNCTION("%%closure-code", ProcedureFixed1);
+ DECLARE_FUNCTION("%%closure-code", procedure_fixed_1);
ASSERT_CLOSUREP(closure);
@@ -187,38 +193,41 @@
if (NULLP(CDDR(exp)))
body = CADR(exp);
else
- body = CONS(Scm_Intern("begin"), CDR(exp));
+ body = CONS(scm_intern("begin"), CDR(exp));
return CONS(CAR(exp), body);
}
-ScmObj ScmOp_verbose(ScmObj args)
+ScmObj
+scm_p_verbose(ScmObj args)
{
- DECLARE_FUNCTION("verbose", ProcedureVariadic0);
+ DECLARE_FUNCTION("verbose", procedure_variadic_0);
if (!NULLP(args)) {
ASSERT_INTP(CAR(args));
- SigScm_SetVerboseLevel(SCM_INT_VALUE(CAR(args)));
+ scm_set_verbose_level(SCM_INT_VALUE(CAR(args)));
}
- return Scm_NewInt(sscm_verbose_level);
+ return scm_make_int(sscm_verbose_level);
}
-ScmObj ScmOp_eof_val(void)
+ScmObj
+scm_p_eof_val(void)
{
- DECLARE_FUNCTION("eof-val", ProcedureFixed0);
+ DECLARE_FUNCTION("eof-val", procedure_fixed_0);
return SCM_EOF;
}
-ScmObj ScmExp_undefine(ScmObj var, ScmObj env)
+ScmObj
+scm_s_undefine(ScmObj var, ScmObj env)
{
ScmRef val;
- DECLARE_FUNCTION("undefine", SyntaxFixed1);
+ DECLARE_FUNCTION("undefine", syntax_fixed_1);
ASSERT_SYMBOLP(var);
- val = Scm_LookupEnvironment(var, env);
+ val = scm_lookup_environment(var, env);
if (val != SCM_INVALID_REF)
return SET(val, SCM_UNBOUND);
@@ -227,15 +236,17 @@
return SCM_FALSE;
}
-long SigScm_GetVerboseLevel(void)
+long
+scm_get_verbose_level(void)
{
return sscm_verbose_level;
}
-void SigScm_SetVerboseLevel(long level)
+void
+scm_set_verbose_level(long level)
{
if (level < 0)
- ERR("SigScm_SetVerboseLevel: positive value required but got: %d",
+ ERR("scm_set_verbose_level: positive value required but got: %d",
level);
if (sscm_verbose_level == level)
@@ -245,11 +256,11 @@
if (level > 5)
level = 5;
- SigScm_SetDebugCategories(sscm_debug_mask_tbl[level]);
+ scm_set_debug_categories(sscm_debug_mask_tbl[level]);
if (level >= 2)
- SigScm_SetDebugCategories(SigScm_DebugCategories()
- | SigScm_PredefinedDebugCategories());
+ scm_set_debug_categories(scm_debug_categories()
+ | scm_predefined_debug_categories());
if (level == 0) {
saved_error_port = scm_current_error_port;
Modified: branches/r5rs/sigscheme/operations-srfi1.c
===================================================================
--- branches/r5rs/sigscheme/operations-srfi1.c 2005-12-16 08:29:32 UTC (rev 2609)
+++ branches/r5rs/sigscheme/operations-srfi1.c 2005-12-16 09:06:42 UTC (rev 2610)
@@ -60,7 +60,8 @@
/*=======================================
Function Implementations
=======================================*/
-void SigScm_Initialize_SRFI1(void)
+void
+scm_initialize_srfi1(void)
{
/*=======================================================================
SRFI-1 Procedures
@@ -71,17 +72,19 @@
/*==============================================================================
SRFI1 : The procedures : Constructors
==============================================================================*/
-ScmObj ScmOp_SRFI1_xcons(ScmObj a, ScmObj b)
+ScmObj
+scm_p_srfi1_xcons(ScmObj a, ScmObj b)
{
- DECLARE_FUNCTION("xcons", ProcedureFixed2);
+ DECLARE_FUNCTION("xcons", procedure_fixed_2);
return CONS(b, a);
}
-ScmObj ScmOp_SRFI1_consstar(ScmObj args)
+ScmObj
+scm_p_srfi1_consstar(ScmObj args)
{
ScmObj tail_cons = SCM_FALSE;
ScmObj prev_last = args;
- DECLARE_FUNCTION("cons*", ProcedureVariadic0);
+ DECLARE_FUNCTION("cons*", procedure_variadic_0);
if (NULLP(CDR(args)))
return CAR(args);
@@ -98,13 +101,14 @@
return args;
}
-ScmObj ScmOp_SRFI1_make_list(ScmObj length, ScmObj args)
+ScmObj
+scm_p_srfi1_make_list(ScmObj length, ScmObj args)
{
ScmObj filler = SCM_FALSE;
ScmObj head = SCM_FALSE;
int len = 0;
int i = 0;
- DECLARE_FUNCTION("make-list", ProcedureVariadic1);
+ DECLARE_FUNCTION("make-list", procedure_variadic_1);
ASSERT_INTP(length);
@@ -124,14 +128,15 @@
return head;
}
-ScmObj ScmOp_SRFI1_list_tabulate(ScmObj scm_n, ScmObj args)
+ScmObj
+scm_p_srfi1_list_tabulate(ScmObj scm_n, ScmObj args)
{
ScmObj proc = SCM_FALSE;
ScmObj head = SCM_NULL;
ScmObj num = SCM_FALSE;
int n = 0;
int i = 0;
- DECLARE_FUNCTION("list-tabulate", ProcedureVariadic1);
+ DECLARE_FUNCTION("list-tabulate", procedure_variadic_1);
ASSERT_INTP(scm_n);
@@ -144,10 +149,10 @@
/* then create list */
for (i = n; 0 < i; i--) {
- num = Scm_NewInt(i - 1);
+ num = scm_make_int(i - 1);
if (!NULLP(proc))
- num = Scm_call(proc, LIST_1(num));
+ num = scm_call(proc, LIST_1(num));
head = CONS(num, head);
}
@@ -155,14 +160,15 @@
return head;
}
-ScmObj ScmOp_SRFI1_list_copy(ScmObj lst)
+ScmObj
+scm_p_srfi1_list_copy(ScmObj lst)
{
ScmObj head = SCM_FALSE;
ScmObj tail = SCM_FALSE;
ScmObj obj = SCM_FALSE;
- DECLARE_FUNCTION("list-copy", ProcedureFixed1);
+ DECLARE_FUNCTION("list-copy", procedure_fixed_1);
- if (FALSEP(ScmOp_listp(lst)))
+ if (FALSEP(scm_p_listp(lst)))
ERR_OBJ("list required but got", lst);
for (; !NULLP(lst); lst = CDR(lst)) {
@@ -170,7 +176,7 @@
/* further copy */
if (CONSP(obj))
- obj = ScmOp_SRFI1_list_copy(obj);
+ obj = scm_p_srfi1_list_copy(obj);
/* then create new cons */
obj = CONS(obj, SCM_NULL);
@@ -186,18 +192,20 @@
return head;
}
-ScmObj ScmOp_SRFI1_circular_list(ScmObj args)
+ScmObj
+scm_p_srfi1_circular_list(ScmObj args)
{
- DECLARE_FUNCTION("circular-list", ProcedureVariadic0);
+ DECLARE_FUNCTION("circular-list", procedure_variadic_0);
- if (FALSEP(ScmOp_listp(args)))
+ if (FALSEP(scm_p_listp(args)))
ERR_OBJ("list required but got", args);
- SET_CDR(ScmOp_SRFI1_last_pair(args), args);
+ SET_CDR(scm_p_srfi1_last_pair(args), args);
return args;
}
-ScmObj ScmOp_SRFI1_iota(ScmObj scm_count, ScmObj args)
+ScmObj
+scm_p_srfi1_iota(ScmObj scm_count, ScmObj args)
{
ScmObj scm_start = SCM_FALSE;
ScmObj scm_step = SCM_FALSE;
@@ -206,7 +214,7 @@
int start = 0;
int step = 0;
int i = 0;
- DECLARE_FUNCTION("iota", ProcedureVariadic1);
+ DECLARE_FUNCTION("iota", procedure_variadic_1);
/* get params */
if (!NULLP(args))
@@ -227,7 +235,7 @@
start = NULLP(scm_start) ? 0 : SCM_INT_VALUE(scm_start);
step = NULLP(scm_step) ? 1 : SCM_INT_VALUE(scm_step);
for (i = count - 1; 0 <= i; i--) {
- head = CONS(Scm_NewInt(start + i*step), head);
+ head = CONS(scm_make_int(start + i*step), head);
}
return head;
@@ -236,17 +244,19 @@
/*==============================================================================
SRFI1 : The procedures : Predicates
==============================================================================*/
-ScmObj ScmOp_SRFI1_proper_listp(ScmObj lst)
+ScmObj
+scm_p_srfi1_proper_listp(ScmObj lst)
{
- DECLARE_FUNCTION("proper-list?", ProcedureFixed1);
- return ScmOp_listp(lst);
+ DECLARE_FUNCTION("proper-list?", procedure_fixed_1);
+ return scm_p_listp(lst);
}
-ScmObj ScmOp_SRFI1_circular_listp(ScmObj obj)
+ScmObj
+scm_p_srfi1_circular_listp(ScmObj obj)
{
ScmObj slow = obj;
int len = 0;
- DECLARE_FUNCTION("circular-list?", ProcedureFixed1);
+ DECLARE_FUNCTION("circular-list?", procedure_fixed_1);
for (;;) {
if (NULLP(obj)) break;
@@ -267,11 +277,12 @@
return SCM_FALSE;
}
-ScmObj ScmOp_SRFI1_dotted_listp(ScmObj obj)
+ScmObj
+scm_p_srfi1_dotted_listp(ScmObj obj)
{
ScmObj slow = obj;
int len = 0;
- DECLARE_FUNCTION("dotted-list?", ProcedureFixed1);
+ DECLARE_FUNCTION("dotted-list?", procedure_fixed_1);
for (;;) {
if (NULLP(obj)) break;
@@ -292,23 +303,26 @@
return SCM_FALSE;
}
-ScmObj ScmOp_SRFI1_not_pairp(ScmObj pair)
+ScmObj
+scm_p_srfi1_not_pairp(ScmObj pair)
{
- DECLARE_FUNCTION("not-pair?", ProcedureFixed1);
+ DECLARE_FUNCTION("not-pair?", procedure_fixed_1);
return CONSP(pair) ? SCM_FALSE : SCM_TRUE;
}
-ScmObj ScmOp_SRFI1_null_listp(ScmObj lst)
+ScmObj
+scm_p_srfi1_null_listp(ScmObj lst)
{
- DECLARE_FUNCTION("null-list?", ProcedureFixed1);
+ DECLARE_FUNCTION("null-list?", procedure_fixed_1);
/* TODO : check circular list */
return NULLP(lst) ? SCM_TRUE : SCM_FALSE;
}
-ScmObj ScmOp_SRFI1_listequal(ScmObj eqproc, ScmObj args)
+ScmObj
+scm_p_srfi1_listequal(ScmObj eqproc, ScmObj args)
{
ScmObj first_lst = SCM_FALSE;
- DECLARE_FUNCTION("list=", ProcedureVariadic1);
+ DECLARE_FUNCTION("list=", procedure_variadic_1);
if (NULLP(args))
return SCM_TRUE;
@@ -330,7 +344,7 @@
static ScmObj compare_list(ScmObj eqproc, ScmObj lst1, ScmObj lst2)
{
#define CHECK_LIST_EQUALITY_WITH_EQPROC(eqproc, obj1, obj2) \
- (Scm_call(eqproc, \
+ (scm_call(eqproc, \
LIST_2(obj1, obj2)))
ScmObj ret_cmp = SCM_FALSE;
@@ -353,80 +367,92 @@
return SCM_TRUE;
}
-ScmObj ScmOp_SRFI1_first(ScmObj lst)
+ScmObj
+scm_p_srfi1_first(ScmObj lst)
{
- DECLARE_FUNCTION("first", ProcedureFixed1);
- return ScmOp_car(lst);
+ DECLARE_FUNCTION("first", procedure_fixed_1);
+ return scm_p_car(lst);
}
-ScmObj ScmOp_SRFI1_second(ScmObj lst)
+ScmObj
+scm_p_srfi1_second(ScmObj lst)
{
- DECLARE_FUNCTION("second", ProcedureFixed1);
- return ScmOp_cadr(lst);
+ DECLARE_FUNCTION("second", procedure_fixed_1);
+ return scm_p_cadr(lst);
}
-ScmObj ScmOp_SRFI1_third(ScmObj lst)
+ScmObj
+scm_p_srfi1_third(ScmObj lst)
{
- DECLARE_FUNCTION("third", ProcedureFixed1);
- return ScmOp_caddr(lst);
+ DECLARE_FUNCTION("third", procedure_fixed_1);
+ return scm_p_caddr(lst);
}
-ScmObj ScmOp_SRFI1_fourth(ScmObj lst)
+ScmObj
+scm_p_srfi1_fourth(ScmObj lst)
{
- DECLARE_FUNCTION("fourth", ProcedureFixed1);
- return ScmOp_cadddr(lst);
+ DECLARE_FUNCTION("fourth", procedure_fixed_1);
+ return scm_p_cadddr(lst);
}
-ScmObj ScmOp_SRFI1_fifth(ScmObj lst)
+ScmObj
+scm_p_srfi1_fifth(ScmObj lst)
{
- DECLARE_FUNCTION("fifth", ProcedureFixed1);
- return ScmOp_car(ScmOp_cddddr(lst));
+ DECLARE_FUNCTION("fifth", procedure_fixed_1);
+ return scm_p_car(scm_p_cddddr(lst));
}
-ScmObj ScmOp_SRFI1_sixth(ScmObj lst)
+ScmObj
+scm_p_srfi1_sixth(ScmObj lst)
{
- DECLARE_FUNCTION("sixth", ProcedureFixed1);
- return ScmOp_cadr(ScmOp_cddddr(lst));
+ DECLARE_FUNCTION("sixth", procedure_fixed_1);
+ return scm_p_cadr(scm_p_cddddr(lst));
}
-ScmObj ScmOp_SRFI1_seventh(ScmObj lst)
+ScmObj
+scm_p_srfi1_seventh(ScmObj lst)
{
- DECLARE_FUNCTION("seventh", ProcedureFixed1);
- return ScmOp_caddr(ScmOp_cddddr(lst));
+ DECLARE_FUNCTION("seventh", procedure_fixed_1);
+ return scm_p_caddr(scm_p_cddddr(lst));
}
-ScmObj ScmOp_SRFI1_eighth(ScmObj lst)
+ScmObj
+scm_p_srfi1_eighth(ScmObj lst)
{
- DECLARE_FUNCTION("eighth", ProcedureFixed1);
- return ScmOp_cadddr(ScmOp_cddddr(lst));
+ DECLARE_FUNCTION("eighth", procedure_fixed_1);
+ return scm_p_cadddr(scm_p_cddddr(lst));
}
-ScmObj ScmOp_SRFI1_ninth(ScmObj lst)
+ScmObj
+scm_p_srfi1_ninth(ScmObj lst)
{
- DECLARE_FUNCTION("ninth", ProcedureFixed1);
- return ScmOp_car(ScmOp_cddddr(ScmOp_cddddr(lst)));
+ DECLARE_FUNCTION("ninth", procedure_fixed_1);
+ return scm_p_car(scm_p_cddddr(scm_p_cddddr(lst)));
}
-ScmObj ScmOp_SRFI1_tenth(ScmObj lst)
+ScmObj
+scm_p_srfi1_tenth(ScmObj lst)
{
- DECLARE_FUNCTION("tenth", ProcedureFixed1);
- return ScmOp_cadr(ScmOp_cddddr(ScmOp_cddddr(lst)));
+ DECLARE_FUNCTION("tenth", procedure_fixed_1);
+ return scm_p_cadr(scm_p_cddddr(scm_p_cddddr(lst)));
}
-ScmObj ScmOp_SRFI1_carpluscdr(ScmObj lst)
+ScmObj
+scm_p_srfi1_carpluscdr(ScmObj lst)
{
- DECLARE_FUNCTION("car+cdr", ProcedureFixed1);
- return ScmOp_values(LIST_2(CAR(lst), CDR(lst)));
+ DECLARE_FUNCTION("car+cdr", procedure_fixed_1);
+ return scm_p_values(LIST_2(CAR(lst), CDR(lst)));
}
-ScmObj ScmOp_SRFI1_take(ScmObj lst, ScmObj scm_idx)
+ScmObj
+scm_p_srfi1_take(ScmObj lst, ScmObj scm_idx)
{
ScmObj tmp = lst;
ScmObj ret = SCM_FALSE;
ScmObj ret_tail = SCM_FALSE;
int idx = 0;
int i;
- DECLARE_FUNCTION("take", ProcedureFixed2);
+ DECLARE_FUNCTION("take", procedure_fixed_2);
ASSERT_INTP(scm_idx);
@@ -449,12 +475,13 @@
return ret;
}
-ScmObj ScmOp_SRFI1_drop(ScmObj lst, ScmObj scm_idx)
+ScmObj
+scm_p_srfi1_drop(ScmObj lst, ScmObj scm_idx)
{
ScmObj ret = lst;
int idx = 0;
int i;
- DECLARE_FUNCTION("drop", ProcedureFixed2);
+ DECLARE_FUNCTION("drop", procedure_fixed_2);
ASSERT_INTP(scm_idx);
@@ -469,11 +496,12 @@
return ret;
}
-ScmObj ScmOp_SRFI1_take_right(ScmObj lst, ScmObj scm_elem)
+ScmObj
+scm_p_srfi1_take_right(ScmObj lst, ScmObj scm_elem)
{
ScmObj tmp = lst;
int len = 0;
- DECLARE_FUNCTION("take-right", ProcedureFixed2);
+ DECLARE_FUNCTION("take-right", procedure_fixed_2);
ASSERT_INTP(scm_elem);
@@ -482,14 +510,15 @@
len -= SCM_INT_VALUE(scm_elem);
- return ScmOp_SRFI1_drop(lst, Scm_NewInt(len));
+ return scm_p_srfi1_drop(lst, scm_make_int(len));
}
-ScmObj ScmOp_SRFI1_drop_right(ScmObj lst, ScmObj scm_elem)
+ScmObj
+scm_p_srfi1_drop_right(ScmObj lst, ScmObj scm_elem)
{
ScmObj tmp = lst;
int len = 0;
- DECLARE_FUNCTION("drop-right", ProcedureFixed2);
+ DECLARE_FUNCTION("drop-right", procedure_fixed_2);
ASSERT_INTP(scm_elem);
@@ -498,15 +527,16 @@
len -= SCM_INT_VALUE(scm_elem);
- return ScmOp_SRFI1_take(lst, Scm_NewInt(len));
+ return scm_p_srfi1_take(lst, scm_make_int(len));
}
-ScmObj ScmOp_SRFI1_taked(ScmObj lst, ScmObj scm_idx)
+ScmObj
+scm_p_srfi1_taked(ScmObj lst, ScmObj scm_idx)
{
ScmObj tmp = lst;
int idx = 0;
int i;
- DECLARE_FUNCTION("take!", ProcedureFixed2);
+ DECLARE_FUNCTION("take!", procedure_fixed_2);
ASSERT_INTP(scm_idx);
@@ -521,12 +551,13 @@
return lst;
}
-ScmObj ScmOp_SRFI1_drop_rightd(ScmObj lst, ScmObj scm_idx)
+ScmObj
+scm_p_srfi1_drop_rightd(ScmObj lst, ScmObj scm_idx)
{
ScmObj tmp = lst;
int len = 0;
int i;
- DECLARE_FUNCTION("drop-right!", ProcedureFixed2);
+ DECLARE_FUNCTION("drop-right!", procedure_fixed_2);
ASSERT_INTP(scm_idx);
@@ -545,37 +576,41 @@
return lst;
}
-ScmObj ScmOp_SRFI1_split_at(ScmObj lst, ScmObj idx)
+ScmObj
+scm_p_srfi1_split_at(ScmObj lst, ScmObj idx)
{
- DECLARE_FUNCTION("split-at", ProcedureFixed2);
+ DECLARE_FUNCTION("split-at", procedure_fixed_2);
- return ScmOp_values(LIST_2(ScmOp_SRFI1_take(lst, idx),
- ScmOp_SRFI1_drop(lst, idx)));
+ return scm_p_values(LIST_2(scm_p_srfi1_take(lst, idx),
+ scm_p_srfi1_drop(lst, idx)));
}
-ScmObj ScmOp_SRFI1_split_atd(ScmObj lst, ScmObj idx)
+ScmObj
+scm_p_srfi1_split_atd(ScmObj lst, ScmObj idx)
{
- ScmObj drop = ScmOp_SRFI1_drop(lst, idx);
- DECLARE_FUNCTION("split-at!", ProcedureFixed2);
+ ScmObj drop = scm_p_srfi1_drop(lst, idx);
+ DECLARE_FUNCTION("split-at!", procedure_fixed_2);
- return ScmOp_values(LIST_2(ScmOp_SRFI1_taked(lst, idx),
+ return scm_p_values(LIST_2(scm_p_srfi1_taked(lst, idx),
drop));
}
-ScmObj ScmOp_SRFI1_last(ScmObj lst)
+ScmObj
+scm_p_srfi1_last(ScmObj lst)
{
- DECLARE_FUNCTION("last", ProcedureFixed1);
+ DECLARE_FUNCTION("last", procedure_fixed_1);
/* sanity check */
if (NULLP(lst))
ERR_OBJ("non-empty, proper list is required but got", lst);
- return CAR(ScmOp_SRFI1_last_pair(lst));
+ return CAR(scm_p_srfi1_last_pair(lst));
}
-ScmObj ScmOp_SRFI1_last_pair(ScmObj lst)
+ScmObj
+scm_p_srfi1_last_pair(ScmObj lst)
{
- DECLARE_FUNCTION("last-pair", ProcedureFixed1);
+ DECLARE_FUNCTION("last-pair", procedure_fixed_1);
/* sanity check */
if (NULLP(lst))
@@ -590,26 +625,28 @@
/*==============================================================================
SRFI1 : The procedures : Miscellaneous
==============================================================================*/
-ScmObj ScmOp_SRFI1_lengthplus(ScmObj lst)
+ScmObj
+scm_p_srfi1_lengthplus(ScmObj lst)
{
- DECLARE_FUNCTION("length+", ProcedureFixed1);
+ DECLARE_FUNCTION("length+", procedure_fixed_1);
/* FIXME!: remove expensive circular_listp */
- if (NFALSEP(ScmOp_SRFI1_circular_listp(lst)))
+ if (NFALSEP(scm_p_srfi1_circular_listp(lst)))
return SCM_FALSE;
- return ScmOp_length(lst);
+ return scm_p_length(lst);
}
-ScmObj ScmOp_SRFI1_concatenate(ScmObj args)
+ScmObj
+scm_p_srfi1_concatenate(ScmObj args)
{
ScmObj lsts_of_lst = CAR(args);
- DECLARE_FUNCTION("concatenate", ProcedureVariadic0);
+ DECLARE_FUNCTION("concatenate", procedure_variadic_0);
#if SCM_STRICT_ARGCHECK
if (!NULLP(CDR(args)))
ERR_OBJ("superfluous arguments", args);
#endif
- return ScmOp_append(lsts_of_lst);
+ return scm_p_append(lsts_of_lst);
}
Modified: branches/r5rs/sigscheme/operations-srfi2.c
===================================================================
--- branches/r5rs/sigscheme/operations-srfi2.c 2005-12-16 08:29:32 UTC (rev 2609)
+++ branches/r5rs/sigscheme/operations-srfi2.c 2005-12-16 09:06:42 UTC (rev 2610)
@@ -61,7 +61,8 @@
/*=======================================
Function Implementations
=======================================*/
-void SigScm_Initialize_SRFI2(void)
+void
+scm_initialize_srfi2(void)
{
/*=======================================================================
SRFI-2 Procedure
@@ -69,14 +70,15 @@
REGISTER_FUNC_TABLE(srfi2_func_info_table);
}
-ScmObj ScmExp_SRFI2_and_letstar(ScmObj claws, ScmObj body, ScmEvalState *eval_state)
+ScmObj
+scm_s_srfi2_and_letstar(ScmObj claws, ScmObj body, ScmEvalState *eval_state)
{
ScmObj env = eval_state->env;
ScmObj claw = SCM_FALSE;
ScmObj var = SCM_FALSE;
ScmObj val = SCM_FALSE;
ScmObj exp = SCM_FALSE;
- DECLARE_FUNCTION("and-let*", SyntaxVariadicTailRec1);
+ DECLARE_FUNCTION("and-let*", syntax_variadic_tailrec_1);
/*========================================================================
(and-let* <claws> <body>)
@@ -100,7 +102,7 @@
var = CAR(claw);
exp = CADR(claw);
val = EVAL(exp, env);
- env = Scm_ExtendEnvironment(LIST_1(var), LIST_1(val), env);
+ env = scm_extend_environment(LIST_1(var), LIST_1(val), env);
} else {
goto err;
}
@@ -114,14 +116,14 @@
return SCM_FALSE;
}
} else if (NULLP(claws)) {
- env = Scm_ExtendEnvironment(SCM_NULL, SCM_NULL, env);
+ env = scm_extend_environment(SCM_NULL, SCM_NULL, env);
} else {
goto err;
}
eval_state->env = env;
- return ScmExp_begin(body, eval_state);
+ return scm_s_begin(body, eval_state);
err:
ERR_OBJ("invalid claws form", claws);
Modified: branches/r5rs/sigscheme/operations-srfi23.c
===================================================================
--- branches/r5rs/sigscheme/operations-srfi23.c 2005-12-16 08:29:32 UTC (rev 2609)
+++ branches/r5rs/sigscheme/operations-srfi23.c 2005-12-16 09:06:42 UTC (rev 2610)
@@ -60,7 +60,8 @@
/*=======================================
Function Implementations
=======================================*/
-void SigScm_Initialize_SRFI23(void)
+void
+scm_initialize_srfi23(void)
{
/*=======================================================================
SRFI-23 Procedure
@@ -84,10 +85,11 @@
* error object to an exception handler. The default exception handler then
* might do something as described in points 1 to 3.
*/
-ScmObj ScmOp_SRFI23_error(ScmObj reason, ScmObj args)
+ScmObj
+scm_p_srfi23_error(ScmObj reason, ScmObj args)
{
ScmObj err_obj;
- DECLARE_FUNCTION("error", ProcedureVariadic1);
+ DECLARE_FUNCTION("error", procedure_variadic_1);
#if 0
/*
* Although SRFI-23 specified that "The argument <reason> should be a
@@ -96,8 +98,8 @@
ASSERT_STRINGP(reason);
#endif
- err_obj = Scm_MakeErrorObj(reason, args);
- Scm_RaiseError(err_obj);
+ err_obj = scm_make_error_obj(reason, args);
+ scm_raise_error(err_obj);
/* NOTREACHED */
return SCM_UNDEF;
}
Modified: branches/r5rs/sigscheme/operations-srfi34.c
===================================================================
--- branches/r5rs/sigscheme/operations-srfi34.c 2005-12-16 08:29:32 UTC (rev 2609)
+++ branches/r5rs/sigscheme/operations-srfi34.c 2005-12-16 09:06:42 UTC (rev 2610)
@@ -61,7 +61,7 @@
#define ERRMSG_HANDLER_RETURNED "handler returned"
#define ERRMSG_FALLBACK_EXHAUSTED "fallback handler exhausted"
-#define MAKE_STR_COPYING Scm_NewImmutableStringCopying
+#define MAKE_STR_COPYING scm_make_immutable_string_copying
#define DECLARE_PRIVATE_FUNCTION(func_name, type) \
DECLARE_INTERNAL_FUNCTION(func_name)
@@ -119,56 +119,57 @@
/*=======================================
Function Implementations
=======================================*/
-void SigScm_Initialize_SRFI34(void)
+void
+scm_initialize_srfi34(void)
{
ScmObj *const *var;
- Scm_Use("srfi-23");
+ scm_use("srfi-23");
/* protect global variables */
for (var = &global_var_list[0]; *var; var++) {
**var = SCM_FALSE;
- SigScm_GC_Protect(*var);
+ scm_gc_protect(*var);
}
errmsg_unhandled_exception = MAKE_STR_COPYING(ERRMSG_UNHANDLED_EXCEPTION);
errmsg_handler_returned = MAKE_STR_COPYING(ERRMSG_HANDLER_RETURNED);
errmsg_fallback_exhausted = MAKE_STR_COPYING(ERRMSG_FALLBACK_EXHAUSTED);
- sym_error = Scm_Intern("error");
- sym_raise = Scm_Intern("raise");
+ sym_error = scm_intern("error");
+ sym_raise = scm_intern("raise");
- sym_lex_env = Scm_Intern("lex-env");
- sym_cond_catch = Scm_Intern("cond-catch");
- sym_body = Scm_Intern("body");
- sym_condition = Scm_Intern("condition");
- sym_guard_k = Scm_Intern("guard-k");
- sym_handler_k = Scm_Intern("handler-k");
+ sym_lex_env = scm_intern("lex-env");
+ sym_cond_catch = scm_intern("cond-catch");
+ sym_body = scm_intern("body");
+ sym_condition = scm_intern("condition");
+ sym_guard_k = scm_intern("guard-k");
+ sym_handler_k = scm_intern("handler-k");
/* prepare procedures and syntaxes */
- syn_apply = Scm_SymbolValue(Scm_Intern("apply"), SCM_INTERACTION_ENV);
- proc_values = Scm_SymbolValue(Scm_Intern("values"), SCM_INTERACTION_ENV);
+ syn_apply = scm_symbol_value(scm_intern("apply"), SCM_INTERACTION_ENV);
+ proc_values = scm_symbol_value(scm_intern("values"), SCM_INTERACTION_ENV);
/* FIXME: make registration type-safe */
- syn_set_cur_handlers = Scm_NewFunc(SCM_SYNTAX_FIXED | 1,
+ syn_set_cur_handlers = scm_make_func(SCM_SYNTAX_FIXED | 1,
&set_cur_handlers);
- proc_with_exception_handlers = Scm_NewFunc(SCM_PROCEDURE_FIXED | 2,
+ proc_with_exception_handlers = scm_make_func(SCM_PROCEDURE_FIXED | 2,
&with_exception_handlers);
- syn_guard_internal = Scm_NewFunc(SCM_SYNTAX_FIXED | 1,
+ syn_guard_internal = scm_make_func(SCM_SYNTAX_FIXED | 1,
&guard_internal);
- syn_guard_handler = Scm_NewFunc(SCM_SYNTAX_FIXED_TAIL_REC | 1,
+ syn_guard_handler = scm_make_func(SCM_SYNTAX_FIXED_TAIL_REC | 1,
&guard_handler);
- syn_guard_handler_body = Scm_NewFunc(SCM_SYNTAX_FIXED | 1,
+ syn_guard_handler_body = scm_make_func(SCM_SYNTAX_FIXED | 1,
&guard_handler_body);
- syn_guard_body = Scm_NewFunc(SCM_SYNTAX_FIXED_TAIL_REC | 0,
+ syn_guard_body = scm_make_func(SCM_SYNTAX_FIXED_TAIL_REC | 0,
&guard_body);
#if USE_WITH_SIGSCHEME_FATAL_ERROR
proc_fallback_handler
- = ScmExp_lambda(LIST_1(sym_condition),
- LIST_1(LIST_4(Scm_Intern("if"),
- LIST_2(Scm_Intern("%%error-object?"),
+ = scm_s_lambda(LIST_1(sym_condition),
+ LIST_1(LIST_4(scm_intern("if"),
+ LIST_2(scm_intern("%%error-object?"),
sym_condition),
- LIST_2(Scm_Intern("%%fatal-error"),
+ LIST_2(scm_intern("%%fatal-error"),
sym_condition),
LIST_3(sym_error,
errmsg_unhandled_exception,
@@ -177,11 +178,11 @@
#else /* USE_WITH_SIGSCHEME_FATAL_ERROR */
/*
* The 'error' procedure should not be invoked directly by
- * ScmOp_SRFI23_error(), to allow dynamic redifinition, and keep SRFI-23
+ * scm_p_srfi23_error(), to allow dynamic redifinition, and keep SRFI-23
* implementation abstract.
*/
proc_fallback_handler
- = ScmExp_lambda(LIST_1(sym_condition),
+ = scm_s_lambda(LIST_1(sym_condition),
LIST_1(LIST_3(sym_error,
errmsg_unhandled_exception,
sym_condition)),
@@ -207,21 +208,22 @@
DECLARE_PRIVATE_FUNCTION("with_exception_handlers", ProcedureFixed2);
prev_handlers = current_exception_handlers;
- before = ScmExp_lambda(SCM_NULL,
+ before = scm_s_lambda(SCM_NULL,
LIST_1(LIST_2(syn_set_cur_handlers, new_handlers)),
SCM_INTERACTION_ENV);
- after = ScmExp_lambda(SCM_NULL,
+ after = scm_s_lambda(SCM_NULL,
LIST_1(LIST_2(syn_set_cur_handlers, prev_handlers)),
SCM_INTERACTION_ENV);
- return Scm_DynamicWind(before, thunk, after);
+ return scm_dynamic_wind(before, thunk, after);
}
/* with-exception-handler */
-ScmObj ScmOp_SRFI34_with_exception_handler(ScmObj handler, ScmObj thunk)
+ScmObj
+scm_p_srfi34_with_exception_handler(ScmObj handler, ScmObj thunk)
{
ScmObj handlers;
- DECLARE_FUNCTION("with-exception-handler", ProcedureFixed2);
+ DECLARE_FUNCTION("with-exception-handler", procedure_fixed_2);
ASSERT_PROCEDUREP(handler);
ASSERT_PROCEDUREP(thunk);
@@ -232,24 +234,25 @@
/* raise */
-ScmObj ScmOp_SRFI34_raise(ScmObj obj)
+ScmObj
+scm_p_srfi34_raise(ScmObj obj)
{
ScmObj handler, rest_handlers, thunk, err_obj;
- DECLARE_FUNCTION("raise", ProcedureFixed1);
+ DECLARE_FUNCTION("raise", procedure_fixed_1);
if (NULLP(current_exception_handlers)) {
if (ERROBJP(obj))
err_obj = obj;
else
- err_obj = Scm_MakeErrorObj(errmsg_fallback_exhausted, LIST_1(obj));
- ScmOp_fatal_error(err_obj);
+ err_obj = scm_make_error_obj(errmsg_fallback_exhausted, LIST_1(obj));
+ scm_p_fatal_error(err_obj);
/* NOTREACHED */
}
handler = CAR(current_exception_handlers);
rest_handlers = CDR(current_exception_handlers);
obj = LIST_2(SYM_QUOTE, obj);
- thunk = ScmExp_lambda(SCM_NULL,
+ thunk = scm_s_lambda(SCM_NULL,
LIST_2(LIST_2(handler, obj),
LIST_3(sym_error,
errmsg_handler_returned, obj)),
@@ -259,28 +262,28 @@
/* guard */
-ScmObj ScmExp_SRFI34_guard(ScmObj cond_catch, ScmObj body,
+ScmObj scm_s_srfi34_guard(ScmObj cond_catch, ScmObj body,
ScmEvalState *eval_state)
{
ScmObj lex_env, proc_guard_int, ret;
- DECLARE_FUNCTION("guard", SyntaxVariadicTailRec1);
+ DECLARE_FUNCTION("guard", syntax_variadic_tailrec_1);
ASSERT_CONSP(cond_catch);
ASSERT_CONSP(body);
lex_env = eval_state->env;
eval_state->env
- = Scm_ExtendEnvironment(LIST_3(sym_lex_env, sym_cond_catch, sym_body),
+ = scm_extend_environment(LIST_3(sym_lex_env, sym_cond_catch, sym_body),
LIST_3(lex_env, cond_catch, body),
lex_env);
- proc_guard_int = ScmExp_lambda(LIST_1(sym_guard_k),
+ proc_guard_int = scm_s_lambda(LIST_1(sym_guard_k),
LIST_1(LIST_2(syn_guard_internal, sym_guard_k)),
eval_state->env);
- ret = Scm_CallWithCurrentContinuation(proc_guard_int, eval_state);
+ ret = scm_call_with_current_continuation(proc_guard_int, eval_state);
eval_state->env = lex_env;
eval_state->ret_type = SCM_RETTYPE_AS_IS;
- return Scm_call(ret, SCM_NULL);
+ return scm_call(ret, SCM_NULL);
}
static ScmObj guard_internal(ScmObj q_guard_k, ScmObj env)
@@ -288,14 +291,14 @@
ScmObj handler, body;
DECLARE_PRIVATE_FUNCTION("guard", SyntaxFixed1);
- handler = ScmExp_lambda(LIST_1(sym_condition),
+ handler = scm_s_lambda(LIST_1(sym_condition),
LIST_1(LIST_2(syn_guard_handler, sym_condition)),
env);
- body = ScmExp_lambda(SCM_NULL,
+ body = scm_s_lambda(SCM_NULL,
LIST_1(LIST_1(syn_guard_body)),
env);
- return ScmOp_SRFI34_with_exception_handler(handler, body);
+ return scm_p_srfi34_with_exception_handler(handler, body);
}
static ScmObj guard_handler(ScmObj q_condition, ScmEvalState *eval_state)
@@ -304,33 +307,33 @@
DECLARE_PRIVATE_FUNCTION("guard", SyntaxFixedTailRec1);
handler_body
- = ScmExp_lambda(LIST_1(sym_handler_k),
+ = scm_s_lambda(LIST_1(sym_handler_k),
LIST_1(LIST_2(syn_guard_handler_body, sym_handler_k)),
eval_state->env);
- ret = Scm_CallWithCurrentContinuation(handler_body, eval_state);
+ ret = scm_call_with_current_continuation(handler_body, eval_state);
if (eval_state->ret_type == SCM_RETTYPE_NEED_EVAL) {
ret = EVAL(ret, eval_state->env);
eval_state->ret_type = SCM_RETTYPE_AS_IS;
}
- return Scm_call(ret, SCM_NULL);
+ return scm_call(ret, SCM_NULL);
}
-/* assumes that ScmExp_delay() returns a closure */
+/* assumes that scm_s_delay() returns a closure */
static ScmObj delay(ScmObj evaled_obj, ScmObj env)
{
ScmObj vals;
if (VALUEPACKETP(evaled_obj)) {
vals = SCM_VALUEPACKET_VALUES(evaled_obj);
- return ScmExp_delay(LIST_3(syn_apply,
+ return scm_s_delay(LIST_3(syn_apply,
proc_values, LIST_2(SYM_QUOTE, vals)),
env);
} else {
- return ScmExp_delay(LIST_2(SYM_QUOTE, evaled_obj), env);
+ return scm_s_delay(LIST_2(SYM_QUOTE, evaled_obj), env);
}
}
-/* assumes that ScmExp_delay() returns a closure */
+/* assumes that scm_s_delay() returns a closure */
static ScmObj guard_handler_body(ScmObj q_handler_k, ScmObj env)
{
ScmEvalState eval_state;
@@ -338,31 +341,31 @@
ScmObj sym_var, clauses, caught, reraise;
DECLARE_PRIVATE_FUNCTION("guard", SyntaxFixed1);
- lex_env = Scm_SymbolValue(sym_lex_env, env);
- condition = Scm_SymbolValue(sym_condition, env);
- cond_catch = Scm_SymbolValue(sym_cond_catch, env);
- guard_k = Scm_SymbolValue(sym_guard_k, env);
+ lex_env = scm_symbol_value(sym_lex_env, env);
+ condition = scm_symbol_value(sym_condition, env);
+ cond_catch = scm_symbol_value(sym_cond_catch, env);
+ guard_k = scm_symbol_value(sym_guard_k, env);
handler_k = EVAL(q_handler_k, env);
/* eval cond-catch block */
sym_var = CAR(cond_catch);
clauses = CDR(cond_catch);
ASSERT_SYMBOLP(sym_var);
- cond_env = Scm_ExtendEnvironment(LIST_1(sym_var),
+ cond_env = scm_extend_environment(LIST_1(sym_var),
LIST_1(condition),
lex_env);
eval_state.env = cond_env;
eval_state.ret_type = SCM_RETTYPE_NEED_EVAL;
- caught = ScmExp_cond_internal(clauses, SCM_INVALID, &eval_state);
+ caught = scm_s_cond_internal(clauses, SCM_INVALID, &eval_state);
if (VALIDP(caught)) {
if (eval_state.ret_type == SCM_RETTYPE_NEED_EVAL)
caught = EVAL(caught, cond_env);
- Scm_CallContinuation(guard_k, delay(caught, cond_env));
+ scm_call_continuation(guard_k, delay(caught, cond_env));
} else {
- reraise = ScmExp_delay(LIST_2(sym_raise, LIST_2(SYM_QUOTE, condition)),
+ reraise = scm_s_delay(LIST_2(sym_raise, LIST_2(SYM_QUOTE, condition)),
cond_env);
- Scm_CallContinuation(handler_k, reraise);
+ scm_call_continuation(handler_k, reraise);
}
/* NOTREACHED */
return SCM_UNDEF;
@@ -374,18 +377,18 @@
ScmObj lex_env, guard_k, body, result;
DECLARE_PRIVATE_FUNCTION("guard", SyntaxFixedTailRec0);
- lex_env = Scm_SymbolValue(sym_lex_env, eval_state->env);
- guard_k = Scm_SymbolValue(sym_guard_k, eval_state->env);
- body = Scm_SymbolValue(sym_body, eval_state->env);
+ lex_env = scm_symbol_value(sym_lex_env, eval_state->env);
+ guard_k = scm_symbol_value(sym_guard_k, eval_state->env);
+ body = scm_symbol_value(sym_body, eval_state->env);
/* evaluate the body */
lex_eval_state.env = lex_env;
lex_eval_state.ret_type = SCM_RETTYPE_NEED_EVAL;
- result = ScmExp_begin(body, &lex_eval_state); /* always NEED_EVAL */
+ result = scm_s_begin(body, &lex_eval_state); /* always NEED_EVAL */
result = EVAL(result, lex_env);
eval_state->ret_type = SCM_RETTYPE_AS_IS;
- Scm_CallContinuation(guard_k, delay(result, lex_env));
+ scm_call_continuation(guard_k, delay(result, lex_env));
/* NOTREACHED */
return SCM_UNDEF;
}
Modified: branches/r5rs/sigscheme/operations-srfi38.c
===================================================================
--- branches/r5rs/sigscheme/operations-srfi38.c 2005-12-16 08:29:32 UTC (rev 2609)
+++ branches/r5rs/sigscheme/operations-srfi38.c 2005-12-16 09:06:42 UTC (rev 2610)
@@ -59,29 +59,31 @@
/*=======================================
Function Implementations
=======================================*/
-void SigScm_Initialize_SRFI38(void)
+void
+scm_initialize_srfi38(void)
{
REGISTER_FUNC_TABLE(srfi38_func_info_table);
/* SRFI-38 allows providing (read/ss) and (write/ss) */
- Scm_DefineAlias("write/ss", "write-with-shared-structure");
+ scm_define_alias("write/ss", "write-with-shared-structure");
- Scm_writess_func = SigScm_WriteToPortWithSharedStructure;
+ scm_writess_func = scm_write_to_port_with_shared_structure;
}
/*=============================================================================
SRFI38 : External Representation for Data With Shared Structure
=============================================================================*/
-ScmObj ScmOp_SRFI38_write_with_shared_structure(ScmObj obj, ScmObj args)
+ScmObj
+scm_p_srfi38_write_with_shared_structure(ScmObj obj, ScmObj args)
{
ScmObj port = scm_current_output_port;
- DECLARE_FUNCTION("write-with-shared-structure", ProcedureVariadic1);
+ DECLARE_FUNCTION("write-with-shared-structure", procedure_variadic_1);
/* get port */
port = scm_current_output_port;
if (!NULLP(args) && PORTP(CAR(args)))
port = CAR(args);
- SigScm_WriteToPortWithSharedStructure(port, obj);
+ scm_write_to_port_with_shared_structure(port, obj);
return SCM_UNDEF;
}
Modified: branches/r5rs/sigscheme/operations-srfi6.c
===================================================================
--- branches/r5rs/sigscheme/operations-srfi6.c 2005-12-16 08:29:32 UTC (rev 2609)
+++ branches/r5rs/sigscheme/operations-srfi6.c 2005-12-16 09:06:42 UTC (rev 2610)
@@ -64,9 +64,10 @@
/*=======================================
Function Implementations
=======================================*/
-void SigScm_Initialize_SRFI6(void)
+void
+scm_initialize_srfi6(void)
{
- Scm_strport_init();
+ scm_strport_init();
/*=======================================================================
SRFI-6 Procedures
@@ -76,44 +77,47 @@
static void istrport_finalize(char **str, int ownership, void **opaque)
{
- SigScm_GC_Unprotect((ScmObj *)opaque);
+ scm_gc_unprotect((ScmObj *)opaque);
}
-ScmObj ScmOp_SRFI6_open_input_string(ScmObj str)
+ScmObj
+scm_p_srfi6_open_input_string(ScmObj str)
{
ScmObj *hold_str;
ScmBytePort *bport;
- DECLARE_FUNCTION("open-input-string", ProcedureFixed1);
+ DECLARE_FUNCTION("open-input-string", procedure_fixed_1);
ASSERT_STRINGP(str);
bport = ScmInputStrPort_new_const(SCM_STRING_STR(str), istrport_finalize);
hold_str = (ScmObj *)ScmInputStrPort_ref_opaque(bport);
*hold_str = str;
- SigScm_GC_Protect(hold_str);
- return Scm_NewPort(Scm_NewCharPort(bport), SCM_PORTFLAG_INPUT);
+ scm_gc_protect(hold_str);
+ return scm_make_port(scm_make_char_port(bport), SCM_PORTFLAG_INPUT);
}
-ScmObj ScmOp_SRFI6_open_output_string(void)
+ScmObj
+scm_p_srfi6_open_output_string(void)
{
ScmBytePort *bport;
- DECLARE_FUNCTION("open-output-string", ProcedureFixed0);
+ DECLARE_FUNCTION("open-output-string", procedure_fixed_0);
bport = ScmOutputStrPort_new(NULL);
- return Scm_NewPort(Scm_NewCharPort(bport), SCM_PORTFLAG_OUTPUT);
+ return scm_make_port(scm_make_char_port(bport), SCM_PORTFLAG_OUTPUT);
}
-ScmObj ScmOp_SRFI6_get_output_string(ScmObj port)
+ScmObj
+scm_p_srfi6_get_output_string(ScmObj port)
{
ScmBaseCharPort *cport;
- DECLARE_FUNCTION("get-output-string", ProcedureFixed1);
+ DECLARE_FUNCTION("get-output-string", procedure_fixed_1);
ASSERT_PORTP(port);
SCM_ASSERT_LIVE_PORT(port);
cport = SCM_CHARPORT_DYNAMIC_CAST(ScmBaseCharPort, SCM_PORT_IMPL(port));
- return Scm_NewMutableStringCopying(ScmOutputStrPort_str(cport->bport));
+ return scm_make_mutable_string_copying(ScmOutputStrPort_str(cport->bport));
}
Modified: branches/r5rs/sigscheme/operations-srfi60.c
===================================================================
--- branches/r5rs/sigscheme/operations-srfi60.c 2005-12-16 08:29:32 UTC (rev 2609)
+++ branches/r5rs/sigscheme/operations-srfi60.c 2005-12-16 09:06:42 UTC (rev 2610)
@@ -66,7 +66,7 @@
default: \
ERR(opstr ": (internal error) unrecognized state specifier: %d", *state); \
} \
- return Scm_NewInt(result); \
+ return scm_make_int(result); \
} while (/* CONSTCOND */ 0)
/*=======================================
@@ -80,19 +80,20 @@
/*=======================================
Function Implementations
=======================================*/
-void SigScm_Initialize_SRFI60(void)
+void
+scm_initialize_srfi60(void)
{
/*=======================================================================
SRFI-60 Procedures
=======================================================================*/
REGISTER_FUNC_TABLE(srfi60_func_info_table);
- Scm_DefineAlias("bitwise-and" , "logand");
- Scm_DefineAlias("bitwise-ior" , "logior");
- Scm_DefineAlias("bitwise-xor" , "logxor");
- Scm_DefineAlias("bitwise-not" , "lognot");
- Scm_DefineAlias("bitwise-merge" , "bitwise-if");
- Scm_DefineAlias("any-bits-set?" , "logtest");
+ scm_define_alias("bitwise-and" , "logand");
+ scm_define_alias("bitwise-ior" , "logior");
+ scm_define_alias("bitwise-xor" , "logxor");
+ scm_define_alias("bitwise-not" , "lognot");
+ scm_define_alias("bitwise-merge" , "bitwise-if");
+ scm_define_alias("any-bits-set?" , "logtest");
}
/*=============================================================================
@@ -100,40 +101,42 @@
=============================================================================*/
/* Bitwise Operations */
-ScmObj ScmOp_SRFI60_logand(ScmObj left, ScmObj right,
+ScmObj scm_p_srfi60_logand(ScmObj left, ScmObj right,
enum ScmReductionState *state)
{
- DECLARE_FUNCTION("logand", ReductionOperator);
+ DECLARE_FUNCTION("logand", reduction_operator);
BITWISE_OPERATION_BODY(&, "logand");
}
-ScmObj ScmOp_SRFI60_logior(ScmObj left, ScmObj right,
+ScmObj scm_p_srfi60_logior(ScmObj left, ScmObj right,
enum ScmReductionState *state)
{
- DECLARE_FUNCTION("logior", ReductionOperator);
+ DECLARE_FUNCTION("logior", reduction_operator);
BITWISE_OPERATION_BODY(|, "logior");
}
-ScmObj ScmOp_SRFI60_logxor(ScmObj left, ScmObj right,
+ScmObj scm_p_srfi60_logxor(ScmObj left, ScmObj right,
enum ScmReductionState *state)
{
- DECLARE_FUNCTION("logxor", ReductionOperator);
+ DECLARE_FUNCTION("logxor", reduction_operator);
BITWISE_OPERATION_BODY(^, "logxor");
}
-ScmObj ScmOp_SRFI60_lognot(ScmObj n)
+ScmObj
+scm_p_srfi60_lognot(ScmObj n)
{
- DECLARE_FUNCTION("lognot", ProcedureFixed1);
+ DECLARE_FUNCTION("lognot", procedure_fixed_1);
ASSERT_INTP(n);
- return Scm_NewInt(~SCM_INT_VALUE(n));
+ return scm_make_int(~SCM_INT_VALUE(n));
}
-ScmObj ScmOp_SRFI60_bitwise_if(ScmObj mask, ScmObj n0, ScmObj n1)
+ScmObj
+scm_p_srfi60_bitwise_if(ScmObj mask, ScmObj n0, ScmObj n1)
{
int result, c_mask;
- DECLARE_FUNCTION("bitwise-if", ProcedureFixed3);
+ DECLARE_FUNCTION("bitwise-if", procedure_fixed_3);
ASSERT_INTP(mask);
ASSERT_INTP(n0);
@@ -142,12 +145,13 @@
c_mask = SCM_INT_VALUE(mask);
result = (c_mask & SCM_INT_VALUE(n0)) | (~c_mask & SCM_INT_VALUE(n1));
- return Scm_NewInt(result);
+ return scm_make_int(result);
}
-ScmObj ScmOp_SRFI60_logtest(ScmObj j, ScmObj k)
+ScmObj
+scm_p_srfi60_logtest(ScmObj j, ScmObj k)
{
- DECLARE_FUNCTION("logtest", ProcedureFixed2);
+ DECLARE_FUNCTION("logtest", procedure_fixed_2);
ASSERT_INTP(j);
ASSERT_INTP(k);
Modified: branches/r5rs/sigscheme/operations-srfi8.c
===================================================================
--- branches/r5rs/sigscheme/operations-srfi8.c 2005-12-16 08:29:32 UTC (rev 2609)
+++ branches/r5rs/sigscheme/operations-srfi8.c 2005-12-16 09:06:42 UTC (rev 2610)
@@ -60,7 +60,8 @@
/*=======================================
Function Implementations
=======================================*/
-void SigScm_Initialize_SRFI8(void)
+void
+scm_initialize_srfi8(void)
{
/*=======================================================================
SRFI-8 Procedure
@@ -71,14 +72,15 @@
/*=============================================================================
SRFI8 : Receive
=============================================================================*/
-ScmObj ScmExp_SRFI8_receive(ScmObj formals, ScmObj expr, ScmObj body, ScmEvalState *eval_state)
+ScmObj
+scm_s_srfi8_receive(ScmObj formals, ScmObj expr, ScmObj body, ScmEvalState *eval_state)
{
/*
* (receive <formals> <expression> <body>)
*/
ScmObj env = eval_state->env;
ScmObj actuals = SCM_FALSE;
- DECLARE_FUNCTION("receive", SyntaxVariadicTailRec2);
+ DECLARE_FUNCTION("receive", syntax_variadic_tailrec_2);
if (!(CONSP(formals) || NULLP(formals) || SYMBOLP(formals)))
ERR_OBJ("bad formals", formals);
@@ -92,7 +94,7 @@
else
actuals = CONS(actuals, SCM_NULL);
- eval_state->env = env = Scm_ExtendEnvironment(formals, actuals, env);
+ eval_state->env = env = scm_extend_environment(formals, actuals, env);
- return ScmExp_begin(body, eval_state);
+ return scm_s_begin(body, eval_state);
}
Modified: branches/r5rs/sigscheme/operations.c
===================================================================
--- branches/r5rs/sigscheme/operations.c 2005-12-16 08:29:32 UTC (rev 2609)
+++ branches/r5rs/sigscheme/operations.c 2005-12-16 09:06:42 UTC (rev 2610)
@@ -60,7 +60,7 @@
/*=======================================
File Local Function Declarations
=======================================*/
-static ScmObj ScmOp_listtail_internal(ScmObj obj, int k);
+static ScmObj scm_p_listtail_internal(ScmObj obj, int k);
static ScmObj map_single_arg(ScmObj proc, ScmObj args);
static ScmObj map_multiple_args(ScmObj proc, ScmObj args);
@@ -71,10 +71,11 @@
/*==============================================================================
R5RS : 6.1 Equivalence predicates
==============================================================================*/
-ScmObj ScmOp_eqvp(ScmObj obj1, ScmObj obj2)
+ScmObj
+scm_p_eqvp(ScmObj obj1, ScmObj obj2)
{
enum ScmObjType type;
- DECLARE_FUNCTION("eqv?", ProcedureFixed2);
+ DECLARE_FUNCTION("eqv?", procedure_fixed_2);
if (EQ(obj1, obj2))
return SCM_TRUE;
@@ -93,7 +94,7 @@
break;
case ScmChar:
- return ScmOp_charequalp(obj1, obj2);
+ return scm_p_charequalp(obj1, obj2);
#if SCM_DEBUG
case ScmFreeCell:
@@ -108,19 +109,21 @@
return SCM_FALSE;
}
-ScmObj ScmOp_eqp(ScmObj obj1, ScmObj obj2)
+ScmObj
+scm_p_eqp(ScmObj obj1, ScmObj obj2)
{
- DECLARE_FUNCTION("eq?", ProcedureFixed2);
+ DECLARE_FUNCTION("eq?", procedure_fixed_2);
return (EQ(obj1, obj2)) ? SCM_TRUE : SCM_FALSE;
}
-ScmObj ScmOp_equalp(ScmObj obj1, ScmObj obj2)
+ScmObj
+scm_p_equalp(ScmObj obj1, ScmObj obj2)
{
enum ScmObjType type;
int i = 0;
ScmObj elm1 = SCM_FALSE;
ScmObj elm2 = SCM_FALSE;
- DECLARE_FUNCTION("equal?", ProcedureFixed2);
+ DECLARE_FUNCTION("equal?", procedure_fixed_2);
if (EQ(obj1, obj2))
return SCM_TRUE;
@@ -139,7 +142,7 @@
break;
case ScmChar:
- return ScmOp_charequalp(obj1, obj2);
+ return scm_p_charequalp(obj1, obj2);
case ScmString:
if (strcmp(SCM_STRING_STR(obj1), SCM_STRING_STR(obj2)) == 0)
@@ -153,11 +156,11 @@
elm2 = CAR(obj2);
if (!EQ(elm1, elm2)
&& (SCM_TYPE(elm1) != SCM_TYPE(elm2)
- || FALSEP(ScmOp_equalp(elm1, elm2))))
+ || FALSEP(scm_p_equalp(elm1, elm2))))
return SCM_FALSE;
}
/* compare last cdr */
- return (EQ(obj1, obj2)) ? SCM_TRUE : ScmOp_equalp(obj1, obj2);
+ return (EQ(obj1, obj2)) ? SCM_TRUE : scm_p_equalp(obj1, obj2);
case ScmVector:
if (SCM_VECTOR_LEN(obj1) != SCM_VECTOR_LEN(obj2))
@@ -168,7 +171,7 @@
elm2 = SCM_VECTOR_CREF(obj2, i);
if (!EQ(elm1, elm2)
&& (SCM_TYPE(elm1) != SCM_TYPE(elm2)
- || FALSEP(ScmOp_equalp(elm1, elm2))))
+ || FALSEP(scm_p_equalp(elm1, elm2))))
return SCM_FALSE;
}
return SCM_TRUE;
@@ -206,10 +209,11 @@
==============================================================================*/
/* Note: SigScheme supports only the integer part of the numerical tower. */
-ScmObj ScmOp_add(ScmObj left, ScmObj right, enum ScmReductionState *state)
+ScmObj
+scm_p_add(ScmObj left, ScmObj right, enum ScmReductionState *state)
{
int result = 0;
- DECLARE_FUNCTION("+", ReductionOperator);
+ DECLARE_FUNCTION("+", reduction_operator);
switch (*state) {
case SCM_REDUCE_PARTWAY:
case SCM_REDUCE_LAST:
@@ -226,13 +230,14 @@
ERR("(internal error) unrecognized state specifier: %d", *state);
}
- return Scm_NewInt(result);
+ return scm_make_int(result);
}
-ScmObj ScmOp_multiply(ScmObj left, ScmObj right, enum ScmReductionState *state)
+ScmObj
+scm_p_multiply(ScmObj left, ScmObj right, enum ScmReductionState *state)
{
int result = 1;
- DECLARE_FUNCTION("*", ReductionOperator);
+ DECLARE_FUNCTION("*", reduction_operator);
switch (*state) {
case SCM_REDUCE_PARTWAY:
case SCM_REDUCE_LAST:
@@ -249,13 +254,14 @@
ERR("(internal error) unrecognized state specifier: %d", *state);
}
- return Scm_NewInt(result);
+ return scm_make_int(result);
}
-ScmObj ScmOp_subtract(ScmObj left, ScmObj right, enum ScmReductionState *state)
+ScmObj
+scm_p_subtract(ScmObj left, ScmObj right, enum ScmReductionState *state)
{
int result = 0;
- DECLARE_FUNCTION("-", ReductionOperator);
+ DECLARE_FUNCTION("-", reduction_operator);
switch (*state) {
case SCM_REDUCE_PARTWAY:
case SCM_REDUCE_LAST:
@@ -272,13 +278,14 @@
default:
ERR("(internal error) unrecognized state specifier: %d", *state);
}
- return Scm_NewInt(result);
+ return scm_make_int(result);
}
-ScmObj ScmOp_divide(ScmObj left, ScmObj right, enum ScmReductionState *state)
+ScmObj
+scm_p_divide(ScmObj left, ScmObj right, enum ScmReductionState *state)
{
int result = 1;
- DECLARE_FUNCTION("/", ReductionOperator);
+ DECLARE_FUNCTION("/", reduction_operator);
switch (*state) {
case SCM_REDUCE_PARTWAY:
case SCM_REDUCE_LAST:
@@ -296,18 +303,20 @@
default:
ERR("(internal error) unrecognized state specifier: %d", *state);
}
- return Scm_NewInt(result);
+ return scm_make_int(result);
}
-ScmObj ScmOp_numberp(ScmObj obj)
+ScmObj
+scm_p_numberp(ScmObj obj)
{
- DECLARE_FUNCTION("number?", ProcedureFixed1);
+ DECLARE_FUNCTION("number?", procedure_fixed_1);
return (INTP(obj)) ? SCM_TRUE : SCM_FALSE;
}
-ScmObj ScmOp_equal(ScmObj left, ScmObj right, enum ScmReductionState *state)
+ScmObj
+scm_p_equal(ScmObj left, ScmObj right, enum ScmReductionState *state)
{
- DECLARE_FUNCTION("=", ReductionOperator);
+ DECLARE_FUNCTION("=", reduction_operator);
#define COMPARATOR_BODY(op) \
switch (*state) { \
case SCM_REDUCE_0: \
@@ -329,69 +338,79 @@
COMPARATOR_BODY(==);
}
-ScmObj ScmOp_less(ScmObj left, ScmObj right, enum ScmReductionState *state)
+ScmObj
+scm_p_less(ScmObj left, ScmObj right, enum ScmReductionState *state)
{
- DECLARE_FUNCTION("<", ReductionOperator);
+ DECLARE_FUNCTION("<", reduction_operator);
COMPARATOR_BODY(<);
}
-ScmObj ScmOp_less_eq(ScmObj left, ScmObj right, enum ScmReductionState *state)
+ScmObj
+scm_p_less_eq(ScmObj left, ScmObj right, enum ScmReductionState *state)
{
- DECLARE_FUNCTION("<=", ReductionOperator);
+ DECLARE_FUNCTION("<=", reduction_operator);
COMPARATOR_BODY(<=);
}
-ScmObj ScmOp_greater(ScmObj left, ScmObj right, enum ScmReductionState *state)
+ScmObj
+scm_p_greater(ScmObj left, ScmObj right, enum ScmReductionState *state)
{
- DECLARE_FUNCTION(">", ReductionOperator);
+ DECLARE_FUNCTION(">", reduction_operator);
COMPARATOR_BODY(>);
}
-ScmObj ScmOp_greater_eq(ScmObj left, ScmObj right, enum ScmReductionState *state)
+ScmObj
+scm_p_greater_eq(ScmObj left, ScmObj right, enum ScmReductionState *state)
{
- DECLARE_FUNCTION(">=", ReductionOperator);
+ DECLARE_FUNCTION(">=", reduction_operator);
COMPARATOR_BODY(>=);
#undef COMPARATOR_BODY
}
-ScmObj ScmOp_zerop(ScmObj scm_num)
+ScmObj
+scm_p_zerop(ScmObj scm_num)
{
- DECLARE_FUNCTION("zero?", ProcedureFixed1);
+ DECLARE_FUNCTION("zero?", procedure_fixed_1);
ASSERT_INTP(scm_num);
return (SCM_INT_VALUE(scm_num) == 0) ? SCM_TRUE : SCM_FALSE;
}
-ScmObj ScmOp_positivep(ScmObj scm_num)
+ScmObj
+scm_p_positivep(ScmObj scm_num)
{
- DECLARE_FUNCTION("positive?", ProcedureFixed1);
+ DECLARE_FUNCTION("positive?", procedure_fixed_1);
ASSERT_INTP(scm_num);
return (SCM_INT_VALUE(scm_num) > 0) ? SCM_TRUE : SCM_FALSE;
}
-ScmObj ScmOp_negativep(ScmObj scm_num)
+ScmObj
+scm_p_negativep(ScmObj scm_num)
{
- DECLARE_FUNCTION("negative?", ProcedureFixed1);
+ DECLARE_FUNCTION("negative?", procedure_fixed_1);
ASSERT_INTP(scm_num);
return (SCM_INT_VALUE(scm_num) < 0) ? SCM_TRUE : SCM_FALSE;
}
-ScmObj ScmOp_oddp(ScmObj scm_num)
+ScmObj
+scm_p_oddp(ScmObj scm_num)
{
- DECLARE_FUNCTION("odd?", ProcedureFixed1);
+ DECLARE_FUNCTION("odd?", procedure_fixed_1);
ASSERT_INTP(scm_num);
return (SCM_INT_VALUE(scm_num) & 0x1) ? SCM_TRUE : SCM_FALSE;
}
-ScmObj ScmOp_evenp(ScmObj scm_num)
+ScmObj
+scm_p_evenp(ScmObj scm_num)
{
- DECLARE_FUNCTION("even?", ProcedureFixed1);
+ DECLARE_FUNCTION("even?", procedure_fixed_1);
ASSERT_INTP(scm_num);
return (SCM_INT_VALUE(scm_num) & 0x1) ? SCM_FALSE : SCM_TRUE;
}
-ScmObj ScmOp_max(ScmObj left, ScmObj right, enum ScmReductionState *state)
+ScmObj
+scm_p_max(ScmObj left, ScmObj right, enum ScmReductionState *state)
{
- DECLARE_FUNCTION("max", ReductionOperator);
+ DECLARE_FUNCTION("max", reduction_operator);
if (*state == SCM_REDUCE_0)
ERR("at least 1 argument required");
ASSERT_INTP(left);
@@ -400,9 +419,10 @@
return SCM_INT_VALUE(left) > SCM_INT_VALUE(right) ? left : right;
}
-ScmObj ScmOp_min(ScmObj left, ScmObj right, enum ScmReductionState *state)
+ScmObj
+scm_p_min(ScmObj left, ScmObj right, enum ScmReductionState *state)
{
- DECLARE_FUNCTION("min", ReductionOperator);
+ DECLARE_FUNCTION("min", reduction_operator);
if (*state == SCM_REDUCE_0)
ERR("at least 1 argument required");
ASSERT_INTP(left);
@@ -412,23 +432,25 @@
}
-ScmObj ScmOp_abs(ScmObj scm_num)
+ScmObj
+scm_p_abs(ScmObj scm_num)
{
int num = 0;
- DECLARE_FUNCTION("abs", ProcedureFixed1);
+ DECLARE_FUNCTION("abs", procedure_fixed_1);
ASSERT_INTP(scm_num);
num = SCM_INT_VALUE(scm_num);
- return (num < 0) ? Scm_NewInt(-num) : scm_num;
+ return (num < 0) ? scm_make_int(-num) : scm_num;
}
-ScmObj ScmOp_quotient(ScmObj scm_n1, ScmObj scm_n2)
+ScmObj
+scm_p_quotient(ScmObj scm_n1, ScmObj scm_n2)
{
int n1 = 0;
int n2 = 0;
- DECLARE_FUNCTION("quotient", ProcedureFixed2);
+ DECLARE_FUNCTION("quotient", procedure_fixed_2);
ASSERT_INTP(scm_n1);
ASSERT_INTP(scm_n2);
@@ -439,15 +461,16 @@
if (n2 == 0)
ERR("division by zero");
- return Scm_NewInt((int)(n1 / n2));
+ return scm_make_int((int)(n1 / n2));
}
-ScmObj ScmOp_modulo(ScmObj scm_n1, ScmObj scm_n2)
+ScmObj
+scm_p_modulo(ScmObj scm_n1, ScmObj scm_n2)
{
int n1 = 0;
int n2 = 0;
int rem = 0;
- DECLARE_FUNCTION("modulo", ProcedureFixed2);
+ DECLARE_FUNCTION("modulo", procedure_fixed_2);
ASSERT_INTP(scm_n1);
ASSERT_INTP(scm_n2);
@@ -465,14 +488,15 @@
rem += n2;
}
- return Scm_NewInt(rem);
+ return scm_make_int(rem);
}
-ScmObj ScmOp_remainder(ScmObj scm_n1, ScmObj scm_n2)
+ScmObj
+scm_p_remainder(ScmObj scm_n1, ScmObj scm_n2)
{
int n1 = 0;
int n2 = 0;
- DECLARE_FUNCTION("remainder", ProcedureFixed2);
+ DECLARE_FUNCTION("remainder", procedure_fixed_2);
ASSERT_INTP(scm_n1);
ASSERT_INTP(scm_n2);
@@ -483,19 +507,20 @@
if (n2 == 0)
ERR("division by zero");
- return Scm_NewInt(n1 % n2);
+ return scm_make_int(n1 % n2);
}
/*==============================================================================
R5RS : 6.2 Numbers : 6.2.6 Numerical input and output
==============================================================================*/
-ScmObj ScmOp_number2string(ScmObj num, ScmObj args)
+ScmObj
+scm_p_number2string(ScmObj num, ScmObj args)
{
char buf[sizeof(int)*CHAR_BIT + 1];
char *p;
unsigned int n, r;
ScmObj radix;
- DECLARE_FUNCTION("number->string", ProcedureVariadic1);
+ DECLARE_FUNCTION("number->string", procedure_variadic_1);
ASSERT_INTP(num);
n = SCM_INT_VALUE(num);
@@ -534,16 +559,17 @@
if (r == 10 && SCM_INT_VALUE (num) < 0)
*--p = '-';
- return Scm_NewMutableStringCopying(p);
+ return scm_make_mutable_string_copying(p);
}
-ScmObj ScmOp_string2number(ScmObj str, ScmObj args)
+ScmObj
+scm_p_string2number(ScmObj str, ScmObj args)
{
ScmObj radix = SCM_FALSE;
int r = 10;
int num = 0;
char *first_nondigit = NULL;
- DECLARE_FUNCTION("string->number", ProcedureVariadic1);
+ DECLARE_FUNCTION("string->number", procedure_variadic_1);
ASSERT_STRINGP(str);
@@ -566,7 +592,7 @@
if (*first_nondigit)
ERR("ill-formatted number: %s", SCM_STRING_STR(str));
- return Scm_NewInt(num);
+ return scm_make_int(num);
}
/*===================================
@@ -575,24 +601,27 @@
/*==============================================================================
R5RS : 6.3 Other data types : 6.3.1 Booleans
==============================================================================*/
-ScmObj ScmOp_not(ScmObj obj)
+ScmObj
+scm_p_not(ScmObj obj)
{
- DECLARE_FUNCTION("not", ProcedureFixed1);
+ DECLARE_FUNCTION("not", procedure_fixed_1);
return (FALSEP(obj)) ? SCM_TRUE : SCM_FALSE;
}
-ScmObj ScmOp_booleanp(ScmObj obj)
+ScmObj
+scm_p_booleanp(ScmObj obj)
{
- DECLARE_FUNCTION("boolean?", ProcedureFixed1);
+ DECLARE_FUNCTION("boolean?", procedure_fixed_1);
return (EQ(obj, SCM_FALSE) || EQ(obj, SCM_TRUE)) ? SCM_TRUE : SCM_FALSE;
}
/*==============================================================================
R5RS : 6.3 Other data types : 6.3.2 Pairs and lists
==============================================================================*/
-ScmObj ScmOp_car(ScmObj obj)
+ScmObj
+scm_p_car(ScmObj obj)
{
- DECLARE_FUNCTION("car", ProcedureFixed1);
+ DECLARE_FUNCTION("car", procedure_fixed_1);
#if SCM_COMPAT_SIOD_BUGS
if (NULLP(obj))
return SCM_NULL;
@@ -603,9 +632,10 @@
return CAR(obj);
}
-ScmObj ScmOp_cdr(ScmObj obj)
+ScmObj
+scm_p_cdr(ScmObj obj)
{
- DECLARE_FUNCTION("cdr", ProcedureFixed1);
+ DECLARE_FUNCTION("cdr", procedure_fixed_1);
#if SCM_COMPAT_SIOD_BUGS
if (NULLP(obj))
return SCM_NULL;
@@ -616,21 +646,24 @@
return CDR(obj);
}
-ScmObj ScmOp_pairp(ScmObj obj)
+ScmObj
+scm_p_pairp(ScmObj obj)
{
- DECLARE_FUNCTION("pair?", ProcedureFixed1);
+ DECLARE_FUNCTION("pair?", procedure_fixed_1);
return (CONSP(obj)) ? SCM_TRUE : SCM_FALSE;
}
-ScmObj ScmOp_cons(ScmObj car, ScmObj cdr)
+ScmObj
+scm_p_cons(ScmObj car, ScmObj cdr)
{
- DECLARE_FUNCTION("cons", ProcedureFixed2);
+ DECLARE_FUNCTION("cons", procedure_fixed_2);
return CONS(car, cdr);
}
-ScmObj ScmOp_set_card(ScmObj pair, ScmObj car)
+ScmObj
+scm_p_set_card(ScmObj pair, ScmObj car)
{
- DECLARE_FUNCTION("set-car!", ProcedureFixed2);
+ DECLARE_FUNCTION("set-car!", procedure_fixed_2);
ASSERT_CONSP(pair);
SET_CAR(pair, car);
@@ -642,9 +675,10 @@
#endif
}
-ScmObj ScmOp_set_cdrd(ScmObj pair, ScmObj cdr)
+ScmObj
+scm_p_set_cdrd(ScmObj pair, ScmObj cdr)
{
- DECLARE_FUNCTION("set-cdr!", ProcedureFixed2);
+ DECLARE_FUNCTION("set-cdr!", procedure_fixed_2);
ASSERT_CONSP(pair);
SET_CDR(pair, cdr);
@@ -656,61 +690,70 @@
#endif
}
-ScmObj ScmOp_caar(ScmObj lst)
+ScmObj
+scm_p_caar(ScmObj lst)
{
- DECLARE_FUNCTION("caar", ProcedureFixed1);
- return ScmOp_car( ScmOp_car(lst) );
+ DECLARE_FUNCTION("caar", procedure_fixed_1);
+ return scm_p_car( scm_p_car(lst) );
}
-ScmObj ScmOp_cadr(ScmObj lst)
+ScmObj
+scm_p_cadr(ScmObj lst)
{
- DECLARE_FUNCTION("cadr", ProcedureFixed1);
- return ScmOp_car( ScmOp_cdr(lst) );
+ DECLARE_FUNCTION("cadr", procedure_fixed_1);
+ return scm_p_car( scm_p_cdr(lst) );
}
-ScmObj ScmOp_cdar(ScmObj lst)
+ScmObj
+scm_p_cdar(ScmObj lst)
{
- DECLARE_FUNCTION("cdar", ProcedureFixed1);
- return ScmOp_cdr( ScmOp_car(lst) );
+ DECLARE_FUNCTION("cdar", procedure_fixed_1);
+ return scm_p_cdr( scm_p_car(lst) );
}
-ScmObj ScmOp_cddr(ScmObj lst)
+ScmObj
+scm_p_cddr(ScmObj lst)
{
- DECLARE_FUNCTION("cddr", ProcedureFixed1);
- return ScmOp_cdr( ScmOp_cdr(lst) );
+ DECLARE_FUNCTION("cddr", procedure_fixed_1);
+ return scm_p_cdr( scm_p_cdr(lst) );
}
-ScmObj ScmOp_caddr(ScmObj lst)
+ScmObj
+scm_p_caddr(ScmObj lst)
{
- DECLARE_FUNCTION("caddr", ProcedureFixed1);
- return ScmOp_car( ScmOp_cdr( ScmOp_cdr(lst) ));
+ DECLARE_FUNCTION("caddr", procedure_fixed_1);
+ return scm_p_car( scm_p_cdr( scm_p_cdr(lst) ));
}
-ScmObj ScmOp_cdddr(ScmObj lst)
+ScmObj
+scm_p_cdddr(ScmObj lst)
{
- DECLARE_FUNCTION("cdddr", ProcedureFixed1);
- return ScmOp_cdr( ScmOp_cdr( ScmOp_cdr(lst) ));
+ DECLARE_FUNCTION("cdddr", procedure_fixed_1);
+ return scm_p_cdr( scm_p_cdr( scm_p_cdr(lst) ));
}
-ScmObj ScmOp_list(ScmObj args)
+ScmObj
+scm_p_list(ScmObj args)
{
- DECLARE_FUNCTION("list", ProcedureVariadic0);
+ DECLARE_FUNCTION("list", procedure_variadic_0);
return args;
}
-ScmObj ScmOp_nullp(ScmObj obj)
+ScmObj
+scm_p_nullp(ScmObj obj)
{
- DECLARE_FUNCTION("null?", ProcedureFixed1);
+ DECLARE_FUNCTION("null?", procedure_fixed_1);
return (NULLP(obj)) ? SCM_TRUE : SCM_FALSE;
}
-ScmObj ScmOp_listp(ScmObj obj)
+ScmObj
+scm_p_listp(ScmObj obj)
{
int len = 0;
- DECLARE_FUNCTION("list?", ProcedureFixed1);
+ DECLARE_FUNCTION("list?", procedure_fixed_1);
if (NULLP(obj))
return SCM_TRUE;
if (!CONSP(obj))
return SCM_FALSE;
- len = ScmOp_c_length(obj);
+ len = scm_p_c_length(obj);
return (len != -1) ? SCM_TRUE : SCM_FALSE;
}
@@ -721,10 +764,11 @@
* This function is ported from Gauche, by Shiro Kawai(shiro at acm.org)
*/
/* FIXME:
- * - Rename to Scm_c_length() since it isn't a Scheme procedure
+ * - Rename to scm_c_length() since it isn't a Scheme procedure
* - Insert its copyright and license into this file properly
*/
-int ScmOp_c_length(ScmObj lst)
+int
+scm_p_c_length(ScmObj lst)
{
ScmObj slow = lst;
int len = 0;
@@ -748,22 +792,24 @@
return len;
}
-ScmObj ScmOp_length(ScmObj obj)
+ScmObj
+scm_p_length(ScmObj obj)
{
- int len = ScmOp_c_length(obj);
- DECLARE_FUNCTION("length", ProcedureFixed1);
+ int len = scm_p_c_length(obj);
+ DECLARE_FUNCTION("length", procedure_fixed_1);
if (len < 0)
ERR_OBJ("list required but got", obj);
- return Scm_NewInt(len);
+ return scm_make_int(len);
}
-ScmObj ScmOp_append(ScmObj args)
+ScmObj
+scm_p_append(ScmObj args)
{
ScmQueue q;
ScmObj elm_lst, res;
- DECLARE_FUNCTION("append", ProcedureVariadic0);
+ DECLARE_FUNCTION("append", procedure_variadic_0);
if (NULLP(args))
return SCM_NULL;
@@ -783,10 +829,11 @@
return res;
}
-ScmObj ScmOp_reverse(ScmObj lst)
+ScmObj
+scm_p_reverse(ScmObj lst)
{
ScmObj ret_lst = SCM_NULL;
- DECLARE_FUNCTION("reverse", ProcedureFixed1);
+ DECLARE_FUNCTION("reverse", procedure_fixed_1);
for (; CONSP(lst); lst = CDR(lst))
ret_lst = CONS(CAR(lst), ret_lst);
@@ -797,7 +844,8 @@
return ret_lst;
}
-static ScmObj ScmOp_listtail_internal(ScmObj lst, int k)
+static ScmObj
+scm_p_listtail_internal(ScmObj lst, int k)
{
while (k--) {
if (!CONSP(lst))
@@ -808,28 +856,30 @@
return lst;
}
-ScmObj ScmOp_list_tail(ScmObj lst, ScmObj scm_k)
+ScmObj
+scm_p_list_tail(ScmObj lst, ScmObj scm_k)
{
ScmObj ret;
- DECLARE_FUNCTION("list-tail", ProcedureFixed2);
+ DECLARE_FUNCTION("list-tail", procedure_fixed_2);
ASSERT_INTP(scm_k);
- ret = ScmOp_listtail_internal(lst, SCM_INT_VALUE(scm_k));
+ ret = scm_p_listtail_internal(lst, SCM_INT_VALUE(scm_k));
if (EQ(ret, SCM_INVALID))
ERR_OBJ("out of range or bad list, arglist is", CONS(lst, scm_k));
return ret;
}
-ScmObj ScmOp_list_ref(ScmObj lst, ScmObj scm_k)
+ScmObj
+scm_p_list_ref(ScmObj lst, ScmObj scm_k)
{
ScmObj tail = SCM_NULL;
- DECLARE_FUNCTION("list-ref", ProcedureFixed2);
+ DECLARE_FUNCTION("list-ref", procedure_fixed_2);
ASSERT_INTP(scm_k);
- tail = ScmOp_listtail_internal(lst, SCM_INT_VALUE(scm_k));
+ tail = scm_p_listtail_internal(lst, SCM_INT_VALUE(scm_k));
if (EQ(tail, SCM_INVALID) || NULLP(tail))
ERR_OBJ("out of range or bad list, arglist is", CONS(lst, scm_k));
@@ -844,9 +894,10 @@
return SCM_FALSE; \
} while (/* CONSTCOND */ 0)
-ScmObj ScmOp_memq(ScmObj obj, ScmObj lst)
+ScmObj
+scm_p_memq(ScmObj obj, ScmObj lst)
{
- DECLARE_FUNCTION("memq", ProcedureFixed2);
+ DECLARE_FUNCTION("memq", procedure_fixed_2);
for (; CONSP(lst); lst = CDR(lst))
if (EQ(obj, CAR(lst)))
@@ -860,12 +911,13 @@
return SCM_FALSE;
}
-ScmObj ScmOp_memv(ScmObj obj, ScmObj lst)
+ScmObj
+scm_p_memv(ScmObj obj, ScmObj lst)
{
- DECLARE_FUNCTION("memv", ProcedureFixed2);
+ DECLARE_FUNCTION("memv", procedure_fixed_2);
for (; CONSP(lst); lst = CDR(lst))
- if (NFALSEP(ScmOp_eqvp(obj, CAR(lst))))
+ if (NFALSEP(scm_p_eqvp(obj, CAR(lst))))
return lst;
#if SCM_STRICT_ARGCHECK
@@ -876,12 +928,13 @@
return SCM_FALSE;
}
-ScmObj ScmOp_member(ScmObj obj, ScmObj lst)
+ScmObj
+scm_p_member(ScmObj obj, ScmObj lst)
{
- DECLARE_FUNCTION("member", ProcedureFixed2);
+ DECLARE_FUNCTION("member", procedure_fixed_2);
for (; CONSP(lst); lst = CDR(lst))
- if (NFALSEP(ScmOp_equalp(obj, CAR(lst))))
+ if (NFALSEP(scm_p_equalp(obj, CAR(lst))))
return lst;
#if SCM_STRICT_ARGCHECK
@@ -892,12 +945,13 @@
return SCM_FALSE;
}
-ScmObj ScmOp_assq(ScmObj obj, ScmObj alist)
+ScmObj
+scm_p_assq(ScmObj obj, ScmObj alist)
{
ScmObj tmp_lst = SCM_NULL;
ScmObj tmpobj = SCM_NULL;
ScmObj car;
- DECLARE_FUNCTION("assq", ProcedureFixed2);
+ DECLARE_FUNCTION("assq", procedure_fixed_2);
for (tmp_lst = alist; CONSP(tmp_lst); tmp_lst = CDR(tmp_lst)) {
tmpobj = CAR(tmp_lst);
@@ -915,22 +969,23 @@
return SCM_FALSE;
}
-ScmObj ScmOp_assv(ScmObj obj, ScmObj alist)
+ScmObj
+scm_p_assv(ScmObj obj, ScmObj alist)
{
ScmObj tmp_lst = SCM_NULL;
ScmObj tmpobj = SCM_NULL;
ScmObj car;
- DECLARE_FUNCTION("assv", ProcedureFixed2);
+ DECLARE_FUNCTION("assv", procedure_fixed_2);
for (tmp_lst = alist; CONSP(tmp_lst); tmp_lst = CDR(tmp_lst)) {
tmpobj = CAR(tmp_lst);
car = CAR(tmpobj);
#if SCM_STRICT_R5RS
ASSERT_CONSP(tmpobj);
- if (NFALSEP(ScmOp_eqvp(car, obj)))
+ if (NFALSEP(scm_p_eqvp(car, obj)))
return tmpobj;
#else
- if (CONSP(tmpobj) && NFALSEP(ScmOp_eqvp(car, obj)))
+ if (CONSP(tmpobj) && NFALSEP(scm_p_eqvp(car, obj)))
return tmpobj;
#endif
}
@@ -938,22 +993,23 @@
return SCM_FALSE;
}
-ScmObj ScmOp_assoc(ScmObj obj, ScmObj alist)
+ScmObj
+scm_p_assoc(ScmObj obj, ScmObj alist)
{
ScmObj tmp_lst = SCM_NULL;
ScmObj tmpobj = SCM_NULL;
ScmObj car;
- DECLARE_FUNCTION("assoc", ProcedureFixed2);
+ DECLARE_FUNCTION("assoc", procedure_fixed_2);
for (tmp_lst = alist; CONSP(tmp_lst); tmp_lst = CDR(tmp_lst)) {
tmpobj = CAR(tmp_lst);
car = CAR(tmpobj);
#if SCM_STRICT_R5RS
ASSERT_CONSP(tmpobj);
- if (NFALSEP(ScmOp_equalp(car, obj)))
+ if (NFALSEP(scm_p_equalp(car, obj)))
return tmpobj;
#else
- if (CONSP(tmpobj) && NFALSEP(ScmOp_equalp(car, obj)))
+ if (CONSP(tmpobj) && NFALSEP(scm_p_equalp(car, obj)))
return tmpobj;
#endif
}
@@ -965,38 +1021,43 @@
/*==============================================================================
R5RS : 6.3 Other data types : 6.3.3 Symbols
==============================================================================*/
-ScmObj ScmOp_symbolp(ScmObj obj)
+ScmObj
+scm_p_symbolp(ScmObj obj)
{
- DECLARE_FUNCTION("symbol?", ProcedureFixed1);
+ DECLARE_FUNCTION("symbol?", procedure_fixed_1);
return (SYMBOLP(obj)) ? SCM_TRUE : SCM_FALSE;
}
-ScmObj ScmOp_symbol2string(ScmObj obj)
+ScmObj
+scm_p_symbol2string(ScmObj obj)
{
- DECLARE_FUNCTION("symbol->string", ProcedureFixed1);
+ DECLARE_FUNCTION("symbol->string", procedure_fixed_1);
ASSERT_SYMBOLP(obj);
- return Scm_NewImmutableStringCopying(SCM_SYMBOL_NAME(obj));
+ return scm_make_immutable_string_copying(SCM_SYMBOL_NAME(obj));
}
-ScmObj ScmOp_string2symbol(ScmObj str)
+ScmObj
+scm_p_string2symbol(ScmObj str)
{
- DECLARE_FUNCTION("string->symbol", ProcedureFixed1);
+ DECLARE_FUNCTION("string->symbol", procedure_fixed_1);
ASSERT_STRINGP(str);
- return Scm_Intern(SCM_STRING_STR(str));
+ return scm_intern(SCM_STRING_STR(str));
}
/*==============================================================================
R5RS : 6.3 Other data types : 6.3.4 Characters
==============================================================================*/
-ScmObj ScmOp_charp(ScmObj obj)
+ScmObj
+scm_p_charp(ScmObj obj)
{
- DECLARE_FUNCTION("char?", ProcedureFixed1);
+ DECLARE_FUNCTION("char?", procedure_fixed_1);
return (CHARP(obj)) ? SCM_TRUE : SCM_FALSE;
}
-ScmObj ScmOp_charequalp(ScmObj ch1, ScmObj ch2)
+ScmObj
+scm_p_charequalp(ScmObj ch1, ScmObj ch2)
{
- DECLARE_FUNCTION("char=?", ProcedureFixed2);
+ DECLARE_FUNCTION("char=?", procedure_fixed_2);
ASSERT_CHARP(ch1);
ASSERT_CHARP(ch2);
@@ -1004,10 +1065,11 @@
return (SCM_CHAR_VALUE(ch1) == SCM_CHAR_VALUE(ch2)) ? SCM_TRUE : SCM_FALSE;
}
-ScmObj ScmOp_char_alphabeticp(ScmObj obj)
+ScmObj
+scm_p_char_alphabeticp(ScmObj obj)
{
int ch;
- DECLARE_FUNCTION("char-alphabetic?", ProcedureFixed1);
+ DECLARE_FUNCTION("char-alphabetic?", procedure_fixed_1);
ASSERT_CHARP(obj);
@@ -1016,10 +1078,11 @@
return (isascii(ch) && isalpha(ch)) ? SCM_TRUE : SCM_FALSE;
}
-ScmObj ScmOp_char_numericp(ScmObj obj)
+ScmObj
+scm_p_char_numericp(ScmObj obj)
{
int ch;
- DECLARE_FUNCTION("char-numeric?", ProcedureFixed1);
+ DECLARE_FUNCTION("char-numeric?", procedure_fixed_1);
ASSERT_CHARP(obj);
@@ -1028,10 +1091,11 @@
return (isascii(ch) && isdigit(ch)) ? SCM_TRUE : SCM_FALSE;
}
-ScmObj ScmOp_char_whitespacep(ScmObj obj)
+ScmObj
+scm_p_char_whitespacep(ScmObj obj)
{
int ch;
- DECLARE_FUNCTION("char-whitespace?", ProcedureFixed1);
+ DECLARE_FUNCTION("char-whitespace?", procedure_fixed_1);
ASSERT_CHARP(obj);
@@ -1040,10 +1104,11 @@
return (isascii(ch) && isspace(ch)) ? SCM_TRUE : SCM_FALSE;
}
-ScmObj ScmOp_char_upper_casep(ScmObj obj)
+ScmObj
+scm_p_char_upper_casep(ScmObj obj)
{
int ch;
- DECLARE_FUNCTION("char-upper-case?", ProcedureFixed1);
+ DECLARE_FUNCTION("char-upper-case?", procedure_fixed_1);
ASSERT_CHARP(obj);
@@ -1052,10 +1117,11 @@
return (isascii(ch) && isupper(ch)) ? SCM_TRUE : SCM_FALSE;
}
-ScmObj ScmOp_char_lower_casep(ScmObj obj)
+ScmObj
+scm_p_char_lower_casep(ScmObj obj)
{
int ch;
- DECLARE_FUNCTION("char-lower-case?", ProcedureFixed1);
+ DECLARE_FUNCTION("char-lower-case?", procedure_fixed_1);
ASSERT_CHARP(obj);
@@ -1064,33 +1130,36 @@
return (isascii(ch) && islower(ch)) ? SCM_TRUE : SCM_FALSE;
}
-ScmObj ScmOp_char2integer(ScmObj obj)
+ScmObj
+scm_p_char2integer(ScmObj obj)
{
- DECLARE_FUNCTION("char->integer", ProcedureFixed1);
+ DECLARE_FUNCTION("char->integer", procedure_fixed_1);
ASSERT_CHARP(obj);
- return Scm_NewInt(SCM_CHAR_VALUE(obj));
+ return scm_make_int(SCM_CHAR_VALUE(obj));
}
-ScmObj ScmOp_integer2char(ScmObj obj)
+ScmObj
+scm_p_integer2char(ScmObj obj)
{
int val;
char buf[SCM_MB_MAX_LEN + sizeof((char)'\0')];
- DECLARE_FUNCTION("integer->char", ProcedureFixed1);
+ DECLARE_FUNCTION("integer->char", procedure_fixed_1);
ASSERT_INTP(obj);
val = SCM_INT_VALUE(obj);
- if (!SCM_CHARCODEC_INT2STR(Scm_current_char_codec, buf, val, SCM_MB_STATELESS))
+ if (!SCM_CHARCODEC_INT2STR(scm_current_char_codec, buf, val, SCM_MB_STATELESS))
ERR_OBJ("invalid char value", obj);
- return Scm_NewChar(val);
+ return scm_make_char(val);
}
-ScmObj ScmOp_char_upcase(ScmObj obj)
+ScmObj
+scm_p_char_upcase(ScmObj obj)
{
int ch;
- DECLARE_FUNCTION("char-upcase", ProcedureFixed1);
+ DECLARE_FUNCTION("char-upcase", procedure_fixed_1);
ASSERT_CHARP(obj);
@@ -1101,10 +1170,11 @@
return obj;
}
-ScmObj ScmOp_char_downcase(ScmObj obj)
+ScmObj
+scm_p_char_downcase(ScmObj obj)
{
int ch;
- DECLARE_FUNCTION("char-downcase", ProcedureFixed1);
+ DECLARE_FUNCTION("char-downcase", procedure_fixed_1);
ASSERT_CHARP(obj);
@@ -1118,23 +1188,25 @@
/*==============================================================================
R5RS : 6.3 Other data types : 6.3.5 Strings
==============================================================================*/
-ScmObj ScmOp_stringp(ScmObj obj)
+ScmObj
+scm_p_stringp(ScmObj obj)
{
- DECLARE_FUNCTION("string?", ProcedureFixed1);
+ DECLARE_FUNCTION("string?", procedure_fixed_1);
return (STRINGP(obj)) ? SCM_TRUE : SCM_FALSE;
}
-ScmObj ScmOp_make_string(ScmObj length, ScmObj args)
+ScmObj
+scm_p_make_string(ScmObj length, ScmObj args)
{
int filler_val, len, i;
ScmObj filler = SCM_FALSE;
ScmObj sport = SCM_FALSE;
- DECLARE_FUNCTION("make-string", ProcedureVariadic1);
+ DECLARE_FUNCTION("make-string", procedure_variadic_1);
ASSERT_INTP(length);
len = SCM_INT_VALUE(length);
if (len == 0)
- return Scm_NewMutableStringCopying("");
+ return scm_make_mutable_string_copying("");
if (len < 0)
ERR_OBJ("length must be a positive integer", length);
@@ -1150,33 +1222,36 @@
/* TODO: make efficient */
/* fill string (multibyte-ready) */
- sport = ScmOp_SRFI6_open_output_string();
+ sport = scm_p_srfi6_open_output_string();
for (i = 0; i < len; i++) {
SCM_PORT_PUT_CHAR(sport, filler_val);
}
- return ScmOp_SRFI6_get_output_string(sport);
+ return scm_p_srfi6_get_output_string(sport);
}
-ScmObj ScmOp_string(ScmObj args)
+ScmObj
+scm_p_string(ScmObj args)
{
- DECLARE_FUNCTION("string", ProcedureVariadic0);
- return ScmOp_list2string(args);
+ DECLARE_FUNCTION("string", procedure_variadic_0);
+ return scm_p_list2string(args);
}
-ScmObj ScmOp_string_length(ScmObj str)
+ScmObj
+scm_p_string_length(ScmObj str)
{
- DECLARE_FUNCTION("string-length", ProcedureFixed1);
+ DECLARE_FUNCTION("string-length", procedure_fixed_1);
ASSERT_STRINGP(str);
- return Scm_NewInt(Scm_mb_bare_c_strlen(SCM_STRING_STR(str)));
+ return scm_make_int(scm_mb_bare_c_strlen(SCM_STRING_STR(str)));
}
-ScmObj ScmOp_string_ref(ScmObj str, ScmObj k)
+ScmObj
+scm_p_string_ref(ScmObj str, ScmObj k)
{
int c_index = 0;
int ch;
ScmMultibyteString mbs;
- DECLARE_FUNCTION("string-ref", ProcedureFixed2);
+ DECLARE_FUNCTION("string-ref", procedure_fixed_2);
ASSERT_STRINGP(str);
ASSERT_INTP(k);
@@ -1188,18 +1263,19 @@
SCM_MBS_INIT(mbs);
SCM_MBS_SET_STR(mbs, SCM_STRING_STR(str));
SCM_MBS_SET_SIZE(mbs, strlen(SCM_STRING_STR(str)));
- mbs = Scm_mb_strref(mbs, c_index);
+ mbs = scm_mb_strref(mbs, c_index);
/* FIXME: support stateful encoding */
- ch = SCM_CHARCODEC_STR2INT(Scm_current_char_codec, SCM_MBS_GET_STR(mbs),
+ ch = SCM_CHARCODEC_STR2INT(scm_current_char_codec, SCM_MBS_GET_STR(mbs),
SCM_MBS_GET_SIZE(mbs), SCM_MB_STATELESS);
if (ch == EOF)
ERR("string-ref: invalid char sequence");
- return Scm_NewChar(ch);
+ return scm_make_char(ch);
}
-ScmObj ScmOp_string_setd(ScmObj str, ScmObj k, ScmObj ch)
+ScmObj
+scm_p_string_setd(ScmObj str, ScmObj k, ScmObj ch)
{
int c_start_index = 0;
int prefix_size = 0;
@@ -1211,7 +1287,7 @@
const char *string_str = NULL;
char new_ch_str[SCM_MB_MAX_LEN + sizeof((char)'\0')];
const char *next;
- DECLARE_FUNCTION("string-set!", ProcedureFixed3);
+ DECLARE_FUNCTION("string-set!", procedure_fixed_3);
ASSERT_STRINGP(str);
ASSERT_MUTABLEP(str);
@@ -1229,10 +1305,10 @@
SCM_MBS_INIT(mbs);
SCM_MBS_SET_STR(mbs, string_str);
SCM_MBS_SET_SIZE(mbs, strlen(string_str));
- mbs = Scm_mb_strref(mbs, c_start_index);
+ mbs = scm_mb_strref(mbs, c_start_index);
/* FIXME: support stateful encoding */
- next = SCM_CHARCODEC_INT2STR(Scm_current_char_codec, new_ch_str,
+ next = SCM_CHARCODEC_INT2STR(scm_current_char_codec, new_ch_str,
SCM_CHAR_VALUE(ch), SCM_MB_STATELESS);
if (!next)
ERR_OBJ("invalid char in", str);
@@ -1258,9 +1334,10 @@
return str;
}
-ScmObj ScmOp_stringequalp(ScmObj str1, ScmObj str2)
+ScmObj
+scm_p_stringequalp(ScmObj str1, ScmObj str2)
{
- DECLARE_FUNCTION("string=?", ProcedureFixed2);
+ DECLARE_FUNCTION("string=?", procedure_fixed_2);
ASSERT_STRINGP(str1);
ASSERT_STRINGP(str2);
@@ -1271,14 +1348,15 @@
return SCM_FALSE;
}
-ScmObj ScmOp_substring(ScmObj str, ScmObj start, ScmObj end)
+ScmObj
+scm_p_substring(ScmObj str, ScmObj start, ScmObj end)
{
int c_start_index = 0;
int c_end_index = 0;
char *new_str = NULL;
ScmMultibyteString mbs;
const char *string_str = NULL;
- DECLARE_FUNCTION("substring", ProcedureFixed3);
+ DECLARE_FUNCTION("substring", procedure_fixed_3);
ASSERT_STRINGP(str);
ASSERT_MUTABLEP(str);
@@ -1301,17 +1379,18 @@
SCM_MBS_INIT(mbs);
SCM_MBS_SET_STR(mbs, string_str);
SCM_MBS_SET_SIZE(mbs, strlen(string_str));
- mbs = Scm_mb_substring(mbs, c_start_index, c_end_index - c_start_index);
+ mbs = scm_mb_substring(mbs, c_start_index, c_end_index - c_start_index);
/* copy from start_ptr to end_ptr */
new_str = scm_malloc(SCM_MBS_GET_SIZE(mbs) + 1);
memcpy(new_str, SCM_MBS_GET_STR(mbs), SCM_MBS_GET_SIZE(mbs));
new_str[SCM_MBS_GET_SIZE(mbs)] = 0;
- return Scm_NewMutableString(new_str);
+ return scm_make_mutable_string(new_str);
}
-ScmObj ScmOp_string_append(ScmObj args)
+ScmObj
+scm_p_string_append(ScmObj args)
{
/* FIXME: transition to new arg extraction mechanism incomplete. */
int total_size = 0;
@@ -1320,10 +1399,10 @@
ScmObj obj = SCM_FALSE;
char *new_str = NULL;
char *p = NULL;
- DECLARE_FUNCTION("string-append", ProcedureVariadic0);
+ DECLARE_FUNCTION("string-append", procedure_variadic_0);
if (NO_MORE_ARG(args))
- return Scm_NewMutableStringCopying("");
+ return scm_make_mutable_string_copying("");
/* count total size of the new string */
for (strlst = args; !NULLP(strlst); strlst = CDR(strlst)) {
@@ -1345,10 +1424,11 @@
p += strlen(SCM_STRING_STR(obj));
}
- return Scm_NewMutableString(new_str);
+ return scm_make_mutable_string(new_str);
}
-ScmObj ScmOp_string2list(ScmObj str)
+ScmObj
+scm_p_string2list(ScmObj str)
{
ScmQueue q;
ScmObj res;
@@ -1356,7 +1436,7 @@
ScmMultibyteString mbs;
ScmMultibyteCharInfo mbc;
ScmMultibyteState state;
- DECLARE_FUNCTION("string->list", ProcedureFixed1);
+ DECLARE_FUNCTION("string->list", procedure_fixed_1);
ASSERT_STRINGP(str);
@@ -1368,35 +1448,36 @@
SCM_QUEUE_POINT_TO(q, res);
while (SCM_MBS_GET_SIZE(mbs)) {
state = SCM_MBS_GET_STATE(mbs);
- mbc = SCM_CHARCODEC_SCAN_CHAR(Scm_current_char_codec, mbs);
+ mbc = SCM_CHARCODEC_SCAN_CHAR(scm_current_char_codec, mbs);
if (SCM_MBCINFO_ERRORP(mbc) || SCM_MBCINFO_INCOMPLETEP(mbc))
ERR("string->list: invalid char sequence");
- ch = SCM_CHARCODEC_STR2INT(Scm_current_char_codec,
+ ch = SCM_CHARCODEC_STR2INT(scm_current_char_codec,
SCM_MBS_GET_STR(mbs),
SCM_MBCINFO_GET_SIZE(mbc),
state);
if (ch == EOF)
ERR("string->list: invalid char sequence");
- SCM_QUEUE_ADD(q, Scm_NewChar(ch));
+ SCM_QUEUE_ADD(q, scm_make_char(ch));
SCM_MBS_SKIP_CHAR(mbs, mbc);
}
return res;
}
-ScmObj ScmOp_list2string(ScmObj lst)
+ScmObj
+scm_p_list2string(ScmObj lst)
{
ScmObj rest, ch, sport;
- DECLARE_FUNCTION("list->string", ProcedureFixed1);
+ DECLARE_FUNCTION("list->string", procedure_fixed_1);
ASSERT_LISTP(lst);
if (NULLP(lst))
- return Scm_NewMutableStringCopying("");
+ return scm_make_mutable_string_copying("");
/* TODO: make efficient */
- sport = ScmOp_SRFI6_open_output_string();
+ sport = scm_p_srfi6_open_output_string();
for (rest = lst; CONSP(rest); rest = CDR(rest)) {
ch = CAR(rest);
ASSERT_CHARP(ch);
@@ -1405,17 +1486,19 @@
if (!NULLP(rest))
ERR_OBJ("invalid char list", lst);
- return ScmOp_SRFI6_get_output_string(sport);
+ return scm_p_srfi6_get_output_string(sport);
}
-ScmObj ScmOp_string_copy(ScmObj str)
+ScmObj
+scm_p_string_copy(ScmObj str)
{
- DECLARE_FUNCTION("string-copy", ProcedureFixed1);
+ DECLARE_FUNCTION("string-copy", procedure_fixed_1);
ASSERT_STRINGP(str);
- return Scm_NewMutableStringCopying(SCM_STRING_STR(str));
+ return scm_make_mutable_string_copying(SCM_STRING_STR(str));
}
-ScmObj ScmOp_string_filld(ScmObj str, ScmObj ch)
+ScmObj
+scm_p_string_filld(ScmObj str, ScmObj ch)
{
int char_size = 0;
int str_len = 0;
@@ -1423,7 +1506,7 @@
char *p = NULL;
char ch_str[SCM_MB_MAX_LEN + sizeof((char)'\0')];
const char *next;
- DECLARE_FUNCTION("string-fill!", ProcedureFixed2);
+ DECLARE_FUNCTION("string-fill!", procedure_fixed_2);
ASSERT_STRINGP(str);
ASSERT_MUTABLEP(str);
@@ -1431,10 +1514,10 @@
str_len = SCM_STRING_LEN(str);
if (str_len == 0)
- return Scm_NewMutableStringCopying("");
+ return scm_make_mutable_string_copying("");
/* FIXME: support stateful encoding */
- next = SCM_CHARCODEC_INT2STR(Scm_current_char_codec, ch_str,
+ next = SCM_CHARCODEC_INT2STR(scm_current_char_codec, ch_str,
SCM_CHAR_VALUE(ch), SCM_MB_STATELESS);
if (!next)
ERR_OBJ("invalid char in", str);
@@ -1454,19 +1537,21 @@
/*==============================================================================
R5RS : 6.3 Other data types : 6.3.6 Vectors
==============================================================================*/
-ScmObj ScmOp_vectorp(ScmObj obj)
+ScmObj
+scm_p_vectorp(ScmObj obj)
{
- DECLARE_FUNCTION("vector?", ProcedureFixed1);
+ DECLARE_FUNCTION("vector?", procedure_fixed_1);
return (VECTORP(obj)) ? SCM_TRUE : SCM_FALSE;
}
-ScmObj ScmOp_make_vector(ScmObj vector_len, ScmObj args)
+ScmObj
+scm_p_make_vector(ScmObj vector_len, ScmObj args)
{
ScmObj *vec = NULL;
ScmObj filler = SCM_FALSE;
int len = 0;
int i = 0;
- DECLARE_FUNCTION("make-vector", ProcedureVariadic1);
+ DECLARE_FUNCTION("make-vector", procedure_variadic_1);
ASSERT_INTP(vector_len);
@@ -1486,35 +1571,38 @@
for (i = 0; i < len; i++)
vec[i] = filler;
- return Scm_NewVector(vec, len);
+ return scm_make_vector(vec, len);
}
-ScmObj ScmOp_vector(ScmObj args)
+ScmObj
+scm_p_vector(ScmObj args)
{
int len, i;
ScmObj *vec;
- DECLARE_FUNCTION("vector", ProcedureVariadic0);
+ DECLARE_FUNCTION("vector", procedure_variadic_0);
- len = SCM_INT_VALUE(ScmOp_length(args));
+ len = SCM_INT_VALUE(scm_p_length(args));
vec = scm_malloc(sizeof(ScmObj) * len);
for (i = 0; i < len; i++)
vec[i] = POP_ARG(args);
- return Scm_NewVector(vec, len);
+ return scm_make_vector(vec, len);
}
-ScmObj ScmOp_vector_length(ScmObj vec)
+ScmObj
+scm_p_vector_length(ScmObj vec)
{
- DECLARE_FUNCTION("vector-length", ProcedureFixed1);
+ DECLARE_FUNCTION("vector-length", procedure_fixed_1);
ASSERT_VECTORP(vec);
- return Scm_NewInt(SCM_VECTOR_LEN(vec));
+ return scm_make_int(SCM_VECTOR_LEN(vec));
}
-ScmObj ScmOp_vector_ref(ScmObj vec, ScmObj scm_k)
+ScmObj
+scm_p_vector_ref(ScmObj vec, ScmObj scm_k)
{
- DECLARE_FUNCTION("vector-ref", ProcedureFixed2);
+ DECLARE_FUNCTION("vector-ref", procedure_fixed_2);
ASSERT_VECTORP(vec);
ASSERT_INTP(scm_k);
@@ -1526,9 +1614,10 @@
return SCM_VECTOR_REF(vec, scm_k);
}
-ScmObj ScmOp_vector_setd(ScmObj vec, ScmObj scm_k, ScmObj obj)
+ScmObj
+scm_p_vector_setd(ScmObj vec, ScmObj scm_k, ScmObj obj)
{
- DECLARE_FUNCTION("vector-set!", ProcedureFixed3);
+ DECLARE_FUNCTION("vector-set!", procedure_fixed_3);
ASSERT_VECTORP(vec);
ASSERT_INTP(scm_k);
@@ -1542,13 +1631,14 @@
return SCM_UNDEF;
}
-ScmObj ScmOp_vector2list(ScmObj vec)
+ScmObj
+scm_p_vector2list(ScmObj vec)
{
ScmQueue q;
ScmObj res;
ScmObj *v;
int len, i;
- DECLARE_FUNCTION("vector->list", ProcedureFixed1);
+ DECLARE_FUNCTION("vector->list", procedure_fixed_1);
ASSERT_VECTORP(vec);
@@ -1563,19 +1653,20 @@
return res;
}
-ScmObj ScmOp_list2vector(ScmObj lst)
+ScmObj
+scm_p_list2vector(ScmObj lst)
{
ScmObj scm_len = SCM_NULL;
ScmObj *v = NULL;
int c_len = 0;
int i = 0;
- DECLARE_FUNCTION("list->vector", ProcedureFixed1);
+ DECLARE_FUNCTION("list->vector", procedure_fixed_1);
/* TOOD : canbe optimized. scanning list many times */
- if (FALSEP(ScmOp_listp(lst)))
+ if (FALSEP(scm_p_listp(lst)))
ERR_OBJ("list required but got", lst);
- scm_len = ScmOp_length(lst);
+ scm_len = scm_p_length(lst);
c_len = SCM_INT_VALUE(scm_len);
v = scm_malloc(sizeof(ScmObj) * c_len);
for (i = 0; i < c_len; i++) {
@@ -1583,14 +1674,15 @@
lst = CDR(lst);
}
- return Scm_NewVector(v, c_len);
+ return scm_make_vector(v, c_len);
}
-ScmObj ScmOp_vector_filld(ScmObj vec, ScmObj fill)
+ScmObj
+scm_p_vector_filld(ScmObj vec, ScmObj fill)
{
int c_len = 0;
int i = 0;
- DECLARE_FUNCTION("vector-fill!", ProcedureFixed2);
+ DECLARE_FUNCTION("vector-fill!", procedure_fixed_2);
ASSERT_VECTORP(vec);
@@ -1605,15 +1697,17 @@
/*=======================================
R5RS : 6.4 Control Features
=======================================*/
-ScmObj ScmOp_procedurep(ScmObj obj)
+ScmObj
+scm_p_procedurep(ScmObj obj)
{
- DECLARE_FUNCTION("procedure?", ProcedureFixed1);
+ DECLARE_FUNCTION("procedure?", procedure_fixed_1);
return (PROCEDUREP(obj)) ? SCM_TRUE : SCM_FALSE;
}
-ScmObj ScmOp_map(ScmObj proc, ScmObj args)
+ScmObj
+scm_p_map(ScmObj proc, ScmObj args)
{
- DECLARE_FUNCTION("map", ProcedureVariadic1);
+ DECLARE_FUNCTION("map", procedure_variadic_1);
if (NULLP(args))
ERR("map: wrong number of arguments");
@@ -1636,7 +1730,7 @@
SCM_QUEUE_POINT_TO(q, res);
while (!NO_MORE_ARG(lst)) {
elm = POP_ARG(lst);
- SCM_QUEUE_ADD(q, Scm_call(proc, LIST_1(elm)));
+ SCM_QUEUE_ADD(q, scm_call(proc, LIST_1(elm)));
}
return res;
@@ -1668,39 +1762,43 @@
if (!NULLP(rest_args))
ERR_OBJ("proper list required but got", args);
- SCM_QUEUE_ADD(resq, Scm_call(proc, map_args));
+ SCM_QUEUE_ADD(resq, scm_call(proc, map_args));
}
}
-ScmObj ScmOp_for_each(ScmObj proc, ScmObj args)
+ScmObj
+scm_p_for_each(ScmObj proc, ScmObj args)
{
- DECLARE_FUNCTION("for-each", ProcedureVariadic1);
- ScmOp_map(proc, args);
+ DECLARE_FUNCTION("for-each", procedure_variadic_1);
+ scm_p_map(proc, args);
return SCM_UNDEF;
}
-ScmObj ScmOp_force(ScmObj closure)
+ScmObj
+scm_p_force(ScmObj closure)
{
- DECLARE_FUNCTION("force", ProcedureFixed1);
+ DECLARE_FUNCTION("force", procedure_fixed_1);
ASSERT_CLOSUREP(closure);
- return Scm_call(closure, SCM_NULL);
+ return scm_call(closure, SCM_NULL);
}
-ScmObj ScmOp_call_with_current_continuation(ScmObj proc, ScmEvalState *eval_state)
+ScmObj
+scm_p_call_with_current_continuation(ScmObj proc, ScmEvalState *eval_state)
{
- DECLARE_FUNCTION("call-with-current-continuation", ProcedureFixedTailRec1);
+ DECLARE_FUNCTION("call-with-current-continuation", procedure_fixed_tailrec_1);
ASSERT_PROCEDUREP(proc);
- return Scm_CallWithCurrentContinuation(proc, eval_state);
+ return scm_call_with_current_continuation(proc, eval_state);
}
-ScmObj ScmOp_values(ScmObj args)
+ScmObj
+scm_p_values(ScmObj args)
{
- DECLARE_FUNCTION("values", ProcedureVariadic0);
+ DECLARE_FUNCTION("values", procedure_variadic_0);
/* Values with one arg must return something that fits an ordinary
* continuation. */
if (CONSP(args) && NULLP(CDR(args)))
@@ -1710,16 +1808,16 @@
return SCM_MAKE_VALUEPACKET(args);
}
-ScmObj ScmOp_call_with_values(ScmObj producer, ScmObj consumer,
+ScmObj scm_p_call_with_values(ScmObj producer, ScmObj consumer,
ScmEvalState *eval_state)
{
ScmObj vals;
- DECLARE_FUNCTION("call-with-values", ProcedureFixedTailRec2);
+ DECLARE_FUNCTION("call-with-values", procedure_fixed_tailrec_2);
ASSERT_PROCEDUREP(producer);
ASSERT_PROCEDUREP(consumer);
- vals = Scm_call(producer, SCM_NULL);
+ vals = scm_call(producer, SCM_NULL);
if (!VALUEPACKETP(vals)) {
/* got back a single value */
@@ -1729,18 +1827,19 @@
vals = SCM_VALUEPACKET_VALUES(vals);
}
- return Scm_tailcall(consumer, vals, eval_state);
+ return scm_tailcall(consumer, vals, eval_state);
}
-ScmObj ScmOp_dynamic_wind(ScmObj before, ScmObj thunk, ScmObj after)
+ScmObj
+scm_p_dynamic_wind(ScmObj before, ScmObj thunk, ScmObj after)
{
- DECLARE_FUNCTION("dynamic-wind", ProcedureFixed3);
+ DECLARE_FUNCTION("dynamic-wind", procedure_fixed_3);
ASSERT_PROCEDUREP(before);
ASSERT_PROCEDUREP(thunk);
ASSERT_PROCEDUREP(after);
- return Scm_DynamicWind(before, thunk, after);
+ return scm_dynamic_wind(before, thunk, after);
}
#if SCM_USE_DEEP_CADRS
Modified: branches/r5rs/sigscheme/print.c
===================================================================
--- branches/r5rs/sigscheme/print.c 2005-12-16 08:29:32 UTC (rev 2609)
+++ branches/r5rs/sigscheme/print.c 2005-12-16 09:06:42 UTC (rev 2610)
@@ -98,7 +98,7 @@
/*=======================================
Variable Declarations
=======================================*/
-void (*Scm_writess_func)(ScmObj port, ScmObj obj) = &SigScm_WriteToPort;
+void (*scm_writess_func)(ScmObj port, ScmObj obj) = &scm_write_to_port;
#if SCM_USE_SRFI38
static write_ss_context *write_ss_ctx; /* misc info in priting shared structures */
@@ -126,14 +126,16 @@
/*=======================================
Function Implementations
=======================================*/
-void SigScm_Display(ScmObj obj)
+void
+scm_display(ScmObj obj)
{
- SigScm_DisplayToPort(scm_current_output_port, obj);
+ scm_display_to_port(scm_current_output_port, obj);
}
-void SigScm_WriteToPort(ScmObj port, ScmObj obj)
+void
+scm_write_to_port(ScmObj port, ScmObj obj)
{
- DECLARE_INTERNAL_FUNCTION("SigScm_WriteToPort");
+ DECLARE_INTERNAL_FUNCTION("scm_write_to_port");
ASSERT_PORTP(port);
SCM_ASSERT_LIVE_PORT(port);
@@ -147,9 +149,10 @@
#endif /* SCM_VOLATILE_OUTPUT */
}
-void SigScm_DisplayToPort(ScmObj port, ScmObj obj)
+void
+scm_display_to_port(ScmObj port, ScmObj obj)
{
- DECLARE_INTERNAL_FUNCTION("SigScm_DisplayToPort");
+ DECLARE_INTERNAL_FUNCTION("scm_display_to_port");
ASSERT_PORTP(port);
SCM_ASSERT_LIVE_PORT(port);
@@ -172,19 +175,19 @@
int index = get_shared_index(obj);
if (index > 0) {
/* defined datum */
- SigScm_PortPrintf(port, "#%d#", index);
+ scm_port_printf(port, "#%d#", index);
return;
}
if (index < 0) {
/* defining datum, with the new index negated */
- SigScm_PortPrintf(port, "#%d=", -index);
+ scm_port_printf(port, "#%d=", -index);
/* Print it; the next time it'll be defined. */
}
}
#endif
switch (SCM_TYPE(obj)) {
case ScmInt:
- SigScm_PortPrintf(port, "%d", SCM_INT_VALUE(obj));
+ scm_port_printf(port, "%d", SCM_INT_VALUE(obj));
break;
case ScmCons:
if (ERROBJP(obj))
@@ -203,11 +206,11 @@
break;
case ScmFunc:
SCM_PORT_PUTS(port, (SCM_SYNTAXP(obj)) ? "#<syntax " : "#<subr ");
- sym = Scm_SymbolBoundTo(obj);
+ sym = scm_symbol_bound_to(obj);
if (NFALSEP(sym))
- SigScm_DisplayToPort(port, sym);
+ scm_display_to_port(port, sym);
else
- SigScm_PortPrintf(port, "%p", (void *)obj);
+ scm_port_printf(port, "%p", (void *)obj);
SCM_PORT_PUT_CHAR(port, '>');
break;
case ScmClosure:
@@ -243,10 +246,10 @@
ERR("You cannot print ScmFreeCell, may be GC bug.");
break;
case ScmCPointer:
- SigScm_PortPrintf(port, "#<c_pointer %p>", SCM_C_POINTER_VALUE(obj));
+ scm_port_printf(port, "#<c_pointer %p>", SCM_C_POINTER_VALUE(obj));
break;
case ScmCFuncPointer:
- SigScm_PortPrintf(port, "#<c_func_pointer %p>",
+ scm_port_printf(port, "#<c_func_pointer %p>",
(void *)(uintptr_t)SCM_C_FUNCPOINTER_VALUE(obj));
break;
}
@@ -262,7 +265,7 @@
case AS_WRITE:
SCM_PORT_PUTS(port, "#\\");
/* special chars */
- for (info = Scm_special_char_table; info->esc_seq; info++) {
+ for (info = scm_special_char_table; info->esc_seq; info++) {
if (c == info->code) {
SCM_PORT_PUTS(port, info->lex_rep);
return;
@@ -271,7 +274,7 @@
/* other control chars are printed in hexadecimal form */
if (isascii(c) && iscntrl(c)) {
- SigScm_PortPrintf(port, "x%02x", c);
+ scm_port_printf(port, "x%02x", c);
return;
}
/* FALLTHROUGH */
@@ -300,7 +303,7 @@
SCM_PORT_PUT_CHAR(port, '\"'); /* first doublequote */
for (i = 0; i < len; i++) {
c = str[i];
- for (info = Scm_special_char_table; info->esc_seq; info++) {
+ for (info = scm_special_char_table; info->esc_seq; info++) {
if (c == info->code) {
SCM_PORT_PUTS(port, info->esc_seq);
break;
@@ -354,12 +357,12 @@
index = get_shared_index(lst);
if (index > 0) {
/* defined datum */
- SigScm_PortPrintf(port, ". #%d#", index);
+ scm_port_printf(port, ". #%d#", index);
goto close_parens_and_return;
}
if (index < 0) {
/* defining datum, with the new index negated */
- SigScm_PortPrintf(port, ". #%d=", -index);
+ scm_port_printf(port, ". #%d=", -index);
necessary_close_parens++;
goto cheap_recursion;
}
@@ -462,11 +465,11 @@
switch (otype) {
case AS_WRITE:
SCM_PORT_PUTS(port, "#<error ");
- SigScm_WriteToPort(port, reason);
+ scm_write_to_port(port, reason);
break;
case AS_DISPLAY:
- SigScm_DisplayToPort(port, reason);
+ scm_display_to_port(port, reason);
if (CONSP(objs))
SCM_PORT_PUT_CHAR(port, ':');
break;
@@ -478,7 +481,7 @@
for (; CONSP(objs); objs = CDR(objs)) {
SCM_PORT_PUT_CHAR(port, ' ');
- SigScm_WriteToPort(port, CAR(objs));
+ scm_write_to_port(port, CAR(objs));
}
if (otype == AS_WRITE)
@@ -633,7 +636,8 @@
return 0;
}
-void SigScm_WriteToPortWithSharedStructure(ScmObj port, ScmObj obj)
+void
+scm_write_to_port_with_shared_structure(ScmObj port, ScmObj obj)
{
write_ss_context ctx = {{0}};
unsigned int i;
@@ -651,7 +655,7 @@
if (!HASH_EMPTY(ctx.seen))
write_ss_ctx = &ctx;
- SigScm_WriteToPort(port, obj);
+ scm_write_to_port(port, obj);
write_ss_ctx = NULL;
free(ctx.seen.ents);
Modified: branches/r5rs/sigscheme/read.c
===================================================================
--- branches/r5rs/sigscheme/read.c 2005-12-16 08:29:32 UTC (rev 2609)
+++ branches/r5rs/sigscheme/read.c 2005-12-16 09:06:42 UTC (rev 2610)
@@ -77,7 +77,7 @@
/*=======================================
Variable Declarations
=======================================*/
-const ScmSpecialCharInfo Scm_special_char_table[] = {
+const ScmSpecialCharInfo scm_special_char_table[] = {
/* printable characters */
{'\"', "\\\"", "\""}, /* 34, R5RS */
{'\\', "\\\\", "\\"}, /* 92, R5RS */
@@ -136,27 +136,29 @@
/*===========================================================================
S-Expression Parser
===========================================================================*/
-ScmObj SigScm_Read(ScmObj port)
+ScmObj
+scm_read(ScmObj port)
{
ScmObj sexp = SCM_FALSE;
- DECLARE_INTERNAL_FUNCTION("SigScm_Read");
+ DECLARE_INTERNAL_FUNCTION("scm_read");
ASSERT_PORTP(port);
sexp = read_sexpression(port);
#if SCM_DEBUG
- if ((SigScm_DebugCategories() & SCM_DBG_READ) && !EOFP(sexp)) {
- SigScm_WriteToPort(scm_current_error_port, sexp);
- SigScm_ErrorNewline();
+ if ((scm_debug_categories() & SCM_DBG_READ) && !EOFP(sexp)) {
+ scm_write_to_port(scm_current_error_port, sexp);
+ scm_error_newline();
}
#endif
return sexp;
}
-ScmObj SigScm_Read_Char(ScmObj port)
+ScmObj
+scm_read_char(ScmObj port)
{
- DECLARE_INTERNAL_FUNCTION("SigScm_Read_Char");
+ DECLARE_INTERNAL_FUNCTION("scm_read_char");
ASSERT_PORTP(port);
@@ -238,8 +240,8 @@
*err = TOKEN_BUF_EXCEEDED;
break;
}
- /* FIXME: check Unicode capability of Scm_current_char_codec */
- p = SCM_CHARCODEC_INT2STR(Scm_current_char_codec,
+ /* FIXME: check Unicode capability of scm_current_char_codec */
+ p = SCM_CHARCODEC_INT2STR(scm_current_char_codec,
p, c, SCM_MB_STATELESS);
#else
ERR("non-ASCII char in token: 0x%x", c);
@@ -287,7 +289,7 @@
case 'f':
return SCM_FALSE;
case '(':
- return ScmOp_list2vector(read_list(port, ')'));
+ return scm_p_list2vector(read_list(port, ')'));
case '\\':
return read_char(port);
case 'b': case 'o': case 'd': case 'x':
@@ -401,7 +403,7 @@
SCM_QUEUE_SLOPPY_APPEND(q, cdr);
return lst;
} else if (strcmp(dot_buf, "...") == 0) {
- elm = Scm_Intern(dot_buf);
+ elm = scm_intern(dot_buf);
} else {
ERR("bad dot syntax");
}
@@ -480,7 +482,7 @@
c = SCM_PORT_GET_CHAR(port);
next = SCM_PORT_PEEK_CHAR(port);
if (strchr(DELIMITER_CHARS, next) || next == EOF)
- return Scm_NewChar(c);
+ return scm_make_char(c);
#if SCM_USE_SRFI75
else if (!isascii(c))
ERR("invalid character literal");
@@ -496,12 +498,12 @@
#if SCM_USE_SRFI75
unicode = parse_unicode_sequence(buf, len + 1);
if (0 <= unicode)
- return Scm_NewChar(unicode);
+ return scm_make_char(unicode);
#endif
/* named chars */
- for (info = Scm_special_char_table; info->esc_seq; info++) {
+ for (info = scm_special_char_table; info->esc_seq; info++) {
if (strcmp(buf, info->lex_rep) == 0)
- return Scm_NewChar(info->code);
+ return scm_make_char(info->code);
}
ERR("invalid character literal: #\\%s", buf);
}
@@ -535,7 +537,7 @@
case '\"':
LBUF_EXTEND(lbuf, SCM_LBUF_F_STRING, offset + 1);
*p = '\0';
- obj = Scm_NewImmutableStringCopying(LBUF_BUF(lbuf));
+ obj = scm_make_immutable_string_copying(LBUF_BUF(lbuf));
LBUF_FREE(lbuf);
return obj;
@@ -546,8 +548,8 @@
c = read_unicode_sequence(port, c);
LBUF_EXTEND(lbuf, SCM_LBUF_F_STRING, offset + MB_MAX_SIZE);
p = &LBUF_BUF(lbuf)[offset];
- /* FIXME: check Unicode capability of Scm_current_char_codec */
- p = SCM_CHARCODEC_INT2STR(Scm_current_char_codec,
+ /* FIXME: check Unicode capability of scm_current_char_codec */
+ p = SCM_CHARCODEC_INT2STR(scm_current_char_codec,
p, c, SCM_MB_STATELESS);
if (!p)
ERR("invalid Unicode sequence in string: 0x%x", c);
@@ -556,7 +558,7 @@
#endif
{
/* escape sequences */
- for (info = Scm_special_char_table; info->esc_seq; info++) {
+ for (info = scm_special_char_table; info->esc_seq; info++) {
if (strlen(info->esc_seq) == 2 && c == info->esc_seq[1]) {
LBUF_EXTEND(lbuf, SCM_LBUF_F_STRING, offset + 1);
p = &LBUF_BUF(lbuf)[offset];
@@ -573,7 +575,7 @@
LBUF_EXTEND(lbuf, SCM_LBUF_F_STRING, offset + MB_MAX_SIZE);
p = &LBUF_BUF(lbuf)[offset];
/* FIXME: support stateful encoding */
- p = SCM_CHARCODEC_INT2STR(Scm_current_char_codec,
+ p = SCM_CHARCODEC_INT2STR(scm_current_char_codec,
p, c, SCM_MB_STATELESS);
if (!p)
ERR("invalid char in string: 0x%x", c);
@@ -608,7 +610,7 @@
LBUF_EXTEND(lbuf, SCM_LBUF_F_SYMBOL, LBUF_SIZE(lbuf) + MB_MAX_SIZE);
}
- sym = Scm_Intern(LBUF_BUF(lbuf));
+ sym = scm_intern(LBUF_BUF(lbuf));
LBUF_FREE(lbuf);
return sym;
@@ -633,14 +635,14 @@
if (err == TOKEN_BUF_EXCEEDED)
ERR("invalid number literal");
if (!buf[1])
- return Scm_Intern(buf);
+ return scm_intern(buf);
return parse_number(port, buf, sizeof(buf), 'd');
}
if (c == '.') {
read_token(port, &err, buf, sizeof(buf), DELIMITER_CHARS);
if (strcmp(buf, "...") == 0)
- return Scm_Intern(buf);
+ return scm_intern(buf);
/* TODO: support numeric expressions when the numeric tower is
implemented */
ERR("invalid identifier: %s", buf);
@@ -673,7 +675,7 @@
if (*first_nondigit)
goto err;
- return Scm_NewInt(number);
+ return scm_make_int(number);
err:
ERR("ill-formatted number: #%c%s", prefix, buf);
Modified: branches/r5rs/sigscheme/sbcport.c
===================================================================
--- branches/r5rs/sigscheme/sbcport.c 2005-12-16 08:29:32 UTC (rev 2609)
+++ branches/r5rs/sigscheme/sbcport.c 2005-12-16 09:06:42 UTC (rev 2610)
@@ -82,7 +82,7 @@
Function Implementations
=======================================*/
void
-Scm_sbcport_init(void)
+scm_sbcport_init(void)
{
ScmCharPortVTbl *vptr;
Modified: branches/r5rs/sigscheme/sbcport.h
===================================================================
--- branches/r5rs/sigscheme/sbcport.h 2005-12-16 08:29:32 UTC (rev 2609)
+++ branches/r5rs/sigscheme/sbcport.h 2005-12-16 09:06:42 UTC (rev 2610)
@@ -66,7 +66,7 @@
/*=======================================
Function Declarations
=======================================*/
-void Scm_sbcport_init(void);
+void scm_sbcport_init(void);
void ScmSingleByteCharPort_construct(ScmSingleByteCharPort *port,
const ScmCharPortVTbl *vptr,
Modified: branches/r5rs/sigscheme/script/scm_decl.rb
===================================================================
--- branches/r5rs/sigscheme/script/scm_decl.rb 2005-12-16 08:29:32 UTC (rev 2609)
+++ branches/r5rs/sigscheme/script/scm_decl.rb 2005-12-16 09:06:42 UTC (rev 2610)
@@ -42,7 +42,7 @@
# $8 :register_func ProcedureFixedTailRec2
# $9 :functype_prefix Procedure
# $10 :functype_spec FixedTailRec2
-SCM_DECL_RE = /\n((ScmObj)\s+(Scm(Op|Exp)_(\w+))\(([^{]+)\))[ \t]*\n\s*\{[^{}]+DECLARE_FUNCTION\(\s*\"([^\"]+)\"[\s,]+([^\s,]+)\)/m
+SCM_DECL_RE = /\n((ScmObj)\s+(scm_([sp])_(\w+))\(([^{]+)\))[ \t]*\n\s*\{[^{}]+DECLARE_FUNCTION\(\s*\"([^\"]+)\"[\s,]+([^\s,]+)\)/m
class String
@@ -57,7 +57,7 @@
:func_body => func_body,
:args => args.gsub(/\s+/, " "),
:proc => proc,
- :register_func => "Scm_Register" + register_func,
+ :register_func => "scm_register_" + register_func,
:functype_prefix => functype_prefix,
:functype_spec => functype_spec,
}
Modified: branches/r5rs/sigscheme/sigscheme.c
===================================================================
--- branches/r5rs/sigscheme/sigscheme.c 2005-12-16 08:29:32 UTC (rev 2609)
+++ branches/r5rs/sigscheme/sigscheme.c 2005-12-16 09:06:42 UTC (rev 2610)
@@ -60,47 +60,47 @@
/*=======================================
Variable Declarations
=======================================*/
-ScmObj Scm_sym_quote, Scm_sym_quasiquote;
-ScmObj Scm_sym_unquote, Scm_sym_unquote_splicing;
-ScmObj Scm_sym_else, Scm_sym_yields;
+ScmObj scm_sym_quote, scm_sym_quasiquote;
+ScmObj scm_sym_unquote, scm_sym_unquote_splicing;
+ScmObj scm_sym_else, scm_sym_yields;
static int scm_initialized;
static ScmObj features;
#if SCM_COMPAT_SIOD
-static ScmObj scm_return_value = NULL;
+static ScmObj scm_return_value_cache = NULL;
#endif
static struct module_info module_info_table[] = {
#if SCM_USE_NONSTD_FEATURES
- {"sscm", SigScm_Initialize_NONSTD_FEATURES},
+ {"sscm", scm_initialize_nonstd_features},
#endif
#if SCM_USE_SRFI1
- {"srfi-1", SigScm_Initialize_SRFI1},
+ {"srfi-1", scm_initialize_srfi1},
#endif
#if SCM_USE_SRFI2
- {"srfi-2", SigScm_Initialize_SRFI2},
+ {"srfi-2", scm_initialize_srfi2},
#endif
#if SCM_USE_SRFI6
- {"srfi-6", SigScm_Initialize_SRFI6},
+ {"srfi-6", scm_initialize_srfi6},
#endif
#if SCM_USE_SRFI8
- {"srfi-8", SigScm_Initialize_SRFI8},
+ {"srfi-8", scm_initialize_srfi8},
#endif
#if SCM_USE_SRFI23
- {"srfi-23", SigScm_Initialize_SRFI23},
+ {"srfi-23", scm_initialize_srfi23},
#endif
#if SCM_USE_SRFI34
- {"srfi-34", SigScm_Initialize_SRFI34},
+ {"srfi-34", scm_initialize_srfi34},
#endif
#if SCM_USE_SRFI38
- {"srfi-38", SigScm_Initialize_SRFI38},
+ {"srfi-38", scm_initialize_srfi38},
#endif
#if SCM_USE_SRFI60
- {"srfi-60", SigScm_Initialize_SRFI60},
+ {"srfi-60", scm_initialize_srfi60},
#endif
#if SCM_COMPAT_SIOD
- {"siod", SigScm_Initialize_SIOD},
+ {"siod", scm_initialize_siod},
#endif
{NULL, NULL}
};
@@ -108,49 +108,51 @@
/*=======================================
File Local Function Declarations
=======================================*/
-static void SigScm_Initialize_internal(void);
-static int Scm_RegisterFunc(const char *name, ScmFuncType func, enum ScmFuncTypeCode type);
-static ScmObj Scm_eval_c_string_internal(const char *exp);
+static void scm_initialize_internal(void);
+static int scm_register_func(const char *name, ScmFuncType func, enum ScmFuncTypeCode type);
+static ScmObj scm_eval_c_string_internal(const char *exp);
/*=======================================
Function Implementations
=======================================*/
-void SigScm_Initialize(void)
+void
+scm_initialize(void)
{
#if SCM_GCC4_READY_GC
- SCM_GC_PROTECTED_CALL_VOID(SigScm_Initialize_internal, ());
+ SCM_GC_PROTECTED_CALL_VOID(scm_initialize_internal, ());
#else
ScmObj stack_start;
- SigScm_GC_ProtectStack(&stack_start);
- SigScm_Initialize_internal();
- SigScm_GC_UnprotectStack(&stack_start);
+ scm_gc_protect_stack(&stack_start);
+ scm_initialize_internal();
+ scm_gc_unprotect_stack(&stack_start);
#endif
}
-static void SigScm_Initialize_internal(void)
+static void
+scm_initialize_internal(void)
{
/*=======================================================================
Core
=======================================================================*/
- SigScm_SetDebugCategories(SCM_DBG_ERRMSG | SCM_DBG_BACKTRACE
- | SigScm_PredefinedDebugCategories());
+ scm_set_debug_categories(SCM_DBG_ERRMSG | SCM_DBG_BACKTRACE
+ | scm_predefined_debug_categories());
/* FIXME: make configurable from libsscm client */
- SigScm_InitStorage(0x4000, 0x2000, 0x800, 1);
- SigScm_InitError();
- Scm_InitIO();
+ scm_init_storage(0x4000, 0x2000, 0x800, 1);
+ scm_init_error();
+ scm_init_io();
/*=======================================================================
Predefined Symbols and Variables
=======================================================================*/
- Scm_sym_quote = Scm_Intern("quote");
- Scm_sym_quasiquote = Scm_Intern("quasiquote");
- Scm_sym_unquote = Scm_Intern("unquote");
- Scm_sym_unquote_splicing = Scm_Intern("unquote-splicing");
- Scm_sym_else = Scm_Intern("else");
- Scm_sym_yields = Scm_Intern("=>");
+ scm_sym_quote = scm_intern("quote");
+ scm_sym_quasiquote = scm_intern("quasiquote");
+ scm_sym_unquote = scm_intern("unquote");
+ scm_sym_unquote_splicing = scm_intern("unquote-splicing");
+ scm_sym_else = scm_intern("else");
+ scm_sym_yields = scm_intern("=>");
- SigScm_GC_Protect(&features);
+ scm_gc_protect(&features);
features = SCM_NULL;
/*=======================================================================
@@ -158,59 +160,64 @@
=======================================================================*/
/* R5RS Functions */
REGISTER_FUNC_TABLE(r5rs_func_info_table);
- Scm_DefineAlias("integer?", "number?");
+ scm_define_alias("integer?", "number?");
#if SCM_USE_DEEP_CADRS
/* Deep c[ad]+r Functions */
REGISTER_FUNC_TABLE(r5rs_deepcadrs_func_info_table);
#endif
#if SCM_USE_NONSTD_FEATURES
- Scm_Use("sscm");
+ scm_use("sscm");
#endif
/*=======================================================================
Fixing up
=======================================================================*/
/* to evaluate SigScheme-dependent codes conditionally */
- Scm_Provide(Scm_NewImmutableStringCopying("sigscheme"));
+ scm_provide(scm_make_immutable_string_copying("sigscheme"));
#if SCM_STRICT_R5RS
- Scm_Provide(Scm_NewImmutableStringCopying("strict-r5rs"));
+ scm_provide(scm_make_immutable_string_copying("strict-r5rs"));
#endif
#if SCM_COMPAT_SIOD_BUGS
- Scm_Provide(Scm_NewImmutableStringCopying("siod-bugs"));
+ scm_provide(scm_make_immutable_string_copying("siod-bugs"));
#endif
scm_initialized = TRUE;
}
-void SigScm_Finalize()
+void
+scm_finalize()
{
- SigScm_FinalizeStorage();
+ scm_finalize_storage();
scm_initialized = FALSE;
}
-void Scm_DefineAlias(const char *newsym, const char *sym)
+void
+scm_define_alias(const char *newsym, const char *sym)
{
- SCM_SYMBOL_SET_VCELL(Scm_Intern(newsym),
- SCM_SYMBOL_VCELL(Scm_Intern(sym)));
+ SCM_SYMBOL_SET_VCELL(scm_intern(newsym),
+ SCM_SYMBOL_VCELL(scm_intern(sym)));
}
-void Scm_Provide(ScmObj feature)
+void
+scm_provide(ScmObj feature)
{
features = CONS(feature, features);
}
-int Scm_Providedp(ScmObj feature)
+int
+scm_providedp(ScmObj feature)
{
- return NFALSEP(ScmOp_member(feature, features));
+ return NFALSEP(scm_p_member(feature, features));
}
-int Scm_Use(const char *feature)
+int
+scm_use(const char *feature)
{
ScmObj ok;
SCM_ASSERT(feature);
- ok = ScmExp_use(Scm_Intern(feature), SCM_INTERACTION_ENV);
+ ok = scm_s_use(scm_intern(feature), SCM_INTERACTION_ENV);
return NFALSEP(ok);
}
@@ -226,20 +233,21 @@
* - Make the module_info_table dynamically registerable for dynamic loadable
* objects (if necessary)
*/
-ScmObj ScmExp_use(ScmObj feature, ScmObj env)
+ScmObj
+scm_s_use(ScmObj feature, ScmObj env)
{
struct module_info *mod;
ScmObj feature_str;
- DECLARE_FUNCTION("use", SyntaxFixed1);
+ DECLARE_FUNCTION("use", syntax_fixed_1);
ASSERT_SYMBOLP(feature);
for (mod = module_info_table; mod->name; mod++) {
- if (EQ(feature, Scm_Intern(mod->name))) {
- feature_str = ScmOp_symbol2string(feature);
- if (FALSEP(ScmOp_providedp(feature_str))) {
+ if (EQ(feature, scm_intern(mod->name))) {
+ feature_str = scm_p_symbol2string(feature);
+ if (FALSEP(scm_p_providedp(feature_str))) {
(*mod->initializer)();
- ScmOp_provide(feature_str);
+ scm_p_provide(feature_str);
}
return SCM_TRUE;
}
@@ -248,7 +256,8 @@
return SCM_FALSE;
}
-ScmObj Scm_eval_c_string(const char *exp)
+ScmObj
+scm_eval_c_string(const char *exp)
{
#if !SCM_GCC4_READY_GC
ScmObj stack_start;
@@ -256,54 +265,57 @@
ScmObj ret;
#if SCM_GCC4_READY_GC
- SCM_GC_PROTECTED_CALL(ret, ScmObj, Scm_eval_c_string_internal, (exp));
+ SCM_GC_PROTECTED_CALL(ret, ScmObj, scm_eval_c_string_internal, (exp));
#else
/* start protecting stack */
- SigScm_GC_ProtectStack(&stack_start);
+ scm_gc_protect_stack(&stack_start);
- ret = Scm_eval_c_string_internal(exp);
+ ret = scm_eval_c_string_internal(exp);
/* now no need to protect stack */
- SigScm_GC_UnprotectStack(&stack_start);
+ scm_gc_unprotect_stack(&stack_start);
#endif
return ret;
}
-ScmObj Scm_eval_c_string_internal(const char *exp)
+ScmObj
+scm_eval_c_string_internal(const char *exp)
{
ScmObj str_port, ret;
ScmBytePort *bport;
bport = ScmInputStrPort_new_const(exp, NULL);
- str_port = Scm_NewPort(Scm_NewCharPort(bport), SCM_PORTFLAG_INPUT);
+ str_port = scm_make_port(scm_make_char_port(bport), SCM_PORTFLAG_INPUT);
- ret = SigScm_Read(str_port);
+ ret = scm_read(str_port);
ret = EVAL(ret, SCM_INTERACTION_ENV);
#if SCM_COMPAT_SIOD
- scm_return_value = ret;
+ scm_return_value_cache = ret;
#endif
return ret;
}
#if SCM_COMPAT_SIOD
-ScmObj Scm_return_value(void)
+ScmObj
+scm_return_value(void)
{
- return scm_return_value;
+ return scm_return_value_cache;
}
#endif
/* TODO: parse properly */
/* don't access ScmObj if (!scm_initialized) */
-char **Scm_InterpretArgv(char **argv)
+char **
+scm_interpret_argv(char **argv)
{
char **argp, **rest;
const char *encoding;
ScmCharCodec *specified_codec;
ScmObj err_obj;
- DECLARE_INTERNAL_FUNCTION("Scm_InterpretArgv");
+ DECLARE_INTERNAL_FUNCTION("scm_interpret_argv");
encoding = NULL;
argp = (strcmp(argv[0], "/usr/bin/env") == 0) ? &argv[2] : &argv[1];
@@ -330,11 +342,11 @@
rest = argp;
if (encoding) {
- specified_codec = Scm_mb_find_codec(encoding);
+ specified_codec = scm_mb_find_codec(encoding);
if (!specified_codec) {
if (scm_initialized) {
- err_obj = Scm_NewImmutableStringCopying(encoding);
- Scm_FreeArgv(argv);
+ err_obj = scm_make_immutable_string_copying(encoding);
+ scm_free_argv(argv);
ERR_OBJ("unsupported encoding", err_obj);
} else {
fprintf(stderr, "%sunsupported encoding: %s\n",
@@ -342,13 +354,14 @@
exit(EXIT_FAILURE);
}
}
- Scm_current_char_codec = specified_codec;
+ scm_current_char_codec = specified_codec;
}
return rest;
}
-void Scm_FreeArgv(char **argv)
+void
+scm_free_argv(char **argv)
{
char **argp;
@@ -362,10 +375,11 @@
Scheme Function Export Related Functions
===========================================================================*/
/* New Interfaces */
-static int Scm_RegisterFunc(const char *name, ScmFuncType c_func, enum ScmFuncTypeCode type)
+static int
+scm_register_func(const char *name, ScmFuncType c_func, enum ScmFuncTypeCode type)
{
- ScmObj sym = Scm_Intern(name);
- ScmObj func = Scm_NewFunc(type, c_func);
+ ScmObj sym = scm_intern(name);
+ ScmObj func = scm_make_func(type, c_func);
/* TODO: reject bad TYPE */
SCM_SYMBOL_SET_VCELL(sym, func);
@@ -373,329 +387,329 @@
}
/* Not implemented yet. */
-void Scm_RegisterReductionOperator(const char *name, ScmObj (*func)(ScmObj, ScmObj, enum ScmReductionState*))
+void scm_register_reduction_operator(const char *name, ScmObj (*func)(ScmObj, ScmObj, enum ScmReductionState*))
{
- Scm_RegisterFunc(name, func, SCM_REDUCTION_OPERATOR);
+ scm_register_func(name, func, SCM_REDUCTION_OPERATOR);
}
/* So, yeah, um... this isn't really such a big deal if you think
* about W32.... */
-void Scm_RegisterSyntaxFixed0(const char *name, ScmObj (*func)(ScmObj))
+void scm_register_syntax_fixed_0(const char *name, ScmObj (*func)(ScmObj))
{
- Scm_RegisterFunc(name, func, SCM_SYNTAX_FIXED | 0);
+ scm_register_func(name, func, SCM_SYNTAX_FIXED | 0);
}
#if SCM_FUNCTYPE_MAND_MAX >= 1
-void Scm_RegisterSyntaxFixed1(const char *name, ScmObj (*func)(ScmObj, ScmObj))
+void scm_register_syntax_fixed_1(const char *name, ScmObj (*func)(ScmObj, ScmObj))
{
- Scm_RegisterFunc(name, func, SCM_SYNTAX_FIXED | 1);
+ scm_register_func(name, func, SCM_SYNTAX_FIXED | 1);
}
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 2
-void Scm_RegisterSyntaxFixed2(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj))
+void scm_register_syntax_fixed_2(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj))
{
- Scm_RegisterFunc(name, func, SCM_SYNTAX_FIXED | 2);
+ scm_register_func(name, func, SCM_SYNTAX_FIXED | 2);
}
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 3
-void Scm_RegisterSyntaxFixed3(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj))
+void scm_register_syntax_fixed_3(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj))
{
- Scm_RegisterFunc(name, func, SCM_SYNTAX_FIXED | 3);
+ scm_register_func(name, func, SCM_SYNTAX_FIXED | 3);
}
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 4
-void Scm_RegisterSyntaxFixed4(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj))
+void scm_register_syntax_fixed_4(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj))
{
- Scm_RegisterFunc(name, func, SCM_SYNTAX_FIXED | 4);
+ scm_register_func(name, func, SCM_SYNTAX_FIXED | 4);
}
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 5
-void Scm_RegisterSyntaxFixed5(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmObj))
+void scm_register_syntax_fixed_5(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmObj))
{
- Scm_RegisterFunc(name, func, SCM_SYNTAX_FIXED | 5);
+ scm_register_func(name, func, SCM_SYNTAX_FIXED | 5);
}
#endif
-void Scm_RegisterSyntaxFixedTailRec0(const char *name, ScmObj (*func)(ScmEvalState*))
+void scm_register_syntax_fixed_tailrec_0(const char *name, ScmObj (*func)(ScmEvalState*))
{
- Scm_RegisterFunc(name, func, SCM_SYNTAX_FIXED_TAIL_REC | 0);
+ scm_register_func(name, func, SCM_SYNTAX_FIXED_TAIL_REC | 0);
}
#if SCM_FUNCTYPE_MAND_MAX >= 1
-void Scm_RegisterSyntaxFixedTailRec1(const char *name, ScmObj (*func)(ScmObj, ScmEvalState*))
+void scm_register_syntax_fixed_tailrec_1(const char *name, ScmObj (*func)(ScmObj, ScmEvalState*))
{
- Scm_RegisterFunc(name, func, SCM_SYNTAX_FIXED_TAIL_REC | 1);
+ scm_register_func(name, func, SCM_SYNTAX_FIXED_TAIL_REC | 1);
}
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 2
-void Scm_RegisterSyntaxFixedTailRec2(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmEvalState*))
+void scm_register_syntax_fixed_tailrec_2(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmEvalState*))
{
- Scm_RegisterFunc(name, func, SCM_SYNTAX_FIXED_TAIL_REC | 2);
+ scm_register_func(name, func, SCM_SYNTAX_FIXED_TAIL_REC | 2);
}
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 3
-void Scm_RegisterSyntaxFixedTailRec3(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmEvalState*))
+void scm_register_syntax_fixed_tailrec_3(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmEvalState*))
{
- Scm_RegisterFunc(name, func, SCM_SYNTAX_FIXED_TAIL_REC | 3);
+ scm_register_func(name, func, SCM_SYNTAX_FIXED_TAIL_REC | 3);
}
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 4
-void Scm_RegisterSyntaxFixedTailRec4(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState*))
+void scm_register_syntax_fixed_tailrec_4(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState*))
{
- Scm_RegisterFunc(name, func, SCM_SYNTAX_FIXED_TAIL_REC | 4);
+ scm_register_func(name, func, SCM_SYNTAX_FIXED_TAIL_REC | 4);
}
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 5
-void Scm_RegisterSyntaxFixedTailRec5(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState*))
+void scm_register_syntax_fixed_tailrec_5(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState*))
{
- Scm_RegisterFunc(name, func, SCM_SYNTAX_FIXED_TAIL_REC | 5);
+ scm_register_func(name, func, SCM_SYNTAX_FIXED_TAIL_REC | 5);
}
#endif
-void Scm_RegisterSyntaxVariadic0(const char *name, ScmObj (*func)(ScmObj, ScmObj))
+void scm_register_syntax_variadic_0(const char *name, ScmObj (*func)(ScmObj, ScmObj))
{
- Scm_RegisterFunc(name, func, SCM_SYNTAX_VARIADIC | 0);
+ scm_register_func(name, func, SCM_SYNTAX_VARIADIC | 0);
}
#if SCM_FUNCTYPE_MAND_MAX >= 1
-void Scm_RegisterSyntaxVariadic1(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj))
+void scm_register_syntax_variadic_1(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj))
{
- Scm_RegisterFunc(name, func, SCM_SYNTAX_VARIADIC | 1);
+ scm_register_func(name, func, SCM_SYNTAX_VARIADIC | 1);
}
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 2
-void Scm_RegisterSyntaxVariadic2(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj))
+void scm_register_syntax_variadic_2(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj))
{
- Scm_RegisterFunc(name, func, SCM_SYNTAX_VARIADIC | 2);
+ scm_register_func(name, func, SCM_SYNTAX_VARIADIC | 2);
}
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 3
-void Scm_RegisterSyntaxVariadic3(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj))
+void scm_register_syntax_variadic_3(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj))
{
- Scm_RegisterFunc(name, func, SCM_SYNTAX_VARIADIC | 3);
+ scm_register_func(name, func, SCM_SYNTAX_VARIADIC | 3);
}
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 4
-void Scm_RegisterSyntaxVariadic4(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmObj))
+void scm_register_syntax_variadic_4(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmObj))
{
- Scm_RegisterFunc(name, func, SCM_SYNTAX_VARIADIC | 4);
+ scm_register_func(name, func, SCM_SYNTAX_VARIADIC | 4);
}
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 5
-void Scm_RegisterSyntaxVariadic5(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmObj))
+void scm_register_syntax_variadic_5(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmObj))
{
- Scm_RegisterFunc(name, func, SCM_SYNTAX_VARIADIC | 5);
+ scm_register_func(name, func, SCM_SYNTAX_VARIADIC | 5);
}
#endif
-void Scm_RegisterSyntaxVariadicTailRec0(const char *name, ScmObj (*func)(ScmObj, ScmEvalState*))
+void scm_register_syntax_variadic_tailrec_0(const char *name, ScmObj (*func)(ScmObj, ScmEvalState*))
{
- Scm_RegisterFunc(name, func, SCM_SYNTAX_VARIADIC_TAIL_REC | 0);
+ scm_register_func(name, func, SCM_SYNTAX_VARIADIC_TAIL_REC | 0);
}
#if SCM_FUNCTYPE_MAND_MAX >= 1
-void Scm_RegisterSyntaxVariadicTailRec1(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmEvalState*))
+void scm_register_syntax_variadic_tailrec_1(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmEvalState*))
{
- Scm_RegisterFunc(name, func, SCM_SYNTAX_VARIADIC_TAIL_REC | 1);
+ scm_register_func(name, func, SCM_SYNTAX_VARIADIC_TAIL_REC | 1);
}
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 2
-void Scm_RegisterSyntaxVariadicTailRec2(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmEvalState*))
+void scm_register_syntax_variadic_tailrec_2(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmEvalState*))
{
- Scm_RegisterFunc(name, func, SCM_SYNTAX_VARIADIC_TAIL_REC | 2);
+ scm_register_func(name, func, SCM_SYNTAX_VARIADIC_TAIL_REC | 2);
}
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 3
-void Scm_RegisterSyntaxVariadicTailRec3(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState*))
+void scm_register_syntax_variadic_tailrec_3(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState*))
{
- Scm_RegisterFunc(name, func, SCM_SYNTAX_VARIADIC_TAIL_REC | 3);
+ scm_register_func(name, func, SCM_SYNTAX_VARIADIC_TAIL_REC | 3);
}
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 4
-void Scm_RegisterSyntaxVariadicTailRec4(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState*))
+void scm_register_syntax_variadic_tailrec_4(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState*))
{
- Scm_RegisterFunc(name, func, SCM_SYNTAX_VARIADIC_TAIL_REC | 4);
+ scm_register_func(name, func, SCM_SYNTAX_VARIADIC_TAIL_REC | 4);
}
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 5
-void Scm_RegisterSyntaxVariadicTailRec5(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState*))
+void scm_register_syntax_variadic_tailrec_5(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState*))
{
- Scm_RegisterFunc(name, func, SCM_SYNTAX_VARIADIC_TAIL_REC | 5);
+ scm_register_func(name, func, SCM_SYNTAX_VARIADIC_TAIL_REC | 5);
}
#endif
-void Scm_RegisterProcedureFixed0(const char *name, ScmObj (*func)())
+void scm_register_procedure_fixed_0(const char *name, ScmObj (*func)())
{
- Scm_RegisterFunc(name, func, SCM_PROCEDURE_FIXED | 0);
+ scm_register_func(name, func, SCM_PROCEDURE_FIXED | 0);
}
#if SCM_FUNCTYPE_MAND_MAX >= 1
-void Scm_RegisterProcedureFixed1(const char *name, ScmObj (*func)(ScmObj))
+void scm_register_procedure_fixed_1(const char *name, ScmObj (*func)(ScmObj))
{
- Scm_RegisterFunc(name, func, SCM_PROCEDURE_FIXED | 1);
+ scm_register_func(name, func, SCM_PROCEDURE_FIXED | 1);
}
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 2
-void Scm_RegisterProcedureFixed2(const char *name, ScmObj (*func)(ScmObj, ScmObj))
+void scm_register_procedure_fixed_2(const char *name, ScmObj (*func)(ScmObj, ScmObj))
{
- Scm_RegisterFunc(name, func, SCM_PROCEDURE_FIXED | 2);
+ scm_register_func(name, func, SCM_PROCEDURE_FIXED | 2);
}
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 3
-void Scm_RegisterProcedureFixed3(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj))
+void scm_register_procedure_fixed_3(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj))
{
- Scm_RegisterFunc(name, func, SCM_PROCEDURE_FIXED | 3);
+ scm_register_func(name, func, SCM_PROCEDURE_FIXED | 3);
}
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 4
-void Scm_RegisterProcedureFixed4(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj))
+void scm_register_procedure_fixed_4(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj))
{
- Scm_RegisterFunc(name, func, SCM_PROCEDURE_FIXED | 4);
+ scm_register_func(name, func, SCM_PROCEDURE_FIXED | 4);
}
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 5
-void Scm_RegisterProcedureFixed5(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj))
+void scm_register_procedure_fixed_5(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj))
{
- Scm_RegisterFunc(name, func, SCM_PROCEDURE_FIXED | 5);
+ scm_register_func(name, func, SCM_PROCEDURE_FIXED | 5);
}
#endif
-void Scm_RegisterProcedureFixedTailRec0(const char *name, ScmObj (*func)(ScmEvalState*))
+void scm_register_procedure_fixed_tailrec_0(const char *name, ScmObj (*func)(ScmEvalState*))
{
- Scm_RegisterFunc(name, func, SCM_PROCEDURE_FIXED_TAIL_REC | 0);
+ scm_register_func(name, func, SCM_PROCEDURE_FIXED_TAIL_REC | 0);
}
#if SCM_FUNCTYPE_MAND_MAX >= 1
-void Scm_RegisterProcedureFixedTailRec1(const char *name, ScmObj (*func)(ScmObj, ScmEvalState*))
+void scm_register_procedure_fixed_tailrec_1(const char *name, ScmObj (*func)(ScmObj, ScmEvalState*))
{
- Scm_RegisterFunc(name, func, SCM_PROCEDURE_FIXED_TAIL_REC | 1);
+ scm_register_func(name, func, SCM_PROCEDURE_FIXED_TAIL_REC | 1);
}
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 2
-void Scm_RegisterProcedureFixedTailRec2(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmEvalState*))
+void scm_register_procedure_fixed_tailrec_2(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmEvalState*))
{
- Scm_RegisterFunc(name, func, SCM_PROCEDURE_FIXED_TAIL_REC | 2);
+ scm_register_func(name, func, SCM_PROCEDURE_FIXED_TAIL_REC | 2);
}
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 3
-void Scm_RegisterProcedureFixedTailRec3(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmEvalState*))
+void scm_register_procedure_fixed_tailrec_3(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmEvalState*))
{
- Scm_RegisterFunc(name, func, SCM_PROCEDURE_FIXED_TAIL_REC | 3);
+ scm_register_func(name, func, SCM_PROCEDURE_FIXED_TAIL_REC | 3);
}
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 4
-void Scm_RegisterProcedureFixedTailRec4(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState*))
+void scm_register_procedure_fixed_tailrec_4(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState*))
{
- Scm_RegisterFunc(name, func, SCM_PROCEDURE_FIXED_TAIL_REC | 4);
+ scm_register_func(name, func, SCM_PROCEDURE_FIXED_TAIL_REC | 4);
}
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 5
-void Scm_RegisterProcedureFixedTailRec5(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState*))
+void scm_register_procedure_fixed_tailrec_5(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState*))
{
- Scm_RegisterFunc(name, func, SCM_PROCEDURE_FIXED_TAIL_REC | 5);
+ scm_register_func(name, func, SCM_PROCEDURE_FIXED_TAIL_REC | 5);
}
#endif
-void Scm_RegisterProcedureVariadic0(const char *name, ScmObj (*func)(ScmObj))
+void scm_register_procedure_variadic_0(const char *name, ScmObj (*func)(ScmObj))
{
- Scm_RegisterFunc(name, func, SCM_PROCEDURE_VARIADIC | 0);
+ scm_register_func(name, func, SCM_PROCEDURE_VARIADIC | 0);
}
#if SCM_FUNCTYPE_MAND_MAX >= 1
-void Scm_RegisterProcedureVariadic1(const char *name, ScmObj (*func)(ScmObj, ScmObj))
+void scm_register_procedure_variadic_1(const char *name, ScmObj (*func)(ScmObj, ScmObj))
{
- Scm_RegisterFunc(name, func, SCM_PROCEDURE_VARIADIC | 1);
+ scm_register_func(name, func, SCM_PROCEDURE_VARIADIC | 1);
}
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 2
-void Scm_RegisterProcedureVariadic2(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj))
+void scm_register_procedure_variadic_2(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj))
{
- Scm_RegisterFunc(name, func, SCM_PROCEDURE_VARIADIC | 2);
+ scm_register_func(name, func, SCM_PROCEDURE_VARIADIC | 2);
}
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 3
-void Scm_RegisterProcedureVariadic3(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj))
+void scm_register_procedure_variadic_3(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj))
{
- Scm_RegisterFunc(name, func, SCM_PROCEDURE_VARIADIC | 3);
+ scm_register_func(name, func, SCM_PROCEDURE_VARIADIC | 3);
}
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 4
-void Scm_RegisterProcedureVariadic4(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj))
+void scm_register_procedure_variadic_4(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj))
{
- Scm_RegisterFunc(name, func, SCM_PROCEDURE_VARIADIC | 4);
+ scm_register_func(name, func, SCM_PROCEDURE_VARIADIC | 4);
}
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 5
-void Scm_RegisterProcedureVariadic5(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmObj))
+void scm_register_procedure_variadic_5(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmObj))
{
- Scm_RegisterFunc(name, func, SCM_PROCEDURE_VARIADIC | 5);
+ scm_register_func(name, func, SCM_PROCEDURE_VARIADIC | 5);
}
#endif
-void Scm_RegisterProcedureVariadicTailRec0(const char *name, ScmObj (*func)(ScmObj, ScmEvalState*))
+void scm_register_procedure_variadic_tailrec_0(const char *name, ScmObj (*func)(ScmObj, ScmEvalState*))
{
- Scm_RegisterFunc(name, func, SCM_PROCEDURE_VARIADIC_TAIL_REC | 0);
+ scm_register_func(name, func, SCM_PROCEDURE_VARIADIC_TAIL_REC | 0);
}
#if SCM_FUNCTYPE_MAND_MAX >= 1
-void Scm_RegisterProcedureVariadicTailRec1(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmEvalState*))
+void scm_register_procedure_variadic_tailrec_1(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmEvalState*))
{
- Scm_RegisterFunc(name, func, SCM_PROCEDURE_VARIADIC_TAIL_REC | 1);
+ scm_register_func(name, func, SCM_PROCEDURE_VARIADIC_TAIL_REC | 1);
}
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 2
-void Scm_RegisterProcedureVariadicTailRec2(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmEvalState*))
+void scm_register_procedure_variadic_tailrec_2(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmEvalState*))
{
- Scm_RegisterFunc(name, func, SCM_PROCEDURE_VARIADIC_TAIL_REC | 2);
+ scm_register_func(name, func, SCM_PROCEDURE_VARIADIC_TAIL_REC | 2);
}
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 3
-void Scm_RegisterProcedureVariadicTailRec3(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState*))
+void scm_register_procedure_variadic_tailrec_3(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState*))
{
- Scm_RegisterFunc(name, func, SCM_PROCEDURE_VARIADIC_TAIL_REC | 3);
+ scm_register_func(name, func, SCM_PROCEDURE_VARIADIC_TAIL_REC | 3);
}
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 4
-void Scm_RegisterProcedureVariadicTailRec4(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState*))
+void scm_register_procedure_variadic_tailrec_4(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState*))
{
- Scm_RegisterFunc(name, func, SCM_PROCEDURE_VARIADIC_TAIL_REC | 4);
+ scm_register_func(name, func, SCM_PROCEDURE_VARIADIC_TAIL_REC | 4);
}
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 5
-void Scm_RegisterProcedureVariadicTailRec5(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState*))
+void scm_register_procedure_variadic_tailrec_5(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState*))
{
- Scm_RegisterFunc(name, func, SCM_PROCEDURE_VARIADIC_TAIL_REC | 5);
+ scm_register_func(name, func, SCM_PROCEDURE_VARIADIC_TAIL_REC | 5);
}
#endif
Modified: branches/r5rs/sigscheme/sigscheme.h
===================================================================
--- branches/r5rs/sigscheme/sigscheme.h 2005-12-16 08:29:32 UTC (rev 2609)
+++ branches/r5rs/sigscheme/sigscheme.h 2005-12-16 09:06:42 UTC (rev 2610)
@@ -77,8 +77,8 @@
/* RFC: better names for the debug printing */
#if SCM_DEBUG
-#define SCM_CDBG(args) (SigScm_CategorizedDebug args)
-#define SCM_DBG(args) (SigScm_Debug args)
+#define SCM_CDBG(args) (scm_categorized_debug args)
+#define SCM_DBG(args) (scm_debug args)
#else /* SCM_DEBUG */
#define SCM_CDBG(args)
#define SCM_DBG(args)
@@ -89,16 +89,16 @@
* - support immediate termination to produce core instead of robust recovery
*/
#define SCM_ASSERT(cond) \
- ((cond) || SigScm_Die("assertion failed", __FILE__, __LINE__))
+ ((cond) || scm_die("assertion failed", __FILE__, __LINE__))
#define SCM_ASSERT_ALLOCATED(p) \
- ((p) || (Scm_FatalError(SCM_ERRMSG_MEMORY_EXHAUSTED), 1))
+ ((p) || (scm_fatal_error(SCM_ERRMSG_MEMORY_EXHAUSTED), 1))
-#define SCM_ERROBJP(obj) (NFALSEP(ScmOp_error_objectp(obj)))
+#define SCM_ERROBJP(obj) (NFALSEP(scm_p_error_objectp(obj)))
#define SCM_SYMBOL_BOUNDP(sym) (!SCM_EQ(SCM_SYMBOL_VCELL(sym), SCM_UNBOUND))
-#define SCM_CONS(kar, kdr) (Scm_NewCons((kar), (kdr)))
+#define SCM_CONS(kar, kdr) (scm_make_cons((kar), (kdr)))
#if SCM_USE_STORAGE_ABSTRACTION_LAYER
#define SCM_CAR(kons) (SCM_CONS_CAR(kons))
#define SCM_CDR(kons) (SCM_CONS_CDR(kons))
@@ -126,7 +126,7 @@
#define SCM_LIST_4_P(lst) (SCM_CONSP(lst) && SCM_LIST_3_P(SCM_CDR(lst)))
#define SCM_LIST_5_P(lst) (SCM_CONSP(lst) && SCM_LIST_4_P(SCM_CDR(lst)))
-#define SCM_EVAL(obj, env) (Scm_eval((obj), (env)))
+#define SCM_EVAL(obj, env) (scm_eval((obj), (env)))
#if SCM_GCC4_READY_GC
/*
@@ -152,9 +152,9 @@
ScmObj *stack_start; \
\
if (0) exp_ret func args; /* compile-time type check */ \
- stack_start = SigScm_GC_ProtectStack(NULL); \
+ stack_start = scm_gc_protect_stack(NULL); \
exp_ret (*fp)args; \
- SigScm_GC_UnprotectStack(stack_start); \
+ scm_gc_unprotect_stack(stack_start); \
} while (/* CONSTCOND */ 0)
#endif /* SCM_GCC4_READY_GC */
@@ -163,15 +163,15 @@
/*
* Port I/O Handling macros
*/
-#define SCM_CHARPORT_ERROR(cport, msg) (SigScm_Error(msg))
-#define SCM_BYTEPORT_ERROR(bport, msg) (SigScm_Error(msg))
+#define SCM_CHARPORT_ERROR(cport, msg) (scm_error(msg))
+#define SCM_BYTEPORT_ERROR(bport, msg) (scm_error(msg))
#define SCM_PORT_MALLOC(size) (scm_malloc(size))
#define SCM_PORT_CALLOC(number, size) (scm_calloc(number, size))
#define SCM_PORT_REALLOC(ptr, size) (scm_realloc(ptr, size))
#define SCM_ASSERT_LIVE_PORT(port) \
(SCM_PORT_IMPL(port) \
- || (SigScm_ErrorObj("operated on closed port", port), 1))
+ || (scm_error_obj("(unknown)", "operated on closed port", port), 1))
#define SCM_PORT_CLOSE_IMPL(port) \
(SCM_CHARPORT_CLOSE(SCM_PORT_IMPL(port)), SCM_PORT_SET_IMPL(port, NULL))
@@ -202,7 +202,7 @@
*/
#include "baseport.h"
-#define SCM_WRITESS_TO_PORT(port, obj) ((*Scm_writess_func)(port, obj))
+#define SCM_WRITESS_TO_PORT(port, obj) ((*scm_writess_func)(port, obj))
/*============================================================================
Type Definitions
@@ -535,7 +535,7 @@
/* storage-gc.c */
#if SCM_GCC4_READY_GC
/*
- * The variable to ensure that a call of SigScm_GC_ProtectStack() is
+ * The variable to ensure that a call of scm_gc_protect_stack() is
* uninlined in portable way through (*f)().
*
* Don't access this variables directly. Use SCM_GC_PROTECTED_CALL*() instead.
@@ -550,147 +550,147 @@
SigScheme : Core Functions
===========================================================================*/
/* sigscheme.c */
-void SigScm_Initialize(void);
-void SigScm_Finalize(void);
-void Scm_DefineAlias(const char *newsym, const char *sym);
-void Scm_Provide(ScmObj feature);
-int Scm_Providedp(ScmObj feature);
-int Scm_Use(const char *feature);
-ScmObj ScmExp_use(ScmObj feature, ScmObj env);
-ScmObj Scm_eval_c_string(const char *exp);
+void scm_initialize(void);
+void scm_finalize(void);
+void scm_define_alias(const char *newsym, const char *sym);
+void scm_provide(ScmObj feature);
+int scm_providedp(ScmObj feature);
+int scm_use(const char *feature);
+ScmObj scm_s_use(ScmObj feature, ScmObj env);
+ScmObj scm_eval_c_string(const char *exp);
#if SCM_COMPAT_SIOD
-ScmObj Scm_return_value(void);
+ScmObj scm_return_value(void);
#endif
/* Procedure/Syntax Registration */
-void Scm_RegisterReductionOperator(const char *name, ScmObj (*func)(ScmObj, ScmObj, enum ScmReductionState*));
-void Scm_RegisterSyntaxFixed0(const char *name, ScmObj (*func)(ScmObj));
+void scm_register_reduction_operator(const char *name, ScmObj (*func)(ScmObj, ScmObj, enum ScmReductionState*));
+void scm_register_syntax_fixed_0(const char *name, ScmObj (*func)(ScmObj));
#if SCM_FUNCTYPE_MAND_MAX >= 1
-void Scm_RegisterSyntaxFixed1(const char *name, ScmObj (*func)(ScmObj, ScmObj));
+void scm_register_syntax_fixed_1(const char *name, ScmObj (*func)(ScmObj, ScmObj));
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 2
-void Scm_RegisterSyntaxFixed2(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj));
+void scm_register_syntax_fixed_2(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj));
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 3
-void Scm_RegisterSyntaxFixed3(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj));
+void scm_register_syntax_fixed_3(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj));
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 4
-void Scm_RegisterSyntaxFixed4(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj));
+void scm_register_syntax_fixed_4(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj));
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 5
-void Scm_RegisterSyntaxFixed5(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmObj));
+void scm_register_syntax_fixed_5(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmObj));
#endif
-void Scm_RegisterSyntaxFixedTailRec0(const char *name, ScmObj (*func)(ScmEvalState*));
+void scm_register_syntax_fixed_tailrec_0(const char *name, ScmObj (*func)(ScmEvalState*));
#if SCM_FUNCTYPE_MAND_MAX >= 1
-void Scm_RegisterSyntaxFixedTailRec1(const char *name, ScmObj (*func)(ScmObj, ScmEvalState*));
+void scm_register_syntax_fixed_tailrec_1(const char *name, ScmObj (*func)(ScmObj, ScmEvalState*));
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 2
-void Scm_RegisterSyntaxFixedTailRec2(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmEvalState*));
+void scm_register_syntax_fixed_tailrec_2(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmEvalState*));
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 3
-void Scm_RegisterSyntaxFixedTailRec3(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmEvalState*));
+void scm_register_syntax_fixed_tailrec_3(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmEvalState*));
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 4
-void Scm_RegisterSyntaxFixedTailRec4(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState*));
+void scm_register_syntax_fixed_tailrec_4(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState*));
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 5
-void Scm_RegisterSyntaxFixedTailRec5(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState*));
+void scm_register_syntax_fixed_tailrec_5(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState*));
#endif
-void Scm_RegisterSyntaxVariadic0(const char *name, ScmObj (*func)(ScmObj, ScmObj));
+void scm_register_syntax_variadic_0(const char *name, ScmObj (*func)(ScmObj, ScmObj));
#if SCM_FUNCTYPE_MAND_MAX >= 1
-void Scm_RegisterSyntaxVariadic1(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj));
+void scm_register_syntax_variadic_1(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj));
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 2
-void Scm_RegisterSyntaxVariadic2(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj));
+void scm_register_syntax_variadic_2(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj));
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 3
-void Scm_RegisterSyntaxVariadic3(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj));
+void scm_register_syntax_variadic_3(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj));
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 4
-void Scm_RegisterSyntaxVariadic4(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmObj));
+void scm_register_syntax_variadic_4(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmObj));
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 5
-void Scm_RegisterSyntaxVariadic5(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmObj));
+void scm_register_syntax_variadic_5(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmObj));
#endif
-void Scm_RegisterSyntaxVariadicTailRec0(const char *name, ScmObj (*func)(ScmObj, ScmEvalState*));
+void scm_register_syntax_variadic_tailrec_0(const char *name, ScmObj (*func)(ScmObj, ScmEvalState*));
#if SCM_FUNCTYPE_MAND_MAX >= 1
-void Scm_RegisterSyntaxVariadicTailRec1(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmEvalState*));
+void scm_register_syntax_variadic_tailrec_1(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmEvalState*));
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 2
-void Scm_RegisterSyntaxVariadicTailRec2(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmEvalState*));
+void scm_register_syntax_variadic_tailrec_2(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmEvalState*));
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 3
-void Scm_RegisterSyntaxVariadicTailRec3(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState*));
+void scm_register_syntax_variadic_tailrec_3(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState*));
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 4
-void Scm_RegisterSyntaxVariadicTailRec4(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState*));
+void scm_register_syntax_variadic_tailrec_4(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState*));
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 5
-void Scm_RegisterSyntaxVariadicTailRec5(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState*));
+void scm_register_syntax_variadic_tailrec_5(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState*));
#endif
-void Scm_RegisterProcedureFixed0(const char *name, ScmObj (*func)());
+void scm_register_procedure_fixed_0(const char *name, ScmObj (*func)());
#if SCM_FUNCTYPE_MAND_MAX >= 1
-void Scm_RegisterProcedureFixed1(const char *name, ScmObj (*func)(ScmObj));
+void scm_register_procedure_fixed_1(const char *name, ScmObj (*func)(ScmObj));
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 2
-void Scm_RegisterProcedureFixed2(const char *name, ScmObj (*func)(ScmObj, ScmObj));
+void scm_register_procedure_fixed_2(const char *name, ScmObj (*func)(ScmObj, ScmObj));
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 3
-void Scm_RegisterProcedureFixed3(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj));
+void scm_register_procedure_fixed_3(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj));
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 4
-void Scm_RegisterProcedureFixed4(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj));
+void scm_register_procedure_fixed_4(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj));
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 5
-void Scm_RegisterProcedureFixed5(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj));
+void scm_register_procedure_fixed_5(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj));
#endif
-void Scm_RegisterProcedureFixedTailRec0(const char *name, ScmObj (*func)(ScmEvalState*));
+void scm_register_procedure_fixed_tailrec_0(const char *name, ScmObj (*func)(ScmEvalState*));
#if SCM_FUNCTYPE_MAND_MAX >= 1
-void Scm_RegisterProcedureFixedTailRec1(const char *name, ScmObj (*func)(ScmObj, ScmEvalState*));
+void scm_register_procedure_fixed_tailrec_1(const char *name, ScmObj (*func)(ScmObj, ScmEvalState*));
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 2
-void Scm_RegisterProcedureFixedTailRec2(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmEvalState*));
+void scm_register_procedure_fixed_tailrec_2(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmEvalState*));
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 3
-void Scm_RegisterProcedureFixedTailRec3(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmEvalState*));
+void scm_register_procedure_fixed_tailrec_3(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmEvalState*));
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 4
-void Scm_RegisterProcedureFixedTailRec4(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState*));
+void scm_register_procedure_fixed_tailrec_4(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState*));
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 5
-void Scm_RegisterProcedureFixedTailRec5(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState*));
+void scm_register_procedure_fixed_tailrec_5(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState*));
#endif
-void Scm_RegisterProcedureVariadic0(const char *name, ScmObj (*func)(ScmObj));
+void scm_register_procedure_variadic_0(const char *name, ScmObj (*func)(ScmObj));
#if SCM_FUNCTYPE_MAND_MAX >= 1
-void Scm_RegisterProcedureVariadic1(const char *name, ScmObj (*func)(ScmObj, ScmObj));
+void scm_register_procedure_variadic_1(const char *name, ScmObj (*func)(ScmObj, ScmObj));
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 2
-void Scm_RegisterProcedureVariadic2(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj));
+void scm_register_procedure_variadic_2(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj));
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 3
-void Scm_RegisterProcedureVariadic3(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj));
+void scm_register_procedure_variadic_3(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj));
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 4
-void Scm_RegisterProcedureVariadic4(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj));
+void scm_register_procedure_variadic_4(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj));
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 5
-void Scm_RegisterProcedureVariadic5(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmObj));
+void scm_register_procedure_variadic_5(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmObj));
#endif
-void Scm_RegisterProcedureVariadicTailRec0(const char *name, ScmObj (*func)(ScmObj, ScmEvalState*));
+void scm_register_procedure_variadic_tailrec_0(const char *name, ScmObj (*func)(ScmObj, ScmEvalState*));
#if SCM_FUNCTYPE_MAND_MAX >= 1
-void Scm_RegisterProcedureVariadicTailRec1(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmEvalState*));
+void scm_register_procedure_variadic_tailrec_1(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmEvalState*));
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 2
-void Scm_RegisterProcedureVariadicTailRec2(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmEvalState*));
+void scm_register_procedure_variadic_tailrec_2(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmEvalState*));
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 3
-void Scm_RegisterProcedureVariadicTailRec3(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState*));
+void scm_register_procedure_variadic_tailrec_3(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState*));
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 4
-void Scm_RegisterProcedureVariadicTailRec4(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState*));
+void scm_register_procedure_variadic_tailrec_4(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState*));
#endif
#if SCM_FUNCTYPE_MAND_MAX >= 5
-void Scm_RegisterProcedureVariadicTailRec5(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState*));
+void scm_register_procedure_variadic_tailrec_5(const char *name, ScmObj (*func)(ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmObj, ScmEvalState*));
#endif
/* alloc.c */
@@ -703,288 +703,288 @@
/* Don't use these functions directly. Use SCM_MAKE_*() or MAKE_*() instead to
* allow flexible object allocation. */
/* FIXME: rename to scm_make_*() */
-ScmObj Scm_NewCons(ScmObj a, ScmObj b);
-ScmObj Scm_NewInt(int val);
-ScmObj Scm_NewSymbol(char *name, ScmObj v_cell);
-ScmObj Scm_NewChar(int val);
-ScmObj Scm_NewString(char *str, int is_immutable);
-ScmObj Scm_NewImmutableString(char *str);
-ScmObj Scm_NewImmutableStringCopying(const char *str);
-ScmObj Scm_NewMutableString(char *str);
-ScmObj Scm_NewMutableStringCopying(const char *str);
-ScmObj Scm_NewFunc(enum ScmFuncTypeCode type, ScmFuncType func);
-ScmObj Scm_NewClosure(ScmObj exp, ScmObj env);
-ScmObj Scm_NewVector(ScmObj *vec, int len);
-ScmObj Scm_NewPort(ScmCharPort *cport, enum ScmPortFlag flag);
-ScmObj Scm_NewContinuation(void);
+ScmObj scm_make_cons(ScmObj a, ScmObj b);
+ScmObj scm_make_int(int val);
+ScmObj scm_make_symbol(char *name, ScmObj v_cell);
+ScmObj scm_make_char(int val);
+ScmObj scm_make_string(char *str, int is_immutable);
+ScmObj scm_make_immutable_string(char *str);
+ScmObj scm_make_immutable_string_copying(const char *str);
+ScmObj scm_make_mutable_string(char *str);
+ScmObj scm_make_mutable_string_copying(const char *str);
+ScmObj scm_make_func(enum ScmFuncTypeCode type, ScmFuncType func);
+ScmObj scm_make_closure(ScmObj exp, ScmObj env);
+ScmObj scm_make_vector(ScmObj *vec, int len);
+ScmObj scm_make_port(ScmCharPort *cport, enum ScmPortFlag flag);
+ScmObj scm_make_continuation(void);
#if !SCM_USE_VALUECONS
-ScmObj Scm_NewValuePacket(ScmObj values);
+ScmObj scm_make_value_packet(ScmObj values);
#endif
#if SCM_USE_NONSTD_FEATURES
-ScmObj Scm_NewCPointer(void *data);
-ScmObj Scm_NewCFuncPointer(ScmCFunc func);
+ScmObj scm_make_cpointer(void *data);
+ScmObj scm_make_cfunc_pointer(ScmCFunc func);
#endif
/* storage-gc.c */
-void SigScm_GC_Protect(ScmObj *var);
-void SigScm_GC_Unprotect(ScmObj *var);
+void scm_gc_protect(ScmObj *var);
+void scm_gc_unprotect(ScmObj *var);
#if SCM_GCC4_READY_GC
/*
* Ordinary programs should not call these functions directly. Use
* SCM_GC_PROTECTED_CALL*() instead.
*/
#ifdef __GNUC__
-#define SigScm_GC_ProtectStack SigScm_GC_ProtectStackInternal
+#define scm_gc_protect_stack scm_gc_protect_stack_internal
#else /* __GNUC__ */
-#define SigScm_GC_ProtectStack (*scm_gc_protect_stack)
+#define scm_gc_protect_stack (*scm_gc_protect_stack)
#endif /* __GNUC__ */
-ScmObj *SigScm_GC_ProtectStackInternal(ScmObj *designated_stack_start) SCM_NOINLINE;
+ScmObj *scm_gc_protect_stack_internal(ScmObj *designated_stack_start) SCM_NOINLINE;
#else /* SCM_GCC4_READY_GC */
-void SigScm_GC_ProtectStack(ScmObj *stack_start);
+void scm_gc_protect_stack(ScmObj *stack_start);
#endif /* SCM_GCC4_READY_GC */
-void SigScm_GC_UnprotectStack(ScmObj *stack_start);
+void scm_gc_unprotect_stack(ScmObj *stack_start);
/* storage-symbol.c */
-ScmObj Scm_Intern(const char *name);
-ScmObj Scm_SymbolBoundTo(ScmObj obj);
+ScmObj scm_intern(const char *name);
+ScmObj scm_symbol_bound_to(ScmObj obj);
/* eval.c */
-ScmObj ScmOp_eval(ScmObj obj, ScmObj env);
-ScmObj ScmOp_apply(ScmObj proc, ScmObj arg0, ScmObj rest, ScmEvalState *eval_state);
-ScmObj ScmExp_quote(ScmObj datum, ScmObj env);
-ScmObj ScmExp_lambda(ScmObj formals, ScmObj body, ScmObj env);
-ScmObj ScmExp_if(ScmObj test, ScmObj conseq, ScmObj rest, ScmEvalState *eval_state);
-ScmObj ScmExp_setd(ScmObj var, ScmObj val, ScmObj env);
-ScmObj ScmExp_cond(ScmObj args, ScmEvalState *eval_state);
-ScmObj ScmExp_case(ScmObj key, ScmObj args, ScmEvalState *eval_state);
-ScmObj ScmExp_and(ScmObj args, ScmEvalState *eval_state);
-ScmObj ScmExp_or(ScmObj args, ScmEvalState *eval_state);
-ScmObj ScmExp_let(ScmObj args, ScmEvalState *eval_state);
-ScmObj ScmExp_letstar(ScmObj bindings, ScmObj body, ScmEvalState *eval_state);
-ScmObj ScmExp_letrec(ScmObj bindings, ScmObj body, ScmEvalState *eval_state);
-ScmObj ScmExp_begin(ScmObj args, ScmEvalState *eval_state);
-ScmObj ScmExp_do(ScmObj bindings, ScmObj testframe, ScmObj commands, ScmEvalState *eval_state);
-ScmObj ScmExp_delay(ScmObj expr, ScmObj env);
-ScmObj ScmExp_quasiquote(ScmObj datum, ScmObj env);
-ScmObj ScmExp_unquote(ScmObj dummy, ScmObj env);
-ScmObj ScmExp_unquote_splicing(ScmObj dummy, ScmObj env);
-ScmObj ScmExp_define(ScmObj var, ScmObj rest, ScmObj env);
-ScmObj ScmOp_scheme_report_environment(ScmObj version);
-ScmObj ScmOp_null_environment(ScmObj version);
-ScmObj ScmOp_interaction_environment(void);
+ScmObj scm_p_eval(ScmObj obj, ScmObj env);
+ScmObj scm_p_apply(ScmObj proc, ScmObj arg0, ScmObj rest, ScmEvalState *eval_state);
+ScmObj scm_s_quote(ScmObj datum, ScmObj env);
+ScmObj scm_s_lambda(ScmObj formals, ScmObj body, ScmObj env);
+ScmObj scm_s_if(ScmObj test, ScmObj conseq, ScmObj rest, ScmEvalState *eval_state);
+ScmObj scm_s_setd(ScmObj var, ScmObj val, ScmObj env);
+ScmObj scm_s_cond(ScmObj args, ScmEvalState *eval_state);
+ScmObj scm_s_case(ScmObj key, ScmObj args, ScmEvalState *eval_state);
+ScmObj scm_s_and(ScmObj args, ScmEvalState *eval_state);
+ScmObj scm_s_or(ScmObj args, ScmEvalState *eval_state);
+ScmObj scm_s_let(ScmObj args, ScmEvalState *eval_state);
+ScmObj scm_s_letstar(ScmObj bindings, ScmObj body, ScmEvalState *eval_state);
+ScmObj scm_s_letrec(ScmObj bindings, ScmObj body, ScmEvalState *eval_state);
+ScmObj scm_s_begin(ScmObj args, ScmEvalState *eval_state);
+ScmObj scm_s_do(ScmObj bindings, ScmObj testframe, ScmObj commands, ScmEvalState *eval_state);
+ScmObj scm_s_delay(ScmObj expr, ScmObj env);
+ScmObj scm_s_quasiquote(ScmObj datum, ScmObj env);
+ScmObj scm_s_unquote(ScmObj dummy, ScmObj env);
+ScmObj scm_s_unquote_splicing(ScmObj dummy, ScmObj env);
+ScmObj scm_s_define(ScmObj var, ScmObj rest, ScmObj env);
+ScmObj scm_p_scheme_report_environment(ScmObj version);
+ScmObj scm_p_null_environment(ScmObj version);
+ScmObj scm_p_interaction_environment(void);
-ScmObj Scm_call(ScmObj proc, ScmObj args);
+ScmObj scm_call(ScmObj proc, ScmObj args);
/* operations.c */
-ScmObj ScmOp_eqvp(ScmObj obj1, ScmObj obj2);
-ScmObj ScmOp_eqp(ScmObj obj1, ScmObj obj2);
-ScmObj ScmOp_equalp(ScmObj obj1, ScmObj obj2);
-ScmObj ScmOp_add(ScmObj left, ScmObj right, enum ScmReductionState *state);
-ScmObj ScmOp_subtract(ScmObj left, ScmObj right, enum ScmReductionState *state);
-ScmObj ScmOp_multiply(ScmObj left, ScmObj right, enum ScmReductionState *state);
-ScmObj ScmOp_divide(ScmObj left, ScmObj right, enum ScmReductionState *state);
-ScmObj ScmOp_equal(ScmObj left, ScmObj right, enum ScmReductionState *state);
-ScmObj ScmOp_less(ScmObj left, ScmObj right, enum ScmReductionState *state);
-ScmObj ScmOp_less_eq(ScmObj left, ScmObj right, enum ScmReductionState *state);
-ScmObj ScmOp_greater(ScmObj left, ScmObj right, enum ScmReductionState *state);
-ScmObj ScmOp_greater_eq(ScmObj left, ScmObj right, enum ScmReductionState *state);
-ScmObj ScmOp_numberp(ScmObj obj);
-ScmObj ScmOp_zerop(ScmObj scm_num);
-ScmObj ScmOp_positivep(ScmObj scm_num);
-ScmObj ScmOp_negativep(ScmObj scm_num);
-ScmObj ScmOp_oddp(ScmObj scm_num);
-ScmObj ScmOp_evenp(ScmObj scm_num);
-ScmObj ScmOp_max(ScmObj left, ScmObj right, enum ScmReductionState *state);
-ScmObj ScmOp_min(ScmObj left, ScmObj right, enum ScmReductionState *state);
-ScmObj ScmOp_abs(ScmObj scm_num);
-ScmObj ScmOp_quotient(ScmObj scm_n1, ScmObj scm_n2);
-ScmObj ScmOp_modulo(ScmObj scm_n1, ScmObj scm_n2);
-ScmObj ScmOp_remainder(ScmObj scm_n1, ScmObj scm_n2);
-ScmObj ScmOp_number2string (ScmObj num, ScmObj args);
-ScmObj ScmOp_string2number(ScmObj str, ScmObj args);
-ScmObj ScmOp_not(ScmObj obj);
-ScmObj ScmOp_booleanp(ScmObj obj);
-ScmObj ScmOp_car(ScmObj obj);
-ScmObj ScmOp_cdr(ScmObj obj);
-ScmObj ScmOp_pairp(ScmObj obj);
-ScmObj ScmOp_cons(ScmObj car, ScmObj cdr);
-ScmObj ScmOp_set_card(ScmObj pair, ScmObj car);
-ScmObj ScmOp_set_cdrd(ScmObj pair, ScmObj cdr);
-ScmObj ScmOp_caar(ScmObj lst);
-ScmObj ScmOp_cadr(ScmObj lst);
-ScmObj ScmOp_cdar(ScmObj lst);
-ScmObj ScmOp_cddr(ScmObj lst);
-ScmObj ScmOp_caddr(ScmObj lst);
-ScmObj ScmOp_cdddr(ScmObj lst);
-ScmObj ScmOp_list(ScmObj args);
-ScmObj ScmOp_nullp(ScmObj obj);
-ScmObj ScmOp_listp(ScmObj obj);
-ScmObj ScmOp_length(ScmObj obj);
-ScmObj ScmOp_append(ScmObj args);
-ScmObj ScmOp_reverse(ScmObj lst);
-ScmObj ScmOp_list_tail(ScmObj lst, ScmObj scm_k);
-ScmObj ScmOp_list_ref(ScmObj lst, ScmObj scm_k);
-ScmObj ScmOp_memq(ScmObj obj, ScmObj lst);
-ScmObj ScmOp_memv(ScmObj obj, ScmObj lst);
-ScmObj ScmOp_member(ScmObj obj, ScmObj lst);
-ScmObj ScmOp_assq(ScmObj obj, ScmObj alist);
-ScmObj ScmOp_assv(ScmObj obj, ScmObj alist);
-ScmObj ScmOp_assoc(ScmObj obj, ScmObj alist);
-ScmObj ScmOp_symbolp(ScmObj obj);
-ScmObj ScmOp_symbol2string(ScmObj obj);
-ScmObj ScmOp_string2symbol(ScmObj str);
+ScmObj scm_p_eqvp(ScmObj obj1, ScmObj obj2);
+ScmObj scm_p_eqp(ScmObj obj1, ScmObj obj2);
+ScmObj scm_p_equalp(ScmObj obj1, ScmObj obj2);
+ScmObj scm_p_add(ScmObj left, ScmObj right, enum ScmReductionState *state);
+ScmObj scm_p_subtract(ScmObj left, ScmObj right, enum ScmReductionState *state);
+ScmObj scm_p_multiply(ScmObj left, ScmObj right, enum ScmReductionState *state);
+ScmObj scm_p_divide(ScmObj left, ScmObj right, enum ScmReductionState *state);
+ScmObj scm_p_equal(ScmObj left, ScmObj right, enum ScmReductionState *state);
+ScmObj scm_p_less(ScmObj left, ScmObj right, enum ScmReductionState *state);
+ScmObj scm_p_less_eq(ScmObj left, ScmObj right, enum ScmReductionState *state);
+ScmObj scm_p_greater(ScmObj left, ScmObj right, enum ScmReductionState *state);
+ScmObj scm_p_greater_eq(ScmObj left, ScmObj right, enum ScmReductionState *state);
+ScmObj scm_p_numberp(ScmObj obj);
+ScmObj scm_p_zerop(ScmObj scm_num);
+ScmObj scm_p_positivep(ScmObj scm_num);
+ScmObj scm_p_negativep(ScmObj scm_num);
+ScmObj scm_p_oddp(ScmObj scm_num);
+ScmObj scm_p_evenp(ScmObj scm_num);
+ScmObj scm_p_max(ScmObj left, ScmObj right, enum ScmReductionState *state);
+ScmObj scm_p_min(ScmObj left, ScmObj right, enum ScmReductionState *state);
+ScmObj scm_p_abs(ScmObj scm_num);
+ScmObj scm_p_quotient(ScmObj scm_n1, ScmObj scm_n2);
+ScmObj scm_p_modulo(ScmObj scm_n1, ScmObj scm_n2);
+ScmObj scm_p_remainder(ScmObj scm_n1, ScmObj scm_n2);
+ScmObj scm_p_number2string (ScmObj num, ScmObj args);
+ScmObj scm_p_string2number(ScmObj str, ScmObj args);
+ScmObj scm_p_not(ScmObj obj);
+ScmObj scm_p_booleanp(ScmObj obj);
+ScmObj scm_p_car(ScmObj obj);
+ScmObj scm_p_cdr(ScmObj obj);
+ScmObj scm_p_pairp(ScmObj obj);
+ScmObj scm_p_cons(ScmObj car, ScmObj cdr);
+ScmObj scm_p_set_card(ScmObj pair, ScmObj car);
+ScmObj scm_p_set_cdrd(ScmObj pair, ScmObj cdr);
+ScmObj scm_p_caar(ScmObj lst);
+ScmObj scm_p_cadr(ScmObj lst);
+ScmObj scm_p_cdar(ScmObj lst);
+ScmObj scm_p_cddr(ScmObj lst);
+ScmObj scm_p_caddr(ScmObj lst);
+ScmObj scm_p_cdddr(ScmObj lst);
+ScmObj scm_p_list(ScmObj args);
+ScmObj scm_p_nullp(ScmObj obj);
+ScmObj scm_p_listp(ScmObj obj);
+ScmObj scm_p_length(ScmObj obj);
+ScmObj scm_p_append(ScmObj args);
+ScmObj scm_p_reverse(ScmObj lst);
+ScmObj scm_p_list_tail(ScmObj lst, ScmObj scm_k);
+ScmObj scm_p_list_ref(ScmObj lst, ScmObj scm_k);
+ScmObj scm_p_memq(ScmObj obj, ScmObj lst);
+ScmObj scm_p_memv(ScmObj obj, ScmObj lst);
+ScmObj scm_p_member(ScmObj obj, ScmObj lst);
+ScmObj scm_p_assq(ScmObj obj, ScmObj alist);
+ScmObj scm_p_assv(ScmObj obj, ScmObj alist);
+ScmObj scm_p_assoc(ScmObj obj, ScmObj alist);
+ScmObj scm_p_symbolp(ScmObj obj);
+ScmObj scm_p_symbol2string(ScmObj obj);
+ScmObj scm_p_string2symbol(ScmObj str);
-ScmObj ScmOp_charp(ScmObj obj);
-ScmObj ScmOp_charequalp(ScmObj ch1, ScmObj ch2);
+ScmObj scm_p_charp(ScmObj obj);
+ScmObj scm_p_charequalp(ScmObj ch1, ScmObj ch2);
/* TODO : many comparing functions around char is unimplemented */
-ScmObj ScmOp_char_alphabeticp(ScmObj obj);
-ScmObj ScmOp_char_numericp(ScmObj obj);
-ScmObj ScmOp_char_whitespacep(ScmObj obj);
-ScmObj ScmOp_char_upper_casep(ScmObj obj);
-ScmObj ScmOp_char_lower_casep(ScmObj obj);
-ScmObj ScmOp_char2integer(ScmObj obj);
-ScmObj ScmOp_integer2char(ScmObj obj);
-ScmObj ScmOp_char_upcase(ScmObj obj);
-ScmObj ScmOp_char_downcase(ScmObj obj);
+ScmObj scm_p_char_alphabeticp(ScmObj obj);
+ScmObj scm_p_char_numericp(ScmObj obj);
+ScmObj scm_p_char_whitespacep(ScmObj obj);
+ScmObj scm_p_char_upper_casep(ScmObj obj);
+ScmObj scm_p_char_lower_casep(ScmObj obj);
+ScmObj scm_p_char2integer(ScmObj obj);
+ScmObj scm_p_integer2char(ScmObj obj);
+ScmObj scm_p_char_upcase(ScmObj obj);
+ScmObj scm_p_char_downcase(ScmObj obj);
-ScmObj ScmOp_stringp(ScmObj obj);
-ScmObj ScmOp_make_string(ScmObj length, ScmObj args);
-ScmObj ScmOp_string(ScmObj args);
-ScmObj ScmOp_string_length(ScmObj str);
-ScmObj ScmOp_string_ref(ScmObj str, ScmObj k);
-ScmObj ScmOp_string_setd(ScmObj str, ScmObj k, ScmObj ch);
-ScmObj ScmOp_stringequalp(ScmObj str1, ScmObj str2);
+ScmObj scm_p_stringp(ScmObj obj);
+ScmObj scm_p_make_string(ScmObj length, ScmObj args);
+ScmObj scm_p_string(ScmObj args);
+ScmObj scm_p_string_length(ScmObj str);
+ScmObj scm_p_string_ref(ScmObj str, ScmObj k);
+ScmObj scm_p_string_setd(ScmObj str, ScmObj k, ScmObj ch);
+ScmObj scm_p_stringequalp(ScmObj str1, ScmObj str2);
/* TODO : many comparing functions around string is unimplemented */
-ScmObj ScmOp_substring(ScmObj str, ScmObj start, ScmObj end);
-ScmObj ScmOp_string_append(ScmObj args);
-ScmObj ScmOp_string2list(ScmObj str);
-ScmObj ScmOp_list2string(ScmObj lst);
-ScmObj ScmOp_string_copy(ScmObj str);
-ScmObj ScmOp_string_filld(ScmObj str, ScmObj ch);
-ScmObj ScmOp_vectorp(ScmObj obj);
-ScmObj ScmOp_make_vector(ScmObj vector_len, ScmObj args);
-ScmObj ScmOp_vector(ScmObj args);
-ScmObj ScmOp_vector_length(ScmObj vec);
-ScmObj ScmOp_vector_ref(ScmObj vec, ScmObj scm_k);
-ScmObj ScmOp_vector_setd(ScmObj vec, ScmObj scm_k, ScmObj obj);
-ScmObj ScmOp_vector2list(ScmObj vec);
-ScmObj ScmOp_list2vector(ScmObj lst);
-ScmObj ScmOp_vector_filld(ScmObj vec, ScmObj fill);
-ScmObj ScmOp_procedurep(ScmObj obj);
-ScmObj ScmOp_map(ScmObj proc, ScmObj args);
-ScmObj ScmOp_for_each(ScmObj proc, ScmObj args);
-ScmObj ScmOp_force(ScmObj closure);
-ScmObj ScmOp_call_with_current_continuation(ScmObj proc, ScmEvalState *eval_state);
-ScmObj ScmOp_values(ScmObj args);
-ScmObj ScmOp_call_with_values(ScmObj producer, ScmObj consumer, ScmEvalState *eval_state);
-ScmObj ScmOp_dynamic_wind(ScmObj before, ScmObj thunk, ScmObj after);
+ScmObj scm_p_substring(ScmObj str, ScmObj start, ScmObj end);
+ScmObj scm_p_string_append(ScmObj args);
+ScmObj scm_p_string2list(ScmObj str);
+ScmObj scm_p_list2string(ScmObj lst);
+ScmObj scm_p_string_copy(ScmObj str);
+ScmObj scm_p_string_filld(ScmObj str, ScmObj ch);
+ScmObj scm_p_vectorp(ScmObj obj);
+ScmObj scm_p_make_vector(ScmObj vector_len, ScmObj args);
+ScmObj scm_p_vector(ScmObj args);
+ScmObj scm_p_vector_length(ScmObj vec);
+ScmObj scm_p_vector_ref(ScmObj vec, ScmObj scm_k);
+ScmObj scm_p_vector_setd(ScmObj vec, ScmObj scm_k, ScmObj obj);
+ScmObj scm_p_vector2list(ScmObj vec);
+ScmObj scm_p_list2vector(ScmObj lst);
+ScmObj scm_p_vector_filld(ScmObj vec, ScmObj fill);
+ScmObj scm_p_procedurep(ScmObj obj);
+ScmObj scm_p_map(ScmObj proc, ScmObj args);
+ScmObj scm_p_for_each(ScmObj proc, ScmObj args);
+ScmObj scm_p_force(ScmObj closure);
+ScmObj scm_p_call_with_current_continuation(ScmObj proc, ScmEvalState *eval_state);
+ScmObj scm_p_values(ScmObj args);
+ScmObj scm_p_call_with_values(ScmObj producer, ScmObj consumer, ScmEvalState *eval_state);
+ScmObj scm_p_dynamic_wind(ScmObj before, ScmObj thunk, ScmObj after);
/* operations-r5rs-deepcadrs.c */
#if SCM_USE_DEEP_CADRS
-ScmObj ScmOp_caaar(ScmObj lst);
-ScmObj ScmOp_caadr(ScmObj lst);
-ScmObj ScmOp_cadar(ScmObj lst);
-ScmObj ScmOp_cdaar(ScmObj lst);
-ScmObj ScmOp_cdadr(ScmObj lst);
-ScmObj ScmOp_cddar(ScmObj lst);
-ScmObj ScmOp_caaaar(ScmObj lst);
-ScmObj ScmOp_caaadr(ScmObj lst);
-ScmObj ScmOp_caadar(ScmObj lst);
-ScmObj ScmOp_caaddr(ScmObj lst);
-ScmObj ScmOp_cadaar(ScmObj lst);
-ScmObj ScmOp_cadadr(ScmObj lst);
-ScmObj ScmOp_caddar(ScmObj lst);
-ScmObj ScmOp_cadddr(ScmObj lst);
-ScmObj ScmOp_cdaaar(ScmObj lst);
-ScmObj ScmOp_cdaadr(ScmObj lst);
-ScmObj ScmOp_cdadar(ScmObj lst);
-ScmObj ScmOp_cdaddr(ScmObj lst);
-ScmObj ScmOp_cddaar(ScmObj lst);
-ScmObj ScmOp_cddadr(ScmObj lst);
-ScmObj ScmOp_cdddar(ScmObj lst);
-ScmObj ScmOp_cddddr(ScmObj lst);
+ScmObj scm_p_caaar(ScmObj lst);
+ScmObj scm_p_caadr(ScmObj lst);
+ScmObj scm_p_cadar(ScmObj lst);
+ScmObj scm_p_cdaar(ScmObj lst);
+ScmObj scm_p_cdadr(ScmObj lst);
+ScmObj scm_p_cddar(ScmObj lst);
+ScmObj scm_p_caaaar(ScmObj lst);
+ScmObj scm_p_caaadr(ScmObj lst);
+ScmObj scm_p_caadar(ScmObj lst);
+ScmObj scm_p_caaddr(ScmObj lst);
+ScmObj scm_p_cadaar(ScmObj lst);
+ScmObj scm_p_cadadr(ScmObj lst);
+ScmObj scm_p_caddar(ScmObj lst);
+ScmObj scm_p_cadddr(ScmObj lst);
+ScmObj scm_p_cdaaar(ScmObj lst);
+ScmObj scm_p_cdaadr(ScmObj lst);
+ScmObj scm_p_cdadar(ScmObj lst);
+ScmObj scm_p_cdaddr(ScmObj lst);
+ScmObj scm_p_cddaar(ScmObj lst);
+ScmObj scm_p_cddadr(ScmObj lst);
+ScmObj scm_p_cdddar(ScmObj lst);
+ScmObj scm_p_cddddr(ScmObj lst);
#endif /* SCM_USE_DEEP_CADRS */
/* operations-nonstd.c */
#if SCM_USE_NONSTD_FEATURES
-void SigScm_Initialize_NONSTD_FEATURES(void);
-ScmObj ScmOp_symbol_boundp(ScmObj sym, ScmObj rest);
-ScmObj ScmOp_load_path(void);
-/* FIXME: add ScmObj SigScm_require(const char *c_filename); */
-ScmObj ScmOp_require(ScmObj filename);
-ScmObj ScmOp_provide(ScmObj feature);
-ScmObj ScmOp_providedp(ScmObj feature);
-ScmObj ScmOp_file_existsp(ScmObj filepath);
-ScmObj ScmOp_delete_file(ScmObj filepath);
+void scm_initialize_nonstd_features(void);
+ScmObj scm_p_symbol_boundp(ScmObj sym, ScmObj rest);
+ScmObj scm_p_load_path(void);
+/* FIXME: add ScmObj scm_require(const char *c_filename); */
+ScmObj scm_p_require(ScmObj filename);
+ScmObj scm_p_provide(ScmObj feature);
+ScmObj scm_p_providedp(ScmObj feature);
+ScmObj scm_p_file_existsp(ScmObj filepath);
+ScmObj scm_p_delete_file(ScmObj filepath);
#endif
/* io.c */
-void SigScm_set_lib_path(const char *path);
-ScmObj Scm_MakeSharedFilePort(FILE *file, const char *aux_info,
+void scm_set_lib_path(const char *path);
+ScmObj scm_make_shared_file_port(FILE *file, const char *aux_info,
enum ScmPortFlag flag);
-void SigScm_PortPrintf(ScmObj port, const char *fmt, ...);
-void SigScm_VPortPrintf(ScmObj port, const char *fmt, va_list args);
-void SigScm_PortNewline(ScmObj port);
-void SigScm_ErrorPrintf(const char *fmt, ...);
-void SigScm_VErrorPrintf(const char *fmt, va_list args);
-void SigScm_ErrorNewline(void);
+void scm_port_printf(ScmObj port, const char *fmt, ...);
+void scm_port_vprintf(ScmObj port, const char *fmt, va_list args);
+void scm_port_newline(ScmObj port);
+void scm_error_printf(const char *fmt, ...);
+void scm_error_vprintf(const char *fmt, va_list args);
+void scm_error_newline(void);
-ScmObj ScmOp_call_with_input_file(ScmObj filepath, ScmObj proc);
-ScmObj ScmOp_call_with_output_file(ScmObj filepath, ScmObj proc);
-ScmObj ScmOp_input_portp(ScmObj obj);
-ScmObj ScmOp_output_portp(ScmObj obj);
-ScmObj ScmOp_current_input_port(void);
-ScmObj ScmOp_current_output_port(void);
-ScmObj ScmOp_with_input_from_file(ScmObj filepath, ScmObj thunk);
-ScmObj ScmOp_with_output_to_file(ScmObj filepath, ScmObj thunk);
-ScmObj ScmOp_open_input_file(ScmObj filepath);
-ScmObj ScmOp_open_output_file(ScmObj filepath);
-ScmObj ScmOp_close_input_port(ScmObj port);
-ScmObj ScmOp_close_output_port(ScmObj port);
+ScmObj scm_p_call_with_input_file(ScmObj filepath, ScmObj proc);
+ScmObj scm_p_call_with_output_file(ScmObj filepath, ScmObj proc);
+ScmObj scm_p_input_portp(ScmObj obj);
+ScmObj scm_p_output_portp(ScmObj obj);
+ScmObj scm_p_current_input_port(void);
+ScmObj scm_p_current_output_port(void);
+ScmObj scm_p_with_input_from_file(ScmObj filepath, ScmObj thunk);
+ScmObj scm_p_with_output_to_file(ScmObj filepath, ScmObj thunk);
+ScmObj scm_p_open_input_file(ScmObj filepath);
+ScmObj scm_p_open_output_file(ScmObj filepath);
+ScmObj scm_p_close_input_port(ScmObj port);
+ScmObj scm_p_close_output_port(ScmObj port);
-ScmObj ScmOp_read(ScmObj args);
-ScmObj ScmOp_read_char(ScmObj args);
-ScmObj ScmOp_peek_char(ScmObj args);
-ScmObj ScmOp_eof_objectp(ScmObj obj);
-ScmObj ScmOp_char_readyp(ScmObj args);
-ScmObj ScmOp_write(ScmObj obj, ScmObj args);
-ScmObj ScmOp_display(ScmObj obj, ScmObj args);
-ScmObj ScmOp_newline(ScmObj args);
-ScmObj ScmOp_write_char(ScmObj obj, ScmObj args);
+ScmObj scm_p_read(ScmObj args);
+ScmObj scm_p_read_char(ScmObj args);
+ScmObj scm_p_peek_char(ScmObj args);
+ScmObj scm_p_eof_objectp(ScmObj obj);
+ScmObj scm_p_char_readyp(ScmObj args);
+ScmObj scm_p_write(ScmObj obj, ScmObj args);
+ScmObj scm_p_display(ScmObj obj, ScmObj args);
+ScmObj scm_p_newline(ScmObj args);
+ScmObj scm_p_write_char(ScmObj obj, ScmObj args);
-ScmObj SigScm_load(const char *c_filename);
-ScmObj ScmOp_load(ScmObj filename);
+ScmObj scm_load(const char *c_filename);
+ScmObj scm_p_load(ScmObj filename);
/* read.c */
-ScmObj SigScm_Read(ScmObj port);
-ScmObj SigScm_Read_Char(ScmObj port);
+ScmObj scm_read(ScmObj port);
+ScmObj scm_read_char(ScmObj port);
/* error.c */
-int SigScm_DebugCategories(void);
-void SigScm_SetDebugCategories(int categories);
-int SigScm_PredefinedDebugCategories(void);
-void SigScm_CategorizedDebug(int category, const char *msg, ...);
-void SigScm_Debug(const char *msg, ...);
-int SigScm_Die(const char *msg, const char *filename, int line);
-void SigScm_Error(const char *msg, ...) SCM_NORETURN;
-void SigScm_ErrorObj(const char *msg, ScmObj obj) SCM_NORETURN;
-void SigScm_ShowBacktrace(ScmObj trace_stack);
-ScmObj Scm_MakeErrorObj(ScmObj reason, ScmObj objs);
-void Scm_RaiseError(ScmObj err_obj) SCM_NORETURN;
-void Scm_FatalError(const char *msg) SCM_NORETURN;
-void Scm_SetFatalErrorCallback(void (*cb)(void));
-ScmObj ScmOp_error_objectp(ScmObj obj);
-ScmObj ScmOp_fatal_error(ScmObj err_obj) SCM_NORETURN;
-ScmObj ScmOp_inspect_error(ScmObj err_obj);
-ScmObj ScmOp_backtrace(void);
+int scm_debug_categories(void);
+void scm_set_debug_categories(int categories);
+int scm_predefined_debug_categories(void);
+void scm_categorized_debug(int category, const char *msg, ...);
+void scm_debug(const char *msg, ...);
+int scm_die(const char *msg, const char *filename, int line);
+void scm_error(const char *msg, ...) SCM_NORETURN;
+void scm_error_obj(const char *funcname, const char *msg, ScmObj obj) SCM_NORETURN;
+void scm_show_backtrace(ScmObj trace_stack);
+ScmObj scm_make_error_obj(ScmObj reason, ScmObj objs);
+void scm_raise_error(ScmObj err_obj) SCM_NORETURN;
+void scm_fatal_error(const char *msg) SCM_NORETURN;
+void scm_set_fatal_error_callback(void (*cb)(void));
+ScmObj scm_p_error_objectp(ScmObj obj);
+ScmObj scm_p_fatal_error(ScmObj err_obj) SCM_NORETURN;
+ScmObj scm_p_inspect_error(ScmObj err_obj);
+ScmObj scm_p_backtrace(void);
/* print.c */
-void SigScm_Display(ScmObj obj);
-void SigScm_WriteToPort(ScmObj port, ScmObj obj);
-void SigScm_DisplayToPort(ScmObj port, ScmObj obj);
+void scm_display(ScmObj obj);
+void scm_write_to_port(ScmObj port, ScmObj obj);
+void scm_display_to_port(ScmObj port, ScmObj obj);
#if SCM_USE_SRFI38
-void SigScm_WriteToPortWithSharedStructure(ScmObj port, ScmObj obj);
+void scm_write_to_port_with_shared_structure(ScmObj port, ScmObj obj);
#endif
@@ -993,105 +993,105 @@
===========================================================================*/
#if SCM_USE_SRFI1
/* operations-srfi1.c */
-void SigScm_Initialize_SRFI1(void);
-ScmObj ScmOp_SRFI1_xcons(ScmObj a, ScmObj b);
-ScmObj ScmOp_SRFI1_consstar(ScmObj args);
-ScmObj ScmOp_SRFI1_make_list(ScmObj length, ScmObj args);
-ScmObj ScmOp_SRFI1_list_tabulate(ScmObj scm_n, ScmObj args);
-ScmObj ScmOp_SRFI1_list_copy(ScmObj lst);
-ScmObj ScmOp_SRFI1_circular_list(ScmObj args);
-ScmObj ScmOp_SRFI1_iota(ScmObj scm_count, ScmObj args);
-ScmObj ScmOp_SRFI1_proper_listp(ScmObj lst);
-ScmObj ScmOp_SRFI1_circular_listp(ScmObj lst);
-ScmObj ScmOp_SRFI1_dotted_listp(ScmObj lst);
-ScmObj ScmOp_SRFI1_not_pairp(ScmObj pair);
-ScmObj ScmOp_SRFI1_null_listp(ScmObj lst);
-ScmObj ScmOp_SRFI1_listequal(ScmObj eqproc, ScmObj args);
-ScmObj ScmOp_SRFI1_first(ScmObj lst);
-ScmObj ScmOp_SRFI1_second(ScmObj lst);
-ScmObj ScmOp_SRFI1_third(ScmObj lst);
-ScmObj ScmOp_SRFI1_fourth(ScmObj lst);
-ScmObj ScmOp_SRFI1_fifth(ScmObj lst);
-ScmObj ScmOp_SRFI1_sixth(ScmObj lst);
-ScmObj ScmOp_SRFI1_seventh(ScmObj lst);
-ScmObj ScmOp_SRFI1_eighth(ScmObj lst);
-ScmObj ScmOp_SRFI1_ninth(ScmObj lst);
-ScmObj ScmOp_SRFI1_tenth(ScmObj lst);
-ScmObj ScmOp_SRFI1_carpluscdr(ScmObj lst);
-ScmObj ScmOp_SRFI1_take(ScmObj lst, ScmObj scm_idx);
-ScmObj ScmOp_SRFI1_drop(ScmObj lst, ScmObj scm_idx);
-ScmObj ScmOp_SRFI1_take_right(ScmObj lst, ScmObj scm_elem);
-ScmObj ScmOp_SRFI1_drop_right(ScmObj lst, ScmObj scm_elem);
-ScmObj ScmOp_SRFI1_taked(ScmObj lst, ScmObj scm_idx);
-ScmObj ScmOp_SRFI1_drop_rightd(ScmObj lst, ScmObj scm_idx);
-ScmObj ScmOp_SRFI1_split_at(ScmObj lst, ScmObj idx);
-ScmObj ScmOp_SRFI1_split_atd(ScmObj lst, ScmObj idx);
-ScmObj ScmOp_SRFI1_last(ScmObj lst);
-ScmObj ScmOp_SRFI1_last_pair(ScmObj lst);
-ScmObj ScmOp_SRFI1_lengthplus(ScmObj lst);
-ScmObj ScmOp_SRFI1_concatenate(ScmObj args);
+void scm_initialize_srfi1(void);
+ScmObj scm_p_srfi1_xcons(ScmObj a, ScmObj b);
+ScmObj scm_p_srfi1_consstar(ScmObj args);
+ScmObj scm_p_srfi1_make_list(ScmObj length, ScmObj args);
+ScmObj scm_p_srfi1_list_tabulate(ScmObj scm_n, ScmObj args);
+ScmObj scm_p_srfi1_list_copy(ScmObj lst);
+ScmObj scm_p_srfi1_circular_list(ScmObj args);
+ScmObj scm_p_srfi1_iota(ScmObj scm_count, ScmObj args);
+ScmObj scm_p_srfi1_proper_listp(ScmObj lst);
+ScmObj scm_p_srfi1_circular_listp(ScmObj lst);
+ScmObj scm_p_srfi1_dotted_listp(ScmObj lst);
+ScmObj scm_p_srfi1_not_pairp(ScmObj pair);
+ScmObj scm_p_srfi1_null_listp(ScmObj lst);
+ScmObj scm_p_srfi1_listequal(ScmObj eqproc, ScmObj args);
+ScmObj scm_p_srfi1_first(ScmObj lst);
+ScmObj scm_p_srfi1_second(ScmObj lst);
+ScmObj scm_p_srfi1_third(ScmObj lst);
+ScmObj scm_p_srfi1_fourth(ScmObj lst);
+ScmObj scm_p_srfi1_fifth(ScmObj lst);
+ScmObj scm_p_srfi1_sixth(ScmObj lst);
+ScmObj scm_p_srfi1_seventh(ScmObj lst);
+ScmObj scm_p_srfi1_eighth(ScmObj lst);
+ScmObj scm_p_srfi1_ninth(ScmObj lst);
+ScmObj scm_p_srfi1_tenth(ScmObj lst);
+ScmObj scm_p_srfi1_carpluscdr(ScmObj lst);
+ScmObj scm_p_srfi1_take(ScmObj lst, ScmObj scm_idx);
+ScmObj scm_p_srfi1_drop(ScmObj lst, ScmObj scm_idx);
+ScmObj scm_p_srfi1_take_right(ScmObj lst, ScmObj scm_elem);
+ScmObj scm_p_srfi1_drop_right(ScmObj lst, ScmObj scm_elem);
+ScmObj scm_p_srfi1_taked(ScmObj lst, ScmObj scm_idx);
+ScmObj scm_p_srfi1_drop_rightd(ScmObj lst, ScmObj scm_idx);
+ScmObj scm_p_srfi1_split_at(ScmObj lst, ScmObj idx);
+ScmObj scm_p_srfi1_split_atd(ScmObj lst, ScmObj idx);
+ScmObj scm_p_srfi1_last(ScmObj lst);
+ScmObj scm_p_srfi1_last_pair(ScmObj lst);
+ScmObj scm_p_srfi1_lengthplus(ScmObj lst);
+ScmObj scm_p_srfi1_concatenate(ScmObj args);
#endif
#if SCM_USE_SRFI2
/* operations-srfi2.c */
-void SigScm_Initialize_SRFI2(void);
-ScmObj ScmExp_SRFI2_and_letstar(ScmObj claws, ScmObj body, ScmEvalState *eval_state);
+void scm_initialize_srfi2(void);
+ScmObj scm_s_srfi2_and_letstar(ScmObj claws, ScmObj body, ScmEvalState *eval_state);
#endif
#if SCM_USE_SRFI6
/* operations-srfi6.c */
-void SigScm_Initialize_SRFI6(void);
-ScmObj ScmOp_SRFI6_open_input_string(ScmObj str);
-ScmObj ScmOp_SRFI6_open_output_string(void);
-ScmObj ScmOp_SRFI6_get_output_string(ScmObj port);
+void scm_initialize_srfi6(void);
+ScmObj scm_p_srfi6_open_input_string(ScmObj str);
+ScmObj scm_p_srfi6_open_output_string(void);
+ScmObj scm_p_srfi6_get_output_string(ScmObj port);
#endif
#if SCM_USE_SRFI8
/* operations-srfi8.c */
-void SigScm_Initialize_SRFI8(void);
-ScmObj ScmExp_SRFI8_receive(ScmObj formals, ScmObj expr, ScmObj body, ScmEvalState *eval_state);
+void scm_initialize_srfi8(void);
+ScmObj scm_s_srfi8_receive(ScmObj formals, ScmObj expr, ScmObj body, ScmEvalState *eval_state);
#endif
#if SCM_USE_SRFI23
/* operations-srfi23.c */
-void SigScm_Initialize_SRFI23(void);
-ScmObj ScmOp_SRFI23_error(ScmObj reason, ScmObj args);
+void scm_initialize_srfi23(void);
+ScmObj scm_p_srfi23_error(ScmObj reason, ScmObj args);
#endif
#if SCM_USE_SRFI34
/* operations-srfi34.c */
-void SigScm_Initialize_SRFI34(void);
-ScmObj ScmOp_SRFI34_with_exception_handler(ScmObj handler, ScmObj thunk);
-ScmObj ScmExp_SRFI34_guard(ScmObj cond_catch, ScmObj body,
+void scm_initialize_srfi34(void);
+ScmObj scm_p_srfi34_with_exception_handler(ScmObj handler, ScmObj thunk);
+ScmObj scm_s_srfi34_guard(ScmObj cond_catch, ScmObj body,
ScmEvalState *eval_state);
-ScmObj ScmOp_SRFI34_raise(ScmObj obj);
+ScmObj scm_p_srfi34_raise(ScmObj obj);
#endif
#if SCM_USE_SRFI38
/* operations-srfi38.c */
-void SigScm_Initialize_SRFI38(void);
-ScmObj ScmOp_SRFI38_write_with_shared_structure(ScmObj obj, ScmObj args);
+void scm_initialize_srfi38(void);
+ScmObj scm_p_srfi38_write_with_shared_structure(ScmObj obj, ScmObj args);
#endif
#if SCM_USE_SRFI60
/* operations-srfi60.c */
-void SigScm_Initialize_SRFI60(void);
-ScmObj ScmOp_SRFI60_logand(ScmObj left, ScmObj right,
+void scm_initialize_srfi60(void);
+ScmObj scm_p_srfi60_logand(ScmObj left, ScmObj right,
enum ScmReductionState *state);
-ScmObj ScmOp_SRFI60_logior(ScmObj left, ScmObj right,
+ScmObj scm_p_srfi60_logior(ScmObj left, ScmObj right,
enum ScmReductionState *state);
-ScmObj ScmOp_SRFI60_logxor(ScmObj left, ScmObj right,
+ScmObj scm_p_srfi60_logxor(ScmObj left, ScmObj right,
enum ScmReductionState *state);
-ScmObj ScmOp_SRFI60_lognot(ScmObj n);
-ScmObj ScmOp_SRFI60_bitwise_if(ScmObj mask, ScmObj n0, ScmObj n1);
-ScmObj ScmOp_SRFI60_logtest(ScmObj j, ScmObj k);
+ScmObj scm_p_srfi60_lognot(ScmObj n);
+ScmObj scm_p_srfi60_bitwise_if(ScmObj mask, ScmObj n0, ScmObj n1);
+ScmObj scm_p_srfi60_logtest(ScmObj j, ScmObj k);
#endif
#if SCM_COMPAT_SIOD
/* operations-siod.c */
-void SigScm_Initialize_SIOD(void);
-ScmObj ScmOp_symbol_value(ScmObj var);
-ScmObj ScmOp_set_symbol_valued(ScmObj var, ScmObj val);
-ScmObj ScmOp_SIOD_equal(ScmObj obj1, ScmObj obj2);
-ScmObj ScmOp_the_environment(ScmEvalState *eval_state);
-ScmObj ScmOp_closure_code(ScmObj closure);
-ScmObj ScmOp_verbose(ScmObj args);
-ScmObj ScmOp_eof_val(void);
-ScmObj ScmExp_undefine(ScmObj var, ScmObj env);
-long SigScm_GetVerboseLevel(void);
-void SigScm_SetVerboseLevel(long level);
+void scm_initialize_siod(void);
+ScmObj scm_p_symbol_value(ScmObj var);
+ScmObj scm_p_set_symbol_valued(ScmObj var, ScmObj val);
+ScmObj scm_p_siod_equal(ScmObj obj1, ScmObj obj2);
+ScmObj scm_p_the_environment(ScmEvalState *eval_state);
+ScmObj scm_p_closure_code(ScmObj closure);
+ScmObj scm_p_verbose(ScmObj args);
+ScmObj scm_p_eof_val(void);
+ScmObj scm_s_undefine(ScmObj var, ScmObj env);
+long scm_get_verbose_level(void);
+void scm_set_verbose_level(long level);
#endif
#ifdef __cplusplus
Modified: branches/r5rs/sigscheme/sigschemeinternal.h
===================================================================
--- branches/r5rs/sigscheme/sigschemeinternal.h 2005-12-16 08:29:32 UTC (rev 2609)
+++ branches/r5rs/sigscheme/sigschemeinternal.h 2005-12-16 09:06:42 UTC (rev 2610)
@@ -59,7 +59,7 @@
Variable Declarations
=======================================*/
/* sigscheme.c */
-extern ScmObj Scm_sym_else, Scm_sym_yields;
+extern ScmObj scm_sym_else, scm_sym_yields;
/* io.c */
extern ScmObj scm_current_input_port;
@@ -67,14 +67,14 @@
extern ScmObj scm_current_error_port;
/* print.c */
-extern void (*Scm_writess_func)(ScmObj port, ScmObj obj);
+extern void (*scm_writess_func)(ScmObj port, ScmObj obj);
/* read.c */
-extern const ScmSpecialCharInfo Scm_special_char_table[];
+extern const ScmSpecialCharInfo scm_special_char_table[];
/* storage.c */
#if SCM_USE_VALUECONS
-extern ScmObj SigScm_null_values;
+extern ScmObj scm_null_values;
#endif
/*=======================================
@@ -163,8 +163,8 @@
#define SYM_QUASIQUOTE SCM_SYM_QUASIQUOTE
#define SYM_UNQUOTE SCM_SYM_UNQUOTE
#define SYM_UNQUOTE_SPLICING SCM_SYM_UNQUOTE_SPLICING
-#define SYM_ELSE Scm_sym_else
-#define SYM_YIELDS Scm_sym_yields
+#define SYM_ELSE scm_sym_else
+#define SYM_YIELDS scm_sym_yields
#define EQ SCM_EQ
#define NULLP SCM_NULLP
@@ -261,7 +261,7 @@
*/
/* Obscures identifier ID. */
-#define SCM_MANGLE(id) Scm_internal_##id
+#define SCM_MANGLE(id) scm_internal_##id
#define VALIDP(obj) (!EQ((obj), SCM_INVALID))
#define INVALIDP(obj) (EQ((obj), SCM_INVALID))
@@ -282,12 +282,12 @@
/* Signals an error. The current function name and the message are
sent to the error port. The message is formatted by vfprintf(). */
-#define ERR SigScm_Error
+#define ERR scm_error
/* Signals an error that occured on an object. The current function
* name, the message, then the object, are written (with `write') to
* the error port. */
-#define ERR_OBJ(msg, obj) Scm_ErrorObj(SCM_MANGLE(name), (msg), (obj))
+#define ERR_OBJ(msg, obj) scm_error_obj(SCM_MANGLE(name), (msg), (obj))
/* ASSERT_NO_MORE_ARG() asserts that the variadic argument list has
* been exhausted. The assertion is implicit in NO_MORE_ARG(), so
@@ -304,7 +304,7 @@
#define ASSERT_NO_MORE_ARG(args) \
(NO_MORE_ARG(args) || (ERR_OBJ("superfluous argument(s)", (args)), 1))
#define ASSERT_PROPER_ARG_LIST(args) \
- (ScmOp_c_length(args) >= 0 \
+ (scm_p_c_length(args) >= 0 \
|| (ERR_OBJ("bad argument list", (args)), 1))
#else /* not SCM_STRICT_ARGCHECK */
#define NO_MORE_ARG(args) (!CONSP(args))
@@ -459,58 +459,58 @@
Function Declarations
=======================================*/
/* storage.c */
-void SigScm_InitStorage(size_t heap_size, size_t heap_alloc_threshold,
+void scm_init_storage(size_t heap_size, size_t heap_alloc_threshold,
int n_heaps_max, int n_heaps_init);
-void SigScm_FinalizeStorage(void);
+void scm_finalize_storage(void);
/* storage-gc.c */
-void SigScm_InitGC(size_t heap_size, size_t heap_alloc_threshold,
+void scm_init_gc(size_t heap_size, size_t heap_alloc_threshold,
int n_heaps_max, int n_heaps_init);
-void SigScm_FinalizeGC(void);
-ScmObj SigScm_NewObjFromHeap(void);
+void scm_finalize_gc(void);
+ScmObj scm_make_obj_from_heap(void);
/* storage-continuation.c */
-void SigScm_InitContinuation(void);
-void SigScm_FinalizeContinuation(void);
-void Scm_DestructContinuation(ScmObj cont);
-ScmObj Scm_CallWithCurrentContinuation(ScmObj proc, ScmEvalState *eval_state);
-void Scm_CallContinuation(ScmObj cont, ScmObj ret);
-ScmObj Scm_DynamicWind(ScmObj before, ScmObj thunk, ScmObj after);
-void Scm_PushTraceFrame(ScmObj obj, ScmObj env);
-void Scm_PopTraceFrame(void);
-ScmObj Scm_TraceStack(void);
+void scm_init_continuation(void);
+void scm_finalize_continuation(void);
+void scm_destruct_continuation(ScmObj cont);
+ScmObj scm_call_with_current_continuation(ScmObj proc, ScmEvalState *eval_state);
+void scm_call_continuation(ScmObj cont, ScmObj ret);
+ScmObj scm_dynamic_wind(ScmObj before, ScmObj thunk, ScmObj after);
+void scm_push_trace_frame(ScmObj obj, ScmObj env);
+void scm_pop_trace_frame(void);
+ScmObj scm_trace_stack(void);
/* storage-symbol.c */
-void SigScm_InitSymbol(void);
-void SigScm_FinalizeSymbol(void);
+void scm_init_symbol(void);
+void scm_finalize_symbol(void);
/* eval.c */
/* environment related functions */
-ScmObj Scm_ExtendEnvironment(ScmObj vars, ScmObj vals, ScmObj env);
-ScmObj Scm_AddEnvironment(ScmObj var, ScmObj val, ScmObj env);
-ScmRef Scm_LookupEnvironment(ScmObj var, ScmObj env);
-ScmObj Scm_SymbolValue(ScmObj var, ScmObj env);
+ScmObj scm_extend_environment(ScmObj vars, ScmObj vals, ScmObj env);
+ScmObj scm_add_environment(ScmObj var, ScmObj val, ScmObj env);
+ScmRef scm_lookup_environment(ScmObj var, ScmObj env);
+ScmObj scm_symbol_value(ScmObj var, ScmObj env);
-ScmObj Scm_eval(ScmObj obj, ScmObj env);
-ScmObj Scm_tailcall(ScmObj proc, ScmObj args, ScmEvalState *eval_state);
+ScmObj scm_eval(ScmObj obj, ScmObj env);
+ScmObj scm_tailcall(ScmObj proc, ScmObj args, ScmEvalState *eval_state);
-ScmObj ScmExp_cond_internal(ScmObj args, ScmObj case_key, ScmEvalState *eval_state);
+ScmObj scm_s_cond_internal(ScmObj args, ScmObj case_key, ScmEvalState *eval_state);
/* error.c */
-void SigScm_InitError(void);
-void Scm_ThrowException(ScmObj errorobj) SCM_NORETURN;
-void SigScm_ShowErrorHeader(void);
-void Scm_ErrorObj(const char *func_name, const char *msg, ScmObj obj) SCM_NORETURN;
+void scm_init_error(void);
+void scm_throw_exception(ScmObj errorobj) SCM_NORETURN;
+void scm_show_error_header(void);
+void scm_error_obj(const char *func_name, const char *msg, ScmObj obj) SCM_NORETURN;
/* operations.c */
-int ScmOp_c_length(ScmObj lst);
+int scm_p_c_length(ScmObj lst);
/* io.c */
-void Scm_InitIO(void);
-ScmCharPort *Scm_NewCharPort(ScmBytePort *bport);
+void scm_init_io(void);
+ScmCharPort *scm_make_char_port(ScmBytePort *bport);
/* sigscheme.c */
-char **Scm_InterpretArgv(char **argv);
-void Scm_FreeArgv(char **argv);
+char **scm_interpret_argv(char **argv);
+void scm_free_argv(char **argv);
#endif /* __SIGSCHEMEINTERNAL_H */
Modified: branches/r5rs/sigscheme/sigschemetype-compact.h
===================================================================
--- branches/r5rs/sigscheme/sigschemetype-compact.h 2005-12-16 08:29:32 UTC (rev 2609)
+++ branches/r5rs/sigscheme/sigschemetype-compact.h 2005-12-16 09:06:42 UTC (rev 2610)
@@ -235,24 +235,24 @@
Object Creators
============================================================================*/
#define SCM_MAKE_BOOL(x) ((x) ? SCM_TRUE : SCM_FALSE)
-#define SCM_MAKE_INT Scm_NewInt
-#define SCM_MAKE_CONS Scm_NewCons
-#define SCM_MAKE_SYMBOL Scm_NewSymbol
-#define SCM_MAKE_CHAR Scm_NewChar
-#define SCM_MAKE_STRING Scm_NewMutableString
-#define SCM_MAKE_STRING_COPYING Scm_NewMutableStringCopying
-#define SCM_MAKE_IMMUTABLE_STRING Scm_NewImmutableString
-#define SCM_MAKE_IMMUTABLE_STRING_COPYING Scm_NewImmutableStringCopying
-#define SCM_MAKE_FUNC Scm_NewFunc
-#define SCM_MAKE_CLOSURE Scm_NewClosure
-#define SCM_MAKE_VECTOR Scm_NewVector
-#define SCM_MAKE_PORT Scm_NewPort
-#define SCM_MAKE_CONTINUATION Scm_NewContinuation
+#define SCM_MAKE_INT scm_make_int
+#define SCM_MAKE_CONS scm_make_cons
+#define SCM_MAKE_SYMBOL scm_make_symbol
+#define SCM_MAKE_CHAR scm_make_char
+#define SCM_MAKE_STRING scm_make_mutable_string
+#define SCM_MAKE_STRING_COPYING scm_make_mutable_string_copying
+#define SCM_MAKE_IMMUTABLE_STRING scm_make_immutable_string
+#define SCM_MAKE_IMMUTABLE_STRING_COPYING scm_make_immutable_string_copying
+#define SCM_MAKE_FUNC scm_make_func
+#define SCM_MAKE_CLOSURE scm_make_closure
+#define SCM_MAKE_VECTOR scm_make_vector
+#define SCM_MAKE_PORT scm_make_port
+#define SCM_MAKE_CONTINUATION scm_make_continuation
#if SCM_USE_NONSTD_FEATURES
-#define SCM_MAKE_C_POINTER Scm_NewCPointer
-#define SCM_MAKE_C_FUNCPOINTER Scm_NewCFuncPointer
+#define SCM_MAKE_C_POINTER scm_make_cpointer
+#define SCM_MAKE_C_FUNCPOINTER scm_make_cfunc_pointer
#endif /* SCM_USE_NONSTD_FEATURES */
-#define SCM_MAKE_VALUEPACKET Scm_NewValuePacket
+#define SCM_MAKE_VALUEPACKET scm_make_value_packet
/*=======================================
Masks Offsets, and Tags
@@ -742,10 +742,10 @@
Predefined Symbols
============================================================================*/
/* for list construction */
-#define SCM_SYM_QUOTE Scm_sym_quote
-#define SCM_SYM_QUASIQUOTE Scm_sym_quasiquote
-#define SCM_SYM_UNQUOTE Scm_sym_unquote
-#define SCM_SYM_UNQUOTE_SPLICING Scm_sym_unquote_splicing
+#define SCM_SYM_QUOTE scm_sym_quote
+#define SCM_SYM_QUASIQUOTE scm_sym_quasiquote
+#define SCM_SYM_UNQUOTE scm_sym_unquote
+#define SCM_SYM_UNQUOTE_SPLICING scm_sym_unquote_splicing
/*============================================================================
Internal Declarations For Predefined Symbols
@@ -760,8 +760,8 @@
* defined above. They safely hides the internal model against such change.
*/
/* sigscheme.c */
-extern ScmObj Scm_sym_quote, Scm_sym_quasiquote;
-extern ScmObj Scm_sym_unquote, Scm_sym_unquote_splicing;
+extern ScmObj scm_sym_quote, scm_sym_quasiquote;
+extern ScmObj scm_sym_unquote, scm_sym_unquote_splicing;
/*============================================================================
Environment Specifiers
@@ -816,7 +816,7 @@
};
/* storage.c */
-#define SCM_TYPE(a) Scm_Type(a)
-extern enum ScmObjType Scm_Type(ScmObj obj);
+#define SCM_TYPE(a) scm_type(a)
+extern enum ScmObjType scm_type(ScmObj obj);
#endif /* __SIGSCMTYPE_COMPACT_H */
Modified: branches/r5rs/sigscheme/sigschemetype.h
===================================================================
--- branches/r5rs/sigscheme/sigschemetype.h 2005-12-16 08:29:32 UTC (rev 2609)
+++ branches/r5rs/sigscheme/sigschemetype.h 2005-12-16 09:06:42 UTC (rev 2610)
@@ -234,28 +234,28 @@
Object Creators
=======================================*/
#define SCM_MAKE_BOOL(x) ((x) ? SCM_TRUE : SCM_FALSE)
-#define SCM_MAKE_INT Scm_NewInt
-#define SCM_MAKE_CONS Scm_NewCons
-#define SCM_MAKE_SYMBOL Scm_NewSymbol
-#define SCM_MAKE_CHAR Scm_NewChar
-#define SCM_MAKE_STRING Scm_NewMutableString
-#define SCM_MAKE_STRING_COPYING Scm_NewMutableStringCopying
-#define SCM_MAKE_IMMUTABLE_STRING Scm_NewImmutableString
-#define SCM_MAKE_IMMUTABLE_STRING_COPYING Scm_NewImmutableStringCopying
-#define SCM_MAKE_FUNC Scm_NewFunc
-#define SCM_MAKE_CLOSURE Scm_NewClosure
-#define SCM_MAKE_VECTOR Scm_NewVector
-#define SCM_MAKE_PORT Scm_NewPort
-#define SCM_MAKE_CONTINUATION Scm_NewContinuation
+#define SCM_MAKE_INT scm_make_int
+#define SCM_MAKE_CONS scm_make_cons
+#define SCM_MAKE_SYMBOL scm_make_symbol
+#define SCM_MAKE_CHAR scm_make_char
+#define SCM_MAKE_STRING scm_make_mutable_string
+#define SCM_MAKE_STRING_COPYING scm_make_mutable_string_copying
+#define SCM_MAKE_IMMUTABLE_STRING scm_make_immutable_string
+#define SCM_MAKE_IMMUTABLE_STRING_COPYING scm_make_immutable_string_copying
+#define SCM_MAKE_FUNC scm_make_func
+#define SCM_MAKE_CLOSURE scm_make_closure
+#define SCM_MAKE_VECTOR scm_make_vector
+#define SCM_MAKE_PORT scm_make_port
+#define SCM_MAKE_CONTINUATION scm_make_continuation
#if SCM_USE_NONSTD_FEATURES
-#define SCM_MAKE_C_POINTER Scm_NewCPointer
-#define SCM_MAKE_C_FUNCPOINTER Scm_NewCFuncPointer
+#define SCM_MAKE_C_POINTER scm_make_cpointer
+#define SCM_MAKE_C_FUNCPOINTER scm_make_cfunc_pointer
#endif /* SCM_USE_NONSTD_FEATURES */
#if SCM_USE_VALUECONS
-#define SCM_MAKE_VALUEPACKET(vals) (NULLP(vals) ? SigScm_null_values : \
+#define SCM_MAKE_VALUEPACKET(vals) (NULLP(vals) ? scm_null_values : \
(SCM_ENTYPE_VALUEPACKET(vals), (vals)))
#else /* SCM_USE_VALUECONS */
-#define SCM_MAKE_VALUEPACKET(vals) (Scm_NewValuePacket(vals))
+#define SCM_MAKE_VALUEPACKET(vals) (scm_make_value_packet(vals))
#endif /* SCM_USE_VALUECONS */
/*=======================================
@@ -390,7 +390,7 @@
#if SCM_USE_VALUECONS
/* to modify a VALUECONS, rewrite its type to cons by SCM_ENTYPE_CONS(vcons) */
#define SCM_VALUEPACKETP(a) (SCM_TYPE(a) == ScmValuePacket)
-#define SCM_NULLVALUESP(a) (EQ((a), SigScm_null_values))
+#define SCM_NULLVALUESP(a) (EQ((a), scm_null_values))
#define SCM_ENTYPE_VALUEPACKET(a) (SCM_ENTYPE((a), ScmValuePacket))
#define SCM_VALUEPACKET_VALUES(a) ((SCM_NULLVALUESP(a)) ? SCM_NULL : \
(SCM_ENTYPE_CONS(a), (a)))
@@ -458,12 +458,12 @@
Special Constants and Predicates
============================================================================*/
#define SCM_INVALID NULL
-#define SCM_NULL SigScm_null
-#define SCM_TRUE SigScm_true
-#define SCM_FALSE SigScm_false
-#define SCM_EOF SigScm_eof
-#define SCM_UNBOUND SigScm_unbound
-#define SCM_UNDEF SigScm_undef
+#define SCM_NULL scm_null
+#define SCM_TRUE scm_true
+#define SCM_FALSE scm_false
+#define SCM_EOF scm_eof
+#define SCM_UNBOUND scm_unbound
+#define SCM_UNDEF scm_undef
#define SCM_EQ(a, b) ((a) == (b))
#define SCM_NULLP(a) (SCM_EQ((a), SCM_NULL))
@@ -475,10 +475,10 @@
Predefined Symbols
============================================================================*/
/* for list construction */
-#define SCM_SYM_QUOTE Scm_sym_quote
-#define SCM_SYM_QUASIQUOTE Scm_sym_quasiquote
-#define SCM_SYM_UNQUOTE Scm_sym_unquote
-#define SCM_SYM_UNQUOTE_SPLICING Scm_sym_unquote_splicing
+#define SCM_SYM_QUOTE scm_sym_quote
+#define SCM_SYM_QUASIQUOTE scm_sym_quasiquote
+#define SCM_SYM_UNQUOTE scm_sym_unquote
+#define SCM_SYM_UNQUOTE_SPLICING scm_sym_unquote_splicing
/*============================================================================
Internal Declarations For Special Constants And Predefined Symbols
@@ -493,11 +493,11 @@
* above. They safely hides the internal model against such change.
*/
/* storage.c */
-extern ScmObj SigScm_null, SigScm_true, SigScm_false, SigScm_eof;
-extern ScmObj SigScm_unbound, SigScm_undef;
+extern ScmObj scm_null, scm_true, scm_false, scm_eof;
+extern ScmObj scm_unbound, scm_undef;
/* sigscheme.c */
-extern ScmObj Scm_sym_quote, Scm_sym_quasiquote;
-extern ScmObj Scm_sym_unquote, Scm_sym_unquote_splicing;
+extern ScmObj scm_sym_quote, scm_sym_quasiquote;
+extern ScmObj scm_sym_unquote, scm_sym_unquote_splicing;
#endif /* __SIGSCMTYPE_H */
Modified: branches/r5rs/sigscheme/storage-continuation.c
===================================================================
--- branches/r5rs/sigscheme/storage-continuation.c 2005-12-16 08:29:32 UTC (rev 2609)
+++ branches/r5rs/sigscheme/storage-continuation.c 2005-12-16 09:06:42 UTC (rev 2610)
@@ -102,16 +102,18 @@
/*=======================================
Function Implementations
=======================================*/
-void SigScm_InitContinuation(void)
+void
+scm_init_continuation(void)
{
initialize_dynamic_extent();
initialize_continuation_env();
trace_stack = SCM_NULL;
- SigScm_GC_Protect((ScmObj *)&trace_stack);
+ scm_gc_protect((ScmObj *)&trace_stack);
}
-void SigScm_FinalizeContinuation(void)
+void
+scm_finalize_continuation(void)
{
finalize_continuation_env();
finalize_dynamic_extent();
@@ -127,7 +129,7 @@
static void initialize_dynamic_extent(void)
{
current_dynamic_extent = SCM_NULL;
- SigScm_GC_Protect((ScmObj *)¤t_dynamic_extent);
+ scm_gc_protect((ScmObj *)¤t_dynamic_extent);
}
static void finalize_dynamic_extent(void)
@@ -164,7 +166,7 @@
}
while (frame = POP_ARG(retpath), VALIDP(frame)) {
- Scm_call(DYNEXT_FRAME_BEFORE(frame), SCM_NULL);
+ scm_call(DYNEXT_FRAME_BEFORE(frame), SCM_NULL);
}
}
@@ -180,21 +182,22 @@
if (EQ(current_dynamic_extent, dest))
return;
frame = CAR(current_dynamic_extent);
- Scm_call(DYNEXT_FRAME_AFTER(frame), SCM_NULL);
+ scm_call(DYNEXT_FRAME_AFTER(frame), SCM_NULL);
}
}
-ScmObj Scm_DynamicWind(ScmObj before, ScmObj thunk, ScmObj after)
+ScmObj
+scm_dynamic_wind(ScmObj before, ScmObj thunk, ScmObj after)
{
ScmObj ret;
- Scm_call(before, SCM_NULL);
+ scm_call(before, SCM_NULL);
wind_onto_dynamic_extent(before, after);
- ret = Scm_call(thunk, SCM_NULL);
+ ret = scm_call(thunk, SCM_NULL);
unwind_dynamic_extent();
- Scm_call(after, SCM_NULL);
+ scm_call(after, SCM_NULL);
return ret;
}
@@ -205,7 +208,7 @@
static void initialize_continuation_env(void)
{
continuation_stack = SCM_NULL;
- SigScm_GC_Protect((ScmObj *)&continuation_stack);
+ scm_gc_protect((ScmObj *)&continuation_stack);
}
static void finalize_continuation_env(void)
@@ -246,12 +249,14 @@
return dest_cont;
}
-void Scm_DestructContinuation(ScmObj cont)
+void
+scm_destruct_continuation(ScmObj cont)
{
/* no object to free(3) in this implementation */
}
-ScmObj Scm_CallWithCurrentContinuation(ScmObj proc, ScmEvalState *eval_state)
+ScmObj
+scm_call_with_current_continuation(ScmObj proc, ScmEvalState *eval_state)
{
volatile ScmObj cont, ret;
struct continuation_frame cont_frame;
@@ -261,7 +266,7 @@
#if SCM_DEBUG
cont_frame.trace_stack = trace_stack;
#endif
- cont = Scm_NewContinuation();
+ cont = scm_make_continuation();
CONTINUATION_SET_FRAME(cont, &cont_frame);
#if SCM_NESTED_CONTINUATION_ONLY
continuation_stack_push(cont);
@@ -284,17 +289,17 @@
} else {
#if SCM_NESTED_CONTINUATION_ONLY
/* call proc with current continutation as (proc cont): This call must
- * not be Scm_tailcall(), to preserve current stack until longjmp()
+ * not be scm_tailcall(), to preserve current stack until longjmp()
* called.
*/
eval_state->ret_type = SCM_RETTYPE_AS_IS;
- ret = Scm_call(proc, LIST_1(cont));
+ ret = scm_call(proc, LIST_1(cont));
#else
/* ONLY FOR TESTING: This call is properly recursible, but all
* continuations are broken and cannot be called, if the continuation
* is implemented by longjmp().
*/
- ret = Scm_tailcall(proc, LIST_1(cont), eval_state);
+ ret = scm_tailcall(proc, LIST_1(cont), eval_state);
#endif
#if SCM_NESTED_CONTINUATION_ONLY
@@ -305,13 +310,14 @@
}
}
-void Scm_CallContinuation(ScmObj cont, ScmObj ret)
+void
+scm_call_continuation(ScmObj cont, ScmObj ret)
{
struct continuation_frame *frame;
#if SCM_NESTED_CONTINUATION_ONLY
ScmObj dst;
#endif
- DECLARE_INTERNAL_FUNCTION("Scm_CallContinuation");
+ DECLARE_INTERNAL_FUNCTION("scm_call_continuation");
frame = CONTINUATION_FRAME(cont);
@@ -335,14 +341,15 @@
longjmp(frame->c_env, 1);
/* NOTREACHED */
} else {
- ERR("Scm_CallContinuation: called expired continuation");
+ ERR("scm_call_continuation: called expired continuation");
}
}
/*============================================================================
Trace Stack
============================================================================*/
-void Scm_PushTraceFrame(ScmObj obj, ScmObj env)
+void
+scm_push_trace_frame(ScmObj obj, ScmObj env)
{
ScmObj frame;
@@ -350,12 +357,14 @@
trace_stack = CONS(frame, trace_stack);
}
-void Scm_PopTraceFrame(void)
+void
+scm_pop_trace_frame(void)
{
trace_stack = CDR(trace_stack);
}
-ScmObj Scm_TraceStack(void)
+ScmObj
+scm_trace_stack(void)
{
return trace_stack;
}
Modified: branches/r5rs/sigscheme/storage-fatty.h
===================================================================
--- branches/r5rs/sigscheme/storage-fatty.h 2005-12-16 08:29:32 UTC (rev 2609)
+++ branches/r5rs/sigscheme/storage-fatty.h 2005-12-16 09:06:42 UTC (rev 2610)
@@ -138,28 +138,28 @@
/*=======================================
Object Creators
=======================================*/
-#define SCM_SAL_MAKE_INT Scm_NewInt
-#define SCM_SAL_MAKE_CONS Scm_NewCons
-#define SCM_SAL_MAKE_SYMBOL Scm_NewSymbol
-#define SCM_SAL_MAKE_CHAR Scm_NewChar
-#define SCM_SAL_MAKE_STRING Scm_NewMutableString
-#define SCM_SAL_MAKE_STRING_COPYING Scm_NewMutableStringCopying
-#define SCM_SAL_MAKE_IMMUTABLE_STRING Scm_NewImmutableString
-#define SCM_SAL_MAKE_IMMUTABLE_STRING_COPYING Scm_NewImmutableStringCopying
-#define SCM_SAL_MAKE_FUNC Scm_NewFunc
-#define SCM_SAL_MAKE_CLOSURE Scm_NewClosure
-#define SCM_SAL_MAKE_VECTOR Scm_NewVector
-#define SCM_SAL_MAKE_PORT Scm_NewPort
-#define SCM_SAL_MAKE_CONTINUATION Scm_NewContinuation
+#define SCM_SAL_MAKE_INT scm_make_int
+#define SCM_SAL_MAKE_CONS scm_make_cons
+#define SCM_SAL_MAKE_SYMBOL scm_make_symbol
+#define SCM_SAL_MAKE_CHAR scm_make_char
+#define SCM_SAL_MAKE_STRING scm_make_mutable_string
+#define SCM_SAL_MAKE_STRING_COPYING scm_make_mutable_string_copying
+#define SCM_SAL_MAKE_IMMUTABLE_STRING scm_make_immutable_string
+#define SCM_SAL_MAKE_IMMUTABLE_STRING_COPYING scm_make_immutable_string_copying
+#define SCM_SAL_MAKE_FUNC scm_make_func
+#define SCM_SAL_MAKE_CLOSURE scm_make_closure
+#define SCM_SAL_MAKE_VECTOR scm_make_vector
+#define SCM_SAL_MAKE_PORT scm_make_port
+#define SCM_SAL_MAKE_CONTINUATION scm_make_continuation
#if SCM_USE_NONSTD_FEATURES
-#define SCM_SAL_MAKE_C_POINTER Scm_NewCPointer
-#define SCM_SAL_MAKE_C_FUNCPOINTER Scm_NewCFuncPointer
+#define SCM_SAL_MAKE_C_POINTER scm_make_cpointer
+#define SCM_SAL_MAKE_C_FUNCPOINTER scm_make_cfunc_pointer
#endif /* SCM_USE_NONSTD_FEATURES */
#if SCM_USE_VALUECONS
-#define SCM_SAL_MAKE_VALUEPACKET(vals) (NULLP(vals) ? SigScm_null_values : \
+#define SCM_SAL_MAKE_VALUEPACKET(vals) (NULLP(vals) ? scm_null_values : \
(SCM_ENTYPE_VALUEPACKET(vals), (vals)))
#else /* SCM_USE_VALUECONS */
-#define SCM_SAL_MAKE_VALUEPACKET(vals) (Scm_NewValuePacket(vals))
+#define SCM_SAL_MAKE_VALUEPACKET(vals) (scm_make_value_packet(vals))
#endif /* SCM_USE_VALUECONS */
/*=======================================
@@ -268,7 +268,7 @@
#if SCM_USE_VALUECONS
/* to modify a VALUECONS, rewrite its type to cons by SCM_ENTYPE_CONS(vcons) */
#define SCM_SAL_VALUEPACKETP(a) (SCM_TYPE(a) == ScmValuePacket)
-#define SCM_SAL_NULLVALUESP(a) (EQ((a), SigScm_null_values))
+#define SCM_SAL_NULLVALUESP(a) (EQ((a), scm_null_values))
#define SCM_SAL_ENTYPE_VALUEPACKET(a) (SCM_ENTYPE((a), ScmValuePacket))
#define SCM_SAL_VALUEPACKET_VALUES(a) ((SCM_NULLVALUESP(a)) ? SCM_NULL : \
(SCM_ENTYPE_CONS(a), (a)))
@@ -364,30 +364,30 @@
Special Constants and Predicates
============================================================================*/
#define SCM_SAL_INVALID NULL
-#define SCM_SAL_NULL SigScm_null
-#define SCM_SAL_TRUE SigScm_true
-#define SCM_SAL_FALSE SigScm_false
-#define SCM_SAL_EOF SigScm_eof
-#define SCM_SAL_UNBOUND SigScm_unbound
-#define SCM_SAL_UNDEF SigScm_undef
+#define SCM_SAL_NULL scm_null
+#define SCM_SAL_TRUE scm_true
+#define SCM_SAL_FALSE scm_false
+#define SCM_SAL_EOF scm_eof
+#define SCM_SAL_UNBOUND scm_unbound
+#define SCM_SAL_UNDEF scm_undef
#define SCM_SAL_EQ(a, b) ((a) == (b))
/* storage.c */
-extern ScmObj SigScm_null, SigScm_true, SigScm_false, SigScm_eof;
-extern ScmObj SigScm_unbound, SigScm_undef;
+extern ScmObj scm_null, scm_true, scm_false, scm_eof;
+extern ScmObj scm_unbound, scm_undef;
/*============================================================================
Predefined Symbols
============================================================================*/
/* for list construction */
-#define SCM_SAL_SYM_QUOTE Scm_sym_quote
-#define SCM_SAL_SYM_QUASIQUOTE Scm_sym_quasiquote
-#define SCM_SAL_SYM_UNQUOTE Scm_sym_unquote
-#define SCM_SAL_SYM_UNQUOTE_SPLICING Scm_sym_unquote_splicing
+#define SCM_SAL_SYM_QUOTE scm_sym_quote
+#define SCM_SAL_SYM_QUASIQUOTE scm_sym_quasiquote
+#define SCM_SAL_SYM_UNQUOTE scm_sym_unquote
+#define SCM_SAL_SYM_UNQUOTE_SPLICING scm_sym_unquote_splicing
/* sigscheme.c */
-extern ScmObj Scm_sym_quote, Scm_sym_quasiquote;
-extern ScmObj Scm_sym_unquote, Scm_sym_unquote_splicing;
+extern ScmObj scm_sym_quote, scm_sym_quasiquote;
+extern ScmObj scm_sym_unquote, scm_sym_unquote_splicing;
#endif /* __STORAGE_FATTY_H */
Modified: branches/r5rs/sigscheme/storage-gc.c
===================================================================
--- branches/r5rs/sigscheme/storage-gc.c 2005-12-16 08:29:32 UTC (rev 2609)
+++ branches/r5rs/sigscheme/storage-gc.c 2005-12-16 09:06:42 UTC (rev 2610)
@@ -44,7 +44,7 @@
*
* - gc_mark_protected_var()
* marks Scheme objects held in off-heap locations that registered by
- * SigScm_GC_Protect().
+ * scm_gc_protect().
*
* - gc_mark_definite_locations_n()
* marks Scheme objects that held in the symbol table.
@@ -102,7 +102,7 @@
#if UIM_SCM_GCC4_READY_GC
/* See also the comment about these variables in sigscheme.h */
ScmObj *(*volatile scm_gc_protect_stack)(ScmObj *)
- = &SigScm_GC_ProtectStackInternal;
+ = &scm_gc_protect_stack_internal;
#endif /* UIM_SCM_GCC4_READY_GC */
static ScmObj **protected_vars;
@@ -142,7 +142,7 @@
/*=======================================
Function Implementations
=======================================*/
-void SigScm_InitGC(size_t heap_size, size_t heap_alloc_threshold,
+void scm_init_gc(size_t heap_size, size_t heap_alloc_threshold,
int n_heaps_max, int n_heaps_init)
{
stack_start_pointer = NULL;
@@ -152,13 +152,15 @@
initialize_heap(heap_size, heap_alloc_threshold, n_heaps_max, n_heaps_init);
}
-void SigScm_FinalizeGC(void)
+void
+scm_finalize_gc(void)
{
finalize_heap();
finalize_protected_var();
}
-ScmObj SigScm_NewObjFromHeap(void)
+ScmObj
+scm_make_obj_from_heap(void)
{
ScmObj ret = SCM_FALSE;
@@ -195,7 +197,8 @@
return NULL;
}
-void SigScm_GC_Protect(ScmObj *var)
+void
+scm_gc_protect(ScmObj *var)
{
ScmObj **slot;
size_t new_size;
@@ -211,7 +214,8 @@
*slot = var;
}
-void SigScm_GC_Unprotect(ScmObj *var)
+void
+scm_gc_unprotect(ScmObj *var)
{
ScmObj **slot;
@@ -226,7 +230,8 @@
C Stack Protection
============================================================================*/
#if SCM_GCC4_READY_GC
-ScmObj *SigScm_GC_ProtectStackInternal(ScmObj *designated_stack_start)
+ScmObj *
+scm_gc_protect_stack_internal(ScmObj *designated_stack_start)
{
/*
* &stack_start will be relocated to start of the frame of subsequent
@@ -246,14 +251,16 @@
#else /* SCM_GCC4_READY_GC */
-void SigScm_GC_ProtectStack(ScmObj *stack_start)
+void
+scm_gc_protect_stack(ScmObj *stack_start)
{
if (!stack_start_pointer)
stack_start_pointer = stack_start;
}
#endif /* SCM_GCC4_READY_GC */
-void SigScm_GC_UnprotectStack(ScmObj *stack_start)
+void
+scm_gc_unprotect_stack(ScmObj *stack_start)
{
if (stack_start_pointer == stack_start)
stack_start_pointer = NULL;
@@ -288,7 +295,7 @@
CDBG((SCM_DBG_GC, "add_heap current num of heaps:%d", n_heaps));
if (n_heaps_max <= n_heaps)
- Scm_FatalError("heap exhausted");
+ scm_fatal_error("heap exhausted");
heaps = scm_realloc(heaps, sizeof(ScmObjHeap) * (n_heaps + 1));
heap = scm_malloc_aligned(sizeof(ScmCell) * heap_size);
@@ -529,7 +536,7 @@
* module-specific header file which contains the module-specific
* destruction macro.
*/
- Scm_DestructContinuation(cell);
+ scm_destruct_continuation(cell);
}
}
#else /* SCM_OBJ_COMPACT */
@@ -569,7 +576,7 @@
* module-specific header file which contains the module-specific
* destruction macro.
*/
- Scm_DestructContinuation(cell);
+ scm_destruct_continuation(cell);
break;
case ScmFunc:
Modified: branches/r5rs/sigscheme/storage-protection.c
===================================================================
--- branches/r5rs/sigscheme/storage-protection.c 2005-12-16 08:29:32 UTC (rev 2609)
+++ branches/r5rs/sigscheme/storage-protection.c 2005-12-16 09:06:42 UTC (rev 2610)
@@ -57,20 +57,20 @@
* ScmObj str_port = SCM_FALSE;
* ScmObj ret = SCM_FALSE;
*
- * SigScm_GC_ProtectStack(&stack_start);
+ * scm_gc_protect_stack(&stack_start);
*
- * str_port = Scm_NewStringPort(exp);
- * ret = SigScm_Read(str_port);
+ * str_port = scm_make_string_port(exp);
+ * ret = scm_read(str_port);
* ret = EVAL(ret, SCM_NULL);
*
- * SigScm_GC_UnprotectStack(stack_start);
+ * scm_gc_unprotect_stack(stack_start);
* }
*
* The previous strategy assumes that stack_start is certainly located at
* lower than str_port and ret. But the optimization breaks the assumption as
* follows.
*
- * At the breakpoint immediately before SigScm_GC_ProtectStack() of the code
+ * At the breakpoint immediately before scm_gc_protect_stack() of the code
* compiled with gcc4 ((GCC) 4.0.1 20050617 (prerelease) (Debian 4.0.0-10)
* (IA32)), actual storage layout had reported as follows.
*
@@ -109,8 +109,8 @@
* ScmObj str_port = SCM_FALSE;
* ScmObj ret = SCM_FALSE;
*
- * str_port = Scm_NewStringPort(exp);
- * ret = SigScm_Read(str_port);
+ * str_port = scm_make_string_port(exp);
+ * ret = scm_read(str_port);
* ret = EVAL(ret, SCM_NULL);
* return SCM_STRING_STR(ret);
* }
@@ -127,8 +127,8 @@
* ScmObj str_port = SCM_FALSE;
* ScmObj ret = SCM_FALSE;
*
- * str_port = Scm_NewStringPort(exp);
- * ret = SigScm_Read(str_port);
+ * str_port = scm_make_string_port(exp);
+ * ret = scm_read(str_port);
* ret = EVAL(ret, SCM_NULL);
* return SCM_STRING_STR(ret);
* }
@@ -188,7 +188,7 @@
*
* To avoid this condition, gc_protect_stack() and gc_unprotect_stack()
* must certainly be invoked in a separated function which will not be
- * inlined. So SigScm_GC_CallProtectedFuncn() are prepared as function.
+ * inlined. So scm_gc_call_protected_funcn() are prepared as function.
*
* -- YamaKen 2005-09-07
*/
Modified: branches/r5rs/sigscheme/storage-symbol.c
===================================================================
--- branches/r5rs/sigscheme/storage-symbol.c 2005-12-16 08:29:32 UTC (rev 2609)
+++ branches/r5rs/sigscheme/storage-symbol.c 2005-12-16 09:06:42 UTC (rev 2610)
@@ -66,7 +66,8 @@
/*=======================================
Function Implementations
=======================================*/
-ScmObj Scm_Intern(const char *name)
+ScmObj
+scm_intern(const char *name)
{
ScmObj sym, lst, rest;
int hash;
@@ -81,14 +82,15 @@
}
/* if not found, allocate new symbol object and prepend it into the list */
- sym = Scm_NewSymbol(strdup(name), SCM_UNBOUND);
+ sym = scm_make_symbol(strdup(name), SCM_UNBOUND);
scm_symbol_hash[hash] = CONS(sym, lst);
return sym;
}
/* lookup the symbol bound to an obj reversely */
-ScmObj Scm_SymbolBoundTo(ScmObj obj)
+ScmObj
+scm_symbol_bound_to(ScmObj obj)
{
int i;
ScmObj lst, sym, val;
@@ -105,12 +107,14 @@
return SCM_FALSE;
}
-void SigScm_InitSymbol(void)
+void
+scm_init_symbol(void)
{
initialize_symbol_hash();
}
-void SigScm_FinalizeSymbol(void)
+void
+scm_finalize_symbol(void)
{
finalize_symbol_hash();
}
Modified: branches/r5rs/sigscheme/storage.c
===================================================================
--- branches/r5rs/sigscheme/storage.c 2005-12-16 08:29:32 UTC (rev 2609)
+++ branches/r5rs/sigscheme/storage.c 2005-12-16 09:06:42 UTC (rev 2610)
@@ -66,15 +66,15 @@
=======================================*/
/* multiple values */
#if SCM_USE_VALUECONS
-ScmObj SigScm_null_values;
+ScmObj scm_null_values;
#endif
#if !SCM_OBJ_COMPACT
/* SCM_OBJ_COMPACT MUST NOT refer these variables. Use SCM_NULL and so on. */
/* constants */
-ScmObj SigScm_null, SigScm_true, SigScm_false, SigScm_eof;
-ScmObj SigScm_unbound, SigScm_undef;
+ScmObj scm_null, scm_true, scm_false, scm_eof;
+ScmObj scm_unbound, scm_undef;
static ScmCell null_cell, true_cell, false_cell, eof_cell;
static ScmCell unbound_cell, undef_cell;
#endif
@@ -87,16 +87,16 @@
/*=======================================
Function Implementations
=======================================*/
-void SigScm_InitStorage(size_t heap_size, size_t heap_alloc_threshold,
+void scm_init_storage(size_t heap_size, size_t heap_alloc_threshold,
int n_heaps_max, int n_heaps_init)
{
initialize_special_constants();
- SigScm_InitGC(heap_size, heap_alloc_threshold, n_heaps_max, n_heaps_init);
+ scm_init_gc(heap_size, heap_alloc_threshold, n_heaps_max, n_heaps_init);
#if 0 && (SCM_COMPAT_SIOD_BUGS && !SCM_OBJ_COMPACT)
- SigScm_GC_Protect(&SigScm_true);
- SigScm_true = Scm_NewInt(1);
+ scm_gc_protect(&scm_true);
+ scm_true = scm_make_int(1);
#endif
#if SCM_USE_VALUECONS
@@ -104,20 +104,21 @@
* To keep storage model abstract, the cell is allocated from a heap
* instead of directly construct ScmCell
*/
- SigScm_null_values = CONS(SCM_NULL, SCM_NULL);
- SCM_ENTYPE_VALUEPACKET(SigScm_null_values);
- SigScm_GC_Protect(&SigScm_null_values);
+ scm_null_values = CONS(SCM_NULL, SCM_NULL);
+ SCM_ENTYPE_VALUEPACKET(scm_null_values);
+ scm_gc_protect(&scm_null_values);
#endif
- SigScm_InitContinuation();
- SigScm_InitSymbol();
+ scm_init_continuation();
+ scm_init_symbol();
}
-void SigScm_FinalizeStorage(void)
+void
+scm_finalize_storage(void)
{
- SigScm_FinalizeSymbol();
- SigScm_FinalizeContinuation();
- SigScm_FinalizeGC();
+ scm_finalize_symbol();
+ scm_finalize_continuation();
+ scm_finalize_gc();
}
/*===========================================================================
@@ -131,15 +132,15 @@
static void initialize_special_constants(void)
{
#if !SCM_OBJ_COMPACT
- SCM_CONSTANT_BIND_SUBSTANCE(SigScm_null, null_cell);
- SCM_CONSTANT_BIND_SUBSTANCE(SigScm_true, true_cell);
- SCM_CONSTANT_BIND_SUBSTANCE(SigScm_false, false_cell);
- SCM_CONSTANT_BIND_SUBSTANCE(SigScm_eof, eof_cell);
- SCM_CONSTANT_BIND_SUBSTANCE(SigScm_unbound, unbound_cell);
- SCM_CONSTANT_BIND_SUBSTANCE(SigScm_undef, undef_cell);
+ SCM_CONSTANT_BIND_SUBSTANCE(scm_null, null_cell);
+ SCM_CONSTANT_BIND_SUBSTANCE(scm_true, true_cell);
+ SCM_CONSTANT_BIND_SUBSTANCE(scm_false, false_cell);
+ SCM_CONSTANT_BIND_SUBSTANCE(scm_eof, eof_cell);
+ SCM_CONSTANT_BIND_SUBSTANCE(scm_unbound, unbound_cell);
+ SCM_CONSTANT_BIND_SUBSTANCE(scm_undef, undef_cell);
#if SCM_COMPAT_SIOD_BUGS
- SigScm_false = SigScm_null;
+ scm_false = scm_null;
#endif /* SCM_COMPAT_SIOD_BUGS */
#endif /* !SCM_OBJ_COMPACT */
}
@@ -147,9 +148,10 @@
/*===========================================================================
Object Allocators
===========================================================================*/
-ScmObj Scm_NewCons(ScmObj a, ScmObj b)
+ScmObj
+scm_make_cons(ScmObj a, ScmObj b)
{
- ScmObj obj = SigScm_NewObjFromHeap();
+ ScmObj obj = scm_make_obj_from_heap();
SCM_ENTYPE_CONS(obj);
SET_CAR(obj, a);
@@ -158,9 +160,10 @@
return obj;
}
-ScmObj Scm_NewInt(int val)
+ScmObj
+scm_make_int(int val)
{
- ScmObj obj = SigScm_NewObjFromHeap();
+ ScmObj obj = scm_make_obj_from_heap();
SCM_ENTYPE_INT(obj);
SCM_INT_SET_VALUE(obj, val);
@@ -168,9 +171,10 @@
return obj;
}
-ScmObj Scm_NewSymbol(char *name, ScmObj v_cell)
+ScmObj
+scm_make_symbol(char *name, ScmObj v_cell)
{
- ScmObj obj = SigScm_NewObjFromHeap();
+ ScmObj obj = scm_make_obj_from_heap();
SCM_ENTYPE_SYMBOL(obj);
SCM_SYMBOL_SET_NAME(obj, name);
@@ -179,9 +183,10 @@
return obj;
}
-ScmObj Scm_NewChar(int val)
+ScmObj
+scm_make_char(int val)
{
- ScmObj obj = SigScm_NewObjFromHeap();
+ ScmObj obj = scm_make_obj_from_heap();
SCM_ENTYPE_CHAR(obj);
SCM_CHAR_SET_VALUE(obj, val);
@@ -189,13 +194,14 @@
return obj;
}
-ScmObj Scm_NewString(char *str, int is_immutable)
+ScmObj
+scm_make_string(char *str, int is_immutable)
{
- ScmObj obj = SigScm_NewObjFromHeap();
+ ScmObj obj = scm_make_obj_from_heap();
SCM_ENTYPE_STRING(obj);
SCM_STRING_SET_STR(obj, str);
- SCM_STRING_SET_LEN(obj, str ? Scm_mb_bare_c_strlen(str) : 0);
+ SCM_STRING_SET_LEN(obj, str ? scm_mb_bare_c_strlen(str) : 0);
if (is_immutable)
SCM_STRING_SET_IMMUTABLE(obj);
@@ -205,29 +211,34 @@
return obj;
}
-ScmObj Scm_NewImmutableString(char *str)
+ScmObj
+scm_make_immutable_string(char *str)
{
- return Scm_NewString(str, 1);
+ return scm_make_string(str, 1);
}
-ScmObj Scm_NewImmutableStringCopying(const char *str)
+ScmObj
+scm_make_immutable_string_copying(const char *str)
{
- return Scm_NewString(strdup(str), 1);
+ return scm_make_string(strdup(str), 1);
}
-ScmObj Scm_NewMutableString(char *str)
+ScmObj
+scm_make_mutable_string(char *str)
{
- return Scm_NewString(str, 0);
+ return scm_make_string(str, 0);
}
-ScmObj Scm_NewMutableStringCopying(const char *str)
+ScmObj
+scm_make_mutable_string_copying(const char *str)
{
- return Scm_NewString(strdup(str), 0);
+ return scm_make_string(strdup(str), 0);
}
-ScmObj Scm_NewFunc(enum ScmFuncTypeCode type, ScmFuncType func)
+ScmObj
+scm_make_func(enum ScmFuncTypeCode type, ScmFuncType func)
{
- ScmObj obj = SigScm_NewObjFromHeap();
+ ScmObj obj = scm_make_obj_from_heap();
SCM_ENTYPE_FUNC(obj);
SCM_FUNC_SET_TYPECODE(obj, type);
@@ -236,9 +247,10 @@
return obj;
}
-ScmObj Scm_NewClosure(ScmObj exp, ScmObj env)
+ScmObj
+scm_make_closure(ScmObj exp, ScmObj env)
{
- ScmObj obj = SigScm_NewObjFromHeap();
+ ScmObj obj = scm_make_obj_from_heap();
SCM_ENTYPE_CLOSURE(obj);
SCM_CLOSURE_SET_EXP(obj, exp);
@@ -247,9 +259,10 @@
return obj;
}
-ScmObj Scm_NewVector(ScmObj *vec, int len)
+ScmObj
+scm_make_vector(ScmObj *vec, int len)
{
- ScmObj obj = SigScm_NewObjFromHeap();
+ ScmObj obj = scm_make_obj_from_heap();
SCM_ENTYPE_VECTOR(obj);
SCM_VECTOR_SET_VEC(obj, vec);
@@ -258,9 +271,10 @@
return obj;
}
-ScmObj Scm_NewPort(ScmCharPort *cport, enum ScmPortFlag flag)
+ScmObj
+scm_make_port(ScmCharPort *cport, enum ScmPortFlag flag)
{
- ScmObj obj = SigScm_NewObjFromHeap();
+ ScmObj obj = scm_make_obj_from_heap();
SCM_ENTYPE_PORT(obj);
@@ -275,9 +289,10 @@
return obj;
}
-ScmObj Scm_NewContinuation(void)
+ScmObj
+scm_make_continuation(void)
{
- ScmObj obj = SigScm_NewObjFromHeap();
+ ScmObj obj = scm_make_obj_from_heap();
SCM_ENTYPE_CONTINUATION(obj);
SCM_CONTINUATION_SET_OPAQUE(obj, INVALID_CONTINUATION_OPAQUE);
@@ -287,9 +302,10 @@
}
#if !SCM_USE_VALUECONS
-ScmObj Scm_NewValuePacket(ScmObj values)
+ScmObj
+scm_make_value_packet(ScmObj values)
{
- ScmObj obj = SigScm_NewObjFromHeap();
+ ScmObj obj = scm_make_obj_from_heap();
SCM_ENTYPE_VALUEPACKET(obj);
SCM_VALUEPACKET_SET_VALUES(obj, values);
@@ -299,9 +315,10 @@
#endif
#if SCM_USE_NONSTD_FEATURES
-ScmObj Scm_NewCPointer(void *data)
+ScmObj
+scm_make_cpointer(void *data)
{
- ScmObj obj = SigScm_NewObjFromHeap();
+ ScmObj obj = scm_make_obj_from_heap();
SCM_ENTYPE_C_POINTER(obj);
SCM_C_POINTER_SET_VALUE(obj, data);
@@ -309,9 +326,10 @@
return obj;
}
-ScmObj Scm_NewCFuncPointer(ScmCFunc func)
+ScmObj
+scm_make_cfunc_pointer(ScmCFunc func)
{
- ScmObj obj = SigScm_NewObjFromHeap();
+ ScmObj obj = scm_make_obj_from_heap();
SCM_ENTYPE_C_FUNCPOINTER(obj);
SCM_C_FUNCPOINTER_SET_VALUE(obj, func);
@@ -321,7 +339,8 @@
#endif /* SCM_USE_NONSTD_FEATURES */
#if SCM_OBJ_COMPACT
-enum ScmObjType Scm_Type(ScmObj obj)
+enum ScmObjType
+scm_type(ScmObj obj)
{
if (SCM_TAG_CONSP(obj)) {
return ScmCons;
Modified: branches/r5rs/sigscheme/strport.c
===================================================================
--- branches/r5rs/sigscheme/strport.c 2005-12-16 08:29:32 UTC (rev 2609)
+++ branches/r5rs/sigscheme/strport.c 2005-12-16 09:06:42 UTC (rev 2610)
@@ -159,7 +159,8 @@
* Client code must call this first even if current implementation does not
* contain actual code.
*/
-void Scm_strport_init(void)
+void
+scm_strport_init(void)
{
return;
}
Modified: branches/r5rs/sigscheme/strport.h
===================================================================
--- branches/r5rs/sigscheme/strport.h 2005-12-16 08:29:32 UTC (rev 2609)
+++ branches/r5rs/sigscheme/strport.h 2005-12-16 09:06:42 UTC (rev 2610)
@@ -70,7 +70,7 @@
/*=======================================
Function Declarations
=======================================*/
-void Scm_strport_init(void);
+void scm_strport_init(void);
ScmBytePort *ScmInputStrPort_new(char *str,
ScmInputStrPort_finalizer finalize);
Modified: branches/r5rs/sigscheme/test-compact.c
===================================================================
--- branches/r5rs/sigscheme/test-compact.c 2005-12-16 08:29:32 UTC (rev 2609)
+++ branches/r5rs/sigscheme/test-compact.c 2005-12-16 09:06:42 UTC (rev 2610)
@@ -178,7 +178,8 @@
return ret;
}
-ScmObj Scm_CheckInt(int val)
+ScmObj
+scm_check_int(int val)
{
ScmObj obj;
@@ -194,11 +195,12 @@
return obj;
}
-ScmObj Scm_CheckCons()
+ScmObj
+scm_check_cons()
{
ScmObj obj = (ScmObj)malloc(sizeof(ScmCell));
- ScmObj car = Scm_CheckInt(1);
- ScmObj cdr = Scm_CheckInt(2);
+ ScmObj car = scm_check_int(1);
+ ScmObj cdr = scm_check_int(2);
PRINT_SECTION("Cons");
@@ -245,10 +247,11 @@
return obj;
}
-ScmObj Scm_CheckSymbol(const char *name)
+ScmObj
+scm_check_symbol(const char *name)
{
ScmObj obj = (ScmObj)malloc(sizeof(ScmCell));
- ScmObj vcell = Scm_CheckInt(1);
+ ScmObj vcell = scm_check_int(1);
PRINT_SECTION("Symbol");
@@ -291,7 +294,8 @@
return obj;
}
-ScmObj Scm_CheckChar(unsigned int val)
+ScmObj
+scm_check_char(unsigned int val)
{
ScmObj obj;
PRINT_SECTION("Char");
@@ -307,7 +311,8 @@
return obj;
}
-ScmObj Scm_CheckStringCopying(char *str)
+ScmObj
+scm_check_string_copying(char *str)
{
ScmObj obj = (ScmObj)malloc(sizeof(ScmCell));
@@ -372,7 +377,8 @@
return obj;
}
-ScmObj Scm_CheckFunc(void *funcptr)
+ScmObj
+scm_check_func(void *funcptr)
{
ScmObj obj = (ScmObj)malloc(sizeof(ScmCell));
PRINT_SECTION("Func");
@@ -412,11 +418,12 @@
return obj;
}
-ScmObj Scm_CheckClosure()
+ScmObj
+scm_check_closure()
{
ScmObj obj = (ScmObj)malloc(sizeof(ScmCell));
- ScmObj exp = Scm_CheckCons();
- ScmObj env = Scm_CheckCons();
+ ScmObj exp = scm_check_cons();
+ ScmObj env = scm_check_cons();
PRINT_SECTION("Closure");
@@ -465,7 +472,8 @@
return obj;
}
-ScmObj Scm_CheckVector(unsigned int len)
+ScmObj
+scm_check_vector(unsigned int len)
{
ScmObj obj = (ScmObj)malloc(sizeof(ScmCell));
ScmObj *vec = (ScmObj*)malloc(sizeof(ScmObj) * len);
@@ -488,12 +496,12 @@
check_type(ScmVector, obj);
SCM_ASSERT(SCM_VECTOR_LEN(obj) == len);
- SCM_VECTOR_SET_CREF(obj, 0, Scm_CheckInt(11));
+ SCM_VECTOR_SET_CREF(obj, 0, scm_check_int(11));
check_type(ScmVector, obj);
SCM_ASSERT(SCM_INTP(SCM_VECTOR_CREF(obj, 0)));
SCM_ASSERT(SCM_INT_VALUE(SCM_VECTOR_CREF(obj, 0)) == 11);
- SCM_VECTOR_SET_CREF(obj, 0, Scm_CheckInt(3));
+ SCM_VECTOR_SET_CREF(obj, 0, scm_check_int(3));
check_type(ScmVector, obj);
SCM_ASSERT(SCM_INTP(SCM_VECTOR_CREF(obj, 0)));
SCM_ASSERT(SCM_INT_VALUE(SCM_VECTOR_CREF(obj, 0)) == 3);
@@ -512,12 +520,12 @@
check_type(ScmVector, obj);
SCM_ASSERT(SCM_VECTOR_LEN(obj) == len);
- SCM_VECTOR_SET_CREF(obj, 0, Scm_CheckInt(11));
+ SCM_VECTOR_SET_CREF(obj, 0, scm_check_int(11));
check_type(ScmVector, obj);
SCM_ASSERT(SCM_INTP(SCM_VECTOR_CREF(obj, 0)));
SCM_ASSERT(SCM_INT_VALUE(SCM_VECTOR_CREF(obj, 0)) == 11);
- SCM_VECTOR_SET_CREF(obj, 0, Scm_CheckInt(3));
+ SCM_VECTOR_SET_CREF(obj, 0, scm_check_int(3));
check_type(ScmVector, obj);
SCM_ASSERT(SCM_INTP(SCM_VECTOR_CREF(obj, 0)));
SCM_ASSERT(SCM_INT_VALUE(SCM_VECTOR_CREF(obj, 0)) == 3);
@@ -526,7 +534,8 @@
}
-ScmObj Scm_CheckPort()
+ScmObj
+scm_check_port()
{
ScmObj obj = (ScmObj)malloc(sizeof(ScmCell));
ScmCharPort *port = (ScmCharPort*)0x20;
@@ -567,7 +576,8 @@
}
-ScmObj Scm_CheckContinuation(void *val)
+ScmObj
+scm_check_continuation(void *val)
{
ScmObj obj = (ScmObj)malloc(sizeof(ScmCell));
PRINT_SECTION("Continuation");
@@ -605,10 +615,11 @@
return obj;
}
-ScmObj Scm_CheckValuePacket()
+ScmObj
+scm_check_value_packet()
{
ScmObj obj = (ScmObj)malloc(sizeof(ScmCell));
- ScmObj values = Scm_CheckCons();
+ ScmObj values = scm_check_cons();
PRINT_SECTION("ValuePacket");
@@ -637,7 +648,8 @@
return obj;
}
-ScmObj Scm_CheckCPointer(void *data)
+ScmObj
+scm_check_cpointer(void *data)
{
ScmObj obj = (ScmObj)malloc(sizeof(ScmCell));
@@ -666,7 +678,8 @@
return obj;
}
-ScmObj Scm_CheckCFuncPointer(ScmCFunc funcptr)
+ScmObj
+scm_check_cfunc_pointer(ScmCFunc funcptr)
{
ScmObj obj = (ScmObj)malloc(sizeof(ScmCell));
@@ -695,7 +708,8 @@
return obj;
}
-ScmObj Scm_CheckConstant()
+ScmObj
+scm_check_constant()
{
PRINT_SECTION("Constant");
@@ -732,12 +746,13 @@
return SCM_NULL;
}
-ScmObj Scm_CheckRef()
+ScmObj
+scm_check_ref()
{
PRINT_SECTION("REF");
- ScmObj cons = Scm_CheckCons();
- ScmObj tmp = Scm_CheckCons();
+ ScmObj cons = scm_check_cons();
+ ScmObj tmp = scm_check_cons();
ScmRef ref_car = SCM_REF_CAR(cons);
ScmRef ref_cdr = SCM_REF_CDR(cons);
@@ -758,34 +773,34 @@
int main(void)
{
- Scm_CheckInt(0);
- Scm_CheckInt(1);
- Scm_CheckInt(-1);
- Scm_CheckCons();
- Scm_CheckSymbol("aiueo");
- Scm_CheckSymbol(NULL);
- Scm_CheckChar(0);
- Scm_CheckChar(255);
- Scm_CheckStringCopying("aiueo");
-// Scm_CheckStringCopying(NULL);
- Scm_CheckClosure();
- Scm_CheckFunc((void*)0x00000000);
- Scm_CheckFunc((void*)0xfffffffe);
- Scm_CheckFunc((void*)0xffffffff);
- Scm_CheckVector(0);
- Scm_CheckVector(5);
- Scm_CheckContinuation((void*)NULL);
- Scm_CheckContinuation((void*)0x20);
- Scm_CheckValuePacket();
- Scm_CheckPort();
- Scm_CheckCPointer((void*)0x00000000);
- Scm_CheckCPointer((void*)0xfffffffe);
- Scm_CheckCPointer((void*)0xffffffff);
- Scm_CheckCFuncPointer((ScmCFunc)0x00000000);
- Scm_CheckCFuncPointer((ScmCFunc)0xfffffffe);
- Scm_CheckCFuncPointer((ScmCFunc)0xffffffff);
- Scm_CheckConstant();
- Scm_CheckRef();
+ scm_check_int(0);
+ scm_check_int(1);
+ scm_check_int(-1);
+ scm_check_cons();
+ scm_check_symbol("aiueo");
+ scm_check_symbol(NULL);
+ scm_check_char(0);
+ scm_check_char(255);
+ scm_check_string_copying("aiueo");
+// scm_check_string_copying(NULL);
+ scm_check_closure();
+ scm_check_func((void*)0x00000000);
+ scm_check_func((void*)0xfffffffe);
+ scm_check_func((void*)0xffffffff);
+ scm_check_vector(0);
+ scm_check_vector(5);
+ scm_check_continuation((void*)NULL);
+ scm_check_continuation((void*)0x20);
+ scm_check_value_packet();
+ scm_check_port();
+ scm_check_cpointer((void*)0x00000000);
+ scm_check_cpointer((void*)0xfffffffe);
+ scm_check_cpointer((void*)0xffffffff);
+ scm_check_cfunc_pointer((ScmCFunc)0x00000000);
+ scm_check_cfunc_pointer((ScmCFunc)0xfffffffe);
+ scm_check_cfunc_pointer((ScmCFunc)0xffffffff);
+ scm_check_constant();
+ scm_check_ref();
SCM_INVALIDP(SCM_INVALID);
}
Modified: branches/r5rs/uim/uim-compat-scm.c
===================================================================
--- branches/r5rs/uim/uim-compat-scm.c 2005-12-16 08:29:32 UTC (rev 2609)
+++ branches/r5rs/uim/uim-compat-scm.c 2005-12-16 09:06:42 UTC (rev 2610)
@@ -57,7 +57,7 @@
uim_scm_repl_c_string(char *str, long want_init, long want_print)
{
/* TODO: fix return value */
- Scm_eval_c_string(str);
+ scm_eval_c_string(str);
return 0;
}
@@ -187,8 +187,8 @@
for (i = n_strs - 1; 0 <= i; i--) {
c_str = strs[i];
- str = (uim_lisp)Scm_NewMutableStringCopying(c_str);
- lst = (uim_lisp)Scm_NewCons((ScmObj)str, (ScmObj)lst);
+ str = (uim_lisp)scm_make_mutable_string_copying(c_str);
+ lst = (uim_lisp)scm_make_cons((ScmObj)str, (ScmObj)lst);
}
return (uim_lisp)lst;
@@ -197,7 +197,7 @@
uim_lisp
uim_scm_symbol_value(const char *symbol_str)
{
- return (uim_lisp)ScmOp_symbol_value(Scm_Intern(symbol_str));
+ return (uim_lisp)scm_p_symbol_value(scm_intern(symbol_str));
}
uim_lisp
@@ -221,7 +221,7 @@
uim_lisp
uim_scm_nth(uim_lisp n, uim_lisp lst)
{
- return (uim_lisp)ScmOp_list_ref((ScmObj)lst,
+ return (uim_lisp)scm_p_list_ref((ScmObj)lst,
(ScmObj)n);
}
@@ -286,13 +286,13 @@
void
uim_scm_init_fsubr(char *name, uim_lisp (*fcn)(uim_lisp, uim_lisp))
{
- Scm_RegisterSyntaxVariadic0(name, (ScmObj (*)(ScmObj, ScmObj))fcn);
+ scm_register_syntax_variadic_0(name, (ScmObj (*)(ScmObj, ScmObj))fcn);
}
void
uim_scm_provide(const char *feature)
{
- ScmOp_provide(Scm_NewImmutableStringCopying(feature));
+ scm_p_provide(scm_make_immutable_string_copying(feature));
}
Modified: branches/r5rs/uim/uim-scm.c
===================================================================
--- branches/r5rs/uim/uim-scm.c 2005-12-16 08:29:32 UTC (rev 2609)
+++ branches/r5rs/uim/uim-scm.c 2005-12-16 09:06:42 UTC (rev 2610)
@@ -94,7 +94,7 @@
#endif
/* FIXME: don't terminate the process */
- SigScm_ErrorObj(msg, (ScmObj)errobj);
+ scm_error_obj(NULL, msg, (ScmObj)errobj);
#if !UIM_SCM_GCC4_READY_GC
uim_scm_gc_unprotect_stack(&stack_start);
@@ -166,7 +166,7 @@
uim_lisp
uim_scm_make_int(int integer)
{
- return (uim_lisp)Scm_NewInt(integer);
+ return (uim_lisp)scm_make_int(integer);
}
char *
@@ -222,7 +222,7 @@
uim_lisp
uim_scm_make_str(const char *str)
{
- return (uim_lisp)Scm_NewMutableStringCopying(str);
+ return (uim_lisp)scm_make_mutable_string_copying(str);
}
char *
@@ -234,7 +234,7 @@
uim_lisp
uim_scm_make_symbol(const char *name)
{
- return (uim_lisp)Scm_Intern(name);
+ return (uim_lisp)scm_intern(name);
}
void *
@@ -251,7 +251,7 @@
uim_lisp
uim_scm_make_ptr(void *ptr)
{
- return (uim_lisp)Scm_NewCPointer(ptr);
+ return (uim_lisp)scm_make_cpointer(ptr);
}
uim_func_ptr
@@ -269,19 +269,19 @@
uim_lisp
uim_scm_make_func_ptr(uim_func_ptr func_ptr)
{
- return (uim_lisp)Scm_NewCFuncPointer((ScmCFunc)func_ptr);
+ return (uim_lisp)scm_make_cfunc_pointer((ScmCFunc)func_ptr);
}
void
uim_scm_gc_protect(uim_lisp *location)
{
- SigScm_GC_Protect((ScmObj *)location);
+ scm_gc_protect((ScmObj *)location);
}
void
uim_scm_gc_unprotect_stack(uim_lisp *stack_start)
{
- SigScm_GC_UnprotectStack((ScmObj*)stack_start);
+ scm_gc_unprotect_stack((ScmObj*)stack_start);
}
#if UIM_SCM_GCC4_READY_GC
@@ -295,13 +295,13 @@
ScmObj stack_start;
/* intentionally returns invalidated local address */
- return (uim_lisp *)SigScm_GC_ProtectStack(&stack_start);
+ return (uim_lisp *)scm_gc_protect_stack(&stack_start);
}
#else /* UIM_SCM_GCC4_READY_GC */
void
uim_scm_gc_protect_stack(uim_lisp *stack_start)
{
- SigScm_GC_ProtectStack((ScmObj*)stack_start);
+ scm_gc_protect_stack((ScmObj*)stack_start);
}
#endif /* UIM_SCM_GCC4_READY_GC */
@@ -314,19 +314,19 @@
long
uim_scm_get_verbose_level(void)
{
- return (long)SigScm_GetVerboseLevel();
+ return (long)scm_get_verbose_level();
}
void
uim_scm_set_verbose_level(long new_value)
{
- SigScm_SetVerboseLevel(new_value);
+ scm_set_verbose_level(new_value);
}
void
uim_scm_set_lib_path(const char *path)
{
- SigScm_set_lib_path(path);
+ scm_set_lib_path(path);
}
uim_bool
@@ -336,7 +336,7 @@
return UIM_FALSE;
/* FIXME! */
- SigScm_load(fn);
+ scm_load(fn);
return UIM_TRUE;
}
@@ -392,7 +392,7 @@
uim_bool
uim_scm_string_equal(uim_lisp a, uim_lisp b)
{
- return (SCM_NFALSEP(ScmOp_stringequalp((ScmObj)a, (ScmObj)b)));
+ return (SCM_NFALSEP(scm_p_stringequalp((ScmObj)a, (ScmObj)b)));
}
uim_lisp
@@ -417,7 +417,7 @@
uim_scm_gc_protect_stack(&stack_start);
#endif
- ret = (uim_lisp)ScmOp_eval((ScmObj)obj, SCM_NULL);
+ ret = (uim_lisp)scm_p_eval((ScmObj)obj, SCM_NULL);
#if !UIM_SCM_GCC4_READY_GC
uim_scm_gc_unprotect_stack(&stack_start);
@@ -430,7 +430,7 @@
uim_lisp
uim_scm_apply(uim_lisp proc, uim_lisp args)
{
- return (uim_lisp)Scm_call((ScmObj)proc, Scm_NewCons((ScmObj)args, SCM_NULL));
+ return (uim_lisp)scm_call((ScmObj)proc, scm_make_cons((ScmObj)args, SCM_NULL));
}
#endif /* UIM_SCM_EXTENDED_API */
@@ -449,68 +449,68 @@
uim_scm_eval_c_string_internal(const char *str)
#endif
{
- return (uim_lisp)Scm_eval_c_string(str);
+ return (uim_lisp)scm_eval_c_string(str);
}
uim_lisp
uim_scm_return_value(void)
{
/* FIXME: This function should be removed. */
- return (uim_lisp)Scm_return_value();
+ return (uim_lisp)scm_return_value();
}
uim_lisp
uim_scm_car(uim_lisp pair)
{
- return (uim_lisp)ScmOp_car((ScmObj)pair);
+ return (uim_lisp)scm_p_car((ScmObj)pair);
}
uim_lisp
uim_scm_cdr(uim_lisp pair)
{
- return (uim_lisp)ScmOp_cdr((ScmObj)pair);
+ return (uim_lisp)scm_p_cdr((ScmObj)pair);
}
uim_lisp
uim_scm_cadr(uim_lisp lst)
{
- return (uim_lisp)ScmOp_cadr((ScmObj)lst);
+ return (uim_lisp)scm_p_cadr((ScmObj)lst);
}
uim_lisp
uim_scm_caar(uim_lisp lst)
{
- return (uim_lisp)ScmOp_caar((ScmObj)lst);
+ return (uim_lisp)scm_p_caar((ScmObj)lst);
}
uim_lisp
uim_scm_cdar(uim_lisp lst)
{
- return (uim_lisp)ScmOp_cdar((ScmObj)lst);
+ return (uim_lisp)scm_p_cdar((ScmObj)lst);
}
uim_lisp
uim_scm_cddr(uim_lisp lst)
{
- return (uim_lisp)ScmOp_cddr((ScmObj)lst);
+ return (uim_lisp)scm_p_cddr((ScmObj)lst);
}
uim_lisp
uim_scm_cons(uim_lisp car, uim_lisp cdr)
{
- return (uim_lisp)Scm_NewCons((ScmObj)car, (ScmObj)cdr);
+ return (uim_lisp)scm_make_cons((ScmObj)car, (ScmObj)cdr);
}
uim_lisp
uim_scm_length(uim_lisp lst)
{
- return (uim_lisp)ScmOp_length((ScmObj)lst);
+ return (uim_lisp)scm_p_length((ScmObj)lst);
}
uim_lisp
uim_scm_reverse(uim_lisp lst)
{
- return (uim_lisp)ScmOp_reverse((ScmObj)lst);
+ return (uim_lisp)scm_p_reverse((ScmObj)lst);
}
uim_bool
@@ -537,39 +537,39 @@
void
uim_scm_init_subr_0(const char *name, uim_lisp (*func)(void))
{
- Scm_RegisterProcedureFixed0(name, (ScmProcedureFixed0)func);
+ scm_register_procedure_fixed_0(name, (ScmProcedureFixed0)func);
}
void
uim_scm_init_subr_1(const char *name, uim_lisp (*func)(uim_lisp))
{
- Scm_RegisterProcedureFixed1(name, (ScmProcedureFixed1)func);
+ scm_register_procedure_fixed_1(name, (ScmProcedureFixed1)func);
}
void
uim_scm_init_subr_2(const char *name, uim_lisp (*func)(uim_lisp, uim_lisp))
{
- Scm_RegisterProcedureFixed2(name, (ScmProcedureFixed2)func);
+ scm_register_procedure_fixed_2(name, (ScmProcedureFixed2)func);
}
void
uim_scm_init_subr_3(const char *name, uim_lisp (*func)(uim_lisp, uim_lisp, uim_lisp))
{
- Scm_RegisterProcedureFixed3(name, (ScmProcedureFixed3)func);
+ scm_register_procedure_fixed_3(name, (ScmProcedureFixed3)func);
}
void
uim_scm_init_subr_4(const char *name, uim_lisp (*func)(uim_lisp, uim_lisp, uim_lisp,
- uim_lisp))
+ uim_lisp))
{
- Scm_RegisterProcedureFixed4(name, (ScmProcedureFixed4)func);
+ scm_register_procedure_fixed_4(name, (ScmProcedureFixed4)func);
}
void
uim_scm_init_subr_5(const char *name, uim_lisp (*func)(uim_lisp, uim_lisp, uim_lisp,
- uim_lisp, uim_lisp))
+ uim_lisp, uim_lisp))
{
- Scm_RegisterProcedureFixed5(name, (ScmProcedureFixed5)func);
+ scm_register_procedure_fixed_5(name, (ScmProcedureFixed5)func);
}
static void
@@ -601,12 +601,12 @@
* multibyte character as string, it is not a problem. The name
* "ISO-8859-1" is a dummy name for the codec.
*/
- Scm_current_char_codec = Scm_mb_find_codec("ISO-8859-1");
+ scm_current_char_codec = scm_mb_find_codec("ISO-8859-1");
- SigScm_Initialize();
+ scm_initialize();
/* GC safe */
- output_port = Scm_MakeSharedFilePort(uim_output, "uim", SCM_PORTFLAG_OUTPUT);
+ output_port = scm_make_shared_file_port(uim_output, "uim", SCM_PORTFLAG_OUTPUT);
scm_current_output_port = scm_current_error_port = output_port;
#ifdef DEBUG_SCM
@@ -614,9 +614,9 @@
uim_scm_provide("debug");
#endif
- Scm_Use("srfi-23");
- Scm_Use("srfi-34");
- Scm_Use("siod");
+ scm_use("srfi-23");
+ scm_use("srfi-34");
+ scm_use("siod");
true_sym = (uim_lisp)SCM_TRUE;
false_sym = (uim_lisp)SCM_FALSE;
@@ -628,6 +628,6 @@
void
uim_scm_quit(void)
{
- SigScm_Finalize();
+ scm_finalize();
uim_output = NULL;
}
More information about the uim-commit
mailing list