;;; Code:
\f
-;;;### (autoloads nil "5x5" "play/5x5.el" (21040 17194 398147 0))
+;;;### (autoloads nil "5x5" "play/5x5.el" (22086 11930 122062 731000))
;;; Generated autoloads from play/5x5.el
(autoload '5x5 "5x5" "\
;;;***
\f
-;;;### (autoloads nil "ada-mode" "progmodes/ada-mode.el" (20998 4934
-;;;;;; 952905 0))
+;;;### (autoloads nil "ada-mode" "progmodes/ada-mode.el" (22086 11930
+;;;;;; 138062 731000))
;;; Generated autoloads from progmodes/ada-mode.el
(autoload 'ada-add-extensions "ada-mode" "\
;;;***
\f
-;;;### (autoloads nil "ada-stmt" "progmodes/ada-stmt.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "ada-stmt" "progmodes/ada-stmt.el" (22086 11930
+;;;;;; 138062 731000))
;;; Generated autoloads from progmodes/ada-stmt.el
(autoload 'ada-header "ada-stmt" "\
;;;***
\f
-;;;### (autoloads nil "ada-xref" "progmodes/ada-xref.el" (21024 28968
-;;;;;; 738399 0))
+;;;### (autoloads nil "ada-xref" "progmodes/ada-xref.el" (22086 11930
+;;;;;; 138062 731000))
;;; Generated autoloads from progmodes/ada-xref.el
(autoload 'ada-find-file "ada-xref" "\
;;;***
\f
-;;;### (autoloads nil "add-log" "vc/add-log.el" (20992 52525 458637
-;;;;;; 0))
+;;;### (autoloads nil "add-log" "vc/add-log.el" (22086 11930 366062
+;;;;;; 731000))
;;; Generated autoloads from vc/add-log.el
(put 'change-log-default-name 'safe-local-variable 'string-or-null-p)
Optional arg FILE-NAME specifies the file to use.
If FILE-NAME is nil, use the value of `change-log-default-name'.
-If `change-log-default-name' is nil, behave as though it were 'ChangeLog'
+If `change-log-default-name' is nil, behave as though it were \"ChangeLog\"
\(or whatever we use on this operating system).
If `change-log-default-name' contains a leading directory component, then
;;;***
\f
-;;;### (autoloads nil "advice" "emacs-lisp/advice.el" (21032 23080
-;;;;;; 765139 0))
+;;;### (autoloads nil "advice" "emacs-lisp/advice.el" (22092 27717
+;;;;;; 604268 464000))
;;; Generated autoloads from emacs-lisp/advice.el
(defvar ad-redefinition-action 'warn "\
initialized. Redefining a piece of advice whose name is part of
the cache-id will clear the cache.
-See Info node `(elisp)Computed Advice' for detailed documentation.
-
\(fn FUNCTION ADVICE CLASS POSITION)" nil nil)
(autoload 'ad-activate "advice" "\
advice state that will be used during activation if appropriate. Only use
this if the `defadvice' gets actually compiled.
-See Info node `(elisp)Advising Functions' for comprehensive documentation.
usage: (defadvice FUNCTION (CLASS NAME [POSITION] [ARGLIST] FLAG...)
[DOCSTRING] [INTERACTIVE-FORM]
BODY...)
\(fn FUNCTION ARGS &rest BODY)" nil t)
-(put 'defadvice 'doc-string-elt '3)
+(function-put 'defadvice 'doc-string-elt '3)
-(put 'defadvice 'lisp-indent-function '2)
+(function-put 'defadvice 'lisp-indent-function '2)
;;;***
\f
-;;;### (autoloads nil "align" "align.el" (21012 37798 962028 0))
+;;;### (autoloads nil "align" "align.el" (22086 11929 490062 731000))
;;; Generated autoloads from align.el
(autoload 'align "align" "\
;;;***
\f
-;;;### (autoloads nil "allout" "allout.el" (20996 49577 892030 0))
+;;;### (autoloads nil "allout" "allout.el" (22086 11929 494062 731000))
;;; Generated autoloads from allout.el
(push (purecopy '(allout 2 3)) package--builtin-versions)
buffer with name derived from derived from that
of current buffer -- \"*BUFFERNAME exposed*\".
\\[allout-flatten-exposed-to-buffer] `allout-flatten-exposed-to-buffer'
- Like above 'copy-exposed', but convert topic
+ Like above `copy-exposed', but convert topic
prefixes to section.subsection... numeric
format.
\\[customize-variable] allout-auto-activation
subsequent decryption attempts until the cache times-out. That
can take several minutes. (Decryption of other entries is not
affected.) Upgrade your EasyPG version, if you can, and you can
-deliberately clear your gpg-agent's cache by sending it a '-HUP'
+deliberately clear your gpg-agent's cache by sending it a `-HUP'
signal.
See `allout-toggle-current-subtree-encryption' function docstring
;;;***
\f
-;;;### (autoloads nil "allout-widgets" "allout-widgets.el" (21124
-;;;;;; 45367 88860 0))
+;;;### (autoloads nil "allout-widgets" "allout-widgets.el" (22086
+;;;;;; 11929 490062 731000))
;;; Generated autoloads from allout-widgets.el
(push (purecopy '(allout-widgets 1 0)) package--builtin-versions)
;;;***
\f
-;;;### (autoloads nil "ange-ftp" "net/ange-ftp.el" (21032 23080 765139
-;;;;;; 0))
+;;;### (autoloads nil "ange-ftp" "net/ange-ftp.el" (22092 27717 960268
+;;;;;; 464000))
;;; Generated autoloads from net/ange-ftp.el
(defalias 'ange-ftp-re-read-dir 'ange-ftp-reread-dir)
;;;***
\f
-;;;### (autoloads nil "animate" "play/animate.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "animate" "play/animate.el" (22086 11930 122062
+;;;;;; 731000))
;;; Generated autoloads from play/animate.el
(autoload 'animate-string "animate" "\
;;;***
\f
-;;;### (autoloads nil "ansi-color" "ansi-color.el" (21086 26537 509049
-;;;;;; 0))
+;;;### (autoloads nil "ansi-color" "ansi-color.el" (22086 11929 494062
+;;;;;; 731000))
;;; Generated autoloads from ansi-color.el
(push (purecopy '(ansi-color 3 4 2)) package--builtin-versions)
;;;***
\f
-;;;### (autoloads nil "antlr-mode" "progmodes/antlr-mode.el" (21022
-;;;;;; 34805 522289 827000))
+;;;### (autoloads nil "antlr-mode" "progmodes/antlr-mode.el" (22086
+;;;;;; 11930 138062 731000))
;;; Generated autoloads from progmodes/antlr-mode.el
(push (purecopy '(antlr-mode 2 2 3)) package--builtin-versions)
;;;***
\f
-;;;### (autoloads nil "appt" "calendar/appt.el" (20992 52525 458637
-;;;;;; 0))
+;;;### (autoloads nil "appt" "calendar/appt.el" (22086 11929 526062
+;;;;;; 731000))
;;; Generated autoloads from calendar/appt.el
(autoload 'appt-add "appt" "\
;;;***
\f
-;;;### (autoloads nil "apropos" "apropos.el" (20991 31656 363459
-;;;;;; 0))
+;;;### (autoloads nil "apropos" "apropos.el" (22099 26170 362017
+;;;;;; 16000))
;;; Generated autoloads from apropos.el
(autoload 'apropos-read-pattern "apropos" "\
(autoload 'apropos-variable "apropos" "\
Show variables that match PATTERN.
-When DO-NOT-ALL is not-nil, show user options only, i.e. behave
+When DO-NOT-ALL is non-nil, show user options only, i.e. behave
like `apropos-user-option'.
\(fn PATTERN &optional DO-NOT-ALL)" t nil)
;;;***
\f
-;;;### (autoloads nil "arc-mode" "arc-mode.el" (21123 58191 550148
-;;;;;; 88000))
+;;;### (autoloads nil "arc-mode" "arc-mode.el" (22086 11929 494062
+;;;;;; 731000))
;;; Generated autoloads from arc-mode.el
(autoload 'archive-mode "arc-mode" "\
;;;***
\f
-;;;### (autoloads nil "array" "array.el" (21040 17194 398147 0))
+;;;### (autoloads nil "array" "array.el" (22086 11929 494062 731000))
;;; Generated autoloads from array.el
(autoload 'array-mode "array" "\
;;;***
\f
-;;;### (autoloads nil "artist" "textmodes/artist.el" (20891 18859
-;;;;;; 893295 0))
+;;;### (autoloads nil "artist" "textmodes/artist.el" (22086 11930
+;;;;;; 310062 731000))
;;; Generated autoloads from textmodes/artist.el
(push (purecopy '(artist 1 2 6)) package--builtin-versions)
* Cut copies, then clears the rectangle/square.
* When drawing lines or poly-lines, you can set arrows.
- See below under ``Arrows'' for more info.
+ See below under \"Arrows\" for more info.
* The mode line shows the currently selected drawing operation.
In addition, if it has an asterisk (*) at the end, you
artist-vaporize-fuzziness Tolerance when recognizing lines
artist-spray-interval Seconds between repeated sprayings
artist-spray-radius Size of the spray-area
- artist-spray-chars The spray-``color''
- artist-spray-new-chars Initial spray-``color''
+ artist-spray-chars The spray-\"color\"
+ artist-spray-new-chars Initial spray-\"color\"
Hooks
;;;***
\f
-;;;### (autoloads nil "asm-mode" "progmodes/asm-mode.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "asm-mode" "progmodes/asm-mode.el" (22086 11930
+;;;;;; 142062 731000))
;;; Generated autoloads from progmodes/asm-mode.el
(autoload 'asm-mode "asm-mode" "\
;;;***
\f
-;;;### (autoloads nil "auth-source" "gnus/auth-source.el" (20953
-;;;;;; 16424 151515 0))
+;;;### (autoloads nil "auth-source" "gnus/auth-source.el" (22086
+;;;;;; 11929 774062 731000))
;;; Generated autoloads from gnus/auth-source.el
(defvar auth-source-cache-expiry 7200 "\
;;;***
\f
-;;;### (autoloads nil "autoarg" "autoarg.el" (21056 5418 85093 0))
+;;;### (autoloads nil "autoarg" "autoarg.el" (22086 11929 494062
+;;;;;; 731000))
;;; Generated autoloads from autoarg.el
(defvar autoarg-mode nil "\
;;;***
\f
-;;;### (autoloads nil "autoconf" "progmodes/autoconf.el" (21116 51266
-;;;;;; 54795 0))
+;;;### (autoloads nil "autoconf" "progmodes/autoconf.el" (22086 11930
+;;;;;; 142062 731000))
;;; Generated autoloads from progmodes/autoconf.el
(autoload 'autoconf-mode "autoconf" "\
;;;***
\f
-;;;### (autoloads nil "autoinsert" "autoinsert.el" (21056 5418 85093
-;;;;;; 0))
+;;;### (autoloads nil "autoinsert" "autoinsert.el" (22086 11929 494062
+;;;;;; 731000))
;;; Generated autoloads from autoinsert.el
(autoload 'auto-insert "autoinsert" "\
;;;***
\f
-;;;### (autoloads nil "autoload" "emacs-lisp/autoload.el" (21105
-;;;;;; 27518 41539 966000))
+;;;### (autoloads nil "autoload" "emacs-lisp/autoload.el" (22086
+;;;;;; 11929 634062 731000))
;;; Generated autoloads from emacs-lisp/autoload.el
(put 'generated-autoload-file 'safe-local-variable 'stringp)
(put 'generated-autoload-load-name 'safe-local-variable 'stringp)
+(put 'autoload-ensure-writable 'risky-local-variable t)
+
(autoload 'update-file-autoloads "autoload" "\
Update the autoloads for FILE.
If prefix arg SAVE-AFTER is non-nil, save the buffer too.
;;;***
\f
-;;;### (autoloads nil "autorevert" "autorevert.el" (21041 38058 75002
-;;;;;; 0))
+;;;### (autoloads nil "autorevert" "autorevert.el" (22089 51528 204929
+;;;;;; 316000))
;;; Generated autoloads from autorevert.el
(autoload 'auto-revert-mode "autorevert" "\
Turn on Auto-Revert Mode.
This function is designed to be added to hooks, for example:
- (add-hook 'c-mode-hook 'turn-on-auto-revert-mode)
+ (add-hook \\='c-mode-hook #\\='turn-on-auto-revert-mode)
\(fn)" nil nil)
Turn on Auto-Revert Tail mode.
This function is designed to be added to hooks, for example:
- (add-hook 'my-logfile-mode-hook 'turn-on-auto-revert-tail-mode)
+ (add-hook \\='my-logfile-mode-hook #\\='turn-on-auto-revert-tail-mode)
\(fn)" nil nil)
;;;***
\f
-;;;### (autoloads nil "avoid" "avoid.el" (21028 26023 305371 0))
+;;;### (autoloads nil "avoid" "avoid.el" (22086 11929 498062 731000))
;;; Generated autoloads from avoid.el
(defvar mouse-avoidance-mode nil "\
* cat-and-mouse: Same as `animate'.
* proteus: As `animate', but changes the shape of the mouse pointer too.
-Whenever the mouse is moved, the frame is also raised.
-
\(See `mouse-avoidance-threshold' for definition of \"too close\",
and `mouse-avoidance-nudge-dist' and `mouse-avoidance-nudge-var' for
definition of \"random distance\".)
;;;***
\f
-;;;### (autoloads nil "bat-mode" "progmodes/bat-mode.el" (21024 28968
-;;;;;; 738399 0))
+;;;### (autoloads nil "bat-mode" "progmodes/bat-mode.el" (22086 11930
+;;;;;; 142062 731000))
;;; Generated autoloads from progmodes/bat-mode.el
(add-to-list 'auto-mode-alist '("\\.\\(bat\\|cmd\\)\\'" . bat-mode))
;;;***
\f
-;;;### (autoloads nil "battery" "battery.el" (21096 9821 480125 690000))
+;;;### (autoloads nil "battery" "battery.el" (22086 11929 498062
+;;;;;; 731000))
;;; Generated autoloads from battery.el
(put 'battery-mode-line-string 'risky-local-variable t)
;;;***
\f
-;;;### (autoloads nil "benchmark" "emacs-lisp/benchmark.el" (20709
-;;;;;; 26818 907104 0))
+;;;### (autoloads nil "benchmark" "emacs-lisp/benchmark.el" (22086
+;;;;;; 11929 638062 731000))
;;; Generated autoloads from emacs-lisp/benchmark.el
(autoload 'benchmark-run "benchmark" "\
\(fn &optional REPETITIONS &rest FORMS)" nil t)
-(put 'benchmark-run 'lisp-indent-function '1)
+(function-put 'benchmark-run 'lisp-indent-function '1)
(autoload 'benchmark-run-compiled "benchmark" "\
Time execution of compiled version of FORMS.
\(fn &optional REPETITIONS &rest FORMS)" nil t)
-(put 'benchmark-run-compiled 'lisp-indent-function '1)
+(function-put 'benchmark-run-compiled 'lisp-indent-function '1)
(autoload 'benchmark "benchmark" "\
Print the time taken for REPETITIONS executions of FORM.
;;;***
\f
-;;;### (autoloads nil "bibtex" "textmodes/bibtex.el" (21036 20141
-;;;;;; 396718 0))
+;;;### (autoloads nil "bibtex" "textmodes/bibtex.el" (22092 27718
+;;;;;; 508268 464000))
;;; Generated autoloads from textmodes/bibtex.el
(autoload 'bibtex-initialize "bibtex" "\
;;;***
\f
;;;### (autoloads nil "bibtex-style" "textmodes/bibtex-style.el"
-;;;;;; (20709 26818 907104 0))
+;;;;;; (22086 11930 310062 731000))
;;; Generated autoloads from textmodes/bibtex-style.el
(autoload 'bibtex-style-mode "bibtex-style" "\
;;;***
\f
-;;;### (autoloads nil "binhex" "mail/binhex.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "binhex" "mail/binhex.el" (22086 11929 930062
+;;;;;; 731000))
;;; Generated autoloads from mail/binhex.el
(defconst binhex-begin-line "^:...............................................................$" "\
;;;***
\f
-;;;### (autoloads nil "blackbox" "play/blackbox.el" (21040 17194
-;;;;;; 398147 0))
+;;;### (autoloads nil "blackbox" "play/blackbox.el" (22086 11930
+;;;;;; 122062 731000))
;;; Generated autoloads from play/blackbox.el
(autoload 'blackbox "blackbox" "\
;;;***
\f
-;;;### (autoloads nil "bookmark" "bookmark.el" (21040 17194 398147
-;;;;;; 0))
+;;;### (autoloads nil "bookmark" "bookmark.el" (22086 11929 498062
+;;;;;; 731000))
;;; Generated autoloads from bookmark.el
(define-key ctl-x-r-map "b" 'bookmark-jump)
(define-key ctl-x-r-map "m" 'bookmark-set)
+ (define-key ctl-x-r-map "M" 'bookmark-set-no-overwrite)
(define-key ctl-x-r-map "l" 'bookmark-bmenu-list)
-(defvar bookmark-map (let ((map (make-sparse-keymap))) (define-key map "x" 'bookmark-set) (define-key map "m" 'bookmark-set) (define-key map "j" 'bookmark-jump) (define-key map "g" 'bookmark-jump) (define-key map "o" 'bookmark-jump-other-window) (define-key map "i" 'bookmark-insert) (define-key map "e" 'edit-bookmarks) (define-key map "f" 'bookmark-insert-location) (define-key map "r" 'bookmark-rename) (define-key map "d" 'bookmark-delete) (define-key map "l" 'bookmark-load) (define-key map "w" 'bookmark-write) (define-key map "s" 'bookmark-save) map) "\
+(defvar bookmark-map (let ((map (make-sparse-keymap))) (define-key map "x" 'bookmark-set) (define-key map "m" 'bookmark-set) (define-key map "M" 'bookmark-set-no-overwrite) (define-key map "j" 'bookmark-jump) (define-key map "g" 'bookmark-jump) (define-key map "o" 'bookmark-jump-other-window) (define-key map "i" 'bookmark-insert) (define-key map "e" 'edit-bookmarks) (define-key map "f" 'bookmark-insert-location) (define-key map "r" 'bookmark-rename) (define-key map "d" 'bookmark-delete) (define-key map "l" 'bookmark-load) (define-key map "w" 'bookmark-write) (define-key map "s" 'bookmark-save) map) "\
Keymap containing bindings to bookmark functions.
It is not bound to any key by default: to bind it
so that you have a bookmark prefix, just use `global-set-key' and bind a
(autoload 'bookmark-set "bookmark" "\
Set a bookmark named NAME at the current location.
-If name is nil, then prompt the user.
+If NAME is nil, then prompt the user.
With a prefix arg (non-nil NO-OVERWRITE), do not overwrite any
existing bookmark that has the same name as NAME, but instead push the
\(fn &optional NAME NO-OVERWRITE)" t nil)
+(autoload 'bookmark-set-no-overwrite "bookmark" "\
+Set a bookmark named NAME at the current location.
+If NAME is nil, then prompt the user.
+
+If a bookmark named NAME already exists and prefix argument
+PUSH-BOOKMARK is non-nil, then push the new bookmark onto the
+bookmark alist. Pushing it means that among bookmarks named
+NAME, this one becomes the one in effect, but the others are
+still there, in order, and become effective again if the user
+ever deletes the most recent one.
+
+Otherwise, if a bookmark named NAME already exists but PUSH-BOOKMARK
+is nil, raise an error.
+
+To yank words from the text of the buffer and use them as part of the
+bookmark name, type C-w while setting a bookmark. Successive C-w's
+yank successive words.
+
+Typing C-u inserts (at the bookmark name prompt) the name of the last
+bookmark used in the document where the new bookmark is being set;
+this helps you use a single bookmark name to track progress through a
+large document. If there is no prior bookmark for this document, then
+C-u inserts an appropriate name based on the buffer or file.
+
+Use \\[bookmark-delete] to remove bookmarks (you give it a name and
+it removes only the first instance of a bookmark with that name from
+the list of bookmarks.)
+
+\(fn &optional NAME PUSH-BOOKMARK)" t nil)
+
(autoload 'bookmark-jump "bookmark" "\
Jump to bookmark BOOKMARK (a point in some file).
You may have a problem using this function if the value of variable
(autoload 'bookmark-write "bookmark" "\
Write bookmarks to a file (reading the file name with the minibuffer).
-Don't use this in Lisp programs; use `bookmark-save' instead.
\(fn)" t nil)
+(function-put 'bookmark-write 'interactive-only 'bookmark-save)
+
(autoload 'bookmark-save "bookmark" "\
Save currently defined bookmarks.
Saves by default in the file defined by the variable
If you load a file containing bookmarks with the same names as
bookmarks already present in your Emacs, the new bookmarks will get
-unique numeric suffixes \"<2>\", \"<3>\", ... following the same
-method buffers use to resolve name collisions.
+unique numeric suffixes \"<2>\", \"<3>\", etc.
\(fn FILE &optional OVERWRITE NO-MSG)" t nil)
;;;***
\f
-;;;### (autoloads nil "browse-url" "net/browse-url.el" (21032 23080
-;;;;;; 765139 0))
+;;;### (autoloads nil "browse-url" "net/browse-url.el" (22086 11929
+;;;;;; 990062 731000))
;;; Generated autoloads from net/browse-url.el
(defvar browse-url-browser-function 'browse-url-default-browser "\
(autoload 'browse-url "browse-url" "\
Ask a WWW browser to load URL.
-Prompts for a URL, defaulting to the URL at or before point. Variable
-`browse-url-browser-function' says which browser to use.
+Prompt for a URL, defaulting to the URL at or before point.
+The variable `browse-url-browser-function' says which browser to use.
If the URL is a mailto: URL, consult `browse-url-mailto-function'
first, if that exists.
+Passes any ARGS to the browser function.
+The default is to pass `browse-url-new-window-flag'.
+
\(fn URL &rest ARGS)" t nil)
(autoload 'browse-url-at-point "browse-url" "\
Ask a WWW browser to load the URL at or before point.
-Doesn't let you edit the URL like `browse-url'. Variable
-`browse-url-browser-function' says which browser to use.
+Variable `browse-url-browser-function' says which browser to use.
+Optional prefix argument ARG non-nil inverts the value of the option
+`browse-url-new-window-flag'.
\(fn &optional ARG)" t nil)
(autoload 'browse-url-at-mouse "browse-url" "\
Ask a WWW browser to load a URL clicked with the mouse.
The URL is the one around or before the position of the mouse click
-but point is not changed. Doesn't let you edit the URL like
-`browse-url'. Variable `browse-url-browser-function' says which browser
-to use.
+but point is not changed. Variable `browse-url-browser-function'
+says which browser to use.
\(fn EVENT)" t nil)
\(fn URL &optional NEW-WINDOW)" t nil)
+(make-obsolete 'browse-url-netscape 'nil '"25.1")
+
(autoload 'browse-url-mozilla "browse-url" "\
Ask the Mozilla WWW browser to load URL.
Default to the URL around or before point. The strings in variable
(autoload 'browse-url-firefox "browse-url" "\
Ask the Firefox WWW browser to load URL.
-Default to the URL around or before point. The strings in
-variable `browse-url-firefox-arguments' are also passed to
-Firefox.
+Defaults to the URL around or before point. Passes the strings
+in the variable `browse-url-firefox-arguments' to Firefox.
-When called interactively, if variable
-`browse-url-new-window-flag' is non-nil, load the document in a
-new Firefox window, otherwise use a random existing one. A
-non-nil interactive prefix argument reverses the effect of
-`browse-url-new-window-flag'.
+Interactively, if the variable `browse-url-new-window-flag' is non-nil,
+loads the document in a new Firefox window. A non-nil prefix argument
+reverses the effect of `browse-url-new-window-flag'.
If `browse-url-firefox-new-window-is-tab' is non-nil, then
whenever a document would otherwise be loaded in a new window, it
is loaded in a new tab in an existing window instead.
-When called non-interactively, optional second argument
-NEW-WINDOW is used instead of `browse-url-new-window-flag'.
-
-On MS-Windows systems the optional `new-window' parameter is
-ignored. Firefox for Windows does not support the \"-remote\"
-command line parameter. Therefore, the
-`browse-url-new-window-flag' and `browse-url-firefox-new-window-is-tab'
-are ignored as well. Firefox on Windows will always open the requested
-URL in a new window.
+Non-interactively, this uses the optional second argument NEW-WINDOW
+instead of `browse-url-new-window-flag'.
\(fn URL &optional NEW-WINDOW)" t nil)
\(fn URL &optional NEW-WINDOW)" t nil)
+(make-obsolete 'browse-url-galeon 'nil '"25.1")
+
(autoload 'browse-url-emacs "browse-url" "\
Ask Emacs to load URL into a buffer and show it in another window.
\(fn URL &optional NEW-WINDOW)" t nil)
+(make-obsolete 'browse-url-gnome-moz 'nil '"25.1")
+
(autoload 'browse-url-mosaic "browse-url" "\
Ask the XMosaic WWW browser to load URL.
\(fn URL &optional NEW-WINDOW)" t nil)
+(make-obsolete 'browse-url-mosaic 'nil '"25.1")
+
(autoload 'browse-url-cci "browse-url" "\
Ask the XMosaic WWW browser to load URL.
Default to the URL around or before point.
\(fn URL &optional NEW-WINDOW)" t nil)
+(make-obsolete 'browse-url-cci 'nil '"25.1")
+
+(autoload 'browse-url-conkeror "browse-url" "\
+Ask the Conkeror WWW browser to load URL.
+Default to the URL around or before point. Also pass the strings
+in the variable `browse-url-conkeror-arguments' to Conkeror.
+
+When called interactively, if variable
+`browse-url-new-window-flag' is non-nil, load the document in a
+new Conkeror window, otherwise use a random existing one. A
+non-nil interactive prefix argument reverses the effect of
+`browse-url-new-window-flag'.
+
+If variable `browse-url-conkeror-new-window-is-buffer' is
+non-nil, then whenever a document would otherwise be loaded in a
+new window, load it in a new buffer in an existing window instead.
+
+When called non-interactively, use optional second argument
+NEW-WINDOW instead of `browse-url-new-window-flag'.
+
+\(fn URL &optional NEW-WINDOW)" t nil)
+
(autoload 'browse-url-w3 "browse-url" "\
Ask the w3 WWW browser to load URL.
Default to the URL around or before point.
\(fn URL &optional NEW-WINDOW)" t nil)
+(make-obsolete 'browse-url-w3-gnudoit 'nil '"25.1")
+
(autoload 'browse-url-text-xterm "browse-url" "\
Ask a text browser to load URL.
URL defaults to the URL around or before point.
;;;***
\f
-;;;### (autoloads nil "bs" "bs.el" (20992 52525 458637 0))
+;;;### (autoloads nil "bs" "bs.el" (22086 11929 498062 731000))
;;; Generated autoloads from bs.el
(push (purecopy '(bs 1 17)) package--builtin-versions)
;;;***
\f
-;;;### (autoloads nil "bubbles" "play/bubbles.el" (21041 38058 75002
-;;;;;; 0))
+;;;### (autoloads nil "bubbles" "play/bubbles.el" (22086 11930 122062
+;;;;;; 731000))
;;; Generated autoloads from play/bubbles.el
(autoload 'bubbles "bubbles" "\
;;;***
\f
;;;### (autoloads nil "bug-reference" "progmodes/bug-reference.el"
-;;;;;; (20709 26818 907104 0))
+;;;;;; (22086 11930 142062 731000))
;;; Generated autoloads from progmodes/bug-reference.el
(put 'bug-reference-url-format 'safe-local-variable (lambda (s) (or (stringp s) (and (symbolp s) (get s 'bug-reference-url-format)))))
;;;***
\f
-;;;### (autoloads nil "bytecomp" "emacs-lisp/bytecomp.el" (21145
-;;;;;; 51520 109004 0))
+;;;### (autoloads nil "bytecomp" "emacs-lisp/bytecomp.el" (22108
+;;;;;; 15942 526032 987000))
;;; Generated autoloads from emacs-lisp/bytecomp.el
(put 'byte-compile-dynamic 'safe-local-variable 'booleanp)
(put 'byte-compile-disable-print-circle 'safe-local-variable 'booleanp)
(autoload 'byte-compile-enable-warning "bytecomp" "\
Change `byte-compile-warnings' to enable WARNING.
-If `byte-compile-warnings' is `t', do nothing. Otherwise, if the
+If `byte-compile-warnings' is t, do nothing. Otherwise, if the
first element is `not', remove WARNING, else add it.
Normally you should let-bind `byte-compile-warnings' before calling this,
else the global value will be modified.
all functions called by those functions.
The call graph does not include macros, inline functions, or
-primitives that the byte-code interpreter knows about directly (eq,
-cons, etc.).
+primitives that the byte-code interpreter knows about directly
+\(`eq', `cons', etc.).
The call tree also lists those functions which are not known to be called
\(that is, to which no calls have been compiled), and which cannot be
;;;***
\f
-;;;### (autoloads nil "cal-china" "calendar/cal-china.el" (21023
-;;;;;; 8104 618865 0))
+;;;### (autoloads nil "cal-china" "calendar/cal-china.el" (22086
+;;;;;; 11929 526062 731000))
;;; Generated autoloads from calendar/cal-china.el
(put 'calendar-chinese-time-zone 'risky-local-variable t)
;;;***
\f
-;;;### (autoloads nil "cal-dst" "calendar/cal-dst.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "cal-dst" "calendar/cal-dst.el" (22086 11929
+;;;;;; 526062 731000))
;;; Generated autoloads from calendar/cal-dst.el
(put 'calendar-daylight-savings-starts 'risky-local-variable t)
;;;***
\f
-;;;### (autoloads nil "cal-hebrew" "calendar/cal-hebrew.el" (20709
-;;;;;; 26818 907104 0))
+;;;### (autoloads nil "cal-hebrew" "calendar/cal-hebrew.el" (22086
+;;;;;; 11929 526062 731000))
;;; Generated autoloads from calendar/cal-hebrew.el
(autoload 'calendar-hebrew-list-yahrzeits "cal-hebrew" "\
\(fn DEATH-DATE START-YEAR END-YEAR)" t nil)
-(define-obsolete-function-alias 'list-yahrzeit-dates 'calendar-hebrew-list-yahrzeits "23.1")
-
;;;***
\f
-;;;### (autoloads nil "calc" "calc/calc.el" (21128 42425 434886 0))
+;;;### (autoloads nil "calc" "calc/calc.el" (22086 11929 522062 731000))
;;; Generated autoloads from calc/calc.el
(define-key ctl-x-map "*" 'calc-dispatch)
(autoload 'quick-calc "calc" "\
Do a quick calculation in the minibuffer without invoking full Calculator.
+With prefix argument INSERT, insert the result in the current
+buffer. Otherwise, the result is copied into the kill ring.
-\(fn)" t nil)
+\(fn &optional INSERT)" t nil)
(autoload 'calc-eval "calc" "\
Do a quick calculation and return the result as a string.
\(fn FUNC ARGS &rest BODY)" nil t)
-(put 'defmath 'doc-string-elt '3)
+(function-put 'defmath 'doc-string-elt '3)
;;;***
\f
-;;;### (autoloads nil "calc-undo" "calc/calc-undo.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "calc-undo" "calc/calc-undo.el" (22086 11929
+;;;;;; 518062 731000))
;;; Generated autoloads from calc/calc-undo.el
(autoload 'calc-undo "calc-undo" "\
;;;***
\f
-;;;### (autoloads nil "calculator" "calculator.el" (21031 2230 839140
-;;;;;; 0))
+;;;### (autoloads nil "calculator" "calculator.el" (22092 27717 520268
+;;;;;; 464000))
;;; Generated autoloads from calculator.el
(autoload 'calculator "calculator" "\
;;;***
\f
-;;;### (autoloads nil "calendar" "calendar/calendar.el" (20993 36675
-;;;;;; 840108 928000))
+;;;### (autoloads nil "calendar" "calendar/calendar.el" (22092 27717
+;;;;;; 540268 464000))
;;; Generated autoloads from calendar/calendar.el
(autoload 'calendar "calendar" "\
;;;***
\f
-;;;### (autoloads nil "canlock" "gnus/canlock.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "canlock" "gnus/canlock.el" (22086 11929 774062
+;;;;;; 731000))
;;; Generated autoloads from gnus/canlock.el
(autoload 'canlock-insert-header "canlock" "\
;;;***
\f
-;;;### (autoloads nil "cap-words" "progmodes/cap-words.el" (20709
-;;;;;; 26818 907104 0))
-;;; Generated autoloads from progmodes/cap-words.el
-
-(autoload 'capitalized-words-mode "cap-words" "\
-Toggle Capitalized Words mode.
-With a prefix argument ARG, enable Capitalized Words mode if ARG
-is positive, and disable it otherwise. If called from Lisp,
-enable the mode if ARG is omitted or nil.
-
-Capitalized Words mode is a buffer-local minor mode. When
-enabled, a word boundary occurs immediately before an uppercase
-letter in a symbol. This is in addition to all the normal
-boundaries given by the syntax and category tables. There is no
-restriction to ASCII.
-
-E.g. the beginning of words in the following identifier are as marked:
-
- capitalizedWorDD
- ^ ^ ^^
-
-Note that these word boundaries only apply for word motion and
-marking commands such as \\[forward-word]. This mode does not affect word
-boundaries found by regexp matching (`\\>', `\\w' &c).
-
-This style of identifiers is common in environments like Java ones,
-where underscores aren't trendy enough. Capitalization rules are
-sometimes part of the language, e.g. Haskell, which may thus encourage
-such a style. It is appropriate to add `capitalized-words-mode' to
-the mode hook for programming language modes in which you encounter
-variables like this, e.g. `java-mode-hook'. It's unlikely to cause
-trouble if such identifiers aren't used.
-
-See also `glasses-mode' and `studlify-word'.
-Obsoletes `c-forward-into-nomenclature'.
-
-\(fn &optional ARG)" t nil)
-
-;;;***
-\f
-;;;### (autoloads nil "cc-compat" "progmodes/cc-compat.el" (20709
-;;;;;; 26818 907104 0))
-;;; Generated autoloads from progmodes/cc-compat.el
-(put 'c-indent-level 'safe-local-variable 'integerp)
-
-;;;***
-\f
-;;;### (autoloads nil "cc-engine" "progmodes/cc-engine.el" (21102
-;;;;;; 14759 136845 0))
+;;;### (autoloads nil "cc-engine" "progmodes/cc-engine.el" (22108
+;;;;;; 15942 570032 987000))
;;; Generated autoloads from progmodes/cc-engine.el
(autoload 'c-guess-basic-syntax "cc-engine" "\
;;;***
\f
-;;;### (autoloads nil "cc-guess" "progmodes/cc-guess.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "cc-guess" "progmodes/cc-guess.el" (22086 11930
+;;;;;; 150062 731000))
;;; Generated autoloads from progmodes/cc-guess.el
(defvar c-guess-guessed-offsets-alist nil "\
;;;***
\f
-;;;### (autoloads nil "cc-mode" "progmodes/cc-mode.el" (21040 17194
-;;;;;; 398147 0))
+;;;### (autoloads nil "cc-mode" "progmodes/cc-mode.el" (22101 42694
+;;;;;; 157526 804000))
;;; Generated autoloads from progmodes/cc-mode.el
(autoload 'c-initialize-cc-mode "cc-mode" "\
(add-to-list 'auto-mode-alist '("\\.ii\\'" . c++-mode))
(autoload 'c-mode "cc-mode" "\
-Major mode for editing K&R and ANSI C code.
+Major mode for editing C code.
+
To submit a problem report, enter `\\[c-submit-bug-report]' from a
c-mode buffer. This automatically sets up a mail buffer with version
information already added. You just need to add a description of the
;;;***
\f
-;;;### (autoloads nil "cc-styles" "progmodes/cc-styles.el" (20709
-;;;;;; 26818 907104 0))
+;;;### (autoloads nil "cc-styles" "progmodes/cc-styles.el" (22086
+;;;;;; 11930 154062 731000))
;;; Generated autoloads from progmodes/cc-styles.el
(autoload 'c-set-style "cc-styles" "\
;;;***
\f
-;;;### (autoloads nil "cc-vars" "progmodes/cc-vars.el" (20907 7082
-;;;;;; 901087 0))
+;;;### (autoloads nil "cc-vars" "progmodes/cc-vars.el" (22086 11930
+;;;;;; 154062 731000))
;;; Generated autoloads from progmodes/cc-vars.el
(put 'c-basic-offset 'safe-local-variable 'integerp)
(put 'c-backslash-column 'safe-local-variable 'integerp)
;;;***
\f
-;;;### (autoloads nil "ccl" "international/ccl.el" (20884 7264 412929
-;;;;;; 442000))
+;;;### (autoloads nil "ccl" "international/ccl.el" (22086 11929 874062
+;;;;;; 731000))
;;; Generated autoloads from international/ccl.el
(autoload 'ccl-compile "ccl" "\
\(fn CCL-PROGRAM)" nil nil)
(autoload 'ccl-dump "ccl" "\
-Disassemble compiled CCL-CODE.
+Disassemble compiled CCL-code CODE.
-\(fn CCL-CODE)" nil nil)
+\(fn CODE)" nil nil)
(autoload 'declare-ccl-program "ccl" "\
Declare NAME as a name of CCL program.
BRANCH := (branch EXPRESSION CCL_BLOCK_0 [CCL_BLOCK_1 ...])
;; Execute STATEMENTs until (break) or (end) is executed.
+
+;; Create a block of STATEMENTs for repeating. The STATEMENTs
+;; are executed sequentially until REPEAT or BREAK is executed.
+;; If REPEAT statement is executed, STATEMENTs are executed from the
+;; start again. If BREAK statements is executed, the execution
+;; exits from the block. If neither REPEAT nor BREAK is
+;; executed, the execution exits from the block after executing the
+;; last STATEMENT.
LOOP := (loop STATEMENT [STATEMENT ...])
;; Terminate the most inner loop.
TRANSLATE :=
- (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'.
+ ;; Decode character SRC, translate it by translate table
+ ;; TABLE, and encode it back to DST. TABLE is specified
+ ;; by its id number in REG_0, SRC is specified by its
+ ;; charset id number and codepoint in REG_1 and REG_2
+ ;; respectively.
+ ;; On encoding, the charset of highest priority is selected.
+ ;; After the execution, DST is specified by its charset
+ ;; id number and codepoint in REG_1 and REG_2 respectively.
+ (translate-character REG_0 REG_1 REG_2)
+
+ ;; Same as above except for SYMBOL specifying the name of
+ ;; the translate table defined by `define-translation-table'.
+ | (translate-character SYMBOL REG_1 REG_2)
+
LOOKUP :=
- (lookup-character SYMBOL REG(charset) REG(codepoint))
+ ;; Look up character SRC in hash table TABLE. TABLE is
+ ;; specified by its name in SYMBOL, and SRC is specified by
+ ;; its charset id number and codepoint in REG_1 and REG_2
+ ;; respectively.
+ ;; If its associated value is an integer, set REG_1 to that
+ ;; value, and set r7 to 1. Otherwise, set r7 to 0.
+ (lookup-character SYMBOL REG_1 REG_2)
+
+ ;; Look up integer value N in hash table TABLE. TABLE is
+ ;; specified by its name in SYMBOL and N is specified in
+ ;; REG.
+ ;; If its associated value is a character, set REG to that
+ ;; value, and set r7 to 1. Otherwise, set r7 to 0.
| (lookup-integer SYMBOL REG(integer))
- ;; SYMBOL refers to a table defined by `define-translation-hash-table'.
+
MAP :=
- (iterate-multiple-map REG REG MAP-IDs)
- | (map-multiple REG REG (MAP-SET))
- | (map-single REG REG MAP-ID)
+ ;; The following statements are for internal use only.
+ (iterate-multiple-map REG REG MAP-IDs)
+ | (map-multiple REG REG (MAP-SET))
+ | (map-single REG REG MAP-ID)
+
MAP-IDs := MAP-ID ...
MAP-SET := MAP-IDs | (MAP-IDs) MAP-SET
MAP-ID := integer
\(fn NAME CCL-PROGRAM &optional DOC)" nil t)
-(put 'define-ccl-program 'doc-string-elt '3)
+(function-put 'define-ccl-program 'doc-string-elt '3)
(autoload 'check-ccl-program "ccl" "\
Check validity of CCL-PROGRAM.
;;;***
\f
-;;;### (autoloads nil "cconv" "emacs-lisp/cconv.el" (21120 48308
-;;;;;; 922449 0))
+;;;### (autoloads nil "cconv" "emacs-lisp/cconv.el" (22102 63557
+;;;;;; 288509 103000))
;;; Generated autoloads from emacs-lisp/cconv.el
(autoload 'cconv-closure-convert "cconv" "\
;;;***
\f
-;;;### (autoloads nil "cedet" "cedet/cedet.el" (20983 37555 279226
-;;;;;; 0))
+;;;### (autoloads nil "cedet" "cedet/cedet.el" (22086 11929 542062
+;;;;;; 731000))
;;; Generated autoloads from cedet/cedet.el
(push (purecopy '(cedet 2 0)) package--builtin-versions)
;;;***
\f
-;;;### (autoloads nil "cfengine" "progmodes/cfengine.el" (21128 42425
-;;;;;; 434886 0))
+;;;### (autoloads nil "cfengine" "progmodes/cfengine.el" (22086 11930
+;;;;;; 154062 731000))
;;; Generated autoloads from progmodes/cfengine.el
-(push (purecopy '(cfengine 1 3)) package--builtin-versions)
+(push (purecopy '(cfengine 1 4)) package--builtin-versions)
(autoload 'cfengine3-mode "cfengine" "\
Major mode for editing CFEngine3 input.
\(fn)" t nil)
(autoload 'cfengine-auto-mode "cfengine" "\
-Choose between `cfengine2-mode' and `cfengine3-mode' depending
-on the buffer contents
+Choose `cfengine2-mode' or `cfengine3-mode' by buffer contents.
-\(fn)" nil nil)
+\(fn)" t nil)
+
+;;;***
+\f
+;;;### (autoloads nil "character-fold" "character-fold.el" (22109
+;;;;;; 36809 195889 179000))
+;;; Generated autoloads from character-fold.el
+
+(autoload 'character-fold-to-regexp "character-fold" "\
+Return a regexp matching anything that character-folds into STRING.
+Any character in STRING that has an entry in
+`character-fold-table' is replaced with that entry (which is a
+regexp) and other characters are `regexp-quote'd.
+
+If the resulting regexp would be too long for Emacs to handle,
+just return the result of calling `regexp-quote' on STRING.
+
+FROM is for internal use. It specifies an index in the STRING
+from which to start.
+
+\(fn STRING &optional LAX FROM)" nil nil)
;;;***
\f
-;;;### (autoloads nil "chart" "emacs-lisp/chart.el" (21049 14338
-;;;;;; 391345 0))
+;;;### (autoloads nil "chart" "emacs-lisp/chart.el" (22092 27717
+;;;;;; 628268 464000))
;;; Generated autoloads from emacs-lisp/chart.el
(push (purecopy '(chart 0 2)) package--builtin-versions)
;;;***
\f
;;;### (autoloads nil "check-declare" "emacs-lisp/check-declare.el"
-;;;;;; (20709 26818 907104 0))
+;;;;;; (22086 11929 650062 731000))
;;; Generated autoloads from emacs-lisp/check-declare.el
(autoload 'check-declare-file "check-declare" "\
;;;***
\f
-;;;### (autoloads nil "checkdoc" "emacs-lisp/checkdoc.el" (20996
-;;;;;; 49577 892030 0))
+;;;### (autoloads nil "checkdoc" "emacs-lisp/checkdoc.el" (22104
+;;;;;; 18893 193441 487000))
;;; Generated autoloads from emacs-lisp/checkdoc.el
(push (purecopy '(checkdoc 0 6 2)) package--builtin-versions)
(put 'checkdoc-force-docstrings-flag 'safe-local-variable #'booleanp)
(put 'checkdoc-symbol-words 'safe-local-variable #'checkdoc-list-of-strings-p)
(autoload 'checkdoc-list-of-strings-p "checkdoc" "\
-
+Return t when OBJ is a list of strings.
\(fn OBJ)" nil nil)
(put 'checkdoc-proper-noun-regexp 'safe-local-variable 'stringp)
\(fn &optional TAKE-NOTES)" t nil)
+(autoload 'checkdoc-file "checkdoc" "\
+Check FILE for document, comment, error style, and rogue spaces.
+
+\(fn FILE)" nil nil)
+
(autoload 'checkdoc-start "checkdoc" "\
Start scanning the current buffer for documentation string style errors.
Only documentation strings are checked.
\(fn &optional ARG)" t nil)
+(autoload 'checkdoc-package-keywords "checkdoc" "\
+Find package keywords that aren't in `finder-known-keywords'.
+
+\(fn)" t nil)
+
;;;***
\f
-;;;### (autoloads nil "china-util" "language/china-util.el" (20799
-;;;;;; 169 640767 0))
+;;;### (autoloads nil "china-util" "language/china-util.el" (22086
+;;;;;; 11929 890062 731000))
;;; Generated autoloads from language/china-util.el
(autoload 'decode-hz-region "china-util" "\
;;;***
\f
-;;;### (autoloads nil "chistory" "chistory.el" (21040 17194 398147
-;;;;;; 0))
+;;;### (autoloads nil "chistory" "chistory.el" (22086 11929 582062
+;;;;;; 731000))
;;; Generated autoloads from chistory.el
(autoload 'repeat-matching-complex-command "chistory" "\
;;;***
\f
-;;;### (autoloads nil "cl-indent" "emacs-lisp/cl-indent.el" (21112
-;;;;;; 20657 455367 0))
+;;;### (autoloads nil "cl-indent" "emacs-lisp/cl-indent.el" (22086
+;;;;;; 11929 654062 731000))
;;; Generated autoloads from emacs-lisp/cl-indent.el
(autoload 'common-lisp-indent-function "cl-indent" "\
of them. The first list element has an offset of 2, all the rest
have an offset of 2+1=3.
+If the current mode is actually `emacs-lisp-mode', look for a
+`common-lisp-indent-function-for-elisp' property before looking
+at `common-lisp-indent-function' and, if set, use its value
+instead.
+
\(fn INDENT-POINT STATE)" nil nil)
;;;***
\f
-;;;### (autoloads nil "cl-lib" "emacs-lisp/cl-lib.el" (20998 4934
-;;;;;; 952905 0))
+;;;### (autoloads nil "cl-lib" "emacs-lisp/cl-lib.el" (22086 11929
+;;;;;; 654062 731000))
;;; Generated autoloads from emacs-lisp/cl-lib.el
(push (purecopy '(cl-lib 1 0)) package--builtin-versions)
This variable is not used at present, but it is defined in hopes that
a future Emacs interpreter will be able to use it.")
-(define-error 'cl-assertion-failed (purecopy "Assertion failed"))
-
-(autoload 'cl--defsubst-expand "cl-macs")
-
-(put 'cl-defun 'doc-string-elt 3)
-
-(put 'cl-defmacro 'doc-string-elt 3)
-
-(put 'cl-defsubst 'doc-string-elt 3)
-
-(put 'cl-defstruct 'doc-string-elt 2)
-
;;;***
\f
-;;;### (autoloads nil "cmacexp" "progmodes/cmacexp.el" (21082 29482
-;;;;;; 330637 0))
+;;;### (autoloads nil "cmacexp" "progmodes/cmacexp.el" (22086 11930
+;;;;;; 158062 731000))
;;; Generated autoloads from progmodes/cmacexp.el
(autoload 'c-macro-expand "cmacexp" "\
;;;***
\f
-;;;### (autoloads nil "cmuscheme" "cmuscheme.el" (20932 61699 522706
-;;;;;; 0))
+;;;### (autoloads nil "cmuscheme" "cmuscheme.el" (22086 11929 582062
+;;;;;; 731000))
;;; Generated autoloads from cmuscheme.el
(autoload 'run-scheme "cmuscheme" "\
;;;***
\f
-;;;### (autoloads nil "color" "color.el" (20721 17977 14204 0))
+;;;### (autoloads nil "color" "color.el" (22086 11929 582062 731000))
;;; Generated autoloads from color.el
(autoload 'color-name-to-rgb "color" "\
;;;***
\f
-;;;### (autoloads nil "comint" "comint.el" (21145 51520 109004 0))
+;;;### (autoloads nil "comint" "comint.el" (22086 11929 586062 731000))
;;; Generated autoloads from comint.el
(defvar comint-output-filter-functions '(ansi-color-process-output comint-postoutput-scroll-to-bottom comint-watch-for-password-prompt) "\
\(fn PROGRAM)" t nil)
+(function-put 'comint-run 'interactive-only 'make-comint)
+
(defvar comint-file-name-prefix (purecopy "") "\
Prefix prepended to absolute file names taken from process input.
This is used by Comint's and shell's completion functions, and by shell's
;;;***
\f
-;;;### (autoloads nil "compare-w" "vc/compare-w.el" (20992 52525
-;;;;;; 458637 0))
+;;;### (autoloads nil "compare-w" "vc/compare-w.el" (22086 11930
+;;;;;; 370062 731000))
;;; Generated autoloads from vc/compare-w.el
(autoload 'compare-windows "compare-w" "\
-Compare text in current window with text in next window.
+Compare text in current window with text in another window.
+The option `compare-windows-get-window-function' defines how
+to get another window.
+
Compares the text starting at point in each window,
moving over text in each one as far as they match.
;;;***
\f
-;;;### (autoloads nil "compile" "progmodes/compile.el" (21131 18620
-;;;;;; 480626 0))
+;;;### (autoloads nil "compile" "progmodes/compile.el" (22099 26170
+;;;;;; 422017 16000))
;;; Generated autoloads from progmodes/compile.el
(defvar compilation-mode-hook nil "\
Sometimes it is useful for files to supply local values for this variable.
You might also use mode hooks to specify it in certain modes, like this:
- (add-hook 'c-mode-hook
+ (add-hook \\='c-mode-hook
(lambda ()
(unless (or (file-exists-p \"makefile\")
(file-exists-p \"Makefile\"))
- (set (make-local-variable 'compile-command)
+ (set (make-local-variable \\='compile-command)
(concat \"make -k \"
(if buffer-file-name
(shell-quote-argument
`compilation-shell-minor-mode'.
Interactively, prompts for the command if the variable
-`compilation-read-command' is non-nil; otherwise uses`compile-command'.
+`compilation-read-command' is non-nil; otherwise uses `compile-command'.
With prefix arg, always prompts.
Additionally, with universal prefix arg, compilation buffer will be in
comint mode, i.e. interactive.
;;;***
\f
-;;;### (autoloads nil "completion" "completion.el" (20999 25770 522517
-;;;;;; 0))
+;;;### (autoloads nil "completion" "completion.el" (22086 11929 586062
+;;;;;; 731000))
;;; Generated autoloads from completion.el
(defvar dynamic-completion-mode nil "\
;;;***
\f
-;;;### (autoloads nil "conf-mode" "textmodes/conf-mode.el" (20791
-;;;;;; 9657 561026 0))
+;;;### (autoloads nil "conf-mode" "textmodes/conf-mode.el" (22086
+;;;;;; 11930 314062 731000))
;;; Generated autoloads from textmodes/conf-mode.el
(autoload 'conf-mode "conf-mode" "\
;;;***
\f
-;;;### (autoloads nil "cookie1" "play/cookie1.el" (20932 61824 204300
-;;;;;; 748000))
+;;;### (autoloads nil "cookie1" "play/cookie1.el" (22086 11930 122062
+;;;;;; 731000))
;;; Generated autoloads from play/cookie1.el
(autoload 'cookie "cookie1" "\
;;;***
\f
-;;;### (autoloads nil "copyright" "emacs-lisp/copyright.el" (21041
-;;;;;; 38058 75002 0))
+;;;### (autoloads nil "copyright" "emacs-lisp/copyright.el" (22086
+;;;;;; 11929 662062 731000))
;;; Generated autoloads from emacs-lisp/copyright.el
(put 'copyright-at-end-flag 'safe-local-variable 'booleanp)
(put 'copyright-names-regexp 'safe-local-variable 'stringp)
;;;***
\f
-;;;### (autoloads nil "cperl-mode" "progmodes/cperl-mode.el" (21111
-;;;;;; 33338 390427 0))
+;;;### (autoloads nil "cperl-mode" "progmodes/cperl-mode.el" (22086
+;;;;;; 11930 162062 731000))
;;; Generated autoloads from progmodes/cperl-mode.el
(put 'cperl-indent-level 'safe-local-variable 'integerp)
(put 'cperl-brace-offset 'safe-local-variable 'integerp)
;;;***
\f
-;;;### (autoloads nil "cpp" "progmodes/cpp.el" (20874 65006 672942
-;;;;;; 217000))
+;;;### (autoloads nil "cpp" "progmodes/cpp.el" (22092 27718 148268
+;;;;;; 464000))
;;; Generated autoloads from progmodes/cpp.el
(autoload 'cpp-highlight-buffer "cpp" "\
;;;***
\f
-;;;### (autoloads nil "crisp" "emulation/crisp.el" (20709 26818 907104
-;;;;;; 0))
-;;; Generated autoloads from emulation/crisp.el
-
-(defvar crisp-mode nil "\
-Track status of CRiSP emulation mode.
-A value of nil means CRiSP mode is not enabled. A value of t
-indicates CRiSP mode is enabled.
-
-Setting this variable directly does not take effect;
-use either M-x customize or the function `crisp-mode'.")
-
-(custom-autoload 'crisp-mode "crisp" nil)
-
-(autoload 'crisp-mode "crisp" "\
-Toggle CRiSP/Brief emulation (CRiSP mode).
-With a prefix argument ARG, enable CRiSP mode if ARG is positive,
-and disable it otherwise. If called from Lisp, enable the mode
-if ARG is omitted or nil.
-
-\(fn &optional ARG)" t nil)
-
-(defalias 'brief-mode 'crisp-mode)
-
-;;;***
-\f
-;;;### (autoloads nil "crm" "emacs-lisp/crm.el" (21034 64808 616539
-;;;;;; 0))
+;;;### (autoloads nil "crm" "emacs-lisp/crm.el" (22086 11929 662062
+;;;;;; 731000))
;;; Generated autoloads from emacs-lisp/crm.el
(autoload 'completing-read-multiple "crm" "\
Read multiple strings in the minibuffer, with completion.
-By using this functionality, a user may specify multiple strings at a
-single prompt, optionally using completion.
+The arguments are the same as those of `completing-read'.
+\\<crm-local-completion-map>
+Input multiple strings by separating each one with a string that
+matches the regexp `crm-separator'. For example, if the separator
+regexp is \",\", entering \"alice,bob,eve\" specifies the strings
+\"alice\", \"bob\", and \"eve\".
-Multiple strings are specified by separating each of the strings with
-a prespecified separator regexp. For example, if the separator
-regexp is \",\", the strings 'alice', 'bob', and 'eve' would be
-specified as 'alice,bob,eve'.
-
-The default value for the separator regexp is the value of
-`crm-default-separator' (comma). The separator regexp may be
-changed by modifying the value of `crm-separator'.
-
-Contiguous strings of non-separator-characters are referred to as
-'elements'. In the aforementioned example, the elements are: 'alice',
-'bob', and 'eve'.
+We refer to contiguous strings of non-separator-characters as
+\"elements\". In this example there are three elements.
Completion is available on a per-element basis. For example, if the
-contents of the minibuffer are 'alice,bob,eve' and point is between
-'l' and 'i', pressing TAB operates on the element 'alice'.
+contents of the minibuffer are \"alice,bob,eve\" and point is between
+\"l\" and \"i\", pressing \\[minibuffer-complete] operates on the element \"alice\".
-The return value of this function is a list of the read strings
+This function returns a list of the strings that were read,
with empty strings removed.
-See the documentation for `completing-read' for details on the arguments:
-PROMPT, TABLE, PREDICATE, REQUIRE-MATCH, INITIAL-INPUT, HIST, DEF, and
-INHERIT-INPUT-METHOD.
-
\(fn PROMPT TABLE &optional PREDICATE REQUIRE-MATCH INITIAL-INPUT HIST DEF INHERIT-INPUT-METHOD)" nil nil)
;;;***
\f
-;;;### (autoloads nil "css-mode" "textmodes/css-mode.el" (21075 56234
-;;;;;; 349623 0))
+;;;### (autoloads nil "css-mode" "textmodes/css-mode.el" (22086 11930
+;;;;;; 314062 731000))
;;; Generated autoloads from textmodes/css-mode.el
(autoload 'css-mode "css-mode" "\
Major mode to edit Cascading Style Sheets.
+\(fn)" t nil)
+ (add-to-list 'auto-mode-alist '("\\.scss\\'" . scss-mode))
+
+(autoload 'scss-mode "css-mode" "\
+Major mode to edit \"Sassy CSS\" files.
+
\(fn)" t nil)
;;;***
\f
-;;;### (autoloads nil "cua-base" "emulation/cua-base.el" (20992 52525
-;;;;;; 458637 0))
+;;;### (autoloads nil "cua-base" "emulation/cua-base.el" (22086 11929
+;;;;;; 690062 731000))
;;; Generated autoloads from emulation/cua-base.el
(defvar cua-mode nil "\
CUA bindings, or `cua-prefix-override-inhibit-delay' to change
the prefix fallback behavior.
-CUA mode manages Transient Mark mode internally. Trying to disable
-Transient Mark mode while CUA mode is enabled does not work; if you
-only want to highlight the region when it is selected using a
-shifted movement key, set `cua-highlight-region-shift-only'.
-
\(fn &optional ARG)" t nil)
(autoload 'cua-selection-mode "cua-base" "\
;;;***
\f
-;;;### (autoloads nil "cus-edit" "cus-edit.el" (21024 28968 738399
-;;;;;; 0))
+;;;### (autoloads nil "cua-rect" "emulation/cua-rect.el" (22087 9807
+;;;;;; 178279 951000))
+;;; Generated autoloads from emulation/cua-rect.el
+
+(autoload 'cua-rectangle-mark-mode "cua-rect" "\
+Toggle the region as rectangular.
+Activates the region if needed. Only lasts until the region is deactivated.
+
+\(fn &optional ARG)" t nil)
+
+;;;***
+\f
+;;;### (autoloads nil "cursor-sensor" "emacs-lisp/cursor-sensor.el"
+;;;;;; (22086 11929 662062 731000))
+;;; Generated autoloads from emacs-lisp/cursor-sensor.el
+
+(autoload 'cursor-intangible-mode "cursor-sensor" "\
+Keep cursor outside of any `cursor-intangible' text property.
+
+\(fn &optional ARG)" t nil)
+
+(autoload 'cursor-sensor-mode "cursor-sensor" "\
+Handle the `cursor-sensor-functions' text property.
+This property should hold a list of functions which react to the motion
+of the cursor. They're called with three arguments (WINDOW OLDPOS DIR)
+where WINDOW is the affected window, OLDPOS is the last known position of
+the cursor and DIR can be `left' or `entered' depending on whether the cursor is
+entering the area covered by the text-property property or leaving it.
+
+\(fn &optional ARG)" t nil)
+
+;;;***
+\f
+;;;### (autoloads nil "cus-edit" "cus-edit.el" (22086 11929 590062
+;;;;;; 731000))
;;; Generated autoloads from cus-edit.el
(defvar custom-browse-sort-alphabetically nil "\
For example, the MH-E package updates this alist as follows:
- (add-to-list 'customize-package-emacs-version-alist
- '(MH-E (\"6.0\" . \"22.1\") (\"6.1\" . \"22.1\")
+ (add-to-list \\='customize-package-emacs-version-alist
+ \\='(MH-E (\"6.0\" . \"22.1\") (\"6.1\" . \"22.1\")
(\"7.0\" . \"22.1\") (\"7.1\" . \"22.1\")
(\"7.2\" . \"22.1\") (\"7.3\" . \"22.1\")
(\"7.4\" . \"22.1\") (\"8.0\" . \"22.1\")))
\(fn REGEXP)" t nil)
+(autoload 'custom-prompt-customize-unsaved-options "cus-edit" "\
+Prompt user to customize any unsaved customization options.
+Return non-nil if user chooses to customize, for use in
+`kill-emacs-query-functions'.
+
+\(fn)" nil nil)
+
(autoload 'custom-buffer-create "cus-edit" "\
Create a buffer containing OPTIONS.
Optional NAME is the name of the buffer.
OPTIONS should be an alist of the form ((SYMBOL WIDGET)...), where
SYMBOL is a customization option, and WIDGET is a widget for editing
that option.
+DESCRIPTION is unused.
\(fn OPTIONS &optional NAME DESCRIPTION)" nil nil)
;;;***
\f
-;;;### (autoloads nil "cus-theme" "cus-theme.el" (20841 12463 538770
-;;;;;; 0))
+;;;### (autoloads nil "cus-theme" "cus-theme.el" (22086 11929 590062
+;;;;;; 731000))
;;; Generated autoloads from cus-theme.el
(autoload 'customize-create-theme "cus-theme" "\
;;;***
\f
-;;;### (autoloads nil "cvs-status" "vc/cvs-status.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "cvs-status" "vc/cvs-status.el" (22086 11930
+;;;;;; 370062 731000))
;;; Generated autoloads from vc/cvs-status.el
(autoload 'cvs-status-mode "cvs-status" "\
;;;***
\f
-;;;### (autoloads nil "cwarn" "progmodes/cwarn.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "cwarn" "progmodes/cwarn.el" (22089 51528 280929
+;;;;;; 316000))
;;; Generated autoloads from progmodes/cwarn.el
(push (purecopy '(cwarn 1 3 1)) package--builtin-versions)
;;;***
\f
-;;;### (autoloads nil "cyril-util" "language/cyril-util.el" (20826
-;;;;;; 45095 436233 0))
+;;;### (autoloads nil "cyril-util" "language/cyril-util.el" (22086
+;;;;;; 11929 890062 731000))
;;; Generated autoloads from language/cyril-util.el
(autoload 'cyrillic-encode-koi8-r-char "cyril-util" "\
;;;***
\f
-;;;### (autoloads nil "dabbrev" "dabbrev.el" (20992 52525 458637
-;;;;;; 0))
+;;;### (autoloads nil "dabbrev" "dabbrev.el" (22086 11929 590062
+;;;;;; 731000))
;;; Generated autoloads from dabbrev.el
(put 'dabbrev-case-fold-search 'risky-local-variable t)
(put 'dabbrev-case-replace 'risky-local-variable t)
;;;***
\f
-;;;### (autoloads nil "data-debug" "cedet/data-debug.el" (21040 17194
-;;;;;; 398147 0))
+;;;### (autoloads nil "data-debug" "cedet/data-debug.el" (22086 11929
+;;;;;; 542062 731000))
;;; Generated autoloads from cedet/data-debug.el
(autoload 'data-debug-new-buffer "data-debug" "\
;;;***
\f
-;;;### (autoloads nil "dbus" "net/dbus.el" (21032 23080 765139 0))
+;;;### (autoloads nil "dbus" "net/dbus.el" (22086 11929 990062 731000))
;;; Generated autoloads from net/dbus.el
(autoload 'dbus-handle-event "dbus" "\
;;;***
\f
-;;;### (autoloads nil "dcl-mode" "progmodes/dcl-mode.el" (20763 30266
-;;;;;; 231060 0))
+;;;### (autoloads nil "dcl-mode" "progmodes/dcl-mode.el" (22086 11930
+;;;;;; 162062 731000))
;;; Generated autoloads from progmodes/dcl-mode.el
(autoload 'dcl-mode "dcl-mode" "\
;;;***
\f
-;;;### (autoloads nil "debug" "emacs-lisp/debug.el" (21145 51520
-;;;;;; 109004 0))
+;;;### (autoloads nil "debug" "emacs-lisp/debug.el" (22086 11929
+;;;;;; 662062 731000))
;;; Generated autoloads from emacs-lisp/debug.el
(setq debugger 'debug)
;;;***
\f
-;;;### (autoloads nil "decipher" "play/decipher.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "decipher" "play/decipher.el" (22086 11930
+;;;;;; 126062 731000))
;;; Generated autoloads from play/decipher.el
(autoload 'decipher "decipher" "\
;;;***
\f
-;;;### (autoloads nil "delim-col" "delim-col.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "delim-col" "delim-col.el" (22086 11929 590062
+;;;;;; 731000))
;;; Generated autoloads from delim-col.el
(push (purecopy '(delim-col 2 1)) package--builtin-versions)
;;;***
\f
-;;;### (autoloads nil "delsel" "delsel.el" (21104 56491 538513 0))
+;;;### (autoloads nil "delsel" "delsel.el" (22086 11929 594062 731000))
;;; Generated autoloads from delsel.el
(defalias 'pending-delete-mode 'delete-selection-mode)
is positive, and disable it otherwise. If called from Lisp,
enable the mode if ARG is omitted or nil.
-When Delete Selection mode is enabled, Transient Mark mode is also
-enabled and typed text replaces the selection if the selection is
-active. Otherwise, typed text is just inserted at point regardless of
-any selection.
+When Delete Selection mode is enabled, typed text replaces the selection
+if the selection is active. Otherwise, typed text is just inserted at
+point regardless of any selection.
\(fn &optional ARG)" t nil)
;;;***
\f
-;;;### (autoloads nil "derived" "emacs-lisp/derived.el" (20900 33838
-;;;;;; 319219 0))
+;;;### (autoloads nil "derived" "emacs-lisp/derived.el" (22086 11929
+;;;;;; 666062 731000))
;;; Generated autoloads from emacs-lisp/derived.el
(autoload 'define-derived-mode "derived" "\
\(fn CHILD PARENT NAME &optional DOCSTRING &rest BODY)" nil t)
-(put 'define-derived-mode 'doc-string-elt '4)
+(function-put 'define-derived-mode 'doc-string-elt '4)
+
+(function-put 'define-derived-mode 'lisp-indent-function '3)
(autoload 'derived-mode-init-mode-variables "derived" "\
Initialize variables for a new MODE.
;;;***
\f
-;;;### (autoloads nil "descr-text" "descr-text.el" (21024 28968 738399
-;;;;;; 0))
+;;;### (autoloads nil "descr-text" "descr-text.el" (22086 11929 594062
+;;;;;; 731000))
;;; Generated autoloads from descr-text.el
(autoload 'describe-text-properties "descr-text" "\
\(fn POS &optional BUFFER)" t nil)
+(autoload 'describe-char-eldoc "descr-text" "\
+Return a description of character at point for use by ElDoc mode.
+
+Return nil if character at point is a printable ASCII
+character (i.e. codepoint between 32 and 127 inclusively).
+Otherwise return a description formatted by
+`describe-char-eldoc--format' function taking into account value
+of `eldoc-echo-area-use-multiline-p' variable and width of
+minibuffer window for width limit.
+
+This function is meant to be used as a value of
+`eldoc-documentation-function' variable.
+
+\(fn)" nil nil)
+
;;;***
\f
-;;;### (autoloads nil "desktop" "desktop.el" (21082 29482 330637
-;;;;;; 0))
+;;;### (autoloads nil "desktop" "desktop.el" (22092 27717 592268
+;;;;;; 464000))
;;; Generated autoloads from desktop.el
(defvar desktop-save-mode nil "\
Non-nil if Desktop-Save mode is enabled.
-See the command `desktop-save-mode' for a description of this minor mode.")
+See the command `desktop-save-mode' for a description of this minor mode.
+Setting this variable directly does not take effect;
+either customize it (see the info node `Easy Customization')
+or call the function `desktop-save-mode'.")
(custom-autoload 'desktop-save-mode "desktop" nil)
(autoload 'desktop-save-mode "desktop" "\
Toggle desktop saving (Desktop Save mode).
-With a prefix argument ARG, enable Desktop Save mode if ARG is
-positive, and disable it otherwise. If called from Lisp, enable
-the mode if ARG is omitted or nil.
+With a prefix argument ARG, enable Desktop Save mode if ARG is positive,
+and disable it otherwise. If called from Lisp, enable the mode if ARG
+is omitted or nil.
+
+When Desktop Save mode is enabled, the state of Emacs is saved from
+one session to another. In particular, Emacs will save the desktop when
+it exits (this may prompt you; see the option `desktop-save'). The next
+time Emacs starts, if this mode is active it will restore the desktop.
+
+To manually save the desktop at any time, use the command `\\[desktop-save]'.
+To load it, use `\\[desktop-read]'.
+
+Once a desktop file exists, Emacs will auto-save it according to the
+option `desktop-auto-save-timeout'.
-If Desktop Save mode is enabled, the state of Emacs is saved from
-one session to another. See variable `desktop-save' and function
-`desktop-read' for details.
+To see all the options you can set, browse the `desktop' customization group.
+
+For further details, see info node `(emacs)Saving Emacs Sessions'.
\(fn &optional ARG)" t nil)
Furthermore, they may use the following variables:
- desktop-file-version
- desktop-buffer-major-mode
- desktop-buffer-minor-modes
- desktop-buffer-point
- desktop-buffer-mark
- desktop-buffer-read-only
- desktop-buffer-locals
+ `desktop-file-version'
+ `desktop-buffer-major-mode'
+ `desktop-buffer-minor-modes'
+ `desktop-buffer-point'
+ `desktop-buffer-mark'
+ `desktop-buffer-read-only'
+ `desktop-buffer-locals'
If a handler returns a buffer, then the saved mode settings
and variable values for that buffer are copied into it.
(defun foo-restore-desktop-buffer
...
- (add-to-list 'desktop-buffer-mode-handlers
- '(foo-mode . foo-restore-desktop-buffer))
+ (add-to-list \\='desktop-buffer-mode-handlers
+ \\='(foo-mode . foo-restore-desktop-buffer))
-Furthermore the major mode function must be autoloaded.")
+The major mode function must either be autoloaded, or of the form
+\"foobar-mode\" and defined in library \"foobar\", so that desktop
+can guess how to load the mode's definition.")
(put 'desktop-buffer-mode-handlers 'risky-local-variable t)
Furthermore, they may use the following variables:
- desktop-file-version
- desktop-buffer-file-name
- desktop-buffer-name
- desktop-buffer-major-mode
- desktop-buffer-minor-modes
- desktop-buffer-point
- desktop-buffer-mark
- desktop-buffer-read-only
- desktop-buffer-misc
+ `desktop-file-version'
+ `desktop-buffer-file-name'
+ `desktop-buffer-name'
+ `desktop-buffer-major-mode'
+ `desktop-buffer-minor-modes'
+ `desktop-buffer-point'
+ `desktop-buffer-mark'
+ `desktop-buffer-read-only'
+ `desktop-buffer-misc'
When a handler is called, the buffer has been created and the major mode has
been set, but local variables listed in desktop-buffer-locals has not yet been
(defun foo-desktop-restore
...
- (add-to-list 'desktop-minor-mode-handlers
- '(foo-mode . foo-desktop-restore))
+ (add-to-list \\='desktop-minor-mode-handlers
+ \\='(foo-mode . foo-desktop-restore))
-Furthermore the minor mode function must be autoloaded.
+The minor mode function must either be autoloaded, or of the form
+\"foobar-mode\" and defined in library \"foobar\", so that desktop
+can guess how to load the mode's definition.
See also `desktop-minor-mode-table'.")
Save the desktop in a desktop file.
Parameter DIRNAME specifies where to save the desktop file.
Optional parameter RELEASE says whether we're done with this desktop.
-If AUTO-SAVE is non-nil, compare the saved contents to the one last saved,
-and don't save the buffer if they are the same.
+If ONLY-IF-CHANGED is non-nil, compare the current desktop information
+to that in the desktop file, and if the desktop information has not
+changed since it was last saved then do not rewrite the file.
-\(fn DIRNAME &optional RELEASE AUTO-SAVE)" t nil)
+\(fn DIRNAME &optional RELEASE ONLY-IF-CHANGED)" t nil)
(autoload 'desktop-remove "desktop" "\
Delete desktop file in `desktop-dirname'.
;;;***
\f
-;;;### (autoloads nil "deuglify" "gnus/deuglify.el" (20791 9657 561026
-;;;;;; 0))
+;;;### (autoloads nil "deuglify" "gnus/deuglify.el" (22086 11929
+;;;;;; 774062 731000))
;;; Generated autoloads from gnus/deuglify.el
(autoload 'gnus-article-outlook-unwrap-lines "deuglify" "\
;;;***
\f
-;;;### (autoloads nil "diary-lib" "calendar/diary-lib.el" (20992
-;;;;;; 52525 458637 0))
+;;;### (autoloads nil "diary-lib" "calendar/diary-lib.el" (22092
+;;;;;; 27717 544268 464000))
;;; Generated autoloads from calendar/diary-lib.el
(autoload 'diary "diary-lib" "\
\(setq diary-mail-days 3
diary-file \"/path/to/diary.file\"
- calendar-date-style 'european
+ calendar-date-style \\='european
diary-mail-addr \"user@host.name\")
\(diary-mail-entries)
;;;***
\f
-;;;### (autoloads nil "diff" "vc/diff.el" (20760 54070 584283 0))
+;;;### (autoloads nil "diff" "vc/diff.el" (22086 11930 370062 731000))
;;; Generated autoloads from vc/diff.el
-(defvar diff-switches (purecopy "-c") "\
+(defvar diff-switches (purecopy "-u") "\
A string or list of strings specifying switches to be passed to diff.")
(custom-autoload 'diff-switches "diff" t)
;;;***
\f
-;;;### (autoloads nil "diff-mode" "vc/diff-mode.el" (21136 36544
-;;;;;; 158478 0))
+;;;### (autoloads nil "diff-mode" "vc/diff-mode.el" (22087 9807 430279
+;;;;;; 951000))
;;; Generated autoloads from vc/diff-mode.el
(autoload 'diff-mode "diff-mode" "\
;;;***
\f
-;;;### (autoloads nil "dig" "net/dig.el" (20709 26818 907104 0))
+;;;### (autoloads nil "dig" "net/dig.el" (22086 11929 990062 731000))
;;; Generated autoloads from net/dig.el
(autoload 'dig "dig" "\
;;;***
\f
-;;;### (autoloads nil "dired" "dired.el" (21105 26139 752484 0))
+;;;### (autoloads nil "dired" "dired.el" (22086 11929 598062 731000))
;;; Generated autoloads from dired.el
(defvar dired-listing-switches (purecopy "-al") "\
\"Edit\" directory DIRNAME--delete, rename, print, etc. some files in it.
Optional second argument SWITCHES specifies the `ls' options used.
\(Interactively, use a prefix argument to be able to specify SWITCHES.)
-Dired displays a list of files in DIRNAME (which may also have
-shell wildcards appended to select certain files). If DIRNAME is a cons,
-its first element is taken as the directory name and the rest as an explicit
-list of files to make directory entries for.
+
+If DIRNAME is a string, Dired displays a list of files in DIRNAME (which
+may also have shell wildcards appended to select certain files).
+
+If DIRNAME is a cons, its first element is taken as the directory name
+and the rest as an explicit list of files to make directory entries for.
+In this case, SWITCHES are applied to each of the files separately, and
+therefore switches that control the order of the files in the produced
+listing have no effect.
+
\\<dired-mode-map>You can flag files for deletion with \\[dired-flag-file-deletion] and then
delete them by typing \\[dired-do-flagged-delete].
Type \\[describe-mode] after entering Dired for more info.
to see why something went wrong.
Type \\[dired-unmark] to Unmark a file or all files of an inserted subdirectory.
Type \\[dired-unmark-backward] to back up one line and unmark or unflag.
-Type \\[dired-do-flagged-delete] to delete (eXecute) the files flagged `D'.
+Type \\[dired-do-flagged-delete] to delete (eXpunge) the files flagged `D'.
Type \\[dired-find-file] to Find the current line's file
(or dired it in another buffer, if it is a directory).
Type \\[dired-find-file-other-window] to find file or Dired directory in Other window.
\(fn &optional DIRNAME SWITCHES)" nil nil)
(put 'dired-find-alternate-file 'disabled t)
-(autoload 'dired-hide-details-mode "dired" "\
-Hide details in Dired mode.
-
-\(fn &optional ARG)" t nil)
-
;;;***
\f
-;;;### (autoloads nil "dirtrack" "dirtrack.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "dirtrack" "dirtrack.el" (22086 11929 598062
+;;;;;; 731000))
;;; Generated autoloads from dirtrack.el
(autoload 'dirtrack-mode "dirtrack" "\
;;;***
\f
-;;;### (autoloads nil "disass" "emacs-lisp/disass.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "disass" "emacs-lisp/disass.el" (22086 11929
+;;;;;; 666062 731000))
;;; Generated autoloads from emacs-lisp/disass.el
(autoload 'disassemble "disass" "\
;;;***
\f
-;;;### (autoloads nil "disp-table" "disp-table.el" (20992 52525 458637
-;;;;;; 0))
+;;;### (autoloads nil "disp-table" "disp-table.el" (22086 11929 598062
+;;;;;; 731000))
;;; Generated autoloads from disp-table.el
(autoload 'make-display-table "disp-table" "\
;;;***
\f
-;;;### (autoloads nil "dissociate" "play/dissociate.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "dissociate" "play/dissociate.el" (22086 11930
+;;;;;; 126062 731000))
;;; Generated autoloads from play/dissociate.el
(autoload 'dissociated-press "dissociate" "\
;;;***
\f
-;;;### (autoloads nil "dnd" "dnd.el" (20709 26818 907104 0))
+;;;### (autoloads nil "dnd" "dnd.el" (22086 11929 598062 731000))
;;; Generated autoloads from dnd.el
(defvar dnd-protocol-alist `((,(purecopy "^file:///") . dnd-open-local-file) (,(purecopy "^file://") . dnd-open-file) (,(purecopy "^file:") . dnd-open-local-file) (,(purecopy "^\\(https?\\|ftp\\|file\\|nfs\\)://") . dnd-open-file)) "\
;;;***
\f
-;;;### (autoloads nil "dns-mode" "textmodes/dns-mode.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "dns-mode" "textmodes/dns-mode.el" (22086 11930
+;;;;;; 314062 731000))
;;; Generated autoloads from textmodes/dns-mode.el
(autoload 'dns-mode "dns-mode" "\
;;;***
\f
-;;;### (autoloads nil "doc-view" "doc-view.el" (21144 30651 337793
-;;;;;; 0))
+;;;### (autoloads nil "doc-view" "doc-view.el" (22086 11929 598062
+;;;;;; 731000))
;;; Generated autoloads from doc-view.el
(autoload 'doc-view-mode-p "doc-view" "\
;;;***
\f
-;;;### (autoloads nil "doctor" "play/doctor.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "doctor" "play/doctor.el" (22086 11930 126062
+;;;;;; 731000))
;;; Generated autoloads from play/doctor.el
(autoload 'doctor "doctor" "\
;;;***
\f
-;;;### (autoloads nil "double" "double.el" (20709 26818 907104 0))
+;;;### (autoloads nil "double" "double.el" (22086 11929 602062 731000))
;;; Generated autoloads from double.el
(autoload 'double-mode "double" "\
;;;***
\f
-;;;### (autoloads nil "dunnet" "play/dunnet.el" (20900 33838 319219
-;;;;;; 0))
+;;;### (autoloads nil "dunnet" "play/dunnet.el" (22093 48588 576393
+;;;;;; 539000))
;;; Generated autoloads from play/dunnet.el
-(push (purecopy '(dunnet 2 1)) package--builtin-versions)
+(push (purecopy '(dunnet 2 2)) package--builtin-versions)
(autoload 'dunnet "dunnet" "\
Switch to *dungeon* buffer and start game.
;;;***
\f
-;;;### (autoloads nil "easy-mmode" "emacs-lisp/easy-mmode.el" (20992
-;;;;;; 52525 458637 0))
+;;;### (autoloads nil "easy-mmode" "emacs-lisp/easy-mmode.el" (22092
+;;;;;; 27717 632268 464000))
;;; Generated autoloads from emacs-lisp/easy-mmode.el
(defalias 'easy-mmode-define-minor-mode 'define-minor-mode)
BODY contains code to execute each time the mode is enabled or disabled.
It is executed after toggling the mode, and before running MODE-hook.
Before the actual body code, you can write keyword arguments, i.e.
- alternating keywords and values. These following special keywords
- are supported (other keywords are passed to `defcustom' if the minor
- mode is global):
+ alternating keywords and values. If you provide BODY, then you must
+ provide (even if just nil) INIT-VALUE, LIGHTER, and KEYMAP, or provide
+ at least one keyword argument, or both; otherwise, BODY would be
+ misinterpreted as the first omitted argument. The following special
+ keywords are supported (other keywords are passed to `defcustom' if
+ the minor mode is global):
:group GROUP Custom group name to use in all generated `defcustom' forms.
Defaults to MODE without the possible trailing \"-mode\".
For example, you could write
(define-minor-mode foo-mode \"If enabled, foo on you!\"
- :lighter \" Foo\" :require 'foo :global t :group 'hassle :version \"27.5\"
+ :lighter \" Foo\" :require \\='foo :global t :group \\='hassle :version \"27.5\"
...BODY CODE...)
\(fn MODE DOC &optional INIT-VALUE LIGHTER KEYMAP &rest BODY)" nil t)
-(put 'define-minor-mode 'doc-string-elt '2)
+(function-put 'define-minor-mode 'doc-string-elt '2)
+
+(function-put 'define-minor-mode 'lisp-indent-function '1)
(defalias 'easy-mmode-define-global-mode 'define-globalized-minor-mode)
\(fn GLOBAL-MODE MODE TURN-ON &rest KEYS)" nil t)
-(put 'define-globalized-minor-mode 'doc-string-elt '2)
+(function-put 'define-globalized-minor-mode 'doc-string-elt '2)
(autoload 'easy-mmode-define-keymap "easy-mmode" "\
Return a keymap built from bindings BS.
:inherit Parent keymap.
:group Ignored.
:suppress Non-nil to call `suppress-keymap' on keymap,
- 'nodigits to suppress digits as prefix arguments.
+ `nodigits' to suppress digits as prefix arguments.
\(fn BS &optional NAME M ARGS)" nil nil)
;;;***
\f
-;;;### (autoloads nil "easymenu" "emacs-lisp/easymenu.el" (21074
-;;;;;; 35375 473679 0))
+;;;### (autoloads nil "easymenu" "emacs-lisp/easymenu.el" (22086
+;;;;;; 11929 666062 731000))
;;; Generated autoloads from emacs-lisp/easymenu.el
(autoload 'easy-menu-define "easymenu" "\
\(fn SYMBOL MAPS DOC MENU)" nil t)
-(put 'easy-menu-define 'lisp-indent-function 'defun)
+(function-put 'easy-menu-define 'lisp-indent-function 'defun)
(autoload 'easy-menu-do-define "easymenu" "\
;;;***
\f
-;;;### (autoloads nil "ebnf2ps" "progmodes/ebnf2ps.el" (21093 51745
-;;;;;; 752738 587000))
+;;;### (autoloads nil "ebnf2ps" "progmodes/ebnf2ps.el" (22086 11930
+;;;;;; 166062 731000))
;;; Generated autoloads from progmodes/ebnf2ps.el
(push (purecopy '(ebnf2ps 4 4)) package--builtin-versions)
;;;***
\f
-;;;### (autoloads nil "ebrowse" "progmodes/ebrowse.el" (20992 52525
-;;;;;; 458637 0))
+;;;### (autoloads nil "ebrowse" "progmodes/ebrowse.el" (22086 11930
+;;;;;; 170062 731000))
;;; Generated autoloads from progmodes/ebrowse.el
(autoload 'ebrowse-tree-mode "ebrowse" "\
;;;***
\f
-;;;### (autoloads nil "ebuff-menu" "ebuff-menu.el" (20992 52525 458637
-;;;;;; 0))
+;;;### (autoloads nil "ebuff-menu" "ebuff-menu.el" (22086 11929 602062
+;;;;;; 731000))
;;; Generated autoloads from ebuff-menu.el
(autoload 'electric-buffer-list "ebuff-menu" "\
;;;***
\f
-;;;### (autoloads nil "echistory" "echistory.el" (21040 46773 613700
-;;;;;; 854000))
+;;;### (autoloads nil "echistory" "echistory.el" (22086 11929 602062
+;;;;;; 731000))
;;; Generated autoloads from echistory.el
(autoload 'Electric-command-history-redo-expression "echistory" "\
;;;***
\f
-;;;### (autoloads nil "ecomplete" "gnus/ecomplete.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "ecomplete" "gnus/ecomplete.el" (22086 11929
+;;;;;; 774062 731000))
;;; Generated autoloads from gnus/ecomplete.el
(autoload 'ecomplete-setup "ecomplete" "\
;;;***
\f
-;;;### (autoloads nil "ede" "cedet/ede.el" (20908 27948 216644 0))
+;;;### (autoloads nil "ede" "cedet/ede.el" (22092 27717 556268 464000))
;;; Generated autoloads from cedet/ede.el
(push (purecopy '(ede 1 2)) package--builtin-versions)
;;;***
\f
-;;;### (autoloads nil "ede/dired" "cedet/ede/dired.el" (20709 26818
-;;;;;; 907104 0))
-;;; Generated autoloads from cedet/ede/dired.el
-(push (purecopy '(dired 0 4)) package--builtin-versions)
-
-;;;***
-\f
-;;;### (autoloads nil "ede/project-am" "cedet/ede/project-am.el"
-;;;;;; (20881 10343 547564 552000))
-;;; Generated autoloads from cedet/ede/project-am.el
-(push (purecopy '(project-am 0 0 3)) package--builtin-versions)
-
-;;;***
-\f
-;;;### (autoloads nil "edebug" "emacs-lisp/edebug.el" (20996 49577
-;;;;;; 892030 0))
+;;;### (autoloads nil "edebug" "emacs-lisp/edebug.el" (22086 11929
+;;;;;; 670062 731000))
;;; Generated autoloads from emacs-lisp/edebug.el
(defvar edebug-all-defs nil "\
You can use the command `edebug-all-defs' to toggle the value of this
variable. You may wish to make it local to each buffer with
-\(make-local-variable 'edebug-all-defs) in your
+\(make-local-variable \\='edebug-all-defs) in your
`emacs-lisp-mode-hook'.")
(custom-autoload 'edebug-all-defs "edebug" t)
;;;***
\f
-;;;### (autoloads nil "ediff" "vc/ediff.el" (21041 38058 75002 0))
+;;;### (autoloads nil "ediff" "vc/ediff.el" (22086 11930 378062 731000))
;;; Generated autoloads from vc/ediff.el
(push (purecopy '(ediff 2 81 4)) package--builtin-versions)
;;;***
\f
-;;;### (autoloads nil "ediff-help" "vc/ediff-help.el" (20992 52525
-;;;;;; 458637 0))
+;;;### (autoloads nil "ediff-help" "vc/ediff-help.el" (22086 11930
+;;;;;; 370062 731000))
;;; Generated autoloads from vc/ediff-help.el
(autoload 'ediff-customize "ediff-help" "\
;;;***
\f
-;;;### (autoloads nil "ediff-mult" "vc/ediff-mult.el" (21032 23080
-;;;;;; 765139 0))
+;;;### (autoloads nil "ediff-mult" "vc/ediff-mult.el" (22086 11930
+;;;;;; 374062 731000))
;;; Generated autoloads from vc/ediff-mult.el
(autoload 'ediff-show-registry "ediff-mult" "\
;;;***
\f
-;;;### (autoloads nil "ediff-util" "vc/ediff-util.el" (21032 23080
-;;;;;; 765139 0))
+;;;### (autoloads nil "ediff-util" "vc/ediff-util.el" (22086 11930
+;;;;;; 374062 731000))
;;; Generated autoloads from vc/ediff-util.el
(autoload 'ediff-toggle-multiframe "ediff-util" "\
;;;***
\f
-;;;### (autoloads nil "edmacro" "edmacro.el" (20964 20753 310858
-;;;;;; 446000))
+;;;### (autoloads nil "edmacro" "edmacro.el" (22086 11929 602062
+;;;;;; 731000))
;;; Generated autoloads from edmacro.el
(push (purecopy '(edmacro 2 1)) package--builtin-versions)
Edit a keyboard macro.
At the prompt, type any key sequence which is bound to a keyboard macro.
Or, type `C-x e' or RET to edit the last keyboard macro, `C-h l' to edit
-the last 300 keystrokes as a keyboard macro, or `M-x' to edit a macro by
+the last 300 keystrokes as a keyboard macro, or `\\[execute-extended-command]' to edit a macro by
its command name.
With a prefix argument, format the macro in a more concise way.
;;;***
\f
-;;;### (autoloads nil "edt" "emulation/edt.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "edt" "emulation/edt.el" (22086 11929 694062
+;;;;;; 731000))
;;; Generated autoloads from emulation/edt.el
(autoload 'edt-set-scroll-margins "edt" "\
;;;***
\f
-;;;### (autoloads nil "ehelp" "ehelp.el" (20992 52525 458637 0))
+;;;### (autoloads nil "ehelp" "ehelp.el" (22086 11929 602062 731000))
;;; Generated autoloads from ehelp.el
(autoload 'with-electric-help "ehelp" "\
;;;***
\f
-;;;### (autoloads nil "eieio" "emacs-lisp/eieio.el" (21051 23094
-;;;;;; 730130 282000))
+;;;### (autoloads nil "eieio" "emacs-lisp/eieio.el" (22086 11929
+;;;;;; 674062 731000))
;;; Generated autoloads from emacs-lisp/eieio.el
(push (purecopy '(eieio 1 4)) package--builtin-versions)
;;;***
\f
-;;;### (autoloads nil "eieio-core" "emacs-lisp/eieio-core.el" (20908
-;;;;;; 27948 216644 0))
+;;;### (autoloads nil "eieio-core" "emacs-lisp/eieio-core.el" (22086
+;;;;;; 11929 670062 731000))
;;; Generated autoloads from emacs-lisp/eieio-core.el
(push (purecopy '(eieio-core 1 4)) package--builtin-versions)
;;;***
\f
-;;;### (autoloads nil "eieio-custom" "emacs-lisp/eieio-custom.el"
-;;;;;; (20929 34089 117790 0))
-;;; Generated autoloads from emacs-lisp/eieio-custom.el
-
-(autoload 'customize-object "eieio-custom" "\
-Customize OBJ in a custom buffer.
-Optional argument GROUP is the sub-group of slots to display.
-
-\(fn OBJ &optional GROUP)" nil nil)
-
-;;;***
-\f
-;;;### (autoloads nil "eieio-opt" "emacs-lisp/eieio-opt.el" (20892
-;;;;;; 39729 858825 0))
-;;; Generated autoloads from emacs-lisp/eieio-opt.el
-
-(autoload 'eieio-browse "eieio-opt" "\
-Create an object browser window to show all objects.
-If optional ROOT-CLASS, then start with that, otherwise start with
-variable `eieio-default-superclass'.
-
-\(fn &optional ROOT-CLASS)" t nil)
-(defalias 'describe-class 'eieio-describe-class)
-
-(autoload 'eieio-describe-class "eieio-opt" "\
-Describe a CLASS defined by a string or symbol.
-If CLASS is actually an object, then also display current values of that object.
-Optional HEADERFCN should be called to insert a few bits of info first.
-
-\(fn CLASS &optional HEADERFCN)" t nil)
-
-(autoload 'eieio-describe-constructor "eieio-opt" "\
-Describe the constructor function FCN.
-Uses `eieio-describe-class' to describe the class being constructed.
+;;;### (autoloads nil "elec-pair" "elec-pair.el" (22086 11929 602062
+;;;;;; 731000))
+;;; Generated autoloads from elec-pair.el
-\(fn FCN)" t nil)
-(defalias 'describe-generic 'eieio-describe-generic)
+(defvar electric-pair-text-pairs '((34 . 34)) "\
+Alist of pairs that should always be used in comments and strings.
-(autoload 'eieio-describe-generic "eieio-opt" "\
-Describe the generic function GENERIC.
-Also extracts information about all methods specific to this generic.
+Pairs of delimiters in this list are a fallback in case they have
+no syntax relevant to `electric-pair-mode' in the syntax table
+defined in `electric-pair-text-syntax-table'")
-\(fn GENERIC)" t nil)
+(custom-autoload 'electric-pair-text-pairs "elec-pair" t)
-;;;***
-\f
-;;;### (autoloads nil "eldoc" "emacs-lisp/eldoc.el" (21041 38058
-;;;;;; 75002 0))
-;;; Generated autoloads from emacs-lisp/eldoc.el
-
-(defvar eldoc-minor-mode-string (purecopy " ElDoc") "\
-String to display in mode line when ElDoc Mode is enabled; nil for none.")
+(defvar electric-pair-mode nil "\
+Non-nil if Electric-Pair mode is enabled.
+See the command `electric-pair-mode' for a description of this minor mode.
+Setting this variable directly does not take effect;
+either customize it (see the info node `Easy Customization')
+or call the function `electric-pair-mode'.")
-(custom-autoload 'eldoc-minor-mode-string "eldoc" t)
+(custom-autoload 'electric-pair-mode "elec-pair" nil)
-(autoload 'eldoc-mode "eldoc" "\
-Toggle echo area display of Lisp objects at point (ElDoc mode).
-With a prefix argument ARG, enable ElDoc mode if ARG is positive,
-and disable it otherwise. If called from Lisp, enable ElDoc mode
-if ARG is omitted or nil.
+(autoload 'electric-pair-mode "elec-pair" "\
+Toggle automatic parens pairing (Electric Pair mode).
+With a prefix argument ARG, enable Electric Pair mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+the mode if ARG is omitted or nil.
-ElDoc mode is a buffer-local minor mode. When enabled, the echo
-area displays information about a function or variable in the
-text where point is. If point is on a documented variable, it
-displays the first line of that variable's doc string. Otherwise
-it displays the argument list of the function called in the
-expression point is on.
+Electric Pair mode is a global minor mode. When enabled, typing
+an open parenthesis automatically inserts the corresponding
+closing parenthesis. (Likewise for brackets, etc.). To toggle
+the mode in a single buffer, use `electric-pair-local-mode'.
\(fn &optional ARG)" t nil)
-(autoload 'eldoc-post-insert-mode "eldoc" "\
-Toggle Eldoc-Post-Insert mode on or off.
-With a prefix argument ARG, enable Eldoc-Post-Insert mode if ARG is
-positive, and disable it otherwise. If called from Lisp, enable
-the mode if ARG is omitted or nil, and toggle it if ARG is `toggle'.
-\\{eldoc-post-insert-mode-map}
+(autoload 'electric-pair-local-mode "elec-pair" "\
+Toggle `electric-pair-mode' only in this buffer.
\(fn &optional ARG)" t nil)
-(autoload 'turn-on-eldoc-mode "eldoc" "\
-Unequivocally turn on ElDoc mode (see command `eldoc-mode').
-
-\(fn)" t nil)
-
-(defvar eldoc-documentation-function nil "\
-If non-nil, function to call to return doc string.
-The function of no args should return a one-line string for displaying
-doc about a function etc. appropriate to the context around point.
-It should return nil if there's no doc appropriate for the context.
-Typically doc is returned if point is on a function-like name or in its
-arg list.
-
-The result is used as is, so the function must explicitly handle
-the variables `eldoc-argument-case' and `eldoc-echo-area-use-multiline-p',
-and the face `eldoc-highlight-function-argument', if they are to have any
-effect.
-
-This variable is expected to be made buffer-local by modes (other than
-Emacs Lisp mode) that support ElDoc.")
-
;;;***
\f
-;;;### (autoloads nil "elide-head" "elide-head.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "elide-head" "elide-head.el" (22086 11929 602062
+;;;;;; 731000))
;;; Generated autoloads from elide-head.el
(autoload 'elide-head "elide-head" "\
;;;***
\f
-;;;### (autoloads nil "elint" "emacs-lisp/elint.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "elint" "emacs-lisp/elint.el" (22086 11929
+;;;;;; 674062 731000))
;;; Generated autoloads from emacs-lisp/elint.el
(autoload 'elint-file "elint" "\
;;;***
\f
-;;;### (autoloads nil "elp" "emacs-lisp/elp.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "elp" "emacs-lisp/elp.el" (22086 11929 674062
+;;;;;; 731000))
;;; Generated autoloads from emacs-lisp/elp.el
(autoload 'elp-instrument-function "elp" "\
;;;***
\f
-;;;### (autoloads nil "emacs-lock" "emacs-lock.el" (20933 31141 450159
-;;;;;; 0))
+;;;### (autoloads nil "emacs-lock" "emacs-lock.el" (22086 11929 690062
+;;;;;; 731000))
;;; Generated autoloads from emacs-lock.el
(autoload 'emacs-lock-mode "emacs-lock" "\
;;;***
\f
-;;;### (autoloads nil "emacsbug" "mail/emacsbug.el" (21048 11307
-;;;;;; 937592 0))
+;;;### (autoloads nil "emacsbug" "mail/emacsbug.el" (22086 11929
+;;;;;; 934062 731000))
;;; Generated autoloads from mail/emacsbug.el
(autoload 'report-emacs-bug "emacsbug" "\
Report a bug in GNU Emacs.
Prompts for bug subject. Leaves you in a mail buffer.
-\(fn TOPIC &optional RECENT-KEYS)" t nil)
+\(fn TOPIC &optional UNUSED)" t nil)
+
+(set-advertised-calling-convention 'report-emacs-bug '(topic) '"24.5")
;;;***
\f
-;;;### (autoloads nil "emerge" "vc/emerge.el" (21032 23080 765139
-;;;;;; 0))
+;;;### (autoloads nil "emerge" "vc/emerge.el" (22086 11930 378062
+;;;;;; 731000))
;;; Generated autoloads from vc/emerge.el
(autoload 'emerge-files "emerge" "\
;;;***
\f
-;;;### (autoloads nil "enriched" "textmodes/enriched.el" (21136 36544
-;;;;;; 158478 0))
+;;;### (autoloads nil "enriched" "textmodes/enriched.el" (22086 11930
+;;;;;; 314062 731000))
;;; Generated autoloads from textmodes/enriched.el
(autoload 'enriched-mode "enriched" "\
;;;***
\f
-;;;### (autoloads nil "epa" "epa.el" (21034 64808 616539 0))
+;;;### (autoloads nil "epa" "epa.el" (22086 11929 698062 731000))
;;; Generated autoloads from epa.el
(autoload 'epa-list-keys "epa" "\
For example:
-\(let ((context (epg-make-context 'OpenPGP)))
+\(let ((context (epg-make-context \\='OpenPGP)))
(decode-coding-string
(epg-decrypt-string context (buffer-substring start end))
- 'utf-8))
+ \\='utf-8))
\(fn START END &optional MAKE-BUFFER-FUNCTION)" t nil)
\(fn START END)" t nil)
+(function-put 'epa-decrypt-armor-in-region 'interactive-only 't)
+
(autoload 'epa-verify-region "epa" "\
Verify the current region between START and END.
For example:
-\(let ((context (epg-make-context 'OpenPGP)))
+\(let ((context (epg-make-context \\='OpenPGP)))
(decode-coding-string
(epg-verify-string context (buffer-substring start end))
- 'utf-8))
+ \\='utf-8))
\(fn START END)" t nil)
+(function-put 'epa-verify-region 'interactive-only 't)
+
(autoload 'epa-verify-cleartext-in-region "epa" "\
Verify OpenPGP cleartext signed messages in the current region
between START and END.
\(fn START END)" t nil)
+(function-put 'epa-verify-cleartext-in-region 'interactive-only 't)
+
(autoload 'epa-sign-region "epa" "\
Sign the current region between START and END by SIGNERS keys selected.
For example:
-\(let ((context (epg-make-context 'OpenPGP)))
+\(let ((context (epg-make-context \\='OpenPGP)))
(epg-sign-string
context
- (encode-coding-string (buffer-substring start end) 'utf-8)))
+ (encode-coding-string (buffer-substring start end) \\='utf-8)))
\(fn START END SIGNERS MODE)" t nil)
+(function-put 'epa-sign-region 'interactive-only 't)
+
(autoload 'epa-encrypt-region "epa" "\
Encrypt the current region between START and END for RECIPIENTS.
For example:
-\(let ((context (epg-make-context 'OpenPGP)))
+\(let ((context (epg-make-context \\='OpenPGP)))
(epg-encrypt-string
context
- (encode-coding-string (buffer-substring start end) 'utf-8)
+ (encode-coding-string (buffer-substring start end) \\='utf-8)
nil))
\(fn START END RECIPIENTS SIGN SIGNERS)" t nil)
+(function-put 'epa-encrypt-region 'interactive-only 't)
+
(autoload 'epa-delete-keys "epa" "\
Delete selected KEYS.
;;;***
\f
-;;;### (autoloads nil "epa-dired" "epa-dired.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "epa-dired" "epa-dired.el" (22086 11929 698062
+;;;;;; 731000))
;;; Generated autoloads from epa-dired.el
(autoload 'epa-dired-do-decrypt "epa-dired" "\
;;;***
\f
-;;;### (autoloads nil "epa-file" "epa-file.el" (21102 14759 136845
-;;;;;; 0))
+;;;### (autoloads nil "epa-file" "epa-file.el" (22086 11929 698062
+;;;;;; 731000))
;;; Generated autoloads from epa-file.el
(autoload 'epa-file-handler "epa-file" "\
;;;***
\f
-;;;### (autoloads nil "epa-mail" "epa-mail.el" (20978 19624 657047
-;;;;;; 0))
+;;;### (autoloads nil "epa-mail" "epa-mail.el" (22086 11929 698062
+;;;;;; 731000))
;;; Generated autoloads from epa-mail.el
(autoload 'epa-mail-mode "epa-mail" "\
Decrypt OpenPGP armors in the current buffer.
The buffer is expected to contain a mail message.
-Don't use this command in Lisp programs!
-
\(fn)" t nil)
+(function-put 'epa-mail-decrypt 'interactive-only 't)
+
(autoload 'epa-mail-verify "epa-mail" "\
Verify OpenPGP cleartext signed messages in the current buffer.
The buffer is expected to contain a mail message.
-Don't use this command in Lisp programs!
-
\(fn)" t nil)
+(function-put 'epa-mail-verify 'interactive-only 't)
+
(autoload 'epa-mail-sign "epa-mail" "\
Sign the current buffer.
The buffer is expected to contain a mail message.
-Don't use this command in Lisp programs!
-
\(fn START END SIGNERS MODE)" t nil)
+(function-put 'epa-mail-sign 'interactive-only 't)
+
(autoload 'epa-mail-encrypt "epa-mail" "\
Encrypt the outgoing mail message in the current buffer.
Takes the recipients from the text in the header in the buffer
Import keys in the OpenPGP armor format in the current buffer.
The buffer is expected to contain a mail message.
-Don't use this command in Lisp programs!
-
\(fn)" t nil)
+(function-put 'epa-mail-import-keys 'interactive-only 't)
+
(defvar epa-global-mail-mode nil "\
Non-nil if Epa-Global-Mail mode is enabled.
See the command `epa-global-mail-mode' for a description of this minor mode.
;;;***
\f
-;;;### (autoloads nil "epg" "epg.el" (21069 17449 167398 0))
+;;;### (autoloads nil "epg" "epg.el" (22092 27717 648268 464000))
;;; Generated autoloads from epg.el
(push (purecopy '(epg 1 0 0)) package--builtin-versions)
;;;***
\f
-;;;### (autoloads nil "epg-config" "epg-config.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "epg-config" "epg-config.el" (22086 11929 698062
+;;;;;; 731000))
;;; Generated autoloads from epg-config.el
(autoload 'epg-configuration "epg-config" "\
;;;***
\f
-;;;### (autoloads nil "erc" "erc/erc.el" (21053 29224 547064 0))
+;;;### (autoloads nil "erc" "erc/erc.el" (22093 48588 540393 539000))
;;; Generated autoloads from erc/erc.el
(push (purecopy '(erc 5 3)) package--builtin-versions)
`erc-compute-port', `erc-compute-nick' and `erc-compute-full-name' will
be invoked for the values of the other parameters.
-\(fn &key (server (erc-compute-server)) (port (erc-compute-port)) (nick (erc-compute-nick)) PASSWORD (full-name (erc-compute-full-name)))" t nil)
+\(fn &key (SERVER (erc-compute-server)) (PORT (erc-compute-port)) (NICK (erc-compute-nick)) PASSWORD (FULL-NAME (erc-compute-full-name)))" t nil)
(defalias 'erc-select 'erc)
;;;***
\f
-;;;### (autoloads nil "erc-autoaway" "erc/erc-autoaway.el" (20709
-;;;;;; 26818 907104 0))
+;;;### (autoloads nil "erc-autoaway" "erc/erc-autoaway.el" (22086
+;;;;;; 11929 706062 731000))
;;; Generated autoloads from erc/erc-autoaway.el
(autoload 'erc-autoaway-mode "erc-autoaway")
;;;***
\f
-;;;### (autoloads nil "erc-button" "erc/erc-button.el" (21139 12727
-;;;;;; 345232 0))
+;;;### (autoloads nil "erc-button" "erc/erc-button.el" (22092 27717
+;;;;;; 652268 464000))
;;; Generated autoloads from erc/erc-button.el
(autoload 'erc-button-mode "erc-button" nil t)
;;;***
\f
-;;;### (autoloads nil "erc-capab" "erc/erc-capab.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "erc-capab" "erc/erc-capab.el" (22086 11929
+;;;;;; 706062 731000))
;;; Generated autoloads from erc/erc-capab.el
(autoload 'erc-capab-identify-mode "erc-capab" nil t)
;;;***
\f
-;;;### (autoloads nil "erc-compat" "erc/erc-compat.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "erc-compat" "erc/erc-compat.el" (22086 11929
+;;;;;; 706062 731000))
;;; Generated autoloads from erc/erc-compat.el
(autoload 'erc-define-minor-mode "erc-compat")
;;;***
\f
-;;;### (autoloads nil "erc-dcc" "erc/erc-dcc.el" (20759 33211 414988
-;;;;;; 0))
+;;;### (autoloads nil "erc-dcc" "erc/erc-dcc.el" (22086 11929 706062
+;;;;;; 731000))
;;; Generated autoloads from erc/erc-dcc.el
(autoload 'erc-dcc-mode "erc-dcc")
;;;***
\f
;;;### (autoloads nil "erc-desktop-notifications" "erc/erc-desktop-notifications.el"
-;;;;;; (21042 58928 39127 0))
+;;;;;; (22086 11929 706062 731000))
;;; Generated autoloads from erc/erc-desktop-notifications.el
(autoload 'erc-notifications-mode "erc-desktop-notifications" "" t)
;;;***
\f
-;;;### (autoloads nil "erc-ezbounce" "erc/erc-ezbounce.el" (20709
-;;;;;; 26818 907104 0))
+;;;### (autoloads nil "erc-ezbounce" "erc/erc-ezbounce.el" (22086
+;;;;;; 11929 710062 731000))
;;; Generated autoloads from erc/erc-ezbounce.el
(autoload 'erc-cmd-ezb "erc-ezbounce" "\
(autoload 'erc-ezb-get-login "erc-ezbounce" "\
Return an appropriate EZBounce login for SERVER and PORT.
Look up entries in `erc-ezb-login-alist'. If the username or password
-in the alist is `nil', prompt for the appropriate values.
+in the alist is nil, prompt for the appropriate values.
\(fn SERVER PORT)" nil nil)
;;;***
\f
-;;;### (autoloads nil "erc-fill" "erc/erc-fill.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "erc-fill" "erc/erc-fill.el" (22086 11929 710062
+;;;;;; 731000))
;;; Generated autoloads from erc/erc-fill.el
(autoload 'erc-fill-mode "erc-fill" nil t)
;;;***
\f
-;;;### (autoloads nil "erc-identd" "erc/erc-identd.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "erc-identd" "erc/erc-identd.el" (22086 11929
+;;;;;; 710062 731000))
;;; Generated autoloads from erc/erc-identd.el
(autoload 'erc-identd-mode "erc-identd")
;;;***
\f
-;;;### (autoloads nil "erc-imenu" "erc/erc-imenu.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "erc-imenu" "erc/erc-imenu.el" (22086 11929
+;;;;;; 710062 731000))
;;; Generated autoloads from erc/erc-imenu.el
(autoload 'erc-create-imenu-index "erc-imenu" "\
;;;***
\f
-;;;### (autoloads nil "erc-join" "erc/erc-join.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "erc-join" "erc/erc-join.el" (22086 11929 710062
+;;;;;; 731000))
;;; Generated autoloads from erc/erc-join.el
(autoload 'erc-autojoin-mode "erc-join" nil t)
;;;***
\f
-;;;### (autoloads nil "erc-lang" "erc/erc-lang.el" (20709 26818 907104
-;;;;;; 0))
-;;; Generated autoloads from erc/erc-lang.el
-(push (purecopy '(erc-lang 1 0 0)) package--builtin-versions)
-
-;;;***
-\f
-;;;### (autoloads nil "erc-list" "erc/erc-list.el" (21050 53033 774595
-;;;;;; 0))
+;;;### (autoloads nil "erc-list" "erc/erc-list.el" (22086 11929 710062
+;;;;;; 731000))
;;; Generated autoloads from erc/erc-list.el
-(push (purecopy '(erc-list 0 1)) package--builtin-versions)
(autoload 'erc-list-mode "erc-list")
;;;***
\f
-;;;### (autoloads nil "erc-log" "erc/erc-log.el" (20891 18859 893295
-;;;;;; 0))
+;;;### (autoloads nil "erc-log" "erc/erc-log.el" (22086 11929 710062
+;;;;;; 731000))
;;; Generated autoloads from erc/erc-log.el
(autoload 'erc-log-mode "erc-log" nil t)
;;;***
\f
-;;;### (autoloads nil "erc-match" "erc/erc-match.el" (20763 30266
-;;;;;; 231060 0))
+;;;### (autoloads nil "erc-match" "erc/erc-match.el" (22092 27717
+;;;;;; 652268 464000))
;;; Generated autoloads from erc/erc-match.el
(autoload 'erc-match-mode "erc-match")
;;;***
\f
-;;;### (autoloads nil "erc-menu" "erc/erc-menu.el" (20884 7264 412929
-;;;;;; 442000))
+;;;### (autoloads nil "erc-menu" "erc/erc-menu.el" (22086 11929 710062
+;;;;;; 731000))
;;; Generated autoloads from erc/erc-menu.el
(autoload 'erc-menu-mode "erc-menu" nil t)
;;;***
\f
-;;;### (autoloads nil "erc-netsplit" "erc/erc-netsplit.el" (20709
-;;;;;; 26818 907104 0))
+;;;### (autoloads nil "erc-netsplit" "erc/erc-netsplit.el" (22086
+;;;;;; 11929 710062 731000))
;;; Generated autoloads from erc/erc-netsplit.el
(autoload 'erc-netsplit-mode "erc-netsplit")
;;;***
\f
-;;;### (autoloads nil "erc-networks" "erc/erc-networks.el" (20709
-;;;;;; 26818 907104 0))
+;;;### (autoloads nil "erc-networks" "erc/erc-networks.el" (22086
+;;;;;; 11929 710062 731000))
;;; Generated autoloads from erc/erc-networks.el
(autoload 'erc-determine-network "erc-networks" "\
;;;***
\f
-;;;### (autoloads nil "erc-notify" "erc/erc-notify.el" (21013 58662
-;;;;;; 278539 0))
+;;;### (autoloads nil "erc-notify" "erc/erc-notify.el" (22086 11929
+;;;;;; 710062 731000))
;;; Generated autoloads from erc/erc-notify.el
(autoload 'erc-notify-mode "erc-notify" nil t)
;;;***
\f
-;;;### (autoloads nil "erc-page" "erc/erc-page.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "erc-page" "erc/erc-page.el" (22086 11929 710062
+;;;;;; 731000))
;;; Generated autoloads from erc/erc-page.el
(autoload 'erc-page-mode "erc-page")
;;;***
\f
-;;;### (autoloads nil "erc-pcomplete" "erc/erc-pcomplete.el" (21112
-;;;;;; 20657 455367 0))
+;;;### (autoloads nil "erc-pcomplete" "erc/erc-pcomplete.el" (22086
+;;;;;; 11929 710062 731000))
;;; Generated autoloads from erc/erc-pcomplete.el
(autoload 'erc-completion-mode "erc-pcomplete" nil t)
;;;***
\f
-;;;### (autoloads nil "erc-replace" "erc/erc-replace.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "erc-replace" "erc/erc-replace.el" (22086 11929
+;;;;;; 710062 731000))
;;; Generated autoloads from erc/erc-replace.el
(autoload 'erc-replace-mode "erc-replace")
;;;***
\f
-;;;### (autoloads nil "erc-ring" "erc/erc-ring.el" (20884 7264 412929
-;;;;;; 442000))
+;;;### (autoloads nil "erc-ring" "erc/erc-ring.el" (22092 27717 652268
+;;;;;; 464000))
;;; Generated autoloads from erc/erc-ring.el
(autoload 'erc-ring-mode "erc-ring" nil t)
;;;***
\f
-;;;### (autoloads nil "erc-services" "erc/erc-services.el" (20709
-;;;;;; 26818 907104 0))
+;;;### (autoloads nil "erc-services" "erc/erc-services.el" (22086
+;;;;;; 11929 710062 731000))
;;; Generated autoloads from erc/erc-services.el
(autoload 'erc-services-mode "erc-services" nil t)
;;;***
\f
-;;;### (autoloads nil "erc-sound" "erc/erc-sound.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "erc-sound" "erc/erc-sound.el" (22086 11929
+;;;;;; 714062 731000))
;;; Generated autoloads from erc/erc-sound.el
(autoload 'erc-sound-mode "erc-sound")
;;;***
\f
-;;;### (autoloads nil "erc-speedbar" "erc/erc-speedbar.el" (20709
-;;;;;; 26818 907104 0))
+;;;### (autoloads nil "erc-speedbar" "erc/erc-speedbar.el" (22086
+;;;;;; 11929 714062 731000))
;;; Generated autoloads from erc/erc-speedbar.el
(autoload 'erc-speedbar-browser "erc-speedbar" "\
;;;***
\f
-;;;### (autoloads nil "erc-spelling" "erc/erc-spelling.el" (20709
-;;;;;; 26818 907104 0))
+;;;### (autoloads nil "erc-spelling" "erc/erc-spelling.el" (22086
+;;;;;; 11929 714062 731000))
;;; Generated autoloads from erc/erc-spelling.el
(autoload 'erc-spelling-mode "erc-spelling" nil t)
;;;***
\f
-;;;### (autoloads nil "erc-stamp" "erc/erc-stamp.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "erc-stamp" "erc/erc-stamp.el" (22086 11929
+;;;;;; 714062 731000))
;;; Generated autoloads from erc/erc-stamp.el
(autoload 'erc-timestamp-mode "erc-stamp" nil t)
;;;***
\f
-;;;### (autoloads nil "erc-track" "erc/erc-track.el" (21013 58662
-;;;;;; 278539 0))
+;;;### (autoloads nil "erc-track" "erc/erc-track.el" (22092 27717
+;;;;;; 656268 464000))
;;; Generated autoloads from erc/erc-track.el
(defvar erc-track-minor-mode nil "\
;;;***
\f
-;;;### (autoloads nil "erc-truncate" "erc/erc-truncate.el" (20709
-;;;;;; 26818 907104 0))
+;;;### (autoloads nil "erc-truncate" "erc/erc-truncate.el" (22086
+;;;;;; 11929 714062 731000))
;;; Generated autoloads from erc/erc-truncate.el
(autoload 'erc-truncate-mode "erc-truncate" nil t)
;;;***
\f
-;;;### (autoloads nil "erc-xdcc" "erc/erc-xdcc.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "erc-xdcc" "erc/erc-xdcc.el" (22086 11929 714062
+;;;;;; 731000))
;;; Generated autoloads from erc/erc-xdcc.el
(autoload 'erc-xdcc-mode "erc-xdcc")
;;;***
\f
-;;;### (autoloads nil "ert" "emacs-lisp/ert.el" (21112 43970 768678
-;;;;;; 0))
+;;;### (autoloads nil "ert" "emacs-lisp/ert.el" (22092 27717 632268
+;;;;;; 464000))
;;; Generated autoloads from emacs-lisp/ert.el
(autoload 'ert-deftest "ert" "\
using :expected-result. See `ert-test-result-type-p' for a
description of valid values for RESULT-TYPE.
-\(fn NAME () [DOCSTRING] [:expected-result RESULT-TYPE] [:tags '(TAG...)] BODY...)" nil (quote macro))
+\(fn NAME () [DOCSTRING] [:expected-result RESULT-TYPE] [:tags \\='(TAG...)] BODY...)" nil t)
+
+(function-put 'ert-deftest 'doc-string-elt '3)
+
+(function-put 'ert-deftest 'lisp-indent-function '2)
(put 'ert-deftest 'lisp-indent-function 2)
;;;***
\f
-;;;### (autoloads nil "ert-x" "emacs-lisp/ert-x.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "ert-x" "emacs-lisp/ert-x.el" (22086 11929
+;;;;;; 674062 731000))
;;; Generated autoloads from emacs-lisp/ert-x.el
(put 'ert-with-test-buffer 'lisp-indent-function 1)
;;;***
\f
-;;;### (autoloads nil "esh-mode" "eshell/esh-mode.el" (21048 47760
-;;;;;; 436258 0))
+;;;### (autoloads nil "esh-mode" "eshell/esh-mode.el" (22086 11929
+;;;;;; 722062 731000))
;;; Generated autoloads from eshell/esh-mode.el
(autoload 'eshell-mode "esh-mode" "\
;;;***
\f
-;;;### (autoloads nil "eshell" "eshell/eshell.el" (21042 9718 407372
-;;;;;; 0))
+;;;### (autoloads nil "eshell" "eshell/eshell.el" (22086 11929 722062
+;;;;;; 731000))
;;; Generated autoloads from eshell/eshell.el
(push (purecopy '(eshell 2 4 2)) package--builtin-versions)
;;;***
\f
-;;;### (autoloads nil "etags" "progmodes/etags.el" (20992 52525 458637
-;;;;;; 0))
+;;;### (autoloads nil "etags" "progmodes/etags.el" (22105 39773 947886
+;;;;;; 896000))
;;; Generated autoloads from progmodes/etags.el
(defvar tags-file-name nil "\
as they appeared in the `etags' command that created the table, usually
without directory names.
+\(fn)" nil nil)
+
+(autoload 'tags-lazy-completion-table "etags" "\
+
+
\(fn)" nil nil)
(defun tags-completion-at-point-function ()
(if (or tags-table-list tags-file-name)
See documentation of variable `tags-file-name'.
\(fn TAGNAME &optional NEXT-P REGEXP-P)" t nil)
- (define-key esc-map "." 'find-tag)
+
+(make-obsolete 'find-tag 'xref-find-definitions '"25.1")
(autoload 'find-tag-other-window "etags" "\
Find tag (in current tags table) whose name contains TAGNAME.
See documentation of variable `tags-file-name'.
\(fn TAGNAME &optional NEXT-P REGEXP-P)" t nil)
- (define-key ctl-x-4-map "." 'find-tag-other-window)
+
+(make-obsolete 'find-tag-other-window 'xref-find-definitions-other-window '"25.1")
(autoload 'find-tag-other-frame "etags" "\
Find tag (in current tags table) whose name contains TAGNAME.
See documentation of variable `tags-file-name'.
\(fn TAGNAME &optional NEXT-P)" t nil)
- (define-key ctl-x-5-map "." 'find-tag-other-frame)
+
+(make-obsolete 'find-tag-other-frame 'xref-find-definitions-other-frame '"25.1")
(autoload 'find-tag-regexp "etags" "\
Find tag (in current tags table) whose name matches REGEXP.
See documentation of variable `tags-file-name'.
\(fn REGEXP &optional NEXT-P OTHER-WINDOW)" t nil)
- (define-key esc-map [?\C-.] 'find-tag-regexp)
- (define-key esc-map "*" 'pop-tag-mark)
-(autoload 'pop-tag-mark "etags" "\
-Pop back to where \\[find-tag] was last invoked.
+(make-obsolete 'find-tag-regexp 'xref-find-apropos '"25.1")
-This is distinct from invoking \\[find-tag] with a negative argument
-since that pops a stack of markers at which tags were found, not from
-where they were found.
-
-\(fn)" t nil)
+(defalias 'pop-tag-mark 'xref-pop-marker-stack)
(autoload 'next-file "etags" "\
Select next file among files in current tags table.
nil, we exit; otherwise we scan the next file.
\(fn &optional FIRST-TIME)" t nil)
- (define-key esc-map "," 'tags-loop-continue)
+
+(make-obsolete 'tags-loop-continue '"use `xref-find-definitions' interface instead." '"25.1")
(autoload 'tags-search "etags" "\
Search through all files listed in tags table for match for REGEXP.
\(fn REGEXP)" t nil)
+(make-obsolete 'tags-apropos 'xref-find-apropos '"25.1")
+
(autoload 'select-tags-table "etags" "\
Select a tags table file from a menu of those you have already used.
The list of tags tables to select from is stored in `tags-table-set-list';
\(fn)" t nil)
+(autoload 'etags--xref-backend "etags" "\
+
+
+\(fn)" nil nil)
+
;;;***
\f
-;;;### (autoloads nil "ethio-util" "language/ethio-util.el" (20709
-;;;;;; 26818 907104 0))
+;;;### (autoloads nil "ethio-util" "language/ethio-util.el" (22086
+;;;;;; 11929 894062 731000))
;;; Generated autoloads from language/ethio-util.el
(autoload 'setup-ethiopic-environment-internal "ethio-util" "\
;;;***
\f
-;;;### (autoloads nil "eudc" "net/eudc.el" (21040 17194 398147 0))
+;;;### (autoloads nil "eudc" "net/eudc.el" (22099 965 90725 479000))
;;; Generated autoloads from net/eudc.el
(autoload 'eudc-set-server "eudc" "\
;;;***
\f
-;;;### (autoloads nil "eudc-bob" "net/eudc-bob.el" (20791 9657 561026
-;;;;;; 0))
+;;;### (autoloads nil "eudc-bob" "net/eudc-bob.el" (22086 11929 990062
+;;;;;; 731000))
;;; Generated autoloads from net/eudc-bob.el
(autoload 'eudc-display-generic-binary "eudc-bob" "\
;;;***
\f
-;;;### (autoloads nil "eudc-export" "net/eudc-export.el" (20871 33574
-;;;;;; 214287 0))
+;;;### (autoloads nil "eudc-export" "net/eudc-export.el" (22099 965
+;;;;;; 74725 479000))
;;; Generated autoloads from net/eudc-export.el
(autoload 'eudc-insert-record-at-point-into-bbdb "eudc-export" "\
;;;***
\f
-;;;### (autoloads nil "eudc-hotlist" "net/eudc-hotlist.el" (21040
-;;;;;; 17194 398147 0))
+;;;### (autoloads nil "eudc-hotlist" "net/eudc-hotlist.el" (22086
+;;;;;; 11929 990062 731000))
;;; Generated autoloads from net/eudc-hotlist.el
(autoload 'eudc-edit-hotlist "eudc-hotlist" "\
;;;***
\f
-;;;### (autoloads nil "ewoc" "emacs-lisp/ewoc.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "ewoc" "emacs-lisp/ewoc.el" (22086 11929 674062
+;;;;;; 731000))
;;; Generated autoloads from emacs-lisp/ewoc.el
(autoload 'ewoc-create "ewoc" "\
;;;***
\f
-;;;### (autoloads nil "eww" "net/eww.el" (21141 54458 609734 0))
+;;;### (autoloads nil "eww" "net/eww.el" (22093 48588 548393 539000))
;;; Generated autoloads from net/eww.el
+(defvar eww-suggest-uris '(eww-links-at-point url-get-url-at-point eww-current-url) "\
+List of functions called to form the list of default URIs for `eww'.
+Each of the elements is a function returning either a string or a list
+of strings. The results will be joined into a single list with
+duplicate entries (if any) removed.")
+
+(custom-autoload 'eww-suggest-uris "eww" t)
+
(autoload 'eww "eww" "\
Fetch URL and render the page.
If the input doesn't look like an URL or a domain name, the
word(s) will be searched for via `eww-search-prefix'.
\(fn URL)" t nil)
+ (defalias 'browse-web 'eww)
(autoload 'eww-open-file "eww" "\
-Render a file using EWW.
+Render FILE using EWW.
\(fn FILE)" t nil)
+(autoload 'eww-search-words "eww" "\
+Search the web for the text between BEG and END.
+See the `eww-search-prefix' variable for the search engine used.
+
+\(fn &optional BEG END)" t nil)
+
+(autoload 'eww-mode "eww" "\
+Mode for browsing the web.
+
+\(fn)" t nil)
+
(autoload 'eww-browse-url "eww" "\
\(fn URL &optional NEW-WINDOW)" nil nil)
+(autoload 'eww-list-bookmarks "eww" "\
+Display the bookmarks.
+
+\(fn)" t nil)
+
;;;***
\f
-;;;### (autoloads nil "executable" "progmodes/executable.el" (21041
-;;;;;; 38058 75002 0))
+;;;### (autoloads nil "executable" "progmodes/executable.el" (22086
+;;;;;; 11930 170062 731000))
;;; Generated autoloads from progmodes/executable.el
(autoload 'executable-command-find-posix-p "executable" "\
\(fn INTERPRETER &optional ARGUMENT NO-QUERY-FLAG INSERT-FLAG)" t nil)
-(autoload 'executable-self-display "executable" "\
-Turn a text file into a self-displaying Un*x command.
-The magic number of such a command displays all lines but itself.
-
-\(fn)" t nil)
-
(autoload 'executable-make-buffer-file-executable-if-script-p "executable" "\
Make file executable according to umask if not already executable.
If file already has any execute bits set at all, do not change existing
;;;***
\f
-;;;### (autoloads nil "expand" "expand.el" (20709 26818 907104 0))
+;;;### (autoloads nil "expand" "expand.el" (22086 11929 726062 731000))
;;; Generated autoloads from expand.el
(autoload 'expand-add-abbrevs "expand" "\
;;;***
\f
-;;;### (autoloads nil "f90" "progmodes/f90.el" (20992 52525 458637
-;;;;;; 0))
+;;;### (autoloads nil "f90" "progmodes/f90.el" (22092 27718 152268
+;;;;;; 464000))
;;; Generated autoloads from progmodes/f90.el
(autoload 'f90-mode "f90" "\
\\[f90-indent-new-line] indents current line and creates a new indented line.
\\[f90-indent-subprogram] indents the current subprogram.
-Type `? or `\\[help-command] to display a list of built-in abbrevs for F90 keywords.
+Type \\=`? or \\=`\\[help-command] to display a list of built-in abbrevs for F90 keywords.
Key definitions:
\\{f90-mode-map}
Non-nil causes `f90-do-auto-fill' to break lines before delimiters
(default t).
`f90-beginning-ampersand'
- Automatic insertion of & at beginning of continuation lines (default t).
+ Automatic insertion of `&' at beginning of continuation lines (default t).
`f90-smart-end'
From an END statement, check and fill the end using matching block start.
Allowed values are `blink', `no-blink', and nil, which determine
;;;***
\f
-;;;### (autoloads nil "face-remap" "face-remap.el" (21082 29482 330637
-;;;;;; 0))
+;;;### (autoloads nil "face-remap" "face-remap.el" (22086 11929 726062
+;;;;;; 731000))
;;; Generated autoloads from face-remap.el
(autoload 'face-remap-add-relative "face-remap" "\
If SPECS is empty, call `face-remap-reset-base' to use the normal
definition of FACE as the base remapping; note that this is
-different from SPECS containing a single value `nil', which means
+different from SPECS containing a single value nil, which means
not to inherit from the global definition of FACE at all.
\(fn FACE &rest SPECS)" nil nil)
;;;***
\f
-;;;### (autoloads nil "feedmail" "mail/feedmail.el" (21002 1963 769129
-;;;;;; 0))
+;;;### (autoloads nil "feedmail" "mail/feedmail.el" (22092 27717
+;;;;;; 880268 464000))
;;; Generated autoloads from mail/feedmail.el
(push (purecopy '(feedmail 11)) package--builtin-versions)
(autoload 'feedmail-queue-reminder "feedmail" "\
Perform some kind of reminder activity about queued and draft messages.
Called with an optional symbol argument which says what kind of event
-is triggering the reminder activity. The default is 'on-demand, which
+is triggering the reminder activity. The default is `on-demand', which
is what you typically would use if you were putting this in your Emacs start-up
or mail hook code. Other recognized values for WHAT-EVENT (these are passed
internally by feedmail):
;;;***
\f
-;;;### (autoloads nil "ffap" "ffap.el" (21090 23592 994673 0))
+;;;### (autoloads nil "ffap" "ffap.el" (22086 11929 730062 731000))
;;; Generated autoloads from ffap.el
(autoload 'ffap-next "ffap" "\
Search buffer for next file or URL, and run ffap.
Optional argument BACK says to search backwards.
Optional argument WRAP says to try wrapping around if necessary.
-Interactively: use a single prefix to search backwards,
+Interactively: use a single prefix \\[universal-argument] to search backwards,
double prefix to wrap forward, triple to wrap backwards.
Actual search is done by the function `ffap-next-guess'.
;;;***
\f
-;;;### (autoloads nil "filecache" "filecache.el" (20998 4934 952905
-;;;;;; 0))
+;;;### (autoloads nil "filecache" "filecache.el" (22086 11929 734062
+;;;;;; 731000))
;;; Generated autoloads from filecache.el
(autoload 'file-cache-add-directory "filecache" "\
;;;***
\f
-;;;### (autoloads nil "filenotify" "filenotify.el" (21142 14078 948441
-;;;;;; 0))
+;;;### (autoloads nil "filenotify" "filenotify.el" (22086 11929 734062
+;;;;;; 731000))
;;; Generated autoloads from filenotify.el
(autoload 'file-notify-handle-event "filenotify" "\
Handle file system monitoring event.
-If EVENT is a filewatch event, call its callback.
+If EVENT is a filewatch event, call its callback. It has the format
+
+ (file-notify (DESCRIPTOR ACTIONS FILE [FILE1-OR-COOKIE]) CALLBACK)
+
Otherwise, signal a `file-notify-error'.
\(fn EVENT)" t nil)
;;;***
\f
-;;;### (autoloads nil "files-x" "files-x.el" (20938 49065 383398
-;;;;;; 0))
+;;;### (autoloads nil "files-x" "files-x.el" (22086 11929 734062
+;;;;;; 731000))
;;; Generated autoloads from files-x.el
(autoload 'add-file-local-variable "files-x" "\
;;;***
\f
-;;;### (autoloads nil "filesets" "filesets.el" (20999 25770 522517
-;;;;;; 0))
+;;;### (autoloads nil "filesets" "filesets.el" (22092 27717 792268
+;;;;;; 464000))
;;; Generated autoloads from filesets.el
(autoload 'filesets-init "filesets" "\
;;;***
\f
-;;;### (autoloads nil "find-cmd" "find-cmd.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "find-cmd" "find-cmd.el" (22086 11929 746062
+;;;;;; 731000))
;;; Generated autoloads from find-cmd.el
(push (purecopy '(find-cmd 0 6)) package--builtin-versions)
Initiate the building of a find command.
For example:
-\(find-cmd '(prune (name \".svn\" \".git\" \".CVS\"))
- '(and (or (name \"*.pl\" \"*.pm\" \"*.t\")
+\(find-cmd \\='(prune (name \".svn\" \".git\" \".CVS\"))
+ \\='(and (or (name \"*.pl\" \"*.pm\" \"*.t\")
(mtime \"+1\"))
(fstype \"nfs\" \"ufs\"))))
;;;***
\f
-;;;### (autoloads nil "find-dired" "find-dired.el" (20763 30266 231060
-;;;;;; 0))
+;;;### (autoloads nil "find-dired" "find-dired.el" (22086 11929 746062
+;;;;;; 731000))
;;; Generated autoloads from find-dired.el
(autoload 'find-dired "find-dired" "\
(autoload 'find-name-dired "find-dired" "\
Search DIR recursively for files matching the globbing pattern PATTERN,
-and run dired on those files.
+and run Dired on those files.
PATTERN is a shell wildcard (not an Emacs regexp) and need not be quoted.
-The command run (after changing into DIR) is
+The default command run (after changing into DIR) is
- find . -name 'PATTERN' -ls
+ find . -name \\='PATTERN\\=' -ls
+
+See `find-name-arg' to customize the arguments.
\(fn DIR PATTERN)" t nil)
(autoload 'find-grep-dired "find-dired" "\
-Find files in DIR containing a regexp REGEXP and start Dired on output.
+Find files in DIR matching a regexp REGEXP and start Dired on output.
The command run (after changing into DIR) is
find . \\( -type f -exec `grep-program' `find-grep-options' \\
;;;***
\f
-;;;### (autoloads nil "find-file" "find-file.el" (20999 25770 522517
-;;;;;; 0))
+;;;### (autoloads nil "find-file" "find-file.el" (22092 27717 792268
+;;;;;; 464000))
;;; Generated autoloads from find-file.el
(defvar ff-special-constructs `((,(purecopy "^#\\s *\\(include\\|import\\)\\s +[<\"]\\(.*\\)[>\"]") lambda nil (buffer-substring (match-beginning 2) (match-end 2)))) "\
;;;***
\f
-;;;### (autoloads nil "find-func" "emacs-lisp/find-func.el" (20709
-;;;;;; 26818 907104 0))
+;;;### (autoloads nil "find-func" "emacs-lisp/find-func.el" (22086
+;;;;;; 11929 678062 731000))
;;; Generated autoloads from emacs-lisp/find-func.el
(autoload 'find-library "find-func" "\
\(fn KEY)" t nil)
+(autoload 'find-function-on-key-other-window "find-func" "\
+Find, in the other window, the function that KEY invokes.
+See `find-function-on-key'.
+
+\(fn KEY)" t nil)
+
+(autoload 'find-function-on-key-other-frame "find-func" "\
+Find, in the other frame, the function that KEY invokes.
+See `find-function-on-key'.
+
+\(fn KEY)" t nil)
+
(autoload 'find-function-at-point "find-func" "\
Find directly the function at point in the other window.
;;;***
\f
-;;;### (autoloads nil "find-lisp" "find-lisp.el" (20993 35788 926781
-;;;;;; 0))
+;;;### (autoloads nil "find-lisp" "find-lisp.el" (22086 11929 746062
+;;;;;; 731000))
;;; Generated autoloads from find-lisp.el
(autoload 'find-lisp-find-dired "find-lisp" "\
;;;***
\f
-;;;### (autoloads nil "finder" "finder.el" (21031 2230 839140 0))
+;;;### (autoloads nil "finder" "finder.el" (22086 11929 750062 731000))
;;; Generated autoloads from finder.el
(push (purecopy '(finder 1 0)) package--builtin-versions)
;;;***
\f
-;;;### (autoloads nil "flow-ctrl" "flow-ctrl.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "flow-ctrl" "flow-ctrl.el" (22086 11929 750062
+;;;;;; 731000))
;;; Generated autoloads from flow-ctrl.el
(autoload 'enable-flow-control "flow-ctrl" "\
;;;***
\f
-;;;### (autoloads nil "flow-fill" "gnus/flow-fill.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "flow-fill" "gnus/flow-fill.el" (22086 11929
+;;;;;; 774062 731000))
;;; Generated autoloads from gnus/flow-fill.el
(autoload 'fill-flowed-encode "flow-fill" "\
;;;***
\f
-;;;### (autoloads nil "flymake" "progmodes/flymake.el" (21019 11047
-;;;;;; 84796 0))
+;;;### (autoloads nil "flymake" "progmodes/flymake.el" (22092 27718
+;;;;;; 156268 464000))
;;; Generated autoloads from progmodes/flymake.el
(push (purecopy '(flymake 0 3)) package--builtin-versions)
(autoload 'flymake-mode "flymake" "\
-Toggle on-the-fly syntax checking.
-With a prefix argument ARG, enable the mode if ARG is positive,
-and disable it otherwise. If called from Lisp, enable the mode
-if ARG is omitted or nil.
+Toggle Flymake mode on or off.
+With a prefix argument ARG, enable Flymake mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+the mode if ARG is omitted or nil, and toggle it if ARG is `toggle'.
+\\{flymake-mode-map}
\(fn &optional ARG)" t nil)
;;;***
\f
-;;;### (autoloads nil "flyspell" "textmodes/flyspell.el" (20847 51240
-;;;;;; 240216 0))
+;;;### (autoloads nil "flyspell" "textmodes/flyspell.el" (22086 11930
+;;;;;; 314062 731000))
;;; Generated autoloads from textmodes/flyspell.el
(autoload 'flyspell-prog-mode "flyspell" "\
Consider using the `ispell-parser' to check your text. For instance
consider adding:
-\(add-hook 'tex-mode-hook (function (lambda () (setq ispell-parser 'tex))))
+\(add-hook \\='tex-mode-hook (function (lambda () (setq ispell-parser \\='tex))))
in your init file.
\\[flyspell-region] checks all words inside a region.
;;;***
\f
-;;;### (autoloads nil "foldout" "foldout.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "foldout" "foldout.el" (22086 11929 750062
+;;;;;; 731000))
;;; Generated autoloads from foldout.el
(push (purecopy '(foldout 1 10)) package--builtin-versions)
;;;***
\f
-;;;### (autoloads nil "follow" "follow.el" (21049 14338 391345 0))
+;;;### (autoloads nil "follow" "follow.el" (22096 24780 228094 47000))
;;; Generated autoloads from follow.el
(autoload 'turn-on-follow-mode "follow" "\
This means that whenever one window is moved, all the
others will follow. (Hence the name Follow mode.)
-* Should the point (cursor) end up outside a window, another
+* Should point (cursor) end up outside a window, another
window displaying that point is selected, if possible. This
makes it possible to walk between windows using normal cursor
movement commands.
mileage may vary).
To split one large window into two side-by-side windows, the commands
-`\\[split-window-right]' or `M-x follow-delete-other-windows-and-split' can be used.
+`\\[split-window-right]' or `\\[follow-delete-other-windows-and-split]' can be used.
Only windows displayed in the same frame follow each other.
\(fn &optional ARG)" t nil)
+(autoload 'follow-scroll-up "follow" "\
+Scroll text in a Follow mode window chain up.
+
+If called with no ARG, the `next-screen-context-lines' last lines of
+the bottom window in the chain will be visible in the top window.
+
+If called with an argument, scroll ARG lines up.
+Negative ARG means scroll downward.
+
+Works like `scroll-up' when not in Follow mode.
+
+\(fn &optional ARG)" t nil)
+
+(autoload 'follow-scroll-down "follow" "\
+Scroll text in a Follow mode window chain down.
+
+If called with no ARG, the `next-screen-context-lines' top lines of
+the top window in the chain will be visible in the bottom window.
+
+If called with an argument, scroll ARG lines down.
+Negative ARG means scroll upward.
+
+Works like `scroll-down' when not in Follow mode.
+
+\(fn &optional ARG)" t nil)
+
(autoload 'follow-delete-other-windows-and-split "follow" "\
Create two side by side windows and enter Follow mode.
;;;***
\f
-;;;### (autoloads nil "footnote" "mail/footnote.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "footnote" "mail/footnote.el" (22086 11929
+;;;;;; 934062 731000))
;;; Generated autoloads from mail/footnote.el
(push (purecopy '(footnote 0 19)) package--builtin-versions)
;;;***
\f
-;;;### (autoloads nil "forms" "forms.el" (20999 25770 522517 0))
+;;;### (autoloads nil "forms" "forms.el" (22086 11929 754062 731000))
;;; Generated autoloads from forms.el
(autoload 'forms-mode "forms" "\
;;;***
\f
-;;;### (autoloads nil "fortran" "progmodes/fortran.el" (20992 52525
-;;;;;; 458637 0))
+;;;### (autoloads nil "fortran" "progmodes/fortran.el" (22092 27718
+;;;;;; 156268 464000))
;;; Generated autoloads from progmodes/fortran.el
(autoload 'fortran-mode "fortran" "\
Amount of extra indentation for text in full-line comments (default 0).
`fortran-comment-indent-style'
How to indent the text in full-line comments. Allowed values are:
- nil don't change the indentation
- fixed indent to `fortran-comment-line-extra-indent' beyond the
+ nil don't change the indentation
+ `fixed' indent to `fortran-comment-line-extra-indent' beyond the
value of either
`fortran-minimum-statement-indent-fixed' (fixed format) or
`fortran-minimum-statement-indent-tab' (TAB format),
depending on the continuation format in use.
- relative indent to `fortran-comment-line-extra-indent' beyond the
+ `relative' indent to `fortran-comment-line-extra-indent' beyond the
indentation for a line of code.
- (default 'fixed)
+ (default `fixed')
`fortran-comment-indent-char'
Single-character string to be inserted instead of space for
full-line comment indentation (default \" \").
;;;***
\f
-;;;### (autoloads nil "fortune" "play/fortune.el" (20765 36517 595445
-;;;;;; 191000))
+;;;### (autoloads nil "fortune" "play/fortune.el" (22086 11930 126062
+;;;;;; 731000))
;;; Generated autoloads from play/fortune.el
(autoload 'fortune-add-fortune "fortune" "\
;;;***
\f
-;;;### (autoloads nil "frameset" "frameset.el" (21005 64551 555603
-;;;;;; 0))
+;;;### (autoloads nil "frameset" "frameset.el" (22086 11929 754062
+;;;;;; 731000))
;;; Generated autoloads from frameset.el
(defvar frameset-session-filter-alist '((name . :never) (left . frameset-filter-iconified) (minibuffer . frameset-filter-minibuffer) (top . frameset-filter-iconified)) "\
FILTERS is an alist of parameter filters; if nil, the value of
`frameset-filter-alist' is used instead.
-REUSE-FRAMES selects the policy to use to reuse frames when restoring:
- t Reuse existing frames if possible, and delete those not reused.
- nil Restore frameset in new frames and delete existing frames.
- :keep Restore frameset in new frames and keep the existing ones.
- LIST A list of frames to reuse; only these are reused (if possible).
- Remaining frames in this list are deleted; other frames not
- included on the list are left untouched.
+REUSE-FRAMES selects the policy to reuse frames when restoring:
+ t All existing frames can be reused.
+ nil No existing frame can be reused.
+ match Only frames with matching frame ids can be reused.
+ PRED A predicate function; it receives as argument a live frame,
+ and must return non-nil to allow reusing it, nil otherwise.
FORCE-DISPLAY can be:
t Frames are restored in the current display.
nil Frames are restored, if possible, in their original displays.
- :delete Frames in other displays are deleted instead of restored.
+ delete Frames in other displays are deleted instead of restored.
PRED A function called with two arguments, the parameter alist and
the window state (in that order). It must return t, nil or
- `:delete', as above but affecting only the frame that will
+ `delete', as above but affecting only the frame that will
be created from that parameter alist.
FORCE-ONSCREEN can be:
t Force onscreen only those frames that are fully offscreen.
nil Do not force any frame back onscreen.
- :all Force onscreen any frame fully or partially offscreen.
+ all Force onscreen any frame fully or partially offscreen.
PRED A function called with three arguments,
- the live frame just restored,
- a list (LEFT TOP WIDTH HEIGHT), describing the frame,
- a list (LEFT TOP WIDTH HEIGHT), describing the workarea.
It must return non-nil to force the frame onscreen, nil otherwise.
+CLEANUP-FRAMES allows to \"clean up\" the frame list after restoring a frameset:
+ t Delete all frames that were not created or restored upon.
+ nil Keep all frames.
+ FUNC A function called with two arguments:
+ - FRAME, a live frame.
+ - ACTION, which can be one of
+ :rejected Frame existed, but was not a candidate for reuse.
+ :ignored Frame existed, was a candidate, but wasn't reused.
+ :reused Frame existed, was a candidate, and restored upon.
+ :created Frame didn't exist, was created and restored upon.
+ Return value is ignored.
+
Note the timing and scope of the operations described above: REUSE-FRAMES
affects existing frames; PREDICATE, FILTERS and FORCE-DISPLAY affect the frame
-being restored before that happens; and FORCE-ONSCREEN affects the frame once
-it has been restored.
+being restored before that happens; FORCE-ONSCREEN affects the frame once
+it has been restored; and CLEANUP-FRAMES affects all frames alive after the
+restoration, including those that have been reused or created anew.
All keyword parameters default to nil.
-\(fn FRAMESET &key PREDICATE FILTERS REUSE-FRAMES FORCE-DISPLAY FORCE-ONSCREEN)" nil nil)
+\(fn FRAMESET &key PREDICATE FILTERS REUSE-FRAMES FORCE-DISPLAY FORCE-ONSCREEN CLEANUP-FRAMES)" nil nil)
+
+(autoload 'frameset--jump-to-register "frameset" "\
+Restore frameset from DATA stored in register.
+Called from `jump-to-register'. Internal use only.
+
+\(fn DATA)" nil nil)
+
+(autoload 'frameset--print-register "frameset" "\
+Print basic info about frameset stored in DATA.
+Called from `list-registers' and `view-register'. Internal use only.
+
+\(fn DATA)" nil nil)
(autoload 'frameset-to-register "frameset" "\
Store the current frameset in register REGISTER.
Use \\[jump-to-register] to restore the frameset.
Argument is a character, naming the register.
-\(fn REGISTER &optional ARG)" t nil)
+Interactively, reads the register using `register-read-with-preview'.
+
+\(fn REGISTER)" t nil)
;;;***
\f
-;;;### (autoloads nil "gamegrid" "play/gamegrid.el" (20752 26925
-;;;;;; 124734 677000))
+;;;### (autoloads nil "gamegrid" "play/gamegrid.el" (22086 11930
+;;;;;; 126062 731000))
;;; Generated autoloads from play/gamegrid.el
(push (purecopy '(gamegrid 1 2)) package--builtin-versions)
;;;***
\f
-;;;### (autoloads nil "gdb-mi" "progmodes/gdb-mi.el" (21129 63287
-;;;;;; 644820 0))
+;;;### (autoloads nil "gdb-mi" "progmodes/gdb-mi.el" (22092 27718
+;;;;;; 172268 464000))
;;; Generated autoloads from progmodes/gdb-mi.el
(defvar gdb-enable-debug nil "\
;;;***
\f
-;;;### (autoloads nil "generic" "emacs-lisp/generic.el" (20928 13222
-;;;;;; 500272 0))
+;;;### (autoloads nil "generic" "emacs-lisp/generic.el" (22086 11929
+;;;;;; 678062 731000))
;;; Generated autoloads from emacs-lisp/generic.el
(defvar generic-mode-list nil "\
\(fn MODE COMMENT-LIST KEYWORD-LIST FONT-LOCK-LIST AUTO-MODE-LIST FUNCTION-LIST &optional DOCSTRING)" nil t)
-(put 'define-generic-mode 'lisp-indent-function '1)
+(function-put 'define-generic-mode 'lisp-indent-function '1)
-(put 'define-generic-mode 'doc-string-elt '7)
+(function-put 'define-generic-mode 'doc-string-elt '7)
(autoload 'generic-mode-internal "generic" "\
Go into the generic mode MODE.
;;;***
\f
-;;;### (autoloads nil "glasses" "progmodes/glasses.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "glasses" "progmodes/glasses.el" (22086 11930
+;;;;;; 178062 731000))
;;; Generated autoloads from progmodes/glasses.el
(autoload 'glasses-mode "glasses" "\
;;;***
\f
-;;;### (autoloads nil "gmm-utils" "gnus/gmm-utils.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "gmm-utils" "gnus/gmm-utils.el" (22086 11929
+;;;;;; 778062 731000))
;;; Generated autoloads from gnus/gmm-utils.el
(autoload 'gmm-regexp-concat "gmm-utils" "\
;;;***
\f
-;;;### (autoloads nil "gnus" "gnus/gnus.el" (21002 1963 769129 0))
+;;;### (autoloads nil "gnus" "gnus/gnus.el" (22086 11929 810062 731000))
;;; Generated autoloads from gnus/gnus.el
(push (purecopy '(gnus 5 13)) package--builtin-versions)
(when (fboundp 'custom-autoload)
;;;***
\f
-;;;### (autoloads nil "gnus-agent" "gnus/gnus-agent.el" (21048 47760
-;;;;;; 436258 0))
+;;;### (autoloads nil "gnus-agent" "gnus/gnus-agent.el" (22086 11929
+;;;;;; 778062 731000))
;;; Generated autoloads from gnus/gnus-agent.el
(autoload 'gnus-unplugged "gnus-agent" "\
;;;***
\f
-;;;### (autoloads nil "gnus-art" "gnus/gnus-art.el" (21141 54458
-;;;;;; 609734 0))
+;;;### (autoloads nil "gnus-art" "gnus/gnus-art.el" (22086 11929
+;;;;;; 782062 731000))
;;; Generated autoloads from gnus/gnus-art.el
(autoload 'gnus-article-prepare-display "gnus-art" "\
;;;***
\f
-;;;### (autoloads nil "gnus-bookmark" "gnus/gnus-bookmark.el" (21040
-;;;;;; 17194 398147 0))
+;;;### (autoloads nil "gnus-bookmark" "gnus/gnus-bookmark.el" (22086
+;;;;;; 11929 782062 731000))
;;; Generated autoloads from gnus/gnus-bookmark.el
(autoload 'gnus-bookmark-set "gnus-bookmark" "\
;;;***
\f
-;;;### (autoloads nil "gnus-cache" "gnus/gnus-cache.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "gnus-cache" "gnus/gnus-cache.el" (22086 11929
+;;;;;; 782062 731000))
;;; Generated autoloads from gnus/gnus-cache.el
(autoload 'gnus-jog-cache "gnus-cache" "\
;;;***
\f
-;;;### (autoloads nil "gnus-delay" "gnus/gnus-delay.el" (20988 22031
-;;;;;; 837044 0))
+;;;### (autoloads nil "gnus-delay" "gnus/gnus-delay.el" (22086 11929
+;;;;;; 786062 731000))
;;; Generated autoloads from gnus/gnus-delay.el
(autoload 'gnus-delay-article "gnus-delay" "\
;;;***
\f
-;;;### (autoloads nil "gnus-diary" "gnus/gnus-diary.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "gnus-diary" "gnus/gnus-diary.el" (22086 11929
+;;;;;; 786062 731000))
;;; Generated autoloads from gnus/gnus-diary.el
(autoload 'gnus-user-format-function-d "gnus-diary" "\
;;;***
\f
-;;;### (autoloads nil "gnus-dired" "gnus/gnus-dired.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "gnus-dired" "gnus/gnus-dired.el" (22086 11929
+;;;;;; 786062 731000))
;;; Generated autoloads from gnus/gnus-dired.el
(autoload 'turn-on-gnus-dired-mode "gnus-dired" "\
;;;***
\f
-;;;### (autoloads nil "gnus-draft" "gnus/gnus-draft.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "gnus-draft" "gnus/gnus-draft.el" (22086 11929
+;;;;;; 786062 731000))
;;; Generated autoloads from gnus/gnus-draft.el
(autoload 'gnus-draft-reminder "gnus-draft" "\
;;;***
\f
-;;;### (autoloads nil "gnus-fun" "gnus/gnus-fun.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "gnus-fun" "gnus/gnus-fun.el" (22086 11929
+;;;;;; 786062 731000))
;;; Generated autoloads from gnus/gnus-fun.el
+(autoload 'gnus--random-face-with-type "gnus-fun" "\
+Return file from DIR with extension EXT, omitting matches of OMIT, processed by FUN.
+
+\(fn DIR EXT OMIT FUN)" nil nil)
+
+(autoload 'message-goto-eoh "message" nil t)
+
(autoload 'gnus-random-x-face "gnus-fun" "\
Return X-Face header data chosen randomly from `gnus-x-face-directory'.
+Files matching `gnus-x-face-omit-files' are not considered.
+
\(fn)" t nil)
(autoload 'gnus-insert-random-x-face-header "gnus-fun" "\
\(fn)" t nil)
(autoload 'gnus-x-face-from-file "gnus-fun" "\
-Insert an X-Face header based on an image file.
+Insert an X-Face header based on an image FILE.
Depending on `gnus-convert-image-to-x-face-command' it may accept
different input formats.
\(fn FILE)" t nil)
(autoload 'gnus-face-from-file "gnus-fun" "\
-Return a Face header based on an image file.
+Return a Face header based on an image FILE.
Depending on `gnus-convert-image-to-face-command' it may accept
different input formats.
\(fn FILE)" nil nil)
+(autoload 'gnus-random-face "gnus-fun" "\
+Return randomly chosen Face from `gnus-face-directory'.
+
+Files matching `gnus-face-omit-files' are not considered.
+
+\(fn)" t nil)
+
+(autoload 'gnus-insert-random-face-header "gnus-fun" "\
+Insert a random Face header from `gnus-face-directory'.
+
+\(fn)" nil nil)
+
;;;***
\f
-;;;### (autoloads nil "gnus-gravatar" "gnus/gnus-gravatar.el" (20874
-;;;;;; 65006 176325 548000))
+;;;### (autoloads nil "gnus-gravatar" "gnus/gnus-gravatar.el" (22086
+;;;;;; 11929 786062 731000))
;;; Generated autoloads from gnus/gnus-gravatar.el
(autoload 'gnus-treat-from-gravatar "gnus-gravatar" "\
;;;***
\f
-;;;### (autoloads nil "gnus-group" "gnus/gnus-group.el" (21104 56491
-;;;;;; 538513 0))
+;;;### (autoloads nil "gnus-group" "gnus/gnus-group.el" (22086 11929
+;;;;;; 790062 731000))
;;; Generated autoloads from gnus/gnus-group.el
(autoload 'gnus-fetch-group "gnus-group" "\
;;;***
\f
-;;;### (autoloads nil "gnus-html" "gnus/gnus-html.el" (21141 54458
-;;;;;; 609734 0))
+;;;### (autoloads nil "gnus-html" "gnus/gnus-html.el" (22086 11929
+;;;;;; 790062 731000))
;;; Generated autoloads from gnus/gnus-html.el
(autoload 'gnus-article-html "gnus-html" "\
;;;***
\f
-;;;### (autoloads nil "gnus-kill" "gnus/gnus-kill.el" (21040 17194
-;;;;;; 398147 0))
+;;;### (autoloads nil "gnus-kill" "gnus/gnus-kill.el" (22086 11929
+;;;;;; 790062 731000))
;;; Generated autoloads from gnus/gnus-kill.el
(defalias 'gnus-batch-kill 'gnus-batch-score)
;;;***
\f
-;;;### (autoloads nil "gnus-ml" "gnus/gnus-ml.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "gnus-ml" "gnus/gnus-ml.el" (22086 11929 790062
+;;;;;; 731000))
;;; Generated autoloads from gnus/gnus-ml.el
(autoload 'turn-on-gnus-mailing-list-mode "gnus-ml" "\
;;;***
\f
-;;;### (autoloads nil "gnus-mlspl" "gnus/gnus-mlspl.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "gnus-mlspl" "gnus/gnus-mlspl.el" (22092 27717
+;;;;;; 816268 464000))
;;; Generated autoloads from gnus/gnus-mlspl.el
(autoload 'gnus-group-split-setup "gnus-mlspl" "\
If CATCH-ALL is nil, no catch-all handling is performed, regardless of
catch-all marks in group parameters. Otherwise, if there is no
selected group whose SPLIT-REGEXP matches the empty string, nor is
-there a selected group whose SPLIT-SPEC is 'catch-all, this fancy
+there a selected group whose SPLIT-SPEC is `catch-all', this fancy
split (say, a group name) will be appended to the returned SPLIT list,
-as the last element of a '| SPLIT.
+as the last element of a `|' SPLIT.
For example, given the following group parameters:
;;;***
\f
-;;;### (autoloads nil "gnus-msg" "gnus/gnus-msg.el" (20974 22577
-;;;;;; 548213 0))
+;;;### (autoloads nil "gnus-msg" "gnus/gnus-msg.el" (22086 11929
+;;;;;; 794062 731000))
;;; Generated autoloads from gnus/gnus-msg.el
(autoload 'gnus-msg-mail "gnus-msg" "\
;;;***
\f
;;;### (autoloads nil "gnus-notifications" "gnus/gnus-notifications.el"
-;;;;;; (20886 939 575794 0))
+;;;;;; (22086 11929 794062 731000))
;;; Generated autoloads from gnus/gnus-notifications.el
(autoload 'gnus-notifications "gnus-notifications" "\
;;;***
\f
-;;;### (autoloads nil "gnus-picon" "gnus/gnus-picon.el" (20874 65006
-;;;;;; 672942 217000))
+;;;### (autoloads nil "gnus-picon" "gnus/gnus-picon.el" (22086 11929
+;;;;;; 794062 731000))
;;; Generated autoloads from gnus/gnus-picon.el
(autoload 'gnus-treat-from-picon "gnus-picon" "\
;;;***
\f
-;;;### (autoloads nil "gnus-range" "gnus/gnus-range.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "gnus-range" "gnus/gnus-range.el" (22086 11929
+;;;;;; 794062 731000))
;;; Generated autoloads from gnus/gnus-range.el
(autoload 'gnus-sorted-difference "gnus-range" "\
;;;***
\f
-;;;### (autoloads nil "gnus-registry" "gnus/gnus-registry.el" (20955
-;;;;;; 58152 201869 0))
+;;;### (autoloads nil "gnus-registry" "gnus/gnus-registry.el" (22086
+;;;;;; 11929 794062 731000))
;;; Generated autoloads from gnus/gnus-registry.el
(autoload 'gnus-registry-initialize "gnus-registry" "\
;;;***
\f
-;;;### (autoloads nil "gnus-sieve" "gnus/gnus-sieve.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "gnus-sieve" "gnus/gnus-sieve.el" (22086 11929
+;;;;;; 794062 731000))
;;; Generated autoloads from gnus/gnus-sieve.el
(autoload 'gnus-sieve-update "gnus-sieve" "\
;;;***
\f
-;;;### (autoloads nil "gnus-spec" "gnus/gnus-spec.el" (21042 58928
-;;;;;; 39127 0))
+;;;### (autoloads nil "gnus-spec" "gnus/gnus-spec.el" (22086 11929
+;;;;;; 798062 731000))
;;; Generated autoloads from gnus/gnus-spec.el
(autoload 'gnus-update-format "gnus-spec" "\
;;;***
\f
-;;;### (autoloads nil "gnus-start" "gnus/gnus-start.el" (20986 60038
-;;;;;; 720063 0))
+;;;### (autoloads nil "gnus-start" "gnus/gnus-start.el" (22086 11929
+;;;;;; 798062 731000))
;;; Generated autoloads from gnus/gnus-start.el
(autoload 'gnus-declare-backend "gnus-start" "\
;;;***
\f
-;;;### (autoloads nil "gnus-sum" "gnus/gnus-sum.el" (21048 47760
-;;;;;; 436258 0))
+;;;### (autoloads nil "gnus-sum" "gnus/gnus-sum.el" (22086 11929
+;;;;;; 802062 731000))
;;; Generated autoloads from gnus/gnus-sum.el
(autoload 'gnus-summary-bookmark-jump "gnus-sum" "\
;;;***
\f
-;;;### (autoloads nil "gnus-sync" "gnus/gnus-sync.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "gnus-sync" "gnus/gnus-sync.el" (22086 11929
+;;;;;; 802062 731000))
;;; Generated autoloads from gnus/gnus-sync.el
(autoload 'gnus-sync-initialize "gnus-sync" "\
;;;***
\f
-;;;### (autoloads nil "gnus-win" "gnus/gnus-win.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "gnus-win" "gnus/gnus-win.el" (22086 11929
+;;;;;; 806062 731000))
;;; Generated autoloads from gnus/gnus-win.el
(autoload 'gnus-add-configuration "gnus-win" "\
;;;***
\f
-;;;### (autoloads nil "gnutls" "net/gnutls.el" (21049 14338 391345
-;;;;;; 0))
+;;;### (autoloads nil "gnutls" "net/gnutls.el" (22086 11929 994062
+;;;;;; 731000))
;;; Generated autoloads from net/gnutls.el
(defvar gnutls-min-prime-bits 256 "\
;;;***
\f
-;;;### (autoloads nil "gomoku" "play/gomoku.el" (21139 62016 336404
-;;;;;; 0))
+;;;### (autoloads nil "gomoku" "play/gomoku.el" (22086 11930 126062
+;;;;;; 731000))
;;; Generated autoloads from play/gomoku.el
(autoload 'gomoku "gomoku" "\
;;;***
\f
-;;;### (autoloads nil "goto-addr" "net/goto-addr.el" (20766 6456
-;;;;;; 368550 0))
+;;;### (autoloads nil "goto-addr" "net/goto-addr.el" (22086 11929
+;;;;;; 994062 731000))
;;; Generated autoloads from net/goto-addr.el
(define-obsolete-function-alias 'goto-address-at-mouse 'goto-address-at-point "22.1")
;;;***
\f
-;;;### (autoloads nil "gravatar" "gnus/gravatar.el" (20901 54695
-;;;;;; 989166 0))
+;;;### (autoloads nil "gravatar" "gnus/gravatar.el" (22086 11929
+;;;;;; 810062 731000))
;;; Generated autoloads from gnus/gravatar.el
(autoload 'gravatar-retrieve "gravatar" "\
;;;***
\f
-;;;### (autoloads nil "grep" "progmodes/grep.el" (20896 36774 886399
-;;;;;; 0))
+;;;### (autoloads nil "grep" "progmodes/grep.el" (22086 11930 178062
+;;;;;; 731000))
;;; Generated autoloads from progmodes/grep.el
(defvar grep-window-height nil "\
(custom-autoload 'grep-setup-hook "grep" t)
-(defconst grep-regexp-alist '(("^\\(.+?\\)\\(:[ ]*\\)\\([1-9][0-9]*\\)\\2" 1 3 ((lambda nil (when grep-highlight-matches (let* ((beg (match-end 0)) (end (save-excursion (goto-char beg) (line-end-position))) (mbeg (text-property-any beg end 'font-lock-face grep-match-face))) (when mbeg (- mbeg beg))))) lambda nil (when grep-highlight-matches (let* ((beg (match-end 0)) (end (save-excursion (goto-char beg) (line-end-position))) (mbeg (text-property-any beg end 'font-lock-face grep-match-face)) (mend (and mbeg (next-single-property-change mbeg 'font-lock-face nil end)))) (when mend (- mend beg)))))) ("^Binary file \\(.+\\) matches$" 1 nil nil 0 1)) "\
+(defconst grep-regexp-alist '(("^\\(.*?[^/\n]\\):[ ]*\\([1-9][0-9]*\\)[ ]*:" 1 2 ((lambda nil (when grep-highlight-matches (let* ((beg (match-end 0)) (end (save-excursion (goto-char beg) (line-end-position))) (mbeg (text-property-any beg end 'font-lock-face grep-match-face))) (when mbeg (- mbeg beg))))) lambda nil (when grep-highlight-matches (let* ((beg (match-end 0)) (end (save-excursion (goto-char beg) (line-end-position))) (mbeg (text-property-any beg end 'font-lock-face grep-match-face)) (mend (and mbeg (next-single-property-change mbeg 'font-lock-face nil end)))) (when mend (- mend beg)))))) ("^Binary file \\(.+\\) matches$" 1 nil nil 0 1)) "\
Regexp used to match grep hits. See `compilation-error-regexp-alist'.")
(defvar grep-program (purecopy "grep") "\
This variable's value takes effect when `grep-compute-defaults' is called.")
(defvar find-program (purecopy "find") "\
-The default find program for `grep-find-command'.
-This variable's value takes effect when `grep-compute-defaults' is called.")
+The default find program.
+This is used by commands like `grep-find-command', `find-dired'
+and others.")
(defvar xargs-program (purecopy "xargs") "\
The default xargs program for `grep-find-command'.
\(fn)" nil nil)
(autoload 'grep "grep" "\
-Run grep, with user-specified args, and collect output in a buffer.
-While grep runs asynchronously, you can use \\[next-error] (M-x next-error),
-or \\<grep-mode-map>\\[compile-goto-error] in the *grep* buffer, to go to the lines where grep found
-matches. To kill the grep job before it finishes, type \\[kill-compilation].
+Run Grep with user-specified COMMAND-ARGS, collect output in a buffer.
+While Grep runs asynchronously, you can use \\[next-error] (M-x next-error),
+or \\<grep-mode-map>\\[compile-goto-error] in the *grep* buffer, to go to the lines where Grep found
+matches. To kill the Grep job before it finishes, type \\[kill-compilation].
+
+Noninteractively, COMMAND-ARGS should specify the Grep command-line
+arguments.
For doing a recursive `grep', see the `rgrep' command. For running
-`grep' in a specific directory, see `lgrep'.
+Grep in a specific directory, see `lgrep'.
This command uses a special history list for its COMMAND-ARGS, so you
can easily repeat a grep command.
-A prefix argument says to default the argument based upon the current
-tag the cursor is over, substituting it into the last grep command
-in the grep command history (or into `grep-command' if that history
+A prefix argument says to default the COMMAND-ARGS based on the current
+tag the cursor is over, substituting it into the last Grep command
+in the Grep command history (or into `grep-command' if that history
list is empty).
\(fn COMMAND-ARGS)" t nil)
Like `rgrep' but uses `zgrep' for `grep-program', sets the default
file name to `*.gz', and sets `grep-highlight-matches' to `always'.
-\(fn REGEXP &optional FILES DIR CONFIRM GREP-FIND-TEMPLATE)" t nil)
+\(fn REGEXP &optional FILES DIR CONFIRM TEMPLATE)" t nil)
(defalias 'rzgrep 'zrgrep)
;;;***
\f
-;;;### (autoloads nil "gs" "gs.el" (20709 26818 907104 0))
+;;;### (autoloads nil "gs" "gs.el" (22086 11929 854062 731000))
;;; Generated autoloads from gs.el
(autoload 'gs-load-image "gs" "\
;;;***
\f
-;;;### (autoloads nil "gud" "progmodes/gud.el" (21126 691 872266
-;;;;;; 0))
+;;;### (autoloads nil "gud" "progmodes/gud.el" (22092 27718 188268
+;;;;;; 464000))
;;; Generated autoloads from progmodes/gud.el
(autoload 'gud-gdb "gud" "\
\(fn COMMAND-LINE)" t nil)
+(autoload 'guiler "gud" "\
+Run guiler on program FILE in buffer `*gud-FILE*'.
+The directory containing FILE becomes the initial working directory
+and source-file directory for your debugger.
+
+\(fn COMMAND-LINE)" t nil)
+
(autoload 'jdb "gud" "\
Run jdb with command line COMMAND-LINE in a buffer.
The buffer is named \"*gud*\" if no initial class is given or
;;;***
\f
-;;;### (autoloads nil "gv" "emacs-lisp/gv.el" (21114 9531 52922 0))
+;;;### (autoloads nil "gv" "emacs-lisp/gv.el" (22099 26170 382017
+;;;;;; 16000))
;;; Generated autoloads from emacs-lisp/gv.el
(autoload 'gv-get "gv" "\
\(fn (GETTER SETTER) PLACE &rest BODY)" nil t)
-(put 'gv-letplace 'lisp-indent-function '2)
+(function-put 'gv-letplace 'lisp-indent-function '2)
(autoload 'gv-define-expander "gv" "\
Use HANDLER to handle NAME as a generalized var.
\(fn NAME HANDLER)" nil t)
-(put 'gv-define-expander 'lisp-indent-function '1)
+(function-put 'gv-define-expander 'lisp-indent-function '1)
(autoload 'gv--defun-declaration "gv" "\
\(fn SYMBOL NAME ARGS HANDLER &optional FIX)" nil nil)
-(push `(gv-expander ,(apply-partially #'gv--defun-declaration 'gv-expander)) defun-declarations-alist)
+(or (assq 'gv-expander defun-declarations-alist) (let ((x `(gv-expander ,(apply-partially #'gv--defun-declaration 'gv-expander)))) (push x macro-declarations-alist) (push x defun-declarations-alist)))
-(push `(gv-setter ,(apply-partially #'gv--defun-declaration 'gv-setter)) defun-declarations-alist)
+(or (assq 'gv-setter defun-declarations-alist) (push `(gv-setter ,(apply-partially #'gv--defun-declaration 'gv-setter)) defun-declarations-alist))
(autoload 'gv-define-setter "gv" "\
Define a setter method for generalized variable NAME.
The first arg in ARGLIST (the one that receives VAL) receives an expression
which can do arbitrary things, whereas the other arguments are all guaranteed
to be pure and copyable. Example use:
- (gv-define-setter aref (v a i) `(aset ,a ,i ,v))
+ (gv-define-setter aref (v a i) \\=`(aset ,a ,i ,v))
\(fn NAME ARGLIST &rest BODY)" nil t)
-(put 'gv-define-setter 'lisp-indent-function '2)
+(function-put 'gv-define-setter 'lisp-indent-function '2)
(autoload 'gv-define-simple-setter "gv" "\
Define a simple setter method for generalized variable NAME.
(autoload 'gv-ref "gv" "\
Return a reference to PLACE.
This is like the `&' operator of the C language.
+Note: this only works reliably with lexical binding mode, except for very
+simple PLACEs such as (function-symbol \\='foo) which will also work in dynamic
+binding mode.
\(fn PLACE)" nil t)
;;;***
\f
-;;;### (autoloads nil "handwrite" "play/handwrite.el" (20791 9657
-;;;;;; 561026 0))
+;;;### (autoloads nil "handwrite" "play/handwrite.el" (22086 11930
+;;;;;; 130062 731000))
;;; Generated autoloads from play/handwrite.el
(autoload 'handwrite "handwrite" "\
;;;***
\f
-;;;### (autoloads nil "hanoi" "play/hanoi.el" (20478 3673 653810
-;;;;;; 0))
+;;;### (autoloads nil "hanoi" "play/hanoi.el" (22086 11930 130062
+;;;;;; 731000))
;;; Generated autoloads from play/hanoi.el
(autoload 'hanoi "hanoi" "\
;;;***
\f
-;;;### (autoloads nil "hashcash" "mail/hashcash.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "hashcash" "mail/hashcash.el" (22092 27717
+;;;;;; 880268 464000))
;;; Generated autoloads from mail/hashcash.el
(autoload 'hashcash-insert-payment "hashcash" "\
;;;***
\f
-;;;### (autoloads nil "help-at-pt" "help-at-pt.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "help-at-pt" "help-at-pt.el" (22086 11929 854062
+;;;;;; 731000))
;;; Generated autoloads from help-at-pt.el
(autoload 'help-at-pt-string "help-at-pt" "\
;;;***
\f
-;;;### (autoloads nil "help-fns" "help-fns.el" (20924 16196 967284
-;;;;;; 0))
+;;;### (autoloads nil "help-fns" "help-fns.el" (22101 42694 89526
+;;;;;; 804000))
;;; Generated autoloads from help-fns.el
(autoload 'describe-function "help-fns" "\
alternatively, it can be a function definition.
If TYPE is `defvar', search for a variable definition.
If TYPE is `defface', search for a face definition.
-If TYPE is the value returned by `symbol-function' for a function symbol,
- search for a function definition.
+If TYPE is not a symbol, search for a function definition.
The return value is the absolute name of a readable file where OBJECT is
defined. If several such files exist, preference is given to a file
\(fn VARIABLE &optional BUFFER FRAME)" t nil)
+(autoload 'describe-symbol "help-fns" "\
+Display the full documentation of SYMBOL.
+Will show the info of SYMBOL as a function, variable, and/or face.
+Optional arguments BUFFER and FRAME specify for which buffer and
+frame to show the information about SYMBOL; they default to the
+current buffer and the selected frame, respectively.
+
+\(fn SYMBOL &optional BUFFER FRAME)" t nil)
+
(autoload 'describe-syntax "help-fns" "\
Describe the syntax specifications in the syntax table of BUFFER.
The descriptions are inserted in a help buffer, which is then displayed.
;;;***
\f
-;;;### (autoloads nil "help-macro" "help-macro.el" (20992 52525 458637
-;;;;;; 0))
+;;;### (autoloads nil "help-macro" "help-macro.el" (22086 11929 854062
+;;;;;; 731000))
;;; Generated autoloads from help-macro.el
(defvar three-step-help nil "\
;;;***
\f
-;;;### (autoloads nil "help-mode" "help-mode.el" (21048 47760 436258
-;;;;;; 0))
+;;;### (autoloads nil "help-mode" "help-mode.el" (22086 11929 854062
+;;;;;; 731000))
;;; Generated autoloads from help-mode.el
(autoload 'help-mode "help-mode" "\
\(fn)" t nil)
(autoload 'help-mode-setup "help-mode" "\
-
+Enter Help Mode in the current buffer.
\(fn)" nil nil)
(autoload 'help-mode-finish "help-mode" "\
-
+Finalize Help Mode setup in current buffer.
\(fn)" nil nil)
\(fn FROM TO)" nil nil)
+(define-obsolete-function-alias 'help-xref-interned 'describe-symbol "25.1")
+
(autoload 'help-bookmark-jump "help-mode" "\
Jump to help-mode bookmark BOOKMARK.
Handler function for record returned by `help-bookmark-make-record'.
;;;***
\f
-;;;### (autoloads nil "helper" "emacs-lisp/helper.el" (20992 52525
-;;;;;; 458637 0))
+;;;### (autoloads nil "helper" "emacs-lisp/helper.el" (22086 11929
+;;;;;; 678062 731000))
;;; Generated autoloads from emacs-lisp/helper.el
(autoload 'Helper-describe-bindings "helper" "\
;;;***
\f
-;;;### (autoloads nil "hexl" "hexl.el" (20763 30266 231060 0))
+;;;### (autoloads nil "hexl" "hexl.el" (22086 11929 858062 731000))
;;; Generated autoloads from hexl.el
(autoload 'hexl-mode "hexl" "\
Each line in the buffer has an \"address\" (displayed in hexadecimal)
representing the offset into the file that the characters on this line
are at and 16 characters from the file (displayed as hexadecimal
-values grouped every `hexl-bits' bits) and as their ASCII values.
+values grouped every `hexl-bits' bits, and as their ASCII values).
If any of the characters (displayed as ASCII characters) are
-unprintable (control or meta characters) they will be replaced as
+unprintable (control or meta characters) they will be replaced by
periods.
If `hexl-mode' is invoked with an argument the buffer is assumed to be
A sample format:
- HEX ADDR: 0001 0203 0405 0607 0809 0a0b 0c0d 0e0f ASCII-TEXT
+ HEX ADDR: 0011 2233 4455 6677 8899 aabb ccdd eeff ASCII-TEXT
-------- ---- ---- ---- ---- ---- ---- ---- ---- ----------------
00000000: 5468 6973 2069 7320 6865 786c 2d6d 6f64 This is hexl-mod
00000010: 652e 2020 4561 6368 206c 696e 6520 7265 e. Each line re
000000b0: 7461 626c 6520 6368 6172 6163 7465 7220 table character
000000c0: 7265 6769 6f6e 2e0a region..
-Movement is as simple as movement in a normal Emacs text buffer. Most
-cursor movement bindings are the same: use \\[hexl-backward-char], \\[hexl-forward-char], \\[hexl-next-line], and \\[hexl-previous-line]
+Movement is as simple as movement in a normal Emacs text buffer.
+Most cursor movement bindings are the same: use \\[hexl-backward-char], \\[hexl-forward-char], \\[hexl-next-line], and \\[hexl-previous-line]
to move the cursor left, right, down, and up.
Advanced cursor movement commands (ala \\[hexl-beginning-of-line], \\[hexl-end-of-line], \\[hexl-beginning-of-buffer], and \\[hexl-end-of-buffer]) are
\\[hexl-insert-decimal-char] will insert a given decimal value (if it is between 0 and 255)
into the buffer at the current point.
-\\[hexl-mode-exit] will exit hexl-mode.
+\\[hexl-mode-exit] will exit `hexl-mode'.
Note: saving the file with any of the usual Emacs commands
will actually convert it back to binary format while saving.
;;;***
\f
-;;;### (autoloads nil "hi-lock" "hi-lock.el" (20908 27948 216644
-;;;;;; 0))
+;;;### (autoloads nil "hi-lock" "hi-lock.el" (22092 27717 860268
+;;;;;; 464000))
;;; Generated autoloads from hi-lock.el
(autoload 'hi-lock-mode "hi-lock" "\
(See `font-lock-keywords'.) They may be edited and re-loaded with \\[hi-lock-find-patterns],
any valid `font-lock-keywords' form is acceptable. When a file is
loaded the patterns are read if `hi-lock-file-patterns-policy' is
- 'ask and the user responds y to the prompt, or if
+ `ask' and the user responds y to the prompt, or if
`hi-lock-file-patterns-policy' is bound to a function and that
function returns t.
(autoload 'hi-lock-line-face-buffer "hi-lock" "\
Set face of all lines containing a match of REGEXP to FACE.
-Interactively, prompt for REGEXP then FACE. Use
-`hi-lock-read-regexp-defaults-function' to retrieve default
-value(s) of REGEXP. Use the global history list for FACE.
+Interactively, prompt for REGEXP using `read-regexp', then FACE.
+Use the global history list for FACE.
Use Font lock mode, if enabled, to highlight REGEXP. Otherwise,
use overlays for highlighting. If overlays are used, the
(autoload 'hi-lock-face-buffer "hi-lock" "\
Set face of each match of REGEXP to FACE.
-Interactively, prompt for REGEXP then FACE. Use
-`hi-lock-read-regexp-defaults-function' to retrieve default
-value(s) REGEXP. Use the global history list for FACE.
+Interactively, prompt for REGEXP using `read-regexp', then FACE.
+Use the global history list for FACE.
Use Font lock mode, if enabled, to highlight REGEXP. Otherwise,
use overlays for highlighting. If overlays are used, the
(autoload 'hi-lock-face-phrase-buffer "hi-lock" "\
Set face of each match of phrase REGEXP to FACE.
-Interactively, prompt for REGEXP then FACE. Use
-`hi-lock-read-regexp-defaults-function' to retrieve default
-value(s) of REGEXP. Use the global history list for FACE. When
-called interactively, replace whitespace in user provided regexp
-with arbitrary whitespace and make initial lower-case letters
-case-insensitive before highlighting with `hi-lock-set-pattern'.
+Interactively, prompt for REGEXP using `read-regexp', then FACE.
+Use the global history list for FACE.
+
+When called interactively, replace whitespace in user-provided
+regexp with arbitrary whitespace, and make initial lower-case
+letters case-insensitive, before highlighting with `hi-lock-set-pattern'.
Use Font lock mode, if enabled, to highlight REGEXP. Otherwise,
use overlays for highlighting. If overlays are used, the
(defalias 'highlight-symbol-at-point 'hi-lock-face-symbol-at-point)
(autoload 'hi-lock-face-symbol-at-point "hi-lock" "\
-Set face of each match of the symbol at point.
-Use `find-tag-default-as-regexp' to retrieve the symbol at point.
-Use non-nil `hi-lock-auto-select-face' to retrieve the next face
-from `hi-lock-face-defaults' automatically.
+Highlight each instance of the symbol at point.
+Uses the next face from `hi-lock-face-defaults' without prompting,
+unless you use a prefix argument.
+Uses `find-tag-default-as-symbol-regexp' to retrieve the symbol at point.
-Use Font lock mode, if enabled, to highlight symbol at point.
-Otherwise, use overlays for highlighting. If overlays are used,
-the highlighting will not update as you type.
+This uses Font lock mode if it is enabled; otherwise it uses overlays,
+in which case the highlighting will not update as you type.
\(fn)" t nil)
;;;***
\f
-;;;### (autoloads nil "hideif" "progmodes/hideif.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "hideif" "progmodes/hideif.el" (22092 27718
+;;;;;; 188268 464000))
;;; Generated autoloads from progmodes/hideif.el
(autoload 'hide-ifdef-mode "hideif" "\
Several variables affect how the hiding is done:
`hide-ifdef-env'
- An association list of defined and undefined symbols for the
- current buffer. Initially, the global value of `hide-ifdef-env'
- is used.
+ An association list of defined and undefined symbols for the
+ current project. Initially, the global value of `hide-ifdef-env'
+ is used. This variable was a buffer-local variable, which limits
+ hideif to parse only one C/C++ file at a time. We've extended
+ hideif to support parsing a C/C++ project containing multiple C/C++
+ source files opened simultaneously in different buffers. Therefore
+ `hide-ifdef-env' can no longer be buffer local but must be global.
`hide-ifdef-define-alist'
- An association list of defined symbol lists.
+ An association list of defined symbol lists.
Use `hide-ifdef-set-define-alist' to save the current `hide-ifdef-env'
and `hide-ifdef-use-define-alist' to set the current `hide-ifdef-env'
from one of the lists in `hide-ifdef-define-alist'.
`hide-ifdef-lines'
- Set to non-nil to not show #if, #ifdef, #ifndef, #else, and
- #endif lines when hiding.
+ Set to non-nil to not show #if, #ifdef, #ifndef, #else, and
+ #endif lines when hiding.
`hide-ifdef-initially'
- Indicates whether `hide-ifdefs' should be called when Hide-Ifdef mode
- is activated.
+ Indicates whether `hide-ifdefs' should be called when Hide-Ifdef mode
+ is activated.
`hide-ifdef-read-only'
- Set to non-nil if you want to make buffers read only while hiding.
- After `show-ifdefs', read-only status is restored to previous value.
+ Set to non-nil if you want to make buffers read only while hiding.
+ After `show-ifdefs', read-only status is restored to previous value.
\\{hide-ifdef-mode-map}
;;;***
\f
-;;;### (autoloads nil "hideshow" "progmodes/hideshow.el" (20791 9657
-;;;;;; 561026 0))
+;;;### (autoloads nil "hideshow" "progmodes/hideshow.el" (22093 48588
+;;;;;; 580393 539000))
;;; Generated autoloads from progmodes/hideshow.el
(defvar hs-special-modes-alist (mapcar 'purecopy '((c-mode "{" "}" "/[*/]" nil nil) (c++-mode "{" "}" "/[*/]" nil nil) (bibtex-mode ("@\\S(*\\(\\s(\\)" 1)) (java-mode "{" "}" "/[*/]" nil nil) (js-mode "{" "}" "/[*/]" nil))) "\
When hideshow minor mode is on, the menu bar is augmented with hideshow
commands and the hideshow commands are enabled.
-The value '(hs . t) is added to `buffer-invisibility-spec'.
+The value (hs . t) is added to `buffer-invisibility-spec'.
The main commands are: `hs-hide-all', `hs-show-all', `hs-hide-block',
`hs-show-block', `hs-hide-level' and `hs-toggle-hiding'. There is also
;;;***
\f
-;;;### (autoloads nil "hilit-chg" "hilit-chg.el" (20992 52525 458637
-;;;;;; 0))
+;;;### (autoloads nil "hilit-chg" "hilit-chg.el" (22086 11929 858062
+;;;;;; 731000))
;;; Generated autoloads from hilit-chg.el
(autoload 'highlight-changes-mode "hilit-chg" "\
When Highlight Changes is enabled, changes are marked with a text
property. Normally they are displayed in a distinctive face, but
-command \\[highlight-changes-visible-mode] can be used to toggles
+command \\[highlight-changes-visible-mode] can be used to toggle
this on and off.
Other functions for buffers in this mode include:
The default value can be customized with variable
`highlight-changes-visibility-initial-state'.
-This command does not itself set highlight-changes mode.
+This command does not itself set Highlight Changes mode.
\(fn &optional ARG)" t nil)
this function to `write-file-functions' as a buffer-local value. To do
this, eval the following in the buffer to be saved:
- (add-hook 'write-file-functions 'highlight-changes-rotate-faces nil t)
+ (add-hook \\='write-file-functions \\='highlight-changes-rotate-faces nil t)
\(fn)" t nil)
;;;***
\f
-;;;### (autoloads nil "hippie-exp" "hippie-exp.el" (20992 52525 458637
-;;;;;; 0))
+;;;### (autoloads nil "hippie-exp" "hippie-exp.el" (22086 11929 858062
+;;;;;; 731000))
;;; Generated autoloads from hippie-exp.el
(push (purecopy '(hippie-exp 1 6)) package--builtin-versions)
;;;***
\f
-;;;### (autoloads nil "hl-line" "hl-line.el" (20992 52525 458637
-;;;;;; 0))
+;;;### (autoloads nil "hl-line" "hl-line.el" (22086 11929 858062
+;;;;;; 731000))
;;; Generated autoloads from hl-line.el
(autoload 'hl-line-mode "hl-line" "\
;;;***
\f
-;;;### (autoloads nil "holidays" "calendar/holidays.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "holidays" "calendar/holidays.el" (22086 11929
+;;;;;; 534062 731000))
;;; Generated autoloads from calendar/holidays.el
-(define-obsolete-variable-alias 'general-holidays 'holiday-general-holidays "23.1")
-
(defvar holiday-general-holidays (mapcar 'purecopy '((holiday-fixed 1 1 "New Year's Day") (holiday-float 1 1 3 "Martin Luther King Day") (holiday-fixed 2 2 "Groundhog Day") (holiday-fixed 2 14 "Valentine's Day") (holiday-float 2 1 3 "President's Day") (holiday-fixed 3 17 "St. Patrick's Day") (holiday-fixed 4 1 "April Fools' Day") (holiday-float 5 0 2 "Mother's Day") (holiday-float 5 1 -1 "Memorial Day") (holiday-fixed 6 14 "Flag Day") (holiday-float 6 0 3 "Father's Day") (holiday-fixed 7 4 "Independence Day") (holiday-float 9 1 1 "Labor Day") (holiday-float 10 1 2 "Columbus Day") (holiday-fixed 10 31 "Halloween") (holiday-fixed 11 11 "Veteran's Day") (holiday-float 11 4 4 "Thanksgiving"))) "\
General holidays. Default value is for the United States.
See the documentation for `calendar-holidays' for details.")
(put 'holiday-general-holidays 'risky-local-variable t)
-(define-obsolete-variable-alias 'oriental-holidays 'holiday-oriental-holidays "23.1")
-
(defvar holiday-oriental-holidays (mapcar 'purecopy '((holiday-chinese-new-year) (if calendar-chinese-all-holidays-flag (append (holiday-chinese 1 15 "Lantern Festival") (holiday-chinese-qingming) (holiday-chinese 5 5 "Dragon Boat Festival") (holiday-chinese 7 7 "Double Seventh Festival") (holiday-chinese 8 15 "Mid-Autumn Festival") (holiday-chinese 9 9 "Double Ninth Festival") (holiday-chinese-winter-solstice))))) "\
Oriental holidays.
See the documentation for `calendar-holidays' for details.")
(put 'holiday-oriental-holidays 'risky-local-variable t)
-(define-obsolete-variable-alias 'local-holidays 'holiday-local-holidays "23.1")
-
(defvar holiday-local-holidays nil "\
Local holidays.
See the documentation for `calendar-holidays' for details.")
(put 'holiday-local-holidays 'risky-local-variable t)
-(define-obsolete-variable-alias 'other-holidays 'holiday-other-holidays "23.1")
-
(defvar holiday-other-holidays nil "\
User defined holidays.
See the documentation for `calendar-holidays' for details.")
(put 'holiday-other-holidays 'risky-local-variable t)
-(defvar hebrew-holidays-1 (mapcar 'purecopy '((holiday-hebrew-rosh-hashanah) (if calendar-hebrew-all-holidays-flag (holiday-julian 11 (let ((m displayed-month) (y displayed-year) year) (calendar-increment-month m y -1) (setq year (calendar-extract-year (calendar-julian-from-absolute (calendar-absolute-from-gregorian (list m 1 y))))) (if (zerop (% (1+ year) 4)) 22 21)) "\"Tal Umatar\" (evening)")))) "\
-Component of the old default value of `holiday-hebrew-holidays'.")
-
-(put 'hebrew-holidays-1 'risky-local-variable t)
-
-(defvar hebrew-holidays-2 (mapcar 'purecopy '((holiday-hebrew-hanukkah) (if calendar-hebrew-all-holidays-flag (holiday-hebrew 10 (let ((h-year (calendar-extract-year (calendar-hebrew-from-absolute (calendar-absolute-from-gregorian (list displayed-month 28 displayed-year)))))) (if (= 6 (% (calendar-hebrew-to-absolute (list 10 10 h-year)) 7)) 11 10)) "Tzom Teveth")) (if calendar-hebrew-all-holidays-flag (holiday-hebrew 11 15 "Tu B'Shevat")))) "\
-Component of the old default value of `holiday-hebrew-holidays'.")
-
-(put 'hebrew-holidays-2 'risky-local-variable t)
-
-(defvar hebrew-holidays-3 (mapcar 'purecopy '((if calendar-hebrew-all-holidays-flag (holiday-hebrew 11 (let* ((m displayed-month) (y displayed-year) (h-year (progn (calendar-increment-month m y 1) (calendar-extract-year (calendar-hebrew-from-absolute (calendar-absolute-from-gregorian (list m (calendar-last-day-of-month m y) y)))))) (s-s (calendar-hebrew-from-absolute (if (= 6 (% (calendar-hebrew-to-absolute (list 7 1 h-year)) 7)) (calendar-dayname-on-or-before 6 (calendar-hebrew-to-absolute (list 11 17 h-year))) (calendar-dayname-on-or-before 6 (calendar-hebrew-to-absolute (list 11 16 h-year)))))) (day (calendar-extract-day s-s))) day) "Shabbat Shirah")))) "\
-Component of the old default value of `holiday-hebrew-holidays'.")
-
-(put 'hebrew-holidays-3 'risky-local-variable t)
-
-(defvar hebrew-holidays-4 (mapcar 'purecopy '((holiday-hebrew-passover) (and calendar-hebrew-all-holidays-flag (let* ((m displayed-month) (y displayed-year) (year (progn (calendar-increment-month m y -1) (calendar-extract-year (calendar-julian-from-absolute (calendar-absolute-from-gregorian (list m 1 y))))))) (= 21 (% year 28))) (holiday-julian 3 26 "Kiddush HaHamah")) (if calendar-hebrew-all-holidays-flag (holiday-hebrew-tisha-b-av)))) "\
-Component of the old default value of `holiday-hebrew-holidays'.")
-
-(put 'hebrew-holidays-4 'risky-local-variable t)
-
-(define-obsolete-variable-alias 'hebrew-holidays 'holiday-hebrew-holidays "23.1")
-
(defvar holiday-hebrew-holidays (mapcar 'purecopy '((holiday-hebrew-passover) (holiday-hebrew-rosh-hashanah) (holiday-hebrew-hanukkah) (if calendar-hebrew-all-holidays-flag (append (holiday-hebrew-tisha-b-av) (holiday-hebrew-misc))))) "\
Jewish holidays.
See the documentation for `calendar-holidays' for details.")
(put 'holiday-hebrew-holidays 'risky-local-variable t)
-(define-obsolete-variable-alias 'christian-holidays 'holiday-christian-holidays "23.1")
-
(defvar holiday-christian-holidays (mapcar 'purecopy '((holiday-easter-etc) (holiday-fixed 12 25 "Christmas") (if calendar-christian-all-holidays-flag (append (holiday-fixed 1 6 "Epiphany") (holiday-julian 12 25 "Christmas (Julian calendar)") (holiday-greek-orthodox-easter) (holiday-fixed 8 15 "Assumption") (holiday-advent 0 "Advent"))))) "\
Christian holidays.
See the documentation for `calendar-holidays' for details.")
(put 'holiday-christian-holidays 'risky-local-variable t)
-(define-obsolete-variable-alias 'islamic-holidays 'holiday-islamic-holidays "23.1")
-
(defvar holiday-islamic-holidays (mapcar 'purecopy '((holiday-islamic-new-year) (holiday-islamic 9 1 "Ramadan Begins") (if calendar-islamic-all-holidays-flag (append (holiday-islamic 1 10 "Ashura") (holiday-islamic 3 12 "Mulad-al-Nabi") (holiday-islamic 7 26 "Shab-e-Mi'raj") (holiday-islamic 8 15 "Shab-e-Bara't") (holiday-islamic 9 27 "Shab-e Qadr") (holiday-islamic 10 1 "Id-al-Fitr") (holiday-islamic 12 10 "Id-al-Adha"))))) "\
Islamic holidays.
See the documentation for `calendar-holidays' for details.")
(put 'holiday-islamic-holidays 'risky-local-variable t)
-(define-obsolete-variable-alias 'bahai-holidays 'holiday-bahai-holidays "23.1")
-
-(defvar holiday-bahai-holidays (mapcar 'purecopy '((holiday-bahai-new-year) (holiday-bahai-ridvan) (holiday-fixed 5 23 "Declaration of the Báb") (holiday-fixed 5 29 "Ascension of Bahá'u'lláh") (holiday-fixed 7 9 "Martyrdom of the Báb") (holiday-fixed 10 20 "Birth of the Báb") (holiday-fixed 11 12 "Birth of Bahá'u'lláh") (if calendar-bahai-all-holidays-flag (append (holiday-fixed 11 26 "Day of the Covenant") (holiday-fixed 11 28 "Ascension of `Abdu'l-Bahá"))))) "\
-Bahá'à holidays.
+(defvar holiday-bahai-holidays (mapcar 'purecopy '((holiday-bahai-new-year) (holiday-bahai-ridvan) (holiday-fixed 5 23 "Declaration of the Báb") (holiday-fixed 5 29 "Ascension of Bahá’u’lláh") (holiday-fixed 7 9 "Martyrdom of the Báb") (holiday-fixed 10 20 "Birth of the Báb") (holiday-fixed 11 12 "Birth of Bahá’u’lláh") (if calendar-bahai-all-holidays-flag (append (holiday-fixed 11 26 "Day of the Covenant") (holiday-fixed 11 28 "Ascension of `Abdu’l-Bahá"))))) "\
+Bahá’à holidays.
See the documentation for `calendar-holidays' for details.")
(custom-autoload 'holiday-bahai-holidays "holidays" t)
(put 'holiday-bahai-holidays 'risky-local-variable t)
-(define-obsolete-variable-alias 'solar-holidays 'holiday-solar-holidays "23.1")
-
(defvar holiday-solar-holidays (mapcar 'purecopy '((solar-equinoxes-solstices) (holiday-sexp calendar-daylight-savings-starts (format "Daylight Saving Time Begins %s" (solar-time-string (/ calendar-daylight-savings-starts-time (float 60)) calendar-standard-time-zone-name))) (holiday-sexp calendar-daylight-savings-ends (format "Daylight Saving Time Ends %s" (solar-time-string (/ calendar-daylight-savings-ends-time (float 60)) calendar-daylight-time-zone-name))))) "\
Sun-related holidays.
See the documentation for `calendar-holidays' for details.")
;;;***
\f
-;;;### (autoloads nil "html2text" "gnus/html2text.el" (20791 9657
-;;;;;; 561026 0))
+;;;### (autoloads nil "html2text" "gnus/html2text.el" (22086 11929
+;;;;;; 810062 731000))
;;; Generated autoloads from gnus/html2text.el
(autoload 'html2text "html2text" "\
;;;***
\f
-;;;### (autoloads nil "htmlfontify" "htmlfontify.el" (21124 45614
-;;;;;; 800155 912000))
+;;;### (autoloads nil "htmlfontify" "htmlfontify.el" (22092 27717
+;;;;;; 864268 464000))
;;; Generated autoloads from htmlfontify.el
(push (purecopy '(htmlfontify 0 21)) package--builtin-versions)
;;;***
\f
-;;;### (autoloads nil "ibuf-macs" "ibuf-macs.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "ibuf-macs" "ibuf-macs.el" (22086 11929 862062
+;;;;;; 731000))
;;; Generated autoloads from ibuf-macs.el
(autoload 'define-ibuffer-column "ibuf-macs" "\
change its definition, you should explicitly call
`ibuffer-recompile-formats'.
-\(fn SYMBOL (&key NAME INLINE PROPS SUMMARIZER) &rest BODY)" nil (quote macro))
+\(fn SYMBOL (&key NAME INLINE PROPS SUMMARIZER) &rest BODY)" nil t)
+
+(function-put 'define-ibuffer-column 'lisp-indent-function 'defun)
(autoload 'define-ibuffer-sorter "ibuf-macs" "\
Define a method of sorting named NAME.
buffer object, and `b' bound to another. BODY should return a non-nil
value if and only if `a' is \"less than\" `b'.
-\(fn NAME DOCUMENTATION (&key DESCRIPTION) &rest BODY)" nil (quote macro))
+\(fn NAME DOCUMENTATION (&key DESCRIPTION) &rest BODY)" nil t)
+
+(function-put 'define-ibuffer-sorter 'lisp-indent-function '1)
+
+(function-put 'define-ibuffer-sorter 'doc-string-elt '2)
(autoload 'define-ibuffer-op "ibuf-macs" "\
Generate a function which operates on a buffer.
COMPLEX means this function is special; see the source code of this
macro for exactly what it does.
-\(fn OP ARGS DOCUMENTATION (&key INTERACTIVE MARK MODIFIER-P DANGEROUS OPSTRING ACTIVE-OPSTRING COMPLEX) &rest BODY)" nil (quote macro))
+\(fn OP ARGS DOCUMENTATION (&key INTERACTIVE MARK MODIFIER-P DANGEROUS OPSTRING ACTIVE-OPSTRING COMPLEX) &rest BODY)" nil t)
+
+(function-put 'define-ibuffer-op 'lisp-indent-function '2)
+
+(function-put 'define-ibuffer-op 'doc-string-elt '3)
(autoload 'define-ibuffer-filter "ibuf-macs" "\
Define a filter named NAME.
will be evaluated with BUF bound to the buffer object, and QUALIFIER
bound to the current value of the filter.
-\(fn NAME DOCUMENTATION (&key READER DESCRIPTION) &rest BODY)" nil (quote macro))
+\(fn NAME DOCUMENTATION (&key READER DESCRIPTION) &rest BODY)" nil t)
+
+(function-put 'define-ibuffer-filter 'lisp-indent-function '2)
+
+(function-put 'define-ibuffer-filter 'doc-string-elt '2)
;;;***
\f
-;;;### (autoloads nil "ibuffer" "ibuffer.el" (21105 26139 752484
-;;;;;; 0))
+;;;### (autoloads nil "ibuffer" "ibuffer.el" (22092 27717 868268
+;;;;;; 464000))
;;; Generated autoloads from ibuffer.el
(autoload 'ibuffer-list-buffers "ibuffer" "\
(autoload 'ibuffer "ibuffer" "\
Begin using Ibuffer to edit a list of buffers.
-Type 'h' after entering ibuffer for more information.
+Type `h' after entering ibuffer for more information.
All arguments are optional.
OTHER-WINDOW-P says to use another window.
;;;***
\f
-;;;### (autoloads nil "icalendar" "calendar/icalendar.el" (21077
-;;;;;; 65494 651556 676000))
+;;;### (autoloads nil "icalendar" "calendar/icalendar.el" (22092
+;;;;;; 27717 556268 464000))
;;; Generated autoloads from calendar/icalendar.el
(push (purecopy '(icalendar 0 19)) package--builtin-versions)
;;;***
\f
-;;;### (autoloads nil "icomplete" "icomplete.el" (21091 44456 774347
-;;;;;; 0))
+;;;### (autoloads nil "icomplete" "icomplete.el" (22086 11929 862062
+;;;;;; 731000))
;;; Generated autoloads from icomplete.el
(defvar icomplete-mode nil "\
positive, and disable it otherwise. If called from Lisp, enable
the mode if ARG is omitted or nil.
+When this global minor mode is enabled, typing in the minibuffer
+continuously displays a list of possible completions that match
+the string you have typed. See `icomplete-completions' for a
+description of how prospective completions are displayed.
+
+For more information, see Info node `(emacs)Icomplete'.
+For options you can set, `\\[customize-group] icomplete'.
+
+You can use the following key bindings to navigate and select
+completions:
+
+\\{icomplete-minibuffer-map}
+
\(fn &optional ARG)" t nil)
+(when (locate-library "obsolete/iswitchb")
+ (autoload 'iswitchb-mode "iswitchb" "Toggle Iswitchb mode." t)
+ (make-obsolete 'iswitchb-mode
+ "use `icomplete-mode' or `ido-mode' instead." "24.4"))
;;;***
\f
-;;;### (autoloads nil "icon" "progmodes/icon.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "icon" "progmodes/icon.el" (22086 11930 186062
+;;;;;; 731000))
;;; Generated autoloads from progmodes/icon.el
(autoload 'icon-mode "icon" "\
;;;***
\f
-;;;### (autoloads nil "idlw-shell" "progmodes/idlw-shell.el" (20938
-;;;;;; 49065 383398 0))
+;;;### (autoloads nil "idlw-shell" "progmodes/idlw-shell.el" (22086
+;;;;;; 11930 194062 731000))
;;; Generated autoloads from progmodes/idlw-shell.el
(autoload 'idlwave-shell "idlw-shell" "\
;;;***
\f
-;;;### (autoloads nil "idlwave" "progmodes/idlwave.el" (20929 34089
-;;;;;; 117790 0))
+;;;### (autoloads nil "idlwave" "progmodes/idlwave.el" (22092 27718
+;;;;;; 216268 464000))
;;; Generated autoloads from progmodes/idlwave.el
(push (purecopy '(idlwave 6 1 22)) package--builtin-versions)
5. Code Templates and Abbreviations
--------------------------------
Many Abbreviations are predefined to expand to code fragments and templates.
- The abbreviations start generally with a `\\`. Some examples:
+ The abbreviations start generally with a `\\'. Some examples:
\\pr PROCEDURE template
\\fu FUNCTION template
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 URL `http://idlwave.org'.
+ documentation, check IDLWAVE's homepage at URL
+ `http://github.com/jdtsmith/idlwave'.
IDLWAVE has customize support - see the group `idlwave'.
10.Keybindings
;;;***
\f
-;;;### (autoloads nil "ido" "ido.el" (21103 35626 321341 0))
+;;;### (autoloads nil "ido" "ido.el" (22093 48588 548393 539000))
;;; Generated autoloads from ido.el
(defvar ido-mode nil "\
Determines for which buffer/file Ido should be enabled.
The following values are possible:
-- `buffer': Turn only on ido buffer behavior (switching, killing,
+- `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.
+- `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-autoload 'ido-mode "ido" nil)
(autoload 'ido-mode "ido" "\
-Toggle ido mode on or off.
-With ARG, turn ido-mode on if arg is positive, off otherwise.
-Turning on ido-mode will remap (via a minor-mode keymap) the default
+Toggle Ido mode on or off.
+With ARG, turn Ido mode on if arg is positive, off otherwise.
+Turning on Ido mode will remap (via a minor-mode keymap) the default
keybindings for the `find-file' and `switch-to-buffer' families of
-commands to the ido versions of these functions.
-However, if ARG arg equals 'files, remap only commands for files, or
-if it equals 'buffers, remap only commands for buffer switching.
+commands to the Ido versions of these functions.
+However, if ARG arg equals `files', remap only commands for files, or
+if it equals `buffers', remap only commands for buffer switching.
This function also adds a hook to the minibuffer.
\(fn &optional ARG)" t nil)
buffer you want, it can then be selected. As you type, most keys have
their normal keybindings, except for the following: \\<ido-buffer-completion-map>
-RET Select the buffer at the front of the list of matches. If the
-list is empty, possibly prompt to create new buffer.
+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] Use the current input string verbatim.
+\\[ido-select-text] Use the current input string verbatim.
-\\[ido-next-match] Put the first element at the end of the list.
-\\[ido-prev-match] Put the last element at the start of the list.
-\\[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'.
+\\[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'.
\(fn)" t nil)
(autoload '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.
+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
then be selected. As you type, most keys have their normal keybindings,
except for the following: \\<ido-file-completion-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] Use the current input string verbatim.
-
-\\[ido-next-match] Put the first element at the end of the list.
-\\[ido-prev-match] Put the last element at the start of the list.
-\\[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-magic-delete-char] Open the specified directory in Dired mode.
-\\[ido-edit-input] Edit input string (including directory).
-\\[ido-prev-work-directory] or \\[ido-next-work-directory] go to previous/next directory in work directory history.
-\\[ido-merge-work-directories] search for file in the work directory history.
-\\[ido-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-or-pop-dir] and \\[ido-wide-find-dir-or-delete-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-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'.
+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] Use the current input string verbatim.
+
+\\[ido-next-match] Put the first element at the end of the list.
+\\[ido-prev-match] Put the last element at the start of the list.
+\\[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-magic-delete-char] Open the specified directory in Dired mode.
+\\[ido-edit-input] Edit input string (including directory).
+\\[ido-prev-work-directory] Go to previous directory in work directory history.
+\\[ido-next-work-directory] Go to next directory in work directory history.
+\\[ido-merge-work-directories] Search for file in the work directory history.
+\\[ido-forget-work-directory] Remove current directory from the work directory history.
+\\[ido-prev-work-file] Cycle to previous file in work file history.
+\\[ido-next-work-file] Cycle to next file in work file history.
+\\[ido-wide-find-file-or-pop-dir] Prompt for a file and use find to locate it.
+\\[ido-wide-find-dir-or-delete-dir] Prompt for a directory and use find to locate it.
+\\[ido-make-directory] Prompt 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-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'.
\(fn)" t nil)
\(fn)" t nil)
(autoload 'ido-dired "ido" "\
-Call `dired' the ido way.
+Call `dired' the Ido way.
The directory is selected interactively by typing a substring.
For details of keybindings, see `ido-find-file'.
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.
-\(fn PROMPT &optional DEFAULT REQUIRE-MATCH)" nil nil)
+\(fn PROMPT &optional DEFAULT REQUIRE-MATCH PREDICATE)" nil nil)
(autoload 'ido-read-file-name "ido" "\
Ido replacement for the built-in `read-file-name'.
(autoload 'ido-completing-read "ido" "\
Ido replacement for the built-in `completing-read'.
-Read a string in the minibuffer with ido-style completion.
+Read a string in the minibuffer with Ido-style completion.
PROMPT is a string to prompt with; normally it ends in a colon and a space.
CHOICES is a list of strings which are the possible completions.
-PREDICATE and INHERIT-INPUT-METHOD is currently ignored; it is included
+PREDICATE and INHERIT-INPUT-METHOD are currently ignored; they are included
to be compatible with `completing-read'.
If REQUIRE-MATCH is non-nil, the user is not allowed to exit unless
the input is (or completes to) an element of CHOICES or is null.
;;;***
\f
-;;;### (autoloads nil "ielm" "ielm.el" (21089 2732 351717 0))
+;;;### (autoloads nil "ielm" "ielm.el" (22086 11929 866062 731000))
;;; Generated autoloads from ielm.el
(autoload 'ielm "ielm" "\
;;;***
\f
-;;;### (autoloads nil "iimage" "iimage.el" (20709 26818 907104 0))
+;;;### (autoloads nil "iimage" "iimage.el" (22086 11929 866062 731000))
;;; Generated autoloads from iimage.el
(define-obsolete-function-alias 'turn-on-iimage-mode 'iimage-mode "24.1")
;;;***
\f
-;;;### (autoloads nil "image" "image.el" (21107 32686 465643 0))
+;;;### (autoloads nil "image" "image.el" (22092 27717 872268 464000))
;;; Generated autoloads from image.el
(autoload 'image-type-from-data "image" "\
\(fn SYMBOL SPECS &optional DOC)" nil t)
-(put 'defimage 'doc-string-elt '3)
+(function-put 'defimage 'doc-string-elt '3)
(autoload 'imagemagick-register-types "image" "\
Register file types that can be handled by ImageMagick.
;;;***
\f
-;;;### (autoloads nil "image-dired" "image-dired.el" (20971 46377
-;;;;;; 737658 0))
+;;;### (autoloads nil "image-dired" "image-dired.el" (22092 27717
+;;;;;; 872268 464000))
;;; Generated autoloads from image-dired.el
(push (purecopy '(image-dired 0 4 11)) package--builtin-versions)
;;;***
\f
-;;;### (autoloads nil "image-file" "image-file.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "image-file" "image-file.el" (22086 11929 866062
+;;;;;; 731000))
;;; Generated autoloads from image-file.el
(defvar image-file-name-extensions (purecopy '("png" "jpeg" "jpg" "gif" "tiff" "tif" "xbm" "xpm" "pbm" "pgm" "ppm" "pnm" "svg")) "\
;;;***
\f
-;;;### (autoloads nil "image-mode" "image-mode.el" (21005 64551 555603
-;;;;;; 0))
+;;;### (autoloads nil "image-mode" "image-mode.el" (22091 6875 287217
+;;;;;; 891000))
;;; Generated autoloads from image-mode.el
(autoload 'image-mode "image-mode" "\
;;;***
\f
-;;;### (autoloads nil "imenu" "imenu.el" (21145 51520 109004 0))
+;;;### (autoloads nil "imenu" "imenu.el" (22092 27717 872268 464000))
;;; Generated autoloads from imenu.el
(defvar imenu-sort-function nil "\
;;;***
\f
-;;;### (autoloads nil "ind-util" "language/ind-util.el" (20826 45095
-;;;;;; 436233 0))
+;;;### (autoloads nil "ind-util" "language/ind-util.el" (22086 11929
+;;;;;; 898062 731000))
;;; Generated autoloads from language/ind-util.el
(autoload 'indian-compose-region "ind-util" "\
;;;***
\f
-;;;### (autoloads nil "inf-lisp" "progmodes/inf-lisp.el" (21098 17703
-;;;;;; 588969 0))
+;;;### (autoloads nil "inf-lisp" "progmodes/inf-lisp.el" (22086 11930
+;;;;;; 206062 731000))
;;; Generated autoloads from progmodes/inf-lisp.el
(autoload 'inferior-lisp "inf-lisp" "\
;;;***
\f
-;;;### (autoloads nil "info" "info.el" (21040 17194 398147 0))
+;;;### (autoloads nil "info" "info.el" (22086 11929 874062 731000))
;;; Generated autoloads from info.el
(defcustom Info-default-directory-list (let* ((config-dir (file-name-as-directory (or (and (featurep 'ns) (let ((dir (expand-file-name "../info" data-directory))) (if (file-directory-p dir) dir))) configure-info-directory))) (prefixes (prune-directory-list '("/usr/local/" "/usr/" "/opt/" "/"))) (suffixes '("share/" "" "gnu/" "gnu/lib/" "gnu/lib/emacs/" "emacs/" "lib/" "lib/emacs/")) (standard-info-dirs (apply #'nconc (mapcar (lambda (pfx) (let ((dirs (mapcar (lambda (sfx) (concat pfx sfx "info/")) suffixes))) (prune-directory-list dirs))) prefixes))) (dirs (if (member config-dir standard-info-dirs) (nconc standard-info-dirs (list config-dir)) (cons config-dir standard-info-dirs)))) (if (not (eq system-type 'windows-nt)) dirs (let* ((instdir (file-name-directory invocation-directory)) (dir1 (expand-file-name "../info/" instdir)) (dir2 (expand-file-name "../../../info/" instdir))) (cond ((file-exists-p dir1) (append dirs (list dir1))) ((file-exists-p dir2) (append dirs (list dir2))) (t dirs))))) "\
In interactive use, a non-numeric prefix argument directs
this command to read a file name from the minibuffer.
-A numeric prefix argument N selects an Info buffer named
-\"*info*<%s>\".
+A numeric prefix argument of N selects an Info buffer named \"*info*<N>\".
The search path for Info files is in the variable `Info-directory-list'.
The top-level Info directory is made by combining all the files named `dir'
(autoload 'info-display-manual "info" "\
Display an Info buffer displaying MANUAL.
If there is an existing Info buffer for MANUAL, display it.
-Otherwise, visit the manual in a new Info buffer.
+Otherwise, visit the manual in a new Info buffer. In interactive
+use, a prefix argument directs this command to limit the
+completion alternatives to currently visited manuals.
\(fn MANUAL)" t nil)
;;;***
\f
-;;;### (autoloads nil "info-look" "info-look.el" (20854 24486 190633
-;;;;;; 0))
+;;;### (autoloads nil "info-look" "info-look.el" (22086 11929 870062
+;;;;;; 731000))
;;; Generated autoloads from info-look.el
(autoload 'info-lookup-reset "info-look" "\
value into the minibuffer so you can edit it. The default symbol is the
one found at point.
-With prefix arg a query for the symbol help mode is offered.
+With prefix arg MODE a query for the symbol help mode is offered.
\(fn SYMBOL &optional MODE)" t nil)
(put 'info-lookup-file 'info-file "emacs")
into the minibuffer so you can edit it.
The default file name is the one found at point.
-With prefix arg a query for the file help mode is offered.
+With prefix arg MODE a query for the file help mode is offered.
\(fn FILE &optional MODE)" t nil)
;;;***
\f
-;;;### (autoloads nil "info-xref" "info-xref.el" (20947 64044 876888
-;;;;;; 0))
+;;;### (autoloads nil "info-xref" "info-xref.el" (22086 11929 870062
+;;;;;; 731000))
;;; Generated autoloads from info-xref.el
(push (purecopy '(info-xref 3)) package--builtin-versions)
;;;***
\f
-;;;### (autoloads nil "informat" "informat.el" (20774 566 676067
-;;;;;; 0))
+;;;### (autoloads nil "informat" "informat.el" (22086 11929 874062
+;;;;;; 731000))
;;; Generated autoloads from informat.el
(autoload 'Info-tagify "informat" "\
;;;***
\f
-;;;### (autoloads nil "inversion" "cedet/inversion.el" (20745 310
-;;;;;; 425822 0))
+;;;### (autoloads nil "inline" "emacs-lisp/inline.el" (22086 11929
+;;;;;; 678062 731000))
+;;; Generated autoloads from emacs-lisp/inline.el
+
+(autoload 'define-inline "inline" "\
+
+
+\(fn NAME ARGS &rest BODY)" nil t)
+
+(function-put 'define-inline 'lisp-indent-function 'defun)
+
+(function-put 'define-inline 'doc-string-elt '3)
+
+;;;***
+\f
+;;;### (autoloads nil "inversion" "cedet/inversion.el" (22086 11929
+;;;;;; 550062 731000))
;;; Generated autoloads from cedet/inversion.el
(push (purecopy '(inversion 1 3)) package--builtin-versions)
;;;***
\f
-;;;### (autoloads nil "isearch-x" "international/isearch-x.el" (20922
-;;;;;; 60838 997229 0))
+;;;### (autoloads nil "isearch-x" "international/isearch-x.el" (22086
+;;;;;; 11929 874062 731000))
;;; Generated autoloads from international/isearch-x.el
(autoload 'isearch-toggle-specified-input-method "isearch-x" "\
;;;***
\f
-;;;### (autoloads nil "isearchb" "isearchb.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "isearchb" "isearchb.el" (22086 11929 886062
+;;;;;; 731000))
;;; Generated autoloads from isearchb.el
(push (purecopy '(isearchb 1 5)) package--builtin-versions)
;;;***
\f
-;;;### (autoloads nil "iso-cvt" "international/iso-cvt.el" (20791
-;;;;;; 9657 561026 0))
+;;;### (autoloads nil "iso-cvt" "international/iso-cvt.el" (22086
+;;;;;; 11929 874062 731000))
;;; Generated autoloads from international/iso-cvt.el
(autoload 'iso-spanish "iso-cvt" "\
;;;***
\f
;;;### (autoloads nil "iso-transl" "international/iso-transl.el"
-;;;;;; (20791 9657 561026 0))
+;;;;;; (22086 11929 874062 731000))
;;; Generated autoloads from international/iso-transl.el
(define-key key-translation-map "\C-x8" 'iso-transl-ctl-x-8-map)
(autoload 'iso-transl-ctl-x-8-map "iso-transl" "Keymap for C-x 8 prefix." t 'keymap)
;;;***
\f
-;;;### (autoloads nil "ispell" "textmodes/ispell.el" (21118 6587
-;;;;;; 141205 0))
+;;;### (autoloads nil "ispell" "textmodes/ispell.el" (22086 11930
+;;;;;; 318062 731000))
;;; Generated autoloads from textmodes/ispell.el
(put 'ispell-check-comments 'safe-local-variable (lambda (a) (memq a '(nil t exclusive))))
(defvar ispell-personal-dictionary nil "\
File name of your personal spelling dictionary, or nil.
If nil, the default personal dictionary, (\"~/.ispell_DICTNAME\" for ispell or
-\"~/.aspell.LANG.pws\" for aspell) is used, where DICTNAME is the name of your
+\"~/.aspell.LANG.pws\" for Aspell) is used, where DICTNAME is the name of your
default dictionary and LANG the two letter language code.")
(custom-autoload 'ispell-personal-dictionary "ispell" t)
(autoload 'ispell-buffer-with-debug "ispell" "\
`ispell-buffer' with some output sent to `ispell-debug-buffer' buffer.
-Use APPEND to append the info to previous buffer if exists.
+If APPEND is non-n il, append the info to previous buffer if exists.
\(fn &optional APPEND)" t nil)
\(fn)" t nil)
(autoload 'ispell-complete-word "ispell" "\
-Try to complete the word before or under point.
-If optional INTERIOR-FRAG is non-nil then the word may be a character
+Try to complete the word before or at point.
+If optional INTERIOR-FRAG is non-nil, then the word may be a character
sequence inside of a word.
Standard ispell choices are then available.
spelled.
All the buffer-local variables and dictionaries are ignored. To
-read them into the running ispell process, type \\[ispell-word]
+read them into the running Ispell process, type \\[ispell-word]
SPC.
For spell-checking \"on the fly\", not just after typing SPC or
To spell-check whenever a message is sent, include the appropriate lines
in your init file:
- (add-hook 'message-send-hook 'ispell-message) ;; GNUS 5
- (add-hook 'news-inews-hook 'ispell-message) ;; GNUS 4
- (add-hook 'mail-send-hook 'ispell-message)
- (add-hook 'mh-before-send-letter-hook 'ispell-message)
+ (add-hook \\='message-send-hook \\='ispell-message) ;; GNUS 5
+ (add-hook \\='news-inews-hook \\='ispell-message) ;; GNUS 4
+ (add-hook \\='mail-send-hook \\='ispell-message)
+ (add-hook \\='mh-before-send-letter-hook \\='ispell-message)
You can bind this to the key C-c i in GNUS or mail by adding to
`news-reply-mode-hook' or `mail-mode-hook' the following lambda expression:
- (function (lambda () (local-set-key \"\\C-ci\" 'ispell-message)))
+ (function (lambda () (local-set-key \"\\C-ci\" \\='ispell-message)))
\(fn)" t nil)
;;;***
\f
-;;;### (autoloads nil "iswitchb" "iswitchb.el" (21120 48308 922449
-;;;;;; 0))
-;;; Generated autoloads from iswitchb.el
-
-(defvar iswitchb-mode nil "\
-Non-nil if Iswitchb mode is enabled.
-See the command `iswitchb-mode' for a description of this minor mode.
-Setting this variable directly does not take effect;
-either customize it (see the info node `Easy Customization')
-or call the function `iswitchb-mode'.")
-
-(custom-autoload 'iswitchb-mode "iswitchb" nil)
-
-(autoload 'iswitchb-mode "iswitchb" "\
-Toggle Iswitchb mode.
-With a prefix argument ARG, enable Iswitchb mode if ARG is
-positive, and disable it otherwise. If called from Lisp, enable
-the mode if ARG is omitted or nil.
-
-Iswitchb mode is a global minor mode that enables switching
-between buffers using substrings. See `iswitchb' for details.
-
-\(fn &optional ARG)" t nil)
-
-;;;***
-\f
-;;;### (autoloads nil "japan-util" "language/japan-util.el" (20709
-;;;;;; 26818 907104 0))
+;;;### (autoloads nil "japan-util" "language/japan-util.el" (22086
+;;;;;; 11929 898062 731000))
;;; Generated autoloads from language/japan-util.el
(autoload 'setup-japanese-environment-internal "japan-util" "\
The argument may be a character or string. The result has the same type.
The argument object is not altered--the value is a copy.
Optional argument HANKAKU t means to convert to `hankaku' Katakana
- (`japanese-jisx0201-kana'), in which case return value
- may be a string even if OBJ is a character if two Katakanas are
- necessary to represent OBJ.
+\(`japanese-jisx0201-kana'), in which case return value
+may be a string even if OBJ is a character if two Katakanas are
+necessary to represent OBJ.
\(fn OBJ &optional HANKAKU)" nil nil)
;;;***
\f
-;;;### (autoloads nil "jka-compr" "jka-compr.el" (20998 4934 952905
-;;;;;; 0))
+;;;### (autoloads nil "jka-compr" "jka-compr.el" (22086 11929 890062
+;;;;;; 731000))
;;; Generated autoloads from jka-compr.el
(defvar jka-compr-inhibit nil "\
;;;***
\f
-;;;### (autoloads nil "js" "progmodes/js.el" (21139 12727 345232
-;;;;;; 0))
+;;;### (autoloads nil "js" "progmodes/js.el" (22109 36809 299889
+;;;;;; 179000))
;;; Generated autoloads from progmodes/js.el
(push (purecopy '(js 9)) package--builtin-versions)
(autoload 'js-mode "js" "\
Major mode for editing JavaScript.
+\(fn)" t nil)
+
+(autoload 'js-jsx-mode "js" "\
+Major mode for editing JSX.
+
+To customize the indentation for this mode, set the SGML offset
+variables (`sgml-basic-offset', `sgml-attribute-offset' et al.)
+locally, like so:
+
+ (defun set-jsx-indentation ()
+ (setq-local sgml-basic-offset js-indent-level))
+ (add-hook \\='js-jsx-mode-hook #\\='set-jsx-indentation)
+
\(fn)" t nil)
(defalias 'javascript-mode 'js-mode)
+(dolist (name (list "node" "nodejs" "gjs" "rhino")) (add-to-list 'interpreter-mode-alist (cons (purecopy name) 'js-mode)))
+
;;;***
\f
-;;;### (autoloads nil "json" "json.el" (21139 12727 345232 0))
+;;;### (autoloads nil "json" "json.el" (22101 42694 105526 804000))
;;; Generated autoloads from json.el
(push (purecopy '(json 1 4)) package--builtin-versions)
;;;***
\f
-;;;### (autoloads nil "keypad" "emulation/keypad.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "keypad" "emulation/keypad.el" (22092 27717
+;;;;;; 636268 464000))
;;; Generated autoloads from emulation/keypad.el
(defvar keypad-setup nil "\
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 keypad, i.e. 0 .. 9 and . (or DECIMAL arg)
- 'none Removes all bindings for keypad keys in function-key-map;
- this enables any user-defined bindings for the keypad keys
- in the global and local keymaps.
-
-If SETUP is 'numeric and the optional fourth argument DECIMAL is non-nil,
+ `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 keypad, i.e. 0 .. 9 and . (or DECIMAL arg)
+ `none' Removes all bindings for keypad keys in function-key-map;
+ this enables any user-defined bindings for the keypad keys
+ in the global and local keymaps.
+
+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 `.'
\(fn SETUP &optional NUMLOCK SHIFT DECIMAL)" nil nil)
;;;***
\f
-;;;### (autoloads nil "kinsoku" "international/kinsoku.el" (20709
-;;;;;; 26818 907104 0))
+;;;### (autoloads nil "kinsoku" "international/kinsoku.el" (22086
+;;;;;; 11929 878062 731000))
;;; Generated autoloads from international/kinsoku.el
(autoload 'kinsoku "kinsoku" "\
;;;***
\f
-;;;### (autoloads nil "kkc" "international/kkc.el" (20998 4934 952905
-;;;;;; 0))
+;;;### (autoloads nil "kkc" "international/kkc.el" (22086 11929 878062
+;;;;;; 731000))
;;; Generated autoloads from international/kkc.el
(defvar kkc-after-update-conversion-functions nil "\
;;;***
\f
-;;;### (autoloads nil "kmacro" "kmacro.el" (21056 5418 85093 0))
+;;;### (autoloads nil "kmacro" "kmacro.el" (22086 11929 890062 731000))
;;; Generated autoloads from kmacro.el
(global-set-key "\C-x(" 'kmacro-start-macro)
(global-set-key "\C-x)" 'kmacro-end-macro)
(autoload 'kmacro-exec-ring-item "kmacro" "\
Execute item ITEM from the macro ring.
+ARG is the number of times to execute the item.
\(fn ITEM ARG)" nil nil)
;;;***
\f
-;;;### (autoloads nil "korea-util" "language/korea-util.el" (20709
-;;;;;; 26818 907104 0))
+;;;### (autoloads nil "korea-util" "language/korea-util.el" (22086
+;;;;;; 11929 902062 731000))
;;; Generated autoloads from language/korea-util.el
(defvar default-korean-keyboard (purecopy (if (string-match "3" (or (getenv "HANGUL_KEYBOARD_TYPE") "")) "3" "")) "\
;;;***
\f
-;;;### (autoloads nil "landmark" "play/landmark.el" (21040 47148
-;;;;;; 604043 521000))
-;;; Generated autoloads from play/landmark.el
-
-(defalias 'landmark-repeat 'landmark-test-run)
-
-(autoload 'landmark-test-run "landmark" "\
-Run 100 Landmark games, each time saving the weights from the previous game.
-
-\(fn)" t nil)
-
-(autoload 'landmark "landmark" "\
-Start or resume an Landmark game.
-If a game is in progress, this command allows you to resume it.
-Here is the relation between prefix args and game options:
-
-prefix arg | robot is auto-started | weights are saved from last game
----------------------------------------------------------------------
-none / 1 | yes | no
- 2 | yes | yes
- 3 | no | yes
- 4 | no | no
-
-You start by moving to a square and typing \\[landmark-start-robot],
-if you did not use a prefix arg to ask for automatic start.
-Use \\[describe-mode] for more info.
-
-\(fn PARG)" t nil)
-
-;;;***
-\f
-;;;### (autoloads nil "lao-util" "language/lao-util.el" (20826 45095
-;;;;;; 436233 0))
+;;;### (autoloads nil "lao-util" "language/lao-util.el" (22086 11929
+;;;;;; 902062 731000))
;;; Generated autoloads from language/lao-util.el
(autoload 'lao-compose-string "lao-util" "\
;;;***
\f
-;;;### (autoloads nil "latexenc" "international/latexenc.el" (20799
-;;;;;; 169 640767 0))
+;;;### (autoloads nil "latexenc" "international/latexenc.el" (22086
+;;;;;; 11929 878062 731000))
;;; Generated autoloads from international/latexenc.el
(defvar latex-inputenc-coding-alist (purecopy '(("ansinew" . windows-1252) ("applemac" . mac-roman) ("ascii" . us-ascii) ("cp1250" . windows-1250) ("cp1252" . windows-1252) ("cp1257" . cp1257) ("cp437de" . cp437) ("cp437" . cp437) ("cp850" . cp850) ("cp852" . cp852) ("cp858" . cp858) ("cp865" . cp865) ("latin1" . iso-8859-1) ("latin2" . iso-8859-2) ("latin3" . iso-8859-3) ("latin4" . iso-8859-4) ("latin5" . iso-8859-5) ("latin9" . iso-8859-15) ("next" . next) ("utf8" . utf-8) ("utf8x" . utf-8))) "\
;;;***
\f
;;;### (autoloads nil "latin1-disp" "international/latin1-disp.el"
-;;;;;; (20826 45095 436233 0))
+;;;;;; (22086 11929 878062 731000))
;;; Generated autoloads from international/latin1-disp.el
(defvar latin1-display nil "\
;;;***
\f
-;;;### (autoloads nil "ld-script" "progmodes/ld-script.el" (20874
-;;;;;; 62962 290468 0))
+;;;### (autoloads nil "ld-script" "progmodes/ld-script.el" (22086
+;;;;;; 11930 210062 731000))
;;; Generated autoloads from progmodes/ld-script.el
(autoload 'ld-script-mode "ld-script" "\
;;;***
\f
-;;;### (autoloads nil "life" "play/life.el" (21048 47760 436258 0))
+;;;### (autoloads nil "let-alist" "emacs-lisp/let-alist.el" (22092
+;;;;;; 27717 632268 464000))
+;;; Generated autoloads from emacs-lisp/let-alist.el
+(push (purecopy '(let-alist 1 0 4)) package--builtin-versions)
+
+(autoload 'let-alist "let-alist" "\
+Let-bind dotted symbols to their cdrs in ALIST and execute BODY.
+Dotted symbol is any symbol starting with a `.'. Only those present
+in BODY are let-bound and this search is done at compile time.
+
+For instance, the following code
+
+ (let-alist alist
+ (if (and .title .body)
+ .body
+ .site
+ .site.contents))
+
+essentially expands to
+
+ (let ((.title (cdr (assq \\='title alist)))
+ (.body (cdr (assq \\='body alist)))
+ (.site (cdr (assq \\='site alist)))
+ (.site.contents (cdr (assq \\='contents (cdr (assq \\='site alist))))))
+ (if (and .title .body)
+ .body
+ .site
+ .site.contents))
+
+If you nest `let-alist' invocations, the inner one can't access
+the variables of the outer one. You can, however, access alists
+inside the original alist by using dots inside the symbol, as
+displayed in the example above.
+
+\(fn ALIST &rest BODY)" nil t)
+
+(function-put 'let-alist 'lisp-indent-function '1)
+
+;;;***
+\f
+;;;### (autoloads nil "life" "play/life.el" (22086 11930 130062 731000))
;;; Generated autoloads from play/life.el
(autoload 'life "life" "\
;;;***
\f
-;;;### (autoloads nil "linum" "linum.el" (21100 59431 520894 0))
+;;;### (autoloads nil "linum" "linum.el" (22086 11929 930062 731000))
;;; Generated autoloads from linum.el
(push (purecopy '(linum 0 9 24)) package--builtin-versions)
;;;***
\f
-;;;### (autoloads nil "loadhist" "loadhist.el" (21126 691 872266
-;;;;;; 0))
+;;;### (autoloads nil "loadhist" "loadhist.el" (22086 11929 930062
+;;;;;; 731000))
;;; Generated autoloads from loadhist.el
(autoload 'unload-feature "loadhist" "\
;;;***
\f
-;;;### (autoloads nil "locate" "locate.el" (21040 17194 398147 0))
+;;;### (autoloads nil "locate" "locate.el" (22086 11929 930062 731000))
;;; Generated autoloads from locate.el
(defvar locate-ls-subdir-switches (purecopy "-al") "\
;;;***
\f
-;;;### (autoloads nil "log-edit" "vc/log-edit.el" (21147 6837 926168
-;;;;;; 0))
+;;;### (autoloads nil "log-edit" "vc/log-edit.el" (22092 27718 544268
+;;;;;; 464000))
;;; Generated autoloads from vc/log-edit.el
(autoload 'log-edit "log-edit" "\
;;;***
\f
-;;;### (autoloads nil "log-view" "vc/log-view.el" (20986 13739 89657
-;;;;;; 0))
+;;;### (autoloads nil "log-view" "vc/log-view.el" (22086 11930 378062
+;;;;;; 731000))
;;; Generated autoloads from vc/log-view.el
(autoload 'log-view-mode "log-view" "\
;;;***
\f
-;;;### (autoloads nil "lpr" "lpr.el" (21104 56491 538513 0))
+;;;### (autoloads nil "lpr" "lpr.el" (22086 11929 930062 731000))
;;; Generated autoloads from lpr.el
(defvar lpr-windows-system (memq system-type '(ms-dos windows-nt)) "\
;;;***
\f
-;;;### (autoloads nil "ls-lisp" "ls-lisp.el" (21048 11307 937592
-;;;;;; 0))
+;;;### (autoloads nil "ls-lisp" "ls-lisp.el" (22086 11929 930062
+;;;;;; 731000))
;;; Generated autoloads from ls-lisp.el
(defvar ls-lisp-support-shell-wildcards t "\
;;;***
\f
-;;;### (autoloads nil "lunar" "calendar/lunar.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "lunar" "calendar/lunar.el" (22086 11929 534062
+;;;;;; 731000))
;;; Generated autoloads from calendar/lunar.el
(autoload 'lunar-phases "lunar" "\
\(fn &optional ARG)" t nil)
-(define-obsolete-function-alias 'phases-of-moon 'lunar-phases "23.1")
-
;;;***
\f
-;;;### (autoloads nil "m4-mode" "progmodes/m4-mode.el" (20874 62962
-;;;;;; 290468 0))
+;;;### (autoloads nil "m4-mode" "progmodes/m4-mode.el" (22086 11930
+;;;;;; 210062 731000))
;;; Generated autoloads from progmodes/m4-mode.el
(autoload 'm4-mode "m4-mode" "\
;;;***
\f
-;;;### (autoloads nil "macros" "macros.el" (20709 26818 907104 0))
+;;;### (autoloads nil "macros" "macros.el" (22086 11929 930062 731000))
;;; Generated autoloads from macros.el
(autoload 'name-last-kbd-macro "macros" "\
\(fn SYMBOL)" t nil)
(autoload 'insert-kbd-macro "macros" "\
-Insert in buffer the definition of kbd macro NAME, as Lisp code.
+Insert in buffer the definition of kbd macro MACRONAME, as Lisp code.
+MACRONAME should be a symbol.
Optional second arg KEYS means also record the keys it is on
\(this is the prefix argument, when calling interactively).
;;;***
\f
-;;;### (autoloads nil "mail-extr" "mail/mail-extr.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "mail-extr" "mail/mail-extr.el" (22086 11929
+;;;;;; 934062 731000))
;;; Generated autoloads from mail/mail-extr.el
(autoload 'mail-extract-address-components "mail-extr" "\
;;;***
\f
-;;;### (autoloads nil "mail-hist" "mail/mail-hist.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "mail-hist" "mail/mail-hist.el" (22086 11929
+;;;;;; 934062 731000))
;;; Generated autoloads from mail/mail-hist.el
(autoload 'mail-hist-define-keys "mail-hist" "\
;;;***
\f
-;;;### (autoloads nil "mail-utils" "mail/mail-utils.el" (20891 18859
-;;;;;; 893295 0))
+;;;### (autoloads nil "mail-utils" "mail/mail-utils.el" (22086 11929
+;;;;;; 934062 731000))
;;; Generated autoloads from mail/mail-utils.el
(defvar mail-use-rfc822 nil "\
;;;***
\f
-;;;### (autoloads nil "mailabbrev" "mail/mailabbrev.el" (20847 51240
-;;;;;; 240216 0))
+;;;### (autoloads nil "mailabbrev" "mail/mailabbrev.el" (22086 11929
+;;;;;; 938062 731000))
;;; Generated autoloads from mail/mailabbrev.el
(defvar mail-abbrevs-mode nil "\
;;;***
\f
-;;;### (autoloads nil "mailalias" "mail/mailalias.el" (20970 25513
-;;;;;; 362767 0))
+;;;### (autoloads nil "mailalias" "mail/mailalias.el" (22086 11929
+;;;;;; 938062 731000))
;;; Generated autoloads from mail/mailalias.el
(defvar mail-complete-style 'angles "\
Specifies how \\[mail-complete] formats the full name when it completes.
-If `nil', they contain just the return address like:
+If nil, they contain just the return address like:
king@grassland.com
If `parens', they look like:
king@grassland.com (Elvis Parsley)
;;;***
\f
-;;;### (autoloads nil "mailclient" "mail/mailclient.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "mailclient" "mail/mailclient.el" (22086 11929
+;;;;;; 938062 731000))
;;; Generated autoloads from mail/mailclient.el
(autoload 'mailclient-send-it "mailclient" "\
;;;***
\f
-;;;### (autoloads nil "make-mode" "progmodes/make-mode.el" (20924
-;;;;;; 16196 967284 0))
+;;;### (autoloads nil "make-mode" "progmodes/make-mode.el" (22086
+;;;;;; 11930 210062 731000))
;;; Generated autoloads from progmodes/make-mode.el
(autoload 'makefile-mode "make-mode" "\
;;;***
\f
-;;;### (autoloads nil "makesum" "makesum.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "makesum" "makesum.el" (22086 11929 954062
+;;;;;; 731000))
;;; Generated autoloads from makesum.el
(autoload 'make-command-summary "makesum" "\
;;;***
\f
-;;;### (autoloads nil "man" "man.el" (21116 51266 54795 0))
+;;;### (autoloads nil "man" "man.el" (22086 11929 954062 731000))
;;; Generated autoloads from man.el
(defalias 'manual-entry 'man)
(autoload 'man "man" "\
Get a Un*x manual page and put it in a buffer.
-This command is the top-level command in the man package. It
-runs a Un*x command to retrieve and clean a manpage in the
+This command is the top-level command in the man package.
+It runs a Un*x command to retrieve and clean a manpage in the
background and places the results in a `Man-mode' browsing
-buffer. See variable `Man-notify-method' for what happens when
-the buffer is ready. If a buffer already exists for this man
-page, it will display immediately.
+buffer. The variable `Man-width' defines the number of columns in
+formatted manual pages. The buffer is displayed immediately.
+The variable `Man-notify-method' defines how the buffer is displayed.
+If a buffer already exists for this man page, it will be displayed
+without running the man command.
For a manpage from a particular section, use either of the
following. \"cat(1)\" is how cross-references appear and is
;;;***
\f
-;;;### (autoloads nil "master" "master.el" (20884 7264 912957 506000))
+;;;### (autoloads nil "map" "emacs-lisp/map.el" (22086 11929 678062
+;;;;;; 731000))
+;;; Generated autoloads from emacs-lisp/map.el
+(push (purecopy '(map 1 0)) package--builtin-versions)
+
+;;;***
+\f
+;;;### (autoloads nil "master" "master.el" (22086 11929 954062 731000))
;;; Generated autoloads from master.el
(push (purecopy '(master 1 0 2)) package--builtin-versions)
;;;***
\f
-;;;### (autoloads nil "mb-depth" "mb-depth.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "mb-depth" "mb-depth.el" (22086 11929 958062
+;;;;;; 731000))
;;; Generated autoloads from mb-depth.el
(defvar minibuffer-depth-indicate-mode nil "\
;;;***
\f
-;;;### (autoloads nil "md4" "md4.el" (20709 26818 907104 0))
+;;;### (autoloads nil "md4" "md4.el" (22086 11929 958062 731000))
;;; Generated autoloads from md4.el
(push (purecopy '(md4 1 0)) package--builtin-versions)
;;;***
\f
-;;;### (autoloads nil "message" "gnus/message.el" (21132 39477 543900
-;;;;;; 0))
+;;;### (autoloads nil "message" "gnus/message.el" (22092 27717 852268
+;;;;;; 464000))
;;; Generated autoloads from gnus/message.el
(define-mail-user-agent 'message-user-agent 'message-mail 'message-send-and-exit 'message-kill-buffer 'message-send-hook)
;;;***
\f
-;;;### (autoloads nil "meta-mode" "progmodes/meta-mode.el" (20874
-;;;;;; 62962 290468 0))
+;;;### (autoloads nil "meta-mode" "progmodes/meta-mode.el" (22086
+;;;;;; 11930 210062 731000))
;;; Generated autoloads from progmodes/meta-mode.el
(push (purecopy '(meta-mode 1 0)) package--builtin-versions)
;;;***
\f
-;;;### (autoloads nil "metamail" "mail/metamail.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "metamail" "mail/metamail.el" (22086 11929
+;;;;;; 938062 731000))
;;; Generated autoloads from mail/metamail.el
(autoload 'metamail-interpret-header "metamail" "\
\(fn &optional VIEWMODE BUFFER NODISPLAY)" t nil)
(autoload 'metamail-region "metamail" "\
-Process current region through 'metamail'.
+Process current region through `metamail'.
Optional argument VIEWMODE specifies the value of the
EMACS_VIEW_MODE environment variable (defaulted to 1).
Optional argument BUFFER specifies a buffer to be filled (nil
;;;***
\f
-;;;### (autoloads nil "mh-comp" "mh-e/mh-comp.el" (20890 54503 125088
-;;;;;; 852000))
+;;;### (autoloads nil "mh-comp" "mh-e/mh-comp.el" (22086 11929 970062
+;;;;;; 731000))
;;; Generated autoloads from mh-e/mh-comp.el
(autoload 'mh-smail "mh-comp" "\
;;;***
\f
-;;;### (autoloads nil "mh-e" "mh-e/mh-e.el" (20987 34598 970563 0))
+;;;### (autoloads nil "mh-e" "mh-e/mh-e.el" (22092 27717 888268 464000))
;;; Generated autoloads from mh-e/mh-e.el
-(push (purecopy '(mh-e 8 5)) package--builtin-versions)
+(push (purecopy '(mh-e 8 6)) package--builtin-versions)
(put 'mh-progs 'risky-local-variable t)
;;;***
\f
-;;;### (autoloads nil "mh-folder" "mh-e/mh-folder.el" (20787 12616
-;;;;;; 976036 0))
+;;;### (autoloads nil "mh-folder" "mh-e/mh-folder.el" (22086 11929
+;;;;;; 970062 731000))
;;; Generated autoloads from mh-e/mh-folder.el
(autoload 'mh-rmail "mh-folder" "\
;;;***
\f
-;;;### (autoloads nil "midnight" "midnight.el" (21058 47149 742317
-;;;;;; 0))
+;;;### (autoloads nil "midnight" "midnight.el" (22086 11929 978062
+;;;;;; 731000))
;;; Generated autoloads from midnight.el
+(defvar midnight-mode nil "\
+Non-nil if Midnight mode is enabled.
+See the command `midnight-mode' for a description of this minor mode.
+Setting this variable directly does not take effect;
+either customize it (see the info node `Easy Customization')
+or call the function `midnight-mode'.")
+
+(custom-autoload 'midnight-mode "midnight" nil)
+
+(autoload 'midnight-mode "midnight" "\
+Non-nil means run `midnight-hook' at midnight.
+
+\(fn &optional ARG)" t nil)
+
(autoload 'clean-buffer-list "midnight" "\
Kill old buffers that have not been displayed recently.
The relevant variables are `clean-buffer-list-delay-general',
;;;***
\f
-;;;### (autoloads nil "minibuf-eldef" "minibuf-eldef.el" (20760 54070
-;;;;;; 584283 0))
+;;;### (autoloads nil "minibuf-eldef" "minibuf-eldef.el" (22086 11929
+;;;;;; 978062 731000))
;;; Generated autoloads from minibuf-eldef.el
(defvar minibuffer-electric-default-mode nil "\
;;;***
\f
-;;;### (autoloads nil "misc" "misc.el" (20709 26818 907104 0))
+;;;### (autoloads nil "misc" "misc.el" (22086 11929 982062 731000))
;;; Generated autoloads from misc.el
(autoload 'butterfly "misc" "\
;;;***
\f
-;;;### (autoloads nil "misearch" "misearch.el" (20721 17977 14204
-;;;;;; 0))
+;;;### (autoloads nil "misearch" "misearch.el" (22086 11929 982062
+;;;;;; 731000))
;;; Generated autoloads from misearch.el
(add-hook 'isearch-mode-hook 'multi-isearch-setup)
The buffer where the search is currently searching.
The value is nil when the search still is in the initial buffer.")
+(defvar multi-isearch-buffer-list nil "\
+Sequence of buffers visited by multiple buffers Isearch.
+This is nil if Isearch is not currently searching more than one buffer.")
+
+(defvar multi-isearch-file-list nil "\
+Sequence of files visited by multiple file buffers Isearch.")
+
(autoload 'multi-isearch-setup "misearch" "\
Set up isearch to search multiple buffers.
Intended to be added to `isearch-mode-hook'.
;;;***
\f
-;;;### (autoloads nil "mixal-mode" "progmodes/mixal-mode.el" (21002
-;;;;;; 1963 769129 0))
+;;;### (autoloads nil "mixal-mode" "progmodes/mixal-mode.el" (22086
+;;;;;; 11930 210062 731000))
;;; Generated autoloads from progmodes/mixal-mode.el
(push (purecopy '(mixal-mode 0 1)) package--builtin-versions)
;;;***
\f
-;;;### (autoloads nil "mm-encode" "gnus/mm-encode.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "mm-encode" "gnus/mm-encode.el" (22086 11929
+;;;;;; 818062 731000))
;;; Generated autoloads from gnus/mm-encode.el
(autoload 'mm-default-file-encoding "mm-encode" "\
;;;***
\f
-;;;### (autoloads nil "mm-extern" "gnus/mm-extern.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "mm-extern" "gnus/mm-extern.el" (22086 11929
+;;;;;; 818062 731000))
;;; Generated autoloads from gnus/mm-extern.el
(autoload 'mm-extern-cache-contents "mm-extern" "\
;;;***
\f
-;;;### (autoloads nil "mm-partial" "gnus/mm-partial.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "mm-partial" "gnus/mm-partial.el" (22086 11929
+;;;;;; 818062 731000))
;;; Generated autoloads from gnus/mm-partial.el
(autoload 'mm-inline-partial "mm-partial" "\
;;;***
\f
-;;;### (autoloads nil "mm-url" "gnus/mm-url.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "mm-url" "gnus/mm-url.el" (22086 11929 818062
+;;;;;; 731000))
;;; Generated autoloads from gnus/mm-url.el
(autoload 'mm-url-insert-file-contents "mm-url" "\
;;;***
\f
-;;;### (autoloads nil "mm-uu" "gnus/mm-uu.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "mm-uu" "gnus/mm-uu.el" (22086 11929 818062
+;;;;;; 731000))
;;; Generated autoloads from gnus/mm-uu.el
(autoload 'mm-uu-dissect "mm-uu" "\
;;;***
\f
-;;;### (autoloads nil "mml" "gnus/mml.el" (20829 21286 719109 0))
+;;;### (autoloads nil "mml" "gnus/mml.el" (22086 11929 822062 731000))
;;; Generated autoloads from gnus/mml.el
(autoload 'mml-to-mime "mml" "\
;;;***
\f
-;;;### (autoloads nil "mml1991" "gnus/mml1991.el" (20875 30633 412173
-;;;;;; 0))
+;;;### (autoloads nil "mml1991" "gnus/mml1991.el" (22086 11929 822062
+;;;;;; 731000))
;;; Generated autoloads from gnus/mml1991.el
(autoload 'mml1991-encrypt "mml1991" "\
;;;***
\f
-;;;### (autoloads nil "mml2015" "gnus/mml2015.el" (21042 58928 39127
-;;;;;; 0))
+;;;### (autoloads nil "mml2015" "gnus/mml2015.el" (22086 11929 822062
+;;;;;; 731000))
;;; Generated autoloads from gnus/mml2015.el
(autoload 'mml2015-decrypt "mml2015" "\
;;;***
\f
-;;;### (autoloads nil "mode-local" "cedet/mode-local.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "mode-local" "cedet/mode-local.el" (22096 24780
+;;;;;; 204094 47000))
;;; Generated autoloads from cedet/mode-local.el
(put 'define-overloadable-function 'doc-string-elt 3)
;;;***
\f
-;;;### (autoloads nil "modula2" "progmodes/modula2.el" (20355 10021
-;;;;;; 546955 0))
+;;;### (autoloads nil "modula2" "progmodes/modula2.el" (22086 11930
+;;;;;; 214062 731000))
;;; Generated autoloads from progmodes/modula2.el
(defalias 'modula-2-mode 'm2-mode)
;;;***
\f
-;;;### (autoloads nil "morse" "play/morse.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "morse" "play/morse.el" (22086 11930 130062
+;;;;;; 731000))
;;; Generated autoloads from play/morse.el
(autoload 'morse-region "morse" "\
;;;***
\f
-;;;### (autoloads nil "mouse-drag" "mouse-drag.el" (20992 52525 458637
-;;;;;; 0))
+;;;### (autoloads nil "mouse-drag" "mouse-drag.el" (22086 11929 982062
+;;;;;; 731000))
;;; Generated autoloads from mouse-drag.el
(autoload 'mouse-drag-throw "mouse-drag" "\
hemisphere you're in.)
To test this function, evaluate:
- (global-set-key [down-mouse-2] 'mouse-drag-throw)
+ (global-set-key [down-mouse-2] \\='mouse-drag-throw)
\(fn START-EVENT)" t nil)
middle button in Tk text widgets.
To test this function, evaluate:
- (global-set-key [down-mouse-2] 'mouse-drag-drag)
+ (global-set-key [down-mouse-2] \\='mouse-drag-drag)
\(fn START-EVENT)" t nil)
;;;***
\f
-;;;### (autoloads nil "mpc" "mpc.el" (21075 56234 349623 0))
+;;;### (autoloads nil "mpc" "mpc.el" (22105 39773 859886 896000))
;;; Generated autoloads from mpc.el
(autoload 'mpc "mpc" "\
;;;***
\f
-;;;### (autoloads nil "mpuz" "play/mpuz.el" (21040 17194 398147 0))
+;;;### (autoloads nil "mpuz" "play/mpuz.el" (22086 11930 130062 731000))
;;; Generated autoloads from play/mpuz.el
(autoload 'mpuz "mpuz" "\
;;;***
\f
-;;;### (autoloads nil "msb" "msb.el" (20999 25770 522517 0))
+;;;### (autoloads nil "msb" "msb.el" (22086 11929 986062 731000))
;;; Generated autoloads from msb.el
(defvar msb-mode nil "\
;;;***
\f
-;;;### (autoloads nil "mule-diag" "international/mule-diag.el" (20891
-;;;;;; 18859 893295 0))
+;;;### (autoloads nil "mule-diag" "international/mule-diag.el" (22086
+;;;;;; 11929 882062 731000))
;;; Generated autoloads from international/mule-diag.el
(autoload 'list-character-sets "mule-diag" "\
;;;***
\f
-;;;### (autoloads nil "mule-util" "international/mule-util.el" (20991
-;;;;;; 31656 363459 0))
+;;;### (autoloads nil "mule-util" "international/mule-util.el" (22108
+;;;;;; 15942 546032 987000))
;;; Generated autoloads from international/mule-util.el
(defsubst string-to-list (string) "\
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 \"...\".
+defaults to `truncate-string-ellipsis'.
\(fn STR END-COLUMN &optional START-COLUMN PADDING ELLIPSIS)" nil nil)
\(fn CHAR)" nil nil)
-;;;***
-\f
-;;;### (autoloads nil "net-utils" "net/net-utils.el" (20903 10024
-;;;;;; 645978 0))
+(autoload 'filepos-to-bufferpos "mule-util" "\
+Try to return the buffer position corresponding to a particular file position.
+The file position is given as a (0-based) BYTE count.
+The function presumes the file is encoded with CODING-SYSTEM, which defaults
+to `buffer-file-coding-system'.
+QUALITY can be:
+ `approximate', in which case we may cut some corners to avoid
+ excessive work.
+ `exact', in which case we may end up re-(en/de)coding a large
+ part of the file/buffer.
+ nil, in which case we may return nil rather than an approximation.
+
+\(fn BYTE &optional QUALITY CODING-SYSTEM)" nil nil)
+
+(autoload 'bufferpos-to-filepos "mule-util" "\
+Try to return the file byte corresponding to a particular buffer POSITION.
+Value is the file position given as a (0-based) byte count.
+The function presumes the file is encoded with CODING-SYSTEM, which defaults
+to `buffer-file-coding-system'.
+QUALITY can be:
+ `approximate', in which case we may cut some corners to avoid
+ excessive work.
+ `exact', in which case we may end up re-(en/de)coding a large
+ part of the file/buffer.
+ nil, in which case we may return nil rather than an approximation.
+
+\(fn POSITION &optional QUALITY CODING-SYSTEM)" nil nil)
+
+;;;***
+\f
+;;;### (autoloads nil "net-utils" "net/net-utils.el" (22086 11929
+;;;;;; 998062 731000))
;;; Generated autoloads from net/net-utils.el
(autoload 'ifconfig "net-utils" "\
;;;***
\f
-;;;### (autoloads nil "netrc" "net/netrc.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "netrc" "net/netrc.el" (22086 11929 998062
+;;;;;; 731000))
;;; Generated autoloads from net/netrc.el
(autoload 'netrc-credentials "netrc" "\
;;;***
\f
-;;;### (autoloads nil "network-stream" "net/network-stream.el" (21074
-;;;;;; 35375 473679 0))
+;;;### (autoloads nil "network-stream" "net/network-stream.el" (22086
+;;;;;; 11929 998062 731000))
;;; Generated autoloads from net/network-stream.el
(autoload 'open-network-stream "network-stream" "\
:client-certificate should either be a list where the first
element is the certificate key file name, and the second
- element is the certificate file name itself, or `t', which
+ element is the certificate file name itself, or t, which
means that `auth-source' will be queried for the key and the
certificate. This parameter will only be used when doing TLS
or STARTTLS connections.
:use-starttls-if-possible is a boolean that says to do opportunistic
STARTTLS upgrades even if Emacs doesn't have built-in TLS functionality.
+:warn-unless-encrypted is a boolean which, if :return-list is
+non-nil, is used warn the user if the connection isn't encrypted.
+
:nogreeting is a boolean that can be used to inhibit waiting for
a greeting from the server.
:nowait is a boolean that says the connection should be made
- asynchronously, if possible.
+asynchronously, if possible.
\(fn NAME BUFFER HOST SERVICE &rest PARAMETERS)" nil nil)
;;;***
\f
-;;;### (autoloads nil "newst-backend" "net/newst-backend.el" (20709
-;;;;;; 26818 907104 0))
+;;;### (autoloads nil "newst-backend" "net/newst-backend.el" (22092
+;;;;;; 27717 964268 464000))
;;; Generated autoloads from net/newst-backend.el
(autoload 'newsticker-running-p "newst-backend" "\
;;;***
\f
;;;### (autoloads nil "newst-plainview" "net/newst-plainview.el"
-;;;;;; (20992 52525 458637 0))
+;;;;;; (22092 27717 980268 464000))
;;; Generated autoloads from net/newst-plainview.el
(autoload 'newsticker-plainview "newst-plainview" "\
;;;***
\f
-;;;### (autoloads nil "newst-reader" "net/newst-reader.el" (21145
-;;;;;; 51520 109004 0))
+;;;### (autoloads nil "newst-reader" "net/newst-reader.el" (22086
+;;;;;; 11929 998062 731000))
;;; Generated autoloads from net/newst-reader.el
(autoload 'newsticker-show-news "newst-reader" "\
;;;***
\f
-;;;### (autoloads nil "newst-ticker" "net/newst-ticker.el" (20709
-;;;;;; 26818 907104 0))
+;;;### (autoloads nil "newst-ticker" "net/newst-ticker.el" (22086
+;;;;;; 11929 998062 731000))
;;; Generated autoloads from net/newst-ticker.el
(autoload 'newsticker-ticker-running-p "newst-ticker" "\
;;;***
\f
-;;;### (autoloads nil "newst-treeview" "net/newst-treeview.el" (21040
-;;;;;; 17194 398147 0))
+;;;### (autoloads nil "newst-treeview" "net/newst-treeview.el" (22109
+;;;;;; 36809 263889 179000))
;;; Generated autoloads from net/newst-treeview.el
(autoload 'newsticker-treeview "newst-treeview" "\
;;;***
\f
-;;;### (autoloads nil "newsticker" "net/newsticker.el" (20709 26818
-;;;;;; 907104 0))
-;;; Generated autoloads from net/newsticker.el
-(push (purecopy '(newsticker 1 99)) package--builtin-versions)
-
-;;;***
-\f
-;;;### (autoloads nil "nndiary" "gnus/nndiary.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "nndiary" "gnus/nndiary.el" (22086 11929 822062
+;;;;;; 731000))
;;; Generated autoloads from gnus/nndiary.el
(autoload 'nndiary-generate-nov-databases "nndiary" "\
;;;***
\f
-;;;### (autoloads nil "nndoc" "gnus/nndoc.el" (21135 15680 63905
-;;;;;; 0))
+;;;### (autoloads nil "nndoc" "gnus/nndoc.el" (22086 11929 822062
+;;;;;; 731000))
;;; Generated autoloads from gnus/nndoc.el
(autoload 'nndoc-add-type "nndoc" "\
;;;***
\f
-;;;### (autoloads nil "nnfolder" "gnus/nnfolder.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "nnfolder" "gnus/nnfolder.el" (22086 11929
+;;;;;; 826062 731000))
;;; Generated autoloads from gnus/nnfolder.el
(autoload 'nnfolder-generate-active-file "nnfolder" "\
;;;***
\f
-;;;### (autoloads nil "nnmairix" "gnus/nnmairix.el" (20709 26818
-;;;;;; 907104 0))
-;;; Generated autoloads from gnus/nnmairix.el
-(push (purecopy '(nnmairix 0 6)) package--builtin-versions)
-
-;;;***
-\f
-;;;### (autoloads nil "nnml" "gnus/nnml.el" (20955 58152 201869 0))
+;;;### (autoloads nil "nnml" "gnus/nnml.el" (22102 63557 304509 103000))
;;; Generated autoloads from gnus/nnml.el
(autoload 'nnml-generate-nov-databases "nnml" "\
;;;***
\f
-;;;### (autoloads nil "novice" "novice.el" (20709 26818 907104 0))
+;;;### (autoloads nil "novice" "novice.el" (22086 11930 22062 731000))
;;; Generated autoloads from novice.el
(define-obsolete-variable-alias 'disabled-command-hook 'disabled-command-function "22.1")
;;;***
\f
-;;;### (autoloads nil "nroff-mode" "textmodes/nroff-mode.el" (20709
-;;;;;; 26818 907104 0))
+;;;### (autoloads nil "nroff-mode" "textmodes/nroff-mode.el" (22086
+;;;;;; 11930 318062 731000))
;;; Generated autoloads from textmodes/nroff-mode.el
(autoload 'nroff-mode "nroff-mode" "\
;;;***
\f
-;;;### (autoloads nil "ntlm" "net/ntlm.el" (20709 26818 907104 0))
+;;;### (autoloads nil "ntlm" "net/ntlm.el" (22086 11930 2062 731000))
;;; Generated autoloads from net/ntlm.el
-(push (purecopy '(ntlm 1 0)) package--builtin-versions)
+(push (purecopy '(ntlm 2 0 0)) package--builtin-versions)
;;;***
\f
-;;;### (autoloads nil "nxml-glyph" "nxml/nxml-glyph.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "nxml-glyph" "nxml/nxml-glyph.el" (22086 11930
+;;;;;; 26062 731000))
;;; Generated autoloads from nxml/nxml-glyph.el
(autoload 'nxml-glyph-display-string "nxml-glyph" "\
;;;***
\f
-;;;### (autoloads nil "nxml-mode" "nxml/nxml-mode.el" (21075 56234
-;;;;;; 349623 0))
+;;;### (autoloads nil "nxml-mode" "nxml/nxml-mode.el" (22086 11930
+;;;;;; 26062 731000))
;;; Generated autoloads from nxml/nxml-mode.el
(autoload 'nxml-mode "nxml-mode" "\
\\[customize-group] nxml RET.
\(fn)" t nil)
-
(defalias 'xml-mode 'nxml-mode)
;;;***
\f
-;;;### (autoloads nil "nxml-uchnm" "nxml/nxml-uchnm.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "nxml-uchnm" "nxml/nxml-uchnm.el" (22086 11930
+;;;;;; 26062 731000))
;;; Generated autoloads from nxml/nxml-uchnm.el
(autoload 'nxml-enable-unicode-char-name-sets "nxml-uchnm" "\
;;;***
\f
-;;;### (autoloads nil "octave" "progmodes/octave.el" (21135 48053
-;;;;;; 151871 0))
+;;;### (autoloads nil "octave" "progmodes/octave.el" (22086 11930
+;;;;;; 214062 731000))
;;; Generated autoloads from progmodes/octave.el
(autoload 'octave-mode "octave" "\
for solving linear and nonlinear problems numerically. Function
definitions can also be stored in files and used in batch mode.
+See Info node `(octave-mode) Using Octave Mode' for more details.
+
+Key bindings:
+\\{octave-mode-map}
+
\(fn)" t nil)
(autoload 'inferior-octave "octave" "\
;;;***
\f
-;;;### (autoloads nil "opascal" "progmodes/opascal.el" (20858 21542
-;;;;;; 723007 0))
+;;;### (autoloads nil "opascal" "progmodes/opascal.el" (22086 11930
+;;;;;; 214062 731000))
;;; Generated autoloads from progmodes/opascal.el
(define-obsolete-function-alias 'delphi-mode 'opascal-mode "24.4")
(autoload 'opascal-mode "opascal" "\
-Major mode for editing OPascal code. \\<opascal-mode-map>
+Major mode for editing OPascal code.\\<opascal-mode-map>
\\[opascal-find-unit] - Search for a OPascal source file.
\\[opascal-fill-comment] - Fill the current comment.
\\[opascal-new-comment-line] - If in a // comment, do a new comment line.
Extra indentation for blocks in compound statements.
`opascal-case-label-indent' (default 0)
Extra indentation for case statement labels.
- `opascal-tab-always-indents' (default `tab-always-indents')
- Non-nil means TAB in OPascal mode should always reindent the current line,
- regardless of where in the line point is when the TAB command is used.
`opascal-search-path' (default .)
Directories to search when finding external units.
`opascal-verbose' (default nil)
Coloring:
- `opascal-keyword-face' (default font-lock-keyword-face)
+ `opascal-keyword-face' (default `font-lock-keyword-face')
Face used to color OPascal keywords.
-Turning on OPascal mode calls the value of the variable `opascal-mode-hook'
-with no args, if that value is non-nil.
-
\(fn)" t nil)
;;;***
\f
-;;;### (autoloads nil "org" "org/org.el" (21128 42425 434886 0))
+;;;### (autoloads nil "org" "org/org.el" (22092 27718 88268 464000))
;;; Generated autoloads from org/org.el
(autoload 'org-babel-do-load-languages "org" "\
;;;***
\f
-;;;### (autoloads nil "org-agenda" "org/org-agenda.el" (21128 42425
-;;;;;; 434886 0))
+;;;### (autoloads nil "org-agenda" "org/org-agenda.el" (22092 27718
+;;;;;; 24268 464000))
;;; Generated autoloads from org/org-agenda.el
(autoload 'org-toggle-sticky-agenda "org-agenda" "\
\(fn &rest ARGS)" nil nil)
+(autoload 'org-agenda-check-for-timestamp-as-reason-to-ignore-todo-item "org-agenda" "\
+Do we have a reason to ignore this TODO entry because it has a time stamp?
+
+\(fn &optional END)" nil nil)
+
(autoload 'org-agenda-set-restriction-lock "org-agenda" "\
Set restriction lock for agenda, to current subtree or file.
-Restriction will be the file if TYPE is `file', or if type is the
-universal prefix '(4), or if the cursor is before the first headline
+Restriction will be the file if TYPE is `file', or if TYPE is the
+universal prefix `(4)', or if the cursor is before the first headline
in the file. Otherwise, restriction will be to the current subtree.
\(fn &optional TYPE)" t nil)
argument: an entry from `org-agenda-get-day-entries'.
FILTER can also be an alist with the car of each cell being
-either 'headline or 'category. For example:
+either `headline' or `category'. For example:
- '((headline \"IMPORTANT\")
- (category \"Work\"))
+ ((headline \"IMPORTANT\")
+ (category \"Work\"))
will only add headlines containing IMPORTANT or headlines
belonging to the \"Work\" category.
;;;***
\f
-;;;### (autoloads nil "org-capture" "org/org-capture.el" (21123 24503
-;;;;;; 570934 0))
+;;;### (autoloads nil "org-capture" "org/org-capture.el" (22086 11930
+;;;;;; 82062 731000))
;;; Generated autoloads from org/org-capture.el
(autoload 'org-capture-string "org-capture" "\
;;;***
\f
-;;;### (autoloads nil "org-colview" "org/org-colview.el" (21123 24503
-;;;;;; 570934 0))
+;;;### (autoloads nil "org-colview" "org/org-colview.el" (22086 11930
+;;;;;; 82062 731000))
;;; Generated autoloads from org/org-colview.el
+(autoload 'org-columns-remove-overlays "org-colview" "\
+Remove all currently active column overlays.
+
+\(fn)" t nil)
+
+(autoload 'org-columns-get-format-and-top-level "org-colview" "\
+
+
+\(fn)" nil nil)
+
(autoload 'org-columns "org-colview" "\
Turn on column view on an org-mode file.
When COLUMNS-FMT-STRING is non-nil, use it as the column format.
\(fn &optional COLUMNS-FMT-STRING)" t nil)
+(autoload 'org-columns-compute "org-colview" "\
+Sum the values of property PROPERTY hierarchically, for the entire buffer.
+
+\(fn PROPERTY)" t nil)
+
+(autoload 'org-columns-number-to-string "org-colview" "\
+Convert a computed column number to a string value, according to FMT.
+
+\(fn N FMT &optional PRINTF)" nil nil)
+
(autoload 'org-dblock-write:columnview "org-colview" "\
Write the column view table.
PARAMS is a property list of parameters:
;;;***
\f
-;;;### (autoloads nil "org-compat" "org/org-compat.el" (21123 24503
-;;;;;; 570934 0))
+;;;### (autoloads nil "org-compat" "org/org-compat.el" (22086 11930
+;;;;;; 82062 731000))
;;; Generated autoloads from org/org-compat.el
(autoload 'org-check-version "org-compat" "\
;;;***
\f
-;;;### (autoloads nil "org-macs" "org/org-macs.el" (21123 24503 570934
-;;;;;; 0))
+;;;### (autoloads nil "org-macs" "org/org-macs.el" (22092 27718 44268
+;;;;;; 464000))
;;; Generated autoloads from org/org-macs.el
(autoload 'org-load-noerror-mustsuffix "org-macs" "\
;;;***
\f
-;;;### (autoloads nil "org-version" "org/org-version.el" (21123 24503
-;;;;;; 570934 0))
+;;;### (autoloads nil "org-version" "org/org-version.el" (22086 11930
+;;;;;; 98062 731000))
;;; Generated autoloads from org/org-version.el
(autoload 'org-release "org-version" "\
\(fn)" nil nil)
-(defvar org-odt-data-dir "/usr/share/emacs/etc/org" "\
-The location of ODT styles.")
-
;;;***
\f
-;;;### (autoloads nil "outline" "outline.el" (20773 35190 350513
-;;;;;; 0))
+;;;### (autoloads nil "outline" "outline.el" (22086 11930 118062
+;;;;;; 731000))
;;; Generated autoloads from outline.el
(put 'outline-regexp 'safe-local-variable 'stringp)
(put 'outline-heading-end-regexp 'safe-local-variable 'stringp)
of the heading, so they move with it, if the line is killed and yanked
back. A heading with text hidden under it is marked with an ellipsis (...).
-Commands:\\<outline-mode-map>
-\\[outline-next-visible-heading] outline-next-visible-heading move by visible headings
-\\[outline-previous-visible-heading] outline-previous-visible-heading
-\\[outline-forward-same-level] outline-forward-same-level similar but skip subheadings
-\\[outline-backward-same-level] outline-backward-same-level
-\\[outline-up-heading] outline-up-heading move from subheading to heading
-
-\\[hide-body] make all text invisible (not headings).
-\\[show-all] make everything in buffer visible.
-\\[hide-sublevels] make only the first N levels of headers visible.
-
-The remaining commands are used when point is on a heading line.
-They apply to some of the body or subheadings of that heading.
-\\[hide-subtree] hide-subtree make body and subheadings invisible.
-\\[show-subtree] show-subtree make body and subheadings visible.
-\\[show-children] show-children make direct subheadings visible.
- No effect on body, or subheadings 2 or more levels down.
- With arg N, affects subheadings N levels down.
-\\[hide-entry] make immediately following body invisible.
-\\[show-entry] make it visible.
-\\[hide-leaves] make body under heading and under its subheadings invisible.
- The subheadings remain visible.
-\\[show-branches] make all subheadings at all levels visible.
+\\{outline-mode-map}
+The commands `outline-hide-subtree', `outline-show-subtree',
+`outline-show-children', `outline-hide-entry',
+`outline-show-entry', `outline-hide-leaves', and `outline-show-branches'
+are used when point is on a heading line.
The variable `outline-regexp' can be changed to control what is a heading.
A line is a heading if `outline-regexp' matches something at the
;;;***
\f
-;;;### (autoloads nil "package" "emacs-lisp/package.el" (21133 20713
-;;;;;; 577800 0))
+;;;### (autoloads nil "package" "emacs-lisp/package.el" (22092 27717
+;;;;;; 636268 464000))
;;; Generated autoloads from emacs-lisp/package.el
(push (purecopy '(package 1 0 1)) package--builtin-versions)
(custom-autoload 'package-enable-at-startup "package" t)
+(autoload 'package-initialize "package" "\
+Load Emacs Lisp packages, and activate them.
+The variable `package-load-list' controls which packages to load.
+If optional arg NO-ACTIVATE is non-nil, don't activate packages.
+If `user-init-file' does not mention `(package-initialize)', add
+it to the file.
+If called as part of loading `user-init-file', set
+`package-enable-at-startup' to nil, to prevent accidentally
+loading packages twice.
+
+\(fn &optional NO-ACTIVATE)" t nil)
+
+(autoload 'package-import-keyring "package" "\
+Import keys from FILE.
+
+\(fn &optional FILE)" t nil)
+
+(autoload 'package-refresh-contents "package" "\
+Download descriptions of all configured ELPA packages.
+For each archive configured in the variable `package-archives',
+inform Emacs about the latest versions of all packages it offers,
+and make them available for download.
+Optional argument ASYNC specifies whether to perform the
+downloads in the background.
+
+\(fn &optional ASYNC)" t nil)
+
(autoload 'package-install "package" "\
Install the package PKG.
-PKG can be a package-desc or the package name of one the available packages
+PKG can be a package-desc or a symbol naming one of the available packages
in an archive in `package-archives'. Interactively, prompt for its name.
-\(fn PKG)" t nil)
+If called interactively or if DONT-SELECT nil, add PKG to
+`package-selected-packages'.
+
+If PKG is a package-desc and it is already installed, don't try
+to install it but still mark it as selected.
+
+\(fn PKG &optional DONT-SELECT)" t nil)
(autoload 'package-install-from-buffer "package" "\
Install a package from the current buffer.
-The current buffer is assumed to be a single .el or .tar file that follows the
-packaging guidelines; see info node `(elisp)Packaging'.
+The current buffer is assumed to be a single .el or .tar file or
+a directory. These must follow the packaging guidelines (see
+info node `(elisp)Packaging').
+
+Specially, if current buffer is a directory, the -pkg.el
+description file is not mandatory, in which case the information
+is derived from the main .el file in the directory.
+
Downloads and installs required packages as needed.
\(fn)" t nil)
(autoload 'package-install-file "package" "\
Install a package from a file.
-The file can either be a tar file or an Emacs Lisp file.
+The file can either be a tar file, an Emacs Lisp file, or a
+directory.
\(fn FILE)" t nil)
-(autoload 'package-import-keyring "package" "\
-Import keys from FILE.
+(autoload 'package-install-selected-packages "package" "\
+Ensure packages in `package-selected-packages' are installed.
+If some packages are not installed propose to install them.
-\(fn &optional FILE)" t nil)
+\(fn)" t nil)
-(autoload 'package-refresh-contents "package" "\
-Download the ELPA archive description if needed.
-This informs Emacs about the latest versions of all packages, and
-makes them available for download.
+(autoload 'package-reinstall "package" "\
+Reinstall package PKG.
+PKG should be either a symbol, the package name, or a package-desc
+object.
-\(fn)" t nil)
+\(fn PKG)" t nil)
-(autoload 'package-initialize "package" "\
-Load Emacs Lisp packages, and activate them.
-The variable `package-load-list' controls which packages to load.
-If optional arg NO-ACTIVATE is non-nil, don't activate packages.
+(autoload 'package-autoremove "package" "\
+Remove packages that are no more needed.
-\(fn &optional NO-ACTIVATE)" t nil)
+Packages that are no more needed by other packages in
+`package-selected-packages' and their dependencies
+will be deleted.
+
+\(fn)" t nil)
(autoload 'describe-package "package" "\
Display the full documentation of PACKAGE (a symbol).
;;;***
\f
-;;;### (autoloads nil "paren" "paren.el" (20903 56815 695483 0))
+;;;### (autoloads nil "paren" "paren.el" (22086 11930 122062 731000))
;;; Generated autoloads from paren.el
(defvar show-paren-mode nil "\
;;;***
\f
-;;;### (autoloads nil "parse-time" "calendar/parse-time.el" (20709
-;;;;;; 26818 907104 0))
+;;;### (autoloads nil "parse-time" "calendar/parse-time.el" (22086
+;;;;;; 11929 534062 731000))
;;; Generated autoloads from calendar/parse-time.el
(put 'parse-time-rules 'risky-local-variable t)
;;;***
\f
-;;;### (autoloads nil "pascal" "progmodes/pascal.el" (20870 12718
-;;;;;; 549931 0))
+;;;### (autoloads nil "pascal" "progmodes/pascal.el" (22092 27718
+;;;;;; 228268 464000))
;;; Generated autoloads from progmodes/pascal.el
(autoload 'pascal-mode "pascal" "\
-Major mode for editing Pascal code.
\\<pascal-mode-map>
+Major mode for editing Pascal code.\\<pascal-mode-map>
TAB indents for Pascal code. Delete converts tabs to spaces as it moves back.
\\[completion-at-point] completes the word around current point with respect to position in code
See also the user variables `pascal-type-keywords', `pascal-start-keywords' and
`pascal-separator-keywords'.
-Turning on Pascal mode calls the value of the variable pascal-mode-hook with
-no args, if that value is non-nil.
-
\(fn)" t nil)
;;;***
\f
-;;;### (autoloads nil "password-cache" "password-cache.el" (20709
-;;;;;; 26818 907104 0))
+;;;### (autoloads nil "password-cache" "password-cache.el" (22086
+;;;;;; 11930 122062 731000))
;;; Generated autoloads from password-cache.el
(defvar password-cache t "\
;;;***
\f
-;;;### (autoloads nil "pcase" "emacs-lisp/pcase.el" (20991 31656
-;;;;;; 363459 0))
+;;;### (autoloads nil "pcase" "emacs-lisp/pcase.el" (22091 6875 247217
+;;;;;; 891000))
;;; Generated autoloads from emacs-lisp/pcase.el
(autoload 'pcase "pcase" "\
-Perform ML-style pattern matching on EXP.
-CASES is a list of elements of the form (UPATTERN CODE...).
+Eval EXP and perform ML-style pattern matching on that value.
+CASES is a list of elements of the form (PATTERN CODE...).
-UPatterns can take the following forms:
+Patterns can take the following forms:
_ matches anything.
- SELFQUOTING matches itself. This includes keywords, numbers, and strings.
SYMBOL matches anything and binds it to SYMBOL.
- (or UPAT...) matches if any of the patterns matches.
- (and UPAT...) matches if all the patterns match.
- `QPAT matches if the QPattern QPAT matches.
- (pred PRED) matches if PRED applied to the object returns non-nil.
+ (or PAT...) matches if any of the patterns matches.
+ (and PAT...) matches if all the patterns match.
+ \\='VAL matches if the object is `equal' to VAL.
+ ATOM is a shorthand for \\='ATOM.
+ ATOM can be a keyword, an integer, or a string.
+ (pred FUN) matches if FUN applied to the object returns non-nil.
(guard BOOLEXP) matches if BOOLEXP evaluates to non-nil.
- (let UPAT EXP) matches if EXP matches UPAT.
+ (let PAT EXP) matches if EXP matches PAT.
+ (app FUN PAT) matches if FUN applied to the object matches PAT.
If a SYMBOL is used twice in the same pattern (i.e. the pattern is
\"non-linear\"), then the second occurrence is turned into an `eq'uality test.
-QPatterns can take the following forms:
- (QPAT1 . QPAT2) matches if QPAT1 matches the car and QPAT2 the cdr.
- ,UPAT matches if the UPattern UPAT matches.
- STRING matches if the object is `equal' to STRING.
- ATOM matches if the object is `eq' to ATOM.
-QPatterns for vectors are not implemented yet.
-
-PRED can take the form
- FUNCTION in which case it gets called with one argument.
- (FUN ARG1 .. ARGN) in which case it gets called with an N+1'th argument
+FUN can take the form
+ SYMBOL or (lambda ARGS BODY) in which case it's called with one argument.
+ (F ARG1 .. ARGn) in which case F gets called with an n+1'th argument
which is the value being matched.
-A PRED of the form FUNCTION is equivalent to one of the form (FUNCTION).
-PRED patterns can refer to variables bound earlier in the pattern.
+So a FUN of the form SYMBOL is equivalent to one of the form (FUN).
+FUN can refer to variables bound earlier in the pattern.
E.g. you can match pairs where the cdr is larger than the car with a pattern
-like `(,a . ,(pred (< a))) or, with more checks:
-`(,(and a (pred numberp)) . ,(and (pred numberp) (pred (< a))))
+like \\=`(,a . ,(pred (< a))) or, with more checks:
+\\=`(,(and a (pred numberp)) . ,(and (pred numberp) (pred (< a))))
+FUN is assumed to be pure, i.e. it can be dropped if its result is not used,
+and two identical calls can be merged into one.
+
+Additional patterns can be defined via `pcase-defmacro'.
+Currently, the following patterns are provided this way:
\(fn EXP &rest CASES)" nil t)
-(put 'pcase 'lisp-indent-function '1)
+(function-put 'pcase 'lisp-indent-function '1)
+
+(autoload 'pcase-exhaustive "pcase" "\
+The exhaustive version of `pcase' (which see).
+
+\(fn EXP &rest CASES)" nil t)
+
+(function-put 'pcase-exhaustive 'lisp-indent-function '1)
+
+(autoload 'pcase-lambda "pcase" "\
+Like `lambda' but allow each argument to be a pattern.
+I.e. accepts the usual &optional and &rest keywords, but every
+formal argument can be any pattern accepted by `pcase' (a mere
+variable name being but a special case of it).
+
+\(fn LAMBDA-LIST &rest BODY)" nil t)
+
+(function-put 'pcase-lambda 'doc-string-elt '2)
+
+(function-put 'pcase-lambda 'lisp-indent-function 'defun)
(autoload 'pcase-let* "pcase" "\
Like `let*' but where you can use `pcase' patterns for bindings.
BODY should be an expression, and BINDINGS should be a list of bindings
-of the form (UPAT EXP).
+of the form (PAT EXP).
\(fn BINDINGS &rest BODY)" nil t)
-(put 'pcase-let* 'lisp-indent-function '1)
+(function-put 'pcase-let* 'lisp-indent-function '1)
(autoload 'pcase-let "pcase" "\
Like `let' but where you can use `pcase' patterns for bindings.
BODY should be a list of expressions, and BINDINGS should be a list of bindings
-of the form (UPAT EXP).
+of the form (PAT EXP).
+The macro is expanded and optimized under the assumption that those
+patterns *will* match, so a mismatch may go undetected or may cause
+any kind of error.
\(fn BINDINGS &rest BODY)" nil t)
-(put 'pcase-let 'lisp-indent-function '1)
+(function-put 'pcase-let 'lisp-indent-function '1)
+
+(autoload 'pcase-dolist "pcase" "\
+
+
+\(fn SPEC &rest BODY)" nil t)
+
+(function-put 'pcase-dolist 'lisp-indent-function '1)
+
+(autoload 'pcase-defmacro "pcase" "\
+Define a new kind of pcase PATTERN, by macro expansion.
+Patterns of the form (NAME ...) will be expanded according
+to this macro.
+
+\(fn NAME ARGS &rest BODY)" nil t)
+
+(function-put 'pcase-defmacro 'lisp-indent-function '2)
+
+(function-put 'pcase-defmacro 'doc-string-elt '3)
;;;***
\f
-;;;### (autoloads nil "pcmpl-cvs" "pcmpl-cvs.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "pcmpl-cvs" "pcmpl-cvs.el" (22086 11930 122062
+;;;;;; 731000))
;;; Generated autoloads from pcmpl-cvs.el
(autoload 'pcomplete/cvs "pcmpl-cvs" "\
;;;***
\f
-;;;### (autoloads nil "pcmpl-gnu" "pcmpl-gnu.el" (20907 7082 901087
-;;;;;; 0))
+;;;### (autoloads nil "pcmpl-gnu" "pcmpl-gnu.el" (22086 11930 122062
+;;;;;; 731000))
;;; Generated autoloads from pcmpl-gnu.el
(autoload 'pcomplete/gzip "pcmpl-gnu" "\
;;;***
\f
-;;;### (autoloads nil "pcmpl-linux" "pcmpl-linux.el" (20884 7264
-;;;;;; 912957 506000))
+;;;### (autoloads nil "pcmpl-linux" "pcmpl-linux.el" (22086 11930
+;;;;;; 122062 731000))
;;; Generated autoloads from pcmpl-linux.el
(autoload 'pcomplete/kill "pcmpl-linux" "\
;;;***
\f
-;;;### (autoloads nil "pcmpl-rpm" "pcmpl-rpm.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "pcmpl-rpm" "pcmpl-rpm.el" (22086 11930 122062
+;;;;;; 731000))
;;; Generated autoloads from pcmpl-rpm.el
(autoload 'pcomplete/rpm "pcmpl-rpm" "\
;;;***
\f
-;;;### (autoloads nil "pcmpl-unix" "pcmpl-unix.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "pcmpl-unix" "pcmpl-unix.el" (22086 11930 122062
+;;;;;; 731000))
;;; Generated autoloads from pcmpl-unix.el
(autoload 'pcomplete/cd "pcmpl-unix" "\
;;;***
\f
-;;;### (autoloads nil "pcmpl-x" "pcmpl-x.el" (21135 15680 63905 0))
+;;;### (autoloads nil "pcmpl-x" "pcmpl-x.el" (22086 11930 122062
+;;;;;; 731000))
;;; Generated autoloads from pcmpl-x.el
(autoload 'pcomplete/tlmgr "pcmpl-x" "\
(autoload 'pcomplete/ack "pcmpl-x" "\
Completion for the `ack' command.
-Start an argument with '-' to complete short options and '--' for
+Start an argument with `-' to complete short options and `--' for
long options.
\(fn)" nil nil)
;;;***
\f
-;;;### (autoloads nil "pcomplete" "pcomplete.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "pcomplete" "pcomplete.el" (22086 11930 122062
+;;;;;; 731000))
;;; Generated autoloads from pcomplete.el
(autoload 'pcomplete "pcomplete" "\
;;;***
\f
-;;;### (autoloads nil "pcvs" "vc/pcvs.el" (21104 56491 538513 0))
+;;;### (autoloads nil "pcvs" "vc/pcvs.el" (22092 27718 548268 464000))
;;; Generated autoloads from vc/pcvs.el
(autoload 'cvs-checkout "pcvs" "\
-Run a 'cvs checkout MODULES' in DIR.
+Run a `cvs checkout MODULES' in DIR.
Feed the output to a *cvs* buffer, display it in the current window,
and run `cvs-mode' on it.
(defvar cvs-dired-use-hook '(4) "\
Whether or not opening a CVS directory should run PCL-CVS.
A value of nil means never do it.
-ALWAYS means to always do it unless a prefix argument is given to the
+`always' means to always do it unless a prefix argument is given to the
command that prompted the opening of the directory.
Anything else means to do it only if the prefix arg is equal to this value.")
;;;***
\f
-;;;### (autoloads nil "pcvs-defs" "vc/pcvs-defs.el" (21075 56234
-;;;;;; 349623 0))
+;;;### (autoloads nil "pcvs-defs" "vc/pcvs-defs.el" (22086 11930
+;;;;;; 378062 731000))
;;; Generated autoloads from vc/pcvs-defs.el
(defvar cvs-global-menu (let ((m (make-sparse-keymap "PCL-CVS"))) (define-key m [status] `(menu-item ,(purecopy "Directory Status") cvs-status :help ,(purecopy "A more verbose status of a workarea"))) (define-key m [checkout] `(menu-item ,(purecopy "Checkout Module") cvs-checkout :help ,(purecopy "Check out a module from the repository"))) (define-key m [update] `(menu-item ,(purecopy "Update Directory") cvs-update :help ,(purecopy "Fetch updates from the repository"))) (define-key m [examine] `(menu-item ,(purecopy "Examine Directory") cvs-examine :help ,(purecopy "Examine the current state of a workarea"))) (fset 'cvs-global-menu m)) "\
;;;***
\f
-;;;### (autoloads nil "perl-mode" "progmodes/perl-mode.el" (21075
-;;;;;; 56234 349623 0))
+;;;### (autoloads nil "perl-mode" "progmodes/perl-mode.el" (22086
+;;;;;; 11930 214062 731000))
;;; Generated autoloads from progmodes/perl-mode.el
(put 'perl-indent-level 'safe-local-variable 'integerp)
(put 'perl-continued-statement-offset 'safe-local-variable 'integerp)
;;;***
\f
-;;;### (autoloads nil "picture" "textmodes/picture.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "picture" "textmodes/picture.el" (22086 11930
+;;;;;; 318062 731000))
;;; Generated autoloads from textmodes/picture.el
(autoload 'picture-mode "picture" "\
;;;***
\f
-;;;### (autoloads nil "plstore" "gnus/plstore.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "pinentry" "net/pinentry.el" (22086 11930 2062
+;;;;;; 731000))
+;;; Generated autoloads from net/pinentry.el
+(push (purecopy '(pinentry 0 1)) package--builtin-versions)
+
+(autoload 'pinentry-start "pinentry" "\
+Start a Pinentry service.
+
+Once the environment is properly set, subsequent invocations of
+the gpg command will interact with Emacs for passphrase input.
+
+If the optional QUIET argument is non-nil, messages at startup
+will not be shown.
+
+\(fn &optional QUIET)" t nil)
+
+;;;***
+\f
+;;;### (autoloads nil "plstore" "gnus/plstore.el" (22086 11929 842062
+;;;;;; 731000))
;;; Generated autoloads from gnus/plstore.el
(autoload 'plstore-open "plstore" "\
;;;***
\f
-;;;### (autoloads nil "po" "textmodes/po.el" (20791 9657 561026 0))
+;;;### (autoloads nil "po" "textmodes/po.el" (22086 11930 322062
+;;;;;; 731000))
;;; Generated autoloads from textmodes/po.el
(autoload 'po-find-file-coding-system "po" "\
;;;***
\f
-;;;### (autoloads nil "pong" "play/pong.el" (20709 26818 907104 0))
+;;;### (autoloads nil "pong" "play/pong.el" (22086 11930 130062 731000))
;;; Generated autoloads from play/pong.el
(autoload 'pong "pong" "\
;;;***
\f
-;;;### (autoloads nil "pop3" "gnus/pop3.el" (20709 26818 907104 0))
+;;;### (autoloads nil "pop3" "gnus/pop3.el" (22086 11929 846062 731000))
;;; Generated autoloads from gnus/pop3.el
(autoload 'pop3-movemail "pop3" "\
;;;***
\f
-;;;### (autoloads nil "pp" "emacs-lisp/pp.el" (21013 58662 278539
-;;;;;; 0))
+;;;### (autoloads nil "pp" "emacs-lisp/pp.el" (22086 11929 682062
+;;;;;; 731000))
;;; Generated autoloads from emacs-lisp/pp.el
(autoload 'pp-to-string "pp" "\
;;;***
\f
-;;;### (autoloads nil "printing" "printing.el" (21032 23080 765139
-;;;;;; 0))
+;;;### (autoloads nil "printing" "printing.el" (22092 27718 128268
+;;;;;; 464000))
;;; Generated autoloads from printing.el
(push (purecopy '(printing 6 9 3)) package--builtin-versions)
;;;***
\f
-;;;### (autoloads nil "proced" "proced.el" (20709 26818 907104 0))
+;;;### (autoloads nil "proced" "proced.el" (22092 27718 128268 464000))
;;; Generated autoloads from proced.el
(autoload 'proced "proced" "\
;;;***
\f
-;;;### (autoloads nil "profiler" "profiler.el" (21077 11573 151993
-;;;;;; 0))
+;;;### (autoloads nil "profiler" "profiler.el" (22086 11930 134062
+;;;;;; 731000))
;;; Generated autoloads from profiler.el
(autoload 'profiler-start "profiler" "\
;;;***
\f
-;;;### (autoloads nil "prolog" "progmodes/prolog.el" (21112 54200
-;;;;;; 857404 0))
+;;;### (autoloads nil "project" "progmodes/project.el" (22088 30660
+;;;;;; 79412 927000))
+;;; Generated autoloads from progmodes/project.el
+
+(autoload 'project-current "project" "\
+Return the project instance in DIR or `default-directory'.
+When no project found in DIR, and MAYBE-PROMPT is non-nil, ask
+the user for a different directory to look in.
+
+\(fn &optional MAYBE-PROMPT DIR)" nil nil)
+
+(autoload 'project-find-regexp "project" "\
+Find all matches for REGEXP in the current project.
+With \\[universal-argument] prefix, you can specify the directory
+to search in, and the file name pattern to search for.
+
+\(fn REGEXP)" t nil)
+
+(autoload 'project-or-libraries-find-regexp "project" "\
+Find all matches for REGEXP in the current project or libraries.
+With \\[universal-argument] prefix, you can specify the file name
+pattern to search for.
+
+\(fn REGEXP)" t nil)
+
+;;;***
+\f
+;;;### (autoloads nil "prolog" "progmodes/prolog.el" (22086 11930
+;;;;;; 218062 731000))
;;; Generated autoloads from progmodes/prolog.el
(autoload 'prolog-mode "prolog" "\
;;;***
\f
-;;;### (autoloads nil "ps-bdf" "ps-bdf.el" (20799 169 640767 0))
+;;;### (autoloads nil "ps-bdf" "ps-bdf.el" (22092 27718 404268 464000))
;;; Generated autoloads from ps-bdf.el
(defvar bdf-directory-list (if (memq system-type '(ms-dos windows-nt)) (list (expand-file-name "fonts/bdf" installation-directory)) '("/usr/local/share/emacs/fonts/bdf")) "\
List of directories to search for `BDF' font files.
-The default value is '(\"/usr/local/share/emacs/fonts/bdf\").")
+The default value is (\"/usr/local/share/emacs/fonts/bdf\").")
(custom-autoload 'bdf-directory-list "ps-bdf" t)
;;;***
\f
-;;;### (autoloads nil "ps-mode" "progmodes/ps-mode.el" (20777 63161
-;;;;;; 848428 0))
+;;;### (autoloads nil "ps-mode" "progmodes/ps-mode.el" (22086 11930
+;;;;;; 218062 731000))
;;; Generated autoloads from progmodes/ps-mode.el
(push (purecopy '(ps-mode 1 1 9)) package--builtin-versions)
The following variables hold user options, and can
be set through the `customize' command:
- `ps-mode-auto-indent'
`ps-mode-tab'
`ps-mode-paper-size'
`ps-mode-print-function'
;;;***
\f
-;;;### (autoloads nil "ps-print" "ps-print.el" (21122 3638 533479
-;;;;;; 0))
+;;;### (autoloads nil "ps-print" "ps-print.el" (22092 27718 412268
+;;;;;; 464000))
;;; Generated autoloads from ps-print.el
(push (purecopy '(ps-print 7 3 5)) package--builtin-versions)
(autoload 'ps-line-lengths "ps-print" "\
Display the correspondence between a line length and a font size.
Done using the current ps-print setup.
-Try: pr -t file | awk '{printf \"%3d %s
-\", length($0), $0}' | sort -r | head
+Try: pr -t file | awk \\='{printf \"%3d %s
+\", length($0), $0}\\=' | sort -r | head
\(fn)" t nil)
;;;***
\f
-;;;### (autoloads nil "pulse" "cedet/pulse.el" (21106 11815 370918
-;;;;;; 0))
+;;;### (autoloads nil "pulse" "cedet/pulse.el" (22086 11929 550062
+;;;;;; 731000))
;;; Generated autoloads from cedet/pulse.el
(push (purecopy '(pulse 1 0)) package--builtin-versions)
+(autoload 'pulse-momentary-highlight-one-line "pulse" "\
+Highlight the line around POINT, unhighlighting before next command.
+Optional argument FACE specifies the face to do the highlighting.
+
+\(fn POINT &optional FACE)" nil nil)
+
+(autoload 'pulse-momentary-highlight-region "pulse" "\
+Highlight between START and END, unhighlighting before next command.
+Optional argument FACE specifies the face to do the highlighting.
+
+\(fn START END &optional FACE)" nil nil)
+
;;;***
\f
-;;;### (autoloads nil "python" "progmodes/python.el" (21144 30651
-;;;;;; 337793 0))
+;;;### (autoloads nil "python" "progmodes/python.el" (22092 27718
+;;;;;; 244268 464000))
;;; Generated autoloads from progmodes/python.el
-(push (purecopy '(python 0 24 2)) package--builtin-versions)
+(push (purecopy '(python 0 25 1)) package--builtin-versions)
-(add-to-list 'auto-mode-alist (cons (purecopy "\\.py\\'") 'python-mode))
+(add-to-list 'auto-mode-alist (cons (purecopy "\\.pyw?\\'") 'python-mode))
(add-to-list 'interpreter-mode-alist (cons (purecopy "python[0-9.]*") 'python-mode))
(autoload 'run-python "python" "\
Run an inferior Python process.
-Input and output via buffer named after
-`python-shell-buffer-name'. If there is a process already
-running in that buffer, just switch to it.
-With argument, allows you to define CMD so you can edit the
-command used to call the interpreter and define DEDICATED, so a
-dedicated process for the current buffer is open. When numeric
-prefix arg is other than 0 or 4 do not SHOW.
+Argument CMD defaults to `python-shell-calculate-command' return
+value. When called interactively with `prefix-arg', it allows
+the user to edit such value and choose whether the interpreter
+should be DEDICATED for the current buffer. When numeric prefix
+arg is other than 0 or 4 do not SHOW.
-Runs the hook `inferior-python-mode-hook' (after the
-`comint-mode-hook' is run). (Type \\[describe-mode] in the
+For a given buffer and same values of DEDICATED, if a process is
+already running for it, it will do nothing. This means that if
+the current buffer is using a global process, the user is still
+able to switch it to use a dedicated one.
+
+Runs the hook `inferior-python-mode-hook' after
+`comint-mode-hook' is run. (Type \\[describe-mode] in the
process buffer for a list of commands.)
-\(fn CMD &optional DEDICATED SHOW)" t nil)
+\(fn &optional CMD DEDICATED SHOW)" t nil)
(autoload 'python-mode "python" "\
Major mode for editing Python files.
;;;***
\f
-;;;### (autoloads nil "qp" "gnus/qp.el" (20709 26818 907104 0))
+;;;### (autoloads nil "qp" "gnus/qp.el" (22086 11929 846062 731000))
;;; Generated autoloads from gnus/qp.el
(autoload 'quoted-printable-decode-region "qp" "\
;;;***
\f
-;;;### (autoloads nil "quail" "international/quail.el" (21113 26590
-;;;;;; 654875 0))
+;;;### (autoloads nil "quail" "international/quail.el" (22086 11929
+;;;;;; 882062 731000))
;;; Generated autoloads from international/quail.el
(autoload 'quail-title "quail" "\
documentation of `quail-keyboard-layout' and
`quail-keyboard-layout-standard' for more detail.
-SHOW-LAYOUT non-nil means the `quail-help' command should show
-the user's keyboard layout visually with translated characters.
-If KBD-TRANSLATE is set, it is desirable to set also this flag unless
-this package defines no translations for single character keys.
+SHOW-LAYOUT non-nil means the function `quail-help' (as used by
+the command `describe-input-method') should show the user's keyboard
+layout visually with translated characters. If KBD-TRANSLATE is
+set, it is desirable to also set this flag, unless this package
+defines no translations for single character keys.
CREATE-DECODE-MAP non-nil means decode map is also created. A decode
map is an alist of translations and corresponding original keys.
;;;***
\f
-;;;### (autoloads nil "quail/hangul" "leim/quail/hangul.el" (21141
-;;;;;; 54458 609734 0))
+;;;### (autoloads nil "quail/hangul" "leim/quail/hangul.el" (22086
+;;;;;; 11929 922062 731000))
;;; Generated autoloads from leim/quail/hangul.el
(autoload 'hangul-input-method-activate "quail/hangul" "\
;;;***
\f
;;;### (autoloads nil "quail/uni-input" "leim/quail/uni-input.el"
-;;;;;; (21141 54458 609734 0))
+;;;;;; (22086 11929 930062 731000))
;;; Generated autoloads from leim/quail/uni-input.el
(autoload 'ucs-input-activate "quail/uni-input" "\
;;;***
\f
-;;;### (autoloads nil "quickurl" "net/quickurl.el" (21040 17194 398147
-;;;;;; 0))
+;;;### (autoloads nil "quickurl" "net/quickurl.el" (22086 11930 2062
+;;;;;; 731000))
;;; Generated autoloads from net/quickurl.el
(defconst quickurl-reread-hook-postfix "\n;; Local Variables:\n;; eval: (progn (require 'quickurl) (add-hook 'local-write-file-hooks (lambda () (quickurl-read) nil)))\n;; End:\n" "\
;;;***
\f
-;;;### (autoloads nil "rcirc" "net/rcirc.el" (21113 26590 654875
-;;;;;; 0))
+;;;### (autoloads nil "rcirc" "net/rcirc.el" (22092 27717 984268
+;;;;;; 464000))
;;; Generated autoloads from net/rcirc.el
(autoload 'rcirc "rcirc" "\
;;;***
\f
-;;;### (autoloads nil "re-builder" "emacs-lisp/re-builder.el" (20984
-;;;;;; 58408 354075 0))
+;;;### (autoloads nil "re-builder" "emacs-lisp/re-builder.el" (22086
+;;;;;; 11929 682062 731000))
;;; Generated autoloads from emacs-lisp/re-builder.el
(defalias 'regexp-builder 're-builder)
;;;***
\f
-;;;### (autoloads nil "recentf" "recentf.el" (20871 33574 214287
-;;;;;; 0))
+;;;### (autoloads nil "recentf" "recentf.el" (22086 11930 254062
+;;;;;; 731000))
;;; Generated autoloads from recentf.el
(defvar recentf-mode nil "\
;;;***
\f
-;;;### (autoloads nil "rect" "rect.el" (21120 48308 922449 0))
+;;;### (autoloads nil "rect" "rect.el" (22087 9807 394279 951000))
;;; Generated autoloads from rect.el
(autoload 'delete-rectangle "rect" "\
;;;***
\f
-;;;### (autoloads nil "refill" "textmodes/refill.el" (20884 7264
-;;;;;; 912957 506000))
+;;;### (autoloads nil "refill" "textmodes/refill.el" (22086 11930
+;;;;;; 322062 731000))
;;; Generated autoloads from textmodes/refill.el
(autoload 'refill-mode "refill" "\
;;;***
\f
-;;;### (autoloads nil "reftex" "textmodes/reftex.el" (20928 13222
-;;;;;; 500272 0))
+;;;### (autoloads nil "reftex" "textmodes/reftex.el" (22086 11930
+;;;;;; 330062 731000))
;;; Generated autoloads from textmodes/reftex.el
+(autoload 'reftex-citation "reftex-cite" nil t)
+(autoload 'reftex-all-document-files "reftex-parse")
+(autoload 'reftex-isearch-minor-mode "reftex-global" nil t)
+(autoload 'reftex-index-phrases-mode "reftex-index" nil t)
(autoload 'turn-on-reftex "reftex" "\
Turn on RefTeX mode.
;;;***
\f
-;;;### (autoloads nil "reftex-cite" "textmodes/reftex-cite.el" (20921
-;;;;;; 39978 248467 0))
-;;; Generated autoloads from textmodes/reftex-cite.el
-
-(autoload '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 formatted according
-to `reftex-cite-format' and inserted into the buffer.
+;;;### (autoloads nil "reftex-vars" "textmodes/reftex-vars.el" (22092
+;;;;;; 27718 512268 464000))
+;;; Generated autoloads from textmodes/reftex-vars.el
+(put 'reftex-vref-is-default 'safe-local-variable (lambda (x) (or (stringp x) (symbolp x))))
+(put 'reftex-fref-is-default 'safe-local-variable (lambda (x) (or (stringp x) (symbolp x))))
+(put 'reftex-level-indent 'safe-local-variable 'integerp)
+(put 'reftex-guess-label-type 'safe-local-variable (lambda (x) (memq x '(nil t))))
-If NO-INSERT is non-nil, nothing is inserted, only the selected key returned.
-
-FORMAT-KEY can be used to pre-select a citation format.
-
-When called with a `C-u' prefix, prompt for optional arguments in
-cite macros. When called with a numeric prefix, make that many
-citations. When called with point inside the braces of a `\\cite'
-command, it will add another key, ignoring the value of
-`reftex-cite-format'.
-
-The regular expression uses an expanded syntax: && is interpreted as `and'.
-Thus, `aaaa&&bbb' matches entries which contain both `aaaa' and `bbb'.
-While entering the regexp, completion on knows citation keys is possible.
-`=' is a good regular expression to match all entries in all files.
-
-\(fn &optional NO-INSERT FORMAT-KEY)" t nil)
-
-;;;***
-\f
-;;;### (autoloads nil "reftex-global" "textmodes/reftex-global.el"
-;;;;;; (20709 26818 907104 0))
-;;; Generated autoloads from textmodes/reftex-global.el
-
-(autoload 'reftex-isearch-minor-mode "reftex-global" "\
-When on, isearch searches the whole document, not only the current file.
-This minor mode allows isearch to search through all the files of
-the current TeX document.
-
-With no argument, this command toggles
-`reftex-isearch-minor-mode'. With a prefix argument ARG, turn
-`reftex-isearch-minor-mode' on if ARG is positive, otherwise turn it off.
-
-\(fn &optional ARG)" t nil)
-
-;;;***
-\f
-;;;### (autoloads nil "reftex-index" "textmodes/reftex-index.el"
-;;;;;; (20709 26818 907104 0))
-;;; Generated autoloads from textmodes/reftex-index.el
-
-(autoload 'reftex-index-phrases-mode "reftex-index" "\
-Major mode for managing the Index phrases of a LaTeX document.
-This buffer was created with RefTeX.
-
-To insert new phrases, use
- - `C-c \\' in the LaTeX document to copy selection or word
- - `\\[reftex-index-new-phrase]' in the phrases buffer.
-
-To index phrases use one of:
-
-\\[reftex-index-this-phrase] index current phrase
-\\[reftex-index-next-phrase] index next phrase (or N with prefix arg)
-\\[reftex-index-all-phrases] index all phrases
-\\[reftex-index-remaining-phrases] index current and following phrases
-\\[reftex-index-region-phrases] index the phrases in the region
-
-You can sort the phrases in this buffer with \\[reftex-index-sort-phrases].
-To display information about the phrase at point, use \\[reftex-index-phrases-info].
-
-For more information see the RefTeX User Manual.
-
-Here are all local bindings.
-
-\\{reftex-index-phrases-mode-map}
-
-\(fn)" t nil)
-
-;;;***
-\f
-;;;### (autoloads nil "reftex-parse" "textmodes/reftex-parse.el"
-;;;;;; (21107 58096 588457 0))
-;;; Generated autoloads from textmodes/reftex-parse.el
-
-(autoload 'reftex-all-document-files "reftex-parse" "\
-Return a list of all files belonging to the current document.
-When RELATIVE is non-nil, give file names relative to directory
-of master file.
-
-\(fn &optional RELATIVE)" nil nil)
-
-;;;***
-\f
-;;;### (autoloads nil "reftex-vars" "textmodes/reftex-vars.el" (20895
-;;;;;; 15912 444844 0))
-;;; Generated autoloads from textmodes/reftex-vars.el
-(put 'reftex-vref-is-default 'safe-local-variable (lambda (x) (or (stringp x) (symbolp x))))
-(put 'reftex-fref-is-default 'safe-local-variable (lambda (x) (or (stringp x) (symbolp x))))
-(put 'reftex-level-indent 'safe-local-variable 'integerp)
-(put 'reftex-guess-label-type 'safe-local-variable (lambda (x) (memq x '(nil t))))
-
-;;;***
-\f
-;;;### (autoloads nil "regexp-opt" "emacs-lisp/regexp-opt.el" (20709
-;;;;;; 26818 907104 0))
-;;; Generated autoloads from emacs-lisp/regexp-opt.el
+;;;***
+\f
+;;;### (autoloads nil "regexp-opt" "emacs-lisp/regexp-opt.el" (22086
+;;;;;; 11929 682062 731000))
+;;; Generated autoloads from emacs-lisp/regexp-opt.el
(autoload 'regexp-opt "regexp-opt" "\
Return a regexp to match a string in the list STRINGS.
The returned regexp is typically more efficient than the equivalent regexp:
(let ((open (if PAREN \"\\\\(\" \"\")) (close (if PAREN \"\\\\)\" \"\")))
- (concat open (mapconcat 'regexp-quote STRINGS \"\\\\|\") close))
+ (concat open (mapconcat \\='regexp-quote STRINGS \"\\\\|\") close))
If PAREN is `words', then the resulting regexp is additionally surrounded
by \\=\\< and \\>.
;;;***
\f
-;;;### (autoloads nil "regi" "emacs-lisp/regi.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "regi" "emacs-lisp/regi.el" (22086 11929 682062
+;;;;;; 731000))
;;; Generated autoloads from emacs-lisp/regi.el
(push (purecopy '(regi 1 8)) package--builtin-versions)
;;;***
\f
-;;;### (autoloads nil "remember" "textmodes/remember.el" (21093 51772
-;;;;;; 844670 0))
+;;;### (autoloads nil "remember" "textmodes/remember.el" (22086 11930
+;;;;;; 334062 731000))
;;; Generated autoloads from textmodes/remember.el
(push (purecopy '(remember 2 0)) package--builtin-versions)
\(fn)" nil nil)
(autoload 'remember-notes "remember" "\
-Creates notes buffer and switches to it if called interactively.
-
-If a notes buffer created by a previous invocation of this
-function already exist, it will be returned. Otherwise a new
-buffer will be created whose content will be read from file
-pointed by `remember-data-file'. If a buffer visiting this file
-already exist, that buffer will be used instead of creating a new
-one (see `find-file-noselect' function for more details).
-
-Name of the created buffer is taken from `remember-notes-buffer-name'
-variable and if a buffer with that name already exist (but was not
-created by this function), it will be first killed.
-\\<remember-notes-mode-map>
-`remember-notes-mode' is active in the notes buffer which by default
-contains only one \\[save-and-bury-buffer] binding which saves and
-buries the buffer.
-
-Function returns notes buffer. When called interactively,
-switches to it as well.
-
-Notes buffer is meant for keeping random notes which you'd like to
-preserve across Emacs restarts. The notes will be stored in the
-`remember-data-file'.
+Return the notes buffer, creating it if needed, and maybe switch to it.
+This buffer is for notes that you want to preserve across Emacs sessions.
+The notes are saved in `remember-data-file'.
+
+If a buffer is already visiting that file, just return it.
+
+Otherwise, create the buffer, and rename it to `remember-notes-buffer-name',
+unless a buffer of that name already exists. Set the major mode according
+to `remember-notes-initial-major-mode', and enable `remember-notes-mode'
+minor mode.
+
+Use \\<remember-notes-mode-map>\\[remember-notes-save-and-bury-buffer] to save and bury the notes buffer.
+
+Interactively, or if SWITCH-TO is non-nil, switch to the buffer.
+Return the buffer.
+
+Set `initial-buffer-choice' to `remember-notes' to visit your notes buffer
+when Emacs starts. Set `remember-notes-buffer-name' to \"*scratch*\"
+to turn the *scratch* buffer into your notes buffer.
\(fn &optional SWITCH-TO)" t nil)
;;;***
\f
-;;;### (autoloads nil "repeat" "repeat.el" (20709 26818 907104 0))
+;;;### (autoloads nil "repeat" "repeat.el" (22086 11930 258062 731000))
;;; Generated autoloads from repeat.el
(push (purecopy '(repeat 0 51)) package--builtin-versions)
;;;***
\f
-;;;### (autoloads nil "reporter" "mail/reporter.el" (20921 39978
-;;;;;; 248467 0))
+;;;### (autoloads nil "reporter" "mail/reporter.el" (22086 11929
+;;;;;; 938062 731000))
;;; Generated autoloads from mail/reporter.el
(autoload 'reporter-submit-bug-report "reporter" "\
;;;***
\f
-;;;### (autoloads nil "reposition" "reposition.el" (20992 52525 458637
-;;;;;; 0))
+;;;### (autoloads nil "reposition" "reposition.el" (22086 11930 262062
+;;;;;; 731000))
;;; Generated autoloads from reposition.el
(autoload 'reposition-window "reposition" "\
;;;***
\f
-;;;### (autoloads nil "reveal" "reveal.el" (21041 38058 75002 0))
+;;;### (autoloads nil "reveal" "reveal.el" (22086 11930 262062 731000))
;;; Generated autoloads from reveal.el
(autoload 'reveal-mode "reveal" "\
;;;***
\f
-;;;### (autoloads nil "ring" "emacs-lisp/ring.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "ring" "emacs-lisp/ring.el" (22086 11929 682062
+;;;;;; 731000))
;;; Generated autoloads from emacs-lisp/ring.el
(autoload 'ring-p "ring" "\
;;;***
\f
-;;;### (autoloads nil "rlogin" "net/rlogin.el" (20903 10024 645978
-;;;;;; 0))
+;;;### (autoloads nil "rlogin" "net/rlogin.el" (22086 11930 6062
+;;;;;; 731000))
;;; Generated autoloads from net/rlogin.el
(autoload 'rlogin "rlogin" "\
;;;***
\f
-;;;### (autoloads nil "rmail" "mail/rmail.el" (21105 26139 752484
-;;;;;; 0))
+;;;### (autoloads nil "rmail" "mail/rmail.el" (22092 27717 884268
+;;;;;; 464000))
;;; Generated autoloads from mail/rmail.el
(defvar rmail-file-name (purecopy "~/RMAIL") "\
(autoload 'rmail-movemail-variant-p "rmail" "\
Return t if the current movemail variant is any of VARIANTS.
-Currently known variants are 'emacs and 'mailutils.
+Currently known variants are `emacs' and `mailutils'.
\(fn &rest VARIANTS)" nil nil)
;;;***
\f
-;;;### (autoloads nil "rmailout" "mail/rmailout.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "rmailout" "mail/rmailout.el" (22086 11929
+;;;;;; 942062 731000))
;;; Generated autoloads from mail/rmailout.el
(put 'rmail-output-file-alist 'risky-local-variable t)
;;;***
\f
-;;;### (autoloads nil "rng-cmpct" "nxml/rng-cmpct.el" (20998 4934
-;;;;;; 952905 0))
+;;;### (autoloads nil "rng-cmpct" "nxml/rng-cmpct.el" (22086 11930
+;;;;;; 26062 731000))
;;; Generated autoloads from nxml/rng-cmpct.el
(autoload 'rng-c-load-schema "rng-cmpct" "\
;;;***
\f
-;;;### (autoloads nil "rng-nxml" "nxml/rng-nxml.el" (20813 33065
-;;;;;; 721081 0))
+;;;### (autoloads nil "rng-nxml" "nxml/rng-nxml.el" (22086 11930
+;;;;;; 30062 731000))
;;; Generated autoloads from nxml/rng-nxml.el
(autoload 'rng-nxml-mode-init "rng-nxml" "\
;;;***
\f
-;;;### (autoloads nil "rng-valid" "nxml/rng-valid.el" (20884 6711
-;;;;;; 386198 0))
+;;;### (autoloads nil "rng-valid" "nxml/rng-valid.el" (22086 11930
+;;;;;; 30062 731000))
;;; Generated autoloads from nxml/rng-valid.el
(autoload 'rng-validate-mode "rng-valid" "\
;;;***
\f
-;;;### (autoloads nil "rng-xsd" "nxml/rng-xsd.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "rng-xsd" "nxml/rng-xsd.el" (22086 11930 30062
+;;;;;; 731000))
;;; Generated autoloads from nxml/rng-xsd.el
(put 'http://www\.w3\.org/2001/XMLSchema-datatypes 'rng-dt-compile 'rng-xsd-compile)
;;;***
\f
-;;;### (autoloads nil "robin" "international/robin.el" (20523 62082
-;;;;;; 997685 0))
+;;;### (autoloads nil "robin" "international/robin.el" (22086 11929
+;;;;;; 882062 731000))
;;; Generated autoloads from international/robin.el
(autoload 'robin-define-package "robin" "\
;;;***
\f
-;;;### (autoloads nil "rot13" "rot13.el" (20992 52525 458637 0))
+;;;### (autoloads nil "rot13" "rot13.el" (22086 11930 266062 731000))
;;; Generated autoloads from rot13.el
(autoload 'rot13 "rot13" "\
;;;***
\f
-;;;### (autoloads nil "rst" "textmodes/rst.el" (20932 10282 564846
-;;;;;; 0))
+;;;### (autoloads nil "rst" "textmodes/rst.el" (22086 11930 338062
+;;;;;; 731000))
;;; Generated autoloads from textmodes/rst.el
(add-to-list 'auto-mode-alist (purecopy '("\\.re?st\\'" . rst-mode)))
;;;***
\f
-;;;### (autoloads nil "ruby-mode" "progmodes/ruby-mode.el" (21135
-;;;;;; 48053 151871 0))
+;;;### (autoloads nil "ruby-mode" "progmodes/ruby-mode.el" (22089
+;;;;;; 51528 360929 316000))
;;; Generated autoloads from progmodes/ruby-mode.el
(push (purecopy '(ruby-mode 1 2)) package--builtin-versions)
\(fn)" t nil)
-(add-to-list 'auto-mode-alist (cons (purecopy (concat "\\(?:\\." "rb\\|ru\\|rake\\|thor" "\\|jbuilder\\|gemspec" "\\|/" "\\(?:Gem\\|Rake\\|Cap\\|Thor" "Vagrant\\|Guard\\)file" "\\)\\'")) 'ruby-mode))
+(add-to-list 'auto-mode-alist (cons (purecopy (concat "\\(?:\\.\\(?:" "rbw?\\|ru\\|rake\\|thor" "\\|jbuilder\\|rabl\\|gemspec\\|podspec" "\\)" "\\|/" "\\(?:Gem\\|Rake\\|Cap\\|Thor" "\\|Puppet\\|Berks" "\\|Vagrant\\|Guard\\|Pod\\)file" "\\)\\'")) 'ruby-mode))
(dolist (name (list "ruby" "rbx" "jruby" "ruby1.9" "ruby1.8")) (add-to-list 'interpreter-mode-alist (cons (purecopy name) 'ruby-mode)))
;;;***
\f
-;;;### (autoloads nil "ruler-mode" "ruler-mode.el" (20791 9657 561026
-;;;;;; 0))
+;;;### (autoloads nil "ruler-mode" "ruler-mode.el" (22086 11930 266062
+;;;;;; 731000))
;;; Generated autoloads from ruler-mode.el
(push (purecopy '(ruler-mode 1 6)) package--builtin-versions)
;;;***
\f
-;;;### (autoloads nil "rx" "emacs-lisp/rx.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "rx" "emacs-lisp/rx.el" (22086 11929 686062
+;;;;;; 731000))
;;; Generated autoloads from emacs-lisp/rx.el
(autoload 'rx-to-string "rx" "\
REGEXPS is a non-empty sequence of forms of the sort listed below.
Note that `rx' is a Lisp macro; when used in a Lisp program being
- compiled, the translation is performed by the compiler.
+compiled, the translation is performed by the compiler.
See `rx-to-string' for how to do such a translation at run-time.
The following are valid subforms of regular expressions in sexp
matches space and tab only.
`graphic', `graph'
- matches graphic characters--everything except ASCII control chars,
- space, and DEL.
+ matches graphic characters--everything except whitespace, ASCII
+ and non-ASCII control characters, surrogates, and codepoints
+ unassigned by Unicode.
`printing', `print'
- matches printing characters--everything except ASCII control chars
- and DEL.
+ matches whitespace and graphic characters.
`alphanumeric', `alnum'
- matches letters and digits. (But at present, for multibyte characters,
- it matches anything that has word syntax.)
+ matches alphabetic characters and digits. (For multibyte characters,
+ it matches according to Unicode character properties.)
`letter', `alphabetic', `alpha'
- matches letters. (But at present, for multibyte characters,
- it matches anything that has word syntax.)
+ matches alphabetic characters. (For multibyte characters,
+ it matches according to Unicode character properties.)
`ascii'
matches ASCII (unibyte) characters.
`not-at-end-of-line' (\\c<)
`not-at-beginning-of-line' (\\c>)
`alpha-numeric-two-byte' (\\cA)
- `chinse-two-byte' (\\cC)
+ `chinese-two-byte' (\\cC)
`greek-two-byte' (\\cG)
`japanese-hiragana-two-byte' (\\cH)
`indian-tow-byte' (\\cI)
;;;***
\f
-;;;### (autoloads nil "sasl-ntlm" "net/sasl-ntlm.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "sasl-ntlm" "net/sasl-ntlm.el" (22086 11930
+;;;;;; 6062 731000))
;;; Generated autoloads from net/sasl-ntlm.el
(push (purecopy '(sasl 1 0)) package--builtin-versions)
;;;***
\f
-;;;### (autoloads nil "savehist" "savehist.el" (21040 42923 330142
-;;;;;; 838000))
+;;;### (autoloads nil "savehist" "savehist.el" (22086 11930 266062
+;;;;;; 731000))
;;; Generated autoloads from savehist.el
(push (purecopy '(savehist 24)) package--builtin-versions)
;;;***
\f
-;;;### (autoloads nil "scheme" "progmodes/scheme.el" (21112 54200
-;;;;;; 857404 0))
+;;;### (autoloads nil "saveplace" "saveplace.el" (22086 11930 266062
+;;;;;; 731000))
+;;; Generated autoloads from saveplace.el
+
+(defvar save-place-mode nil "\
+Non-nil if Save-Place mode is enabled.
+See the command `save-place-mode' for a description of this minor mode.
+Setting this variable directly does not take effect;
+either customize it (see the info node `Easy Customization')
+or call the function `save-place-mode'.")
+
+(custom-autoload 'save-place-mode "saveplace" nil)
+
+(autoload 'save-place-mode "saveplace" "\
+Non-nil means automatically save place in each file.
+This means when you visit a file, point goes to the last place
+where it was when you previously visited the same file.
+
+\(fn &optional ARG)" t nil)
+
+;;;***
+\f
+;;;### (autoloads nil "scheme" "progmodes/scheme.el" (22086 11930
+;;;;;; 222062 731000))
;;; Generated autoloads from progmodes/scheme.el
(autoload 'scheme-mode "scheme" "\
;;;***
\f
-;;;### (autoloads nil "score-mode" "gnus/score-mode.el" (21040 17194
-;;;;;; 398147 0))
+;;;### (autoloads nil "score-mode" "gnus/score-mode.el" (22086 11929
+;;;;;; 850062 731000))
;;; Generated autoloads from gnus/score-mode.el
(autoload 'gnus-score-mode "score-mode" "\
;;;***
\f
-;;;### (autoloads nil "scroll-all" "scroll-all.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "scroll-all" "scroll-all.el" (22089 51528 372929
+;;;;;; 316000))
;;; Generated autoloads from scroll-all.el
(defvar scroll-all-mode nil "\
;;;***
\f
-;;;### (autoloads nil "scroll-lock" "scroll-lock.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "scroll-lock" "scroll-lock.el" (22086 11930
+;;;;;; 270062 731000))
;;; Generated autoloads from scroll-lock.el
(autoload 'scroll-lock-mode "scroll-lock" "\
;;;***
\f
-;;;### (autoloads nil "secrets" "net/secrets.el" (21071 59176 747909
-;;;;;; 0))
+;;;### (autoloads nil "secrets" "net/secrets.el" (22086 11930 6062
+;;;;;; 731000))
;;; Generated autoloads from net/secrets.el
(when (featurep 'dbusbind)
(autoload 'secrets-show-secrets "secrets" nil t))
;;;***
\f
-;;;### (autoloads nil "semantic" "cedet/semantic.el" (21052 33668
-;;;;;; 690120 156000))
+;;;### (autoloads nil "semantic" "cedet/semantic.el" (22092 27717
+;;;;;; 568268 464000))
;;; Generated autoloads from cedet/semantic.el
(push (purecopy '(semantic 2 2)) package--builtin-versions)
;;;***
\f
;;;### (autoloads nil "semantic/bovine/grammar" "cedet/semantic/bovine/grammar.el"
-;;;;;; (21145 51520 109004 0))
+;;;;;; (22086 11929 554062 731000))
;;; Generated autoloads from cedet/semantic/bovine/grammar.el
(autoload 'bovine-grammar-mode "semantic/bovine/grammar" "\
;;;***
\f
;;;### (autoloads nil "semantic/wisent/grammar" "cedet/semantic/wisent/grammar.el"
-;;;;;; (21145 51520 109004 0))
+;;;;;; (22086 11929 578062 731000))
;;; Generated autoloads from cedet/semantic/wisent/grammar.el
(autoload 'wisent-grammar-mode "semantic/wisent/grammar" "\
;;;***
\f
-;;;### (autoloads nil "sendmail" "mail/sendmail.el" (21002 1963 769129
-;;;;;; 0))
+;;;### (autoloads nil "sendmail" "mail/sendmail.el" (22086 11929
+;;;;;; 946062 731000))
;;; Generated autoloads from mail/sendmail.el
(defvar mail-from-style 'default "\
Specifies how \"From:\" fields look.
-If `nil', they contain just the return address like:
+If nil, they contain just the return address like:
king@grassland.com
If `parens', they look like:
king@grassland.com (Elvis Parsley)
;;;***
\f
-;;;### (autoloads nil "server" "server.el" (20992 52525 458637 0))
+;;;### (autoloads nil "seq" "emacs-lisp/seq.el" (22086 11929 686062
+;;;;;; 731000))
+;;; Generated autoloads from emacs-lisp/seq.el
+(push (purecopy '(seq 2 3)) package--builtin-versions)
+
+;;;***
+\f
+;;;### (autoloads nil "server" "server.el" (22093 48588 588393 539000))
;;; Generated autoloads from server.el
(put 'server-host 'risky-local-variable t)
;;;***
\f
-;;;### (autoloads nil "ses" "ses.el" (21132 39477 543900 0))
+;;;### (autoloads nil "ses" "ses.el" (22092 27718 416268 464000))
;;; Generated autoloads from ses.el
(autoload 'ses-mode "ses" "\
;;;***
\f
-;;;### (autoloads nil "sgml-mode" "textmodes/sgml-mode.el" (20784
-;;;;;; 36406 653593 0))
+;;;### (autoloads nil "sgml-mode" "textmodes/sgml-mode.el" (22092
+;;;;;; 27718 512268 464000))
;;; Generated autoloads from textmodes/sgml-mode.el
(autoload 'sgml-mode "sgml-mode" "\
Major mode for editing SGML documents.
Makes > match <.
-Keys <, &, SPC within <>, \", / and ' can be electric depending on
+Keys <, &, SPC within <>, \", / and \\=' can be electric depending on
`sgml-quick-keys'.
An argument of N to a tag-inserting command means to wrap it around
the next N words. In Transient Mark mode, when the mark is active,
N defaults to -1, which means to wrap it around the current region.
-If you like upcased tags, put (setq sgml-transformation-function 'upcase)
+If you like upcased tags, put (setq sgml-transformation-function \\='upcase)
in your init file.
Use \\[sgml-validate] to validate your document with an SGML parser.
If you mainly create your own documents, `sgml-specials' might be
interesting. But note that some HTML 2 browsers can't handle `''.
To work around that, do:
- (eval-after-load \"sgml-mode\" '(aset sgml-char-names ?' nil))
+ (eval-after-load \"sgml-mode\" \\='(aset sgml-char-names ?\\=' nil))
\\{html-mode-map}
;;;***
\f
-;;;### (autoloads nil "sh-script" "progmodes/sh-script.el" (21118
-;;;;;; 6587 141205 0))
+;;;### (autoloads nil "sh-script" "progmodes/sh-script.el" (22092
+;;;;;; 27718 260268 464000))
;;; Generated autoloads from progmodes/sh-script.el
(push (purecopy '(sh-script 2 0 6)) package--builtin-versions)
(put 'sh-shell 'safe-local-variable 'symbolp)
\\[backward-delete-char-untabify] Delete backward one position, even if it was a tab.
-\\[newline-and-indent] Delete unquoted space and indent new line same as this one.
\\[sh-end-of-command] Go to end of successive commands.
\\[sh-beginning-of-command] Go to beginning of successive commands.
\\[sh-set-shell] Set this buffer's shell, and maybe its magic number.
;;;***
\f
-;;;### (autoloads nil "shadow" "emacs-lisp/shadow.el" (21082 29482
-;;;;;; 330637 0))
+;;;### (autoloads nil "shadow" "emacs-lisp/shadow.el" (22086 11929
+;;;;;; 686062 731000))
;;; Generated autoloads from emacs-lisp/shadow.el
(autoload 'list-load-path-shadows "shadow" "\
and that each of these directories contains a file called XXX.el. Then
XXX.el in the site-lisp directory is referred to by all of:
-\(require 'XXX), (autoload .... \"XXX\"), (load-library \"XXX\") etc.
+\(require \\='XXX), (autoload .... \"XXX\"), (load-library \"XXX\") etc.
The first XXX.el file prevents Emacs from seeing the second (unless
the second is loaded explicitly via `load-file').
;;;***
\f
-;;;### (autoloads nil "shadowfile" "shadowfile.el" (20959 55207 940876
-;;;;;; 0))
+;;;### (autoloads nil "shadowfile" "shadowfile.el" (22086 11930 278062
+;;;;;; 731000))
;;; Generated autoloads from shadowfile.el
(autoload 'shadow-define-cluster "shadowfile" "\
;;;***
\f
-;;;### (autoloads nil "shell" "shell.el" (21041 38058 75002 0))
+;;;### (autoloads nil "shell" "shell.el" (22086 11930 278062 731000))
;;; Generated autoloads from shell.el
(defvar shell-dumb-shell-regexp (purecopy "cmd\\(proxy\\)?\\.exe") "\
;;;***
\f
-;;;### (autoloads nil "shr" "net/shr.el" (21049 14338 391345 0))
+;;;### (autoloads nil "shr" "net/shr.el" (22087 9807 382279 951000))
;;; Generated autoloads from net/shr.el
+(autoload 'shr-render-region "shr" "\
+Display the HTML rendering of the region between BEGIN and END.
+
+\(fn BEGIN END &optional BUFFER)" t nil)
+
(autoload 'shr-insert-document "shr" "\
Render the parsed document DOM into the current buffer.
DOM should be a parse tree as generated by
;;;***
\f
-;;;### (autoloads nil "sieve" "gnus/sieve.el" (20926 57896 715754
-;;;;;; 0))
+;;;### (autoloads nil "sieve" "gnus/sieve.el" (22086 11929 850062
+;;;;;; 731000))
;;; Generated autoloads from gnus/sieve.el
(autoload 'sieve-manage "sieve" "\
;;;***
\f
-;;;### (autoloads nil "sieve-mode" "gnus/sieve-mode.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "sieve-mode" "gnus/sieve-mode.el" (22086 11929
+;;;;;; 850062 731000))
;;; Generated autoloads from gnus/sieve-mode.el
(autoload 'sieve-mode "sieve-mode" "\
;;;***
\f
-;;;### (autoloads nil "simula" "progmodes/simula.el" (20777 63161
-;;;;;; 848428 0))
+;;;### (autoloads nil "simula" "progmodes/simula.el" (22092 27718
+;;;;;; 288268 464000))
;;; Generated autoloads from progmodes/simula.el
(autoload 'simula-mode "simula" "\
with respect to the previous line of the statement.
`simula-label-offset' -4711
Offset of SIMULA label lines relative to usual indentation.
- `simula-if-indent' '(0 . 0)
+ `simula-if-indent' (0 . 0)
Extra indentation of THEN and ELSE with respect to the starting IF.
Value is a cons cell, the car is extra THEN indentation and the cdr
extra ELSE indentation. IF after ELSE is indented as the starting IF.
- `simula-inspect-indent' '(0 . 0)
+ `simula-inspect-indent' (0 . 0)
Extra indentation of WHEN and OTHERWISE with respect to the
corresponding INSPECT. Value is a cons cell, the car is
extra WHEN indentation and the cdr extra OTHERWISE indentation.
`simula-electric-indent' nil
If this variable is non-nil, `simula-indent-line'
will check the previous line to see if it has to be reindented.
- `simula-abbrev-keyword' 'upcase
+ `simula-abbrev-keyword' `upcase'
Determine how SIMULA keywords will be expanded. Value is one of
the symbols `upcase', `downcase', `capitalize', (as in) `abbrev-table',
or nil if they should not be changed.
- `simula-abbrev-stdproc' 'abbrev-table
+ `simula-abbrev-stdproc' `abbrev-table'
Determine how standard SIMULA procedure and class names will be
expanded. Value is one of the symbols `upcase', `downcase', `capitalize',
(as in) `abbrev-table', or nil if they should not be changed.
;;;***
\f
-;;;### (autoloads nil "skeleton" "skeleton.el" (21087 47399 892476
-;;;;;; 0))
+;;;### (autoloads nil "skeleton" "skeleton.el" (22086 11930 290062
+;;;;;; 731000))
;;; Generated autoloads from skeleton.el
(defvar skeleton-filter-function 'identity "\
\(fn COMMAND DOCUMENTATION &rest SKELETON)" nil t)
-(put 'define-skeleton 'doc-string-elt '2)
+(function-put 'define-skeleton 'doc-string-elt '2)
(autoload 'skeleton-proxy-new "skeleton" "\
Insert SKELETON.
If ELEMENT is a string or a character it gets inserted (see also
`skeleton-transformation-function'). Other possibilities are:
- \\n go to next line and indent according to mode
+ \\n go to next line and indent according to mode, unless
+ this is the first/last element of a skeleton and point
+ is at bol/eol
_ interesting point, interregion here
- interesting point, no interregion interaction, overrides
interesting point set by _
@ add position to `skeleton-positions'
& do next ELEMENT if previous moved point
| do next ELEMENT if previous didn't move point
- -num delete num preceding characters (see `skeleton-untabify')
+ -NUM delete NUM preceding characters (see `skeleton-untabify')
resume: skipped, continue here if quit is signaled
nil skipped
After termination, point will be positioned at the last occurrence of -
or at the first occurrence of _ or at the end of the inserted text.
-Further elements can be defined via `skeleton-further-elements'. ELEMENT may
-itself be a SKELETON with an INTERACTOR. The user is prompted repeatedly for
-different inputs. The SKELETON is processed as often as the user enters a
-non-empty string. \\[keyboard-quit] terminates skeleton insertion, but
-continues after `resume:' and positions at `_' if any. If INTERACTOR in such
-a subskeleton is a prompt-string which contains a \".. %s ..\" it is
-formatted with `skeleton-subprompt'. Such an INTERACTOR may also be a list of
-strings with the subskeleton being repeated once for each string.
+Note that \\n as the last element of the skeleton only inserts a
+newline if not at eol. If you want to unconditionally insert a newline
+at the end of the skeleton, use \"\\n\" instead. Likewise with \\n
+as the first element when at bol.
+
+Further elements can be defined via `skeleton-further-elements'.
+ELEMENT may itself be a SKELETON with an INTERACTOR. The user is prompted
+repeatedly for different inputs. The SKELETON is processed as often as
+the user enters a non-empty string. \\[keyboard-quit] terminates skeleton insertion, but
+continues after `resume:' and positions at `_' if any. If INTERACTOR in
+such a subskeleton is a prompt-string which contains a \".. %s ..\" it is
+formatted with `skeleton-subprompt'. Such an INTERACTOR may also be a list
+of strings with the subskeleton being repeated once for each string.
Quoted Lisp expressions are evaluated for their side-effects.
Other Lisp expressions are evaluated and the value treated as above.
such as backslash.
If a match is found in `skeleton-pair-alist', that is inserted, else
-the defaults are used. These are (), [], {}, <> and `' for the
-symmetrical ones, and the same character twice for the others.
+the defaults are used. These are (), [], {}, <> and (grave
+accent, apostrophe) for the paired ones, and the same character
+twice for the others.
\(fn ARG)" t nil)
;;;***
\f
-;;;### (autoloads nil "smerge-mode" "vc/smerge-mode.el" (21139 62016
-;;;;;; 336404 0))
+;;;### (autoloads nil "smerge-mode" "vc/smerge-mode.el" (22092 27718
+;;;;;; 548268 464000))
;;; Generated autoloads from vc/smerge-mode.el
(autoload 'smerge-ediff "smerge-mode" "\
;;;***
\f
-;;;### (autoloads nil "smiley" "gnus/smiley.el" (20726 5184 974741
-;;;;;; 509000))
+;;;### (autoloads nil "smiley" "gnus/smiley.el" (22086 11929 850062
+;;;;;; 731000))
;;; Generated autoloads from gnus/smiley.el
(autoload 'smiley-region "smiley" "\
;;;***
\f
-;;;### (autoloads nil "smtpmail" "mail/smtpmail.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "smtpmail" "mail/smtpmail.el" (22086 11929
+;;;;;; 950062 731000))
;;; Generated autoloads from mail/smtpmail.el
(autoload 'smtpmail-send-it "smtpmail" "\
;;;***
\f
-;;;### (autoloads nil "snake" "play/snake.el" (21040 17194 398147
-;;;;;; 0))
+;;;### (autoloads nil "snake" "play/snake.el" (22086 11930 130062
+;;;;;; 731000))
;;; Generated autoloads from play/snake.el
(autoload 'snake "snake" "\
;;;***
\f
-;;;### (autoloads nil "snmp-mode" "net/snmp-mode.el" (20891 18859
-;;;;;; 893295 0))
+;;;### (autoloads nil "snmp-mode" "net/snmp-mode.el" (22086 11930
+;;;;;; 10062 731000))
;;; Generated autoloads from net/snmp-mode.el
(autoload 'snmp-mode "snmp-mode" "\
;;;***
\f
-;;;### (autoloads nil "solar" "calendar/solar.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "soap-client" "net/soap-client.el" (22092 27717
+;;;;;; 988268 464000))
+;;; Generated autoloads from net/soap-client.el
+(push (purecopy '(soap-client 3 0 2)) package--builtin-versions)
+
+;;;***
+\f
+;;;### (autoloads nil "solar" "calendar/solar.el" (22086 11929 534062
+;;;;;; 731000))
;;; Generated autoloads from calendar/solar.el
(autoload 'sunrise-sunset "solar" "\
;;;***
\f
-;;;### (autoloads nil "solitaire" "play/solitaire.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "solitaire" "play/solitaire.el" (22086 11930
+;;;;;; 130062 731000))
;;; Generated autoloads from play/solitaire.el
(autoload 'solitaire "solitaire" "\
;;;***
\f
-;;;### (autoloads nil "sort" "sort.el" (20896 36774 886399 0))
+;;;### (autoloads nil "sort" "sort.el" (22086 11930 290062 731000))
;;; Generated autoloads from sort.el
(put 'sort-fold-case 'safe-local-variable 'booleanp)
\(fn BEG END)" t nil)
(autoload 'delete-duplicate-lines "sort" "\
-Delete duplicate lines in the region between BEG and END.
-
-If REVERSE is nil, search and delete duplicates forward keeping the first
-occurrence of duplicate lines. If REVERSE is non-nil (when called
-interactively with C-u prefix), search and delete duplicates backward
-keeping the last occurrence of duplicate lines.
+Delete all but one copy of any identical lines in the region.
+Non-interactively, arguments BEG and END delimit the region.
+Normally it searches forwards, keeping the first instance of
+each identical line. If REVERSE is non-nil (interactively, with
+a C-u prefix), it searches backwards and keeps the last instance of
+each repeated line.
-If ADJACENT is non-nil (when called interactively with two C-u prefixes),
-delete repeated lines only if they are adjacent. It works like the utility
-`uniq' and is useful when lines are already sorted in a large file since
-this is more efficient in performance and memory usage than when ADJACENT
-is nil that uses additional memory to remember previous lines.
+Identical lines need not be adjacent, unless the argument
+ADJACENT is non-nil (interactively, with a C-u C-u prefix).
+This is a more efficient mode of operation, and may be useful
+on large regions that have already been sorted.
-If KEEP-BLANKS is non-nil (when called interactively with three C-u prefixes),
-duplicate blank lines are preserved.
+If the argument KEEP-BLANKS is non-nil (interactively, with a
+C-u C-u C-u prefix), it retains repeated blank lines.
-When called from Lisp and INTERACTIVE is omitted or nil, return the number
-of deleted duplicate lines, do not print it; if INTERACTIVE is t, the
-function behaves in all respects as if it had been called interactively.
+Returns the number of deleted lines. Interactively, or if INTERACTIVE
+is non-nil, it also prints a message describing the number of deletions.
\(fn BEG END &optional REVERSE ADJACENT KEEP-BLANKS INTERACTIVE)" t nil)
;;;***
\f
-;;;### (autoloads nil "spam" "gnus/spam.el" (20901 54695 989166 0))
+;;;### (autoloads nil "spam" "gnus/spam.el" (22086 11929 854062 731000))
;;; Generated autoloads from gnus/spam.el
(autoload 'spam-initialize "spam" "\
;;;***
\f
-;;;### (autoloads nil "spam-report" "gnus/spam-report.el" (20874
-;;;;;; 65006 672942 217000))
+;;;### (autoloads nil "spam-report" "gnus/spam-report.el" (22086
+;;;;;; 11929 850062 731000))
;;; Generated autoloads from gnus/spam-report.el
(autoload 'spam-report-process-queue "spam-report" "\
;;;***
\f
-;;;### (autoloads nil "speedbar" "speedbar.el" (21024 28968 738399
-;;;;;; 0))
+;;;### (autoloads nil "speedbar" "speedbar.el" (22092 27718 452268
+;;;;;; 464000))
;;; Generated autoloads from speedbar.el
(defalias 'speedbar 'speedbar-frame-mode)
;;;***
\f
-;;;### (autoloads nil "spook" "play/spook.el" (21041 38058 75002
-;;;;;; 0))
+;;;### (autoloads nil "spook" "play/spook.el" (22086 11930 130062
+;;;;;; 731000))
;;; Generated autoloads from play/spook.el
(autoload 'spook "spook" "\
;;;***
\f
-;;;### (autoloads nil "sql" "progmodes/sql.el" (21082 29482 330637
-;;;;;; 0))
+;;;### (autoloads nil "sql" "progmodes/sql.el" (22092 27718 320268
+;;;;;; 464000))
;;; Generated autoloads from progmodes/sql.el
-(push (purecopy '(sql 3 3)) package--builtin-versions)
+(push (purecopy '(sql 3 5)) package--builtin-versions)
(autoload 'sql-add-product-keywords "sql" "\
Add highlighting KEYWORDS for SQL PRODUCT.
For example:
- (sql-add-product-keywords 'ms
- '((\"\\\\b\\\\w+_t\\\\b\" . font-lock-type-face)))
+ (sql-add-product-keywords \\='ms
+ \\='((\"\\\\b\\\\w+_t\\\\b\" . font-lock-type-face)))
adds a fontification pattern to fontify identifiers ending in
`_t' as data types.
\(fn PRODUCT KEYWORDS &optional APPEND)" nil nil)
-(eval '(defun sql-help nil #("Show short help for the SQL modes.\n\nUse an entry function to open an interactive SQL buffer. This buffer is\nusually named `*SQL*'. The name of the major mode is SQLi.\n\nUse the following commands to start a specific SQL interpreter:\n\n \\\\FREE\n\nOther non-free SQL implementations are also supported:\n\n \\\\NONFREE\n\nBut we urge you to choose a free implementation instead of these.\n\nYou can also use \\[sql-product-interactive] to invoke the\ninterpreter for the current `sql-product'.\n\nOnce you have the SQLi buffer, you can enter SQL statements in the\nbuffer. The output generated is appended to the buffer and a new prompt\nis generated. See the In/Out menu in the SQLi buffer for some functions\nthat help you navigate through the buffer, the input history, etc.\n\nIf you have a really complex SQL statement or if you are writing a\nprocedure, you can do this in a separate buffer. Put the new buffer in\n`sql-mode' by calling \\[sql-mode]. The name of this buffer can be\nanything. The name of the major mode is SQL.\n\nIn this SQL buffer (SQL mode), you can send the region or the entire\nbuffer to the interactive SQL buffer (SQLi mode). The results are\nappended to the SQLi buffer without disturbing your SQL buffer." 0 1 (dynamic-docstring-function sql--make-help-docstring)) (interactive) (describe-function 'sql-help)))
-
(autoload 'sql-mode "sql" "\
Major mode to edit SQL.
one. If you specify backslash as escape character in SQL, you
must tell Emacs. Here's how to do that in your init file:
-\(add-hook 'sql-mode-hook
+\(add-hook \\='sql-mode-hook
(lambda ()
(modify-syntax-entry ?\\\\ \".\" sql-mode-syntax-table)))
Try to set `comint-output-filter-functions' like this:
\(setq comint-output-filter-functions (append comint-output-filter-functions
- '(comint-strip-ctrl-m)))
+ \\='(comint-strip-ctrl-m)))
\(Type \\[describe-mode] in the SQL buffer for a list of commands.)
\(fn &optional BUFFER)" t nil)
+(autoload 'sql-vertica "sql" "\
+Run vsql as an inferior process.
+
+\(fn &optional BUFFER)" t nil)
+
;;;***
\f
-;;;### (autoloads nil "srecode" "cedet/srecode.el" (20748 62911 684442
-;;;;;; 0))
+;;;### (autoloads nil "srecode" "cedet/srecode.el" (22086 11929 578062
+;;;;;; 731000))
;;; Generated autoloads from cedet/srecode.el
(push (purecopy '(srecode 1 2)) package--builtin-versions)
;;;***
\f
;;;### (autoloads nil "srecode/srt-mode" "cedet/srecode/srt-mode.el"
-;;;;;; (21048 47760 436258 0))
+;;;;;; (22086 11929 582062 731000))
;;; Generated autoloads from cedet/srecode/srt-mode.el
(autoload 'srecode-template-mode "srecode/srt-mode" "\
;;;***
\f
-;;;### (autoloads nil "starttls" "gnus/starttls.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "starttls" "gnus/starttls.el" (22086 11929
+;;;;;; 854062 731000))
;;; Generated autoloads from gnus/starttls.el
(autoload 'starttls-open-stream "starttls" "\
;;;***
\f
-;;;### (autoloads nil "strokes" "strokes.el" (20799 169 640767 0))
+;;;### (autoloads nil "strokes" "strokes.el" (22086 11930 294062
+;;;;;; 731000))
;;; Generated autoloads from strokes.el
(autoload 'strokes-global-set-stroke "strokes" "\
Interactively give STROKE the global binding as COMMAND.
-Operated just like `global-set-key', except for strokes.
-COMMAND is a symbol naming an interactively-callable function. STROKE
-is a list of sampled positions on the stroke grid as described in the
+Works just like `global-set-key', except for strokes. COMMAND is
+a symbol naming an interactively-callable function. STROKE is a
+list of sampled positions on the stroke grid as described in the
documentation for the `strokes-define-stroke' function.
See also `strokes-global-set-stroke-string'.
(autoload '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.
+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.
\(fn &optional CHRONOLOGICAL STROKES-MAP)" t nil)
(autoload 'strokes-mode "strokes" "\
Toggle Strokes mode, a global minor mode.
With a prefix argument ARG, enable Strokes mode if ARG is
-positive, and disable it otherwise. If called from Lisp, enable
-the mode if ARG is omitted or nil.
+positive, and disable it otherwise. If called from Lisp,
+enable the mode if ARG is omitted or nil.
\\<strokes-mode-map>
Strokes are pictographic mouse gestures which invoke commands.
;;;***
\f
-;;;### (autoloads nil "studly" "play/studly.el" (20355 10021 546955
-;;;;;; 0))
+;;;### (autoloads nil "studly" "play/studly.el" (22086 11930 130062
+;;;;;; 731000))
;;; Generated autoloads from play/studly.el
(autoload 'studlify-region "studly" "\
;;;***
\f
-;;;### (autoloads nil "subword" "progmodes/subword.el" (21086 26537
-;;;;;; 509049 0))
+;;;### (autoloads nil "subword" "progmodes/subword.el" (22086 11930
+;;;;;; 226062 731000))
;;; Generated autoloads from progmodes/subword.el
+(define-obsolete-function-alias 'capitalized-words-mode 'subword-mode "25.1")
+
(autoload 'subword-mode "subword" "\
Toggle subword movement and editing (Subword mode).
With a prefix argument ARG, enable Subword mode if ARG is
positive, and disable it otherwise. If called from Lisp, enable
the mode if ARG is omitted or nil.
-Subword mode is a buffer-local minor mode. Enabling it remaps
-word-based editing commands to subword-based commands that handle
+Subword mode is a buffer-local minor mode. Enabling it changes
+the definition of a word so that word-based commands stop inside
symbols with mixed uppercase and lowercase letters,
e.g. \"GtkWidget\", \"EmacsFrameClass\", \"NSGraphicsContext\".
EmacsFrameClass => \"Emacs\", \"Frame\" and \"Class\"
NSGraphicsContext => \"NS\", \"Graphics\" and \"Context\"
-The subword oriented commands activated in this minor mode recognize
-subwords in a nomenclature to move between subwords and to edit them
-as words.
+This mode changes the definition of a word so that word commands
+treat nomenclature boundaries as word boundaries.
\\{subword-mode-map}
positive, and disable it otherwise. If called from Lisp, enable
the mode if ARG is omitted or nil.
-Superword mode is a buffer-local minor mode. Enabling it remaps
-word-based editing commands to superword-based commands that
-treat symbols as words, e.g. \"this_is_a_symbol\".
-
-The superword oriented commands activated in this minor mode
-recognize symbols as superwords to move between superwords and to
-edit them as words.
+Superword mode is a buffer-local minor mode. Enabling it changes
+the definition of words such that symbols characters are treated
+as parts of words: e.g., in `superword-mode',
+\"this_is_a_symbol\" counts as one word.
\\{superword-mode-map}
;;;***
\f
-;;;### (autoloads nil "supercite" "mail/supercite.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "supercite" "mail/supercite.el" (22086 11929
+;;;;;; 950062 731000))
;;; Generated autoloads from mail/supercite.el
(autoload 'sc-cite-original "supercite" "\
;;;***
\f
-;;;### (autoloads nil "t-mouse" "t-mouse.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "t-mouse" "t-mouse.el" (22086 11930 298062
+;;;;;; 731000))
;;; Generated autoloads from t-mouse.el
(define-obsolete-function-alias 't-mouse-mode 'gpm-mouse-mode "23.1")
;;;***
\f
-;;;### (autoloads nil "tabify" "tabify.el" (20999 25770 522517 0))
+;;;### (autoloads nil "tabify" "tabify.el" (22086 11930 298062 731000))
;;; Generated autoloads from tabify.el
(autoload 'untabify "tabify" "\
;;;***
\f
-;;;### (autoloads nil "table" "textmodes/table.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "table" "textmodes/table.el" (22092 27718 520268
+;;;;;; 464000))
;;; 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.")
-
-(custom-autoload 'table-cell-map-hook "table" t)
-
-(defvar table-load-hook nil "\
-List of functions to be called after the table is first loaded.")
-
-(custom-autoload 'table-load-hook "table" t)
-
-(defvar table-point-entered-cell-hook nil "\
-List of functions to be called after point entered a table cell.")
-
-(custom-autoload 'table-point-entered-cell-hook "table" t)
-
-(defvar table-point-left-cell-hook nil "\
-List of functions to be called after point left a table cell.")
-
-(custom-autoload 'table-point-left-cell-hook "table" t)
-
(autoload 'table-insert "table" "\
Insert an editable text table.
Insert a table of specified number of COLUMNS and ROWS. Optional
(autoload '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.
+WHAT is a symbol `cell', `row' or `column'. JUSTIFY is a symbol
+`left', `center', `right', `top', `middle', `bottom' or `none'.
\(fn WHAT JUSTIFY)" t nil)
(autoload '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
+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.
(autoload '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.
+JUSTIFY is a symbol `left', `center' or `right' for horizontal,
+or `top', `middle', `bottom' or `none' for vertical.
\(fn JUSTIFY)" t nil)
(autoload '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.
+JUSTIFY is a symbol `left', `center' or `right' for horizontal,
+or `top', `middle', `bottom' or `none' for vertical.
\(fn JUSTIFY)" t nil)
(autoload '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.
+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
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.
+structure is uniform. JUSTIFY is a 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-insert-sequence \"D0\" -16 1 1 \\='center)
(table-forward-cell 16)
- (table-insert-sequence \"A[0]\" -16 1 1 'center)
+ (table-insert-sequence \"A[0]\" -16 1 1 \\='center)
(table-forward-cell 1)
- (table-insert-sequence \"-\" 16 0 1 'center))
+ (table-insert-sequence \"-\" 16 0 1 \\='center))
(progn
(table-insert 16 8 5 1)
- (table-insert-sequence \"@\" 0 1 2 'right)
+ (table-insert-sequence \"@\" 0 1 2 \\='right)
(table-forward-cell 1)
- (table-insert-sequence \"64\" 0 1 2 'left))
+ (table-insert-sequence \"64\" 0 1 2 \\='left))
\(fn STR N INCREMENT INTERVAL JUSTIFY)" t nil)
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
+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.
;;;***
\f
-;;;### (autoloads nil "talk" "talk.el" (20992 52525 458637 0))
+;;;### (autoloads nil "talk" "talk.el" (22086 11930 298062 731000))
;;; Generated autoloads from talk.el
(autoload 'talk-connect "talk" "\
;;;***
\f
-;;;### (autoloads nil "tar-mode" "tar-mode.el" (20932 10282 564846
-;;;;;; 0))
+;;;### (autoloads nil "tar-mode" "tar-mode.el" (22086 11930 298062
+;;;;;; 731000))
;;; Generated autoloads from tar-mode.el
(autoload 'tar-mode "tar-mode" "\
;;;***
\f
-;;;### (autoloads nil "tcl" "progmodes/tcl.el" (20903 10024 645978
-;;;;;; 0))
+;;;### (autoloads nil "tcl" "progmodes/tcl.el" (22086 11930 230062
+;;;;;; 731000))
;;; Generated autoloads from progmodes/tcl.el
(autoload 'tcl-mode "tcl" "\
;;;***
\f
-;;;### (autoloads nil "telnet" "net/telnet.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "telnet" "net/telnet.el" (22086 11930 14062
+;;;;;; 731000))
;;; Generated autoloads from net/telnet.el
(autoload 'telnet "telnet" "\
;;;***
\f
-;;;### (autoloads nil "term" "term.el" (21049 14338 391345 0))
+;;;### (autoloads nil "term" "term.el" (22102 63557 312509 103000))
;;; Generated autoloads from term.el
(autoload 'make-term "term" "\
;;;***
\f
-;;;### (autoloads nil "testcover" "emacs-lisp/testcover.el" (20878
-;;;;;; 6823 881439 0))
+;;;### (autoloads nil "testcover" "emacs-lisp/testcover.el" (22086
+;;;;;; 11929 686062 731000))
;;; Generated autoloads from emacs-lisp/testcover.el
(autoload 'testcover-this-defun "testcover" "\
;;;***
\f
-;;;### (autoloads nil "tetris" "play/tetris.el" (20874 65006 672942
-;;;;;; 217000))
+;;;### (autoloads nil "tetris" "play/tetris.el" (22086 11930 130062
+;;;;;; 731000))
;;; Generated autoloads from play/tetris.el
(push (purecopy '(tetris 2 1)) package--builtin-versions)
;;;***
\f
-;;;### (autoloads nil "tex-mode" "textmodes/tex-mode.el" (21136 36544
-;;;;;; 158478 0))
+;;;### (autoloads nil "tex-mode" "textmodes/tex-mode.el" (22092 27718
+;;;;;; 524268 464000))
;;; Generated autoloads from textmodes/tex-mode.el
(defvar tex-shell-file-name nil "\
for example,
(setq tex-alt-dvi-print-command
- '(format \"lpr -P%s\" (read-string \"Use printer: \")))
+ \\='(format \"lpr -P%s\" (read-string \"Use printer: \")))
would tell \\[tex-print] with a prefix argument to ask you which printer to
use.")
(autoload 'plain-tex-mode "tex-mode" "\
Major mode for editing files of input for plain TeX.
Makes $ and } display the characters they match.
-Makes \" insert `` when it seems to be the beginning of a quotation,
-and '' when it appears to be the end; it inserts \" only after a \\.
+Makes \" insert \\=`\\=` when it seems to be the beginning of a quotation,
+and \\='\\=' when it appears to be the end; it inserts \" only after a \\.
Use \\[tex-region] to run TeX on the current region, plus a \"header\"
copied from the top of the file (containing macro definitions, etc.),
(autoload 'latex-mode "tex-mode" "\
Major mode for editing files of input for LaTeX.
Makes $ and } display the characters they match.
-Makes \" insert `` when it seems to be the beginning of a quotation,
-and '' when it appears to be the end; it inserts \" only after a \\.
+Makes \" insert \\=`\\=` when it seems to be the beginning of a quotation,
+and \\='\\=' when it appears to be the end; it inserts \" only after a \\.
Use \\[tex-region] to run LaTeX on the current region, plus the preamble
copied from the top of the file (containing \\documentstyle, etc.),
(autoload 'slitex-mode "tex-mode" "\
Major mode for editing files of input for SliTeX.
Makes $ and } display the characters they match.
-Makes \" insert `` when it seems to be the beginning of a quotation,
-and '' when it appears to be the end; it inserts \" only after a \\.
+Makes \" insert \\=`\\=` when it seems to be the beginning of a quotation,
+and \\='\\=' when it appears to be the end; it inserts \" only after a \\.
Use \\[tex-region] to run SliTeX on the current region, plus the preamble
copied from the top of the file (containing \\documentstyle, etc.),
;;;***
\f
-;;;### (autoloads nil "texinfmt" "textmodes/texinfmt.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "texinfmt" "textmodes/texinfmt.el" (22086 11930
+;;;;;; 350062 731000))
;;; Generated autoloads from textmodes/texinfmt.el
(autoload 'texinfo-format-buffer "texinfmt" "\
;;;***
\f
-;;;### (autoloads nil "texinfo" "textmodes/texinfo.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "texinfo" "textmodes/texinfo.el" (22086 11930
+;;;;;; 350062 731000))
;;; Generated autoloads from textmodes/texinfo.el
(defvar texinfo-open-quote (purecopy "``") "\
;;;***
\f
-;;;### (autoloads nil "thai-util" "language/thai-util.el" (20709
-;;;;;; 26818 907104 0))
+;;;### (autoloads nil "thai-util" "language/thai-util.el" (22086
+;;;;;; 11929 902062 731000))
;;; Generated autoloads from language/thai-util.el
(autoload 'thai-compose-region "thai-util" "\
;;;***
\f
-;;;### (autoloads nil "thingatpt" "thingatpt.el" (21114 9531 52922
-;;;;;; 0))
+;;;### (autoloads nil "thingatpt" "thingatpt.el" (22086 11930 354062
+;;;;;; 731000))
;;; Generated autoloads from thingatpt.el
(autoload 'forward-thing "thingatpt" "\
;;;***
\f
-;;;### (autoloads nil "thumbs" "thumbs.el" (20958 59019 473587 89000))
+;;;### (autoloads nil "thumbs" "thumbs.el" (22086 11930 354062 731000))
;;; Generated autoloads from thumbs.el
(autoload 'thumbs-find-thumb "thumbs" "\
;;;***
\f
-;;;### (autoloads nil "tibet-util" "language/tibet-util.el" (20826
-;;;;;; 45095 436233 0))
+;;;### (autoloads nil "thunk" "emacs-lisp/thunk.el" (22086 11929
+;;;;;; 690062 731000))
+;;; Generated autoloads from emacs-lisp/thunk.el
+(push (purecopy '(thunk 1 0)) package--builtin-versions)
+
+;;;***
+\f
+;;;### (autoloads nil "tibet-util" "language/tibet-util.el" (22086
+;;;;;; 11929 906062 731000))
;;; Generated autoloads from language/tibet-util.el
(autoload 'tibetan-char-p "tibet-util" "\
;;;***
\f
-;;;### (autoloads nil "tildify" "textmodes/tildify.el" (20791 9657
-;;;;;; 561026 0))
+;;;### (autoloads nil "tildify" "textmodes/tildify.el" (22086 11930
+;;;;;; 354062 731000))
;;; Generated autoloads from textmodes/tildify.el
-(push (purecopy '(tildify 4 5)) package--builtin-versions)
+(push (purecopy '(tildify 4 6 1)) package--builtin-versions)
(autoload 'tildify-region "tildify" "\
Add hard spaces in the region between BEG and END.
-See variables `tildify-pattern-alist', `tildify-string-alist', and
+See variables `tildify-pattern', `tildify-space-string', and
`tildify-ignored-environments-alist' for information about configuration
parameters.
This function performs no refilling of the changed text.
+If DONT-ASK is set, or called interactively with prefix argument, user
+won't be prompted for confirmation of each substitution.
-\(fn BEG END)" t nil)
+\(fn BEG END &optional DONT-ASK)" t nil)
(autoload 'tildify-buffer "tildify" "\
Add hard spaces in the current buffer.
-See variables `tildify-pattern-alist', `tildify-string-alist', and
+See variables `tildify-pattern', `tildify-space-string', and
`tildify-ignored-environments-alist' for information about configuration
parameters.
This function performs no refilling of the changed text.
+If DONT-ASK is set, or called interactively with prefix argument, user
+won't be prompted for confirmation of each substitution.
+
+\(fn &optional DONT-ASK)" t nil)
+
+(autoload 'tildify-space "tildify" "\
+Convert space before point into a hard space if the context is right.
+
+If
+ * character before point is a space character,
+ * character before that has \"w\" character syntax (i.e. it's a word
+ constituent),
+ * `tildify-space-pattern' matches when `looking-back' (no more than 10
+ characters) from before the space character, and
+ * all predicates in `tildify-space-predicates' return non-nil,
+replace the space character with value of `tildify-space-string' and
+return t.
+
+Otherwise, if
+ * `tildify-double-space-undos' variable is non-nil,
+ * character before point is a space character, and
+ * text before that is a hard space as defined by
+ `tildify-space-string' variable,
+remove the hard space and leave only the space character.
+
+This function is meant to be used as a `post-self-insert-hook'.
\(fn)" t nil)
+(autoload 'tildify-mode "tildify" "\
+Adds electric behaviour to space character.
+
+When space is inserted into a buffer in a position where hard space is required
+instead (determined by `tildify-space-pattern' and `tildify-space-predicates'),
+that space character is replaced by a hard space specified by
+`tildify-space-string'. Converting of the space is done by `tildify-space'.
+
+When `tildify-mode' is enabled, if `tildify-string-alist' specifies a hard space
+representation for current major mode, the `tildify-space-string' buffer-local
+variable will be set to the representation.
+
+\(fn &optional ARG)" t nil)
+
;;;***
\f
-;;;### (autoloads nil "time" "time.el" (21145 51520 109004 0))
+;;;### (autoloads nil "time" "time.el" (22086 11930 354062 731000))
;;; Generated autoloads from time.el
(defvar display-time-day-and-date nil "\
;;;***
\f
-;;;### (autoloads nil "time-date" "calendar/time-date.el" (20709
-;;;;;; 26818 907104 0))
+;;;### (autoloads nil "time-date" "calendar/time-date.el" (22086
+;;;;;; 11929 538062 731000))
;;; Generated autoloads from calendar/time-date.el
(autoload 'date-to-time "time-date" "\
(autoload 'time-to-seconds "time-date"))
(autoload 'seconds-to-time "time-date" "\
-Convert SECONDS (a floating point number) to a time value.
+Convert SECONDS to a time value.
\(fn SECONDS)" nil nil)
-(autoload 'time-less-p "time-date" "\
-Return non-nil if time value T1 is earlier than time value T2.
-
-\(fn T1 T2)" nil nil)
-
(autoload 'days-to-time "time-date" "\
Convert DAYS into a time value.
\(fn TIME)" nil nil)
(defalias 'subtract-time 'time-subtract)
-
-(autoload 'time-subtract "time-date" "\
-Subtract two time values, T1 minus T2.
-Return the difference in the format of a time value.
-
-\(fn T1 T2)" nil nil)
-
-(autoload 'time-add "time-date" "\
-Add two time values T1 and T2. One should represent a time difference.
-
-\(fn T1 T2)" nil nil)
+(autoload 'time-add "time-date")
+(autoload 'time-subtract "time-date")
+(autoload 'time-less-p "time-date")
(autoload 'date-to-day "time-date" "\
Return the number of days between year 1 and DATE.
\(fn STRING SECONDS)" nil nil)
+(autoload 'seconds-to-string "time-date" "\
+Convert the time interval in seconds to a short string.
+
+\(fn DELAY)" nil nil)
+
;;;***
\f
-;;;### (autoloads nil "time-stamp" "time-stamp.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "time-stamp" "time-stamp.el" (22092 27718 528268
+;;;;;; 464000))
;;; Generated autoloads from time-stamp.el
(put 'time-stamp-format 'safe-local-variable 'stringp)
(put 'time-stamp-time-zone 'safe-local-variable 'string-or-null-p)
Update the time stamp string(s) in the buffer.
A template in a file can be automatically updated with a new time stamp
every time you save the file. Add this line to your init file:
- (add-hook 'before-save-hook 'time-stamp)
+ (add-hook \\='before-save-hook \\='time-stamp)
or customize `before-save-hook' through Custom.
Normally the template must appear in the first 8 lines of a file and
look like one of the following:
;;;***
\f
-;;;### (autoloads nil "timeclock" "calendar/timeclock.el" (21013
-;;;;;; 58662 278539 0))
+;;;### (autoloads nil "timeclock" "calendar/timeclock.el" (22086
+;;;;;; 11929 538062 731000))
;;; Generated autoloads from calendar/timeclock.el
(push (purecopy '(timeclock 2 6 1)) package--builtin-versions)
;;;***
\f
;;;### (autoloads nil "titdic-cnv" "international/titdic-cnv.el"
-;;;;;; (21145 51520 109004 0))
+;;;;;; (22086 11929 886062 731000))
;;; Generated autoloads from international/titdic-cnv.el
(autoload 'titdic-convert "titdic-cnv" "\
;;;***
\f
-;;;### (autoloads nil "tmm" "tmm.el" (21086 55571 430148 991000))
+;;;### (autoloads nil "tmm" "tmm.el" (22086 11930 354062 731000))
;;; Generated autoloads from tmm.el
(define-key global-map "\M-`" 'tmm-menubar)
(define-key global-map [menu-bar mouse-1] 'tmm-menubar-mouse)
;;;***
\f
-;;;### (autoloads nil "todo-mode" "calendar/todo-mode.el" (20982
-;;;;;; 16679 447285 0))
+;;;### (autoloads nil "todo-mode" "calendar/todo-mode.el" (22086
+;;;;;; 11929 538062 731000))
;;; Generated autoloads from calendar/todo-mode.el
(autoload 'todo-show "todo-mode" "\
\(fn &optional SOLICIT-FILE INTERACTIVE)" t nil)
+(autoload 'todo-mode "todo-mode" "\
+Major mode for displaying, navigating and editing todo lists.
+
+\\{todo-mode-map}
+
+\(fn)" t nil)
+
+(autoload 'todo-archive-mode "todo-mode" "\
+Major mode for archived todo categories.
+
+\\{todo-archive-mode-map}
+
+\(fn)" t nil)
+
+(autoload 'todo-filtered-items-mode "todo-mode" "\
+Mode for displaying and reprioritizing top priority Todo.
+
+\\{todo-filtered-items-mode-map}
+
+\(fn)" t nil)
+
;;;***
\f
-;;;### (autoloads nil "tool-bar" "tool-bar.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "tool-bar" "tool-bar.el" (22086 11930 358062
+;;;;;; 731000))
;;; Generated autoloads from tool-bar.el
(autoload 'toggle-tool-bar-mode-from-frame "tool-bar" "\
;;;***
\f
-;;;### (autoloads nil "tpu-edt" "emulation/tpu-edt.el" (21105 26139
-;;;;;; 752484 0))
-;;; Generated autoloads from emulation/tpu-edt.el
-(push (purecopy '(tpu-edt 4 5)) package--builtin-versions)
-
-(defvar tpu-edt-mode nil "\
-Non-nil if Tpu-Edt mode is enabled.
-See the command `tpu-edt-mode' for a description of this minor mode.
-Setting this variable directly does not take effect;
-either customize it (see the info node `Easy Customization')
-or call the function `tpu-edt-mode'.")
-
-(custom-autoload 'tpu-edt-mode "tpu-edt" nil)
-
-(autoload 'tpu-edt-mode "tpu-edt" "\
-Toggle TPU/edt emulation on or off.
-With a prefix argument ARG, enable the mode if ARG is positive,
-and disable it otherwise. If called from Lisp, enable the mode
-if ARG is omitted or nil.
-
-\(fn &optional ARG)" t nil)
-
-(defalias 'tpu-edt 'tpu-edt-on)
-
-(autoload 'tpu-edt-on "tpu-edt" "\
-Turn on TPU/edt emulation.
-
-\(fn)" t nil)
-
-;;;***
-\f
-;;;### (autoloads nil "tpu-mapper" "emulation/tpu-mapper.el" (20709
-;;;;;; 26818 907104 0))
-;;; Generated autoloads from emulation/tpu-mapper.el
-
-(autoload 'tpu-mapper "tpu-mapper" "\
-Create an Emacs lisp file defining the TPU-edt keypad for X-windows.
-
-This command displays an instruction screen showing the TPU-edt keypad
-and asks you to press the TPU-edt editing keys. It uses the keys you
-press to create an Emacs Lisp file that will define a TPU-edt keypad
-for your X server. You can even re-arrange the standard EDT keypad to
-suit your tastes (or to cope with those silly Sun and PC keypads).
-
-Finally, you will be prompted for the name of the file to store the key
-definitions. If you chose the default, TPU-edt will find it and load it
-automatically. If you specify a different file name, you will need to
-set the variable ``tpu-xkeys-file'' before starting TPU-edt. Here's how
-you might go about doing that in your init file.
-
- (setq tpu-xkeys-file (expand-file-name \"~/.my-emacs-x-keys\"))
- (tpu-edt)
-
-Known Problems:
-
-Sometimes, tpu-mapper will ignore a key you press, and just continue to
-prompt for the same key. This can happen when your window manager sucks
-up the key and doesn't pass it on to Emacs, or it could be an Emacs bug.
-Either way, there's nothing that tpu-mapper can do about it. You must
-press RETURN, to skip the current key and continue. Later, you and/or
-your local X guru can try to figure out why the key is being ignored.
-
-\(fn)" t nil)
-
-;;;***
-\f
-;;;### (autoloads nil "tq" "emacs-lisp/tq.el" (21074 35375 473679
-;;;;;; 0))
+;;;### (autoloads nil "tq" "emacs-lisp/tq.el" (22086 11929 690062
+;;;;;; 731000))
;;; Generated autoloads from emacs-lisp/tq.el
(autoload 'tq-create "tq" "\
;;;***
\f
-;;;### (autoloads nil "trace" "emacs-lisp/trace.el" (20903 10024
-;;;;;; 645978 0))
+;;;### (autoloads nil "trace" "emacs-lisp/trace.el" (22086 11929
+;;;;;; 690062 731000))
;;; Generated autoloads from emacs-lisp/trace.el
(defvar trace-buffer "*trace-output*" "\
\(fn &rest VALUES)" nil nil)
(autoload 'trace-function-foreground "trace" "\
-Traces FUNCTION with trace output going to BUFFER.
-For every call of FUNCTION Lisp-style trace messages that display argument
-and return values will be inserted into BUFFER. This function generates the
-trace advice for FUNCTION and activates it together with any other advice
-there might be!! The trace BUFFER will popup whenever FUNCTION is called.
-Do not use this to trace functions that switch buffers or do any other
-display oriented stuff, use `trace-function-background' instead.
+Trace calls to function FUNCTION.
+With a prefix argument, also prompt for the trace buffer (default
+`trace-buffer'), and a Lisp expression CONTEXT.
+
+Tracing a function causes every call to that function to insert
+into BUFFER Lisp-style trace messages that display the function's
+arguments and return values. It also evaluates CONTEXT, if that is
+non-nil, and inserts its value too. For example, you can use this
+to track the current buffer, or position of point.
+
+This function creates BUFFER if it does not exist. This buffer will
+popup whenever FUNCTION is called. Do not use this function to trace
+functions that switch buffers, or do any other display-oriented
+stuff - use `trace-function-background' instead.
-To untrace a function, use `untrace-function' or `untrace-all'.
+To stop tracing a function, use `untrace-function' or `untrace-all'.
\(fn FUNCTION &optional BUFFER CONTEXT)" t nil)
(autoload 'trace-function-background "trace" "\
-Traces FUNCTION with trace output going quietly to BUFFER.
-Like `trace-function-foreground' but without popping up the trace BUFFER or
-changing the window configuration.
+Trace calls to function FUNCTION, quietly.
+This is like `trace-function-foreground', but without popping up
+the output buffer or changing the window configuration.
\(fn FUNCTION &optional BUFFER CONTEXT)" t nil)
;;;***
\f
-;;;### (autoloads nil "tramp" "net/tramp.el" (21141 54458 609734
-;;;;;; 0))
+;;;### (autoloads nil "tramp" "net/tramp.el" (22092 27718 8268 464000))
;;; Generated autoloads from net/tramp.el
(defvar tramp-mode t "\
It can have the following values:
- 'ftp -- Ange-FTP respective EFS like syntax (GNU Emacs default)
- 'sep -- Syntax as defined for XEmacs.")
+ `ftp' -- Ange-FTP respective EFS like syntax (GNU Emacs default)
+ `sep' -- Syntax as defined for XEmacs.")
(custom-autoload 'tramp-syntax "tramp" t)
not mentioned here will be handled by Tramp's file name handler
functions, or the normal Emacs functions.")
-(defun tramp-run-real-handler (operation args) "\
-Invoke normal file name handler for OPERATION.
-First arg specifies the OPERATION, second arg is a list of arguments to
-pass to the OPERATION." (let* ((inhibit-file-name-handlers (\` (tramp-file-name-handler tramp-vc-file-name-handler tramp-completion-file-name-handler cygwin-mount-name-hook-function cygwin-mount-map-drive-hook-function \, (and (eq inhibit-file-name-operation operation) inhibit-file-name-handlers)))) (inhibit-file-name-operation operation)) (apply operation args)))
-
(defun tramp-completion-run-real-handler (operation args) "\
Invoke `tramp-file-name-handler' for OPERATION.
First arg specifies the OPERATION, second arg is a list of arguments to
pass to the OPERATION." (let* ((inhibit-file-name-handlers (\` (tramp-completion-file-name-handler cygwin-mount-name-hook-function cygwin-mount-map-drive-hook-function \, (and (eq inhibit-file-name-operation operation) inhibit-file-name-handlers)))) (inhibit-file-name-operation operation)) (apply operation args)))
-(autoload 'tramp-file-name-handler "tramp" "\
-Invoke Tramp file name handler.
-Falls back to normal file name handler if no Tramp file name handler exists.
-
-\(fn OPERATION &rest ARGS)" nil nil)
-
(defun tramp-completion-file-name-handler (operation &rest args) "\
Invoke Tramp file name completion handler.
Falls back to normal file name handler if no Tramp file name handler exists." (let ((directory-sep-char 47) (fn (assoc operation tramp-completion-file-name-handler-alist))) (if (and fn tramp-mode (or (eq tramp-syntax (quote sep)) (featurep (quote tramp)) (and (boundp (quote partial-completion-mode)) (symbol-value (quote partial-completion-mode))) (featurep (quote ido)) (featurep (quote icicles)))) (save-match-data (apply (cdr fn) args)) (tramp-completion-run-real-handler operation args))))
-(defun tramp-register-file-name-handlers nil "\
-Add Tramp file name handlers to `file-name-handler-alist'." (let ((a1 (rassq (quote tramp-file-name-handler) file-name-handler-alist))) (setq file-name-handler-alist (delq a1 file-name-handler-alist))) (let ((a1 (rassq (quote tramp-completion-file-name-handler) file-name-handler-alist))) (setq file-name-handler-alist (delq a1 file-name-handler-alist))) (add-to-list (quote file-name-handler-alist) (cons tramp-file-name-regexp (quote tramp-file-name-handler))) (put (quote tramp-file-name-handler) (quote safe-magic) t) (add-to-list (quote file-name-handler-alist) (cons tramp-completion-file-name-regexp (quote tramp-completion-file-name-handler))) (put (quote tramp-completion-file-name-handler) (quote safe-magic) t) (dolist (fnh (quote (epa-file-handler jka-compr-handler))) (let ((entry (rassoc fnh file-name-handler-alist))) (when entry (setq file-name-handler-alist (cons entry (delete entry file-name-handler-alist)))))))
+(defun tramp-autoload-file-name-handler (operation &rest args) "\
+Load Tramp file name handler, and perform OPERATION." (let ((default-directory "/")) (load "tramp" nil t)) (apply operation args))
+
+(defun tramp-register-autoload-file-name-handlers nil "\
+Add Tramp file name handlers to `file-name-handler-alist' during autoload." (add-to-list (quote file-name-handler-alist) (cons tramp-file-name-regexp (quote tramp-autoload-file-name-handler))) (put (quote tramp-autoload-file-name-handler) (quote safe-magic) t) (add-to-list (quote file-name-handler-alist) (cons tramp-completion-file-name-regexp (quote tramp-completion-file-name-handler))) (put (quote tramp-completion-file-name-handler) (quote safe-magic) t))
-(tramp-register-file-name-handlers)
+(tramp-register-autoload-file-name-handlers)
(autoload 'tramp-unload-file-name-handlers "tramp" "\
;;;***
\f
-;;;### (autoloads nil "tramp-ftp" "net/tramp-ftp.el" (21089 2732
-;;;;;; 351717 0))
+;;;### (autoloads nil "tramp-ftp" "net/tramp-ftp.el" (22086 11930
+;;;;;; 14062 731000))
;;; Generated autoloads from net/tramp-ftp.el
(autoload 'tramp-ftp-enable-ange-ftp "tramp-ftp" "\
;;;***
\f
-;;;### (autoloads nil "tutorial" "tutorial.el" (20999 25770 522517
-;;;;;; 0))
+;;;### (autoloads nil "tutorial" "tutorial.el" (22086 11930 358062
+;;;;;; 731000))
;;; Generated autoloads from tutorial.el
(autoload 'help-with-tutorial "tutorial" "\
;;;***
\f
-;;;### (autoloads nil "tv-util" "language/tv-util.el" (20355 10021
-;;;;;; 546955 0))
+;;;### (autoloads nil "tv-util" "language/tv-util.el" (22086 11929
+;;;;;; 906062 731000))
;;; Generated autoloads from language/tv-util.el
(autoload 'tai-viet-composition-function "tv-util" "\
;;;***
\f
-;;;### (autoloads nil "two-column" "textmodes/two-column.el" (21049
-;;;;;; 1191 520844 232000))
+;;;### (autoloads nil "two-column" "textmodes/two-column.el" (22086
+;;;;;; 11930 354062 731000))
;;; Generated autoloads from textmodes/two-column.el
(autoload '2C-command "two-column" () t 'keymap)
(global-set-key "\C-x6" '2C-command)
;;;***
\f
-;;;### (autoloads nil "type-break" "type-break.el" (20884 7264 912957
-;;;;;; 506000))
+;;;### (autoloads nil "type-break" "type-break.el" (22086 11930 358062
+;;;;;; 731000))
;;; Generated autoloads from type-break.el
(defvar type-break-mode nil "\
;;;***
\f
-;;;### (autoloads nil "uce" "mail/uce.el" (21082 29482 330637 0))
+;;;### (autoloads nil "uce" "mail/uce.el" (22086 11929 950062 731000))
;;; Generated autoloads from mail/uce.el
(autoload 'uce-reply-to-uce "uce" "\
;;;***
\f
;;;### (autoloads nil "ucs-normalize" "international/ucs-normalize.el"
-;;;;;; (20709 26818 907104 0))
+;;;;;; (22086 11929 886062 731000))
;;; Generated autoloads from international/ucs-normalize.el
(autoload 'ucs-normalize-NFD-region "ucs-normalize" "\
;;;***
\f
-;;;### (autoloads nil "underline" "textmodes/underline.el" (20709
-;;;;;; 26818 907104 0))
+;;;### (autoloads nil "underline" "textmodes/underline.el" (22086
+;;;;;; 11930 354062 731000))
;;; Generated autoloads from textmodes/underline.el
(autoload 'underline-region "underline" "\
;;;***
\f
-;;;### (autoloads nil "unrmail" "mail/unrmail.el" (20895 15912 444844
-;;;;;; 0))
+;;;### (autoloads nil "unrmail" "mail/unrmail.el" (22086 11929 950062
+;;;;;; 731000))
;;; Generated autoloads from mail/unrmail.el
(autoload 'batch-unrmail "unrmail" "\
;;;***
\f
-;;;### (autoloads nil "unsafep" "emacs-lisp/unsafep.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "unsafep" "emacs-lisp/unsafep.el" (22086 11929
+;;;;;; 690062 731000))
;;; Generated autoloads from emacs-lisp/unsafep.el
(autoload 'unsafep "unsafep" "\
;;;***
\f
-;;;### (autoloads nil "url" "url/url.el" (20893 60586 188550 0))
+;;;### (autoloads nil "url" "url/url.el" (22086 11930 366062 731000))
;;; Generated autoloads from url/url.el
(autoload 'url-retrieve "url" "\
associated with it (the case for dired, info, or mailto URLs that need
no further processing). URL is either a string or a parsed URL.
-\(fn URL)" nil nil)
+\(fn URL &optional SILENT INHIBIT-COOKIES)" nil nil)
;;;***
\f
-;;;### (autoloads nil "url-auth" "url/url-auth.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "url-auth" "url/url-auth.el" (22092 27718 528268
+;;;;;; 464000))
;;; Generated autoloads from url/url-auth.el
(autoload 'url-get-authentication "url-auth" "\
string representing the URL, or the parsed representation returned by
`url-generic-parse-url'
REALM is the realm at a specific site we are looking for. This should be a
- string specifying the exact realm, or nil or the symbol 'any' to
+ string specifying the exact realm, or nil or the symbol `any' to
specify that the filename portion of the URL should be used as the
realm
TYPE is the type of authentication to be returned. This is either a string
- representing the type (basic, digest, etc), or nil or the symbol 'any'
- to specify that any authentication is acceptable. If requesting 'any'
+ representing the type (basic, digest, etc), or nil or the symbol `any'
+ to specify that any authentication is acceptable. If requesting `any'
the strongest matching authentication will be returned. If this is
wrong, it's no big deal, the error from the server will specify exactly
what type of auth to use
;;;***
\f
-;;;### (autoloads nil "url-cache" "url/url-cache.el" (20751 39094
-;;;;;; 700824 0))
+;;;### (autoloads nil "url-cache" "url/url-cache.el" (22086 11930
+;;;;;; 362062 731000))
;;; Generated autoloads from url/url-cache.el
(autoload 'url-store-in-cache "url-cache" "\
;;;***
\f
-;;;### (autoloads nil "url-cid" "url/url-cid.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "url-cid" "url/url-cid.el" (22086 11930 362062
+;;;;;; 731000))
;;; Generated autoloads from url/url-cid.el
(autoload 'url-cid "url-cid" "\
;;;***
\f
-;;;### (autoloads nil "url-dav" "url/url-dav.el" (20891 18859 893295
-;;;;;; 0))
+;;;### (autoloads nil "url-dav" "url/url-dav.el" (22086 11930 362062
+;;;;;; 731000))
;;; Generated autoloads from url/url-dav.el
(autoload 'url-dav-supported-p "url-dav" "\
;;;***
\f
-;;;### (autoloads nil "url-file" "url/url-file.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "url-file" "url/url-file.el" (22086 11930 362062
+;;;;;; 731000))
;;; Generated autoloads from url/url-file.el
(autoload 'url-file "url-file" "\
;;;***
\f
-;;;### (autoloads nil "url-gw" "url/url-gw.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "url-gw" "url/url-gw.el" (22086 11930 362062
+;;;;;; 731000))
;;; Generated autoloads from url/url-gw.el
(autoload 'url-gateway-nslookup-host "url-gw" "\
Will not make a connection if `url-gateway-unplugged' is non-nil.
Might do a non-blocking connection; use `process-status' to check.
-\(fn NAME BUFFER HOST SERVICE)" nil nil)
+Optional arg GATEWAY-METHOD specifies the gateway to be used,
+overriding the value of `url-gateway-method'.
+
+\(fn NAME BUFFER HOST SERVICE &optional GATEWAY-METHOD)" nil nil)
;;;***
\f
-;;;### (autoloads nil "url-handlers" "url/url-handlers.el" (20984
-;;;;;; 58408 354075 0))
+;;;### (autoloads nil "url-handlers" "url/url-handlers.el" (22089
+;;;;;; 51528 372929 316000))
;;; Generated autoloads from url/url-handlers.el
(defvar url-handler-mode nil "\
\(fn URL &rest IGNORED)" nil nil)
+(autoload 'url-insert-buffer-contents "url-handlers" "\
+Insert the contents of BUFFER into current buffer.
+This is like `url-insert', but also decodes the current buffer as
+if it had been inserted from a file named URL.
+
+\(fn BUFFER URL &optional VISIT BEG END REPLACE)" nil nil)
+
(autoload 'url-insert-file-contents "url-handlers" "\
;;;***
\f
-;;;### (autoloads nil "url-http" "url/url-http.el" (21063 65063 266334
-;;;;;; 0))
+;;;### (autoloads nil "url-http" "url/url-http.el" (22092 27718 532268
+;;;;;; 464000))
;;; Generated autoloads from url/url-http.el
(autoload 'url-default-expander "url-expand")
;;;***
\f
-;;;### (autoloads nil "url-irc" "url/url-irc.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "url-irc" "url/url-irc.el" (22086 11930 366062
+;;;;;; 731000))
;;; Generated autoloads from url/url-irc.el
(autoload 'url-irc "url-irc" "\
;;;***
\f
-;;;### (autoloads nil "url-ldap" "url/url-ldap.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "url-ldap" "url/url-ldap.el" (22086 11930 366062
+;;;;;; 731000))
;;; Generated autoloads from url/url-ldap.el
(autoload 'url-ldap "url-ldap" "\
;;;***
\f
-;;;### (autoloads nil "url-mailto" "url/url-mailto.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "url-mailto" "url/url-mailto.el" (22086 11930
+;;;;;; 366062 731000))
;;; Generated autoloads from url/url-mailto.el
(autoload 'url-mail "url-mailto" "\
;;;***
\f
-;;;### (autoloads nil "url-misc" "url/url-misc.el" (21047 30582 575560
-;;;;;; 699000))
+;;;### (autoloads nil "url-misc" "url/url-misc.el" (22086 11930 366062
+;;;;;; 731000))
;;; Generated autoloads from url/url-misc.el
(autoload 'url-man "url-misc" "\
;;;***
\f
-;;;### (autoloads nil "url-news" "url/url-news.el" (20884 7264 912957
-;;;;;; 506000))
+;;;### (autoloads nil "url-news" "url/url-news.el" (22086 11930 366062
+;;;;;; 731000))
;;; Generated autoloads from url/url-news.el
(autoload 'url-news "url-news" "\
;;;***
\f
-;;;### (autoloads nil "url-ns" "url/url-ns.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "url-ns" "url/url-ns.el" (22086 11930 366062
+;;;;;; 731000))
;;; Generated autoloads from url/url-ns.el
(autoload 'isPlainHostName "url-ns" "\
;;;***
\f
-;;;### (autoloads nil "url-parse" "url/url-parse.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "url-parse" "url/url-parse.el" (22086 11930
+;;;;;; 366062 731000))
;;; Generated autoloads from url/url-parse.el
(autoload 'url-recreate-url "url-parse" "\
ATTRIBUTES is nil; this slot originally stored the attribute and
value alists for IMAP URIs, but this feature was removed
since it conflicts with RFC 3986.
-FULLNESS is non-nil iff the hierarchical sequence component of
+FULLNESS is non-nil if the hierarchical sequence component of
the URL starts with two slashes, \"//\".
The parser follows RFC 3986, except that it also tries to handle
;;;***
\f
-;;;### (autoloads nil "url-privacy" "url/url-privacy.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "url-privacy" "url/url-privacy.el" (22086 11930
+;;;;;; 366062 731000))
;;; Generated autoloads from url/url-privacy.el
(autoload 'url-setup-privacy-info "url-privacy" "\
;;;***
\f
-;;;### (autoloads nil "url-queue" "url/url-queue.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "url-queue" "url/url-queue.el" (22086 11930
+;;;;;; 366062 731000))
;;; Generated autoloads from url/url-queue.el
(autoload 'url-queue-retrieve "url-queue" "\
;;;***
\f
-;;;### (autoloads nil "url-util" "url/url-util.el" (21063 65063 266334
-;;;;;; 0))
+;;;### (autoloads nil "url-tramp" "url/url-tramp.el" (22086 11930
+;;;;;; 366062 731000))
+;;; Generated autoloads from url/url-tramp.el
+
+(defvar url-tramp-protocols '("ftp" "ssh" "scp" "rsync" "telnet") "\
+List of URL protocols the work is handled by Tramp.
+They must also be covered by `url-handler-regexp'.")
+
+(custom-autoload 'url-tramp-protocols "url-tramp" t)
+
+(autoload 'url-tramp-file-handler "url-tramp" "\
+Function called from the `file-name-handler-alist' routines.
+OPERATION is what needs to be done. ARGS are the arguments that
+would have been passed to OPERATION.
+
+\(fn OPERATION &rest ARGS)" nil nil)
+
+;;;***
+\f
+;;;### (autoloads nil "url-util" "url/url-util.el" (22092 27718 532268
+;;;;;; 464000))
;;; Generated autoloads from url/url-util.el
(defvar url-debug nil "\
\(fn STRING)" nil nil)
(autoload 'url-normalize-url "url-util" "\
-Return a 'normalized' version of URL.
+Return a \"normalized\" version of URL.
Strips out default port numbers, etc.
\(fn URL)" nil nil)
\(fn &rest ARGS)" nil nil)
(autoload 'url-get-normalized-date "url-util" "\
-Return a 'real' date string that most HTTP servers can understand.
+Return a date string that most HTTP servers can understand.
\(fn &optional SPECIFIED-TIME)" nil nil)
Build a query-string.
Given a QUERY in the form:
-'((key1 val1)
+ ((key1 val1)
(key2 val2)
(key3 val1 val2)
(key4)
;;;***
\f
-;;;### (autoloads nil "userlock" "userlock.el" (20998 4934 952905
-;;;;;; 0))
+;;;### (autoloads nil "userlock" "userlock.el" (22092 27718 532268
+;;;;;; 464000))
;;; Generated autoloads from userlock.el
(autoload 'ask-user-about-lock "userlock" "\
Ask user what to do when he wants to edit FILE but it is locked by OPPONENT.
This function has a choice of three things to do:
- do (signal 'file-locked (list FILE OPPONENT))
+ do (signal \\='file-locked (list FILE OPPONENT))
to refrain from editing the file
return t (grab the lock on the file)
return nil (edit the file even though it is locked).
(autoload 'ask-user-about-supersession-threat "userlock" "\
Ask a user who is about to modify an obsolete buffer what to do.
This function has two choices: it can return, in which case the modification
-of the buffer will proceed, or it can (signal 'file-supersession (file)),
+of the buffer will proceed, or it can (signal \\='file-supersession (file)),
in which case the proposed buffer modification will not be made.
You can rewrite this to use any criterion you like to choose which one to do.
;;;***
\f
-;;;### (autoloads nil "utf-7" "international/utf-7.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "utf-7" "international/utf-7.el" (22086 11929
+;;;;;; 886062 731000))
;;; Generated autoloads from international/utf-7.el
(autoload 'utf-7-post-read-conversion "utf-7" "\
;;;***
\f
-;;;### (autoloads nil "utf7" "gnus/utf7.el" (20791 9657 561026 0))
+;;;### (autoloads nil "utf7" "gnus/utf7.el" (22086 11929 854062 731000))
;;; Generated autoloads from gnus/utf7.el
(autoload 'utf7-encode "utf7" "\
;;;***
\f
-;;;### (autoloads nil "uudecode" "mail/uudecode.el" (20709 26818
-;;;;;; 907104 0))
+;;;### (autoloads nil "uudecode" "mail/uudecode.el" (22086 11929
+;;;;;; 954062 731000))
;;; Generated autoloads from mail/uudecode.el
(autoload 'uudecode-decode-region-external "uudecode" "\
;;;***
\f
-;;;### (autoloads nil "vc" "vc/vc.el" (21141 54458 609734 0))
+;;;### (autoloads nil "vc" "vc/vc.el" (22093 48588 592393 539000))
;;; Generated autoloads from vc/vc.el
(defvar vc-checkout-hook nil "\
(custom-autoload 'vc-before-checkin-hook "vc" t)
+(autoload 'vc-responsible-backend "vc" "\
+Return the name of a backend system that is responsible for FILE.
+
+If FILE is already registered, return the
+backend of FILE. If FILE is not registered, then the
+first backend in `vc-handled-backends' that declares itself
+responsible for FILE is returned.
+
+\(fn FILE)" nil nil)
+
(autoload 'vc-next-action "vc" "\
Do the next logical version control operation on the current fileset.
This requires that all files in the current VC fileset be in the
If every file is registered and unlocked, check out (lock)
the file(s) for editing.
If every file is locked by you and has changes, pop up a
- *vc-log* buffer to check in the changes. If the variable
- `vc-keep-workfiles' is non-nil (the default), leave a
+ *vc-log* buffer to check in the changes. Leave a
read-only copy of each changed file after checking in.
If every file is locked by you and unchanged, unlock them.
If every file is locked by someone else, offer to steal the lock.
Register into a version control system.
If VC-FILESET is given, register the files in that fileset.
Otherwise register the current file.
-With prefix argument SET-REVISION, allow user to specify initial revision
-level. If COMMENT is present, use that as an initial comment.
+If COMMENT is present, use that as an initial comment.
The version control system to use is found by cycling through the list
`vc-handled-backends'. The first backend in that list which declares
register the file. If no backend declares itself responsible, the
first backend that could register the file is used.
-\(fn &optional SET-REVISION VC-FILESET COMMENT)" t nil)
+\(fn &optional VC-FILESET COMMENT)" t nil)
(autoload 'vc-version-diff "vc" "\
Report diffs between revisions of the fileset in the repository history.
\(fn HISTORIC &optional NOT-URGENT)" t nil)
+(autoload 'vc-root-dir "vc" "\
+Return the root directory for the current VC tree.
+Return nil if the root directory cannot be identified.
+
+\(fn)" nil nil)
+
(autoload 'vc-revision-other-window "vc" "\
Visit revision REV of the current file in another window.
If the current file is named `F', the revision is named `F.~REV~'.
\(fn)" t nil)
+(autoload 'vc-message-unresolved-conflicts "vc" "\
+Display a message indicating unresolved conflicts in FILENAME.
+
+\(fn FILENAME)" nil nil)
+
(defalias 'vc-resolve-conflicts 'smerge-ediff)
(autoload 'vc-create-tag "vc" "\
\(fn DIR NAME BRANCHP)" t nil)
(autoload 'vc-retrieve-tag "vc" "\
-Descending recursively from DIR, retrieve the tag called NAME.
-If NAME is empty, it refers to the latest revisions.
+For each file in or below DIR, retrieve their tagged version NAME.
+NAME can name a branch, in which case this command will switch to the
+named branch in the directory DIR.
+Interactively, prompt for DIR only for VCS that works at file level;
+otherwise use the default directory of the current buffer.
+If NAME is empty, it refers to the latest revisions of the current branch.
If locking is used for the files in DIR, then there must not be any
locked files at or below DIR (but if NAME is empty, locked files are
allowed and simply skipped).
\(fn &optional REMOTE-LOCATION)" t nil)
+(autoload 'vc-region-history "vc" "\
+Show the history of the region FROM..TO.
+
+\(fn FROM TO)" t nil)
+
(autoload 'vc-revert "vc" "\
Revert working copies of the selected fileset to their repository contents.
This asks for confirmation if the buffer contents are not identical
\(fn)" t nil)
-(autoload 'vc-rollback "vc" "\
-Roll back (remove) the most recent changeset committed to the repository.
-This may be either a file-level or a repository-level operation,
-depending on the underlying version-control system.
-
-\(fn)" t nil)
-
(define-obsolete-function-alias 'vc-revert-buffer 'vc-revert "23.1")
(autoload 'vc-pull "vc" "\
(defalias 'vc-update 'vc-pull)
+(autoload 'vc-push "vc" "\
+Push the current branch.
+You must be visiting a version controlled file, or in a `vc-dir' buffer.
+On a distributed version control system, this runs a \"push\"
+operation on the current branch, prompting for the precise command
+if required. Optional prefix ARG non-nil forces a prompt.
+On a non-distributed version control system, this signals an error.
+
+\(fn &optional ARG)" t nil)
+
(autoload 'vc-switch-backend "vc" "\
Make BACKEND the current version control system for FILE.
FILE must already be registered in BACKEND. The change is not
;;;***
\f
-;;;### (autoloads nil "vc-annotate" "vc/vc-annotate.el" (21031 51082
-;;;;;; 798722 0))
+;;;### (autoloads nil "vc-annotate" "vc/vc-annotate.el" (22086 11930
+;;;;;; 382062 731000))
;;; Generated autoloads from vc/vc-annotate.el
(autoload 'vc-annotate "vc-annotate" "\
mode-specific menu. `vc-annotate-color-map' and
`vc-annotate-very-old-color' define the mapping of time to colors.
`vc-annotate-background' specifies the background color.
+`vc-annotate-background-mode' specifies whether the color map
+should be applied to the background or to the foreground.
\(fn FILE REV &optional DISPLAY-MODE BUF MOVE-POINT-TO VC-BK)" t nil)
;;;***
\f
-;;;### (autoloads nil "vc-arch" "vc/vc-arch.el" (21071 59176 747909
-;;;;;; 0))
-;;; Generated autoloads from vc/vc-arch.el
- (defun vc-arch-registered (file)
- (if (vc-find-root file "{arch}/=tagging-method")
- (progn
- (load "vc-arch" nil t)
- (vc-arch-registered file))))
-
-;;;***
-\f
-;;;### (autoloads nil "vc-bzr" "vc/vc-bzr.el" (21041 38058 75002
-;;;;;; 0))
+;;;### (autoloads nil "vc-bzr" "vc/vc-bzr.el" (22086 11930 382062
+;;;;;; 731000))
;;; Generated autoloads from vc/vc-bzr.el
(defconst vc-bzr-admin-dirname ".bzr" "\
;;;***
\f
-;;;### (autoloads nil "vc-cvs" "vc/vc-cvs.el" (21071 59176 747909
-;;;;;; 0))
+;;;### (autoloads nil "vc-cvs" "vc/vc-cvs.el" (22099 26170 434017
+;;;;;; 16000))
;;; Generated autoloads from vc/vc-cvs.el
(defun vc-cvs-registered (f)
"Return non-nil if file F is registered with CVS."
;;;***
\f
-;;;### (autoloads nil "vc-dir" "vc/vc-dir.el" (21053 29224 547064
-;;;;;; 0))
+;;;### (autoloads nil "vc-dir" "vc/vc-dir.el" (22086 11930 386062
+;;;;;; 731000))
;;; Generated autoloads from vc/vc-dir.el
(autoload 'vc-dir "vc-dir" "\
;;;***
\f
-;;;### (autoloads nil "vc-dispatcher" "vc/vc-dispatcher.el" (21143
-;;;;;; 9782 474230 0))
+;;;### (autoloads nil "vc-dispatcher" "vc/vc-dispatcher.el" (22104
+;;;;;; 18893 237441 487000))
;;; Generated autoloads from vc/vc-dispatcher.el
(autoload 'vc-do-command "vc-dispatcher" "\
;;;***
\f
-;;;### (autoloads nil "vc-git" "vc/vc-git.el" (21139 12727 345232
-;;;;;; 0))
+;;;### (autoloads nil "vc-git" "vc/vc-git.el" (22097 45637 495432
+;;;;;; 455000))
;;; Generated autoloads from vc/vc-git.el
(defun vc-git-registered (file)
"Return non-nil if FILE is registered with git."
;;;***
\f
-;;;### (autoloads nil "vc-hg" "vc/vc-hg.el" (21031 51082 798722 0))
+;;;### (autoloads nil "vc-hg" "vc/vc-hg.el" (22097 45637 503432 455000))
;;; Generated autoloads from vc/vc-hg.el
(defun vc-hg-registered (file)
"Return non-nil if FILE is registered with hg."
;;;***
\f
-;;;### (autoloads nil "vc-mtn" "vc/vc-mtn.el" (21071 59176 747909
-;;;;;; 0))
+;;;### (autoloads nil "vc-mtn" "vc/vc-mtn.el" (22097 45637 515432
+;;;;;; 455000))
;;; Generated autoloads from vc/vc-mtn.el
(defconst vc-mtn-admin-dir "_MTN" "\
;;;***
\f
-;;;### (autoloads nil "vc-rcs" "vc/vc-rcs.el" (21113 26590 654875
-;;;;;; 0))
+;;;### (autoloads nil "vc-rcs" "vc/vc-rcs.el" (22097 45637 527432
+;;;;;; 455000))
;;; Generated autoloads from vc/vc-rcs.el
(defvar vc-rcs-master-templates (purecopy '("%sRCS/%s,v" "%s%s,v" "%sRCS/%s")) "\
;;;***
\f
-;;;### (autoloads nil "vc-sccs" "vc/vc-sccs.el" (21056 5418 85093
-;;;;;; 0))
+;;;### (autoloads nil "vc-sccs" "vc/vc-sccs.el" (22086 11930 386062
+;;;;;; 731000))
;;; Generated autoloads from vc/vc-sccs.el
(defvar vc-sccs-master-templates (purecopy '("%sSCCS/s.%s" "%ss.%s" vc-sccs-search-project-dir)) "\
;;;***
\f
-;;;### (autoloads nil "vc-svn" "vc/vc-svn.el" (21077 42241 670130
-;;;;;; 556000))
+;;;### (autoloads nil "vc-src" "vc/vc-src.el" (22086 11930 386062
+;;;;;; 731000))
+;;; Generated autoloads from vc/vc-src.el
+
+(defvar vc-src-master-templates (purecopy '("%s.src/%s,v")) "\
+Where to look for SRC master files.
+For a description of possible values, see `vc-check-master-templates'.")
+
+(custom-autoload 'vc-src-master-templates "vc-src" t)
+
+(defun vc-src-registered (f) (vc-default-registered 'src f))
+
+;;;***
+\f
+;;;### (autoloads nil "vc-svn" "vc/vc-svn.el" (22101 42694 157526
+;;;;;; 804000))
;;; Generated autoloads from vc/vc-svn.el
(defun vc-svn-registered (f)
(let ((admin-dir (cond ((and (eq system-type 'windows-nt)
;;;***
\f
-;;;### (autoloads nil "vera-mode" "progmodes/vera-mode.el" (20893
-;;;;;; 60586 188550 0))
+;;;### (autoloads nil "vera-mode" "progmodes/vera-mode.el" (22092
+;;;;;; 27718 320268 464000))
;;; Generated autoloads from progmodes/vera-mode.el
(push (purecopy '(vera-mode 2 28)) package--builtin-versions)
(add-to-list 'auto-mode-alist (cons (purecopy "\\.vr[hi]?\\'") 'vera-mode))
;;;***
\f
;;;### (autoloads nil "verilog-mode" "progmodes/verilog-mode.el"
-;;;;;; (21124 45367 88860 0))
+;;;;;; (22092 27718 348268 464000))
;;; Generated autoloads from progmodes/verilog-mode.el
(autoload 'verilog-mode "verilog-mode" "\
Set to 0 to get such code to lined up underneath the task or
function keyword.
`verilog-indent-level-directive' (default 1)
- Indentation of `ifdef/`endif blocks.
+ Indentation of \\=`ifdef/\\=`endif blocks.
`verilog-cexp-indent' (default 1)
Indentation of Verilog statements broken across lines i.e.:
if (a)
will be inserted. Setting this variable to zero results in every
end acquiring a comment; the default avoids too many redundant
comments in tight quarters.
- `verilog-auto-lineup' (default 'declarations)
+ `verilog-auto-lineup' (default `declarations')
List of contexts where auto lineup of code should be done.
Variables controlling other actions:
- `verilog-linter' (default surelint)
+ `verilog-linter' (default `surelint')
Unix program to call to run the lint checker. This is the default
command for \\[compile-command] and \\[verilog-auto-save-compile].
;;;***
\f
-;;;### (autoloads nil "vhdl-mode" "progmodes/vhdl-mode.el" (20892
-;;;;;; 39729 858825 0))
+;;;### (autoloads nil "vhdl-mode" "progmodes/vhdl-mode.el" (22092
+;;;;;; 27718 400268 464000))
;;; Generated autoloads from progmodes/vhdl-mode.el
(autoload 'vhdl-mode "vhdl-mode" "\
;;; --> \" := \" [[ --> [ --CR --> comment-out code
.. --> \" => \" ] --> ) --- --> horizontal line
,, --> \" <= \" ]] --> ] ---- --> display comment
- == --> \" == \" '' --> \\\"
+ == --> \" == \" \\='\\=' --> \\\"
WORD COMPLETION:
Typing `TAB' after `(' looks for and inserts complete parenthesized
expressions (e.g. for array index ranges). All keywords as well as
standard types and subprograms of VHDL have predefined abbreviations
- (e.g. type \"std\" and `TAB' will toggle through all standard types
+ (e.g., type \"std\" and `TAB' will toggle through all standard types
beginning with \"std\").
Typing `TAB' after a non-word character indents the line if at the
according to option `vhdl-argument-list-indent'.
If option `vhdl-indent-tabs-mode' is nil, spaces are used instead of
- tabs. `M-x tabify' and `M-x untabify' allow to convert spaces to tabs
+ tabs. `\\[tabify]' and `\\[untabify]' allow to convert spaces to tabs
and vice versa.
Syntax-based indentation can be very slow in large files. Option
- `vhdl-indent-syntax-based' allows to use faster but simpler indentation.
+ `vhdl-indent-syntax-based' allows you to use faster but simpler indentation.
Option `vhdl-indent-comment-like-next-code-line' controls whether
comment lines are indented like the preceding or like the following code
CODE FILLING:
- Code filling allows to condense code (e.g. sensitivity lists or port
+ Code filling allows you to condense code (e.g. sensitivity lists or port
maps) by removing comments and newlines and re-wrapping so that all
lines are maximally filled (block filling). `C-c C-f C-f' fills a list
enclosed by parenthesis, `C-c C-f C-g' a group of lines separated by
VHDL STANDARDS:
The VHDL standards to be used are specified in option `vhdl-standard'.
- Available standards are: VHDL'87/'93(02), VHDL-AMS, and Math Packages.
+ Available standards are: VHDL'87/'93(02)/'08, VHDL-AMS, and Math Packages.
KEYWORD CASE:
Words with special syntax can be highlighted by specifying their
syntax and color in option `vhdl-special-syntax-alist' and by setting
- option `vhdl-highlight-special-words' to non-nil. This allows to
+ option `vhdl-highlight-special-words' to non-nil. This allows you to
establish some naming conventions (e.g. to distinguish different kinds
of signals or other objects by using name suffices) and to support them
visually.
`vhdl-highlight-translate-off' is non-nil.
For documentation and customization of the used colors see
- customization group `vhdl-highlight-faces' (`M-x customize-group'). For
+ customization group `vhdl-highlight-faces' (`\\[customize-group]'). For
highlighting of matching parenthesis, see customization group
`paren-showing'. Automatic buffer highlighting is turned on/off by
option `global-font-lock-mode' (`font-lock-auto-fontify' in XEmacs).
CODE FIXING:
`C-c C-x C-p' fixes the closing parenthesis of a generic/port clause
- (e.g. if the closing parenthesis is on the wrong line or is missing).
+ (e.g., if the closing parenthesis is on the wrong line or is missing).
PRINTING:
sessions using the \"Save Options\" menu entry.
Options and their detailed descriptions can also be accessed by using
- the \"Customize\" menu entry or the command `M-x customize-option' (`M-x
- customize-group' for groups). Some customizations only take effect
+ the \"Customize\" menu entry or the command `\\[customize-option]'
+ (`\\[customize-group]' for groups). Some customizations only take effect
after some action (read the NOTE in the option documentation).
Customization can also be done globally (i.e. site-wide, read the
INSTALL file).
Not all options are described in this documentation, so go and see
- what other useful user options there are (`M-x vhdl-customize' or menu)!
+ what other useful user options there are (`\\[vhdl-customize]' or menu)!
FILE EXTENSIONS:
automatically recognized as VHDL source files. To add an extension
\".xxx\", add the following line to your Emacs start-up file (`.emacs'):
- (push '(\"\\\\.xxx\\\\'\" . vhdl-mode) auto-mode-alist)
+ (push \\='(\"\\\\.xxx\\\\\\='\" . vhdl-mode) auto-mode-alist)
HINTS:
Maintenance:
------------
-To submit a bug report, enter `M-x vhdl-submit-bug-report' within VHDL Mode.
+To submit a bug report, enter `\\[vhdl-submit-bug-report]' within VHDL Mode.
Add a description of the problem and include a reproducible test case.
Questions and enhancement requests can be sent to <reto@gnu.org>.
;;;***
\f
-;;;### (autoloads nil "vi" "emulation/vi.el" (20929 34089 117790
-;;;;;; 0))
-;;; Generated autoloads from emulation/vi.el
-
-(autoload 'vi-mode "vi" "\
-Major mode that acts like the `vi' editor.
-The purpose of this mode is to provide you the combined power of vi (namely,
-the \"cross product\" effect of commands and repeat last changes) and Emacs.
-
-This command redefines nearly all keys to look like vi commands.
-It records the previous major mode, and any vi command for input
-\(`i', `a', `s', etc.) switches back to that mode.
-Thus, ordinary Emacs (in whatever major mode you had been using)
-is \"input\" mode as far as vi is concerned.
-
-To get back into vi from \"input\" mode, you must issue this command again.
-Therefore, it is recommended that you assign it to a key.
-
-Major differences between this mode and real vi :
-
-* Limitations and unsupported features
- - Search patterns with line offset (e.g. /pat/+3 or /pat/z.) are
- not supported.
- - Ex commands are not implemented; try ':' to get some hints.
- - No line undo (i.e. the 'U' command), but multi-undo is a standard feature.
-
-* Modifications
- - The stopping positions for some point motion commands (word boundary,
- pattern search) are slightly different from standard 'vi'.
- Also, no automatic wrap around at end of buffer for pattern searching.
- - Since changes are done in two steps (deletion then insertion), you need
- to undo twice to completely undo a change command. But this is not needed
- for undoing a repeated change command.
- - No need to set/unset 'magic', to search for a string with regular expr
- in it just put a prefix arg for the search commands. Replace cmds too.
- - ^R is bound to incremental backward search, so use ^L to redraw screen.
-
-* Extensions
- - Some standard (or modified) Emacs commands were integrated, such as
- incremental search, query replace, transpose objects, and keyboard macros.
- - In command state, ^X links to the 'ctl-x-map', and ESC can be linked to
- esc-map or set undefined. These can give you the full power of Emacs.
- - See vi-com-map for those keys that are extensions to standard vi, e.g.
- `vi-name-last-change-or-macro', `vi-verify-spelling', `vi-locate-def',
- `vi-mark-region', and 'vi-quote-words'. Some of them are quite handy.
- - Use \\[vi-switch-mode] to switch among different modes quickly.
-
-Syntax table and abbrevs while in vi mode remain as they were in Emacs.
-
-\(fn)" t nil)
-
-;;;***
-\f
-;;;### (autoloads nil "viet-util" "language/viet-util.el" (20826
-;;;;;; 45095 436233 0))
+;;;### (autoloads nil "viet-util" "language/viet-util.el" (22086
+;;;;;; 11929 906062 731000))
;;; Generated autoloads from language/viet-util.el
(autoload 'viet-encode-viscii-char "viet-util" "\
;;;***
\f
-;;;### (autoloads nil "view" "view.el" (20999 25770 522517 0))
+;;;### (autoloads nil "view" "view.el" (22086 11930 390062 731000))
;;; Generated autoloads from view.el
(defvar view-remove-frame-by-deleting t "\
;;;***
\f
-;;;### (autoloads nil "vip" "emulation/vip.el" (20929 34089 117790
-;;;;;; 0))
-;;; Generated autoloads from emulation/vip.el
-
-(autoload 'vip-setup "vip" "\
-Set up bindings for C-x 7 and C-z that are useful for VIP users.
-
-\(fn)" nil nil)
-
-(autoload 'vip-mode "vip" "\
-Turn on VIP emulation of VI.
-
-\(fn)" t nil)
-
-;;;***
-\f
-;;;### (autoloads nil "viper" "emulation/viper.el" (20954 37295 781599
-;;;;;; 0))
+;;;### (autoloads nil "viper" "emulation/viper.el" (22086 11929 698062
+;;;;;; 731000))
;;; Generated autoloads from emulation/viper.el
(push (purecopy '(viper 3 14 1)) package--builtin-versions)
;;;***
\f
-;;;### (autoloads nil "warnings" "emacs-lisp/warnings.el" (20709
-;;;;;; 26818 907104 0))
+;;;### (autoloads nil "warnings" "emacs-lisp/warnings.el" (22086
+;;;;;; 11929 690062 731000))
;;; Generated autoloads from emacs-lisp/warnings.el
(defvar warning-prefix-function nil "\
\(fn TYPE MESSAGE &optional LEVEL BUFFER-NAME)" nil nil)
(autoload 'lwarn "warnings" "\
-Display a warning message made from (format MESSAGE ARGS...).
-Aside from generating the message with `format',
+Display a warning message made from (format-message MESSAGE ARGS...).
+\\<special-mode-map>
+Aside from generating the message with `format-message',
this is equivalent to `display-warning'.
TYPE is the warning type: either a custom group name (a symbol),
\(fn TYPE LEVEL MESSAGE &rest ARGS)" nil nil)
(autoload 'warn "warnings" "\
-Display a warning message made from (format MESSAGE ARGS...).
-Aside from generating the message with `format',
+Display a warning message made from (format-message MESSAGE ARGS...).
+Aside from generating the message with `format-message',
this is equivalent to `display-warning', using
`emacs' as the type and `:warning' as the level.
;;;***
\f
-;;;### (autoloads nil "wdired" "wdired.el" (21049 14338 391345 0))
+;;;### (autoloads nil "wdired" "wdired.el" (22086 11930 394062 731000))
;;; Generated autoloads from wdired.el
(push (purecopy '(wdired 2 0)) package--builtin-versions)
;;;***
\f
-;;;### (autoloads nil "webjump" "net/webjump.el" (20927 49244 970422
-;;;;;; 0))
+;;;### (autoloads nil "webjump" "net/webjump.el" (22086 11930 22062
+;;;;;; 731000))
;;; Generated autoloads from net/webjump.el
(autoload 'webjump "webjump" "\
;;;***
\f
-;;;### (autoloads nil "which-func" "progmodes/which-func.el" (20895
-;;;;;; 15912 444844 0))
+;;;### (autoloads nil "which-func" "progmodes/which-func.el" (22086
+;;;;;; 11930 242062 731000))
;;; Generated autoloads from progmodes/which-func.el
(put 'which-func-format 'risky-local-variable t)
(put 'which-func-current 'risky-local-variable t)
;;;***
\f
-;;;### (autoloads nil "whitespace" "whitespace.el" (20986 60038 720063
-;;;;;; 0))
+;;;### (autoloads nil "whitespace" "whitespace.el" (22086 11930 394062
+;;;;;; 731000))
;;; Generated autoloads from whitespace.el
(push (purecopy '(whitespace 13 2 2)) package--builtin-versions)
C-i toggle indentation SPACEs visualization (via `indent-tabs-mode')
I toggle indentation SPACEs visualization
i toggle indentation TABs visualization
+ C-t toggle big indentation visualization
C-a toggle SPACEs after TAB visualization (via `indent-tabs-mode')
A toggle SPACEs after TAB: SPACEs visualization
a toggle SPACEs after TAB: TABs visualization
indentation toggle indentation SPACEs visualization
indentation::tab toggle indentation SPACEs visualization
indentation::space toggle indentation TABs visualization
+ big-indent toggle big indentation visualization
space-after-tab toggle SPACEs after TAB visualization
space-after-tab::tab toggle SPACEs after TAB: SPACEs visualization
space-after-tab::space toggle SPACEs after TAB: TABs visualization
C-i toggle indentation SPACEs visualization (via `indent-tabs-mode')
I toggle indentation SPACEs visualization
i toggle indentation TABs visualization
+ C-t toggle big indentation visualization
C-a toggle SPACEs after TAB visualization (via `indent-tabs-mode')
A toggle SPACEs after TAB: SPACEs visualization
a toggle SPACEs after TAB: TABs visualization
indentation toggle indentation SPACEs visualization
indentation::tab toggle indentation SPACEs visualization
indentation::space toggle indentation TABs visualization
+ big-indent toggle big indentation visualization
space-after-tab toggle SPACEs after TAB visualization
space-after-tab::tab toggle SPACEs after TAB: SPACEs visualization
space-after-tab::space toggle SPACEs after TAB: TABs visualization
(autoload 'whitespace-report "whitespace" "\
Report some whitespace problems in buffer.
-Return nil if there is no whitespace problem; otherwise, return
-non-nil.
-
-If FORCE is non-nil or \\[universal-argument] was pressed just
-before calling `whitespace-report' interactively, it forces
-`whitespace-style' to have:
-
- empty
- trailing
- indentation
- space-before-tab
- space-after-tab
-
-If REPORT-IF-BOGUS is non-nil, it reports only when there are any
-whitespace problems in buffer.
-
-Report if some of the following whitespace problems exist:
-
-* If `indent-tabs-mode' is non-nil:
- empty 1. empty lines at beginning of buffer.
- empty 2. empty lines at end of buffer.
- trailing 3. SPACEs or TABs at end of line.
- indentation 4. 8 or more SPACEs at beginning of line.
- space-before-tab 5. SPACEs before TAB.
- space-after-tab 6. 8 or more SPACEs after TAB.
-
-* If `indent-tabs-mode' is nil:
- empty 1. empty lines at beginning of buffer.
- empty 2. empty lines at end of buffer.
- trailing 3. SPACEs or TABs at end of line.
- indentation 4. TABS at beginning of line.
- space-before-tab 5. SPACEs before TAB.
- space-after-tab 6. 8 or more SPACEs after TAB.
-
-See `whitespace-style' for documentation.
-See also `whitespace-cleanup' and `whitespace-cleanup-region' for
-cleaning up these problems.
+Perform `whitespace-report-region' on the current buffer.
\(fn &optional FORCE REPORT-IF-BOGUS)" t nil)
forces `whitespace-style' to have:
empty
+ trailing
indentation
space-before-tab
- trailing
space-after-tab
-If REPORT-IF-BOGUS is non-nil, it reports only when there are any
-whitespace problems in buffer.
+If REPORT-IF-BOGUS is t, it reports only when there are any
+whitespace problems in buffer; if it is `never', it does not
+report problems.
Report if some of the following whitespace problems exist:
;;;***
\f
-;;;### (autoloads nil "wid-browse" "wid-browse.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "wid-browse" "wid-browse.el" (22086 11930 394062
+;;;;;; 731000))
;;; Generated autoloads from wid-browse.el
(autoload 'widget-browse-at "wid-browse" "\
;;;***
\f
-;;;### (autoloads nil "wid-edit" "wid-edit.el" (20959 55207 940876
-;;;;;; 0))
+;;;### (autoloads nil "wid-edit" "wid-edit.el" (22092 27718 580268
+;;;;;; 464000))
;;; Generated autoloads from wid-edit.el
(autoload 'widgetp "wid-edit" "\
;;;***
\f
-;;;### (autoloads nil "windmove" "windmove.el" (20709 26818 907104
-;;;;;; 0))
+;;;### (autoloads nil "windmove" "windmove.el" (22092 27718 580268
+;;;;;; 464000))
;;; Generated autoloads from windmove.el
(autoload 'windmove-left "windmove" "\
(autoload 'windmove-default-keybindings "windmove" "\
Set up keybindings for `windmove'.
Keybindings are of the form MODIFIER-{left,right,up,down}.
-Default MODIFIER is 'shift.
+Default MODIFIER is `shift'.
\(fn &optional MODIFIER)" t nil)
;;;***
\f
-;;;### (autoloads nil "winner" "winner.el" (20992 52525 458637 0))
+;;;### (autoloads nil "winner" "winner.el" (22086 11930 398062 731000))
;;; Generated autoloads from winner.el
(defvar winner-mode nil "\
;;;***
\f
-;;;### (autoloads nil "woman" "woman.el" (20999 25770 522517 0))
+;;;### (autoloads nil "woman" "woman.el" (22092 27718 620268 464000))
;;; Generated autoloads from woman.el
(push (purecopy '(woman 0 551)) package--builtin-versions)
;;;***
\f
-;;;### (autoloads nil "ws-mode" "emulation/ws-mode.el" (21040 17194
-;;;;;; 398147 0))
-;;; Generated autoloads from emulation/ws-mode.el
-(push (purecopy '(ws-mode 0 7)) package--builtin-versions)
-
-(autoload 'wordstar-mode "ws-mode" "\
-Major mode with WordStar-like key bindings.
-
-BUGS:
- - Help menus with WordStar commands (C-j just calls help-for-help)
- are not implemented
- - Options for search and replace
- - Show markers (C-k h) is somewhat strange
- - Search and replace (C-q a) is only available in forward direction
-
-No key bindings beginning with ESC are installed, they will work
-Emacs-like.
-
-\(fn)" t nil)
-
-;;;***
-\f
-;;;### (autoloads nil "xml" "xml.el" (21002 1963 769129 0))
+;;;### (autoloads nil "xml" "xml.el" (22092 27718 620268 464000))
;;; Generated autoloads from xml.el
(autoload 'xml-parse-file "xml" "\
If PARSE-NS is an alist, it will be used as the mapping from
namespace to URIs instead.
-If it is the symbol 'symbol-qnames, expanded names will be
-returned as a plain symbol 'namespace:foo instead of a cons.
+If it is the symbol `symbol-qnames', expanded names will be
+returned as a plain symbol `namespace:foo' instead of a cons.
Both features can be combined by providing a cons cell
If PARSE-NS is an alist, it will be used as the mapping from
namespace to URIs instead.
-If it is the symbol 'symbol-qnames, expanded names will be
-returned as a plain symbol 'namespace:foo instead of a cons.
+If it is the symbol `symbol-qnames', expanded names will be
+returned as a plain symbol `namespace:foo' instead of a cons.
Both features can be combined by providing a cons cell
;;;***
\f
-;;;### (autoloads nil "xmltok" "nxml/xmltok.el" (21075 56234 349623
-;;;;;; 0))
+;;;### (autoloads nil "xmltok" "nxml/xmltok.el" (22086 11930 30062
+;;;;;; 731000))
;;; Generated autoloads from nxml/xmltok.el
(autoload 'xmltok-get-declared-encoding-position "xmltok" "\
;;;***
\f
-;;;### (autoloads nil "xt-mouse" "xt-mouse.el" (20797 44848 327754
-;;;;;; 0))
+;;;### (autoloads nil "xref" "progmodes/xref.el" (22105 39773 959886
+;;;;;; 896000))
+;;; Generated autoloads from progmodes/xref.el
+
+(autoload 'xref-find-backend "xref" "\
+
+
+\(fn)" nil nil)
+
+(autoload 'xref-pop-marker-stack "xref" "\
+Pop back to where \\[xref-find-definitions] was last invoked.
+
+\(fn)" t nil)
+
+(autoload 'xref-marker-stack-empty-p "xref" "\
+Return t if the marker stack is empty; nil otherwise.
+
+\(fn)" nil nil)
+
+(autoload 'xref-find-definitions "xref" "\
+Find the definition of the identifier at point.
+With prefix argument or when there's no identifier at point,
+prompt for it.
+
+If the backend has sufficient information to determine a unique
+definition for IDENTIFIER, it returns only that definition. If
+there are multiple possible definitions, it returns all of them.
+
+If the backend returns one definition, jump to it; otherwise,
+display the list in a buffer.
+
+\(fn IDENTIFIER)" t nil)
+
+(autoload 'xref-find-definitions-other-window "xref" "\
+Like `xref-find-definitions' but switch to the other window.
+
+\(fn IDENTIFIER)" t nil)
+
+(autoload 'xref-find-definitions-other-frame "xref" "\
+Like `xref-find-definitions' but switch to the other frame.
+
+\(fn IDENTIFIER)" t nil)
+
+(autoload 'xref-find-references "xref" "\
+Find references to the identifier at point.
+With prefix argument, prompt for the identifier.
+
+\(fn IDENTIFIER)" t nil)
+
+(autoload 'xref-find-apropos "xref" "\
+Find all meaningful symbols that match PATTERN.
+The argument has the same meaning as in `apropos'.
+
+\(fn PATTERN)" t nil)
+ (define-key esc-map "." #'xref-find-definitions)
+ (define-key esc-map "," #'xref-pop-marker-stack)
+ (define-key esc-map "?" #'xref-find-references)
+ (define-key esc-map [?\C-.] #'xref-find-apropos)
+ (define-key ctl-x-4-map "." #'xref-find-definitions-other-window)
+ (define-key ctl-x-5-map "." #'xref-find-definitions-other-frame)
+
+;;;***
+\f
+;;;### (autoloads nil "xt-mouse" "xt-mouse.el" (22086 11930 402062
+;;;;;; 731000))
;;; Generated autoloads from xt-mouse.el
(defvar xterm-mouse-mode nil "\
;;;***
\f
-;;;### (autoloads nil "yenc" "gnus/yenc.el" (20709 26818 907104 0))
+;;;### (autoloads nil "yenc" "gnus/yenc.el" (22086 11929 854062 731000))
;;; Generated autoloads from gnus/yenc.el
(autoload 'yenc-decode-region "yenc" "\
;;;***
\f
-;;;### (autoloads nil "zone" "play/zone.el" (20992 52525 458637 0))
+;;;### (autoloads nil "zone" "play/zone.el" (22086 11930 130062 731000))
;;; Generated autoloads from play/zone.el
(autoload 'zone "zone" "\
;;;;;; "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-map.el" "calc/calc-math.el"
-;;;;;; "calc/calc-menu.el" "calc/calc-misc.el" "calc/calc-mode.el"
-;;;;;; "calc/calc-mtx.el" "calc/calc-nlfit.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-units.el"
-;;;;;; "calc/calc-vec.el" "calc/calc-yank.el" "calc/calcalg2.el"
-;;;;;; "calc/calcalg3.el" "calc/calccomp.el" "calc/calcsel2.el"
-;;;;;; "calendar/cal-bahai.el" "calendar/cal-coptic.el" "calendar/cal-french.el"
-;;;;;; "calendar/cal-html.el" "calendar/cal-islam.el" "calendar/cal-iso.el"
-;;;;;; "calendar/cal-julian.el" "calendar/cal-loaddefs.el" "calendar/cal-mayan.el"
-;;;;;; "calendar/cal-menu.el" "calendar/cal-move.el" "calendar/cal-persia.el"
-;;;;;; "calendar/cal-tex.el" "calendar/cal-x.el" "calendar/diary-loaddefs.el"
-;;;;;; "calendar/hol-loaddefs.el" "cdl.el" "cedet/cedet-cscope.el"
-;;;;;; "cedet/cedet-files.el" "cedet/cedet-global.el" "cedet/cedet-idutils.el"
-;;;;;; "cedet/ede/auto.el" "cedet/ede/autoconf-edit.el" "cedet/ede/base.el"
-;;;;;; "cedet/ede/cpp-root.el" "cedet/ede/custom.el" "cedet/ede/emacs.el"
-;;;;;; "cedet/ede/files.el" "cedet/ede/generic.el" "cedet/ede/linux.el"
-;;;;;; "cedet/ede/locate.el" "cedet/ede/make.el" "cedet/ede/makefile-edit.el"
-;;;;;; "cedet/ede/pconf.el" "cedet/ede/pmake.el" "cedet/ede/proj-archive.el"
-;;;;;; "cedet/ede/proj-aux.el" "cedet/ede/proj-comp.el" "cedet/ede/proj-elisp.el"
-;;;;;; "cedet/ede/proj-info.el" "cedet/ede/proj-misc.el" "cedet/ede/proj-obj.el"
-;;;;;; "cedet/ede/proj-prog.el" "cedet/ede/proj-scheme.el" "cedet/ede/proj-shared.el"
-;;;;;; "cedet/ede/proj.el" "cedet/ede/shell.el" "cedet/ede/simple.el"
+;;;;;; "calc/calc-loaddefs.el" "calc/calc-macs.el" "calc/calc-map.el"
+;;;;;; "calc/calc-math.el" "calc/calc-menu.el" "calc/calc-misc.el"
+;;;;;; "calc/calc-mode.el" "calc/calc-mtx.el" "calc/calc-nlfit.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-units.el" "calc/calc-vec.el" "calc/calc-yank.el"
+;;;;;; "calc/calcalg2.el" "calc/calcalg3.el" "calc/calccomp.el"
+;;;;;; "calc/calcsel2.el" "calendar/cal-bahai.el" "calendar/cal-coptic.el"
+;;;;;; "calendar/cal-french.el" "calendar/cal-html.el" "calendar/cal-islam.el"
+;;;;;; "calendar/cal-iso.el" "calendar/cal-julian.el" "calendar/cal-loaddefs.el"
+;;;;;; "calendar/cal-mayan.el" "calendar/cal-menu.el" "calendar/cal-move.el"
+;;;;;; "calendar/cal-persia.el" "calendar/cal-tex.el" "calendar/cal-x.el"
+;;;;;; "calendar/diary-loaddefs.el" "calendar/hol-loaddefs.el" "cdl.el"
+;;;;;; "cedet/cedet-cscope.el" "cedet/cedet-files.el" "cedet/cedet-global.el"
+;;;;;; "cedet/cedet-idutils.el" "cedet/ede/auto.el" "cedet/ede/autoconf-edit.el"
+;;;;;; "cedet/ede/base.el" "cedet/ede/config.el" "cedet/ede/cpp-root.el"
+;;;;;; "cedet/ede/custom.el" "cedet/ede/detect.el" "cedet/ede/dired.el"
+;;;;;; "cedet/ede/emacs.el" "cedet/ede/files.el" "cedet/ede/generic.el"
+;;;;;; "cedet/ede/linux.el" "cedet/ede/loaddefs.el" "cedet/ede/locate.el"
+;;;;;; "cedet/ede/make.el" "cedet/ede/makefile-edit.el" "cedet/ede/pconf.el"
+;;;;;; "cedet/ede/pmake.el" "cedet/ede/proj-archive.el" "cedet/ede/proj-aux.el"
+;;;;;; "cedet/ede/proj-comp.el" "cedet/ede/proj-elisp.el" "cedet/ede/proj-info.el"
+;;;;;; "cedet/ede/proj-misc.el" "cedet/ede/proj-obj.el" "cedet/ede/proj-prog.el"
+;;;;;; "cedet/ede/proj-scheme.el" "cedet/ede/proj-shared.el" "cedet/ede/proj.el"
+;;;;;; "cedet/ede/project-am.el" "cedet/ede/shell.el" "cedet/ede/simple.el"
;;;;;; "cedet/ede/source.el" "cedet/ede/speedbar.el" "cedet/ede/srecode.el"
;;;;;; "cedet/ede/system.el" "cedet/ede/util.el" "cedet/semantic/analyze.el"
;;;;;; "cedet/semantic/analyze/complete.el" "cedet/semantic/analyze/debug.el"
;;;;;; "cedet/semantic/fw.el" "cedet/semantic/grammar-wy.el" "cedet/semantic/grammar.el"
;;;;;; "cedet/semantic/html.el" "cedet/semantic/ia-sb.el" "cedet/semantic/ia.el"
;;;;;; "cedet/semantic/idle.el" "cedet/semantic/imenu.el" "cedet/semantic/java.el"
-;;;;;; "cedet/semantic/lex-spp.el" "cedet/semantic/lex.el" "cedet/semantic/mru-bookmark.el"
-;;;;;; "cedet/semantic/sb.el" "cedet/semantic/scope.el" "cedet/semantic/senator.el"
-;;;;;; "cedet/semantic/sort.el" "cedet/semantic/symref.el" "cedet/semantic/symref/cscope.el"
-;;;;;; "cedet/semantic/symref/filter.el" "cedet/semantic/symref/global.el"
-;;;;;; "cedet/semantic/symref/grep.el" "cedet/semantic/symref/idutils.el"
-;;;;;; "cedet/semantic/symref/list.el" "cedet/semantic/tag-file.el"
-;;;;;; "cedet/semantic/tag-ls.el" "cedet/semantic/tag-write.el"
+;;;;;; "cedet/semantic/lex-spp.el" "cedet/semantic/lex.el" "cedet/semantic/loaddefs.el"
+;;;;;; "cedet/semantic/mru-bookmark.el" "cedet/semantic/sb.el" "cedet/semantic/scope.el"
+;;;;;; "cedet/semantic/senator.el" "cedet/semantic/sort.el" "cedet/semantic/symref.el"
+;;;;;; "cedet/semantic/symref/cscope.el" "cedet/semantic/symref/filter.el"
+;;;;;; "cedet/semantic/symref/global.el" "cedet/semantic/symref/grep.el"
+;;;;;; "cedet/semantic/symref/idutils.el" "cedet/semantic/symref/list.el"
+;;;;;; "cedet/semantic/tag-file.el" "cedet/semantic/tag-ls.el" "cedet/semantic/tag-write.el"
;;;;;; "cedet/semantic/tag.el" "cedet/semantic/texi.el" "cedet/semantic/util-modes.el"
;;;;;; "cedet/semantic/util.el" "cedet/semantic/wisent.el" "cedet/semantic/wisent/comp.el"
;;;;;; "cedet/semantic/wisent/java-tags.el" "cedet/semantic/wisent/javascript.el"
;;;;;; "cedet/srecode/el.el" "cedet/srecode/expandproto.el" "cedet/srecode/extract.el"
;;;;;; "cedet/srecode/fields.el" "cedet/srecode/filters.el" "cedet/srecode/find.el"
;;;;;; "cedet/srecode/getset.el" "cedet/srecode/insert.el" "cedet/srecode/java.el"
-;;;;;; "cedet/srecode/map.el" "cedet/srecode/mode.el" "cedet/srecode/semantic.el"
-;;;;;; "cedet/srecode/srt.el" "cedet/srecode/table.el" "cedet/srecode/template.el"
-;;;;;; "cedet/srecode/texi.el" "cus-dep.el" "dframe.el" "dired-aux.el"
-;;;;;; "dired-x.el" "dos-fns.el" "dos-vars.el" "dos-w32.el" "dynamic-setting.el"
-;;;;;; "emacs-lisp/authors.el" "emacs-lisp/avl-tree.el" "emacs-lisp/bindat.el"
-;;;;;; "emacs-lisp/byte-opt.el" "emacs-lisp/cl-extra.el" "emacs-lisp/cl-macs.el"
+;;;;;; "cedet/srecode/loaddefs.el" "cedet/srecode/map.el" "cedet/srecode/mode.el"
+;;;;;; "cedet/srecode/semantic.el" "cedet/srecode/srt.el" "cedet/srecode/table.el"
+;;;;;; "cedet/srecode/template.el" "cedet/srecode/texi.el" "cus-dep.el"
+;;;;;; "dframe.el" "dired-aux.el" "dired-loaddefs.el" "dired-x.el"
+;;;;;; "dom.el" "dos-fns.el" "dos-vars.el" "dos-w32.el" "dynamic-setting.el"
+;;;;;; "emacs-lisp/avl-tree.el" "emacs-lisp/bindat.el" "emacs-lisp/byte-opt.el"
+;;;;;; "emacs-lisp/cl-extra.el" "emacs-lisp/cl-loaddefs.el" "emacs-lisp/cl-macs.el"
;;;;;; "emacs-lisp/cl-seq.el" "emacs-lisp/cl.el" "emacs-lisp/eieio-base.el"
-;;;;;; "emacs-lisp/eieio-datadebug.el" "emacs-lisp/eieio-speedbar.el"
-;;;;;; "emacs-lisp/find-gc.el" "emacs-lisp/gulp.el" "emacs-lisp/helpers.el"
-;;;;;; "emacs-lisp/lisp-mnt.el" "emacs-lisp/package-x.el" "emacs-lisp/smie.el"
-;;;;;; "emacs-lisp/tcover-ses.el" "emacs-lisp/tcover-unsafep.el"
-;;;;;; "emulation/cua-gmrk.el" "emulation/cua-rect.el" "emulation/edt-lk201.el"
+;;;;;; "emacs-lisp/eieio-compat.el" "emacs-lisp/eieio-custom.el"
+;;;;;; "emacs-lisp/eieio-datadebug.el" "emacs-lisp/eieio-loaddefs.el"
+;;;;;; "emacs-lisp/eieio-opt.el" "emacs-lisp/eieio-speedbar.el"
+;;;;;; "emacs-lisp/generator.el" "emacs-lisp/lisp-mnt.el" "emacs-lisp/package-x.el"
+;;;;;; "emacs-lisp/smie.el" "emacs-lisp/subr-x.el" "emacs-lisp/tcover-ses.el"
+;;;;;; "emacs-lisp/tcover-unsafep.el" "emulation/cua-gmrk.el" "emulation/edt-lk201.el"
;;;;;; "emulation/edt-mapper.el" "emulation/edt-pc.el" "emulation/edt-vt100.el"
-;;;;;; "emulation/tpu-extras.el" "emulation/viper-cmd.el" "emulation/viper-ex.el"
-;;;;;; "emulation/viper-init.el" "emulation/viper-keym.el" "emulation/viper-macs.el"
-;;;;;; "emulation/viper-mous.el" "emulation/viper-util.el" "erc/erc-backend.el"
-;;;;;; "erc/erc-goodies.el" "erc/erc-ibuffer.el" "eshell/em-alias.el"
+;;;;;; "emulation/viper-cmd.el" "emulation/viper-ex.el" "emulation/viper-init.el"
+;;;;;; "emulation/viper-keym.el" "emulation/viper-macs.el" "emulation/viper-mous.el"
+;;;;;; "emulation/viper-util.el" "erc/erc-backend.el" "erc/erc-goodies.el"
+;;;;;; "erc/erc-ibuffer.el" "erc/erc-lang.el" "eshell/em-alias.el"
;;;;;; "eshell/em-banner.el" "eshell/em-basic.el" "eshell/em-cmpl.el"
;;;;;; "eshell/em-dirs.el" "eshell/em-glob.el" "eshell/em-hist.el"
;;;;;; "eshell/em-ls.el" "eshell/em-pred.el" "eshell/em-prompt.el"
;;;;;; "eshell/em-rebind.el" "eshell/em-script.el" "eshell/em-smart.el"
;;;;;; "eshell/em-term.el" "eshell/em-tramp.el" "eshell/em-unix.el"
;;;;;; "eshell/em-xtra.el" "eshell/esh-arg.el" "eshell/esh-cmd.el"
-;;;;;; "eshell/esh-ext.el" "eshell/esh-io.el" "eshell/esh-module.el"
-;;;;;; "eshell/esh-opt.el" "eshell/esh-proc.el" "eshell/esh-util.el"
-;;;;;; "eshell/esh-var.el" "ezimage.el" "format-spec.el" "fringe.el"
-;;;;;; "generic-x.el" "gnus/compface.el" "gnus/gnus-async.el" "gnus/gnus-bcklg.el"
-;;;;;; "gnus/gnus-cite.el" "gnus/gnus-cus.el" "gnus/gnus-demon.el"
-;;;;;; "gnus/gnus-dup.el" "gnus/gnus-eform.el" "gnus/gnus-ems.el"
-;;;;;; "gnus/gnus-icalendar.el" "gnus/gnus-int.el" "gnus/gnus-logic.el"
-;;;;;; "gnus/gnus-mh.el" "gnus/gnus-salt.el" "gnus/gnus-score.el"
-;;;;;; "gnus/gnus-setup.el" "gnus/gnus-srvr.el" "gnus/gnus-topic.el"
-;;;;;; "gnus/gnus-undo.el" "gnus/gnus-util.el" "gnus/gnus-uu.el"
-;;;;;; "gnus/gnus-vm.el" "gnus/gssapi.el" "gnus/ietf-drums.el" "gnus/legacy-gnus-agent.el"
-;;;;;; "gnus/mail-parse.el" "gnus/mail-prsvr.el" "gnus/mail-source.el"
-;;;;;; "gnus/mailcap.el" "gnus/messcompat.el" "gnus/mm-archive.el"
-;;;;;; "gnus/mm-bodies.el" "gnus/mm-decode.el" "gnus/mm-util.el"
-;;;;;; "gnus/mm-view.el" "gnus/mml-sec.el" "gnus/mml-smime.el" "gnus/nnagent.el"
-;;;;;; "gnus/nnbabyl.el" "gnus/nndir.el" "gnus/nndraft.el" "gnus/nneething.el"
-;;;;;; "gnus/nngateway.el" "gnus/nnheader.el" "gnus/nnimap.el" "gnus/nnir.el"
-;;;;;; "gnus/nnmail.el" "gnus/nnmaildir.el" "gnus/nnmbox.el" "gnus/nnmh.el"
-;;;;;; "gnus/nnnil.el" "gnus/nnoo.el" "gnus/nnregistry.el" "gnus/nnrss.el"
-;;;;;; "gnus/nnspool.el" "gnus/nntp.el" "gnus/nnvirtual.el" "gnus/nnweb.el"
-;;;;;; "gnus/registry.el" "gnus/rfc1843.el" "gnus/rfc2045.el" "gnus/rfc2047.el"
-;;;;;; "gnus/rfc2104.el" "gnus/rfc2231.el" "gnus/rtree.el" "gnus/sieve-manage.el"
-;;;;;; "gnus/smime.el" "gnus/spam-stat.el" "gnus/spam-wash.el" "hex-util.el"
-;;;;;; "hfy-cmap.el" "ibuf-ext.el" "international/cp51932.el" "international/eucjp-ms.el"
-;;;;;; "international/fontset.el" "international/iso-ascii.el" "international/ja-dic-cnv.el"
+;;;;;; "eshell/esh-ext.el" "eshell/esh-groups.el" "eshell/esh-io.el"
+;;;;;; "eshell/esh-module.el" "eshell/esh-opt.el" "eshell/esh-proc.el"
+;;;;;; "eshell/esh-util.el" "eshell/esh-var.el" "ezimage.el" "format-spec.el"
+;;;;;; "fringe.el" "generic-x.el" "gnus/compface.el" "gnus/gnus-async.el"
+;;;;;; "gnus/gnus-bcklg.el" "gnus/gnus-cite.el" "gnus/gnus-cloud.el"
+;;;;;; "gnus/gnus-cus.el" "gnus/gnus-demon.el" "gnus/gnus-dup.el"
+;;;;;; "gnus/gnus-eform.el" "gnus/gnus-ems.el" "gnus/gnus-icalendar.el"
+;;;;;; "gnus/gnus-int.el" "gnus/gnus-logic.el" "gnus/gnus-mh.el"
+;;;;;; "gnus/gnus-salt.el" "gnus/gnus-score.el" "gnus/gnus-srvr.el"
+;;;;;; "gnus/gnus-topic.el" "gnus/gnus-undo.el" "gnus/gnus-util.el"
+;;;;;; "gnus/gnus-uu.el" "gnus/gnus-vm.el" "gnus/gssapi.el" "gnus/ietf-drums.el"
+;;;;;; "gnus/legacy-gnus-agent.el" "gnus/mail-parse.el" "gnus/mail-prsvr.el"
+;;;;;; "gnus/mail-source.el" "gnus/mailcap.el" "gnus/messcompat.el"
+;;;;;; "gnus/mm-archive.el" "gnus/mm-bodies.el" "gnus/mm-decode.el"
+;;;;;; "gnus/mm-util.el" "gnus/mm-view.el" "gnus/mml-sec.el" "gnus/mml-smime.el"
+;;;;;; "gnus/nnagent.el" "gnus/nnbabyl.el" "gnus/nndir.el" "gnus/nndraft.el"
+;;;;;; "gnus/nneething.el" "gnus/nngateway.el" "gnus/nnheader.el"
+;;;;;; "gnus/nnimap.el" "gnus/nnir.el" "gnus/nnmail.el" "gnus/nnmaildir.el"
+;;;;;; "gnus/nnmairix.el" "gnus/nnmbox.el" "gnus/nnmh.el" "gnus/nnnil.el"
+;;;;;; "gnus/nnoo.el" "gnus/nnregistry.el" "gnus/nnrss.el" "gnus/nnspool.el"
+;;;;;; "gnus/nntp.el" "gnus/nnvirtual.el" "gnus/nnweb.el" "gnus/registry.el"
+;;;;;; "gnus/rfc1843.el" "gnus/rfc2045.el" "gnus/rfc2047.el" "gnus/rfc2231.el"
+;;;;;; "gnus/rtree.el" "gnus/sieve-manage.el" "gnus/smime.el" "gnus/spam-stat.el"
+;;;;;; "gnus/spam-wash.el" "hex-util.el" "hfy-cmap.el" "ibuf-ext.el"
+;;;;;; "international/charscript.el" "international/fontset.el"
+;;;;;; "international/iso-ascii.el" "international/ja-dic-cnv.el"
;;;;;; "international/ja-dic-utl.el" "international/ogonek.el" "kermit.el"
;;;;;; "language/hanja-util.el" "language/thai-word.el" "ldefs-boot.el"
;;;;;; "leim/quail/arabic.el" "leim/quail/croatian.el" "leim/quail/cyril-jis.el"
;;;;;; "leim/quail/lrt.el" "leim/quail/persian.el" "leim/quail/py-punct.el"
;;;;;; "leim/quail/pypunct-b5.el" "leim/quail/rfc1345.el" "leim/quail/sgml-input.el"
;;;;;; "leim/quail/sisheng.el" "leim/quail/slovak.el" "leim/quail/symbol-ksc.el"
-;;;;;; "leim/quail/thai.el" "leim/quail/tibetan.el" "leim/quail/viqr.el"
-;;;;;; "leim/quail/vntelex.el" "leim/quail/vnvni.el" "leim/quail/welsh.el"
-;;;;;; "loadup.el" "mail/blessmail.el" "mail/mailheader.el" "mail/mspools.el"
-;;;;;; "mail/rfc2368.el" "mail/rfc822.el" "mail/rmail-spam-filter.el"
-;;;;;; "mail/rmailedit.el" "mail/rmailkwd.el" "mail/rmailmm.el"
-;;;;;; "mail/rmailmsc.el" "mail/rmailsort.el" "mail/rmailsum.el"
-;;;;;; "mail/undigest.el" "mh-e/mh-acros.el" "mh-e/mh-alias.el"
-;;;;;; "mh-e/mh-buffers.el" "mh-e/mh-compat.el" "mh-e/mh-funcs.el"
-;;;;;; "mh-e/mh-gnus.el" "mh-e/mh-identity.el" "mh-e/mh-inc.el"
-;;;;;; "mh-e/mh-junk.el" "mh-e/mh-letter.el" "mh-e/mh-limit.el"
+;;;;;; "leim/quail/tamil-dvorak.el" "leim/quail/thai.el" "leim/quail/tibetan.el"
+;;;;;; "leim/quail/viqr.el" "leim/quail/vntelex.el" "leim/quail/vnvni.el"
+;;;;;; "leim/quail/welsh.el" "loadup.el" "mail/blessmail.el" "mail/mailheader.el"
+;;;;;; "mail/mspools.el" "mail/rfc2368.el" "mail/rfc822.el" "mail/rmail-loaddefs.el"
+;;;;;; "mail/rmail-spam-filter.el" "mail/rmailedit.el" "mail/rmailkwd.el"
+;;;;;; "mail/rmailmm.el" "mail/rmailmsc.el" "mail/rmailsort.el"
+;;;;;; "mail/rmailsum.el" "mail/undigest.el" "mh-e/mh-acros.el"
+;;;;;; "mh-e/mh-alias.el" "mh-e/mh-buffers.el" "mh-e/mh-compat.el"
+;;;;;; "mh-e/mh-funcs.el" "mh-e/mh-gnus.el" "mh-e/mh-identity.el"
+;;;;;; "mh-e/mh-inc.el" "mh-e/mh-junk.el" "mh-e/mh-letter.el" "mh-e/mh-limit.el"
;;;;;; "mh-e/mh-loaddefs.el" "mh-e/mh-mime.el" "mh-e/mh-print.el"
;;;;;; "mh-e/mh-scan.el" "mh-e/mh-search.el" "mh-e/mh-seq.el" "mh-e/mh-show.el"
;;;;;; "mh-e/mh-speed.el" "mh-e/mh-thread.el" "mh-e/mh-tool-bar.el"
-;;;;;; "mh-e/mh-utils.el" "mh-e/mh-xface.el" "mouse-copy.el" "mouse.el"
-;;;;;; "mwheel.el" "net/dns.el" "net/eudc-vars.el" "net/eudcb-bbdb.el"
-;;;;;; "net/eudcb-ldap.el" "net/eudcb-mab.el" "net/eudcb-ph.el"
-;;;;;; "net/hmac-def.el" "net/hmac-md5.el" "net/imap.el" "net/ldap.el"
-;;;;;; "net/mairix.el" "net/sasl-cram.el" "net/sasl-digest.el" "net/sasl.el"
-;;;;;; "net/shr-color.el" "net/soap-client.el" "net/soap-inspect.el"
-;;;;;; "net/socks.el" "net/tls.el" "net/tramp-adb.el" "net/tramp-cache.el"
-;;;;;; "net/tramp-cmds.el" "net/tramp-compat.el" "net/tramp-gvfs.el"
-;;;;;; "net/tramp-gw.el" "net/tramp-loaddefs.el" "net/tramp-sh.el"
-;;;;;; "net/tramp-smb.el" "net/tramp-uu.el" "net/trampver.el" "net/zeroconf.el"
-;;;;;; "notifications.el" "nxml/nxml-enc.el" "nxml/nxml-maint.el"
+;;;;;; "mh-e/mh-utils.el" "mh-e/mh-xface.el" "mouse-copy.el" "mwheel.el"
+;;;;;; "net/dns.el" "net/eudc-vars.el" "net/eudcb-bbdb.el" "net/eudcb-ldap.el"
+;;;;;; "net/eudcb-mab.el" "net/eudcb-ph.el" "net/hmac-def.el" "net/hmac-md5.el"
+;;;;;; "net/imap.el" "net/ldap.el" "net/mairix.el" "net/newsticker.el"
+;;;;;; "net/nsm.el" "net/rfc2104.el" "net/sasl-cram.el" "net/sasl-digest.el"
+;;;;;; "net/sasl-scram-rfc.el" "net/sasl.el" "net/shr-color.el"
+;;;;;; "net/soap-inspect.el" "net/socks.el" "net/tls.el" "net/tramp-adb.el"
+;;;;;; "net/tramp-cache.el" "net/tramp-cmds.el" "net/tramp-compat.el"
+;;;;;; "net/tramp-gvfs.el" "net/tramp-gw.el" "net/tramp-loaddefs.el"
+;;;;;; "net/tramp-sh.el" "net/tramp-smb.el" "net/tramp-uu.el" "net/trampver.el"
+;;;;;; "net/zeroconf.el" "notifications.el" "nxml/nxml-enc.el" "nxml/nxml-maint.el"
;;;;;; "nxml/nxml-ns.el" "nxml/nxml-outln.el" "nxml/nxml-parse.el"
;;;;;; "nxml/nxml-rap.el" "nxml/nxml-util.el" "nxml/rng-dt.el" "nxml/rng-loc.el"
;;;;;; "nxml/rng-maint.el" "nxml/rng-match.el" "nxml/rng-parse.el"
;;;;;; "nxml/rng-pttrn.el" "nxml/rng-uri.el" "nxml/rng-util.el"
-;;;;;; "nxml/xsd-regexp.el" "org/ob-C.el" "org/ob-R.el" "org/ob-asymptote.el"
-;;;;;; "org/ob-awk.el" "org/ob-calc.el" "org/ob-clojure.el" "org/ob-comint.el"
-;;;;;; "org/ob-core.el" "org/ob-css.el" "org/ob-ditaa.el" "org/ob-dot.el"
-;;;;;; "org/ob-emacs-lisp.el" "org/ob-eval.el" "org/ob-exp.el" "org/ob-fortran.el"
-;;;;;; "org/ob-gnuplot.el" "org/ob-haskell.el" "org/ob-io.el" "org/ob-java.el"
-;;;;;; "org/ob-js.el" "org/ob-keys.el" "org/ob-latex.el" "org/ob-ledger.el"
-;;;;;; "org/ob-lilypond.el" "org/ob-lisp.el" "org/ob-lob.el" "org/ob-makefile.el"
-;;;;;; "org/ob-matlab.el" "org/ob-maxima.el" "org/ob-mscgen.el"
-;;;;;; "org/ob-ocaml.el" "org/ob-octave.el" "org/ob-org.el" "org/ob-perl.el"
-;;;;;; "org/ob-picolisp.el" "org/ob-plantuml.el" "org/ob-python.el"
-;;;;;; "org/ob-ref.el" "org/ob-ruby.el" "org/ob-sass.el" "org/ob-scala.el"
-;;;;;; "org/ob-scheme.el" "org/ob-screen.el" "org/ob-sh.el" "org/ob-shen.el"
-;;;;;; "org/ob-sql.el" "org/ob-sqlite.el" "org/ob-table.el" "org/ob-tangle.el"
-;;;;;; "org/ob.el" "org/org-archive.el" "org/org-attach.el" "org/org-bbdb.el"
-;;;;;; "org/org-bibtex.el" "org/org-clock.el" "org/org-crypt.el"
-;;;;;; "org/org-ctags.el" "org/org-datetree.el" "org/org-docview.el"
-;;;;;; "org/org-element.el" "org/org-entities.el" "org/org-eshell.el"
-;;;;;; "org/org-faces.el" "org/org-feed.el" "org/org-footnote.el"
-;;;;;; "org/org-gnus.el" "org/org-habit.el" "org/org-id.el" "org/org-indent.el"
-;;;;;; "org/org-info.el" "org/org-inlinetask.el" "org/org-install.el"
-;;;;;; "org/org-irc.el" "org/org-list.el" "org/org-macro.el" "org/org-mhe.el"
-;;;;;; "org/org-mobile.el" "org/org-mouse.el" "org/org-pcomplete.el"
-;;;;;; "org/org-plot.el" "org/org-protocol.el" "org/org-rmail.el"
-;;;;;; "org/org-src.el" "org/org-table.el" "org/org-timer.el" "org/org-w3m.el"
-;;;;;; "org/ox-ascii.el" "org/ox-beamer.el" "org/ox-html.el" "org/ox-icalendar.el"
-;;;;;; "org/ox-latex.el" "org/ox-man.el" "org/ox-md.el" "org/ox-odt.el"
-;;;;;; "org/ox-org.el" "org/ox-publish.el" "org/ox-texinfo.el" "org/ox.el"
-;;;;;; "play/gametree.el" "play/meese.el" "progmodes/ada-prj.el"
-;;;;;; "progmodes/cc-align.el" "progmodes/cc-awk.el" "progmodes/cc-bytecomp.el"
-;;;;;; "progmodes/cc-cmds.el" "progmodes/cc-defs.el" "progmodes/cc-fonts.el"
-;;;;;; "progmodes/cc-langs.el" "progmodes/cc-menus.el" "progmodes/ebnf-abn.el"
-;;;;;; "progmodes/ebnf-bnf.el" "progmodes/ebnf-dtd.el" "progmodes/ebnf-ebx.el"
-;;;;;; "progmodes/ebnf-iso.el" "progmodes/ebnf-otz.el" "progmodes/ebnf-yac.el"
-;;;;;; "progmodes/idlw-complete-structtag.el" "progmodes/idlw-help.el"
-;;;;;; "progmodes/idlw-toolbar.el" "progmodes/mantemp.el" "progmodes/xscheme.el"
-;;;;;; "ps-def.el" "ps-mule.el" "ps-samp.el" "saveplace.el" "sb-image.el"
-;;;;;; "scroll-bar.el" "select.el" "soundex.el" "subdirs.el" "tempo.el"
+;;;;;; "nxml/xsd-regexp.el" "obarray.el" "org/ob-C.el" "org/ob-R.el"
+;;;;;; "org/ob-asymptote.el" "org/ob-awk.el" "org/ob-calc.el" "org/ob-clojure.el"
+;;;;;; "org/ob-comint.el" "org/ob-core.el" "org/ob-css.el" "org/ob-ditaa.el"
+;;;;;; "org/ob-dot.el" "org/ob-emacs-lisp.el" "org/ob-eval.el" "org/ob-exp.el"
+;;;;;; "org/ob-fortran.el" "org/ob-gnuplot.el" "org/ob-haskell.el"
+;;;;;; "org/ob-io.el" "org/ob-java.el" "org/ob-js.el" "org/ob-keys.el"
+;;;;;; "org/ob-latex.el" "org/ob-ledger.el" "org/ob-lilypond.el"
+;;;;;; "org/ob-lisp.el" "org/ob-lob.el" "org/ob-makefile.el" "org/ob-matlab.el"
+;;;;;; "org/ob-maxima.el" "org/ob-mscgen.el" "org/ob-ocaml.el" "org/ob-octave.el"
+;;;;;; "org/ob-org.el" "org/ob-perl.el" "org/ob-picolisp.el" "org/ob-plantuml.el"
+;;;;;; "org/ob-python.el" "org/ob-ref.el" "org/ob-ruby.el" "org/ob-sass.el"
+;;;;;; "org/ob-scala.el" "org/ob-scheme.el" "org/ob-screen.el" "org/ob-sh.el"
+;;;;;; "org/ob-shen.el" "org/ob-sql.el" "org/ob-sqlite.el" "org/ob-table.el"
+;;;;;; "org/ob-tangle.el" "org/ob.el" "org/org-archive.el" "org/org-attach.el"
+;;;;;; "org/org-bbdb.el" "org/org-bibtex.el" "org/org-clock.el"
+;;;;;; "org/org-crypt.el" "org/org-ctags.el" "org/org-datetree.el"
+;;;;;; "org/org-docview.el" "org/org-element.el" "org/org-entities.el"
+;;;;;; "org/org-eshell.el" "org/org-faces.el" "org/org-feed.el"
+;;;;;; "org/org-footnote.el" "org/org-gnus.el" "org/org-habit.el"
+;;;;;; "org/org-id.el" "org/org-indent.el" "org/org-info.el" "org/org-inlinetask.el"
+;;;;;; "org/org-install.el" "org/org-irc.el" "org/org-list.el" "org/org-loaddefs.el"
+;;;;;; "org/org-macro.el" "org/org-mhe.el" "org/org-mobile.el" "org/org-mouse.el"
+;;;;;; "org/org-pcomplete.el" "org/org-plot.el" "org/org-protocol.el"
+;;;;;; "org/org-rmail.el" "org/org-src.el" "org/org-table.el" "org/org-timer.el"
+;;;;;; "org/org-w3m.el" "org/ox-ascii.el" "org/ox-beamer.el" "org/ox-html.el"
+;;;;;; "org/ox-icalendar.el" "org/ox-latex.el" "org/ox-man.el" "org/ox-md.el"
+;;;;;; "org/ox-odt.el" "org/ox-org.el" "org/ox-publish.el" "org/ox-texinfo.el"
+;;;;;; "org/ox.el" "play/gametree.el" "progmodes/ada-prj.el" "progmodes/cc-align.el"
+;;;;;; "progmodes/cc-awk.el" "progmodes/cc-bytecomp.el" "progmodes/cc-cmds.el"
+;;;;;; "progmodes/cc-defs.el" "progmodes/cc-fonts.el" "progmodes/cc-langs.el"
+;;;;;; "progmodes/cc-menus.el" "progmodes/ebnf-abn.el" "progmodes/ebnf-bnf.el"
+;;;;;; "progmodes/ebnf-dtd.el" "progmodes/ebnf-ebx.el" "progmodes/ebnf-iso.el"
+;;;;;; "progmodes/ebnf-otz.el" "progmodes/ebnf-yac.el" "progmodes/idlw-complete-structtag.el"
+;;;;;; "progmodes/idlw-help.el" "progmodes/idlw-toolbar.el" "progmodes/mantemp.el"
+;;;;;; "progmodes/xscheme.el" "ps-def.el" "ps-mule.el" "ps-samp.el"
+;;;;;; "sb-image.el" "scroll-bar.el" "soundex.el" "subdirs.el" "tempo.el"
;;;;;; "textmodes/bib-mode.el" "textmodes/makeinfo.el" "textmodes/page-ext.el"
;;;;;; "textmodes/refbib.el" "textmodes/refer.el" "textmodes/reftex-auc.el"
-;;;;;; "textmodes/reftex-dcr.el" "textmodes/reftex-ref.el" "textmodes/reftex-sel.el"
-;;;;;; "textmodes/reftex-toc.el" "textmodes/texnfo-upd.el" "timezone.el"
-;;;;;; "tooltip.el" "tree-widget.el" "url/url-about.el" "url/url-cookie.el"
-;;;;;; "url/url-dired.el" "url/url-domsuf.el" "url/url-expand.el"
-;;;;;; "url/url-ftp.el" "url/url-future.el" "url/url-history.el"
-;;;;;; "url/url-imap.el" "url/url-methods.el" "url/url-nfs.el" "url/url-proxy.el"
-;;;;;; "url/url-vars.el" "vc/ediff-diff.el" "vc/ediff-init.el" "vc/ediff-merg.el"
-;;;;;; "vc/ediff-ptch.el" "vc/ediff-vers.el" "vc/ediff-wind.el"
-;;;;;; "vc/pcvs-info.el" "vc/pcvs-parse.el" "vc/pcvs-util.el" "vc/vc-dav.el"
-;;;;;; "vcursor.el" "vt-control.el" "vt100-led.el" "w32-common-fns.el"
-;;;;;; "w32-fns.el" "w32-vars.el" "x-dnd.el") (21147 7118 261519
-;;;;;; 169000))
+;;;;;; "textmodes/reftex-cite.el" "textmodes/reftex-dcr.el" "textmodes/reftex-global.el"
+;;;;;; "textmodes/reftex-index.el" "textmodes/reftex-parse.el" "textmodes/reftex-ref.el"
+;;;;;; "textmodes/reftex-sel.el" "textmodes/reftex-toc.el" "textmodes/texnfo-upd.el"
+;;;;;; "timezone.el" "tooltip.el" "tree-widget.el" "url/url-about.el"
+;;;;;; "url/url-cookie.el" "url/url-dired.el" "url/url-domsuf.el"
+;;;;;; "url/url-expand.el" "url/url-ftp.el" "url/url-future.el"
+;;;;;; "url/url-history.el" "url/url-imap.el" "url/url-methods.el"
+;;;;;; "url/url-nfs.el" "url/url-proxy.el" "url/url-vars.el" "vc/ediff-diff.el"
+;;;;;; "vc/ediff-init.el" "vc/ediff-merg.el" "vc/ediff-ptch.el"
+;;;;;; "vc/ediff-vers.el" "vc/ediff-wind.el" "vc/pcvs-info.el" "vc/pcvs-parse.el"
+;;;;;; "vc/pcvs-util.el" "vc/vc-dav.el" "vc/vc-filewise.el" "vcursor.el"
+;;;;;; "vt-control.el" "vt100-led.el" "w32-fns.el" "w32-vars.el"
+;;;;;; "x-dnd.el") (22108 15942 558032 987000))
;;;***
\f