xemacs-beta: lisp/bytecomp.el comparison

comparison lisp/bytecomp.el @ 444:576fb035e263 r21-2-37

Import from CVS: tag r21-2-37

author	cvs
date	Mon, 13 Aug 2007 11:36:19 +0200
parents	abe6d1db359e
children	1ccc32a20af4

comparison

equal deleted inserted replaced

-:a8296e22da4e
+:576fb035e263
 ;;	Ben Wing <ben@xemacs.org>
 ;;	Martin Buchholz <martin@xemacs.org>
 ;;	Richard Stallman <rms@gnu.org>
 ;; Keywords: internal lisp
-(defconst byte-compile-version (purecopy  "2.27 XEmacs; 2000-09-12."))
+(defconst byte-compile-version "2.27 XEmacs; 2000-09-12.")
 ;; This file is part of XEmacs.
 ;; XEmacs is free software; you can redistribute it and/or modify it
 ;; under the terms of the GNU General Public License as published by
 ;;;					    symbols)
 ;;; byte-compile-emacs19-compatibility	Whether the compiler should
 ;;;				generate .elc files which can be loaded into
 ;;;				generic emacs 19.
 ;;; emacs-lisp-file-regexp	Regexp for the extension of source-files;
-;;;				see also the function byte-compile-dest-file.
+;;;				see also the function `byte-compile-dest-file'.
 ;;; byte-compile-overwrite-file	If nil, delete old .elc files before saving.
 ;;;
 ;;; Most of the above parameters can also be set on a file-by-file basis; see
 ;;; the documentation of the `byte-compiler-options' macro.
 ;;;	defined with `defun' by using the `proclaim-inline' form like so:
 ;;;		(proclaim-inline my-function)
 ;;;	This is, in fact, exactly what `defsubst' does.  To make a function no
 ;;;	longer be inline, you must use `proclaim-notinline'.  Beware that if
 ;;;	you define a function with `defsubst' and later redefine it with
-;;;	`defun', it will still be open-coded until you use proclaim-notinline.
+;;;	`defun', it will still be open-coded until you use `proclaim-notinline'.
 ;;;
 ;;;  o	You can also open-code one particular call to a function without
 ;;;	open-coding all calls.  Use the 'inline' form to do this, like so:
 ;;;
 ;;;		(inline (foo 1 2 3))	;; `foo' will be open-coded
 ;;;	the compilation environment in the same way that it remembers macro
 ;;;	definitions.
 ;;;
 ;;;  o  Forms like ((lambda ...) ...) are open-coded.
 ;;;
-;;;  o  The form `eval-when-compile' is like progn, except that the body
+;;;  o  The form `eval-when-compile' is like `progn', except that the body
 ;;;     is evaluated at compile-time.  When it appears at top-level, this
 ;;;     is analogous to the Common Lisp idiom (eval-when (compile) ...).
 ;;;     When it does not appear at top-level, it is similar to the
 ;;;     Common Lisp #. reader macro (but not in interpreted code).
 ;;;
-;;;  o  The form `eval-and-compile' is similar to eval-when-compile, but
+;;;  o  The form `eval-and-compile' is similar to `eval-when-compile',
-;;;	the whole form is evalled both at compile-time and at run-time.
+;;;     but the whole form is evalled both at compile-time and at run-time.
 ;;;
 ;;;  o  The command M-x byte-compile-and-load-file does what you'd think.
 ;;;
-;;;  o  The command compile-defun is analogous to eval-defun.
+;;;  o  The command `compile-defun' is analogous to `eval-defun'.
 ;;;
-;;;  o  If you run byte-compile-file on a filename which is visited in a
+;;;  o  If you run `byte-compile-file' on a filename which is visited in a
 ;;;     buffer, and that buffer is modified, you are asked whether you want
 ;;;     to save the buffer before compiling.
 ;;;
 ;;;  o  You can add this to /etc/magic to make file(1) recognize the files
 ;;;     generated by this compiler:
 (t
 (defmacro byte-compile-single-version () nil)
 (defmacro byte-compile-version-cond (cond) cond)))
 )
-(defvar emacs-lisp-file-regexp (purecopy "\\.el$")
+(defvar emacs-lisp-file-regexp "\\.el$"
 "*Regexp which matches Emacs Lisp source files.
 You may want to redefine `byte-compile-dest-file' if you change this.")
 ;; This enables file name handlers such as jka-compr
 ;; to remove parts of the file name that should not be copied
 (defvar byte-compile-free-assignments)
 (defvar byte-compiler-error-flag)
 (defconst byte-compile-initial-macro-environment
-(purecopy
+'((byte-compiler-options . (lambda (&rest forms)
-'((byte-compiler-options . (lambda (&rest forms)
+			       (apply 'byte-compiler-options-handler forms)))
-				(apply 'byte-compiler-options-handler forms)))
+(eval-when-compile . (lambda (&rest body)
-(eval-when-compile . (lambda (&rest body)
+			   (list 'quote (eval (cons 'progn body)))))
-			    (list 'quote (eval (byte-compile-top-level
+(eval-and-compile . (lambda (&rest body)
-						(cons 'progn body))))))
+			  (eval (cons 'progn body))
-(eval-and-compile . (lambda (&rest body)
+			  (cons 'progn body))))
-			   (eval (cons 'progn body))
-			   (cons 'progn body)))))
 "The default macro-environment passed to macroexpand by the compiler.
 Placing a macro here will cause a macro to have different semantics when
 expanded by the compiler as when expanded by the interpreter.")
 (defvar byte-compile-macro-environment byte-compile-initial-macro-environment
 (byte-defop 192  1 byte-constant	"for reference to a constant")
 ;; codes 193-255 are consumed by byte-constant.
 (defconst byte-constant-limit 64
 "Exclusive maximum index usable in the `byte-constant' opcode.")
-(defconst byte-goto-ops (purecopy
+(defconst byte-goto-ops
-			 '(byte-goto byte-goto-if-nil byte-goto-if-not-nil
+'(byte-goto byte-goto-if-nil byte-goto-if-not-nil
-			   byte-goto-if-nil-else-pop
+	      byte-goto-if-nil-else-pop
-			   byte-goto-if-not-nil-else-pop))
+	      byte-goto-if-not-nil-else-pop)
 "List of byte-codes whose offset is a pc.")
 (defconst byte-goto-always-pop-ops
-(purecopy '(byte-goto-if-nil byte-goto-if-not-nil)))
+'(byte-goto-if-nil byte-goto-if-not-nil))
 (defconst byte-rel-goto-ops
-(purecopy '(byte-rel-goto byte-rel-goto-if-nil byte-rel-goto-if-not-nil
+'(byte-rel-goto byte-rel-goto-if-nil byte-rel-goto-if-not-nil
-	      byte-rel-goto-if-nil-else-pop byte-rel-goto-if-not-nil-else-pop))
+		  byte-rel-goto-if-nil-else-pop byte-rel-goto-if-not-nil-else-pop)
 "byte-codes for relative jumps.")
 (byte-extrude-byte-code-vectors)
 ;;; lapcode generator
 (setcar (cdr (cdr (assq 'file-format byte-compiler-legal-options)))
 	  (if (byte-compile-version-cond byte-compile-emacs19-compatibility)
 	      '(emacs19) '(emacs20)))))
 ;; now we can copy it.
-(setq byte-compiler-legal-options (purecopy byte-compiler-legal-options))
+(setq byte-compiler-legal-options byte-compiler-legal-options)
 (defun byte-compiler-options-handler (&rest args)
 (let (key val desc choices)
 (while args
 (if (or (atom (car args)) (nthcdr 2 (car args)) (null (cdr (car args))))
 		   (not (= 0 (logand (cdr (car rest))
 				     byte-compile-global-bit))))
 	      (setq var nil))
 	  (setq rest (cdr rest)))
 	;; if var is nil at this point, it's a defvar in this file.
-	(not var))))
+	(not var))
+;; Perhaps (eval-when-compile (defvar foo))
+(and (boundp 'current-load-list)
+	   (memq var current-load-list))))
 ;;; If we have compiled bindings of variables which have no referents, warn.
 (defun byte-compile-warn-about-unused-variables ()
 (let ((rest byte-compile-bound-variables)
 ;;;###autoload
 (defun byte-recompile-directory (directory &optional arg norecursion force)
 "Recompile every `.el' file in DIRECTORY that needs recompilation.
 This is if a `.elc' file exists but is older than the `.el' file.
-Files in subdirectories of DIRECTORY are processed also unless argument
+Files in subdirectories of DIRECTORY are also processed unless
-NORECURSION is non-nil.
+optional argument NORECURSION is non-nil.
 If the `.elc' file does not exist, normally the `.el' file is *not* compiled.
 But a prefix argument (optional second arg) means ask user,
 for each such `.el' file, whether to compile it.  Prefix argument 0 means
 don't ask and compile the file anyway.
 A nonzero prefix argument also means ask about each subdirectory.
-If the fourth argument FORCE is non-nil,
+If the fourth optional argument FORCE is non-nil,
 recompile every `.el' file that already has a `.elc' file."
 (interactive "DByte recompile directory: \nP")
 (if arg
 (setq arg (prefix-numeric-value arg)))
 (if noninteractive
 		(if cell (setcdr cell
 				 (logior (cdr cell)
 					 (if (eq base-op 'byte-varset)
 					     byte-compile-assigned-bit
 					   byte-compile-referenced-bit)))))
+	      (and (boundp 'current-load-list)
+		   (memq var current-load-list))
 	      (if (eq base-op 'byte-varset)
 		  (or (memq var byte-compile-free-assignments)
 		      (progn
 			(byte-compile-warn "assignment to free variable %s"
 					   var)
 (when (memq 'free-vars byte-compile-warnings)
 (push (cons var byte-compile-global-bit) byte-compile-bound-variables))
 (byte-compile-body-do-effect
 (list
 ;; Put the defined variable in this library's load-history entry
-;; just as a real defvar would, but only in top-level forms.
+;; just as a real defvar would, but only in top-level forms with values.
-(when (null byte-compile-current-form)
+(when (and (> (length form) 2)
+		 (null byte-compile-current-form))
 	`(push ',var current-load-list))
 (when (> (length form) 3)
 	(when (and string (not (stringp string)))
 	  (byte-compile-warn "Third arg to %s %s is not a string: %s"
 			     fun var string))
 (defun batch-byte-compile ()
 "Run `byte-compile-file' on the files remaining on the command line.
 Use this from the command line, with `-batch';
 it won't work in an interactive Emacs.
 Each file is processed even if an error occurred previously.
-For example, invoke \"xemacs -batch -f batch-byte-compile $emacs/ ~/*.el\""
+For example, invoke \"xemacs -batch -f batch-byte-compile $emacs/ ~/*.el\"."
 ;; command-line-args-left is what is left of the command line (from
 ;; startup.el)
 (defvar command-line-args-left)	;Avoid 'free variable' warning
 (if (not noninteractive)
 (error "`batch-byte-compile' is to be used only with -batch"))

Mercurial > hg > xemacs-beta

comparison lisp/bytecomp.el @ 444:576fb035e263 r21-2-37