lisp/hippie-exp.el

   1 ;;; hippie-exp.el --- expand text trying various ways to find its expansion
   2
   3 ;; Copyright (C) 1992, 2001, 2002, 2003, 2004, 2005,
   4 ;;   2006, 2007, 2008 Free Software Foundation, Inc.
   5
   6 ;; Author: Anders Holst <aho@sans.kth.se>
   7 ;; Last change: 3 March 1998
   8 ;; Version: 1.6
   9 ;; Keywords: abbrev convenience
  10
  11 ;; This file is part of GNU Emacs.
  12
  13 ;; GNU Emacs is free software: you can redistribute it and/or modify
  14 ;; it under the terms of the GNU General Public License as published by
  15 ;; the Free Software Foundation, either version 3 of the License, or
  16 ;; (at your option) any later version.
  17
  18 ;; GNU Emacs is distributed in the hope that it will be useful,
  19 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  20 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21 ;; GNU General Public License for more details.
  22
  23 ;; You should have received a copy of the GNU General Public License
  24 ;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
  25
  26 ;;; Commentary:
  27
  28 ;;  `hippie-expand' is a single function for a lot of different kinds
  29 ;;  of completions and expansions.  Called repeatedly it tries all
  30 ;;  possible completions in succession.
  31 ;;  Which kinds of completions to try, and in which order, is
  32 ;;  determined by the contents of `hippie-expand-try-functions-list'.
  33 ;;  Much customization of `hippie-expand' can be made by changing the
  34 ;;  order of, removing, or inserting new functions in this list.
  35 ;;  Given a positive numeric argument, `hippie-expand' jumps directly
  36 ;;  ARG functions forward in this list.  Given some other argument
  37 ;;  (a negative argument or just Ctrl-U) it undoes the tried
  38 ;;  completion.
  39 ;;
  40 ;;  If the variable `hippie-expand-verbose' is non-nil, `hippie-expand'
  41 ;;  outputs in a message which try-function in the list that is used
  42 ;;  currently (ie. was used currently and will be tried first the next
  43 ;;  time).
  44 ;;  The variable `hippie-expand-max-buffers' determines in how many
  45 ;;  buffers, apart from the current, to search for expansions in.  It
  46 ;;  is used by the try-functions named "-all-buffers".
  47 ;;  The variable `hippie-expand-ignore-buffers' is a list of regexps
  48 ;;  matching buffer names (as strings) or major modes (as atoms) of
  49 ;;  buffers that should not be searched by the try-functions named
  50 ;;  "-all-buffers".
  51 ;;  If set, the variable `hippie-expand-only-buffers' does the opposite
  52 ;;  of `hippie-expand-ignore-buffers', in that the search is restricted
  53 ;;  to only the kind of buffers listed.
  54 ;;  If the variable `hippie-expand-no-restriction' is non-nil, narrowed
  55 ;;  buffers are widened before they are searched.
  56 ;;  The variable `hippie-expand-dabbrev-skip-space' controls whether
  57 ;;  trailing spaces will be included in the abbreviation to search for,
  58 ;;  which then gives the same behavior as the original `dabbrev-expand'.
  59 ;;  The variable `hippie-expand-dabbrev-as-symbol' controls whether
  60 ;;  characters of syntax '_' is considered part of the words to expand
  61 ;;  dynamically.
  62 ;;  See also the macro `make-hippie-expand-function' below.
  63 ;;
  64 ;;  A short description of the current try-functions in this file:
  65 ;;    `try-complete-file-name' : very convenient to have in any buffer,
  66 ;;      and not just in the minibuffer or (some) shell-mode.  It goes
  67 ;;      through all possible completions instead of just completing as
  68 ;;      much as is unique.
  69 ;;    `try-complete-file-name-partially' : To insert in the list just
  70 ;;      before `try-complete-file-name' for those who want first to get
  71 ;;      a file name completed only as many characters as is unique.
  72 ;;    `try-expand-all-abbrevs' : can be removed if you don't use abbrevs.
  73 ;;      Otherwise it looks through all abbrev-tables, starting with
  74 ;;      the local followed by the global.
  75 ;;    `try-expand-line' : Searches the buffer for an entire line that
  76 ;;      begins exactly as the current line.  Convenient sometimes, for
  77 ;;      example as a substitute for (or complement to) the history
  78 ;;      list in shell-like buffers.  At other times, only confusing.
  79 ;;    `try-expand-line-all-buffers' : Like `try-expand-line' but searches
  80 ;;      in all buffers (except the current).  (This may be a little
  81 ;;      slow, don't use it unless you are really fond of `hippie-expand'.)
  82 ;;    `try-expand-list' : Tries to expand the text back to the nearest
  83 ;;      open delimiter, to a whole list from the buffer. Convenient for
  84 ;;      example when writing lisp or TeX.
  85 ;;    `try-expand-list-all-buffers' : Like `try-expand-list' but searches
  86 ;;      in all buffers (except the current).
  87 ;;    `try-expand-dabbrev' : works exactly as dabbrev-expand (but of
  88 ;;      course in a way compatible with the other try-functions).
  89 ;;    `try-expand-dabbrev-all-buffers' : perhaps the most useful of them,
  90 ;;      like `dabbrev-expand' but searches all Emacs buffers (except the
  91 ;;      current) for matching words.  (No, I don't find this one
  92 ;;      particularly slow.)
  93 ;;    `try-expand-dabbrev-visible': Searches the currently visible parts of
  94 ;;      all windows.  Can be put before `try-expand-dabbrev-all-buffers' to
  95 ;;      first try the expansions you can see.
  96 ;;    `try-expand-dabbrev-from-kill': Searches the kill ring for a suitable
  97 ;;      completion of the word.  Good to have, just in case the word was not
  98 ;;      found elsewhere.
  99 ;;    `try-expand-whole-kill' : Tries to complete text with a whole entry
 100 ;;      from the kill ring.  May be good if you don't know how far up in
 101 ;;      the kill-ring the required entry is, and don't want to mess with
 102 ;;      "Choose Next Paste".
 103 ;;    `try-complete-lisp-symbol' : like `lisp-complete-symbol', but goes
 104 ;;      through all possibilities instead of completing what is unique.
 105 ;;      Might be tedious (usually a lot of possible completions) and
 106 ;;      since its function is much like `lisp-complete-symbol', which
 107 ;;      already has a key of its own, you might want to remove this.
 108 ;;    `try-complete-lisp-symbol-partially' : To insert in the list just
 109 ;;      before `try-complete-lisp-symbol' for those who first want to get
 110 ;;      completion of what is unique in the name.
 111 ;;
 112 ;;  Not all of the above functions are by default in
 113 ;;  `hippie-expand-try-functions-list'.  This variable is better set
 114 ;;  in ".emacs" to make `hippie-expand' behave maximally convenient
 115 ;;  according to personal taste.  Also, instead of loading the
 116 ;;  variable with all kinds of try-functions above, it might be an
 117 ;;  idea to use `make-hippie-expand-function' to construct different
 118 ;;  `hippie-expand'-like functions, with different try-lists and bound
 119 ;;  to different keys. It is also possible to make
 120 ;;  `hippie-expand-try-functions-list' a buffer local variable, and
 121 ;;  let it depend on the mode (by setting it in the mode-hooks).
 122 ;;
 123 ;;  To write new try-functions, consider the following:
 124 ;;  Each try-function takes one argument OLD which is nil the first
 125 ;;  time the function is called and true in succeeding calls for the
 126 ;;  same string to complete.  The first time the function has to
 127 ;;  extract the string before point to complete, and substitute the
 128 ;;  first completion alternative for it.  On following calls it has to
 129 ;;  substitute the next possible completion for the last tried string.
 130 ;;  The try-function is to return t as long as it finds new
 131 ;;  possible completions.  When there are no more alternatives it has
 132 ;;  to restore the text before point to its original contents, and
 133 ;;  return nil (don't beep or message or anything).
 134 ;;  The try-function can (should) use the following functions:
 135 ;;    `he-init-string' : Initializes the text to substitute to the
 136 ;;      contents of the region BEGIN to END.  Also sets the variable
 137 ;;      `he-search-string' to the text to expand.
 138 ;;    `he-substitute-string' : substitutes STR into the region
 139 ;;      initialized with `he-init-string'.  (An optional second argument
 140 ;;      TRANS-CASE non-nil, means transfer of case from the abbreviation
 141 ;;      to the expansion is ok if that is enabled in the buffer.)
 142 ;;    `he-reset-string' : Resets the initialized region to its original
 143 ;;      contents.
 144 ;;  There is also a variable: `he-tried-table' which is meant to contain
 145 ;;  all tried expansions so far.  The try-function can check this
 146 ;;  variable to see whether an expansion has already been tried
 147 ;;  (hint: `he-string-member').
 148 ;;
 149 ;;  Known bugs
 150 ;;
 151 ;;  It may happen that some completion suggestion occurs twice, in
 152 ;;  spite of the use of `he-tried-table' to prevent that.  This is
 153 ;;  because different try-functions may try to complete different
 154 ;;  lengths of text, and thus put different amounts of the
 155 ;;  text in `he-tried-table'.  Anyway this seems to occur seldom enough
 156 ;;  not to be too disturbing.  Also it should NOT be possible for the
 157 ;;  opposite situation to occur, that `hippie-expand' misses some
 158 ;;  suggestion because it thinks it has already tried it.
 159 ;;
 160 ;;  Acknowledgement
 161 ;;
 162 ;;  I want to thank Mikael Djurfeldt in discussions with whom the idea
 163 ;;  of this function took form.
 164 ;;  I am also grateful to all those who have given me suggestions on
 165 ;;  how to improve it, and all those who helped to find and remove bugs.
 166 ;;
 167
 168 ;;; Code:
 169
 170 (eval-when-compile (require 'comint))
 171
 172 (defgroup hippie-expand nil
 173   "Expand text trying various ways to find its expansion."
 174   :link '(custom-manual "(autotype)Hippie Expand")
 175   :link '(emacs-commentary-link "hippie-exp")
 176   :group 'abbrev
 177   :group 'convenience)
 178
 179 (defvar he-num -1)
 180
 181 (defvar he-string-beg (make-marker))
 182
 183 (defvar he-string-end (make-marker))
 184
 185 (defvar he-search-string ())
 186
 187 (defvar he-expand-list ())
 188
 189 (defvar he-tried-table ())
 190
 191 (defvar he-search-loc (make-marker))
 192
 193 (defvar he-search-loc2 ())
 194
 195 (defvar he-search-bw ())
 196
 197 (defvar he-search-bufs ())
 198
 199 (defvar he-searched-n-bufs ())
 200
 201 (defvar he-search-window ())
 202
 203 ;;;###autoload
 204 (defcustom hippie-expand-try-functions-list
 205   '(try-complete-file-name-partially
 206     try-complete-file-name
 207     try-expand-all-abbrevs
 208     try-expand-list
 209     try-expand-line
 210     try-expand-dabbrev
 211     try-expand-dabbrev-all-buffers
 212     try-expand-dabbrev-from-kill
 213     try-complete-lisp-symbol-partially
 214     try-complete-lisp-symbol)
 215   "The list of expansion functions tried in order by `hippie-expand'.
 216 To change the behavior of `hippie-expand', remove, change the order of,
 217 or insert functions in this list."
 218   :type '(repeat function)
 219   :group 'hippie-expand)
 220
 221 ;;;###autoload
 222 (defcustom hippie-expand-verbose t
 223   "*Non-nil makes `hippie-expand' output which function it is trying."
 224   :type 'boolean
 225   :group 'hippie-expand)
 226
 227 ;;;###autoload
 228 (defcustom hippie-expand-dabbrev-skip-space nil
 229   "*Non-nil means tolerate trailing spaces in the abbreviation to expand."
 230   :group 'hippie-expand
 231   :type 'boolean)
 232
 233 ;;;###autoload
 234 (defcustom hippie-expand-dabbrev-as-symbol t
 235   "*Non-nil means expand as symbols, i.e. syntax `_' is considered a letter."
 236   :group 'hippie-expand
 237   :type 'boolean)
 238
 239 ;;;###autoload
 240 (defcustom hippie-expand-no-restriction t
 241   "*Non-nil means that narrowed buffers are widened during search."
 242   :group 'hippie-expand
 243   :type 'boolean)
 244
 245 ;;;###autoload
 246 (defcustom hippie-expand-max-buffers ()
 247   "*The maximum number of buffers (apart from the current) searched.
 248 If nil, all buffers are searched."
 249   :type '(choice (const :tag "All" nil)
 250                  integer)
 251   :group 'hippie-expand)
 252
 253 ;;;###autoload
 254 (defcustom hippie-expand-ignore-buffers '("^ \\*.*\\*$" dired-mode)
 255   "*A list specifying which buffers not to search (if not current).
 256 Can contain both regexps matching buffer names (as strings) and major modes
 257 \(as atoms)"
 258   :type '(repeat (choice regexp (symbol :tag "Major Mode")))
 259   :group 'hippie-expand)
 260
 261 ;;;###autoload
 262 (defcustom hippie-expand-only-buffers ()
 263   "*A list specifying the only buffers to search (in addition to current).
 264 Can contain both regexps matching buffer names (as strings) and major modes
 265 \(as atoms).  If non-nil, this variable overrides the variable
 266 `hippie-expand-ignore-buffers'."
 267   :type '(repeat (choice regexp (symbol :tag "Major Mode")))
 268   :group 'hippie-expand)
 269
 270 ;;;###autoload
 271 (defun hippie-expand (arg)
 272   "Try to expand text before point, using multiple methods.
 273 The expansion functions in `hippie-expand-try-functions-list' are
 274 tried in order, until a possible expansion is found.  Repeated
 275 application of `hippie-expand' inserts successively possible
 276 expansions.
 277 With a positive numeric argument, jumps directly to the ARG next
 278 function in this list.  With a negative argument or just \\[universal-argument],
 279 undoes the expansion."
 280   (interactive "P")
 281   (if (or (not arg)
 282           (and (integerp arg) (> arg 0)))
 283       (let ((first (or (= he-num -1)
 284                        (not (equal this-command last-command)))))
 285         (if first
 286             (progn
 287               (setq he-num -1)
 288               (setq he-tried-table nil)))
 289         (if arg
 290             (if (not first) (he-reset-string))
 291             (setq arg 0))
 292         (let ((i (max (+ he-num arg) 0)))
 293           (while (not (or (>= i (length hippie-expand-try-functions-list))
 294                           (apply (nth i hippie-expand-try-functions-list)
 295                                  (list (= he-num i)))))
 296             (setq i (1+ i)))
 297           (setq he-num i))
 298         (if (>= he-num (length hippie-expand-try-functions-list))
 299             (progn
 300               (setq he-num -1)
 301               (if first
 302                   (message "No expansion found")
 303                   (message "No further expansions found"))
 304               (ding))
 305             (if (and hippie-expand-verbose
 306                      (not (window-minibuffer-p (selected-window))))
 307                 (message "Using %s"
 308                          (nth he-num hippie-expand-try-functions-list)))))
 309       (if (and (>= he-num 0)
 310                (eq (marker-buffer he-string-beg) (current-buffer)))
 311           (progn
 312             (setq he-num -1)
 313             (he-reset-string)
 314             (if (and hippie-expand-verbose
 315                      (not (window-minibuffer-p (selected-window))))
 316                 (message "Undoing expansions"))))))
 317
 318 ;; Initializes the region to expand (to between BEG and END).
 319 (defun he-init-string (beg end)
 320   (set-marker he-string-beg beg)
 321   (set-marker he-string-end end)
 322   (setq he-search-string (buffer-substring-no-properties beg end)))
 323
 324 ;; Resets the expanded region to its original contents.
 325 (defun he-reset-string ()
 326   (let ((newpos (point-marker)))
 327     (goto-char he-string-beg)
 328     (insert he-search-string)
 329     (delete-region (point) he-string-end)
 330     (goto-char newpos)))
 331
 332 ;; Substitutes an expansion STR into the correct region (the region
 333 ;; initialized with `he-init-string').
 334 ;; An optional argument TRANS-CASE means that it is ok to transfer case
 335 ;; from the abbreviation to the expansion if that is possible, and is
 336 ;; enabled in the buffer.
 337 (defun he-substitute-string (str &optional trans-case)
 338   (let ((trans-case (and trans-case
 339                          case-replace
 340                          case-fold-search))
 341         (newpos (point-marker))
 342         (subst ()))
 343     (goto-char he-string-beg)
 344     (setq subst (if trans-case (he-transfer-case he-search-string str) str))
 345     (setq he-tried-table (cons subst he-tried-table))
 346     (insert subst)
 347     (delete-region (point) he-string-end)
 348     (goto-char newpos)))
 349
 350 (defun he-capitalize-first (str)
 351   (save-match-data
 352     (if (string-match "\\Sw*\\(\\sw\\).*" str)
 353         (let ((res (downcase str))
 354               (no (match-beginning 1)))
 355           (aset res no (upcase (aref str no)))
 356           res)
 357       str)))
 358
 359 (defun he-ordinary-case-p (str)
 360   (or (string= str (downcase str))
 361       (string= str (upcase str))
 362       (string= str (capitalize str))
 363       (string= str (he-capitalize-first str))))
 364
 365 (defun he-transfer-case (from-str to-str)
 366   (cond ((string= from-str (substring to-str 0 (min (length from-str)
 367                                                     (length to-str))))
 368          to-str)
 369         ((not (he-ordinary-case-p to-str))
 370          to-str)
 371         ((string= from-str (downcase from-str))
 372          (downcase to-str))
 373         ((string= from-str (upcase from-str))
 374          (upcase to-str))
 375         ((string= from-str (he-capitalize-first from-str))
 376          (he-capitalize-first to-str))
 377         ((string= from-str (capitalize from-str))
 378          (capitalize to-str))
 379         (t
 380          to-str)))
 381
 382
 383 ;; Check if STR is a member of LST.
 384 ;; Transform to the final case if optional TRANS-CASE is non-nil.
 385 (defun he-string-member (str lst &optional trans-case)
 386   (if str
 387       (member (if (and trans-case
 388                        case-replace
 389                        case-fold-search)
 390                   (he-transfer-case he-search-string str)
 391                 str)
 392               lst)))
 393
 394 ;; Check if current buffer matches any atom or regexp in LST.
 395 ;; Atoms are interpreted as major modes, strings as regexps mathing the name.
 396 (defun he-buffer-member (lst)
 397   (or (memq major-mode lst)
 398       (progn
 399         (while (and lst
 400                     (or (not (stringp (car lst)))
 401                         (not (string-match (car lst) (buffer-name)))))
 402           (setq lst (cdr lst)))
 403         lst)))
 404
 405 ;;  For the real hippie-expand enthusiast: A macro that makes it
 406 ;;  possible to use many functions like hippie-expand, but with
 407 ;;  different try-functions-lists.
 408 ;;  Usage is for example:
 409 ;;    (fset 'my-complete-file (make-hippie-expand-function
 410 ;;                             '(try-complete-file-name-partially
 411 ;;                               try-complete-file-name)))
 412 ;;    (fset 'my-complete-line (make-hippie-expand-function
 413 ;;                             '(try-expand-line
 414 ;;                               try-expand-line-all-buffers)))
 415 ;;
 416 ;;;###autoload
 417 (defmacro make-hippie-expand-function (try-list &optional verbose)
 418   "Construct a function similar to `hippie-expand'.
 419 Make it use the expansion functions in TRY-LIST.  An optional second
 420 argument VERBOSE non-nil makes the function verbose."
 421   `(function (lambda (arg)
 422     ,(concat
 423       "Try to expand text before point, using the following functions: \n"
 424       (mapconcat 'prin1-to-string (eval try-list) ", "))
 425     (interactive "P")
 426     (let ((hippie-expand-try-functions-list ,try-list)
 427           (hippie-expand-verbose ,verbose))
 428       (hippie-expand arg)))))
 429
 430
 431 ;;;  Here follows the try-functions and their requisites:
 432
 433
 434 (defun try-complete-file-name (old)
 435   "Try to complete text as a file name.
 436 The argument OLD has to be nil the first call of this function, and t
 437 for subsequent calls (for further possible completions of the same
 438 string).  It returns t if a new completion is found, nil otherwise."
 439   (if (not old)
 440       (progn
 441         (he-init-string (he-file-name-beg) (point))
 442         (let ((name-part (he-file-name-nondirectory he-search-string))
 443               (dir-part (expand-file-name (or (he-file-name-directory
 444                                                he-search-string) ""))))
 445           (if (not (he-string-member name-part he-tried-table))
 446               (setq he-tried-table (cons name-part he-tried-table)))
 447           (if (and (not (equal he-search-string ""))
 448                    (he-file-directory-p dir-part))
 449               (setq he-expand-list (sort (file-name-all-completions
 450                                           name-part
 451                                           dir-part)
 452                                          'string-lessp))
 453               (setq he-expand-list ())))))
 454
 455   (while (and he-expand-list
 456               (he-string-member (car he-expand-list) he-tried-table))
 457     (setq he-expand-list (cdr he-expand-list)))
 458   (if (null he-expand-list)
 459       (progn
 460         (if old (he-reset-string))
 461         ())
 462       (let ((filename (he-concat-directory-file-name
 463                        (he-file-name-directory he-search-string)
 464                        (car he-expand-list))))
 465         (he-substitute-string filename)
 466         (setq he-tried-table (cons (car he-expand-list) (cdr he-tried-table)))
 467         (setq he-expand-list (cdr he-expand-list))
 468         t)))
 469
 470 (defun try-complete-file-name-partially (old)
 471   "Try to complete text as a file name, as many characters as unique.
 472 The argument OLD has to be nil the first call of this function.  It
 473 returns t if a unique, possibly partial, completion is found, nil
 474 otherwise."
 475   (let ((expansion ()))
 476     (if (not old)
 477         (progn
 478           (he-init-string (he-file-name-beg) (point))
 479           (let ((name-part (he-file-name-nondirectory he-search-string))
 480                 (dir-part (expand-file-name (or (he-file-name-directory
 481                                                  he-search-string) ""))))
 482             (if (and (not (equal he-search-string ""))
 483                      (he-file-directory-p dir-part))
 484                 (setq expansion (file-name-completion name-part
 485                                                       dir-part)))
 486             (if (or (eq expansion t)
 487                     (string= expansion name-part)
 488                     (he-string-member expansion he-tried-table))
 489                 (setq expansion ())))))
 490
 491     (if (not expansion)
 492         (progn
 493           (if old (he-reset-string))
 494           ())
 495         (let ((filename (he-concat-directory-file-name
 496                          (he-file-name-directory he-search-string)
 497                          expansion)))
 498           (he-substitute-string filename)
 499           (setq he-tried-table (cons expansion (cdr he-tried-table)))
 500           t))))
 501
 502 (defvar he-file-name-chars
 503   (cond ((memq system-type '(vax-vms axp-vms))
 504          "-a-zA-Z0-9_/.,~^#$+=:\\[\\]")
 505         ((memq system-type '(ms-dos windows-nt cygwin))
 506          "-a-zA-Z0-9_/.,~^#$+=:\\\\")
 507         (t                          ;; More strange file formats ?
 508          "-a-zA-Z0-9_/.,~^#$+="))
 509   "Characters that are considered part of the file name to expand.")
 510
 511 (defun he-file-name-beg ()
 512   (let ((op (point)))
 513     (save-excursion
 514       (skip-chars-backward he-file-name-chars)
 515       (if (> (skip-syntax-backward "w") 0)  ;; No words with non-file chars
 516           op
 517         (point)))))
 518
 519 ;; Thanks go to Richard Levitte <levitte@e.kth.se> who helped to make these
 520 ;; work under VMS, and to David Hughes <ukchugd@ukpmr.cs.philips.nl> who
 521 ;; helped to make it work on PC.
 522 (defun he-file-name-nondirectory (file)
 523   "Fix to make `file-name-nondirectory' work for hippie-expand under VMS."
 524   (if (memq system-type '(axp-vms vax-vms))
 525       (let ((n (file-name-nondirectory file)))
 526         (if (string-match "^\\(\\[.*\\)\\.\\([^\\.]*\\)$" n)
 527             (concat "[." (substring n (match-beginning 2) (match-end 2)))
 528           n))
 529     (file-name-nondirectory file)))
 530
 531 (defun he-file-name-directory (file)
 532   "Fix to make `file-name-directory' work for hippie-expand under VMS."
 533   (if (memq system-type '(axp-vms vax-vms))
 534       (let ((n (file-name-nondirectory file))
 535             (d (file-name-directory file)))
 536         (if (string-match "^\\(\\[.*\\)\\.\\([^\\.]*\\)$" n)
 537             (concat d (substring n (match-beginning 1) (match-end 1)) "]")
 538           d))
 539     (file-name-directory file)))
 540
 541 (defun he-file-directory-p (file)
 542   "Fix to make `file-directory-p' work for hippie-expand under VMS."
 543   (if (memq system-type '(vax-vms axp-vms))
 544       (or (file-directory-p file)
 545           (file-directory-p (concat file "[000000]")))
 546     (file-directory-p file)))
 547
 548 (defun he-concat-directory-file-name (dir-part name-part)
 549   "Try to slam together two parts of a file specification, system dependently."
 550   (cond ((null dir-part) name-part)
 551         ((memq system-type '(axp-vms vax-vms))
 552          (if (and (string= (substring dir-part -1) "]")
 553                   (string= (substring name-part 0 2) "[."))
 554              (concat (substring dir-part 0 -1) (substring name-part 1))
 555            (concat dir-part name-part)))
 556         ((memq system-type '(ms-dos w32))
 557          (if (and (string-match "\\\\" dir-part)
 558                   (not (string-match "/" dir-part))
 559                   (= (aref name-part (1- (length name-part))) ?/))
 560              (aset name-part (1- (length name-part)) ?\\))
 561          (concat dir-part name-part))
 562         (t
 563          (concat dir-part name-part))))
 564
 565 (defun try-complete-lisp-symbol (old)
 566   "Try to complete word as an Emacs Lisp symbol.
 567 The argument OLD has to be nil the first call of this function, and t
 568 for subsequent calls (for further possible completions of the same
 569 string).  It returns t if a new completion is found, nil otherwise."
 570   (if (not old)
 571       (progn
 572         (he-init-string (he-lisp-symbol-beg) (point))
 573         (if (not (he-string-member he-search-string he-tried-table))
 574             (setq he-tried-table (cons he-search-string he-tried-table)))
 575         (setq he-expand-list
 576               (and (not (equal he-search-string ""))
 577                    (sort (all-completions he-search-string obarray
 578                                           (function (lambda (sym)
 579                                             (or (boundp sym)
 580                                                 (fboundp sym)
 581                                                 (symbol-plist sym)))))
 582                          'string-lessp)))))
 583   (while (and he-expand-list
 584               (he-string-member (car he-expand-list) he-tried-table))
 585     (setq he-expand-list (cdr he-expand-list)))
 586   (if (null he-expand-list)
 587       (progn
 588         (if old (he-reset-string))
 589         ())
 590       (progn
 591         (he-substitute-string (car he-expand-list))
 592         (setq he-expand-list (cdr he-expand-list))
 593         t)))
 594
 595 (defun try-complete-lisp-symbol-partially (old)
 596   "Try to complete as an Emacs Lisp symbol, as many characters as unique.
 597 The argument OLD has to be nil the first call of this function.  It
 598 returns t if a unique, possibly partial, completion is found, nil
 599 otherwise."
 600   (let ((expansion ()))
 601     (if (not old)
 602         (progn
 603           (he-init-string (he-lisp-symbol-beg) (point))
 604           (if (not (string= he-search-string ""))
 605               (setq expansion
 606                     (try-completion he-search-string obarray
 607                                     (function (lambda (sym)
 608                                       (or (boundp sym)
 609                                           (fboundp sym)
 610                                           (symbol-plist sym)))))))
 611           (if (or (eq expansion t)
 612                   (string= expansion he-search-string)
 613                   (he-string-member expansion he-tried-table))
 614               (setq expansion ()))))
 615
 616   (if (not expansion)
 617       (progn
 618         (if old (he-reset-string))
 619         ())
 620       (progn
 621         (he-substitute-string expansion)
 622         t))))
 623
 624 (defun he-lisp-symbol-beg ()
 625   (save-excursion
 626     (skip-syntax-backward "w_")
 627     (point)))
 628
 629 (defun try-expand-line (old)
 630   "Try to complete the current line to an entire line in the buffer.
 631 The argument OLD has to be nil the first call of this function, and t
 632 for subsequent calls (for further possible completions of the same
 633 string).  It returns t if a new completion is found, nil otherwise."
 634   (let ((expansion ())
 635         (strip-prompt (and (get-buffer-process (current-buffer))
 636                            comint-use-prompt-regexp
 637                            comint-prompt-regexp)))
 638     (if (not old)
 639         (progn
 640           (he-init-string (he-line-beg strip-prompt) (point))
 641           (set-marker he-search-loc he-string-beg)
 642           (setq he-search-bw t)))
 643
 644     (if (not (equal he-search-string ""))
 645         (save-excursion
 646           (save-restriction
 647             (if hippie-expand-no-restriction
 648                 (widen))
 649             ;; Try looking backward unless inhibited.
 650             (if he-search-bw
 651                 (progn
 652                   (goto-char he-search-loc)
 653                   (setq expansion (he-line-search he-search-string
 654                                                   strip-prompt t))
 655                   (set-marker he-search-loc (point))
 656                   (if (not expansion)
 657                       (progn
 658                         (set-marker he-search-loc he-string-end)
 659                         (setq he-search-bw ())))))
 660
 661             (if (not expansion) ; Then look forward.
 662                 (progn
 663                   (goto-char he-search-loc)
 664                   (setq expansion (he-line-search he-search-string
 665                                                   strip-prompt nil))
 666                   (set-marker he-search-loc (point)))))))
 667
 668     (if (not expansion)
 669         (progn
 670           (if old (he-reset-string))
 671           ())
 672         (progn
 673           (he-substitute-string expansion t)
 674           t))))
 675
 676 (defun try-expand-line-all-buffers (old)
 677   "Try to complete the current line, searching all other buffers.
 678 The argument OLD has to be nil the first call of this function, and t
 679 for subsequent calls (for further possible completions of the same
 680 string).  It returns t if a new completion is found, nil otherwise."
 681   (let ((expansion ())
 682         (strip-prompt (and (get-buffer-process (current-buffer))
 683                            comint-use-prompt-regexp
 684                            comint-prompt-regexp))
 685         (buf (current-buffer))
 686         (orig-case-fold-search case-fold-search))
 687     (if (not old)
 688         (progn
 689           (he-init-string (he-line-beg strip-prompt) (point))
 690           (setq he-search-bufs (buffer-list))
 691           (setq he-searched-n-bufs 0)
 692           (set-marker he-search-loc 1 (car he-search-bufs))))
 693
 694     (if (not (equal he-search-string ""))
 695         (while (and he-search-bufs
 696                     (not expansion)
 697                     (or (not hippie-expand-max-buffers)
 698                         (< he-searched-n-bufs hippie-expand-max-buffers)))
 699           (set-buffer (car he-search-bufs))
 700           (if (and (not (eq (current-buffer) buf))
 701                    (if hippie-expand-only-buffers
 702                        (he-buffer-member hippie-expand-only-buffers)
 703                      (not (he-buffer-member hippie-expand-ignore-buffers))))
 704               (save-excursion
 705                 (save-restriction
 706                   (if hippie-expand-no-restriction
 707                       (widen))
 708                   (goto-char he-search-loc)
 709                   (setq strip-prompt (and (get-buffer-process (current-buffer))
 710                                           comint-use-prompt-regexp
 711                                           comint-prompt-regexp))
 712                   (setq expansion
 713                         (let ((case-fold-search orig-case-fold-search))
 714                           (he-line-search he-search-string
 715                                           strip-prompt nil)))
 716                   (set-marker he-search-loc (point))
 717                   (if (not expansion)
 718                       (progn
 719                         (setq he-search-bufs (cdr he-search-bufs))
 720                         (setq he-searched-n-bufs (1+ he-searched-n-bufs))
 721                         (set-marker he-search-loc 1 (car he-search-bufs))))))
 722             (setq he-search-bufs (cdr he-search-bufs))
 723             (set-marker he-search-loc 1 (car he-search-bufs)))))
 724
 725     (set-buffer buf)
 726     (if (not expansion)
 727         (progn
 728           (if old (he-reset-string))
 729           ())
 730         (progn
 731           (he-substitute-string expansion t)
 732           t))))
 733
 734 (defun he-line-search (str strip-prompt reverse)
 735   (let ((result ()))
 736     (while (and (not result)
 737                 (if reverse
 738                     (re-search-backward
 739                      (he-line-search-regexp str strip-prompt)
 740                      nil t)
 741                     (re-search-forward
 742                      (he-line-search-regexp str strip-prompt)
 743                      nil t)))
 744       (setq result (buffer-substring-no-properties (match-end 1)
 745                                                    (match-end 0)))
 746       (if (he-string-member result he-tried-table t)
 747           (setq result nil)))               ; if already in table, ignore
 748     result))
 749
 750 (defun he-line-beg (strip-prompt)
 751   (save-excursion
 752     (if (re-search-backward (he-line-search-regexp "" strip-prompt)
 753                             (save-excursion (beginning-of-line)
 754                                             (point)) t)
 755         (match-beginning 2)
 756       (point))))
 757
 758 (defun he-line-search-regexp (pat strip-prompt)
 759   (if strip-prompt
 760       (concat "\\(" comint-prompt-regexp "\\|^\\s-*\\)\\("
 761               (regexp-quote pat)
 762               "[^\n]*[^ \t\n]\\)")
 763       (concat "^\\(\\s-*\\)\\("
 764               (regexp-quote pat)
 765               "[^\n]*[^ \t\n]\\)")))
 766
 767 (defun try-expand-list (old)
 768   "Try to complete the current beginning of a list.
 769 The argument OLD has to be nil the first call of this function, and t
 770 for subsequent calls (for further possible completions of the same
 771 string).  It returns t if a new completion is found, nil otherwise."
 772   (let ((expansion ()))
 773     (if (not old)
 774         (progn
 775           (he-init-string (he-list-beg) (point))
 776           (set-marker he-search-loc he-string-beg)
 777           (setq he-search-bw t)))
 778
 779     (if (not (equal he-search-string ""))
 780         (save-excursion
 781           (save-restriction
 782             (if hippie-expand-no-restriction
 783                 (widen))
 784             ;; Try looking backward unless inhibited.
 785             (if he-search-bw
 786                 (progn
 787                   (goto-char he-search-loc)
 788                   (setq expansion (he-list-search he-search-string t))
 789                   (set-marker he-search-loc (point))
 790                   (if (not expansion)
 791                       (progn
 792                         (set-marker he-search-loc he-string-end)
 793                         (setq he-search-bw ())))))
 794
 795             (if (not expansion) ; Then look forward.
 796                 (progn
 797                   (goto-char he-search-loc)
 798                   (setq expansion (he-list-search he-search-string nil))
 799                   (set-marker he-search-loc (point)))))))
 800
 801     (if (not expansion)
 802         (progn
 803           (if old (he-reset-string))
 804           ())
 805         (progn
 806           (he-substitute-string expansion t)
 807           t))))
 808
 809 (defun try-expand-list-all-buffers (old)
 810   "Try to complete the current list, searching all other buffers.
 811 The argument OLD has to be nil the first call of this function, and t
 812 for subsequent calls (for further possible completions of the same
 813 string).  It returns t if a new completion is found, nil otherwise."
 814   (let ((expansion ())
 815         (buf (current-buffer))
 816         (orig-case-fold-search case-fold-search))
 817     (if (not old)
 818         (progn
 819           (he-init-string (he-list-beg) (point))
 820           (setq he-search-bufs (buffer-list))
 821           (setq he-searched-n-bufs 0)
 822           (set-marker he-search-loc 1 (car he-search-bufs))))
 823
 824     (if (not (equal he-search-string ""))
 825         (while (and he-search-bufs
 826                     (not expansion)
 827                     (or (not hippie-expand-max-buffers)
 828                         (< he-searched-n-bufs hippie-expand-max-buffers)))
 829           (set-buffer (car he-search-bufs))
 830           (if (and (not (eq (current-buffer) buf))
 831                    (if hippie-expand-only-buffers
 832                        (he-buffer-member hippie-expand-only-buffers)
 833                      (not (he-buffer-member hippie-expand-ignore-buffers))))
 834               (save-excursion
 835                 (save-restriction
 836                   (if hippie-expand-no-restriction
 837                       (widen))
 838                   (goto-char he-search-loc)
 839                   (setq expansion
 840                         (let ((case-fold-search orig-case-fold-search))
 841                           (he-list-search he-search-string nil)))
 842                   (set-marker he-search-loc (point))
 843                   (if (not expansion)
 844                       (progn
 845                         (setq he-search-bufs (cdr he-search-bufs))
 846                         (setq he-searched-n-bufs (1+ he-searched-n-bufs))
 847                         (set-marker he-search-loc 1 (car he-search-bufs))))))
 848             (setq he-search-bufs (cdr he-search-bufs))
 849             (set-marker he-search-loc 1 (car he-search-bufs)))))
 850
 851     (set-buffer buf)
 852     (if (not expansion)
 853         (progn
 854           (if old (he-reset-string))
 855           ())
 856         (progn
 857           (he-substitute-string expansion t)
 858           t))))
 859
 860 (defun he-list-search (str reverse)
 861   (let ((result ())
 862         beg pos err)
 863     (while (and (not result)
 864                 (if reverse
 865                     (search-backward str nil t)
 866                     (search-forward str nil t)))
 867       (setq pos (point))
 868       (setq beg (match-beginning 0))
 869       (goto-char beg)
 870       (setq err ())
 871       (condition-case ()
 872           (forward-list 1)
 873         (error (setq err t)))
 874       (if (and reverse
 875                (> (point) he-string-beg))
 876           (setq err t))
 877       (if (not err)
 878           (progn
 879             (setq result (buffer-substring-no-properties beg (point)))
 880             (if (he-string-member result he-tried-table t)
 881                 (setq result nil))))           ; if already in table, ignore
 882       (goto-char pos))
 883     result))
 884
 885 (defun he-list-beg ()
 886   (save-excursion
 887     (condition-case ()
 888         (backward-up-list 1)
 889       (error ()))
 890     (point)))
 891
 892 (defun try-expand-all-abbrevs (old)
 893   "Try to expand word before point according to all abbrev tables.
 894 The argument OLD has to be nil the first call of this function, and t
 895 for subsequent calls (for further possible expansions of the same
 896 string).  It returns t if a new expansion is found, nil otherwise."
 897   (if (not old)
 898       (progn
 899         (he-init-string (he-dabbrev-beg) (point))
 900         (setq he-expand-list
 901               (and (not (equal he-search-string ""))
 902                    (mapcar (function (lambda (sym)
 903                              (if (and (boundp sym) (vectorp (eval sym)))
 904                                  (abbrev-expansion (downcase he-search-string)
 905                                                    (eval sym)))))
 906                            (append '(local-abbrev-table
 907                                      global-abbrev-table)
 908                                    abbrev-table-name-list))))))
 909   (while (and he-expand-list
 910               (or (not (car he-expand-list))
 911                   (he-string-member (car he-expand-list) he-tried-table t)))
 912     (setq he-expand-list (cdr he-expand-list)))
 913   (if (null he-expand-list)
 914       (progn
 915         (if old (he-reset-string))
 916         ())
 917       (progn
 918         (he-substitute-string (car he-expand-list) t)
 919         (setq he-expand-list (cdr he-expand-list))
 920         t)))
 921
 922 (defun try-expand-dabbrev (old)
 923   "Try to expand word \"dynamically\", searching the current buffer.
 924 The argument OLD has to be nil the first call of this function, and t
 925 for subsequent calls (for further possible expansions of the same
 926 string).  It returns t if a new expansion is found, nil otherwise."
 927   (let ((expansion ()))
 928     (if (not old)
 929         (progn
 930           (he-init-string (he-dabbrev-beg) (point))
 931           (set-marker he-search-loc he-string-beg)
 932           (setq he-search-bw t)))
 933
 934     (if (not (equal he-search-string ""))
 935         (save-excursion
 936           (save-restriction
 937             (if hippie-expand-no-restriction
 938                 (widen))
 939             ;; Try looking backward unless inhibited.
 940             (if he-search-bw
 941                 (progn
 942                   (goto-char he-search-loc)
 943                   (setq expansion (he-dabbrev-search he-search-string t))
 944                   (set-marker he-search-loc (point))
 945                   (if (not expansion)
 946                       (progn
 947                         (set-marker he-search-loc he-string-end)
 948                         (setq he-search-bw ())))))
 949
 950             (if (not expansion) ; Then look forward.
 951                 (progn
 952                   (goto-char he-search-loc)
 953                   (setq expansion (he-dabbrev-search he-search-string nil))
 954                   (set-marker he-search-loc (point)))))))
 955
 956     (if (not expansion)
 957         (progn
 958           (if old (he-reset-string))
 959           ())
 960         (progn
 961           (he-substitute-string expansion t)
 962           t))))
 963
 964 (defun try-expand-dabbrev-all-buffers (old)
 965   "Tries to expand word \"dynamically\", searching all other buffers.
 966 The argument OLD has to be nil the first call of this function, and t
 967 for subsequent calls (for further possible expansions of the same
 968 string).  It returns t if a new expansion is found, nil otherwise."
 969   (let ((expansion ())
 970         (buf (current-buffer))
 971         (orig-case-fold-search case-fold-search))
 972     (if (not old)
 973         (progn
 974           (he-init-string (he-dabbrev-beg) (point))
 975           (setq he-search-bufs (buffer-list))
 976           (setq he-searched-n-bufs 0)
 977           (set-marker he-search-loc 1 (car he-search-bufs))))
 978
 979     (if (not (equal he-search-string ""))
 980         (while (and he-search-bufs
 981                     (not expansion)
 982                     (or (not hippie-expand-max-buffers)
 983                         (< he-searched-n-bufs hippie-expand-max-buffers)))
 984           (set-buffer (car he-search-bufs))
 985           (if (and (not (eq (current-buffer) buf))
 986                    (if hippie-expand-only-buffers
 987                        (he-buffer-member hippie-expand-only-buffers)
 988                      (not (he-buffer-member hippie-expand-ignore-buffers))))
 989               (save-excursion
 990                 (save-restriction
 991                   (if hippie-expand-no-restriction
 992                       (widen))
 993                   (goto-char he-search-loc)
 994                   (setq expansion
 995                         (let ((case-fold-search orig-case-fold-search))
 996                           (he-dabbrev-search he-search-string nil)))
 997                   (set-marker he-search-loc (point))
 998                   (if (not expansion)
 999                       (progn
1000                         (setq he-search-bufs (cdr he-search-bufs))
1001                         (setq he-searched-n-bufs (1+ he-searched-n-bufs))
1002                         (set-marker he-search-loc 1 (car he-search-bufs))))))
1003             (setq he-search-bufs (cdr he-search-bufs))
1004             (set-marker he-search-loc 1 (car he-search-bufs)))))
1005
1006     (set-buffer buf)
1007     (if (not expansion)
1008         (progn
1009           (if old (he-reset-string))
1010           ())
1011         (progn
1012           (he-substitute-string expansion t)
1013           t))))
1014
1015 ;; Thanks go to Jeff Dairiki <dairiki@faraday.apl.washington.edu> who
1016 ;; suggested this one.
1017 (defun try-expand-dabbrev-visible (old)
1018   "Try to expand word \"dynamically\", searching visible window parts.
1019 The argument OLD has to be nil the first call of this function, and t
1020 for subsequent calls (for further possible expansions of the same
1021 string).  It returns t if a new expansion is found, nil otherwise."
1022   (let ((expansion ())
1023         (buf (current-buffer))
1024         (flag (if (frame-visible-p (window-frame (selected-window)))
1025                   'visible t)))
1026     (if (not old)
1027         (progn
1028            (he-init-string (he-dabbrev-beg) (point))
1029            (setq he-search-window (selected-window))
1030            (set-marker he-search-loc
1031                        (window-start he-search-window)
1032                        (window-buffer he-search-window))))
1033
1034     (while (and (not (equal he-search-string ""))
1035                 (marker-position he-search-loc)
1036                 (not expansion))
1037       (save-excursion
1038         (set-buffer (marker-buffer he-search-loc))
1039         (goto-char he-search-loc)
1040         (setq expansion (he-dabbrev-search he-search-string ()
1041                                            (window-end he-search-window)))
1042         (if (and expansion
1043                  (eq (marker-buffer he-string-beg) (current-buffer))
1044                  (eq (marker-position he-string-beg) (match-beginning 0)))
1045             (setq expansion (he-dabbrev-search he-search-string ()
1046                                                (window-end he-search-window))))
1047         (set-marker he-search-loc (point) (current-buffer)))
1048       (if (not expansion)
1049           (progn
1050             (setq he-search-window (next-window he-search-window nil flag))
1051             (if (eq he-search-window (selected-window))
1052                 (set-marker he-search-loc nil)
1053               (set-marker he-search-loc (window-start he-search-window)
1054                           (window-buffer he-search-window))))))
1055
1056     (set-buffer buf)
1057     (if (not expansion)
1058         (progn
1059           (if old (he-reset-string))
1060           ())
1061         (progn
1062           (he-substitute-string expansion t)
1063           t))))
1064
1065 (defun he-dabbrev-search (pattern &optional reverse limit)
1066   (let ((result ())
1067         (regpat (cond ((not hippie-expand-dabbrev-as-symbol)
1068                        (concat "\\<" (regexp-quote pattern) "\\sw+"))
1069                       ((eq (char-syntax (aref pattern 0)) ?_)
1070                        (concat (regexp-quote pattern) "\\(\\sw\\|\\s_\\)+"))
1071                       (t
1072                        (concat "\\<" (regexp-quote pattern)
1073                                "\\(\\sw\\|\\s_\\)+")))))
1074     (while (and (not result)
1075                 (if reverse
1076                      (re-search-backward regpat limit t)
1077                      (re-search-forward regpat limit t)))
1078       (setq result (buffer-substring-no-properties (match-beginning 0)
1079                                                    (match-end 0)))
1080       (if (or (and hippie-expand-dabbrev-as-symbol
1081                    (> (match-beginning 0) (point-min))
1082                    (memq (char-syntax (char-after (1- (match-beginning 0))))
1083                          '(?_ ?w)))
1084               (he-string-member result he-tried-table t))
1085           (setq result nil)))     ; ignore if bad prefix or already in table
1086     result))
1087
1088 (defun he-dabbrev-beg ()
1089   (let ((op (point)))
1090     (save-excursion
1091       (if hippie-expand-dabbrev-skip-space
1092           (skip-syntax-backward ". "))
1093       (if (= (skip-syntax-backward (if hippie-expand-dabbrev-as-symbol
1094                                        "w_" "w"))
1095              0)
1096           op
1097         (point)))))
1098
1099 (defun try-expand-dabbrev-from-kill (old)
1100   "Try to expand word \"dynamically\", searching the kill ring.
1101 The argument OLD has to be nil the first call of this function, and t
1102 for subsequent calls (for further possible completions of the same
1103 string).  It returns t if a new completion is found, nil otherwise."
1104   (let ((expansion ()))
1105     (if (not old)
1106         (progn
1107           (he-init-string (he-dabbrev-beg) (point))
1108           (setq he-expand-list
1109                 (if (not (equal he-search-string ""))
1110                     kill-ring))
1111           (setq he-search-loc2 0)))
1112     (if (not (equal he-search-string ""))
1113         (setq expansion (he-dabbrev-kill-search he-search-string)))
1114     (if (not expansion)
1115         (progn
1116           (if old (he-reset-string))
1117           ())
1118         (progn
1119           (he-substitute-string expansion t)
1120           t))))
1121
1122 (defun he-dabbrev-kill-search (pattern)
1123   (let ((result ())
1124         (regpat (cond ((not hippie-expand-dabbrev-as-symbol)
1125                        (concat "\\<" (regexp-quote pattern) "\\sw+"))
1126                       ((eq (char-syntax (aref pattern 0)) ?_)
1127                        (concat (regexp-quote pattern) "\\(\\sw\\|\\s_\\)+"))
1128                       (t
1129                        (concat "\\<" (regexp-quote pattern)
1130                                "\\(\\sw\\|\\s_\\)+"))))
1131         (killstr (car he-expand-list)))
1132     (while (and (not result)
1133                 he-expand-list)
1134       (while (and (not result)
1135                   (string-match regpat killstr he-search-loc2))
1136         (setq result (substring killstr (match-beginning 0) (match-end 0)))
1137         (set-text-properties 0 (length result) () result)
1138         (setq he-search-loc2 (1+ (match-beginning 0)))
1139         (if (or (and hippie-expand-dabbrev-as-symbol
1140                      (> (match-beginning 0) 0)
1141                      (memq (char-syntax (aref killstr (1- (match-beginning 0))))
1142                            '(?_ ?w)))
1143                 (he-string-member result he-tried-table t))
1144             (setq result nil)))     ; ignore if bad prefix or already in table
1145       (if (and (not result)
1146                 he-expand-list)
1147           (progn
1148             (setq he-expand-list (cdr he-expand-list))
1149             (setq killstr (car he-expand-list))
1150             (setq he-search-loc2 0))))
1151     result))
1152
1153 (defun try-expand-whole-kill (old)
1154   "Try to complete text with something from the kill ring.
1155 The argument OLD has to be nil the first call of this function, and t
1156 for subsequent calls (for further possible completions of the same
1157 string).  It returns t if a new completion is found, nil otherwise."
1158   (let ((expansion ()))
1159     (if (not old)
1160         (progn
1161           (he-init-string (he-kill-beg) (point))
1162           (if (not (he-string-member he-search-string he-tried-table))
1163               (setq he-tried-table (cons he-search-string he-tried-table)))
1164           (setq he-expand-list
1165                 (if (not (equal he-search-string ""))
1166                     kill-ring))
1167           (setq he-search-loc2 ())))
1168     (if (not (equal he-search-string ""))
1169         (setq expansion (he-whole-kill-search he-search-string)))
1170     (if (not expansion)
1171         (progn
1172           (if old (he-reset-string))
1173           ())
1174         (progn
1175           (he-substitute-string expansion)
1176           t))))
1177
1178 (defun he-whole-kill-search (str)
1179   (let ((case-fold-search ())
1180         (result ())
1181         (str (regexp-quote str))
1182         (killstr (car he-expand-list))
1183         (pos -1))
1184     (while (and (not result)
1185                 he-expand-list)
1186       (if (not he-search-loc2)
1187           (while (setq pos (string-match str killstr (1+ pos)))
1188             (setq he-search-loc2 (cons pos he-search-loc2))))
1189       (while (and (not result)
1190                   he-search-loc2)
1191         (setq pos (car he-search-loc2))
1192         (setq he-search-loc2 (cdr he-search-loc2))
1193         (save-excursion
1194           (goto-char he-string-beg)
1195           (if (and (>= (- (point) pos) (point-min))   ; avoid some string GC
1196                    (eq (char-after (- (point) pos)) (aref killstr 0))
1197                    (search-backward (substring killstr 0 pos)
1198                                     (- (point) pos) t))
1199               (progn
1200                 (setq result (substring killstr pos))
1201                 (set-text-properties 0 (length result) () result))))
1202         (if (and result
1203                  (he-string-member result he-tried-table))
1204             (setq result nil)))     ; ignore if already in table
1205       (if (and (not result)
1206                 he-expand-list)
1207           (progn
1208             (setq he-expand-list (cdr he-expand-list))
1209             (setq killstr (car he-expand-list))
1210             (setq pos -1))))
1211     result))
1212
1213 (defun he-kill-beg ()
1214   (let ((op (point)))
1215     (save-excursion
1216       (skip-syntax-backward "^w_")
1217       (if (= (skip-syntax-backward "w_") 0)
1218           op
1219         (point)))))
1220
1221
1222 (provide 'hippie-exp)
1223
1224 ;; arch-tag: 5e6e00bf-b061-4a7a-9b46-de0ae105ab99
1225 ;;; hippie-exp.el ends here