;;;***
\f
;;;### (autoloads (ada-mode ada-add-extensions) "ada-mode" "progmodes/ada-mode.el"
-;;;;;; (15564 31133))
+;;;;;; (15640 49865))
;;; Generated autoloads from progmodes/ada-mode.el
(autoload (quote ada-add-extensions) "ada-mode" "\
(autoload (quote ada-mode) "ada-mode" "\
Ada mode is the major mode for editing Ada code.
-This version was built on $Date: 2002/04/28 21:14:17 $.
+This version was built on Date: 2002/05/21 11:58:02 .
Bindings are as follows: (Note: 'LFD' is control-j.)
\\{ada-mode-map}
;;;***
\f
;;;### (autoloads (ada-header) "ada-stmt" "progmodes/ada-stmt.el"
-;;;;;; (15539 14609))
+;;;;;; (15640 49865))
;;; Generated autoloads from progmodes/ada-stmt.el
(autoload (quote ada-header) "ada-stmt" "\
;;;***
\f
;;;### (autoloads (ada-find-file) "ada-xref" "progmodes/ada-xref.el"
-;;;;;; (15563 27310))
+;;;;;; (15685 64561))
;;; Generated autoloads from progmodes/ada-xref.el
(autoload (quote ada-find-file) "ada-xref" "\
;;;### (autoloads (change-log-redate change-log-merge add-log-current-defun
;;;;;; change-log-mode add-change-log-entry-other-window add-change-log-entry
;;;;;; find-change-log prompt-for-change-log-name add-log-mailing-address
-;;;;;; add-log-full-name) "add-log" "add-log.el" (15320 20633))
+;;;;;; add-log-full-name) "add-log" "add-log.el" (15683 14753))
;;; Generated autoloads from add-log.el
(defvar add-log-full-name nil "\
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.
-This defaults to the value of `user-mail-address'.")
+*Electronic mail addresses of user, for inclusion in ChangeLog headers.
+This defaults to the value of `user-mail-address'. In addition to
+being a simple string, this value can also be a list. All elements
+will be recognized as referring to the same user; when creating a new
+ChangeLog entry, one element will be chosen at random.")
(autoload (quote prompt-for-change-log-name) "add-log" "\
Prompt for a change log name." nil nil)
point for uppercase headings starting in the first column or
identifiers followed by `:' or `='. See variables
`add-log-current-defun-header-regexp' and
-`add-log-current-defun-function'
+`add-log-current-defun-function'.
Has a preference of looking backwards." nil nil)
;;;***
\f
;;;### (autoloads (defadvice ad-add-advice ad-default-compilation-action
-;;;;;; ad-redefinition-action) "advice" "emacs-lisp/advice.el" (15566
-;;;;;; 7178))
+;;;;;; ad-redefinition-action) "advice" "emacs-lisp/advice.el" (15656
+;;;;;; 53216))
;;; Generated autoloads from emacs-lisp/advice.el
(defvar ad-redefinition-action (quote warn) "\
;;;***
\f
;;;### (autoloads (ange-ftp-hook-function ange-ftp-reread-dir) "ange-ftp"
-;;;;;; "net/ange-ftp.el" (15576 11370))
+;;;;;; "net/ange-ftp.el" (15727 34847))
;;; Generated autoloads from net/ange-ftp.el
(defalias (quote ange-ftp-re-read-dir) (quote ange-ftp-reread-dir))
(autoload (quote ange-ftp-hook-function) "ange-ftp" nil nil nil)
-(or (assoc "^/[^/:]*[^/:.]:" file-name-handler-alist) (setq file-name-handler-alist (cons (quote ("^/[^/:]*[^/:.]:" . ange-ftp-hook-function)) file-name-handler-alist)))
-
-(or (assoc "^/[^/:]*\\'" file-name-handler-alist) (setq file-name-handler-alist (cons (quote ("^/[^/:]*\\'" . ange-ftp-completion-hook-function)) file-name-handler-alist)))
+(put (quote ange-ftp-hook-function) (quote file-remote-p) t)
;;;***
\f
;;;***
\f
;;;### (autoloads (ansi-color-process-output ansi-color-for-comint-mode-on)
-;;;;;; "ansi-color" "ansi-color.el" (15363 46804))
+;;;;;; "ansi-color" "ansi-color.el" (15583 13478))
;;; Generated autoloads from ansi-color.el
(autoload (quote ansi-color-for-comint-mode-on) "ansi-color" "\
;;;### (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" (15362 27516))
+;;;;;; "appt" "calendar/appt.el" (15708 56871))
;;; Generated autoloads from calendar/appt.el
(defvar appt-issue-message t "\
;;;***
\f
;;;### (autoloads (apropos-documentation apropos-value apropos apropos-command
-;;;;;; apropos-variable apropos-mode) "apropos" "apropos.el" (15572
-;;;;;; 475))
+;;;;;; apropos-variable apropos-mode) "apropos" "apropos.el" (15727
+;;;;;; 34856))
;;; Generated autoloads from apropos.el
(autoload (quote apropos-mode) "apropos" "\
With optional prefix DO-ALL or if `apropos-do-all' is non-nil, also show
normal variables." t nil)
-(fset (quote command-apropos) (quote apropos-command))
+(defalias (quote command-apropos) (quote apropos-command))
(autoload (quote apropos-command) "apropos" "\
Show commands (interactively callable functions) that match APROPOS-REGEXP.
;;;***
\f
-;;;### (autoloads (archive-mode) "arc-mode" "arc-mode.el" (15490
-;;;;;; 39259))
+;;;### (autoloads (archive-mode) "arc-mode" "arc-mode.el" (15591
+;;;;;; 63983))
;;; Generated autoloads from arc-mode.el
(autoload (quote archive-mode) "arc-mode" "\
;;;***
\f
-;;;### (autoloads (artist-mode) "artist" "textmodes/artist.el" (15490
-;;;;;; 41522))
+;;;### (autoloads (artist-mode) "artist" "textmodes/artist.el" (15651
+;;;;;; 7291))
;;; Generated autoloads from textmodes/artist.el
(autoload (quote artist-mode) "artist" "\
;;;***
\f
;;;### (autoloads (auto-insert-mode define-auto-insert auto-insert)
-;;;;;; "autoinsert" "autoinsert.el" (15566 54821))
+;;;;;; "autoinsert" "autoinsert.el" (15567 16400))
;;; Generated autoloads from autoinsert.el
(autoload (quote auto-insert) "autoinsert" "\
\f
;;;### (autoloads (batch-update-autoloads update-autoloads-from-directories
;;;;;; update-file-autoloads) "autoload" "emacs-lisp/autoload.el"
-;;;;;; (15428 59181))
+;;;;;; (15688 41019))
;;; 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" (15538 8758))
+;;;;;; auto-revert-mode) "autorevert" "autorevert.el" (15538 21129))
;;; Generated autoloads from autorevert.el
(defvar auto-revert-mode nil "\
;;;***
\f
-;;;### (autoloads (bibtex-mode) "bibtex" "textmodes/bibtex.el" (15507
-;;;;;; 13708))
+;;;### (autoloads (bibtex-mode) "bibtex" "textmodes/bibtex.el" (15727
+;;;;;; 34845))
;;; Generated autoloads from textmodes/bibtex.el
(autoload (quote bibtex-mode) "bibtex" "\
To submit a problem report, enter \\[bibtex-submit-bug-report] from a
BibTeX mode buffer. This automatically sets up a mail buffer with
version information already added. You just need to add a description
-of the problem, including a reproducable test case and send the
+of the problem, including a reproducible test case and send the
message.
;;;;;; bookmark-load bookmark-save bookmark-write bookmark-delete
;;;;;; bookmark-insert bookmark-rename bookmark-insert-location
;;;;;; bookmark-relocate bookmark-jump bookmark-set) "bookmark"
-;;;;;; "bookmark.el" (15394 11948))
+;;;;;; "bookmark.el" (15625 11767))
;;; Generated autoloads from bookmark.el
(define-key ctl-x-map "rb" 'bookmark-jump)
(define-key ctl-x-map "rm" 'bookmark-set)
;;;;;; browse-url-of-buffer browse-url-of-file browse-url-generic-program
;;;;;; browse-url-save-file browse-url-new-window-flag browse-url-galeon-program
;;;;;; browse-url-browser-display browse-url-browser-function) "browse-url"
-;;;;;; "net/browse-url.el" (15509 27625))
+;;;;;; "net/browse-url.el" (15683 14757))
;;; Generated autoloads from net/browse-url.el
(defvar browse-url-browser-function (if (memq system-type (quote (windows-nt ms-dos))) (quote browse-url-default-windows-browser) (quote browse-url-default-browser)) "\
;;;***
\f
;;;### (autoloads (bs-show bs-customize bs-cycle-previous bs-cycle-next)
-;;;;;; "bs" "bs.el" (15354 40500))
+;;;;;; "bs" "bs.el" (15727 34856))
;;; Generated autoloads from bs.el
(autoload (quote bs-cycle-next) "bs" "\
;;;;;; batch-byte-compile-if-not-done display-call-tree byte-compile
;;;;;; compile-defun byte-compile-file byte-recompile-directory
;;;;;; byte-force-recompile) "bytecomp" "emacs-lisp/bytecomp.el"
-;;;;;; (15518 11598))
+;;;;;; (15727 34849))
;;; Generated autoloads from emacs-lisp/bytecomp.el
(autoload (quote byte-force-recompile) "bytecomp" "\
This is if a `.elc' file exists but is older than the `.el' file.
Files in subdirectories of DIRECTORY are processed also.
-If the `.elc' file does not exist, normally the `.el' file is *not* compiled.
-But a prefix argument (optional second arg) means ask user,
-for each such `.el' file, whether to compile it. Prefix argument 0 means
-don't ask and compile the file anyway.
+If the `.elc' file does not exist, normally this function *does not*
+compile the corresponding `.el' file. However,
+if ARG (the prefix argument) is 0, that means do compile all those files.
+A nonzero ARG means ask the user, for each such `.el' file,
+whether to compile it.
-A nonzero prefix argument also means ask about each subdirectory.
+A nonzero ARG also means ask about each subdirectory before scanning it.
If the third argument FORCE is non-nil,
recompile every `.el' file that already has a `.elc' file." t nil)
;;;***
\f
;;;### (autoloads (list-yahrzeit-dates) "cal-hebrew" "calendar/cal-hebrew.el"
-;;;;;; (15531 4260))
+;;;;;; (15683 14756))
;;; Generated autoloads from calendar/cal-hebrew.el
(autoload (quote list-yahrzeit-dates) "cal-hebrew" "\
\f
;;;### (autoloads (defmath calc-embedded-activate calc-embedded calc-grab-rectangle
;;;;;; calc-grab-region full-calc-keypad calc-keypad calc-eval quick-calc
-;;;;;; full-calc calc calc-dispatch) "calc" "calc/calc.el" (15564
-;;;;;; 39428))
+;;;;;; full-calc calc calc-dispatch) "calc" "calc/calc.el" (15698
+;;;;;; 64355))
;;; Generated autoloads from calc/calc.el
(defvar calc-info-filename "calc.info" "\
;;;***
\f
;;;### (autoloads (calc-extensions) "calc-ext" "calc/calc-ext.el"
-;;;;;; (15483 59373))
+;;;;;; (15605 43432))
;;; Generated autoloads from calc/calc-ext.el
(autoload (quote calc-extensions) "calc-ext" "\
;;;;;; 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"
-;;;;;; (15531 5620))
+;;;;;; (15533 28773))
;;; Generated autoloads from calendar/calendar.el
(defvar calendar-week-start-day 0 "\
;;;***
\f
-;;;### (autoloads nil "cc-langs" "progmodes/cc-langs.el" (15555 23256))
+;;;### (autoloads nil "cc-langs" "progmodes/cc-langs.el" (15556 56060))
;;; 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"
-;;;;;; (15555 23256))
+;;;;;; (15613 3383))
;;; 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" (15555 23256))
+;;;;;; "progmodes/cc-styles.el" (15623 552))
;;; Generated autoloads from progmodes/cc-styles.el
(autoload (quote c-set-style) "cc-styles" "\
The variable `c-indentation-style' always contains the buffer's current
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
+If the optional argument DONT-OVERRIDE is t, 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)
+If DONT-OVERRIDE is neither nil nor t, only those style variables that
+have default (i.e. non-buffer local) values will keep their settings
+while the rest will be overridden. This is useful to avoid overriding
+global settings done in ~/.emacs when setting a style from a mode hook
+\(providing the style variables are buffer local, which is the
+default).
+
+Obviously, setting DONT-OVERRIDE to t is useful mainly when the
+initial style is chosen for a CC Mode buffer by a major mode. Since
+that is done internally by CC Mode, it typically won't have any effect
+when used elsewhere." t nil)
(autoload (quote c-add-style) "cc-styles" "\
Adds a style to `c-style-alist', or updates an existing one.
;;;***
\f
-;;;### (autoloads nil "cc-vars" "progmodes/cc-vars.el" (15555 23256))
+;;;### (autoloads nil "cc-vars" "progmodes/cc-vars.el" (15556 56060))
;;; Generated autoloads from progmodes/cc-vars.el
(defconst c-emacs-features (let ((infodock-p (boundp (quote infodock-version))) (comments (let ((table (copy-syntax-table)) entry) (modify-syntax-entry 97 ". 12345678" table) (cond ((arrayp table) (setq entry (aref table 97)) (if (consp entry) (setq entry (car entry)))) ((fboundp (quote get-char-table)) (setq entry (get-char-table 97 table))) ((and (fboundp (quote char-table-p)) (char-table-p table)) (setq entry (car (char-table-range table [97])))) (t (error "CC Mode is incompatible with this version of Emacs"))) (if (= (logand (lsh entry -16) 255) 255) (quote 8-bit) (quote 1-bit))))) (if infodock-p (list comments (quote infodock)) (list comments))) "\
\f
;;;### (autoloads (ccl-execute-with-args check-ccl-program define-ccl-program
;;;;;; declare-ccl-program ccl-dump ccl-compile) "ccl" "international/ccl.el"
-;;;;;; (15185 62673))
+;;;;;; (15669 59919))
;;; Generated autoloads from international/ccl.el
(autoload (quote ccl-compile) "ccl" "\
STATEMENT :=
SET | IF | BRANCH | LOOP | REPEAT | BREAK | READ | WRITE | CALL
- | TRANSLATE | END
+ | TRANSLATE | MAP | LOOKUP | END
SET := (REG = EXPRESSION)
| (REG ASSIGNMENT_OPERATOR EXPRESSION)
(translate-character REG(table) REG(charset) REG(codepoint))
| (translate-character SYMBOL REG(charset) REG(codepoint))
;; SYMBOL must refer to a table defined by `define-translation-table'.
+LOOKUP :=
+ (lookup-character SYMBOL REG(charset) REG(codepoint))
+ | (lookup-integer SYMBOL REG(integer))
+ ;; SYMBOL refers to a table defined by `define-hash-translation-table'.
MAP :=
(iterate-multiple-map REG REG MAP-IDs)
| (map-multiple REG REG (MAP-SET))
;;;;;; checkdoc-comments checkdoc-continue checkdoc-start checkdoc-current-buffer
;;;;;; checkdoc-eval-current-buffer checkdoc-message-interactive
;;;;;; checkdoc-interactive checkdoc) "checkdoc" "emacs-lisp/checkdoc.el"
-;;;;;; (15457 19651))
+;;;;;; (15702 53007))
;;; Generated autoloads from emacs-lisp/checkdoc.el
(autoload (quote checkdoc) "checkdoc" "\
-Interactivly check the entire buffer for style errors.
-The current status of the ckeck will be displayed in a buffer which
+Interactively check the entire buffer for style errors.
+The current status of the check will be displayed in a buffer which
the users will view as each check is completed." t nil)
(autoload (quote checkdoc-interactive) "checkdoc" "\
;;;***
\f
;;;### (autoloads (command-history list-command-history repeat-matching-complex-command)
-;;;;;; "chistory" "chistory.el" (15569 32085))
+;;;;;; "chistory" "chistory.el" (15569 44237))
;;; Generated autoloads from chistory.el
(autoload (quote repeat-matching-complex-command) "chistory" "\
;;;***
\f
-;;;### (autoloads nil "cl" "emacs-lisp/cl.el" (15369 55605))
+;;;### (autoloads nil "cl" "emacs-lisp/cl.el" (15666 1371))
;;; 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"
-;;;;;; (15505 46978))
+;;;;;; (15738 35331))
;;; Generated autoloads from emacs-lisp/cl-indent.el
(autoload (quote common-lisp-indent-function) "cl-indent" nil nil nil)
;;;***
\f
;;;### (autoloads (cp-make-coding-system) "code-pages" "international/code-pages.el"
-;;;;;; (15400 23081))
+;;;;;; (15591 63983))
;;; Generated autoloads from international/code-pages.el
(autoload (quote cp-make-coding-system) "code-pages" "\
\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" (15507 30173))
+;;;;;; "codepage" "international/codepage.el" (15507 55753))
;;; Generated autoloads from international/codepage.el
(autoload (quote cp-make-coding-systems-for-codepage) "codepage" "\
;;;### (autoloads (comint-redirect-results-list-from-process comint-redirect-results-list
;;;;;; comint-redirect-send-command-to-process comint-redirect-send-command
;;;;;; comint-run make-comint make-comint-in-buffer) "comint" "comint.el"
-;;;;;; (15551 8581))
+;;;;;; (15727 34856))
;;; Generated autoloads from comint.el
(autoload (quote make-comint-in-buffer) "comint" "\
;;;***
\f
-;;;### (autoloads (compare-windows) "compare-w" "compare-w.el" (15569
-;;;;;; 32086))
+;;;### (autoloads (compare-windows) "compare-w" "compare-w.el" (15669
+;;;;;; 19465))
;;; Generated autoloads from compare-w.el
(autoload (quote compare-windows) "compare-w" "\
;;;***
\f
;;;### (autoloads (next-error compilation-minor-mode compilation-shell-minor-mode
-;;;;;; compilation-mode grep-find grep compile compilation-search-path
+;;;;;; compilation-mode grep-tree grep-find grep compile compilation-search-path
;;;;;; compilation-ask-about-save compilation-window-height compilation-mode-hook)
-;;;;;; "compile" "progmodes/compile.el" (15535 6898))
+;;;;;; "compile" "progmodes/compile.el" (15738 35332))
;;; Generated autoloads from progmodes/compile.el
(defvar compilation-mode-hook nil "\
This command uses a special history list for its arguments, so you can
easily repeat a find command." t nil)
+(autoload (quote grep-tree) "compile" "\
+Grep for REGEXP in FILES in directory tree rooted at DIR.
+Collect output in a buffer.
+Interactively, prompt separately for each search parameter.
+With prefix arg, reuse previous REGEXP.
+The search is limited to file names matching shell pattern FILES.
+FILES may use abbreviations defined in `grep-tree-files-aliases', e.g.
+entering `ch' is equivalent to `*.[ch]'.
+
+While find runs asynchronously, you can use the \\[next-error] command
+to find the text that grep hits refer to.
+
+This command uses a special history list for its arguments, so you can
+easily repeat a find command.
+
+When used non-interactively, optional arg SUBDIRS limits the search to
+those sub directories of DIR." t nil)
+
(autoload (quote compilation-mode) "compile" "\
Major mode for compilation log buffers.
\\<compilation-mode-map>To visit the source for a line-numbered error,
;;;***
\f
;;;### (autoloads (dynamic-completion-mode) "completion" "completion.el"
-;;;;;; (15394 12097))
+;;;;;; (15707 34351))
;;; Generated autoloads from completion.el
(autoload (quote dynamic-completion-mode) "completion" "\
;;;### (autoloads (decompose-composite-char compose-last-chars compose-chars-after
;;;;;; find-composition compose-chars decompose-string compose-string
;;;;;; decompose-region compose-region) "composite" "composite.el"
-;;;;;; (15185 62672))
+;;;;;; (15727 34855))
;;; 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))) "\
(autoload (quote compose-region) "composite" "\
Compose characters in the current region.
+Characters are composed relatively, i.e. composed by overstricking or
+stacking depending on ascent, descent and other properties.
+
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.
+sequence (vector, list, or string) of integers. In this case,
+characters are composed not relatively but according to COMPONENTS.
If it is a character, it is an alternate character to display instead
of the text in the region.
(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)
+(make-obsolete (quote decompose-composite-char) (quote char-to-string) "21.1")
+
;;;***
\f
;;;### (autoloads (shuffle-vector cookie-snarf cookie-insert cookie)
;;;***
\f
;;;### (autoloads (cperl-mode) "cperl-mode" "progmodes/cperl-mode.el"
-;;;;;; (15538 7172))
+;;;;;; (15649 61374))
;;; Generated autoloads from progmodes/cperl-mode.el
(autoload (quote cperl-mode) "cperl-mode" "\
well, with optional special formatting done on {}. (Disabled by
default.) You can always quote (with \\[quoted-insert]) the left
\"paren\" to avoid the expansion. The processing of < is special,
-since most the time you mean \"less\". Cperl mode tries to guess
+since most the time you mean \"less\". CPerl mode tries to guess
whether you want to type pair <>, and inserts is if it
appropriate. You can set `cperl-electric-parens-string' to the string that
contains the parenths from the above list you want to be electrical.
DO NOT FORGET to read micro-docs (available from `Perl' menu)
or as help on variables `cperl-tips', `cperl-problems',
-`cperl-non-problems', `cperl-praise', `cperl-speed'." t nil)
+`cperl-praise', `cperl-speed'." t nil)
;;;***
\f
;;;### (autoloads (cpp-parse-edit cpp-highlight-buffer) "cpp" "progmodes/cpp.el"
-;;;;;; (15344 20121))
+;;;;;; (15593 36679))
;;; Generated autoloads from progmodes/cpp.el
(autoload (quote cpp-highlight-buffer) "cpp" "\
;;;***
\f
;;;### (autoloads (cua-mode cua-mode) "cua-base" "emulation/cua-base.el"
-;;;;;; (15568 28316))
+;;;;;; (15640 49861))
;;; Generated autoloads from emulation/cua-base.el
(defvar cua-mode nil "\
;;;;;; 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"
-;;;;;; (15571 26633))
+;;;;;; (15728 32690))
;;; Generated autoloads from cus-edit.el
(add-hook 'same-window-regexps "\\`\\*Customiz.*\\*\\'")
;;;***
\f
;;;### (autoloads (custom-set-faces custom-declare-face) "cus-face"
-;;;;;; "cus-face.el" (15540 20497))
+;;;;;; "cus-face.el" (15540 34267))
;;; Generated autoloads from cus-face.el
(autoload (quote custom-declare-face) "cus-face" "\
;;;***
\f
;;;### (autoloads (global-cwarn-mode turn-on-cwarn-mode cwarn-mode)
-;;;;;; "cwarn" "progmodes/cwarn.el" (15538 7545))
+;;;;;; "cwarn" "progmodes/cwarn.el" (15538 21135))
;;; Generated autoloads from progmodes/cwarn.el
(autoload (quote cwarn-mode) "cwarn" "\
\f
;;;### (autoloads (standard-display-cyrillic-translit cyrillic-encode-alternativnyj-char
;;;;;; cyrillic-encode-koi8-r-char) "cyril-util" "language/cyril-util.el"
-;;;;;; (15458 48360))
+;;;;;; (15683 14756))
;;; Generated autoloads from language/cyril-util.el
(autoload (quote cyrillic-encode-koi8-r-char) "cyril-util" "\
;;;***
\f
;;;### (autoloads (dabbrev-expand dabbrev-completion) "dabbrev" "dabbrev.el"
-;;;;;; (15509 27673))
+;;;;;; (15671 8032))
;;; Generated autoloads from dabbrev.el
(define-key esc-map "/" (quote dabbrev-expand))
;;;***
\f
-;;;### (autoloads (dcl-mode) "dcl-mode" "progmodes/dcl-mode.el" (15363
-;;;;;; 46803))
+;;;### (autoloads (dcl-mode) "dcl-mode" "progmodes/dcl-mode.el" (15727
+;;;;;; 34846))
;;; 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" (15542 21037))
+;;;;;; "emacs-lisp/debug.el" (15685 15800))
;;; Generated autoloads from emacs-lisp/debug.el
(setq debugger (quote debug))
;;;***
\f
;;;### (autoloads (derived-mode-init-mode-variables define-derived-mode)
-;;;;;; "derived" "derived.el" (15383 8927))
+;;;;;; "derived" "derived.el" (15704 32804))
;;; Generated autoloads from derived.el
(autoload (quote define-derived-mode) "derived" "\
;;;***
\f
-;;;### (autoloads (describe-text-at) "descr-text" "descr-text.el"
-;;;;;; (15568 22302))
+;;;### (autoloads (describe-char describe-text-properties) "descr-text"
+;;;;;; "descr-text.el" (15640 49858))
;;; Generated autoloads from descr-text.el
-(autoload (quote describe-text-at) "descr-text" "\
-Describe widgets, buttons, overlays and text properties at POS." t nil)
+(autoload (quote describe-text-properties) "descr-text" "\
+Describe widgets, buttons, overlays and text properties at POS.
+Interactively, describe them for the character after point.
+If optional second argument OUTPUT-BUFFER is non-nil,
+insert the output into that buffer, and don't initialize or clear it
+otherwise." t nil)
+
+(autoload (quote describe-char) "descr-text" "\
+Describe the character after POS (interactively, the character after point).
+The information includes character code, charset and code points in it,
+syntax, category, how the character is encoded in a file,
+character composition information (if relevant),
+as well as widgets, buttons, overlays, and text properties." t nil)
;;;***
\f
;;;### (autoloads (desktop-load-default desktop-read) "desktop" "desktop.el"
-;;;;;; (15500 30127))
+;;;;;; (15501 5682))
;;; Generated autoloads from desktop.el
(autoload (quote desktop-read) "desktop" "\
;;;***
\f
-;;;### (autoloads nil "devan-util" "language/devan-util.el" (15400
-;;;;;; 23222))
+;;;### (autoloads nil "devan-util" "language/devan-util.el" (15656
+;;;;;; 53216))
;;; Generated autoloads from language/devan-util.el
(defconst devanagari-consonant "[\x51ad5-\x51af9\x51b38-\x51b3f]")
;;;***
\f
;;;### (autoloads (diary-mail-entries diary) "diary-lib" "calendar/diary-lib.el"
-;;;;;; (15555 49408))
+;;;;;; (15728 32693))
;;; Generated autoloads from calendar/diary-lib.el
(autoload (quote diary) "diary-lib" "\
;;;***
\f
;;;### (autoloads (diff-backup diff diff-command diff-switches) "diff"
-;;;;;; "diff.el" (15300 62416))
+;;;;;; "diff.el" (15738 35316))
;;; Generated autoloads from diff.el
(defvar diff-switches "-c" "\
Find and display the differences between OLD and NEW files.
Interactively the current buffer's file name is the default for NEW
and a backup file for NEW is the default for OLD.
-With prefix arg, prompt for diff switches." t nil)
+With prefix arg, prompt for diff switches.
+If NO-ASYNC is non-nil, call diff syncrhonously." t nil)
(autoload (quote diff-backup) "diff" "\
Diff this file with its backup file or vice versa.
;;;***
\f
;;;### (autoloads (diff-minor-mode diff-mode) "diff-mode" "diff-mode.el"
-;;;;;; (15410 13379))
+;;;;;; (15669 19465))
;;; Generated autoloads from diff-mode.el
(autoload (quote diff-mode) "diff-mode" "\
;;;;;; dired dired-copy-preserve-time dired-dwim-target dired-keep-marker-symlink
;;;;;; dired-keep-marker-hardlink dired-keep-marker-copy dired-keep-marker-rename
;;;;;; dired-trivial-filenames dired-ls-F-marks-symlinks dired-listing-switches)
-;;;;;; "dired" "dired.el" (15556 53665))
+;;;;;; "dired" "dired.el" (15730 33154))
;;; Generated autoloads from dired.el
(defvar dired-listing-switches "-al" "\
(autoload (quote dired-noselect) "dired" "\
Like `dired' but returns the dired buffer as value, does not select it." nil nil)
+ (put 'dired-find-alternate-file 'disabled t)
;;;***
\f
;;;;;; 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" (15549 18023))
+;;;;;; "dired-aux.el" (15583 13479))
;;; Generated autoloads from dired-aux.el
(autoload (quote dired-diff) "dired-aux" "\
;;;***
\f
;;;### (autoloads (double-mode double-mode) "double" "double.el"
-;;;;;; (15186 56482))
+;;;;;; (15738 35316))
;;; Generated autoloads from double.el
(defvar double-mode nil "\
;;;***
\f
-;;;### (autoloads (dunnet) "dunnet" "play/dunnet.el" (15186 44923))
+;;;### (autoloads (dunnet) "dunnet" "play/dunnet.el" (15651 7290))
;;; Generated autoloads from play/dunnet.el
(autoload (quote dunnet) "dunnet" "\
\f
;;;### (autoloads (easy-mmode-defsyntax easy-mmode-defmap easy-mmode-define-keymap
;;;;;; easy-mmode-define-global-mode define-minor-mode) "easy-mmode"
-;;;;;; "emacs-lisp/easy-mmode.el" (15491 62641))
+;;;;;; "emacs-lisp/easy-mmode.el" (15727 34849))
;;; Generated autoloads from emacs-lisp/easy-mmode.el
(defalias (quote easy-mmode-define-minor-mode) (quote define-minor-mode))
;;;***
\f
;;;### (autoloads (easy-menu-change easy-menu-create-menu easy-menu-do-define
-;;;;;; easy-menu-define) "easymenu" "emacs-lisp/easymenu.el" (15563
-;;;;;; 27270))
+;;;;;; easy-menu-define) "easymenu" "emacs-lisp/easymenu.el" (15738
+;;;;;; 35331))
;;; Generated autoloads from emacs-lisp/easymenu.el
(put (quote easy-menu-define) (quote lisp-indent-function) (quote defun))
(autoload (quote easy-menu-define) "easymenu" "\
Define a menu bar submenu in maps MAPS, according to MENU.
The menu keymap is stored in symbol SYMBOL, both as its value
-and as its function definition. DOC is used as the doc string for SYMBOL.
+and as its function definition. DOC is used as the doc string for SYMBOL.
The first element of MENU must be a string. It is the menu bar item name.
It may be followed by the following keyword argument pairs
;;;;;; ebrowse-back-in-position-stack ebrowse-tags-search-member-use
;;;;;; ebrowse-tags-query-replace ebrowse-tags-loop-continue ebrowse-tags-complete-symbol
;;;;;; ebrowse-electric-choose-tree ebrowse-tree-mode) "ebrowse"
-;;;;;; "progmodes/ebrowse.el" (15495 20102))
+;;;;;; "progmodes/ebrowse.el" (15664 47250))
;;; Generated autoloads from progmodes/ebrowse.el
(autoload (quote ebrowse-tree-mode) "ebrowse" "\
;;;***
\f
;;;### (autoloads (edebug-eval-top-level-form def-edebug-spec edebug-all-forms
-;;;;;; edebug-all-defs) "edebug" "emacs-lisp/edebug.el" (15542 21134))
+;;;;;; edebug-all-defs) "edebug" "emacs-lisp/edebug.el" (15698 64355))
;;; Generated autoloads from emacs-lisp/edebug.el
(defvar edebug-all-defs nil "\
(defalias (quote edebug-defun) (quote edebug-eval-top-level-form))
(autoload (quote edebug-eval-top-level-form) "edebug" "\
-Evaluate a top level form, such as a defun or defmacro.
-This is like `eval-defun', but the code is always instrumented for Edebug.
-Print its name in the minibuffer and leave point where it is,
-or if an error occurs, leave point after it with mark at the original point." t nil)
+Evaluate the top level form point is in, stepping through with Edebug.
+This is like `eval-defun' except that it steps the code for Edebug
+before evaluating it. It displays the value in the echo area
+using `eval-expression' (which see).
+
+If you do this on a function definition
+such as a defun or defmacro, it defines the function and instruments
+its definition for Edebug, so it will do Edebug stepping when called
+later. It displays `Edebug: FUNCTION' in the echo area to indicate
+that FUNCTION is now instrumented for Edebug.
+
+If the current defun is actually a call to `defvar' or `defcustom',
+evaluating it this way resets the variable using its initial value
+expression even if the variable already has some other value.
+\(Normally `defvar' and `defcustom' do not alter the value if there
+already is one.)" t nil)
;;;***
\f
;;;;;; ediff-windows-linewise ediff-windows-wordwise ediff-merge-directory-revisions-with-ancestor
;;;;;; 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" (15512 11746))
+;;;;;; ediff-directories ediff-buffers3 ediff-buffers ediff-backup
+;;;;;; ediff-files3 ediff-files) "ediff" "ediff.el" (15689 46993))
;;; Generated autoloads from ediff.el
(autoload (quote ediff-files) "ediff" "\
(defalias (quote ediff) (quote ediff-files))
+(autoload (quote ediff-backup) "ediff" "\
+Run Ediff on FILE and its backup file.
+Uses the latest backup, if there are several numerical backups.
+If this file is a backup, `ediff' it with its original." t nil)
+
(autoload (quote ediff-buffers) "ediff" "\
Run Ediff on a pair of buffers, BUFFER-A and BUFFER-B." t nil)
;;;***
\f
;;;### (autoloads (ediff-show-registry) "ediff-mult" "ediff-mult.el"
-;;;;;; (15512 11746))
+;;;;;; (15513 1037))
;;; 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" (15547 47959))
+;;;;;; "ediff-util" "ediff-util.el" (15698 64354))
;;; 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"
-;;;;;; (15186 56482))
+;;;;;; (15738 35316))
;;; Generated autoloads from edmacro.el
- (define-key ctl-x-map "\C-k" 'edit-kbd-macro)
(defvar edmacro-eight-bits nil "\
*Non-nil if edit-kbd-macro should leave 8-bit characters intact.
;;;***
\f
;;;### (autoloads (edt-emulation-on edt-set-scroll-margins) "edt"
-;;;;;; "emulation/edt.el" (15424 44422))
+;;;;;; "emulation/edt.el" (15640 49861))
;;; Generated autoloads from emulation/edt.el
(autoload (quote edt-set-scroll-margins) "edt" "\
;;;***
\f
-;;;### (autoloads (elide-head) "elide-head" "elide-head.el" (15186
-;;;;;; 56482))
+;;;### (autoloads (elide-head) "elide-head" "elide-head.el" (15707
+;;;;;; 34351))
;;; Generated autoloads from elide-head.el
(autoload (quote elide-head) "elide-head" "\
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)
+This is suitable as an entry on `find-file-hook' or appropriate mode hooks." t nil)
;;;***
\f
;;;***
\f
;;;### (autoloads (report-emacs-bug) "emacsbug" "mail/emacsbug.el"
-;;;;;; (15566 54822))
+;;;;;; (15672 42728))
;;; Generated autoloads from mail/emacsbug.el
(autoload (quote report-emacs-bug) "emacsbug" "\
;;;***
\f
;;;### (autoloads (encoded-kbd-mode) "encoded-kb" "international/encoded-kb.el"
-;;;;;; (15538 8043))
+;;;;;; (15538 21134))
;;; Generated autoloads from international/encoded-kb.el
(defvar encoded-kbd-mode nil "\
;;;***
\f
;;;### (autoloads (enriched-decode enriched-encode enriched-mode)
-;;;;;; "enriched" "enriched.el" (15535 7606))
+;;;;;; "enriched" "enriched.el" (15535 38780))
;;; Generated autoloads from enriched.el
(autoload (quote enriched-mode) "enriched" "\
;;;***
\f
-;;;### (autoloads (eshell-mode) "esh-mode" "eshell/esh-mode.el" (15470
-;;;;;; 10677))
+;;;### (autoloads (eshell-mode) "esh-mode" "eshell/esh-mode.el" (15623
+;;;;;; 551))
;;; Generated autoloads from eshell/esh-mode.el
(autoload (quote eshell-mode) "esh-mode" "\
;;;***
\f
;;;### (autoloads (eshell-report-bug eshell-command-result eshell-command
-;;;;;; eshell) "eshell" "eshell/eshell.el" (15470 1515))
+;;;;;; eshell) "eshell" "eshell/eshell.el" (15683 14756))
;;; Generated autoloads from eshell/eshell.el
(autoload (quote eshell) "eshell" "\
The buffer used for Eshell sessions is determined by the value of
`eshell-buffer-name'. If there is already an Eshell session active in
that buffer, Emacs will simply switch to it. Otherwise, a new session
-will begin. A new session is always created if the prefix
-argument ARG is specified. Returns the buffer selected (or created)." t nil)
+will begin. A numeric prefix arg (as in `C-u 42 M-x eshell RET')
+switches to the session with that number, creating it if necessary. A
+nonnumeric prefix arg means to create a new session. Returns the
+buffer selected (or created)." t nil)
(autoload (quote eshell-command) "eshell" "\
Execute the Eshell command string COMMAND.
;;;;;; find-tag find-tag-noselect tags-table-files visit-tags-table
;;;;;; find-tag-default-function find-tag-hook tags-add-tables tags-compression-info-list
;;;;;; tags-table-list tags-case-fold-search) "etags" "progmodes/etags.el"
-;;;;;; (15542 20094))
+;;;;;; (15738 35332))
;;; Generated autoloads from progmodes/etags.el
(defvar tags-file-name nil "\
;;;;;; 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)
-;;;;;; "ethio-util" "language/ethio-util.el" (15391 46451))
+;;;;;; "ethio-util" "language/ethio-util.el" (15707 34351))
;;; Generated autoloads from language/ethio-util.el
(autoload (quote setup-ethiopic-environment-internal) "ethio-util" nil nil nil)
;;;***
\f
-;;;### (autoloads (f90-mode) "f90" "progmodes/f90.el" (15568 32039))
+;;;### (autoloads (f90-mode) "f90" "progmodes/f90.el" (15730 33159))
;;; Generated autoloads from progmodes/f90.el
(autoload (quote f90-mode) "f90" "\
;;;;;; 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" (15566 54821))
+;;;;;; "facemenu" "facemenu.el" (15657 51987))
;;; Generated autoloads from facemenu.el
(define-key global-map "\M-g" 'facemenu-keymap)
(autoload 'facemenu-keymap "facemenu" "Keymap for face-changing commands." t 'keymap)
(setq facemenu-menu (make-sparse-keymap "Text Properties"))
-(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 "Describe Text") (quote describe-text-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 [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 "Describe Properties") (quote describe-text-properties))) (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 (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))))
;;;***
\f
;;;### (autoloads (ffap-bindings dired-at-point ffap-at-mouse ffap-menu
-;;;;;; find-file-at-point ffap-next) "ffap" "ffap.el" (15576 11370))
+;;;;;; find-file-at-point ffap-next) "ffap" "ffap.el" (15576 17069))
;;; Generated autoloads from ffap.el
(autoload (quote ffap-next) "ffap" "\
;;;***
\f
;;;### (autoloads (file-cache-minibuffer-complete) "filecache" "filecache.el"
-;;;;;; (15567 1421))
+;;;;;; (15567 16400))
;;; 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" (15560 12076))
+;;;;;; find-ls-option) "find-dired" "find-dired.el" (15593 24723))
;;; 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"
-;;;;;; (15561 49354))
+;;;;;; (15561 55028))
;;; 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-function-search-for-symbol) "find-func"
-;;;;;; "emacs-lisp/find-func.el" (15577 21908))
+;;;;;; "emacs-lisp/find-func.el" (15738 35331))
;;; Generated autoloads from emacs-lisp/find-func.el
(autoload (quote find-function-search-for-symbol) "find-func" "\
Search for SYMBOL.
If VARIABLE-P is nil, `find-function-regexp' is used, otherwise
-`find-variable-regexp' is used. The search is done in library LIBRARY." nil nil)
+`find-variable-regexp' is used. The search is done in library LIBRARY." nil nil)
(autoload (quote find-function-noselect) "find-func" "\
Return a pair (BUFFER . POINT) pointing to the definition of FUNCTION.
;;;***
\f
;;;### (autoloads (finder-by-keyword finder-commentary finder-list-keywords)
-;;;;;; "finder" "finder.el" (15515 48615))
+;;;;;; "finder" "finder.el" (15518 17562))
;;; Generated autoloads from finder.el
(autoload (quote finder-list-keywords) "finder" "\
\f
;;;### (autoloads (flyspell-buffer flyspell-region flyspell-mode-off
;;;;;; flyspell-version flyspell-mode flyspell-prog-mode flyspell-mode-line-string)
-;;;;;; "flyspell" "textmodes/flyspell.el" (15577 18154))
+;;;;;; "flyspell" "textmodes/flyspell.el" (15577 29858))
;;; Generated autoloads from textmodes/flyspell.el
(defvar flyspell-mode-line-string " Fly" "\
;;;***
\f
-;;;### (autoloads (font-lock-fontify-buffer global-font-lock-mode
-;;;;;; font-lock-remove-keywords font-lock-add-keywords turn-on-font-lock
-;;;;;; font-lock-mode) "font-lock" "font-lock.el" (15525 29334))
+;;;### (autoloads (font-lock-fontify-buffer font-lock-remove-keywords
+;;;;;; font-lock-add-keywords) "font-lock" "font-lock.el" (15727
+;;;;;; 34855))
;;; Generated autoloads from font-lock.el
-(make-variable-buffer-local (quote font-lock-defaults))
-
-(autoload (quote font-lock-mode) "font-lock" "\
-Toggle Font Lock mode.
-With arg, turn Font Lock mode off if and only if arg is a non-positive
-number; if arg is nil, toggle Font Lock mode; anything else turns Font
-Lock on.
-\(Font Lock is also known as \"syntax highlighting\".)
-
-When Font Lock mode is enabled, text is fontified as you type it:
-
- - Comments are displayed in `font-lock-comment-face';
- - Strings are displayed in `font-lock-string-face';
- - Certain other expressions are displayed in other faces according to the
- value of the variable `font-lock-keywords'.
-
-To customize the faces (colors, fonts, etc.) used by Font Lock for
-fontifying different parts of buffer text, use \\[customize-face].
-
-You can enable Font Lock mode in any major mode automatically by turning on in
-the major mode's hook. For example, put in your ~/.emacs:
-
- (add-hook 'c-mode-hook 'turn-on-font-lock)
-
-Alternatively, you can use Global Font Lock mode to automagically turn on Font
-Lock mode in buffers whose major mode supports it and whose major mode is one
-of `font-lock-global-modes'. For example, put in your ~/.emacs:
-
- (global-font-lock-mode t)
-
-There are a number of support modes that may be used to speed up Font Lock mode
-in various ways, specified via the variable `font-lock-support-mode'. Where
-major modes support different levels of fontification, you can use the variable
-`font-lock-maximum-decoration' to specify which level you generally prefer.
-When you turn Font Lock mode on/off the buffer is fontified/defontified, though
-fontification occurs only if the buffer is less than `font-lock-maximum-size'.
-
-For example, to specify that Font Lock mode use use Lazy Lock mode as a support
-mode and use maximum levels of fontification, put in your ~/.emacs:
-
- (setq font-lock-support-mode 'lazy-lock-mode)
- (setq font-lock-maximum-decoration t)
-
-To add your own highlighting for some major mode, and modify the highlighting
-selected automatically via the variable `font-lock-maximum-decoration', you can
-use `font-lock-add-keywords'.
-
-To fontify a buffer, without turning on Font Lock mode and regardless of buffer
-size, you can use \\[font-lock-fontify-buffer].
-
-To fontify a block (the function or paragraph containing point, or a number of
-lines around point), perhaps because modification on the current line caused
-syntactic change on other lines, you can use \\[font-lock-fontify-block].
-
-See the variable `font-lock-defaults-alist' for the Font Lock mode default
-settings. You can set your own default settings for some mode, by setting a
-buffer local value for `font-lock-defaults', via its mode hook." t nil)
-
-(autoload (quote turn-on-font-lock) "font-lock" "\
-Turn on Font Lock mode (only if the terminal can display it)." nil nil)
-
(autoload (quote font-lock-add-keywords) "font-lock" "\
Add highlighting KEYWORDS for MODE.
MODE should be a symbol, the major mode command name, such as `c-mode'
to use nil for MODE (and place the call in a loop or on a hook) to avoid
subtle problems due to details of the implementation.
-Note that some modes have specialised support for additional patterns, e.g.,
+Note that some modes have specialized support for additional patterns, e.g.,
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)
to use nil for MODE (and place the call in a loop or on a hook) to avoid
subtle problems due to details of the implementation." nil nil)
-(defvar global-font-lock-mode nil "\
-Non-nil if Global-Font-Lock mode is enabled.
-See the command `global-font-lock-mode' for a description of this minor-mode.
-Setting this variable directly does not take effect;
-use either \\[customize] or the function `global-font-lock-mode'.")
-
-(custom-add-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 global-font-lock-mode) "font-lock" "\
-Toggle Font-Lock mode in every buffer.
-With prefix ARG, turn Global-Font-Lock mode on if and only if ARG is positive.
-Font-Lock mode is actually not turned on in every buffer but only in those
-in which `turn-on-font-lock-if-enabled' turns it on." t nil)
-
(autoload (quote font-lock-fontify-buffer) "font-lock" "\
Fontify the current buffer the way the function `font-lock-mode' would." t nil)
;;;***
\f
;;;### (autoloads (forms-find-file-other-window forms-find-file forms-mode)
-;;;;;; "forms" "forms.el" (15186 56482))
+;;;;;; "forms" "forms.el" (15590 49016))
;;; Generated autoloads from forms.el
(autoload (quote forms-mode) "forms" "\
;;;***
\f
;;;### (autoloads (fortran-mode fortran-tab-mode-default) "fortran"
-;;;;;; "progmodes/fortran.el" (15568 22303))
+;;;;;; "progmodes/fortran.el" (15727 34846))
;;; Generated autoloads from progmodes/fortran.el
(defvar fortran-tab-mode-default nil "\
choose from a set of files in a directory, call interactively with prefix
and choose the directory as the fortune-file." t nil)
+;;;***
+\f
+;;;### (autoloads (set-fringe-style fringe-mode) "fringe" "fringe.el"
+;;;;;; (15601 35587))
+;;; Generated autoloads from fringe.el
+
+(autoload (quote fringe-mode) "fringe" "\
+Toggle appearance of fringes on all frames.
+Valid values for MODE include `none', `default', `left-only',
+`right-only', `minimal' and `half'. MODE can also be a cons cell
+where the integer in car will be used as left fringe width and the
+integer in cdr will be used as right fringe width. If MODE is not
+specified, the user is queried.
+It applies to all frames that exist and frames to be created in the
+future.
+If you want to set appearance of fringes on the selected frame only,
+see `set-fringe-style'." t nil)
+
+(autoload (quote set-fringe-style) "fringe" "\
+Set appearance of fringes on selected frame.
+Valid values for MODE include `none', `default', `left-only',
+`right-only', `minimal' and `half'. MODE can also be a cons cell
+where the integer in car will be used as left fringe width and the
+integer in cdr will be used as right fringe width. If MODE is not
+specified, the user is queried.
+If you want to set appearance of fringes on all frames, see `fringe-mode'." t nil)
+
;;;***
\f
;;;### (autoloads (generic-mode define-generic-mode) "generic" "generic.el"
;;;***
\f
;;;### (autoloads (gnus-article-prepare-display) "gnus-art" "gnus/gnus-art.el"
-;;;;;; (15477 13591))
+;;;;;; (15727 34848))
;;; Generated autoloads from gnus/gnus-art.el
(autoload (quote gnus-article-prepare-display) "gnus-art" "\
;;;***
\f
;;;### (autoloads (gnus-fetch-group-other-frame gnus-fetch-group)
-;;;;;; "gnus-group" "gnus/gnus-group.el" (15530 4992))
+;;;;;; "gnus-group" "gnus/gnus-group.el" (15533 28774))
;;; Generated autoloads from gnus/gnus-group.el
(autoload (quote gnus-fetch-group) "gnus-group" "\
;;;***
\f
;;;### (autoloads (gnus-declare-backend gnus-unload) "gnus-start"
-;;;;;; "gnus/gnus-start.el" (15514 12379))
+;;;;;; "gnus/gnus-start.el" (15651 7289))
;;; Generated autoloads from gnus/gnus-start.el
(autoload (quote gnus-unload) "gnus-start" "\
;;;***
\f
-;;;### (autoloads (gomoku) "gomoku" "play/gomoku.el" (15514 64735))
+;;;### (autoloads (gomoku) "gomoku" "play/gomoku.el" (15515 40568))
;;; Generated autoloads from play/gomoku.el
(autoload (quote gomoku) "gomoku" "\
;;;***
\f
;;;### (autoloads (jdb pdb perldb xdb dbx sdb gdb) "gud" "gud.el"
-;;;;;; (15521 62479))
+;;;;;; (15522 14844))
;;; Generated autoloads from gud.el
(autoload (quote gdb) "gud" "\
;;;***
\f
-;;;### (autoloads (handwrite) "handwrite" "play/handwrite.el" (15187
-;;;;;; 60207))
+;;;### (autoloads (handwrite) "handwrite" "play/handwrite.el" (15587
+;;;;;; 64724))
;;; Generated autoloads from play/handwrite.el
(autoload (quote handwrite) "handwrite" "\
\f
;;;### (autoloads (describe-categories describe-syntax describe-variable
;;;;;; variable-at-point describe-function-1 describe-function locate-library
-;;;;;; help-with-tutorial) "help-fns" "help-fns.el" (15573 52064))
+;;;;;; help-with-tutorial) "help-fns" "help-fns.el" (15735 17293))
;;; Generated autoloads from help-fns.el
(autoload (quote help-with-tutorial) "help-fns" "\
(autoload (quote locate-library) "help-fns" "\
Show the precise file name of Emacs library LIBRARY.
-This command searches the directories in `load-path' like `M-x load-library'
-to find the file that `M-x load-library RET LIBRARY RET' would load.
+This command searches the directories in `load-path' like `\\[load-library]'
+to find the file that `\\[load-library] RET LIBRARY RET' would load.
Optional second arg NOSUFFIX non-nil means don't add suffixes `load-suffixes'
to the specified name LIBRARY.
\f
;;;### (autoloads (help-xref-on-pp help-insert-xref-button help-xref-button
;;;;;; help-make-xrefs help-setup-xref help-mode-finish help-mode-setup
-;;;;;; help-mode) "help-mode" "help-mode.el" (15424 41953))
+;;;;;; help-mode) "help-mode" "help-mode.el" (15669 19465))
;;; Generated autoloads from help-mode.el
(autoload (quote help-mode) "help-mode" "\
(autoload (quote help-make-xrefs) "help-mode" "\
Parse and hyperlink documentation cross-references in the given BUFFER.
-Find cross-reference information in a buffer and, if
-`help-highlight-p' is non-nil, highlight it with face defined by
-`help-highlight-face'; activate such cross references for selection
-with `help-follow'. Cross-references have the canonical form `...'
-and the type of reference may be disambiguated by the preceding
-word(s) used in `help-xref-symbol-regexp'.
+Find cross-reference information in a buffer and activate such cross
+references for selection with `help-follow'. Cross-references have
+the canonical form `...' and the type of reference may be
+disambiguated by the preceding word(s) used in
+`help-xref-symbol-regexp'.
If the variable `help-xref-mule-regexp' is non-nil, find also
cross-reference information related to multilingual environment
;;;***
\f
;;;### (autoloads (hexlify-buffer hexl-find-file hexl-mode) "hexl"
-;;;;;; "hexl.el" (15490 51792))
+;;;;;; "hexl.el" (15661 53042))
;;; Generated autoloads from hexl.el
(autoload (quote hexl-mode) "hexl" "\
\\<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
+of 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
;;;***
\f
;;;### (autoloads (hide-ifdef-lines hide-ifdef-read-only hide-ifdef-initially
-;;;;;; hide-ifdef-mode) "hideif" "progmodes/hideif.el" (15494 12696))
+;;;;;; hide-ifdef-mode) "hideif" "progmodes/hideif.el" (15496 13874))
;;; Generated autoloads from progmodes/hideif.el
(autoload (quote hide-ifdef-mode) "hideif" "\
;;;***
\f
;;;### (autoloads (hs-minor-mode hs-hide-comments-when-hiding-all)
-;;;;;; "hideshow" "progmodes/hideshow.el" (15538 7669))
+;;;;;; "hideshow" "progmodes/hideshow.el" (15587 64724))
;;; Generated autoloads from progmodes/hideshow.el
(defvar hs-hide-comments-when-hiding-all t "\
;;;### (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" (15556 11212))
+;;;;;; "hilit-chg" "hilit-chg.el" (15738 35316))
;;; Generated autoloads from hilit-chg.el
(defvar highlight-changes-mode nil)
shown in the last face in the list.
You can automatically rotate colours when the buffer is saved
-by adding the following to `local-write-file-hooks', by evaling it in the
+by adding the following to `local-write-file-hooks', by evaling it in the
buffer to be saved):
(add-hook 'local-write-file-hooks 'highlight-changes-rotate-faces)" t nil)
When called from a program:
- if ARG is nil or omitted, turn it off
-- if ARG is `active', turn it on in active mode
+- if ARG is `active', turn it on in active mode
- if ARG is `passive', turn it on in passive mode
- otherwise just turn it on
;;;***
\f
;;;### (autoloads (global-hl-line-mode hl-line-mode) "hl-line" "hl-line.el"
-;;;;;; (15521 40298))
+;;;;;; (15522 14844))
;;; Generated autoloads from hl-line.el
(autoload (quote hl-line-mode) "hl-line" "\
;;;;;; ibuffer-backward-filter-group ibuffer-forward-filter-group
;;;;;; ibuffer-toggle-filter-group ibuffer-mouse-toggle-filter-group
;;;;;; ibuffer-interactive-filter-by-mode ibuffer-mouse-filter-by-mode
-;;;;;; ibuffer-auto-mode) "ibuf-ext" "ibuf-ext.el" (15576 843))
+;;;;;; ibuffer-auto-mode) "ibuf-ext" "ibuf-ext.el" (15738 35316))
;;; Generated autoloads from ibuf-ext.el
(autoload (quote ibuffer-auto-mode) "ibuf-ext" "\
If prefix argument ADD is non-nil, then add the saved filters instead
of replacing the current filters." t nil)
(autoload 'ibuffer-filter-by-mode "ibuf-ext.el")
+ (autoload 'ibuffer-filter-by-used-mode "ibuf-ext.el")
(autoload 'ibuffer-filter-by-name "ibuf-ext.el")
(autoload 'ibuffer-filter-by-filename "ibuf-ext.el")
(autoload 'ibuffer-filter-by-size-gt "ibuf-ext.el")
;;;***
\f
;;;### (autoloads (define-ibuffer-filter define-ibuffer-op define-ibuffer-sorter
-;;;;;; define-ibuffer-column) "ibuf-macs" "ibuf-macs.el" (15569
-;;;;;; 32086))
+;;;;;; define-ibuffer-column) "ibuf-macs" "ibuf-macs.el" (15623
+;;;;;; 547))
;;; Generated autoloads from ibuf-macs.el
(autoload (quote define-ibuffer-column) "ibuf-macs" "\
Define a column SYMBOL for use with `ibuffer-formats'.
BODY will be called with `buffer' bound to the buffer object, and
-`mark' bound to the current mark on the buffer. The current buffer
-will be `buffer'.
+`mark' bound to the current mark on the buffer. The original ibuffer
+buffer will be bound to `ibuffer-buf'.
If NAME is given, it will be used as a title for the column.
Otherwise, the title will default to a capitalized version of the
value if and only if `a' is \"less than\" `b'." nil (quote macro))
(autoload (quote define-ibuffer-op) "ibuf-macs" "\
-Generate a function named `ibuffer-do-OP', which operates on a buffer.
+Generate a function which operates on a buffer.
+OP becomes the name of the function; if it doesn't begin with
+`ibuffer-do-', then that is prepended to it.
When an operation is performed, this function will be called once for
each marked buffer, with that buffer current.
;;;***
\f
;;;### (autoloads (ibuffer ibuffer-other-window ibuffer-list-buffers)
-;;;;;; "ibuffer" "ibuffer.el" (15576 843))
+;;;;;; "ibuffer" "ibuffer.el" (15727 34854))
;;; Generated autoloads from ibuffer.el
(autoload (quote ibuffer-list-buffers) "ibuffer" "\
Optional argument SHRINK means shrink the buffer to minimal size. The
special value `onewindow' means always use another window.
Optional argument FILTER-GROUPS is an initial set of filtering
-groups to use; see `ibuffer-filter-groups'." t nil)
+groups to use; see `ibuffer-filter-groups'.
+Optional argument FORMATS is the value to use for `ibuffer-formats'.
+If specified, then the variable `ibuffer-formats' will have that value
+locally in this buffer." t nil)
;;;***
\f
;;;***
\f
;;;### (autoloads (idlwave-shell) "idlw-shell" "progmodes/idlw-shell.el"
-;;;;;; (15470 21905))
+;;;;;; (15738 35332))
;;; Generated autoloads from progmodes/idlw-shell.el
(autoload (quote idlwave-shell) "idlw-shell" "\
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 command to run comes from variable `idlwave-shell-explicit-file-name',
+with options taken from `idlwave-shell-command-line-options'.
The buffer is put in `idlwave-shell-mode', providing commands for sending
input and controlling the IDL job. See help on `idlwave-shell-mode'.
;;;***
\f
;;;### (autoloads (idlwave-mode) "idlwave" "progmodes/idlwave.el"
-;;;;;; (15470 22102))
+;;;;;; (15738 35332))
;;; Generated autoloads from progmodes/idlwave.el
(autoload (quote idlwave-mode) "idlwave" "\
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.
+ 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:
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).
+ 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').
+ 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
+ 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 item 4).
3. Online IDL Help
9. Documentation and Customization
-------------------------------
- Info documentation for this package is available. Use \\[idlwave-info]
- to display (complain to your sysadmin if that does not work).
- For Postscript and HTML versions of the documentation, check IDLWAVE's
- homepage at `http://www.strw.leidenuniv.nl/~dominik/Tools/idlwave'.
+ Info documentation for this package is available. Use
+ \\[idlwave-info] to display (complain to your sysadmin if that does
+ not work). For Postscript, PDF, and HTML versions of the
+ documentation, check IDLWAVE's homepage at `http://idlwave.org'.
IDLWAVE has customize support - see the group `idlwave'.
10.Keybindings
;;;***
\f
-;;;### (autoloads (ielm) "ielm" "ielm.el" (15482 24869))
+;;;### (autoloads (ido-read-directory-name ido-read-file-name ido-dired
+;;;;;; ido-insert-file ido-write-file ido-find-file-other-frame
+;;;;;; ido-display-file ido-find-file-read-only-other-frame ido-find-file-read-only-other-window
+;;;;;; ido-find-file-read-only ido-find-alternate-file ido-find-file-other-window
+;;;;;; ido-find-file ido-find-file-in-dir ido-switch-buffer-other-frame
+;;;;;; ido-insert-buffer ido-kill-buffer ido-display-buffer ido-switch-buffer-other-window
+;;;;;; ido-switch-buffer ido-read-buffer ido-mode ido-mode) "ido"
+;;;;;; "ido.el" (15731 19470))
+;;; Generated autoloads from ido.el
+
+(defvar ido-mode nil "\
+Determines for which functional group (buffer and files) ido behavior
+should be enabled. The following values are possible:
+- 'buffer: Turn only on ido buffer behavior (switching, killing,
+ displaying...)
+- 'file: Turn only on ido file behavior (finding, writing, inserting...)
+- 'both: Turn on ido buffer and file behavior.
+- nil: Turn off any ido switching.
+
+Setting this variable directly does not take effect;
+use either \\[customize] or the function `ido-mode'.")
+
+(custom-add-to-group (quote ido) (quote ido-mode) (quote custom-variable))
+
+(custom-add-load (quote ido-mode) (quote ido))
+
+(autoload (quote ido-mode) "ido" "\
+Toggle ido speed-ups on or off.
+With ARG, turn ido speed-up on if arg is positive, off otherwise.
+If second argument NOBIND is non-nil, no keys are rebound; otherwise,
+turning on ido-mode will modify the default keybindings for the
+find-file and switch-to-buffer families of commands to the ido
+versions of these functions.
+However, if second arg equals 'files, bind only for files, or if it
+equals 'buffers, bind only for buffers.
+This function also adds a hook to the minibuffer." t nil)
+
+(autoload (quote ido-read-buffer) "ido" "\
+Replacement for the built-in `read-buffer'.
+Return the name of a buffer selected.
+PROMPT is the prompt to give to the user. DEFAULT if given is the default
+buffer to be selected, which will go to the front of the list.
+If REQUIRE-MATCH is non-nil, an existing-buffer must be selected.
+If INITIAL is non-nil, it specifies the initial input string." nil nil)
+
+(autoload (quote ido-switch-buffer) "ido" "\
+Switch to another buffer.
+The buffer is displayed according to `ido-default-buffer-method' -- the
+default is to show it in the same window, unless it is already visible
+in another frame.
+
+As you type in a string, all of the buffers matching the string are
+displayed if substring-matching is used (default). Look at
+`ido-enable-prefix' and `ido-toggle-prefix'. When you have found the
+buffer you want, it can then be selected. As you type, most keys have their
+normal keybindings, except for the following: \\<ido-mode-map>
+
+RET Select the buffer at the front of the list of matches. If the
+list is empty, possibly prompt to create new buffer.
+
+\\[ido-select-text] Select the current prompt as the buffer.
+If no buffer is found, prompt for a new one.
+
+\\[ido-next-match] Put the first element at the end of the list.
+\\[ido-prev-match] Put the last element at the start of the list.
+\\[ido-complete] Complete a common suffix to the current string that
+matches all buffers. If there is only one match, select that buffer.
+If there is no common suffix, show a list of all matching buffers
+in a separate window.
+\\[ido-edit-input] Edit input string.
+\\[ido-fallback-command] Fallback to non-ido version of current command.
+\\[ido-toggle-regexp] Toggle regexp searching.
+\\[ido-toggle-prefix] Toggle between substring and prefix matching.
+\\[ido-toggle-case] Toggle case-sensitive searching of buffer names.
+\\[ido-completion-help] Show list of matching buffers in separate window.
+\\[ido-enter-find-file] Drop into ido-find-file.
+\\[ido-kill-buffer-at-head] Kill buffer at head of buffer list.
+\\[ido-toggle-ignore] Toggle ignoring buffers listed in `ido-ignore-buffers'." t nil)
+
+(autoload (quote ido-switch-buffer-other-window) "ido" "\
+Switch to another buffer and show it in another window.
+The buffer name is selected interactively by typing a substring.
+For details of keybindings, do `\\[describe-function] ido'." t nil)
+
+(autoload (quote ido-display-buffer) "ido" "\
+Display a buffer in another window but don't select it.
+The buffer name is selected interactively by typing a substring.
+For details of keybindings, do `\\[describe-function] ido'." t nil)
+
+(autoload (quote ido-kill-buffer) "ido" "\
+Kill a buffer.
+The buffer name is selected interactively by typing a substring.
+For details of keybindings, do `\\[describe-function] ido'." t nil)
+
+(autoload (quote ido-insert-buffer) "ido" "\
+Insert contents of a buffer in current buffer after point.
+The buffer name is selected interactively by typing a substring.
+For details of keybindings, do `\\[describe-function] ido'." t nil)
+
+(autoload (quote ido-switch-buffer-other-frame) "ido" "\
+Switch to another buffer and show it in another frame.
+The buffer name is selected interactively by typing a substring.
+For details of keybindings, do `\\[describe-function] ido'." t nil)
+
+(autoload (quote ido-find-file-in-dir) "ido" "\
+Switch to another file starting from DIR." t nil)
+
+(autoload (quote ido-find-file) "ido" "\
+Edit file with name obtained via minibuffer.
+The file is displayed according to `ido-default-file-method' -- the
+default is to show it in the same window, unless it is already
+visible in another frame.
+
+The file name is selected interactively by typing a substring. As you type
+in a string, all of the filenames matching the string are displayed if
+substring-matching is used (default). Look at `ido-enable-prefix' and
+`ido-toggle-prefix'. When you have found the filename you want, it can
+then be selected. As you type, most keys have their normal keybindings,
+except for the following: \\<ido-mode-map>
+
+RET Select the file at the front of the list of matches. If the
+list is empty, possibly prompt to create new file.
+
+\\[ido-select-text] Select the current prompt as the buffer or file.
+If no buffer or file is found, prompt for a new one.
+
+\\[ido-next-match] Put the first element at the end of the list.
+\\[ido-prev-match] Put the last element at the start of the list.
+\\[ido-complete] Complete a common suffix to the current string that
+matches all files. If there is only one match, select that file.
+If there is no common suffix, show a list of all matching files
+in a separate window.
+\\[ido-edit-input] Edit input string (including path).
+\\[ido-prev-work-directory] or \\[ido-next-work-directory] go to previous/next directory in work directory history.
+\\[ido-merge-work-directories] search for file in the work directory history.
+\\[ido-forget-work-directory] removes current directory from the work directory history.
+\\[ido-prev-work-file] or \\[ido-next-work-file] cycle through the work file history.
+\\[ido-wide-find-file] and \\[ido-wide-find-dir] prompts and uses find to locate files or directories.
+\\[ido-make-directory] prompts for a directory to create in current directory.
+\\[ido-fallback-command] Fallback to non-ido version of current command.
+\\[ido-toggle-regexp] Toggle regexp searching.
+\\[ido-toggle-prefix] Toggle between substring and prefix matching.
+\\[ido-toggle-case] Toggle case-sensitive searching of file names.
+\\[ido-toggle-vc] Toggle version control for this file.
+\\[ido-toggle-literal] Toggle literal reading of this file.
+\\[ido-completion-help] Show list of matching files in separate window.
+\\[ido-toggle-ignore] Toggle ignoring files listed in `ido-ignore-files'." t nil)
+
+(autoload (quote ido-find-file-other-window) "ido" "\
+Switch to another file and show it in another window.
+The file name is selected interactively by typing a substring.
+For details of keybindings, do `\\[describe-function] ido-find-file'." t nil)
+
+(autoload (quote ido-find-alternate-file) "ido" "\
+Switch to another file and show it in another window.
+The file name is selected interactively by typing a substring.
+For details of keybindings, do `\\[describe-function] ido-find-file'." t nil)
+
+(autoload (quote ido-find-file-read-only) "ido" "\
+Edit file read-only with name obtained via minibuffer.
+The file name is selected interactively by typing a substring.
+For details of keybindings, do `\\[describe-function] ido-find-file'." t nil)
+
+(autoload (quote ido-find-file-read-only-other-window) "ido" "\
+Edit file read-only in other window with name obtained via minibuffer.
+The file name is selected interactively by typing a substring.
+For details of keybindings, do `\\[describe-function] ido-find-file'." t nil)
+
+(autoload (quote ido-find-file-read-only-other-frame) "ido" "\
+Edit file read-only in other frame with name obtained via minibuffer.
+The file name is selected interactively by typing a substring.
+For details of keybindings, do `\\[describe-function] ido-find-file'." t nil)
+
+(autoload (quote ido-display-file) "ido" "\
+Display a file in another window but don't select it.
+The file name is selected interactively by typing a substring.
+For details of keybindings, do `\\[describe-function] ido-find-file'." t nil)
+
+(autoload (quote ido-find-file-other-frame) "ido" "\
+Switch to another file and show it in another frame.
+The file name is selected interactively by typing a substring.
+For details of keybindings, do `\\[describe-function] ido-find-file'." t nil)
+
+(autoload (quote ido-write-file) "ido" "\
+Write current buffer to a file.
+The file name is selected interactively by typing a substring.
+For details of keybindings, do `\\[describe-function] ido-find-file'." t nil)
+
+(autoload (quote ido-insert-file) "ido" "\
+Insert contents of file in current buffer.
+The file name is selected interactively by typing a substring.
+For details of keybindings, do `\\[describe-function] ido-find-file'." t nil)
+
+(autoload (quote ido-dired) "ido" "\
+Call dired the ido way.
+The directory is selected interactively by typing a substring.
+For details of keybindings, do `\\[describe-function] ido-find-file'." t nil)
+
+(autoload (quote ido-read-file-name) "ido" "\
+Read file name, prompting with PROMPT and completing in directory DIR.
+See `read-file-name' for additional parameters." nil nil)
+
+(autoload (quote ido-read-directory-name) "ido" "\
+Read directory name, prompting with PROMPT and completing in directory DIR.
+See `read-file-name' for additional parameters." nil nil)
+
+;;;***
+\f
+;;;### (autoloads (ielm) "ielm" "ielm.el" (15727 34854))
;;; Generated autoloads from ielm.el
(add-hook 'same-window-buffer-names "*ielm*")
\f
;;;### (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" (15500 45542))
+;;;;;; image-type-from-data) "image" "image.el" (15698 64354))
;;; Generated autoloads from image.el
(autoload (quote image-type-from-data) "image" "\
\f
;;;### (autoloads (auto-image-file-mode insert-image-file image-file-name-regexp
;;;;;; image-file-name-regexps image-file-name-extensions) "image-file"
-;;;;;; "image-file.el" (15415 19725))
+;;;;;; "image-file.el" (15579 13239))
;;; Generated autoloads from image-file.el
(defvar image-file-name-extensions (quote ("png" "jpeg" "jpg" "gif" "tiff" "tif" "xbm" "xpm" "pbm" "pgm" "ppm" "pnm")) "\
;;;***
\f
;;;### (autoloads (imenu imenu-add-menubar-index imenu-add-to-menubar
-;;;;;; imenu-sort-function) "imenu" "imenu.el" (15509 27826))
+;;;;;; imenu-sort-function) "imenu" "imenu.el" (15727 34854))
;;; Generated autoloads from imenu.el
(defvar imenu-sort-function nil "\
\f
;;;### (autoloads (indian-char-glyph indian-glyph-char in-is13194-pre-write-conversion
;;;;;; in-is13194-post-read-conversion indian-compose-string indian-compose-region)
-;;;;;; "ind-util" "language/ind-util.el" (15390 23523))
+;;;;;; "ind-util" "language/ind-util.el" (15656 53216))
;;; Generated autoloads from language/ind-util.el
(autoload (quote indian-compose-region) "ind-util" "\
;;;***
\f
;;;### (autoloads (inferior-lisp) "inf-lisp" "progmodes/inf-lisp.el"
-;;;;;; (15394 10957))
+;;;;;; (15651 7290))
;;; Generated autoloads from progmodes/inf-lisp.el
(defvar inferior-lisp-filter-regexp "\\`\\s *\\(:\\(\\w\\|\\s_\\)\\)?\\s *\\'" "\
\f
;;;### (autoloads (Info-speedbar-browser Info-goto-emacs-key-command-node
;;;;;; Info-goto-emacs-command-node Info-directory info-standalone
-;;;;;; info info-other-window) "info" "info.el" (15577 18154))
+;;;;;; info-emacs-manual info info-other-window) "info" "info.el"
+;;;;;; (15685 15800))
;;; Generated autoloads from info.el
(autoload (quote info-other-window) "info" "\
The top-level Info directory is made by combining all the files named `dir'
in all the directories in that path." t nil)
+(autoload (quote info-emacs-manual) "info" nil t nil)
+
(autoload (quote info-standalone) "info" "\
Run Emacs as a standalone Info reader.
Usage: emacs -f info-standalone [filename]
\f
;;;### (autoloads (info-complete-file info-complete-symbol info-lookup-file
;;;;;; info-lookup-symbol info-lookup-reset) "info-look" "info-look.el"
-;;;;;; (15440 59237))
+;;;;;; (15671 8032))
;;; Generated autoloads from info-look.el
(autoload (quote info-lookup-reset) "info-look" "\
;;;***
\f
;;;### (autoloads (iso-accents-mode) "iso-acc" "international/iso-acc.el"
-;;;;;; (15538 7960))
+;;;;;; (15640 49863))
;;; Generated autoloads from international/iso-acc.el
(autoload (quote iso-accents-mode) "iso-acc" "\
;;;;;; ispell-region ispell-change-dictionary ispell-kill-ispell
;;;;;; ispell-help ispell-pdict-save ispell-word ispell-dictionary-alist
;;;;;; ispell-local-dictionary-alist ispell-personal-dictionary)
-;;;;;; "ispell" "textmodes/ispell.el" (15471 40661))
+;;;;;; "ispell" "textmodes/ispell.el" (15686 22779))
;;; Generated autoloads from textmodes/ispell.el
(defconst xemacsp (string-match "Lucid\\|XEmacs" emacs-version) "\
(defvar ispell-menu-map-needed (and (not ispell-menu-map) (not xemacsp) (quote reload)))
-(if (and ispell-menu-map-needed (or (not (fboundp (quote byte-compiling-files-p))) (not (byte-compiling-files-p)))) (let ((dicts (reverse (cons (cons "default" nil) ispell-dictionary-alist))) (path (and (boundp (quote ispell-library-path)) ispell-library-path)) name load-dict) (setq ispell-menu-map (make-sparse-keymap "Spell")) (while dicts (setq name (car (car dicts)) load-dict (car (cdr (member "-d" (nth 5 (car dicts))))) dicts (cdr dicts)) (cond ((not (stringp name)) (define-key ispell-menu-map (vector (quote default)) (cons "Select Default Dict" (cons "Dictionary for which Ispell was configured" (list (quote lambda) nil (quote (interactive)) (list (quote ispell-change-dictionary) "default")))))) ((or (not path) (file-exists-p (concat path "/" name ".hash")) (file-exists-p (concat path "/" name ".has")) (and load-dict (or (file-exists-p (concat path "/" load-dict ".hash")) (file-exists-p (concat path "/" load-dict ".has"))))) (define-key ispell-menu-map (vector (intern name)) (cons (concat "Select " (capitalize name) " Dict") (list (quote lambda) nil (quote (interactive)) (list (quote ispell-change-dictionary) name)))))))))
+(if ispell-menu-map-needed (let ((dicts (reverse (cons (cons "default" nil) ispell-dictionary-alist))) (dir (if (boundp (quote ispell-library-directory)) ispell-library-directory)) 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 [default] (quote ("Select Default Dict" "Dictionary for which Ispell was configured" lambda nil (interactive) (ispell-change-dictionary "default"))))) ((or (not dir) (file-exists-p (concat dir "/" name ".hash")) (file-exists-p (concat dir "/" name ".has")) (and load-dict (or (file-exists-p (concat dir "/" load-dict ".hash")) (file-exists-p (concat dir "/" load-dict ".has"))))) (define-key ispell-menu-map (vector (intern name)) (cons (concat "Select " (capitalize name) " Dict") (\` (lambda nil (interactive) (ispell-change-dictionary (\, name)))))))))))
-(if (and ispell-menu-map-needed (or (not (fboundp (quote byte-compiling-files-p))) (not (byte-compiling-files-p)))) (progn (define-key ispell-menu-map [ispell-change-dictionary] (quote (menu-item "Change Dictionary..." ispell-change-dictionary :help "Supply explicit path to dictionary"))) (define-key ispell-menu-map [ispell-kill-ispell] (quote (menu-item "Kill Process" ispell-kill-ispell :enable (and (boundp (quote ispell-process)) ispell-process (eq (ispell-process-status) (quote run))) :help "Terminate Ispell subprocess"))) (define-key ispell-menu-map [ispell-pdict-save] (quote (menu-item "Save Dictionary" (lambda nil (interactive) (ispell-pdict-save t t)) :help "Save personal dictionary"))) (define-key ispell-menu-map [ispell-customize] (quote (menu-item "Customize..." (lambda nil (interactive) (customize-group (quote ispell))) :help "Customize spell checking options"))) (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 [flyspell-mode] (quote (menu-item "Automatic spell checking (Flyspell)" flyspell-mode :help "Check spelling while you edit the text" :button (:toggle . flyspell-mode)))) (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-change-dictionary] (quote (menu-item "Change Dictionary..." ispell-change-dictionary :help "Supply explicit dictionary file name"))) (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-customize] (quote (menu-item "Customize..." (lambda nil (interactive) (customize-group (quote ispell))) :help "Customize spell checking options"))) (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 [flyspell-mode] (quote (menu-item "Automatic spell checking (Flyspell)" flyspell-mode :help "Check spelling while you edit the text" :button (:toggle . flyspell-mode)))) (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 (and ispell-menu-map-needed (or (not (fboundp (quote byte-compiling-files-p))) (not (byte-compiling-files-p)))) (progn (define-key ispell-menu-map [ispell-continue] (quote (menu-item "Continue Spell-Checking" ispell-continue :enable (and (boundp (quote ispell-region-end)) (marker-position ispell-region-end) (equal (marker-buffer ispell-region-end) (current-buffer))) :help "Continue spell checking last region"))) (define-key ispell-menu-map [ispell-word] (quote (menu-item "Spell-Check Word" ispell-word :help "Spell-check word at cursor"))) (define-key ispell-menu-map [ispell-comments-and-strings] (quote (menu-item "Spell-Check Comments" ispell-comments-and-strings :help "Spell-check only comments and strings")))))
+(if ispell-menu-map-needed (progn (define-key ispell-menu-map [ispell-continue] (quote (menu-item "Continue Spell-Checking" ispell-continue :enable (and (boundp (quote ispell-region-end)) (marker-position ispell-region-end) (equal (marker-buffer ispell-region-end) (current-buffer))) :help "Continue spell checking last region"))) (define-key ispell-menu-map [ispell-word] (quote (menu-item "Spell-Check Word" ispell-word :help "Spell-check word at cursor"))) (define-key ispell-menu-map [ispell-comments-and-strings] (quote (menu-item "Spell-Check Comments" ispell-comments-and-strings :help "Spell-check only comments and strings")))))
-(if (and ispell-menu-map-needed (or (not (fboundp (quote byte-compiling-files-p))) (not (byte-compiling-files-p)))) (progn (define-key ispell-menu-map [ispell-region] (quote (menu-item "Spell-Check Region" ispell-region :enable mark-active :help "Spell-check text in marked region"))) (define-key ispell-menu-map [ispell-message] (quote (menu-item "Spell-Check Message" ispell-message :help "Skip headers and included message text"))) (define-key ispell-menu-map [ispell-buffer] (quote (menu-item "Spell-Check Buffer" ispell-buffer :help "Check spelling of selected buffer"))) (fset (quote ispell-menu-map) (symbol-value (quote ispell-menu-map)))))
+(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 :help "Check spelling of selected buffer"))) (fset (quote ispell-menu-map) (symbol-value (quote ispell-menu-map)))))
(defvar ispell-skip-region-alist (quote ((ispell-words-keyword forward-line) (ispell-dictionary-keyword forward-line) (ispell-pdict-keyword forward-line) (ispell-parsing-keyword forward-line) ("^---*BEGIN PGP [A-Z ]*--*" . "^---*END PGP [A-Z ]*--*") ("^---* \\(Start of \\)?[Ff]orwarded [Mm]essage" . "^---* End of [Ff]orwarded [Mm]essage") ("\\(-+\\|\\(/\\|\\(\\(\\w\\|[-_]\\)+[.:@]\\)\\)\\(\\w\\|[-_]\\)*\\([.:/@]+\\(\\w\\|[-_]\\|~\\)+\\)+\\)"))) "\
Alist expressing beginning and end of regions not to spell check.
\f
;;;### (autoloads (iswitchb-mode iswitchb-buffer-other-frame iswitchb-display-buffer
;;;;;; iswitchb-buffer-other-window iswitchb-buffer iswitchb-default-keybindings
-;;;;;; iswitchb-read-buffer) "iswitchb" "iswitchb.el" (15544 11212))
+;;;;;; iswitchb-read-buffer) "iswitchb" "iswitchb.el" (15544 37705))
;;; Generated autoloads from iswitchb.el
(autoload (quote iswitchb-read-buffer) "iswitchb" "\
;;;***
\f
;;;### (autoloads (with-auto-compression-mode auto-compression-mode)
-;;;;;; "jka-compr" "jka-compr.el" (15409 25587))
+;;;;;; "jka-compr" "jka-compr.el" (15730 33155))
;;; Generated autoloads from jka-compr.el
(defvar auto-compression-mode nil "\
;;;***
\f
-;;;### (autoloads (keypad-setup keypad-shifted-setup keypad-setup)
-;;;;;; "keypad" "emulation/keypad.el" (15564 28215))
+;;;### (autoloads (keypad-setup keypad-numlock-shifted-setup keypad-shifted-setup
+;;;;;; keypad-numlock-setup keypad-setup) "keypad" "emulation/keypad.el"
+;;;;;; (15640 49861))
;;; Generated autoloads from emulation/keypad.el
(defvar keypad-setup nil "\
-Specifies the keypad setup for unshifted keypad keys.
-The options are:
- 'prefix Numeric prefix argument, i.e. M-0 .. M-9 and M--
- 'cursor Cursor movement keys.
- 'S-cursor Shifted cursor movement keys.
- 'numeric Plain numeric, i.e. 0 .. 9 and . (or DECIMAL arg)
- 'none Removes all bindings for keypad keys in function-key-map.
- nil Keep existing bindings for the keypad keys.")
+Specifies the keypad setup for unshifted keypad keys when NumLock is off.
+When selecting the plain numeric keypad setup, the character returned by the
+decimal key must be specified.")
(custom-add-to-group (quote keyboard) (quote keypad-setup) (quote custom-variable))
(custom-add-load (quote keypad-setup) (quote keypad))
+(defvar keypad-numlock-setup nil "\
+Specifies the keypad setup for unshifted keypad keys when NumLock is on.
+When selecting the plain numeric keypad setup, the character returned by the
+decimal key must be specified.")
+
+(custom-add-to-group (quote keyboard) (quote keypad-numlock-setup) (quote custom-variable))
+
+(custom-add-load (quote keypad-numlock-setup) (quote keypad))
+
(defvar keypad-shifted-setup nil "\
-Specifies the keypad setup for shifted keypad keys.
-See `keypad-setup' for available options.")
+Specifies the keypad setup for shifted keypad keys when NumLock is off.
+When selecting the plain numeric keypad setup, the character returned by the
+decimal key must be specified.")
(custom-add-to-group (quote keyboard) (quote keypad-shifted-setup) (quote custom-variable))
(custom-add-load (quote keypad-shifted-setup) (quote keypad))
+(defvar keypad-numlock-shifted-setup nil "\
+Specifies the keypad setup for shifted keypad keys when NumLock is off.
+When selecting the plain numeric keypad setup, the character returned by the
+decimal key must be specified.")
+
+(custom-add-to-group (quote keyboard) (quote keypad-numlock-shifted-setup) (quote custom-variable))
+
+(custom-add-load (quote keypad-numlock-shifted-setup) (quote keypad))
+
(autoload (quote keypad-setup) "keypad" "\
Set keypad bindings in function-key-map according to SETUP.
If optional second argument NUMLOCK is non-nil, the NumLock On bindings
are changed. Otherwise, the NumLock Off bindings are changed.
+If optional third argument SHIFT is non-nil, the shifted keypad
+keys are bound.
Setup Binding
-------------------------------------------------------------
'prefix Command prefix argument, i.e. M-0 .. M-9 and M--
'S-cursor Bind shifted keypad keys to the shifted cursor movement keys.
'cursor Bind keypad keys to the cursor movement keys.
- 'numeric Plain numeric, i.e. 0 .. 9 and . (or DECIMAL arg)
+ 'numeric Plain numeric keypad, i.e. 0 .. 9 and . (or DECIMAL arg)
'none Removes all bindings for keypad keys in function-key-map.
-If SETUP is 'numeric and the optional third argument DECIMAL is non-nil,
+If SETUP is 'numeric and the optional fourth argument DECIMAL is non-nil,
the decimal key on the keypad is mapped to DECIMAL instead of `.'" nil nil)
;;;***
When it returns, the point is at the tail of the selected conversion,
and the return value is the length of the conversion." t nil)
+;;;***
+\f
+;;;### (autoloads (kmacro-end-call-mouse kmacro-end-and-call-macro
+;;;;;; kmacro-end-or-call-macro kmacro-start-macro-or-insert-counter
+;;;;;; kmacro-call-macro kmacro-end-macro kmacro-start-macro) "kmacro"
+;;;;;; "kmacro.el" (15739 48977))
+;;; Generated autoloads from kmacro.el
+ (global-set-key "\C-x(" 'kmacro-start-macro)
+ (global-set-key "\C-x)" 'kmacro-end-macro)
+ (global-set-key "\C-xe" 'kmacro-end-and-call-macro)
+ (global-set-key [f3] 'kmacro-start-macro-or-insert-counter)
+ (global-set-key [f4] 'kmacro-end-or-call-macro)
+ (global-set-key "\C-x\C-k" 'kmacro-keymap)
+ (autoload 'kmacro-keymap "kmacro" "Keymap for keyboard macro commands." t 'keymap)
+
+(autoload (quote kmacro-start-macro) "kmacro" "\
+Record subsequent keyboard input, defining a keyboard macro.
+The commands are recorded even as they are executed.
+Use \\[kmacro-end-macro] to finish recording and make the macro available.
+Use \\[call-last-kbd-macro] to execute the macro.
+Use \\[name-last-kbd-macro] to give it a permanent name.
+Non-nil arg (prefix arg) means append to last macro defined;
+
+With \\[universal-argument] prefix, append to last keyboard macro
+defined. Depending on `kmacro-execute-before-append', this may begin
+by re-executing the last macro as if you typed it again.
+
+Otherwise, it sets `kmacro-counter' to ARG or 0 if missing before
+defining the macro.
+
+Use \\[kmacro-insert-counter] to insert (and increment) the macro counter.
+The counter value can be set or modified via \\[kmacro-set-counter] and \\[kmacro-add-counter].
+The format of the counter can be modified via \\[kmacro-set-format]." t nil)
+
+(autoload (quote kmacro-end-macro) "kmacro" "\
+Finish defining a keyboard macro.
+The definition was started by \\[kmacro-start-macro].
+The macro is now available for use via \\[kmacro-call-macro],
+or it can be given a name with \\[name-last-kbd-macro] and then invoked
+under that name.
+
+With numeric arg, repeat macro now that many times,
+counting the definition just completed as the first repetition.
+An argument of zero means repeat until error." t nil)
+
+(autoload (quote kmacro-call-macro) "kmacro" "\
+Call the last keyboard macro that you defined with \\[kmacro-start-macro].
+A prefix argument serves as a repeat count. Zero means repeat until error.
+
+When you call the macro, you can call the macro again by repeating
+just the last key in the key sequence that you used to call this
+command. See `kmacro-call-repeat-key' and `kmacro-call-repeat-with-arg'
+for details on how to adjust or disable this behaviour.
+
+To make a macro permanent so you can call it even after defining
+others, use M-x name-last-kbd-macro." t nil)
+
+(autoload (quote kmacro-start-macro-or-insert-counter) "kmacro" "\
+Record subsequent keyboard input, defining a keyboard macro.
+The commands are recorded even as they are executed.
+
+Sets the `kmacro-counter' to ARG (or 0 if no prefix arg) before defining the
+macro.
+
+With \\[universal-argument], appends to current keyboard macro (keeping
+the current value of `kmacro-counter').
+
+When defining/executing macro, inserts macro counter and increments
+the counter with ARG or 1 if missing. With \\[universal-argument],
+inserts previous kmacro-counter (but do not modify counter).
+
+The macro counter can be modified via \\[kmacro-set-counter] and \\[kmacro-add-counter].
+The format of the counter can be modified via \\[kmacro-set-format]." t nil)
+
+(autoload (quote kmacro-end-or-call-macro) "kmacro" "\
+End kbd macro if currently being defined; else call last kbd macro.
+With numeric prefix ARG, repeat macro that many times.
+With \\[universal-argument], call second macro in macro ring." t nil)
+
+(autoload (quote kmacro-end-and-call-macro) "kmacro" "\
+Call last keyboard macro, ending it first if currently being defined.
+With numeric prefix ARG, repeat macro that many times." t nil)
+
+(autoload (quote kmacro-end-call-mouse) "kmacro" "\
+Move point to the position clicked with the mouse and call last kbd macro.
+If kbd macro currently being defined end it before activating it." t nil)
+
;;;***
\f
;;;### (autoloads (setup-korean-environment-internal) "korea-util"
;;;***
\f
;;;### (autoloads (turn-on-lazy-lock lazy-lock-mode) "lazy-lock"
-;;;;;; "lazy-lock.el" (15509 27929))
+;;;;;; "lazy-lock.el" (15510 21813))
;;; Generated autoloads from lazy-lock.el
(autoload (quote lazy-lock-mode) "lazy-lock" "\
;;;***
\f
-;;;### (autoloads (unload-feature) "loadhist" "loadhist.el" (14846
-;;;;;; 46315))
+;;;### (autoloads (unload-feature) "loadhist" "loadhist.el" (15727
+;;;;;; 34851))
;;; Generated autoloads from loadhist.el
(autoload (quote unload-feature) "loadhist" "\
;;;***
\f
;;;### (autoloads (print-region lpr-region print-buffer lpr-buffer
-;;;;;; lpr-command lpr-switches printer-name) "lpr" "lpr.el" (15185
-;;;;;; 49574))
+;;;;;; lpr-command lpr-switches printer-name) "lpr" "lpr.el" (15595
+;;;;;; 6759))
;;; Generated autoloads from lpr.el
(defvar lpr-windows-system (memq system-type (quote (emx win32 w32 mswindows ms-dos windows-nt))))
;;;***
\f
-;;;### (autoloads (phases-of-moon) "lunar" "calendar/lunar.el" (15186
-;;;;;; 39912))
+;;;### (autoloads (phases-of-moon) "lunar" "calendar/lunar.el" (15683
+;;;;;; 14756))
;;; Generated autoloads from calendar/lunar.el
(autoload (quote phases-of-moon) "lunar" "\
;;;***
\f
;;;### (autoloads (what-domain mail-extract-address-components) "mail-extr"
-;;;;;; "mail/mail-extr.el" (15353 37573))
+;;;;;; "mail/mail-extr.el" (15661 53043))
;;; Generated autoloads from mail/mail-extr.el
(autoload (quote mail-extract-address-components) "mail-extr" "\
\f
;;;### (autoloads (mail-fetch-field mail-unquote-printable-region
;;;;;; mail-unquote-printable mail-quote-printable mail-file-babyl-p
-;;;;;; mail-use-rfc822) "mail-utils" "mail/mail-utils.el" (15512
-;;;;;; 17296))
+;;;;;; mail-use-rfc822) "mail-utils" "mail/mail-utils.el" (15513
+;;;;;; 1037))
;;; Generated autoloads from mail/mail-utils.el
(defvar mail-use-rfc822 nil "\
;;;***
\f
;;;### (autoloads (define-mail-abbrev build-mail-abbrevs mail-abbrevs-setup)
-;;;;;; "mailabbrev" "mail/mailabbrev.el" (15551 24563))
+;;;;;; "mailabbrev" "mail/mailabbrev.el" (15664 47249))
;;; Generated autoloads from mail/mailabbrev.el
(autoload (quote mail-abbrevs-setup) "mailabbrev" "\
;;;;;; 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" (15530 4992))
+;;;;;; message-from-style) "message" "gnus/message.el" (15533 28774))
;;; Generated autoloads from gnus/message.el
(defvar message-from-style (quote default) "\
;;;***
\f
;;;### (autoloads (metapost-mode metafont-mode) "meta-mode" "progmodes/meta-mode.el"
-;;;;;; (15186 56483))
+;;;;;; (15577 64658))
;;; Generated autoloads from progmodes/meta-mode.el
(autoload (quote metafont-mode) "meta-mode" "\
;;;***
\f
-;;;### (autoloads (mouse-sel-mode) "mouse-sel" "mouse-sel.el" (15363
-;;;;;; 46804))
+;;;### (autoloads (mouse-sel-mode) "mouse-sel" "mouse-sel.el" (15669
+;;;;;; 19465))
;;; Generated autoloads from mouse-sel.el
+(defvar mouse-sel-mode nil "\
+Non-nil if Mouse-Sel mode is enabled.
+See the command `mouse-sel-mode' for a description of this minor-mode.
+Setting this variable directly does not take effect;
+use either \\[customize] or the function `mouse-sel-mode'.")
+
+(custom-add-to-group (quote mouse-sel) (quote mouse-sel-mode) (quote custom-variable))
+
+(custom-add-load (quote mouse-sel-mode) (quote mouse-sel))
+
(autoload (quote mouse-sel-mode) "mouse-sel" "\
Toggle Mouse Sel mode.
With prefix ARG, turn Mouse Sel mode on if and only if ARG is positive.
Quad-clicking selects paragraphs.
- Selecting sets the region & X primary selection, but does NOT affect
-the kill-ring, nor do the kill-ring function change the X selection.
+the `kill-ring', nor do the kill-ring functions change the X selection.
Because the mouse handlers set the primary selection directly,
-mouse-sel sets the variables interprogram-cut-function and
-interprogram-paste-function to nil.
+mouse-sel sets the variables `interprogram-cut-function' and
+`interprogram-paste-function' to nil.
- Clicking mouse-2 inserts the contents of the primary selection at
the mouse position (or point, if `mouse-yank-at-point' is non-nil).
;;;***
\f
-;;;### (autoloads (mpuz) "mpuz" "play/mpuz.el" (15572 475))
+;;;### (autoloads (mpuz) "mpuz" "play/mpuz.el" (15572 18539))
;;; Generated autoloads from play/mpuz.el
(autoload (quote mpuz) "mpuz" "\
;;;***
\f
-;;;### (autoloads (msb-mode) "msb" "msb.el" (15577 18154))
+;;;### (autoloads (msb-mode) "msb" "msb.el" (15577 29858))
;;; Generated autoloads from msb.el
(defvar msb-mode nil "\
;;;### (autoloads (mule-diag list-input-methods list-fontsets describe-fontset
;;;;;; describe-font list-coding-categories list-coding-systems
;;;;;; describe-current-coding-system describe-current-coding-system-briefly
-;;;;;; describe-coding-system describe-char-after describe-character-set
-;;;;;; list-charset-chars read-charset list-character-sets) "mule-diag"
-;;;;;; "international/mule-diag.el" (15556 13128))
+;;;;;; describe-coding-system describe-character-set list-charset-chars
+;;;;;; read-charset list-character-sets) "mule-diag" "international/mule-diag.el"
+;;;;;; (15669 48157))
;;; Generated autoloads from international/mule-diag.el
(autoload (quote list-character-sets) "mule-diag" "\
(autoload (quote describe-character-set) "mule-diag" "\
Display information about built-in character set CHARSET." t nil)
-(autoload (quote describe-char-after) "mule-diag" "\
-Display information about the character at POS in the current buffer.
-POS defaults to point.
-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)
;;;;;; 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"
-;;;;;; (15387 32159))
+;;;;;; (15671 1184))
;;; 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)
+(make-obsolete (quote string-to-sequence) "use `string-to-list' or `string-to-vector'." "21.4")
+
(defsubst string-to-list (string) "\
Return a list of characters in STRING." (append string nil))
(autoload (quote truncate-string-to-width) "mule-util" "\
Truncate string STR to end at column END-COLUMN.
-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 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
-if column START-COLUMN appears in the middle of a character in STR.
+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. Both END-COLUMN and START-COLUMN
+are specified in terms of character display width in the current
+buffer; see also `char-width'.
+
+The optional 4th arg PADDING, if non-nil, specifies a padding
+character (which should have a display width of 1) 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 if column START-COLUMN appears in the
+middle of a character in STR.
If PADDING is nil, no padding is added in these cases, so
-the resulting string may be narrower than END-COLUMN." nil nil)
+the resulting string may be narrower than END-COLUMN.
+
+If ELLIPSIS is non-nil, it should be a string which will replace the
+end of STR (including any padding) if it extends beyond END-COLUMN,
+unless the display width of STR is equal to or less than the display
+width of ELLIPSIS. If it is non-nil and not a string, then ELLIPSIS
+defaults to \"...\"." nil nil)
(defalias (quote truncate-string) (quote truncate-string-to-width))
+(make-obsolete (quote truncate-string) (quote truncate-string-to-width) "20.1")
+
(defsubst nested-alist-p (obj) "\
Return t if OBJ is a nested alist.
;;;***
\f
;;;### (autoloads (mwheel-install mouse-wheel-mode) "mwheel" "mwheel.el"
-;;;;;; (15572 25213))
+;;;;;; (15727 34850))
;;; Generated autoloads from mwheel.el
(defvar mouse-wheel-mode nil "\
;;;;;; comment-region uncomment-region comment-kill comment-set-column
;;;;;; comment-indent comment-indent-default comment-normalize-vars
;;;;;; comment-multi-line comment-padding comment-style comment-column)
-;;;;;; "newcomment" "newcomment.el" (15566 54821))
+;;;;;; "newcomment" "newcomment.el" (15732 40307))
;;; Generated autoloads from newcomment.el
(defalias (quote indent-for-comment) (quote comment-indent))
(autoload (quote comment-region) "newcomment" "\
Comment or uncomment each line in the region.
-With just \\[universal-argument] prefix arg, uncomment each line in region BEG..END.
+With just \\[universal-argument] prefix arg, uncomment each line in region BEG .. END.
Numeric prefix arg ARG means use ARG comment characters.
If ARG is negative, delete that many comment characters instead.
By default, comments start at the left margin, are terminated on each line,
;;;***
\f
-;;;### (autoloads (nndoc-add-type) "nndoc" "gnus/nndoc.el" (14857
-;;;;;; 57188))
+;;;### (autoloads (nndoc-add-type) "nndoc" "gnus/nndoc.el" (15640
+;;;;;; 49862))
;;; Generated autoloads from gnus/nndoc.el
(autoload (quote nndoc-add-type) "nndoc" "\
;;;***
\f
;;;### (autoloads (nnfolder-generate-active-file) "nnfolder" "gnus/nnfolder.el"
-;;;;;; (15542 20588))
+;;;;;; (15727 34848))
;;; Generated autoloads from gnus/nnfolder.el
(autoload (quote nnfolder-generate-active-file) "nnfolder" "\
;;;***
\f
;;;### (autoloads (nnml-generate-nov-databases) "nnml" "gnus/nnml.el"
-;;;;;; (15538 8229))
+;;;;;; (15538 21134))
;;; 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" (14791 27653))
+;;;;;; "nnsoup" "gnus/nnsoup.el" (15655 50635))
;;; Generated autoloads from gnus/nnsoup.el
(autoload (quote nnsoup-pack-replies) "nnsoup" "\
;;;***
\f
;;;### (autoloads (disable-command enable-command disabled-command-hook)
-;;;;;; "novice" "novice.el" (15513 5696))
+;;;;;; "novice" "novice.el" (15515 40558))
;;; Generated autoloads from novice.el
(defvar disabled-command-hook (quote disabled-command-hook) "\
;;;***
\f
;;;### (autoloads (outline-minor-mode outline-mode) "outline" "textmodes/outline.el"
-;;;;;; (15369 59595))
+;;;;;; (15593 36680))
;;; Generated autoloads from textmodes/outline.el
(autoload (quote outline-mode) "outline" "\
;;;***
\f
-;;;### (autoloads (show-paren-mode) "paren" "paren.el" (15500 30068))
+;;;### (autoloads (show-paren-mode) "paren" "paren.el" (15501 5682))
;;; Generated autoloads from paren.el
(defvar show-paren-mode nil "\
;;;***
\f
-;;;### (autoloads (pascal-mode) "pascal" "progmodes/pascal.el" (15465
-;;;;;; 21182))
+;;;### (autoloads (pascal-mode) "pascal" "progmodes/pascal.el" (15738
+;;;;;; 35332))
;;; Generated autoloads from progmodes/pascal.el
(autoload (quote pascal-mode) "pascal" "\
;;;***
\f
;;;### (autoloads (pc-selection-mode pc-selection-mode) "pc-select"
-;;;;;; "emulation/pc-select.el" (15509 28072))
+;;;;;; "emulation/pc-select.el" (15510 21814))
;;; Generated autoloads from emulation/pc-select.el
(defvar pc-selection-mode nil "\
;;;***
\f
-;;;### (autoloads (pcomplete/cvs) "pcmpl-cvs" "pcmpl-cvs.el" (15185
-;;;;;; 62672))
+;;;### (autoloads (pcomplete/cvs) "pcmpl-cvs" "pcmpl-cvs.el" (15645
+;;;;;; 3600))
;;; Generated autoloads from pcmpl-cvs.el
(autoload (quote pcomplete/cvs) "pcmpl-cvs" "\
\f
;;;### (autoloads (pcomplete-shell-setup pcomplete-comint-setup pcomplete-list
;;;;;; pcomplete-help pcomplete-expand pcomplete-continue pcomplete-expand-and-complete
-;;;;;; pcomplete-reverse pcomplete) "pcomplete" "pcomplete.el" (15500
-;;;;;; 12111))
+;;;;;; pcomplete-reverse pcomplete) "pcomplete" "pcomplete.el" (15698
+;;;;;; 64354))
;;; Generated autoloads from pcomplete.el
(autoload (quote pcomplete) "pcomplete" "\
\f
;;;### (autoloads (cvs-dired-use-hook cvs-dired-action cvs-status
;;;;;; cvs-update cvs-examine cvs-quickdir cvs-checkout) "pcvs"
-;;;;;; "pcvs.el" (15531 13380))
+;;;;;; "pcvs.el" (15732 40308))
;;; Generated autoloads from pcvs.el
(autoload (quote cvs-checkout) "pcvs" "\
;;;***
\f
-;;;### (autoloads nil "pcvs-defs" "pcvs-defs.el" (15394 12580))
+;;;### (autoloads nil "pcvs-defs" "pcvs-defs.el" (15646 4758))
;;; 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 (picture-mode) "picture" "textmodes/picture.el"
-;;;;;; (15504 26112))
+;;;;;; (15648 42443))
;;; Generated autoloads from textmodes/picture.el
(autoload (quote picture-mode) "picture" "\
;;;***
\f
;;;### (autoloads (run-prolog prolog-mode) "prolog" "progmodes/prolog.el"
-;;;;;; (13446 12665))
+;;;;;; (15609 17209))
;;; Generated autoloads from progmodes/prolog.el
(autoload (quote prolog-mode) "prolog" "\
;;;### (autoloads (ps-mule-begin-page ps-mule-begin-job ps-mule-header-string-charsets
;;;;;; ps-mule-encode-header-string ps-mule-initialize ps-mule-plot-composition
;;;;;; ps-mule-plot-string ps-mule-set-ascii-font ps-mule-prepare-ascii-font
-;;;;;; ps-multibyte-buffer) "ps-mule" "ps-mule.el" (15272 45416))
+;;;;;; ps-multibyte-buffer) "ps-mule" "ps-mule.el" (15677 43265))
;;; Generated autoloads from ps-mule.el
(defvar ps-multibyte-buffer nil "\
;;;;;; ps-spool-region ps-spool-buffer-with-faces ps-spool-buffer
;;;;;; ps-print-region-with-faces ps-print-region ps-print-buffer-with-faces
;;;;;; ps-print-buffer ps-print-customize ps-paper-type) "ps-print"
-;;;;;; "ps-print.el" (15564 39433))
+;;;;;; "ps-print.el" (15728 1715))
;;; Generated autoloads from ps-print.el
(defvar ps-paper-type (quote letter) "\
;;;;;; quail-defrule quail-install-decode-map quail-install-map
;;;;;; quail-define-rules quail-show-keyboard-layout quail-set-keyboard-layout
;;;;;; quail-define-package quail-use-package quail-title) "quail"
-;;;;;; "international/quail.el" (15453 4573))
+;;;;;; "international/quail.el" (15640 49863))
;;; Generated autoloads from international/quail.el
(autoload (quote quail-title) "quail" "\
\f
;;;### (autoloads (recentf-mode recentf-open-more-files recentf-open-files
;;;;;; recentf-cleanup recentf-edit-list recentf-save-list) "recentf"
-;;;;;; "recentf.el" (15565 33514))
+;;;;;; "recentf.el" (15565 44318))
;;; Generated autoloads from recentf.el
(autoload (quote recentf-save-list) "recentf" "\
;;;### (autoloads (clear-rectangle string-insert-rectangle string-rectangle
;;;;;; delete-whitespace-rectangle open-rectangle insert-rectangle
;;;;;; yank-rectangle kill-rectangle extract-rectangle delete-extract-rectangle
-;;;;;; delete-rectangle move-to-column-force) "rect" "rect.el" (15576
-;;;;;; 11370))
+;;;;;; delete-rectangle move-to-column-force) "rect" "rect.el" (15671
+;;;;;; 1183))
;;; Generated autoloads from rect.el
(autoload (quote move-to-column-force) "rect" "\
-Obsolete. Use `move-to-column'.
If COLUMN is within a multi-column character, replace it by spaces and tab.
As for `move-to-column', passing anything but nil or t in FLAG will move to
the desired column only if the line is long enough." nil nil)
+(make-obsolete (quote move-to-column-force) (quote move-to-column) "21.2")
+
(autoload (quote delete-rectangle) "rect" "\
Delete (don't save) text in the region-rectangle.
The same range of columns is deleted in each line starting with the
;;;***
\f
;;;### (autoloads (reftex-mode turn-on-reftex) "reftex" "textmodes/reftex.el"
-;;;;;; (15186 39912))
+;;;;;; (15738 35332))
;;; Generated autoloads from textmodes/reftex.el
(autoload (quote turn-on-reftex) "reftex" "\
;;;***
\f
;;;### (autoloads (reftex-citation) "reftex-cite" "textmodes/reftex-cite.el"
-;;;;;; (15186 39912))
+;;;;;; (15727 34845))
;;; 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
-matching entries for selection. The selected entry is formated according
+matching entries for selection. The selected entry is formatted according
to `reftex-cite-format' and inserted into the buffer.
If NO-INSERT is non-nil, nothing is inserted, only the selected key returned.
;;;***
\f
;;;### (autoloads (reftex-index-phrases-mode) "reftex-index" "textmodes/reftex-index.el"
-;;;;;; (15369 62712))
+;;;;;; (15727 34844))
;;; Generated autoloads from textmodes/reftex-index.el
(autoload (quote reftex-index-phrases-mode) "reftex-index" "\
;;;***
\f
;;;### (autoloads (regexp-opt-depth regexp-opt) "regexp-opt" "emacs-lisp/regexp-opt.el"
-;;;;;; (15419 36726))
+;;;;;; (15640 49861))
;;; Generated autoloads from emacs-lisp/regexp-opt.el
(autoload (quote regexp-opt) "regexp-opt" "\
;;;***
\f
;;;### (autoloads (global-reveal-mode reveal-mode) "reveal" "reveal.el"
-;;;;;; (15400 24203))
+;;;;;; (15593 36678))
;;; Generated autoloads from reveal.el
(autoload (quote reveal-mode) "reveal" "\
;;;***
\f
-;;;### (autoloads (read-file-name-electric-shadow-mode read-file-name-electric-shadow-tty-properties
-;;;;;; read-file-name-electric-shadow-properties) "rfn-eshadow"
-;;;;;; "rfn-eshadow.el" (15577 18154))
+;;;### (autoloads (file-name-shadow-mode file-name-shadow-tty-properties
+;;;;;; file-name-shadow-properties) "rfn-eshadow" "rfn-eshadow.el"
+;;;;;; (15727 34850))
;;; Generated autoloads from rfn-eshadow.el
-(defvar read-file-name-electric-shadow-properties (quote (face read-file-name-electric-shadow field shadow)) "\
+(defvar file-name-shadow-properties (quote (face file-name-shadow field shadow)) "\
Properties given to the `shadowed' part of a filename in the minibuffer.
-Only used when `read-file-name-electric-shadow-mode' is active.
+Only used when `file-name-shadow-mode' is active.
If emacs is not running under a window system,
-`read-file-name-electric-shadow-tty-properties' is used instead.")
+`file-name-shadow-tty-properties' is used instead.")
-(defvar read-file-name-electric-shadow-tty-properties (quote (before-string "{" after-string "} " field shadow)) "\
+(defvar file-name-shadow-tty-properties (quote (before-string "{" after-string "} " field shadow)) "\
Properties given to the `shadowed' part of a filename in the minibuffer.
-Only used when `read-file-name-electric-shadow-mode' is active and emacs
+Only used when `file-name-shadow-mode' is active and emacs
is not running under a window-system; if emacs is running under a window
-system, `read-file-name-electric-shadow-properties' is used instead.")
+system, `file-name-shadow-properties' is used instead.")
-(defvar read-file-name-electric-shadow-mode nil "\
-Non-nil if Read-File-Name-Electric-Shadow mode is enabled.
-See the command `read-file-name-electric-shadow-mode' for a description of this minor-mode.
+(defvar file-name-shadow-mode nil "\
+Non-nil if File-Name-Shadow mode is enabled.
+See the command `file-name-shadow-mode' for a description of this minor-mode.
Setting this variable directly does not take effect;
-use either \\[customize] or the function `read-file-name-electric-shadow-mode'.")
+use either \\[customize] or the function `file-name-shadow-mode'.")
-(custom-add-to-group (quote minibuffer) (quote read-file-name-electric-shadow-mode) (quote custom-variable))
+(custom-add-to-group (quote minibuffer) (quote file-name-shadow-mode) (quote custom-variable))
-(custom-add-load (quote read-file-name-electric-shadow-mode) (quote rfn-eshadow))
+(custom-add-load (quote file-name-shadow-mode) (quote rfn-eshadow))
-(autoload (quote read-file-name-electric-shadow-mode) "rfn-eshadow" "\
-Toggle Read-File-Name Electric Shadow mode.
-When active, any part of the filename being read in the minibuffer
-that would be ignored because the result is passed through
-`substitute-in-file-name' is given the properties in
-`read-file-name-electric-shadow-properties', which can be used to make
+(autoload (quote file-name-shadow-mode) "rfn-eshadow" "\
+Toggle File-Name Shadow mode.
+When active, any part of a filename being read in the minibuffer
+that would be ignored (because the result is passed through
+`substitute-in-file-name') is given the properties in
+`file-name-shadow-properties', which can be used to make
that portion dim, invisible, or otherwise less visually noticeable.
With prefix argument ARG, turn on if positive, otherwise off.
;;;***
\f
-;;;### (autoloads (rlogin) "rlogin" "net/rlogin.el" (15504 36563))
+;;;### (autoloads (rlogin) "rlogin" "net/rlogin.el" (15507 55753))
;;; Generated autoloads from net/rlogin.el
(add-hook 'same-window-regexps "^\\*rlogin-.*\\*\\(\\|<[0-9]+>\\)")
;;;;;; 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" (15574 49295))
+;;;;;; "rmail" "mail/rmail.el" (15727 34847))
;;; Generated autoloads from mail/rmail.el
(defvar rmail-dont-reply-to-names nil "\
(defvar rmail-search-mime-header-function nil "\
Function to check if a regexp matches a header of MIME message.
This function is called if `rmail-enable-mime' is non-nil.
-It is called with four arguments MSG, REGEXP, and LIMIT, where
+It is called with three arguments MSG, REGEXP, and LIMIT, where
MSG is the message number,
REGEXP is the regular expression,
LIMIT is the position specifying the end of header.")
;;;;;; 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" (15479 52723))
+;;;;;; "rmailsum" "mail/rmailsum.el" (15649 61373))
;;; Generated autoloads from mail/rmailsum.el
(defvar rmail-summary-scroll-between-messages t "\
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.
+Then it should be a regexp matching your mail addresses.
Setting this variable has an effect only before reading a mail.")
;;;***
\f
-;;;### (autoloads (toggle-rot13-mode rot13-other-window) "rot13"
-;;;;;; "rot13.el" (15185 49574))
+;;;### (autoloads (toggle-rot13-mode rot13-other-window rot13-region
+;;;;;; rot13-string rot13) "rot13" "rot13.el" (15601 18543))
;;; Generated autoloads from rot13.el
+(autoload (quote rot13) "rot13" "\
+Return Rot13 encryption of OBJECT, a buffer or string." nil nil)
+
+(autoload (quote rot13-string) "rot13" "\
+Return Rot13 encryption of STRING." nil nil)
+
+(autoload (quote rot13-region) "rot13" "\
+Rot13 encrypt the region between START and END in current buffer." t nil)
+
(autoload (quote rot13-other-window) "rot13" "\
Display current buffer in rot 13 in another window.
The text itself is not modified, only the way it is displayed is affected.
;;;***
\f
-;;;### (autoloads (ruler-mode) "ruler-mode" "ruler-mode.el" (15433
-;;;;;; 31797))
+;;;### (autoloads (ruler-mode) "ruler-mode" "ruler-mode.el" (15730
+;;;;;; 33159))
;;; Generated autoloads from ruler-mode.el
(autoload (quote ruler-mode) "ruler-mode" "\
;;;***
\f
-;;;### (autoloads (rx rx-to-string) "rx" "emacs-lisp/rx.el" (15288
-;;;;;; 6955))
+;;;### (autoloads (rx rx-to-string) "rx" "emacs-lisp/rx.el" (15738
+;;;;;; 35331))
;;; Generated autoloads from emacs-lisp/rx.el
(autoload (quote rx-to-string) "rx" "\
still match. A non-greedy regexp matches as little as possible.
`(maximal-match SEXP)'
- produce a greedy regexp for SEXP. This is the default.
+ produce a greedy regexp for SEXP. This is the default.
`(zero-or-more SEXP)'
matches zero or more occurrences of what SEXP matches.
matches N to M occurrences of what SEXP matches.
`(eval FORM)'
- evaluate FORM and insert result. If result is a string,
+ evaluate FORM and insert result. If result is a string,
`regexp-quote' it.
`(regexp REGEXP)'
;;;***
\f
;;;### (autoloads (dsssl-mode scheme-mode) "scheme" "progmodes/scheme.el"
-;;;;;; (15186 56483))
+;;;;;; (15651 7291))
;;; Generated autoloads from progmodes/scheme.el
(autoload (quote scheme-mode) "scheme" "\
;;;***
\f
-;;;### (autoloads (scroll-all-mode scroll-all-mode) "scroll-all"
-;;;;;; "scroll-all.el" (15559 6000))
+;;;### (autoloads (scroll-all-mode) "scroll-all" "scroll-all.el"
+;;;;;; (15704 51484))
;;; Generated autoloads from scroll-all.el
-(defvar scroll-all-mode nil "\
-Control/track scroll locking.
-
+(defvar scroll-all-mode "Toggle Scroll-All minor mode.\nWith ARG, turn Scroll-All minor mode on if ARG is positive, off otherwise.\nWhen Scroll-All mode is on, scrolling commands entered in one window\napply to all visible windows in the same frame." "\
+Non-nil if Scroll-All mode is enabled.
+See the command `scroll-all-mode' for a description of this minor-mode.
Setting this variable directly does not take effect;
use either \\[customize] or the function `scroll-all-mode'.")
-(custom-add-to-group (quote windows) (quote scroll-all-mode) (quote custom-variable))
+(custom-add-to-group (quote scroll-all) (quote scroll-all-mode) (quote custom-variable))
(custom-add-load (quote scroll-all-mode) (quote scroll-all))
(autoload (quote scroll-all-mode) "scroll-all" "\
-Toggle Scroll-All minor mode." t nil)
+ *SL*" t nil)
;;;***
\f
;;;### (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 send-mail-function
-;;;;;; mail-yank-ignored-headers mail-interactive mail-self-blind
-;;;;;; mail-specify-envelope-from mail-from-style) "sendmail" "mail/sendmail.el"
-;;;;;; (15564 31133))
+;;;;;; mail-default-directory mail-signature mail-personal-alias-file
+;;;;;; mail-alias-file mail-default-reply-to mail-archive-file-name
+;;;;;; mail-header-separator send-mail-function mail-yank-ignored-headers
+;;;;;; mail-interactive mail-self-blind mail-specify-envelope-from
+;;;;;; mail-from-style) "sendmail" "mail/sendmail.el" (15731 62230))
;;; Generated autoloads from mail/sendmail.el
(defvar mail-from-style (quote angles) "\
Otherwise, it should be an expression; it is evaluated
and should insert whatever you want to insert.")
+(defvar mail-default-directory "~/" "\
+*Directory for mail buffers.
+Value of `default-directory' for mail buffers.
+This directory is used for auto-save files of mail buffers.")
+
(autoload (quote mail-mode) "sendmail" "\
Major mode for editing mail to be sent.
Like Text Mode but with these additional commands:
;;;***
\f
-;;;### (autoloads (server-start) "server" "server.el" (15391 29182))
+;;;### (autoloads (server-start) "server" "server.el" (15708 56871))
;;; Generated autoloads from server.el
(autoload (quote server-start) "server" "\
;;;***
\f
;;;### (autoloads (html-mode sgml-mode) "sgml-mode" "textmodes/sgml-mode.el"
-;;;;;; (15547 65195))
+;;;;;; (15664 47250))
;;; Generated autoloads from textmodes/sgml-mode.el
(autoload (quote sgml-mode) "sgml-mode" "\
;;;***
\f
;;;### (autoloads (sh-mode) "sh-script" "progmodes/sh-script.el"
-;;;;;; (15437 54281))
+;;;;;; (15738 35332))
;;; Generated autoloads from progmodes/sh-script.el
(put (quote sh-mode) (quote mode-class) (quote special))
;;;***
\f
;;;### (autoloads (list-load-path-shadows) "shadow" "emacs-lisp/shadow.el"
-;;;;;; (15523 24004))
+;;;;;; (15524 61380))
;;; Generated autoloads from emacs-lisp/shadow.el
(autoload (quote list-load-path-shadows) "shadow" "\
;;;***
\f
;;;### (autoloads (shadow-initialize shadow-define-regexp-group shadow-define-literal-group
-;;;;;; shadow-define-cluster) "shadowfile" "shadowfile.el" (15508
-;;;;;; 64852))
+;;;;;; shadow-define-cluster) "shadowfile" "shadowfile.el" (15509
+;;;;;; 450))
;;; Generated autoloads from shadowfile.el
(autoload (quote shadow-define-cluster) "shadowfile" "\
;;;***
\f
;;;### (autoloads (shell shell-dumb-shell-regexp) "shell" "shell.el"
-;;;;;; (15531 7805))
+;;;;;; (15651 7287))
;;; Generated autoloads from shell.el
(defvar shell-dumb-shell-regexp "cmd\\(proxy\\)?\\.exe" "\
;;;***
\f
-;;;### (autoloads (simula-mode) "simula" "progmodes/simula.el" (15394
-;;;;;; 11051))
+;;;### (autoloads (simula-mode) "simula" "progmodes/simula.el" (15727
+;;;;;; 34845))
;;; 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"
-;;;;;; (15184 11044))
+;;;;;; (15585 20334))
;;; Generated autoloads from skeleton.el
(defvar skeleton-filter (quote identity) "\
;;;***
\f
-;;;### (autoloads (smerge-mode) "smerge-mode" "smerge-mode.el" (15347
-;;;;;; 6543))
+;;;### (autoloads (smerge-mode) "smerge-mode" "smerge-mode.el" (15732
+;;;;;; 40308))
;;; Generated autoloads from smerge-mode.el
(autoload (quote smerge-mode) "smerge-mode" "\
;;;***
\f
;;;### (autoloads (smtpmail-send-it) "smtpmail" "mail/smtpmail.el"
-;;;;;; (15577 18154))
+;;;;;; (15734 30756))
;;; Generated autoloads from mail/smtpmail.el
(autoload (quote smtpmail-send-it) "smtpmail" nil nil nil)
\f
;;;### (autoloads (solar-equinoxes-solstices sunrise-sunset calendar-location-name
;;;;;; calendar-longitude calendar-latitude calendar-time-display-form)
-;;;;;; "solar" "calendar/solar.el" (15532 48415))
+;;;;;; "solar" "calendar/solar.el" (15738 35331))
;;; Generated autoloads from calendar/solar.el
(defvar calendar-time-display-form (quote (12-hours ":" minutes am-pm (if time-zone " (") time-zone (if time-zone ")"))) "\
*The pseudo-pattern that governs the way a time of day is formatted.
A pseudo-pattern is a list of expressions that can involve the keywords
-`12-hours', `24-hours', and `minutes', all numbers in string form,
-and `am-pm' and `time-zone', both alphabetic strings.
+`12-hours', `24-hours', and `minutes', all numbers in string form,
+and `am-pm' and `time-zone', both alphabetic strings.
For example, the form
;;;***
\f
-;;;### (autoloads (solitaire) "solitaire" "play/solitaire.el" (15543
-;;;;;; 12464))
+;;;### (autoloads (solitaire) "solitaire" "play/solitaire.el" (15544
+;;;;;; 37711))
;;; 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" (15542 22464))
+;;;;;; sort-lines sort-subr) "sort" "sort.el" (15544 37707))
;;; Generated autoloads from sort.el
(autoload (quote sort-subr) "sort" "\
;;;***
\f
;;;### (autoloads (speedbar-get-focus speedbar-frame-mode) "speedbar"
-;;;;;; "speedbar.el" (15545 44180))
+;;;;;; "speedbar.el" (15738 35331))
;;; Generated autoloads from speedbar.el
(defalias (quote speedbar) (quote speedbar-frame-mode))
;;;;;; strokes-mode strokes-list-strokes strokes-load-user-strokes
;;;;;; strokes-help strokes-describe-stroke strokes-do-complex-stroke
;;;;;; strokes-do-stroke strokes-read-complex-stroke strokes-read-stroke
-;;;;;; strokes-global-set-stroke strokes-mode) "strokes" "strokes.el"
-;;;;;; (15571 26633))
+;;;;;; strokes-global-set-stroke) "strokes" "strokes.el" (15664
+;;;;;; 47248))
;;; Generated autoloads from strokes.el
-(defvar strokes-mode nil "\
-Non-nil when `strokes' is globally enabled.
-Setting this variable directly does not take effect. Use either Customize
-or M-x strokes-mode.")
-
-(custom-add-to-group (quote strokes) (quote strokes-mode) (quote custom-variable))
-
-(custom-add-load (quote strokes-mode) (quote strokes))
-
(autoload (quote strokes-global-set-stroke) "strokes" "\
Interactively give STROKE the global binding as COMMAND.
Operated just like `global-set-key', except for strokes.
is a list of sampled positions on the stroke grid as described in the
documentation for the `strokes-define-stroke' function." t nil)
-(defalias (quote global-set-stroke) (quote strokes-global-set-stroke))
-
(autoload (quote strokes-read-stroke) "strokes" "\
Read a simple stroke (interactively) and return the stroke.
Optional PROMPT in minibuffer displays before and during stroke reading.
Read a complex stroke (interactively) and return the stroke.
Optional PROMPT in minibuffer displays before and during stroke reading.
Note that a complex stroke allows the user to pen-up and pen-down. This
-is implemented by allowing the user to paint with button1 or button2 and
-then complete the stroke with button3.
+is implemented by allowing the user to paint with button 1 or button 2 and
+then complete the stroke with button 3.
Optional EVENT is acceptable as the starting event of the stroke" nil nil)
(autoload (quote strokes-do-stroke) "strokes" "\
(autoload (quote strokes-describe-stroke) "strokes" "\
Displays the command which STROKE maps to, reading STROKE interactively." t nil)
-(defalias (quote describe-stroke) (quote strokes-describe-stroke))
-
(autoload (quote strokes-help) "strokes" "\
-Get instructional help on using the `strokes' package." t nil)
+Get instruction on using the `strokes' package." t nil)
(autoload (quote strokes-load-user-strokes) "strokes" "\
Load user-defined strokes from file named by `strokes-file'." t nil)
-(defalias (quote load-user-strokes) (quote strokes-load-user-strokes))
-
(autoload (quote strokes-list-strokes) "strokes" "\
Pop up a buffer containing an alphabetical listing of strokes in STROKES-MAP.
With CHRONOLOGICAL prefix arg (\\[universal-argument]) list strokes
chronologically by command name.
If STROKES-MAP is not given, `strokes-global-map' will be used instead." t nil)
-(autoload (quote strokes-mode) "strokes" "\
-Toggle strokes being enabled.
-With ARG, turn strokes on if and only if ARG is positive or true.
-Note that `strokes-mode' is a global mode. Think of it as a minor
-mode in all buffers when activated.
-By default, strokes are invoked with mouse button-2. You can define
-new strokes with
+(defvar strokes-mode nil "\
+Non-nil if Strokes mode is enabled.
+See the command `strokes-mode' for a description of this minor-mode.
+Setting this variable directly does not take effect;
+use either \\[customize] or the function `strokes-mode'.")
-> M-x global-set-stroke
+(custom-add-to-group (quote strokes) (quote strokes-mode) (quote custom-variable))
+
+(custom-add-load (quote strokes-mode) (quote strokes))
+
+(autoload (quote strokes-mode) "strokes" "\
+Toggle Strokes global minor mode.\\<strokes-mode-map>
+With ARG, turn strokes on if and only if ARG is positive.
+Strokes are pictographic mouse gestures which invoke commands.
+Strokes are invoked with \\[strokes-do-stroke]. You can define
+new strokes with \\[strokes-global-set-stroke]. See also
+\\[strokes-do-complex-stroke] for `complex' strokes.
To use strokes for pictographic editing, such as Chinese/Japanese, use
-S-mouse-2, which draws strokes and inserts them. Encode/decode your
-strokes with
+\\[strokes-compose-complex-stroke], which draws strokes and inserts them.
+Encode/decode your strokes with \\[strokes-encode-buffer],
+\\[strokes-decode-buffer].
-> M-x strokes-encode-buffer
-> M-x strokes-decode-buffer" t nil)
+\\{strokes-mode-map}" t nil)
(autoload (quote strokes-decode-buffer) "strokes" "\
Decode stroke strings in BUFFER and display their corresponding glyphs.
;;;***
\f
;;;### (autoloads (sc-cite-original) "supercite" "mail/supercite.el"
-;;;;;; (15497 10307))
+;;;;;; (15498 37604))
;;; Generated autoloads from mail/supercite.el
(autoload (quote sc-cite-original) "supercite" "\
;;;***
\f
;;;### (autoloads (syntax-ppss) "syntax" "emacs-lisp/syntax.el" (15569
-;;;;;; 32087))
+;;;;;; 44241))
;;; Generated autoloads from emacs-lisp/syntax.el
(autoload (quote syntax-ppss) "syntax" "\
;;;***
\f
-;;;### (autoloads (talk-connect) "talk" "talk.el" (15569 32087))
+;;;### (autoloads (table-release table-capture table-delete-column
+;;;;;; table-delete-row table-insert-sequence table-generate-source
+;;;;;; table-query-dimension table-fixed-width-mode table-justify-column
+;;;;;; table-justify-row table-justify-cell table-justify table-split-cell
+;;;;;; table-split-cell-horizontally table-split-cell-vertically
+;;;;;; table-span-cell table-backward-cell table-forward-cell table-narrow-cell
+;;;;;; table-widen-cell table-shorten-cell table-heighten-cell table-unrecognize-cell
+;;;;;; table-recognize-cell table-unrecognize-table table-recognize-table
+;;;;;; table-unrecognize-region table-recognize-region table-unrecognize
+;;;;;; table-recognize table-insert-row-column table-insert-column
+;;;;;; table-insert-row table-insert table-point-left-cell-hook
+;;;;;; table-point-entered-cell-hook table-load-hook table-cell-map-hook)
+;;;;;; "table" "textmodes/table.el" (15738 35332))
+;;; Generated autoloads from textmodes/table.el
+
+(defvar table-cell-map-hook nil "\
+*Normal hooks run when finishing construction of `table-cell-map'.
+User can modify `table-cell-map' by adding custom functions here.")
+
+(defvar table-load-hook nil "\
+*List of functions to be called after the table is first loaded.")
+
+(defvar table-point-entered-cell-hook nil "\
+*List of functions to be called after point entered a table cell.")
+
+(defvar table-point-left-cell-hook nil "\
+*List of functions to be called after point left a table cell.")
+
+(autoload (quote table-insert) "table" "\
+Insert an editable text table.
+Insert a table of specified number of COLUMNS and ROWS. Optional
+parameter CELL-WIDTH and CELL-HEIGHT can specify the size of each
+cell. The cell size is uniform across the table if the specified size
+is a number. They can be a list of numbers to specify different size
+for each cell. When called interactively, the list of number is
+entered by simply listing all the numbers with space characters
+delimiting them.
+
+Examples:
+
+\\[table-insert] inserts a table at the current point location.
+
+Suppose we have the following situation where `-!-' indicates the
+location of point.
+
+ -!-
+
+Type \\[table-insert] and hit ENTER key. As it asks table
+specification, provide 3 for number of columns, 1 for number of rows,
+5 for cell width and 1 for cell height. Now you shall see the next
+table and the point is automatically moved to the beginning of the
+first cell.
+
+ +-----+-----+-----+
+ |-!- | | |
+ +-----+-----+-----+
+
+Inside a table cell, there are special key bindings. \\<table-cell-map>
+
+M-9 \\[table-widen-cell] (or \\[universal-argument] 9 \\[table-widen-cell]) widens the first cell by 9 character
+width, which results as
+
+ +--------------+-----+-----+
+ |-!- | | |
+ +--------------+-----+-----+
+
+Type TAB \\[table-widen-cell] then type TAB M-2 M-7 \\[table-widen-cell] (or \\[universal-argument] 2 7 \\[table-widen-cell]). Typing
+TAB moves the point forward by a cell. The result now looks like this:
+
+ +--------------+------+--------------------------------+
+ | | |-!- |
+ +--------------+------+--------------------------------+
+
+If you knew each width of the columns prior to the table creation,
+what you could have done better was to have had given the complete
+width information to `table-insert'.
+
+Cell width(s): 14 6 32
+
+instead of
+
+Cell width(s): 5
+
+This would have eliminated the previously mentioned width adjustment
+work all together.
+
+If the point is in the last cell type S-TAB S-TAB to move it to the
+first cell. Now type \\[table-heighten-cell] which heighten the row by a line.
+
+ +--------------+------+--------------------------------+
+ |-!- | | |
+ | | | |
+ +--------------+------+--------------------------------+
+
+Type \\[table-insert-row-column] and tell it to insert a row.
+
+ +--------------+------+--------------------------------+
+ |-!- | | |
+ | | | |
+ +--------------+------+--------------------------------+
+ | | | |
+ | | | |
+ +--------------+------+--------------------------------+
+
+Move the point under the table as shown below.
+
+ +--------------+------+--------------------------------+
+ | | | |
+ | | | |
+ +--------------+------+--------------------------------+
+ | | | |
+ | | | |
+ +--------------+------+--------------------------------+
+ -!-
+
+Type M-x table-insert-row instead of \\[table-insert-row-column]. \\[table-insert-row-column] does not work
+when the point is outside of the table. This insertion at
+outside of the table effectively appends a row at the end.
+
+ +--------------+------+--------------------------------+
+ | | | |
+ | | | |
+ +--------------+------+--------------------------------+
+ | | | |
+ | | | |
+ +--------------+------+--------------------------------+
+ |-!- | | |
+ | | | |
+ +--------------+------+--------------------------------+
+
+Text editing inside the table cell produces reasonably expected
+results.
+
+ +--------------+------+--------------------------------+
+ | | | |
+ | | | |
+ +--------------+------+--------------------------------+
+ | | |Text editing inside the table |
+ | | |cell produces reasonably |
+ | | |expected results.-!- |
+ +--------------+------+--------------------------------+
+ | | | |
+ | | | |
+ +--------------+------+--------------------------------+
+
+Inside a table cell has a special keymap.
+
+\\{table-cell-map}
+" t nil)
+
+(autoload (quote table-insert-row) "table" "\
+Insert N table row(s).
+When point is in a table the newly inserted row(s) are placed above
+the current row. When point is outside of the table it must be below
+the table within the table width range, then the newly created row(s)
+are appended at the bottom of the table." t nil)
+
+(autoload (quote table-insert-column) "table" "\
+Insert N table column(s).
+When point is in a table the newly inserted column(s) are placed left
+of the current column. When point is outside of the table it must be
+right side of the table within the table height range, then the newly
+created column(s) are appended at the right of the table." t nil)
+
+(autoload (quote table-insert-row-column) "table" "\
+Insert row(s) or column(s).
+See `table-insert-row' and `table-insert-column'." t nil)
+
+(autoload (quote table-recognize) "table" "\
+Recognize all tables within the current buffer and activate them.
+Scans the entire buffer and recognizes valid table cells. If the
+optional numeric prefix argument ARG is negative the tables in the
+buffer become inactive, meaning the tables become plain text and loses
+all the table specific features." t nil)
+
+(autoload (quote table-unrecognize) "table" nil t nil)
+
+(autoload (quote table-recognize-region) "table" "\
+Recognize all tables within region.
+BEG and END specify the region to work on. If the optional numeric
+prefix argument ARG is negative the tables in the region become
+inactive, meaning the tables become plain text and lose all the table
+specific features." t nil)
+
+(autoload (quote table-unrecognize-region) "table" nil t nil)
+
+(autoload (quote table-recognize-table) "table" "\
+Recognize a table at point.
+If the optional numeric prefix argument ARG is negative the table
+becomes inactive, meaning the table becomes plain text and loses all
+the table specific features." t nil)
+
+(autoload (quote table-unrecognize-table) "table" nil t nil)
+
+(autoload (quote table-recognize-cell) "table" "\
+Recognize a table cell that contains current point.
+Probe the cell dimension and prepare the cell information. The
+optional two arguments FORCE and NO-COPY are for internal use only and
+must not be specified. When the optional numeric prefix argument ARG
+is negative the cell becomes inactive, meaning that the cell becomes
+plain text and loses all the table specific features." t nil)
+
+(autoload (quote table-unrecognize-cell) "table" nil t nil)
+
+(autoload (quote table-heighten-cell) "table" "\
+Heighten the current cell by N lines by expanding the cell vertically.
+Heightening is done by adding blank lines at the bottom of the current
+cell. Other cells aligned horizontally with the current one are also
+heightened in order to keep the rectangular table structure. The
+optional argument NO-COPY is internal use only and must not be
+specified." t nil)
+
+(autoload (quote table-shorten-cell) "table" "\
+Shorten the current cell by N lines by shrinking the cell vertically.
+Shortening is done by removing blank lines from the bottom of the cell
+and possibly from the top of the cell as well. Therefor, the cell
+must have some bottom/top blank lines to be shorten effectively. This
+is applicable to all the cells aligned horizontally with the current
+one because they are also shortened in order to keep the rectangular
+table structure." t nil)
+
+(autoload (quote table-widen-cell) "table" "\
+Widen the current cell by N columns and expand the cell horizontally.
+Some other cells in the same table are widen as well to keep the
+table's rectangle structure." t nil)
+
+(autoload (quote table-narrow-cell) "table" "\
+Narrow the current cell by N columns and shrink the cell horizontally.
+Some other cells in the same table are narrowed as well to keep the
+table's rectangle structure." t nil)
+
+(autoload (quote table-forward-cell) "table" "\
+Move point forward to the beginning of the next cell.
+With argument ARG, do it ARG times;
+a negative argument ARG = -N means move backward N cells.
+Do not specify NO-RECOGNIZE and UNRECOGNIZE. They are for internal use only.
+
+Sample Cell Traveling Order (In Irregular Table Cases)
+
+You can actually try how it works in this buffer. Press
+\\[table-recognize] and go to cells in the following tables and press
+\\[table-forward-cell] or TAB key.
+
++-----+--+ +--+-----+ +--+--+--+ +--+--+--+ +---------+ +--+---+--+
+|0 |1 | |0 |1 | |0 |1 |2 | |0 |1 |2 | |0 | |0 |1 |2 |
++--+--+ | | +--+--+ +--+ | | | | +--+ +----+----+ +--+-+-+--+
+|2 |3 | | | |2 |3 | |3 +--+ | | +--+3 | |1 |2 | |3 |4 |
+| +--+--+ +--+--+ | +--+4 | | | |4 +--+ +--+-+-+--+ +----+----+
+| |4 | |4 | | |5 | | | | | |5 | |3 |4 |5 | |5 |
++--+-----+ +-----+--+ +--+--+--+ +--+--+--+ +--+---+--+ +---------+
+
++--+--+--+ +--+--+--+ +--+--+--+ +--+--+--+
+|0 |1 |2 | |0 |1 |2 | |0 |1 |2 | |0 |1 |2 |
+| | | | | +--+ | | | | | +--+ +--+
++--+ +--+ +--+3 +--+ | +--+ | |3 +--+4 |
+|3 | |4 | |4 +--+5 | | |3 | | +--+5 +--+
+| | | | | |6 | | | | | | |6 | |7 |
++--+--+--+ +--+--+--+ +--+--+--+ +--+--+--+
+
++--+--+--+ +--+--+--+ +--+--+--+--+ +--+-----+--+ +--+--+--+--+
+|0 |1 |2 | |0 |1 |2 | |0 |1 |2 |3 | |0 |1 |2 | |0 |1 |2 |3 |
+| +--+ | | +--+ | | +--+--+ | | | | | | +--+--+ |
+| |3 +--+ +--+3 | | +--+4 +--+ +--+ +--+ +--+4 +--+
++--+ |4 | |4 | +--+ |5 +--+--+6 | |3 +--+--+4 | |5 | |6 |
+|5 +--+ | | +--+5 | | |7 |8 | | | |5 |6 | | | | | |
+| |6 | | | |6 | | +--+--+--+--+ +--+--+--+--+ +--+-----+--+
++--+--+--+ +--+--+--+
+" t nil)
+
+(autoload (quote table-backward-cell) "table" "\
+Move backward to the beginning of the previous cell.
+With argument ARG, do it ARG times;
+a negative argument ARG = -N means move forward N cells." t nil)
+
+(autoload (quote table-span-cell) "table" "\
+Span current cell into adjacent cell in DIRECTION.
+DIRECTION is one of symbols; right, left, above or below." t nil)
+
+(autoload (quote table-split-cell-vertically) "table" "\
+Split current cell vertically.
+Creates a cell above and a cell below the current point location." t nil)
+
+(autoload (quote table-split-cell-horizontally) "table" "\
+Split current cell horizontally.
+Creates a cell on the left and a cell on the right of the current point location." t nil)
+
+(autoload (quote table-split-cell) "table" "\
+Split current cell in ORIENTATION.
+ORIENTATION is a symbol either horizontally or vertically." t nil)
+
+(autoload (quote table-justify) "table" "\
+Justify contents of a cell, a row of cells or a column of cells.
+WHAT is a symbol 'cell, 'row or 'column. JUSTIFY is a symbol 'left,
+'center, 'right, 'top, 'middle, 'bottom or 'none." t nil)
+
+(autoload (quote table-justify-cell) "table" "\
+Justify cell contents.
+JUSTIFY is a symbol 'left, 'center or 'right for horizontal, or 'top,
+'middle, 'bottom or 'none for vertical. When optional PARAGRAPH is
+non-nil the justify operation is limited to the current paragraph,
+otherwise the entire cell contents is justified." t nil)
+
+(autoload (quote table-justify-row) "table" "\
+Justify cells of a row.
+JUSTIFY is a symbol 'left, 'center or 'right for horizontal, or top,
+'middle, 'bottom or 'none for vertical." t nil)
+
+(autoload (quote table-justify-column) "table" "\
+Justify cells of a column.
+JUSTIFY is a symbol 'left, 'center or 'right for horizontal, or top,
+'middle, 'bottom or 'none for vertical." t nil)
+
+(autoload (quote table-fixed-width-mode) "table" "\
+Toggle fixing width mode.
+In the fixed width mode, typing inside a cell never changes the cell
+width where in the normal mode the cell width expands automatically in
+order to prevent a word being folded into multiple lines." t nil)
+
+(autoload (quote table-query-dimension) "table" "\
+Return the dimension of the current cell and the current table.
+The result is a list (cw ch tw th c r cells) where cw is the cell
+width, ch is the cell height, tw is the table width, th is the table
+height, c is the number of columns, r is the number of rows and cells
+is the total number of cells. The cell dimension excludes the cell
+frame while the table dimension includes the table frame. The columns
+and the rows are counted by the number of cell boundaries. Therefore
+the number tends to be larger than it appears for the tables with
+non-uniform cell structure (heavily spanned and split). When optional
+WHERE is provided the cell and table at that location is reported." t nil)
+
+(autoload (quote table-generate-source) "table" "\
+Generate source of the current table in the specified language.
+LANGUAGE is a symbol that specifies the language to describe the
+structure of the table. It must be either 'html, 'latex or 'cals.
+The resulted source text is inserted into DEST-BUFFER and the buffer
+object is returned. When DEST-BUFFER is omitted or nil the default
+buffer specified in `table-dest-buffer-name' is used. In this case
+the content of the default buffer is erased prior to the generation.
+When DEST-BUFFER is non-nil it is expected to be either a destination
+buffer or a name of the destination buffer. In this case the
+generated result is inserted at the current point in the destination
+buffer and the previously existing contents in the buffer are
+untouched.
+
+References used for this implementation:
+
+HTML:
+ http://www.w3.org
+
+LaTeX:
+ http://www.maths.tcd.ie/~dwilkins/LaTeXPrimer/Tables.html
+
+CALS (DocBook DTD):
+ http://www.oasis-open.org/html/a502.htm
+ http://www.oreilly.com/catalog/docbook/chapter/book/table.html#AEN114751
+" t nil)
+
+(autoload (quote table-insert-sequence) "table" "\
+Travel cells forward while inserting a specified sequence string in each cell.
+STR is the base string from which the sequence starts. When STR is an
+empty string then each cell content is erased. When STR ends with
+numerical characters (they may optionally be surrounded by a pair of
+parentheses) they are incremented as a decimal number. Otherwise the
+last character in STR is incremented in ASCII code order. N is the
+number of sequence elements to insert. When N is negative the cell
+traveling direction is backward. When N is zero it travels forward
+entire table. INCREMENT is the increment between adjacent sequence
+elements and can be a negative number for effectively decrementing.
+INTERVAL is the number of cells to travel between sequence element
+insertion which is normally 1. When zero or less is given for
+INTERVAL it is interpreted as number of cells per row so that sequence
+is placed straight down vertically as long as the table's cell
+structure is uniform. JUSTIFY is one of the symbol 'left, 'center or
+'right, that specifies justification of the inserted string.
+
+Example:
+
+ (progn
+ (table-insert 16 3 5 1)
+ (table-forward-cell 15)
+ (table-insert-sequence \"D0\" -16 1 1 'center)
+ (table-forward-cell 16)
+ (table-insert-sequence \"A[0]\" -16 1 1 'center)
+ (table-forward-cell 1)
+ (table-insert-sequence \"-\" 16 0 1 'center))
+
+ (progn
+ (table-insert 16 8 5 1)
+ (table-insert-sequence \"@\" 0 1 2 'right)
+ (table-forward-cell 1)
+ (table-insert-sequence \"64\" 0 1 2 'left))
+" t nil)
+
+(autoload (quote table-delete-row) "table" "\
+Delete N row(s) of cells.
+Delete N rows of cells from current row. The current row is the row
+contains the current cell where point is located. Each row must
+consists from cells of same height." t nil)
+
+(autoload (quote table-delete-column) "table" "\
+Delete N column(s) of cells.
+Delete N columns of cells from current column. The current column is
+the column contains the current cell where point is located. Each
+column must consists from cells of same width." t nil)
+
+(autoload (quote table-capture) "table" "\
+Convert plain text into a table by capturing the text in the region.
+Create a table with the text in region as cell contents. BEG and END
+specify the region. The text in the region is replaced with a table.
+The removed text is inserted in the table. When optional
+COL-DELIM-REGEXP and ROW-DELIM-REGEXP are provided the region contents
+is parsed and separated into individual cell contents by using the
+delimiter regular expressions. This parsing determines the number of
+columns and rows of the table automatically. If COL-DELIM-REGEXP and
+ROW-DELIM-REGEXP are omitted the result table has only one cell and
+the entire region contents is placed in that cell. Optional JUSTIFY
+is one of 'left, 'center or 'right, which specifies the cell
+justification. Optional MIN-CELL-WIDTH specifies the minimum cell
+width. Optional COLUMNS specify the number of columns when
+ROW-DELIM-REGEXP is not specified.
+
+
+Example 1:
+
+1, 2, 3, 4
+5, 6, 7, 8
+, 9, 10
+
+Running `table-capture' on above 3 line region with COL-DELIM-REGEXP
+\",\" and ROW-DELIM-REGEXP \"\\n\" creates the following table. In
+this example the cells are centered and minimum cell width is
+specified as 5.
+
++-----+-----+-----+-----+
+| 1 | 2 | 3 | 4 |
++-----+-----+-----+-----+
+| 5 | 6 | 7 | 8 |
++-----+-----+-----+-----+
+| | 9 | 10 | |
++-----+-----+-----+-----+
+
+Note:
+
+In case the function is called interactively user must use \\[quoted-insert] `quoted-insert'
+in order to enter \"\\n\" successfully. COL-DELIM-REGEXP at the end
+of each row is optional.
+
+
+Example 2:
+
+This example shows how a table can be used for text layout editing.
+Let `table-capture' capture the following region starting from
+-!- and ending at -*-, that contains three paragraphs and two item
+name headers. This time specify empty string for both
+COL-DELIM-REGEXP and ROW-DELIM-REGEXP.
+
+-!-`table-capture' is a powerful command however mastering its power
+requires some practice. Here is a list of items what it can do.
+
+Parse Cell Items By using column delimiter regular
+ expression and raw delimiter regular
+ expression, it parses the specified text
+ area and extracts cell items from
+ non-table text and then forms a table out
+ of them.
+
+Capture Text Area When no delimiters are specified it
+ creates a single cell table. The text in
+ the specified region is placed in that
+ cell.-*-
+
+Now the entire content is captured in a cell which is itself a table
+like this.
+
++-----------------------------------------------------------------+
+|`table-capture' is a powerful command however mastering its power|
+|requires some practice. Here is a list of items what it can do. |
+| |
+|Parse Cell Items By using column delimiter regular |
+| expression and raw delimiter regular |
+| expression, it parses the specified text |
+| area and extracts cell items from |
+| non-table text and then forms a table out |
+| of them. |
+| |
+|Capture Text Area When no delimiters are specified it |
+| creates a single cell table. The text in |
+| the specified region is placed in that |
+| cell. |
++-----------------------------------------------------------------+
+
+By splitting the cell appropriately we now have a table consisting of
+paragraphs occupying its own cell. Each cell can now be edited
+independently.
+
++-----------------------------------------------------------------+
+|`table-capture' is a powerful command however mastering its power|
+|requires some practice. Here is a list of items what it can do. |
++---------------------+-------------------------------------------+
+|Parse Cell Items |By using column delimiter regular |
+| |expression and raw delimiter regular |
+| |expression, it parses the specified text |
+| |area and extracts cell items from |
+| |non-table text and then forms a table out |
+| |of them. |
++---------------------+-------------------------------------------+
+|Capture Text Area |When no delimiters are specified it |
+| |creates a single cell table. The text in |
+| |the specified region is placed in that |
+| |cell. |
++---------------------+-------------------------------------------+
+
+By applying `table-release', which does the opposite process, the
+contents become once again plain text. `table-release' works as
+companion command to `table-capture' this way.
+" t nil)
+
+(autoload (quote table-release) "table" "\
+Convert a table into plain text by removing the frame from a table.
+Remove the frame from a table and inactivate the table. This command
+converts a table into plain text without frames. It is a companion to
+`table-capture' which does the opposite process." t nil)
+
+;;;***
+\f
+;;;### (autoloads (talk-connect) "talk" "talk.el" (15569 44240))
;;; Generated autoloads from talk.el
(autoload (quote talk-connect) "talk" "\
;;;***
\f
-;;;### (autoloads (tar-mode) "tar-mode" "tar-mode.el" (15523 24019))
+;;;### (autoloads (tar-mode) "tar-mode" "tar-mode.el" (15712 9990))
;;; Generated autoloads from tar-mode.el
(autoload (quote tar-mode) "tar-mode" "\
;;;***
\f
;;;### (autoloads (tcl-help-on-word inferior-tcl tcl-mode) "tcl"
-;;;;;; "progmodes/tcl.el" (15528 51856))
+;;;;;; "progmodes/tcl.el" (15533 28779))
;;; Generated autoloads from progmodes/tcl.el
(autoload (quote tcl-mode) "tcl" "\
;;;***
\f
-;;;### (autoloads (ansi-term term make-term) "term" "term.el" (15548
-;;;;;; 29279))
+;;;### (autoloads (ansi-term term make-term) "term" "term.el" (15549
+;;;;;; 60240))
;;; Generated autoloads from term.el
(autoload (quote make-term) "term" "\
;;;;;; tex-start-commands tex-start-options slitex-run-command latex-run-command
;;;;;; tex-run-command tex-offer-save tex-main-file tex-first-line-header-regexp
;;;;;; tex-directory tex-shell-file-name) "tex-mode" "textmodes/tex-mode.el"
-;;;;;; (15568 22304))
+;;;;;; (15666 2624))
;;; Generated autoloads from textmodes/tex-mode.el
(defvar tex-shell-file-name nil "\
SliTeX Mode sets `tex-command' to this string.
See the documentation of that variable.")
-(defvar tex-start-options nil "\
+(defvar tex-start-options "" "\
*TeX options to use when starting TeX.
-These precede the commands in `tex-start-options'
-and the input file name. If nil, TeX runs with no options.
-See the documentation of `tex-command'.")
+These immediately precede the commands in `tex-start-commands'
+and the input file name, with no separating space and are not shell-quoted.
+If nil, TeX runs with no options. See the documentation of `tex-command'.")
(defvar tex-start-commands "\\nonstopmode\\input" "\
*TeX commands to use when starting TeX.
-These precede the input file name. If nil, no commands are used.
-See the documentation of `tex-command'.")
+They are shell-quoted and precede the input file name, with a separating space.
+If nil, no commands are used. See the documentation of `tex-command'.")
(defvar latex-block-names nil "\
*User defined LaTeX block names.
;;;***
\f
;;;### (autoloads (texi2info texinfo-format-region texinfo-format-buffer)
-;;;;;; "texinfmt" "textmodes/texinfmt.el" (15498 27766))
+;;;;;; "texinfmt" "textmodes/texinfmt.el" (15498 37611))
;;; Generated autoloads from textmodes/texinfmt.el
(autoload (quote texinfo-format-buffer) "texinfmt" "\
;;;***
\f
;;;### (autoloads (texinfo-mode texinfo-close-quote texinfo-open-quote)
-;;;;;; "texinfo" "textmodes/texinfo.el" (15565 33607))
+;;;;;; "texinfo" "textmodes/texinfo.el" (15656 53217))
;;; Generated autoloads from textmodes/texinfo.el
(defvar texinfo-open-quote "``" "\
;;;;;; tibetan-composition-function tibetan-decompose-string tibetan-decompose-region
;;;;;; tibetan-compose-region tibetan-compose-string tibetan-transcription-to-tibetan
;;;;;; tibetan-tibetan-to-transcription tibetan-char-p) "tibet-util"
-;;;;;; "language/tibet-util.el" (15576 40652))
+;;;;;; "language/tibet-util.el" (15576 41093))
;;; Generated autoloads from language/tibet-util.el
(autoload (quote tibetan-char-p) "tibet-util" "\
;;;***
\f
;;;### (autoloads (display-time-mode display-time display-time-day-and-date)
-;;;;;; "time" "time.el" (15566 59716))
+;;;;;; "time" "time.el" (15567 16402))
;;; Generated autoloads from time.el
(defvar display-time-day-and-date nil "\
;;;***
\f
;;;### (autoloads (time-stamp-toggle-active time-stamp) "time-stamp"
-;;;;;; "time-stamp.el" (15573 52062))
+;;;;;; "time-stamp.el" (15590 49016))
;;; Generated autoloads from time-stamp.el
(autoload (quote time-stamp) "time-stamp" "\
;;;;;; timeclock-workday-remaining-string timeclock-reread-log timeclock-query-out
;;;;;; timeclock-change timeclock-status-string timeclock-out timeclock-in
;;;;;; timeclock-modeline-display) "timeclock" "calendar/timeclock.el"
-;;;;;; (15332 4541))
+;;;;;; (15664 47249))
;;; Generated autoloads from calendar/timeclock.el
(autoload (quote timeclock-modeline-display) "timeclock" "\
\f
;;;### (autoloads (with-timeout run-with-idle-timer add-timeout run-with-timer
;;;;;; run-at-time cancel-function-timers cancel-timer) "timer"
-;;;;;; "timer.el" (15293 31965))
+;;;;;; "timer.el" (15671 8032))
;;; 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" (15538 7889))
+;;;;;; "international/titdic-cnv.el" (15683 14756))
;;; 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" (15556 11342))
+;;;;;; "tmm.el" (15556 56039))
;;; Generated autoloads from tmm.el
(define-key global-map "\M-`" 'tmm-menubar)
(define-key global-map [f10] 'tmm-menubar)
\f
;;;### (autoloads (tool-bar-local-item-from-menu tool-bar-add-item-from-menu
;;;;;; tool-bar-local-item tool-bar-add-item tool-bar-mode) "tool-bar"
-;;;;;; "toolbar/tool-bar.el" (15572 42737))
+;;;;;; "toolbar/tool-bar.el" (15669 19466))
;;; Generated autoloads from toolbar/tool-bar.el
(defvar tool-bar-mode nil "\
;;;***
\f
;;;### (autoloads (tooltip-mode tooltip-mode) "tooltip" "tooltip.el"
-;;;;;; (15425 23276))
+;;;;;; (15642 10295))
;;; Generated autoloads from tooltip.el
(autoload (quote tooltip-mode) "tooltip" "\
;;;***
\f
-;;;### (autoloads (tpu-edt-on) "tpu-edt" "emulation/tpu-edt.el" (15400
-;;;;;; 24828))
+;;;### (autoloads (tpu-edt-on) "tpu-edt" "emulation/tpu-edt.el" (15651
+;;;;;; 7288))
;;; Generated autoloads from emulation/tpu-edt.el
(defalias (quote tpu-edt-mode) (quote tpu-edt-on))
there might be!! Trace output will quietly go to BUFFER without changing
the window or buffer configuration at all." t nil)
+;;;***
+\f
+;;;### (autoloads (tramp-file-name-handler tramp-file-name-regexp)
+;;;;;; "tramp" "net/tramp.el" (15731 28628))
+;;; Generated autoloads from net/tramp.el
+
+(defconst tramp-file-name-regexp-unified "\\`/[^/:]+:" "\
+Value for `tramp-file-name-regexp' for unified remoting.
+Emacs (not XEmacs) uses a unified filename syntax for Ange-FTP and
+Tramp. See `tramp-file-name-structure-unified' for more explanations.")
+
+(defconst tramp-file-name-regexp-separate "\\`/\\[.*\\]" "\
+Value for `tramp-file-name-regexp' for separate remoting.
+XEmacs uses a separate filename syntax for Tramp and EFS.
+See `tramp-file-name-structure-separate' for more explanations.")
+
+(defvar tramp-file-name-regexp (if (featurep (quote xemacs)) tramp-file-name-regexp-separate tramp-file-name-regexp-unified) "\
+*Regular expression matching file names handled by tramp.
+This regexp should match tramp file names but no other file names.
+\(When tramp.el is loaded, this regular expression is prepended to
+`file-name-handler-alist', and that is searched sequentially. Thus,
+if the tramp entry appears rather early in the `file-name-handler-alist'
+and is a bit too general, then some files might be considered tramp
+files which are not really tramp files.
+
+Please note that the entry in `file-name-handler-alist' is made when
+this file (tramp.el) is loaded. This means that this variable must be set
+before loading tramp.el. Alternatively, `file-name-handler-alist' can be
+updated after changing this variable.
+
+Also see `tramp-file-name-structure' and `tramp-make-tramp-file-format'.")
+
+(autoload (quote tramp-file-name-handler) "tramp" "\
+Invoke tramp file name handler.
+Falls back to normal file name handler if no tramp file name handler exists." nil nil)
+
+(add-to-list (quote file-name-handler-alist) (cons tramp-file-name-regexp (quote tramp-file-name-handler)))
+
;;;***
\f
;;;### (autoloads (2C-split 2C-associate-buffer 2C-two-columns) "two-column"
;;;;;; vc-directory vc-resolve-conflicts vc-merge vc-insert-headers
;;;;;; vc-version-other-window vc-diff vc-register vc-next-action
;;;;;; vc-do-command edit-vc-file with-vc-file vc-branch-part vc-before-checkin-hook
-;;;;;; vc-checkin-hook vc-checkout-hook) "vc" "vc.el" (15494 7904))
+;;;;;; vc-checkin-hook vc-checkout-hook) "vc" "vc.el" (15735 17293))
;;; Generated autoloads from vc.el
(defvar vc-checkout-hook nil "\
;;;***
\f
-;;;### (autoloads nil "vc-cvs" "vc-cvs.el" (15539 8527))
+;;;### (autoloads nil "vc-cvs" "vc-cvs.el" (15651 7288))
;;; Generated autoloads from vc-cvs.el
(defun vc-cvs-registered (f)
(when (file-readable-p (expand-file-name
;;;***
\f
;;;### (autoloads (vc-rcs-master-templates) "vc-rcs" "vc-rcs.el"
-;;;;;; (15510 8498))
+;;;;;; (15735 17293))
;;; Generated autoloads from vc-rcs.el
(defvar vc-rcs-master-templates (quote ("%sRCS/%s,v" "%s%s,v" "%sRCS/%s")) "\
;;;***
\f
;;;### (autoloads (vc-sccs-master-templates) "vc-sccs" "vc-sccs.el"
-;;;;;; (15510 8683))
+;;;;;; (15510 21813))
;;; Generated autoloads from vc-sccs.el
(defvar vc-sccs-master-templates (quote ("%sSCCS/s.%s" "%ss.%s" vc-sccs-search-project-dir)) "\
;;;***
\f
;;;### (autoloads (vhdl-mode) "vhdl-mode" "progmodes/vhdl-mode.el"
-;;;;;; (15440 59334))
+;;;;;; (15738 35332))
;;; Generated autoloads from progmodes/vhdl-mode.el
(autoload (quote vhdl-mode) "vhdl-mode" "\
;;;### (autoloads (viqr-pre-write-conversion viqr-post-read-conversion
;;;;;; viet-encode-viqr-buffer viet-encode-viqr-region viet-decode-viqr-buffer
;;;;;; viet-decode-viqr-region viet-encode-viscii-char) "viet-util"
-;;;;;; "language/viet-util.el" (15565 33566))
+;;;;;; "language/viet-util.el" (15565 44318))
;;; Generated autoloads from language/viet-util.el
(autoload (quote viet-encode-viscii-char) "viet-util" "\
\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" (15349
-;;;;;; 43162))
+;;;;;; view-file-other-window view-file) "view" "view.el" (15625
+;;;;;; 11768))
;;; Generated autoloads from view.el
(defvar view-mode nil "\
;;;***
\f
;;;### (autoloads (viper-mode toggle-viper-mode) "viper" "emulation/viper.el"
-;;;;;; (15547 47959))
+;;;;;; (15564 59462))
;;; Generated autoloads from emulation/viper.el
(autoload (quote toggle-viper-mode) "viper" "\
(autoload (quote viper-mode) "viper" "\
Turn on Viper emulation of Vi." t nil)
+;;;***
+\f
+;;;### (autoloads (warn lwarn display-warning) "warnings" "warnings.el"
+;;;;;; (15738 35331))
+;;; Generated autoloads from warnings.el
+
+(defvar warning-prefix-function nil "\
+Function to generate warning prefixes.
+This function, if non-nil, is called with two arguments,
+the severity level and its entry in `warning-levels',
+and should return the entry that should actually be used.
+The warnings buffer is current when this function is called
+and the function can insert text in it. This text becomes
+the beginning of the warning.")
+
+(defvar warning-series nil "\
+Non-nil means treat multiple `display-warning' calls as a series.
+A marker indicates a position in the warnings buffer
+which is the start of the current series; it means that
+additional warnings in the same buffer should not move point.
+t means the next warning begins a series (and stores a marker here).
+A symbol with a function definition is like t, except
+also call that function before the next warning.")
+
+(defvar warning-fill-prefix nil "\
+Non-nil means fill each warning text using this string as `fill-prefix'.")
+
+(defvar warning-group-format " (%s)" "\
+Format for displaying the warning group in the warning message.
+The result of formatting the group this way gets included in the
+message under the control of the string in `warning-levels'.")
+
+(autoload (quote display-warning) "warnings" "\
+Display a warning message, MESSAGE.
+GROUP should be a custom group name (a symbol),
+or else a list of symbols whose first element is a custom group name.
+\(The rest of the symbols represent subcategories, for warning purposes
+only, and you can use whatever symbols you like.)
+
+LEVEL should be either :warning, :error, or :emergency.
+:emergency -- a problem that will seriously impair Emacs operation soon
+ if you do not attend to it promptly.
+:error -- data or circumstances that are inherently wrong.
+:warning -- data or circumstances that are not inherently wrong,
+ but raise suspicion of a possible problem.
+:debug -- info for debugging only.
+
+BUFFER-NAME, if specified, is the name of the buffer for logging the
+warning. By default, it is `*Warnings*'.
+
+See the `warnings' custom group for user customization features.
+
+See also `warning-series', `warning-prefix-function' and
+`warning-fill-prefix' for additional programming features." nil nil)
+
+(autoload (quote lwarn) "warnings" "\
+Display a warning message made from (format MESSAGE ARGS...).
+Aside from generating the message with `format',
+this is equivalent to `display-warning'.
+
+GROUP should be a custom group name (a symbol).
+or else a list of symbols whose first element is a custom group name.
+\(The rest of the symbols represent subcategories and
+can be whatever you like.)
+
+LEVEL should be either :warning, :error, or :emergency.
+:emergency -- a problem that will seriously impair Emacs operation soon
+ if you do not attend to it promptly.
+:error -- invalid data or circumstances.
+:warning -- suspicious data or circumstances." nil nil)
+
+(autoload (quote warn) "warnings" "\
+Display a warning message made from (format MESSAGE ARGS...).
+Aside from generating the message with `format',
+this is equivalent to `display-warning', using
+`emacs' as the group and `:warning' as the level." nil nil)
+
;;;***
\f
;;;### (autoloads (webjump) "webjump" "net/webjump.el" (15381 44879))
;;;***
\f
;;;### (autoloads (which-function-mode) "which-func" "which-func.el"
-;;;;;; (15356 16861))
+;;;;;; (15707 34351))
;;; Generated autoloads from which-func.el
(defalias (quote which-func-mode) (quote which-function-mode))
;;;***
\f
;;;### (autoloads (widget-minor-mode widget-browse-other-window widget-browse
-;;;;;; widget-browse-at) "wid-browse" "wid-browse.el" (15467 59919))
+;;;;;; widget-browse-at) "wid-browse" "wid-browse.el" (15698 64355))
;;; Generated autoloads from wid-browse.el
(autoload (quote widget-browse-at) "wid-browse" "\
;;;***
\f
;;;### (autoloads (widget-setup widget-insert widget-delete widget-create
-;;;;;; widget-prompt-value widgetp) "wid-edit" "wid-edit.el" (15546
-;;;;;; 28837))
+;;;;;; widget-prompt-value widgetp) "wid-edit" "wid-edit.el" (15683
+;;;;;; 14756))
;;; Generated autoloads from wid-edit.el
(autoload (quote widgetp) "wid-edit" "\
\f
;;;### (autoloads (windmove-default-keybindings windmove-down windmove-right
;;;;;; windmove-up windmove-left) "windmove" "windmove.el" (15576
-;;;;;; 843))
+;;;;;; 17070))
;;; Generated autoloads from windmove.el
(autoload (quote windmove-left) "windmove" "\
;;;***
\f
;;;### (autoloads (woman-find-file woman-dired-find-file woman) "woman"
-;;;;;; "woman.el" (15408 51988))
+;;;;;; "woman.el" (15584 9753))
;;; Generated autoloads from woman.el
(autoload (quote woman) "woman" "\
;;;***
\f
-;;;### (autoloads (xterm-mouse-mode) "xt-mouse" "xt-mouse.el" (15542
-;;;;;; 21888))
+;;;### (autoloads (xterm-mouse-mode) "xt-mouse" "xt-mouse.el" (15698
+;;;;;; 64355))
;;; Generated autoloads from xt-mouse.el
+(defvar xterm-mouse-mode nil "\
+Non-nil if Xterm-Mouse mode is enabled.
+See the command `xterm-mouse-mode' for a description of this minor-mode.
+Setting this variable directly does not take effect;
+use either \\[customize] or the function `xterm-mouse-mode'.")
+
+(custom-add-to-group (quote xterm-mouse) (quote xterm-mouse-mode) (quote custom-variable))
+
+(custom-add-load (quote xterm-mouse-mode) (quote xt-mouse))
+
(autoload (quote xterm-mouse-mode) "xt-mouse" "\
Toggle XTerm mouse mode.
With prefix arg, turn XTerm mouse mode on iff arg is positive.
;;;***
\f
-;;;### (autoloads (zone) "zone" "play/zone.el" (15422 4402))
+;;;### (autoloads (zone) "zone" "play/zone.el" (15640 49864))
;;; Generated autoloads from play/zone.el
(autoload (quote zone) "zone" "\
;;;***
\f
;;;### (autoloads (zone-mode zone-mode-update-serial-hook) "zone-mode"
-;;;;;; "net/zone-mode.el" (15566 7114))
+;;;;;; "net/zone-mode.el" (15567 16402))
;;; Generated autoloads from net/zone-mode.el
(autoload (quote zone-mode-update-serial-hook) "zone-mode" "\
;;;***
\f
-;;;### (autoloads nil nil ("abbrev.el" "abbrevlist.el" "allout.el"
-;;;;;; "bindings.el" "buff-menu.el" "byte-run.el" "case-table.el"
-;;;;;; "cdl.el" "cus-dep.el" "cus-load.el" "cus-start.el" "custom.el"
-;;;;;; "dos-fns.el" "dos-vars.el" "dos-w32.el" "ediff-diff.el" "ediff-hook.el"
-;;;;;; "ediff-init.el" "ediff-merg.el" "ediff-ptch.el" "ediff-vers.el"
-;;;;;; "ediff-wind.el" "electric.el" "emacs-lock.el" "env.el" "faces.el"
-;;;;;; "files.el" "filesets.el" "finder-inf.el" "float-sup.el" "foldout.el"
-;;;;;; "format.el" "forms-d2.el" "forms-pass.el" "frame.el" "generic-x.el"
-;;;;;; "help.el" "indent.el" "isearch.el" "kermit.el" "loadup.el"
-;;;;;; "map-ynp.el" "menu-bar.el" "misc.el" "mouse-copy.el" "mouse-drag.el"
-;;;;;; "mouse.el" "patcomp.el" "paths.el" "pcvs-info.el" "pcvs-parse.el"
-;;;;;; "pcvs-util.el" "regi.el" "register.el" "replace.el" "s-region.el"
-;;;;;; "saveplace.el" "scroll-bar.el" "select.el" "simple.el" "soundex.el"
-;;;;;; "startup.el" "subr.el" "tempo.el" "timezone.el" "uniquify.el"
-;;;;;; "unused.el" "vc-hooks.el" "vcursor.el" "version.el" "vms-patch.el"
-;;;;;; "vmsproc.el" "vt-control.el" "vt100-led.el" "w32-fns.el"
-;;;;;; "w32-vars.el" "widget.el" "window.el" "xml.el" "xscheme.el"
-;;;;;; "calc/calc-aent.el" "calc/calc-alg.el" "calc/calc-arith.el"
-;;;;;; "calc/calc-bin.el" "calc/calc-comb.el" "calc/calc-cplx.el"
-;;;;;; "calc/calc-embed.el" "calc/calc-fin.el" "calc/calc-forms.el"
-;;;;;; "calc/calc-frac.el" "calc/calc-funcs.el" "calc/calc-graph.el"
-;;;;;; "calc/calc-help.el" "calc/calc-incom.el" "calc/calc-keypd.el"
-;;;;;; "calc/calc-lang.el" "calc/calc-macs.el" "calc/calc-maint.el"
-;;;;;; "calc/calc-map.el" "calc/calc-math.el" "calc/calc-misc.el"
-;;;;;; "calc/calc-mode.el" "calc/calc-mtx.el" "calc/calc-poly.el"
-;;;;;; "calc/calc-prog.el" "calc/calc-rewr.el" "calc/calc-rules.el"
-;;;;;; "calc/calc-sel.el" "calc/calc-stat.el" "calc/calc-store.el"
-;;;;;; "calc/calc-stuff.el" "calc/calc-trail.el" "calc/calc-undo.el"
-;;;;;; "calc/calc-units.el" "calc/calc-vec.el" "calc/calc-yank.el"
-;;;;;; "calc/calcalg2.el" "calc/calcalg3.el" "calc/calccomp.el"
-;;;;;; "calc/calcsel2.el" "eshell/em-alias.el" "eshell/em-banner.el"
-;;;;;; "eshell/em-basic.el" "eshell/em-cmpl.el" "eshell/em-dirs.el"
-;;;;;; "eshell/em-glob.el" "eshell/em-hist.el" "eshell/em-ls.el"
-;;;;;; "eshell/em-pred.el" "eshell/em-prompt.el" "eshell/em-rebind.el"
-;;;;;; "eshell/em-script.el" "eshell/em-smart.el" "eshell/em-term.el"
-;;;;;; "eshell/em-unix.el" "eshell/em-xtra.el" "eshell/esh-arg.el"
-;;;;;; "eshell/esh-cmd.el" "eshell/esh-ext.el" "eshell/esh-groups.el"
-;;;;;; "eshell/esh-io.el" "eshell/esh-maint.el" "eshell/esh-module.el"
-;;;;;; "eshell/esh-opt.el" "eshell/esh-proc.el" "eshell/esh-util.el"
-;;;;;; "eshell/esh-var.el" "net/eudc-vars.el" "net/eudcb-bbdb.el"
-;;;;;; "net/eudcb-ldap.el" "net/eudcb-ph.el" "net/ldap.el" "net/netrc.el"
-;;;;;; "calendar/cal-china.el" "calendar/cal-coptic.el" "calendar/cal-french.el"
-;;;;;; "calendar/cal-islam.el" "calendar/cal-iso.el" "calendar/cal-julian.el"
-;;;;;; "calendar/cal-mayan.el" "calendar/cal-menu.el" "calendar/cal-move.el"
-;;;;;; "calendar/cal-persia.el" "calendar/cal-tex.el" "calendar/cal-x.el"
-;;;;;; "calendar/parse-time.el" "emacs-lisp/assoc.el" "emacs-lisp/authors.el"
-;;;;;; "emacs-lisp/byte-opt.el" "emacs-lisp/cl-compat.el" "emacs-lisp/cl-extra.el"
-;;;;;; "emacs-lisp/cl-macs.el" "emacs-lisp/cl-seq.el" "emacs-lisp/cl-specs.el"
-;;;;;; "emacs-lisp/cust-print.el" "emacs-lisp/ewoc.el" "emacs-lisp/find-gc.el"
-;;;;;; "emacs-lisp/float.el" "emacs-lisp/gulp.el" "emacs-lisp/levents.el"
-;;;;;; "emacs-lisp/lisp-mnt.el" "emacs-lisp/lisp-mode.el" "emacs-lisp/lisp.el"
-;;;;;; "emacs-lisp/lmenu.el" "emacs-lisp/lselect.el" "emacs-lisp/lucid.el"
-;;;;;; "emacs-lisp/sregex.el" "emulation/cua-gmrk.el" "emulation/cua-rect.el"
-;;;;;; "emulation/edt-lk201.el" "emulation/edt-mapper.el" "emulation/edt-pc.el"
-;;;;;; "emulation/edt-vt100.el" "emulation/tpu-mapper.el" "emulation/viper-cmd.el"
-;;;;;; "emulation/viper-ex.el" "emulation/viper-init.el" "emulation/viper-keym.el"
-;;;;;; "emulation/viper-macs.el" "emulation/viper-mous.el" "emulation/viper-util.el"
-;;;;;; "gnus/flow-fill.el" "gnus/format-spec.el" "gnus/gnus-async.el"
-;;;;;; "gnus/gnus-bcklg.el" "gnus/gnus-cite.el" "gnus/gnus-cus.el"
-;;;;;; "gnus/gnus-demon.el" "gnus/gnus-draft.el" "gnus/gnus-dup.el"
-;;;;;; "gnus/gnus-eform.el" "gnus/gnus-ems.el" "gnus/gnus-gl.el"
-;;;;;; "gnus/gnus-int.el" "gnus/gnus-logic.el" "gnus/gnus-mh.el"
-;;;;;; "gnus/gnus-nocem.el" "gnus/gnus-range.el" "gnus/gnus-salt.el"
-;;;;;; "gnus/gnus-score.el" "gnus/gnus-setup.el" "gnus/gnus-srvr.el"
-;;;;;; "gnus/gnus-sum.el" "gnus/gnus-topic.el" "gnus/gnus-undo.el"
-;;;;;; "gnus/gnus-util.el" "gnus/gnus-uu.el" "gnus/gnus-vm.el" "gnus/ietf-drums.el"
-;;;;;; "gnus/imap.el" "gnus/mail-parse.el" "gnus/mail-prsvr.el"
-;;;;;; "gnus/mail-source.el" "gnus/mailcap.el" "gnus/messcompat.el"
-;;;;;; "gnus/mm-bodies.el" "gnus/mm-decode.el" "gnus/mm-encode.el"
-;;;;;; "gnus/mm-util.el" "gnus/mm-view.el" "gnus/mml.el" "gnus/nnagent.el"
-;;;;;; "gnus/nnbabyl.el" "gnus/nndir.el" "gnus/nndraft.el" "gnus/nneething.el"
-;;;;;; "gnus/nngateway.el" "gnus/nnheader.el" "gnus/nnimap.el" "gnus/nnlistserv.el"
-;;;;;; "gnus/nnmail.el" "gnus/nnmbox.el" "gnus/nnmh.el" "gnus/nnoo.el"
-;;;;;; "gnus/nnslashdot.el" "gnus/nnspool.el" "gnus/nntp.el" "gnus/nnultimate.el"
-;;;;;; "gnus/nnvirtual.el" "gnus/nnwarchive.el" "gnus/nnweb.el"
-;;;;;; "gnus/pop3.el" "gnus/qp.el" "gnus/rfc1843.el" "gnus/rfc2045.el"
-;;;;;; "gnus/rfc2047.el" "gnus/rfc2104.el" "gnus/rfc2231.el" "gnus/starttls.el"
-;;;;;; "gnus/utf7.el" "gnus/webmail.el" "international/characters.el"
-;;;;;; "international/iso-ascii.el" "international/iso-insert.el"
-;;;;;; "international/iso-swed.el" "international/ja-dic-cnv.el"
-;;;;;; "international/ja-dic-utl.el" "international/latin-1.el"
-;;;;;; "international/latin-2.el" "international/latin-3.el" "international/latin-4.el"
-;;;;;; "international/latin-5.el" "international/latin-8.el" "international/latin-9.el"
-;;;;;; "international/mule-cmds.el" "international/mule-conf.el"
-;;;;;; "international/mule.el" "international/ogonek.el" "international/swedish.el"
-;;;;;; "international/ucs-tables.el" "international/utf-8-subst.el"
-;;;;;; "international/utf-8.el" "language/chinese.el" "language/cyrillic.el"
-;;;;;; "language/czech.el" "language/devanagari.el" "language/english.el"
-;;;;;; "language/ethiopic.el" "language/european.el" "language/georgian.el"
-;;;;;; "language/greek.el" "language/hebrew.el" "language/indian.el"
-;;;;;; "language/japanese.el" "language/korean.el" "language/lao.el"
-;;;;;; "language/misc-lang.el" "language/romanian.el" "language/slovak.el"
-;;;;;; "language/thai.el" "language/tibetan.el" "language/utf-8-lang.el"
-;;;;;; "language/vietnamese.el" "mail/blessmail.el" "mail/mailheader.el"
-;;;;;; "mail/mailpost.el" "mail/mh-funcs.el" "mail/mh-pick.el" "mail/mh-seq.el"
-;;;;;; "mail/mspools.el" "mail/rfc2368.el" "mail/rfc822.el" "mail/uce.el"
-;;;;;; "mail/vms-pmail.el" "obsolete/c-mode.el" "obsolete/cplus-md.el"
-;;;;;; "obsolete/hilit19.el" "obsolete/mlsupport.el" "obsolete/ooutline.el"
-;;;;;; "obsolete/profile.el" "obsolete/rnews.el" "obsolete/sc.el"
-;;;;;; "obsolete/sun-curs.el" "obsolete/sun-fns.el" "obsolete/uncompress.el"
-;;;;;; "obsolete/x-apollo.el" "obsolete/x-menu.el" "play/gamegrid.el"
-;;;;;; "play/gametree.el" "play/meese.el" "progmodes/ada-prj.el"
-;;;;;; "progmodes/cc-align.el" "progmodes/cc-bytecomp.el" "progmodes/cc-cmds.el"
-;;;;;; "progmodes/cc-compat.el" "progmodes/cc-defs.el" "progmodes/cc-engine.el"
-;;;;;; "progmodes/cc-menus.el" "progmodes/ebnf-bnf.el" "progmodes/ebnf-iso.el"
-;;;;;; "progmodes/ebnf-otz.el" "progmodes/ebnf-yac.el" "progmodes/idlw-rinfo.el"
-;;;;;; "progmodes/idlw-toolbar.el" "progmodes/mantemp.el" "term/AT386.el"
-;;;;;; "term/apollo.el" "term/bg-mouse.el" "term/bobcat.el" "term/internal.el"
-;;;;;; "term/iris-ansi.el" "term/keyswap.el" "term/linux.el" "term/lk201.el"
-;;;;;; "term/mac-win.el" "term/news.el" "term/pc-win.el" "term/rxvt.el"
-;;;;;; "term/sun-mouse.el" "term/sun.el" "term/sup-mouse.el" "term/tty-colors.el"
-;;;;;; "term/tvi970.el" "term/vt100.el" "term/vt102.el" "term/vt125.el"
-;;;;;; "term/vt200.el" "term/vt201.el" "term/vt220.el" "term/vt240.el"
-;;;;;; "term/vt300.el" "term/vt320.el" "term/vt400.el" "term/vt420.el"
-;;;;;; "term/w32-win.el" "term/wyse50.el" "term/x-win.el" "term/xterm.el"
-;;;;;; "textmodes/bib-mode.el" "textmodes/fill.el" "textmodes/makeinfo.el"
-;;;;;; "textmodes/page-ext.el" "textmodes/page.el" "textmodes/paragraphs.el"
-;;;;;; "textmodes/refbib.el" "textmodes/refer.el" "textmodes/reftex-auc.el"
-;;;;;; "textmodes/reftex-dcr.el" "textmodes/reftex-global.el" "textmodes/reftex-parse.el"
+;;;### (autoloads nil nil ("textmodes/text-mode.el" "textmodes/reftex-vars.el"
+;;;;;; "textmodes/fill.el" "term/x-win.el" "language/european.el"
+;;;;;; "international/utf-8.el" "international/mule.el" "emacs-lisp/float.el"
+;;;;;; "gnus/gnus-int.el" "vcursor.el" "vc-hooks.el" "subr.el" "startup.el"
+;;;;;; "simple.el" "replace.el" "pcvs-parse.el" "menu-bar.el" "font-core.el"
+;;;;;; "files.el" "faces.el" "play/meese.el" "obsolete/hilit19.el"
+;;;;;; "eshell/esh-groups.el" "window.el" "uniquify.el" "saveplace.el"
+;;;;;; "textmodes/page-ext.el" "term/mac-win.el" "international/mule-cmds.el"
+;;;;;; "eshell/esh-util.el" "eshell/esh-ext.el" "eshell/em-ls.el"
+;;;;;; "eshell/em-hist.el" "eshell/em-glob.el" "eshell/em-dirs.el"
+;;;;;; "eshell/em-cmpl.el" "select.el" "language/indian.el" "textmodes/reftex-global.el"
+;;;;;; "textmodes/reftex-auc.el" "language/georgian.el" "international/utf-16.el"
+;;;;;; "international/ucs-tables.el" "international/ja-dic-cnv.el"
+;;;;;; "ediff-wind.el" "cus-start.el" "progmodes/idlw-toolbar.el"
+;;;;;; "progmodes/idlw-rinfo.el" "language/cyrillic.el" "international/utf-8-subst.el"
+;;;;;; "international/mule-conf.el" "international/characters.el"
+;;;;;; "mouse.el" "loadup.el" "help.el" "ediff-ptch.el" "textmodes/texnfo-upd.el"
+;;;;;; "textmodes/refer.el" "textmodes/refbib.el" "textmodes/paragraphs.el"
+;;;;;; "textmodes/page.el" "textmodes/makeinfo.el" "textmodes/bib-mode.el"
+;;;;;; "term/wyse50.el" "term/vt420.el" "term/vt400.el" "term/vt320.el"
+;;;;;; "term/vt300.el" "term/vt240.el" "term/vt220.el" "term/vt201.el"
+;;;;;; "term/vt200.el" "term/vt125.el" "term/vt102.el" "term/vt100.el"
+;;;;;; "term/tvi970.el" "term/sup-mouse.el" "term/sun.el" "term/sun-mouse.el"
+;;;;;; "term/rxvt.el" "term/pc-win.el" "term/news.el" "term/lk201.el"
+;;;;;; "term/linux.el" "term/keyswap.el" "term/iris-ansi.el" "term/internal.el"
+;;;;;; "term/bobcat.el" "term/bg-mouse.el" "term/apollo.el" "term/AT386.el"
+;;;;;; "progmodes/mantemp.el" "progmodes/ebnf-otz.el" "progmodes/ebnf-iso.el"
+;;;;;; "progmodes/ebnf-bnf.el" "progmodes/cc-menus.el" "progmodes/cc-defs.el"
+;;;;;; "progmodes/cc-compat.el" "progmodes/cc-cmds.el" "progmodes/cc-bytecomp.el"
+;;;;;; "progmodes/cc-align.el" "play/gametree.el" "play/gamegrid.el"
+;;;;;; "obsolete/x-menu.el" "obsolete/x-apollo.el" "obsolete/uncompress.el"
+;;;;;; "obsolete/sun-fns.el" "obsolete/sun-curs.el" "obsolete/sc.el"
+;;;;;; "obsolete/rnews.el" "obsolete/profile.el" "obsolete/ooutline.el"
+;;;;;; "obsolete/mlsupport.el" "obsolete/cplus-md.el" "mail/vms-pmail.el"
+;;;;;; "mail/uce.el" "mail/rfc822.el" "mail/rfc2368.el" "mail/mspools.el"
+;;;;;; "mail/mh-seq.el" "mail/mh-pick.el" "mail/mh-funcs.el" "mail/mailpost.el"
+;;;;;; "mail/mailheader.el" "mail/blessmail.el" "language/vietnamese.el"
+;;;;;; "language/tibetan.el" "language/thai.el" "language/slovak.el"
+;;;;;; "language/romanian.el" "language/misc-lang.el" "language/lao.el"
+;;;;;; "language/korean.el" "language/japanese.el" "language/hebrew.el"
+;;;;;; "language/greek.el" "language/ethiopic.el" "language/english.el"
+;;;;;; "language/devanagari.el" "language/czech.el" "language/chinese.el"
+;;;;;; "international/swedish.el" "international/ogonek.el" "international/latin-9.el"
+;;;;;; "international/latin-8.el" "international/latin-5.el" "international/latin-4.el"
+;;;;;; "international/latin-3.el" "international/latin-2.el" "international/latin-1.el"
+;;;;;; "international/ja-dic-utl.el" "international/iso-swed.el"
+;;;;;; "international/iso-insert.el" "international/iso-ascii.el"
+;;;;;; "gnus/webmail.el" "gnus/utf7.el" "gnus/starttls.el" "gnus/rfc2231.el"
+;;;;;; "gnus/rfc2104.el" "gnus/rfc2047.el" "gnus/rfc2045.el" "gnus/rfc1843.el"
+;;;;;; "gnus/qp.el" "gnus/pop3.el" "gnus/nnweb.el" "gnus/nnwarchive.el"
+;;;;;; "gnus/nnultimate.el" "gnus/nntp.el" "gnus/nnspool.el" "gnus/nnslashdot.el"
+;;;;;; "gnus/nnoo.el" "gnus/nnlistserv.el" "gnus/nnimap.el" "gnus/nngateway.el"
+;;;;;; "gnus/nneething.el" "gnus/nndraft.el" "gnus/nndir.el" "gnus/nnagent.el"
+;;;;;; "gnus/mml.el" "gnus/mm-view.el" "gnus/mm-util.el" "gnus/mm-encode.el"
+;;;;;; "gnus/mm-decode.el" "gnus/mm-bodies.el" "gnus/messcompat.el"
+;;;;;; "gnus/mailcap.el" "gnus/mail-source.el" "gnus/mail-prsvr.el"
+;;;;;; "gnus/mail-parse.el" "gnus/ietf-drums.el" "gnus/gnus-vm.el"
+;;;;;; "gnus/gnus-uu.el" "gnus/gnus-util.el" "gnus/gnus-undo.el"
+;;;;;; "gnus/gnus-srvr.el" "gnus/gnus-setup.el" "gnus/gnus-score.el"
+;;;;;; "gnus/gnus-salt.el" "gnus/gnus-range.el" "gnus/gnus-nocem.el"
+;;;;;; "gnus/gnus-mh.el" "gnus/gnus-logic.el" "gnus/gnus-gl.el"
+;;;;;; "gnus/gnus-eform.el" "gnus/gnus-dup.el" "gnus/gnus-draft.el"
+;;;;;; "gnus/gnus-demon.el" "gnus/gnus-cus.el" "gnus/gnus-bcklg.el"
+;;;;;; "gnus/gnus-async.el" "gnus/format-spec.el" "gnus/flow-fill.el"
+;;;;;; "emulation/viper-util.el" "emulation/viper-mous.el" "emulation/viper-macs.el"
+;;;;;; "emulation/viper-keym.el" "emulation/viper-init.el" "emulation/tpu-mapper.el"
+;;;;;; "emulation/edt-vt100.el" "emulation/edt-pc.el" "emulation/edt-mapper.el"
+;;;;;; "emulation/edt-lk201.el" "emacs-lisp/sregex.el" "emacs-lisp/lucid.el"
+;;;;;; "emacs-lisp/lselect.el" "emacs-lisp/lmenu.el" "emacs-lisp/lisp.el"
+;;;;;; "emacs-lisp/lisp-mnt.el" "emacs-lisp/levents.el" "emacs-lisp/gulp.el"
+;;;;;; "emacs-lisp/find-gc.el" "emacs-lisp/ewoc.el" "emacs-lisp/cust-print.el"
+;;;;;; "emacs-lisp/cl-specs.el" "emacs-lisp/cl-macs.el" "emacs-lisp/cl-compat.el"
+;;;;;; "emacs-lisp/byte-opt.el" "emacs-lisp/assoc.el" "calendar/parse-time.el"
+;;;;;; "calendar/cal-x.el" "calendar/cal-tex.el" "calendar/cal-persia.el"
+;;;;;; "calendar/cal-move.el" "calendar/cal-menu.el" "calendar/cal-mayan.el"
+;;;;;; "calendar/cal-julian.el" "calendar/cal-iso.el" "calendar/cal-islam.el"
+;;;;;; "calendar/cal-french.el" "calendar/cal-coptic.el" "calendar/cal-china.el"
+;;;;;; "net/netrc.el" "net/eudcb-ph.el" "net/eudcb-ldap.el" "net/eudcb-bbdb.el"
+;;;;;; "net/eudc-vars.el" "eshell/esh-var.el" "eshell/esh-proc.el"
+;;;;;; "eshell/esh-opt.el" "eshell/esh-module.el" "eshell/esh-maint.el"
+;;;;;; "eshell/esh-io.el" "eshell/esh-cmd.el" "eshell/esh-arg.el"
+;;;;;; "eshell/em-xtra.el" "eshell/em-term.el" "eshell/em-smart.el"
+;;;;;; "eshell/em-script.el" "eshell/em-rebind.el" "eshell/em-prompt.el"
+;;;;;; "eshell/em-basic.el" "eshell/em-banner.el" "eshell/em-alias.el"
+;;;;;; "calc/calcsel2.el" "calc/calccomp.el" "calc/calcalg3.el"
+;;;;;; "calc/calcalg2.el" "calc/calc-yank.el" "calc/calc-vec.el"
+;;;;;; "calc/calc-undo.el" "calc/calc-trail.el" "calc/calc-stuff.el"
+;;;;;; "calc/calc-store.el" "calc/calc-stat.el" "calc/calc-sel.el"
+;;;;;; "calc/calc-rules.el" "calc/calc-rewr.el" "calc/calc-prog.el"
+;;;;;; "calc/calc-poly.el" "calc/calc-mtx.el" "calc/calc-mode.el"
+;;;;;; "calc/calc-misc.el" "calc/calc-math.el" "calc/calc-map.el"
+;;;;;; "calc/calc-maint.el" "calc/calc-macs.el" "calc/calc-lang.el"
+;;;;;; "calc/calc-keypd.el" "calc/calc-incom.el" "calc/calc-graph.el"
+;;;;;; "calc/calc-funcs.el" "calc/calc-frac.el" "calc/calc-forms.el"
+;;;;;; "calc/calc-fin.el" "calc/calc-embed.el" "calc/calc-cplx.el"
+;;;;;; "calc/calc-comb.el" "calc/calc-bin.el" "calc/calc-arith.el"
+;;;;;; "calc/calc-aent.el" "xml.el" "widget.el" "vt100-led.el" "vt-control.el"
+;;;;;; "vmsproc.el" "vms-patch.el" "unused.el" "timezone.el" "tempo.el"
+;;;;;; "soundex.el" "scroll-bar.el" "s-region.el" "register.el"
+;;;;;; "regi.el" "pcvs-util.el" "paths.el" "patcomp.el" "mouse-drag.el"
+;;;;;; "misc.el" "map-ynp.el" "kermit.el" "isearch.el" "generic-x.el"
+;;;;;; "forms-pass.el" "forms-d2.el" "foldout.el" "float-sup.el"
+;;;;;; "env.el" "emacs-lock.el" "electric.el" "ediff-vers.el" "ediff-merg.el"
+;;;;;; "ediff-init.el" "ediff-hook.el" "dos-vars.el" "dos-fns.el"
+;;;;;; "cus-dep.el" "cdl.el" "case-table.el" "byte-run.el" "buff-menu.el"
+;;;;;; "abbrevlist.el" "abbrev.el" "custom.el" "indent.el" "version.el"
+;;;;;; "w32-vars.el" "xscheme.el" "net/ldap.el" "emacs-lisp/cl-extra.el"
+;;;;;; "emacs-lisp/cl-seq.el" "emulation/cua-gmrk.el" "gnus/gnus-cite.el"
+;;;;;; "gnus/nnmail.el" "gnus/nnvirtual.el" "language/utf-8-lang.el"
+;;;;;; "calc/calc-help.el" "calc/calc-units.el" "dos-w32.el" "ediff-diff.el"
+;;;;;; "filesets.el" "format.el" "pcvs-info.el" "w32-fns.el" "calc/calc-alg.el"
+;;;;;; "gnus/gnus-ems.el" "gnus/gnus-sum.el" "gnus/gnus-topic.el"
+;;;;;; "gnus/nnheader.el" "emacs-lisp/bindat.el" "emacs-lisp/lisp-mode.el"
+;;;;;; "emulation/cua-rect.el" "emulation/viper-cmd.el" "eshell/em-pred.el"
+;;;;;; "eshell/em-unix.el" "net/tramp-vc.el" "progmodes/ada-prj.el"
+;;;;;; "progmodes/ebnf-yac.el" "term/tty-colors.el" "term/w32-win.el"
+;;;;;; "term/xterm.el" "allout.el" "bindings.el" "cus-load.el" "finder-inf.el"
+;;;;;; "frame.el" "mouse-copy.el" "emacs-lisp/authors.el" "emulation/viper-ex.el"
+;;;;;; "gnus/imap.el" "gnus/nnbabyl.el" "gnus/nnmbox.el" "gnus/nnmh.el"
+;;;;;; "progmodes/cc-engine.el" "textmodes/reftex-dcr.el" "textmodes/reftex-parse.el"
;;;;;; "textmodes/reftex-ref.el" "textmodes/reftex-sel.el" "textmodes/reftex-toc.el"
-;;;;;; "textmodes/reftex-vars.el" "textmodes/texnfo-upd.el" "textmodes/text-mode.el"
-;;;;;; "subdirs.el") (15577 23798 631183))
+;;;;;; "subdirs.el") (15739 50398 369119))
;;;***
\f