I can't compile mcclim. My operating system is ubuntu 11.04,when execute   " (require 'mcclim)  " in emacs,there comes an error:


; file: /usr/share/common-lisp/source/clx/requests.lisp
; in: DEFUN CHANGE-PROPERTY
;     (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-CHANGEPROPERTY+)
;       ((XLIB::DATA (MEMBER :REPLACE :PREPEND :APPEND)) XLIB::MODE)
;       (XLIB:WINDOW XLIB:WINDOW)
;       (XLIB:RESOURCE-ID XLIB::PROPERTY-ID XLIB::TYPE-ID)
;       (XLIB:CARD8 FORMAT)
;       (XLIB:CARD32 LENGTH)
;       (PROGN
;        (ECASE FORMAT
;          (8
;           (XLIB::SEQUENCE-PUT 24 XLIB::DATA :FORMAT XLIB:CARD8 :START XLIB::START
;                               :END XLIB::END :TRANSFORM XLIB::TRANSFORM))
;          (16
;           (XLIB::SEQUENCE-PUT 24 XLIB::DATA :FORMAT XLIB:CARD16 :START
;                               XLIB::START :END XLIB::END :TRANSFORM
;                               XLIB::TRANSFORM))
;          (32
;           (XLIB::SEQUENCE-PUT 24 XLIB::DATA :FORMAT XLIB:CARD32 :START
;                               XLIB::START :END XLIB::END :TRANSFORM
;                               XLIB::TRANSFORM)))))
; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
; --> MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS PROGN
; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET*
; --> XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK SETF LET* MULTIPLE-VALUE-BIND
; --> LET LDB SB-KERNEL:%LDB 1+
; ==>
;   (+ (XLIB::BUFFER-REQUEST-NUMBER XLIB::BUFFER) 1)
;
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
;
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
; --> MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS PROGN
; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET*
; --> XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK SETF LET* MULTIPLE-VALUE-BIND
; --> LET LDB SB-KERNEL:%LDB
; ==>
;   (LOGAND (ASH INT (- SB-C::POSN)) (ASH 4294967295 (- SB-C::SIZE 32)))
;
; note: forced to do static-fun Two-arg-and (cost 53)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; compiling (DEFUN DELETE-PROPERTY ...)

; file: /usr/share/common-lisp/source/clx/requests.lisp
; in: DEFUN DELETE-PROPERTY
;     (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-DELETEPROPERTY+)
;       (XLIB:WINDOW XLIB:WINDOW)
;       (XLIB:RESOURCE-ID XLIB::PROPERTY-ID))
; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
; --> MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS PROGN
; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET*
; --> XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK SETF LET* MULTIPLE-VALUE-BIND
; --> LET LDB SB-KERNEL:%LDB 1+
; ==>
;   (+ (XLIB::BUFFER-REQUEST-NUMBER XLIB::BUFFER) 1)
;
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
;
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
; --> MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS PROGN
; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET*
; --> XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK SETF LET* MULTIPLE-VALUE-BIND
; --> LET LDB SB-KERNEL:%LDB
; ==>
;   (LOGAND (ASH INT (- SB-C::POSN)) (ASH 4294967295 (- SB-C::SIZE 32)))
;
; note: forced to do static-fun Two-arg-and (cost 53)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; compiling (DEFUN GET-PROPERTY ...)

; file: /usr/share/common-lisp/source/clx/requests.lisp
; in: DEFUN GET-PROPERTY
;     (XLIB::WITH-BUFFER-REQUEST-AND-REPLY (XLIB:DISPLAY XLIB::+X-GETPROPERTY+ NIL
;                                           :SIZES (8 32))
;         (((XLIB::DATA BOOLEAN) XLIB::DELETE-P) (XLIB:WINDOW XLIB:WINDOW)
;          (XLIB:RESOURCE-ID XLIB::PROPERTY-ID)
;          ((OR NULL XLIB:RESOURCE-ID) XLIB::TYPE-ID) (XLIB:CARD32 XLIB::START)
;          (XLIB:CARD32 (XLIB::INDEX- (OR XLIB::END 64000) XLIB::START)))
;       (LET ((XLIB::REPLY-FORMAT (XLIB::CARD8-GET 1))
;             (XLIB::REPLY-TYPE (XLIB::CARD32-GET 8))
;             (XLIB::BYTES-AFTER (XLIB::CARD32-GET 12))
;             (XLIB::NITEMS (XLIB::CARD32-GET 16)))
;         (VALUES XLIB::REPLY-FORMAT XLIB::REPLY-TYPE XLIB::BYTES-AFTER
;                 (AND (PLUSP XLIB::NITEMS) (ECASE XLIB::REPLY-FORMAT # # # #)))))
; --> LET UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL BLOCK SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN
; --> XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
; --> XLIB::WITHOUT-ABORTS PROGN XLIB::WITH-BUFFER-REQUEST-INTERNAL
; --> XLIB::WITH-BUFFER-OUTPUT LET LET* XLIB::BUFFER-NEW-REQUEST-NUMBER
; --> BLOCK SETF LET* MULTIPLE-VALUE-BIND LET LDB SB-KERNEL:%LDB 1+
; ==>
;   (+ (XLIB::BUFFER-REQUEST-NUMBER XLIB::BUFFER) 1)
;
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
;
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; --> LET UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL BLOCK SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN
; --> XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
; --> XLIB::WITHOUT-ABORTS PROGN XLIB::WITH-BUFFER-REQUEST-INTERNAL
; --> XLIB::WITH-BUFFER-OUTPUT LET LET* XLIB::BUFFER-NEW-REQUEST-NUMBER
; --> BLOCK SETF LET* MULTIPLE-VALUE-BIND LET LDB SB-KERNEL:%LDB
; ==>
;   (LOGAND (ASH INT (- SB-C::POSN)) (ASH 4294967295 (- SB-C::SIZE 32)))
;
; note: forced to do static-fun Two-arg-and (cost 53)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; compiling (DEFUN ROTATE-PROPERTIES ...)

; file: /usr/share/common-lisp/source/clx/requests.lisp
; in: DEFUN ROTATE-PROPERTIES
;     (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-ROTATEPROPERTIES+)
;       (XLIB:WINDOW XLIB:WINDOW)
;       (XLIB:CARD16 LENGTH)
;       (XLIB:INT16 (- XLIB::DELTA))
;       ((SEQUENCE :END LENGTH) SEQUENCE))
; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
; --> MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS PROGN
; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET*
; --> XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK SETF LET* MULTIPLE-VALUE-BIND
; --> LET LDB SB-KERNEL:%LDB 1+
; ==>
;   (+ (XLIB::BUFFER-REQUEST-NUMBER XLIB::BUFFER) 1)
;
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
;
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
; --> MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS PROGN
; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET*
; --> XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK SETF LET* MULTIPLE-VALUE-BIND
; --> LET LDB SB-KERNEL:%LDB
; ==>
;   (LOGAND (ASH INT (- SB-C::POSN)) (ASH 4294967295 (- SB-C::SIZE 32)))
;
; note: forced to do static-fun Two-arg-and (cost 53)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; compiling (DEFUN LIST-PROPERTIES ...)

; file: /usr/share/common-lisp/source/clx/requests.lisp
; in: DEFUN LIST-PROPERTIES
;     (XLIB::WITH-BUFFER-REQUEST-AND-REPLY (XLIB:DISPLAY XLIB::+X-LISTPROPERTIES+
;                                           NIL :SIZES 16)
;         ((XLIB:WINDOW XLIB:WINDOW))
;       (VALUES
;        (XLIB::SEQUENCE-GET :RESULT-TYPE XLIB::RESULT-TYPE :LENGTH
;                            (XLIB::CARD16-GET 8) :INDEX XLIB::+REPLYSIZE+)))
; --> LET UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL BLOCK SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN
; --> XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
; --> XLIB::WITHOUT-ABORTS PROGN XLIB::WITH-BUFFER-REQUEST-INTERNAL
; --> XLIB::WITH-BUFFER-OUTPUT LET LET* XLIB::BUFFER-NEW-REQUEST-NUMBER
; --> BLOCK SETF LET* MULTIPLE-VALUE-BIND LET LDB SB-KERNEL:%LDB 1+
; ==>
;   (+ (XLIB::BUFFER-REQUEST-NUMBER XLIB::BUFFER) 1)
;
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
;
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; --> LET UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL BLOCK SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN
; --> XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
; --> XLIB::WITHOUT-ABORTS PROGN XLIB::WITH-BUFFER-REQUEST-INTERNAL
; --> XLIB::WITH-BUFFER-OUTPUT LET LET* XLIB::BUFFER-NEW-REQUEST-NUMBER
; --> BLOCK SETF LET* MULTIPLE-VALUE-BIND LET LDB SB-KERNEL:%LDB
; ==>
;   (LOGAND (ASH INT (- SB-C::POSN)) (ASH 4294967295 (- SB-C::SIZE 32)))
;
; note: forced to do static-fun Two-arg-and (cost 53)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; compiling (DEFUN SELECTION-OWNER ...)

; file: /usr/share/common-lisp/source/clx/requests.lisp
; in: DEFUN SELECTION-OWNER
;     (XLIB::WITH-BUFFER-REQUEST-AND-REPLY (XLIB:DISPLAY
;                                           XLIB::+X-GETSELECTIONOWNER+ 12 :SIZES
;                                           32)
;         ((XLIB:RESOURCE-ID XLIB::SELECTION-ID))
;       (VALUES (XLIB::RESOURCE-ID-OR-NIL-GET 8)))
; --> LET UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL BLOCK SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN
; --> XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
; --> XLIB::WITHOUT-ABORTS PROGN XLIB::WITH-BUFFER-REQUEST-INTERNAL
; --> XLIB::WITH-BUFFER-OUTPUT LET LET* XLIB::BUFFER-NEW-REQUEST-NUMBER
; --> BLOCK SETF LET* MULTIPLE-VALUE-BIND LET LDB SB-KERNEL:%LDB 1+
; ==>
;   (+ (XLIB::BUFFER-REQUEST-NUMBER XLIB::BUFFER) 1)
;
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
;
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; --> LET UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL BLOCK SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN
; --> XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
; --> XLIB::WITHOUT-ABORTS PROGN XLIB::WITH-BUFFER-REQUEST-INTERNAL
; --> XLIB::WITH-BUFFER-OUTPUT LET LET* XLIB::BUFFER-NEW-REQUEST-NUMBER
; --> BLOCK SETF LET* MULTIPLE-VALUE-BIND LET LDB SB-KERNEL:%LDB
; ==>
;   (LOGAND (ASH INT (- SB-C::POSN)) (ASH 4294967295 (- SB-C::SIZE 32)))
;
; note: forced to do static-fun Two-arg-and (cost 53)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; compiling (DEFUN SET-SELECTION-OWNER ...)

; file: /usr/share/common-lisp/source/clx/requests.lisp
; in: DEFUN SET-SELECTION-OWNER
;     (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-SETSELECTIONOWNER+)
;       ((OR NULL XLIB:WINDOW) XLIB::OWNER)
;       (XLIB:RESOURCE-ID XLIB::SELECTION-ID)
;       ((OR NULL XLIB:CARD32) TIME))
; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
; --> MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS PROGN
; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET*
; --> XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK SETF LET* MULTIPLE-VALUE-BIND
; --> LET LDB SB-KERNEL:%LDB 1+
; ==>
;   (+ (XLIB::BUFFER-REQUEST-NUMBER XLIB::BUFFER) 1)
;
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
;
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
; --> MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS PROGN
; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET*
; --> XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK SETF LET* MULTIPLE-VALUE-BIND
; --> LET LDB SB-KERNEL:%LDB
; ==>
;   (LOGAND (ASH INT (- SB-C::POSN)) (ASH 4294967295 (- SB-C::SIZE 32)))
;
; note: forced to do static-fun Two-arg-and (cost 53)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; compiling (DEFSETF SELECTION-OWNER ...)
; compiling (DEFUN CONVERT-SELECTION ...)

; file: /usr/share/common-lisp/source/clx/requests.lisp
; in: DEFUN CONVERT-SELECTION
;     (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-CONVERTSELECTION+)
;       (XLIB:WINDOW XLIB::REQUESTOR)
;       (XLIB:RESOURCE-ID XLIB::SELECTION-ID XLIB::TYPE-ID)
;       ((OR NULL XLIB:RESOURCE-ID) XLIB::PROPERTY-ID)
;       ((OR NULL XLIB:CARD32) TIME))
; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
; --> MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS PROGN
; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET*
; --> XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK SETF LET* MULTIPLE-VALUE-BIND
; --> LET LDB SB-KERNEL:%LDB 1+
; ==>
;   (+ (XLIB::BUFFER-REQUEST-NUMBER XLIB::BUFFER) 1)
;
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
;
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
; --> MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS PROGN
; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET*
; --> XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK SETF LET* MULTIPLE-VALUE-BIND
; --> LET LDB SB-KERNEL:%LDB
; ==>
;   (LOGAND (ASH INT (- SB-C::POSN)) (ASH 4294967295 (- SB-C::SIZE 32)))
;
; note: forced to do static-fun Two-arg-and (cost 53)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; compiling (DEFUN SEND-EVENT ...)

; file: /usr/share/common-lisp/source/clx/requests.lisp
; in: DEFUN SEND-EVENT
;     (APPLY (SVREF XLIB::*EVENT-SEND-VECTOR* XLIB::INTERNAL-EVENT-CODE)
;            XLIB:DISPLAY XLIB::ARGS)
; --> MULTIPLE-VALUE-CALL
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN
;    (SVREF XLIB::*EVENT-SEND-VECTOR* XLIB::INTERNAL-EVENT-CODE))
;
; note: unable to
;   optimize
; because:
;   optimize away possible call to FDEFINITION at runtime

;     (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-SENDEVENT+)
;       ((XLIB::DATA BOOLEAN) XLIB::PROPAGATE-P)
;       (LENGTH 11)
;       ((OR (MEMBER :POINTER-WINDOW :INPUT-FOCUS) XLIB:WINDOW) XLIB:WINDOW)
;       (XLIB:CARD32 (XLIB::ENCODE-EVENT-MASK XLIB:EVENT-MASK))
;       (XLIB:CARD8 XLIB::EXTERNAL-EVENT-CODE)
;       (PROGN
;        (APPLY (SVREF XLIB::*EVENT-SEND-VECTOR* XLIB::INTERNAL-EVENT-CODE)
;               XLIB:DISPLAY XLIB::ARGS)
;        (SETF (XLIB::BUFFER-BOFFSET XLIB:DISPLAY)
;                (XLIB::INDEX+ XLIB::BUFFER-BOFFSET 44))))
; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
; --> MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS PROGN
; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET*
; --> XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK SETF LET* MULTIPLE-VALUE-BIND
; --> LET LDB SB-KERNEL:%LDB 1+
; ==>
;   (+ (XLIB::BUFFER-REQUEST-NUMBER XLIB::BUFFER) 1)
;
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
;
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; --> LET XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK
; --> MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS PROGN
; --> XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET LET*
; --> XLIB::BUFFER-NEW-REQUEST-NUMBER BLOCK SETF LET* MULTIPLE-VALUE-BIND
; --> LET LDB SB-KERNEL:%LDB
; ==>
;   (LOGAND (ASH INT (- SB-C::POSN)) (ASH 4294967295 (- SB-C::SIZE 32)))
;
; note: forced to do static-fun Two-arg-and (cost 53)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.
ASDF could not load mcclim because   failed AVER:
                                       (AND (NULL (TN-READS TN))
                                            (NULL (TN-WRITES TN)))
                                   This is probably a bug in SBCL itself.
                                   (Alternatively, SBCL might have been
                                   corrupted by bad user code, e.g. by an
                                   undefined Lisp operation like
                                   (FMAKUNBOUND 'COMPILE), or by stray
                                   pointers from alien code or from unsafe
                                   Lisp code; or there might be a bug in
                                   the OS or hardware that SBCL is running
                                   on.) If it seems to be a bug in SBCL
                                   itself, the maintainers would like to
                                   know about it. Bug reports are welcome
                                   on the SBCL mailing lists, which you
                                   can find at




This error appears recently. I  am a freshman in common lisp ,so I mail you for help.
I am sorry for my poor English.
Thank you