;; 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.
;;; 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
;;; 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:
;;;
;;; 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
-;;; the whole form is evalled both at compile-time and at run-time.
+;;; o The form `eval-and-compile' is similar to `eval-when-compile',
+;;; 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.
;;;
(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.")
(defvar byte-compiler-error-flag)
(defconst byte-compile-initial-macro-environment
- (purecopy
- '((byte-compiler-options . (lambda (&rest forms)
- (apply 'byte-compiler-options-handler forms)))
- (eval-when-compile . (lambda (&rest body)
- (list 'quote (eval (byte-compile-top-level
- (cons 'progn body))))))
- (eval-and-compile . (lambda (&rest body)
- (eval (cons 'progn body))
- (cons 'progn body)))))
+ '((byte-compiler-options . (lambda (&rest forms)
+ (apply 'byte-compiler-options-handler forms)))
+ (eval-when-compile . (lambda (&rest body)
+ (list 'quote (eval (cons 'progn body)))))
+ (eval-and-compile . (lambda (&rest 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.")
(defconst byte-constant-limit 64
"Exclusive maximum index usable in the `byte-constant' opcode.")
-(defconst byte-goto-ops (purecopy
- '(byte-goto byte-goto-if-nil byte-goto-if-not-nil
- byte-goto-if-nil-else-pop
- byte-goto-if-not-nil-else-pop))
+(defconst byte-goto-ops
+ '(byte-goto byte-goto-if-nil byte-goto-if-not-nil
+ byte-goto-if-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-if-nil-else-pop byte-rel-goto-if-not-nil-else-pop))
+ '(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-codes for relative jumps.")
(byte-extrude-byte-code-vectors)
'(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)
(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-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
-NORECURSION is non-nil.
+Files in subdirectories of DIRECTORY are also processed unless
+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,
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
;; file if under Mule. If there are any extended characters in the
;; input file, use `escape-quoted' to make sure that both binary and
;; extended characters are output properly and distinguished properly.
- ;; Otherwise, use `raw-text' for maximum portability with non-Mule
+ ;; Otherwise, use `binary' for maximum portability with non-Mule
;; Emacsen.
(when (featurep '(or mule file-coding))
(defvar buffer-file-coding-system)
- (if (or (featurep '(not mule)) ;; Don't scan buffer if we are not muleized
- (save-excursion
- (set-buffer byte-compile-inbuffer)
+ (let (ces)
+ (if (featurep 'mule)
+ (save-excursion
+ (set-buffer byte-compile-inbuffer)
+ (goto-char (point-min))
+ ;; mrb- There must be a better way than skip-chars-forward
+ (skip-chars-forward (concat (char-to-string 0) "-"
+ (char-to-string 255)))
+ (if (eq (point) (point-max))
+ (setq ces 'binary)
+ (goto-char (point-min))
+ (while (< (point)(point-max))
+ (cond ((eq (char-after) ?\;)
+ (delete-region (point)(point-at-eol))
+ (if (eq (char-after) ?\n)
+ (delete-char 1)
+ (forward-char))
+ )
+ ((eq (char-after) ?\?)
+ (forward-char 2)
+ )
+ ((eq (char-after) ?\n)
+ (forward-char)
+ )
+ ((eq (char-after) ?\")
+ (forward-char)
+ (while (and (< (point)(point-max))
+ (not (when (eq (char-after) ?\")
+ (forward-char)
+ t)))
+ (if (eq (char-after) ?\\)
+ (forward-char 2)
+ (forward-char)))
+ )
+ (t
+ (forward-char))))
(goto-char (point-min))
- ;; mrb- There must be a better way than skip-chars-forward
(skip-chars-forward (concat (char-to-string 0) "-"
- (char-to-string 255)))
- (eq (point) (point-max))))
- (setq buffer-file-coding-system 'raw-text-unix)
- (insert "(require 'mule)\n;;;###coding system: escape-quoted\n")
- (setq buffer-file-coding-system 'escape-quoted)
- ;; #### Lazy loading not yet implemented for MULE files
- ;; mrb - Fix this someday.
- (save-excursion
- (set-buffer byte-compile-inbuffer)
- (setq byte-compile-dynamic nil
- byte-compile-dynamic-docstrings nil))
- ;;(external-debugging-output (prin1-to-string (buffer-local-variables))))
- ))
+ (char-to-string 255))))
+ (setq ces
+ (if (eq (point) (point-max))
+ (if (and (featurep 'utf-2000)
+ (re-search-backward "\\\\u[0-9A-Fa-f]+" nil t))
+ 'utf-8-unix
+ 'binary))))
+ (setq ces 'binary))
+ (if (eq ces 'binary)
+ (setq buffer-file-coding-system 'binary)
+ (cond ((eq ces 'utf-8-unix)
+ (insert "(require 'mule)\n;;;###coding system: utf-8-unix\n")
+ (setq buffer-file-coding-system 'utf-8-unix)
+ )
+ (t
+ (insert "(require 'mule)\n;;;###coding system: escape-quoted\n")
+ (setq buffer-file-coding-system 'escape-quoted)
+ ))
+ ;; #### Lazy loading not yet implemented for MULE files
+ ;; mrb - Fix this someday.
+ (save-excursion
+ (set-buffer byte-compile-inbuffer)
+ (setq byte-compile-dynamic nil
+ byte-compile-dynamic-docstrings nil))
+ ;; (external-debugging-output
+ ;; (prin1-to-string (buffer-local-variables)))
+ )))
)
(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-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.
- (when (null byte-compile-current-form)
+ ;; just as a real defvar would, but only in top-level forms with values.
+ (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)))
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