Krzysztof Drewniak | 2 Jun 02:28 2011
Picon

Re: [STUMP] [Fwd: Re: "Applications Menu" contrib module]

On Mon, 2011-05-30 at 20:29 -0500, Krzysztof Drewniak wrote:
[snip]
> > 
> > Hi Ben,
> > 
> > I got your fix, and I can't believe I hadn't thought of that. Thank you
> > for your idea and the menu-method. It needed a little tinkering so it
> > would work, but nothing major. The code is much simpler now.
> > 
> > Here's the new patches.
> > 
> > Thank you,
> > 
> > Krzysztof Drewniak
> Accidentally forgot to send to the list. Fixing that
> 
> Krzysztof Drewniak

I just realized I left a debug print in load-menu-file . Should I
resubmit my patch?

Krzysztof Drewniak
--

-- 
X-Real-Email-With-Antispam: krzysdrewniak at gmail dot com
pgp key on keyserver.ubuntu.com 2388E924

_______________________________________________
Stumpwm-devel mailing list
(Continue reading)

Duncan Bayne | 8 Jun 00:37 2011
Picon

[STUMP] Displaying messages using StumpWM

Hi All,

I'm learning Common Lisp, & I had an idea for a CI-like tool.  The
rough idea is that it's a Lisp program that will monitor a set of Lisp
files, & if any changes, run all the lisp-unit tests in them.

The thing is, I'd like to display the result using the StumpWm
message() function.  However - and possibly this is just because I'm
new to Common Lisp - I don't see how I can have my Lisp program get
StumpWM to display messages.

I've had a read through the StumpWM manual but couldn't see anything.
Could someone please point me in the right direction - or let me know
whether what I'm trying to do is impossible (or a bad idea)?  Perhaps
I should be implementing this as an extension to Emacs ...

--

-- 
Duncan Bayne
ph: +61 420 817 082 | web: http://www.fluidscape.com/ | skype: duncan_bayne
Manuel Giraud | 8 Jun 13:36 2011
Picon

Re: [STUMP] Displaying messages using StumpWM

Duncan Bayne <dhgbayne <at> gmail.com> writes:

> I'm learning Common Lisp, & I had an idea for a CI-like tool.  The
> rough idea is that it's a Lisp program that will monitor a set of Lisp
> files, & if any changes, run all the lisp-unit tests in them.

Good luck with that but I don't see how it is related to a window
manager.

> The thing is, I'd like to display the result using the StumpWm
> message() function.  However - and possibly this is just because I'm
> new to Common Lisp - I don't see how I can have my Lisp program get
> StumpWM to display messages.

StumpWM run into a Common Lisp implementation (sbcl, clisp or whatnot)
instance so your program has to run in that same instance in order to
call any of the running stumpwm function. Or you have to be able to
communicate with that lisp instance (maybe you could use
contrib/stumpish as an example).

--

-- 
Manuel Giraud
Duncan Bayne | 8 Jun 13:54 2011
Picon

Re: [STUMP] Displaying messages using StumpWM

>> I'm learning Common Lisp, & I had an idea for a CI-like tool.  The
>> rough idea is that it's a Lisp program that will monitor a set of Lisp
>> files, & if any changes, run all the lisp-unit tests in them.
>
> Good luck with that but I don't see how it is related to a window
> manager.

Nothing specifically, but I was wondering if StumpWM had a feature
like Growl (http://www.growl.info).

> StumpWM run into a Common Lisp implementation (sbcl, clisp or whatnot)
> instance so your program has to run in that same instance in order to
> call any of the running stumpwm function. Or you have to be able to
> communicate with that lisp instance (maybe you could use
> contrib/stumpish as an example).

Thanks, I'll look into that - maybe even contribute a Growl-like API
back, if I figure it all out.

--

-- 
Duncan Bayne
ph: +61 420 817 082 | web: http://www.fluidscape.com/ | skype: duncan_bayne
Scott Jaderholm | 9 Jun 05:59 2011
Picon

[STUMP] raise and focus rule set to nil focuses window if only window in frame

When I make a placement rule that isn't supposed to focus the window (nil as third field in dumped rules) it only works (doesn't focus the window) when there's already a window in the destination frame. Anyone else have this problem? is it a bug? Or is the scope of the raise option really only raising not focusing?

Scott

_______________________________________________
Stumpwm-devel mailing list
Stumpwm-devel <at> nongnu.org
https://lists.nongnu.org/mailman/listinfo/stumpwm-devel
Jay Belanger | 8 Jun 06:03 2011
Picon

[STUMP] Problems with Stumpwm and sbcl in Ubuntu 11.04


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
 "~ <at> <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
 "~ <at> <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]> 
David Bjergaard | 9 Jun 19:46 2011
Picon

Re: [STUMP] Problems with Stumpwm and sbcl in Ubuntu 11.04

Hi,

I've also recompiled stumpwm in 11.04 after upgrading, but I installed
the latest sbcl from source because the binary distributed with 11.04
doesn't enable threading by default making it impossible to take
advantage of slime and swank features.  Try downloading and compiling
the latest sbcl and then follow the instructions on the archwiki. It
took a little more tweaking than I expected but eventually I got it
working.

Cheers,

       Dave

On Tue, Jun 7, 2011 at 11:03 PM, Jay Belanger <jay.p.belanger <at> gmail.com> wrote:
>
> 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
>  "~ <at> <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
>  "~ <at> <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]>
>
> _______________________________________________
> Stumpwm-devel mailing list
> Stumpwm-devel <at> nongnu.org
> https://lists.nongnu.org/mailman/listinfo/stumpwm-devel
>
Jay Belanger | 10 Jun 04:47 2011
Picon

Re: [STUMP] Problems with Stumpwm and sbcl in Ubuntu 11.04


> I've also recompiled stumpwm in 11.04 after upgrading, but I installed
> the latest sbcl

That worked!
I'm no longer using the supplied sbcl and now I can once again compile
stumpwm.  I'll assume there is a bug in Ubuntu's version.

Thanks for the tip.
Krzysztof Drewniak | 11 Jun 15:43 2011
Picon

[STUMP] Applications menu patch - with issues fixed

I'm attaching the "Applications Menu" patch with the issues (stray debug
prints) fixed. If this patch is acceptable, please push it.

Thanks,

Krzyaztof
--

-- 
X-Real-Email-With-Antispam: krzysdrewniak at gmail dot com
pgp key on keyserver.ubuntu.com 2388E924

Attachment (app-menu.patch): text/x-patch, 2936 bytes
_______________________________________________
Stumpwm-devel mailing list
Stumpwm-devel <at> nongnu.org
https://lists.nongnu.org/mailman/listinfo/stumpwm-devel
Johnny | 12 Jun 11:52 2011
Picon

[STUMP] Gimp handling problems

/repost after joining the list, apologies for any duplication/

Hi all,

I am trying to configure the gimp based on the advise on the stumpwmwiki
at http://stumpwm.svkt.org/cgi-bin/wiki.pl/Handling_the_Gimp. 

However, using the code suggested and running 'C-t : gimp' gives the
error 'The function STUMPWM-USER::SCREEN-WIDTH is undefined'.

Attempts to circumvent this by explicitly defining the screen width and
height gives the next error message 'The function STUMPWM-USER::GNEW is
undefined'.

What am I getting wrong here and how to get a nice gimp configuration
with stumpwm?

I have since found that there is a 'defun screen-width' in screen.lisp
and a 'defcommand gnew' in group.lisp; maybe I need to refer these in
the .stumpwmrc?

Attaching my complete stumpwmrc below.

Attachment (stumpwmrc): application/octet-stream, 1758 bytes

Thanks,
--

-- 
Johnny
_______________________________________________
Stumpwm-devel mailing list
Stumpwm-devel <at> nongnu.org
https://lists.nongnu.org/mailman/listinfo/stumpwm-devel

Gmane