Mercurial > emacs
annotate lisp/progmodes/cc-bytecomp.el @ 38957:113b18d8a765
Add Keywords header. From Pavel Janik.
author | Eli Zaretskii <eliz@gnu.org> |
---|---|
date | Sun, 26 Aug 2001 16:34:04 +0000 |
parents | 7a94f1c588c4 |
children | 7a3ac6c387fe |
rev | line source |
---|---|
38422
7a94f1c588c4
Some fixes to follow coding conventions.
Pavel Janík <Pavel@Janik.cz>
parents:
38401
diff
changeset
|
1 ;;; cc-bytecomp.el --- compile time setup for proper compilation |
36920 | 2 |
3 ;; Copyright (C) 2000, 01 Free Software Foundation, Inc. | |
4 | |
5 ;; Author: Martin Stjernholm | |
6 ;; Maintainer: bug-cc-mode@gnu.org | |
7 ;; Created: 15-Jul-2000 | |
8 ;; Version: See cc-mode.el | |
9 ;; Keywords: c languages oop | |
10 | |
38401 | 11 ;; This file is part of GNU Emacs. |
12 | |
13 ;; GNU Emacs is free software; you can redistribute it and/or modify | |
36920 | 14 ;; it under the terms of the GNU General Public License as published by |
38401 | 15 ;; the Free Software Foundation; either version 2, or (at your option) |
16 ;; any later version. | |
36920 | 17 |
38401 | 18 ;; GNU Emacs is distributed in the hope that it will be useful, |
36920 | 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 | |
38401 | 24 ;; along with GNU Emacs; see the file COPYING. If not, write to the |
25 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330, | |
36920 | 26 ;; Boston, MA 02111-1307, USA. |
27 | |
28 ;;; Commentary: | |
29 | |
30 ;; This file is used to ensure that the CC Mode files are correctly | |
31 ;; compiled regardless the environment (e.g. if an older CC Mode with | |
32 ;; outdated macros are loaded during compilation). It also provides | |
33 ;; features to defeat the compiler warnings for selected symbols. | |
34 | |
35 | |
38422
7a94f1c588c4
Some fixes to follow coding conventions.
Pavel Janík <Pavel@Janik.cz>
parents:
38401
diff
changeset
|
36 ;;; Code: |
7a94f1c588c4
Some fixes to follow coding conventions.
Pavel Janík <Pavel@Janik.cz>
parents:
38401
diff
changeset
|
37 |
36920 | 38 (defvar cc-bytecomp-unbound-variables nil) |
39 (defvar cc-bytecomp-original-functions nil) | |
40 (defvar cc-bytecomp-original-properties nil) | |
41 (defvar cc-bytecomp-load-depth 0) | |
42 (defvar cc-bytecomp-loaded-files nil) | |
43 (defvar cc-bytecomp-environment-set nil) | |
44 | |
45 (put 'cc-eval-when-compile 'lisp-indent-hook 0) | |
46 (defmacro cc-eval-when-compile (&rest body) | |
47 "Like `progn', but evaluates the body at compile time. | |
48 The result of the body appears to the compiler as a quoted constant. | |
49 | |
50 This variant works around what looks like a bug in | |
51 `eval-when-compile': During byte compilation it byte compiles its | |
52 contents before evaluating it. That can cause forms to be compiled in | |
53 situations they aren't intended to be compiled. See cc-bytecomp.el | |
54 for further discussion." | |
55 ;; | |
56 ;; Example: It's not possible to defsubst a primitive, e.g. the | |
57 ;; following will produce an error (in any emacs flavor), since | |
58 ;; `nthcdr' is a primitive function that's handled specially by the | |
59 ;; byte compiler and thus can't be redefined: | |
60 ;; | |
61 ;; (defsubst nthcdr (val) val) | |
62 ;; | |
63 ;; `defsubst', like `defmacro', needs to be evaluated at compile | |
64 ;; time, so this will produce an error during byte compilation. | |
65 ;; | |
66 ;; CC Mode occasionally needs to do things like this for cross-emacs | |
67 ;; compatibility (although we try to avoid it since it results in | |
68 ;; byte code that isn't compatible between emacsen). It therefore | |
69 ;; uses the following to conditionally do a `defsubst': | |
70 ;; | |
71 ;; (eval-when-compile | |
72 ;; (if (not (fboundp 'foo)) | |
73 ;; (defsubst foo ...))) | |
74 ;; | |
75 ;; But `eval-when-compile' byte compiles its contents and _then_ | |
76 ;; evaluates it (in all current emacs versions, up to and including | |
77 ;; Emacs 20.6 and XEmacs 21.1 as of this writing). So this will | |
78 ;; still produce an error, since the byte compiler will get to the | |
79 ;; defsubst anyway. That's arguably a bug because the point with | |
80 ;; `eval-when-compile' is that it should evaluate rather than | |
81 ;; compile its contents. | |
82 `(eval-when-compile (eval '(progn ,@body)))) | |
83 | |
84 (defun cc-bytecomp-setup-environment () | |
85 ;; Eval'ed during compilation to setup variables, functions etc | |
86 ;; declared with `cc-bytecomp-defvar' et al. | |
87 (if (= cc-bytecomp-load-depth 0) | |
88 (let (p) | |
89 (if cc-bytecomp-environment-set | |
90 (error "Byte compilation environment already set - \ | |
91 perhaps a `cc-bytecomp-restore-environment' is forgotten somewhere")) | |
92 (setq p cc-bytecomp-unbound-variables) | |
93 (while p | |
94 (if (not (boundp (car p))) | |
95 (progn | |
96 (eval `(defvar ,(car p))) | |
97 (set (car p) 'cc-bytecomp-ignore))) | |
98 (setq p (cdr p))) | |
99 (setq p cc-bytecomp-original-functions) | |
100 (while p | |
101 (let ((fun (car (car p))) | |
102 (temp-macro (car (cdr (car p))))) | |
103 (if temp-macro | |
104 (eval `(defmacro ,fun ,@temp-macro)) | |
105 (fset fun 'cc-bytecomp-ignore))) | |
106 (setq p (cdr p))) | |
107 (setq p cc-bytecomp-original-properties) | |
108 (while p | |
109 (let ((sym (car (car (car p)))) | |
110 (prop (cdr (car (car p)))) | |
111 (tempdef (car (cdr (car p))))) | |
112 (put sym prop tempdef)) | |
113 (setq p (cdr p))) | |
114 (setq cc-bytecomp-environment-set t)))) | |
115 | |
116 (defun cc-bytecomp-restore-environment () | |
117 ;; Eval'ed during compilation to restore variables, functions etc | |
118 ;; declared with `cc-bytecomp-defvar' et al. | |
119 (if (= cc-bytecomp-load-depth 0) | |
120 (let (p) | |
121 (setq p cc-bytecomp-unbound-variables) | |
122 (while p | |
123 (let ((var (car p))) | |
124 (if (and (boundp var) | |
125 (eq var 'cc-bytecomp-ignore)) | |
126 (makunbound var))) | |
127 (setq p (cdr p))) | |
128 (setq p cc-bytecomp-original-functions) | |
129 (while p | |
130 (let ((fun (car (car p))) | |
131 (def (car (cdr (cdr (car p)))))) | |
132 (if (and (fboundp fun) | |
133 (eq (symbol-function fun) 'cc-bytecomp-ignore)) | |
134 (if (eq def 'unbound) | |
135 (fmakunbound fun) | |
136 (fset fun def)))) | |
137 (setq p (cdr p))) | |
138 (setq p cc-bytecomp-original-properties) | |
139 (while p | |
140 (let ((sym (car (car (car p)))) | |
141 (prop (cdr (car (car p)))) | |
142 (tempdef (car (cdr (car p)))) | |
143 (origdef (cdr (cdr (car p))))) | |
144 (if (eq (get sym prop) tempdef) | |
145 (put sym prop origdef))) | |
146 (setq p (cdr p))) | |
147 (setq cc-bytecomp-environment-set nil)))) | |
148 | |
149 (defun cc-bytecomp-load (cc-part) | |
150 ;; Eval'ed during compilation to load a CC Mode file from the source | |
151 ;; directory (assuming it's the same as the compiled file | |
152 ;; destination dir). | |
153 (if (and (boundp 'byte-compile-dest-file) | |
154 (stringp byte-compile-dest-file)) | |
155 (progn | |
156 (cc-bytecomp-restore-environment) | |
157 (let ((cc-bytecomp-load-depth (1+ cc-bytecomp-load-depth)) | |
158 (load-path | |
159 (cons (file-name-directory byte-compile-dest-file) | |
160 load-path)) | |
161 (cc-file (concat cc-part ".el"))) | |
162 (if (member cc-file cc-bytecomp-loaded-files) | |
163 () | |
164 (setq cc-bytecomp-loaded-files | |
165 (cons cc-file cc-bytecomp-loaded-files)) | |
166 (load cc-file nil t t))) | |
167 (cc-bytecomp-setup-environment) | |
168 t))) | |
169 | |
170 (defmacro cc-require (cc-part) | |
171 "Force loading of the corresponding .el file in the current | |
172 directory during compilation, but compile in a `require'. Don't use | |
173 within `eval-when-compile'. | |
174 | |
175 Having cyclic cc-require's will result in infinite recursion. That's | |
176 somewhat intentional." | |
177 `(progn | |
178 (cc-eval-when-compile (cc-bytecomp-load (symbol-name ,cc-part))) | |
179 (require ,cc-part))) | |
180 | |
181 (defmacro cc-provide (feature) | |
182 "A replacement for the `provide' form that restores the environment | |
183 after the compilation. Don't use within `eval-when-compile'." | |
184 `(progn | |
185 (eval-when-compile (cc-bytecomp-restore-environment)) | |
186 (provide ,feature))) | |
187 | |
188 (defmacro cc-load (cc-part) | |
189 "Force loading of the corresponding .el file in the current | |
190 directory during compilation. Don't use outside `eval-when-compile' | |
191 or `eval-and-compile'. | |
192 | |
193 Having cyclic cc-load's will result in infinite recursion. That's | |
194 somewhat intentional." | |
195 `(or (and (featurep 'cc-bytecomp) | |
196 (cc-bytecomp-load ,cc-part)) | |
197 (load ,cc-part nil t nil))) | |
198 | |
199 (defun cc-bytecomp-is-compiling () | |
200 "Return non-nil if eval'ed during compilation. Don't use outside | |
201 `eval-when-compile'." | |
202 (and (boundp 'byte-compile-dest-file) | |
203 (stringp byte-compile-dest-file))) | |
204 | |
205 (defmacro cc-bytecomp-defvar (var) | |
206 "Binds the symbol as a variable during compilation of the file, | |
207 to silence the byte compiler. Don't use within `eval-when-compile'." | |
208 `(eval-when-compile | |
209 (if (boundp ',var) | |
210 nil | |
211 (if (not (memq ',var cc-bytecomp-unbound-variables)) | |
212 (setq cc-bytecomp-unbound-variables | |
213 (cons ',var cc-bytecomp-unbound-variables))) | |
214 (if (and (cc-bytecomp-is-compiling) | |
215 (= cc-bytecomp-load-depth 0)) | |
216 (progn | |
217 (defvar ,var) | |
218 (set ',var 'cc-bytecomp-ignore)))))) | |
219 | |
220 (defmacro cc-bytecomp-defun (fun) | |
221 "Bind the symbol as a function during compilation of the file, | |
222 to silence the byte compiler. Don't use within `eval-when-compile'." | |
223 `(eval-when-compile | |
224 (if (not (assq ',fun cc-bytecomp-original-functions)) | |
225 (setq cc-bytecomp-original-functions | |
226 (cons (list ',fun | |
227 nil | |
228 (if (fboundp ',fun) | |
229 (symbol-function ',fun) | |
230 'unbound)) | |
231 cc-bytecomp-original-functions))) | |
232 (if (and (cc-bytecomp-is-compiling) | |
233 (= cc-bytecomp-load-depth 0) | |
234 (not (fboundp ',fun))) | |
235 (fset ',fun 'cc-bytecomp-ignore)))) | |
236 | |
237 (put 'cc-bytecomp-defmacro 'lisp-indent-function 'defun) | |
238 (defmacro cc-bytecomp-defmacro (fun &rest temp-macro) | |
239 "Bind the symbol as a macro during compilation (and evaluation) of the | |
240 file. Don't use outside `eval-when-compile'." | |
241 `(progn | |
242 (if (not (assq ',fun cc-bytecomp-original-functions)) | |
243 (setq cc-bytecomp-original-functions | |
244 (cons (list ',fun | |
245 ',temp-macro | |
246 (if (fboundp ',fun) | |
247 (symbol-function ',fun) | |
248 'unbound)) | |
249 cc-bytecomp-original-functions))) | |
250 (defmacro ,fun ,@temp-macro))) | |
251 | |
252 (defmacro cc-bytecomp-put (symbol propname value) | |
253 "Set a property on a symbol during compilation (and evaluation) of | |
254 the file. Don't use outside `eval-when-compile'." | |
255 `(cc-eval-when-compile | |
256 (if (not (assoc (cons ,symbol ,propname) cc-bytecomp-original-properties)) | |
257 (setq cc-bytecomp-original-properties | |
258 (cons (cons (cons ,symbol ,propname) | |
259 (cons ,value (get ,symbol ,propname))) | |
260 cc-bytecomp-original-properties))) | |
261 (put ,symbol ,propname ,value))) | |
262 | |
263 (defmacro cc-bytecomp-obsolete-var (symbol) | |
264 "Suppress warnings about that the given symbol is an obsolete variable. | |
265 Don't use within `eval-when-compile'." | |
266 `(eval-when-compile | |
267 (if (get ',symbol 'byte-obsolete-variable) | |
268 (cc-bytecomp-put ',symbol 'byte-obsolete-variable nil)))) | |
269 | |
270 (defun cc-bytecomp-ignore-obsolete (form) | |
271 ;; Wraps a call to `byte-compile-obsolete' that suppresses the warning. | |
272 (let ((byte-compile-warnings | |
273 (delq 'obsolete (append byte-compile-warnings nil)))) | |
274 (byte-compile-obsolete form))) | |
275 | |
276 (defmacro cc-bytecomp-obsolete-fun (symbol) | |
277 "Suppress warnings about that the given symbol is an obsolete function. | |
278 Don't use within `eval-when-compile'." | |
279 `(eval-when-compile | |
280 (if (eq (get ',symbol 'byte-compile) 'byte-compile-obsolete) | |
281 (cc-bytecomp-put ',symbol 'byte-compile | |
282 'cc-bytecomp-ignore-obsolete)))) | |
283 | |
284 ;; Override ourselves with a version loaded from source if we're | |
285 ;; compiling, like cc-require does for all the other files. | |
286 (if (and (cc-bytecomp-is-compiling) | |
287 (= cc-bytecomp-load-depth 0)) | |
288 (let ((load-path | |
289 (cons (file-name-directory byte-compile-dest-file) load-path)) | |
290 (cc-bytecomp-load-depth 1)) | |
291 (load "cc-bytecomp.el" nil t t))) | |
292 | |
293 | |
294 (provide 'cc-bytecomp) | |
38422
7a94f1c588c4
Some fixes to follow coding conventions.
Pavel Janík <Pavel@Janik.cz>
parents:
38401
diff
changeset
|
295 |
7a94f1c588c4
Some fixes to follow coding conventions.
Pavel Janík <Pavel@Janik.cz>
parents:
38401
diff
changeset
|
296 ;;; cc-bytecomp.el ends here |