Instead, there's now a separate property for each kind of metaobject.
The reason is that some declarations can produce two metaobjects, e.g.,
a message declaration might also include a direct method, and we can't
possibly use the same metaobject class for both. To resolve this, we
use different properties to name the different metaobject classes.
* For classes, we use `:lisp-metaclass' (to distinguish from a runtime
metaclass).
* For messages, `:message-class'.
* For methods, `:method-class'.
* For slots, `:slot-class'.
* For slot initializers, `:initializer-class'.
* For modules, `:module-class'.
',name
(lambda (,classvar)
(make-sod-slot ,classvar ,name (c-type ,type)
',name
(lambda (,classvar)
(make-sod-slot ,classvar ,name (c-type ,type)
- (make-property-set :lisp-class 'sod-class-slot
+ (make-property-set :slot-class 'sod-class-slot
:initializer-function
(lambda (,class)
,init)
:initializer-function
(lambda (,class)
,init)
(defmethod make-sod-slot
((class sod-class) name type pset &optional location)
(with-default-error-location (location)
(defmethod make-sod-slot
((class sod-class) name type pset &optional location)
(with-default-error-location (location)
- (let ((slot (make-instance (get-property pset :lisp-class :symbol
+ (let ((slot (make-instance (get-property pset :slot-class :symbol
'sod-slot)
:class class
:name name
'sod-slot)
:class class
:name name
(defmethod make-sod-initializer-using-slot
((class sod-class) (slot sod-slot)
init-class value-kind value-form pset location)
(defmethod make-sod-initializer-using-slot
((class sod-class) (slot sod-slot)
init-class value-kind value-form pset location)
- (make-instance (get-property pset :lisp-class :symbol init-class)
+ (make-instance (get-property pset :initializer-class :symbol init-class)
:class class
:slot slot
:value-kind value-kind
:class class
:slot slot
:value-kind value-kind
(defmethod make-sod-message
((class sod-class) name type pset &optional location)
(with-default-error-location (location)
(defmethod make-sod-message
((class sod-class) name type pset &optional location)
(with-default-error-location (location)
- (let ((message (make-instance (get-property pset :lisp-class :symbol
+ (let ((message (make-instance (get-property pset :message-class :symbol
'standard-message)
:class class
:name name
'standard-message)
:class class
:name name
(defmethod make-sod-method-using-message
((message sod-message) (class sod-class) type body pset location)
(defmethod make-sod-method-using-message
((message sod-message) (class sod-class) type body pset location)
- (make-instance (or (get-property pset :lisp-class :symbol)
+ (make-instance (or (get-property pset :method-class :symbol)
(sod-message-method-class message class pset))
:message message
:class class
(sod-message-method-class message class pset))
:message message
:class class
"Construct and return a new SOD class with the given NAME and SUPERCLASSES.
This is the main constructor function for classes. The protocol works as
"Construct and return a new SOD class with the given NAME and SUPERCLASSES.
This is the main constructor function for classes. The protocol works as
- follows. The `:lisp-class' property in PSET is checked: if it exists, it
- must be a symbol naming a (CLOS) class, which is used in place of
+ follows. The `:lisp-metaclass' property in PSET is checked: if it exists,
+ it must be a symbol naming a (CLOS) class, which is used in place of
`sod-class'. All of the arguments are then passed to `make-instance';
further behaviour is left to the standard CLOS instance construction
protocol; for example, `sod-class' defines an `:after'-method on
`sod-class'. All of the arguments are then passed to `make-instance';
further behaviour is left to the standard CLOS instance construction
protocol; for example, `sod-class' defines an `:after'-method on
(with-default-error-location (location)
(let* ((pset (property-set pset))
(with-default-error-location (location)
(let* ((pset (property-set pset))
- (class (make-instance (get-property pset :lisp-class :symbol
+ (class (make-instance (get-property pset :lisp-metaclass :symbol
'sod-class)
:name name
:superclasses superclasses
'sod-class)
:name name
:superclasses superclasses
This is the main constructor function for slots. This is a generic
function primarily so that the CLASS can intervene in the construction
This is the main constructor function for slots. This is a generic
function primarily so that the CLASS can intervene in the construction
- process. The default method uses the `:lisp-class' property (defaulting
+ process. The default method uses the `:slot-class' property (defaulting
to `sod-slot') to choose a (CLOS) class to instantiate. The slot is then
constructed by `make-instance' passing the arguments as initargs; further
behaviour is left to the standard CLOS instance construction protocol; for
to `sod-slot') to choose a (CLOS) class to instantiate. The slot is then
constructed by `make-instance' passing the arguments as initargs; further
behaviour is left to the standard CLOS instance construction protocol; for
This generic function does the common work for constructing instance and
class initializers. It can usefully be specialized according to both the
This generic function does the common work for constructing instance and
class initializers. It can usefully be specialized according to both the
- class and slot types. The default method uses the `:lisp-class' property
- (defaulting to INIT-CLASS) to choose a (CLOS) class to instantiate. The
- slot is then constructed by `make-instance' passing the arguments as
- initargs; further behaviour is left to the standard CLOS instance
- construction protocol; for example, `sod-initializer' defines an
+ class and slot types. The default method uses the `:initializer-class'
+ property (defaulting to INIT-CLASS) to choose a (CLOS) class to
+ instantiate. The slot is then constructed by `make-instance' passing the
+ arguments as initargs; further behaviour is left to the standard CLOS
+ instance construction protocol; for example, `sod-initializer' defines an
`:after'-method on `shared-initialize'.
Diagnosing unused properties is left for the caller (usually
`:after'-method on `shared-initialize'.
Diagnosing unused properties is left for the caller (usually
This is the main constructor function for messages. This is a generic
function primarily so that the CLASS can intervene in the construction
This is the main constructor function for messages. This is a generic
function primarily so that the CLASS can intervene in the construction
- process. The default method uses the `:lisp-class' property (defaulting
- to `sod-message') to choose a (CLOS) class to instantiate. The message is
- then constructed by `make-instance' passing the arguments as initargs;
- further behaviour is left to the standard CLOS instance construction
- protocol; for example, `sod-message' defines an `:after'-method on
- `shared-initialize'."))
+ process. The default method uses the `:message-class' property
+ (defaulting to `sod-message') to choose a (CLOS) class to instantiate.
+ The message is then constructed by `make-instance' passing the arguments
+ as initargs; further behaviour is left to the standard CLOS instance
+ construction protocol; for example, `sod-message' defines an
+ `:after'-method on `shared-initialize'."))
(export 'make-sod-method)
(defgeneric make-sod-method
(export 'make-sod-method)
(defgeneric make-sod-method
This is a generic function so that it can be specialized according to both
a class and -- more particularly -- a message. The default method uses
This is a generic function so that it can be specialized according to both
a class and -- more particularly -- a message. The default method uses
- the `:lisp-class' property (defaulting to the result of calling
+ the `:method-class' property (defaulting to the result of calling
`sod-message-method-class') to choose a (CLOS) class to instantiate. The
method is then constructed by `make-instance' passing the arguments as
initargs; further behaviour is left to the standard CLOS instance
`sod-message-method-class') to choose a (CLOS) class to instantiate. The
method is then constructed by `make-instance' passing the arguments as
initargs; further behaviour is left to the standard CLOS instance
"Return the preferred class for methods on MESSAGE.
The message can inspect the PSET to decide on a particular message. A
"Return the preferred class for methods on MESSAGE.
The message can inspect the PSET to decide on a particular message. A
- `:lisp-class' property will usually override this decision: it's then the
- programmer's responsibility to ensure that the selected method class is
- appropriate."))
+ `:method-class' property will usually override this decision: it's then
+ the programmer's responsibility to ensure that the selected method class
+ is appropriate."))
(export 'check-message-type)
(defgeneric check-message-type (message type)
(export 'check-message-type)
(defgeneric check-message-type (message type)
(defmethod finalize-module ((module module))
(let* ((pset (module-pset module))
(defmethod finalize-module ((module module))
(let* ((pset (module-pset module))
- (class (get-property pset :lisp-class :symbol 'module)))
+ (class (get-property pset :module-class :symbol 'module)))
;; Always call `change-class', even if it's the same one; this will
;; exercise the property-set fiddling in `shared-initialize' and we can
;; Always call `change-class', even if it's the same one; this will
;; exercise the property-set fiddling in `shared-initialize' and we can
During module construction, this is always an instance of `module'. Once
we've finished constructing it, we'll call `change-class' to turn it into
During module construction, this is always an instance of `module'. Once
we've finished constructing it, we'll call `change-class' to turn it into
- an instance of whatever type is requested in the module's `:lisp-class'
+ an instance of whatever type is requested in the module's `:module-class'
property.")
(export 'module-import)
property.")
(export 'module-import)
This isn't necessary if you made the module by hand. If you've
constructed it incrementally, then it might be a good plan. In
particular, it will change the class (using `change-class') of the module
This isn't necessary if you made the module by hand. If you've
constructed it incrementally, then it might be a good plan. In
particular, it will change the class (using `change-class') of the module
- according to the class choice set in the module's `:lisp-class' property.
- This has the side effects of calling `shared-initialize', setting the
- module's state to `t', and checking for unrecognized
+ according to the class choice set in the module's `:module-class'
+ property. This has the side effects of calling `shared-initialize',
+ setting the module's state to `t', and checking for unrecognized
properties. (Therefore subclasses should add a method to
`shared-initialize' taking care of looking at interesting properties, just
to make sure they're ticked off.)"))
properties. (Therefore subclasses should add a method to
`shared-initialize' taking care of looking at interesting properties, just
to make sure they're ticked off.)"))
~mdw / sod / commitdiff