From: WoodHacker
Subject: Compiler warnings
Date: Thu, 03 Nov 2005 14:21:50 +0000
Message-ID: <1131027710.277212.56670@f14g2000cwb.googlegroups.com>

I am working with event loops in CLX (i.e. event-case).   I have the
following clause:
       (:client-message (type data format)
           (if (and (eql format 32)
                       (eql type :WM_PROTOCOLS)
                       (eql (xlib:atom-name *vl-display*
(get-delete-atom data)) :WM_DELETE_WINDOW))
                 (progn
                   (setf *vl-running* nil))
                   t)))

The idea is to exit the event loop and set the running flag to nil so I
can clean up the system and exit an outer loop.   This all works fast
and fine.   (All my other clauses are similar)

HOWEVER, when I compile this in SBCL I get a ton of warnings, mostly
having to do with the variables type, data, and format inside the IF.
(The values are correct if I print them out.)  It seems to have a lot
of  trouble also with globals like *vl-display*.

I feel the problem centers around the fact that the variables are not
bound at compile time.   But how do I bind them?   I tried a Lambda
expression, which gets rid of the errors, but makes the system so slow
it not longer works.   As you can probably tell, I'm fairly new to CL
and have a lot to learn.    Getting so many warnings just doesn't seen
right, even tough the code works fine.

• Re: Compiler warnings Bill Atkins
  • Re: Compiler warnings WoodHacker
    • Re: Compiler warnings Rob Warnock
      • Re: Compiler warnings WoodHacker
      • Re: Compiler warnings Thomas F. Burdick

From: Bill Atkins
Subject: Re: Compiler warnings
Date: Thu, 03 Nov 2005 14:28:27 +0000
Message-ID: <1131028107.511088.111260@g49g2000cwa.googlegroups.com>

Why not post some of the warnings?

Bill

From: WoodHacker
Subject: Re: Compiler warnings
Date: Thu, 03 Nov 2005 21:06:04 +0000
Message-ID: <1131051964.695646.266040@z14g2000cwz.googlegroups.com>

Well, you asked for it....  (not a pretty sight - get my code seems to
work fine)

; --> XLIB:EVENT-COND LET XLIB::EVENT-LOOP LET XLIB:WITH-EVENT-QUEUE
MACROLET
; --> LET XLIB::HOLDING-LOCK IF HANDLER-CASE BLOCK LET TAGBODY
HANDLER-BIND LET
; --> MULTIPLE-VALUE-PROG1 PROGN RETURN-FROM MULTIPLE-VALUE-PROG1
WITH-TIMEOUT
; --> LET MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF PROGN
; --> SB-THREAD:WITH-RECURSIVE-LOCK LOCALLY MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL FUNCTION PROGV LET UNWIND-PROTECT FLET BLOCK
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK
SB-C::%WITHIN-CLEANUP
; --> RETURN-FROM PROGN LOOP BLOCK TAGBODY PROGN MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL FUNCTION LET UNWIND-PROTECT FLET BLOCK
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK
SB-C::%WITHIN-CLEANUP
; --> RETURN-FROM PROGN LET XLIB::EVENT-DISPATCH XLIB::READING-EVENT
; --> XLIB::WITH-BUFFER-INPUT LET LET* LET CASE LET COND IF COND IF
COND IF
; --> COND IF COND IF COND IF COND IF COND IF COND IF COND IF COND IF
PROGN
; --> XLIB::BINDING-EVENT-VALUES LET LET LET*
; ==>
;   (MAKE-ARRAY (CEILING 160 FORMAT) :ELEMENT-TYPE `(UNSIGNED-BYTE
,FORMAT))
;
; note: unable to optimize because: ELEMENT-TYPE is not constant.

; --> XLIB:EVENT-COND LET XLIB::EVENT-LOOP LET XLIB:WITH-EVENT-QUEUE
MACROLET
; --> LET XLIB::HOLDING-LOCK IF HANDLER-CASE BLOCK LET TAGBODY
HANDLER-BIND LET
; --> MULTIPLE-VALUE-PROG1 PROGN RETURN-FROM MULTIPLE-VALUE-PROG1
WITH-TIMEOUT
; --> LET MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF PROGN
; --> SB-THREAD:WITH-RECURSIVE-LOCK LOCALLY MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL FUNCTION PROGV LET UNWIND-PROTECT FLET BLOCK
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK
SB-C::%WITHIN-CLEANUP
; --> RETURN-FROM PROGN LOOP BLOCK TAGBODY PROGN MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL FUNCTION LET UNWIND-PROTECT FLET BLOCK
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK
SB-C::%WITHIN-CLEANUP
; --> RETURN-FROM PROGN LET XLIB::EVENT-DISPATCH XLIB::READING-EVENT
; --> XLIB::WITH-BUFFER-INPUT LET LET* LET CASE LET COND IF COND IF
COND IF
; --> COND IF COND IF COND IF COND IF COND IF COND IF COND IF COND IF
PROGN
; --> XLIB::BINDING-EVENT-VALUES LET LET LET* DO BLOCK LET TAGBODY
TAGBODY CASE
; --> LET COND IF PROGN SETF SB-KERNEL:%ASET LET*
; ==>
;   (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:EVENT-COND LET XLIB::EVENT-LOOP LET XLIB:WITH-EVENT-QUEUE
MACROLET
; --> LET XLIB::HOLDING-LOCK IF HANDLER-CASE BLOCK LET TAGBODY
HANDLER-BIND LET
; --> MULTIPLE-VALUE-PROG1 PROGN RETURN-FROM MULTIPLE-VALUE-PROG1
WITH-TIMEOUT
; --> LET MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF PROGN
; --> SB-THREAD:WITH-RECURSIVE-LOCK LOCALLY MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL FUNCTION PROGV LET UNWIND-PROTECT FLET BLOCK
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK
SB-C::%WITHIN-CLEANUP
; --> RETURN-FROM PROGN LOOP BLOCK TAGBODY PROGN MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL FUNCTION LET UNWIND-PROTECT FLET BLOCK
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK
SB-C::%WITHIN-CLEANUP
; --> RETURN-FROM PROGN LET XLIB::EVENT-DISPATCH XLIB::READING-EVENT
; --> XLIB::WITH-BUFFER-INPUT LET LET* LET CASE LET COND IF COND IF
COND IF
; --> COND IF COND IF COND IF COND IF COND IF COND IF COND IF COND IF
PROGN
; --> XLIB::BINDING-EVENT-VALUES LET LET LET* DO BLOCK LET TAGBODY
TAGBODY CASE
; --> LET COND IF COND IF PROGN SETF SB-KERNEL:%ASET LET*
; ==>
;   (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:EVENT-COND LET XLIB::EVENT-LOOP LET XLIB:WITH-EVENT-QUEUE
MACROLET
; --> LET XLIB::HOLDING-LOCK IF HANDLER-CASE BLOCK LET TAGBODY
HANDLER-BIND LET
; --> MULTIPLE-VALUE-PROG1 PROGN RETURN-FROM MULTIPLE-VALUE-PROG1
WITH-TIMEOUT
; --> LET MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF PROGN
; --> SB-THREAD:WITH-RECURSIVE-LOCK LOCALLY MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL FUNCTION PROGV LET UNWIND-PROTECT FLET BLOCK
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK
SB-C::%WITHIN-CLEANUP
; --> RETURN-FROM PROGN LOOP BLOCK TAGBODY PROGN MULTIPLE-VALUE-BIND
; --> MULTIPLE-VALUE-CALL FUNCTION LET UNWIND-PROTECT FLET BLOCK
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK
SB-C::%WITHIN-CLEANUP
; --> RETURN-FROM PROGN LET XLIB::EVENT-DISPATCH XLIB::READING-EVENT
; --> XLIB::WITH-BUFFER-INPUT LET LET* LET CASE LET COND IF COND IF
COND IF
; --> COND IF COND IF COND IF COND IF COND IF COND IF COND IF COND IF
PROGN
; --> XLIB::BINDING-EVENT-VALUES LET LET LET* DO BLOCK LET TAGBODY
TAGBODY CASE
; --> LET COND IF COND IF COND IF PROGN SETF SB-KERNEL:%ASET LET*
; ==>
;   (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:EVENT-COND LET XLIB::EVENT-LOOP LET XLIB:WITH-EVENT-QUEUE
MACROLET
; --> LET XLIB::HOLDING-LOCK IF HANDLER-CASE BLOCK LET TAGBODY
HANDLER-BIND LET
; --> MULTIPLE-VALUE-PROG1 PROGN RETURN-FROM MULTIPLE-VALUE-PROG1
WITH-TIMEOUT
; --> LET MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF
UNWIND-PROTECT
; --> FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK
; --> SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN
SB-THREAD:WITH-RECURSIVE-LOCK
; --> LOCALLY MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION PROGV
LET
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL
BLOCK
; --> SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LOOP BLOCK TAGBODY PROGN
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION LET
UNWIND-PROTECT FLET
; --> BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK
SB-C::%WITHIN-CLEANUP
; --> RETURN-FROM PROGN LET XLIB::EVENT-DISPATCH XLIB::READING-EVENT
; --> XLIB::WITH-BUFFER-INPUT LET LET* LET CASE LET COND IF COND IF
COND IF
; --> COND IF COND IF COND IF COND IF COND IF COND IF COND IF COND IF
PROGN
; --> XLIB::BINDING-EVENT-VALUES LET LET LET*
; ==>
;   (MAKE-ARRAY (CEILING 160 FORMAT) :ELEMENT-TYPE `(UNSIGNED-BYTE
,FORMAT))
;
; note: unable to optimize because: ELEMENT-TYPE is not constant.

; --> XLIB:EVENT-COND LET XLIB::EVENT-LOOP LET XLIB:WITH-EVENT-QUEUE
MACROLET
; --> LET XLIB::HOLDING-LOCK IF HANDLER-CASE BLOCK LET TAGBODY
HANDLER-BIND LET
; --> MULTIPLE-VALUE-PROG1 PROGN RETURN-FROM MULTIPLE-VALUE-PROG1
WITH-TIMEOUT
; --> LET MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF
UNWIND-PROTECT
; --> FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK
; --> SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN
SB-THREAD:WITH-RECURSIVE-LOCK
; --> LOCALLY MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION PROGV
LET
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL
BLOCK
; --> SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LOOP BLOCK TAGBODY PROGN
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION LET
UNWIND-PROTECT FLET
; --> BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK
SB-C::%WITHIN-CLEANUP
; --> RETURN-FROM PROGN LET XLIB::EVENT-DISPATCH XLIB::READING-EVENT
; --> XLIB::WITH-BUFFER-INPUT LET LET* LET CASE LET COND IF COND IF
COND IF
; --> COND IF COND IF COND IF COND IF COND IF COND IF COND IF COND IF
PROGN
; --> XLIB::BINDING-EVENT-VALUES LET LET LET* DO BLOCK LET TAGBODY
TAGBODY CASE
; --> LET COND IF PROGN SETF SB-KERNEL:%ASET LET*
; ==>
;   (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:EVENT-COND LET XLIB::EVENT-LOOP LET XLIB:WITH-EVENT-QUEUE
MACROLET
; --> LET XLIB::HOLDING-LOCK IF HANDLER-CASE BLOCK LET TAGBODY
HANDLER-BIND LET
; --> MULTIPLE-VALUE-PROG1 PROGN RETURN-FROM MULTIPLE-VALUE-PROG1
WITH-TIMEOUT
; --> LET MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF
UNWIND-PROTECT
; --> FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK
; --> SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN
SB-THREAD:WITH-RECURSIVE-LOCK
; --> LOCALLY MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION PROGV
LET
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL
BLOCK
; --> SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LOOP BLOCK TAGBODY PROGN
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION LET
UNWIND-PROTECT FLET
; --> BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK
SB-C::%WITHIN-CLEANUP
; --> RETURN-FROM PROGN LET XLIB::EVENT-DISPATCH XLIB::READING-EVENT
; --> XLIB::WITH-BUFFER-INPUT LET LET* LET CASE LET COND IF COND IF
COND IF
; --> COND IF COND IF COND IF COND IF COND IF COND IF COND IF COND IF
PROGN
; --> XLIB::BINDING-EVENT-VALUES LET LET LET* DO BLOCK LET TAGBODY
TAGBODY CASE
; --> LET COND IF COND IF PROGN SETF SB-KERNEL:%ASET LET*
; ==>
;   (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:EVENT-COND LET XLIB::EVENT-LOOP LET XLIB:WITH-EVENT-QUEUE
MACROLET
; --> LET XLIB::HOLDING-LOCK IF HANDLER-CASE BLOCK LET TAGBODY
HANDLER-BIND LET
; --> MULTIPLE-VALUE-PROG1 PROGN RETURN-FROM MULTIPLE-VALUE-PROG1
WITH-TIMEOUT
; --> LET MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF
UNWIND-PROTECT
; --> FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK
; --> SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN
SB-THREAD:WITH-RECURSIVE-LOCK
; --> LOCALLY MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION PROGV
LET
; --> UNWIND-PROTECT FLET BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL
BLOCK
; --> SB-C::%WITHIN-CLEANUP RETURN-FROM PROGN LOOP BLOCK TAGBODY PROGN
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION LET
UNWIND-PROTECT FLET
; --> BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL BLOCK
SB-C::%WITHIN-CLEANUP
; --> RETURN-FROM PROGN LET XLIB::EVENT-DISPATCH XLIB::READING-EVENT
; --> XLIB::WITH-BUFFER-INPUT LET LET* LET CASE LET COND IF COND IF
COND IF
; --> COND IF COND IF COND IF COND IF COND IF COND IF COND IF COND IF
PROGN
; --> XLIB::BINDING-EVENT-VALUES LET LET LET* DO BLOCK LET TAGBODY
TAGBODY CASE
; --> LET COND IF COND IF COND IF PROGN SETF SB-KERNEL:%ASET LET*
; ==>
;   (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.

From: Rob Warnock
Subject: Re: Compiler warnings
Date: Fri, 04 Nov 2005 03:54:36 +0000
Message-ID: <GKmdnazIu7jhRvfenZ2dnUVZ_s6dnZ2d@speakeasy.net>

WoodHacker <·······@comcast.net> wrote:
+---------------
| Well, you asked for it....  (not a pretty sight - get my code seems to
| work fine)
+---------------

That's because *none* of those are "errors" -- they're just warnings
[or perhaps one should say "advisories" or "commentary"] that you're
not going to get the absolutely tightest, fastest code the compiler
might possibly be able to give you if you told it a little bit more
about the types of things.

But no errors per se...  ;-}


-Rob

-----
Rob Warnock			<····@rpw3.org>
627 26th Avenue			<URL:http://rpw3.org/>
San Mateo, CA 94403		(650)572-2607

From: WoodHacker
Subject: Re: Compiler warnings
Date: Fri, 04 Nov 2005 13:09:13 +0000
Message-ID: <1131109753.622291.200170@g49g2000cwa.googlegroups.com>

Thanks...

From: Thomas F. Burdick
Subject: Re: Compiler warnings
Date: Wed, 09 Nov 2005 12:41:14 +0000
Message-ID: <xcv1x1qxac5.fsf@conquest.OCF.Berkeley.EDU>

····@rpw3.org (Rob Warnock) writes:

> WoodHacker <·······@comcast.net> wrote:
> +---------------
> | Well, you asked for it....  (not a pretty sight - get my code seems to
> | work fine)
> +---------------
> 
> That's because *none* of those are "errors" -- they're just warnings
> [or perhaps one should say "advisories" or "commentary"] that you're
> not going to get the absolutely tightest, fastest code the compiler
> might possibly be able to give you if you told it a little bit more
> about the types of things.
> 
> But no errors per se...  ;-}

No warnings, either.  Those were all notes.  To the OP: if you use
Emacs/SLIME, it will categorize SBCL's noise for you into Errors,
Warnings, and Notes.  Very handy.

-- 
           /|_     .-----------------------.                        
         ,'  .\  / | Free Mumia Abu-Jamal! |
     ,--'    _,'   | Abolish the racist    |
    /       /      | death penalty!        |
   (   -.  |       `-----------------------'
   |     ) |                               
  (`-.  '--.)                              
   `. )----'