DC-Build-Header: stumpwm 1:20090502.git482df740-1 / Tue Jul 14 02:00:00 +0200 2009 sbuild (Debian sbuild) 0.58.6 (20 Jun 2009) on paramount-32.rennes.grid5000.fr ╔══════════════════════════════════════════════════════════════════════════════╗ ║ stumpwm 1:20090502.git482df740-1 (amd64) 14 Jul 2009 02:00 ║ ╚══════════════════════════════════════════════════════════════════════════════╝ Package: stumpwm Version: 1:20090502.git482df740-1 Architecture: amd64 Start Time: 20090714-0200 ┌──────────────────────────────────────────────────────────────────────────────┐ │ Fetch source files │ └──────────────────────────────────────────────────────────────────────────────┘ Check APT ───────── Checking available source versions... Download source files with APT ────────────────────────────── Reading package lists... Building dependency tree... Reading state information... Need to get 307kB of source archives. Get:1 http://localhost sid/main stumpwm 1:20090502.git482df740-1 (dsc) [1565B] Get:2 http://localhost sid/main stumpwm 1:20090502.git482df740-1 (tar) [204kB] Get:3 http://localhost sid/main stumpwm 1:20090502.git482df740-1 (diff) [101kB] Fetched 307kB in 26s (11.7kB/s) Download complete and in download only mode Check arch ────────── ** Using build dependencies supplied by package: Build-Depends: debhelper (>= 5.0.0), quilt (>= 0.40) Build-Depends-Indep: dh-lisp, texinfo, autoconf, sbcl, cl-clx-sbcl, cl-ppcre ┌──────────────────────────────────────────────────────────────────────────────┐ │ Install build dependencies │ └──────────────────────────────────────────────────────────────────────────────┘ Checking for already installed source dependencies... debhelper: missing Using default version 7.2.21 quilt: missing Using default version 0.46-7 dh-lisp: missing texinfo: missing autoconf: missing sbcl: missing cl-clx-sbcl: missing cl-ppcre: missing Checking for source dependency conflicts... Installing positive dependencies: debhelper quilt dh-lisp texinfo autoconf sbcl cl-clx-sbcl cl-ppcre Reading package lists... Building dependency tree... Reading state information... The following extra packages will be installed: bsdmainutils cl-asdf common-lisp-controller diffstat file gettext gettext-base groff-base html2text intltool-debian libcroco3 libglib2.0-0 libgomp1 libmagic1 libpcre3 libxml2 m4 man-db po-debconf realpath Suggested packages: autobook autoconf-archive autoconf-doc autoconf2.13 gnu-standards libtool vacation wamerican wordlist whois dh-make cvs gettext-doc groff www-browser libmail-box-perl procmail graphviz sbcl-doc sbcl-source slime texlive-base texlive-latex-base texlive-generic-recommended texinfo-doc-nonfree Recommended packages: automake automaken curl wget lynx libglib2.0-data shared-mime-info xml-core libmail-sendmail-perl binfmt-support The following NEW packages will be installed: autoconf bsdmainutils cl-asdf cl-clx-sbcl cl-ppcre common-lisp-controller debhelper dh-lisp diffstat file gettext gettext-base groff-base html2text intltool-debian libcroco3 libglib2.0-0 libgomp1 libmagic1 libpcre3 libxml2 m4 man-db po-debconf quilt realpath sbcl texinfo 0 upgraded, 28 newly installed, 0 to remove and 0 not upgraded. Need to get 21.9MB of archives. After this operation, 83.0MB of additional disk space will be used. Get:1 http://localhost sid/main bsdmainutils 6.1.10 [179kB] Get:2 http://localhost sid/main groff-base 1.18.1.1-22 [897kB] Get:3 http://localhost sid/main man-db 2.5.5-2 [1506kB] Get:4 http://localhost sid/main libmagic1 5.03-1 [389kB] Get:5 http://localhost sid/main file 5.03-1 [46.7kB] Get:6 http://localhost sid/main gettext-base 0.17-6 [125kB] Get:7 http://localhost sid/main libpcre3 7.8-2 [215kB] Get:8 http://localhost sid/main libxml2 2.7.3.dfsg-2 [865kB] Get:9 http://localhost sid/main m4 1.4.13-1 [288kB] Get:10 http://localhost sid/main texinfo 4.13a.dfsg.1-4 [978kB] Get:11 http://localhost sid/main autoconf 2.63-3 [508kB] Get:12 http://localhost sid/main cl-asdf 1.111-1 [211kB] Get:13 http://localhost sid/main realpath 1.15 [16.2kB] Get:14 http://localhost sid/main common-lisp-controller 6.18 [33.3kB] Get:15 http://localhost sid/main cl-clx-sbcl 0.7.3-3 [449kB] Get:16 http://localhost sid/main cl-ppcre 2.0.1-1 [104kB] Get:17 http://localhost sid/main html2text 1.3.2a-14 [103kB] Get:18 http://localhost sid/main libglib2.0-0 2.20.4-1 [849kB] Get:19 http://localhost sid/main libcroco3 0.6.1-2 [123kB] Get:20 http://localhost sid/main libgomp1 4.4.0-10 [25.2kB] Get:21 http://localhost sid/main gettext 0.17-6 [2710kB] Get:22 http://localhost sid/main intltool-debian 0.35.0+20060710.1 [30.8kB] Get:23 http://localhost sid/main po-debconf 1.0.16 [224kB] Get:24 http://localhost sid/main debhelper 7.2.21 [544kB] Get:25 http://localhost sid/main dh-lisp 0.6.4 [9634B] Get:26 http://localhost sid/main diffstat 1.47-1 [24.2kB] Get:27 http://localhost sid/main quilt 0.46-7 [349kB] Get:28 http://localhost sid/main sbcl 1:1.0.29.11-1 [10.1MB] debconf: delaying package configuration, since apt-utils is not installed Fetched 21.9MB in 1min 35s (230kB/s) Selecting previously deselected package bsdmainutils. (Reading database ... (Reading database ... 5% (Reading database ... 10% (Reading database ... 15% (Reading database ... 20% (Reading database ... 25% (Reading database ... 30% (Reading database ... 35% (Reading database ... 40% (Reading database ... 45% (Reading database ... 50% (Reading database ... 55% (Reading database ... 60% (Reading database ... 65% (Reading database ... 70% (Reading database ... 75% (Reading database ... 80% (Reading database ... 85% (Reading database ... 90% (Reading database ... 95% (Reading database ... 100% (Reading database ... 9662 files and directories currently installed.) Unpacking bsdmainutils (from .../bsdmainutils_6.1.10_amd64.deb) ... Selecting previously deselected package groff-base. Unpacking groff-base (from .../groff-base_1.18.1.1-22_amd64.deb) ... Selecting previously deselected package man-db. Unpacking man-db (from .../man-db_2.5.5-2_amd64.deb) ... Selecting previously deselected package libmagic1. Unpacking libmagic1 (from .../libmagic1_5.03-1_amd64.deb) ... Selecting previously deselected package file. Unpacking file (from .../archives/file_5.03-1_amd64.deb) ... Selecting previously deselected package gettext-base. Unpacking gettext-base (from .../gettext-base_0.17-6_amd64.deb) ... Selecting previously deselected package libpcre3. Unpacking libpcre3 (from .../libpcre3_7.8-2_amd64.deb) ... Selecting previously deselected package libxml2. Unpacking libxml2 (from .../libxml2_2.7.3.dfsg-2_amd64.deb) ... Selecting previously deselected package m4. Unpacking m4 (from .../archives/m4_1.4.13-1_amd64.deb) ... Selecting previously deselected package texinfo. Unpacking texinfo (from .../texinfo_4.13a.dfsg.1-4_amd64.deb) ... Selecting previously deselected package autoconf. Unpacking autoconf (from .../autoconf_2.63-3_all.deb) ... Selecting previously deselected package cl-asdf. Unpacking cl-asdf (from .../cl-asdf_1.111-1_all.deb) ... Selecting previously deselected package realpath. Unpacking realpath (from .../realpath_1.15_amd64.deb) ... Selecting previously deselected package common-lisp-controller. Unpacking common-lisp-controller (from .../common-lisp-controller_6.18_all.deb) ... Selecting previously deselected package cl-clx-sbcl. Unpacking cl-clx-sbcl (from .../cl-clx-sbcl_0.7.3-3_all.deb) ... Selecting previously deselected package cl-ppcre. Unpacking cl-ppcre (from .../cl-ppcre_2.0.1-1_all.deb) ... Selecting previously deselected package html2text. Unpacking html2text (from .../html2text_1.3.2a-14_amd64.deb) ... Selecting previously deselected package libglib2.0-0. Unpacking libglib2.0-0 (from .../libglib2.0-0_2.20.4-1_amd64.deb) ... Selecting previously deselected package libcroco3. Unpacking libcroco3 (from .../libcroco3_0.6.1-2_amd64.deb) ... Selecting previously deselected package libgomp1. Unpacking libgomp1 (from .../libgomp1_4.4.0-10_amd64.deb) ... Selecting previously deselected package gettext. Unpacking gettext (from .../gettext_0.17-6_amd64.deb) ... Selecting previously deselected package intltool-debian. Unpacking intltool-debian (from .../intltool-debian_0.35.0+20060710.1_all.deb) ... Selecting previously deselected package po-debconf. Unpacking po-debconf (from .../po-debconf_1.0.16_all.deb) ... Selecting previously deselected package debhelper. Unpacking debhelper (from .../debhelper_7.2.21_all.deb) ... Selecting previously deselected package dh-lisp. Unpacking dh-lisp (from .../archives/dh-lisp_0.6.4_all.deb) ... Selecting previously deselected package diffstat. Unpacking diffstat (from .../diffstat_1.47-1_amd64.deb) ... Selecting previously deselected package quilt. Unpacking quilt (from .../archives/quilt_0.46-7_all.deb) ... Selecting previously deselected package sbcl. Unpacking sbcl (from .../sbcl_1%3a1.0.29.11-1_amd64.deb) ... Setting up bsdmainutils (6.1.10) ... update-alternatives: using /usr/bin/bsd-write to provide /usr/bin/write (write) in auto mode. Setting up groff-base (1.18.1.1-22) ... Setting up man-db (2.5.5-2) ... Building database of manual pages ... Setting up libmagic1 (5.03-1) ... Setting up file (5.03-1) ... Setting up gettext-base (0.17-6) ... Setting up libpcre3 (7.8-2) ... Setting up libxml2 (2.7.3.dfsg-2) ... Setting up m4 (1.4.13-1) ... Setting up texinfo (4.13a.dfsg.1-4) ... Setting up autoconf (2.63-3) ... Setting up cl-asdf (1.111-1) ... Reinstalling for sbcl Recompiling Common Lisp Controller for sbcl /usr/lib/common-lisp/bin/sbcl.sh loading and dumping clc. ; loading system definition from /usr/lib/sbcl/sb-grovel/sb-grovel.asd into ; # ; registering # as SB-GROVEL [undoing binding stack and other enclosing state... done] [saving current Lisp image into sbcl-new.core: writing 6176 bytes from the read-only space at 0x20000000 writing 4064 bytes from the static space at 0x20100000 writing 44417024 bytes from the dynamic space at 0x1000000000 done] Done rebuilding Setting up realpath (1.15) ... Setting up common-lisp-controller (6.18) ... Reinstalling for sbcl Recompiling Common Lisp Controller for sbcl /usr/lib/common-lisp/bin/sbcl.sh loading and dumping clc. ; loading system definition from /usr/lib/sbcl/sb-grovel/sb-grovel.asd into ; # ; registering # as SB-GROVEL [undoing binding stack and other enclosing state... done] [saving current Lisp image into sbcl-new.core: writing 6176 bytes from the read-only space at 0x20000000 writing 4064 bytes from the static space at 0x20100000 writing 44417024 bytes from the dynamic space at 0x1000000000 done] Done rebuilding Setting up cl-clx-sbcl (0.7.3-3) ... Setting up cl-ppcre (2.0.1-1) ... Setting up html2text (1.3.2a-14) ... Setting up libglib2.0-0 (2.20.4-1) ... Setting up libcroco3 (0.6.1-2) ... Setting up libgomp1 (4.4.0-10) ... Setting up gettext (0.17-6) ... Setting up intltool-debian (0.35.0+20060710.1) ... Setting up po-debconf (1.0.16) ... Setting up debhelper (7.2.21) ... Setting up dh-lisp (0.6.4) ... Setting up diffstat (1.47-1) ... Setting up quilt (0.46-7) ... Setting up sbcl (1:1.0.29.11-1) ... /usr/lib/common-lisp/bin/sbcl.sh loading and dumping clc. ; loading system definition from /usr/lib/sbcl/sb-grovel/sb-grovel.asd into ; # ; registering # as SB-GROVEL [undoing binding stack and other enclosing state... done] [saving current Lisp image into sbcl-new.core: writing 6176 bytes from the read-only space at 0x20000000 writing 4064 bytes from the static space at 0x20100000 writing 44408832 bytes from the dynamic space at 0x1000000000 done] Removing negative dependencies: Checking correctness of source dependencies... Kernel: Linux 2.6.26-2-amd64 amd64 (x86_64) Toolchain package versions: libc6-dev_2.9-19 linux-libc-dev_2.6.30-2 g++-4.3_4.3.3-13 gcc-4.3_4.3.3-13 binutils_2.19.51.20090704-1 libstdc++6_4.4.0-10 libstdc++6-4.3-dev_4.3.3-13 ┌──────────────────────────────────────────────────────────────────────────────┐ │ Build │ └──────────────────────────────────────────────────────────────────────────────┘ Unpack source ───────────── gpgv: keyblock resource `/home/user/.gnupg/trustedkeys.gpg': general error gpgv: Signature made Fri May 8 10:41:30 2009 CEST using RSA key ID 68440D33 gpgv: Can't check signature: public key not found dpkg-source: warning: failed to verify signature on ./stumpwm_20090502.git482df740-1.dsc dpkg-source: info: extracting stumpwm in stumpwm-20090502.git482df740 dpkg-source: info: unpacking stumpwm_20090502.git482df740.orig.tar.gz dpkg-source: info: applying stumpwm_20090502.git482df740-1.diff.gz Check disc space ──────────────── dpkg-buildpackage ───────────────── dpkg-buildpackage: set CFLAGS to default value: -g -O2 dpkg-buildpackage: set CPPFLAGS to default value: dpkg-buildpackage: set LDFLAGS to default value: dpkg-buildpackage: set FFLAGS to default value: -g -O2 dpkg-buildpackage: set CXXFLAGS to default value: -g -O2 dpkg-buildpackage: source package stumpwm dpkg-buildpackage: source version 1:20090502.git482df740-1 dpkg-buildpackage: source changed by Luca Capello dpkg-buildpackage: host architecture amd64 /usr/bin/fakeroot debian/rules clean QUILT_PATCHES=debian/patches quilt --quiltrc /dev/null pop -a -R || test $? = 2 No patch removed rm -rf .pc debian/stamp-patched dh_testdir dh_testroot [ ! -f Makefile ] || /usr/bin/make clean rm -rf autom4te.cache Makefile make-image.lisp version.lisp config.log config.status configure dh_clean dpkg-source -b stumpwm-20090502.git482df740 dpkg-source: info: using source format `1.0' dpkg-source: info: building stumpwm using existing stumpwm_20090502.git482df740.orig.tar.gz dpkg-source: info: building stumpwm in stumpwm_20090502.git482df740-1.diff.gz dpkg-source: info: building stumpwm in stumpwm_20090502.git482df740-1.dsc debian/rules build # quilt exits with 2 as return when there was nothing to do. # That's not an error here (but it's useful to break loops in crude scripts) QUILT_PATCHES=debian/patches quilt --quiltrc /dev/null push -a || test $? = 2 Applying patch 02_correct-Stumpwm-StumpWM-in-README.diff patching file README Applying patch 04_default-to-x-terminal-emulator.diff patching file bindings.lisp patching file sample-stumpwmrc.lisp Applying patch 05_default-to-x-www-browser.diff patching file sample-stumpwmrc.lisp Applying patch 06_add-upstream-changelog.diff patching file ChangeLog Now at patch 06_add-upstream-changelog.diff touch debian/stamp-patched ./autogen.sh ./configure --with-lisp=sbcl \ --with-ppcre=/usr/share/common-lisp/source/cl-ppcre checking for sbcl... /usr/bin/sbcl checking for clisp... no checking for openmcl... no configure: Using sbcl at /usr/bin/sbcl checking for makeinfo... yes checking for xdpyinfo... no 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 sed -e 's/@PACKAGE_VERSION@/Debian Git checkout 1:20090502.git482df740-1/' version.lisp.in >version.lisp /usr/bin/make stumpwm.info make[1]: Entering directory `/build/user-stumpwm_20090502.git482df740-1-amd64-iymCWB/stumpwm-20090502.git482df740' /usr/bin/sbcl --eval "(progn (require 'asdf) (require 'stumpwm) (load \"manual.lisp\"))" --eval "(progn (stumpwm::generate-manual) (sb-ext:quit))" This is SBCL 1.0.29.11.debian, an implementation of ANSI Common Lisp. More information about SBCL is available at . 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/share/common-lisp/systems/clx.asd into ; # ; registering # as CLX ; loading system definition from ; /usr/lib/sbcl/sb-bsd-sockets/sb-bsd-sockets.asd into # ; registering # as SB-BSD-SOCKETS ; registering # as ; SB-BSD-SOCKETS-TESTS ; loading system definition from /usr/share/common-lisp/systems/cl-ppcre.asd ; into # ; registering # as CL-PPCRE ; registering # as CL-PPCRE-TEST ; compiling file "/usr/share/common-lisp/source/clx/package.lisp" (written 14 JUL 2005 03:24:44 PM): ; compiling (IN-PACKAGE :COMMON-LISP-USER) ; compiling (DEFPACKAGE XLIB ...) ; /var/cache/common-lisp-controller/1001/sbcl/clx/package.fasl written ; compilation finished in 0:00:00.016 ; compiling file "/usr/share/common-lisp/source/clx/depdefs.lisp" (written 28 JUL 2008 07:32:15 PM): ; compiling (IN-PACKAGE :XLIB) ; compiling (DECLAIM (DECLARATION CLX-VALUES)) ; compiling (DECLAIM (DECLARATION ARGLIST)) ; compiling (DECLAIM (DECLARATION INDENTATION)) ; compiling (DEFMACRO WITH-VECTOR ...) ; compiling (DEFMACRO WITHIN-DEFINITION ...) ; compiling (DEFCONSTANT +CLX-CACHED-TYPES+ ...) ; compiling (DEFMACRO RESOURCE-ID-MAP-TEST ...) ; compiling (DEFMACRO ATOM-CACHE-MAP-TEST ...) ; compiling (DEFMACRO KEYSYM->CHARACTER-MAP-TEST ...) ; compiling (ECASE SB-C:*BACKEND-BYTE-ORDER* ...) ; compiling (DEFTYPE BUFFER-BYTES ...) ; compiling (DEFTYPE ARRAY-INDEX ...) ; compiling (DEFUN MAKE-INDEX-TYPED ...) ; compiling (DEFUN MAKE-INDEX-OP ...) ; compiling (DEFMACRO INDEX+ ...) ; compiling (DEFMACRO INDEX-LOGAND ...) ; compiling (DEFMACRO INDEX-LOGIOR ...) ; compiling (DEFMACRO INDEX- ...) ; compiling (DEFMACRO INDEX* ...) ; compiling (DEFMACRO INDEX1+ ...) ; compiling (DEFMACRO INDEX1- ...) ; compiling (DEFMACRO INDEX-INCF ...) ; compiling (DEFMACRO INDEX-DECF ...) ; compiling (DEFMACRO INDEX-MIN ...) ; compiling (DEFMACRO INDEX-MAX ...) ; compiling (DEFMACRO INDEX-FLOOR ...) ; compiling (DEFMACRO INDEX-CEILING ...) ; compiling (DEFMACRO INDEX-TRUNCATE ...) ; compiling (DEFMACRO INDEX-MOD ...) ; compiling (DEFMACRO INDEX-ASH ...) ; compiling (DEFMACRO INDEX-PLUSP ...) ; compiling (DEFMACRO INDEX-ZEROP ...) ; compiling (DEFMACRO INDEX-EVENP ...) ; compiling (DEFMACRO INDEX-ODDP ...) ; compiling (DEFMACRO INDEX> ...) ; compiling (DEFMACRO INDEX= ...) ; compiling (DEFMACRO INDEX< ...) ; compiling (DEFMACRO INDEX>= ...) ; compiling (DEFMACRO INDEX<= ...) ; compiling (DEFCONSTANT +REPLYSIZE+ ...) ; compiling (DEFVAR *EMPTY-BYTES* ...) ; compiling (DECLAIM (TYPE BUFFER-BYTES ...)) ; compiling (DEFSTRUCT (REPLY-BUFFER # ...) ...) ; compiling (DEFCONSTANT +BUFFER-TEXT16-SIZE+ ...) ; compiling (DEFTYPE BUFFER-TEXT16 ...) ; compiling (DEFPARAMETER *XLIB-PACKAGE* ...) ; compiling (DEFUN XINTERN ...) ; compiling (DEFPARAMETER *KEYWORD-PACKAGE* ...) ; compiling (DEFUN KINTERN ...) ; compiling (DEFVAR *DEF-CLX-CLASS-USE-DEFCLASS* ...) ; compiling (DEFMACRO DEF-CLX-CLASS ...) ; compiling (DEF-CLX-CLASS (BUFFER # ...) ...) ; compiling (DEFCONSTANT +IMAGE-BIT-LSB-FIRST-P+ ...) ; compiling (DEFCONSTANT +IMAGE-BYTE-LSB-FIRST-P+ ...) ; compiling (DEFCONSTANT +IMAGE-UNIT+ ...) ; compiling (DEFCONSTANT +IMAGE-PAD+ ...) ; /var/cache/common-lisp-controller/1001/sbcl/clx/depdefs.fasl written ; compilation finished in 0:00:00.359 ; compiling file "/usr/share/common-lisp/source/clx/clx.lisp" (written 28 JUL 2008 07:32:15 PM): ; compiling (IN-PACKAGE :XLIB) ; compiling (PUSHNEW :CLX ...) ; compiling (PUSHNEW :XLIB ...) ; compiling (DEFPARAMETER *VERSION* ...) ; compiling (PUSHNEW :CLX-MIT-R4 ...) ; compiling (PUSHNEW :CLX-MIT-R5 ...) ; compiling (DEFPARAMETER *PROTOCOL-MAJOR-VERSION* ...) ; compiling (DEFPARAMETER *PROTOCOL-MINOR-VERSION* ...) ; compiling (DEFPARAMETER *X-TCP-PORT* ...) ; compiling (DEFTYPE GENERALIZED-BOOLEAN ...) ; compiling (DEFTYPE CARD32 ...) ; compiling (DEFTYPE CARD29 ...) ; compiling (DEFTYPE CARD24 ...) ; compiling (DEFTYPE INT32 ...) ; compiling (DEFTYPE CARD16 ...) ; compiling (DEFTYPE INT16 ...) ; compiling (DEFTYPE CARD8 ...) ; compiling (DEFTYPE INT8 ...) ; compiling (DEFTYPE CARD4 ...) ; compiling (DEFTYPE CHAR8 ...) ; compiling (DEFTYPE RGB-VAL ...) ; compiling (DEFTYPE ANGLE ...) ; compiling (DEFTYPE MASK32 ...) ; compiling (DEFTYPE MASK16 ...) ; compiling (DEFTYPE PIXEL ...) ; compiling (DEFTYPE IMAGE-DEPTH ...) ; compiling (DEFTYPE RESOURCE-ID ...) ; compiling (DEFTYPE KEYSYM ...) ; compiling (DEF-CLX-CLASS (COLOR # ...) ...) ; compiling (DEFUN PRINT-COLOR ...) ; compiling (DEFUN MAKE-COLOR ...) ; compiling (DEFUN COLOR-RGB ...) ; compiling (DEF-CLX-CLASS (BITMAP-FORMAT # ...) ...) ; compiling (DEFUN PRINT-BITMAP-FORMAT ...) ; compiling (DEF-CLX-CLASS (PIXMAP-FORMAT # ...) ...) ; compiling (DEFUN PRINT-PIXMAP-FORMAT ...) ; compiling (DEFPARAMETER *ATOM-CACHE-SIZE* ...) ; compiling (DEFPARAMETER *RESOURCE-ID-MAP-SIZE* ...) ; compiling (DEF-CLX-CLASS (DISPLAY # ...) ...) ; compiling (DEFUN PRINT-DISPLAY-NAME ...) ; compiling (DEFUN PRINT-DISPLAY ...) ; compiling (DEF-CLX-CLASS (DRAWABLE # ...) ...) ; compiling (DEFUN PRINT-DRAWABLE ...) ; compiling (DEF-CLX-CLASS (WINDOW # ...)) ; compiling (DEF-CLX-CLASS (PIXMAP # ...)) ; compiling (DEF-CLX-CLASS (VISUAL-INFO # ...) ...) ; compiling (DEFUN PRINT-VISUAL-INFO ...) ; compiling (DEF-CLX-CLASS (COLORMAP # ...) ...) ; compiling (DEFUN PRINT-COLORMAP ...) ; compiling (DEF-CLX-CLASS (CURSOR # ...) ...) ; compiling (DEFUN PRINT-CURSOR ...) ; compiling (DEFTYPE XATOM ...) ; compiling (DEFCONSTANT +PREDEFINED-ATOMS+ ...) ; compiling (DEFTYPE STRINGABLE ...) ; compiling (DEFTYPE FONTABLE ...) ; compiling (DEFTYPE TIMESTAMP ...) ; compiling (DEFCONSTANT +BIT-GRAVITY-VECTOR+ ...) ; compiling (DEFTYPE BIT-GRAVITY ...) ; compiling (DEFCONSTANT +WIN-GRAVITY-VECTOR+ ...) ; compiling (DEFPARAMETER *PROTOCOL-FAMILIES* ...) ; compiling (DEFTYPE WIN-GRAVITY ...) ; compiling (DEFTYPE GRAB-STATUS ...) ; compiling (DEFTYPE ALIST ...) ; compiling (DEFTYPE CLX-LIST ...) ; compiling (DEFTYPE CLX-SEQUENCE ...) ; compiling (DEFTYPE REPEAT-SEQ ...) ; compiling (DEFTYPE POINT-SEQ ...) ; compiling (DEFTYPE SEG-SEQ ...) ; compiling (DEFTYPE RECT-SEQ ...) ; compiling (DEFTYPE ARC-SEQ ...) ; compiling (DEFTYPE GCONTEXT-STATE ...) ; compiling (DEF-CLX-CLASS (GCONTEXT # ...) ...) ; compiling (DEFUN PRINT-GCONTEXT ...) ; compiling (DEFCONSTANT +EVENT-MASK-VECTOR+ ...) ; compiling (DEFTYPE EVENT-MASK-CLASS ...) ; compiling (DEFTYPE EVENT-MASK ...) ; compiling (DEFCONSTANT +POINTER-EVENT-MASK-VECTOR+ ...) ; compiling (DEFTYPE POINTER-EVENT-MASK-CLASS ...) ; compiling (DEFTYPE POINTER-EVENT-MASK ...) ; compiling (DEFCONSTANT +DEVICE-EVENT-MASK-VECTOR+ ...) ; compiling (DEFTYPE DEVICE-EVENT-MASK-CLASS ...) ; compiling (DEFTYPE DEVICE-EVENT-MASK ...) ; compiling (DEFCONSTANT +STATE-MASK-VECTOR+ ...) ; compiling (DEFTYPE MODIFIER-KEY ...) ; compiling (DEFTYPE MODIFIER-MASK ...) ; compiling (DEFTYPE STATE-MASK-KEY ...) ; compiling (DEFCONSTANT +GCONTEXT-COMPONENTS+ ...) ; compiling (DEFTYPE GCONTEXT-KEY ...) ; compiling (DEFTYPE EVENT-KEY ...) ; compiling (DEFTYPE ERROR-KEY ...) ; compiling (DEFTYPE DRAW-DIRECTION ...) ; compiling (DEFCONSTANT +BOOLE-VECTOR+ ...) ; compiling (DEFTYPE BOOLE-CONSTANT ...) ; compiling (DEF-CLX-CLASS (SCREEN # ...) ...) ; compiling (DEFUN PRINT-SCREEN ...) ; compiling (DEFUN SCREEN-ROOT-VISUAL ...) ; compiling (DEFTYPE FONT-PROPS ...) ; compiling (DEF-CLX-CLASS (FONT-INFO # ...) ...) ; compiling (DEF-CLX-CLASS (FONT # ...) ...) ; compiling (DEFUN PRINT-FONT ...) ; compiling (DEFUN FONT-ID ...) ; compiling (DEFUN FONT-FONT-INFO ...) ; compiling (DEFUN FONT-CHAR-INFOS ...) ; compiling (DEFUN MAKE-FONT ...) ; compiling (MAKE-FONT-INFO-ACCESSORS IGNORE ...) ; compiling (DEFUN FONT-PROPERTY ...) ; compiling (MAKE-MUMBLE-EQUAL WINDOW) ; compiling (MAKE-MUMBLE-EQUAL PIXMAP) ; compiling (MAKE-MUMBLE-EQUAL CURSOR) ; compiling (MAKE-MUMBLE-EQUAL FONT) ; compiling (MAKE-MUMBLE-EQUAL GCONTEXT) ; compiling (MAKE-MUMBLE-EQUAL COLORMAP) ; compiling (MAKE-MUMBLE-EQUAL DRAWABLE) ; compiling (DEFUN ENCODE-MASK ...) ; compiling (DEFUN DECODE-MASK ...) ; file: /usr/share/common-lisp/source/clx/clx.lisp ; in: DEFUN ENCODE-EVENT-MASK ; (XLIB::X-TYPE-ERROR XLIB:EVENT-MASK 'XLIB:EVENT-MASK) ; ==> ; XLIB:EVENT-MASK ; ; note: deleting unreachable code ; compiling (DEFUN ENCODE-EVENT-MASK ...) ; compiling (DEFUN MAKE-EVENT-MASK ...) ; compiling (DEFUN MAKE-EVENT-KEYS ...) ; file: /usr/share/common-lisp/source/clx/clx.lisp ; in: DEFUN ENCODE-DEVICE-EVENT-MASK ; (XLIB::X-TYPE-ERROR XLIB:DEVICE-EVENT-MASK 'XLIB:DEVICE-EVENT-MASK) ; ==> ; XLIB:DEVICE-EVENT-MASK ; ; note: deleting unreachable code ; compiling (DEFUN ENCODE-DEVICE-EVENT-MASK ...) ; file: /usr/share/common-lisp/source/clx/clx.lisp ; in: DEFUN ENCODE-MODIFIER-MASK ; (XLIB::X-TYPE-ERROR XLIB:MODIFIER-MASK 'XLIB:MODIFIER-MASK) ; ==> ; XLIB:MODIFIER-MASK ; ; note: deleting unreachable code ; compiling (DEFUN ENCODE-MODIFIER-MASK ...) ; file: /usr/share/common-lisp/source/clx/clx.lisp ; in: DEFUN ENCODE-STATE-MASK ; (XLIB::X-TYPE-ERROR XLIB::STATE-MASK ; '(OR XLIB:MASK16 (XLIB::CLX-LIST XLIB:STATE-MASK-KEY))) ; ==> ; XLIB::STATE-MASK ; ; note: deleting unreachable code ; compiling (DEFUN ENCODE-STATE-MASK ...) ; compiling (DEFUN MAKE-STATE-MASK ...) ; compiling (DEFUN MAKE-STATE-KEYS ...) ; file: /usr/share/common-lisp/source/clx/clx.lisp ; in: DEFUN ENCODE-POINTER-EVENT-MASK ; (XLIB::X-TYPE-ERROR XLIB:POINTER-EVENT-MASK 'XLIB:POINTER-EVENT-MASK) ; ==> ; XLIB:POINTER-EVENT-MASK ; ; note: deleting unreachable code ; compiling (DEFUN ENCODE-POINTER-EVENT-MASK ...) ; /var/cache/common-lisp-controller/1001/sbcl/clx/clx.fasl written ; compilation finished in 0:00:00.870 ; compiling file "/usr/share/common-lisp/source/clx/dependent.lisp" (written 28 JUL 2008 07:32:15 PM): ; compiling (IN-PACKAGE :XLIB) ; compiling (PROCLAIM (QUOTE #)) ; compiling (DEFPARAMETER *OUTPUT-BUFFER-SIZE* ...) ; compiling (DEFPARAMETER *REPLY-TIMEOUT* ...) ; compiling (DEFCONSTANT +WORD-0+ ...) ; compiling (DEFCONSTANT +WORD-1+ ...) ; compiling (DEFCONSTANT +LONG-0+ ...) ; compiling (DEFCONSTANT +LONG-1+ ...) ; compiling (DEFCONSTANT +LONG-2+ ...) ; compiling (DEFCONSTANT +LONG-3+ ...) ; compiling (DEFCONSTANT +BUFFER-SPEED+ ...) ; compiling (DEFCONSTANT +BUFFER-SAFETY+ ...) ; compiling (DEFCONSTANT +BUFFER-DEBUG+ ...) ; compiling (DEFUN DECLARE-BUFMAC ...) ; compiling (DEFUN DECLARE-BUFFUN ...) ; compiling (DECLAIM (INLINE CARD8->INT8 ...)) ; compiling (DEFUN CARD8->INT8 ...) ; compiling (DEFUN INT8->CARD8 ...) ; compiling (DEFUN CARD16->INT16 ...) ; compiling (DEFUN INT16->CARD16 ...) ; compiling (DEFUN CARD32->INT32 ...) ; compiling (DEFUN INT32->CARD32 ...) ; compiling (DECLAIM (INLINE AREF-CARD8 ...)) ; compiling (DEFUN AREF-CARD8 ...) ; compiling (DEFUN ASET-CARD8 ...) ; compiling (DEFUN AREF-INT8 ...) ; compiling (DEFUN ASET-INT8 ...) ; compiling (DEFUN AREF-CARD16 ...) ; compiling (DEFUN ASET-CARD16 ...) ; compiling (DEFUN AREF-INT16 ...) ; compiling (DEFUN ASET-INT16 ...) ; compiling (DEFUN AREF-CARD32 ...) ; compiling (DEFUN ASET-CARD32 ...) ; compiling (DEFUN AREF-INT32 ...) ; compiling (DEFUN ASET-INT32 ...) ; compiling (DEFUN AREF-CARD29 ...) ; compiling (DEFUN ASET-CARD29 ...) ; compiling (DEFSETF AREF-CARD8 ...) ; compiling (DEFSETF AREF-INT8 ...) ; compiling (DEFSETF AREF-CARD16 ...) ; compiling (DEFSETF AREF-INT16 ...) ; compiling (DEFSETF AREF-CARD32 ...) ; compiling (DEFSETF AREF-INT32 ...) ; compiling (DEFSETF AREF-CARD29 ...) ; compiling (DEFUN RGB-VAL->CARD16 ...) ; compiling (DEFUN CARD16->RGB-VAL ...) ; compiling (DEFUN RADIANS->INT16 ...) ; compiling (DEFUN INT16->RADIANS ...) ; compiling (DEFTYPE ANGLE ...) ; compiling (DEFUN ANGLEP ...) ; compiling (DECLAIM (INLINE CHAR->CARD8 ...)) ; compiling (CHAR-TRANSLATORS) ; compiling (DEFUN MAKE-PROCESS-LOCK ...) ; compiling (DEFMACRO HOLDING-LOCK ...) ; compiling (DEFMACRO WITHOUT-ABORTS ...) ; compiling (DECLAIM (INLINE YIELD)) ; compiling (DEFUN YIELD ...) ; compiling (DEFUN PROCESS-BLOCK ...) ; compiling (DECLAIM (INLINE PROCESS-WAKEUP)) ; compiling (DEFUN PROCESS-WAKEUP ...) ; compiling (DECLAIM (INLINE CURRENT-PROCESS)) ; compiling (DEFUN CURRENT-PROCESS ...) ; compiling (DEFMACRO WITHOUT-INTERRUPTS ...) ; compiling (DEFVAR *WITHOUT-INTERRUPTS-SIC-LOCK* ...) ; compiling (DEFMACRO WITHOUT-INTERRUPTS ...) ; compiling (DEFVAR *CONDITIONAL-STORE-LOCK* ...) ; compiling (DEFMACRO CONDITIONAL-STORE ...) ; compiling (DEFMACRO WRAP-BUF-OUTPUT ...) ; compiling (DEFMACRO WRAP-BUF-INPUT ...) ; compiling (DEFCONSTANT +X-UNIX-SOCKET-PATH+ ...) ; compiling (DEFUN OPEN-X-STREAM ...) ; file: /usr/share/common-lisp/source/clx/dependent.lisp ; in: DEFUN BUFFER-READ-DEFAULT ; (SB-SYS:READ-N-BYTES (XLIB::DISPLAY-INPUT-STREAM XLIB:DISPLAY) VECTOR ; XLIB::START (- XLIB::END XLIB::START)) ; --> BLOCK IF LET* SB-IMPL::EOF-OR-LOSE IF AND IF AND THE ; ==> ; (< SB-IMPL::READ-END SB-IMPL::END) ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first argument is a REAL, not a FLOAT. ; ; note: forced to do GENERIC-< (cost 10) ; unable to do inline fixnum comparison (cost 4) because: ; The first argument is a REAL, not a FIXNUM. ; The second argument is a (INTEGER -1152921504606846973 ; 2305843009213693946), not a FIXNUM. ; --> BLOCK IF LET* ; ==> ; (+ SB-IMPL::START SB-IMPL::NUMBYTES) ; ; note: doing signed word to integer coercion (cost 20), for: ; the first result of inline (signed-byte 64) arithmetic ; compiling (DEFUN BUFFER-READ-DEFAULT ...) ; compiling (DEFUN BUFFER-WRITE-DEFAULT ...) ; compiling (DEFUN BUFFER-FORCE-OUTPUT-DEFAULT ...) ; compiling (DEFUN BUFFER-CLOSE-DEFAULT ...) ; compiling (DEFUN BUFFER-INPUT-WAIT-DEFAULT ...) ; compiling (DEFUN BUFFER-LISTEN-DEFAULT ...) ; compiling (DEFMACRO WITH-STACK-LIST ...) ; compiling (DEFMACRO WITH-STACK-LIST* ...) ; compiling (DECLAIM (INLINE BUFFER-REPLACE)) ; compiling (DEFUN BUFFER-REPLACE ...) ; compiling (DEFMACRO WITH-GCONTEXT-BINDINGS ...) ; compiling (DEFCONSTANT +TYPE-CHECK?+ ...) ; compiling (DEFMACRO TYPE? ...) ; compiling (DEFUN X-TYPE-ERROR ...) ; compiling (DEFUN DEFAULT-ERROR-HANDLER ...) ; compiling (DEFUN X-ERROR ...) ; compiling (DEFUN X-CERROR ...) ; compiling (DEFINE-CONDITION X-ERROR ...) ; compiling (DEFUN HOST-ADDRESS ...) ; compiling (DEFMACRO USE-CLOSURES ...) ; compiling (DEFUN CLX-MACROEXPAND ...) ; compiling (DEFUN GETENV ...) ; compiling (DEFUN GET-HOST-NAME ...) ; compiling (DEFUN HOMEDIR-FILE-PATHNAME ...) ; compiling (DEFUN DEFAULT-RESOURCES-PATHNAME ...) ; compiling (DEFUN RESOURCES-PATHNAME ...) ; compiling (DEFUN AUTHORITY-PATHNAME ...) ; compiling (DEFUN GET-DEFAULT-DISPLAY ...) ; compiling (DEFUN GC-CLEANUP ...) ; compiling (DEFUN DEFAULT-KEYSYM-TRANSLATE ...) ; compiling (DEFTYPE PIXARRAY-1-ELEMENT-TYPE ...) ; compiling (DEFTYPE PIXARRAY-4-ELEMENT-TYPE ...) ; compiling (DEFTYPE PIXARRAY-8-ELEMENT-TYPE ...) ; compiling (DEFTYPE PIXARRAY-16-ELEMENT-TYPE ...) ; compiling (DEFTYPE PIXARRAY-24-ELEMENT-TYPE ...) ; compiling (DEFTYPE PIXARRAY-32-ELEMENT-TYPE ...) ; compiling (DEFTYPE PIXARRAY-1 ...) ; compiling (DEFTYPE PIXARRAY-4 ...) ; compiling (DEFTYPE PIXARRAY-8 ...) ; compiling (DEFTYPE PIXARRAY-16 ...) ; compiling (DEFTYPE PIXARRAY-24 ...) ; compiling (DEFTYPE PIXARRAY-32 ...) ; compiling (DEFTYPE PIXARRAY ...) ; compiling (DEFTYPE BITMAP ...) ; compiling (DEFMACRO WITH-UNDERLYING-SIMPLE-VECTOR ...) ; compiling (DEFMACRO READ-IMAGE-LOAD-BYTE ...) ; compiling (DEFMACRO READ-IMAGE-ASSEMBLE-BYTES ...) ; compiling (DEFMACRO WRITE-IMAGE-LOAD-BYTE ...) ; compiling (DEFMACRO WRITE-IMAGE-ASSEMBLE-BYTES ...) ; compiling (DEFUN FAST-READ-PIXARRAY-24 ...) ; compiling (DEFUN PIXARRAY-ELEMENT-SIZE ...) ; compiling (DEFUN COPY-BIT-RECT ...) ; compiling (DEFUN FAST-READ-PIXARRAY-USING-BITBLT ...) ; file: /usr/share/common-lisp/source/clx/dependent.lisp ; in: DEFUN FAST-READ-PIXARRAY ; (XLIB::READ-PIXARRAY-INTERNAL XLIB::BBUF XLIB::BOFFSET XLIB:PIXARRAY XLIB::X ; XLIB::Y XLIB::WIDTH XLIB::HEIGHT XLIB::PADDED-BYTES-PER-LINE ; XLIB::BITS-PER-PIXEL FUNCTION XLIB::UNIT ...) ; ==> ; XLIB::BBUF ; ; note: deleting unreachable code ; compiling (DEFUN FAST-READ-PIXARRAY ...) ; compiling (DEFUN FAST-WRITE-PIXARRAY-24 ...) ; file: /usr/share/common-lisp/source/clx/dependent.lisp ; in: DEFUN FAST-WRITE-PIXARRAY-USING-BITBLT ; (ARRAY-DIMENSION XLIB:PIXARRAY 1) ; ; note: unable to ; optimize ; because: ; The array dimensions are unknown; must call ARRAY-DIMENSION at runtime. ; compiling (DEFUN FAST-WRITE-PIXARRAY-USING-BITBLT ...) ; file: /usr/share/common-lisp/source/clx/dependent.lisp ; in: DEFUN FAST-WRITE-PIXARRAY ; (XLIB::WRITE-PIXARRAY-INTERNAL XLIB::BBUF XLIB::BOFFSET XLIB:PIXARRAY XLIB::X ; XLIB::Y XLIB::WIDTH XLIB::HEIGHT XLIB::PADDED-BYTES-PER-LINE ; XLIB::BITS-PER-PIXEL FUNCTION XLIB::+IMAGE-UNIT+ ...) ; ==> ; XLIB::BBUF ; ; note: deleting unreachable code ; compiling (DEFUN FAST-WRITE-PIXARRAY ...) ; compiling (DEFUN FAST-COPY-PIXARRAY ...) ; /var/cache/common-lisp-controller/1001/sbcl/clx/dependent.fasl written ; compilation finished in 0:00:00.781 ; compiling file "/usr/share/common-lisp/source/clx/macros.lisp" (written 14 JUL 2005 03:24:44 PM): ; compiling (IN-PACKAGE :XLIB) ; compiling (DEFMACRO TYPE-CHECK ...) ; compiling (DEFVAR *REQUIRED-ARG-DUMMY*) ; compiling (DEFMACRO REQUIRED-ARG ...) ; compiling (DEFMACRO LROUND ...) ; compiling (DEFMACRO WROUND ...) ; compiling (DEFUN INDEX-INCREMENT ...) ; compiling (DEFUN GETIFY ...) ; compiling (DEFUN PUTIFY ...) ; compiling (DEFMACRO DEFINE-ACCESSOR ...) ; compiling (DEFINE-ACCESSOR CARD32 ...) ; compiling (DEFINE-ACCESSOR CARD29 ...) ; compiling (DEFINE-ACCESSOR CARD16 ...) ; compiling (DEFINE-ACCESSOR CARD8 ...) ; compiling (DEFINE-ACCESSOR INTEGER ...) ; compiling (DEFINE-ACCESSOR INT16 ...) ; compiling (DEFINE-ACCESSOR RGB-VAL ...) ; compiling (DEFINE-ACCESSOR ANGLE ...) ; compiling (DEFINE-ACCESSOR BIT ...) ; compiling (DEFINE-ACCESSOR BOOLEAN ...) ; compiling (DEFINE-ACCESSOR DRAWABLE ...) ; compiling (DEFINE-ACCESSOR WINDOW ...) ; compiling (DEFINE-ACCESSOR PIXMAP ...) ; compiling (DEFINE-ACCESSOR GCONTEXT ...) ; compiling (DEFINE-ACCESSOR CURSOR ...) ; compiling (DEFINE-ACCESSOR COLORMAP ...) ; compiling (DEFINE-ACCESSOR FONT ...) ; compiling (DEFINE-ACCESSOR KEYWORD ...) ; compiling (DEFINE-ACCESSOR RESOURCE-ID ...) ; compiling (DEFINE-ACCESSOR RESOURCE-ID-OR-NIL ...) ; compiling (DEFMACRO CHAR-INFO-GET ...) ; compiling (DEFINE-ACCESSOR MEMBER8 ...) ; compiling (DEFINE-ACCESSOR MEMBER16 ...) ; compiling (DEFINE-ACCESSOR MEMBER ...) ; compiling (DEFTYPE MEMBER-VECTOR ...) ; compiling (DEFINE-ACCESSOR MEMBER-VECTOR ...) ; compiling (DEFINE-ACCESSOR MEMBER16-VECTOR ...) ; compiling (DEFINE-ACCESSOR MEMBER8-VECTOR ...) ; compiling (DEFINE-ACCESSOR BOOLE-CONSTANT ...) ; compiling (DEFINE-ACCESSOR NULL ...) ; compiling (DEFINE-ACCESSOR PAD8 ...) ; compiling (DEFINE-ACCESSOR PAD16 ...) ; compiling (DEFINE-ACCESSOR BIT-VECTOR256 ...) ; compiling (DEFINE-ACCESSOR STRING ...) ; compiling (DEFINE-ACCESSOR SEQUENCE ...) ; compiling (DEFMACRO CLIENT-MESSAGE-EVENT-GET-SEQUENCE ...) ; compiling (DEFMACRO CLIENT-MESSAGE-EVENT-PUT-SEQUENCE ...) ; compiling (DEFINE-ACCESSOR CLIENT-MESSAGE-SEQUENCE ...) ; compiling (DEFINE-ACCESSOR CODE ...) ; compiling (DEFINE-ACCESSOR LENGTH ...) ; compiling (DEFTYPE DATA ...) ; compiling (DEFINE-ACCESSOR DATA ...) ; compiling (DEFMACRO OR-EXPAND ...) ; compiling (DEFINE-ACCESSOR OR ...) ; compiling (SETF (GET # ...) ...) ; file: /usr/share/common-lisp/source/clx/macros.lisp ; in: DEFUN MASK-GET ; (DEFUN XLIB::MASK-GET (XLIB::INDEX XLIB::TYPE-VALUES XLIB::BODY-FUNCTION) ; (DECLARE (TYPE FUNCTION XLIB::BODY-FUNCTION) ; (DYNAMIC-EXTENT XLIB::BODY-FUNCTION)) ; (LET* ((BIT 0) (XLIB::RESULT (MAPCAR #'# #))) ; `(,@(WHEN (ATOM #) (LIST #)) ; (PROGN (SETQ XLIB::%MASK #) (SETQ XLIB::%INDEX ,#) ,(CAR XLIB::RESULT)) ; ,@(CDR XLIB::RESULT)))) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN LOCALLY SB-C::%FUNCALL ; ==> ; #:G951 ; ; note: could not stack allocate the result of (DEFUN MASK-GET ; (INDEX TYPE-VALUES BODY-FUNCTION) ; (DECLARE (TYPE FUNCTION BODY-FUNCTION) ; (DYNAMIC-EXTENT BODY-FUNCTION)) ; (LET* ((BIT 0) ; (RESULT ; (MAPCAR #'(LAMBDA # #) ; (GET-PUT-ITEMS # ; TYPE-VALUES NIL ; #'#)))) ; `(,@(WHEN (ATOM (CAR RESULT)) ; (LIST (POP RESULT))) ; (PROGN ; (SETQ %MASK (READ-CARD32 ,INDEX)) ; (SETQ %INDEX ,(CEILING INDEX 4)) ; ,(CAR RESULT)) ; ,@(CDR RESULT)))) ; file: /usr/share/common-lisp/source/clx/macros.lisp ; in: DEFUN MASK-PUT ; (DEFUN XLIB::MASK-PUT (XLIB::INDEX XLIB::TYPE-VALUES XLIB::BODY-FUNCTION) ; (DECLARE (TYPE FUNCTION XLIB::BODY-FUNCTION) ; (DYNAMIC-EXTENT XLIB::BODY-FUNCTION)) ; `((LET ((XLIB::%MASK 0) (XLIB::%INDEX ,XLIB::INDEX)) ; ,@(LET (#) ; (XLIB::GET-PUT-ITEMS XLIB::INDEX XLIB::TYPE-VALUES T #'#)) ; (XLIB::WRITE-CARD32 ,XLIB::INDEX XLIB::%MASK) ; (XLIB::WRITE-CARD16 2 (XLIB::INDEX-CEILING # 4)) ; (INCF (XLIB::BUFFER-BOFFSET XLIB::%BUFFER) XLIB::%INDEX)))) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN LOCALLY SB-C::%FUNCALL ; ==> ; #:G967 ; ; note: could not stack allocate the result of (DEFUN MASK-PUT ; (INDEX TYPE-VALUES BODY-FUNCTION) ; (DECLARE (TYPE FUNCTION BODY-FUNCTION) ; (DYNAMIC-EXTENT BODY-FUNCTION)) ; `((LET ((%MASK 0) (%INDEX ,INDEX)) ; ,@(LET ((BIT 1)) ; (GET-PUT-ITEMS INDEX ; TYPE-VALUES T ; #'(LAMBDA # # #))) ; (WRITE-CARD32 ,INDEX %MASK) ; (WRITE-CARD16 2 ; (INDEX-CEILING ; (INDEX-INCF %INDEX 4) 4)) ; (INCF (BUFFER-BOFFSET %BUFFER) ; %INDEX)))) ; compiling (DEFUN MASK-GET ...) ; compiling (DEFUN MASK-PUT ...) ; compiling (DEFINE-ACCESSOR PROGN ...) ; compiling (DEFMACRO CHECK-PUT ...) ; file: /usr/share/common-lisp/source/clx/macros.lisp ; in: DEFUN GET-PUT-ITEMS ; (DEFUN XLIB::GET-PUT-ITEMS ; (XLIB::INDEX XLIB::TYPE-ARGS XLIB::PUTP &OPTIONAL XLIB::BODY-FUNCTION) ; (DECLARE (TYPE (OR NULL FUNCTION) XLIB::BODY-FUNCTION) ; (DYNAMIC-EXTENT XLIB::BODY-FUNCTION)) ; (UNLESS XLIB::BODY-FUNCTION ; (SETQ XLIB::BODY-FUNCTION ; #'(LAMBDA (TYPE XLIB::INDEX XLIB::ITEM XLIB::ARGS) `(#)))) ; (DO* ((XLIB::ITEMS XLIB::TYPE-ARGS (CDR XLIB::ITEMS)) ; (TYPE (CAAR XLIB::ITEMS) (CAAR XLIB::ITEMS)) ; (XLIB::ARGS NIL NIL) ; (XLIB::RESULT NIL) ; (XLIB::SIZES NIL)) ; ((ENDP XLIB::ITEMS) (VALUES XLIB::RESULT XLIB::INDEX XLIB::SIZES)) ; (WHEN (CONSP TYPE) (SETQ XLIB::ARGS (CDR TYPE) TYPE (CAR TYPE))) ; (COND ((MEMBER TYPE '#)) ; ((EQ TYPE 'XLIB::MASK) (SETQ XLIB::RESULT # XLIB::INDEX NIL)) ; (T (DO* # # # # #))))) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN COND IF COND IF PROGN SB-C::%FUNCALL ; --> MULTIPLE-VALUE-BIND LET VALUES PROG1 LET ; ==> ; #:G1134 ; ; note: could not stack allocate the result of (DEFUN GET-PUT-ITEMS ; (INDEX TYPE-ARGS PUTP ; &OPTIONAL BODY-FUNCTION) ; (DECLARE ; (TYPE (OR NULL FUNCTION) ; BODY-FUNCTION) ; (DYNAMIC-EXTENT BODY-FUNCTION)) ; (UNLESS BODY-FUNCTION ; (SETQ BODY-FUNCTION ; #'(LAMBDA ; (TYPE INDEX ITEM ARGS) ; `((CHECK-PUT ,INDEX ; ,ITEM ,TYPE ; ,@ARGS))))) ; (DO* ((ITEMS TYPE-ARGS (CDR ITEMS)) ; (TYPE (CAAR ITEMS) (CAAR ITEMS)) ; (ARGS NIL NIL) ; (RESULT NIL) ; (SIZES NIL)) ; ((ENDP ITEMS) ; (VALUES RESULT INDEX SIZES)) ; (WHEN (CONSP TYPE) ; (SETQ ARGS ; (CDR TYPE) ; TYPE ; (CAR TYPE))) ; (COND ; ((MEMBER TYPE '(RETURN BUFFER))) ; ((EQ TYPE 'MASK) ; (SETQ RESULT ; (APPEND RESULT #) ; INDEX ; NIL)) ; (T ; (DO* (# ; #) ; (#) ; (WHEN # #) ; (SETQ RESULT #) ; (WHEN # #)))))) ; compiling (DEFUN GET-PUT-ITEMS ...) ; compiling (DEFMACRO WITH-BUFFER-REQUEST-INTERNAL ...) ; compiling (DEFMACRO WITH-BUFFER-REQUEST ...) ; compiling (DEFMACRO WITH-BUFFER-REQUEST-AND-REPLY ...) ; compiling (DEFMACRO COMPARE-REQUEST ...) ; compiling (DEFMACRO PUT-ITEMS ...) ; compiling (DEFMACRO DECODE-TYPE ...) ; compiling (DEFMACRO ENCODE-TYPE ...) ; compiling (DEFMACRO SET-DECODE-TYPE ...) ; compiling (DEFSETF DECODE-TYPE ...) ; compiling (DEFCONSTANT +X-CREATEWINDOW+ ...) ; compiling (DEFCONSTANT +X-CHANGEWINDOWATTRIBUTES+ ...) ; compiling (DEFCONSTANT +X-GETWINDOWATTRIBUTES+ ...) ; compiling (DEFCONSTANT +X-DESTROYWINDOW+ ...) ; compiling (DEFCONSTANT +X-DESTROYSUBWINDOWS+ ...) ; compiling (DEFCONSTANT +X-CHANGESAVESET+ ...) ; compiling (DEFCONSTANT +X-REPARENTWINDOW+ ...) ; compiling (DEFCONSTANT +X-MAPWINDOW+ ...) ; compiling (DEFCONSTANT +X-MAPSUBWINDOWS+ ...) ; compiling (DEFCONSTANT +X-UNMAPWINDOW+ ...) ; compiling (DEFCONSTANT +X-UNMAPSUBWINDOWS+ ...) ; compiling (DEFCONSTANT +X-CONFIGUREWINDOW+ ...) ; compiling (DEFCONSTANT +X-CIRCULATEWINDOW+ ...) ; compiling (DEFCONSTANT +X-GETGEOMETRY+ ...) ; compiling (DEFCONSTANT +X-QUERYTREE+ ...) ; compiling (DEFCONSTANT +X-INTERNATOM+ ...) ; compiling (DEFCONSTANT +X-GETATOMNAME+ ...) ; compiling (DEFCONSTANT +X-CHANGEPROPERTY+ ...) ; compiling (DEFCONSTANT +X-DELETEPROPERTY+ ...) ; compiling (DEFCONSTANT +X-GETPROPERTY+ ...) ; compiling (DEFCONSTANT +X-LISTPROPERTIES+ ...) ; compiling (DEFCONSTANT +X-SETSELECTIONOWNER+ ...) ; compiling (DEFCONSTANT +X-GETSELECTIONOWNER+ ...) ; compiling (DEFCONSTANT +X-CONVERTSELECTION+ ...) ; compiling (DEFCONSTANT +X-SENDEVENT+ ...) ; compiling (DEFCONSTANT +X-GRABPOINTER+ ...) ; compiling (DEFCONSTANT +X-UNGRABPOINTER+ ...) ; compiling (DEFCONSTANT +X-GRABBUTTON+ ...) ; compiling (DEFCONSTANT +X-UNGRABBUTTON+ ...) ; compiling (DEFCONSTANT +X-CHANGEACTIVEPOINTERGRAB+ ...) ; compiling (DEFCONSTANT +X-GRABKEYBOARD+ ...) ; compiling (DEFCONSTANT +X-UNGRABKEYBOARD+ ...) ; compiling (DEFCONSTANT +X-GRABKEY+ ...) ; compiling (DEFCONSTANT +X-UNGRABKEY+ ...) ; compiling (DEFCONSTANT +X-ALLOWEVENTS+ ...) ; compiling (DEFCONSTANT +X-GRABSERVER+ ...) ; compiling (DEFCONSTANT +X-UNGRABSERVER+ ...) ; compiling (DEFCONSTANT +X-QUERYPOINTER+ ...) ; compiling (DEFCONSTANT +X-GETMOTIONEVENTS+ ...) ; compiling (DEFCONSTANT +X-TRANSLATECOORDS+ ...) ; compiling (DEFCONSTANT +X-WARPPOINTER+ ...) ; compiling (DEFCONSTANT +X-SETINPUTFOCUS+ ...) ; compiling (DEFCONSTANT +X-GETINPUTFOCUS+ ...) ; compiling (DEFCONSTANT +X-QUERYKEYMAP+ ...) ; compiling (DEFCONSTANT +X-OPENFONT+ ...) ; compiling (DEFCONSTANT +X-CLOSEFONT+ ...) ; compiling (DEFCONSTANT +X-QUERYFONT+ ...) ; compiling (DEFCONSTANT +X-QUERYTEXTEXTENTS+ ...) ; compiling (DEFCONSTANT +X-LISTFONTS+ ...) ; compiling (DEFCONSTANT +X-LISTFONTSWITHINFO+ ...) ; compiling (DEFCONSTANT +X-SETFONTPATH+ ...) ; compiling (DEFCONSTANT +X-GETFONTPATH+ ...) ; compiling (DEFCONSTANT +X-CREATEPIXMAP+ ...) ; compiling (DEFCONSTANT +X-FREEPIXMAP+ ...) ; compiling (DEFCONSTANT +X-CREATEGC+ ...) ; compiling (DEFCONSTANT +X-CHANGEGC+ ...) ; compiling (DEFCONSTANT +X-COPYGC+ ...) ; compiling (DEFCONSTANT +X-SETDASHES+ ...) ; compiling (DEFCONSTANT +X-SETCLIPRECTANGLES+ ...) ; compiling (DEFCONSTANT +X-FREEGC+ ...) ; compiling (DEFCONSTANT +X-CLEARTOBACKGROUND+ ...) ; compiling (DEFCONSTANT +X-COPYAREA+ ...) ; compiling (DEFCONSTANT +X-COPYPLANE+ ...) ; compiling (DEFCONSTANT +X-POLYPOINT+ ...) ; compiling (DEFCONSTANT +X-POLYLINE+ ...) ; compiling (DEFCONSTANT +X-POLYSEGMENT+ ...) ; compiling (DEFCONSTANT +X-POLYRECTANGLE+ ...) ; compiling (DEFCONSTANT +X-POLYARC+ ...) ; compiling (DEFCONSTANT +X-FILLPOLY+ ...) ; compiling (DEFCONSTANT +X-POLYFILLRECTANGLE+ ...) ; compiling (DEFCONSTANT +X-POLYFILLARC+ ...) ; compiling (DEFCONSTANT +X-PUTIMAGE+ ...) ; compiling (DEFCONSTANT +X-GETIMAGE+ ...) ; compiling (DEFCONSTANT +X-POLYTEXT8+ ...) ; compiling (DEFCONSTANT +X-POLYTEXT16+ ...) ; compiling (DEFCONSTANT +X-IMAGETEXT8+ ...) ; compiling (DEFCONSTANT +X-IMAGETEXT16+ ...) ; compiling (DEFCONSTANT +X-CREATECOLORMAP+ ...) ; compiling (DEFCONSTANT +X-FREECOLORMAP+ ...) ; compiling (DEFCONSTANT +X-COPYCOLORMAPANDFREE+ ...) ; compiling (DEFCONSTANT +X-INSTALLCOLORMAP+ ...) ; compiling (DEFCONSTANT +X-UNINSTALLCOLORMAP+ ...) ; compiling (DEFCONSTANT +X-LISTINSTALLEDCOLORMAPS+ ...) ; compiling (DEFCONSTANT +X-ALLOCCOLOR+ ...) ; compiling (DEFCONSTANT +X-ALLOCNAMEDCOLOR+ ...) ; compiling (DEFCONSTANT +X-ALLOCCOLORCELLS+ ...) ; compiling (DEFCONSTANT +X-ALLOCCOLORPLANES+ ...) ; compiling (DEFCONSTANT +X-FREECOLORS+ ...) ; compiling (DEFCONSTANT +X-STORECOLORS+ ...) ; compiling (DEFCONSTANT +X-STORENAMEDCOLOR+ ...) ; compiling (DEFCONSTANT +X-QUERYCOLORS+ ...) ; compiling (DEFCONSTANT +X-LOOKUPCOLOR+ ...) ; compiling (DEFCONSTANT +X-CREATECURSOR+ ...) ; compiling (DEFCONSTANT +X-CREATEGLYPHCURSOR+ ...) ; compiling (DEFCONSTANT +X-FREECURSOR+ ...) ; compiling (DEFCONSTANT +X-RECOLORCURSOR+ ...) ; compiling (DEFCONSTANT +X-QUERYBESTSIZE+ ...) ; compiling (DEFCONSTANT +X-QUERYEXTENSION+ ...) ; compiling (DEFCONSTANT +X-LISTEXTENSIONS+ ...) ; compiling (DEFCONSTANT +X-SETKEYBOARDMAPPING+ ...) ; compiling (DEFCONSTANT +X-GETKEYBOARDMAPPING+ ...) ; compiling (DEFCONSTANT +X-CHANGEKEYBOARDCONTROL+ ...) ; compiling (DEFCONSTANT +X-GETKEYBOARDCONTROL+ ...) ; compiling (DEFCONSTANT +X-BELL+ ...) ; compiling (DEFCONSTANT +X-CHANGEPOINTERCONTROL+ ...) ; compiling (DEFCONSTANT +X-GETPOINTERCONTROL+ ...) ; compiling (DEFCONSTANT +X-SETSCREENSAVER+ ...) ; compiling (DEFCONSTANT +X-GETSCREENSAVER+ ...) ; compiling (DEFCONSTANT +X-CHANGEHOSTS+ ...) ; compiling (DEFCONSTANT +X-LISTHOSTS+ ...) ; compiling (DEFCONSTANT +X-CHANGEACCESSCONTROL+ ...) ; compiling (DEFCONSTANT +X-CHANGECLOSEDOWNMODE+ ...) ; compiling (DEFCONSTANT +X-KILLCLIENT+ ...) ; compiling (DEFCONSTANT +X-ROTATEPROPERTIES+ ...) ; compiling (DEFCONSTANT +X-FORCESCREENSAVER+ ...) ; compiling (DEFCONSTANT +X-SETPOINTERMAPPING+ ...) ; compiling (DEFCONSTANT +X-GETPOINTERMAPPING+ ...) ; compiling (DEFCONSTANT +X-SETMODIFIERMAPPING+ ...) ; compiling (DEFCONSTANT +X-GETMODIFIERMAPPING+ ...) ; compiling (DEFCONSTANT +X-NOOPERATION+ ...) ; compiling (DEFMACRO THREADED-ATOMIC-PUSH ...) ; compiling (DEFMACRO THREADED-ATOMIC-POP ...) ; compiling (DEFMACRO THREADED-NCONC ...) ; compiling (DEFMACRO THREADED-PUSH ...) ; compiling (DEFMACRO THREADED-POP ...) ; compiling (DEFMACRO THREADED-ENQUEUE ...) ; compiling (DEFMACRO THREADED-DEQUEUE ...) ; compiling (DEFMACRO THREADED-REQUEUE ...) ; compiling (DEFMACRO THREADED-DOLIST ...) ; compiling (DEFMACRO THREADED-DELETE ...) ; compiling (DEFMACRO THREADED-LENGTH ...) ; /var/cache/common-lisp-controller/1001/sbcl/clx/macros.fasl written ; compilation finished in 0:00:00.857 ; compiling file "/usr/share/common-lisp/source/clx/bufmac.lisp" (written 14 JUL 2005 03:24:43 PM): ; compiling (IN-PACKAGE :XLIB) ; compiling (DEFMACRO WRITE-CARD8 ...) ; compiling (DEFMACRO WRITE-INT8 ...) ; compiling (DEFMACRO WRITE-CARD16 ...) ; compiling (DEFMACRO WRITE-INT16 ...) ; compiling (DEFMACRO WRITE-CARD32 ...) ; compiling (DEFMACRO WRITE-INT32 ...) ; compiling (DEFMACRO WRITE-CARD29 ...) ; compiling (DEFMACRO WRITE-CHAR2B ...) ; compiling (DEFMACRO SET-BUFFER-OFFSET ...) ; compiling (DEFMACRO ADVANCE-BUFFER-OFFSET ...) ; compiling (DEFMACRO WITH-BUFFER-OUTPUT ...) ; compiling (DEFMACRO WRITING-BUFFER-CHUNKS ...) ; /var/cache/common-lisp-controller/1001/sbcl/clx/bufmac.fasl written ; compilation finished in 0:00:00.079 ; compiling file "/usr/share/common-lisp/source/clx/buffer.lisp" (written 14 JUL 2005 03:24:44 PM): ; compiling (IN-PACKAGE :XLIB) ; compiling (DEFCONSTANT +REQUESTSIZE+ ...) ; compiling (DEFMACRO WITH-BUFFER ...) ; file: /usr/share/common-lisp/source/clx/buffer.lisp ; in: DEFUN WITH-BUFFER-FUNCTION ; (XLIB::WITH-BUFFER (XLIB::BUFFER :TIMEOUT XLIB::TIMEOUT :INLINE T) ; (FUNCALL FUNCTION)) ; --> MACROLET LET XLIB::HOLDING-LOCK IF HANDLER-CASE SB-INT:DX-FLET FLET BLOCK ; --> WITH-TIMEOUT SB-INT:DX-FLET FLET LET IF ; ==> ; (> SB-IMPL::EXPIRES 0) ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; due to type uncertainty: ; The first argument is a REAL, not a FLOAT. ; (DEFUN XLIB::WITH-BUFFER-FUNCTION (XLIB::BUFFER XLIB::TIMEOUT FUNCTION) ; (DECLARE (TYPE XLIB:DISPLAY XLIB::BUFFER) ; (TYPE (OR NULL NUMBER) XLIB::TIMEOUT) (TYPE FUNCTION FUNCTION) ; (DYNAMIC-EXTENT FUNCTION) (IGNORABLE XLIB::TIMEOUT)) ; (XLIB::WITH-BUFFER (XLIB::BUFFER :TIMEOUT XLIB::TIMEOUT :INLINE T) ; (FUNCALL FUNCTION))) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN LOCALLY SB-C::%FUNCALL ; ==> ; #:G65 ; ; note: could not stack allocate the result of (DEFUN WITH-BUFFER-FUNCTION ; (BUFFER TIMEOUT FUNCTION) ; (DECLARE (TYPE DISPLAY BUFFER) ; (TYPE (OR NULL NUMBER) TIMEOUT) ; (TYPE FUNCTION FUNCTION) ; (DYNAMIC-EXTENT FUNCTION) ; (IGNORABLE TIMEOUT)) ; (WITH-BUFFER ; (BUFFER :TIMEOUT TIMEOUT :INLINE T) ; (FUNCALL FUNCTION))) ; (XLIB::WITH-BUFFER (XLIB::BUFFER :TIMEOUT XLIB::TIMEOUT :INLINE T) ; (FUNCALL FUNCTION)) ; --> MACROLET LET XLIB::HOLDING-LOCK IF HANDLER-CASE SB-INT:DX-FLET FLET BLOCK ; --> WITH-TIMEOUT SB-INT:DX-FLET FLET LET IF ; ==> ; (> SB-IMPL::EXPIRES 0) ; ; note: forced to do GENERIC-> (cost 10) ; unable to do inline fixnum comparison (cost 3) because: ; The first argument is a REAL, not a FIXNUM. ; unable to do inline fixnum comparison (cost 4) because: ; The first argument is a REAL, not a FIXNUM. ; etc. ; compiling (DEFUN WITH-BUFFER-FUNCTION ...) ; compiling (DEFMACRO READ-CARD8 ...) ; compiling (DEFMACRO READ-INT8 ...) ; compiling (DEFMACRO READ-CARD16 ...) ; compiling (DEFMACRO READ-INT16 ...) ; compiling (DEFMACRO READ-CARD32 ...) ; compiling (DEFMACRO READ-INT32 ...) ; compiling (DEFMACRO READ-CARD29 ...) ; compiling (DEFMACRO EVENT-CODE ...) ; compiling (DEFMACRO READING-EVENT ...) ; compiling (DEFMACRO WITH-BUFFER-INPUT ...) ; compiling (DEFUN MAKE-BUFFER ...) ; compiling (DEFUN MAKE-REPLY-BUFFER ...) ; compiling (DEFUN BUFFER-ENSURE-SIZE ...) ; compiling (DEFUN BUFFER-PAD-REQUEST ...) ; compiling (DECLAIM (INLINE BUFFER-NEW-REQUEST-NUMBER)) ; compiling (DEFUN BUFFER-NEW-REQUEST-NUMBER ...) ; file: /usr/share/common-lisp/source/clx/buffer.lisp ; in: DEFUN WITH-BUFFER-REQUEST-FUNCTION ; (DEFUN XLIB::WITH-BUFFER-REQUEST-FUNCTION ; (XLIB:DISPLAY XLIB::GC-FORCE XLIB::REQUEST-FUNCTION) ; (DECLARE (TYPE XLIB:DISPLAY XLIB:DISPLAY) ; (TYPE (OR NULL XLIB:GCONTEXT) XLIB::GC-FORCE)) ; (DECLARE (TYPE FUNCTION XLIB::REQUEST-FUNCTION) ; (DYNAMIC-EXTENT XLIB::REQUEST-FUNCTION)) ; (XLIB::WITH-BUFFER (XLIB:DISPLAY :INLINE T) ; (MULTIPLE-VALUE-PROG1 ; (PROGN ; (WHEN XLIB::GC-FORCE #) ; (XLIB::WITHOUT-ABORTS #)) ; (XLIB:DISPLAY-INVOKE-AFTER-FUNCTION XLIB:DISPLAY)))) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN LOCALLY SB-C::%FUNCALL ; ==> ; #:G313 ; ; note: could not stack allocate the result of (DEFUN WITH-BUFFER-REQUEST-FUNCTION ; (DISPLAY GC-FORCE ; REQUEST-FUNCTION) ; (DECLARE (TYPE DISPLAY DISPLAY) ; (TYPE (OR NULL GCONTEXT) GC-FORCE)) ; (DECLARE ; (TYPE FUNCTION REQUEST-FUNCTION) ; (DYNAMIC-EXTENT REQUEST-FUNCTION)) ; (WITH-BUFFER (DISPLAY :INLINE T) ; (MULTIPLE-VALUE-PROG1 ; (PROGN ; (WHEN GC-FORCE ; (FORCE-GCONTEXT-CHANGES-INTERNAL ; GC-FORCE)) ; (WITHOUT-ABORTS ; (FUNCALL ; REQUEST-FUNCTION ; DISPLAY))) ; (DISPLAY-INVOKE-AFTER-FUNCTION ; DISPLAY)))) ; compiling (DEFUN WITH-BUFFER-REQUEST-FUNCTION ...) ; file: /usr/share/common-lisp/source/clx/buffer.lisp ; in: DEFUN WITH-BUFFER-REQUEST-FUNCTION-NOLOCK ; (DEFUN XLIB::WITH-BUFFER-REQUEST-FUNCTION-NOLOCK ; (XLIB:DISPLAY XLIB::GC-FORCE XLIB::REQUEST-FUNCTION) ; (DECLARE (TYPE XLIB:DISPLAY XLIB:DISPLAY) ; (TYPE (OR NULL XLIB:GCONTEXT) XLIB::GC-FORCE)) ; (DECLARE (TYPE FUNCTION XLIB::REQUEST-FUNCTION) ; (DYNAMIC-EXTENT XLIB::REQUEST-FUNCTION)) ; (MULTIPLE-VALUE-PROG1 ; (PROGN ; (WHEN XLIB::GC-FORCE ; (XLIB::FORCE-GCONTEXT-CHANGES-INTERNAL XLIB::GC-FORCE)) ; (XLIB::WITHOUT-ABORTS (FUNCALL XLIB::REQUEST-FUNCTION XLIB:DISPLAY))) ; (XLIB:DISPLAY-INVOKE-AFTER-FUNCTION XLIB:DISPLAY))) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN LOCALLY SB-C::%FUNCALL ; ==> ; #:G324 ; ; note: could not stack allocate the result of (DEFUN WITH-BUFFER-REQUEST-FUNCTION-NOLOCK ; (DISPLAY GC-FORCE ; REQUEST-FUNCTION) ; (DECLARE (TYPE DISPLAY DISPLAY) ; (TYPE (OR NULL GCONTEXT) GC-FORCE)) ; (DECLARE ; (TYPE FUNCTION REQUEST-FUNCTION) ; (DYNAMIC-EXTENT REQUEST-FUNCTION)) ; (MULTIPLE-VALUE-PROG1 ; (PROGN ; (WHEN GC-FORCE ; (FORCE-GCONTEXT-CHANGES-INTERNAL ; GC-FORCE)) ; (WITHOUT-ABORTS ; (FUNCALL REQUEST-FUNCTION ; DISPLAY))) ; (DISPLAY-INVOKE-AFTER-FUNCTION ; DISPLAY))) ; compiling (DEFUN WITH-BUFFER-REQUEST-FUNCTION-NOLOCK ...) ; compiling (DEFSTRUCT (PENDING-COMMAND # ...) ...) ; file: /usr/share/common-lisp/source/clx/buffer.lisp ; in: DEFUN WITH-BUFFER-REQUEST-AND-REPLY-FUNCTION ; (DEFUN XLIB::WITH-BUFFER-REQUEST-AND-REPLY-FUNCTION ; (XLIB:DISPLAY XLIB::MULTIPLE-REPLY XLIB::REQUEST-FUNCTION ; XLIB::REPLY-FUNCTION) ; (DECLARE (TYPE XLIB:DISPLAY XLIB:DISPLAY) ; (TYPE XLIB:GENERALIZED-BOOLEAN XLIB::MULTIPLE-REPLY)) ; (DECLARE (TYPE FUNCTION XLIB::REQUEST-FUNCTION XLIB::REPLY-FUNCTION) ; (DYNAMIC-EXTENT XLIB::REQUEST-FUNCTION XLIB::REPLY-FUNCTION)) ; (LET ((XLIB::PENDING-COMMAND NIL) (XLIB::REPLY-BUFFER NIL)) ; (DECLARE (TYPE (OR NULL XLIB::PENDING-COMMAND) XLIB::PENDING-COMMAND) ; (TYPE (OR NULL XLIB::REPLY-BUFFER) XLIB::REPLY-BUFFER)) ; (UNWIND-PROTECT (PROGN (XLIB::WITH-BUFFER # # # # #) (COND # #)) ; (WHEN XLIB::REPLY-BUFFER ; (XLIB::DEALLOCATE-REPLY-BUFFER XLIB::REPLY-BUFFER)) ; (WHEN XLIB::PENDING-COMMAND ; (XLIB::STOP-PENDING-COMMAND XLIB:DISPLAY XLIB::PENDING-COMMAND))))) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN LOCALLY SB-C::%FUNCALL ; ==> ; #:G411 ; ; note: could not stack allocate the result of (DEFUN WITH-BUFFER-REQUEST-AND-REPLY-FUNCTION ; (DISPLAY MULTIPLE-REPLY ; REQUEST-FUNCTION REPLY-FUNCTION) ; (DECLARE (TYPE DISPLAY DISPLAY) ; (TYPE GENERALIZED-BOOLEAN ; MULTIPLE-REPLY)) ; (DECLARE ; (TYPE FUNCTION REQUEST-FUNCTION ; REPLY-FUNCTION) ; (DYNAMIC-EXTENT REQUEST-FUNCTION ; REPLY-FUNCTION)) ; (LET ((PENDING-COMMAND NIL) ; (REPLY-BUFFER NIL)) ; (DECLARE ; (TYPE (OR NULL PENDING-COMMAND) ; PENDING-COMMAND) ; (TYPE (OR NULL REPLY-BUFFER) ; REPLY-BUFFER)) ; (UNWIND-PROTECT ; (PROGN ; (WITH-BUFFER ; (DISPLAY :INLINE T) ; (SETQ PENDING-COMMAND #) ; (WITHOUT-ABORTS #) ; (BUFFER-FORCE-OUTPUT DISPLAY) ; (DISPLAY-INVOKE-AFTER-FUNCTION ; DISPLAY)) ; (COND (MULTIPLE-REPLY (LOOP #)) ; (T # #))) ; (WHEN REPLY-BUFFER ; (DEALLOCATE-REPLY-BUFFER ; REPLY-BUFFER)) ; (WHEN PENDING-COMMAND ; (STOP-PENDING-COMMAND DISPLAY ; PENDING-COMMAND))))) ; ==> ; #:G412 ; ; note: could not stack allocate the result of (DEFUN WITH-BUFFER-REQUEST-AND-REPLY-FUNCTION ; (DISPLAY MULTIPLE-REPLY ; REQUEST-FUNCTION REPLY-FUNCTION) ; (DECLARE (TYPE DISPLAY DISPLAY) ; (TYPE GENERALIZED-BOOLEAN ; MULTIPLE-REPLY)) ; (DECLARE ; (TYPE FUNCTION REQUEST-FUNCTION ; REPLY-FUNCTION) ; (DYNAMIC-EXTENT REQUEST-FUNCTION ; REPLY-FUNCTION)) ; (LET ((PENDING-COMMAND NIL) ; (REPLY-BUFFER NIL)) ; (DECLARE ; (TYPE (OR NULL PENDING-COMMAND) ; PENDING-COMMAND) ; (TYPE (OR NULL REPLY-BUFFER) ; REPLY-BUFFER)) ; (UNWIND-PROTECT ; (PROGN ; (WITH-BUFFER ; (DISPLAY :INLINE T) ; (SETQ PENDING-COMMAND #) ; (WITHOUT-ABORTS #) ; (BUFFER-FORCE-OUTPUT DISPLAY) ; (DISPLAY-INVOKE-AFTER-FUNCTION ; DISPLAY)) ; (COND (MULTIPLE-REPLY (LOOP #)) ; (T # #))) ; (WHEN REPLY-BUFFER ; (DEALLOCATE-REPLY-BUFFER ; REPLY-BUFFER)) ; (WHEN PENDING-COMMAND ; (STOP-PENDING-COMMAND DISPLAY ; PENDING-COMMAND))))) ; compiling (DEFUN WITH-BUFFER-REQUEST-AND-REPLY-FUNCTION ...) ; compiling (DEFUN BUFFER-WRITE ...) ; compiling (DEFUN BUFFER-FLUSH ...) ; compiling (DEFMACRO WITH-BUFFER-FLUSH-INHIBITED ...) ; compiling (DEFUN BUFFER-FORCE-OUTPUT ...) ; compiling (DEFUN CLOSE-BUFFER ...) ; compiling (DEFUN BUFFER-INPUT ...) ; compiling (DEFUN BUFFER-INPUT-WAIT ...) ; compiling (DEFUN BUFFER-LISTEN ...) ; compiling (DEFUN READ-SEQUENCE-STRING ...) ; file: /usr/share/common-lisp/source/clx/buffer.lisp ; in: DEFUN READ-SEQUENCE-CHAR ; (DEFUN XLIB::READ-SEQUENCE-CHAR ; (XLIB::REPLY-BUFFER XLIB::RESULT-TYPE XLIB::NITEMS ; &OPTIONAL XLIB::TRANSFORM XLIB::DATA (XLIB::START 0) (XLIB::INDEX 0)) ; (DECLARE (TYPE XLIB::REPLY-BUFFER XLIB::REPLY-BUFFER) ; (TYPE T XLIB::RESULT-TYPE) ; (TYPE XLIB:ARRAY-INDEX XLIB::NITEMS XLIB::START XLIB::INDEX) ; (TYPE (OR NULL SEQUENCE) XLIB::DATA)) ; (DECLARE (TYPE (OR NULL (FUNCTION # T)) XLIB::TRANSFORM) ; (DYNAMIC-EXTENT XLIB::TRANSFORM)) ; (IF XLIB::TRANSFORM ; (FLET ((XLIB::CARD8->CHAR->TRANSFORM # ; # ; #)) ; (DECLARE (DYNAMIC-EXTENT #'XLIB::CARD8->CHAR->TRANSFORM)) ; (XLIB::READ-SEQUENCE-CARD8 XLIB::REPLY-BUFFER XLIB::RESULT-TYPE ; XLIB::NITEMS #'XLIB::CARD8->CHAR->TRANSFORM XLIB::DATA XLIB::START ; XLIB::INDEX)) ; (XLIB::READ-SEQUENCE-CARD8 XLIB::REPLY-BUFFER XLIB::RESULT-TYPE ; XLIB::NITEMS #'XLIB:CARD8->CHAR XLIB::DATA XLIB::START XLIB::INDEX))) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN COND IF COND IF COND IF COND IF COND IF ; --> PROGN SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET ; ==> ; #:G676 ; ; note: could not stack allocate the result of (DEFUN READ-SEQUENCE-CHAR ; (REPLY-BUFFER RESULT-TYPE NITEMS ; &OPTIONAL TRANSFORM DATA ; (START 0) (INDEX 0)) ; (DECLARE ; (TYPE REPLY-BUFFER REPLY-BUFFER) ; (TYPE T RESULT-TYPE) ; (TYPE ARRAY-INDEX NITEMS START INDEX) ; (TYPE (OR NULL SEQUENCE) DATA)) ; (DECLARE ; (TYPE ; (OR NULL (FUNCTION (CHARACTER) T)) ; TRANSFORM) ; (DYNAMIC-EXTENT TRANSFORM)) ; (IF TRANSFORM ; (FLET ((CARD8->CHAR->TRANSFORM (V) ; (DECLARE #) ; (FUNCALL TRANSFORM #))) ; (DECLARE ; (DYNAMIC-EXTENT ; #'CARD8->CHAR->TRANSFORM)) ; (READ-SEQUENCE-CARD8 ; REPLY-BUFFER RESULT-TYPE NITEMS ; #'CARD8->CHAR->TRANSFORM DATA ; START INDEX)) ; (READ-SEQUENCE-CARD8 REPLY-BUFFER ; RESULT-TYPE NITEMS #'CARD8->CHAR ; DATA START INDEX))) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-C::%FUNCALL ; ==> ; XLIB::TRANSFORM ; ; note: could not stack allocate the result of (DEFUN READ-SEQUENCE-CHAR ; (REPLY-BUFFER RESULT-TYPE NITEMS ; &OPTIONAL TRANSFORM DATA ; (START 0) (INDEX 0)) ; (DECLARE ; (TYPE REPLY-BUFFER REPLY-BUFFER) ; (TYPE T RESULT-TYPE) ; (TYPE ARRAY-INDEX NITEMS START INDEX) ; (TYPE (OR NULL SEQUENCE) DATA)) ; (DECLARE ; (TYPE ; (OR NULL (FUNCTION (CHARACTER) T)) ; TRANSFORM) ; (DYNAMIC-EXTENT TRANSFORM)) ; (IF TRANSFORM ; (FLET ((CARD8->CHAR->TRANSFORM (V) ; (DECLARE #) ; (FUNCALL TRANSFORM #))) ; (DECLARE ; (DYNAMIC-EXTENT ; #'CARD8->CHAR->TRANSFORM)) ; (READ-SEQUENCE-CARD8 ; REPLY-BUFFER RESULT-TYPE NITEMS ; #'CARD8->CHAR->TRANSFORM DATA ; START INDEX)) ; (READ-SEQUENCE-CARD8 REPLY-BUFFER ; RESULT-TYPE NITEMS #'CARD8->CHAR ; DATA START INDEX))) ; compiling (DEFUN READ-SEQUENCE-CHAR ...) ; compiling (DEFUN READ-LIST-CARD8 ...) ; file: /usr/share/common-lisp/source/clx/buffer.lisp ; in: DEFUN READ-LIST-CARD8-WITH-TRANSFORM ; (DEFUN XLIB::READ-LIST-CARD8-WITH-TRANSFORM ; (XLIB::REPLY-BUFFER XLIB::NITEMS XLIB::DATA XLIB::TRANSFORM ; XLIB::START XLIB::INDEX) ; (DECLARE (TYPE XLIB::REPLY-BUFFER XLIB::REPLY-BUFFER) ; (TYPE XLIB:ARRAY-INDEX XLIB::NITEMS XLIB::START XLIB::INDEX) ; (TYPE LIST XLIB::DATA)) ; (DECLARE (TYPE (FUNCTION (XLIB:CARD8) T) XLIB::TRANSFORM) ; (DYNAMIC-EXTENT XLIB::TRANSFORM)) ; (XLIB::WITH-BUFFER-INPUT (XLIB::REPLY-BUFFER :SIZES (8) :INDEX XLIB::INDEX) ; (DO* ((XLIB::J XLIB::NITEMS #) ; (XLIB::LST # #) ; (XLIB::INDEX 0 #)) ; ((XLIB::INDEX-ZEROP XLIB::J)) ; (DECLARE ; (TYPE XLIB:ARRAY-INDEX XLIB::J XLIB::INDEX) ; (LIST XLIB::LST)) ; (SETF (CAR XLIB::LST) ; (FUNCALL XLIB::TRANSFORM #))))) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN LOCALLY SB-C::%FUNCALL ; ==> ; #:G731 ; ; note: could not stack allocate the result of (DEFUN READ-LIST-CARD8-WITH-TRANSFORM ; (REPLY-BUFFER NITEMS DATA ; TRANSFORM START INDEX) ; (DECLARE ; (TYPE REPLY-BUFFER REPLY-BUFFER) ; (TYPE ARRAY-INDEX NITEMS START INDEX) ; (TYPE LIST DATA)) ; (DECLARE ; (TYPE (FUNCTION (CARD8) T) TRANSFORM) ; (DYNAMIC-EXTENT TRANSFORM)) ; (WITH-BUFFER-INPUT ; (REPLY-BUFFER :SIZES (8) :INDEX ; INDEX) ; (DO* ((J NITEMS (INDEX- J 1)) ; (LST (NTHCDR START DATA) ; (CDR LST)) ; (INDEX 0 (INDEX+ INDEX 1))) ; ((INDEX-ZEROP J)) ; (DECLARE (TYPE ARRAY-INDEX J INDEX) ; (LIST LST)) ; (SETF (CAR LST) ; (FUNCALL TRANSFORM ; (READ-CARD8 ; INDEX)))))) ; compiling (DEFUN READ-LIST-CARD8-WITH-TRANSFORM ...) ; compiling (DEFUN READ-SIMPLE-ARRAY-CARD8 ...) ; file: /usr/share/common-lisp/source/clx/buffer.lisp ; in: DEFUN READ-SIMPLE-ARRAY-CARD8-WITH-TRANSFORM ; (DEFUN XLIB::READ-SIMPLE-ARRAY-CARD8-WITH-TRANSFORM ; (XLIB::REPLY-BUFFER XLIB::NITEMS XLIB::DATA XLIB::TRANSFORM ; XLIB::START XLIB::INDEX) ; (DECLARE (TYPE XLIB::REPLY-BUFFER XLIB::REPLY-BUFFER) ; (TYPE XLIB:ARRAY-INDEX XLIB::NITEMS XLIB::START XLIB::INDEX) ; (TYPE (SIMPLE-ARRAY XLIB:CARD8 (*)) XLIB::DATA)) ; (DECLARE (TYPE (FUNCTION (XLIB:CARD8) XLIB:CARD8) XLIB::TRANSFORM) ; (DYNAMIC-EXTENT XLIB::TRANSFORM)) ; (XLIB::WITH-VECTOR (XLIB::DATA (SIMPLE-ARRAY XLIB:CARD8 (*))) ; (XLIB::WITH-BUFFER-INPUT ; (XLIB::REPLY-BUFFER :SIZES (8) :INDEX XLIB::INDEX) ; (DO* (# ; # ; #) ; (#) ; (DECLARE #) ; (SETF # #))))) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN LOCALLY SB-C::%FUNCALL ; ==> ; #:G808 ; ; note: could not stack allocate the result of (DEFUN READ-SIMPLE-ARRAY-CARD8-WITH-TRANSFORM ; (REPLY-BUFFER NITEMS DATA ; TRANSFORM START INDEX) ; (DECLARE ; (TYPE REPLY-BUFFER REPLY-BUFFER) ; (TYPE ARRAY-INDEX NITEMS START INDEX) ; (TYPE (SIMPLE-ARRAY CARD8 (*)) DATA)) ; (DECLARE ; (TYPE (FUNCTION (CARD8) CARD8) ; TRANSFORM) ; (DYNAMIC-EXTENT TRANSFORM)) ; (WITH-VECTOR ; (DATA (SIMPLE-ARRAY CARD8 (*))) ; (WITH-BUFFER-INPUT ; (REPLY-BUFFER :SIZES (8) :INDEX ; INDEX) ; (DO* ((J START #) ; (END #) ; (INDEX 0 #)) ; ((INDEX>= J END)) ; (DECLARE ; (TYPE ARRAY-INDEX J END INDEX)) ; (SETF (AREF DATA J) ; (THE CARD8 #)))))) ; compiling (DEFUN READ-SIMPLE-ARRAY-CARD8-WITH-TRANSFORM ...) ; file: /usr/share/common-lisp/source/clx/buffer.lisp ; in: DEFUN READ-VECTOR-CARD8 ; (SETF (AREF XLIB::DATA XLIB::J) (XLIB::READ-CARD8 XLIB::INDEX)) ; --> SB-KERNEL:%ASET ; ==> ; (SB-KERNEL:HAIRY-DATA-VECTOR-SET ARRAY SB-INT:INDEX SB-C::NEW-VALUE) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a VECTOR, not a SIMPLE-STRING. ; ; note: unable to ; avoid runtime dispatch on array element type ; due to type uncertainty: ; The first argument is a VECTOR, not a SIMPLE-ARRAY. ; compiling (DEFUN READ-VECTOR-CARD8 ...) ; file: /usr/share/common-lisp/source/clx/buffer.lisp ; in: DEFUN READ-VECTOR-CARD8-WITH-TRANSFORM ; (SETF (AREF XLIB::DATA XLIB::J) ; (FUNCALL XLIB::TRANSFORM (XLIB::READ-CARD8 XLIB::INDEX))) ; --> SB-KERNEL:%ASET ; ==> ; (SB-KERNEL:HAIRY-DATA-VECTOR-SET ARRAY SB-INT:INDEX SB-C::NEW-VALUE) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a VECTOR, not a SIMPLE-STRING. ; ; note: unable to ; avoid runtime dispatch on array element type ; due to type uncertainty: ; The first argument is a VECTOR, not a SIMPLE-ARRAY. ; (DEFUN XLIB::READ-VECTOR-CARD8-WITH-TRANSFORM ; (XLIB::REPLY-BUFFER XLIB::NITEMS XLIB::DATA XLIB::TRANSFORM ; XLIB::START XLIB::INDEX) ; (DECLARE (TYPE XLIB::REPLY-BUFFER XLIB::REPLY-BUFFER) ; (TYPE XLIB:ARRAY-INDEX XLIB::NITEMS XLIB::START XLIB::INDEX) ; (TYPE VECTOR XLIB::DATA) (OPTIMIZE)) ; (DECLARE (TYPE (FUNCTION (XLIB:CARD8) T) XLIB::TRANSFORM) ; (DYNAMIC-EXTENT XLIB::TRANSFORM)) ; (XLIB::WITH-VECTOR (XLIB::DATA VECTOR) ; (XLIB::WITH-BUFFER-INPUT ; (XLIB::REPLY-BUFFER :SIZES (8) :INDEX XLIB::INDEX) ; (DO* (# ; # ; #) ; (#) ; (DECLARE #) ; (SETF # #))))) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN LOCALLY SB-C::%FUNCALL ; ==> ; #:G868 ; ; note: could not stack allocate the result of (DEFUN READ-VECTOR-CARD8-WITH-TRANSFORM ; (REPLY-BUFFER NITEMS DATA ; TRANSFORM START INDEX) ; (DECLARE ; (TYPE REPLY-BUFFER REPLY-BUFFER) ; (TYPE ARRAY-INDEX NITEMS START INDEX) ; (TYPE VECTOR DATA) (OPTIMIZE)) ; (DECLARE ; (TYPE (FUNCTION (CARD8) T) TRANSFORM) ; (DYNAMIC-EXTENT TRANSFORM)) ; (WITH-VECTOR (DATA VECTOR) ; (WITH-BUFFER-INPUT ; (REPLY-BUFFER :SIZES (8) ; :INDEX INDEX) ; (DO* ((J START #) ; (END #) ; (INDEX 0 #)) ; ((INDEX>= J END)) ; (DECLARE ; (TYPE ARRAY-INDEX J ; END INDEX)) ; (SETF (AREF DATA J) ; (FUNCALL ; TRANSFORM ; #)))))) ; compiling (DEFUN READ-VECTOR-CARD8-WITH-TRANSFORM ...) ; file: /usr/share/common-lisp/source/clx/buffer.lisp ; in: DEFUN READ-SEQUENCE-CARD8 ; (DEFUN XLIB::READ-SEQUENCE-CARD8 ; (XLIB::REPLY-BUFFER XLIB::RESULT-TYPE XLIB::NITEMS ; &OPTIONAL XLIB::TRANSFORM XLIB::DATA (XLIB::START 0) (XLIB::INDEX 0)) ; (DECLARE (TYPE XLIB::REPLY-BUFFER XLIB::REPLY-BUFFER) ; (TYPE T XLIB::RESULT-TYPE) ; (TYPE XLIB:ARRAY-INDEX XLIB::NITEMS XLIB::START XLIB::INDEX) ; (TYPE (OR NULL SEQUENCE) XLIB::DATA)) ; (DECLARE (TYPE (OR NULL (FUNCTION # T)) XLIB::TRANSFORM) ; (DYNAMIC-EXTENT XLIB::TRANSFORM)) ; (LET ((XLIB::RESULT (OR XLIB::DATA #))) ; (TYPECASE XLIB::RESULT ; (LIST (IF XLIB::TRANSFORM # #)) ; ((SIMPLE-ARRAY XLIB:CARD8 #) (IF XLIB::TRANSFORM # #)) ; (T (IF XLIB::TRANSFORM # #))) ; XLIB::RESULT)) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN COND IF COND IF COND IF COND IF COND IF ; --> PROGN SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET ; ==> ; #:G937 ; ; note: could not stack allocate the result of (DEFUN READ-SEQUENCE-CARD8 ; (REPLY-BUFFER RESULT-TYPE NITEMS ; &OPTIONAL TRANSFORM DATA ; (START 0) (INDEX 0)) ; (DECLARE ; (TYPE REPLY-BUFFER REPLY-BUFFER) ; (TYPE T RESULT-TYPE) ; (TYPE ARRAY-INDEX NITEMS START INDEX) ; (TYPE (OR NULL SEQUENCE) DATA)) ; (DECLARE ; (TYPE (OR NULL (FUNCTION (CARD8) T)) ; TRANSFORM) ; (DYNAMIC-EXTENT TRANSFORM)) ; (LET ((RESULT ; (OR DATA ; (MAKE-SEQUENCE RESULT-TYPE ; NITEMS)))) ; (TYPECASE RESULT ; (LIST ; (IF TRANSFORM ; (READ-LIST-CARD8-WITH-TRANSFORM ; REPLY-BUFFER NITEMS RESULT ; TRANSFORM START INDEX) ; (READ-LIST-CARD8 REPLY-BUFFER ; NITEMS RESULT START INDEX))) ; ((SIMPLE-ARRAY CARD8 (*)) ; (IF TRANSFORM ; (READ-SIMPLE-ARRAY-CARD8-WITH-TRANSFORM ; REPLY-BUFFER NITEMS RESULT ; TRANSFORM START INDEX) ; (READ-SIMPLE-ARRAY-CARD8 ; REPLY-BUFFER NITEMS RESULT ; START INDEX))) ; (T ; (IF TRANSFORM ; (READ-VECTOR-CARD8-WITH-TRANSFORM ; REPLY-BUFFER NITEMS RESULT ; TRANSFORM START INDEX) ; (READ-VECTOR-CARD8 ; REPLY-BUFFER NITEMS RESULT ; START INDEX)))) ; RESULT)) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-C::%FUNCALL ; ==> ; XLIB::TRANSFORM ; ; note: could not stack allocate the result of (DEFUN READ-SEQUENCE-CARD8 ; (REPLY-BUFFER RESULT-TYPE NITEMS ; &OPTIONAL TRANSFORM DATA ; (START 0) (INDEX 0)) ; (DECLARE ; (TYPE REPLY-BUFFER REPLY-BUFFER) ; (TYPE T RESULT-TYPE) ; (TYPE ARRAY-INDEX NITEMS START INDEX) ; (TYPE (OR NULL SEQUENCE) DATA)) ; (DECLARE ; (TYPE (OR NULL (FUNCTION (CARD8) T)) ; TRANSFORM) ; (DYNAMIC-EXTENT TRANSFORM)) ; (LET ((RESULT ; (OR DATA ; (MAKE-SEQUENCE RESULT-TYPE ; NITEMS)))) ; (TYPECASE RESULT ; (LIST ; (IF TRANSFORM ; (READ-LIST-CARD8-WITH-TRANSFORM ; REPLY-BUFFER NITEMS RESULT ; TRANSFORM START INDEX) ; (READ-LIST-CARD8 REPLY-BUFFER ; NITEMS RESULT START INDEX))) ; ((SIMPLE-ARRAY CARD8 (*)) ; (IF TRANSFORM ; (READ-SIMPLE-ARRAY-CARD8-WITH-TRANSFORM ; REPLY-BUFFER NITEMS RESULT ; TRANSFORM START INDEX) ; (READ-SIMPLE-ARRAY-CARD8 ; REPLY-BUFFER NITEMS RESULT ; START INDEX))) ; (T ; (IF TRANSFORM ; (READ-VECTOR-CARD8-WITH-TRANSFORM ; REPLY-BUFFER NITEMS RESULT ; TRANSFORM START INDEX) ; (READ-VECTOR-CARD8 ; REPLY-BUFFER NITEMS RESULT ; START INDEX)))) ; RESULT)) ; compiling (DEFUN READ-SEQUENCE-CARD8 ...) ; file: /usr/share/common-lisp/source/clx/buffer.lisp ; in: DEFUN READ-SEQUENCE-INT8 ; (DEFUN XLIB::READ-SEQUENCE-INT8 ; (XLIB::REPLY-BUFFER XLIB::RESULT-TYPE XLIB::NITEMS ; &OPTIONAL XLIB::TRANSFORM XLIB::DATA (XLIB::START 0) (XLIB::INDEX 0)) ; (DECLARE (TYPE XLIB::REPLY-BUFFER XLIB::REPLY-BUFFER) ; (TYPE T XLIB::RESULT-TYPE) ; (TYPE XLIB:ARRAY-INDEX XLIB::NITEMS XLIB::START XLIB::INDEX) ; (TYPE (OR NULL SEQUENCE) XLIB::DATA)) ; (DECLARE (TYPE (OR NULL (FUNCTION # T)) XLIB::TRANSFORM) ; (DYNAMIC-EXTENT XLIB::TRANSFORM)) ; (IF XLIB::TRANSFORM ; (FLET ((XLIB::CARD8->INT8->TRANSFORM # ; # ; #)) ; (DECLARE (DYNAMIC-EXTENT #'XLIB::CARD8->INT8->TRANSFORM)) ; (XLIB::READ-SEQUENCE-CARD8 XLIB::REPLY-BUFFER XLIB::RESULT-TYPE ; XLIB::NITEMS #'XLIB::CARD8->INT8->TRANSFORM XLIB::DATA XLIB::START ; XLIB::INDEX)) ; (XLIB::READ-SEQUENCE-CARD8 XLIB::REPLY-BUFFER XLIB::RESULT-TYPE ; XLIB::NITEMS #'XLIB::CARD8->INT8 XLIB::DATA XLIB::START XLIB::INDEX))) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN COND IF COND IF COND IF COND IF COND IF ; --> PROGN SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET ; ==> ; #:G1011 ; ; note: could not stack allocate the result of (DEFUN READ-SEQUENCE-INT8 ; (REPLY-BUFFER RESULT-TYPE NITEMS ; &OPTIONAL TRANSFORM DATA ; (START 0) (INDEX 0)) ; (DECLARE ; (TYPE REPLY-BUFFER REPLY-BUFFER) ; (TYPE T RESULT-TYPE) ; (TYPE ARRAY-INDEX NITEMS START INDEX) ; (TYPE (OR NULL SEQUENCE) DATA)) ; (DECLARE ; (TYPE (OR NULL (FUNCTION (INT8) T)) ; TRANSFORM) ; (DYNAMIC-EXTENT TRANSFORM)) ; (IF TRANSFORM ; (FLET ((CARD8->INT8->TRANSFORM (V) ; (DECLARE #) ; (FUNCALL TRANSFORM #))) ; (DECLARE ; (DYNAMIC-EXTENT ; #'CARD8->INT8->TRANSFORM)) ; (READ-SEQUENCE-CARD8 ; REPLY-BUFFER RESULT-TYPE NITEMS ; #'CARD8->INT8->TRANSFORM DATA ; START INDEX)) ; (READ-SEQUENCE-CARD8 REPLY-BUFFER ; RESULT-TYPE NITEMS #'CARD8->INT8 ; DATA START INDEX))) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-C::%FUNCALL ; ==> ; XLIB::TRANSFORM ; ; note: could not stack allocate the result of (DEFUN READ-SEQUENCE-INT8 ; (REPLY-BUFFER RESULT-TYPE NITEMS ; &OPTIONAL TRANSFORM DATA ; (START 0) (INDEX 0)) ; (DECLARE ; (TYPE REPLY-BUFFER REPLY-BUFFER) ; (TYPE T RESULT-TYPE) ; (TYPE ARRAY-INDEX NITEMS START INDEX) ; (TYPE (OR NULL SEQUENCE) DATA)) ; (DECLARE ; (TYPE (OR NULL (FUNCTION (INT8) T)) ; TRANSFORM) ; (DYNAMIC-EXTENT TRANSFORM)) ; (IF TRANSFORM ; (FLET ((CARD8->INT8->TRANSFORM (V) ; (DECLARE #) ; (FUNCALL TRANSFORM #))) ; (DECLARE ; (DYNAMIC-EXTENT ; #'CARD8->INT8->TRANSFORM)) ; (READ-SEQUENCE-CARD8 ; REPLY-BUFFER RESULT-TYPE NITEMS ; #'CARD8->INT8->TRANSFORM DATA ; START INDEX)) ; (READ-SEQUENCE-CARD8 REPLY-BUFFER ; RESULT-TYPE NITEMS #'CARD8->INT8 ; DATA START INDEX))) ; compiling (DEFUN READ-SEQUENCE-INT8 ...) ; compiling (DEFUN READ-LIST-CARD16 ...) ; file: /usr/share/common-lisp/source/clx/buffer.lisp ; in: DEFUN READ-LIST-CARD16-WITH-TRANSFORM ; (DEFUN XLIB::READ-LIST-CARD16-WITH-TRANSFORM ; (XLIB::REPLY-BUFFER XLIB::NITEMS XLIB::DATA XLIB::TRANSFORM ; XLIB::START XLIB::INDEX) ; (DECLARE (TYPE XLIB::REPLY-BUFFER XLIB::REPLY-BUFFER) ; (TYPE XLIB:ARRAY-INDEX XLIB::NITEMS XLIB::START XLIB::INDEX) ; (TYPE LIST XLIB::DATA)) ; (DECLARE (TYPE (FUNCTION (XLIB:CARD16) T) XLIB::TRANSFORM) ; (DYNAMIC-EXTENT XLIB::TRANSFORM)) ; (XLIB::WITH-BUFFER-INPUT ; (XLIB::REPLY-BUFFER :SIZES (16) :INDEX XLIB::INDEX) ; (DO* ((XLIB::J XLIB::NITEMS #) ; (XLIB::LST # #) ; (XLIB::INDEX 0 #)) ; ((XLIB::INDEX-ZEROP XLIB::J)) ; (DECLARE (TYPE XLIB:ARRAY-INDEX XLIB::J XLIB::INDEX) (LIST XLIB::LST)) ; (SETF (CAR XLIB::LST) (FUNCALL XLIB::TRANSFORM #))))) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN LOCALLY SB-C::%FUNCALL ; ==> ; #:G1066 ; ; note: could not stack allocate the result of (DEFUN READ-LIST-CARD16-WITH-TRANSFORM ; (REPLY-BUFFER NITEMS DATA ; TRANSFORM START INDEX) ; (DECLARE ; (TYPE REPLY-BUFFER REPLY-BUFFER) ; (TYPE ARRAY-INDEX NITEMS START INDEX) ; (TYPE LIST DATA)) ; (DECLARE ; (TYPE (FUNCTION (CARD16) T) ; TRANSFORM) ; (DYNAMIC-EXTENT TRANSFORM)) ; (WITH-BUFFER-INPUT ; (REPLY-BUFFER :SIZES (16) :INDEX ; INDEX) ; (DO* ((J NITEMS (INDEX- J 1)) ; (LST (NTHCDR START DATA) ; (CDR LST)) ; (INDEX 0 (INDEX+ INDEX 2))) ; ((INDEX-ZEROP J)) ; (DECLARE (TYPE ARRAY-INDEX J INDEX) ; (LIST LST)) ; (SETF (CAR LST) ; (FUNCALL TRANSFORM ; (READ-CARD16 ; INDEX)))))) ; compiling (DEFUN READ-LIST-CARD16-WITH-TRANSFORM ...) ; compiling (DEFUN READ-SIMPLE-ARRAY-CARD16 ...) ; file: /usr/share/common-lisp/source/clx/buffer.lisp ; in: DEFUN READ-SIMPLE-ARRAY-CARD16-WITH-TRANSFORM ; (DEFUN XLIB::READ-SIMPLE-ARRAY-CARD16-WITH-TRANSFORM ; (XLIB::REPLY-BUFFER XLIB::NITEMS XLIB::DATA XLIB::TRANSFORM ; XLIB::START XLIB::INDEX) ; (DECLARE (TYPE XLIB::REPLY-BUFFER XLIB::REPLY-BUFFER) ; (TYPE XLIB:ARRAY-INDEX XLIB::NITEMS XLIB::START XLIB::INDEX) ; (TYPE (SIMPLE-ARRAY XLIB:CARD16 (*)) XLIB::DATA)) ; (DECLARE (TYPE (FUNCTION (XLIB:CARD16) XLIB:CARD16) XLIB::TRANSFORM) ; (DYNAMIC-EXTENT XLIB::TRANSFORM)) ; (XLIB::WITH-VECTOR (XLIB::DATA (SIMPLE-ARRAY XLIB:CARD16 (*))) ; (XLIB::WITH-BUFFER-INPUT ; (XLIB::REPLY-BUFFER :SIZES (16) :INDEX XLIB::INDEX) ; (DO* (# ; # ; #) ; (#) ; (DECLARE #) ; (SETF # #))))) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN LOCALLY SB-C::%FUNCALL ; ==> ; #:G1124 ; ; note: could not stack allocate the result of (DEFUN READ-SIMPLE-ARRAY-CARD16-WITH-TRANSFORM ; (REPLY-BUFFER NITEMS DATA ; TRANSFORM START INDEX) ; (DECLARE ; (TYPE REPLY-BUFFER REPLY-BUFFER) ; (TYPE ARRAY-INDEX NITEMS START INDEX) ; (TYPE (SIMPLE-ARRAY CARD16 (*)) ; DATA)) ; (DECLARE ; (TYPE (FUNCTION (CARD16) CARD16) ; TRANSFORM) ; (DYNAMIC-EXTENT TRANSFORM)) ; (WITH-VECTOR ; (DATA (SIMPLE-ARRAY CARD16 (*))) ; (WITH-BUFFER-INPUT ; (REPLY-BUFFER :SIZES (16) :INDEX ; INDEX) ; (DO* ((J START #) ; (END #) ; (INDEX 0 #)) ; ((INDEX>= J END)) ; (DECLARE ; (TYPE ARRAY-INDEX J END INDEX)) ; (SETF (AREF DATA J) ; (THE CARD16 #)))))) ; compiling (DEFUN READ-SIMPLE-ARRAY-CARD16-WITH-TRANSFORM ...) ; file: /usr/share/common-lisp/source/clx/buffer.lisp ; in: DEFUN READ-VECTOR-CARD16 ; (SETF (AREF XLIB::DATA XLIB::J) (XLIB::READ-CARD16 XLIB::INDEX)) ; --> SB-KERNEL:%ASET ; ==> ; (SB-KERNEL:HAIRY-DATA-VECTOR-SET ARRAY SB-INT:INDEX SB-C::NEW-VALUE) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a VECTOR, not a SIMPLE-STRING. ; ; note: unable to ; avoid runtime dispatch on array element type ; due to type uncertainty: ; The first argument is a VECTOR, not a SIMPLE-ARRAY. ; compiling (DEFUN READ-VECTOR-CARD16 ...) ; file: /usr/share/common-lisp/source/clx/buffer.lisp ; in: DEFUN READ-VECTOR-CARD16-WITH-TRANSFORM ; (SETF (AREF XLIB::DATA XLIB::J) ; (FUNCALL XLIB::TRANSFORM (XLIB::READ-CARD16 XLIB::INDEX))) ; --> SB-KERNEL:%ASET ; ==> ; (SB-KERNEL:HAIRY-DATA-VECTOR-SET ARRAY SB-INT:INDEX SB-C::NEW-VALUE) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a VECTOR, not a SIMPLE-STRING. ; ; note: unable to ; avoid runtime dispatch on array element type ; due to type uncertainty: ; The first argument is a VECTOR, not a SIMPLE-ARRAY. ; (DEFUN XLIB::READ-VECTOR-CARD16-WITH-TRANSFORM ; (XLIB::REPLY-BUFFER XLIB::NITEMS XLIB::DATA XLIB::TRANSFORM ; XLIB::START XLIB::INDEX) ; (DECLARE (TYPE XLIB::REPLY-BUFFER XLIB::REPLY-BUFFER) ; (TYPE XLIB:ARRAY-INDEX XLIB::NITEMS XLIB::START XLIB::INDEX) ; (TYPE VECTOR XLIB::DATA) (OPTIMIZE)) ; (DECLARE (TYPE (FUNCTION (XLIB:CARD16) T) XLIB::TRANSFORM) ; (DYNAMIC-EXTENT XLIB::TRANSFORM)) ; (XLIB::WITH-VECTOR (XLIB::DATA VECTOR) ; (XLIB::WITH-BUFFER-INPUT ; (XLIB::REPLY-BUFFER :SIZES (16) :INDEX XLIB::INDEX) ; (DO* (# ; # ; #) ; (#) ; (DECLARE #) ; (SETF # #))))) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN LOCALLY SB-C::%FUNCALL ; ==> ; #:G1184 ; ; note: could not stack allocate the result of (DEFUN READ-VECTOR-CARD16-WITH-TRANSFORM ; (REPLY-BUFFER NITEMS DATA ; TRANSFORM START INDEX) ; (DECLARE ; (TYPE REPLY-BUFFER REPLY-BUFFER) ; (TYPE ARRAY-INDEX NITEMS START INDEX) ; (TYPE VECTOR DATA) (OPTIMIZE)) ; (DECLARE ; (TYPE (FUNCTION (CARD16) T) ; TRANSFORM) ; (DYNAMIC-EXTENT TRANSFORM)) ; (WITH-VECTOR (DATA VECTOR) ; (WITH-BUFFER-INPUT ; (REPLY-BUFFER :SIZES ; (16) :INDEX INDEX) ; (DO* ((J START #) ; (END #) ; (INDEX 0 #)) ; ((INDEX>= J END)) ; (DECLARE ; (TYPE ARRAY-INDEX J ; END INDEX)) ; (SETF (AREF DATA J) ; (FUNCALL ; TRANSFORM ; #)))))) ; compiling (DEFUN READ-VECTOR-CARD16-WITH-TRANSFORM ...) ; file: /usr/share/common-lisp/source/clx/buffer.lisp ; in: DEFUN READ-SEQUENCE-CARD16 ; (DEFUN XLIB::READ-SEQUENCE-CARD16 ; (XLIB::REPLY-BUFFER XLIB::RESULT-TYPE XLIB::NITEMS ; &OPTIONAL XLIB::TRANSFORM XLIB::DATA (XLIB::START 0) (XLIB::INDEX 0)) ; (DECLARE (TYPE XLIB::REPLY-BUFFER XLIB::REPLY-BUFFER) ; (TYPE T XLIB::RESULT-TYPE) ; (TYPE XLIB:ARRAY-INDEX XLIB::NITEMS XLIB::START XLIB::INDEX) ; (TYPE (OR NULL SEQUENCE) XLIB::DATA)) ; (DECLARE (TYPE (OR NULL (FUNCTION # T)) XLIB::TRANSFORM) ; (DYNAMIC-EXTENT XLIB::TRANSFORM)) ; (LET ((XLIB::RESULT (OR XLIB::DATA #))) ; (TYPECASE XLIB::RESULT ; (LIST (IF XLIB::TRANSFORM # #)) ; ((SIMPLE-ARRAY XLIB:CARD16 #) (IF XLIB::TRANSFORM # #)) ; (T (IF XLIB::TRANSFORM # #))) ; XLIB::RESULT)) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN COND IF COND IF COND IF COND IF COND IF ; --> PROGN SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET ; ==> ; #:G1253 ; ; note: could not stack allocate the result of (DEFUN READ-SEQUENCE-CARD16 ; (REPLY-BUFFER RESULT-TYPE NITEMS ; &OPTIONAL TRANSFORM DATA ; (START 0) (INDEX 0)) ; (DECLARE ; (TYPE REPLY-BUFFER REPLY-BUFFER) ; (TYPE T RESULT-TYPE) ; (TYPE ARRAY-INDEX NITEMS START INDEX) ; (TYPE (OR NULL SEQUENCE) DATA)) ; (DECLARE ; (TYPE (OR NULL (FUNCTION (CARD16) T)) ; TRANSFORM) ; (DYNAMIC-EXTENT TRANSFORM)) ; (LET ((RESULT ; (OR DATA ; (MAKE-SEQUENCE RESULT-TYPE ; NITEMS)))) ; (TYPECASE RESULT ; (LIST ; (IF TRANSFORM ; (READ-LIST-CARD16-WITH-TRANSFORM ; REPLY-BUFFER NITEMS RESULT ; TRANSFORM START INDEX) ; (READ-LIST-CARD16 ; REPLY-BUFFER NITEMS RESULT ; START INDEX))) ; ((SIMPLE-ARRAY CARD16 (*)) ; (IF TRANSFORM ; (READ-SIMPLE-ARRAY-CARD16-WITH-TRANSFORM ; REPLY-BUFFER NITEMS RESULT ; TRANSFORM START INDEX) ; (READ-SIMPLE-ARRAY-CARD16 ; REPLY-BUFFER NITEMS RESULT ; START INDEX))) ; (T ; (IF TRANSFORM ; (READ-VECTOR-CARD16-WITH-TRANSFORM ; REPLY-BUFFER NITEMS RESULT ; TRANSFORM START INDEX) ; (READ-VECTOR-CARD16 ; REPLY-BUFFER NITEMS RESULT ; START INDEX)))) ; RESULT)) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-C::%FUNCALL ; ==> ; XLIB::TRANSFORM ; ; note: could not stack allocate the result of (DEFUN READ-SEQUENCE-CARD16 ; (REPLY-BUFFER RESULT-TYPE NITEMS ; &OPTIONAL TRANSFORM DATA ; (START 0) (INDEX 0)) ; (DECLARE ; (TYPE REPLY-BUFFER REPLY-BUFFER) ; (TYPE T RESULT-TYPE) ; (TYPE ARRAY-INDEX NITEMS START INDEX) ; (TYPE (OR NULL SEQUENCE) DATA)) ; (DECLARE ; (TYPE (OR NULL (FUNCTION (CARD16) T)) ; TRANSFORM) ; (DYNAMIC-EXTENT TRANSFORM)) ; (LET ((RESULT ; (OR DATA ; (MAKE-SEQUENCE RESULT-TYPE ; NITEMS)))) ; (TYPECASE RESULT ; (LIST ; (IF TRANSFORM ; (READ-LIST-CARD16-WITH-TRANSFORM ; REPLY-BUFFER NITEMS RESULT ; TRANSFORM START INDEX) ; (READ-LIST-CARD16 ; REPLY-BUFFER NITEMS RESULT ; START INDEX))) ; ((SIMPLE-ARRAY CARD16 (*)) ; (IF TRANSFORM ; (READ-SIMPLE-ARRAY-CARD16-WITH-TRANSFORM ; REPLY-BUFFER NITEMS RESULT ; TRANSFORM START INDEX) ; (READ-SIMPLE-ARRAY-CARD16 ; REPLY-BUFFER NITEMS RESULT ; START INDEX))) ; (T ; (IF TRANSFORM ; (READ-VECTOR-CARD16-WITH-TRANSFORM ; REPLY-BUFFER NITEMS RESULT ; TRANSFORM START INDEX) ; (READ-VECTOR-CARD16 ; REPLY-BUFFER NITEMS RESULT ; START INDEX)))) ; RESULT)) ; compiling (DEFUN READ-SEQUENCE-CARD16 ...) ; file: /usr/share/common-lisp/source/clx/buffer.lisp ; in: DEFUN READ-SEQUENCE-INT16 ; (DEFUN XLIB::READ-SEQUENCE-INT16 ; (XLIB::REPLY-BUFFER XLIB::RESULT-TYPE XLIB::NITEMS ; &OPTIONAL XLIB::TRANSFORM XLIB::DATA (XLIB::START 0) (XLIB::INDEX 0)) ; (DECLARE (TYPE XLIB::REPLY-BUFFER XLIB::REPLY-BUFFER) ; (TYPE T XLIB::RESULT-TYPE) ; (TYPE XLIB:ARRAY-INDEX XLIB::NITEMS XLIB::START XLIB::INDEX) ; (TYPE (OR NULL SEQUENCE) XLIB::DATA)) ; (DECLARE (TYPE (OR NULL (FUNCTION # T)) XLIB::TRANSFORM) ; (DYNAMIC-EXTENT XLIB::TRANSFORM)) ; (IF XLIB::TRANSFORM ; (FLET ((XLIB::CARD16->INT16->TRANSFORM # ; # ; #)) ; (DECLARE (DYNAMIC-EXTENT #'XLIB::CARD16->INT16->TRANSFORM)) ; (XLIB::READ-SEQUENCE-CARD16 XLIB::REPLY-BUFFER XLIB::RESULT-TYPE ; XLIB::NITEMS #'XLIB::CARD16->INT16->TRANSFORM XLIB::DATA XLIB::START ; XLIB::INDEX)) ; (XLIB::READ-SEQUENCE-CARD16 XLIB::REPLY-BUFFER XLIB::RESULT-TYPE ; XLIB::NITEMS #'XLIB::CARD16->INT16 XLIB::DATA XLIB::START ; XLIB::INDEX))) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN COND IF COND IF COND IF COND IF COND IF ; --> PROGN SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET ; ==> ; #:G1327 ; ; note: could not stack allocate the result of (DEFUN READ-SEQUENCE-INT16 ; (REPLY-BUFFER RESULT-TYPE NITEMS ; &OPTIONAL TRANSFORM DATA ; (START 0) (INDEX 0)) ; (DECLARE ; (TYPE REPLY-BUFFER REPLY-BUFFER) ; (TYPE T RESULT-TYPE) ; (TYPE ARRAY-INDEX NITEMS START INDEX) ; (TYPE (OR NULL SEQUENCE) DATA)) ; (DECLARE ; (TYPE (OR NULL (FUNCTION (INT16) T)) ; TRANSFORM) ; (DYNAMIC-EXTENT TRANSFORM)) ; (IF TRANSFORM ; (FLET ((CARD16->INT16->TRANSFORM ; (V) ; (DECLARE #) ; (FUNCALL TRANSFORM #))) ; (DECLARE ; (DYNAMIC-EXTENT ; #'CARD16->INT16->TRANSFORM)) ; (READ-SEQUENCE-CARD16 ; REPLY-BUFFER RESULT-TYPE NITEMS ; #'CARD16->INT16->TRANSFORM DATA ; START INDEX)) ; (READ-SEQUENCE-CARD16 REPLY-BUFFER ; RESULT-TYPE NITEMS ; #'CARD16->INT16 DATA START ; INDEX))) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-C::%FUNCALL ; ==> ; XLIB::TRANSFORM ; ; note: could not stack allocate the result of (DEFUN READ-SEQUENCE-INT16 ; (REPLY-BUFFER RESULT-TYPE NITEMS ; &OPTIONAL TRANSFORM DATA ; (START 0) (INDEX 0)) ; (DECLARE ; (TYPE REPLY-BUFFER REPLY-BUFFER) ; (TYPE T RESULT-TYPE) ; (TYPE ARRAY-INDEX NITEMS START INDEX) ; (TYPE (OR NULL SEQUENCE) DATA)) ; (DECLARE ; (TYPE (OR NULL (FUNCTION (INT16) T)) ; TRANSFORM) ; (DYNAMIC-EXTENT TRANSFORM)) ; (IF TRANSFORM ; (FLET ((CARD16->INT16->TRANSFORM ; (V) ; (DECLARE #) ; (FUNCALL TRANSFORM #))) ; (DECLARE ; (DYNAMIC-EXTENT ; #'CARD16->INT16->TRANSFORM)) ; (READ-SEQUENCE-CARD16 ; REPLY-BUFFER RESULT-TYPE NITEMS ; #'CARD16->INT16->TRANSFORM DATA ; START INDEX)) ; (READ-SEQUENCE-CARD16 REPLY-BUFFER ; RESULT-TYPE NITEMS ; #'CARD16->INT16 DATA START ; INDEX))) ; compiling (DEFUN READ-SEQUENCE-INT16 ...) ; compiling (DEFUN READ-LIST-CARD32 ...) ; file: /usr/share/common-lisp/source/clx/buffer.lisp ; in: DEFUN READ-LIST-CARD32-WITH-TRANSFORM ; (DEFUN XLIB::READ-LIST-CARD32-WITH-TRANSFORM ; (XLIB::REPLY-BUFFER XLIB::NITEMS XLIB::DATA XLIB::TRANSFORM ; XLIB::START XLIB::INDEX) ; (DECLARE (TYPE XLIB::REPLY-BUFFER XLIB::REPLY-BUFFER) ; (TYPE XLIB:ARRAY-INDEX XLIB::NITEMS XLIB::START XLIB::INDEX) ; (TYPE LIST XLIB::DATA)) ; (DECLARE (TYPE (FUNCTION (XLIB:CARD32) T) XLIB::TRANSFORM) ; (DYNAMIC-EXTENT XLIB::TRANSFORM)) ; (XLIB::WITH-BUFFER-INPUT ; (XLIB::REPLY-BUFFER :SIZES (32) :INDEX XLIB::INDEX) ; (DO* ((XLIB::J XLIB::NITEMS #) ; (XLIB::LST # #) ; (XLIB::INDEX 0 #)) ; ((XLIB::INDEX-ZEROP XLIB::J)) ; (DECLARE (TYPE XLIB:ARRAY-INDEX XLIB::J XLIB::INDEX) (LIST XLIB::LST)) ; (SETF (CAR XLIB::LST) (FUNCALL XLIB::TRANSFORM #))))) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN LOCALLY SB-C::%FUNCALL ; ==> ; #:G1382 ; ; note: could not stack allocate the result of (DEFUN READ-LIST-CARD32-WITH-TRANSFORM ; (REPLY-BUFFER NITEMS DATA ; TRANSFORM START INDEX) ; (DECLARE ; (TYPE REPLY-BUFFER REPLY-BUFFER) ; (TYPE ARRAY-INDEX NITEMS START INDEX) ; (TYPE LIST DATA)) ; (DECLARE ; (TYPE (FUNCTION (CARD32) T) ; TRANSFORM) ; (DYNAMIC-EXTENT TRANSFORM)) ; (WITH-BUFFER-INPUT ; (REPLY-BUFFER :SIZES (32) :INDEX ; INDEX) ; (DO* ((J NITEMS (INDEX- J 1)) ; (LST (NTHCDR START DATA) ; (CDR LST)) ; (INDEX 0 (INDEX+ INDEX 4))) ; ((INDEX-ZEROP J)) ; (DECLARE (TYPE ARRAY-INDEX J INDEX) ; (LIST LST)) ; (SETF (CAR LST) ; (FUNCALL TRANSFORM ; (READ-CARD32 ; INDEX)))))) ; compiling (DEFUN READ-LIST-CARD32-WITH-TRANSFORM ...) ; compiling (DEFUN READ-SIMPLE-ARRAY-CARD32 ...) ; file: /usr/share/common-lisp/source/clx/buffer.lisp ; in: DEFUN READ-SIMPLE-ARRAY-CARD32-WITH-TRANSFORM ; (DEFUN XLIB::READ-SIMPLE-ARRAY-CARD32-WITH-TRANSFORM ; (XLIB::REPLY-BUFFER XLIB::NITEMS XLIB::DATA XLIB::TRANSFORM ; XLIB::START XLIB::INDEX) ; (DECLARE (TYPE XLIB::REPLY-BUFFER XLIB::REPLY-BUFFER) ; (TYPE XLIB:ARRAY-INDEX XLIB::NITEMS XLIB::START XLIB::INDEX) ; (TYPE (SIMPLE-ARRAY XLIB:CARD32 (*)) XLIB::DATA)) ; (DECLARE (TYPE (FUNCTION (XLIB:CARD32) XLIB:CARD32) XLIB::TRANSFORM) ; (DYNAMIC-EXTENT XLIB::TRANSFORM)) ; (XLIB::WITH-VECTOR (XLIB::DATA (SIMPLE-ARRAY XLIB:CARD32 (*))) ; (XLIB::WITH-BUFFER-INPUT ; (XLIB::REPLY-BUFFER :SIZES (32) :INDEX XLIB::INDEX) ; (DO* (# ; # ; #) ; (#) ; (DECLARE #) ; (SETF # #))))) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN LOCALLY SB-C::%FUNCALL ; ==> ; #:G1440 ; ; note: could not stack allocate the result of (DEFUN READ-SIMPLE-ARRAY-CARD32-WITH-TRANSFORM ; (REPLY-BUFFER NITEMS DATA ; TRANSFORM START INDEX) ; (DECLARE ; (TYPE REPLY-BUFFER REPLY-BUFFER) ; (TYPE ARRAY-INDEX NITEMS START INDEX) ; (TYPE (SIMPLE-ARRAY CARD32 (*)) ; DATA)) ; (DECLARE ; (TYPE (FUNCTION (CARD32) CARD32) ; TRANSFORM) ; (DYNAMIC-EXTENT TRANSFORM)) ; (WITH-VECTOR ; (DATA (SIMPLE-ARRAY CARD32 (*))) ; (WITH-BUFFER-INPUT ; (REPLY-BUFFER :SIZES (32) :INDEX ; INDEX) ; (DO* ((J START #) ; (END #) ; (INDEX 0 #)) ; ((INDEX>= J END)) ; (DECLARE ; (TYPE ARRAY-INDEX J END INDEX)) ; (SETF (AREF DATA J) ; (THE CARD32 #)))))) ; compiling (DEFUN READ-SIMPLE-ARRAY-CARD32-WITH-TRANSFORM ...) ; file: /usr/share/common-lisp/source/clx/buffer.lisp ; in: DEFUN READ-VECTOR-CARD32 ; (SETF (AREF XLIB::DATA XLIB::J) (XLIB::READ-CARD32 XLIB::INDEX)) ; --> SB-KERNEL:%ASET ; ==> ; (SB-KERNEL:HAIRY-DATA-VECTOR-SET ARRAY SB-INT:INDEX SB-C::NEW-VALUE) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a VECTOR, not a SIMPLE-STRING. ; ; note: unable to ; avoid runtime dispatch on array element type ; due to type uncertainty: ; The first argument is a VECTOR, not a SIMPLE-ARRAY. ; compiling (DEFUN READ-VECTOR-CARD32 ...) ; file: /usr/share/common-lisp/source/clx/buffer.lisp ; in: DEFUN READ-VECTOR-CARD32-WITH-TRANSFORM ; (SETF (AREF XLIB::DATA XLIB::J) ; (FUNCALL XLIB::TRANSFORM (XLIB::READ-CARD32 XLIB::INDEX))) ; --> SB-KERNEL:%ASET ; ==> ; (SB-KERNEL:HAIRY-DATA-VECTOR-SET ARRAY SB-INT:INDEX SB-C::NEW-VALUE) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a VECTOR, not a SIMPLE-STRING. ; ; note: unable to ; avoid runtime dispatch on array element type ; due to type uncertainty: ; The first argument is a VECTOR, not a SIMPLE-ARRAY. ; (DEFUN XLIB::READ-VECTOR-CARD32-WITH-TRANSFORM ; (XLIB::REPLY-BUFFER XLIB::NITEMS XLIB::DATA XLIB::TRANSFORM ; XLIB::START XLIB::INDEX) ; (DECLARE (TYPE XLIB::REPLY-BUFFER XLIB::REPLY-BUFFER) ; (TYPE XLIB:ARRAY-INDEX XLIB::NITEMS XLIB::START XLIB::INDEX) ; (TYPE VECTOR XLIB::DATA) (OPTIMIZE)) ; (DECLARE (TYPE (FUNCTION (XLIB:CARD32) T) XLIB::TRANSFORM) ; (DYNAMIC-EXTENT XLIB::TRANSFORM)) ; (XLIB::WITH-VECTOR (XLIB::DATA VECTOR) ; (XLIB::WITH-BUFFER-INPUT ; (XLIB::REPLY-BUFFER :SIZES (32) :INDEX XLIB::INDEX) ; (DO* (# ; # ; #) ; (#) ; (DECLARE #) ; (SETF # #))))) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN LOCALLY SB-C::%FUNCALL ; ==> ; #:G1500 ; ; note: could not stack allocate the result of (DEFUN READ-VECTOR-CARD32-WITH-TRANSFORM ; (REPLY-BUFFER NITEMS DATA ; TRANSFORM START INDEX) ; (DECLARE ; (TYPE REPLY-BUFFER REPLY-BUFFER) ; (TYPE ARRAY-INDEX NITEMS START INDEX) ; (TYPE VECTOR DATA) (OPTIMIZE)) ; (DECLARE ; (TYPE (FUNCTION (CARD32) T) ; TRANSFORM) ; (DYNAMIC-EXTENT TRANSFORM)) ; (WITH-VECTOR (DATA VECTOR) ; (WITH-BUFFER-INPUT ; (REPLY-BUFFER :SIZES ; (32) :INDEX INDEX) ; (DO* ((J START #) ; (END #) ; (INDEX 0 #)) ; ((INDEX>= J END)) ; (DECLARE ; (TYPE ARRAY-INDEX J ; END INDEX)) ; (SETF (AREF DATA J) ; (FUNCALL ; TRANSFORM ; #)))))) ; compiling (DEFUN READ-VECTOR-CARD32-WITH-TRANSFORM ...) ; file: /usr/share/common-lisp/source/clx/buffer.lisp ; in: DEFUN READ-SEQUENCE-CARD32 ; (DEFUN XLIB::READ-SEQUENCE-CARD32 ; (XLIB::REPLY-BUFFER XLIB::RESULT-TYPE XLIB::NITEMS ; &OPTIONAL XLIB::TRANSFORM XLIB::DATA (XLIB::START 0) (XLIB::INDEX 0)) ; (DECLARE (TYPE XLIB::REPLY-BUFFER XLIB::REPLY-BUFFER) ; (TYPE T XLIB::RESULT-TYPE) ; (TYPE XLIB:ARRAY-INDEX XLIB::NITEMS XLIB::START XLIB::INDEX) ; (TYPE (OR NULL SEQUENCE) XLIB::DATA)) ; (DECLARE (TYPE (OR NULL (FUNCTION # T)) XLIB::TRANSFORM) ; (DYNAMIC-EXTENT XLIB::TRANSFORM)) ; (LET ((XLIB::RESULT (OR XLIB::DATA #))) ; (TYPECASE XLIB::RESULT ; (LIST (IF XLIB::TRANSFORM # #)) ; ((SIMPLE-ARRAY XLIB:CARD32 #) (IF XLIB::TRANSFORM # #)) ; (T (IF XLIB::TRANSFORM # #))) ; XLIB::RESULT)) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN COND IF COND IF COND IF COND IF COND IF ; --> PROGN SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET ; ==> ; #:G1569 ; ; note: could not stack allocate the result of (DEFUN READ-SEQUENCE-CARD32 ; (REPLY-BUFFER RESULT-TYPE NITEMS ; &OPTIONAL TRANSFORM DATA ; (START 0) (INDEX 0)) ; (DECLARE ; (TYPE REPLY-BUFFER REPLY-BUFFER) ; (TYPE T RESULT-TYPE) ; (TYPE ARRAY-INDEX NITEMS START INDEX) ; (TYPE (OR NULL SEQUENCE) DATA)) ; (DECLARE ; (TYPE (OR NULL (FUNCTION (CARD32) T)) ; TRANSFORM) ; (DYNAMIC-EXTENT TRANSFORM)) ; (LET ((RESULT ; (OR DATA ; (MAKE-SEQUENCE RESULT-TYPE ; NITEMS)))) ; (TYPECASE RESULT ; (LIST ; (IF TRANSFORM ; (READ-LIST-CARD32-WITH-TRANSFORM ; REPLY-BUFFER NITEMS RESULT ; TRANSFORM START INDEX) ; (READ-LIST-CARD32 ; REPLY-BUFFER NITEMS RESULT ; START INDEX))) ; ((SIMPLE-ARRAY CARD32 (*)) ; (IF TRANSFORM ; (READ-SIMPLE-ARRAY-CARD32-WITH-TRANSFORM ; REPLY-BUFFER NITEMS RESULT ; TRANSFORM START INDEX) ; (READ-SIMPLE-ARRAY-CARD32 ; REPLY-BUFFER NITEMS RESULT ; START INDEX))) ; (T ; (IF TRANSFORM ; (READ-VECTOR-CARD32-WITH-TRANSFORM ; REPLY-BUFFER NITEMS RESULT ; TRANSFORM START INDEX) ; (READ-VECTOR-CARD32 ; REPLY-BUFFER NITEMS RESULT ; START INDEX)))) ; RESULT)) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-C::%FUNCALL ; ==> ; XLIB::TRANSFORM ; ; note: could not stack allocate the result of (DEFUN READ-SEQUENCE-CARD32 ; (REPLY-BUFFER RESULT-TYPE NITEMS ; &OPTIONAL TRANSFORM DATA ; (START 0) (INDEX 0)) ; (DECLARE ; (TYPE REPLY-BUFFER REPLY-BUFFER) ; (TYPE T RESULT-TYPE) ; (TYPE ARRAY-INDEX NITEMS START INDEX) ; (TYPE (OR NULL SEQUENCE) DATA)) ; (DECLARE ; (TYPE (OR NULL (FUNCTION (CARD32) T)) ; TRANSFORM) ; (DYNAMIC-EXTENT TRANSFORM)) ; (LET ((RESULT ; (OR DATA ; (MAKE-SEQUENCE RESULT-TYPE ; NITEMS)))) ; (TYPECASE RESULT ; (LIST ; (IF TRANSFORM ; (READ-LIST-CARD32-WITH-TRANSFORM ; REPLY-BUFFER NITEMS RESULT ; TRANSFORM START INDEX) ; (READ-LIST-CARD32 ; REPLY-BUFFER NITEMS RESULT ; START INDEX))) ; ((SIMPLE-ARRAY CARD32 (*)) ; (IF TRANSFORM ; (READ-SIMPLE-ARRAY-CARD32-WITH-TRANSFORM ; REPLY-BUFFER NITEMS RESULT ; TRANSFORM START INDEX) ; (READ-SIMPLE-ARRAY-CARD32 ; REPLY-BUFFER NITEMS RESULT ; START INDEX))) ; (T ; (IF TRANSFORM ; (READ-VECTOR-CARD32-WITH-TRANSFORM ; REPLY-BUFFER NITEMS RESULT ; TRANSFORM START INDEX) ; (READ-VECTOR-CARD32 ; REPLY-BUFFER NITEMS RESULT ; START INDEX)))) ; RESULT)) ; compiling (DEFUN READ-SEQUENCE-CARD32 ...) ; file: /usr/share/common-lisp/source/clx/buffer.lisp ; in: DEFUN READ-SEQUENCE-INT32 ; (DEFUN XLIB::READ-SEQUENCE-INT32 ; (XLIB::REPLY-BUFFER XLIB::RESULT-TYPE XLIB::NITEMS ; &OPTIONAL XLIB::TRANSFORM XLIB::DATA (XLIB::START 0) (XLIB::INDEX 0)) ; (DECLARE (TYPE XLIB::REPLY-BUFFER XLIB::REPLY-BUFFER) ; (TYPE T XLIB::RESULT-TYPE) ; (TYPE XLIB:ARRAY-INDEX XLIB::NITEMS XLIB::START XLIB::INDEX) ; (TYPE (OR NULL SEQUENCE) XLIB::DATA)) ; (DECLARE (TYPE (OR NULL (FUNCTION # T)) XLIB::TRANSFORM) ; (DYNAMIC-EXTENT XLIB::TRANSFORM)) ; (IF XLIB::TRANSFORM ; (FLET ((XLIB::CARD32->INT32->TRANSFORM # ; # ; #)) ; (DECLARE (DYNAMIC-EXTENT #'XLIB::CARD32->INT32->TRANSFORM)) ; (XLIB::READ-SEQUENCE-CARD32 XLIB::REPLY-BUFFER XLIB::RESULT-TYPE ; XLIB::NITEMS #'XLIB::CARD32->INT32->TRANSFORM XLIB::DATA XLIB::START ; XLIB::INDEX)) ; (XLIB::READ-SEQUENCE-CARD32 XLIB::REPLY-BUFFER XLIB::RESULT-TYPE ; XLIB::NITEMS #'XLIB::CARD32->INT32 XLIB::DATA XLIB::START ; XLIB::INDEX))) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN COND IF COND IF COND IF COND IF COND IF ; --> PROGN SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET ; ==> ; #:G1643 ; ; note: could not stack allocate the result of (DEFUN READ-SEQUENCE-INT32 ; (REPLY-BUFFER RESULT-TYPE NITEMS ; &OPTIONAL TRANSFORM DATA ; (START 0) (INDEX 0)) ; (DECLARE ; (TYPE REPLY-BUFFER REPLY-BUFFER) ; (TYPE T RESULT-TYPE) ; (TYPE ARRAY-INDEX NITEMS START INDEX) ; (TYPE (OR NULL SEQUENCE) DATA)) ; (DECLARE ; (TYPE (OR NULL (FUNCTION (INT32) T)) ; TRANSFORM) ; (DYNAMIC-EXTENT TRANSFORM)) ; (IF TRANSFORM ; (FLET ((CARD32->INT32->TRANSFORM ; (V) ; (DECLARE #) ; (FUNCALL TRANSFORM #))) ; (DECLARE ; (DYNAMIC-EXTENT ; #'CARD32->INT32->TRANSFORM)) ; (READ-SEQUENCE-CARD32 ; REPLY-BUFFER RESULT-TYPE NITEMS ; #'CARD32->INT32->TRANSFORM DATA ; START INDEX)) ; (READ-SEQUENCE-CARD32 REPLY-BUFFER ; RESULT-TYPE NITEMS ; #'CARD32->INT32 DATA START ; INDEX))) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-C::%FUNCALL ; ==> ; XLIB::TRANSFORM ; ; note: could not stack allocate the result of (DEFUN READ-SEQUENCE-INT32 ; (REPLY-BUFFER RESULT-TYPE NITEMS ; &OPTIONAL TRANSFORM DATA ; (START 0) (INDEX 0)) ; (DECLARE ; (TYPE REPLY-BUFFER REPLY-BUFFER) ; (TYPE T RESULT-TYPE) ; (TYPE ARRAY-INDEX NITEMS START INDEX) ; (TYPE (OR NULL SEQUENCE) DATA)) ; (DECLARE ; (TYPE (OR NULL (FUNCTION (INT32) T)) ; TRANSFORM) ; (DYNAMIC-EXTENT TRANSFORM)) ; (IF TRANSFORM ; (FLET ((CARD32->INT32->TRANSFORM ; (V) ; (DECLARE #) ; (FUNCALL TRANSFORM #))) ; (DECLARE ; (DYNAMIC-EXTENT ; #'CARD32->INT32->TRANSFORM)) ; (READ-SEQUENCE-CARD32 ; REPLY-BUFFER RESULT-TYPE NITEMS ; #'CARD32->INT32->TRANSFORM DATA ; START INDEX)) ; (READ-SEQUENCE-CARD32 REPLY-BUFFER ; RESULT-TYPE NITEMS ; #'CARD32->INT32 DATA START ; INDEX))) ; compiling (DEFUN READ-SEQUENCE-INT32 ...) ; file: /usr/share/common-lisp/source/clx/buffer.lisp ; in: DEFUN WRITE-SEQUENCE-CHAR ; (DEFUN XLIB::WRITE-SEQUENCE-CHAR ; (XLIB::BUFFER XLIB::BOFFSET XLIB::DATA ; &OPTIONAL (XLIB::START 0) (XLIB::END (LENGTH XLIB::DATA)) ; XLIB::TRANSFORM) ; (DECLARE (TYPE XLIB::BUFFER XLIB::BUFFER) (TYPE SEQUENCE XLIB::DATA) ; (TYPE XLIB:ARRAY-INDEX XLIB::BOFFSET XLIB::START XLIB::END)) ; (DECLARE (TYPE (OR NULL (FUNCTION # CHARACTER)) XLIB::TRANSFORM) ; (DYNAMIC-EXTENT XLIB::TRANSFORM)) ; (IF XLIB::TRANSFORM ; (FLET ((XLIB::TRANSFORM->CHAR->CARD8 # ; #)) ; (DECLARE (DYNAMIC-EXTENT #'XLIB::TRANSFORM->CHAR->CARD8)) ; (XLIB::WRITE-SEQUENCE-CARD8 XLIB::BUFFER XLIB::BOFFSET XLIB::DATA ; XLIB::START XLIB::END #'XLIB::TRANSFORM->CHAR->CARD8)) ; (XLIB::WRITE-SEQUENCE-CARD8 XLIB::BUFFER XLIB::BOFFSET XLIB::DATA ; XLIB::START XLIB::END #'XLIB:CHAR->CARD8))) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN COND IF COND IF COND IF COND IF PROGN ; --> SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET ; ==> ; #:G1705 ; ; note: could not stack allocate the result of (DEFUN WRITE-SEQUENCE-CHAR ; (BUFFER BOFFSET DATA ; &OPTIONAL (START 0) ; (END (LENGTH DATA)) TRANSFORM) ; (DECLARE (TYPE BUFFER BUFFER) ; (TYPE SEQUENCE DATA) ; (TYPE ARRAY-INDEX BOFFSET START END)) ; (DECLARE ; (TYPE ; (OR NULL (FUNCTION (T) CHARACTER)) ; TRANSFORM) ; (DYNAMIC-EXTENT TRANSFORM)) ; (IF TRANSFORM ; (FLET ((TRANSFORM->CHAR->CARD8 (X) ; (CHAR->CARD8 #))) ; (DECLARE ; (DYNAMIC-EXTENT ; #'TRANSFORM->CHAR->CARD8)) ; (WRITE-SEQUENCE-CARD8 BUFFER ; BOFFSET DATA START END ; #'TRANSFORM->CHAR->CARD8)) ; (WRITE-SEQUENCE-CARD8 BUFFER ; BOFFSET DATA START END ; #'CHAR->CARD8))) ; compiling (DEFUN WRITE-SEQUENCE-CHAR ...) ; compiling (DEFUN WRITE-LIST-CARD8 ...) ; file: /usr/share/common-lisp/source/clx/buffer.lisp ; in: DEFUN WRITE-LIST-CARD8-WITH-TRANSFORM ; (DEFUN XLIB::WRITE-LIST-CARD8-WITH-TRANSFORM ; (XLIB::BUFFER XLIB::BOFFSET XLIB::DATA XLIB::START XLIB::END ; XLIB::TRANSFORM) ; (DECLARE (TYPE XLIB::BUFFER XLIB::BUFFER) (TYPE LIST XLIB::DATA) ; (TYPE XLIB:ARRAY-INDEX XLIB::BOFFSET XLIB::START XLIB::END)) ; (DECLARE (TYPE (FUNCTION (T) XLIB:CARD8) XLIB::TRANSFORM) ; (DYNAMIC-EXTENT XLIB::TRANSFORM)) ; (XLIB::WRITING-BUFFER-CHUNKS XLIB:CARD8 ; ((XLIB::LST (NTHCDR XLIB::START XLIB::DATA))) ; ((TYPE LIST XLIB::LST)) ; (DOTIMES (XLIB::J XLIB::CHUNK) ; (DECLARE (TYPE XLIB:ARRAY-INDEX XLIB::J)) ; (XLIB::WRITE-CARD8 XLIB::J ; (FUNCALL XLIB::TRANSFORM ; #)))) ; NIL) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN LOCALLY SB-C::%FUNCALL ; ==> ; #:G1813 ; ; note: could not stack allocate the result of (DEFUN WRITE-LIST-CARD8-WITH-TRANSFORM ; (BUFFER BOFFSET DATA START END ; TRANSFORM) ; (DECLARE (TYPE BUFFER BUFFER) ; (TYPE LIST DATA) ; (TYPE ARRAY-INDEX BOFFSET START END)) ; (DECLARE ; (TYPE (FUNCTION (T) CARD8) TRANSFORM) ; (DYNAMIC-EXTENT TRANSFORM)) ; (WRITING-BUFFER-CHUNKS CARD8 ; ((LST ; (NTHCDR START ; DATA))) ; ((TYPE LIST ; LST)) ; (DOTIMES ; (J CHUNK) ; (DECLARE ; (TYPE ; ARRAY-INDEX ; J)) ; (WRITE-CARD8 ; J ; (FUNCALL ; TRANSFORM ; (POP ; LST))))) ; NIL) ; compiling (DEFUN WRITE-LIST-CARD8-WITH-TRANSFORM ...) ; compiling (DEFUN WRITE-SIMPLE-ARRAY-CARD8 ...) ; file: /usr/share/common-lisp/source/clx/buffer.lisp ; in: DEFUN WRITE-SIMPLE-ARRAY-CARD8-WITH-TRANSFORM ; (DEFUN XLIB::WRITE-SIMPLE-ARRAY-CARD8-WITH-TRANSFORM ; (XLIB::BUFFER XLIB::BOFFSET XLIB::DATA XLIB::START XLIB::END ; XLIB::TRANSFORM) ; (DECLARE (TYPE XLIB::BUFFER XLIB::BUFFER) ; (TYPE (SIMPLE-ARRAY XLIB:CARD8 (*)) XLIB::DATA) ; (TYPE XLIB:ARRAY-INDEX XLIB::BOFFSET XLIB::START XLIB::END)) ; (DECLARE (TYPE (FUNCTION (XLIB:CARD8) XLIB:CARD8) XLIB::TRANSFORM) ; (DYNAMIC-EXTENT XLIB::TRANSFORM)) ; (XLIB::WITH-VECTOR (XLIB::DATA (SIMPLE-ARRAY XLIB:CARD8 (*))) ; (XLIB::WRITING-BUFFER-CHUNKS XLIB:CARD8 ; ((XLIB::INDEX XLIB::START)) ; ((TYPE XLIB:ARRAY-INDEX ; XLIB::INDEX)) ; (DOTIMES ; (XLIB::J XLIB::CHUNK) ; (DECLARE #) ; (XLIB::WRITE-CARD8 ; XLIB::J #) ; (SETQ XLIB::INDEX #)))) ; NIL) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN LOCALLY SB-C::%FUNCALL ; ==> ; #:G1942 ; ; note: could not stack allocate the result of (DEFUN WRITE-SIMPLE-ARRAY-CARD8-WITH-TRANSFORM ; (BUFFER BOFFSET DATA START END ; TRANSFORM) ; (DECLARE (TYPE BUFFER BUFFER) ; (TYPE (SIMPLE-ARRAY CARD8 (*)) DATA) ; (TYPE ARRAY-INDEX BOFFSET START END)) ; (DECLARE ; (TYPE (FUNCTION (CARD8) CARD8) ; TRANSFORM) ; (DYNAMIC-EXTENT TRANSFORM)) ; (WITH-VECTOR ; (DATA (SIMPLE-ARRAY CARD8 (*))) ; (WRITING-BUFFER-CHUNKS CARD8 ; ((INDEX ; START)) ; ((TYPE ; ARRAY-INDEX ; INDEX)) ; (DOTIMES ; (J CHUNK) ; (DECLARE ; (TYPE ; ARRAY-INDEX ; J)) ; (WRITE-CARD8 ; J ; (FUNCALL ; TRANSFORM ; #)) ; (SETQ INDEX ; (INDEX+ ; INDEX ; 1))))) ; NIL) ; compiling (DEFUN WRITE-SIMPLE-ARRAY-CARD8-WITH-TRANSFORM ...) ; file: /usr/share/common-lisp/source/clx/buffer.lisp ; in: DEFUN WRITE-VECTOR-CARD8 ; (AREF XLIB::DATA XLIB::INDEX) ; ==> ; (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a VECTOR, not a SIMPLE-STRING. ; ; note: unable to ; avoid runtime dispatch on array element type ; due to type uncertainty: ; The first argument is a VECTOR, not a SIMPLE-ARRAY. ; compiling (DEFUN WRITE-VECTOR-CARD8 ...) ; file: /usr/share/common-lisp/source/clx/buffer.lisp ; in: DEFUN WRITE-VECTOR-CARD8-WITH-TRANSFORM ; (AREF XLIB::DATA XLIB::INDEX) ; ==> ; (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a VECTOR, not a SIMPLE-STRING. ; ; note: unable to ; avoid runtime dispatch on array element type ; due to type uncertainty: ; The first argument is a VECTOR, not a SIMPLE-ARRAY. ; (DEFUN XLIB::WRITE-VECTOR-CARD8-WITH-TRANSFORM ; (XLIB::BUFFER XLIB::BOFFSET XLIB::DATA XLIB::START XLIB::END ; XLIB::TRANSFORM) ; (DECLARE (TYPE XLIB::BUFFER XLIB::BUFFER) (TYPE VECTOR XLIB::DATA) ; (TYPE XLIB:ARRAY-INDEX XLIB::BOFFSET XLIB::START XLIB::END)) ; (DECLARE (TYPE (FUNCTION (T) XLIB:CARD8) XLIB::TRANSFORM) ; (DYNAMIC-EXTENT XLIB::TRANSFORM)) ; (XLIB::WITH-VECTOR (XLIB::DATA VECTOR) ; (XLIB::WRITING-BUFFER-CHUNKS XLIB:CARD8 ; ((XLIB::INDEX XLIB::START)) ; ((TYPE XLIB:ARRAY-INDEX ; XLIB::INDEX)) ; (DOTIMES ; (XLIB::J XLIB::CHUNK) ; (DECLARE #) ; (XLIB::WRITE-CARD8 ; XLIB::J #) ; (SETQ XLIB::INDEX #)))) ; NIL) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN LOCALLY SB-C::%FUNCALL ; ==> ; #:G2053 ; ; note: could not stack allocate the result of (DEFUN WRITE-VECTOR-CARD8-WITH-TRANSFORM ; (BUFFER BOFFSET DATA START END ; TRANSFORM) ; (DECLARE (TYPE BUFFER BUFFER) ; (TYPE VECTOR DATA) ; (TYPE ARRAY-INDEX BOFFSET START END)) ; (DECLARE ; (TYPE (FUNCTION (T) CARD8) TRANSFORM) ; (DYNAMIC-EXTENT TRANSFORM)) ; (WITH-VECTOR (DATA VECTOR) ; (WRITING-BUFFER-CHUNKS ; CARD8 ((INDEX START)) ; ((TYPE ARRAY-INDEX ; INDEX)) ; (DOTIMES (J CHUNK) ; (DECLARE ; (TYPE ARRAY-INDEX J)) ; (WRITE-CARD8 J ; (FUNCALL ; TRANSFORM ; #)) ; (SETQ INDEX ; (INDEX+ INDEX ; 1))))) ; NIL) ; compiling (DEFUN WRITE-VECTOR-CARD8-WITH-TRANSFORM ...) ; file: /usr/share/common-lisp/source/clx/buffer.lisp ; in: DEFUN WRITE-SEQUENCE-CARD8 ; (DEFUN XLIB::WRITE-SEQUENCE-CARD8 ; (XLIB::BUFFER XLIB::BOFFSET XLIB::DATA ; &OPTIONAL (XLIB::START 0) (XLIB::END (LENGTH XLIB::DATA)) ; XLIB::TRANSFORM) ; (DECLARE (TYPE XLIB::BUFFER XLIB::BUFFER) (TYPE SEQUENCE XLIB::DATA) ; (TYPE XLIB:ARRAY-INDEX XLIB::BOFFSET XLIB::START XLIB::END)) ; (DECLARE (TYPE (OR NULL (FUNCTION # XLIB:CARD8)) XLIB::TRANSFORM) ; (DYNAMIC-EXTENT XLIB::TRANSFORM)) ; (TYPECASE XLIB::DATA ; (LIST ; (IF XLIB::TRANSFORM ; (XLIB::WRITE-LIST-CARD8-WITH-TRANSFORM XLIB::BUFFER XLIB::BOFFSET ; XLIB::DATA XLIB::START XLIB::END XLIB::TRANSFORM) ; (XLIB::WRITE-LIST-CARD8 XLIB::BUFFER XLIB::BOFFSET XLIB::DATA ; XLIB::START XLIB::END))) ; ((SIMPLE-ARRAY XLIB:CARD8 (*)) ; (IF XLIB::TRANSFORM ; (XLIB::WRITE-SIMPLE-ARRAY-CARD8-WITH-TRANSFORM XLIB::BUFFER ; XLIB::BOFFSET XLIB::DATA XLIB::START XLIB::END XLIB::TRANSFORM) ; (XLIB::WRITE-SIMPLE-ARRAY-CARD8 XLIB::BUFFER XLIB::BOFFSET ; XLIB::DATA XLIB::START XLIB::END))) ; (T ; (IF XLIB::TRANSFORM ; (XLIB::WRITE-VECTOR-CARD8-WITH-TRANSFORM XLIB::BUFFER XLIB::BOFFSET ; XLIB::DATA XLIB::START XLIB::END XLIB::TRANSFORM) ; (XLIB::WRITE-VECTOR-CARD8 XLIB::BUFFER XLIB::BOFFSET XLIB::DATA ; XLIB::START XLIB::END))))) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN COND IF COND IF COND IF COND IF PROGN ; --> SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET ; ==> ; #:G2114 ; ; note: could not stack allocate the result of (DEFUN WRITE-SEQUENCE-CARD8 ; (BUFFER BOFFSET DATA ; &OPTIONAL (START 0) ; (END (LENGTH DATA)) TRANSFORM) ; (DECLARE (TYPE BUFFER BUFFER) ; (TYPE SEQUENCE DATA) ; (TYPE ARRAY-INDEX BOFFSET START END)) ; (DECLARE ; (TYPE (OR NULL (FUNCTION (T) CARD8)) ; TRANSFORM) ; (DYNAMIC-EXTENT TRANSFORM)) ; (TYPECASE DATA ; (LIST ; (IF TRANSFORM ; (WRITE-LIST-CARD8-WITH-TRANSFORM ; BUFFER BOFFSET DATA START END ; TRANSFORM) ; (WRITE-LIST-CARD8 BUFFER ; BOFFSET DATA START END))) ; ((SIMPLE-ARRAY CARD8 (*)) ; (IF TRANSFORM ; (WRITE-SIMPLE-ARRAY-CARD8-WITH-TRANSFORM ; BUFFER BOFFSET DATA START END ; TRANSFORM) ; (WRITE-SIMPLE-ARRAY-CARD8 ; BUFFER BOFFSET DATA START ; END))) ; (T ; (IF TRANSFORM ; (WRITE-VECTOR-CARD8-WITH-TRANSFORM ; BUFFER BOFFSET DATA START END ; TRANSFORM) ; (WRITE-VECTOR-CARD8 BUFFER ; BOFFSET DATA START END))))) ; compiling (DEFUN WRITE-SEQUENCE-CARD8 ...) ; file: /usr/share/common-lisp/source/clx/buffer.lisp ; in: DEFUN WRITE-SEQUENCE-INT8 ; (DEFUN XLIB::WRITE-SEQUENCE-INT8 ; (XLIB::BUFFER XLIB::BOFFSET XLIB::DATA ; &OPTIONAL (XLIB::START 0) (XLIB::END (LENGTH XLIB::DATA)) ; XLIB::TRANSFORM) ; (DECLARE (TYPE XLIB::BUFFER XLIB::BUFFER) (TYPE SEQUENCE XLIB::DATA) ; (TYPE XLIB:ARRAY-INDEX XLIB::BOFFSET XLIB::START XLIB::END)) ; (DECLARE (TYPE (OR NULL (FUNCTION # XLIB:INT8)) XLIB::TRANSFORM) ; (DYNAMIC-EXTENT XLIB::TRANSFORM)) ; (IF XLIB::TRANSFORM ; (FLET ((XLIB::TRANSFORM->INT8->CARD8 # ; #)) ; (DECLARE (DYNAMIC-EXTENT #'XLIB::TRANSFORM->INT8->CARD8)) ; (XLIB::WRITE-SEQUENCE-CARD8 XLIB::BUFFER XLIB::BOFFSET XLIB::DATA ; XLIB::START XLIB::END #'XLIB::TRANSFORM->INT8->CARD8)) ; (XLIB::WRITE-SEQUENCE-CARD8 XLIB::BUFFER XLIB::BOFFSET XLIB::DATA ; XLIB::START XLIB::END #'XLIB::INT8->CARD8))) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN COND IF COND IF COND IF COND IF PROGN ; --> SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET ; ==> ; #:G2175 ; ; note: could not stack allocate the result of (DEFUN WRITE-SEQUENCE-INT8 ; (BUFFER BOFFSET DATA ; &OPTIONAL (START 0) ; (END (LENGTH DATA)) TRANSFORM) ; (DECLARE (TYPE BUFFER BUFFER) ; (TYPE SEQUENCE DATA) ; (TYPE ARRAY-INDEX BOFFSET START END)) ; (DECLARE ; (TYPE (OR NULL (FUNCTION (T) INT8)) ; TRANSFORM) ; (DYNAMIC-EXTENT TRANSFORM)) ; (IF TRANSFORM ; (FLET ((TRANSFORM->INT8->CARD8 (X) ; (INT8->CARD8 #))) ; (DECLARE ; (DYNAMIC-EXTENT ; #'TRANSFORM->INT8->CARD8)) ; (WRITE-SEQUENCE-CARD8 BUFFER ; BOFFSET DATA START END ; #'TRANSFORM->INT8->CARD8)) ; (WRITE-SEQUENCE-CARD8 BUFFER ; BOFFSET DATA START END ; #'INT8->CARD8))) ; compiling (DEFUN WRITE-SEQUENCE-INT8 ...) ; compiling (DEFUN WRITE-LIST-CARD16 ...) ; file: /usr/share/common-lisp/source/clx/buffer.lisp ; in: DEFUN WRITE-LIST-CARD16-WITH-TRANSFORM ; (DEFUN XLIB::WRITE-LIST-CARD16-WITH-TRANSFORM ; (XLIB::BUFFER XLIB::BOFFSET XLIB::DATA XLIB::START XLIB::END ; XLIB::TRANSFORM) ; (DECLARE (TYPE XLIB::BUFFER XLIB::BUFFER) (TYPE LIST XLIB::DATA) ; (TYPE XLIB:ARRAY-INDEX XLIB::BOFFSET XLIB::START XLIB::END)) ; (DECLARE (TYPE (FUNCTION (T) XLIB:CARD16) XLIB::TRANSFORM) ; (DYNAMIC-EXTENT XLIB::TRANSFORM)) ; (XLIB::WRITING-BUFFER-CHUNKS XLIB:CARD16 ; ((XLIB::LST (NTHCDR XLIB::START XLIB::DATA))) ; ((TYPE LIST XLIB::LST)) ; (DO ((XLIB::J 0 #)) ; ((XLIB::INDEX>= XLIB::J XLIB::CHUNK)) ; (DECLARE (TYPE XLIB:ARRAY-INDEX XLIB::J)) ; (XLIB::WRITE-CARD16 XLIB::J ; (FUNCALL XLIB::TRANSFORM ; #)))) ; NIL) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN LOCALLY SB-C::%FUNCALL ; ==> ; #:G2276 ; ; note: could not stack allocate the result of (DEFUN WRITE-LIST-CARD16-WITH-TRANSFORM ; (BUFFER BOFFSET DATA START END ; TRANSFORM) ; (DECLARE (TYPE BUFFER BUFFER) ; (TYPE LIST DATA) ; (TYPE ARRAY-INDEX BOFFSET START END)) ; (DECLARE ; (TYPE (FUNCTION (T) CARD16) ; TRANSFORM) ; (DYNAMIC-EXTENT TRANSFORM)) ; (WRITING-BUFFER-CHUNKS CARD16 ; ((LST ; (NTHCDR START ; DATA))) ; ((TYPE LIST ; LST)) ; (DO ((J 0 ; (INDEX+ ; J 2))) ; ((INDEX>= J ; CHUNK)) ; (DECLARE ; (TYPE ; ARRAY-INDEX ; J)) ; (WRITE-CARD16 ; J ; (FUNCALL ; TRANSFORM ; (POP ; LST))))) ; NIL) ; compiling (DEFUN WRITE-LIST-CARD16-WITH-TRANSFORM ...) ; compiling (DEFUN WRITE-SIMPLE-ARRAY-CARD16 ...) ; file: /usr/share/common-lisp/source/clx/buffer.lisp ; in: DEFUN WRITE-SIMPLE-ARRAY-CARD16-WITH-TRANSFORM ; (DEFUN XLIB::WRITE-SIMPLE-ARRAY-CARD16-WITH-TRANSFORM ; (XLIB::BUFFER XLIB::BOFFSET XLIB::DATA XLIB::START XLIB::END ; XLIB::TRANSFORM) ; (DECLARE (TYPE XLIB::BUFFER XLIB::BUFFER) ; (TYPE (SIMPLE-ARRAY XLIB:CARD16 (*)) XLIB::DATA) ; (TYPE XLIB:ARRAY-INDEX XLIB::BOFFSET XLIB::START XLIB::END)) ; (DECLARE (TYPE (FUNCTION (XLIB:CARD16) XLIB:CARD16) XLIB::TRANSFORM) ; (DYNAMIC-EXTENT XLIB::TRANSFORM)) ; (XLIB::WITH-VECTOR (XLIB::DATA (SIMPLE-ARRAY XLIB:CARD16 (*))) ; (XLIB::WRITING-BUFFER-CHUNKS XLIB:CARD16 ; ((XLIB::INDEX XLIB::START)) ; ((TYPE XLIB:ARRAY-INDEX ; XLIB::INDEX)) ; (DO (#) ; (#) ; (DECLARE #) ; (XLIB::WRITE-CARD16 ; XLIB::J #) ; (SETQ XLIB::INDEX #)))) ; NIL) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN LOCALLY SB-C::%FUNCALL ; ==> ; #:G2375 ; ; note: could not stack allocate the result of (DEFUN WRITE-SIMPLE-ARRAY-CARD16-WITH-TRANSFORM ; (BUFFER BOFFSET DATA START END ; TRANSFORM) ; (DECLARE (TYPE BUFFER BUFFER) ; (TYPE (SIMPLE-ARRAY CARD16 (*)) DATA) ; (TYPE ARRAY-INDEX BOFFSET START END)) ; (DECLARE ; (TYPE (FUNCTION (CARD16) CARD16) ; TRANSFORM) ; (DYNAMIC-EXTENT TRANSFORM)) ; (WITH-VECTOR ; (DATA (SIMPLE-ARRAY CARD16 (*))) ; (WRITING-BUFFER-CHUNKS CARD16 ; ((INDEX ; START)) ; ((TYPE ; ARRAY-INDEX ; INDEX)) ; (DO ((J 0 #)) ; ((INDEX>= ; J ; CHUNK)) ; (DECLARE ; (TYPE ; ARRAY-INDEX ; J)) ; (WRITE-CARD16 ; J ; (FUNCALL ; TRANSFORM ; #)) ; (SETQ INDEX ; (INDEX+ ; INDEX ; 1))))) ; NIL) ; compiling (DEFUN WRITE-SIMPLE-ARRAY-CARD16-WITH-TRANSFORM ...) ; file: /usr/share/common-lisp/source/clx/buffer.lisp ; in: DEFUN WRITE-VECTOR-CARD16 ; (AREF XLIB::DATA XLIB::INDEX) ; ==> ; (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a VECTOR, not a SIMPLE-STRING. ; ; note: unable to ; avoid runtime dispatch on array element type ; due to type uncertainty: ; The first argument is a VECTOR, not a SIMPLE-ARRAY. ; compiling (DEFUN WRITE-VECTOR-CARD16 ...) ; file: /usr/share/common-lisp/source/clx/buffer.lisp ; in: DEFUN WRITE-VECTOR-CARD16-WITH-TRANSFORM ; (AREF XLIB::DATA XLIB::INDEX) ; ==> ; (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a VECTOR, not a SIMPLE-STRING. ; ; note: unable to ; avoid runtime dispatch on array element type ; due to type uncertainty: ; The first argument is a VECTOR, not a SIMPLE-ARRAY. ; (DEFUN XLIB::WRITE-VECTOR-CARD16-WITH-TRANSFORM ; (XLIB::BUFFER XLIB::BOFFSET XLIB::DATA XLIB::START XLIB::END ; XLIB::TRANSFORM) ; (DECLARE (TYPE XLIB::BUFFER XLIB::BUFFER) (TYPE VECTOR XLIB::DATA) ; (TYPE XLIB:ARRAY-INDEX XLIB::BOFFSET XLIB::START XLIB::END) (OPTIMIZE)) ; (DECLARE (TYPE (FUNCTION (T) XLIB:CARD16) XLIB::TRANSFORM) ; (DYNAMIC-EXTENT XLIB::TRANSFORM)) ; (XLIB::WITH-VECTOR (XLIB::DATA VECTOR) ; (XLIB::WRITING-BUFFER-CHUNKS XLIB:CARD16 ; ((XLIB::INDEX XLIB::START)) ; ((TYPE XLIB:ARRAY-INDEX ; XLIB::INDEX)) ; (DO (#) ; (#) ; (DECLARE #) ; (XLIB::WRITE-CARD16 ; XLIB::J #) ; (SETQ XLIB::INDEX #)))) ; NIL) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN LOCALLY SB-C::%FUNCALL ; ==> ; #:G2476 ; ; note: could not stack allocate the result of (DEFUN WRITE-VECTOR-CARD16-WITH-TRANSFORM ; (BUFFER BOFFSET DATA START END ; TRANSFORM) ; (DECLARE (TYPE BUFFER BUFFER) ; (TYPE VECTOR DATA) ; (TYPE ARRAY-INDEX BOFFSET START END) ; (OPTIMIZE)) ; (DECLARE ; (TYPE (FUNCTION (T) CARD16) ; TRANSFORM) ; (DYNAMIC-EXTENT TRANSFORM)) ; (WITH-VECTOR (DATA VECTOR) ; (WRITING-BUFFER-CHUNKS ; CARD16 ((INDEX START)) ; ((TYPE ARRAY-INDEX ; INDEX)) ; (DO ((J 0 #)) ; ((INDEX>= J CHUNK)) ; (DECLARE ; (TYPE ARRAY-INDEX J)) ; (WRITE-CARD16 J ; (FUNCALL ; TRANSFORM ; #)) ; (SETQ INDEX ; (INDEX+ INDEX ; 1))))) ; NIL) ; compiling (DEFUN WRITE-VECTOR-CARD16-WITH-TRANSFORM ...) ; file: /usr/share/common-lisp/source/clx/buffer.lisp ; in: DEFUN WRITE-SEQUENCE-CARD16 ; (DEFUN XLIB::WRITE-SEQUENCE-CARD16 ; (XLIB::BUFFER XLIB::BOFFSET XLIB::DATA ; &OPTIONAL (XLIB::START 0) (XLIB::END (LENGTH XLIB::DATA)) ; XLIB::TRANSFORM) ; (DECLARE (TYPE XLIB::BUFFER XLIB::BUFFER) (TYPE SEQUENCE XLIB::DATA) ; (TYPE XLIB:ARRAY-INDEX XLIB::BOFFSET XLIB::START XLIB::END)) ; (DECLARE (TYPE (OR NULL (FUNCTION # XLIB:CARD16)) XLIB::TRANSFORM) ; (DYNAMIC-EXTENT XLIB::TRANSFORM)) ; (TYPECASE XLIB::DATA ; (LIST ; (IF XLIB::TRANSFORM ; (XLIB::WRITE-LIST-CARD16-WITH-TRANSFORM XLIB::BUFFER XLIB::BOFFSET ; XLIB::DATA XLIB::START XLIB::END XLIB::TRANSFORM) ; (XLIB::WRITE-LIST-CARD16 XLIB::BUFFER XLIB::BOFFSET XLIB::DATA ; XLIB::START XLIB::END))) ; ((SIMPLE-ARRAY XLIB:CARD16 (*)) ; (IF XLIB::TRANSFORM ; (XLIB::WRITE-SIMPLE-ARRAY-CARD16-WITH-TRANSFORM XLIB::BUFFER ; XLIB::BOFFSET XLIB::DATA XLIB::START XLIB::END XLIB::TRANSFORM) ; (XLIB::WRITE-SIMPLE-ARRAY-CARD16 XLIB::BUFFER XLIB::BOFFSET ; XLIB::DATA XLIB::START XLIB::END))) ; (T ; (IF XLIB::TRANSFORM ; (XLIB::WRITE-VECTOR-CARD16-WITH-TRANSFORM XLIB::BUFFER XLIB::BOFFSET ; XLIB::DATA XLIB::START XLIB::END XLIB::TRANSFORM) ; (XLIB::WRITE-VECTOR-CARD16 XLIB::BUFFER XLIB::BOFFSET XLIB::DATA ; XLIB::START XLIB::END))))) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN COND IF COND IF COND IF COND IF PROGN ; --> SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET ; ==> ; #:G2534 ; ; note: could not stack allocate the result of (DEFUN WRITE-SEQUENCE-CARD16 ; (BUFFER BOFFSET DATA ; &OPTIONAL (START 0) ; (END (LENGTH DATA)) TRANSFORM) ; (DECLARE (TYPE BUFFER BUFFER) ; (TYPE SEQUENCE DATA) ; (TYPE ARRAY-INDEX BOFFSET START END)) ; (DECLARE ; (TYPE (OR NULL (FUNCTION (T) CARD16)) ; TRANSFORM) ; (DYNAMIC-EXTENT TRANSFORM)) ; (TYPECASE DATA ; (LIST ; (IF TRANSFORM ; (WRITE-LIST-CARD16-WITH-TRANSFORM ; BUFFER BOFFSET DATA START END ; TRANSFORM) ; (WRITE-LIST-CARD16 BUFFER ; BOFFSET DATA START END))) ; ((SIMPLE-ARRAY CARD16 (*)) ; (IF TRANSFORM ; (WRITE-SIMPLE-ARRAY-CARD16-WITH-TRANSFORM ; BUFFER BOFFSET DATA START END ; TRANSFORM) ; (WRITE-SIMPLE-ARRAY-CARD16 ; BUFFER BOFFSET DATA START ; END))) ; (T ; (IF TRANSFORM ; (WRITE-VECTOR-CARD16-WITH-TRANSFORM ; BUFFER BOFFSET DATA START END ; TRANSFORM) ; (WRITE-VECTOR-CARD16 BUFFER ; BOFFSET DATA START END))))) ; compiling (DEFUN WRITE-SEQUENCE-CARD16 ...) ; compiling (DEFUN WRITE-LIST-INT16 ...) ; file: /usr/share/common-lisp/source/clx/buffer.lisp ; in: DEFUN WRITE-LIST-INT16-WITH-TRANSFORM ; (DEFUN XLIB::WRITE-LIST-INT16-WITH-TRANSFORM ; (XLIB::BUFFER XLIB::BOFFSET XLIB::DATA XLIB::START XLIB::END ; XLIB::TRANSFORM) ; (DECLARE (TYPE XLIB::BUFFER XLIB::BUFFER) (TYPE LIST XLIB::DATA) ; (TYPE XLIB:ARRAY-INDEX XLIB::BOFFSET XLIB::START XLIB::END)) ; (DECLARE (TYPE (FUNCTION (T) XLIB:INT16) XLIB::TRANSFORM) ; (DYNAMIC-EXTENT XLIB::TRANSFORM)) ; (XLIB::WRITING-BUFFER-CHUNKS XLIB:INT16 ; ((XLIB::LST (NTHCDR XLIB::START XLIB::DATA))) ; ((TYPE LIST XLIB::LST)) ; (DO ((XLIB::J 0 #)) ; ((XLIB::INDEX>= XLIB::J XLIB::CHUNK)) ; (DECLARE (TYPE XLIB:ARRAY-INDEX XLIB::J)) ; (XLIB::WRITE-INT16 XLIB::J ; (FUNCALL XLIB::TRANSFORM ; #)))) ; NIL) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN LOCALLY SB-C::%FUNCALL ; ==> ; #:G2635 ; ; note: could not stack allocate the result of (DEFUN WRITE-LIST-INT16-WITH-TRANSFORM ; (BUFFER BOFFSET DATA START END ; TRANSFORM) ; (DECLARE (TYPE BUFFER BUFFER) ; (TYPE LIST DATA) ; (TYPE ARRAY-INDEX BOFFSET START END)) ; (DECLARE ; (TYPE (FUNCTION (T) INT16) TRANSFORM) ; (DYNAMIC-EXTENT TRANSFORM)) ; (WRITING-BUFFER-CHUNKS INT16 ; ((LST ; (NTHCDR START ; DATA))) ; ((TYPE LIST ; LST)) ; (DO ((J 0 ; (INDEX+ ; J 2))) ; ((INDEX>= J ; CHUNK)) ; (DECLARE ; (TYPE ; ARRAY-INDEX ; J)) ; (WRITE-INT16 ; J ; (FUNCALL ; TRANSFORM ; (POP ; LST))))) ; NIL) ; compiling (DEFUN WRITE-LIST-INT16-WITH-TRANSFORM ...) ; compiling (DEFUN WRITE-SIMPLE-ARRAY-INT16 ...) ; file: /usr/share/common-lisp/source/clx/buffer.lisp ; in: DEFUN WRITE-SIMPLE-ARRAY-INT16-WITH-TRANSFORM ; (DEFUN XLIB::WRITE-SIMPLE-ARRAY-INT16-WITH-TRANSFORM ; (XLIB::BUFFER XLIB::BOFFSET XLIB::DATA XLIB::START XLIB::END ; XLIB::TRANSFORM) ; (DECLARE (TYPE XLIB::BUFFER XLIB::BUFFER) ; (TYPE (SIMPLE-ARRAY XLIB:INT16 (*)) XLIB::DATA) ; (TYPE XLIB:ARRAY-INDEX XLIB::BOFFSET XLIB::START XLIB::END)) ; (DECLARE (TYPE (FUNCTION (XLIB:INT16) XLIB:INT16) XLIB::TRANSFORM) ; (DYNAMIC-EXTENT XLIB::TRANSFORM)) ; (XLIB::WITH-VECTOR (XLIB::DATA (SIMPLE-ARRAY XLIB:INT16 (*))) ; (XLIB::WRITING-BUFFER-CHUNKS XLIB:INT16 ; ((XLIB::INDEX XLIB::START)) ; ((TYPE XLIB:ARRAY-INDEX ; XLIB::INDEX)) ; (DO (#) ; (#) ; (DECLARE #) ; (XLIB::WRITE-INT16 ; XLIB::J #) ; (SETQ XLIB::INDEX #)))) ; NIL) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN LOCALLY SB-C::%FUNCALL ; ==> ; #:G2734 ; ; note: could not stack allocate the result of (DEFUN WRITE-SIMPLE-ARRAY-INT16-WITH-TRANSFORM ; (BUFFER BOFFSET DATA START END ; TRANSFORM) ; (DECLARE (TYPE BUFFER BUFFER) ; (TYPE (SIMPLE-ARRAY INT16 (*)) DATA) ; (TYPE ARRAY-INDEX BOFFSET START END)) ; (DECLARE ; (TYPE (FUNCTION (INT16) INT16) ; TRANSFORM) ; (DYNAMIC-EXTENT TRANSFORM)) ; (WITH-VECTOR ; (DATA (SIMPLE-ARRAY INT16 (*))) ; (WRITING-BUFFER-CHUNKS INT16 ; ((INDEX ; START)) ; ((TYPE ; ARRAY-INDEX ; INDEX)) ; (DO ((J 0 #)) ; ((INDEX>= ; J ; CHUNK)) ; (DECLARE ; (TYPE ; ARRAY-INDEX ; J)) ; (WRITE-INT16 ; J ; (FUNCALL ; TRANSFORM ; #)) ; (SETQ INDEX ; (INDEX+ ; INDEX ; 1))))) ; NIL) ; compiling (DEFUN WRITE-SIMPLE-ARRAY-INT16-WITH-TRANSFORM ...) ; file: /usr/share/common-lisp/source/clx/buffer.lisp ; in: DEFUN WRITE-VECTOR-INT16 ; (AREF XLIB::DATA XLIB::INDEX) ; ==> ; (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a VECTOR, not a SIMPLE-STRING. ; ; note: unable to ; avoid runtime dispatch on array element type ; due to type uncertainty: ; The first argument is a VECTOR, not a SIMPLE-ARRAY. ; compiling (DEFUN WRITE-VECTOR-INT16 ...) ; file: /usr/share/common-lisp/source/clx/buffer.lisp ; in: DEFUN WRITE-VECTOR-INT16-WITH-TRANSFORM ; (AREF XLIB::DATA XLIB::INDEX) ; ==> ; (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a VECTOR, not a SIMPLE-STRING. ; ; note: unable to ; avoid runtime dispatch on array element type ; due to type uncertainty: ; The first argument is a VECTOR, not a SIMPLE-ARRAY. ; (DEFUN XLIB::WRITE-VECTOR-INT16-WITH-TRANSFORM ; (XLIB::BUFFER XLIB::BOFFSET XLIB::DATA XLIB::START XLIB::END ; XLIB::TRANSFORM) ; (DECLARE (TYPE XLIB::BUFFER XLIB::BUFFER) (TYPE VECTOR XLIB::DATA) ; (TYPE XLIB:ARRAY-INDEX XLIB::BOFFSET XLIB::START XLIB::END) (OPTIMIZE)) ; (DECLARE (TYPE (FUNCTION (T) XLIB:INT16) XLIB::TRANSFORM) ; (DYNAMIC-EXTENT XLIB::TRANSFORM)) ; (XLIB::WITH-VECTOR (XLIB::DATA VECTOR) ; (XLIB::WRITING-BUFFER-CHUNKS XLIB:INT16 ; ((XLIB::INDEX XLIB::START)) ; ((TYPE XLIB:ARRAY-INDEX ; XLIB::INDEX)) ; (DO (#) ; (#) ; (DECLARE #) ; (XLIB::WRITE-INT16 ; XLIB::J #) ; (SETQ XLIB::INDEX #)))) ; NIL) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN LOCALLY SB-C::%FUNCALL ; ==> ; #:G2835 ; ; note: could not stack allocate the result of (DEFUN WRITE-VECTOR-INT16-WITH-TRANSFORM ; (BUFFER BOFFSET DATA START END ; TRANSFORM) ; (DECLARE (TYPE BUFFER BUFFER) ; (TYPE VECTOR DATA) ; (TYPE ARRAY-INDEX BOFFSET START END) ; (OPTIMIZE)) ; (DECLARE ; (TYPE (FUNCTION (T) INT16) TRANSFORM) ; (DYNAMIC-EXTENT TRANSFORM)) ; (WITH-VECTOR (DATA VECTOR) ; (WRITING-BUFFER-CHUNKS ; INT16 ((INDEX START)) ; ((TYPE ARRAY-INDEX ; INDEX)) ; (DO ((J 0 #)) ; ((INDEX>= J CHUNK)) ; (DECLARE ; (TYPE ARRAY-INDEX J)) ; (WRITE-INT16 J ; (FUNCALL ; TRANSFORM ; #)) ; (SETQ INDEX ; (INDEX+ INDEX ; 1))))) ; NIL) ; compiling (DEFUN WRITE-VECTOR-INT16-WITH-TRANSFORM ...) ; file: /usr/share/common-lisp/source/clx/buffer.lisp ; in: DEFUN WRITE-SEQUENCE-INT16 ; (DEFUN XLIB::WRITE-SEQUENCE-INT16 ; (XLIB::BUFFER XLIB::BOFFSET XLIB::DATA ; &OPTIONAL (XLIB::START 0) (XLIB::END (LENGTH XLIB::DATA)) ; XLIB::TRANSFORM) ; (DECLARE (TYPE XLIB::BUFFER XLIB::BUFFER) (TYPE SEQUENCE XLIB::DATA) ; (TYPE XLIB:ARRAY-INDEX XLIB::BOFFSET XLIB::START XLIB::END)) ; (DECLARE (TYPE (OR NULL (FUNCTION # XLIB:INT16)) XLIB::TRANSFORM) ; (DYNAMIC-EXTENT XLIB::TRANSFORM)) ; (TYPECASE XLIB::DATA ; (LIST ; (IF XLIB::TRANSFORM ; (XLIB::WRITE-LIST-INT16-WITH-TRANSFORM XLIB::BUFFER XLIB::BOFFSET ; XLIB::DATA XLIB::START XLIB::END XLIB::TRANSFORM) ; (XLIB::WRITE-LIST-INT16 XLIB::BUFFER XLIB::BOFFSET XLIB::DATA ; XLIB::START XLIB::END))) ; ((SIMPLE-ARRAY XLIB:INT16 (*)) ; (IF XLIB::TRANSFORM ; (XLIB::WRITE-SIMPLE-ARRAY-INT16-WITH-TRANSFORM XLIB::BUFFER ; XLIB::BOFFSET XLIB::DATA XLIB::START XLIB::END XLIB::TRANSFORM) ; (XLIB::WRITE-SIMPLE-ARRAY-INT16 XLIB::BUFFER XLIB::BOFFSET ; XLIB::DATA XLIB::START XLIB::END))) ; (T ; (IF XLIB::TRANSFORM ; (XLIB::WRITE-VECTOR-INT16-WITH-TRANSFORM XLIB::BUFFER XLIB::BOFFSET ; XLIB::DATA XLIB::START XLIB::END XLIB::TRANSFORM) ; (XLIB::WRITE-VECTOR-INT16 XLIB::BUFFER XLIB::BOFFSET XLIB::DATA ; XLIB::START XLIB::END))))) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN COND IF COND IF COND IF COND IF PROGN ; --> SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET ; ==> ; #:G2893 ; ; note: could not stack allocate the result of (DEFUN WRITE-SEQUENCE-INT16 ; (BUFFER BOFFSET DATA ; &OPTIONAL (START 0) ; (END (LENGTH DATA)) TRANSFORM) ; (DECLARE (TYPE BUFFER BUFFER) ; (TYPE SEQUENCE DATA) ; (TYPE ARRAY-INDEX BOFFSET START END)) ; (DECLARE ; (TYPE (OR NULL (FUNCTION (T) INT16)) ; TRANSFORM) ; (DYNAMIC-EXTENT TRANSFORM)) ; (TYPECASE DATA ; (LIST ; (IF TRANSFORM ; (WRITE-LIST-INT16-WITH-TRANSFORM ; BUFFER BOFFSET DATA START END ; TRANSFORM) ; (WRITE-LIST-INT16 BUFFER ; BOFFSET DATA START END))) ; ((SIMPLE-ARRAY INT16 (*)) ; (IF TRANSFORM ; (WRITE-SIMPLE-ARRAY-INT16-WITH-TRANSFORM ; BUFFER BOFFSET DATA START END ; TRANSFORM) ; (WRITE-SIMPLE-ARRAY-INT16 ; BUFFER BOFFSET DATA START ; END))) ; (T ; (IF TRANSFORM ; (WRITE-VECTOR-INT16-WITH-TRANSFORM ; BUFFER BOFFSET DATA START END ; TRANSFORM) ; (WRITE-VECTOR-INT16 BUFFER ; BOFFSET DATA START END))))) ; compiling (DEFUN WRITE-SEQUENCE-INT16 ...) ; compiling (DEFUN WRITE-LIST-CARD32 ...) ; file: /usr/share/common-lisp/source/clx/buffer.lisp ; in: DEFUN WRITE-LIST-CARD32-WITH-TRANSFORM ; (DEFUN XLIB::WRITE-LIST-CARD32-WITH-TRANSFORM ; (XLIB::BUFFER XLIB::BOFFSET XLIB::DATA XLIB::START XLIB::END ; XLIB::TRANSFORM) ; (DECLARE (TYPE XLIB::BUFFER XLIB::BUFFER) (TYPE LIST XLIB::DATA) ; (TYPE XLIB:ARRAY-INDEX XLIB::BOFFSET XLIB::START XLIB::END)) ; (DECLARE (TYPE (FUNCTION (T) XLIB:CARD32) XLIB::TRANSFORM) ; (DYNAMIC-EXTENT XLIB::TRANSFORM)) ; (XLIB::WRITING-BUFFER-CHUNKS XLIB:CARD32 ; ((XLIB::LST (NTHCDR XLIB::START XLIB::DATA))) ; ((TYPE LIST XLIB::LST)) ; (DO ((XLIB::J 0 #)) ; ((XLIB::INDEX>= XLIB::J XLIB::CHUNK)) ; (DECLARE (TYPE XLIB:ARRAY-INDEX XLIB::J)) ; (XLIB::WRITE-CARD32 XLIB::J ; (FUNCALL XLIB::TRANSFORM ; #)))) ; NIL) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN LOCALLY SB-C::%FUNCALL ; ==> ; #:G2994 ; ; note: could not stack allocate the result of (DEFUN WRITE-LIST-CARD32-WITH-TRANSFORM ; (BUFFER BOFFSET DATA START END ; TRANSFORM) ; (DECLARE (TYPE BUFFER BUFFER) ; (TYPE LIST DATA) ; (TYPE ARRAY-INDEX BOFFSET START END)) ; (DECLARE ; (TYPE (FUNCTION (T) CARD32) ; TRANSFORM) ; (DYNAMIC-EXTENT TRANSFORM)) ; (WRITING-BUFFER-CHUNKS CARD32 ; ((LST ; (NTHCDR START ; DATA))) ; ((TYPE LIST ; LST)) ; (DO ((J 0 ; (INDEX+ ; J 4))) ; ((INDEX>= J ; CHUNK)) ; (DECLARE ; (TYPE ; ARRAY-INDEX ; J)) ; (WRITE-CARD32 ; J ; (FUNCALL ; TRANSFORM ; (POP ; LST))))) ; NIL) ; compiling (DEFUN WRITE-LIST-CARD32-WITH-TRANSFORM ...) ; compiling (DEFUN WRITE-SIMPLE-ARRAY-CARD32 ...) ; file: /usr/share/common-lisp/source/clx/buffer.lisp ; in: DEFUN WRITE-SIMPLE-ARRAY-CARD32-WITH-TRANSFORM ; (DEFUN XLIB::WRITE-SIMPLE-ARRAY-CARD32-WITH-TRANSFORM ; (XLIB::BUFFER XLIB::BOFFSET XLIB::DATA XLIB::START XLIB::END ; XLIB::TRANSFORM) ; (DECLARE (TYPE XLIB::BUFFER XLIB::BUFFER) ; (TYPE (SIMPLE-ARRAY XLIB:CARD32 (*)) XLIB::DATA) ; (TYPE XLIB:ARRAY-INDEX XLIB::BOFFSET XLIB::START XLIB::END)) ; (DECLARE (TYPE (FUNCTION (XLIB:CARD32) XLIB:CARD32) XLIB::TRANSFORM) ; (DYNAMIC-EXTENT XLIB::TRANSFORM)) ; (XLIB::WITH-VECTOR (XLIB::DATA (SIMPLE-ARRAY XLIB:CARD32 (*))) ; (XLIB::WRITING-BUFFER-CHUNKS XLIB:CARD32 ; ((XLIB::INDEX XLIB::START)) ; ((TYPE XLIB:ARRAY-INDEX ; XLIB::INDEX)) ; (DO (#) ; (#) ; (DECLARE #) ; (XLIB::WRITE-CARD32 ; XLIB::J #) ; (SETQ XLIB::INDEX #)))) ; NIL) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN LOCALLY SB-C::%FUNCALL ; ==> ; #:G3093 ; ; note: could not stack allocate the result of (DEFUN WRITE-SIMPLE-ARRAY-CARD32-WITH-TRANSFORM ; (BUFFER BOFFSET DATA START END ; TRANSFORM) ; (DECLARE (TYPE BUFFER BUFFER) ; (TYPE (SIMPLE-ARRAY CARD32 (*)) DATA) ; (TYPE ARRAY-INDEX BOFFSET START END)) ; (DECLARE ; (TYPE (FUNCTION (CARD32) CARD32) ; TRANSFORM) ; (DYNAMIC-EXTENT TRANSFORM)) ; (WITH-VECTOR ; (DATA (SIMPLE-ARRAY CARD32 (*))) ; (WRITING-BUFFER-CHUNKS CARD32 ; ((INDEX ; START)) ; ((TYPE ; ARRAY-INDEX ; INDEX)) ; (DO ((J 0 #)) ; ((INDEX>= ; J ; CHUNK)) ; (DECLARE ; (TYPE ; ARRAY-INDEX ; J)) ; (WRITE-CARD32 ; J ; (FUNCALL ; TRANSFORM ; #)) ; (SETQ INDEX ; (INDEX+ ; INDEX ; 1))))) ; NIL) ; compiling (DEFUN WRITE-SIMPLE-ARRAY-CARD32-WITH-TRANSFORM ...) ; file: /usr/share/common-lisp/source/clx/buffer.lisp ; in: DEFUN WRITE-VECTOR-CARD32 ; (AREF XLIB::DATA XLIB::INDEX) ; ==> ; (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a VECTOR, not a SIMPLE-STRING. ; ; note: unable to ; avoid runtime dispatch on array element type ; due to type uncertainty: ; The first argument is a VECTOR, not a SIMPLE-ARRAY. ; compiling (DEFUN WRITE-VECTOR-CARD32 ...) ; file: /usr/share/common-lisp/source/clx/buffer.lisp ; in: DEFUN WRITE-VECTOR-CARD32-WITH-TRANSFORM ; (AREF XLIB::DATA XLIB::INDEX) ; ==> ; (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a VECTOR, not a SIMPLE-STRING. ; ; note: unable to ; avoid runtime dispatch on array element type ; due to type uncertainty: ; The first argument is a VECTOR, not a SIMPLE-ARRAY. ; (DEFUN XLIB::WRITE-VECTOR-CARD32-WITH-TRANSFORM ; (XLIB::BUFFER XLIB::BOFFSET XLIB::DATA XLIB::START XLIB::END ; XLIB::TRANSFORM) ; (DECLARE (TYPE XLIB::BUFFER XLIB::BUFFER) (TYPE VECTOR XLIB::DATA) ; (TYPE XLIB:ARRAY-INDEX XLIB::BOFFSET XLIB::START XLIB::END) (OPTIMIZE)) ; (DECLARE (TYPE (FUNCTION (T) XLIB:CARD32) XLIB::TRANSFORM) ; (DYNAMIC-EXTENT XLIB::TRANSFORM)) ; (XLIB::WITH-VECTOR (XLIB::DATA VECTOR) ; (XLIB::WRITING-BUFFER-CHUNKS XLIB:CARD32 ; ((XLIB::INDEX XLIB::START)) ; ((TYPE XLIB:ARRAY-INDEX ; XLIB::INDEX)) ; (DO (#) ; (#) ; (DECLARE #) ; (XLIB::WRITE-CARD32 ; XLIB::J #) ; (SETQ XLIB::INDEX #)))) ; NIL) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN LOCALLY SB-C::%FUNCALL ; ==> ; #:G3194 ; ; note: could not stack allocate the result of (DEFUN WRITE-VECTOR-CARD32-WITH-TRANSFORM ; (BUFFER BOFFSET DATA START END ; TRANSFORM) ; (DECLARE (TYPE BUFFER BUFFER) ; (TYPE VECTOR DATA) ; (TYPE ARRAY-INDEX BOFFSET START END) ; (OPTIMIZE)) ; (DECLARE ; (TYPE (FUNCTION (T) CARD32) ; TRANSFORM) ; (DYNAMIC-EXTENT TRANSFORM)) ; (WITH-VECTOR (DATA VECTOR) ; (WRITING-BUFFER-CHUNKS ; CARD32 ((INDEX START)) ; ((TYPE ARRAY-INDEX ; INDEX)) ; (DO ((J 0 #)) ; ((INDEX>= J CHUNK)) ; (DECLARE ; (TYPE ARRAY-INDEX J)) ; (WRITE-CARD32 J ; (FUNCALL ; TRANSFORM ; #)) ; (SETQ INDEX ; (INDEX+ INDEX ; 1))))) ; NIL) ; compiling (DEFUN WRITE-VECTOR-CARD32-WITH-TRANSFORM ...) ; file: /usr/share/common-lisp/source/clx/buffer.lisp ; in: DEFUN WRITE-SEQUENCE-CARD32 ; (DEFUN XLIB::WRITE-SEQUENCE-CARD32 ; (XLIB::BUFFER XLIB::BOFFSET XLIB::DATA ; &OPTIONAL (XLIB::START 0) (XLIB::END (LENGTH XLIB::DATA)) ; XLIB::TRANSFORM) ; (DECLARE (TYPE XLIB::BUFFER XLIB::BUFFER) (TYPE SEQUENCE XLIB::DATA) ; (TYPE XLIB:ARRAY-INDEX XLIB::BOFFSET XLIB::START XLIB::END)) ; (DECLARE (TYPE (OR NULL (FUNCTION # XLIB:CARD32)) XLIB::TRANSFORM) ; (DYNAMIC-EXTENT XLIB::TRANSFORM)) ; (TYPECASE XLIB::DATA ; (LIST ; (IF XLIB::TRANSFORM ; (XLIB::WRITE-LIST-CARD32-WITH-TRANSFORM XLIB::BUFFER XLIB::BOFFSET ; XLIB::DATA XLIB::START XLIB::END XLIB::TRANSFORM) ; (XLIB::WRITE-LIST-CARD32 XLIB::BUFFER XLIB::BOFFSET XLIB::DATA ; XLIB::START XLIB::END))) ; ((SIMPLE-ARRAY XLIB:CARD32 (*)) ; (IF XLIB::TRANSFORM ; (XLIB::WRITE-SIMPLE-ARRAY-CARD32-WITH-TRANSFORM XLIB::BUFFER ; XLIB::BOFFSET XLIB::DATA XLIB::START XLIB::END XLIB::TRANSFORM) ; (XLIB::WRITE-SIMPLE-ARRAY-CARD32 XLIB::BUFFER XLIB::BOFFSET ; XLIB::DATA XLIB::START XLIB::END))) ; (T ; (IF XLIB::TRANSFORM ; (XLIB::WRITE-VECTOR-CARD32-WITH-TRANSFORM XLIB::BUFFER XLIB::BOFFSET ; XLIB::DATA XLIB::START XLIB::END XLIB::TRANSFORM) ; (XLIB::WRITE-VECTOR-CARD32 XLIB::BUFFER XLIB::BOFFSET XLIB::DATA ; XLIB::START XLIB::END))))) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN COND IF COND IF COND IF COND IF PROGN ; --> SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET ; ==> ; #:G3252 ; ; note: could not stack allocate the result of (DEFUN WRITE-SEQUENCE-CARD32 ; (BUFFER BOFFSET DATA ; &OPTIONAL (START 0) ; (END (LENGTH DATA)) TRANSFORM) ; (DECLARE (TYPE BUFFER BUFFER) ; (TYPE SEQUENCE DATA) ; (TYPE ARRAY-INDEX BOFFSET START END)) ; (DECLARE ; (TYPE (OR NULL (FUNCTION (T) CARD32)) ; TRANSFORM) ; (DYNAMIC-EXTENT TRANSFORM)) ; (TYPECASE DATA ; (LIST ; (IF TRANSFORM ; (WRITE-LIST-CARD32-WITH-TRANSFORM ; BUFFER BOFFSET DATA START END ; TRANSFORM) ; (WRITE-LIST-CARD32 BUFFER ; BOFFSET DATA START END))) ; ((SIMPLE-ARRAY CARD32 (*)) ; (IF TRANSFORM ; (WRITE-SIMPLE-ARRAY-CARD32-WITH-TRANSFORM ; BUFFER BOFFSET DATA START END ; TRANSFORM) ; (WRITE-SIMPLE-ARRAY-CARD32 ; BUFFER BOFFSET DATA START ; END))) ; (T ; (IF TRANSFORM ; (WRITE-VECTOR-CARD32-WITH-TRANSFORM ; BUFFER BOFFSET DATA START END ; TRANSFORM) ; (WRITE-VECTOR-CARD32 BUFFER ; BOFFSET DATA START END))))) ; compiling (DEFUN WRITE-SEQUENCE-CARD32 ...) ; file: /usr/share/common-lisp/source/clx/buffer.lisp ; in: DEFUN WRITE-SEQUENCE-INT32 ; (DEFUN XLIB::WRITE-SEQUENCE-INT32 ; (XLIB::BUFFER XLIB::BOFFSET XLIB::DATA ; &OPTIONAL (XLIB::START 0) (XLIB::END (LENGTH XLIB::DATA)) ; XLIB::TRANSFORM) ; (DECLARE (TYPE XLIB::BUFFER XLIB::BUFFER) (TYPE SEQUENCE XLIB::DATA) ; (TYPE XLIB:ARRAY-INDEX XLIB::BOFFSET XLIB::START XLIB::END)) ; (DECLARE (TYPE (OR NULL (FUNCTION # XLIB:INT32)) XLIB::TRANSFORM) ; (DYNAMIC-EXTENT XLIB::TRANSFORM)) ; (IF XLIB::TRANSFORM ; (FLET ((XLIB::TRANSFORM->INT32->CARD32 # ; #)) ; (DECLARE (DYNAMIC-EXTENT #'XLIB::TRANSFORM->INT32->CARD32)) ; (XLIB::WRITE-SEQUENCE-CARD32 XLIB::BUFFER XLIB::BOFFSET XLIB::DATA ; XLIB::START XLIB::END #'XLIB::TRANSFORM->INT32->CARD32)) ; (XLIB::WRITE-SEQUENCE-CARD32 XLIB::BUFFER XLIB::BOFFSET XLIB::DATA ; XLIB::START XLIB::END #'XLIB::INT32->CARD32))) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN COND IF COND IF COND IF COND IF PROGN ; --> SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET ; ==> ; #:G3313 ; ; note: could not stack allocate the result of (DEFUN WRITE-SEQUENCE-INT32 ; (BUFFER BOFFSET DATA ; &OPTIONAL (START 0) ; (END (LENGTH DATA)) TRANSFORM) ; (DECLARE (TYPE BUFFER BUFFER) ; (TYPE SEQUENCE DATA) ; (TYPE ARRAY-INDEX BOFFSET START END)) ; (DECLARE ; (TYPE (OR NULL (FUNCTION (T) INT32)) ; TRANSFORM) ; (DYNAMIC-EXTENT TRANSFORM)) ; (IF TRANSFORM ; (FLET ((TRANSFORM->INT32->CARD32 ; (X) ; (INT32->CARD32 #))) ; (DECLARE ; (DYNAMIC-EXTENT ; #'TRANSFORM->INT32->CARD32)) ; (WRITE-SEQUENCE-CARD32 BUFFER ; BOFFSET DATA START END ; #'TRANSFORM->INT32->CARD32)) ; (WRITE-SEQUENCE-CARD32 BUFFER ; BOFFSET DATA START END ; #'INT32->CARD32))) ; compiling (DEFUN WRITE-SEQUENCE-INT32 ...) ; compiling (DEFUN READ-BITVECTOR256 ...) ; compiling (DEFUN WRITE-BITVECTOR256 ...) ; compiling (DEFUN WRITE-LIST-CHAR2B ...) ; file: /usr/share/common-lisp/source/clx/buffer.lisp ; in: DEFUN WRITE-LIST-CHAR2B-WITH-TRANSFORM ; (DEFUN XLIB::WRITE-LIST-CHAR2B-WITH-TRANSFORM ; (XLIB::BUFFER XLIB::BOFFSET XLIB::DATA XLIB::START XLIB::END ; XLIB::TRANSFORM) ; (DECLARE (TYPE XLIB::BUFFER XLIB::BUFFER) (TYPE LIST XLIB::DATA) ; (TYPE XLIB:ARRAY-INDEX XLIB::BOFFSET XLIB::START XLIB::END)) ; (DECLARE (TYPE (FUNCTION (T) XLIB:CARD16) XLIB::TRANSFORM) ; (DYNAMIC-EXTENT XLIB::TRANSFORM)) ; (XLIB::WRITING-BUFFER-CHUNKS XLIB:CARD16 ; ((XLIB::LST (NTHCDR XLIB::START XLIB::DATA))) ; ((TYPE LIST XLIB::LST)) ; (DO ((XLIB::J 0 #)) ; ((XLIB::INDEX>= XLIB::J #) ; (SETF XLIB::CHUNK XLIB::J)) ; (DECLARE (TYPE XLIB:ARRAY-INDEX XLIB::J)) ; (XLIB::WRITE-CHAR2B XLIB::J ; (FUNCALL XLIB::TRANSFORM ; #)))) ; NIL) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN LOCALLY SB-C::%FUNCALL ; ==> ; #:G3518 ; ; note: could not stack allocate the result of (DEFUN WRITE-LIST-CHAR2B-WITH-TRANSFORM ; (BUFFER BOFFSET DATA START END ; TRANSFORM) ; (DECLARE (TYPE BUFFER BUFFER) ; (TYPE LIST DATA) ; (TYPE ARRAY-INDEX BOFFSET START END)) ; (DECLARE ; (TYPE (FUNCTION (T) CARD16) ; TRANSFORM) ; (DYNAMIC-EXTENT TRANSFORM)) ; (WRITING-BUFFER-CHUNKS CARD16 ; ((LST ; (NTHCDR START ; DATA))) ; ((TYPE LIST ; LST)) ; (DO ((J 0 ; (INDEX+ ; J 2))) ; ((INDEX>= J ; (1- ; CHUNK)) ; (SETF CHUNK ; J)) ; (DECLARE ; (TYPE ; ARRAY-INDEX ; J)) ; (WRITE-CHAR2B ; J ; (FUNCALL ; TRANSFORM ; (POP ; LST))))) ; NIL) ; compiling (DEFUN WRITE-LIST-CHAR2B-WITH-TRANSFORM ...) ; compiling (DEFUN WRITE-SIMPLE-ARRAY-CHAR2B ...) ; file: /usr/share/common-lisp/source/clx/buffer.lisp ; in: DEFUN WRITE-SIMPLE-ARRAY-CHAR2B-WITH-TRANSFORM ; (DEFUN XLIB::WRITE-SIMPLE-ARRAY-CHAR2B-WITH-TRANSFORM ; (XLIB::BUFFER XLIB::BOFFSET XLIB::DATA XLIB::START XLIB::END ; XLIB::TRANSFORM) ; (DECLARE (TYPE XLIB::BUFFER XLIB::BUFFER) ; (TYPE (SIMPLE-ARRAY XLIB:CARD16 (*)) XLIB::DATA) ; (TYPE XLIB:ARRAY-INDEX XLIB::BOFFSET XLIB::START XLIB::END)) ; (DECLARE (TYPE (FUNCTION (XLIB:CARD16) XLIB:CARD16) XLIB::TRANSFORM) ; (DYNAMIC-EXTENT XLIB::TRANSFORM)) ; (XLIB::WITH-VECTOR (XLIB::DATA (SIMPLE-ARRAY XLIB:CARD16 (*))) ; (XLIB::WRITING-BUFFER-CHUNKS XLIB:CARD16 ; ((XLIB::INDEX XLIB::START)) ; ((TYPE XLIB:ARRAY-INDEX ; XLIB::INDEX)) ; (DO (#) ; (# #) ; (DECLARE #) ; (XLIB::WRITE-CHAR2B ; XLIB::J #) ; (SETQ XLIB::INDEX #)))) ; NIL) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN LOCALLY SB-C::%FUNCALL ; ==> ; #:G3647 ; ; note: could not stack allocate the result of (DEFUN WRITE-SIMPLE-ARRAY-CHAR2B-WITH-TRANSFORM ; (BUFFER BOFFSET DATA START END ; TRANSFORM) ; (DECLARE (TYPE BUFFER BUFFER) ; (TYPE (SIMPLE-ARRAY CARD16 (*)) DATA) ; (TYPE ARRAY-INDEX BOFFSET START END)) ; (DECLARE ; (TYPE (FUNCTION (CARD16) CARD16) ; TRANSFORM) ; (DYNAMIC-EXTENT TRANSFORM)) ; (WITH-VECTOR ; (DATA (SIMPLE-ARRAY CARD16 (*))) ; (WRITING-BUFFER-CHUNKS CARD16 ; ((INDEX ; START)) ; ((TYPE ; ARRAY-INDEX ; INDEX)) ; (DO ((J 0 #)) ; ((INDEX>= ; J #) ; (SETF CHUNK ; J)) ; (DECLARE ; (TYPE ; ARRAY-INDEX ; J)) ; (WRITE-CHAR2B ; J ; (FUNCALL ; TRANSFORM ; #)) ; (SETQ INDEX ; (INDEX+ ; INDEX ; 1))))) ; NIL) ; compiling (DEFUN WRITE-SIMPLE-ARRAY-CHAR2B-WITH-TRANSFORM ...) ; file: /usr/share/common-lisp/source/clx/buffer.lisp ; in: DEFUN WRITE-VECTOR-CHAR2B ; (AREF XLIB::DATA XLIB::INDEX) ; ==> ; (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a VECTOR, not a SIMPLE-STRING. ; ; note: unable to ; avoid runtime dispatch on array element type ; due to type uncertainty: ; The first argument is a VECTOR, not a SIMPLE-ARRAY. ; compiling (DEFUN WRITE-VECTOR-CHAR2B ...) ; file: /usr/share/common-lisp/source/clx/buffer.lisp ; in: DEFUN WRITE-VECTOR-CHAR2B-WITH-TRANSFORM ; (AREF XLIB::DATA XLIB::INDEX) ; ==> ; (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a VECTOR, not a SIMPLE-STRING. ; ; note: unable to ; avoid runtime dispatch on array element type ; due to type uncertainty: ; The first argument is a VECTOR, not a SIMPLE-ARRAY. ; (DEFUN XLIB::WRITE-VECTOR-CHAR2B-WITH-TRANSFORM ; (XLIB::BUFFER XLIB::BOFFSET XLIB::DATA XLIB::START XLIB::END ; XLIB::TRANSFORM) ; (DECLARE (TYPE XLIB::BUFFER XLIB::BUFFER) (TYPE VECTOR XLIB::DATA) ; (TYPE XLIB:ARRAY-INDEX XLIB::BOFFSET XLIB::START XLIB::END) (OPTIMIZE)) ; (DECLARE (TYPE (FUNCTION (T) XLIB:CARD16) XLIB::TRANSFORM) ; (DYNAMIC-EXTENT XLIB::TRANSFORM)) ; (XLIB::WITH-VECTOR (XLIB::DATA VECTOR) ; (XLIB::WRITING-BUFFER-CHUNKS XLIB:CARD16 ; ((XLIB::INDEX XLIB::START)) ; ((TYPE XLIB:ARRAY-INDEX ; XLIB::INDEX)) ; (DO (#) ; (# #) ; (DECLARE #) ; (XLIB::WRITE-CHAR2B ; XLIB::J #) ; (SETQ XLIB::INDEX #)))) ; NIL) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN LOCALLY SB-C::%FUNCALL ; ==> ; #:G3778 ; ; note: could not stack allocate the result of (DEFUN WRITE-VECTOR-CHAR2B-WITH-TRANSFORM ; (BUFFER BOFFSET DATA START END ; TRANSFORM) ; (DECLARE (TYPE BUFFER BUFFER) ; (TYPE VECTOR DATA) ; (TYPE ARRAY-INDEX BOFFSET START END) ; (OPTIMIZE)) ; (DECLARE ; (TYPE (FUNCTION (T) CARD16) ; TRANSFORM) ; (DYNAMIC-EXTENT TRANSFORM)) ; (WITH-VECTOR (DATA VECTOR) ; (WRITING-BUFFER-CHUNKS ; CARD16 ((INDEX START)) ; ((TYPE ARRAY-INDEX ; INDEX)) ; (DO ((J 0 #)) ; ((INDEX>= J #) ; (SETF CHUNK J)) ; (DECLARE ; (TYPE ARRAY-INDEX J)) ; (WRITE-CHAR2B J ; (FUNCALL ; TRANSFORM ; #)) ; (SETQ INDEX ; (INDEX+ INDEX ; 1))))) ; NIL) ; compiling (DEFUN WRITE-VECTOR-CHAR2B-WITH-TRANSFORM ...) ; file: /usr/share/common-lisp/source/clx/buffer.lisp ; in: DEFUN WRITE-SEQUENCE-CHAR2B ; (DEFUN XLIB::WRITE-SEQUENCE-CHAR2B ; (XLIB::BUFFER XLIB::BOFFSET XLIB::DATA ; &OPTIONAL (XLIB::START 0) (XLIB::END (LENGTH XLIB::DATA)) ; XLIB::TRANSFORM) ; (DECLARE (TYPE XLIB::BUFFER XLIB::BUFFER) (TYPE SEQUENCE XLIB::DATA) ; (TYPE XLIB:ARRAY-INDEX XLIB::BOFFSET XLIB::START XLIB::END)) ; (DECLARE (TYPE (OR NULL (FUNCTION # XLIB:CARD16)) XLIB::TRANSFORM) ; (DYNAMIC-EXTENT XLIB::TRANSFORM)) ; (TYPECASE XLIB::DATA ; (LIST ; (IF XLIB::TRANSFORM ; (XLIB::WRITE-LIST-CHAR2B-WITH-TRANSFORM XLIB::BUFFER XLIB::BOFFSET ; XLIB::DATA XLIB::START XLIB::END XLIB::TRANSFORM) ; (XLIB::WRITE-LIST-CHAR2B XLIB::BUFFER XLIB::BOFFSET XLIB::DATA ; XLIB::START XLIB::END))) ; ((SIMPLE-ARRAY XLIB:CARD16 (*)) ; (IF XLIB::TRANSFORM ; (XLIB::WRITE-SIMPLE-ARRAY-CHAR2B-WITH-TRANSFORM XLIB::BUFFER ; XLIB::BOFFSET XLIB::DATA XLIB::START XLIB::END XLIB::TRANSFORM) ; (XLIB::WRITE-SIMPLE-ARRAY-CHAR2B XLIB::BUFFER XLIB::BOFFSET ; XLIB::DATA XLIB::START XLIB::END))) ; (T ; (IF XLIB::TRANSFORM ; (XLIB::WRITE-VECTOR-CHAR2B-WITH-TRANSFORM XLIB::BUFFER XLIB::BOFFSET ; XLIB::DATA XLIB::START XLIB::END XLIB::TRANSFORM) ; (XLIB::WRITE-VECTOR-CHAR2B XLIB::BUFFER XLIB::BOFFSET XLIB::DATA ; XLIB::START XLIB::END))))) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN COND IF COND IF COND IF COND IF PROGN ; --> SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET VALUES PROG1 LET ; ==> ; #:G3845 ; ; note: could not stack allocate the result of (DEFUN WRITE-SEQUENCE-CHAR2B ; (BUFFER BOFFSET DATA ; &OPTIONAL (START 0) ; (END (LENGTH DATA)) TRANSFORM) ; (DECLARE (TYPE BUFFER BUFFER) ; (TYPE SEQUENCE DATA) ; (TYPE ARRAY-INDEX BOFFSET START END)) ; (DECLARE ; (TYPE (OR NULL (FUNCTION (T) CARD16)) ; TRANSFORM) ; (DYNAMIC-EXTENT TRANSFORM)) ; (TYPECASE DATA ; (LIST ; (IF TRANSFORM ; (WRITE-LIST-CHAR2B-WITH-TRANSFORM ; BUFFER BOFFSET DATA START END ; TRANSFORM) ; (WRITE-LIST-CHAR2B BUFFER ; BOFFSET DATA START END))) ; ((SIMPLE-ARRAY CARD16 (*)) ; (IF TRANSFORM ; (WRITE-SIMPLE-ARRAY-CHAR2B-WITH-TRANSFORM ; BUFFER BOFFSET DATA START END ; TRANSFORM) ; (WRITE-SIMPLE-ARRAY-CHAR2B ; BUFFER BOFFSET DATA START ; END))) ; (T ; (IF TRANSFORM ; (WRITE-VECTOR-CHAR2B-WITH-TRANSFORM ; BUFFER BOFFSET DATA START END ; TRANSFORM) ; (WRITE-VECTOR-CHAR2B BUFFER ; BOFFSET DATA START END))))) ; compiling (DEFUN WRITE-SEQUENCE-CHAR2B ...) ; /var/cache/common-lisp-controller/1001/sbcl/clx/buffer.fasl written ; compilation finished in 0:00:02.058 ; compiling file "/usr/share/common-lisp/source/clx/display.lisp" (written 26 AUG 2005 12:13:28 PM): ; compiling (IN-PACKAGE :XLIB) ; compiling (DEFPARAMETER *KNOWN-AUTHORIZATIONS* ...) ; compiling (DEFUN READ-XAUTH-ENTRY ...) ; compiling (DEFUN GET-BEST-AUTHORIZATION ...) ; compiling (DEFUN INITIALIZE-RESOURCE-ALLOCATOR ...) ; compiling (DEFUN RESOURCEALLOC ...) ; compiling (DEFMACRO ALLOCATE-RESOURCE-ID ...) ; compiling (DEFMACRO DEALLOCATE-RESOURCE-ID ...) ; compiling (DEFUN DEALLOCATE-RESOURCE-ID-INTERNAL ...) ; compiling (DEFUN LOOKUP-RESOURCE-ID ...) ; compiling (DEFUN SAVE-ID ...) ; compiling (GENERATE-LOOKUP-FUNCTIONS IGNORE ...) ; compiling (DEFUN ID-ATOM ...) ; compiling (DEFUN ATOM-ID ...) ; compiling (DEFUN SET-ATOM-ID ...) ; compiling (DEFSETF ATOM-ID ...) ; compiling (DEFUN INITIALIZE-PREDEFINED-ATOMS ...) ; compiling (DEFUN VISUAL-INFO ...) ; compiling (DEFMACRO WITH-DISPLAY ...) ; compiling (DEFMACRO WITH-EVENT-QUEUE ...) ; file: /usr/share/common-lisp/source/clx/display.lisp ; in: DEFUN WITH-EVENT-QUEUE-FUNCTION ; (DEFUN XLIB::WITH-EVENT-QUEUE-FUNCTION (XLIB:DISPLAY XLIB::TIMEOUT FUNCTION) ; (DECLARE (TYPE XLIB:DISPLAY XLIB:DISPLAY) ; (TYPE (OR NULL NUMBER) XLIB::TIMEOUT) (TYPE FUNCTION FUNCTION) ; (DYNAMIC-EXTENT FUNCTION) (IGNORABLE XLIB:DISPLAY XLIB::TIMEOUT)) ; (XLIB:WITH-EVENT-QUEUE (XLIB:DISPLAY :TIMEOUT XLIB::TIMEOUT :INLINE T) ; (FUNCALL FUNCTION))) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN LOCALLY SB-C::%FUNCALL ; ==> ; #:G457 ; ; note: could not stack allocate the result of (DEFUN WITH-EVENT-QUEUE-FUNCTION ; (DISPLAY TIMEOUT FUNCTION) ; (DECLARE (TYPE DISPLAY DISPLAY) ; (TYPE (OR NULL NUMBER) TIMEOUT) ; (TYPE FUNCTION FUNCTION) ; (DYNAMIC-EXTENT FUNCTION) ; (IGNORABLE DISPLAY TIMEOUT)) ; (WITH-EVENT-QUEUE ; (DISPLAY :TIMEOUT TIMEOUT :INLINE T) ; (FUNCALL FUNCTION))) ; compiling (DEFUN WITH-EVENT-QUEUE-FUNCTION ...) ; compiling (DEFMACRO WITH-EVENT-QUEUE-INTERNAL ...) ; compiling (DEFUN OPEN-DEFAULT-DISPLAY ...) ; compiling (DEFUN OPEN-DISPLAY ...) ; compiling (DEFUN DISPLAY-FORCE-OUTPUT ...) ; compiling (DEFUN CLOSE-DISPLAY ...) ; file: /usr/share/common-lisp/source/clx/display.lisp ; in: DEFUN DISPLAY-CONNECT ; (LENGTH XLIB::AUTHORIZATION-NAME) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)). ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a SEQUENCE, not a VECTOR. ; (LENGTH XLIB::AUTHORIZATION-DATA) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)). ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a SEQUENCE, not a VECTOR. ; (LENGTH XLIB::AUTHORIZATION-NAME) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)). ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a SEQUENCE, not a VECTOR. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)). ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a SEQUENCE, not a VECTOR. ; compiling (DEFUN DISPLAY-CONNECT ...) ; compiling (DEFUN DISPLAY-PROTOCOL-VERSION ...) ; compiling (DEFUN DISPLAY-VENDOR ...) ; compiling (DEFUN DISPLAY-NSCREENS ...) ; compiling (DEFVAR *INSIDE-DISPLAY-AFTER-FUNCTION* ...) ; compiling (DEFUN DISPLAY-INVOKE-AFTER-FUNCTION ...) ; file: /usr/share/common-lisp/source/clx/display.lisp ; in: DEFUN DISPLAY-FINISH-OUTPUT ; (XLIB::WITH-BUFFER-REQUEST-AND-REPLY ; (XLIB:DISPLAY XLIB::+X-GETINPUTFOCUS+ 16 :SIZES (8 32)) NIL) ; --> 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 DISPLAY-FINISH-OUTPUT ...) ; compiling (DEFPARAMETER *REQUEST-NAMES* ...) ; /var/cache/common-lisp-controller/1001/sbcl/clx/display.fasl written ; compilation finished in 0:00:00.553 ; compiling file "/usr/share/common-lisp/source/clx/gcontext.lisp" (written 14 JUL 2005 03:24:45 PM): ; compiling (IN-PACKAGE :XLIB) ; compiling (DEFCONSTANT +GCONTEXT-FAST-CHANGE-LENGTH+ ...) ; compiling (DEF-GC-INTERNALS IGNORE ...) ; compiling (DEFTYPE GCMASK ...) ; compiling (DEFTYPE XGCMASK ...) ; compiling (DEFSTRUCT (GCONTEXT-EXTENSION # ...) ...) ; compiling (DEFVAR *GCONTEXT-EXTENSIONS* ...) ; compiling (DEFVAR *GCONTEXT-LOCAL-STATE-CACHE* ...) ; compiling (DEFMACRO GCONTEXT-STATE-NEXT ...) ; compiling (DEFUN ALLOCATE-GCONTEXT-STATE ...) ; compiling (DEFUN DEALLOCATE-GCONTEXT-STATE ...) ; compiling (DEFVAR *TEMP-GCONTEXT-CACHE* ...) ; compiling (DEFUN ALLOCATE-TEMP-GCONTEXT ...) ; compiling (DEFUN DEALLOCATE-TEMP-GCONTEXT ...) ; compiling (DEFMACRO XGCMASK->GCMASK ...) ; compiling (DEFMACRO ACCESS-GCONTEXT ...) ; compiling (DEFMACRO MODIFY-GCONTEXT ...) ; compiling (DEFMACRO DEF-GC-ACCESSOR ...) ; compiling (DEFMACRO INCF-INTERNAL-TIMESTAMP ...) ; compiling (DEF-GC-ACCESSOR FUNCTION ...) ; compiling (DEF-GC-ACCESSOR PLANE-MASK ...) ; compiling (DEF-GC-ACCESSOR FOREGROUND ...) ; compiling (DEF-GC-ACCESSOR BACKGROUND ...) ; compiling (DEF-GC-ACCESSOR LINE-WIDTH ...) ; compiling (DEF-GC-ACCESSOR LINE-STYLE ...) ; compiling (DEF-GC-ACCESSOR CAP-STYLE ...) ; compiling (DEF-GC-ACCESSOR JOIN-STYLE ...) ; compiling (DEF-GC-ACCESSOR FILL-STYLE ...) ; compiling (DEF-GC-ACCESSOR FILL-RULE ...) ; compiling (DEF-GC-ACCESSOR TILE ...) ; compiling (DEF-GC-ACCESSOR STIPPLE ...) ; compiling (DEF-GC-ACCESSOR TS-X ...) ; compiling (DEF-GC-ACCESSOR TS-Y ...) ; compiling (DEF-GC-ACCESSOR SUBWINDOW-MODE ...) ; compiling (DEF-GC-ACCESSOR EXPOSURES ...) ; compiling (DEF-GC-ACCESSOR CLIP-X ...) ; compiling (DEF-GC-ACCESSOR CLIP-Y ...) ; compiling (DEF-GC-ACCESSOR DASH-OFFSET ...) ; compiling (DEF-GC-ACCESSOR ARC-MODE ...) ; compiling (DEFUN GCONTEXT-CLIP-MASK ...) ; compiling (DEFSETF GCONTEXT-CLIP-MASK ...) ; compiling (DEFUN SET-GCONTEXT-CLIP-MASK ...) ; compiling (DEFUN GCONTEXT-DASHES ...) ; compiling (DEFSETF GCONTEXT-DASHES ...) ; compiling (DEFUN SET-GCONTEXT-DASHES ...) ; compiling (DEFUN GCONTEXT-FONT ...) ; compiling (DEFSETF GCONTEXT-FONT ...) ; compiling (DEFUN SET-GCONTEXT-FONT ...) ; file: /usr/share/common-lisp/source/clx/gcontext.lisp ; in: DEFUN FORCE-GCONTEXT-CHANGES-INTERNAL ; (LENGTH XLIB::LOCAL-DASH) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)). ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a SEQUENCE, not a VECTOR. ; (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-SETDASHES+) ; (XLIB:GCONTEXT XLIB:GCONTEXT) ; (XLIB:CARD16 ; (OR ; (XLIB::GCONTEXT-INTERNAL-DASH-OFFSET ; XLIB::LOCAL-STATE) ; 0) ; (LENGTH XLIB::LOCAL-DASH)) ; ((SEQUENCE :FORMAT XLIB:CARD8) XLIB::LOCAL-DASH)) ; --> LET XLIB::WITH-BUFFER PROGN MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS ; --> PROGN XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET ; --> LET* XLIB::CHECK-PUT XLIB::SEQUENCE-PUT LET ; ==> ; (LENGTH XLIB::LOCAL-DASH) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (OR CONS VECTOR ; SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY ; * (*)). ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (OR CONS VECTOR ; SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR. ; --> LET XLIB::WITH-BUFFER PROGN 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). ; (ZEROP (XLIB::BUFFER-LAST-REQUEST XLIB:DISPLAY)) ; ==> ; (= (XLIB::BUFFER-LAST-REQUEST XLIB:DISPLAY) 0) ; ; note: unable to ; open-code FLOAT to RATIONAL comparison ; 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: unable to open code because: The operands might not be the same type. ; (EQL (SVREF XLIB::SERVER-STATE XLIB::I) ; (SETQ XLIB::LOCAL (SVREF XLIB::LOCAL-STATE XLIB::I))) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a T, not a SINGLE-FLOAT. ; The second argument is a T, not a SINGLE-FLOAT. ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a T, not a DOUBLE-FLOAT. ; The second argument is a T, not a DOUBLE-FLOAT. ; (FUNCALL (XLIB::GCONTEXT-EXTENSION-SET-FUNCTION (CAR XLIB::EXTENSION)) ; XLIB:GCONTEXT XLIB::LOCAL) ; --> SB-C::%FUNCALL THE ; ==> ; (SB-KERNEL:%COERCE-CALLABLE-TO-FUN ; (XLIB::GCONTEXT-EXTENSION-SET-FUNCTION (CAR XLIB::EXTENSION))) ; ; note: unable to ; optimize ; because: ; optimize away possible call to FDEFINITION at runtime ; (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-SETCLIPRECTANGLES+) ; (XLIB::DATA (FIRST XLIB::LOCAL-CLIP)) ; (XLIB:GCONTEXT XLIB:GCONTEXT) ; (XLIB:CARD16 ; (OR ; (XLIB::GCONTEXT-INTERNAL-CLIP-X ; XLIB::LOCAL-STATE) ; 0) ; (OR ; (XLIB::GCONTEXT-INTERNAL-CLIP-Y ; XLIB::LOCAL-STATE) ; 0)) ; ((SEQUENCE :FORMAT XLIB:INT16) ; (SECOND XLIB::LOCAL-CLIP))) ; --> LET XLIB::WITH-BUFFER PROGN MULTIPLE-VALUE-PROG1 XLIB::WITHOUT-ABORTS ; --> PROGN XLIB::WITH-BUFFER-REQUEST-INTERNAL XLIB::WITH-BUFFER-OUTPUT LET ; --> LET* XLIB::CHECK-PUT LET XLIB::SEQUENCE-PUT LET ; ==> ; (LENGTH XLIB::.VALUE.) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)). ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a SEQUENCE, not a VECTOR. ; --> LET XLIB::WITH-BUFFER PROGN 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). ; (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-CHANGEGC+) ; (XLIB:GCONTEXT XLIB:GCONTEXT) ; (PROGN ; (DO ((XLIB::I 0 #) ; (BIT 1 #) ; (XLIB::NBYTE 12) ; (XLIB::MASK 0) ; (XLIB::LOCAL 0)) ; ((XLIB::INDEX>= XLIB::I ; XLIB::+GCONTEXT-FAST-CHANGE-LENGTH+) ; (WHEN # # #) ; (XLIB::CARD29-PUT 8 XLIB::MASK) ; (XLIB::CARD16-PUT 2 #) ; (XLIB::INDEX-INCF # XLIB::NBYTE)) ; (DECLARE ; (TYPE XLIB:ARRAY-INDEX XLIB::I XLIB::NBYTE) ; (TYPE XLIB::XGCMASK BIT) ; (TYPE XLIB::GCMASK XLIB::MASK) ; (TYPE # XLIB::LOCAL)) ; (UNLESS (EQL # #) ; (SETF # XLIB::LOCAL) ; (XLIB::CARD32-PUT XLIB::NBYTE XLIB::LOCAL) ; (SETQ XLIB::MASK #) ; (XLIB::INDEX-INCF XLIB::NBYTE 4))))) ; --> LET XLIB::WITH-BUFFER PROGN 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 PROGN 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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. ; (EQL (SVREF XLIB::SERVER-STATE XLIB::I) ; (SETQ XLIB::LOCAL (SVREF XLIB::LOCAL-STATE XLIB::I))) ; ; note: forced to do GENERIC-EQL (cost 10) ; unable to do inline fixnum comparison (cost 4) because: ; The first argument is a T, not a FIXNUM. ; The second argument is a T, not a FIXNUM. ; (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-SETCLIPRECTANGLES+) ; (XLIB::DATA (FIRST XLIB::LOCAL-CLIP)) ; (XLIB:GCONTEXT XLIB:GCONTEXT) ; (XLIB:CARD16 ; (OR ; (XLIB::GCONTEXT-INTERNAL-CLIP-X ; XLIB::LOCAL-STATE) ; 0) ; (OR ; (XLIB::GCONTEXT-INTERNAL-CLIP-Y ; XLIB::LOCAL-STATE) ; 0)) ; ((SEQUENCE :FORMAT XLIB:INT16) ; (SECOND XLIB::LOCAL-CLIP))) ; --> LET XLIB::WITH-BUFFER PROGN 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 PROGN 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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. ; (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-SETDASHES+) ; (XLIB:GCONTEXT XLIB:GCONTEXT) ; (XLIB:CARD16 ; (OR ; (XLIB::GCONTEXT-INTERNAL-DASH-OFFSET ; XLIB::LOCAL-STATE) ; 0) ; (LENGTH XLIB::LOCAL-DASH)) ; ((SEQUENCE :FORMAT XLIB:CARD8) XLIB::LOCAL-DASH)) ; --> LET XLIB::WITH-BUFFER PROGN 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 PROGN 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 FORCE-GCONTEXT-CHANGES-INTERNAL ...) ; compiling (DEFUN FORCE-GCONTEXT-CHANGES ...) ; compiling (DEFMACRO WITH-GCONTEXT ...) ; file: /usr/share/common-lisp/source/clx/gcontext.lisp ; in: DEFUN COPY-GCONTEXT-LOCAL-STATE ; (XLIB::ALLOCATE-RESOURCE-ID XLIB:DISPLAY XLIB:GCONTEXT 'XLIB:GCONTEXT) ; --> 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-COPYGC+) ; (XLIB:GCONTEXT XLIB:GCONTEXT) ; (XLIB:GCONTEXT XLIB::TEMP-GC) ; (XLIB:CARD29 ; (XLIB::XGCMASK->GCMASK XLIB::TEMP-MASK))) ; --> LET XLIB::WITH-BUFFER PROGN 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). ; (- XLIB::*GCONTEXT-DATA-LENGTH*) ; ==> ; (SB-KERNEL:%NEGATE XLIB::*GCONTEXT-DATA-LENGTH*) ; ; 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). ; (ELT XLIB::*GCONTEXT-EXTENSIONS* XLIB::I) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)). ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a SEQUENCE, not a LIST. ; (FUNCALL XLIB::COPY-FUNCTION XLIB:GCONTEXT XLIB::TEMP-GC ; (SVREF XLIB::LOCAL-STATE ; (XLIB::INDEX+ XLIB::I XLIB::*GCONTEXT-DATA-LENGTH*))) ; --> SB-C::%FUNCALL THE ; ==> ; (SB-KERNEL:%COERCE-CALLABLE-TO-FUN XLIB::COPY-FUNCTION) ; ; note: unable to ; optimize ; because: ; optimize away possible call to FDEFINITION at runtime ; (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-CREATEGC+) ; (XLIB:GCONTEXT XLIB::TEMP-GC) ; (XLIB:DRAWABLE ; (XLIB::GCONTEXT-DRAWABLE XLIB:GCONTEXT)) ; (XLIB:CARD29 0)) ; --> LET XLIB::WITH-BUFFER PROGN 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 PROGN 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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. ; (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-COPYGC+) ; (XLIB:GCONTEXT XLIB:GCONTEXT) ; (XLIB:GCONTEXT XLIB::TEMP-GC) ; (XLIB:CARD29 ; (XLIB::XGCMASK->GCMASK XLIB::TEMP-MASK))) ; --> LET XLIB::WITH-BUFFER PROGN 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 PROGN 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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. ; (- XLIB::*GCONTEXT-DATA-LENGTH*) ; ==> ; (SB-KERNEL:%NEGATE XLIB::*GCONTEXT-DATA-LENGTH*) ; ; note: forced to do GENERIC-NEGATE (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 (signed-byte 64) arithmetic (cost 2) because: ; The first argument is a NUMBER, not a (SIGNED-BYTE 64). ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES ; (SIGNED-BYTE 64) &REST ; T). ; (ASH XLIB::EXTENSION-MASK (- XLIB::*GCONTEXT-DATA-LENGTH*)) ; ; note: forced to do full call ; unable to do inline ASH (cost 3) because: ; The second argument is a INTEGER, not a (UNSIGNED-BYTE 60). ; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM ; &REST T). ; unable to do inline ASH (cost 3) because: ; The second argument is a INTEGER, not a (UNSIGNED-BYTE 60). ; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM ; &REST T). ; etc. ; (ASH BIT -1) ; ; note: forced to do full call ; unable to do inline ASH (cost 2) 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 ASH (cost 3) because: ; The first argument is a INTEGER, not a (UNSIGNED-BYTE 64). ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE 64) ; &REST T). ; etc. ; compiling (DEFUN COPY-GCONTEXT-LOCAL-STATE ...) ; file: /usr/share/common-lisp/source/clx/gcontext.lisp ; in: DEFUN RESTORE-GCONTEXT-TEMP-STATE ; (- XLIB::*GCONTEXT-DATA-LENGTH*) ; ==> ; (SB-KERNEL:%NEGATE XLIB::*GCONTEXT-DATA-LENGTH*) ; ; 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). ; (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-FREEGC+) ; (XLIB:GCONTEXT XLIB::TEMP-GC)) ; --> LET XLIB::WITH-BUFFER PROGN 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). ; (FUNCALL XLIB::COPY-FUNCTION XLIB::TEMP-GC XLIB:GCONTEXT ; (SVREF XLIB::LOCAL-STATE XLIB::I)) ; --> SB-C::%FUNCALL THE ; ==> ; (SB-KERNEL:%COERCE-CALLABLE-TO-FUN XLIB::COPY-FUNCTION) ; ; note: unable to ; optimize ; because: ; optimize away possible call to FDEFINITION at runtime ; (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-COPYGC+) ; (XLIB:GCONTEXT XLIB::TEMP-GC) ; (XLIB:GCONTEXT XLIB:GCONTEXT) ; (XLIB:CARD29 ; (XLIB::XGCMASK->GCMASK XLIB::TEMP-MASK))) ; --> LET XLIB::WITH-BUFFER PROGN 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 PROGN 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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. ; (- XLIB::*GCONTEXT-DATA-LENGTH*) ; ==> ; (SB-KERNEL:%NEGATE XLIB::*GCONTEXT-DATA-LENGTH*) ; ; note: forced to do GENERIC-NEGATE (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 (signed-byte 64) arithmetic (cost 2) because: ; The first argument is a NUMBER, not a (SIGNED-BYTE 64). ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES ; (SIGNED-BYTE 64) &REST ; T). ; (ASH XLIB::TEMP-MASK (- XLIB::*GCONTEXT-DATA-LENGTH*)) ; ; note: forced to do full call ; unable to do inline ASH (cost 3) because: ; The second argument is a INTEGER, not a (UNSIGNED-BYTE 60). ; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM ; &REST T). ; unable to do inline ASH (cost 3) because: ; The second argument is a INTEGER, not a (UNSIGNED-BYTE 60). ; The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM ; &REST T). ; etc. ; (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-FREEGC+) ; (XLIB:GCONTEXT XLIB::TEMP-GC)) ; --> LET XLIB::WITH-BUFFER PROGN 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 PROGN 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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. ; (ASH BIT -1) ; ; note: forced to do full call ; unable to do inline ASH (cost 2) 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 ASH (cost 3) because: ; The first argument is a INTEGER, not a (UNSIGNED-BYTE 64). ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE 64) ; &REST T). ; etc. ; compiling (DEFUN RESTORE-GCONTEXT-TEMP-STATE ...) ; file: /usr/share/common-lisp/source/clx/gcontext.lisp ; in: DEFUN CREATE-GCONTEXT ; (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-CREATEGC+) ; (XLIB:RESOURCE-ID XLIB::GCONTEXTID) ; (XLIB:DRAWABLE XLIB:DRAWABLE) ; (PROGN ; (DO* ((XLIB::I 0 #) ; (BIT 1 #) ; (XLIB::NBYTE 16) ; (XLIB::MASK 0) ; (XLIB::LOCAL # #)) ; ((XLIB::INDEX>= XLIB::I ; XLIB::+GCONTEXT-FAST-CHANGE-LENGTH+) ; (XLIB::CARD29-PUT 12 XLIB::MASK) ; (XLIB::CARD16-PUT 2 #) ; (XLIB::INDEX-INCF # XLIB::NBYTE)) ; (DECLARE ; (TYPE XLIB:ARRAY-INDEX XLIB::I XLIB::NBYTE) ; (TYPE XLIB::XGCMASK BIT) ; (TYPE XLIB::GCMASK XLIB::MASK) ; (TYPE # XLIB::LOCAL)) ; (UNLESS (EQL XLIB::LOCAL #) ; (SETF # XLIB::LOCAL) ; (XLIB::CARD32-PUT XLIB::NBYTE XLIB::LOCAL) ; (SETQ XLIB::MASK #) ; (XLIB::INDEX-INCF XLIB::NBYTE 4))))) ; --> 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 CREATE-GCONTEXT ...) ; file: /usr/share/common-lisp/source/clx/gcontext.lisp ; in: DEFUN COPY-GCONTEXT-COMPONENTS ; (FIND XLIB::KEY XLIB::*GCONTEXT-EXTENSIONS* :KEY ; #'XLIB::GCONTEXT-EXTENSION-NAME) ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a SEQUENCE, not a (OR CONS NULL VECTOR). ; (FUNCALL (XLIB::GCONTEXT-EXTENSION-COPY-FUNCTION XLIB::EXTENSION) XLIB::SRC ; XLIB::DST ; (SVREF (XLIB::GCONTEXT-LOCAL-STATE XLIB::SRC) ; (XLIB::INDEX+ ; (POSITION XLIB::EXTENSION XLIB::*GCONTEXT-EXTENSIONS*) ; XLIB::*GCONTEXT-DATA-LENGTH*))) ; --> SB-C::%FUNCALL THE ; ==> ; (SB-KERNEL:%COERCE-CALLABLE-TO-FUN ; (XLIB::GCONTEXT-EXTENSION-COPY-FUNCTION XLIB::EXTENSION)) ; ; note: unable to ; optimize ; because: ; optimize away possible call to FDEFINITION at runtime ; (POSITION XLIB::EXTENSION XLIB::*GCONTEXT-EXTENSIONS*) ; ; note: unable to ; optimize ; due to type uncertainty: ; The second argument is a SEQUENCE, not a (OR CONS NULL VECTOR). ; (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-COPYGC+) ; (XLIB:GCONTEXT XLIB::SRC XLIB::DST) ; (XLIB:CARD29 (XLIB::XGCMASK->GCMASK XLIB::MASK))) ; --> LET XLIB::WITH-BUFFER PROGN 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 PROGN 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 COPY-GCONTEXT-COMPONENTS ...) ; compiling (DEFUN COPY-GCONTEXT ...) ; file: /usr/share/common-lisp/source/clx/gcontext.lisp ; in: DEFUN FREE-GCONTEXT ; (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-FREEGC+) ; (XLIB:GCONTEXT XLIB:GCONTEXT)) ; --> 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 FREE-GCONTEXT ...) ; compiling (DEFMACRO DEFINE-GCONTEXT-ACCESSOR ...) ; compiling (DEFUN ADD-GCONTEXT-EXTENSION ...) ; /var/cache/common-lisp-controller/1001/sbcl/clx/gcontext.fasl written ; compilation finished in 0:00:02.046 ; compiling file "/usr/share/common-lisp/source/clx/input.lisp" (written 14 JUL 2005 03:24:45 PM): ; compiling (IN-PACKAGE :XLIB) ; compiling (DEFVAR *EVENT-FREE-LIST* ...) ; compiling (DEFCONSTANT +MAX-EVENTS+ ...) ; compiling (DEFVAR *EVENT-KEY-VECTOR* ...) ; compiling (DEFVAR *EVENT-MACRO-VECTOR* ...) ; compiling (DEFVAR *EVENT-HANDLER-VECTOR* ...) ; compiling (DEFVAR *EVENT-SEND-VECTOR* ...) ; compiling (DEFUN ALLOCATE-EVENT ...) ; compiling (DEFUN DEALLOCATE-EVENT ...) ; compiling (DEFPARAMETER *FIRST-EXTENSION-EVENT-CODE* ...) ; compiling (DEFVAR *EXTENSIONS* ...) ; compiling (DEFMACRO DEFINE-EXTENSION ...) ; compiling (DEFUN CANONICALIZE-EVENT-NAME ...) ; compiling (DEFUN ALLOCATE-EXTENSION-EVENT-CODE ...) ; compiling (DEFUN GET-INTERNAL-EVENT-CODE ...) ; compiling (DEFUN GET-EXTERNAL-EVENT-CODE ...) ; compiling (DEFMACRO EXTENSION-OPCODE ...) ; compiling (DEFUN INITIALIZE-EXTENSIONS ...) ; compiling (DEFVAR *PENDING-COMMAND-FREE-LIST* ...) ; compiling (DEFUN START-PENDING-COMMAND ...) ; compiling (DEFUN STOP-PENDING-COMMAND ...) ; compiling (DEFVAR *REPLY-BUFFER-FREE-LISTS* ...) ; compiling (DEFUN ALLOCATE-REPLY-BUFFER ...) ; compiling (DEFUN DEALLOCATE-REPLY-BUFFER ...) ; compiling (DEFUN READ-ERROR-INPUT ...) ; compiling (DEFUN READ-REPLY-INPUT ...) ; compiling (DEFUN READ-EVENT-INPUT ...) ; compiling (DEFUN NOTE-INPUT-COMPLETE ...) ; file: /usr/share/common-lisp/source/clx/input.lisp ; in: DEFUN READ-INPUT ; (DEFUN XLIB::READ-INPUT ; (XLIB:DISPLAY XLIB::TIMEOUT XLIB::FORCE-OUTPUT-P XLIB::PREDICATE ; &REST XLIB::PREDICATE-ARGS) ; (DECLARE (TYPE XLIB:DISPLAY XLIB:DISPLAY) ; (TYPE (OR NULL NUMBER) XLIB::TIMEOUT) ; (TYPE XLIB:GENERALIZED-BOOLEAN XLIB::FORCE-OUTPUT-P) ; (DYNAMIC-EXTENT XLIB::PREDICATE-ARGS)) ; (DECLARE (TYPE FUNCTION XLIB::PREDICATE) (DYNAMIC-EXTENT XLIB::PREDICATE)) ; (LET ((XLIB::REPLY-BUFFER NIL) (XLIB::TOKEN (OR # #))) ; (DECLARE (TYPE (OR NULL XLIB::REPLY-BUFFER) XLIB::REPLY-BUFFER)) ; (UNWIND-PROTECT ; (TAGBODY ; LOOP ; (WHEN # #) ; (WHEN # #) ; (WHEN # #) ; (UNLESS # # #) ; (SETQ XLIB::REPLY-BUFFER #) ; (XLIB::WITH-BUFFER-INPUT # #) ; (GO LOOP) ; FORCE-OUTPUT ; (XLIB::NOTE-INPUT-COMPLETE XLIB:DISPLAY XLIB::TOKEN) ; (XLIB:DISPLAY-FORCE-OUTPUT XLIB:DISPLAY) ...) ; (WHEN (NOT #) (XLIB::DEALLOCATE-REPLY-BUFFER XLIB::REPLY-BUFFER)) ; (XLIB::NOTE-INPUT-COMPLETE XLIB:DISPLAY XLIB::TOKEN)))) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN COND IF PROGN MULTIPLE-VALUE-BIND ; --> MULTIPLE-VALUE-CALL FUNCTION LOCALLY SB-C::%FUNCALL ; ==> ; #:G693 ; ; note: could not stack allocate the result of (DEFUN READ-INPUT ; (DISPLAY TIMEOUT FORCE-OUTPUT-P ; PREDICATE ; &REST PREDICATE-ARGS) ; (DECLARE (TYPE DISPLAY DISPLAY) ; (TYPE (OR NULL NUMBER) TIMEOUT) ; (TYPE GENERALIZED-BOOLEAN ; FORCE-OUTPUT-P) ; (DYNAMIC-EXTENT PREDICATE-ARGS)) ; (DECLARE (TYPE FUNCTION PREDICATE) ; (DYNAMIC-EXTENT PREDICATE)) ; (LET ((REPLY-BUFFER NIL) ; (TOKEN ; (OR (CURRENT-PROCESS) ; (CONS NIL NIL)))) ; (DECLARE ; (TYPE (OR NULL REPLY-BUFFER) ; REPLY-BUFFER)) ; (UNWIND-PROTECT ; (TAGBODY ; LOOP ; (WHEN (DISPLAY-DEAD DISPLAY) ; (X-ERROR 'CLOSED-DISPLAY ; :DISPLAY DISPLAY)) ; (WHEN ; (APPLY PREDICATE ; PREDICATE-ARGS) ; (RETURN-FROM READ-INPUT ; NIL)) ; (WHEN (AND FORCE-OUTPUT-P #) ; (GO FORCE-OUTPUT)) ; (UNLESS (OR # #) ; (IF # # #) ; (GO LOOP)) ; (SETQ REPLY-BUFFER ; (ALLOCATE-EVENT)) ; (WITH-BUFFER-INPUT ; (REPLY-BUFFER :SIZES #) ; (LET # ; # ; # ; # ; #)) ; (GO LOOP) ; FORCE-OUTPUT ; (NOTE-INPUT-COMPLETE DISPLAY ; TOKEN) ; (DISPLAY-FORCE-OUTPUT ; DISPLAY) ...) ; (WHEN (NOT (NULL REPLY-BUFFER)) ; (DEALLOCATE-REPLY-BUFFER ; REPLY-BUFFER)) ; (NOTE-INPUT-COMPLETE DISPLAY ; TOKEN)))) ; #'(LAMBDA (XLIB:DISPLAY XLIB::PREDICATE &REST XLIB::PREDICATE-ARGS) ; (DECLARE (TYPE XLIB:DISPLAY XLIB:DISPLAY) ; (DYNAMIC-EXTENT XLIB::PREDICATE-ARGS) (TYPE FUNCTION XLIB::PREDICATE) ; (DYNAMIC-EXTENT XLIB::PREDICATE)) ; (OR (APPLY XLIB::PREDICATE XLIB::PREDICATE-ARGS) ; (NULL (XLIB::DISPLAY-INPUT-IN-PROGRESS XLIB:DISPLAY)) ; (NOT (NULL (XLIB::DISPLAY-DEAD XLIB:DISPLAY))))) ; --> SB-C::%FUNCALL ; ==> ; XLIB::PREDICATE ; ; note: could not stack allocate the result of #'(LAMBDA ; (DISPLAY PREDICATE ; &REST PREDICATE-ARGS) ; (DECLARE (TYPE DISPLAY DISPLAY) ; (DYNAMIC-EXTENT PREDICATE-ARGS) ; (TYPE FUNCTION PREDICATE) ; (DYNAMIC-EXTENT PREDICATE)) ; (OR (APPLY PREDICATE PREDICATE-ARGS) ; (NULL ; (DISPLAY-INPUT-IN-PROGRESS ; DISPLAY)) ; (NOT ; (NULL (DISPLAY-DEAD DISPLAY))))) ; --> LET SB-C::%FUNCALL ; ==> ; XLIB::PREDICATE ; ; note: could not stack allocate the result of #'(LAMBDA ; (DISPLAY PREDICATE ; &REST PREDICATE-ARGS) ; (DECLARE (TYPE DISPLAY DISPLAY) ; (DYNAMIC-EXTENT PREDICATE-ARGS) ; (TYPE FUNCTION PREDICATE) ; (DYNAMIC-EXTENT PREDICATE)) ; (OR (APPLY PREDICATE PREDICATE-ARGS) ; (NULL ; (DISPLAY-INPUT-IN-PROGRESS ; DISPLAY)) ; (NOT ; (NULL (DISPLAY-DEAD DISPLAY))))) ; compiling (DEFUN READ-INPUT ...) ; compiling (DEFUN REPORT-ASYNCHRONOUS-ERRORS ...) ; compiling (DEFUN WAIT-FOR-EVENT ...) ; compiling (DEFUN READ-REPLY ...) ; compiling (DEFUN EVENT-LISTEN ...) ; file: /usr/share/common-lisp/source/clx/input.lisp ; in: DEFUN QUEUE-EVENT ; (APPLY (SVREF XLIB::*EVENT-SEND-VECTOR* XLIB::EVENT-CODE) XLIB:DISPLAY ; XLIB::ARGS) ; --> MULTIPLE-VALUE-CALL ; ==> ; (SB-KERNEL:%COERCE-CALLABLE-TO-FUN ; (SVREF XLIB::*EVENT-SEND-VECTOR* XLIB::EVENT-CODE)) ; ; note: unable to ; optimize ; because: ; optimize away possible call to FDEFINITION at runtime ; compiling (DEFUN QUEUE-EVENT ...) ; compiling (DEFUN ENQUEUE-EVENT ...) ; compiling (DEFMACRO DEFINE-EVENT ...) ; compiling (DEFINE-EVENT :KEY-PRESS ...) ; compiling (DEFINE-EVENT :KEY-RELEASE ...) ; compiling (DEFINE-EVENT :BUTTON-PRESS ...) ; compiling (DEFINE-EVENT :BUTTON-RELEASE ...) ; compiling (DEFINE-EVENT :MOTION-NOTIFY ...) ; compiling (DEFINE-EVENT :ENTER-NOTIFY ...) ; compiling (DEFINE-EVENT :LEAVE-NOTIFY ...) ; compiling (DEFINE-EVENT :FOCUS-IN ...) ; compiling (DEFINE-EVENT :FOCUS-OUT ...) ; compiling (DEFINE-EVENT :KEYMAP-NOTIFY ...) ; compiling (DEFINE-EVENT :EXPOSURE ...) ; compiling (DEFINE-EVENT :GRAPHICS-EXPOSURE ...) ; compiling (DEFINE-EVENT :NO-EXPOSURE ...) ; compiling (DEFINE-EVENT :VISIBILITY-NOTIFY ...) ; compiling (DEFINE-EVENT :CREATE-NOTIFY ...) ; compiling (DEFINE-EVENT :DESTROY-NOTIFY ...) ; compiling (DEFINE-EVENT :UNMAP-NOTIFY ...) ; compiling (DEFINE-EVENT :MAP-NOTIFY ...) ; compiling (DEFINE-EVENT :MAP-REQUEST ...) ; compiling (DEFINE-EVENT :REPARENT-NOTIFY ...) ; compiling (DEFINE-EVENT :CONFIGURE-NOTIFY ...) ; compiling (DEFINE-EVENT :CONFIGURE-REQUEST ...) ; compiling (DEFINE-EVENT :GRAVITY-NOTIFY ...) ; compiling (DEFINE-EVENT :RESIZE-REQUEST ...) ; compiling (DEFINE-EVENT :CIRCULATE-NOTIFY ...) ; compiling (DEFINE-EVENT :CIRCULATE-REQUEST ...) ; compiling (DEFINE-EVENT :PROPERTY-NOTIFY ...) ; compiling (DEFINE-EVENT :SELECTION-CLEAR ...) ; compiling (DEFINE-EVENT :SELECTION-REQUEST ...) ; compiling (DEFINE-EVENT :SELECTION-NOTIFY ...) ; compiling (DEFINE-EVENT :COLORMAP-NOTIFY ...) ; compiling (DEFINE-EVENT :CLIENT-MESSAGE ...) ; compiling (DEFINE-EVENT :MAPPING-NOTIFY ...) ; compiling (DEFMACRO DECLARE-EVENT ...) ; compiling (DEFUN CHECK-CONSISTENCY ...) ; file: /usr/share/common-lisp/source/clx/input.lisp ; in: ; DECLARE-EVENT (:KEY-PRESS :KEY-RELEASE :BUTTON-PRESS :BUTTON-RELEASE) ; (XLIB:DECLARE-EVENT (:KEY-PRESS :KEY-RELEASE :BUTTON-PRESS :BUTTON-RELEASE) ; (XLIB::DATA XLIB::CODE) (XLIB:CARD16 SEQUENCE) ; ((OR NULL XLIB:CARD32) TIME) ; (XLIB:WINDOW XLIB::ROOT (XLIB:WINDOW XLIB::EVENT-WINDOW)) ; ((OR NULL XLIB:WINDOW) XLIB::CHILD) ; (XLIB:INT16 XLIB::ROOT-X XLIB::ROOT-Y XLIB::X XLIB::Y) ; (XLIB:CARD16 XLIB::STATE) (BOOLEAN XLIB::SAME-SCREEN-P)) ; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN ; --> LOCALLY SB-C::%FUNCALL ; ==> ; #:G1641 ; ; note: could not stack allocate the result of (DECLARE-EVENT ; (:KEY-PRESS :KEY-RELEASE :BUTTON-PRESS ; :BUTTON-RELEASE) ; (DATA CODE) (CARD16 SEQUENCE) ; ((OR NULL CARD32) TIME) ; (WINDOW ROOT (WINDOW EVENT-WINDOW)) ; ((OR NULL WINDOW) CHILD) ; (INT16 ROOT-X ROOT-Y X Y) ; (CARD16 STATE) (BOOLEAN SAME-SCREEN-P)) ; compiling (DECLARE-EVENT (:KEY-PRESS :KEY-RELEASE ...) ...) ; file: /usr/share/common-lisp/source/clx/input.lisp ; in: DECLARE-EVENT :MOTION-NOTIFY ; (XLIB:DECLARE-EVENT :MOTION-NOTIFY ((XLIB::DATA BOOLEAN) XLIB::HINT-P) ; (XLIB:CARD16 SEQUENCE) ((OR NULL XLIB:CARD32) TIME) ; (XLIB:WINDOW XLIB::ROOT (XLIB:WINDOW XLIB::EVENT-WINDOW)) ; ((OR NULL XLIB:WINDOW) XLIB::CHILD) ; (XLIB:INT16 XLIB::ROOT-X XLIB::ROOT-Y XLIB::X XLIB::Y) ; (XLIB:CARD16 XLIB::STATE) (BOOLEAN XLIB::SAME-SCREEN-P)) ; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN ; --> LOCALLY SB-C::%FUNCALL ; ==> ; #:G1846 ; ; note: could not stack allocate the result of (DECLARE-EVENT :MOTION-NOTIFY ; ((DATA BOOLEAN) HINT-P) ; (CARD16 SEQUENCE) ; ((OR NULL CARD32) TIME) ; (WINDOW ROOT ; (WINDOW EVENT-WINDOW)) ; ((OR NULL WINDOW) CHILD) ; (INT16 ROOT-X ROOT-Y X Y) ; (CARD16 STATE) ; (BOOLEAN SAME-SCREEN-P)) ; compiling (DECLARE-EVENT :MOTION-NOTIFY ...) ; file: /usr/share/common-lisp/source/clx/input.lisp ; in: DECLARE-EVENT (:ENTER-NOTIFY :LEAVE-NOTIFY) ; (XLIB:DECLARE-EVENT (:ENTER-NOTIFY :LEAVE-NOTIFY) ; ((XLIB::DATA ; (XLIB::MEMBER8 :ANCESTOR :VIRTUAL :INFERIOR :NONLINEAR ; :NONLINEAR-VIRTUAL)) ; XLIB::KIND) ; (XLIB:CARD16 SEQUENCE) ((OR NULL XLIB:CARD32) TIME) ; (XLIB:WINDOW XLIB::ROOT (XLIB:WINDOW XLIB::EVENT-WINDOW)) ; ((OR NULL XLIB:WINDOW) XLIB::CHILD) ; (XLIB:INT16 XLIB::ROOT-X XLIB::ROOT-Y XLIB::X XLIB::Y) ; (XLIB:CARD16 XLIB::STATE) ; ((XLIB::MEMBER8 :NORMAL :GRAB :UNGRAB) XLIB::MODE) ; ((BIT 0) XLIB::FOCUS-P) ((BIT 1) XLIB::SAME-SCREEN-P)) ; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN ; --> LOCALLY SB-C::%FUNCALL ; ==> ; #:G1988 ; ; note: could not stack allocate the result of (DECLARE-EVENT ; (:ENTER-NOTIFY :LEAVE-NOTIFY) ; ((DATA ; (MEMBER8 :ANCESTOR :VIRTUAL :INFERIOR ; :NONLINEAR :NONLINEAR-VIRTUAL)) ; KIND) ; (CARD16 SEQUENCE) ; ((OR NULL CARD32) TIME) ; (WINDOW ROOT (WINDOW EVENT-WINDOW)) ; ((OR NULL WINDOW) CHILD) ; (INT16 ROOT-X ROOT-Y X Y) ; (CARD16 STATE) ; ((MEMBER8 :NORMAL :GRAB :UNGRAB) MODE) ; ((BIT 0) FOCUS-P) ; ((BIT 1) SAME-SCREEN-P)) ; compiling (DECLARE-EVENT (:ENTER-NOTIFY :LEAVE-NOTIFY) ...) ; file: /usr/share/common-lisp/source/clx/input.lisp ; in: DECLARE-EVENT (:FOCUS-IN :FOCUS-OUT) ; (XLIB:DECLARE-EVENT (:FOCUS-IN :FOCUS-OUT) ; ((XLIB::DATA ; (XLIB::MEMBER8 :ANCESTOR :VIRTUAL :INFERIOR :NONLINEAR ; :NONLINEAR-VIRTUAL :POINTER :POINTER-ROOT :NONE)) ; XLIB::KIND) ; (XLIB:CARD16 SEQUENCE) ; (XLIB:WINDOW (XLIB:WINDOW XLIB::EVENT-WINDOW)) ; ((XLIB::MEMBER8 :NORMAL :WHILE-GRABBED :GRAB :UNGRAB) ; XLIB::MODE)) ; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN ; --> LOCALLY SB-C::%FUNCALL ; ==> ; #:G2272 ; ; note: could not stack allocate the result of (DECLARE-EVENT (:FOCUS-IN :FOCUS-OUT) ; ((DATA ; (MEMBER8 :ANCESTOR ; :VIRTUAL :INFERIOR ; :NONLINEAR ; :NONLINEAR-VIRTUAL ; :POINTER :POINTER-ROOT ; :NONE)) ; KIND) ; (CARD16 SEQUENCE) ; (WINDOW ; (WINDOW EVENT-WINDOW)) ; ((MEMBER8 :NORMAL ; :WHILE-GRABBED :GRAB ; :UNGRAB) ; MODE)) ; compiling (DECLARE-EVENT (:FOCUS-IN :FOCUS-OUT) ...) ; file: /usr/share/common-lisp/source/clx/input.lisp ; in: DECLARE-EVENT :KEYMAP-NOTIFY ; (XLIB:DECLARE-EVENT :KEYMAP-NOTIFY ((XLIB::BIT-VECTOR256 0) XLIB::KEYMAP)) ; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN ; --> LOCALLY SB-C::%FUNCALL ; ==> ; #:G2510 ; ; note: could not stack allocate the result of (DECLARE-EVENT :KEYMAP-NOTIFY ; ((BIT-VECTOR256 0) ; KEYMAP)) ; compiling (DECLARE-EVENT :KEYMAP-NOTIFY ...) ; file: /usr/share/common-lisp/source/clx/input.lisp ; in: DECLARE-EVENT :EXPOSURE ; (XLIB:DECLARE-EVENT :EXPOSURE (XLIB:CARD16 SEQUENCE) ; (XLIB:WINDOW (XLIB:WINDOW XLIB::EVENT-WINDOW)) ; (XLIB:CARD16 XLIB::X XLIB::Y XLIB::WIDTH XLIB::HEIGHT ; COUNT)) ; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN ; --> LOCALLY SB-C::%FUNCALL ; ==> ; #:G2581 ; ; note: could not stack allocate the result of (DECLARE-EVENT :EXPOSURE ; (CARD16 SEQUENCE) ; (WINDOW ; (WINDOW EVENT-WINDOW)) ; (CARD16 X Y WIDTH HEIGHT ; COUNT)) ; compiling (DECLARE-EVENT :EXPOSURE ...) ; file: /usr/share/common-lisp/source/clx/input.lisp ; in: DECLARE-EVENT :GRAPHICS-EXPOSURE ; (XLIB:DECLARE-EVENT :GRAPHICS-EXPOSURE (XLIB:CARD16 SEQUENCE) ; (XLIB:DRAWABLE (XLIB:DRAWABLE XLIB::EVENT-WINDOW)) ; (XLIB:CARD16 XLIB::X XLIB::Y XLIB::WIDTH XLIB::HEIGHT) ; (XLIB:CARD16 XLIB::MINOR) (XLIB:CARD16 COUNT) ; (XLIB:CARD8 XLIB::MAJOR)) ; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN ; --> LOCALLY SB-C::%FUNCALL ; ==> ; #:G2667 ; ; note: could not stack allocate the result of (DECLARE-EVENT :GRAPHICS-EXPOSURE ; (CARD16 SEQUENCE) ; (DRAWABLE ; (DRAWABLE EVENT-WINDOW)) ; (CARD16 X Y WIDTH HEIGHT) ; (CARD16 MINOR) ; (CARD16 COUNT) ; (CARD8 MAJOR)) ; compiling (DECLARE-EVENT :GRAPHICS-EXPOSURE ...) ; file: /usr/share/common-lisp/source/clx/input.lisp ; in: DECLARE-EVENT :NO-EXPOSURE ; (XLIB:DECLARE-EVENT :NO-EXPOSURE (XLIB:CARD16 SEQUENCE) ; (XLIB:DRAWABLE (XLIB:DRAWABLE XLIB::EVENT-WINDOW)) ; (XLIB:CARD16 XLIB::MINOR) (XLIB:CARD8 XLIB::MAJOR)) ; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN ; --> LOCALLY SB-C::%FUNCALL ; ==> ; #:G2758 ; ; note: could not stack allocate the result of (DECLARE-EVENT :NO-EXPOSURE ; (CARD16 SEQUENCE) ; (DRAWABLE ; (DRAWABLE EVENT-WINDOW)) ; (CARD16 MINOR) ; (CARD8 MAJOR)) ; compiling (DECLARE-EVENT :NO-EXPOSURE ...) ; file: /usr/share/common-lisp/source/clx/input.lisp ; in: DECLARE-EVENT :VISIBILITY-NOTIFY ; (XLIB:DECLARE-EVENT :VISIBILITY-NOTIFY (XLIB:CARD16 SEQUENCE) ; (XLIB:WINDOW (XLIB:WINDOW XLIB::EVENT-WINDOW)) ; ((XLIB::MEMBER8 :UNOBSCURED :PARTIALLY-OBSCURED ; :FULLY-OBSCURED) ; XLIB::STATE)) ; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN ; --> LOCALLY SB-C::%FUNCALL ; ==> ; #:G2840 ; ; note: could not stack allocate the result of (DECLARE-EVENT :VISIBILITY-NOTIFY ; (CARD16 SEQUENCE) ; (WINDOW ; (WINDOW EVENT-WINDOW)) ; ((MEMBER8 :UNOBSCURED ; :PARTIALLY-OBSCURED ; :FULLY-OBSCURED) ; STATE)) ; compiling (DECLARE-EVENT :VISIBILITY-NOTIFY ...) ; file: /usr/share/common-lisp/source/clx/input.lisp ; in: DECLARE-EVENT :CREATE-NOTIFY ; (XLIB:DECLARE-EVENT :CREATE-NOTIFY (XLIB:CARD16 SEQUENCE) ; (XLIB:WINDOW (XLIB::PARENT XLIB::EVENT-WINDOW) ; XLIB:WINDOW) ; (XLIB:INT16 XLIB::X XLIB::Y) ; (XLIB:CARD16 XLIB::WIDTH XLIB::HEIGHT XLIB::BORDER-WIDTH) ; (BOOLEAN XLIB::OVERRIDE-REDIRECT-P)) ; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN ; --> LOCALLY SB-C::%FUNCALL ; ==> ; #:G2985 ; ; note: could not stack allocate the result of (DECLARE-EVENT :CREATE-NOTIFY ; (CARD16 SEQUENCE) ; (WINDOW ; (PARENT EVENT-WINDOW) ; WINDOW) ; (INT16 X Y) ; (CARD16 WIDTH HEIGHT ; BORDER-WIDTH) ; (BOOLEAN ; OVERRIDE-REDIRECT-P)) ; compiling (DECLARE-EVENT :CREATE-NOTIFY ...) ; file: /usr/share/common-lisp/source/clx/input.lisp ; in: DECLARE-EVENT :DESTROY-NOTIFY ; (XLIB:DECLARE-EVENT :DESTROY-NOTIFY (XLIB:CARD16 SEQUENCE) ; (XLIB:WINDOW XLIB::EVENT-WINDOW XLIB:WINDOW)) ; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN ; --> LOCALLY SB-C::%FUNCALL ; ==> ; #:G3074 ; ; note: could not stack allocate the result of (DECLARE-EVENT :DESTROY-NOTIFY ; (CARD16 SEQUENCE) ; (WINDOW EVENT-WINDOW ; WINDOW)) ; compiling (DECLARE-EVENT :DESTROY-NOTIFY ...) ; file: /usr/share/common-lisp/source/clx/input.lisp ; in: DECLARE-EVENT :UNMAP-NOTIFY ; (XLIB:DECLARE-EVENT :UNMAP-NOTIFY (XLIB:CARD16 SEQUENCE) ; (XLIB:WINDOW XLIB::EVENT-WINDOW XLIB:WINDOW) ; (BOOLEAN XLIB::CONFIGURE-P)) ; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN ; --> LOCALLY SB-C::%FUNCALL ; ==> ; #:G3145 ; ; note: could not stack allocate the result of (DECLARE-EVENT :UNMAP-NOTIFY ; (CARD16 SEQUENCE) ; (WINDOW EVENT-WINDOW ; WINDOW) ; (BOOLEAN CONFIGURE-P)) ; compiling (DECLARE-EVENT :UNMAP-NOTIFY ...) ; file: /usr/share/common-lisp/source/clx/input.lisp ; in: DECLARE-EVENT :MAP-NOTIFY ; (XLIB:DECLARE-EVENT :MAP-NOTIFY (XLIB:CARD16 SEQUENCE) ; (XLIB:WINDOW XLIB::EVENT-WINDOW XLIB:WINDOW) ; (BOOLEAN XLIB::OVERRIDE-REDIRECT-P)) ; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN ; --> LOCALLY SB-C::%FUNCALL ; ==> ; #:G3224 ; ; note: could not stack allocate the result of (DECLARE-EVENT :MAP-NOTIFY ; (CARD16 SEQUENCE) ; (WINDOW EVENT-WINDOW ; WINDOW) ; (BOOLEAN ; OVERRIDE-REDIRECT-P)) ; compiling (DECLARE-EVENT :MAP-NOTIFY ...) ; file: /usr/share/common-lisp/source/clx/input.lisp ; in: DECLARE-EVENT :MAP-REQUEST ; (XLIB:DECLARE-EVENT :MAP-REQUEST (XLIB:CARD16 SEQUENCE) ; (XLIB:WINDOW (XLIB::PARENT XLIB::EVENT-WINDOW) ; XLIB:WINDOW)) ; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN ; --> LOCALLY SB-C::%FUNCALL ; ==> ; #:G3303 ; ; note: could not stack allocate the result of (DECLARE-EVENT :MAP-REQUEST ; (CARD16 SEQUENCE) ; (WINDOW ; (PARENT EVENT-WINDOW) ; WINDOW)) ; compiling (DECLARE-EVENT :MAP-REQUEST ...) ; file: /usr/share/common-lisp/source/clx/input.lisp ; in: DECLARE-EVENT :REPARENT-NOTIFY ; (XLIB:DECLARE-EVENT :REPARENT-NOTIFY (XLIB:CARD16 SEQUENCE) ; (XLIB:WINDOW XLIB::EVENT-WINDOW XLIB:WINDOW XLIB::PARENT) ; (XLIB:INT16 XLIB::X XLIB::Y) ; (BOOLEAN XLIB::OVERRIDE-REDIRECT-P)) ; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN ; --> LOCALLY SB-C::%FUNCALL ; ==> ; #:G3378 ; ; note: could not stack allocate the result of (DECLARE-EVENT :REPARENT-NOTIFY ; (CARD16 SEQUENCE) ; (WINDOW EVENT-WINDOW ; WINDOW PARENT) ; (INT16 X Y) ; (BOOLEAN ; OVERRIDE-REDIRECT-P)) ; compiling (DECLARE-EVENT :REPARENT-NOTIFY ...) ; file: /usr/share/common-lisp/source/clx/input.lisp ; in: DECLARE-EVENT :CONFIGURE-NOTIFY ; (XLIB:DECLARE-EVENT :CONFIGURE-NOTIFY (XLIB:CARD16 SEQUENCE) ; (XLIB:WINDOW XLIB::EVENT-WINDOW XLIB:WINDOW) ; ((OR NULL XLIB:WINDOW) XLIB::ABOVE-SIBLING) ; (XLIB:INT16 XLIB::X XLIB::Y) ; (XLIB:CARD16 XLIB::WIDTH XLIB::HEIGHT XLIB::BORDER-WIDTH) ; (BOOLEAN XLIB::OVERRIDE-REDIRECT-P)) ; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN ; --> LOCALLY SB-C::%FUNCALL ; ==> ; #:G3480 ; ; note: could not stack allocate the result of (DECLARE-EVENT :CONFIGURE-NOTIFY ; (CARD16 SEQUENCE) ; (WINDOW EVENT-WINDOW ; WINDOW) ; ((OR NULL WINDOW) ; ABOVE-SIBLING) ; (INT16 X Y) ; (CARD16 WIDTH HEIGHT ; BORDER-WIDTH) ; (BOOLEAN ; OVERRIDE-REDIRECT-P)) ; compiling (DECLARE-EVENT :CONFIGURE-NOTIFY ...) ; file: /usr/share/common-lisp/source/clx/input.lisp ; in: DECLARE-EVENT :CONFIGURE-REQUEST ; (XLIB:DECLARE-EVENT :CONFIGURE-REQUEST ; ((XLIB::DATA ; (XLIB::MEMBER8 :ABOVE :BELOW :TOP-IF :BOTTOM-IF ; :OPPOSITE)) ; XLIB::STACK-MODE) ; (XLIB:CARD16 SEQUENCE) ; (XLIB:WINDOW (XLIB::PARENT XLIB::EVENT-WINDOW) ; XLIB:WINDOW) ; ((OR NULL XLIB:WINDOW) XLIB::ABOVE-SIBLING) ; (XLIB:INT16 XLIB::X XLIB::Y) ; (XLIB:CARD16 XLIB::WIDTH XLIB::HEIGHT XLIB::BORDER-WIDTH ; XLIB::VALUE-MASK)) ; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN ; --> LOCALLY SB-C::%FUNCALL ; ==> ; #:G3593 ; ; note: could not stack allocate the result of (DECLARE-EVENT :CONFIGURE-REQUEST ; ((DATA ; (MEMBER8 :ABOVE :BELOW ; :TOP-IF :BOTTOM-IF ; :OPPOSITE)) ; STACK-MODE) ; (CARD16 SEQUENCE) ; (WINDOW ; (PARENT EVENT-WINDOW) ; WINDOW) ; ((OR NULL WINDOW) ; ABOVE-SIBLING) ; (INT16 X Y) ; (CARD16 WIDTH HEIGHT ; BORDER-WIDTH VALUE-MASK)) ; compiling (DECLARE-EVENT :CONFIGURE-REQUEST ...) ; file: /usr/share/common-lisp/source/clx/input.lisp ; in: DECLARE-EVENT :GRAVITY-NOTIFY ; (XLIB:DECLARE-EVENT :GRAVITY-NOTIFY (XLIB:CARD16 SEQUENCE) ; (XLIB:WINDOW XLIB::EVENT-WINDOW XLIB:WINDOW) ; (XLIB:INT16 XLIB::X XLIB::Y)) ; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN ; --> LOCALLY SB-C::%FUNCALL ; ==> ; #:G3761 ; ; note: could not stack allocate the result of (DECLARE-EVENT :GRAVITY-NOTIFY ; (CARD16 SEQUENCE) ; (WINDOW EVENT-WINDOW ; WINDOW) ; (INT16 X Y)) ; compiling (DECLARE-EVENT :GRAVITY-NOTIFY ...) ; file: /usr/share/common-lisp/source/clx/input.lisp ; in: DECLARE-EVENT :RESIZE-REQUEST ; (XLIB:DECLARE-EVENT :RESIZE-REQUEST (XLIB:CARD16 SEQUENCE) ; (XLIB:WINDOW (XLIB:WINDOW XLIB::EVENT-WINDOW)) ; (XLIB:CARD16 XLIB::WIDTH XLIB::HEIGHT)) ; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN ; --> LOCALLY SB-C::%FUNCALL ; ==> ; #:G3837 ; ; note: could not stack allocate the result of (DECLARE-EVENT :RESIZE-REQUEST ; (CARD16 SEQUENCE) ; (WINDOW ; (WINDOW EVENT-WINDOW)) ; (CARD16 WIDTH HEIGHT)) ; compiling (DECLARE-EVENT :RESIZE-REQUEST ...) ; file: /usr/share/common-lisp/source/clx/input.lisp ; in: DECLARE-EVENT :CIRCULATE-NOTIFY ; (XLIB:DECLARE-EVENT :CIRCULATE-NOTIFY (XLIB:CARD16 SEQUENCE) ; (XLIB:WINDOW XLIB::EVENT-WINDOW XLIB:WINDOW XLIB::PARENT) ; ((XLIB::MEMBER8 :TOP :BOTTOM) XLIB::PLACE)) ; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN ; --> LOCALLY SB-C::%FUNCALL ; ==> ; #:G3914 ; ; note: could not stack allocate the result of (DECLARE-EVENT :CIRCULATE-NOTIFY ; (CARD16 SEQUENCE) ; (WINDOW EVENT-WINDOW ; WINDOW PARENT) ; ((MEMBER8 :TOP :BOTTOM) ; PLACE)) ; compiling (DECLARE-EVENT :CIRCULATE-NOTIFY ...) ; file: /usr/share/common-lisp/source/clx/input.lisp ; in: DECLARE-EVENT :CIRCULATE-REQUEST ; (XLIB:DECLARE-EVENT :CIRCULATE-REQUEST (XLIB:CARD16 SEQUENCE) ; (XLIB:WINDOW (XLIB::PARENT XLIB::EVENT-WINDOW) ; XLIB:WINDOW) ; (XLIB::PAD16 1 2) ; ((XLIB::MEMBER8 :TOP :BOTTOM) XLIB::PLACE)) ; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN ; --> LOCALLY SB-C::%FUNCALL ; ==> ; #:G4059 ; ; note: could not stack allocate the result of (DECLARE-EVENT :CIRCULATE-REQUEST ; (CARD16 SEQUENCE) ; (WINDOW ; (PARENT EVENT-WINDOW) ; WINDOW) ; (PAD16 1 2) ; ((MEMBER8 :TOP :BOTTOM) ; PLACE)) ; compiling (DECLARE-EVENT :CIRCULATE-REQUEST ...) ; file: /usr/share/common-lisp/source/clx/input.lisp ; in: DECLARE-EVENT :PROPERTY-NOTIFY ; (XLIB:DECLARE-EVENT :PROPERTY-NOTIFY (XLIB:CARD16 SEQUENCE) ; (XLIB:WINDOW (XLIB:WINDOW XLIB::EVENT-WINDOW)) ; (KEYWORD ATOM) ((OR NULL XLIB:CARD32) TIME) ; ((XLIB::MEMBER8 :NEW-VALUE :DELETED) XLIB::STATE)) ; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN ; --> LOCALLY SB-C::%FUNCALL ; ==> ; #:G4216 ; ; note: could not stack allocate the result of (DECLARE-EVENT :PROPERTY-NOTIFY ; (CARD16 SEQUENCE) ; (WINDOW ; (WINDOW EVENT-WINDOW)) ; (KEYWORD ATOM) ; ((OR NULL CARD32) TIME) ; ((MEMBER8 :NEW-VALUE ; :DELETED) ; STATE)) ; compiling (DECLARE-EVENT :PROPERTY-NOTIFY ...) ; file: /usr/share/common-lisp/source/clx/input.lisp ; in: DECLARE-EVENT :SELECTION-CLEAR ; (XLIB:DECLARE-EVENT :SELECTION-CLEAR (XLIB:CARD16 SEQUENCE) ; ((OR NULL XLIB:CARD32) TIME) ; (XLIB:WINDOW (XLIB:WINDOW XLIB::EVENT-WINDOW)) ; (KEYWORD XLIB::SELECTION)) ; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN ; --> LOCALLY SB-C::%FUNCALL ; ==> ; #:G4374 ; ; note: could not stack allocate the result of (DECLARE-EVENT :SELECTION-CLEAR ; (CARD16 SEQUENCE) ; ((OR NULL CARD32) TIME) ; (WINDOW ; (WINDOW EVENT-WINDOW)) ; (KEYWORD SELECTION)) ; compiling (DECLARE-EVENT :SELECTION-CLEAR ...) ; file: /usr/share/common-lisp/source/clx/input.lisp ; in: DECLARE-EVENT :SELECTION-REQUEST ; (XLIB:DECLARE-EVENT :SELECTION-REQUEST (XLIB:CARD16 SEQUENCE) ; ((OR NULL XLIB:CARD32) TIME) ; (XLIB:WINDOW (XLIB:WINDOW XLIB::EVENT-WINDOW) ; XLIB::REQUESTOR) ; (KEYWORD XLIB::SELECTION XLIB::TARGET) ; ((OR NULL KEYWORD) XLIB::PROPERTY)) ; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN ; --> LOCALLY SB-C::%FUNCALL ; ==> ; #:G4477 ; ; note: could not stack allocate the result of (DECLARE-EVENT :SELECTION-REQUEST ; (CARD16 SEQUENCE) ; ((OR NULL CARD32) TIME) ; (WINDOW ; (WINDOW EVENT-WINDOW) ; REQUESTOR) ; (KEYWORD SELECTION ; TARGET) ; ((OR NULL KEYWORD) ; PROPERTY)) ; compiling (DECLARE-EVENT :SELECTION-REQUEST ...) ; file: /usr/share/common-lisp/source/clx/input.lisp ; in: DECLARE-EVENT :SELECTION-NOTIFY ; (XLIB:DECLARE-EVENT :SELECTION-NOTIFY (XLIB:CARD16 SEQUENCE) ; ((OR NULL XLIB:CARD32) TIME) ; (XLIB:WINDOW (XLIB:WINDOW XLIB::EVENT-WINDOW)) ; (KEYWORD XLIB::SELECTION XLIB::TARGET) ; ((OR NULL KEYWORD) XLIB::PROPERTY)) ; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN ; --> LOCALLY SB-C::%FUNCALL ; ==> ; #:G4588 ; ; note: could not stack allocate the result of (DECLARE-EVENT :SELECTION-NOTIFY ; (CARD16 SEQUENCE) ; ((OR NULL CARD32) TIME) ; (WINDOW ; (WINDOW EVENT-WINDOW)) ; (KEYWORD SELECTION ; TARGET) ; ((OR NULL KEYWORD) ; PROPERTY)) ; compiling (DECLARE-EVENT :SELECTION-NOTIFY ...) ; file: /usr/share/common-lisp/source/clx/input.lisp ; in: DECLARE-EVENT :COLORMAP-NOTIFY ; (XLIB:DECLARE-EVENT :COLORMAP-NOTIFY (XLIB:CARD16 SEQUENCE) ; (XLIB:WINDOW (XLIB:WINDOW XLIB::EVENT-WINDOW)) ; ((OR NULL XLIB:COLORMAP) XLIB:COLORMAP) ; (BOOLEAN XLIB::NEW-P XLIB::INSTALLED-P)) ; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN ; --> LOCALLY SB-C::%FUNCALL ; ==> ; #:G4684 ; ; note: could not stack allocate the result of (DECLARE-EVENT :COLORMAP-NOTIFY ; (CARD16 SEQUENCE) ; (WINDOW ; (WINDOW EVENT-WINDOW)) ; ((OR NULL COLORMAP) ; COLORMAP) ; (BOOLEAN NEW-P ; INSTALLED-P)) ; compiling (DECLARE-EVENT :COLORMAP-NOTIFY ...) ; file: /usr/share/common-lisp/source/clx/input.lisp ; in: DECLARE-EVENT :CLIENT-MESSAGE ; (XLIB:DECLARE-EVENT :CLIENT-MESSAGE (XLIB::DATA FORMAT) ; (XLIB:CARD16 SEQUENCE) ; (XLIB:WINDOW (XLIB:WINDOW XLIB::EVENT-WINDOW)) ; (KEYWORD TYPE) ; ((XLIB::CLIENT-MESSAGE-SEQUENCE FORMAT) XLIB::DATA)) ; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN BLOCK ; --> XLIB::READING-EVENT XLIB::WITH-BUFFER-INPUT LET LET* FUNCALL ; --> SB-C::%FUNCALL XLIB::CLIENT-MESSAGE-SEQUENCE-GET ; --> XLIB::CLIENT-MESSAGE-EVENT-GET-SEQUENCE LET* DO BLOCK LET TAGBODY TAGBODY ; --> CASE LET COND IF PROGN SETF SB-KERNEL:%ASET ; ==> ; (SB-KERNEL:HAIRY-DATA-VECTOR-SET ARRAY SB-INT:INDEX SB-C::NEW-VALUE) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (SIMPLE-ARRAY * (*)), not a SIMPLE-STRING. ; ; note: unable to ; avoid runtime dispatch on array element type ; because: ; Upgraded element type of array is not known at compile time. ; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN BLOCK ; --> XLIB::READING-EVENT XLIB::WITH-BUFFER-INPUT LET LET* FUNCALL ; --> SB-C::%FUNCALL XLIB::CLIENT-MESSAGE-SEQUENCE-GET ; --> XLIB::CLIENT-MESSAGE-EVENT-GET-SEQUENCE LET* DO BLOCK LET TAGBODY TAGBODY ; --> CASE LET COND IF COND IF PROGN SETF SB-KERNEL:%ASET ; ==> ; (SB-KERNEL:HAIRY-DATA-VECTOR-SET ARRAY SB-INT:INDEX SB-C::NEW-VALUE) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (SIMPLE-ARRAY * (*)), not a SIMPLE-STRING. ; ; note: unable to ; avoid runtime dispatch on array element type ; because: ; Upgraded element type of array is not known at compile time. ; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN BLOCK ; --> XLIB::READING-EVENT XLIB::WITH-BUFFER-INPUT LET LET* FUNCALL ; --> SB-C::%FUNCALL XLIB::CLIENT-MESSAGE-SEQUENCE-GET ; --> XLIB::CLIENT-MESSAGE-EVENT-GET-SEQUENCE LET* DO BLOCK LET TAGBODY TAGBODY ; --> CASE LET COND IF COND IF COND IF PROGN SETF SB-KERNEL:%ASET ; ==> ; (SB-KERNEL:HAIRY-DATA-VECTOR-SET ARRAY SB-INT:INDEX SB-C::NEW-VALUE) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (SIMPLE-ARRAY * (*)), not a SIMPLE-STRING. ; ; note: unable to ; avoid runtime dispatch on array element type ; because: ; Upgraded element type of array is not known at compile time. ; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN ; --> LOCALLY SB-C::%FUNCALL ; ==> ; #:G4804 ; ; note: could not stack allocate the result of (DECLARE-EVENT :CLIENT-MESSAGE ; (DATA FORMAT) ; (CARD16 SEQUENCE) ; (WINDOW ; (WINDOW EVENT-WINDOW)) ; (KEYWORD TYPE) ; ((CLIENT-MESSAGE-SEQUENCE ; FORMAT) ; DATA)) ; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN BLOCK ; --> XLIB::WITH-BUFFER-OUTPUT LET LET* XLIB::CLIENT-MESSAGE-SEQUENCE-PUT ; --> XLIB::CLIENT-MESSAGE-EVENT-PUT-SEQUENCE ECASE LET COND IF PROGN ; --> XLIB::SEQUENCE-PUT XLIB::WRITE-SEQUENCE-CARD8 MIN LET ; ==> ; (LENGTH XLIB::DATA) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)). ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a SEQUENCE, not a VECTOR. ; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN BLOCK ; --> XLIB::WITH-BUFFER-OUTPUT LET LET* XLIB::CLIENT-MESSAGE-SEQUENCE-PUT ; --> XLIB::CLIENT-MESSAGE-EVENT-PUT-SEQUENCE ECASE LET COND IF COND IF PROGN ; --> XLIB::SEQUENCE-PUT XLIB::WRITE-SEQUENCE-CARD16 MIN LET ; ==> ; (LENGTH XLIB::DATA) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)). ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a SEQUENCE, not a VECTOR. ; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN BLOCK ; --> XLIB::WITH-BUFFER-OUTPUT LET LET* XLIB::CLIENT-MESSAGE-SEQUENCE-PUT ; --> XLIB::CLIENT-MESSAGE-EVENT-PUT-SEQUENCE ECASE LET COND IF COND IF COND IF ; --> PROGN XLIB::SEQUENCE-PUT XLIB::WRITE-SEQUENCE-CARD32 MIN LET ; ==> ; (LENGTH XLIB::DATA) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)). ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a SEQUENCE, not a VECTOR. ; compiling (DECLARE-EVENT :CLIENT-MESSAGE ...) ; file: /usr/share/common-lisp/source/clx/input.lisp ; in: DECLARE-EVENT :MAPPING-NOTIFY ; (XLIB:DECLARE-EVENT :MAPPING-NOTIFY (XLIB:CARD16 SEQUENCE) ; ((XLIB::MEMBER8 :MODIFIER :KEYBOARD :POINTER) ; XLIB::REQUEST) ; (XLIB:CARD8 XLIB::START) (XLIB:CARD8 COUNT)) ; --> XLIB::WITHIN-DEFINITION PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN ; --> LOCALLY SB-C::%FUNCALL ; ==> ; #:G4901 ; ; note: could not stack allocate the result of (DECLARE-EVENT :MAPPING-NOTIFY ; (CARD16 SEQUENCE) ; ((MEMBER8 :MODIFIER ; :KEYBOARD :POINTER) ; REQUEST) ; (CARD8 START) ; (CARD8 COUNT)) ; compiling (DECLARE-EVENT :MAPPING-NOTIFY ...) ; compiling (DEFUN EVENT-LOOP-SETUP ...) ; compiling (DEFUN EVENT-LOOP-STEP-BEFORE ...) ; compiling (DEFUN DEQUEUE-EVENT ...) ; compiling (DEFUN EVENT-LOOP-STEP-AFTER ...) ; compiling (DEFMACRO EVENT-LOOP ...) ; compiling (DEFUN DISCARD-CURRENT-EVENT ...) ; file: /usr/share/common-lisp/source/clx/input.lisp ; in: DEFUN PROCESS-EVENT ; (DEFUN XLIB:PROCESS-EVENT ; (XLIB:DISPLAY ; &KEY XLIB::HANDLER XLIB::TIMEOUT XLIB::PEEK-P XLIB::DISCARD-P ; (XLIB::FORCE-OUTPUT-P T)) ; (DECLARE (TYPE XLIB:DISPLAY XLIB:DISPLAY) ; (TYPE (OR NULL NUMBER) XLIB::TIMEOUT) ; (TYPE XLIB:GENERALIZED-BOOLEAN XLIB::PEEK-P XLIB::DISCARD-P ; XLIB::FORCE-OUTPUT-P)) ; (DECLARE (TYPE T XLIB::HANDLER) (DYNAMIC-EXTENT XLIB::HANDLER)) ; (XLIB::EVENT-LOOP ; (XLIB:DISPLAY XLIB::EVENT XLIB::TIMEOUT XLIB::FORCE-OUTPUT-P ; XLIB::DISCARD-P) ; (LET* ((XLIB::EVENT-CODE #) (XLIB::EVENT-DECODER #)) ; (DECLARE (TYPE XLIB:ARRAY-INDEX XLIB::EVENT-CODE) ; (TYPE # XLIB::EVENT-DECODER)) ; (IF XLIB::EVENT-DECODER ; (LET # ; #) ; (CERROR "Ignore this event" ; "Server Error: event with unknown event code ~d received." ; XLIB::EVENT-CODE))))) ; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN LET SB-C::%FUNCALL ; ==> ; #:N-VALUE-5248 ; ; note: could not stack allocate the result of (DEFUN PROCESS-EVENT ; (DISPLAY ; &KEY HANDLER TIMEOUT PEEK-P ; DISCARD-P (FORCE-OUTPUT-P T)) ; (DECLARE (TYPE DISPLAY DISPLAY) ; (TYPE (OR NULL NUMBER) TIMEOUT) ; (TYPE GENERALIZED-BOOLEAN PEEK-P ; DISCARD-P FORCE-OUTPUT-P)) ; (DECLARE (TYPE T HANDLER) ; (DYNAMIC-EXTENT HANDLER)) ; (EVENT-LOOP ; (DISPLAY EVENT TIMEOUT FORCE-OUTPUT-P ; DISCARD-P) ; (LET* ((EVENT-CODE ; (EVENT-CODE EVENT)) ; (EVENT-DECODER (AND # #))) ; (DECLARE ; (TYPE ARRAY-INDEX EVENT-CODE) ; (TYPE (OR NULL FUNCTION) ; EVENT-DECODER)) ; (IF EVENT-DECODER ; (LET (#) ; (IF EVENT-HANDLER # #)) ; (CERROR "Ignore this event" ; "Server Error: event with unknown event code ~d received." ; EVENT-CODE))))) ; compiling (DEFUN PROCESS-EVENT ...) ; compiling (DEFUN MAKE-EVENT-HANDLERS ...) ; compiling (DEFUN EVENT-HANDLER ...) ; compiling (DEFUN SET-EVENT-HANDLER ...) ; compiling (DEFSETF EVENT-HANDLER ...) ; compiling (DEFMACRO EVENT-CASE ...) ; compiling (DEFMACRO EVENT-COND ...) ; compiling (DEFUN GET-EVENT-CODE ...) ; compiling (DEFUN UNIVERSAL-EVENT-GET-MACRO ...) ; compiling (DEFMACRO EVENT-DISPATCH ...) ; compiling (DEFMACRO BINDING-EVENT-VALUES ...) ; compiling (DEFPARAMETER *XERROR-VECTOR* ...) ; file: /usr/share/common-lisp/source/clx/input.lisp ; in: DEFUN MAKE-ERROR ; (FUNCALL XLIB::ERROR-DECODE-FUNCTION XLIB:DISPLAY XLIB::EVENT) ; --> SB-C::%FUNCALL THE ; ==> ; (SB-KERNEL:%COERCE-CALLABLE-TO-FUN XLIB::ERROR-DECODE-FUNCTION) ; ; note: unable to ; optimize ; because: ; optimize away possible call to FDEFINITION at runtime ; compiling (DEFUN MAKE-ERROR ...) ; compiling (DEFUN REPORT-ERROR ...) ; compiling (DEFUN REQUEST-NAME ...) ; compiling (DEFUN REPORT-REQUEST-ERROR ...) ; compiling (DEFINE-CONDITION REQUEST-ERROR ...) ; compiling (DEFINE-CONDITION RESOURCE-ERROR ...) ; compiling (DEFINE-CONDITION UNKNOWN-ERROR ...) ; compiling (DEFINE-CONDITION ACCESS-ERROR ...) ; compiling (DEFINE-CONDITION ALLOC-ERROR ...) ; compiling (DEFINE-CONDITION ATOM-ERROR ...) ; compiling (DEFINE-CONDITION COLORMAP-ERROR ...) ; compiling (DEFINE-CONDITION CURSOR-ERROR ...) ; compiling (DEFINE-CONDITION DRAWABLE-ERROR ...) ; compiling (DEFINE-CONDITION FONT-ERROR ...) ; compiling (DEFINE-CONDITION GCONTEXT-ERROR ...) ; compiling (DEFINE-CONDITION ID-CHOICE-ERROR ...) ; compiling (DEFINE-CONDITION ILLEGAL-REQUEST-ERROR ...) ; compiling (DEFINE-CONDITION LENGTH-ERROR ...) ; compiling (DEFINE-CONDITION MATCH-ERROR ...) ; compiling (DEFINE-CONDITION NAME-ERROR ...) ; compiling (DEFINE-CONDITION PIXMAP-ERROR ...) ; compiling (DEFINE-CONDITION VALUE-ERROR ...) ; compiling (DEFINE-CONDITION WINDOW-ERROR ...) ; compiling (DEFINE-CONDITION IMPLEMENTATION-ERROR ...) ; compiling (DEFINE-CONDITION X-TYPE-ERROR ...) ; compiling (DEFINE-CONDITION CLOSED-DISPLAY ...) ; compiling (DEFINE-CONDITION LOOKUP-ERROR ...) ; compiling (DEFINE-CONDITION CONNECTION-FAILURE ...) ; compiling (DEFINE-CONDITION REPLY-LENGTH-ERROR ...) ; compiling (DEFINE-CONDITION REPLY-TIMEOUT ...) ; compiling (DEFINE-CONDITION SEQUENCE-ERROR ...) ; compiling (DEFINE-CONDITION UNEXPECTED-REPLY ...) ; compiling (DEFINE-CONDITION MISSING-PARAMETER ...) ; compiling (DEFINE-CONDITION INVALID-FONT ...) ; compiling (DEFINE-CONDITION DEVICE-BUSY ...) ; compiling (DEFINE-CONDITION UNIMPLEMENTED-EVENT ...) ; compiling (DEFINE-CONDITION UNDEFINED-EVENT ...) ; compiling (DEFINE-CONDITION ABSENT-EXTENSION ...) ; compiling (DEFINE-CONDITION INCONSISTENT-PARAMETERS ...) ; compiling (DEFUN GET-ERROR-KEY ...) ; compiling (DEFMACRO DEFINE-ERROR ...) ; compiling (DEFUN DECODE-CORE-ERROR ...) ; compiling (DEFUN DECODE-RESOURCE-ERROR ...) ; compiling (DEFINE-ERROR UNKNOWN-ERROR ...) ; compiling (DEFINE-ERROR REQUEST-ERROR ...) ; compiling (DEFINE-ERROR VALUE-ERROR ...) ; compiling (DEFINE-ERROR WINDOW-ERROR ...) ; compiling (DEFINE-ERROR PIXMAP-ERROR ...) ; compiling (DEFINE-ERROR ATOM-ERROR ...) ; compiling (DEFINE-ERROR CURSOR-ERROR ...) ; compiling (DEFINE-ERROR FONT-ERROR ...) ; compiling (DEFINE-ERROR MATCH-ERROR ...) ; compiling (DEFINE-ERROR DRAWABLE-ERROR ...) ; compiling (DEFINE-ERROR ACCESS-ERROR ...) ; compiling (DEFINE-ERROR ALLOC-ERROR ...) ; compiling (DEFINE-ERROR COLORMAP-ERROR ...) ; compiling (DEFINE-ERROR GCONTEXT-ERROR ...) ; compiling (DEFINE-ERROR ID-CHOICE-ERROR ...) ; compiling (DEFINE-ERROR NAME-ERROR ...) ; compiling (DEFINE-ERROR LENGTH-ERROR ...) ; compiling (DEFINE-ERROR IMPLEMENTATION-ERROR ...) ; /var/cache/common-lisp-controller/1001/sbcl/clx/input.fasl written ; compilation finished in 0:00:03.179 ; compiling file "/usr/share/common-lisp/source/clx/requests.lisp" (written 14 JUL 2005 03:24:44 PM): ; compiling (IN-PACKAGE :XLIB) ; file: /usr/share/common-lisp/source/clx/requests.lisp ; in: DEFUN CREATE-WINDOW ; (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 64) arithmetic (cost 2) because: ; The first argument is a INTEGER, not a (UNSIGNED-BYTE 64). ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE 64) ; &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 64) arithmetic (cost 2) because: ; The first argument is a INTEGER, not a (UNSIGNED-BYTE 64). ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE 64) ; &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 64) arithmetic (cost 2) because: ; The first argument is a INTEGER, not a (UNSIGNED-BYTE 64). ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE 64) ; &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 64) arithmetic (cost 2) because: ; The first argument is a INTEGER, not a (UNSIGNED-BYTE 64). ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE 64) ; &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 64) arithmetic (cost 2) because: ; The first argument is a INTEGER, not a (UNSIGNED-BYTE 64). ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE 64) ; &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 64) arithmetic (cost 2) because: ; The first argument is a INTEGER, not a (UNSIGNED-BYTE 64). ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE 64) ; &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 64) arithmetic (cost 2) because: ; The first argument is a INTEGER, not a (UNSIGNED-BYTE 64). ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE 64) ; &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 64) arithmetic (cost 2) because: ; The first argument is a INTEGER, not a (UNSIGNED-BYTE 64). ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE 64) ; &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 64) arithmetic (cost 2) because: ; The first argument is a INTEGER, not a (UNSIGNED-BYTE 64). ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE 64) ; &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 64) arithmetic (cost 2) because: ; The first argument is a INTEGER, not a (UNSIGNED-BYTE 64). ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE 64) ; &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 64) arithmetic (cost 2) because: ; The first argument is a INTEGER, not a (UNSIGNED-BYTE 64). ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE 64) ; &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 64) arithmetic (cost 2) because: ; The first argument is a INTEGER, not a (UNSIGNED-BYTE 64). ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE 64) ; &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 64) arithmetic (cost 2) because: ; The first argument is a INTEGER, not a (UNSIGNED-BYTE 64). ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE 64) ; &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 64) arithmetic (cost 2) because: ; The first argument is a INTEGER, not a (UNSIGNED-BYTE 64). ; The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES ; (UNSIGNED-BYTE 64) ; &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 64) arithmetic (cost 5) because: ; The first argument is a NUMBER, not a (SIGNED-BYTE 64). ; The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) ; &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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 CREATE-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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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-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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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-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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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-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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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-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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 ...) ; compiling (DEFUN LOOKUP-XATOM ...) ; 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 CHANGE-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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 ...) ; compiling (DEFSETF SELECTION-OWNER ...) ; 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 CONVERT-SELECTION ...) ; 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 GRAB-POINTER ; (XLIB::WITH-BUFFER-REQUEST-AND-REPLY ; (XLIB:DISPLAY XLIB::+X-GRABPOINTER+ NIL :SIZES 8) ; (((XLIB::DATA BOOLEAN) XLIB::OWNER-P) (XLIB:WINDOW XLIB:WINDOW) ; (XLIB:CARD16 (XLIB::ENCODE-POINTER-EVENT-MASK XLIB:EVENT-MASK)) ; (BOOLEAN (NOT XLIB::SYNC-POINTER-P) (NOT XLIB::SYNC-KEYBOARD-P)) ; ((OR NULL XLIB:WINDOW) XLIB::CONFINE-TO) ; ((OR NULL XLIB:CURSOR) XLIB:CURSOR) ((OR NULL XLIB:CARD32) TIME)) ; (VALUES ; (XLIB::MEMBER8-GET 1 :SUCCESS :ALREADY-GRABBED :INVALID-TIME :NOT-VIEWABLE ; :FROZEN))) ; --> 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 GRAB-POINTER ...) ; file: /usr/share/common-lisp/source/clx/requests.lisp ; in: DEFUN UNGRAB-POINTER ; (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-UNGRABPOINTER+) ; ((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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 UNGRAB-POINTER ...) ; file: /usr/share/common-lisp/source/clx/requests.lisp ; in: DEFUN GRAB-BUTTON ; (XLIB::WITH-BUFFER-REQUEST ; ((XLIB:WINDOW-DISPLAY XLIB:WINDOW) XLIB::+X-GRABBUTTON+) ; ((XLIB::DATA BOOLEAN) XLIB::OWNER-P) (XLIB:WINDOW XLIB:WINDOW) ; (XLIB:CARD16 (XLIB::ENCODE-POINTER-EVENT-MASK XLIB:EVENT-MASK)) ; (BOOLEAN (NOT XLIB::SYNC-POINTER-P) (NOT XLIB::SYNC-KEYBOARD-P)) ; ((OR NULL XLIB:WINDOW) XLIB::CONFINE-TO) ((OR NULL XLIB:CURSOR) XLIB:CURSOR) ; (XLIB:CARD8 (IF (EQ XLIB::BUTTON :ANY) 0 XLIB::BUTTON)) (XLIB::PAD8 1) ; (XLIB:CARD16 (XLIB::ENCODE-MODIFIER-MASK XLIB::MODIFIERS))) ; --> 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 GRAB-BUTTON ...) ; file: /usr/share/common-lisp/source/clx/requests.lisp ; in: DEFUN UNGRAB-BUTTON ; (XLIB::WITH-BUFFER-REQUEST ; ((XLIB:WINDOW-DISPLAY XLIB:WINDOW) XLIB::+X-UNGRABBUTTON+) ; (XLIB::DATA (IF (EQ XLIB::BUTTON :ANY) 0 XLIB::BUTTON)) ; (XLIB:WINDOW XLIB:WINDOW) ; (XLIB:CARD16 (XLIB::ENCODE-MODIFIER-MASK XLIB::MODIFIERS))) ; --> 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 UNGRAB-BUTTON ...) ; file: /usr/share/common-lisp/source/clx/requests.lisp ; in: DEFUN CHANGE-ACTIVE-POINTER-GRAB ; (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-CHANGEACTIVEPOINTERGRAB+) ; ((OR NULL XLIB:CURSOR) XLIB:CURSOR) ; ((OR NULL XLIB:CARD32) TIME) ; (XLIB:CARD16 ; (XLIB::ENCODE-POINTER-EVENT-MASK ; XLIB:EVENT-MASK))) ; --> 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 CHANGE-ACTIVE-POINTER-GRAB ...) ; file: /usr/share/common-lisp/source/clx/requests.lisp ; in: DEFUN GRAB-KEYBOARD ; (XLIB::WITH-BUFFER-REQUEST-AND-REPLY ; (XLIB:DISPLAY XLIB::+X-GRABKEYBOARD+ NIL :SIZES 8) ; (((XLIB::DATA BOOLEAN) XLIB::OWNER-P) (XLIB:WINDOW XLIB:WINDOW) ; ((OR NULL XLIB:CARD32) TIME) ; (BOOLEAN (NOT XLIB::SYNC-POINTER-P) (NOT XLIB::SYNC-KEYBOARD-P))) ; (VALUES ; (XLIB::MEMBER8-GET 1 :SUCCESS :ALREADY-GRABBED :INVALID-TIME :NOT-VIEWABLE ; :FROZEN))) ; --> 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 GRAB-KEYBOARD ...) ; file: /usr/share/common-lisp/source/clx/requests.lisp ; in: DEFUN UNGRAB-KEYBOARD ; (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-UNGRABKEYBOARD+) ; ((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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 UNGRAB-KEYBOARD ...) ; file: /usr/share/common-lisp/source/clx/requests.lisp ; in: DEFUN GRAB-KEY ; (XLIB::WITH-BUFFER-REQUEST ; ((XLIB:WINDOW-DISPLAY XLIB:WINDOW) XLIB::+X-GRABKEY+) ; ((XLIB::DATA BOOLEAN) XLIB::OWNER-P) (XLIB:WINDOW XLIB:WINDOW) ; (XLIB:CARD16 (XLIB::ENCODE-MODIFIER-MASK XLIB::MODIFIERS)) ; (XLIB:CARD8 (IF (EQ XLIB::KEY :ANY) 0 XLIB::KEY)) ; (BOOLEAN (NOT XLIB::SYNC-POINTER-P) (NOT XLIB::SYNC-KEYBOARD-P))) ; --> 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 GRAB-KEY ...) ; file: /usr/share/common-lisp/source/clx/requests.lisp ; in: DEFUN UNGRAB-KEY ; (XLIB::WITH-BUFFER-REQUEST ; ((XLIB:WINDOW-DISPLAY XLIB:WINDOW) XLIB::+X-UNGRABKEY+) ; (XLIB::DATA (IF (EQ XLIB::KEY :ANY) 0 XLIB::KEY)) (XLIB:WINDOW XLIB:WINDOW) ; (XLIB:CARD16 (XLIB::ENCODE-MODIFIER-MASK XLIB::MODIFIERS))) ; --> 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 UNGRAB-KEY ...) ; file: /usr/share/common-lisp/source/clx/requests.lisp ; in: DEFUN ALLOW-EVENTS ; (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-ALLOWEVENTS+) ; ((XLIB::DATA ; (MEMBER :ASYNC-POINTER :SYNC-POINTER ; :REPLAY-POINTER :ASYNC-KEYBOARD ; :SYNC-KEYBOARD :REPLAY-KEYBOARD ; :ASYNC-BOTH :SYNC-BOTH)) ; XLIB::MODE) ; ((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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 ALLOW-EVENTS ...) ; file: /usr/share/common-lisp/source/clx/requests.lisp ; in: DEFUN GRAB-SERVER ; (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-GRABSERVER+)) ; --> 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 GRAB-SERVER ...) ; file: /usr/share/common-lisp/source/clx/requests.lisp ; in: DEFUN UNGRAB-SERVER ; (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-UNGRABSERVER+)) ; --> 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 UNGRAB-SERVER ...) ; compiling (DEFMACRO WITH-SERVER-GRABBED ...) ; file: /usr/share/common-lisp/source/clx/requests.lisp ; in: DEFUN QUERY-POINTER ; (XLIB::WITH-BUFFER-REQUEST-AND-REPLY ; (XLIB:DISPLAY XLIB::+X-QUERYPOINTER+ 26 :SIZES (8 16 32)) ; ((XLIB:WINDOW XLIB:WINDOW)) ; (VALUES (XLIB::INT16-GET 20) (XLIB::INT16-GET 22) (XLIB::BOOLEAN-GET 1) ; (XLIB::OR-GET 12 NULL XLIB:WINDOW) (XLIB::CARD16-GET 24) ; (XLIB::INT16-GET 16) (XLIB::INT16-GET 18) (XLIB::WINDOW-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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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-POINTER ...) ; file: /usr/share/common-lisp/source/clx/requests.lisp ; in: DEFUN POINTER-POSITION ; (XLIB::WITH-BUFFER-REQUEST-AND-REPLY ; (XLIB:DISPLAY XLIB::+X-QUERYPOINTER+ 24 :SIZES (8 16)) ; ((XLIB:WINDOW XLIB:WINDOW)) ; (VALUES (XLIB::INT16-GET 20) (XLIB::INT16-GET 22) (XLIB::BOOLEAN-GET 1))) ; --> 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 POINTER-POSITION ...) ; file: /usr/share/common-lisp/source/clx/requests.lisp ; in: DEFUN GLOBAL-POINTER-POSITION ; (XLIB::WITH-BUFFER-REQUEST-AND-REPLY ; (XLIB:DISPLAY XLIB::+X-QUERYPOINTER+ 20 :SIZES (16 32)) ; ((XLIB:WINDOW (XLIB:SCREEN-ROOT (FIRST #)))) ; (VALUES (XLIB::INT16-GET 16) (XLIB::INT16-GET 18) (XLIB::WINDOW-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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 GLOBAL-POINTER-POSITION ...) ; file: /usr/share/common-lisp/source/clx/requests.lisp ; in: DEFUN MOTION-EVENTS ; (XLIB::WITH-BUFFER-REQUEST-AND-REPLY ; (XLIB:DISPLAY XLIB::+X-GETMOTIONEVENTS+ NIL :SIZES 32) ; ((XLIB:WINDOW XLIB:WINDOW) ((OR NULL XLIB:CARD32) XLIB::START XLIB::STOP)) ; (VALUES ; (XLIB::SEQUENCE-GET :RESULT-TYPE XLIB::RESULT-TYPE :LENGTH ; (XLIB::INDEX* (XLIB::CARD32-GET 8) 3) :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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 MOTION-EVENTS ...) ; file: /usr/share/common-lisp/source/clx/requests.lisp ; in: DEFUN TRANSLATE-COORDINATES ; (XLIB::WITH-BUFFER-REQUEST-AND-REPLY ; (XLIB:DISPLAY XLIB::+X-TRANSLATECOORDS+ 16 :SIZES (8 16 32)) ; ((XLIB:WINDOW XLIB::SRC XLIB::DST) (XLIB:INT16 XLIB::SRC-X XLIB::SRC-Y)) ; (AND (XLIB::BOOLEAN-GET 1) ; (VALUES (XLIB::INT16-GET 12) (XLIB::INT16-GET 14) ; (XLIB::OR-GET 8 NULL XLIB:WINDOW)))) ; --> 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 TRANSLATE-COORDINATES ...) ; file: /usr/share/common-lisp/source/clx/requests.lisp ; in: DEFUN WARP-POINTER ; (XLIB::WITH-BUFFER-REQUEST ; ((XLIB:WINDOW-DISPLAY XLIB::DST) XLIB::+X-WARPPOINTER+) (XLIB:RESOURCE-ID 0) ; (XLIB:WINDOW XLIB::DST) (XLIB:INT16 0 0) (XLIB:CARD16 0 0) ; (XLIB:INT16 XLIB::DST-X XLIB::DST-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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 WARP-POINTER ...) ; file: /usr/share/common-lisp/source/clx/requests.lisp ; in: DEFUN WARP-POINTER-RELATIVE ; (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-WARPPOINTER+) ; (XLIB:RESOURCE-ID 0) (XLIB:RESOURCE-ID 0) ; (XLIB:INT16 0 0) (XLIB:CARD16 0 0) ; (XLIB:INT16 XLIB::X-OFF XLIB::Y-OFF)) ; --> 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 WARP-POINTER-RELATIVE ...) ; file: /usr/share/common-lisp/source/clx/requests.lisp ; in: DEFUN WARP-POINTER-IF-INSIDE ; (XLIB::WITH-BUFFER-REQUEST ; ((XLIB:WINDOW-DISPLAY XLIB::DST) XLIB::+X-WARPPOINTER+) ; (XLIB:WINDOW XLIB::SRC XLIB::DST) (XLIB:INT16 XLIB::SRC-X XLIB::SRC-Y) ; (XLIB:CARD16 (OR XLIB::SRC-WIDTH 0) (OR XLIB::SRC-HEIGHT 0)) ; (XLIB:INT16 XLIB::DST-X XLIB::DST-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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 WARP-POINTER-IF-INSIDE ...) ; file: /usr/share/common-lisp/source/clx/requests.lisp ; in: DEFUN WARP-POINTER-RELATIVE-IF-INSIDE ; (XLIB::WITH-BUFFER-REQUEST ; ((XLIB:WINDOW-DISPLAY XLIB::SRC) XLIB::+X-WARPPOINTER+) ; (XLIB:WINDOW XLIB::SRC) (XLIB:RESOURCE-ID 0) ; (XLIB:INT16 XLIB::SRC-X XLIB::SRC-Y) ; (XLIB:CARD16 (OR XLIB::SRC-WIDTH 0) (OR XLIB::SRC-HEIGHT 0)) ; (XLIB:INT16 XLIB::X-OFF XLIB::Y-OFF)) ; --> 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 WARP-POINTER-RELATIVE-IF-INSIDE ...) ; file: /usr/share/common-lisp/source/clx/requests.lisp ; in: DEFUN SET-INPUT-FOCUS ; (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-SETINPUTFOCUS+) ; ((XLIB::DATA (MEMBER :NONE :POINTER-ROOT :PARENT)) ; XLIB::REVERT-TO) ; ((OR XLIB:WINDOW (MEMBER :NONE :POINTER-ROOT)) ; XLIB::FOCUS) ; ((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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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-INPUT-FOCUS ...) ; file: /usr/share/common-lisp/source/clx/requests.lisp ; in: DEFUN INPUT-FOCUS ; (XLIB::WITH-BUFFER-REQUEST-AND-REPLY ; (XLIB:DISPLAY XLIB::+X-GETINPUTFOCUS+ 16 :SIZES (8 32)) NIL ; (VALUES (XLIB::OR-GET 8 XLIB:WINDOW (MEMBER :NONE :POINTER-ROOT)) ; (XLIB::MEMBER8-GET 1 :NONE :POINTER-ROOT :PARENT))) ; --> 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 INPUT-FOCUS ...) ; file: /usr/share/common-lisp/source/clx/requests.lisp ; in: DEFUN QUERY-KEYMAP ; (XLIB::WITH-BUFFER-REQUEST-AND-REPLY ; (XLIB:DISPLAY XLIB::+X-QUERYKEYMAP+ 40 :SIZES 8) NIL ; (VALUES (XLIB::BIT-VECTOR256-GET 8 8 BIT-VECTOR))) ; --> 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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-KEYMAP ...) ; file: /usr/share/common-lisp/source/clx/requests.lisp ; in: DEFUN CREATE-PIXMAP ; (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-CREATEPIXMAP+) ; (XLIB::DATA XLIB::DEPTH) ; (XLIB:RESOURCE-ID XLIB::PID) ; (XLIB:DRAWABLE XLIB:DRAWABLE) ; (XLIB:CARD16 XLIB::WIDTH XLIB::HEIGHT)) ; --> 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 CREATE-PIXMAP ...) ; file: /usr/share/common-lisp/source/clx/requests.lisp ; in: DEFUN FREE-PIXMAP ; (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-FREEPIXMAP+) ; (XLIB:PIXMAP XLIB:PIXMAP)) ; --> 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 FREE-PIXMAP ...) ; file: /usr/share/common-lisp/source/clx/requests.lisp ; in: DEFUN CLEAR-AREA ; (XLIB::WITH-BUFFER-REQUEST ; ((XLIB:WINDOW-DISPLAY XLIB:WINDOW) XLIB::+X-CLEARTOBACKGROUND+) ; ((XLIB::DATA BOOLEAN) XLIB::EXPOSURES-P) (XLIB:WINDOW XLIB:WINDOW) ; (XLIB:INT16 XLIB::X XLIB::Y) ; (XLIB:CARD16 (OR XLIB::WIDTH 0) (OR XLIB::HEIGHT 0))) ; --> 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 CLEAR-AREA ...) ; file: /usr/share/common-lisp/source/clx/requests.lisp ; in: DEFUN COPY-AREA ; (XLIB::WITH-BUFFER-REQUEST ; ((XLIB:DRAWABLE-DISPLAY XLIB::SRC) XLIB::+X-COPYAREA+ :GC-FORCE ; XLIB:GCONTEXT) ; (XLIB:DRAWABLE XLIB::SRC XLIB::DST) (XLIB:GCONTEXT XLIB:GCONTEXT) ; (XLIB:INT16 XLIB::SRC-X XLIB::SRC-Y XLIB::DST-X XLIB::DST-Y) ; (XLIB:CARD16 XLIB::WIDTH XLIB::HEIGHT)) ; --> 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 COPY-AREA ...) ; file: /usr/share/common-lisp/source/clx/requests.lisp ; in: DEFUN COPY-PLANE ; (XLIB::WITH-BUFFER-REQUEST ; ((XLIB:DRAWABLE-DISPLAY XLIB::SRC) XLIB::+X-COPYPLANE+ :GC-FORCE ; XLIB:GCONTEXT) ; (XLIB:DRAWABLE XLIB::SRC XLIB::DST) (XLIB:GCONTEXT XLIB:GCONTEXT) ; (XLIB:INT16 XLIB::SRC-X XLIB::SRC-Y XLIB::DST-X XLIB::DST-Y) ; (XLIB:CARD16 XLIB::WIDTH XLIB::HEIGHT) (XLIB:CARD32 XLIB::PLANE)) ; --> 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 COPY-PLANE ...) ; file: /usr/share/common-lisp/source/clx/requests.lisp ; in: DEFUN CREATE-COLORMAP ; (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-CREATECOLORMAP+) ; ((XLIB::DATA BOOLEAN) XLIB::ALLOC-P) ; (XLIB:CARD29 XLIB::ID) (XLIB:WINDOW XLIB:WINDOW) ; (XLIB:CARD29 ; (XLIB:VISUAL-INFO-ID XLIB:VISUAL-INFO))) ; --> 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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. ; file: /usr/share/common-lisp/source/clx/requests.lisp ; in: DEFUN FREE-COLORMAP ; (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-FREECOLORMAP+) ; (XLIB:COLORMAP XLIB:COLORMAP)) ; --> 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). ; compiling (DEFUN CREATE-COLORMAP ...) ; ; 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 FREE-COLORMAP ...) ; file: /usr/share/common-lisp/source/clx/requests.lisp ; in: DEFUN COPY-COLORMAP-AND-FREE ; (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-COPYCOLORMAPANDFREE+) ; (XLIB:RESOURCE-ID XLIB::ID) ; (XLIB:COLORMAP XLIB:COLORMAP)) ; --> 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 COPY-COLORMAP-AND-FREE ...) ; file: /usr/share/common-lisp/source/clx/requests.lisp ; in: DEFUN INSTALL-COLORMAP ; (XLIB::WITH-BUFFER-REQUEST ; ((XLIB:COLORMAP-DISPLAY XLIB:COLORMAP) XLIB::+X-INSTALLCOLORMAP+) ; (XLIB:COLORMAP XLIB:COLORMAP)) ; --> 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 INSTALL-COLORMAP ...) ; file: /usr/share/common-lisp/source/clx/requests.lisp ; in: DEFUN UNINSTALL-COLORMAP ; (XLIB::WITH-BUFFER-REQUEST ; ((XLIB:COLORMAP-DISPLAY XLIB:COLORMAP) XLIB::+X-UNINSTALLCOLORMAP+) ; (XLIB:COLORMAP XLIB:COLORMAP)) ; --> 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 UNINSTALL-COLORMAP ...) ; file: /usr/share/common-lisp/source/clx/requests.lisp ; in: DEFUN INSTALLED-COLORMAPS ; (XLIB::WITH-BUFFER-REQUEST-AND-REPLY ; (XLIB:DISPLAY XLIB::+X-LISTINSTALLEDCOLORMAPS+ NIL :SIZES 16) ; ((XLIB:WINDOW XLIB:WINDOW)) ; (VALUES ; (XLIB::SEQUENCE-GET :RESULT-TYPE XLIB::RESULT-TYPE :LENGTH ; (XLIB::CARD16-GET 8) :TRANSFORM #'XLIB::GET-COLORMAP ; :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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 INSTALLED-COLORMAPS ...) ; file: /usr/share/common-lisp/source/clx/requests.lisp ; in: DEFUN ALLOC-COLOR ; (XLIB::WITH-BUFFER-REQUEST-AND-REPLY ; (XLIB:DISPLAY XLIB::+X-ALLOCNAMEDCOLOR+ 24 :SIZES (16 32)) ; ((XLIB:COLORMAP XLIB:COLORMAP) (XLIB:CARD16 LENGTH) (XLIB::PAD16 NIL) ; (STRING STRING)) ; (VALUES (XLIB::CARD32-GET 8) ; (XLIB:MAKE-COLOR :RED (XLIB::RGB-VAL-GET 18) :GREEN ; (XLIB::RGB-VAL-GET 20) :BLUE ; (XLIB::RGB-VAL-GET 22)) ; (XLIB:MAKE-COLOR :RED (XLIB::RGB-VAL-GET 12) :GREEN ; (XLIB::RGB-VAL-GET 14) :BLUE ; (XLIB::RGB-VAL-GET 16)))) ; --> 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). ; (XLIB::WITH-BUFFER-REQUEST-AND-REPLY ; (XLIB:DISPLAY XLIB::+X-ALLOCCOLOR+ 20 :SIZES (16 32)) ; ((XLIB:COLORMAP XLIB:COLORMAP) ; (XLIB:RGB-VAL (XLIB:COLOR-RED XLIB:COLOR) (XLIB:COLOR-GREEN XLIB:COLOR) ; (XLIB:COLOR-BLUE XLIB:COLOR)) ; (XLIB::PAD16 NIL)) ; (VALUES (XLIB::CARD32-GET 16) ; (XLIB:MAKE-COLOR :RED (XLIB::RGB-VAL-GET 8) :GREEN ; (XLIB::RGB-VAL-GET 10) :BLUE ; (XLIB::RGB-VAL-GET 12)) ; XLIB:COLOR)) ; --> 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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. ; (XLIB::WITH-BUFFER-REQUEST-AND-REPLY ; (XLIB:DISPLAY XLIB::+X-ALLOCNAMEDCOLOR+ 24 :SIZES (16 32)) ; ((XLIB:COLORMAP XLIB:COLORMAP) (XLIB:CARD16 LENGTH) (XLIB::PAD16 NIL) ; (STRING STRING)) ; (VALUES (XLIB::CARD32-GET 8) ; (XLIB:MAKE-COLOR :RED (XLIB::RGB-VAL-GET 18) :GREEN ; (XLIB::RGB-VAL-GET 20) :BLUE ; (XLIB::RGB-VAL-GET 22)) ; (XLIB:MAKE-COLOR :RED (XLIB::RGB-VAL-GET 12) :GREEN ; (XLIB::RGB-VAL-GET 14) :BLUE ; (XLIB::RGB-VAL-GET 16)))) ; --> 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: 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 ALLOC-COLOR ...) ; file: /usr/share/common-lisp/source/clx/requests.lisp ; in: DEFUN ALLOC-COLOR-CELLS ; (XLIB::WITH-BUFFER-REQUEST-AND-REPLY ; (XLIB:DISPLAY XLIB::+X-ALLOCCOLORCELLS+ NIL :SIZES 16) ; (((XLIB::DATA BOOLEAN) XLIB::CONTIGUOUS-P) (XLIB:COLORMAP XLIB:COLORMAP) ; (XLIB:CARD16 XLIB::COLORS XLIB::PLANES)) ; (LET ((XLIB::PIXEL-LENGTH (XLIB::CARD16-GET 8)) ; (XLIB::MASK-LENGTH (XLIB::CARD16-GET 10))) ; (VALUES ; (XLIB::SEQUENCE-GET :RESULT-TYPE XLIB::RESULT-TYPE :LENGTH ; XLIB::PIXEL-LENGTH :INDEX XLIB::+REPLYSIZE+) ; (XLIB::SEQUENCE-GET :RESULT-TYPE XLIB::RESULT-TYPE :LENGTH ; XLIB::MASK-LENGTH :INDEX ; (XLIB::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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 ALLOC-COLOR-CELLS ...) ; file: /usr/share/common-lisp/source/clx/requests.lisp ; in: DEFUN ALLOC-COLOR-PLANES ; (XLIB::WITH-BUFFER-REQUEST-AND-REPLY ; (XLIB:DISPLAY XLIB::+X-ALLOCCOLORPLANES+ NIL :SIZES (16 32)) ; (((XLIB::DATA BOOLEAN) XLIB::CONTIGUOUS-P) (XLIB:COLORMAP XLIB:COLORMAP) ; (XLIB:CARD16 XLIB::COLORS XLIB::REDS XLIB::GREENS XLIB::BLUES)) ; (LET ((XLIB::RED-MASK (XLIB::CARD32-GET 12)) ; (XLIB::GREEN-MASK (XLIB::CARD32-GET 16)) ; (XLIB::BLUE-MASK (XLIB::CARD32-GET 20))) ; (VALUES ; (XLIB::SEQUENCE-GET :RESULT-TYPE XLIB::RESULT-TYPE :LENGTH ; (XLIB::CARD16-GET 8) :INDEX XLIB::+REPLYSIZE+) ; XLIB::RED-MASK XLIB::GREEN-MASK XLIB::BLUE-MASK))) ; --> 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 ALLOC-COLOR-PLANES ...) ; file: /usr/share/common-lisp/source/clx/requests.lisp ; in: DEFUN FREE-COLORS ; (XLIB::WITH-BUFFER-REQUEST ; ((XLIB:COLORMAP-DISPLAY XLIB:COLORMAP) XLIB::+X-FREECOLORS+) ; (XLIB:COLORMAP XLIB:COLORMAP) (XLIB:CARD32 XLIB::PLANE-MASK) ; (SEQUENCE XLIB::PIXELS)) ; --> 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::CHECK-PUT XLIB::SEQUENCE-PUT LET ; ==> ; (LENGTH XLIB::PIXELS) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)). ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a SEQUENCE, not a VECTOR. ; --> 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 FREE-COLORS ...) ; file: /usr/share/common-lisp/source/clx/requests.lisp ; in: DEFUN STORE-COLOR ; (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-STORENAMEDCOLOR+) ; ((XLIB::DATA XLIB:CARD8) XLIB::FLAGS) ; (XLIB:COLORMAP XLIB:COLORMAP) ; (XLIB:CARD32 XLIB:PIXEL) (XLIB:CARD16 LENGTH) ; (XLIB::PAD16 NIL) (STRING STRING)) ; --> 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). ; (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-STORECOLORS+) ; (XLIB:COLORMAP XLIB:COLORMAP) ; (XLIB:CARD32 XLIB:PIXEL) ; (XLIB:RGB-VAL (XLIB:COLOR-RED XLIB::SPEC) ; (XLIB:COLOR-GREEN XLIB::SPEC) ; (XLIB:COLOR-BLUE XLIB::SPEC)) ; (XLIB:CARD8 XLIB::FLAGS) (XLIB::PAD8 NIL)) ; --> 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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. ; (XLIB::WITH-BUFFER-REQUEST (XLIB:DISPLAY XLIB::+X-STORENAMEDCOLOR+) ; ((XLIB::DATA XLIB:CARD8) XLIB::FLAGS) ; (XLIB:COLORMAP XLIB:COLORMAP) ; (XLIB:CARD32 XLIB:PIXEL) (XLIB:CARD16 LENGTH) ; (XLIB::PAD16 NIL) (STRING STRING)) ; --> 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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 STORE-COLOR ...) ; compiling (DEFUN STORE-COLORS ...) ; file: /usr/share/common-lisp/source/clx/requests.lisp ; in: DEFUN QUERY-COLORS ; (XLIB::WITH-BUFFER-REQUEST-AND-REPLY ; (XLIB:DISPLAY XLIB::+X-QUERYCOLORS+ NIL :SIZES (8 16)) ; ((XLIB:COLORMAP XLIB:COLORMAP) (SEQUENCE XLIB::PIXELS)) ; (LET ((SEQUENCE (MAKE-SEQUENCE XLIB::RESULT-TYPE #))) ; (XLIB::ADVANCE-BUFFER-OFFSET XLIB::+REPLYSIZE+) ; (DOTIMES (XLIB::I (LENGTH SEQUENCE) SEQUENCE) ; (SETF (ELT SEQUENCE XLIB::I) (XLIB:MAKE-COLOR :RED # :GREEN # :BLUE #)) ; (XLIB::ADVANCE-BUFFER-OFFSET 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::CHECK-PUT XLIB::SEQUENCE-PUT LET ; ==> ; (LENGTH XLIB::PIXELS) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)). ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a SEQUENCE, not a VECTOR. ; (LENGTH SEQUENCE) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (OR (SIMPLE-ARRAY * (*)) CONS NULL ; SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY ; * (*)). ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (OR (SIMPLE-ARRAY * (*)) CONS NULL ; SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR. ; (SETF (ELT SEQUENCE XLIB::I) ; (XLIB:MAKE-COLOR :RED (XLIB::RGB-VAL-GET 0) :GREEN ; (XLIB::RGB-VAL-GET 2) :BLUE (XLIB::RGB-VAL-GET 4))) ; ==> ; (SB-KERNEL:%SETELT SEQUENCE XLIB::I ; (XLIB:MAKE-COLOR :RED (XLIB::RGB-VAL-GET 0) :GREEN ; (XLIB::RGB-VAL-GET 2) :BLUE ; (XLIB::RGB-VAL-GET 4))) ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (OR (SIMPLE-ARRAY * (*)) CONS NULL ; SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY ; * (*)). ; ; note: unable to ; optimize ; due to type uncertainty: ; The first argument is a (OR (SIMPLE-ARRAY * (*)) CONS NULL ; SB-KERNEL:EXTENDED-SEQUENCE), not a LIST. ; (XLIB::WITH-BUFFER-REQUEST-AND-REPLY ; (XLIB:DISPLAY XLIB::+X-QUERYCOLORS+ NIL :SIZES (8 16)) ; ((XLIB:COLORMAP XLIB:COLORMAP) (SEQUENCE XLIB::PIXELS)) ; (LET ((SEQUENCE (MAKE-SEQUENCE XLIB::RESULT-TYPE #))) ; (XLIB::ADVANCE-BUFFER-OFFSET XLIB::+REPLYSIZE+) ; (DOTIMES (XLIB::I (LENGTH SEQUENCE) SEQUENCE) ; (SETF (ELT SEQUENCE XLIB::I) (XLIB:MAKE-COLOR :RED # :GREEN # :BLUE #)) ; (XLIB::ADVANCE-BUFFER-OFFSET 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 18446744073709551615 (- SB-C::SIZE 64))) ; ; 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-COLORS ...) ; file: /usr/share/common-lisp/source/clx/requests.lisp ; in: DEFUN LOOKUP-COLOR ; (XLIB::WITH-BUFFER-REQUEST-AND-REPLY ; (XLIB:DISPLAY XLIB::+X-LOOKUPCOLOR+ 20 :SIZES 16) ; ((XLIB:COLORMAP XLIB:COLORMAP) (XLIB:CARD16 LENGTH) (XLIB::PAD16 NIL) ; (STRING STRING)) ; (VALUES ; (XLIB:MAKE-COLOR :RED (XLIB::RGB-VAL-GET 14) :GREEN (XLIB::RGB-VAL-GET 16) ; :BLUE (XLIB::RGB-VAL-GET 18)) ; (XLIB:MAKE-COLOR :RED (XLIB::RGB-VAL-GET 8) :GREEN (XLIB::RGB-VAL-GET 10) ; :BLUE (XLIB::RGB-VAL-GET 12)))) ; --> 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: