-/* Copyright (C) 1995,1996 Free Software Foundation, Inc.
+/* Copyright (C) 1995, 1996, 1999, 2000 Free Software Foundation, Inc.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* If you write modifications of your own for GUILE, it is your choice
* whether to permit this exception to apply to your modifications.
* If you do not wish that, delete this exception notice. */
+
+/* Software engineering face-lift by Greg J. Badros, 11-Dec-1999,
+ gjb@cs.washington.edu, http://www.cs.washington.edu/homes/gjb */
+
\f
/* This file and objects.h contains those minimal pieces of the Guile
* libguile. See the comments in objects.h.
*/
-#include "_scm.h"
-
-#include "struct.h"
-#include "procprop.h"
-#include "chars.h"
-#include "keywords.h"
-#include "smob.h"
-#include "eval.h"
-#include "alist.h"
-
-#include "objects.h"
+#include "libguile/_scm.h"
+
+#include "libguile/struct.h"
+#include "libguile/procprop.h"
+#include "libguile/chars.h"
+#include "libguile/keywords.h"
+#include "libguile/smob.h"
+#include "libguile/eval.h"
+#include "libguile/alist.h"
+#include "libguile/ports.h"
+#include "libguile/strings.h"
+#include "libguile/vectors.h"
+
+#include "libguile/validate.h"
+#include "libguile/objects.h"
\f
SCM scm_metaclass_standard;
SCM *scm_port_class = 0;
SCM *scm_smob_class = 0;
-SCM scm_apply_generic_env;
-
SCM scm_no_applicable_method;
SCM (*scm_make_extended_class) (char *type_name);
return scm_class_integer;
case scm_tc3_imm24:
- if (SCM_ICHRP (x))
+ if (SCM_CHARP (x))
return scm_class_char;
else
{
return scm_class_pair;
case scm_tcs_closures:
return scm_class_procedure;
- case scm_tcs_symbols:
+ case scm_tc7_symbol:
return scm_class_symbol;
case scm_tc7_vector:
case scm_tc7_wvect:
+#ifdef HAVE_ARRAYS
case scm_tc7_bvect:
case scm_tc7_byvect:
case scm_tc7_svect:
case scm_tc7_fvect:
case scm_tc7_dvect:
case scm_tc7_cvect:
+#endif
return scm_class_vector;
case scm_tc7_string:
case scm_tc7_substring:
case scm_tc7_smob:
{
- SCM type = SCM_TYP16 (x);
- if (type == scm_tc16_flo)
- {
- if (SCM_CAR (x) & SCM_IMAG_PART)
- return scm_class_complex;
- else
- return scm_class_real;
- }
- else if (type != scm_tc16_port_with_ps)
+ long type = SCM_TYP16 (x);
+ if (type != scm_tc16_port_with_ps)
return scm_smob_class[SCM_TC2SMOBNUM (type)];
x = SCM_PORT_WITH_PS_PORT (x);
/* fall through to ports */
}
case scm_tc7_port:
- return scm_port_class[(SCM_WRTNG & SCM_CAR (x)
- ? (SCM_RDNG & SCM_CAR (x)
+ return scm_port_class[(SCM_WRTNG & SCM_CELL_WORD_0 (x)
+ ? (SCM_RDNG & SCM_CELL_WORD_0 (x)
? SCM_INOUT_PCLASS_INDEX | SCM_PTOBNUM (x)
: SCM_OUT_PCLASS_INDEX | SCM_PTOBNUM (x))
: SCM_IN_PCLASS_INDEX | SCM_PTOBNUM (x))];
else if (SCM_OBJ_CLASS_FLAGS (x) & SCM_CLASSF_GOOPS)
{
/* Goops object */
- if (SCM_OBJ_CLASS_REDEF (x) != SCM_BOOL_F)
+ if (! SCM_FALSEP (SCM_OBJ_CLASS_REDEF (x)))
scm_change_object_class (x,
SCM_CLASS_OF (x), /* old */
SCM_OBJ_CLASS_REDEF (x)); /* new */
SCM class = scm_make_extended_class (SCM_NFALSEP (name)
? SCM_ROCHARS (name)
: 0);
- SCM_SET_STRUCT_TABLE_CLASS (handle, class);
+ SCM_SET_STRUCT_TABLE_CLASS (SCM_CDR (handle), class);
return class;
}
}
return scm_class_unknown;
}
+/* (SCM_IM_DISPATCH ARGS N-SPECIALIZED
+ * #((TYPE1 ... ENV FORMALS FORM ...) ...)
+ * GF)
+ *
+ * (SCM_IM_HASH_DISPATCH ARGS N-SPECIALIZED HASHSET MASK
+ * #((TYPE1 ... ENV FORMALS FORM ...) ...)
+ * GF)
+ *
+ * ARGS is either a list of expressions, in which case they
+ * are interpreted as the arguments of an application, or
+ * a non-pair, which is interpreted as a single expression
+ * yielding all arguments.
+ *
+ * SCM_IM_DISPATCH expressions in generic functions always
+ * have ARGS = the symbol `args' or the iloc #@0-0.
+ *
+ * Need FORMALS in order to support varying arity. This
+ * also avoids the need for renaming of bindings.
+ *
+ * We should probably not complicate this mechanism by
+ * introducing "optimizations" for getters and setters or
+ * primitive methods. Getters and setter will normally be
+ * compiled into @slot-[ref|set!] or a procedure call.
+ * They rely on the dispatch performed before executing
+ * the code which contains them.
+ *
+ * We might want to use a more efficient representation of
+ * this form in the future, perhaps after we have introduced
+ * low-level support for syntax-case macros.
+ */
+
SCM
scm_mcache_lookup_cmethod (SCM cache, SCM args)
{
methods = SCM_CADR (z);
i = 0;
ls = args;
- do
- {
- i += (SCM_STRUCT_DATA (scm_class_of (SCM_CAR (ls)))
- [scm_si_hashsets + hashset]);
- ls = SCM_CDR (ls);
- }
- while (--j && SCM_NIMP (ls));
+ if (SCM_NIMP (ls))
+ do
+ {
+ i += SCM_STRUCT_DATA (scm_class_of (SCM_CAR (ls)))
+ [scm_si_hashsets + hashset];
+ ls = SCM_CDR (ls);
+ }
+ while (--j && SCM_NIMP (ls));
i &= mask;
end = i;
}
int j = n;
z = SCM_VELTS (methods)[i];
ls = args; /* list of arguments */
- do
- {
- /* More arguments than specifiers => CLASS != ENV */
- if (scm_class_of (SCM_CAR (ls)) != SCM_CAR (z))
- goto next_method;
- ls = SCM_CDR (ls);
- z = SCM_CDR (z);
- }
- while (--j && SCM_NIMP (ls));
+ if (SCM_NIMP (ls))
+ do
+ {
+ /* More arguments than specifiers => CLASS != ENV */
+ if (! SCM_EQ_P (scm_class_of (SCM_CAR (ls)), SCM_CAR (z)))
+ goto next_method;
+ ls = SCM_CDR (ls);
+ z = SCM_CDR (z);
+ }
+ while (--j && SCM_NIMP (ls));
/* Fewer arguments than specifiers => CAR != ENV */
- if (!SCM_CONSP (SCM_CAR (z)))
+ if (!(SCM_IMP (SCM_CAR (z)) || SCM_CONSP (SCM_CAR (z))))
goto next_method;
return z;
next_method:
}
SCM
-scm_mcache_create_cmethod (SCM cache, SCM args)
+scm_mcache_compute_cmethod (SCM cache, SCM args)
{
SCM cmethod = scm_mcache_lookup_cmethod (cache, args);
if (SCM_IMP (cmethod))
}
SCM
-scm_call_generic_0 (SCM gf)
-{
- SCM clos = SCM_ENTITY_PROC_0 (gf);
- if (SCM_CLOSUREP (clos))
- return scm_eval_body (SCM_CDR (SCM_CODE (clos)),
- SCM_EXTEND_ENV (SCM_CAR (SCM_CODE (clos)),
- SCM_LIST1 (gf),
- SCM_ENV (clos)));
- else
- return SCM_SUBRF (clos) (gf);
-}
-
-SCM
-scm_call_generic_1 (SCM gf, SCM a1)
+scm_apply_generic (SCM gf, SCM args)
{
- SCM args = SCM_LIST1 (a1);
- SCM cmethod = scm_mcache_create_cmethod (SCM_ENTITY_PROC_1 (gf), args);
+ SCM cmethod = scm_mcache_compute_cmethod (SCM_ENTITY_PROCEDURE (gf), args);
return scm_eval_body (SCM_CDR (SCM_CMETHOD_CODE (cmethod)),
SCM_EXTEND_ENV (SCM_CAR (SCM_CMETHOD_CODE (cmethod)),
args,
}
SCM
-scm_call_generic_2 (SCM gf, SCM a1, SCM a2)
+scm_call_generic_0 (SCM gf)
{
- SCM args = SCM_LIST2 (a1, a2);
- SCM cmethod = scm_mcache_create_cmethod (SCM_ENTITY_PROC_2 (gf), args);
- if (SCM_IMP (cmethod))
- return scm_call_generic_2 (scm_no_applicable_method, gf, args);
- return scm_eval_body (SCM_CDR (SCM_CMETHOD_CODE (cmethod)),
- SCM_EXTEND_ENV (SCM_CAR (SCM_CMETHOD_CODE (cmethod)),
- args,
- SCM_CMETHOD_ENV (cmethod)));
+ return scm_apply_generic (gf, SCM_EOL);
}
SCM
-scm_call_generic_3 (SCM gf, SCM a1, SCM a2, SCM a3)
+scm_call_generic_1 (SCM gf, SCM a1)
{
- SCM args = SCM_LIST3 (a1, a2, a3);
- SCM cmethod = scm_mcache_create_cmethod (SCM_ENTITY_PROC_3 (gf), args);
- if (SCM_IMP (cmethod))
- return scm_call_generic_2 (scm_no_applicable_method, gf, args);
- return scm_eval_body (SCM_CDR (SCM_CMETHOD_CODE (cmethod)),
- SCM_EXTEND_ENV (SCM_CAR (SCM_CMETHOD_CODE (cmethod)),
- args,
- SCM_CMETHOD_ENV (cmethod)));
+ return scm_apply_generic (gf, SCM_LIST1 (a1));
}
SCM
-scm_apply_generic (SCM gf, SCM args)
+scm_call_generic_2 (SCM gf, SCM a1, SCM a2)
{
- if (SCM_NULLP (args))
- return scm_call_generic_0 (gf);
- {
- SCM cache = (SCM_NULLP (SCM_CDR (args))
- ? SCM_ENTITY_PROC_1 (gf)
- : (SCM_NULLP (SCM_CDDR (args))
- ? SCM_ENTITY_PROC_2 (gf)
- : SCM_ENTITY_PROC_3 (gf)));
- SCM cmethod = scm_mcache_create_cmethod (cache, args);
- if (SCM_IMP (cmethod))
- return scm_call_generic_2 (scm_no_applicable_method, gf, args);
- return scm_eval_body (SCM_CDR (SCM_CMETHOD_CODE (cmethod)),
- SCM_EXTEND_ENV (SCM_CAR (SCM_CMETHOD_CODE (cmethod)),
- args,
- SCM_CMETHOD_ENV (cmethod)));
- }
+ return scm_apply_generic (gf, SCM_LIST2 (a1, a2));
}
-SCM_PROC (s_entity_p, "entity?", 1, 0, 0, scm_entity_p);
-
SCM
-scm_entity_p (SCM obj)
+scm_call_generic_3 (SCM gf, SCM a1, SCM a2, SCM a3)
{
- return (SCM_NIMP (obj) && SCM_STRUCTP (obj) && SCM_I_ENTITYP (obj)
- ? SCM_BOOL_T
- : SCM_BOOL_F);
+ return scm_apply_generic (gf, SCM_LIST3 (a1, a2, a3));
}
-SCM_PROC (s_operator_p, "operator?", 1, 0, 0, scm_operator_p);
-
-SCM
-scm_operator_p (SCM obj)
+SCM_DEFINE (scm_entity_p, "entity?", 1, 0, 0,
+ (SCM obj),
+"")
+#define FUNC_NAME s_scm_entity_p
{
- return (SCM_NIMP (obj)
- && SCM_STRUCTP (obj)
- && SCM_I_OPERATORP (obj)
- && !SCM_I_ENTITYP (obj)
- ? SCM_BOOL_T
- : SCM_BOOL_F);
+ return SCM_BOOL(SCM_STRUCTP (obj) && SCM_I_ENTITYP (obj));
}
+#undef FUNC_NAME
-SCM_PROC (s_set_object_procedure_x, "set-object-procedure!", 1, 0, 1, scm_set_object_procedure_x);
-
-SCM_SYMBOL (scm_sym_atdispatch, "@dispatch");
+SCM_DEFINE (scm_operator_p, "operator?", 1, 0, 0,
+ (SCM obj),
+"")
+#define FUNC_NAME s_scm_operator_p
+{
+ return SCM_BOOL(SCM_STRUCTP (obj)
+ && SCM_I_OPERATORP (obj)
+ && !SCM_I_ENTITYP (obj));
+}
+#undef FUNC_NAME
-SCM
-scm_set_object_procedure_x (SCM obj, SCM procs)
+SCM_DEFINE (scm_set_object_procedure_x, "set-object-procedure!", 2, 0, 0,
+ (SCM obj, SCM proc),
+"")
+#define FUNC_NAME s_scm_set_object_procedure_x
{
- SCM proc[4], *pp, p, setp, arity;
- int i, a, r;
- SCM_ASSERT (SCM_NIMP (obj) && SCM_STRUCTP (obj)
+ SCM_ASSERT (SCM_STRUCTP (obj)
&& ((SCM_CLASS_FLAGS (obj) & SCM_CLASSF_OPERATOR)
|| (SCM_I_ENTITYP (obj)
&& !(SCM_OBJ_CLASS_FLAGS (obj)
& SCM_CLASSF_PURE_GENERIC))),
obj,
SCM_ARG1,
- s_set_object_procedure_x);
- for (i = 0; i < 4; ++i)
- proc[i] = SCM_BOOL_F;
- i = 0;
- while (SCM_NIMP (procs))
- {
- if (i == 4)
- scm_wrong_num_args (scm_makfrom0str (s_set_object_procedure_x));
- p = SCM_CAR (procs);
- setp = 0;
- SCM_ASSERT (SCM_NIMP (p), p, SCM_ARG2 + i, s_set_object_procedure_x);
- if (SCM_CLOSUREP (p))
- {
- arity = scm_procedure_property (p, scm_sym_arity);
- a = SCM_INUM (SCM_CAR (arity));
- /* Closures have zero optional args */
- r = SCM_NFALSEP (SCM_CADDR (arity));
- if (a == 1 || (a <= 1 && r))
- {
- if (SCM_NFALSEP (proc[0]))
- goto ambiguous;
- proc[0] = setp = p;
- }
- if (a == 2 || (a <= 2 && r))
- {
- if (SCM_NFALSEP (proc[1]))
- goto ambiguous;
- proc[1] = setp = p;
- }
- if (a == 3 || (a <= 3 && r))
- {
- if (SCM_NFALSEP (proc[2]))
- goto ambiguous;
- proc[2] = setp = p;
- }
- if (a <= 4 && r)
- {
- if (SCM_NFALSEP (proc[3]))
- goto ambiguous;
- proc[3] = setp = p;
- }
- }
- else if (SCM_TYP7 (p) == scm_tc7_subr_1)
- {
- if (SCM_NFALSEP (proc[0]))
- goto ambiguous;
- proc[0] = setp = p;
- }
- else if (SCM_TYP7 (p) == scm_tc7_subr_2)
- {
- if (SCM_NFALSEP (proc[1]))
- goto ambiguous;
- proc[1] = setp = p;
- }
- else if (SCM_TYP7 (p) == scm_tc7_subr_3)
- {
- if (SCM_NFALSEP (proc[2]))
- goto ambiguous;
- proc[2] = setp = p;
- }
- else if (SCM_TYP7 (p) == scm_tc7_lsubr_2)
- {
- if (SCM_NFALSEP (proc[3]))
- {
- ambiguous:
- SCM_ASSERT (0, p, "Ambiguous procedure arities",
- s_set_object_procedure_x);
- }
- proc[3] = setp = p;
- }
- SCM_ASSERT (setp, p, SCM_ARG2 + i, s_set_object_procedure_x);
- ++i;
- procs = SCM_CDR (procs);
- }
- pp = (SCM_I_ENTITYP (obj)
- ? &SCM_ENTITY_PROC_0 (obj)
- : &SCM_OPERATOR_CLASS (obj)->proc0);
- for (i = 0; i < 4; ++i)
- *pp++ = proc[i];
+ FUNC_NAME);
+ SCM_VALIDATE_PROC (2,proc);
+ if (SCM_I_ENTITYP (obj))
+ SCM_SET_ENTITY_PROCEDURE (obj, proc);
+ else
+ SCM_OPERATOR_CLASS (obj)->procedure = proc;
return SCM_UNSPECIFIED;
}
+#undef FUNC_NAME
#ifdef GUILE_DEBUG
-SCM_PROC (s_object_procedures, "object-procedures", 1, 0, 0, scm_object_procedures);
-
-SCM
-scm_object_procedures (SCM obj)
+SCM_DEFINE (scm_object_procedure, "object-procedure", 1, 0, 0,
+ (SCM obj),
+"")
+#define FUNC_NAME s_scm_object_procedure
{
- SCM_ASSERT (SCM_NIMP (obj) && SCM_STRUCTP (obj) && SCM_I_OPERATORP (obj),
- obj, SCM_ARG1, s_object_procedures);
+ SCM_ASSERT (SCM_STRUCTP (obj)
+ && ((SCM_CLASS_FLAGS (obj) & SCM_CLASSF_OPERATOR)
+ || SCM_I_ENTITYP (obj)),
+ obj, SCM_ARG1, FUNC_NAME);
return (SCM_I_ENTITYP (obj)
- ? SCM_LIST4 (SCM_ENTITY_PROC_0 (obj),
- SCM_ENTITY_PROC_1 (obj),
- SCM_ENTITY_PROC_2 (obj),
- SCM_ENTITY_PROC_3 (obj))
- : SCM_LIST4 (SCM_OPERATOR_PROC_0 (obj),
- SCM_OPERATOR_PROC_1 (obj),
- SCM_OPERATOR_PROC_2 (obj),
- SCM_OPERATOR_PROC_3 (obj)));
+ ? SCM_ENTITY_PROCEDURE (obj)
+ : SCM_OPERATOR_CLASS (obj)->procedure);
}
+#undef FUNC_NAME
#endif /* GUILE_DEBUG */
/* The following procedures are not a part of Goops but a minimal
return c;
}
-SCM_PROC (s_make_class_object, "make-class-object", 2, 0, 0, scm_make_class_object);
-
-SCM
-scm_make_class_object (SCM metaclass, SCM layout)
+SCM_DEFINE (scm_make_class_object, "make-class-object", 2, 0, 0,
+ (SCM metaclass, SCM layout),
+"")
+#define FUNC_NAME s_scm_make_class_object
{
unsigned long flags = 0;
- SCM_ASSERT (SCM_NIMP (metaclass) && SCM_STRUCTP (metaclass),
- metaclass, SCM_ARG1, s_make_class_object);
- SCM_ASSERT (SCM_NIMP (layout) && SCM_STRINGP (layout),
- layout, SCM_ARG2, s_make_class_object);
- if (metaclass == scm_metaclass_operator)
+ SCM_VALIDATE_STRUCT (1,metaclass);
+ SCM_VALIDATE_STRING (2,layout);
+ if (SCM_EQ_P (metaclass, scm_metaclass_operator))
flags = SCM_CLASSF_OPERATOR;
return scm_i_make_class_object (metaclass, layout, flags);
}
+#undef FUNC_NAME
-SCM_PROC (s_make_subclass_object, "make-subclass-object", 2, 0, 0, scm_make_subclass_object);
-
-SCM
-scm_make_subclass_object (SCM class, SCM layout)
+SCM_DEFINE (scm_make_subclass_object, "make-subclass-object", 2, 0, 0,
+ (SCM class, SCM layout),
+"")
+#define FUNC_NAME s_scm_make_subclass_object
{
SCM pl;
- SCM_ASSERT (SCM_NIMP (class) && SCM_STRUCTP (class),
- class,
- SCM_ARG1,
- s_make_subclass_object);
- SCM_ASSERT (SCM_NIMP (layout) && SCM_STRINGP (layout),
- layout,
- SCM_ARG2,
- s_make_subclass_object);
- pl = SCM_STRUCT_DATA (class)[scm_vtable_index_layout];
+ SCM_VALIDATE_STRUCT (1,class);
+ SCM_VALIDATE_STRING (2,layout);
+ pl = SCM_PACK (SCM_STRUCT_DATA (class) [scm_vtable_index_layout]);
/* Convert symbol->string */
pl = scm_makfromstr (SCM_CHARS (pl), (scm_sizet) SCM_LENGTH (pl), 0);
return scm_i_make_class_object (SCM_STRUCT_VTABLE (class),
scm_string_append (SCM_LIST2 (pl, layout)),
SCM_CLASS_FLAGS (class));
}
+#undef FUNC_NAME
void
scm_init_objects ()
{
SCM ms = scm_makfrom0str (SCM_METACLASS_STANDARD_LAYOUT);
- SCM ml = scm_make_struct_layout (ms);
- SCM mt = scm_make_vtable_vtable (ml, SCM_INUM0,
+ SCM mt = scm_make_vtable_vtable (ms, SCM_INUM0,
SCM_LIST3 (SCM_BOOL_F, SCM_EOL, SCM_EOL));
SCM os = scm_makfrom0str (SCM_METACLASS_OPERATOR_LAYOUT);
- SCM ol = scm_make_struct_layout (os);
- SCM ot = scm_make_vtable_vtable (ol, SCM_INUM0,
+ SCM ot = scm_make_vtable_vtable (os, SCM_INUM0,
SCM_LIST3 (SCM_BOOL_F, SCM_EOL, SCM_EOL));
SCM es = scm_makfrom0str (SCM_ENTITY_LAYOUT);
SCM_SET_CLASS_DESTRUCTOR (et, scm_struct_free_entity);
scm_sysintern ("<entity>", et);
-#include "objects.x"
+#include "libguile/objects.x"
}
+
+/*
+ Local Variables:
+ c-file-style: "gnu"
+ End:
+*/
HCoop / bpt / guile.git / blobdiff