static int register_classes (void) { SLang_Class_Type *cl,*cl2; if (SLssl_Type_Id != -1) return 0; if (NULL == (cl = SLclass_allocate_class ("SLssl_Type"))) return -1; (void) SLclass_set_destroy_function (cl, sl_destroy_ssl); if (-1 == SLclass_register_class (cl, SLANG_VOID_TYPE, sizeof (SLssl_Type), SLANG_CLASS_TYPE_MMT)) return -1; SLssl_Type_Id = SLclass_get_class_id (cl); if (NULL == (cl2 = SLclass_allocate_class ("SLsslctx_Type"))) return -1; (void) SLclass_set_destroy_function (cl2, sl_destroy_sslctx); if (-1 == SLclass_register_class (cl2, SLANG_VOID_TYPE, sizeof (SLsslctx_Type), SLANG_CLASS_TYPE_MMT)) return -1; SLsslctx_Type_Id = SLclass_get_class_id (cl2); return 0; }
int _SLang_init_bstring (void) { SLang_Class_Type *cl; if (NULL == (cl = SLclass_allocate_class ("BString_Type"))) return -1; (void) SLclass_set_destroy_function (cl, bstring_destroy); (void) SLclass_set_push_function (cl, bstring_push); (void) SLclass_set_string_function (cl, bstring_string); if (-1 == SLclass_register_class (cl, SLANG_BSTRING_TYPE, sizeof (char *), SLANG_CLASS_TYPE_PTR)) return -1; if ((-1 == SLclass_add_typecast (SLANG_BSTRING_TYPE, SLANG_STRING_TYPE, bstring_to_string, 1)) || (-1 == SLclass_add_typecast (SLANG_STRING_TYPE, SLANG_BSTRING_TYPE, string_to_bstring, 1)) || (-1 == SLclass_add_binary_op (SLANG_STRING_TYPE, SLANG_BSTRING_TYPE, string_bstring_bin_op, bstring_bstring_bin_op_result)) || (-1 == SLclass_add_binary_op (SLANG_BSTRING_TYPE, SLANG_STRING_TYPE, bstring_string_bin_op, bstring_bstring_bin_op_result)) || (-1 == SLclass_add_binary_op (SLANG_BSTRING_TYPE, SLANG_BSTRING_TYPE, bstring_bstring_bin_op, bstring_bstring_bin_op_result))) return -1; if (-1 == SLadd_intrin_fun_table (BString_Table, NULL)) return -1; return 0; }
static int register_iconv_type (void) { SLang_Class_Type *cl; if (ICONV_Type_Id != 0) return 0; if (NULL == (cl = SLclass_allocate_class ("ICONV_Type"))) return -1; if (-1 == SLclass_set_destroy_function (cl, destroy_iconv)) return -1; /* By registering as SLANG_VOID_TYPE, slang will dynamically allocate a * type. */ if (-1 == SLclass_register_class (cl, SLANG_VOID_TYPE, sizeof (ICONV_Type), SLANG_CLASS_TYPE_MMT)) return -1; ICONV_Type_Id = SLclass_get_class_id (cl); if (-1 == SLclass_patch_intrin_fun_table1 (ICONV_Intrinsics, DUMMY_ICONV_TYPE, ICONV_Type_Id)) return -1; return 0; }
int _pSLang_init_sllist (void) { SLang_Class_Type *cl; if (SLclass_is_class_defined (SLANG_LIST_TYPE)) return 0; if (NULL == (cl = SLclass_allocate_class ("List_Type"))) return -1; (void) SLclass_set_destroy_function (cl, cl_list_destroy); (void) SLclass_set_push_function (cl, cl_list_push); (void) SLclass_set_aput_function (cl, _pSLlist_aput); (void) SLclass_set_aget_function (cl, _pSLlist_aget); (void) SLclass_set_deref_function (cl, cl_list_dereference); (void) SLclass_set_string_function (cl, string_method); (void) SLclass_set_eqs_function (cl, eqs_method); (void) SLclass_set_is_container (cl, 1); cl->cl_length = list_length; cl->cl_foreach_open = cl_foreach_open; cl->cl_foreach_close = cl_foreach_close; cl->cl_foreach = cl_foreach; if (-1 == SLclass_register_class (cl, SLANG_LIST_TYPE, sizeof (SLang_List_Type), SLANG_CLASS_TYPE_PTR)) return -1; if (-1 == SLadd_intrin_fun_table (Intrin_Table, NULL)) return -1; return 0; }
static int register_termios_type (void) { SLang_Class_Type *cl; if (Termios_Type_Id != 0) return 0; if (NULL == (cl = SLclass_allocate_class ("Termios_Type"))) return -1; if (-1 == SLclass_set_destroy_function (cl, destroy_termios)) return -1; if (-1 == SLclass_set_deref_function (cl, termios_dereference)) return -1; /* By registering as SLANG_VOID_TYPE, slang will dynamically allocate a * type. */ if (-1 == SLclass_register_class (cl, SLANG_VOID_TYPE, sizeof (struct termios), SLANG_CLASS_TYPE_MMT)) return -1; Termios_Type_Id = SLclass_get_class_id (cl); if (-1 == SLclass_patch_intrin_fun_table1 (Termios_Intrinsics, DUMMY_TERMIOS_TYPE, Termios_Type_Id)) return -1; return 0; }
int SLang_init_slassoc (void) { SLang_Class_Type *cl; if (SLclass_is_class_defined (SLANG_ASSOC_TYPE)) return 0; if (NULL == (cl = SLclass_allocate_class ("Assoc_Type"))) return -1; (void) SLclass_set_destroy_function (cl, assoc_destroy); (void) SLclass_set_aput_function (cl, _pSLassoc_aput); (void) SLclass_set_aget_function (cl, _pSLassoc_aget); (void) SLclass_set_anew_function (cl, assoc_anew); cl->cl_length = assoc_length; cl->cl_foreach_open = cl_foreach_open; cl->cl_foreach_close = cl_foreach_close; cl->cl_foreach = cl_foreach; if (-1 == SLclass_register_class (cl, SLANG_ASSOC_TYPE, sizeof (SLang_Assoc_Array_Type), SLANG_CLASS_TYPE_MMT)) return -1; if (-1 == SLadd_intrin_fun_table (Assoc_Table, "__SLASSOC__")) return -1; return 0; }
static int register_chksum_type (void) { SLang_Class_Type *cl; if (Chksum_Type_Id != 0) return 0; if (NULL == (cl = SLclass_allocate_class ("Chksum_Type"))) return -1; if (-1 == SLclass_set_destroy_function (cl, destroy_chksum_type)) return -1; if (-1 == SLclass_set_push_function (cl, push_chksum_type)) return -1; /* By registering as SLANG_VOID_TYPE, slang will dynamically allocate a * type. */ if (-1 == SLclass_register_class (cl, SLANG_VOID_TYPE, sizeof (Chksum_Object_Type *), SLANG_CLASS_TYPE_PTR)) return -1; Chksum_Type_Id = SLclass_get_class_id (cl); if (-1 == SLclass_patch_intrin_fun_table1 (Intrinsics, DUMMY_CHKSUM_TYPE, Chksum_Type_Id)) return -1; return 0; }
static int add_test_classes (void) { SLang_Class_Type *cl; cl = SLclass_allocate_class ("Test_Type"); if (cl == NULL) return -1; (void) SLclass_set_destroy_function (cl, test_type_destroy); (void) SLclass_set_sget_function (cl, test_type_sget); (void) SLclass_set_sput_function (cl, test_type_sput); (void) SLclass_set_push_function (cl, test_type_push); if (-1 == SLclass_register_class (cl, SLANG_VOID_TYPE, sizeof (Test_Type *), SLANG_CLASS_TYPE_PTR)) return -1; Test_Type_Id = SLclass_get_class_id (cl); return 0; }
static int register_rline_type (void) { SLang_Class_Type *cl; if (Rline_Type_Id != 0) return 0; if (NULL == (cl = SLclass_allocate_class ("RLine_Type"))) return -1; if (-1 == SLclass_set_destroy_function (cl, destroy_rline)) return -1; /* By registering as SLANG_VOID_TYPE, slang will dynamically allocate a * type. */ if (-1 == SLclass_register_class (cl, SLANG_VOID_TYPE, sizeof (SLang_RLine_Info_Type*), SLANG_CLASS_TYPE_MMT)) return -1; Rline_Type_Id = SLclass_get_class_id (cl); return 0; }
int _pSLinit_slcomplex (void) { SLang_Class_Type *cl; SLtype *types; if (NULL == (cl = SLclass_allocate_class ("Complex_Type"))) return -1; (void) SLclass_set_destroy_function (cl, complex_destroy); (void) SLclass_set_push_function (cl, complex_push); (void) SLclass_set_pop_function (cl, complex_pop); if (-1 == SLclass_register_class (cl, SLANG_COMPLEX_TYPE, 2 * sizeof (double), SLANG_CLASS_TYPE_VECTOR)) return -1; types = _pSLarith_Arith_Types; while (*types != SLANG_DOUBLE_TYPE) { SLtype t = *types++; if ((-1 == SLclass_add_binary_op (t, SLANG_COMPLEX_TYPE, generic_complex_binary, complex_binary_result)) || (-1 == SLclass_add_binary_op (SLANG_COMPLEX_TYPE, t, complex_generic_binary, complex_binary_result)) || (-1 == (SLclass_add_typecast (t, SLANG_COMPLEX_TYPE, complex_typecast, 1)))) return -1; } if ((-1 == (SLclass_add_binary_op (SLANG_COMPLEX_TYPE, SLANG_COMPLEX_TYPE, complex_complex_binary, complex_binary_result))) || (-1 == (SLclass_add_binary_op (SLANG_COMPLEX_TYPE, SLANG_DOUBLE_TYPE, complex_double_binary, complex_binary_result))) || (-1 == (SLclass_add_binary_op (SLANG_DOUBLE_TYPE, SLANG_COMPLEX_TYPE, double_complex_binary, complex_binary_result))) || (-1 == (SLclass_add_unary_op (SLANG_COMPLEX_TYPE, complex_unary, complex_unary_result))) || (-1 == (SLclass_add_typecast (SLANG_DOUBLE_TYPE, SLANG_COMPLEX_TYPE, complex_typecast, 1)))) return -1; return 0; }
int _pSLregister_types (void) { SLang_Class_Type *cl; #if 1 /* A good compiler should optimize this code away. */ if ((sizeof(short) != SIZEOF_SHORT) || (sizeof(int) != SIZEOF_INT) || (sizeof(long) != SIZEOF_LONG) || (sizeof(float) != SIZEOF_FLOAT) || (sizeof(double) != SIZEOF_DOUBLE)) SLang_exit_error ("S-Lang Library not built properly. Fix SIZEOF_* in config.h and recompile"); #endif if (-1 == _pSLclass_init ()) return -1; /* Undefined Type */ if (NULL == (cl = SLclass_allocate_class ("Undefined_Type"))) return -1; (void) SLclass_set_push_function (cl, undefined_method); (void) SLclass_set_pop_function (cl, undefined_method); (void) SLclass_set_destroy_function (cl, void_undefined_method); if (-1 == SLclass_register_class (cl, SLANG_UNDEFINED_TYPE, sizeof (int), SLANG_CLASS_TYPE_SCALAR)) return -1; /* Make Void_Type a synonym for Undefined_Type. Note that this does * not mean that Void_Type represents SLANG_VOID_TYPE. Void_Type is * used by array_map to indicate no array is to be created. */ if (-1 == SLclass_create_synonym ("Void_Type", SLANG_UNDEFINED_TYPE)) return -1; if (-1 == _pSLarith_register_types ()) return -1; /* SLANG_INTP_TYPE -- not used within the interpreter */ if (NULL == (cl = SLclass_allocate_class ("_IntegerP_Type"))) return -1; (void) SLclass_set_push_function (cl, intp_push); (void) SLclass_set_pop_function (cl, intp_pop); if (-1 == SLclass_register_class (cl, SLANG_INTP_TYPE, sizeof (int *), SLANG_CLASS_TYPE_SCALAR)) return -1; /* String Type */ if (NULL == (cl = SLclass_allocate_class ("String_Type"))) return -1; (void) SLclass_set_destroy_function (cl, string_destroy); (void) SLclass_set_push_function (cl, string_push); (void) SLclass_set_acopy_function (cl, string_acopy); cl->cl_foreach_open = _pSLbstring_foreach_open; cl->cl_foreach_close = _pSLbstring_foreach_close; cl->cl_foreach = _pSLbstring_foreach; cl->cl_cmp = string_cmp; if (-1 == SLclass_register_class (cl, SLANG_STRING_TYPE, sizeof (char *), SLANG_CLASS_TYPE_PTR)) return -1; /* ref Type */ if (NULL == (cl = SLclass_allocate_class ("Ref_Type"))) return -1; cl->cl_dereference = ref_dereference; cl->cl_push = ref_push; cl->cl_destroy = ref_destroy; cl->cl_string = ref_string; cl->cl_cmp = ref_cmp; if (-1 == SLclass_register_class (cl, SLANG_REF_TYPE, sizeof (SLang_Ref_Type *), SLANG_CLASS_TYPE_PTR)) return -1; /* NULL Type */ if (NULL == (cl = SLclass_allocate_class ("Null_Type"))) return -1; cl->cl_push = null_push; cl->cl_pop = null_pop; cl->cl_foreach_open = null_foreach_open; cl->cl_foreach_close = null_foreach_close; cl->cl_foreach = null_foreach; cl->cl_to_bool = null_to_bool; if (-1 == SLclass_register_class (cl, SLANG_NULL_TYPE, sizeof (char *), SLANG_CLASS_TYPE_SCALAR)) return -1; /* AnyType */ if (NULL == (cl = SLclass_allocate_class ("Any_Type"))) return -1; (void) SLclass_set_push_function (cl, anytype_push); (void) SLclass_set_destroy_function (cl, anytype_destroy); #if 0 (void) SLclass_set_apush_function (cl, anytype_apush); #endif cl->cl_dereference = anytype_dereference; if (-1 == SLclass_register_class (cl, SLANG_ANY_TYPE, sizeof (VOID_STAR), SLANG_CLASS_TYPE_PTR)) return -1; if (-1 == _pSLang_init_bstring ()) return -1; if ((-1 == SLclass_add_typecast (SLANG_STRING_TYPE, SLANG_INT_TYPE, string_to_int, 0)) || (-1 == SLclass_add_binary_op (SLANG_STRING_TYPE, SLANG_STRING_TYPE, string_string_bin_op, string_string_bin_op_result))) return -1; return 0; }