From 7a29be4337845832a1d9752bb66cf0c76df77ed1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Daniel=20Kochma=C5=84ski?= Date: Wed, 1 Jul 2015 16:56:17 +0200 Subject: [PATCH] CLOS: remove dead code and conditionals for non-clos builds MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Builds without CLOS weren't possible for long time, yet a lot of dead code for non-clos builds was spread across sources. This commit removes all ifdefs and dead blocks from codebase. Signed-off-by: Daniel Kochmański --- src/c/all_symbols.d | 2 -- src/c/alloc.d | 12 --------- src/c/alloc_2.d | 21 --------------- src/c/cfun.d | 2 -- src/c/ecl_features.h | 2 -- src/c/eval.d | 4 --- src/c/gbc-new.d | 15 ----------- src/c/gbc.d | 13 ---------- src/c/instance.d | 2 -- src/c/interpreter.d | 2 -- src/c/main.d | 10 -------- src/c/predicate.d | 17 +------------ src/c/printer/write_ugly.d | 27 -------------------- src/c/reference.d | 5 +--- src/c/serialize.d | 4 --- src/c/structure.d | 52 ++------------------------------------ src/c/symbols_list.h | 15 ----------- src/c/symbols_list2.h | 15 ----------- src/c/typespec.d | 11 ++------ src/h/config.h.in | 2 -- src/h/external.h | 16 ------------ src/h/internal.h | 2 -- src/h/object.h | 27 -------------------- 23 files changed, 6 insertions(+), 272 deletions(-) diff --git a/src/c/all_symbols.d b/src/c/all_symbols.d index d339a07ea..695686bb7 100644 --- a/src/c/all_symbols.d +++ b/src/c/all_symbols.d @@ -189,9 +189,7 @@ make_this_symbol(int i, cl_object s, int code, const char *name, case EXT_PACKAGE: package = cl_core.ext_package; break; case KEYWORD_PACKAGE: package = cl_core.keyword_package; break; case MP_PACKAGE: package = cl_core.mp_package; break; -#ifdef CLOS case CLOS_PACKAGE: package = cl_core.clos_package; break; -#endif #ifdef ECL_CLOS_STREAMS case GRAY_PACKAGE: package = cl_core.gray_package; break; #endif diff --git a/src/c/alloc.d b/src/c/alloc.d index a508237a8..360ae518c 100644 --- a/src/c/alloc.d +++ b/src/c/alloc.d @@ -335,12 +335,6 @@ ONCE_MORE: obj->vector.displaced = ECL_NIL; obj->vector.self.bit = NULL; break; -#ifndef CLOS - case t_structure: - obj->str.name = OBJNULL; - obj->str.self = NULL; - break; -#endif /* CLOS */ case t_stream: obj->stream.mode = (short)ecl_smm_broadcast; obj->stream.file.descriptor = -1; @@ -406,7 +400,6 @@ ONCE_MORE: obj->semaphore.handle = NULL; break; #endif -#ifdef CLOS case t_instance: obj->instance.length = 0; ECL_CLASS_OF(obj) = OBJNULL; @@ -414,7 +407,6 @@ ONCE_MORE: obj->instance.isgf = 0; obj->instance.slots = NULL; break; -#endif /* CLOS */ case t_codeblock: obj->cblock.locked = 0; obj->cblock.name = ECL_NIL; @@ -747,11 +739,7 @@ init_alloc(void) init_tm(t_cfun, "fCFUN", sizeof(struct ecl_cfun), 32); init_tm(t_cfunfixed, "fCFUN", sizeof(struct ecl_cfun), 32); init_tm(t_cclosure, "cCCLOSURE", sizeof(struct ecl_cclosure), 1); -#ifndef CLOS - init_tm(t_structure, "SSTRUCTURE", sizeof(struct ecl_structure), 32); -#else init_tm(t_instance, "IINSTANCE", sizeof(struct ecl_instance), 32); -#endif /* CLOS */ init_tm(t_foreign, "LFOREIGN", sizeof(struct ecl_foreign), 1); #ifdef ECL_THREADS init_tm(t_process, "tPROCESS", sizeof(struct ecl_process), 2); diff --git a/src/c/alloc_2.d b/src/c/alloc_2.d index 3cbf23149..233f9dd4a 100644 --- a/src/c/alloc_2.d +++ b/src/c/alloc_2.d @@ -438,18 +438,11 @@ cl_object_mark_proc(void *addr, struct GC_ms_entry *msp, struct GC_ms_entry *msl MAYBE_MARK(o->cclosure.block); MAYBE_MARK(o->cclosure.env); break; -# ifndef CLOS - case t_structure: - MAYBE_MARK(o->structure.name); - MAYBE_MARK(o->structure.self); - break; -# else case t_instance: MAYBE_MARK(o->instance.slots); MAYBE_MARK(o->instance.sig); MAYBE_MARK(o->instance.clas); break; -# endif # ifdef ECL_THREADS case t_process: MAYBE_MARK(o->process.queue_record); @@ -595,11 +588,7 @@ ecl_alloc_object(cl_type t) case t_cfun: case t_cfunfixed: case t_cclosure: -#ifdef CLOS case t_instance: -#else - case t_structure: -#endif #ifdef ECL_THREADS case t_process: case t_lock: @@ -874,11 +863,7 @@ init_alloc(void) init_tm(t_cfun, "CFUN", sizeof(struct ecl_cfun), -1); init_tm(t_cfunfixed, "CFUNFIXED", sizeof(struct ecl_cfunfixed), -1); init_tm(t_cclosure, "CCLOSURE", sizeof(struct ecl_cclosure), -1); -#ifndef CLOS - init_tm(t_structure, "STRUCTURE", sizeof(struct ecl_structure), 2); -#else init_tm(t_instance, "INSTANCE", sizeof(struct ecl_instance), 4); -#endif /* CLOS */ #ifdef ECL_THREADS init_tm(t_process, "PROCESS", sizeof(struct ecl_process), 8); init_tm(t_lock, "LOCK", sizeof(struct ecl_lock), 2); @@ -996,16 +981,10 @@ init_alloc(void) to_bitmap(&o, &(o.cclosure.block)) | to_bitmap(&o, &(o.cclosure.file)) | to_bitmap(&o, &(o.cclosure.file_position)); -# ifndef CLOS - type_info[t_structure].descriptor = - to_bitmap(&o, &(o.structure.self)) | - to_bitmap(&o, &(o.structure.name)); -# else type_info[t_instance].descriptor = to_bitmap(&o, &(o.instance.clas)) | to_bitmap(&o, &(o.instance.sig)) | to_bitmap(&o, &(o.instance.slots)); -# endif # ifdef ECL_THREADS type_info[t_process].descriptor = to_bitmap(&o, &(o.process.name)) | diff --git a/src/c/cfun.d b/src/c/cfun.d index 0f1c9a281..840bfbb66 100644 --- a/src/c/cfun.d +++ b/src/c/cfun.d @@ -149,7 +149,6 @@ cl_function_lambda_expression(cl_object fun) lex = ECL_T; output = ECL_NIL; break; -#ifdef CLOS case t_instance: if (fun->instance.isgf) { name = ECL_NIL; @@ -157,7 +156,6 @@ cl_function_lambda_expression(cl_object fun) output = ECL_NIL; break; } -#endif default: FEinvalid_function(fun); } diff --git a/src/c/ecl_features.h b/src/c/ecl_features.h index 3c3054ca2..3e5996144 100644 --- a/src/c/ecl_features.h +++ b/src/c/ecl_features.h @@ -32,9 +32,7 @@ ecl_def_string_array(feature_names,static,const) = { #ifdef ECL_THREADS ecl_def_string_array_elt("THREADS"), #endif -#ifdef CLOS ecl_def_string_array_elt("CLOS"), -#endif #ifdef ENABLE_DLOPEN ecl_def_string_array_elt("DLOPEN"), #endif diff --git a/src/c/eval.d b/src/c/eval.d index 03fdcd4b4..224b975cc 100644 --- a/src/c/eval.d +++ b/src/c/eval.d @@ -54,7 +54,6 @@ ecl_apply_from_stack_frame(cl_object frame, cl_object x) return APPLY(narg, fun->cfun.entry, sp); case t_cclosure: return APPLY(narg, fun->cclosure.entry, sp); -#ifdef CLOS case t_instance: switch (fun->instance.isgf) { case ECL_STANDARD_DISPATCH: @@ -69,7 +68,6 @@ ecl_apply_from_stack_frame(cl_object frame, cl_object x) default: FEinvalid_function(fun); } -#endif case t_symbol: if (ecl_unlikely(fun->symbol.stype & ecl_stp_macro)) FEundefined_function(x); @@ -101,11 +99,9 @@ ecl_function_dispatch(cl_env_ptr env, cl_object x) case t_cclosure: env->function = fun; return fun->cclosure.entry; -#ifdef CLOS case t_instance: env->function = fun; return fun->instance.entry; -#endif case t_symbol: if (ecl_unlikely(fun->symbol.stype & ecl_stp_macro)) FEundefined_function(x); diff --git a/src/c/gbc-new.d b/src/c/gbc-new.d index 243dbcf77..2985aafbd 100644 --- a/src/c/gbc-new.d +++ b/src/c/gbc-new.d @@ -267,19 +267,6 @@ BEGIN: break; j= sizeof(int) * ((x->vector.offset + x->vector.dim + W_SIZE -1)/W_SIZE); goto COPY_ARRAY; - -#ifndef CLOS - case t_structure: - mark_object(x->str.name); - p = x->str.self; - if (p == NULL) - break; - for (i = 0, j = x->str.length; i < j; i++) - mark_object(p[i]); - mark_contblock(p, j*sizeof(cl_object)); - break; -#endif CLOS - case t_stream: switch ((enum smmode)x->stream.mode) { case ecl_smm_closed: @@ -378,7 +365,6 @@ BEGIN: mark_next(x->thread.entry); break; #endif THREADS -#ifdef CLOS case t_instance: mark_object(x->instance.class); p = x->instance.slots; @@ -400,7 +386,6 @@ BEGIN: mark_object(p[i]); mark_contblock(p, j*sizeof(cl_object)); break; -#endif CLOS case t_codeblock: mark_object(x->cblock.name); mark_contblock(x->cblock.start, x->cblock.size); diff --git a/src/c/gbc.d b/src/c/gbc.d index b30910977..37cab079f 100644 --- a/src/c/gbc.d +++ b/src/c/gbc.d @@ -273,15 +273,6 @@ BEGIN: break; j= sizeof(int) * ((x->vector.offset + x->vector.dim + W_SIZE -1)/W_SIZE); goto COPY_ARRAY; - -#ifndef CLOS - case t_structure: - mark_object(x->str.name); - p = x->str.self; - i = x->str.length; - goto MARK_DATA; -#endif /* CLOS */ - case t_stream: switch ((enum ecl_smmode)x->stream.mode) { case ecl_smm_input: @@ -392,14 +383,12 @@ BEGIN: case t_semaphore: break; #endif -#ifdef CLOS case t_instance: mark_object(x->instance.clas); mark_object(x->instance.sig); p = x->instance.slots; i = x->instance.length; goto MARK_DATA; -#endif /* CLOS */ case t_codeblock: mark_object(x->cblock.name); mark_object(x->cblock.next); @@ -528,13 +517,11 @@ mark_cl_env(struct cl_env_struct *env) mark_object(env->big_register[1]); mark_object(env->big_register[2]); -#ifdef CLOS #ifdef ECL_THREADS mark_object(env->method_hash_clear_list); #endif mark_object(env->method_hash); mark_object(env->method_spec_vector); -#endif #ifdef ECL_THREADS /* We should mark the stacks of the threads somehow!!! */ diff --git a/src/c/instance.d b/src/c/instance.d index 014369fa0..b6ff862f5 100644 --- a/src/c/instance.d +++ b/src/c/instance.d @@ -99,7 +99,6 @@ si_instance_ref(cl_object x, cl_object index) @(return x->instance.slots[i]) } -#ifdef CLOS cl_object clos_safe_instance_ref(cl_object x, cl_object index) { @@ -117,7 +116,6 @@ clos_safe_instance_ref(cl_object x, cl_object index) x = _ecl_funcall4(@'slot-unbound', ECL_NIL, x, index); @(return x) } -#endif cl_object ecl_instance_set(cl_object x, cl_fixnum i, cl_object v) diff --git a/src/c/interpreter.d b/src/c/interpreter.d index 5941b3215..f50d0e30d 100644 --- a/src/c/interpreter.d +++ b/src/c/interpreter.d @@ -501,7 +501,6 @@ ecl_interpret(cl_object frame, cl_object env, cl_object bytecodes) the_env->function = reg0; reg0 = APPLY(narg, reg0->cclosure.entry, frame_aux.base); break; -#ifdef CLOS case t_instance: switch (reg0->instance.isgf) { case ECL_STANDARD_DISPATCH: @@ -520,7 +519,6 @@ ecl_interpret(cl_object frame, cl_object env, cl_object bytecodes) FEinvalid_function(reg0); } break; -#endif case t_symbol: if (ecl_unlikely(reg0->symbol.stype & ecl_stp_macro)) FEundefined_function(x); diff --git a/src/c/main.d b/src/c/main.d index a2b99e738..460c29eda 100755 --- a/src/c/main.d +++ b/src/c/main.d @@ -159,12 +159,10 @@ ecl_init_env(cl_env_ptr env) ((struct ecl_fficall*)env->fficall)->registers = 0; #endif -#ifdef CLOS /* Needs 128 elements for 64 entries to differentiate between EQL specializers and class specializers */ env->method_cache = ecl_make_cache(128, 4096); env->slot_cache = ecl_make_cache(3, 4096); -#endif env->pending_interrupt = ECL_NIL; { int size = ecl_option_values[ECL_OPT_SIGNAL_QUEUE_SIZE]; @@ -304,10 +302,8 @@ ecl_def_ct_base_string(str_si,"SI",2,static,const); ecl_def_ct_base_string(str_sys,"SYS",3,static,const); ecl_def_ct_base_string(str_system,"SYSTEM",6,static,const); ecl_def_ct_base_string(str_ext,"EXT",3,static,const); -#ifdef CLOS ecl_def_ct_base_string(str_clos,"CLOS",4,static,const); ecl_def_ct_base_string(str_mop,"MOP",3,static,const); -#endif ecl_def_ct_base_string(str_mp,"MP",2,static,const); ecl_def_ct_base_string(str_multiprocessing,"MULTIPROCESSING",15,static,const); #ifdef ECL_CLOS_STREAMS @@ -356,12 +352,10 @@ struct cl_core_struct cl_core = { ECL_NIL, /* keyword_package */ ECL_NIL, /* system_package */ ECL_NIL, /* ext_package */ -#ifdef CLOS ECL_NIL, /* clos_package */ # ifdef ECL_CLOS_STREAMS ECL_NIL, /* gray_package */ # endif -#endif ECL_NIL, /* mp_package */ ECL_NIL, /* c_package */ ECL_NIL, /* ffi_package */ @@ -585,12 +579,10 @@ cl_boot(int argc, char **argv) ecl_make_package(str_c, ecl_list1(str_compiler), ecl_list1(cl_core.lisp_package)); -#ifdef CLOS cl_core.clos_package = ecl_make_package(str_clos, ecl_list1(str_mop), ecl_list1(cl_core.lisp_package)); -#endif cl_core.mp_package = ecl_make_package(str_mp, ecl_list1(str_multiprocessing), @@ -749,12 +741,10 @@ cl_boot(int argc, char **argv) /* * Set up infrastructure for CLOS. */ -#ifdef CLOS ECL_SET(@'si::*class-name-hash-table*', cl__make_hash_table(@'eq', ecl_make_fixnum(1024), /* size */ cl_core.rehash_size, cl_core.rehash_threshold)); -#endif /* * Features. diff --git a/src/c/predicate.d b/src/c/predicate.d index c6873f52f..da68ac0c0 100644 --- a/src/c/predicate.d +++ b/src/c/predicate.d @@ -222,10 +222,7 @@ cl_functionp(cl_object x) t = ecl_t_of(x); if (t == t_bytecodes || t == t_bclosure || t == t_cfun || t == t_cfunfixed || t == t_cclosure -#ifdef CLOS - || (t == t_instance && x->instance.isgf) -#endif - ) + || (t == t_instance && x->instance.isgf)) output = ECL_T; else output = ECL_NIL; @@ -478,7 +475,6 @@ BEGIN: x = CDR(x); y = CDR(y); goto BEGIN; -#ifdef CLOS case t_instance: { cl_index i; if ((ty != tx) || (ECL_CLASS_OF(x) != ECL_CLASS_OF(y))) @@ -488,17 +484,6 @@ BEGIN: return(FALSE); return(TRUE); } -#else - case t_structure: { - cl_index i; - if ((tx != ty) || (x->str.name != y->str.name)) - return(FALSE); - for (i = 0; i < x->str.length; i++) - if (!ecl_equalp(x->str.self[i], y->str.self[i])) - return(FALSE); - return(TRUE); - } -#endif /* CLOS */ case t_pathname: return (tx == ty) && ecl_equal(x, y); case t_hashtable: { diff --git a/src/c/printer/write_ugly.d b/src/c/printer/write_ugly.d index d373f158c..7282cc04b 100644 --- a/src/c/printer/write_ugly.d +++ b/src/c/printer/write_ugly.d @@ -299,34 +299,11 @@ write_stream(cl_object x, cl_object stream) _ecl_write_unreadable(x, prefix, tag, stream); } -#ifdef CLOS static void write_instance(cl_object x, cl_object stream) { _ecl_funcall3(@'print-object', x, stream); } -#else -static void -write_structure(cl_object x, cl_object stream) -{ - cl_object print_function; - unlikely_if (ecl_t_of(x->str.name) != t_symbol) - FEerror("Found a corrupt structure with an invalid type name~%" - " ~S", x->str.name); - print_function = si_get_sysprop(x->str.name, @'si::structure-print-function'); - if (Null(print_function) || !ecl_print_structure()) { - writestr_stream("#S", stream); - /* structure_to_list conses slot names and values into - * a list to be printed. print shouldn't allocate - * memory - Beppe - */ - x = structure_to_list(x); - si_write_object(x, stream); - } else { - _ecl_funcall4(print_function, x, stream, ecl_make_fixnum(0)); - } -} -#endif /* !CLOS */ static void write_readtable(cl_object x, cl_object stream) @@ -451,11 +428,7 @@ static printer dispatch[FREE+1] = { write_cfun, /* t_cfun */ write_cfun, /* t_cfunfixed */ write_cclosure, /* t_cclosure */ -#ifdef CLOS write_instance, /* t_instance */ -#else - write_structure, /* t_structure */ -#endif /* CLOS */ #ifdef ECL_THREADS write_process, /* t_process */ write_lock, /* t_lock */ diff --git a/src/c/reference.d b/src/c/reference.d index 3de285813..0585fc3dd 100644 --- a/src/c/reference.d +++ b/src/c/reference.d @@ -119,10 +119,7 @@ si_coerce_to_function(cl_object fun) cl_type t = ecl_t_of(fun); if (!(t == t_cfun || t == t_cfunfixed || t == t_cclosure || t == t_bytecodes || t == t_bclosure -#ifdef CLOS - || (t == t_instance && fun->instance.isgf) -#endif - )) { + || (t == t_instance && fun->instance.isgf))) { fun = ecl_fdefinition(fun); } @(return fun) diff --git a/src/c/serialize.d b/src/c/serialize.d index e4ef68cfb..db526e261 100644 --- a/src/c/serialize.d +++ b/src/c/serialize.d @@ -66,11 +66,7 @@ static cl_index object_size[] = { ROUNDED_SIZE(ecl_cfun), /* t_cfun */ ROUNDED_SIZE(ecl_cfunfixed), /* t_cfunfixed */ ROUNDED_SIZE(ecl_cclosure), /* t_cclosure */ -#ifdef CLOS ROUNDED_SIZE(ecl_instance), /* t_instance */ -#else - ROUNDED_SIZE(ecl_structure), /* t_structure */ -#endif /* CLOS */ #ifdef ECL_THREADS ROUNDED_SIZE(ecl_process), /* t_process */ ROUNDED_SIZE(ecl_lock), /* t_lock */ diff --git a/src/c/structure.d b/src/c/structure.d index 2010bb5ee..e38443f4f 100644 --- a/src/c/structure.d +++ b/src/c/structure.d @@ -19,13 +19,8 @@ #include #include -#ifndef CLOS -#error "Needs to define CLOS" -#endif - /******************************* ------- ******************************/ -#ifdef CLOS static bool structure_subtypep(cl_object x, cl_object y) { @@ -40,20 +35,6 @@ structure_subtypep(cl_object x, cl_object y) return FALSE; } } -#else -static bool -structure_subtypep(cl_object x, cl_object y) -{ - do { - if (!ECL_SYMBOLP(x)) - return(FALSE); - if (x == y) - return(TRUE); - x = si_get_sysprop(x, @'si::structure-include'); - } while (x != ECL_NIL); - return(FALSE); -} -#endif /* CLOS */ cl_object si_structure_subtype_p(cl_object x, cl_object y) @@ -71,9 +52,7 @@ si_structure_subtype_p(cl_object x, cl_object y) ECL_STRUCT_SLOTS(x) = NULL; /* for GC sake */ ECL_STRUCT_LENGTH(x) = --narg; ECL_STRUCT_SLOTS(x) = (cl_object *)ecl_alloc_align(sizeof(cl_object)*narg, sizeof(cl_object)); -#ifdef CLOS x->instance.sig = ECL_UNBOUND; -#endif if (narg >= ECL_SLOTS_LIMIT) FEerror("Limit on structure size exceeded: ~S slots requested.", 1, ecl_make_fixnum(narg)); @@ -82,30 +61,7 @@ si_structure_subtype_p(cl_object x, cl_object y) @(return x) @) -#ifdef CLOS #define ecl_copy_structure si_copy_instance -#else -cl_object -ecl_copy_structure(cl_object x) -{ - cl_index j, size; - cl_object y; - - if (ecl_unlikely(Null(si_structurep(x)))) - FEwrong_type_only_arg(@[copy-structure], x, @[structure]); - y = ecl_alloc_object(T_STRUCTURE); - ECL_STRUCT_TYPE(y) = ECL_STRUCT_TYPE(x); - ECL_STRUCT_LENGTH(y) = j = ECL_STRUCT_LENGTH(x); - size = sizeof(cl_object)*j; - ECL_STRUCT_SLOTS(y) = NULL; /* for GC sake */ - ECL_STRUCT_SLOTS(y) = (cl_object *)ecl_alloc_align(size, sizeof(cl_object)); - memcpy(ECL_STRUCT_SLOTS(y), ECL_STRUCT_SLOTS(x), size); -#ifdef CLOS - y->instance.sig = x->instance.sig; -#endif - @(return y) -} -#endif /* !CLOS */ cl_object cl_copy_structure(cl_object s) @@ -182,13 +138,9 @@ ecl_structure_set(cl_object x, cl_object type, int n, cl_object v) cl_object si_structurep(cl_object s) { -#ifdef CLOS - if (ECL_INSTANCEP(s) && structure_subtypep(ECL_CLASS_OF(s), @'structure-object')) + if (ECL_INSTANCEP(s) && + structure_subtypep(ECL_CLASS_OF(s), @'structure-object')) return ECL_T; -#else - if (ecl_t_of(s) == t_structure) - return ECL_T; -#endif else return ECL_NIL; } diff --git a/src/c/symbols_list.h b/src/c/symbols_list.h index 7c9a6fc1d..a4af8e9a0 100755 --- a/src/c/symbols_list.h +++ b/src/c/symbols_list.h @@ -84,11 +84,7 @@ cl_symbols[] = { {"NIL", CL_ORDINARY, NULL, -1, OBJNULL}, {"T", CL_ORDINARY, NULL, -1, OBJNULL}, -#ifdef CLOS {SYS_ "UNBOUND", SI_CONSTANT, si_unbound, 0, ECL_UNBOUND}, -#else -{SYS_ "UNBOUND", SI_ORDINARY, NULL, -1, ECL_UNBOUND}, -#endif {SYS_ "PROTECT-TAG", SI_ORDINARY, NULL, -1, OBJNULL}, {SYS_ "*RESTART-CLUSTERS*", SI_SPECIAL, NULL, -1, Cnil}, {SYS_ "*HANDLER-CLUSTERS*", SI_SPECIAL, NULL, -1, Cnil}, @@ -1020,8 +1016,6 @@ cl_symbols[] = { {"Y-OR-N-P", CL_ORDINARY, ECL_NAME(cl_y_or_n_p), -1, OBJNULL}, {"YES-OR-NO-P", CL_ORDINARY, ECL_NAME(cl_yes_or_no_p), -1, OBJNULL}, {"ZEROP", CL_ORDINARY, cl_zerop, 1, OBJNULL}, - -#ifdef CLOS {"ALLOCATE-INSTANCE", CL_ORDINARY, NULL, 2, OBJNULL}, {"ADD-METHOD", CL_ORDINARY, NULL, -1, OBJNULL}, {"BUILT-IN-CLASS", CL_ORDINARY, NULL, -1, OBJNULL}, @@ -1106,7 +1100,6 @@ cl_symbols[] = { {KEY_ "REQUIRED", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "WRITER", KEYWORD, NULL, -1, OBJNULL}, {KEY_ "WRITERS", KEYWORD, NULL, -1, OBJNULL}, -#endif /* SYSTEM PACKAGE */ {SYS_ "#!", SI_ORDINARY, NULL, -1, OBJNULL}, @@ -1275,9 +1268,6 @@ cl_symbols[] = { {SYS_ "WRITE-OBJECT", SI_SPECIAL, si_write_object, 2, OBJNULL}, {SYS_ "WRITE-UGLY-OBJECT", SI_SPECIAL, si_write_ugly_object, 2, OBJNULL}, -#ifndef CLOS -{SYS_ "STRUCTURE-INCLUDE", SI_ORDINARY, NULL, -1, OBJNULL}, -#else {SYS_ "COPY-INSTANCE", SI_ORDINARY, si_copy_instance, 1, OBJNULL}, {SYS_ "GENERIC-FUNCTION-P", SI_ORDINARY, si_generic_function_p, 1, OBJNULL}, {SYS_ "INSTANCE-REF", SI_ORDINARY, si_instance_ref, 2, OBJNULL}, @@ -1292,7 +1282,6 @@ cl_symbols[] = { {SYS_ "SUBCLASSP", SI_ORDINARY, ECL_NAME(si_subclassp), -1, OBJNULL}, {SYS_ "OF-CLASS-P", SI_ORDINARY, ECL_NAME(si_of_class_p), -1, OBJNULL}, /*{SYS_ "UNBOUND", SI_ORDINARY, si_unbound, 0, OBJNULL}, */ -#endif {EXT_ "*SOURCE-LOCATION*", EXT_SPECIAL, NULL, -1, ECL_NIL}, {EXT_ "*REGISTER-WITH-PDE-HOOK*", EXT_SPECIAL, NULL, -1, ECL_NIL}, @@ -1465,10 +1454,8 @@ cl_symbols[] = { {EXT_ "INTEGER64", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "LAMBDA-BLOCK", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "QUIT", EXT_ORDINARY, si_quit, -1, OBJNULL}, -#ifdef CLOS {EXT_ "GET-METHOD", EXT_ORDINARY, NULL, -1, OBJNULL}, {EXT_ "INSTANCE", EXT_ORDINARY, NULL, -1, OBJNULL}, -#endif {SYS_ "ALLOCATE-FOREIGN-DATA", SI_ORDINARY, si_allocate_foreign_data, 2, OBJNULL}, {SYS_ "FIND-FOREIGN-SYMBOL", SI_ORDINARY, si_find_foreign_symbol, 4, OBJNULL}, @@ -1626,7 +1613,6 @@ cl_symbols[] = { {SYS_ "QUASIQUOTE", SI_ORDINARY, NULL, -1, OBJNULL}, {SYS_ "*EXIT-HOOKS*", SI_SPECIAL, NULL, -1, ECL_NIL}, -#ifdef CLOS {CLOS_ ".COMBINED-METHOD-ARGS.", CLOS_SPECIAL, NULL, -1, ECL_NIL}, {CLOS_ "+BUILTIN-CLASSES+", CLOS_ORDINARY, NULL, -1, ECL_NIL}, {CLOS_ "*NEXT-METHODS*", CLOS_SPECIAL, NULL, -1, ECL_NIL}, @@ -1736,7 +1722,6 @@ cl_symbols[] = { {CLOS_ "LOAD-DEFCLASS", CLOS_ORDINARY, ECL_NAME(clos_load_defclass), 4, OBJNULL}, {CLOS_ "DOCSTRING", CLOS_ORDINARY, NULL, -1, OBJNULL}, {CLOS_ "SAFE-INSTANCE-REF", CLOS_ORDINARY, clos_safe_instance_ref, 2, OBJNULL}, -#endif {SYS_ "CL-FIXNUM-BITS", SI_CONSTANT, NULL, -1, ecl_make_fixnum(FIXNUM_BITS)}, {EXT_ "CL-FIXNUM", EXT_ORDINARY, NULL, -1, NULL}, diff --git a/src/c/symbols_list2.h b/src/c/symbols_list2.h index 6c886b9d3..e3fda409b 100644 --- a/src/c/symbols_list2.h +++ b/src/c/symbols_list2.h @@ -84,11 +84,7 @@ cl_symbols[] = { {"NIL",NULL}, {"T",NULL}, -#ifdef CLOS {SYS_ "UNBOUND","si_unbound"}, -#else -{SYS_ "UNBOUND",NULL}, -#endif {SYS_ "PROTECT-TAG",NULL}, {SYS_ "*RESTART-CLUSTERS*",NULL}, {SYS_ "*HANDLER-CLUSTERS*",NULL}, @@ -1020,8 +1016,6 @@ cl_symbols[] = { {"Y-OR-N-P","ECL_NAME(cl_y_or_n_p)"}, {"YES-OR-NO-P","ECL_NAME(cl_yes_or_no_p)"}, {"ZEROP","cl_zerop"}, - -#ifdef CLOS {"ALLOCATE-INSTANCE",NULL}, {"ADD-METHOD",NULL}, {"BUILT-IN-CLASS",NULL}, @@ -1106,7 +1100,6 @@ cl_symbols[] = { {KEY_ "REQUIRED",NULL}, {KEY_ "WRITER",NULL}, {KEY_ "WRITERS",NULL}, -#endif /* SYSTEM PACKAGE */ {SYS_ "#!",NULL}, @@ -1275,9 +1268,6 @@ cl_symbols[] = { {SYS_ "WRITE-OBJECT","si_write_object"}, {SYS_ "WRITE-UGLY-OBJECT","si_write_ugly_object"}, -#ifndef CLOS -{SYS_ "STRUCTURE-INCLUDE",NULL}, -#else {SYS_ "COPY-INSTANCE","si_copy_instance"}, {SYS_ "GENERIC-FUNCTION-P","si_generic_function_p"}, {SYS_ "INSTANCE-REF","si_instance_ref"}, @@ -1292,7 +1282,6 @@ cl_symbols[] = { {SYS_ "SUBCLASSP","ECL_NAME(si_subclassp)"}, {SYS_ "OF-CLASS-P","ECL_NAME(si_of_class_p)"}, /*{SYS_ "UNBOUND","si_unbound"}, */ -#endif {EXT_ "*SOURCE-LOCATION*",NULL}, {EXT_ "*REGISTER-WITH-PDE-HOOK*",NULL}, @@ -1465,10 +1454,8 @@ cl_symbols[] = { {EXT_ "INTEGER64",NULL}, {EXT_ "LAMBDA-BLOCK",NULL}, {EXT_ "QUIT","si_quit"}, -#ifdef CLOS {EXT_ "GET-METHOD",NULL}, {EXT_ "INSTANCE",NULL}, -#endif {SYS_ "ALLOCATE-FOREIGN-DATA","si_allocate_foreign_data"}, {SYS_ "FIND-FOREIGN-SYMBOL","si_find_foreign_symbol"}, @@ -1626,7 +1613,6 @@ cl_symbols[] = { {SYS_ "QUASIQUOTE",NULL}, {SYS_ "*EXIT-HOOKS*",NULL}, -#ifdef CLOS {CLOS_ ".COMBINED-METHOD-ARGS.",NULL}, {CLOS_ "+BUILTIN-CLASSES+",NULL}, {CLOS_ "*NEXT-METHODS*",NULL}, @@ -1736,7 +1722,6 @@ cl_symbols[] = { {CLOS_ "LOAD-DEFCLASS","ECL_NAME(clos_load_defclass)"}, {CLOS_ "DOCSTRING",NULL}, {CLOS_ "SAFE-INSTANCE-REF","clos_safe_instance_ref"}, -#endif {SYS_ "CL-FIXNUM-BITS",NULL}, {EXT_ "CL-FIXNUM",NULL}, diff --git a/src/c/typespec.d b/src/c/typespec.d index 24ffa69f3..d10dfd266 100644 --- a/src/c/typespec.d +++ b/src/c/typespec.d @@ -234,7 +234,6 @@ cl_type_of(cl_object x) cl_object t; cl_type tx = ecl_t_of(x); switch (tx) { -#ifdef CLOS case t_instance: { cl_object cl = ECL_CLASS_OF(x); t = ECL_CLASS_NAME(cl); @@ -242,12 +241,10 @@ cl_type_of(cl_object x) t = cl; break; } -#endif -#if 1 case t_fixnum: case t_bignum: - t = cl_list(3, @'integer', x, x); break; -#endif + t = cl_list(3, @'integer', x, x); + break; case t_character: { int i = ECL_CHAR_CODE(x); if (ecl_standard_char_p(i)) { @@ -320,10 +317,6 @@ cl_type_of(cl_object x) t = @'simple-array'; t = cl_list(3, t, @'bit', cl_list(1, ecl_make_fixnum(x->vector.dim))); break; -#ifndef CLOS - case t_structure: - t = x->str.name; break; -#endif case t_stream: switch (x->stream.mode) { case ecl_smm_synonym: t = @'synonym-stream'; break; diff --git a/src/h/config.h.in b/src/h/config.h.in index 697d62379..09903e2f7 100644 --- a/src/h/config.h.in +++ b/src/h/config.h.in @@ -49,8 +49,6 @@ /* * FEATURES LINKED IN */ -/* Always use CLOS */ -#define CLOS /* Use GNU Multiple Precision library for bignums */ #ifndef DPP diff --git a/src/h/external.h b/src/h/external.h index 840205242..d5b5e05ec 100755 --- a/src/h/external.h +++ b/src/h/external.h @@ -109,10 +109,8 @@ struct cl_env_struct { generic functions. In a multithreaded environment we must queue operations in which the hash is cleared from updated generic functions. */ -#ifdef CLOS struct ecl_cache *method_cache; struct ecl_cache *slot_cache; -#endif /* foreign function interface */ #ifdef HAVE_LIBFFI @@ -177,12 +175,10 @@ struct cl_core_struct { cl_object keyword_package; cl_object system_package; cl_object ext_package; -#ifdef CLOS cl_object clos_package; # ifdef ECL_CLOS_STREAMS cl_object gray_package; # endif -#endif cl_object mp_package; cl_object c_package; cl_object ffi_package; @@ -497,10 +493,8 @@ extern ECL_API short ecl_digit_char(cl_fixnum w, cl_fixnum r); /* clos.c */ -#ifdef CLOS extern ECL_API cl_object cl_find_class _ECL_ARGS((cl_narg narg, cl_object name, ...)); extern ECL_API cl_object cl_class_of(cl_object x); -#endif /* cmpaux.c */ @@ -784,14 +778,12 @@ extern ECL_API void ecl_register_root(cl_object *p); /* gfun.c */ -#ifdef CLOS extern ECL_API void _ecl_set_method_hash_size(cl_env_ptr env, cl_index size); extern ECL_API cl_object si_clear_gfun_hash(cl_object what); extern ECL_API cl_object clos_set_funcallable_instance_function(cl_object x, cl_object function_or_t); extern ECL_API cl_object si_generic_function_p(cl_object instance); extern ECL_API cl_object _ecl_standard_dispatch(cl_object frame, cl_object fun); -#endif /* CLOS */ /* hash.c */ @@ -828,7 +820,6 @@ extern ECL_API cl_index ecl_hash_table_count(cl_object hash); /* instance.c */ -#ifdef CLOS extern ECL_API cl_object si_allocate_raw_instance(cl_object orig, cl_object clas, cl_object size); extern ECL_API cl_object si_instance_class(cl_object x); extern ECL_API cl_object si_instance_class_set(cl_object x, cl_object y); @@ -849,7 +840,6 @@ extern ECL_API cl_object si_copy_instance(cl_object x); extern ECL_API cl_object ecl_slot_value(cl_object x, const char *slot); extern ECL_API cl_object ecl_slot_value_set(cl_object x, const char *slot, cl_object y); -#endif /* CLOS */ /* list.c */ @@ -1654,9 +1644,6 @@ extern ECL_API cl_object si_structure_set(cl_object x, cl_object type, cl_object extern ECL_API cl_object si_structurep(cl_object s); extern ECL_API cl_object si_make_structure _ECL_ARGS((cl_narg narg, cl_object type, ...)); -#ifndef CLOS -extern ECL_API cl_object structure_to_list(cl_object x); -#endif extern ECL_API cl_object ecl_structure_ref(cl_object x, cl_object name, int n); extern ECL_API cl_object ecl_structure_set(cl_object x, cl_object name, int n, cl_object v); @@ -2139,7 +2126,6 @@ extern ECL_API cl_object cl_copy_pprint_dispatch _ECL_ARGS((cl_narg narg, ...)); extern ECL_API cl_object cl_pprint_dispatch _ECL_ARGS((cl_narg narg, cl_object V1, ...)); extern ECL_API cl_object cl_set_pprint_dispatch _ECL_ARGS((cl_narg narg, cl_object V1, cl_object V2, ...)); -#ifdef CLOS /* combin.lsp */ extern ECL_API cl_object cl_method_combination_error _ECL_ARGS((cl_narg narg, cl_object format, ...)); @@ -2199,8 +2185,6 @@ extern ECL_API cl_object clos_standard_instance_set(cl_object object, cl_object extern ECL_API cl_object clos_extract_lambda_list(cl_object object); extern ECL_API cl_object clos_extract_specializer_names(cl_object object); -#endif - /* conditions.lsp */ extern ECL_API cl_object cl_abort _ECL_ARGS((cl_narg narg, ...)); extern ECL_API cl_object cl_continue _ECL_ARGS((cl_narg narg, ...)); diff --git a/src/h/internal.h b/src/h/internal.h index b6528b35f..1c67df1f1 100755 --- a/src/h/internal.h +++ b/src/h/internal.h @@ -31,9 +31,7 @@ extern void init_all_symbols(void); extern void init_alloc(void); extern void init_backq(void); extern void init_big(); -#ifdef CLOS extern void init_clos(void); -#endif extern void init_error(void); extern void init_eval(void); extern void init_file(void); diff --git a/src/h/object.h b/src/h/object.h index 00d78b8d6..97e710715 100644 --- a/src/h/object.h +++ b/src/h/object.h @@ -71,12 +71,8 @@ typedef enum { t_cfun, t_cfunfixed, t_cclosure, -#ifdef CLOS t_instance, t_structure = t_instance, -#else - t_structure, -#endif /* CLOS */ #ifdef ECL_THREADS t_process, t_lock, @@ -491,28 +487,12 @@ struct ecl_string { /* string header */ }; #endif -#ifdef CLOS #define T_STRUCTURE t_instance #define ECL_STRUCT_TYPE(x) ECL_CLASS_OF(x) #define ECL_STRUCT_SLOTS(x) (x)->instance.slots #define ECL_STRUCT_LENGTH(x) (x)->instance.length #define ECL_STRUCT_SLOT(x,i) (x)->instance.slots[i] #define ECL_STRUCT_NAME(x) ECL_CLASS_NAME(ECL_CLASS_OF(x)) -#else -struct ecl_structure { /* structure header */ - _ECL_HDR; - cl_object name; /* structure name */ - cl_object *self; /* structure self */ - cl_fixnum length; /* structure length */ -}; - -#define T_STRUCTURE t_structure -#define ECL_STRUCT_TYPE(x) x->str.name -#define ECL_STRUCT_SLOTS(x) (x)->str.self -#define ECL_STRUCT_LENGTH(x) (x)->str.length -#define ECL_STRUCT_SLOT(x,i) (x)->str.self[i] -#define ECL_STRUCT_NAME(x) x->str.name -#endif enum ecl_smmode { /* stream mode */ ecl_smm_input, /* input */ @@ -961,7 +941,6 @@ struct ecl_condition_variable { }; #endif /* ECL_THREADS */ -#ifdef CLOS #define ECL_CLASS_OF(x) (x)->instance.clas #define ECL_SPEC_FLAG(x) (x)->instance.slots[0] #define ECL_SPEC_OBJECT(x) (x)->instance.slots[3] @@ -986,7 +965,6 @@ struct ecl_instance { /* instance header */ cl_object sig; /* generation signature */ cl_object *slots; /* instance slots */ }; -#endif /* CLOS */ #ifdef ECL_SSE2 union ecl_sse_data { @@ -1055,13 +1033,8 @@ union cl_lispunion { struct ecl_cfun cfun; /* compiled function */ struct ecl_cfunfixed cfunfixed; /* compiled function */ struct ecl_cclosure cclosure; /* compiled closure */ - struct ecl_dummy d; /* dummy */ -#ifdef CLOS struct ecl_instance instance; /* clos instance */ -#else - struct ecl_structure str; /* structure */ -#endif /* CLOS */ #ifdef ECL_THREADS struct ecl_process process; /* process */ struct ecl_queue queue; /* lock */