Ignore-this: 8562c17c6a8cc5e34d542426d3f31b17

darcs-hash:0d1655a5d920bd2f3fb3f861aba369220830180f

Ignore-this: e194502be15d6dc9bb692a6f647ebaab

darcs-hash:225e9c7c65e65e9c86ae35c61c6291dc9b2c07a9

Removed dependencies on portable-threads and trivial-garbage, plus minor multi-threading improvements.

darcs-hash:56b8fd98f2f784f29a7b1f62cd955a40790c5a69

darcs-hash:7a53a0dc61acabeafcdfcd98bc490d30157f960e

Another variation of making ContextL thread-safe. This time it should actually work ;), and it is again more fine-grained, that is, more efficient than the previous version.

darcs-hash:011b88f50371c2287cfd915f09bfb45b80d45feb

darcs-hash:c442d421467ec11c3072a14fd76efb7122f35609

darcs-hash:8b01c155a4dae58941c4c7d7994abed83c613135

darcs-hash:8edd57f0bc55028220ea4fff3452936b444a88e1

Added slightly more flexible error handling when find-layer and find-layer-class don't find a layer for a given name.

darcs-hash:516c6dae5af8d32451c81f2b9b3038e00f8e66a0

darcs-hash:89ac2b42b0d622ace7c09e5615f984df7bc0631d

darcs-hash:a2ce2fcb8632e34bfa443183257a1611b803220a

darcs-hash:4cfd40b19c5238a1336c9c9d037617b48367692c

darcs-hash:909ff3d2493c6b1fa35779df04a31eedd063e40e

Added an initform to layer-name in standard-layer-class to avoid entering the debugger when printing instances. (due to Attila Lendvai)

darcs-hash:1cc178b53067c12965d7a04526e8888dc781e7d6

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

darcs-hash:88684054b2764d3b4ea3c073e4e9e8351630e7ac

darcs-hash:c9861c9dd1a7637cbbaf60d630cb523012df46c3

darcs-hash:ca3929f52d4d5187e8a8f156bfd2cd2f62cb780a

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

Added activate-layer-using-class and deactivate-layer-using-class for metacircular layer activation/deactivation.

darcs-hash:a8f2ff872a966c3ab926dff7e6c22c04ac495f96

darcs-hash:db5223dd0c5e1860c4f4b2dcdf9edc5c2c2f2a21

darcs-hash:9d38c93fb54f993efee4f7b14d9041206f9873b6

Renamed layer-object and layer-class to standard-layer-object and standard-layer-class, as another preparatory step towards providing a MOP for layer activation/deactivation.

darcs-hash:5f254394bca0562ec72ab0445ab7343b679d56e7

Turned many uses of *active-context* into a reference to a lexically scoped parameter active-context. This is a first step towards providing a MOP for layer activation/deactivation.

darcs-hash:2a666b054fd6f68d1088ca23d18e208faea6f1b5

darcs-hash:d4f0c0c82bb211af377e25eea7c56c76bcf46a6e

Thanks to Nick Bourner for the main idea.

darcs-hash:d7776316665209947e6c0ac0854b3aaf0911fda6

Layers and layer classes were somewhat mixed up until recently. (See also comments about singleton classes.) They are now more cleanly separated.

Note that previous uses of find-layer have to be replaced by calls to find-layer-class. The function find-layer has now a slightly different meaning - it returns the prototye instance for a layer, not its class anymore.

darcs-hash:f862d26e676edd3e41c48c4ac4179576fcbb449a

darcs-hash:f28a50485b85fb7094c8f369ad3bc3ddab27e3da

darcs-hash:fc3de0eff69b544d0c196d969a6ee9dfbb1fc43f

darcs-hash:19fac4713c67fb909f953806a2e2b5f1fedd9262

darcs-hash:0ddcfa92239728c45890caf0d4769abbe00a2a02

Before this change, layers were simply classes with the same name as given in the deflayer form. This potentially leads to name conflicts between classes and layers. Since Common Lisp favors multiple namespaces, I have changed this, so now layers reside in their own namespace. (They are still internally implemented as classes.)

darcs-hash:8d44351700472fed4f93f563cf8ebc48107a8d2c

darcs-hash:3df7bc6ef7e74d841e60d2f3c0d5694a43e68b31

darcs-hash:4cc8d597a6f4648ef2474770569de7d7a1814d40

Added safe-special-symbol-progv and special-symbol-progv, plus a few optimization tweaks in cx-layer.

darcs-hash:c175ed95215a08b035ecc013bd6a517a4dce94a9

Inheritance between layers is not officially supported yet, but I have already added checks for ensuring active and inactive that would result in incorrect layer orderings.

darcs-hash:47fd8d829607c3210815da6d8b0057f58853f33e

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:ff9f06424ff8aa76528f8c3c9f67c9b9f5db3b37