(U+5349): Use `->denotational' to integrate U-0002F82C.
[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.
868
869 Variables of note:
870
871   tag-table-alist               controls which tables apply to which buffers
872   tags-file-name                a default tags table
873   tags-build-completion-table   controls completion behavior
874   buffer-tag-table              another way of specifying a buffer-local table
875   make-tags-files-invisible     whether tags tables should be very hidden
876   tag-mark-stack-max            how many tags-based hops to remember" t nil)
877
878 (autoload 'find-tag-other-window "etags" "\
879 *Find tag whose name contains TAGNAME, in another window.
880  Selects the buffer that the tag is contained in in another window
881 and puts point at its definition.
882  If TAGNAME is a null string, the expression in the buffer
883 around or before point is used as the tag name.
884  If second arg NEXT is non-nil (interactively, with prefix arg),
885 searches for the next tag in the tag table
886 that matches the tagname used in the previous find-tag.
887
888 This version of this function supports multiple active tags tables,
889 and completion.
890
891 Variables of note:
892
893   tag-table-alist               controls which tables apply to which buffers
894   tags-file-name                a default tags table
895   tags-build-completion-table   controls completion behavior
896   buffer-tag-table              another way of specifying a buffer-local table
897   make-tags-files-invisible     whether tags tables should be very hidden
898   tag-mark-stack-max            how many tags-based hops to remember" t nil)
899
900 (autoload 'tag-complete-symbol "etags" "\
901 The function used to do tags-completion (using 'tag-completion-predicate)." t nil)
902
903 (autoload 'next-file "etags" "\
904 Select next file among files in current tag table(s).
905
906 A first argument of t (prefix arg, if interactive) initializes to the
907 beginning of the list of files in the (first) tags table.  If the argument
908 is neither nil nor t, it is evalled to initialize the list of files.
909
910 Non-nil second argument NOVISIT means use a temporary buffer
911 to save time and avoid uninteresting warnings.
912
913 Value is nil if the file was already visited;
914 if the file was newly read in, the value is the filename." t nil)
915
916 (autoload 'tags-loop-continue "etags" "\
917 Continue last \\[tags-search] or \\[tags-query-replace] command.
918 Used noninteractively with non-nil argument to begin such a command (the
919 argument is passed to `next-file', which see).
920 Two variables control the processing we do on each file:
921 the value of `tags-loop-scan' is a form to be executed on each file
922 to see if it is interesting (it returns non-nil if so)
923 and `tags-loop-operate' is a form to execute to operate on an interesting file
924 If the latter returns non-nil, we exit; otherwise we scan the next file." t nil)
925
926 (autoload 'tags-search "etags" "\
927 Search through all files listed in tags table for match for REGEXP.
928 Stops when a match is found.
929 To continue searching for next match, use command \\[tags-loop-continue].
930
931 See documentation of variable `tag-table-alist'." t nil)
932
933 (autoload 'tags-query-replace "etags" "\
934 Query-replace-regexp FROM with TO through all files listed in tags table.
935 Third arg DELIMITED (prefix arg) means replace only word-delimited matches.
936 If you exit (\\[keyboard-quit] or ESC), you can resume the query-replace
937 with the command \\[tags-loop-continue].
938
939 See documentation of variable `tag-table-alist'." t nil)
940
941 (autoload 'list-tags "etags" "\
942 Display list of tags in FILE." t nil)
943
944 (autoload 'tags-apropos "etags" "\
945 Display list of all tags in tag table REGEXP matches." t nil)
946 (define-key esc-map "*" 'pop-tag-mark)
947
948 (autoload 'pop-tag-mark "etags" "\
949 Go to last tag position.
950 `find-tag' maintains a mark-stack seperate from the \\[set-mark-command] mark-stack.
951 This function pops (and moves to) the tag at the top of this stack." t nil)
952
953 ;;;***
954 \f
955 ;;;### (autoloads (finder-by-keyword finder-commentary) "finder" "lisp/finder.el")
956
957 (autoload 'finder-commentary "finder" "\
958 Display FILE's commentary section.
959 FILE should be in a form suitable for passing to `locate-library'." t nil)
960
961 (autoload 'finder-by-keyword "finder" "\
962 Find packages matching a given keyword." t nil)
963
964 ;;;***
965 \f
966 ;;;### (autoloads (font-lock-set-defaults-1 font-lock-fontify-buffer turn-off-font-lock turn-on-font-lock font-lock-mode font-lock-mode font-lock-fontify-string-delimiters font-lock-maximum-size font-lock-maximum-decoration font-lock-use-fonts font-lock-use-colors font-lock-mode-disable-list font-lock-mode-enable-list font-lock-auto-fontify) "font-lock" "lisp/font-lock.el")
967
968 (defvar font-lock-auto-fontify t "\
969 *Whether font-lock should automatically fontify files as they're loaded.
970 This will only happen if font-lock has fontifying keywords for the major
971 mode of the file.  You can get finer-grained control over auto-fontification
972 by using this variable in combination with `font-lock-mode-enable-list' or
973 `font-lock-mode-disable-list'.")
974
975 (defvar font-lock-mode-enable-list nil "\
976 *List of modes to auto-fontify, if `font-lock-auto-fontify' is nil.")
977
978 (defvar font-lock-mode-disable-list nil "\
979 *List of modes not to auto-fontify, if `font-lock-auto-fontify' is t.")
980
981 (defvar font-lock-use-colors '(color) "\
982 *Specification for when Font Lock will set up color defaults.
983 Normally this should be '(color), meaning that Font Lock will set up
984 color defaults that are only used on color displays.  Set this to nil
985 if you don't want Font Lock to set up color defaults at all.  This
986 should be one of
987
988 -- a list of valid tags, meaning that the color defaults will be used
989    when all of the tags apply. (e.g. '(color x))
990 -- a list whose first element is 'or and whose remaining elements are
991    lists of valid tags, meaning that the defaults will be used when
992    any of the tag lists apply.
993 -- nil, meaning that the defaults should not be set up at all.
994
995 \(If you specify face values in your init file, they will override any
996 that Font Lock specifies, regardless of whether you specify the face
997 values before or after loading Font Lock.)
998
999 See also `font-lock-use-fonts'.  If you want more control over the faces
1000 used for fontification, see the documentation of `font-lock-mode' for
1001 how to do it.")
1002
1003 (defvar font-lock-use-fonts '(or (mono) (grayscale)) "\
1004 *Specification for when Font Lock will set up non-color defaults.
1005
1006 Normally this should be '(or (mono) (grayscale)), meaning that Font
1007 Lock will set up non-color defaults that are only used on either mono
1008 or grayscale displays.  Set this to nil if you don't want Font Lock to
1009 set up non-color defaults at all.  This should be one of
1010
1011 -- a list of valid tags, meaning that the non-color defaults will be used
1012    when all of the tags apply. (e.g. '(grayscale x))
1013 -- a list whose first element is 'or and whose remaining elements are
1014    lists of valid tags, meaning that the defaults will be used when
1015    any of the tag lists apply.
1016 -- nil, meaning that the defaults should not be set up at all.
1017
1018 \(If you specify face values in your init file, they will override any
1019 that Font Lock specifies, regardless of whether you specify the face
1020 values before or after loading Font Lock.)
1021
1022 See also `font-lock-use-colors'.  If you want more control over the faces
1023 used for fontification, see the documentation of `font-lock-mode' for
1024 how to do it.")
1025
1026 (defvar font-lock-maximum-decoration t "\
1027 *If non-nil, the maximum decoration level for fontifying.
1028 If nil, use the minimum decoration (equivalent to level 0).
1029 If t, use the maximum decoration available.
1030 If a number, use that level of decoration (or if not available the maximum).
1031 If a list, each element should be a cons pair of the form (MAJOR-MODE . LEVEL),
1032 where MAJOR-MODE is a symbol or t (meaning the default).  For example:
1033  ((c++-mode . 2) (c-mode . t) (t . 1))
1034 means use level 2 decoration for buffers in `c++-mode', the maximum decoration
1035 available for buffers in `c-mode', and level 1 decoration otherwise.")
1036
1037 (define-obsolete-variable-alias 'font-lock-use-maximal-decoration 'font-lock-maximum-decoration)
1038
1039 (defvar font-lock-maximum-size (* 250 1024) "\
1040 *If non-nil, the maximum size for buffers for fontifying.
1041 Only buffers less than this can be fontified when Font Lock mode is turned on.
1042 If nil, means size is irrelevant.
1043 If a list, each element should be a cons pair of the form (MAJOR-MODE . SIZE),
1044 where MAJOR-MODE is a symbol or t (meaning the default).  For example:
1045  ((c++-mode . 256000) (c-mode . 256000) (rmail-mode . 1048576))
1046 means that the maximum size is 250K for buffers in `c++-mode' or `c-mode', one
1047 megabyte for buffers in `rmail-mode', and size is irrelevant otherwise.")
1048
1049 (defvar font-lock-fontify-string-delimiters nil "\
1050 *If non-nil, apply font-lock-string-face to string delimiters as well as
1051 string text when fontifying.")
1052
1053 (defvar font-lock-keywords nil "\
1054 A list defining the keywords for `font-lock-mode' to highlight.
1055
1056  FONT-LOCK-KEYWORDS := List of FONT-LOCK-FORM's.
1057
1058  FONT-LOCK-FORM     :== MATCHER
1059                       | (MATCHER . MATCH)
1060                       | (MATCHER . FACE-FORM)
1061                       | (MATCHER . HIGHLIGHT)
1062                       | (MATCHER HIGHLIGHT ...)
1063                       | (eval . FORM)
1064
1065  MATCHER            :== A string containing a regexp.
1066                       | A variable containing a regexp to search for.
1067                       | A function to call to make the search.
1068                         It is called with one arg, the limit of the search,
1069                         and should leave MATCH results in the XEmacs global
1070                         match data.
1071
1072  MATCH              :== An integer match subexpression number from MATCHER.
1073
1074  FACE-FORM           :== The symbol naming a defined face.
1075                       | Expression whos value is the face name to use.  If you
1076                         want FACE-FORM to be a symbol that evaluates to a face,
1077                         use a form like \"(progn sym)\".
1078
1079  HIGHLIGHT          :== MATCH-HIGHLIGHT
1080                       | MATCH-ANCHORED
1081
1082  FORM               :== Expression returning a FONT-LOCK-FORM, evaluated when
1083                         the FONT-LOCK-FORM is first used in a buffer.  This
1084                         feature can be used to provide a FONT-LOCK-FORM that
1085                         can only be generated when Font Lock mode is actually
1086                         turned on.
1087
1088  MATCH-HIGHLIGHT    :== (MATCH FACE-FORM OVERRIDE LAXMATCH)
1089
1090  OVERRIDE           :== t        - overwrite existing fontification
1091                       | 'keep    - only parts not already fontified are
1092                                    highlighted.
1093                       | 'prepend - merge faces, this fontification has
1094                                    precedence over existing
1095                       | 'append  - merge faces, existing fontification has
1096                                    precedence over
1097                                    this face.
1098
1099  LAXMATCH           :== If non-nil, no error is signalled if there is no MATCH
1100                         in MATCHER.
1101
1102  MATCH-ANCHORED     :== (ANCHOR-MATCHER PRE-MATCH-FORM \\
1103                                           POST-MATCH-FORM MATCH-HIGHLIGHT ...)
1104
1105  ANCHOR-MATCHER     :== Like a MATCHER, except that the limit of the search
1106                         defaults to the end of the line after PRE-MATCH-FORM
1107                         is evaluated.  However, if PRE-MATCH-FORM returns a
1108                         position greater than the end of the line, that
1109                         position is used as the limit of the search.  It is
1110                         generally a bad idea to return a position greater than
1111                         the end of the line, i.e., cause the ANCHOR-MATCHER
1112                         search to span lines.
1113
1114  PRE-MATCH-FORM     :== Evaluated before the ANCHOR-MATCHER is used, therefore
1115                         can be used to initialize before, ANCHOR-MATCHER is
1116                         used.  Typically, PRE-MATCH-FORM is used to move to
1117                         some position relative to the original MATCHER, before
1118                         starting with the ANCHOR-MATCHER.
1119
1120  POST-MATCH-FORM    :== Like PRE-MATCH-FORM, but used to clean up after the
1121                         ANCHOR-MATCHER.  It might be used to move, before
1122                         resuming with MATCH-ANCHORED's parent's MATCHER.
1123
1124 For example, an element of the first form highlights (if not already highlighted):
1125
1126   \"\\\\\\=<foo\\\\\\=>\"                    Discrete occurrences of \"foo\" in the value
1127                                  of the variable `font-lock-keyword-face'.
1128
1129   (\"fu\\\\(bar\\\\)\" . 1)            Substring \"bar\" within all occurrences of
1130                                  \"fubar\" in the value of
1131                                  `font-lock-keyword-face'.
1132
1133   (\"fubar\" . fubar-face)         Occurrences of \"fubar\" in the value of
1134                                  `fubar-face'.
1135
1136   (\"foo\\\\|bar\" 0 foo-bar-face t) Occurrences of either \"foo\" or \"bar\" in the
1137                                  value of `foo-bar-face', even if already
1138                                  highlighted.
1139
1140   (fubar-match 1 fubar-face)     The first subexpression within all
1141                                  occurrences of whatever the function
1142                                  `fubar-match' finds and matches in the value
1143                                  of `fubar-face'.
1144
1145   (\"\\\\\\=<anchor\\\\\\=>\" (0 anchor-face) (\"\\\\\\=<item\\\\\\=>\" nil nil (0 item-face)))
1146    -------------- ---------------  ------------ --- --- -------------
1147        |            |               |            |   |          |
1148    MATCHER          |         ANCHOR-MATCHER     |   +------+ MATCH-HIGHLIGHT
1149              MATCH-HIGHLIGHT                 PRE-MATCH-FORM |
1150                                                            POST-MATCH-FORM
1151
1152   Discrete occurrences of \"anchor\" in the value of `anchor-face', and
1153   subsequent discrete occurrences of \"item\" (on the same line) in the value
1154   of `item-face'.  (Here PRE-MATCH-FORM and POST-MATCH-FORM are nil.
1155   Therefore \"item\" is initially searched for starting from the end of the
1156   match of \"anchor\", and searching for subsequent instance of \"anchor\"
1157   resumes from where searching for \"item\" concluded.)
1158
1159 For highlighting single items, typically only MATCH-HIGHLIGHT is required.
1160 However, if an item or (typically) several items are to be highlighted
1161 following the instance of another item (the anchor) then MATCH-ANCHORED may be
1162 required.
1163
1164 These regular expressions should not match text which spans lines.  While
1165 \\[font-lock-fontify-buffer] handles multi-line patterns correctly, updating when you
1166 edit the buffer does not, since it considers text one line at a time.
1167
1168 Be very careful composing regexps for this list; the wrong pattern can
1169 dramatically slow things down!
1170 ")
1171
1172 (make-variable-buffer-local 'font-lock-keywords)
1173
1174 (defvar font-lock-syntactic-keywords nil "\
1175 A list of the syntactic keywords to highlight.
1176 Can be the list or the name of a function or variable whose value is the list.
1177 See `font-lock-keywords' for a description of the form of this list;
1178 the differences are listed below.  MATCH-HIGHLIGHT should be of the form:
1179
1180  (MATCH SYNTAX OVERRIDE LAXMATCH)
1181
1182 where SYNTAX can be of the form (SYNTAX-CODE . MATCHING-CHAR), the name of a
1183 syntax table, or an expression whose value is such a form or a syntax table.
1184 OVERRIDE cannot be `prepend' or `append'.
1185
1186 For example, an element of the form highlights syntactically:
1187
1188  (\"\\\\$\\\\(#\\\\)\" 1 (1 . nil))
1189
1190  a hash character when following a dollar character, with a SYNTAX-CODE of
1191  1 (meaning punctuation syntax).  Assuming that the buffer syntax table does
1192  specify hash characters to have comment start syntax, the element will only
1193  highlight hash characters that do not follow dollar characters as comments
1194  syntactically.
1195
1196  (\"\\\\('\\\\).\\\\('\\\\)\"
1197   (1 (7 . ?'))
1198   (2 (7 . ?')))
1199
1200  both single quotes which surround a single character, with a SYNTAX-CODE of
1201  7 (meaning string quote syntax) and a MATCHING-CHAR of a single quote (meaning
1202  a single quote matches a single quote).  Assuming that the buffer syntax table
1203  does not specify single quotes to have quote syntax, the element will only
1204  highlight single quotes of the form 'c' as strings syntactically.
1205  Other forms, such as foo'bar or 'fubar', will not be highlighted as strings.
1206
1207 This is normally set via `font-lock-defaults'.")
1208
1209 (make-variable-buffer-local 'font-lock-syntactic-keywords)
1210
1211 (progn (defvar font-lock-mode nil "Non nil means `font-lock-mode' is on") (custom-add-to-group 'font-lock 'font-lock-mode 'custom-variable) (custom-add-load 'font-lock-mode 'font-lock))
1212
1213 (defvar font-lock-mode-hook nil "\
1214 Function or functions to run on entry to font-lock-mode.")
1215
1216 (autoload 'font-lock-mode "font-lock" "\
1217 Toggle Font Lock Mode.
1218 With arg, turn font-lock mode on if and only if arg is positive.
1219
1220 When Font Lock mode is enabled, text is fontified as you type it:
1221
1222  - Comments are displayed in `font-lock-comment-face';
1223  - Strings are displayed in `font-lock-string-face';
1224  - Documentation strings (in Lisp-like languages) are displayed in
1225    `font-lock-doc-string-face';
1226  - Language keywords (\"reserved words\") are displayed in
1227    `font-lock-keyword-face';
1228  - Function names in their defining form are displayed in
1229    `font-lock-function-name-face';
1230  - Variable names in their defining form are displayed in
1231    `font-lock-variable-name-face';
1232  - Type names are displayed in `font-lock-type-face';
1233  - References appearing in help files and the like are displayed
1234    in `font-lock-reference-face';
1235  - Preprocessor declarations are displayed in
1236   `font-lock-preprocessor-face';
1237
1238    and
1239
1240  - Certain other expressions are displayed in other faces according
1241    to the value of the variable `font-lock-keywords'.
1242
1243 Where modes support different levels of fontification, you can use the variable
1244 `font-lock-maximum-decoration' to specify which level you generally prefer.
1245 When you turn Font Lock mode on/off the buffer is fontified/defontified, though
1246 fontification occurs only if the buffer is less than `font-lock-maximum-size'.
1247 To fontify a buffer without turning on Font Lock mode, and regardless of buffer
1248 size, you can use \\[font-lock-fontify-buffer].
1249
1250 See the variable `font-lock-keywords' for customization." t nil)
1251
1252 (autoload 'turn-on-font-lock "font-lock" "\
1253 Unconditionally turn on Font Lock mode." t nil)
1254
1255 (autoload 'turn-off-font-lock "font-lock" "\
1256 Unconditionally turn off Font Lock mode." t nil)
1257
1258 (autoload 'font-lock-fontify-buffer "font-lock" "\
1259 Fontify the current buffer the way `font-lock-mode' would.
1260 See `font-lock-mode' for details.
1261
1262 This can take a while for large buffers." t nil)
1263
1264 (autoload 'font-lock-set-defaults-1 "font-lock" nil nil nil)
1265
1266 (add-minor-mode 'font-lock-mode " Font")
1267
1268 ;;;***
1269 \f
1270 ;;;### (autoloads (font-menu-weight-constructor font-menu-size-constructor font-menu-family-constructor reset-device-font-menus font-menu-this-frame-only-p font-menu-ignore-scaled-fonts) "font-menu" "lisp/font-menu.el")
1271
1272 (defvar font-menu-ignore-scaled-fonts nil "\
1273 *If non-nil, then the font menu will try to show only bitmap fonts.")
1274
1275 (defvar font-menu-this-frame-only-p nil "\
1276 *If non-nil, then changing the default font from the font menu will only
1277 affect one frame instead of all frames.")
1278
1279 (fset 'install-font-menus 'reset-device-font-menus)
1280
1281 (autoload 'reset-device-font-menus "font-menu" "\
1282 Generates the `Font', `Size', and `Weight' submenus for the Options menu.
1283 This is run the first time that a font-menu is needed for each device.
1284 If you don't like the lazy invocation of this function, you can add it to
1285 `create-device-hook' and that will make the font menus respond more quickly
1286 when they are selected for the first time.  If you add fonts to your system,
1287 or if you change your font path, you can call this to re-initialize the menus." nil nil)
1288
1289 (autoload 'font-menu-family-constructor "font-menu" nil nil nil)
1290
1291 (autoload 'font-menu-size-constructor "font-menu" nil nil nil)
1292
1293 (autoload 'font-menu-weight-constructor "font-menu" nil nil nil)
1294
1295 ;;;***
1296 \f
1297 ;;;### (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")
1298
1299 (autoload 'font-create-object "font" "\
1300 Return a font descriptor object for FONTNAME, appropriate for DEVICE." nil nil)
1301
1302 (autoload 'font-default-font-for-device "font" nil nil nil)
1303
1304 (autoload 'font-default-object-for-device "font" nil nil nil)
1305
1306 (autoload 'font-default-family-for-device "font" nil nil nil)
1307
1308 (autoload 'font-default-registry-for-device "font" nil nil nil)
1309
1310 (autoload 'font-default-encoding-for-device "font" nil nil nil)
1311
1312 (autoload 'font-default-size-for-device "font" nil nil nil)
1313
1314 (autoload 'x-font-build-cache "font" nil nil nil)
1315
1316 ;;;***
1317 \f
1318 ;;;### (autoloads (gnuserv-start gnuserv-running-p gnuserv-frame gnuserv-mode-line-string) "gnuserv" "lisp/gnuserv.el")
1319
1320 (defvar gnuserv-mode-line-string " Server" "\
1321 *String to display in the modeline when Gnuserv is active.
1322 Set this to nil if you don't want a modeline indicator.")
1323
1324 (defvar gnuserv-frame nil "\
1325 *The frame to be used to display all edited files.
1326 If nil, then a new frame is created for each file edited.
1327 If t, then the currently selected frame will be used.
1328 If a function, then this will be called with a symbol `x' or `tty' as the
1329 only argument, and its return value will be interpreted as above.")
1330
1331 (autoload 'gnuserv-running-p "gnuserv" "\
1332 Return non-nil if a gnuserv process is running from this XEmacs session." nil nil)
1333
1334 (autoload 'gnuserv-start "gnuserv" "\
1335 Allow this Emacs process to be a server for client processes.
1336 This starts a gnuserv communications subprocess through which
1337 client \"editors\" (gnuclient and gnudoit) can send editing commands to
1338 this Emacs job.  See the gnuserv(1) manual page for more details.
1339
1340 Prefix arg means just kill any existing server communications subprocess." t nil)
1341
1342 ;;;***
1343 \f
1344 ;;;### (autoloads (gtk-font-menu-font-data gtk-reset-device-font-menus) "gtk-font-menu" "lisp/gtk-font-menu.el")
1345
1346 (autoload 'gtk-reset-device-font-menus "gtk-font-menu" "\
1347 Generates the `Font', `Size', and `Weight' submenus for the Options menu.
1348 This is run the first time that a font-menu is needed for each device.
1349 If you don't like the lazy invocation of this function, you can add it to
1350 `create-device-hook' and that will make the font menus respond more quickly
1351 when they are selected for the first time.  If you add fonts to your system, 
1352 or if you change your font path, you can call this to re-initialize the menus." nil nil)
1353
1354 (autoload 'gtk-font-menu-font-data "gtk-font-menu" nil nil nil)
1355
1356 ;;;***
1357 \f
1358 ;;;### (autoloads (three-step-help) "help-macro" "lisp/help-macro.el")
1359
1360 (defvar three-step-help t "\
1361 *Non-nil means give more info about Help command in three steps.
1362 The three steps are simple prompt, prompt with all options,
1363 and window listing and describing the options.
1364 A value of nil means skip the middle step, so that
1365 \\[help-command] \\[help-command] gives the window that lists the options.")
1366
1367 ;;;***
1368 \f
1369 ;;;### (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")
1370
1371 (autoload 'hyper-apropos "hyper-apropos" "\
1372 Display lists of functions and variables matching REGEXP
1373 in buffer \"*Hyper Apropos*\".  If optional prefix arg is given, then the
1374 value of `hyper-apropos-programming-apropos' is toggled for this search.
1375 See also `hyper-apropos-mode'." t nil)
1376
1377 (autoload 'hyper-describe-key "hyper-apropos" nil t nil)
1378
1379 (autoload 'hyper-describe-key-briefly "hyper-apropos" nil t nil)
1380
1381 (autoload 'hyper-describe-face "hyper-apropos" "\
1382 Describe face..
1383 See also `hyper-apropos' and `hyper-describe-function'." t nil)
1384
1385 (autoload 'hyper-describe-variable "hyper-apropos" "\
1386 Hypertext drop-in replacement for `describe-variable'.
1387 See also `hyper-apropos' and `hyper-describe-function'." t nil)
1388
1389 (autoload 'hyper-where-is "hyper-apropos" "\
1390 Print message listing key sequences that invoke specified command." t nil)
1391
1392 (autoload 'hyper-describe-function "hyper-apropos" "\
1393 Hypertext replacement for `describe-function'.  Unlike `describe-function'
1394 in that the symbol under the cursor is the default if it is a function.
1395 See also `hyper-apropos' and `hyper-describe-variable'." t nil)
1396
1397 (autoload 'hyper-apropos-read-variable-symbol "hyper-apropos" "\
1398 Hypertext drop-in replacement for `describe-variable'.
1399 See also `hyper-apropos' and `hyper-describe-function'." nil nil)
1400
1401 (define-obsolete-function-alias 'hypropos-read-variable-symbol 'hyper-apropos-read-variable-symbol)
1402
1403 (define-obsolete-function-alias 'hypropos-get-doc 'hyper-apropos-get-doc)
1404
1405 (autoload 'hyper-set-variable "hyper-apropos" nil t nil)
1406
1407 (autoload 'hyper-apropos-set-variable "hyper-apropos" "\
1408 Interactively set the variable on the current line." t nil)
1409
1410 (define-obsolete-function-alias 'hypropos-set-variable 'hyper-apropos-set-variable)
1411
1412 (autoload 'hyper-apropos-popup-menu "hyper-apropos" nil t nil)
1413
1414 (define-obsolete-function-alias 'hypropos-popup-menu 'hyper-apropos-popup-menu)
1415
1416 ;;;***
1417 \f
1418 ;;;### (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")
1419
1420 (defvar Info-directory-list nil "\
1421 List of directories to search for Info documentation files.
1422
1423 The first directory in this list, the \"dir\" file there will become
1424 the (dir)Top node of the Info documentation tree.
1425
1426 Note: DO NOT use the `customize' interface to change the value of this
1427 variable.  Its value is created dynamically on each startup, depending
1428 on XEmacs packages installed on the system.  If you want to change the
1429 search path, make the needed modifications on the variable's value
1430 from .emacs.  For instance:
1431
1432     (setq Info-directory-list (cons \"~/info\" Info-directory-list))")
1433
1434 (autoload 'info "info" "\
1435 Enter Info, the documentation browser.
1436 Optional argument FILE specifies the file to examine;
1437 the default is the top-level directory of Info.
1438
1439 In interactive use, a prefix argument directs this command
1440 to read a file name from the minibuffer." t nil)
1441
1442 (autoload 'Info-query "info" "\
1443 Enter Info, the documentation browser.  Prompt for name of Info file." t nil)
1444
1445 (autoload 'Info-find-node "info" "\
1446 Go to an info node specified as separate FILENAME and NODENAME.
1447 Look for a plausible filename, or if not found then look for URL's and
1448 dispatch to the appropriate fn.  NO-GOING-BACK is non-nil if
1449 recovering from an error in this function; it says do not attempt
1450 further (recursive) error recovery.  TRYFILE is ??" nil nil)
1451
1452 (autoload 'Info-batch-rebuild-dir "info" "\
1453 (Re)build `dir' files in the directories remaining on the command line.
1454 Use this from the command line, with `-batch', it won't work in an
1455 interactive XEmacs.
1456
1457 Each file is processed even if an error occurred previously. For example,
1458 invoke \"xemacs -batch -f Info-batch-rebuild-dir /usr/local/info\"." nil nil)
1459
1460 (autoload 'Info-goto-node "info" "\
1461 Go to info node named NAME.  Give just NODENAME or (FILENAME)NODENAME.
1462 Actually, the following interpretations of NAME are tried in order:
1463     (FILENAME)NODENAME
1464     (FILENAME)     (using Top node)
1465     NODENAME       (in current file)
1466     TAGNAME        (see below)
1467     FILENAME       (using Top node)
1468 where TAGNAME is a string that appears in quotes: \"TAGNAME\", in an
1469 annotation for any node of any file.  (See `a' and `x' commands.)" t nil)
1470
1471 (autoload 'Info-visit-file "info" "\
1472 Directly visit an info file." t nil)
1473
1474 (autoload 'Info-search "info" "\
1475 Search for REGEXP, starting from point, and select node it's found in." t nil)
1476
1477 (autoload 'Info-emacs-command "info" "\
1478 Look up an Emacs command in the Emacs manual in the Info system.
1479 This command is designed to be used whether you are already in Info or not." t nil)
1480
1481 (autoload 'Info-goto-emacs-command-node "info" "\
1482 Look up an Emacs command in the Emacs manual in the Info system.
1483 This command is designed to be used whether you are already in Info or not." t nil)
1484
1485 (autoload 'Info-goto-emacs-key-command-node "info" "\
1486 Look up an Emacs key sequence in the Emacs manual in the Info system.
1487 This command is designed to be used whether you are already in Info or not." t nil)
1488
1489 (autoload 'Info-emacs-key "info" "\
1490 Look up an Emacs key sequence in the Emacs manual in the Info system.
1491 This command is designed to be used whether you are already in Info or not." t nil)
1492
1493 (autoload 'Info-elisp-ref "info" "\
1494 Look up an Emacs Lisp function in the Elisp manual in the Info system.
1495 This command is designed to be used whether you are already in Info or not." t nil)
1496
1497 ;;;***
1498 \f
1499 ;;;### (autoloads nil "itimer-autosave" "lisp/itimer-autosave.el")
1500
1501 ;;;***
1502 \f
1503 ;;;### (autoloads nil "loaddefs" "lisp/loaddefs.el")
1504
1505 ;;;***
1506 \f
1507 ;;;### (autoloads nil "loadhist" "lisp/loadhist.el")
1508
1509 ;;;***
1510 \f
1511 ;;;### (autoloads (mswindows-font-menu-font-data mswindows-reset-device-font-menus) "msw-font-menu" "lisp/msw-font-menu.el")
1512
1513 (autoload 'mswindows-reset-device-font-menus "msw-font-menu" "\
1514 Generates the `Font', `Size', and `Weight' submenus for the Options menu.
1515 This is run the first time that a font-menu is needed for each device.
1516 If you don't like the lazy invocation of this function, you can add it to
1517 `create-device-hook' and that will make the font menus respond more quickly
1518 when they are selected for the first time.  If you add fonts to your system, 
1519 or if you change your font path, you can call this to re-initialize the menus." nil nil)
1520
1521 (autoload 'mswindows-font-menu-font-data "msw-font-menu" nil nil nil)
1522
1523 ;;;***
1524 \f
1525 ;;;### (autoloads (mwheel-install) "mwheel" "lisp/mwheel.el")
1526
1527 (autoload 'mwheel-install "mwheel" "\
1528 Enable mouse wheel support." t nil)
1529
1530 ;;;***
1531 \f
1532 ;;;### (autoloads (package-admin-add-binary-package) "package-admin" "lisp/package-admin.el")
1533
1534 (autoload 'package-admin-add-binary-package "package-admin" "\
1535 Install a pre-bytecompiled XEmacs package into package hierarchy." t nil)
1536
1537 ;;;***
1538 \f
1539 ;;;### (autoloads (package-get-package-provider package-get package-get-list-packages-where package-get-info 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-site-release-download-sites package-get-pre-release-download-sites package-get-download-sites package-get-install-to-user-init-directory package-get-package-index-file-location) "package-get" "lisp/package-get.el")
1540
1541 (defvar package-get-base nil "\
1542 List of packages that are installed at this site.
1543 For each element in the alist,  car is the package name and the cdr is
1544 a plist containing information about the package.   Typical fields
1545 kept in the plist are:
1546
1547 version         - version of this package
1548 provides        - list of symbols provided
1549 requires        - list of symbols that are required.
1550                   These in turn are provided by other packages.
1551 filename        - name of the file.
1552 size            - size of the file (aka the bundled package)
1553 md5sum          - computed md5 checksum
1554 description     - What this package is for.
1555 type            - Whether this is a 'binary (default) or 'single file package
1556
1557 More fields may be added as needed.  An example:
1558
1559 '(
1560  (name
1561   (version \"<version 2>\"
1562    file \"filename\"
1563    description \"what this package is about.\"
1564    provides (<list>)
1565    requires (<list>)
1566    size <integer-bytes>
1567    md5sum \"<checksum\"
1568    type single
1569    )
1570   (version \"<version 1>\"
1571    file \"filename\"
1572    description \"what this package is about.\"
1573    provides (<list>)
1574    requires (<list>)
1575    size <integer-bytes>
1576    md5sum \"<checksum\"
1577    type single
1578    )
1579    ...
1580    ))
1581
1582 For version information, it is assumed things are listed in most
1583 recent to least recent -- in other words, the version names don't have to
1584 be lexically ordered.  It is debatable if it makes sense to have more than
1585 one version of a package available.")
1586
1587 (defvar package-get-package-index-file-location (car (split-path (or (getenv "EMACSPACKAGEPATH") user-init-directory))) "\
1588 *The directory where the package-index file can be found.")
1589
1590 (defvar package-get-install-to-user-init-directory nil "\
1591 *If non-nil install packages under `user-init-directory'.")
1592
1593 (defvar package-get-download-sites '(("US (Main XEmacs Site)" "ftp.xemacs.org" "pub/xemacs/packages") ("Argentina (xmundo.net)" "xemacs.xmundo.net" "pub/mirrors/xemacs/packages") ("Australia (aarnet.edu.au)" "mirror.aarnet.edu.au" "pub/xemacs/packages") ("Australia (au.xemacs.org)" "ftp.au.xemacs.org" "pub/xemacs/packages") ("Austria (at.xemacs.org)" "ftp.at.xemacs.org" "editors/xemacs/packages") ("Belgium (be.xemacs.org)" "ftp.be.xemacs.org" "xemacs/packages") ("Brazil (br.xemacs.org)" "ftp.br.xemacs.org" "pub/xemacs/packages") ("Canada (ca.xemacs.org)" "ftp.ca.xemacs.org" "pub/Mirror/xemacs/packages") ("Canada (crc.ca)" "ftp.crc.ca" "pub/packages/editors/xemacs/packages") ("Canada (nrc.ca)" "ftp.nrc.ca" "pub/packages/editors/xemacs/packages") ("Czech Republic (cz.xemacs.org)" "ftp.cz.xemacs.org" "MIRRORS/ftp.xemacs.org/pub/xemacs/packages") ("Denmark (dk.xemacs.org)" "ftp.dk.xemacs.org" "xemacs/packages") ("Finland (fi.xemacs.org)" "ftp.fi.xemacs.org" "pub/mirrors/ftp.xemacs.org/pub/tux/xemacs/packages") ("France (fr.xemacs.org)" "ftp.fr.xemacs.org" "pub/xemacs/packages") ("France (mirror.cict.fr)" "mirror.cict.fr" "xemacs/packages") ("France (pasteur.fr)" "ftp.pasteur.fr" "pub/computing/xemacs/packages") ("Germany (de.xemacs.org)" "ftp.de.xemacs.org" "pub/ftp.xemacs.org/tux/xemacs/packages") ("Greece (gr.xemacs.org)" "ftp.gr.xemacs.org" "mirrors/XEmacs/ftp/packages") ("Hong Kong (hk.xemacs.org)" "ftp.hk.xemacs.org" "pub/xemacsftp/packages") ("Ireland (ie.xemacs.org)" "ftp.ie.xemacs.org" "mirrors/ftp.xemacs.org/pub/xemacs/packages") ("Ireland (heanet.ie)" "ftp.heanet.ie" "mirrors/ftp.xemacs.org/packages") ("Italy (it.xemacs.org)" "ftp.it.xemacs.org" "unix/packages/XEMACS/packages") ("Japan (dti.ad.jp)" "ftp.dti.ad.jp" "pub/unix/editor/xemacs/packages") ("Japan (jp.xemacs.org)" "ftp.jp.xemacs.org" "pub/text/xemacs/packages") ("Korea (kr.xemacs.org)" "ftp.kr.xemacs.org" "pub/tools/emacs/xemacs/packages") ("Netherlands (nl.xemacs.org)" "ftp.nl.xemacs.org" "pub/xemacs/ftp/packages") ("Norway (no.xemacs.org)" "ftp.no.xemacs.org" "pub/xemacs/packages") ("Portugal (pt.xemacs.org)" "ftp.pt.xemacs.org" "pub/MIRRORS/ftp.xemacs.org/packages") ("Russia (ru.xemacs.org)" "ftp.ru.xemacs.org" "pub/emacs/xemacs/packages") ("Saudi Arabia (sa.xemacs.org)" "ftp.sa.xemacs.org" "pub/xemacs.org/packages") ("Sweden (se.xemacs.org)" "ftp.se.xemacs.org" "pub/gnu/xemacs/packages") ("Switzerland (ch.xemacs.org)" "ftp.ch.xemacs.org" "mirror/xemacs/packages") ("Taiwan (ftp.tw.xemacs.org)" "ftp.tw.xemacs.org" "Unix/Editors/XEmacs/packages") ("UK (uk.xemacs.org)" "ftp.uk.xemacs.org" "sites/ftp.xemacs.org/pub/xemacs/packages") ("US (ibiblio.org)" "mirrors.ibiblio.org" "pub/mirrors/xemacs/packages") ("US (us.xemacs.org)" "ftp.us.xemacs.org" "pub/mirrors/xemacs/packages")) "\
1594 *List of remote sites available for downloading packages.
1595 List format is '(site-description site-name directory-on-site).
1596 SITE-DESCRIPTION is a textual description of the site.  SITE-NAME
1597 is the internet address of the download site.  DIRECTORY-ON-SITE
1598 is the directory on the site in which packages may be found.
1599 This variable is used to initialize `package-get-remote', the
1600 variable actually used to specify package download sites.")
1601
1602 (defvar package-get-pre-release-download-sites '(("US Pre-Releases (Main XEmacs Site)" "ftp.xemacs.org" "pub/xemacs/beta/experimental/packages") ("Argentina Pre-Releases (xmundo.net)" "xemacs.xmundo.net" "pub/mirrors/xemacs/beta/experimental/packages") ("Australia Pre-Releases (aarnet.edu.au)" "mirror.aarnet.edu.au" "pub/xemacs/beta/experimental/packages") ("Australia Pre-Releases (au.xemacs.org)" "ftp.au.xemacs.org" "pub/xemacs/beta/experimental/packages") ("Austria Pre-Releases (at.xemacs.org)" "ftp.at.xemacs.org" "editors/xemacs/beta/experimental/packages") ("Belgium (be.xemacs.org)" "ftp.be.xemacs.org" "xemacs/beta/experimental/packages") ("Brazil Pre-Releases (br.xemacs.org)" "ftp.br.xemacs.org" "pub/xemacs/xemacs-21.5/experimental/packages") ("Canada Pre-Releases (ca.xemacs.org)" "ftp.ca.xemacs.org" "pub/Mirror/xemacs/beta/experimental/packages") ("Canada Pre-Releases (nrc.ca)" "ftp.nrc.ca" "pub/packages/editors/xemacs/beta/experimental/packages") ("Czech Republic Pre-Releases (cz.xemacs.org)" "ftp.cz.xemacs.org" "MIRRORS/ftp.xemacs.org/pub/xemacs/xemacs-21.5/experimental/packages") ("Denmark Pre-Releases (dk.xemacs.org)" "ftp.dk.xemacs.org" "xemacs/beta/experimental/packages") ("Finland Pre-Releases (fi.xemacs.org)" "ftp.fi.xemacs.org" "pub/mirrors/ftp.xemacs.org/pub/tux/xemacs/beta/experimental/packages") ("France Pre-Releases (fr.xemacs.org)" "ftp.fr.xemacs.org" "pub/xemacs/beta/experimental/packages") ("France Pre-Releases (mirror.cict.fr)" "mirror.cict.fr" "xemacs/beta/experimental/packages") ("France Pre-Releases (pasteur.fr)" "ftp.pasteur.fr" "pub/computing/xemacs/beta/experimental/packages") ("Germany Pre-Releases (de.xemacs.org)" "ftp.de.xemacs.org" "pub/ftp.xemacs.org/tux/xemacs/beta/experimental/packages") ("Greece Pre-Releases (gr.xemacs.org)" "ftp.gr.xemacs.org" "mirrors/XEmacs/ftp/beta/experimental/packages") ("Hong Kong Pre-Releases (hk.xemacs.org)" "ftp.hk.xemacs.org" "pub/xemacsftp/beta/experimental/packages") ("Ireland Pre-Releases (ie.xemacs.org)" "ftp.ie.xemacs.org" "mirrors/ftp.xemacs.org/pub/xemacs/beta/experimental/packages") ("Ireland Pre-Releases (heanet.ie)" "ftp.heanet.ie" "mirrors/ftp.xemacs.org/beta/experimental/packages") ("Italy Pre-Releases (it.xemacs.org)" "ftp.it.xemacs.org" "unix/packages/XEMACS/beta/experimental/packages") ("Japan Pre-Releases (dti.ad.jp)" "ftp.dti.ad.jp" "pub/unix/editor/xemacs/beta/experimental/packages") ("Japan Pre-Releases (jp.xemacs.org)" "ftp.jp.xemacs.org" "pub/text/xemacs/beta/experimental/packages") ("Korea (kr.xemacs.org)" "ftp.kr.xemacs.org" "pub/tools/emacs/xemacs/beta/experimental/packages") ("Netherlands (nl.xemacs.org)" "ftp.nl.xemacs.org" "pub/xemacs/ftp/beta/experimental/packages") ("Norway Pre-Releases (no.xemacs.org)" "ftp.no.xemacs.org" "pub/xemacs/beta/experimental/packages") ("Portugal Pre-Releases (pt.xemacs.org)" "ftp.pt.xemacs.org" "pub/MIRRORS/ftp.xemacs.org/beta/experimental/packages") ("Russia Pre-Releases (ru.xemacs.org)" "ftp.ru.xemacs.org" "pub/emacs/xemacs/beta/experimental/packages") ("Saudi Arabia (sa.xemacs.org)" "ftp.sa.xemacs.org" "pub/xemacs.org/beta/experimental/packages") ("Sweden Pre-Releases (se.xemacs.org)" "ftp.se.xemacs.org" "pub/gnu/xemacs/beta/experimental/packages") ("Switzerland Pre-Releases (ch.xemacs.org)" "ftp.ch.xemacs.org" "mirror/xemacs/beta/experimental/packages") ("Taiwan Pre-Releases (ftp.tw.xemacs.org)" "ftp.tw.xemacs.org" "Unix/Editors/XEmacs/beta/experimental/packages") ("UK Pre-Releases (uk.xemacs.org)" "ftp.uk.xemacs.org" "sites/ftp.xemacs.org/pub/xemacs/beta/experimental/packages") ("US Pre-Releases (ibiblio.org)" "mirrors.ibiblio.org" "pub/mirrors/xemacs/beta/experimental/packages") ("US Pre-Releases (us.xemacs.org)" "ftp.us.xemacs.org" "pub/mirrors/xemacs/beta/experimental/packages")) "\
1603 *List of remote sites available for downloading \"Pre-Release\" packages.
1604 List format is '(site-description site-name directory-on-site).
1605 SITE-DESCRIPTION is a textual description of the site.  SITE-NAME
1606 is the internet address of the download site.  DIRECTORY-ON-SITE
1607 is the directory on the site in which packages may be found.
1608 This variable is used to initialize `package-get-remote', the
1609 variable actually used to specify package download sites.")
1610
1611 (defvar package-get-site-release-download-sites nil "\
1612 *List of remote sites available for downloading \"Site Release\" packages.
1613 List format is '(site-description site-name directory-on-site).
1614 SITE-DESCRIPTION is a textual description of the site.  SITE-NAME
1615 is the internet address of the download site.  DIRECTORY-ON-SITE
1616 is the directory on the site in which packages may be found.
1617 This variable is used to initialize `package-get-remote', the
1618 variable actually used to specify package download sites.")
1619
1620 (autoload 'package-get-require-base "package-get" "\
1621 Require that a package-get database has been loaded.
1622 If the optional FORCE-CURRENT argument or the value of
1623 `package-get-always-update' is Non-nil, try to update the database
1624 from a location in `package-get-remote'. Otherwise a local copy is used
1625 if available and remote access is never done.
1626
1627 Please use FORCE-CURRENT only when the user is explictly dealing with packages
1628 and remote access is likely in the near future." nil nil)
1629
1630 (autoload 'package-get-update-base-entry "package-get" "\
1631 Update an entry in `package-get-base'." nil nil)
1632
1633 (autoload 'package-get-update-base "package-get" "\
1634 Update the package-get database file with entries from DB-FILE.
1635 Unless FORCE-CURRENT is non-nil never try to update the database." t nil)
1636
1637 (autoload 'package-get-update-base-from-buffer "package-get" "\
1638 Update the package-get database with entries from BUFFER.
1639 BUFFER defaults to the current buffer.  This command can be
1640 used interactively, for example from a mail or news buffer." t nil)
1641
1642 (autoload 'package-get-save-base "package-get" "\
1643 Write the package-get database to FILE.
1644
1645 Note: This database will be unsigned of course." t nil)
1646
1647 (autoload 'package-get-delete-package "package-get" "\
1648 Delete an installation of PACKAGE below directory PKG-TOPDIR.
1649 PACKAGE is a symbol, not a string.
1650 This is just an interactive wrapper for `package-admin-delete-binary-package'." t nil)
1651
1652 (autoload 'package-get-update-all "package-get" "\
1653 Fetch and install the latest versions of all currently installed packages." t nil)
1654
1655 (autoload 'package-get-all "package-get" "\
1656 Fetch PACKAGE with VERSION and all other required packages.
1657 Uses `package-get-base' to determine just what is required and what
1658 package provides that functionality.  If VERSION is nil, retrieves
1659 latest version.  Optional argument FETCHED-PACKAGES is used to keep
1660 track of packages already fetched.  Optional argument INSTALL-DIR,
1661 if non-nil, specifies the package directory where fetched packages
1662 should be installed.
1663
1664 Returns nil upon error." t nil)
1665
1666 (autoload 'package-get-dependencies "package-get" "\
1667 Compute dependencies for PACKAGES.
1668 Uses `package-get-base' to determine just what is required and what
1669 package provides that functionality.  Returns the list of packages
1670 required by PACKAGES." nil nil)
1671
1672 (autoload 'package-get-info "package-get" "\
1673 Get information about a package.
1674
1675 Quite similar to `package-get-info-prop', but can retrieve a lot more
1676 information.
1677
1678 Argument PACKAGE is the name of an XEmacs package (a symbol).  It must
1679 be a valid package, ie, a member of `package-get-base'.
1680
1681 Argument INFORMATION is a symbol that can be any one of:
1682
1683    standards-version     Package system version (not used).
1684    version               Version of the XEmacs package.
1685    author-version        The upstream version of the package.
1686    date                  The date the package was last modified.
1687    build-date            The date the package was last built.
1688    maintainer            The maintainer of the package.
1689    distribution          Will always be \"xemacs\" (not used).
1690    priority              \"low\", \"medium\", or \"high\" (not used).
1691    category              Either \"standard\", \"mule\", or \"unsupported\"..
1692    dump                  Is the package dumped (not used).
1693    description           A description of the package.
1694    filename              The filename of the binary tarball of the package.
1695    md5sum                The md5sum of filename.
1696    size                  The size in bytes of filename.
1697    provides              A list of symbols that this package provides.
1698    requires              A list of packages that this package requires.
1699    type                  Can be either \"regular\" or \"single-file\".
1700
1701 If optional argument ARG is non-nil insert INFORMATION into current
1702 buffer at point.  This is very useful for doing things like inserting
1703 a maintainer's email address into a mail buffer.
1704
1705 If optional argument REMOTE is non-nil use a package list from a
1706 remote site.  For this to work `package-get-remote' must be non-nil.
1707
1708 If this function is called interactively it will display INFORMATION
1709 in the minibuffer." t nil)
1710
1711 (autoload 'package-get-list-packages-where "package-get" "\
1712 Return a list of packages that fulfill certain criteria.
1713
1714 Argument ITEM, a symbol, is what you want to check for.  ITEM must be a
1715 symbol even when it doesn't make sense to be a symbol (think, searching
1716 maintainers, descriptions, etc).  The function will convert the symbol
1717 to a string if a string is what is needed.  The downside to this is that
1718 ITEM can only ever be a single word.
1719
1720 Argument FIELD, a symbol, is the field to check in.  You can specify
1721 any one of:
1722
1723       Field            Sane or Allowable Content
1724     description          any single word
1725     category             `standard' or `mule'
1726     maintainer           any single word
1727     build-date           yyyy-mm-dd
1728     date                 yyyy-mm-dd
1729     type                 `regular' or `single'
1730     requires             any package name
1731     provides             any symbol
1732     priority             `low', `medium', or `high'
1733
1734 Optional Argument ARG, a prefix arg, insert output at point in the
1735 current buffer." t nil)
1736
1737 (autoload 'package-get "package-get" "\
1738 Fetch PACKAGE from remote site.
1739 Optional arguments VERSION indicates which version to retrieve, nil
1740 means most recent version.  CONFLICT indicates what happens if the
1741 package is already installed.  Valid values for CONFLICT are:
1742 'always always retrieve the package even if it is already installed
1743 'never  do not retrieve the package if it is installed.
1744 INSTALL-DIR, if non-nil, specifies the package directory where
1745 fetched packages should be installed.
1746
1747 The value of `package-get-base' is used to determine what files should
1748 be retrieved.  The value of `package-get-remote' is used to determine
1749 where a package should be retrieved from.
1750
1751 Once the package is retrieved, its md5 checksum is computed.  If that
1752 sum does not match that stored in `package-get-base' for this version
1753 of the package, an error is signalled.
1754
1755 Returns `t' upon success, the symbol `error' if the package was
1756 successfully installed but errors occurred during initialization, or
1757 `nil' upon error." t nil)
1758
1759 (autoload 'package-get-package-provider "package-get" "\
1760 Search for a package that provides SYM and return the name and
1761   version.  Searches in `package-get-base' for SYM.   If SYM is a
1762   consp, then it must match a corresponding (provide (SYM VERSION)) from
1763   the package.
1764
1765 If FORCE-CURRENT is non-nil make sure the database is up to date. This might
1766 lead to Emacs accessing remote sites." t nil)
1767
1768 ;;;***
1769 \f
1770 ;;;### (autoloads (package-net-update-installed-db package-net-setup-directory) "package-net" "lisp/package-net.el")
1771
1772 (autoload 'package-net-setup-directory "package-net" nil nil nil)
1773
1774 (autoload 'package-net-update-installed-db "package-net" "\
1775 Write out the installed package index in a net install suitable format.
1776 If DESTDIR is non-nil then use that as the destination directory. 
1777 DESTDIR defaults to the value of `package-net-setup-directory'." nil nil)
1778
1779 ;;;***
1780 \f
1781 ;;;### (autoloads (pui-list-packages pui-set-local-package-get-directory package-ui-site-release-download-menu package-ui-pre-release-download-menu package-ui-download-menu package-ui-add-site) "package-ui" "lisp/package-ui.el")
1782
1783 (autoload 'package-ui-add-site "package-ui" "\
1784 Add site to package-get-remote and possibly offer to update package list." nil nil)
1785
1786 (autoload 'package-ui-download-menu "package-ui" "\
1787 Build the `Add Download Site' menu." nil nil)
1788
1789 (autoload 'package-ui-pre-release-download-menu "package-ui" "\
1790 Build the 'Pre-Release Download Sites' menu." nil nil)
1791
1792 (autoload 'package-ui-site-release-download-menu "package-ui" "\
1793 Build the 'Site Release Download Sites' menu." nil nil)
1794
1795 (autoload 'pui-set-local-package-get-directory "package-ui" "\
1796 Set a new package binary directory in `package-get-remote'.
1797 Note that no provision is made for saving any changes made by this function.
1798 It exists mainly as a convenience for one-time package installations from
1799 disk." t nil)
1800
1801 (autoload 'pui-list-packages "package-ui" "\
1802 List all packages and package information.
1803 The package name, version, and description are displayed.  From the displayed
1804 buffer, the user can see which packages are installed, which are not, and
1805 which are out-of-date (a newer version is available).  The user can then
1806 select packages for installation via the keyboard or mouse." t nil)
1807
1808 (defalias 'list-packages 'pui-list-packages)
1809
1810 ;;;***
1811 \f
1812 ;;;### (autoloads (picture-mode) "picture" "lisp/picture.el")
1813
1814 (autoload 'picture-mode "picture" "\
1815 Switch to Picture mode, in which a quarter-plane screen model is used.
1816 Printing characters replace instead of inserting themselves with motion
1817 afterwards settable by these commands:
1818   C-c <   Move left after insertion.
1819   C-c >   Move right after insertion.
1820   C-c ^   Move up after insertion.
1821   C-c .   Move down after insertion.
1822   C-c `   Move northwest (nw) after insertion.
1823   C-c '   Move northeast (ne) after insertion.
1824   C-c /   Move southwest (sw) after insertion.
1825   C-c \\   Move southeast (se) after insertion.
1826 The current direction is displayed in the modeline.  The initial
1827 direction is right.  Whitespace is inserted and tabs are changed to
1828 spaces when required by movement.  You can move around in the buffer
1829 with these commands:
1830   \\[picture-move-down]   Move vertically to SAME column in previous line.
1831   \\[picture-move-up]     Move vertically to SAME column in next line.
1832   \\[picture-end-of-line]         Move to column following last non-whitespace character.
1833   \\[picture-forward-column]      Move right inserting spaces if required.
1834   \\[picture-backward-column]     Move left changing tabs to spaces if required.
1835   C-c C-f Move in direction of current picture motion.
1836   C-c C-b Move in opposite direction of current picture motion.
1837   Return  Move to beginning of next line.
1838 You can edit tabular text with these commands:
1839   M-Tab   Move to column beneath (or at) next interesting character.
1840             `Indents' relative to a previous line.
1841   Tab     Move to next stop in tab stop list.
1842   C-c Tab Set tab stops according to context of this line.
1843             With ARG resets tab stops to default (global) value.
1844             See also documentation of variable  picture-tab-chars
1845             which defines \"interesting character\".  You can manually
1846             change the tab stop list with command \\[edit-tab-stops].
1847 You can manipulate text with these commands:
1848   C-d     Clear (replace) ARG columns after point without moving.
1849   C-c C-d Delete char at point - the command normally assigned to C-d.
1850   \\[picture-backward-clear-column]  Clear (replace) ARG columns before point, moving back over them.
1851   \\[picture-clear-line]          Clear ARG lines, advancing over them.  The cleared
1852             text is saved in the kill ring.
1853   \\[picture-open-line]   Open blank line(s) beneath current line.
1854 You can manipulate rectangles with these commands:
1855   C-c C-k Clear (or kill) a rectangle and save it.
1856   C-c C-w Like C-c C-k except rectangle is saved in named register.
1857   C-c C-y Overlay (or insert) currently saved rectangle at point.
1858   C-c C-x Like C-c C-y except rectangle is taken from named register.
1859   \\[copy-rectangle-to-register]   Copies a rectangle to a register.
1860   \\[advertised-undo]   Can undo effects of rectangle overlay commands
1861             commands if invoked soon enough.
1862 You can return to the previous mode with:
1863   C-c C-c Which also strips trailing whitespace from every line.
1864             Stripping is suppressed by supplying an argument.
1865
1866 Entry to this mode calls the value of  picture-mode-hook  if non-nil.
1867
1868 Note that Picture mode commands will work outside of Picture mode, but
1869 they are not defaultly assigned to keys." t nil)
1870
1871 (defalias 'edit-picture 'picture-mode)
1872
1873 ;;;***
1874 \f
1875 ;;;### (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")
1876
1877 (autoload 'delete-rectangle "rect" "\
1878 Delete the text in the region-rectangle without saving it.
1879 The same range of columns is deleted in each line starting with the line
1880 where the region begins and ending with the line where the region ends.
1881
1882 When called from a program, the rectangle's corners are START and END.
1883 With a prefix (or FILL) argument, also fill lines where nothing has to be
1884 deleted." t nil)
1885
1886 (autoload 'delete-extract-rectangle "rect" "\
1887 Delete the contents of the rectangle with corners at START and END, and
1888 return it as a list of strings, one for each line of the rectangle.
1889
1890 With an optional FILL argument, also fill lines where nothing has to be
1891 deleted." nil nil)
1892
1893 (autoload 'extract-rectangle "rect" "\
1894 Return the contents of the rectangle with corners at START and END,
1895 as a list of strings, one for each line of the rectangle." nil nil)
1896
1897 (defvar killed-rectangle nil "\
1898 Rectangle for `yank-rectangle' to insert.")
1899
1900 (autoload 'kill-rectangle "rect" "\
1901 Delete the region-rectangle and save it as the last killed one.
1902 You might prefer to use `delete-extract-rectangle' from a program.
1903
1904 When called from a program, the rectangle's corners are START and END.
1905 With a prefix (or FILL) argument, also fill lines where nothing has to be
1906 deleted." t nil)
1907
1908 (autoload 'yank-rectangle "rect" "\
1909 Yank the last killed rectangle with upper left corner at point." t nil)
1910
1911 (autoload 'insert-rectangle "rect" "\
1912 Insert text of RECTANGLE with upper left corner at point.
1913 RECTANGLE's first line is inserted at point, its second
1914 line is inserted at a point vertically under point, etc.
1915 RECTANGLE should be a list of strings.
1916 After this command, the mark is at the upper left corner
1917 and point is at the lower right corner." nil nil)
1918
1919 (autoload 'open-rectangle "rect" "\
1920 Blank out the region-rectangle, shifting text right.
1921
1922 When called from a program, the rectangle's corners are START and END.
1923 With a prefix (or FILL) argument, fill with blanks even if there is no text
1924 on the right side of the rectangle." t nil)
1925
1926 (autoload 'string-rectangle "rect" "\
1927 Insert STRING on each line of the region-rectangle, shifting text right.
1928 The left edge of the rectangle specifies the column for insertion.
1929
1930 If `pending-delete-mode' is active the string replace the region.
1931 Otherwise this command does not delete or overwrite any existing text.
1932
1933 When called from a program, the rectangle's corners are START and END." t nil)
1934
1935 (autoload 'replace-rectangle "rect" "\
1936 Like `string-rectangle', but unconditionally replace the original region,
1937 as if `pending-delete-mode' were active." t nil)
1938
1939 (autoload 'clear-rectangle "rect" "\
1940 Blank out the region-rectangle.
1941 The text previously in the region is overwritten with blanks.
1942
1943 When called from a program, the rectangle's corners are START and END.
1944 With a prefix (or FILL) argument, also fill with blanks the parts of the
1945 rectangle which were empty." t nil)
1946
1947 ;;;***
1948 \f
1949 ;;;### (autoloads (list-load-path-shadows) "shadow" "lisp/shadow.el")
1950
1951 (autoload 'list-load-path-shadows "shadow" "\
1952 Display a list of Emacs Lisp files that shadow other files.
1953
1954 This function lists potential load-path problems.  Directories in the
1955 `load-path' variable are searched, in order, for Emacs Lisp
1956 files.  When a previously encountered file name is found again, a
1957 message is displayed indicating that the later file is \"hidden\" by
1958 the earlier.
1959
1960 For example, suppose `load-path' is set to
1961
1962 \(\"/usr/gnu/emacs/site-lisp\" \"/usr/gnu/emacs/share/emacs/19.30/lisp\")
1963
1964 and that each of these directories contains a file called XXX.el.  Then
1965 XXX.el in the site-lisp directory is referred to by all of:
1966 \(require 'XXX), (autoload .... \"XXX\"), (load-library \"XXX\") etc.
1967
1968 The first XXX.el file prevents emacs from seeing the second (unless
1969 the second is loaded explicitly via load-file).
1970
1971 When not intended, such shadowings can be the source of subtle
1972 problems.  For example, the above situation may have arisen because the
1973 XXX package was not distributed with versions of emacs prior to
1974 19.30.  An emacs maintainer downloaded XXX from elsewhere and installed
1975 it.  Later, XXX was updated and included in the emacs distribution.
1976 Unless the emacs maintainer checks for this, the new version of XXX
1977 will be hidden behind the old (which may no longer work with the new
1978 emacs version).
1979
1980 This function performs these checks and flags all possible
1981 shadowings.  Because a .el file may exist without a corresponding .elc
1982 \(or vice-versa), these suffixes are essentially ignored.  A file
1983 XXX.elc in an early directory (that does not contain XXX.el) is
1984 considered to shadow a later file XXX.el, and vice-versa.
1985
1986 When run interactively, the shadowings (if any) are displayed in a
1987 buffer called `*Shadows*'.  Shadowings are located by calling the
1988 \(non-interactive) companion function, `find-emacs-lisp-shadows'." t nil)
1989
1990 ;;;***
1991 \f
1992 ;;;### (autoloads (load-default-sounds load-sound-file) "sound" "lisp/sound.el")
1993
1994 (or sound-alist (setq sound-alist '((ready nil) (warp nil))))
1995
1996 (autoload 'load-sound-file "sound" "\
1997 Read in an audio-file and add it to the sound-alist.
1998
1999 FILENAME can either be absolute or relative, in which case the file will
2000 be searched in the directories given by `default-sound-directory-list'.
2001 When looking for the file, the extensions given by `sound-extension-list' are
2002 also tried in the given order.
2003
2004 You can only play sound files if you are running on display 0 of the
2005 console of a machine with native sound support or running a NetAudio
2006 server and XEmacs has the necessary sound support compiled in.
2007
2008 The sound file must be in the Sun/NeXT U-LAW format, except on Linux,
2009 where .wav files are also supported by the sound card drivers." t nil)
2010
2011 (autoload 'load-default-sounds "sound" "\
2012 Load and install some sound files as beep-types, using
2013 `load-sound-file'.  This only works if you're on display 0 of the
2014 console of a machine with native sound support or running a NetAudio
2015 server and XEmacs has the necessary sound support compiled in." t nil)
2016
2017 ;;;***
2018 \f
2019 ;;;### (autoloads (ask-user-about-supersession-threat ask-user-about-lock) "userlock" "lisp/userlock.el")
2020
2021 (autoload 'ask-user-about-lock "userlock" "\
2022 Ask user wanting to edit FILENAME, locked by OTHER-USER, what to do.
2023 This function has a choice of three things to do:
2024   do (signal 'file-locked (list FILENAME OTHER-USER))
2025     to refrain from editing the file
2026   return t (grab the lock on the file)
2027   return nil (edit the file even though it is locked).
2028 You can rewrite it to use any criteria you like to choose which one to do." nil nil)
2029
2030 (autoload 'ask-user-about-supersession-threat "userlock" "\
2031 Ask user who is about to modify an obsolete buffer what to do.
2032 This function has two choices: it can return, in which case the modification
2033 of the buffer will proceed, or it can (signal 'file-supersession (FILENAME)),
2034 in which case the proposed buffer modification will not be made.
2035
2036 You can rewrite this to use any criteria you like to choose which one to do.
2037 The buffer in question is current when this function is called." nil nil)
2038
2039 ;;;***
2040 \f
2041 ;;;### (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")
2042
2043 (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))
2044
2045 (defvar view-mode-map (let ((map (copy-keymap view-minor-mode-map))) (set-keymap-name map 'view-mode-map) map))
2046
2047 (autoload 'view-file "view-less" "\
2048 Find FILENAME, enter view mode.  With prefix arg OTHER-WINDOW-P, use other window." t nil)
2049
2050 (autoload 'view-buffer "view-less" "\
2051 Switch to BUFFER, enter view mode.  With prefix arg use other window." t nil)
2052
2053 (autoload 'view-file-other-window "view-less" "\
2054 Find FILENAME in other window, and enter view mode." t nil)
2055
2056 (autoload 'view-buffer-other-window "view-less" "\
2057 Switch to BUFFER in another window, and enter view mode." t nil)
2058
2059 (autoload 'view-minor-mode "view-less" "\
2060 Minor mode for viewing text, with bindings like `less'.
2061 Commands are:
2062 \\<view-minor-mode-map>
2063 0..9    prefix args
2064 -       prefix minus
2065 \\[scroll-up]   page forward
2066 \\[scroll-down] page back
2067 \\[view-scroll-lines-up]        scroll prefix-arg lines forward, default 1.
2068 \\[view-scroll-lines-down]      scroll prefix-arg lines backward, default 1.
2069 \\[view-scroll-some-lines-down] scroll prefix-arg lines backward, default 10.
2070 \\[view-scroll-some-lines-up]   scroll prefix-arg lines forward, default 10.
2071 \\[what-line]   print line number
2072 \\[view-mode-describe]  print this help message
2073 \\[view-search-forward] regexp search, uses previous string if you just hit RET
2074 \\[view-search-backward]        as above but searches backward
2075 \\[view-repeat-search]  repeat last search
2076 \\[view-goto-line]      goto line prefix-arg, default 1
2077 \\[view-last-windowful] goto line prefix-arg, default last line
2078 \\[view-goto-percent]   goto a position by percentage
2079 \\[toggle-truncate-lines]       toggle truncate-lines
2080 \\[view-file]   view another file
2081 \\[view-buffer] view another buffer
2082 \\[view-cleanup-backspaces]     cleanup backspace constructions
2083 \\[shell-command]       execute a shell command
2084 \\[shell-command-on-region]     execute a shell command with the region as input
2085 \\[view-quit]   exit view-mode, and bury the current buffer.
2086
2087 If invoked with the optional (prefix) arg non-nil, view-mode cleans up
2088 backspace constructions.
2089
2090 More precisely:
2091 \\{view-minor-mode-map}" t nil)
2092
2093 (autoload 'view-mode "view-less" "\
2094 View the current buffer using view-minor-mode.  This exists to be 99.9%
2095 compatible with the implementations of `view-mode' in view.el and older
2096 versions of view-less.el." t nil)
2097
2098 (autoload 'view-major-mode "view-less" "\
2099 View the current buffer using view-mode, as a major mode.
2100 This function has a nonstandard name because `view-mode' is wrongly
2101 named but is like this for compatibility reasons." t nil)
2102
2103 (autoload 'auto-view-mode "view-less" "\
2104 If the file of the current buffer is not writable, call view-mode.
2105 This is meant to be added to `find-file-hooks'." nil nil)
2106
2107 (autoload 'toggle-truncate-lines "view-less" "\
2108 Toggles the values of truncate-lines.
2109 Positive prefix arg sets, negative disables." t nil)
2110
2111 ;;;***
2112 \f
2113 ;;;### (autoloads (widget-minor-mode widget-browse-other-window widget-browse widget-browse-at) "wid-browse" "lisp/wid-browse.el")
2114
2115 (autoload 'widget-browse-at "wid-browse" "\
2116 Browse the widget under point." t nil)
2117
2118 (autoload 'widget-browse "wid-browse" "\
2119 Create a widget browser for WIDGET." t nil)
2120
2121 (autoload 'widget-browse-other-window "wid-browse" "\
2122 Show widget browser for WIDGET in other window." t nil)
2123
2124 (autoload 'widget-minor-mode "wid-browse" "\
2125 Togle minor mode for traversing widgets.
2126 With arg, turn widget mode on if and only if arg is positive." t nil)
2127
2128 ;;;***
2129 \f
2130 ;;;### (autoloads (widget-delete widget-create widget-prompt-value) "wid-edit" "lisp/wid-edit.el")
2131
2132 (autoload 'widget-prompt-value "wid-edit" "\
2133 Prompt for a value matching WIDGET, using PROMPT.
2134 The current value is assumed to be VALUE, unless UNBOUND is non-nil." nil nil)
2135
2136 (autoload 'widget-create "wid-edit" "\
2137 Create widget of TYPE.
2138 The optional ARGS are additional keyword arguments." nil nil)
2139
2140 (autoload 'widget-delete "wid-edit" "\
2141 Delete WIDGET." nil nil)
2142
2143 ;;;***
2144 \f
2145 ;;;### (autoloads (x-font-menu-font-data x-reset-device-font-menus) "x-font-menu" "lisp/x-font-menu.el")
2146
2147 (autoload 'x-reset-device-font-menus "x-font-menu" "\
2148 Generates the `Font', `Size', and `Weight' submenus for the Options menu.
2149 This is run the first time that a font-menu is needed for each device.
2150 If you don't like the lazy invocation of this function, you can add it to
2151 `create-device-hook' and that will make the font menus respond more quickly
2152 when they are selected for the first time.  If you add fonts to your system, 
2153 or if you change your font path, you can call this to re-initialize the menus." nil nil)
2154
2155 (autoload 'x-font-menu-font-data "x-font-menu" nil nil nil)
2156
2157 ;;;***
2158 \f
2159 ;;;### (autoloads (x-win-init-sun) "x-win-sun" "lisp/x-win-sun.el")
2160
2161 (autoload 'x-win-init-sun "x-win-sun" nil nil nil)
2162
2163 ;;;***
2164 \f
2165 ;;;### (autoloads (x-win-init-xfree86) "x-win-xfree86" "lisp/x-win-xfree86.el")
2166
2167 (autoload 'x-win-init-xfree86 "x-win-xfree86" nil nil nil)
2168
2169 ;;;***
2170
2171 (provide 'lisp-autoloads)