mirrors/ecl
1
Fork 0
mirror of https://gitlab.com/embeddable-common-lisp/ecl.git synced 2026-01-13 12:52:08 -08:00
Code Issues Projects Releases Packages Wiki Activity

CLOS: remove dead code and conditionals for non-clos builds

Browse source 
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 <dkochmanski@turtle-solutions.eu>
This commit is contained in:
Daniel Kochmański 2015-07-01 16:56:17 +02:00
parent dc6aa0bce0
commit 7a29be4337
23 changed files with 6 additions and 272 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/c/all_symbols.d
View file

@ -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

12
src/c/alloc.d
View file

@ -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);

21
src/c/alloc_2.d
View file

@ -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)) |

2
src/c/cfun.d
View file

@ -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);
}

2
src/c/ecl_features.h
View file

@ -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

4
src/c/eval.d
View file

@ -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);

15
src/c/gbc-new.d
View file

@ -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);

13
src/c/gbc.d
View file

@ -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!!! */

2
src/c/instance.d
View file

@ -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)

2
src/c/interpreter.d
View file

@ -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);

10
src/c/main.d
View file

@ -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.

17
src/c/predicate.d
View file

@ -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: {

27
src/c/printer/write_ugly.d
View file

@ -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 */

5
src/c/reference.d
View file

@ -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)

4
src/c/serialize.d
View file

@ -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 */

52
src/c/structure.d
View file

@ -19,13 +19,8 @@
#include <ecl/ecl-inl.h>
#include <string.h>
#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;
}

15
src/c/symbols_list.h
View file

@ -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},

15
src/c/symbols_list2.h
View file

@ -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},

11
src/c/typespec.d
View file

@ -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;

2
src/h/config.h.in
View file

@ -49,8 +49,6 @@
/*
* FEATURES LINKED IN
*/
/* Always use CLOS */
#define CLOS
/* Use GNU Multiple Precision library for bignums */
#ifndef DPP

16
src/h/external.h
View file

@ -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, ...));

2
src/h/internal.h
View file

@ -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);

27
src/h/object.h
View file

@ -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 */