Custom Query (1030 matches)

find-applicable-methods expects to be called with symbols:

(ccl::FIND-APPLICABLE-METHODS 'PROCESS-KILL '(PROCESS) nil) -> (#<CCL::STANDARD-KERNEL-METHOD PROCESS-KILL (PROCESS)>)

but "some" functions pass a list of actual classes as the args parameter, like swank-backend::xref-locations so i can't use "who calls".

my workaround is to map the args list and replace non-symbols by the class-name like this:

(defun find-applicable-methods (name args qualifiers)
  (setf args
	(mapcar #'(lambda (arg)
		    (if (symbolp arg)
			arg
			(class-name arg)))
		args))
  ...)

you can trigger the error without slime with xref-describe:

Welcome to Clozure Common Lisp Version 1.3-r11936  (DarwinX8664)!
? (ccl::xref-describe 'ccl:process-interrupt :verbose t)

 PROCESS-INTERRUPT is directly called by:
     PROCESS-ABORT
       Type: FUNCTION
       File: /Users/Shared/develop/lisp/ccl/level-1/l1-processes.lisp

     PROCESS-KILL (#<STANDARD-CLASS PROCESS>)
       Type: METHOD
> Error: Class named #<STANDARD-CLASS PROCESS> not found.
...
1 > :B
 (6A57C8) : 0 (FIND-CLASS #<STANDARD-CLASS PROCESS> NIL NIL) 669
 (6A5828) : 1 (FIND-APPLICABLE-METHODS PROCESS-KILL (#<STANDARD-CLASS PROCESS>) NIL) 2093
 (6A58A8) : 2 (GET-SOURCE-FILES-WITH-TYPES (PROCESS-KILL (#<STANDARD-CLASS PROCESS>)) METHOD) 357
 (6A5918) : 3 (EDIT-DEFINITION-P (PROCESS-KILL (#<STANDARD-CLASS PROCESS>)) METHOD) 125
 (6A5960) : 4 (%SOURCE-FILE-FOR-XREF-ENTRY #<XREF-ENTRY PROCESS-KILL METHOD (#<STANDARD-CLASS PROCESS>)>) 205
 (6A5980) : 5 (%PRINT-XREF-ENTRIES (#<XREF-ENTRY PROCESS-ABORT FUNCTION> #<XREF-ENTRY PROCESS-KILL METHOD #> #<XREF-ENTRY PROCESS-RESET METHOD #> #<XREF-ENTRY QUIT FUNCTION> #<XREF-ENTRY INTERACTIVE-ABORT-IN-PROCESS FUNCTION> ...) #<ECHOING-TWO-WAY-STREAM input #<BASIC-CHARACTER-INPUT-STREAM ISO-8859-1 (TTY/0) #x300040F00FED>, output #<BASIC-CHARACTER-OUTPUT-STREAM ISO-8859-1 (TTY/1) #x300040F00ADD> #x300040F03A7D> T) 477
 (6A59B8) : 6 (WHO-DIRECTLY-CALLS PROCESS-INTERRUPT :INVERSE NIL :IN-FILES NIL :IN-FUNCTIONS NIL :VERBOSE T :STREAM #<ECHOING-TWO-WAY-STREAM input #<BASIC-CHARACTER-INPUT-STREAM ISO-8859-1 (TTY/0) #x300040F00FED>, output #<BASIC-CHARACTER-OUTPUT-STREAM ISO-8859-1 (TTY/1) #x300040F00ADD> #x300040F03A7D>) 397
 (6A5A28) : 7 (WHO-CALLS PROCESS-INTERRUPT :INVERSE NIL :IN-FILES NIL :IN-FUNCTIONS NIL :VERBOSE T :STREAM #<ECHOING-TWO-WAY-STREAM input #<BASIC-CHARACTER-INPUT-STREAM ISO-8859-1 (TTY/0) #x300040F00FED>, output #<BASIC-CHARACTER-OUTPUT-STREAM ISO-8859-1 (TTY/1) #x300040F00ADD> #x300040F03A7D>) 189
 (6A5A90) : 8 (XREF-DESCRIBE PROCESS-INTERRUPT :VERBOSE T) 189

compile a file containing a defgeneric as its last form, and load the compiled file. the source-notes for that function (and its methods) are missing, instead there are pathnames. Consequently slime fails when trying to "goto definition" (meta-.). Now for the magic: if you add some other definition (eg. a defun) below (and compile again), the source-notes are there!?

example: (contents of file "~/source-note-test.lisp" )

(defgeneric adoctestfun (input)

(:documentation "Parse INPUT, ") (:method ((input string))

(format t "string ~s" input))

(:method ((input number))

(format t "number ~s" (* 2 input))))

;; (defun somethingunrelated (i) (* 2 i))

(compile-file "~/source-note-test.lisp") (load "~/source-note-test.dx64fsl") (find-definition-sources 'adoctestfun) -> no source notes

;; now uncomment the defun and try again:

(compile-file "~/source-note-test.lisp") (load "~/source-note-test.dx64fsl") (find-definition-sources 'adoctestfun) -> ok, source notes are there

(tested in 1.3-r11936 DarwinX8664 and 1.3-RC1-r11804MS (LinuxX8632)

A function defined with MACROLET that is declaimed as INLINE doesn't seem to actually inline at the call site.

If you manually write the definition out without the MACROLET, inlining works as expected.

I have tried locally declaring the function as INLINE at the call site, and I have also tried doing a DECLAIM INLINE outside of the MACROLET, all to no avail.

See the interactions below to reproduce.

File def.lisp

(defpackage :foo
  (:use :cl)
  (:export fun))

(in-package :foo)

(macrolet ((def (name op)
             `(progn
                (declaim (inline ,name))
                (defun ,name (a b)
                  (,op a b)))))
  (def fun +))

File use.lisp

(in-package :cl-user)

(defun bar (a b)
  (declare (optimize speed (safety 0) (debug 0) (space 0)))
  (foo:fun a (* a b)))

REPL interaction (note the line marked with !!!!...!!)

CL-USER> (lisp-implementation-type)
"Clozure Common Lisp"
CL-USER> (lisp-implementation-version)
"Version 1.11-dev-r16361M-trunk  (LinuxARM32)"
CL-USER> (load (compile-file "def.lisp"))
#P"def.lafsl"
CL-USER> (load (compile-file "use.lisp"))
#P"use.lafsl"
CL-USER> (disassemble #'bar)
;; Source: "use.lisp.newest":23-122
  (mov imm0 (:$ 19))
  (stmdb (:! sp) (imm0 vsp fn lr))
  (mov fn temp2)
  (stmdb (:! vsp) (arg_z arg_y))        ;[12]

;;; (* a b)
  (sploadlr .SPbuiltin-times)           ;[16]
  (blx lr)

;;; (foo:fun a (* a b))
  (ldr arg_y (:@ vsp (:$ 4)))           ;[24]
  (mov nargs (:$ 8))
  (ldr temp1 (:@ fn 'FOO:FUN))          ; *** !!!!!!!!!!!!!!
  (ldmia (:! sp) (imm0 vsp fn lr))
  (ldr temp2 (:@ temp1 (:$ 6)))         ;[40]
  (ldr pc (:@ temp2 (:$ -2)))

;;; #<no source text>
NIL