From: Richard M. Stallman Date: Mon, 15 May 1995 23:16:08 +0000 (+0000) Subject: (dabbrev-completion): Use mapcar, not mapc. X-Git-Tag: emacs-19.34~4038 X-Git-Url: http://git.eshelyaron.com/gitweb/?a=commitdiff_plain;h=df6eb420bf10e4fd45a19a2a3d451eeafc98d20b;p=emacs.git (dabbrev-completion): Use mapcar, not mapc. Call dabbrev--reset-global-variables as the first thing. (dabbrev-abbrev-char-regexp): Default value is nil again. (dabbrev--find-all-expansions): Don't use push. (dabbrev--search): Likewise. (dabbrev-check-other-buffers): Renamed from dabbrev-always-check-other-buffers. (dabbrev-check-all-buffers): Renamed frm dabbrev-check-rest-of-buffers. (dabbrev-expand): Now checks for marker. (dabbrev--try-find): Now does a protected call to `widen'. (dabbrev-always-check-other-buffers): Default now t. (dabbrev--capitalize): Function deleted. (dabbrev-completion): Use `capitalize'. --- diff --git a/lisp/dabbrev.el b/lisp/dabbrev.el index 430824de8eb..2d14fbb07e7 100644 --- a/lisp/dabbrev.el +++ b/lisp/dabbrev.el @@ -4,7 +4,7 @@ ;; Author: Don Morrison ;; Maintainer: Lars Lindberg ;; Created: 16 Mars 1992 -;; Lindberg's last update version: 5.2 +;; Lindberg's last update version: 5.7 ;; Keywords: abbrev expand completion ;; This program is free software; you can redistribute it and/or modify @@ -30,17 +30,6 @@ ;; To expand a word, just put the point right after the word and press ;; M-/ (dabbrev-expand) or M-C-/ (dabbrev-completion). ;; -;; There are powerful things in this package that aren't turned on by -;; default. I recommend you to do the following. -;; -;; Put the following 2 lines in your .emacs file: -;; (setq dabbrev-always-check-other-buffers t) -;; (setq dabbrev-abbrev-char-regexp "\\sw\\|\\s_") -;; -;; Dabbrev will now search in all buffers with the same major mode for -;; your expansions. It will also search for complete symbols, the old -;; dabbrev package only looked half-heartedly for symbols. -;; ;; Check out the customizable variables below to learn about all the ;; features of this package. @@ -85,7 +74,7 @@ ;; - Check the kill-ring when everything else fails. (Maybe something ;; for hippie-expand?). [Bng] -;;; Thanks goes to +;;; These people gave suggestions: ;; [hymie] Hyman Rosen ;; [burgett] Steve Burgett ;; [jules] Julian Gosnell @@ -149,20 +138,20 @@ variable to see if its value is t or nil. This variable has an effect only when the value of `dabbrev-case-fold-search' evaluates to t.") -(defvar dabbrev-abbrev-char-regexp "\\sw\\|\\s_" +(defvar dabbrev-abbrev-char-regexp nil "*Regexp to recognize a character in an abbreviation or expansion. This regexp will be surrounded with \\\\( ... \\\\) when actually used. Set this variable to \"\\\\sw\" if you want ordinary words or -\"\\\\sw\\\\|\\\\s_\" if you want symbols. +\"\\\\sw\\\\|\\\\s_\" if you want symbols (including characters whose +syntax is \"symbol\" as well as those whose syntax is \"word\". -You can also set it to nil if you want old-style dabbrev searching -\(the abbreviation is from point to previous word-start, the -search is for symbols). +The value nil has a special meaning: the abbreviation is from point to +previous word-start, but the search is for symbols. For instance, if you are programming in Lisp, `yes-or-no-p' is a symbol, -while `yes', `or', `no' and `p' are considered words. If you set this -variable to nil, then expanding `yes-or-no-' looks for a symbol +while `yes', `or', `no' and `p' are considered words. If this +variable is nil, then expanding `yes-or-no-' looks for a symbol starting with or containing `no-'. If you set this variable to \"\\\\sw\\\\|\\\\s_\", that expansion looks for a symbol starting with `yes-or-no-'. Finally, if you set this variable to \"\\\\sw\", then @@ -171,28 +160,33 @@ but expanding `yes-or-no' looks for a word starting with `no'. The recommended value is \"\\\\sw\\\\|\\\\s_\".") -(defvar dabbrev-check-rest-of-buffers t - "*Non-nil means dabbrev package should search in all buffers. -It searches the buffers pointed out by `dabbrev-select-buffers-function' -first; afterward it looks in the rest of the buffers.") +(defvar dabbrev-check-all-buffers t + "*Non-nil means dabbrev package should search *all* buffers. +Dabbrev always searches the current buffer first. Then, if +`dabbrev-check-other-buffers' says so, it searches the buffers +designated by `dabbrev-select-buffers-function'. -;; I recommend that you set this to t. -(defvar dabbrev-always-check-other-buffers nil +Then, if `dabbrev-check-all-buffers' is non-nil, dabbrev searches +all the other buffers.") + +(defvar dabbrev-check-other-buffers t "*Should \\[dabbrev-expand] look in other buffers?\ -nil = Don't look in other buffers.\n\ -t = Look in other buffers.\n\ -Value other than nil and t = ask the user if he want's to look in -other buffers. -The recommended value is t.") +nil: Don't look in other buffers. +t: Also look for expansions in the buffers pointed out by + `dabbrev-select-buffers-function'. +Anything else: When we can't find any more expansions in +the current buffer, then ask the user whether to look in other +buffers too. + +The default value is t.") ;; I guess setting this to a function that selects all C- or C++- ;; mode buffers would be a good choice for a debugging buffer, ;; when debugging C- or C++-code. (defvar dabbrev-select-buffers-function 'dabbrev--select-buffers "A function that selects buffers that should be searched by dabbrev. - The function should take no arguments and return a list of buffers to search for expansions. Have a look at `dabbrev--select-buffers' for an example. @@ -200,8 +194,7 @@ an example. A mode setting this variable should make it buffer local.") (defvar dabbrev-friend-buffer-function 'dabbrev--same-major-mode-p - "*A function to check if OTHER-BUFFER should be searched by dabbrev. - + "*A function to decide whether dabbrev should search OTHER-BUFFER. The function should take one argument, OTHER-BUFFER, and return non-nil if that buffer should be searched. Have a look at `dabbrev--same-major-mode-p' for an example. @@ -257,8 +250,8 @@ this list.") ;; The buffer we last did a completion in. (defvar dabbrev--last-completion-buffer nil) -;; Same as dabbrev-always-check-other-buffers, but is set for every expand. -(defvar dabbrev--check-other-buffers dabbrev-always-check-other-buffers) +;; Same as dabbrev-check-other-buffers, but is set for every expand. +(defvar dabbrev--check-other-buffers dabbrev-check-other-buffers) ;; The regexp for recognizing a character in an abbreviation. (defvar dabbrev--abbrev-char-regexp nil) @@ -316,8 +309,9 @@ With no prefix argument, it reuses an old completion list if there is a suitable one already." (interactive "*P") - (let* ((dabbrev-always-check-other-buffers (and arg t)) - (dabbrev-check-rest-of-buffers + (dabbrev--reset-global-variables) + (let* ((dabbrev-check-other-buffers (and arg t)) + (dabbrev-check-all-buffers (and arg (= (prefix-numeric-value arg) 16))) (abbrev (dabbrev--abbrev-at-point)) (ignore-case-p (and (eval dabbrev-case-fold-search) @@ -343,7 +337,6 @@ if there is a suitable one already." ;;-------------------------------- ;; New abbreviation to expand. ;;-------------------------------- - (dabbrev--reset-global-variables) (setq dabbrev--last-abbreviation abbrev) ;; Find all expansion (let ((completion-list @@ -357,22 +350,22 @@ if there is a suitable one already." (cond ((or (not ignore-case-p) (not dabbrev-case-replace)) - (mapc (function (lambda (string) - (intern string my-obarray))) - completion-list)) + (mapcar (function (lambda (string) + (intern string my-obarray))) + completion-list)) ((string= abbrev (upcase abbrev)) - (mapc (function (lambda (string) - (intern (upcase string) my-obarray))) - completion-list)) + (mapcar (function (lambda (string) + (intern (upcase string) my-obarray))) + completion-list)) ((string= (substring abbrev 0 1) (upcase (substring abbrev 0 1))) - (mapc (function (lambda (string) - (intern (dabbrev--capitalize string) my-obarray))) - completion-list)) + (mapcar (function (lambda (string) + (intern (capitalize string) my-obarray))) + completion-list)) (t - (mapc (function (lambda (string) - (intern (downcase string) my-obarray))) - completion-list))) + (mapcar (function (lambda (string) + (intern (downcase string) my-obarray))) + completion-list))) (setq dabbrev--last-obarray my-obarray) (setq dabbrev--last-completion-buffer (current-buffer)) ;; Find the longest common string. @@ -420,10 +413,6 @@ with the next possible expansion not yet tried. The variable `dabbrev-backward-only' may be used to limit the direction of search to backward if set non-nil. -??? -To make it more powerful, make sure that -`dabbrev-always-check-other-buffers' is set to t. - See also `dabbrev-abbrev-char-regexp' and \\[dabbrev-completion]." (interactive "*P") (let (abbrev expansion old direction) @@ -433,7 +422,8 @@ See also `dabbrev-abbrev-char-regexp' and \\[dabbrev-completion]." ;; (the abbrev, or the previously-made expansion) (save-excursion (if (and (null arg) - dabbrev--last-abbrev-location + (markerp dabbrev--last-abbrev-location) + (marker-position dabbrev--last-abbrev-location) (or (eq last-command this-command) (and (window-minibuffer-p (selected-window)) (= dabbrev--last-abbrev-location @@ -488,22 +478,6 @@ See also `dabbrev-abbrev-char-regexp' and \\[dabbrev-completion]." ;;;---------------------------------------------------------------- ;;;---------------------------------------------------------------- -(defun dabbrev--capitalize (string) - ;; Capitalize STRING (See capitalize-word) - (let ((new-string "")) - (save-match-data - (while (string-match "\\w+" string) - (let* ((mb (match-beginning 0)) - (me (match-end 0)) - (ms (substring string mb me))) - (setq new-string - (concat new-string - (substring string 0 mb) - (upcase (substring ms 0 1)) - (downcase (substring ms 1)))) - (setq string (substring string me))))) - new-string)) - ;;; Checks if OTHER-BUFFER has the same major mode as current buffer. (defun dabbrev--same-major-mode-p (other-buffer) (eq major-mode @@ -563,7 +537,7 @@ See also `dabbrev-abbrev-char-regexp' and \\[dabbrev-completion]." dabbrev--last-buffer-found nil dabbrev--abbrev-char-regexp (or dabbrev-abbrev-char-regexp "\\sw\\|\\s_") - dabbrev--check-other-buffers dabbrev-always-check-other-buffers)) + dabbrev--check-other-buffers dabbrev-check-other-buffers)) ;;; Find all buffers that are considered "friends" according to the ;;; function pointed out by dabbrev-friend-buffer-function. @@ -582,19 +556,21 @@ See also `dabbrev-abbrev-char-regexp' and \\[dabbrev-completion]." ;;; but looking in reverse instead if REVERSE is non-nil. (defun dabbrev--try-find (abbrev reverse n ignore-case) (save-excursion - (let ((expansion nil)) - (and dabbrev--last-expansion-location - (goto-char dabbrev--last-expansion-location)) - (let ((case-fold-search ignore-case) - (count n)) - (while (and (> count 0) - (setq expansion (dabbrev--search abbrev - reverse - ignore-case))) - (setq count (1- count)))) - (and expansion - (setq dabbrev--last-expansion-location (point))) - expansion))) + (save-restriction + (widen) + (let ((expansion nil)) + (and dabbrev--last-expansion-location + (goto-char dabbrev--last-expansion-location)) + (let ((case-fold-search ignore-case) + (count n)) + (while (and (> count 0) + (setq expansion (dabbrev--search abbrev + reverse + ignore-case))) + (setq count (1- count)))) + (and expansion + (setq dabbrev--last-expansion-location (point))) + expansion)))) ;;; Find all expansions of ABBREV (defun dabbrev--find-all-expansions (abbrev ignore-case) @@ -603,7 +579,7 @@ See also `dabbrev-abbrev-char-regexp' and \\[dabbrev-completion]." (save-excursion (goto-char (point-min)) (while (setq expansion (dabbrev--find-expansion abbrev -1 ignore-case)) - (push expansion all-expansions))) + (setq all-expansions (cons expansion all-expansions)))) all-expansions)) (defun dabbrev--scanning-message () @@ -671,7 +647,7 @@ See also `dabbrev-abbrev-char-regexp' and \\[dabbrev-completion]." (let* (friend-buffer-list non-friend-buffer-list) (setq dabbrev--friend-buffer-list (funcall dabbrev-select-buffers-function)) - (if dabbrev-check-rest-of-buffers + (if dabbrev-check-all-buffers (setq non-friend-buffer-list (nreverse (dabbrev-filter-elements @@ -789,7 +765,7 @@ See also `dabbrev-abbrev-char-regexp' and \\[dabbrev-completion]." ;; Put in `dabbrev--last-table' and decide if we should return ;; result or (downcase result) ;;-------------------------------- - (push found-string dabbrev--last-table) + (setq dabbrev--last-table (cons found-string dabbrev--last-table)) (let ((result (buffer-substring (match-beginning 0) (match-end 0)))) (if (and ignore-case (eval dabbrev-case-replace)) (downcase result)