git.chise.org Git - chise/xemacs-chise.git.1/blob - lisp/bytecomp-runtime.el

   1 ;;; bytecomp-runtime.el --- byte-compiler support for inlining
   2
   3 ;; Copyright (C) 1992, 1997 Free Software Foundation, Inc.
   4
   5 ;; Author: Jamie Zawinski <jwz@jwz.org>
   6 ;; Author: Hallvard Furuseth <hbf@ulrik.uio.no>
   7 ;; Maintainer: XEmacs Development Team
   8 ;; Keywords: internal, dumped
   9
  10 ;; This file is part of XEmacs.
  11
  12 ;; XEmacs is free software; you can redistribute it and/or modify it
  13 ;; under the terms of the GNU General Public License as published by
  14 ;; the Free Software Foundation; either version 2, or (at your option)
  15 ;; any later version.
  16
  17 ;; XEmacs is distributed in the hope that it will be useful, but
  18 ;; WITHOUT ANY WARRANTY; without even the implied warranty of
  19 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20 ;; General Public License for more details.
  21
  22 ;; You should have received a copy of the GNU General Public License
  23 ;; along with XEmacs; see the file COPYING.  If not, write to the
  24 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  25 ;; Boston, MA 02111-1307, USA.
  26
  27 ;;; Synched up with: FSF 19.30.
  28
  29 ;;; Commentary:
  30
  31 ;; This file is dumped with XEmacs.
  32
  33 ;; The code in this file should always be loaded, because it defines things
  34 ;; like "defsubst" which should work interpreted as well.  The code in
  35 ;; bytecomp.el and byte-optimize.el can be loaded as needed.
  36
  37 ;; interface to selectively inlining functions.
  38 ;; This only happens when source-code optimization is turned on.
  39
  40 ;;; Code:
  41
  42 ;; Redefined in byte-optimize.el.
  43 ;; This is not documented--it's not clear that we should promote it.
  44 (fset 'inline 'progn)
  45 (put 'inline 'lisp-indent-hook 0)
  46
  47
  48 ;;; Interface to inline functions.
  49
  50 ;; FSF comments the next two out, but I see no reason to do so. --ben
  51 (defmacro proclaim-inline (&rest fns)
  52   "Cause the named functions to be open-coded when called from compiled code.
  53 They will only be compiled open-coded when `byte-optimize' is true."
  54   (cons 'eval-and-compile
  55         (apply
  56          'nconc
  57          (mapcar
  58           #'(lambda (x)
  59               `((or (memq (get ',x 'byte-optimizer)
  60                           '(nil byte-compile-inline-expand))
  61                     (error
  62                      "%s already has a byte-optimizer, can't make it inline"
  63                      ',x))
  64                 (put ',x 'byte-optimizer 'byte-compile-inline-expand)))
  65           fns))))
  66
  67
  68 (defmacro proclaim-notinline (&rest fns)
  69   "Cause the named functions to no longer be open-coded."
  70   (cons 'eval-and-compile
  71         (apply
  72          'nconc
  73          (mapcar
  74           #'(lambda (x)
  75               `((if (eq (get ',x 'byte-optimizer)
  76                         'byte-compile-inline-expand)
  77                     (put ',x 'byte-optimizer nil))))
  78           fns))))
  79
  80 ;; This has a special byte-hunk-handler in bytecomp.el.
  81 (defmacro defsubst (name arglist &rest body)
  82   "Define an inline function.  The syntax is just like that of `defun'."
  83   (or (memq (get name 'byte-optimizer)
  84             '(nil byte-compile-inline-expand))
  85       (error "`%s' is a primitive" name))
  86   (list 'prog1
  87         (cons 'defun (cons name (cons arglist body)))
  88         (list 'proclaim-inline name)))
  89 ; Instead of the above line, FSF has this:
  90 ;       (list 'eval-and-compile
  91 ;             (list 'put (list 'quote name)
  92 ;                   ''byte-optimizer ''byte-compile-inline-expand))))
  93
  94 (defun make-obsolete (fn new)
  95   "Make the byte-compiler warn that FUNCTION is obsolete.
  96 The warning will say that NEW should be used instead.
  97 If NEW is a string, that is the `use instead' message."
  98   (interactive "aMake function obsolete: \nxObsoletion replacement: ")
  99   (let ((handler (get fn 'byte-compile)))
 100     (if (eq 'byte-compile-obsolete handler)
 101         (setcar (get fn 'byte-obsolete-info) new)
 102       (put fn 'byte-obsolete-info (cons new handler))
 103       (put fn 'byte-compile 'byte-compile-obsolete)))
 104   fn)
 105
 106 (defun make-obsolete-variable (var new)
 107   "Make the byte-compiler warn that VARIABLE is obsolete,
 108 and NEW should be used instead.  If NEW is a string, then that is the
 109 `use instead' message."
 110   (interactive
 111    (list
 112     (let ((str (completing-read "Make variable obsolete: " obarray 'boundp t)))
 113       (if (equal str "") (error ""))
 114       (intern str))
 115     (car (read-from-string (read-string "Obsoletion replacement: ")))))
 116   (put var 'byte-obsolete-variable new)
 117   var)
 118
 119 ;; By overwhelming demand, we separate out truly obsolete symbols from
 120 ;; those that are present for GNU Emacs compatibility.
 121 (defun make-compatible (fn new)
 122   "Make the byte-compiler know that FUNCTION is provided for compatibility.
 123 The warning will say that NEW should be used instead.
 124 If NEW is a string, that is the `use instead' message."
 125   (interactive "aMake function compatible: \nxCompatible replacement: ")
 126   (let ((handler (get fn 'byte-compile)))
 127     (if (eq 'byte-compile-compatible handler)
 128         (setcar (get fn 'byte-compatible-info) new)
 129       (put fn 'byte-compatible-info (cons new handler))
 130       (put fn 'byte-compile 'byte-compile-compatible)))
 131   fn)
 132
 133 (defun make-compatible-variable (var new)
 134   "Make the byte-compiler know that VARIABLE is provided for compatibility.
 135 and NEW should be used instead.  If NEW is a string, then that is the
 136 `use instead' message."
 137   (interactive
 138    (list
 139     (let ((str (completing-read "Make variable compatible: "
 140                                 obarray 'boundp t)))
 141       (if (equal str "") (error ""))
 142       (intern str))
 143     (car (read-from-string (read-string "Compatible replacement: ")))))
 144   (put var 'byte-compatible-variable new)
 145   var)
 146
 147 (put 'dont-compile 'lisp-indent-hook 0)
 148 (defmacro dont-compile (&rest body)
 149   "Like `progn', but the body always runs interpreted (not compiled).
 150 If you think you need this, you're probably making a mistake somewhere."
 151   (list 'eval (list 'quote (if (cdr body) (cons 'progn body) (car body)))))
 152
 153 \f
 154 ;;; interface to evaluating things at compile time and/or load time
 155 ;;; these macro must come after any uses of them in this file, as their
 156 ;;; definition in the file overrides the magic definitions on the
 157 ;;; byte-compile-macro-environment.
 158
 159 (put 'eval-when-compile 'lisp-indent-hook 0)
 160 (defmacro eval-when-compile (&rest body)
 161   "Like `progn', but evaluates the body at compile time.
 162 The result of the body appears to the compiler as a quoted constant."
 163   ;; Not necessary because we have it in b-c-initial-macro-environment
 164   ;; (list 'quote (eval (cons 'progn body)))
 165   (cons 'progn body))
 166
 167 (put 'eval-and-compile 'lisp-indent-hook 0)
 168 (defmacro eval-and-compile (&rest body)
 169   "Like `progn', but evaluates the body at compile time and at load time."
 170   ;; Remember, it's magic.
 171   (cons 'progn body))
 172
 173 ;;; From Emacs 20.
 174 (put 'eval-when-feature 'lisp-indent-hook 1)
 175 (defmacro eval-when-feature (feature &rest body)
 176   "Run the body forms when FEATURE is featurep, be it now or later.
 177 Called (eval-when-feature (FEATURE [. FILENAME]) BODYFORMS...).
 178 If (featurep 'FEATURE), evals now; otherwise adds an elt to
 179 `after-load-alist' (which see), using FEATURE as filename if FILENAME is nil."
 180   (let ((file (or (cdr feature) (symbol-name (car feature)))))
 181     `(let ((bodythunk #'(lambda () ,@body)))
 182        (if (featurep ',(car feature))
 183            (funcall bodythunk)
 184          (setq after-load-alist (cons '(,file . (list 'lambda '() bodythunk))
 185                                       after-load-alist))))))
 186
 187
 188 \f
 189 ;;; Interface to file-local byte-compiler parameters.
 190 ;;; Redefined in bytecomp.el.
 191
 192 ;;; The great RMS speaketh:
 193 ;;;
 194 ;;; I nuked this because it's not a good idea for users to think of
 195 ;;; using it.  These options are a matter of installation preference,
 196 ;;; and have nothing to do with particular source files; it's a
 197 ;;; mistake to suggest to users that they should associate these with
 198 ;;; particular source files.  There is hardly any reason to change
 199 ;;; these parameters, anyway.  --rms.
 200 ;;;
 201 ;;; But I'll leave this stuff alone. --ben
 202
 203 (put 'byte-compiler-options 'lisp-indent-hook 0)
 204 (defmacro byte-compiler-options (&rest args)
 205   "Set some compilation-parameters for this file.
 206 This will affect only the file in which it appears; this does nothing when
 207 evaluated, or when loaded from a .el file.
 208
 209 Each argument to this macro must be a list of a key and a value.
 210
 211   Keys:           Values:               Corresponding variable:
 212
 213   verbose         t, nil                byte-compile-verbose
 214   optimize        t, nil, source, byte  byte-optimize
 215   warnings        list of warnings      byte-compile-warnings
 216   file-format     emacs19, emacs20      byte-compile-emacs19-compatibility
 217
 218 The value specified with the `warnings' option must be a list, containing
 219 some subset of the following flags:
 220
 221   free-vars     references to variables not in the current lexical scope.
 222   unused-vars   references to non-global variables bound but not referenced.
 223   unresolved    calls to unknown functions.
 224   callargs      lambda calls with args that don't match the definition.
 225   redefine      function cell redefined from a macro to a lambda or vice
 226                 versa, or redefined to take a different number of arguments.
 227
 228 If the first element if the list is `+' or `-' then the specified elements
 229 are added to or removed from the current set of warnings, instead of the
 230 entire set of warnings being overwritten.
 231
 232 For example, something like this might appear at the top of a source file:
 233
 234     (byte-compiler-options
 235       (optimize t)
 236       (warnings (- callargs))           ; Don't warn about arglist mismatch
 237       (warnings (+ unused-vars))        ; Do warn about unused bindings
 238       (file-format emacs19))"
 239   nil)
 240
 241 ;;; bytecomp-runtime.el ends here