|
209
|
1 ;;; DO NOT MODIFY THIS FILE
|
|
|
2 (if (featurep 'TopLevel-autoloads) (error "Already loaded"))
|
|
|
3
|
|
|
4 ;;;### (autoloads (batch-byte-recompile-directory batch-byte-recompile-directory-norecurse batch-byte-compile display-call-tree byte-compile-sexp byte-compile compile-defun byte-compile-file byte-recompile-file byte-recompile-directory byte-force-recompile) "bytecomp" "lisp/bytecomp.el")
|
|
|
5
|
|
|
6 (autoload 'byte-force-recompile "bytecomp" "\
|
|
|
7 Recompile every `.el' file in DIRECTORY that already has a `.elc' file.
|
|
|
8 Files in subdirectories of DIRECTORY are processed also." t nil)
|
|
|
9
|
|
|
10 (autoload 'byte-recompile-directory "bytecomp" "\
|
|
|
11 Recompile every `.el' file in DIRECTORY that needs recompilation.
|
|
|
12 This is if a `.elc' file exists but is older than the `.el' file.
|
|
|
13 Files in subdirectories of DIRECTORY are processed also unless argument
|
|
|
14 NORECURSION is non-nil.
|
|
|
15
|
|
|
16 If the `.elc' file does not exist, normally the `.el' file is *not* compiled.
|
|
|
17 But a prefix argument (optional second arg) means ask user,
|
|
|
18 for each such `.el' file, whether to compile it. Prefix argument 0 means
|
|
|
19 don't ask and compile the file anyway.
|
|
|
20
|
|
|
21 A nonzero prefix argument also means ask about each subdirectory.
|
|
|
22
|
|
|
23 If the fourth argument FORCE is non-nil,
|
|
|
24 recompile every `.el' file that already has a `.elc' file." t nil)
|
|
|
25
|
|
|
26 (autoload 'byte-recompile-file "bytecomp" "\
|
|
|
27 Recompile a file of Lisp code named FILENAME if it needs recompilation.
|
|
|
28 This is if the `.elc' file exists but is older than the `.el' file.
|
|
|
29
|
|
|
30 If the `.elc' file does not exist, normally the `.el' file is *not*
|
|
|
31 compiled. But a prefix argument (optional second arg) means ask user
|
|
|
32 whether to compile it. Prefix argument 0 don't ask and recompile anyway." t nil)
|
|
|
33
|
|
|
34 (autoload 'byte-compile-file "bytecomp" "\
|
|
|
35 Compile a file of Lisp code named FILENAME into a file of byte code.
|
|
|
36 The output file's name is made by appending `c' to the end of FILENAME.
|
|
|
37 With prefix arg (noninteractively: 2nd arg), load the file after compiling." t nil)
|
|
|
38
|
|
|
39 (autoload 'compile-defun "bytecomp" "\
|
|
|
40 Compile and evaluate the current top-level form.
|
|
|
41 Print the result in the minibuffer.
|
|
|
42 With argument, insert value in current buffer after the form." t nil)
|
|
|
43
|
|
|
44 (autoload 'byte-compile "bytecomp" "\
|
|
|
45 If FORM is a symbol, byte-compile its function definition.
|
|
|
46 If FORM is a lambda or a macro, byte-compile it as a function." nil nil)
|
|
|
47
|
|
|
48 (autoload 'byte-compile-sexp "bytecomp" "\
|
|
|
49 Compile and return SEXP." nil nil)
|
|
|
50
|
|
|
51 (autoload 'display-call-tree "bytecomp" "\
|
|
|
52 Display a call graph of a specified file.
|
|
|
53 This lists which functions have been called, what functions called
|
|
|
54 them, and what functions they call. The list includes all functions
|
|
|
55 whose definitions have been compiled in this Emacs session, as well as
|
|
|
56 all functions called by those functions.
|
|
|
57
|
|
|
58 The call graph does not include macros, inline functions, or
|
|
|
59 primitives that the byte-code interpreter knows about directly (eq,
|
|
|
60 cons, etc.).
|
|
|
61
|
|
|
62 The call tree also lists those functions which are not known to be called
|
|
|
63 \(that is, to which no calls have been compiled), and which cannot be
|
|
|
64 invoked interactively." t nil)
|
|
|
65
|
|
|
66 (autoload 'batch-byte-compile "bytecomp" "\
|
|
|
67 Run `byte-compile-file' on the files remaining on the command line.
|
|
|
68 Use this from the command line, with `-batch';
|
|
|
69 it won't work in an interactive Emacs.
|
|
|
70 Each file is processed even if an error occurred previously.
|
|
|
71 For example, invoke \"emacs -batch -f batch-byte-compile $emacs/ ~/*.el\"" nil nil)
|
|
|
72
|
|
|
73 (autoload 'batch-byte-recompile-directory-norecurse "bytecomp" "\
|
|
|
74 Same as `batch-byte-recompile-directory' but without recursion." nil nil)
|
|
|
75
|
|
|
76 (autoload 'batch-byte-recompile-directory "bytecomp" "\
|
|
|
77 Runs `byte-recompile-directory' on the dirs remaining on the command line.
|
|
|
78 Must be used only with `-batch', and kills Emacs on completion.
|
|
|
79 For example, invoke `xemacs -batch -f batch-byte-recompile-directory .'." nil nil)
|
|
|
80
|
|
|
81 ;;;***
|
|
|
82
|
|
|
83 ;;;### (autoloads (compiler-macroexpand define-compiler-macro ignore-errors assert check-type typep deftype cl-struct-setf-expander defstruct define-modify-macro callf2 callf letf* letf rotatef shiftf remf cl-do-pop psetf setf get-setf-method 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* gentemp gensym cl-compile-time-init) "cl-macs" "lisp/cl-macs.el")
|
|
|
84
|
|
|
85 (autoload 'cl-compile-time-init "cl-macs" nil nil nil)
|
|
|
86
|
|
|
87 (autoload 'gensym "cl-macs" "\
|
|
|
88 Generate a new uninterned symbol.
|
|
|
89 The name is made by appending a number to PREFIX, default \"G\"." nil nil)
|
|
|
90
|
|
|
91 (autoload 'gentemp "cl-macs" "\
|
|
|
92 Generate a new interned symbol with a unique name.
|
|
|
93 The name is made by appending a number to PREFIX, default \"G\"." nil nil)
|
|
|
94
|
|
|
95 (autoload 'defun* "cl-macs" "\
|
|
|
96 (defun* NAME ARGLIST [DOCSTRING] BODY...): define NAME as a function.
|
|
|
97 Like normal `defun', except ARGLIST allows full Common Lisp conventions,
|
|
|
98 and BODY is implicitly surrounded by (block NAME ...)." nil 'macro)
|
|
|
99
|
|
|
100 (autoload 'defmacro* "cl-macs" "\
|
|
|
101 (defmacro* NAME ARGLIST [DOCSTRING] BODY...): define NAME as a macro.
|
|
|
102 Like normal `defmacro', except ARGLIST allows full Common Lisp conventions,
|
|
|
103 and BODY is implicitly surrounded by (block NAME ...)." nil 'macro)
|
|
|
104
|
|
|
105 (autoload 'function* "cl-macs" "\
|
|
|
106 (function* SYMBOL-OR-LAMBDA): introduce a function.
|
|
|
107 Like normal `function', except that if argument is a lambda form, its
|
|
|
108 ARGLIST allows full Common Lisp conventions." nil 'macro)
|
|
|
109
|
|
|
110 (autoload 'destructuring-bind "cl-macs" nil nil 'macro)
|
|
|
111
|
|
|
112 (autoload 'eval-when "cl-macs" "\
|
|
|
113 (eval-when (WHEN...) BODY...): control when BODY is evaluated.
|
|
|
114 If `compile' is in WHEN, BODY is evaluated when compiled at top-level.
|
|
|
115 If `load' is in WHEN, BODY is evaluated when loaded after top-level compile.
|
|
|
116 If `eval' is in WHEN, BODY is evaluated when interpreted or at non-top-level." nil 'macro)
|
|
|
117
|
|
|
118 (autoload 'load-time-value "cl-macs" "\
|
|
|
119 Like `progn', but evaluates the body at load time.
|
|
|
120 The result of the body appears to the compiler as a quoted constant." nil 'macro)
|
|
|
121
|
|
|
122 (autoload 'case "cl-macs" "\
|
|
|
123 (case EXPR CLAUSES...): evals EXPR, chooses from CLAUSES on that value.
|
|
|
124 Each clause looks like (KEYLIST BODY...). EXPR is evaluated and compared
|
|
|
125 against each key in each KEYLIST; the corresponding BODY is evaluated.
|
|
|
126 If no clause succeeds, case returns nil. A single atom may be used in
|
|
|
127 place of a KEYLIST of one atom. A KEYLIST of `t' or `otherwise' is
|
|
|
128 allowed only in the final clause, and matches if no other keys match.
|
|
|
129 Key values are compared by `eql'." nil 'macro)
|
|
|
130
|
|
|
131 (autoload 'ecase "cl-macs" "\
|
|
|
132 (ecase EXPR CLAUSES...): like `case', but error if no case fits.
|
|
|
133 `otherwise'-clauses are not allowed." nil 'macro)
|
|
|
134
|
|
|
135 (autoload 'typecase "cl-macs" "\
|
|
|
136 (typecase EXPR CLAUSES...): evals EXPR, chooses from CLAUSES on that value.
|
|
|
137 Each clause looks like (TYPE BODY...). EXPR is evaluated and, if it
|
|
|
138 satisfies TYPE, the corresponding BODY is evaluated. If no clause succeeds,
|
|
|
139 typecase returns nil. A TYPE of `t' or `otherwise' is allowed only in the
|
|
|
140 final clause, and matches if no other keys match." nil 'macro)
|
|
|
141
|
|
|
142 (autoload 'etypecase "cl-macs" "\
|
|
|
143 (etypecase EXPR CLAUSES...): like `typecase', but error if no case fits.
|
|
|
144 `otherwise'-clauses are not allowed." nil 'macro)
|
|
|
145
|
|
|
146 (autoload 'block "cl-macs" "\
|
|
|
147 (block NAME BODY...): define a lexically-scoped block named NAME.
|
|
|
148 NAME may be any symbol. Code inside the BODY forms can call `return-from'
|
|
|
149 to jump prematurely out of the block. This differs from `catch' and `throw'
|
|
|
150 in two respects: First, the NAME is an unevaluated symbol rather than a
|
|
|
151 quoted symbol or other form; and second, NAME is lexically rather than
|
|
|
152 dynamically scoped: Only references to it within BODY will work. These
|
|
|
153 references may appear inside macro expansions, but not inside functions
|
|
|
154 called from BODY." nil 'macro)
|
|
|
155
|
|
|
156 (autoload 'return "cl-macs" "\
|
|
|
157 (return [RESULT]): return from the block named nil.
|
|
|
158 This is equivalent to `(return-from nil RESULT)'." nil 'macro)
|
|
|
159
|
|
|
160 (autoload 'return-from "cl-macs" "\
|
|
|
161 (return-from NAME [RESULT]): return from the block named NAME.
|
|
|
162 This jump out to the innermost enclosing `(block NAME ...)' form,
|
|
|
163 returning RESULT from that form (or nil if RESULT is omitted).
|
|
|
164 This is compatible with Common Lisp, but note that `defun' and
|
|
|
165 `defmacro' do not create implicit blocks as they do in Common Lisp." nil 'macro)
|
|
|
166
|
|
|
167 (autoload 'loop "cl-macs" "\
|
|
|
168 (loop CLAUSE...): The Common Lisp `loop' macro.
|
|
|
169 Valid clauses are:
|
|
|
170 for VAR from/upfrom/downfrom NUM to/upto/downto/above/below NUM by NUM,
|
|
|
171 for VAR in LIST by FUNC, for VAR on LIST by FUNC, for VAR = INIT then EXPR,
|
|
|
172 for VAR across ARRAY, repeat NUM, with VAR = INIT, while COND, until COND,
|
|
|
173 always COND, never COND, thereis COND, collect EXPR into VAR,
|
|
|
174 append EXPR into VAR, nconc EXPR into VAR, sum EXPR into VAR,
|
|
|
175 count EXPR into VAR, maximize EXPR into VAR, minimize EXPR into VAR,
|
|
|
176 if COND CLAUSE [and CLAUSE]... else CLAUSE [and CLAUSE...],
|
|
|
177 unless COND CLAUSE [and CLAUSE]... else CLAUSE [and CLAUSE...],
|
|
|
178 do EXPRS..., initially EXPRS..., finally EXPRS..., return EXPR,
|
|
|
179 finally return EXPR, named NAME." nil 'macro)
|
|
|
180
|
|
|
181 (autoload 'do "cl-macs" "\
|
|
|
182 The Common Lisp `do' loop.
|
|
|
183 Format is: (do ((VAR INIT [STEP])...) (END-TEST [RESULT...]) BODY...)" nil 'macro)
|
|
|
184
|
|
|
185 (autoload 'do* "cl-macs" "\
|
|
|
186 The Common Lisp `do*' loop.
|
|
|
187 Format is: (do* ((VAR INIT [STEP])...) (END-TEST [RESULT...]) BODY...)" nil 'macro)
|
|
|
188
|
|
|
189 (autoload 'dolist "cl-macs" "\
|
|
|
190 (dolist (VAR LIST [RESULT]) BODY...): loop over a list.
|
|
|
191 Evaluate BODY with VAR bound to each `car' from LIST, in turn.
|
|
|
192 Then evaluate RESULT to get return value, default nil." nil 'macro)
|
|
|
193
|
|
|
194 (autoload 'dotimes "cl-macs" "\
|
|
|
195 (dotimes (VAR COUNT [RESULT]) BODY...): loop a certain number of times.
|
|
|
196 Evaluate BODY with VAR bound to successive integers from 0, inclusive,
|
|
|
197 to COUNT, exclusive. Then evaluate RESULT to get return value, default
|
|
|
198 nil." nil 'macro)
|
|
|
199
|
|
|
200 (autoload 'do-symbols "cl-macs" "\
|
|
|
201 (dosymbols (VAR [OBARRAY [RESULT]]) BODY...): loop over all symbols.
|
|
|
202 Evaluate BODY with VAR bound to each interned symbol, or to each symbol
|
|
|
203 from OBARRAY." nil 'macro)
|
|
|
204
|
|
|
205 (autoload 'do-all-symbols "cl-macs" nil nil 'macro)
|
|
|
206
|
|
|
207 (autoload 'psetq "cl-macs" "\
|
|
|
208 (psetq SYM VAL SYM VAL ...): set SYMs to the values VALs in parallel.
|
|
|
209 This is like `setq', except that all VAL forms are evaluated (in order)
|
|
|
210 before assigning any symbols SYM to the corresponding values." nil 'macro)
|
|
|
211
|
|
|
212 (autoload 'progv "cl-macs" "\
|
|
|
213 (progv SYMBOLS VALUES BODY...): bind SYMBOLS to VALUES dynamically in BODY.
|
|
|
214 The forms SYMBOLS and VALUES are evaluated, and must evaluate to lists.
|
|
|
215 Each SYMBOL in the first list is bound to the corresponding VALUE in the
|
|
|
216 second list (or made unbound if VALUES is shorter than SYMBOLS); then the
|
|
|
217 BODY forms are executed and their result is returned. This is much like
|
|
|
218 a `let' form, except that the list of symbols can be computed at run-time." nil 'macro)
|
|
|
219
|
|
|
220 (autoload 'flet "cl-macs" "\
|
|
|
221 (flet ((FUNC ARGLIST BODY...) ...) FORM...): make temporary function defns.
|
|
|
222 This is an analogue of `let' that operates on the function cell of FUNC
|
|
|
223 rather than its value cell. The FORMs are evaluated with the specified
|
|
|
224 function definitions in place, then the definitions are undone (the FUNCs
|
|
|
225 go back to their previous definitions, or lack thereof)." nil 'macro)
|
|
|
226
|
|
|
227 (autoload 'labels "cl-macs" "\
|
|
|
228 (labels ((FUNC ARGLIST BODY...) ...) FORM...): make temporary func bindings.
|
|
|
229 This is like `flet', except the bindings are lexical instead of dynamic.
|
|
|
230 Unlike `flet', this macro is fully complaint with the Common Lisp standard." nil 'macro)
|
|
|
231
|
|
|
232 (autoload 'macrolet "cl-macs" "\
|
|
|
233 (macrolet ((NAME ARGLIST BODY...) ...) FORM...): make temporary macro defns.
|
|
|
234 This is like `flet', but for macros instead of functions." nil 'macro)
|
|
|
235
|
|
|
236 (autoload 'symbol-macrolet "cl-macs" "\
|
|
|
237 (symbol-macrolet ((NAME EXPANSION) ...) FORM...): make symbol macro defns.
|
|
|
238 Within the body FORMs, references to the variable NAME will be replaced
|
|
|
239 by EXPANSION, and (setq NAME ...) will act like (setf EXPANSION ...)." nil 'macro)
|
|
|
240
|
|
|
241 (autoload 'lexical-let "cl-macs" "\
|
|
|
242 (lexical-let BINDINGS BODY...): like `let', but lexically scoped.
|
|
|
243 The main visible difference is that lambdas inside BODY will create
|
|
|
244 lexical closures as in Common Lisp." nil 'macro)
|
|
|
245
|
|
|
246 (autoload 'lexical-let* "cl-macs" "\
|
|
|
247 (lexical-let* BINDINGS BODY...): like `let*', but lexically scoped.
|
|
|
248 The main visible difference is that lambdas inside BODY will create
|
|
|
249 lexical closures as in Common Lisp." nil 'macro)
|
|
|
250
|
|
|
251 (autoload 'multiple-value-bind "cl-macs" "\
|
|
|
252 (multiple-value-bind (SYM SYM...) FORM BODY): collect multiple return values.
|
|
|
253 FORM must return a list; the BODY is then executed with the first N elements
|
|
|
254 of this list bound (`let'-style) to each of the symbols SYM in turn. This
|
|
|
255 is analogous to the Common Lisp `multiple-value-bind' macro, using lists to
|
|
|
256 simulate true multiple return values. For compatibility, (values A B C) is
|
|
|
257 a synonym for (list A B C)." nil 'macro)
|
|
|
258
|
|
|
259 (autoload 'multiple-value-setq "cl-macs" "\
|
|
|
260 (multiple-value-setq (SYM SYM...) FORM): collect multiple return values.
|
|
|
261 FORM must return a list; the first N elements of this list are stored in
|
|
|
262 each of the symbols SYM in turn. This is analogous to the Common Lisp
|
|
|
263 `multiple-value-setq' macro, using lists to simulate true multiple return
|
|
|
264 values. For compatibility, (values A B C) is a synonym for (list A B C)." nil 'macro)
|
|
|
265
|
|
|
266 (autoload 'locally "cl-macs" nil nil 'macro)
|
|
|
267
|
|
|
268 (autoload 'the "cl-macs" nil nil 'macro)
|
|
|
269
|
|
|
270 (autoload 'declare "cl-macs" nil nil 'macro)
|
|
|
271
|
|
|
272 (autoload 'define-setf-method "cl-macs" "\
|
|
|
273 (define-setf-method NAME ARGLIST BODY...): define a `setf' method.
|
|
|
274 This method shows how to handle `setf's to places of the form (NAME ARGS...).
|
|
|
275 The argument forms ARGS are bound according to ARGLIST, as if NAME were
|
|
|
276 going to be expanded as a macro, then the BODY forms are executed and must
|
|
|
277 return a list of five elements: a temporary-variables list, a value-forms
|
|
|
278 list, a store-variables list (of length one), a store-form, and an access-
|
|
|
279 form. See `defsetf' for a simpler way to define most setf-methods." nil 'macro)
|
|
|
280
|
|
|
281 (autoload 'defsetf "cl-macs" "\
|
|
|
282 (defsetf NAME FUNC): define a `setf' method.
|
|
|
283 This macro is an easy-to-use substitute for `define-setf-method' that works
|
|
|
284 well for simple place forms. In the simple `defsetf' form, `setf's of
|
|
|
285 the form (setf (NAME ARGS...) VAL) are transformed to function or macro
|
|
|
286 calls of the form (FUNC ARGS... VAL). Example: (defsetf aref aset).
|
|
|
287 Alternate form: (defsetf NAME ARGLIST (STORE) BODY...).
|
|
|
288 Here, the above `setf' call is expanded by binding the argument forms ARGS
|
|
|
289 according to ARGLIST, binding the value form VAL to STORE, then executing
|
|
|
290 BODY, which must return a Lisp form that does the necessary `setf' operation.
|
|
|
291 Actually, ARGLIST and STORE may be bound to temporary variables which are
|
|
|
292 introduced automatically to preserve proper execution order of the arguments.
|
|
|
293 Example: (defsetf nth (n x) (v) (list 'setcar (list 'nthcdr n x) v))." nil 'macro)
|
|
|
294
|
|
|
295 (autoload 'get-setf-method "cl-macs" "\
|
|
|
296 Return a list of five values describing the setf-method for PLACE.
|
|
|
297 PLACE may be any Lisp form which can appear as the PLACE argument to
|
|
|
298 a macro like `setf' or `incf'." nil nil)
|
|
|
299
|
|
|
300 (autoload 'setf "cl-macs" "\
|
|
|
301 (setf PLACE VAL PLACE VAL ...): set each PLACE to the value of its VAL.
|
|
|
302 This is a generalized version of `setq'; the PLACEs may be symbolic
|
|
|
303 references such as (car x) or (aref x i), as well as plain symbols.
|
|
|
304 For example, (setf (cadar x) y) is equivalent to (setcar (cdar x) y).
|
|
|
305 The return value is the last VAL in the list." nil 'macro)
|
|
|
306
|
|
|
307 (autoload 'psetf "cl-macs" "\
|
|
|
308 (psetf PLACE VAL PLACE VAL ...): set PLACEs to the values VALs in parallel.
|
|
|
309 This is like `setf', except that all VAL forms are evaluated (in order)
|
|
|
310 before assigning any PLACEs to the corresponding values." nil 'macro)
|
|
|
311
|
|
|
312 (autoload 'cl-do-pop "cl-macs" nil nil nil)
|
|
|
313
|
|
|
314 (autoload 'remf "cl-macs" "\
|
|
|
315 (remf PLACE TAG): remove TAG from property list PLACE.
|
|
|
316 PLACE may be a symbol, or any generalized variable allowed by `setf'.
|
|
|
317 The form returns true if TAG was found and removed, nil otherwise." nil 'macro)
|
|
|
318
|
|
|
319 (autoload 'shiftf "cl-macs" "\
|
|
|
320 (shiftf PLACE PLACE... VAL): shift left among PLACEs.
|
|
|
321 Example: (shiftf A B C) sets A to B, B to C, and returns the old A.
|
|
|
322 Each PLACE may be a symbol, or any generalized variable allowed by `setf'." nil 'macro)
|
|
|
323
|
|
|
324 (autoload 'rotatef "cl-macs" "\
|
|
|
325 (rotatef PLACE...): rotate left among PLACEs.
|
|
|
326 Example: (rotatef A B C) sets A to B, B to C, and C to A. It returns nil.
|
|
|
327 Each PLACE may be a symbol, or any generalized variable allowed by `setf'." nil 'macro)
|
|
|
328
|
|
|
329 (autoload 'letf "cl-macs" "\
|
|
|
330 (letf ((PLACE VALUE) ...) BODY...): temporarily bind to PLACEs.
|
|
|
331 This is the analogue of `let', but with generalized variables (in the
|
|
|
332 sense of `setf') for the PLACEs. Each PLACE is set to the corresponding
|
|
|
333 VALUE, then the BODY forms are executed. On exit, either normally or
|
|
|
334 because of a `throw' or error, the PLACEs are set back to their original
|
|
|
335 values. Note that this macro is *not* available in Common Lisp.
|
|
|
336 As a special case, if `(PLACE)' is used instead of `(PLACE VALUE)',
|
|
|
337 the PLACE is not modified before executing BODY." nil 'macro)
|
|
|
338
|
|
|
339 (autoload 'letf* "cl-macs" "\
|
|
|
340 (letf* ((PLACE VALUE) ...) BODY...): temporarily bind to PLACEs.
|
|
|
341 This is the analogue of `let*', but with generalized variables (in the
|
|
|
342 sense of `setf') for the PLACEs. Each PLACE is set to the corresponding
|
|
|
343 VALUE, then the BODY forms are executed. On exit, either normally or
|
|
|
344 because of a `throw' or error, the PLACEs are set back to their original
|
|
|
345 values. Note that this macro is *not* available in Common Lisp.
|
|
|
346 As a special case, if `(PLACE)' is used instead of `(PLACE VALUE)',
|
|
|
347 the PLACE is not modified before executing BODY." nil 'macro)
|
|
|
348
|
|
|
349 (autoload 'callf "cl-macs" "\
|
|
|
350 (callf FUNC PLACE ARGS...): set PLACE to (FUNC PLACE ARGS...).
|
|
|
351 FUNC should be an unquoted function name. PLACE may be a symbol,
|
|
|
352 or any generalized variable allowed by `setf'." nil 'macro)
|
|
|
353
|
|
|
354 (autoload 'callf2 "cl-macs" "\
|
|
|
355 (callf2 FUNC ARG1 PLACE ARGS...): set PLACE to (FUNC ARG1 PLACE ARGS...).
|
|
|
356 Like `callf', but PLACE is the second argument of FUNC, not the first." nil 'macro)
|
|
|
357
|
|
|
358 (autoload 'define-modify-macro "cl-macs" "\
|
|
|
359 (define-modify-macro NAME ARGLIST FUNC): define a `setf'-like modify macro.
|
|
|
360 If NAME is called, it combines its PLACE argument with the other arguments
|
|
|
361 from ARGLIST using FUNC: (define-modify-macro incf (&optional (n 1)) +)" nil 'macro)
|
|
|
362
|
|
|
363 (autoload 'defstruct "cl-macs" "\
|
|
|
364 (defstruct (NAME OPTIONS...) (SLOT SLOT-OPTS...)...): define a struct type.
|
|
|
365 This macro defines a new Lisp data type called NAME, which contains data
|
|
|
366 stored in SLOTs. This defines a `make-NAME' constructor, a `copy-NAME'
|
|
|
367 copier, a `NAME-p' predicate, and setf-able `NAME-SLOT' accessors." nil 'macro)
|
|
|
368
|
|
|
369 (autoload 'cl-struct-setf-expander "cl-macs" nil nil nil)
|
|
|
370
|
|
|
371 (autoload 'deftype "cl-macs" "\
|
|
|
372 (deftype NAME ARGLIST BODY...): define NAME as a new data type.
|
|
|
373 The type name can then be used in `typecase', `check-type', etc." nil 'macro)
|
|
|
374
|
|
|
375 (autoload 'typep "cl-macs" "\
|
|
|
376 Check that OBJECT is of type TYPE.
|
|
|
377 TYPE is a Common Lisp-style type specifier." nil nil)
|
|
|
378
|
|
|
379 (autoload 'check-type "cl-macs" "\
|
|
|
380 Verify that FORM is of type TYPE; signal an error if not.
|
|
|
381 STRING is an optional description of the desired type." nil 'macro)
|
|
|
382
|
|
|
383 (autoload 'assert "cl-macs" "\
|
|
|
384 Verify that FORM returns non-nil; signal an error if not.
|
|
|
385 Second arg SHOW-ARGS means to include arguments of FORM in message.
|
|
|
386 Other args STRING and ARGS... are arguments to be passed to `error'.
|
|
|
387 They are not evaluated unless the assertion fails. If STRING is
|
|
|
388 omitted, a default message listing FORM itself is used." nil 'macro)
|
|
|
389
|
|
|
390 (autoload 'ignore-errors "cl-macs" "\
|
|
|
391 Execute FORMS; if an error occurs, return nil.
|
|
|
392 Otherwise, return result of last FORM." nil 'macro)
|
|
|
393
|
|
|
394 (autoload 'define-compiler-macro "cl-macs" "\
|
|
|
395 (define-compiler-macro FUNC ARGLIST BODY...): Define a compiler-only macro.
|
|
|
396 This is like `defmacro', but macro expansion occurs only if the call to
|
|
|
397 FUNC is compiled (i.e., not interpreted). Compiler macros should be used
|
|
|
398 for optimizing the way calls to FUNC are compiled; the form returned by
|
|
|
399 BODY should do the same thing as a call to the normal function called
|
|
|
400 FUNC, though possibly more efficiently. Note that, like regular macros,
|
|
|
401 compiler macros are expanded repeatedly until no further expansions are
|
|
|
402 possible. Unlike regular macros, BODY can decide to \"punt\" and leave the
|
|
|
403 original function call alone by declaring an initial `&whole foo' parameter
|
|
|
404 and then returning foo." nil 'macro)
|
|
|
405
|
|
|
406 (autoload 'compiler-macroexpand "cl-macs" nil nil nil)
|
|
|
407
|
|
|
408 ;;;***
|
|
|
409
|
|
|
410 ;;;### (autoloads (Custom-make-dependencies) "cus-dep" "lisp/cus-dep.el")
|
|
|
411
|
|
|
412 (autoload 'Custom-make-dependencies "cus-dep" "\
|
|
|
413 Extract custom dependencies from .el files in SUBDIRS.
|
|
|
414 SUBDIRS is a list of directories. If it is nil, the command-line
|
|
|
415 arguments are used. If it is a string, only that directory is
|
|
|
416 processed. This function is especially useful in batch mode.
|
|
|
417
|
|
|
418 Batch usage: xemacs -batch -l cus-dep.el -f Custom-make-dependencies DIRS" t nil)
|
|
|
419
|
|
|
420 ;;;***
|
|
|
421
|
|
|
422 ;;;### (autoloads (customize-menu-create custom-menu-create custom-save-all customize-save-customized customize-browse custom-buffer-create-other-window custom-buffer-create customize-apropos-groups customize-apropos-faces customize-apropos-options customize-apropos customize-saved customize-customized customize-face-other-window customize-face customize-option-other-window customize-variable customize-other-window customize customize-save-variable customize-set-variable customize-set-value) "cus-edit" "lisp/cus-edit.el")
|
|
|
423
|
|
|
424 (autoload 'customize-set-value "cus-edit" "\
|
|
|
425 Set VARIABLE to VALUE. VALUE is a Lisp object.
|
|
|
426
|
|
|
427 If VARIABLE has a `variable-interactive' property, that is used as if
|
|
|
428 it were the arg to `interactive' (which see) to interactively read the value.
|
|
|
429
|
|
|
430 If VARIABLE has a `custom-type' property, it must be a widget and the
|
|
|
431 `:prompt-value' property of that widget will be used for reading the value." t nil)
|
|
|
432
|
|
|
433 (autoload 'customize-set-variable "cus-edit" "\
|
|
|
434 Set the default for VARIABLE to VALUE. VALUE is a Lisp object.
|
|
|
435
|
|
|
436 If VARIABLE has a `custom-set' property, that is used for setting
|
|
|
437 VARIABLE, otherwise `set-default' is used.
|
|
|
438
|
|
|
439 The `customized-value' property of the VARIABLE will be set to a list
|
|
|
440 with a quoted VALUE as its sole list member.
|
|
|
441
|
|
|
442 If VARIABLE has a `variable-interactive' property, that is used as if
|
|
|
443 it were the arg to `interactive' (which see) to interactively read the value.
|
|
|
444
|
|
|
445 If VARIABLE has a `custom-type' property, it must be a widget and the
|
|
|
446 `:prompt-value' property of that widget will be used for reading the value. " t nil)
|
|
|
447
|
|
|
448 (autoload 'customize-save-variable "cus-edit" "\
|
|
|
449 Set the default for VARIABLE to VALUE, and save it for future sessions.
|
|
|
450 If VARIABLE has a `custom-set' property, that is used for setting
|
|
|
451 VARIABLE, otherwise `set-default' is used.
|
|
|
452
|
|
|
453 The `customized-value' property of the VARIABLE will be set to a list
|
|
|
454 with a quoted VALUE as its sole list member.
|
|
|
455
|
|
|
456 If VARIABLE has a `variable-interactive' property, that is used as if
|
|
|
457 it were the arg to `interactive' (which see) to interactively read the value.
|
|
|
458
|
|
|
459 If VARIABLE has a `custom-type' property, it must be a widget and the
|
|
|
460 `:prompt-value' property of that widget will be used for reading the value. " t nil)
|
|
|
461
|
|
|
462 (autoload 'customize "cus-edit" "\
|
|
|
463 Select a customization buffer which you can use to set user options.
|
|
|
464 User options are structured into \"groups\".
|
|
|
465 The default group is `Emacs'." t nil)
|
|
|
466
|
|
|
467 (defalias 'customize-group 'customize)
|
|
|
468
|
|
|
469 (autoload 'customize-other-window "cus-edit" "\
|
|
|
470 Customize SYMBOL, which must be a customization group." t nil)
|
|
|
471
|
|
|
472 (defalias 'customize-group-other-window 'customize-other-window)
|
|
|
473
|
|
|
474 (defalias 'customize-option 'customize-variable)
|
|
|
475
|
|
|
476 (autoload 'customize-variable "cus-edit" "\
|
|
|
477 Customize SYMBOL, which must be a user option variable." t nil)
|
|
|
478
|
|
|
479 (defalias 'customize-variable-other-window 'customize-option-other-window)
|
|
|
480
|
|
|
481 (autoload 'customize-option-other-window "cus-edit" "\
|
|
|
482 Customize SYMBOL, which must be a user option variable.
|
|
|
483 Show the buffer in another window, but don't select it." t nil)
|
|
|
484
|
|
|
485 (autoload 'customize-face "cus-edit" "\
|
|
|
486 Customize SYMBOL, which should be a face name or nil.
|
|
|
487 If SYMBOL is nil, customize all faces." t nil)
|
|
|
488
|
|
|
489 (autoload 'customize-face-other-window "cus-edit" "\
|
|
|
490 Show customization buffer for FACE in other window." t nil)
|
|
|
491
|
|
|
492 (autoload 'customize-customized "cus-edit" "\
|
|
|
493 Customize all user options set since the last save in this session." t nil)
|
|
|
494
|
|
|
495 (autoload 'customize-saved "cus-edit" "\
|
|
|
496 Customize all already saved user options." t nil)
|
|
|
497
|
|
|
498 (autoload 'customize-apropos "cus-edit" "\
|
|
|
499 Customize all user options matching REGEXP.
|
|
|
500 If ALL is `options', include only options.
|
|
|
501 If ALL is `faces', include only faces.
|
|
|
502 If ALL is `groups', include only groups.
|
|
|
503 If ALL is t (interactively, with prefix arg), include options which are not
|
|
|
504 user-settable, as well as faces and groups." t nil)
|
|
|
505
|
|
|
506 (autoload 'customize-apropos-options "cus-edit" "\
|
|
|
507 Customize all user options matching REGEXP.
|
|
|
508 With prefix arg, include options which are not user-settable." t nil)
|
|
|
509
|
|
|
510 (autoload 'customize-apropos-faces "cus-edit" "\
|
|
|
511 Customize all user faces matching REGEXP." t nil)
|
|
|
512
|
|
|
513 (autoload 'customize-apropos-groups "cus-edit" "\
|
|
|
514 Customize all user groups matching REGEXP." t nil)
|
|
|
515
|
|
|
516 (autoload 'custom-buffer-create "cus-edit" "\
|
|
|
517 Create a buffer containing OPTIONS.
|
|
|
518 Optional NAME is the name of the buffer.
|
|
|
519 OPTIONS should be an alist of the form ((SYMBOL WIDGET)...), where
|
|
|
520 SYMBOL is a customization option, and WIDGET is a widget for editing
|
|
|
521 that option." nil nil)
|
|
|
522
|
|
|
523 (autoload 'custom-buffer-create-other-window "cus-edit" "\
|
|
|
524 Create a buffer containing OPTIONS.
|
|
|
525 Optional NAME is the name of the buffer.
|
|
|
526 OPTIONS should be an alist of the form ((SYMBOL WIDGET)...), where
|
|
|
527 SYMBOL is a customization option, and WIDGET is a widget for editing
|
|
|
528 that option." nil nil)
|
|
|
529
|
|
|
530 (autoload 'customize-browse "cus-edit" "\
|
|
|
531 Create a tree browser for the customize hierarchy." t nil)
|
|
|
532
|
|
|
533 (defcustom custom-file (if (boundp 'emacs-user-extension-dir) (concat "~" init-file-user emacs-user-extension-dir "options.el") "~/.emacs") "File used for storing customization information.\nIf you change this from the default \"~/.emacs\" you need to\nexplicitly load that file for the settings to take effect." :type 'file :group 'customize)
|
|
|
534
|
|
|
535 (autoload 'customize-save-customized "cus-edit" "\
|
|
|
536 Save all user options which have been set in this session." t nil)
|
|
|
537
|
|
|
538 (autoload 'custom-save-all "cus-edit" "\
|
|
|
539 Save all customizations in `custom-file'." nil nil)
|
|
|
540
|
|
|
541 (autoload 'custom-menu-create "cus-edit" "\
|
|
|
542 Create menu for customization group SYMBOL.
|
|
|
543 The menu is in a format applicable to `easy-menu-define'." nil nil)
|
|
|
544
|
|
|
545 (autoload 'customize-menu-create "cus-edit" "\
|
|
|
546 Return a customize menu for customization group SYMBOL.
|
|
|
547 If optional NAME is given, use that as the name of the menu.
|
|
|
548 Otherwise the menu will be named `Customize'.
|
|
|
549 The format is suitable for use with `easy-menu-define'." nil nil)
|
|
|
550
|
|
|
551 ;;;***
|
|
|
552
|
|
|
553 ;;;### (autoloads (custom-set-faces custom-declare-face) "cus-face" "lisp/cus-face.el")
|
|
|
554
|
|
|
555 (autoload 'custom-declare-face "cus-face" "\
|
|
|
556 Like `defface', but FACE is evaluated as a normal argument." nil nil)
|
|
|
557
|
|
|
558 (autoload 'custom-set-faces "cus-face" "\
|
|
|
559 Initialize faces according to user preferences.
|
|
|
560 The arguments should be a list where each entry has the form:
|
|
|
561
|
|
|
562 (FACE SPEC [NOW])
|
|
|
563
|
|
|
564 SPEC will be stored as the saved value for FACE. If NOW is present
|
|
|
565 and non-nil, FACE will also be created according to SPEC.
|
|
|
566
|
|
|
567 See `defface' for the format of SPEC." nil nil)
|
|
|
568
|
|
|
569 ;;;***
|
|
|
570
|
|
|
571 ;;;### (autoloads (disassemble) "disass" "lisp/disass.el")
|
|
|
572
|
|
|
573 (autoload 'disassemble "disass" "\
|
|
|
574 Print disassembled code for OBJECT in (optional) BUFFER.
|
|
|
575 OBJECT can be a symbol defined as a function, or a function itself
|
|
|
576 \(a lambda expression or a compiled-function object).
|
|
|
577 If OBJECT is not already compiled, we compile it, but do not
|
|
|
578 redefine OBJECT if it is a symbol." t nil)
|
|
|
579
|
|
|
580 ;;;***
|
|
|
581
|
|
|
582 ;;;### (autoloads (widget-minor-mode widget-browse-other-window widget-browse widget-browse-at) "wid-browse" "lisp/wid-browse.el")
|
|
|
583
|
|
|
584 (autoload 'widget-browse-at "wid-browse" "\
|
|
|
585 Browse the widget under point." t nil)
|
|
|
586
|
|
|
587 (autoload 'widget-browse "wid-browse" "\
|
|
|
588 Create a widget browser for WIDGET." t nil)
|
|
|
589
|
|
|
590 (autoload 'widget-browse-other-window "wid-browse" "\
|
|
|
591 Show widget browser for WIDGET in other window." t nil)
|
|
|
592
|
|
|
593 (autoload 'widget-minor-mode "wid-browse" "\
|
|
|
594 Togle minor mode for traversing widgets.
|
|
|
595 With arg, turn widget mode on if and only if arg is positive." t nil)
|
|
|
596
|
|
|
597 ;;;***
|
|
|
598
|
|
|
599 ;;;### (autoloads (widget-delete widget-create widget-prompt-value) "wid-edit" "lisp/wid-edit.el")
|
|
|
600
|
|
|
601 (autoload 'widget-prompt-value "wid-edit" "\
|
|
|
602 Prompt for a value matching WIDGET, using PROMPT.
|
|
|
603 The current value is assumed to be VALUE, unless UNBOUND is non-nil." nil nil)
|
|
|
604
|
|
|
605 (autoload 'widget-create "wid-edit" "\
|
|
|
606 Create widget of TYPE.
|
|
|
607 The optional ARGS are additional keyword arguments." nil nil)
|
|
|
608
|
|
|
609 (autoload 'widget-delete "wid-edit" "\
|
|
|
610 Delete WIDGET." nil nil)
|
|
|
611
|
|
|
612 ;;;***
|
|
|
613
|
|
|
614 ;;;### (autoloads (font-menu-weight-constructor font-menu-size-constructor font-menu-family-constructor reset-device-font-menus) "x-font-menu" "lisp/x-font-menu.el")
|
|
|
615
|
|
|
616 (defcustom font-menu-ignore-scaled-fonts t "*If non-nil, then the font menu will try to show only bitmap fonts." :type 'boolean :group 'x)
|
|
|
617
|
|
|
618 (defcustom font-menu-this-frame-only-p nil "*If non-nil, then changing the default font from the font menu will only\naffect one frame instead of all frames." :type 'boolean :group 'x)
|
|
|
619
|
|
|
620 (fset 'install-font-menus 'reset-device-font-menus)
|
|
|
621
|
|
|
622 (autoload 'reset-device-font-menus "x-font-menu" "\
|
|
|
623 Generates the `Font', `Size', and `Weight' submenus for the Options menu.
|
|
|
624 This is run the first time that a font-menu is needed for each device.
|
|
|
625 If you don't like the lazy invocation of this function, you can add it to
|
|
|
626 `create-device-hook' and that will make the font menus respond more quickly
|
|
|
627 when they are selected for the first time. If you add fonts to your system,
|
|
|
628 or if you change your font path, you can call this to re-initialize the menus." nil nil)
|
|
|
629
|
|
|
630 (autoload 'font-menu-family-constructor "x-font-menu" nil nil nil)
|
|
|
631
|
|
|
632 (autoload 'font-menu-size-constructor "x-font-menu" nil nil nil)
|
|
|
633
|
|
|
634 (autoload 'font-menu-weight-constructor "x-font-menu" nil nil nil)
|
|
|
635
|
|
|
636 ;;;***
|
|
|
637
|
|
|
638 (provide 'TopLevel-autoloads)
|
