code.delx.au - gnu-emacs/blob - lisp/progmodes/cc-bytecomp.el

   1 ;;; cc-bytecomp.el --- compile time setup for proper compilation
   2
   3 ;; Copyright (C) 2000-2013 Free Software Foundation, Inc.
   4
   5 ;; Author:     Martin Stjernholm
   6 ;; Maintainer: bug-cc-mode@gnu.org
   7 ;; Created:    15-Jul-2000
   8 ;; Keywords:   c languages
   9 ;; Package:    cc-mode
  10
  11 ;; This file is part of GNU Emacs.
  12
  13 ;; GNU Emacs is free software: you can redistribute it and/or modify
  14 ;; it under the terms of the GNU General Public License as published by
  15 ;; the Free Software Foundation, either version 3 of the License, or
  16 ;; (at your option) any later version.
  17
  18 ;; GNU Emacs is distributed in the hope that it will be useful,
  19 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  20 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21 ;; GNU General Public License for more details.
  22
  23 ;; You should have received a copy of the GNU General Public License
  24 ;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
  25
  26 ;;; Commentary:
  27
  28 ;; This file is used to ensure that the CC Mode files are correctly
  29 ;; compiled regardless the environment (e.g. if an older CC Mode with
  30 ;; outdated macros are loaded during compilation).  It also provides
  31 ;; features to defeat the compiler warnings for selected symbols.
  32 ;;
  33 ;; There's really nothing CC Mode specific here; this functionality
  34 ;; ought to be provided by the byte compilers or some accompanying
  35 ;; library.  To use it from some package "foo.el", begin by putting
  36 ;; the following blurb at the top of the file:
  37 ;;
  38 ;;   (eval-when-compile
  39 ;;     (let ((load-path
  40 ;;            (if (and (boundp 'byte-compile-dest-file)
  41 ;;                     (stringp byte-compile-dest-file))
  42 ;;                (cons (file-name-directory byte-compile-dest-file) load-path)
  43 ;;              load-path)))
  44 ;;       (load "cc-bytecomp" nil t))
  45 ;;
  46 ;; This (unfortunately rather clumsy) form will ensure that the
  47 ;; cc-bytecomp.el in the same directory as foo.el is loaded during
  48 ;; byte compilation of the latter.
  49 ;;
  50 ;; At the end of foo.el there should normally be a "(provide 'foo)".
  51 ;; Replace it with "(cc-provide 'foo)"; that is necessary to restore
  52 ;; the environment after the byte compilation.  If you don't have a
  53 ;; `provide' at the end, you have to add the following as the very
  54 ;; last form in the file:
  55 ;;
  56 ;;   (eval-when-compile (cc-bytecomp-restore-environment))
  57 ;;
  58 ;; Now everything is set to use the various functions and macros in
  59 ;; this package.
  60 ;;
  61 ;; If your package is split into several files, you should use
  62 ;; `cc-require', `cc-require-when-compile' or `cc-load' to load them.
  63 ;; That ensures that the files in the same directory always are
  64 ;; loaded, to avoid mixup with other versions of them that might exist
  65 ;; elsewhere in the load path.
  66 ;;
  67 ;; To suppress byte compiler warnings, use the macros
  68 ;; `cc-bytecomp-defun', `cc-bytecomp-defvar',
  69 ;; `cc-bytecomp-obsolete-fun', and `cc-bytecomp-obsolete-var'.
  70 ;;
  71 ;; This file is not used at all after the package has been byte
  72 ;; compiled.  It is however necessary when running uncompiled.
  73
  74 \f
  75 ;;; Code:
  76
  77 (defvar cc-bytecomp-unbound-variables nil)
  78 (defvar cc-bytecomp-original-functions nil)
  79 (defvar cc-bytecomp-original-properties nil)
  80 (defvar cc-bytecomp-loaded-files nil)
  81 (defvar cc-bytecomp-environment-set nil)
  82
  83 (defmacro cc-bytecomp-debug-msg (&rest args)
  84   ;;`(message ,@args)
  85   )
  86
  87 (defun cc-bytecomp-setup-environment ()
  88   ;; Eval'ed during compilation to setup variables, functions etc
  89   ;; declared with `cc-bytecomp-defvar' et al.
  90   (if (not load-in-progress)
  91       ;; Look at `load-in-progress' to tell whether we're called
  92       ;; directly in the file being compiled or just from some file
  93       ;; being loaded during compilation.
  94       (let (p)
  95         (if cc-bytecomp-environment-set
  96             (error "Byte compilation environment already set - \
  97 perhaps a `cc-bytecomp-restore-environment' is forgotten somewhere"))
  98         (setq p cc-bytecomp-unbound-variables)
  99         (while p
 100           (if (not (boundp (car p)))
 101               (progn
 102                 (eval `(defvar ,(car p)))
 103                 (set (car p) (intern (concat "cc-bytecomp-ignore-var:"
 104                                              (symbol-name (car p)))))
 105                 (cc-bytecomp-debug-msg
 106                  "cc-bytecomp-setup-environment: Covered variable %s"
 107                  (car p))))
 108           (setq p (cdr p)))
 109         (setq p cc-bytecomp-original-functions)
 110         (while p
 111           (let ((fun (car (car p)))
 112                 (temp-macro (car (cdr (car p)))))
 113             (if (not (fboundp fun))
 114                 (if temp-macro
 115                     (progn
 116                       (eval `(defmacro ,fun ,@temp-macro))
 117                       (cc-bytecomp-debug-msg
 118                        "cc-bytecomp-setup-environment: Bound macro %s" fun))
 119                   (fset fun (intern (concat "cc-bytecomp-ignore-fun:"
 120                                             (symbol-name fun))))
 121                   (cc-bytecomp-debug-msg
 122                    "cc-bytecomp-setup-environment: Covered function %s" fun))))
 123           (setq p (cdr p)))
 124         (setq p cc-bytecomp-original-properties)
 125         (while p
 126           (let ((sym (car (car (car p))))
 127                 (prop (cdr (car (car p))))
 128                 (tempdef (car (cdr (car p)))))
 129             (put sym prop tempdef)
 130             (cc-bytecomp-debug-msg
 131              "cc-bytecomp-setup-environment: Bound property %s for %s to %s"
 132              prop sym tempdef))
 133           (setq p (cdr p)))
 134         (setq cc-bytecomp-environment-set t)
 135         (cc-bytecomp-debug-msg
 136          "cc-bytecomp-setup-environment: Done"))))
 137
 138 (defun cc-bytecomp-restore-environment ()
 139   ;; Eval'ed during compilation to restore variables, functions etc
 140   ;; declared with `cc-bytecomp-defvar' et al.
 141   (if (not load-in-progress)
 142       (let (p)
 143         (setq p cc-bytecomp-unbound-variables)
 144         (while p
 145           (let ((var (car p)))
 146             (if (boundp var)
 147                 (if (eq (intern (concat "cc-bytecomp-ignore-var:"
 148                                         (symbol-name var)))
 149                         (symbol-value var))
 150                     (progn
 151                       (makunbound var)
 152                       (cc-bytecomp-debug-msg
 153                        "cc-bytecomp-restore-environment: Unbound variable %s"
 154                        var))
 155                   (cc-bytecomp-debug-msg
 156                    "cc-bytecomp-restore-environment: Not restoring variable %s"
 157                    var))))
 158           (setq p (cdr p)))
 159         (setq p cc-bytecomp-original-functions)
 160         (while p
 161           (let ((fun (car (car p)))
 162                 (temp-macro (car (cdr (car p))))
 163                 (def (car (cdr (cdr (car p))))))
 164             (if (fboundp fun)
 165                 (if (eq (or temp-macro
 166                             (intern (concat "cc-bytecomp-ignore-fun:"
 167                                             (symbol-name fun))))
 168                            (symbol-function fun))
 169                     (if (eq def 'unbound)
 170                         (progn
 171                           (fmakunbound fun)
 172                           (cc-bytecomp-debug-msg
 173                            "cc-bytecomp-restore-environment: Unbound function %s"
 174                            fun))
 175                       (fset fun def)
 176                       (cc-bytecomp-debug-msg
 177                        "cc-bytecomp-restore-environment: Restored function %s"
 178                        fun))
 179                   (cc-bytecomp-debug-msg
 180                    "cc-bytecomp-restore-environment: Not restoring function %s"
 181                    fun))))
 182           (setq p (cdr p)))
 183         (setq p cc-bytecomp-original-properties)
 184         (while p
 185           (let ((sym (car (car (car p))))
 186                 (prop (cdr (car (car p))))
 187                 (tempdef (car (cdr (car p))))
 188                 (origdef (cdr (cdr (car p)))))
 189             (if (eq (get sym prop) tempdef)
 190                 (progn
 191                   (put sym prop origdef)
 192                   (cc-bytecomp-debug-msg
 193                    "cc-bytecomp-restore-environment: Restored property %s for %s to %s"
 194                    prop sym origdef))
 195               (cc-bytecomp-debug-msg
 196                "cc-bytecomp-restore-environment: Not restoring property %s for %s"
 197                prop sym)))
 198           (setq p (cdr p)))
 199         (setq cc-bytecomp-environment-set nil)
 200         (cc-bytecomp-debug-msg
 201          "cc-bytecomp-restore-environment: Done"))))
 202
 203 (eval
 204  ;; This eval is to avoid byte compilation of the function below.
 205  ;; There's some bug in XEmacs 21.4.6 that can cause it to dump core
 206  ;; here otherwise.  My theory is that `cc-bytecomp-load' might be
 207  ;; redefined recursively during the `load' inside it, and if it in
 208  ;; that case is byte compiled then the byte interpreter gets
 209  ;; confused.  I haven't succeeded in isolating the bug, though. /mast
 210
 211  '(defun cc-bytecomp-load (cc-part)
 212     ;; Eval'ed during compilation to load a CC Mode file from the source
 213     ;; directory (assuming it's the same as the compiled file
 214     ;; destination dir).
 215     (if (and (boundp 'byte-compile-dest-file)
 216              (stringp byte-compile-dest-file))
 217         (progn
 218           (cc-bytecomp-restore-environment)
 219           (let ((load-path
 220                  (cons (file-name-directory byte-compile-dest-file)
 221                        load-path))
 222                 (cc-file (concat cc-part ".el")))
 223             (if (member cc-file cc-bytecomp-loaded-files)
 224                 ()
 225               (setq cc-bytecomp-loaded-files
 226                     (cons cc-file cc-bytecomp-loaded-files))
 227               (cc-bytecomp-debug-msg
 228                "cc-bytecomp-load: Loading %S" cc-file)
 229               (load cc-file nil t t)
 230               (cc-bytecomp-debug-msg
 231                "cc-bytecomp-load: Loaded %S" cc-file)))
 232           (cc-bytecomp-setup-environment)
 233           t))))
 234
 235 (defmacro cc-require (cc-part)
 236   "Force loading of the corresponding .el file in the current directory
 237 during compilation, but compile in a `require'.  Don't use within
 238 `eval-when-compile'.
 239
 240 Having cyclic cc-require's will result in infinite recursion.  That's
 241 somewhat intentional."
 242   `(progn
 243      (eval-when-compile (cc-bytecomp-load (symbol-name ,cc-part)))
 244      (require ,cc-part)))
 245
 246 (defmacro cc-provide (feature)
 247   "A replacement for the `provide' form that restores the environment
 248 after the compilation.  Don't use within `eval-when-compile'."
 249   `(progn
 250      (eval-when-compile (cc-bytecomp-restore-environment))
 251      (provide ,feature)))
 252
 253 (defmacro cc-load (cc-part)
 254   "Force loading of the corresponding .el file in the current directory
 255 during compilation.  Don't use outside `eval-when-compile' or
 256 `eval-and-compile'.
 257
 258 Having cyclic cc-load's will result in infinite recursion.  That's
 259 somewhat intentional."
 260   `(or (and (featurep 'cc-bytecomp)
 261             (cc-bytecomp-load ,cc-part))
 262        (load ,cc-part nil t nil)))
 263
 264 (defmacro cc-require-when-compile (cc-part)
 265   "Force loading of the corresponding .el file in the current directory
 266 during compilation, but do a compile time `require' otherwise.  Don't
 267 use within `eval-when-compile'."
 268   `(eval-when-compile
 269      (if (and (featurep 'cc-bytecomp)
 270               (cc-bytecomp-is-compiling))
 271          (if (or (not load-in-progress)
 272                  (not (featurep ,cc-part)))
 273              (cc-bytecomp-load (symbol-name ,cc-part)))
 274        (require ,cc-part))))
 275
 276 (defmacro cc-external-require (feature)
 277   "Do a `require' of an external package.
 278 This restores and sets up the compilation environment before and
 279 afterwards.  Don't use within `eval-when-compile'."
 280   `(progn
 281      (eval-when-compile (cc-bytecomp-restore-environment))
 282      (require ,feature)
 283      (eval-when-compile (cc-bytecomp-setup-environment))))
 284
 285 (defun cc-bytecomp-is-compiling ()
 286   "Return non-nil if eval'ed during compilation.  Don't use outside
 287 `eval-when-compile'."
 288   (and (boundp 'byte-compile-dest-file)
 289        (stringp byte-compile-dest-file)))
 290
 291 (defmacro cc-bytecomp-defvar (var)
 292   "Binds the symbol as a variable during compilation of the file,
 293 to silence the byte compiler.  Don't use within `eval-when-compile'."
 294   `(eval-when-compile
 295      (if (boundp ',var)
 296          (cc-bytecomp-debug-msg
 297           "cc-bytecomp-defvar: %s bound already as variable" ',var)
 298        (if (not (memq ',var cc-bytecomp-unbound-variables))
 299            (progn
 300              (cc-bytecomp-debug-msg
 301               "cc-bytecomp-defvar: Saving %s (as unbound)" ',var)
 302              (setq cc-bytecomp-unbound-variables
 303                    (cons ',var cc-bytecomp-unbound-variables))))
 304        (if (and (cc-bytecomp-is-compiling)
 305                 (not load-in-progress))
 306            (progn
 307              (defvar ,var)
 308              (set ',var (intern (concat "cc-bytecomp-ignore-var:"
 309                                         (symbol-name ',var))))
 310              (cc-bytecomp-debug-msg
 311               "cc-bytecomp-defvar: Covered variable %s" ',var))))))
 312
 313 (defmacro cc-bytecomp-defun (fun)
 314   "Bind the symbol as a function during compilation of the file,
 315 to silence the byte compiler.  Don't use within `eval-when-compile'.
 316
 317 If the symbol already is bound as a function, it will keep that
 318 definition.  That means that this macro will not shut up warnings
 319 about incorrect number of arguments.  It's dangerous to try to replace
 320 existing functions since the byte compiler might need the definition
 321 at compile time, e.g. for macros and inline functions."
 322   `(eval-when-compile
 323      (if (fboundp ',fun)
 324          (cc-bytecomp-debug-msg
 325           "cc-bytecomp-defun: %s bound already as function" ',fun)
 326        (if (not (assq ',fun cc-bytecomp-original-functions))
 327            (progn
 328              (cc-bytecomp-debug-msg
 329               "cc-bytecomp-defun: Saving %s (as unbound)" ',fun)
 330              (setq cc-bytecomp-original-functions
 331                    (cons (list ',fun nil 'unbound)
 332                          cc-bytecomp-original-functions))))
 333        (if (and (cc-bytecomp-is-compiling)
 334                 (not load-in-progress))
 335            (progn
 336              (fset ',fun (intern (concat "cc-bytecomp-ignore-fun:"
 337                                          (symbol-name ',fun))))
 338              (cc-bytecomp-debug-msg
 339               "cc-bytecomp-defun: Covered function %s" ',fun))))))
 340
 341 (defmacro cc-bytecomp-put (symbol propname value)
 342   "Set a property on a symbol during compilation (and evaluation) of
 343 the file.  Don't use outside `eval-when-compile'."
 344   `(eval-when-compile
 345      (if (not (assoc (cons ,symbol ,propname) cc-bytecomp-original-properties))
 346          (progn
 347            (cc-bytecomp-debug-msg
 348             "cc-bytecomp-put: Saving property %s for %s with value %s"
 349             ,propname ,symbol (get ,symbol ,propname))
 350            (setq cc-bytecomp-original-properties
 351                  (cons (cons (cons ,symbol ,propname)
 352                              (cons ,value (get ,symbol ,propname)))
 353                        cc-bytecomp-original-properties))))
 354      (put ,symbol ,propname ,value)
 355      (cc-bytecomp-debug-msg
 356       "cc-bytecomp-put: Bound property %s for %s to %s"
 357       ,propname ,symbol ,value)))
 358
 359 (defmacro cc-bytecomp-obsolete-var (symbol)
 360   "Suppress warnings that the given symbol is an obsolete variable.
 361 Don't use within `eval-when-compile'."
 362   `(eval-when-compile
 363      (if (get ',symbol 'byte-obsolete-variable)
 364          (cc-bytecomp-put ',symbol 'byte-obsolete-variable nil)
 365        ;; This avoids a superfluous compiler warning
 366        ;; about calling `get' for effect.
 367        t)))
 368
 369 (defun cc-bytecomp-ignore-obsolete (form)
 370   ;; Wraps a call to `byte-compile-obsolete' that suppresses the warning.
 371   (let ((byte-compile-warnings byte-compile-warnings))
 372     (byte-compile-disable-warning 'obsolete)
 373     (byte-compile-obsolete form)))
 374
 375 (defmacro cc-bytecomp-obsolete-fun (symbol)
 376   "Suppress warnings that the given symbol is an obsolete function.
 377 Don't use within `eval-when-compile'."
 378   `(eval-when-compile
 379      (if (eq (get ',symbol 'byte-compile) 'byte-compile-obsolete)
 380          (cc-bytecomp-put ',symbol 'byte-compile
 381                           'cc-bytecomp-ignore-obsolete)
 382        ;; This avoids a superfluous compiler warning
 383        ;; about calling `get' for effect.
 384        t)))
 385
 386 (defmacro cc-bytecomp-boundp (symbol)
 387   "Return non-nil if the given symbol is bound as a variable outside
 388 the compilation.  This is the same as using `boundp' but additionally
 389 exclude any variables that have been bound during compilation with
 390 `cc-bytecomp-defvar'."
 391   (if (and (cc-bytecomp-is-compiling)
 392            (memq (car (cdr symbol)) cc-bytecomp-unbound-variables))
 393       nil
 394     `(boundp ,symbol)))
 395
 396 (defmacro cc-bytecomp-fboundp (symbol)
 397   "Return non-nil if the given symbol is bound as a function outside
 398 the compilation.  This is the same as using `fboundp' but additionally
 399 exclude any functions that have been bound during compilation with
 400 `cc-bytecomp-defun'."
 401   (let (fun-elem)
 402     (if (and (cc-bytecomp-is-compiling)
 403              (setq fun-elem (assq (car (cdr symbol))
 404                                   cc-bytecomp-original-functions))
 405              (eq (elt fun-elem 2) 'unbound))
 406         nil
 407       `(fboundp ,symbol))))
 408
 409 \f
 410 (provide 'cc-bytecomp)
 411
 412 ;;; cc-bytecomp.el ends here