\f
;;;### (autoloads (5x5-crack 5x5-crack-xor-mutate 5x5-crack-mutating-best
;;;;;; 5x5-crack-mutating-current 5x5-crack-randomly 5x5) "5x5"
-;;;;;; "play/5x5.el" (19968 28627))
+;;;;;; "play/5x5.el" (20244 35516))
;;; Generated autoloads from play/5x5.el
(autoload '5x5 "5x5" "\
;;;***
\f
;;;### (autoloads (ada-mode ada-add-extensions) "ada-mode" "progmodes/ada-mode.el"
-;;;;;; (19890 42850))
+;;;;;; (20428 57510))
;;; Generated autoloads from progmodes/ada-mode.el
(autoload 'ada-add-extensions "ada-mode" "\
;;;***
\f
;;;### (autoloads (ada-header) "ada-stmt" "progmodes/ada-stmt.el"
-;;;;;; (19845 45374))
+;;;;;; (20244 35516))
;;; Generated autoloads from progmodes/ada-stmt.el
(autoload 'ada-header "ada-stmt" "\
;;;***
\f
;;;### (autoloads (ada-find-file) "ada-xref" "progmodes/ada-xref.el"
-;;;;;; (19890 42850))
+;;;;;; (20356 35090))
;;; Generated autoloads from progmodes/ada-xref.el
(autoload 'ada-find-file "ada-xref" "\
;;;;;; add-change-log-entry-other-window add-change-log-entry find-change-log
;;;;;; prompt-for-change-log-name add-log-mailing-address add-log-full-name
;;;;;; add-log-current-defun-function) "add-log" "vc/add-log.el"
-;;;;;; (20033 22846))
+;;;;;; (20356 35090))
;;; Generated autoloads from vc/add-log.el
(put 'change-log-default-name 'safe-local-variable 'string-or-null-p)
\(fn)" t nil)
(defvar add-log-lisp-like-modes '(emacs-lisp-mode lisp-mode scheme-mode dsssl-mode lisp-interaction-mode) "\
-*Modes that look like Lisp to `add-log-current-defun'.")
+Modes that look like Lisp to `add-log-current-defun'.")
(defvar add-log-c-like-modes '(c-mode c++-mode c++-c-mode objc-mode) "\
-*Modes that look like C to `add-log-current-defun'.")
+Modes that look like C to `add-log-current-defun'.")
(defvar add-log-tex-like-modes '(TeX-mode plain-TeX-mode LaTeX-mode tex-mode) "\
-*Modes that look like TeX to `add-log-current-defun'.")
+Modes that look like TeX to `add-log-current-defun'.")
(autoload 'add-log-current-defun "add-log" "\
Return name of function definition point is in, or nil.
\f
;;;### (autoloads (defadvice ad-activate ad-add-advice ad-disable-advice
;;;;;; ad-enable-advice ad-default-compilation-action ad-redefinition-action)
-;;;;;; "advice" "emacs-lisp/advice.el" (19931 11784))
+;;;;;; "advice" "emacs-lisp/advice.el" (20290 33419))
;;; Generated autoloads from emacs-lisp/advice.el
(defvar ad-redefinition-action 'warn "\
[DOCSTRING] [INTERACTIVE-FORM]
BODY...)
-\(fn FUNCTION ARGS &rest BODY)" nil (quote macro))
+\(fn FUNCTION ARGS &rest BODY)" nil t)
(put 'defadvice 'doc-string-elt '3)
\f
;;;### (autoloads (align-newline-and-indent align-unhighlight-rule
;;;;;; align-highlight-rule align-current align-entire align-regexp
-;;;;;; align) "align" "align.el" (19886 45771))
+;;;;;; align) "align" "align.el" (20244 35516))
;;; Generated autoloads from align.el
(autoload 'align "align" "\
\f
;;;### (autoloads (outlineify-sticky allout-mode allout-mode-p allout-auto-activation
;;;;;; allout-setup allout-auto-activation-helper) "allout" "allout.el"
-;;;;;; (19988 13913))
+;;;;;; (20412 11425))
;;; Generated autoloads from allout.el
(autoload 'allout-auto-activation-helper "allout" "\
\(fn VAR VALUE)" nil nil)
(autoload 'allout-setup "allout" "\
-Do fundamental emacs session for allout auto-activation.
+Do fundamental Emacs session for allout auto-activation.
Establishes allout processing as part of visiting a file if
`allout-auto-activation' is non-nil, or removes it otherwise.
(autoload 'allout-mode-p "allout" "\
Return t if `allout-mode' is active in current buffer.
-\(fn)" nil (quote macro))
+\(fn)" nil t)
(autoload 'allout-mode "allout" "\
-Toggle minor mode for controlling exposure and editing of text outlines.
-\\<allout-mode-map-value>
-
-Allout outline mode always runs as a minor mode.
+Toggle Allout outline mode.
+With a prefix argument ARG, enable Allout outline mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+the mode if ARG is omitted or nil.
-Allout outline mode provides extensive outline oriented
-formatting and manipulation. It enables structural editing of
-outlines, as well as navigation and exposure. It also is
-specifically aimed at accommodating syntax-sensitive text like
-programming languages. (For example, see the allout code itself,
-which is organized as an allout outline.)
+\\<allout-mode-map-value>
+Allout outline mode is a minor mode that provides extensive
+outline oriented formatting and manipulation. It enables
+structural editing of outlines, as well as navigation and
+exposure. It also is specifically aimed at accommodating
+syntax-sensitive text like programming languages. (For example,
+see the allout code itself, which is organized as an allout
+outline.)
In addition to typical outline navigation and exposure, allout includes:
of special `allout-mode' features and terminology. See also the
outline menubar additions for quick reference to many of the
features. Customize `allout-auto-activation' to prepare your
-emacs session for automatic activation of `allout-mode'.
+Emacs session for automatic activation of `allout-mode'.
The bindings are those listed in `allout-prefixed-keybindings'
and `allout-unprefixed-keybindings'. We recommend customizing
\\[allout-rebullet-current-heading] `allout-rebullet-current-heading' Prompt for alternate bullet for
current topic
\\[allout-rebullet-topic] `allout-rebullet-topic' Reconcile bullets of topic and
- its' offspring -- distinctive bullets are not changed, others
+ its offspring -- distinctive bullets are not changed, others
are alternated according to nesting depth.
\\[allout-number-siblings] `allout-number-siblings' Number bullets of topic and siblings --
the offspring are not affected.
----------------------------------
\\[allout-kill-topic] `allout-kill-topic' Kill current topic, including offspring.
\\[allout-copy-topic-as-kill] `allout-copy-topic-as-kill' Copy current topic, including offspring.
-\\[allout-kill-line] `allout-kill-line' kill-line, attending to outline structure.
+\\[allout-kill-line] `allout-kill-line' Kill line, attending to outline structure.
\\[allout-copy-line-as-kill] `allout-copy-line-as-kill' Copy line but don't delete it.
\\[allout-yank] `allout-yank' Yank, adjusting depth of yanked topic to
depth of heading if yanking into bare topic
heading (ie, prefix sans text).
-\\[allout-yank-pop] `allout-yank-pop' Is to allout-yank as yank-pop is to yank
+\\[allout-yank-pop] `allout-yank-pop' Is to `allout-yank' as `yank-pop' is to `yank'.
Topic-oriented Encryption:
-------------------------
Extending Allout
-Allout exposure and authoring activites all have associated
+Allout exposure and authoring activities all have associated
hooks, by which independent code can cooperate with allout
without changes to the allout core. Here are key ones:
`allout-mode-hook'
`allout-mode-deactivate-hook' (deprecated)
`allout-mode-off-hook'
-`allout-exposure-change-hook'
-`allout-structure-added-hook'
-`allout-structure-deleted-hook'
-`allout-structure-shifted-hook'
+`allout-exposure-change-functions'
+`allout-structure-added-functions'
+`allout-structure-deleted-functions'
+`allout-structure-shifted-functions'
`allout-after-copy-or-kill-hook'
`allout-post-undo-hook'
When the PREFIX-LEAD is set to the comment-string of a
programming language, outline structuring can be embedded in
program code without interfering with processing of the text
- (by emacs or the language processor) as program code. This
+ (by Emacs or the language processor) as program code. This
setting happens automatically when allout mode is used in
programming-mode buffers. See `allout-use-mode-specific-leader'
docstring for more detail.
`allout-distinctive-bullets-string'. When creating a TOPIC,
plain BULLETs are by default used, according to the DEPTH of the
TOPIC. Choice among the distinctive BULLETs is offered when you
- provide a universal argugment (\\[universal-argument]) to the
- TOPIC creation command, or when explictly rebulleting a TOPIC. The
+ provide a universal argument (\\[universal-argument]) to the
+ TOPIC creation command, or when explicitly rebulleting a TOPIC. The
significance of the various distinctive bullets is purely by
convention. See the documentation for the above bullet strings for
more details.
Activate outline mode and establish file var so it is started subsequently.
See `allout-layout' and customization of `allout-auto-activation'
-for details on preparing emacs for automatic allout activation.
+for details on preparing Emacs for automatic allout activation.
\(fn &optional ARG)" t nil)
\f
;;;### (autoloads (allout-widgets-mode allout-widgets-auto-activation
;;;;;; allout-widgets-setup allout-widgets) "allout-widgets" "allout-widgets.el"
-;;;;;; (19988 13913))
+;;;;;; (20438 17064))
;;; Generated autoloads from allout-widgets.el
(let ((loads (get 'allout-widgets 'custom-loads))) (if (member '"allout-widgets" loads) nil (put 'allout-widgets 'custom-loads (cons '"allout-widgets" loads))))
(autoload 'allout-widgets-setup "allout-widgets" "\
-Commission or decommision allout-widgets-mode along with allout-mode.
+Commission or decommission allout-widgets-mode along with allout-mode.
Meant to be used by customization of `allout-widgets-auto-activation'.
(put 'allout-widgets-mode-inhibit 'safe-local-variable (if (fboundp 'booleanp) 'booleanp (lambda (x) (member x '(t nil)))))
(autoload 'allout-widgets-mode "allout-widgets" "\
-Allout-mode extension, providing graphical decoration of outline structure.
-
-This is meant to operate along with allout-mode, via `allout-mode-hook'.
+Toggle Allout Widgets mode.
+With a prefix argument ARG, enable Allout Widgets mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+the mode if ARG is omitted or nil.
-If optional argument ARG is greater than 0, enable.
-If optional argument ARG is less than 0, disable.
-Anything else, toggle between active and inactive.
+Allout Widgets mode is an extension of Allout mode that provides
+graphical decoration of outline structure. It is meant to
+operate along with `allout-mode', via `allout-mode-hook'.
The graphics include:
;;;***
\f
;;;### (autoloads (ange-ftp-hook-function ange-ftp-reread-dir) "ange-ftp"
-;;;;;; "net/ange-ftp.el" (19977 43600))
+;;;;;; "net/ange-ftp.el" (20451 20881))
;;; Generated autoloads from net/ange-ftp.el
(defalias 'ange-ftp-re-read-dir 'ange-ftp-reread-dir)
;;;***
\f
;;;### (autoloads (animate-birthday-present animate-sequence animate-string)
-;;;;;; "animate" "play/animate.el" (19986 58615))
+;;;;;; "animate" "play/animate.el" (20356 35090))
;;; Generated autoloads from play/animate.el
(autoload 'animate-string "animate" "\
;;;***
\f
;;;### (autoloads (ansi-color-process-output ansi-color-for-comint-mode-on)
-;;;;;; "ansi-color" "ansi-color.el" (19854 41422))
+;;;;;; "ansi-color" "ansi-color.el" (20428 57510))
;;; Generated autoloads from ansi-color.el
(autoload 'ansi-color-for-comint-mode-on "ansi-color" "\
;;;***
\f
;;;### (autoloads (antlr-set-tabs antlr-mode antlr-show-makefile-rules)
-;;;;;; "antlr-mode" "progmodes/antlr-mode.el" (19890 42850))
+;;;;;; "antlr-mode" "progmodes/antlr-mode.el" (20428 57510))
;;; Generated autoloads from progmodes/antlr-mode.el
(autoload 'antlr-show-makefile-rules "antlr-mode" "\
;;;***
\f
;;;### (autoloads (appt-activate appt-add) "appt" "calendar/appt.el"
-;;;;;; (19956 37456))
+;;;;;; (20244 35516))
;;; Generated autoloads from calendar/appt.el
(autoload 'appt-add "appt" "\
\f
;;;### (autoloads (apropos-documentation apropos-value apropos-library
;;;;;; apropos apropos-documentation-property apropos-command apropos-variable
-;;;;;; apropos-read-pattern) "apropos" "apropos.el" (19909 7240))
+;;;;;; apropos-read-pattern) "apropos" "apropos.el" (20373 41604))
;;; Generated autoloads from apropos.el
(autoload 'apropos-read-pattern "apropos" "\
(autoload 'apropos-library "apropos" "\
List the variables and functions defined by library FILE.
FILE should be one of the libraries currently loaded and should
-thus be found in `load-history'.
+thus be found in `load-history'. If `apropos-do-all' is non-nil,
+the output includes key-bindings of commands.
\(fn FILE)" t nil)
search for matches for any two (or more) of those words.
With \\[universal-argument] prefix, or if `apropos-do-all' is non-nil, also looks
-at the function and at the names and values of properties.
+at function definitions (arguments, documentation and body) and at the
+names and values of properties.
+
Returns list of symbols and values found.
\(fn PATTERN &optional DO-ALL)" t nil)
search for matches for that word as a substring. If it is a list of words,
search for matches for any two (or more) of those words.
-With \\[universal-argument] prefix, or if `apropos-do-all' is non-nil, also use
-documentation that is not stored in the documentation file and show key
-bindings.
+Note that by default this command only searches in the file specified by
+`internal-doc-file-name'; i.e., the etc/DOC file. With \\[universal-argument] prefix,
+or if `apropos-do-all' is non-nil, it searches all currently defined
+documentation strings.
+
Returns list of symbols and documentation found.
\(fn PATTERN &optional DO-ALL)" t nil)
;;;***
\f
-;;;### (autoloads (archive-mode) "arc-mode" "arc-mode.el" (19990
-;;;;;; 55648))
+;;;### (autoloads (archive-mode) "arc-mode" "arc-mode.el" (20412
+;;;;;; 11425))
;;; Generated autoloads from arc-mode.el
(autoload 'archive-mode "arc-mode" "\
;;;***
\f
-;;;### (autoloads (array-mode) "array" "array.el" (19845 45374))
+;;;### (autoloads (array-mode) "array" "array.el" (20244 35516))
;;; Generated autoloads from array.el
(autoload 'array-mode "array" "\
;;;***
\f
-;;;### (autoloads (artist-mode) "artist" "textmodes/artist.el" (19914
-;;;;;; 25180))
+;;;### (autoloads (artist-mode) "artist" "textmodes/artist.el" (20359
+;;;;;; 18671))
;;; Generated autoloads from textmodes/artist.el
(autoload 'artist-mode "artist" "\
Toggle Artist mode.
-With argument STATE, turn Artist mode on if STATE is positive.
+With argument ARG, turn Artist mode on if ARG is positive.
Artist lets you draw lines, squares, rectangles and poly-lines,
ellipses and circles with your mouse and/or keyboard.
Hooks
- When entering artist-mode, the hook `artist-mode-init-hook' is called.
- When quitting artist-mode, the hook `artist-mode-exit-hook' is called.
+ Turning the mode on or off runs `artist-mode-hook'.
Keymap summary
\\{artist-mode-map}
-\(fn &optional STATE)" t nil)
+\(fn &optional ARG)" t nil)
;;;***
\f
-;;;### (autoloads (asm-mode) "asm-mode" "progmodes/asm-mode.el" (19890
-;;;;;; 42850))
+;;;### (autoloads (asm-mode) "asm-mode" "progmodes/asm-mode.el" (20356
+;;;;;; 35090))
;;; Generated autoloads from progmodes/asm-mode.el
(autoload 'asm-mode "asm-mode" "\
;;;***
\f
;;;### (autoloads (auth-source-cache-expiry) "auth-source" "gnus/auth-source.el"
-;;;;;; (20062 2656))
+;;;;;; (20428 57510))
;;; Generated autoloads from gnus/auth-source.el
(defvar auth-source-cache-expiry 7200 "\
;;;***
\f
;;;### (autoloads (autoarg-kp-mode autoarg-mode) "autoarg" "autoarg.el"
-;;;;;; (19845 45374))
+;;;;;; (20244 35516))
;;; Generated autoloads from autoarg.el
(defvar autoarg-mode nil "\
(custom-autoload 'autoarg-mode "autoarg" nil)
(autoload 'autoarg-mode "autoarg" "\
-Toggle Autoarg minor mode globally.
-With ARG, turn Autoarg mode on if ARG is positive, off otherwise.
+Toggle Autoarg mode, a global minor mode.
+With a prefix argument ARG, enable Autoarg mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+the mode if ARG is omitted or nil.
+
\\<autoarg-mode-map>
-In Autoarg mode digits are bound to `digit-argument' -- i.e. they
-supply prefix arguments as C-DIGIT and M-DIGIT normally do -- and
-C-DIGIT inserts DIGIT. \\[autoarg-terminate] terminates the prefix sequence
-and inserts the digits of the autoarg sequence into the buffer.
-Without a numeric prefix arg the normal binding of \\[autoarg-terminate] is
-invoked, i.e. what it would be with Autoarg mode off.
+In Autoarg mode, digits are bound to `digit-argument', i.e. they
+supply prefix arguments as C-DIGIT and M-DIGIT normally do.
+Furthermore, C-DIGIT inserts DIGIT.
+\\[autoarg-terminate] terminates the prefix sequence and inserts
+the digits of the autoarg sequence into the buffer.
+Without a numeric prefix arg, the normal binding of \\[autoarg-terminate]
+is invoked, i.e. what it would be with Autoarg mode off.
For example:
`6 9 \\[autoarg-terminate]' inserts `69' into the buffer, as does `C-6 C-9'.
(custom-autoload 'autoarg-kp-mode "autoarg" nil)
(autoload 'autoarg-kp-mode "autoarg" "\
-Toggle Autoarg-KP minor mode globally.
-With ARG, turn Autoarg mode on if ARG is positive, off otherwise.
+Toggle Autoarg-KP mode, a global minor mode.
+With a prefix argument ARG, enable Autoarg-KP mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+the mode if ARG is omitted or nil.
+
\\<autoarg-kp-mode-map>
-This is similar to \\[autoarg-mode] but rebinds the keypad keys `kp-1'
-etc. to supply digit arguments.
+This is similar to `autoarg-mode' but rebinds the keypad keys
+`kp-1' etc. to supply digit arguments.
\\{autoarg-kp-mode-map}
;;;***
\f
;;;### (autoloads (autoconf-mode) "autoconf" "progmodes/autoconf.el"
-;;;;;; (19845 45374))
+;;;;;; (20244 35516))
;;; Generated autoloads from progmodes/autoconf.el
(autoload 'autoconf-mode "autoconf" "\
;;;***
\f
;;;### (autoloads (auto-insert-mode define-auto-insert auto-insert)
-;;;;;; "autoinsert" "autoinsert.el" (19988 13913))
+;;;;;; "autoinsert" "autoinsert.el" (20412 11425))
;;; Generated autoloads from autoinsert.el
(autoload 'auto-insert "autoinsert" "\
(custom-autoload 'auto-insert-mode "autoinsert" nil)
(autoload 'auto-insert-mode "autoinsert" "\
-Toggle Auto-insert mode.
-With prefix ARG, turn Auto-insert mode on if and only if ARG is positive.
-Returns the new status of Auto-insert mode (non-nil means on).
+Toggle Auto-insert mode, a global minor mode.
+With a prefix argument ARG, enable Auto-insert mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+the mode if ARG is omitted or nil.
When Auto-insert mode is enabled, when new files are created you can
insert a template for the file depending on the mode of the buffer.
\f
;;;### (autoloads (batch-update-autoloads update-directory-autoloads
;;;;;; update-file-autoloads) "autoload" "emacs-lisp/autoload.el"
-;;;;;; (19924 47209))
+;;;;;; (20446 34252))
;;; Generated autoloads from emacs-lisp/autoload.el
(put 'generated-autoload-file 'safe-local-variable 'stringp)
\f
;;;### (autoloads (global-auto-revert-mode turn-on-auto-revert-tail-mode
;;;;;; auto-revert-tail-mode turn-on-auto-revert-mode auto-revert-mode)
-;;;;;; "autorevert" "autorevert.el" (19878 51661))
+;;;;;; "autorevert" "autorevert.el" (20373 41604))
;;; Generated autoloads from autorevert.el
(autoload 'auto-revert-mode "autorevert" "\
-Toggle reverting buffer when file on disk changes.
+Toggle reverting buffer when the file changes (Auto Revert mode).
+With a prefix argument ARG, enable Auto Revert mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+the mode if ARG is omitted or nil.
+
+Auto Revert mode is a minor mode that affects only the current
+buffer. When enabled, it reverts the buffer when the file on
+disk changes.
-With arg, turn Auto Revert mode on if and only if arg is positive.
-This is a minor mode that affects only the current buffer.
Use `global-auto-revert-mode' to automatically revert all buffers.
Use `auto-revert-tail-mode' if you know that the file will only grow
without being changed in the part that is already in the buffer.
\(fn)" nil nil)
(autoload 'auto-revert-tail-mode "autorevert" "\
-Toggle reverting tail of buffer when file on disk grows.
-With arg, turn Tail mode on if arg is positive, otherwise turn it off.
+Toggle reverting tail of buffer when the file grows.
+With a prefix argument ARG, enable Auto-Revert Tail mode if ARG
+is positive, and disable it otherwise. If called from Lisp,
+enable the mode if ARG is omitted or nil.
-When Tail mode is enabled, the tail of the file is constantly
-followed, as with the shell command `tail -f'. This means that
-whenever the file grows on disk (presumably because some
-background process is appending to it from time to time), this is
-reflected in the current buffer.
+When Auto Revert Tail mode is enabled, the tail of the file is
+constantly followed, as with the shell command `tail -f'. This
+means that whenever the file grows on disk (presumably because
+some background process is appending to it from time to time),
+this is reflected in the current buffer.
You can edit the buffer and turn this mode off and on again as
you please. But make sure the background process has stopped
\(fn &optional ARG)" t nil)
(autoload 'turn-on-auto-revert-tail-mode "autorevert" "\
-Turn on Auto-Revert Tail Mode.
+Turn on Auto-Revert Tail mode.
This function is designed to be added to hooks, for example:
(add-hook 'my-logfile-mode-hook 'turn-on-auto-revert-tail-mode)
(autoload 'global-auto-revert-mode "autorevert" "\
Toggle Global Auto Revert mode.
-With optional prefix argument ARG, enable Global Auto Revert Mode
-if ARG > 0, else disable it.
+With a prefix argument ARG, enable Global Auto Revert mode if ARG
+is positive, and disable it otherwise. If called from Lisp,
+enable the mode if ARG is omitted or nil.
-This is a global minor mode that reverts any buffer associated
-with a file when the file changes on disk. Use `auto-revert-mode'
-to revert a particular buffer.
+Global Auto Revert mode is a global minor mode that reverts any
+buffer associated with a file when the file changes on disk. Use
+`auto-revert-mode' to revert a particular buffer.
If `global-auto-revert-non-file-buffers' is non-nil, this mode
may also revert some non-file buffers, as described in the
;;;***
\f
;;;### (autoloads (mouse-avoidance-mode mouse-avoidance-mode) "avoid"
-;;;;;; "avoid.el" (19845 45374))
+;;;;;; "avoid.el" (20373 41604))
;;; Generated autoloads from avoid.el
(defvar mouse-avoidance-mode nil "\
;;;***
\f
;;;### (autoloads (display-battery-mode battery) "battery" "battery.el"
-;;;;;; (20055 29424))
+;;;;;; (20373 41604))
;;; Generated autoloads from battery.el
(put 'battery-mode-line-string 'risky-local-variable t)
(custom-autoload 'display-battery-mode "battery" nil)
(autoload 'display-battery-mode "battery" "\
-Display battery status information in the mode line.
-The text being displayed in the mode line is controlled by the variables
+Toggle battery status display in mode line (Display Battery mode).
+With a prefix argument ARG, enable Display Battery mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+the mode if ARG is omitted or nil.
+
+The text displayed in the mode line is controlled by
`battery-mode-line-format' and `battery-status-function'.
-The mode line will be updated automatically every `battery-update-interval'
+The mode line is be updated every `battery-update-interval'
seconds.
\(fn &optional ARG)" t nil)
;;;***
\f
;;;### (autoloads (benchmark benchmark-run-compiled benchmark-run)
-;;;;;; "benchmark" "emacs-lisp/benchmark.el" (19981 40664))
+;;;;;; "benchmark" "emacs-lisp/benchmark.el" (20244 35516))
;;; Generated autoloads from emacs-lisp/benchmark.el
(autoload 'benchmark-run "benchmark" "\
garbage collections that ran, and the time taken by garbage collection.
See also `benchmark-run-compiled'.
-\(fn &optional REPETITIONS &rest FORMS)" nil (quote macro))
+\(fn &optional REPETITIONS &rest FORMS)" nil t)
(autoload 'benchmark-run-compiled "benchmark" "\
Time execution of compiled version of FORMS.
byte code obtained by wrapping FORMS in a `lambda' and compiling the
result. The overhead of the `lambda's is accounted for.
-\(fn &optional REPETITIONS &rest FORMS)" nil (quote macro))
+\(fn &optional REPETITIONS &rest FORMS)" nil t)
(autoload 'benchmark "benchmark" "\
Print the time taken for REPETITIONS executions of FORM.
;;;***
\f
;;;### (autoloads (bibtex-search-entry bibtex-mode bibtex-initialize)
-;;;;;; "bibtex" "textmodes/bibtex.el" (19997 28887))
+;;;;;; "bibtex" "textmodes/bibtex.el" (20446 34252))
;;; Generated autoloads from textmodes/bibtex.el
(autoload 'bibtex-initialize "bibtex" "\
;;;***
\f
;;;### (autoloads (bibtex-style-mode) "bibtex-style" "textmodes/bibtex-style.el"
-;;;;;; (19863 8742))
+;;;;;; (20244 35516))
;;; Generated autoloads from textmodes/bibtex-style.el
(autoload 'bibtex-style-mode "bibtex-style" "\
\f
;;;### (autoloads (binhex-decode-region binhex-decode-region-external
;;;;;; binhex-decode-region-internal) "binhex" "mail/binhex.el"
-;;;;;; (19845 45374))
+;;;;;; (20356 35090))
;;; Generated autoloads from mail/binhex.el
-(defconst binhex-begin-line "^:...............................................................$")
+(defconst binhex-begin-line "^:...............................................................$" "\
+Regular expression matching the start of a BinHex encoded region.")
(autoload 'binhex-decode-region-internal "binhex" "\
Binhex decode region between START and END without using an external program.
;;;***
\f
-;;;### (autoloads (blackbox) "blackbox" "play/blackbox.el" (19845
-;;;;;; 45374))
+;;;### (autoloads (blackbox) "blackbox" "play/blackbox.el" (20244
+;;;;;; 35516))
;;; Generated autoloads from play/blackbox.el
(autoload 'blackbox "blackbox" "\
;;;;;; bookmark-save bookmark-write bookmark-delete bookmark-insert
;;;;;; bookmark-rename bookmark-insert-location bookmark-relocate
;;;;;; bookmark-jump-other-window bookmark-jump bookmark-set) "bookmark"
-;;;;;; "bookmark.el" (19998 49767))
+;;;;;; "bookmark.el" (20412 11425))
;;; Generated autoloads from bookmark.el
(define-key ctl-x-r-map "b" 'bookmark-jump)
(define-key ctl-x-r-map "m" 'bookmark-set)
;;;### (autoloads (browse-url-elinks browse-url-kde browse-url-generic
;;;;;; browse-url-mail browse-url-text-emacs browse-url-text-xterm
;;;;;; browse-url-w3-gnudoit browse-url-w3 browse-url-cci browse-url-mosaic
-;;;;;; browse-url-gnome-moz browse-url-emacs browse-url-galeon browse-url-firefox
-;;;;;; browse-url-mozilla browse-url-netscape browse-url-xdg-open
-;;;;;; browse-url-at-mouse browse-url-at-point browse-url browse-url-of-region
-;;;;;; browse-url-of-dired-file browse-url-of-buffer browse-url-of-file
-;;;;;; browse-url-browser-function) "browse-url" "net/browse-url.el"
-;;;;;; (20048 56149))
+;;;;;; browse-url-gnome-moz browse-url-emacs browse-url-galeon browse-url-chromium
+;;;;;; browse-url-firefox browse-url-mozilla browse-url-netscape
+;;;;;; browse-url-xdg-open browse-url-at-mouse browse-url-at-point
+;;;;;; browse-url browse-url-of-region browse-url-of-dired-file
+;;;;;; browse-url-of-buffer browse-url-of-file browse-url-browser-function)
+;;;;;; "browse-url" "net/browse-url.el" (20412 11425))
;;; Generated autoloads from net/browse-url.el
(defvar browse-url-browser-function 'browse-url-default-browser "\
\(fn EVENT)" t nil)
(autoload 'browse-url-xdg-open "browse-url" "\
+Pass the specified URL to the \"xdg-open\" command.
+xdg-open is a desktop utility that calls your preferred web browser.
+The optional argument IGNORED is not used.
-
-\(fn URL &optional NEW-WINDOW)" t nil)
+\(fn URL &optional IGNORED)" t nil)
(autoload 'browse-url-netscape "browse-url" "\
Ask the Netscape WWW browser to load URL.
\(fn URL &optional NEW-WINDOW)" t nil)
+(autoload 'browse-url-chromium "browse-url" "\
+Ask the Chromium WWW browser to load URL.
+Default to the URL around or before point. The strings in
+variable `browse-url-chromium-arguments' are also passed to
+Chromium.
+
+\(fn URL &optional NEW-WINDOW)" t nil)
+
(autoload 'browse-url-galeon "browse-url" "\
Ask the Galeon WWW browser to load URL.
Default to the URL around or before point. The strings in variable
;;;***
\f
-;;;### (autoloads (snarf-bruces bruce) "bruce" "play/bruce.el" (19845
-;;;;;; 45374))
-;;; Generated autoloads from play/bruce.el
-
-(autoload 'bruce "bruce" "\
-Adds that special touch of class to your outgoing mail.
-
-\(fn)" t nil)
-
-(autoload 'snarf-bruces "bruce" "\
-Return a vector containing the lines from `bruce-phrases-file'.
-
-\(fn)" nil nil)
-
-;;;***
-\f
;;;### (autoloads (bs-show bs-customize bs-cycle-previous bs-cycle-next)
-;;;;;; "bs" "bs.el" (19998 49767))
+;;;;;; "bs" "bs.el" (20373 41604))
;;; Generated autoloads from bs.el
(autoload 'bs-cycle-next "bs" "\
;;;***
\f
-;;;### (autoloads (bubbles) "bubbles" "play/bubbles.el" (19889 21967))
+;;;### (autoloads (bubbles) "bubbles" "play/bubbles.el" (20244 35516))
;;; Generated autoloads from play/bubbles.el
(autoload 'bubbles "bubbles" "\
;;;***
\f
;;;### (autoloads (bug-reference-prog-mode bug-reference-mode) "bug-reference"
-;;;;;; "progmodes/bug-reference.el" (19890 42850))
+;;;;;; "progmodes/bug-reference.el" (20244 35516))
;;; Generated autoloads from progmodes/bug-reference.el
(put 'bug-reference-url-format 'safe-local-variable (lambda (s) (or (stringp s) (and (symbolp s) (get s 'bug-reference-url-format)))))
(autoload 'bug-reference-mode "bug-reference" "\
-Minor mode to buttonize bugzilla references in the current buffer.
+Toggle hyperlinking bug references in the buffer (Bug Reference mode).
+With a prefix argument ARG, enable Bug Reference mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+the mode if ARG is omitted or nil.
\(fn &optional ARG)" t nil)
;;;;;; batch-byte-compile-if-not-done display-call-tree byte-compile
;;;;;; compile-defun byte-compile-file byte-recompile-directory
;;;;;; byte-force-recompile byte-compile-enable-warning byte-compile-disable-warning)
-;;;;;; "bytecomp" "emacs-lisp/bytecomp.el" (19998 49767))
+;;;;;; "bytecomp" "emacs-lisp/bytecomp.el" (20452 43334))
;;; Generated autoloads from emacs-lisp/bytecomp.el
(put 'byte-compile-dynamic 'safe-local-variable 'booleanp)
(put 'byte-compile-disable-print-circle 'safe-local-variable 'booleanp)
;;;***
\f
-;;;### (autoloads nil "cal-china" "calendar/cal-china.el" (19885
-;;;;;; 24894))
+;;;### (autoloads nil "cal-china" "calendar/cal-china.el" (20244
+;;;;;; 35516))
;;; Generated autoloads from calendar/cal-china.el
(put 'calendar-chinese-time-zone 'risky-local-variable t)
;;;***
\f
-;;;### (autoloads nil "cal-dst" "calendar/cal-dst.el" (19885 24894))
+;;;### (autoloads nil "cal-dst" "calendar/cal-dst.el" (20244 35516))
;;; Generated autoloads from calendar/cal-dst.el
(put 'calendar-daylight-savings-starts 'risky-local-variable t)
;;;***
\f
;;;### (autoloads (calendar-hebrew-list-yahrzeits) "cal-hebrew" "calendar/cal-hebrew.el"
-;;;;;; (19885 24894))
+;;;;;; (20290 33419))
;;; Generated autoloads from calendar/cal-hebrew.el
(autoload 'calendar-hebrew-list-yahrzeits "cal-hebrew" "\
\f
;;;### (autoloads (defmath calc-embedded-activate calc-embedded calc-grab-rectangle
;;;;;; calc-grab-region full-calc-keypad calc-keypad calc-eval quick-calc
-;;;;;; full-calc calc calc-dispatch) "calc" "calc/calc.el" (19943
-;;;;;; 25429))
+;;;;;; full-calc calc calc-dispatch) "calc" "calc/calc.el" (20412
+;;;;;; 11425))
;;; Generated autoloads from calc/calc.el
(define-key ctl-x-map "*" 'calc-dispatch)
See Info node `(calc)Defining Functions'.
-\(fn FUNC ARGS &rest BODY)" nil (quote macro))
+\(fn FUNC ARGS &rest BODY)" nil t)
(put 'defmath 'doc-string-elt '3)
;;;***
\f
-;;;### (autoloads (calc-undo) "calc-undo" "calc/calc-undo.el" (19845
-;;;;;; 45374))
+;;;### (autoloads (calc-undo) "calc-undo" "calc/calc-undo.el" (20244
+;;;;;; 35516))
;;; Generated autoloads from calc/calc-undo.el
(autoload 'calc-undo "calc-undo" "\
;;;***
\f
-;;;### (autoloads (calculator) "calculator" "calculator.el" (19931
-;;;;;; 11784))
+;;;### (autoloads (calculator) "calculator" "calculator.el" (20428
+;;;;;; 57510))
;;; Generated autoloads from calculator.el
(autoload 'calculator "calculator" "\
;;;***
\f
-;;;### (autoloads (calendar) "calendar" "calendar/calendar.el" (19956
-;;;;;; 37456))
+;;;### (autoloads (calendar) "calendar" "calendar/calendar.el" (20452
+;;;;;; 43334))
;;; Generated autoloads from calendar/calendar.el
(autoload 'calendar "calendar" "\
;;;***
\f
;;;### (autoloads (canlock-verify canlock-insert-header) "canlock"
-;;;;;; "gnus/canlock.el" (19845 45374))
+;;;;;; "gnus/canlock.el" (20244 35516))
;;; Generated autoloads from gnus/canlock.el
(autoload 'canlock-insert-header "canlock" "\
;;;***
\f
;;;### (autoloads (capitalized-words-mode) "cap-words" "progmodes/cap-words.el"
-;;;;;; (19845 45374))
+;;;;;; (20244 35516))
;;; Generated autoloads from progmodes/cap-words.el
(autoload 'capitalized-words-mode "cap-words" "\
Toggle Capitalized Words mode.
+With a prefix argument ARG, enable Capitalized Words mode if ARG
+is positive, and disable it otherwise. If called from Lisp,
+enable the mode if ARG is omitted or nil.
-In this minor mode, a word boundary occurs immediately before an
-uppercase letter in a symbol. This is in addition to all the normal
+Capitalized Words mode is a buffer-local minor mode. When
+enabled, a word boundary occurs immediately before an uppercase
+letter in a symbol. This is in addition to all the normal
boundaries given by the syntax and category tables. There is no
restriction to ASCII.
;;;***
\f
-;;;### (autoloads nil "cc-compat" "progmodes/cc-compat.el" (19845
-;;;;;; 45374))
+;;;### (autoloads nil "cc-compat" "progmodes/cc-compat.el" (20244
+;;;;;; 35516))
;;; Generated autoloads from progmodes/cc-compat.el
(put 'c-indent-level 'safe-local-variable 'integerp)
;;;***
\f
;;;### (autoloads (c-guess-basic-syntax) "cc-engine" "progmodes/cc-engine.el"
-;;;;;; (20048 56149))
+;;;;;; (20373 41604))
;;; Generated autoloads from progmodes/cc-engine.el
(autoload 'c-guess-basic-syntax "cc-engine" "\
\f
;;;### (autoloads (c-guess-install c-guess-region-no-install c-guess-region
;;;;;; c-guess-buffer-no-install c-guess-buffer c-guess-no-install
-;;;;;; c-guess) "cc-guess" "progmodes/cc-guess.el" (19981 40664))
+;;;;;; c-guess) "cc-guess" "progmodes/cc-guess.el" (20276 3849))
;;; Generated autoloads from progmodes/cc-guess.el
(defvar c-guess-guessed-offsets-alist nil "\
\f
;;;### (autoloads (awk-mode pike-mode idl-mode java-mode objc-mode
;;;;;; c++-mode c-mode c-initialize-cc-mode) "cc-mode" "progmodes/cc-mode.el"
-;;;;;; (20010 40918))
+;;;;;; (20419 46656))
;;; Generated autoloads from progmodes/cc-mode.el
(autoload 'c-initialize-cc-mode "cc-mode" "\
(defvar pike-mode-syntax-table nil "\
Syntax table used in pike-mode buffers.")
- (add-to-list 'auto-mode-alist '("\\.\\(u?lpc\\|pike\\|pmod\\(.in\\)?\\)\\'" . pike-mode))
+ (add-to-list 'auto-mode-alist '("\\.\\(u?lpc\\|pike\\|pmod\\(\\.in\\)?\\)\\'" . pike-mode))
(add-to-list 'interpreter-mode-alist '("pike" . pike-mode))
(autoload 'pike-mode "cc-mode" "\
;;;***
\f
;;;### (autoloads (c-set-offset c-add-style c-set-style) "cc-styles"
-;;;;;; "progmodes/cc-styles.el" (19981 40664))
+;;;;;; "progmodes/cc-styles.el" (20244 35516))
;;; Generated autoloads from progmodes/cc-styles.el
(autoload 'c-set-style "cc-styles" "\
;;;***
\f
-;;;### (autoloads nil "cc-vars" "progmodes/cc-vars.el" (19997 28887))
+;;;### (autoloads nil "cc-vars" "progmodes/cc-vars.el" (20290 33419))
;;; Generated autoloads from progmodes/cc-vars.el
(put 'c-basic-offset 'safe-local-variable 'integerp)
(put 'c-backslash-column 'safe-local-variable 'integerp)
\f
;;;### (autoloads (ccl-execute-with-args check-ccl-program define-ccl-program
;;;;;; declare-ccl-program ccl-dump ccl-compile) "ccl" "international/ccl.el"
-;;;;;; (19943 25429))
+;;;;;; (20244 35516))
;;; Generated autoloads from international/ccl.el
(autoload 'ccl-compile "ccl" "\
Optional arg VECTOR is a compiled CCL code of the CCL program.
-\(fn NAME &optional VECTOR)" nil (quote macro))
+\(fn NAME &optional VECTOR)" nil t)
(autoload 'define-ccl-program "ccl" "\
Set NAME the compiled code of CCL-PROGRAM.
ARG := REG | integer
OPERATOR :=
- ;; Normal arithmethic operators (same meaning as C code).
+ ;; Normal arithmetic operators (same meaning as C code).
+ | - | * | / | %
;; Bitwise operators (same meaning as C code)
| de-sjis
;; If ARG_0 and ARG_1 are the first and second code point of
- ;; JISX0208 character CHAR, and SJIS is the correponding
+ ;; JISX0208 character CHAR, and SJIS is the corresponding
;; Shift-JIS code,
;; (REG = ARG_0 en-sjis ARG_1) means:
;; ((REG = HIGH)
MAP-SET := MAP-IDs | (MAP-IDs) MAP-SET
MAP-ID := integer
-\(fn NAME CCL-PROGRAM &optional DOC)" nil (quote macro))
+\(fn NAME CCL-PROGRAM &optional DOC)" nil t)
(put 'define-ccl-program 'doc-string-elt '3)
If CCL-PROGRAM is a vector and optional arg NAME (symbol) is supplied,
register CCL-PROGRAM by name NAME, and return NAME.
-\(fn CCL-PROGRAM &optional NAME)" nil (quote macro))
+\(fn CCL-PROGRAM &optional NAME)" nil t)
(autoload 'ccl-execute-with-args "ccl" "\
Execute CCL-PROGRAM with registers initialized by the remaining args.
;;;***
\f
;;;### (autoloads (cconv-closure-convert) "cconv" "emacs-lisp/cconv.el"
-;;;;;; (19943 25429))
+;;;;;; (20452 43334))
;;; Generated autoloads from emacs-lisp/cconv.el
(autoload 'cconv-closure-convert "cconv" "\
;;;***
\f
-;;;### (autoloads (cfengine-mode cfengine3-mode) "cfengine" "progmodes/cfengine.el"
-;;;;;; (19981 40664))
+;;;### (autoloads (cfengine-auto-mode cfengine2-mode cfengine3-mode)
+;;;;;; "cfengine" "progmodes/cfengine.el" (20356 35090))
;;; Generated autoloads from progmodes/cfengine.el
(autoload 'cfengine3-mode "cfengine" "\
-Major mode for editing cfengine input.
+Major mode for editing CFEngine3 input.
There are no special keybindings by default.
Action blocks are treated as defuns, i.e. \\[beginning-of-defun] moves
\(fn)" t nil)
-(autoload 'cfengine-mode "cfengine" "\
-Major mode for editing cfengine input.
+(autoload 'cfengine2-mode "cfengine" "\
+Major mode for editing CFEngine2 input.
There are no special keybindings by default.
Action blocks are treated as defuns, i.e. \\[beginning-of-defun] moves
\(fn)" t nil)
+(autoload 'cfengine-auto-mode "cfengine" "\
+Choose between `cfengine2-mode' and `cfengine3-mode' depending
+on the buffer contents
+
+\(fn)" nil nil)
+
;;;***
\f
;;;### (autoloads (check-declare-directory check-declare-file) "check-declare"
-;;;;;; "emacs-lisp/check-declare.el" (19906 31087))
+;;;;;; "emacs-lisp/check-declare.el" (20380 26775))
;;; Generated autoloads from emacs-lisp/check-declare.el
(autoload 'check-declare-file "check-declare" "\
;;;;;; checkdoc-comments checkdoc-continue checkdoc-start checkdoc-current-buffer
;;;;;; checkdoc-eval-current-buffer checkdoc-message-interactive
;;;;;; checkdoc-interactive checkdoc checkdoc-list-of-strings-p)
-;;;;;; "checkdoc" "emacs-lisp/checkdoc.el" (19931 11784))
+;;;;;; "checkdoc" "emacs-lisp/checkdoc.el" (20412 11425))
;;; Generated autoloads from emacs-lisp/checkdoc.el
(put 'checkdoc-force-docstrings-flag 'safe-local-variable 'booleanp)
(put 'checkdoc-force-history-flag 'safe-local-variable 'booleanp)
\(fn &optional TAKE-NOTES)" t nil)
(autoload 'checkdoc-minor-mode "checkdoc" "\
-Toggle Checkdoc minor mode, a mode for checking Lisp doc strings.
-With prefix ARG, turn Checkdoc minor mode on if ARG is positive, otherwise
-turn it off.
+Toggle automatic docstring checking (Checkdoc minor mode).
+With a prefix argument ARG, enable Checkdoc minor mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+the mode if ARG is omitted or nil.
In Checkdoc minor mode, the usual bindings for `eval-defun' which is
bound to \\<checkdoc-minor-mode-map>\\[checkdoc-eval-defun] and `checkdoc-eval-current-buffer' are overridden to include
\f
;;;### (autoloads (pre-write-encode-hz post-read-decode-hz encode-hz-buffer
;;;;;; encode-hz-region decode-hz-buffer decode-hz-region) "china-util"
-;;;;;; "language/china-util.el" (19845 45374))
+;;;;;; "language/china-util.el" (20244 35516))
;;; Generated autoloads from language/china-util.el
(autoload 'decode-hz-region "china-util" "\
;;;***
\f
;;;### (autoloads (command-history list-command-history repeat-matching-complex-command)
-;;;;;; "chistory" "chistory.el" (19845 45374))
+;;;;;; "chistory" "chistory.el" (20244 35516))
;;; Generated autoloads from chistory.el
(autoload 'repeat-matching-complex-command "chistory" "\
;;;***
\f
-;;;### (autoloads nil "cl" "emacs-lisp/cl.el" (19863 8742))
-;;; Generated autoloads from emacs-lisp/cl.el
-
-(defvar custom-print-functions nil "\
-This is a list of functions that format user objects for printing.
-Each function is called in turn with three arguments: the object, the
-stream, and the print level (currently ignored). If it is able to
-print the object it returns true; otherwise it returns nil and the
-printer proceeds to the next function on the list.
-
-This variable is not used at present, but it is defined in hopes that
-a future Emacs interpreter will be able to use it.")
-
-;;;***
-\f
;;;### (autoloads (common-lisp-indent-function) "cl-indent" "emacs-lisp/cl-indent.el"
-;;;;;; (19918 22236))
+;;;;;; (20290 33419))
;;; Generated autoloads from emacs-lisp/cl-indent.el
(autoload 'common-lisp-indent-function "cl-indent" "\
;;;***
\f
+;;;### (autoloads nil "cl-lib" "emacs-lisp/cl-lib.el" (20452 55920))
+;;; Generated autoloads from emacs-lisp/cl-lib.el
+
+(define-obsolete-variable-alias 'custom-print-functions 'cl-custom-print-functions "24.2")
+
+(defvar cl-custom-print-functions nil "\
+This is a list of functions that format user objects for printing.
+Each function is called in turn with three arguments: the object, the
+stream, and the print level (currently ignored). If it is able to
+print the object it returns true; otherwise it returns nil and the
+printer proceeds to the next function on the list.
+
+This variable is not used at present, but it is defined in hopes that
+a future Emacs interpreter will be able to use it.")
+
+(autoload 'cl--defsubst-expand "cl-macs")
+
+(put 'cl-defun 'doc-string-elt 3)
+
+(put 'cl-defmacro 'doc-string-elt 3)
+
+(put 'cl-defsubst 'doc-string-elt 3)
+
+(put 'cl-defstruct 'doc-string-elt 2)
+
+;;;***
+\f
;;;### (autoloads (c-macro-expand) "cmacexp" "progmodes/cmacexp.el"
-;;;;;; (19845 45374))
+;;;;;; (20356 35090))
;;; Generated autoloads from progmodes/cmacexp.el
(autoload 'c-macro-expand "cmacexp" "\
;;;***
\f
-;;;### (autoloads (run-scheme) "cmuscheme" "cmuscheme.el" (19886
-;;;;;; 45771))
+;;;### (autoloads (run-scheme) "cmuscheme" "cmuscheme.el" (20244
+;;;;;; 35516))
;;; Generated autoloads from cmuscheme.el
(autoload 'run-scheme "cmuscheme" "\
\(Type \\[describe-mode] in the process buffer for a list of commands.)
\(fn CMD)" t nil)
- (add-hook 'same-window-buffer-names (purecopy "*scheme*"))
;;;***
\f
-;;;### (autoloads (color-name-to-rgb) "color" "color.el" (19845 45374))
+;;;### (autoloads (color-name-to-rgb) "color" "color.el" (20356 19083))
;;; Generated autoloads from color.el
(autoload 'color-name-to-rgb "color" "\
;;;### (autoloads (comint-redirect-results-list-from-process comint-redirect-results-list
;;;;;; comint-redirect-send-command-to-process comint-redirect-send-command
;;;;;; comint-run make-comint make-comint-in-buffer) "comint" "comint.el"
-;;;;;; (19981 40664))
+;;;;;; (20420 52684))
;;; Generated autoloads from comint.el
-(defvar comint-output-filter-functions '(comint-postoutput-scroll-to-bottom comint-watch-for-password-prompt) "\
+(defvar comint-output-filter-functions '(ansi-color-process-output comint-postoutput-scroll-to-bottom comint-watch-for-password-prompt) "\
Functions to call after output is inserted into the buffer.
One possible function is `comint-postoutput-scroll-to-bottom'.
These functions get one argument, a string containing the text as originally
(autoload 'make-comint-in-buffer "comint" "\
Make a Comint process NAME in BUFFER, running PROGRAM.
If BUFFER is nil, it defaults to NAME surrounded by `*'s.
-PROGRAM should be either a string denoting an executable program to create
-via `start-file-process', or a cons pair of the form (HOST . SERVICE) denoting
-a TCP connection to be opened via `open-network-stream'. If there is already
-a running process in that buffer, it is not restarted. Optional fourth arg
-STARTFILE is the name of a file, whose contents are sent to the
-process as its initial input.
+If there is a running process in BUFFER, it is not restarted.
+
+PROGRAM should be one of the following:
+- a string, denoting an executable program to create via
+ `start-file-process'
+- a cons pair of the form (HOST . SERVICE), denoting a TCP
+ connection to be opened via `open-network-stream'
+- nil, denoting a newly-allocated pty.
+
+Optional fourth arg STARTFILE is the name of a file, whose
+contents are sent to the process as its initial input.
If PROGRAM is a string, any more args are arguments to PROGRAM.
-Returns the (possibly newly created) process buffer.
+Return the (possibly newly created) process buffer.
\(fn NAME BUFFER PROGRAM &optional STARTFILE &rest SWITCHES)" nil nil)
;;;***
\f
;;;### (autoloads (compare-windows) "compare-w" "vc/compare-w.el"
-;;;;;; (19845 45374))
+;;;;;; (20244 35516))
;;; Generated autoloads from vc/compare-w.el
(autoload 'compare-windows "compare-w" "\
;;;;;; compilation-shell-minor-mode compilation-mode compilation-start
;;;;;; compile compilation-disable-input compile-command compilation-search-path
;;;;;; compilation-ask-about-save compilation-window-height compilation-start-hook
-;;;;;; compilation-mode-hook) "compile" "progmodes/compile.el" (20051
-;;;;;; 32345))
+;;;;;; compilation-mode-hook) "compile" "progmodes/compile.el" (20428
+;;;;;; 57510))
;;; Generated autoloads from progmodes/compile.el
(defvar compilation-mode-hook nil "\
(custom-autoload 'compilation-window-height "compile" t)
(defvar compilation-process-setup-function nil "\
-*Function to call to customize the compilation process.
+Function to call to customize the compilation process.
This function is called immediately before the compilation process is
started. It can be used to set any variables or functions that are used
while processing the output of the compilation process.")
\(fn &optional NAME-OF-MODE)" t nil)
+(put 'define-compilation-mode 'doc-string-elt 3)
+
(autoload 'compilation-shell-minor-mode "compile" "\
-Toggle compilation shell minor mode.
-With arg, turn compilation mode on if and only if arg is positive.
-In this minor mode, all the error-parsing commands of the
-Compilation major mode are available but bound to keys that don't
-collide with Shell mode. See `compilation-mode'.
-Turning the mode on runs the normal hook `compilation-shell-minor-mode-hook'.
+Toggle Compilation Shell minor mode.
+With a prefix argument ARG, enable Compilation Shell minor mode
+if ARG is positive, and disable it otherwise. If called from
+Lisp, enable the mode if ARG is omitted or nil.
+
+When Compilation Shell minor mode is enabled, all the
+error-parsing commands of the Compilation major mode are
+available but bound to keys that don't collide with Shell mode.
+See `compilation-mode'.
\(fn &optional ARG)" t nil)
(autoload 'compilation-minor-mode "compile" "\
-Toggle compilation minor mode.
-With arg, turn compilation mode on if and only if arg is positive.
-In this minor mode, all the error-parsing commands of the
-Compilation major mode are available. See `compilation-mode'.
-Turning the mode on runs the normal hook `compilation-minor-mode-hook'.
+Toggle Compilation minor mode.
+With a prefix argument ARG, enable Compilation minor mode if ARG
+is positive, and disable it otherwise. If called from Lisp,
+enable the mode if ARG is omitted or nil.
+
+When Compilation minor mode is enabled, all the error-parsing
+commands of Compilation major mode are available. See
+`compilation-mode'.
\(fn &optional ARG)" t nil)
;;;***
\f
;;;### (autoloads (dynamic-completion-mode) "completion" "completion.el"
-;;;;;; (19886 45771))
+;;;;;; (20412 11425))
;;; Generated autoloads from completion.el
(defvar dynamic-completion-mode nil "\
(custom-autoload 'dynamic-completion-mode "completion" nil)
(autoload 'dynamic-completion-mode "completion" "\
-Enable dynamic word-completion.
+Toggle dynamic word-completion on or off.
+With a prefix argument ARG, enable the mode if ARG is positive,
+and disable it otherwise. If called from Lisp, enable the mode
+if ARG is omitted or nil.
\(fn &optional ARG)" t nil)
;;;### (autoloads (conf-xdefaults-mode conf-ppd-mode conf-colon-mode
;;;;;; conf-space-keywords conf-space-mode conf-javaprop-mode conf-windows-mode
;;;;;; conf-unix-mode conf-mode) "conf-mode" "textmodes/conf-mode.el"
-;;;;;; (19845 45374))
+;;;;;; (20244 35516))
;;; Generated autoloads from textmodes/conf-mode.el
(autoload 'conf-mode "conf-mode" "\
;;;***
\f
;;;### (autoloads (shuffle-vector cookie-snarf cookie-insert cookie)
-;;;;;; "cookie1" "play/cookie1.el" (19845 45374))
+;;;;;; "cookie1" "play/cookie1.el" (20373 41604))
;;; Generated autoloads from play/cookie1.el
(autoload 'cookie "cookie1" "\
;;;***
\f
;;;### (autoloads (copyright-update-directory copyright copyright-fix-years
-;;;;;; copyright-update) "copyright" "emacs-lisp/copyright.el" (19845
-;;;;;; 45374))
+;;;;;; copyright-update) "copyright" "emacs-lisp/copyright.el" (20412
+;;;;;; 11425))
;;; Generated autoloads from emacs-lisp/copyright.el
(put 'copyright-at-end-flag 'safe-local-variable 'booleanp)
(put 'copyright-names-regexp 'safe-local-variable 'stringp)
;;;***
\f
;;;### (autoloads (cperl-perldoc-at-point cperl-perldoc cperl-mode)
-;;;;;; "cperl-mode" "progmodes/cperl-mode.el" (19997 56302))
+;;;;;; "cperl-mode" "progmodes/cperl-mode.el" (20451 20950))
;;; Generated autoloads from progmodes/cperl-mode.el
(put 'cperl-indent-level 'safe-local-variable 'integerp)
(put 'cperl-brace-offset 'safe-local-variable 'integerp)
since most the time you mean \"less\". CPerl mode tries to guess
whether you want to type pair <>, and inserts is if it
appropriate. You can set `cperl-electric-parens-string' to the string that
-contains the parenths from the above list you want to be electrical.
-Electricity of parenths is controlled by `cperl-electric-parens'.
+contains the parens from the above list you want to be electrical.
+Electricity of parens is controlled by `cperl-electric-parens'.
You may also set `cperl-electric-parens-mark' to have electric parens
look for active mark and \"embrace\" a region if possible.'
;;;***
\f
;;;### (autoloads (cpp-parse-edit cpp-highlight-buffer) "cpp" "progmodes/cpp.el"
-;;;;;; (19890 42850))
+;;;;;; (20356 35090))
;;; Generated autoloads from progmodes/cpp.el
(autoload 'cpp-highlight-buffer "cpp" "\
;;;***
\f
;;;### (autoloads (crisp-mode crisp-mode) "crisp" "emulation/crisp.el"
-;;;;;; (19845 45374))
+;;;;;; (20428 57510))
;;; Generated autoloads from emulation/crisp.el
(defvar crisp-mode nil "\
(custom-autoload 'crisp-mode "crisp" nil)
(autoload 'crisp-mode "crisp" "\
-Toggle CRiSP/Brief emulation minor mode.
-With ARG, turn CRiSP mode on if ARG is positive, off otherwise.
+Toggle CRiSP/Brief emulation (CRiSP mode).
+With a prefix argument ARG, enable CRiSP mode if ARG is positive,
+and disable it otherwise. If called from Lisp, enable the mode
+if ARG is omitted or nil.
\(fn &optional ARG)" t nil)
;;;***
\f
;;;### (autoloads (completing-read-multiple) "crm" "emacs-lisp/crm.el"
-;;;;;; (19845 45374))
+;;;;;; (20244 35516))
;;; Generated autoloads from emacs-lisp/crm.el
(autoload 'completing-read-multiple "crm" "\
;;;***
\f
-;;;### (autoloads (css-mode) "css-mode" "textmodes/css-mode.el" (19978
-;;;;;; 37530))
+;;;### (autoloads (css-mode) "css-mode" "textmodes/css-mode.el" (20244
+;;;;;; 35516))
;;; Generated autoloads from textmodes/css-mode.el
(autoload 'css-mode "css-mode" "\
;;;***
\f
;;;### (autoloads (cua-selection-mode cua-mode) "cua-base" "emulation/cua-base.el"
-;;;;;; (19894 39890))
+;;;;;; (20434 28080))
;;; Generated autoloads from emulation/cua-base.el
(defvar cua-mode nil "\
(custom-autoload 'cua-mode "cua-base" nil)
(autoload 'cua-mode "cua-base" "\
-Toggle CUA key-binding mode.
-When enabled, using shifted movement keys will activate the
-region (and highlight the region using `transient-mark-mode'),
-and typed text replaces the active selection.
-
-Also when enabled, you can use C-z, C-x, C-c, and C-v to undo,
-cut, copy, and paste in addition to the normal Emacs bindings.
-The C-x and C-c keys only do cut and copy when the region is
-active, so in most cases, they do not conflict with the normal
-function of these prefix keys.
+Toggle Common User Access style editing (CUA mode).
+With a prefix argument ARG, enable CUA mode if ARG is positive,
+and disable it otherwise. If called from Lisp, enable the mode
+if ARG is omitted or nil.
+
+CUA mode is a global minor mode. When enabled, typed text
+replaces the active selection, and you can use C-z, C-x, C-c, and
+C-v to undo, cut, copy, and paste in addition to the normal Emacs
+bindings. The C-x and C-c keys only do cut and copy when the
+region is active, so in most cases, they do not conflict with the
+normal function of these prefix keys.
If you really need to perform a command which starts with one of
the prefix keys even when the region is active, you have three
;;;;;; customize-mode customize customize-push-and-save customize-save-variable
;;;;;; customize-set-variable customize-set-value custom-menu-sort-alphabetically
;;;;;; custom-buffer-sort-alphabetically custom-browse-sort-alphabetically)
-;;;;;; "cus-edit" "cus-edit.el" (20025 8284))
+;;;;;; "cus-edit" "cus-edit.el" (20438 17064))
;;; Generated autoloads from cus-edit.el
(defvar custom-browse-sort-alphabetically nil "\
If non-nil, sort each customization group alphabetically in menus.")
(custom-autoload 'custom-menu-sort-alphabetically "cus-edit" t)
- (add-hook 'same-window-regexps (purecopy "\\`\\*Customiz.*\\*\\'"))
(autoload 'customize-set-value "cus-edit" "\
Set VARIABLE to VALUE, and return VALUE. VALUE is a Lisp object.
(autoload 'customize-group "cus-edit" "\
Customize GROUP, which must be a customization group.
+If OTHER-WINDOW is non-nil, display in another window.
-\(fn &optional GROUP)" t nil)
+\(fn &optional GROUP OTHER-WINDOW)" t nil)
(autoload 'customize-group-other-window "cus-edit" "\
Customize GROUP, which must be a customization group, in another window.
(defalias 'customize-variable 'customize-option)
(autoload 'customize-option "cus-edit" "\
-Customize SYMBOL, which must be a user option variable.
+Customize SYMBOL, which must be a user option.
\(fn SYMBOL)" t nil)
(defalias 'customize-variable-other-window 'customize-option-other-window)
(autoload 'customize-option-other-window "cus-edit" "\
-Customize SYMBOL, which must be a user option variable.
+Customize SYMBOL, which must be a user option.
Show the buffer in another window, but don't select it.
\(fn SYMBOL)" t nil)
(autoload 'customize-changed-options "cus-edit" "\
Customize all settings whose meanings have changed in Emacs itself.
-This includes new user option variables and faces, and new
-customization groups, as well as older options and faces whose meanings
-or default values have changed since the previous major Emacs release.
+This includes new user options and faces, and new customization
+groups, as well as older options and faces whose meanings or
+default values have changed since the previous major Emacs
+release.
With argument SINCE-VERSION (a string), customize all settings
that were added or redefined since that version.
If FACE is nil, customize all faces. If FACE is actually a
face-alias, customize the face it is aliased to.
+If OTHER-WINDOW is non-nil, display in another window.
+
Interactively, when point is on text which has a face specified,
suggest to customize that face, if it's customizable.
-\(fn &optional FACE)" t nil)
+\(fn &optional FACE OTHER-WINDOW)" t nil)
(autoload 'customize-face-other-window "cus-edit" "\
Show customization buffer for face FACE in other window.
\(fn &optional FACE)" t nil)
(autoload 'customize-unsaved "cus-edit" "\
-Customize all user options set in this session but not saved.
+Customize all options and faces set in this session but not saved.
\(fn)" t nil)
\(fn)" t nil)
(autoload 'customize-saved "cus-edit" "\
-Customize all already saved user options.
+Customize all saved options and faces.
\(fn)" t nil)
(autoload 'customize-apropos "cus-edit" "\
-Customize all loaded options, faces and groups matching PATTERN.
+Customize loaded options, faces and groups matching PATTERN.
PATTERN can be a word, a list of words (separated by spaces),
or a regexp (using some regexp special characters). If it is a word,
search for matches for that word as a substring. If it is a list of words,
If TYPE is `options', include only options.
If TYPE is `faces', include only faces.
If TYPE is `groups', include only groups.
-If TYPE is t (interactively, with prefix arg), include variables
-that are not customizable options, as well as faces and groups
-\(but we recommend using `apropos-variable' instead).
\(fn PATTERN &optional TYPE)" t nil)
(autoload 'customize-apropos-options "cus-edit" "\
Customize all loaded customizable options matching REGEXP.
-With prefix ARG, include variables that are not customizable options
-\(but it is better to use `apropos-variable' if you want to find those).
-\(fn REGEXP &optional ARG)" t nil)
+\(fn REGEXP &optional IGNORED)" t nil)
(autoload 'customize-apropos-faces "cus-edit" "\
Customize all loaded faces matching REGEXP.
;;;***
\f
;;;### (autoloads (customize-themes describe-theme custom-theme-visit-theme
-;;;;;; customize-create-theme) "cus-theme" "cus-theme.el" (20059
-;;;;;; 26455))
+;;;;;; customize-create-theme) "cus-theme" "cus-theme.el" (20336
+;;;;;; 29137))
;;; Generated autoloads from cus-theme.el
(autoload 'customize-create-theme "cus-theme" "\
Create or edit a custom theme.
THEME, if non-nil, should be an existing theme to edit. If THEME
-is `user', provide an option to remove these as custom settings.
+is `user', the resulting *Custom Theme* buffer also contains a
+checkbox for removing the theme settings specified in the buffer
+from the Custom save file.
BUFFER, if non-nil, should be a buffer to use; the default is
named *Custom Theme*.
;;;***
\f
;;;### (autoloads (cvs-status-mode) "cvs-status" "vc/cvs-status.el"
-;;;;;; (19863 8742))
+;;;;;; (20356 35090))
;;; Generated autoloads from vc/cvs-status.el
(autoload 'cvs-status-mode "cvs-status" "\
;;;***
\f
;;;### (autoloads (global-cwarn-mode turn-on-cwarn-mode cwarn-mode)
-;;;;;; "cwarn" "progmodes/cwarn.el" (19845 45374))
+;;;;;; "cwarn" "progmodes/cwarn.el" (20446 34252))
;;; Generated autoloads from progmodes/cwarn.el
(autoload 'cwarn-mode "cwarn" "\
be included in the variable `cwarn-configuration'. By default C and
C++ modes are included.
-With ARG, turn CWarn mode on if and only if arg is positive.
+With a prefix argument ARG, enable the mode if ARG is positive,
+and disable it otherwise. If called from Lisp, enable the mode
+if ARG is omitted or nil.
\(fn &optional ARG)" t nil)
(custom-autoload 'global-cwarn-mode "cwarn" nil)
(autoload 'global-cwarn-mode "cwarn" "\
-Toggle Cwarn mode in every possible buffer.
-With prefix ARG, turn Global-Cwarn mode on if and only if
-ARG is positive.
+Toggle Cwarn mode in all buffers.
+With prefix ARG, enable Global-Cwarn mode if ARG is positive;
+otherwise, disable it. If called from Lisp, enable the mode if
+ARG is omitted or nil.
+
Cwarn mode is enabled in all buffers where
`turn-on-cwarn-mode-if-enabled' would do it.
See `cwarn-mode' for more information on Cwarn mode.
\f
;;;### (autoloads (standard-display-cyrillic-translit cyrillic-encode-alternativnyj-char
;;;;;; cyrillic-encode-koi8-r-char) "cyril-util" "language/cyril-util.el"
-;;;;;; (19845 45374))
+;;;;;; (20244 35516))
;;; Generated autoloads from language/cyril-util.el
(autoload 'cyrillic-encode-koi8-r-char "cyril-util" "\
;;;***
\f
;;;### (autoloads (dabbrev-expand dabbrev-completion) "dabbrev" "dabbrev.el"
-;;;;;; (19989 34789))
+;;;;;; (20412 11425))
;;; Generated autoloads from dabbrev.el
(put 'dabbrev-case-fold-search 'risky-local-variable t)
(put 'dabbrev-case-replace 'risky-local-variable t)
;;;***
\f
;;;### (autoloads (data-debug-new-buffer) "data-debug" "cedet/data-debug.el"
-;;;;;; (19845 45374))
+;;;;;; (20356 35090))
;;; Generated autoloads from cedet/data-debug.el
(autoload 'data-debug-new-buffer "data-debug" "\
;;;***
\f
-;;;### (autoloads (dbus-handle-event) "dbus" "net/dbus.el" (19931
-;;;;;; 11784))
+;;;### (autoloads (dbus-handle-event) "dbus" "net/dbus.el" (20446
+;;;;;; 34252))
;;; Generated autoloads from net/dbus.el
(autoload 'dbus-handle-event "dbus" "\
;;;***
\f
-;;;### (autoloads (dcl-mode) "dcl-mode" "progmodes/dcl-mode.el" (19890
-;;;;;; 42850))
+;;;### (autoloads (dcl-mode) "dcl-mode" "progmodes/dcl-mode.el" (20356
+;;;;;; 35090))
;;; Generated autoloads from progmodes/dcl-mode.el
(autoload 'dcl-mode "dcl-mode" "\
dcl-block-begin-regexp
dcl-block-end-regexp
Regexps that match command lines that begin and end, respectively,
- a block of commmand lines that will be given extra indentation.
+ a block of command lines that will be given extra indentation.
Command lines between THEN-ELSE-ENDIF are always indented; these variables
make it possible to define other places to indent.
Set to nil to disable this feature.
;;;***
\f
;;;### (autoloads (cancel-debug-on-entry debug-on-entry debug) "debug"
-;;;;;; "emacs-lisp/debug.el" (20051 32345))
+;;;;;; "emacs-lisp/debug.el" (20244 35516))
;;; Generated autoloads from emacs-lisp/debug.el
(setq debugger 'debug)
;;;***
\f
;;;### (autoloads (decipher-mode decipher) "decipher" "play/decipher.el"
-;;;;;; (19889 21967))
+;;;;;; (20244 35516))
;;; Generated autoloads from play/decipher.el
(autoload 'decipher "decipher" "\
;;;***
\f
;;;### (autoloads (delimit-columns-rectangle delimit-columns-region
-;;;;;; delimit-columns-customize) "delim-col" "delim-col.el" (19886
-;;;;;; 45771))
+;;;;;; delimit-columns-customize) "delim-col" "delim-col.el" (20244
+;;;;;; 35516))
;;; Generated autoloads from delim-col.el
(autoload 'delimit-columns-customize "delim-col" "\
;;;***
\f
-;;;### (autoloads (delphi-mode) "delphi" "progmodes/delphi.el" (19965
-;;;;;; 52428))
+;;;### (autoloads (delphi-mode) "delphi" "progmodes/delphi.el" (20356
+;;;;;; 35090))
;;; Generated autoloads from progmodes/delphi.el
(autoload 'delphi-mode "delphi" "\
;;;***
\f
-;;;### (autoloads (delete-selection-mode) "delsel" "delsel.el" (19845
-;;;;;; 45374))
+;;;### (autoloads (delete-selection-mode) "delsel" "delsel.el" (20244
+;;;;;; 35516))
;;; Generated autoloads from delsel.el
(defalias 'pending-delete-mode 'delete-selection-mode)
(autoload 'delete-selection-mode "delsel" "\
Toggle Delete Selection mode.
-With prefix ARG, turn Delete Selection mode on if ARG is
-positive, off if ARG is not positive.
+With a prefix argument ARG, enable Delete Selection mode if ARG
+is positive, and disable it otherwise. If called from Lisp,
+enable the mode if ARG is omitted or nil.
When Delete Selection mode is enabled, Transient Mark mode is also
enabled and typed text replaces the selection if the selection is
;;;***
\f
;;;### (autoloads (derived-mode-init-mode-variables define-derived-mode)
-;;;;;; "derived" "emacs-lisp/derived.el" (20054 8529))
+;;;;;; "derived" "emacs-lisp/derived.el" (20438 17064))
;;; Generated autoloads from emacs-lisp/derived.el
(autoload 'define-derived-mode "derived" "\
See Info node `(elisp)Derived Modes' for more details.
-\(fn CHILD PARENT NAME &optional DOCSTRING &rest BODY)" nil (quote macro))
+\(fn CHILD PARENT NAME &optional DOCSTRING &rest BODY)" nil t)
(put 'define-derived-mode 'doc-string-elt '4)
;;;***
\f
;;;### (autoloads (describe-char describe-text-properties) "descr-text"
-;;;;;; "descr-text.el" (19886 45771))
+;;;;;; "descr-text.el" (20434 28080))
;;; Generated autoloads from descr-text.el
(autoload 'describe-text-properties "descr-text" "\
\(fn POS &optional OUTPUT-BUFFER BUFFER)" t nil)
(autoload 'describe-char "descr-text" "\
-Describe the character after POS (interactively, the character after point).
-Is POS is taken to be in buffer BUFFER or current buffer if nil.
-The information includes character code, charset and code points in it,
-syntax, category, how the character is encoded in a file,
-character composition information (if relevant),
-as well as widgets, buttons, overlays, and text properties.
+Describe position POS (interactively, point) and the char after POS.
+POS is taken to be in BUFFER, or the current buffer if BUFFER is nil.
+The information is displayed in buffer `*Help*'.
+
+The position information includes POS; the total size of BUFFER; the
+region limits, if narrowed; the column number; and the horizontal
+scroll amount, if the buffer is horizontally scrolled.
+
+The character information includes the character code; charset and
+code points in it; syntax; category; how the character is encoded in
+BUFFER and in BUFFER's file; character composition information (if
+relevant); the font and font glyphs used to display the character;
+the character's canonical name and other properties defined by the
+Unicode Data Base; and widgets, buttons, overlays, and text properties
+relevant to POS.
\(fn POS &optional BUFFER)" t nil)
;;;### (autoloads (desktop-revert desktop-save-in-desktop-dir desktop-change-dir
;;;;;; desktop-load-default desktop-read desktop-remove desktop-save
;;;;;; desktop-clear desktop-locals-to-save desktop-save-mode) "desktop"
-;;;;;; "desktop.el" (19886 45771))
+;;;;;; "desktop.el" (20451 20881))
;;; Generated autoloads from desktop.el
(defvar desktop-save-mode nil "\
(custom-autoload 'desktop-save-mode "desktop" nil)
(autoload 'desktop-save-mode "desktop" "\
-Toggle desktop saving mode.
-With numeric ARG, turn desktop saving on if ARG is positive, off
-otherwise. If desktop saving is turned on, the state of Emacs is
-saved from one session to another. See variable `desktop-save'
-and function `desktop-read' for details.
+Toggle desktop saving (Desktop Save mode).
+With a prefix argument ARG, enable Desktop Save mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+the mode if ARG is omitted or nil.
+
+If Desktop Save mode is enabled, the state of Emacs is saved from
+one session to another. See variable `desktop-save' and function
+`desktop-read' for details.
\(fn &optional ARG)" t nil)
\f
;;;### (autoloads (gnus-article-outlook-deuglify-article gnus-outlook-deuglify-article
;;;;;; gnus-article-outlook-repair-attribution gnus-article-outlook-unwrap-lines)
-;;;;;; "deuglify" "gnus/deuglify.el" (19845 45374))
+;;;;;; "deuglify" "gnus/deuglify.el" (20244 35516))
;;; Generated autoloads from gnus/deuglify.el
(autoload 'gnus-article-outlook-unwrap-lines "deuglify" "\
;;;***
\f
;;;### (autoloads (diary-mode diary-mail-entries diary) "diary-lib"
-;;;;;; "calendar/diary-lib.el" (19975 1875))
+;;;;;; "calendar/diary-lib.el" (20290 33419))
;;; Generated autoloads from calendar/diary-lib.el
(autoload 'diary "diary-lib" "\
;;;***
\f
;;;### (autoloads (diff-buffer-with-file diff-backup diff diff-command
-;;;;;; diff-switches) "diff" "vc/diff.el" (19999 41597))
+;;;;;; diff-switches) "diff" "vc/diff.el" (20380 26775))
;;; Generated autoloads from vc/diff.el
(defvar diff-switches (purecopy "-c") "\
;;;***
\f
;;;### (autoloads (diff-minor-mode diff-mode) "diff-mode" "vc/diff-mode.el"
-;;;;;; (19930 13389))
+;;;;;; (20415 57974))
;;; Generated autoloads from vc/diff-mode.el
(autoload 'diff-mode "diff-mode" "\
\(fn)" t nil)
(autoload 'diff-minor-mode "diff-mode" "\
-Minor mode for viewing/editing context diffs.
+Toggle Diff minor mode.
+With a prefix argument ARG, enable Diff minor mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+the mode if ARG is omitted or nil.
+
\\{diff-minor-mode-map}
\(fn &optional ARG)" t nil)
;;;***
\f
-;;;### (autoloads (dig) "dig" "net/dig.el" (19845 45374))
+;;;### (autoloads (dig) "dig" "net/dig.el" (20244 35516))
;;; Generated autoloads from net/dig.el
(autoload 'dig "dig" "\
;;;***
\f
;;;### (autoloads (dired-mode dired-noselect dired-other-frame dired-other-window
-;;;;;; dired dired-listing-switches) "dired" "dired.el" (20045 30688))
+;;;;;; dired dired-listing-switches) "dired" "dired.el" (20452 43334))
;;; Generated autoloads from dired.el
(defvar dired-listing-switches (purecopy "-al") "\
;;;***
\f
;;;### (autoloads (dirtrack dirtrack-mode) "dirtrack" "dirtrack.el"
-;;;;;; (19886 45771))
+;;;;;; (20412 11425))
;;; Generated autoloads from dirtrack.el
(autoload 'dirtrack-mode "dirtrack" "\
-Enable or disable Dirtrack directory tracking in a shell buffer.
-This method requires that your shell prompt contain the full
-current working directory at all times, and that `dirtrack-list'
-is set to match the prompt. This is an alternative to
-`shell-dirtrack-mode', which works differently, by tracking `cd'
-and similar commands which change the shell working directory.
+Toggle directory tracking in shell buffers (Dirtrack mode).
+With a prefix argument ARG, enable Dirtrack mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+the mode if ARG is omitted or nil.
-\(fn &optional ARG)" t nil)
+This method requires that your shell prompt contain the current
+working directory at all times, and that you set the variable
+`dirtrack-list' to match the prompt.
-(autoload 'dirtrack "dirtrack" "\
-Determine the current directory by scanning the process output for a prompt.
-The prompt to look for is the first item in `dirtrack-list'.
+This is an alternative to `shell-dirtrack-mode', which works by
+tracking `cd' and similar commands which change the shell working
+directory.
-You can toggle directory tracking by using the function `dirtrack-mode'.
+\(fn &optional ARG)" t nil)
-If directory tracking does not seem to be working, you can use the
-function `dirtrack-debug-mode' to turn on debugging output.
+(autoload 'dirtrack "dirtrack" "\
+Determine the current directory from the process output for a prompt.
+This filter function is used by `dirtrack-mode'. It looks for
+the prompt specified by `dirtrack-list', and calls
+`shell-process-cd' if the directory seems to have changed away
+from `default-directory'.
\(fn INPUT)" nil nil)
;;;***
\f
-;;;### (autoloads (disassemble) "disass" "emacs-lisp/disass.el" (19931
-;;;;;; 11784))
+;;;### (autoloads (disassemble) "disass" "emacs-lisp/disass.el" (20432
+;;;;;; 64735))
;;; Generated autoloads from emacs-lisp/disass.el
(autoload 'disassemble "disass" "\
;;;;;; standard-display-g1 standard-display-ascii standard-display-default
;;;;;; standard-display-8bit describe-current-display-table describe-display-table
;;;;;; set-display-table-slot display-table-slot make-display-table)
-;;;;;; "disp-table" "disp-table.el" (19984 16846))
+;;;;;; "disp-table" "disp-table.el" (20244 35516))
;;; Generated autoloads from disp-table.el
(autoload 'make-display-table "disp-table" "\
;;;***
\f
;;;### (autoloads (dissociated-press) "dissociate" "play/dissociate.el"
-;;;;;; (19845 45374))
+;;;;;; (20244 35516))
;;; Generated autoloads from play/dissociate.el
(autoload 'dissociated-press "dissociate" "\
;;;***
\f
-;;;### (autoloads (dnd-protocol-alist) "dnd" "dnd.el" (19886 45771))
+;;;### (autoloads (dnd-protocol-alist) "dnd" "dnd.el" (20244 35516))
;;; Generated autoloads from dnd.el
(defvar dnd-protocol-alist `((,(purecopy "^file:///") . dnd-open-local-file) (,(purecopy "^file://") . dnd-open-file) (,(purecopy "^file:") . dnd-open-local-file) (,(purecopy "^\\(https?\\|ftp\\|file\\|nfs\\)://") . dnd-open-file)) "\
;;;***
\f
;;;### (autoloads (dns-mode-soa-increment-serial dns-mode) "dns-mode"
-;;;;;; "textmodes/dns-mode.el" (19845 45374))
+;;;;;; "textmodes/dns-mode.el" (20244 35516))
;;; Generated autoloads from textmodes/dns-mode.el
(autoload 'dns-mode "dns-mode" "\
;;;***
\f
;;;### (autoloads (doc-view-bookmark-jump doc-view-minor-mode doc-view-mode-maybe
-;;;;;; doc-view-mode doc-view-mode-p) "doc-view" "doc-view.el" (20002
-;;;;;; 46800))
+;;;;;; doc-view-mode doc-view-mode-p) "doc-view" "doc-view.el" (20377
+;;;;;; 36640))
;;; Generated autoloads from doc-view.el
(autoload 'doc-view-mode-p "doc-view" "\
\(fn)" nil nil)
(autoload 'doc-view-minor-mode "doc-view" "\
-Toggle Doc view minor mode.
-With arg, turn Doc view minor mode on if arg is positive, off otherwise.
+Toggle displaying buffer via Doc View (Doc View minor mode).
+With a prefix argument ARG, enable Doc View minor mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+the mode if ARG is omitted or nil.
+
See the command `doc-view-mode' for more information on this mode.
\(fn &optional ARG)" t nil)
;;;***
\f
-;;;### (autoloads (doctor) "doctor" "play/doctor.el" (19890 42850))
+;;;### (autoloads (doctor) "doctor" "play/doctor.el" (20446 34252))
;;; Generated autoloads from play/doctor.el
(autoload 'doctor "doctor" "\
;;;***
\f
-;;;### (autoloads (double-mode) "double" "double.el" (19845 45374))
+;;;### (autoloads (double-mode) "double" "double.el" (20244 35516))
;;; Generated autoloads from double.el
(autoload 'double-mode "double" "\
-Toggle Double mode.
-With prefix argument ARG, turn Double mode on if ARG is positive, otherwise
-turn it off.
+Toggle special insertion on double keypresses (Double mode).
+With a prefix argument ARG, enable Double mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+the mode if ARG is omitted or nil.
-When Double mode is on, some keys will insert different strings
-when pressed twice. See variable `double-map' for details.
+When Double mode is enabled, some keys will insert different
+strings when pressed twice. See `double-map' for details.
\(fn &optional ARG)" t nil)
;;;***
\f
-;;;### (autoloads (dunnet) "dunnet" "play/dunnet.el" (19845 45374))
+;;;### (autoloads (dunnet) "dunnet" "play/dunnet.el" (20244 35516))
;;; Generated autoloads from play/dunnet.el
(autoload 'dunnet "dunnet" "\
\f
;;;### (autoloads (easy-mmode-defsyntax easy-mmode-defmap easy-mmode-define-keymap
;;;;;; define-globalized-minor-mode define-minor-mode) "easy-mmode"
-;;;;;; "emacs-lisp/easy-mmode.el" (19845 45374))
+;;;;;; "emacs-lisp/easy-mmode.el" (20438 17064))
;;; Generated autoloads from emacs-lisp/easy-mmode.el
(defalias 'easy-mmode-define-minor-mode 'define-minor-mode)
(autoload 'define-minor-mode "easy-mmode" "\
Define a new minor mode MODE.
-This defines the control variable MODE and the toggle command MODE.
+This defines the toggle command MODE and (by default) a control variable
+MODE (you can override this with the :variable keyword, see below).
DOC is the documentation for the mode toggle command.
+The defined mode command takes one optional (prefix) argument.
+Interactively with no prefix argument it toggles the mode.
+With a prefix argument, it enables the mode if the argument is
+positive and otherwise disables it. When called from Lisp, it
+enables the mode if the argument is omitted or nil, and toggles
+the mode if the argument is `toggle'. If DOC is nil this
+function adds a basic doc-string stating these facts.
+
Optional INIT-VALUE is the initial value of the mode's variable.
-Optional LIGHTER is displayed in the modeline when the mode is on.
+Optional LIGHTER is displayed in the mode line when the mode is on.
Optional KEYMAP is the default keymap bound to the mode keymap.
If non-nil, it should be a variable name (whose value is a keymap),
or an expression that returns either a keymap or a list of
- arguments for `easy-mmode-define-keymap'. If KEYMAP is not a symbol,
- this also defines the variable MODE-map.
+ arguments for `easy-mmode-define-keymap'. If you supply a KEYMAP
+ argument that is not a symbol, this macro defines the variable
+ MODE-map and gives it the value that KEYMAP specifies.
BODY contains code to execute each time the mode is enabled or disabled.
It is executed after toggling the mode, and before running MODE-hook.
buffer-local, so don't make the variable MODE buffer-local.
By default, the mode is buffer-local.
:init-value VAL Same as the INIT-VALUE argument.
+ Not used if you also specify :variable.
:lighter SPEC Same as the LIGHTER argument.
:keymap MAP Same as the KEYMAP argument.
:require SYM Same as in `defcustom'.
-:variable PLACE The location (as can be used with `setf') to use instead
- of the variable MODE to store the state of the mode. PLACE
- can also be of the form (GET . SET) where GET is an expression
- that returns the current state and SET is a function that takes
- a new state and sets it. If you specify a :variable, this
- function assumes it is defined elsewhere.
+:variable PLACE The location to use instead of the variable MODE to store
+ the state of the mode. This can be simply a different
+ named variable, or more generally anything that can be used
+ with the CL macro `setf'. PLACE can also be of the form
+ (GET . SET), where GET is an expression that returns the
+ current state, and SET is a function that takes one argument,
+ the new state, and sets it. If you specify a :variable,
+ this function does not define a MODE variable (nor any of
+ the terms used in :variable).
+:after-hook A single lisp form which is evaluated after the mode hooks
+ have been run. It should not be quoted.
For example, you could write
(define-minor-mode foo-mode \"If enabled, foo on you!\"
:lighter \" Foo\" :require 'foo :global t :group 'hassle :version \"27.5\"
...BODY CODE...)
-\(fn MODE DOC &optional INIT-VALUE LIGHTER KEYMAP &rest BODY)" nil (quote macro))
+\(fn MODE DOC &optional INIT-VALUE LIGHTER KEYMAP &rest BODY)" nil t)
+
+(put 'define-minor-mode 'doc-string-elt '2)
(defalias 'easy-mmode-define-global-mode 'define-globalized-minor-mode)
prevent problems with derived modes, that is, major modes that
call another major mode in their body.
-\(fn GLOBAL-MODE MODE TURN-ON &rest KEYS)" nil (quote macro))
+\(fn GLOBAL-MODE MODE TURN-ON &rest KEYS)" nil t)
+
+(put 'define-globalized-minor-mode 'doc-string-elt '2)
(autoload 'easy-mmode-define-keymap "easy-mmode" "\
Return a keymap built from bindings BS.
The M, BS, and ARGS arguments are as per that function. DOC is
the constant's documentation.
-\(fn M BS DOC &rest ARGS)" nil (quote macro))
+\(fn M BS DOC &rest ARGS)" nil t)
(autoload 'easy-mmode-defsyntax "easy-mmode" "\
Define variable ST as a syntax-table.
CSS contains a list of syntax specifications of the form (CHAR . SYNTAX).
-\(fn ST CSS DOC &rest ARGS)" nil (quote macro))
+\(fn ST CSS DOC &rest ARGS)" nil t)
;;;***
\f
;;;### (autoloads (easy-menu-change easy-menu-create-menu easy-menu-do-define
-;;;;;; easy-menu-define) "easymenu" "emacs-lisp/easymenu.el" (19845
-;;;;;; 45374))
+;;;;;; easy-menu-define) "easymenu" "emacs-lisp/easymenu.el" (20438
+;;;;;; 17064))
;;; Generated autoloads from emacs-lisp/easymenu.el
(autoload 'easy-menu-define "easymenu" "\
KEYS is nil, a string or a vector; nil or a keyboard equivalent to this
menu item.
-This is a hint that will considerably speed up Emacs' first display of
+This is a hint that will considerably speed up Emacs's first display of
a menu. Use `:key-sequence nil' when you know that this menu item has no
keyboard equivalent.
A menu item can be a list with the same format as MENU. This is a submenu.
-\(fn SYMBOL MAPS DOC MENU)" nil (quote macro))
+\(fn SYMBOL MAPS DOC MENU)" nil t)
(put 'easy-menu-define 'lisp-indent-function 'defun)
;;;;;; ebnf-eps-file ebnf-eps-directory ebnf-spool-region ebnf-spool-buffer
;;;;;; ebnf-spool-file ebnf-spool-directory ebnf-print-region ebnf-print-buffer
;;;;;; ebnf-print-file ebnf-print-directory ebnf-customize) "ebnf2ps"
-;;;;;; "progmodes/ebnf2ps.el" (19845 45374))
+;;;;;; "progmodes/ebnf2ps.el" (20373 41604))
;;; Generated autoloads from progmodes/ebnf2ps.el
(autoload 'ebnf-customize "ebnf2ps" "\
;;;;;; ebrowse-tags-find-declaration-other-window ebrowse-tags-find-definition
;;;;;; ebrowse-tags-view-definition ebrowse-tags-find-declaration
;;;;;; ebrowse-tags-view-declaration ebrowse-member-mode ebrowse-electric-choose-tree
-;;;;;; ebrowse-tree-mode) "ebrowse" "progmodes/ebrowse.el" (19890
-;;;;;; 42850))
+;;;;;; ebrowse-tree-mode) "ebrowse" "progmodes/ebrowse.el" (20434
+;;;;;; 28080))
;;; Generated autoloads from progmodes/ebrowse.el
(autoload 'ebrowse-tree-mode "ebrowse" "\
;;;***
\f
;;;### (autoloads (electric-buffer-list) "ebuff-menu" "ebuff-menu.el"
-;;;;;; (19845 45374))
+;;;;;; (20438 17064))
;;; Generated autoloads from ebuff-menu.el
(autoload 'electric-buffer-list "ebuff-menu" "\
-Pop up a buffer describing the set of Emacs buffers.
-Vaguely like ITS lunar select buffer; combining typeoutoid buffer
-listing with menuoid buffer selection.
-
-If the very next character typed is a space then the buffer list
-window disappears. Otherwise, one may move around in the buffer list
-window, marking buffers to be selected, saved or deleted.
-
-To exit and select a new buffer, type a space when the cursor is on
-the appropriate line of the buffer-list window. Other commands are
-much like those of `Buffer-menu-mode'.
+Pop up the Buffer Menu in an \"electric\" window.
+If you type SPC or RET (`Electric-buffer-menu-select'), that
+selects the buffer at point and quits the \"electric\" window.
+Otherwise, you can move around in the Buffer Menu, marking
+buffers to be selected, saved or deleted; these other commands
+are much like those of `Buffer-menu-mode'.
Run hooks in `electric-buffer-menu-mode-hook' on entry.
-\\{electric-buffer-menu-mode-map}
+\\<electric-buffer-menu-mode-map>
+\\[keyboard-quit] or \\[Electric-buffer-menu-quit] -- exit buffer menu, returning to previous window and buffer
+ configuration. If the very first character typed is a space, it
+ also has this effect.
+\\[Electric-buffer-menu-select] -- select buffer of line point is on.
+ Also show buffers marked with m in other windows,
+ deletes buffers marked with \"D\", and saves those marked with \"S\".
+\\[Buffer-menu-mark] -- mark buffer to be displayed.
+\\[Buffer-menu-not-modified] -- clear modified-flag on that buffer.
+\\[Buffer-menu-save] -- mark that buffer to be saved.
+\\[Buffer-menu-delete] or \\[Buffer-menu-delete-backwards] -- mark that buffer to be deleted.
+\\[Buffer-menu-unmark] -- remove all kinds of marks from current line.
+\\[Electric-buffer-menu-mode-view-buffer] -- view buffer, returning when done.
+\\[Buffer-menu-backup-unmark] -- back up a line and remove marks.
\(fn ARG)" t nil)
;;;***
\f
;;;### (autoloads (Electric-command-history-redo-expression) "echistory"
-;;;;;; "echistory.el" (19886 45771))
+;;;;;; "echistory.el" (20244 35516))
;;; Generated autoloads from echistory.el
(autoload 'Electric-command-history-redo-expression "echistory" "\
;;;***
\f
;;;### (autoloads (ecomplete-setup) "ecomplete" "gnus/ecomplete.el"
-;;;;;; (19845 45374))
+;;;;;; (20244 35516))
;;; Generated autoloads from gnus/ecomplete.el
(autoload 'ecomplete-setup "ecomplete" "\
;;;***
\f
-;;;### (autoloads (global-ede-mode) "ede" "cedet/ede.el" (19914 25180))
+;;;### (autoloads (global-ede-mode) "ede" "cedet/ede.el" (20244 35516))
;;; Generated autoloads from cedet/ede.el
(defvar global-ede-mode nil "\
(autoload 'global-ede-mode "ede" "\
Toggle global EDE (Emacs Development Environment) mode.
-With non-nil argument ARG, enable global EDE mode if ARG is
-positive; otherwise, disable it.
+With a prefix argument ARG, enable global EDE mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+the mode if ARG is omitted or nil.
This global minor mode enables `ede-minor-mode' in all buffers in
an EDE controlled project.
\f
;;;### (autoloads (edebug-all-forms edebug-all-defs edebug-eval-top-level-form
;;;;;; edebug-basic-spec edebug-all-forms edebug-all-defs) "edebug"
-;;;;;; "emacs-lisp/edebug.el" (20050 11479))
+;;;;;; "emacs-lisp/edebug.el" (20446 34252))
;;; Generated autoloads from emacs-lisp/edebug.el
(defvar edebug-all-defs nil "\
;;;;;; ediff-merge-directories-with-ancestor ediff-merge-directories
;;;;;; ediff-directories3 ediff-directory-revisions ediff-directories
;;;;;; ediff-buffers3 ediff-buffers ediff-backup ediff-current-file
-;;;;;; ediff-files3 ediff-files) "ediff" "vc/ediff.el" (19996 8027))
+;;;;;; ediff-files3 ediff-files) "ediff" "vc/ediff.el" (20373 41604))
;;; Generated autoloads from vc/ediff.el
(autoload 'ediff-files "ediff" "\
;;;***
\f
;;;### (autoloads (ediff-customize) "ediff-help" "vc/ediff-help.el"
-;;;;;; (19845 45374))
+;;;;;; (20244 35516))
;;; Generated autoloads from vc/ediff-help.el
(autoload 'ediff-customize "ediff-help" "\
;;;***
\f
;;;### (autoloads (ediff-show-registry) "ediff-mult" "vc/ediff-mult.el"
-;;;;;; (19845 45374))
+;;;;;; (20244 35516))
;;; Generated autoloads from vc/ediff-mult.el
(autoload 'ediff-show-registry "ediff-mult" "\
;;;***
\f
;;;### (autoloads (ediff-toggle-use-toolbar ediff-toggle-multiframe)
-;;;;;; "ediff-util" "vc/ediff-util.el" (19981 40664))
+;;;;;; "ediff-util" "vc/ediff-util.el" (20318 5885))
;;; Generated autoloads from vc/ediff-util.el
(autoload 'ediff-toggle-multiframe "ediff-util" "\
\f
;;;### (autoloads (format-kbd-macro read-kbd-macro edit-named-kbd-macro
;;;;;; edit-last-kbd-macro edit-kbd-macro) "edmacro" "edmacro.el"
-;;;;;; (19886 45771))
+;;;;;; (20438 17064))
;;; Generated autoloads from edmacro.el
(autoload 'edit-kbd-macro "edmacro" "\
;;;***
\f
;;;### (autoloads (edt-emulation-on edt-set-scroll-margins) "edt"
-;;;;;; "emulation/edt.el" (19845 45374))
+;;;;;; "emulation/edt.el" (20448 36271))
;;; Generated autoloads from emulation/edt.el
(autoload 'edt-set-scroll-margins "edt" "\
;;;***
\f
;;;### (autoloads (electric-helpify with-electric-help) "ehelp" "ehelp.el"
-;;;;;; (19865 50420))
+;;;;;; (20244 35516))
;;; Generated autoloads from ehelp.el
(autoload 'with-electric-help "ehelp" "\
;;;***
\f
;;;### (autoloads (turn-on-eldoc-mode eldoc-mode eldoc-minor-mode-string)
-;;;;;; "eldoc" "emacs-lisp/eldoc.el" (19845 45374))
+;;;;;; "eldoc" "emacs-lisp/eldoc.el" (20244 35516))
;;; Generated autoloads from emacs-lisp/eldoc.el
(defvar eldoc-minor-mode-string (purecopy " ElDoc") "\
(custom-autoload 'eldoc-minor-mode-string "eldoc" t)
(autoload 'eldoc-mode "eldoc" "\
-Toggle ElDoc mode on or off.
-In ElDoc mode, the echo area displays information about a
-function or variable in the text where point is. If point is
-on a documented variable, it displays the first line of that
-variable's doc string. Otherwise it displays the argument list
-of the function called in the expression point is on.
-
-With prefix ARG, turn ElDoc mode on if and only if ARG is positive.
+Toggle echo area display of Lisp objects at point (ElDoc mode).
+With a prefix argument ARG, enable ElDoc mode if ARG is positive,
+and disable it otherwise. If called from Lisp, enable ElDoc mode
+if ARG is omitted or nil.
+
+ElDoc mode is a buffer-local minor mode. When enabled, the echo
+area displays information about a function or variable in the
+text where point is. If point is on a documented variable, it
+displays the first line of that variable's doc string. Otherwise
+it displays the argument list of the function called in the
+expression point is on.
\(fn &optional ARG)" t nil)
;;;***
\f
;;;### (autoloads (electric-layout-mode electric-pair-mode electric-indent-mode)
-;;;;;; "electric" "electric.el" (19886 45771))
+;;;;;; "electric" "electric.el" (20373 41604))
;;; Generated autoloads from electric.el
(defvar electric-indent-chars '(10) "\
(custom-autoload 'electric-indent-mode "electric" nil)
(autoload 'electric-indent-mode "electric" "\
-Automatically reindent lines of code when inserting particular chars.
-`electric-indent-chars' specifies the set of chars that should cause reindentation.
+Toggle on-the-fly reindentation (Electric Indent mode).
+With a prefix argument ARG, enable Electric Indent mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+the mode if ARG is omitted or nil.
+
+This is a global minor mode. When enabled, it reindents whenever
+the hook `electric-indent-functions' returns non-nil, or you
+insert a character from `electric-indent-chars'.
\(fn &optional ARG)" t nil)
(custom-autoload 'electric-pair-mode "electric" nil)
(autoload 'electric-pair-mode "electric" "\
-Automatically pair-up parens when inserting an open paren.
+Toggle automatic parens pairing (Electric Pair mode).
+With a prefix argument ARG, enable Electric Pair mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+the mode if ARG is omitted or nil.
+
+Electric Pair mode is a global minor mode. When enabled, typing
+an open parenthesis automatically inserts the corresponding
+closing parenthesis. (Likewise for brackets, etc.)
+
+See options `electric-pair-pairs' and `electric-pair-skip-self'.
\(fn &optional ARG)" t nil)
(autoload 'electric-layout-mode "electric" "\
Automatically insert newlines around some chars.
+With a prefix argument ARG, enable Electric Layout mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+the mode if ARG is omitted or nil.
+The variable `electric-layout-rules' says when and how to insert newlines.
\(fn &optional ARG)" t nil)
;;;***
\f
-;;;### (autoloads (elide-head) "elide-head" "elide-head.el" (19845
-;;;;;; 45374))
+;;;### (autoloads (elide-head) "elide-head" "elide-head.el" (20244
+;;;;;; 35516))
;;; Generated autoloads from elide-head.el
(autoload 'elide-head "elide-head" "\
\f
;;;### (autoloads (elint-initialize elint-defun elint-current-buffer
;;;;;; elint-directory elint-file) "elint" "emacs-lisp/elint.el"
-;;;;;; (19845 45374))
+;;;;;; (20423 37562))
;;; Generated autoloads from emacs-lisp/elint.el
(autoload 'elint-file "elint" "\
;;;***
\f
;;;### (autoloads (elp-results elp-instrument-package elp-instrument-list
-;;;;;; elp-instrument-function) "elp" "emacs-lisp/elp.el" (19981
-;;;;;; 40664))
+;;;;;; elp-instrument-function) "elp" "emacs-lisp/elp.el" (20244
+;;;;;; 35516))
;;; Generated autoloads from emacs-lisp/elp.el
(autoload 'elp-instrument-function "elp" "\
;;;***
\f
;;;### (autoloads (emacs-lock-mode) "emacs-lock" "emacs-lock.el"
-;;;;;; (19988 13913))
+;;;;;; (20412 11425))
;;; Generated autoloads from emacs-lock.el
(autoload 'emacs-lock-mode "emacs-lock" "\
Toggle Emacs Lock mode in the current buffer.
+If called with a plain prefix argument, ask for the locking mode
+to be used. With any other prefix ARG, turn mode on if ARG is
+positive, off otherwise. If called from Lisp, enable the mode if
+ARG is omitted or nil.
-With \\[universal-argument], ask for the locking mode to be used.
-With other prefix ARG, turn mode on if ARG is positive, off otherwise.
-
-Initially, if the user does not pass an explicit locking mode, it defaults
-to `emacs-lock-default-locking-mode' (which see); afterwards, the locking
-mode most recently set on the buffer is used instead.
+Initially, if the user does not pass an explicit locking mode, it
+defaults to `emacs-lock-default-locking-mode' (which see);
+afterwards, the locking mode most recently set on the buffer is
+used instead.
When called from Elisp code, ARG can be any locking mode:
;;;***
\f
-;;;### (autoloads (report-emacs-bug) "emacsbug" "mail/emacsbug.el"
-;;;;;; (19978 37530))
+;;;### (autoloads (report-emacs-bug-query-existing-bugs report-emacs-bug)
+;;;;;; "emacsbug" "mail/emacsbug.el" (20432 42254))
;;; Generated autoloads from mail/emacsbug.el
(autoload 'report-emacs-bug "emacsbug" "\
\(fn TOPIC &optional RECENT-KEYS)" t nil)
+(autoload 'report-emacs-bug-query-existing-bugs "emacsbug" "\
+Query for KEYWORDS at `report-emacs-bug-tracker-url', and return the result.
+The result is an alist with items of the form (URL SUBJECT NO).
+
+\(fn KEYWORDS)" t nil)
+
;;;***
\f
;;;### (autoloads (emerge-merge-directories emerge-revisions-with-ancestor
;;;;;; emerge-revisions emerge-files-with-ancestor-remote emerge-files-remote
;;;;;; emerge-files-with-ancestor-command emerge-files-command emerge-buffers-with-ancestor
;;;;;; emerge-buffers emerge-files-with-ancestor emerge-files) "emerge"
-;;;;;; "vc/emerge.el" (19845 45374))
+;;;;;; "vc/emerge.el" (20356 35090))
;;; Generated autoloads from vc/emerge.el
(autoload 'emerge-files "emerge" "\
;;;***
\f
;;;### (autoloads (enriched-decode enriched-encode enriched-mode)
-;;;;;; "enriched" "textmodes/enriched.el" (19845 45374))
+;;;;;; "enriched" "textmodes/enriched.el" (20276 3849))
;;; Generated autoloads from textmodes/enriched.el
(autoload 'enriched-mode "enriched" "\
Minor mode for editing text/enriched files.
These are files with embedded formatting information in the MIME standard
text/enriched format.
+
+With a prefix argument ARG, enable the mode if ARG is positive,
+and disable it otherwise. If called from Lisp, enable the mode
+if ARG is omitted or nil.
+
Turning the mode on or off runs `enriched-mode-hook'.
More information about Enriched mode is available in the file
;;;;;; epa-sign-region epa-verify-cleartext-in-region epa-verify-region
;;;;;; epa-decrypt-armor-in-region epa-decrypt-region epa-encrypt-file
;;;;;; epa-sign-file epa-verify-file epa-decrypt-file epa-select-keys
-;;;;;; epa-list-secret-keys epa-list-keys) "epa" "epa.el" (20042
-;;;;;; 17367))
+;;;;;; epa-list-secret-keys epa-list-keys) "epa" "epa.el" (20434
+;;;;;; 28080))
;;; Generated autoloads from epa.el
(autoload 'epa-list-keys "epa" "\
;;;***
\f
;;;### (autoloads (epa-dired-do-encrypt epa-dired-do-sign epa-dired-do-verify
-;;;;;; epa-dired-do-decrypt) "epa-dired" "epa-dired.el" (19865 50420))
+;;;;;; epa-dired-do-decrypt) "epa-dired" "epa-dired.el" (20244 35516))
;;; Generated autoloads from epa-dired.el
(autoload 'epa-dired-do-decrypt "epa-dired" "\
;;;***
\f
;;;### (autoloads (epa-file-disable epa-file-enable epa-file-handler)
-;;;;;; "epa-file" "epa-file.el" (20038 20303))
+;;;;;; "epa-file" "epa-file.el" (20244 35516))
;;; Generated autoloads from epa-file.el
(autoload 'epa-file-handler "epa-file" "\
\f
;;;### (autoloads (epa-global-mail-mode epa-mail-import-keys epa-mail-encrypt
;;;;;; epa-mail-sign epa-mail-verify epa-mail-decrypt epa-mail-mode)
-;;;;;; "epa-mail" "epa-mail.el" (20043 38232))
+;;;;;; "epa-mail" "epa-mail.el" (20318 5885))
;;; Generated autoloads from epa-mail.el
(autoload 'epa-mail-mode "epa-mail" "\
A minor-mode for composing encrypted/clearsigned mails.
+With a prefix argument ARG, enable the mode if ARG is positive,
+and disable it otherwise. If called from Lisp, enable the mode
+if ARG is omitted or nil.
\(fn &optional ARG)" t nil)
(autoload 'epa-global-mail-mode "epa-mail" "\
Minor mode to hook EasyPG into Mail mode.
+With a prefix argument ARG, enable the mode if ARG is positive,
+and disable it otherwise. If called from Lisp, enable the mode
+if ARG is omitted or nil.
\(fn &optional ARG)" t nil)
;;;***
\f
-;;;### (autoloads (epg-make-context) "epg" "epg.el" (20031 47065))
+;;;### (autoloads (epg-make-context) "epg" "epg.el" (20244 35516))
;;; Generated autoloads from epg.el
(autoload 'epg-make-context "epg" "\
;;;***
\f
;;;### (autoloads (epg-expand-group epg-check-configuration epg-configuration)
-;;;;;; "epg-config" "epg-config.el" (19845 45374))
+;;;;;; "epg-config" "epg-config.el" (20373 41604))
;;; Generated autoloads from epg-config.el
(autoload 'epg-configuration "epg-config" "\
;;;***
\f
-;;;### (autoloads (erc-handle-irc-url erc erc-select-read-args) "erc"
-;;;;;; "erc/erc.el" (19986 58615))
+;;;### (autoloads (erc-handle-irc-url erc-tls erc erc-select-read-args)
+;;;;;; "erc" "erc/erc.el" (20446 34252))
;;; Generated autoloads from erc/erc.el
(autoload 'erc-select-read-args "erc" "\
(defalias 'erc-select 'erc)
+(autoload 'erc-tls "erc" "\
+Interactively select TLS connection parameters and run ERC.
+Arguments are the same as for `erc'.
+
+\(fn &rest R)" t nil)
+
(autoload 'erc-handle-irc-url "erc" "\
Use ERC to IRC on HOST:PORT in CHANNEL as USER with PASSWORD.
If ERC is already connected to HOST:PORT, simply /join CHANNEL.
;;;***
\f
-;;;### (autoloads nil "erc-autoaway" "erc/erc-autoaway.el" (19845
-;;;;;; 45374))
+;;;### (autoloads nil "erc-autoaway" "erc/erc-autoaway.el" (20356
+;;;;;; 35090))
;;; Generated autoloads from erc/erc-autoaway.el
(autoload 'erc-autoaway-mode "erc-autoaway")
;;;***
\f
-;;;### (autoloads nil "erc-button" "erc/erc-button.el" (19895 48172))
+;;;### (autoloads nil "erc-button" "erc/erc-button.el" (20434 28080))
;;; Generated autoloads from erc/erc-button.el
(autoload 'erc-button-mode "erc-button" nil t)
;;;***
\f
-;;;### (autoloads nil "erc-capab" "erc/erc-capab.el" (19845 45374))
+;;;### (autoloads nil "erc-capab" "erc/erc-capab.el" (20244 35516))
;;; Generated autoloads from erc/erc-capab.el
(autoload 'erc-capab-identify-mode "erc-capab" nil t)
;;;***
\f
-;;;### (autoloads nil "erc-compat" "erc/erc-compat.el" (19845 45374))
+;;;### (autoloads nil "erc-compat" "erc/erc-compat.el" (20318 5885))
;;; Generated autoloads from erc/erc-compat.el
(autoload 'erc-define-minor-mode "erc-compat")
;;;***
\f
;;;### (autoloads (erc-ctcp-query-DCC pcomplete/erc-mode/DCC erc-cmd-DCC)
-;;;;;; "erc-dcc" "erc/erc-dcc.el" (19895 48172))
+;;;;;; "erc-dcc" "erc/erc-dcc.el" (20446 34252))
;;; Generated autoloads from erc/erc-dcc.el
(autoload 'erc-dcc-mode "erc-dcc")
\(fn)" nil nil)
(defvar erc-ctcp-query-DCC-hook '(erc-ctcp-query-DCC) "\
-Hook variable for CTCP DCC queries")
+Hook variable for CTCP DCC queries.")
(autoload 'erc-ctcp-query-DCC "erc-dcc" "\
The function called when a CTCP DCC request is detected by the client.
;;;;;; erc-ezb-add-session erc-ezb-end-of-session-list erc-ezb-init-session-list
;;;;;; erc-ezb-identify erc-ezb-notice-autodetect erc-ezb-lookup-action
;;;;;; erc-ezb-get-login erc-cmd-ezb) "erc-ezbounce" "erc/erc-ezbounce.el"
-;;;;;; (19845 45374))
+;;;;;; (20244 35516))
;;; Generated autoloads from erc/erc-ezbounce.el
(autoload 'erc-cmd-ezb "erc-ezbounce" "\
;;;***
\f
-;;;### (autoloads (erc-fill) "erc-fill" "erc/erc-fill.el" (19845
-;;;;;; 45374))
+;;;### (autoloads (erc-fill) "erc-fill" "erc/erc-fill.el" (20244
+;;;;;; 35516))
;;; Generated autoloads from erc/erc-fill.el
(autoload 'erc-fill-mode "erc-fill" nil t)
;;;***
\f
;;;### (autoloads (erc-identd-stop erc-identd-start) "erc-identd"
-;;;;;; "erc/erc-identd.el" (19845 45374))
+;;;;;; "erc/erc-identd.el" (20244 35516))
;;; Generated autoloads from erc/erc-identd.el
(autoload 'erc-identd-mode "erc-identd")
;;;***
\f
;;;### (autoloads (erc-create-imenu-index) "erc-imenu" "erc/erc-imenu.el"
-;;;;;; (19845 45374))
+;;;;;; (20244 35516))
;;; Generated autoloads from erc/erc-imenu.el
(autoload 'erc-create-imenu-index "erc-imenu" "\
;;;***
\f
-;;;### (autoloads nil "erc-join" "erc/erc-join.el" (19845 45374))
+;;;### (autoloads nil "erc-join" "erc/erc-join.el" (20356 35090))
;;; Generated autoloads from erc/erc-join.el
(autoload 'erc-autojoin-mode "erc-join" nil t)
;;;***
\f
-;;;### (autoloads nil "erc-list" "erc/erc-list.el" (19845 45374))
+;;;### (autoloads nil "erc-list" "erc/erc-list.el" (20244 35516))
;;; Generated autoloads from erc/erc-list.el
(autoload 'erc-list-mode "erc-list")
;;;***
\f
;;;### (autoloads (erc-save-buffer-in-logs erc-logging-enabled) "erc-log"
-;;;;;; "erc/erc-log.el" (19845 45374))
+;;;;;; "erc/erc-log.el" (20356 35090))
;;; Generated autoloads from erc/erc-log.el
(autoload 'erc-log-mode "erc-log" nil t)
Return non-nil if logging is enabled for BUFFER.
If BUFFER is nil, the value of `current-buffer' is used.
Logging is enabled if `erc-log-channels-directory' is non-nil, the directory
-is writeable (it will be created as necessary) and
+is writable (it will be created as necessary) and
`erc-enable-logging' returns a non-nil value.
\(fn &optional BUFFER)" nil nil)
;;;### (autoloads (erc-delete-dangerous-host erc-add-dangerous-host
;;;;;; erc-delete-keyword erc-add-keyword erc-delete-fool erc-add-fool
;;;;;; erc-delete-pal erc-add-pal) "erc-match" "erc/erc-match.el"
-;;;;;; (19845 45374))
+;;;;;; (20434 28080))
;;; Generated autoloads from erc/erc-match.el
(autoload 'erc-match-mode "erc-match")
;;;***
\f
-;;;### (autoloads nil "erc-menu" "erc/erc-menu.el" (19845 45374))
+;;;### (autoloads nil "erc-menu" "erc/erc-menu.el" (20244 35516))
;;; Generated autoloads from erc/erc-menu.el
(autoload 'erc-menu-mode "erc-menu" nil t)
;;;***
\f
;;;### (autoloads (erc-cmd-WHOLEFT) "erc-netsplit" "erc/erc-netsplit.el"
-;;;;;; (19845 45374))
+;;;;;; (20244 35516))
;;; Generated autoloads from erc/erc-netsplit.el
(autoload 'erc-netsplit-mode "erc-netsplit")
;;;***
\f
;;;### (autoloads (erc-server-select erc-determine-network) "erc-networks"
-;;;;;; "erc/erc-networks.el" (19845 45374))
+;;;;;; "erc/erc-networks.el" (20244 35516))
;;; Generated autoloads from erc/erc-networks.el
(autoload 'erc-determine-network "erc-networks" "\
;;;***
\f
;;;### (autoloads (pcomplete/erc-mode/NOTIFY erc-cmd-NOTIFY) "erc-notify"
-;;;;;; "erc/erc-notify.el" (19845 45374))
+;;;;;; "erc/erc-notify.el" (20356 35090))
;;; Generated autoloads from erc/erc-notify.el
(autoload 'erc-notify-mode "erc-notify" nil t)
(autoload 'erc-cmd-NOTIFY "erc-notify" "\
Change `erc-notify-list' or list current notify-list members online.
-Without args, list the current list of notificated people online,
+Without args, list the current list of notified people online,
with args, toggle notify status of people.
\(fn &rest ARGS)" nil nil)
;;;***
\f
-;;;### (autoloads nil "erc-page" "erc/erc-page.el" (19845 45374))
+;;;### (autoloads nil "erc-page" "erc/erc-page.el" (20244 35516))
;;; Generated autoloads from erc/erc-page.el
(autoload 'erc-page-mode "erc-page")
;;;***
\f
-;;;### (autoloads nil "erc-pcomplete" "erc/erc-pcomplete.el" (19936
-;;;;;; 52203))
+;;;### (autoloads nil "erc-pcomplete" "erc/erc-pcomplete.el" (20356
+;;;;;; 35090))
;;; Generated autoloads from erc/erc-pcomplete.el
(autoload 'erc-completion-mode "erc-pcomplete" nil t)
;;;***
\f
-;;;### (autoloads nil "erc-replace" "erc/erc-replace.el" (19845 45374))
+;;;### (autoloads nil "erc-replace" "erc/erc-replace.el" (20244 35516))
;;; Generated autoloads from erc/erc-replace.el
(autoload 'erc-replace-mode "erc-replace")
;;;***
\f
-;;;### (autoloads nil "erc-ring" "erc/erc-ring.el" (19845 45374))
+;;;### (autoloads nil "erc-ring" "erc/erc-ring.el" (20244 35516))
;;; Generated autoloads from erc/erc-ring.el
(autoload 'erc-ring-mode "erc-ring" nil t)
;;;***
\f
;;;### (autoloads (erc-nickserv-identify erc-nickserv-identify-mode)
-;;;;;; "erc-services" "erc/erc-services.el" (19845 45374))
+;;;;;; "erc-services" "erc/erc-services.el" (20359 18671))
;;; Generated autoloads from erc/erc-services.el
(autoload 'erc-services-mode "erc-services" nil t)
;;;***
\f
-;;;### (autoloads nil "erc-sound" "erc/erc-sound.el" (19845 45374))
+;;;### (autoloads nil "erc-sound" "erc/erc-sound.el" (20356 35090))
;;; Generated autoloads from erc/erc-sound.el
(autoload 'erc-sound-mode "erc-sound")
;;;***
\f
;;;### (autoloads (erc-speedbar-browser) "erc-speedbar" "erc/erc-speedbar.el"
-;;;;;; (19845 45374))
+;;;;;; (20244 35516))
;;; Generated autoloads from erc/erc-speedbar.el
(autoload 'erc-speedbar-browser "erc-speedbar" "\
;;;***
\f
-;;;### (autoloads nil "erc-spelling" "erc/erc-spelling.el" (19845
-;;;;;; 45374))
+;;;### (autoloads nil "erc-spelling" "erc/erc-spelling.el" (20244
+;;;;;; 35516))
;;; Generated autoloads from erc/erc-spelling.el
(autoload 'erc-spelling-mode "erc-spelling" nil t)
;;;***
\f
-;;;### (autoloads nil "erc-stamp" "erc/erc-stamp.el" (19845 45374))
+;;;### (autoloads nil "erc-stamp" "erc/erc-stamp.el" (20434 28080))
;;; Generated autoloads from erc/erc-stamp.el
(autoload 'erc-timestamp-mode "erc-stamp" nil t)
;;;***
\f
;;;### (autoloads (erc-track-minor-mode) "erc-track" "erc/erc-track.el"
-;;;;;; (19845 45374))
+;;;;;; (20428 57510))
;;; Generated autoloads from erc/erc-track.el
(defvar erc-track-minor-mode nil "\
(custom-autoload 'erc-track-minor-mode "erc-track" nil)
(autoload 'erc-track-minor-mode "erc-track" "\
-Global minor mode for tracking ERC buffers and showing activity in the
-mode line.
+Toggle mode line display of ERC activity (ERC Track minor mode).
+With a prefix argument ARG, enable ERC Track minor mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+the mode if ARG is omitted or nil.
-This exists for the sole purpose of providing the C-c C-SPC and
-C-c C-@ keybindings. Make sure that you have enabled the track
-module, otherwise the keybindings will not do anything useful.
+ERC Track minor mode is a global minor mode. It exists for the
+sole purpose of providing the C-c C-SPC and C-c C-@ keybindings.
+Make sure that you have enabled the track module, otherwise the
+keybindings will not do anything useful.
\(fn &optional ARG)" t nil)
(autoload 'erc-track-mode "erc-track" nil t)
;;;***
\f
;;;### (autoloads (erc-truncate-buffer erc-truncate-buffer-to-size)
-;;;;;; "erc-truncate" "erc/erc-truncate.el" (19845 45374))
+;;;;;; "erc-truncate" "erc/erc-truncate.el" (20356 35090))
;;; Generated autoloads from erc/erc-truncate.el
(autoload 'erc-truncate-mode "erc-truncate" nil t)
;;;***
\f
;;;### (autoloads (erc-xdcc-add-file) "erc-xdcc" "erc/erc-xdcc.el"
-;;;;;; (19845 45374))
+;;;;;; (20356 35090))
;;; Generated autoloads from erc/erc-xdcc.el
(autoload 'erc-xdcc-mode "erc-xdcc")
\f
;;;### (autoloads (ert-describe-test ert-run-tests-interactively
;;;;;; ert-run-tests-batch-and-exit ert-run-tests-batch ert-deftest)
-;;;;;; "ert" "emacs-lisp/ert.el" (19846 36966))
+;;;;;; "ert" "emacs-lisp/ert.el" (20356 35090))
;;; Generated autoloads from emacs-lisp/ert.el
(autoload 'ert-deftest "ert" "\
\(fn NAME () [DOCSTRING] [:expected-result RESULT-TYPE] [:tags '(TAG...)] BODY...)" nil (quote macro))
-(put 'ert-deftest 'lisp-indent-function '2)
-
-(put 'ert-deftest 'doc-string-elt '3)
-
(put 'ert-deftest 'lisp-indent-function 2)
(put 'ert-info 'lisp-indent-function 1)
;;;***
\f
;;;### (autoloads (ert-kill-all-test-buffers) "ert-x" "emacs-lisp/ert-x.el"
-;;;;;; (19845 45374))
+;;;;;; (20373 41604))
;;; Generated autoloads from emacs-lisp/ert-x.el
(put 'ert-with-test-buffer 'lisp-indent-function 1)
;;;***
\f
-;;;### (autoloads (eshell-mode) "esh-mode" "eshell/esh-mode.el" (19890
-;;;;;; 42850))
+;;;### (autoloads (eshell-mode) "esh-mode" "eshell/esh-mode.el" (20428
+;;;;;; 57510))
;;; Generated autoloads from eshell/esh-mode.el
(autoload 'eshell-mode "esh-mode" "\
;;;***
\f
;;;### (autoloads (eshell-command-result eshell-command eshell) "eshell"
-;;;;;; "eshell/eshell.el" (19845 45374))
+;;;;;; "eshell/eshell.el" (20373 41604))
;;; Generated autoloads from eshell/eshell.el
(autoload 'eshell "eshell" "\
;;;;;; visit-tags-table tags-table-mode find-tag-default-function
;;;;;; find-tag-hook tags-add-tables tags-compression-info-list
;;;;;; tags-table-list tags-case-fold-search) "etags" "progmodes/etags.el"
-;;;;;; (20007 64734))
+;;;;;; (20412 11425))
;;; Generated autoloads from progmodes/etags.el
(defvar tags-file-name nil "\
-*File name of tags table.
+File name of tags table.
To switch to a new tags table, setting this variable is sufficient.
If you set this variable, do not also set `tags-table-list'.
Use the `etags' program to make a tags table file.")
(put 'tags-file-name 'safe-local-variable 'stringp)
(defvar tags-case-fold-search 'default "\
-*Whether tags operations should be case-sensitive.
+Whether tags operations should be case-sensitive.
A value of t means case-insensitive, a value of nil means case-sensitive.
Any other value means use the setting of `case-fold-search'.")
(custom-autoload 'tags-case-fold-search "etags" t)
(defvar tags-table-list nil "\
-*List of file names of tags tables to search.
+List of file names of tags tables to search.
An element that is a directory means the file \"TAGS\" in that directory.
To switch to a new list of tags tables, setting this variable is sufficient.
If you set this variable, do not also set `tags-file-name'.
(custom-autoload 'tags-table-list "etags" t)
(defvar tags-compression-info-list (purecopy '("" ".Z" ".bz2" ".gz" ".xz" ".tgz")) "\
-*List of extensions tried by etags when jka-compr is used.
+List of extensions tried by etags when jka-compr is used.
An empty string means search the non-compressed file.
These extensions will be tried only if jka-compr was activated
\(i.e. via customize of `auto-compression-mode' or by calling the function
(custom-autoload 'tags-compression-info-list "etags" t)
(defvar tags-add-tables 'ask-user "\
-*Control whether to add a new tags table to the current list.
+Control whether to add a new tags table to the current list.
t means do; nil means don't (always start a new list).
Any other value means ask the user whether to add a new tags table
to the current list (as opposed to starting a new list).")
(custom-autoload 'tags-add-tables "etags" t)
(defvar find-tag-hook nil "\
-*Hook to be run by \\[find-tag] after finding a tag. See `run-hooks'.
+Hook to be run by \\[find-tag] after finding a tag. See `run-hooks'.
The value in the buffer in which \\[find-tag] is done is used,
not the value in the buffer \\[find-tag] goes to.")
(custom-autoload 'find-tag-hook "etags" t)
(defvar find-tag-default-function nil "\
-*A function of no arguments used by \\[find-tag] to pick a default tag.
+A function of no arguments used by \\[find-tag] to pick a default tag.
If nil, and the symbol that is the value of `major-mode'
has a `find-tag-default-function' property (see `put'), that is used.
Otherwise, `find-tag-default' is used.")
;;;;;; ethio-fidel-to-sera-marker ethio-fidel-to-sera-region ethio-fidel-to-sera-buffer
;;;;;; ethio-sera-to-fidel-marker ethio-sera-to-fidel-region ethio-sera-to-fidel-buffer
;;;;;; setup-ethiopic-environment-internal) "ethio-util" "language/ethio-util.el"
-;;;;;; (19845 45374))
+;;;;;; (20356 35090))
;;; Generated autoloads from language/ethio-util.el
(autoload 'setup-ethiopic-environment-internal "ethio-util" "\
\(fn)" nil nil)
(autoload 'ethio-find-file "ethio-util" "\
-Transliterate file content into Ethiopic dependig on filename suffix.
+Transliterate file content into Ethiopic depending on filename suffix.
\(fn)" nil nil)
\f
;;;### (autoloads (eudc-load-eudc eudc-query-form eudc-expand-inline
;;;;;; eudc-get-phone eudc-get-email eudc-set-server) "eudc" "net/eudc.el"
-;;;;;; (19931 11784))
+;;;;;; (20428 57510))
;;; Generated autoloads from net/eudc.el
(autoload 'eudc-set-server "eudc" "\
\f
;;;### (autoloads (eudc-display-jpeg-as-button eudc-display-jpeg-inline
;;;;;; eudc-display-sound eudc-display-mail eudc-display-url eudc-display-generic-binary)
-;;;;;; "eudc-bob" "net/eudc-bob.el" (19845 45374))
+;;;;;; "eudc-bob" "net/eudc-bob.el" (20244 35516))
;;; Generated autoloads from net/eudc-bob.el
(autoload 'eudc-display-generic-binary "eudc-bob" "\
;;;***
\f
;;;### (autoloads (eudc-try-bbdb-insert eudc-insert-record-at-point-into-bbdb)
-;;;;;; "eudc-export" "net/eudc-export.el" (19931 11784))
+;;;;;; "eudc-export" "net/eudc-export.el" (20244 35516))
;;; Generated autoloads from net/eudc-export.el
(autoload 'eudc-insert-record-at-point-into-bbdb "eudc-export" "\
;;;***
\f
;;;### (autoloads (eudc-edit-hotlist) "eudc-hotlist" "net/eudc-hotlist.el"
-;;;;;; (19931 11784))
+;;;;;; (20244 35516))
;;; Generated autoloads from net/eudc-hotlist.el
(autoload 'eudc-edit-hotlist "eudc-hotlist" "\
;;;***
\f
-;;;### (autoloads (ewoc-create) "ewoc" "emacs-lisp/ewoc.el" (19845
-;;;;;; 45374))
+;;;### (autoloads (ewoc-create) "ewoc" "emacs-lisp/ewoc.el" (20452
+;;;;;; 43334))
;;; Generated autoloads from emacs-lisp/ewoc.el
(autoload 'ewoc-create "ewoc" "\
;;;### (autoloads (executable-make-buffer-file-executable-if-script-p
;;;;;; executable-self-display executable-set-magic executable-interpret
;;;;;; executable-command-find-posix-p) "executable" "progmodes/executable.el"
-;;;;;; (19890 42850))
+;;;;;; (20356 35090))
;;; Generated autoloads from progmodes/executable.el
(autoload 'executable-command-find-posix-p "executable" "\
\f
;;;### (autoloads (expand-jump-to-next-slot expand-jump-to-previous-slot
;;;;;; expand-abbrev-hook expand-add-abbrevs) "expand" "expand.el"
-;;;;;; (19886 45771))
+;;;;;; (20244 35516))
;;; Generated autoloads from expand.el
(autoload 'expand-add-abbrevs "expand" "\
-Add a list of abbrev to abbrev table TABLE.
+Add a list of abbreviations to abbrev table TABLE.
ABBREVS is a list of abbrev definitions; each abbrev description entry
has the form (ABBREV EXPANSION ARG).
ABBREV is the abbreviation to replace.
EXPANSION is the replacement string or a function which will make the
-expansion. For example you, could use the DMacros or skeleton packages
+expansion. For example, you could use the DMacros or skeleton packages
to generate such functions.
ARG is an optional argument which can be a number or a list of
If ARG is a list of numbers, point is placed according to the first
member of the list, but you can visit the other specified positions
-cyclicaly with the functions `expand-jump-to-previous-slot' and
+cyclically with the functions `expand-jump-to-previous-slot' and
`expand-jump-to-next-slot'.
If ARG is omitted, point is placed at the end of the expanded text.
;;;***
\f
-;;;### (autoloads (f90-mode) "f90" "progmodes/f90.el" (19975 1875))
+;;;### (autoloads (f90-mode) "f90" "progmodes/f90.el" (20412 11425))
;;; Generated autoloads from progmodes/f90.el
(autoload 'f90-mode "f90" "\
;;;### (autoloads (variable-pitch-mode buffer-face-toggle buffer-face-set
;;;;;; buffer-face-mode text-scale-adjust text-scale-decrease text-scale-increase
;;;;;; text-scale-set face-remap-set-base face-remap-reset-base
-;;;;;; face-remap-add-relative) "face-remap" "face-remap.el" (19845
-;;;;;; 45374))
+;;;;;; face-remap-add-relative) "face-remap" "face-remap.el" (20446
+;;;;;; 34252))
;;; Generated autoloads from face-remap.el
(autoload 'face-remap-add-relative "face-remap" "\
Add a face remapping entry of FACE to SPECS in the current buffer.
-
-Return a cookie which can be used to delete the remapping with
+Return a cookie which can be used to delete this remapping with
`face-remap-remove-relative'.
-SPECS can be any value suitable for the `face' text property,
-including a face name, a list of face names, or a face-attribute
-property list. The attributes given by SPECS will be merged with
-any other currently active face remappings of FACE, and with the
-global definition of FACE. An attempt is made to sort multiple
-entries so that entries with relative face-attributes are applied
-after entries with absolute face-attributes.
+The remaining arguments, SPECS, should form a list of faces.
+Each list element should be either a face name or a property list
+of face attribute/value pairs. If more than one face is listed,
+that specifies an aggregate face, in the same way as in a `face'
+text property, except for possible priority changes noted below.
-The base (lowest priority) remapping may be set to a specific
-value, instead of the default of the global face definition,
-using `face-remap-set-base'.
+The face remapping specified by SPECS takes effect alongside the
+remappings from other calls to `face-remap-add-relative' for the
+same FACE, as well as the normal definition of FACE (at lowest
+priority). This function tries to sort multiple remappings for
+the same face, so that remappings specifying relative face
+attributes are applied after remappings specifying absolute face
+attributes.
+
+The base (lowest priority) remapping may be set to something
+other than the normal definition of FACE via `face-remap-set-base'.
\(fn FACE &rest SPECS)" nil nil)
(autoload 'face-remap-reset-base "face-remap" "\
-Set the base remapping of FACE to inherit from FACE's global definition.
+Set the base remapping of FACE to the normal definition of FACE.
+This causes the remappings specified by `face-remap-add-relative'
+to apply on top of the normal definition of FACE.
\(fn FACE)" nil nil)
(autoload 'face-remap-set-base "face-remap" "\
Set the base remapping of FACE in the current buffer to SPECS.
-If SPECS is empty, the default base remapping is restored, which
-inherits from the global definition of FACE; note that this is
-different from SPECS containing a single value `nil', which does
-not inherit from the global definition of FACE.
+This causes the remappings specified by `face-remap-add-relative'
+to apply on top of the face specification given by SPECS.
+
+The remaining arguments, SPECS, should form a list of faces.
+Each list element should be either a face name or a property list
+of face attribute/value pairs, like in a `face' text property.
+
+If SPECS is empty, call `face-remap-reset-base' to use the normal
+definition of FACE as the base remapping; note that this is
+different from SPECS containing a single value `nil', which means
+not to inherit from the global definition of FACE at all.
\(fn FACE &rest SPECS)" nil nil)
(autoload 'buffer-face-mode "face-remap" "\
Minor mode for a buffer-specific default face.
-When enabled, the face specified by the variable
-`buffer-face-mode-face' is used to display the buffer text.
+With a prefix argument ARG, enable the mode if ARG is positive,
+and disable it otherwise. If called from Lisp, enable the mode
+if ARG is omitted or nil. When enabled, the face specified by the
+variable `buffer-face-mode-face' is used to display the buffer text.
\(fn &optional ARG)" t nil)
(autoload 'buffer-face-set "face-remap" "\
Enable `buffer-face-mode', using face specs SPECS.
-SPECS can be any value suitable for the `face' text property,
-including a face name, a list of face names, or a face-attribute
-If SPECS is nil, then `buffer-face-mode' is disabled.
+Each argument in SPECS should be a face, i.e. either a face name
+or a property list of face attributes and values. If more than
+one face is listed, that specifies an aggregate face, like in a
+`face' text property. If SPECS is nil or omitted, disable
+`buffer-face-mode'.
-This function will make the variable `buffer-face-mode-face'
-buffer local, and set it to FACE.
+This function makes the variable `buffer-face-mode-face' buffer
+local, and sets it to FACE.
\(fn &rest SPECS)" t nil)
(autoload 'buffer-face-toggle "face-remap" "\
Toggle `buffer-face-mode', using face specs SPECS.
-SPECS can be any value suitable for the `face' text property,
-including a face name, a list of face names, or a face-attribute
+Each argument in SPECS should be a face, i.e. either a face name
+or a property list of face attributes and values. If more than
+one face is listed, that specifies an aggregate face, like in a
+`face' text property.
If `buffer-face-mode' is already enabled, and is currently using
the face specs SPECS, then it is disabled; if buffer-face-mode is
\f
;;;### (autoloads (feedmail-queue-reminder feedmail-run-the-queue
;;;;;; feedmail-run-the-queue-global-prompt feedmail-run-the-queue-no-prompts
-;;;;;; feedmail-send-it) "feedmail" "mail/feedmail.el" (19986 58615))
+;;;;;; feedmail-send-it) "feedmail" "mail/feedmail.el" (20412 11425))
;;; Generated autoloads from mail/feedmail.el
(autoload 'feedmail-send-it "feedmail" "\
;;;***
\f
-;;;### (autoloads (ffap-bindings dired-at-point ffap-at-mouse ffap-menu
-;;;;;; find-file-at-point ffap-next) "ffap" "ffap.el" (19845 45374))
+;;;### (autoloads (ffap-bindings ffap-guess-file-name-at-point dired-at-point
+;;;;;; ffap-at-mouse ffap-menu find-file-at-point ffap-next) "ffap"
+;;;;;; "ffap.el" (20412 11425))
;;; Generated autoloads from ffap.el
(autoload 'ffap-next "ffap" "\
\(fn &optional FILENAME)" t nil)
-(defun ffap-guess-file-name-at-point nil "\
+(autoload 'ffap-guess-file-name-at-point "ffap" "\
Try to get a file name at point.
-This hook is intended to be put in `file-name-at-point-functions'." (when (fboundp (quote ffap-guesser)) (let ((guess (ffap-guesser))) (setq guess (if (or (not guess) (and (fboundp (quote ffap-url-p)) (ffap-url-p guess)) (and (fboundp (quote ffap-file-remote-p)) (ffap-file-remote-p guess))) guess (abbreviate-file-name (expand-file-name guess)))) (when guess (if (file-directory-p guess) (file-name-as-directory guess) guess)))))
+This hook is intended to be put in `file-name-at-point-functions'.
+
+\(fn)" nil nil)
(autoload 'ffap-bindings "ffap" "\
Evaluate the forms in variable `ffap-bindings'.
;;;### (autoloads (file-cache-minibuffer-complete file-cache-add-directory-recursively
;;;;;; file-cache-add-directory-using-locate file-cache-add-directory-using-find
;;;;;; file-cache-add-file file-cache-add-directory-list file-cache-add-directory)
-;;;;;; "filecache" "filecache.el" (19845 45374))
+;;;;;; "filecache" "filecache.el" (20244 35516))
;;; Generated autoloads from filecache.el
(autoload 'file-cache-add-directory "filecache" "\
;;;;;; copy-file-locals-to-dir-locals delete-dir-local-variable
;;;;;; add-dir-local-variable delete-file-local-variable-prop-line
;;;;;; add-file-local-variable-prop-line delete-file-local-variable
-;;;;;; add-file-local-variable) "files-x" "files-x.el" (19886 45771))
+;;;;;; add-file-local-variable) "files-x" "files-x.el" (20356 35090))
;;; Generated autoloads from files-x.el
(autoload 'add-file-local-variable "files-x" "\
;;;***
\f
-;;;### (autoloads (filesets-init) "filesets" "filesets.el" (19845
-;;;;;; 45374))
+;;;### (autoloads (filesets-init) "filesets" "filesets.el" (20318
+;;;;;; 5885))
;;; Generated autoloads from filesets.el
(autoload 'filesets-init "filesets" "\
;;;***
\f
-;;;### (autoloads (find-cmd) "find-cmd" "find-cmd.el" (19845 45374))
+;;;### (autoloads (find-cmd) "find-cmd" "find-cmd.el" (20244 35516))
;;; Generated autoloads from find-cmd.el
(autoload 'find-cmd "find-cmd" "\
;;;***
\f
;;;### (autoloads (find-grep-dired find-name-dired find-dired) "find-dired"
-;;;;;; "find-dired.el" (19980 19797))
+;;;;;; "find-dired.el" (20244 35516))
;;; Generated autoloads from find-dired.el
(autoload 'find-dired "find-dired" "\
;;;***
\f
;;;### (autoloads (ff-mouse-find-other-file-other-window ff-mouse-find-other-file
-;;;;;; ff-find-other-file ff-get-other-file) "find-file" "find-file.el"
-;;;;;; (19845 45374))
+;;;;;; ff-find-other-file ff-get-other-file ff-special-constructs)
+;;;;;; "find-file" "find-file.el" (20412 11425))
;;; Generated autoloads from find-file.el
(defvar ff-special-constructs `((,(purecopy "^#\\s *\\(include\\|import\\)\\s +[<\"]\\(.*\\)[>\"]") lambda nil (buffer-substring (match-beginning 2) (match-end 2)))) "\
-*List of special constructs for `ff-treat-as-special' to recognize.
+List of special constructs recognized by `ff-treat-as-special'.
Each element, tried in order, has the form (REGEXP . EXTRACT).
If REGEXP matches the current line (from the beginning of the line),
`ff-treat-as-special' calls function EXTRACT with no args.
If EXTRACT returns nil, keep trying. Otherwise, return the
filename that EXTRACT returned.")
+(custom-autoload 'ff-special-constructs "find-file" t)
+
(autoload 'ff-get-other-file "find-file" "\
Find the header or source file corresponding to this file.
See also the documentation for `ff-find-other-file'.
;;;;;; find-variable find-variable-noselect find-function-other-frame
;;;;;; find-function-other-window find-function find-function-noselect
;;;;;; find-function-search-for-symbol find-library) "find-func"
-;;;;;; "emacs-lisp/find-func.el" (20050 11479))
+;;;;;; "emacs-lisp/find-func.el" (20244 35516))
;;; Generated autoloads from emacs-lisp/find-func.el
(autoload 'find-library "find-func" "\
;;;***
\f
;;;### (autoloads (find-lisp-find-dired-filter find-lisp-find-dired-subdirectories
-;;;;;; find-lisp-find-dired) "find-lisp" "find-lisp.el" (19886 45771))
+;;;;;; find-lisp-find-dired) "find-lisp" "find-lisp.el" (20244 35516))
;;; Generated autoloads from find-lisp.el
(autoload 'find-lisp-find-dired "find-lisp" "\
;;;***
\f
;;;### (autoloads (finder-by-keyword finder-commentary finder-list-keywords)
-;;;;;; "finder" "finder.el" (19893 19022))
+;;;;;; "finder" "finder.el" (20244 35516))
;;; Generated autoloads from finder.el
(autoload 'finder-list-keywords "finder" "\
;;;***
\f
;;;### (autoloads (enable-flow-control-on enable-flow-control) "flow-ctrl"
-;;;;;; "flow-ctrl.el" (19845 45374))
+;;;;;; "flow-ctrl.el" (20244 35516))
;;; Generated autoloads from flow-ctrl.el
(autoload 'enable-flow-control "flow-ctrl" "\
;;;***
\f
;;;### (autoloads (fill-flowed fill-flowed-encode) "flow-fill" "gnus/flow-fill.el"
-;;;;;; (19845 45374))
+;;;;;; (20244 35516))
;;; Generated autoloads from gnus/flow-fill.el
(autoload 'fill-flowed-encode "flow-fill" "\
;;;***
\f
;;;### (autoloads (flymake-find-file-hook flymake-mode-off flymake-mode-on
-;;;;;; flymake-mode) "flymake" "progmodes/flymake.el" (19984 16846))
+;;;;;; flymake-mode) "flymake" "progmodes/flymake.el" (20434 28080))
;;; Generated autoloads from progmodes/flymake.el
(autoload 'flymake-mode "flymake" "\
-Minor mode to do on-the-fly syntax checking.
-When called interactively, toggles the minor mode.
-With arg, turn Flymake mode on if and only if arg is positive.
+Toggle on-the-fly syntax checking.
+With a prefix argument ARG, enable the mode if ARG is positive,
+and disable it otherwise. If called from Lisp, enable the mode
+if ARG is omitted or nil.
\(fn &optional ARG)" t nil)
\f
;;;### (autoloads (flyspell-buffer flyspell-region flyspell-mode-off
;;;;;; turn-off-flyspell turn-on-flyspell flyspell-mode flyspell-prog-mode)
-;;;;;; "flyspell" "textmodes/flyspell.el" (19982 3545))
+;;;;;; "flyspell" "textmodes/flyspell.el" (20434 28080))
;;; Generated autoloads from textmodes/flyspell.el
(autoload 'flyspell-prog-mode "flyspell" "\
Turn on `flyspell-mode' for comments and strings.
\(fn)" t nil)
-(defvar flyspell-mode nil)
+(defvar flyspell-mode nil "Non-nil if Flyspell mode is enabled.")
(autoload 'flyspell-mode "flyspell" "\
-Minor mode performing on-the-fly spelling checking.
-This spawns a single Ispell process and checks each word.
-The default flyspell behavior is to highlight incorrect words.
-With no argument, this command toggles Flyspell mode.
-With a prefix argument ARG, turn Flyspell minor mode on if ARG is positive,
-otherwise turn it off.
+Toggle on-the-fly spell checking (Flyspell mode).
+With a prefix argument ARG, enable Flyspell mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+the mode if ARG is omitted or nil.
+
+Flyspell mode is a buffer-local minor mode. When enabled, it
+spawns a single Ispell process and checks each word. The default
+flyspell behavior is to highlight incorrect words.
Bindings:
\\[ispell-word]: correct words (using Ispell).
\f
;;;### (autoloads (follow-delete-other-windows-and-split follow-mode
;;;;;; turn-off-follow-mode turn-on-follow-mode) "follow" "follow.el"
-;;;;;; (19998 49767))
+;;;;;; (20412 11425))
;;; Generated autoloads from follow.el
(autoload 'turn-on-follow-mode "follow" "\
\(fn)" nil nil)
(autoload 'follow-mode "follow" "\
-Minor mode that combines windows into one tall virtual window.
+Toggle Follow mode.
+With a prefix argument ARG, enable Follow mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+the mode if ARG is omitted or nil.
-The feeling of a \"virtual window\" has been accomplished by the use
-of two major techniques:
+Follow mode is a minor mode that combines windows into one tall
+virtual window. This is accomplished by two main techniques:
* The windows always displays adjacent sections of the buffer.
This means that whenever one window is moved, all the
mileage may vary).
To split one large window into two side-by-side windows, the commands
-`\\[split-window-horizontally]' or `M-x follow-delete-other-windows-and-split' can be used.
+`\\[split-window-right]' or `M-x follow-delete-other-windows-and-split' can be used.
Only windows displayed in the same frame follow each other.
-If the variable `follow-intercept-processes' is non-nil, Follow mode
-will listen to the output of processes and redisplay accordingly.
-\(This is the default.)
-
This command runs the normal hook `follow-mode-hook'.
Keys specific to Follow mode:
the rightmost is selected. If ARG is nil, the leftmost window is
selected if the original window is the first one in the frame.
-To bind this command to a hotkey, place the following line
-in your `~/.emacs' file, replacing [f7] by your favourite key:
- (global-set-key [f7] 'follow-delete-other-windows-and-split)
-
\(fn &optional ARG)" t nil)
;;;***
\f
-;;;### (autoloads (footnote-mode) "footnote" "mail/footnote.el" (19913
-;;;;;; 4309))
+;;;### (autoloads (footnote-mode) "footnote" "mail/footnote.el" (20412
+;;;;;; 11425))
;;; Generated autoloads from mail/footnote.el
(autoload 'footnote-mode "footnote" "\
-Toggle footnote minor mode.
-This minor mode provides footnote support for `message-mode'. To get
-started, play around with the following keys:
+Toggle Footnote mode.
+With a prefix argument ARG, enable Footnote mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+the mode if ARG is omitted or nil.
+
+Footnode mode is a buffer-local minor mode. If enabled, it
+provides footnote support for `message-mode'. To get started,
+play around with the following keys:
\\{footnote-minor-mode-map}
\(fn &optional ARG)" t nil)
;;;***
\f
;;;### (autoloads (forms-find-file-other-window forms-find-file forms-mode)
-;;;;;; "forms" "forms.el" (19886 45771))
+;;;;;; "forms" "forms.el" (20428 57510))
;;; Generated autoloads from forms.el
(autoload 'forms-mode "forms" "\
;;;***
\f
;;;### (autoloads (fortran-mode) "fortran" "progmodes/fortran.el"
-;;;;;; (19956 37456))
+;;;;;; (20446 34252))
;;; Generated autoloads from progmodes/fortran.el
(autoload 'fortran-mode "fortran" "\
;;;***
\f
;;;### (autoloads (fortune fortune-to-signature fortune-compile fortune-from-region
-;;;;;; fortune-add-fortune) "fortune" "play/fortune.el" (19931 11784))
+;;;;;; fortune-add-fortune) "fortune" "play/fortune.el" (20244 35516))
;;; Generated autoloads from play/fortune.el
(autoload 'fortune-add-fortune "fortune" "\
;;;***
\f
;;;### (autoloads (gdb gdb-enable-debug) "gdb-mi" "progmodes/gdb-mi.el"
-;;;;;; (19988 13913))
+;;;;;; (20415 57974))
;;; Generated autoloads from progmodes/gdb-mi.el
(defvar gdb-enable-debug nil "\
-Non-nil means record the process input and output in `gdb-debug-log'.")
+Non-nil if Gdb-Enable-Debug mode is enabled.
+See the command `gdb-enable-debug' for a description of this minor mode.")
+
+(custom-autoload 'gdb-enable-debug "gdb-mi" nil)
-(custom-autoload 'gdb-enable-debug "gdb-mi" t)
+(autoload 'gdb-enable-debug "gdb-mi" "\
+Toggle logging of transaction between Emacs and Gdb.
+The log is stored in `gdb-debug-log' as an alist with elements
+whose cons is send, send-item or recv and whose cdr is the string
+being transferred. This list may grow up to a size of
+`gdb-debug-log-max' after which the oldest element (at the end of
+the list) is deleted every time a new one is added (at the front).
+
+\(fn &optional ARG)" t nil)
(autoload 'gdb "gdb-mi" "\
Run gdb on program FILE in buffer *gud-FILE*.
The directory containing FILE becomes the initial working directory
and source-file directory for your debugger.
+COMMAND-LINE is the shell command for starting the gdb session.
+It should be a string consisting of the name of the gdb
+executable followed by command-line options. The command-line
+options should include \"-i=mi\" to use gdb's MI text interface.
+Note that the old \"--annotate\" option is no longer supported.
+
If `gdb-many-windows' is nil (the default value) then gdb just
pops up the GUD buffer unless `gdb-show-main' is t. In this case
it starts with two windows: one displaying the GUD buffer and the
;;;***
\f
;;;### (autoloads (generic-make-keywords-list generic-mode generic-mode-internal
-;;;;;; define-generic-mode) "generic" "emacs-lisp/generic.el" (19845
-;;;;;; 45374))
+;;;;;; define-generic-mode) "generic" "emacs-lisp/generic.el" (20412
+;;;;;; 11425))
;;; Generated autoloads from emacs-lisp/generic.el
(defvar generic-mode-list nil "\
See the file generic-x.el for some examples of `define-generic-mode'.
-\(fn MODE COMMENT-LIST KEYWORD-LIST FONT-LOCK-LIST AUTO-MODE-LIST FUNCTION-LIST &optional DOCSTRING)" nil (quote macro))
+\(fn MODE COMMENT-LIST KEYWORD-LIST FONT-LOCK-LIST AUTO-MODE-LIST FUNCTION-LIST &optional DOCSTRING)" nil t)
(put 'define-generic-mode 'lisp-indent-function '1)
+(put 'define-generic-mode 'doc-string-elt '7)
+
(autoload 'generic-mode-internal "generic" "\
Go into the generic mode MODE.
;;;***
\f
;;;### (autoloads (glasses-mode) "glasses" "progmodes/glasses.el"
-;;;;;; (19906 31087))
+;;;;;; (20356 35090))
;;; Generated autoloads from progmodes/glasses.el
(autoload 'glasses-mode "glasses" "\
Minor mode for making identifiers likeThis readable.
-When this mode is active, it tries to add virtual separators (like underscores)
-at places they belong to.
+With a prefix argument ARG, enable the mode if ARG is positive,
+and disable it otherwise. If called from Lisp, enable the mode
+if ARG is omitted or nil. When this mode is active, it tries to
+add virtual separators (like underscores) at places they belong to.
\(fn &optional ARG)" t nil)
\f
;;;### (autoloads (gmm-tool-bar-from-list gmm-widget-p gmm-error
;;;;;; gmm-message gmm-regexp-concat) "gmm-utils" "gnus/gmm-utils.el"
-;;;;;; (19845 45374))
+;;;;;; (20318 5885))
;;; Generated autoloads from gnus/gmm-utils.el
(autoload 'gmm-regexp-concat "gmm-utils" "\
;;;***
\f
;;;### (autoloads (gnus gnus-other-frame gnus-slave gnus-no-server
-;;;;;; gnus-slave-no-server) "gnus" "gnus/gnus.el" (20027 50006))
+;;;;;; gnus-slave-no-server) "gnus" "gnus/gnus.el" (20414 21581))
;;; Generated autoloads from gnus/gnus.el
(when (fboundp 'custom-autoload)
(custom-autoload 'gnus-select-method "gnus"))
;;;;;; gnus-agent-get-undownloaded-list gnus-agent-delete-group
;;;;;; gnus-agent-rename-group gnus-agent-possibly-save-gcc gnus-agentize
;;;;;; gnus-slave-unplugged gnus-plugged gnus-unplugged) "gnus-agent"
-;;;;;; "gnus/gnus-agent.el" (20048 56149))
+;;;;;; "gnus/gnus-agent.el" (20446 34252))
;;; Generated autoloads from gnus/gnus-agent.el
(autoload 'gnus-unplugged "gnus-agent" "\
;;;***
\f
;;;### (autoloads (gnus-article-prepare-display) "gnus-art" "gnus/gnus-art.el"
-;;;;;; (20050 11479))
+;;;;;; (20373 41604))
;;; Generated autoloads from gnus/gnus-art.el
(autoload 'gnus-article-prepare-display "gnus-art" "\
;;;***
\f
;;;### (autoloads (gnus-bookmark-bmenu-list gnus-bookmark-jump gnus-bookmark-set)
-;;;;;; "gnus-bookmark" "gnus/gnus-bookmark.el" (19845 45374))
+;;;;;; "gnus-bookmark" "gnus/gnus-bookmark.el" (20244 35516))
;;; Generated autoloads from gnus/gnus-bookmark.el
(autoload 'gnus-bookmark-set "gnus-bookmark" "\
\f
;;;### (autoloads (gnus-cache-delete-group gnus-cache-rename-group
;;;;;; gnus-cache-generate-nov-databases gnus-cache-generate-active
-;;;;;; gnus-jog-cache) "gnus-cache" "gnus/gnus-cache.el" (19845
-;;;;;; 45374))
+;;;;;; gnus-jog-cache) "gnus-cache" "gnus/gnus-cache.el" (20244
+;;;;;; 35516))
;;; Generated autoloads from gnus/gnus-cache.el
(autoload 'gnus-jog-cache "gnus-cache" "\
;;;***
\f
;;;### (autoloads (gnus-delay-initialize gnus-delay-send-queue gnus-delay-article)
-;;;;;; "gnus-delay" "gnus/gnus-delay.el" (19931 11784))
+;;;;;; "gnus-delay" "gnus/gnus-delay.el" (20244 35516))
;;; Generated autoloads from gnus/gnus-delay.el
(autoload 'gnus-delay-article "gnus-delay" "\
;;;***
\f
;;;### (autoloads (gnus-user-format-function-D gnus-user-format-function-d)
-;;;;;; "gnus-diary" "gnus/gnus-diary.el" (19845 45374))
+;;;;;; "gnus-diary" "gnus/gnus-diary.el" (20244 35516))
;;; Generated autoloads from gnus/gnus-diary.el
(autoload 'gnus-user-format-function-d "gnus-diary" "\
;;;***
\f
;;;### (autoloads (turn-on-gnus-dired-mode) "gnus-dired" "gnus/gnus-dired.el"
-;;;;;; (19845 45374))
+;;;;;; (20244 35516))
;;; Generated autoloads from gnus/gnus-dired.el
(autoload 'turn-on-gnus-dired-mode "gnus-dired" "\
;;;***
\f
;;;### (autoloads (gnus-draft-reminder) "gnus-draft" "gnus/gnus-draft.el"
-;;;;;; (19981 40664))
+;;;;;; (20244 35516))
;;; Generated autoloads from gnus/gnus-draft.el
(autoload 'gnus-draft-reminder "gnus-draft" "\
\f
;;;### (autoloads (gnus-convert-png-to-face gnus-convert-face-to-png
;;;;;; gnus-face-from-file gnus-x-face-from-file gnus-insert-random-x-face-header
-;;;;;; gnus-random-x-face) "gnus-fun" "gnus/gnus-fun.el" (19980
-;;;;;; 19797))
+;;;;;; gnus-random-x-face) "gnus-fun" "gnus/gnus-fun.el" (20244
+;;;;;; 35516))
;;; Generated autoloads from gnus/gnus-fun.el
(autoload 'gnus-random-x-face "gnus-fun" "\
;;;***
\f
;;;### (autoloads (gnus-treat-mail-gravatar gnus-treat-from-gravatar)
-;;;;;; "gnus-gravatar" "gnus/gnus-gravatar.el" (19845 45374))
+;;;;;; "gnus-gravatar" "gnus/gnus-gravatar.el" (20244 35516))
;;; Generated autoloads from gnus/gnus-gravatar.el
(autoload 'gnus-treat-from-gravatar "gnus-gravatar" "\
;;;***
\f
;;;### (autoloads (gnus-fetch-group-other-frame gnus-fetch-group)
-;;;;;; "gnus-group" "gnus/gnus-group.el" (20062 2656))
+;;;;;; "gnus-group" "gnus/gnus-group.el" (20438 17064))
;;; Generated autoloads from gnus/gnus-group.el
(autoload 'gnus-fetch-group "gnus-group" "\
;;;***
\f
;;;### (autoloads (gnus-html-prefetch-images gnus-article-html) "gnus-html"
-;;;;;; "gnus/gnus-html.el" (20050 11479))
+;;;;;; "gnus/gnus-html.el" (20276 3849))
;;; Generated autoloads from gnus/gnus-html.el
(autoload 'gnus-article-html "gnus-html" "\
;;;***
\f
;;;### (autoloads (gnus-batch-score) "gnus-kill" "gnus/gnus-kill.el"
-;;;;;; (19845 45374))
+;;;;;; (20244 35516))
;;; Generated autoloads from gnus/gnus-kill.el
(defalias 'gnus-batch-kill 'gnus-batch-score)
\f
;;;### (autoloads (gnus-mailing-list-mode gnus-mailing-list-insinuate
;;;;;; turn-on-gnus-mailing-list-mode) "gnus-ml" "gnus/gnus-ml.el"
-;;;;;; (19845 45374))
+;;;;;; (20244 35516))
;;; Generated autoloads from gnus/gnus-ml.el
(autoload 'turn-on-gnus-mailing-list-mode "gnus-ml" "\
\f
;;;### (autoloads (gnus-group-split-fancy gnus-group-split gnus-group-split-update
;;;;;; gnus-group-split-setup) "gnus-mlspl" "gnus/gnus-mlspl.el"
-;;;;;; (19845 45374))
+;;;;;; (20244 35516))
;;; Generated autoloads from gnus/gnus-mlspl.el
(autoload 'gnus-group-split-setup "gnus-mlspl" "\
;;;***
\f
;;;### (autoloads (gnus-button-reply gnus-button-mailto gnus-msg-mail)
-;;;;;; "gnus-msg" "gnus/gnus-msg.el" (20055 29424))
+;;;;;; "gnus-msg" "gnus/gnus-msg.el" (20434 28080))
;;; Generated autoloads from gnus/gnus-msg.el
(autoload 'gnus-msg-mail "gnus-msg" "\
Start editing a mail message to be sent.
Like `message-mail', but with Gnus paraphernalia, particularly the
Gcc: header for archiving purposes.
+If Gnus isn't running, a plain `message-mail' setup is used
+instead.
\(fn &optional TO SUBJECT OTHER-HEADERS CONTINUE SWITCH-ACTION YANK-ACTION SEND-ACTIONS RETURN-ACTION)" t nil)
\f
;;;### (autoloads (gnus-treat-newsgroups-picon gnus-treat-mail-picon
;;;;;; gnus-treat-from-picon) "gnus-picon" "gnus/gnus-picon.el"
-;;;;;; (19845 45374))
+;;;;;; (20290 33419))
;;; Generated autoloads from gnus/gnus-picon.el
(autoload 'gnus-treat-from-picon "gnus-picon" "\
;;;;;; gnus-sorted-nintersection gnus-sorted-range-intersection
;;;;;; gnus-sorted-intersection gnus-intersection gnus-sorted-complement
;;;;;; gnus-sorted-ndifference gnus-sorted-difference) "gnus-range"
-;;;;;; "gnus/gnus-range.el" (19845 45374))
+;;;;;; "gnus/gnus-range.el" (20244 35516))
;;; Generated autoloads from gnus/gnus-range.el
(autoload 'gnus-sorted-difference "gnus-range" "\
;;;***
\f
;;;### (autoloads (gnus-registry-install-hooks gnus-registry-initialize)
-;;;;;; "gnus-registry" "gnus/gnus-registry.el" (19976 22732))
+;;;;;; "gnus-registry" "gnus/gnus-registry.el" (20415 57974))
;;; Generated autoloads from gnus/gnus-registry.el
(autoload 'gnus-registry-initialize "gnus-registry" "\
;;;***
\f
;;;### (autoloads (gnus-sieve-article-add-rule gnus-sieve-generate
-;;;;;; gnus-sieve-update) "gnus-sieve" "gnus/gnus-sieve.el" (19845
-;;;;;; 45374))
+;;;;;; gnus-sieve-update) "gnus-sieve" "gnus/gnus-sieve.el" (20244
+;;;;;; 35516))
;;; Generated autoloads from gnus/gnus-sieve.el
(autoload 'gnus-sieve-update "gnus-sieve" "\
;;;***
\f
;;;### (autoloads (gnus-update-format) "gnus-spec" "gnus/gnus-spec.el"
-;;;;;; (20046 14433))
+;;;;;; (20244 35516))
;;; Generated autoloads from gnus/gnus-spec.el
(autoload 'gnus-update-format "gnus-spec" "\
;;;***
\f
;;;### (autoloads (gnus-declare-backend) "gnus-start" "gnus/gnus-start.el"
-;;;;;; (19988 13913))
+;;;;;; (20373 41604))
;;; Generated autoloads from gnus/gnus-start.el
(autoload 'gnus-declare-backend "gnus-start" "\
;;;***
\f
;;;### (autoloads (gnus-summary-bookmark-jump) "gnus-sum" "gnus/gnus-sum.el"
-;;;;;; (20050 11479))
+;;;;;; (20331 12564))
;;; Generated autoloads from gnus/gnus-sum.el
(autoload 'gnus-summary-bookmark-jump "gnus-sum" "\
;;;***
\f
;;;### (autoloads (gnus-sync-install-hooks gnus-sync-initialize)
-;;;;;; "gnus-sync" "gnus/gnus-sync.el" (19845 45374))
+;;;;;; "gnus-sync" "gnus/gnus-sync.el" (20244 35516))
;;; Generated autoloads from gnus/gnus-sync.el
(autoload 'gnus-sync-initialize "gnus-sync" "\
;;;***
\f
;;;### (autoloads (gnus-add-configuration) "gnus-win" "gnus/gnus-win.el"
-;;;;;; (19845 45374))
+;;;;;; (20448 36271))
;;; Generated autoloads from gnus/gnus-win.el
(autoload 'gnus-add-configuration "gnus-win" "\
;;;***
\f
;;;### (autoloads (gnutls-min-prime-bits) "gnutls" "net/gnutls.el"
-;;;;;; (20002 46800))
+;;;;;; (20419 46656))
;;; Generated autoloads from net/gnutls.el
-(defvar gnutls-min-prime-bits nil "\
-The minimum number of bits to be used in Diffie-Hellman key exchange.
-
-This sets the minimum accepted size of the key to be used in a
-client-server handshake. If the server sends a prime with fewer than
-the specified number of bits the handshake will fail.
+(defvar gnutls-min-prime-bits 256 "\
+Minimum number of prime bits accepted by GnuTLS for key exchange.
+During a Diffie-Hellman handshake, if the server sends a prime
+number with fewer than this number of bits, the handshake is
+rejected. (The smaller the prime number, the less secure the
+key exchange is against man-in-the-middle attacks.)
-A value of nil says to use the default gnutls value.")
+A value of nil says to use the default GnuTLS value.")
(custom-autoload 'gnutls-min-prime-bits "gnutls" t)
;;;***
\f
-;;;### (autoloads (gomoku) "gomoku" "play/gomoku.el" (19889 21967))
+;;;### (autoloads (gomoku) "gomoku" "play/gomoku.el" (20356 35090))
;;; Generated autoloads from play/gomoku.el
(autoload 'gomoku "gomoku" "\
;;;***
\f
;;;### (autoloads (goto-address-prog-mode goto-address-mode goto-address
-;;;;;; goto-address-at-point) "goto-addr" "net/goto-addr.el" (19845
-;;;;;; 45374))
+;;;;;; goto-address-at-point) "goto-addr" "net/goto-addr.el" (20356
+;;;;;; 35090))
;;; Generated autoloads from net/goto-addr.el
(define-obsolete-function-alias 'goto-address-at-mouse 'goto-address-at-point "22.1")
(autoload 'goto-address-mode "goto-addr" "\
Minor mode to buttonize URLs and e-mail addresses in the current buffer.
+With a prefix argument ARG, enable the mode if ARG is positive,
+and disable it otherwise. If called from Lisp, enable the mode
+if ARG is omitted or nil.
\(fn &optional ARG)" t nil)
(autoload 'goto-address-prog-mode "goto-addr" "\
-Turn on `goto-address-mode', but only in comments and strings.
+Like `goto-address-mode', but only for comments and strings.
\(fn &optional ARG)" t nil)
;;;***
\f
;;;### (autoloads (gravatar-retrieve-synchronously gravatar-retrieve)
-;;;;;; "gravatar" "gnus/gravatar.el" (19845 45374))
+;;;;;; "gravatar" "gnus/gravatar.el" (20290 33419))
;;; Generated autoloads from gnus/gravatar.el
(autoload 'gravatar-retrieve "gravatar" "\
\f
;;;### (autoloads (zrgrep rgrep lgrep grep-find grep grep-mode grep-compute-defaults
;;;;;; grep-process-setup grep-setup-hook grep-find-command grep-command
-;;;;;; grep-window-height) "grep" "progmodes/grep.el" (20050 11479))
+;;;;;; grep-window-height) "grep" "progmodes/grep.el" (20373 41604))
;;; Generated autoloads from progmodes/grep.el
(defvar grep-window-height nil "\
-*Number of lines in a grep window. If nil, use `compilation-window-height'.")
+Number of lines in a grep window. If nil, use `compilation-window-height'.")
(custom-autoload 'grep-window-height "grep" t)
(custom-autoload 'grep-setup-hook "grep" t)
-(defconst grep-regexp-alist '(("^\\(.+?\\)\\(:[ ]*\\)\\([1-9][0-9]*\\)\\2" 1 3) ("^\\(\\(.+?\\):\\([1-9][0-9]*\\):\\).*?\\(\e\\[01;31m\\(?:\e\\[K\\)?\\)\\(.*?\\)\\(\e\\[[0-9]*m\\)" 2 3 ((lambda nil (setq compilation-error-screen-columns nil) (- (match-beginning 4) (match-end 1))) lambda nil (- (match-end 5) (match-end 1) (- (match-end 4) (match-beginning 4)))) nil 1) ("^Binary file \\(.+\\) matches$" 1 nil nil 0 1)) "\
+(defconst grep-regexp-alist '(("^\\(.+?\\)\\(:[ ]*\\)\\([1-9][0-9]*\\)\\2" 1 3 ((lambda nil (when grep-highlight-matches (let* ((beg (match-end 0)) (end (save-excursion (goto-char beg) (line-end-position))) (mbeg (text-property-any beg end 'font-lock-face 'match))) (when mbeg (- mbeg beg))))) lambda nil (when grep-highlight-matches (let* ((beg (match-end 0)) (end (save-excursion (goto-char beg) (line-end-position))) (mbeg (text-property-any beg end 'font-lock-face 'match)) (mend (and mbeg (next-single-property-change mbeg 'font-lock-face nil end)))) (when mend (- mend beg)))))) ("^Binary file \\(.+\\) matches$" 1 nil nil 0 1)) "\
Regexp used to match grep hits. See `compilation-error-regexp-alist'.")
(defvar grep-program (purecopy "grep") "\
This variable's value takes effect when `grep-compute-defaults' is called.")
-(defvar grep-history nil)
+(defvar grep-history nil "\
+History list for grep.")
-(defvar grep-find-history nil)
+(defvar grep-find-history nil "\
+History list for grep-find.")
(autoload 'grep-process-setup "grep" "\
Setup compilation variables and buffer for `grep'.
(autoload 'grep "grep" "\
Run grep, with user-specified args, and collect output in a buffer.
While grep runs asynchronously, you can use \\[next-error] (M-x next-error),
-or \\<grep-mode-map>\\[compile-goto-error] in the grep output buffer, to go to the lines where grep
-found matches.
+or \\<grep-mode-map>\\[compile-goto-error] in the *grep* buffer, to go to the lines where grep found
+matches. To kill the grep job before it finishes, type \\[kill-compilation].
For doing a recursive `grep', see the `rgrep' command. For running
`grep' in a specific directory, see `lgrep'.
before it is executed.
With two \\[universal-argument] prefixes, directly edit and run `grep-find-command'.
-Collect output in a buffer. While find runs asynchronously, you
-can use \\[next-error] (M-x next-error), or \\<grep-mode-map>\\[compile-goto-error] in the grep output buffer,
-to go to the lines where grep found matches.
+Collect output in a buffer. While the recursive grep is running,
+you can use \\[next-error] (M-x next-error), or \\<grep-mode-map>\\[compile-goto-error] in the grep output buffer,
+to visit the lines where matches were found. To kill the job
+before it finishes, type \\[kill-compilation].
This command shares argument histories with \\[lgrep] and \\[grep-find].
+When called programmatically and FILES is nil, REGEXP is expected
+to specify a command to run.
+
\(fn REGEXP &optional FILES DIR CONFIRM)" t nil)
(autoload 'zrgrep "grep" "\
;;;***
\f
-;;;### (autoloads (gs-load-image) "gs" "gs.el" (19845 45374))
+;;;### (autoloads (gs-load-image) "gs" "gs.el" (20244 35516))
;;; Generated autoloads from gs.el
(autoload 'gs-load-image "gs" "\
;;;***
\f
;;;### (autoloads (gud-tooltip-mode gdb-script-mode jdb pdb perldb
-;;;;;; xdb dbx sdb gud-gdb) "gud" "progmodes/gud.el" (19988 13913))
+;;;;;; xdb dbx sdb gud-gdb) "gud" "progmodes/gud.el" (20373 41604))
;;; Generated autoloads from progmodes/gud.el
(autoload 'gud-gdb "gud" "\
gud, see `gud-mode'.
\(fn COMMAND-LINE)" t nil)
- (add-hook 'same-window-regexps (purecopy "\\*gud-.*\\*\\(\\|<[0-9]+>\\)"))
(autoload 'gdb-script-mode "gud" "\
Major mode for editing GDB scripts.
(autoload 'gud-tooltip-mode "gud" "\
Toggle the display of GUD tooltips.
+With a prefix argument ARG, enable the feature if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+it if ARG is omitted or nil.
\(fn &optional ARG)" t nil)
;;;***
\f
-;;;### (autoloads (handwrite) "handwrite" "play/handwrite.el" (19889
-;;;;;; 21967))
+;;;### (autoloads (setf gv-define-simple-setter gv-define-setter
+;;;;;; gv--defun-declaration gv-define-expander gv-letplace gv-get)
+;;;;;; "gv" "emacs-lisp/gv.el" (20452 56419))
+;;; Generated autoloads from emacs-lisp/gv.el
+
+(autoload 'gv-get "gv" "\
+Build the code that applies DO to PLACE.
+PLACE must be a valid generalized variable.
+DO must be a function; it will be called with 2 arguments: GETTER and SETTER,
+where GETTER is a (copyable) Elisp expression that returns the value of PLACE,
+and SETTER is a function which returns the code to set PLACE when called
+with a (not necessarily copyable) Elisp expression that returns the value to
+set it to.
+DO must return an Elisp expression.
+
+\(fn PLACE DO)" nil nil)
+
+(autoload 'gv-letplace "gv" "\
+Build the code manipulating the generalized variable PLACE.
+GETTER will be bound to a copyable expression that returns the value
+of PLACE.
+SETTER will be bound to a function that takes an expression V and returns
+and new expression that sets PLACE to V.
+BODY should return some Elisp expression E manipulating PLACE via GETTER
+and SETTER.
+The returned value will then be an Elisp expression that first evaluates
+all the parts of PLACE that can be evaluated and then runs E.
+
+\(fn (GETTER SETTER) PLACE &rest BODY)" nil t)
+
+(put 'gv-letplace 'lisp-indent-function '2)
+
+(autoload 'gv-define-expander "gv" "\
+Use HANDLER to handle NAME as a generalized var.
+NAME is a symbol: the name of a function, macro, or special form.
+HANDLER is a function which takes an argument DO followed by the same
+arguments as NAME. DO is a function as defined in `gv-get'.
+
+\(fn NAME HANDLER)" nil t)
+
+(put 'gv-define-expander 'lisp-indent-function '1)
+
+(autoload 'gv--defun-declaration "gv" "\
+
+
+\(fn SYMBOL NAME ARGS HANDLER &optional FIX)" nil nil)
+
+(push `(gv-expander ,(apply-partially #'gv--defun-declaration 'gv-expander)) defun-declarations-alist)
+
+(push `(gv-setter ,(apply-partially #'gv--defun-declaration 'gv-setter)) defun-declarations-alist)
+
+(autoload 'gv-define-setter "gv" "\
+Define a setter method for generalized variable NAME.
+This macro is an easy-to-use substitute for `gv-define-expander' that works
+well for simple place forms.
+Assignments of VAL to (NAME ARGS...) are expanded by binding the argument
+forms (VAL ARGS...) according to ARGLIST, then executing BODY, which must
+return a Lisp form that does the assignment.
+Actually, ARGLIST may be bound to temporary variables which are introduced
+automatically to preserve proper execution order of the arguments. Example:
+ (gv-define-setter aref (v a i) `(aset ,a ,i ,v))
+
+\(fn NAME ARGLIST &rest BODY)" nil t)
+
+(put 'gv-define-setter 'lisp-indent-function '2)
+
+(autoload 'gv-define-simple-setter "gv" "\
+Define a simple setter method for generalized variable NAME.
+This macro is an easy-to-use substitute for `gv-define-expander' that works
+well for simple place forms. Assignments of VAL to (NAME ARGS...) are
+turned into calls of the form (SETTER ARGS... VAL).
+If FIX-RETURN is non-nil, then SETTER is not assumed to return VAL and
+instead the assignment is turned into (prog1 VAL (SETTER ARGS... VAL))
+so as to preserve the semantics of `setf'.
+
+\(fn NAME SETTER &optional FIX-RETURN)" nil t)
+
+(autoload 'setf "gv" "\
+Set each PLACE to the value of its VAL.
+This is a generalized version of `setq'; the PLACEs may be symbolic
+references such as (car x) or (aref x i), as well as plain symbols.
+For example, (setf (cadr x) y) is equivalent to (setcar (cdr x) y).
+The return value is the last VAL in the list.
+
+\(fn PLACE VAL PLACE VAL ...)" nil t)
+
+(put 'gv-place 'edebug-form-spec 'edebug-match-form)
+
+;;;***
+\f
+;;;### (autoloads (handwrite) "handwrite" "play/handwrite.el" (20318
+;;;;;; 5885))
;;; Generated autoloads from play/handwrite.el
(autoload 'handwrite "handwrite" "\
;;;***
\f
;;;### (autoloads (hanoi-unix-64 hanoi-unix hanoi) "hanoi" "play/hanoi.el"
-;;;;;; (19981 40664))
+;;;;;; (19989 53691))
;;; Generated autoloads from play/hanoi.el
(autoload 'hanoi "hanoi" "\
\f
;;;### (autoloads (mail-check-payment mail-add-payment-async mail-add-payment
;;;;;; hashcash-verify-payment hashcash-insert-payment-async hashcash-insert-payment)
-;;;;;; "hashcash" "mail/hashcash.el" (19845 45374))
+;;;;;; "hashcash" "mail/hashcash.el" (20356 35090))
;;; Generated autoloads from mail/hashcash.el
(autoload 'hashcash-insert-payment "hashcash" "\
;;;### (autoloads (scan-buf-previous-region scan-buf-next-region
;;;;;; scan-buf-move-to-region help-at-pt-display-when-idle help-at-pt-set-timer
;;;;;; help-at-pt-cancel-timer display-local-help help-at-pt-kbd-string
-;;;;;; help-at-pt-string) "help-at-pt" "help-at-pt.el" (19845 45374))
+;;;;;; help-at-pt-string) "help-at-pt" "help-at-pt.el" (20244 35516))
;;; Generated autoloads from help-at-pt.el
(autoload 'help-at-pt-string "help-at-pt" "\
;;;### (autoloads (doc-file-to-info doc-file-to-man describe-categories
;;;;;; describe-syntax describe-variable variable-at-point describe-function-1
;;;;;; find-lisp-object-file-name help-C-file-name describe-function)
-;;;;;; "help-fns" "help-fns.el" (20029 5330))
+;;;;;; "help-fns" "help-fns.el" (20438 21557))
;;; Generated autoloads from help-fns.el
(autoload 'describe-function "help-fns" "\
;;;***
\f
;;;### (autoloads (three-step-help) "help-macro" "help-macro.el"
-;;;;;; (19845 45374))
+;;;;;; (20253 50954))
;;; Generated autoloads from help-macro.el
(defvar three-step-help nil "\
;;;***
\f
-;;;### (autoloads (help-xref-on-pp help-insert-xref-button help-xref-button
-;;;;;; help-make-xrefs help-buffer help-setup-xref help-mode-finish
-;;;;;; help-mode-setup) "help-mode" "help-mode.el" (20059 26455))
+;;;### (autoloads (help-bookmark-jump help-xref-on-pp help-insert-xref-button
+;;;;;; help-xref-button help-make-xrefs help-buffer help-setup-xref
+;;;;;; help-mode-finish help-mode-setup help-mode) "help-mode" "help-mode.el"
+;;;;;; (20446 34252))
;;; Generated autoloads from help-mode.el
+(autoload 'help-mode "help-mode" "\
+Major mode for viewing help text and navigating references in it.
+Entry to this mode runs the normal hook `help-mode-hook'.
+Commands:
+\\{help-mode-map}
+
+\(fn)" t nil)
+
(autoload 'help-mode-setup "help-mode" "\
\(fn FROM TO)" nil nil)
+(autoload 'help-bookmark-jump "help-mode" "\
+Jump to help-mode bookmark BOOKMARK.
+Handler function for record returned by `help-bookmark-make-record'.
+BOOKMARK is a bookmark name or a bookmark record.
+
+\(fn BOOKMARK)" nil nil)
+
;;;***
\f
;;;### (autoloads (Helper-help Helper-describe-bindings) "helper"
-;;;;;; "emacs-lisp/helper.el" (19845 45374))
+;;;;;; "emacs-lisp/helper.el" (20244 35516))
;;; Generated autoloads from emacs-lisp/helper.el
(autoload 'Helper-describe-bindings "helper" "\
;;;***
\f
;;;### (autoloads (hexlify-buffer hexl-find-file hexl-mode) "hexl"
-;;;;;; "hexl.el" (19865 50420))
+;;;;;; "hexl.el" (20420 52684))
;;; Generated autoloads from hexl.el
(autoload 'hexl-mode "hexl" "\
Each line in the buffer has an \"address\" (displayed in hexadecimal)
representing the offset into the file that the characters on this line
are at and 16 characters from the file (displayed as hexadecimal
-values grouped every 16 bits) and as their ASCII values.
+values grouped every `hexl-bits' bits) and as their ASCII values.
If any of the characters (displayed as ASCII characters) are
unprintable (control or meta characters) they will be replaced as
;;;### (autoloads (hi-lock-write-interactive-patterns hi-lock-unface-buffer
;;;;;; hi-lock-face-phrase-buffer hi-lock-face-buffer hi-lock-line-face-buffer
;;;;;; global-hi-lock-mode hi-lock-mode) "hi-lock" "hi-lock.el"
-;;;;;; (20034 23247))
+;;;;;; (20412 11425))
;;; Generated autoloads from hi-lock.el
(autoload 'hi-lock-mode "hi-lock" "\
-Toggle minor mode for interactively adding font-lock highlighting patterns.
-
-If ARG positive, turn hi-lock on. Issuing a hi-lock command will also
-turn hi-lock on. To turn hi-lock on in all buffers use
-`global-hi-lock-mode' or in your .emacs file (global-hi-lock-mode 1).
-When hi-lock is turned on, a \"Regexp Highlighting\" submenu is added
-to the \"Edit\" menu. The commands in the submenu, which can be
-called interactively, are:
+Toggle selective highlighting of patterns (Hi Lock mode).
+With a prefix argument ARG, enable Hi Lock mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+the mode if ARG is omitted or nil.
+
+Issuing one the highlighting commands listed below will
+automatically enable Hi Lock mode. To enable Hi Lock mode in all
+buffers, use `global-hi-lock-mode' or add (global-hi-lock-mode 1)
+to your init file. When Hi Lock mode is enabled, a \"Regexp
+Highlighting\" submenu is added to the \"Edit\" menu. The
+commands in the submenu, which can be called interactively, are:
\\[highlight-regexp] REGEXP FACE
Highlight matches of pattern REGEXP in current buffer with FACE.
(custom-autoload 'global-hi-lock-mode "hi-lock" nil)
(autoload 'global-hi-lock-mode "hi-lock" "\
-Toggle Hi-Lock mode in every possible buffer.
-With prefix ARG, turn Global-Hi-Lock mode on if and only if
-ARG is positive.
+Toggle Hi-Lock mode in all buffers.
+With prefix ARG, enable Global-Hi-Lock mode if ARG is positive;
+otherwise, disable it. If called from Lisp, enable the mode if
+ARG is omitted or nil.
+
Hi-Lock mode is enabled in all buffers where
`turn-on-hi-lock-if-enabled' would do it.
See `hi-lock-mode' for more information on Hi-Lock mode.
;;;***
\f
;;;### (autoloads (hide-ifdef-mode) "hideif" "progmodes/hideif.el"
-;;;;;; (19890 42850))
+;;;;;; (20244 35516))
;;; Generated autoloads from progmodes/hideif.el
(autoload 'hide-ifdef-mode "hideif" "\
-Toggle Hide-Ifdef mode. This is a minor mode, albeit a large one.
-With ARG, turn Hide-Ifdef mode on if arg is positive, off otherwise.
-In Hide-Ifdef mode, code within #ifdef constructs that the C preprocessor
-would eliminate may be hidden from view. Several variables affect
-how the hiding is done:
+Toggle features to hide/show #ifdef blocks (Hide-Ifdef mode).
+With a prefix argument ARG, enable Hide-Ifdef mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+the mode if ARG is omitted or nil.
+
+Hide-Ifdef mode is a buffer-local minor mode for use with C and
+C-like major modes. When enabled, code within #ifdef constructs
+that the C preprocessor would eliminate may be hidden from view.
+Several variables affect how the hiding is done:
`hide-ifdef-env'
An association list of defined and undefined symbols for the
;;;***
\f
;;;### (autoloads (turn-off-hideshow hs-minor-mode) "hideshow" "progmodes/hideshow.el"
-;;;;;; (19938 7518))
+;;;;;; (20359 18671))
;;; Generated autoloads from progmodes/hideshow.el
(defvar hs-special-modes-alist (mapcar 'purecopy '((c-mode "{" "}" "/[*/]" nil nil) (c++-mode "{" "}" "/[*/]" nil nil) (bibtex-mode ("@\\S(*\\(\\s(\\)" 1)) (java-mode "{" "}" "/[*/]" nil nil) (js-mode "{" "}" "/[*/]" nil))) "\
-*Alist for initializing the hideshow variables for different modes.
+Alist for initializing the hideshow variables for different modes.
Each element has the form
(MODE START END COMMENT-START FORWARD-SEXP-FUNC ADJUST-BEG-FUNC).
(autoload 'hs-minor-mode "hideshow" "\
Minor mode to selectively hide/show code and comment blocks.
+With a prefix argument ARG, enable the mode if ARG is positive,
+and disable it otherwise. If called from Lisp, enable the mode
+if ARG is omitted or nil.
+
When hideshow minor mode is on, the menu bar is augmented with hideshow
commands and the hideshow commands are enabled.
The value '(hs . t) is added to `buffer-invisibility-spec'.
;;;;;; highlight-compare-buffers highlight-changes-rotate-faces
;;;;;; highlight-changes-previous-change highlight-changes-next-change
;;;;;; highlight-changes-remove-highlight highlight-changes-visible-mode
-;;;;;; highlight-changes-mode) "hilit-chg" "hilit-chg.el" (19931
-;;;;;; 11784))
+;;;;;; highlight-changes-mode) "hilit-chg" "hilit-chg.el" (20244
+;;;;;; 35516))
;;; Generated autoloads from hilit-chg.el
(autoload 'highlight-changes-mode "hilit-chg" "\
-Toggle Highlight Changes mode.
-
-With ARG, turn Highlight Changes mode on if and only if arg is positive.
+Toggle highlighting changes in this buffer (Highlight Changes mode).
+With a prefix argument ARG, enable Highlight Changes mode if ARG
+is positive, and disable it otherwise. If called from Lisp,
+enable the mode if ARG is omitted or nil.
-In Highlight Changes mode changes are recorded with a text property.
-Normally they are displayed in a distinctive face, but command
-\\[highlight-changes-visible-mode] can be used to toggles this
-on and off.
+When Highlight Changes is enabled, changes are marked with a text
+property. Normally they are displayed in a distinctive face, but
+command \\[highlight-changes-visible-mode] can be used to toggles
+this on and off.
Other functions for buffers in this mode include:
\\[highlight-changes-next-change] - move point to beginning of next change
\(fn &optional ARG)" t nil)
(autoload 'highlight-changes-visible-mode "hilit-chg" "\
-Toggle visiblility of changes when buffer is in Highlight Changes mode.
+Toggle visibility of highlighting due to Highlight Changes mode.
+With a prefix argument ARG, enable Highlight Changes Visible mode
+if ARG is positive, and disable it otherwise. If called from
+Lisp, enable the mode if ARG is omitted or nil.
-This mode only has an effect when Highlight Changes mode is on.
-It allows toggling between whether or not the changed text is displayed
+Highlight Changes Visible mode only has an effect when Highlight
+Changes mode is on. When enabled, the changed text is displayed
in a distinctive face.
The default value can be customized with variable
-`highlight-changes-visibility-initial-state'
+`highlight-changes-visibility-initial-state'.
This command does not itself set highlight-changes mode.
(custom-autoload 'global-highlight-changes-mode "hilit-chg" nil)
(autoload 'global-highlight-changes-mode "hilit-chg" "\
-Toggle Highlight-Changes mode in every possible buffer.
-With prefix ARG, turn Global-Highlight-Changes mode on if and only if
-ARG is positive.
+Toggle Highlight-Changes mode in all buffers.
+With prefix ARG, enable Global-Highlight-Changes mode if ARG is positive;
+otherwise, disable it. If called from Lisp, enable the mode if
+ARG is omitted or nil.
+
Highlight-Changes mode is enabled in all buffers where
`highlight-changes-mode-turn-on' would do it.
See `highlight-changes-mode' for more information on Highlight-Changes mode.
;;;;;; hippie-expand-ignore-buffers hippie-expand-max-buffers hippie-expand-no-restriction
;;;;;; hippie-expand-dabbrev-as-symbol hippie-expand-dabbrev-skip-space
;;;;;; hippie-expand-verbose hippie-expand-try-functions-list) "hippie-exp"
-;;;;;; "hippie-exp.el" (19845 45374))
+;;;;;; "hippie-exp.el" (20244 35516))
;;; Generated autoloads from hippie-exp.el
(defvar hippie-expand-try-functions-list '(try-complete-file-name-partially try-complete-file-name try-expand-all-abbrevs try-expand-list try-expand-line try-expand-dabbrev try-expand-dabbrev-all-buffers try-expand-dabbrev-from-kill try-complete-lisp-symbol-partially try-complete-lisp-symbol) "\
Make it use the expansion functions in TRY-LIST. An optional second
argument VERBOSE non-nil makes the function verbose.
-\(fn TRY-LIST &optional VERBOSE)" nil (quote macro))
+\(fn TRY-LIST &optional VERBOSE)" nil t)
;;;***
\f
;;;### (autoloads (global-hl-line-mode hl-line-mode) "hl-line" "hl-line.el"
-;;;;;; (19976 22732))
+;;;;;; (20244 35516))
;;; Generated autoloads from hl-line.el
(autoload 'hl-line-mode "hl-line" "\
-Buffer-local minor mode to highlight the line about point.
-With ARG, turn Hl-Line mode on if ARG is positive, off otherwise.
+Toggle highlighting of the current line (Hl-Line mode).
+With a prefix argument ARG, enable Hl-Line mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+the mode if ARG is omitted or nil.
-If `hl-line-sticky-flag' is non-nil, Hl-Line mode highlights the
+Hl-Line mode is a buffer-local minor mode. If
+`hl-line-sticky-flag' is non-nil, Hl-Line mode highlights the
line about the buffer's point in all windows. Caveat: the
buffer's point might be different from the point of a
non-selected window. Hl-Line mode uses the function
(custom-autoload 'global-hl-line-mode "hl-line" nil)
(autoload 'global-hl-line-mode "hl-line" "\
-Global minor mode to highlight the line about point in the current window.
-With ARG, turn Global-Hl-Line mode on if ARG is positive, off otherwise.
+Toggle line highlighting in all buffers (Global Hl-Line mode).
+With a prefix argument ARG, enable Global Hl-Line mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+the mode if ARG is omitted or nil.
If `global-hl-line-sticky-flag' is non-nil, Global Hl-Line mode
highlights the line about the current buffer's point in all
;;;;;; holiday-bahai-holidays holiday-islamic-holidays holiday-christian-holidays
;;;;;; holiday-hebrew-holidays holiday-other-holidays holiday-local-holidays
;;;;;; holiday-oriental-holidays holiday-general-holidays) "holidays"
-;;;;;; "calendar/holidays.el" (19882 48702))
+;;;;;; "calendar/holidays.el" (20412 11425))
;;; Generated autoloads from calendar/holidays.el
(define-obsolete-variable-alias 'general-holidays 'holiday-general-holidays "23.1")
(define-obsolete-variable-alias 'bahai-holidays 'holiday-bahai-holidays "23.1")
-(defvar holiday-bahai-holidays (mapcar 'purecopy '((holiday-bahai-new-year) (holiday-bahai-ridvan) (holiday-fixed 5 23 "Declaration of the Bab") (holiday-fixed 5 29 "Ascension of Baha'u'llah") (holiday-fixed 7 9 "Martyrdom of the Bab") (holiday-fixed 10 20 "Birth of the Bab") (holiday-fixed 11 12 "Birth of Baha'u'llah") (if calendar-bahai-all-holidays-flag (append (holiday-fixed 11 26 "Day of the Covenant") (holiday-fixed 11 28 "Ascension of `Abdu'l-Baha"))))) "\
-Baha'i holidays.
+(defvar holiday-bahai-holidays (mapcar 'purecopy '((holiday-bahai-new-year) (holiday-bahai-ridvan) (holiday-fixed 5 23 "Declaration of the Báb") (holiday-fixed 5 29 "Ascension of Bahá'u'lláh") (holiday-fixed 7 9 "Martyrdom of the Báb") (holiday-fixed 10 20 "Birth of the Báb") (holiday-fixed 11 12 "Birth of Bahá'u'lláh") (if calendar-bahai-all-holidays-flag (append (holiday-fixed 11 26 "Day of the Covenant") (holiday-fixed 11 28 "Ascension of `Abdu'l-Bahá"))))) "\
+Bahá'à holidays.
See the documentation for `calendar-holidays' for details.")
(custom-autoload 'holiday-bahai-holidays "holidays" t)
;;;***
\f
-;;;### (autoloads (html2text) "html2text" "gnus/html2text.el" (19845
-;;;;;; 45374))
+;;;### (autoloads (html2text) "html2text" "gnus/html2text.el" (20244
+;;;;;; 35516))
;;; Generated autoloads from gnus/html2text.el
(autoload 'html2text "html2text" "\
;;;***
\f
;;;### (autoloads (htmlfontify-copy-and-link-dir htmlfontify-buffer)
-;;;;;; "htmlfontify" "htmlfontify.el" (19886 45771))
+;;;;;; "htmlfontify" "htmlfontify.el" (20331 12564))
;;; Generated autoloads from htmlfontify.el
(autoload 'htmlfontify-buffer "htmlfontify" "\
;;;***
\f
;;;### (autoloads (define-ibuffer-filter define-ibuffer-op define-ibuffer-sorter
-;;;;;; define-ibuffer-column) "ibuf-macs" "ibuf-macs.el" (19845
-;;;;;; 45374))
+;;;;;; define-ibuffer-column) "ibuf-macs" "ibuf-macs.el" (20412
+;;;;;; 11425))
;;; Generated autoloads from ibuf-macs.el
(autoload 'define-ibuffer-column "ibuf-macs" "\
\(fn SYMBOL (&key NAME INLINE PROPS SUMMARIZER) &rest BODY)" nil (quote macro))
-(put 'define-ibuffer-column 'lisp-indent-function 'defun)
-
(autoload 'define-ibuffer-sorter "ibuf-macs" "\
Define a method of sorting named NAME.
DOCUMENTATION is the documentation of the function, which will be called
\(fn NAME DOCUMENTATION (&key DESCRIPTION) &rest BODY)" nil (quote macro))
-(put 'define-ibuffer-sorter 'lisp-indent-function '1)
-
(autoload 'define-ibuffer-op "ibuf-macs" "\
Generate a function which operates on a buffer.
OP becomes the name of the function; if it doesn't begin with
\(fn OP ARGS DOCUMENTATION (&key INTERACTIVE MARK MODIFIER-P DANGEROUS OPSTRING ACTIVE-OPSTRING COMPLEX) &rest BODY)" nil (quote macro))
-(put 'define-ibuffer-op 'lisp-indent-function '2)
-
(autoload 'define-ibuffer-filter "ibuf-macs" "\
Define a filter named NAME.
DOCUMENTATION is the documentation of the function.
\(fn NAME DOCUMENTATION (&key READER DESCRIPTION) &rest BODY)" nil (quote macro))
-(put 'define-ibuffer-filter 'lisp-indent-function '2)
-
;;;***
\f
;;;### (autoloads (ibuffer ibuffer-other-window ibuffer-list-buffers)
-;;;;;; "ibuffer" "ibuffer.el" (20053 39261))
+;;;;;; "ibuffer" "ibuffer.el" (20412 11425))
;;; Generated autoloads from ibuffer.el
(autoload 'ibuffer-list-buffers "ibuffer" "\
\f
;;;### (autoloads (icalendar-import-buffer icalendar-import-file
;;;;;; icalendar-export-region icalendar-export-file) "icalendar"
-;;;;;; "calendar/icalendar.el" (20015 58840))
+;;;;;; "calendar/icalendar.el" (20434 28080))
;;; Generated autoloads from calendar/icalendar.el
(autoload 'icalendar-export-file "icalendar" "\
;;;***
\f
-;;;### (autoloads (icomplete-mode) "icomplete" "icomplete.el" (19940
-;;;;;; 49234))
+;;;### (autoloads (icomplete-mode) "icomplete" "icomplete.el" (20452
+;;;;;; 44311))
;;; Generated autoloads from icomplete.el
(defvar icomplete-mode nil "\
(custom-autoload 'icomplete-mode "icomplete" nil)
(autoload 'icomplete-mode "icomplete" "\
-Toggle incremental minibuffer completion for this Emacs session.
-With a numeric argument, turn Icomplete mode on if ARG is positive,
-otherwise turn it off.
+Toggle incremental minibuffer completion (Icomplete mode).
+With a prefix argument ARG, enable Icomplete mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+the mode if ARG is omitted or nil.
\(fn &optional ARG)" t nil)
;;;***
\f
-;;;### (autoloads (icon-mode) "icon" "progmodes/icon.el" (19890 42850))
+;;;### (autoloads (icon-mode) "icon" "progmodes/icon.el" (20356 35090))
;;; Generated autoloads from progmodes/icon.el
(autoload 'icon-mode "icon" "\
;;;***
\f
;;;### (autoloads (idlwave-shell) "idlw-shell" "progmodes/idlw-shell.el"
-;;;;;; (19931 11784))
+;;;;;; (20428 57510))
;;; Generated autoloads from progmodes/idlw-shell.el
(autoload 'idlwave-shell "idlw-shell" "\
;;;***
\f
;;;### (autoloads (idlwave-mode) "idlwave" "progmodes/idlwave.el"
-;;;;;; (19863 8742))
+;;;;;; (20412 11425))
;;; Generated autoloads from progmodes/idlwave.el
(autoload 'idlwave-mode "idlwave" "\
;;;;;; ido-find-alternate-file ido-find-file-other-window ido-find-file
;;;;;; ido-find-file-in-dir ido-switch-buffer-other-frame ido-insert-buffer
;;;;;; ido-kill-buffer ido-display-buffer ido-switch-buffer-other-window
-;;;;;; ido-switch-buffer ido-mode ido-mode) "ido" "ido.el" (20025
-;;;;;; 8284))
+;;;;;; ido-switch-buffer ido-mode ido-mode) "ido" "ido.el" (20451
+;;;;;; 20881))
;;; Generated autoloads from ido.el
(defvar ido-mode nil "\
RET Select the buffer at the front of the list of matches. If the
list is empty, possibly prompt to create new buffer.
-\\[ido-select-text] Select the current prompt as the buffer.
-If no buffer is found, prompt for a new one.
+\\[ido-select-text] Use the current input string verbatim.
\\[ido-next-match] Put the first element at the end of the list.
\\[ido-prev-match] Put the last element at the start of the list.
RET Select the file at the front of the list of matches. If the
list is empty, possibly prompt to create new file.
-\\[ido-select-text] Select the current prompt as the buffer or file.
-If no buffer or file is found, prompt for a new one.
+\\[ido-select-text] Use the current input string verbatim.
\\[ido-next-match] Put the first element at the end of the list.
\\[ido-prev-match] Put the last element at the start of the list.
matches all files. If there is only one match, select that file.
If there is no common suffix, show a list of all matching files
in a separate window.
+\\[ido-magic-delete-char] Open the specified directory in Dired mode.
\\[ido-edit-input] Edit input string (including directory).
\\[ido-prev-work-directory] or \\[ido-next-work-directory] go to previous/next directory in work directory history.
\\[ido-merge-work-directories] search for file in the work directory history.
\\[ido-toggle-regexp] Toggle regexp searching.
\\[ido-toggle-prefix] Toggle between substring and prefix matching.
\\[ido-toggle-case] Toggle case-sensitive searching of file names.
-\\[ido-toggle-vc] Toggle version control for this file.
\\[ido-toggle-literal] Toggle literal reading of this file.
\\[ido-completion-help] Show list of matching files in separate window.
\\[ido-toggle-ignore] Toggle ignoring files listed in `ido-ignore-files'.
;;;***
\f
-;;;### (autoloads (ielm) "ielm" "ielm.el" (19931 11784))
+;;;### (autoloads (ielm) "ielm" "ielm.el" (20244 35516))
;;; Generated autoloads from ielm.el
- (add-hook 'same-window-buffer-names (purecopy "*ielm*"))
(autoload 'ielm "ielm" "\
Interactively evaluate Emacs Lisp expressions.
;;;***
\f
-;;;### (autoloads (iimage-mode) "iimage" "iimage.el" (19845 45374))
+;;;### (autoloads (iimage-mode) "iimage" "iimage.el" (20276 3849))
;;; Generated autoloads from iimage.el
(define-obsolete-function-alias 'turn-on-iimage-mode 'iimage-mode "24.1")
(autoload 'iimage-mode "iimage" "\
-Toggle inline image minor mode.
+Toggle Iimage mode on or off.
+With a prefix argument ARG, enable Iimage mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+the mode if ARG is omitted or nil, and toggle it if ARG is `toggle'.
+\\{iimage-mode-map}
\(fn &optional ARG)" t nil)
;;;;;; create-image image-type-auto-detected-p image-type-available-p
;;;;;; image-type image-type-from-file-name image-type-from-file-header
;;;;;; image-type-from-buffer image-type-from-data) "image" "image.el"
-;;;;;; (20013 17118))
+;;;;;; (20438 17064))
;;; Generated autoloads from image.el
(autoload 'image-type-from-data "image" "\
(defimage test-image ((:type xpm :file \"~/test1.xpm\")
(:type xbm :file \"~/test1.xbm\")))
-\(fn SYMBOL SPECS &optional DOC)" nil (quote macro))
+\(fn SYMBOL SPECS &optional DOC)" nil t)
(put 'defimage 'doc-string-elt '3)
(autoload 'imagemagick-register-types "image" "\
Register file types that can be handled by ImageMagick.
-This adds the file types returned by `imagemagick-types'
-\(excluding the ones in `imagemagick-types-inhibit') to
-`auto-mode-alist' and `image-type-file-name-regexps', so that
-Emacs visits them in Image mode.
+This function is called at startup, after loading the init file.
+It registers the ImageMagick types returned by `imagemagick-filter-types'.
+
+Registered image types are added to `auto-mode-alist', so that
+Emacs visits them in Image mode. They are also added to
+`image-type-file-name-regexps', so that the `image-type' function
+recognizes these files as having image type `imagemagick'.
-If Emacs is compiled without ImageMagick support, do nothing.
+If Emacs is compiled without ImageMagick support, this does nothing.
\(fn)" nil nil)
;;;;;; image-dired-jump-thumbnail-buffer image-dired-delete-tag
;;;;;; image-dired-tag-files image-dired-show-all-from-dir image-dired-display-thumbs
;;;;;; image-dired-dired-with-window-configuration image-dired-dired-toggle-marked-thumbs)
-;;;;;; "image-dired" "image-dired.el" (20033 22846))
+;;;;;; "image-dired" "image-dired.el" (20244 35516))
;;; Generated autoloads from image-dired.el
(autoload 'image-dired-dired-toggle-marked-thumbs "image-dired" "\
\f
;;;### (autoloads (auto-image-file-mode insert-image-file image-file-name-regexp
;;;;;; image-file-name-regexps image-file-name-extensions) "image-file"
-;;;;;; "image-file.el" (19845 45374))
+;;;;;; "image-file.el" (20244 35516))
;;; Generated autoloads from image-file.el
(defvar image-file-name-extensions (purecopy '("png" "jpeg" "jpg" "gif" "tiff" "tif" "xbm" "xpm" "pbm" "pgm" "ppm" "pnm" "svg")) "\
(custom-autoload 'auto-image-file-mode "image-file" nil)
(autoload 'auto-image-file-mode "image-file" "\
-Toggle visiting of image files as images.
-With prefix argument ARG, turn on if positive, otherwise off.
-Returns non-nil if the new state is enabled.
+Toggle visiting of image files as images (Auto Image File mode).
+With a prefix argument ARG, enable Auto Image File mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+the mode if ARG is omitted or nil.
-Image files are those whose name has an extension in
+An image file is one whose name has an extension in
`image-file-name-extensions', or matches a regexp in
`image-file-name-regexps'.
;;;***
\f
;;;### (autoloads (image-bookmark-jump image-mode-as-text image-minor-mode
-;;;;;; image-mode) "image-mode" "image-mode.el" (19999 41597))
+;;;;;; image-mode) "image-mode" "image-mode.el" (20420 52684))
;;; Generated autoloads from image-mode.el
(autoload 'image-mode "image-mode" "\
\(fn)" t nil)
(autoload 'image-minor-mode "image-mode" "\
-Toggle Image minor mode.
-With arg, turn Image minor mode on if arg is positive, off otherwise.
-It provides the key \\<image-mode-map>\\[image-toggle-display] to switch back to `image-mode'
-to display an image file as the actual image.
+Toggle Image minor mode in this buffer.
+With a prefix argument ARG, enable Image minor mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+the mode if ARG is omitted or nil.
+
+Image minor mode provides the key \\<image-mode-map>\\[image-toggle-display],
+to switch back to `image-mode' and display an image file as the
+actual image.
\(fn &optional ARG)" t nil)
;;;***
\f
;;;### (autoloads (imenu imenu-add-menubar-index imenu-add-to-menubar
-;;;;;; imenu-sort-function) "imenu" "imenu.el" (19845 45374))
+;;;;;; imenu-sort-function) "imenu" "imenu.el" (20412 11425))
;;; Generated autoloads from imenu.el
(defvar imenu-sort-function nil "\
\f
;;;### (autoloads (indian-2-column-to-ucs-region in-is13194-pre-write-conversion
;;;;;; in-is13194-post-read-conversion indian-compose-string indian-compose-region)
-;;;;;; "ind-util" "language/ind-util.el" (19845 45374))
+;;;;;; "ind-util" "language/ind-util.el" (20244 35516))
;;; Generated autoloads from language/ind-util.el
(autoload 'indian-compose-region "ind-util" "\
\f
;;;### (autoloads (inferior-lisp inferior-lisp-prompt inferior-lisp-load-command
;;;;;; inferior-lisp-program inferior-lisp-filter-regexp) "inf-lisp"
-;;;;;; "progmodes/inf-lisp.el" (19845 45374))
+;;;;;; "progmodes/inf-lisp.el" (20356 35090))
;;; Generated autoloads from progmodes/inf-lisp.el
(defvar inferior-lisp-filter-regexp (purecopy "\\`\\s *\\(:\\(\\w\\|\\s_\\)\\)?\\s *\\'") "\
-*What not to save on inferior Lisp's input history.
+What not to save on inferior Lisp's input history.
Input matching this regexp is not saved on the input history in Inferior Lisp
mode. Default is whitespace followed by 0 or 1 single-letter colon-keyword
\(as in :a, :c, etc.)")
(custom-autoload 'inferior-lisp-filter-regexp "inf-lisp" t)
(defvar inferior-lisp-program (purecopy "lisp") "\
-*Program name for invoking an inferior Lisp in Inferior Lisp mode.")
+Program name for invoking an inferior Lisp in Inferior Lisp mode.")
(custom-autoload 'inferior-lisp-program "inf-lisp" t)
(defvar inferior-lisp-load-command (purecopy "(load \"%s\")\n") "\
-*Format-string for building a Lisp expression to load a file.
+Format-string for building a Lisp expression to load a file.
This format string should use `%s' to substitute a file name
and should result in a Lisp expression that will command the inferior Lisp
to load that file. The default works acceptably on most Lisps.
(custom-autoload 'inferior-lisp-prompt "inf-lisp" t)
(defvar inferior-lisp-mode-hook 'nil "\
-*Hook for customizing Inferior Lisp mode.")
+Hook for customizing Inferior Lisp mode.")
(autoload 'inferior-lisp "inf-lisp" "\
Run an inferior Lisp process, input and output via buffer `*inferior-lisp*'.
\(Type \\[describe-mode] in the process buffer for a list of commands.)
\(fn CMD)" t nil)
- (add-hook 'same-window-buffer-names (purecopy "*inferior-lisp*"))
(defalias 'run-lisp 'inferior-lisp)
;;;### (autoloads (info-display-manual Info-bookmark-jump Info-speedbar-browser
;;;;;; Info-goto-emacs-key-command-node Info-goto-emacs-command-node
;;;;;; Info-mode info-finder info-apropos Info-index Info-directory
-;;;;;; Info-on-current-buffer info-standalone info-emacs-manual
-;;;;;; info info-other-window) "info" "info.el" (20031 47065))
+;;;;;; Info-on-current-buffer info-standalone info-emacs-bug info-emacs-manual
+;;;;;; info info-other-window) "info" "info.el" (20434 28080))
;;; Generated autoloads from info.el
(autoload 'info-other-window "info" "\
Like `info' but show the Info buffer in another window.
\(fn &optional FILE-OR-NODE)" t nil)
- (add-hook 'same-window-regexps (purecopy "\\*info\\*\\(\\|<[0-9]+>\\)"))
(put 'info 'info-file (purecopy "emacs"))
(autoload 'info "info" "\
\(fn)" t nil)
+(autoload 'info-emacs-bug "info" "\
+Display the \"Reporting Bugs\" section of the Emacs manual in Info mode.
+
+\(fn)" t nil)
+
(autoload 'info-standalone "info" "\
Run Emacs as a standalone Info reader.
Usage: emacs -f info-standalone [filename]
\f
;;;### (autoloads (info-complete-file info-complete-symbol info-lookup-file
;;;;;; info-lookup-symbol info-lookup-reset) "info-look" "info-look.el"
-;;;;;; (19984 16846))
+;;;;;; (20244 35516))
;;; Generated autoloads from info-look.el
(autoload 'info-lookup-reset "info-look" "\
\f
;;;### (autoloads (info-xref-docstrings info-xref-check-all-custom
;;;;;; info-xref-check-all info-xref-check) "info-xref" "info-xref.el"
-;;;;;; (19886 45771))
+;;;;;; (20244 35516))
;;; Generated autoloads from info-xref.el
(autoload 'info-xref-check "info-xref" "\
;;;***
\f
;;;### (autoloads (batch-info-validate Info-validate Info-split Info-split-threshold
-;;;;;; Info-tagify) "informat" "informat.el" (19886 45771))
+;;;;;; Info-tagify) "informat" "informat.el" (20244 35516))
;;; Generated autoloads from informat.el
(autoload 'Info-tagify "informat" "\
\f
;;;### (autoloads (isearch-process-search-multibyte-characters isearch-toggle-input-method
;;;;;; isearch-toggle-specified-input-method) "isearch-x" "international/isearch-x.el"
-;;;;;; (19845 45374))
+;;;;;; (20244 35516))
;;; Generated autoloads from international/isearch-x.el
(autoload 'isearch-toggle-specified-input-method "isearch-x" "\
;;;***
\f
-;;;### (autoloads (isearchb-activate) "isearchb" "isearchb.el" (19845
-;;;;;; 45374))
+;;;### (autoloads (isearchb-activate) "isearchb" "isearchb.el" (20244
+;;;;;; 35516))
;;; Generated autoloads from isearchb.el
(autoload 'isearchb-activate "isearchb" "\
;;;### (autoloads (iso-cvt-define-menu iso-cvt-write-only iso-cvt-read-only
;;;;;; iso-sgml2iso iso-iso2sgml iso-iso2duden iso-iso2gtex iso-gtex2iso
;;;;;; iso-tex2iso iso-iso2tex iso-german iso-spanish) "iso-cvt"
-;;;;;; "international/iso-cvt.el" (19845 45374))
+;;;;;; "international/iso-cvt.el" (20244 35516))
;;; Generated autoloads from international/iso-cvt.el
(autoload 'iso-spanish "iso-cvt" "\
;;;***
\f
;;;### (autoloads nil "iso-transl" "international/iso-transl.el"
-;;;;;; (19845 45374))
+;;;;;; (20244 35516))
;;; Generated autoloads from international/iso-transl.el
(or key-translation-map (setq key-translation-map (make-sparse-keymap)))
(define-key key-translation-map "\C-x8" 'iso-transl-ctl-x-8-map)
;;;;;; ispell-complete-word ispell-continue ispell-buffer ispell-comments-and-strings
;;;;;; ispell-region ispell-change-dictionary ispell-kill-ispell
;;;;;; ispell-help ispell-pdict-save ispell-word ispell-personal-dictionary)
-;;;;;; "ispell" "textmodes/ispell.el" (20055 29424))
+;;;;;; "ispell" "textmodes/ispell.el" (20428 57510))
;;; Generated autoloads from textmodes/ispell.el
(put 'ispell-check-comments 'safe-local-variable (lambda (a) (memq a '(nil t exclusive))))
(defvar ispell-personal-dictionary nil "\
-*File name of your personal spelling dictionary, or nil.
+File name of your personal spelling dictionary, or nil.
If nil, the default personal dictionary, (\"~/.ispell_DICTNAME\" for ispell or
\"~/.aspell.LANG.pws\" for aspell) is used, where DICTNAME is the name of your
default dictionary and LANG the two letter language code.")
(defvar ispell-menu-map-needed (and (not ispell-menu-map) (not (featurep 'xemacs)) 'reload))
-(if ispell-menu-map-needed (progn (setq ispell-menu-map (make-sparse-keymap "Spell")) (define-key ispell-menu-map [ispell-change-dictionary] `(menu-item ,(purecopy "Change Dictionary...") ispell-change-dictionary :help ,(purecopy "Supply explicit dictionary file name"))) (define-key ispell-menu-map [ispell-kill-ispell] `(menu-item ,(purecopy "Kill Process") ispell-kill-ispell :enable (and (boundp 'ispell-process) ispell-process (eq (ispell-process-status) 'run)) :help ,(purecopy "Terminate Ispell subprocess"))) (define-key ispell-menu-map [ispell-pdict-save] `(menu-item ,(purecopy "Save Dictionary") (lambda nil (interactive) (ispell-pdict-save t t)) :help ,(purecopy "Save personal dictionary"))) (define-key ispell-menu-map [ispell-customize] `(menu-item ,(purecopy "Customize...") (lambda nil (interactive) (customize-group 'ispell)) :help ,(purecopy "Customize spell checking options"))) (define-key ispell-menu-map [ispell-help] `(menu-item ,(purecopy "Help") (lambda nil (interactive) (describe-function 'ispell-help)) :help ,(purecopy "Show standard Ispell keybindings and commands"))) (define-key ispell-menu-map [flyspell-mode] `(menu-item ,(purecopy "Automatic spell checking (Flyspell)") flyspell-mode :help ,(purecopy "Check spelling while you edit the text") :button (:toggle bound-and-true-p flyspell-mode))) (define-key ispell-menu-map [ispell-complete-word] `(menu-item ,(purecopy "Complete Word") ispell-complete-word :help ,(purecopy "Complete word at cursor using dictionary"))) (define-key ispell-menu-map [ispell-complete-word-interior-frag] `(menu-item ,(purecopy "Complete Word Fragment") ispell-complete-word-interior-frag :help ,(purecopy "Complete word fragment at cursor")))))
+(if ispell-menu-map-needed (progn (setq ispell-menu-map (make-sparse-keymap "Spell")) (define-key ispell-menu-map [ispell-change-dictionary] `(menu-item ,(purecopy "Change Dictionary...") ispell-change-dictionary :help ,(purecopy "Supply explicit dictionary file name"))) (define-key ispell-menu-map [ispell-kill-ispell] `(menu-item ,(purecopy "Kill Process") (lambda nil (interactive) (ispell-kill-ispell nil 'clear)) :enable (and (boundp 'ispell-process) ispell-process (eq (ispell-process-status) 'run)) :help ,(purecopy "Terminate Ispell subprocess"))) (define-key ispell-menu-map [ispell-pdict-save] `(menu-item ,(purecopy "Save Dictionary") (lambda nil (interactive) (ispell-pdict-save t t)) :help ,(purecopy "Save personal dictionary"))) (define-key ispell-menu-map [ispell-customize] `(menu-item ,(purecopy "Customize...") (lambda nil (interactive) (customize-group 'ispell)) :help ,(purecopy "Customize spell checking options"))) (define-key ispell-menu-map [ispell-help] `(menu-item ,(purecopy "Help") (lambda nil (interactive) (describe-function 'ispell-help)) :help ,(purecopy "Show standard Ispell keybindings and commands"))) (define-key ispell-menu-map [flyspell-mode] `(menu-item ,(purecopy "Automatic spell checking (Flyspell)") flyspell-mode :help ,(purecopy "Check spelling while you edit the text") :button (:toggle bound-and-true-p flyspell-mode))) (define-key ispell-menu-map [ispell-complete-word] `(menu-item ,(purecopy "Complete Word") ispell-complete-word :help ,(purecopy "Complete word at cursor using dictionary"))) (define-key ispell-menu-map [ispell-complete-word-interior-frag] `(menu-item ,(purecopy "Complete Word Fragment") ispell-complete-word-interior-frag :help ,(purecopy "Complete word fragment at cursor")))))
(if ispell-menu-map-needed (progn (define-key ispell-menu-map [ispell-continue] `(menu-item ,(purecopy "Continue Spell-Checking") ispell-continue :enable (and (boundp 'ispell-region-end) (marker-position ispell-region-end) (equal (marker-buffer ispell-region-end) (current-buffer))) :help ,(purecopy "Continue spell checking last region"))) (define-key ispell-menu-map [ispell-word] `(menu-item ,(purecopy "Spell-Check Word") ispell-word :help ,(purecopy "Spell-check word at cursor"))) (define-key ispell-menu-map [ispell-comments-and-strings] `(menu-item ,(purecopy "Spell-Check Comments") ispell-comments-and-strings :help ,(purecopy "Spell-check only comments and strings")))))
(KEY FUNCTION ARGS) - FUNCTION called with ARGS returns end of region.")
(defvar ispell-tex-skip-alists (purecopy '((("\\\\addcontentsline" ispell-tex-arg-end 2) ("\\\\add\\(tocontents\\|vspace\\)" ispell-tex-arg-end) ("\\\\\\([aA]lph\\|arabic\\)" ispell-tex-arg-end) ("\\\\bibliographystyle" ispell-tex-arg-end) ("\\\\makebox" ispell-tex-arg-end 0) ("\\\\e?psfig" ispell-tex-arg-end) ("\\\\document\\(class\\|style\\)" . "\\\\begin[ \n]*{[ \n]*document[ \n]*}")) (("\\(figure\\|table\\)\\*?" ispell-tex-arg-end 0) ("list" ispell-tex-arg-end 2) ("program" . "\\\\end[ \n]*{[ \n]*program[ \n]*}") ("verbatim\\*?" . "\\\\end[ \n]*{[ \n]*verbatim\\*?[ \n]*}")))) "\
-*Lists of regions to be skipped in TeX mode.
+Lists of regions to be skipped in TeX mode.
First list is used raw.
Second list has key placed inside \\begin{}.
for skipping in latex mode.")
(defconst ispell-html-skip-alists '(("<[cC][oO][dD][eE]\\>[^>]*>" "</[cC][oO][dD][eE]*>") ("<[sS][cC][rR][iI][pP][tT]\\>[^>]*>" "</[sS][cC][rR][iI][pP][tT]>") ("<[aA][pP][pP][lL][eE][tT]\\>[^>]*>" "</[aA][pP][pP][lL][eE][tT]>") ("<[vV][eE][rR][bB]\\>[^>]*>" "<[vV][eE][rR][bB]\\>[^>]*>") ("<[tT][tT]/" "/") ("<[^ \n>]" ">") ("&[^ \n;]" "[; \n]")) "\
-*Lists of start and end keys to skip in HTML buffers.
+Lists of start and end keys to skip in HTML buffers.
Same format as `ispell-skip-region-alist'.
Note - substrings of other matches must come last
(e.g. \"<[tT][tT]/\" and \"<[^ \\t\\n>]\").")
(autoload 'ispell-kill-ispell "ispell" "\
Kill current Ispell process (so that you may start a fresh one).
With NO-ERROR, just return non-nil if there was no Ispell running.
+With CLEAR, buffer session localwords are cleaned.
-\(fn &optional NO-ERROR)" t nil)
+\(fn &optional NO-ERROR CLEAR)" t nil)
(autoload 'ispell-change-dictionary "ispell" "\
Change to dictionary DICT for Ispell.
(autoload 'ispell-region "ispell" "\
Interactively check a region for spelling errors.
-Return nil if spell session is quit,
- otherwise returns shift offset amount for last line processed.
+Return nil if spell session was terminated, otherwise returns shift offset
+amount for last line processed.
\(fn REG-START REG-END &optional RECHECKP SHIFT)" t nil)
\(fn)" t nil)
(autoload 'ispell-minor-mode "ispell" "\
-Toggle Ispell minor mode.
-With prefix argument ARG, turn Ispell minor mode on if ARG is positive,
-otherwise turn it off.
+Toggle last-word spell checking (Ispell minor mode).
+With a prefix argument ARG, enable Ispell minor mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+the mode if ARG is omitted or nil.
+
+Ispell minor mode is a buffer-local minor mode. When enabled,
+typing SPC or RET warns you if the previous word is incorrectly
+spelled.
-In Ispell minor mode, pressing SPC or RET
-warns you if the previous word is incorrectly spelled.
+All the buffer-local variables and dictionaries are ignored. To
+read them into the running ispell process, type \\[ispell-word]
+SPC.
-All the buffer-local variables and dictionaries are ignored -- to read
-them into the running ispell process, type \\[ispell-word] SPC.
+For spell-checking \"on the fly\", not just after typing SPC or
+RET, use `flyspell-mode'.
\(fn &optional ARG)" t nil)
To abort spell checking of a message region and send the message anyway,
use the `x' command. (Any subsequent regions will be checked.)
-The `X' command aborts the message send so that you can edit the buffer.
+The `X' command aborts sending the message so that you can edit the buffer.
To spell-check whenever a message is sent, include the appropriate lines
in your .emacs file:
;;;***
\f
-;;;### (autoloads (iswitchb-mode) "iswitchb" "iswitchb.el" (19946
-;;;;;; 29209))
+;;;### (autoloads (iswitchb-mode) "iswitchb" "iswitchb.el" (20412
+;;;;;; 11425))
;;; Generated autoloads from iswitchb.el
(defvar iswitchb-mode nil "\
(custom-autoload 'iswitchb-mode "iswitchb" nil)
(autoload 'iswitchb-mode "iswitchb" "\
-Toggle Iswitchb global minor mode.
-With arg, turn Iswitchb mode on if ARG is positive, otherwise turn it off.
-This mode enables switching between buffers using substrings. See
-`iswitchb' for details.
+Toggle Iswitchb mode.
+With a prefix argument ARG, enable Iswitchb mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+the mode if ARG is omitted or nil.
+
+Iswitchb mode is a global minor mode that enables switching
+between buffers using substrings. See `iswitchb' for details.
\(fn &optional ARG)" t nil)
;;;### (autoloads (read-hiragana-string japanese-zenkaku-region japanese-hankaku-region
;;;;;; japanese-hiragana-region japanese-katakana-region japanese-zenkaku
;;;;;; japanese-hankaku japanese-hiragana japanese-katakana setup-japanese-environment-internal)
-;;;;;; "japan-util" "language/japan-util.el" (19845 45374))
+;;;;;; "japan-util" "language/japan-util.el" (20244 35516))
;;; Generated autoloads from language/japan-util.el
(autoload 'setup-japanese-environment-internal "japan-util" "\
;;;***
\f
;;;### (autoloads (jka-compr-uninstall jka-compr-handler) "jka-compr"
-;;;;;; "jka-compr.el" (20000 30139))
+;;;;;; "jka-compr.el" (20318 5885))
;;; Generated autoloads from jka-compr.el
(defvar jka-compr-inhibit nil "\
(autoload 'jka-compr-uninstall "jka-compr" "\
Uninstall jka-compr.
This removes the entries in `file-name-handler-alist' and `auto-mode-alist'
-and `inhibit-first-line-modes-suffixes' that were added
+and `inhibit-local-variables-suffixes' that were added
by `jka-compr-installed'.
\(fn)" nil nil)
;;;***
\f
-;;;### (autoloads (js-mode) "js" "progmodes/js.el" (20038 20303))
+;;;### (autoloads (js-mode) "js" "progmodes/js.el" (20415 57974))
;;; Generated autoloads from progmodes/js.el
(autoload 'js-mode "js" "\
\f
;;;### (autoloads (keypad-setup keypad-numlock-shifted-setup keypad-shifted-setup
;;;;;; keypad-numlock-setup keypad-setup) "keypad" "emulation/keypad.el"
-;;;;;; (19845 45374))
+;;;;;; (20244 35516))
;;; Generated autoloads from emulation/keypad.el
(defvar keypad-setup nil "\
;;;***
\f
;;;### (autoloads (kinsoku) "kinsoku" "international/kinsoku.el"
-;;;;;; (19845 45374))
+;;;;;; (20244 35516))
;;; Generated autoloads from international/kinsoku.el
(autoload 'kinsoku "kinsoku" "\
;;;***
\f
-;;;### (autoloads (kkc-region) "kkc" "international/kkc.el" (19845
-;;;;;; 45374))
+;;;### (autoloads (kkc-region) "kkc" "international/kkc.el" (20244
+;;;;;; 35516))
;;; Generated autoloads from international/kkc.el
(defvar kkc-after-update-conversion-functions nil "\
;;;### (autoloads (kmacro-end-call-mouse kmacro-end-and-call-macro
;;;;;; kmacro-end-or-call-macro kmacro-start-macro-or-insert-counter
;;;;;; kmacro-call-macro kmacro-end-macro kmacro-start-macro kmacro-exec-ring-item)
-;;;;;; "kmacro" "kmacro.el" (19886 45771))
+;;;;;; "kmacro" "kmacro.el" (20412 11425))
;;; Generated autoloads from kmacro.el
(global-set-key "\C-x(" 'kmacro-start-macro)
(global-set-key "\C-x)" 'kmacro-end-macro)
;;;***
\f
;;;### (autoloads (setup-korean-environment-internal) "korea-util"
-;;;;;; "language/korea-util.el" (19845 45374))
+;;;;;; "language/korea-util.el" (20356 35090))
;;; Generated autoloads from language/korea-util.el
(defvar default-korean-keyboard (purecopy (if (string-match "3" (or (getenv "HANGUL_KEYBOARD_TYPE") "")) "3" "")) "\
-*The kind of Korean keyboard for Korean input method.
+The kind of Korean keyboard for Korean input method.
\"\" for 2, \"3\" for 3.")
(autoload 'setup-korean-environment-internal "korea-util" "\
;;;***
\f
;;;### (autoloads (landmark landmark-test-run) "landmark" "play/landmark.el"
-;;;;;; (19889 21967))
+;;;;;; (20356 35090))
;;; Generated autoloads from play/landmark.el
(defalias 'landmark-repeat 'landmark-test-run)
\f
;;;### (autoloads (lao-compose-region lao-composition-function lao-transcribe-roman-to-lao-string
;;;;;; lao-transcribe-single-roman-syllable-to-lao lao-compose-string)
-;;;;;; "lao-util" "language/lao-util.el" (19845 45374))
+;;;;;; "lao-util" "language/lao-util.el" (20244 35516))
;;; Generated autoloads from language/lao-util.el
(autoload 'lao-compose-string "lao-util" "\
Transcribe a Romanized Lao syllable in the region FROM and TO to Lao string.
Only the first syllable is transcribed.
The value has the form: (START END LAO-STRING), where
-START and END are the beggining and end positions of the Roman Lao syllable,
+START and END are the beginning and end positions of the Roman Lao syllable,
LAO-STRING is the Lao character transcription of it.
Optional 3rd arg STR, if non-nil, is a string to search for Roman Lao
\f
;;;### (autoloads (latexenc-find-file-coding-system latexenc-coding-system-to-inputenc
;;;;;; latexenc-inputenc-to-coding-system latex-inputenc-coding-alist)
-;;;;;; "latexenc" "international/latexenc.el" (19845 45374))
+;;;;;; "latexenc" "international/latexenc.el" (20244 35516))
;;; Generated autoloads from international/latexenc.el
(defvar latex-inputenc-coding-alist (purecopy '(("ansinew" . windows-1252) ("applemac" . mac-roman) ("ascii" . us-ascii) ("cp1250" . windows-1250) ("cp1252" . windows-1252) ("cp1257" . cp1257) ("cp437de" . cp437) ("cp437" . cp437) ("cp850" . cp850) ("cp852" . cp852) ("cp858" . cp858) ("cp865" . cp865) ("latin1" . iso-8859-1) ("latin2" . iso-8859-2) ("latin3" . iso-8859-3) ("latin4" . iso-8859-4) ("latin5" . iso-8859-5) ("latin9" . iso-8859-15) ("next" . next) ("utf8" . utf-8) ("utf8x" . utf-8))) "\
;;;***
\f
;;;### (autoloads (latin1-display-ucs-per-lynx latin1-display latin1-display)
-;;;;;; "latin1-disp" "international/latin1-disp.el" (19845 45374))
+;;;;;; "latin1-disp" "international/latin1-disp.el" (20244 35516))
;;; Generated autoloads from international/latin1-disp.el
(defvar latin1-display nil "\
;;;***
\f
;;;### (autoloads (ld-script-mode) "ld-script" "progmodes/ld-script.el"
-;;;;;; (19961 55377))
+;;;;;; (20244 35516))
;;; Generated autoloads from progmodes/ld-script.el
(autoload 'ld-script-mode "ld-script" "\
;;;***
\f
-;;;### (autoloads (ledit-from-lisp-mode ledit-mode) "ledit" "ledit.el"
-;;;;;; (19845 45374))
-;;; Generated autoloads from ledit.el
-
-(defconst ledit-save-files t "\
-*Non-nil means Ledit should save files before transferring to Lisp.")
-
-(defconst ledit-go-to-lisp-string "%?lisp" "\
-*Shell commands to execute to resume Lisp job.")
-
-(defconst ledit-go-to-liszt-string "%?liszt" "\
-*Shell commands to execute to resume Lisp compiler job.")
-
-(autoload 'ledit-mode "ledit" "\
-\\<ledit-mode-map>Major mode for editing text and stuffing it to a Lisp job.
-Like Lisp mode, plus these special commands:
- \\[ledit-save-defun] -- record defun at or after point
- for later transmission to Lisp job.
- \\[ledit-save-region] -- record region for later transmission to Lisp job.
- \\[ledit-go-to-lisp] -- transfer to Lisp job and transmit saved text.
- \\[ledit-go-to-liszt] -- transfer to Liszt (Lisp compiler) job
- and transmit saved text.
-
-\\{ledit-mode-map}
-To make Lisp mode automatically change to Ledit mode,
-do (setq lisp-mode-hook 'ledit-from-lisp-mode)
-
-\(fn)" t nil)
-
-(autoload 'ledit-from-lisp-mode "ledit" "\
-
-
-\(fn)" nil nil)
-
-;;;***
-\f
-;;;### (autoloads (life) "life" "play/life.el" (19845 45374))
+;;;### (autoloads (life) "life" "play/life.el" (20244 35516))
;;; Generated autoloads from play/life.el
(autoload 'life "life" "\
;;;***
\f
;;;### (autoloads (global-linum-mode linum-mode linum-format) "linum"
-;;;;;; "linum.el" (19865 50420))
+;;;;;; "linum.el" (20244 35516))
;;; Generated autoloads from linum.el
(defvar linum-format 'dynamic "\
(custom-autoload 'linum-format "linum" t)
(autoload 'linum-mode "linum" "\
-Toggle display of line numbers in the left margin.
+Toggle display of line numbers in the left margin (Linum mode).
+With a prefix argument ARG, enable Linum mode if ARG is positive,
+and disable it otherwise. If called from Lisp, enable the mode
+if ARG is omitted or nil.
+
+Linum mode is a buffer-local minor mode.
\(fn &optional ARG)" t nil)
(custom-autoload 'global-linum-mode "linum" nil)
(autoload 'global-linum-mode "linum" "\
-Toggle Linum mode in every possible buffer.
-With prefix ARG, turn Global-Linum mode on if and only if
-ARG is positive.
+Toggle Linum mode in all buffers.
+With prefix ARG, enable Global-Linum mode if ARG is positive;
+otherwise, disable it. If called from Lisp, enable the mode if
+ARG is omitted or nil.
+
Linum mode is enabled in all buffers where
`linum-on' would do it.
See `linum-mode' for more information on Linum mode.
;;;***
\f
-;;;### (autoloads (unload-feature) "loadhist" "loadhist.el" (19996
-;;;;;; 8027))
+;;;### (autoloads (unload-feature) "loadhist" "loadhist.el" (20412
+;;;;;; 11425))
;;; Generated autoloads from loadhist.el
(autoload 'unload-feature "loadhist" "\
;;;***
\f
;;;### (autoloads (locate-with-filter locate locate-ls-subdir-switches)
-;;;;;; "locate" "locate.el" (19886 45771))
+;;;;;; "locate" "locate.el" (20244 35516))
;;; Generated autoloads from locate.el
(defvar locate-ls-subdir-switches (purecopy "-al") "\
;;;***
\f
-;;;### (autoloads (log-edit) "log-edit" "vc/log-edit.el" (19870 57559))
+;;;### (autoloads (log-edit) "log-edit" "vc/log-edit.el" (20412 11425))
;;; Generated autoloads from vc/log-edit.el
(autoload 'log-edit "log-edit" "\
;;;***
\f
-;;;### (autoloads (log-view-mode) "log-view" "vc/log-view.el" (19946
-;;;;;; 1612))
+;;;### (autoloads (log-view-mode) "log-view" "vc/log-view.el" (20290
+;;;;;; 33419))
;;; Generated autoloads from vc/log-view.el
(autoload 'log-view-mode "log-view" "\
;;;***
\f
-;;;### (autoloads (longlines-mode) "longlines" "longlines.el" (20031
-;;;;;; 47065))
+;;;### (autoloads (longlines-mode) "longlines" "longlines.el" (20244
+;;;;;; 35516))
;;; Generated autoloads from longlines.el
(autoload 'longlines-mode "longlines" "\
-Minor mode to wrap long lines.
-In Long Lines mode, long lines are wrapped if they extend beyond
-`fill-column'. The soft newlines used for line wrapping will not
-show up when the text is yanked or saved to disk.
+Toggle Long Lines mode in this buffer.
+With a prefix argument ARG, enable Long Lines mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+the mode if ARG is omitted or nil.
-With no argument, this command toggles Long Lines mode.
-With a prefix argument ARG, turn Long Lines minor mode on if ARG is positive,
-otherwise turn it off.
+When Long Lines mode is enabled, long lines are wrapped if they
+extend beyond `fill-column'. The soft newlines used for line
+wrapping will not show up when the text is yanked or saved to
+disk.
-If the variable `longlines-auto-wrap' is non-nil, lines are automatically
-wrapped whenever the buffer is changed. You can always call
-`fill-paragraph' to fill individual paragraphs.
+If the variable `longlines-auto-wrap' is non-nil, lines are
+automatically wrapped whenever the buffer is changed. You can
+always call `fill-paragraph' to fill individual paragraphs.
-If the variable `longlines-show-hard-newlines' is non-nil, hard newlines
-are indicated with a symbol.
+If the variable `longlines-show-hard-newlines' is non-nil, hard
+newlines are indicated with a symbol.
\(fn &optional ARG)" t nil)
;;;***
\f
;;;### (autoloads (print-region lpr-region print-buffer lpr-buffer
-;;;;;; lpr-command lpr-switches printer-name) "lpr" "lpr.el" (19909
-;;;;;; 7240))
+;;;;;; lpr-command lpr-switches printer-name) "lpr" "lpr.el" (20244
+;;;;;; 35516))
;;; Generated autoloads from lpr.el
-(defvar lpr-windows-system (memq system-type '(ms-dos windows-nt)))
+(defvar lpr-windows-system (memq system-type '(ms-dos windows-nt)) "\
+Non-nil if running on MS-DOS or MS Windows.")
-(defvar lpr-lp-system (memq system-type '(usg-unix-v hpux irix)))
+(defvar lpr-lp-system (memq system-type '(usg-unix-v hpux irix)) "\
+Non-nil if running on a system type that uses the \"lp\" command.")
(defvar printer-name (and (eq system-type 'ms-dos) "PRN") "\
The name of a local printer to which data is sent for printing.
;;;***
\f
;;;### (autoloads (ls-lisp-support-shell-wildcards) "ls-lisp" "ls-lisp.el"
-;;;;;; (19886 45771))
+;;;;;; (20276 3849))
;;; Generated autoloads from ls-lisp.el
(defvar ls-lisp-support-shell-wildcards t "\
;;;***
\f
-;;;### (autoloads (lunar-phases) "lunar" "calendar/lunar.el" (19845
-;;;;;; 45374))
+;;;### (autoloads (lunar-phases) "lunar" "calendar/lunar.el" (20244
+;;;;;; 35516))
;;; Generated autoloads from calendar/lunar.el
(autoload 'lunar-phases "lunar" "\
;;;***
\f
-;;;### (autoloads (m4-mode) "m4-mode" "progmodes/m4-mode.el" (19845
-;;;;;; 45374))
+;;;### (autoloads (m4-mode) "m4-mode" "progmodes/m4-mode.el" (20356
+;;;;;; 35090))
;;; Generated autoloads from progmodes/m4-mode.el
(autoload 'm4-mode "m4-mode" "\
;;;***
\f
;;;### (autoloads (macroexpand-all) "macroexp" "emacs-lisp/macroexp.el"
-;;;;;; (19930 13389))
+;;;;;; (20452 43334))
;;; Generated autoloads from emacs-lisp/macroexp.el
(autoload 'macroexpand-all "macroexp" "\
;;;***
\f
;;;### (autoloads (apply-macro-to-region-lines kbd-macro-query insert-kbd-macro
-;;;;;; name-last-kbd-macro) "macros" "macros.el" (19886 45771))
+;;;;;; name-last-kbd-macro) "macros" "macros.el" (20244 35516))
;;; Generated autoloads from macros.el
(autoload 'name-last-kbd-macro "macros" "\
;;;***
\f
;;;### (autoloads (what-domain mail-extract-address-components) "mail-extr"
-;;;;;; "mail/mail-extr.el" (19845 45374))
+;;;;;; "mail/mail-extr.el" (20356 35090))
;;; Generated autoloads from mail/mail-extr.el
(autoload 'mail-extract-address-components "mail-extr" "\
\f
;;;### (autoloads (mail-hist-put-headers-into-history mail-hist-keep-history
;;;;;; mail-hist-enable mail-hist-define-keys) "mail-hist" "mail/mail-hist.el"
-;;;;;; (19845 45374))
+;;;;;; (20356 35090))
;;; Generated autoloads from mail/mail-hist.el
(autoload 'mail-hist-define-keys "mail-hist" "\
\(fn)" nil nil)
(defvar mail-hist-keep-history t "\
-*Non-nil means keep a history for headers and text of outgoing mail.")
+Non-nil means keep a history for headers and text of outgoing mail.")
(custom-autoload 'mail-hist-keep-history "mail-hist" t)
;;;### (autoloads (mail-fetch-field mail-unquote-printable-region
;;;;;; mail-unquote-printable mail-quote-printable-region mail-quote-printable
;;;;;; mail-file-babyl-p mail-dont-reply-to-names mail-use-rfc822)
-;;;;;; "mail-utils" "mail/mail-utils.el" (19922 19303))
+;;;;;; "mail-utils" "mail/mail-utils.el" (20318 5885))
;;; Generated autoloads from mail/mail-utils.el
(defvar mail-use-rfc822 nil "\
\(fn FILE)" nil nil)
(autoload 'mail-quote-printable "mail-utils" "\
-Convert a string to the \"quoted printable\" Q encoding.
+Convert a string to the \"quoted printable\" Q encoding if necessary.
+If the string contains only ASCII characters and no troublesome ones,
+we return it unconverted.
+
If the optional argument WRAPPER is non-nil,
we add the wrapper characters =?ISO-8859-1?Q?....?=.
;;;***
\f
;;;### (autoloads (define-mail-abbrev build-mail-abbrevs mail-abbrevs-setup
-;;;;;; mail-abbrevs-mode) "mailabbrev" "mail/mailabbrev.el" (19968
-;;;;;; 28627))
+;;;;;; mail-abbrevs-mode) "mailabbrev" "mail/mailabbrev.el" (20412
+;;;;;; 11425))
;;; Generated autoloads from mail/mailabbrev.el
(defvar mail-abbrevs-mode nil "\
(custom-autoload 'mail-abbrevs-mode "mailabbrev" nil)
(autoload 'mail-abbrevs-mode "mailabbrev" "\
-Non-nil means expand mail aliases as abbrevs, in certain message headers.
+Toggle abbrev expansion of mail aliases (Mail Abbrevs mode).
+With a prefix argument ARG, enable Mail Abbrevs mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+the mode if ARG is omitted or nil.
+
+Mail Abbrevs mode is a global minor mode. When enabled,
+abbrev-like expansion is performed when editing certain mail
+headers (those specified by `mail-abbrev-mode-regexp'), based on
+the entries in your `mail-personal-alias-file'.
\(fn &optional ARG)" t nil)
\f
;;;### (autoloads (mail-complete mail-completion-at-point-function
;;;;;; define-mail-alias expand-mail-aliases mail-complete-style)
-;;;;;; "mailalias" "mail/mailalias.el" (19881 27850))
+;;;;;; "mailalias" "mail/mailalias.el" (20244 35516))
;;; Generated autoloads from mail/mailalias.el
(defvar mail-complete-style 'angles "\
;;;***
\f
;;;### (autoloads (mailclient-send-it) "mailclient" "mail/mailclient.el"
-;;;;;; (19845 45374))
+;;;;;; (20244 35516))
;;; Generated autoloads from mail/mailclient.el
(autoload 'mailclient-send-it "mailclient" "\
\f
;;;### (autoloads (makefile-imake-mode makefile-bsdmake-mode makefile-makepp-mode
;;;;;; makefile-gmake-mode makefile-automake-mode makefile-mode)
-;;;;;; "make-mode" "progmodes/make-mode.el" (19968 28627))
+;;;;;; "make-mode" "progmodes/make-mode.el" (20412 11425))
;;; Generated autoloads from progmodes/make-mode.el
(autoload 'makefile-mode "make-mode" "\
;;;***
\f
-;;;### (autoloads (make-command-summary) "makesum" "makesum.el" (19886
-;;;;;; 45771))
+;;;### (autoloads (make-command-summary) "makesum" "makesum.el" (20244
+;;;;;; 35516))
;;; Generated autoloads from makesum.el
(autoload 'make-command-summary "makesum" "\
;;;***
\f
;;;### (autoloads (Man-bookmark-jump man-follow man) "man" "man.el"
-;;;;;; (19999 41597))
+;;;;;; (20412 11425))
;;; Generated autoloads from man.el
(defalias 'manual-entry 'man)
;;;***
\f
-;;;### (autoloads (master-mode) "master" "master.el" (19845 45374))
+;;;### (autoloads (master-mode) "master" "master.el" (20244 35516))
;;; Generated autoloads from master.el
(autoload 'master-mode "master" "\
Toggle Master mode.
-With no argument, this command toggles the mode.
-Non-null prefix argument turns on the mode.
-Null prefix argument turns off the mode.
+With a prefix argument ARG, enable Master mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+the mode if ARG is omitted or nil.
-When Master mode is enabled, you can scroll the slave buffer using the
-following commands:
+When Master mode is enabled, you can scroll the slave buffer
+using the following commands:
\\{master-mode-map}
;;;***
\f
;;;### (autoloads (minibuffer-depth-indicate-mode) "mb-depth" "mb-depth.el"
-;;;;;; (19845 45374))
+;;;;;; (20244 35516))
;;; Generated autoloads from mb-depth.el
(defvar minibuffer-depth-indicate-mode nil "\
(autoload 'minibuffer-depth-indicate-mode "mb-depth" "\
Toggle Minibuffer Depth Indication mode.
-When active, any recursive use of the minibuffer will show
-the recursion depth in the minibuffer prompt. This is only
-useful if `enable-recursive-minibuffers' is non-nil.
+With a prefix argument ARG, enable Minibuffer Depth Indication
+mode if ARG is positive, and disable it otherwise. If called
+from Lisp, enable the mode if ARG is omitted or nil.
-With prefix argument ARG, turn on if positive, otherwise off.
-Returns non-nil if the new state is enabled.
+Minibuffer Depth Indication mode is a global minor mode. When
+enabled, any recursive use of the minibuffer will show the
+recursion depth in the minibuffer prompt. This is only useful if
+`enable-recursive-minibuffers' is non-nil.
\(fn &optional ARG)" t nil)
;;;;;; message-forward-make-body message-forward message-recover
;;;;;; message-supersede message-cancel-news message-followup message-wide-reply
;;;;;; message-reply message-news message-mail message-mode) "message"
-;;;;;; "gnus/message.el" (20047 35303))
+;;;;;; "gnus/message.el" (20290 33419))
;;; Generated autoloads from gnus/message.el
(define-mail-user-agent 'message-user-agent 'message-mail 'message-send-and-exit 'message-kill-buffer 'message-send-hook)
;;;***
\f
;;;### (autoloads (metapost-mode metafont-mode) "meta-mode" "progmodes/meta-mode.el"
-;;;;;; (19968 28627))
+;;;;;; (20412 11425))
;;; Generated autoloads from progmodes/meta-mode.el
(autoload 'metafont-mode "meta-mode" "\
\f
;;;### (autoloads (metamail-region metamail-buffer metamail-interpret-body
;;;;;; metamail-interpret-header) "metamail" "mail/metamail.el"
-;;;;;; (19845 45374))
+;;;;;; (20356 35090))
;;; Generated autoloads from mail/metamail.el
(autoload 'metamail-interpret-header "metamail" "\
\f
;;;### (autoloads (mh-fully-kill-draft mh-send-letter mh-user-agent-compose
;;;;;; mh-smail-batch mh-smail-other-window mh-smail) "mh-comp"
-;;;;;; "mh-e/mh-comp.el" (19993 31832))
+;;;;;; "mh-e/mh-comp.el" (20244 35516))
;;; Generated autoloads from mh-e/mh-comp.el
(autoload 'mh-smail "mh-comp" "\
;;;***
\f
-;;;### (autoloads (mh-version) "mh-e" "mh-e/mh-e.el" (20004 2139))
+;;;### (autoloads (mh-version) "mh-e" "mh-e/mh-e.el" (20244 35516))
;;; Generated autoloads from mh-e/mh-e.el
(put 'mh-progs 'risky-local-variable t)
;;;***
\f
;;;### (autoloads (mh-folder-mode mh-nmail mh-rmail) "mh-folder"
-;;;;;; "mh-e/mh-folder.el" (20004 2139))
+;;;;;; "mh-e/mh-folder.el" (20373 41604))
;;; Generated autoloads from mh-e/mh-folder.el
(autoload 'mh-rmail "mh-folder" "\
;;;***
\f
;;;### (autoloads (midnight-delay-set clean-buffer-list) "midnight"
-;;;;;; "midnight.el" (19853 59245))
+;;;;;; "midnight.el" (20244 35516))
;;; Generated autoloads from midnight.el
(autoload 'clean-buffer-list "midnight" "\
;;;***
\f
;;;### (autoloads (minibuffer-electric-default-mode) "minibuf-eldef"
-;;;;;; "minibuf-eldef.el" (19845 45374))
+;;;;;; "minibuf-eldef.el" (20356 35090))
;;; Generated autoloads from minibuf-eldef.el
(defvar minibuffer-electric-default-mode nil "\
(autoload 'minibuffer-electric-default-mode "minibuf-eldef" "\
Toggle Minibuffer Electric Default mode.
-When active, minibuffer prompts that show a default value only show the
-default when it's applicable -- that is, when hitting RET would yield
-the default value. If the user modifies the input such that hitting RET
-would enter a non-default value, the prompt is modified to remove the
-default indication.
+With a prefix argument ARG, enable Minibuffer Electric Default
+mode if ARG is positive, and disable it otherwise. If called
+from Lisp, enable the mode if ARG is omitted or nil.
-With prefix argument ARG, turn on if positive, otherwise off.
-Returns non-nil if the new state is enabled.
+Minibuffer Electric Default mode is a global minor mode. When
+enabled, minibuffer prompts that show a default value only show
+the default when it's applicable -- that is, when hitting RET
+would yield the default value. If the user modifies the input
+such that hitting RET would enter a non-default value, the prompt
+is modified to remove the default indication.
\(fn &optional ARG)" t nil)
;;;***
\f
;;;### (autoloads (list-dynamic-libraries butterfly) "misc" "misc.el"
-;;;;;; (19968 28627))
+;;;;;; (20356 35090))
;;; Generated autoloads from misc.el
(autoload 'butterfly "misc" "\
\f
;;;### (autoloads (multi-isearch-files-regexp multi-isearch-files
;;;;;; multi-isearch-buffers-regexp multi-isearch-buffers multi-isearch-setup)
-;;;;;; "misearch" "misearch.el" (19886 45771))
+;;;;;; "misearch" "misearch.el" (20420 52684))
;;; Generated autoloads from misearch.el
(add-hook 'isearch-mode-hook 'multi-isearch-setup)
;;;***
\f
;;;### (autoloads (mixal-mode) "mixal-mode" "progmodes/mixal-mode.el"
-;;;;;; (19961 55377))
+;;;;;; (20244 35516))
;;; Generated autoloads from progmodes/mixal-mode.el
(autoload 'mixal-mode "mixal-mode" "\
;;;***
\f
+;;;### (autoloads (mm-default-file-encoding) "mm-encode" "gnus/mm-encode.el"
+;;;;;; (20244 35516))
+;;; Generated autoloads from gnus/mm-encode.el
+
+(autoload 'mm-default-file-encoding "mm-encode" "\
+Return a default encoding for FILE.
+
+\(fn FILE)" nil nil)
+
+;;;***
+\f
;;;### (autoloads (mm-inline-external-body mm-extern-cache-contents)
-;;;;;; "mm-extern" "gnus/mm-extern.el" (19845 45374))
+;;;;;; "mm-extern" "gnus/mm-extern.el" (20244 35516))
;;; Generated autoloads from gnus/mm-extern.el
(autoload 'mm-extern-cache-contents "mm-extern" "\
;;;***
\f
;;;### (autoloads (mm-inline-partial) "mm-partial" "gnus/mm-partial.el"
-;;;;;; (19845 45374))
+;;;;;; (20244 35516))
;;; Generated autoloads from gnus/mm-partial.el
(autoload 'mm-inline-partial "mm-partial" "\
;;;***
\f
;;;### (autoloads (mm-url-insert-file-contents-external mm-url-insert-file-contents)
-;;;;;; "mm-url" "gnus/mm-url.el" (19877 30798))
+;;;;;; "mm-url" "gnus/mm-url.el" (20244 35516))
;;; Generated autoloads from gnus/mm-url.el
(autoload 'mm-url-insert-file-contents "mm-url" "\
;;;***
\f
;;;### (autoloads (mm-uu-dissect-text-parts mm-uu-dissect) "mm-uu"
-;;;;;; "gnus/mm-uu.el" (19845 45374))
+;;;;;; "gnus/mm-uu.el" (20318 5885))
;;; Generated autoloads from gnus/mm-uu.el
(autoload 'mm-uu-dissect "mm-uu" "\
;;;***
\f
+;;;### (autoloads (mml-attach-file mml-to-mime) "mml" "gnus/mml.el"
+;;;;;; (20244 35516))
+;;; Generated autoloads from gnus/mml.el
+
+(autoload 'mml-to-mime "mml" "\
+Translate the current buffer from MML to MIME.
+
+\(fn)" nil nil)
+
+(autoload 'mml-attach-file "mml" "\
+Attach a file to the outgoing MIME message.
+The file is not inserted or encoded until you send the message with
+`\\[message-send-and-exit]' or `\\[message-send]'.
+
+FILE is the name of the file to attach. TYPE is its
+content-type, a string of the form \"type/subtype\". DESCRIPTION
+is a one-line description of the attachment. The DISPOSITION
+specifies how the attachment is intended to be displayed. It can
+be either \"inline\" (displayed automatically within the message
+body) or \"attachment\" (separate from the body).
+
+\(fn FILE &optional TYPE DESCRIPTION DISPOSITION)" t nil)
+
+;;;***
+\f
;;;### (autoloads (mml1991-sign mml1991-encrypt) "mml1991" "gnus/mml1991.el"
-;;;;;; (20026 29156))
+;;;;;; (20291 57212))
;;; Generated autoloads from gnus/mml1991.el
(autoload 'mml1991-encrypt "mml1991" "\
\f
;;;### (autoloads (mml2015-self-encrypt mml2015-sign mml2015-encrypt
;;;;;; mml2015-verify-test mml2015-verify mml2015-decrypt-test mml2015-decrypt)
-;;;;;; "mml2015" "gnus/mml2015.el" (20059 26455))
+;;;;;; "mml2015" "gnus/mml2015.el" (20244 35516))
;;; Generated autoloads from gnus/mml2015.el
(autoload 'mml2015-decrypt "mml2015" "\
;;;***
\f
-;;;### (autoloads (m2-mode) "modula2" "progmodes/modula2.el" (19845
-;;;;;; 45374))
+;;;### (autoloads nil "mode-local" "cedet/mode-local.el" (20412 11425))
+;;; Generated autoloads from cedet/mode-local.el
+
+(put 'define-overloadable-function 'doc-string-elt 3)
+
+;;;***
+\f
+;;;### (autoloads (m2-mode) "modula2" "progmodes/modula2.el" (20356
+;;;;;; 35090))
;;; Generated autoloads from progmodes/modula2.el
(defalias 'modula-2-mode 'm2-mode)
;;;***
\f
;;;### (autoloads (denato-region nato-region unmorse-region morse-region)
-;;;;;; "morse" "play/morse.el" (19869 36706))
+;;;;;; "morse" "play/morse.el" (20244 35516))
;;; Generated autoloads from play/morse.el
(autoload 'morse-region "morse" "\
;;;***
\f
;;;### (autoloads (mouse-drag-drag mouse-drag-throw) "mouse-drag"
-;;;;;; "mouse-drag.el" (19890 42850))
+;;;;;; "mouse-drag.el" (20356 35090))
;;; Generated autoloads from mouse-drag.el
(autoload 'mouse-drag-throw "mouse-drag" "\
;;;***
\f
-;;;### (autoloads (mouse-sel-mode) "mouse-sel" "mouse-sel.el" (19997
-;;;;;; 28887))
-;;; Generated autoloads from mouse-sel.el
-
-(defvar mouse-sel-mode nil "\
-Non-nil if Mouse-Sel mode is enabled.
-See the command `mouse-sel-mode' for a description of this minor mode.
-Setting this variable directly does not take effect;
-either customize it (see the info node `Easy Customization')
-or call the function `mouse-sel-mode'.")
-
-(custom-autoload 'mouse-sel-mode "mouse-sel" nil)
-
-(autoload 'mouse-sel-mode "mouse-sel" "\
-Toggle Mouse Sel mode.
-With prefix ARG, turn Mouse Sel mode on if and only if ARG is positive.
-Returns the new status of Mouse Sel mode (non-nil means on).
-
-When Mouse Sel mode is enabled, mouse selection is enhanced in
-various ways:
-
-- Double-clicking on symbol constituents selects symbols.
-Double-clicking on quotes or parentheses selects sexps.
-Double-clicking on whitespace selects whitespace.
-Triple-clicking selects lines.
-Quad-clicking selects paragraphs.
-
-- Selecting sets the region & X primary selection, but does NOT affect
-the `kill-ring', nor do the kill-ring functions change the X selection.
-Because the mouse handlers set the primary selection directly,
-mouse-sel sets the variables `interprogram-cut-function' and
-`interprogram-paste-function' to nil.
-
-- Clicking mouse-2 inserts the contents of the primary selection at
-the mouse position (or point, if `mouse-yank-at-point' is non-nil).
-
-- mouse-2 while selecting or extending copies selection to the
-kill ring; mouse-1 or mouse-3 kills it.
-
-\(fn &optional ARG)" t nil)
-
-;;;***
-\f
-;;;### (autoloads (mpc) "mpc" "mpc.el" (20052 53218))
+;;;### (autoloads (mpc) "mpc" "mpc.el" (20377 36640))
;;; Generated autoloads from mpc.el
(autoload 'mpc "mpc" "\
;;;***
\f
-;;;### (autoloads (mpuz) "mpuz" "play/mpuz.el" (19890 42850))
+;;;### (autoloads (mpuz) "mpuz" "play/mpuz.el" (20434 28080))
;;; Generated autoloads from play/mpuz.el
(autoload 'mpuz "mpuz" "\
;;;***
\f
-;;;### (autoloads (msb-mode) "msb" "msb.el" (19931 11784))
+;;;### (autoloads (msb-mode) "msb" "msb.el" (20356 35090))
;;; Generated autoloads from msb.el
(defvar msb-mode nil "\
(autoload 'msb-mode "msb" "\
Toggle Msb mode.
-With arg, turn Msb mode on if and only if arg is positive.
+With a prefix argument ARG, enable Msb mode if ARG is positive,
+and disable it otherwise. If called from Lisp, enable the mode
+if ARG is omitted or nil.
+
This mode overrides the binding(s) of `mouse-buffer-menu' to provide a
different buffer menu using the function `msb'.
;;;;;; describe-current-coding-system describe-current-coding-system-briefly
;;;;;; describe-coding-system describe-character-set list-charset-chars
;;;;;; read-charset list-character-sets) "mule-diag" "international/mule-diag.el"
-;;;;;; (19845 45374))
+;;;;;; (20244 35516))
;;; Generated autoloads from international/mule-diag.el
(autoload 'list-character-sets "mule-diag" "\
;;;;;; coding-system-translation-table-for-decode coding-system-pre-write-conversion
;;;;;; coding-system-post-read-conversion lookup-nested-alist set-nested-alist
;;;;;; truncate-string-to-width store-substring string-to-sequence)
-;;;;;; "mule-util" "international/mule-util.el" (19845 45374))
+;;;;;; "mule-util" "international/mule-util.el" (20244 35516))
;;; Generated autoloads from international/mule-util.el
(autoload 'string-to-sequence "mule-util" "\
(autoload 'with-coding-priority "mule-util" "\
Execute BODY like `progn' with CODING-SYSTEMS at the front of priority list.
CODING-SYSTEMS is a list of coding systems. See `set-coding-system-priority'.
-This affects the implicit sorting of lists of coding sysems returned by
+This affects the implicit sorting of lists of coding systems returned by
operations such as `find-coding-systems-region'.
-\(fn CODING-SYSTEMS &rest BODY)" nil (quote macro))
+\(fn CODING-SYSTEMS &rest BODY)" nil t)
(put 'with-coding-priority 'lisp-indent-function 1)
(autoload 'detect-coding-with-priority "mule-util" "\
PRIORITY-LIST is an alist of coding categories vs the corresponding
coding systems ordered by priority.
-\(fn FROM TO PRIORITY-LIST)" nil (quote macro))
+\(fn FROM TO PRIORITY-LIST)" nil t)
(autoload 'detect-coding-with-language-environment "mule-util" "\
Detect a coding system for the text between FROM and TO with LANG-ENV.
;;;### (autoloads (network-connection network-connection-to-service
;;;;;; whois-reverse-lookup whois finger ftp run-dig dns-lookup-host
;;;;;; nslookup nslookup-host ping traceroute route arp netstat
-;;;;;; iwconfig ifconfig) "net-utils" "net/net-utils.el" (19845
-;;;;;; 45374))
+;;;;;; iwconfig ifconfig) "net-utils" "net/net-utils.el" (20244
+;;;;;; 35516))
;;; Generated autoloads from net/net-utils.el
(autoload 'ifconfig "net-utils" "\
;;;***
\f
-;;;### (autoloads (netrc-credentials) "netrc" "net/netrc.el" (19845
-;;;;;; 45374))
+;;;### (autoloads (netrc-credentials) "netrc" "net/netrc.el" (20290
+;;;;;; 33419))
;;; Generated autoloads from net/netrc.el
(autoload 'netrc-credentials "netrc" "\
Return a user name/password pair.
-Port specifications will be prioritised in the order they are
+Port specifications will be prioritized in the order they are
listed in the PORTS list.
\(fn MACHINE &rest PORTS)" nil nil)
;;;***
\f
;;;### (autoloads (open-network-stream) "network-stream" "net/network-stream.el"
-;;;;;; (20044 59100))
+;;;;;; (20373 41604))
;;; Generated autoloads from net/network-stream.el
(autoload 'open-network-stream "network-stream" "\
capability command, and should return the command to switch on
STARTTLS if the server supports STARTTLS, and nil otherwise.
-:always-query-capabilies says whether to query the server for
+:always-query-capabilities says whether to query the server for
capabilities, even if we're doing a `plain' network connection.
:client-certificate should either be a list where the first
certificate. This parameter will only be used when doing TLS
or STARTTLS connections.
-If :use-starttls-if-possible is non-nil, do opportunistic
-STARTTLS upgrades even if Emacs doesn't have built-in TLS
-functionality.
+:use-starttls-if-possible is a boolean that says to do opportunistic
+STARTTLS upgrades even if Emacs doesn't have built-in TLS functionality.
:nowait is a boolean that says the connection should be made
asynchronously, if possible.
;;;***
\f
-;;;### (autoloads (comment-indent-new-line comment-auto-fill-only-comments
-;;;;;; comment-dwim comment-or-uncomment-region comment-box comment-region
-;;;;;; uncomment-region comment-kill comment-set-column comment-indent
-;;;;;; comment-indent-default comment-normalize-vars comment-multi-line
-;;;;;; comment-padding comment-style comment-column) "newcomment"
-;;;;;; "newcomment.el" (19938 7518))
-;;; Generated autoloads from newcomment.el
-
-(defalias 'indent-for-comment 'comment-indent)
-
-(defalias 'set-comment-column 'comment-set-column)
-
-(defalias 'kill-comment 'comment-kill)
-
-(defalias 'indent-new-comment-line 'comment-indent-new-line)
-
-(defvar comment-use-syntax 'undecided "\
-Non-nil if syntax-tables can be used instead of regexps.
-Can also be `undecided' which means that a somewhat expensive test will
-be used to try to determine whether syntax-tables should be trusted
-to understand comments or not in the given buffer.
-Major modes should set this variable.")
-
-(defvar comment-column 32 "\
-Column to indent right-margin comments to.
-Each mode may establish a different default value for this variable; you
-can set the value for a particular mode using that mode's hook.
-Comments might be indented to a different value in order not to go beyond
-`comment-fill-column' or in order to align them with surrounding comments.")
-
-(custom-autoload 'comment-column "newcomment" t)
-(put 'comment-column 'safe-local-variable 'integerp)
-
-(defvar comment-start nil "\
-*String to insert to start a new comment, or nil if no comment syntax.")
-(put 'comment-start 'safe-local-variable 'string-or-null-p)
-
-(defvar comment-start-skip nil "\
-*Regexp to match the start of a comment plus everything up to its body.
-If there are any \\(...\\) pairs, the comment delimiter text is held to begin
-at the place matched by the close of the first pair.")
-(put 'comment-start-skip 'safe-local-variable 'string-or-null-p)
-
-(defvar comment-end-skip nil "\
-Regexp to match the end of a comment plus everything back to its body.")
-(put 'comment-end-skip 'safe-local-variable 'string-or-null-p)
-
-(defvar comment-end (purecopy "") "\
-*String to insert to end a new comment.
-Should be an empty string if comments are terminated by end-of-line.")
-(put 'comment-end 'safe-local-variable 'string-or-null-p)
-
-(defvar comment-indent-function 'comment-indent-default "\
-Function to compute desired indentation for a comment.
-This function is called with no args with point at the beginning of
-the comment's starting delimiter and should return either the desired
-column indentation or nil.
-If nil is returned, indentation is delegated to `indent-according-to-mode'.")
-
-(defvar comment-insert-comment-function nil "\
-Function to insert a comment when a line doesn't contain one.
-The function has no args.
-
-Applicable at least in modes for languages like fixed-format Fortran where
-comments always start in column zero.")
-
-(defvar comment-style 'indent "\
-Style to be used for `comment-region'.
-See `comment-styles' for a list of available styles.")
-
-(custom-autoload 'comment-style "newcomment" t)
-
-(defvar comment-padding (purecopy " ") "\
-Padding string that `comment-region' puts between comment chars and text.
-Can also be an integer which will be automatically turned into a string
-of the corresponding number of spaces.
-
-Extra spacing between the comment characters and the comment text
-makes the comment easier to read. Default is 1. nil means 0.")
-
-(custom-autoload 'comment-padding "newcomment" t)
-
-(defvar comment-multi-line nil "\
-Non-nil means `comment-indent-new-line' continues comments.
-That is, it inserts no new terminator or starter.
-This affects `auto-fill-mode', which is the main reason to
-customize this variable.
-
-It also affects \\[indent-new-comment-line]. However, if you want this
-behavior for explicit filling, you might as well use \\[newline-and-indent].")
-
-(custom-autoload 'comment-multi-line "newcomment" t)
-
-(autoload 'comment-normalize-vars "newcomment" "\
-Check and setup the variables needed by other commenting functions.
-Functions autoloaded from newcomment.el, being entry points, should call
-this function before any other, so the rest of the code can assume that
-the variables are properly set.
-
-\(fn &optional NOERROR)" nil nil)
-
-(autoload 'comment-indent-default "newcomment" "\
-Default for `comment-indent-function'.
-
-\(fn)" nil nil)
-
-(autoload 'comment-indent "newcomment" "\
-Indent this line's comment to `comment-column', or insert an empty comment.
-If CONTINUE is non-nil, use the `comment-continue' markers if any.
-
-\(fn &optional CONTINUE)" t nil)
-
-(autoload 'comment-set-column "newcomment" "\
-Set the comment column based on point.
-With no ARG, set the comment column to the current column.
-With just minus as arg, kill any comment on this line.
-With any other arg, set comment column to indentation of the previous comment
- and then align or create a comment on this line at that column.
-
-\(fn ARG)" t nil)
-
-(autoload 'comment-kill "newcomment" "\
-Kill the first comment on this line, if any.
-With prefix ARG, kill comments on that many lines starting with this one.
-
-\(fn ARG)" t nil)
-
-(autoload 'uncomment-region "newcomment" "\
-Uncomment each line in the BEG .. END region.
-The numeric prefix ARG can specify a number of chars to remove from the
-comment markers.
-
-\(fn BEG END &optional ARG)" t nil)
-
-(autoload 'comment-region "newcomment" "\
-Comment or uncomment each line in the region.
-With just \\[universal-argument] prefix arg, uncomment each line in region BEG .. END.
-Numeric prefix ARG means use ARG comment characters.
-If ARG is negative, delete that many comment characters instead.
-
-The strings used as comment starts are built from `comment-start'
-and `comment-padding'; the strings used as comment ends are built
-from `comment-end' and `comment-padding'.
-
-By default, the `comment-start' markers are inserted at the
-current indentation of the region, and comments are terminated on
-each line (even for syntaxes in which newline does not end the
-comment and blank lines do not get comments). This can be
-changed with `comment-style'.
-
-\(fn BEG END &optional ARG)" t nil)
-
-(autoload 'comment-box "newcomment" "\
-Comment out the BEG .. END region, putting it inside a box.
-The numeric prefix ARG specifies how many characters to add to begin- and
-end- comment markers additionally to what `comment-add' already specifies.
-
-\(fn BEG END &optional ARG)" t nil)
-
-(autoload 'comment-or-uncomment-region "newcomment" "\
-Call `comment-region', unless the region only consists of comments,
-in which case call `uncomment-region'. If a prefix arg is given, it
-is passed on to the respective function.
-
-\(fn BEG END &optional ARG)" t nil)
-
-(autoload 'comment-dwim "newcomment" "\
-Call the comment command you want (Do What I Mean).
-If the region is active and `transient-mark-mode' is on, call
-`comment-region' (unless it only consists of comments, in which
-case it calls `uncomment-region').
-Else, if the current line is empty, call `comment-insert-comment-function'
-if it is defined, otherwise insert a comment and indent it.
-Else if a prefix ARG is specified, call `comment-kill'.
-Else, call `comment-indent'.
-You can configure `comment-style' to change the way regions are commented.
-
-\(fn ARG)" t nil)
-
-(defvar comment-auto-fill-only-comments nil "\
-Non-nil means to only auto-fill inside comments.
-This has no effect in modes that do not define a comment syntax.")
-
-(custom-autoload 'comment-auto-fill-only-comments "newcomment" t)
-
-(autoload 'comment-indent-new-line "newcomment" "\
-Break line at point and indent, continuing comment if within one.
-This indents the body of the continued comment
-under the previous comment line.
-
-This command is intended for styles where you write a comment per line,
-starting a new comment (and terminating it if necessary) on each line.
-If you want to continue one comment across several lines, use \\[newline-and-indent].
-
-If a fill column is specified, it overrides the use of the comment column
-or comment indentation.
-
-The inserted newline is marked hard if variable `use-hard-newlines' is true,
-unless optional argument SOFT is non-nil.
-
-\(fn &optional SOFT)" t nil)
-
-;;;***
-\f
;;;### (autoloads (newsticker-start newsticker-running-p) "newst-backend"
-;;;;;; "net/newst-backend.el" (19918 22236))
+;;;;;; "net/newst-backend.el" (20244 35516))
;;; Generated autoloads from net/newst-backend.el
(autoload 'newsticker-running-p "newst-backend" "\
;;;***
\f
;;;### (autoloads (newsticker-plainview) "newst-plainview" "net/newst-plainview.el"
-;;;;;; (19918 22236))
+;;;;;; (20434 28080))
;;; Generated autoloads from net/newst-plainview.el
(autoload 'newsticker-plainview "newst-plainview" "\
;;;***
\f
;;;### (autoloads (newsticker-show-news) "newst-reader" "net/newst-reader.el"
-;;;;;; (19918 22236))
+;;;;;; (20434 28080))
;;; Generated autoloads from net/newst-reader.el
(autoload 'newsticker-show-news "newst-reader" "\
;;;***
\f
;;;### (autoloads (newsticker-start-ticker newsticker-ticker-running-p)
-;;;;;; "newst-ticker" "net/newst-ticker.el" (19845 45374))
+;;;;;; "newst-ticker" "net/newst-ticker.el" (20428 57510))
;;; Generated autoloads from net/newst-ticker.el
(autoload 'newsticker-ticker-running-p "newst-ticker" "\
;;;***
\f
;;;### (autoloads (newsticker-treeview) "newst-treeview" "net/newst-treeview.el"
-;;;;;; (19918 22236))
+;;;;;; (20434 28080))
;;; Generated autoloads from net/newst-treeview.el
(autoload 'newsticker-treeview "newst-treeview" "\
;;;***
\f
;;;### (autoloads (nndiary-generate-nov-databases) "nndiary" "gnus/nndiary.el"
-;;;;;; (19845 45374))
+;;;;;; (20244 35516))
;;; Generated autoloads from gnus/nndiary.el
(autoload 'nndiary-generate-nov-databases "nndiary" "\
;;;***
\f
-;;;### (autoloads (nndoc-add-type) "nndoc" "gnus/nndoc.el" (19845
-;;;;;; 45374))
+;;;### (autoloads (nndoc-add-type) "nndoc" "gnus/nndoc.el" (20244
+;;;;;; 35516))
;;; Generated autoloads from gnus/nndoc.el
(autoload 'nndoc-add-type "nndoc" "\
;;;***
\f
;;;### (autoloads (nnfolder-generate-active-file) "nnfolder" "gnus/nnfolder.el"
-;;;;;; (19845 45374))
+;;;;;; (20244 35516))
;;; Generated autoloads from gnus/nnfolder.el
(autoload 'nnfolder-generate-active-file "nnfolder" "\
;;;***
\f
;;;### (autoloads (nnml-generate-nov-databases) "nnml" "gnus/nnml.el"
-;;;;;; (19845 45374))
+;;;;;; (20290 33419))
;;; Generated autoloads from gnus/nnml.el
(autoload 'nnml-generate-nov-databases "nnml" "\
;;;***
\f
;;;### (autoloads (disable-command enable-command disabled-command-function)
-;;;;;; "novice" "novice.el" (19845 45374))
+;;;;;; "novice" "novice.el" (20412 11425))
;;; Generated autoloads from novice.el
+(define-obsolete-variable-alias 'disabled-command-hook 'disabled-command-function "22.1")
+
(defvar disabled-command-function 'disabled-command-function "\
Function to call to handle disabled commands.
If nil, the feature is disabled, i.e., all commands work normally.")
-(define-obsolete-variable-alias 'disabled-command-hook 'disabled-command-function "22.1")
-
(autoload 'disabled-command-function "novice" "\
;;;***
\f
;;;### (autoloads (nroff-mode) "nroff-mode" "textmodes/nroff-mode.el"
-;;;;;; (19845 45374))
+;;;;;; (20244 35516))
;;; Generated autoloads from textmodes/nroff-mode.el
(autoload 'nroff-mode "nroff-mode" "\
;;;***
\f
;;;### (autoloads (nxml-glyph-display-string) "nxml-glyph" "nxml/nxml-glyph.el"
-;;;;;; (19845 45374))
+;;;;;; (20446 34252))
;;; Generated autoloads from nxml/nxml-glyph.el
(autoload 'nxml-glyph-display-string "nxml-glyph" "\
;;;***
\f
-;;;### (autoloads (nxml-mode) "nxml-mode" "nxml/nxml-mode.el" (19927
-;;;;;; 37225))
+;;;### (autoloads (nxml-mode) "nxml-mode" "nxml/nxml-mode.el" (20446
+;;;;;; 34252))
;;; Generated autoloads from nxml/nxml-mode.el
(autoload 'nxml-mode "nxml-mode" "\
If `nxml-slash-auto-complete-flag' is non-nil, then inserting a `</'
automatically inserts the rest of the end-tag.
-\\[nxml-complete] performs completion on the symbol preceding point.
+\\[completion-at-point] performs completion on the symbol preceding point.
\\[nxml-dynamic-markup-word] uses the contents of the current buffer
to choose a tag to put around the word preceding point.
;;;***
\f
;;;### (autoloads (nxml-enable-unicode-char-name-sets) "nxml-uchnm"
-;;;;;; "nxml/nxml-uchnm.el" (19845 45374))
+;;;;;; "nxml/nxml-uchnm.el" (20244 35516))
;;; Generated autoloads from nxml/nxml-uchnm.el
(autoload 'nxml-enable-unicode-char-name-sets "nxml-uchnm" "\
;;;;;; org-babel-next-src-block org-babel-goto-named-result org-babel-goto-named-src-block
;;;;;; org-babel-goto-src-block-head org-babel-hide-result-toggle-maybe
;;;;;; org-babel-sha1-hash org-babel-execute-subtree org-babel-execute-buffer
-;;;;;; org-babel-map-inline-src-blocks org-babel-map-src-blocks
-;;;;;; org-babel-open-src-block-result org-babel-switch-to-session-with-code
-;;;;;; org-babel-switch-to-session org-babel-initiate-session org-babel-load-in-session
+;;;;;; org-babel-map-executables org-babel-map-call-lines org-babel-map-inline-src-blocks
+;;;;;; org-babel-map-src-blocks org-babel-open-src-block-result
+;;;;;; org-babel-switch-to-session-with-code org-babel-switch-to-session
+;;;;;; org-babel-initiate-session org-babel-load-in-session org-babel-insert-header-arg
;;;;;; org-babel-check-src-block org-babel-expand-src-block org-babel-execute-src-block
;;;;;; org-babel-pop-to-session-maybe org-babel-load-in-session-maybe
;;;;;; org-babel-expand-src-block-maybe org-babel-view-src-block-info
;;;;;; org-babel-execute-maybe org-babel-execute-safely-maybe) "ob"
-;;;;;; "org/ob.el" (20045 31431))
+;;;;;; "org/ob.el" (20419 46656))
;;; Generated autoloads from org/ob.el
(autoload 'org-babel-execute-safely-maybe "ob" "\
execution and the collection and formatting of results can be
controlled through a variety of header arguments.
-With prefix argument ARG, force re-execution even if a an
-existing result cached in the buffer would otherwise have been
-returned.
+With prefix argument ARG, force re-execution even if an existing
+result cached in the buffer would otherwise have been returned.
Optionally supply a value for INFO in the form returned by
`org-babel-get-src-block-info'.
\(fn)" t nil)
+(autoload 'org-babel-insert-header-arg "ob" "\
+Insert a header argument selecting from lists of common args and values.
+
+\(fn)" t nil)
+
(autoload 'org-babel-load-in-session "ob" "\
Load the body of the current source-code block.
Evaluate the header arguments for the source block before
beg-body --------- point at the beginning of the body
end-body --------- point at the end of the body
-\(fn FILE &rest BODY)" nil (quote macro))
+\(fn FILE &rest BODY)" nil t)
(put 'org-babel-map-src-blocks 'lisp-indent-function '1)
If FILE is nil evaluate BODY forms on source blocks in current
buffer.
-\(fn FILE &rest BODY)" nil (quote macro))
+\(fn FILE &rest BODY)" nil t)
(put 'org-babel-map-inline-src-blocks 'lisp-indent-function '1)
+(autoload 'org-babel-map-call-lines "ob" "\
+Evaluate BODY forms on each call line in FILE.
+If FILE is nil evaluate BODY forms on source blocks in current
+buffer.
+
+\(fn FILE &rest BODY)" nil t)
+
+(put 'org-babel-map-call-lines 'lisp-indent-function '1)
+
+(autoload 'org-babel-map-executables "ob" "\
+
+
+\(fn FILE &rest BODY)" nil t)
+
+(put 'org-babel-map-executables 'lisp-indent-function '1)
+
(autoload 'org-babel-execute-buffer "ob" "\
Execute source code blocks in a buffer.
Call `org-babel-execute-src-block' on every source block in
;;;***
\f
;;;### (autoloads (org-babel-describe-bindings) "ob-keys" "org/ob-keys.el"
-;;;;;; (20045 30710))
+;;;;;; (20244 35516))
;;; Generated autoloads from org/ob-keys.el
(autoload 'org-babel-describe-bindings "ob-keys" "\
;;;***
\f
;;;### (autoloads (org-babel-lob-get-info org-babel-lob-execute-maybe
-;;;;;; org-babel-lob-ingest) "ob-lob" "org/ob-lob.el" (20045 31431))
+;;;;;; org-babel-lob-ingest) "ob-lob" "org/ob-lob.el" (20356 19083))
;;; Generated autoloads from org/ob-lob.el
(autoload 'org-babel-lob-ingest "ob-lob" "\
\f
;;;### (autoloads (org-babel-tangle org-babel-tangle-file org-babel-load-file
;;;;;; org-babel-tangle-lang-exts) "ob-tangle" "org/ob-tangle.el"
-;;;;;; (20045 30712))
+;;;;;; (20356 19083))
;;; Generated autoloads from org/ob-tangle.el
(defvar org-babel-tangle-lang-exts '(("emacs-lisp" . "el")) "\
;;;***
\f
;;;### (autoloads (inferior-octave) "octave-inf" "progmodes/octave-inf.el"
-;;;;;; (19968 28627))
+;;;;;; (20356 35090))
;;; Generated autoloads from progmodes/octave-inf.el
(autoload 'inferior-octave "octave-inf" "\
;;;***
\f
;;;### (autoloads (octave-mode) "octave-mod" "progmodes/octave-mod.el"
-;;;;;; (19968 28627))
+;;;;;; (20412 11425))
;;; Generated autoloads from progmodes/octave-mod.el
(autoload 'octave-mode "octave-mod" "\
;;;;;; org-map-entries org-open-link-from-string org-open-at-point-global
;;;;;; org-insert-link-global org-store-link org-run-like-in-org-mode
;;;;;; turn-on-orgstruct++ turn-on-orgstruct orgstruct-mode org-global-cycle
-;;;;;; org-mode org-babel-do-load-languages) "org" "org/org.el"
-;;;;;; (20045 30720))
+;;;;;; org-mode org-version org-babel-do-load-languages) "org" "org/org.el"
+;;;;;; (20420 52684))
;;; Generated autoloads from org/org.el
(autoload 'org-babel-do-load-languages "org" "\
\(fn SYM VALUE)" nil nil)
+(autoload 'org-version "org" "\
+Show the org-mode version in the echo area.
+With prefix arg HERE, insert it at point.
+
+\(fn &optional HERE)" t nil)
+
(autoload 'org-mode "org" "\
Outline-based notes management and organizer, alias
\"Carsten's outline-mode for keeping track of everything.\"
nil The current buffer, respecting the restriction if any
tree The subtree started with the entry at point
region The entries within the active region, if any
+region-start-level
+ The entries within the active region, but only those at
+ the same level than the first one.
file The current buffer, without restriction
file-with-archives
The current buffer, and any archives associated with it
(autoload 'org-switchb "org" "\
Switch between Org buffers.
-With a prefix argument, restrict available to files.
+With one prefix argument, restrict available buffers to files.
With two prefix arguments, restrict available buffers to agenda files.
Defaults to `iswitchb' for buffer name completion.
;;;;;; org-diary org-agenda-list-stuck-projects org-tags-view org-todo-list
;;;;;; org-search-view org-agenda-list org-batch-store-agenda-views
;;;;;; org-store-agenda-views org-batch-agenda-csv org-batch-agenda
-;;;;;; org-agenda) "org-agenda" "org/org-agenda.el" (20045 30712))
+;;;;;; org-agenda) "org-agenda" "org/org-agenda.el" (20420 52684))
;;; Generated autoloads from org/org-agenda.el
(autoload 'org-agenda "org-agenda" "\
Parameters are alternating variable names and values that will be bound
before running the agenda command.
-\(fn CMD-KEY &rest PARAMETERS)" nil (quote macro))
+\(fn CMD-KEY &rest PARAMETERS)" nil t)
(autoload 'org-batch-agenda-csv "org-agenda" "\
Run an agenda command in batch mode and send the result to STDOUT.
priority-n The computed numerical priority
agenda-day The day in the agenda where this is listed
-\(fn CMD-KEY &rest PARAMETERS)" nil (quote macro))
+\(fn CMD-KEY &rest PARAMETERS)" nil t)
(autoload 'org-store-agenda-views "org-agenda" "\
(autoload 'org-batch-store-agenda-views "org-agenda" "\
Run all custom agenda commands that have a file argument.
-\(fn &rest PARAMETERS)" nil (quote macro))
+\(fn &rest PARAMETERS)" nil t)
(autoload 'org-agenda-list "org-agenda" "\
Produce a daily/weekly view from all files in variable `org-agenda-files'.
you will be able to go to other days/weeks.
With a numeric prefix argument in an interactive call, the agenda will
-span INCLUDE-ALL days. Lisp programs should instead specify SPAN to change
+span ARG days. Lisp programs should instead specify SPAN to change
the number of days. SPAN defaults to `org-agenda-span'.
START-DAY defaults to TODAY, or to the most recent match for the weekday
given in `org-agenda-start-on-weekday'.
-\(fn &optional INCLUDE-ALL START-DAY SPAN)" t nil)
+\(fn &optional ARG START-DAY SPAN)" t nil)
(autoload 'org-search-view "org-agenda" "\
Show all entries that contain a phrase or words or regular expressions.
If FILTER is a string, use this string as a regular expression
for filtering entries out.
+If FILTER is a function, filter out entries against which
+calling the function returns nil. This function takes one
+argument: an entry from `org-agenda-get-day-entries'.
+
FILTER can also be an alist with the car of each cell being
either 'headline or 'category. For example:
will only add headlines containing IMPORTANT or headlines
belonging to the \"Work\" category.
-\(fn &optional REFRESH FILTER)" t nil)
+ARGS are symbols indicating what kind of entries to consider.
+By default `org-agenda-to-appt' will use :deadline, :scheduled
+and :timestamp entries. See the docstring of `org-diary' for
+details and examples.
+
+\(fn &optional REFRESH FILTER &rest ARGS)" t nil)
;;;***
\f
;;;### (autoloads (org-archive-subtree-default-with-confirmation
;;;;;; org-archive-subtree-default) "org-archive" "org/org-archive.el"
-;;;;;; (20045 30713))
+;;;;;; (20356 19083))
;;; Generated autoloads from org/org-archive.el
(autoload 'org-archive-subtree-default "org-archive" "\
;;;### (autoloads (org-export-as-ascii org-export-region-as-ascii
;;;;;; org-replace-region-by-ascii org-export-as-ascii-to-buffer
;;;;;; org-export-as-utf8-to-buffer org-export-as-utf8 org-export-as-latin1-to-buffer
-;;;;;; org-export-as-latin1) "org-ascii" "org/org-ascii.el" (20045
-;;;;;; 30713))
+;;;;;; org-export-as-latin1) "org-ascii" "org/org-ascii.el" (20345
+;;;;;; 61951))
;;; Generated autoloads from org/org-ascii.el
(autoload 'org-export-as-latin1 "org-ascii" "\
;;;***
\f
-;;;### (autoloads (org-attach) "org-attach" "org/org-attach.el" (20045
-;;;;;; 30713))
+;;;### (autoloads (org-attach) "org-attach" "org/org-attach.el" (20356
+;;;;;; 19083))
;;; Generated autoloads from org/org-attach.el
(autoload 'org-attach "org-attach" "\
;;;***
\f
;;;### (autoloads (org-bbdb-anniversaries) "org-bbdb" "org/org-bbdb.el"
-;;;;;; (20045 30713))
+;;;;;; (20345 61951))
;;; Generated autoloads from org/org-bbdb.el
(autoload 'org-bbdb-anniversaries "org-bbdb" "\
;;;***
\f
;;;### (autoloads (org-capture-import-remember-templates org-capture-insert-template-here
-;;;;;; org-capture) "org-capture" "org/org-capture.el" (20045 30713))
+;;;;;; org-capture) "org-capture" "org/org-capture.el" (20356 19083))
;;; Generated autoloads from org/org-capture.el
(autoload 'org-capture "org-capture" "\
;;;***
\f
;;;### (autoloads (org-clock-persistence-insinuate org-get-clocktable)
-;;;;;; "org-clock" "org/org-clock.el" (20045 30713))
+;;;;;; "org-clock" "org/org-clock.el" (20428 57510))
;;; Generated autoloads from org/org-clock.el
(autoload 'org-get-clocktable "org-clock" "\
;;;***
\f
;;;### (autoloads (org-datetree-find-date-create) "org-datetree"
-;;;;;; "org/org-datetree.el" (20045 30713))
+;;;;;; "org/org-datetree.el" (20345 61951))
;;; Generated autoloads from org/org-datetree.el
(autoload 'org-datetree-find-date-create "org-datetree" "\
;;;### (autoloads (org-export-as-docbook org-export-as-docbook-pdf-and-open
;;;;;; org-export-as-docbook-pdf org-export-region-as-docbook org-replace-region-by-docbook
;;;;;; org-export-as-docbook-to-buffer org-export-as-docbook-batch)
-;;;;;; "org-docbook" "org/org-docbook.el" (20045 30713))
+;;;;;; "org-docbook" "org/org-docbook.el" (20356 19083))
;;; Generated autoloads from org/org-docbook.el
(autoload 'org-export-as-docbook-batch "org-docbook" "\
\f
;;;### (autoloads (org-insert-export-options-template org-export-as-org
;;;;;; org-export-visible org-export) "org-exp" "org/org-exp.el"
-;;;;;; (20045 30715))
+;;;;;; (20356 19083))
;;; Generated autoloads from org/org-exp.el
(autoload 'org-export "org-exp" "\
;;;***
\f
;;;### (autoloads (org-feed-show-raw-feed org-feed-goto-inbox org-feed-update
-;;;;;; org-feed-update-all) "org-feed" "org/org-feed.el" (20045
-;;;;;; 30715))
+;;;;;; org-feed-update-all) "org-feed" "org/org-feed.el" (20244
+;;;;;; 35516))
;;; Generated autoloads from org/org-feed.el
(autoload 'org-feed-update-all "org-feed" "\
;;;***
\f
;;;### (autoloads (org-footnote-normalize org-footnote-action) "org-footnote"
-;;;;;; "org/org-footnote.el" (20045 30715))
+;;;;;; "org/org-footnote.el" (20380 26775))
;;; Generated autoloads from org/org-footnote.el
(autoload 'org-footnote-action "org-footnote" "\
export properties of the buffer.
When EXPORT-PROPS is non-nil, the default action is to insert
-normalized footnotes towards the end of the pre-processing buffer.
-Some exporters like docbook, odt, etc. expect that footnote
-definitions be available before any references to them. Such
-exporters can let bind `org-footnote-insert-pos-for-preprocessor' to
-symbol 'point-min to achieve the desired behaviour.
+normalized footnotes towards the end of the pre-processing
+buffer. Some exporters (docbook, odt...) expect footnote
+definitions to be available before any references to them. Such
+exporters can let bind `org-footnote-insert-pos-for-preprocessor'
+to symbol `point-min' to achieve the desired behaviour.
Additional note on `org-footnote-insert-pos-for-preprocessor':
1. This variable has not effect when FOR-PREPROCESSOR is nil.
;;;### (autoloads (org-freemind-to-org-mode org-freemind-from-org-sparse-tree
;;;;;; org-freemind-from-org-mode org-freemind-from-org-mode-node
;;;;;; org-freemind-show org-export-as-freemind) "org-freemind"
-;;;;;; "org/org-freemind.el" (20045 31431))
+;;;;;; "org/org-freemind.el" (20356 19083))
;;; Generated autoloads from org/org-freemind.el
(autoload 'org-export-as-freemind "org-freemind" "\
;;;### (autoloads (org-export-htmlize-generate-css org-export-as-html
;;;;;; org-export-region-as-html org-replace-region-by-html org-export-as-html-to-buffer
;;;;;; org-export-as-html-batch org-export-as-html-and-open) "org-html"
-;;;;;; "org/org-html.el" (20045 30715))
+;;;;;; "org/org-html.el" (20356 19083))
;;; Generated autoloads from org/org-html.el
(put 'org-export-html-style-include-default 'safe-local-variable 'booleanp)
\f
;;;### (autoloads (org-export-icalendar-combine-agenda-files org-export-icalendar-all-agenda-files
;;;;;; org-export-icalendar-this-file) "org-icalendar" "org/org-icalendar.el"
-;;;;;; (20045 30716))
+;;;;;; (20356 19083))
;;; Generated autoloads from org/org-icalendar.el
(autoload 'org-export-icalendar-this-file "org-icalendar" "\
;;;### (autoloads (org-id-store-link org-id-find-id-file org-id-find
;;;;;; org-id-goto org-id-get-with-outline-drilling org-id-get-with-outline-path-completion
;;;;;; org-id-get org-id-copy org-id-get-create) "org-id" "org/org-id.el"
-;;;;;; (20045 30716))
+;;;;;; (20244 35516))
;;; Generated autoloads from org/org-id.el
(autoload 'org-id-get-create "org-id" "\
;;;***
\f
;;;### (autoloads (org-indent-mode) "org-indent" "org/org-indent.el"
-;;;;;; (20045 30716))
+;;;;;; (20345 61951))
;;; Generated autoloads from org/org-indent.el
(autoload 'org-indent-mode "org-indent" "\
When active, indent text according to outline structure.
-Internally this works by adding `line-prefix' properties to all non-headlines.
-These properties are updated locally in idle time.
-FIXME: How to update when broken?
+Internally this works by adding `line-prefix' and `wrap-prefix'
+properties, after each buffer modification, on the modified zone.
+
+The process is synchronous. Though, initial indentation of
+buffer, which can take a few seconds on large buffers, is done
+during idle time.
\(fn &optional ARG)" t nil)
;;;***
\f
;;;### (autoloads (org-irc-store-link) "org-irc" "org/org-irc.el"
-;;;;;; (20045 30716))
+;;;;;; (20244 35516))
;;; Generated autoloads from org/org-irc.el
(autoload 'org-irc-store-link "org-irc" "\
;;;### (autoloads (org-export-as-pdf-and-open org-export-as-pdf org-export-as-latex
;;;;;; org-export-region-as-latex org-replace-region-by-latex org-export-as-latex-to-buffer
;;;;;; org-export-as-latex-batch) "org-latex" "org/org-latex.el"
-;;;;;; (20045 30716))
+;;;;;; (20345 61951))
;;; Generated autoloads from org/org-latex.el
(autoload 'org-export-as-latex-batch "org-latex" "\
;;;***
\f
+;;;### (autoloads (org-lparse-region org-replace-region-by org-lparse-to-buffer
+;;;;;; org-lparse-batch org-lparse-and-open) "org-lparse" "org/org-lparse.el"
+;;;;;; (20419 46656))
+;;; Generated autoloads from org/org-lparse.el
+
+(autoload 'org-lparse-and-open "org-lparse" "\
+Export outline to TARGET-BACKEND via NATIVE-BACKEND and open exported file.
+If there is an active region, export only the region. The prefix
+ARG specifies how many levels of the outline should become
+headlines. The default is 3. Lower levels will become bulleted
+lists.
+
+\(fn TARGET-BACKEND NATIVE-BACKEND ARG &optional FILE-OR-BUF)" nil nil)
+
+(autoload 'org-lparse-batch "org-lparse" "\
+Call the function `org-lparse'.
+This function can be used in batch processing as:
+emacs --batch
+ --load=$HOME/lib/emacs/org.el
+ --eval \"(setq org-export-headline-levels 2)\"
+ --visit=MyFile --funcall org-lparse-batch
+
+\(fn TARGET-BACKEND &optional NATIVE-BACKEND)" nil nil)
+
+(autoload 'org-lparse-to-buffer "org-lparse" "\
+Call `org-lparse' with output to a temporary buffer.
+No file is created. The prefix ARG is passed through to
+`org-lparse'.
+
+\(fn BACKEND ARG)" nil nil)
+
+(autoload 'org-replace-region-by "org-lparse" "\
+Assume the current region has org-mode syntax, and convert it to HTML.
+This can be used in any buffer. For example, you could write an
+itemized list in org-mode syntax in an HTML buffer and then use
+this command to convert it.
+
+\(fn BACKEND BEG END)" nil nil)
+
+(autoload 'org-lparse-region "org-lparse" "\
+Convert region from BEG to END in org-mode buffer to HTML.
+If prefix arg BODY-ONLY is set, omit file header, footer, and table of
+contents, and only produce the region of converted text, useful for
+cut-and-paste operations.
+If BUFFER is a buffer or a string, use/create that buffer as a target
+of the converted HTML. If BUFFER is the symbol `string', return the
+produced HTML as a string and leave not buffer behind. For example,
+a Lisp program could call this function in the following way:
+
+ (setq html (org-lparse-region \"html\" beg end t 'string))
+
+When called interactively, the output buffer is selected, and shown
+in a window. A non-interactive call will only return the buffer.
+
+\(fn BACKEND BEG END &optional BODY-ONLY BUFFER)" nil nil)
+
+;;;***
+\f
;;;### (autoloads (org-mobile-create-sumo-agenda org-mobile-pull
-;;;;;; org-mobile-push) "org-mobile" "org/org-mobile.el" (20045
-;;;;;; 30717))
+;;;;;; org-mobile-push) "org-mobile" "org/org-mobile.el" (20356
+;;;;;; 19083))
;;; Generated autoloads from org/org-mobile.el
(autoload 'org-mobile-push "org-mobile" "\
;;;***
\f
+;;;### (autoloads (org-export-as-odf-and-open org-export-as-odf org-export-odt-convert
+;;;;;; org-export-as-odt org-export-as-odt-batch org-export-as-odt-and-open)
+;;;;;; "org-odt" "org/org-odt.el" (20419 46656))
+;;; Generated autoloads from org/org-odt.el
+
+(autoload 'org-export-as-odt-and-open "org-odt" "\
+Export the outline as ODT and immediately open it with a browser.
+If there is an active region, export only the region.
+The prefix ARG specifies how many levels of the outline should become
+headlines. The default is 3. Lower levels will become bulleted lists.
+
+\(fn ARG)" t nil)
+
+(autoload 'org-export-as-odt-batch "org-odt" "\
+Call the function `org-lparse-batch'.
+This function can be used in batch processing as:
+emacs --batch
+ --load=$HOME/lib/emacs/org.el
+ --eval \"(setq org-export-headline-levels 2)\"
+ --visit=MyFile --funcall org-export-as-odt-batch
+
+\(fn)" nil nil)
+
+(autoload 'org-export-as-odt "org-odt" "\
+Export the outline as a OpenDocumentText file.
+If there is an active region, export only the region. The prefix
+ARG specifies how many levels of the outline should become
+headlines. The default is 3. Lower levels will become bulleted
+lists. HIDDEN is obsolete and does nothing.
+EXT-PLIST is a property list with external parameters overriding
+org-mode's default settings, but still inferior to file-local
+settings. When TO-BUFFER is non-nil, create a buffer with that
+name and export to that buffer. If TO-BUFFER is the symbol
+`string', don't leave any buffer behind but just return the
+resulting XML as a string. When BODY-ONLY is set, don't produce
+the file header and footer, simply return the content of
+<body>...</body>, without even the body tags themselves. When
+PUB-DIR is set, use this as the publishing directory.
+
+\(fn ARG &optional HIDDEN EXT-PLIST TO-BUFFER BODY-ONLY PUB-DIR)" t nil)
+
+(autoload 'org-export-odt-convert "org-odt" "\
+Convert IN-FILE to format OUT-FMT using a command line converter.
+IN-FILE is the file to be converted. If unspecified, it defaults
+to variable `buffer-file-name'. OUT-FMT is the desired output
+format. Use `org-export-odt-convert-process' as the converter.
+If PREFIX-ARG is non-nil then the newly converted file is opened
+using `org-open-file'.
+
+\(fn &optional IN-FILE OUT-FMT PREFIX-ARG)" t nil)
+
+(autoload 'org-export-as-odf "org-odt" "\
+Export LATEX-FRAG as OpenDocument formula file ODF-FILE.
+Use `org-create-math-formula' to convert LATEX-FRAG first to
+MathML. When invoked as an interactive command, use
+`org-latex-regexps' to infer LATEX-FRAG from currently active
+region. If no LaTeX fragments are found, prompt for it. Push
+MathML source to kill ring, if `org-export-copy-to-kill-ring' is
+non-nil.
+
+\(fn LATEX-FRAG &optional ODF-FILE)" t nil)
+
+(autoload 'org-export-as-odf-and-open "org-odt" "\
+Export LaTeX fragment as OpenDocument formula and immediately open it.
+Use `org-export-as-odf' to read LaTeX fragment and OpenDocument
+formula file.
+
+\(fn)" t nil)
+
+;;;***
+\f
;;;### (autoloads (org-plot/gnuplot) "org-plot" "org/org-plot.el"
-;;;;;; (20045 30717))
+;;;;;; (20244 35516))
;;; Generated autoloads from org/org-plot.el
(autoload 'org-plot/gnuplot "org-plot" "\
\f
;;;### (autoloads (org-publish-current-project org-publish-current-file
;;;;;; org-publish-all org-publish) "org-publish" "org/org-publish.el"
-;;;;;; (20045 30718))
+;;;;;; (20356 19083))
;;; Generated autoloads from org/org-publish.el
(defalias 'org-publish-project 'org-publish)
\f
;;;### (autoloads (org-remember-handler org-remember org-remember-apply-template
;;;;;; org-remember-annotation org-remember-insinuate) "org-remember"
-;;;;;; "org/org-remember.el" (20045 30718))
+;;;;;; "org/org-remember.el" (20420 52684))
;;; Generated autoloads from org/org-remember.el
(autoload 'org-remember-insinuate "org-remember" "\
;;;***
\f
;;;### (autoloads (org-table-to-lisp orgtbl-mode turn-on-orgtbl)
-;;;;;; "org-table" "org/org-table.el" (20045 30718))
+;;;;;; "org-table" "org/org-table.el" (20419 46656))
;;; Generated autoloads from org/org-table.el
(autoload 'turn-on-orgtbl "org-table" "\
;;;***
\f
;;;### (autoloads (org-export-as-taskjuggler-and-open org-export-as-taskjuggler)
-;;;;;; "org-taskjuggler" "org/org-taskjuggler.el" (20045 30718))
+;;;;;; "org-taskjuggler" "org/org-taskjuggler.el" (20356 19083))
;;; Generated autoloads from org/org-taskjuggler.el
(autoload 'org-export-as-taskjuggler "org-taskjuggler" "\
\f
;;;### (autoloads (org-timer-set-timer org-timer-item org-timer-change-times-in-region
;;;;;; org-timer org-timer-start) "org-timer" "org/org-timer.el"
-;;;;;; (20045 30718))
+;;;;;; (20356 19083))
;;; Generated autoloads from org/org-timer.el
(autoload 'org-timer-start "org-timer" "\
;;;***
\f
;;;### (autoloads (org-export-as-xoxo) "org-xoxo" "org/org-xoxo.el"
-;;;;;; (20045 30719))
+;;;;;; (20345 61951))
;;; Generated autoloads from org/org-xoxo.el
(autoload 'org-export-as-xoxo "org-xoxo" "\
;;;***
\f
;;;### (autoloads (outline-minor-mode outline-mode) "outline" "outline.el"
-;;;;;; (19886 45771))
+;;;;;; (20356 35090))
;;; Generated autoloads from outline.el
(put 'outline-regexp 'safe-local-variable 'stringp)
(put 'outline-heading-end-regexp 'safe-local-variable 'stringp)
(autoload 'outline-minor-mode "outline" "\
Toggle Outline minor mode.
-With arg, turn Outline minor mode on if arg is positive, off otherwise.
+With a prefix argument ARG, enable Outline minor mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+the mode if ARG is omitted or nil.
+
See the command `outline-mode' for more information on this mode.
\(fn &optional ARG)" t nil)
;;;***
\f
;;;### (autoloads (list-packages describe-package package-initialize
-;;;;;; package-install-file package-install-from-buffer package-install
-;;;;;; package-enable-at-startup) "package" "emacs-lisp/package.el"
-;;;;;; (20059 26455))
+;;;;;; package-refresh-contents package-install-file package-install-from-buffer
+;;;;;; package-install package-enable-at-startup) "package" "emacs-lisp/package.el"
+;;;;;; (20446 34252))
;;; Generated autoloads from emacs-lisp/package.el
(defvar package-enable-at-startup t "\
\(fn FILE)" t nil)
+(autoload 'package-refresh-contents "package" "\
+Download the ELPA archive description if needed.
+This informs Emacs about the latest versions of all packages, and
+makes them available for download.
+
+\(fn)" t nil)
+
(autoload 'package-initialize "package" "\
Load Emacs Lisp packages, and activate them.
The variable `package-load-list' controls which packages to load.
;;;***
\f
-;;;### (autoloads (show-paren-mode) "paren" "paren.el" (19845 45374))
+;;;### (autoloads (show-paren-mode) "paren" "paren.el" (20356 35090))
;;; Generated autoloads from paren.el
(defvar show-paren-mode nil "\
(custom-autoload 'show-paren-mode "paren" nil)
(autoload 'show-paren-mode "paren" "\
-Toggle Show Paren mode.
-With prefix ARG, turn Show Paren mode on if and only if ARG is positive.
-Returns the new status of Show Paren mode (non-nil means on).
+Toggle visualization of matching parens (Show Paren mode).
+With a prefix argument ARG, enable Show Paren mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+the mode if ARG is omitted or nil.
-When Show Paren mode is enabled, any matching parenthesis is highlighted
-in `show-paren-style' after `show-paren-delay' seconds of Emacs idle time.
+Show Paren mode is a global minor mode. When enabled, any
+matching parenthesis is highlighted in `show-paren-style' after
+`show-paren-delay' seconds of Emacs idle time.
\(fn &optional ARG)" t nil)
;;;***
\f
;;;### (autoloads (parse-time-string) "parse-time" "calendar/parse-time.el"
-;;;;;; (19845 45374))
+;;;;;; (20318 5885))
;;; Generated autoloads from calendar/parse-time.el
(put 'parse-time-rules 'risky-local-variable t)
;;;***
\f
-;;;### (autoloads (pascal-mode) "pascal" "progmodes/pascal.el" (19968
-;;;;;; 28627))
+;;;### (autoloads (pascal-mode) "pascal" "progmodes/pascal.el" (20446
+;;;;;; 34252))
;;; Generated autoloads from progmodes/pascal.el
(autoload 'pascal-mode "pascal" "\
;;;***
\f
;;;### (autoloads (password-in-cache-p password-cache-expiry password-cache)
-;;;;;; "password-cache" "password-cache.el" (19845 45374))
+;;;;;; "password-cache" "password-cache.el" (20244 35516))
;;; Generated autoloads from password-cache.el
(defvar password-cache t "\
;;;***
\f
;;;### (autoloads (pcase-let pcase-let* pcase) "pcase" "emacs-lisp/pcase.el"
-;;;;;; (19863 8742))
+;;;;;; (20452 43334))
;;; Generated autoloads from emacs-lisp/pcase.el
(autoload 'pcase "pcase" "\
like `(,a . ,(pred (< a))) or, with more checks:
`(,(and a (pred numberp)) . ,(and (pred numberp) (pred (< a))))
-\(fn EXP &rest CASES)" nil (quote macro))
+\(fn EXP &rest CASES)" nil t)
(put 'pcase 'lisp-indent-function '1)
BODY should be an expression, and BINDINGS should be a list of bindings
of the form (UPAT EXP).
-\(fn BINDINGS &rest BODY)" nil (quote macro))
+\(fn BINDINGS &rest BODY)" nil t)
(put 'pcase-let* 'lisp-indent-function '1)
BODY should be a list of expressions, and BINDINGS should be a list of bindings
of the form (UPAT EXP).
-\(fn BINDINGS &rest BODY)" nil (quote macro))
+\(fn BINDINGS &rest BODY)" nil t)
(put 'pcase-let 'lisp-indent-function '1)
;;;***
\f
-;;;### (autoloads (pcomplete/cvs) "pcmpl-cvs" "pcmpl-cvs.el" (19845
-;;;;;; 45374))
+;;;### (autoloads (pcomplete/cvs) "pcmpl-cvs" "pcmpl-cvs.el" (20244
+;;;;;; 35516))
;;; Generated autoloads from pcmpl-cvs.el
(autoload 'pcomplete/cvs "pcmpl-cvs" "\
;;;***
\f
;;;### (autoloads (pcomplete/tar pcomplete/make pcomplete/bzip2 pcomplete/gzip)
-;;;;;; "pcmpl-gnu" "pcmpl-gnu.el" (19845 45374))
+;;;;;; "pcmpl-gnu" "pcmpl-gnu.el" (20276 3849))
;;; Generated autoloads from pcmpl-gnu.el
(autoload 'pcomplete/gzip "pcmpl-gnu" "\
;;;***
\f
;;;### (autoloads (pcomplete/mount pcomplete/umount pcomplete/kill)
-;;;;;; "pcmpl-linux" "pcmpl-linux.el" (19986 58615))
+;;;;;; "pcmpl-linux" "pcmpl-linux.el" (20244 35516))
;;; Generated autoloads from pcmpl-linux.el
(autoload 'pcomplete/kill "pcmpl-linux" "\
;;;***
\f
-;;;### (autoloads (pcomplete/rpm) "pcmpl-rpm" "pcmpl-rpm.el" (19961
-;;;;;; 55377))
+;;;### (autoloads (pcomplete/rpm) "pcmpl-rpm" "pcmpl-rpm.el" (20452
+;;;;;; 43334))
;;; Generated autoloads from pcmpl-rpm.el
(autoload 'pcomplete/rpm "pcmpl-rpm" "\
\f
;;;### (autoloads (pcomplete/scp pcomplete/ssh pcomplete/chgrp pcomplete/chown
;;;;;; pcomplete/which pcomplete/xargs pcomplete/rm pcomplete/rmdir
-;;;;;; pcomplete/cd) "pcmpl-unix" "pcmpl-unix.el" (19845 45374))
+;;;;;; pcomplete/cd) "pcmpl-unix" "pcmpl-unix.el" (20375 3831))
;;; Generated autoloads from pcmpl-unix.el
(autoload 'pcomplete/cd "pcmpl-unix" "\
\f
;;;### (autoloads (pcomplete-shell-setup pcomplete-comint-setup pcomplete-list
;;;;;; pcomplete-help pcomplete-expand pcomplete-continue pcomplete-expand-and-complete
-;;;;;; pcomplete-reverse pcomplete) "pcomplete" "pcomplete.el" (20051
-;;;;;; 32345))
+;;;;;; pcomplete-reverse pcomplete) "pcomplete" "pcomplete.el" (20377
+;;;;;; 36816))
;;; Generated autoloads from pcomplete.el
(autoload 'pcomplete "pcomplete" "\
\f
;;;### (autoloads (cvs-dired-use-hook cvs-dired-action cvs-status
;;;;;; cvs-update cvs-examine cvs-quickdir cvs-checkout) "pcvs"
-;;;;;; "vc/pcvs.el" (19845 45374))
+;;;;;; "vc/pcvs.el" (20373 41604))
;;; Generated autoloads from vc/pcvs.el
(autoload 'cvs-checkout "pcvs" "\
;;;***
\f
-;;;### (autoloads nil "pcvs-defs" "vc/pcvs-defs.el" (20062 2656))
+;;;### (autoloads nil "pcvs-defs" "vc/pcvs-defs.el" (20356 35090))
;;; Generated autoloads from vc/pcvs-defs.el
-(defvar cvs-global-menu (let ((m (make-sparse-keymap "PCL-CVS"))) (define-key m [status] `(menu-item ,(purecopy "Directory Status") cvs-status :help ,(purecopy "A more verbose status of a workarea"))) (define-key m [checkout] `(menu-item ,(purecopy "Checkout Module") cvs-checkout :help ,(purecopy "Check out a module from the repository"))) (define-key m [update] `(menu-item ,(purecopy "Update Directory") cvs-update :help ,(purecopy "Fetch updates from the repository"))) (define-key m [examine] `(menu-item ,(purecopy "Examine Directory") cvs-examine :help ,(purecopy "Examine the current state of a workarea"))) (fset 'cvs-global-menu m)))
+(defvar cvs-global-menu (let ((m (make-sparse-keymap "PCL-CVS"))) (define-key m [status] `(menu-item ,(purecopy "Directory Status") cvs-status :help ,(purecopy "A more verbose status of a workarea"))) (define-key m [checkout] `(menu-item ,(purecopy "Checkout Module") cvs-checkout :help ,(purecopy "Check out a module from the repository"))) (define-key m [update] `(menu-item ,(purecopy "Update Directory") cvs-update :help ,(purecopy "Fetch updates from the repository"))) (define-key m [examine] `(menu-item ,(purecopy "Examine Directory") cvs-examine :help ,(purecopy "Examine the current state of a workarea"))) (fset 'cvs-global-menu m)) "\
+Global menu used by PCL-CVS.")
;;;***
\f
;;;### (autoloads (perl-mode) "perl-mode" "progmodes/perl-mode.el"
-;;;;;; (19911 48973))
+;;;;;; (20373 41604))
;;; Generated autoloads from progmodes/perl-mode.el
(put 'perl-indent-level 'safe-local-variable 'integerp)
(put 'perl-continued-statement-offset 'safe-local-variable 'integerp)
;;;***
\f
;;;### (autoloads (picture-mode) "picture" "textmodes/picture.el"
-;;;;;; (19845 45374))
+;;;;;; (20373 41604))
;;; Generated autoloads from textmodes/picture.el
(autoload 'picture-mode "picture" "\
You can manipulate text with these commands:
Clear ARG columns after point without moving: \\[picture-clear-column]
- Delete char at point: \\[delete-char]
+ Delete char at point: \\[picture-delete-char]
Clear ARG columns backward: \\[picture-backward-clear-column]
Clear ARG lines, advancing over them: \\[picture-clear-line]
(the cleared text is saved in the kill ring)
Entry to this mode calls the value of `picture-mode-hook' if non-nil.
Note that Picture mode commands will work outside of Picture mode, but
-they are not defaultly assigned to keys.
+they are not by default assigned to keys.
\(fn)" t nil)
;;;***
\f
-;;;### (autoloads (plstore-open) "plstore" "gnus/plstore.el" (19990
-;;;;;; 55648))
+;;;### (autoloads (plstore-mode plstore-open) "plstore" "gnus/plstore.el"
+;;;;;; (20380 26775))
;;; Generated autoloads from gnus/plstore.el
(autoload 'plstore-open "plstore" "\
\(fn FILE)" nil nil)
+(autoload 'plstore-mode "plstore" "\
+Major mode for editing PLSTORE files.
+
+\(fn)" t nil)
+
;;;***
\f
;;;### (autoloads (po-find-file-coding-system) "po" "textmodes/po.el"
-;;;;;; (19845 45374))
+;;;;;; (20244 35516))
;;; Generated autoloads from textmodes/po.el
(autoload 'po-find-file-coding-system "po" "\
;;;***
\f
-;;;### (autoloads (pong) "pong" "play/pong.el" (19845 45374))
+;;;### (autoloads (pong) "pong" "play/pong.el" (20244 35516))
;;; Generated autoloads from play/pong.el
(autoload 'pong "pong" "\
;;;***
\f
-;;;### (autoloads (pop3-movemail) "pop3" "gnus/pop3.el" (20048 56149))
+;;;### (autoloads (pop3-movemail) "pop3" "gnus/pop3.el" (20244 35516))
;;; Generated autoloads from gnus/pop3.el
(autoload 'pop3-movemail "pop3" "\
\f
;;;### (autoloads (pp-macroexpand-last-sexp pp-eval-last-sexp pp-macroexpand-expression
;;;;;; pp-eval-expression pp pp-buffer pp-to-string) "pp" "emacs-lisp/pp.el"
-;;;;;; (19845 45374))
+;;;;;; (20276 3849))
;;; Generated autoloads from emacs-lisp/pp.el
(autoload 'pp-to-string "pp" "\
;;;;;; pr-ps-buffer-print pr-ps-buffer-using-ghostscript pr-ps-buffer-preview
;;;;;; pr-ps-directory-ps-print pr-ps-directory-print pr-ps-directory-using-ghostscript
;;;;;; pr-ps-directory-preview pr-interface) "printing" "printing.el"
-;;;;;; (19999 41597))
+;;;;;; (20244 35516))
;;; Generated autoloads from printing.el
(autoload 'pr-interface "printing" "\
M-x pr-ps-fast-fire RET
The command prompts the user for a N-UP value and printing will
- immediatelly be done using the current active printer.
+ immediately be done using the current active printer.
C-u M-x pr-ps-fast-fire RET
C-u 0 M-x pr-ps-fast-fire RET
The command prompts the user for a N-UP value and also for a current
- PostScript printer, then printing will immediatelly be done using the new
+ PostScript printer, then printing will immediately be done using the new
current active printer.
C-u 1 M-x pr-ps-fast-fire RET
If it's nil, send the image to the printer.
If it's a list or an integer lesser or equal to zero, the command prompts
- the user for a current PostScript printer, then printing will immediatelly
+ the user for a current PostScript printer, then printing will immediately
be done using the new current active printer.
If it's an integer equal to 1, the command prompts the user for a file name
instead of sending it to the printer.
If it's a symbol which it's defined in `pr-ps-printer-alist', it's the new
- active printer and printing will immediatelly be done using the new active
+ active printer and printing will immediately be done using the new active
printer.
Otherwise, send the image to the printer.
If it's nil, the printing is sent to the current active text printer.
If it's a symbol which it's defined in `pr-txt-printer-alist', it's the new
- active printer and printing will immediatelly be done using the new active
+ active printer and printing will immediately be done using the new active
printer.
If it's non-nil, the command prompts the user for a new active text printer.
;;;***
\f
-;;;### (autoloads (proced) "proced" "proced.el" (20053 39261))
+;;;### (autoloads (proced) "proced" "proced.el" (20428 57510))
;;; Generated autoloads from proced.el
(autoload 'proced "proced" "\
;;;***
\f
;;;### (autoloads (run-prolog mercury-mode prolog-mode) "prolog"
-;;;;;; "progmodes/prolog.el" (19890 42850))
+;;;;;; "progmodes/prolog.el" (20412 11425))
;;; Generated autoloads from progmodes/prolog.el
(autoload 'prolog-mode "prolog" "\
;;;***
\f
-;;;### (autoloads (bdf-directory-list) "ps-bdf" "ps-bdf.el" (19845
-;;;;;; 45374))
+;;;### (autoloads (bdf-directory-list) "ps-bdf" "ps-bdf.el" (20244
+;;;;;; 35516))
;;; Generated autoloads from ps-bdf.el
(defvar bdf-directory-list (if (memq system-type '(ms-dos windows-nt)) (list (expand-file-name "fonts/bdf" installation-directory)) '("/usr/local/share/emacs/fonts/bdf")) "\
;;;***
\f
-;;;### (autoloads (ps-mode) "ps-mode" "progmodes/ps-mode.el" (19961
-;;;;;; 55377))
+;;;### (autoloads (ps-mode) "ps-mode" "progmodes/ps-mode.el" (20356
+;;;;;; 35090))
;;; Generated autoloads from progmodes/ps-mode.el
(autoload 'ps-mode "ps-mode" "\
;;;;;; ps-spool-region ps-spool-buffer-with-faces ps-spool-buffer
;;;;;; ps-print-region-with-faces ps-print-region ps-print-buffer-with-faces
;;;;;; ps-print-buffer ps-print-customize ps-print-color-p ps-paper-type
-;;;;;; ps-page-dimensions-database) "ps-print" "ps-print.el" (19931
-;;;;;; 11784))
+;;;;;; ps-page-dimensions-database) "ps-print" "ps-print.el" (20244
+;;;;;; 35516))
;;; Generated autoloads from ps-print.el
(defvar ps-page-dimensions-database (purecopy (list (list 'a4 (/ (* 72 21.0) 2.54) (/ (* 72 29.7) 2.54) "A4") (list 'a3 (/ (* 72 29.7) 2.54) (/ (* 72 42.0) 2.54) "A3") (list 'letter (* 72 8.5) (* 72 11.0) "Letter") (list 'legal (* 72 8.5) (* 72 14.0) "Legal") (list 'letter-small (* 72 7.68) (* 72 10.16) "LetterSmall") (list 'tabloid (* 72 11.0) (* 72 17.0) "Tabloid") (list 'ledger (* 72 17.0) (* 72 11.0) "Ledger") (list 'statement (* 72 5.5) (* 72 8.5) "Statement") (list 'executive (* 72 7.5) (* 72 10.0) "Executive") (list 'a4small (* 72 7.47) (* 72 10.85) "A4Small") (list 'b4 (* 72 10.125) (* 72 14.33) "B4") (list 'b5 (* 72 7.16) (* 72 10.125) "B5") '(addresslarge 236.0 99.0 "AddressLarge") '(addresssmall 236.0 68.0 "AddressSmall") '(cuthanging13 90.0 222.0 "CutHanging13") '(cuthanging15 90.0 114.0 "CutHanging15") '(diskette 181.0 136.0 "Diskette") '(eurofilefolder 139.0 112.0 "EuropeanFilefolder") '(eurofoldernarrow 526.0 107.0 "EuroFolderNarrow") '(eurofolderwide 526.0 136.0 "EuroFolderWide") '(euronamebadge 189.0 108.0 "EuroNameBadge") '(euronamebadgelarge 223.0 136.0 "EuroNameBadgeLarge") '(filefolder 230.0 37.0 "FileFolder") '(jewelry 76.0 136.0 "Jewelry") '(mediabadge 180.0 136.0 "MediaBadge") '(multipurpose 126.0 68.0 "MultiPurpose") '(retaillabel 90.0 104.0 "RetailLabel") '(shipping 271.0 136.0 "Shipping") '(slide35mm 26.0 104.0 "Slide35mm") '(spine8mm 187.0 26.0 "Spine8mm") '(topcoated 425.19685 136.0 "TopCoatedPaper") '(topcoatedpaper 396.0 136.0 "TopcoatedPaper150") '(vhsface 205.0 127.0 "VHSFace") '(vhsspine 400.0 50.0 "VHSSpine") '(zipdisk 156.0 136.0 "ZipDisk"))) "\
;;;***
\f
-;;;### (autoloads (jython-mode python-mode python-after-info-look
-;;;;;; run-python) "python" "progmodes/python.el" (19975 1875))
+;;;### (autoloads (python-mode) "python" "progmodes/python.el" (20448
+;;;;;; 45252))
;;; Generated autoloads from progmodes/python.el
-(add-to-list 'interpreter-mode-alist (cons (purecopy "jython") 'jython-mode))
-
-(add-to-list 'interpreter-mode-alist (cons (purecopy "python") 'python-mode))
-
(add-to-list 'auto-mode-alist (cons (purecopy "\\.py\\'") 'python-mode))
-(autoload 'run-python "python" "\
-Run an inferior Python process, input and output via buffer *Python*.
-CMD is the Python command to run. NOSHOW non-nil means don't
-show the buffer automatically.
-
-Interactively, a prefix arg means to prompt for the initial
-Python command line (default is `python-command').
-
-A new process is started if one isn't running attached to
-`python-buffer', or if called from Lisp with non-nil arg NEW.
-Otherwise, if a process is already running in `python-buffer',
-switch to that buffer.
-
-This command runs the hook `inferior-python-mode-hook' after
-running `comint-mode-hook'. Type \\[describe-mode] in the
-process buffer for a list of commands.
-
-By default, Emacs inhibits the loading of Python modules from the
-current working directory, for security reasons. To disable this
-behavior, change `python-remove-cwd-from-path' to nil.
-
-\(fn &optional CMD NOSHOW NEW)" t nil)
-
-(autoload 'python-after-info-look "python" "\
-Set up info-look for Python.
-Used with `eval-after-load'.
-
-\(fn)" nil nil)
+(add-to-list 'interpreter-mode-alist (cons (purecopy "python") 'python-mode))
(autoload 'python-mode "python" "\
Major mode for editing Python files.
-Turns on Font Lock mode unconditionally since it is currently required
-for correct parsing of the source.
-See also `jython-mode', which is actually invoked if the buffer appears to
-contain Jython code. See also `run-python' and associated Python mode
-commands for running Python under Emacs.
-
-The Emacs commands which work with `defun's, e.g. \\[beginning-of-defun], deal
-with nested `def' and `class' blocks. They take the innermost one as
-current without distinguishing method and class definitions. Used multiple
-times, they move over others at the same indentation level until they reach
-the end of definitions at that level, when they move up a level.
-\\<python-mode-map>
-Colon is electric: it outdents the line if appropriate, e.g. for
-an else statement. \\[python-backspace] at the beginning of an indented statement
-deletes a level of indentation to close the current block; otherwise it
-deletes a character backward. TAB indents the current line relative to
-the preceding code. Successive TABs, with no intervening command, cycle
-through the possibilities for indentation on the basis of enclosing blocks.
-
-\\[fill-paragraph] fills comments and multi-line strings appropriately, but has no
-effect outside them.
-
-Supports Eldoc mode (only for functions, using a Python process),
-Info-Look and Imenu. In Outline minor mode, `class' and `def'
-lines count as headers. Symbol completion is available in the
-same way as in the Python shell using the `rlcompleter' module
-and this is added to the Hippie Expand functions locally if
-Hippie Expand mode is turned on. Completion of symbols of the
-form x.y only works if the components are literal
-module/attribute names, not variables. An abbrev table is set up
-with skeleton expansions for compound statement templates.
\\{python-mode-map}
-
-\(fn)" t nil)
-
-(autoload 'jython-mode "python" "\
-Major mode for editing Jython files.
-Like `python-mode', but sets up parameters for Jython subprocesses.
-Runs `jython-mode-hook' after `python-mode-hook'.
+Entry to this mode calls the value of `python-mode-hook'
+if that value is non-nil.
\(fn)" t nil)
;;;***
\f
;;;### (autoloads (quoted-printable-decode-region) "qp" "gnus/qp.el"
-;;;;;; (19845 45374))
+;;;;;; (20244 35516))
;;; Generated autoloads from gnus/qp.el
(autoload 'quoted-printable-decode-region "qp" "\
;;;;;; quail-defrule quail-install-decode-map quail-install-map
;;;;;; quail-define-rules quail-show-keyboard-layout quail-set-keyboard-layout
;;;;;; quail-define-package quail-use-package quail-title) "quail"
-;;;;;; "international/quail.el" (19943 25429))
+;;;;;; "international/quail.el" (20331 16635))
;;; Generated autoloads from international/quail.el
(autoload 'quail-title "quail" "\
no-decode-map --- the value non-nil means that decoding map is not
generated for the following translations.
-\(fn &rest RULES)" nil (quote macro))
+\(fn &rest RULES)" nil t)
(autoload 'quail-install-map "quail" "\
Install the Quail map MAP in the current Quail package.
\f
;;;### (autoloads (quickurl-list quickurl-list-mode quickurl-edit-urls
;;;;;; quickurl-browse-url-ask quickurl-browse-url quickurl-add-url
-;;;;;; quickurl-ask quickurl) "quickurl" "net/quickurl.el" (20054
-;;;;;; 8529))
+;;;;;; quickurl-ask quickurl) "quickurl" "net/quickurl.el" (20356
+;;;;;; 35090))
;;; Generated autoloads from net/quickurl.el
(defconst quickurl-reread-hook-postfix "\n;; Local Variables:\n;; eval: (progn (require 'quickurl) (add-hook 'local-write-file-hooks (lambda () (quickurl-read) nil)))\n;; End:\n" "\
Insert a URL based on LOOKUP.
If not supplied LOOKUP is taken to be the word at point in the current
-buffer, this default action can be modifed via
+buffer, this default action can be modified via
`quickurl-grab-lookup-function'.
\(fn &optional LOOKUP)" t nil)
Browse the URL associated with LOOKUP.
If not supplied LOOKUP is taken to be the word at point in the
-current buffer, this default action can be modifed via
+current buffer, this default action can be modified via
`quickurl-grab-lookup-function'.
\(fn &optional LOOKUP)" t nil)
;;;***
\f
;;;### (autoloads (rcirc-track-minor-mode rcirc-connect rcirc) "rcirc"
-;;;;;; "net/rcirc.el" (20058 5591))
+;;;;;; "net/rcirc.el" (20434 28080))
;;; Generated autoloads from net/rcirc.el
(autoload 'rcirc "rcirc" "\
(autoload 'rcirc-track-minor-mode "rcirc" "\
Global minor mode for tracking activity in rcirc buffers.
+With a prefix argument ARG, enable the mode if ARG is positive,
+and disable it otherwise. If called from Lisp, enable the mode
+if ARG is omitted or nil.
\(fn &optional ARG)" t nil)
;;;***
\f
-;;;### (autoloads (remote-compile) "rcompile" "net/rcompile.el" (19845
-;;;;;; 45374))
+;;;### (autoloads (remote-compile) "rcompile" "net/rcompile.el" (20290
+;;;;;; 33419))
;;; Generated autoloads from net/rcompile.el
(autoload 'remote-compile "rcompile" "\
;;;***
\f
;;;### (autoloads (re-builder) "re-builder" "emacs-lisp/re-builder.el"
-;;;;;; (19975 1875))
+;;;;;; (20428 57510))
;;; Generated autoloads from emacs-lisp/re-builder.el
(defalias 'regexp-builder 're-builder)
;;;***
\f
-;;;### (autoloads (recentf-mode) "recentf" "recentf.el" (19886 45771))
+;;;### (autoloads (recentf-mode) "recentf" "recentf.el" (20356 35090))
;;; Generated autoloads from recentf.el
(defvar recentf-mode nil "\
(custom-autoload 'recentf-mode "recentf" nil)
(autoload 'recentf-mode "recentf" "\
-Toggle recentf mode.
-With prefix argument ARG, turn on if positive, otherwise off.
-Returns non-nil if the new state is enabled.
+Toggle \"Open Recent\" menu (Recentf mode).
+With a prefix argument ARG, enable Recentf mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+Recentf mode if ARG is omitted or nil.
-When recentf mode is enabled, it maintains a menu for visiting files
-that were operated on recently.
+When Recentf mode is enabled, a \"Open Recent\" submenu is
+displayed in the \"File\" menu, containing a list of files that
+were operated on recently.
\(fn &optional ARG)" t nil)
;;;;;; string-rectangle delete-whitespace-rectangle open-rectangle
;;;;;; insert-rectangle yank-rectangle kill-rectangle extract-rectangle
;;;;;; delete-extract-rectangle delete-rectangle) "rect" "rect.el"
-;;;;;; (19999 41597))
+;;;;;; (20244 35516))
;;; Generated autoloads from rect.el
(define-key ctl-x-r-map "c" 'clear-rectangle)
(define-key ctl-x-r-map "k" 'kill-rectangle)
;;;***
\f
-;;;### (autoloads (refill-mode) "refill" "textmodes/refill.el" (19845
-;;;;;; 45374))
+;;;### (autoloads (refill-mode) "refill" "textmodes/refill.el" (20244
+;;;;;; 35516))
;;; Generated autoloads from textmodes/refill.el
(autoload 'refill-mode "refill" "\
-Toggle Refill minor mode.
-With prefix arg, turn Refill mode on if arg is positive, otherwise turn it off.
+Toggle automatic refilling (Refill mode).
+With a prefix argument ARG, enable Refill mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+the mode if ARG is omitted or nil.
+
+Refill mode is a buffer-local minor mode. When enabled, the
+current paragraph is refilled as you edit. Self-inserting
+characters only cause refilling if they would cause
+auto-filling.
-When Refill mode is on, the current paragraph will be formatted when
-changes are made within it. Self-inserting characters only cause
-refilling if they would cause auto-filling.
+For true \"word wrap\" behavior, use `visual-line-mode' instead.
\(fn &optional ARG)" t nil)
;;;***
\f
;;;### (autoloads (reftex-reset-scanning-information reftex-mode
-;;;;;; turn-on-reftex) "reftex" "textmodes/reftex.el" (19845 45374))
+;;;;;; turn-on-reftex) "reftex" "textmodes/reftex.el" (20244 35516))
;;; Generated autoloads from textmodes/reftex.el
(autoload 'turn-on-reftex "reftex" "\
\(fn)" nil nil)
(autoload 'reftex-mode "reftex" "\
-Minor mode with distinct support for \\label, \\ref and \\cite in LaTeX.
+Toggle RefTeX mode.
+With a prefix argument ARG, enable RefTeX mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+the mode if ARG is omitted or nil.
+
+RefTeX mode is a buffer-local minor mode with distinct support
+for \\label, \\ref and \\cite in LaTeX.
\\<reftex-mode-map>A Table of Contents of the entire (multifile) document with browsing
capabilities is available with `\\[reftex-toc]'.
;;;***
\f
;;;### (autoloads (reftex-citation) "reftex-cite" "textmodes/reftex-cite.el"
-;;;;;; (19845 45374))
+;;;;;; (20244 35516))
;;; Generated autoloads from textmodes/reftex-cite.el
(autoload 'reftex-citation "reftex-cite" "\
;;;***
\f
;;;### (autoloads (reftex-isearch-minor-mode) "reftex-global" "textmodes/reftex-global.el"
-;;;;;; (19845 45374))
+;;;;;; (20428 57510))
;;; Generated autoloads from textmodes/reftex-global.el
(autoload 'reftex-isearch-minor-mode "reftex-global" "\
;;;***
\f
;;;### (autoloads (reftex-index-phrases-mode) "reftex-index" "textmodes/reftex-index.el"
-;;;;;; (19845 45374))
+;;;;;; (20412 11425))
;;; Generated autoloads from textmodes/reftex-index.el
(autoload 'reftex-index-phrases-mode "reftex-index" "\
;;;***
\f
;;;### (autoloads (reftex-all-document-files) "reftex-parse" "textmodes/reftex-parse.el"
-;;;;;; (19980 19797))
+;;;;;; (20244 35516))
;;; Generated autoloads from textmodes/reftex-parse.el
(autoload 'reftex-all-document-files "reftex-parse" "\
;;;***
\f
-;;;### (autoloads nil "reftex-vars" "textmodes/reftex-vars.el" (19845
-;;;;;; 45374))
+;;;### (autoloads nil "reftex-vars" "textmodes/reftex-vars.el" (20356
+;;;;;; 35090))
;;; Generated autoloads from textmodes/reftex-vars.el
(put 'reftex-vref-is-default 'safe-local-variable (lambda (x) (or (stringp x) (symbolp x))))
(put 'reftex-fref-is-default 'safe-local-variable (lambda (x) (or (stringp x) (symbolp x))))
;;;***
\f
;;;### (autoloads (regexp-opt-depth regexp-opt) "regexp-opt" "emacs-lisp/regexp-opt.el"
-;;;;;; (19845 45374))
+;;;;;; (20373 41604))
;;; Generated autoloads from emacs-lisp/regexp-opt.el
(autoload 'regexp-opt "regexp-opt" "\
\f
;;;### (autoloads (remember-diary-extract-entries remember-clipboard
;;;;;; remember-other-frame remember) "remember" "textmodes/remember.el"
-;;;;;; (19845 45374))
+;;;;;; (20244 35516))
;;; Generated autoloads from textmodes/remember.el
(autoload 'remember "remember" "\
;;;***
\f
-;;;### (autoloads (repeat) "repeat" "repeat.el" (19951 19539))
+;;;### (autoloads (repeat) "repeat" "repeat.el" (20412 11425))
;;; Generated autoloads from repeat.el
(autoload 'repeat "repeat" "\
;;;***
\f
;;;### (autoloads (reporter-submit-bug-report) "reporter" "mail/reporter.el"
-;;;;;; (19845 45374))
+;;;;;; (20244 35516))
;;; Generated autoloads from mail/reporter.el
(autoload 'reporter-submit-bug-report "reporter" "\
;;;***
\f
;;;### (autoloads (reposition-window) "reposition" "reposition.el"
-;;;;;; (19845 45374))
+;;;;;; (20244 35516))
;;; Generated autoloads from reposition.el
(autoload 'reposition-window "reposition" "\
;;;***
\f
;;;### (autoloads (global-reveal-mode reveal-mode) "reveal" "reveal.el"
-;;;;;; (19863 8742))
+;;;;;; (20244 35516))
;;; Generated autoloads from reveal.el
(autoload 'reveal-mode "reveal" "\
-Toggle Reveal mode on or off.
-Reveal mode renders invisible text around point visible again.
+Toggle uncloaking of invisible text near point (Reveal mode).
+With a prefix argument ARG, enable Reveal mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+Reveal mode if ARG is omitted or nil.
-Interactively, with no prefix argument, toggle the mode.
-With universal prefix ARG (or if ARG is nil) turn mode on.
-With zero or negative ARG turn mode off.
+Reveal mode is a buffer-local minor mode. When enabled, it
+reveals invisible text around point.
\(fn &optional ARG)" t nil)
(custom-autoload 'global-reveal-mode "reveal" nil)
(autoload 'global-reveal-mode "reveal" "\
-Toggle Reveal mode in all buffers on or off.
+Toggle Reveal mode in all buffers (Global Reveal mode).
Reveal mode renders invisible text around point visible again.
-Interactively, with no prefix argument, toggle the mode.
-With universal prefix ARG (or if ARG is nil) turn mode on.
-With zero or negative ARG turn mode off.
+With a prefix argument ARG, enable Global Reveal mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+the mode if ARG is omitted or nil.
\(fn &optional ARG)" t nil)
;;;***
\f
;;;### (autoloads (make-ring ring-p) "ring" "emacs-lisp/ring.el"
-;;;;;; (19845 45374))
+;;;;;; (20331 12564))
;;; Generated autoloads from emacs-lisp/ring.el
(autoload 'ring-p "ring" "\
;;;***
\f
-;;;### (autoloads (rlogin) "rlogin" "net/rlogin.el" (19870 57559))
+;;;### (autoloads (rlogin) "rlogin" "net/rlogin.el" (20412 11425))
;;; Generated autoloads from net/rlogin.el
- (add-hook 'same-window-regexps (purecopy "^\\*rlogin-.*\\*\\(\\|<[0-9]+>\\)"))
(autoload 'rlogin "rlogin" "\
Open a network login connection via `rlogin' with args INPUT-ARGS.
;;;;;; rmail rmail-show-message-hook rmail-secondary-file-regexp
;;;;;; rmail-secondary-file-directory rmail-primary-inbox-list rmail-highlighted-headers
;;;;;; rmail-retry-ignored-headers rmail-displayed-headers rmail-ignored-headers
-;;;;;; rmail-user-mail-address-regexp rmail-movemail-variant-p)
-;;;;;; "rmail" "mail/rmail.el" (20063 23511))
+;;;;;; rmail-user-mail-address-regexp rmail-movemail-variant-p rmail-spool-directory
+;;;;;; rmail-file-name) "rmail" "mail/rmail.el" (20438 17064))
;;; Generated autoloads from mail/rmail.el
+(defvar rmail-file-name (purecopy "~/RMAIL") "\
+Name of user's primary mail file.")
+
+(custom-autoload 'rmail-file-name "rmail" t)
+
+(put 'rmail-spool-directory 'standard-value '((cond ((file-exists-p "/var/mail") "/var/mail/") ((file-exists-p "/var/spool/mail") "/var/spool/mail/") ((memq system-type '(hpux usg-unix-v irix)) "/usr/mail/") (t "/usr/spool/mail/"))))
+
+(defvar rmail-spool-directory (purecopy (cond ((file-exists-p "/var/mail") "/var/mail/") ((file-exists-p "/var/spool/mail") "/var/spool/mail/") ((memq system-type '(hpux usg-unix-v irix)) "/usr/mail/") (t "/usr/spool/mail/"))) "\
+Name of directory used by system mailer for delivering new mail.
+Its name should end with a slash.")
+
+(custom-autoload 'rmail-spool-directory "rmail" t)
+(custom-initialize-delay 'rmail-spool-directory nil)
+
(autoload 'rmail-movemail-variant-p "rmail" "\
Return t if the current movemail variant is any of VARIANTS.
Currently known variants are 'emacs and 'mailutils.
(custom-autoload 'rmail-user-mail-address-regexp "rmail" t)
-(defvaralias 'rmail-dont-reply-to-names 'mail-dont-reply-to-names)
+(define-obsolete-variable-alias 'rmail-dont-reply-to-names 'mail-dont-reply-to-names "24.1")
(defvar rmail-default-dont-reply-to-names nil "\
Regexp specifying part of the default value of `mail-dont-reply-to-names'.
(defvar rmail-insert-mime-forwarded-message-function nil "\
Function to insert a message in MIME format so it can be forwarded.
-This function is called if `rmail-enable-mime' or
-`rmail-enable-mime-composing' is non-nil.
+This function is called if `rmail-enable-mime' and
+`rmail-enable-mime-composing' are non-nil.
It is called with one argument FORWARD-BUFFER, which is a
buffer containing the message to forward. The current buffer
is the outgoing mail buffer.")
;;;***
\f
;;;### (autoloads (rmail-output-body-to-file rmail-output-as-seen
-;;;;;; rmail-output) "rmailout" "mail/rmailout.el" (19845 45374))
+;;;;;; rmail-output) "rmailout" "mail/rmailout.el" (20244 35516))
;;; Generated autoloads from mail/rmailout.el
(put 'rmail-output-file-alist 'risky-local-variable t)
;;;***
\f
;;;### (autoloads (rng-c-load-schema) "rng-cmpct" "nxml/rng-cmpct.el"
-;;;;;; (19845 45374))
+;;;;;; (20244 35516))
;;; Generated autoloads from nxml/rng-cmpct.el
(autoload 'rng-c-load-schema "rng-cmpct" "\
;;;***
\f
;;;### (autoloads (rng-nxml-mode-init) "rng-nxml" "nxml/rng-nxml.el"
-;;;;;; (19845 45374))
+;;;;;; (20356 35090))
;;; Generated autoloads from nxml/rng-nxml.el
(autoload 'rng-nxml-mode-init "rng-nxml" "\
;;;***
\f
;;;### (autoloads (rng-validate-mode) "rng-valid" "nxml/rng-valid.el"
-;;;;;; (19845 45374))
+;;;;;; (20290 33419))
;;; Generated autoloads from nxml/rng-valid.el
(autoload 'rng-validate-mode "rng-valid" "\
rechecking will be paused whenever there is input pending.
By default, uses a vacuous schema that allows any well-formed XML
-document. A schema can be specified explictly using
+document. A schema can be specified explicitly using
\\[rng-set-schema-file-and-validate], or implicitly based on the buffer's
file name or on the root element name. In each case the schema must
be a RELAX NG schema using the compact schema (such schemas
;;;***
\f
-;;;### (autoloads (rng-xsd-compile) "rng-xsd" "nxml/rng-xsd.el" (19930
-;;;;;; 13389))
+;;;### (autoloads (rng-xsd-compile) "rng-xsd" "nxml/rng-xsd.el" (20244
+;;;;;; 35516))
;;; Generated autoloads from nxml/rng-xsd.el
(put 'http://www\.w3\.org/2001/XMLSchema-datatypes 'rng-dt-compile 'rng-xsd-compile)
;;;***
\f
;;;### (autoloads (robin-use-package robin-modify-package robin-define-package)
-;;;;;; "robin" "international/robin.el" (19845 45374))
+;;;;;; "robin" "international/robin.el" (20428 57510))
;;; Generated autoloads from international/robin.el
(autoload 'robin-define-package "robin" "\
If there already exists a robin package whose name is NAME, the new
one replaces the old one.
-\(fn NAME DOCSTRING &rest RULES)" nil (quote macro))
+\(fn NAME DOCSTRING &rest RULES)" nil t)
(autoload 'robin-modify-package "robin" "\
Change a rule in an already defined robin package.
;;;***
\f
;;;### (autoloads (toggle-rot13-mode rot13-other-window rot13-region
-;;;;;; rot13-string rot13) "rot13" "rot13.el" (19845 45374))
+;;;;;; rot13-string rot13) "rot13" "rot13.el" (20244 35516))
;;; Generated autoloads from rot13.el
(autoload 'rot13 "rot13" "\
;;;***
\f
;;;### (autoloads (rst-minor-mode rst-mode) "rst" "textmodes/rst.el"
-;;;;;; (19986 58615))
+;;;;;; (20451 21022))
;;; Generated autoloads from textmodes/rst.el
(add-to-list 'auto-mode-alist (purecopy '("\\.re?st\\'" . rst-mode)))
(autoload 'rst-mode "rst" "\
Major mode for editing reStructuredText documents.
\\<rst-mode-map>
-There are a number of convenient keybindings provided by
-Rst mode. The main one is \\[rst-adjust], it updates or rotates
-the section title around point or promotes/demotes the
-decorations within the region (see full details below).
-Use negative prefix arg to rotate in the other direction.
Turning on `rst-mode' calls the normal hooks `text-mode-hook'
and `rst-mode-hook'. This mode also supports font-lock
-highlighting. You may customize `rst-mode-lazy' to toggle
-font-locking of blocks.
+highlighting.
\\{rst-mode-map}
\(fn)" t nil)
(autoload 'rst-minor-mode "rst" "\
-ReST Minor Mode.
Toggle ReST minor mode.
-With no argument, this command toggles the mode.
-Non-null prefix argument turns on the mode.
-Null prefix argument turns off the mode.
+With a prefix argument ARG, enable ReST minor mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+the mode if ARG is omitted or nil.
When ReST minor mode is enabled, the ReST mode keybindings
are installed on top of the major mode bindings. Use this
;;;***
\f
;;;### (autoloads (ruby-mode) "ruby-mode" "progmodes/ruby-mode.el"
-;;;;;; (19845 45374))
+;;;;;; (20374 56770))
;;; Generated autoloads from progmodes/ruby-mode.el
(autoload 'ruby-mode "ruby-mode" "\
;;;***
\f
-;;;### (autoloads (ruler-mode) "ruler-mode" "ruler-mode.el" (19845
-;;;;;; 45374))
+;;;### (autoloads (ruler-mode) "ruler-mode" "ruler-mode.el" (20244
+;;;;;; 35516))
;;; Generated autoloads from ruler-mode.el
(defvar ruler-mode nil "\
Use the command `ruler-mode' to change this variable.")
(autoload 'ruler-mode "ruler-mode" "\
-Toggle Ruler mode.
-In Ruler mode, Emacs displays a ruler in the header line.
+Toggle display of ruler in header line (Ruler mode).
+With a prefix argument ARG, enable Ruler mode if ARG is positive,
+and disable it otherwise. If called from Lisp, enable the mode
+if ARG is omitted or nil.
\(fn &optional ARG)" t nil)
;;;***
\f
-;;;### (autoloads (rx rx-to-string) "rx" "emacs-lisp/rx.el" (19965
-;;;;;; 52428))
+;;;### (autoloads (rx rx-to-string) "rx" "emacs-lisp/rx.el" (20451
+;;;;;; 21074))
;;; Generated autoloads from emacs-lisp/rx.el
(autoload 'rx-to-string "rx" "\
`(regexp REGEXP)'
include REGEXP in string notation in the result.
-\(fn &rest REGEXPS)" nil (quote macro))
+\(fn &rest REGEXPS)" nil t)
;;;***
\f
-;;;### (autoloads (savehist-mode) "savehist" "savehist.el" (19886
-;;;;;; 45771))
+;;;### (autoloads (savehist-mode) "savehist" "savehist.el" (20452
+;;;;;; 43636))
;;; Generated autoloads from savehist.el
(defvar savehist-mode nil "\
(custom-autoload 'savehist-mode "savehist" nil)
(autoload 'savehist-mode "savehist" "\
-Toggle savehist-mode.
-Positive ARG turns on `savehist-mode'. When on, savehist-mode causes
-minibuffer history to be saved periodically and when exiting Emacs.
-When turned on for the first time in an Emacs session, it causes the
-previous minibuffer history to be loaded from `savehist-file'.
+Toggle saving of minibuffer history (Savehist mode).
+With a prefix argument ARG, enable Savehist mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+the mode if ARG is omitted or nil.
+
+When Savehist mode is enabled, minibuffer history is saved
+periodically and when exiting Emacs. When Savehist mode is
+enabled for the first time in an Emacs session, it loads the
+previous minibuffer history from `savehist-file'.
This mode should normally be turned on from your Emacs init file.
-Calling it at any other time replaces your current minibuffer histories,
-which is probably undesirable.
+Calling it at any other time replaces your current minibuffer
+histories, which is probably undesirable.
\(fn &optional ARG)" t nil)
;;;***
\f
;;;### (autoloads (dsssl-mode scheme-mode) "scheme" "progmodes/scheme.el"
-;;;;;; (20050 11479))
+;;;;;; (20428 57510))
;;; Generated autoloads from progmodes/scheme.el
(autoload 'scheme-mode "scheme" "\
In addition, if an inferior Scheme process is running, some additional
commands will be defined, for evaluating expressions and controlling
the interpreter, and the state of the process will be displayed in the
-modeline of all Scheme buffers. The names of commands that interact
+mode line of all Scheme buffers. The names of commands that interact
with the Scheme process start with \"xscheme-\" if you use the MIT
Scheme-specific `xscheme' package; for more information see the
documentation for `xscheme-interaction-mode'. Use \\[run-scheme] to
;;;***
\f
;;;### (autoloads (gnus-score-mode) "score-mode" "gnus/score-mode.el"
-;;;;;; (19845 45374))
+;;;;;; (20244 35516))
;;; Generated autoloads from gnus/score-mode.el
(autoload 'gnus-score-mode "score-mode" "\
;;;***
\f
;;;### (autoloads (scroll-all-mode) "scroll-all" "scroll-all.el"
-;;;;;; (19845 45374))
+;;;;;; (20373 41604))
;;; Generated autoloads from scroll-all.el
(defvar scroll-all-mode nil "\
(custom-autoload 'scroll-all-mode "scroll-all" nil)
(autoload 'scroll-all-mode "scroll-all" "\
-Toggle Scroll-All minor mode.
-With ARG, turn Scroll-All minor mode on if ARG is positive, off otherwise.
-When Scroll-All mode is on, scrolling commands entered in one window
-apply to all visible windows in the same frame.
+Toggle shared scrolling in same-frame windows (Scroll-All mode).
+With a prefix argument ARG, enable Scroll-All mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+the mode if ARG is omitted or nil.
+
+When Scroll-All mode is enabled, scrolling commands invoked in
+one window apply to all visible windows in the same frame.
\(fn &optional ARG)" t nil)
;;;***
\f
;;;### (autoloads (scroll-lock-mode) "scroll-lock" "scroll-lock.el"
-;;;;;; (19845 45374))
+;;;;;; (20276 3849))
;;; Generated autoloads from scroll-lock.el
(autoload 'scroll-lock-mode "scroll-lock" "\
Buffer-local minor mode for pager-like scrolling.
-Keys which normally move point by line or paragraph will scroll
-the buffer by the respective amount of lines instead and point
-will be kept vertically fixed relative to window boundaries
-during scrolling.
+With a prefix argument ARG, enable the mode if ARG is positive,
+and disable it otherwise. If called from Lisp, enable the mode
+if ARG is omitted or nil. When enabled, keys that normally move
+point by line or paragraph will scroll the buffer by the
+respective amount of lines instead and point will be kept
+vertically fixed relative to window boundaries during scrolling.
\(fn &optional ARG)" t nil)
;;;***
\f
-;;;### (autoloads nil "secrets" "net/secrets.el" (19845 45374))
+;;;### (autoloads nil "secrets" "net/secrets.el" (20318 5885))
;;; Generated autoloads from net/secrets.el
(when (featurep 'dbusbind)
(autoload 'secrets-show-secrets "secrets" nil t))
;;;***
\f
;;;### (autoloads (semantic-mode semantic-default-submodes) "semantic"
-;;;;;; "cedet/semantic.el" (19981 40664))
+;;;;;; "cedet/semantic.el" (20356 35090))
;;; Generated autoloads from cedet/semantic.el
(defvar semantic-default-submodes '(global-semantic-idle-scheduler-mode global-semanticdb-minor-mode) "\
(custom-autoload 'semantic-mode "semantic" nil)
(autoload 'semantic-mode "semantic" "\
-Toggle Semantic mode.
-With ARG, turn Semantic mode on if ARG is positive, off otherwise.
+Toggle parser features (Semantic mode).
+With a prefix argument ARG, enable Semantic mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+Semantic mode if ARG is omitted or nil.
In Semantic mode, Emacs parses the buffers you visit for their
semantic content. This information is used by a variety of
;;;***
\f
;;;### (autoloads (mail-other-frame mail-other-window mail mail-mailing-lists
-;;;;;; mail-mode sendmail-user-agent-compose mail-default-headers
-;;;;;; mail-default-directory mail-signature-file mail-signature
-;;;;;; mail-citation-prefix-regexp mail-citation-hook mail-indentation-spaces
-;;;;;; mail-yank-prefix mail-setup-hook mail-personal-alias-file
-;;;;;; mail-default-reply-to mail-archive-file-name mail-header-separator
-;;;;;; sendmail-query-once send-mail-function mail-interactive mail-self-blind
-;;;;;; mail-specify-envelope-from mail-from-style) "sendmail" "mail/sendmail.el"
-;;;;;; (20025 8284))
+;;;;;; mail-mode sendmail-user-agent-compose sendmail-query-once
+;;;;;; mail-default-headers mail-default-directory mail-signature-file
+;;;;;; mail-signature mail-citation-prefix-regexp mail-citation-hook
+;;;;;; mail-indentation-spaces mail-yank-prefix mail-setup-hook
+;;;;;; mail-personal-alias-file mail-default-reply-to mail-archive-file-name
+;;;;;; mail-header-separator send-mail-function mail-interactive
+;;;;;; mail-self-blind mail-specify-envelope-from mail-from-style)
+;;;;;; "sendmail" "mail/sendmail.el" (20419 46656))
;;; Generated autoloads from mail/sendmail.el
(defvar mail-from-style 'default "\
(custom-autoload 'mail-interactive "sendmail" t)
-(defvar send-mail-function 'sendmail-query-once "\
+(defvar send-mail-function (if (and (boundp 'smtpmail-smtp-server) smtpmail-smtp-server) 'smtpmail-send-it 'sendmail-query-once) "\
Function to call to send the current buffer as mail.
The headers should be delimited by a line which is
not a valid RFC822 header or continuation line,
(custom-autoload 'send-mail-function "sendmail" t)
-(autoload 'sendmail-query-once "sendmail" "\
-Send an email via `sendmail-query-once-function'.
-If `sendmail-query-once-function' is `query', ask the user what
-function to use, and then save that choice.
-
-\(fn)" nil nil)
-
(defvar mail-header-separator (purecopy "--text follows this line--") "\
Line used to separate headers from text in messages being composed.")
(custom-autoload 'mail-default-headers "sendmail" t)
+(autoload 'sendmail-query-once "sendmail" "\
+Query for `send-mail-function' and send mail with it.
+This also saves the value of `send-mail-function' via Customize.
+
+\(fn)" nil nil)
+
(define-mail-user-agent 'sendmail-user-agent 'sendmail-user-agent-compose 'mail-send-and-exit)
(autoload 'sendmail-user-agent-compose "sendmail" "\
\\[mail-signature] mail-signature (insert `mail-signature-file' file).
\\[mail-yank-original] mail-yank-original (insert current message, in Rmail).
\\[mail-fill-yanked-message] mail-fill-yanked-message (fill what was yanked).
+\\[mail-insert-file] insert a text file into the message.
+\\[mail-add-attachment] attach to the message a file as binary attachment.
Turning on Mail mode runs the normal hooks `text-mode-hook' and
`mail-mode-hook' (in that order).
(custom-autoload 'mail-mailing-lists "sendmail" t)
(defvar sendmail-coding-system nil "\
-*Coding system for encoding the outgoing mail.
+Coding system for encoding the outgoing mail.
This has higher priority than the default `buffer-file-coding-system'
and `default-sendmail-coding-system',
but lower priority than the local value of `buffer-file-coding-system'.
instead use `sendmail-coding-system' to get a constant encoding
of outgoing mails regardless of the current language environment.
See also the function `select-message-coding-system'.")
- (add-hook 'same-window-buffer-names (purecopy "*mail*"))
- (add-hook 'same-window-buffer-names (purecopy "*unsent mail*"))
(autoload 'mail "sendmail" "\
Edit a message to be sent. Prefix arg means resume editing (don't erase).
;;;***
\f
;;;### (autoloads (server-save-buffers-kill-terminal server-mode
-;;;;;; server-force-delete server-start) "server" "server.el" (20059
-;;;;;; 26455))
+;;;;;; server-force-delete server-start) "server" "server.el" (20373
+;;;;;; 41604))
;;; Generated autoloads from server.el
(put 'server-host 'risky-local-variable t)
(autoload 'server-start "server" "\
Allow this Emacs process to be a server for client processes.
-This starts a server communications subprocess through which
-client \"editors\" can send your editing commands to this Emacs
-job. To use the server, set up the program `emacsclient' in the
-Emacs distribution as your standard \"editor\".
+This starts a server communications subprocess through which client
+\"editors\" can send your editing commands to this Emacs job.
+To use the server, set up the program `emacsclient' in the Emacs
+distribution as your standard \"editor\".
Optional argument LEAVE-DEAD (interactively, a prefix arg) means just
kill any existing server communications subprocess.
(autoload 'server-mode "server" "\
Toggle Server mode.
-With ARG, turn Server mode on if ARG is positive, off otherwise.
+With a prefix argument ARG, enable Server mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+Server mode if ARG is omitted or nil.
+
Server mode runs a process that accepts commands from the
-`emacsclient' program. See `server-start' and Info node `Emacs server'.
+`emacsclient' program. See Info node `Emacs server' and
+`server-start' for details.
\(fn &optional ARG)" t nil)
;;;***
\f
-;;;### (autoloads (ses-mode) "ses" "ses.el" (19980 19797))
+;;;### (autoloads (ses-mode) "ses" "ses.el" (20428 57510))
;;; Generated autoloads from ses.el
(autoload 'ses-mode "ses" "\
;;;***
\f
;;;### (autoloads (html-mode sgml-mode) "sgml-mode" "textmodes/sgml-mode.el"
-;;;;;; (19845 45374))
+;;;;;; (20428 57510))
;;; Generated autoloads from textmodes/sgml-mode.el
(autoload 'sgml-mode "sgml-mode" "\
;;;***
\f
;;;### (autoloads (sh-mode) "sh-script" "progmodes/sh-script.el"
-;;;;;; (20051 32345))
+;;;;;; (20412 11425))
;;; Generated autoloads from progmodes/sh-script.el
(put 'sh-shell 'safe-local-variable 'symbolp)
\\[sh-set-shell] Set this buffer's shell, and maybe its magic number.
\\[sh-execute-region] Have optional header and region be executed in a subshell.
-\\[sh-maybe-here-document] Without prefix, following an unquoted < inserts here document.
-{, (, [, ', \", `
- Unless quoted with \\, insert the pairs {}, (), [], or '', \"\", ``.
+`sh-electric-here-document-mode' controls whether insertion of two
+unquoted < insert a here document.
If you generally program a shell different from your login shell you can
set `sh-shell-file' accordingly. If your shell's file name doesn't correctly
;;;***
\f
;;;### (autoloads (list-load-path-shadows) "shadow" "emacs-lisp/shadow.el"
-;;;;;; (19845 45374))
+;;;;;; (20244 35516))
;;; Generated autoloads from emacs-lisp/shadow.el
(autoload 'list-load-path-shadows "shadow" "\
;;;***
\f
;;;### (autoloads (shadow-initialize shadow-define-regexp-group shadow-define-literal-group
-;;;;;; shadow-define-cluster) "shadowfile" "shadowfile.el" (19886
-;;;;;; 45771))
+;;;;;; shadow-define-cluster) "shadowfile" "shadowfile.el" (20244
+;;;;;; 35516))
;;; Generated autoloads from shadowfile.el
(autoload 'shadow-define-cluster "shadowfile" "\
;;;***
\f
;;;### (autoloads (shell shell-dumb-shell-regexp) "shell" "shell.el"
-;;;;;; (20058 5591))
+;;;;;; (20412 11425))
;;; Generated autoloads from shell.el
(defvar shell-dumb-shell-regexp (purecopy "cmd\\(proxy\\)?\\.exe") "\
\(Type \\[describe-mode] in the shell buffer for a list of commands.)
\(fn &optional BUFFER)" t nil)
- (add-hook 'same-window-buffer-names (purecopy "*shell*"))
;;;***
\f
-;;;### (autoloads (shr-insert-document) "shr" "gnus/shr.el" (20007
-;;;;;; 64734))
+;;;### (autoloads (shr-insert-document) "shr" "gnus/shr.el" (20446
+;;;;;; 34252))
;;; Generated autoloads from gnus/shr.el
(autoload 'shr-insert-document "shr" "\
-
+Render the parsed document DOM into the current buffer.
+DOM should be a parse tree as generated by
+`libxml-parse-html-region' or similar.
\(fn DOM)" nil nil)
;;;***
\f
;;;### (autoloads (sieve-upload-and-bury sieve-upload sieve-manage)
-;;;;;; "sieve" "gnus/sieve.el" (19845 45374))
+;;;;;; "sieve" "gnus/sieve.el" (20244 35516))
;;; Generated autoloads from gnus/sieve.el
(autoload 'sieve-manage "sieve" "\
;;;***
\f
;;;### (autoloads (sieve-mode) "sieve-mode" "gnus/sieve-mode.el"
-;;;;;; (19845 45374))
+;;;;;; (20244 35516))
;;; Generated autoloads from gnus/sieve-mode.el
(autoload 'sieve-mode "sieve-mode" "\
;;;***
\f
-;;;### (autoloads (simula-mode) "simula" "progmodes/simula.el" (19890
-;;;;;; 42850))
+;;;### (autoloads (simula-mode) "simula" "progmodes/simula.el" (20356
+;;;;;; 35090))
;;; Generated autoloads from progmodes/simula.el
(autoload 'simula-mode "simula" "\
;;;***
\f
;;;### (autoloads (skeleton-pair-insert-maybe skeleton-insert skeleton-proxy-new
-;;;;;; define-skeleton) "skeleton" "skeleton.el" (19845 45374))
+;;;;;; define-skeleton) "skeleton" "skeleton.el" (20412 11425))
;;; Generated autoloads from skeleton.el
(defvar skeleton-filter-function 'identity "\
DOCUMENTATION is that of the command.
SKELETON is as defined under `skeleton-insert'.
-\(fn COMMAND DOCUMENTATION &rest SKELETON)" nil (quote macro))
+\(fn COMMAND DOCUMENTATION &rest SKELETON)" nil t)
+
+(put 'define-skeleton 'doc-string-elt '2)
(autoload 'skeleton-proxy-new "skeleton" "\
Insert SKELETON.
;;;***
\f
;;;### (autoloads (smerge-start-session smerge-mode smerge-ediff)
-;;;;;; "smerge-mode" "vc/smerge-mode.el" (19946 1612))
+;;;;;; "smerge-mode" "vc/smerge-mode.el" (20415 57974))
;;; Generated autoloads from vc/smerge-mode.el
(autoload 'smerge-ediff "smerge-mode" "\
(autoload 'smerge-mode "smerge-mode" "\
Minor mode to simplify editing output from the diff3 program.
+With a prefix argument ARG, enable the mode if ARG is positive,
+and disable it otherwise. If called from Lisp, enable the mode
+if ARG is omitted or nil.
\\{smerge-mode-map}
\(fn &optional ARG)" t nil)
;;;***
\f
;;;### (autoloads (smiley-buffer smiley-region) "smiley" "gnus/smiley.el"
-;;;;;; (19939 28373))
+;;;;;; (20244 35516))
;;; Generated autoloads from gnus/smiley.el
(autoload 'smiley-region "smiley" "\
;;;***
\f
;;;### (autoloads (smtpmail-send-queued-mail smtpmail-send-it) "smtpmail"
-;;;;;; "mail/smtpmail.el" (20053 39293))
+;;;;;; "mail/smtpmail.el" (20412 11425))
;;; Generated autoloads from mail/smtpmail.el
(autoload 'smtpmail-send-it "smtpmail" "\
;;;***
\f
-;;;### (autoloads (snake) "snake" "play/snake.el" (19845 45374))
+;;;### (autoloads (snake) "snake" "play/snake.el" (20244 35516))
;;; Generated autoloads from play/snake.el
(autoload 'snake "snake" "\
;;;***
\f
;;;### (autoloads (snmpv2-mode snmp-mode) "snmp-mode" "net/snmp-mode.el"
-;;;;;; (19845 45374))
+;;;;;; (20356 35090))
;;; Generated autoloads from net/snmp-mode.el
(autoload 'snmp-mode "snmp-mode" "\
;;;***
\f
-;;;### (autoloads (sunrise-sunset) "solar" "calendar/solar.el" (19886
-;;;;;; 45771))
+;;;### (autoloads (sunrise-sunset) "solar" "calendar/solar.el" (20244
+;;;;;; 35516))
;;; Generated autoloads from calendar/solar.el
(autoload 'sunrise-sunset "solar" "\
;;;***
\f
-;;;### (autoloads (solitaire) "solitaire" "play/solitaire.el" (19889
-;;;;;; 21967))
+;;;### (autoloads (solitaire) "solitaire" "play/solitaire.el" (20428
+;;;;;; 57510))
;;; Generated autoloads from play/solitaire.el
(autoload 'solitaire "solitaire" "\
o o o
-Pick your favourite shortcuts:
+Pick your favorite shortcuts:
\\{solitaire-mode-map}
\f
;;;### (autoloads (reverse-region sort-columns sort-regexp-fields
;;;;;; sort-fields sort-numeric-fields sort-pages sort-paragraphs
-;;;;;; sort-lines sort-subr) "sort" "sort.el" (19845 45374))
+;;;;;; sort-lines sort-subr) "sort" "sort.el" (20331 12564))
;;; Generated autoloads from sort.el
(put 'sort-fold-case 'safe-local-variable 'booleanp)
;;;***
\f
-;;;### (autoloads (spam-initialize) "spam" "gnus/spam.el" (20022
-;;;;;; 32083))
+;;;### (autoloads (spam-initialize) "spam" "gnus/spam.el" (20244
+;;;;;; 35516))
;;; Generated autoloads from gnus/spam.el
(autoload 'spam-initialize "spam" "\
\f
;;;### (autoloads (spam-report-deagentize spam-report-agentize spam-report-url-to-file
;;;;;; spam-report-url-ping-mm-url spam-report-process-queue) "spam-report"
-;;;;;; "gnus/spam-report.el" (19845 45374))
+;;;;;; "gnus/spam-report.el" (20244 35516))
;;; Generated autoloads from gnus/spam-report.el
(autoload 'spam-report-process-queue "spam-report" "\
;;;***
\f
;;;### (autoloads (speedbar-get-focus speedbar-frame-mode) "speedbar"
-;;;;;; "speedbar.el" (19886 45771))
+;;;;;; "speedbar.el" (20434 28080))
;;; Generated autoloads from speedbar.el
(defalias 'speedbar 'speedbar-frame-mode)
;;;***
\f
-;;;### (autoloads (snarf-spooks spook) "spook" "play/spook.el" (19845
-;;;;;; 45374))
+;;;### (autoloads (snarf-spooks spook) "spook" "play/spook.el" (20244
+;;;;;; 35516))
;;; Generated autoloads from play/spook.el
(autoload 'spook "spook" "\
;;;;;; sql-ms sql-ingres sql-solid sql-mysql sql-sqlite sql-informix
;;;;;; sql-sybase sql-oracle sql-product-interactive sql-connect
;;;;;; sql-mode sql-help sql-add-product-keywords) "sql" "progmodes/sql.el"
-;;;;;; (19988 13913))
+;;;;;; (20318 5885))
;;; Generated autoloads from progmodes/sql.el
(autoload 'sql-add-product-keywords "sql" "\
;;;***
\f
;;;### (autoloads (srecode-template-mode) "srecode/srt-mode" "cedet/srecode/srt-mode.el"
-;;;;;; (19845 45374))
+;;;;;; (20244 35516))
;;; Generated autoloads from cedet/srecode/srt-mode.el
(autoload 'srecode-template-mode "srecode/srt-mode" "\
;;;***
\f
;;;### (autoloads (starttls-open-stream) "starttls" "gnus/starttls.el"
-;;;;;; (20047 35303))
+;;;;;; (20244 35516))
;;; Generated autoloads from gnus/starttls.el
(autoload 'starttls-open-stream "starttls" "\
Third arg is name of the host to connect to, or its IP address.
Fourth arg PORT is an integer specifying a port to connect to.
If `starttls-use-gnutls' is nil, this may also be a service name, but
-GNUTLS requires a port number.
+GnuTLS requires a port number.
\(fn NAME BUFFER HOST PORT)" nil nil)
;;;;;; strokes-mode strokes-list-strokes strokes-load-user-strokes
;;;;;; strokes-help strokes-describe-stroke strokes-do-complex-stroke
;;;;;; strokes-do-stroke strokes-read-complex-stroke strokes-read-stroke
-;;;;;; strokes-global-set-stroke) "strokes" "strokes.el" (19886
-;;;;;; 45771))
+;;;;;; strokes-global-set-stroke) "strokes" "strokes.el" (20428
+;;;;;; 57510))
;;; Generated autoloads from strokes.el
(autoload 'strokes-global-set-stroke "strokes" "\
(custom-autoload 'strokes-mode "strokes" nil)
(autoload 'strokes-mode "strokes" "\
-Toggle Strokes global minor mode.\\<strokes-mode-map>
-With ARG, turn strokes on if and only if ARG is positive.
+Toggle Strokes mode, a global minor mode.
+With a prefix argument ARG, enable Strokes mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+the mode if ARG is omitted or nil.
+
+\\<strokes-mode-map>
Strokes are pictographic mouse gestures which invoke commands.
Strokes are invoked with \\[strokes-do-stroke]. You can define
new strokes with \\[strokes-global-set-stroke]. See also
;;;***
\f
;;;### (autoloads (studlify-buffer studlify-word studlify-region)
-;;;;;; "studly" "play/studly.el" (19845 45374))
+;;;;;; "studly" "play/studly.el" (19765 60663))
;;; Generated autoloads from play/studly.el
(autoload 'studlify-region "studly" "\
;;;***
\f
;;;### (autoloads (global-subword-mode subword-mode) "subword" "progmodes/subword.el"
-;;;;;; (19845 45374))
+;;;;;; (20244 35516))
;;; Generated autoloads from progmodes/subword.el
(autoload 'subword-mode "subword" "\
-Mode enabling subword movement and editing keys.
-In spite of GNU Coding Standards, it is popular to name a symbol by
-mixing uppercase and lowercase letters, e.g. \"GtkWidget\",
-\"EmacsFrameClass\", \"NSGraphicsContext\", etc. Here we call these
-mixed case symbols `nomenclatures'. Also, each capitalized (or
-completely uppercase) part of a nomenclature is called a `subword'.
-Here are some examples:
+Toggle subword movement and editing (Subword mode).
+With a prefix argument ARG, enable Subword mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+the mode if ARG is omitted or nil.
+
+Subword mode is a buffer-local minor mode. Enabling it remaps
+word-based editing commands to subword-based commands that handle
+symbols with mixed uppercase and lowercase letters,
+e.g. \"GtkWidget\", \"EmacsFrameClass\", \"NSGraphicsContext\".
+
+Here we call these mixed case symbols `nomenclatures'. Each
+capitalized (or completely uppercase) part of a nomenclature is
+called a `subword'. Here are some examples:
Nomenclature Subwords
===========================================================
(custom-autoload 'global-subword-mode "subword" nil)
(autoload 'global-subword-mode "subword" "\
-Toggle Subword mode in every possible buffer.
-With prefix ARG, turn Global-Subword mode on if and only if
-ARG is positive.
+Toggle Subword mode in all buffers.
+With prefix ARG, enable Global-Subword mode if ARG is positive;
+otherwise, disable it. If called from Lisp, enable the mode if
+ARG is omitted or nil.
+
Subword mode is enabled in all buffers where
`(lambda nil (subword-mode 1))' would do it.
See `subword-mode' for more information on Subword mode.
;;;***
\f
;;;### (autoloads (sc-cite-original) "supercite" "mail/supercite.el"
-;;;;;; (19931 11784))
+;;;;;; (20276 3849))
;;; Generated autoloads from mail/supercite.el
(autoload 'sc-cite-original "supercite" "\
;;;***
\f
-;;;### (autoloads (gpm-mouse-mode) "t-mouse" "t-mouse.el" (19845
-;;;;;; 45374))
+;;;### (autoloads (gpm-mouse-mode) "t-mouse" "t-mouse.el" (20244
+;;;;;; 35516))
;;; Generated autoloads from t-mouse.el
(define-obsolete-function-alias 't-mouse-mode 'gpm-mouse-mode "23.1")
(custom-autoload 'gpm-mouse-mode "t-mouse" nil)
(autoload 'gpm-mouse-mode "t-mouse" "\
-Toggle gpm-mouse mode to use the mouse in GNU/Linux consoles.
-With prefix arg, turn gpm-mouse mode on if arg is positive,
-otherwise turn it off.
+Toggle mouse support in GNU/Linux consoles (GPM Mouse mode).
+With a prefix argument ARG, enable GPM Mouse mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+the mode if ARG is omitted or nil.
This allows the use of the mouse when operating on a GNU/Linux console,
in the same way as you can use the mouse under X11.
;;;***
\f
-;;;### (autoloads (tabify untabify) "tabify" "tabify.el" (19998 49767))
+;;;### (autoloads (tabify untabify) "tabify" "tabify.el" (20244 35516))
;;; Generated autoloads from tabify.el
(autoload 'untabify "tabify" "\
;;;;;; table-recognize table-insert-row-column table-insert-column
;;;;;; table-insert-row table-insert table-point-left-cell-hook
;;;;;; table-point-entered-cell-hook table-load-hook table-cell-map-hook)
-;;;;;; "table" "textmodes/table.el" (19845 45374))
+;;;;;; "table" "textmodes/table.el" (20434 28080))
;;; Generated autoloads from textmodes/table.el
(defvar table-cell-map-hook nil "\
(autoload 'table-shorten-cell "table" "\
Shorten the current cell by N lines by shrinking the cell vertically.
Shortening is done by removing blank lines from the bottom of the cell
-and possibly from the top of the cell as well. Therefor, the cell
+and possibly from the top of the cell as well. Therefore, the cell
must have some bottom/top blank lines to be shorten effectively. This
is applicable to all the cells aligned horizontally with the current
one because they are also shortened in order to keep the rectangular
(autoload 'table-release "table" "\
Convert a table into plain text by removing the frame from a table.
-Remove the frame from a table and inactivate the table. This command
+Remove the frame from a table and deactivate the table. This command
converts a table into plain text without frames. It is a companion to
`table-capture' which does the opposite process.
;;;***
\f
-;;;### (autoloads (tabulated-list-mode) "tabulated-list" "emacs-lisp/tabulated-list.el"
-;;;;;; (20045 30688))
-;;; Generated autoloads from emacs-lisp/tabulated-list.el
-
-(autoload 'tabulated-list-mode "tabulated-list" "\
-Generic major mode for browsing a list of items.
-This mode is usually not used directly; instead, other major
-modes are derived from it, using `define-derived-mode'.
-
-In this major mode, the buffer is divided into multiple columns,
-which are labelled using the header line. Each non-empty line
-belongs to one \"entry\", and the entries can be sorted according
-to their column values.
-
-An inheriting mode should usually do the following in their body:
-
- - Set `tabulated-list-format', specifying the column format.
- - Set `tabulated-list-revert-hook', if the buffer contents need
- to be specially recomputed prior to `revert-buffer'.
- - Maybe set a `tabulated-list-entries' function (see below).
- - Maybe set `tabulated-list-printer' (see below).
- - Maybe set `tabulated-list-padding'.
- - Call `tabulated-list-init-header' to initialize `header-line-format'
- according to `tabulated-list-format'.
-
-An inheriting mode is usually accompanied by a \"list-FOO\"
-command (e.g. `list-packages', `list-processes'). This command
-creates or switches to a buffer and enables the major mode in
-that buffer. If `tabulated-list-entries' is not a function, the
-command should initialize it to a list of entries for displaying.
-Finally, it should call `tabulated-list-print'.
-
-`tabulated-list-print' calls the printer function specified by
-`tabulated-list-printer', once for each entry. The default
-printer is `tabulated-list-print-entry', but a mode that keeps
-data in an ewoc may instead specify a printer function (e.g., one
-that calls `ewoc-enter-last'), with `tabulated-list-print-entry'
-as the ewoc pretty-printer.
-
-\(fn)" t nil)
-
-;;;***
-\f
-;;;### (autoloads (talk talk-connect) "talk" "talk.el" (19886 45771))
+;;;### (autoloads (talk talk-connect) "talk" "talk.el" (20244 35516))
;;; Generated autoloads from talk.el
(autoload 'talk-connect "talk" "\
;;;***
\f
-;;;### (autoloads (tar-mode) "tar-mode" "tar-mode.el" (19977 43600))
+;;;### (autoloads (tar-mode) "tar-mode" "tar-mode.el" (20412 11425))
;;; Generated autoloads from tar-mode.el
(autoload 'tar-mode "tar-mode" "\
;;;***
\f
;;;### (autoloads (tcl-help-on-word inferior-tcl tcl-mode) "tcl"
-;;;;;; "progmodes/tcl.el" (19890 42850))
+;;;;;; "progmodes/tcl.el" (20356 35090))
;;; Generated autoloads from progmodes/tcl.el
(autoload 'tcl-mode "tcl" "\
;;;***
\f
-;;;### (autoloads (rsh telnet) "telnet" "net/telnet.el" (19845 45374))
+;;;### (autoloads (rsh telnet) "telnet" "net/telnet.el" (20244 35516))
;;; Generated autoloads from net/telnet.el
- (add-hook 'same-window-regexps (purecopy "\\*telnet-.*\\*\\(\\|<[0-9]+>\\)"))
(autoload 'telnet "telnet" "\
Open a network login connection to host named HOST (a string).
Normally input is edited in Emacs and sent a line at a time.
\(fn HOST &optional PORT)" t nil)
- (add-hook 'same-window-regexps (purecopy "\\*rsh-[^-]*\\*\\(\\|<[0-9]*>\\)"))
(autoload 'rsh "telnet" "\
Open a network login connection to host named HOST (a string).
;;;***
\f
;;;### (autoloads (serial-term ansi-term term make-term) "term" "term.el"
-;;;;;; (20050 11479))
+;;;;;; (20451 20881))
;;; Generated autoloads from term.el
(autoload 'make-term "term" "\
;;;***
\f
-;;;### (autoloads (terminal-emulator) "terminal" "terminal.el" (19931
-;;;;;; 11784))
+;;;### (autoloads (terminal-emulator) "terminal" "terminal.el" (20244
+;;;;;; 35516))
;;; Generated autoloads from terminal.el
(autoload 'terminal-emulator "terminal" "\
;;;***
\f
;;;### (autoloads (testcover-this-defun) "testcover" "emacs-lisp/testcover.el"
-;;;;;; (19998 49767))
+;;;;;; (20244 35516))
;;; Generated autoloads from emacs-lisp/testcover.el
(autoload 'testcover-this-defun "testcover" "\
;;;***
\f
-;;;### (autoloads (tetris) "tetris" "play/tetris.el" (19889 21967))
+;;;### (autoloads (tetris) "tetris" "play/tetris.el" (20244 35516))
;;; Generated autoloads from play/tetris.el
(autoload 'tetris "tetris" "\
;;;;;; tex-start-commands tex-start-options slitex-run-command latex-run-command
;;;;;; tex-run-command tex-offer-save tex-main-file tex-first-line-header-regexp
;;;;;; tex-directory tex-shell-file-name) "tex-mode" "textmodes/tex-mode.el"
-;;;;;; (19845 45374))
+;;;;;; (20446 34252))
;;; Generated autoloads from textmodes/tex-mode.el
(defvar tex-shell-file-name nil "\
;;;***
\f
;;;### (autoloads (texi2info texinfo-format-region texinfo-format-buffer)
-;;;;;; "texinfmt" "textmodes/texinfmt.el" (19845 45374))
+;;;;;; "texinfmt" "textmodes/texinfmt.el" (20434 28080))
;;; Generated autoloads from textmodes/texinfmt.el
(autoload 'texinfo-format-buffer "texinfmt" "\
;;;***
\f
;;;### (autoloads (texinfo-mode texinfo-close-quote texinfo-open-quote)
-;;;;;; "texinfo" "textmodes/texinfo.el" (19845 45374))
+;;;;;; "texinfo" "textmodes/texinfo.el" (20244 35516))
;;; Generated autoloads from textmodes/texinfo.el
(defvar texinfo-open-quote (purecopy "``") "\
\f
;;;### (autoloads (thai-composition-function thai-compose-buffer
;;;;;; thai-compose-string thai-compose-region) "thai-util" "language/thai-util.el"
-;;;;;; (19845 45374))
+;;;;;; (20276 3849))
;;; Generated autoloads from language/thai-util.el
(autoload 'thai-compose-region "thai-util" "\
\f
;;;### (autoloads (list-at-point number-at-point symbol-at-point
;;;;;; sexp-at-point thing-at-point bounds-of-thing-at-point forward-thing)
-;;;;;; "thingatpt" "thingatpt.el" (19990 55648))
+;;;;;; "thingatpt" "thingatpt.el" (20419 46656))
;;; Generated autoloads from thingatpt.el
(autoload 'forward-thing "thingatpt" "\
\f
;;;### (autoloads (thumbs-dired-setroot thumbs-dired-show thumbs-dired-show-marked
;;;;;; thumbs-show-from-dir thumbs-find-thumb) "thumbs" "thumbs.el"
-;;;;;; (19931 11784))
+;;;;;; (20244 35516))
;;; Generated autoloads from thumbs.el
(autoload 'thumbs-find-thumb "thumbs" "\
;;;;;; tibetan-post-read-conversion tibetan-compose-buffer tibetan-decompose-buffer
;;;;;; tibetan-decompose-string tibetan-decompose-region tibetan-compose-region
;;;;;; tibetan-compose-string tibetan-transcription-to-tibetan tibetan-tibetan-to-transcription
-;;;;;; tibetan-char-p) "tibet-util" "language/tibet-util.el" (19845
-;;;;;; 45374))
+;;;;;; tibetan-char-p) "tibet-util" "language/tibet-util.el" (20356
+;;;;;; 35090))
;;; Generated autoloads from language/tibet-util.el
(autoload 'tibetan-char-p "tibet-util" "\
;;;***
\f
;;;### (autoloads (tildify-buffer tildify-region) "tildify" "textmodes/tildify.el"
-;;;;;; (19845 45374))
+;;;;;; (20373 41604))
;;; Generated autoloads from textmodes/tildify.el
(autoload 'tildify-region "tildify" "\
\f
;;;### (autoloads (emacs-init-time emacs-uptime display-time-world
;;;;;; display-time-mode display-time display-time-day-and-date)
-;;;;;; "time" "time.el" (20033 22846))
+;;;;;; "time" "time.el" (20412 11425))
;;; Generated autoloads from time.el
(defvar display-time-day-and-date nil "\
(autoload 'display-time-mode "time" "\
Toggle display of time, load level, and mail flag in mode lines.
-With a numeric arg, enable this display if arg is positive.
+With a prefix argument ARG, enable Display Time mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+it if ARG is omitted or nil.
-When this display is enabled, it updates automatically every minute
-\(you can control the number of seconds between updates by
-customizing `display-time-interval').
-If `display-time-day-and-date' is non-nil, the current day and date
-are displayed as well.
-This runs the normal hook `display-time-hook' after each update.
+When Display Time mode is enabled, it updates every minute (you
+can control the number of seconds between updates by customizing
+`display-time-interval'). If `display-time-day-and-date' is
+non-nil, the current day and date are displayed as well. This
+runs the normal hook `display-time-hook' after each update.
\(fn &optional ARG)" t nil)
;;;;;; time-to-day-in-year date-leap-year-p days-between date-to-day
;;;;;; time-add time-subtract time-since days-to-time time-less-p
;;;;;; seconds-to-time date-to-time) "time-date" "calendar/time-date.el"
-;;;;;; (19885 24894))
+;;;;;; (20244 35516))
;;; Generated autoloads from calendar/time-date.el
(autoload 'date-to-time "time-date" "\
;;;***
\f
;;;### (autoloads (time-stamp-toggle-active time-stamp) "time-stamp"
-;;;;;; "time-stamp.el" (20033 22846))
+;;;;;; "time-stamp.el" (20244 35516))
;;; Generated autoloads from time-stamp.el
(put 'time-stamp-format 'safe-local-variable 'stringp)
(put 'time-stamp-time-zone 'safe-local-variable 'string-or-null-p)
;;;### (autoloads (timeclock-when-to-leave-string timeclock-workday-elapsed-string
;;;;;; timeclock-workday-remaining-string timeclock-reread-log timeclock-query-out
;;;;;; timeclock-change timeclock-status-string timeclock-out timeclock-in
-;;;;;; timeclock-modeline-display) "timeclock" "calendar/timeclock.el"
-;;;;;; (19981 40664))
+;;;;;; timeclock-mode-line-display) "timeclock" "calendar/timeclock.el"
+;;;;;; (20428 57510))
;;; Generated autoloads from calendar/timeclock.el
-(autoload 'timeclock-modeline-display "timeclock" "\
-Toggle display of the amount of time left today in the modeline.
+(autoload 'timeclock-mode-line-display "timeclock" "\
+Toggle display of the amount of time left today in the mode line.
If `timeclock-use-display-time' is non-nil (the default), then
-the function `display-time-mode' must be active, and the modeline
+the function `display-time-mode' must be active, and the mode line
will be updated whenever the time display is updated. Otherwise,
the timeclock will use its own sixty second timer to do its
-updating. With prefix ARG, turn modeline display on if and only
-if ARG is positive. Returns the new status of timeclock modeline
+updating. With prefix ARG, turn mode line display on if and only
+if ARG is positive. Returns the new status of timeclock mode line
display (non-nil means on).
\(fn &optional ARG)" t nil)
;;;***
\f
;;;### (autoloads (batch-titdic-convert titdic-convert) "titdic-cnv"
-;;;;;; "international/titdic-cnv.el" (19845 45374))
+;;;;;; "international/titdic-cnv.el" (20290 33419))
;;; Generated autoloads from international/titdic-cnv.el
(autoload 'titdic-convert "titdic-cnv" "\
;;;***
\f
;;;### (autoloads (tmm-prompt tmm-menubar-mouse tmm-menubar) "tmm"
-;;;;;; "tmm.el" (19845 45374))
+;;;;;; "tmm.el" (20432 55251))
;;; Generated autoloads from tmm.el
(define-key global-map "\M-`" 'tmm-menubar)
(define-key global-map [menu-bar mouse-1] 'tmm-menubar-mouse)
\f
;;;### (autoloads (todo-show todo-cp todo-mode todo-print todo-top-priorities
;;;;;; todo-insert-item todo-add-item-non-interactively todo-add-category)
-;;;;;; "todo-mode" "calendar/todo-mode.el" (19845 45374))
+;;;;;; "todo-mode" "calendar/todo-mode.el" (20244 35516))
;;; Generated autoloads from calendar/todo-mode.el
(autoload 'todo-add-category "todo-mode" "\
\f
;;;### (autoloads (tool-bar-local-item-from-menu tool-bar-add-item-from-menu
;;;;;; tool-bar-local-item tool-bar-add-item toggle-tool-bar-mode-from-frame)
-;;;;;; "tool-bar" "tool-bar.el" (19994 52720))
+;;;;;; "tool-bar" "tool-bar.el" (20290 33419))
;;; Generated autoloads from tool-bar.el
(autoload 'toggle-tool-bar-mode-from-frame "tool-bar" "\
;;;***
\f
;;;### (autoloads (tpu-edt-on tpu-edt-mode) "tpu-edt" "emulation/tpu-edt.el"
-;;;;;; (19931 11784))
+;;;;;; (20412 11425))
;;; Generated autoloads from emulation/tpu-edt.el
(defvar tpu-edt-mode nil "\
(custom-autoload 'tpu-edt-mode "tpu-edt" nil)
(autoload 'tpu-edt-mode "tpu-edt" "\
-TPU/edt emulation.
+Toggle TPU/edt emulation on or off.
+With a prefix argument ARG, enable the mode if ARG is positive,
+and disable it otherwise. If called from Lisp, enable the mode
+if ARG is omitted or nil.
\(fn &optional ARG)" t nil)
;;;***
\f
;;;### (autoloads (tpu-mapper) "tpu-mapper" "emulation/tpu-mapper.el"
-;;;;;; (19845 45374))
+;;;;;; (20244 35516))
;;; Generated autoloads from emulation/tpu-mapper.el
(autoload 'tpu-mapper "tpu-mapper" "\
;;;***
\f
-;;;### (autoloads (tq-create) "tq" "emacs-lisp/tq.el" (19845 45374))
+;;;### (autoloads (tq-create) "tq" "emacs-lisp/tq.el" (20244 35516))
;;; Generated autoloads from emacs-lisp/tq.el
(autoload 'tq-create "tq" "\
;;;***
\f
;;;### (autoloads (trace-function-background trace-function trace-buffer)
-;;;;;; "trace" "emacs-lisp/trace.el" (19845 45374))
+;;;;;; "trace" "emacs-lisp/trace.el" (20244 35516))
;;; Generated autoloads from emacs-lisp/trace.el
(defvar trace-buffer (purecopy "*trace-output*") "\
;;;### (autoloads (tramp-unload-tramp tramp-completion-handle-file-name-completion
;;;;;; tramp-completion-handle-file-name-all-completions tramp-unload-file-name-handlers
;;;;;; tramp-file-name-handler tramp-syntax tramp-mode) "tramp"
-;;;;;; "net/tramp.el" (20062 2656))
+;;;;;; "net/tramp.el" (20446 34252))
;;; Generated autoloads from net/tramp.el
(defvar tramp-mode t "\
-*Whether Tramp is enabled.
+Whether Tramp is enabled.
If it is set to nil, all remote file names are used literally.")
(custom-autoload 'tramp-mode "tramp" t)
(custom-autoload 'tramp-syntax "tramp" t)
-(defconst tramp-file-name-regexp-unified (if (memq system-type '(cygwin windows-nt)) "\\`/\\([^[/:]\\{2,\\}\\|[^/]\\{2,\\}]\\):" "\\`/\\([^[/:]+\\|[^/]+]\\):") "\
+(defconst tramp-file-name-regexp-unified (if (memq system-type '(cygwin windows-nt)) "\\`/\\([^[/|:]\\{2,\\}\\|[^/|]\\{2,\\}]\\):" "\\`/\\([^[/|:]+\\|[^/|]+]\\):") "\
Value for `tramp-file-name-regexp' for unified remoting.
Emacs (not XEmacs) uses a unified filename syntax for Ange-FTP and
Tramp. See `tramp-file-name-structure' for more explanations.
XEmacs uses a separate filename syntax for Tramp and EFS.
See `tramp-file-name-structure' for more explanations.")
-(defconst tramp-file-name-regexp-url "\\`/[^/:]+://" "\
+(defconst tramp-file-name-regexp-url "\\`/[^/|:]+://" "\
Value for `tramp-file-name-regexp' for URL-like remoting.
See `tramp-file-name-structure' for more explanations.")
(defconst tramp-file-name-regexp (cond ((equal tramp-syntax 'ftp) tramp-file-name-regexp-unified) ((equal tramp-syntax 'sep) tramp-file-name-regexp-separate) ((equal tramp-syntax 'url) tramp-file-name-regexp-url) (t (error "Wrong `tramp-syntax' defined"))) "\
-*Regular expression matching file names handled by Tramp.
+Regular expression matching file names handled by Tramp.
This regexp should match Tramp file names but no other file names.
When tramp.el is loaded, this regular expression is prepended to
`file-name-handler-alist', and that is searched sequentially. Thus,
See `tramp-file-name-structure' for more explanations.")
(defconst tramp-completion-file-name-regexp (cond ((equal tramp-syntax 'ftp) tramp-completion-file-name-regexp-unified) ((equal tramp-syntax 'sep) tramp-completion-file-name-regexp-separate) ((equal tramp-syntax 'url) tramp-completion-file-name-regexp-url) (t (error "Wrong `tramp-syntax' defined"))) "\
-*Regular expression matching file names handled by Tramp completion.
+Regular expression matching file names handled by Tramp completion.
This regexp should match partial Tramp file names only.
Please note that the entry in `file-name-handler-alist' is made when
;;;***
\f
;;;### (autoloads (tramp-ftp-enable-ange-ftp) "tramp-ftp" "net/tramp-ftp.el"
-;;;;;; (19946 29209))
+;;;;;; (20438 17064))
;;; Generated autoloads from net/tramp-ftp.el
(autoload 'tramp-ftp-enable-ange-ftp "tramp-ftp" "\
;;;***
\f
-;;;### (autoloads (help-with-tutorial) "tutorial" "tutorial.el" (20048
-;;;;;; 56149))
+;;;### (autoloads (help-with-tutorial) "tutorial" "tutorial.el" (20373
+;;;;;; 41604))
;;; Generated autoloads from tutorial.el
(autoload 'help-with-tutorial "tutorial" "\
;;;***
\f
;;;### (autoloads (tai-viet-composition-function) "tv-util" "language/tv-util.el"
-;;;;;; (19845 45374))
+;;;;;; (19765 60663))
;;; Generated autoloads from language/tv-util.el
(autoload 'tai-viet-composition-function "tv-util" "\
;;;***
\f
;;;### (autoloads (2C-split 2C-associate-buffer 2C-two-columns) "two-column"
-;;;;;; "textmodes/two-column.el" (19845 45374))
+;;;;;; "textmodes/two-column.el" (20373 41604))
;;; Generated autoloads from textmodes/two-column.el
(autoload '2C-command "two-column" () t 'keymap)
(global-set-key "\C-x6" '2C-command)
;;;;;; type-break type-break-mode type-break-keystroke-threshold
;;;;;; type-break-good-break-interval type-break-good-rest-interval
;;;;;; type-break-interval type-break-mode) "type-break" "type-break.el"
-;;;;;; (19985 37722))
+;;;;;; (20356 35090))
;;; Generated autoloads from type-break.el
(defvar type-break-mode nil "\
;;;***
\f
-;;;### (autoloads (uce-reply-to-uce) "uce" "mail/uce.el" (19845 45374))
+;;;### (autoloads (uce-reply-to-uce) "uce" "mail/uce.el" (20244 35516))
;;; Generated autoloads from mail/uce.el
(autoload 'uce-reply-to-uce "uce" "\
;;;;;; ucs-normalize-NFKC-string ucs-normalize-NFKC-region ucs-normalize-NFKD-string
;;;;;; ucs-normalize-NFKD-region ucs-normalize-NFC-string ucs-normalize-NFC-region
;;;;;; ucs-normalize-NFD-string ucs-normalize-NFD-region) "ucs-normalize"
-;;;;;; "international/ucs-normalize.el" (20052 53218))
+;;;;;; "international/ucs-normalize.el" (20244 35516))
;;; Generated autoloads from international/ucs-normalize.el
(autoload 'ucs-normalize-NFD-region "ucs-normalize" "\
;;;***
\f
;;;### (autoloads (ununderline-region underline-region) "underline"
-;;;;;; "textmodes/underline.el" (19845 45374))
+;;;;;; "textmodes/underline.el" (20244 35516))
;;; Generated autoloads from textmodes/underline.el
(autoload 'underline-region "underline" "\
;;;***
\f
;;;### (autoloads (unrmail batch-unrmail) "unrmail" "mail/unrmail.el"
-;;;;;; (19845 45374))
+;;;;;; (20373 41604))
;;; Generated autoloads from mail/unrmail.el
(autoload 'batch-unrmail "unrmail" "\
;;;***
\f
-;;;### (autoloads (unsafep) "unsafep" "emacs-lisp/unsafep.el" (19845
-;;;;;; 45374))
+;;;### (autoloads (unsafep) "unsafep" "emacs-lisp/unsafep.el" (20244
+;;;;;; 35516))
;;; Generated autoloads from emacs-lisp/unsafep.el
(autoload 'unsafep "unsafep" "\
;;;***
\f
;;;### (autoloads (url-retrieve-synchronously url-retrieve) "url"
-;;;;;; "url/url.el" (19845 45374))
+;;;;;; "url/url.el" (20451 20881))
;;; Generated autoloads from url/url.el
(autoload 'url-retrieve "url" "\
Retrieve URL asynchronously and call CALLBACK with CBARGS when finished.
-URL is either a string or a parsed URL.
+URL is either a string or a parsed URL. If it is a string
+containing characters that are not valid in a URI, those
+characters are percent-encoded; see `url-encode-url'.
CALLBACK is called when the object has been completely retrieved, with
the current buffer containing the object, and any MIME headers associated
take effect.
If SILENT, then don't message progress reports and the like.
+If INHIBIT-COOKIES, cookies will neither be stored nor sent to
+the server.
+If URL is a multibyte string, it will be encoded as utf-8 and
+URL-encoded before it's used.
-\(fn URL CALLBACK &optional CBARGS SILENT)" nil nil)
+\(fn URL CALLBACK &optional CBARGS SILENT INHIBIT-COOKIES)" nil nil)
(autoload 'url-retrieve-synchronously "url" "\
Retrieve URL synchronously.
;;;***
\f
;;;### (autoloads (url-register-auth-scheme url-get-authentication)
-;;;;;; "url-auth" "url/url-auth.el" (19845 45374))
+;;;;;; "url-auth" "url/url-auth.el" (20244 35516))
;;; Generated autoloads from url/url-auth.el
(autoload 'url-get-authentication "url-auth" "\
;;;***
\f
;;;### (autoloads (url-cache-extract url-is-cached url-store-in-cache)
-;;;;;; "url-cache" "url/url-cache.el" (19988 13913))
+;;;;;; "url-cache" "url/url-cache.el" (20276 3849))
;;; Generated autoloads from url/url-cache.el
(autoload 'url-store-in-cache "url-cache" "\
;;;***
\f
-;;;### (autoloads (url-cid) "url-cid" "url/url-cid.el" (19845 45374))
+;;;### (autoloads (url-cid) "url-cid" "url/url-cid.el" (20244 35516))
;;; Generated autoloads from url/url-cid.el
(autoload 'url-cid "url-cid" "\
;;;***
\f
;;;### (autoloads (url-dav-vc-registered url-dav-supported-p) "url-dav"
-;;;;;; "url/url-dav.el" (19845 45374))
+;;;;;; "url/url-dav.el" (20356 35090))
;;; Generated autoloads from url/url-dav.el
(autoload 'url-dav-supported-p "url-dav" "\
;;;***
\f
-;;;### (autoloads (url-file) "url-file" "url/url-file.el" (19845
-;;;;;; 45374))
+;;;### (autoloads (url-file) "url-file" "url/url-file.el" (20244
+;;;;;; 35516))
;;; Generated autoloads from url/url-file.el
(autoload 'url-file "url-file" "\
;;;***
\f
;;;### (autoloads (url-open-stream url-gateway-nslookup-host) "url-gw"
-;;;;;; "url/url-gw.el" (19864 29553))
+;;;;;; "url/url-gw.el" (20244 35516))
;;; Generated autoloads from url/url-gw.el
(autoload 'url-gateway-nslookup-host "url-gw" "\
\f
;;;### (autoloads (url-insert-file-contents url-file-local-copy url-copy-file
;;;;;; url-file-handler url-handler-mode) "url-handlers" "url/url-handlers.el"
-;;;;;; (19845 45374))
+;;;;;; (20446 34252))
;;; Generated autoloads from url/url-handlers.el
(defvar url-handler-mode nil "\
(custom-autoload 'url-handler-mode "url-handlers" nil)
(autoload 'url-handler-mode "url-handlers" "\
-Use URL to handle URL-like file names.
+Toggle using `url' library for URL filenames (URL Handler mode).
+With a prefix argument ARG, enable URL Handler mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+the mode if ARG is omitted or nil.
\(fn &optional ARG)" t nil)
;;;***
\f
;;;### (autoloads (url-http-options url-http-file-attributes url-http-file-exists-p
-;;;;;; url-http) "url-http" "url/url-http.el" (20031 47065))
+;;;;;; url-http) "url-http" "url/url-http.el" (20415 57974))
;;; Generated autoloads from url/url-http.el
(autoload 'url-http "url-http" "\
When retrieval is completed, the function CALLBACK is executed with
CBARGS as the arguments.
-\(fn URL CALLBACK CBARGS)" nil nil)
+Optional arg RETRY-BUFFER, if non-nil, specifies the buffer of a
+previous `url-http' call, which is being re-attempted.
+
+\(fn URL CALLBACK CBARGS &optional RETRY-BUFFER)" nil nil)
(autoload 'url-http-file-exists-p "url-http" "\
;;;***
\f
-;;;### (autoloads (url-irc) "url-irc" "url/url-irc.el" (19845 45374))
+;;;### (autoloads (url-irc) "url-irc" "url/url-irc.el" (20244 35516))
;;; Generated autoloads from url/url-irc.el
(autoload 'url-irc "url-irc" "\
;;;***
\f
-;;;### (autoloads (url-ldap) "url-ldap" "url/url-ldap.el" (19845
-;;;;;; 45374))
+;;;### (autoloads (url-ldap) "url-ldap" "url/url-ldap.el" (20356
+;;;;;; 35090))
;;; Generated autoloads from url/url-ldap.el
(autoload 'url-ldap "url-ldap" "\
;;;***
\f
;;;### (autoloads (url-mailto url-mail) "url-mailto" "url/url-mailto.el"
-;;;;;; (19845 45374))
+;;;;;; (20244 35516))
;;; Generated autoloads from url/url-mailto.el
(autoload 'url-mail "url-mailto" "\
;;;***
\f
;;;### (autoloads (url-data url-generic-emulator-loader url-info
-;;;;;; url-man) "url-misc" "url/url-misc.el" (19845 45374))
+;;;;;; url-man) "url-misc" "url/url-misc.el" (20244 35516))
;;; Generated autoloads from url/url-misc.el
(autoload 'url-man "url-misc" "\
;;;***
\f
;;;### (autoloads (url-snews url-news) "url-news" "url/url-news.el"
-;;;;;; (19845 45374))
+;;;;;; (20244 35516))
;;; Generated autoloads from url/url-news.el
(autoload 'url-news "url-news" "\
\f
;;;### (autoloads (url-ns-user-pref url-ns-prefs isInNet isResolvable
;;;;;; dnsResolve dnsDomainIs isPlainHostName) "url-ns" "url/url-ns.el"
-;;;;;; (19845 45374))
+;;;;;; (20244 35516))
;;; Generated autoloads from url/url-ns.el
(autoload 'isPlainHostName "url-ns" "\
;;;***
\f
;;;### (autoloads (url-generic-parse-url url-recreate-url) "url-parse"
-;;;;;; "url/url-parse.el" (19845 45374))
+;;;;;; "url/url-parse.el" (20412 11425))
;;; Generated autoloads from url/url-parse.el
(autoload 'url-recreate-url "url-parse" "\
(autoload 'url-generic-parse-url "url-parse" "\
Return an URL-struct of the parts of URL.
The CL-style struct contains the following fields:
-TYPE USER PASSWORD HOST PORTSPEC FILENAME TARGET ATTRIBUTES FULLNESS.
+
+TYPE is the URI scheme (string or nil).
+USER is the user name (string or nil).
+PASSWORD is the password (string [deprecated] or nil).
+HOST is the host (a registered name, IP literal in square
+ brackets, or IPv4 address in dotted-decimal form).
+PORTSPEC is the specified port (a number), or nil.
+FILENAME is the path AND the query component of the URI.
+TARGET is the fragment identifier component (used to refer to a
+ subordinate resource, e.g. a part of a webpage).
+ATTRIBUTES is nil; this slot originally stored the attribute and
+ value alists for IMAP URIs, but this feature was removed
+ since it conflicts with RFC 3986.
+FULLNESS is non-nil iff the hierarchical sequence component of
+ the URL starts with two slashes, \"//\".
+
+The parser follows RFC 3986, except that it also tries to handle
+URIs that are not fully specified (e.g. lacking TYPE), and it
+does not check for or perform %-encoding.
+
+Here is an example. The URL
+
+ foo://bob:pass@example.com:42/a/b/c.dtb?type=animal&name=narwhal#nose
+
+parses to
+
+ TYPE = \"foo\"
+ USER = \"bob\"
+ PASSWORD = \"pass\"
+ HOST = \"example.com\"
+ PORTSPEC = 42
+ FILENAME = \"/a/b/c.dtb?type=animal&name=narwhal\"
+ TARGET = \"nose\"
+ ATTRIBUTES = nil
+ FULLNESS = t
\(fn URL)" nil nil)
;;;***
\f
;;;### (autoloads (url-setup-privacy-info) "url-privacy" "url/url-privacy.el"
-;;;;;; (19845 45374))
+;;;;;; (20244 35516))
;;; Generated autoloads from url/url-privacy.el
(autoload 'url-setup-privacy-info "url-privacy" "\
;;;***
\f
;;;### (autoloads (url-queue-retrieve) "url-queue" "url/url-queue.el"
-;;;;;; (19943 25429))
+;;;;;; (20336 29137))
;;; Generated autoloads from url/url-queue.el
(autoload 'url-queue-retrieve "url-queue" "\
Retrieve URL asynchronously and call CALLBACK with CBARGS when finished.
-Like `url-retrieve' (which see for details of the arguments), but
-controls the level of parallelism via the
-`url-queue-parallel-processes' variable.
+This is like `url-retrieve' (which see for details of the arguments),
+but with limits on the degree of parallelism. The variable
+`url-queue-parallel-processes' sets the number of concurrent processes.
+The variable `url-queue-timeout' sets a timeout.
-\(fn URL CALLBACK &optional CBARGS SILENT)" nil nil)
+\(fn URL CALLBACK &optional CBARGS SILENT INHIBIT-COOKIES)" nil nil)
;;;***
\f
;;;### (autoloads (url-view-url url-truncate-url-for-viewing url-file-extension
-;;;;;; url-hexify-string url-unhex-string url-parse-query-string
-;;;;;; url-file-nondirectory url-file-directory url-percentage url-display-percentage
-;;;;;; url-pretty-length url-strip-leading-spaces url-eat-trailing-space
-;;;;;; url-get-normalized-date url-lazy-message url-normalize-url
-;;;;;; url-insert-entities-in-string url-parse-args url-debug url-debug)
-;;;;;; "url-util" "url/url-util.el" (19867 59212))
+;;;;;; url-encode-url url-hexify-string url-unhex-string url-build-query-string
+;;;;;; url-parse-query-string url-file-nondirectory url-file-directory
+;;;;;; url-percentage url-display-percentage url-pretty-length url-strip-leading-spaces
+;;;;;; url-eat-trailing-space url-get-normalized-date url-lazy-message
+;;;;;; url-normalize-url url-insert-entities-in-string url-parse-args
+;;;;;; url-debug url-debug) "url-util" "url/url-util.el" (20412
+;;;;;; 11425))
;;; Generated autoloads from url/url-util.el
(defvar url-debug nil "\
\(fn QUERY &optional DOWNCASE ALLOW-NEWLINES)" nil nil)
+(autoload 'url-build-query-string "url-util" "\
+Build a query-string.
+
+Given a QUERY in the form:
+'((key1 val1)
+ (key2 val2)
+ (key3 val1 val2)
+ (key4)
+ (key5
+
+\(fn QUERY &optional SEMICOLONS KEEP-EMPTY)" nil nil)
+
(autoload 'url-unhex-string "url-util" "\
Remove %XX embedded spaces, etc in a URL.
If optional second argument ALLOW-NEWLINES is non-nil, then allow the
\(fn STR &optional ALLOW-NEWLINES)" nil nil)
(autoload 'url-hexify-string "url-util" "\
-Return a new string that is STRING URI-encoded.
-First, STRING is converted to utf-8, if necessary. Then, for each
-character in the utf-8 string, those found in `url-unreserved-chars'
-are left as-is, all others are represented as a three-character
-string: \"%\" followed by two lowercase hex digits.
+URI-encode STRING and return the result.
+If STRING is multibyte, it is first converted to a utf-8 byte
+string. Each byte corresponding to an allowed character is left
+as-is, while all other bytes are converted to a three-character
+string: \"%\" followed by two upper-case hex digits.
+
+The allowed characters are specified by ALLOWED-CHARS. If this
+argument is nil, the list `url-unreserved-chars' determines the
+allowed characters. Otherwise, ALLOWED-CHARS should be a vector
+whose Nth element is non-nil if character N is allowed.
+
+\(fn STRING &optional ALLOWED-CHARS)" nil nil)
+
+(autoload 'url-encode-url "url-util" "\
+Return a properly URI-encoded version of URL.
+This function also performs URI normalization, e.g. converting
+the scheme to lowercase if it is uppercase. Apart from
+normalization, if URL is already URI-encoded, this function
+should return it unchanged.
-\(fn STRING)" nil nil)
+\(fn URL)" nil nil)
(autoload 'url-file-extension "url-util" "\
Return the filename extension of FNAME.
;;;***
\f
;;;### (autoloads (ask-user-about-supersession-threat ask-user-about-lock)
-;;;;;; "userlock" "userlock.el" (19845 45374))
+;;;;;; "userlock" "userlock.el" (20244 35516))
;;; Generated autoloads from userlock.el
(autoload 'ask-user-about-lock "userlock" "\
\f
;;;### (autoloads (utf-7-imap-pre-write-conversion utf-7-pre-write-conversion
;;;;;; utf-7-imap-post-read-conversion utf-7-post-read-conversion)
-;;;;;; "utf-7" "international/utf-7.el" (19845 45374))
+;;;;;; "utf-7" "international/utf-7.el" (20244 35516))
;;; Generated autoloads from international/utf-7.el
(autoload 'utf-7-post-read-conversion "utf-7" "\
;;;***
\f
-;;;### (autoloads (utf7-encode) "utf7" "gnus/utf7.el" (19845 45374))
+;;;### (autoloads (utf7-encode) "utf7" "gnus/utf7.el" (20244 35516))
;;; Generated autoloads from gnus/utf7.el
(autoload 'utf7-encode "utf7" "\
\f
;;;### (autoloads (uudecode-decode-region uudecode-decode-region-internal
;;;;;; uudecode-decode-region-external) "uudecode" "mail/uudecode.el"
-;;;;;; (19845 45374))
+;;;;;; (20356 35090))
;;; Generated autoloads from mail/uudecode.el
(autoload 'uudecode-decode-region-external "uudecode" "\
;;;;;; vc-print-log vc-retrieve-tag vc-create-tag vc-merge vc-insert-headers
;;;;;; vc-revision-other-window vc-root-diff vc-ediff vc-version-ediff
;;;;;; vc-diff vc-version-diff vc-register vc-next-action vc-before-checkin-hook
-;;;;;; vc-checkin-hook vc-checkout-hook) "vc" "vc/vc.el" (19997
-;;;;;; 28887))
+;;;;;; vc-checkin-hook vc-checkout-hook) "vc" "vc/vc.el" (20420
+;;;;;; 52684))
;;; Generated autoloads from vc/vc.el
(defvar vc-checkout-hook nil "\
(autoload 'vc-next-action "vc" "\
Do the next logical version control operation on the current fileset.
-This requires that all files in the fileset be in the same state.
-
-For locking systems:
- If every file is not already registered, this registers each for version
-control.
- If every file is registered and not locked by anyone, this checks out
-a writable and locked file of each ready for editing.
- If every file is checked out and locked by the calling user, this
-first checks to see if each file has changed since checkout. If not,
-it performs a revert on that file.
- If every file has been changed, this pops up a buffer for entry
-of a log message; when the message has been entered, it checks in the
-resulting changes along with the log message as change commentary. If
-the variable `vc-keep-workfiles' is non-nil (which is its default), a
-read-only copy of each changed file is left in place afterwards.
- If the affected file is registered and locked by someone else, you are
-given the option to steal the lock(s).
-
-For merging systems:
- If every file is not already registered, this registers each one for version
-control. This does an add, but not a commit.
- If every file is added but not committed, each one is committed.
- If every working file is changed, but the corresponding repository file is
-unchanged, this pops up a buffer for entry of a log message; when the
-message has been entered, it checks in the resulting changes along
-with the logmessage as change commentary. A writable file is retained.
- If the repository file is changed, you are asked if you want to
-merge in the changes into your working copy.
+This requires that all files in the current VC fileset be in the
+same state. If not, signal an error.
+
+For merging-based version control systems:
+ If every file in the VC fileset is not registered for version
+ control, register the fileset (but don't commit).
+ If every work file in the VC fileset is added or changed, pop
+ up a *vc-log* buffer to commit the fileset.
+ For a centralized version control system, if any work file in
+ the VC fileset is out of date, offer to update the fileset.
+
+For old-style locking-based version control systems, like RCS:
+ If every file is not registered, register the file(s).
+ If every file is registered and unlocked, check out (lock)
+ the file(s) for editing.
+ If every file is locked by you and has changes, pop up a
+ *vc-log* buffer to check in the changes. If the variable
+ `vc-keep-workfiles' is non-nil (the default), leave a
+ read-only copy of each changed file after checking in.
+ If every file is locked by you and unchanged, unlock them.
+ If every file is locked by someone else, offer to steal the lock.
\(fn VERBOSE)" t nil)
(autoload 'vc-merge "vc" "\
Perform a version control merge operation.
+You must be visiting a version controlled file, or in a `vc-dir' buffer.
On a distributed version control system, this runs a \"merge\"
operation to incorporate changes from another branch onto the
current branch, prompting for an argument list.
(autoload 'vc-pull "vc" "\
Update the current fileset or branch.
+You must be visiting a version controlled file, or in a `vc-dir' buffer.
On a distributed version control system, this runs a \"pull\"
operation to update the current branch, prompting for an argument
list if required. Optional prefix ARG forces a prompt.
;;;***
\f
;;;### (autoloads (vc-annotate) "vc-annotate" "vc/vc-annotate.el"
-;;;;;; (19920 63959))
+;;;;;; (20432 54738))
;;; Generated autoloads from vc/vc-annotate.el
(autoload 'vc-annotate "vc-annotate" "\
;;;***
\f
-;;;### (autoloads nil "vc-arch" "vc/vc-arch.el" (19984 16846))
+;;;### (autoloads nil "vc-arch" "vc/vc-arch.el" (20428 57510))
;;; Generated autoloads from vc/vc-arch.el
(defun vc-arch-registered (file)
(if (vc-find-root file "{arch}/=tagging-method")
;;;***
\f
-;;;### (autoloads nil "vc-bzr" "vc/vc-bzr.el" (19991 42275))
+;;;### (autoloads nil "vc-bzr" "vc/vc-bzr.el" (20412 11425))
;;; Generated autoloads from vc/vc-bzr.el
(defconst vc-bzr-admin-dirname ".bzr" "\
Name of the directory containing Bzr repository status files.")
-(defconst vc-bzr-admin-checkout-format-file (concat vc-bzr-admin-dirname "/checkout/format"))
+(defconst vc-bzr-admin-checkout-format-file (concat vc-bzr-admin-dirname "/checkout/format") "\
+Name of the format file in a .bzr directory.")
(defun vc-bzr-registered (file)
(if (vc-find-root file vc-bzr-admin-checkout-format-file)
(progn
;;;***
\f
-;;;### (autoloads nil "vc-cvs" "vc/vc-cvs.el" (19845 45374))
+;;;### (autoloads nil "vc-cvs" "vc/vc-cvs.el" (20428 57510))
;;; Generated autoloads from vc/vc-cvs.el
- (defun vc-cvs-registered (f)
+(defun vc-cvs-registered (f)
+ "Return non-nil if file F is registered with CVS."
(when (file-readable-p (expand-file-name
"CVS/Entries" (file-name-directory f)))
(load "vc-cvs")
;;;***
\f
-;;;### (autoloads (vc-dir) "vc-dir" "vc/vc-dir.el" (19930 13389))
+;;;### (autoloads (vc-dir) "vc-dir" "vc/vc-dir.el" (20377 36640))
;;; Generated autoloads from vc/vc-dir.el
(autoload 'vc-dir "vc-dir" "\
;;;***
\f
;;;### (autoloads (vc-do-command) "vc-dispatcher" "vc/vc-dispatcher.el"
-;;;;;; (19845 45374))
+;;;;;; (20373 41604))
;;; Generated autoloads from vc/vc-dispatcher.el
(autoload 'vc-do-command "vc-dispatcher" "\
;;;***
\f
-;;;### (autoloads nil "vc-git" "vc/vc-git.el" (20063 23511))
+;;;### (autoloads nil "vc-git" "vc/vc-git.el" (20428 57510))
;;; Generated autoloads from vc/vc-git.el
(defun vc-git-registered (file)
"Return non-nil if FILE is registered with git."
;;;***
\f
-;;;### (autoloads nil "vc-hg" "vc/vc-hg.el" (19845 45374))
+;;;### (autoloads nil "vc-hg" "vc/vc-hg.el" (20377 36640))
;;; Generated autoloads from vc/vc-hg.el
(defun vc-hg-registered (file)
"Return non-nil if FILE is registered with hg."
;;;***
\f
-;;;### (autoloads nil "vc-mtn" "vc/vc-mtn.el" (19845 45374))
+;;;### (autoloads nil "vc-mtn" "vc/vc-mtn.el" (20428 57510))
;;; Generated autoloads from vc/vc-mtn.el
-(defconst vc-mtn-admin-dir "_MTN")
+(defconst vc-mtn-admin-dir "_MTN" "\
+Name of the monotone directory.")
-(defconst vc-mtn-admin-format (concat vc-mtn-admin-dir "/format"))
+(defconst vc-mtn-admin-format (concat vc-mtn-admin-dir "/format") "\
+Name of the monotone directory's format file.")
(defun vc-mtn-registered (file)
(if (vc-find-root file vc-mtn-admin-format)
(progn
;;;***
\f
;;;### (autoloads (vc-rcs-master-templates) "vc-rcs" "vc/vc-rcs.el"
-;;;;;; (19845 45374))
+;;;;;; (20432 42254))
;;; Generated autoloads from vc/vc-rcs.el
(defvar vc-rcs-master-templates (purecopy '("%sRCS/%s,v" "%s%s,v" "%sRCS/%s")) "\
;;;***
\f
;;;### (autoloads (vc-sccs-master-templates) "vc-sccs" "vc/vc-sccs.el"
-;;;;;; (19845 45374))
+;;;;;; (20432 42254))
;;; Generated autoloads from vc/vc-sccs.el
(defvar vc-sccs-master-templates (purecopy '("%sSCCS/s.%s" "%ss.%s" vc-sccs-search-project-dir)) "\
;;;***
\f
-;;;### (autoloads nil "vc-svn" "vc/vc-svn.el" (19845 45374))
+;;;### (autoloads nil "vc-svn" "vc/vc-svn.el" (20318 5885))
;;; Generated autoloads from vc/vc-svn.el
(defun vc-svn-registered (f)
(let ((admin-dir (cond ((and (eq system-type 'windows-nt)
;;;***
\f
;;;### (autoloads (vera-mode) "vera-mode" "progmodes/vera-mode.el"
-;;;;;; (19890 42850))
+;;;;;; (20434 28080))
;;; Generated autoloads from progmodes/vera-mode.el
(add-to-list 'auto-mode-alist (cons (purecopy "\\.vr[hi]?\\'") 'vera-mode))
;;;***
\f
;;;### (autoloads (verilog-mode) "verilog-mode" "progmodes/verilog-mode.el"
-;;;;;; (19973 46551))
+;;;;;; (20420 52684))
;;; Generated autoloads from progmodes/verilog-mode.el
(autoload 'verilog-mode "verilog-mode" "\
\\[verilog-sk-initial] Insert an initial begin .. end block.
\\[verilog-sk-fork] Insert a fork begin .. end .. join block.
\\[verilog-sk-module] Insert a module .. (/*AUTOARG*/);.. endmodule block.
+ \\[verilog-sk-ovm-class] Insert an OVM Class block.
+ \\[verilog-sk-uvm-class] Insert an UVM Class block.
\\[verilog-sk-primitive] Insert a primitive .. (.. );.. endprimitive block.
\\[verilog-sk-repeat] Insert a repeat (..) begin .. end block.
\\[verilog-sk-specify] Insert a specify .. endspecify block.
;;;***
\f
;;;### (autoloads (vhdl-mode) "vhdl-mode" "progmodes/vhdl-mode.el"
-;;;;;; (19914 25180))
+;;;;;; (20428 57510))
;;; Generated autoloads from progmodes/vhdl-mode.el
(autoload 'vhdl-mode "vhdl-mode" "\
brackets and removed if the queried string is left empty. Prompts for
mandatory arguments remain in the code if the queried string is left
empty. They can be queried again by `C-c C-t C-q'. Enabled
- electrification is indicated by `/e' in the modeline.
+ electrification is indicated by `/e' in the mode line.
Typing `M-SPC' after a keyword inserts a space without calling the
template generator. Automatic template generation (i.e.
Double striking of some keys inserts cumbersome VHDL syntax elements.
Stuttering can be disabled (enabled) by typing `C-c C-m C-s' or by
option `vhdl-stutter-mode'. Enabled stuttering is indicated by `/s' in
- the modeline. The stuttering keys and their effects are:
+ the mode line. The stuttering keys and their effects are:
;; --> \" : \" [ --> ( -- --> comment
;;; --> \" := \" [[ --> [ --CR --> comment-out code
with a comment in between.
`--CR' comments out code on that line. Re-hitting CR comments
out following lines.
- `C-c c' comments out a region if not commented out,
- uncomments a region if already commented out.
+ `C-c C-c' comments out a region if not commented out,
+ uncomments a region if already commented out. Option
+ `comment-style' defines where the comment characters
+ should be placed (beginning of line, indent, etc.).
You are prompted for comments after object definitions (i.e. signals,
variables, constants, ports) and after subprogram and process
`TAB' indents a line if at the beginning of the line. The amount of
indentation is specified by option `vhdl-basic-offset'. `C-c C-i C-l'
always indents the current line (is bound to `TAB' if option
- `vhdl-intelligent-tab' is nil).
+ `vhdl-intelligent-tab' is nil). If a region is active, `TAB' indents
+ the entire region.
Indentation can be done for a group of lines (`C-c C-i C-g'), a region
(`M-C-\\') or the entire buffer (menu). Argument and port lists are
Syntax-based indentation can be very slow in large files. Option
`vhdl-indent-syntax-based' allows to use faster but simpler indentation.
+ Option `vhdl-indent-comment-like-next-code-line' controls whether
+ comment lines are indented like the preceding or like the following code
+ line.
+
ALIGNMENT:
The alignment functions align operators, keywords, and inline comments
CODE BEAUTIFICATION:
`C-c M-b' and `C-c C-b' beautify the code of a region or of the entire
- buffer respectively. This inludes indentation, alignment, and case
+ buffer respectively. This includes indentation, alignment, and case
fixing. Code beautification can also be run non-interactively using the
command:
STRUCTURAL COMPOSITION:
- Enables simple structural composition. `C-c C-c C-n' creates a skeleton
+ Enables simple structural composition. `C-c C-m C-n' creates a skeleton
for a new component. Subcomponents (i.e. component declaration and
instantiation) can be automatically placed from a previously read port
- (`C-c C-c C-p') or directly from the hierarchy browser (`P'). Finally,
+ (`C-c C-m C-p') or directly from the hierarchy browser (`P'). Finally,
all subcomponents can be automatically connected using internal signals
- and ports (`C-c C-c C-w') following these rules:
+ and ports (`C-c C-m C-w') following these rules:
- subcomponent actual ports with same name are considered to be
connected by a signal (internal signal or port)
- signals that are only inputs to subcomponents are considered as
Component declarations can be placed in a components package (option
`vhdl-use-components-package') which can be automatically generated for
- an entire directory or project (`C-c C-c M-p'). The VHDL'93 direct
+ an entire directory or project (`C-c C-m M-p'). The VHDL'93 direct
component instantiation is also supported (option
`vhdl-use-direct-instantiation').
-| Configuration declarations can automatically be generated either from
-| the menu (`C-c C-c C-f') (for the architecture the cursor is in) or from
-| the speedbar menu (for the architecture under the cursor). The
-| configurations can optionally be hierarchical (i.e. include all
-| component levels of a hierarchical design, option
-| `vhdl-compose-configuration-hierarchical') or include subconfigurations
-| (option `vhdl-compose-configuration-use-subconfiguration'). For
-| subcomponents in hierarchical configurations, the most-recently-analyzed
-| (mra) architecture is selected. If another architecture is desired, it
-| can be marked as most-recently-analyzed (speedbar menu) before
-| generating the configuration.
-|
-| Note: Configurations of subcomponents (i.e. hierarchical configuration
-| declarations) are currently not considered when displaying
-| configurations in speedbar.
+ Configuration declarations can automatically be generated either from
+ the menu (`C-c C-m C-f') (for the architecture the cursor is in) or from
+ the speedbar menu (for the architecture under the cursor). The
+ configurations can optionally be hierarchical (i.e. include all
+ component levels of a hierarchical design, option
+ `vhdl-compose-configuration-hierarchical') or include subconfigurations
+ (option `vhdl-compose-configuration-use-subconfiguration'). For
+ subcomponents in hierarchical configurations, the most-recently-analyzed
+ (mra) architecture is selected. If another architecture is desired, it
+ can be marked as most-recently-analyzed (speedbar menu) before
+ generating the configuration.
+
+ Note: Configurations of subcomponents (i.e. hierarchical configuration
+ declarations) are currently not considered when displaying
+ configurations in speedbar.
See the options group `vhdl-compose' for all relevant user options.
The Makefile's default target \"all\" compiles the entire design, the
target \"clean\" removes it and the target \"library\" creates the
- library directory if not existent. The Makefile also includes a target
- for each primary library unit which allows selective compilation of this
- unit, its secondary units and its subhierarchy (example: compilation of
- a design specified by a configuration). User specific parts can be
- inserted into a Makefile with option `vhdl-makefile-generation-hook'.
+ library directory if not existent. These target names can be customized
+ by option `vhdl-makefile-default-targets'. The Makefile also includes a
+ target for each primary library unit which allows selective compilation
+ of this unit, its secondary units and its subhierarchy (example:
+ compilation of a design specified by a configuration). User specific
+ parts can be inserted into a Makefile with option
+ `vhdl-makefile-generation-hook'.
Limitations:
- Only library units and dependencies within the current library are
VHDL STANDARDS:
The VHDL standards to be used are specified in option `vhdl-standard'.
- Available standards are: VHDL'87/'93, VHDL-AMS, and Math Packages.
+ Available standards are: VHDL'87/'93(02), VHDL-AMS, and Math Packages.
KEYWORD CASE:
- Out parameters of procedures are considered to be read.
Use option `vhdl-entity-file-name' to specify the entity file name
(used to obtain the port names).
+ Use option `vhdl-array-index-record-field-in-sensitivity-list' to
+ specify whether to include array indices and record fields in
+ sensitivity lists.
CODE FIXING:
PRINTING:
- Postscript printing with different faces (an optimized set of faces is
+ PostScript printing with different faces (an optimized set of faces is
used if `vhdl-print-customize-faces' is non-nil) or colors (if
`ps-print-color-p' is non-nil) is possible using the standard Emacs
- postscript printing commands. Option `vhdl-print-two-column' defines
+ PostScript printing commands. Option `vhdl-print-two-column' defines
appropriate default settings for nice landscape two-column printing.
The paper format can be set by option `ps-paper-type'. Do not forget to
switch `ps-print-color-p' to nil for printing on black-and-white
to above mailing lists by sending an email to <reto@gnu.org>.
VHDL Mode is officially distributed at
-URL `http://opensource.ethz.ch/emacs/vhdl-mode.html'
+http://www.iis.ee.ethz.ch/~zimmi/emacs/vhdl-mode.html
where the latest version can be found.
Known problems:
---------------
-- Indentation bug in simultaneous if- and case-statements (VHDL-AMS).
- XEmacs: Incorrect start-up when automatically opening speedbar.
- XEmacs: Indentation in XEmacs 21.4 (and higher).
+- Indentation incorrect for new 'postponed' VHDL keyword.
+- Indentation incorrect for 'protected body' construct.
The VHDL Mode Authors
;;;***
\f
-;;;### (autoloads (vi-mode) "vi" "emulation/vi.el" (19845 45374))
+;;;### (autoloads (vi-mode) "vi" "emulation/vi.el" (20107 60012))
;;; Generated autoloads from emulation/vi.el
(autoload 'vi-mode "vi" "\
;;;### (autoloads (viqr-pre-write-conversion viqr-post-read-conversion
;;;;;; viet-encode-viqr-buffer viet-encode-viqr-region viet-decode-viqr-buffer
;;;;;; viet-decode-viqr-region viet-encode-viscii-char) "viet-util"
-;;;;;; "language/viet-util.el" (19845 45374))
+;;;;;; "language/viet-util.el" (20244 35516))
;;; Generated autoloads from language/viet-util.el
(autoload 'viet-encode-viscii-char "viet-util" "\
;;;;;; view-mode view-buffer-other-frame view-buffer-other-window
;;;;;; view-buffer view-file-other-frame view-file-other-window
;;;;;; view-file kill-buffer-if-not-modified view-remove-frame-by-deleting)
-;;;;;; "view" "view.el" (20053 39261))
+;;;;;; "view" "view.el" (20331 12564))
;;; Generated autoloads from view.el
(defvar view-remove-frame-by-deleting t "\
Exiting View mode will then discard the user's edits. Setting
EXIT-ACTION to `kill-buffer-if-not-modified' avoids this.
+This function does not enable View mode if the buffer's major-mode
+has a `special' mode-class, because such modes usually have their
+own View-like bindings.
+
\(fn BUFFER &optional EXIT-ACTION)" t nil)
(autoload 'view-buffer-other-window "view" "\
argument. This function is called when finished viewing buffer. Use
this argument instead of explicitly setting `view-exit-action'.
+This function does not enable View mode if the buffer's major-mode
+has a `special' mode-class, because such modes usually have their
+own View-like bindings.
+
\(fn BUFFER &optional NOT-RETURN EXIT-ACTION)" t nil)
(autoload 'view-buffer-other-frame "view" "\
argument. This function is called when finished viewing buffer. Use
this argument instead of explicitly setting `view-exit-action'.
+This function does not enable View mode if the buffer's major-mode
+has a `special' mode-class, because such modes usually have their
+own View-like bindings.
+
\(fn BUFFER &optional NOT-RETURN EXIT-ACTION)" t nil)
(autoload 'view-mode "view" "\
Toggle View mode, a minor mode for viewing text but not editing it.
-With prefix argument ARG, turn View mode on if ARG is positive, otherwise
-turn it off.
+With a prefix argument ARG, enable View mode if ARG is positive,
+and disable it otherwise. If called from Lisp, enable View mode
+if ARG is omitted or nil.
+
+When View mode is enabled, commands that do not change the buffer
+contents are available as usual. Kill commands insert text in
+kill buffers but do not delete. Most other commands beep and
+tell the user that the buffer is read-only.
-Emacs commands that do not change the buffer contents are available as usual.
-Kill commands insert text in kill buffers but do not delete. Other commands
-\(among them most letters and punctuation) beep and tell that the buffer is
-read-only.
\\<view-mode-map>
-The following additional commands are provided. Most commands take prefix
-arguments. Page commands default to \"page size\" lines which is almost a whole
-window full, or number of lines set by \\[View-scroll-page-forward-set-page-size] or \\[View-scroll-page-backward-set-page-size]. Half page commands default to
-and set \"half page size\" lines which initially is half a window full. Search
-commands default to a repeat count of one.
+
+The following additional commands are provided. Most commands
+take prefix arguments. Page commands default to \"page size\"
+lines which is almost a whole window, or number of lines set by
+\\[View-scroll-page-forward-set-page-size] or \\[View-scroll-page-backward-set-page-size].
+Half page commands default to and set \"half page size\" lines
+which initially is half a window full. Search commands default
+to a repeat count of one.
H, h, ? This message.
Digits provide prefix arguments.
Update `view-return-to-alist' of buffer BUFFER.
Remove from `view-return-to-alist' all entries referencing dead
windows. Optional argument ITEM non-nil means add ITEM to
-`view-return-to-alist' after purging. For a decsription of items
+`view-return-to-alist' after purging. For a description of items
that can be added see the RETURN-TO-ALIST argument of the
function `view-mode-exit'. If `view-return-to-alist' contains an
entry for the selected window, purge that entry from
;;;***
\f
-;;;### (autoloads (vip-mode vip-setup) "vip" "emulation/vip.el" (19845
-;;;;;; 45374))
+;;;### (autoloads (vip-mode vip-setup) "vip" "emulation/vip.el" (20244
+;;;;;; 35516))
;;; Generated autoloads from emulation/vip.el
(autoload 'vip-setup "vip" "\
;;;***
\f
;;;### (autoloads (viper-mode toggle-viper-mode) "viper" "emulation/viper.el"
-;;;;;; (19931 11784))
+;;;;;; (20356 35090))
;;; Generated autoloads from emulation/viper.el
(autoload 'toggle-viper-mode "viper" "\
;;;***
\f
;;;### (autoloads (warn lwarn display-warning) "warnings" "emacs-lisp/warnings.el"
-;;;;;; (19906 31087))
+;;;;;; (20244 35516))
;;; Generated autoloads from emacs-lisp/warnings.el
(defvar warning-prefix-function nil "\
;;;***
\f
;;;### (autoloads (wdired-change-to-wdired-mode) "wdired" "wdired.el"
-;;;;;; (19913 4309))
+;;;;;; (20452 43334))
;;; Generated autoloads from wdired.el
(autoload 'wdired-change-to-wdired-mode "wdired" "\
;;;***
\f
-;;;### (autoloads (webjump) "webjump" "net/webjump.el" (19931 11784))
+;;;### (autoloads (webjump) "webjump" "net/webjump.el" (20356 35090))
;;; Generated autoloads from net/webjump.el
(autoload 'webjump "webjump" "\
;;;***
\f
-;;;### (autoloads (which-function-mode) "which-func" "progmodes/which-func.el"
-;;;;;; (19988 13913))
+;;;### (autoloads (which-function-mode which-func-mode) "which-func"
+;;;;;; "progmodes/which-func.el" (20428 57510))
;;; Generated autoloads from progmodes/which-func.el
(put 'which-func-format 'risky-local-variable t)
(put 'which-func-current 'risky-local-variable t)
-(defalias 'which-func-mode 'which-function-mode)
+(autoload 'which-func-mode "which-func" "\
+
+
+\(fn &optional ARG)" nil nil)
(defvar which-function-mode nil "\
Non-nil if Which-Function mode is enabled.
(custom-autoload 'which-function-mode "which-func" nil)
(autoload 'which-function-mode "which-func" "\
-Toggle Which Function mode, globally.
-When Which Function mode is enabled, the current function name is
-continuously displayed in the mode line, in certain major modes.
+Toggle mode line display of current function (Which Function mode).
+With a prefix argument ARG, enable Which Function mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+the mode if ARG is omitted or nil.
-With prefix ARG, turn Which Function mode on if arg is positive,
-and off otherwise.
+Which Function mode is a global minor mode. When enabled, the
+current function name is continuously displayed in the mode line,
+in certain major modes.
\(fn &optional ARG)" t nil)
;;;### (autoloads (whitespace-report-region whitespace-report whitespace-cleanup-region
;;;;;; whitespace-cleanup global-whitespace-toggle-options whitespace-toggle-options
;;;;;; global-whitespace-newline-mode global-whitespace-mode whitespace-newline-mode
-;;;;;; whitespace-mode) "whitespace" "whitespace.el" (19905 10215))
+;;;;;; whitespace-mode) "whitespace" "whitespace.el" (20434 28080))
;;; Generated autoloads from whitespace.el
(autoload 'whitespace-mode "whitespace" "\
-Toggle whitespace minor mode visualization (\"ws\" on modeline).
-
-If ARG is null, toggle whitespace visualization.
-If ARG is a number greater than zero, turn on visualization;
-otherwise, turn off visualization.
+Toggle whitespace visualization (Whitespace mode).
+With a prefix argument ARG, enable Whitespace mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+the mode if ARG is omitted or nil.
See also `whitespace-style', `whitespace-newline' and
`whitespace-display-mappings'.
\(fn &optional ARG)" t nil)
(autoload 'whitespace-newline-mode "whitespace" "\
-Toggle NEWLINE minor mode visualization (\"nl\" on modeline).
-
-If ARG is null, toggle NEWLINE visualization.
-If ARG is a number greater than zero, turn on visualization;
-otherwise, turn off visualization.
+Toggle newline visualization (Whitespace Newline mode).
+With a prefix argument ARG, enable Whitespace Newline mode if ARG
+is positive, and disable it otherwise. If called from Lisp,
+enable the mode if ARG is omitted or nil.
Use `whitespace-newline-mode' only for NEWLINE visualization
exclusively. For other visualizations, including NEWLINE
(custom-autoload 'global-whitespace-mode "whitespace" nil)
(autoload 'global-whitespace-mode "whitespace" "\
-Toggle whitespace global minor mode visualization (\"WS\" on modeline).
-
-If ARG is null, toggle whitespace visualization.
-If ARG is a number greater than zero, turn on visualization;
-otherwise, turn off visualization.
+Toggle whitespace visualization globally (Global Whitespace mode).
+With a prefix argument ARG, enable Global Whitespace mode if ARG
+is positive, and disable it otherwise. If called from Lisp,
+enable it if ARG is omitted or nil.
See also `whitespace-style', `whitespace-newline' and
`whitespace-display-mappings'.
(custom-autoload 'global-whitespace-newline-mode "whitespace" nil)
(autoload 'global-whitespace-newline-mode "whitespace" "\
-Toggle NEWLINE global minor mode visualization (\"NL\" on modeline).
-
-If ARG is null, toggle NEWLINE visualization.
-If ARG is a number greater than zero, turn on visualization;
-otherwise, turn off visualization.
+Toggle global newline visualization (Global Whitespace Newline mode).
+With a prefix argument ARG, enable Global Whitespace Newline mode
+if ARG is positive, and disable it otherwise. If called from
+Lisp, enable it if ARG is omitted or nil.
Use `global-whitespace-newline-mode' only for NEWLINE
visualization exclusively. For other visualizations, including
;;;***
\f
;;;### (autoloads (widget-minor-mode widget-browse-other-window widget-browse
-;;;;;; widget-browse-at) "wid-browse" "wid-browse.el" (19886 45771))
+;;;;;; widget-browse-at) "wid-browse" "wid-browse.el" (20276 3849))
;;; Generated autoloads from wid-browse.el
(autoload 'widget-browse-at "wid-browse" "\
\(fn &optional WIDGET)" t nil)
(autoload 'widget-minor-mode "wid-browse" "\
-Togle minor mode for traversing widgets.
-With arg, turn widget mode on if and only if arg is positive.
+Minor mode for traversing widgets.
+With a prefix argument ARG, enable the mode if ARG is positive,
+and disable it otherwise. If called from Lisp, enable the mode
+if ARG is omitted or nil.
\(fn &optional ARG)" t nil)
;;;***
\f
;;;### (autoloads (widget-setup widget-insert widget-delete widget-create
-;;;;;; widget-prompt-value widgetp) "wid-edit" "wid-edit.el" (19968
-;;;;;; 28627))
+;;;;;; widget-prompt-value widgetp) "wid-edit" "wid-edit.el" (20373
+;;;;;; 41604))
;;; Generated autoloads from wid-edit.el
(autoload 'widgetp "wid-edit" "\
;;;***
\f
;;;### (autoloads (windmove-default-keybindings windmove-down windmove-right
-;;;;;; windmove-up windmove-left) "windmove" "windmove.el" (19886
-;;;;;; 45771))
+;;;;;; windmove-up windmove-left) "windmove" "windmove.el" (20253
+;;;;;; 50954))
;;; Generated autoloads from windmove.el
(autoload 'windmove-left "windmove" "\
;;;***
\f
;;;### (autoloads (winner-mode winner-mode) "winner" "winner.el"
-;;;;;; (19998 49767))
+;;;;;; (20452 43334))
;;; Generated autoloads from winner.el
(defvar winner-mode nil "\
;;;***
\f
;;;### (autoloads (woman-bookmark-jump woman-find-file woman-dired-find-file
-;;;;;; woman woman-locale) "woman" "woman.el" (19981 40664))
+;;;;;; woman woman-locale) "woman" "woman.el" (20373 41604))
;;; Generated autoloads from woman.el
(defvar woman-locale nil "\
;;;***
\f
;;;### (autoloads (wordstar-mode) "ws-mode" "emulation/ws-mode.el"
-;;;;;; (19845 45374))
+;;;;;; (20331 12564))
;;; Generated autoloads from emulation/ws-mode.el
(autoload 'wordstar-mode "ws-mode" "\
C-o r set-fill-column
C-o C-u keyboard-quit
C-o wd delete-other-windows
- C-o wh split-window-horizontally
+ C-o wh split-window-right
C-o wo other-window
- C-o wv split-window-vertically
+ C-o wv split-window-below
C-q 0 ws-find-marker-0
C-q 1 ws-find-marker-1
;;;***
\f
-;;;### (autoloads (xesam-search) "xesam" "net/xesam.el" (19845 45374))
+;;;### (autoloads (xesam-search) "xesam" "net/xesam.el" (20373 41604))
;;; Generated autoloads from net/xesam.el
(autoload 'xesam-search "xesam" "\
;;;***
\f
;;;### (autoloads (xml-parse-region xml-parse-file) "xml" "xml.el"
-;;;;;; (19886 45771))
+;;;;;; (20380 26775))
;;; Generated autoloads from xml.el
(autoload 'xml-parse-file "xml" "\
;;;***
\f
;;;### (autoloads (xmltok-get-declared-encoding-position) "xmltok"
-;;;;;; "nxml/xmltok.el" (19845 45374))
+;;;;;; "nxml/xmltok.el" (20244 35516))
;;; Generated autoloads from nxml/xmltok.el
(autoload 'xmltok-get-declared-encoding-position "xmltok" "\
;;;***
\f
-;;;### (autoloads (xterm-mouse-mode) "xt-mouse" "xt-mouse.el" (20034
-;;;;;; 23247))
+;;;### (autoloads (xterm-mouse-mode) "xt-mouse" "xt-mouse.el" (20244
+;;;;;; 35516))
;;; Generated autoloads from xt-mouse.el
(defvar xterm-mouse-mode nil "\
(autoload 'xterm-mouse-mode "xt-mouse" "\
Toggle XTerm mouse mode.
-With prefix arg, turn XTerm mouse mode on if arg is positive, otherwise turn
-it off.
+With a prefix argument ARG, enable XTerm mouse mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+the mode if ARG is omitted or nil.
Turn it on to use Emacs mouse commands, and off to use xterm mouse commands.
This works in terminal emulators compatible with xterm. It only
;;;***
\f
;;;### (autoloads (yenc-extract-filename yenc-decode-region) "yenc"
-;;;;;; "gnus/yenc.el" (19845 45374))
+;;;;;; "gnus/yenc.el" (20244 35516))
;;; Generated autoloads from gnus/yenc.el
(autoload 'yenc-decode-region "yenc" "\
;;;***
\f
;;;### (autoloads (psychoanalyze-pinhead apropos-zippy insert-zippyism
-;;;;;; yow) "yow" "play/yow.el" (19845 45374))
+;;;;;; yow) "yow" "play/yow.el" (20373 41604))
;;; Generated autoloads from play/yow.el
(autoload 'yow "yow" "\
;;;***
\f
-;;;### (autoloads (zone) "zone" "play/zone.el" (19889 21967))
+;;;### (autoloads (zone) "zone" "play/zone.el" (20428 57510))
;;; Generated autoloads from play/zone.el
(autoload 'zone "zone" "\
;;;;;; "cedet/ede/proj-shared.el" "cedet/ede/proj.el" "cedet/ede/project-am.el"
;;;;;; "cedet/ede/shell.el" "cedet/ede/simple.el" "cedet/ede/source.el"
;;;;;; "cedet/ede/speedbar.el" "cedet/ede/srecode.el" "cedet/ede/system.el"
-;;;;;; "cedet/ede/util.el" "cedet/inversion.el" "cedet/mode-local.el"
-;;;;;; "cedet/pulse.el" "cedet/semantic/analyze.el" "cedet/semantic/analyze/complete.el"
+;;;;;; "cedet/ede/util.el" "cedet/inversion.el" "cedet/pulse.el"
+;;;;;; "cedet/semantic/analyze.el" "cedet/semantic/analyze/complete.el"
;;;;;; "cedet/semantic/analyze/debug.el" "cedet/semantic/analyze/fcn.el"
;;;;;; "cedet/semantic/analyze/refs.el" "cedet/semantic/bovine.el"
;;;;;; "cedet/semantic/bovine/c-by.el" "cedet/semantic/bovine/c.el"
;;;;;; "cedet/srecode/loaddefs.el" "cedet/srecode/map.el" "cedet/srecode/mode.el"
;;;;;; "cedet/srecode/semantic.el" "cedet/srecode/srt-wy.el" "cedet/srecode/srt.el"
;;;;;; "cedet/srecode/table.el" "cedet/srecode/template.el" "cedet/srecode/texi.el"
-;;;;;; "cus-dep.el" "dframe.el" "dired-aux.el" "dired-x.el" "dos-fns.el"
-;;;;;; "dos-vars.el" "dos-w32.el" "dynamic-setting.el" "emacs-lisp/assoc.el"
+;;;;;; "cus-dep.el" "cus-load.el" "dframe.el" "dired-aux.el" "dired-x.el"
+;;;;;; "dos-fns.el" "dos-vars.el" "dos-w32.el" "dynamic-setting.el"
;;;;;; "emacs-lisp/authors.el" "emacs-lisp/avl-tree.el" "emacs-lisp/bindat.el"
;;;;;; "emacs-lisp/byte-opt.el" "emacs-lisp/chart.el" "emacs-lisp/cl-extra.el"
;;;;;; "emacs-lisp/cl-loaddefs.el" "emacs-lisp/cl-macs.el" "emacs-lisp/cl-seq.el"
-;;;;;; "emacs-lisp/cl-specs.el" "emacs-lisp/cust-print.el" "emacs-lisp/eieio-base.el"
-;;;;;; "emacs-lisp/eieio-custom.el" "emacs-lisp/eieio-datadebug.el"
-;;;;;; "emacs-lisp/eieio-opt.el" "emacs-lisp/eieio-speedbar.el"
-;;;;;; "emacs-lisp/eieio.el" "emacs-lisp/find-gc.el" "emacs-lisp/gulp.el"
-;;;;;; "emacs-lisp/lisp-mnt.el" "emacs-lisp/package-x.el" "emacs-lisp/regi.el"
-;;;;;; "emacs-lisp/smie.el" "emacs-lisp/tcover-ses.el" "emacs-lisp/tcover-unsafep.el"
-;;;;;; "emulation/cua-gmrk.el" "emulation/cua-rect.el" "emulation/edt-lk201.el"
-;;;;;; "emulation/edt-mapper.el" "emulation/edt-pc.el" "emulation/edt-vt100.el"
-;;;;;; "emulation/tpu-extras.el" "emulation/viper-cmd.el" "emulation/viper-ex.el"
-;;;;;; "emulation/viper-init.el" "emulation/viper-keym.el" "emulation/viper-macs.el"
-;;;;;; "emulation/viper-mous.el" "emulation/viper-util.el" "erc/erc-backend.el"
-;;;;;; "erc/erc-goodies.el" "erc/erc-ibuffer.el" "erc/erc-lang.el"
-;;;;;; "eshell/em-alias.el" "eshell/em-banner.el" "eshell/em-basic.el"
-;;;;;; "eshell/em-cmpl.el" "eshell/em-dirs.el" "eshell/em-glob.el"
-;;;;;; "eshell/em-hist.el" "eshell/em-ls.el" "eshell/em-pred.el"
-;;;;;; "eshell/em-prompt.el" "eshell/em-rebind.el" "eshell/em-script.el"
-;;;;;; "eshell/em-smart.el" "eshell/em-term.el" "eshell/em-unix.el"
-;;;;;; "eshell/em-xtra.el" "eshell/esh-arg.el" "eshell/esh-cmd.el"
-;;;;;; "eshell/esh-ext.el" "eshell/esh-groups.el" "eshell/esh-io.el"
-;;;;;; "eshell/esh-module.el" "eshell/esh-opt.el" "eshell/esh-proc.el"
-;;;;;; "eshell/esh-util.el" "eshell/esh-var.el" "ezimage.el" "foldout.el"
-;;;;;; "format-spec.el" "forms-d2.el" "forms-pass.el" "fringe.el"
-;;;;;; "generic-x.el" "gnus/compface.el" "gnus/gnus-async.el" "gnus/gnus-bcklg.el"
-;;;;;; "gnus/gnus-cite.el" "gnus/gnus-cus.el" "gnus/gnus-demon.el"
-;;;;;; "gnus/gnus-dup.el" "gnus/gnus-eform.el" "gnus/gnus-ems.el"
-;;;;;; "gnus/gnus-int.el" "gnus/gnus-logic.el" "gnus/gnus-mh.el"
-;;;;;; "gnus/gnus-salt.el" "gnus/gnus-score.el" "gnus/gnus-setup.el"
-;;;;;; "gnus/gnus-srvr.el" "gnus/gnus-topic.el" "gnus/gnus-undo.el"
-;;;;;; "gnus/gnus-util.el" "gnus/gnus-uu.el" "gnus/gnus-vm.el" "gnus/gssapi.el"
-;;;;;; "gnus/ietf-drums.el" "gnus/legacy-gnus-agent.el" "gnus/mail-parse.el"
-;;;;;; "gnus/mail-prsvr.el" "gnus/mail-source.el" "gnus/mailcap.el"
-;;;;;; "gnus/messcompat.el" "gnus/mm-bodies.el" "gnus/mm-decode.el"
-;;;;;; "gnus/mm-encode.el" "gnus/mm-util.el" "gnus/mm-view.el" "gnus/mml-sec.el"
-;;;;;; "gnus/mml-smime.el" "gnus/mml.el" "gnus/nnagent.el" "gnus/nnbabyl.el"
-;;;;;; "gnus/nndir.el" "gnus/nndraft.el" "gnus/nneething.el" "gnus/nngateway.el"
+;;;;;; "emacs-lisp/cl.el" "emacs-lisp/eieio-base.el" "emacs-lisp/eieio-custom.el"
+;;;;;; "emacs-lisp/eieio-datadebug.el" "emacs-lisp/eieio-opt.el"
+;;;;;; "emacs-lisp/eieio-speedbar.el" "emacs-lisp/eieio.el" "emacs-lisp/find-gc.el"
+;;;;;; "emacs-lisp/gulp.el" "emacs-lisp/lisp-mnt.el" "emacs-lisp/package-x.el"
+;;;;;; "emacs-lisp/regi.el" "emacs-lisp/smie.el" "emacs-lisp/tcover-ses.el"
+;;;;;; "emacs-lisp/tcover-unsafep.el" "emulation/cua-gmrk.el" "emulation/cua-rect.el"
+;;;;;; "emulation/edt-lk201.el" "emulation/edt-mapper.el" "emulation/edt-pc.el"
+;;;;;; "emulation/edt-vt100.el" "emulation/tpu-extras.el" "emulation/viper-cmd.el"
+;;;;;; "emulation/viper-ex.el" "emulation/viper-init.el" "emulation/viper-keym.el"
+;;;;;; "emulation/viper-macs.el" "emulation/viper-mous.el" "emulation/viper-util.el"
+;;;;;; "erc/erc-backend.el" "erc/erc-goodies.el" "erc/erc-ibuffer.el"
+;;;;;; "erc/erc-lang.el" "eshell/em-alias.el" "eshell/em-banner.el"
+;;;;;; "eshell/em-basic.el" "eshell/em-cmpl.el" "eshell/em-dirs.el"
+;;;;;; "eshell/em-glob.el" "eshell/em-hist.el" "eshell/em-ls.el"
+;;;;;; "eshell/em-pred.el" "eshell/em-prompt.el" "eshell/em-rebind.el"
+;;;;;; "eshell/em-script.el" "eshell/em-smart.el" "eshell/em-term.el"
+;;;;;; "eshell/em-unix.el" "eshell/em-xtra.el" "eshell/esh-arg.el"
+;;;;;; "eshell/esh-cmd.el" "eshell/esh-ext.el" "eshell/esh-groups.el"
+;;;;;; "eshell/esh-io.el" "eshell/esh-module.el" "eshell/esh-opt.el"
+;;;;;; "eshell/esh-proc.el" "eshell/esh-util.el" "eshell/esh-var.el"
+;;;;;; "ezimage.el" "finder-inf.el" "foldout.el" "format-spec.el"
+;;;;;; "fringe.el" "generic-x.el" "gnus/compface.el" "gnus/gnus-async.el"
+;;;;;; "gnus/gnus-bcklg.el" "gnus/gnus-cite.el" "gnus/gnus-cus.el"
+;;;;;; "gnus/gnus-demon.el" "gnus/gnus-dup.el" "gnus/gnus-eform.el"
+;;;;;; "gnus/gnus-ems.el" "gnus/gnus-int.el" "gnus/gnus-logic.el"
+;;;;;; "gnus/gnus-mh.el" "gnus/gnus-salt.el" "gnus/gnus-score.el"
+;;;;;; "gnus/gnus-setup.el" "gnus/gnus-srvr.el" "gnus/gnus-topic.el"
+;;;;;; "gnus/gnus-undo.el" "gnus/gnus-util.el" "gnus/gnus-uu.el"
+;;;;;; "gnus/gnus-vm.el" "gnus/gssapi.el" "gnus/ietf-drums.el" "gnus/legacy-gnus-agent.el"
+;;;;;; "gnus/mail-parse.el" "gnus/mail-prsvr.el" "gnus/mail-source.el"
+;;;;;; "gnus/mailcap.el" "gnus/messcompat.el" "gnus/mm-bodies.el"
+;;;;;; "gnus/mm-decode.el" "gnus/mm-util.el" "gnus/mm-view.el" "gnus/mml-sec.el"
+;;;;;; "gnus/mml-smime.el" "gnus/nnagent.el" "gnus/nnbabyl.el" "gnus/nndir.el"
+;;;;;; "gnus/nndraft.el" "gnus/nneething.el" "gnus/nngateway.el"
;;;;;; "gnus/nnheader.el" "gnus/nnimap.el" "gnus/nnir.el" "gnus/nnmail.el"
;;;;;; "gnus/nnmaildir.el" "gnus/nnmairix.el" "gnus/nnmbox.el" "gnus/nnmh.el"
;;;;;; "gnus/nnnil.el" "gnus/nnoo.el" "gnus/nnregistry.el" "gnus/nnrss.el"
;;;;;; "international/uni-old-name.el" "international/uni-titlecase.el"
;;;;;; "international/uni-uppercase.el" "json.el" "kermit.el" "language/hanja-util.el"
;;;;;; "language/thai-word.el" "ldefs-boot.el" "loadup.el" "mail/blessmail.el"
-;;;;;; "mail/mailheader.el" "mail/mailpost.el" "mail/mspools.el"
-;;;;;; "mail/rfc2368.el" "mail/rfc822.el" "mail/rmail-spam-filter.el"
-;;;;;; "mail/rmailedit.el" "mail/rmailkwd.el" "mail/rmailmm.el"
-;;;;;; "mail/rmailmsc.el" "mail/rmailsort.el" "mail/rmailsum.el"
-;;;;;; "mail/undigest.el" "md4.el" "mh-e/mh-acros.el" "mh-e/mh-alias.el"
-;;;;;; "mh-e/mh-buffers.el" "mh-e/mh-compat.el" "mh-e/mh-funcs.el"
-;;;;;; "mh-e/mh-gnus.el" "mh-e/mh-identity.el" "mh-e/mh-inc.el"
-;;;;;; "mh-e/mh-junk.el" "mh-e/mh-letter.el" "mh-e/mh-limit.el"
+;;;;;; "mail/mailheader.el" "mail/mspools.el" "mail/rfc2368.el"
+;;;;;; "mail/rfc822.el" "mail/rmail-spam-filter.el" "mail/rmailedit.el"
+;;;;;; "mail/rmailkwd.el" "mail/rmailmm.el" "mail/rmailmsc.el" "mail/rmailsort.el"
+;;;;;; "mail/rmailsum.el" "mail/undigest.el" "md4.el" "mh-e/mh-acros.el"
+;;;;;; "mh-e/mh-alias.el" "mh-e/mh-buffers.el" "mh-e/mh-compat.el"
+;;;;;; "mh-e/mh-funcs.el" "mh-e/mh-gnus.el" "mh-e/mh-identity.el"
+;;;;;; "mh-e/mh-inc.el" "mh-e/mh-junk.el" "mh-e/mh-letter.el" "mh-e/mh-limit.el"
;;;;;; "mh-e/mh-loaddefs.el" "mh-e/mh-mime.el" "mh-e/mh-print.el"
;;;;;; "mh-e/mh-scan.el" "mh-e/mh-search.el" "mh-e/mh-seq.el" "mh-e/mh-show.el"
;;;;;; "mh-e/mh-speed.el" "mh-e/mh-thread.el" "mh-e/mh-tool-bar.el"
;;;;;; "nxml/xsd-regexp.el" "org/ob-C.el" "org/ob-R.el" "org/ob-asymptote.el"
;;;;;; "org/ob-awk.el" "org/ob-calc.el" "org/ob-clojure.el" "org/ob-comint.el"
;;;;;; "org/ob-css.el" "org/ob-ditaa.el" "org/ob-dot.el" "org/ob-emacs-lisp.el"
-;;;;;; "org/ob-eval.el" "org/ob-exp.el" "org/ob-gnuplot.el" "org/ob-haskell.el"
-;;;;;; "org/ob-java.el" "org/ob-js.el" "org/ob-latex.el" "org/ob-ledger.el"
-;;;;;; "org/ob-lilypond.el" "org/ob-lisp.el" "org/ob-matlab.el"
-;;;;;; "org/ob-maxima.el" "org/ob-mscgen.el" "org/ob-ocaml.el" "org/ob-octave.el"
-;;;;;; "org/ob-org.el" "org/ob-perl.el" "org/ob-plantuml.el" "org/ob-python.el"
+;;;;;; "org/ob-eval.el" "org/ob-exp.el" "org/ob-fortran.el" "org/ob-gnuplot.el"
+;;;;;; "org/ob-haskell.el" "org/ob-java.el" "org/ob-js.el" "org/ob-latex.el"
+;;;;;; "org/ob-ledger.el" "org/ob-lilypond.el" "org/ob-lisp.el"
+;;;;;; "org/ob-matlab.el" "org/ob-maxima.el" "org/ob-mscgen.el"
+;;;;;; "org/ob-ocaml.el" "org/ob-octave.el" "org/ob-org.el" "org/ob-perl.el"
+;;;;;; "org/ob-picolisp.el" "org/ob-plantuml.el" "org/ob-python.el"
;;;;;; "org/ob-ref.el" "org/ob-ruby.el" "org/ob-sass.el" "org/ob-scheme.el"
-;;;;;; "org/ob-screen.el" "org/ob-sh.el" "org/ob-sql.el" "org/ob-sqlite.el"
-;;;;;; "org/ob-table.el" "org/org-beamer.el" "org/org-bibtex.el"
-;;;;;; "org/org-colview.el" "org/org-compat.el" "org/org-crypt.el"
-;;;;;; "org/org-ctags.el" "org/org-docview.el" "org/org-entities.el"
-;;;;;; "org/org-exp-blocks.el" "org/org-faces.el" "org/org-gnus.el"
-;;;;;; "org/org-habit.el" "org/org-info.el" "org/org-inlinetask.el"
-;;;;;; "org/org-install.el" "org/org-jsinfo.el" "org/org-list.el"
-;;;;;; "org/org-mac-message.el" "org/org-macs.el" "org/org-mew.el"
-;;;;;; "org/org-mhe.el" "org/org-mks.el" "org/org-mouse.el" "org/org-pcomplete.el"
-;;;;;; "org/org-protocol.el" "org/org-rmail.el" "org/org-special-blocks.el"
-;;;;;; "org/org-src.el" "org/org-vm.el" "org/org-w3m.el" "org/org-wl.el"
-;;;;;; "patcomp.el" "play/gamegrid.el" "play/gametree.el" "play/meese.el"
-;;;;;; "progmodes/ada-prj.el" "progmodes/cc-align.el" "progmodes/cc-awk.el"
-;;;;;; "progmodes/cc-bytecomp.el" "progmodes/cc-cmds.el" "progmodes/cc-defs.el"
-;;;;;; "progmodes/cc-fonts.el" "progmodes/cc-langs.el" "progmodes/cc-menus.el"
-;;;;;; "progmodes/ebnf-abn.el" "progmodes/ebnf-bnf.el" "progmodes/ebnf-dtd.el"
-;;;;;; "progmodes/ebnf-ebx.el" "progmodes/ebnf-iso.el" "progmodes/ebnf-otz.el"
-;;;;;; "progmodes/ebnf-yac.el" "progmodes/idlw-complete-structtag.el"
+;;;;;; "org/ob-screen.el" "org/ob-sh.el" "org/ob-shen.el" "org/ob-sql.el"
+;;;;;; "org/ob-sqlite.el" "org/ob-table.el" "org/org-beamer.el"
+;;;;;; "org/org-bibtex.el" "org/org-colview.el" "org/org-compat.el"
+;;;;;; "org/org-crypt.el" "org/org-ctags.el" "org/org-docview.el"
+;;;;;; "org/org-entities.el" "org/org-eshell.el" "org/org-exp-blocks.el"
+;;;;;; "org/org-faces.el" "org/org-gnus.el" "org/org-habit.el" "org/org-info.el"
+;;;;;; "org/org-inlinetask.el" "org/org-install.el" "org/org-jsinfo.el"
+;;;;;; "org/org-list.el" "org/org-mac-message.el" "org/org-macs.el"
+;;;;;; "org/org-mew.el" "org/org-mhe.el" "org/org-mks.el" "org/org-mouse.el"
+;;;;;; "org/org-pcomplete.el" "org/org-protocol.el" "org/org-rmail.el"
+;;;;;; "org/org-special-blocks.el" "org/org-src.el" "org/org-vm.el"
+;;;;;; "org/org-w3m.el" "org/org-wl.el" "play/gamegrid.el" "play/gametree.el"
+;;;;;; "play/meese.el" "progmodes/ada-prj.el" "progmodes/cc-align.el"
+;;;;;; "progmodes/cc-awk.el" "progmodes/cc-bytecomp.el" "progmodes/cc-cmds.el"
+;;;;;; "progmodes/cc-defs.el" "progmodes/cc-fonts.el" "progmodes/cc-langs.el"
+;;;;;; "progmodes/cc-menus.el" "progmodes/ebnf-abn.el" "progmodes/ebnf-bnf.el"
+;;;;;; "progmodes/ebnf-dtd.el" "progmodes/ebnf-ebx.el" "progmodes/ebnf-iso.el"
+;;;;;; "progmodes/ebnf-otz.el" "progmodes/ebnf-yac.el" "progmodes/idlw-complete-structtag.el"
;;;;;; "progmodes/idlw-help.el" "progmodes/idlw-toolbar.el" "progmodes/mantemp.el"
;;;;;; "progmodes/xscheme.el" "ps-def.el" "ps-mule.el" "ps-samp.el"
;;;;;; "saveplace.el" "sb-image.el" "scroll-bar.el" "select.el"
;;;;;; "textmodes/reftex-ref.el" "textmodes/reftex-sel.el" "textmodes/reftex-toc.el"
;;;;;; "textmodes/texnfo-upd.el" "timezone.el" "tooltip.el" "tree-widget.el"
;;;;;; "uniquify.el" "url/url-about.el" "url/url-cookie.el" "url/url-dired.el"
-;;;;;; "url/url-expand.el" "url/url-ftp.el" "url/url-future.el"
-;;;;;; "url/url-history.el" "url/url-imap.el" "url/url-methods.el"
-;;;;;; "url/url-nfs.el" "url/url-proxy.el" "url/url-vars.el" "vc/ediff-diff.el"
-;;;;;; "vc/ediff-init.el" "vc/ediff-merg.el" "vc/ediff-ptch.el"
-;;;;;; "vc/ediff-vers.el" "vc/ediff-wind.el" "vc/pcvs-info.el" "vc/pcvs-parse.el"
-;;;;;; "vc/pcvs-util.el" "vc/vc-dav.el" "vcursor.el" "vt-control.el"
-;;;;;; "vt100-led.el" "w32-fns.el" "w32-vars.el" "x-dnd.el") (20063
-;;;;;; 23539 958052))
+;;;;;; "url/url-domsuf.el" "url/url-expand.el" "url/url-ftp.el"
+;;;;;; "url/url-future.el" "url/url-history.el" "url/url-imap.el"
+;;;;;; "url/url-methods.el" "url/url-nfs.el" "url/url-proxy.el"
+;;;;;; "url/url-vars.el" "vc/ediff-diff.el" "vc/ediff-init.el" "vc/ediff-merg.el"
+;;;;;; "vc/ediff-ptch.el" "vc/ediff-vers.el" "vc/ediff-wind.el"
+;;;;;; "vc/pcvs-info.el" "vc/pcvs-parse.el" "vc/pcvs-util.el" "vc/vc-dav.el"
+;;;;;; "vcursor.el" "vt-control.el" "vt100-led.el" "w32-fns.el"
+;;;;;; "w32-vars.el" "x-dnd.el") (20452 56581 711508))
;;;***
\f
HCoop / bpt / emacs.git / blobdiff