-;;; loaddefs.el --- define autoloads from other files
-
-;; Copyright (C) 1985,86,87,92,93,94,95,96,97,98 Free Software Foundation, Inc.
-
-;; Maintainer: FSF
-;; Keywords: internal
-
-;; This file is part of GNU Emacs.
-
-;; GNU Emacs is free software; you can redistribute it and/or modify
-;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation; either version 2, or (at your option)
-;; any later version.
-
-;; GNU Emacs is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-;; GNU General Public License for more details.
-
-;; You should have received a copy of the GNU General Public License
-;; along with GNU Emacs; see the file COPYING. If not, write to
-;; the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-;; Boston, MA 02111-1307, USA.
-
-;;; **********************************************************************
-;;; You should never need to write autoloads by hand and put them here.
-;;;
-;;; It is no longer necessary. Instead use autoload.el to maintain them
-;;; for you. Just insert ";;;###autoload" before defuns or defmacros you
-;;; want to be autoloaded, or other forms you want copied into loaddefs.el
-;;; (defvars, key definitions, etc.). For example,
-;;; ;;;###autoload
-;;; (defun foobar () ....)
-;;; ;;;###autoload (define-key global-map "f" 'foobar)
-;;; ;;;###autoload
-;;; (defvar foobar-var nil "\
-;;; This is foobar-var's doc-string.")
-;;;
-;;; Then do M-x update-file-autoloads on the file to update loaddefs.el.
-;;;
-;;; You can also use M-x update-autoloads-from-directory to update the
-;;; autoloads in loaddefs.el for all .el files in the directory specified.
-;;; **********************************************************************
-
-;;; Generated autoloads follow (made by autoload.el).
-
-;;; To sort them, execute the following after narrowing
-;;; to a region starting just after the following formfeed (control-l)
-;;; and ending just after the last formfeed in the file.
-
-;;;(sort-regexp-fields nil "\n*.*\n.*from \\(.*\\)[^\f]*\f" "\\1"
-;;; (point-min) (point-max))
-\f
-;;;### (autoloads (ada-make-filename-from-adaname ada-mode) "ada-mode"
-;;;;;; "progmodes/ada-mode.el" (14049 32049))
+;;; loaddefs.el --- automatically extracted autoloads
+;;
+;;; Code:
+\f
+;;;### (autoloads (5x5-crack 5x5-crack-xor-mutate 5x5-crack-mutating-best
+;;;;;; 5x5-crack-mutating-current 5x5-crack-randomly 5x5) "5x5"
+;;;;;; "play/5x5.el" (14247 4566))
+;;; Generated autoloads from play/5x5.el
+
+(autoload (quote 5x5) "5x5" "\
+Play 5x5.
+
+The object of 5x5 is very simple, by moving around the grid and flipping
+squares you must fill the grid.
+
+5x5 keyboard bindings are:
+\\<5x5-mode-map>
+Flip \\[5x5-flip-current]
+Move up \\[5x5-up]
+Move down \\[5x5-down]
+Move left \\[5x5-left]
+Move right \\[5x5-right]
+Start new game \\[5x5-new-game]
+New game with random grid \\[5x5-randomize]
+Random cracker \\[5x5-crack-randomly]
+Mutate current cracker \\[5x5-crack-mutating-current]
+Mutate best cracker \\[5x5-crack-mutating-best]
+Mutate xor cracker \\[5x5-crack-xor-mutate]
+Quit current game \\[5x5-quit-game]" t nil)
+
+(autoload (quote 5x5-crack-randomly) "5x5" "\
+Attempt to crack 5x5 using random solutions." t nil)
+
+(autoload (quote 5x5-crack-mutating-current) "5x5" "\
+Attempt to crack 5x5 by mutating the current solution." t nil)
+
+(autoload (quote 5x5-crack-mutating-best) "5x5" "\
+Attempt to crack 5x5 by mutating the best solution." t nil)
+
+(autoload (quote 5x5-crack-xor-mutate) "5x5" "\
+Attempt to crack 5x5 by xor the current and best solution and then
+mutating the result." t nil)
+
+(autoload (quote 5x5-crack) "5x5" "\
+Attempt to find a solution for 5x5.
+
+5x5-crack takes the argument BREEDER which should be a function that takes
+two parameters, the first will be a grid vector array that is the current
+solution and the second will be the best solution so far. The function
+should return a grid vector array that is the new solution." t nil)
+
+;;;***
+\f
+;;;### (autoloads (ada-mode ada-add-extensions) "ada-mode" "progmodes/ada-mode.el"
+;;;;;; (14360 11474))
;;; Generated autoloads from progmodes/ada-mode.el
+(autoload (quote ada-add-extensions) "ada-mode" "\
+Define SPEC and BODY as being valid extensions for Ada files.
+Going from body to spec with `ff-find-other-file' used these
+extensions.
+SPEC and BODY are two regular expressions that must match against the file
+name" nil nil)
+
(autoload (quote ada-mode) "ada-mode" "\
Ada mode is the major mode for editing Ada code.
Re-format the parameter-list point is in '\\[ada-format-paramlist]'
Indent all lines in region '\\[ada-indent-region]'
- Call external pretty printer program '\\[ada-call-pretty-printer]'
Adjust case of identifiers and keywords in region '\\[ada-adjust-case-region]'
Adjust case of identifiers and keywords in buffer '\\[ada-adjust-case-buffer]'
- Call EXTERNAL pretty printer (if you have one) '\\[ada-call-pretty-printer]'
-
- Fill comment paragraph '\\[ada-fill-comment-paragraph]'
- Fill comment paragraph and justify each line '\\[ada-fill-comment-paragraph-justify]'
- Fill comment paragraph, justify and append postfix '\\[ada-fill-comment-paragraph-postfix]'
+ Fill comment paragraph, justify and append postfix '\\[fill-paragraph]'
Next func/proc/task '\\[ada-next-procedure]' Previous func/proc/task '\\[ada-previous-procedure]'
Next package '\\[ada-next-package]' Previous package '\\[ada-previous-package]'
or '\\[ff-mouse-find-other-file]
Switch to other file in other window '\\[ada-ff-other-window]'
or '\\[ff-mouse-find-other-file-other-window]
- If you use this function in a spec and no body is available, it gets created
- with body stubs.
+ If you use this function in a spec and no body is available, it gets created with body stubs.
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]'
- Execute Gnatf: '\\[ada-gnatf-current]'" t nil)
+ Complete identifier: '\\[ada-complete-identifier]'" t nil)
+
+;;;***
+\f
+;;;### (autoloads (ada-header) "ada-stmt" "progmodes/ada-stmt.el"
+;;;;;; (14360 11651))
+;;; Generated autoloads from progmodes/ada-stmt.el
-(autoload (quote ada-make-filename-from-adaname) "ada-mode" "\
-Determine the filename of a package/procedure from its own Ada name." t nil)
+(autoload (quote ada-header) "ada-stmt" "\
+Insert a descriptive header at the top of the file." t nil)
;;;***
\f
-;;;### (autoloads (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"
-;;;;;; (14214 15653))
+;;;### (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" (14565 55609))
;;; Generated autoloads from add-log.el
(defvar add-log-full-name nil "\
*Full name of user, for inclusion in ChangeLog daily headers.
-This defaults to the value returned by the `user-full-name' function.")
+This defaults to the value returned by the function `user-full-name'.")
(defvar add-log-mailing-address nil "\
*Electronic mail address of user, for inclusion in ChangeLog daily headers.
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 variable
-`add-log-current-defun-header-regexp'.
+identifiers followed by `:' or `='. See variables
+`add-log-current-defun-header-regexp' and
+`add-log-current-defun-function'
Has a preference of looking backwards." nil nil)
+(autoload (quote change-log-merge) "add-log" "\
+Merge the contents of ChangeLog file OTHER-LOG with this buffer.
+Both must be found in Change Log mode (since the merging depends on
+the appropriate motion commands).
+
+Entries are inserted in chronological order.
+
+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)
+
;;;***
\f
;;;### (autoloads (defadvice ad-add-advice ad-default-compilation-action
-;;;;;; ad-redefinition-action) "advice" "emacs-lisp/advice.el" (14192
-;;;;;; 4647))
+;;;;;; ad-redefinition-action) "advice" "emacs-lisp/advice.el" (14410
+;;;;;; 19111))
;;; Generated autoloads from emacs-lisp/advice.el
(defvar ad-redefinition-action (quote warn) "\
A value of `always' will result in unconditional compilation, `never' will
always avoid compilation, `maybe' will compile if the byte-compiler is already
loaded, and `like-original' will compile if the original definition of the
-advised function is compiled or a built-in function. Every other value will
-be interpreted as `maybe'. This variable will only be considered if the
+advised function is compiled or a built-in function. Every other value will
+be interpreted as `maybe'. This variable will only be considered if the
COMPILE argument of `ad-activate' was supplied as nil.")
(autoload (quote ad-add-advice) "advice" "\
-Adds a piece of ADVICE to FUNCTION's list of advices in CLASS.
+Add a piece of ADVICE to FUNCTION's list of advices in CLASS.
If FUNCTION already has one or more pieces of advice of the specified
CLASS then POSITION determines where the new piece will go. The value
of POSITION can either be `first', `last' or a number where 0 corresponds
extreme position. If there was already a piece of ADVICE with the same
name, then the position argument will be ignored and the old advice
will be overwritten with the new one.
- If the FUNCTION was not advised already, then its advice info will be
+ If the FUNCTION was not advised already, then its advice info will be
initialized. Redefining a piece of advice whose name is part of the cache-id
will clear the cache." nil nil)
(autoload (quote defadvice) "advice" "\
-Defines a piece of advice for FUNCTION (a symbol).
+Define a piece of advice for FUNCTION (a symbol).
The syntax of `defadvice' is as follows:
(defadvice FUNCTION (CLASS NAME [POSITION] [ARGLIST] FLAG...)
`compile': In conjunction with `activate' specifies that the resulting
advised function should be compiled.
-`disable': The defined advice will be disabled, hence, it will not be used
+`disable': The defined advice will be disabled, hence, it will not be used
during activation until somebody enables it.
`preactivate': Preactivates the advised FUNCTION at macro-expansion/compile
documentation of the advised function can be dumped onto the `DOC' file
during preloading.
-Look at the file `advice.el' for comprehensive documentation." nil (quote macro))
+See Info node `(elisp)Advising Functions' for comprehensive documentation." nil (quote macro))
+
+;;;***
+\f
+;;;### (autoloads (align-unhighlight-rule align-highlight-rule align-current
+;;;;;; align-entire align-regexp align) "align" "align.el" (14463
+;;;;;; 7197))
+;;; Generated autoloads from align.el
+
+(autoload (quote align) "align" "\
+Attempt to align a region based on a set of alignment rules.
+BEG and END mark the region. If BEG and END are specifically set to
+nil (this can only be done programmatically), the beginning and end of
+the current alignment section will be calculated based on the location
+of point, and the value of `align-region-separate' (or possibly each
+rule's `separate' attribute).
+
+If SEPARATE is non-nil, it overrides the value of
+`align-region-separate' for all rules, except those that have their
+`separate' attribute set.
+
+RULES and EXCLUDE-RULES, if either is non-nil, will replace the
+default rule lists defined in `align-rules-list' and
+`align-exclude-rules-list'. See `align-rules-list' for more details
+on the format of these lists." t nil)
+
+(autoload (quote align-regexp) "align" "\
+Align the current region using an ad-hoc rule read from the minibuffer.
+BEG and END mark the limits of the region. This function will prompt
+for the REGEXP to align with. If no prefix arg was specified, you
+only need to supply the characters to be lined up and any preceding
+whitespace is replaced. If a prefix arg was specified, the full
+regexp with parenthesized whitespace should be supplied; it will also
+prompt for which parenthesis GROUP within REGEXP to modify, the amount
+of SPACING to use, and whether or not to REPEAT the rule throughout
+the line. See `align-rules-list' for more information about these
+options.
+
+For example, let's say you had a list of phone numbers, and wanted to
+align them so that the opening parentheses would line up:
+
+ Fred (123) 456-7890
+ Alice (123) 456-7890
+ Mary-Anne (123) 456-7890
+ Joe (123) 456-7890
+
+There is no predefined rule to handle this, but you could easily do it
+using a REGEXP like \"(\". All you would have to do is to mark the
+region, call `align-regexp' and type in that regular expression." t nil)
+
+(autoload (quote align-entire) "align" "\
+Align the selected region as if it were one alignment section.
+BEG and END mark the extent of the region. If RULES or EXCLUDE-RULES
+is set to a list of rules (see `align-rules-list'), it can be used to
+override the default alignment rules that would have been used to
+align that section." t nil)
+
+(autoload (quote align-current) "align" "\
+Call `align' on the current alignment section.
+This function assumes you want to align only the current section, and
+so saves you from having to specify the region. If RULES or
+EXCLUDE-RULES is set to a list of rules (see `align-rules-list'), it
+can be used to override the default alignment rules that would have
+been used to align that section." t nil)
+
+(autoload (quote align-highlight-rule) "align" "\
+Highlight the whitespace which a given rule would have modified.
+BEG and END mark the extent of the region. TITLE identifies the rule
+that should be highlighted. If RULES or EXCLUDE-RULES is set to a
+list of rules (see `align-rules-list'), it can be used to override the
+default alignment rules that would have been used to identify the text
+to be colored." t nil)
+
+(autoload (quote align-unhighlight-rule) "align" "\
+Remove any highlighting that was added by `align-highlight-rule'." t nil)
;;;***
\f
;;;### (autoloads (ange-ftp-hook-function ange-ftp-reread-dir) "ange-ftp"
-;;;;;; "ange-ftp.el" (14203 50169))
-;;; Generated autoloads from ange-ftp.el
+;;;;;; "net/ange-ftp.el" (14619 61800))
+;;; Generated autoloads from net/ange-ftp.el
(defalias 'ange-ftp-re-read-dir 'ange-ftp-reread-dir)
(autoload (quote ange-ftp-reread-dir) "ange-ftp" "\
;;;***
\f
+;;;### (autoloads (antlr-set-tabs antlr-mode) "antlr-mode" "progmodes/antlr-mode.el"
+;;;;;; (14431 34774))
+;;; Generated autoloads from progmodes/antlr-mode.el
+
+(autoload (quote antlr-mode) "antlr-mode" "\
+Major mode for editing ANTLR grammar files.
+\\{antlr-mode-map}" t nil)
+
+(autoload (quote antlr-set-tabs) "antlr-mode" "\
+Use ANTLR's convention for TABs according to `antlr-tab-offset-alist'.
+Used in `antlr-mode'. Also a useful function in `java-mode-hook'." nil nil)
+
+;;;***
+\f
;;;### (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" (14063 14962))
+;;;;;; "appt" "calendar/appt.el" (14563 8413))
;;; 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" "apropos.el" (13940 33135))
+;;;;;; apropos-variable apropos-mode) "apropos" "apropos.el" (14617
+;;;;;; 51641))
;;; Generated autoloads from apropos.el
+(autoload (quote apropos-mode) "apropos" "\
+Major mode for following hyperlinks in output of apropos commands.
+
+\\{apropos-mode-map}" t nil)
+
(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
;;;***
\f
-;;;### (autoloads (archive-mode) "arc-mode" "arc-mode.el" (14033
-;;;;;; 32154))
+;;;### (autoloads (archive-mode) "arc-mode" "arc-mode.el" (14539
+;;;;;; 44524))
;;; Generated autoloads from arc-mode.el
(autoload (quote archive-mode) "arc-mode" "\
;;;***
\f
-;;;### (autoloads (array-mode) "array" "array.el" (13623 48741))
+;;;### (autoloads (array-mode) "array" "array.el" (14460 38616))
;;; Generated autoloads from array.el
(autoload (quote array-mode) "array" "\
considered to be a two-dimensional set of strings. The strings are
NOT recognized as integers or real numbers.
- The array MUST reside at the top of the buffer.
+ The array MUST reside at the top of the buffer.
TABs are not respected, and may be converted into spaces at any time.
-Setting the variable 'respect-tabs to non-nil will prevent TAB conversion,
+Setting the variable 'array-respect-tabs to non-nil will prevent TAB conversion,
but will cause many functions to give errors if they encounter one.
Upon entering array mode, you will be prompted for the values of
The variables are:
Variables you assign:
- max-row: The number of rows in the array.
- max-column: The number of columns in the array.
- columns-per-line: The number of columns in the array per line of buffer.
- field-width: The width of each field, in characters.
- rows-numbered: A logical variable describing whether to ignore
+ array-max-row: The number of rows in the array.
+ array-max-column: The number of columns in the array.
+ array-columns-per-line: The number of columns in the array per line of buffer.
+ array-field-width: The width of each field, in characters.
+ array-rows-numbered: A logical variable describing whether to ignore
row numbers in the buffer.
Variables which are calculated:
- line-length: The number of characters in a buffer line.
- lines-per-row: The number of buffer lines used to display each row.
+ array-line-length: The number of characters in a buffer line.
+ array-lines-per-row: The number of buffer lines used to display each row.
The following commands are available (an asterisk indicates it may
take a numeric prefix argument):
;;;***
\f
-;;;### (autoloads (asm-mode) "asm-mode" "progmodes/asm-mode.el" (13833
-;;;;;; 34413))
+;;;### (autoloads (asm-mode) "asm-mode" "progmodes/asm-mode.el" (14286
+;;;;;; 393))
;;; Generated autoloads from progmodes/asm-mode.el
(autoload (quote asm-mode) "asm-mode" "\
;;;***
\f
;;;### (autoloads (auto-show-mode auto-show-mode) "auto-show" "auto-show.el"
-;;;;;; (14201 235))
+;;;;;; (14516 149))
;;; Generated autoloads from auto-show.el
(defvar auto-show-mode nil "\
-Non-nil means do automatic horizontal scrolling, when lines are truncated.
+Obsolete.")
-This variable is automatically local in each buffer where it is set.
+(autoload (quote auto-show-mode) "auto-show" "\
+This command is obsolete." t nil)
-Setting this variable directly does not take effect;
-use either \\[customize] or the function `auto-show-mode'.")
+;;;***
+\f
+;;;### (autoloads (autoarg-mode autoarg-mode) "autoarg" "autoarg.el"
+;;;;;; (14622 51307))
+;;; Generated autoloads from autoarg.el
-(custom-add-to-group (quote auto-show) (quote auto-show-mode) (quote custom-variable))
+(defvar autoarg-mode nil "\
+Toggle Autoarg mode.
-(custom-add-load (quote auto-show-mode) (quote auto-show))
+You must modify via \\[customize] for this variable to have an effect.")
-(autoload (quote auto-show-mode) "auto-show" "\
-Turn automatic horizontal scroll mode on or off.
-With arg, turn auto scrolling on if arg is positive, off otherwise.
-This mode is enabled or disabled for each buffer individually.
-It takes effect only when `truncate-lines' is non-nil." t nil)
+(custom-add-to-group (quote editing) (quote autoarg-mode) (quote custom-variable))
+
+(custom-add-load (quote autoarg-mode) (quote autoarg))
+
+(autoload (quote autoarg-mode) "autoarg" "\
+Toggle Autoarg mode 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)
+
+;;;***
+\f
+;;;### (autoloads (autoconf-mode) "autoconf" "progmodes/autoconf.el"
+;;;;;; (14532 61420))
+;;; Generated autoloads from progmodes/autoconf.el
+
+(autoload (quote autoconf-mode) "autoconf" "\
+Major mode for editing Autoconf configure.in files." t nil)
;;;***
\f
;;;### (autoloads (auto-insert-mode define-auto-insert auto-insert)
-;;;;;; "autoinsert" "autoinsert.el" (14118 1735))
+;;;;;; "autoinsert" "autoinsert.el" (14410 18534))
;;; Generated autoloads from autoinsert.el
(autoload (quote auto-insert) "autoinsert" "\
or if CONDITION had no actions, after all other CONDITIONs." nil nil)
(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.
-Returns the new status of auto-insert mode (non-nil means on).
+Toggle Auto-insert mode.
+With prefix ARG, turn Auto-insert mode on if and only if ARG is positive.
+Returns the new status of Auto-insert mode (non-nil means on).
-When auto-insert mode is enabled, when new files are created you can
+When Auto-insert mode is enabled, when new files are created you can
insert a template for the file depending on the mode of the buffer." t nil)
;;;***
\f
;;;### (autoloads (batch-update-autoloads update-autoloads-from-directories
;;;;;; update-file-autoloads) "autoload" "emacs-lisp/autoload.el"
-;;;;;; (14198 40228))
+;;;;;; (14563 8438))
;;; 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) "autorevert" "autorevert.el" (13691 6971))
+;;;;;; auto-revert-mode global-auto-revert-mode) "autorevert" "autorevert.el"
+;;;;;; (14495 17959))
;;; Generated autoloads from autorevert.el
+(defvar auto-revert-mode nil "\
+*Non-nil when Auto-Revert Mode is active.
+
+Never set this variable directly, use the command `auto-revert-mode'
+instead.")
+
+(defvar global-auto-revert-mode nil "\
+When on, buffers are automatically reverted when files on disk change.
+
+Set this variable using \\[customize] only. Otherwise, use the
+command `global-auto-revert-mode'.")
+
+(custom-add-to-group (quote auto-revert) (quote global-auto-revert-mode) (quote custom-variable))
+
+(custom-add-load (quote global-auto-revert-mode) (quote autorevert))
+
(autoload (quote auto-revert-mode) "autorevert" "\
Toggle reverting buffer when file on disk changes.
;;;***
\f
-;;;### (autoloads (mouse-avoidance-mode) "avoid" "avoid.el" (14118
-;;;;;; 1851))
+;;;### (autoloads (mouse-avoidance-mode mouse-avoidance-mode) "avoid"
+;;;;;; "avoid.el" (14539 53646))
;;; Generated autoloads from avoid.el
+(defvar mouse-avoidance-mode nil "\
+Activate mouse avoidance mode.
+See function `mouse-avoidance-mode' for possible values.
+Setting this variable directly does not take effect;
+use either \\[customize] or the function `mouse-avoidance-mode'.")
+
+(custom-add-to-group (quote avoid) (quote mouse-avoidance-mode) (quote custom-variable))
+
+(custom-add-load (quote mouse-avoidance-mode) (quote avoid))
+
(autoload (quote mouse-avoidance-mode) "avoid" "\
Set cursor avoidance mode to MODE.
MODE should be one of the symbols `banish', `exile', `jump', `animate',
;;;***
\f
-;;;### (autoloads (awk-mode) "awk-mode" "progmodes/awk-mode.el" (13549
-;;;;;; 38922))
+;;;### (autoloads (awk-mode) "awk-mode" "progmodes/awk-mode.el" (14546
+;;;;;; 45178))
;;; Generated autoloads from progmodes/awk-mode.el
(autoload (quote awk-mode) "awk-mode" "\
;;;***
\f
;;;### (autoloads (backquote) "backquote" "emacs-lisp/backquote.el"
-;;;;;; (13607 51085))
+;;;;;; (14455 30228))
;;; Generated autoloads from emacs-lisp/backquote.el
(autoload (quote backquote) "backquote" "\
;;;***
\f
;;;### (autoloads (display-battery battery) "battery" "battery.el"
-;;;;;; (13599 8260))
+;;;;;; (14422 6418))
;;; Generated autoloads from battery.el
(autoload (quote battery) "battery" "\
Display battery status information in the echo area.
-The text beeing displayed in the echo area is controlled by the variables
+The text being displayed in the echo area is controlled by the variables
`battery-echo-area-format' and `battery-status-function'." t nil)
(autoload (quote display-battery) "battery" "\
;;;***
\f
-;;;### (autoloads (bibtex-mode) "bibtex" "textmodes/bibtex.el" (14198
-;;;;;; 46296))
+;;;### (autoloads (bibtex-mode) "bibtex" "textmodes/bibtex.el" (14504
+;;;;;; 9460))
;;; Generated autoloads from textmodes/bibtex.el
(autoload (quote bibtex-mode) "bibtex" "\
bibtex-ispell-abstract
bibtex-ispell-entry
bibtex-narrow-to-entry
- bibtex-hide-entry-bodies
bibtex-sort-buffer
bibtex-validate
bibtex-count
;;;***
\f
;;;### (autoloads (blackbox) "blackbox" "play/blackbox.el" (13229
-;;;;;; 27943))
+;;;;;; 27947))
;;; Generated autoloads from play/blackbox.el
(autoload (quote blackbox) "blackbox" "\
;;;;;; bookmark-load bookmark-save bookmark-write bookmark-delete
;;;;;; bookmark-insert bookmark-rename bookmark-insert-location
;;;;;; bookmark-relocate bookmark-jump bookmark-set) "bookmark"
-;;;;;; "bookmark.el" (14143 29124))
+;;;;;; "bookmark.el" (14531 42950))
;;; Generated autoloads from bookmark.el
(define-key ctl-x-map "rb" 'bookmark-jump)
(define-key ctl-x-map "rm" 'bookmark-set)
;;;;;; 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" "browse-url.el"
-;;;;;; (14124 22133))
-;;; Generated autoloads from browse-url.el
+;;;;;; browse-url-browser-function) "browse-url" "net/browse-url.el"
+;;;;;; (14558 23455))
+;;; 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)) "\
*Function to display the current buffer in a WWW browser.
;;;***
\f
;;;### (autoloads (snarf-bruces bruce) "bruce" "play/bruce.el" (13607
-;;;;;; 42463))
+;;;;;; 42538))
;;; Generated autoloads from play/bruce.el
(autoload (quote bruce) "bruce" "\
;;;***
\f
+;;;### (autoloads (bs-show bs-customize bs-cycle-previous bs-cycle-next)
+;;;;;; "bs" "bs.el" (14495 17961))
+;;; Generated autoloads from bs.el
+
+(autoload (quote bs-cycle-next) "bs" "\
+Select next buffer defined by buffer cycling.
+The buffers taking part in buffer cycling are defined
+by buffer configuration `bs-cycle-configuration-name'." t nil)
+
+(autoload (quote bs-cycle-previous) "bs" "\
+Select previous buffer defined by buffer cycling.
+The buffers taking part in buffer cycling are defined
+by buffer configuration `bs-cycle-configuration-name'." t nil)
+
+(autoload (quote bs-customize) "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.
+\\<bs-mode-map>
+There are many key commands similar to `Buffer-menu-mode' for
+manipulating buffer list and buffers itself.
+User can move with [up] or [down], select a buffer
+by \\[bs-select] or [SPC]
+
+Type \\[bs-kill] to leave Buffer Selection Menu without a selection.
+Type \\[bs-help] after invocation to get help on commands available.
+With prefix argument ARG show a different buffer list. Function
+`bs--configuration-name-for-prefix-arg' determine accordingly
+name of buffer configuration." t nil)
+
+;;;***
+\f
;;;### (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" (14090 25925))
+;;;;;; "emacs-lisp/bytecomp.el" (14564 35790))
;;; Generated autoloads from emacs-lisp/bytecomp.el
(autoload (quote byte-force-recompile) "bytecomp" "\
;;;***
\f
;;;### (autoloads (list-yahrzeit-dates) "cal-hebrew" "calendar/cal-hebrew.el"
-;;;;;; (13997 6380))
+;;;;;; (13997 6729))
;;; Generated autoloads from calendar/cal-hebrew.el
(autoload (quote list-yahrzeit-dates) "cal-hebrew" "\
;;;***
\f
+;;;### (autoloads (calculator) "calculator" "calculator.el" (14511
+;;;;;; 60346))
+;;; Generated autoloads from calculator.el
+
+(autoload (quote calculator) "calculator" "\
+Run the pocket calculator.
+See the documentation for `calculator-mode' for more information." t nil)
+
+;;;***
+\f
;;;### (autoloads (calendar solar-holidays islamic-holidays christian-holidays
;;;;;; hebrew-holidays other-holidays local-holidays oriental-holidays
;;;;;; general-holidays holidays-in-diary-buffer diary-list-include-blanks
;;;;;; european-date-diary-pattern american-date-diary-pattern european-calendar-style
;;;;;; abbreviated-calendar-year sexp-diary-entry-symbol diary-include-string
;;;;;; islamic-diary-entry-symbol hebrew-diary-entry-symbol diary-nonmarking-symbol
-;;;;;; diary-file today-invisible-calendar-hook today-visible-calendar-hook
-;;;;;; initial-calendar-window-hook calendar-load-hook all-islamic-calendar-holidays
-;;;;;; all-christian-calendar-holidays all-hebrew-calendar-holidays
-;;;;;; mark-holidays-in-calendar view-calendar-holidays-initially
-;;;;;; mark-diary-entries-in-calendar number-of-diary-entries view-diary-entries-initially
-;;;;;; calendar-offset calendar-week-start-day) "calendar" "calendar/calendar.el"
-;;;;;; (14198 38416))
+;;;;;; diary-file calendar-move-hook today-invisible-calendar-hook
+;;;;;; today-visible-calendar-hook initial-calendar-window-hook
+;;;;;; calendar-load-hook all-islamic-calendar-holidays all-christian-calendar-holidays
+;;;;;; all-hebrew-calendar-holidays mark-holidays-in-calendar view-calendar-holidays-initially
+;;;;;; 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))
;;; Generated autoloads from calendar/calendar.el
(defvar calendar-week-start-day 0 "\
*Non-nil means mark dates with diary entries, in the calendar window.
The marking symbol is specified by the variable `diary-entry-marker'.")
+(defvar calendar-remove-frame-by-deleting nil "\
+*Determine how the calendar mode removes a frame no longer needed.
+If nil, make an icon of the frame. If non-nil, delete the frame.")
+
(defvar view-calendar-holidays-initially nil "\
*Non-nil means display holidays for current three month period on entry.
The holidays are displayed in another window when the calendar is first
characters in the calendar buffer by the hooks may cause the failure of the
functions that move by days and weeks.")
+(defvar calendar-move-hook nil "\
+*List of functions called whenever the cursor moves in the calendar.
+
+For example,
+
+ (add-hook 'calendar-move-hook (lambda () (view-diary-entries 1)))
+
+redisplays the diary for whatever date the cursor is moved to.")
+
(defvar diary-file "~/diary" "\
*Name of the file in which one's personal diary of dates is kept.
*List of pseudo-patterns describing the American patterns of date used.
See the documentation of `diary-date-forms' for an explanation.")
-(defvar european-date-diary-pattern (quote ((day "/" month "[^/0-9]") (day "/" month "/" year "[^0-9]") (backup day " *" monthname "\\W+\\<[^*0-9]") (day " *" monthname " *" year "[^0-9]") (dayname "\\W"))) "\
+(defvar european-date-diary-pattern (quote ((day "/" month "[^/0-9]") (day "/" month "/" year "[^0-9]") (backup day " *" monthname "\\W+\\<\\([^*0-9]\\|\\([0-9]+[:aApP]\\)\\)") (day " *" monthname " *" year "[^0-9]") (dayname "\\W"))) "\
*List of pseudo-patterns describing the European patterns of date used.
See the documentation of `diary-date-forms' for an explanation.")
;;;***
\f
-;;;### (autoloads nil "cc-langs" "progmodes/cc-langs.el" (13932 14133))
+;;;### (autoloads nil "cc-langs" "progmodes/cc-langs.el" (14419 57707))
;;; 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"
-;;;;;; (13932 14133))
+;;;;;; (14419 57707))
;;; 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" (13932 14133))
+;;;;;; "progmodes/cc-styles.el" (14419 57707))
;;; Generated autoloads from progmodes/cc-styles.el
(autoload (quote c-set-style) "cc-styles" "\
for details of setting up styles.
The variable `c-indentation-style' always contains the buffer's current
-style name." t nil)
+style name.
+
+If the optional argument DONT-OVERRIDE is non-nil, no style variables
+that already have values will be overridden. I.e. in the case of
+`c-offsets-alist', syntactic symbols will only be added, and in the
+case of all other style variables, only those set to `set-from-style'
+will be reassigned.
+
+Obviously, specifying DONT-OVERRIDE is useful mainly when the initial
+style is chosen for a CC Mode buffer by a major mode. Since this is
+done internally by CC Mode, there's hardly ever a reason to use it." t nil)
(autoload (quote c-add-style) "cc-styles" "\
Adds a style to `c-style-alist', or updates an existing one.
(autoload (quote c-set-offset) "cc-styles" "\
Change the value of a syntactic element symbol in `c-offsets-alist'.
SYMBOL is the syntactic element symbol to change and OFFSET is the new
-offset for that syntactic element. Optional ADD says to add SYMBOL to
-`c-offsets-alist' if it doesn't already appear there." t nil)
+offset for that syntactic element. The optional argument is not used
+and exists only for compatibility reasons." t nil)
;;;***
\f
-;;;### (autoloads nil "cc-vars" "progmodes/cc-vars.el" (13932 14133))
+;;;### (autoloads nil "cc-vars" "progmodes/cc-vars.el" (14419 57707))
;;; 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))) "\
features supporting those needed by CC Mode. Here's the current
supported list, along with the values for this variable:
- XEmacs 19: (8-bit)
- XEmacs 20: (8-bit)
- Emacs 19: (1-bit)
+ XEmacs 19, 20, 21: (8-bit)
+ Emacs 19, 20: (1-bit)
Infodock (based on XEmacs) has an additional symbol on this list:
`infodock'.")
\f
;;;### (autoloads (ccl-execute-with-args check-ccl-program define-ccl-program
;;;;;; declare-ccl-program ccl-dump ccl-compile) "ccl" "international/ccl.el"
-;;;;;; (14236 17288))
+;;;;;; (14543 61454))
;;; Generated autoloads from international/ccl.el
(autoload (quote ccl-compile) "ccl" "\
;;;;;; checkdoc-continue checkdoc-start checkdoc-current-buffer
;;;;;; checkdoc-eval-current-buffer checkdoc-message-interactive
;;;;;; checkdoc-interactive checkdoc) "checkdoc" "emacs-lisp/checkdoc.el"
-;;;;;; (13847 27399))
+;;;;;; (14482 54417))
;;; Generated autoloads from emacs-lisp/checkdoc.el
(autoload (quote checkdoc) "checkdoc" "\
;;;***
\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 36670))
+;;;;;; 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-mode list-command-history repeat-matching-complex-command)
-;;;;;; "chistory" "chistory.el" (13569 33539))
+;;;### (autoloads (command-history list-command-history repeat-matching-complex-command)
+;;;;;; "chistory" "chistory.el" (14447 15307))
;;; Generated autoloads from chistory.el
(autoload (quote repeat-matching-complex-command) "chistory" "\
The buffer is left in Command History mode." t nil)
-(autoload (quote command-history-mode) "chistory" "\
-Major mode for examining commands from `command-history'.
+(autoload (quote command-history) "chistory" "\
+Examine commands from `command-history' in a buffer.
The number of commands listed is controlled by `list-command-history-max'.
The command history is filtered by `list-command-history-filter' if non-nil.
Use \\<command-history-map>\\[command-history-repeat] to repeat the command on the current line.
Otherwise much like Emacs-Lisp Mode except that there is no self-insertion
and digits provide prefix arguments. Tab does not indent.
\\{command-history-map}
-Calls the value of `command-history-hook' if that is non-nil.
-The Command History listing is recomputed each time this mode is invoked." t nil)
+
+This command always recompiles the Command History listing
+and runs the normal hook `command-history-hook'." t nil)
;;;***
\f
-;;;### (autoloads nil "cl" "emacs-lisp/cl.el" (14160 15534))
+;;;### (autoloads nil "cl" "emacs-lisp/cl.el" (14617 51703))
;;; 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"
-;;;;;; (13903 50959))
+;;;;;; (14518 39681))
;;; 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"
-;;;;;; (13661 53315))
+;;;;;; (14368 26241))
;;; Generated autoloads from progmodes/cmacexp.el
(autoload (quote c-macro-expand) "cmacexp" "\
;;;***
\f
-;;;### (autoloads (run-scheme) "cmuscheme" "cmuscheme.el" (13569
-;;;;;; 33926))
+;;;### (autoloads (run-scheme) "cmuscheme" "cmuscheme.el" (14535
+;;;;;; 44845))
;;; Generated autoloads from cmuscheme.el
(autoload (quote run-scheme) "cmuscheme" "\
\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 7952))
+;;;;;; "codepage" "international/codepage.el" (14124 8038))
;;; Generated autoloads from international/codepage.el
(autoload (quote cp-make-coding-systems-for-codepage) "codepage" "\
;;;***
\f
-;;;### (autoloads (comint-run make-comint) "comint" "comint.el" (14198
-;;;;;; 39428))
+;;;### (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" (14619 5053))
;;; Generated autoloads from comint.el
(autoload (quote make-comint) "comint" "\
hooks on this symbol are run in the buffer.
See `make-comint' and `comint-exec'." t nil)
+(autoload (quote comint-redirect-send-command) "comint" "\
+Send COMMAND to process in current buffer, with output to OUTPUT-BUFFER.
+With prefix arg, echo output in process buffer.
+
+If NO-DISPLAY is non-nil, do not show the output buffer." t nil)
+
+(autoload (quote comint-redirect-send-command-to-process) "comint" "\
+Send COMMAND to PROCESS, with output to OUTPUT-BUFFER.
+With prefix arg, echo output in process buffer.
+
+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.
+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.
+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
-;;;;;; 17934))
+;;;;;; 18289))
;;; 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" (14198 39593))
+;;;;;; "compile" "progmodes/compile.el" (14569 2479))
;;; Generated autoloads from progmodes/compile.el
(defvar compilation-mode-hook nil "\
and a string describing how the process finished.")
(defvar compilation-ask-about-save t "\
-*If not nil, M-x compile asks which buffers to save before compiling.
+*Non-nil means \\[compile] asks which buffers to save before compiling.
Otherwise, it saves all modified buffers without asking.")
(defvar compilation-search-path (quote (nil)) "\
if that history list is empty)." t nil)
(autoload (quote grep-find) "compile" "\
-Run grep via find, with user-specified args, and collect output in a buffer.
+Run grep via find, with user-specified args COMMAND-ARGS.
+Collect output in a buffer.
While find runs asynchronously, you can use the \\[next-error] command
to find the text that grep hits refer to.
;;;***
\f
;;;### (autoloads (partial-completion-mode) "complete" "complete.el"
-;;;;;; (14115 62109))
+;;;;;; (14393 17619))
;;; Generated autoloads from complete.el
(autoload (quote partial-completion-mode) "complete" "\
;;;***
\f
;;;### (autoloads (dynamic-completion-mode) "completion" "completion.el"
-;;;;;; (13876 49580))
+;;;;;; (14495 17962))
;;; Generated autoloads from completion.el
(autoload (quote dynamic-completion-mode) "completion" "\
;;;***
\f
+;;;### (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))
+;;; 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))) "\
+Alist of symbols vs integer codes of glyph reference points.
+A glyph reference point symbol is to be used to specify a composition
+rule in COMPONENTS argument to such functions as `compose-region' and
+`make-composition'.
+
+Meanings of glyph reference point codes are as follows:
+
+ 0----1----2 <---- ascent 0:tl or top-left
+ | | 1:tc or top-center
+ | | 2:tr or top-right
+ | | 3:Bl or base-left 9:cl or center-left
+ 9 10 11 <---- center 4:Bc or base-center 10:cc or center-center
+ | | 5:Br or base-right 11:cr or center-right
+ --3----4----5-- <-- baseline 6:bl or bottom-left
+ | | 7:bc or bottom-center
+ 6----7----8 <---- descent 8:br or bottom-right
+
+Glyph reference point symbols are to be used to specify composition
+rule of the form (GLOBAL-REF-POINT . NEW-REF-POINT), where
+GLOBAL-REF-POINT is a reference point in the overall glyphs already
+composed, and NEW-REF-POINT is a reference point in the new glyph to
+be added.
+
+For instance, if GLOBAL-REF-POINT is `br' (bottom-right) and
+NEW-REF-POINT is `tl' (top-left), the overall glyph is updated as
+follows (the point `*' corresponds to both reference points):
+
+ +-------+--+ <--- new ascent
+ | | |
+ | global| |
+ | glyph | |
+ -- | | |-- <--- baseline (doesn't change)
+ +----+--*--+
+ | | new |
+ | |glyph|
+ +----+-----+ <--- new descent
+")
+
+(autoload (quote compose-region) "composite" "\
+Compose characters in the current region.
+
+When called from a program, expects these four arguments.
+
+First two arguments START and END are positions (integers or markers)
+specifying the region.
+
+Optional 3rd argument COMPONENTS, if non-nil, is a character or a
+sequence (vector, list, or string) of integers.
+
+If it is a character, it is an alternate character to display instead
+of the text in the region.
+
+If it is a string, the elements are alternate characters.
+
+If it is a vector or list, it is a sequence of alternate characters and
+composition rules, where (2N)th elements are characters and (2N+1)th
+elements are composition rules to specify how to compose (2N+2)th
+elements with previously composed N glyphs.
+
+A composition rule is a cons of global and new glyph reference point
+symbols. See the documentation of `reference-point-alist' for more
+detail.
+
+Optional 4th argument MODIFICATION-FUNC is a function to call to
+adjust the composition when it gets invalid because of a change of
+text in the composition." t nil)
+
+(autoload (quote decompose-region) "composite" "\
+Decompose text in the current region.
+
+When called from a program, expects two arguments,
+positions (integers or markers) specifying the region." t nil)
+
+(autoload (quote compose-string) "composite" "\
+Compose characters in string STRING.
+
+The return value is STRING where `composition' property is put on all
+the characters in it.
+
+Optional 2nd and 3rd arguments START and END specify the range of
+STRING to be composed. They defaults to the beginning and the end of
+STRING respectively.
+
+Optional 4th argument COMPONENTS, if non-nil, is a character or a
+sequence (vector, list, or string) of integers. See the function
+`compose-region' for more detail.
+
+Optional 5th argument MODIFICATION-FUNC is a function to call to
+adjust the composition when it gets invalid because of a change of
+text in the composition." nil nil)
+
+(autoload (quote decompose-string) "composite" "\
+Return STRING where `composition' property is removed." nil nil)
+
+(autoload (quote compose-chars) "composite" "\
+Return a string from arguments in which all characters are composed.
+For relative composition, arguments are characters.
+For rule-based composition, Mth (where M is odd) arguments are
+characters, and Nth (where N is even) arguments are composition rules.
+A composition rule is a cons of glyph reference points of the form
+\(GLOBAL-REF-POINT . NEW-REF-POINT). See the documentation of
+`reference-point-alist' for more detail." nil nil)
+
+(autoload (quote find-composition) "composite" "\
+Return information about a composition at or nearest to buffer position POS.
+
+If the character at POS has `composition' property, the value is a list
+of FROM, TO, and VALID-P.
+
+FROM and TO specify the range of text that has the same `composition'
+property, VALID-P is non-nil if and only if this composition is valid.
+
+If there's no composition at POS, and the optional 2nd argument LIMIT
+is non-nil, search for a composition toward LIMIT.
+
+If no composition is found, return nil.
+
+Optional 3rd argument STRING, if non-nil, is a string to look for a
+composition in; nil means the current buffer.
+
+If a valid composition is found and the optional 4th argument DETAIL-P
+is non-nil, the return value is a list of FROM, TO, COMPONENTS,
+RELATIVE-P, MOD-FUNC, and WIDTH.
+
+COMPONENTS is a vector of integers, the meaning depends on RELATIVE-P.
+
+RELATIVE-P is t if the composition method is relative, else nil.
+
+If RELATIVE-P is t, COMPONENTS is a vector of characters to be
+composed. If RELATIVE-P is nil, COMPONENTS is a vector of characters
+and composition rules as described in `compose-region'.
+
+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.
+
+It looks up the char-table `composition-function-table' (which see) by
+a character after POS. If non-nil value is found, the format of the
+value should be an alist of PATTERNs vs FUNCs, where PATTERNs are
+regular expressions and FUNCs are functions. If the text after POS
+matches one of PATTERNs, call the corresponding FUNC with three
+arguments POS, TO, and PATTERN, where TO is the end position of text
+matching PATTERN, and return what FUNC returns. Otherwise, return
+nil.
+
+FUNC is responsible for composing the text properly. The return value
+is:
+ nil -- if no characters were composed.
+ CHARS (integer) -- if CHARS characters were composed.
+
+Optional 2nd arg LIMIT, if non-nil, limits the matching of text.
+
+This function is the default value of `compose-chars-after-function'." nil nil)
+
+(autoload (quote compose-last-chars) "composite" "\
+Compose last characters.
+The argument is a parameterized event of the form (compose-last-chars N),
+where N is the number of characters before point to compose.
+This function is intended to be used from input methods.
+The global keymap binds special event `compose-last-chars' to this
+function. Input method may generate an event (compose-last-chars N)
+after a sequence character events." t nil)
+(global-set-key [compose-last-chars] 'compose-last-chars)
+
+(autoload (quote decompose-composite-char) "composite" "\
+Convert CHAR to string.
+This is only for backward compatibility with Emacs 20.4 and the earlier.
+
+If optional 2nd arg TYPE is non-nil, it is `string', `list', or
+`vector'. In this case, CHAR is converted string, list of CHAR, or
+vector of CHAR respectively." nil nil)
+
+;;;***
+\f
;;;### (autoloads (shuffle-vector cookie-snarf cookie-insert cookie)
-;;;;;; "cookie1" "play/cookie1.el" (13538 26297))
+;;;;;; "cookie1" "play/cookie1.el" (13538 26685))
;;; Generated autoloads from play/cookie1.el
(autoload (quote cookie) "cookie1" "\
;;;***
\f
;;;### (autoloads (copyright copyright-update) "copyright" "emacs-lisp/copyright.el"
-;;;;;; (13940 33273))
+;;;;;; (14463 42213))
;;; Generated autoloads from emacs-lisp/copyright.el
(autoload (quote copyright-update) "copyright" "\
;;;***
\f
;;;### (autoloads (cperl-mode) "cperl-mode" "progmodes/cperl-mode.el"
-;;;;;; (14177 62783))
+;;;;;; (14456 48530))
;;; Generated autoloads from progmodes/cperl-mode.el
(autoload (quote cperl-mode) "cperl-mode" "\
;;;***
\f
;;;### (autoloads (cpp-parse-edit cpp-highlight-buffer) "cpp" "progmodes/cpp.el"
-;;;;;; (13826 9909))
+;;;;;; (14568 36509))
;;; Generated autoloads from progmodes/cpp.el
(autoload (quote cpp-highlight-buffer) "cpp" "\
;;;***
\f
;;;### (autoloads (crisp-mode crisp-mode) "crisp" "emulation/crisp.el"
-;;;;;; (14179 6457))
+;;;;;; (14302 38178))
;;; Generated autoloads from emulation/crisp.el
(defvar crisp-mode nil "\
;;;***
\f
+;;;### (autoloads (completing-read-multiple) "crm" "emacs-lisp/crm.el"
+;;;;;; (14600 8203))
+;;; 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-save-customized custom-file customize-browse custom-buffer-create-other-window
;;;;;; custom-buffer-create customize-apropos-groups customize-apropos-faces
;;;;;; 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"
-;;;;;; (14092 56283))
+;;;;;; (14599 11147))
;;; Generated autoloads from cus-edit.el
(add-hook 'same-window-regexps "\\`\\*Customiz.*\\*\\'")
it were the arg to `interactive' (which see) to interactively read the value.
If VARIABLE has a `custom-type' property, it must be a widget and the
-`:prompt-value' property of that widget will be used for reading the value." t nil)
+`:prompt-value' property of that widget will be used for reading the value.
+
+If given a prefix (or a COMMENT argument), also prompt for a comment." t nil)
(autoload (quote customize-set-variable) "cus-edit" "\
Set the default for VARIABLE to VALUE. VALUE is a Lisp object.
it were the arg to `interactive' (which see) to interactively read the value.
If VARIABLE has a `custom-type' property, it must be a widget and the
-`:prompt-value' property of that widget will be used for reading the value. " t nil)
+`:prompt-value' property of that widget will be used for reading the value.
+
+If given a prefix (or a COMMENT argument), also prompt for a comment." t nil)
(autoload (quote customize-save-variable) "cus-edit" "\
Set the default for VARIABLE to VALUE, and save it for future sessions.
it were the arg to `interactive' (which see) to interactively read the value.
If VARIABLE has a `custom-type' property, it must be a widget and the
-`:prompt-value' property of that widget will be used for reading the value. " t nil)
+`:prompt-value' property of that widget will be used for reading the value.
+
+If given a prefix (or a COMMENT argument), also prompt for a comment." t nil)
(autoload (quote customize) "cus-edit" "\
Select a customization buffer which you can use to set user options.
If SYMBOL is nil, customize all faces." t nil)
(autoload (quote customize-face-other-window) "cus-edit" "\
-Show customization buffer for FACE in other window." t nil)
+Show customization buffer for face SYMBOL in other window." t nil)
(autoload (quote customize-customized) "cus-edit" "\
Customize all user options set since the last save in this session." t nil)
File used for storing customization information.
The default is nil, which means to use your init file
as specified by `user-init-file'. If you specify some other file,
-you need to explicitly load that file for the settings to take effect.")
+you need to explicitly load that file for the settings to take effect.
+
+When you change this variable, look in the previous custom file
+\(usually your init file) for the forms `(custom-set-variables ...)'
+and `(custom-set-faces ...)', and copy them (whichever ones you find)
+to the new custom file. This will preserve your existing customizations.")
(autoload (quote customize-save-customized) "cus-edit" "\
Save all user options which have been set in this session." t nil)
(autoload (quote customize-menu-create) "cus-edit" "\
Return a customize menu for customization group SYMBOL.
-If optional NAME is given, use that as the name of the menu.
+If optional NAME is given, use that as the name of the menu.
Otherwise the menu will be named `Customize'.
The format is suitable for use with `easy-menu-define'." nil nil)
;;;***
\f
;;;### (autoloads (custom-set-faces custom-declare-face) "cus-face"
-;;;;;; "cus-face.el" (14228 23896))
+;;;;;; "cus-face.el" (14505 58892))
;;; Generated autoloads from cus-face.el
(autoload (quote custom-declare-face) "cus-face" "\
Initialize faces according to user preferences.
The arguments should be a list where each entry has the form:
- (FACE SPEC [NOW])
+ (FACE SPEC [NOW [COMMENT]])
SPEC is stored as the saved value for FACE.
If NOW is present and non-nil, FACE is created now, according to SPEC.
+COMMENT is a string comment about FACE.
See `defface' for the format of SPEC." nil nil)
;;;***
\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 36671))
-;;; Generated autoloads from language/cyril-util.el
+;;;### (autoloads (cvs-status-mode) "cvs-status" "cvs-status.el"
+;;;;;; (14619 3306))
+;;; Generated autoloads from cvs-status.el
+
+(autoload (quote cvs-status-mode) "cvs-status" "\
+Mode used for cvs status output." t nil)
+
+;;;***
+\f
+;;;### (autoloads (global-cwarn-mode turn-on-cwarn-mode cwarn-mode)
+;;;;;; "cwarn" "progmodes/cwarn.el" (14431 15379))
+;;; Generated autoloads from progmodes/cwarn.el
+
+(autoload (quote cwarn-mode) "cwarn" "\
+Minor mode that hightlight 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
+C++ modes are included.
+
+With ARG, turn CWarn mode on if and only if arg is positive." t nil)
-(autoload (quote setup-cyrillic-iso-environment) "cyril-util" "\
-Setup multilingual environment (MULE) for Cyrillic ISO-8859-5 users." t nil)
+(autoload (quote turn-on-cwarn-mode) "cwarn" "\
+Turn on CWarn mode.
-(autoload (quote setup-cyrillic-koi8-environment) "cyril-util" "\
-Setup multilingual environment (MULE) for Cyrillic KOI8 users." t nil)
+This function is designed to be added to hooks, for example:
+ (add-hook 'c-mode-hook 'turn-on-cwarn-mode)" nil nil)
+
+(autoload (quote global-cwarn-mode) "cwarn" "\
+Hightlight suspicious C and C++ constructions in all buffers.
-(autoload (quote setup-cyrillic-alternativnyj-environment) "cyril-util" "\
-Setup multilingual environment (MULE) for Cyrillic ALTERNATIVNYJ users." t nil)
+With ARG, turn CWarn mode on globally if and only if arg is positive." t nil)
+
+;;;***
+\f
+;;;### (autoloads (standard-display-cyrillic-translit cyrillic-encode-alternativnyj-char
+;;;;;; cyrillic-encode-koi8-r-char) "cyril-util" "language/cyril-util.el"
+;;;;;; (14623 45987))
+;;; Generated autoloads from language/cyril-util.el
(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"
-;;;;;; (13833 28318))
+;;;;;; (14568 46430))
;;; Generated autoloads from dabbrev.el
(define-key esc-map "/" (quote dabbrev-expand))
;;;***
\f
;;;### (autoloads (dcl-mode) "dcl-mode" "progmodes/dcl-mode.el" (13706
-;;;;;; 39004))
+;;;;;; 38927))
;;; Generated autoloads from progmodes/dcl-mode.el
(autoload (quote dcl-mode) "dcl-mode" "\
;;;***
\f
;;;### (autoloads (cancel-debug-on-entry debug-on-entry debug) "debug"
-;;;;;; "emacs-lisp/debug.el" (14144 59544))
+;;;;;; "emacs-lisp/debug.el" (14547 29510))
;;; Generated autoloads from emacs-lisp/debug.el
(setq debugger (quote debug))
;;;***
\f
;;;### (autoloads (decipher-mode decipher) "decipher" "play/decipher.el"
-;;;;;; (13875 47217))
+;;;;;; (13875 47403))
;;; 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))
+;;; Generated autoloads from delim-col.el
+
+(autoload (quote delimit-columns-region) "delim-col" "\
+Prettify all columns in a text region.
+
+START and END delimits the text region." t nil)
+
+(autoload (quote delimit-columns-rectangle) "delim-col" "\
+Prettify all columns in a text rectangle.
+
+START and END delimits the corners of text rectangle." t nil)
+
+;;;***
+\f
+;;;### (autoloads (delphi-mode) "delphi" "progmodes/delphi.el" (14505
+;;;;;; 12112))
+;;; Generated autoloads from progmodes/delphi.el
+
+(autoload (quote delphi-mode) "delphi" "\
+Major mode for editing Delphi code. \\<delphi-mode-map>
+\\[delphi-tab] - Indents the current line for Delphi code.
+\\[delphi-find-unit] - Search for a Delphi source file.
+\\[delphi-fill-comment] - Fill the current comment.
+\\[delphi-new-comment-line] - If in a // comment, do a new comment line.
+
+M-x indent-region also works for indenting a whole region.
+
+Customization:
+
+ `delphi-indent-level' (default 3)
+ Indentation of Delphi statements with respect to containing block.
+ `delphi-compound-block-indent' (default 0)
+ Extra indentation for blocks in compound statements.
+ `delphi-case-label-indent' (default 0)
+ Extra indentation for case statement labels.
+ `delphi-tab-always-indents' (default t)
+ Non-nil means TAB in Delphi mode should always reindent the current line,
+ regardless of where in the line point is when the TAB command is used.
+ `delphi-newline-always-indents' (default t)
+ Non-nil means NEWLINE in Delphi mode should always reindent the current
+ line, insert a blank line and move to the default indent column of the
+ blank line.
+ `delphi-search-path' (default .)
+ Directories to search when finding external units.
+ `delphi-verbose' (default nil)
+ If true then delphi token processing progress is reported to the user.
+
+Coloring:
+
+ `delphi-comment-face' (default font-lock-comment-face)
+ Face used to color delphi comments.
+ `delphi-string-face' (default font-lock-string-face)
+ Face used to color delphi strings.
+ `delphi-keyword-face' (default font-lock-keyword-face)
+ Face used to color delphi keywords.
+ `delphi-other-face' (default nil)
+ Face used to color everything else.
+
+Turning on Delphi mode calls the value of the variable delphi-mode-hook with
+no args, if that value is non-nil." t nil)
+
+;;;***
+\f
;;;### (autoloads (delete-selection-mode delete-selection-mode) "delsel"
-;;;;;; "delsel.el" (14118 1897))
+;;;;;; "delsel.el" (14410 18534))
;;; Generated autoloads from delsel.el
(defalias (quote pending-delete-mode) (quote delete-selection-mode))
;;;***
\f
-;;;### (autoloads (derived-mode-init-mode-variables define-derived-mode)
-;;;;;; "derived" "derived.el" (13721 58283))
+;;;### (autoloads (derived-mode-init-mode-variables) "derived" "derived.el"
+;;;;;; (14552 48685))
;;; Generated autoloads from derived.el
-(autoload (quote define-derived-mode) "derived" "\
-Create a new mode as a variant of an existing mode.
-
-The arguments to this command are as follow:
-
-CHILD: the name of the command for the derived mode.
-PARENT: the name of the command for the parent mode (ie. text-mode).
-NAME: a string which will appear in the status line (ie. \"Hypertext\")
-DOCSTRING: an optional documentation string--if you do not supply one,
- the function will attempt to invent something useful.
-BODY: forms to execute just before running the
- hooks for the new mode.
-
-Here is how you could define LaTeX-Thesis mode as a variant of LaTeX mode:
-
- (define-derived-mode LaTeX-thesis-mode LaTeX-mode \"LaTeX-Thesis\")
-
-You could then make new key bindings for `LaTeX-thesis-mode-map'
-without changing regular LaTeX mode. In this example, BODY is empty,
-and DOCSTRING is generated by default.
-
-On a more complicated level, the following command uses sgml-mode as
-the parent, and then sets the variable `case-fold-search' to nil:
-
- (define-derived-mode article-mode sgml-mode \"Article\"
- \"Major mode for editing technical articles.\"
- (setq case-fold-search nil))
-
-Note that if the documentation string had been left out, it would have
-been generated automatically, with a reference to the keymap." nil (quote macro))
-
(autoload (quote derived-mode-init-mode-variables) "derived" "\
-Initialise variables for a new mode.
+Initialise variables for a new MODE.
Right now, if they don't already exist, set up a blank keymap, an
empty syntax table, and an empty abbrev table -- these will be merged
the first time the mode is used." nil nil)
;;;***
\f
;;;### (autoloads (desktop-load-default desktop-read) "desktop" "desktop.el"
-;;;;;; (13897 58559))
+;;;;;; (14598 57772))
;;; 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" (13941 57965))
+;;;;;; indian-to-devanagari) "devan-util" "language/devan-util.el"
+;;;;;; (14623 45988))
;;; 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 characters to Devanagari basic characters." nil nil)
+Convert IS 13194 character CHAR to Devanagari basic characters.
+If CHAR is not IS 13194, return CHAR as is." nil nil)
(autoload (quote devanagari-to-indian) "devan-util" "\
-Convert Devanagari basic characters to IS 13194 characters." nil nil)
+Convert Devanagari basic character CHAR to IS 13194 characters.
+If CHAR is not Devanagari basic character, return CHAR as is." nil nil)
(autoload (quote indian-to-devanagari-region) "devan-util" "\
-Convert IS 13194 characters in region to Devanagari basic characters." t nil)
+Convert IS 13194 characters in region to Devanagari basic characters.
+When called from a program, expects two arguments,
+positions (integers or markers) specifying the region." t nil)
(autoload (quote devanagari-to-indian-region) "devan-util" "\
-Convert Devanagari basic characters in region to Indian characters." t nil)
+Convert Devanagari basic characters in region to Indian characters.
+When called from a program, expects two arguments,
+positions (integers or markers) specifying the region." t nil)
(autoload (quote indian-to-devanagari-string) "devan-util" "\
-Convert Indian String to Devanagari Basic Character String." nil nil)
+Convert Indian characters in STRING to Devanagari Basic characters." nil nil)
(autoload (quote char-to-glyph-devanagari) "devan-util" "\
-Convert Devanagari characters in the string to Devanagari glyphs.
+Convert Devanagari characters in STRING to Devanagari glyphs.
Ligatures and special rules are processed." nil nil)
(autoload (quote devanagari-decompose-string) "devan-util" "\
-Decompose Devanagari glyph string STR to basic Devanagari character string." nil nil)
+Decompose Devanagari string STR" nil nil)
(autoload (quote devanagari-decompose-region) "devan-util" nil t nil)
;;;***
\f
;;;### (autoloads (diary-mail-entries diary) "diary-lib" "calendar/diary-lib.el"
-;;;;;; (14151 2344))
+;;;;;; (14587 2634))
;;; Generated autoloads from calendar/diary-lib.el
(autoload (quote diary) "diary-lib" "\
;;;***
\f
;;;### (autoloads (diff-backup diff diff-command diff-switches) "diff"
-;;;;;; "diff.el" (13332 40193))
+;;;;;; "diff.el" (14280 10414))
;;; Generated autoloads from diff.el
(defvar diff-switches "-c" "\
;;;***
\f
+;;;### (autoloads (diff-minor-mode diff-mode) "diff-mode" "diff-mode.el"
+;;;;;; (14619 3306))
+;;; Generated autoloads from diff-mode.el
+
+(autoload (quote diff-mode) "diff-mode" "\
+Major mode for viewing/editing context diffs.
+Supports unified and context diffs as well as (to a lesser extent) normal diffs.
+When the buffer is read-only, the ESC prefix is not necessary.
+This mode runs `diff-mode-hook'.
+\\{diff-mode-map}" t nil)
+
+(autoload (quote diff-minor-mode) "diff-mode" "\
+Minor mode for viewing/editing context diffs.
+\\{diff-minor-mode-map}" t nil)
+
+;;;***
+\f
;;;### (autoloads (dired-noselect dired-other-frame dired-other-window
;;;;;; 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" (14052 36795))
+;;;;;; "dired" "dired.el" (14600 27076))
;;; Generated autoloads from dired.el
(defvar dired-listing-switches "-al" "\
;;;### (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-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-add-file dired-do-redisplay
-;;;;;; dired-do-load dired-do-byte-compile 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" (14157 4475))
+;;;;;; 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-add-file dired-do-redisplay dired-do-load dired-do-byte-compile
+;;;;;; 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))
;;; Generated autoloads from dired-aux.el
(autoload (quote dired-diff) "dired-aux" "\
However, if there is a `*' in the command then it is run
just once with the entire file list substituted there.
+If there is no `*', but a `?' in the command then it is still run
+on each file individually but with the filename substituted there
+instead of att the end of the command.
+
No automatic redisplay of dired buffers is attempted, as there's no
telling what files the command may have changed. Type
\\[dired-do-redisplay] to redisplay the marked files.
The shell command has the top level directory as working directory, so
-output files usually are created there instead of in a subdir." t nil)
+output files usually are created there instead of in a subdir.
+
+In a noninteractive call (from Lisp code), you must specify
+the list of file names explicitly with the FILE-LIST argument." t nil)
(autoload (quote dired-do-kill-lines) "dired-aux" "\
Kill all marked lines (not the files).
this subdirectory.
This function takes some pains to conform to `ls -lR' output." t nil)
+(autoload (quote dired-insert-subdir) "dired-aux" "\
+Insert this subdirectory into the same dired buffer.
+If it is already present, overwrites previous entry,
+ else inserts it at its natural place (as `ls -lR' would have done).
+With a prefix arg, you may edit the `ls' switches used for this listing.
+ You can add `R' to the switches to expand the whole tree starting at
+ this subdirectory.
+This function takes some pains to conform to `ls -lR' output." t nil)
+
(autoload (quote dired-prev-subdir) "dired-aux" "\
Go to previous subdirectory, regardless of level.
When called interactively and not on a subdir line, go to this subdir's line." t nil)
;;;***
\f
-;;;### (autoloads (dired-jump) "dired-x" "dired-x.el" (13796 29070))
+;;;### (autoloads (dired-jump) "dired-x" "dired-x.el" (14523 40402))
;;; Generated autoloads from dired-x.el
(autoload (quote dired-jump) "dired-x" "\
;;;***
\f
-;;;### (autoloads (dirtrack) "dirtrack" "dirtrack.el" (14032 29853))
+;;;### (autoloads (dirtrack) "dirtrack" "dirtrack.el" (14032 30315))
;;; Generated autoloads from dirtrack.el
(autoload (quote dirtrack) "dirtrack" "\
;;;***
\f
;;;### (autoloads (disassemble) "disass" "emacs-lisp/disass.el" (13776
-;;;;;; 9510))
+;;;;;; 9615))
;;; Generated autoloads from emacs-lisp/disass.el
(autoload (quote disassemble) "disass" "\
;;;;;; 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" (14168 7661))
+;;;;;; make-display-table) "disp-table" "disp-table.el" (14353 44070))
;;; Generated autoloads from disp-table.el
(autoload (quote make-display-table) "disp-table" "\
from Lisp code also selects Latin-1 as the language environment, and
selects unibyte mode for all Emacs buffers (both existing buffers and
those created subsequently). This provides increased compatibility
-for users who call this function in `.emacs'." t nil)
+for users who call this function in `.emacs'." nil nil)
;;;***
\f
;;;### (autoloads (dissociated-press) "dissociate" "play/dissociate.el"
-;;;;;; (13229 28169))
+;;;;;; (13229 28172))
;;; Generated autoloads from play/dissociate.el
(autoload (quote dissociated-press) "dissociate" "\
;;;***
\f
-;;;### (autoloads (doctor) "doctor" "play/doctor.el" (13556 41287))
+;;;### (autoloads (doctor) "doctor" "play/doctor.el" (13556 41573))
;;; Generated autoloads from play/doctor.el
(autoload (quote doctor) "doctor" "\
;;;***
\f
-;;;### (autoloads (double-mode) "double" "double.el" (13777 61323))
+;;;### (autoloads (double-mode double-mode) "double" "double.el"
+;;;;;; (14288 20375))
;;; Generated autoloads from double.el
+(defvar double-mode nil "\
+Toggle Double mode.
+Setting this variable directly does not take effect;
+use either \\[customize] or the function `double-mode'.")
+
+(custom-add-to-group (quote double) (quote double-mode) (quote custom-variable))
+
+(custom-add-load (quote double-mode) (quote double))
+
(autoload (quote double-mode) "double" "\
Toggle Double mode.
With prefix arg, turn Double mode on iff arg is positive.
;;;***
\f
-;;;### (autoloads (dunnet) "dunnet" "play/dunnet.el" (13607 44565))
+;;;### (autoloads (dunnet) "dunnet" "play/dunnet.el" (13607 44546))
;;; Generated autoloads from play/dunnet.el
(autoload (quote dunnet) "dunnet" "\
;;;***
\f
;;;### (autoloads (gnus-earcon-display) "earcon" "gnus/earcon.el"
-;;;;;; (14030 49072))
+;;;;;; (14030 48685))
;;; Generated autoloads from gnus/earcon.el
(autoload (quote gnus-earcon-display) "earcon" "\
;;;***
\f
-;;;### (autoloads (easy-mmode-define-minor-mode) "easy-mmode" "emacs-lisp/easy-mmode.el"
-;;;;;; (14213 21772))
+;;;### (autoloads (define-derived-mode easy-mmode-defsyntax easy-mmode-defmap
+;;;;;; define-minor-mode) "easy-mmode" "emacs-lisp/easy-mmode.el"
+;;;;;; (14552 48943))
;;; Generated autoloads from emacs-lisp/easy-mmode.el
-(autoload (quote easy-mmode-define-minor-mode) "easy-mmode" "\
+(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').
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 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.
-
-\(defmacro easy-mmode-define-minor-mode
- (MODE DOC &optional INIT-VALUE LIGHTER KEYMAP)...)" nil (quote macro))
+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))
+
+(autoload (quote easy-mmode-defmap) "easy-mmode" nil nil (quote macro))
+
+(autoload (quote easy-mmode-defsyntax) "easy-mmode" nil nil (quote macro))
+
+(autoload (quote define-derived-mode) "easy-mmode" "\
+Create a new mode as a variant of an existing mode.
+
+The arguments to this command are as follow:
+
+CHILD: the name of the command for the derived mode.
+PARENT: the name of the command for the parent mode (e.g. `text-mode').
+NAME: a string which will appear in the status line (e.g. \"Hypertext\")
+DOCSTRING: an optional documentation string--if you do not supply one,
+ the function will attempt to invent something useful.
+BODY: forms to execute just before running the
+ hooks for the new mode.
+
+Here is how you could define LaTeX-Thesis mode as a variant of LaTeX mode:
+
+ (define-derived-mode LaTeX-thesis-mode LaTeX-mode \"LaTeX-Thesis\")
+
+You could then make new key bindings for `LaTeX-thesis-mode-map'
+without changing regular LaTeX mode. In this example, BODY is empty,
+and DOCSTRING is generated by default.
+
+On a more complicated level, the following command uses `sgml-mode' as
+the parent, and then sets the variable `case-fold-search' to nil:
+
+ (define-derived-mode article-mode sgml-mode \"Article\"
+ \"Major mode for editing technical articles.\"
+ (setq case-fold-search nil))
+
+Note that if the documentation string had been left out, it would have
+been generated automatically, with a reference to the keymap." nil (quote macro))
;;;***
\f
;;;### (autoloads (easy-menu-change easy-menu-create-menu easy-menu-do-define
-;;;;;; easy-menu-define) "easymenu" "emacs-lisp/easymenu.el" (14228
-;;;;;; 23892))
+;;;;;; easy-menu-define) "easymenu" "emacs-lisp/easymenu.el" (14574
+;;;;;; 18612))
;;; Generated autoloads from emacs-lisp/easymenu.el
(autoload (quote easy-menu-define) "easymenu" "\
ENABLE is an expression; the item is enabled for selection
whenever this expression's value is non-nil.
-Alternatively, a menu item may have the form:
+Alternatively, a menu item may have the form:
[ NAME CALLBACK [ KEYWORD ARG ] ... ]
NAME is a string; the name of an argument to CALLBACK.
:style STYLE
-
+
STYLE is a symbol describing the type of menu item. The following are
-defined:
+defined:
toggle: A checkbox.
Prepend the name with `(*) ' or `( ) ' depending on if selected or not.
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.
(autoload (quote easy-menu-change) "easymenu" "\
Change menu found at PATH as item NAME to contain ITEMS.
-PATH is a list of strings for locating the menu containing NAME in the
-menu bar. ITEMS is a list of menu items, as in `easy-menu-define'.
-These items entirely replace the previous items in that map.
-If NAME is not present in the menu located by PATH, then add item NAME to
-that menu. If the optional argument BEFORE is present add NAME in menu
-just before BEFORE, otherwise add at end of menu.
+PATH is a list of strings for locating the menu that
+should contain a submenu named NAME.
+ITEMS is a list of menu items, as in `easy-menu-define'.
+These items entirely replace the previous items in that submenu.
+
+If the menu located by PATH has no submenu named NAME, add one.
+If the optional argument BEFORE is present, add it just before
+the submenu named BEFORE, otherwise add it at the end of the menu.
Either call this from `menu-bar-update-hook' or use a menu filter,
to implement dynamic menus." nil nil)
;;;***
\f
+;;;### (autoloads (ebnf-pop-style ebnf-push-style ebnf-reset-style
+;;;;;; 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))
+;;; Generated autoloads from progmodes/ebnf2ps.el
+
+(autoload (quote ebnf-customize) "ebnf2ps" "\
+Customization for ebnf group." t nil)
+
+(autoload (quote ebnf-print-buffer) "ebnf2ps" "\
+Generate and print a PostScript syntatic chart image of the buffer.
+
+When called with a numeric prefix argument (C-u), prompts the user for
+the name of a file to save the PostScript image in, instead of sending
+it to the printer.
+
+More specifically, the FILENAME argument is treated as follows: if it
+is nil, send the image to the printer. If FILENAME is a string, save
+the PostScript image in a file with that name. If FILENAME is a
+number, prompt the user for the name of the file to save in." t nil)
+
+(autoload (quote ebnf-print-region) "ebnf2ps" "\
+Generate and print a PostScript syntatic chart image of the region.
+Like `ebnf-print-buffer', but prints just the current region." t nil)
+
+(autoload (quote ebnf-spool-buffer) "ebnf2ps" "\
+Generate and spool a PostScript syntatic chart image of the buffer.
+Like `ebnf-print-buffer' except that the PostScript image is saved in a
+local buffer to be sent to the printer later.
+
+Use the command `ebnf-despool' to send the spooled images to the printer." t nil)
+
+(autoload (quote ebnf-spool-region) "ebnf2ps" "\
+Generate a PostScript syntatic chart image of the region and spool locally.
+Like `ebnf-spool-buffer', but spools just the current region.
+
+Use the command `ebnf-despool' to send the spooled images to the printer." t nil)
+
+(autoload (quote ebnf-eps-buffer) "ebnf2ps" "\
+Generate a PostScript syntatic chart image of the buffer in a EPS file.
+
+Indeed, for each production is generated a EPS file.
+The EPS file name has the following form:
+
+ <PREFIX><PRODUCTION>.eps
+
+<PREFIX> is given by variable `ebnf-eps-prefix'.
+ The default value is \"ebnf--\".
+
+<PRODUCTION> is the production name.
+ The production name is mapped to form a valid file name.
+ For example, the production name \"A/B + C\" is mapped to
+ \"A_B_+_C\" and the EPS file name used is \"ebnf--A_B_+_C.eps\".
+
+WARNING: It's *NOT* asked any confirmation to override an existing file." t nil)
+
+(autoload (quote ebnf-eps-region) "ebnf2ps" "\
+Generate a PostScript syntatic chart image of the region in a EPS file.
+
+Indeed, for each production is generated a EPS file.
+The EPS file name has the following form:
+
+ <PREFIX><PRODUCTION>.eps
+
+<PREFIX> is given by variable `ebnf-eps-prefix'.
+ The default value is \"ebnf--\".
+
+<PRODUCTION> is the production name.
+ The production name is mapped to form a valid file name.
+ For example, the production name \"A/B + C\" is mapped to
+ \"A_B_+_C\" and the EPS file name used is \"ebnf--A_B_+_C.eps\".
+
+WARNING: It's *NOT* asked any confirmation to override an existing file." t nil)
+
+(defalias (quote ebnf-despool) (quote ps-despool))
+
+(autoload (quote ebnf-syntax-buffer) "ebnf2ps" "\
+Does a syntatic analysis of the current buffer." t nil)
+
+(autoload (quote ebnf-syntax-region) "ebnf2ps" "\
+Does a syntatic analysis of a region." t nil)
+
+(autoload (quote ebnf-setup) "ebnf2ps" "\
+Return the current ebnf2ps setup." nil nil)
+
+(autoload (quote ebnf-insert-style) "ebnf2ps" "\
+Insert a new style NAME with inheritance INHERITS and values VALUES." t nil)
+
+(autoload (quote ebnf-merge-style) "ebnf2ps" "\
+Merge values of style NAME with style VALUES." t nil)
+
+(autoload (quote ebnf-apply-style) "ebnf2ps" "\
+Set STYLE to current style.
+
+It returns the old style symbol." t nil)
+
+(autoload (quote ebnf-reset-style) "ebnf2ps" "\
+Reset current style.
+
+It returns the old style symbol." t nil)
+
+(autoload (quote ebnf-push-style) "ebnf2ps" "\
+Push the current style and set STYLE to current style.
+
+It returns the old style symbol." t nil)
+
+(autoload (quote ebnf-pop-style) "ebnf2ps" "\
+Pop a style and set it to current style.
+
+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" (14613
+;;;;;; 26536))
+;;; 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.\nA second call of this function without changing point inserts the next match. \nA call with prefix PREFIX reads the symbol to insert from the minibuffer with\ncompletion." 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 5246))
+;;;;;; (13778 5499))
;;; Generated autoloads from ebuff-menu.el
(autoload (quote electric-buffer-list) "ebuff-menu" "\
;;;***
\f
;;;### (autoloads (Electric-command-history-redo-expression) "echistory"
-;;;;;; "echistory.el" (13229 28451))
+;;;;;; "echistory.el" (14447 15307))
;;; 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" (13988 42888))
+;;;;;; edebug-all-defs) "edebug" "emacs-lisp/edebug.el" (14583 8560))
;;; Generated autoloads from emacs-lisp/edebug.el
(defvar edebug-all-defs nil "\
Use the command `edebug-all-forms' to toggle the value of this option.")
(autoload (quote def-edebug-spec) "edebug" "\
-Set the edebug-form-spec property of SYMBOL according to SPEC.
+Set the `edebug-form-spec' property of SYMBOL according to SPEC.
Both SYMBOL and SPEC are unevaluated. The SPEC can be 0, t, a symbol
\(naming a function), or a list." nil (quote macro))
;;;;;; 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" (13680 6249))
+;;;;;; ediff-files) "ediff" "ediff.el" (14522 27408))
;;; Generated autoloads from ediff.el
(autoload (quote ediff-files) "ediff" "\
(autoload (quote ediff-directories) "ediff" "\
Run Ediff on a pair of directories, DIR1 and DIR2, comparing files that have
-the same name in both. The third argument, REGEXP, is a regular expression that
-can be used to filter out certain file names." t nil)
+the same name in both. The third argument, REGEXP, is a regular expression
+that can be used to filter out certain file names." t nil)
(defalias (quote edirs) (quote ediff-directories))
(autoload (quote ediff-directory-revisions) "ediff" "\
Run Ediff on a directory, DIR1, comparing its files with their revisions.
The second argument, REGEXP, is a regular expression that filters the file
-names. Only the files that are under revision control are taken into account." t nil)
+names. Only the files that are under revision control are taken into account." t nil)
(defalias (quote edir-revisions) (quote ediff-directory-revisions))
(autoload (quote ediff-directories3) "ediff" "\
Run Ediff on three directories, DIR1, DIR2, and DIR3, comparing files that
-have the same name in all three. The last argument, REGEXP, is a regular
+have the same name in all three. The last argument, REGEXP, is a regular
expression that can be used to filter out certain file names." t nil)
(defalias (quote edirs3) (quote ediff-directories3))
(autoload (quote ediff-merge-directories) "ediff" "\
Run Ediff on a pair of directories, DIR1 and DIR2, merging files that have
-the same name in both. The third argument, REGEXP, is a regular expression that
-can be used to filter out certain file names." t nil)
+the same name in both. The third argument, REGEXP, is a regular expression
+that can be used to filter out certain file names." t nil)
(defalias (quote edirs-merge) (quote ediff-merge-directories))
(autoload (quote ediff-merge-directories-with-ancestor) "ediff" "\
Merge files in directories DIR1 and DIR2 using files in ANCESTOR-DIR as ancestors.
-Ediff merges files that have identical names in DIR1, DIR2. If a pair of files
+Ediff merges files that have identical names in DIR1, DIR2. If a pair of files
in DIR1 and DIR2 doesn't have an ancestor in ANCESTOR-DIR, Ediff will merge
-without ancestor. The fourth argument, REGEXP, is a regular expression that
+without ancestor. The fourth argument, REGEXP, is a regular expression that
can be used to filter out certain file names." t nil)
(autoload (quote ediff-merge-directory-revisions) "ediff" "\
Run Ediff on a directory, DIR1, merging its files with their revisions.
The second argument, REGEXP, is a regular expression that filters the file
-names. Only the files that are under revision control are taken into account." t nil)
+names. Only the files that are under revision control are taken into account." t nil)
(defalias (quote edir-merge-revisions) (quote ediff-merge-directory-revisions))
(autoload (quote ediff-merge-directory-revisions-with-ancestor) "ediff" "\
Run Ediff on a directory, DIR1, merging its files with their revisions and ancestors.
The second argument, REGEXP, is a regular expression that filters the file
-names. Only the files that are under revision control are taken into account." t nil)
+names. Only the files that are under revision control are taken into account." t nil)
(defalias (quote edir-merge-revisions-with-ancestor) (quote ediff-merge-directory-revisions-with-ancestor))
Run Ediff on a pair of regions in two different buffers.
Regions (i.e., point and mark) are assumed to be set in advance.
This function is effective only for relatively small regions, up to 200
-lines. For large regions, use `ediff-regions-linewise'." t nil)
+lines. For large regions, use `ediff-regions-linewise'." t nil)
(autoload (quote ediff-regions-linewise) "ediff" "\
Run Ediff on a pair of regions in two different buffers.
Regions (i.e., point and mark) are assumed to be set in advance.
Each region is enlarged to contain full lines.
This function is effective for large regions, over 100-200
-lines. For small regions, use `ediff-regions-wordwise'." t nil)
+lines. For small regions, use `ediff-regions-wordwise'." t nil)
(defalias (quote ediff-merge) (quote ediff-merge-files))
(autoload (quote run-ediff-from-cvs-buffer) "ediff" "\
Run Ediff-merge on appropriate revisions of the selected file.
-First run after `M-x cvs-update'. Then place the cursor on a line describing a
+First run after `M-x cvs-update'. Then place the cursor on a line describing a
file and then run `run-ediff-from-cvs-buffer'." t nil)
(autoload (quote ediff-patch-file) "ediff" "\
-Run Ediff by patching SOURCE-FILENAME." t nil)
+Run Ediff by patching SOURCE-FILENAME.
+If optional PATCH-BUF is given, use the patch in that buffer
+and don't ask the user.
+If prefix argument, then: if even argument, assume that the patch is in a
+buffer. If odd -- assume it is in a file." t nil)
(autoload (quote ediff-patch-buffer) "ediff" "\
Run Ediff by patching BUFFER-NAME." t nil)
(autoload (quote ediff-revision) "ediff" "\
Run Ediff by comparing versions of a file.
The file is an optional FILE argument or the file visited by the current
-buffer. Use `vc.el' or `rcs.el' depending on `ediff-version-control-package'." t nil)
+buffer. Use `vc.el' or `rcs.el' depending on `ediff-version-control-package'." t nil)
(defalias (quote erevision) (quote ediff-revision))
;;;***
\f
+;;;### (autoloads (ediff-customize) "ediff-help" "ediff-help.el"
+;;;;;; (14522 27392))
+;;; 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))
+;;; 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...")))))
+
+(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"
-;;;;;; (13680 6243))
+;;;;;; (14398 37488))
;;; 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" (13896 8693))
+;;;;;; "ediff-util" "ediff-util.el" (14367 2134))
;;; 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 59578))
+;;;;;; (13957 59893))
;;; Generated autoloads from edmacro.el
(define-key ctl-x-map "\C-k" 'edit-kbd-macro)
;;;***
\f
;;;### (autoloads (edt-emulation-on) "edt" "emulation/edt.el" (13271
-;;;;;; 33643))
+;;;;;; 33724))
;;; Generated autoloads from emulation/edt.el
(autoload (quote edt-emulation-on) "edt" "\
;;;***
\f
;;;### (autoloads (electric-helpify with-electric-help) "ehelp" "ehelp.el"
-;;;;;; (13116 19630))
+;;;;;; (13116 19762))
;;; Generated autoloads from ehelp.el
(autoload (quote with-electric-help) "ehelp" "\
;;;***
\f
;;;### (autoloads (turn-on-eldoc-mode eldoc-mode eldoc-mode) "eldoc"
-;;;;;; "emacs-lisp/eldoc.el" (13881 40287))
+;;;;;; "emacs-lisp/eldoc.el" (13881 39947))
;;; Generated autoloads from emacs-lisp/eldoc.el
(defvar eldoc-mode nil "\
;;;***
\f
+;;;### (autoloads (elide-head) "elide-head" "elide-head.el" (14495
+;;;;;; 17971))
+;;; Generated autoloads from elide-head.el
+
+(autoload (quote elide-head) "elide-head" "\
+Hide header material in buffer according to `elide-head-headers-to-hide'.
+
+The header is made invisible with an overlay. With a prefix arg, show
+an elided material again.
+
+This is suitable as an entry on `find-file-hooks' or appropriate mode hooks." t nil)
+
+;;;***
+\f
;;;### (autoloads (elint-initialize) "elint" "emacs-lisp/elint.el"
-;;;;;; (13363 2815))
+;;;;;; (13363 2909))
;;; Generated autoloads from emacs-lisp/elint.el
(autoload (quote elint-initialize) "elint" "\
\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 6112))
+;;;;;; "elp" "emacs-lisp/elp.el" (13578 6553))
;;; Generated autoloads from emacs-lisp/elp.el
(autoload (quote elp-instrument-function) "elp" "\
;;;***
\f
;;;### (autoloads (report-emacs-bug) "emacsbug" "mail/emacsbug.el"
-;;;;;; (13649 21490))
+;;;;;; (13649 21996))
;;; 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" (13661 53123))
+;;;;;; "emerge.el" (14345 52903))
;;; 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"
-;;;;;; (14035 16830))
+;;;;;; (14516 181))
;;; 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" (14228 23900))
+;;;;;; "enriched" "enriched.el" (14539 53665))
;;; Generated autoloads from enriched.el
(autoload (quote enriched-mode) "enriched" "\
;;;***
\f
-;;;### (autoloads (setenv) "env" "env.el" (13582 12080))
-;;; Generated autoloads from env.el
-
-(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.
-
-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.
-
-This function works by modifying `process-environment'." t nil)
-
-;;;***
-\f
;;;### (autoloads (complete-tag select-tags-table tags-apropos list-tags
;;;;;; tags-query-replace tags-search tags-loop-continue next-file
;;;;;; 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)
-;;;;;; "etags" "progmodes/etags.el" (13878 24272))
+;;;;;; find-tag-default-function find-tag-hook tags-add-tables tags-table-list
+;;;;;; tags-case-fold-search) "etags" "progmodes/etags.el" (14600
+;;;;;; 21015))
;;; Generated autoloads from progmodes/etags.el
(defvar tags-file-name nil "\
Use the `etags' program to make a tags table file.")
(put 'tags-file-name 'variable-interactive "fVisit tags table: ")
+(defvar tags-case-fold-search (quote default) "\
+*Whether tags operations should be case-sensitive.
+A value of t means case-insensitive, a value of nil means case-sensitive.
+Any other value means use the setting of `case-fold-search'.")
+
(defvar tags-table-list nil "\
*List of file names of tags tables to search.
An element that is a directory means the file \"TAGS\" in that directory.
;;;;;; 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 44051))
+;;;;;; 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))
+;;; Generated autoloads from net/eudc.el
+
+(autoload (quote eudc-set-server) "eudc" "\
+Set the directory server to SERVER using PROTOCOL.
+Unless NO-SAVE is non-nil, the server is saved as the default
+server for future sessions." t nil)
+
+(autoload (quote eudc-get-email) "eudc" "\
+Get the email field of NAME from the directory server." t nil)
+
+(autoload (quote eudc-get-phone) "eudc" "\
+Get the phone field of NAME from the directory server." t nil)
+
+(autoload (quote eudc-expand-inline) "eudc" "\
+Query the directory server, and expand the query string before point.
+The query string consists of the buffer substring from the point back to
+the preceding comma, colon or beginning of line.
+The variable `eudc-inline-query-format' controls how to associate the
+individual inline query words with directory attribute names.
+After querying the server for the given string, the expansion specified by
+`eudc-inline-expansion-format' is inserted in the buffer at point.
+If REPLACE is non nil, then this expansion replaces the name in the buffer.
+`eudc-expansion-overwrites-query' being non nil inverts the meaning of REPLACE.
+Multiple servers can be tried with the same query until one finds a match,
+see `eudc-inline-expansion-servers'" t nil)
+
+(autoload (quote eudc-query-form) "eudc" "\
+Display a form to query the directory server.
+If given a non-nil argument GET-FIELDS-FROM-SERVER, the function first
+queries the server for the existing fields and displays a corresponding form." t nil)
+
+(autoload (quote eudc-load-eudc) "eudc" "\
+Load the Emacs Unified Directory Client.
+This does nothing except loading eudc by autoload side-effect." t nil)
+
+(cond ((not (string-match "XEmacs" emacs-version)) (defvar eudc-tools-menu (make-sparse-keymap "Directory Search")) (fset (quote eudc-tools-menu) (symbol-value (quote eudc-tools-menu))) (define-key eudc-tools-menu [phone] (quote ("Get Phone" . eudc-get-phone))) (define-key eudc-tools-menu [email] (quote ("Get Email" . eudc-get-email))) (define-key eudc-tools-menu [separator-eudc-email] (quote ("--"))) (define-key eudc-tools-menu [expand-inline] (quote ("Expand Inline Query" . eudc-expand-inline))) (define-key eudc-tools-menu [query] (quote ("Query with Form" . eudc-query-form))) (define-key eudc-tools-menu [separator-eudc-query] (quote ("--"))) (define-key eudc-tools-menu [new] (quote ("New Server" . eudc-set-server))) (define-key eudc-tools-menu [load] (quote ("Load Hotlist of Servers" . eudc-load-eudc)))) (t (let ((menu (quote ("Directory Search" ["Load Hotlist of Servers" eudc-load-eudc t] ["New Server" eudc-set-server t] ["---" nil nil] ["Query with Form" eudc-query-form t] ["Expand Inline Query" eudc-expand-inline t] ["---" nil nil] ["Get Email" eudc-get-email t] ["Get Phone" eudc-get-phone t])))) (if (not (featurep (quote eudc-autoloads))) (if (string-match "XEmacs" emacs-version) (if (and (featurep (quote menubar)) (not (featurep (quote infodock)))) (add-submenu (quote ("Tools")) menu)) (require (quote easymenu)) (cond ((fboundp (quote easy-menu-add-item)) (easy-menu-add-item nil (quote ("tools")) (easy-menu-create-menu (car menu) (cdr menu)))) ((fboundp (quote easy-menu-create-keymaps)) (define-key global-map [menu-bar tools eudc] (cons "Directory Search" (easy-menu-create-keymaps "Directory Search" (cdr menu)))))))))))
+
+;;;***
+\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))
+;;; Generated autoloads from net/eudc-bob.el
+
+(autoload (quote eudc-display-generic-binary) "eudc-bob" "\
+Display a button for unidentified binary DATA." nil nil)
+
+(autoload (quote eudc-display-url) "eudc-bob" "\
+Display URL and make it clickable." nil nil)
+
+(autoload (quote eudc-display-sound) "eudc-bob" "\
+Display a button to play the sound DATA." nil nil)
+
+(autoload (quote eudc-display-jpeg-inline) "eudc-bob" "\
+Display the JPEG DATA inline at point if possible." nil nil)
+
+(autoload (quote eudc-display-jpeg-as-button) "eudc-bob" "\
+Display a button for the JPEG DATA." nil nil)
+
+;;;***
+\f
+;;;### (autoloads (eudc-try-bbdb-insert eudc-insert-record-at-point-into-bbdb)
+;;;;;; "eudc-export" "net/eudc-export.el" (14460 58168))
+;;; Generated autoloads from net/eudc-export.el
+
+(autoload (quote eudc-insert-record-at-point-into-bbdb) "eudc-export" "\
+Insert record at point into the BBDB database.
+This function can only be called from a directory query result buffer." t nil)
+
+(autoload (quote eudc-try-bbdb-insert) "eudc-export" "\
+Call `eudc-insert-record-at-point-into-bbdb' if on a record." t nil)
+
+;;;***
+\f
+;;;### (autoloads (eudc-edit-hotlist) "eudc-hotlist" "net/eudc-hotlist.el"
+;;;;;; (14460 58176))
+;;; Generated autoloads from net/eudc-hotlist.el
+
+(autoload (quote eudc-edit-hotlist) "eudc-hotlist" "\
+Edit the hotlist of directory servers in a specialized buffer." t nil)
+
+;;;***
+\f
;;;### (autoloads (executable-self-display executable-set-magic)
-;;;;;; "executable" "progmodes/executable.el" (13940 33475))
+;;;;;; "executable" "progmodes/executable.el" (13940 33734))
;;; Generated autoloads from progmodes/executable.el
(autoload (quote executable-set-magic) "executable" "\
;;;***
\f
;;;### (autoloads (expand-jump-to-next-slot expand-jump-to-previous-slot
-;;;;;; expand-add-abbrevs) "expand" "expand.el" (14001 49584))
+;;;;;; expand-add-abbrevs) "expand" "expand.el" (14443 18506))
;;; Generated autoloads from expand.el
(autoload (quote expand-add-abbrevs) "expand" "\
;;;***
\f
-;;;### (autoloads (f90-mode) "f90" "progmodes/f90.el" (13970 7858))
+;;;### (autoloads (f90-mode) "f90" "progmodes/f90.el" (14623 45936))
;;; 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" (13453 47399))
+;;;;;; facemenu-set-face) "facemenu" "facemenu.el" (14539 53665))
;;; 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-background-menu) facemenu-background-menu)
-(defvar facemenu-special-menu (let ((map (make-sparse-keymap "Special"))) (define-key map [115] (cons "Remove Special" (quote facemenu-remove-special))) (define-key map [116] (cons "Intangible" (quote facemenu-set-intangible))) (define-key map [118] (cons "Invisible" (quote facemenu-set-invisible))) (define-key map [114] (cons "Read-Only" (quote facemenu-set-read-only))) map) "\
+(defvar facemenu-special-menu (let ((map (make-sparse-keymap "Special"))) (define-key map [115] (cons (purecopy "Remove Special") (quote facemenu-remove-special))) (define-key map [116] (cons (purecopy "Intangible") (quote facemenu-set-intangible))) (define-key map [118] (cons (purecopy "Invisible") (quote facemenu-set-invisible))) (define-key map [114] (cons (purecopy "Read-Only") (quote facemenu-set-read-only))) map) "\
Menu keymap for non-face text-properties.")
(defalias (quote facemenu-special-menu) facemenu-special-menu)
-(defvar facemenu-justification-menu (let ((map (make-sparse-keymap "Justification"))) (define-key map [99] (cons "Center" (quote set-justification-center))) (define-key map [98] (cons "Full" (quote set-justification-full))) (define-key map [114] (cons "Right" (quote set-justification-right))) (define-key map [108] (cons "Left" (quote set-justification-left))) (define-key map [117] (cons "Unfilled" (quote set-justification-none))) map) "\
+(defvar facemenu-justification-menu (let ((map (make-sparse-keymap "Justification"))) (define-key map [99] (cons (purecopy "Center") (quote set-justification-center))) (define-key map [98] (cons (purecopy "Full") (quote set-justification-full))) (define-key map [114] (cons (purecopy "Right") (quote set-justification-right))) (define-key map [108] (cons (purecopy "Left") (quote set-justification-left))) (define-key map [117] (cons (purecopy "Unfilled") (quote set-justification-none))) map) "\
Submenu for text justification commands.")
(defalias (quote facemenu-justification-menu) facemenu-justification-menu)
-(defvar facemenu-indentation-menu (let ((map (make-sparse-keymap "Indentation"))) (define-key map [decrease-right-margin] (cons "Indent Right Less" (quote decrease-right-margin))) (define-key map [increase-right-margin] (cons "Indent Right More" (quote increase-right-margin))) (define-key map [decrease-left-margin] (cons "Indent Less" (quote decrease-left-margin))) (define-key map [increase-left-margin] (cons "Indent More" (quote increase-left-margin))) map) "\
+(defvar facemenu-indentation-menu (let ((map (make-sparse-keymap "Indentation"))) (define-key map [decrease-right-margin] (cons (purecopy "Indent Right Less") (quote decrease-right-margin))) (define-key map [increase-right-margin] (cons (purecopy "Indent Right More") (quote increase-right-margin))) (define-key map [decrease-left-margin] (cons (purecopy "Indent Less") (quote decrease-left-margin))) (define-key map [increase-left-margin] (cons (purecopy "Indent More") (quote increase-left-margin))) map) "\
Submenu for indentation commands.")
(defalias (quote facemenu-indentation-menu) facemenu-indentation-menu)
(setq facemenu-menu (make-sparse-keymap "Text Properties"))
-(let ((map facemenu-menu)) (define-key map [dc] (cons "Display Colors" (quote list-colors-display))) (define-key map [df] (cons "Display Faces" (quote list-faces-display))) (define-key map [dp] (cons "List Properties" (quote list-text-properties-at))) (define-key map [ra] (cons "Remove Text Properties" (quote facemenu-remove-all))) (define-key map [rm] (cons "Remove Face Properties" (quote facemenu-remove-face-props))) (define-key map [s1] (list "-----------------")))
+(let ((map facemenu-menu)) (define-key map [dc] (cons (purecopy "Display Colors") (quote list-colors-display))) (define-key map [df] (cons (purecopy "Display Faces") (quote list-faces-display))) (define-key map [dp] (cons (purecopy "List Properties") (quote list-text-properties-at))) (define-key map [ra] (cons (purecopy "Remove Text Properties") (quote facemenu-remove-all))) (define-key map [rm] (cons (purecopy "Remove Face Properties") (quote facemenu-remove-face-props))) (define-key map [s1] (list (purecopy "--"))))
-(let ((map facemenu-menu)) (define-key map [in] (cons "Indentation" (quote facemenu-indentation-menu))) (define-key map [ju] (cons "Justification" (quote facemenu-justification-menu))) (define-key map [s2] (list "-----------------")) (define-key map [sp] (cons "Special Properties" (quote facemenu-special-menu))) (define-key map [bg] (cons "Background Color" (quote facemenu-background-menu))) (define-key map [fg] (cons "Foreground Color" (quote facemenu-foreground-menu))) (define-key map [fc] (cons "Face" (quote facemenu-face-menu))))
+(let ((map facemenu-menu)) (define-key map [in] (cons (purecopy "Indentation") (quote facemenu-indentation-menu))) (define-key map [ju] (cons (purecopy "Justification") (quote facemenu-justification-menu))) (define-key map [s2] (list (purecopy "--"))) (define-key map [sp] (cons (purecopy "Special Properties") (quote facemenu-special-menu))) (define-key map [bg] (cons (purecopy "Background Color") (quote facemenu-background-menu))) (define-key map [fg] (cons (purecopy "Foreground Color") (quote facemenu-foreground-menu))) (define-key map [fc] (cons (purecopy "Face") (quote facemenu-face-menu))))
(defalias (quote facemenu-menu) facemenu-menu)
;;;***
\f
;;;### (autoloads (turn-on-fast-lock fast-lock-mode) "fast-lock"
-;;;;;; "fast-lock.el" (14139 58050))
+;;;;;; "fast-lock.el" (14477 53252))
;;; Generated autoloads from fast-lock.el
(autoload (quote fast-lock-mode) "fast-lock" "\
\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" (13855 26165))
+;;;;;; "feedmail" "mail/feedmail.el" (14415 45092))
;;; 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 ffap find-file-at-point
-;;;;;; ffap-next) "ffap" "ffap.el" (14021 36699))
+;;;### (autoloads (dired-at-point ffap-at-mouse ffap-menu find-file-at-point
+;;;;;; ffap-next) "ffap" "ffap.el" (14412 8705))
;;; Generated autoloads from ffap.el
(autoload (quote ffap-next) "ffap" "\
and the functions `ffap-file-at-point' and `ffap-url-at-point'.
See <ftp://ftp.mathcs.emory.edu/pub/mic/emacs/> for latest version." t nil)
-
-(autoload (quote ffap) "ffap" "\
-A short alias for the find-file-at-point command." nil nil)
+(defalias 'ffap 'find-file-at-point)
(autoload (quote ffap-menu) "ffap" "\
Put up a menu of files and urls mentioned in this buffer.
;;;***
\f
;;;### (autoloads (file-cache-minibuffer-complete) "filecache" "filecache.el"
-;;;;;; (14027 1470))
+;;;;;; (14332 47695))
;;; Generated autoloads from filecache.el
(autoload (quote file-cache-minibuffer-complete) "filecache" "\
;;;***
\f
;;;### (autoloads (find-grep-dired find-name-dired find-dired find-grep-options
-;;;;;; find-ls-option) "find-dired" "find-dired.el" (13717 27320))
+;;;;;; find-ls-option) "find-dired" "find-dired.el" (14345 52903))
;;; 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"
-;;;;;; (13937 22881))
+;;;;;; (13670 3046))
;;; Generated autoloads from find-file.el
(autoload (quote ff-get-other-file) "find-file" "\
;;;;;; 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"
-;;;;;; (13980 37653))
+;;;;;; (14398 37514))
;;; Generated autoloads from emacs-lisp/find-func.el
(autoload (quote find-function-noselect) "find-func" "\
;;;***
\f
+;;;### (autoloads (finder-by-keyword finder-commentary finder-list-keywords)
+;;;;;; "finder" "finder.el" (14576 32883))
+;;; 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"
-;;;;;; "flow-ctrl.el" (12550 53108))
+;;;;;; "flow-ctrl.el" (12550 54450))
;;; Generated autoloads from flow-ctrl.el
(autoload (quote enable-flow-control) "flow-ctrl" "\
;;;***
\f
;;;### (autoloads (flyspell-mode-off flyspell-mode) "flyspell" "textmodes/flyspell.el"
-;;;;;; (14218 3459))
+;;;;;; (14512 26322))
;;; Generated autoloads from textmodes/flyspell.el
(autoload (quote flyspell-mode) "flyspell" "\
\f
;;;### (autoloads (follow-delete-other-windows-and-split follow-mode
;;;;;; turn-off-follow-mode turn-on-follow-mode) "follow" "follow.el"
-;;;;;; (13674 33097))
+;;;;;; (14392 8455))
;;; Generated autoloads from follow.el
(autoload (quote turn-on-follow-mode) "follow" "\
;;;***
\f
;;;### (autoloads (font-lock-fontify-buffer global-font-lock-mode
-;;;;;; font-lock-add-keywords turn-on-font-lock font-lock-mode)
-;;;;;; "font-lock" "font-lock.el" (14230 12346))
+;;;;;; global-font-lock-mode font-lock-remove-keywords font-lock-add-keywords
+;;;;;; turn-on-font-lock font-lock-mode) "font-lock" "font-lock.el"
+;;;;;; (14620 23716))
;;; Generated autoloads from font-lock.el
(defvar font-lock-mode-hook nil "\
Turn on only if the terminal can display it." nil nil)
(autoload (quote font-lock-add-keywords) "font-lock" "\
-Add highlighting KEYWORDS for MAJOR-MODE.
-MAJOR-MODE should be a symbol, the major mode command name, such as `c-mode'
+Add highlighting KEYWORDS for MODE.
+MODE should be a symbol, the major mode command name, such as `c-mode'
or nil. If nil, highlighting keywords are added for the current buffer.
KEYWORDS should be a list; see the variable `font-lock-keywords'.
By default they are added at the beginning of the current highlighting list.
see the variables `c-font-lock-extra-types', `c++-font-lock-extra-types',
`objc-font-lock-extra-types' and `java-font-lock-extra-types'." nil nil)
+(autoload (quote font-lock-remove-keywords) "font-lock" "\
+Remove highlighting KEYWORDS for MODE.
+
+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.
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'.
+Setting this variable directly does not take effect;
+use either \\[customize] or the function `global-font-lock-mode'.")
+
+(custom-add-to-group (quote font-lock) (quote global-font-lock-mode) (quote custom-variable))
+
+(custom-add-load (quote global-font-lock-mode) (quote font-lock))
+
(autoload (quote font-lock-fontify-buffer) "font-lock" "\
-Fontify the current buffer the way `font-lock-mode' would." t nil)
+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"
-;;;;;; (14094 46514))
+;;;;;; (14551 28678))
;;; Generated autoloads from international/fontset.el
(autoload (quote create-fontset-from-fontset-spec) "fontset" "\
FONTSET-NAME,CHARSET-NAME0:FONT-NAME0,CHARSET-NAME1:FONT-NAME1, ...
Any number of SPACE, TAB, and NEWLINE can be put before and after commas.
-Optional 2nd argument STYLE-VARIANT is a list of font styles
-\(e.g. bold, italic) or the symbol t to specify all available styles.
-If this argument is specified, fontsets which differs from
-FONTSET-NAME in styles are also created. An element of STYLE-VARIANT
-may be cons of style and a font name. In this case, the style variant
-fontset uses the font for ASCII character set.
+Optional 2nd argument is ignored. It exists just for backward
+compatibility.
If this function attempts to create already existing fontset, error is
signaled unless the optional 3rd argument NOERROR is non-nil.
;;;***
\f
+;;;### (autoloads (footnote-mode) "footnote" "mail/footnote.el" (14517
+;;;;;; 9680))
+;;; Generated autoloads from mail/footnote.el
+
+(autoload (quote footnote-mode) "footnote" "\
+Toggle footnote minor mode.
+\\<message-mode-map>
+key binding
+--- -------
+
+\\[Footnote-renumber-footnotes] Footnote-renumber-footnotes
+\\[Footnote-goto-footnote] Footnote-goto-footnote
+\\[Footnote-delete-footnote] Footnote-delete-footnote
+\\[Footnote-cycle-style] Footnote-cycle-style
+\\[Footnote-back-to-message] Footnote-back-to-message
+\\[Footnote-add-footnote] Footnote-add-footnote
+" t nil)
+
+;;;***
+\f
;;;### (autoloads (forms-find-file-other-window forms-find-file forms-mode)
-;;;;;; "forms" "forms.el" (14162 18837))
+;;;;;; "forms" "forms.el" (14381 57540))
;;; Generated autoloads from forms.el
(autoload (quote forms-mode) "forms" "\
;;;***
\f
;;;### (autoloads (fortran-mode fortran-tab-mode-default) "fortran"
-;;;;;; "progmodes/fortran.el" (14164 461))
+;;;;;; "progmodes/fortran.el" (14537 23071))
;;; Generated autoloads from progmodes/fortran.el
(defvar fortran-tab-mode-default nil "\
Non-nil causes line number digits to be moved to the correct column
as typed. (default t)
`fortran-break-before-delimiters'
- Non-nil causes `fortran-fill' to break lines before delimiters.
+ Non-nil causes lines to be broken before delimiters.
(default t)
Turning on Fortran mode calls the value of the variable `fortran-mode-hook'
;;;***
\f
;;;### (autoloads (generic-mode define-generic-mode) "generic" "generic.el"
-;;;;;; (13973 2889))
+;;;;;; (13973 3308))
;;; Generated autoloads from generic.el
(autoload (quote define-generic-mode) "generic" "\
;;;***
\f
+;;;### (autoloads (glasses-mode) "glasses" "progmodes/glasses.el"
+;;;;;; (14609 53573))
+;;; Generated autoloads from progmodes/glasses.el
+
+(autoload (quote glasses-mode) "glasses" "\
+Minor mode for making identifiers likeThis readable.
+When this mode is active, it tries to add virtual separators (like underscores)
+at places they belong to." t nil)
+
+;;;***
+\f
;;;### (autoloads (gnus gnus-other-frame gnus-slave gnus-no-server
-;;;;;; gnus-slave-no-server) "gnus" "gnus/gnus.el" (14030 49469))
+;;;;;; gnus-slave-no-server) "gnus" "gnus/gnus.el" (14030 49411))
;;; 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"
-;;;;;; (14029 49119))
+;;;;;; (14030 49649))
;;; Generated autoloads from gnus/gnus-agent.el
(autoload (quote gnus-unplugged) "gnus-agent" "\
;;;***
\f
;;;### (autoloads (gnus-audio-play) "gnus-audio" "gnus/gnus-audio.el"
-;;;;;; (14030 49345))
+;;;;;; (14030 49288))
;;; Generated autoloads from gnus/gnus-audio.el
(autoload (quote gnus-audio-play) "gnus-audio" "\
\f
;;;### (autoloads (gnus-cache-generate-nov-databases gnus-cache-generate-active
;;;;;; gnus-jog-cache) "gnus-cache" "gnus/gnus-cache.el" (14030
-;;;;;; 49350))
+;;;;;; 49293))
;;; 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 56450))
+;;;;;; "gnus-group" "gnus/gnus-group.el" (14177 56552))
;;; 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 49385))
+;;;;;; (14030 49328))
;;; Generated autoloads from gnus/gnus-kill.el
(defalias (quote gnus-batch-kill) (quote gnus-batch-score))
;;;***
\f
;;;### (autoloads (gnus-change-server) "gnus-move" "gnus/gnus-move.el"
-;;;;;; (14030 49391))
+;;;;;; (14030 49334))
;;; 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 5285))
+;;;;;; "gnus/gnus-mule.el" (14092 5540))
;;; Generated autoloads from gnus/gnus-mule.el
(autoload (quote gnus-mule-add-group) "gnus-mule" "\
;;;***
\f
;;;### (autoloads (gnus-batch-brew-soup) "gnus-soup" "gnus/gnus-soup.el"
-;;;;;; (14030 49414))
+;;;;;; (14030 49357))
;;; 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 49416))
+;;;;;; (14030 49359))
;;; 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" (14030 49423))
+;;;;;; "gnus/gnus-start.el" (14345 52937))
;;; Generated autoloads from gnus/gnus-start.el
(autoload (quote gnus-unload) "gnus-start" "\
;;;***
\f
;;;### (autoloads (gnus-add-configuration) "gnus-win" "gnus/gnus-win.el"
-;;;;;; (14030 49464))
+;;;;;; (14030 49407))
;;; Generated autoloads from gnus/gnus-win.el
(autoload (quote gnus-add-configuration) "gnus-win" "\
;;;***
\f
-;;;### (autoloads (gomoku) "gomoku" "play/gomoku.el" (13940 33305))
+;;;### (autoloads (gomoku) "gomoku" "play/gomoku.el" (13940 33566))
;;; Generated autoloads from play/gomoku.el
(autoload (quote gomoku) "gomoku" "\
;;;***
\f
;;;### (autoloads (goto-address goto-address-at-point goto-address-at-mouse)
-;;;;;; "goto-addr" "goto-addr.el" (13884 38368))
-;;; Generated autoloads from goto-addr.el
+;;;;;; "goto-addr" "net/goto-addr.el" (14385 24830))
+;;; Generated autoloads from net/goto-addr.el
(autoload (quote goto-address-at-mouse) "goto-addr" "\
Send to the e-mail address or load the URL clicked with the mouse.
;;;***
\f
-;;;### (autoloads (gs-load-image) "gs" "gs.el" (14228 23893))
+;;;### (autoloads (gs-load-image) "gs" "gs.el" (14300 2906))
;;; Generated autoloads from gs.el
(autoload (quote gs-load-image) "gs" "\
;;;***
\f
;;;### (autoloads (jdb pdb perldb xdb dbx sdb gdb) "gud" "gud.el"
-;;;;;; (14130 46613))
+;;;;;; (14599 26515))
;;; Generated autoloads from gud.el
(autoload (quote gdb) "gud" "\
;;;***
\f
;;;### (autoloads (handwrite) "handwrite" "play/handwrite.el" (14033
-;;;;;; 23498))
+;;;;;; 23942))
;;; Generated autoloads from play/handwrite.el
(autoload (quote handwrite) "handwrite" "\
;;;***
\f
-;;;### (autoloads (hanoi) "hanoi" "play/hanoi.el" (12579 52103))
+;;;### (autoloads (hanoi-unix-64 hanoi-unix hanoi) "hanoi" "play/hanoi.el"
+;;;;;; (14539 53714))
;;; Generated autoloads from play/hanoi.el
(autoload (quote hanoi) "hanoi" "\
-Towers of Hanoi diversion. Argument is number of rings." t nil)
+Towers of Hanoi diversion. Use NRINGS rings." t nil)
+
+(autoload (quote hanoi-unix) "hanoi" "\
+Towers of Hanoi, UNIX doomsday version.
+Displays 32-ring towers that have been progressing at one move per
+second since 1970-01-01 00:00:00 GMT.
+
+Repent before ring 31 moves." t nil)
+
+(autoload (quote hanoi-unix-64) "hanoi" "\
+Like hanoi-unix, but pretend to have a 64-bit clock.
+This is, necessarily (as of emacs 20.3), a crock. When the
+current-time interface is made s2G-compliant, hanoi.el will need
+to be updated." t nil)
;;;***
\f
-;;;### (autoloads nil "help-macro" "help-macro.el" (13838 43658))
+;;;### (autoloads (three-step-help) "help-macro" "help-macro.el"
+;;;;;; (14264 39262))
;;; Generated autoloads from help-macro.el
(defvar three-step-help nil "\
;;;***
\f
;;;### (autoloads (Helper-help Helper-describe-bindings) "helper"
-;;;;;; "emacs-lisp/helper.el" (12536 45574))
+;;;;;; "emacs-lisp/helper.el" (14518 20602))
;;; 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" (14124 7361))
+;;;;;; "hexl.el" (14589 54862))
;;; Generated autoloads from hexl.el
(autoload (quote hexl-mode) "hexl" "\
-\\<hexl-mode-map>
-A major mode for editing binary files in hex dump format.
+\\<hexl-mode-map>A mode for editing binary files in hex dump format.
+This is not an ordinary major mode; it alters some aspects
+if the current mode's behavior, but not all; also, you can exit
+Hexl mode and return to the previous mode using `hexl-mode-exit'.
This function automatically converts a buffer into the hexl format
using the function `hexlify-buffer'.
Note: saving the file with any of the usual Emacs commands
will actually convert it back to binary format while saving.
-You can use \\[hexl-find-file] to visit a file in hexl-mode.
+You can use \\[hexl-find-file] to visit a file in Hexl mode.
\\[describe-bindings] for advanced commands." t nil)
;;;***
\f
;;;### (autoloads (hide-ifdef-lines hide-ifdef-read-only hide-ifdef-initially
-;;;;;; hide-ifdef-mode) "hideif" "progmodes/hideif.el" (13859 9225))
+;;;;;; hide-ifdef-mode) "hideif" "progmodes/hideif.el" (14392 886))
;;; Generated autoloads from progmodes/hideif.el
+(defvar hide-ifdef-mode nil "\
+Non-nil when hide-ifdef-mode is activated.")
+
(autoload (quote hide-ifdef-mode) "hideif" "\
Toggle Hide-Ifdef mode. This is a minor mode, albeit a large one.
With ARG, turn Hide-Ifdef mode on if arg is positive, off otherwise.
;;;***
\f
-;;;### (autoloads (hs-minor-mode hs-mouse-toggle-hiding hs-hide-all
-;;;;;; hs-show-hidden-short-form hs-hide-comments-when-hiding-all)
-;;;;;; "hideshow" "progmodes/hideshow.el" (13845 6001))
+;;;### (autoloads (hs-minor-mode hs-hide-comments-when-hiding-all)
+;;;;;; "hideshow" "progmodes/hideshow.el" (14512 26322))
;;; Generated autoloads from progmodes/hideshow.el
(defvar hs-hide-comments-when-hiding-all t "\
-Hide the comments too when you do an `hs-hide-all'.")
-
-(defvar hs-show-hidden-short-form t "\
-Leave only the first line visible in a hidden block.
-If non-nil only the first line is visible when a block is in the
-hidden state, else both the first line and the last line are shown.
-A nil value disables `hs-adjust-block-beginning', which see.
-
-An example of how this works: (in C mode)
-original:
-
- /* My function main
- some more stuff about main
- */
- int
- main(void)
- {
- int x=0;
- return 0;
- }
-
-
-hidden and `hs-show-hidden-short-form' is nil
- /* My function main...
- */
- int
- main(void)
- {...
- }
-
-hidden and `hs-show-hidden-short-form' is t
- /* My function main...
- int
- main(void)...
-
-For the last case you have to be on the line containing the
-ellipsis when you do `hs-show-block'.")
-
-(defvar hs-special-modes-alist (quote ((c-mode "{" "}" nil nil hs-c-like-adjust-block-beginning) (c++-mode "{" "}" "/[*/]" nil hs-c-like-adjust-block-beginning) (java-mode "\\(\\(\\([ ]*\\(\\(abstract\\|final\\|native\\|p\\(r\\(ivate\\|otected\\)\\|ublic\\)\\|s\\(tatic\\|ynchronized\\)\\)[ \n]+\\)*[.a-zA-Z0-9_:]+[ \n]*\\(\\[[ \n]*\\][ \n]*\\)?\\([a-zA-Z0-9_:]+[ \n]*\\)([^)]*)\\([ \n ]+throws[ \n][^{]+\\)?\\)\\|\\([ ]*static[^{]*\\)\\)[ \n]*{\\)" "}" "/[*/]" java-hs-forward-sexp hs-c-like-adjust-block-beginning))) "\
+*Hide the comments too when you do an `hs-hide-all'.")
+
+(defvar hs-special-modes-alist (quote ((c-mode "{" "}" "/[*/]" nil hs-c-like-adjust-block-beginning) (c++-mode "{" "}" "/[*/]" nil hs-c-like-adjust-block-beginning) (bibtex-mode ("^@\\S(*\\(\\s(\\)" 1)) (java-mode "{" "}" "/[*/]" nil hs-c-like-adjust-block-beginning))) "\
*Alist for initializing the hideshow variables for different modes.
-It has the form
+Each element has the form
(MODE START END COMMENT-START FORWARD-SEXP-FUNC ADJUST-BEG-FUNC).
-If present, hideshow will use these values as regexps for start, end
-and comment-start, respectively. Since Algol-ish languages do not have
-single-character block delimiters, the function `forward-sexp' used
-by hideshow doesn't work. In this case, if a similar function is
-available, you can register it and have hideshow use it instead of
-`forward-sexp'. See the documentation for `hs-adjust-block-beginning'
-to see what is the use of ADJUST-BEG-FUNC.
-If any of those is left nil, hideshow will try to guess some values
-using function `hs-grok-mode-type'.
+If non-nil, hideshow will use these values as regexps to define blocks
+and comments, respectively for major mode MODE.
-Note that the regexps should not contain leading or trailing whitespace.")
+START, END and COMMENT-START are regular expressions. A block is
+defined as text surrounded by START and END.
-(autoload (quote hs-hide-all) "hideshow" "\
-Hide all top-level blocks, displaying only first and last lines.
-Move point to the beginning of the line, and it run the normal hook
-`hs-hide-hook'. See documentation for `run-hooks'.
-If `hs-hide-comments-when-hiding-all' is t, also hide the comments." t nil)
+As a special case, START may be a list of the form (COMPLEX-START
+MDATA-SELECTOR), where COMPLEX-START is a regexp w/ multiple parts and
+MDATA-SELECTOR an integer that specifies which sub-match is the proper
+place to adjust point, before calling `hs-forward-sexp-func'. For
+example, see the `hs-special-modes-alist' entry for `bibtex-mode'.
-(autoload (quote hs-mouse-toggle-hiding) "hideshow" "\
-Toggle hiding/showing of a block.
-Should be bound to a mouse key." t nil)
+For some major modes, `forward-sexp' does not work properly. In those
+cases, FORWARD-SEXP-FUNC specifies another function to use instead.
+
+See the documentation for `hs-adjust-block-beginning' to see what is the
+use of ADJUST-BEG-FUNC.
+
+If any of the elements is left nil or omitted, hideshow tries to guess
+appropriate values. The regexps should not contain leading or trailing
+whitespace. Case does not matter.")
(autoload (quote hs-minor-mode) "hideshow" "\
Toggle hideshow minor mode.
When hideshow minor mode is on, the menu bar is augmented with hideshow
commands and the hideshow commands are enabled.
The value '(hs . t) is added to `buffer-invisibility-spec'.
-Last, the normal hook `hs-minor-mode-hook' is run; see the doc
-for `run-hooks'.
The main commands are: `hs-hide-all', `hs-show-all', `hs-hide-block',
-`hs-show-block', `hs-hide-level' and `hs-show-region'.
-Also see the documentation for the variable `hs-show-hidden-short-form'.
+`hs-show-block', `hs-hide-level' and `hs-show-region'. There is also
+`hs-hide-initial-comment-block' and `hs-mouse-toggle-hiding'.
Turning hideshow minor mode off reverts the menu bar and the
variables to default values and disables the hideshow commands.
+Lastly, the normal hook `hs-minor-mode-hook' is run using `run-hooks'.
+
Key bindings:
\\{hs-minor-mode-map}" t nil)
;;;### (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" (14082 18582))
+;;;;;; "hilit-chg" "hilit-chg.el" (14288 22009))
;;; 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.
This allows you to manually remove highlighting from uninteresting changes." t nil)
;;;### (autoloads (make-hippie-expand-function hippie-expand hippie-expand-only-buffers
;;;;;; 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-exp" "hippie-exp.el" (13674
-;;;;;; 32879))
+;;;;;; hippie-expand-verbose hippie-expand-try-functions-list) "hippie-exp"
+;;;;;; "hippie-exp.el" (14398 37488))
;;; 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))
+;;; Generated autoloads from hl-line.el
+
+(defvar hl-line-mode nil "\
+Toggle Hl-Line mode.
+Setting this variable directly does not take effect;
+use either \\[customize] or the function `hl-line-mode'.")
+
+(custom-add-to-group (quote hl-line) (quote hl-line-mode) (quote custom-variable))
+
+(custom-add-load (quote hl-line-mode) (quote hl-line))
+
+(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 (list-holidays) "holidays" "calendar/holidays.el"
;;;;;; (13462 53924))
;;; Generated autoloads from calendar/holidays.el
;;;***
\f
;;;### (autoloads (hscroll-global-mode hscroll-mode turn-on-hscroll)
-;;;;;; "hscroll" "hscroll.el" (14210 21345))
+;;;;;; "hscroll" "hscroll.el" (14454 81))
;;; Generated autoloads from hscroll.el
(autoload (quote turn-on-hscroll) "hscroll" "\
-Unconditionally turn on Hscroll mode in the current buffer." nil nil)
+This function is obsolete." nil nil)
(autoload (quote hscroll-mode) "hscroll" "\
-Toggle HScroll mode in the current buffer.
-With ARG, turn HScroll mode on if ARG is positive, off otherwise.
-In HScroll mode, truncated lines will automatically scroll left or
-right when point gets near either edge of the window.
- See also \\[hscroll-global-mode]." t nil)
+This function is absolete." t nil)
(autoload (quote hscroll-global-mode) "hscroll" "\
-Toggle HScroll mode in all buffers (excepting minibuffers).
-With ARG, turn HScroll mode on if ARG is positive, off otherwise.
-If a buffer ever has HScroll mode set locally (via \\[hscroll-mode]),
-it will forever use the local value (i.e., \\[hscroll-global-mode]
-will have no effect on it).
- See also \\[hscroll-mode]." t nil)
+This function is absolete." t nil)
;;;***
\f
;;;### (autoloads (icomplete-minibuffer-setup icomplete-mode) "icomplete"
-;;;;;; "icomplete.el" (14118 2220))
+;;;;;; "icomplete.el" (14440 64840))
;;; Generated autoloads from icomplete.el
(autoload (quote icomplete-mode) "icomplete" "\
;;;***
\f
-;;;### (autoloads (icon-mode) "icon" "progmodes/icon.el" (13549 38921))
+;;;### (autoloads (icon-mode) "icon" "progmodes/icon.el" (13549 39403))
;;; Generated autoloads from progmodes/icon.el
(autoload (quote icon-mode) "icon" "\
;;;***
\f
-;;;### (autoloads (ielm) "ielm" "ielm.el" (13638 46794))
+;;;### (autoloads (idlwave-shell) "idlw-shell" "progmodes/idlw-shell.el"
+;;;;;; (14495 18053))
+;;; Generated autoloads from progmodes/idlw-shell.el
+
+(autoload (quote idlwave-shell) "idlw-shell" "\
+Run an inferior IDL, with I/O through buffer `(idlwave-shell-buffer)'.
+If buffer exists but shell process is not running, start new IDL.
+If buffer exists and shell process is running, just switch to the buffer.
+
+When called with a prefix ARG, or when `idlwave-shell-use-dedicated-frame'
+is non-nil, the shell buffer and the source buffers will be in
+separate frames.
+
+The command to run comes from variable `idlwave-shell-explicit-file-name'.
+
+The buffer is put in `idlwave-shell-mode', providing commands for sending
+input and controlling the IDL job. See help on `idlwave-shell-mode'.
+See also the variable `idlwave-shell-prompt-pattern'.
+
+\(Type \\[describe-mode] in the shell buffer for a list of commands.)" t nil)
+
+;;;***
+\f
+;;;### (autoloads (idlwave-mode) "idlwave" "progmodes/idlwave.el"
+;;;;;; (14495 18054))
+;;; Generated autoloads from progmodes/idlwave.el
+
+(autoload (quote idlwave-mode) "idlwave" "\
+Major mode for editing IDL and WAVE CL .pro files.
+
+The main features of this mode are
+
+1. Indentation and Formatting
+ --------------------------
+ Like other Emacs programming modes, C-j inserts a newline and indents.
+ TAB is used for explicit indentation of the current line.
+
+ To start a continuation line, use \\[idlwave-split-line]. This function can also
+ be used in the middle of a line to split the line at that point.
+ When used inside a long constant string, the string is split at
+ that point with the `+' concatenation operator.
+
+ Comments are indented as follows:
+
+ `;;;' Indentation remains unchanged.
+ `;;' Indent like the surrounding code
+ `;' Indent to a minimum column.
+
+ The indentation of comments starting in column 0 is never changed.
+
+ Use \\[idlwave-fill-paragraph] to refill a paragraph inside a comment. The indentation
+ of the second line of the paragraph relative to the first will be
+ retained. Use \\[idlwave-auto-fill-mode] to toggle auto-fill mode for these comments.
+ When the variable `idlwave-fill-comment-line-only' is nil, code
+ can also be auto-filled and auto-indented (not recommended).
+
+ To convert pre-existing IDL code to your formatting style, mark the
+ entire buffer with \\[mark-whole-buffer] and execute \\[idlwave-expand-region-abbrevs].
+ Then mark the entire buffer again followed by \\[indent-region] (`indent-region').
+
+2. Routine Info
+ ------------
+ IDLWAVE displays information about the calling sequence and the accepted
+ keyword parameters of a procedure or function with \\[idlwave-routine-info].
+ \\[idlwave-find-module] jumps to the source file of a module.
+ 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).
+
+3. 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.
+
+4. Code Templates and Abbreviations
+ --------------------------------
+ Many Abbreviations are predefined to expand to code fragments and templates.
+ The abbreviations start generally with a `\\`. Some examples
+
+ \\pr PROCEDURE template
+ \\fu FUNCTION template
+ \\c CASE statement template
+ \\f FOR loop template
+ \\r REPEAT Loop template
+ \\w WHILE loop template
+ \\i IF statement template
+ \\elif IF-ELSE statement template
+ \\b BEGIN
+
+ For a full list, use \\[idlwave-list-abbrevs]. Some templates also have
+ direct keybindings - see the list of keybindings below.
+
+ \\[idlwave-doc-header] inserts a documentation header at the beginning of the
+ 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
+ -------------------------
+ The case of reserved words and some abbrevs is controlled by
+ `idlwave-reserved-word-upcase' and `idlwave-abbrev-change-case'.
+
+6. 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
+ -----
+ Loading idlwave.el runs `idlwave-load-hook'.
+ Turning on `idlwave-mode' runs `idlwave-mode-hook'.
+
+8. Documentation and Customization
+ -------------------------------
+ Info documentation for this package is available. Use \\[idlwave-info]
+ to display (complain to your sysadmin if that does not work).
+ For Postscript and HTML versions of the documentation, check IDLWAVE's
+ homepage at `http://www.strw.leidenuniv.nl/~dominik/Tools/idlwave'.
+ IDLWAVE has customize support - see the group `idlwave'.
+
+9. Keybindings
+ -----------
+ Here is a list of all keybindings of this mode.
+ If some of the key bindings below show with ??, use \\[describe-key]
+ followed by the key sequence to see what the key sequence does.
+
+\\{idlwave-mode-map}" t nil)
+
+;;;***
+\f
+;;;### (autoloads (ielm) "ielm" "ielm.el" (13638 47263))
;;; 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" "image.el" (14228 23898))
+;;;### (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" (14598 54652))
;;; Generated autoloads from image.el
+(autoload (quote image-type-from-data) "image" "\
+Determine the image type from image data DATA.
+Value is a symbol specifying the image type or nil if type cannot
+be determined." nil nil)
+
(autoload (quote image-type-from-file-header) "image" "\
Determine the type of image file FILE from its first few bytes.
Value is a symbol specifying the image type, or nil if type cannot
Image types are symbols like `xbm' or `jpeg'." nil nil)
(autoload (quote create-image) "image" "\
-Create an image which will be loaded from FILE.
+Create an image.
+FILE-OR-DATA is an image file name or image data.
Optional TYPE is a symbol describing the image type. If TYPE is omitted
-or nil, try to determine the image file type from its first few bytes.
-If that doesn't work, use FILE's extension.as image type.
+or nil, try to determine the image type from its first few bytes
+of image data. If that doesn't work, and FILE-OR-DATA is a file name,
+use its file extension.as image type.
+Optional DATA-P non-nil means FILE-OR-DATA is a string containing image data.
Optional PROPS are additional image attributes to assign to the image,
like, e.g. `:heuristic-mask t'.
Value is the image created, or nil if images of type TYPE are not supported." nil nil)
(autoload (quote put-image) "image" "\
-Put image IMAGE in front of POS in BUFFER.
+Put image IMAGE in front of POS in the current buffer.
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.
POS may be an integer or marker.
-BUFFER nil or omitted means use the current buffer.
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'
-means display it in the right marginal area.
-IMAGE is displayed by putting an overlay into BUFFER with a
-`before-string' that has a `display' property whose value is the
-image." nil nil)
+means display it in the right marginal area." nil nil)
(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.
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'
-means display it in the right marginal area.
-IMAGE is displayed by inserting an \"x\" into the current buffer
-having a `display' property whose value is the image." nil nil)
+means display it in the right marginal area." nil nil)
(autoload (quote remove-images) "image" "\
Remove images between START and END in BUFFER.
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. DOC is an optional
+documentation string.
+
+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 first image
+specification whose TYPE is supported, and FILE exists, is used to
+define SYMBOL." nil nil)
+
(autoload (quote defimage) "image" "\
Define SYMBOL as an image.
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 `:file FILE', where TYPE
-is a symbol specifying the image type, e.g. `xbm', and FILE is the
-file to load the image from. The first image specification whose TYPE
-is supported, and FILE exists, is used to define SYMBOL.
+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 first image
+specification whose TYPE is supported, and FILE exists, is used to
+define SYMBOL.
Example:
;;;***
\f
;;;### (autoloads (imenu imenu-add-menubar-index imenu-add-to-menubar
-;;;;;; imenu-sort-function) "imenu" "imenu.el" (14090 26268))
+;;;;;; imenu-sort-function) "imenu" "imenu.el" (14315 33489))
;;; Generated autoloads from imenu.el
(defvar imenu-sort-function nil "\
(make-variable-buffer-local (quote imenu-extract-index-name-function))
+(defvar imenu-name-lookup-function nil "\
+Function to compare string with index item.
+
+This function will be called with two strings, and should return
+non-nil if they match.
+
+If nil, comparison is done with `string='.
+Set this to some other function for more advanced comparisons,
+such as \"begins with\" or \"name matches and number of
+arguments match\".
+
+This variable is local in all buffers.")
+
+(make-variable-buffer-local (quote imenu-name-lookup-function))
+
(defvar imenu-default-goto-function (quote imenu-default-goto-function) "\
The default function called when selecting an Imenu item.
The function in this variable is called when selecting a normal index-item.")
;;;***
\f
-;;;### (autoloads (inferior-lisp) "inf-lisp" "inf-lisp.el" (13898
-;;;;;; 16181))
-;;; Generated autoloads from inf-lisp.el
+;;;### (autoloads (inferior-lisp) "inf-lisp" "progmodes/inf-lisp.el"
+;;;;;; (14589 55732))
+;;; 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.
;;;***
\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" (14115 64939))
+;;;;;; Info-goto-emacs-command-node Info-directory info-standalone
+;;;;;; info info-other-window) "info" "info.el" (14581 64356))
;;; Generated autoloads from info.el
(autoload (quote info-other-window) "info" "\
Enter Info, the documentation browser.
Optional argument FILE specifies the file to examine;
the default is the top-level directory of Info.
+Called from a program, FILE may specify an Info node of the form
+`(FILENAME)NODENAME'.
In interactive use, a prefix argument directs this command
to read a file name from the minibuffer.
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
\f
;;;### (autoloads (info-complete-file info-complete-symbol info-lookup-file
;;;;;; info-lookup-symbol info-lookup-reset) "info-look" "info-look.el"
-;;;;;; (14177 55621))
+;;;;;; (14539 53666))
;;; Generated autoloads from info-look.el
(autoload (quote info-lookup-reset) "info-look" "\
When this command is called interactively, it reads SYMBOL from the minibuffer.
In the minibuffer, use M-n to yank the default argument value
into the minibuffer so you can edit it.
-The default symbol is the one found at point." t nil)
+The default symbol is the one found at point.
+
+With prefix arg a query for the symbol help mode is offered." t nil)
(autoload (quote info-lookup-file) "info-look" "\
Display the documentation of a file.
When this command is called interactively, it reads FILE from the minibuffer.
In the minibuffer, use M-n to yank the default file name
into the minibuffer so you can edit it.
-The default file name is the one found at point." t nil)
+The default file name is the one found at point.
+
+With prefix arg a query for the file help mode is offered." t nil)
(autoload (quote info-complete-symbol) "info-look" "\
Perform completion on symbol preceding point." t nil)
;;;***
\f
;;;### (autoloads (batch-info-validate Info-validate Info-split Info-tagify)
-;;;;;; "informat" "informat.el" (13728 5098))
+;;;;;; "informat" "informat.el" (14281 34724))
;;; Generated autoloads from informat.el
(autoload (quote Info-tagify) "informat" "\
\f
;;;### (autoloads (isearch-process-search-multibyte-characters isearch-toggle-input-method
;;;;;; isearch-toggle-specified-input-method) "isearch-x" "international/isearch-x.el"
-;;;;;; (13770 34350))
+;;;;;; (13770 35556))
;;; 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"
-;;;;;; (14127 16153))
+;;;;;; (14388 10886))
;;; 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 42797))
+;;;;;; 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 4446))
+;;;;;; (14164 4477))
;;; Generated autoloads from international/iso-transl.el
(or key-translation-map (setq key-translation-map (make-sparse-keymap)))
(define-key key-translation-map "\C-x8" 'iso-transl-ctl-x-8-map)
;;;;;; ispell-complete-word ispell-continue ispell-buffer ispell-comments-and-strings
;;;;;; ispell-region ispell-change-dictionary ispell-kill-ispell
;;;;;; ispell-help ispell-word ispell-dictionary-alist ispell-local-dictionary-alist
-;;;;;; ispell-personal-dictionary) "ispell" "ispell.el" (14218 3684))
-;;; Generated autoloads from ispell.el
+;;;;;; ispell-personal-dictionary) "ispell" "textmodes/ispell.el"
+;;;;;; (14587 2706))
+;;; Generated autoloads from textmodes/ispell.el
+
+(defconst xemacsp (string-match "Lucid\\|XEmacs" emacs-version) "\
+Non nil if using XEmacs.")
+
+(defconst version18p (string-match "18\\.[0-9]+\\.[0-9]+" emacs-version) "\
+Non nil if using emacs version 18.")
+
+(defconst version20p (string-match "20\\.[0-9]+\\.[0-9]+" emacs-version) "\
+Non nil if using emacs version 20.")
(defvar ispell-personal-dictionary nil "\
*File name of your personal spelling dictionary, or 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) ("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-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 ("-C" "-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))))
(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.")
-(defconst ispell-menu-map-needed (and (not ispell-menu-map) (not (string-match "18\\.[0-9]+\\.[0-9]+" emacs-version)) (not (string-match "Lucid\\|XEmacs" emacs-version))))
+(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))) name) (setq ispell-menu-map (make-sparse-keymap "Spell")) (while dicts (setq name (car (car dicts)) dicts (cdr dicts)) (if (stringp name) (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 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" (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 ispell-menu-map-needed (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 ispell-menu-map-needed (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)))))) (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 ispell-menu-map-needed (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))) (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\\|-\\|~\\)+\\)+"))) "\
Alist expressing beginning and end of regions not to spell check.
Word syntax described by `ispell-dictionary-alist' (which see).
This will check or reload the dictionary. Use \\[ispell-change-dictionary]
-or \\[ispell-region] to update the Ispell process." t nil)
+or \\[ispell-region] to update the Ispell process.
+
+return values:
+nil word is correct or spelling is accpeted.
+0 word is inserted into buffer-local definitions.
+\"word\" word corrected from word list.
+\(\"word\" arg) word is hand entered.
+quit spell session exited." t nil)
(autoload (quote ispell-help) "ispell" "\
Display a list of the options available when a misspelling is encountered.
(autoload (quote ispell-region) "ispell" "\
Interactively check a region for spelling errors.
-Return non-nil if spell session completed normally." t nil)
+Return nil if spell session is quit,
+ otherwise returns shift offset amount for last line processed." t nil)
(autoload (quote ispell-comments-and-strings) "ispell" "\
Check comments and strings in the current buffer for spelling errors." t nil)
\f
;;;### (autoloads (iswitchb-buffer-other-frame iswitchb-display-buffer
;;;;;; iswitchb-buffer-other-window iswitchb-buffer iswitchb-default-keybindings
-;;;;;; iswitchb-read-buffer) "iswitchb" "iswitchb.el" (14169 3596))
+;;;;;; iswitchb-read-buffer) "iswitchb" "iswitchb.el" (14619 3306))
;;; Generated autoloads from iswitchb.el
(autoload (quote iswitchb-read-buffer) "iswitchb" "\
\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"
-;;;;;; (13903 50605))
+;;;;;; japanese-hankaku japanese-hiragana japanese-katakana setup-japanese-environment-internal)
+;;;;;; "japan-util" "language/japan-util.el" (14623 45991))
;;; 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"
-;;;;;; (14228 23899))
+;;;;;; (14577 45436))
;;; Generated autoloads from jit-lock.el
(autoload (quote jit-lock-mode) "jit-lock" "\
;;;***
\f
-;;;### (autoloads nil "jka-compr" "jka-compr.el" (14097 45967))
+;;;### (autoloads (auto-compression-mode) "jka-compr" "jka-compr.el"
+;;;;;; (14568 39747))
;;; Generated autoloads from jka-compr.el
+
+(defvar auto-compression-mode nil "\
+Toggle automatic file compression and uncompression.
+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)
"\
Toggle automatic file compression and uncompression.
;;;***
\f
;;;### (autoloads (kinsoku) "kinsoku" "international/kinsoku.el"
-;;;;;; (13866 35246))
+;;;;;; (13866 35434))
;;; Generated autoloads from international/kinsoku.el
(autoload (quote kinsoku) "kinsoku" "\
;;;***
\f
;;;### (autoloads (kkc-region) "kkc" "international/kkc.el" (13810
-;;;;;; 39847))
+;;;;;; 39823))
;;; Generated autoloads from international/kkc.el
(autoload (quote kkc-region) "kkc" "\
;;;***
\f
-;;;### (autoloads (setup-korean-environment-internal setup-korean-environment)
-;;;;;; "korea-util" "language/korea-util.el" (14135 45477))
+;;;### (autoloads (setup-korean-environment-internal) "korea-util"
+;;;;;; "language/korea-util.el" (14623 45991))
;;; Generated autoloads from language/korea-util.el
-(defvar default-korean-keyboard "" "\
+(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"
-;;;;;; (13850 39344))
+;;;;;; (14256 23599))
;;; Generated autoloads from play/landmark.el
(defalias (quote landmark-repeat) (quote lm-test-run))
;;;***
\f
-;;;### (autoloads (setup-lao-environment) "lao-util" "language/lao-util.el"
-;;;;;; (13774 36678))
+;;;### (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" (14623 45991))
;;; 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" "\
+Transcribe a Romanized Lao syllable in the region FROM and TO to Lao string.
+Only the first syllable is transcribed.
+The value has the form: (START END LAO-STRING), where
+START and END are the beggining and end positions of the Roman Lao syllable,
+LAO-STRING is the Lao character transcription of it.
+
+Optional 3rd arg STR, if non-nil, is a string to search for Roman Lao
+syllable. In that case, FROM and TO are indexes to STR." nil nil)
+
+(autoload (quote lao-transcribe-roman-to-lao-string) "lao-util" "\
+Transcribe Romanized Lao string STR to Lao character string." nil nil)
+
+(autoload (quote lao-composition-function) "lao-util" "\
+Compose Lao text in the region FROM and TO.
+The text matches the regular expression PATTERN.
+Optional 4th argument STRING, if non-nil, is a string containing text
+to compose.
+
+The return value is number of composed characters." nil nil)
+
+(autoload (quote lao-compose-region) "lao-util" nil t nil)
;;;***
\f
;;;### (autoloads (turn-on-lazy-lock lazy-lock-mode) "lazy-lock"
-;;;;;; "lazy-lock.el" (13971 14325))
+;;;;;; "lazy-lock.el" (14477 53252))
;;; Generated autoloads from lazy-lock.el
(autoload (quote lazy-lock-mode) "lazy-lock" "\
;;;***
\f
;;;### (autoloads (ledit-from-lisp-mode ledit-mode) "ledit" "ledit.el"
-;;;;;; (13229 28763))
+;;;;;; (14280 10549))
;;; Generated autoloads from ledit.el
(defconst ledit-save-files t "\
;;;***
\f
-;;;### (autoloads (life) "life" "play/life.el" (13578 2952))
+;;;### (autoloads (life) "life" "play/life.el" (13578 3356))
;;; Generated autoloads from play/life.el
(autoload (quote life) "life" "\
;;;***
\f
;;;### (autoloads (unload-feature) "loadhist" "loadhist.el" (13935
-;;;;;; 16173))
+;;;;;; 16155))
;;; Generated autoloads from loadhist.el
(autoload (quote unload-feature) "loadhist" "\
;;;***
\f
;;;### (autoloads (locate-with-filter locate) "locate" "locate.el"
-;;;;;; (13685 31779))
+;;;;;; (14563 8348))
;;; Generated autoloads from locate.el
(autoload (quote locate) "locate" "\
-Run the program `locate', putting results in `*Locate*' buffer." t nil)
+Run the program `locate', putting results in `*Locate*' buffer.
+With prefix arg, prompt for the locate command to run." t nil)
(autoload (quote locate-with-filter) "locate" "\
-Run the locate command with a filter." t nil)
+Run the locate command with a filter.
+
+The filter is a regular expression. Only results matching the filter are
+shown; this is often useful to constrain a big search." t nil)
+
+;;;***
+\f
+;;;### (autoloads (log-edit) "log-edit" "log-edit.el" (14619 3306))
+;;; 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'.
+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].
+Once you're done editing the message, pressing \\[log-edit-done] will call
+`log-edit-done' which will end up calling CALLBACK to do the actual commit." nil nil)
+
+;;;***
+\f
+;;;### (autoloads (log-view-mode) "log-view" "log-view.el" (14619
+;;;;;; 3306))
+;;; Generated autoloads from log-view.el
+
+(autoload (quote log-view-mode) "log-view" "\
+Major mode for browsing CVS log output." t nil)
;;;***
\f
;;;### (autoloads (print-region lpr-region print-buffer lpr-buffer
-;;;;;; lpr-command lpr-switches printer-name) "lpr" "lpr.el" (14149
-;;;;;; 56563))
+;;;;;; lpr-command lpr-switches printer-name) "lpr" "lpr.el" (14563
+;;;;;; 22518))
;;; Generated autoloads from lpr.el
(defvar printer-name (if (memq system-type (quote (ms-dos windows-nt))) "PRN") "\
argument.")
(autoload (quote lpr-buffer) "lpr" "\
-Print buffer contents as with Unix command `lpr'.
-`lpr-switches' is a list of extra switches (strings) to pass to lpr." t nil)
+Print buffer contents without pagination or page headers.
+See the variables `lpr-switches' and `lpr-command'
+for customization of the printer command." t nil)
(autoload (quote print-buffer) "lpr" "\
-Print buffer contents as with Unix command `lpr -p'.
-`lpr-switches' is a list of extra switches (strings) to pass to lpr." t nil)
+Paginate and print buffer contents.
+
+The variable `lpr-headers-switches' controls how to paginate.
+If it is nil (the default), we run the `pr' program (or whatever program
+`lpr-page-header-program' specifies) to paginate.
+`lpr-page-header-switches' specifies the switches for that program.
+
+Otherwise, the switches in `lpr-headers-switches' are used
+in the print command itself; we expect them to request pagination.
+
+See the variables `lpr-switches' and `lpr-command'
+for further customization of the printer command." t nil)
(autoload (quote lpr-region) "lpr" "\
-Print region contents as with Unix command `lpr'.
-`lpr-switches' is a list of extra switches (strings) to pass to lpr." t nil)
+Print region contents without pagination or page headers.
+See the variables `lpr-switches' and `lpr-command'
+for customization of the printer command." t nil)
(autoload (quote print-region) "lpr" "\
-Print region contents as with Unix command `lpr -p'.
-`lpr-switches' is a list of extra switches (strings) to pass to lpr." t nil)
+Paginate and print the region contents.
+
+The variable `lpr-headers-switches' controls how to paginate.
+If it is nil (the default), we run the `pr' program (or whatever program
+`lpr-page-header-program' specifies) to paginate.
+`lpr-page-header-switches' specifies the switches for that program.
+
+Otherwise, the switches in `lpr-headers-switches' are used
+in the print command itself; we expect them to request pagination.
+
+See the variables `lpr-switches' and `lpr-command'
+for further customization of the printer command." t nil)
;;;***
\f
-;;;### (autoloads nil "ls-lisp" "ls-lisp.el" (14184 170))
+;;;### (autoloads nil "ls-lisp" "ls-lisp.el" (14425 19316))
;;; Generated autoloads from ls-lisp.el
(defvar ls-lisp-support-shell-wildcards t "\
;;;***
\f
;;;### (autoloads (m4-mode) "m4-mode" "progmodes/m4-mode.el" (13962
-;;;;;; 30563))
+;;;;;; 30919))
;;; 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 28843))
+;;;;;; name-last-kbd-macro) "macros" "macros.el" (13229 28845))
;;; Generated autoloads from macros.el
(autoload (quote name-last-kbd-macro) "macros" "\
;;;***
\f
;;;### (autoloads (what-domain mail-extract-address-components) "mail-extr"
-;;;;;; "mail/mail-extr.el" (13616 25279))
+;;;;;; "mail/mail-extr.el" (14281 39314))
;;; Generated autoloads from mail/mail-extr.el
(autoload (quote mail-extract-address-components) "mail-extr" "\
\f
;;;### (autoloads (mail-hist-put-headers-into-history mail-hist-keep-history
;;;;;; mail-hist-enable mail-hist-define-keys) "mail-hist" "mail/mail-hist.el"
-;;;;;; (14075 51559))
+;;;;;; (14075 51598))
;;; Generated autoloads from mail/mail-hist.el
(autoload (quote mail-hist-define-keys) "mail-hist" "\
;;;***
\f
-;;;### (autoloads (mail-fetch-field mail-file-babyl-p mail-use-rfc822)
-;;;;;; "mail-utils" "mail/mail-utils.el" (13772 47253))
+;;;### (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))
;;; Generated autoloads from mail/mail-utils.el
(defvar mail-use-rfc822 nil "\
(autoload (quote mail-file-babyl-p) "mail-utils" nil nil nil)
+(autoload (quote mail-quote-printable) "mail-utils" "\
+Convert a string to the \"quoted printable\" Q encoding.
+If the optional argument WRAPPER is non-nil,
+we add the wrapper characters =?ISO-8859-1?Q?....?=." nil nil)
+
+(autoload (quote mail-unquote-printable) "mail-utils" "\
+Undo the \"quoted printable\" encoding.
+If the optional argument WRAPPER is non-nil,
+we expect to find and remove the wrapper characters =?ISO-8859-1?Q?....?=." nil nil)
+
+(autoload (quote mail-unquote-printable-region) "mail-utils" "\
+Undo the \"quoted printable\" encoding in buffer from BEG to END.
+If the optional argument WRAPPER is non-nil,
+we expect to find and remove the wrapper characters =?ISO-8859-1?Q?....?=." t nil)
+
(autoload (quote mail-fetch-field) "mail-utils" "\
Return the value of the header field whose type is FIELD-NAME.
The buffer is expected to be narrowed to just the header of the message.
;;;***
\f
;;;### (autoloads (define-mail-abbrev build-mail-abbrevs mail-abbrevs-setup)
-;;;;;; "mailabbrev" "mail/mailabbrev.el" (13640 6043))
+;;;;;; "mailabbrev" "mail/mailabbrev.el" (14608 9472))
;;; Generated autoloads from mail/mailabbrev.el
(autoload (quote mail-abbrevs-setup) "mailabbrev" "\
\f
;;;### (autoloads (mail-complete define-mail-alias expand-mail-aliases
;;;;;; mail-complete-style) "mailalias" "mail/mailalias.el" (13996
-;;;;;; 15767))
+;;;;;; 15646))
;;; Generated autoloads from mail/mailalias.el
(defvar mail-complete-style (quote angles) "\
;;;***
\f
;;;### (autoloads (makefile-mode) "make-mode" "progmodes/make-mode.el"
-;;;;;; (14013 4126))
+;;;;;; (14608 7464))
;;; Generated autoloads from progmodes/make-mode.el
(autoload (quote makefile-mode) "make-mode" "\
The string that gets appended to all macro names
inserted by `makefile-insert-macro'.
The normal value should be \" = \", since this is what
- standard make expects. However, newer makes such as dmake
+ standard make expects. However, newer makes such as dmake
allow a larger variety of different macro assignments, so you
might prefer to use \" += \" or \" := \" .
filenames are omitted.
makefile-cleanup-continuations-p:
- If this variable is set to a non-nil value then makefile-mode
+ If this variable is set to a non-nil value then Makefile mode
will assure that no line in the file ends with a backslash
(the continuation character) followed by any whitespace.
This is done by silently removing the trailing whitespace, leaving
the backslash itself intact.
- IMPORTANT: Please note that enabling this option causes makefile-mode
+ IMPORTANT: Please note that enabling this option causes Makefile mode
to MODIFY A FILE WITHOUT YOUR CONFIRMATION when \"it seems necessary\".
makefile-browser-hook:
;;;***
\f
;;;### (autoloads (make-command-summary) "makesum" "makesum.el" (13229
-;;;;;; 28914))
+;;;;;; 28917))
;;; Generated autoloads from makesum.el
(autoload (quote make-command-summary) "makesum" "\
;;;***
\f
-;;;### (autoloads (man-follow man) "man" "man.el" (14203 50437))
+;;;### (autoloads (man-follow man) "man" "man.el" (14583 33482))
;;; Generated autoloads from man.el
(defalias (quote manual-entry) (quote man))
;;;;;; 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 49476))
+;;;;;; message-from-style) "message" "gnus/message.el" (14030 49419))
;;; Generated autoloads from gnus/message.el
(defvar message-from-style (quote default) "\
;;;***
\f
;;;### (autoloads (metapost-mode metafont-mode) "meta-mode" "progmodes/meta-mode.el"
-;;;;;; (13549 38921))
+;;;;;; (13549 39401))
;;; Generated autoloads from progmodes/meta-mode.el
(autoload (quote metafont-mode) "meta-mode" "\
\f
;;;### (autoloads (metamail-region metamail-buffer metamail-interpret-body
;;;;;; metamail-interpret-header) "metamail" "mail/metamail.el"
-;;;;;; (13977 61527))
+;;;;;; (14345 52966))
;;; Generated autoloads from mail/metamail.el
(autoload (quote metamail-interpret-header) "metamail" "\
;;;***
\f
;;;### (autoloads (mh-letter-mode mh-smail-other-window mh-smail-batch
-;;;;;; mh-smail) "mh-comp" "mail/mh-comp.el" (14042 3200))
+;;;;;; mh-smail) "mh-comp" "mail/mh-comp.el" (14600 36202))
;;; 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" (13644
-;;;;;; 7194))
+;;;### (autoloads (mh-version mh-rmail) "mh-e" "mail/mh-e.el" (14532
+;;;;;; 63447))
;;; Generated autoloads from mail/mh-e.el
(autoload (quote mh-rmail) "mh-e" "\
;;;***
\f
-;;;### (autoloads nil "mh-mime" "mail/mh-mime.el" (13833 28041))
+;;;### (autoloads nil "mh-mime" "mail/mh-mime.el" (13833 28022))
;;; Generated autoloads from mail/mh-mime.el
(defvar mh-mime-content-types (quote (("text/plain") ("text/richtext") ("multipart/mixed") ("multipart/alternative") ("multipart/digest") ("multipart/parallel") ("message/rfc822") ("message/partial") ("message/external-body") ("application/octet-stream") ("application/postscript") ("image/jpeg") ("image/gif") ("audio/basic") ("video/mpeg"))) "\
;;;***
\f
-;;;### (autoloads nil "mh-utils" "mail/mh-utils.el" (14091 60586))
+;;;### (autoloads nil "mh-utils" "mail/mh-utils.el" (14457 61243))
;;; 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 9946))
+;;;;;; "midnight.el" (14035 10445))
;;; Generated autoloads from midnight.el
(autoload (quote clean-buffer-list) "midnight" "\
;;;***
\f
;;;### (autoloads (modula-2-mode) "modula2" "progmodes/modula2.el"
-;;;;;; (13552 32650))
+;;;;;; (13552 32940))
;;; Generated autoloads from progmodes/modula2.el
(autoload (quote modula-2-mode) "modula2" "\
;;;***
\f
;;;### (autoloads (mouse-sel-mode) "mouse-sel" "mouse-sel.el" (14118
-;;;;;; 2269))
+;;;;;; 2283))
;;; Generated autoloads from mouse-sel.el
(autoload (quote mouse-sel-mode) "mouse-sel" "\
;;;***
\f
-;;;### (autoloads (mpuz) "mpuz" "play/mpuz.el" (14184 34398))
+;;;### (autoloads (mpuz) "mpuz" "play/mpuz.el" (14184 34750))
;;; Generated autoloads from play/mpuz.el
(autoload (quote mpuz) "mpuz" "\
;;;***
\f
-;;;### (autoloads (msb-mode msb-mode) "msb" "msb.el" (14162 41143))
+;;;### (autoloads (msb-mode msb-mode) "msb" "msb.el" (14555 52300))
;;; Generated autoloads from msb.el
(defvar msb-mode nil "\
;;;***
\f
;;;### (autoloads (dump-codings dump-charsets mule-diag list-input-methods
-;;;;;; list-fontsets describe-fontset describe-font list-coding-systems
-;;;;;; describe-current-coding-system describe-current-coding-system-briefly
-;;;;;; describe-coding-system list-character-sets) "mule-diag" "international/mule-diag.el"
-;;;;;; (14184 58760))
+;;;;;; list-fontsets describe-fontset describe-font list-coding-categories
+;;;;;; list-coding-systems describe-current-coding-system describe-current-coding-system-briefly
+;;;;;; describe-coding-system describe-char-after list-charset-chars
+;;;;;; read-charset list-character-sets) "mule-diag" "international/mule-diag.el"
+;;;;;; (14621 5038))
;;; Generated autoloads from international/mule-diag.el
(autoload (quote list-character-sets) "mule-diag" "\
Display a list of all character sets.
-The ID column contains a charset identification number for internal Emacs use.
-The B column contains a number of bytes occupied in a buffer
- by any character in this character set.
-The W column contains a number of columns occupied on the screen
- by any character in this character set.
+The ID-NUM column contains a charset identification number
+ for internal Emacs use.
+
+The MULTIBYTE-FORM column contains a format of multibyte sequence
+ of characters in the charset for buffer and string
+ by one to four hexadecimal digits.
+ `xx' stands for any byte in the range 0..127.
+ `XX' stands for any byte in the range 160..255.
+
+The D column contains a dimension of this character set.
+The CH column contains a number of characters in a block of this character set.
+The FINAL-CHAR column contains an ISO-2022's <final-char> to use for
+ designating this character set in ISO-2022-based coding systems.
With prefix arg, the output format gets more cryptic,
but still shows the full information." t nil)
+(autoload (quote read-charset) "mule-diag" "\
+Read a character set from the minibuffer, prompting with string PROMPT.
+It reads an Emacs' character set listed in the variable `charset-list'
+or a non-ISO character set listed in the variable
+`non-iso-charset-alist'.
+
+Optional arguments are DEFAULT-VALUE and INITIAL-INPUT.
+DEFAULT-VALUE, if non-nil, is the default value.
+INITIAL-INPUT, if non-nil, is a string inserted in the minibuffer initially.
+See the documentation of the function `completing-read' for the
+detailed meanings of these arguments." nil nil)
+
+(autoload (quote list-charset-chars) "mule-diag" "\
+Display a list of characters in the specified character set." 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)
With prefix arg, the output format gets more cryptic,
but still contains full information about each coding system." t nil)
+(autoload (quote list-coding-categories) "mule-diag" "\
+Display a list of all coding categories." nil nil)
+
(autoload (quote describe-font) "mule-diag" "\
Display information about fonts which partially match FONTNAME." 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.
;;;***
\f
-;;;### (autoloads (decompose-composite-char compose-chars compose-chars-component
-;;;;;; decompose-string decompose-region compose-region detect-coding-with-language-environment
-;;;;;; detect-coding-with-priority coding-system-equal coding-system-translation-table-for-encode
+;;;### (autoloads (detect-coding-with-language-environment detect-coding-with-priority
+;;;;;; coding-system-equal coding-system-translation-table-for-encode
;;;;;; coding-system-translation-table-for-decode coding-system-pre-write-conversion
;;;;;; 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"
-;;;;;; (14184 58760))
+;;;;;; (14568 36382))
;;; 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)
(autoload (quote truncate-string-to-width) "mule-util" "\
Truncate string STR to end at column END-COLUMN.
-The optional 2nd arg START-COLUMN, if non-nil, specifies
+The optional 3rd arg START-COLUMN, if non-nil, specifies
the starting column; that means to return the characters occupying
columns START-COLUMN ... END-COLUMN of STR.
-The optional 3rd arg PADDING, if non-nil, specifies a padding character
+The optional 4th arg PADDING, if non-nil, specifies a padding character
to add at the end of the result if STR doesn't reach column END-COLUMN,
or if END-COLUMN comes in the middle of a character in STR.
PADDING is also added at the beginning of the result
(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.
The detection takes into account the coding system priorities for the
language environment LANG-ENV." nil nil)
-(autoload (quote compose-region) "mule-util" "\
-Compose all characters in the current region into one composite character.
-When called from a program, expects two arguments,
-positions (integers or markers) specifying the region." t nil)
-
-(autoload (quote decompose-region) "mule-util" "\
-Decompose all composite characters in the current region.
-Composite characters are broken up into individual components.
-When called from a program, expects two arguments,
-positions (integers or markers) specifying the region." t nil)
-
-(autoload (quote decompose-string) "mule-util" "\
-Decompose all composite characters in STRING." nil nil)
-
-(defconst reference-point-alist (quote ((tl . 0) (tc . 1) (tr . 2) (ml . 3) (mc . 4) (mr . 5) (bl . 6) (bc . 7) (br . 8) (top-left . 0) (top-center . 1) (top-right . 2) (mid-left . 3) (mid-center . 4) (mid-right . 5) (bottom-left . 6) (bottom-center . 7) (bottom-right . 8) (0 . 0) (1 . 1) (2 . 2) (3 . 3) (4 . 4) (5 . 5) (6 . 6) (7 . 7) (8 . 8))) "\
-Alist of reference point symbols vs reference point codes.
-A reference point symbol is to be used to specify a composition rule
-while making a composite character by the function `compose-chars'
-\(which see).
-
-Meanings of reference point codes are as follows:
-
- 0----1----2 <-- ascent 0:tl or top-left
- | | 1:tc or top-center
- | | 2:tr or top-right
- | | 3:ml or mid-left
- | 4 <--+---- center 4:mc or mid-center
- | | 5:mr or mid-right
---- 3 5 <-- baseline 6:bl or bottom-left
- | | 7:bc or bottom-center
- 6----7----8 <-- descent 8:br or bottom-right
-
-Reference point symbols are to be used to specify composition rule of
-the form (GLOBAL-REF-POINT . NEW-REF-POINT), where GLOBAL-REF-POINT
-is a reference point in the overall glyphs already composed, and
-NEW-REF-POINT is a reference point in the new glyph to be added.
-
-For instance, if GLOBAL-REF-POINT is 8 and NEW-REF-POINT is 1, the
-overall glyph is updated as follows:
-
- +-------+--+ <--- new ascent
- | | |
- | global| |
- | glyph | |
---- | | | <--- baseline (doesn't change)
- +----+--+--+
- | | new |
- | |glyph|
- +----+-----+ <--- new descent
-")
-
-(autoload (quote compose-chars-component) "mule-util" nil nil nil)
-
-(autoload (quote compose-chars) "mule-util" "\
-Return one char string composed from the arguments.
-For relative composition, each argument should be a non-composition character
-or a relative-composition character.
-For rule-based composition, Nth (where N is odd) argument should be
-a non-composition character or a rule-based-composition character,
-and Mth (where M is even) argument should be a composition rule.
-A composition rule has the form (GLOBAL-REF-POINT . NEW-REF-POINT).
-See the documentation of `reference-point-alist' for more detail." nil nil)
+;;;***
+\f
+;;;### (autoloads (mwheel-install) "mwheel" "mwheel.el" (14378 51930))
+;;; Generated autoloads from mwheel.el
-(autoload (quote decompose-composite-char) "mule-util" "\
-Convert composite character CHAR to a sequence of the components.
-Optional 1st arg TYPE specifies the type of sequence returned.
-It should be `string' (default), `list', or `vector'.
-Optional 2nd arg WITH-COMPOSITION-RULE non-nil means the returned
-sequence contains embedded composition rules if any. In this case, the
-order of elements in the sequence is the same as arguments for
-`compose-chars' to create CHAR.
-If TYPE is omitted or is `string', composition rules are omitted
-even if WITH-COMPOSITION-RULE is t." nil nil)
+(autoload (quote mwheel-install) "mwheel" "\
+Enable mouse wheel support." nil nil)
;;;***
\f
;;;### (autoloads (network-connection network-connection-to-service
-;;;;;; whois-reverse-lookup whois finger ftp nslookup nslookup-host
-;;;;;; route arp netstat ipconfig ping traceroute) "net-utils" "net-utils.el"
-;;;;;; (13870 8854))
-;;; Generated autoloads from net-utils.el
+;;;;;; whois-reverse-lookup whois finger ftp dig nslookup nslookup-host
+;;;;;; route arp netstat ipconfig ping traceroute) "net-utils" "net/net-utils.el"
+;;;;;; (14564 29931))
+;;; Generated autoloads from net/net-utils.el
(autoload (quote traceroute) "net-utils" "\
Run traceroute program for TARGET." t nil)
(autoload (quote nslookup) "net-utils" "\
Run nslookup program." t nil)
+(autoload (quote dig) "net-utils" "\
+Run dig program." t nil)
+
(autoload (quote ftp) "net-utils" "\
Run ftp program." t nil)
;;;***
\f
;;;### (autoloads (nndoc-add-type) "nndoc" "gnus/nndoc.el" (14030
-;;;;;; 49490))
+;;;;;; 49432))
;;; Generated autoloads from gnus/nndoc.el
(autoload (quote nndoc-add-type) "nndoc" "\
;;;***
\f
;;;### (autoloads (nnfolder-generate-active-file) "nnfolder" "gnus/nnfolder.el"
-;;;;;; (14030 49496))
+;;;;;; (14030 49439))
;;; Generated autoloads from gnus/nnfolder.el
(autoload (quote nnfolder-generate-active-file) "nnfolder" "\
;;;***
\f
;;;### (autoloads (nnkiboze-generate-groups) "nnkiboze" "gnus/nnkiboze.el"
-;;;;;; (14030 49502))
+;;;;;; (14030 49445))
;;; Generated autoloads from gnus/nnkiboze.el
(autoload (quote nnkiboze-generate-groups) "nnkiboze" "\
;;;***
\f
;;;### (autoloads (nnml-generate-nov-databases) "nnml" "gnus/nnml.el"
-;;;;;; (14030 49514))
+;;;;;; (14030 49457))
;;; 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" (14030 49518))
+;;;;;; "nnsoup" "gnus/nnsoup.el" (14293 3539))
;;; Generated autoloads from gnus/nnsoup.el
(autoload (quote nnsoup-pack-replies) "nnsoup" "\
;;;***
\f
;;;### (autoloads (disable-command enable-command disabled-command-hook)
-;;;;;; "novice" "novice.el" (13229 29108))
+;;;;;; "novice" "novice.el" (13229 29111))
;;; Generated autoloads from novice.el
(defvar disabled-command-hook (quote disabled-command-hook) "\
;;;***
\f
;;;### (autoloads (nroff-mode) "nroff-mode" "textmodes/nroff-mode.el"
-;;;;;; (13611 44372))
+;;;;;; (13382 24740))
;;; Generated autoloads from textmodes/nroff-mode.el
(autoload (quote nroff-mode) "nroff-mode" "\
;;;***
\f
;;;### (autoloads (octave-help) "octave-hlp" "progmodes/octave-hlp.el"
-;;;;;; (13145 50262))
+;;;;;; (13145 50478))
;;; Generated autoloads from progmodes/octave-hlp.el
(autoload (quote octave-help) "octave-hlp" "\
;;;***
\f
;;;### (autoloads (inferior-octave) "octave-inf" "progmodes/octave-inf.el"
-;;;;;; (14211 48115))
+;;;;;; (14302 32388))
;;; Generated autoloads from progmodes/octave-inf.el
(autoload (quote inferior-octave) "octave-inf" "\
;;;***
\f
;;;### (autoloads (octave-mode) "octave-mod" "progmodes/octave-mod.el"
-;;;;;; (13935 15541))
+;;;;;; (14535 42068))
;;; Generated autoloads from progmodes/octave-mod.el
(autoload (quote octave-mode) "octave-mod" "\
;;;***
\f
;;;### (autoloads (edit-options list-options) "options" "options.el"
-;;;;;; (14045 29891))
+;;;;;; (14045 29847))
;;; Generated autoloads from options.el
(autoload (quote list-options) "options" "\
;;;***
\f
;;;### (autoloads (outline-minor-mode outline-mode) "outline" "textmodes/outline.el"
-;;;;;; (14115 62973))
+;;;;;; (14495 18064))
;;; Generated autoloads from textmodes/outline.el
(autoload (quote outline-mode) "outline" "\
;;;***
\f
-;;;### (autoloads (show-paren-mode) "paren" "paren.el" (14118 2930))
+;;;### (autoloads (show-paren-mode show-paren-mode) "paren" "paren.el"
+;;;;;; (14316 49544))
;;; 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.
+Setting this variable directly does not take effect;
+use either \\[customize] or the function `show-paren-mode'.")
+
+(custom-add-to-group (quote paren-showing) (quote show-paren-mode) (quote custom-variable))
+
+(custom-add-load (quote show-paren-mode) (quote paren))
+
(autoload (quote show-paren-mode) "paren" "\
Toggle Show Paren mode.
With prefix ARG, turn Show Paren mode on if and only if ARG is positive.
;;;***
\f
-;;;### (autoloads (pascal-mode) "pascal" "progmodes/pascal.el" (14218
-;;;;;; 4426))
+;;;### (autoloads (pascal-mode) "pascal" "progmodes/pascal.el" (14507
+;;;;;; 63078))
;;; Generated autoloads from progmodes/pascal.el
(autoload (quote pascal-mode) "pascal" "\
;;;***
\f
;;;### (autoloads (pc-bindings-mode) "pc-mode" "emulation/pc-mode.el"
-;;;;;; (13229 29211))
+;;;;;; (13229 29217))
;;; Generated autoloads from emulation/pc-mode.el
(autoload (quote pc-bindings-mode) "pc-mode" "\
;;;***
\f
;;;### (autoloads (pc-selection-mode pc-selection-mode) "pc-select"
-;;;;;; "emulation/pc-select.el" (13674 34130))
+;;;;;; "emulation/pc-select.el" (13674 34216))
;;; 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" (14619 3307))
+;;; Generated autoloads from pcvs.el
+
+(autoload (quote cvs-checkout) "pcvs" "\
+Run a 'cvs checkout MODULES' in DIR.
+Feed the output to a *cvs* buffer, display it in the current window,
+and run `cvs-mode' on it.
+
+With a prefix argument, prompt for cvs FLAGS to use." 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.
+Feed the output to a *cvs* buffer and run `cvs-mode' on it.
+With a prefix argument, prompt for a directory and cvs FLAGS 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." t nil)
+
+(autoload (quote cvs-update) "pcvs" "\
+Run a `cvs update' in the current working DIRECTORY.
+Feed the output to a *cvs* buffer and run `cvs-mode' on it.
+With a prefix argument, prompt for a directory and cvs FLAGS to use.
+A prefix arg >8 (ex: \\[universal-argument] \\[universal-argument]),
+ prevents reuse of an existing *cvs* buffer." t nil)
+
+(autoload (quote cvs-status) "pcvs" "\
+Run a `cvs status' in the current working DIRECTORY.
+Feed the output to a *cvs* buffer and run `cvs-mode' on it.
+With a prefix argument, prompt for a directory and cvs FLAGS 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." t nil)
+
+(add-to-list (quote completion-ignored-extensions) "CVS/")
+
+(defvar cvs-dired-use-hook (quote (4)) "\
+Whether or not opening a CVS directory should run PCL-CVS.
+NIL means never do it.
+ALWAYS means to always do it unless a prefix argument is given to the
+ 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))))))
+
+;;;***
+\f
+;;;### (autoloads nil "pcvs-defs" "pcvs-defs.el" (14552 48685))
+;;; 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 60556))
+;;;;;; (13639 61036))
;;; Generated autoloads from progmodes/perl-mode.el
(autoload (quote perl-mode) "perl-mode" "\
;;;***
\f
-;;;### (autoloads (ph-query-form ph-expand-inline ph-get-phone ph-get-email)
-;;;;;; "ph" "ph.el" (13623 48498))
-;;; Generated autoloads from ph.el
-
-(autoload (quote ph-get-email) "ph" "\
-Get the email field of NAME from the PH/QI directory server." t nil)
-
-(autoload (quote ph-get-phone) "ph" "\
-Get the phone field of NAME from the PH/QI directory server." t nil)
-
-(autoload (quote ph-expand-inline) "ph" "\
-Query the PH server, and expand the query string before point.
-The query string consists of the buffer substring from the point back to
-the preceding comma, colon or beginning of line. If it contains more than
-one word, the variable `ph-inline-query-format-list' controls to map these
-onto CCSO database field names.
-After querying the server for the given string, the expansion specified by
-`ph-inline-expansion-format' is inserted in the buffer at point.
-If REPLACE is t, then this expansion replaces the name in the buffer.
-If `ph-expanding-overwrites-query' is t, that inverts the meaning of REPLACE." t nil)
-
-(autoload (quote ph-query-form) "ph" "\
-Display a form to query the CCSO PH/QI nameserver.
-If given a non-nil argument the function first queries the server
-for the existing fields and displays a corresponding form." t nil)
-
-;;;***
-\f
;;;### (autoloads (picture-mode) "picture" "textmodes/picture.el"
-;;;;;; (13906 30600))
+;;;;;; (14348 33291))
;;; Generated autoloads from textmodes/picture.el
(autoload (quote picture-mode) "picture" "\
;;;***
\f
+;;;### (autoloads (pong) "pong" "play/pong.el" (14453 55473))
+;;; Generated autoloads from play/pong.el
+
+(autoload (quote pong) "pong" "\
+Play pong and waste time.
+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-map}" t nil)
+
+;;;***
+\f
;;;### (autoloads (pp-eval-last-sexp pp-eval-expression pp) "pp"
-;;;;;; "emacs-lisp/pp.el" (13819 15913))
+;;;;;; "emacs-lisp/pp.el" (13819 15860))
;;; Generated autoloads from emacs-lisp/pp.el
(autoload (quote pp) "pp" "\
;;;***
\f
;;;### (autoloads (run-prolog prolog-mode) "prolog" "progmodes/prolog.el"
-;;;;;; (13446 12642))
+;;;;;; (13446 12665))
;;; Generated autoloads from progmodes/prolog.el
(autoload (quote prolog-mode) "prolog" "\
;;;***
\f
-;;;### (autoloads nil "ps-bdf" "ps-bdf.el" (14053 43936))
+;;;### (autoloads nil "ps-bdf" "ps-bdf.el" (14353 44101))
;;; Generated autoloads from ps-bdf.el
(defvar bdf-directory-list (if (eq system-type (quote ms-dos)) (list (expand-file-name "fonts/bdf" installation-directory)) (quote ("/usr/local/share/emacs/fonts/bdf"))) "\
;;;***
\f
+;;;### (autoloads (ps-mode) "ps-mode" "progmodes/ps-mode.el" (14380
+;;;;;; 3795))
+;;; Generated autoloads from progmodes/ps-mode.el
+
+(autoload (quote ps-mode) "ps-mode" "\
+Major mode for editing PostScript with GNU Emacs.
+
+Entry to this mode calls `ps-mode-hook'.
+
+The following variables hold user options, and can
+be set through the `customize' command:
+
+ ps-mode-auto-indent
+ ps-mode-tab
+ ps-mode-paper-size
+ ps-mode-print-function
+ ps-run-prompt
+ ps-run-font-lock-keywords-2
+ ps-run-x
+ ps-run-dumb
+ ps-run-init
+ ps-run-error-line-numbers
+ ps-run-tmp-dir
+
+Type \\[describe-variable] for documentation on these options.
+
+
+\\{ps-mode-map}
+
+
+When starting an interactive PostScript process with \\[ps-run-start],
+a second window will be displayed, and `ps-run-mode-hook' will be called.
+The keymap for this second window is:
+
+\\{ps-run-mode-map}
+
+
+When Ghostscript encounters an error it displays an error message
+with a file position. Clicking mouse-2 on this number will bring
+point to the corresponding spot in the PostScript window, if input
+to the interpreter was sent from that window.
+Typing \\<ps-run-mode-map>\\[ps-run-goto-error] when the cursor is at the number has the same effect.
+" t nil)
+
+;;;***
+\f
;;;### (autoloads (ps-mule-begin-page ps-mule-begin-job ps-mule-initialize
-;;;;;; ps-mule-plot-string ps-mule-set-ascii-font ps-mule-prepare-ascii-font
-;;;;;; ps-multibyte-buffer) "ps-mule" "ps-mule.el" (14138 30128))
+;;;;;; 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" (14588 21278))
;;; Generated autoloads from ps-mule.el
(defvar ps-multibyte-buffer nil "\
changed by setting the variable
`ps-mule-font-info-database-default' differently.
The initial value of this variable is
- `ps-mule-font-info-database-latin' (which see).
+ `ps-mule-font-info-database-latin' (see
+ documentation).
`non-latin-printer' This is the value to use when you have a Japanese
or Korean PostScript printer and want to print
Where ENDPOS is the end position of the sequence and RUN-WIDTH is the width of
the sequence." nil nil)
+(autoload (quote ps-mule-plot-composition) "ps-mule" "\
+Generate PostScript code for ploting composition in the region FROM and TO.
+
+It is assumed that all characters in this region belong to the same
+composition.
+
+Optional argument BG-COLOR specifies background color.
+
+Returns the value:
+
+ (ENDPOS . RUN-WIDTH)
+
+Where ENDPOS is the end position of the sequence and RUN-WIDTH is the width of
+the sequence." nil nil)
+
(autoload (quote ps-mule-initialize) "ps-mule" "\
Initialize global data for printing multi-byte characters." nil nil)
;;;;;; ps-nb-pages-buffer ps-line-lengths ps-despool ps-spool-region-with-faces
;;;;;; 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-paper-type) "ps-print" "ps-print.el" (14182
-;;;;;; 2572))
+;;;;;; ps-print-buffer ps-print-customize ps-paper-type) "ps-print"
+;;;;;; "ps-print.el" (14602 58229))
;;; Generated autoloads from ps-print.el
(defvar ps-paper-type (quote letter) "\
-*Specifies the size of paper to format for.
+*Specify the size of paper to format for.
Should be one of the paper types defined in `ps-page-dimensions-database', for
example `letter', `legal' or `a4'.")
+(autoload (quote ps-print-customize) "ps-print" "\
+Customization of ps-print group." t nil)
+
(autoload (quote ps-print-buffer) "ps-print" "\
Generate and print a PostScript image of the buffer.
;;;### (autoloads (quail-update-leim-list-file quail-defrule-internal
;;;;;; quail-defrule quail-install-map quail-define-rules quail-set-keyboard-layout
;;;;;; quail-define-package quail-use-package) "quail" "international/quail.el"
-;;;;;; (14171 42620))
+;;;;;; (14551 28773))
;;; Generated autoloads from international/quail.el
(autoload (quote quail-use-package) "quail" "\
(autoload (quote quail-install-map) "quail" "\
Install the Quail map 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 map can be referred by the function `quail-map'." nil nil)
(autoload (quote quail-defrule) "quail" "\
\f
;;;### (autoloads (quickurl-list quickurl-list-mode quickurl-edit-urls
;;;;;; quickurl-browse-url-ask quickurl-browse-url quickurl-add-url
-;;;;;; quickurl-ask quickurl) "quickurl" "../../../../gd/gnu/emacs/lisp/quickurl.el"
-;;;;;; (14286 57107))
-;;; Generated autoloads from ../../../../gd/gnu/emacs/lisp/quickurl.el
+;;;;;; quickurl-ask quickurl) "quickurl" "net/quickurl.el" (14554
+;;;;;; 7245))
+;;; 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" "\
Example `quickurl-postfix' text that adds a local variable to the
;;;***
\f
-;;;### (autoloads (remote-compile) "rcompile" "rcompile.el" (13149
-;;;;;; 16506))
-;;; Generated autoloads from rcompile.el
+;;;### (autoloads (remote-compile) "rcompile" "net/rcompile.el" (13149
+;;;;;; 16808))
+;;; Generated autoloads from net/rcompile.el
(autoload (quote remote-compile) "rcompile" "\
Compile the the current buffer's directory on HOST. Log in as USER.
;;;***
\f
-;;;### (autoloads (clear-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" (13926 23562))
+;;;### (autoloads (re-builder) "re-builder" "emacs-lisp/re-builder.el"
+;;;;;; (14539 41135))
+;;; Generated autoloads from emacs-lisp/re-builder.el
+
+(autoload (quote re-builder) "re-builder" "\
+Call up the RE Builder for the current window." t nil)
+
+;;;***
+\f
+;;;### (autoloads (recentf-open-more-files recentf-cleanup recentf-edit-list
+;;;;;; recentf-save-list recentf-mode) "recentf" "recentf.el" (14539
+;;;;;; 49146))
+;;; 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-edit-list) "recentf" "\
+Allow the user to edit the files that are kept in the recent list." t nil)
+
+(autoload (quote recentf-cleanup) "recentf" "\
+Remove all non-readable and excluded files from `recentf-list'." t nil)
+
+(autoload (quote recentf-open-more-files) "recentf" "\
+Allow the user to open files that are not in the menu." 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))
;;; Generated autoloads from rect.el
(autoload (quote move-to-column-force) "rect" "\
Move point to column COLUMN rigidly in the current line.
If COLUMN is within a multi-column character, replace it by
-spaces and tab." nil nil)
+spaces and tab.
+
+As for `move-to-column', passing anything but nil or t in FLAG will move to
+the desired column only if the line is long enough." nil nil)
(autoload (quote delete-rectangle) "rect" "\
-Delete (don't save) text in rectangle with point and mark as corners.
-The same range of columns is deleted in each line starting with the line
-where the region begins and ending with the line where the region ends." t nil)
+Delete (don't save) text in the region-rectangle.
+The same range of columns is deleted in each line starting with the
+line where the region begins and ending with the line where the region
+ends.
+
+When called from a program the rectangle's corners are START and END.
+With a prefix (or a FILL) argument, also fill lines where nothing has
+to be deleted." t nil)
(autoload (quote delete-extract-rectangle) "rect" "\
-Delete contents of rectangle and return it as a list of strings.
-Arguments START and END are the corners of the rectangle.
-The value is list of strings, one for each line of the rectangle." nil nil)
+Delete the contents of the rectangle with corners at START and END.
+Return it as a list of strings, one for each line of the rectangle.
+
+When called from a program the rectangle's corners are START and END.
+With an optional FILL argument, also fill lines where nothing has to be
+deleted." nil nil)
(autoload (quote extract-rectangle) "rect" "\
-Return contents of rectangle with corners at START and END.
-Value is list of strings, one for each line of the rectangle." nil nil)
+Return the contents of the rectangle with corners at START and END.
+Return it as a list of strings, one for each line of the rectangle." nil nil)
(autoload (quote kill-rectangle) "rect" "\
-Delete rectangle with corners at point and mark; save as last killed one.
-Calling from program, supply two args START and END, buffer positions.
-But in programs you might prefer to use `delete-extract-rectangle'." t nil)
+Delete the region-rectangle and save it as the last killed one.
+
+When called from a program the rectangle's corners are START and END.
+You might prefer to use `delete-extract-rectangle' from a program.
+
+With a prefix (or a FILL) argument, also fill lines where nothing has to be
+deleted." t nil)
(autoload (quote yank-rectangle) "rect" "\
Yank the last killed rectangle with upper left corner at point." t nil)
and point is at the lower right corner." nil nil)
(autoload (quote open-rectangle) "rect" "\
-Blank out rectangle with corners at point and mark, shifting text right.
+Blank out the region-rectangle, shifting text right.
+
The text previously in the region is not overwritten by the blanks,
-but instead winds up to the right of the rectangle." t nil)
+but instead winds up to the right of the rectangle.
+
+When called from a program the rectangle's corners are START and END.
+With a prefix (or a FILL) argument, fill with blanks even if there is no text
+on the right side of the rectangle." t nil)
(defalias 'close-rectangle 'delete-whitespace-rectangle) ;; Old name
(autoload (quote delete-whitespace-rectangle) "rect" "\
Delete all whitespace following a specified column in each line.
The left edge of the rectangle specifies the position in each line
at which whitespace deletion should begin. On each line in the
-rectangle, all continuous whitespace starting at that column is deleted." t nil)
+rectangle, all continuous whitespace starting at that column is deleted.
+
+When called from a program the rectangle's corners are START and END.
+With a prefix (or a FILL) argument, also fill too short lines." t nil)
(autoload (quote string-rectangle) "rect" "\
-Replace rectangle contents with STRING on each line.
-The length of STRING need not be the same as the rectangle width.
+Insert STRING on each line of the region-rectangle, shifting text right.
+
+When called from a program the rectangle's corners are START and END.
+The left edge of the rectangle specifies the column for insertion.
+This command does not delete or overwrite any existing text." t nil)
-Called from a program, takes three args; START, END and STRING." t nil)
+(autoload (quote replace-rectangle) "rect" "\
+Like `string-rectangle', but replace the original region." t nil)
(autoload (quote clear-rectangle) "rect" "\
-Blank out rectangle with corners at point and mark.
-The text previously in the region is overwritten by the blanks.
-When called from a program, requires two args which specify the corners." t nil)
+Blank out the region-rectangle.
+The text previously in the region is overwritten with blanks.
+
+When called from a program the rectangle's corners are START and END.
+With a prefix (or a FILL) argument, also fill with blanks the parts of the
+rectangle which were empty." t nil)
;;;***
\f
-;;;### (autoloads (reftex-citation reftex-mode turn-on-reftex) "reftex"
-;;;;;; "textmodes/reftex.el" (14198 46022))
+;;;### (autoloads (reftex-mode turn-on-reftex) "reftex" "textmodes/reftex.el"
+;;;;;; (14495 18077))
;;; Generated autoloads from textmodes/reftex.el
(autoload (quote turn-on-reftex) "reftex" "\
(autoload (quote reftex-mode) "reftex" "\
Minor mode with distinct support for \\label, \\ref and \\cite in LaTeX.
+\\<reftex-mode-map>A Table of Contents of the entire (multifile) document with browsing
+capabilities is available with `\\[reftex-toc]'.
+
Labels can be created with `\\[reftex-label]' and referenced with `\\[reftex-reference]'.
When referencing, you get a menu with all labels of a given type and
context of the label definition. The selected label is inserted as a
to pull out a *formatted* list of articles from your BibTeX
database. The selected citation is inserted as a \\cite macro.
-A Table of Contents of the entire (multifile) document with browsing
-capabilities is available with `\\[reftex-toc]'.
+Index entries can be made with `\\[reftex-index-selection-or-word]' which indexes the word at point
+or the current selection. More general index entries are created with
+`\\[reftex-index]'. `\\[reftex-display-index]' displays the compiled index.
Most command have help available on the fly. This help is accessed by
pressing `?' to any prompt mentioning this feature.
------------------------------------------------------------------------------" t nil)
-(autoload (quote reftex-citation) "reftex" "\
+;;;***
+\f
+;;;### (autoloads (reftex-citation) "reftex-cite" "textmodes/reftex-cite.el"
+;;;;;; (14495 18066))
+;;; Generated autoloads from textmodes/reftex-cite.el
+
+(autoload (quote reftex-citation) "reftex-cite" "\
Make a citation using BibTeX database files.
After prompting for a regular expression, scans the buffers with
bibtex entries (taken from the \\bibliography command) and offers the
If NO-INSERT is non-nil, nothing is inserted, only the selected key returned.
+FORAT-KEY can be used to pre-select a citation format.
+
When called with one or two `C-u' prefixes, first rescans the document.
When called with a numeric prefix, make that many citations. When
called with point inside the braces of a `cite' command, it will
;;;***
\f
+;;;### (autoloads (reftex-index-phrases-mode) "reftex-index" "textmodes/reftex-index.el"
+;;;;;; (14495 18068))
+;;; Generated autoloads from textmodes/reftex-index.el
+
+(autoload (quote reftex-index-phrases-mode) "reftex-index" "\
+Major mode for managing the Index phrases of a LaTeX document.
+This buffer was created with RefTeX.
+
+To insert new phrases, use
+ - `C-c \\' in the LaTeX document to copy selection or word
+ - `\\[reftex-index-new-phrase]' in the phrases buffer.
+
+To index phrases use one of:
+
+\\[reftex-index-this-phrase] index current phrase
+\\[reftex-index-next-phrase] index next phrase (or N with prefix arg)
+\\[reftex-index-all-phrases] index all phrases
+\\[reftex-index-remaining-phrases] index current and following phrases
+\\[reftex-index-region-phrases] index the phrases in the region
+
+You can sort the phrases in this buffer with \\[reftex-index-sort-phrases].
+To display information about the phrase at point, use \\[reftex-index-phrases-info].
+
+For more information see the RefTeX User Manual.
+
+Here are all local bindings.
+
+\\{reftex-index-phrases-map}" t nil)
+
+;;;***
+\f
;;;### (autoloads (regexp-opt-depth regexp-opt) "regexp-opt" "emacs-lisp/regexp-opt.el"
-;;;;;; (14168 7138))
+;;;;;; (14619 3367))
;;; Generated autoloads from emacs-lisp/regexp-opt.el
(autoload (quote regexp-opt) "regexp-opt" "\
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))
-
-but typically contains more regexp grouping constructs.
-Use `regexp-opt-depth' to count them." nil nil)
+ (concat open-paren (mapconcat 'regexp-quote STRINGS \"\\\\|\") close-paren))" nil nil)
(autoload (quote regexp-opt-depth) "regexp-opt" "\
Return the depth of REGEXP.
;;;***
\f
-;;;### (autoloads (repeat) "repeat" "repeat.el" (14081 4553))
+;;;### (autoloads (repeat) "repeat" "repeat.el" (14081 4820))
;;; Generated autoloads from repeat.el
(autoload (quote repeat) "repeat" "\
;;;***
\f
;;;### (autoloads (reporter-submit-bug-report) "reporter" "mail/reporter.el"
-;;;;;; (13651 32636))
+;;;;;; (14356 24412))
;;; Generated autoloads from mail/reporter.el
-(autoload (quote reporter-submit-bug-report) "reporter" nil nil nil)
+(autoload (quote reporter-submit-bug-report) "reporter" "\
+Begin submitting a bug report via email.
+
+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).
+
+VARLIST is the list of variables to dump (see `reporter-dump-state'
+for details). The optional argument PRE-HOOKS and POST-HOOKS are
+passed to `reporter-dump-state'. Optional argument SALUTATION is text
+to be inserted at the top of the mail buffer; in that case, point is
+left after that text.
+
+This function prompts for a summary if `reporter-prompt-for-summary-p'
+is non-nil.
+
+This function does not send a message; it uses the given information
+to initialize a a messagem, which the user can then edit and finally send
+\(or decline to send). The variable `mail-user-agent' controls which
+mail-sending package is used for editing and sending the message." nil nil)
;;;***
\f
;;;### (autoloads (reposition-window) "reposition" "reposition.el"
-;;;;;; (13229 29313))
+;;;;;; (13229 29317))
;;; Generated autoloads from reposition.el
(autoload (quote reposition-window) "reposition" "\
;;;***
\f
;;;### (autoloads (make-ring ring-p) "ring" "emacs-lisp/ring.el"
-;;;;;; (13107 22379))
+;;;;;; (14283 6810))
;;; Generated autoloads from emacs-lisp/ring.el
(autoload (quote ring-p) "ring" "\
;;;***
\f
-;;;### (autoloads (rlogin) "rlogin" "rlogin.el" (13845 29546))
-;;; Generated autoloads from rlogin.el
+;;;### (autoloads (rlogin) "rlogin" "net/rlogin.el" (14550 7959))
+;;; Generated autoloads from net/rlogin.el
(add-hook 'same-window-regexps "^\\*rlogin-.*\\*\\(\\|<[0-9]+>\\)")
(autoload (quote rlogin) "rlogin" "\
;;;***
\f
;;;### (autoloads (rmail-set-pop-password rmail-input rmail-mode
-;;;;;; rmail rmail-enable-mime rmail-secondary-file-regexp rmail-secondary-file-directory
+;;;;;; 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" (14211 33252))
+;;;;;; "rmail" "mail/rmail.el" (14623 46032))
;;; Generated autoloads from mail/rmail.el
(defvar rmail-dont-reply-to-names nil "\
(defvar rmail-secondary-file-regexp "\\.xmail$" "\
*Regexp for which files are secondary Rmail files.")
+(defvar rmail-confirm-expunge (quote yes-or-no-p) "\
+*Whether and how to ask for confirmation before expunging deleted messages.")
+
(defvar rmail-mode-hook nil "\
List of functions to call when Rmail is invoked.")
(defvar rmail-show-message-hook nil "\
List of functions to call when Rmail displays a message.")
+(defvar rmail-quit-hook nil "\
+List of functions to call when quitting out of Rmail.")
+
(defvar rmail-delete-message-hook nil "\
List of functions to call when Rmail deletes a message.
When the hooks are called, the message has been marked deleted but is
;;;***
\f
;;;### (autoloads (rmail-edit-current-message) "rmailedit" "mail/rmailedit.el"
-;;;;;; (13738 33868))
+;;;;;; (14387 64145))
;;; Generated autoloads from mail/rmailedit.el
(autoload (quote rmail-edit-current-message) "rmailedit" "\
\f
;;;### (autoloads (rmail-next-labeled-message rmail-previous-labeled-message
;;;;;; rmail-read-label rmail-kill-label rmail-add-label) "rmailkwd"
-;;;;;; "mail/rmailkwd.el" (12875 8065))
+;;;;;; "mail/rmailkwd.el" (12875 8164))
;;; Generated autoloads from mail/rmailkwd.el
(autoload (quote rmail-add-label) "rmailkwd" "\
;;;***
\f
;;;### (autoloads (set-rmail-inbox-list) "rmailmsc" "mail/rmailmsc.el"
-;;;;;; (13772 51036))
+;;;;;; (13772 51133))
;;; Generated autoloads from mail/rmailmsc.el
(autoload (quote set-rmail-inbox-list) "rmailmsc" "\
\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 6366))
+;;;;;; "mail/rmailout.el" (14179 6393))
;;; Generated autoloads from mail/rmailout.el
(defvar rmail-output-file-alist nil "\
\f
;;;### (autoloads (rmail-sort-by-keywords rmail-sort-by-lines rmail-sort-by-correspondent
;;;;;; rmail-sort-by-recipient rmail-sort-by-author rmail-sort-by-subject
-;;;;;; rmail-sort-by-date) "rmailsort" "mail/rmailsort.el" (13051
-;;;;;; 48729))
+;;;;;; rmail-sort-by-date) "rmailsort" "mail/rmailsort.el" (13054
+;;;;;; 26387))
;;; Generated autoloads from mail/rmailsort.el
(autoload (quote rmail-sort-by-date) "rmailsort" "\
;;;***
\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"
-;;;;;; (14181 58887))
+;;;### (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" (14597 48840))
;;; 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"
-;;;;;; (13668 48323))
+;;;;;; (14263 36299))
;;; Generated autoloads from mail/rnewspost.el
(autoload (quote news-post-news) "rnewspost" "\
;;;***
\f
;;;### (autoloads (toggle-rot13-mode rot13-other-window) "rot13"
-;;;;;; "rot13.el" (13253 16866))
+;;;;;; "rot13.el" (12536 45574))
;;; Generated autoloads from rot13.el
(autoload (quote rot13-other-window) "rot13" "\
;;;### (autoloads (resize-minibuffer-mode resize-minibuffer-frame-exactly
;;;;;; resize-minibuffer-frame-max-height resize-minibuffer-frame
;;;;;; resize-minibuffer-window-exactly resize-minibuffer-window-max-height
-;;;;;; resize-minibuffer-mode) "rsz-mini" "rsz-mini.el" (14118 2329))
+;;;;;; resize-minibuffer-mode) "rsz-mini" "rsz-mini.el" (14301 25409))
;;; Generated autoloads from rsz-mini.el
(defvar resize-minibuffer-mode nil "\
-Toggle resizing the minibuffer so its entire contents are visible.
-Setting this variable directly does not take effect;
-use either \\[customize] or the function `resize-minibuffer-mode'.")
+*This variable is obsolete.")
(custom-add-to-group (quote resize-minibuffer) (quote resize-minibuffer-mode) (quote custom-variable))
(custom-add-load (quote resize-minibuffer-mode) (quote rsz-mini))
(defvar resize-minibuffer-window-max-height nil "\
-*Maximum size the minibuffer window is allowed to become.
-If less than 1 or not a number, the limit is the height of the frame in
-which the active minibuffer window resides.")
+*This variable is obsolete.")
(defvar resize-minibuffer-window-exactly t "\
-*Allow making minibuffer exactly the size to display all its contents.
-If `nil', the minibuffer window can temporarily increase in size but
-never get smaller while it is active. Any other value allows exact
-resizing.")
+*This variable is obsolete.")
(defvar resize-minibuffer-frame nil "\
-*Allow changing the frame height of minibuffer frames.
-If non-`nil' and the active minibuffer is the sole window in its frame,
-allow changing the frame height.")
+*This variable is obsolete.")
(defvar resize-minibuffer-frame-max-height nil "\
-*Maximum size the minibuffer frame is allowed to become.
-If less than 1 or not a number, there is no limit.")
+*This variable is obsolete.")
(defvar resize-minibuffer-frame-exactly t "\
-*Allow making minibuffer frame exactly the size to display all its contents.
-If `nil', the minibuffer frame can temporarily increase in size but
-never get smaller while it is active. Any other value allows exact
-resizing.")
+*This variable is obsolete.")
(autoload (quote resize-minibuffer-mode) "rsz-mini" "\
-Toggle resize-minibuffer mode.
-With argument, enable resize-minibuffer mode if and only if argument
-is positive.
-
-When this minor mode is enabled, the minibuffer is dynamically resized to
-contain the entire region of text put in it as you type.
-
-The variable `resize-minibuffer-mode' is set to t or nil depending on
-whether this mode is active or not.
-
-The maximum height to which the minibuffer can grow is controlled by the
-variable `resize-minibuffer-window-max-height'.
-
-The variable `resize-minibuffer-window-exactly' determines whether the
-minibuffer window should ever be shrunk to make it no larger than needed to
-display its contents.
-
-When using a window system, it is possible for a minibuffer to be the sole
-window in a frame. Since that window is already its maximum size, the only
-way to make more text visible at once is to increase the size of the frame.
-The variable `resize-minibuffer-frame' controls whether this should be
-done. The variables `resize-minibuffer-frame-max-height' and
-`resize-minibuffer-frame-exactly' are analogous to their window
-counterparts." t nil)
+This function is obsolete." t nil)
;;;***
\f
;;;### (autoloads (dsssl-mode scheme-mode) "scheme" "progmodes/scheme.el"
-;;;;;; (13730 29898))
+;;;;;; (14432 37919))
;;; Generated autoloads from progmodes/scheme.el
(autoload (quote scheme-mode) "scheme" "\
Major mode for editing Scheme code.
-Editing commands are similar to those of lisp-mode.
+Editing commands are similar to those of `lisp-mode'.
In addition, if an inferior Scheme process is running, some additional
commands will be defined, for evaluating expressions and controlling
Delete converts tabs to spaces as it moves back.
Blank lines separate paragraphs. Semicolons start comments.
\\{scheme-mode-map}
-Entry to this mode calls the value of scheme-mode-hook
+Entry to this mode calls the value of `scheme-mode-hook'
if that value is non-nil." t nil)
(autoload (quote dsssl-mode) "scheme" "\
Major mode for editing DSSSL code.
-Editing commands are similar to those of lisp-mode.
+Editing commands are similar to those of `lisp-mode'.
Commands:
Delete converts tabs to spaces as it moves back.
;;;***
\f
;;;### (autoloads (gnus-score-mode) "score-mode" "gnus/score-mode.el"
-;;;;;; (14030 49534))
+;;;;;; (14030 49477))
;;; Generated autoloads from gnus/score-mode.el
(autoload (quote gnus-score-mode) "score-mode" "\
;;;***
\f
-;;;### (autoloads (scribe-mode) "scribe" "textmodes/scribe.el" (13552
-;;;;;; 24630))
+;;;### (autoloads (scribe-mode) "scribe" "textmodes/scribe.el" (14381
+;;;;;; 55098))
;;; Generated autoloads from textmodes/scribe.el
(autoload (quote scribe-mode) "scribe" "\
Major mode for editing files of Scribe (a text formatter) source.
-Scribe-mode is similar text-mode, with a few extra commands added.
+Scribe-mode is similar to text-mode, with a few extra commands added.
\\{scribe-mode-map}
Interesting variables:
;;;### (autoloads (mail-other-frame mail-other-window mail mail-mode
;;;;;; 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-from-style) "sendmail"
-;;;;;; "mail/sendmail.el" (14115 60575))
+;;;;;; mail-interactive mail-self-blind mail-specify-envelope-from
+;;;;;; mail-from-style) "sendmail" "mail/sendmail.el" (14603 14745))
;;; Generated autoloads from mail/sendmail.el
(defvar mail-from-style (quote angles) "\
king@grassland.com (Elvis Parsley)
If `angles', they look like:
Elvis Parsley <king@grassland.com>
-If `system-default', Rmail allows the system to insert its default From field.")
+If `system-default', allows the mailer to insert its default From field
+derived from the envelope-from address.
+
+In old versions of Emacs, the `system-default' setting also caused
+Emacs to pass the proper email address from `user-mail-address'
+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 "\
+*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'.
+
+On most systems, specifying the envelope-from address
+is a privileged operation.")
(defvar mail-self-blind nil "\
*Non-nil means insert BCC to self in messages to be sent.
This has higher priority than `default-buffer-file-coding-system'
and `default-sendmail-coding-system',
but lower priority than the local value of `buffer-file-coding-system'.
-See also the function `select-sendmail-coding-system'.")
+See also the function `select-message-coding-system'.")
(defvar default-sendmail-coding-system (quote iso-latin-1) "\
Default coding system for encoding the outgoing mail.
User should not set this variable manually,
instead use sendmail-coding-system to get a constant encoding
of outgoing mails regardless of the current language environment.
-See also the function `select-sendmail-coding-system'.")
+See also the function `select-message-coding-system'.")
(add-hook 'same-window-buffer-names "*mail*")
(autoload (quote mail) "sendmail" "\
;;;***
\f
-;;;### (autoloads (server-start) "server" "server.el" (14057 44873))
+;;;### (autoloads (server-start) "server" "server.el" (14263 33343))
;;; Generated autoloads from server.el
(autoload (quote server-start) "server" "\
;;;***
\f
;;;### (autoloads (html-mode sgml-mode) "sgml-mode" "textmodes/sgml-mode.el"
-;;;;;; (14053 30123))
+;;;;;; (14501 37288))
;;; Generated autoloads from textmodes/sgml-mode.el
(autoload (quote sgml-mode) "sgml-mode" "\
;;;***
\f
;;;### (autoloads (sh-mode) "sh-script" "progmodes/sh-script.el"
-;;;;;; (14202 47537))
+;;;;;; (14432 40418))
;;; Generated autoloads from progmodes/sh-script.el
(put (quote sh-mode) (quote mode-class) (quote special))
\\[sh-until] until loop
\\[sh-while] while loop
+For sh and rc shells indentation commands are:
+\\[sh-show-indent] Show the variable controlling this line's indentation.
+\\[sh-set-indent] Set then variable controlling this line's indentation.
+\\[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.
+
+
\\[backward-delete-char-untabify] Delete backward one position, even if it was a tab.
\\[sh-newline-and-indent] Delete unquoted space and indent new line same as this one.
\\[sh-end-of-command] Go to end of successive commands.
;;;***
\f
;;;### (autoloads (list-load-path-shadows) "shadow" "emacs-lisp/shadow.el"
-;;;;;; (13667 34738))
+;;;;;; (13667 35245))
;;; Generated autoloads from emacs-lisp/shadow.el
(autoload (quote list-load-path-shadows) "shadow" "\
;;;***
\f
;;;### (autoloads (shell shell-prompt-pattern) "shell" "shell.el"
-;;;;;; (14143 46028))
+;;;;;; (14263 35978))
;;; Generated autoloads from shell.el
(defvar shell-prompt-pattern "^[^#$%>\n]*[#$%>] *" "\
;;;***
\f
-;;;### (autoloads (simula-mode) "simula" "progmodes/simula.el" (13578
-;;;;;; 3004))
+;;;### (autoloads (simula-mode) "simula" "progmodes/simula.el" (14256
+;;;;;; 23740))
;;; Generated autoloads from progmodes/simula.el
(autoload (quote simula-mode) "simula" "\
\f
;;;### (autoloads (skeleton-pair-insert-maybe skeleton-insert skeleton-proxy
;;;;;; skeleton-proxy-new define-skeleton) "skeleton" "skeleton.el"
-;;;;;; (13940 33237))
+;;;;;; (13940 33497))
;;; Generated autoloads from skeleton.el
(defvar skeleton-filter (quote identity) "\
;;;***
\f
+;;;### (autoloads (smerge-mode) "smerge-mode" "smerge-mode.el" (14552
+;;;;;; 48942))
+;;; 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 (smtpmail-send-it) "smtpmail" "mail/smtpmail.el"
-;;;;;; (14186 47077))
+;;;;;; (14342 21398))
;;; Generated autoloads from mail/smtpmail.el
(autoload (quote smtpmail-send-it) "smtpmail" nil nil nil)
;;;***
\f
-;;;### (autoloads (snake) "snake" "play/snake.el" (13700 16190))
+;;;### (autoloads (snake) "snake" "play/snake.el" (13700 16733))
;;; Generated autoloads from play/snake.el
(autoload (quote snake) "snake" "\
;;;***
\f
-;;;### (autoloads (snmpv2-mode snmp-mode) "snmp-mode" "snmp-mode.el"
-;;;;;; (14082 18353))
-;;; Generated autoloads from snmp-mode.el
+;;;### (autoloads (snmpv2-mode snmp-mode) "snmp-mode" "net/snmp-mode.el"
+;;;;;; (14082 18459))
+;;; Generated autoloads from net/snmp-mode.el
(autoload (quote snmp-mode) "snmp-mode" "\
Major mode for editing SNMP MIBs.
;;;***
\f
;;;### (autoloads (solitaire) "solitaire" "play/solitaire.el" (13672
-;;;;;; 19835))
+;;;;;; 20348))
;;; Generated autoloads from play/solitaire.el
(autoload (quote solitaire) "solitaire" "\
\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" (13304 43432))
+;;;;;; sort-lines sort-subr) "sort" "sort.el" (14481 36636))
;;; Generated autoloads from sort.el
(autoload (quote sort-subr) "sort" "\
(autoload (quote sort-numeric-fields) "sort" "\
Sort lines in region numerically by the ARGth field of each line.
Fields are separated by whitespace and numbered from 1 up.
-Specified field must contain a number in each line of the region.
+Specified field must contain a number in each line of the region,
+which may begin with \"0x\" or \"0\" for hexadecimal and octal values.
+Otherwise, the number is interpreted according to sort-numeric-base.
With a negative arg, sorts by the ARGth field counted from the right.
Called from a program, there are three arguments:
FIELD, BEG and END. BEG and END specify region to sort." t nil)
;;;***
\f
;;;### (autoloads (speedbar-get-focus speedbar-frame-mode) "speedbar"
-;;;;;; "speedbar.el" (14168 6532))
+;;;;;; "speedbar.el" (14623 45339))
;;; Generated autoloads from speedbar.el
(defalias (quote speedbar) (quote speedbar-frame-mode))
;;;***
\f
;;;### (autoloads (spell-string spell-region spell-word spell-buffer)
-;;;;;; "spell" "textmodes/spell.el" (13553 46126))
+;;;;;; "spell" "textmodes/spell.el" (13553 46858))
;;; Generated autoloads from textmodes/spell.el
(put (quote spell-filter) (quote risky-local-variable) t)
;;;***
\f
;;;### (autoloads (snarf-spooks spook) "spook" "play/spook.el" (13607
-;;;;;; 43407))
+;;;;;; 43485))
;;; Generated autoloads from play/spook.el
(autoload (quote spook) "spook" "\
;;;***
\f
;;;### (autoloads (sql-postgres sql-mode sql-help) "sql" "progmodes/sql.el"
-;;;;;; (14184 35036))
+;;;;;; (14395 64503))
;;; Generated autoloads from progmodes/sql.el
(autoload (quote sql-help) "sql" "\
-Shows short help for the SQL modes.
+Show short help for the SQL modes.
Use an entry function to open an interactive SQL buffer. This buffer is
usually named `*SQL*'. The name of the major mode is SQLi.
\\[sql-send-region]. Such a buffer must exist before you can do this.
See `sql-help' on how to create SQLi buffers.
-\\{sql-mode-map}
+\\{sql-mode-map}
Customization: Entry to this mode runs the `sql-mode-hook'.
When you put a buffer in SQL mode, the buffer stores the last SQLi
before \\[sql-postgres]. 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'. If your output lines end with ^M,
+`default-process-coding-system'. If your output lines end with ^M,
your might try undecided-dos as a coding system. If this doesn't help,
Try to set `comint-output-filter-functions' like this:
;;;### (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" (13337 50329))
+;;;;;; "strokes" "strokes.el" (14527 50024))
;;; Generated autoloads from strokes.el
(defvar strokes-mode nil "\
;;;***
\f
;;;### (autoloads (sc-cite-original) "supercite" "mail/supercite.el"
-;;;;;; (14192 4731))
+;;;;;; (14565 55801))
;;; Generated autoloads from mail/supercite.el
(autoload (quote sc-cite-original) "supercite" "\
;;;***
\f
-;;;### (autoloads (tabify untabify) "tabify" "tabify.el" (13227 8735))
+;;;### (autoloads (tabify untabify) "tabify" "tabify.el" (13227 8639))
;;; Generated autoloads from tabify.el
(autoload (quote untabify) "tabify" "\
;;;***
\f
-;;;### (autoloads (talk-connect) "talk" "talk.el" (13229 29627))
+;;;### (autoloads (talk-connect) "talk" "talk.el" (13229 29630))
;;; Generated autoloads from talk.el
(autoload (quote talk-connect) "talk" "\
;;;***
\f
-;;;### (autoloads (tar-mode) "tar-mode" "tar-mode.el" (14189 16949))
+;;;### (autoloads (tar-mode) "tar-mode" "tar-mode.el" (14495 17995))
;;; Generated autoloads from tar-mode.el
(autoload (quote tar-mode) "tar-mode" "\
;;;***
\f
-;;;### (autoloads (tcl-mode) "tcl-mode" "progmodes/tcl-mode.el" (13878
-;;;;;; 37688))
-;;; Generated autoloads from progmodes/tcl-mode.el
+;;;### (autoloads (tcl-help-on-word inferior-tcl tcl-mode) "tcl"
+;;;;;; "progmodes/tcl.el" (14248 50428))
+;;; Generated autoloads from progmodes/tcl.el
-(autoload (quote tcl-mode) "tcl-mode" "\
-Major mode for editing tcl scripts.
-The following keys are bound:
-\\{tcl-mode-map}
-" t nil)
+(autoload (quote tcl-mode) "tcl" "\
+Major mode for editing Tcl code.
+Expression and list commands understand all Tcl brackets.
+Tab indents for Tcl code.
+Paragraphs are separated by blank lines only.
+Delete converts tabs to spaces as it moves back.
+
+Variables controlling indentation style:
+ tcl-indent-level
+ Indentation of Tcl statements within surrounding block.
+ tcl-continued-indent-level
+ Indentation of continuation line relative to first line of command.
+
+Variables controlling user interaction with mode (see variable
+documentation for details):
+ tcl-tab-always-indent
+ Controls action of TAB key.
+ tcl-auto-newline
+ Non-nil means automatically newline before and after braces, brackets,
+ and semicolons inserted in Tcl code.
+ tcl-electric-hash-style
+ Controls action of `#' key.
+ tcl-use-hairy-comment-detector
+ If t, use more complicated, but slower, comment detector.
+ This variable is only used in Emacs 19.
+ tcl-use-smart-word-finder
+ If not nil, use a smarter, Tcl-specific way to find the current
+ word when looking up help on a Tcl command.
+
+Turning on Tcl mode calls the value of the variable `tcl-mode-hook'
+with no args, if that value is non-nil. Read the documentation for
+`tcl-mode-hook' to see what kinds of interesting hook functions
+already exist.
+
+Commands:
+\\{tcl-mode-map}" t nil)
+
+(autoload (quote inferior-tcl) "tcl" "\
+Run inferior Tcl process.
+Prefix arg means enter program name interactively.
+See documentation for function `inferior-tcl-mode' for more information." t nil)
+
+(autoload (quote tcl-help-on-word) "tcl" "\
+Get help on Tcl command. Default is word at point.
+Prefix argument means invert sense of `tcl-use-smart-word-finder'." t nil)
;;;***
\f
-;;;### (autoloads (rsh telnet) "telnet" "telnet.el" (13858 52046))
-;;; Generated autoloads from telnet.el
+;;;### (autoloads (rsh telnet) "telnet" "net/telnet.el" (13858 52416))
+;;; Generated autoloads from net/telnet.el
(add-hook 'same-window-regexps "\\*telnet-.*\\*\\(\\|<[0-9]+>\\)")
(autoload (quote telnet) "telnet" "\
;;;***
\f
-;;;### (autoloads (ansi-term term make-term) "term" "term.el" (14213
-;;;;;; 23781))
+;;;### (autoloads (ansi-term term make-term) "term" "term.el" (14268
+;;;;;; 17354))
;;; Generated autoloads from term.el
(autoload (quote make-term) "term" "\
;;;***
\f
-;;;### (autoloads (terminal-emulator) "terminal" "terminal.el" (14007
-;;;;;; 19919))
+;;;### (autoloads (terminal-emulator) "terminal" "terminal.el" (14280
+;;;;;; 10588))
;;; Generated autoloads from terminal.el
(autoload (quote terminal-emulator) "terminal" "\
;;;***
\f
-;;;### (autoloads (tetris) "tetris" "play/tetris.el" (13700 15872))
+;;;### (autoloads (tetris) "tetris" "play/tetris.el" (13700 16411))
;;; Generated autoloads from play/tetris.el
(autoload (quote tetris) "tetris" "\
;;;;;; 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"
-;;;;;; (14079 17189))
+;;;;;; (14365 34873))
;;; Generated autoloads from textmodes/tex-mode.el
(defvar tex-shell-file-name nil "\
*Command used by \\[tex-show-print-queue] to show the print queue.
Should show the queue(s) that \\[tex-print] puts jobs on.")
-(defvar tex-default-mode (quote plain-tex-mode) "\
+(defvar tex-default-mode (quote latex-mode) "\
*Mode to enter for a new file that might be either TeX or LaTeX.
This variable is used when it can't be determined whether the file
is plain TeX or LaTeX or what because the file contains no commands.
;;;***
\f
;;;### (autoloads (texi2info texinfo-format-region texinfo-format-buffer)
-;;;;;; "texinfmt" "textmodes/texinfmt.el" (14160 15906))
+;;;;;; "texinfmt" "textmodes/texinfmt.el" (14600 18796))
;;; Generated autoloads from textmodes/texinfmt.el
(autoload (quote texinfo-format-buffer) "texinfmt" "\
;;;***
\f
;;;### (autoloads (texinfo-mode) "texinfo" "textmodes/texinfo.el"
-;;;;;; (14015 33043))
+;;;;;; (14587 10351))
;;; 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)
+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"
-;;;;;; (14021 43245))
+;;;;;; (14263 36019))
;;; Generated autoloads from textmodes/texnfo-upd.el
(autoload (quote texinfo-update-node) "texnfo-upd" "\
;;;***
\f
-;;;### (autoloads (thai-pre-write-conversion thai-post-read-conversion
-;;;;;; thai-compose-buffer thai-compose-string thai-compose-region
-;;;;;; setup-thai-environment) "thai-util" "language/thai-util.el"
-;;;;;; (13969 36778))
+;;;### (autoloads (thai-composition-function thai-post-read-conversion
+;;;;;; thai-compose-buffer thai-compose-string thai-compose-region)
+;;;;;; "thai-util" "language/thai-util.el" (14623 45991))
;;; 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,
(autoload (quote thai-post-read-conversion) "thai-util" nil nil nil)
-(autoload (quote thai-pre-write-conversion) "thai-util" nil nil nil)
+(autoload (quote thai-composition-function) "thai-util" "\
+Compose Thai text in the region FROM and TO.
+The text matches the regular expression PATTERN.
+Optional 4th argument STRING, if non-nil, is a string containing text
+to compose.
+
+The return value is number of composed characters." nil nil)
;;;***
\f
-;;;### (autoloads (thing-at-point bounds-of-thing-at-point forward-thing)
-;;;;;; "thingatpt" "thingatpt.el" (13916 24948))
+;;;### (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))
;;; Generated autoloads from thingatpt.el
(autoload (quote forward-thing) "thingatpt" "\
See the file `thingatpt.el' for documentation on how to define
a symbol as a valid THING." nil nil)
+(autoload (quote sexp-at-point) "thingatpt" nil nil nil)
+
+(autoload (quote symbol-at-point) "thingatpt" nil nil nil)
+
+(autoload (quote number-at-point) "thingatpt" nil nil nil)
+
+(autoload (quote list-at-point) "thingatpt" nil nil nil)
+
;;;***
\f
;;;### (autoloads (tibetan-pre-write-conversion tibetan-post-read-conversion
-;;;;;; tibetan-compose-buffer tibetan-decompose-buffer tibetan-compose-region
-;;;;;; tibetan-decompose-region tibetan-composition tibetan-compose-string
-;;;;;; tibetan-vertical-stacking tibetan-complete-char-examin tibetan-composable-examin
-;;;;;; tibetan-char-examin tibetan-transcription-to-tibetan tibetan-tibetan-to-transcription
-;;;;;; setup-tibetan-environment) "tibet-util" "language/tibet-util.el"
-;;;;;; (13994 41097))
+;;;;;; 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) "tibet-util"
+;;;;;; "language/tibet-util.el" (14623 45991))
;;; Generated autoloads from language/tibet-util.el
-(autoload (quote setup-tibetan-environment) "tibet-util" nil t nil)
-
-(autoload (quote tibetan-tibetan-to-transcription) "tibet-util" "\
-Return a transcription string of Tibetan character CH" nil nil)
-
-(autoload (quote tibetan-transcription-to-tibetan) "tibet-util" "\
-Translate Roman transcription into a sequence of Tibetan components." nil nil)
-
-(autoload (quote tibetan-char-examin) "tibet-util" "\
+(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-composable-examin) "tibet-util" "\
-Check if Tibetan char CH is composable.
-Returns t if CH is a composable char (i.e. neither punctuation nor digit)." nil nil)
-
-(autoload (quote tibetan-complete-char-examin) "tibet-util" "\
-Check if composite char CH contains one or more vowel/vowel modifiers.
-Returns non-nil, if CH contains vowel/vowel modifiers." nil nil)
+(autoload (quote tibetan-tibetan-to-transcription) "tibet-util" "\
+Transcribe Tibetan string STR and return the corresponding Roman string." nil nil)
-(autoload (quote tibetan-vertical-stacking) "tibet-util" "\
-Return a vertically stacked composite char consisting of FIRST and SECOND.
-If UPWARD is non-nil, then SECOND is put above FIRST." nil nil)
+(autoload (quote tibetan-transcription-to-tibetan) "tibet-util" "\
+Convert Tibetan Roman string STR to Tibetan character string.
+The returned string has no composition information." nil nil)
(autoload (quote tibetan-compose-string) "tibet-util" "\
-Compose a sequence of Tibetan character components into a composite character.
-Returns a string containing a composite character." nil nil)
+Compose Tibetan string STR." nil nil)
+
+(autoload (quote tibetan-compose-region) "tibet-util" "\
+Compose Tibetan text the region BEG and END." t nil)
-(autoload (quote tibetan-composition) "tibet-util" "\
-Interface to quail input method.
-Takes two arguments: char PC and string KEY, where PC is the preceding
-character to be composed with current input KEY.
-Returns a string which is the result of composition." nil nil)
+(defalias (quote tibetan-decompose-region) (quote decompose-region))
-(autoload (quote tibetan-decompose-region) "tibet-util" "\
-Decompose Tibetan characters in the region BEG END into their components.
-Components are: base and subjoined consonants, vowel signs, vowel modifiers.
-One column punctuations are converted to their 2 column equivalents." t nil)
+(defalias (quote tibetan-decompose-string) (quote decompose-string))
-(autoload (quote tibetan-compose-region) "tibet-util" "\
-Make composite chars from Tibetan character components in the region BEG END.
-Two column punctuations are converted to their 1 column equivalents." t nil)
+(autoload (quote tibetan-composition-function) "tibet-util" nil nil nil)
(autoload (quote tibetan-decompose-buffer) "tibet-util" "\
Decomposes Tibetan characters in the buffer into their components.
-See also docstring of the function tibetan-decompose-region." t nil)
+See also the documentation of the function `tibetan-decompose-region'." t nil)
(autoload (quote tibetan-compose-buffer) "tibet-util" "\
Composes Tibetan character components in the buffer.
;;;***
\f
-;;;### (autoloads (display-time-mode display-time display-time-day-and-date)
-;;;;;; "time" "time.el" (14127 12135))
+;;;### (autoloads (tildify-buffer tildify-region) "tildify" "textmodes/tildify.el"
+;;;;;; (14357 30776))
+;;; Generated autoloads from textmodes/tildify.el
+
+(autoload (quote tildify-region) "tildify" "\
+Add hard spaces in the region between BEG and END.
+See variables `tildify-pattern-alist', `tildify-string-alist', and
+`tildify-ignored-environments-alist' for information about configuration
+parameters.
+This function performs no refilling of the changed text." t nil)
+
+(autoload (quote tildify-buffer) "tildify" "\
+Add hard spaces in the current buffer.
+See variables `tildify-pattern-alist', `tildify-string-alist', and
+`tildify-ignored-environments-alist' for information about configuration
+parameters.
+This function performs no refilling of the changed text." t nil)
+
+;;;***
+\f
+;;;### (autoloads (display-time-mode display-time display-time-day-and-date
+;;;;;; display-time-mode) "time" "time.el" (14619 48411))
;;; 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.")
;;;***
\f
;;;### (autoloads (time-stamp-toggle-active time-stamp) "time-stamp"
-;;;;;; "time-stamp.el" (14011 51994))
+;;;;;; "time-stamp.el" (14599 11147))
;;; Generated autoloads from time-stamp.el
(autoload (quote time-stamp) "time-stamp" "\
-Update the time stamp string in the buffer.
+Update the time stamp string(s) in the buffer.
A template in a file can be automatically updated with a new time stamp
every time you save the file. Add this line to your .emacs file:
(add-hook 'write-file-hooks 'time-stamp)
Time-stamp: <1998-02-18 10:20:51 gildea>
The time stamp is updated only if the variable `time-stamp-active' is non-nil.
The format of the time stamp is set by the variable `time-stamp-format'.
-The variables `time-stamp-line-limit', `time-stamp-start',
-and `time-stamp-end' control finding the template." t nil)
+The variables `time-stamp-line-limit', `time-stamp-start', `time-stamp-end',
+`time-stamp-count', and `time-stamp-inserts-lines' control finding the
+template." t nil)
(autoload (quote time-stamp-toggle-active) "time-stamp" "\
Toggle `time-stamp-active', setting whether \\[time-stamp] updates a buffer.
\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 52718))
+;;;;;; "timer.el" (13316 52821))
;;; Generated autoloads from timer.el
(defalias (quote disable-timeout) (quote cancel-timer))
;;;***
\f
;;;### (autoloads (batch-titdic-convert titdic-convert) "titdic-cnv"
-;;;;;; "international/titdic-cnv.el" (13618 46611))
+;;;;;; "international/titdic-cnv.el" (13618 46800))
;;; 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" (13700 6160))
+;;;;;; "tmm.el" (14467 13719))
;;; Generated autoloads from tmm.el
(define-key global-map "\M-`" 'tmm-menubar)
(define-key global-map [f10] 'tmm-menubar)
;;;***
\f
-;;;### (autoloads (tooltip-mode) "tooltip" "tooltip.el" (14228 23896))
+;;;### (autoloads (todo-show todo-cp todo-mode todo-print todo-insert-item)
+;;;;;; "todo-mode" "calendar/todo-mode.el" (14619 58196))
+;;; Generated autoloads from calendar/todo-mode.el
+
+(autoload (quote todo-insert-item) "todo-mode" "\
+Insert new TODO list entry.
+With a prefix argument solicit the category, otherwise use the current
+category." 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)
+
+(autoload (quote todo-mode) "todo-mode" "\
+Major mode for editing TODO lists.
+
+\\{todo-mode-map}" t nil)
+
+(autoload (quote todo-cp) "todo-mode" "\
+Make a diary entry appear only in the current date's diary" nil nil)
+
+(autoload (quote todo-show) "todo-mode" "\
+Show TODO list." t nil)
+
+;;;***
+\f
+;;;### (autoloads (tooltip-mode tooltip-mode) "tooltip" "tooltip.el"
+;;;;;; (14495 17998))
;;; Generated autoloads from tooltip.el
(autoload (quote tooltip-mode) "tooltip" "\
Mode for tooltip display.
With ARG, turn tooltip mode on if and only if ARG is positive." t nil)
+(defvar tooltip-mode nil "\
+Toggle tooltip-mode.
+Setting this variable directly does not take effect;
+use either \\[customize] or the function `tooltip-mode'.")
+
+(custom-add-to-group (quote tooltip) (quote tooltip-mode) (quote custom-variable))
+
+(custom-add-load (quote tooltip-mode) (quote tooltip))
+
;;;***
\f
-;;;### (autoloads (tpu-edt-on) "tpu-edt" "emulation/tpu-edt.el" (13697
-;;;;;; 41987))
+;;;### (autoloads (tpu-edt-on) "tpu-edt" "emulation/tpu-edt.el" (14299
+;;;;;; 63726))
;;; Generated autoloads from emulation/tpu-edt.el
(fset (quote tpu-edt-mode) (quote tpu-edt-on))
;;;***
\f
;;;### (autoloads (tpu-set-cursor-bound tpu-set-cursor-free tpu-set-scroll-margins)
-;;;;;; "tpu-extras" "emulation/tpu-extras.el" (13623 36813))
+;;;;;; "tpu-extras" "emulation/tpu-extras.el" (13623 36919))
;;; Generated autoloads from emulation/tpu-extras.el
(autoload (quote tpu-set-scroll-margins) "tpu-extras" "\
;;;***
\f
-;;;### (autoloads (tq-create) "tq" "emacs-lisp/tq.el" (13509 21722))
+;;;### (autoloads (tq-create) "tq" "emacs-lisp/tq.el" (13509 34547))
;;; Generated autoloads from emacs-lisp/tq.el
(autoload (quote tq-create) "tq" "\
;;;***
\f
;;;### (autoloads (trace-function-background trace-function trace-buffer)
-;;;;;; "trace" "emacs-lisp/trace.el" (13607 52218))
+;;;;;; "trace" "emacs-lisp/trace.el" (14583 8560))
;;; Generated autoloads from emacs-lisp/trace.el
(defvar trace-buffer "*trace-output*" "\
;;;***
\f
;;;### (autoloads (2C-split 2C-associate-buffer 2C-two-columns) "two-column"
-;;;;;; "textmodes/two-column.el" (13940 33653))
+;;;;;; "textmodes/two-column.el" (13940 33924))
;;; Generated autoloads from textmodes/two-column.el
(autoload '2C-command "two-column" () t 'keymap)
(global-set-key "\C-x6" '2C-command)
;;;### (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" (14118 2396))
+;;;;;; "type-break" "type-break.el" (14263 36029))
;;; Generated autoloads from type-break.el
(defvar type-break-mode nil "\
;;;***
\f
;;;### (autoloads (ununderline-region underline-region) "underline"
-;;;;;; "textmodes/underline.el" (13229 29692))
+;;;;;; "textmodes/underline.el" (14228 39817))
;;; Generated autoloads from textmodes/underline.el
(autoload (quote underline-region) "underline" "\
;;;***
\f
;;;### (autoloads (unforward-rmail-message undigestify-rmail-message)
-;;;;;; "undigest" "mail/undigest.el" (13475 35425))
+;;;;;; "undigest" "mail/undigest.el" (14473 58848))
;;; Generated autoloads from mail/undigest.el
(autoload (quote undigestify-rmail-message) "undigest" "\
;;;***
\f
;;;### (autoloads (unrmail batch-unrmail) "unrmail" "mail/unrmail.el"
-;;;;;; (13229 29737))
+;;;;;; (13229 29740))
;;; Generated autoloads from mail/unrmail.el
(autoload (quote batch-unrmail) "unrmail" "\
;;;***
\f
;;;### (autoloads (ask-user-about-supersession-threat ask-user-about-lock)
-;;;;;; "userlock" "userlock.el" (13323 27503))
+;;;;;; "userlock" "userlock.el" (14365 43297))
;;; Generated autoloads from userlock.el
(autoload (quote ask-user-about-lock) "userlock" "\
Ask user what to do when he wants to edit FILE but it is locked by OPPONENT.
This function has a choice of three things to do:
- do (signal 'buffer-file-locked (list FILE OPPONENT))
+ do (signal 'file-locked (list FILE OPPONENT))
to refrain from editing the file
return t (grab the lock on the file)
return nil (edit the file even though it is locked).
;;;;;; 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" (14201
-;;;;;; 50318))
+;;;;;; vc-before-checkin-hook vc-checkin-hook) "vc" "vc.el" (14565
+;;;;;; 59735))
;;; Generated autoloads from vc.el
(defvar vc-checkin-hook nil "\
;;;***
\f
;;;### (autoloads (vhdl-mode) "vhdl-mode" "progmodes/vhdl-mode.el"
-;;;;;; (14177 57984))
+;;;;;; (14385 10956))
;;; Generated autoloads from progmodes/vhdl-mode.el
(autoload (quote vhdl-mode) "vhdl-mode" "\
;;;***
\f
-;;;### (autoloads (vi-mode) "vi" "emulation/vi.el" (13229 29770))
+;;;### (autoloads (vi-mode) "vi" "emulation/vi.el" (13229 29773))
;;; Generated autoloads from emulation/vi.el
(autoload (quote vi-mode) "vi" "\
\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 11221))
+;;;;;; 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" (13968
-;;;;;; 41260))
+;;;;;; view-file-other-window view-file) "view" "view.el" (14550
+;;;;;; 6934))
;;; Generated autoloads from view.el
(defvar view-mode nil "\
(autoload (quote view-mode) "view" "\
Toggle View mode, a minor mode for viewing text but not editing it.
-With arg, turn View mode on iff arg is positive.
+With ARG, turn View mode on iff ARG is positive.
Emacs commands that do not change the buffer contents are available as usual.
Kill commands insert text in kill buffers but do not delete. Other commands
\\[beginning-of-buffer] move to the beginning of buffer.
> move to the end of buffer.
\\[View-scroll-to-buffer-end] scroll so that buffer end is at last line of window.
-SPC scroll forward prefix (default \"page size\") lines.
-DEL scroll backward prefix (default \"page size\") lines.
-\\[View-scroll-page-forward-set-page-size] like \\[View-scroll-page-forward] except prefix sets \"page size\".
-\\[View-scroll-page-backward-set-page-size] like \\[View-scroll-page-backward] except prefix sets \"page size\".
-\\[View-scroll-half-page-forward] scroll forward (and if prefix set) \"half page size\" lines.
-\\[View-scroll-half-page-backward] scroll backward (and if prefix set) \"half page size\" lines.
-RET, LFD scroll forward prefix (default one) line(s).
-y scroll backward prefix (default one) line(s).
+SPC scroll forward \"page size\" lines.
+ With prefix scroll forward prefix lines.
+DEL scroll backward \"page size\" lines.
+ With prefix scroll backward prefix lines.
+\\[View-scroll-page-forward-set-page-size] like \\[View-scroll-page-forward] but with prefix sets \"page size\" to prefix.
+\\[View-scroll-page-backward-set-page-size] like \\[View-scroll-page-backward] but with prefix sets \"page size\" to prefix.
+\\[View-scroll-half-page-forward] scroll forward \"half page size\" lines. With prefix, sets
+ \"half page size\" to prefix lines and scrolls forward that much.
+\\[View-scroll-half-page-backward] scroll backward \"half page size\" lines. With prefix, sets
+ \"half page size\" to prefix lines and scrolls backward that much.
+RET, LFD scroll forward one line. With prefix scroll forward prefix line(s).
+y scroll backward one line. With prefix scroll backward prefix line(s).
\\[View-revert-buffer-scroll-page-forward] revert-buffer if necessary and scroll forward.
Use this to view a changing file.
\\[what-line] prints the current line number.
\\[View-kill-and-leave] quit View mode, kill current buffer and go back to other buffer.
The effect of \\[View-leave] , \\[View-quit] and \\[View-kill-and-leave] depends on how view-mode was entered. If it was
-entered by view-file, view-file-other-window or view-file-other-frame (\\[view-file],
-\\[view-file-other-window], \\[view-file-other-frame] or the dired mode v command), then \\[View-quit] will try to kill the
-current buffer. If view-mode was entered from another buffer as is done by
-View-buffer, View-buffer-other-window, View-buffer-other frame, View-file,
-View-file-other-window or View-file-other-frame then \\[view-leave] , \\[view-quit] and \\[view-kill-and-leave] will return
-to that buffer.
+entered by view-file, view-file-other-window or view-file-other-frame
+\(\\[view-file], \\[view-file-other-window], \\[view-file-other-frame] or the dired mode v command), then \\[View-quit] will
+try to kill the current buffer. If view-mode was entered from another buffer
+as is done by View-buffer, View-buffer-other-window, View-buffer-other frame,
+View-file, View-file-other-window or View-file-other-frame then \\[View-leave] , \\[View-quit] and \\[View-kill-and-leave]
+will return to that buffer.
Entry to view-mode runs the normal hook `view-mode-hook'." t nil)
2) t Delete WINDOW or, if it is the only window, its frame.
3) (OLD-BUFF START POINT) Display buffer OLD-BUFF with displayed text
starting at START and point at POINT in WINDOW.
-4) quit-window Do quit-window in WINDOW.
+4) quit-window Do `quit-window' in WINDOW.
For list of all View commands, type H or h while viewing.
;;;***
\f
-;;;### (autoloads (vip-mode) "vip" "emulation/vip.el" (13650 13220))
+;;;### (autoloads (vip-mode) "vip" "emulation/vip.el" (13650 13703))
;;; Generated autoloads from emulation/vip.el
(autoload (quote vip-mode) "vip" "\
;;;***
\f
;;;### (autoloads (viper-mode toggle-viper-mode) "viper" "emulation/viper.el"
-;;;;;; (13691 17826))
+;;;;;; (14522 27540))
;;; Generated autoloads from emulation/viper.el
(autoload (quote toggle-viper-mode) "viper" "\
Toggle Viper on/off.
-If Viper is enabled, turn it off. Otherwise, turn it on." t nil)
+If Viper is enabled, turn it off. Otherwise, turn it on." t nil)
(autoload (quote viper-mode) "viper" "\
Turn on Viper emulation of Vi." t nil)
;;;***
\f
-;;;### (autoloads (webjump) "webjump" "webjump.el" (13883 38120))
-;;; Generated autoloads from webjump.el
+;;;### (autoloads (webjump) "webjump" "net/webjump.el" (14223 54012))
+;;; Generated autoloads from net/webjump.el
(autoload (quote webjump) "webjump" "\
Jumps to a Web site from a programmable hotlist.
;;;***
\f
;;;### (autoloads (which-func-mode which-func-mode-global) "which-func"
-;;;;;; "which-func.el" (14118 2519))
+;;;;;; "which-func.el" (14281 33928))
;;; Generated autoloads from which-func.el
(defvar which-func-mode-global nil "\
;;;***
\f
+;;;### (autoloads (whitespace-describe whitespace-cleanup-region
+;;;;;; whitespace-cleanup whitespace-region whitespace-buffer) "whitespace"
+;;;;;; "whitespace.el" (14495 17999))
+;;; Generated autoloads from whitespace.el
+
+(autoload (quote whitespace-buffer) "whitespace" "\
+Find five different types of white spaces in buffer:
+
+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).
+4. Spaces followed by a TAB. (Almost always, we never want that).
+5. Spaces or TABS at the end of a line.
+
+Check for whitespace only if this buffer really contains a non-empty file
+and:
+1. the major mode is one of the whitespace-modes, or
+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)
+
+(autoload (quote whitespace-cleanup) "whitespace" "\
+Cleanup the five different kinds of whitespace problems.
+
+Use \\[describe-function] whitespace-describe to read a summary of the
+whitespace problems." t nil)
+
+(autoload (quote whitespace-cleanup-region) "whitespace" "\
+Whitespace cleanup on a region specified by point and mark." t nil)
+
+(autoload (quote whitespace-describe) "whitespace" "\
+A summary of whitespaces and what this library can do about them.
+
+The whitespace library is intended to find and help fix five different types
+of whitespace problems that commonly exist in source code.
+
+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 at beginning of line, that should be
+ replaced with TABS).
+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.
+
+Modeline will show a W:<x>!<y> to denote a particular type of whitespace,
+where `x' and `y' can be one (or more) of:
+
+e - End-of-Line whitespace.
+i - Indentation whitespace.
+l - Leading whitespace.
+s - Space followed by Tab.
+t - Trailing whitespace.
+
+If any of the whitespace checks is turned off, the modeline will display a
+!<y>.
+
+ (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
+ always they default to 8.)
+
+ 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
+ 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.)
+
+All the above have caused (and will cause) unwanted codeline integration and
+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)
+
+;;;***
+\f
;;;### (autoloads (widget-minor-mode widget-browse-other-window widget-browse
-;;;;;; widget-browse-at) "wid-browse" "wid-browse.el" (13218 28295))
+;;;;;; widget-browse-at) "wid-browse" "wid-browse.el" (13218 28813))
;;; 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" (14081 4940))
+;;;;;; "wid-edit" "wid-edit.el" (14606 42158))
;;; Generated autoloads from wid-edit.el
(autoload (quote widget-prompt-value) "wid-edit" "\
;;;***
\f
+;;;### (autoloads (windmove-default-keybindings windmove-down windmove-right
+;;;;;; windmove-up windmove-left) "windmove" "windmove.el" (14485
+;;;;;; 64331))
+;;; Generated autoloads from windmove.el
+
+(autoload (quote windmove-left) "windmove" "\
+Select the window to the left of the current one.
+With no prefix argument, or with prefix argument equal to zero,
+\"left\" is relative to the position of point in the window; otherwise
+it is relative to the top edge (for positive ARG) or the bottom edge
+\(for negative ARG) of the current window.
+If no window is at the desired location, an error is signaled." t nil)
+
+(autoload (quote windmove-up) "windmove" "\
+Select the window above the current one.
+With no prefix argument, or with prefix argument equal to zero, \"up\"
+is relative to the position of point in the window; otherwise it is
+relative to the left edge (for positive ARG) or the right edge (for
+negative ARG) of the current window.
+If no window is at the desired location, an error is signaled." t nil)
+
+(autoload (quote windmove-right) "windmove" "\
+Select the window to the right of the current one.
+With no prefix argument, or with prefix argument equal to zero,
+\"right\" is relative to the position of point in the window;
+otherwise it is relative to the top edge (for positive ARG) or the
+bottom edge (for negative ARG) of the current window.
+If no window is at the desired location, an error is signaled." t nil)
+
+(autoload (quote windmove-down) "windmove" "\
+Select the window below the current one.
+With no prefix argument, or with prefix argument equal to zero,
+\"down\" is relative to the position of point in the window; otherwise
+it is relative to the left edge (for positive ARG) or the right edge
+\(for negative ARG) of the current window.
+If no window is at the desired location, an error is signaled." t nil)
+
+(autoload (quote windmove-default-keybindings) "windmove" "\
+Set up default keybindings for `windmove'." t nil)
+
+;;;***
+\f
;;;### (autoloads (winner-mode winner-mode) "winner" "winner.el"
-;;;;;; (14118 1446))
+;;;;;; (14535 44846))
;;; Generated autoloads from winner.el
(defvar winner-mode nil "\
;;;***
\f
+;;;### (autoloads (woman-find-file woman-dired-find-file woman) "woman"
+;;;;;; "woman.el" (14614 53233))
+;;; Generated autoloads from woman.el
+
+(autoload (quote woman) "woman" "\
+Browse a UN*X man page for TOPIC WithOut using a `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 they are given then
+the argument TOPIC should be a topic string and the RE-CACHE may be
+non-nil to force 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 existing WoMan buffers 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"
-;;;;;; (13415 51533))
+;;;;;; (13415 51576))
;;; Generated autoloads from emulation/ws-mode.el
(autoload (quote wordstar-mode) "ws-mode" "\
;;;***
\f
-;;;### (autoloads (xterm-mouse-mode) "xt-mouse" "xt-mouse.el" (13929
-;;;;;; 31262))
+;;;### (autoloads (xterm-mouse-mode) "xt-mouse" "xt-mouse.el" (14516
+;;;;;; 149))
;;; Generated autoloads from xt-mouse.el
(autoload (quote xterm-mouse-mode) "xt-mouse" "\
;;;***
\f
;;;### (autoloads (psychoanalyze-pinhead apropos-zippy insert-zippyism
-;;;;;; yow) "yow" "play/yow.el" (13607 43523))
+;;;;;; yow) "yow" "play/yow.el" (13607 43571))
;;; Generated autoloads from play/yow.el
(autoload (quote yow) "yow" "\
;;;***
\f
;;;### (autoloads (zone-mode zone-mode-update-serial-hook) "zone-mode"
-;;;;;; "zone-mode.el" (13674 19972))
-;;; Generated autoloads from zone-mode.el
+;;;;;; "net/zone-mode.el" (13674 20513))
+;;; Generated autoloads from net/zone-mode.el
(autoload (quote zone-mode-update-serial-hook) "zone-mode" "\
Update the serial number in a zone if the file was modified" t nil)
-(autoload (quote zone-mode) "zone-mode" "A mode for editing DNS zone files.\n\nZone-mode does two things:\n\n - automatically update the serial number for a zone\n when saving the file\n\n - fontification" t nil)
+(autoload (quote zone-mode) "zone-mode" "\
+A mode for editing DNS zone files.
+
+Zone-mode does two things:
+
+ - automatically update the serial number for a zone
+ when saving the file
+
+ - fontification" t nil)
;;;***
\f
-;;; Don't make backup versions of this file - most of it is generated
-;;; automatically by autoload.el, and what isn't changes rarely.
;;; Local Variables:
;;; version-control: never
;;; no-byte-compile: t
HCoop / bpt / emacs.git / blobdiff