Added a level of without-symbol-access to object initialization (in preparation for support for ABCL).

Ignore-this: 95630ccdb73a5eb90c6f72d4af4ecf03

darcs-hash:4ac06cc02d0bee748168d9906a758bfdb07be4e6

Locking of finalize-inheritance for special-class only in CL implementations that actually support multi-threading.

Ignore-this: b1bd7b318308a590a7b72615c2570b90

darcs-hash:343bb2d60d531c5ad2851ef73cfa7fa866f122f9

Ignore-this: 309513f5f1fe1abc7c4c209ac5d39c41

darcs-hash:35c2d50ca9510577bb67fd50beb5f80b0ca7fd83

Removed a subtle bug when finalizing classes that are both special and partial, which was exposed by subtle changes in PCL in SBCL 1.0.42.

Ignore-this: f54641edd4ecc4dd7db49612d38aa82c

darcs-hash:479b9d6f300c9456c0789b83974a83d44fa762a6

Ignore-this: 8562c17c6a8cc5e34d542426d3f31b17

darcs-hash:0d1655a5d920bd2f3fb3f861aba369220830180f

Ignore-this: ced4a277a1c5650088a69d15d076b2ca

darcs-hash:d84ca37d4075abb06d8adcb7da51844664738d1b

darcs-hash:67cf606782d26e4cb21edb7b2a5b1666f35abfc0

darcs-hash:7a53a0dc61acabeafcdfcd98bc490d30157f960e

darcs-hash:6f3c17c2df3eebc75ac5b2f76e0f136b62033011

darcs-hash:166b41f0885ab108410950795cee68ff4fdffe98

Added a rationale why read operatoions on special slots should be thread-safe outside of object initializations.

darcs-hash:55ac64045ae2e1fd3b3e9536d007e087535824e0

This version of ContextL (0.4) incorporates several minor and major changes as a preparation towards a 1.0 release. Here is a list of the changes:

--- Changes in the visible API ---

+ The functions activate-layer and activate-layer-using-class have been renamed to adjoin-layer and adjoin-layer-using-class, and deactivate-layer and deactivate-layer-using-class have been renamed to remove-layer and remove-layer-using-class. The new names reflect better what these functions actually do.

+ Removed the functions funcall-with-layers and apply-with-layers. Use the functions funcall-with-layer-context and apply-with-layer-context instead.

+ The deflayer macro doesn't take a :layer-class option anymore, but instead a :metaclass option. (I have tried to abstract from the internal representation as CLOS classes, but that turns out to be useless for the time being.)

--- Additions to the visible API ---

+ Added the functions funcall-with-layer-context and apply-with-layer-context.

+ Added the function current-layer-context. This captures the set of currently active layers, which can later be reinstalled with funcall-with-layer-context and apply-with-layer-context.

+ Added the metaclasses layered-function and layered-method. However, they should better not be used directly. For programmatically creating layered functions and methods, better use the functions ensure-layered-function and ensure-layered-method.

+ Added the readers layered-function-definer, layered-function-argument-precedence-order, layered-function-lambda-list.

+ Added the readers layered-method-lambda-list, layered-method-specializers, layered-method-layer.

+ Added the readers partial-class-defining-classes, partial-class-defining-metaclass and the class partial-object, which is the default superclass for partial classes.

+ Added the readers slot-definition-layered-readers and slot-definition-layered-writers.

+ You can now specify an :in-layer option in slot specifiers. This means that a slot within a define-layered-class form can be declared to be in a different layer than the respective class itself. This allows, for example, to group slots of different layers in the same define-layered-class form.

+ Layers and layered functions can now also have uninterned symbols as names. This enables a form of anonymous layers and anonymous layered functions when gensym is used to create names for them.

+ Added the function ensure-layer for programmatically creating layers.

--- Internal changes, which are not necessarily visible ---

+ If someone tries to define default initargs for singleton classes or layers, ContextL emits a warning. The error handling is improved for the case when the :allocation for a singleton or layer-specific slot is set to something else than :class.

+ Some of the :in-layer keyword parameters to internal functions have previously taken lists of layers for technical reasons. This is not the case anymore.

+ Changed the handling of the :defining-metaclass option for partial classes.

+ Layered direct slot definition metaobjects don't take :layered-reader, :layered-writer and :layered-accessor initargs anymore, but rather :layered-readers and :layered-writers, which is closer to how the CLOS MOP works as well.

+ Added methods for print-object for the major classes and metaclasses, such that, for example, debug output now prints more nicely.

darcs-hash:592a90c3f26522c79fcebd6c89449ae62c44dd41

Fixed bugs in the implementation of special classes / special slots, especially wrt class reinitialization.

darcs-hash:ea4f62b5b48d08a8ddb29da8ee623b254ea01fc7

darcs-hash:88684054b2764d3b4ea3c073e4e9e8351630e7ac

Restricted MOP-friendly initialization of special slots to CL implementations that actually need it.

darcs-hash:206645062e75064bc1a8ddc6721850de200d03c1

This is achieved by the :reinitialize option for a slot, like this:

(defclass some-class ()
  ((some-slot :initform 'foo :reinitialize t))
  (:metaclass singleton-class))

(deflayer some-layer ()
  ((some-slot :initform 'bar :reinitialize t)))

The default value for the :reinitialize option is nil. If it is nil, then the slot will only be initialized when the class/layer is initialized. When the class/layer already exists before the new defclass/deflayer form is processed, the slot keeps its old value, as is the case for slots with :allocation :class in plain CLOS. If the :reinitialize option is true, however, then the respective slot will always be re/initialized with the value given with the :initform, no matter what. If no :initform is given, the slot is made unbound, again no matter what. In other words, a slot with :reinitialize nil behaves similar to a defvar form while a slot with :reinitialize t behaves similar to a defparameter form.

Currently, CMUCL and MCL have a bug wrt reinitialization of slots with :allocation :class, which leads to subsequent bug in ContextL. This has the consequence that special slots (with the option :special set to true) in singleton classes, in layers and in special classes for slots with :allocation :class do not work correctly anymore when the respective class/layer is reinitialized. As soon as the bugs in CMUCL and MCL are fixed, I can also fix the related bug in ContextL.

darcs-hash:b2fb89374af06a505cd2aa36964ae632b9ab3520

Thanks to Drew Crampsie for the main idea.

darcs-hash:b7486fc468e6422849b3bd4932b21fef7e70ece8

Reimplementation of shared-initialize for special classes was necessary because otherwise slots with :allocation :class would have behaved erroneously when they are assigned to via initargs. (At least that was the case in one CL implementation, probably due to some optimization in the CLOS implementation that is now removed with the plain shared-initialize implementation.)

darcs-hash:84b47c8dd1f896a8173af0d9bf480b3b17467a18

darcs-hash:08a76428c0e36042db5aafa264afc5a9286b5626

darcs-hash:f28a50485b85fb7094c8f369ad3bc3ddab27e3da

CLisp seems to have problems with calling slot-xxx-using-class functions within shared-initialize under some circumstances, so I switched to calling the plain slot-xxx functions instead.

darcs-hash:3a3047de28575f8dbea39007cdc7d79414a89a37

darcs-hash:72871222ecbed3c84d72c6bf30b6cf0c75b8d266

darcs-hash:c59bf6695ee51f3071c4571b8b38ea8c39303142

It's now possible to say with-inactive-layers, and the functional equivalents to with-active-layers have also been adapted to enable inactivation of layers. During the process, a number of bugs have been revealed, especially wrt the previous removal of &allow-other-keys and problems related to finalize-inheritance in Allegro Common Lisp.

darcs-hash:aff71ea96cd5e5cc87944cc24bd01b5f3f5decdd

darcs-hash:0fa0ec7b33bef78dac7de825ba35a8774838a348

darcs-hash:ff9f06424ff8aa76528f8c3c9f67c9b9f5db3b37