[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[STUMP] Problems with Stumpwm and sbcl in Ubuntu 11.04
|
From: |
Jay Belanger |
|
Subject: |
[STUMP] Problems with Stumpwm and sbcl in Ubuntu 11.04 |
|
Date: |
Tue, 07 Jun 2011 23:03:29 -0500 |
|
User-agent: |
Gnus/5.13 (Gnus v5.13) Emacs/24.0.50 (gnu/linux) |
I recently upgraded to Ubuntu 11.04, and now stumpwm won't compile (and
complains quite a bit that specific number types aren't used). The
output says that it might be a bug in sbcl, but I thought it would make
sense to work my way up and see if it may be a problem with stumpwm.
Is anybody else having a problem like this?
The actual bug message follows, and the entire compilation output is at
the end of this message.
BUG MESSAGE:
debugger invoked on a SB-INT:BUG in thread #<THREAD "initial thread" RUNNING
{AB638D1}>:
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 <http://sbcl.sourceforge.net/>.
Type HELP for debugger help, or (SB-EXT:QUIT) to exit from SBCL.
restarts (invokable by number or by possibly-abbreviated name):
0: [TRY-RECOMPILING] Try recompiling requests
1: [RETRY ] Retry compiling component ("clx" "requests").
2: [ACCEPT ] Continue, treating
compiling component ("clx" "requests") as having been
successful.
3: [CONTINUE ] Ignore runtime option --load "./make-image.lisp".
4: [ABORT ] Skip rest of --eval and --load options.
5: Skip to toplevel READ/EVAL/PRINT loop.
6: [QUIT ] Quit SBCL (calling #'QUIT, killing the process).
(SB-INT:BUG
"~@<failed AVER: ~2I~_~A~:>"
(AND (NULL (SB-C::TN-READS SB-C:TN)) (NULL (SB-C::TN-WRITES SB-C:TN))))
0] 6
; compilation aborted after 0:00:18.588
;
; compilation unit aborted
; caught 2 fatal ERROR conditions
; printed 145 notes
make: *** [stumpwm] Error 1
COMPILATION OUTPUT:
[/usr/local/src/stumpwmorig]> make clean
rm -f *.fasl *.fas *.lib *.*fsl
rm -f *.log *.fns *.fn *.aux *.cp *.ky *.log *.toc *.pg *.tp *.vr *.vrs
rm -f stumpwm stumpwm.texi stumpwm.info
[/usr/local/src/stumpwmorig]> git pull
Already up-to-date.
[/usr/local/src/stumpwmorig]> autoconf
[/usr/local/src/stumpwmorig]> ./configure
checking for sbcl... /usr/bin/sbcl
checking for clisp... no
checking for ccl... no
checking for ecl... no
configure: Using sbcl at /usr/bin/sbcl
checking for makeinfo... yes
checking for xdpyinfo... yes
configure: creating ./config.status
config.status: creating Makefile
configure: creating ./config.status
config.status: creating Makefile
config.status: creating make-image.lisp
configure: creating ./config.status
config.status: creating Makefile
config.status: creating make-image.lisp
config.status: creating version.lisp
[/usr/local/src/stumpwmorig]> make
/usr/bin/sbcl --load ./make-image.lisp
This is SBCL 1.0.45.0.debian, an implementation of ANSI Common Lisp.
More information about SBCL is available at <http://www.sbcl.org/>.
SBCL is free software, provided as is, with absolutely no warranty.
It is mostly in the public domain; some portions are provided under
BSD-style licenses. See the CREDITS and COPYING files in the
distribution for more information.
; Loading system definition from /usr/local/src/stumpwmorig/stumpwm.asd into
; #<PACKAGE "ASDF0">
; Registering #<SYSTEM :STUMPWM> as STUMPWM
; Loading system definition from /usr/lib/sbcl/sb-posix/sb-posix.asd into
; #<PACKAGE "ASDF0">
; Loading system definition from /usr/lib/sbcl/sb-grovel/sb-grovel.asd into
; #<PACKAGE "ASDF1">
; Registering #<SYSTEM SB-GROVEL> as SB-GROVEL
; Registering #<SYSTEM SB-POSIX> as SB-POSIX
; Registering #<SYSTEM SB-POSIX-TESTS> as SB-POSIX-TESTS
; Loading system definition from /usr/share/common-lisp/systems/clx.asd into
; #<PACKAGE "ASDF0">
; Registering #<SYSTEM CLX> as CLX
; Loading system definition from
; /usr/lib/sbcl/sb-bsd-sockets/sb-bsd-sockets.asd into #<PACKAGE "ASDF0">
; Registering #<SYSTEM SB-BSD-SOCKETS> as SB-BSD-SOCKETS
; Registering #<SYSTEM SB-BSD-SOCKETS-TESTS> as SB-BSD-SOCKETS-TESTS
; Loading system definition from /usr/share/common-lisp/systems/cl-ppcre.asd
; into #<PACKAGE "ASDF0">
; Registering #<SYSTEM :CL-PPCRE> as CL-PPCRE
; Registering #<SYSTEM :CL-PPCRE-TEST> as CL-PPCRE-TEST
STYLE-WARNING: Couldn't grovel for EAI_ADDRFAMILY (unknown to the C compiler).
; compiling file "/usr/share/common-lisp/source/clx/requests.lisp" (written 28
NOV 2009 09:43:30 AM):
; compiling (IN-PACKAGE :XLIB)
; compiling (DEFUN CREATE-WINDOW ...)
; file: /usr/share/common-lisp/source/clx/requests.lisp
; in: DEFUN CREATE-WINDOW
; (XLIB::ALLOCATE-RESOURCE-ID XLIB:DISPLAY XLIB:WINDOW 'XLIB:WINDOW)
; --> XLIB:WITH-DISPLAY XLIB::WITH-BUFFER MACROLET LET XLIB::HOLDING-LOCK
; --> SB-THREAD:WITH-RECURSIVE-LOCK SB-INT:DX-FLET FLET BLOCK LET FUNCALL
; --> SB-C::%FUNCALL THE
; ==>
; (SB-KERNEL:%COERCE-CALLABLE-TO-FUN (XLIB:DISPLAY-XID XLIB:DISPLAY))
;
; note: unable to
; optimize
; because:
; optimize away possible call to FDEFINITION at runtime
; (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-CREATEWINDOW+)
; (XLIB::DATA XLIB::DEPTH)
; (XLIB:RESOURCE-ID XLIB::WID)
; (XLIB:WINDOW XLIB::PARENT)
; (XLIB:INT16 XLIB::X XLIB::Y)
; (XLIB:CARD16 XLIB::WIDTH XLIB::HEIGHT XLIB::BORDER-WIDTH)
; ((XLIB::MEMBER16 :COPY :INPUT-OUTPUT :INPUT-ONLY) CLASS)
; (XLIB:RESOURCE-ID
; (COND ((EQ XLIB::VISUAL :COPY) 0)
; ((TYPEP XLIB::VISUAL 'XLIB:RESOURCE-ID) XLIB::VISUAL)
; (T (XLIB:VISUAL-INFO-ID XLIB::VISUAL))))
; (XLIB::MASK
; (XLIB:CARD32 XLIB::BACK-PIXMAP XLIB::BACK-PIXEL XLIB::BORDER-PIXMAP
; XLIB::BORDER-PIXEL)
; ((XLIB::MEMBER-VECTOR XLIB::+BIT-GRAVITY-VECTOR+) XLIB:BIT-GRAVITY)
; ((XLIB::MEMBER-VECTOR XLIB::+WIN-GRAVITY-VECTOR+) XLIB::GRAVITY)
; ((MEMBER :NOT-USEFUL :WHEN-MAPPED :ALWAYS) XLIB::BACKING-STORE)
; (XLIB:CARD32 XLIB::BACKING-PLANES XLIB::BACKING-PIXEL)
; ((MEMBER :OFF :ON) XLIB::OVERRIDE-REDIRECT XLIB::SAVE-UNDER)
; (XLIB:CARD32 XLIB:EVENT-MASK XLIB::DO-NOT-PROPAGATE-MASK)
; ((OR (MEMBER :COPY) XLIB:COLORMAP) XLIB:COLORMAP)
; ((OR (MEMBER :NONE) XLIB:CURSOR) XLIB:CURSOR)))
; --> 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* LET
; --> INCF LET*
; ==>
; (+ (XLIB::BUFFER-BOFFSET #:TMP131) #:G132)
;
; 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).
; --> 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).
; --> 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* LET
; --> UNLESS IF PROGN SETQ THE
; ==>
; (LOGIOR XLIB::%MASK 2)
;
; note: forced to do static-fun Two-arg-ior (cost 53)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a INTEGER, not a FIXNUM.
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST
T).
; unable to do inline (unsigned-byte 32) arithmetic (cost 2) because:
; The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
; (UNSIGNED-BYTE 32)
; &REST T).
; etc.
; ==>
; (LOGIOR XLIB::%MASK 4)
;
; note: forced to do static-fun Two-arg-ior (cost 53)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a INTEGER, not a FIXNUM.
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST
T).
; unable to do inline (unsigned-byte 32) arithmetic (cost 2) because:
; The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
; (UNSIGNED-BYTE 32)
; &REST T).
; etc.
; ==>
; (LOGIOR XLIB::%MASK 8)
;
; note: forced to do static-fun Two-arg-ior (cost 53)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a INTEGER, not a FIXNUM.
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST
T).
; unable to do inline (unsigned-byte 32) arithmetic (cost 2) because:
; The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
; (UNSIGNED-BYTE 32)
; &REST T).
; etc.
; ==>
; (LOGIOR XLIB::%MASK 16)
;
; note: forced to do static-fun Two-arg-ior (cost 53)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a INTEGER, not a FIXNUM.
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST
T).
; unable to do inline (unsigned-byte 32) arithmetic (cost 2) because:
; The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
; (UNSIGNED-BYTE 32)
; &REST T).
; etc.
; ==>
; (LOGIOR XLIB::%MASK 32)
;
; note: forced to do static-fun Two-arg-ior (cost 53)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a INTEGER, not a FIXNUM.
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST
T).
; unable to do inline (unsigned-byte 32) arithmetic (cost 2) because:
; The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
; (UNSIGNED-BYTE 32)
; &REST T).
; etc.
; ==>
; (LOGIOR XLIB::%MASK 64)
;
; note: forced to do static-fun Two-arg-ior (cost 53)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a INTEGER, not a FIXNUM.
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST
T).
; unable to do inline (unsigned-byte 32) arithmetic (cost 2) because:
; The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
; (UNSIGNED-BYTE 32)
; &REST T).
; etc.
; ==>
; (LOGIOR XLIB::%MASK 128)
;
; note: forced to do static-fun Two-arg-ior (cost 53)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a INTEGER, not a FIXNUM.
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST
T).
; unable to do inline (unsigned-byte 32) arithmetic (cost 2) because:
; The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
; (UNSIGNED-BYTE 32)
; &REST T).
; etc.
; ==>
; (LOGIOR XLIB::%MASK 256)
;
; note: forced to do static-fun Two-arg-ior (cost 53)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a INTEGER, not a FIXNUM.
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST
T).
; unable to do inline (unsigned-byte 32) arithmetic (cost 2) because:
; The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
; (UNSIGNED-BYTE 32)
; &REST T).
; etc.
; ==>
; (LOGIOR XLIB::%MASK 512)
;
; note: forced to do static-fun Two-arg-ior (cost 53)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a INTEGER, not a FIXNUM.
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST
T).
; unable to do inline (unsigned-byte 32) arithmetic (cost 2) because:
; The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
; (UNSIGNED-BYTE 32)
; &REST T).
; etc.
; ==>
; (LOGIOR XLIB::%MASK 1024)
;
; note: forced to do static-fun Two-arg-ior (cost 53)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a INTEGER, not a FIXNUM.
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST
T).
; unable to do inline (unsigned-byte 32) arithmetic (cost 2) because:
; The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
; (UNSIGNED-BYTE 32)
; &REST T).
; etc.
; ==>
; (LOGIOR XLIB::%MASK 2048)
;
; note: forced to do static-fun Two-arg-ior (cost 53)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a INTEGER, not a FIXNUM.
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST
T).
; unable to do inline (unsigned-byte 32) arithmetic (cost 2) because:
; The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
; (UNSIGNED-BYTE 32)
; &REST T).
; etc.
; ==>
; (LOGIOR XLIB::%MASK 4096)
;
; note: forced to do static-fun Two-arg-ior (cost 53)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a INTEGER, not a FIXNUM.
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST
T).
; unable to do inline (unsigned-byte 32) arithmetic (cost 2) because:
; The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
; (UNSIGNED-BYTE 32)
; &REST T).
; etc.
; ==>
; (LOGIOR XLIB::%MASK 8192)
;
; note: forced to do static-fun Two-arg-ior (cost 53)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a INTEGER, not a FIXNUM.
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST
T).
; unable to do inline (unsigned-byte 32) arithmetic (cost 2) because:
; The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
; (UNSIGNED-BYTE 32)
; &REST T).
; etc.
; ==>
; (LOGIOR XLIB::%MASK 16384)
;
; note: forced to do static-fun Two-arg-ior (cost 53)
; unable to do inline fixnum arithmetic (cost 1) because:
; The first argument is a INTEGER, not a FIXNUM.
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST
T).
; unable to do inline (unsigned-byte 32) arithmetic (cost 2) because:
; The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).
; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
; (UNSIGNED-BYTE 32)
; &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* LET
; --> INCF LET*
; ==>
; (+ (XLIB::BUFFER-BOFFSET #:TMP131) #:G132)
;
; note: forced to do GENERIC-+ (cost 10)
; unable to do inline fixnum arithmetic (cost 2) because:
; The first argument is a NUMBER, not a FIXNUM.
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST
T).
; unable to do inline (signed-byte 32) arithmetic (cost 5) because:
; The first argument is a NUMBER, not a (SIGNED-BYTE 32).
; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE
32)
; &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 1+
; ==>
; (+ (XLIB::BUFFER-REQUEST-NUMBER XLIB::BUFFER) 1)
;
; 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 DESTROY-WINDOW ...)
; file: /usr/share/common-lisp/source/clx/requests.lisp
; in: DEFUN DESTROY-WINDOW
; (XLIB::WITH-BUFFER-REQUEST ((XLIB:WINDOW-DISPLAY XLIB:WINDOW)
; XLIB::+X-DESTROYWINDOW+)
; (XLIB:WINDOW XLIB:WINDOW))
; --> 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 DESTROY-SUBWINDOWS ...)
; file: /usr/share/common-lisp/source/clx/requests.lisp
; in: DEFUN DESTROY-SUBWINDOWS
; (XLIB::WITH-BUFFER-REQUEST ((XLIB:WINDOW-DISPLAY XLIB:WINDOW)
; XLIB::+X-DESTROYSUBWINDOWS+)
; (XLIB:WINDOW XLIB:WINDOW))
; --> 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 ADD-TO-SAVE-SET ...)
; file: /usr/share/common-lisp/source/clx/requests.lisp
; in: DEFUN ADD-TO-SAVE-SET
; (XLIB::WITH-BUFFER-REQUEST ((XLIB:WINDOW-DISPLAY XLIB:WINDOW)
; XLIB::+X-CHANGESAVESET+)
; (XLIB::DATA 0)
; (XLIB:WINDOW XLIB:WINDOW))
; --> 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 REMOVE-FROM-SAVE-SET ...)
; file: /usr/share/common-lisp/source/clx/requests.lisp
; in: DEFUN REMOVE-FROM-SAVE-SET
; (XLIB::WITH-BUFFER-REQUEST ((XLIB:WINDOW-DISPLAY XLIB:WINDOW)
; XLIB::+X-CHANGESAVESET+)
; (XLIB::DATA 1)
; (XLIB:WINDOW XLIB:WINDOW))
; --> 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 REPARENT-WINDOW ...)
; file: /usr/share/common-lisp/source/clx/requests.lisp
; in: DEFUN REPARENT-WINDOW
; (XLIB::WITH-BUFFER-REQUEST ((XLIB:WINDOW-DISPLAY XLIB:WINDOW)
; XLIB::+X-REPARENTWINDOW+)
; (XLIB:WINDOW XLIB:WINDOW XLIB::PARENT)
; (XLIB:INT16 XLIB::X XLIB::Y))
; --> 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 MAP-WINDOW ...)
; file: /usr/share/common-lisp/source/clx/requests.lisp
; in: DEFUN MAP-WINDOW
; (XLIB::WITH-BUFFER-REQUEST ((XLIB:WINDOW-DISPLAY XLIB:WINDOW)
; XLIB::+X-MAPWINDOW+)
; (XLIB:WINDOW XLIB:WINDOW))
; --> 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 MAP-SUBWINDOWS ...)
; file: /usr/share/common-lisp/source/clx/requests.lisp
; in: DEFUN MAP-SUBWINDOWS
; (XLIB::WITH-BUFFER-REQUEST ((XLIB:WINDOW-DISPLAY XLIB:WINDOW)
; XLIB::+X-MAPSUBWINDOWS+)
; (XLIB:WINDOW XLIB:WINDOW))
; --> 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 UNMAP-WINDOW ...)
; file: /usr/share/common-lisp/source/clx/requests.lisp
; in: DEFUN UNMAP-WINDOW
; (XLIB::WITH-BUFFER-REQUEST ((XLIB:WINDOW-DISPLAY XLIB:WINDOW)
; XLIB::+X-UNMAPWINDOW+)
; (XLIB:WINDOW XLIB:WINDOW))
; --> 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 UNMAP-SUBWINDOWS ...)
; file: /usr/share/common-lisp/source/clx/requests.lisp
; in: DEFUN UNMAP-SUBWINDOWS
; (XLIB::WITH-BUFFER-REQUEST ((XLIB:WINDOW-DISPLAY XLIB:WINDOW)
; XLIB::+X-UNMAPSUBWINDOWS+)
; (XLIB:WINDOW XLIB:WINDOW))
; --> 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 CIRCULATE-WINDOW-UP ...)
; file: /usr/share/common-lisp/source/clx/requests.lisp
; in: DEFUN CIRCULATE-WINDOW-UP
; (XLIB::WITH-BUFFER-REQUEST ((XLIB:WINDOW-DISPLAY XLIB:WINDOW)
; XLIB::+X-CIRCULATEWINDOW+)
; (XLIB::DATA 0)
; (XLIB:WINDOW XLIB:WINDOW))
; --> 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 CIRCULATE-WINDOW-DOWN ...)
; file: /usr/share/common-lisp/source/clx/requests.lisp
; in: DEFUN CIRCULATE-WINDOW-DOWN
; (XLIB::WITH-BUFFER-REQUEST ((XLIB:WINDOW-DISPLAY XLIB:WINDOW)
; XLIB::+X-CIRCULATEWINDOW+)
; (XLIB::DATA 1)
; (XLIB:WINDOW XLIB:WINDOW))
; --> 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 QUERY-TREE ...)
; file: /usr/share/common-lisp/source/clx/requests.lisp
; in: DEFUN QUERY-TREE
; (XLIB::WITH-BUFFER-REQUEST-AND-REPLY (XLIB:DISPLAY XLIB::+X-QUERYTREE+ NIL
; :SIZES (8 16 32))
; ((XLIB:WINDOW XLIB:WINDOW))
; (VALUES (XLIB::WINDOW-GET 8) (XLIB::RESOURCE-ID-GET 12)
; (XLIB::SEQUENCE-GET :LENGTH (XLIB::CARD16-GET 16) :RESULT-TYPE
; XLIB::RESULT-TYPE :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 INTERN-ATOM ...)
; file: /usr/share/common-lisp/source/clx/requests.lisp
; in: DEFUN INTERN-ATOM
; (XLIB::WITH-BUFFER-REQUEST-AND-REPLY (XLIB:DISPLAY XLIB::+X-INTERNATOM+ 12
; :SIZES 32)
; ((XLIB::DATA 0) (XLIB:CARD16 (LENGTH STRING)) (XLIB::PAD16 NIL)
; (STRING STRING))
; (VALUES (XLIB::RESOURCE-ID-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 FIND-ATOM ...)
; file: /usr/share/common-lisp/source/clx/requests.lisp
; in: DEFUN FIND-ATOM
; (XLIB::WITH-BUFFER-REQUEST-AND-REPLY (XLIB:DISPLAY XLIB::+X-INTERNATOM+ 12
; :SIZES 32)
; ((XLIB::DATA 1) (XLIB:CARD16 (LENGTH STRING)) (XLIB::PAD16 NIL)
; (STRING STRING))
; (VALUES (XLIB::OR-GET 8 NULL XLIB:RESOURCE-ID)))
; --> 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 ATOM-NAME ...)
; file: /usr/share/common-lisp/source/clx/requests.lisp
; in: DEFUN ATOM-NAME
; (XLIB::WITH-BUFFER-REQUEST-AND-REPLY (XLIB:DISPLAY XLIB::+X-GETATOMNAME+
NIL
; :SIZES (16))
; ((XLIB:RESOURCE-ID XLIB::ATOM-ID))
; (VALUES (XLIB::STRING-GET (XLIB::CARD16-GET 8) 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 LOOKUP-XATOM ...)
; compiling (DEFUN CHANGE-PROPERTY ...)
; 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.
debugger invoked on a SB-INT:BUG in thread #<THREAD "initial thread" RUNNING
{AB638D1}>:
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 <http://sbcl.sourceforge.net/>.
Type HELP for debugger help, or (SB-EXT:QUIT) to exit from SBCL.
restarts (invokable by number or by possibly-abbreviated name):
0: [TRY-RECOMPILING] Try recompiling requests
1: [RETRY ] Retry compiling component ("clx" "requests").
2: [ACCEPT ] Continue, treating
compiling component ("clx" "requests") as having been
successful.
3: [CONTINUE ] Ignore runtime option --load "./make-image.lisp".
4: [ABORT ] Skip rest of --eval and --load options.
5: Skip to toplevel READ/EVAL/PRINT loop.
6: [QUIT ] Quit SBCL (calling #'QUIT, killing the process).
(SB-INT:BUG
"~@<failed AVER: ~2I~_~A~:>"
(AND (NULL (SB-C::TN-READS SB-C:TN)) (NULL (SB-C::TN-WRITES SB-C:TN))))
0] 6
; compilation aborted after 0:00:18.588
;
; compilation unit aborted
; caught 2 fatal ERROR conditions
; printed 145 notes
make: *** [stumpwm] Error 1
[/usr/local/src/stumpwmorig]>
- [STUMP] Problems with Stumpwm and sbcl in Ubuntu 11.04,
Jay Belanger <=