Parent Directory | Revision Log
|Links to HEAD:||(view) (annotate)|
Remove _N"" reader macro from docstrings when possible.
Merge intl-branch 2010-03-18 to HEAD. To build, you need to use boot-2010-02-1 as the bootstrap file. You should probably also use the new -P option for build.sh to generate and update the po files while building.
Restart internalization work. This new branch starts with code from the intl-branch on date 2010-02-12 18:00:00+0500. This version works and LANG=en@piglatin bin/lisp works (once the piglatin translation is added).
Mark translatable strings; regenerate cmucl.pot and cmucl.po
Add (intl:textdomain "cmucl") to the files to set the textdomain.
Merge changes from HEAD to the unicode-utf16 branch.
Fix issue with slot-value-using-class and get-accessor-method-function. See cmucl-imp, 2008/04/03, PCL bug?. Bug and link to solution provided by Hans Hubner. Solution based on sbcl patch 0.8.14.27. Here's the test case: (in-package :cl-user) (use-package :pcl) (defclass test-metaclass (standard-class) ()) (defmethod validate-superclass ((sub test-metaclass) (super standard-class)) t) (defmethod (setf slot-value-using-class) :before (newval (class test-metaclass) object slotd) (print 'setf-slot-value-using-class-before)) (defmethod (setf slot-value-using-class) :after (newval (class test-metaclass) object slotd) (print 'setf-slot-value-using-class-after)) (defclass test-class () (slot) (:metaclass test-metaclass))
Merge code from main branch of 2005-12-17 to ppc gencgc branch. Still doesn't work of course.
Signal a program-error instead of error when the number of arguments to a methood is wrong. Bug found by ansi-tests.
Merge from HEAD to revert bogus dfun changes.
Revert this back to rev 1.35. This change had nothing to do with AMOP :allocation and caused a regression on defmethod-forwared-referenced.1 test.
Add AMOP style custom slot allocation. Patch from Sverker Wiberg, cmucl-imp, 2005-01-18.
Changes in generic function's method combination don't take effect until a method is added or removed from the gf. Reported by Andreas Fuchs on a SBCL mailing list. * src/pcl/methods.lisp (reinitialize-instance) <standard-generic-function>: Make it an around method, call flush-effective-method-cache if the method combination changes. * src/pcl/dfun.lisp (flush-effective-method-cache): New function. (*effective-method-cache*): Renamed from *effective-method-table*.
Lazy signaling of errors because of invalid method qualifiers, for ANSI compliance. * src/pcl/defcombin.lisp (compute-effective-method): If *in-precompute-effective-methods-p*, generate an emf consisting of a call to %invalid-qualifiers if there are such methods. * src/pcl/combin.lisp (standard-compute-effective-method): Likewise. (make-effective-method-lambda): Handle %invalid-qualifiers like %no-primary-method. * src/pcl/braid.lisp (%invalid-qualifiers): New function. (invalid-qualifiers): New method. * src/pcl/generic-functions.lisp (invalid-qualifiers): New gf. * src/pcl/dfun.lisp (*max-emf-precomputation-methods*): Set to 100. * src/docs/cmu-user/extensions.tex (Effective Method Precomputation): Change description of *max-emf-precomputation-methods*.
Loading gray-streams lead to a vicious metacircle because effective methods of close were no longer precomputed, and close is being used somewhere inside the compiler during emf compilation. * src/pcl/gray-streams.lisp (toplevel): Call pcl-close before setting the fdefinition of close to it, analogous to what was already done for pcl-open-stream-p. * src/pcl/dfun.lisp (break-vicious-metacircle): Put the error in infinite-error-protect, just in case.
CLtS effectively forbids method load-time precomputation of effective methods (which I think is either yet another oversight, or bad language design). Found by Paul Dietz. Set *max-emf-precomputation-methods* to > 0 to allow precomputation of effective methods at method load-time for generic functions having less than the specified number of methods. * src/pcl/dfun.lisp (*max-emf-precomputation-methods*): Set to 0. * src/pcl/pkg.lisp ("PCL"): Export *max-emf-precomputation-methods*.
Method definition takes something like O(n^3) time. Reported by Eric Daniel. * src/pcl/dfun.lisp (*max-emf-precomputation-methods*): New variable. (finalize-specializers): Use it.
Fix a bug in constant-value dispatching found by Paul Dietz. * src/pcl/dfun.lisp (use-constant-value-dfun-p): Check more preconditions. (constant-value-miss): Add an assertion.
* src/pcl/info.lisp (split-declarations): Declare arg call-next-method-p ignored. * src/pcl/boot.lisp (bind-simple-lexical-method-macros) (bind-fast-lexical-method-macros): Change lambda-list of with-rebound-original-arguments. (bind-lexical-method-functions): Declare some variables ignored. (bind-lexical-method-functions): Call with-rebound-original-arguments with the right arg. * src/pcl/dfun.lisp (cache-miss-values-internal): Don't call set-emf-name. * src/pcl/fngen.lisp (flush-emf-cache): Fix a typo.
CLHS 7.6.5 keyword argument checking for calls to generic functions. Found by Paul Dietz, of course. This also includes some minor code cleanup and a fix for a bug caused by a typo. * src-gf/pcl/std-class.lisp (compute-effective-slot-definition-initargs): Reformatted to make it readable on a tty. * src-gf/pcl/methods.lisp (set-condition-svuc-method): Fix a typo. * src-gf/pcl/low.lisp (parse-lambda-list): Add an ignore declaration. * src-gf/pcl/init.lisp (valid-initargs): Use method-lambda-list*. * src-gf/pcl/dfun.lisp (use-caching-dfun-p): Use generic-function-methods*. (use-constant-value-dfun-p): Ditto. (use-dispatch-dfun-p): Don't use dispatching dfuns when we must check keyword arguments according to CLHS 7.6.5, because this computes emfs for sets methods that aren't applicable together in the usual sense; this screws up emf keyword argument checking, of course. (make-initial-dfun): Use gf-arg-info*. (update-dfun): Use generic-function-name*. (final-accessor-dfun-type, make-accessor-table) (compute-applicable-methods-using-types) (compute-applicable-methods-using-types): Likewise. * src-gf/pcl/combin.lisp (standard-compute-effective-method): Don't use the single-call-method optimization if we must check keyword arguments according to CLHS 7.6.5. (callable-generator-for-emf): Rewritten to add a keyword argument check to the emf. (emfs-must-check-applicable-keywords-p) (compute-applicable-keywords, check-applicable-keywords): New functions. (odd-number-of-keyword-arguments, invalid-keyword-argument): Moved here from boot.lisp. (make-effective-method-lambda): Add a check-applicable-keywords form to the emf, if appropriate. (memf-test-converter, memf-code-converter) (memf-constant-converter): Deal with check-applicable-keywords. (*applicable-methods*): New variable. (make-callable): Bind it. (make-emf-name): Use generic-function-name*. * src/pcl/braid.lisp (ensure-non-standard-class): Remove an used branch. * src/pcl/boot.lisp (*make-method-lambda-gf-name*): Removed. (expand-defmethod): Don't bind it. (make-method-lambda-internal): Don't add &key to the method function's lambda-list if the gf has &key. (bind-args): Rewritten. Don't do keyword checking as this is done in emfs now. (get-key-arg, get-key-arg1): Simplified; do less checking. (generic-function-name*, generic-function-methods*) (gf-arg-info*, method-lambda-list*): New functions. (check-method-arg-info): Use them. (gf-lambda-list-from-method): New function. (gf-lambda-list): Use it. Don't add &allow-other-keys to a gf's lambda-list if a method has &key. (get-generic-function-info): Use gf-arg-info*. (parse-specialized-lambda-list): Add an ignore declaration. (odd-number-of-keyword-arguments, invalid-keyword-argument): Moved to combin.lisp. (check-generic-function-lambda-list): Remove &more stuff because that's checked elsewhere now (and Python can even tell it is). * src-gf/pcl/ctor.lisp (install-optimized-constructor): Remove an unmatched ).
More SLOT-VALUE etc. on conditions. * src/pcl/slots.lisp (slot-value-using-class) (setf slot-boundp-using-class) <condition-class>: New methods. * src/pcl/std-class.lisp (initialize-internal-slot-functions): Use slot-name->class-table. (shared-initialize): Call update-pv-table-cache-info. (compute-slots) <around condition-class>: New method. * src/pcl/slots-boot.lisp (ensure-accessor): Use slot-name->class-table. (get-optimized-std-accessor-method-function) (get-optimized-std-slot-value-using-class-method-function): Handle condition classes. * src/pcl/methods.lisp (*condition-slot-value-using-class-method*) (*condition-setf-slot-value-using-class-method*) (*condition-slot-boundp-using-class-method*): New vars. (condition-svuc-method, set-condition-svuc-method): New functions. (update-std-or-str-methods): Handle conditions. * src/pcl/generic-functions.lisp (condition-class-p): New gf. * src/pcl/dfun.lisp (make-accessor-table): Use slot-name->class-table. * src/pcl/defs.lisp (*the-condition-class*): New var. (slot-name->class-table): New function. (condition): New class. (*early-class-predicates*): Add condition-class-p. * src/pcl/braid.lisp (bootstrap-meta-braid) (bootstrap-initialize-class): Add condition-class stuff. (bootstrap-make-slot-definitions): Simplified. (bootstrap-make-slot-definition): Use slot-name->class-table.
Code cleanup. Use EXTENSIONS package to reduce clutter. * src/pcl/defsys.lisp ("PCL", "WALKER"): Use ext. * src/pcl/pkg.lisp ("PCL", "WALKER"): Use ext. * src/pcl/*.lisp: Remove ext: prefixes. * src/pcl/low.lisp (symbolicate*): Renamed from symbolicate. * src/pcl/std-class.lisp (shared-initialize): * src/pcl/defs.lisp (get-built-in-class-symbol) (get-built-in-wrapper-symbol): * src/pcl/braid.lisp (initial-classes-and-wrappers) (bootstrap-meta-braid): Use symbolicate*. * src/pcl/macros.lisp (dolist-carefully): Removed. (true, false, zero): Moved to defclass.lisp. (printing-random-thing-internal): Removed. (printing-random-thing): Removed. (rassq): Removed. (*keyword-package*): Removed. (make-keyword): Removed; import from cl. (memq, delq, assq): Macros removed, import from ext. (get-declaration): Moved to boot.lisp, where it's used. * src/pcl/boot.lisp (get-declaration): Moved here from macros.lisp. * src/pcl/methods.lisp (named-object-print-function, print-object): * src/pcl/low.lisp (print-std-instance): * src/pcl/dfun.lisp (print-dfun-info): * src/pcl/cache.lisp (print-cache, print-wrapper): * src/pcl/boot.lisp (make-early-gf): Use print-unreadable-object instead of printing-random-thing. * src/pcl/defclass.lisp (true, false, zero): Moved here from macros.lisp. * src/pcl/methods.lisp (legal-qualifiers-p) (legal-specializers-p): Use dolist.
* src/pcl/dfun.lisp (saut-class-eq, saut-eql): Use cpl-or-nil instead of cpl-maybe-early.
* src-head/pcl/dfun.lisp (cache-miss-values-internal): Test for accessors. * src-head/pcl/rt/defmethod.lisp (defmethod-metacircle.0): New test. * src-head/pcl/rt/defgeneric.lisp (method-class.0): Call the method with the non-standard method class. * src-head/pcl/rt/pkg.lisp ("PCL-TEST"): Don't shadowing-import from PCL.
* src/pcl/dfun.lisp (cache-miss-values-internal): Push wrappers on *cmv-stack* instead of classes. * src/pcl/rt/defgeneric.lisp (method-class.0): New test. * src/pcl/gf-call-optimization.lisp (compute-calls): Simplify. * src/pcl/cache.lisp (probe-cache): Remove version in #+nil.
Break some vicious metacircles. * pcl/dfun.lisp (*standard-classes*, *standard-slot-locations*): New variables. (compute-standard-slot-locations, standard-slot-value) (standard-slot-value/gf, standard-slot-value/method) (standard-slot-value/eslotd, standard-slot-value/class) (maybe-update-standard-class-locations): New functions. (*cmv-stack*): New variable. (cache-miss-values-internal): Use it to detect vicious circles, and call break-vicious-metacircle. (break-vicious-metacircle, accesses-standard-class-slot-p) (find-standard-class-accessor-method): New functions. * pcl/std-class.lisp (update-slots): Call maybe-update-standard-class-locations. * pcl/fixup.lisp (toplevel): Call compute-standard-slot-locations.
* pcl/boot.lisp (parse-defmethod): Rewritten for clarity. Signal an error for most cases of null qualifiers. Improve DESCRIBE on generic functions. * pcl/env.lisp (method-specialized-lambda-list): New function. (describe-object): Use it, and use generic-function-lambda-list. * pcl/methods.lisp (generic-function-pretty-arglist) (method-pretty-arglist): Remove. * pcl/generic-functions.lisp (generic-function-pretty-arglist) (method-pretty-arglist): Remove. AMOP compliance fixes: Reintroduce class METAOBJECT, make GENERIC-FUNCTION a subclass of STANDARD-OBJECT, remove STD-OBJECT. This basically reverts a change of dtc from 1998. * code/describe.lisp (describe-instance): Check for standard-object, not pcl::std-object. * pcl/pkg.lisp ("PCL", "CLOS-MOP"): Export more stuff. * pcl/generic-functions.lisp: Remove some of the useless comments. * pcl/slots.lisp (slot-value-using-class, setf slot-value-using-class) (slot-boundp-using-class, slot-makunbound-using-class): Specialize on standard-object. * pcl/slots-boot.lisp (get-optimized-std-accessor-method-function): Remove an std-class-p case. * pcl/methods.lisp (update-std-or-str-methods): Use standard-object instead of std-object. (mec-all-classes-internal): Use *the-class-standard-object* instead of *the-class-std-object*. (class-test): Don't consider *the-class-std-object*. * pcl/low.lisp (pcl-instance-p) [deftransform]: Use standard-object instead of std-object. * pcl/init.lisp (update-instance-for-different-class) (update-instance-for-redefined-class): Specialize on standard-object instead of std-object. * pcl/dfun.lisp (accessor-values-internal, make-accessor-table) (make-accessor-table): Use *the-class-standard-object* instead of *the-class-std-object*. * pcl/defs.lisp (toplevel): Don't declare *the-class-std-object* special. (standard-object): Single superclass slot-object. (metaobject): New class. (std-object): Class removed. (specializer): Superclass metaobject. (definition-source-mixin, plist-mixin): Superclass standard-object, no metaclass. (documentation-mixin, dependent-update-mixin): No metaclass. (slot-definition, method, generic-function, method-combination): Superclass metaobject. * pcl/cache.lisp (raise-metatype): Don't consider std-class. * pcl/braid.lisp (bootstrap-meta-braid): Don't braid std-class. (bootstrap-initialize-class): Don't consider std-class.
* dfun.lisp (make-initial-dfun): Reactivate the call to precompute-effective-methods, because effective method computation detects methods with invalid qualifiers early. * methods.lisp (precompute-effective-methods): Reactivate.
* std-class.lisp (class-direct-slots, class-slots) (class-default-initargs, class-direct-default-initargs): Add methods for condition-class. * dfun.lisp (saut-class): Change a let to let*.
* bootfiles/18e/boot.lisp: Bootstrap files for the lisp:class = pcl:class part. To get it booted from 18e, cross-compile using boot1.lisp as bootstrap.lisp in pmai's build scripts, then do a normal compile with boot2.lisp as bootstrap.lisp with the resulting Lisp. * code/byte-interp.lisp, code/defstruct.lisp, code/describe.lisp: * code/error.lisp, code/exports.lisp, code/hash-new.lisp: * code/hash.lisp, code/macros.lisp, code/misc.lisp: * code/package.lisp, code/pred.lisp, code/sharpm.lisp, code/type.lisp: * compiler/dump.lisp, compiler/fndb.lisp, compiler/globaldb.lisp: * compiler/proclaim.lisp, compiler/typetran.lisp, compiler/xref.lisp: * compiler/generic/primtype.lisp, compiler/generic/vm-type.lisp: Changes for to use kernel::class etc. * code/class.lisp (toplevel): Shadow class, built-in-class etc. (class): Give it conc-name %class-. (toplevel) [#+bootstrap-lisp-class=pcl-class]: Define old accessors. (everywhere): Use new class accessors. * compiler/generic/vm-fndb.lisp (%make-instance): Change from unsafe to flushable and movable. * code/ntrace.lisp (expand-trace, untrace): Changes for method tracing. * code/profile.lisp (profile, profile-all, unprofile): Method profiling. * pcl/*.text, pcl/bench.lisp, pcl/extensions.lisp: * pcl/fast-init.lisp, pcl/precom1.lisp, pcl/precom4.lisp: * pcl/structure-class.lisp, pcl/user-instances.lisp: Removed. * tools/pclcom.lisp: Changes for my PCL and lisp:class = pcl::class.
(cpl-or-nil): New function. (saut-not-class, saut-not-prototype) (class-applicable-using-class-p, saut-class): Use it.
(*lazy-dfun-compute-p*): Remove. (finalize-specializers): New function. (make-initial-dfun): Call finalize-specializers. Don't call precompute-effective-methods.
*** empty log message ***
*** empty log message ***
Entomotomy Bug: pcl-gf-cache-cacheing-not-needed This commits a patch by Gerd Moellmann which elides the elaborate cacheing of GF caches, since modern GCs are usually better at handling this. Performance on x86 with generational GC seems unharmed by this, other ports using the non-generational GC will have to investigate. Should this turn up performance problems, the patch might get reverted.
Flushed the #+copy-&rest-arg controlled copying of rest arguments, since the code was both unused in CMUCL, and was erroneous in places, too. This brings us in line with SBCL which removed the code early on.
Removed the shadowed version of dotimes from PCL, replacing it with normal cl:dotimes, introducing explicit fixnum declarations where they weren't obviously unnecessary. Based on a patch by Gerd Moellmann.
Huge patch by Gerd Moellmann that removes PCL::ITERATE and PCL::GATHER* in favor of normal CL constructs. In a similar vein to SBCL, this patch also replaces all uses of #'(lambda ...) by just (lambda ...), and removes now-dated looking quotes in front of self-evaluating objects, like keywords and t/nil. The patch has been slightly frobbed by me, to correct a couple of slight oversights, and make more effective use of the loop facility in a number of places.
Mega commit to bring RELENG_18 branch in sync with HEAD in preparation for release tagging 18d.
Trivial spelling fix. From a patch by Eric Marsden.
Fixed bug reported by Marco Antoniotti in the call to no-applicable-method for generic functions with zero methods. Just removing the erroneous special-case call and letting the normal code path handle the situation fixes this.
From Pierre Mai: o All the stuff from cmu-low.lisp has been merged into low.lisp. o Therefore cmu-low.lisp has been removed completely. o All the stuff in low.lisp which either wasn't used in current PCL or was unnecessary in CMU CL, or which was implemented as no-ops for CMU CL has been removed. o Calls in other files to functions which were dropped have been removed. o Source order reorganised a bit and added several comments and doc-strings. o Made `*optimize-speed*' consistent for small and non-small cores, and fixed ordering problem. o Added `*compile-lambda-silent-p*' which when true (the default) will cause compile-lambda to be silent when compiling PCL-generated code.
This set of revisions brings the RELENG_18 branch up to HEAD in preparation for an 18c release.
Remove all #+ and #- conditionals from the source code. What is left is essentially Common Lisp except for explicit references to things in CMUCL specific packages.
Add CMUCL style file-comments; from Peter Van Eynde.
This (huge) revision brings the RELENG_18 branch up to the current HEAD. Note code/unix-glib2.lisp not yet included -- not sure it is ready to go.
Rework the PCL class hierarchy to better match the disjoint instance and funcallable-instance types within CMUCL. Add the new class funcallable-standard-object, and the new class std-object as a superclass of both standard-object and funcallable-standard-object. Generic-functions are now funcallable-standard-objects implemented as FINs and disjoint from standard-objects which are implemented as instances in CMUCL, fixing some problems in the type system. This change moves the PCL implementation away from the MOP specification which requires that generic-functions be standard-objects. However ANSI CL does not require generic functions to be standard-objects and the MOP author Gregor Kiczales suggests it is appropriate for generic functions to be disjoint from standard-objects.
Werkowskis source kit 1.03.7
Back out of part of supposed fix to get-secondary-dispatch-function1 for no-applicable-methods, since it seems to be breaking things.
In dispatch cost estimation, add special-case for structure typep and fill in some guesses for CMU costs.
Arg is GF, not generic-function in use-dispatch-dfun.
New parameterized version of use-dispatch-dfun-p from Harris.
Fix to :after methods on accessor functions. Also, fixed some problems with the result of get-secondary-dispatch-function1 when there are no methods.
In USE-DISPATCH-DFUN-P don't treat built-in classes any different for cmu17.
Richard Harris' fix to allow for very big dispatch functions replaces USE-DISPATCH-DEFUN-P with three functions: USE-DISPATCH-DFUN-P, SIMPLE-DISPATCH-FUNCTION-P, and DISPATCH-FUNCTION-CLASS-TYPEP-COUNT. The problem arose when a generic function had some 10 primary and additional before methods.
Freeze-type dfun-info. Use instance-lambda for funcallable instance functions. Changed some uses of (or std-instance-p fsc-instance-p) to pcl-instance-p.
September-16-92-PCL-e has been incorporated into the CMUCL sources thanks to Rick Harris.
This is is March-92-PCL 2c
This is September 92 PCL.
This is July 92 PCL
This is March-92-PCL-2a.
Merged with latest PCL version.
*** empty log message ***
This form allows you to request diffs between any two revisions of this file. For each of the two "sides" of the diff, select a symbolic revision name using the selection box, or choose 'Use Text Field' and enter a numeric revision.
|Powered by ViewVC 1.1.5|