|
209
|
1 ;;; DO NOT MODIFY THIS FILE
|
|
217
|
2 (if (featurep 'Standard-autoloads) (error "Already loaded"))
|
|
|
3
|
|
|
4 ;;;### (autoloads nil "abbrev" "lisp/abbrev.el")
|
|
|
5
|
|
|
6 ;;;***
|
|
|
7
|
|
|
8 ;;;### (autoloads (about-xemacs) "about" "lisp/about.el")
|
|
|
9
|
|
|
10 (autoload 'about-xemacs "about" "\
|
|
|
11 Describe the True Editor and its minions." t nil)
|
|
|
12
|
|
|
13 ;;;***
|
|
|
14
|
|
|
15 ;;;### (autoloads (apropos-documentation apropos-value apropos apropos-command) "apropos" "lisp/apropos.el")
|
|
|
16
|
|
|
17 (fset 'command-apropos 'apropos-command)
|
|
|
18
|
|
|
19 (autoload 'apropos-command "apropos" "\
|
|
|
20 Shows commands (interactively callable functions) that match REGEXP.
|
|
|
21 With optional prefix ARG or if `apropos-do-all' is non-nil, also show
|
|
|
22 variables." t nil)
|
|
|
23
|
|
|
24 (autoload 'apropos "apropos" "\
|
|
|
25 Show all bound symbols whose names match REGEXP.
|
|
|
26 With optional prefix ARG or if `apropos-do-all' is non-nil, also show unbound
|
|
|
27 symbols and key bindings, which is a little more time-consuming.
|
|
|
28 Returns list of symbols and documentation found." t nil)
|
|
|
29
|
|
|
30 (autoload 'apropos-value "apropos" "\
|
|
|
31 Show all symbols whose value's printed image matches REGEXP.
|
|
|
32 With optional prefix ARG or if `apropos-do-all' is non-nil, also looks
|
|
|
33 at the function and at the names and values of properties.
|
|
|
34 Returns list of symbols and values found." t nil)
|
|
|
35
|
|
|
36 (autoload 'apropos-documentation "apropos" "\
|
|
|
37 Show symbols whose documentation contain matches for REGEXP.
|
|
|
38 With optional prefix ARG or if `apropos-do-all' is non-nil, also use
|
|
|
39 documentation that is not stored in the documentation file and show key
|
|
|
40 bindings.
|
|
|
41 Returns list of symbols and documentation found." t nil)
|
|
|
42
|
|
|
43 ;;;***
|
|
|
44
|
|
|
45 ;;;### (autoloads (batch-update-directory batch-update-autoloads update-autoloads-from-directory update-autoloads-here update-file-autoloads generate-file-autoloads) "autoload" "lisp/autoload.el")
|
|
|
46
|
|
|
47 (autoload 'generate-file-autoloads "autoload" "\
|
|
|
48 Insert at point a loaddefs autoload section for FILE.
|
|
|
49 autoloads are generated for defuns and defmacros in FILE
|
|
|
50 marked by `generate-autoload-cookie' (which see).
|
|
|
51 If FILE is being visited in a buffer, the contents of the buffer
|
|
|
52 are used." t nil)
|
|
|
53
|
|
|
54 (autoload 'update-file-autoloads "autoload" "\
|
|
|
55 Update the autoloads for FILE in `generated-autoload-file'
|
|
|
56 \(which FILE might bind in its local variables).
|
|
|
57 This functions refuses to update autoloads files." t nil)
|
|
|
58
|
|
|
59 (autoload 'update-autoloads-here "autoload" "\
|
|
|
60 Update sections of the current buffer generated by `update-file-autoloads'." t nil)
|
|
|
61
|
|
|
62 (autoload 'update-autoloads-from-directory "autoload" "\
|
|
|
63 Update `generated-autoload-file' with all the current autoloads from DIR.
|
|
|
64 This runs `update-file-autoloads' on each .el file in DIR.
|
|
|
65 Obsolete autoload entries for files that no longer exist are deleted." t nil)
|
|
|
66
|
|
|
67 (autoload 'batch-update-autoloads "autoload" "\
|
|
|
68 Update the autoloads for the files or directories on the command line.
|
|
|
69 Runs `update-file-autoloads' on files and `update-directory-autoloads'
|
|
|
70 on directories. Must be used only with -batch, and kills Emacs on completion.
|
|
|
71 Each file will be processed even if an error occurred previously.
|
|
|
72 For example, invoke `xemacs -batch -f batch-update-autoloads *.el'.
|
|
|
73 The directory to which the auto-autoloads.el file must be the first parameter
|
|
|
74 on the command line." nil nil)
|
|
|
75
|
|
|
76 (autoload 'batch-update-directory "autoload" "\
|
|
|
77 Update the autoloads for the directory on the command line.
|
|
|
78 Runs `update-file-autoloads' on each file in the given directory, must
|
|
|
79 be used only with -batch and kills XEmacs on completion." nil nil)
|
|
|
80
|
|
|
81 ;;;***
|
|
|
82
|
|
|
83 ;;;### (autoloads nil "buff-menu" "lisp/buff-menu.el")
|
|
|
84
|
|
|
85 (defvar list-buffers-directory nil)
|
|
|
86
|
|
|
87 (make-variable-buffer-local 'list-buffers-directory)
|
|
|
88
|
|
|
89 ;;;***
|
|
209
|
90
|
|
|
91 ;;;### (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")
|
|
|
92
|
|
|
93 (autoload 'byte-force-recompile "bytecomp" "\
|
|
|
94 Recompile every `.el' file in DIRECTORY that already has a `.elc' file.
|
|
|
95 Files in subdirectories of DIRECTORY are processed also." t nil)
|
|
|
96
|
|
|
97 (autoload 'byte-recompile-directory "bytecomp" "\
|
|
|
98 Recompile every `.el' file in DIRECTORY that needs recompilation.
|
|
|
99 This is if a `.elc' file exists but is older than the `.el' file.
|
|
|
100 Files in subdirectories of DIRECTORY are processed also unless argument
|
|
|
101 NORECURSION is non-nil.
|
|
|
102
|
|
|
103 If the `.elc' file does not exist, normally the `.el' file is *not* compiled.
|
|
|
104 But a prefix argument (optional second arg) means ask user,
|
|
|
105 for each such `.el' file, whether to compile it. Prefix argument 0 means
|
|
|
106 don't ask and compile the file anyway.
|
|
|
107
|
|
|
108 A nonzero prefix argument also means ask about each subdirectory.
|
|
|
109
|
|
|
110 If the fourth argument FORCE is non-nil,
|
|
|
111 recompile every `.el' file that already has a `.elc' file." t nil)
|
|
|
112
|
|
|
113 (autoload 'byte-recompile-file "bytecomp" "\
|
|
|
114 Recompile a file of Lisp code named FILENAME if it needs recompilation.
|
|
|
115 This is if the `.elc' file exists but is older than the `.el' file.
|
|
|
116
|
|
|
117 If the `.elc' file does not exist, normally the `.el' file is *not*
|
|
|
118 compiled. But a prefix argument (optional second arg) means ask user
|
|
|
119 whether to compile it. Prefix argument 0 don't ask and recompile anyway." t nil)
|
|
|
120
|
|
|
121 (autoload 'byte-compile-file "bytecomp" "\
|
|
|
122 Compile a file of Lisp code named FILENAME into a file of byte code.
|
|
|
123 The output file's name is made by appending `c' to the end of FILENAME.
|
|
|
124 With prefix arg (noninteractively: 2nd arg), load the file after compiling." t nil)
|
|
|
125
|
|
|
126 (autoload 'compile-defun "bytecomp" "\
|
|
|
127 Compile and evaluate the current top-level form.
|
|
|
128 Print the result in the minibuffer.
|
|
|
129 With argument, insert value in current buffer after the form." t nil)
|
|
|
130
|
|
|
131 (autoload 'byte-compile "bytecomp" "\
|
|
|
132 If FORM is a symbol, byte-compile its function definition.
|
|
|
133 If FORM is a lambda or a macro, byte-compile it as a function." nil nil)
|
|
|
134
|
|
|
135 (autoload 'byte-compile-sexp "bytecomp" "\
|
|
|
136 Compile and return SEXP." nil nil)
|
|
|
137
|
|
|
138 (autoload 'display-call-tree "bytecomp" "\
|
|
|
139 Display a call graph of a specified file.
|
|
|
140 This lists which functions have been called, what functions called
|
|
|
141 them, and what functions they call. The list includes all functions
|
|
|
142 whose definitions have been compiled in this Emacs session, as well as
|
|
|
143 all functions called by those functions.
|
|
|
144
|
|
|
145 The call graph does not include macros, inline functions, or
|
|
|
146 primitives that the byte-code interpreter knows about directly (eq,
|
|
|
147 cons, etc.).
|
|
|
148
|
|
|
149 The call tree also lists those functions which are not known to be called
|
|
|
150 \(that is, to which no calls have been compiled), and which cannot be
|
|
|
151 invoked interactively." t nil)
|
|
|
152
|
|
|
153 (autoload 'batch-byte-compile "bytecomp" "\
|
|
|
154 Run `byte-compile-file' on the files remaining on the command line.
|
|
|
155 Use this from the command line, with `-batch';
|
|
|
156 it won't work in an interactive Emacs.
|
|
|
157 Each file is processed even if an error occurred previously.
|
|
|
158 For example, invoke \"emacs -batch -f batch-byte-compile $emacs/ ~/*.el\"" nil nil)
|
|
|
159
|
|
|
160 (autoload 'batch-byte-recompile-directory-norecurse "bytecomp" "\
|
|
|
161 Same as `batch-byte-recompile-directory' but without recursion." nil nil)
|
|
|
162
|
|
|
163 (autoload 'batch-byte-recompile-directory "bytecomp" "\
|
|
|
164 Runs `byte-recompile-directory' on the dirs remaining on the command line.
|
|
|
165 Must be used only with `-batch', and kills Emacs on completion.
|
|
|
166 For example, invoke `xemacs -batch -f batch-byte-recompile-directory .'." nil nil)
|
|
|
167
|
|
|
168 ;;;***
|
|
|
169
|
|
|
170 ;;;### (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")
|
|
|
171
|
|
|
172 (autoload 'cl-compile-time-init "cl-macs" nil nil nil)
|
|
|
173
|
|
|
174 (autoload 'gensym "cl-macs" "\
|
|
|
175 Generate a new uninterned symbol.
|
|
|
176 The name is made by appending a number to PREFIX, default \"G\"." nil nil)
|
|
|
177
|
|
|
178 (autoload 'gentemp "cl-macs" "\
|
|
|
179 Generate a new interned symbol with a unique name.
|
|
|
180 The name is made by appending a number to PREFIX, default \"G\"." nil nil)
|
|
|
181
|
|
|
182 (autoload 'defun* "cl-macs" "\
|
|
|
183 (defun* NAME ARGLIST [DOCSTRING] BODY...): define NAME as a function.
|
|
|
184 Like normal `defun', except ARGLIST allows full Common Lisp conventions,
|
|
|
185 and BODY is implicitly surrounded by (block NAME ...)." nil 'macro)
|
|
|
186
|
|
|
187 (autoload 'defmacro* "cl-macs" "\
|
|
|
188 (defmacro* NAME ARGLIST [DOCSTRING] BODY...): define NAME as a macro.
|
|
|
189 Like normal `defmacro', except ARGLIST allows full Common Lisp conventions,
|
|
|
190 and BODY is implicitly surrounded by (block NAME ...)." nil 'macro)
|
|
|
191
|
|
|
192 (autoload 'function* "cl-macs" "\
|
|
|
193 (function* SYMBOL-OR-LAMBDA): introduce a function.
|
|
|
194 Like normal `function', except that if argument is a lambda form, its
|
|
|
195 ARGLIST allows full Common Lisp conventions." nil 'macro)
|
|
|
196
|
|
|
197 (autoload 'destructuring-bind "cl-macs" nil nil 'macro)
|
|
|
198
|
|
|
199 (autoload 'eval-when "cl-macs" "\
|
|
|
200 (eval-when (WHEN...) BODY...): control when BODY is evaluated.
|
|
|
201 If `compile' is in WHEN, BODY is evaluated when compiled at top-level.
|
|
|
202 If `load' is in WHEN, BODY is evaluated when loaded after top-level compile.
|
|
|
203 If `eval' is in WHEN, BODY is evaluated when interpreted or at non-top-level." nil 'macro)
|
|
|
204
|
|
|
205 (autoload 'load-time-value "cl-macs" "\
|
|
|
206 Like `progn', but evaluates the body at load time.
|
|
|
207 The result of the body appears to the compiler as a quoted constant." nil 'macro)
|
|
|
208
|
|
|
209 (autoload 'case "cl-macs" "\
|
|
|
210 (case EXPR CLAUSES...): evals EXPR, chooses from CLAUSES on that value.
|
|
|
211 Each clause looks like (KEYLIST BODY...). EXPR is evaluated and compared
|
|
|
212 against each key in each KEYLIST; the corresponding BODY is evaluated.
|
|
|
213 If no clause succeeds, case returns nil. A single atom may be used in
|
|
|
214 place of a KEYLIST of one atom. A KEYLIST of `t' or `otherwise' is
|
|
|
215 allowed only in the final clause, and matches if no other keys match.
|
|
|
216 Key values are compared by `eql'." nil 'macro)
|
|
|
217
|
|
|
218 (autoload 'ecase "cl-macs" "\
|
|
|
219 (ecase EXPR CLAUSES...): like `case', but error if no case fits.
|
|
|
220 `otherwise'-clauses are not allowed." nil 'macro)
|
|
|
221
|
|
|
222 (autoload 'typecase "cl-macs" "\
|
|
|
223 (typecase EXPR CLAUSES...): evals EXPR, chooses from CLAUSES on that value.
|
|
|
224 Each clause looks like (TYPE BODY...). EXPR is evaluated and, if it
|
|
|
225 satisfies TYPE, the corresponding BODY is evaluated. If no clause succeeds,
|
|
|
226 typecase returns nil. A TYPE of `t' or `otherwise' is allowed only in the
|
|
|
227 final clause, and matches if no other keys match." nil 'macro)
|
|
|
228
|
|
|
229 (autoload 'etypecase "cl-macs" "\
|
|
|
230 (etypecase EXPR CLAUSES...): like `typecase', but error if no case fits.
|
|
|
231 `otherwise'-clauses are not allowed." nil 'macro)
|
|
|
232
|
|
|
233 (autoload 'block "cl-macs" "\
|
|
|
234 (block NAME BODY...): define a lexically-scoped block named NAME.
|
|
|
235 NAME may be any symbol. Code inside the BODY forms can call `return-from'
|
|
|
236 to jump prematurely out of the block. This differs from `catch' and `throw'
|
|
|
237 in two respects: First, the NAME is an unevaluated symbol rather than a
|
|
|
238 quoted symbol or other form; and second, NAME is lexically rather than
|
|
|
239 dynamically scoped: Only references to it within BODY will work. These
|
|
|
240 references may appear inside macro expansions, but not inside functions
|
|
|
241 called from BODY." nil 'macro)
|
|
|
242
|
|
|
243 (autoload 'return "cl-macs" "\
|
|
|
244 (return [RESULT]): return from the block named nil.
|
|
|
245 This is equivalent to `(return-from nil RESULT)'." nil 'macro)
|
|
|
246
|
|
|
247 (autoload 'return-from "cl-macs" "\
|
|
|
248 (return-from NAME [RESULT]): return from the block named NAME.
|
|
|
249 This jump out to the innermost enclosing `(block NAME ...)' form,
|
|
|
250 returning RESULT from that form (or nil if RESULT is omitted).
|
|
|
251 This is compatible with Common Lisp, but note that `defun' and
|
|
|
252 `defmacro' do not create implicit blocks as they do in Common Lisp." nil 'macro)
|
|
|
253
|
|
|
254 (autoload 'loop "cl-macs" "\
|
|
|
255 (loop CLAUSE...): The Common Lisp `loop' macro.
|
|
|
256 Valid clauses are:
|
|
|
257 for VAR from/upfrom/downfrom NUM to/upto/downto/above/below NUM by NUM,
|
|
|
258 for VAR in LIST by FUNC, for VAR on LIST by FUNC, for VAR = INIT then EXPR,
|
|
|
259 for VAR across ARRAY, repeat NUM, with VAR = INIT, while COND, until COND,
|
|
|
260 always COND, never COND, thereis COND, collect EXPR into VAR,
|
|
|
261 append EXPR into VAR, nconc EXPR into VAR, sum EXPR into VAR,
|
|
|
262 count EXPR into VAR, maximize EXPR into VAR, minimize EXPR into VAR,
|
|
|
263 if COND CLAUSE [and CLAUSE]... else CLAUSE [and CLAUSE...],
|
|
|
264 unless COND CLAUSE [and CLAUSE]... else CLAUSE [and CLAUSE...],
|
|
|
265 do EXPRS..., initially EXPRS..., finally EXPRS..., return EXPR,
|
|
|
266 finally return EXPR, named NAME." nil 'macro)
|
|
|
267
|
|
|
268 (autoload 'do "cl-macs" "\
|
|
|
269 The Common Lisp `do' loop.
|
|
|
270 Format is: (do ((VAR INIT [STEP])...) (END-TEST [RESULT...]) BODY...)" nil 'macro)
|
|
|
271
|
|
|
272 (autoload 'do* "cl-macs" "\
|
|
|
273 The Common Lisp `do*' loop.
|
|
|
274 Format is: (do* ((VAR INIT [STEP])...) (END-TEST [RESULT...]) BODY...)" nil 'macro)
|
|
|
275
|
|
|
276 (autoload 'dolist "cl-macs" "\
|
|
|
277 (dolist (VAR LIST [RESULT]) BODY...): loop over a list.
|
|
|
278 Evaluate BODY with VAR bound to each `car' from LIST, in turn.
|
|
|
279 Then evaluate RESULT to get return value, default nil." nil 'macro)
|
|
|
280
|
|
|
281 (autoload 'dotimes "cl-macs" "\
|
|
|
282 (dotimes (VAR COUNT [RESULT]) BODY...): loop a certain number of times.
|
|
|
283 Evaluate BODY with VAR bound to successive integers from 0, inclusive,
|
|
|
284 to COUNT, exclusive. Then evaluate RESULT to get return value, default
|
|
|
285 nil." nil 'macro)
|
|
|
286
|
|
|
287 (autoload 'do-symbols "cl-macs" "\
|
|
|
288 (dosymbols (VAR [OBARRAY [RESULT]]) BODY...): loop over all symbols.
|
|
|
289 Evaluate BODY with VAR bound to each interned symbol, or to each symbol
|
|
|
290 from OBARRAY." nil 'macro)
|
|
|
291
|
|
|
292 (autoload 'do-all-symbols "cl-macs" nil nil 'macro)
|
|
|
293
|
|
|
294 (autoload 'psetq "cl-macs" "\
|
|
|
295 (psetq SYM VAL SYM VAL ...): set SYMs to the values VALs in parallel.
|
|
|
296 This is like `setq', except that all VAL forms are evaluated (in order)
|
|
|
297 before assigning any symbols SYM to the corresponding values." nil 'macro)
|
|
|
298
|
|
|
299 (autoload 'progv "cl-macs" "\
|
|
|
300 (progv SYMBOLS VALUES BODY...): bind SYMBOLS to VALUES dynamically in BODY.
|
|
|
301 The forms SYMBOLS and VALUES are evaluated, and must evaluate to lists.
|
|
|
302 Each SYMBOL in the first list is bound to the corresponding VALUE in the
|
|
|
303 second list (or made unbound if VALUES is shorter than SYMBOLS); then the
|
|
|
304 BODY forms are executed and their result is returned. This is much like
|
|
|
305 a `let' form, except that the list of symbols can be computed at run-time." nil 'macro)
|
|
|
306
|
|
|
307 (autoload 'flet "cl-macs" "\
|
|
|
308 (flet ((FUNC ARGLIST BODY...) ...) FORM...): make temporary function defns.
|
|
|
309 This is an analogue of `let' that operates on the function cell of FUNC
|
|
|
310 rather than its value cell. The FORMs are evaluated with the specified
|
|
|
311 function definitions in place, then the definitions are undone (the FUNCs
|
|
|
312 go back to their previous definitions, or lack thereof)." nil 'macro)
|
|
|
313
|
|
|
314 (autoload 'labels "cl-macs" "\
|
|
|
315 (labels ((FUNC ARGLIST BODY...) ...) FORM...): make temporary func bindings.
|
|
|
316 This is like `flet', except the bindings are lexical instead of dynamic.
|
|
|
317 Unlike `flet', this macro is fully complaint with the Common Lisp standard." nil 'macro)
|
|
|
318
|
|
|
319 (autoload 'macrolet "cl-macs" "\
|
|
|
320 (macrolet ((NAME ARGLIST BODY...) ...) FORM...): make temporary macro defns.
|
|
|
321 This is like `flet', but for macros instead of functions." nil 'macro)
|
|
|
322
|
|
|
323 (autoload 'symbol-macrolet "cl-macs" "\
|
|
|
324 (symbol-macrolet ((NAME EXPANSION) ...) FORM...): make symbol macro defns.
|
|
|
325 Within the body FORMs, references to the variable NAME will be replaced
|
|
|
326 by EXPANSION, and (setq NAME ...) will act like (setf EXPANSION ...)." nil 'macro)
|
|
|
327
|
|
|
328 (autoload 'lexical-let "cl-macs" "\
|
|
|
329 (lexical-let BINDINGS BODY...): like `let', but lexically scoped.
|
|
|
330 The main visible difference is that lambdas inside BODY will create
|
|
|
331 lexical closures as in Common Lisp." nil 'macro)
|
|
|
332
|
|
|
333 (autoload 'lexical-let* "cl-macs" "\
|
|
|
334 (lexical-let* BINDINGS BODY...): like `let*', but lexically scoped.
|
|
|
335 The main visible difference is that lambdas inside BODY will create
|
|
|
336 lexical closures as in Common Lisp." nil 'macro)
|
|
|
337
|
|
|
338 (autoload 'multiple-value-bind "cl-macs" "\
|
|
|
339 (multiple-value-bind (SYM SYM...) FORM BODY): collect multiple return values.
|
|
|
340 FORM must return a list; the BODY is then executed with the first N elements
|
|
|
341 of this list bound (`let'-style) to each of the symbols SYM in turn. This
|
|
|
342 is analogous to the Common Lisp `multiple-value-bind' macro, using lists to
|
|
|
343 simulate true multiple return values. For compatibility, (values A B C) is
|
|
|
344 a synonym for (list A B C)." nil 'macro)
|
|
|
345
|
|
|
346 (autoload 'multiple-value-setq "cl-macs" "\
|
|
|
347 (multiple-value-setq (SYM SYM...) FORM): collect multiple return values.
|
|
|
348 FORM must return a list; the first N elements of this list are stored in
|
|
|
349 each of the symbols SYM in turn. This is analogous to the Common Lisp
|
|
|
350 `multiple-value-setq' macro, using lists to simulate true multiple return
|
|
|
351 values. For compatibility, (values A B C) is a synonym for (list A B C)." nil 'macro)
|
|
|
352
|
|
|
353 (autoload 'locally "cl-macs" nil nil 'macro)
|
|
|
354
|
|
|
355 (autoload 'the "cl-macs" nil nil 'macro)
|
|
|
356
|
|
|
357 (autoload 'declare "cl-macs" nil nil 'macro)
|
|
|
358
|
|
|
359 (autoload 'define-setf-method "cl-macs" "\
|
|
|
360 (define-setf-method NAME ARGLIST BODY...): define a `setf' method.
|
|
|
361 This method shows how to handle `setf's to places of the form (NAME ARGS...).
|
|
|
362 The argument forms ARGS are bound according to ARGLIST, as if NAME were
|
|
|
363 going to be expanded as a macro, then the BODY forms are executed and must
|
|
|
364 return a list of five elements: a temporary-variables list, a value-forms
|
|
|
365 list, a store-variables list (of length one), a store-form, and an access-
|
|
|
366 form. See `defsetf' for a simpler way to define most setf-methods." nil 'macro)
|
|
|
367
|
|
|
368 (autoload 'defsetf "cl-macs" "\
|
|
|
369 (defsetf NAME FUNC): define a `setf' method.
|
|
|
370 This macro is an easy-to-use substitute for `define-setf-method' that works
|
|
|
371 well for simple place forms. In the simple `defsetf' form, `setf's of
|
|
|
372 the form (setf (NAME ARGS...) VAL) are transformed to function or macro
|
|
|
373 calls of the form (FUNC ARGS... VAL). Example: (defsetf aref aset).
|
|
|
374 Alternate form: (defsetf NAME ARGLIST (STORE) BODY...).
|
|
|
375 Here, the above `setf' call is expanded by binding the argument forms ARGS
|
|
|
376 according to ARGLIST, binding the value form VAL to STORE, then executing
|
|
|
377 BODY, which must return a Lisp form that does the necessary `setf' operation.
|
|
|
378 Actually, ARGLIST and STORE may be bound to temporary variables which are
|
|
|
379 introduced automatically to preserve proper execution order of the arguments.
|
|
|
380 Example: (defsetf nth (n x) (v) (list 'setcar (list 'nthcdr n x) v))." nil 'macro)
|
|
|
381
|
|
|
382 (autoload 'get-setf-method "cl-macs" "\
|
|
|
383 Return a list of five values describing the setf-method for PLACE.
|
|
|
384 PLACE may be any Lisp form which can appear as the PLACE argument to
|
|
|
385 a macro like `setf' or `incf'." nil nil)
|
|
|
386
|
|
|
387 (autoload 'setf "cl-macs" "\
|
|
|
388 (setf PLACE VAL PLACE VAL ...): set each PLACE to the value of its VAL.
|
|
|
389 This is a generalized version of `setq'; the PLACEs may be symbolic
|
|
|
390 references such as (car x) or (aref x i), as well as plain symbols.
|
|
|
391 For example, (setf (cadar x) y) is equivalent to (setcar (cdar x) y).
|
|
|
392 The return value is the last VAL in the list." nil 'macro)
|
|
|
393
|
|
|
394 (autoload 'psetf "cl-macs" "\
|
|
|
395 (psetf PLACE VAL PLACE VAL ...): set PLACEs to the values VALs in parallel.
|
|
|
396 This is like `setf', except that all VAL forms are evaluated (in order)
|
|
|
397 before assigning any PLACEs to the corresponding values." nil 'macro)
|
|
|
398
|
|
|
399 (autoload 'cl-do-pop "cl-macs" nil nil nil)
|
|
|
400
|
|
|
401 (autoload 'remf "cl-macs" "\
|
|
|
402 (remf PLACE TAG): remove TAG from property list PLACE.
|
|
|
403 PLACE may be a symbol, or any generalized variable allowed by `setf'.
|
|
|
404 The form returns true if TAG was found and removed, nil otherwise." nil 'macro)
|
|
|
405
|
|
|
406 (autoload 'shiftf "cl-macs" "\
|
|
|
407 (shiftf PLACE PLACE... VAL): shift left among PLACEs.
|
|
|
408 Example: (shiftf A B C) sets A to B, B to C, and returns the old A.
|
|
|
409 Each PLACE may be a symbol, or any generalized variable allowed by `setf'." nil 'macro)
|
|
|
410
|
|
|
411 (autoload 'rotatef "cl-macs" "\
|
|
|
412 (rotatef PLACE...): rotate left among PLACEs.
|
|
|
413 Example: (rotatef A B C) sets A to B, B to C, and C to A. It returns nil.
|
|
|
414 Each PLACE may be a symbol, or any generalized variable allowed by `setf'." nil 'macro)
|
|
|
415
|
|
|
416 (autoload 'letf "cl-macs" "\
|
|
|
417 (letf ((PLACE VALUE) ...) BODY...): temporarily bind to PLACEs.
|
|
|
418 This is the analogue of `let', but with generalized variables (in the
|
|
|
419 sense of `setf') for the PLACEs. Each PLACE is set to the corresponding
|
|
|
420 VALUE, then the BODY forms are executed. On exit, either normally or
|
|
|
421 because of a `throw' or error, the PLACEs are set back to their original
|
|
|
422 values. Note that this macro is *not* available in Common Lisp.
|
|
|
423 As a special case, if `(PLACE)' is used instead of `(PLACE VALUE)',
|
|
|
424 the PLACE is not modified before executing BODY." nil 'macro)
|
|
|
425
|
|
|
426 (autoload 'letf* "cl-macs" "\
|
|
|
427 (letf* ((PLACE VALUE) ...) BODY...): temporarily bind to PLACEs.
|
|
|
428 This is the analogue of `let*', but with generalized variables (in the
|
|
|
429 sense of `setf') for the PLACEs. Each PLACE is set to the corresponding
|
|
|
430 VALUE, then the BODY forms are executed. On exit, either normally or
|
|
|
431 because of a `throw' or error, the PLACEs are set back to their original
|
|
|
432 values. Note that this macro is *not* available in Common Lisp.
|
|
|
433 As a special case, if `(PLACE)' is used instead of `(PLACE VALUE)',
|
|
|
434 the PLACE is not modified before executing BODY." nil 'macro)
|
|
|
435
|
|
|
436 (autoload 'callf "cl-macs" "\
|
|
|
437 (callf FUNC PLACE ARGS...): set PLACE to (FUNC PLACE ARGS...).
|
|
|
438 FUNC should be an unquoted function name. PLACE may be a symbol,
|
|
|
439 or any generalized variable allowed by `setf'." nil 'macro)
|
|
|
440
|
|
|
441 (autoload 'callf2 "cl-macs" "\
|
|
|
442 (callf2 FUNC ARG1 PLACE ARGS...): set PLACE to (FUNC ARG1 PLACE ARGS...).
|
|
|
443 Like `callf', but PLACE is the second argument of FUNC, not the first." nil 'macro)
|
|
|
444
|
|
|
445 (autoload 'define-modify-macro "cl-macs" "\
|
|
|
446 (define-modify-macro NAME ARGLIST FUNC): define a `setf'-like modify macro.
|
|
|
447 If NAME is called, it combines its PLACE argument with the other arguments
|
|
|
448 from ARGLIST using FUNC: (define-modify-macro incf (&optional (n 1)) +)" nil 'macro)
|
|
|
449
|
|
|
450 (autoload 'defstruct "cl-macs" "\
|
|
|
451 (defstruct (NAME OPTIONS...) (SLOT SLOT-OPTS...)...): define a struct type.
|
|
|
452 This macro defines a new Lisp data type called NAME, which contains data
|
|
|
453 stored in SLOTs. This defines a `make-NAME' constructor, a `copy-NAME'
|
|
|
454 copier, a `NAME-p' predicate, and setf-able `NAME-SLOT' accessors." nil 'macro)
|
|
|
455
|
|
|
456 (autoload 'cl-struct-setf-expander "cl-macs" nil nil nil)
|
|
|
457
|
|
|
458 (autoload 'deftype "cl-macs" "\
|
|
|
459 (deftype NAME ARGLIST BODY...): define NAME as a new data type.
|
|
|
460 The type name can then be used in `typecase', `check-type', etc." nil 'macro)
|
|
|
461
|
|
|
462 (autoload 'typep "cl-macs" "\
|
|
|
463 Check that OBJECT is of type TYPE.
|
|
|
464 TYPE is a Common Lisp-style type specifier." nil nil)
|
|
|
465
|
|
|
466 (autoload 'check-type "cl-macs" "\
|
|
|
467 Verify that FORM is of type TYPE; signal an error if not.
|
|
|
468 STRING is an optional description of the desired type." nil 'macro)
|
|
|
469
|
|
|
470 (autoload 'assert "cl-macs" "\
|
|
|
471 Verify that FORM returns non-nil; signal an error if not.
|
|
|
472 Second arg SHOW-ARGS means to include arguments of FORM in message.
|
|
|
473 Other args STRING and ARGS... are arguments to be passed to `error'.
|
|
|
474 They are not evaluated unless the assertion fails. If STRING is
|
|
|
475 omitted, a default message listing FORM itself is used." nil 'macro)
|
|
|
476
|
|
|
477 (autoload 'ignore-errors "cl-macs" "\
|
|
|
478 Execute FORMS; if an error occurs, return nil.
|
|
|
479 Otherwise, return result of last FORM." nil 'macro)
|
|
|
480
|
|
|
481 (autoload 'define-compiler-macro "cl-macs" "\
|
|
|
482 (define-compiler-macro FUNC ARGLIST BODY...): Define a compiler-only macro.
|
|
|
483 This is like `defmacro', but macro expansion occurs only if the call to
|
|
|
484 FUNC is compiled (i.e., not interpreted). Compiler macros should be used
|
|
|
485 for optimizing the way calls to FUNC are compiled; the form returned by
|
|
|
486 BODY should do the same thing as a call to the normal function called
|
|
|
487 FUNC, though possibly more efficiently. Note that, like regular macros,
|
|
|
488 compiler macros are expanded repeatedly until no further expansions are
|
|
|
489 possible. Unlike regular macros, BODY can decide to \"punt\" and leave the
|
|
|
490 original function call alone by declaring an initial `&whole foo' parameter
|
|
|
491 and then returning foo." nil 'macro)
|
|
|
492
|
|
|
493 (autoload 'compiler-macroexpand "cl-macs" nil nil nil)
|
|
|
494
|
|
|
495 ;;;***
|
|
|
496
|
|
217
|
497 ;;;### (autoloads (batch-remove-old-elc) "cleantree" "lisp/cleantree.el")
|
|
|
498
|
|
|
499 (autoload 'batch-remove-old-elc "cleantree" nil nil nil)
|
|
|
500
|
|
|
501 ;;;***
|
|
|
502
|
|
|
503 ;;;### (autoloads (config-value config-value-hash-table) "config" "lisp/config.el")
|
|
|
504
|
|
|
505 (autoload 'config-value-hash-table "config" "\
|
|
|
506 Returns hashtable of configuration parameters and their values." nil nil)
|
|
|
507
|
|
|
508 (autoload 'config-value "config" "\
|
|
|
509 Return the value of the configuration parameter CONFIG_SYMBOL." nil nil)
|
|
|
510
|
|
|
511 ;;;***
|
|
|
512
|
|
209
|
513 ;;;### (autoloads (Custom-make-dependencies) "cus-dep" "lisp/cus-dep.el")
|
|
|
514
|
|
|
515 (autoload 'Custom-make-dependencies "cus-dep" "\
|
|
|
516 Extract custom dependencies from .el files in SUBDIRS.
|
|
|
517 SUBDIRS is a list of directories. If it is nil, the command-line
|
|
|
518 arguments are used. If it is a string, only that directory is
|
|
|
519 processed. This function is especially useful in batch mode.
|
|
|
520
|
|
|
521 Batch usage: xemacs -batch -l cus-dep.el -f Custom-make-dependencies DIRS" t nil)
|
|
|
522
|
|
|
523 ;;;***
|
|
|
524
|
|
|
525 ;;;### (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")
|
|
|
526
|
|
|
527 (autoload 'customize-set-value "cus-edit" "\
|
|
|
528 Set VARIABLE to VALUE. VALUE is a Lisp object.
|
|
|
529
|
|
|
530 If VARIABLE has a `variable-interactive' property, that is used as if
|
|
|
531 it were the arg to `interactive' (which see) to interactively read the value.
|
|
|
532
|
|
|
533 If VARIABLE has a `custom-type' property, it must be a widget and the
|
|
|
534 `:prompt-value' property of that widget will be used for reading the value." t nil)
|
|
|
535
|
|
|
536 (autoload 'customize-set-variable "cus-edit" "\
|
|
|
537 Set the default for VARIABLE to VALUE. VALUE is a Lisp object.
|
|
|
538
|
|
|
539 If VARIABLE has a `custom-set' property, that is used for setting
|
|
|
540 VARIABLE, otherwise `set-default' is used.
|
|
|
541
|
|
|
542 The `customized-value' property of the VARIABLE will be set to a list
|
|
|
543 with a quoted VALUE as its sole list member.
|
|
|
544
|
|
|
545 If VARIABLE has a `variable-interactive' property, that is used as if
|
|
|
546 it were the arg to `interactive' (which see) to interactively read the value.
|
|
|
547
|
|
|
548 If VARIABLE has a `custom-type' property, it must be a widget and the
|
|
|
549 `:prompt-value' property of that widget will be used for reading the value. " t nil)
|
|
|
550
|
|
|
551 (autoload 'customize-save-variable "cus-edit" "\
|
|
|
552 Set the default for VARIABLE to VALUE, and save it for future sessions.
|
|
|
553 If VARIABLE has a `custom-set' property, that is used for setting
|
|
|
554 VARIABLE, otherwise `set-default' is used.
|
|
|
555
|
|
|
556 The `customized-value' property of the VARIABLE will be set to a list
|
|
|
557 with a quoted VALUE as its sole list member.
|
|
|
558
|
|
|
559 If VARIABLE has a `variable-interactive' property, that is used as if
|
|
|
560 it were the arg to `interactive' (which see) to interactively read the value.
|
|
|
561
|
|
|
562 If VARIABLE has a `custom-type' property, it must be a widget and the
|
|
|
563 `:prompt-value' property of that widget will be used for reading the value. " t nil)
|
|
|
564
|
|
|
565 (autoload 'customize "cus-edit" "\
|
|
|
566 Select a customization buffer which you can use to set user options.
|
|
|
567 User options are structured into \"groups\".
|
|
|
568 The default group is `Emacs'." t nil)
|
|
|
569
|
|
|
570 (defalias 'customize-group 'customize)
|
|
|
571
|
|
|
572 (autoload 'customize-other-window "cus-edit" "\
|
|
|
573 Customize SYMBOL, which must be a customization group." t nil)
|
|
|
574
|
|
|
575 (defalias 'customize-group-other-window 'customize-other-window)
|
|
|
576
|
|
|
577 (defalias 'customize-option 'customize-variable)
|
|
|
578
|
|
|
579 (autoload 'customize-variable "cus-edit" "\
|
|
|
580 Customize SYMBOL, which must be a user option variable." t nil)
|
|
|
581
|
|
|
582 (defalias 'customize-variable-other-window 'customize-option-other-window)
|
|
|
583
|
|
|
584 (autoload 'customize-option-other-window "cus-edit" "\
|
|
|
585 Customize SYMBOL, which must be a user option variable.
|
|
|
586 Show the buffer in another window, but don't select it." t nil)
|
|
|
587
|
|
|
588 (autoload 'customize-face "cus-edit" "\
|
|
|
589 Customize SYMBOL, which should be a face name or nil.
|
|
|
590 If SYMBOL is nil, customize all faces." t nil)
|
|
|
591
|
|
|
592 (autoload 'customize-face-other-window "cus-edit" "\
|
|
|
593 Show customization buffer for FACE in other window." t nil)
|
|
|
594
|
|
|
595 (autoload 'customize-customized "cus-edit" "\
|
|
|
596 Customize all user options set since the last save in this session." t nil)
|
|
|
597
|
|
|
598 (autoload 'customize-saved "cus-edit" "\
|
|
|
599 Customize all already saved user options." t nil)
|
|
|
600
|
|
|
601 (autoload 'customize-apropos "cus-edit" "\
|
|
|
602 Customize all user options matching REGEXP.
|
|
|
603 If ALL is `options', include only options.
|
|
|
604 If ALL is `faces', include only faces.
|
|
|
605 If ALL is `groups', include only groups.
|
|
|
606 If ALL is t (interactively, with prefix arg), include options which are not
|
|
|
607 user-settable, as well as faces and groups." t nil)
|
|
|
608
|
|
|
609 (autoload 'customize-apropos-options "cus-edit" "\
|
|
|
610 Customize all user options matching REGEXP.
|
|
|
611 With prefix arg, include options which are not user-settable." t nil)
|
|
|
612
|
|
|
613 (autoload 'customize-apropos-faces "cus-edit" "\
|
|
|
614 Customize all user faces matching REGEXP." t nil)
|
|
|
615
|
|
|
616 (autoload 'customize-apropos-groups "cus-edit" "\
|
|
|
617 Customize all user groups matching REGEXP." t nil)
|
|
|
618
|
|
|
619 (autoload 'custom-buffer-create "cus-edit" "\
|
|
|
620 Create a buffer containing OPTIONS.
|
|
|
621 Optional NAME is the name of the buffer.
|
|
|
622 OPTIONS should be an alist of the form ((SYMBOL WIDGET)...), where
|
|
|
623 SYMBOL is a customization option, and WIDGET is a widget for editing
|
|
|
624 that option." nil nil)
|
|
|
625
|
|
|
626 (autoload 'custom-buffer-create-other-window "cus-edit" "\
|
|
|
627 Create a buffer containing OPTIONS.
|
|
|
628 Optional NAME is the name of the buffer.
|
|
|
629 OPTIONS should be an alist of the form ((SYMBOL WIDGET)...), where
|
|
|
630 SYMBOL is a customization option, and WIDGET is a widget for editing
|
|
|
631 that option." nil nil)
|
|
|
632
|
|
|
633 (autoload 'customize-browse "cus-edit" "\
|
|
|
634 Create a tree browser for the customize hierarchy." t nil)
|
|
|
635
|
|
217
|
636 (defcustom custom-file (if (boundp 'user-init-directory) (concat "~" init-file-user user-init-directory "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)
|
|
209
|
637
|
|
|
638 (autoload 'customize-save-customized "cus-edit" "\
|
|
|
639 Save all user options which have been set in this session." t nil)
|
|
|
640
|
|
|
641 (autoload 'custom-save-all "cus-edit" "\
|
|
|
642 Save all customizations in `custom-file'." nil nil)
|
|
|
643
|
|
|
644 (autoload 'custom-menu-create "cus-edit" "\
|
|
|
645 Create menu for customization group SYMBOL.
|
|
|
646 The menu is in a format applicable to `easy-menu-define'." nil nil)
|
|
|
647
|
|
|
648 (autoload 'customize-menu-create "cus-edit" "\
|
|
|
649 Return a customize menu for customization group SYMBOL.
|
|
|
650 If optional NAME is given, use that as the name of the menu.
|
|
|
651 Otherwise the menu will be named `Customize'.
|
|
|
652 The format is suitable for use with `easy-menu-define'." nil nil)
|
|
|
653
|
|
|
654 ;;;***
|
|
|
655
|
|
|
656 ;;;### (autoloads (custom-set-faces custom-declare-face) "cus-face" "lisp/cus-face.el")
|
|
|
657
|
|
|
658 (autoload 'custom-declare-face "cus-face" "\
|
|
|
659 Like `defface', but FACE is evaluated as a normal argument." nil nil)
|
|
|
660
|
|
|
661 (autoload 'custom-set-faces "cus-face" "\
|
|
|
662 Initialize faces according to user preferences.
|
|
|
663 The arguments should be a list where each entry has the form:
|
|
|
664
|
|
|
665 (FACE SPEC [NOW])
|
|
|
666
|
|
|
667 SPEC will be stored as the saved value for FACE. If NOW is present
|
|
|
668 and non-nil, FACE will also be created according to SPEC.
|
|
|
669
|
|
|
670 See `defface' for the format of SPEC." nil nil)
|
|
|
671
|
|
|
672 ;;;***
|
|
|
673
|
|
|
674 ;;;### (autoloads (disassemble) "disass" "lisp/disass.el")
|
|
|
675
|
|
|
676 (autoload 'disassemble "disass" "\
|
|
|
677 Print disassembled code for OBJECT in (optional) BUFFER.
|
|
|
678 OBJECT can be a symbol defined as a function, or a function itself
|
|
|
679 \(a lambda expression or a compiled-function object).
|
|
|
680 If OBJECT is not already compiled, we compile it, but do not
|
|
|
681 redefine OBJECT if it is a symbol." t nil)
|
|
|
682
|
|
|
683 ;;;***
|
|
|
684
|
|
217
|
685 ;;;### (autoloads nil "easymenu" "lisp/easymenu.el")
|
|
|
686
|
|
|
687 ;;;***
|
|
|
688
|
|
|
689 ;;;### (autoloads (tags-apropos list-tags tags-query-replace tags-search tags-loop-continue next-file find-tag-other-window find-tag visit-tags-table) "etags" "lisp/etags.el")
|
|
|
690
|
|
|
691 (defcustom tags-build-completion-table 'ask "*If this variable is nil, then tags completion is disabled.\nIf this variable is t, then things which prompt for tags will do so with \n completion across all known tags.\nIf this variable is the symbol `ask', then you will be asked whether each\n tags table should be added to the completion list as it is read in.\n (With the exception that for very small tags tables, you will not be asked,\n since they can be parsed quickly.)" :type '(radio (const :tag "Disabled" nil) (const :tag "Complete All" t) (const :tag "Ask" ask)) :group 'etags)
|
|
|
692
|
|
|
693 (defcustom tags-always-exact nil "*If this variable is non-nil, then tags always looks for exact matches." :type 'boolean :group 'etags)
|
|
|
694
|
|
|
695 (defcustom tag-table-alist nil "*A list which determines which tags files are active for a buffer.\nThis is not really an association list, in that all elements are\nchecked. The CAR of each element of this list is a pattern against\nwhich the buffer's file name is compared; if it matches, then the CDR\nof the list should be the name of the tags table to use. If more than\none element of this list matches the buffer's file name, then all of\nthe associated tags tables will be used. Earlier ones will be\nsearched first.\n\nIf the CAR of elements of this list are strings, then they are treated\nas regular-expressions against which the file is compared (like the\nauto-mode-alist). If they are not strings, then they are evaluated.\nIf they evaluate to non-nil, then the current buffer is considered to\nmatch.\n\nIf the CDR of the elements of this list are strings, then they are\nassumed to name a TAGS file. If they name a directory, then the string\n\"TAGS\" is appended to them to get the file name. If they are not \nstrings, then they are evaluated, and must return an appropriate string.\n\nFor example:\n (setq tag-table-alist\n '((\"/usr/src/public/perl/\" . \"/usr/src/public/perl/perl-3.0/\")\n (\"\\\\.el$\" . \"/usr/local/emacs/src/\")\n (\"/jbw/gnu/\" . \"/usr15/degree/stud/jbw/gnu/\")\n (\"\" . \"/usr/local/emacs/src/\")\n ))\n\nThis means that anything in the /usr/src/public/perl/ directory should use\nthe TAGS file /usr/src/public/perl/perl-3.0/TAGS; and file ending in .el should\nuse the TAGS file /usr/local/emacs/src/TAGS; and anything in or below the\ndirectory /jbw/gnu/ should use the TAGS file /usr15/degree/stud/jbw/gnu/TAGS.\nA file called something like \"/usr/jbw/foo.el\" would use both the TAGS files\n/usr/local/emacs/src/TAGS and /usr15/degree/stud/jbw/gnu/TAGS (in that order)\nbecause it matches both patterns.\n\nIf the buffer-local variable `buffer-tag-table' is set, then it names a tags\ntable that is searched before all others when find-tag is executed from this\nbuffer.\n\nIf there is a file called \"TAGS\" in the same directory as the file in \nquestion, then that tags file will always be used as well (after the\n`buffer-tag-table' but before the tables specified by this list.)\n\nIf the variable tags-file-name is set, then the tags file it names will apply\nto all buffers (for backwards compatibility.) It is searched first.\n" :type '(repeat (cons (choice :value "" (regexp :tag "Buffer regexp") (function :tag "Expression")) (string :tag "Tag file or directory"))) :group 'etags)
|
|
|
696
|
|
|
697 (autoload 'visit-tags-table "etags" "\
|
|
|
698 Tell tags commands to use tags table file FILE first.
|
|
|
699 FILE should be the name of a file created with the `etags' program.
|
|
|
700 A directory name is ok too; it means file TAGS in that directory." t nil)
|
|
|
701
|
|
|
702 (autoload 'find-tag "etags" "\
|
|
|
703 *Find tag whose name contains TAGNAME.
|
|
|
704 Selects the buffer that the tag is contained in
|
|
|
705 and puts point at its definition.
|
|
|
706 If TAGNAME is a null string, the expression in the buffer
|
|
|
707 around or before point is used as the tag name.
|
|
|
708 If called interactively with a numeric argument, searches for the next tag
|
|
|
709 in the tag table that matches the tagname used in the previous find-tag.
|
|
|
710 If second arg OTHER-WINDOW is non-nil, uses another window to display
|
|
|
711 the tag.
|
|
|
712
|
|
|
713 This version of this function supports multiple active tags tables,
|
|
|
714 and completion.
|
|
|
715
|
|
|
716 Variables of note:
|
|
|
717
|
|
|
718 tag-table-alist controls which tables apply to which buffers
|
|
|
719 tags-file-name a default tags table
|
|
|
720 tags-build-completion-table controls completion behavior
|
|
|
721 buffer-tag-table another way of specifying a buffer-local table
|
|
|
722 make-tags-files-invisible whether tags tables should be very hidden
|
|
|
723 tag-mark-stack-max how many tags-based hops to remember" t nil)
|
|
|
724
|
|
|
725 (autoload 'find-tag-other-window "etags" "\
|
|
|
726 *Find tag whose name contains TAGNAME.
|
|
|
727 Selects the buffer that the tag is contained in in another window
|
|
|
728 and puts point at its definition.
|
|
|
729 If TAGNAME is a null string, the expression in the buffer
|
|
|
730 around or before point is used as the tag name.
|
|
|
731 If second arg NEXT is non-nil (interactively, with prefix arg),
|
|
|
732 searches for the next tag in the tag table
|
|
|
733 that matches the tagname used in the previous find-tag.
|
|
|
734
|
|
|
735 This version of this function supports multiple active tags tables,
|
|
|
736 and completion.
|
|
|
737
|
|
|
738 Variables of note:
|
|
|
739
|
|
|
740 tag-table-alist controls which tables apply to which buffers
|
|
|
741 tags-file-name a default tags table
|
|
|
742 tags-build-completion-table controls completion behavior
|
|
|
743 buffer-tag-table another way of specifying a buffer-local table
|
|
|
744 make-tags-files-invisible whether tags tables should be very hidden
|
|
|
745 tag-mark-stack-max how many tags-based hops to remember" t nil)
|
|
|
746
|
|
|
747 (autoload 'next-file "etags" "\
|
|
|
748 Select next file among files in current tag table(s).
|
|
|
749
|
|
|
750 A first argument of t (prefix arg, if interactive) initializes to the
|
|
|
751 beginning of the list of files in the (first) tags table. If the argument
|
|
|
752 is neither nil nor t, it is evalled to initialize the list of files.
|
|
|
753
|
|
|
754 Non-nil second argument NOVISIT means use a temporary buffer
|
|
|
755 to save time and avoid uninteresting warnings.
|
|
|
756
|
|
|
757 Value is nil if the file was already visited;
|
|
|
758 if the file was newly read in, the value is the filename." t nil)
|
|
|
759
|
|
|
760 (autoload 'tags-loop-continue "etags" "\
|
|
|
761 Continue last \\[tags-search] or \\[tags-query-replace] command.
|
|
|
762 Used noninteractively with non-nil argument to begin such a command (the
|
|
|
763 argument is passed to `next-file', which see).
|
|
|
764 Two variables control the processing we do on each file:
|
|
|
765 the value of `tags-loop-scan' is a form to be executed on each file
|
|
|
766 to see if it is interesting (it returns non-nil if so)
|
|
|
767 and `tags-loop-operate' is a form to execute to operate on an interesting file
|
|
|
768 If the latter returns non-nil, we exit; otherwise we scan the next file." t nil)
|
|
|
769
|
|
|
770 (autoload 'tags-search "etags" "\
|
|
|
771 Search through all files listed in tags table for match for REGEXP.
|
|
|
772 Stops when a match is found.
|
|
|
773 To continue searching for next match, use command \\[tags-loop-continue].
|
|
|
774
|
|
|
775 See documentation of variable `tag-table-alist'." t nil)
|
|
|
776
|
|
|
777 (autoload 'tags-query-replace "etags" "\
|
|
|
778 Query-replace-regexp FROM with TO through all files listed in tags table.
|
|
|
779 Third arg DELIMITED (prefix arg) means replace only word-delimited matches.
|
|
|
780 If you exit (\\[keyboard-quit] or ESC), you can resume the query-replace
|
|
|
781 with the command \\[tags-loop-continue].
|
|
|
782
|
|
|
783 See documentation of variable `tag-table-alist'." t nil)
|
|
|
784
|
|
|
785 (autoload 'list-tags "etags" "\
|
|
|
786 Display list of tags in file FILE.
|
|
|
787 FILE should not contain a directory spec
|
|
|
788 unless it has one in the tag table." t nil)
|
|
|
789
|
|
|
790 (autoload 'tags-apropos "etags" "\
|
|
|
791 Display list of all tags in tag table REGEXP matches." t nil)
|
|
|
792
|
|
|
793 ;;;***
|
|
|
794
|
|
|
795 ;;;### (autoloads (font-lock-set-defaults-1 font-lock-fontify-buffer turn-off-font-lock turn-on-font-lock font-lock-mode) "font-lock" "lisp/font-lock.el")
|
|
|
796
|
|
|
797 (defvar font-lock-auto-fontify t "\
|
|
|
798 *Whether font-lock should automatically fontify files as they're loaded.
|
|
|
799 This will only happen if font-lock has fontifying keywords for the major
|
|
|
800 mode of the file. You can get finer-grained control over auto-fontification
|
|
|
801 by using this variable in combination with `font-lock-mode-enable-list' or
|
|
|
802 `font-lock-mode-disable-list'.")
|
|
|
803
|
|
|
804 (defvar font-lock-mode-enable-list nil "\
|
|
|
805 *List of modes to auto-fontify, if `font-lock-auto-fontify' is nil.")
|
|
|
806
|
|
|
807 (defvar font-lock-mode-disable-list nil "\
|
|
|
808 *List of modes not to auto-fontify, if `font-lock-auto-fontify' is t.")
|
|
|
809
|
|
|
810 (defvar font-lock-use-colors '(color) "\
|
|
|
811 *Specification for when Font Lock will set up color defaults.
|
|
|
812 Normally this should be '(color), meaning that Font Lock will set up
|
|
|
813 color defaults that are only used on color displays. Set this to nil
|
|
|
814 if you don't want Font Lock to set up color defaults at all. This
|
|
|
815 should be one of
|
|
|
816
|
|
|
817 -- a list of valid tags, meaning that the color defaults will be used
|
|
|
818 when all of the tags apply. (e.g. '(color x))
|
|
|
819 -- a list whose first element is 'or and whose remaining elements are
|
|
|
820 lists of valid tags, meaning that the defaults will be used when
|
|
|
821 any of the tag lists apply.
|
|
|
822 -- nil, meaning that the defaults should not be set up at all.
|
|
|
823
|
|
|
824 \(If you specify face values in your init file, they will override any
|
|
|
825 that Font Lock specifies, regardless of whether you specify the face
|
|
|
826 values before or after loading Font Lock.)
|
|
|
827
|
|
|
828 See also `font-lock-use-fonts'. If you want more control over the faces
|
|
|
829 used for fontification, see the documentation of `font-lock-mode' for
|
|
|
830 how to do it.")
|
|
|
831
|
|
|
832 (defvar font-lock-use-fonts '(or (mono) (grayscale)) "\
|
|
|
833 *Specification for when Font Lock will set up non-color defaults.
|
|
|
834
|
|
|
835 Normally this should be '(or (mono) (grayscale)), meaning that Font
|
|
|
836 Lock will set up non-color defaults that are only used on either mono
|
|
|
837 or grayscale displays. Set this to nil if you don't want Font Lock to
|
|
|
838 set up non-color defaults at all. This should be one of
|
|
|
839
|
|
|
840 -- a list of valid tags, meaning that the non-color defaults will be used
|
|
|
841 when all of the tags apply. (e.g. '(grayscale x))
|
|
|
842 -- a list whose first element is 'or and whose remaining elements are
|
|
|
843 lists of valid tags, meaning that the defaults will be used when
|
|
|
844 any of the tag lists apply.
|
|
|
845 -- nil, meaning that the defaults should not be set up at all.
|
|
|
846
|
|
|
847 \(If you specify face values in your init file, they will override any
|
|
|
848 that Font Lock specifies, regardless of whether you specify the face
|
|
|
849 values before or after loading Font Lock.)
|
|
|
850
|
|
|
851 See also `font-lock-use-colors'. If you want more control over the faces
|
|
|
852 used for fontification, see the documentation of `font-lock-mode' for
|
|
|
853 how to do it.")
|
|
|
854
|
|
|
855 (defvar font-lock-maximum-decoration nil "\
|
|
|
856 *If non-nil, the maximum decoration level for fontifying.
|
|
|
857 If nil, use the minimum decoration (equivalent to level 0).
|
|
|
858 If t, use the maximum decoration available.
|
|
|
859 If a number, use that level of decoration (or if not available the maximum).
|
|
|
860 If a list, each element should be a cons pair of the form (MAJOR-MODE . LEVEL),
|
|
|
861 where MAJOR-MODE is a symbol or t (meaning the default). For example:
|
|
|
862 ((c++-mode . 2) (c-mode . t) (t . 1))
|
|
|
863 means use level 2 decoration for buffers in `c++-mode', the maximum decoration
|
|
|
864 available for buffers in `c-mode', and level 1 decoration otherwise.")
|
|
|
865
|
|
|
866 (define-obsolete-variable-alias 'font-lock-use-maximal-decoration 'font-lock-maximum-decoration)
|
|
|
867
|
|
|
868 (defvar font-lock-maximum-size (* 250 1024) "\
|
|
|
869 *If non-nil, the maximum size for buffers for fontifying.
|
|
|
870 Only buffers less than this can be fontified when Font Lock mode is turned on.
|
|
|
871 If nil, means size is irrelevant.
|
|
|
872 If a list, each element should be a cons pair of the form (MAJOR-MODE . SIZE),
|
|
|
873 where MAJOR-MODE is a symbol or t (meaning the default). For example:
|
|
|
874 ((c++-mode . 256000) (c-mode . 256000) (rmail-mode . 1048576))
|
|
|
875 means that the maximum size is 250K for buffers in `c++-mode' or `c-mode', one
|
|
|
876 megabyte for buffers in `rmail-mode', and size is irrelevant otherwise.")
|
|
|
877
|
|
|
878 (defvar font-lock-keywords nil "\
|
|
|
879 *A list of the keywords to highlight.
|
|
|
880 Each element should be of the form:
|
|
|
881
|
|
|
882 MATCHER
|
|
|
883 (MATCHER . MATCH)
|
|
|
884 (MATCHER . FACENAME)
|
|
|
885 (MATCHER . HIGHLIGHT)
|
|
|
886 (MATCHER HIGHLIGHT ...)
|
|
|
887 (eval . FORM)
|
|
|
888
|
|
|
889 where HIGHLIGHT should be either MATCH-HIGHLIGHT or MATCH-ANCHORED.
|
|
|
890
|
|
|
891 FORM is an expression, whose value should be a keyword element,
|
|
|
892 evaluated when the keyword is (first) used in a buffer. This feature
|
|
|
893 can be used to provide a keyword that can only be generated when Font
|
|
|
894 Lock mode is actually turned on.
|
|
|
895
|
|
|
896 For highlighting single items, typically only MATCH-HIGHLIGHT is required.
|
|
|
897 However, if an item or (typically) items is to be highlighted following the
|
|
|
898 instance of another item (the anchor) then MATCH-ANCHORED may be required.
|
|
|
899
|
|
|
900 MATCH-HIGHLIGHT should be of the form:
|
|
|
901
|
|
|
902 (MATCH FACENAME OVERRIDE LAXMATCH)
|
|
|
903
|
|
|
904 Where MATCHER can be either the regexp to search for, a variable
|
|
|
905 containing the regexp to search for, or the function to call to make
|
|
|
906 the search (called with one argument, the limit of the search). MATCH
|
|
|
907 is the subexpression of MATCHER to be highlighted. FACENAME is either
|
|
|
908 a symbol naming a face, or an expression whose value is the face name
|
|
|
909 to use. If you want FACENAME to be a symbol that evaluates to a face,
|
|
|
910 use a form like \"(progn sym)\".
|
|
|
911
|
|
|
912 OVERRIDE and LAXMATCH are flags. If OVERRIDE is t, existing fontification may
|
|
|
913 be overwritten. If `keep', only parts not already fontified are highlighted.
|
|
|
914 If `prepend' or `append', existing fontification is merged with the new, in
|
|
|
915 which the new or existing fontification, respectively, takes precedence.
|
|
|
916 If LAXMATCH is non-nil, no error is signalled if there is no MATCH in MATCHER.
|
|
|
917
|
|
|
918 For example, an element of the form highlights (if not already highlighted):
|
|
|
919
|
|
|
920 \"\\\\\\=<foo\\\\\\=>\" Discrete occurrences of \"foo\" in the value of the
|
|
|
921 variable `font-lock-keyword-face'.
|
|
|
922 (\"fu\\\\(bar\\\\)\" . 1) Substring \"bar\" within all occurrences of \"fubar\" in
|
|
|
923 the value of `font-lock-keyword-face'.
|
|
|
924 (\"fubar\" . fubar-face) Occurrences of \"fubar\" in the value of `fubar-face'.
|
|
|
925 (\"foo\\\\|bar\" 0 foo-bar-face t)
|
|
|
926 Occurrences of either \"foo\" or \"bar\" in the value
|
|
|
927 of `foo-bar-face', even if already highlighted.
|
|
|
928
|
|
|
929 MATCH-ANCHORED should be of the form:
|
|
|
930
|
|
|
931 (MATCHER PRE-MATCH-FORM POST-MATCH-FORM MATCH-HIGHLIGHT ...)
|
|
|
932
|
|
|
933 Where MATCHER is as for MATCH-HIGHLIGHT with one exception; see below.
|
|
|
934 PRE-MATCH-FORM and POST-MATCH-FORM are evaluated before the first, and after
|
|
|
935 the last, instance MATCH-ANCHORED's MATCHER is used. Therefore they can be
|
|
|
936 used to initialise before, and cleanup after, MATCHER is used. Typically,
|
|
|
937 PRE-MATCH-FORM is used to move to some position relative to the original
|
|
|
938 MATCHER, before starting with MATCH-ANCHORED's MATCHER. POST-MATCH-FORM might
|
|
|
939 be used to move, before resuming with MATCH-ANCHORED's parent's MATCHER.
|
|
|
940
|
|
|
941 For example, an element of the form highlights (if not already highlighted):
|
|
|
942
|
|
|
943 (\"\\\\\\=<anchor\\\\\\=>\" (0 anchor-face) (\"\\\\\\=<item\\\\\\=>\" nil nil (0 item-face)))
|
|
|
944
|
|
|
945 Discrete occurrences of \"anchor\" in the value of `anchor-face', and subsequent
|
|
|
946 discrete occurrences of \"item\" (on the same line) in the value of `item-face'.
|
|
|
947 (Here PRE-MATCH-FORM and POST-MATCH-FORM are nil. Therefore \"item\" is
|
|
|
948 initially searched for starting from the end of the match of \"anchor\", and
|
|
|
949 searching for subsequent instance of \"anchor\" resumes from where searching
|
|
|
950 for \"item\" concluded.)
|
|
|
951
|
|
|
952 The above-mentioned exception is as follows. The limit of the MATCHER search
|
|
|
953 defaults to the end of the line after PRE-MATCH-FORM is evaluated.
|
|
|
954 However, if PRE-MATCH-FORM returns a position greater than the position after
|
|
|
955 PRE-MATCH-FORM is evaluated, that position is used as the limit of the search.
|
|
|
956 It is generally a bad idea to return a position greater than the end of the
|
|
|
957 line, i.e., cause the MATCHER search to span lines.
|
|
|
958
|
|
|
959 Note that the MATCH-ANCHORED feature is experimental; in the future, we may
|
|
|
960 replace it with other ways of providing this functionality.
|
|
|
961
|
|
|
962 These regular expressions should not match text which spans lines. While
|
|
|
963 \\[font-lock-fontify-buffer] handles multi-line patterns correctly, updating
|
|
|
964 when you edit the buffer does not, since it considers text one line at a time.
|
|
|
965
|
|
|
966 Be very careful composing regexps for this list;
|
|
|
967 the wrong pattern can dramatically slow things down!")
|
|
|
968
|
|
|
969 (make-variable-buffer-local 'font-lock-keywords)
|
|
|
970
|
|
|
971 (defvar font-lock-mode nil)
|
|
|
972
|
|
|
973 (defvar font-lock-mode-hook nil "\
|
|
|
974 Function or functions to run on entry to font-lock-mode.")
|
|
|
975
|
|
|
976 (autoload 'font-lock-mode "font-lock" "\
|
|
|
977 Toggle Font Lock Mode.
|
|
|
978 With arg, turn font-lock mode on if and only if arg is positive.
|
|
|
979
|
|
|
980 When Font Lock mode is enabled, text is fontified as you type it:
|
|
|
981
|
|
|
982 - Comments are displayed in `font-lock-comment-face';
|
|
|
983 - Strings are displayed in `font-lock-string-face';
|
|
|
984 - Documentation strings (in Lisp-like languages) are displayed in
|
|
|
985 `font-lock-doc-string-face';
|
|
|
986 - Language keywords (\"reserved words\") are displayed in
|
|
|
987 `font-lock-keyword-face';
|
|
|
988 - Function names in their defining form are displayed in
|
|
|
989 `font-lock-function-name-face';
|
|
|
990 - Variable names in their defining form are displayed in
|
|
|
991 `font-lock-variable-name-face';
|
|
|
992 - Type names are displayed in `font-lock-type-face';
|
|
|
993 - References appearing in help files and the like are displayed
|
|
|
994 in `font-lock-reference-face';
|
|
|
995 - Preprocessor declarations are displayed in
|
|
|
996 `font-lock-preprocessor-face';
|
|
|
997
|
|
|
998 and
|
|
|
999
|
|
|
1000 - Certain other expressions are displayed in other faces according
|
|
|
1001 to the value of the variable `font-lock-keywords'.
|
|
|
1002
|
|
|
1003 Where modes support different levels of fontification, you can use the variable
|
|
|
1004 `font-lock-maximum-decoration' to specify which level you generally prefer.
|
|
|
1005 When you turn Font Lock mode on/off the buffer is fontified/defontified, though
|
|
|
1006 fontification occurs only if the buffer is less than `font-lock-maximum-size'.
|
|
|
1007 To fontify a buffer without turning on Font Lock mode, and regardless of buffer
|
|
|
1008 size, you can use \\[font-lock-fontify-buffer].
|
|
|
1009
|
|
|
1010 See the variable `font-lock-keywords' for customization." t nil)
|
|
|
1011
|
|
|
1012 (autoload 'turn-on-font-lock "font-lock" "\
|
|
|
1013 Unconditionally turn on Font Lock mode." nil nil)
|
|
|
1014
|
|
|
1015 (autoload 'turn-off-font-lock "font-lock" "\
|
|
|
1016 Unconditionally turn off Font Lock mode." nil nil)
|
|
|
1017
|
|
|
1018 (autoload 'font-lock-fontify-buffer "font-lock" "\
|
|
|
1019 Fontify the current buffer the way `font-lock-mode' would.
|
|
|
1020 See `font-lock-mode' for details.
|
|
|
1021
|
|
|
1022 This can take a while for large buffers." t nil)
|
|
|
1023
|
|
|
1024 (autoload 'font-lock-set-defaults-1 "font-lock" nil nil nil)
|
|
|
1025
|
|
|
1026 (add-minor-mode 'font-lock-mode " Font")
|
|
|
1027
|
|
|
1028 ;;;***
|
|
|
1029
|
|
|
1030 ;;;### (autoloads (x-font-build-cache font-default-size-for-device font-default-encoding-for-device font-default-registry-for-device font-default-family-for-device font-default-object-for-device font-default-font-for-device font-create-object) "font" "lisp/font.el")
|
|
|
1031
|
|
|
1032 (autoload 'font-create-object "font" nil nil nil)
|
|
|
1033
|
|
|
1034 (autoload 'font-default-font-for-device "font" nil nil nil)
|
|
|
1035
|
|
|
1036 (autoload 'font-default-object-for-device "font" nil nil nil)
|
|
|
1037
|
|
|
1038 (autoload 'font-default-family-for-device "font" nil nil nil)
|
|
|
1039
|
|
|
1040 (autoload 'font-default-registry-for-device "font" nil nil nil)
|
|
|
1041
|
|
|
1042 (autoload 'font-default-encoding-for-device "font" nil nil nil)
|
|
|
1043
|
|
|
1044 (autoload 'font-default-size-for-device "font" nil nil nil)
|
|
|
1045
|
|
|
1046 (autoload 'x-font-build-cache "font" nil nil nil)
|
|
|
1047
|
|
|
1048 ;;;***
|
|
|
1049
|
|
|
1050 ;;;### (autoloads (gnuserv-start gnuserv-running-p) "gnuserv" "lisp/gnuserv.el")
|
|
|
1051
|
|
|
1052 (defcustom gnuserv-frame nil "*The frame to be used to display all edited files.\nIf nil, then a new frame is created for each file edited.\nIf t, then the currently selected frame will be used.\nIf a function, then this will be called with a symbol `x' or `tty' as the\nonly argument, and its return value will be interpreted as above." :tag "Gnuserv Frame" :type '(radio (const :tag "Create new frame each time" nil) (const :tag "Use selected frame" t) (function-item :tag "Use main Emacs frame" gnuserv-main-frame-function) (function-item :tag "Use visible frame, otherwise create new" gnuserv-visible-frame-function) (function-item :tag "Create special Gnuserv frame and use it" gnuserv-special-frame-function) (function :tag "Other")) :group 'gnuserv :group 'frames)
|
|
|
1053
|
|
|
1054 (autoload 'gnuserv-running-p "gnuserv" "\
|
|
|
1055 Return non-nil if a gnuserv process is running from this XEmacs session." nil nil)
|
|
|
1056
|
|
|
1057 (autoload 'gnuserv-start "gnuserv" "\
|
|
|
1058 Allow this Emacs process to be a server for client processes.
|
|
|
1059 This starts a gnuserv communications subprocess through which
|
|
|
1060 client \"editors\" (gnuclient and gnudoit) can send editing commands to
|
|
|
1061 this Emacs job. See the gnuserv(1) manual page for more details.
|
|
|
1062
|
|
|
1063 Prefix arg means just kill any existing server communications subprocess." t nil)
|
|
|
1064
|
|
|
1065 ;;;***
|
|
|
1066
|
|
|
1067 ;;;### (autoloads nil "help-macro" "lisp/help-macro.el")
|
|
|
1068
|
|
|
1069 (defcustom three-step-help t "*Non-nil means give more info about Help command in three steps.\nThe three steps are simple prompt, prompt with all options,\nand window listing and describing the options.\nA value of nil means skip the middle step, so that\n\\[help-command] \\[help-command] gives the window that lists the options." :type 'boolean :group 'help-appearance)
|
|
|
1070
|
|
|
1071 ;;;***
|
|
|
1072
|
|
|
1073 ;;;### (autoloads (hyper-apropos-popup-menu hyper-apropos-set-variable hyper-set-variable hyper-apropos-read-variable-symbol hyper-describe-function hyper-describe-variable hyper-describe-face hyper-describe-key-briefly hyper-describe-key hyper-apropos) "hyper-apropos" "lisp/hyper-apropos.el")
|
|
|
1074
|
|
|
1075 (autoload 'hyper-apropos "hyper-apropos" "\
|
|
|
1076 Display lists of functions and variables matching REGEXP
|
|
|
1077 in buffer \"*Hyper Apropos*\". If optional prefix arg is given, then the
|
|
|
1078 value of `hyper-apropos-programming-apropos' is toggled for this search.
|
|
|
1079 See also `hyper-apropos-mode'." t nil)
|
|
|
1080
|
|
|
1081 (autoload 'hyper-describe-key "hyper-apropos" nil t nil)
|
|
|
1082
|
|
|
1083 (autoload 'hyper-describe-key-briefly "hyper-apropos" nil t nil)
|
|
|
1084
|
|
|
1085 (autoload 'hyper-describe-face "hyper-apropos" "\
|
|
|
1086 Describe face..
|
|
|
1087 See also `hyper-apropos' and `hyper-describe-function'." t nil)
|
|
|
1088
|
|
|
1089 (autoload 'hyper-describe-variable "hyper-apropos" "\
|
|
|
1090 Hypertext drop-in replacement for `describe-variable'.
|
|
|
1091 See also `hyper-apropos' and `hyper-describe-function'." t nil)
|
|
|
1092
|
|
|
1093 (autoload 'hyper-describe-function "hyper-apropos" "\
|
|
|
1094 Hypertext replacement for `describe-function'. Unlike `describe-function'
|
|
|
1095 in that the symbol under the cursor is the default if it is a function.
|
|
|
1096 See also `hyper-apropos' and `hyper-describe-variable'." t nil)
|
|
|
1097
|
|
|
1098 (autoload 'hyper-apropos-read-variable-symbol "hyper-apropos" "\
|
|
|
1099 Hypertext drop-in replacement for `describe-variable'.
|
|
|
1100 See also `hyper-apropos' and `hyper-describe-function'." nil nil)
|
|
|
1101
|
|
|
1102 (define-obsolete-function-alias 'hypropos-read-variable-symbol 'hyper-apropos-read-variable-symbol)
|
|
|
1103
|
|
|
1104 (define-obsolete-function-alias 'hypropos-get-doc 'hyper-apropos-get-doc)
|
|
|
1105
|
|
|
1106 (autoload 'hyper-set-variable "hyper-apropos" nil t nil)
|
|
|
1107
|
|
|
1108 (autoload 'hyper-apropos-set-variable "hyper-apropos" "\
|
|
|
1109 Interactively set the variable on the current line." t nil)
|
|
|
1110
|
|
|
1111 (define-obsolete-function-alias 'hypropos-set-variable 'hyper-apropos-set-variable)
|
|
|
1112
|
|
|
1113 (autoload 'hyper-apropos-popup-menu "hyper-apropos" nil t nil)
|
|
|
1114
|
|
|
1115 (define-obsolete-function-alias 'hypropos-popup-menu 'hyper-apropos-popup-menu)
|
|
|
1116
|
|
|
1117 ;;;***
|
|
|
1118
|
|
|
1119 ;;;### (autoloads (Info-elisp-ref Info-emacs-key Info-goto-emacs-key-command-node Info-goto-emacs-command-node Info-emacs-command Info-search Info-visit-file Info-goto-node Info-query info) "info" "lisp/info.el")
|
|
|
1120
|
|
|
1121 (autoload 'info "info" "\
|
|
|
1122 Enter Info, the documentation browser.
|
|
|
1123 Optional argument FILE specifies the file to examine;
|
|
|
1124 the default is the top-level directory of Info.
|
|
|
1125
|
|
|
1126 In interactive use, a prefix argument directs this command
|
|
|
1127 to read a file name from the minibuffer." t nil)
|
|
|
1128
|
|
|
1129 (autoload 'Info-query "info" "\
|
|
|
1130 Enter Info, the documentation browser. Prompt for name of Info file." t nil)
|
|
|
1131
|
|
|
1132 (autoload 'Info-goto-node "info" "\
|
|
|
1133 Go to info node named NAME. Give just NODENAME or (FILENAME)NODENAME.
|
|
|
1134 Actually, the following interpretations of NAME are tried in order:
|
|
|
1135 (FILENAME)NODENAME
|
|
|
1136 (FILENAME) (using Top node)
|
|
|
1137 NODENAME (in current file)
|
|
|
1138 TAGNAME (see below)
|
|
|
1139 FILENAME (using Top node)
|
|
|
1140 where TAGNAME is a string that appears in quotes: \"TAGNAME\", in an
|
|
|
1141 annotation for any node of any file. (See `a' and `x' commands.)" t nil)
|
|
|
1142
|
|
|
1143 (autoload 'Info-visit-file "info" "\
|
|
|
1144 Directly visit an info file." t nil)
|
|
|
1145
|
|
|
1146 (autoload 'Info-search "info" "\
|
|
|
1147 Search for REGEXP, starting from point, and select node it's found in." t nil)
|
|
|
1148
|
|
|
1149 (autoload 'Info-emacs-command "info" "\
|
|
|
1150 Look up an Emacs command in the Emacs manual in the Info system.
|
|
|
1151 This command is designed to be used whether you are already in Info or not." t nil)
|
|
|
1152
|
|
|
1153 (autoload 'Info-goto-emacs-command-node "info" "\
|
|
|
1154 Look up an Emacs command in the Emacs manual in the Info system.
|
|
|
1155 This command is designed to be used whether you are already in Info or not." t nil)
|
|
|
1156
|
|
|
1157 (autoload 'Info-goto-emacs-key-command-node "info" "\
|
|
|
1158 Look up an Emacs key sequence in the Emacs manual in the Info system.
|
|
|
1159 This command is designed to be used whether you are already in Info or not." t nil)
|
|
|
1160
|
|
|
1161 (autoload 'Info-emacs-key "info" "\
|
|
|
1162 Look up an Emacs key sequence in the Emacs manual in the Info system.
|
|
|
1163 This command is designed to be used whether you are already in Info or not." t nil)
|
|
|
1164
|
|
|
1165 (autoload 'Info-elisp-ref "info" "\
|
|
|
1166 Look up an Emacs Lisp function in the Elisp manual in the Info system.
|
|
|
1167 This command is designed to be used whether you are already in Info or not." t nil)
|
|
|
1168
|
|
|
1169 ;;;***
|
|
|
1170
|
|
|
1171 ;;;### (autoloads nil "itimer-autosave" "lisp/itimer-autosave.el")
|
|
|
1172
|
|
|
1173 ;;;***
|
|
|
1174
|
|
|
1175 ;;;### (autoloads nil "loaddefs" "lisp/loaddefs.el")
|
|
|
1176
|
|
|
1177 ;;;***
|
|
|
1178
|
|
|
1179 ;;;### (autoloads (package-admin-add-binary-package package-admin-add-single-file-package) "package-admin" "lisp/package-admin.el")
|
|
|
1180
|
|
|
1181 (autoload 'package-admin-add-single-file-package "package-admin" "\
|
|
|
1182 Install a single file Lisp package into XEmacs package hierarchy.
|
|
|
1183 `file' should be the full path to the lisp file to install.
|
|
|
1184 `destdir' should be a simple directory name.
|
|
|
1185 The optional `pkg-dir' can be used to override the default package hiearchy
|
|
|
1186 \(last package-path)." t nil)
|
|
|
1187
|
|
|
1188 (autoload 'package-admin-add-binary-package "package-admin" "\
|
|
|
1189 Install a pre-bytecompiled XEmacs package into package hierarchy." t nil)
|
|
|
1190
|
|
|
1191 ;;;***
|
|
|
1192
|
|
|
1193 ;;;### (autoloads (list-load-path-shadows) "shadow" "lisp/shadow.el")
|
|
|
1194
|
|
|
1195 (autoload 'list-load-path-shadows "shadow" "\
|
|
|
1196 Display a list of Emacs Lisp files that shadow other files.
|
|
|
1197
|
|
|
1198 This function lists potential load-path problems. Directories in the
|
|
|
1199 `load-path' variable are searched, in order, for Emacs Lisp
|
|
|
1200 files. When a previously encountered file name is found again, a
|
|
|
1201 message is displayed indicating that the later file is \"hidden\" by
|
|
|
1202 the earlier.
|
|
|
1203
|
|
|
1204 For example, suppose `load-path' is set to
|
|
|
1205
|
|
|
1206 \(\"/usr/gnu/emacs/site-lisp\" \"/usr/gnu/emacs/share/emacs/19.30/lisp\")
|
|
|
1207
|
|
|
1208 and that each of these directories contains a file called XXX.el. Then
|
|
|
1209 XXX.el in the site-lisp directory is referred to by all of:
|
|
|
1210 \(require 'XXX), (autoload .... \"XXX\"), (load-library \"XXX\") etc.
|
|
|
1211
|
|
|
1212 The first XXX.el file prevents emacs from seeing the second (unless
|
|
|
1213 the second is loaded explicitly via load-file).
|
|
|
1214
|
|
|
1215 When not intended, such shadowings can be the source of subtle
|
|
|
1216 problems. For example, the above situation may have arisen because the
|
|
|
1217 XXX package was not distributed with versions of emacs prior to
|
|
|
1218 19.30. An emacs maintainer downloaded XXX from elsewhere and installed
|
|
|
1219 it. Later, XXX was updated and included in the emacs distribution.
|
|
|
1220 Unless the emacs maintainer checks for this, the new version of XXX
|
|
|
1221 will be hidden behind the old (which may no longer work with the new
|
|
|
1222 emacs version).
|
|
|
1223
|
|
|
1224 This function performs these checks and flags all possible
|
|
|
1225 shadowings. Because a .el file may exist without a corresponding .elc
|
|
|
1226 \(or vice-versa), these suffixes are essentially ignored. A file
|
|
|
1227 XXX.elc in an early directory (that does not contain XXX.el) is
|
|
|
1228 considered to shadow a later file XXX.el, and vice-versa.
|
|
|
1229
|
|
|
1230 When run interactively, the shadowings (if any) are displayed in a
|
|
|
1231 buffer called `*Shadows*'. Shadowings are located by calling the
|
|
|
1232 \(non-interactive) companion function, `find-emacs-lisp-shadows'." t nil)
|
|
|
1233
|
|
|
1234 ;;;***
|
|
|
1235
|
|
|
1236 ;;;### (autoloads (load-default-sounds load-sound-file) "sound" "lisp/sound.el")
|
|
|
1237
|
|
|
1238 (or sound-alist (setq sound-alist '((ready nil) (warp nil))))
|
|
|
1239
|
|
|
1240 (autoload 'load-sound-file "sound" "\
|
|
|
1241 Read in an audio-file and add it to the sound-alist.
|
|
|
1242
|
|
|
1243 You can only play sound files if you are running on display 0 of the
|
|
|
1244 console of a machine with native sound support or running a NetAudio
|
|
|
1245 server and XEmacs has the necessary sound support compiled in.
|
|
|
1246
|
|
|
1247 The sound file must be in the Sun/NeXT U-LAW format, except on Linux,
|
|
|
1248 where .wav files are also supported by the sound card drivers." t nil)
|
|
|
1249
|
|
|
1250 (autoload 'load-default-sounds "sound" "\
|
|
|
1251 Load and install some sound files as beep-types, using
|
|
|
1252 `load-sound-file'. This only works if you're on display 0 of the
|
|
|
1253 console of a machine with native sound support or running a NetAudio
|
|
|
1254 server and XEmacs has the necessary sound support compiled in." t nil)
|
|
|
1255
|
|
|
1256 ;;;***
|
|
|
1257
|
|
|
1258 ;;;### (autoloads (auto-view-mode view-major-mode view-mode view-minor-mode view-buffer-other-window view-file-other-window view-buffer view-file) "view-less" "lisp/view-less.el")
|
|
|
1259
|
|
|
1260 (defvar view-minor-mode-map (let ((map (make-keymap))) (set-keymap-name map 'view-minor-mode-map) (suppress-keymap map) (define-key map "-" 'negative-argument) (define-key map " " 'scroll-up) (define-key map "f" 'scroll-up) (define-key map "b" 'scroll-down) (define-key map 'backspace 'scroll-down) (define-key map 'delete 'scroll-down) (define-key map "
" 'view-scroll-lines-up) (define-key map "\n" 'view-scroll-lines-up) (define-key map "e" 'view-scroll-lines-up) (define-key map "j" 'view-scroll-lines-up) (define-key map "y" 'view-scroll-lines-down) (define-key map "k" 'view-scroll-lines-down) (define-key map "d" 'view-scroll-some-lines-up) (define-key map "u" 'view-scroll-some-lines-down) (define-key map "r" 'recenter) (define-key map "t" 'toggle-truncate-lines) (define-key map "N" 'view-buffer) (define-key map "E" 'view-file) (define-key map "P" 'view-buffer) (define-key map "!" 'shell-command) (define-key map "|" 'shell-command-on-region) (define-key map "=" 'what-line) (define-key map "?" 'view-search-backward) (define-key map "h" 'view-mode-describe) (define-key map "s" 'view-repeat-search) (define-key map "n" 'view-repeat-search) (define-key map "/" 'view-search-forward) (define-key map "\\" 'view-search-backward) (define-key map "g" 'view-goto-line) (define-key map "G" 'view-last-windowful) (define-key map "%" 'view-goto-percent) (define-key map "p" 'view-goto-percent) (define-key map "m" 'point-to-register) (define-key map "'" 'register-to-point) (define-key map "C" 'view-cleanup-backspaces) (define-key map "" 'view-quit) (define-key map "" 'view-quit-toggle-ro) (define-key map "q" 'view-quit) map))
|
|
|
1261
|
|
|
1262 (defvar view-mode-map (let ((map (copy-keymap view-minor-mode-map))) (set-keymap-name map 'view-mode-map) map))
|
|
|
1263
|
|
|
1264 (autoload 'view-file "view-less" "\
|
|
|
1265 Find FILE, enter view mode. With prefix arg OTHER-P, use other window." t nil)
|
|
|
1266
|
|
|
1267 (autoload 'view-buffer "view-less" "\
|
|
|
1268 Switch to BUF, enter view mode. With prefix arg use other window." t nil)
|
|
|
1269
|
|
|
1270 (autoload 'view-file-other-window "view-less" "\
|
|
|
1271 Find FILE in other window, and enter view mode." t nil)
|
|
|
1272
|
|
|
1273 (autoload 'view-buffer-other-window "view-less" "\
|
|
|
1274 Switch to BUFFER in another window, and enter view mode." t nil)
|
|
|
1275
|
|
|
1276 (autoload 'view-minor-mode "view-less" "\
|
|
|
1277 Minor mode for viewing text, with bindings like `less'.
|
|
|
1278 Commands are:
|
|
|
1279 \\<view-minor-mode-map>
|
|
|
1280 0..9 prefix args
|
|
|
1281 - prefix minus
|
|
|
1282 \\[scroll-up] page forward
|
|
|
1283 \\[scroll-down] page back
|
|
|
1284 \\[view-scroll-lines-up] scroll prefix-arg lines forward, default 1.
|
|
|
1285 \\[view-scroll-lines-down] scroll prefix-arg lines backward, default 1.
|
|
|
1286 \\[view-scroll-some-lines-down] scroll prefix-arg lines backward, default 10.
|
|
|
1287 \\[view-scroll-some-lines-up] scroll prefix-arg lines forward, default 10.
|
|
|
1288 \\[what-line] print line number
|
|
|
1289 \\[view-mode-describe] print this help message
|
|
|
1290 \\[view-search-forward] regexp search, uses previous string if you just hit RET
|
|
|
1291 \\[view-search-backward] as above but searches backward
|
|
|
1292 \\[view-repeat-search] repeat last search
|
|
|
1293 \\[view-goto-line] goto line prefix-arg, default 1
|
|
|
1294 \\[view-last-windowful] goto line prefix-arg, default last line
|
|
|
1295 \\[view-goto-percent] goto a position by percentage
|
|
|
1296 \\[toggle-truncate-lines] toggle truncate-lines
|
|
|
1297 \\[view-file] view another file
|
|
|
1298 \\[view-buffer] view another buffer
|
|
|
1299 \\[view-cleanup-backspaces] cleanup backspace constructions
|
|
|
1300 \\[shell-command] execute a shell command
|
|
|
1301 \\[shell-command-on-region] execute a shell command with the region as input
|
|
|
1302 \\[view-quit] exit view-mode, and bury the current buffer.
|
|
|
1303
|
|
|
1304 If invoked with the optional (prefix) arg non-nil, view-mode cleans up
|
|
|
1305 backspace constructions.
|
|
|
1306
|
|
|
1307 More precisely:
|
|
|
1308 \\{view-minor-mode-map}" t nil)
|
|
|
1309
|
|
|
1310 (autoload 'view-mode "view-less" "\
|
|
|
1311 View the current buffer using view-minor-mode. This exists to be 99.9%
|
|
|
1312 compatible with the implementations of `view-mode' in view.el and older
|
|
|
1313 versions of view-less.el." t nil)
|
|
|
1314
|
|
|
1315 (autoload 'view-major-mode "view-less" "\
|
|
|
1316 View the current buffer using view-mode, as a major mode.
|
|
|
1317 This function has a nonstandard name because `view-mode' is wrongly
|
|
|
1318 named but is like this for compatibility reasons." t nil)
|
|
|
1319
|
|
|
1320 (autoload 'auto-view-mode "view-less" "\
|
|
|
1321 If the file of the current buffer is not writable, call view-mode.
|
|
|
1322 This is meant to be added to `find-file-hooks'." nil nil)
|
|
|
1323
|
|
|
1324 ;;;***
|
|
|
1325
|
|
209
|
1326 ;;;### (autoloads (widget-minor-mode widget-browse-other-window widget-browse widget-browse-at) "wid-browse" "lisp/wid-browse.el")
|
|
|
1327
|
|
|
1328 (autoload 'widget-browse-at "wid-browse" "\
|
|
|
1329 Browse the widget under point." t nil)
|
|
|
1330
|
|
|
1331 (autoload 'widget-browse "wid-browse" "\
|
|
|
1332 Create a widget browser for WIDGET." t nil)
|
|
|
1333
|
|
|
1334 (autoload 'widget-browse-other-window "wid-browse" "\
|
|
|
1335 Show widget browser for WIDGET in other window." t nil)
|
|
|
1336
|
|
|
1337 (autoload 'widget-minor-mode "wid-browse" "\
|
|
|
1338 Togle minor mode for traversing widgets.
|
|
|
1339 With arg, turn widget mode on if and only if arg is positive." t nil)
|
|
|
1340
|
|
|
1341 ;;;***
|
|
|
1342
|
|
|
1343 ;;;### (autoloads (widget-delete widget-create widget-prompt-value) "wid-edit" "lisp/wid-edit.el")
|
|
|
1344
|
|
|
1345 (autoload 'widget-prompt-value "wid-edit" "\
|
|
|
1346 Prompt for a value matching WIDGET, using PROMPT.
|
|
|
1347 The current value is assumed to be VALUE, unless UNBOUND is non-nil." nil nil)
|
|
|
1348
|
|
|
1349 (autoload 'widget-create "wid-edit" "\
|
|
|
1350 Create widget of TYPE.
|
|
|
1351 The optional ARGS are additional keyword arguments." nil nil)
|
|
|
1352
|
|
|
1353 (autoload 'widget-delete "wid-edit" "\
|
|
|
1354 Delete WIDGET." nil nil)
|
|
|
1355
|
|
|
1356 ;;;***
|
|
|
1357
|
|
|
1358 ;;;### (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")
|
|
|
1359
|
|
|
1360 (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)
|
|
|
1361
|
|
|
1362 (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)
|
|
|
1363
|
|
|
1364 (fset 'install-font-menus 'reset-device-font-menus)
|
|
|
1365
|
|
|
1366 (autoload 'reset-device-font-menus "x-font-menu" "\
|
|
|
1367 Generates the `Font', `Size', and `Weight' submenus for the Options menu.
|
|
|
1368 This is run the first time that a font-menu is needed for each device.
|
|
|
1369 If you don't like the lazy invocation of this function, you can add it to
|
|
|
1370 `create-device-hook' and that will make the font menus respond more quickly
|
|
|
1371 when they are selected for the first time. If you add fonts to your system,
|
|
|
1372 or if you change your font path, you can call this to re-initialize the menus." nil nil)
|
|
|
1373
|
|
|
1374 (autoload 'font-menu-family-constructor "x-font-menu" nil nil nil)
|
|
|
1375
|
|
|
1376 (autoload 'font-menu-size-constructor "x-font-menu" nil nil nil)
|
|
|
1377
|
|
|
1378 (autoload 'font-menu-weight-constructor "x-font-menu" nil nil nil)
|
|
|
1379
|
|
|
1380 ;;;***
|
|
|
1381
|
|
217
|
1382 (provide 'Standard-autoloads)
|
