\f
;;;### (autoloads (5x5-crack 5x5-crack-xor-mutate 5x5-crack-mutating-best
;;;;;; 5x5-crack-mutating-current 5x5-crack-randomly 5x5) "5x5"
-;;;;;; "play/5x5.el" (19640 47194))
+;;;;;; "play/5x5.el" (20229 34587))
;;; Generated autoloads from play/5x5.el
(autoload '5x5 "5x5" "\
5x5 keyboard bindings are:
\\<5x5-mode-map>
-Flip \\[5x5-flip-current]
-Move up \\[5x5-up]
-Move down \\[5x5-down]
-Move left \\[5x5-left]
-Move right \\[5x5-right]
-Start new game \\[5x5-new-game]
-New game with random grid \\[5x5-randomize]
-Random cracker \\[5x5-crack-randomly]
-Mutate current cracker \\[5x5-crack-mutating-current]
-Mutate best cracker \\[5x5-crack-mutating-best]
-Mutate xor cracker \\[5x5-crack-xor-mutate]
-Quit current game \\[5x5-quit-game]
+Flip \\[5x5-flip-current]
+Move up \\[5x5-up]
+Move down \\[5x5-down]
+Move left \\[5x5-left]
+Move right \\[5x5-right]
+Start new game \\[5x5-new-game]
+New game with random grid \\[5x5-randomize]
+Random cracker \\[5x5-crack-randomly]
+Mutate current cracker \\[5x5-crack-mutating-current]
+Mutate best cracker \\[5x5-crack-mutating-best]
+Mutate xor cracker \\[5x5-crack-xor-mutate]
+Solve with Calc \\[5x5-solve-suggest]
+Rotate left Calc Solutions \\[5x5-solve-rotate-left]
+Rotate right Calc Solutions \\[5x5-solve-rotate-right]
+Quit current game \\[5x5-quit-game]
\(fn &optional SIZE)" t nil)
;;;***
\f
-;;;### (autoloads (list-one-abbrev-table) "abbrevlist" "abbrevlist.el"
-;;;;;; (19598 13691))
-;;; Generated autoloads from abbrevlist.el
-
-(autoload 'list-one-abbrev-table "abbrevlist" "\
-Display alphabetical listing of ABBREV-TABLE in buffer OUTPUT-BUFFER.
-
-\(fn ABBREV-TABLE OUTPUT-BUFFER)" nil nil)
-
-;;;***
-\f
;;;### (autoloads (ada-mode ada-add-extensions) "ada-mode" "progmodes/ada-mode.el"
-;;;;;; (19714 43298))
+;;;;;; (20229 34587))
;;; Generated autoloads from progmodes/ada-mode.el
(autoload 'ada-add-extensions "ada-mode" "\
;;;***
\f
;;;### (autoloads (ada-header) "ada-stmt" "progmodes/ada-stmt.el"
-;;;;;; (19598 13691))
+;;;;;; (20229 34587))
;;; Generated autoloads from progmodes/ada-stmt.el
(autoload 'ada-header "ada-stmt" "\
;;;***
\f
;;;### (autoloads (ada-find-file) "ada-xref" "progmodes/ada-xref.el"
-;;;;;; (19714 43298))
+;;;;;; (20236 7740))
;;; 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"
-;;;;;; (19714 43298))
+;;;;;; (20229 34587))
;;; Generated autoloads from vc/add-log.el
(put 'change-log-default-name 'safe-local-variable 'string-or-null-p)
\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" (19598 13691))
+;;;;;; "advice" "emacs-lisp/advice.el" (20277 28925))
;;; Generated autoloads from emacs-lisp/advice.el
(defvar ad-redefinition-action 'warn "\
\f
;;;### (autoloads (align-newline-and-indent align-unhighlight-rule
;;;;;; align-highlight-rule align-current align-entire align-regexp
-;;;;;; align) "align" "align.el" (19598 13691))
+;;;;;; align) "align" "align.el" (20229 34587))
;;; Generated autoloads from align.el
(autoload 'align "align" "\
;;;***
\f
-;;;### (autoloads (outlineify-sticky allout-mode) "allout" "allout.el"
-;;;;;; (19714 43298))
+;;;### (autoloads (outlineify-sticky allout-mode allout-mode-p allout-auto-activation
+;;;;;; allout-setup allout-auto-activation-helper) "allout" "allout.el"
+;;;;;; (20279 40897))
;;; Generated autoloads from allout.el
-(put 'allout-use-hanging-indents 'safe-local-variable (if (fboundp 'booleanp) 'booleanp '(lambda (x) (member x '(t nil)))))
+(autoload 'allout-auto-activation-helper "allout" "\
+Institute `allout-auto-activation'.
+
+Intended to be used as the `allout-auto-activation' :set function.
+
+\(fn VAR VALUE)" nil nil)
+
+(autoload 'allout-setup "allout" "\
+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.
+
+The proper way to use this is through customizing the setting of
+`allout-auto-activation'.
+
+\(fn)" nil nil)
+
+(defvar allout-auto-activation nil "\
+Configure allout outline mode auto-activation.
+
+Control whether and how allout outline mode is automatically
+activated when files are visited with non-nil buffer-specific
+file variable `allout-layout'.
+
+When allout-auto-activation is \"On\" (t), allout mode is
+activated in buffers with non-nil `allout-layout', and the
+specified layout is applied.
+
+With value \"ask\", auto-mode-activation is enabled, and endorsement for
+performing auto-layout is asked of the user each time.
-(put 'allout-reindent-bodies 'safe-local-variable '(lambda (x) (memq x '(nil t text force))))
+With value \"activate\", only auto-mode-activation is enabled.
+Auto-layout is not.
-(put 'allout-show-bodies 'safe-local-variable (if (fboundp 'booleanp) 'booleanp '(lambda (x) (member x '(t nil)))))
+With value nil, inhibit any automatic allout-mode activation.")
+
+(custom-autoload 'allout-auto-activation "allout" nil)
+
+(put 'allout-use-hanging-indents 'safe-local-variable (if (fboundp 'booleanp) 'booleanp (lambda (x) (member x '(t nil)))))
+
+(put 'allout-reindent-bodies 'safe-local-variable (lambda (x) (memq x '(nil t text force))))
+
+(put 'allout-show-bodies 'safe-local-variable (if (fboundp 'booleanp) 'booleanp (lambda (x) (member x '(t nil)))))
(put 'allout-header-prefix 'safe-local-variable 'stringp)
(put 'allout-distinctive-bullets-string 'safe-local-variable 'stringp)
-(put 'allout-use-mode-specific-leader 'safe-local-variable '(lambda (x) (or (memq x '(t nil allout-mode-leaders comment-start)) (stringp x))))
+(put 'allout-use-mode-specific-leader 'safe-local-variable (lambda (x) (or (memq x '(t nil allout-mode-leaders comment-start)) (stringp x))))
-(put 'allout-old-style-prefixes 'safe-local-variable (if (fboundp 'booleanp) 'booleanp '(lambda (x) (member x '(t nil)))))
+(put 'allout-old-style-prefixes 'safe-local-variable (if (fboundp 'booleanp) 'booleanp (lambda (x) (member x '(t nil)))))
-(put 'allout-stylish-prefixes 'safe-local-variable (if (fboundp 'booleanp) 'booleanp '(lambda (x) (member x '(t nil)))))
+(put 'allout-stylish-prefixes 'safe-local-variable (if (fboundp 'booleanp) 'booleanp (lambda (x) (member x '(t nil)))))
-(put 'allout-numbered-bullet 'safe-local-variable (if (fboundp 'string-or-null-p) 'string-or-null-p '(lambda (x) (or (stringp x) (null x)))))
+(put 'allout-numbered-bullet 'safe-local-variable (if (fboundp 'string-or-null-p) 'string-or-null-p (lambda (x) (or (stringp x) (null x)))))
-(put 'allout-file-xref-bullet 'safe-local-variable (if (fboundp 'string-or-null-p) 'string-or-null-p '(lambda (x) (or (stringp x) (null x)))))
+(put 'allout-file-xref-bullet 'safe-local-variable (if (fboundp 'string-or-null-p) 'string-or-null-p (lambda (x) (or (stringp x) (null x)))))
(put 'allout-presentation-padding 'safe-local-variable 'integerp)
-(put 'allout-layout 'safe-local-variable '(lambda (x) (or (numberp x) (listp x) (memq x '(: * + -)))))
+(put 'allout-layout 'safe-local-variable (lambda (x) (or (numberp x) (listp x) (memq x '(: * + -)))))
(put 'allout-passphrase-verifier-string 'safe-local-variable 'stringp)
(put 'allout-passphrase-hint-string 'safe-local-variable 'stringp)
+(autoload 'allout-mode-p "allout" "\
+Return t if `allout-mode' is active in current buffer.
+
+\(fn)" nil (quote macro))
+
(autoload 'allout-mode "allout" "\
-Toggle minor mode for controlling exposure and editing of text outlines.
-\\<allout-mode-map>
-
-Optional prefix argument TOGGLE forces the mode to re-initialize
-if it is positive, otherwise it turns the mode off. Allout
-outline mode always runs as a minor mode.
-
-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
-an example, see the allout code itself, which is organized as an allout
+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-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:
repositioning, promotion/demotion, cut, and paste
- incremental search with dynamic exposure and reconcealment of hidden text
- adjustable format, so programming code can be developed in outline-structure
- - easy topic encryption and decryption
+ - easy topic encryption and decryption, symmetric or key-pair
- \"Hot-spot\" operation, for single-keystroke maneuvering and exposure control
- integral outline layout, for automatic initial exposure when visiting a file
- independent extensibility, using comprehensive exposure and authoring hooks
and many other features.
-Below is a description of the key bindings, and then explanation of
-special `allout-mode' features and terminology. See also the outline
-menubar additions for quick reference to many of the features, and see
-the docstring of the function `allout-init' for instructions on
-priming your emacs session for automatic activation of `allout-mode'.
-
-The bindings are dictated by the customizable `allout-keybindings-list'
-variable. We recommend customizing `allout-command-prefix' to use just
-`\\C-c' as the command prefix, if the allout bindings don't conflict with
-any personal bindings you have on \\C-c. In any case, outline structure
-navigation and authoring is simplified by positioning the cursor on an
-item's bullet character, the \"hot-spot\" -- then you can invoke allout
-commands with just the un-prefixed, un-control-shifted command letters.
-This is described further in the HOT-SPOT Operation section.
+Below is a description of the key bindings, and then description
+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'.
+
+The bindings are those listed in `allout-prefixed-keybindings'
+and `allout-unprefixed-keybindings'. We recommend customizing
+`allout-command-prefix' to use just `\\C-c' as the command
+prefix, if the allout bindings don't conflict with any personal
+bindings you have on \\C-c. In any case, outline structure
+navigation and authoring is simplified by positioning the cursor
+on an item's bullet character, the \"hot-spot\" -- then you can
+invoke allout commands with just the un-prefixed,
+un-control-shifted command letters. This is described further in
+the HOT-SPOT Operation section.
Exposure Control:
----------------
\\[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:
-------------------------
Like above 'copy-exposed', but convert topic
prefixes to section.subsection... numeric
format.
-\\[eval-expression] (allout-init t) Setup Emacs session for outline mode
+\\[customize-variable] allout-auto-activation
+ Prepare Emacs session for allout outline mode
auto-activation.
Topic Encryption
Outline mode supports gpg encryption of topics, with support for
-symmetric and key-pair modes, passphrase timeout, passphrase
-consistency checking, user-provided hinting for symmetric key
-mode, and auto-encryption of topics pending encryption on save.
+symmetric and key-pair modes, and auto-encryption of topics
+pending encryption on save.
Topics pending encryption are, by default, automatically
-encrypted during file saves. If the contents of the topic
-containing the cursor was encrypted for a save, it is
-automatically decrypted for continued editing.
-
-The aim of these measures is reliable topic privacy while
-preventing accidents like neglected encryption before saves,
-forgetting which passphrase was used, and other practical
-pitfalls.
+encrypted during file saves, including checkpoint saves, to avoid
+exposing the plain text of encrypted topics in the file system.
+If the content of the topic containing the cursor was encrypted
+for a save, it is automatically decrypted for continued editing.
+
+NOTE: A few GnuPG v2 versions improperly preserve incorrect
+symmetric decryption keys, preventing entry of the correct key on
+subsequent decryption attempts until the cache times-out. That
+can take several minutes. (Decryption of other entries is not
+affected.) Upgrade your EasyPG version, if you can, and you can
+deliberately clear your gpg-agent's cache by sending it a '-HUP'
+signal.
See `allout-toggle-current-subtree-encryption' function docstring
and `allout-encrypt-unencrypted-on-saves' customization variable
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'
+`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-after-copy-or-kill-hook'
+`allout-post-undo-hook'
Terminology
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.
CLOSED: A TOPIC whose immediate OFFSPRING and body-text is CONCEALED.
OPEN: A TOPIC that is not CLOSED, though its OFFSPRING or BODY may be.
-\(fn &optional TOGGLE)" t nil)
+\(fn &optional ARG)" t nil)
(defalias 'outlinify-sticky 'outlineify-sticky)
(autoload 'outlineify-sticky "allout" "\
Activate outline mode and establish file var so it is started subsequently.
-See doc-string for `allout-layout' and `allout-init' for details on
-setup for auto-startup.
+See `allout-layout' and customization of `allout-auto-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"
+;;;;;; (20279 40897))
+;;; 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 decommission allout-widgets-mode along with allout-mode.
+
+Meant to be used by customization of `allout-widgets-auto-activation'.
+
+\(fn VARNAME VALUE)" nil nil)
+
+(defvar allout-widgets-auto-activation nil "\
+Activate to enable allout icon graphics wherever allout mode is active.
+
+Also enable `allout-auto-activation' for this to take effect upon
+visiting an outline.
+
+When this is set you can disable allout widgets in select files
+by setting `allout-widgets-mode-inhibit'
+
+Instead of setting `allout-widgets-auto-activation' you can
+explicitly invoke `allout-widgets-mode' in allout buffers where
+you want allout widgets operation.
+
+See `allout-widgets-mode' for allout widgets mode features.")
+
+(custom-autoload 'allout-widgets-auto-activation "allout-widgets" nil)
+
+(put 'allout-widgets-mode-inhibit 'safe-local-variable (if (fboundp 'booleanp) 'booleanp (lambda (x) (member x '(t nil)))))
+
+(autoload 'allout-widgets-mode "allout-widgets" "\
+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.
+
+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:
+
+- guide lines connecting item bullet-icons with those of their subitems.
+
+- icons for item bullets, varying to indicate whether or not the item
+ has subitems, and if so, whether or not the item is expanded.
+
+- cue area between the bullet-icon and the start of the body headline,
+ for item numbering, encryption indicator, and distinctive bullets.
+
+The bullet-icon and guide line graphics provide keybindings and mouse
+bindings for easy outline navigation and exposure control, extending
+outline hot-spot navigation (see `allout-mode').
\(fn &optional ARG)" t nil)
;;;***
\f
;;;### (autoloads (ange-ftp-hook-function ange-ftp-reread-dir) "ange-ftp"
-;;;;;; "net/ange-ftp.el" (19714 43298))
+;;;;;; "net/ange-ftp.el" (20295 29120))
;;; Generated autoloads from net/ange-ftp.el
(defalias 'ange-ftp-re-read-dir 'ange-ftp-reread-dir)
\(fn &optional DIR)" t nil)
(autoload 'ange-ftp-hook-function "ange-ftp" "\
-Not documented
+
\(fn OPERATION &rest ARGS)" nil nil)
;;;***
\f
;;;### (autoloads (animate-birthday-present animate-sequence animate-string)
-;;;;;; "animate" "play/animate.el" (19562 42953))
+;;;;;; "animate" "play/animate.el" (20229 34587))
;;; Generated autoloads from play/animate.el
(autoload 'animate-string "animate" "\
-Display STRING starting at position VPOS, HPOS, using animation.
+Display STRING animations starting at position VPOS, HPOS.
The characters start at randomly chosen places,
and all slide in parallel to their final positions,
passing through `animate-n-steps' positions before the final ones.
\(fn STRING VPOS &optional HPOS)" nil nil)
(autoload 'animate-sequence "animate" "\
-Display strings from LIST-OF-STRING with animation in a new buffer.
+Display animation strings from LIST-OF-STRING with buffer *Animation*.
Strings will be separated from each other by SPACE lines.
+ When the variable `animation-buffer-name' is non-nil display
+animation in the buffer named by variable's value, creating the
+buffer if one does not exist.
\(fn LIST-OF-STRINGS SPACE)" nil nil)
(autoload 'animate-birthday-present "animate" "\
-Display one's birthday present in a new buffer.
-You can specify the one's name by NAME; the default value is \"Sarah\".
+Return a birthday present in the buffer *Birthday-Present*.
+When optional arg NAME is non-nil or called-interactively, prompt for
+NAME of birthday present receiver and return a birthday present in
+the buffer *Birthday-Present-for-Name*.
\(fn &optional NAME)" t nil)
;;;***
\f
;;;### (autoloads (ansi-color-process-output ansi-color-for-comint-mode-on)
-;;;;;; "ansi-color" "ansi-color.el" (19714 43298))
+;;;;;; "ansi-color" "ansi-color.el" (20290 11197))
;;; 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" (19714 43298))
+;;;;;; "antlr-mode" "progmodes/antlr-mode.el" (20300 47034))
;;; Generated autoloads from progmodes/antlr-mode.el
(autoload 'antlr-show-makefile-rules "antlr-mode" "\
;;;***
\f
;;;### (autoloads (appt-activate appt-add) "appt" "calendar/appt.el"
-;;;;;; (19640 47194))
+;;;;;; (20229 34587))
;;; 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" (19598 13691))
+;;;;;; apropos-read-pattern) "apropos" "apropos.el" (20229 34587))
;;; 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" (19714
-;;;;;; 43298))
+;;;### (autoloads (archive-mode) "arc-mode" "arc-mode.el" (20279
+;;;;;; 40897))
;;; Generated autoloads from arc-mode.el
(autoload 'archive-mode "arc-mode" "\
;;;***
\f
-;;;### (autoloads (array-mode) "array" "array.el" (19714 43298))
+;;;### (autoloads (array-mode) "array" "array.el" (20229 34587))
;;; Generated autoloads from array.el
(autoload 'array-mode "array" "\
;;;***
\f
-;;;### (autoloads (artist-mode) "artist" "textmodes/artist.el" (19640
-;;;;;; 47194))
+;;;### (autoloads (artist-mode) "artist" "textmodes/artist.el" (20229
+;;;;;; 34587))
;;; Generated autoloads from textmodes/artist.el
(autoload 'artist-mode "artist" "\
;;;***
\f
-;;;### (autoloads (asm-mode) "asm-mode" "progmodes/asm-mode.el" (19714
-;;;;;; 43298))
+;;;### (autoloads (asm-mode) "asm-mode" "progmodes/asm-mode.el" (20229
+;;;;;; 34587))
;;; Generated autoloads from progmodes/asm-mode.el
(autoload 'asm-mode "asm-mode" "\
;;;***
\f
+;;;### (autoloads (auth-source-cache-expiry) "auth-source" "gnus/auth-source.el"
+;;;;;; (20279 40897))
+;;; Generated autoloads from gnus/auth-source.el
+
+(defvar auth-source-cache-expiry 7200 "\
+How many seconds passwords are cached, or nil to disable
+expiring. Overrides `password-cache-expiry' through a
+let-binding.")
+
+(custom-autoload 'auth-source-cache-expiry "auth-source" t)
+
+;;;***
+\f
;;;### (autoloads (autoarg-kp-mode autoarg-mode) "autoarg" "autoarg.el"
-;;;;;; (19562 42953))
+;;;;;; (20229 34587))
;;; 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"
-;;;;;; (19714 43298))
+;;;;;; (20229 34587))
;;; Generated autoloads from progmodes/autoconf.el
(autoload 'autoconf-mode "autoconf" "\
;;;***
\f
;;;### (autoloads (auto-insert-mode define-auto-insert auto-insert)
-;;;;;; "autoinsert" "autoinsert.el" (19591 62571))
+;;;;;; "autoinsert" "autoinsert.el" (20229 34587))
;;; 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"
-;;;;;; (19714 43298))
+;;;;;; (20229 34587))
;;; Generated autoloads from emacs-lisp/autoload.el
(put 'generated-autoload-file 'safe-local-variable 'stringp)
(put 'generated-autoload-load-name 'safe-local-variable 'stringp)
(autoload 'update-file-autoloads "autoload" "\
-Update the autoloads for FILE in `generated-autoload-file'
-\(which FILE might bind in its local variables).
-If SAVE-AFTER is non-nil (which is always, when called interactively),
-save the buffer too.
+Update the autoloads for FILE.
+If prefix arg SAVE-AFTER is non-nil, save the buffer too.
+
+If FILE binds `generated-autoload-file' as a file-local variable,
+autoloads are written into that file. Otherwise, the autoloads
+file is determined by OUTFILE. If called interactively, prompt
+for OUTFILE; if called from Lisp with OUTFILE nil, use the
+existing value of `generated-autoload-file'.
Return FILE if there was no autoload cookie in it, else nil.
-\(fn FILE &optional SAVE-AFTER)" t nil)
+\(fn FILE &optional SAVE-AFTER OUTFILE)" t nil)
(autoload 'update-directory-autoloads "autoload" "\
-Update loaddefs.el with all the current autoloads from DIRS, and no old ones.
-This uses `update-file-autoloads' (which see) to do its work.
-In an interactive call, you must give one argument, the name
-of a single directory. In a call from Lisp, you can supply multiple
+Update autoload definitions for Lisp files in the directories DIRS.
+In an interactive call, you must give one argument, the name of a
+single directory. In a call from Lisp, you can supply multiple
directories as separate arguments, but this usage is discouraged.
The function does NOT recursively descend into subdirectories of the
directory or directories specified.
+In an interactive call, prompt for a default output file for the
+autoload definitions, and temporarily bind the variable
+`generated-autoload-file' to this value. When called from Lisp,
+use the existing value of `generated-autoload-file'. If any Lisp
+file binds `generated-autoload-file' as a file-local variable,
+write its autoloads into the specified file instead.
+
\(fn &rest DIRS)" t nil)
(autoload 'batch-update-autoloads "autoload" "\
Update loaddefs.el autoloads in batch mode.
Calls `update-directory-autoloads' on the command line arguments.
+Definitions are written to `generated-autoload-file' (which
+should be non-nil).
\(fn)" nil nil)
\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" (19562 42953))
+;;;;;; "autorevert" "autorevert.el" (20229 34587))
;;; 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" (19714 43298))
+;;;;;; "avoid.el" (20229 34587))
;;; Generated autoloads from avoid.el
(defvar mouse-avoidance-mode nil "\
-Activate mouse avoidance mode.
+Activate Mouse Avoidance mode.
See function `mouse-avoidance-mode' for possible values.
Setting this variable directly does not take effect;
use either \\[customize] or the function `mouse-avoidance-mode'.")
(custom-autoload 'mouse-avoidance-mode "avoid" nil)
(autoload 'mouse-avoidance-mode "avoid" "\
-Set cursor avoidance mode to MODE.
+Set Mouse Avoidance mode to MODE.
MODE should be one of the symbols `banish', `exile', `jump', `animate',
`cat-and-mouse', `proteus', or `none'.
Whenever the mouse is moved, the frame is also raised.
-\(see `mouse-avoidance-threshold' for definition of \"too close\",
+\(See `mouse-avoidance-threshold' for definition of \"too close\",
and `mouse-avoidance-nudge-dist' and `mouse-avoidance-nudge-var' for
definition of \"random distance\".)
;;;***
\f
;;;### (autoloads (display-battery-mode battery) "battery" "battery.el"
-;;;;;; (19562 42953))
+;;;;;; (20279 40897))
;;; 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" (19562 42953))
+;;;;;; "benchmark" "emacs-lisp/benchmark.el" (20229 34587))
;;; Generated autoloads from emacs-lisp/benchmark.el
(autoload 'benchmark-run "benchmark" "\
;;;***
\f
;;;### (autoloads (bibtex-search-entry bibtex-mode bibtex-initialize)
-;;;;;; "bibtex" "textmodes/bibtex.el" (19714 43298))
+;;;;;; "bibtex" "textmodes/bibtex.el" (20276 64704))
;;; Generated autoloads from textmodes/bibtex.el
(autoload 'bibtex-initialize "bibtex" "\
Some features of BibTeX mode are available only by setting the variable
`bibtex-maintain-sorted-entries' to non-nil. However, then BibTeX mode
-works only with buffers containing valid (syntactical correct) and sorted
+works only with buffers containing valid (syntactically correct) and sorted
entries. This is usually the case, if you have created a buffer completely
with BibTeX mode and finished every new entry with \\[bibtex-clean-entry].
\\[bibtex-remove-delimiters] removes the double-quotes or braces around the text of the current field.
\\[bibtex-empty-field] replaces the text of the current field with the default \"\" or {}.
\\[bibtex-find-text] moves point to the end of the current field.
-\\[bibtex-complete] completes word fragment before point according to context.
+\\[completion-at-point] completes word fragment before point according to context.
The command \\[bibtex-clean-entry] cleans the current entry, i.e. it removes OPT/ALT
from the names of all non-empty optional or alternative fields, checks that
where the search starts. If it is nil, start search at beginning of buffer.
If DISPLAY is non-nil, display the buffer containing KEY.
Otherwise, use `set-buffer'.
-When called interactively, GLOBAL is t if there is a prefix arg or the current
-mode is not `bibtex-mode', START is nil, and DISPLAY is t.
+When called interactively, START is nil, DISPLAY is t.
+Also, GLOBAL is t if the current mode is not `bibtex-mode'
+or `bibtex-search-entry-globally' is non-nil.
+A prefix arg negates the value of `bibtex-search-entry-globally'.
\(fn KEY &optional GLOBAL START DISPLAY)" t nil)
;;;***
\f
;;;### (autoloads (bibtex-style-mode) "bibtex-style" "textmodes/bibtex-style.el"
-;;;;;; (19619 52030))
+;;;;;; (20229 34587))
;;; 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"
-;;;;;; (19598 13691))
+;;;;;; (20229 34587))
;;; 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" (19562
-;;;;;; 42953))
+;;;### (autoloads (blackbox) "blackbox" "play/blackbox.el" (20229
+;;;;;; 34587))
;;; 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" (19717 39999))
+;;;;;; "bookmark.el" (20300 47034))
;;; 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"
-;;;;;; (19714 43298))
+;;;;;; 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" (20300 47034))
;;; Generated autoloads from net/browse-url.el
-(defvar browse-url-browser-function (cond ((memq system-type '(windows-nt ms-dos cygwin)) 'browse-url-default-windows-browser) ((memq system-type '(darwin)) 'browse-url-default-macosx-browser) (t 'browse-url-default-browser)) "\
+(defvar browse-url-browser-function 'browse-url-default-browser "\
Function to display the current buffer in a WWW browser.
This is used by the `browse-url-at-point', `browse-url-at-mouse', and
`browse-url-of-file' commands.
\(fn EVENT)" t nil)
(autoload 'browse-url-xdg-open "browse-url" "\
-Not documented
+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" (19562
-;;;;;; 42953))
+;;;### (autoloads (snarf-bruces bruce) "bruce" "play/bruce.el" (20229
+;;;;;; 34587))
;;; Generated autoloads from play/bruce.el
(autoload 'bruce "bruce" "\
;;;***
\f
;;;### (autoloads (bs-show bs-customize bs-cycle-previous bs-cycle-next)
-;;;;;; "bs" "bs.el" (19562 42953))
+;;;;;; "bs" "bs.el" (20300 47034))
;;; Generated autoloads from bs.el
(autoload 'bs-cycle-next "bs" "\
;;;***
\f
-;;;### (autoloads (bubbles) "bubbles" "play/bubbles.el" (19619 52030))
+;;;### (autoloads (bubbles) "bubbles" "play/bubbles.el" (20229 34587))
;;; Generated autoloads from play/bubbles.el
(autoload 'bubbles "bubbles" "\
;;;***
\f
;;;### (autoloads (bug-reference-prog-mode bug-reference-mode) "bug-reference"
-;;;;;; "progmodes/bug-reference.el" (19562 42953))
+;;;;;; "progmodes/bug-reference.el" (20229 34587))
;;; 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" (19737 17936))
+;;;;;; "bytecomp" "emacs-lisp/bytecomp.el" (20276 33121))
;;; 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)
\(fn DIRECTORY)" t nil)
(autoload 'byte-recompile-directory "bytecomp" "\
-Recompile every `.el' file in BYTECOMP-DIRECTORY that needs recompilation.
+Recompile every `.el' file in DIRECTORY that needs recompilation.
This happens when a `.elc' file exists but is older than the `.el' file.
-Files in subdirectories of BYTECOMP-DIRECTORY are processed also.
+Files in subdirectories of DIRECTORY are processed also.
If the `.elc' file does not exist, normally this function *does not*
compile the corresponding `.el' file. However, if the prefix argument
-BYTECOMP-ARG is 0, that means do compile all those files. A nonzero
-BYTECOMP-ARG means ask the user, for each such `.el' file, whether to
-compile it. A nonzero BYTECOMP-ARG also means ask about each subdirectory
+ARG is 0, that means do compile all those files. A nonzero
+ARG means ask the user, for each such `.el' file, whether to
+compile it. A nonzero ARG also means ask about each subdirectory
before scanning it.
-If the third argument BYTECOMP-FORCE is non-nil, recompile every `.el' file
+If the third argument FORCE is non-nil, recompile every `.el' file
that already has a `.elc' file.
-\(fn BYTECOMP-DIRECTORY &optional BYTECOMP-ARG BYTECOMP-FORCE)" t nil)
+\(fn DIRECTORY &optional ARG FORCE)" t nil)
(put 'no-byte-compile 'safe-local-variable 'booleanp)
(autoload 'byte-compile-file "bytecomp" "\
-Compile a file of Lisp code named BYTECOMP-FILENAME into a file of byte code.
-The output file's name is generated by passing BYTECOMP-FILENAME to the
+Compile a file of Lisp code named FILENAME into a file of byte code.
+The output file's name is generated by passing FILENAME to the
function `byte-compile-dest-file' (which see).
With prefix arg (noninteractively: 2nd arg), LOAD the file after compiling.
The value is non-nil if there were no errors, nil if errors.
-\(fn BYTECOMP-FILENAME &optional LOAD)" t nil)
+\(fn FILENAME &optional LOAD)" t nil)
(autoload 'compile-defun "bytecomp" "\
Compile and evaluate the current top-level form.
;;;***
\f
-;;;### (autoloads nil "cal-china" "calendar/cal-china.el" (19598
-;;;;;; 13691))
+;;;### (autoloads nil "cal-china" "calendar/cal-china.el" (20229
+;;;;;; 34587))
;;; 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" (19598 13691))
+;;;### (autoloads nil "cal-dst" "calendar/cal-dst.el" (20229 34587))
;;; 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"
-;;;;;; (19640 47194))
+;;;;;; (20284 58812))
;;; 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" (19591
-;;;;;; 62571))
+;;;;;; full-calc calc calc-dispatch) "calc" "calc/calc.el" (20279
+;;;;;; 40897))
;;; Generated autoloads from calc/calc.el
(define-key ctl-x-map "*" 'calc-dispatch)
;;;***
\f
-;;;### (autoloads (calculator) "calculator" "calculator.el" (19619
-;;;;;; 52030))
+;;;### (autoloads (calc-undo) "calc-undo" "calc/calc-undo.el" (20229
+;;;;;; 34587))
+;;; Generated autoloads from calc/calc-undo.el
+
+(autoload 'calc-undo "calc-undo" "\
+
+
+\(fn N)" t nil)
+
+;;;***
+\f
+;;;### (autoloads (calculator) "calculator" "calculator.el" (20229
+;;;;;; 34587))
;;; Generated autoloads from calculator.el
(autoload 'calculator "calculator" "\
;;;***
\f
-;;;### (autoloads (calendar) "calendar" "calendar/calendar.el" (19714
-;;;;;; 43298))
+;;;### (autoloads (calendar) "calendar" "calendar/calendar.el" (20287
+;;;;;; 5356))
;;; Generated autoloads from calendar/calendar.el
(autoload 'calendar "calendar" "\
;;;***
\f
;;;### (autoloads (canlock-verify canlock-insert-header) "canlock"
-;;;;;; "gnus/canlock.el" (19598 13691))
+;;;;;; "gnus/canlock.el" (20229 34587))
;;; Generated autoloads from gnus/canlock.el
(autoload 'canlock-insert-header "canlock" "\
;;;***
\f
;;;### (autoloads (capitalized-words-mode) "cap-words" "progmodes/cap-words.el"
-;;;;;; (19562 42953))
+;;;;;; (20229 34587))
;;; 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" (19598
-;;;;;; 13691))
+;;;### (autoloads nil "cc-compat" "progmodes/cc-compat.el" (20229
+;;;;;; 34587))
;;; 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"
-;;;;;; (19717 39999))
+;;;;;; (20279 40897))
;;; Generated autoloads from progmodes/cc-engine.el
(autoload 'c-guess-basic-syntax "cc-engine" "\
;;;***
\f
-;;;### (autoloads (pike-mode idl-mode java-mode objc-mode c++-mode
-;;;;;; c-mode c-initialize-cc-mode) "cc-mode" "progmodes/cc-mode.el"
-;;;;;; (19714 43298))
+;;;### (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" (20275 43867))
+;;; Generated autoloads from progmodes/cc-guess.el
+
+(defvar c-guess-guessed-offsets-alist nil "\
+Currently guessed offsets-alist.")
+
+(defvar c-guess-guessed-basic-offset nil "\
+Currently guessed basic-offset.")
+
+(autoload 'c-guess "cc-guess" "\
+Guess the style in the region up to `c-guess-region-max', and install it.
+
+The style is given a name based on the file's absolute file name.
+
+If given a prefix argument (or if the optional argument ACCUMULATE is
+non-nil) then the previous guess is extended, otherwise a new guess is
+made from scratch.
+
+\(fn &optional ACCUMULATE)" t nil)
+
+(autoload 'c-guess-no-install "cc-guess" "\
+Guess the style in the region up to `c-guess-region-max'; don't install it.
+
+If given a prefix argument (or if the optional argument ACCUMULATE is
+non-nil) then the previous guess is extended, otherwise a new guess is
+made from scratch.
+
+\(fn &optional ACCUMULATE)" t nil)
+
+(autoload 'c-guess-buffer "cc-guess" "\
+Guess the style on the whole current buffer, and install it.
+
+The style is given a name based on the file's absolute file name.
+
+If given a prefix argument (or if the optional argument ACCUMULATE is
+non-nil) then the previous guess is extended, otherwise a new guess is
+made from scratch.
+
+\(fn &optional ACCUMULATE)" t nil)
+
+(autoload 'c-guess-buffer-no-install "cc-guess" "\
+Guess the style on the whole current buffer; don't install it.
+
+If given a prefix argument (or if the optional argument ACCUMULATE is
+non-nil) then the previous guess is extended, otherwise a new guess is
+made from scratch.
+
+\(fn &optional ACCUMULATE)" t nil)
+
+(autoload 'c-guess-region "cc-guess" "\
+Guess the style on the region and install it.
+
+The style is given a name based on the file's absolute file name.
+
+If given a prefix argument (or if the optional argument ACCUMULATE is
+non-nil) then the previous guess is extended, otherwise a new guess is
+made from scratch.
+
+\(fn START END &optional ACCUMULATE)" t nil)
+
+(autoload 'c-guess-region-no-install "cc-guess" "\
+Guess the style on the region; don't install it.
+
+Every line of code in the region is examined and values for the following two
+variables are guessed:
+
+* `c-basic-offset', and
+* the indentation values of the various syntactic symbols in
+ `c-offsets-alist'.
+
+The guessed values are put into `c-guess-guessed-basic-offset' and
+`c-guess-guessed-offsets-alist'.
+
+Frequencies of use are taken into account when guessing, so minor
+inconsistencies in the indentation style shouldn't produce wrong guesses.
+
+If given a prefix argument (or if the optional argument ACCUMULATE is
+non-nil) then the previous examination is extended, otherwise a new
+guess is made from scratch.
+
+Note that the larger the region to guess in, the slower the guessing.
+So you can limit the region with `c-guess-region-max'.
+
+\(fn START END &optional ACCUMULATE)" t nil)
+
+(autoload 'c-guess-install "cc-guess" "\
+Install the latest guessed style into the current buffer.
+\(This guessed style is a combination of `c-guess-guessed-basic-offset',
+`c-guess-guessed-offsets-alist' and `c-offsets-alist'.)
+
+The style is entered into CC Mode's style system by
+`c-add-style'. Its name is either STYLE-NAME, or a name based on
+the absolute file name of the file if STYLE-NAME is nil.
+
+\(fn &optional STYLE-NAME)" t 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"
+;;;;;; (20293 38510))
;;; Generated autoloads from progmodes/cc-mode.el
(autoload 'c-initialize-cc-mode "cc-mode" "\
(add-to-list 'interpreter-mode-alist '("gawk" . awk-mode))
(autoload 'awk-mode "cc-mode" "Major mode for editing AWK code." t)
+(autoload 'awk-mode "cc-mode" "\
+Major mode for editing AWK code.
+To submit a problem report, enter `\\[c-submit-bug-report]' from an
+awk-mode buffer. This automatically sets up a mail buffer with version
+information already added. You just need to add a description of the
+problem, including a reproducible test case, and send the message.
+
+To see what version of CC Mode you are running, enter `\\[c-version]'.
+
+The hook `c-mode-common-hook' is run with no args at mode
+initialization, then `awk-mode-hook'.
+
+Key bindings:
+\\{awk-mode-map}
+
+\(fn)" t nil)
+
;;;***
\f
;;;### (autoloads (c-set-offset c-add-style c-set-style) "cc-styles"
-;;;;;; "progmodes/cc-styles.el" (19714 43298))
+;;;;;; "progmodes/cc-styles.el" (20229 34587))
;;; Generated autoloads from progmodes/cc-styles.el
(autoload 'c-set-style "cc-styles" "\
;;;***
\f
-;;;### (autoloads nil "cc-vars" "progmodes/cc-vars.el" (19598 13691))
+;;;### (autoloads nil "cc-vars" "progmodes/cc-vars.el" (20279 40897))
;;; 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"
-;;;;;; (19640 47194))
+;;;;;; (20229 34587))
;;; Generated autoloads from international/ccl.el
(autoload 'ccl-compile "ccl" "\
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)
;;;***
\f
-;;;### (autoloads (cfengine-mode) "cfengine" "progmodes/cfengine.el"
-;;;;;; (19714 43298))
+;;;### (autoloads (cconv-closure-convert) "cconv" "emacs-lisp/cconv.el"
+;;;;;; (20229 34587))
+;;; Generated autoloads from emacs-lisp/cconv.el
+
+(autoload 'cconv-closure-convert "cconv" "\
+Main entry point for closure conversion.
+-- FORM is a piece of Elisp code after macroexpansion.
+-- TOPLEVEL(optional) is a boolean variable, true if we are at the root of AST
+
+Returns a form where all lambdas don't have any free variables.
+
+\(fn FORM)" nil nil)
+
+;;;***
+\f
+;;;### (autoloads (cfengine-auto-mode cfengine2-mode cfengine3-mode)
+;;;;;; "cfengine" "progmodes/cfengine.el" (20229 34587))
;;; Generated autoloads from progmodes/cfengine.el
-(autoload 'cfengine-mode "cfengine" "\
-Major mode for editing cfengine input.
+(autoload 'cfengine3-mode "cfengine" "\
+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 '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
+to the action header.
+
+\(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" (19562 42953))
+;;;;;; "emacs-lisp/check-declare.el" (20229 34587))
;;; 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" (19714 43298))
+;;;;;; "checkdoc" "emacs-lisp/checkdoc.el" (20237 28610))
;;; 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)
(put 'checkdoc-symbol-words 'safe-local-variable 'checkdoc-list-of-strings-p)
(autoload 'checkdoc-list-of-strings-p "checkdoc" "\
-Not documented
+
\(fn OBJ)" nil nil)
\(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" (19562 42953))
+;;;;;; "language/china-util.el" (20229 34587))
;;; Generated autoloads from language/china-util.el
(autoload 'decode-hz-region "china-util" "\
\(fn)" t nil)
(autoload 'post-read-decode-hz "china-util" "\
-Not documented
+
\(fn LEN)" nil nil)
(autoload 'pre-write-encode-hz "china-util" "\
-Not documented
+
\(fn FROM TO)" nil nil)
;;;***
\f
;;;### (autoloads (command-history list-command-history repeat-matching-complex-command)
-;;;;;; "chistory" "chistory.el" (19562 42953))
+;;;;;; "chistory" "chistory.el" (20229 34587))
;;; Generated autoloads from chistory.el
(autoload 'repeat-matching-complex-command "chistory" "\
;;;***
\f
-;;;### (autoloads nil "cl" "emacs-lisp/cl.el" (19640 47194))
+;;;### (autoloads nil "cl" "emacs-lisp/cl.el" (20229 34587))
;;; Generated autoloads from emacs-lisp/cl.el
(defvar custom-print-functions nil "\
;;;***
\f
;;;### (autoloads (common-lisp-indent-function) "cl-indent" "emacs-lisp/cl-indent.el"
-;;;;;; (19598 13691))
+;;;;;; (20279 40897))
;;; Generated autoloads from emacs-lisp/cl-indent.el
(autoload 'common-lisp-indent-function "cl-indent" "\
of this function.
If the indentation point is in a call to a Lisp function, that
-function's common-lisp-indent-function property specifies how
+function's `common-lisp-indent-function' property specifies how
this function should indent it. Possible values for this
property are:
;;;***
\f
;;;### (autoloads (c-macro-expand) "cmacexp" "progmodes/cmacexp.el"
-;;;;;; (19562 42953))
+;;;;;; (20229 34587))
;;; Generated autoloads from progmodes/cmacexp.el
(autoload 'c-macro-expand "cmacexp" "\
;;;***
\f
-;;;### (autoloads (run-scheme) "cmuscheme" "cmuscheme.el" (19562
-;;;;;; 42953))
+;;;### (autoloads (run-scheme) "cmuscheme" "cmuscheme.el" (20229
+;;;;;; 34587))
;;; 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" (20254 62269))
+;;; Generated autoloads from color.el
+
+(autoload 'color-name-to-rgb "color" "\
+Convert COLOR string to a list of normalized RGB components.
+COLOR should be a color name (e.g. \"white\") or an RGB triplet
+string (e.g. \"#ff12ec\").
+
+Normally the return value is a list of three floating-point
+numbers, (RED GREEN BLUE), each between 0.0 and 1.0 inclusive.
+
+Optional arg FRAME specifies the frame where the color is to be
+displayed. If FRAME is omitted or nil, use the selected frame.
+If FRAME cannot display COLOR, return nil.
+
+\(fn COLOR &optional FRAME)" nil nil)
;;;***
\f
;;;### (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"
-;;;;;; (19714 43298))
+;;;;;; (20290 11197))
;;; 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
;;;***
\f
;;;### (autoloads (compare-windows) "compare-w" "vc/compare-w.el"
-;;;;;; (19562 42953))
+;;;;;; (20229 34587))
;;; 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" (19714
-;;;;;; 43298))
+;;;;;; compilation-mode-hook) "compile" "progmodes/compile.el" (20275
+;;;;;; 43867))
;;; Generated autoloads from progmodes/compile.el
(defvar compilation-mode-hook nil "\
*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. The function
-is called with variables `compilation-buffer' and `compilation-window'
-bound to the compilation buffer and window, respectively.")
+while processing the output of the compilation process.")
(defvar compilation-buffer-name-function nil "\
Function to compute the name of a compilation buffer.
\(fn &optional NAME-OF-MODE)" t nil)
(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"
-;;;;;; (19562 42953))
+;;;;;; (20273 55691))
;;; 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"
-;;;;;; (19562 42953))
+;;;;;; (20229 34587))
;;; 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" (19598 13691))
+;;;;;; "cookie1" "play/cookie1.el" (20229 34587))
;;; 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" (19598
-;;;;;; 13691))
+;;;;;; copyright-update) "copyright" "emacs-lisp/copyright.el" (20229
+;;;;;; 34587))
;;; Generated autoloads from emacs-lisp/copyright.el
+(put 'copyright-at-end-flag 'safe-local-variable 'booleanp)
+(put 'copyright-names-regexp 'safe-local-variable 'stringp)
+(put 'copyright-year-ranges 'safe-local-variable 'booleanp)
(autoload 'copyright-update "copyright" "\
Update copyright notice to indicate the current year.
(autoload 'copyright-fix-years "copyright" "\
Convert 2 digit years to 4 digit years.
Uses heuristic: year >= 50 means 19xx, < 50 means 20xx.
+If `copyright-year-ranges' (which see) is non-nil, also
+independently replaces consecutive years with a range.
\(fn)" t nil)
(autoload 'copyright-update-directory "copyright" "\
Update copyright notice for all files in DIRECTORY matching MATCH.
+If FIX is non-nil, run `copyright-fix-years' instead.
-\(fn DIRECTORY MATCH)" t nil)
+\(fn DIRECTORY MATCH &optional FIX)" t nil)
;;;***
\f
;;;### (autoloads (cperl-perldoc-at-point cperl-perldoc cperl-mode)
-;;;;;; "cperl-mode" "progmodes/cperl-mode.el" (19714 43298))
+;;;;;; "cperl-mode" "progmodes/cperl-mode.el" (20229 34587))
;;; 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"
-;;;;;; (19714 43298))
+;;;;;; (20229 34587))
;;; Generated autoloads from progmodes/cpp.el
(autoload 'cpp-highlight-buffer "cpp" "\
;;;***
\f
;;;### (autoloads (crisp-mode crisp-mode) "crisp" "emulation/crisp.el"
-;;;;;; (19619 52030))
+;;;;;; (20229 34587))
;;; 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"
-;;;;;; (19562 42953))
+;;;;;; (20229 34587))
;;; Generated autoloads from emacs-lisp/crm.el
(autoload 'completing-read-multiple "crm" "\
;;;***
\f
-;;;### (autoloads (css-mode) "css-mode" "textmodes/css-mode.el" (19619
-;;;;;; 52030))
+;;;### (autoloads (css-mode) "css-mode" "textmodes/css-mode.el" (20229
+;;;;;; 34587))
;;; 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"
-;;;;;; (19714 43298))
+;;;;;; (20300 47034))
;;; 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-rogue customize-unsaved customize-face-other-window
;;;;;; customize-face customize-changed-options customize-option-other-window
;;;;;; customize-option customize-group-other-window customize-group
-;;;;;; customize-mode customize 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"
-;;;;;; (19714 43298))
+;;;;;; 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" (20271 46782))
;;; 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.
\(fn VARIABLE VALUE &optional COMMENT)" t nil)
+(autoload 'customize-push-and-save "cus-edit" "\
+Add ELTS to LIST-VAR and save for future sessions, safely.
+ELTS should be a list. This function adds each entry to the
+value of LIST-VAR using `add-to-list'.
+
+If Emacs is initialized, call `customize-save-variable' to save
+the resulting list value now. Otherwise, add an entry to
+`after-init-hook' to save it after initialization.
+
+\(fn LIST-VAR ELTS)" nil nil)
+
(autoload 'customize "cus-edit" "\
Select a customization buffer which you can use to set user options.
User options are structured into \"groups\".
(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.
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)
;;;***
\f
-;;;### (autoloads (customize-themes describe-theme customize-create-theme)
-;;;;;; "cus-theme" "cus-theme.el" (19714 43298))
+;;;### (autoloads (customize-themes describe-theme custom-theme-visit-theme
+;;;;;; customize-create-theme) "cus-theme" "cus-theme.el" (20279
+;;;;;; 40897))
;;; Generated autoloads from cus-theme.el
(autoload 'customize-create-theme "cus-theme" "\
\(fn &optional THEME BUFFER)" t nil)
+(autoload 'custom-theme-visit-theme "cus-theme" "\
+Set up a Custom buffer to edit custom theme THEME.
+
+\(fn THEME)" t nil)
+
(autoload 'describe-theme "cus-theme" "\
Display a description of the Custom theme THEME (a symbol).
;;;***
\f
;;;### (autoloads (cvs-status-mode) "cvs-status" "vc/cvs-status.el"
-;;;;;; (19562 42953))
+;;;;;; (20229 34587))
;;; 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" (19598 13691))
+;;;;;; "cwarn" "progmodes/cwarn.el" (20273 55692))
;;; 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"
-;;;;;; (19562 42953))
+;;;;;; (20229 34587))
;;; Generated autoloads from language/cyril-util.el
(autoload 'cyrillic-encode-koi8-r-char "cyril-util" "\
;;;***
\f
;;;### (autoloads (dabbrev-expand dabbrev-completion) "dabbrev" "dabbrev.el"
-;;;;;; (19591 62571))
+;;;;;; (20229 34587))
;;; 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"
-;;;;;; (19598 13691))
+;;;;;; (20229 34587))
;;; Generated autoloads from cedet/data-debug.el
(autoload 'data-debug-new-buffer "data-debug" "\
;;;***
\f
-;;;### (autoloads (dbus-handle-event) "dbus" "net/dbus.el" (19714
-;;;;;; 43298))
+;;;### (autoloads (dbus-handle-event) "dbus" "net/dbus.el" (20229
+;;;;;; 34587))
;;; Generated autoloads from net/dbus.el
(autoload 'dbus-handle-event "dbus" "\
;;;***
\f
-;;;### (autoloads (dcl-mode) "dcl-mode" "progmodes/dcl-mode.el" (19714
-;;;;;; 43298))
+;;;### (autoloads (dcl-mode) "dcl-mode" "progmodes/dcl-mode.el" (20229
+;;;;;; 34587))
;;; 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" (19598 13691))
+;;;;;; "emacs-lisp/debug.el" (20229 34587))
;;; Generated autoloads from emacs-lisp/debug.el
(setq debugger 'debug)
(autoload 'debug "debug" "\
-Enter debugger. To return, type \\<debugger-mode-map>`\\[debugger-continue]'.
+Enter debugger. \\<debugger-mode-map>`\\[debugger-continue]' returns from the debugger.
Arguments are mainly for use when this is called from the internals
of the evaluator.
;;;***
\f
;;;### (autoloads (decipher-mode decipher) "decipher" "play/decipher.el"
-;;;;;; (19714 43298))
+;;;;;; (20229 34587))
;;; 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" (19562
-;;;;;; 42953))
+;;;;;; delimit-columns-customize) "delim-col" "delim-col.el" (20229
+;;;;;; 34587))
;;; Generated autoloads from delim-col.el
(autoload 'delimit-columns-customize "delim-col" "\
;;;***
\f
-;;;### (autoloads (delphi-mode) "delphi" "progmodes/delphi.el" (19714
-;;;;;; 43298))
+;;;### (autoloads (delphi-mode) "delphi" "progmodes/delphi.el" (20229
+;;;;;; 34587))
;;; Generated autoloads from progmodes/delphi.el
(autoload 'delphi-mode "delphi" "\
\\[delphi-fill-comment] - Fill the current comment.
\\[delphi-new-comment-line] - If in a // comment, do a new comment line.
-M-x indent-region also works for indenting a whole region.
+\\[indent-region] also works for indenting a whole region.
Customization:
`delphi-search-path' (default .)
Directories to search when finding external units.
`delphi-verbose' (default nil)
- If true then delphi token processing progress is reported to the user.
+ If true then Delphi token processing progress is reported to the user.
Coloring:
`delphi-comment-face' (default font-lock-comment-face)
- Face used to color delphi comments.
+ Face used to color Delphi comments.
`delphi-string-face' (default font-lock-string-face)
- Face used to color delphi strings.
+ Face used to color Delphi strings.
`delphi-keyword-face' (default font-lock-keyword-face)
- Face used to color delphi keywords.
+ Face used to color Delphi keywords.
`delphi-other-face' (default nil)
Face used to color everything else.
-Turning on Delphi mode calls the value of the variable delphi-mode-hook with
-no args, if that value is non-nil.
+Turning on Delphi mode calls the value of the variable `delphi-mode-hook'
+with no args, if that value is non-nil.
-\(fn &optional SKIP-INITIAL-PARSING)" t nil)
+\(fn)" t nil)
;;;***
\f
-;;;### (autoloads (delete-selection-mode) "delsel" "delsel.el" (19562
-;;;;;; 42953))
+;;;### (autoloads (delete-selection-mode) "delsel" "delsel.el" (20229
+;;;;;; 34587))
;;; 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" (19598 13691))
+;;;;;; "derived" "emacs-lisp/derived.el" (20229 34587))
;;; Generated autoloads from emacs-lisp/derived.el
(autoload 'define-derived-mode "derived" "\
Declare the customization group that corresponds to this mode.
The command `customize-mode' uses this.
:syntax-table TABLE
- Use TABLE instead of the default.
+ Use TABLE instead of the default (CHILD-syntax-table).
A nil value means to simply use the same syntax-table as the parent.
:abbrev-table TABLE
- Use TABLE instead of the default.
+ Use TABLE instead of the default (CHILD-abbrev-table).
A nil value means to simply use the same abbrev-table as the parent.
Here is how you could define LaTeX-Thesis mode as a variant of LaTeX mode:
;;;***
\f
;;;### (autoloads (describe-char describe-text-properties) "descr-text"
-;;;;;; "descr-text.el" (19591 62571))
+;;;;;; "descr-text.el" (20259 55615))
;;; 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" (19598 13691))
+;;;;;; "desktop.el" (20277 28925))
;;; 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" (19598 13691))
+;;;;;; "deuglify" "gnus/deuglify.el" (20229 34587))
;;; 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" (19714 43298))
+;;;;;; "calendar/diary-lib.el" (20287 5356))
;;; 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" (19714 43298))
+;;;;;; diff-switches) "diff" "vc/diff.el" (20229 34587))
;;; Generated autoloads from vc/diff.el
(defvar diff-switches (purecopy "-c") "\
(autoload 'diff "diff" "\
Find and display the differences between OLD and NEW files.
-When called interactively, read OLD and NEW using the minibuffer;
-the default for NEW is the current buffer's file name, and the
-default for OLD is a backup file for NEW, if one exists.
-If NO-ASYNC is non-nil, call diff synchronously.
+When called interactively, read NEW, then OLD, using the
+minibuffer. The default for NEW is the current buffer's file
+name, and the default for OLD is a backup file for NEW, if one
+exists. If NO-ASYNC is non-nil, call diff synchronously.
When called interactively with a prefix argument, prompt
interactively for diff switches. Otherwise, the switches
;;;***
\f
;;;### (autoloads (diff-minor-mode diff-mode) "diff-mode" "vc/diff-mode.el"
-;;;;;; (19591 62571))
+;;;;;; (20300 47034))
;;; 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" (19640 47194))
+;;;### (autoloads (dig) "dig" "net/dig.el" (20229 34587))
;;; Generated autoloads from net/dig.el
(autoload 'dig "dig" "\
;;;***
\f
-;;;### (autoloads (dired-mode dired-auto-revert-buffer dired-noselect
-;;;;;; dired-other-frame dired-other-window dired dired-trivial-filenames
-;;;;;; dired-listing-switches) "dired" "dired.el" (19714 43298))
+;;;### (autoloads (dired-mode dired-noselect dired-other-frame dired-other-window
+;;;;;; dired dired-listing-switches) "dired" "dired.el" (20296 49978))
;;; Generated autoloads from dired.el
(defvar dired-listing-switches (purecopy "-al") "\
(custom-autoload 'dired-listing-switches "dired" t)
-(defvar dired-chown-program (purecopy (if (memq system-type '(hpux usg-unix-v irix gnu/linux cygwin)) "chown" (if (file-exists-p "/usr/sbin/chown") "/usr/sbin/chown" "/etc/chown"))) "\
-Name of chown command (usually `chown' or `/etc/chown').")
-
-(defvar dired-trivial-filenames (purecopy "^\\.\\.?$\\|^#") "\
-Regexp of files to skip when finding first file of a directory.
-A value of nil means move to the subdir line.
-A value of t means move to first file.")
-
-(custom-autoload 'dired-trivial-filenames "dired" t)
-
(defvar dired-directory nil "\
The directory name or wildcard spec that this dired directory lists.
Local to each dired buffer. May be a list, in which case the car is the
shell wildcards appended to select certain files). If DIRNAME is a cons,
its first element is taken as the directory name and the rest as an explicit
list of files to make directory entries for.
-\\<dired-mode-map>You can move around in it with the usual commands.
-You can flag files for deletion with \\[dired-flag-file-deletion] and then
+\\<dired-mode-map>You can flag files for deletion with \\[dired-flag-file-deletion] and then
delete them by typing \\[dired-do-flagged-delete].
Type \\[describe-mode] after entering Dired for more info.
\(fn DIR-OR-LIST &optional SWITCHES)" nil nil)
-(defvar dired-auto-revert-buffer nil "\
-Automatically revert dired buffer on revisiting.
-If t, revisiting an existing dired buffer automatically reverts it.
-If its value is a function, call this function with the directory
-name as single argument and revert the buffer if it returns non-nil.
-Otherwise, a message offering to revert the changed dired buffer
-is displayed.
-Note that this is not the same as `auto-revert-mode' that
-periodically reverts at specified time intervals.")
-
-(custom-autoload 'dired-auto-revert-buffer "dired" t)
-
(autoload 'dired-mode "dired" "\
Mode for \"editing\" directory listings.
In Dired, you are \"editing\" a list of the files in a directory and
files for later commands or \"flag\" them for deletion, either file
by file or all files matching certain criteria.
You can move using the usual cursor motion commands.\\<dired-mode-map>
-Letters no longer insert themselves. Digits are prefix arguments.
-Instead, type \\[dired-flag-file-deletion] to flag a file for Deletion.
+The buffer is read-only. Digits are prefix arguments.
+Type \\[dired-flag-file-deletion] to flag a file `D' for deletion.
Type \\[dired-mark] to Mark a file or subdirectory for later commands.
Most commands operate on the marked files and use the current file
if no files are marked. Use a numeric prefix argument to operate on
to operate on the current file only. Prefix arguments override marks.
Mark-using commands display a list of failures afterwards. Type \\[dired-summary]
to see why something went wrong.
-Type \\[dired-unmark] to Unmark a file or all files of a subdirectory.
-Type \\[dired-unmark-backward] to back up one line and unflag.
-Type \\[dired-do-flagged-delete] to eXecute the deletions requested.
+Type \\[dired-unmark] to Unmark a file or all files of an inserted subdirectory.
+Type \\[dired-unmark-backward] to back up one line and unmark or unflag.
+Type \\[dired-do-flagged-delete] to delete (eXecute) the files flagged `D'.
Type \\[dired-find-file] to Find the current line's file
(or dired it in another buffer, if it is a directory).
Type \\[dired-find-file-other-window] to find file or dired directory in Other window.
Type \\[dired-sort-toggle-or-edit] to toggle Sorting by name/date or change the `ls' switches.
Type \\[revert-buffer] to read all currently expanded directories aGain.
This retains all marks and hides subdirs again that were hidden before.
-SPC and DEL can be used to move down and up by lines.
+Use `SPC' and `DEL' to move down and up by lines.
If Dired ever gets confused, you can either type \\[revert-buffer] to read the
-directories again, type \\[dired-do-redisplay] to relist a single or the marked files or a
+directories again, type \\[dired-do-redisplay] to relist the file at point or the marked files or a
subdirectory, or type \\[dired-build-subdir-alist] to parse the buffer
again for the directory tree.
;;;***
\f
;;;### (autoloads (dirtrack dirtrack-mode) "dirtrack" "dirtrack.el"
-;;;;;; (19714 43298))
+;;;;;; (20273 55691))
;;; 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" (19598
-;;;;;; 13508))
+;;;### (autoloads (disassemble) "disass" "emacs-lisp/disass.el" (20229
+;;;;;; 34587))
;;; 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" (19598 13691))
+;;;;;; "disp-table" "disp-table.el" (20229 34587))
;;; Generated autoloads from disp-table.el
(autoload 'make-display-table "disp-table" "\
;;;***
\f
;;;### (autoloads (dissociated-press) "dissociate" "play/dissociate.el"
-;;;;;; (19562 42953))
+;;;;;; (20229 34587))
;;; Generated autoloads from play/dissociate.el
(autoload 'dissociated-press "dissociate" "\
;;;***
\f
-;;;### (autoloads (dnd-protocol-alist) "dnd" "dnd.el" (19640 47194))
+;;;### (autoloads (dnd-protocol-alist) "dnd" "dnd.el" (20229 34587))
;;; 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" (19619 52030))
+;;;;;; "textmodes/dns-mode.el" (20229 34587))
;;; 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
-;;;;;; doc-view-mode-p) "doc-view" "doc-view.el" (19714 43269))
+;;;### (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" (20279
+;;;;;; 40897))
;;; Generated autoloads from doc-view.el
(autoload 'doc-view-mode-p "doc-view" "\
-Return non-nil if image type TYPE is available for `doc-view'.
-Image types are symbols like `dvi', `postscript' or `pdf'.
+Return non-nil if document type TYPE is available for `doc-view'.
+Document types are symbols like `dvi', `ps', `pdf', or `odf' (any
+OpenDocument format).
\(fn TYPE)" nil nil)
\(fn)" t nil)
+(autoload 'doc-view-mode-maybe "doc-view" "\
+Switch to `doc-view-mode' if possible.
+If the required external tools are not available, then fallback
+to the next best mode.
+
+\(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)
(autoload 'doc-view-bookmark-jump "doc-view" "\
-Not documented
+
\(fn BMK)" nil nil)
;;;***
\f
-;;;### (autoloads (doctor) "doctor" "play/doctor.el" (19714 43298))
+;;;### (autoloads (doctor) "doctor" "play/doctor.el" (20230 15291))
;;; Generated autoloads from play/doctor.el
(autoload 'doctor "doctor" "\
;;;***
\f
-;;;### (autoloads (double-mode) "double" "double.el" (19562 42953))
+;;;### (autoloads (double-mode) "double" "double.el" (20229 34587))
;;; 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" (19562 42953))
+;;;### (autoloads (dunnet) "dunnet" "play/dunnet.el" (20229 34587))
;;; 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" (19714 43298))
+;;;;;; "emacs-lisp/easy-mmode.el" (20294 38748))
;;; 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 KEYMAP is the default keymap bound to the mode keymap.
If non-nil, it should be a variable name (whose value is a keymap),
- a keymap, or a list of arguments for `easy-mmode-define-keymap'.
- If KEYMAP is a keymap or list, this also defines the variable MODE-map.
+ or an expression that returns either a keymap or a list of
+ 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!\"
;;;***
\f
;;;### (autoloads (easy-menu-change easy-menu-create-menu easy-menu-do-define
-;;;;;; easy-menu-define) "easymenu" "emacs-lisp/easymenu.el" (19598
-;;;;;; 13691))
+;;;;;; easy-menu-define) "easymenu" "emacs-lisp/easymenu.el" (20300
+;;;;;; 47034))
;;; Generated autoloads from emacs-lisp/easymenu.el
(autoload 'easy-menu-define "easymenu" "\
:active ENABLE
-ENABLE is an expression; the menu is enabled for selection
-whenever this expression's value is non-nil.
+ENABLE is an expression; the menu is enabled for selection whenever
+this expression's value is non-nil. `:enable' is an alias for `:active'.
The rest of the elements in MENU, are menu items.
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.
:active ENABLE
-ENABLE is an expression; the item is enabled for selection
-whenever this expression's value is non-nil.
+ENABLE is an expression; the item is enabled for selection whenever
+this expression's value is non-nil. `:enable' is an alias for `:active'.
:visible INCLUDE
(put 'easy-menu-define 'lisp-indent-function 'defun)
(autoload 'easy-menu-do-define "easymenu" "\
-Not documented
+
\(fn SYMBOL MAPS DOC MENU)" nil nil)
;;;;;; 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" (19714 43298))
+;;;;;; "progmodes/ebnf2ps.el" (20229 34587))
;;; 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" (19714
-;;;;;; 43298))
+;;;;;; ebrowse-tree-mode) "ebrowse" "progmodes/ebrowse.el" (20229
+;;;;;; 34587))
;;; Generated autoloads from progmodes/ebrowse.el
(autoload 'ebrowse-tree-mode "ebrowse" "\
;;;***
\f
;;;### (autoloads (electric-buffer-list) "ebuff-menu" "ebuff-menu.el"
-;;;;;; (19714 43298))
+;;;;;; (20229 34587))
;;; Generated autoloads from ebuff-menu.el
(autoload 'electric-buffer-list "ebuff-menu" "\
;;;***
\f
;;;### (autoloads (Electric-command-history-redo-expression) "echistory"
-;;;;;; "echistory.el" (19562 42953))
+;;;;;; "echistory.el" (20229 34587))
;;; Generated autoloads from echistory.el
(autoload 'Electric-command-history-redo-expression "echistory" "\
;;;***
\f
;;;### (autoloads (ecomplete-setup) "ecomplete" "gnus/ecomplete.el"
-;;;;;; (19714 43298))
+;;;;;; (20229 34587))
;;; Generated autoloads from gnus/ecomplete.el
(autoload 'ecomplete-setup "ecomplete" "\
-Not documented
+
\(fn)" nil nil)
;;;***
\f
-;;;### (autoloads (global-ede-mode) "ede" "cedet/ede.el" (19714 43298))
+;;;### (autoloads (global-ede-mode) "ede" "cedet/ede.el" (20240 47305))
;;; 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" (19720 57265))
+;;;;;; "emacs-lisp/edebug.el" (20229 34587))
;;; 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" (19598 13691))
+;;;;;; ediff-files3 ediff-files) "ediff" "vc/ediff.el" (20229 34587))
;;; Generated autoloads from vc/ediff.el
(autoload 'ediff-files "ediff" "\
\(fn &optional FILE STARTUP-HOOKS MERGE-BUFFER-FILE)" t nil)
(autoload 'ediff-patch-file "ediff" "\
-Run Ediff by patching SOURCE-FILENAME.
+Query for a file name, and then run Ediff by patching that file.
If optional PATCH-BUF is given, use the patch in that buffer
and don't ask the user.
If prefix argument, then: if even argument, assume that the patch is in a
;;;***
\f
;;;### (autoloads (ediff-customize) "ediff-help" "vc/ediff-help.el"
-;;;;;; (19598 13691))
+;;;;;; (20229 34587))
;;; Generated autoloads from vc/ediff-help.el
(autoload 'ediff-customize "ediff-help" "\
-Not documented
+
\(fn)" t nil)
;;;***
\f
;;;### (autoloads (ediff-show-registry) "ediff-mult" "vc/ediff-mult.el"
-;;;;;; (19598 13691))
+;;;;;; (20229 34587))
;;; 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" (19714 43298))
+;;;;;; "ediff-util" "vc/ediff-util.el" (20300 47034))
;;; 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"
-;;;;;; (19640 47194))
+;;;;;; (20229 34587))
;;; Generated autoloads from edmacro.el
-(defvar edmacro-eight-bits nil "\
-*Non-nil if `edit-kbd-macro' should leave 8-bit characters intact.
-Default nil means to write characters above \\177 in octal notation.")
-
(autoload 'edit-kbd-macro "edmacro" "\
Edit a keyboard macro.
At the prompt, type any key sequence which is bound to a keyboard macro.
;;;***
\f
;;;### (autoloads (edt-emulation-on edt-set-scroll-margins) "edt"
-;;;;;; "emulation/edt.el" (19714 43298))
+;;;;;; "emulation/edt.el" (20229 34587))
;;; Generated autoloads from emulation/edt.el
(autoload 'edt-set-scroll-margins "edt" "\
;;;***
\f
;;;### (autoloads (electric-helpify with-electric-help) "ehelp" "ehelp.el"
-;;;;;; (19562 42953))
+;;;;;; (20229 34587))
;;; Generated autoloads from ehelp.el
(autoload 'with-electric-help "ehelp" "\
\(fn THUNK &optional BUFFER NOERASE MINHEIGHT)" nil nil)
(autoload 'electric-helpify "ehelp" "\
-Not documented
+
\(fn FUN &optional NAME)" nil nil)
;;;***
\f
;;;### (autoloads (turn-on-eldoc-mode eldoc-mode eldoc-minor-mode-string)
-;;;;;; "eldoc" "emacs-lisp/eldoc.el" (19562 42953))
+;;;;;; "eldoc" "emacs-lisp/eldoc.el" (20229 34587))
;;; 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" (19714 43298))
+;;;;;; "electric" "electric.el" (20275 12572))
;;; 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" (19562
-;;;;;; 42953))
+;;;### (autoloads (elide-head) "elide-head" "elide-head.el" (20229
+;;;;;; 34587))
;;; 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"
-;;;;;; (19714 43298))
+;;;;;; (20229 34587))
;;; 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" (19562
-;;;;;; 42953))
+;;;;;; elp-instrument-function) "elp" "emacs-lisp/elp.el" (20229
+;;;;;; 34587))
;;; Generated autoloads from emacs-lisp/elp.el
(autoload 'elp-instrument-function "elp" "\
;;;***
\f
-;;;### (autoloads (report-emacs-bug) "emacsbug" "mail/emacsbug.el"
-;;;;;; (19714 43298))
+;;;### (autoloads (emacs-lock-mode) "emacs-lock" "emacs-lock.el"
+;;;;;; (20237 28610))
+;;; 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.
+
+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:
+
+ exit -- Emacs cannot exit while the buffer is locked
+ kill -- the buffer cannot be killed, but Emacs can exit as usual
+ all -- the buffer is locked against both actions
+
+Other values are interpreted as usual.
+
+\(fn &optional ARG)" t nil)
+
+;;;***
+\f
+;;;### (autoloads (report-emacs-bug-query-existing-bugs report-emacs-bug)
+;;;;;; "emacsbug" "mail/emacsbug.el" (20277 28925))
;;; 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" (19714 43298))
+;;;;;; "vc/emerge.el" (20292 6362))
;;; Generated autoloads from vc/emerge.el
(autoload 'emerge-files "emerge" "\
\(fn BUFFER-A BUFFER-B BUFFER-ANCESTOR &optional STARTUP-HOOKS QUIT-HOOKS)" t nil)
(autoload 'emerge-files-command "emerge" "\
-Not documented
+
\(fn)" nil nil)
(autoload 'emerge-files-with-ancestor-command "emerge" "\
-Not documented
+
\(fn)" nil nil)
(autoload 'emerge-files-remote "emerge" "\
-Not documented
+
\(fn FILE-A FILE-B FILE-OUT)" nil nil)
(autoload 'emerge-files-with-ancestor-remote "emerge" "\
-Not documented
+
\(fn FILE-A FILE-B FILE-ANC FILE-OUT)" nil nil)
\(fn ARG FILE REVISION-A REVISION-B ANCESTOR &optional STARTUP-HOOKS QUIT-HOOKS)" t nil)
(autoload 'emerge-merge-directories "emerge" "\
-Not documented
+
\(fn A-DIR B-DIR ANCESTOR-DIR OUTPUT-DIR)" t nil)
;;;***
\f
;;;### (autoloads (enriched-decode enriched-encode enriched-mode)
-;;;;;; "enriched" "textmodes/enriched.el" (19619 52030))
+;;;;;; "enriched" "textmodes/enriched.el" (20273 55692))
;;; 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
\(fn &optional ARG)" t nil)
(autoload 'enriched-encode "enriched" "\
-Not documented
+
\(fn FROM TO ORIG-BUF)" nil nil)
(autoload 'enriched-decode "enriched" "\
-Not documented
+
\(fn FROM TO)" nil nil)
;;;;;; 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" (19714
-;;;;;; 43298))
+;;;;;; epa-list-secret-keys epa-list-keys) "epa" "epa.el" (20229
+;;;;;; 34587))
;;; Generated autoloads from epa.el
(autoload 'epa-list-keys "epa" "\
(autoload 'epa-decrypt-region "epa" "\
Decrypt the current region between START and END.
-Don't use this command in Lisp programs!
+If MAKE-BUFFER-FUNCTION is non-nil, call it to prepare an output buffer.
+It should return that buffer. If it copies the input, it should
+delete the text now being decrypted. It should leave point at the
+proper place to insert the plaintext.
+
+Be careful about using this command in Lisp programs!
Since this function operates on regions, it does some tricks such
as coding-system detection and unibyte/multibyte conversion. If
you are sure how the data in the region should be treated, you
(epg-decrypt-string context (buffer-substring start end))
'utf-8))
-\(fn START END)" t nil)
+\(fn START END &optional MAKE-BUFFER-FUNCTION)" t nil)
(autoload 'epa-decrypt-armor-in-region "epa" "\
Decrypt OpenPGP armors in the current region between START and END.
;;;***
\f
;;;### (autoloads (epa-dired-do-encrypt epa-dired-do-sign epa-dired-do-verify
-;;;;;; epa-dired-do-decrypt) "epa-dired" "epa-dired.el" (19598 13691))
+;;;;;; epa-dired-do-decrypt) "epa-dired" "epa-dired.el" (20229 34587))
;;; 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" (19640 47194))
+;;;;;; "epa-file" "epa-file.el" (20229 34587))
;;; Generated autoloads from epa-file.el
(autoload 'epa-file-handler "epa-file" "\
-Not documented
+
\(fn OPERATION &rest ARGS)" nil nil)
(autoload 'epa-file-enable "epa-file" "\
-Not documented
+
\(fn)" t nil)
(autoload 'epa-file-disable "epa-file" "\
-Not documented
+
\(fn)" t nil)
\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" (19714 43298))
+;;;;;; "epa-mail" "epa-mail.el" (20273 55691))
;;; 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" (19714 43298))
+;;;### (autoloads (epg-make-context) "epg" "epg.el" (20241 25657))
;;; 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" (19714 43298))
+;;;;;; "epg-config" "epg-config.el" (20229 34587))
;;; 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" (19598 13691))
+;;;### (autoloads (erc-handle-irc-url erc-tls erc erc-select-read-args)
+;;;;;; "erc" "erc/erc.el" (20230 55355))
;;; Generated autoloads from erc/erc.el
(autoload 'erc-select-read-args "erc" "\
`erc-compute-port', `erc-compute-nick' and `erc-compute-full-name' will
be invoked for the values of the other parameters.
-\(fn &key (SERVER (erc-compute-server)) (PORT (erc-compute-port)) (NICK (erc-compute-nick)) PASSWORD (FULL-NAME (erc-compute-full-name)))" t nil)
+\(fn &key (server (erc-compute-server)) (port (erc-compute-port)) (nick (erc-compute-nick)) PASSWORD (full-name (erc-compute-full-name)))" t nil)
(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" (19562
-;;;;;; 42953))
+;;;### (autoloads nil "erc-autoaway" "erc/erc-autoaway.el" (20229
+;;;;;; 34587))
;;; Generated autoloads from erc/erc-autoaway.el
(autoload 'erc-autoaway-mode "erc-autoaway")
;;;***
\f
-;;;### (autoloads nil "erc-button" "erc/erc-button.el" (19562 42953))
+;;;### (autoloads nil "erc-button" "erc/erc-button.el" (20229 34587))
;;; Generated autoloads from erc/erc-button.el
(autoload 'erc-button-mode "erc-button" nil t)
;;;***
\f
-;;;### (autoloads nil "erc-capab" "erc/erc-capab.el" (19562 42953))
+;;;### (autoloads nil "erc-capab" "erc/erc-capab.el" (20229 34587))
;;; 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" (19562 42953))
+;;;### (autoloads nil "erc-compat" "erc/erc-compat.el" (20300 47034))
;;; 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" (19562 42953))
+;;;;;; "erc-dcc" "erc/erc-dcc.el" (20229 34587))
;;; Generated autoloads from erc/erc-dcc.el
(autoload 'erc-dcc-mode "erc-dcc")
;;;;;; 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"
-;;;;;; (19562 42953))
+;;;;;; (20229 34587))
;;; Generated autoloads from erc/erc-ezbounce.el
(autoload 'erc-cmd-ezb "erc-ezbounce" "\
\(fn SERVER PORT)" nil nil)
(autoload 'erc-ezb-lookup-action "erc-ezbounce" "\
-Not documented
+
\(fn MESSAGE)" nil nil)
;;;***
\f
-;;;### (autoloads (erc-fill) "erc-fill" "erc/erc-fill.el" (19562
-;;;;;; 42953))
+;;;### (autoloads (erc-fill) "erc-fill" "erc/erc-fill.el" (20229
+;;;;;; 34587))
;;; Generated autoloads from erc/erc-fill.el
(autoload 'erc-fill-mode "erc-fill" nil t)
;;;***
\f
-;;;### (autoloads nil "erc-hecomplete" "erc/erc-hecomplete.el" (19591
-;;;;;; 62571))
-;;; Generated autoloads from erc/erc-hecomplete.el
- (autoload 'erc-hecomplete-mode "erc-hecomplete" nil t)
-
-;;;***
-\f
;;;### (autoloads (erc-identd-stop erc-identd-start) "erc-identd"
-;;;;;; "erc/erc-identd.el" (19562 42953))
+;;;;;; "erc/erc-identd.el" (20229 34587))
;;; Generated autoloads from erc/erc-identd.el
(autoload 'erc-identd-mode "erc-identd")
\(fn &optional PORT)" t nil)
(autoload 'erc-identd-stop "erc-identd" "\
-Not documented
+
\(fn &rest IGNORE)" t nil)
;;;***
\f
;;;### (autoloads (erc-create-imenu-index) "erc-imenu" "erc/erc-imenu.el"
-;;;;;; (19562 42953))
+;;;;;; (20229 34587))
;;; Generated autoloads from erc/erc-imenu.el
(autoload 'erc-create-imenu-index "erc-imenu" "\
-Not documented
+
\(fn)" nil nil)
;;;***
\f
-;;;### (autoloads nil "erc-join" "erc/erc-join.el" (19598 13691))
+;;;### (autoloads nil "erc-join" "erc/erc-join.el" (20274 22975))
;;; Generated autoloads from erc/erc-join.el
(autoload 'erc-autojoin-mode "erc-join" nil t)
;;;***
\f
-;;;### (autoloads nil "erc-list" "erc/erc-list.el" (19640 47194))
+;;;### (autoloads nil "erc-list" "erc/erc-list.el" (20229 34587))
;;; 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" (19562 42953))
+;;;;;; "erc/erc-log.el" (20229 34587))
;;; 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"
-;;;;;; (19562 42953))
+;;;;;; (20229 34587))
;;; Generated autoloads from erc/erc-match.el
(autoload 'erc-match-mode "erc-match")
;;;***
\f
-;;;### (autoloads nil "erc-menu" "erc/erc-menu.el" (19562 42953))
+;;;### (autoloads nil "erc-menu" "erc/erc-menu.el" (20229 34587))
;;; 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"
-;;;;;; (19562 42953))
+;;;;;; (20229 34587))
;;; 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" (19562 42953))
+;;;;;; "erc/erc-networks.el" (20229 34587))
;;; 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" (19562 42953))
+;;;;;; "erc/erc-notify.el" (20229 34587))
;;; 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)
(autoload 'pcomplete/erc-mode/NOTIFY "erc-notify" "\
-Not documented
+
\(fn)" nil nil)
;;;***
\f
-;;;### (autoloads nil "erc-page" "erc/erc-page.el" (19562 42953))
+;;;### (autoloads nil "erc-page" "erc/erc-page.el" (20237 28610))
;;; Generated autoloads from erc/erc-page.el
(autoload 'erc-page-mode "erc-page")
;;;***
\f
-;;;### (autoloads nil "erc-pcomplete" "erc/erc-pcomplete.el" (19562
-;;;;;; 42953))
+;;;### (autoloads nil "erc-pcomplete" "erc/erc-pcomplete.el" (20229
+;;;;;; 34587))
;;; Generated autoloads from erc/erc-pcomplete.el
(autoload 'erc-completion-mode "erc-pcomplete" nil t)
;;;***
\f
-;;;### (autoloads nil "erc-replace" "erc/erc-replace.el" (19562 42953))
+;;;### (autoloads nil "erc-replace" "erc/erc-replace.el" (20229 34587))
;;; Generated autoloads from erc/erc-replace.el
(autoload 'erc-replace-mode "erc-replace")
;;;***
\f
-;;;### (autoloads nil "erc-ring" "erc/erc-ring.el" (19562 42953))
+;;;### (autoloads nil "erc-ring" "erc/erc-ring.el" (20229 34587))
;;; 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" (19562 42953))
+;;;;;; "erc-services" "erc/erc-services.el" (20229 34587))
;;; Generated autoloads from erc/erc-services.el
(autoload 'erc-services-mode "erc-services" nil t)
;;;***
\f
-;;;### (autoloads nil "erc-sound" "erc/erc-sound.el" (19562 42953))
+;;;### (autoloads nil "erc-sound" "erc/erc-sound.el" (20229 34587))
;;; Generated autoloads from erc/erc-sound.el
(autoload 'erc-sound-mode "erc-sound")
;;;***
\f
;;;### (autoloads (erc-speedbar-browser) "erc-speedbar" "erc/erc-speedbar.el"
-;;;;;; (19562 42953))
+;;;;;; (20229 34587))
;;; Generated autoloads from erc/erc-speedbar.el
(autoload 'erc-speedbar-browser "erc-speedbar" "\
;;;***
\f
-;;;### (autoloads nil "erc-spelling" "erc/erc-spelling.el" (19562
-;;;;;; 42953))
+;;;### (autoloads nil "erc-spelling" "erc/erc-spelling.el" (20229
+;;;;;; 34587))
;;; Generated autoloads from erc/erc-spelling.el
(autoload 'erc-spelling-mode "erc-spelling" nil t)
;;;***
\f
-;;;### (autoloads nil "erc-stamp" "erc/erc-stamp.el" (19562 42953))
+;;;### (autoloads nil "erc-stamp" "erc/erc-stamp.el" (20229 34587))
;;; 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"
-;;;;;; (19562 42953))
+;;;;;; (20229 34587))
;;; 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" (19562 42953))
+;;;;;; "erc-truncate" "erc/erc-truncate.el" (20229 34587))
;;; 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"
-;;;;;; (19640 47194))
+;;;;;; (20229 34587))
;;; Generated autoloads from erc/erc-xdcc.el
(autoload 'erc-xdcc-mode "erc-xdcc")
;;;***
\f
-;;;### (autoloads (eshell-mode) "esh-mode" "eshell/esh-mode.el" (19619
-;;;;;; 52030))
-;;; Generated autoloads from eshell/esh-mode.el
+;;;### (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" (20300 47034))
+;;; Generated autoloads from emacs-lisp/ert.el
-(autoload 'eshell-mode "esh-mode" "\
-Emacs shell interactive mode.
+(autoload 'ert-deftest "ert" "\
+Define NAME (a symbol) as a test.
-\\{eshell-mode-map}
+BODY is evaluated as a `progn' when the test is run. It should
+signal a condition on failure or just return if the test passes.
-\(fn)" nil nil)
+`should', `should-not' and `should-error' are useful for
+assertions in BODY.
-;;;***
-\f
-;;;### (autoloads (eshell-test) "esh-test" "eshell/esh-test.el" (19714
-;;;;;; 43298))
-;;; Generated autoloads from eshell/esh-test.el
+Use `ert' to run tests interactively.
-(autoload 'eshell-test "esh-test" "\
-Test Eshell to verify that it works as expected.
+Tests that are expected to fail can be marked as such
+using :expected-result. See `ert-test-result-type-p' for a
+description of valid values for RESULT-TYPE.
-\(fn &optional ARG)" t nil)
+\(fn NAME () [DOCSTRING] [:expected-result RESULT-TYPE] [:tags '(TAG...)] BODY...)" nil (quote macro))
-;;;***
-\f
-;;;### (autoloads (eshell-command-result eshell-command eshell) "eshell"
-;;;;;; "eshell/eshell.el" (19562 42953))
-;;; Generated autoloads from eshell/eshell.el
+(put 'ert-deftest 'lisp-indent-function '2)
-(autoload 'eshell "eshell" "\
-Create an interactive Eshell buffer.
-The buffer used for Eshell sessions is determined by the value of
-`eshell-buffer-name'. If there is already an Eshell session active in
-that buffer, Emacs will simply switch to it. Otherwise, a new session
-will begin. A numeric prefix arg (as in `C-u 42 M-x eshell RET')
-switches to the session with that number, creating it if necessary. A
-nonnumeric prefix arg means to create a new session. Returns the
-buffer selected (or created).
+(put 'ert-deftest 'doc-string-elt '3)
-\(fn &optional ARG)" t nil)
+(put 'ert-deftest 'lisp-indent-function 2)
-(autoload 'eshell-command "eshell" "\
-Execute the Eshell command string COMMAND.
-With prefix ARG, insert output into the current buffer at point.
+(put 'ert-info 'lisp-indent-function 1)
+
+(autoload 'ert-run-tests-batch "ert" "\
+Run the tests specified by SELECTOR, printing results to the terminal.
+
+SELECTOR works as described in `ert-select-tests', except if
+SELECTOR is nil, in which case all tests rather than none will be
+run; this makes the command line \"emacs -batch -l my-tests.el -f
+ert-run-tests-batch-and-exit\" useful.
+
+Returns the stats object.
+
+\(fn &optional SELECTOR)" nil nil)
+
+(autoload 'ert-run-tests-batch-and-exit "ert" "\
+Like `ert-run-tests-batch', but exits Emacs when done.
+
+The exit status will be 0 if all test results were as expected, 1
+on unexpected results, or 2 if the tool detected an error outside
+of the tests (e.g. invalid SELECTOR or bug in the code that runs
+the tests).
+
+\(fn &optional SELECTOR)" nil nil)
+
+(autoload 'ert-run-tests-interactively "ert" "\
+Run the tests specified by SELECTOR and display the results in a buffer.
+
+SELECTOR works as described in `ert-select-tests'.
+OUTPUT-BUFFER-NAME and MESSAGE-FN should normally be nil; they
+are used for automated self-tests and specify which buffer to use
+and how to display message.
+
+\(fn SELECTOR &optional OUTPUT-BUFFER-NAME MESSAGE-FN)" t nil)
+
+(defalias 'ert 'ert-run-tests-interactively)
+
+(autoload 'ert-describe-test "ert" "\
+Display the documentation for TEST-OR-TEST-NAME (a symbol or ert-test).
+
+\(fn TEST-OR-TEST-NAME)" t nil)
+
+;;;***
+\f
+;;;### (autoloads (ert-kill-all-test-buffers) "ert-x" "emacs-lisp/ert-x.el"
+;;;;;; (20270 25925))
+;;; Generated autoloads from emacs-lisp/ert-x.el
+
+(put 'ert-with-test-buffer 'lisp-indent-function 1)
+
+(autoload 'ert-kill-all-test-buffers "ert-x" "\
+Kill all test buffers that are still live.
+
+\(fn)" t nil)
+
+;;;***
+\f
+;;;### (autoloads (eshell-mode) "esh-mode" "eshell/esh-mode.el" (20229
+;;;;;; 34587))
+;;; Generated autoloads from eshell/esh-mode.el
+
+(autoload 'eshell-mode "esh-mode" "\
+Emacs shell interactive mode.
+
+\\{eshell-mode-map}
+
+\(fn)" nil nil)
+
+;;;***
+\f
+;;;### (autoloads (eshell-command-result eshell-command eshell) "eshell"
+;;;;;; "eshell/eshell.el" (20300 47034))
+;;; Generated autoloads from eshell/eshell.el
+
+(autoload 'eshell "eshell" "\
+Create an interactive Eshell buffer.
+The buffer used for Eshell sessions is determined by the value of
+`eshell-buffer-name'. If there is already an Eshell session active in
+that buffer, Emacs will simply switch to it. Otherwise, a new session
+will begin. A numeric prefix arg (as in `C-u 42 M-x eshell RET')
+switches to the session with that number, creating it if necessary. A
+nonnumeric prefix arg means to create a new session. Returns the
+buffer selected (or created).
+
+\(fn &optional ARG)" t nil)
+
+(autoload 'eshell-command "eshell" "\
+Execute the Eshell command string COMMAND.
+With prefix ARG, insert output into the current buffer at point.
\(fn &optional COMMAND ARG)" t nil)
;;;;;; 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"
-;;;;;; (19714 43298))
+;;;;;; (20237 28610))
;;; Generated autoloads from progmodes/etags.el
(defvar tags-file-name nil "\
Stops when a match is found.
To continue searching for next match, use command \\[tags-loop-continue].
-See documentation of variable `tags-file-name'.
+If FILE-LIST-FORM is non-nil, it should be a form that, when
+evaluated, will return a list of file names. The search will be
+restricted to these files.
+
+Aleso see the documentation of the `tags-file-name' variable.
\(fn REGEXP &optional FILE-LIST-FORM)" t nil)
;;;;;; 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"
-;;;;;; (19562 42953))
+;;;;;; (20229 34587))
;;; Generated autoloads from language/ethio-util.el
(autoload 'setup-ethiopic-environment-internal "ethio-util" "\
-Not documented
+
\(fn)" nil nil)
\(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)
\(fn ARG)" t nil)
(autoload 'ethio-composition-function "ethio-util" "\
-Not documented
+
\(fn POS TO FONT-OBJECT STRING)" 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"
-;;;;;; (19714 43298))
+;;;;;; (20300 47034))
;;; 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" (19598 13691))
+;;;;;; "eudc-bob" "net/eudc-bob.el" (20229 34587))
;;; 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" (19598 13691))
+;;;;;; "eudc-export" "net/eudc-export.el" (20229 34587))
;;; 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"
-;;;;;; (19640 47194))
+;;;;;; (20229 34587))
;;; Generated autoloads from net/eudc-hotlist.el
(autoload 'eudc-edit-hotlist "eudc-hotlist" "\
;;;***
\f
-;;;### (autoloads (ewoc-create) "ewoc" "emacs-lisp/ewoc.el" (19591
-;;;;;; 62571))
+;;;### (autoloads (ewoc-create) "ewoc" "emacs-lisp/ewoc.el" (20300
+;;;;;; 47034))
;;; 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"
-;;;;;; (19562 42953))
+;;;;;; (20229 34587))
;;; 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"
-;;;;;; (19562 42953))
+;;;;;; (20229 34587))
;;; 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" (19714 43298))
+;;;### (autoloads (f90-mode) "f90" "progmodes/f90.el" (20257 13883))
;;; Generated autoloads from progmodes/f90.el
(autoload 'f90-mode "f90" "\
`f90-program-indent'
Extra indentation within program/module/subroutine/function blocks
(default 2).
+`f90-associate-indent'
+ Extra indentation within associate blocks (default 2).
+`f90-critical-indent'
+ Extra indentation within critical/block blocks (default 2).
`f90-continuation-indent'
Extra indentation applied to continuation lines (default 5).
`f90-comment-region'
;;;### (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" (19714
-;;;;;; 43298))
+;;;;;; face-remap-add-relative) "face-remap" "face-remap.el" (20273
+;;;;;; 55691))
;;; Generated autoloads from face-remap.el
(autoload 'face-remap-add-relative "face-remap" "\
(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)
\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" (19619 52030))
+;;;;;; feedmail-send-it) "feedmail" "mail/feedmail.el" (20300 47034))
;;; 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" (19591 62571))
+;;;;;; find-file-at-point ffap-next) "ffap" "ffap.el" (20292 53022))
;;; Generated autoloads from ffap.el
(autoload 'ffap-next "ffap" "\
;;;### (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" (19714 43298))
+;;;;;; "filecache" "filecache.el" (20229 34587))
;;; 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" (19598 13691))
+;;;;;; add-file-local-variable) "files-x" "files-x.el" (20229 34587))
;;; Generated autoloads from files-x.el
(autoload 'add-file-local-variable "files-x" "\
;;;***
\f
-;;;### (autoloads (filesets-init) "filesets" "filesets.el" (19619
-;;;;;; 52030))
+;;;### (autoloads (filesets-init) "filesets" "filesets.el" (20300
+;;;;;; 47034))
;;; Generated autoloads from filesets.el
(autoload 'filesets-init "filesets" "\
;;;***
\f
-;;;### (autoloads (find-cmd) "find-cmd" "find-cmd.el" (19562 42953))
+;;;### (autoloads (find-cmd) "find-cmd" "find-cmd.el" (20229 34587))
;;; Generated autoloads from find-cmd.el
(autoload 'find-cmd "find-cmd" "\
;;;***
\f
-;;;### (autoloads (find-grep-dired find-name-dired find-dired find-grep-options
-;;;;;; find-ls-subdir-switches find-ls-option) "find-dired" "find-dired.el"
-;;;;;; (19562 42953))
+;;;### (autoloads (find-grep-dired find-name-dired find-dired) "find-dired"
+;;;;;; "find-dired.el" (20239 38674))
;;; Generated autoloads from find-dired.el
-(defvar find-ls-option (if (eq system-type 'berkeley-unix) (purecopy '("-ls" . "-gilsb")) (purecopy '("-exec ls -ld {} \\;" . "-ld"))) "\
-Description of the option to `find' to produce an `ls -l'-type listing.
-This is a cons of two strings (FIND-OPTION . LS-SWITCHES). FIND-OPTION
-gives the option (or options) to `find' that produce the desired output.
-LS-SWITCHES is a list of `ls' switches to tell dired how to parse the output.")
-
-(custom-autoload 'find-ls-option "find-dired" t)
-
-(defvar find-ls-subdir-switches (purecopy "-al") "\
-`ls' switches for inserting subdirectories in `*Find*' buffers.
-This should contain the \"-l\" switch.
-Use the \"-F\" or \"-b\" switches if and only if you also use
-them for `find-ls-option'.")
-
-(custom-autoload 'find-ls-subdir-switches "find-dired" t)
-
-(defvar find-grep-options (purecopy (if (or (eq system-type 'berkeley-unix) (string-match "solaris2" system-configuration) (string-match "irix" system-configuration)) "-s" "-q")) "\
-Option to grep to be as silent as possible.
-On Berkeley systems, this is `-s'; on Posix, and with GNU grep, `-q' does it.
-On other systems, the closest you can come is to use `-l'.")
-
-(custom-autoload 'find-grep-options "find-dired" t)
-
(autoload 'find-dired "find-dired" "\
Run `find' and go into Dired mode on a buffer of the output.
-The command run (after changing into DIR) is
+The command run (after changing into DIR) is essentially
find . \\( ARGS \\) -ls
-except that the variable `find-ls-option' specifies what to use
-as the final argument.
+except that the car of the variable `find-ls-option' specifies what to
+use in place of \"-ls\" as the final argument.
\(fn DIR ARGS)" t nil)
Find files in DIR containing a regexp REGEXP and start Dired on output.
The command run (after changing into DIR) is
- find . -exec grep -s -e REGEXP {} \\; -ls
+ find . \\( -type f -exec `grep-program' `find-grep-options' \\
+ -e REGEXP {} \\; \\) -ls
-Thus ARG can also contain additional grep options.
+where the car of the variable `find-ls-option' specifies what to
+use in place of \"-ls\" as the final argument.
\(fn DIR REGEXP)" t nil)
\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"
-;;;;;; (19562 42953))
+;;;;;; (20229 34587))
;;; 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)))) "\
;;;;;; 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" (19714 43298))
+;;;;;; "emacs-lisp/find-func.el" (20229 34587))
;;; Generated autoloads from emacs-lisp/find-func.el
(autoload 'find-library "find-func" "\
not selected. If the function definition can't be found in
the buffer, returns (BUFFER).
+If FUNCTION is a built-in function, this function normally
+attempts to find it in the Emacs C sources; however, if LISP-ONLY
+is non-nil, signal an error instead.
+
If the file where FUNCTION is defined is not known, then it is
searched for in `find-function-source-path' if non-nil, otherwise
in `load-path'.
-\(fn FUNCTION)" nil nil)
+\(fn FUNCTION &optional LISP-ONLY)" nil nil)
(autoload 'find-function "find-func" "\
Find the definition of the FUNCTION near point.
;;;***
\f
;;;### (autoloads (find-lisp-find-dired-filter find-lisp-find-dired-subdirectories
-;;;;;; find-lisp-find-dired) "find-lisp" "find-lisp.el" (19591 62571))
+;;;;;; find-lisp-find-dired) "find-lisp" "find-lisp.el" (20229 34587))
;;; 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" (19714 43298))
+;;;;;; "finder" "finder.el" (20229 34587))
;;; Generated autoloads from finder.el
(autoload 'finder-list-keywords "finder" "\
;;;***
\f
;;;### (autoloads (enable-flow-control-on enable-flow-control) "flow-ctrl"
-;;;;;; "flow-ctrl.el" (19591 62571))
+;;;;;; "flow-ctrl.el" (20229 34587))
;;; 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"
-;;;;;; (19619 52030))
+;;;;;; (20229 34587))
;;; Generated autoloads from gnus/flow-fill.el
(autoload 'fill-flowed-encode "flow-fill" "\
-Not documented
+
\(fn &optional BUFFER)" nil nil)
(autoload 'fill-flowed "flow-fill" "\
-Not documented
+
\(fn &optional BUFFER DELETE-SPACE)" nil nil)
;;;***
\f
-;;;### (autoloads (flymake-mode-off flymake-mode-on flymake-mode)
-;;;;;; "flymake" "progmodes/flymake.el" (19714 43298))
+;;;### (autoloads (flymake-find-file-hook flymake-mode-off flymake-mode-on
+;;;;;; flymake-mode) "flymake" "progmodes/flymake.el" (20273 55692))
;;; 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)
(autoload 'flymake-mode-off "flymake" "\
Turn flymake mode off.
+\(fn)" nil nil)
+
+(autoload 'flymake-find-file-hook "flymake" "\
+
+
\(fn)" nil 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" (19714 43298))
+;;;;;; "flyspell" "textmodes/flyspell.el" (20229 34587))
;;; 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"
-;;;;;; (19562 42953))
+;;;;;; (20229 34587))
;;; 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.
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:
+in your `~/.emacs' file, replacing [f7] by your favorite key:
(global-set-key [f7] 'follow-delete-other-windows-and-split)
\(fn &optional ARG)" t nil)
;;;***
\f
-;;;### (autoloads (footnote-mode) "footnote" "mail/footnote.el" (19562
-;;;;;; 42953))
+;;;### (autoloads (footnote-mode) "footnote" "mail/footnote.el" (20229
+;;;;;; 34587))
;;; 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" (19562 42953))
+;;;;;; "forms" "forms.el" (20229 34587))
;;; Generated autoloads from forms.el
(autoload 'forms-mode "forms" "\
;;;***
\f
;;;### (autoloads (fortran-mode) "fortran" "progmodes/fortran.el"
-;;;;;; (19714 43298))
+;;;;;; (20229 34587))
;;; 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" (19714 43298))
+;;;;;; fortune-add-fortune) "fortune" "play/fortune.el" (20229 34587))
;;; Generated autoloads from play/fortune.el
(autoload 'fortune-add-fortune "fortune" "\
;;;***
\f
;;;### (autoloads (gdb gdb-enable-debug) "gdb-mi" "progmodes/gdb-mi.el"
-;;;;;; (19714 43298))
+;;;;;; (20298 5305))
;;; Generated autoloads from progmodes/gdb-mi.el
(defvar gdb-enable-debug nil "\
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" (19598
-;;;;;; 13691))
+;;;;;; define-generic-mode) "generic" "emacs-lisp/generic.el" (20229
+;;;;;; 34587))
;;; Generated autoloads from emacs-lisp/generic.el
(defvar generic-mode-list nil "\
;;;***
\f
;;;### (autoloads (glasses-mode) "glasses" "progmodes/glasses.el"
-;;;;;; (19562 42953))
+;;;;;; (20273 55692))
;;; 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"
-;;;;;; (19640 47194))
+;;;;;; (20300 47034))
;;; 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" (19714 43298))
+;;;;;; gnus-slave-no-server) "gnus" "gnus/gnus.el" (20276 33121))
;;; 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" (19714 43298))
+;;;;;; "gnus/gnus-agent.el" (20300 47034))
;;; Generated autoloads from gnus/gnus-agent.el
(autoload 'gnus-unplugged "gnus-agent" "\
;;;***
\f
;;;### (autoloads (gnus-article-prepare-display) "gnus-art" "gnus/gnus-art.el"
-;;;;;; (19714 43298))
+;;;;;; (20280 61753))
;;; 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" (19714 43298))
+;;;;;; "gnus-bookmark" "gnus/gnus-bookmark.el" (20229 34587))
;;; 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" (19714
-;;;;;; 43298))
+;;;;;; gnus-jog-cache) "gnus-cache" "gnus/gnus-cache.el" (20229
+;;;;;; 34587))
;;; 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" (19714 43298))
+;;;;;; "gnus-delay" "gnus/gnus-delay.el" (20229 34587))
;;; 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" (19714 43298))
+;;;;;; "gnus-diary" "gnus/gnus-diary.el" (20229 34587))
;;; Generated autoloads from gnus/gnus-diary.el
(autoload 'gnus-user-format-function-d "gnus-diary" "\
-Not documented
+
\(fn HEADER)" nil nil)
(autoload 'gnus-user-format-function-D "gnus-diary" "\
-Not documented
+
\(fn HEADER)" nil nil)
;;;***
\f
;;;### (autoloads (turn-on-gnus-dired-mode) "gnus-dired" "gnus/gnus-dired.el"
-;;;;;; (19714 43298))
+;;;;;; (20229 34587))
;;; 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"
-;;;;;; (19714 43298))
+;;;;;; (20229 34587))
;;; 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" (19640
-;;;;;; 47194))
+;;;;;; gnus-random-x-face) "gnus-fun" "gnus/gnus-fun.el" (20229
+;;;;;; 34587))
;;; 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" (19717 39999))
+;;;;;; "gnus-gravatar" "gnus/gnus-gravatar.el" (20229 34587))
;;; 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" (19714 43298))
+;;;;;; "gnus-group" "gnus/gnus-group.el" (20266 28861))
;;; 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" (19714 43298))
+;;;;;; "gnus/gnus-html.el" (20273 55604))
;;; Generated autoloads from gnus/gnus-html.el
(autoload 'gnus-article-html "gnus-html" "\
-Not documented
+
\(fn &optional HANDLE)" nil nil)
(autoload 'gnus-html-prefetch-images "gnus-html" "\
-Not documented
+
\(fn SUMMARY)" nil nil)
;;;***
\f
;;;### (autoloads (gnus-batch-score) "gnus-kill" "gnus/gnus-kill.el"
-;;;;;; (19640 47194))
+;;;;;; (20229 34587))
;;; 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"
-;;;;;; (19598 13691))
+;;;;;; (20229 34587))
;;; Generated autoloads from gnus/gnus-ml.el
(autoload 'turn-on-gnus-mailing-list-mode "gnus-ml" "\
-Not documented
+
\(fn)" nil nil)
\f
;;;### (autoloads (gnus-group-split-fancy gnus-group-split gnus-group-split-update
;;;;;; gnus-group-split-setup) "gnus-mlspl" "gnus/gnus-mlspl.el"
-;;;;;; (19598 13691))
+;;;;;; (20229 34587))
;;; 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" (19714 43298))
+;;;;;; "gnus-msg" "gnus/gnus-msg.el" (20290 11197))
;;; 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)" t nil)
+\(fn &optional TO SUBJECT OTHER-HEADERS CONTINUE SWITCH-ACTION YANK-ACTION SEND-ACTIONS RETURN-ACTION)" t nil)
(autoload 'gnus-button-mailto "gnus-msg" "\
Mail to ADDRESS.
\f
;;;### (autoloads (gnus-treat-newsgroups-picon gnus-treat-mail-picon
;;;;;; gnus-treat-from-picon) "gnus-picon" "gnus/gnus-picon.el"
-;;;;;; (19640 47194))
+;;;;;; (20279 40897))
;;; 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" (19619 52030))
+;;;;;; "gnus/gnus-range.el" (20229 34587))
;;; Generated autoloads from gnus/gnus-range.el
(autoload 'gnus-sorted-difference "gnus-range" "\
\(fn LIST1 LIST2)" nil nil)
(autoload 'gnus-intersection "gnus-range" "\
-Not documented
+
\(fn LIST1 LIST2)" nil nil)
;;;***
\f
;;;### (autoloads (gnus-registry-install-hooks gnus-registry-initialize)
-;;;;;; "gnus-registry" "gnus/gnus-registry.el" (19714 43298))
+;;;;;; "gnus-registry" "gnus/gnus-registry.el" (20279 40897))
;;; 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" (19598
-;;;;;; 13691))
+;;;;;; gnus-sieve-update) "gnus-sieve" "gnus/gnus-sieve.el" (20229
+;;;;;; 34587))
;;; Generated autoloads from gnus/gnus-sieve.el
(autoload 'gnus-sieve-update "gnus-sieve" "\
\(fn)" t nil)
(autoload 'gnus-sieve-article-add-rule "gnus-sieve" "\
-Not documented
+
\(fn)" t nil)
;;;***
\f
;;;### (autoloads (gnus-update-format) "gnus-spec" "gnus/gnus-spec.el"
-;;;;;; (19640 47194))
+;;;;;; (20229 34587))
;;; Generated autoloads from gnus/gnus-spec.el
(autoload 'gnus-update-format "gnus-spec" "\
;;;***
\f
;;;### (autoloads (gnus-declare-backend) "gnus-start" "gnus/gnus-start.el"
-;;;;;; (19714 43298))
+;;;;;; (20286 14149))
;;; 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"
-;;;;;; (19714 43298))
+;;;;;; (20291 32066))
;;; 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" (19640 47194))
+;;;;;; "gnus-sync" "gnus/gnus-sync.el" (20229 34587))
;;; Generated autoloads from gnus/gnus-sync.el
(autoload 'gnus-sync-initialize "gnus-sync" "\
;;;***
\f
;;;### (autoloads (gnus-add-configuration) "gnus-win" "gnus/gnus-win.el"
-;;;;;; (19714 43298))
+;;;;;; (20232 10689))
;;; Generated autoloads from gnus/gnus-win.el
(autoload 'gnus-add-configuration "gnus-win" "\
;;;***
\f
-;;;### (autoloads (gomoku) "gomoku" "play/gomoku.el" (19714 43298))
+;;;### (autoloads (gnutls-min-prime-bits) "gnutls" "net/gnutls.el"
+;;;;;; (20286 55781))
+;;; 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.
+
+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" (20300 47034))
;;; 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" (19562
-;;;;;; 42953))
+;;;;;; goto-address-at-point) "goto-addr" "net/goto-addr.el" (20273
+;;;;;; 55692))
;;; 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) "gravatar" "gnus/gravatar.el"
-;;;;;; (19640 47194))
+;;;### (autoloads (gravatar-retrieve-synchronously gravatar-retrieve)
+;;;;;; "gravatar" "gnus/gravatar.el" (20279 40897))
;;; Generated autoloads from gnus/gravatar.el
(autoload 'gravatar-retrieve "gravatar" "\
\(fn MAIL-ADDRESS CB &optional CBARGS)" nil nil)
+(autoload 'gravatar-retrieve-synchronously "gravatar" "\
+Retrieve MAIL-ADDRESS gravatar and returns it.
+
+\(fn MAIL-ADDRESS)" nil nil)
+
;;;***
\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" (19714 43298))
+;;;;;; grep-window-height) "grep" "progmodes/grep.el" (20255 25045))
;;; Generated autoloads from progmodes/grep.el
(defvar grep-window-height nil "\
(custom-autoload 'grep-setup-hook "grep" t)
-(defconst grep-regexp-alist '(("^\\(.+?\\)\\(:[ ]*\\)\\([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-find-use-xargs nil "\
-Non-nil means that `grep-find' uses the `xargs' utility by default.
-If `exec', use `find -exec'.
+How to invoke find and grep.
+If `exec', use `find -exec {} ;'.
+If `exec-plus' use `find -exec {} +'.
If `gnu', use `find -print0' and `xargs -0'.
-Any other non-nil value means to use `find -print' and `xargs'.
+Any other value means to use `find -print' and `xargs'.
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'.
\(fn)" nil nil)
(autoload 'grep-compute-defaults "grep" "\
-Not documented
+
\(fn)" nil nil)
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" (19562 42953))
+;;;### (autoloads (gs-load-image) "gs" "gs.el" (20229 34587))
;;; 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" (19714 43298))
+;;;;;; xdb dbx sdb gud-gdb) "gud" "progmodes/gud.el" (20270 25925))
;;; 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" (19562
-;;;;;; 42953))
+;;;### (autoloads (handwrite) "handwrite" "play/handwrite.el" (20300
+;;;;;; 47034))
;;; Generated autoloads from play/handwrite.el
(autoload 'handwrite "handwrite" "\
The functions `handwrite-10pt', `handwrite-11pt', `handwrite-12pt'
and `handwrite-13pt' set up for various sizes of output.
-Variables: handwrite-linespace (default 12)
- handwrite-fontsize (default 11)
- handwrite-numlines (default 60)
- handwrite-pagenumbering (default nil)
+Variables: `handwrite-linespace' (default 12)
+ `handwrite-fontsize' (default 11)
+ `handwrite-numlines' (default 60)
+ `handwrite-pagenumbering' (default nil)
\(fn)" t nil)
;;;***
\f
;;;### (autoloads (hanoi-unix-64 hanoi-unix hanoi) "hanoi" "play/hanoi.el"
-;;;;;; (19562 42953))
+;;;;;; (19981 40664))
;;; 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" (19640 47194))
+;;;;;; "hashcash" "mail/hashcash.el" (20229 34587))
;;; 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" (19562 42953))
+;;;;;; help-at-pt-string) "help-at-pt" "help-at-pt.el" (20229 34587))
;;; 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" (19714 43298))
+;;;;;; "help-fns" "help-fns.el" (20298 5305))
;;; Generated autoloads from help-fns.el
(autoload 'describe-function "help-fns" "\
\(fn OBJECT TYPE)" nil nil)
(autoload 'describe-function-1 "help-fns" "\
-Not documented
+
\(fn FUNCTION)" nil nil)
;;;***
\f
;;;### (autoloads (three-step-help) "help-macro" "help-macro.el"
-;;;;;; (19598 13691))
+;;;;;; (20249 19777))
;;; 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" "help-mode.el" (19640
-;;;;;; 47194))
+;;;;;; help-mode-setup help-mode) "help-mode" "help-mode.el" (20229
+;;;;;; 34587))
;;; Generated autoloads from help-mode.el
(autoload 'help-mode "help-mode" "\
\(fn)" t nil)
(autoload 'help-mode-setup "help-mode" "\
-Not documented
+
\(fn)" nil nil)
(autoload 'help-mode-finish "help-mode" "\
-Not documented
+
\(fn)" nil nil)
(autoload 'help-buffer "help-mode" "\
Return the name of a buffer for inserting help.
If `help-xref-following' is non-nil, this is the name of the
-current buffer.
-Otherwise, it is *Help*; if no buffer with that name currently
-exists, it is created.
+current buffer. Signal an error if this buffer is not derived
+from `help-mode'.
+Otherwise, return \"*Help*\", creating a buffer with that name if
+it does not already exist.
\(fn)" nil nil)
;;;***
\f
;;;### (autoloads (Helper-help Helper-describe-bindings) "helper"
-;;;;;; "emacs-lisp/helper.el" (19598 13691))
+;;;;;; "emacs-lisp/helper.el" (20229 34587))
;;; Generated autoloads from emacs-lisp/helper.el
(autoload 'Helper-describe-bindings "helper" "\
;;;***
\f
;;;### (autoloads (hexlify-buffer hexl-find-file hexl-mode) "hexl"
-;;;;;; "hexl.el" (19714 43298))
+;;;;;; "hexl.el" (20229 34587))
;;; Generated autoloads from hexl.el
(autoload 'hexl-mode "hexl" "\
;;;### (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"
-;;;;;; (19640 47194))
+;;;;;; (20229 34587))
;;; 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"
-;;;;;; (19714 43298))
+;;;;;; (20229 34587))
;;; 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"
-;;;;;; (19562 42953))
+;;;;;; (20273 55692))
;;; 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))) "\
(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" (19640
-;;;;;; 47194))
+;;;;;; highlight-changes-mode) "hilit-chg" "hilit-chg.el" (20229
+;;;;;; 34587))
;;; 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" (19714 43298))
+;;;;;; "hippie-exp.el" (20229 34587))
;;; 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) "\
;;;***
\f
;;;### (autoloads (global-hl-line-mode hl-line-mode) "hl-line" "hl-line.el"
-;;;;;; (19562 42953))
+;;;;;; (20229 34587))
;;; 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
+windows.
Global-Hl-Line mode uses the functions `global-hl-line-unhighlight' and
`global-hl-line-highlight' on `pre-command-hook' and `post-command-hook'.
;;;;;; 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" (19714 43298))
+;;;;;; "calendar/holidays.el" (20287 5356))
;;; 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" (19598
-;;;;;; 13691))
+;;;### (autoloads (html2text) "html2text" "gnus/html2text.el" (20229
+;;;;;; 34587))
;;; Generated autoloads from gnus/html2text.el
(autoload 'html2text "html2text" "\
;;;***
\f
;;;### (autoloads (htmlfontify-copy-and-link-dir htmlfontify-buffer)
-;;;;;; "htmlfontify" "htmlfontify.el" (19640 47194))
+;;;;;; "htmlfontify" "htmlfontify.el" (20300 47034))
;;; 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" (19598
-;;;;;; 13691))
+;;;;;; define-ibuffer-column) "ibuf-macs" "ibuf-macs.el" (20229
+;;;;;; 34587))
;;; Generated autoloads from ibuf-macs.el
(autoload 'define-ibuffer-column "ibuf-macs" "\
;;;***
\f
;;;### (autoloads (ibuffer ibuffer-other-window ibuffer-list-buffers)
-;;;;;; "ibuffer" "ibuffer.el" (19714 43298))
+;;;;;; "ibuffer" "ibuffer.el" (20232 10689))
;;; 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" (19598 13691))
+;;;;;; "calendar/icalendar.el" (20229 34587))
;;; Generated autoloads from calendar/icalendar.el
(autoload 'icalendar-export-file "icalendar" "\
;;;***
\f
-;;;### (autoloads (icomplete-mode) "icomplete" "icomplete.el" (19591
-;;;;;; 62571))
+;;;### (autoloads (icomplete-mode) "icomplete" "icomplete.el" (20294
+;;;;;; 38748))
;;; 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" (19714 43298))
+;;;### (autoloads (icon-mode) "icon" "progmodes/icon.el" (20229 34587))
;;; Generated autoloads from progmodes/icon.el
(autoload 'icon-mode "icon" "\
;;;***
\f
;;;### (autoloads (idlwave-shell) "idlw-shell" "progmodes/idlw-shell.el"
-;;;;;; (19714 43298))
+;;;;;; (20237 28610))
;;; Generated autoloads from progmodes/idlw-shell.el
(autoload 'idlwave-shell "idlw-shell" "\
;;;***
\f
;;;### (autoloads (idlwave-mode) "idlwave" "progmodes/idlwave.el"
-;;;;;; (19714 43298))
+;;;;;; (20229 34587))
;;; 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" (19619
-;;;;;; 52030))
+;;;;;; ido-switch-buffer ido-mode ido-mode) "ido" "ido.el" (20268
+;;;;;; 33259))
;;; Generated autoloads from ido.el
(defvar ido-mode nil "\
(custom-autoload 'ido-mode "ido" nil)
(autoload 'ido-mode "ido" "\
-Toggle ido speed-ups on or off.
-With ARG, turn ido speed-up on if arg is positive, off otherwise.
+Toggle ido mode on or off.
+With ARG, turn ido-mode on if arg is positive, off otherwise.
Turning on ido-mode will remap (via a minor-mode keymap) the default
keybindings for the `find-file' and `switch-to-buffer' families of
commands to the ido versions of these functions.
\\[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'.
Read a string in the minibuffer with ido-style completion.
PROMPT is a string to prompt with; normally it ends in a colon and a space.
CHOICES is a list of strings which are the possible completions.
-PREDICATE is currently ignored; it is included to be compatible
- with `completing-read'.
+PREDICATE and INHERIT-INPUT-METHOD is currently ignored; it is included
+ to be compatible with `completing-read'.
If REQUIRE-MATCH is non-nil, the user is not allowed to exit unless
the input is (or completes to) an element of CHOICES or is null.
If the input is null, `ido-completing-read' returns DEF, or an empty
HIST, if non-nil, specifies a history list.
DEF, if non-nil, is the default value.
-\(fn PROMPT CHOICES &optional PREDICATE REQUIRE-MATCH INITIAL-INPUT HIST DEF)" nil nil)
+\(fn PROMPT CHOICES &optional PREDICATE REQUIRE-MATCH INITIAL-INPUT HIST DEF INHERIT-INPUT-METHOD)" nil nil)
;;;***
\f
-;;;### (autoloads (ielm) "ielm" "ielm.el" (19720 64949))
+;;;### (autoloads (ielm) "ielm" "ielm.el" (20229 34587))
;;; 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" (19640 47194))
+;;;### (autoloads (iimage-mode) "iimage" "iimage.el" (20273 55691))
;;; 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)
;;;***
\f
-;;;### (autoloads (imagemagick-register-types create-animated-image
-;;;;;; defimage find-image remove-images insert-sliced-image insert-image
-;;;;;; put-image create-image image-type-auto-detected-p image-type-available-p
+;;;### (autoloads (imagemagick-register-types defimage find-image
+;;;;;; remove-images insert-sliced-image insert-image put-image
+;;;;;; 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"
-;;;;;; (19714 43298))
+;;;;;; (20300 47034))
;;; Generated autoloads from image.el
(autoload 'image-type-from-data "image" "\
IMAGE is displayed by putting an overlay into the current buffer with a
`before-string' STRING that has a `display' property whose value is the
image. STRING is defaulted if you omit it.
+The overlay created will have the `put-image' property set to t.
POS may be an integer or marker.
AREA is where to display the image. AREA nil or omitted means
display it in the text area, a value of `left-margin' means
(autoload 'insert-image "image" "\
Insert IMAGE into current buffer at point.
IMAGE is displayed by inserting STRING into the current buffer
-with a `display' property whose value is the image. STRING is
-defaulted if you omit it.
+with a `display' property whose value is the image. STRING
+defaults to the empty string if you omit it.
AREA is where to display the image. AREA nil or omitted means
display it in the text area, a value of `left-margin' means
display it in the left marginal area, a value of `right-margin'
(put 'defimage 'doc-string-elt '3)
-(autoload 'create-animated-image "image" "\
-Create an animated image.
-FILE-OR-DATA is an image file name or image data.
-Optional TYPE is a symbol describing the image type. If TYPE is omitted
-or nil, try to determine the image type from its first few bytes
-of image data. If that doesn't work, and FILE-OR-DATA is a file name,
-use its file extension as image type.
-Optional DATA-P non-nil means FILE-OR-DATA is a string containing image data.
-Optional PROPS are additional image attributes to assign to the image,
-like, e.g. `:mask MASK'.
-Value is the image created, or nil if images of type TYPE are not supported.
-
-Images should not be larger than specified by `max-image-size'.
-
-\(fn FILE-OR-DATA &optional TYPE DATA-P &rest PROPS)" nil nil)
-
(autoload 'imagemagick-register-types "image" "\
-Register the file types that ImageMagick is able to handle.
+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.
+
+If Emacs is compiled without ImageMagick support, do 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" (19562 42953))
+;;;;;; "image-dired" "image-dired.el" (20229 34587))
;;; 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" (19562 42953))
+;;;;;; "image-file.el" (20229 34587))
;;; 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" (19619 52030))
+;;;;;; image-mode) "image-mode" "image-mode.el" (20274 22975))
;;; 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)
\(fn)" t nil)
(autoload 'image-bookmark-jump "image-mode" "\
-Not documented
+
\(fn BMK)" nil nil)
;;;***
\f
;;;### (autoloads (imenu imenu-add-menubar-index imenu-add-to-menubar
-;;;;;; imenu-sort-function) "imenu" "imenu.el" (19619 52030))
+;;;;;; imenu-sort-function) "imenu" "imenu.el" (20229 34587))
;;; 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" (19562 42953))
+;;;;;; "ind-util" "language/ind-util.el" (20229 34587))
;;; Generated autoloads from language/ind-util.el
(autoload 'indian-compose-region "ind-util" "\
\(fn FROM TO)" t nil)
(autoload 'indian-compose-string "ind-util" "\
-Not documented
+
\(fn STRING)" nil nil)
(autoload 'in-is13194-post-read-conversion "ind-util" "\
-Not documented
+
\(fn LEN)" nil nil)
(autoload 'in-is13194-pre-write-conversion "ind-util" "\
-Not documented
+
\(fn FROM TO)" nil nil)
\f
;;;### (autoloads (inferior-lisp inferior-lisp-prompt inferior-lisp-load-command
;;;;;; inferior-lisp-program inferior-lisp-filter-regexp) "inf-lisp"
-;;;;;; "progmodes/inf-lisp.el" (19714 43298))
+;;;;;; "progmodes/inf-lisp.el" (20229 34587))
;;; Generated autoloads from progmodes/inf-lisp.el
(defvar inferior-lisp-filter-regexp (purecopy "\\`\\s *\\(:\\(\\w\\|\\s_\\)\\)?\\s *\\'") "\
\(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)
;;;***
\f
-;;;### (autoloads (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"
-;;;;;; (19714 43298))
+;;;### (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" (20242 46528))
;;; 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" "\
Optional argument FILE-OR-NODE specifies the file to examine;
the default is the top-level directory of Info.
Called from a program, FILE-OR-NODE may specify an Info node of the form
-`(FILENAME)NODENAME'.
+\"(FILENAME)NODENAME\".
Optional argument BUFFER specifies the Info buffer name;
the default buffer name is *info*. If BUFFER exists,
just switch to BUFFER. Otherwise, create a new buffer
Display descriptions of the keywords in the Finder virtual manual.
In interactive use, a prefix argument directs this command to read
a list of keywords separated by comma. After that, it displays a node
-with a list packages that contain all specified keywords.
+with a list of packages that contain all specified keywords.
\(fn &optional KEYWORDS)" t nil)
\(fn BMK)" nil nil)
+(autoload 'info-display-manual "info" "\
+Go to Info buffer that displays MANUAL, creating it if none already exists.
+
+\(fn MANUAL)" t nil)
+
;;;***
\f
;;;### (autoloads (info-complete-file info-complete-symbol info-lookup-file
;;;;;; info-lookup-symbol info-lookup-reset) "info-look" "info-look.el"
-;;;;;; (19591 62571))
+;;;;;; (20229 34587))
;;; Generated autoloads from info-look.el
(autoload 'info-lookup-reset "info-look" "\
;;;***
\f
-;;;### (autoloads (info-xref-check-all-custom info-xref-check-all
-;;;;;; info-xref-check) "info-xref" "info-xref.el" (19562 42953))
+;;;### (autoloads (info-xref-docstrings info-xref-check-all-custom
+;;;;;; info-xref-check-all info-xref-check) "info-xref" "info-xref.el"
+;;;;;; (20229 34587))
;;; Generated autoloads from info-xref.el
(autoload 'info-xref-check "info-xref" "\
Check external references in FILENAME, an info document.
+Interactively from an `Info-mode' or `texinfo-mode' buffer the
+current info file is the default.
+
+Results are shown in a `compilation-mode' buffer. The format is
+a bit rough, but there shouldn't be many problems normally. The
+file:line:column: is the info document, but of course normally
+any correction should be made in the original .texi file.
+Finding the right place in the .texi is a manual process.
+
+When a target info file doesn't exist there's obviously no way to
+validate node references within it. A message is given for
+missing target files once per source document. It could be
+simply that you don't have the target installed, or it could be a
+mistake in the reference.
+
+Indirect info files are understood, just pass the top-level
+foo.info to `info-xref-check' and it traverses all sub-files.
+Compressed info files are accepted too as usual for `Info-mode'.
+
+\"makeinfo\" checks references internal to an info document, but
+not external references, which makes it rather easy for mistakes
+to creep in or node name changes to go unnoticed.
+`Info-validate' doesn't check external references either.
\(fn FILENAME)" t nil)
(autoload 'info-xref-check-all "info-xref" "\
-Check external references in all info documents in the usual path.
-The usual path is `Info-directory-list' and `Info-additional-directory-list'.
+Check external references in all info documents in the info path.
+`Info-directory-list' and `Info-additional-directory-list' are
+the info paths. See `info-xref-check' for how each file is
+checked.
+
+The search for \"all\" info files is rather permissive, since
+info files don't necessarily have a \".info\" extension and in
+particular the Emacs manuals normally don't. If you have a
+source code directory in `Info-directory-list' then a lot of
+extraneous files might be read. This will be time consuming but
+should be harmless.
\(fn)" t nil)
(autoload 'info-xref-check-all-custom "info-xref" "\
Check info references in all customize groups and variables.
-`custom-manual' and `info-link' entries in the `custom-links' list are checked.
+Info references can be in `custom-manual' or `info-link' entries
+of the `custom-links' for a variable.
-`custom-load' autoloads for all symbols are loaded in order to get all the
-link information. This will be a lot of lisp packages loaded, and can take
-quite a while.
+Any `custom-load' autoloads in variables are loaded in order to
+get full link information. This will be a lot of Lisp packages
+and can take a long time.
\(fn)" t nil)
+(autoload 'info-xref-docstrings "info-xref" "\
+Check docstring info node references in source files.
+The given files are searched for docstring hyperlinks like
+
+ Info node `(elisp)Documentation Tips'
+
+and those links checked by attempting to visit the target nodes
+as per `info-xref-check' does.
+
+Interactively filenames are read as a wildcard pattern like
+\"foo*.el\", with the current file as a default. Usually this
+will be lisp sources, but anything with such hyperlinks can be
+checked, including the Emacs .c sources (or the etc/DOC file of
+all builtins).
+
+Because info node hyperlinks are found by a simple regexp search
+in the files, the Lisp code checked doesn't have to be loaded,
+and links can be in the file commentary or elsewhere too. Even
+.elc files can usually be checked successfully if you don't have
+the sources handy.
+
+\(fn FILENAME-LIST)" t nil)
+
;;;***
\f
;;;### (autoloads (batch-info-validate Info-validate Info-split Info-split-threshold
-;;;;;; Info-tagify) "informat" "informat.el" (19591 62571))
+;;;;;; Info-tagify) "informat" "informat.el" (20229 34587))
;;; 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"
-;;;;;; (19562 42953))
+;;;;;; (20229 34587))
;;; Generated autoloads from international/isearch-x.el
(autoload 'isearch-toggle-specified-input-method "isearch-x" "\
\(fn)" t nil)
(autoload 'isearch-process-search-multibyte-characters "isearch-x" "\
-Not documented
+
\(fn LAST-CHAR)" nil nil)
;;;***
\f
-;;;### (autoloads (isearchb-activate) "isearchb" "isearchb.el" (19562
-;;;;;; 42953))
+;;;### (autoloads (isearchb-activate) "isearchb" "isearchb.el" (20229
+;;;;;; 34587))
;;; 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" (19562 42953))
+;;;;;; "international/iso-cvt.el" (20229 34587))
;;; Generated autoloads from international/iso-cvt.el
(autoload 'iso-spanish "iso-cvt" "\
;;;***
\f
;;;### (autoloads nil "iso-transl" "international/iso-transl.el"
-;;;;;; (19591 62571))
+;;;;;; (20229 34587))
;;; 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" (19714 43298))
+;;;;;; "ispell" "textmodes/ispell.el" (20229 34587))
;;; Generated autoloads from textmodes/ispell.el
(put 'ispell-check-comments 'safe-local-variable (lambda (a) (memq a '(nil t exclusive))))
\(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 mior 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)
;;;***
\f
-;;;### (autoloads (iswitchb-mode) "iswitchb" "iswitchb.el" (19714
-;;;;;; 43298))
+;;;### (autoloads (iswitchb-mode) "iswitchb" "iswitchb.el" (20229
+;;;;;; 34587))
;;; 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" (19562 42953))
+;;;;;; "japan-util" "language/japan-util.el" (20229 34587))
;;; Generated autoloads from language/japan-util.el
(autoload 'setup-japanese-environment-internal "japan-util" "\
-Not documented
+
\(fn)" nil nil)
;;;***
\f
;;;### (autoloads (jka-compr-uninstall jka-compr-handler) "jka-compr"
-;;;;;; "jka-compr.el" (19562 42953))
+;;;;;; "jka-compr.el" (20250 40679))
;;; Generated autoloads from jka-compr.el
(defvar jka-compr-inhibit nil "\
It is not recommended to set this variable permanently to anything but nil.")
(autoload 'jka-compr-handler "jka-compr" "\
-Not documented
+
\(fn OPERATION &rest ARGS)" nil 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" (19714 43298))
+;;;### (autoloads (js-mode) "js" "progmodes/js.el" (20229 34587))
;;; 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"
-;;;;;; (19562 42953))
+;;;;;; (20237 28610))
;;; Generated autoloads from emulation/keypad.el
(defvar keypad-setup nil "\
;;;***
\f
;;;### (autoloads (kinsoku) "kinsoku" "international/kinsoku.el"
-;;;;;; (19562 42953))
+;;;;;; (20229 34587))
;;; Generated autoloads from international/kinsoku.el
(autoload 'kinsoku "kinsoku" "\
;;;***
\f
-;;;### (autoloads (kkc-region) "kkc" "international/kkc.el" (19619
-;;;;;; 52030))
+;;;### (autoloads (kkc-region) "kkc" "international/kkc.el" (20229
+;;;;;; 34587))
;;; 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" (19591 62571))
+;;;;;; "kmacro" "kmacro.el" (20229 34587))
;;; 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" (19562 42953))
+;;;;;; "language/korea-util.el" (20229 34587))
;;; Generated autoloads from language/korea-util.el
(defvar default-korean-keyboard (purecopy (if (string-match "3" (or (getenv "HANGUL_KEYBOARD_TYPE") "")) "3" "")) "\
\"\" for 2, \"3\" for 3.")
(autoload 'setup-korean-environment-internal "korea-util" "\
-Not documented
+
\(fn)" nil nil)
;;;***
\f
-;;;### (autoloads (lm lm-test-run) "landmark" "play/landmark.el"
-;;;;;; (19714 43298))
+;;;### (autoloads (landmark landmark-test-run) "landmark" "play/landmark.el"
+;;;;;; (20300 47034))
;;; Generated autoloads from play/landmark.el
-(defalias 'landmark-repeat 'lm-test-run)
+(defalias 'landmark-repeat 'landmark-test-run)
-(autoload 'lm-test-run "landmark" "\
-Run 100 Lm games, each time saving the weights from the previous game.
+(autoload 'landmark-test-run "landmark" "\
+Run 100 Landmark games, each time saving the weights from the previous game.
\(fn)" t nil)
-(defalias 'landmark 'lm)
-
-(autoload 'lm "landmark" "\
-Start or resume an Lm game.
+(autoload 'landmark "landmark" "\
+Start or resume an Landmark game.
If a game is in progress, this command allows you to resume it.
Here is the relation between prefix args and game options:
3 | no | yes
4 | no | no
-You start by moving to a square and typing \\[lm-start-robot],
+You start by moving to a square and typing \\[landmark-start-robot],
if you did not use a prefix arg to ask for automatic start.
Use \\[describe-mode] for more info.
\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" (19562 42953))
+;;;;;; "lao-util" "language/lao-util.el" (20229 34587))
;;; Generated autoloads from language/lao-util.el
(autoload 'lao-compose-string "lao-util" "\
-Not documented
+
\(fn STR)" nil nil)
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
\(fn STR)" nil nil)
(autoload 'lao-composition-function "lao-util" "\
-Not documented
+
\(fn GSTRING)" nil nil)
(autoload 'lao-compose-region "lao-util" "\
-Not documented
+
\(fn FROM TO)" t nil)
\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" (19562 42953))
+;;;;;; "latexenc" "international/latexenc.el" (20229 34587))
;;; 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" (19562 42953))
+;;;;;; "latin1-disp" "international/latin1-disp.el" (20229 34587))
;;; Generated autoloads from international/latin1-disp.el
(defvar latin1-display nil "\
;;;***
\f
;;;### (autoloads (ld-script-mode) "ld-script" "progmodes/ld-script.el"
-;;;;;; (19619 52030))
+;;;;;; (20229 34587))
;;; Generated autoloads from progmodes/ld-script.el
(autoload 'ld-script-mode "ld-script" "\
;;;***
\f
;;;### (autoloads (ledit-from-lisp-mode ledit-mode) "ledit" "ledit.el"
-;;;;;; (19562 42953))
+;;;;;; (20229 34587))
;;; Generated autoloads from ledit.el
(defconst ledit-save-files t "\
\(fn)" t nil)
(autoload 'ledit-from-lisp-mode "ledit" "\
-Not documented
+
\(fn)" nil nil)
;;;***
\f
-;;;### (autoloads (life) "life" "play/life.el" (19714 43298))
+;;;### (autoloads (life) "life" "play/life.el" (20229 34587))
;;; Generated autoloads from play/life.el
(autoload 'life "life" "\
;;;***
\f
;;;### (autoloads (global-linum-mode linum-mode linum-format) "linum"
-;;;;;; "linum.el" (19598 13691))
+;;;;;; "linum.el" (20229 34587))
;;; 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" (19591
-;;;;;; 62571))
+;;;### (autoloads (unload-feature) "loadhist" "loadhist.el" (20229
+;;;;;; 34587))
;;; Generated autoloads from loadhist.el
(autoload 'unload-feature "loadhist" "\
;;;***
\f
;;;### (autoloads (locate-with-filter locate locate-ls-subdir-switches)
-;;;;;; "locate" "locate.el" (19714 43298))
+;;;;;; "locate" "locate.el" (20229 34587))
;;; Generated autoloads from locate.el
(defvar locate-ls-subdir-switches (purecopy "-al") "\
;;;***
\f
-;;;### (autoloads (log-edit) "log-edit" "vc/log-edit.el" (19714 43298))
+;;;### (autoloads (log-edit) "log-edit" "vc/log-edit.el" (20229 34587))
;;; Generated autoloads from vc/log-edit.el
(autoload 'log-edit "log-edit" "\
;;;***
\f
-;;;### (autoloads (log-view-mode) "log-view" "vc/log-view.el" (19640
-;;;;;; 47194))
+;;;### (autoloads (log-view-mode) "log-view" "vc/log-view.el" (20279
+;;;;;; 40897))
;;; Generated autoloads from vc/log-view.el
(autoload 'log-view-mode "log-view" "\
;;;***
\f
-;;;### (autoloads (longlines-mode) "longlines" "longlines.el" (19591
-;;;;;; 62571))
+;;;### (autoloads (longlines-mode) "longlines" "longlines.el" (20229
+;;;;;; 34587))
;;; Generated autoloads from longlines.el
(autoload 'longlines-mode "longlines" "\
-Toggle Long Lines mode.
-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.
+
+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" (19714
-;;;;;; 43298))
+;;;;;; lpr-command lpr-switches printer-name) "lpr" "lpr.el" (20229
+;;;;;; 34587))
;;; 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"
-;;;;;; (19714 43298))
+;;;;;; (20273 55604))
;;; Generated autoloads from ls-lisp.el
(defvar ls-lisp-support-shell-wildcards t "\
;;;***
\f
-;;;### (autoloads (lunar-phases) "lunar" "calendar/lunar.el" (19598
-;;;;;; 13691))
+;;;### (autoloads (lunar-phases) "lunar" "calendar/lunar.el" (20229
+;;;;;; 34587))
;;; Generated autoloads from calendar/lunar.el
(autoload 'lunar-phases "lunar" "\
;;;***
\f
-;;;### (autoloads (m4-mode) "m4-mode" "progmodes/m4-mode.el" (19714
-;;;;;; 43298))
+;;;### (autoloads (m4-mode) "m4-mode" "progmodes/m4-mode.el" (20229
+;;;;;; 34587))
;;; Generated autoloads from progmodes/m4-mode.el
(autoload 'm4-mode "m4-mode" "\
;;;***
\f
;;;### (autoloads (macroexpand-all) "macroexp" "emacs-lisp/macroexp.el"
-;;;;;; (19598 13691))
+;;;;;; (20229 34587))
;;; 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" (19598 13691))
+;;;;;; name-last-kbd-macro) "macros" "macros.el" (20229 34587))
;;; 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" (19714 43298))
+;;;;;; "mail/mail-extr.el" (20237 28610))
;;; 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"
-;;;;;; (19598 13691))
+;;;;;; (20229 34587))
;;; Generated autoloads from mail/mail-hist.el
(autoload 'mail-hist-define-keys "mail-hist" "\
\(fn)" nil nil)
(autoload 'mail-hist-enable "mail-hist" "\
-Not documented
+
\(fn)" nil nil)
\f
;;;### (autoloads (mail-fetch-field mail-unquote-printable-region
;;;;;; mail-unquote-printable mail-quote-printable-region mail-quote-printable
-;;;;;; mail-file-babyl-p mail-use-rfc822) "mail-utils" "mail/mail-utils.el"
-;;;;;; (19640 47194))
+;;;;;; mail-file-babyl-p mail-dont-reply-to-names mail-use-rfc822)
+;;;;;; "mail-utils" "mail/mail-utils.el" (20229 34587))
;;; Generated autoloads from mail/mail-utils.el
(defvar mail-use-rfc822 nil "\
(custom-autoload 'mail-use-rfc822 "mail-utils" t)
+(defvar mail-dont-reply-to-names nil "\
+Regexp specifying addresses to prune from a reply message.
+If this is nil, it is set the first time you compose a reply, to
+a value which excludes your own email address.
+
+Matching addresses are excluded from the CC field in replies, and
+also the To field, unless this would leave an empty To field.")
+
+(custom-autoload 'mail-dont-reply-to-names "mail-utils" t)
+
(autoload 'mail-file-babyl-p "mail-utils" "\
Return non-nil if FILE is a Babyl file.
;;;***
\f
;;;### (autoloads (define-mail-abbrev build-mail-abbrevs mail-abbrevs-setup
-;;;;;; mail-abbrevs-mode) "mailabbrev" "mail/mailabbrev.el" (19591
-;;;;;; 62571))
+;;;;;; mail-abbrevs-mode) "mailabbrev" "mail/mailabbrev.el" (20229
+;;;;;; 34587))
;;; 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 define-mail-alias expand-mail-aliases
-;;;;;; mail-complete-style) "mailalias" "mail/mailalias.el" (19591
-;;;;;; 62571))
+;;;### (autoloads (mail-complete mail-completion-at-point-function
+;;;;;; define-mail-alias expand-mail-aliases mail-complete-style)
+;;;;;; "mailalias" "mail/mailalias.el" (20229 34587))
;;; Generated autoloads from mail/mailalias.el
(defvar mail-complete-style 'angles "\
\(fn NAME DEFINITION &optional FROM-MAILRC-FILE)" t nil)
+(autoload 'mail-completion-at-point-function "mailalias" "\
+Compute completion data for mail aliases.
+For use on `completion-at-point-functions'.
+
+\(fn)" nil nil)
+
(autoload 'mail-complete "mailalias" "\
Perform completion on header field or word preceding point.
Completable headers are according to `mail-complete-alist'. If none matches
-current header, calls `mail-complete-function' and passes prefix arg if any.
+current header, calls `mail-complete-function' and passes prefix ARG if any.
\(fn ARG)" t nil)
;;;***
\f
;;;### (autoloads (mailclient-send-it) "mailclient" "mail/mailclient.el"
-;;;;;; (19714 43298))
+;;;;;; (20237 28610))
;;; 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" (19598 13691))
+;;;;;; "make-mode" "progmodes/make-mode.el" (20229 34587))
;;; Generated autoloads from progmodes/make-mode.el
(autoload 'makefile-mode "make-mode" "\
;;;***
\f
-;;;### (autoloads (make-command-summary) "makesum" "makesum.el" (19714
-;;;;;; 43298))
+;;;### (autoloads (make-command-summary) "makesum" "makesum.el" (20229
+;;;;;; 34587))
;;; Generated autoloads from makesum.el
(autoload 'make-command-summary "makesum" "\
;;;***
\f
;;;### (autoloads (Man-bookmark-jump man-follow man) "man" "man.el"
-;;;;;; (19619 52030))
+;;;;;; (20292 53022))
;;; Generated autoloads from man.el
(defalias 'manual-entry 'man)
;;;***
\f
-;;;### (autoloads (master-mode) "master" "master.el" (19562 42953))
+;;;### (autoloads (master-mode) "master" "master.el" (20229 34587))
;;; 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"
-;;;;;; (19562 42953))
+;;;;;; (20229 34587))
;;; 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" (19717 39999))
+;;;;;; "gnus/message.el" (20279 40897))
;;; 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)
to continue editing a message already being composed. SWITCH-FUNCTION
is a function used to switch to and display the mail buffer.
-\(fn &optional TO SUBJECT OTHER-HEADERS CONTINUE SWITCH-FUNCTION YANK-ACTION SEND-ACTIONS)" t nil)
+\(fn &optional TO SUBJECT OTHER-HEADERS CONTINUE SWITCH-FUNCTION YANK-ACTION SEND-ACTIONS RETURN-ACTION &rest IGNORED)" t nil)
(autoload 'message-news "message" "\
Start editing a news article to be sent.
(autoload 'message-reply "message" "\
Start editing a reply to the article in the current buffer.
-\(fn &optional TO-ADDRESS WIDE)" t nil)
+\(fn &optional TO-ADDRESS WIDE SWITCH-FUNCTION)" t nil)
(autoload 'message-wide-reply "message" "\
Make a \"wide\" reply to the message in the current buffer.
\(fn &optional NEWS DIGEST)" t nil)
(autoload 'message-forward-make-body "message" "\
-Not documented
+
\(fn FORWARD-BUFFER &optional DIGEST)" nil nil)
(autoload 'message-forward-rmail-make-body "message" "\
-Not documented
+
\(fn FORWARD-BUFFER)" nil nil)
;;;***
\f
;;;### (autoloads (metapost-mode metafont-mode) "meta-mode" "progmodes/meta-mode.el"
-;;;;;; (19714 43298))
+;;;;;; (20229 34587))
;;; 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"
-;;;;;; (19562 42953))
+;;;;;; (20229 34587))
;;; 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" (19562 42953))
+;;;;;; "mh-e/mh-comp.el" (20229 34587))
;;; Generated autoloads from mh-e/mh-comp.el
(autoload 'mh-smail "mh-comp" "\
Elements look like (HEADER . VALUE) where both HEADER and VALUE
are strings.
-CONTINUE, SWITCH-FUNCTION, YANK-ACTION and SEND-ACTIONS are
-ignored.
+CONTINUE, SWITCH-FUNCTION, YANK-ACTION, SEND-ACTIONS, and
+RETURN-ACTION and any additional arguments are IGNORED.
-\(fn &optional TO SUBJECT OTHER-HEADERS CONTINUE SWITCH-FUNCTION YANK-ACTION SEND-ACTIONS)" nil nil)
+\(fn &optional TO SUBJECT OTHER-HEADERS CONTINUE SWITCH-FUNCTION YANK-ACTION SEND-ACTIONS RETURN-ACTION &rest IGNORED)" nil nil)
(autoload 'mh-send-letter "mh-comp" "\
Save draft and send message.
;;;***
\f
-;;;### (autoloads (mh-version) "mh-e" "mh-e/mh-e.el" (19562 42953))
+;;;### (autoloads (mh-version) "mh-e" "mh-e/mh-e.el" (20229 34587))
;;; 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" (19562 42953))
+;;;;;; "mh-e/mh-folder.el" (20229 34587))
;;; Generated autoloads from mh-e/mh-folder.el
(autoload 'mh-rmail "mh-folder" "\
;;;***
\f
;;;### (autoloads (midnight-delay-set clean-buffer-list) "midnight"
-;;;;;; "midnight.el" (19562 42953))
+;;;;;; "midnight.el" (20229 34587))
;;; Generated autoloads from midnight.el
(autoload 'clean-buffer-list "midnight" "\
;;;***
\f
;;;### (autoloads (minibuffer-electric-default-mode) "minibuf-eldef"
-;;;;;; "minibuf-eldef.el" (19591 62571))
+;;;;;; "minibuf-eldef.el" (20229 34587))
;;; 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 (butterfly) "misc" "misc.el" (19714 43298))
+;;;### (autoloads (list-dynamic-libraries butterfly) "misc" "misc.el"
+;;;;;; (20229 34587))
;;; Generated autoloads from misc.el
(autoload 'butterfly "misc" "\
\(fn)" t nil)
+(autoload 'list-dynamic-libraries "misc" "\
+Display a list of all dynamic libraries known to Emacs.
+\(These are the libraries listed in `dynamic-library-alist'.)
+If optional argument LOADED-ONLY-P (interactively, prefix arg)
+is non-nil, only libraries already loaded are listed.
+Optional argument BUFFER specifies a buffer to use, instead of
+\"*Dynamic Libraries*\".
+The return value is always nil.
+
+\(fn &optional LOADED-ONLY-P BUFFER)" t nil)
+
;;;***
\f
;;;### (autoloads (multi-isearch-files-regexp multi-isearch-files
;;;;;; multi-isearch-buffers-regexp multi-isearch-buffers multi-isearch-setup)
-;;;;;; "misearch" "misearch.el" (19562 42953))
+;;;;;; "misearch" "misearch.el" (20229 34587))
;;; Generated autoloads from misearch.el
(add-hook 'isearch-mode-hook 'multi-isearch-setup)
;;;***
\f
;;;### (autoloads (mixal-mode) "mixal-mode" "progmodes/mixal-mode.el"
-;;;;;; (19714 43298))
+;;;;;; (20237 28610))
;;; Generated autoloads from progmodes/mixal-mode.el
(autoload 'mixal-mode "mixal-mode" "\
;;;***
\f
+;;;### (autoloads (mm-default-file-encoding) "mm-encode" "gnus/mm-encode.el"
+;;;;;; (20229 34587))
+;;; 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" (19714 43298))
+;;;;;; "mm-extern" "gnus/mm-extern.el" (20229 34587))
;;; 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"
-;;;;;; (19619 52030))
+;;;;;; (20229 34587))
;;; 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" (19714 43298))
+;;;;;; "mm-url" "gnus/mm-url.el" (20229 34587))
;;; 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" (19714 43298))
+;;;;;; "gnus/mm-uu.el" (20229 34587))
;;; 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"
+;;;;;; (20229 34587))
+;;; 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"
-;;;;;; (19640 47194))
+;;;;;; (20291 32066))
;;; Generated autoloads from gnus/mml1991.el
(autoload 'mml1991-encrypt "mml1991" "\
-Not documented
+
\(fn CONT &optional SIGN)" nil nil)
(autoload 'mml1991-sign "mml1991" "\
-Not documented
+
\(fn CONT)" nil nil)
\f
;;;### (autoloads (mml2015-self-encrypt mml2015-sign mml2015-encrypt
;;;;;; mml2015-verify-test mml2015-verify mml2015-decrypt-test mml2015-decrypt)
-;;;;;; "mml2015" "gnus/mml2015.el" (19714 43298))
+;;;;;; "mml2015" "gnus/mml2015.el" (20229 34587))
;;; Generated autoloads from gnus/mml2015.el
(autoload 'mml2015-decrypt "mml2015" "\
-Not documented
+
\(fn HANDLE CTL)" nil nil)
(autoload 'mml2015-decrypt-test "mml2015" "\
-Not documented
+
\(fn HANDLE CTL)" nil nil)
(autoload 'mml2015-verify "mml2015" "\
-Not documented
+
\(fn HANDLE CTL)" nil nil)
(autoload 'mml2015-verify-test "mml2015" "\
-Not documented
+
\(fn HANDLE CTL)" nil nil)
(autoload 'mml2015-encrypt "mml2015" "\
-Not documented
+
\(fn CONT &optional SIGN)" nil nil)
(autoload 'mml2015-sign "mml2015" "\
-Not documented
+
\(fn CONT)" nil nil)
(autoload 'mml2015-self-encrypt "mml2015" "\
-Not documented
+
\(fn)" nil nil)
;;;***
\f
-;;;### (autoloads (m2-mode) "modula2" "progmodes/modula2.el" (19714
-;;;;;; 43298))
+;;;### (autoloads (m2-mode) "modula2" "progmodes/modula2.el" (20159
+;;;;;; 42847))
;;; Generated autoloads from progmodes/modula2.el
(defalias 'modula-2-mode 'm2-mode)
;;;***
\f
-;;;### (autoloads (unmorse-region morse-region) "morse" "play/morse.el"
-;;;;;; (19562 42953))
+;;;### (autoloads (denato-region nato-region unmorse-region morse-region)
+;;;;;; "morse" "play/morse.el" (20229 34587))
;;; Generated autoloads from play/morse.el
(autoload 'morse-region "morse" "\
\(fn BEG END)" t nil)
+(autoload 'nato-region "morse" "\
+Convert all text in a given region to NATO phonetic alphabet.
+
+\(fn BEG END)" t nil)
+
+(autoload 'denato-region "morse" "\
+Convert NATO phonetic alphabet in region to ordinary ASCII text.
+
+\(fn BEG END)" t nil)
+
;;;***
\f
;;;### (autoloads (mouse-drag-drag mouse-drag-throw) "mouse-drag"
-;;;;;; "mouse-drag.el" (19714 43298))
+;;;;;; "mouse-drag.el" (20229 34587))
;;; Generated autoloads from mouse-drag.el
(autoload 'mouse-drag-throw "mouse-drag" "\
you'll like it. It's easier to observe than to explain.
If the mouse is clicked and released in the same place of time we
-assume that the user didn't want to scdebugroll but wanted to whatever
+assume that the user didn't want to scroll but wanted to whatever
mouse-2 used to do, so we pass it through.
Throw scrolling was inspired (but is not identical to) the \"hand\"
;;;***
\f
-;;;### (autoloads (mouse-sel-mode) "mouse-sel" "mouse-sel.el" (19714
-;;;;;; 43298))
+;;;### (autoloads (mouse-sel-mode) "mouse-sel" "mouse-sel.el" (20229
+;;;;;; 34587))
;;; Generated autoloads from mouse-sel.el
(defvar mouse-sel-mode 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:
-
-- Clicking mouse-1 starts (cancels) selection, dragging extends it.
+With a prefix argument ARG, enable Mouse Sel mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+the mode if ARG is omitted or nil.
-- Clicking or dragging mouse-3 extends the selection as well.
+Mouse Sel mode is a global minor mode. When enabled, mouse
+selection is enhanced in various ways:
-- Double-clicking on word constituents selects words.
-Double-clicking on symbol constituents selects symbols.
+- 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.
- Clicking mouse-2 inserts the contents of the primary selection at
the mouse position (or point, if `mouse-yank-at-point' is non-nil).
-- Pressing mouse-2 while selecting or extending copies selection
-to the kill ring. Pressing mouse-1 or mouse-3 kills it.
-
-- Double-clicking mouse-3 also kills selection.
-
-- M-mouse-1, M-mouse-2 & M-mouse-3 work similarly to mouse-1, mouse-2
-& mouse-3, but operate on the X secondary selection rather than the
-primary selection and region.
+- 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" (19714 43269))
+;;;### (autoloads (mpc) "mpc" "mpc.el" (20229 34587))
;;; Generated autoloads from mpc.el
(autoload 'mpc "mpc" "\
;;;***
\f
-;;;### (autoloads (mpuz) "mpuz" "play/mpuz.el" (19640 47194))
+;;;### (autoloads (mpuz) "mpuz" "play/mpuz.el" (20229 34587))
;;; Generated autoloads from play/mpuz.el
(autoload 'mpuz "mpuz" "\
;;;***
\f
-;;;### (autoloads (msb-mode) "msb" "msb.el" (19562 42953))
+;;;### (autoloads (msb-mode) "msb" "msb.el" (20229 34587))
;;; 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"
-;;;;;; (19619 52030))
+;;;;;; (20229 34587))
;;; 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" (19562 42953))
+;;;;;; "mule-util" "international/mule-util.el" (20229 34587))
;;; 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-priority'.
-This affects the implicit sorting of lists of coding sysems returned by
+CODING-SYSTEMS is a list of coding systems. See `set-coding-system-priority'.
+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))
;;;### (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" (19714
-;;;;;; 43298))
+;;;;;; iwconfig ifconfig) "net-utils" "net/net-utils.el" (20229
+;;;;;; 34587))
;;; Generated autoloads from net/net-utils.el
(autoload 'ifconfig "net-utils" "\
\(fn ARG SEARCH-STRING)" t nil)
(autoload 'whois-reverse-lookup "net-utils" "\
-Not documented
+
\(fn)" t nil)
;;;***
\f
-;;;### (autoloads (netrc-credentials) "netrc" "net/netrc.el" (19640
-;;;;;; 47194))
+;;;### (autoloads (netrc-credentials) "netrc" "net/netrc.el" (20279
+;;;;;; 40897))
;;; 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"
+;;;;;; (20236 7740))
+;;; Generated autoloads from net/network-stream.el
+
+(autoload 'open-network-stream "network-stream" "\
+Open a TCP connection to HOST, optionally with encryption.
+Normally, return a network process object; with a non-nil
+:return-list parameter, return a list instead (see below).
+Input and output work as for subprocesses; `delete-process'
+closes it.
+
+NAME is the name for the process. It is modified if necessary to
+ make it unique.
+BUFFER is a buffer or buffer name to associate with the process.
+ Process output goes at end of that buffer. BUFFER may be nil,
+ meaning that the process is not associated with any buffer.
+HOST is the name or IP address of the host to connect to.
+SERVICE is the name of the service desired, or an integer specifying
+ a port number to connect to.
+
+The remaining PARAMETERS should be a sequence of keywords and
+values:
+
+:type specifies the connection type, one of the following:
+ nil or `network'
+ -- Begin with an ordinary network connection, and if
+ the parameters :success and :capability-command
+ are also supplied, try to upgrade to an encrypted
+ connection via STARTTLS. Even if that
+ fails (e.g. if HOST does not support TLS), retain
+ an unencrypted connection.
+ `plain' -- An ordinary, unencrypted network connection.
+ `starttls' -- Begin with an ordinary connection, and try
+ upgrading via STARTTLS. If that fails for any
+ reason, drop the connection; in that case the
+ returned object is a killed process.
+ `tls' -- A TLS connection.
+ `ssl' -- Equivalent to `tls'.
+ `shell' -- A shell connection.
+
+:return-list specifies this function's return value.
+ If omitted or nil, return a process object. A non-nil means to
+ return (PROC . PROPS), where PROC is a process object and PROPS
+ is a plist of connection properties, with these keywords:
+ :greeting -- the greeting returned by HOST (a string), or nil.
+ :capabilities -- a string representing HOST's capabilities,
+ or nil if none could be found.
+ :type -- the resulting connection type; `plain' (unencrypted)
+ or `tls' (TLS-encrypted).
+
+:end-of-command specifies a regexp matching the end of a command.
+
+:end-of-capability specifies a regexp matching the end of the
+ response to the command specified for :capability-command.
+ It defaults to the regexp specified for :end-of-command.
+
+:success specifies a regexp matching a message indicating a
+ successful STARTTLS negotiation. For instance, the default
+ should be \"^3\" for an NNTP connection.
+
+:capability-command specifies a command used to query the HOST
+ for its capabilities. For instance, for IMAP this should be
+ \"1 CAPABILITY\\r\\n\".
+
+:starttls-function specifies a function for handling STARTTLS.
+ This function should take one parameter, the response to the
+ capability command, and should return the command to switch on
+ STARTTLS if the server supports STARTTLS, and nil otherwise.
+
+: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
+ element is the certificate key file name, and the second
+ element is the certificate file name itself, or `t', which
+ means that `auth-source' will be queried for the key and the
+ 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.
+
+:nowait is a boolean that says the connection should be made
+ asynchronously, if possible.
+
+\(fn NAME BUFFER HOST SERVICE &rest PARAMETERS)" nil nil)
+
+(defalias 'open-protocol-stream 'open-network-stream)
+
+;;;***
+\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" (19714 43298))
+;;;;;; "newcomment.el" (20296 49978))
;;; Generated autoloads from newcomment.el
(defalias 'indent-for-comment 'comment-indent)
(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 up to its body.")
+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 "") "\
Applicable at least in modes for languages like fixed-format Fortran where
comments always start in column zero.")
+(defconst comment-styles '((plain nil nil nil nil "Start in column 0 (do not indent), as in Emacs-20") (indent-or-triple nil nil nil multi-char "Start in column 0, but only for single-char starters") (indent nil nil nil t "Full comment per line, ends not aligned") (aligned nil t nil t "Full comment per line, ends aligned") (box nil t t t "Full comment per line, ends aligned, + top and bottom") (extra-line t nil t t "One comment for all lines, end on a line by itself") (multi-line t nil nil t "One comment for all lines, end on last commented line") (box-multi t t t t "One comment for all lines, + top and bottom")) "\
+Comment region style definitions.
+Each style is defined with a form (STYLE . (MULTI ALIGN EXTRA INDENT DOC)).
+DOC should succinctly describe the style.
+STYLE should be a mnemonic symbol.
+MULTI specifies that comments are allowed to span multiple lines.
+ e.g. in C it comments regions as
+ /* blabla
+ * bli */
+ rather than
+ /* blabla */
+ /* bli */
+ if `comment-end' is empty, this has no effect.
+
+ALIGN specifies that the `comment-end' markers should be aligned.
+ e.g. in C it comments regions as
+ /* blabla */
+ /* bli */
+ rather than
+ /* blabla */
+ /* bli */
+ if `comment-end' is empty, this has no effect, unless EXTRA is also set,
+ in which case the comment gets wrapped in a box.
+
+EXTRA specifies that an extra line should be used before and after the
+ region to comment (to put the `comment-end' and `comment-start').
+ e.g. in C it comments regions as
+ /*
+ * blabla
+ * bli
+ */
+ rather than
+ /* blabla
+ * bli */
+ if the comment style is not multi line, this has no effect, unless ALIGN
+ is also set, in which case the comment gets wrapped in a box.
+
+INDENT specifies that the `comment-start' markers should not be put at the
+ left margin but at the current indentation of the region to comment.
+If INDENT is `multi-char', that means indent multi-character
+ comment starters, but not one-character comment starters.")
+
(defvar comment-style 'indent "\
Style to be used for `comment-region'.
See `comment-styles' for a list of available styles.")
;;;***
\f
;;;### (autoloads (newsticker-start newsticker-running-p) "newst-backend"
-;;;;;; "net/newst-backend.el" (19598 13691))
+;;;;;; "net/newst-backend.el" (20229 34587))
;;; Generated autoloads from net/newst-backend.el
(autoload 'newsticker-running-p "newst-backend" "\
;;;***
\f
;;;### (autoloads (newsticker-plainview) "newst-plainview" "net/newst-plainview.el"
-;;;;;; (19598 13691))
+;;;;;; (20229 34587))
;;; Generated autoloads from net/newst-plainview.el
(autoload 'newsticker-plainview "newst-plainview" "\
;;;***
\f
;;;### (autoloads (newsticker-show-news) "newst-reader" "net/newst-reader.el"
-;;;;;; (19598 13691))
+;;;;;; (20229 34587))
;;; 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" (19598 13691))
+;;;;;; "newst-ticker" "net/newst-ticker.el" (20229 34587))
;;; Generated autoloads from net/newst-ticker.el
(autoload 'newsticker-ticker-running-p "newst-ticker" "\
;;;***
\f
;;;### (autoloads (newsticker-treeview) "newst-treeview" "net/newst-treeview.el"
-;;;;;; (19598 13691))
+;;;;;; (20229 34587))
;;; Generated autoloads from net/newst-treeview.el
(autoload 'newsticker-treeview "newst-treeview" "\
;;;***
\f
;;;### (autoloads (nndiary-generate-nov-databases) "nndiary" "gnus/nndiary.el"
-;;;;;; (19714 43298))
+;;;;;; (20229 34587))
;;; Generated autoloads from gnus/nndiary.el
(autoload 'nndiary-generate-nov-databases "nndiary" "\
;;;***
\f
-;;;### (autoloads (nndoc-add-type) "nndoc" "gnus/nndoc.el" (19714
-;;;;;; 43298))
+;;;### (autoloads (nndoc-add-type) "nndoc" "gnus/nndoc.el" (20229
+;;;;;; 34587))
;;; Generated autoloads from gnus/nndoc.el
(autoload 'nndoc-add-type "nndoc" "\
;;;***
\f
;;;### (autoloads (nnfolder-generate-active-file) "nnfolder" "gnus/nnfolder.el"
-;;;;;; (19714 43298))
+;;;;;; (20229 34587))
;;; Generated autoloads from gnus/nnfolder.el
(autoload 'nnfolder-generate-active-file "nnfolder" "\
;;;***
\f
;;;### (autoloads (nnml-generate-nov-databases) "nnml" "gnus/nnml.el"
-;;;;;; (19714 43298))
+;;;;;; (20280 61753))
;;; Generated autoloads from gnus/nnml.el
(autoload 'nnml-generate-nov-databases "nnml" "\
;;;***
\f
;;;### (autoloads (disable-command enable-command disabled-command-function)
-;;;;;; "novice" "novice.el" (19714 43298))
+;;;;;; "novice" "novice.el" (20229 34587))
;;; Generated autoloads from novice.el
(defvar disabled-command-function 'disabled-command-function "\
(define-obsolete-variable-alias 'disabled-command-hook 'disabled-command-function "22.1")
(autoload 'disabled-command-function "novice" "\
-Not documented
+
\(fn &optional CMD KEYS)" nil nil)
;;;***
\f
;;;### (autoloads (nroff-mode) "nroff-mode" "textmodes/nroff-mode.el"
-;;;;;; (19619 52030))
+;;;;;; (20229 34587))
;;; Generated autoloads from textmodes/nroff-mode.el
(autoload 'nroff-mode "nroff-mode" "\
;;;***
\f
;;;### (autoloads (nxml-glyph-display-string) "nxml-glyph" "nxml/nxml-glyph.el"
-;;;;;; (19562 42953))
+;;;;;; (20229 34587))
;;; Generated autoloads from nxml/nxml-glyph.el
(autoload 'nxml-glyph-display-string "nxml-glyph" "\
;;;***
\f
-;;;### (autoloads (nxml-mode) "nxml-mode" "nxml/nxml-mode.el" (19714
-;;;;;; 43298))
+;;;### (autoloads (nxml-mode) "nxml-mode" "nxml/nxml-mode.el" (20229
+;;;;;; 34587))
;;; Generated autoloads from nxml/nxml-mode.el
(autoload 'nxml-mode "nxml-mode" "\
;;;***
\f
;;;### (autoloads (nxml-enable-unicode-char-name-sets) "nxml-uchnm"
-;;;;;; "nxml/nxml-uchnm.el" (19562 42953))
+;;;;;; "nxml/nxml-uchnm.el" (20229 34587))
;;; Generated autoloads from nxml/nxml-uchnm.el
(autoload 'nxml-enable-unicode-char-name-sets "nxml-uchnm" "\
\f
;;;### (autoloads (org-babel-mark-block org-babel-previous-src-block
;;;;;; 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-goto-src-block-head org-babel-sha1-hash org-babel-execute-subtree
+;;;;;; org-babel-execute-buffer 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-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-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" (19717 39999))
+;;;;;; "org/ob.el" (20230 13182))
;;; Generated autoloads from org/ob.el
(autoload 'org-babel-execute-safely-maybe "ob" "\
-Not documented
+
\(fn)" nil nil)
(autoload 'org-babel-execute-maybe "ob" "\
-Not documented
+
+
+\(fn)" t nil)
+
+(autoload 'org-babel-view-src-block-info "ob" "\
+Display information on the current source block.
+This includes header arguments, language and name, and is largely
+a window into the `org-babel-get-src-block-info' function.
\(fn)" t nil)
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 &optional ARG INFO PARAMS)" t nil)
+(autoload 'org-babel-check-src-block "ob" "\
+Check for misspelled header arguments in the current code block.
+
+\(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
(put 'org-babel-map-src-blocks 'lisp-indent-function '1)
+(autoload 'org-babel-map-inline-src-blocks "ob" "\
+Evaluate BODY forms on each inline source-block in FILE.
+If FILE is nil evaluate BODY forms on source blocks in current
+buffer.
+
+\(fn FILE &rest BODY)" nil (quote macro))
+
+(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 (quote macro))
+
+(put 'org-babel-map-call-lines '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
\(fn &optional INFO)" t nil)
-(autoload 'org-babel-hide-result-toggle-maybe "ob" "\
-Toggle visibility of result at point.
-
-\(fn)" t nil)
-
(autoload 'org-babel-goto-src-block-head "ob" "\
Go to the beginning of the current code block.
;;;***
\f
;;;### (autoloads (org-babel-describe-bindings) "ob-keys" "org/ob-keys.el"
-;;;;;; (19717 39999))
+;;;;;; (20229 34587))
;;; 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" (19717 39999))
+;;;;;; org-babel-lob-ingest) "ob-lob" "org/ob-lob.el" (20229 34587))
;;; 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"
-;;;;;; (19717 39999))
+;;;;;; (20229 34587))
;;; Generated autoloads from org/ob-tangle.el
(defvar org-babel-tangle-lang-exts '(("emacs-lisp" . "el")) "\
source blocks. Optional argument LANG can be used to limit the
exported source code blocks by language.
-\(fn &optional TARGET-FILE LANG)" t nil)
+\(fn &optional ONLY-THIS-BLOCK TARGET-FILE LANG)" t nil)
;;;***
\f
;;;### (autoloads (inferior-octave) "octave-inf" "progmodes/octave-inf.el"
-;;;;;; (19714 43298))
+;;;;;; (20291 32066))
;;; Generated autoloads from progmodes/octave-inf.el
(autoload 'inferior-octave "octave-inf" "\
;;;***
\f
;;;### (autoloads (octave-mode) "octave-mod" "progmodes/octave-mod.el"
-;;;;;; (19714 43298))
+;;;;;; (20291 32066))
;;; Generated autoloads from progmodes/octave-mod.el
(autoload 'octave-mode "octave-mod" "\
;;;;;; 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"
-;;;;;; (19717 39999))
+;;;;;; (20236 7740))
;;; Generated autoloads from org/org.el
(autoload 'org-babel-do-load-languages "org" "\
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.
\(fn)" t nil)
(autoload 'org-require-autoloaded-modules "org" "\
-Not documented
+
\(fn)" t nil)
;;;;;; 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" (19717 39999))
+;;;;;; org-agenda) "org-agenda" "org/org-agenda.el" (20236 7740))
;;; Generated autoloads from org/org-agenda.el
(autoload 'org-agenda "org-agenda" "\
\(fn CMD-KEY &rest PARAMETERS)" nil (quote macro))
(autoload 'org-store-agenda-views "org-agenda" "\
-Not documented
+
\(fn &rest PARAMETERS)" t nil)
The view will be for the current day or week, but from the overview buffer
you will be able to go to other days/weeks.
-With one \\[universal-argument] prefix argument INCLUDE-ALL,
-all unfinished TODO items will also be shown, before the agenda.
-This feature is considered obsolete, please use the TODO list or a block
-agenda instead.
-
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"
-;;;;;; (19717 39999))
+;;;;;; (20229 34587))
;;; 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" (19717
-;;;;;; 39999))
+;;;;;; org-export-as-latin1) "org-ascii" "org/org-ascii.el" (20229
+;;;;;; 34587))
;;; Generated autoloads from org/org-ascii.el
(autoload 'org-export-as-latin1 "org-ascii" "\
\(fn &rest ARGS)" t nil)
(autoload 'org-export-as-utf8 "org-ascii" "\
-Like `org-export-as-ascii', use use encoding for special symbols.
+Like `org-export-as-ascii', use encoding for special symbols.
\(fn &rest ARGS)" t nil)
;;;***
\f
-;;;### (autoloads (org-attach) "org-attach" "org/org-attach.el" (19717
-;;;;;; 39999))
+;;;### (autoloads (org-attach) "org-attach" "org/org-attach.el" (20229
+;;;;;; 34587))
;;; Generated autoloads from org/org-attach.el
(autoload 'org-attach "org-attach" "\
;;;***
\f
;;;### (autoloads (org-bbdb-anniversaries) "org-bbdb" "org/org-bbdb.el"
-;;;;;; (19717 39999))
+;;;;;; (20230 13182))
;;; 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" (19717 39999))
+;;;;;; org-capture) "org-capture" "org/org-capture.el" (20236 7740))
;;; Generated autoloads from org/org-capture.el
(autoload 'org-capture "org-capture" "\
\(fn &optional GOTO KEYS)" t nil)
(autoload 'org-capture-insert-template-here "org-capture" "\
-Not documented
+
\(fn)" nil nil)
;;;***
\f
;;;### (autoloads (org-clock-persistence-insinuate org-get-clocktable)
-;;;;;; "org-clock" "org/org-clock.el" (19717 39999))
+;;;;;; "org-clock" "org/org-clock.el" (20236 7740))
;;; 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" (19717 39999))
+;;;;;; "org/org-datetree.el" (20229 34587))
;;; 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" (19717 39999))
+;;;;;; "org-docbook" "org/org-docbook.el" (20229 34587))
;;; 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"
-;;;;;; (19717 39999))
+;;;;;; (20236 7740))
;;; Generated autoloads from org/org-exp.el
(autoload 'org-export "org-exp" "\
ARG is a double universal prefix \\[universal-argument] \\[universal-argument], that means to inverse the
value of `org-export-run-in-background'.
+If `org-export-initial-scope' is set to 'subtree, try to export
+the current subtree, otherwise try to export the whole buffer.
+Pressing `1' will switch between these two options.
+
\(fn &optional ARG)" t nil)
(autoload 'org-export-visible "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" (19717
-;;;;;; 39999))
+;;;;;; org-feed-update-all) "org-feed" "org/org-feed.el" (20229
+;;;;;; 34587))
;;; 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" (19717 39999))
+;;;;;; "org/org-footnote.el" (20282 42537))
;;; Generated autoloads from org/org-footnote.el
(autoload 'org-footnote-action "org-footnote" "\
Do the right thing for footnotes.
-When at a footnote reference, jump to the definition. When at a definition,
-jump to the references. When neither at definition or reference,
-create a new footnote, interactively.
+
+When at a footnote reference, jump to the definition.
+
+When at a definition, jump to the references if they exist, offer
+to create them otherwise.
+
+When neither at definition or reference, create a new footnote,
+interactively.
+
With prefix arg SPECIAL, offer additional commands in a menu.
\(fn &optional SPECIAL)" t nil)
(autoload 'org-footnote-normalize "org-footnote" "\
Collect the footnotes in various formats and normalize them.
+
This finds the different sorts of footnotes allowed in Org, and
normalizes them to the usual [N] format that is understood by the
Org-mode exporters.
+
When SORT-ONLY is set, only sort the footnote definitions into the
referenced sequence.
-\(fn &optional SORT-ONLY FOR-PREPROCESSOR)" nil nil)
+If Org is amidst an export process, EXPORT-PROPS will hold the
+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 (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.
+2. This variable (potentially) obviates the need for extra scan
+ of pre-processor buffer as witnessed in
+ `org-export-docbook-get-footnotes'.
+
+\(fn &optional SORT-ONLY EXPORT-PROPS)" nil nil)
;;;***
\f
;;;### (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" (19717 39999))
+;;;;;; "org/org-freemind.el" (20229 34587))
;;; 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" (19717 39999))
+;;;;;; "org/org-html.el" (20229 34587))
;;; 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"
-;;;;;; (19717 39999))
+;;;;;; (20229 34587))
;;; 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"
-;;;;;; (19717 39999))
+;;;;;; (20229 34587))
;;; 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"
-;;;;;; (19717 39999))
+;;;;;; (20229 34587))
;;; 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"
-;;;;;; (19717 39999))
+;;;;;; (20229 34587))
;;; 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"
-;;;;;; (19717 39999))
+;;;;;; (20229 34587))
;;; 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"
+;;;;;; (20236 7740))
+;;; 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" (19717
-;;;;;; 39999))
+;;;;;; org-mobile-push) "org-mobile" "org/org-mobile.el" (20230
+;;;;;; 13182))
;;; 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-region-as-odt org-replace-region-by-odt
+;;;;;; org-export-as-odt-to-buffer org-export-as-odt-batch org-export-as-odt-and-open)
+;;;;;; "org-odt" "org/org-odt.el" (20236 7740))
+;;; 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-to-buffer "org-odt" "\
+Call `org-lparse-odt` with output to a temporary buffer.
+No file is created. The prefix ARG is passed through to `org-lparse-to-buffer'.
+
+\(fn ARG)" t nil)
+
+(autoload 'org-replace-region-by-odt "org-odt" "\
+Assume the current region has org-mode syntax, and convert it to ODT.
+This can be used in any buffer. For example, you could write an
+itemized list in org-mode syntax in an ODT buffer and then use this
+command to convert it.
+
+\(fn BEG END)" t nil)
+
+(autoload 'org-export-region-as-odt "org-odt" "\
+Convert region from BEG to END in org-mode buffer to ODT.
+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 ODT. If BUFFER is the symbol `string', return the
+produced ODT as a string and leave not buffer behind. For example,
+a Lisp program could call this function in the following way:
+
+ (setq odt (org-export-region-as-odt 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 BEG END &optional BODY-ONLY BUFFER)" t 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"
-;;;;;; (19717 39999))
+;;;;;; (20229 34587))
;;; 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"
-;;;;;; (19717 39999))
+;;;;;; (20236 7740))
;;; 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" (19717 39999))
+;;;;;; "org/org-remember.el" (20229 34587))
;;; 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" (19717 39999))
+;;;;;; "org-table" "org/org-table.el" (20236 7740))
;;; 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" (19717 39999))
+;;;;;; "org-taskjuggler" "org/org-taskjuggler.el" (20236 7740))
;;; 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"
-;;;;;; (19717 39999))
+;;;;;; (20229 34587))
;;; 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"
-;;;;;; (19717 39999))
+;;;;;; (20229 34587))
;;; Generated autoloads from org/org-xoxo.el
(autoload 'org-export-as-xoxo "org-xoxo" "\
;;;***
\f
;;;### (autoloads (outline-minor-mode outline-mode) "outline" "outline.el"
-;;;;;; (19640 47194))
+;;;;;; (20229 34587))
;;; Generated autoloads from outline.el
-(put 'outline-regexp 'safe-local-variable 'string-or-null-p)
+(put 'outline-regexp 'safe-local-variable 'stringp)
+(put 'outline-heading-end-regexp 'safe-local-variable 'stringp)
(autoload 'outline-mode "outline" "\
Set major mode for editing outlines with selective display.
(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"
-;;;;;; (19714 43298))
+;;;;;; package-refresh-contents package-install-file package-install-from-buffer
+;;;;;; package-install package-enable-at-startup) "package" "emacs-lisp/package.el"
+;;;;;; (20299 26170))
;;; Generated autoloads from emacs-lisp/package.el
(defvar package-enable-at-startup t "\
(autoload 'package-install "package" "\
Install the package named NAME.
-Interactively, prompt for the package name.
-The package is found on one of the archives in `package-archives'.
+NAME should be the name of one of the available packages in an
+archive in `package-archives'. Interactively, prompt for NAME.
\(fn NAME)" t nil)
\(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.
(autoload 'list-packages "package" "\
Display a list of packages.
-Fetches the updated list of packages before displaying.
+This first fetches the updated list of packages before
+displaying, unless a prefix argument NO-FETCH is specified.
The list is displayed in a buffer named `*Packages*'.
-\(fn)" t nil)
+\(fn &optional NO-FETCH)" t nil)
(defalias 'package-list-packages 'list-packages)
;;;***
\f
-;;;### (autoloads (show-paren-mode) "paren" "paren.el" (19714 43298))
+;;;### (autoloads (show-paren-mode) "paren" "paren.el" (20229 34587))
;;; 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"
-;;;;;; (19598 13691))
+;;;;;; (20296 49978))
;;; Generated autoloads from calendar/parse-time.el
(put 'parse-time-rules 'risky-local-variable t)
;;;***
\f
-;;;### (autoloads (pascal-mode) "pascal" "progmodes/pascal.el" (19714
-;;;;;; 43298))
+;;;### (autoloads (pascal-mode) "pascal" "progmodes/pascal.el" (20273
+;;;;;; 55692))
;;; Generated autoloads from progmodes/pascal.el
(autoload 'pascal-mode "pascal" "\
Major mode for editing Pascal code. \\<pascal-mode-map>
TAB indents for Pascal code. Delete converts tabs to spaces as it moves back.
-\\[pascal-complete-word] completes the word around current point with respect to position in code
-\\[pascal-show-completions] shows all possible completions at this point.
+\\[completion-at-point] completes the word around current point with respect to position in code
+\\[completion-help-at-point] shows all possible completions at this point.
Other useful functions are:
See also the user variables `pascal-type-keywords', `pascal-start-keywords' and
`pascal-separator-keywords'.
-Turning on Pascal mode calls the value of the variable pascal-mode-hook with
-no args, if that value is non-nil.
-
-\(fn)" t nil)
-
-;;;***
-\f
-;;;### (autoloads (password-cache-expiry password-cache) "password-cache"
-;;;;;; "password-cache.el" (19598 13691))
-;;; Generated autoloads from password-cache.el
-
-(defvar password-cache t "\
-Whether to cache passwords.")
-
-(custom-autoload 'password-cache "password-cache" t)
-
-(defvar password-cache-expiry 16 "\
-How many seconds passwords are cached, or nil to disable expiring.
-Whether passwords are cached at all is controlled by `password-cache'.")
-
-(custom-autoload 'password-cache-expiry "password-cache" t)
-
-;;;***
-\f
-;;;### (autoloads (pc-bindings-mode) "pc-mode" "emulation/pc-mode.el"
-;;;;;; (19562 42953))
-;;; Generated autoloads from emulation/pc-mode.el
-
-(autoload 'pc-bindings-mode "pc-mode" "\
-Set up certain key bindings for PC compatibility.
-The keys affected are:
-Delete (and its variants) delete forward instead of backward.
-C-Backspace kills backward a word (as C-Delete normally would).
-M-Backspace does undo.
-Home and End move to beginning and end of line
-C-Home and C-End move to beginning and end of buffer.
-C-Escape does list-buffers.
-
-\(fn)" t nil)
-
-;;;***
-\f
-;;;### (autoloads (pc-selection-mode) "pc-select" "emulation/pc-select.el"
-;;;;;; (19619 52030))
-;;; Generated autoloads from emulation/pc-select.el
-
-(defvar pc-selection-mode nil "\
-Non-nil if Pc-Selection mode is enabled.
-See the command `pc-selection-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 `pc-selection-mode'.")
-
-(custom-autoload 'pc-selection-mode "pc-select" nil)
-
-(autoload 'pc-selection-mode "pc-select" "\
-Change mark behavior to emulate Motif, Mac or MS-Windows cut and paste style.
-
-This mode enables Delete Selection mode and Transient Mark mode.
-
-The arrow keys (and others) are bound to new functions
-which modify the status of the mark.
-
-The ordinary arrow keys disable the mark.
-The shift-arrow keys move, leaving the mark behind.
-
-C-LEFT and C-RIGHT move back or forward one word, disabling the mark.
-S-C-LEFT and S-C-RIGHT move back or forward one word, leaving the mark behind.
-
-M-LEFT and M-RIGHT move back or forward one word or sexp, disabling the mark.
-S-M-LEFT and S-M-RIGHT move back or forward one word or sexp, leaving the mark
-behind. To control whether these keys move word-wise or sexp-wise set the
-variable `pc-select-meta-moves-sexps' after loading pc-select.el but before
-turning PC Selection mode on.
+Turning on Pascal mode calls the value of the variable pascal-mode-hook with
+no args, if that value is non-nil.
-C-DOWN and C-UP move back or forward a paragraph, disabling the mark.
-S-C-DOWN and S-C-UP move back or forward a paragraph, leaving the mark behind.
+\(fn)" t nil)
-HOME moves to beginning of line, disabling the mark.
-S-HOME moves to beginning of line, leaving the mark behind.
-With Ctrl or Meta, these keys move to beginning of buffer instead.
+;;;***
+\f
+;;;### (autoloads (password-in-cache-p password-cache-expiry password-cache)
+;;;;;; "password-cache" "password-cache.el" (20229 34587))
+;;; Generated autoloads from password-cache.el
-END moves to end of line, disabling the mark.
-S-END moves to end of line, leaving the mark behind.
-With Ctrl or Meta, these keys move to end of buffer instead.
+(defvar password-cache t "\
+Whether to cache passwords.")
-PRIOR or PAGE-UP scrolls and disables the mark.
-S-PRIOR or S-PAGE-UP scrolls and leaves the mark behind.
+(custom-autoload 'password-cache "password-cache" t)
-S-DELETE kills the region (`kill-region').
-S-INSERT yanks text from the kill ring (`yank').
-C-INSERT copies the region into the kill ring (`copy-region-as-kill').
+(defvar password-cache-expiry 16 "\
+How many seconds passwords are cached, or nil to disable expiring.
+Whether passwords are cached at all is controlled by `password-cache'.")
-In addition, certain other PC bindings are imitated (to avoid this, set
-the variable `pc-select-selection-keys-only' to t after loading pc-select.el
-but before calling PC Selection mode):
+(custom-autoload 'password-cache-expiry "password-cache" t)
- F6 other-window
- DELETE delete-char
- C-DELETE kill-line
- M-DELETE kill-word
- C-M-DELETE kill-sexp
- C-BACKSPACE backward-kill-word
- M-BACKSPACE undo
+(autoload 'password-in-cache-p "password-cache" "\
+Check if KEY is in the cache.
-\(fn &optional ARG)" t nil)
+\(fn KEY)" nil nil)
;;;***
\f
;;;### (autoloads (pcase-let pcase-let* pcase) "pcase" "emacs-lisp/pcase.el"
-;;;;;; (19726 56598))
+;;;;;; (20229 34587))
;;; Generated autoloads from emacs-lisp/pcase.el
(autoload 'pcase "pcase" "\
(and UPAT...) matches if all the patterns match.
`QPAT matches if the QPattern QPAT matches.
(pred PRED) matches if PRED applied to the object returns non-nil.
- (let VAR EXP) matches anything and set VAR to the value of EXP.
(guard BOOLEXP) matches if BOOLEXP evaluates to non-nil.
+ (let UPAT EXP) matches if EXP matches UPAT.
+If a SYMBOL is used twice in the same pattern (i.e. the pattern is
+\"non-linear\"), then the second occurrence is turned into an `eq'uality test.
QPatterns can take the following forms:
(QPAT1 . QPAT2) matches if QPAT1 matches the car and QPAT2 the cdr.
,UPAT matches if the UPattern UPAT matches.
- STRING matches if the object is `equal' to STRING.
+ STRING matches if the object is `equal' to STRING.
ATOM matches if the object is `eq' to ATOM.
QPatterns for vectors are not implemented yet.
PRED can take the form
- FUNCTION in which case it gets called with one argument.
+ FUNCTION in which case it gets called with one argument.
(FUN ARG1 .. ARGN) in which case it gets called with N+1 arguments.
A PRED of the form FUNCTION is equivalent to one of the form (FUNCTION).
PRED patterns can refer to variables bound earlier in the pattern.
;;;***
\f
-;;;### (autoloads (pcomplete/cvs) "pcmpl-cvs" "pcmpl-cvs.el" (19598
-;;;;;; 13691))
+;;;### (autoloads (pcomplete/cvs) "pcmpl-cvs" "pcmpl-cvs.el" (20229
+;;;;;; 34587))
;;; 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" (19598 13691))
+;;;;;; "pcmpl-gnu" "pcmpl-gnu.el" (20254 62253))
;;; Generated autoloads from pcmpl-gnu.el
(autoload 'pcomplete/gzip "pcmpl-gnu" "\
;;;***
\f
;;;### (autoloads (pcomplete/mount pcomplete/umount pcomplete/kill)
-;;;;;; "pcmpl-linux" "pcmpl-linux.el" (19598 13691))
+;;;;;; "pcmpl-linux" "pcmpl-linux.el" (20229 34587))
;;; Generated autoloads from pcmpl-linux.el
(autoload 'pcomplete/kill "pcmpl-linux" "\
;;;***
\f
-;;;### (autoloads (pcomplete/rpm) "pcmpl-rpm" "pcmpl-rpm.el" (19598
-;;;;;; 13691))
+;;;### (autoloads (pcomplete/rpm) "pcmpl-rpm" "pcmpl-rpm.el" (20229
+;;;;;; 34587))
;;; 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" (19598 13691))
+;;;;;; pcomplete/cd) "pcmpl-unix" "pcmpl-unix.el" (20259 55615))
;;; 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" (19591
-;;;;;; 62571))
+;;;;;; pcomplete-reverse pcomplete) "pcomplete" "pcomplete.el" (20229
+;;;;;; 34587))
;;; 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" (19591 62571))
+;;;;;; "vc/pcvs.el" (20253 16827))
;;; Generated autoloads from vc/pcvs.el
(autoload 'cvs-checkout "pcvs" "\
;;;***
\f
-;;;### (autoloads nil "pcvs-defs" "vc/pcvs-defs.el" (19598 13691))
+;;;### (autoloads nil "pcvs-defs" "vc/pcvs-defs.el" (20229 34587))
;;; 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"
-;;;;;; (19714 43298))
+;;;;;; (20229 34587))
;;; 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 (pgg-snarf-keys pgg-snarf-keys-region pgg-insert-key
-;;;;;; pgg-verify pgg-verify-region pgg-sign pgg-sign-region pgg-decrypt
-;;;;;; pgg-decrypt-region pgg-encrypt pgg-encrypt-symmetric pgg-encrypt-symmetric-region
-;;;;;; pgg-encrypt-region) "pgg" "pgg.el" (19640 47194))
-;;; Generated autoloads from pgg.el
-
-(autoload 'pgg-encrypt-region "pgg" "\
-Encrypt the current region between START and END for RCPTS.
-
-If optional argument SIGN is non-nil, do a combined sign and encrypt.
-
-If optional PASSPHRASE is not specified, it will be obtained from the
-passphrase cache or user.
-
-\(fn START END RCPTS &optional SIGN PASSPHRASE)" t nil)
-
-(autoload 'pgg-encrypt-symmetric-region "pgg" "\
-Encrypt the current region between START and END symmetric with passphrase.
-
-If optional PASSPHRASE is not specified, it will be obtained from the
-cache or user.
-
-\(fn START END &optional PASSPHRASE)" t nil)
-
-(autoload 'pgg-encrypt-symmetric "pgg" "\
-Encrypt the current buffer using a symmetric, rather than key-pair, cipher.
-
-If optional arguments START and END are specified, only encrypt within
-the region.
-
-If optional PASSPHRASE is not specified, it will be obtained from the
-passphrase cache or user.
-
-\(fn &optional START END PASSPHRASE)" t nil)
-
-(autoload 'pgg-encrypt "pgg" "\
-Encrypt the current buffer for RCPTS.
-
-If optional argument SIGN is non-nil, do a combined sign and encrypt.
-
-If optional arguments START and END are specified, only encrypt within
-the region.
-
-If optional PASSPHRASE is not specified, it will be obtained from the
-passphrase cache or user.
-
-\(fn RCPTS &optional SIGN START END PASSPHRASE)" t nil)
-
-(autoload 'pgg-decrypt-region "pgg" "\
-Decrypt the current region between START and END.
-
-If optional PASSPHRASE is not specified, it will be obtained from the
-passphrase cache or user.
-
-\(fn START END &optional PASSPHRASE)" t nil)
-
-(autoload 'pgg-decrypt "pgg" "\
-Decrypt the current buffer.
-
-If optional arguments START and END are specified, only decrypt within
-the region.
-
-If optional PASSPHRASE is not specified, it will be obtained from the
-passphrase cache or user.
-
-\(fn &optional START END PASSPHRASE)" t nil)
-
-(autoload 'pgg-sign-region "pgg" "\
-Make the signature from text between START and END.
-
-If the optional 3rd argument CLEARTEXT is non-nil, it does not create
-a detached signature.
-
-If this function is called interactively, CLEARTEXT is enabled
-and the output is displayed.
-
-If optional PASSPHRASE is not specified, it will be obtained from the
-passphrase cache or user.
-
-\(fn START END &optional CLEARTEXT PASSPHRASE)" t nil)
-
-(autoload 'pgg-sign "pgg" "\
-Sign the current buffer.
-
-If the optional argument CLEARTEXT is non-nil, it does not create a
-detached signature.
-
-If optional arguments START and END are specified, only sign data
-within the region.
-
-If this function is called interactively, CLEARTEXT is enabled
-and the output is displayed.
-
-If optional PASSPHRASE is not specified, it will be obtained from the
-passphrase cache or user.
-
-\(fn &optional CLEARTEXT START END PASSPHRASE)" t nil)
-
-(autoload 'pgg-verify-region "pgg" "\
-Verify the current region between START and END.
-If the optional 3rd argument SIGNATURE is non-nil, it is treated as
-the detached signature of the current region.
-
-If the optional 4th argument FETCH is non-nil, we attempt to fetch the
-signer's public key from `pgg-default-keyserver-address'.
-
-\(fn START END &optional SIGNATURE FETCH)" t nil)
-
-(autoload 'pgg-verify "pgg" "\
-Verify the current buffer.
-If the optional argument SIGNATURE is non-nil, it is treated as
-the detached signature of the current region.
-If the optional argument FETCH is non-nil, we attempt to fetch the
-signer's public key from `pgg-default-keyserver-address'.
-If optional arguments START and END are specified, only verify data
-within the region.
-
-\(fn &optional SIGNATURE FETCH START END)" t nil)
-
-(autoload 'pgg-insert-key "pgg" "\
-Insert the ASCII armored public key.
-
-\(fn)" t nil)
-
-(autoload 'pgg-snarf-keys-region "pgg" "\
-Import public keys in the current region between START and END.
-
-\(fn START END)" t nil)
-
-(autoload 'pgg-snarf-keys "pgg" "\
-Import public keys in the current buffer.
-
-\(fn)" t nil)
-
-;;;***
-\f
-;;;### (autoloads (pgg-gpg-symmetric-key-p) "pgg-gpg" "pgg-gpg.el"
-;;;;;; (19598 13691))
-;;; Generated autoloads from pgg-gpg.el
-
-(autoload 'pgg-gpg-symmetric-key-p "pgg-gpg" "\
-True if decoded armor MESSAGE-KEYS has symmetric encryption indicator.
-
-\(fn MESSAGE-KEYS)" nil nil)
-
-;;;***
-\f
;;;### (autoloads (picture-mode) "picture" "textmodes/picture.el"
-;;;;;; (19714 43298))
+;;;;;; (20291 63109))
;;; 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" (20229
+;;;;;; 34587))
+;;; Generated autoloads from gnus/plstore.el
+
+(autoload 'plstore-open "plstore" "\
+Create a plstore instance associated with FILE.
+
+\(fn FILE)" nil nil)
+
+;;;***
+\f
;;;### (autoloads (po-find-file-coding-system) "po" "textmodes/po.el"
-;;;;;; (19562 42953))
+;;;;;; (20229 34587))
;;; Generated autoloads from textmodes/po.el
(autoload 'po-find-file-coding-system "po" "\
;;;***
\f
-;;;### (autoloads (pong) "pong" "play/pong.el" (19562 42953))
+;;;### (autoloads (pong) "pong" "play/pong.el" (20229 34587))
;;; Generated autoloads from play/pong.el
(autoload 'pong "pong" "\
;;;***
\f
-;;;### (autoloads (pop3-movemail) "pop3" "gnus/pop3.el" (19714 43298))
+;;;### (autoloads (pop3-movemail) "pop3" "gnus/pop3.el" (20229 34587))
;;; 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"
-;;;;;; (19591 62571))
+;;;;;; (20270 25925))
;;; 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"
-;;;;;; (19714 43298))
+;;;;;; (20229 34587))
;;; Generated autoloads from printing.el
(autoload 'pr-interface "printing" "\
\(fn)" t nil)
(autoload 'pr-toggle-region "printing" "\
-Toggle auto region.
+Toggle whether the region is automagically detected.
\(fn)" t nil)
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" (19598 13691))
+;;;### (autoloads (proced) "proced" "proced.el" (20229 34587))
;;; Generated autoloads from proced.el
(autoload 'proced "proced" "\
;;;***
\f
-;;;### (autoloads (switch-to-prolog prolog-mode) "prolog" "progmodes/prolog.el"
-;;;;;; (19714 43298))
+;;;### (autoloads (run-prolog mercury-mode prolog-mode) "prolog"
+;;;;;; "progmodes/prolog.el" (20293 40451))
;;; Generated autoloads from progmodes/prolog.el
(autoload 'prolog-mode "prolog" "\
-Major mode for editing Prolog code for Prologs.
-Blank lines and `%%...' separate paragraphs. `%'s start comments.
+Major mode for editing Prolog code.
+
+Blank lines and `%%...' separate paragraphs. `%'s starts a comment
+line and comments can also be enclosed in /* ... */.
+
+If an optional argument SYSTEM is non-nil, set up mode for the given system.
+
+To find out what version of Prolog mode you are running, enter
+`\\[prolog-mode-version]'.
+
Commands:
\\{prolog-mode-map}
Entry to this mode calls the value of `prolog-mode-hook'
\(fn)" t nil)
-(defalias 'run-prolog 'switch-to-prolog)
-
-(autoload 'switch-to-prolog "prolog" "\
-Run an inferior Prolog process, input and output via buffer *prolog*.
-With prefix argument \\[universal-prefix], prompt for the program to use.
-
-\(fn &optional NAME)" t nil)
-
-;;;***
-\f
-;;;### (autoloads (open-protocol-stream) "proto-stream" "gnus/proto-stream.el"
-;;;;;; (19717 39999))
-;;; Generated autoloads from gnus/proto-stream.el
-
-(autoload 'open-protocol-stream "proto-stream" "\
-Open a network stream to HOST, upgrading to STARTTLS if possible.
-The first four parameters have the same meaning as in
-`open-network-stream'. The function returns a list where the
-first element is the stream, the second element is the greeting
-the server replied with after connecting, and the third element
-is a string representing the capabilities of the server (if any).
-
-The PARAMETERS is a keyword list that can have the following
-values:
-
-:type -- either `network', `network-only, `tls', `shell' or
-`starttls'. If omitted, the default is `network'. `network'
-will be opportunistically upgraded to STARTTLS if both the server
-and Emacs supports it. If you don't want STARTTLS upgrades, use
-`network-only'.
-
-:end-of-command -- a regexp saying what the end of a command is.
-This defaults to \"\\n\".
-
-:success -- a regexp saying whether the STARTTLS command was
-successful or not. For instance, for NNTP this is \"^3\".
+(autoload 'mercury-mode "prolog" "\
+Major mode for editing Mercury programs.
+Actually this is just customized `prolog-mode'.
-:capability-command -- a string representing the command used to
-query server for capabilities. For instance, for IMAP this is
-\"1 CAPABILITY\\r\\n\".
+\(fn)" t nil)
-:starttls-function -- a function that takes one parameter, which
-is the response to the capaibility command. It should return nil
-if it turns out that the server doesn't support STARTTLS, or the
-command to switch on STARTTLS otherwise.
+(autoload 'run-prolog "prolog" "\
+Run an inferior Prolog process, input and output via buffer *prolog*.
+With prefix argument ARG, restart the Prolog process if running before.
-\(fn NAME BUFFER HOST SERVICE &rest PARAMETERS)" nil nil)
+\(fn ARG)" t nil)
;;;***
\f
-;;;### (autoloads (bdf-directory-list) "ps-bdf" "ps-bdf.el" (19598
-;;;;;; 13691))
+;;;### (autoloads (bdf-directory-list) "ps-bdf" "ps-bdf.el" (20229
+;;;;;; 34587))
;;; 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" (19714
-;;;;;; 43298))
+;;;### (autoloads (ps-mode) "ps-mode" "progmodes/ps-mode.el" (20229
+;;;;;; 34587))
;;; 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" (19714
-;;;;;; 43298))
+;;;;;; ps-page-dimensions-database) "ps-print" "ps-print.el" (20229
+;;;;;; 36386))
;;; 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 (python-shell jython-mode python-mode run-python)
-;;;;;; "python" "progmodes/python.el" (19714 43298))
+;;;### (autoloads (jython-mode python-mode python-after-info-look
+;;;;;; run-python) "python" "progmodes/python.el" (20278 20028))
;;; Generated autoloads from progmodes/python.el
(add-to-list 'interpreter-mode-alist (cons (purecopy "jython") 'jython-mode))
\(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)
+
(autoload 'python-mode "python" "\
Major mode for editing Python files.
Turns on Font Lock mode unconditionally since it is currently required
\(fn)" t nil)
-(autoload 'python-shell "python" "\
-Start an interactive Python interpreter in another window.
-This is like Shell mode, except that Python is running in the window
-instead of a shell. See the `Interactive Shell' and `Shell Mode'
-sections of the Emacs manual for details, especially for the key
-bindings active in the `*Python*' buffer.
-
-With optional \\[universal-argument], the user is prompted for the
-flags to pass to the Python interpreter. This has no effect when this
-command is used to switch to an existing process, only when a new
-process is started. If you use this, you will probably want to ensure
-that the current arguments are retained (they will be included in the
-prompt). This argument is ignored when this function is called
-programmatically.
-
-Note: You can toggle between using the CPython interpreter and the
-JPython interpreter by hitting \\[python-toggle-shells]. This toggles
-buffer local variables which control whether all your subshell
-interactions happen to the `*JPython*' or `*Python*' buffers (the
-latter is the name used for the CPython buffer).
-
-Warning: Don't use an interactive Python if you change sys.ps1 or
-sys.ps2 from their default values, or if you're running code that
-prints `>>> ' or `... ' at the start of a line. `python-mode' can't
-distinguish your output from Python's output, and assumes that `>>> '
-at the start of a line is a prompt from Python. Similarly, the Emacs
-Shell mode code assumes that both `>>> ' and `... ' at the start of a
-line are Python prompts. Bad things can happen if you fool either
-mode.
-
-Warning: If you do any editing *in* the process buffer *while* the
-buffer is accepting output from Python, do NOT attempt to `undo' the
-changes. Some of the output (nowhere near the parts you changed!) may
-be lost if you do. This appears to be an Emacs bug, an unfortunate
-interaction between undo and process filters; the same problem exists in
-non-Python process buffers using the default (Emacs-supplied) process
-filter.
-
-\(fn &optional ARGPROMPT)" t nil)
-
;;;***
\f
;;;### (autoloads (quoted-printable-decode-region) "qp" "gnus/qp.el"
-;;;;;; (19598 13691))
+;;;;;; (20229 34587))
;;; 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" (19591 62571))
+;;;;;; "international/quail.el" (20229 34587))
;;; Generated autoloads from international/quail.el
(autoload 'quail-title "quail" "\
\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" (19714
-;;;;;; 43298))
+;;;;;; quickurl-ask quickurl) "quickurl" "net/quickurl.el" (20229
+;;;;;; 34587))
;;; 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" "\
in your ~/.emacs (after loading/requiring quickurl).")
(autoload 'quickurl "quickurl" "\
-Insert an URL based on LOOKUP.
+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)
(autoload 'quickurl-ask "quickurl" "\
-Insert an URL, with `completing-read' prompt, based on LOOKUP.
+Insert a URL, with `completing-read' prompt, based on LOOKUP.
\(fn LOOKUP)" t nil)
(autoload 'quickurl-add-url "quickurl" "\
Allow the user to interactively add a new URL associated with WORD.
-See `quickurl-grab-url' for details on how the default word/url combination
+See `quickurl-grab-url' for details on how the default word/URL combination
is decided.
\(fn WORD URL COMMENT)" 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" (19598 13691))
+;;;;;; "net/rcirc.el" (20280 61753))
;;; Generated autoloads from net/rcirc.el
(autoload 'rcirc "rcirc" "\
(defalias 'irc 'rcirc)
(autoload 'rcirc-connect "rcirc" "\
-Not documented
-\(fn SERVER &optional PORT NICK USER-NAME FULL-NAME STARTUP-CHANNELS PASSWORD)" nil nil)
+
+\(fn SERVER &optional PORT NICK USER-NAME FULL-NAME STARTUP-CHANNELS PASSWORD ENCRYPTION)" nil nil)
(defvar rcirc-track-minor-mode nil "\
Non-nil if Rcirc-Track minor mode is enabled.
(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" (19619
-;;;;;; 52030))
+;;;### (autoloads (remote-compile) "rcompile" "net/rcompile.el" (20290
+;;;;;; 11197))
;;; Generated autoloads from net/rcompile.el
(autoload 'remote-compile "rcompile" "\
;;;***
\f
;;;### (autoloads (re-builder) "re-builder" "emacs-lisp/re-builder.el"
-;;;;;; (19591 62571))
+;;;;;; (20229 34587))
;;; Generated autoloads from emacs-lisp/re-builder.el
(defalias 'regexp-builder 're-builder)
(autoload 're-builder "re-builder" "\
Construct a regexp interactively.
+This command makes the current buffer the \"target\" buffer of
+the regexp builder. It displays a buffer named \"*RE-Builder*\"
+in another window, initially containing an empty regexp.
+
+As you edit the regexp in the \"*RE-Builder*\" buffer, the
+matching parts of the target buffer will be highlighted.
\(fn)" t nil)
;;;***
\f
-;;;### (autoloads (recentf-mode) "recentf" "recentf.el" (19562 42953))
+;;;### (autoloads (recentf-mode) "recentf" "recentf.el" (20229 34587))
;;; 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)
;;;***
\f
-;;;### (autoloads (clear-rectangle string-insert-rectangle string-rectangle
-;;;;;; delete-whitespace-rectangle open-rectangle insert-rectangle
-;;;;;; yank-rectangle kill-rectangle extract-rectangle delete-extract-rectangle
-;;;;;; delete-rectangle move-to-column-force) "rect" "rect.el" (19598
-;;;;;; 13691))
+;;;### (autoloads (rectangle-number-lines clear-rectangle string-insert-rectangle
+;;;;;; string-rectangle delete-whitespace-rectangle open-rectangle
+;;;;;; insert-rectangle yank-rectangle kill-rectangle extract-rectangle
+;;;;;; delete-extract-rectangle delete-rectangle) "rect" "rect.el"
+;;;;;; (20229 34587))
;;; Generated autoloads from rect.el
(define-key ctl-x-r-map "c" 'clear-rectangle)
(define-key ctl-x-r-map "k" 'kill-rectangle)
(define-key ctl-x-r-map "y" 'yank-rectangle)
(define-key ctl-x-r-map "o" 'open-rectangle)
(define-key ctl-x-r-map "t" 'string-rectangle)
-
-(autoload 'move-to-column-force "rect" "\
-If COLUMN is within a multi-column character, replace it by spaces and tab.
-As for `move-to-column', passing anything but nil or t in FLAG will move to
-the desired column only if the line is long enough.
-
-\(fn COLUMN &optional FLAG)" nil nil)
-
-(make-obsolete 'move-to-column-force 'move-to-column "21.2")
+ (define-key ctl-x-r-map "N" 'rectangle-number-lines)
(autoload 'delete-rectangle "rect" "\
Delete (don't save) text in the region-rectangle.
\(fn START END &optional FILL)" t nil)
+(autoload 'rectangle-number-lines "rect" "\
+Insert numbers in front of the region-rectangle.
+
+START-AT, if non-nil, should be a number from which to begin
+counting. FORMAT, if non-nil, should be a format string to pass
+to `format' along with the line count. When called interactively
+with a prefix argument, prompt for START-AT and FORMAT.
+
+\(fn START END START-AT &optional FORMAT)" t nil)
+
;;;***
\f
-;;;### (autoloads (refill-mode) "refill" "textmodes/refill.el" (19591
-;;;;;; 62571))
+;;;### (autoloads (refill-mode) "refill" "textmodes/refill.el" (20229
+;;;;;; 34587))
;;; 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" (19598 13691))
+;;;;;; turn-on-reftex) "reftex" "textmodes/reftex.el" (20229 34587))
;;; 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"
-;;;;;; (19714 43298))
+;;;;;; (20229 34587))
;;; Generated autoloads from textmodes/reftex-cite.el
(autoload 'reftex-citation "reftex-cite" "\
;;;***
\f
;;;### (autoloads (reftex-isearch-minor-mode) "reftex-global" "textmodes/reftex-global.el"
-;;;;;; (19598 13691))
+;;;;;; (20229 34587))
;;; 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"
-;;;;;; (19714 43298))
+;;;;;; (20229 34587))
;;; Generated autoloads from textmodes/reftex-index.el
(autoload 'reftex-index-phrases-mode "reftex-index" "\
Here are all local bindings.
-\\{reftex-index-phrases-map}
+\\{reftex-index-phrases-mode-map}
\(fn)" t nil)
;;;***
\f
;;;### (autoloads (reftex-all-document-files) "reftex-parse" "textmodes/reftex-parse.el"
-;;;;;; (19619 52030))
+;;;;;; (20229 34587))
;;; Generated autoloads from textmodes/reftex-parse.el
(autoload 'reftex-all-document-files "reftex-parse" "\
;;;***
\f
-;;;### (autoloads nil "reftex-vars" "textmodes/reftex-vars.el" (19598
-;;;;;; 13691))
+;;;### (autoloads nil "reftex-vars" "textmodes/reftex-vars.el" (20229
+;;;;;; 34587))
;;; 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"
-;;;;;; (19714 43298))
+;;;;;; (20300 47034))
;;; 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"
-;;;;;; (19714 43298))
+;;;;;; (20229 34587))
;;; Generated autoloads from textmodes/remember.el
(autoload 'remember "remember" "\
;;;***
\f
-;;;### (autoloads (repeat) "repeat" "repeat.el" (19714 43298))
+;;;### (autoloads (repeat) "repeat" "repeat.el" (20229 34587))
;;; Generated autoloads from repeat.el
(autoload 'repeat "repeat" "\
;;;***
\f
;;;### (autoloads (reporter-submit-bug-report) "reporter" "mail/reporter.el"
-;;;;;; (19562 42953))
+;;;;;; (20229 34587))
;;; Generated autoloads from mail/reporter.el
(autoload 'reporter-submit-bug-report "reporter" "\
;;;***
\f
;;;### (autoloads (reposition-window) "reposition" "reposition.el"
-;;;;;; (19714 43298))
+;;;;;; (20229 34587))
;;; Generated autoloads from reposition.el
(autoload 'reposition-window "reposition" "\
;;;***
\f
;;;### (autoloads (global-reveal-mode reveal-mode) "reveal" "reveal.el"
-;;;;;; (19591 62571))
+;;;;;; (20229 34587))
;;; 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"
-;;;;;; (19562 42953))
+;;;;;; (20229 34587))
;;; Generated autoloads from emacs-lisp/ring.el
(autoload 'ring-p "ring" "\
;;;***
\f
-;;;### (autoloads (rlogin) "rlogin" "net/rlogin.el" (19619 52030))
+;;;### (autoloads (rlogin) "rlogin" "net/rlogin.el" (20229 34587))
;;; 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-dont-reply-to-names rmail-user-mail-address-regexp
-;;;;;; rmail-movemail-variant-p) "rmail" "mail/rmail.el" (19714
-;;;;;; 43298))
+;;;;;; rmail-user-mail-address-regexp rmail-movemail-variant-p)
+;;;;;; "rmail" "mail/rmail.el" (20288 55881))
;;; Generated autoloads from mail/rmail.el
(autoload 'rmail-movemail-variant-p "rmail" "\
(custom-autoload 'rmail-user-mail-address-regexp "rmail" t)
-(defvar rmail-dont-reply-to-names nil "\
-A regexp specifying addresses to prune from a reply message.
-If this is nil, it is set the first time you compose a reply, to
-a value which excludes your own email address, plus whatever is
-specified by `rmail-default-dont-reply-to-names'.
-
-Matching addresses are excluded from the CC field in replies, and
-also the To field, unless this would leave an empty To field.")
+(define-obsolete-variable-alias 'rmail-dont-reply-to-names 'mail-dont-reply-to-names "24.1")
-(custom-autoload 'rmail-dont-reply-to-names "rmail" t)
+(defvar rmail-default-dont-reply-to-names nil "\
+Regexp specifying part of the default value of `mail-dont-reply-to-names'.
+This is used when the user does not set `mail-dont-reply-to-names'
+explicitly.")
-(defvar rmail-default-dont-reply-to-names (purecopy "\\`info-") "\
-Regexp specifying part of the default value of `rmail-dont-reply-to-names'.
-This is used when the user does not set `rmail-dont-reply-to-names'
-explicitly. (The other part of the default value is the user's
-email address and name.) It is useful to set this variable in
-the site customization file. The default value is conventionally
-used for large mailing lists to broadcast announcements.")
+(make-obsolete-variable 'rmail-default-dont-reply-to-names 'mail-dont-reply-to-names "24.1")
(defvar rmail-ignored-headers (purecopy (concat "^via:\\|^mail-from:\\|^origin:\\|^references:\\|^sender:" "\\|^status:\\|^received:\\|^x400-originator:\\|^x400-recipients:" "\\|^x400-received:\\|^x400-mts-identifier:\\|^x400-content-type:" "\\|^\\(resent-\\|\\)message-id:\\|^summary-line:\\|^resent-date:" "\\|^nntp-posting-host:\\|^path:\\|^x-char.*:\\|^x-face:\\|^face:" "\\|^x-mailer:\\|^delivered-to:\\|^lines:" "\\|^content-transfer-encoding:\\|^x-coding-system:" "\\|^return-path:\\|^errors-to:\\|^return-receipt-to:" "\\|^precedence:\\|^mime-version:" "\\|^list-owner:\\|^list-help:\\|^list-post:\\|^list-subscribe:" "\\|^list-id:\\|^list-unsubscribe:\\|^list-archive:" "\\|^content-length:\\|^nntp-posting-date:\\|^user-agent" "\\|^importance:\\|^envelope-to:\\|^delivery-date\\|^openpgp:" "\\|^mbox-line:\\|^cancel-lock:" "\\|^DomainKey-Signature:\\|^dkim-signature:" "\\|^resent-face:\\|^resent-x.*:\\|^resent-organization:\\|^resent-openpgp:" "\\|^x-.*:")) "\
Regexp to match header fields that Rmail should normally hide.
(custom-autoload 'rmail-displayed-headers "rmail" t)
-(defvar rmail-retry-ignored-headers (purecopy "^x-authentication-warning:\\|^x-detected-operating-system:\\|^x-spam[-a-z]*:\\|content-type:\\|content-transfer-encoding:\\|mime-version:") "\
+(defvar rmail-retry-ignored-headers (purecopy "^x-authentication-warning:\\|^x-detected-operating-system:\\|^x-spam[-a-z]*:\\|content-type:\\|content-transfer-encoding:\\|mime-version:\\|message-id:") "\
Headers that should be stripped when retrying a failed message.")
(custom-autoload 'rmail-retry-ignored-headers "rmail" t)
(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" (19598 13691))
+;;;;;; rmail-output) "rmailout" "mail/rmailout.el" (20229 34587))
;;; 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"
-;;;;;; (19562 42953))
+;;;;;; (20229 34587))
;;; 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"
-;;;;;; (19714 43298))
+;;;;;; (20229 34587))
;;; 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"
-;;;;;; (19714 43298))
+;;;;;; (20277 28925))
;;; 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" (19562
-;;;;;; 42953))
+;;;### (autoloads (rng-xsd-compile) "rng-xsd" "nxml/rng-xsd.el" (20229
+;;;;;; 34587))
;;; 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" (19562 42953))
+;;;;;; "robin" "international/robin.el" (20209 49217))
;;; Generated autoloads from international/robin.el
(autoload 'robin-define-package "robin" "\
;;;***
\f
;;;### (autoloads (toggle-rot13-mode rot13-other-window rot13-region
-;;;;;; rot13-string rot13) "rot13" "rot13.el" (19591 62571))
+;;;;;; rot13-string rot13) "rot13" "rot13.el" (20229 34587))
;;; Generated autoloads from rot13.el
(autoload 'rot13 "rot13" "\
;;;***
\f
;;;### (autoloads (rst-minor-mode rst-mode) "rst" "textmodes/rst.el"
-;;;;;; (19714 43298))
+;;;;;; (20229 34587))
;;; Generated autoloads from textmodes/rst.el
(add-to-list 'auto-mode-alist (purecopy '("\\.re?st\\'" . rst-mode)))
\(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"
-;;;;;; (19714 43298))
+;;;;;; (20229 34587))
;;; Generated autoloads from progmodes/ruby-mode.el
(autoload 'ruby-mode "ruby-mode" "\
;;;***
\f
-;;;### (autoloads (ruler-mode) "ruler-mode" "ruler-mode.el" (19562
-;;;;;; 42953))
+;;;### (autoloads (ruler-mode) "ruler-mode" "ruler-mode.el" (20229
+;;;;;; 34587))
;;; 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" (19598
-;;;;;; 13691))
+;;;### (autoloads (rx rx-to-string) "rx" "emacs-lisp/rx.el" (20229
+;;;;;; 34587))
;;; Generated autoloads from emacs-lisp/rx.el
(autoload 'rx-to-string "rx" "\
like `and', but makes the match accessible with `match-end',
`match-beginning', and `match-string'.
+`(submatch-n N SEXP1 SEXP2 ...)'
+`(group-n N SEXP1 SEXP2 ...)'
+ like `group', but make it an explicitly-numbered group with
+ group number N.
+
`(or SEXP1 SEXP2 ...)'
`(| SEXP1 SEXP2 ...)'
matches anything that matches SEXP1 or SEXP2, etc. If all
;;;***
\f
-;;;### (autoloads (savehist-mode) "savehist" "savehist.el" (19591
-;;;;;; 62571))
+;;;### (autoloads (savehist-mode) "savehist" "savehist.el" (20229
+;;;;;; 34587))
;;; 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"
-;;;;;; (19714 43298))
+;;;;;; (20229 34587))
;;; Generated autoloads from progmodes/scheme.el
(autoload 'scheme-mode "scheme" "\
;;;***
\f
;;;### (autoloads (gnus-score-mode) "score-mode" "gnus/score-mode.el"
-;;;;;; (19598 13691))
+;;;;;; (20229 34587))
;;; Generated autoloads from gnus/score-mode.el
(autoload 'gnus-score-mode "score-mode" "\
;;;***
\f
;;;### (autoloads (scroll-all-mode) "scroll-all" "scroll-all.el"
-;;;;;; (19562 42953))
+;;;;;; (20229 34587))
;;; 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"
-;;;;;; (19591 62571))
+;;;;;; (20273 55692))
;;; 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" (19562 42953))
+;;;### (autoloads nil "secrets" "net/secrets.el" (20300 47034))
;;; 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" (19619 52030))
+;;;;;; "cedet/semantic.el" (20300 47034))
;;; 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 mail-send-nonascii mail-bury-selects-summary 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-alias-file mail-default-reply-to mail-archive-file-name
+;;;;;; 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" (19714 43298))
+;;;;;; "sendmail" "mail/sendmail.el" (20277 28925))
;;; Generated autoloads from mail/sendmail.el
(defvar mail-from-style 'default "\
(custom-autoload 'mail-interactive "sendmail" t)
-(put 'send-mail-function 'standard-value '((if (and window-system (memq system-type '(darwin windows-nt))) 'mailclient-send-it 'sendmail-send-it)))
-
-(defvar send-mail-function (if (and window-system (memq system-type '(darwin windows-nt))) 'mailclient-send-it 'sendmail-send-it) "\
+(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,
`message-send-mail-function' for use with the Message package.")
(custom-autoload 'send-mail-function "sendmail" t)
-(custom-initialize-delay 'send-mail-function 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-reply-to "sendmail" t)
-(defvar mail-alias-file nil "\
-If non-nil, the name of a file to use instead of `/usr/lib/aliases'.
-This file defines aliases to be expanded by the mailer; this is a different
-feature from that of defining aliases in `.mailrc' to be expanded in Emacs.
-This variable has no effect unless your system uses sendmail as its mailer.")
-
-(custom-autoload 'mail-alias-file "sendmail" t)
-
(defvar mail-personal-alias-file (purecopy "~/.mailrc") "\
If non-nil, the name of the user's personal mail alias file.
This file typically should be in same format as the `.mailrc' file used by
(custom-autoload 'mail-default-headers "sendmail" t)
-(defvar mail-bury-selects-summary t "\
-If non-nil, try to show Rmail summary buffer after returning from mail.
-The functions \\[mail-send-on-exit] or \\[mail-dont-send] select
-the Rmail summary buffer before returning, if it exists and this variable
-is non-nil.")
+(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)
-(custom-autoload 'mail-bury-selects-summary "sendmail" t)
+(autoload 'sendmail-user-agent-compose "sendmail" "\
-(defvar mail-send-nonascii 'mime "\
-Specify whether to allow sending non-ASCII characters in mail.
-If t, that means do allow it. nil means don't allow it.
-`query' means ask the user each time.
-`mime' means add an appropriate MIME header if none already present.
-The default is `mime'.
-Including non-ASCII characters in a mail message can be problematical
-for the recipient, who may not know how to decode them properly.")
-(custom-autoload 'mail-send-nonascii "sendmail" t)
+\(fn &optional TO SUBJECT OTHER-HEADERS CONTINUE SWITCH-FUNCTION YANK-ACTION SEND-ACTIONS RETURN-ACTION &rest IGNORED)" nil nil)
(autoload 'mail-mode "sendmail" "\
Major mode for editing mail to be sent.
\\[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-sent-via] mail-sent-via (add a sent-via field for each To or CC).
+\\[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).
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).
when the message is sent, we apply FUNCTION to ARGS.
This is how Rmail arranges to mark messages `answered'.
-\(fn &optional NOERASE TO SUBJECT IN-REPLY-TO CC REPLYBUFFER ACTIONS)" t nil)
+\(fn &optional NOERASE TO SUBJECT IN-REPLY-TO CC REPLYBUFFER ACTIONS RETURN-ACTION)" t nil)
(autoload 'mail-other-window "sendmail" "\
Like `mail' command, but display mail buffer in another window.
;;;***
\f
;;;### (autoloads (server-save-buffers-kill-terminal server-mode
-;;;;;; server-force-delete server-start) "server" "server.el" (19714
-;;;;;; 43298))
+;;;;;; server-force-delete server-start) "server" "server.el" (20275
+;;;;;; 12606))
;;; Generated autoloads from server.el
(put 'server-host 'risky-local-variable t)
(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" (19591 62571))
+;;;### (autoloads (ses-mode) "ses" "ses.el" (20279 40897))
;;; Generated autoloads from ses.el
(autoload 'ses-mode "ses" "\
;;;***
\f
;;;### (autoloads (html-mode sgml-mode) "sgml-mode" "textmodes/sgml-mode.el"
-;;;;;; (19717 39999))
+;;;;;; (20300 47034))
;;; Generated autoloads from textmodes/sgml-mode.el
(autoload 'sgml-mode "sgml-mode" "\
;;;***
\f
;;;### (autoloads (sh-mode) "sh-script" "progmodes/sh-script.el"
-;;;;;; (19714 43298))
+;;;;;; (20229 34587))
;;; Generated autoloads from progmodes/sh-script.el
(put 'sh-shell 'safe-local-variable 'symbolp)
;;;***
\f
-;;;### (autoloads (sha1) "sha1" "sha1.el" (19598 13691))
-;;; Generated autoloads from sha1.el
-
-(autoload 'sha1 "sha1" "\
-Return the SHA1 (Secure Hash Algorithm) of an object.
-OBJECT is either a string or a buffer.
-Optional arguments BEG and END denote buffer positions for computing the
-hash of a portion of OBJECT.
-If BINARY is non-nil, return a string in binary form.
-
-\(fn OBJECT &optional BEG END BINARY)" nil nil)
-
-;;;***
-\f
;;;### (autoloads (list-load-path-shadows) "shadow" "emacs-lisp/shadow.el"
-;;;;;; (19640 47194))
+;;;;;; (20229 34587))
;;; 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" (19562
-;;;;;; 42953))
+;;;;;; shadow-define-cluster) "shadowfile" "shadowfile.el" (20229
+;;;;;; 34587))
;;; Generated autoloads from shadowfile.el
(autoload 'shadow-define-cluster "shadowfile" "\
;;;***
\f
;;;### (autoloads (shell shell-dumb-shell-regexp) "shell" "shell.el"
-;;;;;; (19714 43298))
+;;;;;; (20300 47034))
;;; 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" (19714
-;;;;;; 43298))
+;;;### (autoloads (shr-insert-document) "shr" "gnus/shr.el" (20298
+;;;;;; 5305))
;;; Generated autoloads from gnus/shr.el
(autoload 'shr-insert-document "shr" "\
-Not documented
+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" (19640 47194))
+;;;;;; "sieve" "gnus/sieve.el" (20229 34587))
;;; Generated autoloads from gnus/sieve.el
(autoload 'sieve-manage "sieve" "\
-Not documented
+
\(fn SERVER &optional PORT)" t nil)
(autoload 'sieve-upload "sieve" "\
-Not documented
+
\(fn &optional NAME)" t nil)
(autoload 'sieve-upload-and-bury "sieve" "\
-Not documented
+
\(fn &optional NAME)" t nil)
;;;***
\f
;;;### (autoloads (sieve-mode) "sieve-mode" "gnus/sieve-mode.el"
-;;;;;; (19598 13691))
+;;;;;; (20229 34587))
;;; Generated autoloads from gnus/sieve-mode.el
(autoload 'sieve-mode "sieve-mode" "\
;;;***
\f
-;;;### (autoloads (simula-mode) "simula" "progmodes/simula.el" (19714
-;;;;;; 43298))
+;;;### (autoloads (simula-mode) "simula" "progmodes/simula.el" (20229
+;;;;;; 34587))
;;; 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" (19714 43298))
+;;;;;; define-skeleton) "skeleton" "skeleton.el" (20229 34587))
;;; Generated autoloads from skeleton.el
(defvar skeleton-filter-function 'identity "\
;;;***
\f
;;;### (autoloads (smerge-start-session smerge-mode smerge-ediff)
-;;;;;; "smerge-mode" "vc/smerge-mode.el" (19714 43298))
+;;;;;; "smerge-mode" "vc/smerge-mode.el" (20273 55692))
;;; 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"
-;;;;;; (19598 13691))
+;;;;;; (20229 34587))
;;; Generated autoloads from gnus/smiley.el
(autoload 'smiley-region "smiley" "\
;;;***
\f
;;;### (autoloads (smtpmail-send-queued-mail smtpmail-send-it) "smtpmail"
-;;;;;; "mail/smtpmail.el" (19562 42953))
+;;;;;; "mail/smtpmail.el" (20283 8297))
;;; Generated autoloads from mail/smtpmail.el
(autoload 'smtpmail-send-it "smtpmail" "\
-Not documented
+
\(fn)" nil nil)
;;;***
\f
-;;;### (autoloads (snake) "snake" "play/snake.el" (19562 42953))
+;;;### (autoloads (snake) "snake" "play/snake.el" (20229 34587))
;;; Generated autoloads from play/snake.el
(autoload 'snake "snake" "\
;;;***
\f
;;;### (autoloads (snmpv2-mode snmp-mode) "snmp-mode" "net/snmp-mode.el"
-;;;;;; (19562 42953))
+;;;;;; (20229 34587))
;;; Generated autoloads from net/snmp-mode.el
(autoload 'snmp-mode "snmp-mode" "\
;;;***
\f
-;;;### (autoloads (sunrise-sunset) "solar" "calendar/solar.el" (19619
-;;;;;; 52030))
+;;;### (autoloads (sunrise-sunset) "solar" "calendar/solar.el" (20229
+;;;;;; 34587))
;;; Generated autoloads from calendar/solar.el
(autoload 'sunrise-sunset "solar" "\
;;;***
\f
-;;;### (autoloads (solitaire) "solitaire" "play/solitaire.el" (19562
-;;;;;; 42953))
+;;;### (autoloads (solitaire) "solitaire" "play/solitaire.el" (20229
+;;;;;; 34587))
;;; 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" (19714 43298))
+;;;;;; sort-lines sort-subr) "sort" "sort.el" (20229 34587))
;;; Generated autoloads from sort.el
(put 'sort-fold-case 'safe-local-variable 'booleanp)
;;;***
\f
-;;;### (autoloads (spam-initialize) "spam" "gnus/spam.el" (19714
-;;;;;; 43298))
+;;;### (autoloads (spam-initialize) "spam" "gnus/spam.el" (20229
+;;;;;; 34587))
;;; 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" (19640 47194))
+;;;;;; "gnus/spam-report.el" (20229 34587))
;;; 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" (19714 43298))
+;;;;;; "speedbar.el" (20229 34587))
;;; Generated autoloads from speedbar.el
(defalias 'speedbar 'speedbar-frame-mode)
;;;***
\f
-;;;### (autoloads (spell-string spell-region spell-word spell-buffer)
-;;;;;; "spell" "textmodes/spell.el" (19619 52030))
-;;; Generated autoloads from textmodes/spell.el
-
-(put 'spell-filter 'risky-local-variable t)
-
-(autoload 'spell-buffer "spell" "\
-Check spelling of every word in the buffer.
-For each incorrect word, you are asked for the correct spelling
-and then put into a query-replace to fix some or all occurrences.
-If you do not want to change a word, just give the same word
-as its \"correct\" spelling; then the query replace is skipped.
-
-\(fn)" t nil)
-
-(make-obsolete 'spell-buffer 'ispell-buffer "23.1")
-
-(autoload 'spell-word "spell" "\
-Check spelling of word at or before point.
-If it is not correct, ask user for the correct spelling
-and `query-replace' the entire buffer to substitute it.
-
-\(fn)" t nil)
-
-(make-obsolete 'spell-word 'ispell-word "23.1")
-
-(autoload 'spell-region "spell" "\
-Like `spell-buffer' but applies only to region.
-Used in a program, applies from START to END.
-DESCRIPTION is an optional string naming the unit being checked:
-for example, \"word\".
-
-\(fn START END &optional DESCRIPTION)" t nil)
-
-(make-obsolete 'spell-region 'ispell-region "23.1")
-
-(autoload 'spell-string "spell" "\
-Check spelling of string supplied as argument.
-
-\(fn STRING)" t nil)
-
-(make-obsolete 'spell-string "The `spell' package is obsolete - use `ispell'." "23.1")
-
-;;;***
-\f
-;;;### (autoloads (snarf-spooks spook) "spook" "play/spook.el" (19562
-;;;;;; 42953))
+;;;### (autoloads (snarf-spooks spook) "spook" "play/spook.el" (20229
+;;;;;; 34587))
;;; 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"
-;;;;;; (19714 43298))
+;;;;;; (20303 23227))
;;; Generated autoloads from progmodes/sql.el
(autoload 'sql-add-product-keywords "sql" "\
The user will not be prompted for any login parameters if a value
is specified in the connection settings.
-\(fn CONNECTION)" t nil)
+\(fn CONNECTION &optional NEW-NAME)" t nil)
(autoload 'sql-product-interactive "sql" "\
Run PRODUCT interpreter as an inferior process.
;;;***
\f
;;;### (autoloads (srecode-template-mode) "srecode/srt-mode" "cedet/srecode/srt-mode.el"
-;;;;;; (19562 42953))
+;;;;;; (20229 34587))
;;; Generated autoloads from cedet/srecode/srt-mode.el
(autoload 'srecode-template-mode "srecode/srt-mode" "\
;;;***
\f
;;;### (autoloads (starttls-open-stream) "starttls" "gnus/starttls.el"
-;;;;;; (19619 52030))
+;;;;;; (20229 34587))
;;; 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" (19562
-;;;;;; 42953))
+;;;;;; strokes-global-set-stroke) "strokes" "strokes.el" (20229
+;;;;;; 34587))
;;; 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" (19562 42953))
+;;;;;; "studly" "play/studly.el" (19845 45374))
;;; Generated autoloads from play/studly.el
(autoload 'studlify-region "studly" "\
;;;***
\f
;;;### (autoloads (global-subword-mode subword-mode) "subword" "progmodes/subword.el"
-;;;;;; (19562 42953))
+;;;;;; (20229 34587))
;;; 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"
-;;;;;; (19562 42953))
+;;;;;; (20273 55692))
;;; Generated autoloads from mail/supercite.el
(autoload 'sc-cite-original "supercite" "\
;;;***
\f
-;;;### (autoloads (gpm-mouse-mode) "t-mouse" "t-mouse.el" (19562
-;;;;;; 42953))
+;;;### (autoloads (gpm-mouse-mode) "t-mouse" "t-mouse.el" (20229
+;;;;;; 34587))
;;; 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" (19598 13691))
+;;;### (autoloads (tabify untabify) "tabify" "tabify.el" (20229 34587))
;;; 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" (19714 43298))
+;;;;;; "table" "textmodes/table.el" (20229 34587))
;;; Generated autoloads from textmodes/table.el
(defvar table-cell-map-hook nil "\
\(fn &optional ARG)" t nil)
(autoload 'table-unrecognize "table" "\
-Not documented
+
\(fn)" t nil)
\(fn BEG END &optional ARG)" t nil)
(autoload 'table-unrecognize-region "table" "\
-Not documented
+
\(fn BEG END)" t nil)
\(fn &optional ARG)" t nil)
(autoload 'table-unrecognize-table "table" "\
-Not documented
+
\(fn)" t nil)
\(fn &optional FORCE NO-COPY ARG)" t nil)
(autoload 'table-unrecognize-cell "table" "\
-Not documented
+
\(fn)" t 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 (talk talk-connect) "talk" "talk.el" (19562 42953))
+;;;### (autoloads (tabulated-list-mode) "tabulated-list" "emacs-lisp/tabulated-list.el"
+;;;;;; (20257 13883))
+;;; 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 labeled 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" (20229 34587))
;;; Generated autoloads from talk.el
(autoload 'talk-connect "talk" "\
;;;***
\f
-;;;### (autoloads (tar-mode) "tar-mode" "tar-mode.el" (19619 52030))
+;;;### (autoloads (tar-mode) "tar-mode" "tar-mode.el" (20273 55692))
;;; 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" (19714 43298))
+;;;;;; "progmodes/tcl.el" (20229 34587))
;;; Generated autoloads from progmodes/tcl.el
(autoload 'tcl-mode "tcl" "\
;;;***
\f
-;;;### (autoloads (rsh telnet) "telnet" "net/telnet.el" (19640 47194))
+;;;### (autoloads (rsh telnet) "telnet" "net/telnet.el" (20229 34587))
;;; 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"
-;;;;;; (19714 43298))
+;;;;;; (20256 47696))
;;; Generated autoloads from term.el
(autoload 'make-term "term" "\
;;;***
\f
-;;;### (autoloads (terminal-emulator) "terminal" "terminal.el" (19591
-;;;;;; 62571))
+;;;### (autoloads (terminal-emulator) "terminal" "terminal.el" (20229
+;;;;;; 34587))
;;; Generated autoloads from terminal.el
(autoload 'terminal-emulator "terminal" "\
;;;***
\f
;;;### (autoloads (testcover-this-defun) "testcover" "emacs-lisp/testcover.el"
-;;;;;; (19591 62571))
+;;;;;; (20229 34587))
;;; Generated autoloads from emacs-lisp/testcover.el
(autoload 'testcover-this-defun "testcover" "\
;;;***
\f
-;;;### (autoloads (tetris) "tetris" "play/tetris.el" (19562 42953))
+;;;### (autoloads (tetris) "tetris" "play/tetris.el" (20229 34587))
;;; 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"
-;;;;;; (19714 43298))
+;;;;;; (20229 34587))
;;; Generated autoloads from textmodes/tex-mode.el
(defvar tex-shell-file-name nil "\
\(fn)" t nil)
(autoload 'tex-start-shell "tex-mode" "\
-Not documented
+
\(fn)" nil nil)
;;;***
\f
;;;### (autoloads (texi2info texinfo-format-region texinfo-format-buffer)
-;;;;;; "texinfmt" "textmodes/texinfmt.el" (19714 43298))
+;;;;;; "texinfmt" "textmodes/texinfmt.el" (20229 34587))
;;; 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" (19714 43298))
+;;;;;; "texinfo" "textmodes/texinfo.el" (20229 34587))
;;; 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"
-;;;;;; (19562 42953))
+;;;;;; (20273 55692))
;;; Generated autoloads from language/thai-util.el
(autoload 'thai-compose-region "thai-util" "\
\(fn)" t nil)
(autoload 'thai-composition-function "thai-util" "\
-Not documented
+
\(fn GSTRING)" nil nil)
\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" (19562 42953))
+;;;;;; "thingatpt" "thingatpt.el" (20229 34587))
;;; Generated autoloads from thingatpt.el
(autoload 'forward-thing "thingatpt" "\
Move forward to the end of the Nth next THING.
+THING should be a symbol specifying a type of syntactic entity.
+Possibilities include `symbol', `list', `sexp', `defun',
+`filename', `url', `email', `word', `sentence', `whitespace',
+`line', and `page'.
\(fn THING &optional N)" nil nil)
(autoload 'bounds-of-thing-at-point "thingatpt" "\
Determine the start and end buffer locations for the THING at point.
-THING is a symbol which specifies the kind of syntactic entity you want.
-Possibilities include `symbol', `list', `sexp', `defun', `filename', `url',
-`email', `word', `sentence', `whitespace', `line', `page' and others.
+THING should be a symbol specifying a type of syntactic entity.
+Possibilities include `symbol', `list', `sexp', `defun',
+`filename', `url', `email', `word', `sentence', `whitespace',
+`line', and `page'.
-See the file `thingatpt.el' for documentation on how to define
-a symbol as a valid THING.
+See the file `thingatpt.el' for documentation on how to define a
+valid THING.
-The value is a cons cell (START . END) giving the start and end positions
-of the textual entity that was found.
+Return a cons cell (START . END) giving the start and end
+positions of the thing found.
\(fn THING)" nil nil)
(autoload 'thing-at-point "thingatpt" "\
Return the THING at point.
-THING is a symbol which specifies the kind of syntactic entity you want.
-Possibilities include `symbol', `list', `sexp', `defun', `filename', `url',
-`email', `word', `sentence', `whitespace', `line', `page' and others.
+THING should be a symbol specifying a type of syntactic entity.
+Possibilities include `symbol', `list', `sexp', `defun',
+`filename', `url', `email', `word', `sentence', `whitespace',
+`line', and `page'.
See the file `thingatpt.el' for documentation on how to define
a symbol as a valid THING.
\f
;;;### (autoloads (thumbs-dired-setroot thumbs-dired-show thumbs-dired-show-marked
;;;;;; thumbs-show-from-dir thumbs-find-thumb) "thumbs" "thumbs.el"
-;;;;;; (19562 42953))
+;;;;;; (20229 34587))
;;; 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" (19562
-;;;;;; 42953))
+;;;;;; tibetan-char-p) "tibet-util" "language/tibet-util.el" (20229
+;;;;;; 34587))
;;; Generated autoloads from language/tibet-util.el
(autoload 'tibetan-char-p "tibet-util" "\
\(fn)" t nil)
(autoload 'tibetan-post-read-conversion "tibet-util" "\
-Not documented
+
\(fn LEN)" nil nil)
(autoload 'tibetan-pre-write-conversion "tibet-util" "\
-Not documented
+
\(fn FROM TO)" nil nil)
(autoload 'tibetan-pre-write-canonicalize-for-unicode "tibet-util" "\
-Not documented
+
\(fn FROM TO)" nil nil)
;;;***
\f
;;;### (autoloads (tildify-buffer tildify-region) "tildify" "textmodes/tildify.el"
-;;;;;; (19562 42953))
+;;;;;; (20229 34587))
;;; 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" (19640 47194))
+;;;;;; "time" "time.el" (20230 55355))
;;; 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.
-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"
-;;;;;; (19714 43298))
+;;;;;; (20229 34587))
;;; 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" (19562 42953))
+;;;;;; "time-stamp.el" (20229 34587))
;;; 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)
;;;;;; 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"
-;;;;;; (19714 43298))
+;;;;;; (20300 47034))
;;; Generated autoloads from calendar/timeclock.el
(autoload 'timeclock-modeline-display "timeclock" "\
;;;***
\f
;;;### (autoloads (batch-titdic-convert titdic-convert) "titdic-cnv"
-;;;;;; "international/titdic-cnv.el" (19640 47194))
+;;;;;; "international/titdic-cnv.el" (20287 35000))
;;; Generated autoloads from international/titdic-cnv.el
(autoload 'titdic-convert "titdic-cnv" "\
;;;***
\f
;;;### (autoloads (tmm-prompt tmm-menubar-mouse tmm-menubar) "tmm"
-;;;;;; "tmm.el" (19562 42953))
+;;;;;; "tmm.el" (20229 34587))
;;; 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" (19562 42953))
+;;;;;; "todo-mode" "calendar/todo-mode.el" (20229 34587))
;;; 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" (19714 43298))
+;;;;;; "tool-bar" "tool-bar.el" (20279 40897))
;;; 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"
-;;;;;; (19714 43298))
+;;;;;; (20300 47034))
;;; 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"
-;;;;;; (19598 13691))
+;;;;;; (20229 34587))
;;; Generated autoloads from emulation/tpu-mapper.el
(autoload 'tpu-mapper "tpu-mapper" "\
;;;***
\f
-;;;### (autoloads (tq-create) "tq" "emacs-lisp/tq.el" (19562 42953))
+;;;### (autoloads (tq-create) "tq" "emacs-lisp/tq.el" (20229 34587))
;;; 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" (19591 62571))
+;;;;;; "trace" "emacs-lisp/trace.el" (20229 34587))
;;; 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" (19714 43298))
+;;;;;; "net/tramp.el" (20300 47034))
;;; Generated autoloads from net/tramp.el
(defvar tramp-mode t "\
Also see `tramp-file-name-structure'.")
-(defconst tramp-root-regexp (if (memq system-type '(cygwin windows-nt)) "\\`\\([a-zA-Z]:\\)?/" "\\`/") "\
-Beginning of an incomplete Tramp file name.
-Usually, it is just \"\\\\`/\". On W32 systems, there might be a
-volume letter, which will be removed by `tramp-drop-volume-letter'.")
-
-(defconst tramp-completion-file-name-regexp-unified (if (memq system-type '(cygwin windows-nt)) (concat tramp-root-regexp "[^/]\\{2,\\}\\'") (concat tramp-root-regexp "[^/]*\\'")) "\
+(defconst tramp-completion-file-name-regexp-unified (if (memq system-type '(cygwin windows-nt)) "\\`/[^/]\\{2,\\}\\'" "\\`/[^/]*\\'") "\
Value for `tramp-completion-file-name-regexp' for unified remoting.
GNU Emacs uses a unified filename syntax for Tramp and Ange-FTP.
See `tramp-file-name-structure' for more explanations.
On W32 systems, the volume letter must be ignored.")
-(defconst tramp-completion-file-name-regexp-separate (concat tramp-root-regexp "\\([[][^]]*\\)?\\'") "\
+(defconst tramp-completion-file-name-regexp-separate "\\`/\\([[][^]]*\\)?\\'" "\
Value for `tramp-completion-file-name-regexp' for separate remoting.
XEmacs uses a separate filename syntax for Tramp and EFS.
See `tramp-file-name-structure' for more explanations.")
-(defconst tramp-completion-file-name-regexp-url (concat tramp-root-regexp "[^/:]+\\(:\\(/\\(/[^/]*\\)?\\)?\\)?\\'") "\
+(defconst tramp-completion-file-name-regexp-url "\\`/[^/:]+\\(:\\(/\\(/[^/]*\\)?\\)?\\)?\\'" "\
Value for `tramp-completion-file-name-regexp' for URL-like remoting.
See `tramp-file-name-structure' for more explanations.")
(tramp-register-file-name-handlers)
(autoload 'tramp-unload-file-name-handlers "tramp" "\
-Not documented
+
\(fn)" nil nil)
;;;***
\f
;;;### (autoloads (tramp-ftp-enable-ange-ftp) "tramp-ftp" "net/tramp-ftp.el"
-;;;;;; (19714 43298))
+;;;;;; (20229 34587))
;;; Generated autoloads from net/tramp-ftp.el
(autoload 'tramp-ftp-enable-ange-ftp "tramp-ftp" "\
-Not documented
+
\(fn)" nil nil)
;;;***
\f
-;;;### (autoloads (help-with-tutorial) "tutorial" "tutorial.el" (19598
-;;;;;; 13691))
+;;;### (autoloads (help-with-tutorial) "tutorial" "tutorial.el" (20229
+;;;;;; 34587))
;;; Generated autoloads from tutorial.el
(autoload 'help-with-tutorial "tutorial" "\
;;;***
\f
;;;### (autoloads (tai-viet-composition-function) "tv-util" "language/tv-util.el"
-;;;;;; (19562 42953))
+;;;;;; (19845 45374))
;;; Generated autoloads from language/tv-util.el
(autoload 'tai-viet-composition-function "tv-util" "\
-Not documented
+
\(fn FROM TO FONT-OBJECT STRING)" nil nil)
;;;***
\f
;;;### (autoloads (2C-split 2C-associate-buffer 2C-two-columns) "two-column"
-;;;;;; "textmodes/two-column.el" (19619 52030))
+;;;;;; "textmodes/two-column.el" (20229 34587))
;;; 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"
-;;;;;; (19714 43298))
+;;;;;; (20229 34587))
;;; Generated autoloads from type-break.el
(defvar type-break-mode nil "\
;;;***
\f
-;;;### (autoloads (uce-reply-to-uce) "uce" "mail/uce.el" (19562 42953))
+;;;### (autoloads (uce-reply-to-uce) "uce" "mail/uce.el" (20229 34587))
;;; 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" (19619 52030))
+;;;;;; "international/ucs-normalize.el" (20229 34587))
;;; Generated autoloads from international/ucs-normalize.el
(autoload 'ucs-normalize-NFD-region "ucs-normalize" "\
;;;***
\f
;;;### (autoloads (ununderline-region underline-region) "underline"
-;;;;;; "textmodes/underline.el" (19562 42953))
+;;;;;; "textmodes/underline.el" (20229 34587))
;;; Generated autoloads from textmodes/underline.el
(autoload 'underline-region "underline" "\
;;;***
\f
;;;### (autoloads (unrmail batch-unrmail) "unrmail" "mail/unrmail.el"
-;;;;;; (19562 42953))
+;;;;;; (20235 41048))
;;; Generated autoloads from mail/unrmail.el
(autoload 'batch-unrmail "unrmail" "\
;;;***
\f
-;;;### (autoloads (unsafep) "unsafep" "emacs-lisp/unsafep.el" (19714
-;;;;;; 43298))
+;;;### (autoloads (unsafep) "unsafep" "emacs-lisp/unsafep.el" (20229
+;;;;;; 34587))
;;; Generated autoloads from emacs-lisp/unsafep.el
(autoload 'unsafep "unsafep" "\
;;;***
\f
;;;### (autoloads (url-retrieve-synchronously url-retrieve) "url"
-;;;;;; "url/url.el" (19640 47194))
+;;;;;; "url/url.el" (20290 11197))
;;; Generated autoloads from url/url.el
(autoload 'url-retrieve "url" "\
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.
-\(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" (19562 42953))
+;;;;;; "url-auth" "url/url-auth.el" (20238 49468))
;;; 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" (19640 47194))
+;;;;;; "url-cache" "url/url-cache.el" (20273 2111))
;;; Generated autoloads from url/url-cache.el
(autoload 'url-store-in-cache "url-cache" "\
;;;***
\f
-;;;### (autoloads (url-cid) "url-cid" "url/url-cid.el" (19562 42953))
+;;;### (autoloads (url-cid) "url-cid" "url/url-cid.el" (20229 34587))
;;; Generated autoloads from url/url-cid.el
(autoload 'url-cid "url-cid" "\
-Not documented
+
\(fn URL)" nil nil)
;;;***
\f
;;;### (autoloads (url-dav-vc-registered url-dav-supported-p) "url-dav"
-;;;;;; "url/url-dav.el" (19591 62571))
+;;;;;; "url/url-dav.el" (20229 34587))
;;; Generated autoloads from url/url-dav.el
(autoload 'url-dav-supported-p "url-dav" "\
-Not documented
+
\(fn URL)" nil nil)
(autoload 'url-dav-vc-registered "url-dav" "\
-Not documented
+
\(fn URL)" nil nil)
;;;***
\f
-;;;### (autoloads (url-file) "url-file" "url/url-file.el" (19714
-;;;;;; 43298))
+;;;### (autoloads (url-file) "url-file" "url/url-file.el" (20229
+;;;;;; 34587))
;;; 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" (19640 47194))
+;;;;;; "url/url-gw.el" (20229 34587))
;;; 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"
-;;;;;; (19591 62571))
+;;;;;; (20229 34587))
;;; 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)
\(fn URL &rest IGNORED)" nil nil)
(autoload 'url-insert-file-contents "url-handlers" "\
-Not documented
+
\(fn URL &optional VISIT BEG END REPLACE)" nil nil)
;;;***
\f
;;;### (autoloads (url-http-options url-http-file-attributes url-http-file-exists-p
-;;;;;; url-http) "url-http" "url/url-http.el" (19640 47194))
+;;;;;; url-http) "url-http" "url/url-http.el" (20277 28925))
;;; Generated autoloads from url/url-http.el
(autoload 'url-http "url-http" "\
\(fn URL CALLBACK CBARGS)" nil nil)
(autoload 'url-http-file-exists-p "url-http" "\
-Not documented
+
\(fn URL)" nil nil)
(defalias 'url-http-file-readable-p 'url-http-file-exists-p)
(autoload 'url-http-file-attributes "url-http" "\
-Not documented
+
\(fn URL &optional ID-FORMAT)" nil nil)
;;;***
\f
-;;;### (autoloads (url-irc) "url-irc" "url/url-irc.el" (19598 13691))
+;;;### (autoloads (url-irc) "url-irc" "url/url-irc.el" (20229 34587))
;;; Generated autoloads from url/url-irc.el
(autoload 'url-irc "url-irc" "\
-Not documented
+
\(fn URL)" nil nil)
;;;***
\f
-;;;### (autoloads (url-ldap) "url-ldap" "url/url-ldap.el" (19562
-;;;;;; 42953))
+;;;### (autoloads (url-ldap) "url-ldap" "url/url-ldap.el" (20229
+;;;;;; 34587))
;;; Generated autoloads from url/url-ldap.el
(autoload 'url-ldap "url-ldap" "\
;;;***
\f
;;;### (autoloads (url-mailto url-mail) "url-mailto" "url/url-mailto.el"
-;;;;;; (19562 42953))
+;;;;;; (20229 34587))
;;; Generated autoloads from url/url-mailto.el
(autoload 'url-mail "url-mailto" "\
-Not documented
+
\(fn &rest ARGS)" t nil)
;;;***
\f
;;;### (autoloads (url-data url-generic-emulator-loader url-info
-;;;;;; url-man) "url-misc" "url/url-misc.el" (19562 42953))
+;;;;;; url-man) "url-misc" "url/url-misc.el" (20229 34587))
;;; Generated autoloads from url/url-misc.el
(autoload 'url-man "url-misc" "\
\(fn URL)" nil nil)
(autoload 'url-generic-emulator-loader "url-misc" "\
-Not documented
+
\(fn URL)" nil nil)
;;;***
\f
;;;### (autoloads (url-snews url-news) "url-news" "url/url-news.el"
-;;;;;; (19562 42953))
+;;;;;; (20229 34587))
;;; Generated autoloads from url/url-news.el
(autoload 'url-news "url-news" "\
-Not documented
+
\(fn URL)" nil nil)
(autoload 'url-snews "url-news" "\
-Not documented
+
\(fn URL)" nil nil)
\f
;;;### (autoloads (url-ns-user-pref url-ns-prefs isInNet isResolvable
;;;;;; dnsResolve dnsDomainIs isPlainHostName) "url-ns" "url/url-ns.el"
-;;;;;; (19562 42953))
+;;;;;; (20229 34587))
;;; Generated autoloads from url/url-ns.el
(autoload 'isPlainHostName "url-ns" "\
-Not documented
+
\(fn HOST)" nil nil)
(autoload 'dnsDomainIs "url-ns" "\
-Not documented
+
\(fn HOST DOM)" nil nil)
(autoload 'dnsResolve "url-ns" "\
-Not documented
+
\(fn HOST)" nil nil)
(autoload 'isResolvable "url-ns" "\
-Not documented
+
\(fn HOST)" nil nil)
(autoload 'isInNet "url-ns" "\
-Not documented
+
\(fn IP NET MASK)" nil nil)
(autoload 'url-ns-prefs "url-ns" "\
-Not documented
+
\(fn &optional FILE)" nil nil)
(autoload 'url-ns-user-pref "url-ns" "\
-Not documented
+
\(fn KEY &optional DEFAULT)" nil nil)
;;;***
\f
;;;### (autoloads (url-generic-parse-url url-recreate-url) "url-parse"
-;;;;;; "url/url-parse.el" (19640 47194))
+;;;;;; "url/url-parse.el" (20273 55604))
;;; Generated autoloads from url/url-parse.el
(autoload 'url-recreate-url "url-parse" "\
;;;***
\f
;;;### (autoloads (url-setup-privacy-info) "url-privacy" "url/url-privacy.el"
-;;;;;; (19562 42953))
+;;;;;; (20229 34587))
;;; 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"
+;;;;;; (20291 32066))
+;;; Generated autoloads from url/url-queue.el
+
+(autoload 'url-queue-retrieve "url-queue" "\
+Retrieve URL asynchronously and call CALLBACK with CBARGS when finished.
+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 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" (19640 47194))
+;;;;;; "url-util" "url/url-util.el" (20229 34587))
;;; Generated autoloads from url/url-util.el
(defvar url-debug nil "\
(custom-autoload 'url-debug "url-util" t)
(autoload 'url-debug "url-util" "\
-Not documented
+
\(fn TAG &rest ARGS)" nil nil)
(autoload 'url-parse-args "url-util" "\
-Not documented
+
\(fn STR &optional NODOWNCASE)" nil nil)
\(fn X)" nil nil)
(autoload 'url-pretty-length "url-util" "\
-Not documented
+
\(fn N)" nil nil)
(autoload 'url-display-percentage "url-util" "\
-Not documented
+
\(fn FMT PERC &rest ARGS)" nil nil)
(autoload 'url-percentage "url-util" "\
-Not documented
+
\(fn X Y)" nil nil)
\(fn FILE)" nil nil)
(autoload 'url-parse-query-string "url-util" "\
-Not documented
+
\(fn QUERY &optional DOWNCASE ALLOW-NEWLINES)" nil nil)
;;;***
\f
;;;### (autoloads (ask-user-about-supersession-threat ask-user-about-lock)
-;;;;;; "userlock" "userlock.el" (19562 42953))
+;;;;;; "userlock" "userlock.el" (20229 34587))
;;; 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" (19562 42953))
+;;;;;; "utf-7" "international/utf-7.el" (20229 34587))
;;; Generated autoloads from international/utf-7.el
(autoload 'utf-7-post-read-conversion "utf-7" "\
-Not documented
+
\(fn LEN)" nil nil)
(autoload 'utf-7-imap-post-read-conversion "utf-7" "\
-Not documented
+
\(fn LEN)" nil nil)
(autoload 'utf-7-pre-write-conversion "utf-7" "\
-Not documented
+
\(fn FROM TO)" nil nil)
(autoload 'utf-7-imap-pre-write-conversion "utf-7" "\
-Not documented
+
\(fn FROM TO)" nil nil)
;;;***
\f
-;;;### (autoloads (utf7-encode) "utf7" "gnus/utf7.el" (19619 52030))
+;;;### (autoloads (utf7-encode) "utf7" "gnus/utf7.el" (20229 34587))
;;; 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"
-;;;;;; (19598 13691))
+;;;;;; (20229 34587))
;;; Generated autoloads from mail/uudecode.el
(autoload 'uudecode-decode-region-external "uudecode" "\
;;;***
\f
;;;### (autoloads (vc-branch-part vc-update-change-log vc-rename-file
-;;;;;; vc-delete-file vc-transfer-file vc-switch-backend vc-update
+;;;;;; vc-delete-file vc-transfer-file vc-switch-backend vc-pull
;;;;;; vc-rollback vc-revert vc-log-outgoing vc-log-incoming vc-print-root-log
;;;;;; vc-print-log vc-retrieve-tag vc-create-tag vc-merge vc-insert-headers
-;;;;;; vc-revision-other-window vc-root-diff vc-diff vc-version-diff
-;;;;;; vc-register vc-next-action vc-before-checkin-hook vc-checkin-hook
-;;;;;; vc-checkout-hook) "vc" "vc/vc.el" (19714 43298))
+;;;;;; 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" (20275
+;;;;;; 43867))
;;; 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)
\(fn HISTORIC &optional NOT-URGENT)" t nil)
+(autoload 'vc-version-ediff "vc" "\
+Show differences between revisions of the fileset in the
+repository history using ediff.
+
+\(fn FILES REV1 REV2)" t nil)
+
+(autoload 'vc-ediff "vc" "\
+Display diffs between file revisions using ediff.
+Normally this compares the currently selected fileset with their
+working revisions. With a prefix argument HISTORIC, it reads two revision
+designators specifying which revisions to compare.
+
+The optional argument NOT-URGENT non-nil means it is ok to say no to
+saving the buffer.
+
+\(fn HISTORIC &optional NOT-URGENT)" t nil)
+
(autoload 'vc-root-diff "vc" "\
Display diffs between VC-controlled whole tree revisions.
Normally, this compares the tree corresponding to the current
(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.
(define-obsolete-function-alias 'vc-revert-buffer 'vc-revert "23.1")
-(autoload 'vc-update "vc" "\
+(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.
\(fn &optional ARG)" t nil)
-(defalias 'vc-pull 'vc-update)
+(defalias 'vc-update 'vc-pull)
(autoload 'vc-switch-backend "vc" "\
Make BACKEND the current version control system for FILE.
;;;***
\f
;;;### (autoloads (vc-annotate) "vc-annotate" "vc/vc-annotate.el"
-;;;;;; (19598 13691))
+;;;;;; (20229 34587))
;;; Generated autoloads from vc/vc-annotate.el
(autoload 'vc-annotate "vc-annotate" "\
;;;***
\f
-;;;### (autoloads nil "vc-arch" "vc/vc-arch.el" (19714 43298))
+;;;### (autoloads nil "vc-arch" "vc/vc-arch.el" (20296 49978))
;;; 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" (19717 39999))
+;;;### (autoloads nil "vc-bzr" "vc/vc-bzr.el" (20300 47034))
;;; 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" (19714 43298))
+;;;### (autoloads nil "vc-cvs" "vc/vc-cvs.el" (20296 49978))
;;; 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" (19714 43298))
+;;;### (autoloads (vc-dir) "vc-dir" "vc/vc-dir.el" (20229 34587))
;;; Generated autoloads from vc/vc-dir.el
(autoload 'vc-dir "vc-dir" "\
;;;***
\f
;;;### (autoloads (vc-do-command) "vc-dispatcher" "vc/vc-dispatcher.el"
-;;;;;; (19598 13691))
+;;;;;; (20229 34587))
;;; Generated autoloads from vc/vc-dispatcher.el
(autoload 'vc-do-command "vc-dispatcher" "\
;;;***
\f
-;;;### (autoloads nil "vc-git" "vc/vc-git.el" (19598 13691))
+;;;### (autoloads nil "vc-git" "vc/vc-git.el" (20303 23227))
;;; 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" (19714 43298))
+;;;### (autoloads nil "vc-hg" "vc/vc-hg.el" (20296 49978))
;;; 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" (19714 43298))
+;;;### (autoloads nil "vc-mtn" "vc/vc-mtn.el" (20296 49978))
;;; 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"
-;;;;;; (19714 43298))
+;;;;;; (20296 49978))
;;; 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"
-;;;;;; (19714 43298))
+;;;;;; (20296 49978))
;;; 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" (19640 47194))
+;;;### (autoloads nil "vc-svn" "vc/vc-svn.el" (20296 49978))
;;; Generated autoloads from vc/vc-svn.el
(defun vc-svn-registered (f)
(let ((admin-dir (cond ((and (eq system-type 'windows-nt)
(getenv "SVN_ASP_DOT_NET_HACK"))
"_svn")
(t ".svn"))))
- (when (file-readable-p (expand-file-name
- (concat admin-dir "/entries")
- (file-name-directory f)))
+ (when (vc-find-root f admin-dir)
(load "vc-svn")
(vc-svn-registered f))))
;;;***
\f
;;;### (autoloads (vera-mode) "vera-mode" "progmodes/vera-mode.el"
-;;;;;; (19714 43298))
+;;;;;; (20229 34587))
;;; 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"
-;;;;;; (19714 43298))
+;;;;;; (20279 40897))
;;; 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"
-;;;;;; (19714 43298))
+;;;;;; (20300 47034))
;;; Generated autoloads from progmodes/vhdl-mode.el
(autoload 'vhdl-mode "vhdl-mode" "\
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:
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
;;;***
\f
-;;;### (autoloads (vi-mode) "vi" "emulation/vi.el" (19562 42953))
+;;;### (autoloads (vi-mode) "vi" "emulation/vi.el" (20104 14925))
;;; 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" (19562 42953))
+;;;;;; "language/viet-util.el" (20229 34587))
;;; Generated autoloads from language/viet-util.el
(autoload 'viet-encode-viscii-char "viet-util" "\
\(fn)" t nil)
(autoload 'viqr-post-read-conversion "viet-util" "\
-Not documented
+
\(fn LEN)" nil nil)
(autoload 'viqr-pre-write-conversion "viet-util" "\
-Not documented
+
\(fn FROM TO)" nil nil)
;;;;;; 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" (19562 42953))
+;;;;;; "view" "view.el" (20265 7997))
;;; Generated autoloads from view.el
(defvar view-remove-frame-by-deleting t "\
(autoload 'view-buffer-other-window "view" "\
View BUFFER in View mode in another window.
-Return to previous buffer when done, unless optional NOT-RETURN is
-non-nil. Emacs commands editing the buffer contents are not available;
-instead, a special set of commands (mostly letters and punctuation) are
-defined for moving around in the buffer.
+Emacs commands editing the buffer contents are not available;
+instead, a special set of commands (mostly letters and
+punctuation) are defined for moving around in the buffer.
Space scrolls forward, Delete scrolls backward.
For a list of all View commands, type H or h while viewing.
This command runs the normal hook `view-mode-hook'.
+Optional argument NOT-RETURN is ignored.
+
Optional argument EXIT-ACTION is either nil or a function with buffer as
argument. This function is called when finished viewing buffer. Use
this argument instead of explicitly setting `view-exit-action'.
(autoload 'view-buffer-other-frame "view" "\
View BUFFER in View mode in another frame.
-Return to previous buffer when done, unless optional NOT-RETURN is
-non-nil. Emacs commands editing the buffer contents are not available;
-instead, a special set of commands (mostly letters and punctuation) are
-defined for moving around in the buffer.
+Emacs commands editing the buffer contents are not available;
+instead, a special set of commands (mostly letters and
+punctuation) are defined for moving around in the buffer.
Space scrolls forward, Delete scrolls backward.
For a list of all View commands, type H or h while viewing.
This command runs the normal hook `view-mode-hook'.
+Optional argument NOT-RETURN is ignored.
+
Optional argument EXIT-ACTION is either nil or a function with buffer as
argument. This function is called when finished viewing buffer. Use
this argument instead of explicitly setting `view-exit-action'.
(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
(autoload 'view-mode-enter "view" "\
Enter View mode and set up exit from view mode depending on optional arguments.
-RETURN-TO non-nil means add RETURN-TO as an element to the buffer
-local alist `view-return-to-alist'. Save EXIT-ACTION in buffer
-local variable `view-exit-action'. It should be either nil or a
+Optional argument QUIT-RESTORE if non-nil must specify a valid
+entry for quitting and restoring any window showing the current
+buffer. This entry replaces any parameter installed by
+`display-buffer' and is used by `view-mode-exit'.
+
+Optional argument EXIT-ACTION, if non-nil, must specify a
function that takes a buffer as argument. This function will be
called by `view-mode-exit'.
-RETURN-TO is either nil, meaning do nothing when exiting view
-mode, or must have the format (WINDOW OLD-WINDOW . OLD-BUF-INFO).
-WINDOW is the window used for viewing. OLD-WINDOW is nil or the
-window to select after viewing. OLD-BUF-INFO tells what to do
-with WINDOW when exiting. It is one of:
-1) nil Do nothing.
-2) t Delete WINDOW or, if it is the only window and
- `view-remove-frame-by-deleting' is non-nil, its
- frame.
-3) (OLD-BUFF START POINT) Display buffer OLD-BUFF with displayed text
- starting at START and point at POINT in WINDOW.
-4) quit-window Do `quit-window' in WINDOW.
-5) keep-frame Like case 2) but do not delete the frame.
-
For a list of all View commands, type H or h while viewing.
This function runs the normal hook `view-mode-hook'.
-\(fn &optional RETURN-TO EXIT-ACTION)" nil nil)
+\(fn &optional QUIT-RESTORE EXIT-ACTION)" nil nil)
(autoload 'View-exit-and-edit "view" "\
Exit View mode and make the current buffer editable.
;;;***
\f
-;;;### (autoloads (vip-mode vip-setup) "vip" "emulation/vip.el" (19619
-;;;;;; 52030))
+;;;### (autoloads (vip-mode vip-setup) "vip" "emulation/vip.el" (20229
+;;;;;; 34587))
;;; Generated autoloads from emulation/vip.el
(autoload 'vip-setup "vip" "\
;;;***
\f
;;;### (autoloads (viper-mode toggle-viper-mode) "viper" "emulation/viper.el"
-;;;;;; (19598 13691))
+;;;;;; (20300 47034))
;;; Generated autoloads from emulation/viper.el
(autoload 'toggle-viper-mode "viper" "\
;;;***
\f
;;;### (autoloads (warn lwarn display-warning) "warnings" "emacs-lisp/warnings.el"
-;;;;;; (19619 52030))
+;;;;;; (20229 34587))
;;; Generated autoloads from emacs-lisp/warnings.el
(defvar warning-prefix-function nil "\
A marker indicates a position in the warnings buffer
which is the start of the current series; it means that
additional warnings in the same buffer should not move point.
-t means the next warning begins a series (and stores a marker here).
+If t, the next warning begins a series (and stores a marker here).
A symbol with a function definition is like t, except
also call that function before the next warning.")
;;;***
\f
;;;### (autoloads (wdired-change-to-wdired-mode) "wdired" "wdired.el"
-;;;;;; (19562 42953))
+;;;;;; (20229 34587))
;;; Generated autoloads from wdired.el
(autoload 'wdired-change-to-wdired-mode "wdired" "\
;;;***
\f
-;;;### (autoloads (webjump) "webjump" "net/webjump.el" (19562 42953))
+;;;### (autoloads (webjump) "webjump" "net/webjump.el" (20229 34587))
;;; Generated autoloads from net/webjump.el
(autoload 'webjump "webjump" "\
;;;***
\f
-;;;### (autoloads (which-function-mode) "which-func" "progmodes/which-func.el"
-;;;;;; (19714 43298))
+;;;### (autoloads (which-function-mode which-func-mode) "which-func"
+;;;;;; "progmodes/which-func.el" (20232 10689))
;;; 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" (19714 43298))
+;;;;;; whitespace-mode) "whitespace" "whitespace.el" (20229 34587))
;;; 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" (19598 13691))
+;;;;;; widget-browse-at) "wid-browse" "wid-browse.el" (20273 55693))
;;; 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" (19714
-;;;;;; 43298))
+;;;;;; widget-prompt-value widgetp) "wid-edit" "wid-edit.el" (20271
+;;;;;; 46782))
;;; 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" (19562
-;;;;;; 42953))
+;;;;;; windmove-up windmove-left) "windmove" "windmove.el" (20250
+;;;;;; 40679))
;;; Generated autoloads from windmove.el
(autoload 'windmove-left "windmove" "\
;;;***
\f
;;;### (autoloads (winner-mode winner-mode) "winner" "winner.el"
-;;;;;; (19591 62571))
+;;;;;; (20237 28610))
;;; 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" (19714 43298))
+;;;;;; woman woman-locale) "woman" "woman.el" (20229 34587))
;;; Generated autoloads from woman.el
(defvar woman-locale nil "\
;;;***
\f
;;;### (autoloads (wordstar-mode) "ws-mode" "emulation/ws-mode.el"
-;;;;;; (19640 47194))
+;;;;;; (20229 34587))
;;; 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" (19562 42953))
+;;;### (autoloads (xesam-search) "xesam" "net/xesam.el" (20229 34587))
;;; Generated autoloads from net/xesam.el
(autoload 'xesam-search "xesam" "\
;;;***
\f
;;;### (autoloads (xml-parse-region xml-parse-file) "xml" "xml.el"
-;;;;;; (19591 62571))
+;;;;;; (20258 34747))
;;; Generated autoloads from xml.el
(autoload 'xml-parse-file "xml" "\
;;;***
\f
;;;### (autoloads (xmltok-get-declared-encoding-position) "xmltok"
-;;;;;; "nxml/xmltok.el" (19562 42953))
+;;;;;; "nxml/xmltok.el" (20229 34587))
;;; Generated autoloads from nxml/xmltok.el
(autoload 'xmltok-get-declared-encoding-position "xmltok" "\
;;;***
\f
-;;;### (autoloads (xterm-mouse-mode) "xt-mouse" "xt-mouse.el" (19562
-;;;;;; 42953))
+;;;### (autoloads (xterm-mouse-mode) "xt-mouse" "xt-mouse.el" (20229
+;;;;;; 34587))
;;; 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" (19598 13691))
+;;;;;; "gnus/yenc.el" (20229 34587))
;;; Generated autoloads from gnus/yenc.el
(autoload 'yenc-decode-region "yenc" "\
;;;***
\f
;;;### (autoloads (psychoanalyze-pinhead apropos-zippy insert-zippyism
-;;;;;; yow) "yow" "play/yow.el" (19562 42953))
+;;;;;; yow) "yow" "play/yow.el" (20229 34587))
;;; Generated autoloads from play/yow.el
(autoload 'yow "yow" "\
;;;***
\f
-;;;### (autoloads (zone) "zone" "play/zone.el" (19562 42953))
+;;;### (autoloads (zone) "zone" "play/zone.el" (20229 34587))
;;; Generated autoloads from play/zone.el
(autoload 'zone "zone" "\
;;;;;; "calc/calc-poly.el" "calc/calc-prog.el" "calc/calc-rewr.el"
;;;;;; "calc/calc-rules.el" "calc/calc-sel.el" "calc/calc-stat.el"
;;;;;; "calc/calc-store.el" "calc/calc-stuff.el" "calc/calc-trail.el"
-;;;;;; "calc/calc-undo.el" "calc/calc-units.el" "calc/calc-vec.el"
-;;;;;; "calc/calc-yank.el" "calc/calcalg2.el" "calc/calcalg3.el"
-;;;;;; "calc/calccomp.el" "calc/calcsel2.el" "calendar/cal-bahai.el"
-;;;;;; "calendar/cal-coptic.el" "calendar/cal-french.el" "calendar/cal-html.el"
-;;;;;; "calendar/cal-islam.el" "calendar/cal-iso.el" "calendar/cal-julian.el"
-;;;;;; "calendar/cal-loaddefs.el" "calendar/cal-mayan.el" "calendar/cal-menu.el"
-;;;;;; "calendar/cal-move.el" "calendar/cal-persia.el" "calendar/cal-tex.el"
-;;;;;; "calendar/cal-x.el" "calendar/diary-loaddefs.el" "calendar/hol-loaddefs.el"
-;;;;;; "cdl.el" "cedet/cedet-cscope.el" "cedet/cedet-files.el" "cedet/cedet-global.el"
+;;;;;; "calc/calc-units.el" "calc/calc-vec.el" "calc/calc-yank.el"
+;;;;;; "calc/calcalg2.el" "calc/calcalg3.el" "calc/calccomp.el"
+;;;;;; "calc/calcsel2.el" "calendar/cal-bahai.el" "calendar/cal-coptic.el"
+;;;;;; "calendar/cal-french.el" "calendar/cal-html.el" "calendar/cal-islam.el"
+;;;;;; "calendar/cal-iso.el" "calendar/cal-julian.el" "calendar/cal-loaddefs.el"
+;;;;;; "calendar/cal-mayan.el" "calendar/cal-menu.el" "calendar/cal-move.el"
+;;;;;; "calendar/cal-persia.el" "calendar/cal-tex.el" "calendar/cal-x.el"
+;;;;;; "calendar/diary-loaddefs.el" "calendar/hol-loaddefs.el" "cdl.el"
+;;;;;; "cedet/cedet-cscope.el" "cedet/cedet-files.el" "cedet/cedet-global.el"
;;;;;; "cedet/cedet-idutils.el" "cedet/cedet.el" "cedet/ede/auto.el"
;;;;;; "cedet/ede/autoconf-edit.el" "cedet/ede/base.el" "cedet/ede/cpp-root.el"
;;;;;; "cedet/ede/custom.el" "cedet/ede/dired.el" "cedet/ede/emacs.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"
;;;;;; "emacs-lisp/authors.el" "emacs-lisp/avl-tree.el" "emacs-lisp/bindat.el"
-;;;;;; "emacs-lisp/byte-lexbind.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-comp.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/sregex.el"
-;;;;;; "emacs-lisp/tcover-ses.el" "emacs-lisp/tcover-unsafep.el"
-;;;;;; "emacs-lock.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/auth-source.el"
-;;;;;; "gnus/color.el" "gnus/compface.el" "gnus/gnus-async.el" "gnus/gnus-bcklg.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/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/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/mml.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"
-;;;;;; "gnus/nnspool.el" "gnus/nntp.el" "gnus/nnvirtual.el" "gnus/nnweb.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" "gnus/nnspool.el"
+;;;;;; "gnus/nntp.el" "gnus/nnvirtual.el" "gnus/nnweb.el" "gnus/registry.el"
;;;;;; "gnus/rfc1843.el" "gnus/rfc2045.el" "gnus/rfc2047.el" "gnus/rfc2104.el"
;;;;;; "gnus/rfc2231.el" "gnus/rtree.el" "gnus/shr-color.el" "gnus/sieve-manage.el"
;;;;;; "gnus/smime.el" "gnus/spam-stat.el" "gnus/spam-wash.el" "hex-util.el"
-;;;;;; "hfy-cmap.el" "ibuf-ext.el" "international/charprop.el" "international/cp51932.el"
-;;;;;; "international/eucjp-ms.el" "international/fontset.el" "international/iso-ascii.el"
-;;;;;; "international/ja-dic-cnv.el" "international/ja-dic-utl.el"
-;;;;;; "international/ogonek.el" "international/uni-bidi.el" "international/uni-category.el"
-;;;;;; "international/uni-combining.el" "international/uni-comment.el"
-;;;;;; "international/uni-decimal.el" "international/uni-decomposition.el"
-;;;;;; "international/uni-digit.el" "international/uni-lowercase.el"
-;;;;;; "international/uni-mirrored.el" "international/uni-name.el"
-;;;;;; "international/uni-numeric.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" "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"
+;;;;;; "hfy-cmap.el" "ibuf-ext.el" "international/cp51932.el" "international/eucjp-ms.el"
+;;;;;; "international/fontset.el" "international/iso-ascii.el" "international/ja-dic-cnv.el"
+;;;;;; "international/ja-dic-utl.el" "international/ogonek.el" "international/uni-bidi.el"
+;;;;;; "international/uni-category.el" "international/uni-combining.el"
+;;;;;; "international/uni-comment.el" "international/uni-decimal.el"
+;;;;;; "international/uni-decomposition.el" "international/uni-digit.el"
+;;;;;; "international/uni-lowercase.el" "international/uni-mirrored.el"
+;;;;;; "international/uni-name.el" "international/uni-numeric.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"
;;;;;; "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"
;;;;;; "mh-e/mh-utils.el" "mh-e/mh-xface.el" "mouse-copy.el" "mouse.el"
;;;;;; "mwheel.el" "net/dns.el" "net/eudc-vars.el" "net/eudcb-bbdb.el"
;;;;;; "net/eudcb-ldap.el" "net/eudcb-mab.el" "net/eudcb-ph.el"
-;;;;;; "net/gnutls.el" "net/hmac-def.el" "net/hmac-md5.el" "net/imap-hash.el"
-;;;;;; "net/imap.el" "net/ldap.el" "net/mairix.el" "net/newsticker.el"
-;;;;;; "net/ntlm.el" "net/sasl-cram.el" "net/sasl-digest.el" "net/sasl-ntlm.el"
-;;;;;; "net/sasl.el" "net/socks.el" "net/tls.el" "net/tramp-cache.el"
+;;;;;; "net/hmac-def.el" "net/hmac-md5.el" "net/imap.el" "net/ldap.el"
+;;;;;; "net/mairix.el" "net/newsticker.el" "net/ntlm.el" "net/sasl-cram.el"
+;;;;;; "net/sasl-digest.el" "net/sasl-ntlm.el" "net/sasl.el" "net/soap-client.el"
+;;;;;; "net/soap-inspect.el" "net/socks.el" "net/tls.el" "net/tramp-cache.el"
;;;;;; "net/tramp-cmds.el" "net/tramp-compat.el" "net/tramp-gvfs.el"
-;;;;;; "net/tramp-gw.el" "net/tramp-imap.el" "net/tramp-loaddefs.el"
-;;;;;; "net/tramp-sh.el" "net/tramp-smb.el" "net/tramp-uu.el" "net/trampver.el"
-;;;;;; "net/zeroconf.el" "notifications.el" "nxml/nxml-enc.el" "nxml/nxml-maint.el"
+;;;;;; "net/tramp-gw.el" "net/tramp-loaddefs.el" "net/tramp-sh.el"
+;;;;;; "net/tramp-smb.el" "net/tramp-uu.el" "net/trampver.el" "net/zeroconf.el"
+;;;;;; "notifications.el" "nxml/nxml-enc.el" "nxml/nxml-maint.el"
;;;;;; "nxml/nxml-ns.el" "nxml/nxml-outln.el" "nxml/nxml-parse.el"
;;;;;; "nxml/nxml-rap.el" "nxml/nxml-util.el" "nxml/rng-dt.el" "nxml/rng-loc.el"
;;;;;; "nxml/rng-maint.el" "nxml/rng-match.el" "nxml/rng-parse.el"
;;;;;; "nxml/rng-pttrn.el" "nxml/rng-uri.el" "nxml/rng-util.el"
;;;;;; "nxml/xsd-regexp.el" "org/ob-C.el" "org/ob-R.el" "org/ob-asymptote.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-js.el" "org/ob-latex.el" "org/ob-ledger.el" "org/ob-lisp.el"
-;;;;;; "org/ob-matlab.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-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-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-complete.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-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-protocol.el"
-;;;;;; "org/org-rmail.el" "org/org-src.el" "org/org-vm.el" "org/org-w3m.el"
-;;;;;; "org/org-wl.el" "patcomp.el" "pgg-def.el" "pgg-parse.el"
-;;;;;; "pgg-pgp.el" "pgg-pgp5.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"
-;;;;;; "soundex.el" "subdirs.el" "tempo.el" "textmodes/bib-mode.el"
-;;;;;; "textmodes/makeinfo.el" "textmodes/page-ext.el" "textmodes/refbib.el"
-;;;;;; "textmodes/refer.el" "textmodes/reftex-auc.el" "textmodes/reftex-dcr.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-history.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" "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" "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" "soundex.el" "subdirs.el" "tempo.el"
+;;;;;; "textmodes/bib-mode.el" "textmodes/makeinfo.el" "textmodes/page-ext.el"
+;;;;;; "textmodes/refbib.el" "textmodes/refer.el" "textmodes/reftex-auc.el"
+;;;;;; "textmodes/reftex-dcr.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") (19737 18184 637096))
+;;;;;; "w32-vars.el" "x-dnd.el") (20303 23285 822071))
;;;***
\f
HCoop / bpt / emacs.git / blobdiff