Add some GT code points.
[chise/xemacs-chise.git.1] / lisp / auto-autoloads.el
1 ;;; DO NOT MODIFY THIS FILE
2 (if (featurep 'lisp-autoloads) (error "Already loaded"))
3 \f
4 ;;;### (autoloads nil "abbrev" "lisp/abbrev.el")
5
6 ;;;***
7 \f
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 \f
15 ;;;### (autoloads (set-modified-alist modify-alist remove-alist set-alist del-alist put-alist vassoc) "alist" "lisp/alist.el")
16
17 (autoload 'vassoc "alist" "\
18 Search VALIST for a vector whose first element is equal to KEY.
19 See also `assoc'." nil nil)
20
21 (autoload 'put-alist "alist" "\
22 Modify ALIST to set VALUE to ITEM.
23 If there is a pair whose car is ITEM, replace its cdr by VALUE.
24 If there is not such pair, create new pair (ITEM . VALUE) and
25 return new alist whose car is the new pair and cdr is ALIST.
26 [tomo's ELIS like function]" nil nil)
27
28 (autoload 'del-alist "alist" "\
29 If there is a pair whose key is ITEM, delete it from ALIST.
30 [tomo's ELIS emulating function]" nil nil)
31
32 (autoload 'set-alist "alist" "\
33 Modify a alist indicated by SYMBOL to set VALUE to ITEM." nil nil)
34
35 (autoload 'remove-alist "alist" "\
36 Remove ITEM from the alist indicated by SYMBOL." nil nil)
37
38 (autoload 'modify-alist "alist" "\
39 Modify alist DEFAULT into alist MODIFIER." nil nil)
40
41 (autoload 'set-modified-alist "alist" "\
42 Modify a value of a symbol SYM into alist MODIFIER.
43 The symbol SYM should be alist. If it is not bound,
44 its value regard as nil." nil nil)
45
46 ;;;***
47 \f
48 ;;;### (autoloads (apropos-documentation apropos-value apropos apropos-command) "apropos" "lisp/apropos.el")
49
50 (fset 'command-apropos 'apropos-command)
51
52 (autoload 'apropos-command "apropos" "\
53 Shows commands (interactively callable functions) that match REGEXP.
54 With optional prefix ARG or if `apropos-do-all' is non-nil, also show
55 variables." t nil)
56
57 (autoload 'apropos "apropos" "\
58 Show all bound symbols whose names match REGEXP.
59 With optional prefix ARG or if `apropos-do-all' is non-nil, also show unbound
60 symbols and key bindings, which is a little more time-consuming.
61 Returns list of symbols and documentation found." t nil)
62
63 (autoload 'apropos-value "apropos" "\
64 Show all symbols whose value's printed image matches REGEXP.
65 With optional prefix ARG or if `apropos-do-all' is non-nil, also looks
66 at the function and at the names and values of properties.
67 Returns list of symbols and values found." t nil)
68
69 (autoload 'apropos-documentation "apropos" "\
70 Show symbols whose documentation contain matches for REGEXP.
71 With optional prefix ARG or if `apropos-do-all' is non-nil, also use
72 documentation that is not stored in the documentation file and show key
73 bindings.
74 Returns list of symbols and documentation found." t nil)
75
76 ;;;***
77 \f
78 ;;;### (autoloads (batch-update-one-directory batch-update-directory batch-update-autoloads update-autoloads-from-directory update-autoloads-here update-file-autoloads generate-file-autoloads) "autoload" "lisp/autoload.el")
79
80 (autoload 'generate-file-autoloads "autoload" "\
81 Insert at point a loaddefs autoload section for FILE.
82 autoloads are generated for defuns and defmacros in FILE
83 marked by `generate-autoload-cookie' (which see).
84 If FILE is being visited in a buffer, the contents of the buffer
85 are used." t nil)
86
87 (autoload 'update-file-autoloads "autoload" "\
88 Update the autoloads for FILE in `generated-autoload-file'
89 \(which FILE might bind in its local variables).
90 This function refuses to update autoloads files." t nil)
91
92 (autoload 'update-autoloads-here "autoload" "\
93 Update sections of the current buffer generated by `update-file-autoloads'." t nil)
94
95 (autoload 'update-autoloads-from-directory "autoload" "\
96 Update `generated-autoload-file' with all the current autoloads from DIR.
97 This runs `update-file-autoloads' on each .el file in DIR.
98 Obsolete autoload entries for files that no longer exist are deleted.
99 Note that, if this function is called from `batch-update-directory',
100 `generated-autoload-file' was rebound in that function." t nil)
101
102 (autoload 'batch-update-autoloads "autoload" "\
103 Update the autoloads for the files or directories on the command line.
104 Runs `update-file-autoloads' on files and `update-directory-autoloads'
105 on directories.  Must be used only with -batch, and kills Emacs on completion.
106 Each file will be processed even if an error occurred previously.
107 For example, invoke `xemacs -batch -f batch-update-autoloads *.el'.
108 The directory to which the auto-autoloads.el file must be the first parameter
109 on the command line." nil nil)
110
111 (autoload 'batch-update-directory "autoload" "\
112 Update the autoloads for the directories on the command line.
113 Runs `update-file-autoloads' on each file in the given directory, and must
114 be used only with -batch." nil nil)
115
116 (autoload 'batch-update-one-directory "autoload" "\
117 Update the autoloads for a single directory on the command line.
118 Runs `update-file-autoloads' on each file in the given directory, and must
119 be used only with -batch." nil nil)
120
121 ;;;***
122 \f
123 ;;;### (autoloads nil "buff-menu" "lisp/buff-menu.el")
124
125 (defvar list-buffers-directory nil)
126
127 (make-variable-buffer-local 'list-buffers-directory)
128
129 ;;;***
130 \f
131 ;;;### (autoloads (build-report) "build-report" "lisp/build-report.el")
132
133 (autoload 'build-report "build-report" "\
134 Report build information including Installation and make output.
135
136 Prompts for status (usually \"Success\" or \"Failure\").  Then uses
137 `compose-mail' to create a mail message.  The Subject header contains
138 status and version information.  Point is left at the beginning of the
139 mail text.  Add some notes if you like, and send the report.
140
141 Looks for Installation and the make output file (`beta.err' by
142 default, customizable via `build-report-make-output-files') in the
143 build directory of the running XEmacs by default (customizable via
144 `build-report-make-output-dir').  The output from make is filtered
145 through `build-report-keep-regexp' and `build-report-delete-regexp'
146 before including in the message.
147
148 See also `mail-user-agent', `build-report-destination', and
149 `build-report-installation-file'." t nil)
150
151 ;;;***
152 \f
153 ;;;### (autoloads (batch-byte-recompile-directory batch-byte-recompile-directory-norecurse batch-byte-compile-one-file batch-byte-compile display-call-tree byte-compile-sexp byte-compile compile-defun byte-compile-buffer byte-compile-and-load-file byte-compile-file byte-recompile-file byte-recompile-directory byte-force-recompile) "bytecomp" "lisp/bytecomp.el")
154
155 (autoload 'byte-force-recompile "bytecomp" "\
156 Recompile every `.el' file in DIRECTORY that already has a `.elc' file.
157 Files in subdirectories of DIRECTORY are processed also." t nil)
158
159 (autoload 'byte-recompile-directory "bytecomp" "\
160 Recompile every `.el' file in DIRECTORY that needs recompilation.
161 This is if a `.elc' file exists but is older than the `.el' file.
162 Files in subdirectories of DIRECTORY are also processed unless
163 optional argument NORECURSION is non-nil.
164
165 If the `.elc' file does not exist, normally the `.el' file is *not* compiled.
166 But a prefix argument (optional second arg) means ask user,
167 for each such `.el' file, whether to compile it.  Prefix argument 0 means
168 don't ask and compile the file anyway.
169
170 A nonzero prefix argument also means ask about each subdirectory.
171
172 If the fourth optional argument FORCE is non-nil,
173 recompile every `.el' file that already has a `.elc' file." t nil)
174
175 (autoload 'byte-recompile-file "bytecomp" "\
176 Recompile a file of Lisp code named FILENAME if it needs recompilation.
177 This is if the `.elc' file exists but is older than the `.el' file.
178
179 If the `.elc' file does not exist, normally the `.el' file is *not*
180 compiled.  But a prefix argument (optional second arg) means ask user
181 whether to compile it.  Prefix argument 0 don't ask and recompile anyway." t nil)
182
183 (autoload 'byte-compile-file "bytecomp" "\
184 Compile a file of Lisp code named FILENAME into a file of byte code.
185 The output file's name is made by appending `c' to the end of FILENAME.
186 With prefix arg (noninteractively: 2nd arg), load the file after compiling." t nil)
187
188 (autoload 'byte-compile-and-load-file "bytecomp" "\
189 Compile a file of Lisp code named FILENAME into a file of byte code,
190 and then load it.  The output file's name is made by appending \"c\" to
191 the end of FILENAME." t nil)
192
193 (autoload 'byte-compile-buffer "bytecomp" "\
194 Byte-compile and evaluate contents of BUFFER (default: the current buffer)." t nil)
195
196 (autoload 'compile-defun "bytecomp" "\
197 Compile and evaluate the current top-level form.
198 Print the result in the minibuffer.
199 With argument, insert value in current buffer after the form." t nil)
200
201 (autoload 'byte-compile "bytecomp" "\
202 If FORM is a symbol, byte-compile its function definition.
203 If FORM is a lambda or a macro, byte-compile it as a function." nil nil)
204
205 (autoload 'byte-compile-sexp "bytecomp" "\
206 Compile and return SEXP." nil nil)
207
208 (autoload 'display-call-tree "bytecomp" "\
209 Display a call graph of a specified file.
210 This lists which functions have been called, what functions called
211 them, and what functions they call.  The list includes all functions
212 whose definitions have been compiled in this Emacs session, as well as
213 all functions called by those functions.
214
215 The call graph does not include macros, inline functions, or
216 primitives that the byte-code interpreter knows about directly (eq,
217 cons, etc.).
218
219 The call tree also lists those functions which are not known to be called
220 \(that is, to which no calls have been compiled), and which cannot be
221 invoked interactively." t nil)
222
223 (autoload 'batch-byte-compile "bytecomp" "\
224 Run `byte-compile-file' on the files remaining on the command line.
225 Use this from the command line, with `-batch';
226 it won't work in an interactive Emacs.
227 Each file is processed even if an error occurred previously.
228 For example, invoke \"xemacs -batch -f batch-byte-compile $emacs/ ~/*.el\"." nil nil)
229
230 (autoload 'batch-byte-compile-one-file "bytecomp" "\
231 Run `byte-compile-file' on a single file remaining on the command line.
232 Use this from the command line, with `-batch';
233 it won't work in an interactive Emacs." nil nil)
234
235 (autoload 'batch-byte-recompile-directory-norecurse "bytecomp" "\
236 Same as `batch-byte-recompile-directory' but without recursion." nil nil)
237
238 (autoload 'batch-byte-recompile-directory "bytecomp" "\
239 Runs `byte-recompile-directory' on the dirs remaining on the command line.
240 Must be used only with `-batch', and kills Emacs on completion.
241 For example, invoke `xemacs -batch -f batch-byte-recompile-directory .'." nil nil)
242
243 ;;;***
244 \f
245 ;;;### (autoloads (compiler-macroexpand define-compiler-macro ignore-file-errors 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* cl-compile-time-init) "cl-macs" "lisp/cl-macs.el")
246
247 (autoload 'cl-compile-time-init "cl-macs" nil nil nil)
248
249 (autoload 'defun* "cl-macs" "\
250 (defun* NAME ARGLIST [DOCSTRING] BODY...): define NAME as a function.
251 Like normal `defun', except ARGLIST allows full Common Lisp conventions,
252 and BODY is implicitly surrounded by (block NAME ...)." nil 'macro)
253
254 (autoload 'defmacro* "cl-macs" "\
255 (defmacro* NAME ARGLIST [DOCSTRING] BODY...): define NAME as a macro.
256 Like normal `defmacro', except ARGLIST allows full Common Lisp conventions,
257 and BODY is implicitly surrounded by (block NAME ...)." nil 'macro)
258
259 (autoload 'function* "cl-macs" "\
260 (function* SYMBOL-OR-LAMBDA): introduce a function.
261 Like normal `function', except that if argument is a lambda form, its
262 ARGLIST allows full Common Lisp conventions." nil 'macro)
263
264 (autoload 'destructuring-bind "cl-macs" nil nil 'macro)
265
266 (autoload 'eval-when "cl-macs" "\
267 (eval-when (WHEN...) BODY...): control when BODY is evaluated.
268 If `compile' is in WHEN, BODY is evaluated when compiled at top-level.
269 If `load' is in WHEN, BODY is evaluated when loaded after top-level compile.
270 If `eval' is in WHEN, BODY is evaluated when interpreted or at non-top-level." nil 'macro)
271
272 (autoload 'load-time-value "cl-macs" "\
273 Like `progn', but evaluates the body at load time.
274 The result of the body appears to the compiler as a quoted constant." nil 'macro)
275
276 (autoload 'case "cl-macs" "\
277 (case EXPR CLAUSES...): evals EXPR, chooses from CLAUSES on that value.
278 Each clause looks like (KEYLIST BODY...).  EXPR is evaluated and compared
279 against each key in each KEYLIST; the corresponding BODY is evaluated.
280 If no clause succeeds, case returns nil.  A single atom may be used in
281 place of a KEYLIST of one atom.  A KEYLIST of `t' or `otherwise' is
282 allowed only in the final clause, and matches if no other keys match.
283 Key values are compared by `eql'." nil 'macro)
284
285 (autoload 'ecase "cl-macs" "\
286 (ecase EXPR CLAUSES...): like `case', but error if no case fits.
287 `otherwise'-clauses are not allowed." nil 'macro)
288
289 (autoload 'typecase "cl-macs" "\
290 (typecase EXPR CLAUSES...): evals EXPR, chooses from CLAUSES on that value.
291 Each clause looks like (TYPE BODY...).  EXPR is evaluated and, if it
292 satisfies TYPE, the corresponding BODY is evaluated.  If no clause succeeds,
293 typecase returns nil.  A TYPE of `t' or `otherwise' is allowed only in the
294 final clause, and matches if no other keys match." nil 'macro)
295
296 (autoload 'etypecase "cl-macs" "\
297 (etypecase EXPR CLAUSES...): like `typecase', but error if no case fits.
298 `otherwise'-clauses are not allowed." nil 'macro)
299
300 (autoload 'block "cl-macs" "\
301 (block NAME BODY...): define a lexically-scoped block named NAME.
302 NAME may be any symbol.  Code inside the BODY forms can call `return-from'
303 to jump prematurely out of the block.  This differs from `catch' and `throw'
304 in two respects:  First, the NAME is an unevaluated symbol rather than a
305 quoted symbol or other form; and second, NAME is lexically rather than
306 dynamically scoped:  Only references to it within BODY will work.  These
307 references may appear inside macro expansions, but not inside functions
308 called from BODY." nil 'macro)
309
310 (autoload 'return "cl-macs" "\
311 (return [RESULT]): return from the block named nil.
312 This is equivalent to `(return-from nil RESULT)'." nil 'macro)
313
314 (autoload 'return-from "cl-macs" "\
315 (return-from NAME [RESULT]): return from the block named NAME.
316 This jumps out to the innermost enclosing `(block NAME ...)' form,
317 returning RESULT from that form (or nil if RESULT is omitted).
318 This is compatible with Common Lisp, but note that `defun' and
319 `defmacro' do not create implicit blocks as they do in Common Lisp." nil 'macro)
320
321 (autoload 'loop "cl-macs" "\
322 (loop CLAUSE...): The Common Lisp `loop' macro.
323 Valid clauses are:
324   for VAR from/upfrom/downfrom NUM to/upto/downto/above/below NUM by NUM,
325   for VAR in LIST by FUNC, for VAR on LIST by FUNC, for VAR = INIT then EXPR,
326   for VAR across ARRAY, repeat NUM, with VAR = INIT, while COND, until COND,
327   always COND, never COND, thereis COND, collect EXPR into VAR,
328   append EXPR into VAR, nconc EXPR into VAR, sum EXPR into VAR,
329   count EXPR into VAR, maximize EXPR into VAR, minimize EXPR into VAR,
330   if COND CLAUSE [and CLAUSE]... else CLAUSE [and CLAUSE...],
331   unless COND CLAUSE [and CLAUSE]... else CLAUSE [and CLAUSE...],
332   do EXPRS..., initially EXPRS..., finally EXPRS..., return EXPR,
333   finally return EXPR, named NAME." nil 'macro)
334
335 (autoload 'do "cl-macs" "\
336 The Common Lisp `do' loop.
337 Format is: (do ((VAR INIT [STEP])...) (END-TEST [RESULT...]) BODY...)" nil 'macro)
338
339 (autoload 'do* "cl-macs" "\
340 The Common Lisp `do*' loop.
341 Format is: (do* ((VAR INIT [STEP])...) (END-TEST [RESULT...]) BODY...)" nil 'macro)
342
343 (autoload 'dolist "cl-macs" "\
344 (dolist (VAR LIST [RESULT]) BODY...): loop over a list.
345 Evaluate BODY with VAR bound to each `car' from LIST, in turn.
346 Then evaluate RESULT to get return value, default nil." nil 'macro)
347
348 (autoload 'dotimes "cl-macs" "\
349 (dotimes (VAR COUNT [RESULT]) BODY...): loop a certain number of times.
350 Evaluate BODY with VAR bound to successive integers from 0, inclusive,
351 to COUNT, exclusive.  Then evaluate RESULT to get return value, default
352 nil." nil 'macro)
353
354 (autoload 'do-symbols "cl-macs" "\
355 (dosymbols (VAR [OBARRAY [RESULT]]) BODY...): loop over all symbols.
356 Evaluate BODY with VAR bound to each interned symbol, or to each symbol
357 from OBARRAY." nil 'macro)
358
359 (autoload 'do-all-symbols "cl-macs" nil nil 'macro)
360
361 (autoload 'psetq "cl-macs" "\
362 (psetq SYM VAL SYM VAL ...): set SYMs to the values VALs in parallel.
363 This is like `setq', except that all VAL forms are evaluated (in order)
364 before assigning any symbols SYM to the corresponding values." nil 'macro)
365
366 (autoload 'progv "cl-macs" "\
367 (progv SYMBOLS VALUES BODY...): bind SYMBOLS to VALUES dynamically in BODY.
368 The forms SYMBOLS and VALUES are evaluated, and must evaluate to lists.
369 Each SYMBOL in the first list is bound to the corresponding VALUE in the
370 second list (or made unbound if VALUES is shorter than SYMBOLS); then the
371 BODY forms are executed and their result is returned.  This is much like
372 a `let' form, except that the list of symbols can be computed at run-time." nil 'macro)
373
374 (autoload 'flet "cl-macs" "\
375 (flet ((FUNC ARGLIST BODY...) ...) FORM...): make temporary function defns.
376 This is an analogue of `let' that operates on the function cell of FUNC
377 rather than its value cell.  The FORMs are evaluated with the specified
378 function definitions in place, then the definitions are undone (the FUNCs
379 go back to their previous definitions, or lack thereof)." nil 'macro)
380
381 (autoload 'labels "cl-macs" "\
382 (labels ((FUNC ARGLIST BODY...) ...) FORM...): make temporary func bindings.
383 This is like `flet', except the bindings are lexical instead of dynamic.
384 Unlike `flet', this macro is fully compliant with the Common Lisp standard." nil 'macro)
385
386 (autoload 'macrolet "cl-macs" "\
387 (macrolet ((NAME ARGLIST BODY...) ...) FORM...): make temporary macro defns.
388 This is like `flet', but for macros instead of functions." nil 'macro)
389
390 (autoload 'symbol-macrolet "cl-macs" "\
391 (symbol-macrolet ((NAME EXPANSION) ...) FORM...): make symbol macro defns.
392 Within the body FORMs, references to the variable NAME will be replaced
393 by EXPANSION, and (setq NAME ...) will act like (setf EXPANSION ...)." nil 'macro)
394
395 (autoload 'lexical-let "cl-macs" "\
396 (lexical-let BINDINGS BODY...): like `let', but lexically scoped.
397 The main visible difference is that lambdas inside BODY will create
398 lexical closures as in Common Lisp." nil 'macro)
399
400 (autoload 'lexical-let* "cl-macs" "\
401 (lexical-let* BINDINGS BODY...): like `let*', but lexically scoped.
402 The main visible difference is that lambdas inside BODY will create
403 lexical closures as in Common Lisp." nil 'macro)
404
405 (autoload 'multiple-value-bind "cl-macs" "\
406 (multiple-value-bind (SYM SYM...) FORM BODY): collect multiple return values.
407 FORM must return a list; the BODY is then executed with the first N elements
408 of this list bound (`let'-style) to each of the symbols SYM in turn.  This
409 is analogous to the Common Lisp `multiple-value-bind' macro, using lists to
410 simulate true multiple return values.  For compatibility, (values A B C) is
411 a synonym for (list A B C)." nil 'macro)
412
413 (autoload 'multiple-value-setq "cl-macs" "\
414 (multiple-value-setq (SYM SYM...) FORM): collect multiple return values.
415 FORM must return a list; the first N elements of this list are stored in
416 each of the symbols SYM in turn.  This is analogous to the Common Lisp
417 `multiple-value-setq' macro, using lists to simulate true multiple return
418 values.  For compatibility, (values A B C) is a synonym for (list A B C)." nil 'macro)
419
420 (autoload 'locally "cl-macs" nil nil 'macro)
421
422 (autoload 'the "cl-macs" nil nil 'macro)
423
424 (autoload 'declare "cl-macs" nil nil 'macro)
425
426 (autoload 'define-setf-method "cl-macs" "\
427 (define-setf-method NAME ARGLIST BODY...): define a `setf' method.
428 This method shows how to handle `setf's to places of the form (NAME ARGS...).
429 The argument forms ARGS are bound according to ARGLIST, as if NAME were
430 going to be expanded as a macro, then the BODY forms are executed and must
431 return a list of five elements: a temporary-variables list, a value-forms
432 list, a store-variables list (of length one), a store-form, and an access-
433 form.  See `defsetf' for a simpler way to define most setf-methods." nil 'macro)
434
435 (autoload 'defsetf "cl-macs" "\
436 (defsetf NAME FUNC): define a `setf' method.
437 This macro is an easy-to-use substitute for `define-setf-method' that works
438 well for simple place forms.  In the simple `defsetf' form, `setf's of
439 the form (setf (NAME ARGS...) VAL) are transformed to function or macro
440 calls of the form (FUNC ARGS... VAL).  Example: (defsetf aref aset).
441 Alternate form: (defsetf NAME ARGLIST (STORE) BODY...).
442 Here, the above `setf' call is expanded by binding the argument forms ARGS
443 according to ARGLIST, binding the value form VAL to STORE, then executing
444 BODY, which must return a Lisp form that does the necessary `setf' operation.
445 Actually, ARGLIST and STORE may be bound to temporary variables which are
446 introduced automatically to preserve proper execution order of the arguments.
447 Example: (defsetf nth (n x) (v) (list 'setcar (list 'nthcdr n x) v))." nil 'macro)
448
449 (autoload 'get-setf-method "cl-macs" "\
450 Return a list of five values describing the setf-method for PLACE.
451 PLACE may be any Lisp form which can appear as the PLACE argument to
452 a macro like `setf' or `incf'." nil nil)
453
454 (autoload 'setf "cl-macs" "\
455 (setf PLACE VAL PLACE VAL ...): set each PLACE to the value of its VAL.
456 This is a generalized version of `setq'; the PLACEs may be symbolic
457 references such as (car x) or (aref x i), as well as plain symbols.
458 For example, (setf (cadar x) y) is equivalent to (setcar (cdar x) y).
459 The return value is the last VAL in the list." nil 'macro)
460
461 (autoload 'psetf "cl-macs" "\
462 (psetf PLACE VAL PLACE VAL ...): set PLACEs to the values VALs in parallel.
463 This is like `setf', except that all VAL forms are evaluated (in order)
464 before assigning any PLACEs to the corresponding values." nil 'macro)
465
466 (autoload 'cl-do-pop "cl-macs" nil nil nil)
467
468 (autoload 'remf "cl-macs" "\
469 (remf PLACE TAG): remove TAG from property list PLACE.
470 PLACE may be a symbol, or any generalized variable allowed by `setf'.
471 The form returns true if TAG was found and removed, nil otherwise." nil 'macro)
472
473 (autoload 'shiftf "cl-macs" "\
474 (shiftf PLACE PLACE... VAL): shift left among PLACEs.
475 Example: (shiftf A B C) sets A to B, B to C, and returns the old A.
476 Each PLACE may be a symbol, or any generalized variable allowed by `setf'." nil 'macro)
477
478 (autoload 'rotatef "cl-macs" "\
479 (rotatef PLACE...): rotate left among PLACEs.
480 Example: (rotatef A B C) sets A to B, B to C, and C to A.  It returns nil.
481 Each PLACE may be a symbol, or any generalized variable allowed by `setf'." nil 'macro)
482
483 (autoload 'letf "cl-macs" "\
484 (letf ((PLACE VALUE) ...) BODY...): temporarily bind to PLACEs.
485 This is the analogue of `let', but with generalized variables (in the
486 sense of `setf') for the PLACEs.  Each PLACE is set to the corresponding
487 VALUE, then the BODY forms are executed.  On exit, either normally or
488 because of a `throw' or error, the PLACEs are set back to their original
489 values.  Note that this macro is *not* available in Common Lisp.
490 As a special case, if `(PLACE)' is used instead of `(PLACE VALUE)',
491 the PLACE is not modified before executing BODY." nil 'macro)
492
493 (autoload 'letf* "cl-macs" "\
494 (letf* ((PLACE VALUE) ...) BODY...): temporarily bind to PLACEs.
495 This is the analogue of `let*', but with generalized variables (in the
496 sense of `setf') for the PLACEs.  Each PLACE is set to the corresponding
497 VALUE, then the BODY forms are executed.  On exit, either normally or
498 because of a `throw' or error, the PLACEs are set back to their original
499 values.  Note that this macro is *not* available in Common Lisp.
500 As a special case, if `(PLACE)' is used instead of `(PLACE VALUE)',
501 the PLACE is not modified before executing BODY." nil 'macro)
502
503 (autoload 'callf "cl-macs" "\
504 (callf FUNC PLACE ARGS...): set PLACE to (FUNC PLACE ARGS...).
505 FUNC should be an unquoted function name.  PLACE may be a symbol,
506 or any generalized variable allowed by `setf'." nil 'macro)
507
508 (autoload 'callf2 "cl-macs" "\
509 (callf2 FUNC ARG1 PLACE ARGS...): set PLACE to (FUNC ARG1 PLACE ARGS...).
510 Like `callf', but PLACE is the second argument of FUNC, not the first." nil 'macro)
511
512 (autoload 'define-modify-macro "cl-macs" "\
513 (define-modify-macro NAME ARGLIST FUNC): define a `setf'-like modify macro.
514 If NAME is called, it combines its PLACE argument with the other arguments
515 from ARGLIST using FUNC: (define-modify-macro incf (&optional (n 1)) +)" nil 'macro)
516
517 (autoload 'defstruct "cl-macs" "\
518 (defstruct (NAME OPTIONS...) (SLOT SLOT-OPTS...)...): define a struct type.
519 This macro defines a new Lisp data type called NAME, which contains data
520 stored in SLOTs.  This defines a `make-NAME' constructor, a `copy-NAME'
521 copier, a `NAME-p' predicate, and setf-able `NAME-SLOT' accessors." nil 'macro)
522
523 (autoload 'cl-struct-setf-expander "cl-macs" nil nil nil)
524
525 (autoload 'deftype "cl-macs" "\
526 (deftype NAME ARGLIST BODY...): define NAME as a new data type.
527 The type name can then be used in `typecase', `check-type', etc." nil 'macro)
528
529 (autoload 'typep "cl-macs" "\
530 Check that OBJECT is of type TYPE.
531 TYPE is a Common Lisp-style type specifier." nil nil)
532
533 (autoload 'check-type "cl-macs" "\
534 Verify that PLACE is of type TYPE; signal a continuable error if not.
535 STRING is an optional description of the desired type." nil 'macro)
536
537 (autoload 'assert "cl-macs" "\
538 Verify that FORM returns non-nil; signal an error if not.
539 Second arg SHOW-ARGS means to include arguments of FORM in message.
540 Other args STRING and ARGS... are arguments to be passed to `error'.
541 They are not evaluated unless the assertion fails.  If STRING is
542 omitted, a default message listing FORM itself is used." nil 'macro)
543
544 (autoload 'ignore-errors "cl-macs" "\
545 Execute FORMS; if an error occurs, return nil.
546 Otherwise, return result of last FORM." nil 'macro)
547
548 (autoload 'ignore-file-errors "cl-macs" "\
549 Execute FORMS; if an error of type `file-error' occurs, return nil.
550 Otherwise, return result of last FORM." nil 'macro)
551
552 (autoload 'define-compiler-macro "cl-macs" "\
553 (define-compiler-macro FUNC ARGLIST BODY...): Define a compiler-only macro.
554 This is like `defmacro', but macro expansion occurs only if the call to
555 FUNC is compiled (i.e., not interpreted).  Compiler macros should be used
556 for optimizing the way calls to FUNC are compiled; the form returned by
557 BODY should do the same thing as a call to the normal function called
558 FUNC, though possibly more efficiently.  Note that, like regular macros,
559 compiler macros are expanded repeatedly until no further expansions are
560 possible.  Unlike regular macros, BODY can decide to \"punt\" and leave the
561 original function call alone by declaring an initial `&whole foo' parameter
562 and then returning foo." nil 'macro)
563
564 (autoload 'compiler-macroexpand "cl-macs" nil nil nil)
565
566 ;;;***
567 \f
568 ;;;### (autoloads (config-value config-value-hash-table) "config" "lisp/config.el")
569
570 (autoload 'config-value-hash-table "config" "\
571 Return hash table of configuration parameters and their values." nil nil)
572
573 (autoload 'config-value "config" "\
574 Return the value of the configuration parameter CONFIG_SYMBOL." nil nil)
575
576 ;;;***
577 \f
578 ;;;### (autoloads (Custom-make-dependencies) "cus-dep" "lisp/cus-dep.el")
579
580 (autoload 'Custom-make-dependencies "cus-dep" "\
581 Extract custom dependencies from .el files in SUBDIRS.
582 SUBDIRS is a list of directories.  If it is nil, the command-line
583 arguments are used.  If it is a string, only that directory is
584 processed.  This function is especially useful in batch mode.
585
586 Batch usage: xemacs -batch -l cus-dep.el -f Custom-make-dependencies DIRS" t nil)
587
588 ;;;***
589 \f
590 ;;;### (autoloads (custom-migrate-custom-file 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-changed-options customize-variable customize-other-window customize customize-save-variable customize-set-variable customize-set-value) "cus-edit" "lisp/cus-edit.el")
591
592 (autoload 'customize-set-value "cus-edit" "\
593 Set VARIABLE to VALUE.  VALUE is a Lisp object.
594
595 If VARIABLE has a `variable-interactive' property, that is used as if
596 it were the arg to `interactive' (which see) to interactively read the value.
597
598 If VARIABLE has a `custom-type' property, it must be a widget and the
599 `:prompt-value' property of that widget will be used for reading the value.
600
601 If given a prefix (or a COMMENT argument), also prompt for a comment." t nil)
602
603 (autoload 'customize-set-variable "cus-edit" "\
604 Set the default for VARIABLE to VALUE.  VALUE is any Lisp object.
605
606 If VARIABLE has a `custom-set' property, that is used for setting
607 VARIABLE, otherwise `set-default' is used.
608
609 The `customized-value' property of the VARIABLE will be set to a list
610 with a quoted VALUE as its sole list member.
611
612 If VARIABLE has a `variable-interactive' property, that is used as if
613 it were the arg to `interactive' (which see) to interactively read the value.
614
615 If VARIABLE has a `custom-type' property, it must be a widget and the
616 `:prompt-value' property of that widget will be used for reading the value.
617
618 If given a prefix (or a COMMENT argument), also prompt for a comment." t nil)
619
620 (autoload 'customize-save-variable "cus-edit" "\
621 Set the default for VARIABLE to VALUE, and save it for future sessions.
622 If VARIABLE has a `custom-set' property, that is used for setting
623 VARIABLE, otherwise `set-default' is used.
624
625 The `customized-value' property of the VARIABLE will be set to a list
626 with a quoted VALUE as its sole list member.
627
628 If VARIABLE has a `variable-interactive' property, that is used as if
629 it were the arg to `interactive' (which see) to interactively read the value.
630
631 If VARIABLE has a `custom-type' property, it must be a widget and the
632 `:prompt-value' property of that widget will be used for reading the value.
633
634 If given a prefix (or a COMMENT argument), also prompt for a comment." t nil)
635
636 (autoload 'customize "cus-edit" "\
637 Select a customization buffer which you can use to set user options.
638 User options are structured into \"groups\".
639 The default group is `Emacs'." t nil)
640
641 (defalias 'customize-group 'customize)
642
643 (autoload 'customize-other-window "cus-edit" "\
644 Customize SYMBOL, which must be a customization group." t nil)
645
646 (defalias 'customize-group-other-window 'customize-other-window)
647
648 (defalias 'customize-option 'customize-variable)
649
650 (autoload 'customize-variable "cus-edit" "\
651 Customize SYMBOL, which must be a user option variable." t nil)
652
653 (autoload 'customize-changed-options "cus-edit" "\
654 Customize all user option variables whose default values changed recently.
655 This means, in other words, variables defined with a `:version' keyword." t nil)
656
657 (defalias 'customize-variable-other-window 'customize-option-other-window)
658
659 (autoload 'customize-option-other-window "cus-edit" "\
660 Customize SYMBOL, which must be a user option variable.
661 Show the buffer in another window, but don't select it." t nil)
662
663 (autoload 'customize-face "cus-edit" "\
664 Customize SYMBOL, which should be a face name or nil.
665 If SYMBOL is nil, customize all faces." t nil)
666
667 (autoload 'customize-face-other-window "cus-edit" "\
668 Show customization buffer for FACE in other window." t nil)
669
670 (autoload 'customize-customized "cus-edit" "\
671 Customize all user options set since the last save in this session." t nil)
672
673 (autoload 'customize-saved "cus-edit" "\
674 Customize all already saved user options." t nil)
675
676 (autoload 'customize-apropos "cus-edit" "\
677 Customize all user options matching REGEXP.
678 If ALL is `options', include only options.
679 If ALL is `faces', include only faces.
680 If ALL is `groups', include only groups.
681 If ALL is t (interactively, with prefix arg), include options which are not
682 user-settable, as well as faces and groups." t nil)
683
684 (autoload 'customize-apropos-options "cus-edit" "\
685 Customize all user options matching REGEXP.
686 With prefix arg, include options which are not user-settable." t nil)
687
688 (autoload 'customize-apropos-faces "cus-edit" "\
689 Customize all user faces matching REGEXP." t nil)
690
691 (autoload 'customize-apropos-groups "cus-edit" "\
692 Customize all user groups matching REGEXP." t nil)
693
694 (autoload 'custom-buffer-create "cus-edit" "\
695 Create a buffer containing OPTIONS.
696 Optional NAME is the name of the buffer.
697 OPTIONS should be an alist of the form ((SYMBOL WIDGET)...), where
698 SYMBOL is a customization option, and WIDGET is a widget for editing
699 that option." nil nil)
700
701 (autoload 'custom-buffer-create-other-window "cus-edit" "\
702 Create a buffer containing OPTIONS.
703 Optional NAME is the name of the buffer.
704 OPTIONS should be an alist of the form ((SYMBOL WIDGET)...), where
705 SYMBOL is a customization option, and WIDGET is a widget for editing
706 that option." nil nil)
707
708 (autoload 'customize-browse "cus-edit" "\
709 Create a tree browser for the customize hierarchy." t nil)
710
711 (autoload 'customize-save-customized "cus-edit" "\
712 Save all user options which have been set in this session." t nil)
713
714 (autoload 'custom-save-all "cus-edit" "\
715 Save all customizations in `custom-file'." nil nil)
716
717 (autoload 'custom-menu-create "cus-edit" "\
718 Create menu for customization group SYMBOL.
719 The menu is in a format applicable to `easy-menu-define'." nil nil)
720
721 (autoload 'customize-menu-create "cus-edit" "\
722 Return a customize menu for customization group SYMBOL.
723 If optional NAME is given, use that as the name of the menu.
724 Otherwise the menu will be named `Customize'.
725 The format is suitable for use with `easy-menu-define'." nil nil)
726
727 (autoload 'custom-migrate-custom-file "cus-edit" "\
728 Migrate custom file from home directory." nil nil)
729
730 ;;;***
731 \f
732 ;;;### (autoloads (custom-reset-faces custom-theme-reset-faces custom-theme-face-value custom-theme-set-faces custom-set-faces custom-set-face-update-spec custom-declare-face) "cus-face" "lisp/cus-face.el")
733
734 (autoload 'custom-declare-face "cus-face" "\
735 Like `defface', but FACE is evaluated as a normal argument." nil nil)
736
737 (autoload 'custom-set-face-update-spec "cus-face" "\
738 Customize the FACE for display types matching DISPLAY, merging
739   in the new items from PLIST." nil nil)
740
741 (autoload 'custom-set-faces "cus-face" "\
742 Initialize faces according to user preferences.
743 This asociates the setting with the USER theme.
744 The arguments should be a list where each entry has the form:
745
746   (FACE SPEC [NOW [COMMENT]])
747
748 SPEC will be stored as the saved value for FACE.  If NOW is present
749 and non-nil, FACE will also be created according to SPEC.
750 COMMENT is a string comment about FACE.
751
752 See `defface' for the format of SPEC." nil nil)
753
754 (autoload 'custom-theme-set-faces "cus-face" "\
755 Initialize faces according to settings specified by args.
756 Records the settings as belonging to THEME.
757
758 See `custom-set-faces' for a description of the arguments ARGS." nil nil)
759
760 (autoload 'custom-theme-face-value "cus-face" "\
761 Return spec of FACE in THEME if the THEME modifies the
762 FACE.  Nil otherwise." nil nil)
763
764 (autoload 'custom-theme-reset-faces "cus-face" nil nil nil)
765
766 (autoload 'custom-reset-faces "cus-face" "\
767 Reset the value of the face to values previously defined.
768 Associate this setting with the 'user' theme.
769
770 ARGS is defined as for `custom-theme-reset-faces'." nil nil)
771
772 ;;;***
773 \f
774 ;;;### (autoloads (make-custom-file-name) "cus-file" "lisp/cus-file.el")
775
776 (defconst custom-file-base "custom.el" "\
777 Base of file name for storing customization information.")
778
779 (defvar custom-file nil "\
780 File used for storing customization information.
781 If you change this from the default you need to
782 explicitly load that file for the settings to take effect.")
783
784 (autoload 'make-custom-file-name "cus-file" "\
785 Construct the default custom file name from the init file name.
786 If FORCE-NEW is non-nil, force post-migration location." nil nil)
787
788 ;;;***
789 \f
790 ;;;### (autoloads (disassemble) "disass" "lisp/disass.el")
791
792 (autoload 'disassemble "disass" "\
793 Print disassembled code for OBJECT in (optional) BUFFER.
794 OBJECT can be a symbol defined as a function, or a function itself
795 \(a lambda expression or a compiled-function object).
796 If OBJECT is not already compiled, we compile it, but do not
797 redefine OBJECT if it is a symbol." t nil)
798
799 ;;;***
800 \f
801 ;;;### (autoloads (standard-display-european standard-display-underline standard-display-graphic standard-display-g1 standard-display-ascii standard-display-default standard-display-8bit make-display-table describe-current-display-table) "disp-table" "lisp/disp-table.el")
802
803 (autoload 'describe-current-display-table "disp-table" "\
804 Describe the display table in use in the selected window and buffer." t nil)
805
806 (autoload 'make-display-table "disp-table" "\
807 Return a new, empty display table." nil nil)
808
809 (autoload 'standard-display-8bit "disp-table" "\
810 Display characters in the range L to H literally." nil nil)
811
812 (autoload 'standard-display-default "disp-table" "\
813 Display characters in the range L to H using the default notation." nil nil)
814
815 (autoload 'standard-display-ascii "disp-table" "\
816 Display character C using printable string S." nil nil)
817
818 (autoload 'standard-display-g1 "disp-table" "\
819 Display character C as character SC in the g1 character set.
820 This function assumes that your terminal uses the SO/SI characters;
821 it is meaningless for an X frame." nil nil)
822
823 (autoload 'standard-display-graphic "disp-table" "\
824 Display character C as character GC in graphics character set.
825 This function assumes VT100-compatible escapes; it is meaningless for an
826 X frame." nil nil)
827
828 (autoload 'standard-display-underline "disp-table" "\
829 Display character C as character UC plus underlining." nil nil)
830
831 (autoload 'standard-display-european "disp-table" "\
832 Toggle display of European characters encoded with ISO 8859.
833 When enabled, characters in the range of 160 to 255 display not
834 as octal escapes, but as accented characters.
835 With prefix argument, enable European character display iff arg is positive." t nil)
836
837 ;;;***
838 \f
839 ;;;### (autoloads nil "easymenu" "lisp/easymenu.el")
840
841 ;;;***
842 \f
843 ;;;### (autoloads (pop-tag-mark tags-apropos list-tags tags-query-replace tags-search tags-loop-continue next-file tag-complete-symbol find-tag-other-window find-tag find-tag-at-point visit-tags-table) "etags" "lisp/etags.el")
844
845 (autoload 'visit-tags-table "etags" "\
846 Tell tags commands to use tags table file FILE when all else fails.
847 FILE should be the name of a file created with the `etags' program.
848 A directory name is ok too; it means file TAGS in that directory." t nil)
849
850 (autoload 'find-tag-at-point "etags" "\
851 *Find tag whose name contains TAGNAME.
852 Identical to `find-tag' but does not prompt for tag when called interactively;
853 instead, uses tag around or before point." t nil)
854
855 (autoload 'find-tag "etags" "\
856 *Find tag whose name contains TAGNAME.
857  Selects the buffer that the tag is contained in
858 and puts point at its definition.
859  If TAGNAME is a null string, the expression in the buffer
860 around or before point is used as the tag name.
861  If called interactively with a numeric argument, searches for the next tag
862 in the tag table that matches the tagname used in the previous find-tag.
863  If second arg OTHER-WINDOW is non-nil, uses another window to display
864 the tag.
865
866 This version of this function supports multiple active tags tables,
867 and completion. See also the commands `\\[push-tag-mark]' and
868 `\\[pop-tag-mark]'.
869
870 Variables of note:
871
872   tag-table-alist               controls which tables apply to which buffers
873   tags-file-name                a default tags table
874   tags-build-completion-table   controls completion behavior
875   buffer-tag-table              another way of specifying a buffer-local table
876   make-tags-files-invisible     whether tags tables should be very hidden
877   tag-mark-stack-max            how many tags-based hops to remember" t nil)
878
879 (autoload 'find-tag-other-window "etags" "\
880 *Find tag whose name contains TAGNAME, in another window.
881  Selects the buffer that the tag is contained in in another window
882 and puts point at its definition.
883  If TAGNAME is a null string, the expression in the buffer
884 around or before point is used as the tag name.
885  If second arg NEXT is non-nil (interactively, with prefix arg),
886 searches for the next tag in the tag table
887 that matches the tagname used in the previous find-tag.
888
889 This version of this function supports multiple active tags tables,
890 and completion.
891
892 Variables of note:
893
894   tag-table-alist               controls which tables apply to which buffers
895   tags-file-name                a default tags table
896   tags-build-completion-table   controls completion behavior
897   buffer-tag-table              another way of specifying a buffer-local table
898   make-tags-files-invisible     whether tags tables should be very hidden
899   tag-mark-stack-max            how many tags-based hops to remember" t nil)
900
901 (autoload 'tag-complete-symbol "etags" "\
902 The function used to do tags-completion (using 'tag-completion-predicate)." t nil)
903
904 (autoload 'next-file "etags" "\
905 Select next file among files in current tag table(s).
906
907 A first argument of t (prefix arg, if interactive) initializes to the
908 beginning of the list of files in the (first) tags table.  If the argument
909 is neither nil nor t, it is evalled to initialize the list of files.
910
911 Non-nil second argument NOVISIT means use a temporary buffer
912 to save time and avoid uninteresting warnings.
913
914 Value is nil if the file was already visited;
915 if the file was newly read in, the value is the filename." t nil)
916
917 (autoload 'tags-loop-continue "etags" "\
918 Continue last \\[tags-search] or \\[tags-query-replace] command.
919 Used noninteractively with non-nil argument to begin such a command (the
920 argument is passed to `next-file', which see).
921 Two variables control the processing we do on each file:
922 the value of `tags-loop-scan' is a form to be executed on each file
923 to see if it is interesting (it returns non-nil if so)
924 and `tags-loop-operate' is a form to execute to operate on an interesting file
925 If the latter returns non-nil, we exit; otherwise we scan the next file." t nil)
926
927 (autoload 'tags-search "etags" "\
928 Search through all files listed in tags table for match for REGEXP.
929 Stops when a match is found.
930 To continue searching for next match, use command \\[tags-loop-continue].
931
932 See documentation of variable `tag-table-alist'." t nil)
933
934 (autoload 'tags-query-replace "etags" "\
935 Query-replace-regexp FROM with TO through all files listed in tags table.
936 Third arg DELIMITED (prefix arg) means replace only word-delimited matches.
937 If you exit (\\[keyboard-quit] or ESC), you can resume the query-replace
938 with the command \\[tags-loop-continue].
939
940 See documentation of variable `tag-table-alist'." t nil)
941
942 (autoload 'list-tags "etags" "\
943 Display list of tags in FILE." t nil)
944
945 (autoload 'tags-apropos "etags" "\
946 Display list of all tags in tag table REGEXP matches." t nil)
947 (define-key esc-map "*" 'pop-tag-mark)
948
949 (autoload 'pop-tag-mark "etags" "\
950 Go to last tag position.
951 `find-tag' maintains a mark-stack seperate from the \\[set-mark-command] mark-stack.
952 This function pops (and moves to) the tag at the top of this stack." t nil)
953
954 ;;;***
955 \f
956 ;;;### (autoloads (finder-by-keyword finder-commentary) "finder" "lisp/finder.el")
957
958 (autoload 'finder-commentary "finder" "\
959 Display FILE's commentary section.
960 FILE should be in a form suitable for passing to `locate-library'." t nil)
961
962 (autoload 'finder-by-keyword "finder" "\
963 Find packages matching a given keyword." t nil)
964
965 ;;;***
966 \f
967 ;;;### (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")
968
969 (defcustom font-lock-auto-fontify t "*Whether font-lock should automatically fontify files as they're loaded.\nThis will only happen if font-lock has fontifying keywords for the major\nmode of the file.  You can get finer-grained control over auto-fontification\nby using this variable in combination with `font-lock-mode-enable-list' or\n`font-lock-mode-disable-list'." :type 'boolean :group 'font-lock)
970
971 (defcustom font-lock-mode-enable-list nil "*List of modes to auto-fontify, if `font-lock-auto-fontify' is nil." :type '(repeat (symbol :tag "Mode")) :group 'font-lock)
972
973 (defcustom font-lock-mode-disable-list nil "*List of modes not to auto-fontify, if `font-lock-auto-fontify' is t." :type '(repeat (symbol :tag "Mode")) :group 'font-lock)
974
975 (defcustom font-lock-use-colors '(color) "*Specification for when Font Lock will set up color defaults.\nNormally this should be '(color), meaning that Font Lock will set up\ncolor defaults that are only used on color displays.  Set this to nil\nif you don't want Font Lock to set up color defaults at all.  This\nshould be one of\n\n-- a list of valid tags, meaning that the color defaults will be used\n   when all of the tags apply. (e.g. '(color x))\n-- a list whose first element is 'or and whose remaining elements are\n   lists of valid tags, meaning that the defaults will be used when\n   any of the tag lists apply.\n-- nil, meaning that the defaults should not be set up at all.\n\n(If you specify face values in your init file, they will override any\nthat Font Lock specifies, regardless of whether you specify the face\nvalues before or after loading Font Lock.)\n\nSee also `font-lock-use-fonts'.  If you want more control over the faces\nused for fontification, see the documentation of `font-lock-mode' for\nhow to do it." :type 'sexp :group 'font-lock)
976
977 (defcustom font-lock-use-fonts '(or (mono) (grayscale)) "*Specification for when Font Lock will set up non-color defaults.\n\nNormally this should be '(or (mono) (grayscale)), meaning that Font\nLock will set up non-color defaults that are only used on either mono\nor grayscale displays.  Set this to nil if you don't want Font Lock to\nset up non-color defaults at all.  This should be one of\n\n-- a list of valid tags, meaning that the non-color defaults will be used\n   when all of the tags apply. (e.g. '(grayscale x))\n-- a list whose first element is 'or and whose remaining elements are\n   lists of valid tags, meaning that the defaults will be used when\n   any of the tag lists apply.\n-- nil, meaning that the defaults should not be set up at all.\n\n(If you specify face values in your init file, they will override any\nthat Font Lock specifies, regardless of whether you specify the face\nvalues before or after loading Font Lock.)\n\nSee also `font-lock-use-colors'.  If you want more control over the faces\nused for fontification, see the documentation of `font-lock-mode' for\nhow to do it." :type 'sexp :group 'font-lock)
978
979 (defcustom font-lock-maximum-decoration t "*If non-nil, the maximum decoration level for fontifying.\nIf nil, use the minimum decoration (equivalent to level 0).\nIf t, use the maximum decoration available.\nIf a number, use that level of decoration (or if not available the maximum).\nIf a list, each element should be a cons pair of the form (MAJOR-MODE . LEVEL),\nwhere MAJOR-MODE is a symbol or t (meaning the default).  For example:\n ((c++-mode . 2) (c-mode . t) (t . 1))\nmeans use level 2 decoration for buffers in `c++-mode', the maximum decoration\navailable for buffers in `c-mode', and level 1 decoration otherwise." :type '(choice (const :tag "default" nil) (const :tag "maximum" t) (integer :tag "level" 1) (repeat :menu-tag "mode specific" :tag "mode specific" :value ((t . t)) (cons :tag "Instance" (radio :tag "Mode" (const :tag "all" t) (symbol :tag "name")) (radio :tag "Decoration" (const :tag "default" nil) (const :tag "maximum" t) (integer :tag "level" 1))))) :group 'font-lock)
980
981 (define-obsolete-variable-alias 'font-lock-use-maximal-decoration 'font-lock-maximum-decoration)
982
983 (defcustom font-lock-maximum-size (* 250 1024) "*If non-nil, the maximum size for buffers for fontifying.\nOnly buffers less than this can be fontified when Font Lock mode is turned on.\nIf nil, means size is irrelevant.\nIf a list, each element should be a cons pair of the form (MAJOR-MODE . SIZE),\nwhere MAJOR-MODE is a symbol or t (meaning the default).  For example:\n ((c++-mode . 256000) (c-mode . 256000) (rmail-mode . 1048576))\nmeans that the maximum size is 250K for buffers in `c++-mode' or `c-mode', one\nmegabyte for buffers in `rmail-mode', and size is irrelevant otherwise." :type '(choice (const :tag "none" nil) (integer :tag "size") (repeat :menu-tag "mode specific" :tag "mode specific" :value ((t)) (cons :tag "Instance" (radio :tag "Mode" (const :tag "all" t) (symbol :tag "name")) (radio :tag "Size" (const :tag "none" nil) (integer :tag "size"))))) :group 'font-lock)
984
985 (defcustom font-lock-fontify-string-delimiters nil "*If non-nil, apply font-lock-string-face to string delimiters as well as\nstring text when fontifying." :type 'boolean :group 'font-lock)
986
987 (defvar font-lock-keywords nil "\
988 A list defining the keywords for `font-lock-mode' to highlight.
989
990  FONT-LOCK-KEYWORDS := List of FONT-LOCK-FORM's.
991
992  FONT-LOCK-FORM     :== MATCHER
993                       | (MATCHER . MATCH)
994                       | (MATCHER . FACE-FORM)
995                       | (MATCHER . HIGHLIGHT)
996                       | (MATCHER HIGHLIGHT ...)
997                       | (eval . FORM)
998
999  MATCHER            :== A string containing a regexp.
1000                       | A variable containing a regexp to search for.
1001                       | A function to call to make the search.
1002                         It is called with one arg, the limit of the search,
1003                         and should leave MATCH results in the XEmacs global
1004                         match data.
1005
1006  MATCH              :== An integer match subexpression number from MATCHER.
1007
1008  FACE-FORM           :== The symbol naming a defined face.
1009                       | Expression whos value is the face name to use.  If you
1010                         want FACE-FORM to be a symbol that evaluates to a face,
1011                         use a form like \"(progn sym)\".
1012
1013  HIGHLIGHT          :== MATCH-HIGHLIGHT
1014                       | MATCH-ANCHORED
1015
1016  FORM               :== Expression returning a FONT-LOCK-FORM, evaluated when
1017                         the FONT-LOCK-FORM is first used in a buffer.  This
1018                         feature can be used to provide a FONT-LOCK-FORM that
1019                         can only be generated when Font Lock mode is actually
1020                         turned on.
1021
1022  MATCH-HIGHLIGHT    :== (MATCH FACE-FORM OVERRIDE LAXMATCH)
1023
1024  OVERRIDE           :== t        - overwrite existing fontification
1025                       | 'keep    - only parts not already fontified are
1026                                    highlighted.
1027                       | 'prepend - merge faces, this fontification has
1028                                    precedence over existing
1029                       | 'append  - merge faces, existing fontification has
1030                                    precedence over
1031                                    this face.
1032
1033  LAXMATCH           :== If non-nil, no error is signalled if there is no MATCH
1034                         in MATCHER.
1035
1036  MATCH-ANCHORED     :== (ANCHOR-MATCHER PRE-MATCH-FORM \\
1037                                           POST-MATCH-FORM MATCH-HIGHLIGHT ...)
1038
1039  ANCHOR-MATCHER     :== Like a MATCHER, except that the limit of the search
1040                         defaults to the end of the line after PRE-MATCH-FORM
1041                         is evaluated.  However, if PRE-MATCH-FORM returns a
1042                         position greater than the end of the line, that
1043                         position is used as the limit of the search.  It is
1044                         generally a bad idea to return a position greater than
1045                         the end of the line, i.e., cause the ANCHOR-MATCHER
1046                         search to span lines.
1047
1048  PRE-MATCH-FORM     :== Evaluated before the ANCHOR-MATCHER is used, therefore
1049                         can be used to initialize before, ANCHOR-MATCHER is
1050                         used.  Typically, PRE-MATCH-FORM is used to move to
1051                         some position relative to the original MATCHER, before
1052                         starting with the ANCHOR-MATCHER.
1053
1054  POST-MATCH-FORM    :== Like PRE-MATCH-FORM, but used to clean up after the
1055                         ANCHOR-MATCHER.  It might be used to move, before
1056                         resuming with MATCH-ANCHORED's parent's MATCHER.
1057
1058 For example, an element of the first form highlights (if not already highlighted):
1059
1060   \"\\\\\\=<foo\\\\\\=>\"                    Discrete occurrences of \"foo\" in the value
1061                                  of the variable `font-lock-keyword-face'.
1062
1063   (\"fu\\\\(bar\\\\)\" . 1)            Substring \"bar\" within all occurrences of
1064                                  \"fubar\" in the value of
1065                                  `font-lock-keyword-face'.
1066
1067   (\"fubar\" . fubar-face)         Occurrences of \"fubar\" in the value of
1068                                  `fubar-face'.
1069
1070   (\"foo\\\\|bar\" 0 foo-bar-face t) Occurrences of either \"foo\" or \"bar\" in the
1071                                  value of `foo-bar-face', even if already
1072                                  highlighted.
1073
1074   (fubar-match 1 fubar-face)     The first subexpression within all
1075                                  occurrences of whatever the function
1076                                  `fubar-match' finds and matches in the value
1077                                  of `fubar-face'.
1078
1079   (\"\\\\\\=<anchor\\\\\\=>\" (0 anchor-face) (\"\\\\\\=<item\\\\\\=>\" nil nil (0 item-face)))
1080    -------------- ---------------  ------------ --- --- -------------
1081        |            |               |            |   |          |
1082    MATCHER          |         ANCHOR-MATCHER     |   +------+ MATCH-HIGHLIGHT
1083              MATCH-HIGHLIGHT                 PRE-MATCH-FORM |
1084                                                            POST-MATCH-FORM
1085
1086   Discrete occurrences of \"anchor\" in the value of `anchor-face', and
1087   subsequent discrete occurrences of \"item\" (on the same line) in the value
1088   of `item-face'.  (Here PRE-MATCH-FORM and POST-MATCH-FORM are nil.
1089   Therefore \"item\" is initially searched for starting from the end of the
1090   match of \"anchor\", and searching for subsequent instance of \"anchor\"
1091   resumes from where searching for \"item\" concluded.)
1092
1093 For highlighting single items, typically only MATCH-HIGHLIGHT is required.
1094 However, if an item or (typically) several items are to be highlighted
1095 following the instance of another item (the anchor) then MATCH-ANCHORED may be
1096 required.
1097
1098 These regular expressions should not match text which spans lines.  While
1099 \\[font-lock-fontify-buffer] handles multi-line patterns correctly, updating when you
1100 edit the buffer does not, since it considers text one line at a time.
1101
1102 Be very careful composing regexps for this list; the wrong pattern can
1103 dramatically slow things down!
1104 ")
1105
1106 (make-variable-buffer-local 'font-lock-keywords)
1107
1108 (defvar font-lock-syntactic-keywords nil "\
1109 A list of the syntactic keywords to highlight.
1110 Can be the list or the name of a function or variable whose value is the list.
1111 See `font-lock-keywords' for a description of the form of this list;
1112 the differences are listed below.  MATCH-HIGHLIGHT should be of the form:
1113
1114  (MATCH SYNTAX OVERRIDE LAXMATCH)
1115
1116 where SYNTAX can be of the form (SYNTAX-CODE . MATCHING-CHAR), the name of a
1117 syntax table, or an expression whose value is such a form or a syntax table.
1118 OVERRIDE cannot be `prepend' or `append'.
1119
1120 For example, an element of the form highlights syntactically:
1121
1122  (\"\\\\$\\\\(#\\\\)\" 1 (1 . nil))
1123
1124  a hash character when following a dollar character, with a SYNTAX-CODE of
1125  1 (meaning punctuation syntax).  Assuming that the buffer syntax table does
1126  specify hash characters to have comment start syntax, the element will only
1127  highlight hash characters that do not follow dollar characters as comments
1128  syntactically.
1129
1130  (\"\\\\('\\\\).\\\\('\\\\)\"
1131   (1 (7 . ?'))
1132   (2 (7 . ?')))
1133
1134  both single quotes which surround a single character, with a SYNTAX-CODE of
1135  7 (meaning string quote syntax) and a MATCHING-CHAR of a single quote (meaning
1136  a single quote matches a single quote).  Assuming that the buffer syntax table
1137  does not specify single quotes to have quote syntax, the element will only
1138  highlight single quotes of the form 'c' as strings syntactically.
1139  Other forms, such as foo'bar or 'fubar', will not be highlighted as strings.
1140
1141 This is normally set via `font-lock-defaults'.")
1142
1143 (make-variable-buffer-local 'font-lock-syntactic-keywords)
1144
1145 (defcustom font-lock-mode nil "Non nil means `font-lock-mode' is on" :group 'font-lock :type 'boolean :initialize 'custom-initialize-default :require 'font-lock :set (function (lambda (var val) (font-lock-mode (or val 0)))))
1146
1147 (defvar font-lock-mode-hook nil "\
1148 Function or functions to run on entry to font-lock-mode.")
1149
1150 (autoload 'font-lock-mode "font-lock" "\
1151 Toggle Font Lock Mode.
1152 With arg, turn font-lock mode on if and only if arg is positive.
1153
1154 When Font Lock mode is enabled, text is fontified as you type it:
1155
1156  - Comments are displayed in `font-lock-comment-face';
1157  - Strings are displayed in `font-lock-string-face';
1158  - Documentation strings (in Lisp-like languages) are displayed in
1159    `font-lock-doc-string-face';
1160  - Language keywords (\"reserved words\") are displayed in
1161    `font-lock-keyword-face';
1162  - Function names in their defining form are displayed in
1163    `font-lock-function-name-face';
1164  - Variable names in their defining form are displayed in
1165    `font-lock-variable-name-face';
1166  - Type names are displayed in `font-lock-type-face';
1167  - References appearing in help files and the like are displayed
1168    in `font-lock-reference-face';
1169  - Preprocessor declarations are displayed in
1170   `font-lock-preprocessor-face';
1171
1172    and
1173
1174  - Certain other expressions are displayed in other faces according
1175    to the value of the variable `font-lock-keywords'.
1176
1177 Where modes support different levels of fontification, you can use the variable
1178 `font-lock-maximum-decoration' to specify which level you generally prefer.
1179 When you turn Font Lock mode on/off the buffer is fontified/defontified, though
1180 fontification occurs only if the buffer is less than `font-lock-maximum-size'.
1181 To fontify a buffer without turning on Font Lock mode, and regardless of buffer
1182 size, you can use \\[font-lock-fontify-buffer].
1183
1184 See the variable `font-lock-keywords' for customization." t nil)
1185
1186 (autoload 'turn-on-font-lock "font-lock" "\
1187 Unconditionally turn on Font Lock mode." t nil)
1188
1189 (autoload 'turn-off-font-lock "font-lock" "\
1190 Unconditionally turn off Font Lock mode." t nil)
1191
1192 (autoload 'font-lock-fontify-buffer "font-lock" "\
1193 Fontify the current buffer the way `font-lock-mode' would.
1194 See `font-lock-mode' for details.
1195
1196 This can take a while for large buffers." t nil)
1197
1198 (autoload 'font-lock-set-defaults-1 "font-lock" nil nil nil)
1199
1200 (add-minor-mode 'font-lock-mode " Font")
1201
1202 ;;;***
1203 \f
1204 ;;;### (autoloads (font-menu-weight-constructor font-menu-size-constructor font-menu-family-constructor reset-device-font-menus) "font-menu" "lisp/font-menu.el")
1205
1206 (defcustom font-menu-ignore-scaled-fonts nil "*If non-nil, then the font menu will try to show only bitmap fonts." :type 'boolean :group 'font-menu)
1207
1208 (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 'font-menu)
1209
1210 (fset 'install-font-menus 'reset-device-font-menus)
1211
1212 (autoload 'reset-device-font-menus "font-menu" "\
1213 Generates the `Font', `Size', and `Weight' submenus for the Options menu.
1214 This is run the first time that a font-menu is needed for each device.
1215 If you don't like the lazy invocation of this function, you can add it to
1216 `create-device-hook' and that will make the font menus respond more quickly
1217 when they are selected for the first time.  If you add fonts to your system,
1218 or if you change your font path, you can call this to re-initialize the menus." nil nil)
1219
1220 (autoload 'font-menu-family-constructor "font-menu" nil nil nil)
1221
1222 (autoload 'font-menu-size-constructor "font-menu" nil nil nil)
1223
1224 (autoload 'font-menu-weight-constructor "font-menu" nil nil nil)
1225
1226 ;;;***
1227 \f
1228 ;;;### (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")
1229
1230 (autoload 'font-create-object "font" "\
1231 Return a font descriptor object for FONTNAME, appropriate for DEVICE." nil nil)
1232
1233 (autoload 'font-default-font-for-device "font" nil nil nil)
1234
1235 (autoload 'font-default-object-for-device "font" nil nil nil)
1236
1237 (autoload 'font-default-family-for-device "font" nil nil nil)
1238
1239 (autoload 'font-default-registry-for-device "font" nil nil nil)
1240
1241 (autoload 'font-default-encoding-for-device "font" nil nil nil)
1242
1243 (autoload 'font-default-size-for-device "font" nil nil nil)
1244
1245 (autoload 'x-font-build-cache "font" nil nil nil)
1246
1247 ;;;***
1248 \f
1249 ;;;### (autoloads (gnuserv-start gnuserv-running-p) "gnuserv" "lisp/gnuserv.el")
1250
1251 (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)
1252
1253 (autoload 'gnuserv-running-p "gnuserv" "\
1254 Return non-nil if a gnuserv process is running from this XEmacs session." nil nil)
1255
1256 (autoload 'gnuserv-start "gnuserv" "\
1257 Allow this Emacs process to be a server for client processes.
1258 This starts a gnuserv communications subprocess through which
1259 client \"editors\" (gnuclient and gnudoit) can send editing commands to
1260 this Emacs job.  See the gnuserv(1) manual page for more details.
1261
1262 Prefix arg means just kill any existing server communications subprocess." t nil)
1263
1264 ;;;***
1265 \f
1266 ;;;### (autoloads (gtk-reset-device-font-menus) "gtk-font-menu" "lisp/gtk-font-menu.el")
1267
1268 (autoload 'gtk-reset-device-font-menus "gtk-font-menu" "\
1269 Generates the `Font', `Size', and `Weight' submenus for the Options menu.
1270 This is run the first time that a font-menu is needed for each device.
1271 If you don't like the lazy invocation of this function, you can add it to
1272 `create-device-hook' and that will make the font menus respond more quickly
1273 when they are selected for the first time.  If you add fonts to your system, 
1274 or if you change your font path, you can call this to re-initialize the menus." nil nil)
1275
1276 (defun* gtk-font-menu-font-data (face dcache) (defvar gtk-font-regexp) (defvar gtk-font-regexp-foundry-and-family) (let* ((case-fold-search t) (domain (if font-menu-this-frame-only-p (selected-frame) (selected-device))) (name (font-instance-name (face-font-instance face domain))) (truename (font-instance-truename (face-font-instance face domain (if (featurep 'mule) 'ascii)))) family size weight entry slant) (when (string-match gtk-font-regexp-foundry-and-family name) (setq family (capitalize (match-string 1 name))) (setq entry (vassoc family (aref dcache 0)))) (when (and (null entry) (string-match gtk-font-regexp-foundry-and-family truename)) (setq family (capitalize (match-string 1 truename))) (setq entry (vassoc family (aref dcache 0)))) (when (null entry) (return-from gtk-font-menu-font-data (make-vector 5 nil))) (when (string-match gtk-font-regexp name) (setq weight (capitalize (match-string 1 name))) (setq size (string-to-int (match-string 6 name)))) (when (string-match gtk-font-regexp truename) (when (not (member weight (aref entry 1))) (setq weight (capitalize (match-string 1 truename)))) (when (not (member size (aref entry 2))) (setq size (string-to-int (match-string 6 truename)))) (setq slant (capitalize (match-string 2 truename)))) (vector entry family size weight slant)))
1277
1278 ;;;***
1279 \f
1280 ;;;### (autoloads nil "help-macro" "lisp/help-macro.el")
1281
1282 (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)
1283
1284 ;;;***
1285 \f
1286 ;;;### (autoloads (hyper-apropos-popup-menu hyper-apropos-set-variable hyper-set-variable hyper-apropos-read-variable-symbol hyper-describe-function hyper-where-is hyper-describe-variable hyper-describe-face hyper-describe-key-briefly hyper-describe-key hyper-apropos) "hyper-apropos" "lisp/hyper-apropos.el")
1287
1288 (autoload 'hyper-apropos "hyper-apropos" "\
1289 Display lists of functions and variables matching REGEXP
1290 in buffer \"*Hyper Apropos*\".  If optional prefix arg is given, then the
1291 value of `hyper-apropos-programming-apropos' is toggled for this search.
1292 See also `hyper-apropos-mode'." t nil)
1293
1294 (autoload 'hyper-describe-key "hyper-apropos" nil t nil)
1295
1296 (autoload 'hyper-describe-key-briefly "hyper-apropos" nil t nil)
1297
1298 (autoload 'hyper-describe-face "hyper-apropos" "\
1299 Describe face..
1300 See also `hyper-apropos' and `hyper-describe-function'." t nil)
1301
1302 (autoload 'hyper-describe-variable "hyper-apropos" "\
1303 Hypertext drop-in replacement for `describe-variable'.
1304 See also `hyper-apropos' and `hyper-describe-function'." t nil)
1305
1306 (autoload 'hyper-where-is "hyper-apropos" "\
1307 Print message listing key sequences that invoke specified command." t nil)
1308
1309 (autoload 'hyper-describe-function "hyper-apropos" "\
1310 Hypertext replacement for `describe-function'.  Unlike `describe-function'
1311 in that the symbol under the cursor is the default if it is a function.
1312 See also `hyper-apropos' and `hyper-describe-variable'." t nil)
1313
1314 (autoload 'hyper-apropos-read-variable-symbol "hyper-apropos" "\
1315 Hypertext drop-in replacement for `describe-variable'.
1316 See also `hyper-apropos' and `hyper-describe-function'." nil nil)
1317
1318 (define-obsolete-function-alias 'hypropos-read-variable-symbol 'hyper-apropos-read-variable-symbol)
1319
1320 (define-obsolete-function-alias 'hypropos-get-doc 'hyper-apropos-get-doc)
1321
1322 (autoload 'hyper-set-variable "hyper-apropos" nil t nil)
1323
1324 (autoload 'hyper-apropos-set-variable "hyper-apropos" "\
1325 Interactively set the variable on the current line." t nil)
1326
1327 (define-obsolete-function-alias 'hypropos-set-variable 'hyper-apropos-set-variable)
1328
1329 (autoload 'hyper-apropos-popup-menu "hyper-apropos" nil t nil)
1330
1331 (define-obsolete-function-alias 'hypropos-popup-menu 'hyper-apropos-popup-menu)
1332
1333 ;;;***
1334 \f
1335 ;;;### (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-batch-rebuild-dir Info-find-node Info-query info) "info" "lisp/info.el")
1336
1337 (defvar Info-directory-list nil "\
1338 List of directories to search for Info documentation files.
1339
1340 The first directory in this list, the \"dir\" file there will become
1341 the (dir)Top node of the Info documentation tree.
1342
1343 Note: DO NOT use the `customize' interface to change the value of this
1344 variable.  Its value is created dynamically on each startup, depending
1345 on XEmacs packages installed on the system.  If you want to change the
1346 search path, make the needed modifications on the variable's value
1347 from .emacs.  For instance:
1348
1349     (setq Info-directory-list (cons \"~/info\" Info-directory-list))")
1350
1351 (autoload 'info "info" "\
1352 Enter Info, the documentation browser.
1353 Optional argument FILE specifies the file to examine;
1354 the default is the top-level directory of Info.
1355
1356 In interactive use, a prefix argument directs this command
1357 to read a file name from the minibuffer." t nil)
1358
1359 (autoload 'Info-query "info" "\
1360 Enter Info, the documentation browser.  Prompt for name of Info file." t nil)
1361
1362 (autoload 'Info-find-node "info" "\
1363 Go to an info node specified as separate FILENAME and NODENAME.
1364 Look for a plausible filename, or if not found then look for URL's and
1365 dispatch to the appropriate fn.  NO-GOING-BACK is non-nil if
1366 recovering from an error in this function; it says do not attempt
1367 further (recursive) error recovery.  TRYFILE is ??" nil nil)
1368
1369 (autoload 'Info-batch-rebuild-dir "info" "\
1370 (Re)build `dir' files in the directories remaining on the command line.
1371 Use this from the command line, with `-batch', it won't work in an
1372 interactive XEmacs.
1373
1374 Each file is processed even if an error occurred previously. For example,
1375 invoke \"xemacs -batch -f Info-batch-rebuild-dir /usr/local/info\"." nil nil)
1376
1377 (autoload 'Info-goto-node "info" "\
1378 Go to info node named NAME.  Give just NODENAME or (FILENAME)NODENAME.
1379 Actually, the following interpretations of NAME are tried in order:
1380     (FILENAME)NODENAME
1381     (FILENAME)     (using Top node)
1382     NODENAME       (in current file)
1383     TAGNAME        (see below)
1384     FILENAME       (using Top node)
1385 where TAGNAME is a string that appears in quotes: \"TAGNAME\", in an
1386 annotation for any node of any file.  (See `a' and `x' commands.)" t nil)
1387
1388 (autoload 'Info-visit-file "info" "\
1389 Directly visit an info file." t nil)
1390
1391 (autoload 'Info-search "info" "\
1392 Search for REGEXP, starting from point, and select node it's found in." t nil)
1393
1394 (autoload 'Info-emacs-command "info" "\
1395 Look up an Emacs command in the Emacs manual in the Info system.
1396 This command is designed to be used whether you are already in Info or not." t nil)
1397
1398 (autoload 'Info-goto-emacs-command-node "info" "\
1399 Look up an Emacs command in the Emacs manual in the Info system.
1400 This command is designed to be used whether you are already in Info or not." t nil)
1401
1402 (autoload 'Info-goto-emacs-key-command-node "info" "\
1403 Look up an Emacs key sequence in the Emacs manual in the Info system.
1404 This command is designed to be used whether you are already in Info or not." t nil)
1405
1406 (autoload 'Info-emacs-key "info" "\
1407 Look up an Emacs key sequence in the Emacs manual in the Info system.
1408 This command is designed to be used whether you are already in Info or not." t nil)
1409
1410 (autoload 'Info-elisp-ref "info" "\
1411 Look up an Emacs Lisp function in the Elisp manual in the Info system.
1412 This command is designed to be used whether you are already in Info or not." t nil)
1413
1414 ;;;***
1415 \f
1416 ;;;### (autoloads nil "itimer-autosave" "lisp/itimer-autosave.el")
1417
1418 ;;;***
1419 \f
1420 ;;;### (autoloads nil "loaddefs" "lisp/loaddefs.el")
1421
1422 ;;;***
1423 \f
1424 ;;;### (autoloads nil "loadhist" "lisp/loadhist.el")
1425
1426 ;;;***
1427 \f
1428 ;;;### (autoloads (mswindows-reset-device-font-menus) "msw-font-menu" "lisp/msw-font-menu.el")
1429
1430 (autoload 'mswindows-reset-device-font-menus "msw-font-menu" "\
1431 Generates the `Font', `Size', and `Weight' submenus for the Options menu.
1432 This is run the first time that a font-menu is needed for each device.
1433 If you don't like the lazy invocation of this function, you can add it to
1434 `create-device-hook' and that will make the font menus respond more quickly
1435 when they are selected for the first time.  If you add fonts to your system, 
1436 or if you change your font path, you can call this to re-initialize the menus." nil nil)
1437
1438 (defun* mswindows-font-menu-font-data (face dcache) (let* ((case-fold-search t) (domain (if font-menu-this-frame-only-p (selected-frame) (selected-device))) (name (font-instance-name (face-font-instance face domain))) (truename (font-instance-truename (face-font-instance face domain (if (featurep 'mule) 'ascii)))) family size weight entry slant) (when (string-match mswindows-font-regexp name) (setq family (match-string 1 name)) (setq entry (vassoc family (aref dcache 0)))) (when (and (null entry) (string-match mswindows-font-regexp truename)) (setq family (match-string 1 truename)) (setq entry (vassoc family (aref dcache 0)))) (when (null entry) (return-from mswindows-font-menu-font-data (make-vector 5 nil))) (when (string-match mswindows-font-regexp name) (setq weight (match-string 2 name)) (setq size (string-to-int (or (match-string 4 name) "0")))) (when (string-match mswindows-font-regexp truename) (when (not (member weight (aref entry 1))) (setq weight (match-string 2 truename))) (when (not (member size (aref entry 2))) (setq size (string-to-int (or (match-string 4 truename) "0")))) (setq slant (match-string 5 truename))) (vector entry family size weight slant)))
1439
1440 ;;;***
1441 \f
1442 ;;;### (autoloads (mwheel-install) "mwheel" "lisp/mwheel.el")
1443
1444 (autoload 'mwheel-install "mwheel" "\
1445 Enable mouse wheel support." t nil)
1446
1447 ;;;***
1448 \f
1449 ;;;### (autoloads (package-admin-add-binary-package package-admin-add-single-file-package) "package-admin" "lisp/package-admin.el")
1450
1451 (autoload 'package-admin-add-single-file-package "package-admin" "\
1452 Install a single file Lisp package into XEmacs package hierarchy.
1453 `file' should be the full path to the lisp file to install.
1454 `destdir' should be a simple directory name.
1455 The optional `pkg-dir' can be used to override the default package hierarchy
1456 \(car (last late-packages))." t nil)
1457
1458 (autoload 'package-admin-add-binary-package "package-admin" "\
1459 Install a pre-bytecompiled XEmacs package into package hierarchy." t nil)
1460
1461 ;;;***
1462 \f
1463 ;;;### (autoloads (package-get-custom package-get-package-provider package-get package-get-dependencies package-get-all package-get-update-all package-get-delete-package package-get-save-base package-get-update-base-from-buffer package-get-update-base package-get-update-base-entry package-get-require-base package-get-download-menu) "package-get" "lisp/package-get.el")
1464
1465 (defvar package-get-base nil "\
1466 List of packages that are installed at this site.
1467 For each element in the alist,  car is the package name and the cdr is
1468 a plist containing information about the package.   Typical fields
1469 kept in the plist are:
1470
1471 version         - version of this package
1472 provides        - list of symbols provided
1473 requires        - list of symbols that are required.
1474                   These in turn are provided by other packages.
1475 filename        - name of the file.
1476 size            - size of the file (aka the bundled package)
1477 md5sum          - computed md5 checksum
1478 description     - What this package is for.
1479 type            - Whether this is a 'binary (default) or 'single file package
1480
1481 More fields may be added as needed.  An example:
1482
1483 '(
1484  (name
1485   (version \"<version 2>\"
1486    file \"filename\"
1487    description \"what this package is about.\"
1488    provides (<list>)
1489    requires (<list>)
1490    size <integer-bytes>
1491    md5sum \"<checksum\"
1492    type single
1493    )
1494   (version \"<version 1>\"
1495    file \"filename\"
1496    description \"what this package is about.\"
1497    provides (<list>)
1498    requires (<list>)
1499    size <integer-bytes>
1500    md5sum \"<checksum\"
1501    type single
1502    )
1503    ...
1504    ))
1505
1506 For version information, it is assumed things are listed in most
1507 recent to least recent -- in other words, the version names don't have to
1508 be lexically ordered.  It is debatable if it makes sense to have more than
1509 one version of a package available.")
1510
1511 (defcustom package-get-download-sites '(("Pre-Releases" "ftp.xemacs.org" "pub/xemacs/beta/experimental/packages") ("xemacs.org" "ftp.xemacs.org" "pub/xemacs/packages") ("ca.xemacs.org (Canada)" "ftp.ca.xemacs.org" "pub/Mirror/xemacs/packages") ("crc.ca (Canada)" "ftp.crc.ca" "pub/packages/editors/xemacs/packages") ("us.xemacs.org (United States)" "ftp.us.xemacs.org" "pub/xemacs/packages") ("ibiblio.org (United States)" "ibiblio.org" "pub/packages/editors/xemacs/packages") ("stealth.net (United States)" "ftp.stealth.net" "pub/mirrors/ftp.xemacs.org/pub/xemacs/packages") ("br.xemacs.org (Brazil)" "ftp.br.xemacs.org" "pub/xemacs/packages") ("at.xemacs.org (Austria)" "ftp.at.xemacs.org" "editors/xemacs/packages") ("be.xemacs.org (Belgium)" "ftp.be.xemacs.org" "xemacs/packages") ("cz.xemacs.org (Czech Republic)" "ftp.cz.xemacs.org" "MIRRORS/ftp.xemacs.org/pub/xemacs/packages") ("dk.xemacs.org (Denmark)" "ftp.dk.xemacs.org" "pub/emacs/xemacs/packages") ("fi.xemacs.org (Finland)" "ftp.fi.xemacs.org" "pub/mirrors/ftp.xemacs.org/pub/tux/xemacs/packages") ("fr.xemacs.org (France)" "ftp.fr.xemacs.org" "pub/xemacs/packages") ("pasteur.fr (France)" "ftp.pasteur.fr" "pub/computing/xemacs/packages") ("de.xemacs.org (Germany)" "ftp.de.xemacs.org" "pub/ftp.xemacs.org/tux/xemacs/packages") ("tu-darmstadt.de (Germany)" "ftp.tu-darmstadt.de" "pub/editors/xemacs/packages") ("ie.xemacs.org (Ireland)" "ftp.ie.xemacs.org" "mirrors/ftp.xemacs.org/pub/xemacs/packages") ("it.xemacs.org (Italy)" "ftp.it.xemacs.org" "unix/packages/XEMACS/packages") ("no.xemacs.org (Norway)" "ftp.no.xemacs.org" "pub/xemacs/packages") ("pl.xemacs.org (Poland)" "ftp.pl.xemacs.org" "pub/unix/editors/xemacs/packages") ("ru.xemacs.org (Russia)" "ftp.ru.xemacs.org" "pub/xemacs/packages") ("sk.xemacs.org (Slovakia)" "ftp.sk.xemacs.org" "pub/mirrors/xemacs/packages") ("se.xemacs.org (Sweden)" "ftp.se.xemacs.org" "pub/gnu/xemacs/packages") ("ch.xemacs.org (Switzerland)" "ftp.ch.xemacs.org" "mirror/xemacs/packages") ("uk.xemacs.org (United Kingdom)" "ftp.uk.xemacs.org" "sites/ftp.xemacs.org/pub/xemacs/packages") ("jp.xemacs.org (Japan)" "ftp.jp.xemacs.org" "pub/GNU/xemacs/packages") ("aist.go.jp (Japan)" "ring.aist.go.jp" "pub/text/xemacs/packages") ("asahi-net.or.jp (Japan)" "ring.asahi-net.or.jp" "pub/text/xemacs/packages") ("dti.ad.jp (Japan)" "ftp.dti.ad.jp" "pub/unix/editor/xemacs/packages") ("jaist.ac.jp (Japan)" "ftp.jaist.ac.jp" "pub/GNU/xemacs/packages") ("nucba.ac.jp (Japan)" "mirror.nucba.ac.jp" "mirror/xemacs/packages") ("sut.ac.jp (Japan)" "sunsite.sut.ac.jp" "pub/archives/packages/xemacs/packages") ("kr.xemacs.org (Korea)" "ftp.kr.xemacs.org" "pub/tools/emacs/xemacs/packages") ("za.xemacs.org (South Africa)" "ftp.za.xemacs.org" "mirrorsites/ftp.xemacs.org/packages") ("sa.xemacs.org (Saudi Arabia)" "ftp.sa.xemacs.org" "pub/mirrors/ftp.xemacs.org/xemacs/packages") ("au.xemacs.org (Australia)" "ftp.au.xemacs.org" "pub/xemacs/packages") ("aarnet.edu.au (Australia)" "mirror.aarnet.edu.au" "pub/xemacs/packages") ("nz.xemacs.org (New Zealand)" "ftp.nz.xemacs.org" "mirror/ftp.xemacs.org/packages")) "*List of remote sites available for downloading packages.\nList format is '(site-description site-name directory-on-site).\nSITE-DESCRIPTION is a textual description of the site.  SITE-NAME\nis the internet address of the download site.  DIRECTORY-ON-SITE\nis the directory on the site in which packages may be found.\nThis variable is used to initialize `package-get-remote', the\nvariable actually used to specify package download sites." :tag "Package download sites" :type '(repeat (list (string :tag "Name") host-name directory)) :group 'package-get)
1512
1513 (autoload 'package-get-download-menu "package-get" "\
1514 Build the `Add Download Site' menu." nil nil)
1515
1516 (autoload 'package-get-require-base "package-get" "\
1517 Require that a package-get database has been loaded.
1518 If the optional FORCE-CURRENT argument or the value of
1519 `package-get-always-update' is Non-nil, try to update the database
1520 from a location in `package-get-remote'. Otherwise a local copy is used
1521 if available and remote access is never done.
1522
1523 Please use FORCE-CURRENT only when the user is explictly dealing with packages
1524 and remote access is likely in the near future." nil nil)
1525
1526 (autoload 'package-get-update-base-entry "package-get" "\
1527 Update an entry in `package-get-base'." nil nil)
1528
1529 (autoload 'package-get-update-base "package-get" "\
1530 Update the package-get database file with entries from DB-FILE.
1531 Unless FORCE-CURRENT is non-nil never try to update the database." t nil)
1532
1533 (autoload 'package-get-update-base-from-buffer "package-get" "\
1534 Update the package-get database with entries from BUFFER.
1535 BUFFER defaults to the current buffer.  This command can be
1536 used interactively, for example from a mail or news buffer." t nil)
1537
1538 (autoload 'package-get-save-base "package-get" "\
1539 Write the package-get database to FILE.
1540
1541 Note: This database will be unsigned of course." t nil)
1542
1543 (autoload 'package-get-delete-package "package-get" "\
1544 Delete an installation of PACKAGE below directory PKG-TOPDIR.
1545 PACKAGE is a symbol, not a string.
1546 This is just an interactive wrapper for `package-admin-delete-binary-package'." t nil)
1547
1548 (autoload 'package-get-update-all "package-get" "\
1549 Fetch and install the latest versions of all currently installed packages." t nil)
1550
1551 (autoload 'package-get-all "package-get" "\
1552 Fetch PACKAGE with VERSION and all other required packages.
1553 Uses `package-get-base' to determine just what is required and what
1554 package provides that functionality.  If VERSION is nil, retrieves
1555 latest version.  Optional argument FETCHED-PACKAGES is used to keep
1556 track of packages already fetched.  Optional argument INSTALL-DIR,
1557 if non-nil, specifies the package directory where fetched packages
1558 should be installed.
1559
1560 Returns nil upon error." t nil)
1561
1562 (autoload 'package-get-dependencies "package-get" "\
1563 Compute dependencies for PACKAGES.
1564 Uses `package-get-base' to determine just what is required and what
1565 package provides that functionality.  Returns the list of packages
1566 required by PACKAGES." nil nil)
1567
1568 (autoload 'package-get "package-get" "\
1569 Fetch PACKAGE from remote site.
1570 Optional arguments VERSION indicates which version to retrieve, nil
1571 means most recent version.  CONFLICT indicates what happens if the
1572 package is already installed.  Valid values for CONFLICT are:
1573 'always always retrieve the package even if it is already installed
1574 'never  do not retrieve the package if it is installed.
1575 INSTALL-DIR, if non-nil, specifies the package directory where
1576 fetched packages should be installed.
1577
1578 The value of `package-get-base' is used to determine what files should
1579 be retrieved.  The value of `package-get-remote' is used to determine
1580 where a package should be retrieved from.  The sites are tried in
1581 order so one is better off listing easily reached sites first.
1582
1583 Once the package is retrieved, its md5 checksum is computed.  If that
1584 sum does not match that stored in `package-get-base' for this version
1585 of the package, an error is signalled.
1586
1587 Returns `t' upon success, the symbol `error' if the package was
1588 successfully installed but errors occurred during initialization, or
1589 `nil' upon error." t nil)
1590
1591 (autoload 'package-get-package-provider "package-get" "\
1592 Search for a package that provides SYM and return the name and
1593   version.  Searches in `package-get-base' for SYM.   If SYM is a
1594   consp, then it must match a corresponding (provide (SYM VERSION)) from
1595   the package.
1596
1597 If FORCE-CURRENT is non-nil make sure the database is up to date. This might
1598 lead to Emacs accessing remote sites." t nil)
1599
1600 (autoload 'package-get-custom "package-get" "\
1601 Fetch and install the latest versions of all customized packages." t nil)
1602
1603 ;;;***
1604 \f
1605 ;;;### (autoloads (package-net-update-installed-db package-net-setup-directory) "package-net" "lisp/package-net.el")
1606
1607 (autoload 'package-net-setup-directory "package-net" nil nil nil)
1608
1609 (autoload 'package-net-update-installed-db "package-net" "\
1610 Write out the installed package index in a net install suitable format.
1611 If DESTDIR is non-nil then use that as the destination directory. 
1612 DESTDIR defaults to the value of `package-net-setup-directory'." nil nil)
1613
1614 ;;;***
1615 \f
1616 ;;;### (autoloads (pui-list-packages pui-add-install-directory package-ui-add-site) "package-ui" "lisp/package-ui.el")
1617
1618 (autoload 'package-ui-add-site "package-ui" "\
1619 Add site to package-get-remote and possibly offer to update package list." nil nil)
1620
1621 (autoload 'pui-add-install-directory "package-ui" "\
1622 Add a new package binary directory to the head of `package-get-remote'.
1623 Note that no provision is made for saving any changes made by this function.
1624 It exists mainly as a convenience for one-time package installations from
1625 disk." t nil)
1626
1627 (autoload 'pui-list-packages "package-ui" "\
1628 List all packages and package information.
1629 The package name, version, and description are displayed.  From the displayed
1630 buffer, the user can see which packages are installed, which are not, and
1631 which are out-of-date (a newer version is available).  The user can then
1632 select packages for installation via the keyboard or mouse." t nil)
1633
1634 (defalias 'list-packages 'pui-list-packages)
1635
1636 ;;;***
1637 \f
1638 ;;;### (autoloads (picture-mode) "picture" "lisp/picture.el")
1639
1640 (autoload 'picture-mode "picture" "\
1641 Switch to Picture mode, in which a quarter-plane screen model is used.
1642 Printing characters replace instead of inserting themselves with motion
1643 afterwards settable by these commands:
1644   C-c <   Move left after insertion.
1645   C-c >   Move right after insertion.
1646   C-c ^   Move up after insertion.
1647   C-c .   Move down after insertion.
1648   C-c `   Move northwest (nw) after insertion.
1649   C-c '   Move northeast (ne) after insertion.
1650   C-c /   Move southwest (sw) after insertion.
1651   C-c \\   Move southeast (se) after insertion.
1652 The current direction is displayed in the modeline.  The initial
1653 direction is right.  Whitespace is inserted and tabs are changed to
1654 spaces when required by movement.  You can move around in the buffer
1655 with these commands:
1656   \\[picture-move-down]   Move vertically to SAME column in previous line.
1657   \\[picture-move-up]     Move vertically to SAME column in next line.
1658   \\[picture-end-of-line]         Move to column following last non-whitespace character.
1659   \\[picture-forward-column]      Move right inserting spaces if required.
1660   \\[picture-backward-column]     Move left changing tabs to spaces if required.
1661   C-c C-f Move in direction of current picture motion.
1662   C-c C-b Move in opposite direction of current picture motion.
1663   Return  Move to beginning of next line.
1664 You can edit tabular text with these commands:
1665   M-Tab   Move to column beneath (or at) next interesting character.
1666             `Indents' relative to a previous line.
1667   Tab     Move to next stop in tab stop list.
1668   C-c Tab Set tab stops according to context of this line.
1669             With ARG resets tab stops to default (global) value.
1670             See also documentation of variable  picture-tab-chars
1671             which defines \"interesting character\".  You can manually
1672             change the tab stop list with command \\[edit-tab-stops].
1673 You can manipulate text with these commands:
1674   C-d     Clear (replace) ARG columns after point without moving.
1675   C-c C-d Delete char at point - the command normally assigned to C-d.
1676   \\[picture-backward-clear-column]  Clear (replace) ARG columns before point, moving back over them.
1677   \\[picture-clear-line]          Clear ARG lines, advancing over them.  The cleared
1678             text is saved in the kill ring.
1679   \\[picture-open-line]   Open blank line(s) beneath current line.
1680 You can manipulate rectangles with these commands:
1681   C-c C-k Clear (or kill) a rectangle and save it.
1682   C-c C-w Like C-c C-k except rectangle is saved in named register.
1683   C-c C-y Overlay (or insert) currently saved rectangle at point.
1684   C-c C-x Like C-c C-y except rectangle is taken from named register.
1685   \\[copy-rectangle-to-register]   Copies a rectangle to a register.
1686   \\[advertised-undo]   Can undo effects of rectangle overlay commands
1687             commands if invoked soon enough.
1688 You can return to the previous mode with:
1689   C-c C-c Which also strips trailing whitespace from every line.
1690             Stripping is suppressed by supplying an argument.
1691
1692 Entry to this mode calls the value of  picture-mode-hook  if non-nil.
1693
1694 Note that Picture mode commands will work outside of Picture mode, but
1695 they are not defaultly assigned to keys." t nil)
1696
1697 (defalias 'edit-picture 'picture-mode)
1698
1699 ;;;***
1700 \f
1701 ;;;### (autoloads (clear-rectangle replace-rectangle string-rectangle open-rectangle insert-rectangle yank-rectangle kill-rectangle extract-rectangle delete-extract-rectangle delete-rectangle) "rect" "lisp/rect.el")
1702
1703 (autoload 'delete-rectangle "rect" "\
1704 Delete the text in the region-rectangle without saving it.
1705 The same range of columns is deleted in each line starting with the line
1706 where the region begins and ending with the line where the region ends.
1707
1708 When called from a program, the rectangle's corners are START and END.
1709 With a prefix (or FILL) argument, also fill lines where nothing has to be
1710 deleted." t nil)
1711
1712 (autoload 'delete-extract-rectangle "rect" "\
1713 Delete the contents of the rectangle with corners at START and END, and
1714 return it as a list of strings, one for each line of the rectangle.
1715
1716 With an optional FILL argument, also fill lines where nothing has to be
1717 deleted." nil nil)
1718
1719 (autoload 'extract-rectangle "rect" "\
1720 Return the contents of the rectangle with corners at START and END,
1721 as a list of strings, one for each line of the rectangle." nil nil)
1722
1723 (defvar killed-rectangle nil "\
1724 Rectangle for `yank-rectangle' to insert.")
1725
1726 (autoload 'kill-rectangle "rect" "\
1727 Delete the region-rectangle and save it as the last killed one.
1728 You might prefer to use `delete-extract-rectangle' from a program.
1729
1730 When called from a program, the rectangle's corners are START and END.
1731 With a prefix (or FILL) argument, also fill lines where nothing has to be
1732 deleted." t nil)
1733
1734 (autoload 'yank-rectangle "rect" "\
1735 Yank the last killed rectangle with upper left corner at point." t nil)
1736
1737 (autoload 'insert-rectangle "rect" "\
1738 Insert text of RECTANGLE with upper left corner at point.
1739 RECTANGLE's first line is inserted at point, its second
1740 line is inserted at a point vertically under point, etc.
1741 RECTANGLE should be a list of strings.
1742 After this command, the mark is at the upper left corner
1743 and point is at the lower right corner." nil nil)
1744
1745 (autoload 'open-rectangle "rect" "\
1746 Blank out the region-rectangle, shifting text right.
1747
1748 When called from a program, the rectangle's corners are START and END.
1749 With a prefix (or FILL) argument, fill with blanks even if there is no text
1750 on the right side of the rectangle." t nil)
1751
1752 (autoload 'string-rectangle "rect" "\
1753 Insert STRING on each line of the region-rectangle, shifting text right.
1754 The left edge of the rectangle specifies the column for insertion.
1755
1756 If `pending-delete-mode' is active the string replace the region.
1757 Otherwise this command does not delete or overwrite any existing text.
1758
1759 When called from a program, the rectangle's corners are START and END." t nil)
1760
1761 (autoload 'replace-rectangle "rect" "\
1762 Like `string-rectangle', but unconditionally replace the original region,
1763 as if `pending-delete-mode' were active." t nil)
1764
1765 (autoload 'clear-rectangle "rect" "\
1766 Blank out the region-rectangle.
1767 The text previously in the region is overwritten with blanks.
1768
1769 When called from a program, the rectangle's corners are START and END.
1770 With a prefix (or FILL) argument, also fill with blanks the parts of the
1771 rectangle which were empty." t nil)
1772
1773 ;;;***
1774 \f
1775 ;;;### (autoloads (list-load-path-shadows) "shadow" "lisp/shadow.el")
1776
1777 (autoload 'list-load-path-shadows "shadow" "\
1778 Display a list of Emacs Lisp files that shadow other files.
1779
1780 This function lists potential load-path problems.  Directories in the
1781 `load-path' variable are searched, in order, for Emacs Lisp
1782 files.  When a previously encountered file name is found again, a
1783 message is displayed indicating that the later file is \"hidden\" by
1784 the earlier.
1785
1786 For example, suppose `load-path' is set to
1787
1788 \(\"/usr/gnu/emacs/site-lisp\" \"/usr/gnu/emacs/share/emacs/19.30/lisp\")
1789
1790 and that each of these directories contains a file called XXX.el.  Then
1791 XXX.el in the site-lisp directory is referred to by all of:
1792 \(require 'XXX), (autoload .... \"XXX\"), (load-library \"XXX\") etc.
1793
1794 The first XXX.el file prevents emacs from seeing the second (unless
1795 the second is loaded explicitly via load-file).
1796
1797 When not intended, such shadowings can be the source of subtle
1798 problems.  For example, the above situation may have arisen because the
1799 XXX package was not distributed with versions of emacs prior to
1800 19.30.  An emacs maintainer downloaded XXX from elsewhere and installed
1801 it.  Later, XXX was updated and included in the emacs distribution.
1802 Unless the emacs maintainer checks for this, the new version of XXX
1803 will be hidden behind the old (which may no longer work with the new
1804 emacs version).
1805
1806 This function performs these checks and flags all possible
1807 shadowings.  Because a .el file may exist without a corresponding .elc
1808 \(or vice-versa), these suffixes are essentially ignored.  A file
1809 XXX.elc in an early directory (that does not contain XXX.el) is
1810 considered to shadow a later file XXX.el, and vice-versa.
1811
1812 When run interactively, the shadowings (if any) are displayed in a
1813 buffer called `*Shadows*'.  Shadowings are located by calling the
1814 \(non-interactive) companion function, `find-emacs-lisp-shadows'." t nil)
1815
1816 ;;;***
1817 \f
1818 ;;;### (autoloads (load-default-sounds load-sound-file) "sound" "lisp/sound.el")
1819
1820 (or sound-alist (setq sound-alist '((ready nil) (warp nil))))
1821
1822 (autoload 'load-sound-file "sound" "\
1823 Read in an audio-file and add it to the sound-alist.
1824
1825 FILENAME can either be absolute or relative, in which case the file will
1826 be searched in the directories given by `default-sound-directory-list'.
1827 When looking for the file, the extensions given by `sound-extension-list' are
1828 also tried in the given order.
1829
1830 You can only play sound files if you are running on display 0 of the
1831 console of a machine with native sound support or running a NetAudio
1832 server and XEmacs has the necessary sound support compiled in.
1833
1834 The sound file must be in the Sun/NeXT U-LAW format, except on Linux,
1835 where .wav files are also supported by the sound card drivers." t nil)
1836
1837 (autoload 'load-default-sounds "sound" "\
1838 Load and install some sound files as beep-types, using
1839 `load-sound-file'.  This only works if you're on display 0 of the
1840 console of a machine with native sound support or running a NetAudio
1841 server and XEmacs has the necessary sound support compiled in." t nil)
1842
1843 ;;;***
1844 \f
1845 ;;;### (autoloads (ask-user-about-supersession-threat ask-user-about-lock) "userlock" "lisp/userlock.el")
1846
1847 (autoload 'ask-user-about-lock "userlock" "\
1848 Ask user wanting to edit FILENAME, locked by OTHER-USER, what to do.
1849 This function has a choice of three things to do:
1850   do (signal 'file-locked (list FILENAME OTHER-USER))
1851     to refrain from editing the file
1852   return t (grab the lock on the file)
1853   return nil (edit the file even though it is locked).
1854 You can rewrite it to use any criteria you like to choose which one to do." nil nil)
1855
1856 (autoload 'ask-user-about-supersession-threat "userlock" "\
1857 Ask user who is about to modify an obsolete buffer what to do.
1858 This function has two choices: it can return, in which case the modification
1859 of the buffer will proceed, or it can (signal 'file-supersession (FILENAME)),
1860 in which case the proposed buffer modification will not be made.
1861
1862 You can rewrite this to use any criteria you like to choose which one to do.
1863 The buffer in question is current when this function is called." nil nil)
1864
1865 ;;;***
1866 \f
1867 ;;;### (autoloads (toggle-truncate-lines 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")
1868
1869 (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 "\r" '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 "\ 3\ 3" 'view-quit) (define-key map "\18\11" 'view-quit-toggle-ro) (define-key map "q" 'view-quit) map))
1870
1871 (defvar view-mode-map (let ((map (copy-keymap view-minor-mode-map))) (set-keymap-name map 'view-mode-map) map))
1872
1873 (autoload 'view-file "view-less" "\
1874 Find FILENAME, enter view mode.  With prefix arg OTHER-WINDOW-P, use other window." t nil)
1875
1876 (autoload 'view-buffer "view-less" "\
1877 Switch to BUFFER, enter view mode.  With prefix arg use other window." t nil)
1878
1879 (autoload 'view-file-other-window "view-less" "\
1880 Find FILENAME in other window, and enter view mode." t nil)
1881
1882 (autoload 'view-buffer-other-window "view-less" "\
1883 Switch to BUFFER in another window, and enter view mode." t nil)
1884
1885 (autoload 'view-minor-mode "view-less" "\
1886 Minor mode for viewing text, with bindings like `less'.
1887 Commands are:
1888 \\<view-minor-mode-map>
1889 0..9    prefix args
1890 -       prefix minus
1891 \\[scroll-up]   page forward
1892 \\[scroll-down] page back
1893 \\[view-scroll-lines-up]        scroll prefix-arg lines forward, default 1.
1894 \\[view-scroll-lines-down]      scroll prefix-arg lines backward, default 1.
1895 \\[view-scroll-some-lines-down] scroll prefix-arg lines backward, default 10.
1896 \\[view-scroll-some-lines-up]   scroll prefix-arg lines forward, default 10.
1897 \\[what-line]   print line number
1898 \\[view-mode-describe]  print this help message
1899 \\[view-search-forward] regexp search, uses previous string if you just hit RET
1900 \\[view-search-backward]        as above but searches backward
1901 \\[view-repeat-search]  repeat last search
1902 \\[view-goto-line]      goto line prefix-arg, default 1
1903 \\[view-last-windowful] goto line prefix-arg, default last line
1904 \\[view-goto-percent]   goto a position by percentage
1905 \\[toggle-truncate-lines]       toggle truncate-lines
1906 \\[view-file]   view another file
1907 \\[view-buffer] view another buffer
1908 \\[view-cleanup-backspaces]     cleanup backspace constructions
1909 \\[shell-command]       execute a shell command
1910 \\[shell-command-on-region]     execute a shell command with the region as input
1911 \\[view-quit]   exit view-mode, and bury the current buffer.
1912
1913 If invoked with the optional (prefix) arg non-nil, view-mode cleans up
1914 backspace constructions.
1915
1916 More precisely:
1917 \\{view-minor-mode-map}" t nil)
1918
1919 (autoload 'view-mode "view-less" "\
1920 View the current buffer using view-minor-mode.  This exists to be 99.9%
1921 compatible with the implementations of `view-mode' in view.el and older
1922 versions of view-less.el." t nil)
1923
1924 (autoload 'view-major-mode "view-less" "\
1925 View the current buffer using view-mode, as a major mode.
1926 This function has a nonstandard name because `view-mode' is wrongly
1927 named but is like this for compatibility reasons." t nil)
1928
1929 (autoload 'auto-view-mode "view-less" "\
1930 If the file of the current buffer is not writable, call view-mode.
1931 This is meant to be added to `find-file-hooks'." nil nil)
1932
1933 (autoload 'toggle-truncate-lines "view-less" "\
1934 Toggles the values of truncate-lines.
1935 Positive prefix arg sets, negative disables." t nil)
1936
1937 ;;;***
1938 \f
1939 ;;;### (autoloads (widget-minor-mode widget-browse-other-window widget-browse widget-browse-at) "wid-browse" "lisp/wid-browse.el")
1940
1941 (autoload 'widget-browse-at "wid-browse" "\
1942 Browse the widget under point." t nil)
1943
1944 (autoload 'widget-browse "wid-browse" "\
1945 Create a widget browser for WIDGET." t nil)
1946
1947 (autoload 'widget-browse-other-window "wid-browse" "\
1948 Show widget browser for WIDGET in other window." t nil)
1949
1950 (autoload 'widget-minor-mode "wid-browse" "\
1951 Togle minor mode for traversing widgets.
1952 With arg, turn widget mode on if and only if arg is positive." t nil)
1953
1954 ;;;***
1955 \f
1956 ;;;### (autoloads (widget-delete widget-create widget-prompt-value) "wid-edit" "lisp/wid-edit.el")
1957
1958 (autoload 'widget-prompt-value "wid-edit" "\
1959 Prompt for a value matching WIDGET, using PROMPT.
1960 The current value is assumed to be VALUE, unless UNBOUND is non-nil." nil nil)
1961
1962 (autoload 'widget-create "wid-edit" "\
1963 Create widget of TYPE.
1964 The optional ARGS are additional keyword arguments." nil nil)
1965
1966 (autoload 'widget-delete "wid-edit" "\
1967 Delete WIDGET." nil nil)
1968
1969 ;;;***
1970 \f
1971 ;;;### (autoloads (x-reset-device-font-menus) "x-font-menu" "lisp/x-font-menu.el")
1972
1973 (autoload 'x-reset-device-font-menus "x-font-menu" "\
1974 Generates the `Font', `Size', and `Weight' submenus for the Options menu.
1975 This is run the first time that a font-menu is needed for each device.
1976 If you don't like the lazy invocation of this function, you can add it to
1977 `create-device-hook' and that will make the font menus respond more quickly
1978 when they are selected for the first time.  If you add fonts to your system, 
1979 or if you change your font path, you can call this to re-initialize the menus." nil nil)
1980
1981 (defun* x-font-menu-font-data (face dcache) (defvar x-font-regexp) (defvar x-font-regexp-foundry-and-family) (let* ((case-fold-search t) (domain (if font-menu-this-frame-only-p (selected-frame) (selected-device))) (name (font-instance-name (face-font-instance face domain))) (truename (font-instance-truename (face-font-instance face domain (if (featurep 'mule) 'ascii)))) family size weight entry slant) (when (string-match x-font-regexp-foundry-and-family name) (setq family (capitalize (match-string 1 name))) (setq entry (vassoc family (aref dcache 0)))) (when (and (null entry) (string-match x-font-regexp-foundry-and-family truename)) (setq family (capitalize (match-string 1 truename))) (setq entry (vassoc family (aref dcache 0)))) (when (null entry) (return-from x-font-menu-font-data (make-vector 5 nil))) (when (string-match x-font-regexp name) (setq weight (capitalize (match-string 1 name))) (setq size (string-to-int (match-string 6 name)))) (when (string-match x-font-regexp truename) (when (not (member weight (aref entry 1))) (setq weight (capitalize (match-string 1 truename)))) (when (not (member size (aref entry 2))) (setq size (string-to-int (match-string 6 truename)))) (setq slant (capitalize (match-string 2 truename)))) (vector entry family size weight slant)))
1982
1983 ;;;***
1984 \f
1985 ;;;### (autoloads (x-win-init-sun) "x-win-sun" "lisp/x-win-sun.el")
1986
1987 (autoload 'x-win-init-sun "x-win-sun" nil nil nil)
1988
1989 ;;;***
1990 \f
1991 ;;;### (autoloads (x-win-init-xfree86) "x-win-xfree86" "lisp/x-win-xfree86.el")
1992
1993 (autoload 'x-win-init-xfree86 "x-win-xfree86" nil nil nil)
1994
1995 ;;;***
1996
1997 (provide 'lisp-autoloads)