;;;***
\f
;;;### (autoloads (ada-mode ada-add-extensions) "ada-mode" "progmodes/ada-mode.el"
-;;;;;; (14360 11474))
+;;;;;; (14821 31351))
;;; Generated autoloads from progmodes/ada-mode.el
(autoload (quote ada-add-extensions) "ada-mode" "\
If you use ada-xref.el:
Goto declaration: '\\[ada-point-and-xref]' on the identifier
or '\\[ada-goto-declaration]' with point on the identifier
- Complete identifier: '\\[ada-complete-identifier]'" t nil)
+ Complete identifier: '\\[ada-complete-identifier]'." t nil)
;;;***
\f
;;;### (autoloads (ada-header) "ada-stmt" "progmodes/ada-stmt.el"
-;;;;;; (14360 11651))
+;;;;;; (14821 31351))
;;; Generated autoloads from progmodes/ada-stmt.el
(autoload (quote ada-header) "ada-stmt" "\
;;;***
\f
-;;;### (autoloads (change-log-merge add-log-current-defun change-log-mode
-;;;;;; 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" "add-log.el" (14525 5303))
+;;;### (autoloads (change-log-redate change-log-merge add-log-current-defun
+;;;;;; change-log-mode 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" "add-log.el" (14807 56557))
;;; Generated autoloads from add-log.el
(defvar add-log-full-name nil "\
directory and its successive parents for a file so named.
Once a file is found, `change-log-default-name' is set locally in the
-current buffer to the complete file name." nil nil)
+current buffer to the complete file name.
+Optional arg BUFFER-FILE overrides `buffer-file-name'." nil nil)
(autoload (quote add-change-log-entry) "add-log" "\
Find change log file and add an entry for today.
Return name of function definition point is in, or nil.
Understands C, Lisp, LaTeX (\"functions\" are chapters, sections, ...),
-Texinfo (@node titles), Perl, and Fortran.
+Texinfo (@node titles) and Perl.
Other modes are handled by a heuristic that looks in the 10K before
point for uppercase headings starting in the first column or
-identifiers followed by `:' or `=', see variables
+identifiers followed by `:' or `='. See variables
`add-log-current-defun-header-regexp' and
`add-log-current-defun-function'
Both must be found in Change Log mode (since the merging depends on
the appropriate motion commands).
-Entries are inserted in chronological order.
+Entries are inserted in chronological order. Both the current and
+old-style time formats for entries are supported." t nil)
-Both the current and old-style time formats for entries are supported,
-so this command could be used to convert old-style logs by merging
-with an empty log." t nil)
+(autoload (quote change-log-redate) "add-log" "\
+Fix any old-style date entries in the current log file to default format." t nil)
;;;***
\f
;;;### (autoloads (defadvice ad-add-advice ad-default-compilation-action
-;;;;;; ad-redefinition-action) "advice" "emacs-lisp/advice.el" (14410
-;;;;;; 19111))
+;;;;;; ad-redefinition-action) "advice" "emacs-lisp/advice.el" (14660
+;;;;;; 49405))
;;; Generated autoloads from emacs-lisp/advice.el
(defvar ad-redefinition-action (quote warn) "\
;;;***
\f
-;;;### (autoloads (align-unhighlight-rule align-highlight-rule align-current
-;;;;;; align-entire align-regexp align) "align" "align.el" (14463
-;;;;;; 7197))
+;;;### (autoloads (align-newline-and-indent align-unhighlight-rule
+;;;;;; align-highlight-rule align-current align-entire align-regexp
+;;;;;; align) "align" "align.el" (14823 12922))
;;; Generated autoloads from align.el
(autoload (quote align) "align" "\
(autoload (quote align-unhighlight-rule) "align" "\
Remove any highlighting that was added by `align-highlight-rule'." t nil)
+(autoload (quote align-newline-and-indent) "align" "\
+A replacement function for `newline-and-indent', aligning as it goes." t nil)
+
;;;***
\f
;;;### (autoloads (ange-ftp-hook-function ange-ftp-reread-dir) "ange-ftp"
-;;;;;; "net/ange-ftp.el" (14546 48005))
+;;;;;; "net/ange-ftp.el" (14729 20675))
;;; Generated autoloads from net/ange-ftp.el
(defalias 'ange-ftp-re-read-dir 'ange-ftp-reread-dir)
;;;***
\f
;;;### (autoloads (antlr-set-tabs antlr-mode) "antlr-mode" "progmodes/antlr-mode.el"
-;;;;;; (14431 34774))
+;;;;;; (14642 37233))
;;; Generated autoloads from progmodes/antlr-mode.el
(autoload (quote antlr-mode) "antlr-mode" "\
;;;### (autoloads (appt-make-list appt-delete appt-add appt-display-diary
;;;;;; appt-display-duration appt-msg-window appt-display-mode-line
;;;;;; appt-visible appt-audible appt-message-warning-time appt-issue-message)
-;;;;;; "appt" "calendar/appt.el" (14517 9487))
+;;;;;; "appt" "calendar/appt.el" (14726 41837))
;;; Generated autoloads from calendar/appt.el
(defvar appt-issue-message t "\
This will occur at midnight when the appointment list is updated.")
(autoload (quote appt-add) "appt" "\
-Add an appointment for the day at TIME and issue MESSAGE.
+Add an appointment for the day at NEW-APPT-TIME and issue message NEW-APPT-MSG.
The time should be in either 24 hour format or am/pm format." t nil)
(autoload (quote appt-delete) "appt" "\
Delete an appointment from the list of appointments." t nil)
-(autoload (quote appt-make-list) "appt" nil nil nil)
+(autoload (quote appt-make-list) "appt" "\
+Create the appointments list from todays diary buffer.
+The time must be at the beginning of a line for it to be
+put in the appointments list.
+ 02/23/89
+ 12:00pm lunch
+ Wednesday
+ 10:00am group meeting
+We assume that the variables DATE and NUMBER
+hold the arguments that `list-diary-entries' received.
+They specify the range of dates that the diary is being processed for." nil nil)
;;;***
\f
;;;### (autoloads (apropos-documentation apropos-value apropos apropos-command
-;;;;;; apropos-variable apropos-mode) "apropos" "apropos.el" (14411
-;;;;;; 43647))
+;;;;;; apropos-variable apropos-mode) "apropos" "apropos.el" (14812
+;;;;;; 23964))
;;; Generated autoloads from apropos.el
(autoload (quote apropos-mode) "apropos" "\
(autoload (quote apropos-variable) "apropos" "\
Show user variables that match REGEXP.
-With optional prefix ARG or if `apropos-do-all' is non-nil, also show
+With optional prefix DO-ALL or if `apropos-do-all' is non-nil, also show
normal variables." t nil)
(fset (quote command-apropos) (quote apropos-command))
(autoload (quote apropos-command) "apropos" "\
-Show commands (interactively callable functions) that match REGEXP.
-With optional prefix ARG, or if `apropos-do-all' is non-nil, also show
+Show commands (interactively callable functions) that match APROPOS-REGEXP.
+With optional prefix DO-ALL, or if `apropos-do-all' is non-nil, also show
noninteractive functions.
If VAR-PREDICATE is non-nil, show only variables, and only those that
satisfy the predicate VAR-PREDICATE." t nil)
(autoload (quote apropos) "apropos" "\
-Show all bound symbols whose names match REGEXP.
-With optional prefix ARG or if `apropos-do-all' is non-nil, also show unbound
-symbols and key bindings, which is a little more time-consuming.
-Returns list of symbols and documentation found." t nil)
+Show all bound symbols whose names match APROPOS-REGEXP.
+With optional prefix DO-ALL or if `apropos-do-all' is non-nil, also
+show unbound symbols and key bindings, which is a little more
+time-consuming. Returns list of symbols and documentation found." t nil)
(autoload (quote apropos-value) "apropos" "\
-Show all symbols whose value's printed image matches REGEXP.
-With optional prefix ARG or if `apropos-do-all' is non-nil, also looks
+Show all symbols whose value's printed image matches APROPOS-REGEXP.
+With optional prefix DO-ALL or if `apropos-do-all' is non-nil, also looks
at the function and at the names and values of properties.
Returns list of symbols and values found." t nil)
(autoload (quote apropos-documentation) "apropos" "\
-Show symbols whose documentation contain matches for REGEXP.
-With optional prefix ARG or if `apropos-do-all' is non-nil, also use
+Show symbols whose documentation contain matches for APROPOS-REGEXP.
+With optional prefix DO-ALL or if `apropos-do-all' is non-nil, also use
documentation that is not stored in the documentation file and show key
bindings.
Returns list of symbols and documentation found." t nil)
;;;***
\f
-;;;### (autoloads (archive-mode) "arc-mode" "arc-mode.el" (14539
-;;;;;; 44524))
+;;;### (autoloads (archive-mode) "arc-mode" "arc-mode.el" (14826
+;;;;;; 51988))
;;; Generated autoloads from arc-mode.el
(autoload (quote archive-mode) "arc-mode" "\
;;;***
\f
-;;;### (autoloads (array-mode) "array" "array.el" (14460 38616))
+;;;### (autoloads (array-mode) "array" "array.el" (14777 22130))
;;; Generated autoloads from array.el
(autoload (quote array-mode) "array" "\
;;;***
\f
-;;;### (autoloads (asm-mode) "asm-mode" "progmodes/asm-mode.el" (14286
-;;;;;; 393))
+;;;### (autoloads (asm-mode) "asm-mode" "progmodes/asm-mode.el" (14807
+;;;;;; 56561))
;;; Generated autoloads from progmodes/asm-mode.el
(autoload (quote asm-mode) "asm-mode" "\
\\{asm-mode-map}
" t nil)
+;;;***
+\f
+;;;### (autoloads (batch-update-authors authors) "authors" "emacs-lisp/authors.el"
+;;;;;; (14849 35128))
+;;; Generated autoloads from emacs-lisp/authors.el
+
+(autoload (quote authors) "authors" "\
+Extract author information from change logs and Lisp source files.
+ROOT is the root directory under which to find the files. If called
+interactively, ROOT is read from the minibuffer. Result is a
+buffer *Authors* containing authorship information." t nil)
+
+(autoload (quote batch-update-authors) "authors" "\
+Produce an AUTHORS file.
+Call this function in batch mode with two command line arguments FILE
+and ROOT. FILE is the file to write, ROOT is the root directory of
+the Emacs source tree, from which to build the file." nil nil)
+
;;;***
\f
;;;### (autoloads (auto-show-mode auto-show-mode) "auto-show" "auto-show.el"
-;;;;;; (14516 149))
+;;;;;; (14777 22130))
;;; Generated autoloads from auto-show.el
(defvar auto-show-mode nil "\
(autoload (quote auto-show-mode) "auto-show" "\
This command is obsolete." t nil)
+;;;***
+\f
+;;;### (autoloads (autoarg-kp-mode autoarg-mode) "autoarg" "autoarg.el"
+;;;;;; (14777 22131))
+;;; Generated autoloads from autoarg.el
+
+(defvar autoarg-mode nil "\
+Toggle Autoarg mode on or off.
+See the command `autoarg-mode' for a description of this minor-mode.
+Setting this variable directly does not take effect;
+use either \\[customize] or the function `autoarg-mode'.")
+
+(custom-add-to-group (quote autoarg) (quote autoarg-mode) (quote custom-variable))
+
+(custom-add-load (quote autoarg-mode) (quote autoarg))
+
+(autoload (quote autoarg-mode) "autoarg" "\
+Toggle Autoarg minor mode globally.
+With ARG, turn Autoarg mode on if ARG is positive, off otherwise.
+\\<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.
+
+For example:
+`6 9 \\[autoarg-terminate]' inserts `69' into the buffer, as does `C-6 C-9'.
+`6 9 a' inserts 69 `a's into the buffer.
+`6 9 \\[autoarg-terminate] \\[autoarg-terminate]' inserts `69' into the buffer and
+then invokes the normal binding of \\[autoarg-terminate].
+`C-u \\[autoarg-terminate]' invokes the normal binding of \\[autoarg-terminate] four times.
+
+\\{autoarg-mode-map}" t nil)
+
+(defvar autoarg-kp-mode nil "\
+Toggle Autoarg-Kp mode on or off.
+See the command `autoarg-kp-mode' for a description of this minor-mode.
+Setting this variable directly does not take effect;
+use either \\[customize] or the function `autoarg-kp-mode'.")
+
+(custom-add-to-group (quote autoarg-kp) (quote autoarg-kp-mode) (quote custom-variable))
+
+(custom-add-load (quote autoarg-kp-mode) (quote autoarg))
+
+(autoload (quote autoarg-kp-mode) "autoarg" "\
+Toggle Autoarg-KP minor mode globally.
+With ARG, turn Autoarg mode on if ARG is positive, off otherwise.
+\\<autoarg-kp-mode-map>
+This is similar to \\[autoarg-mode] but rebinds the keypad keys `kp-1'
+&c to supply digit arguments.
+
+\\{autoarg-kp-mode-map}" t nil)
+
;;;***
\f
;;;### (autoloads (autoconf-mode) "autoconf" "progmodes/autoconf.el"
;;;***
\f
;;;### (autoloads (auto-insert-mode define-auto-insert auto-insert)
-;;;;;; "autoinsert" "autoinsert.el" (14410 18534))
+;;;;;; "autoinsert" "autoinsert.el" (14855 56552))
;;; Generated autoloads from autoinsert.el
(autoload (quote auto-insert) "autoinsert" "\
-Insert default contents into a new file if `auto-insert' is non-nil.
+Insert default contents into new files if variable `auto-insert' is non-nil.
Matches the visited file name against the elements of `auto-insert-alist'." t nil)
(autoload (quote define-auto-insert) "autoinsert" "\
Optional AFTER means to insert action after all existing actions for CONDITION,
or if CONDITION had no actions, after all other CONDITIONs." nil nil)
+(defvar auto-insert-mode nil "\
+Toggle Auto-Insert mode on or off.
+See the command `auto-insert-mode' for a description of this minor-mode.
+Setting this variable directly does not take effect;
+use either \\[customize] or the function `auto-insert-mode'.")
+
+(custom-add-to-group (quote auto-insert) (quote auto-insert-mode) (quote custom-variable))
+
+(custom-add-load (quote auto-insert-mode) (quote autoinsert))
+
(autoload (quote auto-insert-mode) "autoinsert" "\
Toggle Auto-insert mode.
With prefix ARG, turn Auto-insert mode on if and only if ARG is positive.
\f
;;;### (autoloads (batch-update-autoloads update-autoloads-from-directories
;;;;;; update-file-autoloads) "autoload" "emacs-lisp/autoload.el"
-;;;;;; (14398 37513))
+;;;;;; (14659 23014))
;;; Generated autoloads from emacs-lisp/autoload.el
(autoload (quote update-file-autoloads) "autoload" "\
\f
;;;### (autoloads (global-auto-revert-mode turn-on-auto-revert-mode
;;;;;; auto-revert-mode global-auto-revert-mode) "autorevert" "autorevert.el"
-;;;;;; (14495 17959))
+;;;;;; (14777 22132))
;;; Generated autoloads from autorevert.el
(defvar auto-revert-mode nil "\
;;;***
\f
;;;### (autoloads (mouse-avoidance-mode mouse-avoidance-mode) "avoid"
-;;;;;; "avoid.el" (14539 53646))
+;;;;;; "avoid.el" (14777 22132))
;;; 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'.")
MODE should be one of the symbols `banish', `exile', `jump', `animate',
`cat-and-mouse', `proteus', or `none'.
-If MODE is nil, toggle mouse avoidance between `none` and `banish'
+If MODE is nil, toggle mouse avoidance between `none' and `banish'
modes. Positive numbers and symbols other than the above are treated
as equivalent to `banish'; negative numbers and `-' are equivalent to `none'.
-Effects of the different modes:
+Effects of the different modes:
* banish: Move the mouse to the upper-right corner on any keypress.
* exile: Move the mouse to the corner only if the cursor gets too close,
and allow it to return once the cursor is out of the way.
;;;***
\f
-;;;### (autoloads (awk-mode) "awk-mode" "progmodes/awk-mode.el" (14546
-;;;;;; 45178))
+;;;### (autoloads (awk-mode) "awk-mode" "progmodes/awk-mode.el" (14854
+;;;;;; 32223))
;;; Generated autoloads from progmodes/awk-mode.el
(autoload (quote awk-mode) "awk-mode" "\
Major mode for editing AWK code.
-This is much like C mode except for the syntax of comments. It uses
-the same keymap as C mode and has the same variables for customizing
+This is much like C mode except for the syntax of comments. Its keymap
+inherits from C mode's and it has the same variables for customizing
indentation. It has its own abbrev table and its own syntax table.
-Turning on AWK mode calls the value of the variable `awk-mode-hook'
-with no args, if that value is non-nil." t nil)
+Turning on AWK mode runs `awk-mode-hook'." t nil)
;;;***
\f
;;;***
\f
;;;### (autoloads (display-battery battery) "battery" "battery.el"
-;;;;;; (14422 6418))
+;;;;;; (14821 31343))
;;; Generated autoloads from battery.el
(autoload (quote battery) "battery" "\
(autoload (quote display-battery) "battery" "\
Display battery status information in the mode line.
-The text beeing displayed in the mode line is controlled by the variables
+The text being displayed in the mode line is controlled by the variables
`battery-mode-line-format' and `battery-status-function'.
The mode line will be updated automatically every `battery-update-interval'
seconds." t nil)
;;;***
\f
-;;;### (autoloads (bibtex-mode) "bibtex" "textmodes/bibtex.el" (14504
-;;;;;; 9460))
+;;;### (autoloads (bibtex-mode) "bibtex" "textmodes/bibtex.el" (14505
+;;;;;; 7809))
;;; Generated autoloads from textmodes/bibtex.el
(autoload (quote bibtex-mode) "bibtex" "\
\\{bibtex-mode-map}" t nil)
+;;;***
+\f
+;;;### (autoloads nil "binhex" "gnus/binhex.el" (14849 20131))
+;;; Generated autoloads from gnus/binhex.el
+
+(defconst binhex-begin-line "^:...............................................................$")
+
;;;***
\f
;;;### (autoloads (blackbox) "blackbox" "play/blackbox.el" (13229
;;;;;; bookmark-load bookmark-save bookmark-write bookmark-delete
;;;;;; bookmark-insert bookmark-rename bookmark-insert-location
;;;;;; bookmark-relocate bookmark-jump bookmark-set) "bookmark"
-;;;;;; "bookmark.el" (14531 42950))
+;;;;;; "bookmark.el" (14777 22136))
;;; Generated autoloads from bookmark.el
(define-key ctl-x-map "rb" 'bookmark-jump)
(define-key ctl-x-map "rm" 'bookmark-set)
;;;### (autoloads (browse-url-generic browse-url-mail browse-url-mmm
;;;;;; browse-url-lynx-emacs browse-url-lynx-xterm browse-url-w3-gnudoit
;;;;;; browse-url-w3 browse-url-iximosaic browse-url-cci browse-url-grail
-;;;;;; browse-url-mosaic browse-url-netscape 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-generic-program
-;;;;;; browse-url-save-file browse-url-netscape-display browse-url-new-window-p
-;;;;;; browse-url-browser-function) "browse-url" "net/browse-url.el"
-;;;;;; (14554 2050))
+;;;;;; browse-url-mosaic browse-url-gnome-moz browse-url-netscape
+;;;;;; 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-generic-program browse-url-save-file browse-url-netscape-display
+;;;;;; browse-url-new-window-p browse-url-browser-function) "browse-url"
+;;;;;; "net/browse-url.el" (14821 31351))
;;; Generated autoloads from net/browse-url.el
(defvar browse-url-browser-function (if (eq system-type (quote windows-nt)) (quote browse-url-default-windows-browser) (quote browse-url-netscape)) "\
(autoload (quote browse-url-netscape) "browse-url" "\
Ask the Netscape WWW browser to load URL.
-
Default to the URL around or before point. The strings in variable
`browse-url-netscape-arguments' are also passed to Netscape.
When called non-interactively, optional second argument NEW-WINDOW is
used instead of `browse-url-new-window-p'." t nil)
+(autoload (quote browse-url-gnome-moz) "browse-url" "\
+Ask Mozilla/Netscape to load URL via the GNOME program `gnome-moz-remote'.
+Default to the URL around or before point. The strings in variable
+`browse-url-gnome-moz-arguments' are also passed.
+
+When called interactively, if variable `browse-url-new-window-p' is
+non-nil, load the document in a new browser window, otherwise use an
+existing one. A non-nil interactive prefix argument reverses the
+effect of `browse-url-new-window-p'.
+
+When called non-interactively, optional second argument NEW-WINDOW is
+used instead of `browse-url-new-window-p'." t nil)
+
(autoload (quote browse-url-mosaic) "browse-url" "\
Ask the XMosaic WWW browser to load URL.
;;;***
\f
;;;### (autoloads (bs-show bs-customize bs-cycle-previous bs-cycle-next)
-;;;;;; "bs" "bs.el" (14495 17961))
+;;;;;; "bs" "bs.el" (14777 22138))
;;; Generated autoloads from bs.el
(autoload (quote bs-cycle-next) "bs" "\
Customization of group bs for Buffer Selection Menu." t nil)
(autoload (quote bs-show) "bs" "\
-Make a menu of buffers so you can manipulate buffer list or buffers itself.
+Make a menu of buffers so you can manipulate buffers or the buffer list.
\\<bs-mode-map>
There are many key commands similar to `Buffer-menu-mode' for
manipulating buffer list and buffers itself.
;;;### (autoloads (batch-byte-recompile-directory batch-byte-compile
;;;;;; display-call-tree byte-compile compile-defun byte-compile-file
;;;;;; byte-recompile-directory byte-force-recompile) "bytecomp"
-;;;;;; "emacs-lisp/bytecomp.el" (14547 29523))
+;;;;;; "emacs-lisp/bytecomp.el" (14859 7672))
;;; Generated autoloads from emacs-lisp/bytecomp.el
(autoload (quote byte-force-recompile) "bytecomp" "\
;;;***
\f
-;;;### (autoloads (calculator) "calculator" "calculator.el" (14511
-;;;;;; 60346))
+;;;### (autoloads (calculator) "calculator" "calculator.el" (14777
+;;;;;; 22140))
;;; Generated autoloads from calculator.el
(autoload (quote calculator) "calculator" "\
;;;;;; calendar-remove-frame-by-deleting mark-diary-entries-in-calendar
;;;;;; number-of-diary-entries view-diary-entries-initially calendar-offset
;;;;;; calendar-week-start-day) "calendar" "calendar/calendar.el"
-;;;;;; (14393 15349))
+;;;;;; (14854 32222))
;;; Generated autoloads from calendar/calendar.el
(defvar calendar-week-start-day 0 "\
(defvar number-of-diary-entries 1 "\
*Specifies how many days of diary entries are to be displayed initially.
-This variable affects the diary display when the command M-x diary is used,
+This variable affects the diary display when the command \\[diary] is used,
or if the value of the variable `view-diary-entries-initially' is t. For
example, if the default value 1 is used, then only the current day's diary
entries will be displayed. If the value 2 is used, then both the current
See the documentation for the function `include-other-diary-files'.")
(defvar sexp-diary-entry-symbol "%%" "\
-*The string used to indicate a sexp diary entry in diary-file.
+*The string used to indicate a sexp diary entry in `diary-file'.
See the documentation for the function `list-sexp-diary-entries'.")
(defvar abbreviated-calendar-year t "\
*List of functions called after marking diary entries in the calendar.
A function `mark-included-diary-files' is also provided for use as the
-mark-diary-entries-hook; it enables you to use shared diary files together
+`mark-diary-entries-hook'; it enables you to use shared diary files together
with your own. The files included are specified in the diary file by lines
of the form
#include \"filename\"
;;;***
\f
-;;;### (autoloads nil "cc-langs" "progmodes/cc-langs.el" (14419 57707))
+;;;### (autoloads nil "cc-langs" "progmodes/cc-langs.el" (14716 17402))
;;; Generated autoloads from progmodes/cc-langs.el
(defvar c-mode-syntax-table nil "\
\f
;;;### (autoloads (pike-mode idl-mode java-mode objc-mode c++-mode
;;;;;; c-mode c-initialize-cc-mode) "cc-mode" "progmodes/cc-mode.el"
-;;;;;; (14419 57707))
+;;;;;; (14716 17402))
;;; Generated autoloads from progmodes/cc-mode.el
(autoload (quote c-initialize-cc-mode) "cc-mode" nil nil nil)
;;;***
\f
;;;### (autoloads (c-set-offset c-add-style c-set-style) "cc-styles"
-;;;;;; "progmodes/cc-styles.el" (14419 57707))
+;;;;;; "progmodes/cc-styles.el" (14716 17403))
;;; Generated autoloads from progmodes/cc-styles.el
(autoload (quote c-set-style) "cc-styles" "\
;;;***
\f
-;;;### (autoloads nil "cc-vars" "progmodes/cc-vars.el" (14419 57707))
+;;;### (autoloads nil "cc-vars" "progmodes/cc-vars.el" (14716 17403))
;;; Generated autoloads from progmodes/cc-vars.el
(defconst c-emacs-features (let ((infodock-p (boundp (quote infodock-version))) (comments (let ((table (copy-syntax-table)) entry) (modify-syntax-entry 97 ". 12345678" table) (cond ((arrayp table) (setq entry (aref table 97)) (if (consp entry) (setq entry (car entry)))) ((fboundp (quote get-char-table)) (setq entry (get-char-table 97 table))) ((and (fboundp (quote char-table-p)) (char-table-p table)) (setq entry (car (char-table-range table [97])))) (t (error "CC Mode is incompatible with this version of Emacs"))) (if (= (logand (lsh entry -16) 255) 255) (quote 8-bit) (quote 1-bit))))) (if infodock-p (list comments (quote infodock)) (list comments))) "\
\f
;;;### (autoloads (ccl-execute-with-args check-ccl-program define-ccl-program
;;;;;; declare-ccl-program ccl-dump ccl-compile) "ccl" "international/ccl.el"
-;;;;;; (14543 61454))
+;;;;;; (14747 44775))
;;; Generated autoloads from international/ccl.el
(autoload (quote ccl-compile) "ccl" "\
(autoload (quote define-ccl-program) "ccl" "\
Set NAME the compiled code of CCL-PROGRAM.
-CCL-PROGRAM is `eval'ed before being handed to the CCL compiler `ccl-compile'.
-The compiled code is a vector of integers." nil (quote macro))
+
+CCL-PROGRAM is has this form:
+ (BUFFER_MAGNIFICATION
+ CCL_MAIN_CODE
+ [ CCL_EOF_CODE ])
+
+BUFFER_MAGNIFICATION is an integer value specifying the approximate
+output buffer magnification size compared with the bytes of input data
+text. If the value is zero, the CCL program can't execute `read' and
+`write' commands.
+
+CCL_MAIN_CODE and CCL_EOF_CODE are CCL program codes. CCL_MAIN_CODE
+executed at first. If there's no more input data when `read' command
+is executed in CCL_MAIN_CODE, CCL_EOF_CODE is executed. If
+CCL_MAIN_CODE is terminated, CCL_EOF_CODE is not executed.
+
+Here's the syntax of CCL program code in BNF notation. The lines
+starting by two semicolons (and optional leading spaces) describe the
+semantics.
+
+CCL_MAIN_CODE := CCL_BLOCK
+
+CCL_EOF_CODE := CCL_BLOCK
+
+CCL_BLOCK := STATEMENT | (STATEMENT [STATEMENT ...])
+
+STATEMENT :=
+ SET | IF | BRANCH | LOOP | REPEAT | BREAK | READ | WRITE | CALL
+ | TRANSLATE | END
+
+SET := (REG = EXPRESSION)
+ | (REG ASSIGNMENT_OPERATOR EXPRESSION)
+ ;; The following form is the same as (r0 = integer).
+ | integer
+
+EXPRESSION := ARG | (EXPRESSION OPERATOR ARG)
+
+;; Evaluate EXPRESSION. If the result is nonzeor, execute
+;; CCL_BLOCK_0. Otherwise, execute CCL_BLOCK_1.
+IF := (if EXPRESSION CCL_BLOCK_0 CCL_BLOCK_1)
+
+;; Evaluate EXPRESSION. Provided that the result is N, execute
+;; CCL_BLOCK_N.
+BRANCH := (branch EXPRESSION CCL_BLOCK_0 [CCL_BLOCK_1 ...])
+
+;; Execute STATEMENTs until (break) or (end) is executed.
+LOOP := (loop STATEMENT [STATEMENT ...])
+
+;; Terminate the most inner loop.
+BREAK := (break)
+
+REPEAT :=
+ ;; Jump to the head of the most inner loop.
+ (repeat)
+ ;; Same as: ((write [REG | integer | string])
+ ;; (repeat))
+ | (write-repeat [REG | integer | string])
+ ;; Same as: ((write REG [ARRAY])
+ ;; (read REG)
+ ;; (repeat))
+ | (write-read-repeat REG [ARRAY])
+ ;; Same as: ((write integer)
+ ;; (read REG)
+ ;; (repeat))
+ | (write-read-repeat REG integer)
+
+READ := ;; Set REG_0 to a byte read from the input text, set REG_1
+ ;; to the next byte read, and so on.
+ (read REG_0 [REG_1 ...])
+ ;; Same as: ((read REG)
+ ;; (if (REG OPERATOR ARG) CCL_BLOCK_0 CCL_BLOCK_1))
+ | (read-if (REG OPERATOR ARG) CCL_BLOCK_0 CCL_BLOCK_1)
+ ;; Same as: ((read REG)
+ ;; (branch REG CCL_BLOCK_0 [CCL_BLOCK_1 ...]))
+ | (read-branch REG CCL_BLOCK_0 [CCL_BLOCK_1 ...])
+ ;; Read a character from the input text while parsing
+ ;; multibyte representation, set REG_0 to the charset ID of
+ ;; the character, set REG_1 to the code point of the
+ ;; character. If the dimension of charset is two, set REG_1
+ ;; to ((CODE0 << 8) | CODE1), where CODE0 is the first code
+ ;; point and CODE1 is the second code point.
+ | (read-multibyte-character REG_0 REG_1)
+
+WRITE :=
+ ;; Write REG_0, REG_1, ... to the output buffer. If REG_N is
+ ;; a multibyte character, write the corresponding multibyte
+ ;; representation.
+ (write REG_0 [REG_1 ...])
+ ;; Same as: ((r7 = EXPRESSION)
+ ;; (write r7))
+ | (write EXPRESSION)
+ ;; Write the value of `integer' to the output buffer. If it
+ ;; is a multibyte character, write the corresponding multibyte
+ ;; representation.
+ | (write integer)
+ ;; Write the byte sequence of `string' as is to the output
+ ;; buffer.
+ | (write string)
+ ;; Same as: (write string)
+ | string
+ ;; Provided that the value of REG is N, write Nth element of
+ ;; ARRAY to the output buffer. If it is a multibyte
+ ;; character, write the corresponding multibyte
+ ;; representation.
+ | (write REG ARRAY)
+ ;; Write a multibyte representation of a character whose
+ ;; charset ID is REG_0 and code point is REG_1. If the
+ ;; dimension of the charset is two, REG_1 should be ((CODE0 <<
+ ;; 8) | CODE1), where CODE0 is the first code point and CODE1
+ ;; is the second code point of the character.
+ | (write-multibyte-character REG_0 REG_1)
+
+;; Call CCL program whose name is ccl-program-name.
+CALL := (call ccl-program-name)
+
+;; Terminate the CCL program.
+END := (end)
+
+;; CCL registers that can contain any integer value. As r7 is also
+;; used by CCL interpreter, its value is changed unexpectedly.
+REG := r0 | r1 | r2 | r3 | r4 | r5 | r6 | r7
+
+ARG := REG | integer
+
+OPERATOR :=
+ ;; Normal arithmethic operators (same meaning as C code).
+ + | - | * | / | %
+
+ ;; Bitwize operators (same meaning as C code)
+ | & | `|' | ^
+
+ ;; Shifting operators (same meaning as C code)
+ | << | >>
+
+ ;; (REG = ARG_0 <8 ARG_1) means:
+ ;; (REG = ((ARG_0 << 8) | ARG_1))
+ | <8
+
+ ;; (REG = ARG_0 >8 ARG_1) means:
+ ;; ((REG = (ARG_0 >> 8))
+ ;; (r7 = (ARG_0 & 255)))
+ | >8
+
+ ;; (REG = ARG_0 // ARG_1) means:
+ ;; ((REG = (ARG_0 / ARG_1))
+ ;; (r7 = (ARG_0 % ARG_1)))
+ | //
+
+ ;; Normal comparing operators (same meaning as C code)
+ | < | > | == | <= | >= | !=
+
+ ;; If ARG_0 and ARG_1 are higher and lower byte of Shift-JIS
+ ;; code, and CHAR is the corresponding JISX0208 character,
+ ;; (REG = ARG_0 de-sjis ARG_1) means:
+ ;; ((REG = CODE0)
+ ;; (r7 = CODE1))
+ ;; where CODE0 is the first code point of CHAR, CODE1 is the
+ ;; second code point of CHAR.
+ | de-sjis
+
+ ;; If ARG_0 and ARG_1 are the first and second code point of
+ ;; JISX0208 character CHAR, and SJIS is the correponding
+ ;; Shift-JIS code,
+ ;; (REG = ARG_0 en-sjis ARG_1) means:
+ ;; ((REG = HIGH)
+ ;; (r7 = LOW))
+ ;; where HIGH is the higher byte of SJIS, LOW is the lower
+ ;; byte of SJIS.
+ | en-sjis
+
+ASSIGNMENT_OPERATOR :=
+ ;; Same meaning as C code
+ += | -= | *= | /= | %= | &= | `|=' | ^= | <<= | >>=
+
+ ;; (REG <8= ARG) is the same as:
+ ;; ((REG <<= 8)
+ ;; (REG |= ARG))
+ | <8=
+
+ ;; (REG >8= ARG) is the same as:
+ ;; ((r7 = (REG & 255))
+ ;; (REG >>= 8))
+
+ ;; (REG //= ARG) is the same as:
+ ;; ((r7 = (REG % ARG))
+ ;; (REG /= ARG))
+ | //=
+
+ARRAY := `[' integer ... `]'
+
+
+TRANSLATE :=
+ (translate-character REG(table) REG(charset) REG(codepoint))
+ | (translate-character SYMBOL REG(charset) REG(codepoint))
+MAP :=
+ (iterate-multiple-map REG REG MAP-IDs)
+ | (map-multiple REG REG (MAP-SET))
+ | (map-single REG REG MAP-ID)
+MAP-IDs := MAP-ID ...
+MAP-SET := MAP-IDs | (MAP-IDs) MAP-SET
+MAP-ID := integer
+" nil (quote macro))
(autoload (quote check-ccl-program) "ccl" "\
Check validity of CCL-PROGRAM.
(autoload (quote ccl-execute-with-args) "ccl" "\
Execute CCL-PROGRAM with registers initialized by the remaining args.
-The return value is a vector of resulting CCL registers." nil nil)
+The return value is a vector of resulting CCL registers.
+
+See the documentation of `define-ccl-program' for the detail of CCL program." nil nil)
;;;***
\f
;;;***
\f
;;;### (autoloads (encode-hz-buffer encode-hz-region decode-hz-buffer
-;;;;;; decode-hz-region setup-chinese-cns-environment setup-chinese-big5-environment
-;;;;;; setup-chinese-gb-environment) "china-util" "language/china-util.el"
-;;;;;; (13774 37678))
+;;;;;; decode-hz-region) "china-util" "language/china-util.el" (14623
+;;;;;; 45987))
;;; Generated autoloads from language/china-util.el
-(autoload (quote setup-chinese-gb-environment) "china-util" "\
-Setup multilingual environment (MULE) for Chinese GB2312 users." t nil)
-
-(autoload (quote setup-chinese-big5-environment) "china-util" "\
-Setup multilingual environment (MULE) for Chinese Big5 users." t nil)
-
-(autoload (quote setup-chinese-cns-environment) "china-util" "\
-Setup multilingual environment (MULE) for Chinese CNS11643 family users." t nil)
-
(autoload (quote decode-hz-region) "china-util" "\
Decode HZ/ZW encoded text in the current region.
Return the length of resulting text." t nil)
;;;***
\f
;;;### (autoloads (command-history list-command-history repeat-matching-complex-command)
-;;;;;; "chistory" "chistory.el" (14447 15307))
+;;;;;; "chistory" "chistory.el" (14821 31343))
;;; Generated autoloads from chistory.el
(autoload (quote repeat-matching-complex-command) "chistory" "\
;;;***
\f
-;;;### (autoloads nil "cl" "emacs-lisp/cl.el" (14533 31536))
+;;;### (autoloads nil "cl" "emacs-lisp/cl.el" (14753 19207))
;;; 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"
-;;;;;; (14518 39681))
+;;;;;; (14735 57398))
;;; Generated autoloads from emacs-lisp/cl-indent.el
(autoload (quote common-lisp-indent-function) "cl-indent" nil nil nil)
;;;***
\f
;;;### (autoloads (c-macro-expand) "cmacexp" "progmodes/cmacexp.el"
-;;;;;; (14368 26241))
+;;;;;; (14837 50477))
;;; Generated autoloads from progmodes/cmacexp.el
(autoload (quote c-macro-expand) "cmacexp" "\
;;;***
\f
-;;;### (autoloads (run-scheme) "cmuscheme" "cmuscheme.el" (14535
-;;;;;; 44845))
+;;;### (autoloads (run-scheme) "cmuscheme" "cmuscheme.el" (14831
+;;;;;; 12714))
;;; Generated autoloads from cmuscheme.el
(autoload (quote run-scheme) "cmuscheme" "\
Run an inferior Scheme process, input and output via buffer *scheme*.
If there is a process already running in `*scheme*', switch to that buffer.
With argument, allows you to edit the command line (default is value
-of `scheme-program-name'). Runs the hooks `inferior-scheme-mode-hook'
+of `cmuscheme-program-name'). Runs the hooks `inferior-scheme-mode-hook'
\(after the `comint-mode-hook' is run).
\(Type \\[describe-mode] in the process buffer for a list of commands.)" t nil)
(add-hook 'same-window-buffer-names "*scheme*")
\f
;;;### (autoloads (codepage-setup cp-supported-codepages cp-offset-for-codepage
;;;;;; cp-language-for-codepage cp-charset-for-codepage cp-make-coding-systems-for-codepage)
-;;;;;; "codepage" "international/codepage.el" (14124 8038))
+;;;;;; "codepage" "international/codepage.el" (14720 7113))
;;; Generated autoloads from international/codepage.el
(autoload (quote cp-make-coding-systems-for-codepage) "codepage" "\
\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) "comint" "comint.el" (14535 44845))
+;;;;;; comint-run make-comint make-comint-in-buffer) "comint" "comint.el"
+;;;;;; (14854 32221))
;;; Generated autoloads from comint.el
+(autoload (quote make-comint-in-buffer) "comint" "\
+Make a comint process NAME in BUFFER, running PROGRAM.
+If BUFFER is nil, it defaults to NAME surrounded by `*'s.
+PROGRAM should be either a string denoting an executable program to create
+via `start-process', or a cons pair of the form (HOST . SERVICE) denoting a TCP
+connection to be opened via `open-network-stream'. If there is already a
+running process in that buffer, it is not restarted. Optional third arg
+STARTFILE is the name of a file to send the contents of to the process.
+
+If PROGRAM is a string, any more args are arguments to PROGRAM." nil nil)
+
(autoload (quote make-comint) "comint" "\
Make a comint process NAME in a buffer, running PROGRAM.
The name of the buffer is made by surrounding NAME with `*'s.
If NO-DISPLAY is non-nil, do not show the output buffer." t nil)
(autoload (quote comint-redirect-results-list) "comint" "\
-Send COMMAND to current process.
+Send COMMAND to current process.
Return a list of expressions in the output which match REGEXP.
REGEXP-GROUP is the regular expression group in REGEXP to use." nil nil)
(autoload (quote comint-redirect-results-list-from-process) "comint" "\
-Send COMMAND to PROCESS.
+Send COMMAND to PROCESS.
Return a list of expressions in the output which match REGEXP.
REGEXP-GROUP is the regular expression group in REGEXP to use." nil nil)
;;;***
\f
-;;;### (autoloads (compare-windows) "compare-w" "compare-w.el" (14220
-;;;;;; 18289))
+;;;### (autoloads (compare-windows) "compare-w" "compare-w.el" (14777
+;;;;;; 22146))
;;; Generated autoloads from compare-w.el
(autoload (quote compare-windows) "compare-w" "\
;;;### (autoloads (next-error compilation-minor-mode compilation-shell-minor-mode
;;;;;; compilation-mode grep-find grep compile compilation-search-path
;;;;;; compilation-ask-about-save compilation-window-height compilation-mode-hook)
-;;;;;; "compile" "progmodes/compile.el" (14440 46010))
+;;;;;; "compile" "progmodes/compile.el" (14813 40531))
;;; Generated autoloads from progmodes/compile.el
(defvar compilation-mode-hook nil "\
or \\<compilation-minor-mode-map>\\[compile-goto-error] in the grep output buffer, to go to the lines
where grep found matches.
-This command uses a special history list for its arguments, so you can
+This command uses a special history list for its COMMAND-ARGS, so you can
easily repeat a grep command.
A prefix argument says to default the argument based upon the current
If all the error messages parsed so far have been processed already,
the message buffer is checked for new ones.
-A prefix arg specifies how many error messages to move;
+A prefix ARGP specifies how many error messages to move;
negative means move back to previous error messages.
-Just C-u as a prefix means reparse the error message buffer
+Just \\[universal-argument] as a prefix means reparse the error message buffer
and start at the first error.
\\[next-error] normally uses the most recently started compilation or
;;;***
\f
;;;### (autoloads (partial-completion-mode) "complete" "complete.el"
-;;;;;; (14393 17619))
+;;;;;; (14854 32221))
;;; Generated autoloads from complete.el
+(defvar partial-completion-mode nil "\
+Toggle Partial-Completion mode on or off.
+See the command `partial-completion-mode' for a description of this minor-mode.
+Setting this variable directly does not take effect;
+use either \\[customize] or the function `partial-completion-mode'.")
+
+(custom-add-to-group (quote partial-completion) (quote partial-completion-mode) (quote custom-variable))
+
+(custom-add-load (quote partial-completion-mode) (quote complete))
+
(autoload (quote partial-completion-mode) "complete" "\
Toggle Partial Completion mode.
With prefix ARG, turn Partial Completion mode on if ARG is positive.
When Partial Completion mode is enabled, TAB (or M-TAB if `PC-meta-flag' is
nil) is enhanced so that if some string is divided into words and each word is
delimited by a character in `PC-word-delimiters', partial words are completed
-as much as possible.
+as much as possible and `*' characters are treated likewise in file names.
For example, M-x p-c-m expands to M-x partial-completion-mode since no other
command begins with that sequence of characters, and
;;;***
\f
;;;### (autoloads (dynamic-completion-mode) "completion" "completion.el"
-;;;;;; (14495 17962))
+;;;;;; (14777 22150))
;;; Generated autoloads from completion.el
(autoload (quote dynamic-completion-mode) "completion" "\
;;;### (autoloads (decompose-composite-char compose-last-chars compose-chars-after
;;;;;; find-composition compose-chars decompose-string compose-string
;;;;;; decompose-region compose-region) "composite" "composite.el"
-;;;;;; (14422 57499))
+;;;;;; (14855 56552))
;;; Generated autoloads from composite.el
(defconst reference-point-alist (quote ((tl . 0) (tc . 1) (tr . 2) (Bl . 3) (Bc . 4) (Br . 5) (bl . 6) (bc . 7) (br . 8) (cl . 9) (cc . 10) (cr . 11) (top-left . 0) (top-center . 1) (top-right . 2) (base-left . 3) (base-center . 4) (base-right . 5) (bottom-left . 6) (bottom-center . 7) (bottom-right . 8) (center-left . 9) (center-center . 10) (center-right . 11) (ml . 3) (mc . 10) (mr . 5) (mid-left . 3) (mid-center . 10) (mid-right . 5))) "\
MOD-FUNC is a modification function of the composition.
WIDTH is a number of columns the composition occupies on the screen." nil nil)
-(put 'composition-function-table 'char-table-extra-slots 0)
-
-(defvar composition-function-table (make-char-table (quote composition-function-table)) "\
-Char table of patterns and functions to make a composition.
-
-Each element is nil or an alist of PATTERNs vs FUNCs, where PATTERNs
-are regular expressions and FUNCs are functions. FUNC is responsible
-for composing text matching the corresponding PATTERN. FUNC is called
-with three arguments FROM, TO, and PATTERN. See the function
-`compose-chars-after' for more detail.
-
-This table is looked up by the first character of a composition when
-the composition gets invalid after a change in a buffer.")
(autoload (quote compose-chars-after) "composite" "\
Compose characters in current buffer after position POS.
Optional 2nd arg LIMIT, if non-nil, limits the matching of text.
+Optional 3rd arg OBJECT, if non-nil, is a string that contains the
+text to compose. In that case, POS and LIMIT index to the string.
+
This function is the default value of `compose-chars-after-function'." nil nil)
(autoload (quote compose-last-chars) "composite" "\
;;;***
\f
;;;### (autoloads (shuffle-vector cookie-snarf cookie-insert cookie)
-;;;;;; "cookie1" "play/cookie1.el" (13538 26685))
+;;;;;; "cookie1" "play/cookie1.el" (14747 44775))
;;; Generated autoloads from play/cookie1.el
(autoload (quote cookie) "cookie1" "\
;;;***
\f
;;;### (autoloads (copyright copyright-update) "copyright" "emacs-lisp/copyright.el"
-;;;;;; (14463 42213))
+;;;;;; (14463 42380))
;;; Generated autoloads from emacs-lisp/copyright.el
(autoload (quote copyright-update) "copyright" "\
;;;***
\f
;;;### (autoloads (cperl-mode) "cperl-mode" "progmodes/cperl-mode.el"
-;;;;;; (14456 48530))
+;;;;;; (14839 64809))
;;; Generated autoloads from progmodes/cperl-mode.el
(autoload (quote cperl-mode) "cperl-mode" "\
CPerl mode provides expansion of the Perl control constructs:
- if, else, elsif, unless, while, until, continue, do,
+ if, else, elsif, unless, while, until, continue, do,
for, foreach, formy and foreachmy.
and POD directives (Disabled by default, see `cperl-electric-keywords'.)
type some boolean expression within the parens. Having done that,
typing \\[cperl-linefeed] places you - appropriately indented - on a
new line between the braces (if you typed \\[cperl-linefeed] in a POD
-directive line, then appropriate number of new lines is inserted).
+directive line, then appropriate number of new lines is inserted).
If CPerl decides that you want to insert \"English\" style construct like
and you are on a boundary of a statement inside braces, it will
transform the construct into a multiline and will place you into an
-appropriately indented blank line. If you need a usual
-`newline-and-indent' behaviour, it is on \\[newline-and-indent],
+appropriately indented blank line. If you need a usual
+`newline-and-indent' behaviour, it is on \\[newline-and-indent],
see documentation on `cperl-electric-linefeed'.
Use \\[cperl-invert-if-unless] to change a construction of the form
\\[cperl-info-on-current-command] and \\[cperl-info-on-command] to access it.
These keys run commands `cperl-info-on-current-command' and
`cperl-info-on-command', which one is which is controlled by variable
-`cperl-info-on-command-no-prompt' and `cperl-clobber-lisp-bindings'
+`cperl-info-on-command-no-prompt' and `cperl-clobber-lisp-bindings'
\(in turn affected by `cperl-hairy').
Even if you have no info-format documentation, short one-liner-style
Non-nil means automatically newline before and after braces,
and after colons and semicolons, inserted in Perl code. The following
\\[cperl-electric-backspace] will remove the inserted whitespace.
- Insertion after colons requires both this variable and
- `cperl-auto-newline-after-colon' set.
+ Insertion after colons requires both this variable and
+ `cperl-auto-newline-after-colon' set.
`cperl-auto-newline-after-colon'
Non-nil means automatically newline even after colons.
Subject to `cperl-auto-newline' setting.
\(both available from menu).
If `cperl-indent-level' is 0, the statement after opening brace in
-column 0 is indented on
+column 0 is indented on
`cperl-brace-offset'+`cperl-continued-statement-offset'.
Turning on CPerl mode calls the hooks in the variable `cperl-mode-hook'
;;;***
\f
;;;### (autoloads (cpp-parse-edit cpp-highlight-buffer) "cpp" "progmodes/cpp.el"
-;;;;;; (13826 9529))
+;;;;;; (14726 41840))
;;; Generated autoloads from progmodes/cpp.el
(autoload (quote cpp-highlight-buffer) "cpp" "\
;;;***
\f
;;;### (autoloads (crisp-mode crisp-mode) "crisp" "emulation/crisp.el"
-;;;;;; (14302 38178))
+;;;;;; (14634 20465))
;;; Generated autoloads from emulation/crisp.el
(defvar crisp-mode nil "\
(custom-add-load (quote crisp-mode) (quote crisp))
(autoload (quote crisp-mode) "crisp" "\
-Toggle CRiSP emulation minor mode.
+Toggle CRiSP/Brief emulation minor mode.
With ARG, turn CRiSP mode on if ARG is positive, off otherwise." t nil)
+(defalias (quote brief-mode) (quote crisp-mode))
+
+;;;***
+\f
+;;;### (autoloads (completing-read-multiple) "crm" "emacs-lisp/crm.el"
+;;;;;; (14600 36409))
+;;; Generated autoloads from emacs-lisp/crm.el
+
+(autoload (quote completing-read-multiple) "crm" "\
+Read multiple strings in the minibuffer, with completion.
+By using this functionality, a user may specify multiple strings at a
+single prompt, optionally using completion.
+
+Multiple strings are specified by separating each of the strings with
+a prespecified separator character. For example, if the separator
+character is a comma, the strings 'alice', 'bob', and 'eve' would be
+specified as 'alice,bob,eve'.
+
+The default value for the separator character is the value of
+`crm-default-separator' (comma). The separator character may be
+changed by modifying the value of `crm-separator'.
+
+Continguous strings of non-separator-characters are referred to as
+'elements'. In the aforementioned example, the elements are: 'alice',
+'bob', and 'eve'.
+
+Completion is available on a per-element basis. For example, if the
+contents of the minibuffer are 'alice,bob,eve' and point is between
+'l' and 'i', pressing TAB operates on the element 'alice'.
+
+The return value of this function is a list of the read strings.
+
+See the documentation for `completing-read' for details on the arguments:
+PROMPT, TABLE, PREDICATE, REQUIRE-MATCH, INITIAL-INPUT, HIST, DEF, and
+INHERIT-INPUT-METHOD." nil nil)
+
;;;***
\f
;;;### (autoloads (customize-menu-create custom-menu-create custom-save-all
;;;;;; customize-option-other-window customize-changed-options customize-option
;;;;;; customize-group-other-window customize-group customize customize-save-variable
;;;;;; customize-set-variable customize-set-value) "cus-edit" "cus-edit.el"
-;;;;;; (14552 48684))
+;;;;;; (14847 14322))
;;; Generated autoloads from cus-edit.el
(add-hook 'same-window-regexps "\\`\\*Customiz.*\\*\\'")
;;;***
\f
;;;### (autoloads (custom-set-faces custom-declare-face) "cus-face"
-;;;;;; "cus-face.el" (14505 58892))
+;;;;;; "cus-face.el" (14777 22155))
;;; Generated autoloads from cus-face.el
(autoload (quote custom-declare-face) "cus-face" "\
;;;***
\f
;;;### (autoloads (cvs-status-mode) "cvs-status" "cvs-status.el"
-;;;;;; (14552 48684))
+;;;;;; (14854 32221))
;;; Generated autoloads from cvs-status.el
(autoload (quote cvs-status-mode) "cvs-status" "\
;;;***
\f
;;;### (autoloads (global-cwarn-mode turn-on-cwarn-mode cwarn-mode)
-;;;;;; "cwarn" "progmodes/cwarn.el" (14431 15379))
+;;;;;; "cwarn" "progmodes/cwarn.el" (14746 24125))
;;; Generated autoloads from progmodes/cwarn.el
(autoload (quote cwarn-mode) "cwarn" "\
-Minor mode that hightlight suspicious C and C++ constructions.
+Minor mode that highlights suspicious C and C++ constructions.
Note, in addition to enabling this minor mode, the major mode must
be included in the variable `cwarn-configuration'. By default C and
;;;***
\f
;;;### (autoloads (standard-display-cyrillic-translit cyrillic-encode-alternativnyj-char
-;;;;;; cyrillic-encode-koi8-r-char setup-cyrillic-alternativnyj-environment
-;;;;;; setup-cyrillic-koi8-environment setup-cyrillic-iso-environment)
-;;;;;; "cyril-util" "language/cyril-util.el" (13774 37678))
+;;;;;; cyrillic-encode-koi8-r-char) "cyril-util" "language/cyril-util.el"
+;;;;;; (14623 45987))
;;; Generated autoloads from language/cyril-util.el
-(autoload (quote setup-cyrillic-iso-environment) "cyril-util" "\
-Setup multilingual environment (MULE) for Cyrillic ISO-8859-5 users." t nil)
-
-(autoload (quote setup-cyrillic-koi8-environment) "cyril-util" "\
-Setup multilingual environment (MULE) for Cyrillic KOI8 users." t nil)
-
-(autoload (quote setup-cyrillic-alternativnyj-environment) "cyril-util" "\
-Setup multilingual environment (MULE) for Cyrillic ALTERNATIVNYJ users." t nil)
-
(autoload (quote cyrillic-encode-koi8-r-char) "cyril-util" "\
Return KOI8-R external character code of CHAR if appropriate." nil nil)
;;;***
\f
;;;### (autoloads (dabbrev-expand dabbrev-completion) "dabbrev" "dabbrev.el"
-;;;;;; (14385 24830))
+;;;;;; (14777 22159))
;;; Generated autoloads from dabbrev.el
(define-key esc-map "/" (quote dabbrev-expand))
;;;***
\f
;;;### (autoloads (cancel-debug-on-entry debug-on-entry debug) "debug"
-;;;;;; "emacs-lisp/debug.el" (14547 29510))
+;;;;;; "emacs-lisp/debug.el" (14763 42852))
;;; Generated autoloads from emacs-lisp/debug.el
(setq debugger (quote debug))
;;;***
\f
;;;### (autoloads (decipher-mode decipher) "decipher" "play/decipher.el"
-;;;;;; (13875 47403))
+;;;;;; (14747 44776))
;;; Generated autoloads from play/decipher.el
(autoload (quote decipher) "decipher" "\
;;;***
\f
-;;;### (autoloads (delimit-columns-rectangle delimit-columns-region)
-;;;;;; "delim-col" "delim-col.el" (14345 52903))
+;;;### (autoloads (delimit-columns-rectangle delimit-columns-region
+;;;;;; delimit-columns-customize) "delim-col" "delim-col.el" (14846
+;;;;;; 45911))
;;; Generated autoloads from delim-col.el
+(autoload (quote delimit-columns-customize) "delim-col" "\
+Customization of `columns' group." t nil)
+
(autoload (quote delimit-columns-region) "delim-col" "\
Prettify all columns in a text region.
;;;***
\f
-;;;### (autoloads (delete-selection-mode delete-selection-mode) "delsel"
-;;;;;; "delsel.el" (14410 18534))
+;;;### (autoloads (delete-selection-mode) "delsel" "delsel.el" (14854
+;;;;;; 32221))
;;; Generated autoloads from delsel.el
(defalias (quote pending-delete-mode) (quote delete-selection-mode))
+(defvar delete-selection-mode nil "\
+Toggle Delete-Selection mode on or off.
+See the command `delete-selection-mode' for a description of this minor-mode.
+Setting this variable directly does not take effect;
+use either \\[customize] or the function `delete-selection-mode'.")
+
+(custom-add-to-group (quote editing-basics) (quote delete-selection-mode) (quote custom-variable))
+
+(custom-add-load (quote delete-selection-mode) (quote delsel))
+
(autoload (quote delete-selection-mode) "delsel" "\
Toggle Delete Selection mode.
With prefix ARG, turn Delete Selection mode on if and only if ARG is
active. Otherwise, typed text is just inserted at point regardless of
any selection." t nil)
-(defvar delete-selection-mode nil "\
-Toggle Delete Selection mode.
-See command `delete-selection-mode'.
-Setting this variable directly does not take effect;
-use either \\[customize] or the function `delete-selection-mode'.")
-
-(custom-add-to-group (quote editing-basics) (quote delete-selection-mode) (quote custom-variable))
-
-(custom-add-load (quote delete-selection-mode) (quote delsel))
-
;;;***
\f
;;;### (autoloads (derived-mode-init-mode-variables) "derived" "derived.el"
-;;;;;; (14552 48685))
+;;;;;; (14777 22160))
;;; Generated autoloads from derived.el
(autoload (quote derived-mode-init-mode-variables) "derived" "\
;;;***
\f
;;;### (autoloads (desktop-load-default desktop-read) "desktop" "desktop.el"
-;;;;;; (14495 17963))
+;;;;;; (14823 12922))
;;; Generated autoloads from desktop.el
(autoload (quote desktop-read) "desktop" "\
;;;;;; devanagari-compose-region devanagari-compose-string devanagari-decompose-region
;;;;;; devanagari-decompose-string char-to-glyph-devanagari indian-to-devanagari-string
;;;;;; devanagari-to-indian-region indian-to-devanagari-region devanagari-to-indian
-;;;;;; indian-to-devanagari setup-devanagari-environment) "devan-util"
-;;;;;; "language/devan-util.el" (14423 51006))
+;;;;;; indian-to-devanagari) "devan-util" "language/devan-util.el"
+;;;;;; (14776 10060))
;;; Generated autoloads from language/devan-util.el
-(autoload (quote setup-devanagari-environment) "devan-util" "\
-Setup multilingual environment (MULE) for languages using Devanagari." t nil)
-
(autoload (quote indian-to-devanagari) "devan-util" "\
Convert IS 13194 character CHAR to Devanagari basic characters.
If CHAR is not IS 13194, return CHAR as is." nil nil)
;;;***
\f
;;;### (autoloads (diary-mail-entries diary) "diary-lib" "calendar/diary-lib.el"
-;;;;;; (14523 49787))
+;;;;;; (14821 46405))
;;; Generated autoloads from calendar/diary-lib.el
(autoload (quote diary) "diary-lib" "\
;;;***
\f
;;;### (autoloads (diff-backup diff diff-command diff-switches) "diff"
-;;;;;; "diff.el" (14280 10414))
+;;;;;; "diff.el" (14777 22163))
;;; Generated autoloads from diff.el
(defvar diff-switches "-c" "\
;;;***
\f
;;;### (autoloads (diff-minor-mode diff-mode) "diff-mode" "diff-mode.el"
-;;;;;; (14552 48685))
+;;;;;; (14832 4348))
;;; Generated autoloads from diff-mode.el
(autoload (quote diff-mode) "diff-mode" "\
;;;;;; dired dired-copy-preserve-time dired-dwim-target dired-keep-marker-symlink
;;;;;; dired-keep-marker-hardlink dired-keep-marker-copy dired-keep-marker-rename
;;;;;; dired-trivial-filenames dired-ls-F-marks-symlinks dired-listing-switches)
-;;;;;; "dired" "dired.el" (14522 27392))
+;;;;;; "dired" "dired.el" (14856 13563))
;;; Generated autoloads from dired.el
(defvar dired-listing-switches "-al" "\
;;;***
\f
-;;;### (autoloads (dired-do-query-replace dired-do-search dired-hide-all
-;;;;;; dired-hide-subdir dired-tree-down dired-tree-up dired-kill-subdir
-;;;;;; dired-mark-subdir-files dired-goto-subdir dired-prev-subdir
-;;;;;; dired-insert-subdir dired-maybe-insert-subdir dired-downcase
-;;;;;; dired-upcase dired-do-symlink-regexp dired-do-hardlink-regexp
+;;;### (autoloads (dired-show-file-type dired-do-query-replace-regexp
+;;;;;; dired-do-search dired-hide-all dired-hide-subdir dired-tree-down
+;;;;;; dired-tree-up dired-kill-subdir dired-mark-subdir-files dired-goto-subdir
+;;;;;; dired-prev-subdir dired-insert-subdir dired-maybe-insert-subdir
+;;;;;; dired-downcase dired-upcase dired-do-symlink-regexp dired-do-hardlink-regexp
;;;;;; dired-do-copy-regexp dired-do-rename-regexp dired-do-rename
;;;;;; dired-do-hardlink dired-do-symlink dired-do-copy dired-create-directory
;;;;;; dired-rename-file dired-copy-file dired-relist-file dired-remove-file
;;;;;; dired-do-compress dired-compress-file dired-do-kill-lines
;;;;;; dired-do-shell-command dired-do-print dired-do-chown dired-do-chgrp
;;;;;; dired-do-chmod dired-backup-diff dired-diff) "dired-aux"
-;;;;;; "dired-aux.el" (14506 36592))
+;;;;;; "dired-aux.el" (14812 23964))
;;; Generated autoloads from dired-aux.el
(autoload (quote dired-diff) "dired-aux" "\
Stops when a match is found.
To continue searching for next match, use command \\[tags-loop-continue]." t nil)
-(autoload (quote dired-do-query-replace) "dired-aux" "\
+(autoload (quote dired-do-query-replace-regexp) "dired-aux" "\
Do `query-replace-regexp' of FROM with TO, on all marked files.
Third arg DELIMITED (prefix arg) means replace only word-delimited matches.
If you exit (\\[keyboard-quit] or ESC), you can resume the query replace
with the command \\[tags-loop-continue]." t nil)
+(autoload (quote dired-show-file-type) "dired-aux" "\
+Print the type of FILE, according to the `file' command.
+If FILE is a symbolic link and the optional argument DEREF-SYMLINKS is
+true then the type of the file linked to by FILE is printed instead." t nil)
+
;;;***
\f
-;;;### (autoloads (dired-jump) "dired-x" "dired-x.el" (14523 40402))
+;;;### (autoloads (dired-jump) "dired-x" "dired-x.el" (14777 22168))
;;; Generated autoloads from dired-x.el
(autoload (quote dired-jump) "dired-x" "\
;;;***
\f
-;;;### (autoloads (dirtrack) "dirtrack" "dirtrack.el" (14032 30315))
+;;;### (autoloads (dirtrack) "dirtrack" "dirtrack.el" (14831 12714))
;;; Generated autoloads from dirtrack.el
(autoload (quote dirtrack) "dirtrack" "\
;;;;;; standard-display-graphic 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" (14353 44070))
+;;;;;; make-display-table) "disp-table" "disp-table.el" (14777 22181))
;;; Generated autoloads from disp-table.el
(autoload (quote make-display-table) "disp-table" "\
(autoload (quote standard-display-underline) "disp-table" "\
Display character C as character UC plus underlining." nil nil)
-(autoload (quote create-glyph) "disp-table" nil nil nil)
+(autoload (quote create-glyph) "disp-table" "\
+Allocate a glyph code to display by sending STRING to the terminal." nil nil)
(autoload (quote standard-display-european) "disp-table" "\
Semi-obsolete way to toggle display of ISO 8859 European characters.
;;;***
\f
-;;;### (autoloads (doctor) "doctor" "play/doctor.el" (13556 41573))
+;;;### (autoloads (doctor) "doctor" "play/doctor.el" (14831 613))
;;; Generated autoloads from play/doctor.el
(autoload (quote doctor) "doctor" "\
;;;***
\f
;;;### (autoloads (double-mode double-mode) "double" "double.el"
-;;;;;; (14288 20375))
+;;;;;; (14777 22183))
;;; Generated autoloads from double.el
(defvar double-mode nil "\
;;;***
\f
;;;### (autoloads (gnus-earcon-display) "earcon" "gnus/earcon.el"
-;;;;;; (14030 48685))
+;;;;;; (14855 56553))
;;; Generated autoloads from gnus/earcon.el
(autoload (quote gnus-earcon-display) "earcon" "\
;;;***
\f
;;;### (autoloads (define-derived-mode easy-mmode-defsyntax easy-mmode-defmap
-;;;;;; define-minor-mode) "easy-mmode" "emacs-lisp/easy-mmode.el"
-;;;;;; (14552 48943))
+;;;;;; easy-mmode-define-keymap easy-mmode-define-global-mode define-minor-mode)
+;;;;;; "easy-mmode" "emacs-lisp/easy-mmode.el" (14850 36349))
;;; Generated autoloads from emacs-lisp/easy-mmode.el
(defalias (quote easy-mmode-define-minor-mode) (quote define-minor-mode))
(autoload (quote define-minor-mode) "easy-mmode" "\
Define a new minor mode MODE.
-This function defines the associated control variable, keymap,
-toggle command, and hooks (see `easy-mmode-define-toggle').
+This function defines the associated control variable MODE, keymap MODE-map,
+toggle command MODE, and hook MODE-hook.
DOC is the documentation for the mode toggle command.
Optional INIT-VALUE is the initial value of the mode's variable.
-Optional LIGHTER is displayed in the mode-bar when the mode is on.
+Optional LIGHTER is displayed in the modeline when the mode is on.
Optional KEYMAP is the default (defvar) keymap bound to the mode keymap.
-If it is a list, it is passed to `easy-mmode-define-keymap'
-in order to build a valid keymap.
+ If it is a list, it is passed to `easy-mmode-define-keymap'
+ in order to build a valid keymap. It's generally better to use
+ a separate MODE-map variable than to use this argument.
+The above three arguments can be skipped if keyword arguments are
+used (see below).
+
BODY contains code that will be executed each time the mode is (dis)activated.
-It will be executed after any toggling but before running the hooks." nil (quote macro))
+ It will be executed after any toggling but before running the hooks.
+ BODY can start with a list of CL-style keys specifying additional arguments.
+ The following keyword arguments are supported:
+:group Followed by the group name to use for any generated `defcustom'.
+:global If non-nil specifies that the minor mode is not meant to be
+ buffer-local. By default, the variable is made buffer-local.
+:init-value Same as the INIT-VALUE argument.
+:lighter Same as the LIGHTER argument." nil (quote macro))
+
+(autoload (quote easy-mmode-define-global-mode) "easy-mmode" "\
+Make GLOBAL-MODE out of the buffer-local minor MODE.
+TURN-ON is a function that will be called with no args in every buffer
+ and that should try to turn MODE on if applicable for that buffer.
+KEYS is a list of CL-style keyword arguments:
+:group to specify the custom group." nil (quote macro))
+
+(autoload (quote easy-mmode-define-keymap) "easy-mmode" "\
+Return a keymap built from bindings BS.
+BS must be a list of (KEY . BINDING) where
+KEY and BINDINGS are suitable for `define-key'.
+Optional NAME is passed to `make-sparse-keymap'.
+Optional map M can be used to modify an existing map.
+ARGS is a list of additional arguments." nil nil)
(autoload (quote easy-mmode-defmap) "easy-mmode" nil nil (quote macro))
-(autoload (quote easy-mmode-defsyntax) "easy-mmode" nil nil (quote macro))
+(autoload (quote easy-mmode-defsyntax) "easy-mmode" "\
+Define variable ST as a syntax-table.
+CSS contains a list of syntax specifications of the form (CHAR . SYNTAX).
+" nil (quote macro))
(autoload (quote define-derived-mode) "easy-mmode" "\
Create a new mode as a variant of an existing mode.
;;;***
\f
;;;### (autoloads (easy-menu-change easy-menu-create-menu easy-menu-do-define
-;;;;;; easy-menu-define) "easymenu" "emacs-lisp/easymenu.el" (14385
-;;;;;; 24854))
+;;;;;; easy-menu-define) "easymenu" "emacs-lisp/easymenu.el" (14702
+;;;;;; 63698))
;;; Generated autoloads from emacs-lisp/easymenu.el
(autoload (quote easy-menu-define) "easymenu" "\
:key-sequence KEYS
-KEYS is nil a string or a vector; nil or a keyboard equivalent to this
+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' first display of
a menu. Use `:key-sequence nil' when you know that this menu item has no
keyboard equivalent.
INCLUDE is an expression; this item is only visible if this
expression has a non-nil value.
- :suffix NAME
+ :suffix FORM
-NAME is a string; the name of an argument to CALLBACK.
+FORM is an expression that will be dynamically evaluated and whose
+value will be concatenated to the menu entry's NAME.
:style STYLE
Prepend the name with `(*) ' or `( ) ' depending on if selected or not.
radio: A radio button.
Prepend the name with `[X] ' or `[ ] ' depending on if selected or not.
-button: Surround the name with `[' and `]'. Use this for an item in the
+button: Surround the name with `[' and `]'. Use this for an item in the
menu bar itself.
anything else means an ordinary menu item.
SELECTED is an expression; the checkbox or radio button is selected
whenever this expression's value is non-nil.
+ :help HELP
+
+HELP is a string, the help to display for the menu item.
+
A menu item can be a string. Then that string appears in the menu as
unselectable text. A string consisting solely of hyphens is displayed
as a solid horizontal line.
;;;;;; ebnf-apply-style ebnf-merge-style ebnf-insert-style ebnf-setup
;;;;;; ebnf-syntax-region ebnf-syntax-buffer ebnf-eps-region ebnf-eps-buffer
;;;;;; ebnf-spool-region ebnf-spool-buffer ebnf-print-region ebnf-print-buffer
-;;;;;; ebnf-customize) "ebnf2ps" "progmodes/ebnf2ps.el" (14485 59667))
+;;;;;; ebnf-customize) "ebnf2ps" "progmodes/ebnf2ps.el" (14763 39810))
;;; Generated autoloads from progmodes/ebnf2ps.el
(autoload (quote ebnf-customize) "ebnf2ps" "\
It returns the old style symbol." t nil)
+;;;***
+\f
+;;;### (autoloads (ebrowse-save-tree-as ebrowse-tags-query-replace
+;;;;;; ebrowse-tags-loop-continue ebrowse-tags-complete-symbol ebrowse-electric-choose-tree
+;;;;;; ebrowse-tree-mode) "ebrowse" "progmodes/ebrowse.el" (14727
+;;;;;; 65050))
+;;; Generated autoloads from progmodes/ebrowse.el
+
+(autoload (quote ebrowse-tree-mode) "ebrowse" "\
+Major mode for Ebrowse class tree buffers.
+Each line corresponds to a class in a class tree.
+Letters do not insert themselves, they are commands.
+File operations in the tree buffer work on class tree data structures.
+E.g.\\[save-buffer] writes the tree to the file it was loaded from.
+
+Tree mode key bindings:
+\\{ebrowse-tree-mode-map}" t nil)
+
+(autoload (quote ebrowse-electric-choose-tree) "ebrowse" "\
+Return a buffer containing a tree or nil if no tree found or canceled." t nil)
+
+(autoload (quote ebrowse-tags-complete-symbol) "ebrowse" "\
+Perform completion on the C++ symbol preceding point.
+A second call of this function without changing point inserts the next match.
+A call with prefix PREFIX reads the symbol to insert from the minibuffer with
+completion." t nil)
+
+(autoload (quote ebrowse-tags-loop-continue) "ebrowse" "\
+Repeat last operation on files in tree.
+FIRST-TIME non-nil means this is not a repetition, but the first time.
+TREE-BUFFER if indirectly specifies which files to loop over." t nil)
+
+(autoload (quote ebrowse-tags-query-replace) "ebrowse" "\
+Query replace FROM with TO in all files of a class tree.
+With prefix arg, process files of marked classes only." t nil)
+
+(autoload (quote ebrowse-save-tree-as) "ebrowse" "\
+Write the current tree data structure to a file.
+Read the file name from the minibuffer if interactive.
+Otherwise, FILE-NAME specifies the file to save the tree in." t nil)
+
;;;***
\f
;;;### (autoloads (electric-buffer-list) "ebuff-menu" "ebuff-menu.el"
-;;;;;; (13778 5499))
+;;;;;; (14783 15355))
;;; Generated autoloads from ebuff-menu.el
(autoload (quote electric-buffer-list) "ebuff-menu" "\
;;;***
\f
;;;### (autoloads (Electric-command-history-redo-expression) "echistory"
-;;;;;; "echistory.el" (14447 15307))
+;;;;;; "echistory.el" (14777 22184))
;;; Generated autoloads from echistory.el
(autoload (quote Electric-command-history-redo-expression) "echistory" "\
;;;***
\f
;;;### (autoloads (edebug-eval-top-level-form def-edebug-spec edebug-all-forms
-;;;;;; edebug-all-defs) "edebug" "emacs-lisp/edebug.el" (14482 54435))
+;;;;;; edebug-all-defs) "edebug" "emacs-lisp/edebug.el" (14821 31350))
;;; Generated autoloads from emacs-lisp/edebug.el
(defvar edebug-all-defs nil "\
;;;;;; ediff-merge-directory-revisions ediff-merge-directories-with-ancestor
;;;;;; ediff-merge-directories ediff-directories3 ediff-directory-revisions
;;;;;; ediff-directories ediff-buffers3 ediff-buffers ediff-files3
-;;;;;; ediff-files) "ediff" "ediff.el" (14522 27408))
+;;;;;; ediff-files) "ediff" "ediff.el" (14845 20843))
;;; Generated autoloads from ediff.el
(autoload (quote ediff-files) "ediff" "\
;;;***
\f
;;;### (autoloads (ediff-customize) "ediff-help" "ediff-help.el"
-;;;;;; (14522 27392))
+;;;;;; (14777 22188))
;;; Generated autoloads from ediff-help.el
(autoload (quote ediff-customize) "ediff-help" nil t nil)
;;;***
\f
-;;;### (autoloads nil "ediff-hook" "ediff-hook.el" (14367 2123))
+;;;### (autoloads nil "ediff-hook" "ediff-hook.el" (14777 22189))
;;; Generated autoloads from ediff-hook.el
(defvar ediff-window-setup-function)
-(progn (defun ediff-xemacs-init-menus nil (if (featurep (quote menubar)) (progn (add-submenu (quote ("Tools")) ediff-menu "OO-Browser...") (add-submenu (quote ("Tools")) ediff-merge-menu "OO-Browser...") (add-submenu (quote ("Tools")) epatch-menu "OO-Browser...") (add-submenu (quote ("Tools")) ediff-misc-menu "OO-Browser...") (add-menu-button (quote ("Tools")) ["-------" nil nil] "OO-Browser...")))))
+(defun ediff-xemacs-init-menus nil (if (featurep (quote menubar)) (progn (add-submenu (quote ("Tools")) ediff-menu "OO-Browser...") (add-submenu (quote ("Tools")) ediff-merge-menu "OO-Browser...") (add-submenu (quote ("Tools")) epatch-menu "OO-Browser...") (add-submenu (quote ("Tools")) ediff-misc-menu "OO-Browser...") (add-menu-button (quote ("Tools")) ["-------" nil nil] "OO-Browser..."))))
(cond ((string-match "XEmacs" emacs-version) (defvar ediff-menu (quote ("Compare" ["Two Files..." ediff-files t] ["Two Buffers..." ediff-buffers t] ["Three Files..." ediff-files3 t] ["Three Buffers..." ediff-buffers3 t] "---" ["Two Directories..." ediff-directories t] ["Three Directories..." ediff-directories3 t] "---" ["File with Revision..." ediff-revision t] ["Directory Revisions..." ediff-directory-revisions t] "---" ["Windows Word-by-word..." ediff-windows-wordwise t] ["Windows Line-by-line..." ediff-windows-linewise t] "---" ["Regions Word-by-word..." ediff-regions-wordwise t] ["Regions Line-by-line..." ediff-regions-linewise t]))) (defvar ediff-merge-menu (quote ("Merge" ["Files..." ediff-merge-files t] ["Files with Ancestor..." ediff-merge-files-with-ancestor t] ["Buffers..." ediff-merge-buffers t] ["Buffers with Ancestor..." ediff-merge-buffers-with-ancestor t] "---" ["Directories..." ediff-merge-directories t] ["Directories with Ancestor..." ediff-merge-directories-with-ancestor t] "---" ["Revisions..." ediff-merge-revisions t] ["Revisions with Ancestor..." ediff-merge-revisions-with-ancestor t] ["Directory Revisions..." ediff-merge-directory-revisions t] ["Directory Revisions with Ancestor..." ediff-merge-directory-revisions-with-ancestor t]))) (defvar epatch-menu (quote ("Apply Patch" ["To a file..." ediff-patch-file t] ["To a buffer..." ediff-patch-buffer t]))) (defvar ediff-misc-menu (quote ("Ediff Miscellanea" ["Ediff Manual..." ediff-documentation t] ["Customize Ediff..." ediff-customize t] ["List Ediff Sessions..." ediff-show-registry t] ["Use separate frame for Ediff control buffer..." ediff-toggle-multiframe :style toggle :selected (if (and (featurep (quote ediff-util)) (boundp (quote ediff-window-setup-function))) (eq ediff-window-setup-function (quote ediff-setup-windows-multiframe)))] ["Use a toolbar with Ediff control buffer" ediff-toggle-use-toolbar :style toggle :selected (if (featurep (quote ediff-tbar)) (ediff-use-toolbar-p))]))) (if (and (featurep (quote menubar)) (not (featurep (quote infodock))) (not (featurep (quote ediff-hook)))) (ediff-xemacs-init-menus))) ((featurep (quote menu-bar)) (defvar menu-bar-ediff-misc-menu (make-sparse-keymap "Ediff Miscellanea")) (fset (quote menu-bar-ediff-misc-menu) (symbol-value (quote menu-bar-ediff-misc-menu))) (defvar menu-bar-epatch-menu (make-sparse-keymap "Apply Patch")) (fset (quote menu-bar-epatch-menu) (symbol-value (quote menu-bar-epatch-menu))) (defvar menu-bar-ediff-merge-menu (make-sparse-keymap "Merge")) (fset (quote menu-bar-ediff-merge-menu) (symbol-value (quote menu-bar-ediff-merge-menu))) (defvar menu-bar-ediff-menu (make-sparse-keymap "Compare")) (fset (quote menu-bar-ediff-menu) (symbol-value (quote menu-bar-ediff-menu))) (define-key menu-bar-ediff-menu [window] (quote ("This Window and Next Window" . compare-windows))) (define-key menu-bar-ediff-menu [ediff-windows-linewise] (quote ("Windows Line-by-line..." . ediff-windows-linewise))) (define-key menu-bar-ediff-menu [ediff-windows-wordwise] (quote ("Windows Word-by-word..." . ediff-windows-wordwise))) (define-key menu-bar-ediff-menu [separator-ediff-windows] (quote ("--"))) (define-key menu-bar-ediff-menu [ediff-regions-linewise] (quote ("Regions Line-by-line..." . ediff-regions-linewise))) (define-key menu-bar-ediff-menu [ediff-regions-wordwise] (quote ("Regions Word-by-word..." . ediff-regions-wordwise))) (define-key menu-bar-ediff-menu [separator-ediff-regions] (quote ("--"))) (define-key menu-bar-ediff-menu [ediff-dir-revision] (quote ("Directory Revisions..." . ediff-directory-revisions))) (define-key menu-bar-ediff-menu [ediff-revision] (quote ("File with Revision..." . ediff-revision))) (define-key menu-bar-ediff-menu [separator-ediff-directories] (quote ("--"))) (define-key menu-bar-ediff-menu [ediff-directories3] (quote ("Three Directories..." . ediff-directories3))) (define-key menu-bar-ediff-menu [ediff-directories] (quote ("Two Directories..." . ediff-directories))) (define-key menu-bar-ediff-menu [separator-ediff-files] (quote ("--"))) (define-key menu-bar-ediff-menu [ediff-buffers3] (quote ("Three Buffers..." . ediff-buffers3))) (define-key menu-bar-ediff-menu [ediff-files3] (quote ("Three Files..." . ediff-files3))) (define-key menu-bar-ediff-menu [ediff-buffers] (quote ("Two Buffers..." . ediff-buffers))) (define-key menu-bar-ediff-menu [ediff-files] (quote ("Two Files..." . ediff-files))) (define-key menu-bar-ediff-merge-menu [ediff-merge-dir-revisions-with-ancestor] (quote ("Directory Revisions with Ancestor..." . ediff-merge-directory-revisions-with-ancestor))) (define-key menu-bar-ediff-merge-menu [ediff-merge-dir-revisions] (quote ("Directory Revisions..." . ediff-merge-directory-revisions))) (define-key menu-bar-ediff-merge-menu [ediff-merge-revisions-with-ancestor] (quote ("Revisions with Ancestor..." . ediff-merge-revisions-with-ancestor))) (define-key menu-bar-ediff-merge-menu [ediff-merge-revisions] (quote ("Revisions..." . ediff-merge-revisions))) (define-key menu-bar-ediff-merge-menu [separator-ediff-merge] (quote ("--"))) (define-key menu-bar-ediff-merge-menu [ediff-merge-directories-with-ancestor] (quote ("Directories with Ancestor..." . ediff-merge-directories-with-ancestor))) (define-key menu-bar-ediff-merge-menu [ediff-merge-directories] (quote ("Directories..." . ediff-merge-directories))) (define-key menu-bar-ediff-merge-menu [separator-ediff-merge-dirs] (quote ("--"))) (define-key menu-bar-ediff-merge-menu [ediff-merge-buffers-with-ancestor] (quote ("Buffers with Ancestor..." . ediff-merge-buffers-with-ancestor))) (define-key menu-bar-ediff-merge-menu [ediff-merge-buffers] (quote ("Buffers..." . ediff-merge-buffers))) (define-key menu-bar-ediff-merge-menu [ediff-merge-files-with-ancestor] (quote ("Files with Ancestor..." . ediff-merge-files-with-ancestor))) (define-key menu-bar-ediff-merge-menu [ediff-merge-files] (quote ("Files..." . ediff-merge-files))) (define-key menu-bar-epatch-menu [ediff-patch-buffer] (quote ("To a Buffer..." . ediff-patch-buffer))) (define-key menu-bar-epatch-menu [ediff-patch-file] (quote ("To a File..." . ediff-patch-file))) (define-key menu-bar-ediff-misc-menu [emultiframe] (quote ("Toggle use of separate control buffer frame..." . ediff-toggle-multiframe))) (define-key menu-bar-ediff-misc-menu [eregistry] (quote ("List Ediff Sessions..." . ediff-show-registry))) (define-key menu-bar-ediff-misc-menu [ediff-cust] (quote ("Customize Ediff..." . ediff-customize))) (define-key menu-bar-ediff-misc-menu [ediff-doc] (quote ("Ediff Manual..." . ediff-documentation)))))
;;;***
\f
;;;### (autoloads (ediff-show-registry) "ediff-mult" "ediff-mult.el"
-;;;;;; (14398 37488))
+;;;;;; (14845 20842))
;;; Generated autoloads from ediff-mult.el
(autoload (quote ediff-show-registry) "ediff-mult" "\
;;;***
\f
;;;### (autoloads (ediff-toggle-use-toolbar ediff-toggle-multiframe)
-;;;;;; "ediff-util" "ediff-util.el" (14367 2134))
+;;;;;; "ediff-util" "ediff-util.el" (14845 20843))
;;; Generated autoloads from ediff-util.el
(autoload (quote 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"
-;;;;;; (13957 59893))
+;;;;;; (14777 22205))
;;; Generated autoloads from edmacro.el
(define-key ctl-x-map "\C-k" 'edit-kbd-macro)
;;;***
\f
;;;### (autoloads (electric-helpify with-electric-help) "ehelp" "ehelp.el"
-;;;;;; (13116 19762))
+;;;;;; (14793 26118))
;;; Generated autoloads from ehelp.el
(autoload (quote with-electric-help) "ehelp" "\
this value is non-nil.
If THUNK returns nil, we display BUFFER starting at the top, and
-shrink the window to fit. If THUNK returns non-nil, we don't do those
-things.
+shrink the window to fit if `electric-help-shrink-window' is non-nil.
+If THUNK returns non-nil, we don't do those things.
When the user exits (with `electric-help-exit', or otherwise) the help
buffer's window disappears (i.e., we use `save-window-excursion')
;;;***
\f
-;;;### (autoloads (turn-on-eldoc-mode eldoc-mode eldoc-mode) "eldoc"
-;;;;;; "emacs-lisp/eldoc.el" (13881 39947))
+;;;### (autoloads (turn-on-eldoc-mode eldoc-mode eldoc-minor-mode-string
+;;;;;; eldoc-mode) "eldoc" "emacs-lisp/eldoc.el" (14716 17385))
;;; Generated autoloads from emacs-lisp/eldoc.el
(defvar eldoc-mode nil "\
This variable is buffer-local.")
+(defvar eldoc-minor-mode-string " ElDoc" "\
+*String to display in mode line when Eldoc Mode is enabled.")
+
+(cond ((fboundp (quote add-minor-mode)) (add-minor-mode (quote eldoc-mode) (quote eldoc-minor-mode-string))) ((assq (quote eldoc-mode) (default-value (quote minor-mode-alist)))) (t (setq-default minor-mode-alist (append (default-value (quote minor-mode-alist)) (quote ((eldoc-mode eldoc-minor-mode-string)))))))
+
(autoload (quote eldoc-mode) "eldoc" "\
*Enable or disable eldoc mode.
See documentation for the variable of the same name for more details.
;;;***
\f
-;;;### (autoloads (elide-head) "elide-head" "elide-head.el" (14495
-;;;;;; 17971))
+;;;### (autoloads (elide-head) "elide-head" "elide-head.el" (14777
+;;;;;; 22205))
;;; Generated autoloads from elide-head.el
(autoload (quote elide-head) "elide-head" "\
;;;***
\f
-;;;### (autoloads (elp-submit-bug-report elp-results elp-instrument-package
-;;;;;; elp-instrument-list elp-restore-function elp-instrument-function)
-;;;;;; "elp" "emacs-lisp/elp.el" (13578 6553))
+;;;### (autoloads (elp-results elp-instrument-package elp-instrument-list
+;;;;;; elp-instrument-function) "elp" "emacs-lisp/elp.el" (14849
+;;;;;; 20130))
;;; Generated autoloads from emacs-lisp/elp.el
(autoload (quote elp-instrument-function) "elp" "\
Instrument FUNSYM for profiling.
FUNSYM must be a symbol of a defined function." t nil)
-(autoload (quote elp-restore-function) "elp" "\
-Restore an instrumented function to its original definition.
-Argument FUNSYM is the symbol of a defined function." t nil)
-
(autoload (quote elp-instrument-list) "elp" "\
Instrument for profiling, all functions in `elp-function-list'.
Use optional LIST if provided instead." t nil)
information for all instrumented functions are reset after results are
displayed." t nil)
-(autoload (quote elp-submit-bug-report) "elp" "\
-Submit via mail, a bug report on elp." t nil)
-
;;;***
\f
;;;### (autoloads (report-emacs-bug) "emacsbug" "mail/emacsbug.el"
-;;;;;; (13649 21996))
+;;;;;; (14850 36350))
;;; Generated autoloads from mail/emacsbug.el
(autoload (quote report-emacs-bug) "emacsbug" "\
;;;;;; 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"
-;;;;;; "emerge.el" (14345 52903))
+;;;;;; "emerge.el" (14777 22209))
;;; Generated autoloads from emerge.el
(defvar menu-bar-emerge-menu (make-sparse-keymap "Emerge"))
;;;***
\f
;;;### (autoloads (encoded-kbd-mode) "encoded-kb" "international/encoded-kb.el"
-;;;;;; (14516 181))
+;;;;;; (14642 24031))
;;; Generated autoloads from international/encoded-kb.el
(autoload (quote encoded-kbd-mode) "encoded-kb" "\
;;;***
\f
;;;### (autoloads (enriched-decode enriched-encode enriched-mode)
-;;;;;; "enriched" "enriched.el" (14539 53665))
+;;;;;; "enriched" "enriched.el" (14777 22210))
;;; Generated autoloads from enriched.el
(autoload (quote enriched-mode) "enriched" "\
;;;***
\f
-;;;### (autoloads (setenv) "env" "env.el" (13582 12516))
-;;; Generated autoloads from env.el
+;;;### (autoloads (eshell-mode) "esh-mode" "eshell/esh-mode.el" (14845
+;;;;;; 20873))
+;;; Generated autoloads from eshell/esh-mode.el
+
+(autoload (quote eshell-mode) "esh-mode" "\
+Emacs shell interactive mode.
+
+\\{eshell-mode-map}" nil nil)
+
+;;;***
+\f
+;;;### (autoloads (eshell-test) "esh-test" "eshell/esh-test.el" (14845
+;;;;;; 20873))
+;;; Generated autoloads from eshell/esh-test.el
+
+(autoload (quote eshell-test) "esh-test" "\
+Test Eshell to verify that it works as expected." t nil)
+
+;;;***
+\f
+;;;### (autoloads (eshell-report-bug eshell-command-result eshell-command
+;;;;;; eshell) "eshell" "eshell/eshell.el" (14823 12923))
+;;; Generated autoloads from eshell/eshell.el
+
+(autoload (quote 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 new session is always created if the the prefix
+argument ARG is specified. Returns the buffer selected (or created)." t nil)
-(autoload (quote setenv) "env" "\
-Set the value of the environment variable named VARIABLE to VALUE.
-VARIABLE should be a string. VALUE is optional; if not provided or is
-`nil', the environment variable VARIABLE will be removed.
+(autoload (quote eshell-command) "eshell" "\
+Execute the Eshell command string COMMAND.
+With prefix ARG, insert output into the current buffer at point." t nil)
-Interactively, a prefix argument means to unset the variable.
-Interactively, the current value (if any) of the variable
-appears at the front of the history list when you type in the new value.
+(autoload (quote eshell-command-result) "eshell" "\
+Execute the given Eshell COMMAND, and return the result.
+The result might be any Lisp object.
+If STATUS-VAR is a symbol, it will be set to the exit status of the
+command. This is the only way to determine whether the value returned
+corresponding to a successful execution." nil nil)
-This function works by modifying `process-environment'." t nil)
+(autoload (quote eshell-report-bug) "eshell" "\
+Report a bug in Eshell.
+Prompts for the TOPIC. Leaves you in a mail buffer.
+Please include any configuration details that might be involved." t nil)
;;;***
\f
;;;;;; pop-tag-mark find-tag-regexp find-tag-other-frame find-tag-other-window
;;;;;; find-tag find-tag-noselect tags-table-files visit-tags-table
;;;;;; find-tag-default-function find-tag-hook tags-add-tables tags-table-list
-;;;;;; tags-case-fold-search) "etags" "progmodes/etags.el" (14551
-;;;;;; 24244))
+;;;;;; tags-case-fold-search) "etags" "progmodes/etags.el" (14821
+;;;;;; 31354))
;;; Generated autoloads from progmodes/etags.el
(defvar tags-file-name nil "\
See documentation of variable `tags-file-name'." t nil)
(autoload (quote tags-query-replace) "etags" "\
-Query-replace-regexp FROM with TO through all files listed in tags table.
+`Query-replace-regexp' FROM with TO through all files listed in tags table.
Third arg DELIMITED (prefix arg) means replace only word-delimited matches.
If you exit (\\[keyboard-quit] or ESC), you can resume the query-replace
with the command \\[tags-loop-continue].
;;;;;; ethio-fidel-to-sera-marker ethio-fidel-to-sera-mail ethio-fidel-to-sera-mail-or-marker
;;;;;; ethio-fidel-to-sera-buffer ethio-fidel-to-sera-region ethio-sera-to-fidel-marker
;;;;;; ethio-sera-to-fidel-mail ethio-sera-to-fidel-mail-or-marker
-;;;;;; ethio-sera-to-fidel-buffer ethio-sera-to-fidel-region setup-ethiopic-environment-internal
-;;;;;; setup-ethiopic-environment) "ethio-util" "language/ethio-util.el"
-;;;;;; (14180 44101))
+;;;;;; ethio-sera-to-fidel-buffer ethio-sera-to-fidel-region setup-ethiopic-environment-internal)
+;;;;;; "ethio-util" "language/ethio-util.el" (14623 45988))
;;; Generated autoloads from language/ethio-util.el
-(autoload (quote setup-ethiopic-environment) "ethio-util" "\
-Setup multilingual environment for Ethiopic." nil nil)
-
(autoload (quote setup-ethiopic-environment-internal) "ethio-util" nil nil nil)
(autoload (quote ethio-sera-to-fidel-region) "ethio-util" "\
\f
;;;### (autoloads (eudc-load-eudc eudc-query-form eudc-expand-inline
;;;;;; eudc-get-phone eudc-get-email eudc-set-server) "eudc" "net/eudc.el"
-;;;;;; (14463 3149))
+;;;;;; (14463 4091))
;;; Generated autoloads from net/eudc.el
(autoload (quote eudc-set-server) "eudc" "\
\f
;;;### (autoloads (eudc-display-jpeg-as-button eudc-display-jpeg-inline
;;;;;; eudc-display-sound eudc-display-url eudc-display-generic-binary)
-;;;;;; "eudc-bob" "net/eudc-bob.el" (14461 51599))
+;;;;;; "eudc-bob" "net/eudc-bob.el" (14461 55579))
;;; Generated autoloads from net/eudc-bob.el
(autoload (quote 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" (14460 58168))
+;;;;;; "eudc-export" "net/eudc-export.el" (14460 59510))
;;; Generated autoloads from net/eudc-export.el
(autoload (quote eudc-insert-record-at-point-into-bbdb) "eudc-export" "\
;;;***
\f
;;;### (autoloads (eudc-edit-hotlist) "eudc-hotlist" "net/eudc-hotlist.el"
-;;;;;; (14460 58176))
+;;;;;; (14460 59510))
;;; Generated autoloads from net/eudc-hotlist.el
(autoload (quote eudc-edit-hotlist) "eudc-hotlist" "\
;;;***
\f
-;;;### (autoloads (executable-self-display executable-set-magic)
-;;;;;; "executable" "progmodes/executable.el" (13940 33734))
+;;;### (autoloads (executable-make-buffer-file-executable-if-script-p
+;;;;;; executable-self-display executable-set-magic executable-find)
+;;;;;; "executable" "progmodes/executable.el" (14764 17652))
;;; Generated autoloads from progmodes/executable.el
+(autoload (quote executable-find) "executable" "\
+Search for COMMAND in exec-path and return the absolute file name.
+Return nil if COMMAND is not found anywhere in `exec-path'." nil nil)
+
(autoload (quote executable-set-magic) "executable" "\
Set this buffer's interpreter to INTERPRETER with optional ARGUMENT.
The variables `executable-magicless-file-regexp', `executable-prefix',
Turn a text file into a self-displaying Un*x command.
The magic number of such a command displays all lines but itself." t nil)
+(autoload (quote executable-make-buffer-file-executable-if-script-p) "executable" "\
+Make file executable according to umask if not already executable.
+If file already has any execute bits set at all, do not change existing
+file modes." nil nil)
+
;;;***
\f
;;;### (autoloads (expand-jump-to-next-slot expand-jump-to-previous-slot
-;;;;;; expand-add-abbrevs) "expand" "expand.el" (14443 18506))
+;;;;;; expand-add-abbrevs) "expand" "expand.el" (14777 22210))
;;; Generated autoloads from expand.el
(autoload (quote expand-add-abbrevs) "expand" "\
;;;***
\f
-;;;### (autoloads (f90-mode) "f90" "progmodes/f90.el" (14546 35423))
+;;;### (autoloads (f90-mode) "f90" "progmodes/f90.el" (14624 3716))
;;; Generated autoloads from progmodes/f90.el
(autoload (quote f90-mode) "f90" "\
;;;;;; facemenu-remove-special facemenu-remove-all facemenu-remove-face-props
;;;;;; facemenu-set-read-only facemenu-set-intangible facemenu-set-invisible
;;;;;; facemenu-set-face-from-menu facemenu-set-background facemenu-set-foreground
-;;;;;; facemenu-set-face) "facemenu" "facemenu.el" (14539 53665))
+;;;;;; facemenu-set-face) "facemenu" "facemenu.el" (14777 22211))
;;; Generated autoloads from facemenu.el
(define-key global-map "\M-g" 'facemenu-keymap)
(autoload 'facemenu-keymap "facemenu" "Keymap for face-changing commands." t 'keymap)
(defalias (quote facemenu-foreground-menu) facemenu-foreground-menu)
(defvar facemenu-background-menu (let ((map (make-sparse-keymap "Background Color"))) (define-key map "o" (cons "Other..." (quote facemenu-set-background))) map) "\
-Menu keymap for background colors")
+Menu keymap for background colors.")
(defalias (quote facemenu-background-menu) facemenu-background-menu)
typing a character to insert cancels the specification." t nil)
(autoload (quote facemenu-set-foreground) "facemenu" "\
-Set the foreground color of the region or next character typed.
+Set the foreground COLOR of the region or next character typed.
The color is prompted for. A face named `fg:color' is used (or created).
If the region is active, it will be set to the requested face. If
it is inactive (even if mark-even-if-inactive is set) the next
typing a character cancels the request." t nil)
(autoload (quote facemenu-set-background) "facemenu" "\
-Set the background color of the region or next character typed.
+Set the background COLOR of the region or next character typed.
The color is prompted for. A face named `bg:color' is used (or created).
If the region is active, it will be set to the requested face. If
it is inactive (even if mark-even-if-inactive is set) the next
typing a character cancels the request." t nil)
(autoload (quote facemenu-set-face-from-menu) "facemenu" "\
-Set the face of the region or next character typed.
+Set the FACE of the region or next character typed.
This function is designed to be called from a menu; the face to use
is the menu item's name.
\f
;;;### (autoloads (feedmail-queue-reminder feedmail-run-the-queue
;;;;;; feedmail-run-the-queue-global-prompt feedmail-run-the-queue-no-prompts)
-;;;;;; "feedmail" "mail/feedmail.el" (14415 45092))
+;;;;;; "feedmail" "mail/feedmail.el" (14415 51114))
;;; Generated autoloads from mail/feedmail.el
(autoload (quote feedmail-run-the-queue-no-prompts) "feedmail" "\
;;;***
\f
;;;### (autoloads (dired-at-point ffap-at-mouse ffap-menu find-file-at-point
-;;;;;; ffap-next) "ffap" "ffap.el" (14412 8705))
+;;;;;; ffap-next) "ffap" "ffap.el" (14736 26478))
;;; Generated autoloads from ffap.el
(autoload (quote ffap-next) "ffap" "\
;;;***
\f
;;;### (autoloads (file-cache-minibuffer-complete) "filecache" "filecache.el"
-;;;;;; (14332 47695))
+;;;;;; (14767 36637))
;;; Generated autoloads from filecache.el
(autoload (quote file-cache-minibuffer-complete) "filecache" "\
Complete a filename in the minibuffer using a preloaded cache.
Filecache does two kinds of substitution: it completes on names in
the cache, and, once it has found a unique name, it cycles through
-the directories that the name is available in. With a prefix argument,
-the name is considered already unique; only the second substitution
+the directories that the name is available in. With a prefix argument,
+the name is considered already unique; only the second substitution
\(directories) is done." t nil)
(define-key minibuffer-local-completion-map [C-tab] 'file-cache-minibuffer-complete)
(define-key minibuffer-local-map [C-tab] 'file-cache-minibuffer-complete)
;;;***
\f
;;;### (autoloads (find-grep-dired find-name-dired find-dired find-grep-options
-;;;;;; find-ls-option) "find-dired" "find-dired.el" (14345 52903))
+;;;;;; find-ls-option) "find-dired" "find-dired.el" (14718 5093))
;;; Generated autoloads from find-dired.el
(defvar find-ls-option (if (eq system-type (quote berkeley-unix)) (quote ("-ls" . "-gilsb")) (quote ("-exec ls -ld {} \\;" . "-ld"))) "\
\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"
-;;;;;; (13670 3046))
+;;;;;; (14746 24125))
;;; Generated autoloads from find-file.el
(autoload (quote ff-get-other-file) "find-file" "\
Find the header or source file corresponding to this file.
-See also the documentation for `ff-find-other-file;.
+See also the documentation for `ff-find-other-file'.
If optional IN-OTHER-WINDOW is non-nil, find the file in another window." t nil)
Variables of interest include:
- - ff-case-fold-search
- Non-nil means ignore cases in matches (see case-fold-search).
+ - `ff-case-fold-search'
+ Non-nil means ignore cases in matches (see `case-fold-search').
If you have extensions in different cases, you will want this to be nil.
- - ff-always-in-other-window
+ - `ff-always-in-other-window'
If non-nil, always open the other file in another window, unless an
- argument is given to ff-find-other-file.
+ argument is given to `ff-find-other-file'.
- - ff-ignore-include
+ - `ff-ignore-include'
If non-nil, ignores #include lines.
- - ff-always-try-to-create
+ - `ff-always-try-to-create'
If non-nil, always attempt to create the other file if it was not found.
- - ff-quiet-mode
+ - `ff-quiet-mode'
If non-nil, traces which directories are being searched.
- - ff-special-constructs
- A list of regular expressions specifying how to recognise special
- constructs such as include files etc, and an associated method for
+ - `ff-special-constructs'
+ A list of regular expressions specifying how to recognise special
+ constructs such as include files etc, and an associated method for
extracting the filename from that construct.
- - ff-other-file-alist
+ - `ff-other-file-alist'
Alist of extensions to find given the current file's extension.
- - ff-search-directories
+ - `ff-search-directories'
List of directories searched through with each extension specified in
- ff-other-file-alist that matches this file's extension.
+ `ff-other-file-alist' that matches this file's extension.
- - ff-pre-find-hooks
+ - `ff-pre-find-hooks'
List of functions to be called before the search for the file starts.
- - ff-pre-load-hooks
+ - `ff-pre-load-hooks'
List of functions to be called before the other file is loaded.
- - ff-post-load-hooks
+ - `ff-post-load-hooks'
List of functions to be called after the other file is loaded.
- - ff-not-found-hooks
+ - `ff-not-found-hooks'
List of functions to be called if the other file could not be found.
- - ff-file-created-hooks
+ - `ff-file-created-hooks'
List of functions to be called if the other file has been created." t nil)
(autoload (quote ff-mouse-find-other-file) "find-file" "\
Visit the file you click on." t nil)
(autoload (quote ff-mouse-find-other-file-other-window) "find-file" "\
-Visit the file you click on." t nil)
+Visit the file you click on in another window." t nil)
;;;***
\f
;;;;;; find-variable-other-window find-variable find-variable-noselect
;;;;;; find-function-other-frame find-function-other-window find-function
;;;;;; find-function-noselect) "find-func" "emacs-lisp/find-func.el"
-;;;;;; (14398 37514))
+;;;;;; (14854 32222))
;;; Generated autoloads from emacs-lisp/find-func.el
(autoload (quote find-function-noselect) "find-func" "\
(autoload (quote find-function-setup-keys) "find-func" "\
Define some key bindings for the find-function family of functions." nil nil)
+;;;***
+\f
+;;;### (autoloads (finder-by-keyword finder-commentary finder-list-keywords)
+;;;;;; "finder" "finder.el" (14747 44772))
+;;; Generated autoloads from finder.el
+
+(autoload (quote finder-list-keywords) "finder" "\
+Display descriptions of the keywords in the Finder buffer." t nil)
+
+(autoload (quote finder-commentary) "finder" "\
+Display FILE's commentary section.
+FILE should be in a form suitable for passing to `locate-library'." t nil)
+
+(autoload (quote finder-by-keyword) "finder" "\
+Find packages matching a given keyword." t nil)
+
;;;***
\f
;;;### (autoloads (enable-flow-control-on enable-flow-control) "flow-ctrl"
;;;***
\f
-;;;### (autoloads (flyspell-mode-off flyspell-mode) "flyspell" "textmodes/flyspell.el"
-;;;;;; (14512 26322))
+;;;### (autoloads (flyspell-mode-off flyspell-mode flyspell-prog-mode
+;;;;;; flyspell-mode-line-string) "flyspell" "textmodes/flyspell.el"
+;;;;;; (14845 20876))
;;; Generated autoloads from textmodes/flyspell.el
+(defvar flyspell-mode-line-string " Fly" "\
+*String displayed on the modeline when flyspell is active.
+Set this to nil if you don't want a modeline indicator.")
+
+(autoload (quote flyspell-prog-mode) "flyspell" "\
+Turn on `flyspell-mode' for comments and strings." t nil)
+
+(defvar flyspell-mode-map (make-sparse-keymap))
+
(autoload (quote flyspell-mode) "flyspell" "\
Minor mode performing on-the-fly spelling checking.
Ispell is automatically spawned on background for each entered words.
flyspell-buffer checks the whole buffer." t nil)
+(if (fboundp (quote add-minor-mode)) (add-minor-mode (quote flyspell-mode) (quote flyspell-mode-line-string) flyspell-mode-map nil (quote flyspell-mode)) (or (assoc (quote flyspell-mode) minor-mode-alist) (setq minor-mode-alist (cons (quote (flyspell-mode flyspell-mode-line-string)) minor-mode-alist))) (or (assoc (quote flyspell-mode) minor-mode-map-alist) (setq minor-mode-map-alist (cons (cons (quote flyspell-mode) flyspell-mode-map) minor-mode-map-alist))))
+
(autoload (quote flyspell-mode-off) "flyspell" "\
Turn Flyspell mode off." nil nil)
\f
;;;### (autoloads (follow-delete-other-windows-and-split follow-mode
;;;;;; turn-off-follow-mode turn-on-follow-mode) "follow" "follow.el"
-;;;;;; (14392 8455))
+;;;;;; (14392 8635))
;;; Generated autoloads from follow.el
(autoload (quote turn-on-follow-mode) "follow" "\
;;;***
\f
;;;### (autoloads (font-lock-fontify-buffer global-font-lock-mode
-;;;;;; global-font-lock-mode font-lock-remove-keywords font-lock-add-keywords
-;;;;;; turn-on-font-lock font-lock-mode) "font-lock" "font-lock.el"
-;;;;;; (14546 54851))
+;;;;;; font-lock-remove-keywords font-lock-add-keywords turn-on-font-lock
+;;;;;; font-lock-mode) "font-lock" "font-lock.el" (14850 36349))
;;; Generated autoloads from font-lock.el
+(make-variable-buffer-local (quote font-lock-defaults))
+
(defvar font-lock-mode-hook nil "\
Function or functions to run on entry to Font Lock mode.")
(autoload (quote font-lock-mode) "font-lock" "\
Toggle Font Lock mode.
With arg, turn Font Lock mode on if and only if arg is positive.
+\(Font Lock is also known as \"syntax highlighting\".)
When Font Lock mode is enabled, text is fontified as you type it:
- Certain other expressions are displayed in other faces according to the
value of the variable `font-lock-keywords'.
+To customize the faces (colors, fonts, etc.) used by Font Lock for
+fontifying different parts of buffer text, use \\[customize-face].
+
You can enable Font Lock mode in any major mode automatically by turning on in
the major mode's hook. For example, put in your ~/.emacs:
MODE should be a symbol, the major mode command name, such as `c-mode'
or nil. If nil, highlighting keywords are removed for the current buffer." nil nil)
-(autoload (quote global-font-lock-mode) "font-lock" "\
-Toggle Global Font Lock mode.
-With prefix ARG, turn Global Font Lock mode on if and only if ARG is positive.
-Displays a message saying whether the mode is on or off if MESSAGE is non-nil.
-Returns the new status of Global Font Lock mode (non-nil means on).
-
-When Global Font Lock mode is enabled, Font Lock mode is automagically
-turned on in a buffer if its major mode is one of `font-lock-global-modes'." t nil)
-
(defvar global-font-lock-mode nil "\
-Toggle Global Font Lock mode.
-When Global Font Lock mode is enabled, Font Lock mode is automagically
-turned on in a buffer if its major mode is one of `font-lock-global-modes'.
+Toggle Global-Font-Lock mode on or off.
+See the command `global-font-lock-mode' for a description of this minor-mode.
Setting this variable directly does not take effect;
use either \\[customize] or the function `global-font-lock-mode'.")
(custom-add-load (quote global-font-lock-mode) (quote font-lock))
+(autoload (quote global-font-lock-mode) "font-lock" "\
+Toggle Font-Lock mode in every buffer.
+With prefix ARG, turn Global-Font-Lock mode on if and only if ARG is positive.
+Font-Lock mode is actually not turned on in every buffer but only in those
+in which `turn-on-font-lock-if-enabled' turns it on." t nil)
+
(autoload (quote font-lock-fontify-buffer) "font-lock" "\
Fontify the current buffer the way the function `font-lock-mode' would." t nil)
;;;***
\f
;;;### (autoloads (create-fontset-from-fontset-spec) "fontset" "international/fontset.el"
-;;;;;; (14551 28678))
+;;;;;; (14845 20876))
;;; Generated autoloads from international/fontset.el
(autoload (quote create-fontset-from-fontset-spec) "fontset" "\
;;;***
\f
;;;### (autoloads (fortran-mode fortran-tab-mode-default) "fortran"
-;;;;;; "progmodes/fortran.el" (14537 23071))
+;;;;;; "progmodes/fortran.el" (14799 2695))
;;; Generated autoloads from progmodes/fortran.el
(defvar fortran-tab-mode-default nil "\
Variables controlling indentation style and extra features:
`comment-start'
- Normally nil in Fortran mode. If you want to use comments
- starting with `!', set this to the string \"!\".
+ If you want to use comments starting with `!',
+ set this to the string \"!\".
`fortran-do-indent'
Extra indentation within do blocks. (default 3)
`fortran-if-indent'
;;;***
\f
;;;### (autoloads (generic-mode define-generic-mode) "generic" "generic.el"
-;;;;;; (13973 3308))
+;;;;;; (14811 40477))
;;; Generated autoloads from generic.el
(autoload (quote define-generic-mode) "generic" "\
COMMENT-LIST is a list, whose entries are either a single character,
a one or two character string or a cons pair. If the entry is a character
or a one-character string, it is added to the mode's syntax table with
-comment-start syntax. If the entry is a cons pair, the elements of the
-pair are considered to be comment-start and comment-end respectively.
+`comment-start' syntax. If the entry is a cons pair, the elements of the
+pair are considered to be `comment-start' and `comment-end' respectively.
Note that Emacs has limitations regarding comment characters.
KEYWORD-LIST is a list of keywords to highlight with `font-lock-keyword-face'.
FONT-LOCK-LIST is a list of additional expressions to highlight. Each entry
in the list should have the same form as an entry in `font-lock-defaults-alist'
-AUTO-MODE-LIST is a list of regular expressions to add to auto-mode-alist.
-These regexps are added to auto-mode-alist as soon as `define-generic-mode'
+AUTO-MODE-LIST is a list of regular expressions to add to `auto-mode-alist'.
+These regexps are added to `auto-mode-alist' as soon as `define-generic-mode'
is called; any old regexps with the same name are removed.
FUNCTION-LIST is a list of functions to call to do some additional setup.
;;;***
\f
;;;### (autoloads (glasses-mode) "glasses" "progmodes/glasses.el"
-;;;;;; (14480 59906))
+;;;;;; (14746 24126))
;;; Generated autoloads from progmodes/glasses.el
(autoload (quote glasses-mode) "glasses" "\
;;;***
\f
;;;### (autoloads (gnus gnus-other-frame gnus-slave gnus-no-server
-;;;;;; gnus-slave-no-server) "gnus" "gnus/gnus.el" (14030 49411))
+;;;;;; gnus-slave-no-server) "gnus" "gnus/gnus.el" (14845 20875))
;;; Generated autoloads from gnus/gnus.el
(autoload (quote gnus-slave-no-server) "gnus" "\
\f
;;;### (autoloads (gnus-agent-batch gnus-agent-batch-fetch gnus-agentize
;;;;;; gnus-plugged gnus-unplugged) "gnus-agent" "gnus/gnus-agent.el"
-;;;;;; (14030 49649))
+;;;;;; (14845 20874))
;;; Generated autoloads from gnus/gnus-agent.el
(autoload (quote gnus-unplugged) "gnus-agent" "\
(autoload (quote gnus-agent-batch) "gnus-agent" nil t nil)
+;;;***
+\f
+;;;### (autoloads (gnus-article-prepare-display) "gnus-art" "gnus/gnus-art.el"
+;;;;;; (14846 39264))
+;;; Generated autoloads from gnus/gnus-art.el
+
+(autoload (quote gnus-article-prepare-display) "gnus-art" "\
+Make the current buffer look like a nice article." nil nil)
+
;;;***
\f
;;;### (autoloads (gnus-audio-play) "gnus-audio" "gnus/gnus-audio.el"
-;;;;;; (14030 49288))
+;;;;;; (14821 31350))
;;; Generated autoloads from gnus/gnus-audio.el
(autoload (quote gnus-audio-play) "gnus-audio" "\
-Play a sound through the speaker." t nil)
+Play a sound FILE through the speaker." t nil)
;;;***
\f
;;;### (autoloads (gnus-cache-generate-nov-databases gnus-cache-generate-active
-;;;;;; gnus-jog-cache) "gnus-cache" "gnus/gnus-cache.el" (14030
-;;;;;; 49293))
+;;;;;; gnus-jog-cache) "gnus-cache" "gnus/gnus-cache.el" (14792
+;;;;;; 2675))
;;; Generated autoloads from gnus/gnus-cache.el
(autoload (quote gnus-jog-cache) "gnus-cache" "\
;;;***
\f
;;;### (autoloads (gnus-fetch-group-other-frame gnus-fetch-group)
-;;;;;; "gnus-group" "gnus/gnus-group.el" (14177 56552))
+;;;;;; "gnus-group" "gnus/gnus-group.el" (14858 32484))
;;; Generated autoloads from gnus/gnus-group.el
(autoload (quote gnus-fetch-group) "gnus-group" "\
;;;***
\f
;;;### (autoloads (gnus-batch-score) "gnus-kill" "gnus/gnus-kill.el"
-;;;;;; (14030 49328))
+;;;;;; (14813 40531))
;;; Generated autoloads from gnus/gnus-kill.el
(defalias (quote gnus-batch-kill) (quote gnus-batch-score))
Run batched scoring.
Usage: emacs -batch -l ~/.emacs -l gnus -f gnus-batch-score" t nil)
+;;;***
+\f
+;;;### (autoloads (gnus-mailing-list-mode turn-on-gnus-mailing-list-mode)
+;;;;;; "gnus-ml" "gnus/gnus-ml.el" (14855 56553))
+;;; Generated autoloads from gnus/gnus-ml.el
+
+(autoload (quote turn-on-gnus-mailing-list-mode) "gnus-ml" nil nil nil)
+
+(autoload (quote gnus-mailing-list-mode) "gnus-ml" "\
+Minor mode for providing mailing-list commands.
+
+\\{gnus-mailing-list-mode-map}" t nil)
+
+;;;***
+\f
+;;;### (autoloads (gnus-group-split-fancy gnus-group-split gnus-group-split-update
+;;;;;; gnus-group-split-setup) "gnus-mlspl" "gnus/gnus-mlspl.el"
+;;;;;; (14855 56553))
+;;; Generated autoloads from gnus/gnus-mlspl.el
+
+(autoload (quote gnus-group-split-setup) "gnus-mlspl" "\
+Set up the split for nnmail-split-fancy.
+Sets things up so that nnmail-split-fancy is used for mail
+splitting, and defines the variable nnmail-split-fancy according with
+group parameters.
+
+If AUTO-UPDATE is non-nil (prefix argument accepted, if called
+interactively), it makes sure nnmail-split-fancy is re-computed before
+getting new mail, by adding gnus-group-split-update to
+nnmail-pre-get-new-mail-hook." t nil)
+
+(autoload (quote gnus-group-split-update) "gnus-mlspl" "\
+Computes nnmail-split-fancy from group params.
+It does this by calling (gnus-group-split-fancy nil CROSSPOST DEFAULTGROUP)." t nil)
+
+(autoload (quote gnus-group-split) "gnus-mlspl" "\
+Uses information from group parameters in order to split mail.
+See gnus-group-split-fancy for more information.
+
+If no group is defined as catch-all, the value of
+gnus-group-split-default-catch-all-group is used.
+
+gnus-group-split is a valid value for nnmail-split-methods." nil nil)
+
+(autoload (quote gnus-group-split-fancy) "gnus-mlspl" "\
+Uses information from group parameters in order to split mail. It
+can be embedded into nnmail-split-fancy lists with the SPLIT
+
+\(: gnus-group-split-fancy GROUPS NO-CROSSPOST CATCH-ALL)
+
+GROUPS may be a regular expression or a list of group names, that will
+be used to select candidate groups. If it is ommited or nil, all
+existing groups are considered.
+
+if NO-CROSSPOST is ommitted or nil, a & split will be returned,
+otherwise, a | split, that does not allow crossposting, will be
+returned.
+
+if CATCH-ALL is not nil, and there is no selected group whose
+SPLIT-REGEXP matches the empty string, nor is there a selected group
+whose SPLIT-SPEC is 'catch-all, this group name will be appended to
+the returned SPLIT list, as the last element in a '| SPLIT.
+
+For each selected group, a SPLIT is composed like this: if SPLIT-SPEC
+is specified, this split is returned as-is (unless it is nil: in this
+case, the group is ignored). Otherwise, if TO-ADDRESS, TO-LIST and/or
+EXTRA-ALIASES are specified, a regexp that matches any of them is
+constructed (extra-aliases may be a list). Additionally, if
+SPLIT-REGEXP is specified, the regexp will be extended so that it
+matches this regexp too, and if SPLIT-EXCLUDE is specified, RESTRICT
+clauses will be generated.
+
+For example, given the following group parameters:
+
+nnml:mail.bar:
+\((to-address . \"bar@femail.com\")
+ (split-regexp . \".*@femail\\\\.com\"))
+nnml:mail.foo:
+\((to-list . \"foo@nowhere.gov\")
+ (extra-aliases \"foo@localhost\" \"foo-redist@home\")
+ (split-exclude \"bugs-foo\" \"rambling-foo\")
+ (admin-address . \"foo-request@nowhere.gov\"))
+nnml:mail.others:
+\((split-spec . catch-all))
+
+Calling (gnus-group-split-fancy nil nil \"mail.misc\") returns:
+
+\(| (& (any \"\\\\(bar@femail\\\\.com\\\\|.*@femail\\\\.com\\\\)\"
+ \"mail.bar\")
+ (any \"\\\\(foo@nowhere\\\\.gov\\\\|foo@localhost\\\\|foo-redist@home\\\\)\"
+ - \"bugs-foo\" - \"rambling-foo\" \"mail.foo\"))
+ \"mail.others\")" nil nil)
+
;;;***
\f
;;;### (autoloads (gnus-change-server) "gnus-move" "gnus/gnus-move.el"
-;;;;;; (14030 49334))
+;;;;;; (14792 2677))
;;; Generated autoloads from gnus/gnus-move.el
(autoload (quote gnus-change-server) "gnus-move" "\
;;;***
\f
-;;;### (autoloads (gnus-mule-initialize gnus-mule-add-group) "gnus-mule"
-;;;;;; "gnus/gnus-mule.el" (14092 5540))
+;;;### (autoloads (gnus-msg-mail) "gnus-msg" "gnus/gnus-msg.el" (14858
+;;;;;; 32484))
+;;; Generated autoloads from gnus/gnus-msg.el
+
+(define-mail-user-agent (quote gnus-user-agent) (quote gnus-msg-mail) (quote message-send-and-exit) (quote message-kill-buffer) (quote message-send-hook))
+
+(autoload (quote gnus-msg-mail) "gnus-msg" "\
+Start editing a mail message to be sent.
+Like `message-mail', but with Gnus paraphernalia, particularly the
+the Gcc: header for archiving purposes." t nil)
+
+;;;***
+\f
+;;;### (autoloads (gnus-mule-add-group) "gnus-mule" "gnus/gnus-mule.el"
+;;;;;; (14845 20875))
;;; Generated autoloads from gnus/gnus-mule.el
(autoload (quote gnus-mule-add-group) "gnus-mule" "\
Specify that articles of news group NAME are encoded in CODING-SYSTEM.
All news groups deeper than NAME are also the target.
-If CODING-SYSTEM is a cons, the car and cdr part are regarded as
-coding-system for reading and writing respectively." nil nil)
+If CODING-SYSTEM is a cons, the car part is used and the cdr
+part is ignored.
-(autoload (quote gnus-mule-initialize) "gnus-mule" "\
-Do several settings for GNUS to enable automatic code conversion." nil nil)
+This function exists for backward comaptibility with Emacs 20. It is
+recommended to customize the variable `gnus-group-charset-alist'
+rather than using this function." nil nil)
;;;***
\f
;;;### (autoloads (gnus-batch-brew-soup) "gnus-soup" "gnus/gnus-soup.el"
-;;;;;; (14030 49357))
+;;;;;; (14792 2677))
;;; Generated autoloads from gnus/gnus-soup.el
(autoload (quote gnus-batch-brew-soup) "gnus-soup" "\
;;;***
\f
;;;### (autoloads (gnus-update-format) "gnus-spec" "gnus/gnus-spec.el"
-;;;;;; (14030 49359))
+;;;;;; (14792 2677))
;;; Generated autoloads from gnus/gnus-spec.el
(autoload (quote gnus-update-format) "gnus-spec" "\
;;;***
\f
;;;### (autoloads (gnus-declare-backend gnus-unload) "gnus-start"
-;;;;;; "gnus/gnus-start.el" (14345 52937))
+;;;;;; "gnus/gnus-start.el" (14858 32484))
;;; Generated autoloads from gnus/gnus-start.el
(autoload (quote gnus-unload) "gnus-start" "\
-Unload all Gnus features." t nil)
+Unload all Gnus features.
+\(For some value of `all' or `Gnus'.) Currently, features whose names
+have prefixes `gnus-', `nn', `mm-' or `rfc' are unloaded. Use
+cautiously -- unloading may cause trouble." t nil)
(autoload (quote gnus-declare-backend) "gnus-start" "\
Declare backend NAME with ABILITIES as a Gnus backend." nil nil)
;;;***
\f
;;;### (autoloads (gnus-add-configuration) "gnus-win" "gnus/gnus-win.el"
-;;;;;; (14030 49407))
+;;;;;; (14792 2682))
;;; Generated autoloads from gnus/gnus-win.el
(autoload (quote gnus-add-configuration) "gnus-win" "\
;;;***
\f
-;;;### (autoloads (gomoku) "gomoku" "play/gomoku.el" (13940 33566))
+;;;### (autoloads (gomoku) "gomoku" "play/gomoku.el" (14726 41839))
;;; Generated autoloads from play/gomoku.el
(autoload (quote gomoku) "gomoku" "\
;;;***
\f
;;;### (autoloads (goto-address goto-address-at-point goto-address-at-mouse)
-;;;;;; "goto-addr" "net/goto-addr.el" (14385 24830))
+;;;;;; "goto-addr" "net/goto-addr.el" (14747 44775))
;;; Generated autoloads from net/goto-addr.el
(autoload (quote goto-address-at-mouse) "goto-addr" "\
;;;***
\f
;;;### (autoloads (jdb pdb perldb xdb dbx sdb gdb) "gud" "gud.el"
-;;;;;; (14517 9487))
+;;;;;; (14750 26818))
;;; Generated autoloads from gud.el
(autoload (quote gdb) "gud" "\
;;;***
\f
-;;;### (autoloads (handwrite) "handwrite" "play/handwrite.el" (14033
-;;;;;; 23942))
+;;;### (autoloads (handwrite) "handwrite" "play/handwrite.el" (14638
+;;;;;; 40782))
;;; Generated autoloads from play/handwrite.el
(autoload (quote handwrite) "handwrite" "\
;;;***
\f
;;;### (autoloads (Helper-help Helper-describe-bindings) "helper"
-;;;;;; "emacs-lisp/helper.el" (14518 20602))
+;;;;;; "emacs-lisp/helper.el" (14518 32866))
;;; Generated autoloads from emacs-lisp/helper.el
(autoload (quote Helper-describe-bindings) "helper" "\
;;;***
\f
;;;### (autoloads (hexlify-buffer hexl-find-file hexl-mode) "hexl"
-;;;;;; "hexl.el" (14335 43064))
+;;;;;; "hexl.el" (14821 33060))
;;; Generated autoloads from hexl.el
(autoload (quote hexl-mode) "hexl" "\
Convert a binary buffer to hexl format.
This discards the buffer's undo information." t nil)
+;;;***
+\f
+;;;### (autoloads (hi-lock-write-interactive-patterns hi-lock-unface-buffer
+;;;;;; hi-lock-face-buffer hi-lock-line-face-buffer hi-lock-mode
+;;;;;; hi-lock-mode) "hi-lock" "hi-lock.el" (14792 36880))
+;;; Generated autoloads from hi-lock.el
+
+(defgroup hi-lock-interactive-text-highlighting nil "Interactively add and remove font-lock patterns for highlighting text." :group (quote faces))
+
+(defvar hi-lock-mode nil "\
+Toggle hi-lock, for interactively adding font-lock text-highlighting patterns.")
+
+(custom-add-to-group (quote hi-lock-interactive-text-highlighting) (quote hi-lock-mode) (quote custom-variable))
+
+(custom-add-load (quote hi-lock-mode) (quote hi-lock))
+
+(autoload (quote 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. When hi-lock turned on an \"Automatic 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.
+
+\\[highlight-lines-matching-regexp] REGEXP FACE
+ Highlight lines containing matches of REGEXP in current buffer with FACE.
+
+\\[unhighlight-regexp] REGEXP
+ Remove highlighting on matches of REGEXP in current buffer.
+
+\\[hi-lock-write-interactive-patterns]
+ Write active REGEXPs into buffer as comments (if possible). They will
+ be read the next time file is loaded or when the \\[hi-lock-find-patterns] command
+ is issued. The inserted regexps are in the form of font lock keywords.
+ (See `font-lock-keywords') They may be edited and re-loaded with \\[hi-lock-find-patterns],
+ any valid `font-lock-keywords' form is acceptable.
+
+\\[hi-lock-find-patterns]
+ Re-read patterns stored in buffer (in the format produced by \\[hi-lock-write-interactive-patterns]).
+
+When hi-lock is started and if the mode is not excluded, the
+beginning of the buffer is searched for lines of the form:
+ Hi-lock: FOO
+where FOO is a list of patterns. These are added to the font lock keywords
+already present. The patterns must start before position (number
+of characters into buffer) `hi-lock-file-patterns-range'. Patterns
+will be read until
+ Hi-lock: end
+is found. A mode is excluded if it's in the list `hi-lock-exclude-modes'." t nil)
+
+(defalias (quote highlight-lines-matching-regexp) (quote hi-lock-line-face-buffer))
+
+(autoload (quote hi-lock-line-face-buffer) "hi-lock" "\
+Set face of all lines containing matches of REGEXP to FACE.
+
+Interactively, prompt for REGEXP then FACE. Buffer-local history
+list maintained for regexps, global history maintained for faces.
+\\<minibuffer-local-map>Use \\[next-history-element] and \\[previous-history-element] to retrieve next or previous history item.
+\(See info node `Minibuffer History')" t nil)
+
+(defalias (quote highlight-regexp) (quote hi-lock-face-buffer))
+
+(autoload (quote hi-lock-face-buffer) "hi-lock" "\
+Set face of all matches of REGEXP to FACE.
+
+Interactively, prompt for REGEXP then FACE. Buffer-local history
+list maintained for regexps, global history maintained for faces.
+\\<minibuffer-local-map>Use \\[next-history-element] and \\[previous-history-element] to retrieve next or previous history item.
+\(See info node `Minibuffer History')" t nil)
+
+(defalias (quote unhighlight-regexp) (quote hi-lock-unface-buffer))
+
+(autoload (quote hi-lock-unface-buffer) "hi-lock" "\
+Remove highlighting of matches to REGEXP set by hi-lock.
+
+Interactively, prompt for REGEXP. Buffer-local history of inserted
+regexp's maintained. Will accept only regexps inserted by hi-lock
+interactive functions. (See `hi-lock-interactive-patterns'.)
+\\<minibuffer-local-must-match-map>Use \\[minibuffer-complete] to complete a partially typed regexp.
+\(See info node `Minibuffer History'.)" t nil)
+
+(autoload (quote hi-lock-write-interactive-patterns) "hi-lock" "\
+Write interactively added patterns, if any, into buffer at point.
+
+Interactively added patterns are those normally specified using
+`highlight-regexp' and `highlight-lines-matching-regexp'; they can
+be found in variable `hi-lock-interactive-patterns'." t nil)
+
;;;***
\f
;;;### (autoloads (hide-ifdef-lines hide-ifdef-read-only hide-ifdef-initially
-;;;;;; hide-ifdef-mode) "hideif" "progmodes/hideif.el" (14392 886))
+;;;;;; hide-ifdef-mode) "hideif" "progmodes/hideif.el" (14745 16483))
;;; Generated autoloads from progmodes/hideif.el
(defvar hide-ifdef-mode nil "\
;;;***
\f
;;;### (autoloads (hs-minor-mode hs-hide-comments-when-hiding-all)
-;;;;;; "hideshow" "progmodes/hideshow.el" (14512 26322))
+;;;;;; "hideshow" "progmodes/hideshow.el" (14799 2695))
;;; Generated autoloads from progmodes/hideshow.el
(defvar hs-hide-comments-when-hiding-all t "\
The value '(hs . t) is added to `buffer-invisibility-spec'.
The main commands are: `hs-hide-all', `hs-show-all', `hs-hide-block',
-`hs-show-block', `hs-hide-level' and `hs-show-region'. There is also
+`hs-show-block', `hs-hide-level' and `hs-toggle-hiding'. There is also
`hs-hide-initial-comment-block' and `hs-mouse-toggle-hiding'.
Turning hideshow minor mode off reverts the menu bar and the
;;;### (autoloads (global-highlight-changes highlight-compare-with-file
;;;;;; highlight-changes-rotate-faces highlight-changes-previous-change
;;;;;; highlight-changes-next-change highlight-changes-mode highlight-changes-remove-highlight)
-;;;;;; "hilit-chg" "hilit-chg.el" (14288 22009))
+;;;;;; "hilit-chg" "hilit-chg.el" (14750 33582))
;;; Generated autoloads from hilit-chg.el
(defvar highlight-changes-mode nil)
(autoload (quote highlight-changes-remove-highlight) "hilit-chg" "\
-Remove the change face from the region.
+Remove the change face from the region between BEG and END.
This allows you to manually remove highlighting from uninteresting changes." t nil)
(autoload (quote highlight-changes-mode) "hilit-chg" "\
Toggle (or initially set) Highlight Changes mode.
-Without an argument,
- if Highlight Changes mode is not enabled, then enable it (to either active
- or passive as determined by variable highlight-changes-initial-state);
- otherwise, toggle between active and passive states.
+Without an argument:
+ If Highlight Changes mode is not enabled, then enable it (in either active
+ or passive state as determined by the variable
+ `highlight-changes-initial-state'); otherwise, toggle between active
+ and passive state.
-With an argument,
- if just C-u or a positive argument, set state to active;
- with a zero argument, set state to passive;
- with a negative argument, disable Highlight Changes mode completely.
+With an argument ARG:
+ If ARG is positive, set state to active;
+ If ARG is zero, set state to passive;
+ If ARG is negative, disable Highlight Changes mode completely.
-Active state - means changes are shown in a distinctive face.
+Active state - means changes are shown in a distinctive face.
Passive state - means changes are kept and new ones recorded but are
not displayed in a different face.
\\[highlight-changes-rotate-faces] - rotate different \"ages\" of changes through
various faces.
-
Hook variables:
-highlight-changes-enable-hook - when Highlight Changes mode enabled.
-highlight-changes-toggle-hook - when entering active or passive state
-highlight-changes-disable-hook - when turning off Highlight Changes mode.
-" t nil)
+`highlight-changes-enable-hook' - when enabling Highlight Changes mode.
+`highlight-changes-toggle-hook' - when entering active or passive state
+`highlight-changes-disable-hook' - when turning off Highlight Changes mode." t nil)
(autoload (quote highlight-changes-next-change) "hilit-chg" "\
Move to the beginning of the next change, if in Highlight Changes mode." t nil)
(autoload (quote highlight-changes-rotate-faces) "hilit-chg" "\
Rotate the faces used by Highlight Changes mode.
-Current changes will be display in the face described by the first element
-of highlight-changes-face-list, those (older) changes will be shown in the
+Current changes are displayed in the face described by the first element
+of `highlight-changes-face-list', one level older changes are shown in
face described by the second element, and so on. Very old changes remain
shown in the last face in the list.
You can automatically rotate colours when the buffer is saved
-by adding this to local-write-file-hooks, by evaling (in the
+by adding the following to `local-write-file-hooks', by evaling it in the
buffer to be saved):
- (add-hook 'local-write-file-hooks 'highlight-changes-rotate-faces)
-" t nil)
+
+ (add-hook 'local-write-file-hooks 'highlight-changes-rotate-faces)" t nil)
(autoload (quote highlight-compare-with-file) "hilit-chg" "\
Compare this buffer with a file, and highlight differences.
The current buffer must be an unmodified buffer visiting a file,
-and not in read-only mode.
+and must not be read-only.
-If the backup filename exists, it is used as the default
-when called interactively.
+If the buffer has a backup filename, it is used as the default when
+this function is called interactively.
-If a buffer is visiting the file being compared against, it also will
-have its differences highlighted. Otherwise, the file is read in
-temporarily but the buffer is deleted.
+If the current buffer is visiting the file being compared against, it
+also will have its differences highlighted. Otherwise, the file is
+read in temporarily but the buffer is deleted.
-If a buffer is read-only, differences will be highlighted but no property
-changes made, so \\[highlight-changes-next-change] and
+If the buffer is read-only, differences will be highlighted but no property
+changes are made, so \\[highlight-changes-next-change] and
\\[highlight-changes-previous-change] will not work." t nil)
(autoload (quote global-highlight-changes) "hilit-chg" "\
When called from a program:
- if ARG is nil or omitted, turn it off
-- if ARG is 'active, turn it on in active mode
-- if ARG is 'passive, turn it on in passive mode
+- if ARG is `active', turn it on in active mode
+- if ARG is `passive', turn it on in passive mode
- otherwise just turn it on
When global Highlight Changes mode is enabled, Highlight Changes mode is turned
on for future \"suitable\" buffers (and for \"suitable\" existing buffers if
variable `highlight-changes-global-changes-existing-buffers' is non-nil).
-\"Suitablity\" is determined by variable `highlight-changes-global-modes'." t nil)
+\"Suitability\" is determined by variable `highlight-changes-global-modes'." t nil)
;;;***
\f
;;;;;; 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" (14398 37488))
+;;;;;; "hippie-exp.el" (14735 57398))
;;; Generated autoloads from hippie-exp.el
(defvar hippie-expand-try-functions-list (quote (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 (hl-line-mode hl-line-mode) "hl-line" "hl-line.el"
-;;;;;; (14454 80))
+;;;### (autoloads (hl-line-mode) "hl-line" "hl-line.el" (14854 32221))
;;; Generated autoloads from hl-line.el
(defvar hl-line-mode nil "\
-Toggle Hl-Line mode.
+Toggle Hl-Line mode on or off.
+See the command `hl-line-mode' for a description of this minor-mode.
Setting this variable directly does not take effect;
use either \\[customize] or the function `hl-line-mode'.")
(autoload (quote hl-line-mode) "hl-line" "\
Global minor mode to highlight the line about point in the current window.
-
With ARG, turn Hl-Line mode on if ARG is positive, off otherwise.
Uses functions `hl-line-unhighlight' and `hl-line-highlight' on
`pre-command-hook' and `post-command-hook'." t nil)
;;;***
\f
;;;### (autoloads (hscroll-global-mode hscroll-mode turn-on-hscroll)
-;;;;;; "hscroll" "hscroll.el" (14454 81))
+;;;;;; "hscroll" "hscroll.el" (14671 47520))
;;; Generated autoloads from hscroll.el
(autoload (quote turn-on-hscroll) "hscroll" "\
;;;***
\f
;;;### (autoloads (icomplete-minibuffer-setup icomplete-mode) "icomplete"
-;;;;;; "icomplete.el" (14440 64840))
+;;;;;; "icomplete.el" (14636 62704))
;;; Generated autoloads from icomplete.el
(autoload (quote icomplete-mode) "icomplete" "\
;;;***
\f
-;;;### (autoloads (icon-mode) "icon" "progmodes/icon.el" (13549 39403))
+;;;### (autoloads (icon-mode) "icon" "progmodes/icon.el" (14854 32223))
;;; Generated autoloads from progmodes/icon.el
(autoload (quote icon-mode) "icon" "\
;;;***
\f
;;;### (autoloads (idlwave-shell) "idlw-shell" "progmodes/idlw-shell.el"
-;;;;;; (14495 18053))
+;;;;;; (14735 57460))
;;; Generated autoloads from progmodes/idlw-shell.el
(autoload (quote idlwave-shell) "idlw-shell" "\
;;;***
\f
;;;### (autoloads (idlwave-mode) "idlwave" "progmodes/idlwave.el"
-;;;;;; (14495 18054))
+;;;;;; (14671 47574))
;;; Generated autoloads from progmodes/idlwave.el
(autoload (quote idlwave-mode) "idlwave" "\
These commands know about system routines, all routines in idlwave-mode
buffers and (when the idlwave-shell is active) about all modules
currently compiled under this shell. Use \\[idlwave-update-routine-info] to update this
- information, which is also used for completion (see next item).
+ information, which is also used for completion (see item 4).
+
+3. Online IDL Help
+ ---------------
+ \\[idlwave-context-help] displays the IDL documentation relevant
+ for the system variable, keyword, or routine at point. A single key
+ stroke gets you directly to the right place in the docs. Two additional
+ files (an ASCII version of the IDL documentation and a topics file) must
+ be installed for this - check the IDLWAVE webpage for these files.
-3. Completion
+4. Completion
----------
- \\[idlwave-complete] completes the names of procedures, functions and
- keyword parameters. It is context sensitive and figures out what
- is expected at point (procedure/function/keyword). Lower case
- strings are completed in lower case, other strings in mixed or
- upper case.
+ \\[idlwave-complete] completes the names of procedures, functions
+ class names and keyword parameters. It is context sensitive and
+ figures out what is expected at point (procedure/function/keyword).
+ Lower case strings are completed in lower case, other strings in
+ mixed or upper case.
-4. Code Templates and Abbreviations
+5. Code Templates and Abbreviations
--------------------------------
Many Abbreviations are predefined to expand to code fragments and templates.
The abbreviations start generally with a `\\`. Some examples
current program unit (pro, function or main). Change log entries
can be added to the current program unit with \\[idlwave-doc-modification].
-5. Automatic Case Conversion
+6. Automatic Case Conversion
-------------------------
The case of reserved words and some abbrevs is controlled by
`idlwave-reserved-word-upcase' and `idlwave-abbrev-change-case'.
-6. Automatic END completion
+7. Automatic END completion
------------------------
If the variable `idlwave-expand-generic-end' is non-nil, each END typed
will be converted to the specific version, like ENDIF, ENDFOR, etc.
-7. Hooks
+8. Hooks
-----
Loading idlwave.el runs `idlwave-load-hook'.
Turning on `idlwave-mode' runs `idlwave-mode-hook'.
-8. Documentation and Customization
+9. Documentation and Customization
-------------------------------
Info documentation for this package is available. Use \\[idlwave-info]
to display (complain to your sysadmin if that does not work).
homepage at `http://www.strw.leidenuniv.nl/~dominik/Tools/idlwave'.
IDLWAVE has customize support - see the group `idlwave'.
-9. Keybindings
+10.Keybindings
-----------
Here is a list of all keybindings of this mode.
If some of the key bindings below show with ??, use \\[describe-key]
;;;***
\f
-;;;### (autoloads (ielm) "ielm" "ielm.el" (13638 47263))
+;;;### (autoloads (ielm) "ielm" "ielm.el" (14821 31346))
;;; Generated autoloads from ielm.el
(add-hook 'same-window-buffer-names "*ielm*")
;;;***
\f
-;;;### (autoloads (defimage remove-images insert-image put-image
-;;;;;; create-image image-type-available-p image-type-from-file-header
-;;;;;; image-type-from-data) "image" "image.el" (14524 62778))
+;;;### (autoloads (defimage find-image remove-images insert-image
+;;;;;; put-image create-image image-type-available-p image-type-from-file-header
+;;;;;; image-type-from-data) "image" "image.el" (14812 24473))
;;; Generated autoloads from image.el
(autoload (quote image-type-from-data) "image" "\
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. `:heuristic-mask t'.
+like, e.g. `:mask MASK'.
Value is the image created, or nil if images of type TYPE are not supported." nil nil)
(autoload (quote put-image) "image" "\
IMAGE must be an image created with `create-image' or `defimage'.
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.
+image. STRING is defaulted if you omit it.
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 (quote 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.
+with a `display' property whose value is the image. STRING is
+defaulted 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'
Remove only images that were put in BUFFER with calls to `put-image'.
BUFFER nil or omitted means use the current buffer." nil nil)
+(autoload (quote find-image) "image" "\
+Find an image, choosing one of a list of image specifications.
+
+SPECS is a list of image specifications.
+
+Each image specification in SPECS is a property list. The contents of
+a specification are image type dependent. All specifications must at
+least contain the properties `:type TYPE' and either `:file FILE' or
+`:data DATA', where TYPE is a symbol specifying the image type,
+e.g. `xbm', FILE is the file to load the image from, and DATA is a
+string containing the actual image data. The specification whose TYPE
+is supported, and FILE exists, is used to construct the image
+specification to be returned. Return nil if no specification is
+satisfied.
+
+The image is looked for first on `load-path' and then in `data-directory'." nil nil)
+
(autoload (quote defimage) "image" "\
Define SYMBOL as an image.
(defimage test-image ((:type xpm :file \"~/test1.xpm\")
(:type xbm :file \"~/test1.xbm\")))" nil (quote macro))
+;;;***
+\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" (14854 32221))
+;;; Generated autoloads from image-file.el
+
+(defvar image-file-name-extensions (quote ("png" "jpeg" "jpg" "gif" "tiff" "xbm" "xpm" "pbm")) "\
+*A list of image-file filename extensions.
+Filenames having one of these extensions are considered image files,
+in addition to those matching `image-file-name-regexps'.
+
+See `auto-image-file-mode'; if `auto-image-file-mode' is enabled,
+setting this variable directly does not take effect unless
+`auto-image-file-mode' is re-enabled; this happens automatically the
+variable is set using \\[customize].")
+
+(defvar image-file-name-regexps nil "\
+*List of regexps matching image-file filenames.
+Filenames matching one of these regexps are considered image files,
+in addition to those with an extension in `image-file-name-extensions'.
+
+See function `auto-image-file-mode'; if `auto-image-file-mode' is
+enabled, setting this variable directly does not take effect unless
+`auto-image-file-mode' is re-enabled; this happens automatically the
+variable is set using \\[customize].")
+
+(autoload (quote image-file-name-regexp) "image-file" "\
+Return a regular expression matching image-file filenames." nil nil)
+
+(autoload (quote insert-image-file) "image-file" "\
+Insert the image file FILE into the current buffer.
+Optional arguments VISIT, BEG, END, and REPLACE are interpreted as for
+the command `insert-file-contents'." nil nil)
+
+(defvar auto-image-file-mode nil "\
+Toggle Auto-Image-File mode on or off.
+See the command `auto-image-file-mode' for a description of this minor-mode.
+Setting this variable directly does not take effect;
+use either \\[customize] or the function `auto-image-file-mode'.")
+
+(custom-add-to-group (quote image) (quote auto-image-file-mode) (quote custom-variable))
+
+(custom-add-load (quote auto-image-file-mode) (quote image-file))
+
+(autoload (quote 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.
+
+Image files are those whose name has an extension in
+`image-file-name-extensions', or matches a regexp in
+`image-file-name-regexps'." t nil)
+
;;;***
\f
;;;### (autoloads (imenu imenu-add-menubar-index imenu-add-to-menubar
-;;;;;; imenu-sort-function) "imenu" "imenu.el" (14315 33489))
+;;;;;; imenu-sort-function) "imenu" "imenu.el" (14837 50473))
;;; Generated autoloads from imenu.el
(defvar imenu-sort-function nil "\
(MENU-TITLE REGEXP INDEX FUNCTION ARGUMENTS...)
with zero or more ARGUMENTS. The former format creates a simple element in
the index alist when it matches; the latter creates a special element
-of the form (NAME FUNCTION POSITION-MARKER ARGUMENTS...)
-with FUNCTION and ARGUMENTS beiong copied from `imenu-generic-expression'.
+of the form (NAME POSITION-MARKER FUNCTION ARGUMENTS...)
+with FUNCTION and ARGUMENTS copied from `imenu-generic-expression'.
MENU-TITLE is a string used as the title for the submenu or nil if the
entries are not nested.
;;;***
\f
;;;### (autoloads (inferior-lisp) "inf-lisp" "progmodes/inf-lisp.el"
-;;;;;; (13898 16429))
+;;;;;; (14821 31354))
;;; Generated autoloads from progmodes/inf-lisp.el
(defvar inferior-lisp-filter-regexp "\\`\\s *\\(:\\(\\w\\|\\s_\\)\\)?\\s *\\'" "\
*What not to save on inferior Lisp's input history.
Input matching this regexp is not saved on the input history in Inferior Lisp
-mode. Default is whitespace followed by 0 or 1 single-letter colon-keyword
+mode. Default is whitespace followed by 0 or 1 single-letter colon-keyword
\(as in :a, :c, etc.)")
(defvar inferior-lisp-program "lisp" "\
(defvar inferior-lisp-prompt "^[^> \n]*>+:? *" "\
Regexp to recognise prompts in the Inferior Lisp mode.
Defaults to \"^[^> \\n]*>+:? *\", which works pretty good for Lucid, kcl,
-and franz. This variable is used to initialize `comint-prompt-regexp' in the
+and franz. This variable is used to initialize `comint-prompt-regexp' in the
Inferior Lisp buffer.
+This variable is only used if the variable
+`comint-use-prompt-regexp-instead-of-fields' is non-nil.
+
More precise choices:
Lucid Common Lisp: \"^\\\\(>\\\\|\\\\(->\\\\)+\\\\) *\"
franz: \"^\\\\(->\\\\|<[0-9]*>:\\\\) *\"
;;;***
\f
;;;### (autoloads (Info-speedbar-browser Info-goto-emacs-key-command-node
-;;;;;; Info-goto-emacs-command-node info-standalone info info-other-window)
-;;;;;; "info" "info.el" (14544 60288))
+;;;;;; Info-goto-emacs-command-node Info-directory info-standalone
+;;;;;; info info-other-window) "info" "info.el" (14854 32221))
;;; Generated autoloads from info.el
(autoload (quote info-other-window) "info" "\
to read a file name from the minibuffer.
The search path for Info files is in the variable `Info-directory-list'.
-The top-level Info directory is made by combining all the files named `dir'
+The top-level Info directory is made by combining all the files named `dir'
in all the directories in that path." t nil)
(autoload (quote info-standalone) "info" "\
Usage: emacs -f info-standalone [filename]
In standalone mode, \\<Info-mode-map>\\[Info-exit] exits Emacs itself." nil nil)
+(autoload (quote Info-directory) "info" "\
+Go to the Info directory node." t nil)
+
(autoload (quote Info-goto-emacs-command-node) "info" "\
Go to the Info node in the Emacs manual for command COMMAND.
The command is found by looking up in Emacs manual's Command Index
(autoload (quote Info-goto-emacs-key-command-node) "info" "\
Go to the Info node in the Emacs manual the command bound to KEY, a string.
-Interactively, if the binding is execute-extended-command, a command is read.
+Interactively, if the binding is `execute-extended-command', a command is read.
The command is found by looking up in Emacs manual's Command Index
or in another manual found via COMMAND's `info-file' property or
the variable `Info-file-list-for-emacs'." t nil)
\f
;;;### (autoloads (info-complete-file info-complete-symbol info-lookup-file
;;;;;; info-lookup-symbol info-lookup-reset) "info-look" "info-look.el"
-;;;;;; (14539 53666))
+;;;;;; (14712 9626))
;;; Generated autoloads from info-look.el
(autoload (quote info-lookup-reset) "info-look" "\
\f
;;;### (autoloads (isearch-process-search-multibyte-characters isearch-toggle-input-method
;;;;;; isearch-toggle-specified-input-method) "isearch-x" "international/isearch-x.el"
-;;;;;; (13770 35556))
+;;;;;; (14837 50475))
;;; Generated autoloads from international/isearch-x.el
(autoload (quote isearch-toggle-specified-input-method) "isearch-x" "\
;;;***
\f
;;;### (autoloads (iso-accents-mode) "iso-acc" "international/iso-acc.el"
-;;;;;; (14388 10886))
+;;;;;; (14388 11031))
;;; Generated autoloads from international/iso-acc.el
(autoload (quote iso-accents-mode) "iso-acc" "\
;;;***
\f
;;;### (autoloads (iso-cvt-define-menu iso-cvt-write-only iso-cvt-read-only
-;;;;;; iso-iso2duden iso-iso2gtex iso-gtex2iso iso-tex2iso iso-iso2tex
-;;;;;; iso-german iso-spanish) "iso-cvt" "international/iso-cvt.el"
-;;;;;; (13768 42838))
+;;;;;; iso-sgml2iso iso-iso2sgml iso-iso2duden iso-iso2gtex iso-gtex2iso
+;;;;;; iso-tex2iso iso-iso2tex iso-german iso-spanish) "iso-cvt"
+;;;;;; "international/iso-cvt.el" (14564 29908))
;;; Generated autoloads from international/iso-cvt.el
(autoload (quote iso-spanish) "iso-cvt" "\
Optional arg BUFFER is ignored (so that the function can can be used in
`format-alist')." t nil)
+(autoload (quote iso-iso2sgml) "iso-cvt" "\
+Translate ISO 8859-1 characters in the region to SGML entities.
+The entities used are from \"ISO 8879:1986//ENTITIES Added Latin 1//EN\".
+Optional arg BUFFER is ignored (so that the function can can be used in
+`format-alist')." t nil)
+
+(autoload (quote iso-sgml2iso) "iso-cvt" "\
+Translate SGML entities in the region to ISO 8859-1 characters.
+The entities used are from \"ISO 8879:1986//ENTITIES Added Latin 1//EN\".
+Optional arg BUFFER is ignored (so that the function can can be used in
+`format-alist')." t nil)
+
(autoload (quote iso-cvt-read-only) "iso-cvt" "\
Warn that format is read-only." t nil)
;;;***
\f
;;;### (autoloads nil "iso-transl" "international/iso-transl.el"
-;;;;;; (14164 4477))
+;;;;;; (14716 17385))
;;; 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)
;;;***
\f
-;;;### (autoloads (ispell-message ispell-minor-mode ispell-complete-word-interior-frag
+;;;### (autoloads (ispell-message ispell-minor-mode ispell ispell-complete-word-interior-frag
;;;;;; ispell-complete-word ispell-continue ispell-buffer ispell-comments-and-strings
;;;;;; ispell-region ispell-change-dictionary ispell-kill-ispell
;;;;;; ispell-help ispell-word ispell-dictionary-alist ispell-local-dictionary-alist
;;;;;; ispell-personal-dictionary) "ispell" "textmodes/ispell.el"
-;;;;;; (14457 51532))
+;;;;;; (14859 5489))
;;; Generated autoloads from textmodes/ispell.el
-(defconst ispell-xemacsp (string-match "Lucid\\|XEmacs" emacs-version) "\
+(defconst xemacsp (string-match "Lucid\\|XEmacs" emacs-version) "\
Non nil if using XEmacs.")
-(defconst ispell-version18p (string-match "18\\.[0-9]+\\.[0-9]+" emacs-version) "\
+(defconst version18p (string-match "18\\.[0-9]+\\.[0-9]+" emacs-version) "\
Non nil if using emacs version 18.")
-(defconst ispell-version20p (string-match "20\\.[0-9]+\\.[0-9]+" emacs-version) "\
+(defconst version20p (string-match "20\\.[0-9]+\\.[0-9]+" emacs-version) "\
Non nil if using emacs version 20.")
(defvar ispell-personal-dictionary nil "\
*Contains local or customized dictionary definitions.
See `ispell-dictionary-alist'.")
-(setq ispell-dictionary-alist-1 (quote ((nil "[A-Za-z]" "[^A-Za-z]" "[']" nil ("-B") nil iso-8859-1) ("american" "[A-Za-z]" "[^A-Za-z]" "[']" nil ("-B") nil iso-8859-1) ("brasiliano" "[A-Z\301\311\315\323\332\300\310\314\322\331\303\325\307\334\302\312\324a-z\341\351\355\363\372\340\350\354\362\371\343\365\347\374\342\352\364]" "[^A-Z\301\311\315\323\332\300\310\314\322\331\303\325\307\334\302\312\324a-z\341\351\355\363\372\340\350\354\362\371\343\365\347\374\342\352\364]" "[']" nil ("-d" "brasileiro") nil iso-8859-1) ("british" "[A-Za-z]" "[^A-Za-z]" "[']" nil ("-B" "-d" "british") nil iso-8859-1) ("castellano" "[A-Z\301\311\315\321\323\332\334a-z\341\351\355\361\363\372\374]" "[^A-Z\301\311\315\321\323\332\334a-z\341\351\355\361\363\372\374]" "[---]" nil ("-B" "-d" "castellano") "~tex" iso-8859-1) ("castellano8" "[A-Z\301\311\315\321\323\332\334a-z\341\351\355\361\363\372\374]" "[^A-Z\301\311\315\321\323\332\334a-z\341\351\355\361\363\372\374]" "[---]" nil ("-B" "-d" "castellano") "~latin1" iso-8859-1))))
+(setq ispell-dictionary-alist-1 (quote ((nil "[A-Za-z]" "[^A-Za-z]" "[']" nil ("-B") nil iso-8859-1) ("american" "[A-Za-z]" "[^A-Za-z]" "[']" nil ("-B") nil iso-8859-1) ("brasileiro" "[A-Z\301\311\315\323\332\300\310\314\322\331\303\325\307\334\302\312\324a-z\341\351\355\363\372\340\350\354\362\371\343\365\347\374\342\352\364]" "[^A-Z\301\311\315\323\332\300\310\314\322\331\303\325\307\334\302\312\324a-z\341\351\355\363\372\340\350\354\362\371\343\365\347\374\342\352\364]" "[']" nil ("-d" "brasileiro") nil iso-8859-1) ("british" "[A-Za-z]" "[^A-Za-z]" "[']" nil ("-B" "-d" "british") nil iso-8859-1) ("castellano" "[A-Z\301\311\315\321\323\332\334a-z\341\351\355\361\363\372\374]" "[^A-Z\301\311\315\321\323\332\334a-z\341\351\355\361\363\372\374]" "[-]" nil ("-B" "-d" "castellano") "~tex" iso-8859-1) ("castellano8" "[A-Z\301\311\315\321\323\332\334a-z\341\351\355\361\363\372\374]" "[^A-Z\301\311\315\321\323\332\334a-z\341\351\355\361\363\372\374]" "[-]" nil ("-B" "-d" "castellano") "~latin1" iso-8859-1))))
(setq ispell-dictionary-alist-2 (quote (("czech" "[A-Za-z\301\311\314\315\323\332\331\335\256\251\310\330\317\253\322\341\351\354\355\363\372\371\375\276\271\350\370\357\273\362]" "[^A-Za-z\301\311\314\315\323\332\331\335\256\251\310\330\317\253\322\341\351\354\355\363\372\371\375\276\271\350\370\357\273\362]" "" nil ("-B" "-d" "czech") nil iso-8859-2) ("dansk" "[A-Z\306\330\305a-z\346\370\345]" "[^A-Z\306\330\305a-z\346\370\345]" "[']" nil ("-C") nil iso-8859-1) ("deutsch" "[a-zA-Z\"]" "[^a-zA-Z\"]" "[']" t ("-C") "~tex" iso-8859-1) ("deutsch8" "[a-zA-Z\304\326\334\344\366\337\374]" "[^a-zA-Z\304\326\334\344\366\337\374]" "[']" t ("-C" "-d" "deutsch") "~latin1" iso-8859-1) ("english" "[A-Za-z]" "[^A-Za-z]" "[']" nil ("-B") nil iso-8859-1))))
-(setq ispell-dictionary-alist-3 (quote (("esperanto" "[A-Za-z\246\254\266\274\306\330\335\336\346\370\375\376]" "[^A-Za-z\246\254\266\274\306\330\335\336\346\370\375\376]" "[-']" t ("-C") "~latin3" iso-8859-1) ("esperanto-tex" "[A-Za-z^\\]" "[^A-Za-z^\\]" "[-'`\"]" t ("-C" "-d" "esperanto") "~tex" iso-8859-1) ("francais7" "[A-Za-z]" "[^A-Za-z]" "[`'^---]" t nil nil iso-8859-1) ("francais" "[A-Za-z\300\302\306\307\310\311\312\313\316\317\324\331\333\334\340\342\347\350\351\352\353\356\357\364\371\373\374]" "[^A-Za-z\300\302\306\307\310\311\312\313\316\317\324\331\333\334\340\342\347\350\351\352\353\356\357\364\371\373\374]" "[---']" t nil "~list" iso-8859-1))))
+(setq ispell-dictionary-alist-3 (quote (("esperanto" "[A-Za-z\246\254\266\274\306\330\335\336\346\370\375\376]" "[^A-Za-z\246\254\266\274\306\330\335\336\346\370\375\376]" "[-']" t ("-C") "~latin3" iso-8859-1) ("esperanto-tex" "[A-Za-z^\\]" "[^A-Za-z^\\]" "[-'`\"]" t ("-C" "-d" "esperanto") "~tex" iso-8859-1) ("francais7" "[A-Za-z]" "[^A-Za-z]" "[`'^---]" t nil nil iso-8859-1) ("francais" "[A-Za-z\300\302\306\307\310\311\312\313\316\317\324\331\333\334\340\342\347\350\351\352\353\356\357\364\371\373\374]" "[^A-Za-z\300\302\306\307\310\311\312\313\316\317\324\331\333\334\340\342\347\350\351\352\353\356\357\364\371\373\374]" "[-']" t nil "~list" iso-8859-1))))
-(setq ispell-dictionary-alist-4 (quote (("francais-tex" "[A-Za-z\300\302\306\307\310\311\312\313\316\317\324\331\333\334\340\342\347\350\351\352\353\356\357\364\371\373\374\\]" "[^A-Za-z\300\302\306\307\310\311\312\313\316\317\324\331\333\334\340\342\347\350\351\352\353\356\357\364\371\373\374\\]" "[---'^`\"]" t nil "~tex" iso-8859-1) ("nederlands" "[A-Za-z\300-\305\307\310-\317\322-\326\331-\334\340-\345\347\350-\357\361\362-\366\371-\374]" "[^A-Za-z\300-\305\307\310-\317\322-\326\331-\334\340-\345\347\350-\357\361\362-\366\371-\374]" "[']" t ("-C") nil iso-8859-1) ("nederlands8" "[A-Za-z\300-\305\307\310-\317\322-\326\331-\334\340-\345\347\350-\357\361\362-\366\371-\374]" "[^A-Za-z\300-\305\307\310-\317\322-\326\331-\334\340-\345\347\350-\357\361\362-\366\371-\374]" "[']" t ("-C") nil iso-8859-1))))
+(setq ispell-dictionary-alist-4 (quote (("francais-tex" "[A-Za-z\300\302\306\307\310\311\312\313\316\317\324\331\333\334\340\342\347\350\351\352\353\356\357\364\371\373\374\\]" "[^A-Za-z\300\302\306\307\310\311\312\313\316\317\324\331\333\334\340\342\347\350\351\352\353\356\357\364\371\373\374\\]" "[-'^`\"]" t nil "~tex" iso-8859-1) ("italiano" "[A-Z\300\301\310\311\314\315\322\323\331\332a-z\340\341\350\351\354\355\363\371\372]" "[^A-Z\300\301\310\311\314\315\322\323\331\332a-z\340\341\350\351\354\355\363\371\372]" "[-]" nil ("-B" "-d" "italian") "~tex" iso-8859-1) ("nederlands" "[A-Za-z\300-\305\307\310-\317\322-\326\331-\334\340-\345\347\350-\357\361\362-\366\371-\374]" "[^A-Za-z\300-\305\307\310-\317\322-\326\331-\334\340-\345\347\350-\357\361\362-\366\371-\374]" "[']" t ("-C") nil iso-8859-1) ("nederlands8" "[A-Za-z\300-\305\307\310-\317\322-\326\331-\334\340-\345\347\350-\357\361\362-\366\371-\374]" "[^A-Za-z\300-\305\307\310-\317\322-\326\331-\334\340-\345\347\350-\357\361\362-\366\371-\374]" "[']" t ("-C") nil iso-8859-1))))
(setq ispell-dictionary-alist-5 (quote (("norsk" "[A-Za-z\305\306\307\310\311\322\324\330\345\346\347\350\351\362\364\370]" "[^A-Za-z\305\306\307\310\311\322\324\330\345\346\347\350\351\362\364\370]" "[\"]" nil ("-d" "norsk") "~list" iso-8859-1) ("norsk7-tex" "[A-Za-z{}\\'^`]" "[^A-Za-z{}\\'^`]" "[\"]" nil ("-d" "norsk") "~plaintex" iso-8859-1) ("polish" "[A-Za-z\241\243\246\254\257\261\263\266\274\277\306\312\321\323\346\352\361\363]" "[^A-Za-z\241\243\246\254\257\261\263\266\274\277\306\312\321\323\346\352\361\363]" "" nil ("-d" "polish") nil iso-8859-2))))
-(setq ispell-dictionary-alist-6 (quote (("russian" "[\341\342\367\347\344\345\263\366\372\351\352\353\354\355\356\357\360\362\363\364\365\346\350\343\376\373\375\370\371\377\374\340\361\301\302\327\307\304\305\243\326\332\311\312\313\314\315\316\317\320\322\323\324\325\306\310\303\336\333\335\330\331\337\334\300\321]" "[^\341\342\367\347\344\345\263\366\372\351\352\353\354\355\356\357\360\362\363\364\365\346\350\343\376\373\375\370\371\377\374\340\361\301\302\327\307\304\305\243\326\332\311\312\313\314\315\316\317\320\322\323\324\325\306\310\303\336\333\335\330\331\337\334\300\321]" "" nil ("-d" "russian") nil koi8-r) ("svenska" "[A-Za-z\345\344\366\351\340\374\350\346\370\347\305\304\326\311\300\334\310\306\330\307]" "[^A-Za-z\345\344\366\351\340\374\350\346\370\347\305\304\326\311\300\334\310\306\330\307]" "[']" nil ("-C") "~list" iso-8859-1))))
+(setq ispell-dictionary-alist-6 (quote (("russian" "[\341\342\367\347\344\345\263\366\372\351\352\353\354\355\356\357\360\362\363\364\365\346\350\343\376\373\375\370\371\377\374\340\361\301\302\327\307\304\305\243\326\332\311\312\313\314\315\316\317\320\322\323\324\325\306\310\303\336\333\335\330\331\337\334\300\321]" "[^\341\342\367\347\344\345\263\366\372\351\352\353\354\355\356\357\360\362\363\364\365\346\350\343\376\373\375\370\371\377\374\340\361\301\302\327\307\304\305\243\326\332\311\312\313\314\315\316\317\320\322\323\324\325\306\310\303\336\333\335\330\331\337\334\300\321]" "" nil ("-d" "russian") nil koi8-r) ("svenska" "[A-Za-z\345\344\366\351\340\374\350\346\370\347\305\304\326\311\300\334\310\306\330\307]" "[^A-Za-z\345\344\366\351\340\374\350\346\370\347\305\304\326\311\300\334\310\306\330\307]" "[']" nil ("-C") "~list" iso-8859-1) ("portugues" "[a-zA-Z\301\302\311\323\340\341\342\351\352\355\363\343\372]" "[^a-zA-Z\301\302\311\323\340\341\342\351\352\355\363\343\372]" "[']" t ("-C" "-d" "portugues") "~latin1" iso-8859-1))))
(defvar ispell-dictionary-alist (append ispell-local-dictionary-alist ispell-dictionary-alist-1 ispell-dictionary-alist-2 ispell-dictionary-alist-3 ispell-dictionary-alist-4 ispell-dictionary-alist-5 ispell-dictionary-alist-6) "\
An alist of dictionaries and their associated parameters.
If nil when package is loaded, a standard menu will be set,
and added as a submenu of the \"Edit\" menu.")
-(defvar ispell-menu-map-needed (and (not ispell-menu-map) (not ispell-version18p) (not ispell-xemacsp) (quote reload)))
+(defvar ispell-menu-map-needed (and (not ispell-menu-map) (not version18p) (not xemacsp) (quote reload)))
-(if ispell-menu-map-needed (let ((dicts (reverse (cons (cons "default" nil) ispell-dictionary-alist))) (path (and (boundp (quote ispell-library-path)) ispell-library-path)) name load-dict) (setq ispell-menu-map (make-sparse-keymap "Spell")) (while dicts (setq name (car (car dicts)) load-dict (car (cdr (member "-d" (nth 5 (car dicts))))) dicts (cdr dicts)) (cond ((not (stringp name)) (define-key ispell-menu-map (vector (quote default)) (cons "Select Default Dict" (list (quote lambda) nil (quote (interactive)) (list (quote ispell-change-dictionary) "default"))))) ((or (not path) (file-exists-p (concat path "/" name ".hash")) (file-exists-p (concat path "/" name ".has")) (and load-dict (or (file-exists-p (concat path "/" load-dict ".hash")) (file-exists-p (concat path "/" load-dict ".has"))))) (define-key ispell-menu-map (vector (intern name)) (cons (concat "Select " (capitalize name)) (list (quote lambda) nil (quote (interactive)) (list (quote ispell-change-dictionary) name)))))))))
+(if (and ispell-menu-map-needed (or (not (fboundp (quote byte-compiling-files-p))) (not (byte-compiling-files-p)))) (let ((dicts (reverse (cons (cons "default" nil) ispell-dictionary-alist))) (path (and (boundp (quote ispell-library-path)) ispell-library-path)) name load-dict) (setq ispell-menu-map (make-sparse-keymap "Spell")) (while dicts (setq name (car (car dicts)) load-dict (car (cdr (member "-d" (nth 5 (car dicts))))) dicts (cdr dicts)) (cond ((not (stringp name)) (define-key ispell-menu-map (vector (quote default)) (cons "Select Default Dict" (cons "Dictionary for which Ispell was configured" (list (quote lambda) nil (quote (interactive)) (list (quote ispell-change-dictionary) "default")))))) ((or (not path) (file-exists-p (concat path "/" name ".hash")) (file-exists-p (concat path "/" name ".has")) (and load-dict (or (file-exists-p (concat path "/" load-dict ".hash")) (file-exists-p (concat path "/" load-dict ".has"))))) (define-key ispell-menu-map (vector (intern name)) (cons (concat "Select " (capitalize name) " Dict") (list (quote lambda) nil (quote (interactive)) (list (quote ispell-change-dictionary) name)))))))))
-(if ispell-menu-map-needed (progn (define-key ispell-menu-map [ispell-change-dictionary] (quote ("Change Dictionary" . ispell-change-dictionary))) (define-key ispell-menu-map [ispell-kill-ispell] (quote ("Kill Process" . ispell-kill-ispell))) (define-key ispell-menu-map [ispell-pdict-save] (quote ("Save Dictionary" lambda nil (interactive) (ispell-pdict-save t t)))) (define-key ispell-menu-map [ispell-complete-word] (quote ("Complete Word" . ispell-complete-word))) (define-key ispell-menu-map [ispell-complete-word-interior-frag] (quote ("Complete Word Frag" . ispell-complete-word-interior-frag)))))
+(if (and ispell-menu-map-needed (or (not (fboundp (quote byte-compiling-files-p))) (not (byte-compiling-files-p)))) (progn (define-key ispell-menu-map [ispell-change-dictionary] (quote (menu-item "Change Dictionary..." ispell-change-dictionary :help "Supply explicit path to dictionary"))) (define-key ispell-menu-map [ispell-kill-ispell] (quote (menu-item "Kill Process" ispell-kill-ispell :enable (and (boundp (quote ispell-process)) ispell-process (eq (ispell-process-status) (quote run))) :help "Terminate Ispell subprocess"))) (define-key ispell-menu-map [ispell-pdict-save] (quote (menu-item "Save Dictionary" (lambda nil (interactive) (ispell-pdict-save t t)) :help "Save personal dictionary"))) (define-key ispell-menu-map [ispell-help] (quote (menu-item "Help" (lambda nil (interactive) (describe-function (quote ispell-help))) :help "Show standard Ispell keybindings and commands"))) (define-key ispell-menu-map [ispell-complete-word] (quote (menu-item "Complete Word" ispell-complete-word :help "Complete word at cursor using dictionary"))) (define-key ispell-menu-map [ispell-complete-word-interior-frag] (quote (menu-item "Complete Word Fragment" ispell-complete-word-interior-frag :help "Complete word fragment at cursor")))))
-(if ispell-menu-map-needed (progn (define-key ispell-menu-map [ispell-continue] (quote ("Continue Check" . ispell-continue))) (define-key ispell-menu-map [ispell-word] (quote ("Check Word" . ispell-word))) (define-key ispell-menu-map [ispell-comments-and-strings] (quote ("Check Comments" . ispell-comments-and-strings))) (define-key ispell-menu-map [ispell-region] (quote ("Check Region" . ispell-region))) (define-key ispell-menu-map [ispell-buffer] (quote ("Check Buffer" . ispell-buffer)))))
+(if (and ispell-menu-map-needed (or (not (fboundp (quote byte-compiling-files-p))) (not (byte-compiling-files-p)))) (progn (define-key ispell-menu-map [ispell-continue] (quote (menu-item "Continue Spell-Checking" ispell-continue :enable (and (boundp (quote ispell-region-end)) (marker-position ispell-region-end) (equal (marker-buffer ispell-region-end) (current-buffer))) :help "Continue spell checking last region"))) (define-key ispell-menu-map [ispell-word] (quote (menu-item "Spell-Check Word" ispell-word :help "Spell-check word at cursor"))) (define-key ispell-menu-map [ispell-comments-and-strings] (quote (menu-item "Spell-Check Comments" ispell-comments-and-strings :help "Spell-check only comments and strings")))))
-(if ispell-menu-map-needed (progn (define-key ispell-menu-map [ispell-message] (quote ("Check Message" . ispell-message))) (define-key ispell-menu-map [ispell-help] (quote ("Help" lambda nil (interactive) (describe-function (quote ispell-help))))) (put (quote ispell-region) (quote menu-enable) (quote mark-active)) (fset (quote ispell-menu-map) (symbol-value (quote ispell-menu-map)))))
+(if (and ispell-menu-map-needed (or (not (fboundp (quote byte-compiling-files-p))) (not (byte-compiling-files-p)))) (progn (define-key ispell-menu-map [ispell-region] (quote (menu-item "Spell-Check Region" ispell-region :enable mark-active :help "Spell-check text in marked region"))) (define-key ispell-menu-map [ispell-message] (quote (menu-item "Spell-Check Message" ispell-message :help "Skip headers and included message text"))) (define-key ispell-menu-map [ispell-buffer] (quote (menu-item "Spell-Check Buffer" ispell-buffer :help "Check spelling of selected buffer"))) (fset (quote ispell-menu-map) (symbol-value (quote ispell-menu-map)))))
-(defvar ispell-skip-region-alist (quote ((ispell-words-keyword forward-line) (ispell-dictionary-keyword forward-line) (ispell-pdict-keyword forward-line) (ispell-parsing-keyword forward-line) ("^---*BEGIN PGP [A-Z ]*--*" . "^---*END PGP [A-Z ]*--*") ("^---* \\(Start of \\)?[Ff]orwarded [Mm]essage" . "^---* End of [Ff]orwarded [Mm]essage") ("\\(/\\|\\(\\(\\w\\|-\\)+[.:@]\\)\\)\\(\\w\\|-\\)*\\([.:/@]+\\(\\w\\|-\\|~\\)+\\)+"))) "\
+(defvar ispell-skip-region-alist (quote ((ispell-words-keyword forward-line) (ispell-dictionary-keyword forward-line) (ispell-pdict-keyword forward-line) (ispell-parsing-keyword forward-line) ("^---*BEGIN PGP [A-Z ]*--*" . "^---*END PGP [A-Z ]*--*") ("^---* \\(Start of \\)?[Ff]orwarded [Mm]essage" . "^---* End of [Ff]orwarded [Mm]essage") ("\\(-+\\|\\(/\\|\\(\\(\\w\\|[-_]\\)+[.:@]\\)\\)\\(\\w\\|[-_]\\)*\\([.:/@]+\\(\\w\\|[-_]\\|~\\)+\\)+\\)"))) "\
Alist expressing beginning and end of regions not to spell check.
The alist key must be a regular expression.
Valid forms include:
(KEY REGEXP) - skip to end of REGEXP. REGEXP must be a string.
(KEY FUNCTION ARGS) - FUNCTION called with ARGS returns end of region.")
-(defvar ispell-tex-skip-alists (quote ((("\\\\addcontentsline" ispell-tex-arg-end 2) ("\\\\add\\(tocontents\\|vspace\\)" ispell-tex-arg-end) ("\\\\\\([aA]lph\\|arabic\\)" ispell-tex-arg-end) ("\\\\bibliographystyle" ispell-tex-arg-end) ("\\\\makebox" ispell-tex-arg-end 0) ("\\\\document\\(class\\|style\\)" . "\\\\begin[ \n]*{[ \n]*document[ \n]*}")) (("\\(figure\\|table\\)\\*?" ispell-tex-arg-end 0) ("list" ispell-tex-arg-end 2) ("program" . "\\\\end[ \n]*{[ \n]*program[ \n]*}") ("verbatim\\*?" . "\\\\end[ \n]*{[ \n]*verbatim\\*?[ \n]*}")))) "\
+(defvar ispell-tex-skip-alists (quote ((("\\\\addcontentsline" ispell-tex-arg-end 2) ("\\\\add\\(tocontents\\|vspace\\)" ispell-tex-arg-end) ("\\\\\\([aA]lph\\|arabic\\)" ispell-tex-arg-end) ("\\\\bibliographystyle" ispell-tex-arg-end) ("\\\\makebox" ispell-tex-arg-end 0) ("\\\\e?psfig" ispell-tex-arg-end) ("\\\\document\\(class\\|style\\)" . "\\\\begin[ \n]*{[ \n]*document[ \n]*}")) (("\\(figure\\|table\\)\\*?" ispell-tex-arg-end 0) ("list" ispell-tex-arg-end 2) ("program" . "\\\\end[ \n]*{[ \n]*program[ \n]*}") ("verbatim\\*?" . "\\\\end[ \n]*{[ \n]*verbatim\\*?[ \n]*}")))) "\
*Lists of regions to be skipped in TeX mode.
First list is used raw.
Second list has key placed inside \\begin{}.
(autoload (quote ispell-complete-word-interior-frag) "ispell" "\
Completes word matching character sequence inside a word." t nil)
+(autoload (quote ispell) "ispell" "\
+Interactively check a region or buffer for spelling errors.
+If `transient-mark-mode' is on, and a region is active, spell-check
+that region. Otherwise spell-check the buffer." t nil)
+
(autoload (quote ispell-minor-mode) "ispell" "\
Toggle Ispell minor mode.
With prefix arg, turn Ispell minor mode on iff arg is positive.
-
+
In Ispell minor mode, pressing SPC or RET
warns you if the previous word is incorrectly spelled.
;;;***
\f
-;;;### (autoloads (iswitchb-buffer-other-frame iswitchb-display-buffer
+;;;### (autoloads (iswitchb-mode iswitchb-buffer-other-frame iswitchb-display-buffer
;;;;;; iswitchb-buffer-other-window iswitchb-buffer iswitchb-default-keybindings
-;;;;;; iswitchb-read-buffer) "iswitchb" "iswitchb.el" (14482 55434))
+;;;;;; iswitchb-read-buffer iswitchb-mode) "iswitchb" "iswitchb.el"
+;;;;;; (14821 31349))
;;; Generated autoloads from iswitchb.el
+(defvar iswitchb-mode nil "\
+Toggle Iswitchb mode.
+Setting this variable directly does not take effect;
+use either \\[customize] or the function `iswitchb-mode'.")
+
+(custom-add-to-group (quote iswitchb) (quote iswitchb-mode) (quote custom-variable))
+
+(custom-add-load (quote iswitchb-mode) (quote iswitchb))
+
(autoload (quote iswitchb-read-buffer) "iswitchb" "\
Replacement for the built-in `read-buffer'.
-Return the name of a buffer selected.
+Return the name of a buffer selected.
PROMPT is the prompt to give to the user. DEFAULT if given is the default
buffer to be selected, which will go to the front of the list.
If REQUIRE-MATCH is non-nil, an existing-buffer must be selected." nil nil)
(autoload (quote iswitchb-default-keybindings) "iswitchb" "\
Set up default keybindings for `iswitchb-buffer'.
Call this function to override the normal bindings. This function also
-adds a hook to the minibuffer." t nil)
+adds a hook to the minibuffer.
+
+Obsolescent. Use `iswitchb-mode'." t nil)
(autoload (quote iswitchb-buffer) "iswitchb" "\
Switch to another buffer.
The buffer name is selected interactively by typing a substring.
For details of keybindings, do `\\[describe-function] iswitchb'." t nil)
+(autoload (quote iswitchb-mode) "iswitchb" "\
+Toggle Iswitchb global minor mode.
+With arg, turn Iswitchb mode on if and only iff ARG is positive.
+This mode enables switching between buffers using substrings. See
+`iswitchb' for details." t nil)
+
;;;***
\f
;;;### (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
-;;;;;; setup-japanese-environment) "japan-util" "language/japan-util.el"
-;;;;;; (14348 33291))
+;;;;;; japanese-hankaku japanese-hiragana japanese-katakana setup-japanese-environment-internal)
+;;;;;; "japan-util" "language/japan-util.el" (14718 42200))
;;; Generated autoloads from language/japan-util.el
-(autoload (quote setup-japanese-environment) "japan-util" "\
-Setup multilingual environment (MULE) for Japanese." t nil)
-
(autoload (quote setup-japanese-environment-internal) "japan-util" nil nil nil)
(autoload (quote japanese-katakana) "japan-util" "\
;;;***
\f
-;;;### (autoloads (turn-on-jit-lock jit-lock-mode) "jit-lock" "jit-lock.el"
-;;;;;; (14550 5866))
+;;;### (autoloads (jit-lock-register) "jit-lock" "jit-lock.el" (14829
+;;;;;; 31693))
;;; Generated autoloads from jit-lock.el
-(autoload (quote jit-lock-mode) "jit-lock" "\
-Toggle Just-in-time Lock mode.
-With arg, turn Just-in-time Lock mode on if and only if arg is positive.
-Enable it automatically by customizing group `font-lock'.
-
-When Just-in-time Lock mode is enabled, fontification is different in the
-following ways:
-
-- Demand-driven buffer fontification triggered by Emacs C code.
- This means initial fontification of the whole buffer does not occur.
- Instead, fontification occurs when necessary, such as when scrolling
- through the buffer would otherwise reveal unfontified areas. This is
- useful if buffer fontification is too slow for large buffers.
-
-- Stealthy buffer fontification if `jit-lock-stealth-time' is non-nil.
- This means remaining unfontified areas of buffers are fontified if Emacs has
- been idle for `jit-lock-stealth-time' seconds, while Emacs remains idle.
- This is useful if any buffer has any deferred fontification.
-
-- Deferred context fontification if `jit-lock-defer-contextually' is
- non-nil. This means fontification updates the buffer corresponding to
- true syntactic context, after `jit-lock-stealth-time' seconds of Emacs
- idle time, while Emacs remains idle. Otherwise, fontification occurs
- on modified lines only, and subsequent lines can remain fontified
- corresponding to previous syntactic contexts. This is useful where
- strings or comments span lines.
-
-Stealth fontification only occurs while the system remains unloaded.
-If the system load rises above `jit-lock-stealth-load' percent, stealth
-fontification is suspended. Stealth fontification intensity is controlled via
-the variable `jit-lock-stealth-nice' and `jit-lock-stealth-lines'." t nil)
-
-(autoload (quote turn-on-jit-lock) "jit-lock" "\
-Unconditionally turn on Just-in-time Lock mode." nil nil)
+(autoload (quote jit-lock-register) "jit-lock" "\
+Register FUN as a fontification function to be called in this buffer.
+FUN will be called with two arguments START and END indicating the region
+that needs to be (re)fontified.
+If non-nil, CONTEXTUAL means that a contextual fontification would be useful." nil nil)
;;;***
\f
-;;;### (autoloads (auto-compression-mode) "jka-compr" "jka-compr.el"
-;;;;;; (14495 17985))
+;;;### (autoloads (with-auto-compression-mode auto-compression-mode)
+;;;;;; "jka-compr" "jka-compr.el" (14854 32221))
;;; Generated autoloads from jka-compr.el
(defvar auto-compression-mode nil "\
-Toggle automatic file compression and uncompression.
+Toggle Auto-Compression mode on or off.
+See the command `auto-compression-mode' for a description of this minor-mode.
Setting this variable directly does not take effect;
use either \\[customize] or the function `auto-compression-mode'.")
(custom-add-to-group (quote jka-compr) (quote auto-compression-mode) (quote custom-variable))
(custom-add-load (quote auto-compression-mode) (quote jka-compr))
-(defun auto-compression-mode (&optional arg)
- "\
+
+(autoload (quote auto-compression-mode) "jka-compr" "\
Toggle automatic file compression and uncompression.
With prefix argument ARG, turn auto compression on if positive, else off.
-Returns the new status of auto compression (non-nil means on)."
- (interactive "P")
- (if (not (fboundp 'jka-compr-installed-p))
- (progn
- (require 'jka-compr)
- ;; That turned the mode on, so make it initially off.
- (toggle-auto-compression)))
- (toggle-auto-compression arg t))
+Returns the new status of auto compression (non-nil means on)." t nil)
+
+(autoload (quote with-auto-compression-mode) "jka-compr" "\
+Evalute BODY with automatic file compression and uncompression enabled." nil (quote macro))
;;;***
\f
;;;***
\f
-;;;### (autoloads (kkc-region) "kkc" "international/kkc.el" (13810
-;;;;;; 39823))
+;;;### (autoloads (kkc-region) "kkc" "international/kkc.el" (14762
+;;;;;; 13574))
;;; Generated autoloads from international/kkc.el
+(defvar kkc-after-update-conversion-functions nil "\
+Functions to run after a conversion is selected in `japanese' input method.
+With this input method, a user can select a proper conversion from
+candidate list. Each time he changes the selection, functions in this
+list are called with two arguments; starting and ending buffer
+positions that contains the current selection.")
+
(autoload (quote kkc-region) "kkc" "\
Convert Kana string in the current region to Kanji-Kana mixed string.
Users can select a desirable conversion interactively.
;;;***
\f
-;;;### (autoloads (setup-korean-environment-internal setup-korean-environment)
-;;;;;; "korea-util" "language/korea-util.el" (14293 47672))
+;;;### (autoloads (setup-korean-environment-internal) "korea-util"
+;;;;;; "language/korea-util.el" (14623 45991))
;;; Generated autoloads from language/korea-util.el
(defvar default-korean-keyboard (if (string-match "3" (or (getenv "HANGUL_KEYBOARD_TYPE") "")) "3" "") "\
*The kind of Korean keyboard for Korean input method.
\"\" for 2, \"3\" for 3.")
-(autoload (quote setup-korean-environment) "korea-util" "\
-Setup multilingual environment (MULE) for Korean." t nil)
-
(autoload (quote setup-korean-environment-internal) "korea-util" nil nil nil)
;;;***
\f
;;;### (autoloads (lm lm-test-run) "landmark" "play/landmark.el"
-;;;;;; (14256 23599))
+;;;;;; (14747 44776))
;;; Generated autoloads from play/landmark.el
(defalias (quote landmark-repeat) (quote lm-test-run))
;;;***
\f
-;;;### (autoloads (lao-composition-function lao-transcribe-roman-to-lao-string
-;;;;;; lao-transcribe-single-roman-syllable-to-lao lao-compose-string
-;;;;;; setup-lao-environment) "lao-util" "language/lao-util.el"
-;;;;;; (14423 51007))
+;;;### (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" (14647 32047))
;;; Generated autoloads from language/lao-util.el
-(autoload (quote setup-lao-environment) "lao-util" "\
-Setup multilingual environment (MULE) for Lao." t nil)
-
(autoload (quote lao-compose-string) "lao-util" nil nil nil)
(autoload (quote lao-transcribe-single-roman-syllable-to-lao) "lao-util" "\
The return value is number of composed characters." nil nil)
+(autoload (quote lao-compose-region) "lao-util" nil t nil)
+
+;;;***
+\f
+;;;### (autoloads (latin1-display latin1-display) "latin1-disp" "international/latin1-disp.el"
+;;;;;; (14845 20876))
+;;; Generated autoloads from international/latin1-disp.el
+
+(defvar latin1-display nil "\
+Set up Latin-1/ASCII display for ISO8859 character sets.
+This is done for each character set in the list `latin1-display-sets',
+if no font is available to display it. Characters are displayed using
+the corresponding Latin-1 characters where they match. Otherwise
+ASCII sequences are used, mostly following the Latin prefix input
+methods. Some different ASCII sequences are used if
+`latin1-display-mnemonic' is non-nil.
+
+Setting this variable directly does not take effect;
+use either M-x customize of the function `latin1-display'.")
+
+(custom-add-to-group (quote latin1-display) (quote latin1-display) (quote custom-variable))
+
+(custom-add-load (quote latin1-display) (quote latin1-disp))
+
+(autoload (quote latin1-display) "latin1-disp" "\
+Set up Latin-1/ASCII display for the arguments character SETS.
+See option `latin1-display' for the method. The members of the list
+must be in `latin1-display-sets'. With no arguments, reset the
+display for all of `latin1-display-sets'. See also `latin1-display-setup'." nil nil)
+
;;;***
\f
;;;### (autoloads (turn-on-lazy-lock lazy-lock-mode) "lazy-lock"
;;;***
\f
;;;### (autoloads (ledit-from-lisp-mode ledit-mode) "ledit" "ledit.el"
-;;;;;; (14280 10549))
+;;;;;; (14821 31349))
;;; Generated autoloads from ledit.el
(defconst ledit-save-files t "\
;;;***
\f
-;;;### (autoloads (unload-feature) "loadhist" "loadhist.el" (13935
-;;;;;; 16155))
+;;;### (autoloads (unload-feature) "loadhist" "loadhist.el" (14847
+;;;;;; 14322))
;;; Generated autoloads from loadhist.el
(autoload (quote unload-feature) "loadhist" "\
Unload the library that provided FEATURE, restoring all its autoloads.
-If the feature is required by any other loaded code, and optional FORCE
+If the feature is required by any other loaded code, and prefix arg FORCE
is nil, raise an error." t nil)
;;;***
\f
;;;### (autoloads (locate-with-filter locate) "locate" "locate.el"
-;;;;;; (14396 4034))
+;;;;;; (14763 31121))
;;; Generated autoloads from locate.el
(autoload (quote locate) "locate" "\
;;;***
\f
-;;;### (autoloads (log-edit) "log-edit" "log-edit.el" (14537 49316))
+;;;### (autoloads (log-edit) "log-edit" "log-edit.el" (14854 32221))
;;; Generated autoloads from log-edit.el
(autoload (quote log-edit) "log-edit" "\
Setup a buffer to enter a log message.
-The buffer will be put in `log-edit-mode'.
+\\<log-edit-mode-map>The buffer will be put in `log-edit-mode'.
If SETUP is non-nil, the buffer is then erased and `log-edit-hook' is run.
Mark and point will be set around the entire contents of the
buffer so that it is easy to kill the contents of the buffer with \\[kill-region].
;;;***
\f
-;;;### (autoloads (log-view-mode) "log-view" "log-view.el" (14552
-;;;;;; 48685))
+;;;### (autoloads (log-view-mode) "log-view" "log-view.el" (14631
+;;;;;; 42770))
;;; Generated autoloads from log-view.el
(autoload (quote log-view-mode) "log-view" "\
;;;***
\f
;;;### (autoloads (print-region lpr-region print-buffer lpr-buffer
-;;;;;; lpr-command lpr-switches printer-name) "lpr" "lpr.el" (14440
-;;;;;; 46009))
+;;;;;; lpr-command lpr-switches printer-name) "lpr" "lpr.el" (14693
+;;;;;; 49864))
;;; Generated autoloads from lpr.el
(defvar printer-name (if (memq system-type (quote (ms-dos windows-nt))) "PRN") "\
;;;***
\f
-;;;### (autoloads (m4-mode) "m4-mode" "progmodes/m4-mode.el" (13962
-;;;;;; 30919))
+;;;### (autoloads (m4-mode) "m4-mode" "progmodes/m4-mode.el" (14720
+;;;;;; 7115))
;;; Generated autoloads from progmodes/m4-mode.el
(autoload (quote m4-mode) "m4-mode" "\
;;;***
\f
;;;### (autoloads (apply-macro-to-region-lines kbd-macro-query insert-kbd-macro
-;;;;;; name-last-kbd-macro) "macros" "macros.el" (13229 28845))
+;;;;;; name-last-kbd-macro) "macros" "macros.el" (14856 15439))
;;; Generated autoloads from macros.el
(autoload (quote name-last-kbd-macro) "macros" "\
\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"
-;;;;;; (14075 51598))
+;;;;;; (14723 62186))
;;; Generated autoloads from mail/mail-hist.el
(autoload (quote mail-hist-define-keys) "mail-hist" "\
\f
;;;### (autoloads (mail-fetch-field mail-unquote-printable-region
;;;;;; mail-unquote-printable mail-quote-printable mail-file-babyl-p
-;;;;;; mail-use-rfc822) "mail-utils" "mail/mail-utils.el" (14501
-;;;;;; 36191))
+;;;;;; mail-use-rfc822) "mail-utils" "mail/mail-utils.el" (14800
+;;;;;; 33445))
;;; Generated autoloads from mail/mail-utils.el
(defvar mail-use-rfc822 nil "\
;;;***
\f
;;;### (autoloads (define-mail-abbrev build-mail-abbrevs mail-abbrevs-setup)
-;;;;;; "mailabbrev" "mail/mailabbrev.el" (14495 18025))
+;;;;;; "mailabbrev" "mail/mailabbrev.el" (14747 44775))
;;; Generated autoloads from mail/mailabbrev.el
(autoload (quote mail-abbrevs-setup) "mailabbrev" "\
;;;***
\f
;;;### (autoloads (makefile-mode) "make-mode" "progmodes/make-mode.el"
-;;;;;; (14554 2005))
+;;;;;; (14720 7115))
;;; Generated autoloads from progmodes/make-mode.el
(autoload (quote makefile-mode) "make-mode" "\
;;;***
\f
-;;;### (autoloads (man-follow man) "man" "man.el" (14539 53667))
+;;;### (autoloads (man-follow man) "man" "man.el" (14826 51988))
;;; Generated autoloads from man.el
(defalias (quote manual-entry) (quote man))
command to retrieve and clean a manpage in the background and places the
results in a Man mode (manpage browsing) buffer. See variable
`Man-notify-method' for what happens when the buffer is ready.
-If a buffer already exists for this man page, it will display immediately." t nil)
+If a buffer already exists for this man page, it will display immediately.
+
+To specify a man page from a certain section, type SUBJECT(SECTION) or
+SECTION SUBJECT when prompted for a manual entry." t nil)
(autoload (quote man-follow) "man" "\
Get a Un*x manual page of the item under point and put it in a buffer." t nil)
;;;;;; message-signature message-indent-citation-function message-cite-function
;;;;;; message-yank-prefix message-citation-line-function message-send-mail-function
;;;;;; message-user-organization-file message-signature-separator
-;;;;;; message-from-style) "message" "gnus/message.el" (14030 49419))
+;;;;;; message-from-style) "message" "gnus/message.el" (14858 32485))
;;; Generated autoloads from gnus/message.el
(defvar message-from-style (quote default) "\
The headers should be delimited by a line whose contents match the
variable `mail-header-separator'.
-Legal values include `message-send-mail-with-sendmail' (the default),
+Valid values include `message-send-mail-with-sendmail' (the default),
`message-send-mail-with-mh', `message-send-mail-with-qmail' and
`smtpmail-send-it'.")
*Function called to insert the \"Whomever writes:\" line.")
(defvar message-yank-prefix "> " "\
-*Prefix inserted on the lines of yanked messages.
-nil means use indentation.")
+*Prefix inserted on the lines of yanked messages.")
(defvar message-cite-function (quote message-cite-original) "\
*Function for citing an original message.
(defvar message-signature-file "~/.signature" "\
*File containing the text inserted at end of message buffer.")
-(condition-case nil (define-mail-user-agent (quote message-user-agent) (quote message-mail) (quote message-send-and-exit) (quote message-kill-buffer) (quote message-send-hook)) (error nil))
+(define-mail-user-agent (quote message-user-agent) (quote message-mail) (quote message-send-and-exit) (quote message-kill-buffer) (quote message-send-hook))
(autoload (quote message-mode) "message" "\
Major mode for editing mail and news to be sent.
Like Text Mode but with these additional commands:
C-c C-s message-send (send the message) C-c C-c message-send-and-exit
+C-c C-d Pospone sending the message C-c C-k Kill the message
C-c C-f move to a header field (and create it if there isn't):
C-c C-f C-t move to To C-c C-f C-s move to Subject
C-c C-f C-c move to Cc C-c C-f C-b move to Bcc
C-c C-y message-yank-original (insert current message, if any).
C-c C-q message-fill-yanked-message (fill what was yanked).
C-c C-e message-elide-region (elide the text between point and mark).
+C-c C-v message-delete-not-region (remove the text outside the region).
C-c C-z message-kill-to-signature (kill the text up to the signature).
-C-c C-r message-caesar-buffer-body (rot13 the message body)." t nil)
+C-c C-r message-caesar-buffer-body (rot13 the message body).
+C-c C-a mml-attach-file (attach a file as MIME).
+M-RET message-newline-and-reformat (break the line and reformat)." t nil)
(autoload (quote message-mail) "message" "\
Start editing a mail message to be sent.
If TO-NEWSGROUPS, use that as the new Newsgroups line." t nil)
(autoload (quote message-cancel-news) "message" "\
-Cancel an article you posted." t nil)
+Cancel an article you posted.
+If ARG, allow editing of the cancellation message." t nil)
(autoload (quote message-supersede) "message" "\
Start composing a message to supersede the current message.
(autoload (quote message-forward) "message" "\
Forward the current message via mail.
-Optional NEWS will use news to forward instead of mail." t nil)
+Optional NEWS will use news to forward instead of mail.
+Optional DIGEST will use digest to forward." t nil)
(autoload (quote message-resend) "message" "\
Resend the current article to ADDRESS." t nil)
(autoload (quote message-bounce) "message" "\
Re-mail the current message.
-This only makes sense if the current message is a bounce message than
+This only makes sense if the current message is a bounce message that
contains some mail you have written which has been bounced back to
you." t nil)
;;;***
\f
;;;### (autoloads (mh-letter-mode mh-smail-other-window mh-smail-batch
-;;;;;; mh-smail) "mh-comp" "mail/mh-comp.el" (14460 38678))
+;;;;;; mh-smail) "mh-comp" "mail/mh-comp.el" (14849 24594))
;;; Generated autoloads from mail/mh-comp.el
(autoload (quote mh-smail) "mh-comp" "\
;;;***
\f
-;;;### (autoloads (mh-version mh-rmail) "mh-e" "mail/mh-e.el" (14532
-;;;;;; 63447))
+;;;### (autoloads (mh-version mh-rmail) "mh-e" "mail/mh-e.el" (14849
+;;;;;; 24610))
;;; Generated autoloads from mail/mh-e.el
(autoload (quote mh-rmail) "mh-e" "\
;;;***
\f
-;;;### (autoloads nil "mh-utils" "mail/mh-utils.el" (14457 61243))
+;;;### (autoloads nil "mh-utils" "mail/mh-utils.el" (14484 43737))
;;; Generated autoloads from mail/mh-utils.el
(put (quote mh-progs) (quote risky-local-variable) t)
;;;***
\f
;;;### (autoloads (midnight-delay-set clean-buffer-list) "midnight"
-;;;;;; "midnight.el" (14035 10445))
+;;;;;; "midnight.el" (14721 29450))
;;; Generated autoloads from midnight.el
(autoload (quote clean-buffer-list) "midnight" "\
;;;***
\f
;;;### (autoloads (convert-mocklisp-buffer) "mlconvert" "emulation/mlconvert.el"
-;;;;;; (12536 45574))
+;;;;;; (14660 49410))
;;; Generated autoloads from emulation/mlconvert.el
(autoload (quote convert-mocklisp-buffer) "mlconvert" "\
Convert buffer of Mocklisp code to real Lisp that GNU Emacs can run." t nil)
+;;;***
+\f
+;;;### (autoloads (mm-inline-partial) "mm-partial" "gnus/mm-partial.el"
+;;;;;; (14854 32223))
+;;; Generated autoloads from gnus/mm-partial.el
+
+(autoload (quote mm-inline-partial) "mm-partial" "\
+Show the partial part of HANDLE.
+This function replaces the buffer of HANDLE with a buffer contains
+the entire message.
+If NO-DISPLAY is nil, display it. Otherwise, do nothing after replacing." nil nil)
+
;;;***
\f
;;;### (autoloads (modula-2-mode) "modula2" "progmodes/modula2.el"
;;;***
\f
-;;;### (autoloads (mouse-sel-mode) "mouse-sel" "mouse-sel.el" (14118
-;;;;;; 2283))
+;;;### (autoloads (unmorse-region morse-region) "morse" "play/morse.el"
+;;;;;; (14821 31351))
+;;; Generated autoloads from play/morse.el
+
+(autoload (quote morse-region) "morse" "\
+Convert all text in a given region to morse code." t nil)
+
+(autoload (quote unmorse-region) "morse" "\
+Convert morse coded text in region to ordinary ASCII text." t nil)
+
+;;;***
+\f
+;;;### (autoloads (mouse-sel-mode) "mouse-sel" "mouse-sel.el" (14736
+;;;;;; 26481))
;;; Generated autoloads from mouse-sel.el
(autoload (quote mouse-sel-mode) "mouse-sel" "\
Quad-clicking selects paragraphs.
- Selecting sets the region & X primary selection, but does NOT affect
-the kill-ring. Because the mouse handlers set the primary selection
-directly, mouse-sel sets the variables interprogram-cut-function
-and interprogram-paste-function to nil.
+the kill-ring, nor do the kill-ring function change the X selection.
+Because the mouse handlers set the primary selection directly,
+mouse-sel sets the variables interprogram-cut-function and
+interprogram-paste-function to nil.
- Clicking mouse-2 inserts the contents of the primary selection at
the mouse position (or point, if mouse-yank-at-point is non-nil).
;;;***
\f
-;;;### (autoloads (msb-mode msb-mode) "msb" "msb.el" (14263 63030))
+;;;### (autoloads (msb-mode) "msb" "msb.el" (14854 32222))
;;; Generated autoloads from msb.el
(defvar msb-mode nil "\
-Toggle msb-mode.
+Toggle Msb mode on or off.
+See the command `msb-mode' for a description of this minor-mode.
Setting this variable directly does not take effect;
use either \\[customize] or the function `msb-mode'.")
;;;### (autoloads (dump-codings dump-charsets mule-diag list-input-methods
;;;;;; list-fontsets describe-fontset describe-font list-coding-categories
;;;;;; list-coding-systems describe-current-coding-system describe-current-coding-system-briefly
-;;;;;; describe-coding-system list-charset-chars read-charset list-character-sets)
-;;;;;; "mule-diag" "international/mule-diag.el" (14551 28679))
+;;;;;; describe-coding-system describe-char-after describe-character-set
+;;;;;; list-charset-chars read-charset list-character-sets) "mule-diag"
+;;;;;; "international/mule-diag.el" (14763 35975))
;;; Generated autoloads from international/mule-diag.el
(autoload (quote list-character-sets) "mule-diag" "\
(autoload (quote list-charset-chars) "mule-diag" "\
Display a list of characters in the specified character set." t nil)
+(autoload (quote describe-character-set) "mule-diag" "\
+Display information about character set CHARSET." t nil)
+
+(autoload (quote describe-char-after) "mule-diag" "\
+Display information of in current buffer at position POS.
+The information includes character code, charset and code points in it,
+syntax, category, how the character is encoded in a file,
+which font is being used for displaying the character." t nil)
+
(autoload (quote describe-coding-system) "mule-diag" "\
Display information about CODING-SYSTEM." t nil)
The format is \"F[..],K[..],T[..],P>[..],P<[..], default F[..],P<[..],P<[..]\",
where mnemonics of the following coding systems come in this order
at the place of `..':
- `buffer-file-coding-system` (of the current buffer)
- eol-type of buffer-file-coding-system (of the current buffer)
+ `buffer-file-coding-system' (of the current buffer)
+ eol-type of `buffer-file-coding-system' (of the current buffer)
Value returned by `keyboard-coding-system'
- eol-type of (keyboard-coding-system)
- Value returned by `terminal-coding-system.
- eol-type of (terminal-coding-system)
+ eol-type of `keyboard-coding-system'
+ Value returned by `terminal-coding-system'.
+ eol-type of `terminal-coding-system'
`process-coding-system' for read (of the current buffer, if any)
- eol-type of process-coding-system for read (of the current buffer, if any)
+ eol-type of `process-coding-system' for read (of the current buffer, if any)
`process-coding-system' for write (of the current buffer, if any)
- eol-type of process-coding-system for write (of the current buffer, if any)
+ eol-type of `process-coding-system' for write (of the current buffer, if any)
`default-buffer-file-coding-system'
- eol-type of default-buffer-file-coding-system
+ eol-type of `default-buffer-file-coding-system'
`default-process-coding-system' for read
- eol-type of default-process-coding-system for read
+ eol-type of `default-process-coding-system' for read
`default-process-coding-system' for write
- eol-type of default-process-coding-system" t nil)
+ eol-type of `default-process-coding-system'" t nil)
(autoload (quote describe-current-coding-system) "mule-diag" "\
Display coding systems currently used, in detail." t nil)
(autoload (quote describe-fontset) "mule-diag" "\
Display information of FONTSET.
-This shows the name, size, and style of FONTSET, and the list of fonts
-contained in FONTSET.
-
-The column WDxHT contains width and height (pixels) of each fontset
-\(i.e. those of ASCII font in the fontset). The letter `-' in this
-column means that the corresponding fontset is not yet used in any
-frame.
-
-The O column for each font contains one of the following letters:
- o -- font already opened
- - -- font not yet opened
- x -- font can't be opened
- ? -- no font specified
-
-The Charset column for each font contains a name of character set
-displayed (for this fontset) using that font." t nil)
+This shows which font is used for which character(s)." t nil)
(autoload (quote list-fontsets) "mule-diag" "\
Display a list of all fontsets.
;;;;;; coding-system-post-read-conversion coding-system-eol-type-mnemonic
;;;;;; lookup-nested-alist set-nested-alist truncate-string-to-width
;;;;;; store-substring string-to-sequence) "mule-util" "international/mule-util.el"
-;;;;;; (14423 50997))
+;;;;;; (14647 32042))
;;; Generated autoloads from international/mule-util.el
(autoload (quote string-to-sequence) "mule-util" "\
Convert STRING to a sequence of TYPE which contains characters in STRING.
TYPE should be `list' or `vector'." nil nil)
-(defsubst string-to-list (string) "Return a list of characters in STRING." (string-to-sequence string (quote list)))
+(defsubst string-to-list (string) "\
+Return a list of characters in STRING." (string-to-sequence string (quote list)))
-(defsubst string-to-vector (string) "Return a vector of characters in STRING." (string-to-sequence string (quote vector)))
+(defsubst string-to-vector (string) "\
+Return a vector of characters in STRING." (string-to-sequence string (quote vector)))
(autoload (quote store-substring) "mule-util" "\
Embed OBJ (string or character) at index IDX of STRING." nil nil)
(defalias (quote truncate-string) (quote truncate-string-to-width))
-(defsubst nested-alist-p (obj) "Return t if OBJ is a nested alist.\n\nNested alist is a list of the form (ENTRY . BRANCHES), where ENTRY is\nany Lisp object, and BRANCHES is a list of cons cells of the form\n(KEY-ELEMENT . NESTED-ALIST).\n\nYou can use a nested alist to store any Lisp object (ENTRY) for a key\nsequence KEYSEQ, where KEYSEQ is a sequence of KEY-ELEMENT. KEYSEQ\ncan be a string, a vector, or a list." (and obj (listp obj) (listp (cdr obj))))
+(defsubst nested-alist-p (obj) "\
+Return t if OBJ is a nested alist.
+
+Nested alist is a list of the form (ENTRY . BRANCHES), where ENTRY is
+any Lisp object, and BRANCHES is a list of cons cells of the form
+\(KEY-ELEMENT . NESTED-ALIST).
+
+You can use a nested alist to store any Lisp object (ENTRY) for a key
+sequence KEYSEQ, where KEYSEQ is a sequence of KEY-ELEMENT. KEYSEQ
+can be a string, a vector, or a list." (and obj (listp obj) (listp (cdr obj))))
(autoload (quote set-nested-alist) "mule-util" "\
Set ENTRY for KEYSEQ in a nested alist ALIST.
;;;***
\f
-;;;### (autoloads (mwheel-install) "mwheel" "mwheel.el" (14378 51930))
+;;;### (autoloads (mwheel-install mouse-wheel-mode) "mwheel" "mwheel.el"
+;;;;;; (14854 32222))
;;; Generated autoloads from mwheel.el
+(defvar mouse-wheel-mode nil "\
+Toggle Mouse-Wheel mode on or off.
+See the command `mouse-wheel-mode' for a description of this minor-mode.
+Setting this variable directly does not take effect;
+use either \\[customize] or the function `mouse-wheel-mode'.")
+
+(custom-add-to-group (quote mouse) (quote mouse-wheel-mode) (quote custom-variable))
+
+(custom-add-load (quote mouse-wheel-mode) (quote mwheel))
+
+(autoload (quote mouse-wheel-mode) "mwheel" "\
+Toggle mouse wheel support.
+With prefix argument ARG, turn on if positive, otherwise off.
+Returns non-nil if the new state is enabled." t nil)
+
(autoload (quote mwheel-install) "mwheel" "\
Enable mouse wheel support." nil nil)
;;;### (autoloads (network-connection network-connection-to-service
;;;;;; whois-reverse-lookup whois finger ftp dig nslookup nslookup-host
;;;;;; route arp netstat ipconfig ping traceroute) "net-utils" "net/net-utils.el"
-;;;;;; (14385 24830))
+;;;;;; (14813 44131))
;;; Generated autoloads from net/net-utils.el
(autoload (quote traceroute) "net-utils" "\
(autoload (quote ping) "net-utils" "\
Ping HOST.
-If your system's ping continues until interrupted, you can try setting
+If your system's ping continues until interrupted, you can try setting
`ping-program-options'." t nil)
(autoload (quote ipconfig) "net-utils" "\
;;;***
\f
-;;;### (autoloads (nndoc-add-type) "nndoc" "gnus/nndoc.el" (14030
-;;;;;; 49432))
+;;;### (autoloads (comment-indent-new-line comment-dwim comment-region
+;;;;;; uncomment-region comment-kill comment-set-column comment-indent
+;;;;;; comment-indent-default comment-multi-line comment-padding
+;;;;;; comment-style comment-column) "newcomment" "newcomment.el"
+;;;;;; (14821 31349))
+;;; Generated autoloads from newcomment.el
+
+(defalias (quote indent-for-comment) (quote comment-indent))
+
+(defalias (quote set-comment-column) (quote comment-set-column))
+
+(defalias (quote kill-comment) (quote comment-kill))
+
+(defalias (quote indent-new-comment-line) (quote comment-indent-new-line))
+
+(defgroup comment nil "Indenting and filling of comments." :prefix "comment-" :version "21.1" :group (quote fill))
+
+(defvar comment-column 32 "\
+*Column to indent right-margin comments to.
+Setting this variable automatically makes it local to the current buffer.
+Each mode establishes a different default value for this variable; you
+can set the value for a particular mode using that mode's hook.")
+
+(defvar comment-start nil "\
+*String to insert to start a new comment, or nil if no comment syntax.")
+
+(defvar comment-start-skip nil "\
+*Regexp to match the start of a comment plus everything up to its body.
+If there are any \\(...\\) pairs, the comment delimiter text is held to begin
+at the place matched by the close of the first pair.")
+
+(defvar comment-end-skip nil "\
+Regexp to match the end of a comment plus everything up to its body.")
+
+(defvar comment-end "" "\
+*String to insert to end a new comment.
+Should be an empty string if comments are terminated by end-of-line.")
+
+(defvar comment-indent-function (quote comment-indent-default) "\
+Function to compute desired indentation for a comment.
+This function is called with no args with point at the beginning of
+the comment's starting delimiter and should return either the desired
+column indentation or nil.
+If nil is returned, indentation is delegated to `indent-according-to-mode'.")
+
+(defvar comment-style (quote plain) "\
+*Style to be used for `comment-region'.
+See `comment-styles' for a list of available styles.")
+
+(defvar comment-padding " " "\
+Padding string that `comment-region' puts between comment chars and text.
+Can also be an integer which will be automatically turned into a string
+of the corresponding number of spaces.
+
+Extra spacing between the comment characters and the comment text
+makes the comment easier to read. Default is 1. nil means 0.")
+
+(defvar comment-multi-line nil "\
+*Non-nil means \\[comment-indent-new-line] continues comments, with no new terminator or starter.
+This is obsolete because you might as well use \\[newline-and-indent].")
+
+(autoload (quote comment-indent-default) "newcomment" "\
+Default for `comment-indent-function'." nil nil)
+
+(autoload (quote comment-indent) "newcomment" "\
+Indent this line's comment to comment column, or insert an empty comment.
+If CONTINUE is non-nil, use the `comment-continuation' markers if any." t nil)
+
+(autoload (quote comment-set-column) "newcomment" "\
+Set the comment column based on point.
+With no ARG, set the comment column to the current column.
+With just minus as arg, kill any comment on this line.
+With any other arg, set comment column to indentation of the previous comment
+ and then align or create a comment on this line at that column." t nil)
+
+(autoload (quote comment-kill) "newcomment" "\
+Kill the comment on this line, if any.
+With prefix ARG, kill comments on that many lines starting with this one." t nil)
+
+(autoload (quote uncomment-region) "newcomment" "\
+Uncomment each line in the BEG..END region.
+The numeric prefix ARG can specify a number of chars to remove from the
+comment markers." t nil)
+
+(autoload (quote comment-region) "newcomment" "\
+Comment or uncomment each line in the region.
+With just \\[universal-prefix] prefix arg, uncomment each line in region BEG..END.
+Numeric prefix arg ARG means use ARG comment characters.
+If ARG is negative, delete that many comment characters instead.
+By default, comments start at the left margin, are terminated on each line,
+even for syntax in which newline does not end the comment and blank lines
+do not get comments. This can be changed with `comment-style'.
+
+The strings used as comment starts are built from
+`comment-start' without trailing spaces and `comment-padding'." t nil)
+
+(autoload (quote comment-dwim) "newcomment" "\
+Call the comment command you want (Do What I Mean).
+If the region is active and `transient-mark-mode' is on, call
+ `comment-region' (unless it only consists in comments, in which
+ case it calls `uncomment-region').
+Else, if the current line is empty, insert a comment and indent it.
+Else if a prefix ARG is specified, call `comment-kill'.
+Else, call `comment-indent'." t nil)
+
+(autoload (quote comment-indent-new-line) "newcomment" "\
+Break line at point and indent, continuing comment if within one.
+This indents the body of the continued comment
+under the previous comment line.
+
+This command is intended for styles where you write a comment per line,
+starting a new comment (and terminating it if necessary) on each line.
+If you want to continue one comment across several lines, use \\[newline-and-indent].
+
+If a fill column is specified, it overrides the use of the comment column
+or comment indentation.
+
+The inserted newline is marked hard if variable `use-hard-newlines' is true,
+unless optional argument SOFT is non-nil." t nil)
+
+;;;***
+\f
+;;;### (autoloads (nndoc-add-type) "nndoc" "gnus/nndoc.el" (14858
+;;;;;; 32485))
;;; Generated autoloads from gnus/nndoc.el
(autoload (quote nndoc-add-type) "nndoc" "\
;;;***
\f
;;;### (autoloads (nnfolder-generate-active-file) "nnfolder" "gnus/nnfolder.el"
-;;;;;; (14030 49439))
+;;;;;; (14813 40531))
;;; Generated autoloads from gnus/nnfolder.el
(autoload (quote nnfolder-generate-active-file) "nnfolder" "\
-Look for mbox folders in the nnfolder directory and make them into groups." t nil)
+Look for mbox folders in the nnfolder directory and make them into groups.
+This command does not work if you use short group names." t nil)
;;;***
\f
;;;### (autoloads (nnkiboze-generate-groups) "nnkiboze" "gnus/nnkiboze.el"
-;;;;;; (14030 49445))
+;;;;;; (14845 20875))
;;; Generated autoloads from gnus/nnkiboze.el
(autoload (quote nnkiboze-generate-groups) "nnkiboze" "\
;;;***
\f
;;;### (autoloads (nnml-generate-nov-databases) "nnml" "gnus/nnml.el"
-;;;;;; (14030 49457))
+;;;;;; (14858 32485))
;;; Generated autoloads from gnus/nnml.el
(autoload (quote nnml-generate-nov-databases) "nnml" "\
;;;***
\f
;;;### (autoloads (nnsoup-revert-variables nnsoup-set-variables nnsoup-pack-replies)
-;;;;;; "nnsoup" "gnus/nnsoup.el" (14293 3539))
+;;;;;; "nnsoup" "gnus/nnsoup.el" (14792 2698))
;;; Generated autoloads from gnus/nnsoup.el
(autoload (quote nnsoup-pack-replies) "nnsoup" "\
;;;***
\f
;;;### (autoloads (inferior-octave) "octave-inf" "progmodes/octave-inf.el"
-;;;;;; (14302 32388))
+;;;;;; (14747 44776))
;;; Generated autoloads from progmodes/octave-inf.el
(autoload (quote inferior-octave) "octave-inf" "\
;;;***
\f
;;;### (autoloads (octave-mode) "octave-mod" "progmodes/octave-mod.el"
-;;;;;; (14535 42068))
+;;;;;; (14535 42824))
;;; Generated autoloads from progmodes/octave-mod.el
(autoload (quote octave-mode) "octave-mod" "\
;;;***
\f
;;;### (autoloads (edit-options list-options) "options" "options.el"
-;;;;;; (14045 29847))
+;;;;;; (14821 31349))
;;; Generated autoloads from options.el
(autoload (quote list-options) "options" "\
-Display a list of Emacs user options, with values and documentation." t nil)
+Display a list of Emacs user options, with values and documentation.
+It is now better to use Customize instead." t nil)
(autoload (quote edit-options) "options" "\
Edit a list of Emacs user option values.
;;;***
\f
;;;### (autoloads (outline-minor-mode outline-mode) "outline" "textmodes/outline.el"
-;;;;;; (14495 18064))
+;;;;;; (14807 56561))
;;; Generated autoloads from textmodes/outline.el
(autoload (quote outline-mode) "outline" "\
;;;***
\f
-;;;### (autoloads (show-paren-mode show-paren-mode) "paren" "paren.el"
-;;;;;; (14316 49544))
+;;;### (autoloads (show-paren-mode) "paren" "paren.el" (14854 32222))
;;; Generated autoloads from paren.el
(defvar show-paren-mode nil "\
-*Toggle Show Paren mode.
-When Show Paren mode is enabled, any matching parenthesis is highlighted
-after `show-paren-delay' seconds of Emacs idle time.
+Toggle Show-Paren mode on or off.
+See the command `show-paren-mode' for a description of this minor-mode.
Setting this variable directly does not take effect;
use either \\[customize] or the function `show-paren-mode'.")
;;;***
\f
-;;;### (autoloads (pascal-mode) "pascal" "progmodes/pascal.el" (14507
-;;;;;; 63078))
+;;;### (autoloads (pascal-mode) "pascal" "progmodes/pascal.el" (14628
+;;;;;; 14481))
;;; Generated autoloads from progmodes/pascal.el
(autoload (quote pascal-mode) "pascal" "\
;;;***
\f
;;;### (autoloads (pc-selection-mode pc-selection-mode) "pc-select"
-;;;;;; "emulation/pc-select.el" (13674 34216))
+;;;;;; "emulation/pc-select.el" (14783 15356))
;;; Generated autoloads from emulation/pc-select.el
(autoload (quote pc-selection-mode) "pc-select" "\
;;;***
\f
-;;;### (autoloads (cvs-dired-use-hook cvs-status cvs-update cvs-examine
-;;;;;; cvs-checkout) "pcvs" "pcvs.el" (14552 48942))
+;;;### (autoloads (pcomplete/cvs) "pcmpl-cvs" "pcmpl-cvs.el" (14680
+;;;;;; 33021))
+;;; Generated autoloads from pcmpl-cvs.el
+
+(autoload (quote pcomplete/cvs) "pcmpl-cvs" "\
+Completion rules for the `cvs' command." nil nil)
+
+;;;***
+\f
+;;;### (autoloads (pcomplete/tar pcomplete/make pcomplete/bzip2 pcomplete/gzip)
+;;;;;; "pcmpl-gnu" "pcmpl-gnu.el" (14763 35955))
+;;; Generated autoloads from pcmpl-gnu.el
+
+(autoload (quote pcomplete/gzip) "pcmpl-gnu" "\
+Completion for `gzip'." nil nil)
+
+(autoload (quote pcomplete/bzip2) "pcmpl-gnu" "\
+Completion for `bzip2'." nil nil)
+
+(autoload (quote pcomplete/make) "pcmpl-gnu" "\
+Completion for GNU `make'." nil nil)
+
+(autoload (quote pcomplete/tar) "pcmpl-gnu" "\
+Completion for the GNU tar utility." nil nil)
+
+(defalias (quote pcomplete/gdb) (quote pcomplete/xargs))
+
+;;;***
+\f
+;;;### (autoloads (pcomplete/mount pcomplete/umount pcomplete/kill)
+;;;;;; "pcmpl-linux" "pcmpl-linux.el" (14680 33024))
+;;; Generated autoloads from pcmpl-linux.el
+
+(autoload (quote pcomplete/kill) "pcmpl-linux" "\
+Completion for GNU/Linux `kill', using /proc filesystem." nil nil)
+
+(autoload (quote pcomplete/umount) "pcmpl-linux" "\
+Completion for GNU/Linux `umount'." nil nil)
+
+(autoload (quote pcomplete/mount) "pcmpl-linux" "\
+Completion for GNU/Linux `mount'." nil nil)
+
+;;;***
+\f
+;;;### (autoloads (pcomplete/rpm) "pcmpl-rpm" "pcmpl-rpm.el" (14680
+;;;;;; 33025))
+;;; Generated autoloads from pcmpl-rpm.el
+
+(autoload (quote pcomplete/rpm) "pcmpl-rpm" "\
+Completion for RedHat's `rpm' command.
+These rules were taken from the output of `rpm --help' on a RedHat 6.1
+system. They follow my interpretation of what followed, but since I'm
+not a major rpm user/builder, please send me any corrections you find.
+You can use \\[eshell-report-bug] to do so." nil nil)
+
+;;;***
+\f
+;;;### (autoloads (pcomplete/chgrp pcomplete/chown pcomplete/which
+;;;;;; pcomplete/xargs pcomplete/rm pcomplete/rmdir pcomplete/cd)
+;;;;;; "pcmpl-unix" "pcmpl-unix.el" (14680 33026))
+;;; Generated autoloads from pcmpl-unix.el
+
+(autoload (quote pcomplete/cd) "pcmpl-unix" "\
+Completion for `cd'." nil nil)
+
+(defalias (quote pcomplete/pushd) (quote pcomplete/cd))
+
+(autoload (quote pcomplete/rmdir) "pcmpl-unix" "\
+Completion for `rmdir'." nil nil)
+
+(autoload (quote pcomplete/rm) "pcmpl-unix" "\
+Completion for `rm'." nil nil)
+
+(autoload (quote pcomplete/xargs) "pcmpl-unix" "\
+Completion for `xargs'." nil nil)
+
+(defalias (quote pcomplete/time) (quote pcomplete/xargs))
+
+(autoload (quote pcomplete/which) "pcmpl-unix" "\
+Completion for `which'." nil nil)
+
+(autoload (quote pcomplete/chown) "pcmpl-unix" "\
+Completion for the `chown' command." nil nil)
+
+(autoload (quote pcomplete/chgrp) "pcmpl-unix" "\
+Completion for the `chgrp' command." nil nil)
+
+;;;***
+\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" (14826
+;;;;;; 56519))
+;;; Generated autoloads from pcomplete.el
+
+(autoload (quote pcomplete) "pcomplete" "\
+Support extensible programmable completion.
+To use this function, just bind the TAB key to it, or add it to your
+completion functions list (it should occur fairly early in the list)." t nil)
+
+(autoload (quote pcomplete-reverse) "pcomplete" "\
+If cycling completion is in use, cycle backwards." t nil)
+
+(autoload (quote pcomplete-expand-and-complete) "pcomplete" "\
+Expand the textual value of the current argument.
+This will modify the current buffer." t nil)
+
+(autoload (quote pcomplete-continue) "pcomplete" "\
+Complete without reference to any cycling completions." t nil)
+
+(autoload (quote pcomplete-expand) "pcomplete" "\
+Expand the textual value of the current argument.
+This will modify the current buffer." t nil)
+
+(autoload (quote pcomplete-help) "pcomplete" "\
+Display any help information relative to the current argument." t nil)
+
+(autoload (quote pcomplete-list) "pcomplete" "\
+Show the list of possible completions for the current argument." t nil)
+
+(autoload (quote pcomplete-comint-setup) "pcomplete" "\
+Setup a comint buffer to use pcomplete.
+COMPLETEF-SYM should be the symbol where the
+dynamic-complete-functions are kept. For comint mode itself, this is
+`comint-dynamic-complete-functions'." nil nil)
+
+(autoload (quote pcomplete-shell-setup) "pcomplete" "\
+Setup shell-mode to use pcomplete." nil nil)
+
+;;;***
+\f
+;;;### (autoloads (cvs-dired-use-hook cvs-dired-action cvs-status
+;;;;;; cvs-update cvs-examine cvs-quickdir cvs-checkout) "pcvs"
+;;;;;; "pcvs.el" (14854 32222))
;;; Generated autoloads from pcvs.el
(autoload (quote cvs-checkout) "pcvs" "\
With a prefix argument, prompt for cvs FLAGS to use." t nil)
+(autoload (quote cvs-quickdir) "pcvs" "\
+Open a *cvs* buffer on DIR without running cvs.
+With a prefix argument, prompt for a directory to use.
+A prefix arg >8 (ex: \\[universal-argument] \\[universal-argument]),
+ prevents reuse of an existing *cvs* buffer.
+Optional argument NOSHOW if non-nil means not to display the buffer.
+FLAGS is ignored." t nil)
+
(autoload (quote cvs-examine) "pcvs" "\
Run a `cvs -n update' in the specified DIRECTORY.
That is, check what needs to be done, but don't change the disc.
(add-to-list (quote completion-ignored-extensions) "CVS/")
+(defvar cvs-dired-action (quote cvs-quickdir) "\
+The action to be performed when opening a CVS directory.
+Sensible values are `cvs-examine', `cvs-status' and `cvs-quickdir'.")
+
(defvar cvs-dired-use-hook (quote (4)) "\
Whether or not opening a CVS directory should run PCL-CVS.
NIL means never do it.
command that prompted the opening of the directory.
Anything else means to do it only if the prefix arg is equal to this value.")
-(progn (defun cvs-dired-noselect (dir) "Run `cvs-examine' if DIR is a CVS administrative directory.\nThe exact behavior is determined also by `cvs-dired-use-hook'." (when (stringp dir) (setq dir (directory-file-name dir)) (when (and (string= "CVS" (file-name-nondirectory dir)) (file-readable-p (expand-file-name "Entries" dir)) cvs-dired-use-hook (if (eq cvs-dired-use-hook (quote always)) (not current-prefix-arg) (equal current-prefix-arg cvs-dired-use-hook))) (save-excursion (cvs-examine (file-name-directory dir) t t))))))
+(defun cvs-dired-noselect (dir) "\
+Run `cvs-examine' if DIR is a CVS administrative directory.
+The exact behavior is determined also by `cvs-dired-use-hook'." (when (stringp dir) (setq dir (directory-file-name dir)) (when (and (string= "CVS" (file-name-nondirectory dir)) (file-readable-p (expand-file-name "Entries" dir)) cvs-dired-use-hook (if (eq cvs-dired-use-hook (quote always)) (not current-prefix-arg) (equal current-prefix-arg cvs-dired-use-hook))) (save-excursion (funcall cvs-dired-action (file-name-directory dir) t t)))))
;;;***
\f
-;;;### (autoloads nil "pcvs-defs" "pcvs-defs.el" (14552 48685))
+;;;### (autoloads nil "pcvs-defs" "pcvs-defs.el" (14854 32222))
;;; Generated autoloads from pcvs-defs.el
(defvar cvs-global-menu (let ((m (make-sparse-keymap "PCL-CVS"))) (define-key m [status] (quote (menu-item "Directory Status" cvs-status :help "A more verbose status of a workarea"))) (define-key m [checkout] (quote (menu-item "Checkout Module" cvs-checkout :help "Check out a module from the repository"))) (define-key m [update] (quote (menu-item "Update Directory" cvs-update :help "Fetch updates from the repository"))) (define-key m [examine] (quote (menu-item "Examine Directory" cvs-examine :help "Examine the current state of a workarea"))) m))
;;;***
\f
;;;### (autoloads (perl-mode) "perl-mode" "progmodes/perl-mode.el"
-;;;;;; (13639 61036))
+;;;;;; (14807 56561))
;;; Generated autoloads from progmodes/perl-mode.el
(autoload (quote perl-mode) "perl-mode" "\
;;;***
\f
-;;;### (autoloads (pong) "pong" "play/pong.el" (14453 55473))
+;;;### (autoloads (pong) "pong" "play/pong.el" (14747 44776))
;;; Generated autoloads from play/pong.el
(autoload (quote pong) "pong" "\
This is an implementation of the classical game pong.
Move left and right bats and try to bounce the ball to your opponent.
-pong-mode keybindings:
- \\<pong-mode-map>
+pong-mode keybindings:\\<pong-mode-map>
- \\{pong-mode-map}" t nil)
+\\{pong-mode-map}" t nil)
;;;***
\f
;;;***
\f
;;;### (autoloads (run-prolog prolog-mode) "prolog" "progmodes/prolog.el"
-;;;;;; (13446 12665))
+;;;;;; (14729 20675))
;;; Generated autoloads from progmodes/prolog.el
(autoload (quote prolog-mode) "prolog" "\
;;;***
\f
;;;### (autoloads (ps-mode) "ps-mode" "progmodes/ps-mode.el" (14380
-;;;;;; 3795))
+;;;;;; 3920))
;;; Generated autoloads from progmodes/ps-mode.el
(autoload (quote ps-mode) "ps-mode" "\
;;;### (autoloads (ps-mule-begin-page ps-mule-begin-job ps-mule-initialize
;;;;;; ps-mule-plot-composition ps-mule-plot-string ps-mule-set-ascii-font
;;;;;; ps-mule-prepare-ascii-font ps-multibyte-buffer) "ps-mule"
-;;;;;; "ps-mule.el" (14454 81))
+;;;;;; "ps-mule.el" (14729 19580))
;;; Generated autoloads from ps-mule.el
(defvar ps-multibyte-buffer nil "\
;;;;;; 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-paper-type) "ps-print"
-;;;;;; "ps-print.el" (14554 7425))
+;;;;;; "ps-print.el" (14858 37543))
;;; Generated autoloads from ps-print.el
(defvar ps-paper-type (quote letter) "\
;;;***
\f
;;;### (autoloads (quail-update-leim-list-file quail-defrule-internal
-;;;;;; quail-defrule quail-install-map quail-define-rules quail-set-keyboard-layout
+;;;;;; 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" "international/quail.el"
-;;;;;; (14551 28773))
+;;;;;; (14845 20876))
;;; Generated autoloads from international/quail.el
(autoload (quote quail-use-package) "quail" "\
shown.
If it is nil, the current key is shown.
-DOCSTRING is the documentation string of this package.
+DOCSTRING is the documentation string of this package. The command
+`describe-input-method' shows this string while replacing the form
+\\=\\<VAR> in the string by the value of VAR. That value should be a
+string. For instance, the form \\=\\<quail-translation-docstring> is
+replaced by a description about how to select a translation from a
+list of candidates.
TRANSLATION-KEYS specifies additional key bindings used while translation
region is active. It is an alist of single key character vs. corresponding
function tells Quail system the layout of your keyboard so that what
you type is correctly handled." t nil)
+(autoload (quote quail-show-keyboard-layout) "quail" "\
+Show the physical layout of the keyboard type KEYBOARD-TYPE.
+
+The variable `quail-keyboard-layout-type' holds the currently selected
+keyboard type." t nil)
+
(autoload (quote quail-define-rules) "quail" "\
Define translation rules of the current Quail package.
Each argument is a list of KEY and TRANSLATION.
In these cases, a key specific Quail map is generated and assigned to KEY.
If TRANSLATION is a Quail map or a function symbol which returns a Quail map,
- it is used to handle KEY." nil (quote macro))
+ it is used to handle KEY.
+
+The first argument may be an alist of annotations for the following
+rules. Each element has the form (ANNOTATION . VALUE), where
+ANNOTATION is a symbol indicating the annotation type. Currently
+the following annotation types are supported.
+
+ append -- the value non-nil means that the following rules should
+ be appended to the rules of the current Quail package.
+
+ face -- the value is a face to use for displaying TRANSLATIONs in
+ candidate list.
+
+ advice -- the value is a function to call after one of RULES is
+ selected. The function is called with one argument, the
+ selected TRANSLATION string, after the TRANSLATION is
+ inserted.
+
+ no-decode-map --- the value non-nil means that decoding map is not
+ generated for the following translations." nil (quote macro))
(autoload (quote quail-install-map) "quail" "\
Install the Quail map MAP in the current Quail package.
The installed map can be referred by the function `quail-map'." nil nil)
+(autoload (quote quail-install-decode-map) "quail" "\
+Install the Quail decode map DECODE-MAP in the current Quail package.
+
+Optional 2nd arg NAME, if non-nil, is a name of Quail package for
+which to install MAP.
+
+The installed decode map can be referred by the function `quail-decode-map'." nil nil)
+
(autoload (quote quail-defrule) "quail" "\
Add one translation rule, KEY to TRANSLATION, in the current Quail package.
KEY is a string meaning a sequence of keystrokes to be translated.
to the current translations for KEY instead of replacing them." nil nil)
(autoload (quote quail-defrule-internal) "quail" "\
-Define KEY as TRANS in a Quail map MAP." nil nil)
+Define KEY as TRANS in a Quail map MAP.
+
+If Optional 4th arg APPEND is non-nil, TRANS is appended to the
+current translations for KEY instead of replacing them.
+
+Optional 5th arg DECODE-MAP is a Quail decode map.
+
+Optional 6th arg PROPS is a property list annotating TRANS. See the
+function `quail-define-rules' for the detail." nil nil)
(autoload (quote quail-update-leim-list-file) "quail" "\
Update entries for Quail packages in `LEIM' list file in directory DIRNAME.
;;;### (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" (14554
-;;;;;; 7245))
+;;;;;; 8650))
;;; 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 (quote quickurl) "quickurl" "Insert an URL based on LOOKUP.\n\nIf not supplied LOOKUP is taken to be the word at point in the current\nbuffer, this default action can be modifed via\n`quickurl-grab-lookup-function'." t nil)
+(autoload (quote quickurl) "quickurl" "\
+Insert an 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
+`quickurl-grab-lookup-function'." t nil)
(autoload (quote quickurl-ask) "quickurl" "\
Insert an URL, with `completing-read' prompt, based on LOOKUP." t nil)
See `quickurl-grab-url' for details on how the default word/url combination
is decided." t nil)
-(autoload (quote quickurl-browse-url) "quickurl" "Browse the URL associated with LOOKUP.\n\nIf not supplied LOOKUP is taken to be the word at point in the\ncurrent buffer, this default action can be modifed via\n`quickurl-grab-lookup-function'." t nil)
+(autoload (quote quickurl-browse-url) "quickurl" "\
+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
+`quickurl-grab-lookup-function'." t nil)
(autoload (quote quickurl-browse-url-ask) "quickurl" "\
Browse the URL, with `completing-read' prompt, associated with LOOKUP." t nil)
;;;***
\f
-;;;### (autoloads (remote-compile) "rcompile" "net/rcompile.el" (13149
-;;;;;; 16808))
+;;;### (autoloads (remote-compile) "rcompile" "net/rcompile.el" (14550
+;;;;;; 7848))
;;; Generated autoloads from net/rcompile.el
(autoload (quote remote-compile) "rcompile" "\
;;;***
\f
;;;### (autoloads (re-builder) "re-builder" "emacs-lisp/re-builder.el"
-;;;;;; (14539 41135))
+;;;;;; (14539 46619))
;;; Generated autoloads from emacs-lisp/re-builder.el
(autoload (quote re-builder) "re-builder" "\
;;;***
\f
-;;;### (autoloads (recentf-open-more-files recentf-cleanup recentf-edit-list
-;;;;;; recentf-save-list recentf-mode) "recentf" "recentf.el" (14539
-;;;;;; 49146))
+;;;### (autoloads (recentf-mode recentf-open-more-files recentf-open-files
+;;;;;; recentf-cleanup recentf-edit-list recentf-save-list) "recentf"
+;;;;;; "recentf.el" (14854 32222))
;;; Generated autoloads from recentf.el
-(autoload (quote recentf-mode) "recentf" "\
-Toggle recentf mode.
-With prefix ARG, turn recentf mode on if and only if ARG is positive.
-Returns the new status of recentf mode (non-nil means on).
-
-When recentf mode is enabled, it maintains a menu for visiting files that
-were operated on recently." t nil)
-
(autoload (quote recentf-save-list) "recentf" "\
Save the current `recentf-list' to the file `recentf-save-file'." t nil)
(autoload (quote recentf-cleanup) "recentf" "\
Remove all non-readable and excluded files from `recentf-list'." t nil)
+(autoload (quote recentf-open-files) "recentf" "\
+Display buffer allowing user to choose a file from recently-opened list.
+The optional argument FILES may be used to specify the list, otherwise
+`recentf-list' is used. The optional argument BUFFER-NAME specifies
+which buffer to use for the interaction." t nil)
+
(autoload (quote recentf-open-more-files) "recentf" "\
Allow the user to open files that are not in the menu." t nil)
+(defvar recentf-mode nil "\
+Toggle Recentf mode on or off.
+See the command `recentf-mode' for a description of this minor-mode.
+Setting this variable directly does not take effect;
+use either \\[customize] or the function `recentf-mode'.")
+
+(custom-add-to-group (quote recentf) (quote recentf-mode) (quote custom-variable))
+
+(custom-add-load (quote recentf-mode) (quote recentf))
+
+(autoload (quote 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.
+
+When recentf mode is enabled, it maintains a menu for visiting files that
+were operated on recently." t nil)
+
;;;***
\f
;;;### (autoloads (clear-rectangle replace-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" (14537
-;;;;;; 23030))
+;;;;;; delete-rectangle move-to-column-force) "rect" "rect.el" (14710
+;;;;;; 21251))
;;; Generated autoloads from rect.el
(autoload (quote move-to-column-force) "rect" "\
With a prefix (or a FILL) argument, also fill with blanks the parts of the
rectangle which were empty." t nil)
+;;;***
+\f
+;;;### (autoloads (refill-mode) "refill" "textmodes/refill.el" (14845
+;;;;;; 20876))
+;;; Generated autoloads from textmodes/refill.el
+
+(autoload (quote refill-mode) "refill" "\
+Toggle Refill minor mode.
+With prefix arg, turn Refill mode on iff arg is positive.
+
+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." t nil)
+
;;;***
\f
;;;### (autoloads (reftex-mode turn-on-reftex) "reftex" "textmodes/reftex.el"
-;;;;;; (14495 18077))
+;;;;;; (14671 47574))
;;; Generated autoloads from textmodes/reftex.el
(autoload (quote turn-on-reftex) "reftex" "\
;;;***
\f
;;;### (autoloads (reftex-citation) "reftex-cite" "textmodes/reftex-cite.el"
-;;;;;; (14495 18066))
+;;;;;; (14702 63699))
;;; Generated autoloads from textmodes/reftex-cite.el
(autoload (quote reftex-citation) "reftex-cite" "\
;;;***
\f
;;;### (autoloads (reftex-index-phrases-mode) "reftex-index" "textmodes/reftex-index.el"
-;;;;;; (14495 18068))
+;;;;;; (14671 47574))
;;; Generated autoloads from textmodes/reftex-index.el
(autoload (quote reftex-index-phrases-mode) "reftex-index" "\
;;;***
\f
;;;### (autoloads (regexp-opt-depth regexp-opt) "regexp-opt" "emacs-lisp/regexp-opt.el"
-;;;;;; (14535 45202))
+;;;;;; (14854 32222))
;;; Generated autoloads from emacs-lisp/regexp-opt.el
(autoload (quote regexp-opt) "regexp-opt" "\
is enclosed by at least one regexp grouping construct.
The returned regexp is typically more efficient than the equivalent regexp:
- (let ((open-paren (if PAREN \"\\\\(\" \"\")) (close-paren (if PAREN \"\\\\)\" \"\")))
- (concat open-paren (mapconcat 'regexp-quote STRINGS \"\\\\|\") close-paren))" nil nil)
+ (let ((open (if PAREN \"\\\\(\" \"\")) (close (if PAREN \"\\\\)\" \"\")))
+ (concat open (mapconcat 'regexp-quote STRINGS \"\\\\|\") close))
+
+If PAREN is `words', then the resulting regexp is additionally surrounded
+by \\=\\< and \\>." nil nil)
(autoload (quote regexp-opt-depth) "regexp-opt" "\
Return the depth of REGEXP.
;;;***
\f
;;;### (autoloads (reporter-submit-bug-report) "reporter" "mail/reporter.el"
-;;;;;; (14356 24412))
+;;;;;; (14638 40777))
;;; Generated autoloads from mail/reporter.el
(autoload (quote reporter-submit-bug-report) "reporter" "\
ADDRESS is the email address for the package's maintainer. PKGNAME is
the name of the package (if you want to include version numbers,
you must put them into PKGNAME before calling this function).
+Optional PRE-HOOKS and POST-HOOKS are passed to `reporter-dump-state'.
+Optional SALUTATION is inserted at the top of the mail buffer,
+and point is left after the salutation.
VARLIST is the list of variables to dump (see `reporter-dump-state'
for details). The optional argument PRE-HOOKS and POST-HOOKS are
;;;***
\f
;;;### (autoloads (reposition-window) "reposition" "reposition.el"
-;;;;;; (13229 29317))
+;;;;;; (14808 17014))
;;; Generated autoloads from reposition.el
(autoload (quote reposition-window) "reposition" "\
;;;***
\f
;;;### (autoloads (make-ring ring-p) "ring" "emacs-lisp/ring.el"
-;;;;;; (14283 6810))
+;;;;;; (14634 20460))
;;; Generated autoloads from emacs-lisp/ring.el
(autoload (quote ring-p) "ring" "\
;;;***
\f
;;;### (autoloads (rmail-set-pop-password rmail-input rmail-mode
-;;;;;; rmail rmail-enable-mime rmail-confirm-expunge rmail-secondary-file-regexp
-;;;;;; rmail-secondary-file-directory rmail-mail-new-frame rmail-primary-inbox-list
-;;;;;; rmail-delete-after-output rmail-highlight-face rmail-highlighted-headers
-;;;;;; rmail-retry-ignored-headers rmail-displayed-headers rmail-ignored-headers
-;;;;;; rmail-dont-reply-to-names) "rmail" "mail/rmail.el" (14555
-;;;;;; 23001))
+;;;;;; rmail rmail-enable-mime rmail-show-message-hook rmail-confirm-expunge
+;;;;;; rmail-secondary-file-regexp rmail-secondary-file-directory
+;;;;;; rmail-mail-new-frame rmail-primary-inbox-list rmail-delete-after-output
+;;;;;; rmail-highlight-face rmail-highlighted-headers rmail-retry-ignored-headers
+;;;;;; rmail-displayed-headers rmail-ignored-headers rmail-dont-reply-to-names)
+;;;;;; "rmail" "mail/rmail.el" (14726 41837))
;;; Generated autoloads from mail/rmail.el
(defvar rmail-dont-reply-to-names nil "\
;;;***
\f
;;;### (autoloads (rmail-edit-current-message) "rmailedit" "mail/rmailedit.el"
-;;;;;; (14387 64145))
+;;;;;; (14387 64265))
;;; Generated autoloads from mail/rmailedit.el
(autoload (quote rmail-edit-current-message) "rmailedit" "\
\f
;;;### (autoloads (rmail-output-body-to-file rmail-output rmail-fields-not-to-output
;;;;;; rmail-output-to-rmail-file rmail-output-file-alist) "rmailout"
-;;;;;; "mail/rmailout.el" (14179 6393))
+;;;;;; "mail/rmailout.el" (14636 62741))
;;; Generated autoloads from mail/rmailout.el
(defvar rmail-output-file-alist nil "\
which is updated to the name you use in this command.
A prefix argument N says to output N consecutive messages
-starting with the current one. Deleted messages are skipped and don't count." t nil)
+starting with the current one. Deleted messages are skipped and don't count.
+
+If optional argument STAY is non-nil, then leave the last filed
+mesasge up instead of moving forward to the next non-deleted message." t nil)
(defvar rmail-fields-not-to-output nil "\
*Regexp describing fields to exclude when outputting a message to a file.")
;;;***
\f
-;;;### (autoloads (rmail-summary-line-decoder rmail-summary-by-senders
-;;;;;; rmail-summary-by-topic rmail-summary-by-regexp rmail-summary-by-recipients
-;;;;;; rmail-summary-by-labels rmail-summary rmail-summary-line-count-flag
-;;;;;; rmail-summary-scroll-between-messages) "rmailsum" "mail/rmailsum.el"
-;;;;;; (14547 28270))
+;;;### (autoloads (rmail-user-mail-address-regexp rmail-summary-line-decoder
+;;;;;; rmail-summary-by-senders rmail-summary-by-topic rmail-summary-by-regexp
+;;;;;; rmail-summary-by-recipients rmail-summary-by-labels rmail-summary
+;;;;;; rmail-summary-line-count-flag rmail-summary-scroll-between-messages)
+;;;;;; "rmailsum" "mail/rmailsum.el" (14637 38354))
;;; Generated autoloads from mail/rmailsum.el
(defvar rmail-summary-scroll-between-messages t "\
By default, `identity' is set.")
+(defvar rmail-user-mail-address-regexp nil "\
+*Regexp matching user mail addresses.
+If non-nil, this variable is used to identify the correspondent
+when receiving new mail. If it matches the address of the sender,
+the recipient is taken as correspondent of a mail.
+If nil (default value), your `user-login-name' and `user-mail-address'
+are used to exclude yourself as correspondent.
+
+Usually you don't have to set this variable, except if you collect mails
+sent by you under different user names.
+Then it should be a regexp matching your mail adresses.
+
+Setting this variable has an effect only before reading a mail.")
+
;;;***
\f
;;;### (autoloads (news-post-news) "rnewspost" "mail/rnewspost.el"
-;;;;;; (14263 36299))
+;;;;;; (14660 49436))
;;; Generated autoloads from mail/rnewspost.el
(autoload (quote news-post-news) "rnewspost" "\
;;;***
\f
;;;### (autoloads (dsssl-mode scheme-mode) "scheme" "progmodes/scheme.el"
-;;;;;; (14432 37919))
+;;;;;; (14821 46406))
;;; Generated autoloads from progmodes/scheme.el
(autoload (quote scheme-mode) "scheme" "\
commands will be defined, for evaluating expressions and controlling
the interpreter, and the state of the process will be displayed in the
modeline of all Scheme buffers. The names of commands that interact
-with the Scheme process start with \"xscheme-\". For more information
-see the documentation for xscheme-interaction-mode.
+with the Scheme process start with \"xscheme-\" if you use the MIT
+Scheme-specific `xscheme' package; for more information see the
+documentation for `xscheme-interaction-mode'. Use \\[run-scheme] to
+start an inferior Scheme using the more general `cmuscheme' package.
Commands:
Delete converts tabs to spaces as it moves back.
;;;***
\f
;;;### (autoloads (gnus-score-mode) "score-mode" "gnus/score-mode.el"
-;;;;;; (14030 49477))
+;;;;;; (14792 2703))
;;; Generated autoloads from gnus/score-mode.el
(autoload (quote gnus-score-mode) "score-mode" "\
;;;***
\f
;;;### (autoloads (scribe-mode) "scribe" "textmodes/scribe.el" (14381
-;;;;;; 55098))
+;;;;;; 56615))
;;; Generated autoloads from textmodes/scribe.el
(autoload (quote scribe-mode) "scribe" "\
;;;;;; mail-signature mail-personal-alias-file mail-alias-file mail-default-reply-to
;;;;;; mail-archive-file-name mail-header-separator mail-yank-ignored-headers
;;;;;; mail-interactive mail-self-blind mail-specify-envelope-from
-;;;;;; mail-from-style) "sendmail" "mail/sendmail.el" (14532 62968))
+;;;;;; mail-from-style) "sendmail" "mail/sendmail.el" (14821 31351))
;;; Generated autoloads from mail/sendmail.el
(defvar mail-from-style (quote angles) "\
to the mailer to specify the envelope-from address. But that is now
controlled by a separate variable, `mail-specify-envelope-from'.")
-(defvar mail-specify-envelope-from t "\
+(defvar mail-specify-envelope-from nil "\
*If non-nil, specify the envelope-from address when sending mail.
The value used to specify it is whatever is found in `user-mail-address'.
;;;***
\f
-;;;### (autoloads (server-start) "server" "server.el" (14263 33343))
+;;;### (autoloads (server-start) "server" "server.el" (14754 19514))
;;; Generated autoloads from server.el
(autoload (quote server-start) "server" "\
;;;***
\f
;;;### (autoloads (html-mode sgml-mode) "sgml-mode" "textmodes/sgml-mode.el"
-;;;;;; (14501 37288))
+;;;;;; (14501 47217))
;;; Generated autoloads from textmodes/sgml-mode.el
(autoload (quote sgml-mode) "sgml-mode" "\
;;;***
\f
;;;### (autoloads (sh-mode) "sh-script" "progmodes/sh-script.el"
-;;;;;; (14432 40418))
+;;;;;; (14834 55789))
;;; Generated autoloads from progmodes/sh-script.el
(put (quote sh-mode) (quote mode-class) (quote special))
\\[sh-learn-line-indent] Change the indentation variable so this line
would indent to the way it currently is.
\\[sh-learn-buffer-indent] Set the indentation variables so the
-buffer indents as it currently is indendeted.
+buffer indents as it currently is indented.
\\[backward-delete-char-untabify] Delete backward one position, even if it was a tab.
;;;***
\f
-;;;### (autoloads (shell shell-prompt-pattern) "shell" "shell.el"
-;;;;;; (14263 35978))
+;;;### (autoloads (shell shell-dumb-shell-regexp) "shell" "shell.el"
+;;;;;; (14841 20034))
;;; Generated autoloads from shell.el
-(defvar shell-prompt-pattern "^[^#$%>\n]*[#$%>] *" "\
-Regexp to match prompts in the inferior shell.
-Defaults to \"^[^#$%>\\n]*[#$%>] *\", which works pretty well.
-This variable is used to initialise `comint-prompt-regexp' in the
-shell buffer.
-
-The pattern should probably not match more than one line. If it does,
-Shell mode may become confused trying to distinguish prompt from input
-on lines which don't start with a prompt.
-
-This is a fine thing to set in your `.emacs' file.")
+(defvar shell-dumb-shell-regexp "cmd\\(proxy\\)?\\.exe" "\
+Regexp to match shells that don't save their command history.
+For shells that match this regexp, Emacs will write out the
+command history when the shell finishes.")
(autoload (quote shell) "shell" "\
-Run an inferior shell, with I/O through buffer *shell*.
-If buffer exists but shell process is not running, make new shell.
-If buffer exists and shell process is running, just switch to buffer `*shell*'.
+Run an inferior shell, with I/O through BUFFER (which defaults to `*shell*').
+Interactively, a prefix arg means to prompt for BUFFER.
+If BUFFER exists but shell process is not running, make new shell.
+If BUFFER exists and shell process is running, just switch to BUFFER.
Program used comes from variable `explicit-shell-file-name',
or (if that is nil) from the ESHELL environment variable,
or else from SHELL if there is no ESHELL.
;;;***
\f
-;;;### (autoloads (smerge-mode) "smerge-mode" "smerge-mode.el" (14552
-;;;;;; 48942))
+;;;### (autoloads (smerge-mode) "smerge-mode" "smerge-mode.el" (14821
+;;;;;; 31349))
;;; Generated autoloads from smerge-mode.el
(autoload (quote smerge-mode) "smerge-mode" "\
Minor mode to simplify editing output from the diff3 program.
\\{smerge-mode-map}" t nil)
+;;;***
+\f
+;;;### (autoloads (smiley-region) "smiley-ems" "gnus/smiley-ems.el"
+;;;;;; (14858 32485))
+;;; Generated autoloads from gnus/smiley-ems.el
+
+(autoload (quote smiley-region) "smiley-ems" "\
+Replace in the region `smiley-regexp-alist' matches with corresponding images." t nil)
+
;;;***
\f
;;;### (autoloads (smtpmail-send-it) "smtpmail" "mail/smtpmail.el"
-;;;;;; (14342 21398))
+;;;;;; (14342 21630))
;;; Generated autoloads from mail/smtpmail.el
(autoload (quote smtpmail-send-it) "smtpmail" nil nil nil)
;;;***
\f
;;;### (autoloads (snmpv2-mode snmp-mode) "snmp-mode" "net/snmp-mode.el"
-;;;;;; (14082 18459))
+;;;;;; (14550 9134))
;;; Generated autoloads from net/snmp-mode.el
(autoload (quote snmp-mode) "snmp-mode" "\
\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" (14481 36636))
+;;;;;; sort-lines sort-subr) "sort" "sort.el" (14481 36842))
;;; Generated autoloads from sort.el
(autoload (quote sort-subr) "sort" "\
;;;***
\f
;;;### (autoloads (speedbar-get-focus speedbar-frame-mode) "speedbar"
-;;;;;; "speedbar.el" (14403 56247))
+;;;;;; "speedbar.el" (14783 15356))
;;; Generated autoloads from speedbar.el
(defalias (quote speedbar) (quote speedbar-frame-mode))
;;;***
\f
-;;;### (autoloads (snarf-spooks spook) "spook" "play/spook.el" (13607
-;;;;;; 43485))
+;;;### (autoloads (snarf-spooks spook) "spook" "play/spook.el" (14821
+;;;;;; 31351))
;;; Generated autoloads from play/spook.el
(autoload (quote spook) "spook" "\
;;;***
\f
-;;;### (autoloads (sql-postgres sql-mode sql-help) "sql" "progmodes/sql.el"
-;;;;;; (14395 64503))
+;;;### (autoloads (sql-postgres sql-ms sql-ingres sql-solid sql-mysql
+;;;;;; sql-informix sql-sybase sql-oracle sql-mode sql-help) "sql"
+;;;;;; "progmodes/sql.el" (14829 52426))
;;; Generated autoloads from progmodes/sql.el
(autoload (quote sql-help) "sql" "\
is generated. See the In/Out menu in the SQLi buffer for some functions
that help you navigate through the buffer, the input history, etc.
-Put a line with a call to autoload into your `~/.emacs' file for each
-entry function you want to use regularly:
-
-\(autoload 'sql-postgres \"sql\" \"Interactive SQL mode.\" t)
-
If you have a really complex SQL statement or if you are writing a
procedure, you can do this in a separate buffer. Put the new buffer in
`sql-mode' by calling \\[sql-mode]. The name of this buffer can be
For information on how to create multiple SQLi buffers, see
`sql-interactive-mode'." t nil)
+(autoload (quote sql-oracle) "sql" "\
+Run sqlplus by Oracle as an inferior process.
+
+If buffer `*SQL*' exists but no process is running, make a new process.
+If buffer exists and a process is running, just switch to buffer
+`*SQL*'.
+
+Interpreter used comes from variable `sql-oracle-program'. Login uses
+the variables `sql-user', `sql-password', and `sql-database' as
+defaults, if set. Additional command line parameters can be stored in
+the list `sql-oracle-options'.
+
+The buffer is put in sql-interactive-mode, giving commands for sending
+input. See `sql-interactive-mode'.
+
+To specify a coding system for converting non-ASCII characters
+in the input and output to the process, use \\[universal-coding-system-argument]
+before \\[sql-oracle]. You can also specify this with \\[set-buffer-process-coding-system]
+in the SQL buffer, after you start the process.
+The default comes from `process-coding-system-alist' and
+`default-process-coding-system'.
+
+\(Type \\[describe-mode] in the SQL buffer for a list of commands.)" t nil)
+
+(autoload (quote sql-sybase) "sql" "\
+Run isql by SyBase as an inferior process.
+
+If buffer `*SQL*' exists but no process is running, make a new process.
+If buffer exists and a process is running, just switch to buffer
+`*SQL*'.
+
+Interpreter used comes from variable `sql-sybase-program'. Login uses
+the variables `sql-server', `sql-user', `sql-password', and
+`sql-database' as defaults, if set.
+
+The buffer is put in sql-interactive-mode, giving commands for sending
+input. See `sql-interactive-mode'.
+
+To specify a coding system for converting non-ASCII characters
+in the input and output to the process, use \\[universal-coding-system-argument]
+before \\[sql-sybase]. You can also specify this with \\[set-buffer-process-coding-system]
+in the SQL buffer, after you start the process.
+The default comes from `process-coding-system-alist' and
+`default-process-coding-system'.
+
+\(Type \\[describe-mode] in the SQL buffer for a list of commands.)" t nil)
+
+(autoload (quote sql-informix) "sql" "\
+Run dbaccess by Informix as an inferior process.
+
+If buffer `*SQL*' exists but no process is running, make a new process.
+If buffer exists and a process is running, just switch to buffer
+`*SQL*'.
+
+Interpreter used comes from variable `sql-informix-program'. Login uses
+the variable `sql-database' as default, if set.
+
+The buffer is put in sql-interactive-mode, giving commands for sending
+input. See `sql-interactive-mode'.
+
+To specify a coding system for converting non-ASCII characters
+in the input and output to the process, use \\[universal-coding-system-argument]
+before \\[sql-informix]. You can also specify this with \\[set-buffer-process-coding-system]
+in the SQL buffer, after you start the process.
+The default comes from `process-coding-system-alist' and
+`default-process-coding-system'.
+
+\(Type \\[describe-mode] in the SQL buffer for a list of commands.)" t nil)
+
+(autoload (quote sql-mysql) "sql" "\
+Run mysql by TcX as an inferior process.
+
+Note that the widespread idea that mysql is free software is inaccurate;
+its license is too restrictive. We urge you to use PostGres instead.
+
+If buffer `*SQL*' exists but no process is running, make a new process.
+If buffer exists and a process is running, just switch to buffer
+`*SQL*'.
+
+Interpreter used comes from variable `sql-mysql-program'. Login uses
+the variables `sql-user', `sql-password', `sql-database', and
+`sql-server' as defaults, if set.
+
+The buffer is put in sql-interactive-mode, giving commands for sending
+input. See `sql-interactive-mode'.
+
+To specify a coding system for converting non-ASCII characters
+in the input and output to the process, use \\[universal-coding-system-argument]
+before \\[sql-mysql]. You can also specify this with \\[set-buffer-process-coding-system]
+in the SQL buffer, after you start the process.
+The default comes from `process-coding-system-alist' and
+`default-process-coding-system'.
+
+\(Type \\[describe-mode] in the SQL buffer for a list of commands.)" t nil)
+
+(autoload (quote sql-solid) "sql" "\
+Run solsql by Solid as an inferior process.
+
+If buffer `*SQL*' exists but no process is running, make a new process.
+If buffer exists and a process is running, just switch to buffer
+`*SQL*'.
+
+Interpreter used comes from variable `sql-solid-program'. Login uses
+the variables `sql-user', `sql-password', and `sql-server' as
+defaults, if set.
+
+The buffer is put in sql-interactive-mode, giving commands for sending
+input. See `sql-interactive-mode'.
+
+To specify a coding system for converting non-ASCII characters
+in the input and output to the process, use \\[universal-coding-system-argument]
+before \\[sql-solid]. You can also specify this with \\[set-buffer-process-coding-system]
+in the SQL buffer, after you start the process.
+The default comes from `process-coding-system-alist' and
+`default-process-coding-system'.
+
+\(Type \\[describe-mode] in the SQL buffer for a list of commands.)" t nil)
+
+(autoload (quote sql-ingres) "sql" "\
+Run sql by Ingres as an inferior process.
+
+If buffer `*SQL*' exists but no process is running, make a new process.
+If buffer exists and a process is running, just switch to buffer
+`*SQL*'.
+
+Interpreter used comes from variable `sql-ingres-program'. Login uses
+the variable `sql-database' as default, if set.
+
+The buffer is put in sql-interactive-mode, giving commands for sending
+input. See `sql-interactive-mode'.
+
+To specify a coding system for converting non-ASCII characters
+in the input and output to the process, use \\[universal-coding-system-argument]
+before \\[sql-ingres]. You can also specify this with \\[set-buffer-process-coding-system]
+in the SQL buffer, after you start the process.
+The default comes from `process-coding-system-alist' and
+`default-process-coding-system'.
+
+\(Type \\[describe-mode] in the SQL buffer for a list of commands.)" t nil)
+
+(autoload (quote sql-ms) "sql" "\
+Run isql by Microsoft as an inferior process.
+
+If buffer `*SQL*' exists but no process is running, make a new process.
+If buffer exists and a process is running, just switch to buffer
+`*SQL*'.
+
+Interpreter used comes from variable `sql-ms-program'. Login uses the
+variables `sql-user', `sql-password', `sql-database', and `sql-server'
+as defaults, if set.
+
+The buffer is put in sql-interactive-mode, giving commands for sending
+input. See `sql-interactive-mode'.
+
+To specify a coding system for converting non-ASCII characters
+in the input and output to the process, use \\[universal-coding-system-argument]
+before \\[sql-ms]. You can also specify this with \\[set-buffer-process-coding-system]
+in the SQL buffer, after you start the process.
+The default comes from `process-coding-system-alist' and
+`default-process-coding-system'.
+
+\(Type \\[describe-mode] in the SQL buffer for a list of commands.)" t nil)
+
(autoload (quote sql-postgres) "sql" "\
Run psql by Postgres as an inferior process.
;;;***
\f
-;;;### (autoloads (strokes-mode 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" (14527 50024))
+;;;### (autoloads (strokes-compose-complex-stroke strokes-decode-buffer
+;;;;;; 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-mode) "strokes" "strokes.el"
+;;;;;; (14788 10033))
;;; Generated autoloads from strokes.el
(defvar strokes-mode nil "\
-Non-nil when `strokes' is globally enabled")
+Non-nil when `strokes' is globally enabled.
+Setting this variable directly does not take effect. Use either Customize
+or M-x strokes-mode.")
+
+(custom-add-to-group (quote strokes) (quote strokes-mode) (quote custom-variable))
+
+(custom-add-load (quote strokes-mode) (quote strokes))
(autoload (quote strokes-global-set-stroke) "strokes" "\
Interactively give STROKE the global binding as COMMAND.
Optional EVENT is acceptable as the starting event of the stroke" nil nil)
(autoload (quote strokes-do-stroke) "strokes" "\
-Read a simple stroke from the user and then exectute its comand.
+Read a simple stroke from the user and then exectute its command.
This must be bound to a mouse event." t nil)
(autoload (quote strokes-do-complex-stroke) "strokes" "\
(defalias (quote describe-stroke) (quote strokes-describe-stroke))
(autoload (quote strokes-help) "strokes" "\
-Get instructional help on using the the `strokes' package." t nil)
+Get instructional help on using the `strokes' package." t nil)
(autoload (quote strokes-load-user-strokes) "strokes" "\
Load user-defined strokes from file named by `strokes-file'." t nil)
(defalias (quote load-user-strokes) (quote strokes-load-user-strokes))
+(autoload (quote strokes-list-strokes) "strokes" "\
+Pop up a buffer containing an alphabetical listing of strokes in STROKES-MAP.
+With CHRONOLOGICAL prefix arg (\\[universal-argument]) list strokes
+chronologically by command name.
+If STROKES-MAP is not given, `strokes-global-map' will be used instead." t nil)
+
(autoload (quote strokes-mode) "strokes" "\
Toggle strokes being enabled.
With ARG, turn strokes on if and only if ARG is positive or true.
> M-x global-set-stroke
To use strokes for pictographic editing, such as Chinese/Japanese, use
-Sh-button-2, which draws strokes and inserts them. Encode/decode your
+S-mouse-2, which draws strokes and inserts them. Encode/decode your
strokes with
> M-x strokes-encode-buffer
> M-x strokes-decode-buffer" t nil)
+(autoload (quote strokes-decode-buffer) "strokes" "\
+Decode stroke strings in BUFFER and display their corresponding glyphs.
+Optional BUFFER defaults to the current buffer.
+Optional FORCE non-nil will ignore the buffer's read-only status." t nil)
+
+(autoload (quote strokes-compose-complex-stroke) "strokes" "\
+Read a complex stroke and insert its glyph into the current buffer." t nil)
+
+;;;***
+\f
+;;;### (autoloads (studlify-word studlify-region) "studly" "play/studly.el"
+;;;;;; (14821 31351))
+;;; Generated autoloads from play/studly.el
+
+(autoload (quote studlify-region) "studly" "\
+Studlify-case the region" t nil)
+
+(autoload (quote studlify-word) "studly" "\
+Studlify-case the current word, or COUNT words if given an argument" t nil)
+
;;;***
\f
;;;### (autoloads (sc-cite-original) "supercite" "mail/supercite.el"
-;;;;;; (14385 23097))
+;;;;;; (14565 55801))
;;; Generated autoloads from mail/supercite.el
(autoload (quote sc-cite-original) "supercite" "\
;;;***
\f
-;;;### (autoloads (tar-mode) "tar-mode" "tar-mode.el" (14495 17995))
+;;;### (autoloads (tar-mode) "tar-mode" "tar-mode.el" (14664 40536))
;;; Generated autoloads from tar-mode.el
(autoload (quote tar-mode) "tar-mode" "\
;;;***
\f
;;;### (autoloads (tcl-help-on-word inferior-tcl tcl-mode) "tcl"
-;;;;;; "progmodes/tcl.el" (14248 50428))
+;;;;;; "progmodes/tcl.el" (14729 20675))
;;; Generated autoloads from progmodes/tcl.el
(autoload (quote tcl-mode) "tcl" "\
;;;***
\f
-;;;### (autoloads (rsh telnet) "telnet" "net/telnet.el" (13858 52416))
+;;;### (autoloads (rsh telnet) "telnet" "net/telnet.el" (14729 20675))
;;; Generated autoloads from net/telnet.el
(add-hook 'same-window-regexps "\\*telnet-.*\\*\\(\\|<[0-9]+>\\)")
;;;***
\f
-;;;### (autoloads (ansi-term term make-term) "term" "term.el" (14268
-;;;;;; 17354))
+;;;### (autoloads (ansi-term term make-term) "term" "term.el" (14702
+;;;;;; 63698))
;;; Generated autoloads from term.el
(autoload (quote make-term) "term" "\
;;;***
\f
-;;;### (autoloads (terminal-emulator) "terminal" "terminal.el" (14280
-;;;;;; 10588))
+;;;### (autoloads (terminal-emulator) "terminal" "terminal.el" (14758
+;;;;;; 23449))
;;; Generated autoloads from terminal.el
(autoload (quote terminal-emulator) "terminal" "\
;;;;;; tex-start-options-string 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"
-;;;;;; (14365 34873))
+;;;;;; (14849 20131))
;;; Generated autoloads from textmodes/tex-mode.el
(defvar tex-shell-file-name nil "\
;;;***
\f
;;;### (autoloads (texi2info texinfo-format-region texinfo-format-buffer)
-;;;;;; "texinfmt" "textmodes/texinfmt.el" (14456 53455))
+;;;;;; "texinfmt" "textmodes/texinfmt.el" (14600 36293))
;;; Generated autoloads from textmodes/texinfmt.el
(autoload (quote texinfo-format-buffer) "texinfmt" "\
;;;***
\f
;;;### (autoloads (texinfo-mode) "texinfo" "textmodes/texinfo.el"
-;;;;;; (14536 60906))
+;;;;;; (14855 56553))
;;; Generated autoloads from textmodes/texinfo.el
(autoload (quote texinfo-mode) "texinfo" "\
If the file has a `top' node, it must be called `top' or `Top' and
be the first node in the file.
-Entering Texinfo mode calls the value of text-mode-hook, and then the
-value of texinfo-mode-hook." t nil)
-
-;;;***
-\f
-;;;### (autoloads (texinfo-sequential-node-update texinfo-every-node-update
-;;;;;; texinfo-update-node) "texnfo-upd" "textmodes/texnfo-upd.el"
-;;;;;; (14263 36019))
-;;; Generated autoloads from textmodes/texnfo-upd.el
-
-(autoload (quote texinfo-update-node) "texnfo-upd" "\
-Without any prefix argument, update the node in which point is located.
-Interactively, a prefix argument means to operate on the region.
-
-The functions for creating or updating nodes and menus, and their
-keybindings, are:
-
- texinfo-update-node (&optional beginning end) \\[texinfo-update-node]
- texinfo-every-node-update () \\[texinfo-every-node-update]
- texinfo-sequential-node-update (&optional region-p)
-
- texinfo-make-menu (&optional region-p) \\[texinfo-make-menu]
- texinfo-all-menus-update () \\[texinfo-all-menus-update]
- texinfo-master-menu ()
-
- texinfo-indent-menu-description (column &optional region-p)
-
-The `texinfo-column-for-description' variable specifies the column to
-which menu descriptions are indented. Its default value is 32." t nil)
-
-(autoload (quote texinfo-every-node-update) "texnfo-upd" "\
-Update every node in a Texinfo file." t nil)
-
-(autoload (quote texinfo-sequential-node-update) "texnfo-upd" "\
-Update one node (or many) in a Texinfo file with sequential pointers.
-
-This function causes the `Next' or `Previous' pointer to point to the
-immediately preceding or following node, even if it is at a higher or
-lower hierarchical level in the document. Continually pressing `n' or
-`p' takes you straight through the file.
-
-Without any prefix argument, update the node in which point is located.
-Non-nil argument (prefix, if interactive) means update the nodes in the
-marked region.
-
-This command makes it awkward to navigate among sections and
-subsections; it should be used only for those documents that are meant
-to be read like a novel rather than a reference, and for which the
-Info `g*' command is inadequate." t nil)
+Entering Texinfo mode calls the value of `text-mode-hook', and then the
+value of `texinfo-mode-hook'." t nil)
;;;***
\f
;;;### (autoloads (thai-composition-function thai-post-read-conversion
-;;;;;; thai-compose-buffer thai-compose-string thai-compose-region
-;;;;;; setup-thai-environment) "thai-util" "language/thai-util.el"
-;;;;;; (14477 53255))
+;;;;;; thai-compose-buffer thai-compose-string thai-compose-region)
+;;;;;; "thai-util" "language/thai-util.el" (14647 32047))
;;; Generated autoloads from language/thai-util.el
-(autoload (quote setup-thai-environment) "thai-util" "\
-Setup multilingual environment (MULE) for Thai." t nil)
-
(autoload (quote thai-compose-region) "thai-util" "\
Compose Thai characters in the region.
When called from a program, expects two arguments,
\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" (14495 17997))
+;;;;;; "thingatpt" "thingatpt.el" (14746 24125))
;;; Generated autoloads from thingatpt.el
(autoload (quote forward-thing) "thingatpt" "\
\f
;;;### (autoloads (tibetan-pre-write-conversion tibetan-post-read-conversion
;;;;;; tibetan-compose-buffer tibetan-decompose-buffer tibetan-composition-function
-;;;;;; tibetan-compose-region tibetan-compose-string tibetan-transcription-to-tibetan
-;;;;;; tibetan-tibetan-to-transcription tibetan-char-p setup-tibetan-environment)
-;;;;;; "tibet-util" "language/tibet-util.el" (14423 51008))
+;;;;;; 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" (14672
+;;;;;; 33974))
;;; Generated autoloads from language/tibet-util.el
-(autoload (quote setup-tibetan-environment) "tibet-util" nil t nil)
-
(autoload (quote tibetan-char-p) "tibet-util" "\
Check if char CH is Tibetan character.
Returns non-nil if CH is Tibetan. Otherwise, returns nil." nil nil)
(autoload (quote tibetan-compose-region) "tibet-util" "\
Compose Tibetan text the region BEG and END." t nil)
-(defalias (quote tibetan-decompose-region) (quote decompose-region))
+(autoload (quote tibetan-decompose-region) "tibet-util" "\
+Decompose Tibetan text in the region FROM and TO.
+This is different from decompose-region because precomposed Tibetan characters
+are decomposed into normal Tiebtan character sequences." t nil)
-(defalias (quote tibetan-decompose-string) (quote decompose-string))
+(autoload (quote tibetan-decompose-string) "tibet-util" "\
+Decompose Tibetan string STR.
+This is different from decompose-string because precomposed Tibetan characters
+are decomposed into normal Tiebtan character sequences." nil nil)
(autoload (quote tibetan-composition-function) "tibet-util" nil nil nil)
;;;***
\f
;;;### (autoloads (tildify-buffer tildify-region) "tildify" "textmodes/tildify.el"
-;;;;;; (14357 30776))
+;;;;;; (14780 47087))
;;; Generated autoloads from textmodes/tildify.el
(autoload (quote tildify-region) "tildify" "\
;;;***
\f
-;;;### (autoloads (display-time-mode display-time display-time-day-and-date
-;;;;;; display-time-mode) "time" "time.el" (14526 14916))
+;;;### (autoloads (display-time-mode display-time display-time-day-and-date)
+;;;;;; "time" "time.el" (14854 32222))
;;; Generated autoloads from time.el
-(defvar display-time-mode nil "\
-Toggle display of time, load level, and mail flag in mode lines.
-Setting this variable directly does not take effect;
-use either \\[customize] or the function `display-time-mode'.")
-
-(custom-add-to-group (quote display-time) (quote display-time-mode) (quote custom-variable))
-
-(custom-add-load (quote display-time-mode) (quote time))
-
(defvar display-time-day-and-date nil "\
*Non-nil means \\[display-time] should display day and date as well as time.")
are displayed as well.
This runs the normal hook `display-time-hook' after each update." t nil)
+(defvar display-time-mode nil "\
+Toggle Display-Time mode on or off.
+See the command `display-time-mode' for a description of this minor-mode.
+Setting this variable directly does not take effect;
+use either \\[customize] or the function `display-time-mode'.")
+
+(custom-add-to-group (quote display-time) (quote display-time-mode) (quote custom-variable))
+
+(custom-add-load (quote display-time-mode) (quote time))
+
(autoload (quote 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.
are displayed as well.
This runs the normal hook `display-time-hook' after each update." t nil)
+;;;***
+\f
+;;;### (autoloads (safe-date-to-time date-to-time) "time-date" "gnus/time-date.el"
+;;;;;; (14791 27442))
+;;; Generated autoloads from gnus/time-date.el
+
+(autoload (quote date-to-time) "time-date" "\
+Convert DATE into time." nil nil)
+
+(autoload (quote safe-date-to-time) "time-date" "\
+Parse DATE and return a time structure.
+If DATE is malformed, a zero time will be returned." nil nil)
+
;;;***
\f
;;;### (autoloads (time-stamp-toggle-active time-stamp) "time-stamp"
-;;;;;; "time-stamp.el" (14277 60981))
+;;;;;; "time-stamp.el" (14845 20872))
;;; Generated autoloads from time-stamp.el
(autoload (quote time-stamp) "time-stamp" "\
Toggle `time-stamp-active', setting whether \\[time-stamp] updates a buffer.
With arg, turn time stamping on if and only if arg is positive." t nil)
+;;;***
+\f
+;;;### (autoloads (timeclock-when-to-leave-string timeclock-workday-elapsed-string
+;;;;;; timeclock-workday-remaining-string timeclock-reread-log timeclock-query-out
+;;;;;; timeclock-change timeclock-status-string timeclock-out timeclock-in
+;;;;;; timeclock-modeline-display) "timeclock" "calendar/timeclock.el"
+;;;;;; (14845 20873))
+;;; Generated autoloads from calendar/timeclock.el
+
+(autoload (quote timeclock-modeline-display) "timeclock" "\
+Toggle display of the amount of time left today in the modeline.
+If `timeclock-use-display-time' is non-nil, the modeline will be
+updated whenever the time display is updated. Otherwise, the
+timeclock will use its own sixty second timer to do its updating.
+With prefix ARG, turn modeline display on if and only if ARG is
+positive. Returns the new status of timeclock modeline display
+\(non-nil means on)." t nil)
+
+(autoload (quote timeclock-in) "timeclock" "\
+Clock in, recording the current time moment in the timelog.
+With a numeric prefix ARG, record the fact that today has only that
+many hours in it to be worked. If arg is a non-numeric prefix arg
+\(non-nil, but not a number), 0 is assumed (working on a holiday or
+weekend). *If not called interactively, ARG should be the number of
+_seconds_ worked today*. This feature only has effect the first time
+this function is called within a day.
+
+PROJECT as the project being clocked into. If PROJECT is nil, and
+FIND-PROJECT is non-nil -- or the user calls `timeclock-in'
+interactively -- call the function `timeclock-get-project-function' to
+discover the name of the project." t nil)
+
+(autoload (quote timeclock-out) "timeclock" "\
+Clock out, recording the current time moment in the timelog.
+If a prefix ARG is given, the user has completed the project that was
+begun during the last time segment.
+
+REASON is the user's reason for clocking out. If REASON is nil, and
+FIND-REASON is non-nil -- or the user calls `timeclock-out'
+interactively -- call the function `timeclock-get-reason-function' to
+discover the reason." t nil)
+
+(autoload (quote timeclock-status-string) "timeclock" "\
+Report the overall timeclock status at the present moment." t nil)
+
+(autoload (quote timeclock-change) "timeclock" "\
+Change to working on a different project, by clocking in then out.
+With a prefix ARG, consider the previous project as having been
+finished at the time of changeover. PROJECT is the name of the last
+project you were working on." t nil)
+
+(autoload (quote timeclock-query-out) "timeclock" "\
+Ask the user before clocking out.
+This is a useful function for adding to `kill-emacs-hook'." nil nil)
+
+(autoload (quote timeclock-reread-log) "timeclock" "\
+Re-read the timeclock, to account for external changes.
+Returns the new value of `timeclock-discrepancy'." t nil)
+
+(autoload (quote timeclock-workday-remaining-string) "timeclock" "\
+Return a string representing the amount of time left today.
+Display second resolution if SHOW-SECONDS is non-nil. If TODAY-ONLY
+is non-nil, the display will be relative only to time worked today.
+See `timeclock-relative' for more information about the meaning of
+\"relative to today\"." t nil)
+
+(autoload (quote timeclock-workday-elapsed-string) "timeclock" "\
+Return a string representing the amount of time worked today.
+Display seconds resolution if SHOW-SECONDS is non-nil. If RELATIVE is
+non-nil, the amount returned will be relative to past time worked." t nil)
+
+(autoload (quote timeclock-when-to-leave-string) "timeclock" "\
+Return a string representing at what time the workday ends today.
+This string is relative to the value of `timeclock-workday'. If
+NO-MESSAGE is non-nil, no messages will be displayed in the
+minibuffer. If SHOW-SECONDS is non-nil, the value printed/returned
+will include seconds. If TODAY-ONLY is non-nil, the value returned
+will be relative only to the time worked today, and not to past time.
+This argument only makes a difference if `timeclock-relative' is
+non-nil." t nil)
+
;;;***
\f
;;;### (autoloads (with-timeout run-with-idle-timer add-timeout run-with-timer
;;;;;; run-at-time cancel-function-timers cancel-timer) "timer"
-;;;;;; "timer.el" (13316 52821))
+;;;;;; "timer.el" (14766 7772))
;;; Generated autoloads from timer.el
(defalias (quote disable-timeout) (quote cancel-timer))
(autoload (quote run-with-idle-timer) "timer" "\
Perform an action the next time Emacs is idle for SECS seconds.
-If REPEAT is non-nil, do this each time Emacs is idle for SECS seconds.
-SECS may be an integer or a floating point number.
The action is to call FUNCTION with arguments ARGS.
+SECS may be an integer or a floating point number.
+
+If REPEAT is non-nil, do the action each time Emacs has been idle for
+exactly SECS seconds (that is, only once for each time Emacs becomes idle).
This function returns a timer object which you can use in `cancel-timer'." t nil)
(put 'with-timeout 'lisp-indent-function 1)
;;;***
\f
;;;### (autoloads (batch-titdic-convert titdic-convert) "titdic-cnv"
-;;;;;; "international/titdic-cnv.el" (13618 46800))
+;;;;;; "international/titdic-cnv.el" (14821 31351))
;;; Generated autoloads from international/titdic-cnv.el
(autoload (quote titdic-convert) "titdic-cnv" "\
;;;***
\f
;;;### (autoloads (tmm-prompt tmm-menubar-mouse tmm-menubar) "tmm"
-;;;;;; "tmm.el" (14467 13719))
+;;;;;; "tmm.el" (14789 57836))
;;; Generated autoloads from tmm.el
(define-key global-map "\M-`" 'tmm-menubar)
(define-key global-map [f10] 'tmm-menubar)
DEFAULT-ITEM, if non-nil, specifies an initial default choice.
Its value should be an event that has a binding in MENU." nil nil)
+;;;***
+\f
+;;;### (autoloads (todo-print todo-save-top-priorities todo-top-priorities)
+;;;;;; "todo-mode" "calendar/todo-mode.el" (14690 14754))
+;;; Generated autoloads from calendar/todo-mode.el
+
+(autoload (quote todo-top-priorities) "todo-mode" "\
+List top priorities for each category.
+
+Number of entries for each category is given by NOF-PRIORITIES which
+defaults to 'todo-show-priorities'.
+
+If CATEGORY-PR-PAGE is non-nil, a page separator '^L' is inserted
+between each category." t nil)
+
+(autoload (quote todo-save-top-priorities) "todo-mode" "\
+Save top priorities for each category in `todo-file-top'.
+
+Number of entries for each category is given by NOF-PRIORITIES which
+defaults to `todo-show-priorities'." t nil)
+
+(autoload (quote todo-print) "todo-mode" "\
+Print todo summary using `todo-print-function'.
+If CATEGORY-PR-PAGE is non-nil, a page separator `^L' is inserted
+between each category.
+
+Number of entries for each category is given by `todo-print-priorities'." t nil)
+
+;;;***
+\f
+;;;### (autoloads (tool-bar-add-item-from-menu tool-bar-add-item
+;;;;;; tool-bar-mode) "tool-bar" "toolbar/tool-bar.el" (14854 32223))
+;;; Generated autoloads from toolbar/tool-bar.el
+
+(defvar tool-bar-mode nil "\
+Toggle Tool-Bar mode on or off.
+See the command `tool-bar-mode' for a description of this minor-mode.
+Setting this variable directly does not take effect;
+use either \\[customize] or the function `tool-bar-mode'.")
+
+(custom-add-to-group (quote mouse) (quote tool-bar-mode) (quote custom-variable))
+
+(custom-add-load (quote tool-bar-mode) (quote tool-bar))
+
+(autoload (quote tool-bar-mode) "tool-bar" "\
+Toggle use of the tool bar.
+With ARG, display the tool bar if and only if ARG is positive.
+
+See `tool-bar-add-item' and `tool-bar-add-item-from-menu' for
+conveniently adding tool bar items." t nil)
+
+(autoload (quote tool-bar-add-item) "tool-bar" "\
+Add an item to the tool bar.
+ICON names the image, DEF is the key definition and KEY is a symbol
+for the fake function key in the menu keymap. Remaining arguments
+PROPS are additional items to add to the menu item specification. See
+Info node `(elisp)Tool Bar'. Items are added from left to right.
+
+ICON is the base name of a file cnntaining the image to use. The
+function will try to use first ICON.xpm, ICON.pbm then ICON.xbm using
+`find-image'.
+
+Keybindings are made in the map `tool-bar-map'. To define items in
+some local map, bind `tool-bar-map' with `let' around calls of this
+function." nil nil)
+
+(autoload (quote tool-bar-add-item-from-menu) "tool-bar" "\
+Define tool bar binding for COMMAND using the given ICON in keymap MAP.
+The binding of COMMAND is looked up in the menu bar in MAP (default
+`global-map') and modified to add an image specification for ICON, which
+is looked for as by `tool-bar-add-item'.
+MAP must contain an appropriate keymap bound to `[menu-bar]'.
+PROPS is a list of additional properties to add to the binding.
+
+Keybindings are made in the map `tool-bar-map'. To define items in
+some local map, bind `tool-bar-map' with `let' around calls of this
+function." nil nil)
+
;;;***
\f
;;;### (autoloads (tooltip-mode tooltip-mode) "tooltip" "tooltip.el"
-;;;;;; (14495 17998))
+;;;;;; (14849 20130))
;;; Generated autoloads from tooltip.el
(autoload (quote tooltip-mode) "tooltip" "\
;;;***
\f
;;;### (autoloads (trace-function-background trace-function trace-buffer)
-;;;;;; "trace" "emacs-lisp/trace.el" (13607 52440))
+;;;;;; "trace" "emacs-lisp/trace.el" (14583 8560))
;;; Generated autoloads from emacs-lisp/trace.el
(defvar trace-buffer "*trace-output*" "\
;;;### (autoloads (type-break-guesstimate-keystroke-threshold type-break-statistics
;;;;;; type-break type-break-mode type-break-keystroke-threshold
;;;;;; type-break-good-rest-interval type-break-interval type-break-mode)
-;;;;;; "type-break" "type-break.el" (14263 36029))
+;;;;;; "type-break" "type-break.el" (14716 17385))
;;; Generated autoloads from type-break.el
(defvar type-break-mode nil "\
;;;***
\f
;;;### (autoloads (ask-user-about-supersession-threat ask-user-about-lock)
-;;;;;; "userlock" "userlock.el" (14365 43297))
+;;;;;; "userlock" "userlock.el" (14365 43399))
;;; Generated autoloads from userlock.el
(autoload (quote ask-user-about-lock) "userlock" "\
You can rewrite this to use any criterion you like to choose which one to do.
The buffer in question is current when this function is called." nil nil)
+;;;***
+\f
+;;;### (autoloads (uudecode-decode-region uudecode-decode-region-external)
+;;;;;; "uudecode" "gnus/uudecode.el" (14858 32485))
+;;; Generated autoloads from gnus/uudecode.el
+
+(autoload (quote uudecode-decode-region-external) "uudecode" "\
+Uudecode region between START and END with external decoder.
+
+If FILE-NAME is non-nil, save the result to FILE-NAME." t nil)
+
+(autoload (quote uudecode-decode-region) "uudecode" "\
+Uudecode region between START and END.
+If FILE-NAME is non-nil, save the result to FILE-NAME." t nil)
+
;;;***
\f
;;;### (autoloads (vc-annotate vc-update-change-log vc-rename-file
;;;;;; vc-cancel-version vc-revert-buffer vc-print-log vc-retrieve-snapshot
;;;;;; vc-create-snapshot vc-directory vc-resolve-conflicts vc-merge
;;;;;; vc-insert-headers vc-version-other-window vc-diff vc-register
-;;;;;; vc-next-action edit-vc-file with-vc-file vc-annotate-mode-hook
-;;;;;; vc-before-checkin-hook vc-checkin-hook) "vc" "vc.el" (14478
-;;;;;; 52465))
+;;;;;; vc-next-action edit-vc-file with-vc-file vc-before-checkin-hook
+;;;;;; vc-checkin-hook) "vc" "vc.el" (14845 20872))
;;; Generated autoloads from vc.el
(defvar vc-checkin-hook nil "\
See `run-hooks'.")
(defvar vc-before-checkin-hook nil "\
-*Normal hook (list of functions) run before a file gets checked in.
+*Normal hook (list of functions) run before a file gets checked in.
See `run-hooks'.")
-(defvar vc-annotate-mode-hook nil "\
-*Hooks to run when VC-Annotate mode is turned on.")
-
(autoload (quote with-vc-file) "vc" "\
-Execute BODY, checking out a writable copy of FILE first if necessary.
-After BODY has been executed, check-in FILE with COMMENT (a string).
-FILE is passed through `expand-file-name'; BODY executed within
-`save-excursion'. If FILE is not under version control, or locked by
+Check out a writable copy of FILE if necessary and execute the body.
+Check in FILE with COMMENT (a string) after BODY has been executed.
+FILE is passed through `expand-file-name'; BODY executed within
+`save-excursion'. If FILE is not under version control, or locked by
somebody else, signal error." nil (quote macro))
(autoload (quote edit-vc-file) "vc" "\
-Edit FILE under version control, executing BODY. Checkin with COMMENT.
+Edit FILE under version control, executing body.
+Checkin with COMMENT after executing BODY.
This macro uses `with-vc-file', passing args to it.
However, before executing BODY, find FILE, and after BODY, save buffer." nil (quote macro))
(autoload (quote vc-next-action) "vc" "\
Do the next logical checkin or checkout operation on the current file.
- If you call this from within a VC dired buffer with no files marked,
+
+If you call this from within a VC dired buffer with no files marked,
it will operate on the file in the current line.
- If you call this from within a VC dired buffer, and one or more
+
+If you call this from within a VC dired buffer, and one or more
files are marked, it will accept a log message and then operate on
each one. The log message will be used as a comment for any register
or checkin operations, but ignored when doing checkouts. Attempted
lock steals will raise an error.
- A prefix argument lets you specify the version number to use.
+
+A prefix argument lets you specify the version number to use.
For RCS and SCCS files:
If the file is not already registered, this registers it for version
merge in the changes into your working copy." t nil)
(autoload (quote vc-register) "vc" "\
-Register the current file into your version-control system." t nil)
+Register the current file into a version control system.
+With prefix argument SET-VERSION, allow user to specify initial version
+level. If COMMENT is present, use that as an initial comment.
+
+The version control system to use is found by cycling through the list
+`vc-handled-backends'. The first backend in that list which declares
+itself responsible for the file (usually because other files in that
+directory are already registered under that backend) will be used to
+register the file. If no backend declares itself responsible, the
+first backend that could register the file is used." t nil)
(autoload (quote vc-diff) "vc" "\
Display diffs between file versions.
-Normally this compares the current file and buffer with the most recent
+Normally this compares the current file and buffer with the most recent
checked in version of that file. This uses no arguments.
With a prefix argument, it reads the file name to use
and two version designators specifying which versions to compare." t nil)
If `F.~REV~' already exists, it is used instead of being re-created." t nil)
(autoload (quote vc-insert-headers) "vc" "\
-Insert headers in a file for use with your version-control system.
+Insert headers in a file for use with your version control system.
Headers desired are inserted at point, and are pulled from
-the variable `vc-header-alist'." t nil)
+the variable `vc-BACKEND-header'." t nil)
+
+(autoload (quote vc-merge) "vc" "\
+Merge changes between two versions into the current buffer's file.
+This asks for two versions to merge from in the minibuffer. If the
+first version is a branch number, then merge all changes from that
+branch. If the first version is empty, merge news, i.e. recent changes
+from the current branch.
-(autoload (quote vc-merge) "vc" nil t nil)
+See Info node `Merging'." t nil)
(autoload (quote vc-resolve-conflicts) "vc" "\
Invoke ediff to resolve conflicts in the current buffer.
The conflicts must be marked with rcsmerge conflict markers." t nil)
-(autoload (quote vc-directory) "vc" nil t nil)
+(autoload (quote vc-directory) "vc" "\
+Create a buffer in VC Dired Mode for directory DIR.
+
+See Info node `VC Dired Mode'.
+
+With prefix arg READ-SWITCHES, specify a value to override
+`dired-listing-switches' when generating the listing." t nil)
(autoload (quote vc-create-snapshot) "vc" "\
-Make a snapshot called NAME.
-The snapshot is made from all registered files at or below the current
-directory. For each file, the version level of its latest
-version becomes part of the named configuration." t nil)
+Descending recursively from DIR, make a snapshot called NAME.
+For each registered file, the version level of its latest version
+becomes part of the named configuration. If the prefix argument
+BRANCHP is given, the snapshot is made as a new branch and the files
+are checked out in that new branch." t nil)
(autoload (quote vc-retrieve-snapshot) "vc" "\
-Retrieve the snapshot called NAME, or latest versions if NAME is empty.
-When retrieving a snapshot, there must not be any locked files at or below
-the current directory. If none are locked, all registered files are
-checked out (unlocked) at their version levels in the snapshot NAME.
-If NAME is the empty string, all registered files that are not currently
-locked are updated to the latest versions." t nil)
+Descending recursively from DIR, retrieve the snapshot called NAME.
+If NAME is empty, it refers to the latest versions.
+If locking is used for the files in DIR, then there must not be any
+locked files at or below DIR (but if NAME is empty, locked files are
+allowed and simply skipped)." t nil)
(autoload (quote vc-print-log) "vc" "\
List the change log of the current buffer in a window." t nil)
(autoload (quote vc-revert-buffer) "vc" "\
Revert the current buffer's file back to the version it was based on.
This asks for confirmation if the buffer contents are not identical
-to that version. Note that for RCS and CVS, this function does not
-automatically pick up newer changes found in the master file;
-use C-u \\[vc-next-action] RET to do so." t nil)
+to that version. This function does not automatically pick up newer
+changes found in the master file; use \\[universal-argument] \\[vc-next-action] to do so." t nil)
(autoload (quote vc-cancel-version) "vc" "\
Get rid of most recently checked in version of this file.
-A prefix argument means do not revert the buffer afterwards." t nil)
+A prefix argument NOREVERT means do not revert the buffer afterwards." t nil)
(autoload (quote vc-rename-file) "vc" "\
Rename file OLD to NEW, and rename its master file likewise." t nil)
(autoload (quote vc-update-change-log) "vc" "\
-Find change log file and add entries from recent RCS/CVS logs.
+Find change log file and add entries from recent version control logs.
Normally, find log entries for all registered files in the default
-directory using `rcs2log', which finds CVS logs preferentially.
-The mark is left at the end of the text prepended to the change log.
+directory.
-With prefix arg of C-u, only find log entries for the current buffer's file.
+With prefix arg of \\[universal-argument], only find log entries for the current buffer's file.
With any numeric prefix arg, find log entries for all currently visited
files that are under version control. This puts all the entries in the
log for the default directory, which may not be appropriate.
-From a program, any arguments are assumed to be filenames and are
-passed to the `rcs2log' script after massaging to be relative to the
-default directory." t nil)
+From a program, any ARGS are assumed to be filenames for which
+log entries should be gathered." t nil)
(autoload (quote vc-annotate) "vc" "\
-Display the result of the CVS `annotate' command using colors.
-New lines are displayed in red, old in blue.
-A prefix argument specifies a factor for stretching the time scale.
+Display the result of the \"Annotate\" command using colors.
+\"Annotate\" is defined by `vc-BACKEND-annotate-command'. New lines
+are displayed in red, old in blue. A prefix argument specifies a
+factor for stretching the time scale.
`vc-annotate-menu-elements' customizes the menu elements of the
mode-specific menu. `vc-annotate-color-map' and
`vc-annotate-very-old-color' defines the mapping of time to
colors. `vc-annotate-background' specifies the background color." t nil)
+;;;***
+\f
+;;;### (autoloads nil "vc-cvs" "vc-cvs.el" (14845 20872))
+;;; Generated autoloads from vc-cvs.el
+ (defun vc-cvs-registered (f)
+ (when (file-readable-p (expand-file-name
+ "CVS/Entries" (file-name-directory f)))
+ (require 'vc-cvs)
+ (vc-cvs-registered f)))
+
+;;;***
+\f
+;;;### (autoloads (vc-rcs-master-templates) "vc-rcs" "vc-rcs.el"
+;;;;;; (14810 62717))
+;;; Generated autoloads from vc-rcs.el
+
+(defvar vc-rcs-master-templates (quote ("%sRCS/%s,v" "%s%s,v" "%sRCS/%s")) "\
+*Where to look for RCS master files.
+For a description of possible values, see `vc-check-master-templates'.")
+
+(defun vc-rcs-registered (f) (vc-default-registered (quote RCS) f))
+
+;;;***
+\f
+;;;### (autoloads (vc-sccs-master-templates) "vc-sccs" "vc-sccs.el"
+;;;;;; (14777 64827))
+;;; Generated autoloads from vc-sccs.el
+
+(defvar vc-sccs-master-templates (quote ("%sSCCS/s.%s" "%ss.%s" vc-sccs-search-project-dir)) "\
+*Where to look for SCCS master files.
+For a description of possible values, see `vc-check-master-templates'.")
+
+(defun vc-sccs-registered (f) (vc-default-registered (quote SCCS) f))
+
+(defun vc-sccs-search-project-dir (dirname basename) "\
+Return the name of a master file in the SCCS project directory.
+Does not check whether the file exists but returns nil if it does not
+find any project directory." (let ((project-dir (getenv "PROJECTDIR")) dirs dir) (when project-dir (if (file-name-absolute-p project-dir) (setq dirs (quote ("SCCS" ""))) (setq dirs (quote ("src/SCCS" "src" "source/SCCS" "source"))) (setq project-dir (expand-file-name (concat "~" project-dir)))) (while (and (not dir) dirs) (setq dir (expand-file-name (car dirs) project-dir)) (unless (file-directory-p dir) (setq dir nil) (setq dirs (cdr dirs)))) (and dir (expand-file-name (concat "s." basename) dir)))))
+
;;;***
\f
;;;### (autoloads (vhdl-mode) "vhdl-mode" "progmodes/vhdl-mode.el"
-;;;;;; (14385 10956))
+;;;;;; (14385 23382))
;;; Generated autoloads from progmodes/vhdl-mode.el
(autoload (quote vhdl-mode) "vhdl-mode" "\
\f
;;;### (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 setup-vietnamese-environment viet-encode-viscii-char)
-;;;;;; "viet-util" "language/viet-util.el" (13876 11275))
+;;;;;; viet-decode-viqr-region viet-encode-viscii-char) "viet-util"
+;;;;;; "language/viet-util.el" (14623 45992))
;;; Generated autoloads from language/viet-util.el
(autoload (quote viet-encode-viscii-char) "viet-util" "\
Return VISCII character code of CHAR if appropriate." nil nil)
-(autoload (quote setup-vietnamese-environment) "viet-util" "\
-Setup multilingual environment (MULE) for Vietnamese VISCII users." t nil)
-
(autoload (quote viet-decode-viqr-region) "viet-util" "\
Convert `VIQR' mnemonics of the current region to Vietnamese characaters.
When called from a program, expects two arguments,
\f
;;;### (autoloads (View-exit-and-edit view-mode-enter view-mode view-buffer-other-frame
;;;;;; view-buffer-other-window view-buffer view-file-other-frame
-;;;;;; view-file-other-window view-file) "view" "view.el" (14550
-;;;;;; 6934))
+;;;;;; view-file-other-window view-file) "view" "view.el" (14789
+;;;;;; 57836))
;;; Generated autoloads from view.el
(defvar view-mode nil "\
;;;***
\f
;;;### (autoloads (viper-mode toggle-viper-mode) "viper" "emulation/viper.el"
-;;;;;; (14522 27540))
+;;;;;; (14845 20873))
;;; Generated autoloads from emulation/viper.el
(autoload (quote toggle-viper-mode) "viper" "\
;;;***
\f
-;;;### (autoloads (webjump) "webjump" "net/webjump.el" (14223 54012))
+;;;### (autoloads (webjump) "webjump" "net/webjump.el" (14550 8900))
;;; Generated autoloads from net/webjump.el
(autoload (quote webjump) "webjump" "\
;;;***
\f
;;;### (autoloads (which-func-mode which-func-mode-global) "which-func"
-;;;;;; "which-func.el" (14281 33928))
+;;;;;; "which-func.el" (14813 40531))
;;; Generated autoloads from which-func.el
(defvar which-func-mode-global nil "\
When Which Function mode is enabled, the current function name is
continuously displayed in the mode line, in certain major modes.
-With prefix arg, turn Which Function mode on iff arg is positive,
+With prefix ARG, turn Which Function mode on iff arg is positive,
and off otherwise." t nil)
;;;***
\f
-;;;### (autoloads (whitespace-describe whitespace-cleanup-region
+;;;### (autoloads (whitespace-describe whitespace-global-mode whitespace-cleanup-region
;;;;;; whitespace-cleanup whitespace-region whitespace-buffer) "whitespace"
-;;;;;; "whitespace.el" (14495 17999))
+;;;;;; "whitespace.el" (14826 56520))
;;; Generated autoloads from whitespace.el
(autoload (quote whitespace-buffer) "whitespace" "\
-Find five different types of white spaces in buffer:
-
+Find five different types of white spaces in buffer.
+These are:
1. Leading space (empty lines at the top of a file).
2. Trailing space (empty lines at the end of a file).
3. Indentation space (8 or more spaces, that should be replaced with TABS).
2. `whitespace-buffer' was explicitly called with a prefix argument." t nil)
(autoload (quote whitespace-region) "whitespace" "\
-Check a region specified by point and mark for whitespace errors." t nil)
+Check the region for whitespace errors." t nil)
(autoload (quote whitespace-cleanup) "whitespace" "\
Cleanup the five different kinds of whitespace problems.
whitespace problems." t nil)
(autoload (quote whitespace-cleanup-region) "whitespace" "\
-Whitespace cleanup on a region specified by point and mark." t nil)
+Whitespace cleanup on the region." t nil)
+
+(defvar whitespace-global-mode nil "\
+Toggle global Whitespace mode.
+
+Setting this variable directly does not take effect;
+use either \\[customize] or the function `whitespace-global-mode'
+\(which see).")
+
+(custom-add-to-group (quote whitespace) (quote whitespace-global-mode) (quote custom-variable))
+
+(custom-add-load (quote whitespace-global-mode) (quote whitespace))
(autoload (quote whitespace-describe) "whitespace" "\
A summary of whitespaces and what this library can do about them.
2. Trailing space (empty lines at the end of a file).
3. Indentation space (8 or more spaces at beginning of line, that should be
replaced with TABS).
-4. Spaces followed by a TAB. (Almost always, we never want that).
+4. Spaces followed by a TAB. (Almost always, we never want that).
5. Spaces or TABS at the end of a line.
Whitespace errors are reported in a buffer, and on the modeline.
(since (3) is the most controversial one, here is the rationale: Most
terminal drivers and printer drivers have TAB configured or even
- hardcoded to be 8 spaces. (Some of them allow configuration, but almost
+ hardcoded to be 8 spaces. (Some of them allow configuration, but almost
always they default to 8.)
- Changing tab-width to other than 8 and editing will cause your code to
+ Changing `tab-width' to other than 8 and editing will cause your code to
look different from within Emacs, and say, if you cat it or more it, or
even print it.
Almost all the popular programming modes let you define an offset (like
c-basic-offset or perl-indent-level) to configure the offset, so you
- should never have to set your tab-width to be other than 8 in all these
- modes. In fact, with an indent level of say, 4, 2 TABS will cause Emacs
- to replace your 8 spaces with one (try it). If vi users in your
+ should never have to set your `tab-width' to be other than 8 in all these
+ modes. In fact, with an indent level of say, 4, 2 TABS will cause Emacs
+ to replace your 8 spaces with one (try it). If vi users in your
office complain, tell them to use vim, which distinguishes between
tabstop and shiftwidth (vi equivalent of our offsets), and also ask them
to set smarttab.)
merge problems.
whitespace.el will complain if it detects whitespaces on opening a file, and
-warn you on closing a file also. (if in case you had inserted any
-whitespaces during the process of your editing.)" t nil)
+warn you on closing a file also (in case you had inserted any
+whitespaces during the process of your editing)." t nil)
;;;***
\f
;;;### (autoloads (widget-minor-mode widget-browse-other-window widget-browse
-;;;;;; widget-browse-at) "wid-browse" "wid-browse.el" (13218 28813))
+;;;;;; widget-browse-at) "wid-browse" "wid-browse.el" (14840 890))
;;; Generated autoloads from wid-browse.el
(autoload (quote widget-browse-at) "wid-browse" "\
;;;***
\f
;;;### (autoloads (widget-delete widget-create widget-prompt-value)
-;;;;;; "wid-edit" "wid-edit.el" (14508 6458))
+;;;;;; "wid-edit" "wid-edit.el" (14854 32222))
;;; Generated autoloads from wid-edit.el
(autoload (quote widget-prompt-value) "wid-edit" "\
The current value is assumed to be VALUE, unless UNBOUND is non-nil." nil nil)
(autoload (quote widget-create) "wid-edit" "\
-Create widget of TYPE.
+Create widget of TYPE.
The optional ARGS are additional keyword arguments." nil nil)
(autoload (quote widget-delete) "wid-edit" "\
;;;***
\f
;;;### (autoloads (windmove-default-keybindings windmove-down windmove-right
-;;;;;; windmove-up windmove-left) "windmove" "windmove.el" (14485
-;;;;;; 64331))
+;;;;;; windmove-up windmove-left) "windmove" "windmove.el" (14747
+;;;;;; 44775))
;;; Generated autoloads from windmove.el
(autoload (quote windmove-left) "windmove" "\
Toggle Winner mode.
With arg, turn Winner mode on if and only if arg is positive." t nil)
+;;;***
+\f
+;;;### (autoloads (woman-find-file woman-dired-find-file woman) "woman"
+;;;;;; "woman.el" (14836 3751))
+;;; Generated autoloads from woman.el
+
+(autoload (quote woman) "woman" "\
+Browse UN*X man page for TOPIC (Without using external Man program).
+The major browsing mode used is essentially the standard Man mode.
+Choose the filename for the man page using completion, based on the
+topic selected from the directories specified in `woman-manpath' and
+`woman-path'. The directory expansions and topics are cached for
+speed, but a non-nil interactive argument forces the caches to be
+updated (e.g. to re-interpret the current directory).
+
+Used non-interactively, arguments are optional: if given then TOPIC
+should be a topic string and non-nil RE-CACHE forces re-caching." t nil)
+
+(autoload (quote woman-dired-find-file) "woman" "\
+In dired, run the WoMan man-page browser on this file." t nil)
+
+(autoload (quote woman-find-file) "woman" "\
+Find, decode and browse a specific UN*X man-page source file FILE-NAME.
+Use existing buffer if possible; reformat only if prefix arg given.
+When called interactively, optional argument REFORMAT forces reformatting
+of an existing WoMan buffer formatted earlier.
+No external programs are used, except that `gunzip' will be used to
+decompress the file if appropriate. See the documentation for the
+`woman' command for further details." t nil)
+
;;;***
\f
;;;### (autoloads (wordstar-mode) "ws-mode" "emulation/ws-mode.el"
;;;***
\f
;;;### (autoloads (psychoanalyze-pinhead apropos-zippy insert-zippyism
-;;;;;; yow) "yow" "play/yow.el" (13607 43571))
+;;;;;; yow) "yow" "play/yow.el" (14810 62720))
;;; Generated autoloads from play/yow.el
(autoload (quote yow) "yow" "\
(autoload (quote psychoanalyze-pinhead) "yow" "\
Zippy goes to the analyst." t nil)
+;;;***
+\f
+;;;### (autoloads (zone) "zone" "play/zone.el" (14821 31351))
+;;; Generated autoloads from play/zone.el
+
+(autoload (quote zone) "zone" "\
+Zone out, completely." t nil)
+
;;;***
\f
;;;### (autoloads (zone-mode zone-mode-update-serial-hook) "zone-mode"
-;;;;;; "net/zone-mode.el" (13674 20513))
+;;;;;; "net/zone-mode.el" (14550 9028))
;;; Generated autoloads from net/zone-mode.el
(autoload (quote zone-mode-update-serial-hook) "zone-mode" "\