diff lisp/dabbrev.el @ 267:d83efd759350

Initial revision

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/lisp/dabbrev.el	Mon May 13 21:21:58 1991 +0000
@@ -0,0 +1,258 @@
+;; Dynamic abbreviation package for GNU Emacs.
+;; Copyright (C) 1985, 1986 Free Software Foundation, Inc.
+
+;; 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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+
+; DABBREVS - "Dynamic abbreviations" hack, originally written by Don Morrison
+; for Twenex Emacs.  Converted to mlisp by Russ Fish.  Supports the table
+; feature to avoid hitting the same expansion on re-expand, and the search
+; size limit variable.  Bugs fixed from the Twenex version are flagged by
+; comments starting with ;;; .
+; 
+; converted to elisp by Spencer Thomas.
+; Thoroughly cleaned up by Richard Stallman.
+;  
+; If anyone feels like hacking at it, Bob Keller (Keller@Utah-20) first
+; suggested the beast, and has some good ideas for its improvement, but
+; doesn?tknow TECO (the lucky devil...).  One thing that should definitely
+; be done is adding the ability to search some other buffer(s) if you can?t
+; find the expansion you want in the current one.
+
+;; (defun dabbrevs-help ()
+;;   "Give help about dabbrevs."
+;;   (interactive)
+;;   (&info "emacs" "dabbrevs")	; Select the specific info node.
+;; )
+(provide 'dabbrevs)
+
+(defvar dabbrevs-limit nil
+  "*Limits region searched by `dabbrevs-expand' to this many chars away.")
+(make-variable-buffer-local 'dabbrevs-limit)
+
+(defvar dabbrevs-backward-only nil
+  "*If non-NIL, `dabbrevs-expand' only looks backwards.")
+
+; State vars for dabbrevs-re-expand.
+(defvar last-dabbrevs-table nil
+  "Table of expansions seen so far (local)")
+(make-variable-buffer-local 'last-dabbrevs-table)
+
+(defvar last-dabbrevs-abbreviation ""
+  "Last string we tried to expand (local).")
+(make-variable-buffer-local 'last-dabbrevs-abbreviation)
+
+(defvar last-dabbrevs-direction 0
+  "Direction of last dabbrevs search (local)")
+(make-variable-buffer-local 'last-dabbrevs-direction)
+
+(defvar last-dabbrevs-abbrev-location nil
+  "Location last abbreviation began (local).")
+(make-variable-buffer-local 'last-dabbrevs-abbrev-location)
+
+(defvar last-dabbrevs-expansion nil
+    "Last expansion of an abbreviation. (local)")
+(make-variable-buffer-local 'last-dabbrevs-expansion)
+
+(defvar last-dabbrevs-expansion-location nil
+  "Location the last expansion was found. (local)")
+(make-variable-buffer-local 'last-dabbrevs-expansion-location)
+
+;;;###autoload
+(defun dabbrev-expand (arg)
+  "Expand previous word \"dynamically\".
+Expands to the most recent, preceding word for which this is a prefix.
+If no suitable preceding word is found, words following point are considered.
+
+If `case-fold-search' and `case-replace' are non-nil (usually true)
+then the substituted word may be case-adjusted to match the abbreviation
+that you had typed.  This takes place if the substituted word, as found,
+is all lower case, or if it is at the beginning of a sentence and only
+its first letter was upper case.
+
+A positive prefix arg N says to take the Nth backward DISTINCT
+possibility.  A negative argument says search forward.  The variable
+`dabbrev-backward-only' may be used to limit the direction of search to
+backward if set non-nil.
+
+If the cursor has not moved from the end of the previous expansion and
+no argument is given, replace the previously-made expansion
+with the next possible expansion not yet tried."
+  (interactive "*P")
+  (let (abbrev expansion old which loc n pattern
+	(do-case (and case-fold-search case-replace)))
+    ;; abbrev -- the abbrev to expand
+    ;; expansion -- the expansion found (eventually) or nil until then
+    ;; old -- the text currently in the buffer
+    ;;    (the abbrev, or the previously-made expansion)
+    ;; loc -- place where expansion is found
+    ;;    (to start search there for next expansion if requested later)
+    ;; do-case -- non-nil if should transform case when substituting.
+    (save-excursion
+      (if (and (null arg)
+	       (eq last-command this-command)
+	       last-dabbrevs-abbrev-location)
+	  (progn
+	    (setq abbrev last-dabbrevs-abbreviation)
+	    (setq old last-dabbrevs-expansion)
+	    (setq which last-dabbrevs-direction))
+	(setq which (if (null arg)
+			(if dabbrevs-backward-only 1 0)
+		        (prefix-numeric-value arg)))
+	(setq loc (point))
+	(forward-word -1)
+	(setq last-dabbrevs-abbrev-location (point)) ; Original location.
+	(setq abbrev (buffer-substring (point) loc))
+	(setq old abbrev)
+	(setq last-dabbrevs-expansion-location nil)
+	(setq last-dabbrev-table nil))  	; Clear table of things seen.
+
+      (setq pattern (concat "\\b" (regexp-quote abbrev) "\\(\\sw\\|\\s_\\)+"))
+      ;; Try looking backward unless inhibited.
+      (if (>= which 0)
+	  (progn 
+	    (setq n (max 1 which))
+	    (if last-dabbrevs-expansion-location
+		(goto-char last-dabbrevs-expansion-location))
+	    (while (and (> n 0)
+			(setq expansion (dabbrevs-search pattern t do-case)))
+	      (setq loc (point-marker))
+	      (setq last-dabbrev-table (cons expansion last-dabbrev-table))
+	      (setq n (1- n)))
+	    (or expansion
+		(setq last-dabbrevs-expansion-location nil))
+	    (setq last-dabbrevs-direction (min 1 which))))
+
+      (if (and (<= which 0) (not expansion)) ; Then look forward.
+	  (progn 
+	    (setq n (max 1 (- which)))
+	    (if last-dabbrevs-expansion-location
+		(goto-char last-dabbrevs-expansion-location))
+	    (while (and (> n 0)
+			(setq expansion (dabbrevs-search pattern nil do-case)))
+	      (setq loc (point-marker))
+	      (setq last-dabbrev-table (cons expansion last-dabbrev-table))
+	      (setq n (1- n)))
+	    (setq last-dabbrevs-direction -1))))
+
+    (if (not expansion)
+	(let ((first (string= abbrev old)))
+	  (setq last-dabbrevs-abbrev-location nil)
+	  (if (not first)
+	      (progn (undo-boundary)
+		     (delete-backward-char (length old))
+		     (insert abbrev)))
+	  (error (if first
+		     "No dynamic expansion for \"%s\" found."
+		     "No further dynamic expansions for \"%s\" found.")
+		 abbrev))
+      ;; Success: stick it in and return.
+      (undo-boundary)
+      (search-backward old)
+      ;; Make case of replacement conform to case of abbreviation
+      ;; provided (1) that kind of thing is enabled in this buffer
+      ;; and (2) the replacement itself is all lower case.
+      ;; First put back the original abbreviation with its original
+      ;; case pattern.
+      (save-excursion
+	(replace-match abbrev t 'literal))
+      (search-forward abbrev)
+      (let ((do-case (and do-case
+			  (string= (substring expansion 1)
+				   (downcase (substring expansion 1))))))
+	;; First put back the original abbreviation with its original
+	;; case pattern.
+	(save-excursion
+	  (replace-match abbrev t 'literal))
+	(search-forward abbrev)
+	(replace-match (if do-case (downcase expansion) expansion)
+		       (not do-case)
+		       'literal))
+      ;; Save state for re-expand.
+      (setq last-dabbrevs-abbreviation abbrev)
+      (setq last-dabbrevs-expansion expansion)
+      (setq last-dabbrevs-expansion-location loc))))
+
+;;;###autoload
+(define-key esc-map "/" 'dabbrev-expand)
+
+
+;; Search function used by dabbrevs library.  
+;; First arg is string to find as prefix of word.  Second arg is
+;; t for reverse search, nil for forward.  Variable dabbrevs-limit
+;; controls the maximum search region size.
+
+;; Table of expansions already seen is examined in buffer last-dabbrev-table,
+;; so that only distinct possibilities are found by dabbrevs-re-expand.
+;; Note that to prevent finding the abbrev itself it must have been
+;; entered in the table.
+
+;; IGNORE-CASE non-nil means treat case as insignificant while
+;; looking for a match and when comparing with previous matches.
+;; Also if that's non-nil and the match is found at the beginning of a sentence
+;; and is in lower case except for the initial
+;; then it is converted to all lower case for return.
+
+;; Value is the expansion, or nil if not found.  After a successful
+;; search, point is left right after the expansion found.
+
+(defun dabbrevs-search (pattern reverse ignore-case)
+  (let (missing result (case-fold-search ignore-case))
+    (save-restriction 	    ; Uses restriction for limited searches.
+      (if dabbrevs-limit
+	  (narrow-to-region last-dabbrevs-abbrev-location
+			    (+ (point)
+			       (* dabbrevs-limit (if reverse -1 1)))))
+      ;; Keep looking for a distinct expansion.
+      (setq result nil)
+      (setq missing nil)
+      (while  (and (not result) (not missing))
+	; Look for it, leave loop if search fails.
+	(setq missing
+	      (not (if reverse
+		       (re-search-backward pattern nil t)
+		       (re-search-forward pattern nil t))))
+
+	(if (not missing)
+	    (progn
+	      (setq result (buffer-substring (match-beginning 0)
+					     (match-end 0)))
+	      (let* ((test last-dabbrev-table))
+		(while (and test
+			    (not
+			     (if ignore-case
+				 (string= (downcase (car test))
+					  (downcase result))
+			       (string= (car test) result))))
+		  (setq test (cdr test)))
+		(if test (setq result nil))))))	; if already in table, ignore
+      (if result
+	  (save-excursion
+	    (let ((beg (match-beginning 0)))
+	      (goto-char beg)
+	      (and ignore-case
+		   (string= (substring result 1)
+			    (downcase (substring result 1)))
+		   (if (string= paragraph-start
+				(concat "^$\\|" page-delimiter))
+		       (and (re-search-backward sentence-end nil t)
+			    (= (match-end 0) beg))
+		     (forward-char 1)
+		     (backward-sentence)
+		     (= (point) beg))
+		   (setq result (downcase result))))))
+      result)))