Commits

Anonymous committed 9218f3d

Updates to find-func.el and fixes for find-gc.el.

  • Participants
  • Parent commits 199a9b9

Comments (0)

Files changed (4)

+1998-03-03  Markus Linnala  <maage@cs.tut.fi>
+
+	* find-gc.el (trace-call-tree): Use make to make RTL's.
+	(find-gc-unsafe): Print output to buffer. Change
+	garbage_collecting function from Fgarbage_collect_1 to
+	garbage_collect_1.
+	(emacs-source-directory): Change default.
+	(source-files): Try to get default from src directory.
+
+1998-03-04  Jens-Ulrik Petersen  <petersen@kurims.kyoto-u.ac.jp>
+
+	* find-func.el (find-function-regexp): New variable, taken from
+	former constant in `find-function-noselect'.  Can now find
+	function definitions with parameters on a new line (suggested by
+	Christoph Wedler <wedler@fmi.uni-passau.de>).
+	(find-variable-regexp): New variable.
+	(find-function-search-for-symbol): New function of stuff taken out 
+	of `find-function-noselect'
+	(find-function-noselect): Use it and `find-function-regexp'.
+	(find-function-read): Renamed from `find-function-read-function'.
+	With optional arg now read a variable.
+	(find-function-do-it): Added parameter to indicate if a variable
+	is being searched for.
+	(find-function): Use `find-function-read'.
+	(find-function-other-window): Ditto.
+	(find-function-other-frame): Ditto.
+	(find-variable-noselect): New function for finding the point of
+	definition of variables, modeled on `find-function-noselect'.
+	(find-variable): New function.
+	(find-variable-other-window): Ditto.
+	(find-variable-other-frame): Ditto.
+	(find-variable-at-point): New function for "help".
+	(ctl-x-map): Bind find-variable functions.
+
 1998-02-08  Kyle Jones  <kyle_jones@wonderworks.com>
 
 	* xemacs-devel/pretty-print.el: Don't bind keys when
 
 # This XEmacs package contains independent single file lisp packages
 
-VERSION = 1.08
+VERSION = 1.09
 AUTHOR_VERSION =
 MAINTAINER = XEmacs Development Team <xemacs-beta@xemacs.org>
 PACKAGE = xemacs-devel
 ;; Keywords: emacs-lisp, functions
 ;; Created: 97/07/25
 ;; URL: <http://www.kurims.kyoto-u.ac.jp/~petersen/emacs-lisp/>
+;; Version: 0.19
 
 ;; $Id$
 
 ;; (global-set-key [(control ?c) ?4 ?f] 'find-function-other-window)
 ;; (global-set-key [(control ?c) ?5 ?f] 'find-function-other-frame)
 ;; (global-set-key [(control ?c) ?k] 'find-function-on-key)
+;; (global-set-key [(control ?c) ?v] 'find-variable)
+;; (global-set-key [(control ?c) ?4 ?v] 'find-variable-other-window)
+;; (global-set-key [(control ?c) ?5 ?v] 'find-variable-other-frame)
 ;;
 ;; and away you go!  It does pretty much what you would expect,
-;; putting the cursor at the definition of the function at point.
+;; putting the cursor at the definition of the function or variable at
+;; point.
 ;;
-;; In XEmacs the source file of dumped functions is recorded (and can
-;; be accessed with the function `compiled-function-annotation', which
-;; doesn't exist in Emacs), so in XEmacs non-primitive dumped
-;; functions can also be found.  Unfortunately this is not possible in
-;; Emacs.  It would be nice if the location of primitive functions in
-;; the C code was also recorded!
+;; In XEmacs the source file of all loaded Lisp function and variable
+;; definitions is now recorded in `load-history'.  So in XEmacs all
+;; non-primitive functions and variables can be found.  Unfortunately
+;; in Emacs, only loaded function can be found.  It would be nice if
+;; the location of primitive functions in the C code was also
+;; recorded!
 
-;; The code is adapted from `describe-function', `describe-key'
+;; The code started out from `describe-function', `describe-key'
 ;; ("help.el") and `fff-find-loaded-emacs-lisp-function' (Noah Friedman's
 ;; "fff.el").
 
 
 ;;; User variables:
 
+;; (defcustom find-function-method-function 'switch-to-buffer-other-window 
+;;   "The default function used to display the buffer of the definition.
+;; 
+;; Can be for example `switch-to-buffer', `switch-to-buffer-other-window' 
+;; (default), `switch-to-buffer-other-frame', or another function that
+;; takes a buffer as argument."
+;;   :type '(choice (const switch-to-buffer)
+;; 		 (const switch-to-buffer-other-window)
+;; 		 (const switch-to-buffer-other-frame)
+;;                  (function))
+;;   :group 'find-function)
+
+(defcustom find-function-regexp
+  "^\\s-*(def[^cgv\W]\\w+\\*?\\s-+%s\\(\\s-\\|$\\)"
+"The regexp used by `find-function' to search for a function
+definition.  Note it must contain a `%s' at the place where `format'
+should insert the function name.  The default value avoids `defconst',
+`defgroup', `defvar'.
+
+Please send improvements and fixes to the maintainer."
+  :type 'regexp
+  :group 'find-function)
+
+(defcustom find-variable-regexp
+  "^\\s-*(def[^uma\W]\\w+\\*?\\s-+%s\\(\\s-\\|$\\)"
+  "The regexp used by `find-variable' to search for a variable definition.
+It should match right up to the variable name.  The default value
+avoids `defun', `defmacro', `defalias', `defadvice'.
+
+Please send improvements and fixes to the maintainer."
+  :type 'regexp
+  :group 'find-function)
+
 (defcustom find-function-source-path nil
   "The default list of directories where find-function searches.
 
 
 ;;; Functions:
 
+(defun find-function-search-for-symbol (symbol variable-p library)
+  "Search for SYMBOL in LIBRARY.
+If VARIABLE-P is nil, `find-function-regexp' is used, otherwise
+`find-variable-regexp' is used."
+  (if (null library)
+      (error (format "Don't know where `%s' is defined" symbol)))
+  (if (string-match "\\.el\\(c\\)\\'" library)
+      (setq library (substring library 0 (match-beginning 1))))
+  (let* ((path find-function-source-path)
+	 (filename (if (file-exists-p library)
+		       library
+		     (if (string-match "\\(\\.el\\)\\'" library)
+			 (setq library (substring library 0
+						  (match-beginning
+						   1))))
+		     (or (locate-library (concat library ".el") t path)
+			 (locate-library library t path)))))
+    (if (not filename)
+	(error "The library \"%s\" is not in the path." library))
+    (with-current-buffer (find-file-noselect filename)
+      (save-match-data
+	(let ((regexp (format (if variable-p
+				  find-variable-regexp
+				find-function-regexp)
+			      symbol))
+	      (syn-table (syntax-table)))
+	  (unwind-protect
+	      (progn
+		(set-syntax-table emacs-lisp-mode-syntax-table)
+		(goto-char (point-min))
+		(if (re-search-forward regexp nil t)
+		    (progn
+		      (beginning-of-line)
+		      (cons (current-buffer) (point)))
+		  (error "Cannot find definition of `%s'" symbol)))
+	    (set-syntax-table syn-table)))))))
+
 (defun find-function-noselect (function)
   "Returns a pair `(buffer . point)' pointing to the definition of FUNCTION.
 
       (or (eq def function)
 	  (if aliases
 	      (setq aliases (concat aliases
-				    (format ", which is an alias for %s"
+				    (format ", which is an alias for `%s'"
 					    (symbol-name def))))
-	    (setq aliases (format "an alias for %s" (symbol-name def)))))
+	    (setq aliases (format "`%s' an alias for `%s'"
+				  function (symbol-name def)))))
       (setq function (symbol-function function)
 	    def (symbol-function function)))
     (if aliases
 	(message aliases))
-    (setq library
-	  (cond ((eq (car-safe def) 'autoload)
-		 (nth 1 def))
-		((describe-function-find-file function))
-		((compiled-function-p def)
-		 (substring (compiled-function-annotation def) 0 -4))
-		((eq 'macro (car-safe def))
-		 (and (compiled-function-p (cdr def))
-		      (substring (compiled-function-annotation (cdr def)) 0 -4)))))
-    (if (null library)
-	(error (format "Don't know where `%s' is defined" function)))
-    (if (string-match "\\.el\\(c\\)\\'" library)
-	(setq library (substring library 0 (match-beginning 1))))
-    (let* ((path find-function-source-path)
-	   (filename (if (file-exists-p library)
-			 library
-		       (if (string-match "\\(\\.el\\)\\'" library)
-			   (setq library (substring library 0
-						    (match-beginning
-						     1))))
-		       (or (locate-library (concat library ".el") t path)
-			   (locate-library library t path)))))
-      (if (not filename)
-	  (error "The library \"%s\" is not in the path." library))
-      (with-current-buffer (find-file-noselect filename)
-	(save-match-data
-	  (let (;; avoid defconst, defgroup, defvar (any others?)
-		(regexp
-		 (format "^\\s-*(def[^cgv\W]\\w+\\*?\\s-+%s\\s-"
-			 (regexp-quote (symbol-name function))))
-		(syntable (syntax-table)))
-	    (set-syntax-table emacs-lisp-mode-syntax-table)
-	    (goto-char (point-min))
-	    (if (prog1
-		    (re-search-forward regexp nil t)
-		  (set-syntax-table syntable))
-		(progn
-		  (beginning-of-line)
-		  (cons (current-buffer) (point)))
-	      (error "Cannot find definition of `%s'" function))))))))
+    (let ((library
+	   (cond ((eq (car-safe def) 'autoload)
+		  (nth 1 def))
+		 ((describe-symbol-find-file function))
+		 ((compiled-function-p def)
+		  (substring (compiled-function-annotation def) 0 -4))
+		 ((eq 'macro (car-safe def))
+		  (and (compiled-function-p (cdr def))
+		       (substring (compiled-function-annotation (cdr def))
+				  0 -4))))))
+      (find-function-search-for-symbol function nil library))))
 
-(defun find-function-read-function ()
-  "Read and return a function, defaulting to the one near point.
+(defun find-function-read (&optional variable-p)
+  "Read and return an interned symbol, defaulting to the one near point.
 
-`function-at-point' is used to select the default function."
-  (let ((fn (function-at-point))
+If the optional VARIABLE-P is nil, then a function is gotten
+defaulting to the value of the function `function-at-point', otherwise 
+a variable is asked for, with the default coming from
+`variable-at-point'."
+  (let ((symb (funcall (if variable-p
+			   'function-at-point
+			 'variable-at-point)))
 	(enable-recursive-minibuffers t)
 	val)
     (setq val (completing-read
-	       (if fn
-		   (format "Find function (default %s): " fn)
-		 "Find function: ")
-	       obarray 'fboundp t nil 'function-history))
+	       (concat "Find "
+		       (if variable-p
+			   "variable"
+			 "function")
+		       (if symb
+			   (format " (default %s)" symb))
+		       ": ")
+	       obarray (if variable-p 'boundp 'fboundp)
+	       t nil 'function-history))
     (list (if (equal val "")
-	      fn (intern val)))))
+	      symb (intern val)))))
 
-(defun find-function-do-it (function switch-fn)
-  "Find Emacs Lisp FUNCTION in a buffer and display it with SWITCH-FN.
+(defun find-function-do-it (symbol variable-p switch-fn)
+  "Find Emacs Lisp SYMBOL in a buffer and display it with SWITCH-FN.
+If VARIABLE-P is nil, a function definition is searched for, otherwise 
+a variable definition is searched for.
+
 Point is saved in the buffer if it is one of the current buffers."
   (let ((orig-point (point))
 	(orig-buffers (buffer-list))
-	(buffer-point (find-function-noselect function)))
+	(buffer-point (funcall (if variable-p
+				   'find-variable-noselect
+				 'find-function-noselect)
+			       symbol)))
     (when buffer-point
       (funcall switch-fn (car buffer-point))
       (when (memq (car buffer-point) orig-buffers)
 
 The library where FUNCTION is defined is searched for in
 `find-function-source-path', if non `nil', otherwise in `load-path'."
-  (interactive (find-function-read-function))
-  (find-function-do-it function 'switch-to-buffer))
+  (interactive (find-function-read))
+  (find-function-do-it function nil 'switch-to-buffer))
 
 ;;;###autoload
 (defun find-function-other-window (function)
 
 The library where FUNCTION is defined is searched for in
 `find-function-source-path', if non `nil', otherwise in `load-path'."
-  (interactive (find-function-read-function))
-  (find-function-do-it function 'switch-to-buffer-other-window))
+  (interactive (find-function-read))
+  (find-function-do-it function nil 'switch-to-buffer-other-window))
 
 ;;;###autoload
 (defun find-function-other-frame (function)
 
 The library where FUNCTION is defined is searched for in
 `find-function-source-path', if non `nil', otherwise in `load-path'."
-  (interactive (find-function-read-function))
-  (find-function-do-it function 'switch-to-buffer-other-frame))
+  (interactive (find-function-read))
+  (find-function-do-it function nil 'switch-to-buffer-other-frame))
+
+(defun find-variable-noselect (variable)
+  "Returns a pair `(buffer . point)' pointing to the definition of SYMBOL.
+
+Finds the Emacs Lisp library containing the definition of SYMBOL
+in a buffer and the point of the definition.  The buffer is
+not selected.
+
+The library where VARIABLE is defined is searched for in
+`find-function-source-path', if non `nil', otherwise in `load-path'."
+  (if (not variable)
+      (error "You didn't specify a variable"))
+  (and (built-in-variable-type variable)
+       (error "%s is a primitive variable" variable))
+    (let ((library (describe-symbol-find-file variable)))
+      (find-function-search-for-symbol variable 'variable library)))
+
+;;;###autoload
+(defun find-variable (variable)
+  "Find the definition of the variable near point in the current window.
+
+Finds the Emacs Lisp library containing the definition of the variable
+near point (selected by `variable-at-point') in a buffer and
+places point before the definition.  Point is saved in the buffer if
+it is one of the current buffers.
+
+The library where VARIABLE is defined is searched for in
+`find-function-source-path', if non `nil', otherwise in `load-path'."
+  (interactive (find-function-read 'variable))
+  (find-function-do-it variable t 'switch-to-buffer))
+
+;;;###autoload
+(defun find-variable-other-window (variable)
+  "Find the definition of the variable near point in the other window.
+
+Finds the Emacs Lisp library containing the definition of the variable
+near point (selected by `variable-at-point') in a buffer and
+places point before the definition.  Point is saved in the buffer if
+it is one of the current buffers.
+
+The library where VARIABLE is defined is searched for in
+`find-function-source-path', if non `nil', otherwise in `load-path'."
+  (interactive (find-function-read 'variable))
+  (find-function-do-it variable t 'switch-to-buffer-other-window))
+
+;;;###autoload
+(defun find-variable-other-frame (variable)
+  "Find the definition of the variable near point in the another frame.
+
+Finds the Emacs Lisp library containing the definition of the variable
+near point (selected by `variable-at-point') in a buffer and
+places point before the definition.  Point is saved in the buffer if
+it is one of the current buffers.
+
+The library where VARIABLE is defined is searched for in
+`find-function-source-path', if non `nil', otherwise in `load-path'."
+  (interactive (find-function-read 'variable))
+  (find-function-do-it variable t 'switch-to-buffer-other-frame))
 
 ;;;###autoload
 (defun find-function-on-key (key)
     (when symb
       (find-function-other-window symb))))
 
+;;;###autoload
+(defun find-variable-at-point ()
+  "Find directly the function at point in the other window."
+  (interactive)
+  (let ((symb (variable-at-point)))
+    (when symb
+      (find-variable-other-window symb))))
+
 ;; (define-key ctl-x-map "F" 'find-function) ; conflicts with `facemenu-keymap'
-
 ;;;###autoload
 (define-key ctl-x-4-map "F" 'find-function-other-window)
 ;;;###autoload
 (define-key ctl-x-5-map "F" 'find-function-other-frame)
 ;;;###autoload
 (define-key ctl-x-map "K" 'find-function-on-key)
+;;;###autoload
+(define-key ctl-x-map "V" 'find-variable)
+;;;###autoload
+(define-key ctl-x-4-map "V" 'find-variable-other-window)
+;;;###autoload
+(define-key ctl-x-5-map "V" 'find-variable-other-frame)
 
 (provide 'find-func)
 ;;; find-func.el ends here
 
 ;;; Code:
 
+(defvar unsafe-list nil)
+(defvar subrs-used nil)
+(defvar subrs-called nil)
+
 ;; Set this to point to your XEmacs source directory.
-(setq emacs-source-directory "/net/prosper/opt/xemacs/editor/src")
+(defvar emacs-source-directory "/usr/src/xemacs/xemacs-20/src")
 
-;; Set this to the include directories neeed for compilation.  
-(setq include-directives "-I/net/prosper/opt/xemacs/editor/src -I/usr/dt/include -I/net/prosper/opt/SUNWmotif/include -I/net/prosper/opt/xemacs/editor/import/xpm/include -I/net/prosper/opt/xemacs/editor/import/include -I/usr/demo/SOUND/include -I/usr/openwin/include -I/usr/openwin/include/desktop -I/usr/openwin/include/desktop   -I/net/prosper/opt/xemacs/editor/src/../lwlib  -g -v -DNeedFunctionPrototypes -xildoff -I/usr/dt/include -I/net/prosper/opt/SUNWmotif/include -I/net/prosper/opt/xemacs/editor/import/xpm/include -I/net/prosper/opt/xemacs/editor/import/include -I/usr/demo/SOUND/include -I/usr/demo/SOUND/include")
+;;; Functions on this list are safe, even if they appear to be able
+;;; to call the target.
 
-;; Set this to the source files you want to check.
-(setq source-files
-  '(
-"EmacsFrame.c" "EmacsManager.c" "EmacsShell.c" "abbrev.c" "alloc.c"
-"blocktype.c" "buffer.c" "bytecode.c" "callint.c" "callproc.c" "casefiddle.c"
-"casetab.c" "cm.c" "cmds.c" "data.c" "debug.c" "device-stream.c"
-"device-tty.c" "device-x.c" "device.c" "dired.c" "doc.c" "doprnt.c"
-"dynarr.c""editfns.c" "elhash.c" "emacs.c" "eval.c" "event-Xt.c"
-"event-stream.c" "event-tty.c" "events.c" "extents.c" "faces.c" "fileio.c"
-"filelock.c" "filemode.c" "floatfns.c" "fns.c" "font-lock.c" "frame-tty.c"
-"frame-x.c" "frame.c" "getloadavg.c" "glyphs.c" "gmalloc.c" "hash.c"
-"indent.c" "insdel.c" "intl.c" "keyboard.c" "keymap.c" "lastfile.c" "lread.c"
-"lstream.c" "macros.c" "marker.c" "md5.c" "menubar-x.c" "menubar.c"
-"minibuf.c" "objects-x.c" "objects.c" "opaque.c" "print.c" "process.c"
-"pure.c" "redisplay-output.c" "redisplay-tty.c" "redisplay-x.c" "redisplay.c"
-"regex.c" "scrollbar.c" "search.c" "sound.c" "specifier.c" "sunplay.c"
-"sunpro.c" "symbols.c" "syntax.c" "sysdep.c" "terminfo.c" "toolbar-x.c"
-"toolbar.c" "tooltalk.c" "undo.c" "unexsol2.c" "vm-limit.c" "window.c"
-"xgccache.c" "xselect.c"))
+(defvar noreturn-list '(signal_error error Fthrow wrong_type_argument))
+
+;;; Try to load generated source-files
+(load-library (concat emacs-source-directory "/../lisp/source-files.el"))
+
+(defvar source-files nil
+  "Set this to the source files you want to check.")
 
 ;;;
 
 (defun find-gc-unsafe ()
-  (trace-call-tree nil)
+  (setq subrs-used nil)
+  (trace-call-tree t nil)
   (trace-use-tree)
+  (set-buffer (get-buffer-create "*gc-tmp*"))
+  (erase-buffer)
   (find-unsafe-funcs 'Fgarbage_collect)
-  (setq unsafe-list (sort unsafe-list
-			  (function (lambda (x y)
-				      (string-lessp (car x) (car y))))))
-  (princ (format "%s\n" unsafe-list))
+  (setq unsafe-list (sort unsafe-list 'find-gc-sort-p))
+  (insert (format "%s\n" unsafe-list))
   (setq unsafe-list nil)
-  (find-unsafe-funcs 'Fgarbage_collect_1)
-  (setq unsafe-list (sort unsafe-list
-			  (function (lambda (x y)
-				      (string-lessp (car x) (car y))))))
-  (princ (format "%s\n" unsafe-list)))
+  (find-unsafe-funcs 'garbage_collect_1)
+  (setq unsafe-list (sort unsafe-list 'find-gc-sort-p))
+  (insert (format "%s\n" unsafe-list))
+  (goto-char (point-min))
+  (while (search-forward ") (" nil t)
+    (replace-match ")
+ (" nil t))
+  )
 
+(defun find-gc-sort-p (x y)
+  (string-lessp (car x) (car y)))
 
 ;;; This does a depth-first search to find all functions that can
 ;;; ultimately call the function "target".  The result is an a-list
 	    (trace-unsafe (car used)))))))
 
 
-;;; Functions on this list are safe, even if they appear to be able
-;;; to call the target.
-
-(setq noreturn-list '( signal_error error Fthrow wrong_type_argument ))
-
-
 ;;; This produces an a-list of functions in subrs-called.  The cdr of
 ;;; each entry is a list of functions which the function in car calls.
 
-(defun trace-call-tree (&optional already-setup)
-  (or already-setup
-      (progn
-	(princ (format "Setting up directories...\n"))
-	;; Gee, wouldn't a built-in "system" function be handy here.
-	(call-process "sh" nil nil nil "-c" "rm -rf /tmp/esrc")
-	(call-process "sh" nil nil nil "-c" "mkdir /tmp/esrc")
-	(call-process "sh" nil nil nil "-c"
-		      (format "ln -s %s/*.[ch] /tmp/esrc"
-			      emacs-source-directory))))
+(defun trace-call-tree (&optional make-all delete-after)
   (save-excursion
-    (set-buffer (get-buffer-create "*Trace Call Tree*"))
     (setq subrs-called nil)
     (let ((case-fold-search nil)
-	  (files source-files)
-	  name entry)
-      (while files
-	(princ (format "Compiling %s...\n" (car files)))
-	(call-process "sh" nil nil nil "-c"
-	     (format "cd /tmp/esrc; gcc -dr -c %s /tmp/esrc/%s -o /dev/null"
-			      include-directives (car files)))
+	  name entry file)
+      ;; Stage one, make rtl files with make
+      (if make-all
+	  (call-process 
+	   "sh" nil nil nil "-c" 
+	   (format "cd %s; make dortl" emacs-source-directory file))
+	(dolist (file source-files)
+	  (princ (format "Compiling %s...\n" file))
+	  (call-process 
+	   "sh" nil nil nil "-c" 
+	   (format "cd %s; make %s.rtl" emacs-source-directory file))))
+      (set-buffer (get-buffer-create "*Trace Call Tree*"))
+      ;; Stage two, process them
+      (dolist (file source-files)
 	(erase-buffer)
-	(insert-file-contents (concat "/tmp/esrc/" (car files) ".rtl"))
+	(insert-file-contents (concat emacs-source-directory "/" file ".rtl"))
 	(while (re-search-forward ";; Function \\|(call_insn " nil t)
-	  (if (= (char-after (- (point) 3)) ?o)
-	      (progn
-		(looking-at "[a-zA-Z0-9_]+")
-		(setq name (intern (buffer-substring (match-beginning 0)
-						     (match-end 0))))
-		(princ (format "%s : %s\n" (car files) name))
-		(setq entry (list name)
-		      subrs-called (cons entry subrs-called)))
-	    (if (looking-at ".*\n?.*\"\\([A-Za-z0-9_]+\\)\"")
-		(progn
-		  (setq name (intern (buffer-substring (match-beginning 1)
-						       (match-end 1))))
-		  (or (memq name (cdr entry))
-		      (setcdr entry (cons name (cdr entry))))))))
-	;;(delete-file (concat "/tmp/esrc/" (car files) ".rtl"))
-	(setq files (cdr files))))))
+          (if (= (char-after (- (point) 3)) ?o)
+              (progn
+                (looking-at "[a-zA-Z0-9_]+")
+                (setq name (intern (buffer-substring (match-beginning 0)
+                                                     (match-end 0))))
+                (princ (format "%s : %s\n" file name))
+                (setq entry (list name)
+                      subrs-called (cons entry subrs-called)))
+            (if (looking-at ".*\n?.*\"\\([A-Za-z0-9_]+\\)\"")
+                (progn
+                  (setq name (intern (buffer-substring (match-beginning 1)
+                                                       (match-end 1))))
+                  (or (memq name (cdr entry))
+                      (setcdr entry (cons name (cdr entry)))))))))
+      (when delete-after
+	(dolist (file source-files)
+	  (delete-file (concat emacs-source-directory "/" file ".rtl"))))
+	    )))
 
 
 ;;; This produces an inverted a-list in subrs-used.  The cdr of each