Ignore-this: 5fc582c80296bcf9e9453ea8405bfa8d

darcs-hash:d87a782e65902dd1984e30e767ce533ff9f64390

Ignore-this: ca11b0358015cfd046cf0a44a359ed25

darcs-hash:5592e88d4c6284f79974d99677b8f64e7241ced6

Ignore-this: b3c2d0f7fd198e79c2c2f46859b40e93

darcs-hash:b3c39d48c710d720ca416387e170ea01e724e500

With-hash-table-locked didn't exist yet in LispWorks 5.0, so I added a regular lock for that version.

Ignore-this: 5a217ed6f08ddef7de47d5ea05b49adb

darcs-hash:b3ba1a1cd00e81b17cda333f3aeb937918894a6f

Ignore-this: ff85d5ec924e771b28b2a6d490f87e

darcs-hash:157073ae04ea0933121120d315f4091e3c1868fb

Ignore-this: 224e2a1c4d4faafe348b16e501733218

darcs-hash:378a6e46f69d646bbf11fc1953ba614720763402

Ignore-this: 2ab109817fa449fb4b8b8652bacd1487

darcs-hash:f1b3e0310b250651c26bf5477be4c57d2e26cb50

Major reorganization of the code, plus support for generic function invocation protocols in Allegro Common Lisp.

Ignore-this: 9be21704dcdc2ab8e47f596e5a82ff3b

A major reorganization of the code became necessary, because the old structure became harder than necessary to maintain. I have now moved code that is similar across many Common Lisp implementations into a shared source code file, and leave only small parts to implementation-dependent source code files. The setup of packages is combined into one file, and all relevant symbols are now exported from the packages, including symbols that may not have any definitions in some Common Lisp implementations. To further simplify things, I have moved source code from subfolders into the main folder, to avoid hierarchy creep.

Finally, Allegro Common Lisp now also supports the full generic function invocation protocols.

darcs-hash:4b756a79272aa1381988469961dd04652b9f712b

Ignore-this: 8505094d361aee4763045939771f8cfa

Originally, when I started Closer to MOP, I expected implementations that stem from the same original implementations to have similar issues with regard to CLOS MOP compatibility. So specifically, I packaged the code for CMUCL and SBCL into one folder, and that for MCL, OpenMCL and Clozure Common Lisp into one folder. It turned out that the incompatibilites are not at all similar, and that this created more problems than it solved. So I now decided to keep implementations strictly separated, to make my life easier in the future.

darcs-hash:b18e457aea79fad11fed31cb4d2e94af211cc4ef

Turned warnings about missing generic functions for defmethod forms into style warnings, and provided a way to selectively disable/enable them.

Ignore-this: 7a6a9b4cf7a97523943207c0020c2ebb

darcs-hash:c505d79b84192052c5f02c0daf72bd1a09481838

Ignore-this: 1d8e9db1a24ef50d9c12b6f7c4bf6ea7

darcs-hash:cf866c29ec6371bc4572590b0a5c0840dbfe50b1

Added improved generic function invocation protocol to Clozure Common Lisp, clisp, LispWorks and SBCL.

Ignore-this: aaafeefe5dadb70690dcfccd53bc8e2f

darcs-hash:5b84b767f94420808fd46a3579a1850054de3549

Ignore-this: 1bdf2ece0e2b5e5737b0086d687bbe56

darcs-hash:84e9871281d3d91d5a8404cdfb2aa3c79871c83e

Ignore-this: 2cab7a24d8f17062675d9a12063fcdca

darcs-hash:19d18f4943244bab627634c0f4b0921324224a7a

Some CLOS implementations have problems with determining subtype relationships between classes in certain corner cases. For example, clisp doesn't like to determine such relationships for forward referenced classes, and some instances of PCL have problems with anonymous classes under certain circumstances (primarily when doing CLOS MOP programming).

Apparently, subtypep is typically implemented based on the class precedence list, which can only be determined until after a class has been finalized, and this seems to be one of the reasons for these problems. However, the CLOS MOP places restrictions on methods for compute-class-precedence-list such that the subtype relationship actually does _not_ depend on the precedence list, but can be based on a membership test in the unordered set of all direct and indirect superclasses.

I have provided subclassp in Closer to MOP as a utility function that does just that: It walks the superclass hierarchy to determine whether one class is a subclass of another. This implementation is not that efficient, so it should only be used when subtypep fails. (It could probably be made more efficient, but since this is only provided as a replacement for subtypep in hopefully rare corner cases, I haven't put the energy into this to do this yet.)

darcs-hash:1577003438ad08385a1e4f7cf24254fce79ea359

Added standard-instance-access and funcallable-standard-instance-access to LispWorks, due to popular request.

darcs-hash:4977ab122206c49fbdb06b55f915aaae7c7bf1ec

darcs-hash:058a34b332307f899149a33967f81f74a4697788

darcs-hash:f117c253f5ab3d478f32c411f076a5b9d90f28be

A pretty common idiom is this:

(unless (class-finalized-p class)
  (finalize-inheritance class))
class

This is captured in the new utility function ensure-finalized.

darcs-hash:7d147f9c086e13bd2b83e670953ac124ec7dcb27

darcs-hash:a6d51c1d634b093f9403635cb3ec6230bba703b1

darcs-hash:e268d42f1d0bfb9c7ef64135393a2f63b243ed54