[Bese-devel] LispWorks and UCW

[Friedrich Dominicus]

sorry, for bothering you with this. I had to tweak the mopp.lisp file,
and am now not sure if it's a bug with LispWorks or with the given
code.

As I understand all the symbols needed for portable MOP should get
imported with 
(defmethod provide-mopp-symbol ((symbol symbol) (implementation (eql :lispworks)))
  (when (find-symbol (string symbol) :clos)
    (import-to-mopp (find-symbol (string symbol) :clos))))


Now it happens that this has failed for some symbols, but I suppose
that should not have happened. I know that the following is just a
hackerish solution to the problem:

(eval-when (:compile-toplevel :execute)
  (defclass %meta-class (standard-class) ())
  #-LispWorks
  (defmethod mopp:validate-superclass ((c %meta-class) (s mopp:standard-class)) t)
  #+Lispworks
  (defmethod mopp:validate-superclass ((c %meta-class) (s clos::standard-class)) t)
  #-LispWorks
  (defclass %dsd (mopp:standard-direct-slot-definition)
    ((%slot :accessor %slot :initarg :%slot :initform nil)))
    #+LispWorks
    (defclass %dsd (clos::standard-direct-slot-definition)
      ((%slot :accessor %slot :initarg :%slot :initform nil)))
    

  (defmethod mopp:direct-slot-definition-class ((c %meta-class) &rest initargs)
    (declare (ignore c initargs))
    (find-class '%dsd))

  (defclass %class ()
    ((a-slot :%slot 1))
    (:metaclass %meta-class))

  (let ((definition (if (consp (%slot (find-if (lambda (s)
						 (eql 'a-slot 
                                                      #-LispWorks
                                                      (mopp:slot-definition-name s)
                                                      #+LispWorks
                                                      (clos:slot-definition-name s)
                                                      ))
                                               #-LispWorks
                                               (mopp:class-direct-slots (find-class '%class))
                                               #+LispWorks
                                               (clos:class-direct-slots (find-class '%class))
                                               )))
			(lambda (slot-value) (first slot-value))
			(lambda (slot-value) slot-value))))


but with that I got UCW compiled and running with LispWorks. I'm quite
sure that this is not the "right" solution to the problem. Maybe
someone here has a better suggestion.

I still have some problems understanding UCW. Mostly how the parts
should play together. The relationship between application, component,
sub-components etc is not clear to me. 

I do not understand what slime is used for, I guess it's to see the
error messages. Is this a correct?

And well there is a thing I do  not like. The use of links for
starting actions. I would think for that buttons are the "right"
choice. Now I read someone has hacked around ucw:button? 

Would this someone explain what he has to done to implement that?

Regards
Friedrich