Opened 7 years ago

Closed 7 years ago

Last modified 5 years ago

#1225 closed defect (fixed)

While disassembling a gf using objc: Can't use #<error printing ccl::immediate #x12> as a hash-table key

Reported by: informatimago Owned by:
Priority: normal Milestone:
Component: other Version: 1.9
Keywords: Cc:

Description (last modified by gb)

ui> (pprint (swank::macroexpand-all '(defgeneric call-with-focused-view (view function &optional font-view)
                               ;; Note: be careful to return the FUNCTION results in all cases.
                               (:method ((view simple-view) function &optional (font-view view))
                                 (labels ((call-it ()
                                            (call-with-pen-state (lambda () (funcall function view))
                                                                 (view-pen view)))
                                          (call-it/trans ()
                                            (let* ((window (view-window view))
                                                   (wtrans (window-affine-transform window))
                                                   (vtrans (make-affine-transform))
                                                   (origin (convert-coordinates #@(0 0) view window)))
                                              [wtrans set]
                                              [vtrans translateXBy:(cgfloat 0.0) yBy:(cgfloat (point-v (view-size (view-window view))))]
                                              [vtrans scaleXBy:(cgfloat 1.0) yBy:(cgfloat -1.0)]
                                              [vtrans translateXBy:(cgfloat (point-h origin)) yBy:(cgfloat (point-v origin))]
                                              [vtrans concat]
                                              [vtrans release]
                                              ;; (setf *trace-output* cl-user::*to*)
                                              #+debug-views (format-trace 'call-with-focused-view (list (class-name (class-of view))
                                                                                                        :origin (point-to-list origin)
                                                                                                        :frame (rect-to-list (view-frame view))
                                                                                                        :bounds (rect-to-list (view-bounds view)))
                                                                          :ctm (get-ctm window))
                                              (unwind-protect
                                                   (call-it)
                                                [wtrans set]))))
                                   (declare (inline call-it call-it/trans))
                                   (if (eql *current-view* view)
                                       (if (eql *current-font-view* font-view)
                                           (let ((*current-view* view)
                                                 (*current-font-view*  font-view)
                                                 (*current-font-codes* (copy-list *current-font-codes*)))
                                             (call-it))
                                           (unwind-protect
                                                (let* ((*current-view* view)
                                                       (*current-font-view*  font-view)
                                                       (*current-font-codes* (set-font *current-font-view*))) ; change font
                                                  (call-it))
                                             (set-font *current-font-view*))) ; revert font
                                       (with-view-handle (winh view)
                                         (let ((unlock   nil))
                                           (unwind-protect
                                                (let ((*current-view* view)
                                                      (*current-font-view* font-view)
                                                      (*current-font-codes* (copy-list *current-font-codes*)))
                                                  (when (setf unlock [winh lockFocusIfCanDraw])
                                                    (focus-view *current-view* *current-font-view*)
                                                    (apply (function set-current-font-codes) (set-font *current-font-view*))
                                                    (call-it/trans)))
                                             [[NSGraphicsContext currentContext] flushGraphics]
                                             (when unlock
                                               (set-font *current-font-view*)
                                               [winh unlockFocus])
                                             (focus-view *current-view* *current-font-view*))))))))))

(progn (closer-mop::maybe-remove-initial-methods 'call-with-focused-view)
       (progn (eval-when (:compile-toplevel)
                (progn (eval-when #2=(:compile-toplevel)
                         (ccl::record-function-info
                           'call-with-focused-view
                           '#(134218244 nil nil (:methods))
                           #3=#<ccl::lexical-environment #x3020065FEB2D>))
                       (let ((#1=#:g50952
                              (ccl::%defgeneric 'call-with-focused-view
                                                '#4=(view function &optional font-view)
                                                '#5=(standard)
                                                'common-lisp:standard-generic-function
                                                'nil)))
                         (ccl::%set-defgeneric-methods #1#)
                         #1#)))
              (eval-when (:load-toplevel :execute)
                (progn (progn (eval-when #2#
                                (ccl::record-function-info
                                  'call-with-focused-view
                                  '#(134218244 nil nil (:methods))
                                  #3#))
                              (let ((#6=#:g50953
                                     (ccl::%defgeneric 'call-with-focused-view
                                                       '#4#
                                                       '#5#
                                                       'common-lisp:standard-generic-function
                                                       'nil)))
                                (ccl::%set-defgeneric-methods
                                  #6#
                                  (progn (eval-when (:compile-toplevel)
                                           (ccl::record-function-info
                                             'call-with-focused-view
                                             '#(16900 nil nil (:methods ((nil) nil simple-view t)))
                                             #3#))
                                         (ccl:compiler-let ((ccl::*nx-method-warning-name*
                                                             '(call-with-focused-view (simple-view t))))
                                           (let* ((#19=#:g50954
                                                   (ccl::ensure-method
                                                     'call-with-focused-view
                                                     (list 'simple-view t)
                                                     :function
                                                     (ccl:nfunction call-with-focused-view
                                                                    lambda
                                                                    (ccl::&method #8=#:next-method-context
                                                                     . #18=(view
                                                                            function
                                                                            &optional
                                                                            (font-view view)))
                                                                    (declare (ignorable view))
                                                                    (block call-with-focused-view
                                                                      (flet
                                                                       ((call-next-method
                                                                         (&rest #7=#:g50955)
                                                                         (declare (dynamic-extent #7#))
                                                                         (if
                                                                          #7#
                                                                          (apply
                                                                           #'ccl::%call-next-method-with-args
                                                                           #8#
                                                                           #7#)
                                                                          (ccl::%call-next-method #8#)))
                                                                        (next-method-p
                                                                         nil
                                                                         (ccl::%next-method-p #8#)))
                                                                       (declare
                                                                        (inline
                                                                         call-next-method
                                                                         next-method-p))
                                                                       (declare
                                                                        (ftype
                                                                         #'(&rest t)
                                                                         call-with-focused-view))
                                                                       (labels
                                                                        ((call-it
                                                                          nil
                                                                          (call-with-pen-state
                                                                           (lambda
                                                                            nil
                                                                            (funcall function view))
                                                                           (view-pen view)))
                                                                         (call-it/trans
                                                                          nil
                                                                          (let*
                                                                           ((window (view-window view))
                                                                            (wtrans
                                                                             (window-affine-transform
                                                                              window))
                                                                            (vtrans (make-affine-transform))
                                                                            (origin
                                                                             (convert-coordinates
                                                                              0
                                                                              view
                                                                              window)))
                                                                           (progn
                                                                            (let*
                                                                             ()
                                                                             (declare (dynamic-extent))
                                                                             (declare (type ccl:macptr))
                                                                             (declare (ccl::unsettable))
                                                                             (let*
                                                                              ((#9=#:g50956 wtrans))
                                                                              (if
                                                                               (let
                                                                                ((#10=#:g50959
                                                                                  (typep #9# 'ns:+ns-set)))
                                                                                (if
                                                                                 #10#
                                                                                 #10#
                                                                                 (typep
                                                                                  #9#
                                                                                  'ns:ns-ordered-set)))
                                                                               (progn
                                                                                (ccl:%ff-call
                                                                                 (ccl:%reference-external-entry-point
                                                                                  (load-time-value
                                                                                   (ccl::load-eep
                                                                                    #11="objc_msgSend")))
                                                                                 :address
                                                                                 #9#
                                                                                 :address
                                                                                 (ccl::%get-selector
                                                                                  #12=#S(ccl::objc-selector :name "set"
                                                                                                            :%sel #<ns-number -120 (#x7FFF8D318807)>))
                                                                                 :address))
                                                                               (if
                                                                                t
                                                                                (progn
                                                                                 (ccl:%ff-call
                                                                                  (ccl:%reference-external-entry-point
                                                                                   (load-time-value
                                                                                    (ccl::load-eep #11#)))
                                                                                  :address
                                                                                  #9#
                                                                                  :address
                                                                                  (ccl::%get-selector #12#)
                                                                                  :void))
                                                                                nil)))))
                                                                           (progn
                                                                            (let*
                                                                             ()
                                                                             (declare (dynamic-extent))
                                                                             (declare (type ccl:macptr))
                                                                             (declare (ccl::unsettable))
                                                                             (ccl:%ff-call
                                                                              (ccl:%reference-external-entry-point
                                                                               (load-time-value
                                                                                (ccl::load-eep #11#)))
                                                                              :address
                                                                              vtrans
                                                                              :address
                                                                              (ccl::%get-selector
                                                                               #13=#S(ccl::objc-selector :name "translateXBy:yBy:"
                                                                                                         :%sel #<A Foreign Pointer #x7FFF8D3269F3>))
                                                                              :double-float
                                                                              (cgfloat 0.0)
                                                                              :double-float
                                                                              (cgfloat
                                                                               (point-v
                                                                                (view-size
                                                                                 (view-window view))))
                                                                              :void)))
                                                                           (progn
                                                                            (let*
                                                                             ()
                                                                             (declare (dynamic-extent))
                                                                             (declare (type ccl:macptr))
                                                                             (declare (ccl::unsettable))
                                                                             (ccl:%ff-call
                                                                              (ccl:%reference-external-entry-point
                                                                               (load-time-value
                                                                                (ccl::load-eep #11#)))
                                                                              :address
                                                                              vtrans
                                                                              :address
                                                                              (ccl::%get-selector
                                                                               #S(ccl::objc-selector :name "scaleXBy:yBy:"
                                                                                                     :%sel #<A Foreign Pointer #x7FFF8D326A05>))
                                                                              :double-float
                                                                              (cgfloat 1.0)
                                                                              :double-float
                                                                              (cgfloat -1.0)
                                                                              :void)))
                                                                           (progn
                                                                            (let*
                                                                             ()
                                                                             (declare (dynamic-extent))
                                                                             (declare (type ccl:macptr))
                                                                             (declare (ccl::unsettable))
                                                                             (ccl:%ff-call
                                                                              (ccl:%reference-external-entry-point
                                                                               (load-time-value
                                                                                (ccl::load-eep #11#)))
                                                                              :address
                                                                              vtrans
                                                                              :address
                                                                              (ccl::%get-selector #13#)
                                                                              :double-float
                                                                              (cgfloat (point-h origin))
                                                                              :double-float
                                                                              (cgfloat (point-v origin))
                                                                              :void)))
                                                                           (progn
                                                                            (let*
                                                                             ()
                                                                             (declare (dynamic-extent))
                                                                             (declare (type ccl:macptr))
                                                                             (declare (ccl::unsettable))
                                                                             (ccl:%ff-call
                                                                              (ccl:%reference-external-entry-point
                                                                               (load-time-value
                                                                                (ccl::load-eep #11#)))
                                                                              :address
                                                                              vtrans
                                                                              :address
                                                                              (ccl::%get-selector
                                                                               #S(ccl::objc-selector :name "concat"
                                                                                                     :%sel #<A Foreign Pointer #x7FFF8D31B17A>))
                                                                              :void)))
                                                                           (progn
                                                                            (let*
                                                                             ()
                                                                             (declare (dynamic-extent))
                                                                             (declare (type ccl:macptr))
                                                                             (declare (ccl::unsettable))
                                                                             (ccl:%ff-call
                                                                              (ccl:%reference-external-entry-point
                                                                               (load-time-value
                                                                                (ccl::load-eep #11#)))
                                                                              :address
                                                                              vtrans
                                                                              :address
                                                                              (ccl::%get-selector
                                                                               #S(ccl::objc-selector :name "release"
                                                                                                     :%sel #<A Foreign Pointer #x7FFF8D316666>))
                                                                              :void)))
                                                                           (unwind-protect
                                                                            (call-it)
                                                                            (progn
                                                                             (let*
                                                                              ()
                                                                              (declare (dynamic-extent))
                                                                              (declare (type ccl:macptr))
                                                                              (declare (ccl::unsettable))
                                                                              (let*
                                                                               ((#14=#:g50966 wtrans))
                                                                               (if
                                                                                (let
                                                                                 ((#15=#:g50969
                                                                                   (typep #14# 'ns:+ns-set)))
                                                                                 (if
                                                                                  #15#
                                                                                  #15#
                                                                                  (typep
                                                                                   #14#
                                                                                   'ns:ns-ordered-set)))
                                                                                (progn
                                                                                 (ccl:%ff-call
                                                                                  (ccl:%reference-external-entry-point
                                                                                   (load-time-value
                                                                                    (ccl::load-eep #11#)))
                                                                                  :address
                                                                                  #14#
                                                                                  :address
                                                                                  (ccl::%get-selector #12#)
                                                                                  :address))
                                                                                (if
                                                                                 t
                                                                                 (progn
                                                                                  (ccl:%ff-call
                                                                                   (ccl:%reference-external-entry-point
                                                                                    (load-time-value
                                                                                     (ccl::load-eep #11#)))
                                                                                   :address
                                                                                   #14#
                                                                                   :address
                                                                                   (ccl::%get-selector #12#)
                                                                                   :void))
                                                                                 nil)))))))))
                                                                        (declare
                                                                         (inline call-it call-it/trans))
                                                                        (if
                                                                         (eql *current-view* view)
                                                                         (if
                                                                          (eql *current-font-view* font-view)
                                                                          (let
                                                                           ((*current-view* view)
                                                                            (*current-font-view* font-view)
                                                                            (*current-font-codes*
                                                                             (copy-list
                                                                              *current-font-codes*)))
                                                                           (call-it))
                                                                          (unwind-protect
                                                                           (let*
                                                                            ((*current-view* view)
                                                                             (*current-font-view* font-view)
                                                                             (*current-font-codes*
                                                                              (set-font
                                                                               *current-font-view*)))
                                                                            (call-it))
                                                                           (set-font *current-font-view*)))
                                                                         (let*
                                                                          ((#16=#:g50970 view)
                                                                           (#17=#:g50971
                                                                            (handle
                                                                             (if
                                                                              (typep #16# 'window)
                                                                              #16#
                                                                              (view-window #16#)))))
                                                                          (if
                                                                           #17#
                                                                           (progn
                                                                            (let
                                                                             ((winh
                                                                               (progn
                                                                                (let*
                                                                                 ()
                                                                                 (declare (dynamic-extent))
                                                                                 (declare (type ccl:macptr))
                                                                                 (declare (ccl::unsettable))
                                                                                 (ccl:%ff-call
                                                                                  (ccl:%reference-external-entry-point
                                                                                   (load-time-value
                                                                                    (ccl::load-eep #11#)))
                                                                                  :address
                                                                                  #17#
                                                                                  :address
                                                                                  (ccl::%get-selector
                                                                                   #S(ccl::objc-selector :name "contentView"
                                                                                                         :%sel #<A Foreign Pointer #x7FFF8D31B1C5>))
                                                                                  :address)))))
                                                                             (let
                                                                              ((unlock nil))
                                                                              (unwind-protect
                                                                               (let
                                                                                ((*current-view* view)
                                                                                 (*current-font-view*
                                                                                  font-view)
                                                                                 (*current-font-codes*
                                                                                  (copy-list
                                                                                   *current-font-codes*)))
                                                                                (if
                                                                                 (setq
                                                                                  unlock
                                                                                  (progn
                                                                                   (let*
                                                                                    ()
                                                                                    (declare
                                                                                     (dynamic-extent))
                                                                                    (declare
                                                                                     (type ccl:macptr))
                                                                                    (declare
                                                                                     (ccl::unsettable))
                                                                                    (ccl::coerce-from-bool
                                                                                     (ccl:%ff-call
                                                                                      (ccl:%reference-external-entry-point
                                                                                       (load-time-value
                                                                                        (ccl::load-eep
                                                                                         #11#)))
                                                                                      :address
                                                                                      winh
                                                                                      :address
                                                                                      (ccl::%get-selector
                                                                                       #S(ccl::objc-selector :name "lockFocusIfCanDraw"
                                                                                                             :%sel #<ns-date 2001-01-01 00:00:00 +0000 (#x7FFF8D330CFD)>))
                                                                                      :signed-byte)))))
                                                                                 (progn
                                                                                  (focus-view
                                                                                   *current-view*
                                                                                   *current-font-view*)
                                                                                  (apply
                                                                                   #'set-current-font-codes
                                                                                   (set-font
                                                                                    *current-font-view*))
                                                                                  (call-it/trans))))
                                                                               (progn
                                                                                (let*
                                                                                 ()
                                                                                 (declare (dynamic-extent))
                                                                                 (declare (type ccl:macptr))
                                                                                 (declare (ccl::unsettable))
                                                                                 (ccl:%ff-call
                                                                                  (ccl:%reference-external-entry-point
                                                                                   (load-time-value
                                                                                    (ccl::load-eep #11#)))
                                                                                  :address
                                                                                  (progn
                                                                                   (let*
                                                                                    ()
                                                                                    (declare
                                                                                     (dynamic-extent))
                                                                                    (declare
                                                                                     (type ccl:macptr))
                                                                                    (declare
                                                                                     (ccl::unsettable))
                                                                                    (ccl:%ff-call
                                                                                     (ccl:%reference-external-entry-point
                                                                                      (load-time-value
                                                                                       (ccl::load-eep #11#)))
                                                                                     :address
                                                                                     ns:ns-graphics-context
                                                                                     :address
                                                                                     (ccl::%get-selector
                                                                                      #S(ccl::objc-selector :name "currentContext"
                                                                                                            :%sel #<A Foreign Pointer #x7FFF8D31B156>))
                                                                                     :address)))
                                                                                  :address
                                                                                  (ccl::%get-selector
                                                                                   #S(ccl::objc-selector :name "flushGraphics"
                                                                                                         :%sel #<A Foreign Pointer #x7FFF8D3330C6>))
                                                                                  :void)))
                                                                               (if
                                                                                unlock
                                                                                (progn
                                                                                 (set-font
                                                                                  *current-font-view*)
                                                                                 (progn
                                                                                  (let*
                                                                                   ()
                                                                                   (declare (dynamic-extent))
                                                                                   (declare
                                                                                    (type ccl:macptr))
                                                                                   (declare
                                                                                    (ccl::unsettable))
                                                                                   (ccl:%ff-call
                                                                                    (ccl:%reference-external-entry-point
                                                                                     (load-time-value
                                                                                      (ccl::load-eep #11#)))
                                                                                    :address
                                                                                    winh
                                                                                    :address
                                                                                    (ccl::%get-selector
                                                                                     #S(ccl::objc-selector :name "unlockFocus"
                                                                                                           :%sel #<A Foreign Pointer #x7FFF8D31886B>))
                                                                                    :void)))))
                                                                               (focus-view
                                                                                *current-view*
                                                                                *current-font-view*))))))))))))
                                                     :qualifiers
                                                     'nil
                                                     :lambda-list
                                                     '#18#)))
                                             (ccl:record-source-file #19# 'method)
                                             #19#))))
                                #6#)))))
       (let ((#20=#:gf (fdefinition 'call-with-focused-view))) nil #20#))
; No value
ui> (disassemble (function call-with-focused-view))
L0
         (leaq (@ (:^ L0) (% rip)) (% fn))       ;     [0]
         (movq (@ (% rsp)) (% temp2))            ;     [7]
         (movl (% nargs) (% imm0.l))             ;    [11]
         (subq ($ 24) (% imm0))                  ;    [13]
         (jle L34)                               ;    [17]
         (movq (% rbp) (@ 8 (% rsp) (% imm0)))   ;    [19]
         (leaq (@ 8 (% rsp) (% imm0)) (% rbp))   ;    [24]
         (popq (@ 8 (% rbp)))                    ;    [29]
         (jmp L38)                               ;    [32]
L34
         (pushq (% rbp))                         ;    [34]
         (movq (% rsp) (% rbp))                  ;    [35]
L38
         (testl (% nargs) (% nargs))             ;    [38]
         (je L53)                                ;    [40]
         (cmpl ($ 16) (% nargs))                 ;    [42]
         (je L51)                                ;    [45]
         (jb L52)                                ;    [47]
         (pushq (% arg_x))                       ;    [49]
L51
         (pushq (% arg_y))                       ;    [51]
L52
         (pushq (% arg_z))                       ;    [52]
L53
         (pushq (% imm2))                        ;    [53]
         (movq (% rsp) (% arg_z))                ;    [54]
         (movl (@ #x12FB8) (% imm0.l))           ;    [57]
         (cmpq (% temp2) (% imm0))               ;    [64]
         (je L79)                                ;    [67]
         (movl (@ #x12F08) (% temp2.l))          ;    [69]
         (jmp L89)                               ;    [77]
L79
         (pushq (@ #x12F10))                     ;    [79]
         (movq (% imm0) (% temp2))               ;    [86]
L89
         (pushq (% temp2))                       ;    [89]
         (movq (@ 
> Debug: Can't use #<error printing ccl::immediate #x12> as a hash-table key
> While executing: (:internal swank::invoke-default-debugger), in process repl-thread(14).
> Type cmd-. to abort, cmd-\ for a list of available restarts.
> Type :? for other options.
1 > :q
; Evaluation aborted on #<simple-error #x3020064EC22D>.
ui> 

cl-user> (cl-user::print-bug-report-info)


LISP-IMPLEMENTATION-TYPE     "Clozure Common Lisp"
LISP-IMPLEMENTATION-VERSION  "Version 1.9  (Darwinx8664)"
SOFTWARE-TYPE                "Darwin"
SOFTWARE-VERSION             "13.3.0"
MACHINE-INSTANCE             "larissa.local"
MACHINE-TYPE                 "x86_64"
MACHINE-VERSION              "MacBookAir6,2"
*FEATURES*                   (:bordeaux-threads :thread-support :objc-support :cocoa-10.9 :cocoa-10.8 :cocoa-10.7 :cocoa-10.6 :cocoa-10.5 :cocoa-10.4 :cocoa :hemlock :apple-objc-2.0 :apple-objc patchwork.builder::use-cl-midi cffi-features:flat-namespace cffi-features:x86-64 cffi-features:unix cffi-features:darwin :cffi cffi-sys::flat-namespace :bsd :little-endian :swank :com.informatimago.pjb :split-sequence :closer-mop :com.informatimago.common-lisp.lisp.cl-stepper :newline-is-linefeed :has-ascii-code :has-vt :has-bell :has-escape :has-linefeed :has-return :has-backspace :has-tab :has-page :has-rubout :quicklisp :asdf3 :asdf2 :asdf :os-unix :asdf-unicode :primary-classes :common-lisp :openmcl :ccl :ccl-1.2 :ccl-1.3 :ccl-1.4 :ccl-1.5 :ccl-1.6 :ccl-1.7 :ccl-1.8 :ccl-1.9 :clozure :clozure-common-lisp :ansi-cl :unix :openmcl-unicode-strings :openmcl-native-threads :openmcl-partial-mop :mcl-common-mop-subset :openmcl-mop-2 :openmcl-private-hash-tables :x86-64 :x86_64 :x86-target :x86-host :x8664-target :x8664-host :darwin-host :darwin-target :darwinx86-target :darwinx8664-target :darwinx8664-host :64-bit-target :64-bit-host :darwin :little-endian-target :little-endian-host)


; No value
cl-user> 

Change History (7)

comment:1 Changed 7 years ago by gb

  • Description modified (diff)
  • Resolution set to notabug
  • Status changed from new to closed

Nothing in CCL tries to add printed objects (output from the disassembler or other) as keys to any hash table; whether or not some SLIME package does so or not, I couldn't say, though the error message above seems to indicate that it does.

I doubt if this has anything to do with ObjC or Cocoa, either.

comment:2 Changed 7 years ago by gz

  • Resolution notabug deleted
  • Status changed from closed to reopened

I don't know whether this is what's causing this specific error, but the CCL pretty printer does store printed objects in a hash table, see ccl::circularity-process.

comment:3 Changed 7 years ago by gb

You're right - in some stupid, pedantic sense - that ccl::circularity-process does store objects in hash tables when detecting circularity. It doesn't try to detect circularity when printing atoms, like the unbound marker that something's trying to store in a hash table.

You've just wasted my time even more. Most people seem to figure out that being pedantic idiots isn't very useful to them and is rude to other people. I don't know why you haven't figured this out, but I don't really care, either. I don't believe that you're really as stupid as you seem to be, but that's mostly because I don't believe that anyone's that stupid.

If you want to see what's actually causing the problem, try debugging, e.g., setting *BREAK-ON-SIGNALS* to ERROR, so you can see what's actually calling CCL::PUTHASH (which implements (SETF GETHASH)) with an invalid argument. I don't believe that this is a CCL bug; if you want to convince me or anyone else that it is, make some effort to isolate the problem by getting things like SLIME-REPL out of the equation.

This isn't very complicated. If you really are too stupid to understand it, then I'll have to reevaluate my beliefs about how stupid people can be.

comment:4 Changed 7 years ago by informatimago

I confirm that the problem occurs only with slime. When launched from the shell, ccl can disassemble this function without a problem.

comment:5 Changed 7 years ago by gz

Thanks. Can you check with *print-circle* and *print-pretty* set to true?

comment:6 Changed 7 years ago by gb

  • Resolution set to fixed
  • Status changed from reopened to closed

This is a duplicate of ticket:1229.

comment:7 Changed 5 years ago by rme

  • Milestone Clozure CL 1.9 deleted

Milestone Clozure CL 1.9 deleted

Note: See TracTickets for help on using tickets.