|
189
|
1 ;;; cl-defs.el --- Manually maintained autoloads for cl
|
|
0
|
2
|
|
189
|
3 ;; Copyright (C) 1993, 1997 Free Software Foundation, Inc.
|
|
0
|
4
|
|
189
|
5 ;; Maintainer: XEmacs Development Team
|
|
|
6 ;; Keywords: extensions, lisp
|
|
0
|
7
|
|
189
|
8 ;; This file is part of XEmacs.
|
|
0
|
9
|
|
189
|
10 ;; XEmacs is free software; you can redistribute it and/or modify it
|
|
|
11 ;; under the terms of the GNU General Public License as published by
|
|
|
12 ;; the Free Software Foundation; either version 2, or (at your option)
|
|
|
13 ;; any later version.
|
|
0
|
14
|
|
189
|
15 ;; XEmacs is distributed in the hope that it will be useful, but
|
|
|
16 ;; WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
17 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
18 ;; General Public License for more details.
|
|
0
|
19
|
|
189
|
20 ;; You should have received a copy of the GNU General Public License
|
|
|
21 ;; along with XEmacs; see the file COPYING. If not, write to the
|
|
|
22 ;; Free Software Foundation, 59 Temple Place - Suite 330,
|
|
|
23 ;; Boston, MA 02111-1307, USA.
|
|
0
|
24
|
|
189
|
25 ;;; Synched up with: Not synched.
|
|
0
|
26
|
|
189
|
27 ;;; Commentary:
|
|
|
28
|
|
|
29 ;; At one time this file appears to have been generated by autoload.el.
|
|
0
|
30
|
|
189
|
31 ;;; Code:
|
|
0
|
32
|
|
|
33 ;;;***
|
|
|
34
|
|
|
35 ;;;### (autoloads (cl-compile-time-init compiler-macroexpand cl-struct-setf-expander get-setf-method cl-do-pop typep gentemp gensym) "cl-macs" "cl/cl-macs.el" (12559 39909))
|
|
|
36 ;;; Generated autoloads from cl/cl-macs.el
|
|
|
37
|
|
|
38 (autoload 'gensym "cl-macs" "\
|
|
|
39 Generate a new uninterned symbol.
|
|
|
40 The name is made by appending a number to PREFIX, default \"G\"." nil nil)
|
|
|
41
|
|
|
42 (autoload 'gentemp "cl-macs" "\
|
|
|
43 Generate a new interned symbol with a unique name.
|
|
|
44 The name is made by appending a number to PREFIX, default \"G\"." nil nil)
|
|
|
45
|
|
|
46 (autoload 'typep "cl-macs" "\
|
|
|
47 Check that OBJECT is of type TYPE.
|
|
|
48 TYPE is a Common Lisp-style type specifier." nil nil)
|
|
|
49
|
|
|
50 (autoload 'cl-do-pop "cl-macs" nil nil nil)
|
|
|
51
|
|
|
52 (autoload 'get-setf-method "cl-macs" "\
|
|
|
53 Return a list of five values describing the setf-method for PLACE.
|
|
|
54 PLACE may be any Lisp form which can appear as the PLACE argument to
|
|
|
55 a macro like `setf' or `incf'." nil nil)
|
|
|
56
|
|
|
57 (autoload 'cl-struct-setf-expander "cl-macs" nil nil nil)
|
|
|
58
|
|
|
59 (autoload 'compiler-macroexpand "cl-macs" nil nil nil)
|
|
|
60
|
|
|
61 (autoload 'cl-compile-time-init "cl-macs" nil nil nil)
|
|
|
62
|
|
|
63 ;;;***
|
|
|
64
|
|
|
65 ;;;### (autoloads (define-compiler-macro ignore-errors assert check-type defstruct callf2 callf letf* letf rotatef shiftf remf psetf setf define-modify-macro defsetf define-setf-method declare the locally multiple-value-setq multiple-value-bind lexical-let* lexical-let symbol-macrolet macrolet labels flet progv psetq do-all-symbols do-symbols dotimes dolist do* do loop return-from return block etypecase typecase ecase case load-time-value eval-when destructuring-bind function* defmacro* defun*) "cl-macs" "cl/cl-macs.el" (12559 39909))
|
|
|
66 ;;; Generated autoloads from cl/cl-macs.el
|
|
|
67
|
|
|
68 (autoload 'defun* "cl-macs" "\
|
|
|
69 (defun* NAME ARGLIST [DOCSTRING] BODY...): define NAME as a function.
|
|
|
70 Like normal `defun', except ARGLIST allows full Common Lisp conventions,
|
|
|
71 and BODY is implicitly surrounded by (block NAME ...)." nil 'macro)
|
|
|
72
|
|
|
73 (autoload 'defmacro* "cl-macs" "\
|
|
|
74 (defmacro* NAME ARGLIST [DOCSTRING] BODY...): define NAME as a macro.
|
|
|
75 Like normal `defmacro', except ARGLIST allows full Common Lisp conventions,
|
|
|
76 and BODY is implicitly surrounded by (block NAME ...)." nil 'macro)
|
|
|
77
|
|
|
78 (autoload 'function* "cl-macs" "\
|
|
|
79 (function* SYMBOL-OR-LAMBDA): introduce a function.
|
|
|
80 Like normal `function', except that if argument is a lambda form, its
|
|
|
81 ARGLIST allows full Common Lisp conventions." nil 'macro)
|
|
|
82
|
|
|
83 (autoload 'destructuring-bind "cl-macs" nil nil 'macro)
|
|
|
84
|
|
|
85 (autoload 'eval-when "cl-macs" "\
|
|
|
86 (eval-when (WHEN...) BODY...): control when BODY is evaluated.
|
|
|
87 If `compile' is in WHEN, BODY is evaluated when compiled at top-level.
|
|
|
88 If `load' is in WHEN, BODY is evaluated when loaded after top-level compile.
|
|
|
89 If `eval' is in WHEN, BODY is evaluated when interpreted or at non-top-level." nil 'macro)
|
|
|
90
|
|
|
91 (autoload 'load-time-value "cl-macs" "\
|
|
|
92 Like `progn', but evaluates the body at load time.
|
|
|
93 The result of the body appears to the compiler as a quoted constant." nil 'macro)
|
|
|
94
|
|
|
95 (autoload 'case "cl-macs" "\
|
|
|
96 (case EXPR CLAUSES...): evals EXPR, chooses from CLAUSES on that value.
|
|
|
97 Each clause looks like (KEYLIST BODY...). EXPR is evaluated and compared
|
|
|
98 against each key in each KEYLIST; the corresponding BODY is evaluated.
|
|
|
99 If no clause succeeds, case returns nil. A single atom may be used in
|
|
|
100 place of a KEYLIST of one atom. A KEYLIST of `t' or `otherwise' is
|
|
|
101 allowed only in the final clause, and matches if no other keys match.
|
|
|
102 Key values are compared by `eql'." nil 'macro)
|
|
|
103
|
|
|
104 (autoload 'ecase "cl-macs" "\
|
|
|
105 (ecase EXPR CLAUSES...): like `case', but error if no case fits.
|
|
|
106 `otherwise'-clauses are not allowed." nil 'macro)
|
|
|
107
|
|
|
108 (autoload 'typecase "cl-macs" "\
|
|
|
109 (typecase EXPR CLAUSES...): evals EXPR, chooses from CLAUSES on that value.
|
|
|
110 Each clause looks like (TYPE BODY...). EXPR is evaluated and, if it
|
|
|
111 satisfies TYPE, the corresponding BODY is evaluated. If no clause succeeds,
|
|
|
112 typecase returns nil. A TYPE of `t' or `otherwise' is allowed only in the
|
|
|
113 final clause, and matches if no other keys match." nil 'macro)
|
|
|
114
|
|
|
115 (autoload 'etypecase "cl-macs" "\
|
|
|
116 (etypecase EXPR CLAUSES...): like `typecase', but error if no case fits.
|
|
|
117 `otherwise'-clauses are not allowed." nil 'macro)
|
|
|
118
|
|
|
119 (autoload 'block "cl-macs" "\
|
|
|
120 (block NAME BODY...): define a lexically-scoped block named NAME.
|
|
|
121 NAME may be any symbol. Code inside the BODY forms can call `return-from'
|
|
|
122 to jump prematurely out of the block. This differs from `catch' and `throw'
|
|
|
123 in two respects: First, the NAME is an unevaluated symbol rather than a
|
|
|
124 quoted symbol or other form; and second, NAME is lexically rather than
|
|
|
125 dynamically scoped: Only references to it within BODY will work. These
|
|
|
126 references may appear inside macro expansions, but not inside functions
|
|
|
127 called from BODY." nil 'macro)
|
|
|
128
|
|
|
129 (autoload 'return "cl-macs" "\
|
|
|
130 (return [RESULT]): return from the block named nil.
|
|
|
131 This is equivalent to `(return-from nil RESULT)'." nil 'macro)
|
|
|
132
|
|
|
133 (autoload 'return-from "cl-macs" "\
|
|
|
134 (return-from NAME [RESULT]): return from the block named NAME.
|
|
|
135 This jump out to the innermost enclosing `(block NAME ...)' form,
|
|
|
136 returning RESULT from that form (or nil if RESULT is omitted).
|
|
|
137 This is compatible with Common Lisp, but note that `defun' and
|
|
|
138 `defmacro' do not create implicit blocks as they do in Common Lisp." nil 'macro)
|
|
|
139
|
|
|
140 (autoload 'loop "cl-macs" "\
|
|
|
141 (loop CLAUSE...): The Common Lisp `loop' macro.
|
|
|
142 Valid clauses are:
|
|
|
143 for VAR from/upfrom/downfrom NUM to/upto/downto/above/below NUM by NUM,
|
|
|
144 for VAR in LIST by FUNC, for VAR on LIST by FUNC, for VAR = INIT then EXPR,
|
|
|
145 for VAR across ARRAY, repeat NUM, with VAR = INIT, while COND, until COND,
|
|
|
146 always COND, never COND, thereis COND, collect EXPR into VAR,
|
|
|
147 append EXPR into VAR, nconc EXPR into VAR, sum EXPR into VAR,
|
|
|
148 count EXPR into VAR, maximize EXPR into VAR, minimize EXPR into VAR,
|
|
|
149 if COND CLAUSE [and CLAUSE]... else CLAUSE [and CLAUSE...],
|
|
|
150 unless COND CLAUSE [and CLAUSE]... else CLAUSE [and CLAUSE...],
|
|
|
151 do EXPRS..., initially EXPRS..., finally EXPRS..., return EXPR,
|
|
|
152 finally return EXPR, named NAME." nil 'macro)
|
|
|
153
|
|
|
154 (autoload 'do "cl-macs" "\
|
|
|
155 The Common Lisp `do' loop.
|
|
|
156 Format is: (do ((VAR INIT [STEP])...) (END-TEST [RESULT...]) BODY...)" nil 'macro)
|
|
|
157
|
|
|
158 (autoload 'do* "cl-macs" "\
|
|
|
159 The Common Lisp `do*' loop.
|
|
|
160 Format is: (do* ((VAR INIT [STEP])...) (END-TEST [RESULT...]) BODY...)" nil 'macro)
|
|
|
161
|
|
|
162 (autoload 'dolist "cl-macs" "\
|
|
|
163 (dolist (VAR LIST [RESULT]) BODY...): loop over a list.
|
|
|
164 Evaluate BODY with VAR bound to each `car' from LIST, in turn.
|
|
|
165 Then evaluate RESULT to get return value, default nil." nil 'macro)
|
|
|
166
|
|
|
167 (autoload 'dotimes "cl-macs" "\
|
|
|
168 (dotimes (VAR COUNT [RESULT]) BODY...): loop a certain number of times.
|
|
|
169 Evaluate BODY with VAR bound to successive integers from 0, inclusive,
|
|
|
170 to COUNT, exclusive. Then evaluate RESULT to get return value, default
|
|
|
171 nil." nil 'macro)
|
|
|
172
|
|
|
173 (autoload 'do-symbols "cl-macs" "\
|
|
|
174 (dosymbols (VAR [OBARRAY [RESULT]]) BODY...): loop over all symbols.
|
|
|
175 Evaluate BODY with VAR bound to each interned symbol, or to each symbol
|
|
|
176 from OBARRAY." nil 'macro)
|
|
|
177
|
|
|
178 (autoload 'do-all-symbols "cl-macs" nil nil 'macro)
|
|
|
179
|
|
|
180 (autoload 'psetq "cl-macs" "\
|
|
|
181 (psetq SYM VAL SYM VAL ...): set SYMs to the values VALs in parallel.
|
|
|
182 This is like `setq', except that all VAL forms are evaluated (in order)
|
|
|
183 before assigning any symbols SYM to the corresponding values." nil 'macro)
|
|
|
184
|
|
|
185 (autoload 'progv "cl-macs" "\
|
|
|
186 (progv SYMBOLS VALUES BODY...): bind SYMBOLS to VALUES dynamically in BODY.
|
|
|
187 The forms SYMBOLS and VALUES are evaluated, and must evaluate to lists.
|
|
|
188 Each SYMBOL in the first list is bound to the corresponding VALUE in the
|
|
|
189 second list (or made unbound if VALUES is shorter than SYMBOLS); then the
|
|
|
190 BODY forms are executed and their result is returned. This is much like
|
|
|
191 a `let' form, except that the list of symbols can be computed at run-time." nil 'macro)
|
|
|
192
|
|
|
193 (autoload 'flet "cl-macs" "\
|
|
|
194 (flet ((FUNC ARGLIST BODY...) ...) FORM...): make temporary function defns.
|
|
|
195 This is an analogue of `let' that operates on the function cell of FUNC
|
|
|
196 rather than its value cell. The FORMs are evaluated with the specified
|
|
|
197 function definitions in place, then the definitions are undone (the FUNCs
|
|
|
198 go back to their previous definitions, or lack thereof)." nil 'macro)
|
|
|
199
|
|
|
200 (autoload 'labels "cl-macs" nil nil 'macro)
|
|
|
201
|
|
|
202 (autoload 'macrolet "cl-macs" "\
|
|
|
203 (macrolet ((NAME ARGLIST BODY...) ...) FORM...): make temporary macro defns.
|
|
|
204 This is like `flet', but for macros instead of functions." nil 'macro)
|
|
|
205
|
|
|
206 (autoload 'symbol-macrolet "cl-macs" "\
|
|
|
207 (symbol-macrolet ((NAME EXPANSION) ...) FORM...): make symbol macro defns.
|
|
|
208 Within the body FORMs, references to the variable NAME will be replaced
|
|
|
209 by EXPANSION, and (setq NAME ...) will act like (setf EXPANSION ...)." nil 'macro)
|
|
|
210
|
|
|
211 (autoload 'lexical-let "cl-macs" "\
|
|
|
212 (lexical-let BINDINGS BODY...): like `let', but lexically scoped.
|
|
|
213 The main visible difference is that lambdas inside BODY will create
|
|
|
214 lexical closures as in Common Lisp." nil 'macro)
|
|
|
215
|
|
|
216 (autoload 'lexical-let* "cl-macs" "\
|
|
|
217 (lexical-let* BINDINGS BODY...): like `let*', but lexically scoped.
|
|
|
218 The main visible difference is that lambdas inside BODY will create
|
|
|
219 lexical closures as in Common Lisp." nil 'macro)
|
|
|
220
|
|
|
221 (autoload 'multiple-value-bind "cl-macs" "\
|
|
|
222 (multiple-value-bind (SYM SYM...) FORM BODY): collect multiple return values.
|
|
|
223 FORM must return a list; the BODY is then executed with the first N elements
|
|
|
224 of this list bound (`let'-style) to each of the symbols SYM in turn. This
|
|
|
225 is analogous to the Common Lisp `multiple-value-bind' macro, using lists to
|
|
|
226 simulate true multiple return values. For compatibility, (values A B C) is
|
|
|
227 a synonym for (list A B C)." nil 'macro)
|
|
|
228
|
|
|
229 (autoload 'multiple-value-setq "cl-macs" "\
|
|
|
230 (multiple-value-setq (SYM SYM...) FORM): collect multiple return values.
|
|
|
231 FORM must return a list; the first N elements of this list are stored in
|
|
|
232 each of the symbols SYM in turn. This is analogous to the Common Lisp
|
|
|
233 `multiple-value-setq' macro, using lists to simulate true multiple return
|
|
|
234 values. For compatibility, (values A B C) is a synonym for (list A B C)." nil 'macro)
|
|
|
235
|
|
|
236 (autoload 'locally "cl-macs" nil nil 'macro)
|
|
|
237
|
|
|
238 (autoload 'the "cl-macs" nil nil 'macro)
|
|
|
239
|
|
|
240 (autoload 'declare "cl-macs" nil nil 'macro)
|
|
|
241
|
|
|
242 (autoload 'define-setf-method "cl-macs" "\
|
|
|
243 (define-setf-method NAME ARGLIST BODY...): define a `setf' method.
|
|
|
244 This method shows how to handle `setf's to places of the form (NAME ARGS...).
|
|
|
245 The argument forms ARGS are bound according to ARGLIST, as if NAME were
|
|
|
246 going to be expanded as a macro, then the BODY forms are executed and must
|
|
|
247 return a list of five elements: a temporary-variables list, a value-forms
|
|
|
248 list, a store-variables list (of length one), a store-form, and an access-
|
|
|
249 form. See `defsetf' for a simpler way to define most setf-methods." nil 'macro)
|
|
|
250
|
|
|
251 (autoload 'defsetf "cl-macs" "\
|
|
|
252 (defsetf NAME FUNC): define a `setf' method.
|
|
|
253 This macro is an easy-to-use substitute for `define-setf-method' that works
|
|
|
254 well for simple place forms. In the simple `defsetf' form, `setf's of
|
|
|
255 the form (setf (NAME ARGS...) VAL) are transformed to function or macro
|
|
|
256 calls of the form (FUNC ARGS... VAL). Example: (defsetf aref aset).
|
|
|
257 Alternate form: (defsetf NAME ARGLIST (STORE) BODY...).
|
|
|
258 Here, the above `setf' call is expanded by binding the argument forms ARGS
|
|
|
259 according to ARGLIST, binding the value form VAL to STORE, then executing
|
|
|
260 BODY, which must return a Lisp form that does the necessary `setf' operation.
|
|
|
261 Actually, ARGLIST and STORE may be bound to temporary variables which are
|
|
|
262 introduced automatically to preserve proper execution order of the arguments.
|
|
|
263 Example: (defsetf nth (n x) (v) (list 'setcar (list 'nthcdr n x) v))." nil 'macro)
|
|
|
264
|
|
|
265 (autoload 'define-modify-macro "cl-macs" "\
|
|
|
266 (define-modify-macro NAME ARGLIST FUNC): define a `setf'-like modify macro.
|
|
|
267 If NAME is called, it combines its PLACE argument with the other arguments
|
|
|
268 from ARGLIST using FUNC: (define-modify-macro incf (&optional (n 1)) +)" nil 'macro)
|
|
|
269
|
|
|
270 (autoload 'setf "cl-macs" "\
|
|
|
271 (setf PLACE VAL PLACE VAL ...): set each PLACE to the value of its VAL.
|
|
|
272 This is a generalized version of `setq'; the PLACEs may be symbolic
|
|
|
273 references such as (car x) or (aref x i), as well as plain symbols.
|
|
|
274 For example, (setf (cadar x) y) is equivalent to (setcar (cdar x) y).
|
|
|
275 The return value is the last VAL in the list." nil 'macro)
|
|
|
276
|
|
|
277 (autoload 'psetf "cl-macs" "\
|
|
|
278 (psetf PLACE VAL PLACE VAL ...): set PLACEs to the values VALs in parallel.
|
|
|
279 This is like `setf', except that all VAL forms are evaluated (in order)
|
|
|
280 before assigning any PLACEs to the corresponding values." nil 'macro)
|
|
|
281
|
|
|
282 (autoload 'remf "cl-macs" "\
|
|
|
283 (remf PLACE TAG): remove TAG from property list PLACE.
|
|
|
284 PLACE may be a symbol, or any generalized variable allowed by `setf'.
|
|
|
285 The form returns true if TAG was found and removed, nil otherwise." nil 'macro)
|
|
|
286
|
|
|
287 (autoload 'shiftf "cl-macs" "\
|
|
|
288 (shiftf PLACE PLACE... VAL): shift left among PLACEs.
|
|
|
289 Example: (shiftf A B C) sets A to B, B to C, and returns the old A.
|
|
|
290 Each PLACE may be a symbol, or any generalized variable allowed by `setf'." nil 'macro)
|
|
|
291
|
|
|
292 (autoload 'rotatef "cl-macs" "\
|
|
|
293 (rotatef PLACE...): rotate left among PLACEs.
|
|
|
294 Example: (rotatef A B C) sets A to B, B to C, and C to A. It returns nil.
|
|
|
295 Each PLACE may be a symbol, or any generalized variable allowed by `setf'." nil 'macro)
|
|
|
296
|
|
|
297 (autoload 'letf "cl-macs" "\
|
|
|
298 (letf ((PLACE VALUE) ...) BODY...): temporarily bind to PLACEs.
|
|
|
299 This is the analogue of `let', but with generalized variables (in the
|
|
|
300 sense of `setf') for the PLACEs. Each PLACE is set to the corresponding
|
|
|
301 VALUE, then the BODY forms are executed. On exit, either normally or
|
|
|
302 because of a `throw' or error, the PLACEs are set back to their original
|
|
|
303 values. Note that this macro is *not* available in Common Lisp.
|
|
|
304 As a special case, if `(PLACE)' is used instead of `(PLACE VALUE)',
|
|
|
305 the PLACE is not modified before executing BODY." nil 'macro)
|
|
|
306
|
|
|
307 (autoload 'letf* "cl-macs" "\
|
|
|
308 (letf* ((PLACE VALUE) ...) BODY...): temporarily bind to PLACEs.
|
|
|
309 This is the analogue of `let*', but with generalized variables (in the
|
|
|
310 sense of `setf') for the PLACEs. Each PLACE is set to the corresponding
|
|
|
311 VALUE, then the BODY forms are executed. On exit, either normally or
|
|
|
312 because of a `throw' or error, the PLACEs are set back to their original
|
|
|
313 values. Note that this macro is *not* available in Common Lisp.
|
|
|
314 As a special case, if `(PLACE)' is used instead of `(PLACE VALUE)',
|
|
|
315 the PLACE is not modified before executing BODY." nil 'macro)
|
|
|
316
|
|
|
317 (autoload 'callf "cl-macs" "\
|
|
|
318 (callf FUNC PLACE ARGS...): set PLACE to (FUNC PLACE ARGS...).
|
|
|
319 FUNC should be an unquoted function name. PLACE may be a symbol,
|
|
|
320 or any generalized variable allowed by `setf'." nil 'macro)
|
|
|
321
|
|
|
322 (autoload 'callf2 "cl-macs" "\
|
|
|
323 (callf2 FUNC ARG1 PLACE ARGS...): set PLACE to (FUNC ARG1 PLACE ARGS...).
|
|
|
324 Like `callf', but PLACE is the second argument of FUNC, not the first." nil 'macro)
|
|
|
325
|
|
|
326 (autoload 'defstruct "cl-macs" "\
|
|
|
327 (defstruct (NAME OPTIONS...) (SLOT SLOT-OPTS...)...): define a struct type.
|
|
|
328 This macro defines a new Lisp data type called NAME, which contains data
|
|
|
329 stored in SLOTs. This defines a `make-NAME' constructor, a `copy-NAME'
|
|
|
330 copier, a `NAME-p' predicate, and setf-able `NAME-SLOT' accessors." nil 'macro)
|
|
|
331
|
|
|
332 (autoload 'check-type "cl-macs" "\
|
|
|
333 Verify that FORM is of type TYPE; signal an error if not.
|
|
|
334 STRING is an optional description of the desired type." nil 'macro)
|
|
|
335
|
|
|
336 (autoload 'assert "cl-macs" "\
|
|
|
337 Verify that FORM returns non-nil; signal an error if not.
|
|
|
338 Second arg SHOW-ARGS means to include arguments of FORM in message.
|
|
|
339 Other args STRING and ARGS... are arguments to be passed to `error'.
|
|
|
340 They are not evaluated unless the assertion fails. If STRING is
|
|
|
341 omitted, a default message listing FORM itself is used." nil 'macro)
|
|
|
342
|
|
|
343 (autoload 'ignore-errors "cl-macs" "\
|
|
|
344 Execute FORMS; if an error occurs, return nil.
|
|
|
345 Otherwise, return result of last FORM." nil 'macro)
|
|
|
346
|
|
|
347 (autoload 'define-compiler-macro "cl-macs" "\
|
|
|
348 (define-compiler-macro FUNC ARGLIST BODY...): Define a compiler-only macro.
|
|
|
349 This is like `defmacro', but macro expansion occurs only if the call to
|
|
|
350 FUNC is compiled (i.e., not interpreted). Compiler macros should be used
|
|
|
351 for optimizing the way calls to FUNC are compiled; the form returned by
|
|
|
352 BODY should do the same thing as a call to the normal function called
|
|
|
353 FUNC, though possibly more efficiently. Note that, like regular macros,
|
|
|
354 compiler macros are expanded repeatedly until no further expansions are
|
|
|
355 possible. Unlike regular macros, BODY can decide to \"punt\" and leave the
|
|
|
356 original function call alone by declaring an initial `&whole foo' parameter
|
|
|
357 and then returning foo." nil 'macro)
|
|
|
358
|
|
|
359 ;;;***
|
|
189
|
360
|
|
|
361 ;;; cl-defs.el ends here
|
