Mercurial > emacs
changeset 28710:6efaa4627dee
*** empty log message ***
| author | Gerd Moellmann <gerd@gnu.org> |
|---|---|
| date | Tue, 25 Apr 2000 19:43:58 +0000 |
| parents | 7606937fa891 |
| children | 039f763895c3 |
| files | etc/NEWS lisp/ChangeLog lisp/emacs-lisp/crm.el lisp/loaddefs.el src/ChangeLog |
| diffstat | 5 files changed, 742 insertions(+), 38 deletions(-) [+] |
line wrap: on
line diff
--- a/etc/NEWS Tue Apr 25 19:41:30 2000 +0000 +++ b/etc/NEWS Tue Apr 25 19:43:58 2000 +0000 @@ -1126,7 +1126,10 @@ *** autoconf.el provides a major mode for editing configure.in files for Autoconf, selected automatically. -*** windmove.el +*** windmove.el provides moving between windows. + +*** crm.el provides a facility to read multiple strings from the +minibuffer with completion. ** Withdrawn packages @@ -1144,6 +1147,16 @@ When you add a new item, please add it without either +++ or --- so I will know I still need to look at it -- rms. +** The function `shell-command' now sets the default directory of the +`*Shell Command Output*' buffer to the default directory of the buffer +from which the command was issued. + +** The functions `query-replace', `query-replace-regexp', +`query-replace-regexp-eval' `map-query-replace-regexp', +`replace-string', `replace-regexp', and `perform-replace' take two +additional optional arguments START and END that specify the region to +operate on. + ** The new function `count-screen-lines' is a more flexible alternative to `window-buffer-height'.
--- a/lisp/ChangeLog Tue Apr 25 19:41:30 2000 +0000 +++ b/lisp/ChangeLog Tue Apr 25 19:43:58 2000 +0000 @@ -1,3 +1,28 @@ +2000-04-25 Gerd Moellmann <gerd@gnu.org> + + * replace.el (perform-replace): Add parameters START and END. Use + them instead of the check for a region in Transient Mark mode. + (query-replace-read-args): Return two more list elements for the + start and end of the region in Transient Mark mode. + (query-replace, query-replace-regexp, query-replace-regexp-eval) + (map-query-replace-regexp, replace-string, replace-regexp): Add + optional last arguments START and END and pass them to + perform-replace. + + * progmodes/ebrowse.el (ebrowse-tags-query-replace): Construct a + form with additional arguments for perform-replace. + + * progmodes/etags.el (tags-query-replace): Add parameters START + and END. Construct a form with additional arguments for + perform-replace. + + * simple.el (shell-command): Set default directory for "*Shell + Command Output" buffer. + + * language/european.el (iso-latin-4): Fix typo. + + * emacs-lisp/crm.el: New file. + 2000-04-24 Dave Love <fx@gnu.org> * cus-edit.el (Custom-set, Custom-save, Custom-reset-current)
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lisp/emacs-lisp/crm.el Tue Apr 25 19:43:58 2000 +0000 @@ -0,0 +1,629 @@ +;;; crm.el --- read multiple strings with completion + +;; Copyright (C) 1985, 1986, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000 +;; Free Software Foundation, Inc. + +;; Author: Sen Nagata <sen@eccosys.com> +;; Keywords: completion, minibuffer, multiple elements + +;; This file is part of GNU Emacs. + +;; GNU Emacs is free software; you can redistribute it and/or modify +;; it under the terms of the GNU General Public License as published by +;; the Free Software Foundation; either version 2, or (at your option) +;; any later version. + +;; GNU Emacs is distributed in the hope that it will be useful, +;; but WITHOUT ANY WARRANTY; without even the implied warranty of +;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +;; GNU General Public License for more details. + +;; You should have received a copy of the GNU General Public License +;; along with GNU Emacs; see the file COPYING. If not, write to the +;; Free Software Foundation, Inc., 59 Temple Place - Suite 330, +;; Boston, MA 02111-1307, USA. + +;;; Commentary: + +;; This code defines a function, `completing-read-multiple', which +;; provides the ability to read multiple strings in the minibuffer, +;; with completion. + +;; By using this functionality, a user may specify multiple strings at +;; a single prompt, optionally using completion. + +;; Multiple strings are specified by separating each of the strings +;; with a prespecified separator character. For example, if the +;; separator character is a comma, the strings 'alice', 'bob', and +;; 'eve' would be specified as 'alice,bob,eve'. + +;; The default value for the separator character is the value of +;; `crm-default-separator' (comma). The separator character may be +;; changed by modifying the value of `crm-separator'. + +;; Continguous strings of non-separator-characters are referred to as +;; 'elements'. In the aforementioned example, the elements are: +;; 'alice', 'bob', and 'eve'. + +;; Completion is available on a per-element basis. For example, if +;; the contents of the minibuffer are 'alice,bob,eve' and point is +;; between 'l' and 'i', pressing TAB operates on the element 'alice'. + +;; For the moment, I have decided to not bind any special behavior to +;; the separator key. In the future, the separator key might be used +;; to provide completion in certain circumstances. One of the reasons +;; why this functionality is not yet provided is that it is unclear to +;; the author what the precise circumstances are, under which +;; separator-invoked completion should be provided. + +;; Design note: `completing-read-multiple' is modeled after +;; `completing-read'. They should be similar -- it was intentional. + +;; Some of this code started out as translation from C code in +;; src/minibuf.c to Emacs Lisp code. + +;; Thanks to Richard Stallman for all of his help (many of the good +;; ideas in here are from him), Gerd Moellmann for his attention, +;; Stefan Monnier for responding with a code sample and comments very +;; early on, and Kai Grossjohann & Soren Dayton for valuable feedback. + +;;; Questions and Thoughts: + +;; -the author has gone through a number of test-and-fix cycles w/ +;; this code, so it should be usable. please let me know if you find +;; any problems. + +;; -should `completing-read-multiple' allow a trailing separator in +;; a return value when REQUIRE-MATCH is t? if not, should beep when a user +;; tries to exit the minibuffer via RET? + +;; -TODO: possibly make return values from `crm-do-completion' into constants + +;; -TODO: find out whether there is an appropriate way to distinguish between +;; functions intended for internal use and those that aren't. + +;; -tip: use M-f and M-b for ease of navigation among elements. + +;;; History: +;; +;; 2000-04-10: +;; +;; first revamped version + +;;; Code: +(defconst crm-default-separator "," + "Default separator for `completing-read-multiple'.") + +(defvar crm-separator crm-default-separator + "Separator used for separating strings in `completing-read-multiple'. +It should be a single character string that doesn't appear in the list of +completion candidates. Modify this value to make `completing-read-multiple' +use a separator other than `crm-default-separator'.") + +;; actual filling in of these maps occurs below via `crm-init-keymaps' +(defvar crm-local-completion-map nil + "Local keymap for minibuffer multiple input with completion. +Analog of `minibuffer-local-completion-map'.") + +(defvar crm-local-must-match-map nil + "Local keymap for minibuffer multiple input with exact match completion. +Analog of `minibuffer-local-must-match-map' for crm.") + +;; this is supposed to be analogous to last_exact_completion in src/minibuf.c +(defvar crm-last-exact-completion nil + "Completion string if last attempt reported \"Complete, but not unique\".") + +(defvar crm-left-of-element nil + "String to the left of the current element.") + +(defvar crm-current-element nil + "The current element.") + +(defvar crm-right-of-element nil + "String to the right of the current element.") + +(defvar crm-beginning-of-element nil + "Buffer position representing the beginning of the current element.") + +(defvar crm-end-of-element nil + "Buffer position representing the end of the current element.") + +;; emulates temp_echo_area_glyphs from src/minibuf.c +(defun crm-temp-echo-area-glyphs (message-string) + "Temporarily display MESSAGE-STRING in echo area. +After user-input or 2 seconds, erase the displayed string." + (save-excursion + (goto-char (point-max)) + (insert message-string) + (sit-for 2) + (backward-char (length message-string)) + (delete-char (length message-string)))) + +;; this function evolved from a posting by Stefan Monnier +(defun crm-collection-fn (string predicate flag) + "Function used by `completing-read-multiple' to compute completion values. +The value of STRING is the string to be completed. + +The value of PREDICATE is a function to filter possible matches, or +nil if none. + +The value of FLAG is used to specify the type of completion operation. +A value of nil specifies `try-completion'. A value of t specifies +`all-completions'. A value of lambda specifes a test for an exact match. + +For more information on STRING, PREDICATE, and FLAG, see the Elisp +Reference sections on 'Programmed Completion' and 'Basic Completion +Functions'." + (let ((lead "")) + (when (string-match (concat ".*" crm-separator) string) + (setq lead (substring string 0 (match-end 0))) + (setq string (substring string (match-end 0)))) + (if (eq flag 'lambda) + ;; return t for exact match, nil otherwise + (let ((result (try-completion string table predicate))) + (if (stringp result) + nil + (if result + t + nil)))) + (if flag + ;; called via (all-completions string 'crm-completion-fn predicate)? + (all-completions string table predicate) + ;; called via (try-completion string 'crm-completion-fn predicate)? + (let ((result (try-completion string table predicate))) + (if (stringp result) + (concat lead result) + result))))) + +(defun crm-find-current-element () + "Parse the minibuffer to find the current element. +If no element can be found, return nil. + +If an element is found, bind: + + -the variable `crm-current-element' to the current element, + + -the variables `crm-left-of-element' and `crm-right-of-element' to + the strings to the left and right of the current element, + respectively, and + + -the variables `crm-beginning-of-element' and `crm-end-of-element' to + the buffer positions of the beginning and end of the current element + respectively, + +and return t." + (let* ((minibuffer-string (buffer-string)) + (end-index (or (string-match "," minibuffer-string (1- (point))) + (1- (point-max)))) + (target-string (substring minibuffer-string 0 end-index)) + (index (or (string-match + (concat crm-separator "\\([^" crm-separator "]*\\)$") + target-string) + (string-match + (concat "^\\([^" crm-separator "]*\\)$") + target-string)))) + (if (not (numberp index)) + ;; no candidate found + nil + (progn + ;; + (setq crm-beginning-of-element (match-beginning 1)) + (setq crm-end-of-element end-index) + ;; string to the left of the current element + (setq crm-left-of-element (substring target-string 0 (match-beginning 1))) + ;; the current element + (setq crm-current-element (match-string 1 target-string)) + ;; string to the right of the current element + (setq crm-right-of-element (substring minibuffer-string end-index)) + t)))) + +(defun crm-test-completion (candidate) + "Return t if CANDIDATE is an exact match for a valid completion." + (let ((completions + ;; TODO: verify whether the arguments are appropriate + (all-completions candidate table minibuffer-completion-predicate))) + (if (member candidate completions) + t + nil))) + +(defun crm-minibuffer-completion-help () + "Display a list of possible completions of the current minibuffer element." + (interactive) + (message "Making completion list...") + (if (not (crm-find-current-element)) + nil + (let ((completions (all-completions crm-current-element + minibuffer-completion-table + minibuffer-completion-predicate))) + (message nil) + (if (null completions) + (crm-temp-echo-area-glyphs " [No completions]") + (with-output-to-temp-buffer "*Completions*" + (display-completion-list (sort completions 'string-lessp)))))) + nil) + +(defun crm-do-completion () + "This is the internal completion engine. +This function updates the text in the minibuffer +to complete the current string, and returns a number between 0 and 6. +The meanings of the return values are: + + 0 - the string has no possible completion + 1 - the string is already a valid and unique match + 2 - not used + 3 - the string is already a valid match (but longer matches exist too) + 4 - the string was completed to a valid match + 5 - some completion has been done, but the result is not a match + 6 - no completion was done, and the string is not an exact match" + + (if (not (crm-find-current-element)) + nil + (let (last completion completedp) + (setq completion + (try-completion crm-current-element + minibuffer-completion-table + minibuffer-completion-predicate)) + (setq last crm-last-exact-completion) + (setq crm-last-exact-completion nil) + + (catch 'crm-exit + + (if (null completion) ; no possible completion + (progn + (crm-temp-echo-area-glyphs " [No match]") + (throw 'crm-exit 0))) + + (if (eq completion t) ; was already an exact and unique completion + (throw 'crm-exit 1)) + + (setq completedp + (null (string-equal completion crm-current-element))) + + (if completedp + (progn + (erase-buffer) + (insert crm-left-of-element completion) + ;; (if crm-complete-up-to-point + ;; (insert crm-separator)) + (insert crm-right-of-element) + (backward-char (length crm-right-of-element)) + ;; TODO: is this correct? + (setq crm-current-element completion))) + + (if (null (crm-test-completion crm-current-element)) + (progn + (if completedp ; some completion happened + (throw 'crm-exit 5) + (if completion-auto-help + (crm-minibuffer-completion-help) + (crm-temp-echo-area-glyphs " [Next char not unique]"))) + (throw 'crm-exit 6)) + (if completedp + (throw 'crm-exit 4))) + + (setq crm-last-exact-completion completion) + (if (not (null last)) + (progn + (if (not (null (equal crm-current-element last))) + (crm-minibuffer-completion-help)))) + + ;; returning -- was already an exact completion + (throw 'crm-exit 3))))) + +(defun crm-minibuffer-complete () + "Complete the current element. +If no characters can be completed, display a list of possible completions. + +Return t if the current element is now a valid match; otherwise return nil." + (interactive) + ;; take care of scrolling if necessary -- completely cribbed from minibuf.c + (if (not (eq last-command this-command)) + ;; ok? + (setq minibuffer-scroll-window nil)) + (let ((window minibuffer-scroll-window)) + (if (and (not (null window)) + ;; ok? + (not (null (window-buffer window)))) + (let (tem) + (set-buffer (window-buffer window)) + ;; ok? + (setq tem (pos-visible-in-window-p (point-max) window)) + (if (not (null tem)) + ;; ok? + (set-window-start window (point-min) nil) + (scroll-other-window nil)) + ;; reaching here means exiting the function w/ return value of nil + nil) + + (let* ( + ;(crm-end-of-element nil) + (result (crm-do-completion))) + (cond + ((eq 0 result) + nil) + ((eq 1 result) + ;; adapted from Emacs 21 + (if (not (eq (point) crm-end-of-element)) + (goto-char (+ 1 crm-end-of-element))) + (crm-temp-echo-area-glyphs " [Sole completion]") + t) + ((eq 3 result) + ;; adapted from Emacs 21 + (if (not (eq (point) crm-end-of-element)) + (goto-char (+ 1 crm-end-of-element))) + (crm-temp-echo-area-glyphs " [Complete, but not unique]") + t)))))) + +;; i love traffic lights...but only when they're green +(defun crm-find-longest-completable-substring (string) + "Determine the longest completable (left-anchored) substring of STRING. +The description \"left-anchored\" means the positions of the characters +in the substring must be the same as those of the corresponding characters +in STRING. Anchoring is what `^' does in a regular expression. + +The table and predicate used for completion are +`minibuffer-completion-table' and `minibuffer-completion-predicate', +respectively. + +A non-nil return value means that there is some substring which is +completable. A return value of t means that STRING itself is +completable. If a string value is returned it is the longest +completable proper substring of STRING. If nil is returned, STRING +does not have any non-empty completable substrings. + +Remember: \"left-anchored\" substring" + (let* ((length-of-string (length string)) + (index length-of-string) + (done (if (> length-of-string 0) + nil + t)) + (first t) ; ugh, special handling for first time through... + goal-string + result) + ;; loop through left-anchored substrings in order of descending length, + ;; find the first substring that is completable + (while (not done) + (setq result (try-completion (substring string 0 index) + minibuffer-completion-table + minibuffer-completion-predicate)) + (if result + ;; found completable substring + (progn + (setq done t) + (if (and (eq result t) first) + ;; exactly matching string first time through + (setq goal-string t) + ;; fully-completed proper substring + (setq goal-string (substring string 0 index))))) + (setq index (1- index)) + (if first + (setq first nil)) + (if (<= index 0) + (setq done t))) + ;; possible values include: t, nil, some string + goal-string)) + +;; TODO: decide whether trailing separator is allowed. current +;; implementation appears to allow it +(defun crm-strings-completed-p (separated-string) + "Verify that strings in SEPARATED-STRING are completed strings. +A return value of t means that all strings were verified. A number is +returned if verification was unsuccessful. This number represents the +position in SEPARATED-STRING up to where completion was successful." + (let ((strings (split-string separated-string crm-separator)) + ;; buffers start at 1, not 0 + (current-position 1) + current-string + result + done) + (while (and strings (not done)) + (setq current-string (car strings) + result (try-completion current-string + minibuffer-completion-table + minibuffer-completion-predicate)) + (if (eq result t) + (setq strings (cdr strings) + current-position (+ current-position + (length current-string) + ;; automatically adding 1 for separator + ;; character + 1)) + ;; still one more case of a match + (if (stringp result) + (let ((string-list + (all-completions result + minibuffer-completion-table + minibuffer-completion-predicate))) + (if (member result string-list) + ;; ho ho, code duplication... + (setq strings (cdr strings) + current-position (+ current-position + (length current-string) + 1)) + (progn + (setq done t) + ;; current-string is a partially-completed string + (setq current-position (+ current-position + (length current-string)))))) + ;; current-string cannot be completed + (let ((completable-substring + (crm-find-longest-completable-substring current-string))) + (setq done t) + (setq current-position (+ current-position + (length completable-substring))))))) + ;; return our result + (if (null strings) + t + current-position))) + +;; try to complete candidate, then check all separated strings. move +;; point to problem position if checking fails for some string. if +;; checking succeeds for all strings, exit. +(defun crm-minibuffer-complete-and-exit () + "If all of the minibuffer elements are valid completions then exit. +All elements in the minibuffer must match. If there is a mismatch, move point +to the location of mismatch and do not exit. + +This function is modeled after `minibuffer_complete_and_exit' in src/minibuf.c" + (interactive) + + (if (not (crm-find-current-element)) + nil + (let (result) + + (setq result + (catch 'crm-exit + + (if (eq (point-min) (point-max)) + (throw 'crm-exit t)) + + ;; TODO: this test is suspect? + (if (not (null (crm-test-completion crm-current-element))) + (throw 'crm-exit "check")) + + ;; TODO: determine how to detect errors + (let ((result (crm-do-completion))) + + (cond + ((or (eq 1 result) + (eq 3 result)) + (throw 'crm-exit "check")) + ((eq 4 result) + (if (not (null minibuffer-completion-confirm)) + (progn + (crm-temp-echo-area-glyphs " [Confirm]") + nil) + (throw 'crm-exit "check"))) + (nil))))) + + (if (null result) + nil + (if (equal result "check") + (let ((check-strings + (crm-strings-completed-p (buffer-string)))) + ;; check all of minibuffer + (if (eq check-strings t) + (throw 'exit nil) + (if (numberp check-strings) + (progn + (goto-char check-strings) + (crm-temp-echo-area-glyphs " [An element did not match]")) + (message "Unexpected error")))) + (if (eq result t) + (throw 'exit nil) + (message "Unexpected error"))))))) + +(defun crm-init-keymaps () + "Initialize the keymaps used by `completing-read-multiple'. +Two keymaps are used depending on the value of the REQUIRE-MATCH +argument of the function `completing-read-multiple'. + +If REQUIRE-MATCH is nil, the keymap `crm-local-completion-map' is used. +This keymap inherits from the keymap named `minibuffer-local-completion-map'. +The only difference is that TAB is bound to `crm-minibuffer-complete' in +the inheriting keymap. + +If REQUIRE-MACTH is non-nil, the keymap `crm-local-must-match-map' is used. +This keymap inherits from the keymap named `minibuffer-local-must-match-map'. +The inheriting keymap binds RET to `crm-minibuffer-complete-and-exit' +and TAB to `crm-minibuffer-complete'." + (unless crm-local-completion-map + (setq crm-local-completion-map (make-sparse-keymap)) + (set-keymap-parent crm-local-completion-map + minibuffer-local-completion-map) + ;; key definitions + (define-key crm-local-completion-map + (kbd "TAB") + (function crm-minibuffer-complete))) + + (unless crm-local-must-match-map + (setq crm-local-must-match-map (make-sparse-keymap)) + (set-keymap-parent crm-local-must-match-map + minibuffer-local-must-match-map) + ;; key definitions + (define-key crm-local-must-match-map + (kbd "RET") + (function crm-minibuffer-complete-and-exit)) + (define-key crm-local-must-match-map + (kbd "TAB") + (function crm-minibuffer-complete)))) + +(crm-init-keymaps) + +;; superemulates behavior of completing_read in src/minibuf.c +;;;###autoload +(defun completing-read-multiple + (prompt table &optional predicate require-match initial-input + hist def inherit-input-method) + "Read multiple strings in the minibuffer, with completion. +By using this functionality, a user may specify multiple strings at a +single prompt, optionally using completion. + +Multiple strings are specified by separating each of the strings with +a prespecified separator character. For example, if the separator +character is a comma, the strings 'alice', 'bob', and 'eve' would be +specified as 'alice,bob,eve'. + +The default value for the separator character is the value of +`crm-default-separator' (comma). The separator character may be +changed by modifying the value of `crm-separator'. + +Continguous strings of non-separator-characters are referred to as +'elements'. In the aforementioned example, the elements are: 'alice', +'bob', and 'eve'. + +Completion is available on a per-element basis. For example, if the +contents of the minibuffer are 'alice,bob,eve' and point is between +'l' and 'i', pressing TAB operates on the element 'alice'. + +The return value of this function is a list of the read strings. + +See the documentation for `completing-read' for details on the arguments: +PROMPT, TABLE, PREDICATE, REQUIRE-MATCH, INITIAL-INPUT, HIST, DEF, and +INHERIT-INPUT-METHOD." + (let ((minibuffer-completion-table (function crm-collection-fn)) + (minibuffer-completion-predicate predicate) + ;; see completing_read in src/minibuf.c + (minibuffer-completion-confirm (if (eq require-match t) + nil + t)) + crm-last-exact-completion + crm-current-element + crm-left-of-element + crm-right-of-element + crm-beginning-of-element + crm-end-of-element + map) + (if require-match + ;; use `crm-local-must-match-map' + (setq map crm-local-must-match-map) + ;; use `minibuffer-local-completion-map' + (setq map minibuffer-local-completion-map)) + (split-string (read-from-minibuffer + prompt initial-input map + nil hist def inherit-input-method) + crm-separator))) + +;; testing and debugging +;;; (defun crm-init-test-environ () +;;; "Set up some variables for testing." +;;; (interactive) +;;; (setq my-prompt "Prompt: ") +;;; (setq my-table +;;; '(("hi") ("there") ("man") ("may") ("mouth") ("ma") +;;; ("a") ("ab") ("abc") ("abd") ("abf") ("zab") ("acb") +;;; ("da") ("dab") ("dabc") ("dabd") ("dabf") ("dzab") ("dacb") +;;; ("fda") ("fdab") ("fdabc") ("fdabd") ("fdabf") ("fdzab") ("fdacb") +;;; ("gda") ("gdab") ("gdabc") ("gdabd") ("gdabf") ("gdzab") ("gdacb") +;;; )) +;;; (setq my-separator ",")) + +;(completing-read-multiple my-prompt my-table) +;(completing-read-multiple my-prompt my-table nil t) +;(completing-read-multiple my-prompt my-table nil "match") +;(completing-read my-prompt my-table nil t) +;(completing-read my-prompt my-table nil "match") + +(provide 'crm) + +;;; crm.el ends here
--- a/lisp/loaddefs.el Tue Apr 25 19:41:30 2000 +0000 +++ b/lisp/loaddefs.el Tue Apr 25 19:43:58 2000 +0000 @@ -3335,6 +3335,40 @@ ;;;*** +;;;### (autoloads (completing-read-multiple) "crm" "emacs-lisp/crm.el" +;;;;;; (14597 38419)) +;;; Generated autoloads from emacs-lisp/crm.el + +(autoload (quote completing-read-multiple) "crm" "\ +Read multiple strings in the minibuffer, with completion. +By using this functionality, a user may specify multiple strings at a +single prompt, optionally using completion. + +Multiple strings are specified by separating each of the strings with +a prespecified separator character. For example, if the separator +character is a comma, the strings 'alice', 'bob', and 'eve' would be +specified as 'alice,bob,eve'. + +The default value for the separator character is the value of +`crm-default-separator' (comma). The separator character may be +changed by modifying the value of `crm-separator'. + +Continguous strings of non-separator-characters are referred to as +'elements'. In the aforementioned example, the elements are: 'alice', +'bob', and 'eve'. + +Completion is available on a per-element basis. For example, if the +contents of the minibuffer are 'alice,bob,eve' and point is between +'l' and 'i', pressing TAB operates on the element 'alice'. + +The return value of this function is a list of the read strings. + +See the documentation for `completing-read' for details on the arguments: +PROMPT, TABLE, PREDICATE, REQUIRE-MATCH, INITIAL-INPUT, HIST, DEF, and +INHERIT-INPUT-METHOD." nil nil) + +;;;*** + ;;;### (autoloads (customize-menu-create custom-menu-create custom-save-all ;;;;;; customize-save-customized custom-file customize-browse custom-buffer-create-other-window ;;;;;; custom-buffer-create customize-apropos-groups customize-apropos-faces @@ -3343,7 +3377,7 @@ ;;;;;; customize-option-other-window customize-changed-options customize-option ;;;;;; customize-group-other-window customize-group customize customize-save-variable ;;;;;; customize-set-variable customize-set-value) "cus-edit" "cus-edit.el" -;;;;;; (14558 7062)) +;;;;;; (14587 2634)) ;;; Generated autoloads from cus-edit.el (add-hook 'same-window-regexps "\\`\\*Customiz.*\\*\\'") @@ -3997,7 +4031,7 @@ ;;;*** ;;;### (autoloads (diary-mail-entries diary) "diary-lib" "calendar/diary-lib.el" -;;;;;; (14523 49787)) +;;;;;; (14587 2634)) ;;; Generated autoloads from calendar/diary-lib.el (autoload (quote diary) "diary-lib" "\ @@ -4876,8 +4910,8 @@ ;;;### (autoloads (ebrowse-save-tree-as ebrowse-tags-query-replace ;;;;;; ebrowse-tags-loop-continue ebrowse-tags-complete-symbol ebrowse-electric-choose-tree -;;;;;; ebrowse-tree-mode) "ebrowse" "progmodes/ebrowse.el" (14577 -;;;;;; 54346)) +;;;;;; ebrowse-tree-mode) "ebrowse" "progmodes/ebrowse.el" (14597 +;;;;;; 60306)) ;;; Generated autoloads from progmodes/ebrowse.el (autoload (quote ebrowse-tree-mode) "ebrowse" "\ @@ -4945,7 +4979,7 @@ ;;;*** ;;;### (autoloads (edebug-eval-top-level-form def-edebug-spec edebug-all-forms -;;;;;; edebug-all-defs) "edebug" "emacs-lisp/edebug.el" (14576 25687)) +;;;;;; edebug-all-defs) "edebug" "emacs-lisp/edebug.el" (14583 8560)) ;;; Generated autoloads from emacs-lisp/edebug.el (defvar edebug-all-defs nil "\ @@ -5500,8 +5534,8 @@ ;;;;;; pop-tag-mark find-tag-regexp find-tag-other-frame find-tag-other-window ;;;;;; find-tag find-tag-noselect tags-table-files visit-tags-table ;;;;;; find-tag-default-function find-tag-hook tags-add-tables tags-table-list -;;;;;; tags-case-fold-search) "etags" "progmodes/etags.el" (14551 -;;;;;; 24244)) +;;;;;; tags-case-fold-search) "etags" "progmodes/etags.el" (14597 +;;;;;; 60154)) ;;; Generated autoloads from progmodes/etags.el (defvar tags-file-name nil "\ @@ -7276,7 +7310,7 @@ ;;;*** ;;;### (autoloads (jdb pdb perldb xdb dbx sdb gdb) "gud" "gud.el" -;;;;;; (14517 9487)) +;;;;;; (14587 2634)) ;;; Generated autoloads from gud.el (autoload (quote gdb) "gud" "\ @@ -7385,7 +7419,7 @@ ;;;*** ;;;### (autoloads (hexlify-buffer hexl-find-file hexl-mode) "hexl" -;;;;;; "hexl.el" (14335 43064)) +;;;;;; "hexl.el" (14589 54862)) ;;; Generated autoloads from hexl.el (autoload (quote hexl-mode) "hexl" "\ @@ -8205,7 +8239,7 @@ ;;;*** ;;;### (autoloads (inferior-lisp) "inf-lisp" "progmodes/inf-lisp.el" -;;;;;; (13898 16429)) +;;;;;; (14589 55732)) ;;; Generated autoloads from progmodes/inf-lisp.el (defvar inferior-lisp-filter-regexp "\\`\\s *\\(:\\(\\w\\|\\s_\\)\\)?\\s *\\'" "\ @@ -8257,8 +8291,8 @@ ;;;*** ;;;### (autoloads (Info-speedbar-browser Info-goto-emacs-key-command-node -;;;;;; Info-goto-emacs-command-node info-standalone info info-other-window) -;;;;;; "info" "info.el" (14544 60288)) +;;;;;; Info-goto-emacs-command-node Info-directory info-standalone +;;;;;; info info-other-window) "info" "info.el" (14581 64356)) ;;; Generated autoloads from info.el (autoload (quote info-other-window) "info" "\ @@ -8284,6 +8318,9 @@ Usage: emacs -f info-standalone [filename] In standalone mode, \\<Info-mode-map>\\[Info-exit] exits Emacs itself." nil nil) +(autoload (quote Info-directory) "info" "\ +Go to the Info directory node." t nil) + (autoload (quote Info-goto-emacs-command-node) "info" "\ Go to the Info node in the Emacs manual for command COMMAND. The command is found by looking up in Emacs manual's Command Index @@ -8501,16 +8538,16 @@ ;;;;;; ispell-region ispell-change-dictionary ispell-kill-ispell ;;;;;; ispell-help ispell-word ispell-dictionary-alist ispell-local-dictionary-alist ;;;;;; ispell-personal-dictionary) "ispell" "textmodes/ispell.el" -;;;;;; (14457 51532)) +;;;;;; (14587 2706)) ;;; Generated autoloads from textmodes/ispell.el -(defconst ispell-xemacsp (string-match "Lucid\\|XEmacs" emacs-version) "\ +(defconst xemacsp (string-match "Lucid\\|XEmacs" emacs-version) "\ Non nil if using XEmacs.") -(defconst ispell-version18p (string-match "18\\.[0-9]+\\.[0-9]+" emacs-version) "\ +(defconst version18p (string-match "18\\.[0-9]+\\.[0-9]+" emacs-version) "\ Non nil if using emacs version 18.") -(defconst ispell-version20p (string-match "20\\.[0-9]+\\.[0-9]+" emacs-version) "\ +(defconst version20p (string-match "20\\.[0-9]+\\.[0-9]+" emacs-version) "\ Non nil if using emacs version 20.") (defvar ispell-personal-dictionary nil "\ @@ -8522,7 +8559,7 @@ *Contains local or customized dictionary definitions. See `ispell-dictionary-alist'.") -(setq ispell-dictionary-alist-1 (quote ((nil "[A-Za-z]" "[^A-Za-z]" "[']" nil ("-B") nil iso-8859-1) ("american" "[A-Za-z]" "[^A-Za-z]" "[']" nil ("-B") nil iso-8859-1) ("brasiliano" "[A-Z\301\311\315\323\332\300\310\314\322\331\303\325\307\334\302\312\324a-z\341\351\355\363\372\340\350\354\362\371\343\365\347\374\342\352\364]" "[^A-Z\301\311\315\323\332\300\310\314\322\331\303\325\307\334\302\312\324a-z\341\351\355\363\372\340\350\354\362\371\343\365\347\374\342\352\364]" "[']" nil ("-d" "brasileiro") nil iso-8859-1) ("british" "[A-Za-z]" "[^A-Za-z]" "[']" nil ("-B" "-d" "british") nil iso-8859-1) ("castellano" "[A-Z\301\311\315\321\323\332\334a-z\341\351\355\361\363\372\374]" "[^A-Z\301\311\315\321\323\332\334a-z\341\351\355\361\363\372\374]" "[---]" nil ("-B" "-d" "castellano") "~tex" iso-8859-1) ("castellano8" "[A-Z\301\311\315\321\323\332\334a-z\341\351\355\361\363\372\374]" "[^A-Z\301\311\315\321\323\332\334a-z\341\351\355\361\363\372\374]" "[---]" nil ("-B" "-d" "castellano") "~latin1" iso-8859-1)))) +(setq ispell-dictionary-alist-1 (quote ((nil "[A-Za-z]" "[^A-Za-z]" "[']" nil ("-B") nil iso-8859-1) ("american" "[A-Za-z]" "[^A-Za-z]" "[']" nil ("-B") nil iso-8859-1) ("brasileiro" "[A-Z\301\311\315\323\332\300\310\314\322\331\303\325\307\334\302\312\324a-z\341\351\355\363\372\340\350\354\362\371\343\365\347\374\342\352\364]" "[^A-Z\301\311\315\323\332\300\310\314\322\331\303\325\307\334\302\312\324a-z\341\351\355\363\372\340\350\354\362\371\343\365\347\374\342\352\364]" "[']" nil ("-d" "brasileiro") nil iso-8859-1) ("british" "[A-Za-z]" "[^A-Za-z]" "[']" nil ("-B" "-d" "british") nil iso-8859-1) ("castellano" "[A-Z\301\311\315\321\323\332\334a-z\341\351\355\361\363\372\374]" "[^A-Z\301\311\315\321\323\332\334a-z\341\351\355\361\363\372\374]" "[---]" nil ("-B" "-d" "castellano") "~tex" iso-8859-1) ("castellano8" "[A-Z\301\311\315\321\323\332\334a-z\341\351\355\361\363\372\374]" "[^A-Z\301\311\315\321\323\332\334a-z\341\351\355\361\363\372\374]" "[---]" nil ("-B" "-d" "castellano") "~latin1" iso-8859-1)))) (setq ispell-dictionary-alist-2 (quote (("czech" "[A-Za-z\301\311\314\315\323\332\331\335\256\251\310\330\317\253\322\341\351\354\355\363\372\371\375\276\271\350\370\357\273\362]" "[^A-Za-z\301\311\314\315\323\332\331\335\256\251\310\330\317\253\322\341\351\354\355\363\372\371\375\276\271\350\370\357\273\362]" "" nil ("-B" "-d" "czech") nil iso-8859-2) ("dansk" "[A-Z\306\330\305a-z\346\370\345]" "[^A-Z\306\330\305a-z\346\370\345]" "[']" nil ("-C") nil iso-8859-1) ("deutsch" "[a-zA-Z\"]" "[^a-zA-Z\"]" "[']" t ("-C") "~tex" iso-8859-1) ("deutsch8" "[a-zA-Z\304\326\334\344\366\337\374]" "[^a-zA-Z\304\326\334\344\366\337\374]" "[']" t ("-C" "-d" "deutsch") "~latin1" iso-8859-1) ("english" "[A-Za-z]" "[^A-Za-z]" "[']" nil ("-B") nil iso-8859-1)))) @@ -8590,15 +8627,15 @@ If nil when package is loaded, a standard menu will be set, and added as a submenu of the \"Edit\" menu.") -(defvar ispell-menu-map-needed (and (not ispell-menu-map) (not ispell-version18p) (not ispell-xemacsp) (quote reload))) - -(if ispell-menu-map-needed (let ((dicts (reverse (cons (cons "default" nil) ispell-dictionary-alist))) (path (and (boundp (quote ispell-library-path)) ispell-library-path)) name load-dict) (setq ispell-menu-map (make-sparse-keymap "Spell")) (while dicts (setq name (car (car dicts)) load-dict (car (cdr (member "-d" (nth 5 (car dicts))))) dicts (cdr dicts)) (cond ((not (stringp name)) (define-key ispell-menu-map (vector (quote default)) (cons "Select Default Dict" (list (quote lambda) nil (quote (interactive)) (list (quote ispell-change-dictionary) "default"))))) ((or (not path) (file-exists-p (concat path "/" name ".hash")) (file-exists-p (concat path "/" name ".has")) (and load-dict (or (file-exists-p (concat path "/" load-dict ".hash")) (file-exists-p (concat path "/" load-dict ".has"))))) (define-key ispell-menu-map (vector (intern name)) (cons (concat "Select " (capitalize name)) (list (quote lambda) nil (quote (interactive)) (list (quote ispell-change-dictionary) name))))))))) - -(if ispell-menu-map-needed (progn (define-key ispell-menu-map [ispell-change-dictionary] (quote ("Change Dictionary" . ispell-change-dictionary))) (define-key ispell-menu-map [ispell-kill-ispell] (quote ("Kill Process" . ispell-kill-ispell))) (define-key ispell-menu-map [ispell-pdict-save] (quote ("Save Dictionary" lambda nil (interactive) (ispell-pdict-save t t)))) (define-key ispell-menu-map [ispell-complete-word] (quote ("Complete Word" . ispell-complete-word))) (define-key ispell-menu-map [ispell-complete-word-interior-frag] (quote ("Complete Word Frag" . ispell-complete-word-interior-frag))))) - -(if ispell-menu-map-needed (progn (define-key ispell-menu-map [ispell-continue] (quote ("Continue Check" . ispell-continue))) (define-key ispell-menu-map [ispell-word] (quote ("Check Word" . ispell-word))) (define-key ispell-menu-map [ispell-comments-and-strings] (quote ("Check Comments" . ispell-comments-and-strings))) (define-key ispell-menu-map [ispell-region] (quote ("Check Region" . ispell-region))) (define-key ispell-menu-map [ispell-buffer] (quote ("Check Buffer" . ispell-buffer))))) - -(if ispell-menu-map-needed (progn (define-key ispell-menu-map [ispell-message] (quote ("Check Message" . ispell-message))) (define-key ispell-menu-map [ispell-help] (quote ("Help" lambda nil (interactive) (describe-function (quote ispell-help))))) (put (quote ispell-region) (quote menu-enable) (quote mark-active)) (fset (quote ispell-menu-map) (symbol-value (quote ispell-menu-map))))) +(defvar ispell-menu-map-needed (and (not ispell-menu-map) (not version18p) (not xemacsp) (quote reload))) + +(if ispell-menu-map-needed (let ((dicts (reverse (cons (cons "default" nil) ispell-dictionary-alist))) (path (and (boundp (quote ispell-library-path)) ispell-library-path)) name load-dict) (setq ispell-menu-map (make-sparse-keymap "Spell")) (while dicts (setq name (car (car dicts)) load-dict (car (cdr (member "-d" (nth 5 (car dicts))))) dicts (cdr dicts)) (cond ((not (stringp name)) (define-key ispell-menu-map (vector (quote default)) (cons "Select Default Dict" (cons "Dictionary for which Ispell was configured" (list (quote lambda) nil (quote (interactive)) (list (quote ispell-change-dictionary) "default")))))) ((or (not path) (file-exists-p (concat path "/" name ".hash")) (file-exists-p (concat path "/" name ".has")) (and load-dict (or (file-exists-p (concat path "/" load-dict ".hash")) (file-exists-p (concat path "/" load-dict ".has"))))) (define-key ispell-menu-map (vector (intern name)) (cons (concat "Select " (capitalize name) " Dict") (list (quote lambda) nil (quote (interactive)) (list (quote ispell-change-dictionary) name))))))))) + +(if ispell-menu-map-needed (progn (define-key ispell-menu-map [ispell-change-dictionary] (quote (menu-item "Change Dictionary..." ispell-change-dictionary :help "Supply explicit path to dictionary"))) (define-key ispell-menu-map [ispell-kill-ispell] (quote (menu-item "Kill Process" ispell-kill-ispell :enable (and (boundp (quote ispell-process)) ispell-process (eq (ispell-process-status) (quote run))) :help "Terminate Ispell subprocess"))) (define-key ispell-menu-map [ispell-pdict-save] (quote (menu-item "Save Dictionary" (lambda nil (interactive) (ispell-pdict-save t t)) :help "Save personal dictionary"))) (define-key ispell-menu-map [ispell-help] (quote (menu-item "Help" (lambda nil (interactive) (describe-function (quote ispell-help))) :help "Show standard Ispell keybindings and commands"))) (define-key ispell-menu-map [ispell-complete-word] (quote (menu-item "Complete Word" ispell-complete-word :help "Complete word at cursor using dictionary"))) (define-key ispell-menu-map [ispell-complete-word-interior-frag] (quote (menu-item "Complete Word Fragment" ispell-complete-word-interior-frag :help "Complete word fragment at cursor"))))) + +(if ispell-menu-map-needed (progn (define-key ispell-menu-map [ispell-continue] (quote (menu-item "Continue Spell-Checking" ispell-continue :enable (and (boundp (quote ispell-region-end)) (marker-position ispell-region-end) (equal (marker-buffer ispell-region-end) (current-buffer)))))) (define-key ispell-menu-map [ispell-word] (quote (menu-item "Spell-Check Word" ispell-word :help "Spell-check word at cursor"))) (define-key ispell-menu-map [ispell-comments-and-strings] (quote (menu-item "Spell-Check Comments" ispell-comments-and-strings :help "Spell-check only comments and strings"))))) + +(if ispell-menu-map-needed (progn (define-key ispell-menu-map [ispell-region] (quote (menu-item "Spell-Check Region" ispell-region :enable mark-active :help "Spell-check text in marked region"))) (define-key ispell-menu-map [ispell-message] (quote (menu-item "Spell-Check Message" ispell-message :help "Skip headers and included message text"))) (define-key ispell-menu-map [ispell-buffer] (quote (menu-item "Spell-Check Buffer" ispell-buffer))) (fset (quote ispell-menu-map) (symbol-value (quote ispell-menu-map))))) (defvar ispell-skip-region-alist (quote ((ispell-words-keyword forward-line) (ispell-dictionary-keyword forward-line) (ispell-pdict-keyword forward-line) (ispell-parsing-keyword forward-line) ("^---*BEGIN PGP [A-Z ]*--*" . "^---*END PGP [A-Z ]*--*") ("^---* \\(Start of \\)?[Ff]orwarded [Mm]essage" . "^---* End of [Ff]orwarded [Mm]essage") ("\\(/\\|\\(\\(\\w\\|-\\)+[.:@]\\)\\)\\(\\w\\|-\\)*\\([.:/@]+\\(\\w\\|-\\|~\\)+\\)+"))) "\ Alist expressing beginning and end of regions not to spell check. @@ -8739,7 +8776,7 @@ ;;;### (autoloads (iswitchb-buffer-other-frame iswitchb-display-buffer ;;;;;; iswitchb-buffer-other-window iswitchb-buffer iswitchb-default-keybindings -;;;;;; iswitchb-read-buffer) "iswitchb" "iswitchb.el" (14482 55434)) +;;;;;; iswitchb-read-buffer) "iswitchb" "iswitchb.el" (14586 61846)) ;;; Generated autoloads from iswitchb.el (autoload (quote iswitchb-read-buffer) "iswitchb" "\ @@ -9596,7 +9633,7 @@ ;;;*** -;;;### (autoloads (man-follow man) "man" "man.el" (14570 21850)) +;;;### (autoloads (man-follow man) "man" "man.el" (14583 33482)) ;;; Generated autoloads from man.el (defalias (quote manual-entry) (quote man)) @@ -11090,7 +11127,7 @@ ;;;### (autoloads (ps-mule-begin-page ps-mule-begin-job ps-mule-initialize ;;;;;; ps-mule-plot-composition ps-mule-plot-string ps-mule-set-ascii-font ;;;;;; ps-mule-prepare-ascii-font ps-multibyte-buffer) "ps-mule" -;;;;;; "ps-mule.el" (14454 81)) +;;;;;; "ps-mule.el" (14588 21278)) ;;; Generated autoloads from ps-mule.el (defvar ps-multibyte-buffer nil "\ @@ -11187,7 +11224,7 @@ ;;;;;; ps-spool-region ps-spool-buffer-with-faces ps-spool-buffer ;;;;;; ps-print-region-with-faces ps-print-region ps-print-buffer-with-faces ;;;;;; ps-print-buffer ps-print-customize ps-paper-type) "ps-print" -;;;;;; "ps-print.el" (14563 18761)) +;;;;;; "ps-print.el" (14584 21532)) ;;; Generated autoloads from ps-print.el (defvar ps-paper-type (quote letter) "\ @@ -12251,7 +12288,7 @@ ;;;;;; rmail-summary-by-senders rmail-summary-by-topic rmail-summary-by-regexp ;;;;;; rmail-summary-by-recipients rmail-summary-by-labels rmail-summary ;;;;;; rmail-summary-line-count-flag rmail-summary-scroll-between-messages) -;;;;;; "rmailsum" "mail/rmailsum.el" (14568 47126)) +;;;;;; "rmailsum" "mail/rmailsum.el" (14597 48840)) ;;; Generated autoloads from mail/rmailsum.el (defvar rmail-summary-scroll-between-messages t "\ @@ -12444,7 +12481,7 @@ ;;;;;; mail-signature mail-personal-alias-file mail-alias-file mail-default-reply-to ;;;;;; mail-archive-file-name mail-header-separator mail-yank-ignored-headers ;;;;;; mail-interactive mail-self-blind mail-specify-envelope-from -;;;;;; mail-from-style) "sendmail" "mail/sendmail.el" (14532 62968)) +;;;;;; mail-from-style) "sendmail" "mail/sendmail.el" (14588 18519)) ;;; Generated autoloads from mail/sendmail.el (defvar mail-from-style (quote angles) "\ @@ -13324,7 +13361,7 @@ ;;;*** ;;;### (autoloads (speedbar-get-focus speedbar-frame-mode) "speedbar" -;;;;;; "speedbar.el" (14403 56247)) +;;;;;; "speedbar.el" (14597 45194)) ;;; Generated autoloads from speedbar.el (defalias (quote speedbar) (quote speedbar-frame-mode)) @@ -14070,7 +14107,7 @@ ;;;*** ;;;### (autoloads (texinfo-mode) "texinfo" "textmodes/texinfo.el" -;;;;;; (14536 60906)) +;;;;;; (14587 10351)) ;;; Generated autoloads from textmodes/texinfo.el (autoload (quote texinfo-mode) "texinfo" "\ @@ -14137,8 +14174,8 @@ If the file has a `top' node, it must be called `top' or `Top' and be the first node in the file. -Entering Texinfo mode calls the value of text-mode-hook, and then the -value of texinfo-mode-hook." t nil) +Entering Texinfo mode calls the value of `text-mode-hook', and then the +value of `texinfo-mode-hook'." t nil) ;;;*** @@ -14557,7 +14594,7 @@ ;;;*** ;;;### (autoloads (trace-function-background trace-function trace-buffer) -;;;;;; "trace" "emacs-lisp/trace.el" (13607 52440)) +;;;;;; "trace" "emacs-lisp/trace.el" (14583 8560)) ;;; Generated autoloads from emacs-lisp/trace.el (defvar trace-buffer "*trace-output*" "\