Custom Query (1030 matches)

Somewhere in my code is a bug, but it's hard to track down.

? (gen-game)
> Error: value . is not of the expected type LIST.
> While executing: (:INTERNAL (PRINT-OBJECT (CL-ROGUE:LEVEL T))), in process listener(1).

Only by trial and error can I find out which function call is to blame.

Please list the calling functions in an error trace, not just "process listener".

$ clall -r '(read-from-string "+.e2")'

International Allegro CL Free Express Edition --> +.E2, 4
Clozure Common Lisp            --> 0.0, 4
CLISP                          --> |+.E2|, 4
CMU Common Lisp                --> |+.E2|, 4
ECL                            --> 0.0, 4
SBCL                           --> |+.E2|, 4


CLHS is clear about it "2.3.1 Numbers as Tokens", the syntax for
floating point numbers is:

    float          ::=  [sign]
                       {decimal-digit}*
                       decimal-point
                       {decimal-digit}+
                       [exponent]  
                        | 
                       [sign]
                       {decimal-digit}+
                       [decimal-point
                           {decimal-digit}*]
                       exponent    
    exponent       ::=  exponent-marker
                       [sign]
                       {digit}+    

that is, at least one decimal digit is required before or after the dot.

With no digit, the token +.e2 should be read as a symbol.

Sometimes the compiler warns

style-warning: Unused lexical variable FOO

where FOO is some variable I've SETQ'd but then not referred to.

That's annoying enough. I don't think that should be done at all. It's a pain to have to throw away documentary (multiple-value-setq (x y z) ...) variables or go through other hoops just to get rid of this warning. Also, it's "used" by reasonable definition: it's set, just not "read" or "eval'd". Whatever. It's a pain to encounter and to work around.

But that's not the main point.

Sometimes -- not always!! -- I cannot even still the compiler by simply placing the variable inline to be evaluated.

The compiler first of all is so clever as to optimize out the reference, then turns on me and tells me it's not referenced. That is quite frustrating to put it mildly.

Seems to happen in big functions. Small functions work fine, so I cannot give you an example. But it's like this:

  (defun foo (a b) 
       (let (c d)
         (multiple-value-setq (c d) (round a b))
         c))

always warns about D "unused" (annoying to me, but I can deal with it)

  (defun foo (a b) 
       (let (c d)
         (multiple-value-setq (c d) (round a b))
         d
         c))

not in this case, but in some larger functions, warns about D -- unacceptable, bug, etc.!

Note: let me know if this is a known problem: that is, the flakyness (dependency on function size, or whatever), or -- if not -- if you need an example. I'll put cycles on it, but would rather not if it's already known.

Version info:

            CCL::*OPENMCL-MAJOR-VERSION*,  Value: 1
            CCL::*OPENMCL-MINOR-VERSION*,  Value: 6