lisp/abbrev.el

   1 ;;; abbrev.el --- abbrev mode commands for Emacs
   2
   3 ;; Copyright (C) 1985, 1986, 1987, 1992, 2001, 2002, 2003, 2004,
   4 ;;   2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
   5
   6 ;; Maintainer: FSF
   7 ;; Keywords: abbrev convenience
   8
   9 ;; This file is part of GNU Emacs.
  10
  11 ;; GNU Emacs is free software: you can redistribute it and/or modify
  12 ;; it under the terms of the GNU General Public License as published by
  13 ;; the Free Software Foundation, either version 3 of the License, or
  14 ;; (at your option) any later version.
  15
  16 ;; GNU Emacs is distributed in the hope that it will be useful,
  17 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 ;; GNU General Public License for more details.
  20
  21 ;; You should have received a copy of the GNU General Public License
  22 ;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
  23
  24 ;;; Commentary:
  25
  26 ;; This facility is documented in the Emacs Manual.
  27
  28 ;; Todo:
  29
  30 ;; - Make abbrev-file-name obey user-emacs-directory.
  31 ;; - Cleanup name space.
  32
  33 ;;; Code:
  34
  35 (eval-when-compile (require 'cl))
  36
  37 (defgroup abbrev-mode nil
  38   "Word abbreviations mode."
  39   :link '(custom-manual "(emacs)Abbrevs")
  40   :group 'abbrev)
  41
  42 (defcustom only-global-abbrevs nil
  43   "Non-nil means user plans to use global abbrevs only.
  44 This makes the commands that normally define mode-specific abbrevs
  45 define global abbrevs instead."
  46   :type 'boolean
  47   :group 'abbrev-mode
  48   :group 'convenience)
  49
  50 (define-minor-mode abbrev-mode
  51   "Toggle Abbrev mode in the current buffer.
  52 With optional argument ARG, turn abbrev mode on if ARG is
  53 positive, otherwise turn it off.  In Abbrev mode, inserting an
  54 abbreviation causes it to expand and be replaced by its expansion.")
  55
  56 (defcustom abbrev-mode nil
  57   "Enable or disable Abbrev mode.
  58 Non-nil means automatically expand abbrevs as they are inserted.
  59
  60 Setting this variable with `setq' changes it for the current buffer.
  61 Changing it with \\[customize] sets the default value.
  62 Interactively, use the command `abbrev-mode'
  63 to enable or disable Abbrev mode in the current buffer."
  64   :type 'boolean
  65   :group 'abbrev-mode)
  66 (put 'abbrev-mode 'safe-local-variable 'booleanp)
  67
  68 \f
  69 (defvar edit-abbrevs-map
  70   (let ((map (make-sparse-keymap)))
  71     (define-key map "\C-x\C-s" 'edit-abbrevs-redefine)
  72     (define-key map "\C-c\C-c" 'edit-abbrevs-redefine)
  73     map)
  74   "Keymap used in `edit-abbrevs'.")
  75
  76 (defun kill-all-abbrevs ()
  77   "Undefine all defined abbrevs."
  78   (interactive)
  79   (dolist (tablesym abbrev-table-name-list)
  80     (clear-abbrev-table (symbol-value tablesym))))
  81
  82 (defun copy-abbrev-table (table)
  83   "Make a new abbrev-table with the same abbrevs as TABLE."
  84   (let ((new-table (make-abbrev-table)))
  85     (mapatoms
  86      (lambda (symbol)
  87        (define-abbrev new-table
  88          (symbol-name symbol)
  89          (symbol-value symbol)
  90          (symbol-function symbol)))
  91      table)
  92     new-table))
  93
  94 (defun insert-abbrevs ()
  95   "Insert after point a description of all defined abbrevs.
  96 Mark is set after the inserted text."
  97   (interactive)
  98   (push-mark
  99    (save-excursion
 100      (dolist (tablesym abbrev-table-name-list)
 101        (insert-abbrev-table-description tablesym t))
 102      (point))))
 103
 104 (defun list-abbrevs (&optional local)
 105   "Display a list of defined abbrevs.
 106 If LOCAL is non-nil, interactively when invoked with a
 107 prefix arg, display only local, i.e. mode-specific, abbrevs.
 108 Otherwise display all abbrevs."
 109   (interactive "P")
 110   (display-buffer (prepare-abbrev-list-buffer local)))
 111
 112 (defun abbrev-table-name (table)
 113   "Value is the name of abbrev table TABLE."
 114   (let ((tables abbrev-table-name-list)
 115         found)
 116     (while (and (not found) tables)
 117       (when (eq (symbol-value (car tables)) table)
 118         (setq found (car tables)))
 119       (setq tables (cdr tables)))
 120     found))
 121
 122 (defun prepare-abbrev-list-buffer (&optional local)
 123   (with-current-buffer (get-buffer-create "*Abbrevs*")
 124     (erase-buffer)
 125     (if local
 126         (insert-abbrev-table-description
 127          (abbrev-table-name local-abbrev-table) t)
 128       (dolist (table abbrev-table-name-list)
 129         (insert-abbrev-table-description table t)))
 130     (goto-char (point-min))
 131     (set-buffer-modified-p nil)
 132     (edit-abbrevs-mode)
 133     (current-buffer)))
 134
 135 (defun edit-abbrevs-mode ()
 136   "Major mode for editing the list of abbrev definitions.
 137 \\{edit-abbrevs-map}"
 138   (interactive)
 139   (kill-all-local-variables)
 140   (setq major-mode 'edit-abbrevs-mode)
 141   (setq mode-name "Edit-Abbrevs")
 142   (use-local-map edit-abbrevs-map)
 143   (run-mode-hooks 'edit-abbrevs-mode-hook))
 144
 145 (defun edit-abbrevs ()
 146   "Alter abbrev definitions by editing a list of them.
 147 Selects a buffer containing a list of abbrev definitions.
 148 You can edit them and type \\<edit-abbrevs-map>\\[edit-abbrevs-redefine] to redefine abbrevs
 149 according to your editing.
 150 Buffer contains a header line for each abbrev table,
 151  which is the abbrev table name in parentheses.
 152 This is followed by one line per abbrev in that table:
 153 NAME   USECOUNT   EXPANSION   HOOK
 154 where NAME and EXPANSION are strings with quotes,
 155 USECOUNT is an integer, and HOOK is any valid function
 156 or may be omitted (it is usually omitted)."
 157   (interactive)
 158   (switch-to-buffer (prepare-abbrev-list-buffer)))
 159
 160 (defun edit-abbrevs-redefine ()
 161   "Redefine abbrevs according to current buffer contents."
 162   (interactive)
 163   (save-restriction
 164     (widen)
 165     (define-abbrevs t)
 166     (set-buffer-modified-p nil)))
 167
 168 (defun define-abbrevs (&optional arg)
 169   "Define abbrevs according to current visible buffer contents.
 170 See documentation of `edit-abbrevs' for info on the format of the
 171 text you must have in the buffer.
 172 With argument, eliminate all abbrev definitions except
 173 the ones defined from the buffer now."
 174   (interactive "P")
 175   (if arg (kill-all-abbrevs))
 176   (save-excursion
 177     (goto-char (point-min))
 178     (while (and (not (eobp)) (re-search-forward "^(" nil t))
 179       (let* ((buf (current-buffer))
 180              (table (read buf))
 181              abbrevs name hook exp count sys)
 182         (forward-line 1)
 183         (while (progn (forward-line 1)
 184                       (not (eolp)))
 185           (setq name (read buf) count (read buf))
 186           (if (equal count '(sys))
 187               (setq sys t count (read buf)))
 188           (setq exp (read buf))
 189           (skip-chars-backward " \t\n\f")
 190           (setq hook (if (not (eolp)) (read buf)))
 191           (skip-chars-backward " \t\n\f")
 192           (setq abbrevs (cons (list name exp hook count sys) abbrevs)))
 193         (define-abbrev-table table abbrevs)))))
 194
 195 (defun read-abbrev-file (&optional file quietly)
 196   "Read abbrev definitions from file written with `write-abbrev-file'.
 197 Optional argument FILE is the name of the file to read;
 198 it defaults to the value of `abbrev-file-name'.
 199 Optional second argument QUIETLY non-nil means don't display a message."
 200   (interactive
 201    (list
 202     (read-file-name (format "Read abbrev file (default %s): "
 203                             abbrev-file-name)
 204                     nil abbrev-file-name t)))
 205   (load (or file abbrev-file-name) nil quietly)
 206   (setq abbrevs-changed nil))
 207
 208 (defun quietly-read-abbrev-file (&optional file)
 209   "Read abbrev definitions from file written with `write-abbrev-file'.
 210 Optional argument FILE is the name of the file to read;
 211 it defaults to the value of `abbrev-file-name'.
 212 Does not display any message."
 213                                         ;(interactive "fRead abbrev file: ")
 214   (read-abbrev-file file t))
 215
 216 (defun write-abbrev-file (&optional file)
 217   "Write all user-level abbrev definitions to a file of Lisp code.
 218 This does not include system abbrevs; it includes only the abbrev tables
 219 listed in listed in `abbrev-table-name-list'.
 220 The file written can be loaded in another session to define the same abbrevs.
 221 The argument FILE is the file name to write.  If omitted or nil, the file
 222 specified in `abbrev-file-name' is used."
 223   (interactive
 224    (list
 225     (read-file-name "Write abbrev file: "
 226                     (file-name-directory (expand-file-name abbrev-file-name))
 227                     abbrev-file-name)))
 228   (or (and file (> (length file) 0))
 229       (setq file abbrev-file-name))
 230   (let ((coding-system-for-write 'emacs-mule))
 231     (with-temp-file file
 232       (insert ";;-*-coding: emacs-mule;-*-\n")
 233       (dolist (table
 234                ;; We sort the table in order to ease the automatic
 235                ;; merging of different versions of the user's abbrevs
 236                ;; file.  This is useful, for example, for when the
 237                ;; user keeps their home directory in a revision
 238                ;; control system, and is therefore keeping multiple
 239                ;; slightly-differing copies loosely synchronized.
 240                (sort (copy-sequence abbrev-table-name-list)
 241                      (lambda (s1 s2)
 242                        (string< (symbol-name s1)
 243                                 (symbol-name s2)))))
 244         (insert-abbrev-table-description table nil)))))
 245 \f
 246 (defun add-mode-abbrev (arg)
 247   "Define mode-specific abbrev for last word(s) before point.
 248 Argument is how many words before point form the expansion;
 249 or zero means the region is the expansion.
 250 A negative argument means to undefine the specified abbrev.
 251 Reads the abbreviation in the minibuffer.
 252
 253 Don't use this function in a Lisp program; use `define-abbrev' instead."
 254   (interactive "p")
 255   (add-abbrev
 256    (if only-global-abbrevs
 257        global-abbrev-table
 258      (or local-abbrev-table
 259          (error "No per-mode abbrev table")))
 260    "Mode" arg))
 261
 262 (defun add-global-abbrev (arg)
 263   "Define global (all modes) abbrev for last word(s) before point.
 264 The prefix argument specifies the number of words before point that form the
 265 expansion; or zero means the region is the expansion.
 266 A negative argument means to undefine the specified abbrev.
 267 This command uses the minibuffer to read the abbreviation.
 268
 269 Don't use this function in a Lisp program; use `define-abbrev' instead."
 270   (interactive "p")
 271   (add-abbrev global-abbrev-table "Global" arg))
 272
 273 (defun add-abbrev (table type arg)
 274   (let ((exp (and (>= arg 0)
 275                   (buffer-substring-no-properties
 276                    (point)
 277                    (if (= arg 0) (mark)
 278                      (save-excursion (forward-word (- arg)) (point))))))
 279         name)
 280     (setq name
 281           (read-string (format (if exp "%s abbrev for \"%s\": "
 282                                  "Undefine %s abbrev: ")
 283                                type exp)))
 284     (set-text-properties 0 (length name) nil name)
 285     (if (or (null exp)
 286             (not (abbrev-expansion name table))
 287             (y-or-n-p (format "%s expands to \"%s\"; redefine? "
 288                               name (abbrev-expansion name table))))
 289         (define-abbrev table (downcase name) exp))))
 290
 291 (defun inverse-add-mode-abbrev (n)
 292   "Define last word before point as a mode-specific abbrev.
 293 With prefix argument N, defines the Nth word before point.
 294 This command uses the minibuffer to read the expansion.
 295 Expands the abbreviation after defining it."
 296   (interactive "p")
 297   (inverse-add-abbrev
 298    (if only-global-abbrevs
 299        global-abbrev-table
 300      (or local-abbrev-table
 301          (error "No per-mode abbrev table")))
 302    "Mode" n))
 303
 304 (defun inverse-add-global-abbrev (n)
 305   "Define last word before point as a global (mode-independent) abbrev.
 306 With prefix argument N, defines the Nth word before point.
 307 This command uses the minibuffer to read the expansion.
 308 Expands the abbreviation after defining it."
 309   (interactive "p")
 310   (inverse-add-abbrev global-abbrev-table "Global" n))
 311
 312 (defun inverse-add-abbrev (table type arg)
 313   (let (name exp start end)
 314     (save-excursion
 315       (forward-word (1+ (- arg)))
 316       (setq end (point))
 317       (backward-word 1)
 318       (setq start (point)
 319             name (buffer-substring-no-properties start end)))
 320
 321     (setq exp (read-string (format "%s expansion for \"%s\": " type name)
 322                            nil nil nil t))
 323     (when (or (not (abbrev-expansion name table))
 324               (y-or-n-p (format "%s expands to \"%s\"; redefine? "
 325                                 name (abbrev-expansion name table))))
 326       (define-abbrev table (downcase name) exp)
 327       (save-excursion
 328         (goto-char end)
 329         (expand-abbrev)))))
 330
 331 (defun abbrev-prefix-mark (&optional arg)
 332   "Mark current point as the beginning of an abbrev.
 333 Abbrev to be expanded starts here rather than at beginning of word.
 334 This way, you can expand an abbrev with a prefix: insert the prefix,
 335 use this command, then insert the abbrev.  This command inserts a
 336 temporary hyphen after the prefix \(until the intended abbrev
 337 expansion occurs).
 338 If the prefix is itself an abbrev, this command expands it, unless
 339 ARG is non-nil.  Interactively, ARG is the prefix argument."
 340   (interactive "P")
 341   (or arg (expand-abbrev))
 342   (setq abbrev-start-location (point-marker)
 343         abbrev-start-location-buffer (current-buffer))
 344   (insert "-"))
 345
 346 (defun expand-region-abbrevs (start end &optional noquery)
 347   "For abbrev occurrence in the region, offer to expand it.
 348 The user is asked to type `y' or `n' for each occurrence.
 349 A prefix argument means don't query; expand all abbrevs."
 350   (interactive "r\nP")
 351   (save-excursion
 352     (goto-char start)
 353     (let ((lim (- (point-max) end))
 354           pnt string)
 355       (while (and (not (eobp))
 356                   (progn (forward-word 1)
 357                          (<= (setq pnt (point)) (- (point-max) lim))))
 358         (if (abbrev-expansion
 359              (setq string
 360                    (buffer-substring-no-properties
 361                     (save-excursion (forward-word -1) (point))
 362                     pnt)))
 363             (if (or noquery (y-or-n-p (format "Expand `%s'? " string)))
 364                 (expand-abbrev)))))))
 365
 366 ;;; Abbrev properties.
 367
 368 (defun abbrev-table-get (table prop)
 369   "Get the PROP property of abbrev table TABLE."
 370   (let ((sym (intern-soft "" table)))
 371     (if sym (get sym prop))))
 372
 373 (defun abbrev-table-put (table prop val)
 374   "Set the PROP property of abbrev table TABLE to VAL."
 375   (let ((sym (intern "" table)))
 376     (set sym nil)            ; Make sure it won't be confused for an abbrev.
 377     (put sym prop val)))
 378
 379 (defalias 'abbrev-get 'get
 380   "Get the property PROP of abbrev ABBREV
 381
 382 \(fn ABBREV PROP)")
 383
 384 (defalias 'abbrev-put 'put
 385   "Set the property PROP of abbrev ABREV to value VAL.
 386 See `define-abbrev' for the effect of some special properties.
 387
 388 \(fn ABBREV PROP VAL)")
 389
 390 (defmacro abbrev-with-wrapper-hook (var &rest body)
 391   "Run BODY wrapped with the VAR hook.
 392 VAR is a special hook: its functions are called with one argument which
 393 is the \"original\" code (the BODY), so the hook function can wrap the
 394 original function, can call it several times, or even not call it at all.
 395 VAR is normally a symbol (a variable) in which case it is treated like a hook,
 396 with a buffer-local and a global part.  But it can also be an arbitrary expression.
 397 This is similar to an `around' advice."
 398   (declare (indent 1) (debug t))
 399   ;; We need those two gensyms because CL's lexical scoping is not available
 400   ;; for function arguments :-(
 401   (let ((funs (make-symbol "funs"))
 402         (global (make-symbol "global")))
 403     ;; Since the hook is a wrapper, the loop has to be done via
 404     ;; recursion: a given hook function will call its parameter in order to
 405     ;; continue looping.
 406     `(labels ((runrestofhook (,funs ,global)
 407                  ;; `funs' holds the functions left on the hook and `global'
 408                  ;; holds the functions left on the global part of the hook
 409                  ;; (in case the hook is local).
 410                  (lexical-let ((funs ,funs)
 411                                (global ,global))
 412                    (if (consp funs)
 413                        (if (eq t (car funs))
 414                            (runrestofhook (append global (cdr funs)) nil)
 415                          (funcall (car funs)
 416                                   (lambda () (runrestofhook (cdr funs) global))))
 417                      ;; Once there are no more functions on the hook, run
 418                      ;; the original body.
 419                      ,@body))))
 420        (runrestofhook ,var
 421                       ;; The global part of the hook, if any.
 422                       ,(if (symbolp var)
 423                            `(if (local-variable-p ',var)
 424                                 (default-value ',var)))))))
 425
 426
 427 ;;; Code that used to be implemented in src/abbrev.c
 428
 429 (defvar abbrev-table-name-list '(fundamental-mode-abbrev-table
 430                                  global-abbrev-table)
 431   "List of symbols whose values are abbrev tables.")
 432
 433 (defun make-abbrev-table (&optional props)
 434   "Create a new, empty abbrev table object.
 435 PROPS is a list of properties."
 436   ;; The value 59 is an arbitrary prime number.
 437   (let ((table (make-vector 59 0)))
 438     ;; Each abbrev-table has a `modiff' counter which can be used to detect
 439     ;; when an abbreviation was added.  An example of use would be to
 440     ;; construct :regexp dynamically as the union of all abbrev names, so
 441     ;; `modiff' can let us detect that an abbrev was added and hence :regexp
 442     ;; needs to be refreshed.
 443     ;; The presence of `modiff' entry is also used as a tag indicating this
 444     ;; vector is really an abbrev-table.
 445     (abbrev-table-put table :abbrev-table-modiff 0)
 446     (while (consp props)
 447       (abbrev-table-put table (pop props) (pop props)))
 448     table))
 449
 450 (defun abbrev-table-p (object)
 451   (and (vectorp object)
 452        (numberp (abbrev-table-get object :abbrev-table-modiff))))
 453
 454 (defvar global-abbrev-table (make-abbrev-table)
 455   "The abbrev table whose abbrevs affect all buffers.
 456 Each buffer may also have a local abbrev table.
 457 If it does, the local table overrides the global one
 458 for any particular abbrev defined in both.")
 459
 460 (defvar abbrev-minor-mode-table-alist nil
 461   "Alist of abbrev tables to use for minor modes.
 462 Each element looks like (VARIABLE . ABBREV-TABLE);
 463 ABBREV-TABLE is active whenever VARIABLE's value is non-nil.")
 464
 465 (defvar fundamental-mode-abbrev-table
 466   (let ((table (make-abbrev-table)))
 467     ;; Set local-abbrev-table's default to be fundamental-mode-abbrev-table.
 468     (setq-default local-abbrev-table table)
 469     table)
 470   "The abbrev table of mode-specific abbrevs for Fundamental Mode.")
 471
 472 (defvar abbrevs-changed nil
 473   "Set non-nil by defining or altering any word abbrevs.
 474 This causes `save-some-buffers' to offer to save the abbrevs.")
 475
 476 (defcustom abbrev-all-caps nil
 477   "Non-nil means expand multi-word abbrevs all caps if abbrev was so."
 478   :type 'boolean
 479   :group 'abbrev-mode)
 480
 481 (defvar abbrev-start-location nil
 482   "Buffer position for `expand-abbrev' to use as the start of the abbrev.
 483 When nil, use the word before point as the abbrev.
 484 Calling `expand-abbrev' sets this to nil.")
 485
 486 (defvar abbrev-start-location-buffer nil
 487   "Buffer that `abbrev-start-location' has been set for.
 488 Trying to expand an abbrev in any other buffer clears `abbrev-start-location'.")
 489
 490 (defvar last-abbrev nil
 491   "The abbrev-symbol of the last abbrev expanded.  See `abbrev-symbol'.")
 492
 493 (defvar last-abbrev-text nil
 494   "The exact text of the last abbrev expanded.
 495 nil if the abbrev has already been unexpanded.")
 496
 497 (defvar last-abbrev-location 0
 498   "The location of the start of the last abbrev expanded.")
 499
 500 ;; (defvar local-abbrev-table fundamental-mode-abbrev-table
 501 ;;   "Local (mode-specific) abbrev table of current buffer.")
 502 ;; (make-variable-buffer-local 'local-abbrev-table)
 503
 504 (defcustom pre-abbrev-expand-hook nil
 505   "Function or functions to be called before abbrev expansion is done.
 506 This is the first thing that `expand-abbrev' does, and so this may change
 507 the current abbrev table before abbrev lookup happens."
 508   :type 'hook
 509   :group 'abbrev-mode)
 510 (make-obsolete-variable 'pre-abbrev-expand-hook 'abbrev-expand-functions "23.1")
 511
 512 (defun clear-abbrev-table (table)
 513   "Undefine all abbrevs in abbrev table TABLE, leaving it empty."
 514   (setq abbrevs-changed t)
 515   (let* ((sym (intern-soft "" table)))
 516     (dotimes (i (length table))
 517       (aset table i 0))
 518     ;; Preserve the table's properties.
 519     (assert sym)
 520     (let ((newsym (intern "" table)))
 521       (set newsym nil)       ; Make sure it won't be confused for an abbrev.
 522       (setplist newsym (symbol-plist sym)))
 523     (abbrev-table-put table :abbrev-table-modiff
 524                       (1+ (abbrev-table-get table :abbrev-table-modiff))))
 525   ;; For backward compatibility, always return nil.
 526   nil)
 527
 528 (defun define-abbrev (table name expansion &optional hook &rest props)
 529   "Define an abbrev in TABLE named NAME, to expand to EXPANSION and call HOOK.
 530 NAME must be a string, and should be lower-case.
 531 EXPANSION should usually be a string.
 532 To undefine an abbrev, define it with EXPANSION = nil.
 533 If HOOK is non-nil, it should be a function of no arguments;
 534 it is called after EXPANSION is inserted.
 535 If EXPANSION is not a string (and not nil), the abbrev is a
 536  special one, which does not expand in the usual way but only
 537  runs HOOK.
 538
 539 PROPS is a property list.  The following properties are special:
 540 - `:count': the value for the abbrev's usage-count, which is incremented each
 541   time the abbrev is used (the default is zero).
 542 - `:system': if non-nil, says that this is a \"system\" abbreviation
 543   which should not be saved in the user's abbreviation file.
 544   Unless `:system' is `force', a system abbreviation will not
 545   overwrite a non-system abbreviation of the same name.
 546 - `:case-fixed': non-nil means that abbreviations are looked up without
 547   case-folding, and the expansion is not capitalized/upcased.
 548 - `:enable-function': a function of no argument which returns non-nil if the
 549   abbrev should be used for a particular call of `expand-abbrev'.
 550
 551 An obsolete but still supported calling form is:
 552
 553 \(define-abbrev TABLE NAME EXPANSION &optional HOOK COUNT SYSTEM)."
 554   (when (and (consp props) (or (null (car props)) (numberp (car props))))
 555     ;; Old-style calling convention.
 556     (setq props (list* :count (car props)
 557                        (if (cadr props) (list :system (cadr props))))))
 558   (unless (plist-get props :count)
 559     (setq props (plist-put props :count 0)))
 560   (let ((system-flag (plist-get props :system))
 561         (sym (intern name table)))
 562     ;; Don't override a prior user-defined abbrev with a system abbrev,
 563     ;; unless system-flag is `force'.
 564     (unless (and (not (memq system-flag '(nil force)))
 565                  (boundp sym) (symbol-value sym)
 566                  (not (abbrev-get sym :system)))
 567       (unless (or system-flag
 568                   (and (boundp sym) (fboundp sym)
 569                        ;; load-file-name
 570                        (equal (symbol-value sym) expansion)
 571                        (equal (symbol-function sym) hook)))
 572         (setq abbrevs-changed t))
 573       (set sym expansion)
 574       (fset sym hook)
 575       (setplist sym
 576                 ;; Don't store the `force' value of `system-flag' into
 577                 ;; the :system property.
 578                 (if (eq 'force system-flag) (plist-put props :system t) props))
 579       (abbrev-table-put table :abbrev-table-modiff
 580                         (1+ (abbrev-table-get table :abbrev-table-modiff))))
 581     name))
 582
 583 (defun abbrev--check-chars (abbrev global)
 584   "Check if the characters in ABBREV have word syntax in either the
 585 current (if global is nil) or standard syntax table."
 586   (with-syntax-table
 587       (cond ((null global) (standard-syntax-table))
 588             ;; ((syntax-table-p global) global)
 589             (t (syntax-table)))
 590     (when (string-match "\\W" abbrev)
 591       (let ((badchars ())
 592             (pos 0))
 593         (while (string-match "\\W" abbrev pos)
 594           (pushnew (aref abbrev (match-beginning 0)) badchars)
 595           (setq pos (1+ pos)))
 596         (error "Some abbrev characters (%s) are not word constituents %s"
 597                (apply 'string (nreverse badchars))
 598                (if global "in the standard syntax" "in this mode"))))))
 599
 600 (defun define-global-abbrev (abbrev expansion)
 601   "Define ABBREV as a global abbreviation for EXPANSION.
 602 The characters in ABBREV must all be word constituents in the standard
 603 syntax table."
 604   (interactive "sDefine global abbrev: \nsExpansion for %s: ")
 605   (abbrev--check-chars abbrev 'global)
 606   (define-abbrev global-abbrev-table (downcase abbrev) expansion))
 607
 608 (defun define-mode-abbrev (abbrev expansion)
 609   "Define ABBREV as a mode-specific abbreviation for EXPANSION.
 610 The characters in ABBREV must all be word-constituents in the current mode."
 611   (interactive "sDefine mode abbrev: \nsExpansion for %s: ")
 612   (unless local-abbrev-table
 613     (error "Major mode has no abbrev table"))
 614   (abbrev--check-chars abbrev nil)
 615   (define-abbrev local-abbrev-table (downcase abbrev) expansion))
 616
 617 (defun abbrev--active-tables (&optional tables)
 618   "Return the list of abbrev tables currently active.
 619 TABLES if non-nil overrides the usual rules.  It can hold
 620 either a single abbrev table or a list of abbrev tables."
 621   ;; We could just remove the `tables' arg and let callers use
 622   ;; (or table (abbrev--active-tables)) but then they'd have to be careful
 623   ;; to treat the distinction between a single table and a list of tables.
 624   (cond
 625    ((consp tables) tables)
 626    ((vectorp tables) (list tables))
 627    (t
 628     (let ((tables (if (listp local-abbrev-table)
 629                       (append local-abbrev-table
 630                               (list global-abbrev-table))
 631                     (list local-abbrev-table global-abbrev-table))))
 632       ;; Add the minor-mode abbrev tables.
 633       (dolist (x abbrev-minor-mode-table-alist)
 634         (when (and (symbolp (car x)) (boundp (car x)) (symbol-value (car x)))
 635           (setq tables
 636                 (if (listp (cdr x))
 637                     (append (cdr x) tables) (cons (cdr x) tables)))))
 638       tables))))
 639
 640
 641 (defun abbrev-symbol (abbrev &optional table)
 642   "Return the symbol representing abbrev named ABBREV.
 643 This symbol's name is ABBREV, but it is not the canonical symbol of that name;
 644 it is interned in an abbrev-table rather than the normal obarray.
 645 The value is nil if that abbrev is not defined.
 646 Optional second arg TABLE is abbrev table to look it up in.
 647 The default is to try buffer's mode-specific abbrev table, then global table."
 648   (let ((tables (abbrev--active-tables table))
 649         sym)
 650     (while (and tables (not (symbol-value sym)))
 651       (let* ((table (pop tables))
 652              (case-fold (not (abbrev-table-get table :case-fixed))))
 653         (setq tables (append (abbrev-table-get table :parents) tables))
 654         ;; In case the table doesn't set :case-fixed but some of the
 655         ;; abbrevs do, we have to be careful.
 656         (setq sym
 657               ;; First try without case-folding.
 658               (or (intern-soft abbrev table)
 659                   (when case-fold
 660                     ;; We didn't find any abbrev, try case-folding.
 661                     (let ((sym (intern-soft (downcase abbrev) table)))
 662                       ;; Only use it if it doesn't require :case-fixed.
 663                       (and sym (not (abbrev-get sym :case-fixed))
 664                            sym)))))))
 665     (if (symbol-value sym)
 666         sym)))
 667
 668
 669 (defun abbrev-expansion (abbrev &optional table)
 670   "Return the string that ABBREV expands into in the current buffer.
 671 Optionally specify an abbrev table as second arg;
 672 then ABBREV is looked up in that table only."
 673   (symbol-value (abbrev-symbol abbrev table)))
 674
 675
 676 (defun abbrev--before-point ()
 677   "Try and find an abbrev before point.  Return it if found, nil otherwise."
 678   (unless (eq abbrev-start-location-buffer (current-buffer))
 679     (setq abbrev-start-location nil))
 680
 681   (let ((tables (abbrev--active-tables))
 682         (pos (point))
 683         start end name res)
 684
 685     (if abbrev-start-location
 686         (progn
 687           (setq start abbrev-start-location)
 688           (setq abbrev-start-location nil)
 689           ;; Remove the hyphen inserted by `abbrev-prefix-mark'.
 690           (if (and (< start (point-max))
 691                    (eq (char-after start) ?-))
 692               (delete-region start (1+ start)))
 693           (skip-syntax-backward " ")
 694           (setq end (point))
 695           (when (> end start)
 696             (setq name (buffer-substring start end))
 697             (goto-char pos)               ; Restore point.
 698             (list (abbrev-symbol name tables) name start end)))
 699
 700       (while (and tables (not (car res)))
 701         (let* ((table (pop tables))
 702                (enable-fun (abbrev-table-get table :enable-function)))
 703           (setq tables (append (abbrev-table-get table :parents) tables))
 704           (setq res
 705                 (and (or (not enable-fun) (funcall enable-fun))
 706                      (looking-back (or (abbrev-table-get table :regexp)
 707                                        "\\<\\(\\w+\\)\\W*")
 708                                    (line-beginning-position))
 709                      (setq start (match-beginning 1))
 710                      (setq end   (match-end 1))
 711                      (setq name  (buffer-substring start end))
 712                      (let ((abbrev (abbrev-symbol name table)))
 713                        (when abbrev
 714                          (setq enable-fun (abbrev-get abbrev :enable-function))
 715                          (and (or (not enable-fun) (funcall enable-fun))
 716                               ;; This will also look it up in parent tables.
 717                               ;; This is not on purpose, but it seems harmless.
 718                               (list abbrev name start end))))))
 719           ;; Restore point.
 720           (goto-char pos)))
 721       res)))
 722
 723 (defun abbrev-insert (abbrev &optional name wordstart wordend)
 724   "Insert abbrev ABBREV at point.
 725 If non-nil, NAME is the name by which this abbrev was found.
 726 If non-nil, WORDSTART is the place where to insert the abbrev.
 727 If non-nil, WORDEND the abbrev replaces the previous text between
 728 WORDSTART and WORDEND.
 729 Return ABBREV if the expansion should be considered as having taken place."
 730   (unless name (setq name (symbol-name abbrev)))
 731   (unless wordstart (setq wordstart (point)))
 732   (unless wordend (setq wordend wordstart))
 733   ;; Increment use count.
 734   (abbrev-put abbrev :count (1+ (abbrev-get abbrev :count)))
 735   (let ((value abbrev))
 736     ;; If this abbrev has an expansion, delete the abbrev
 737     ;; and insert the expansion.
 738     (when (stringp (symbol-value abbrev))
 739       (goto-char wordstart)
 740       ;; Insert at beginning so that markers at the end (e.g. point)
 741       ;; are preserved.
 742       (insert (symbol-value abbrev))
 743       (delete-char (- wordend wordstart))
 744       (let ((case-fold-search nil))
 745         ;; If the abbrev's name is different from the buffer text (the
 746         ;; only difference should be capitalization), then we may want
 747         ;; to adjust the capitalization of the expansion.
 748         (when (and (not (equal name (symbol-name abbrev)))
 749                    (string-match "[[:upper:]]" name))
 750           (if (not (string-match "[[:lower:]]" name))
 751               ;; Abbrev was all caps.  If expansion is multiple words,
 752               ;; normally capitalize each word.
 753               (if (and (not abbrev-all-caps)
 754                        (save-excursion
 755                          (> (progn (backward-word 1) (point))
 756                             (progn (goto-char wordstart)
 757                                    (forward-word 1) (point)))))
 758                   (upcase-initials-region wordstart (point))
 759                 (upcase-region wordstart (point)))
 760             ;; Abbrev included some caps.  Cap first initial of expansion.
 761             (let ((end (point)))
 762               ;; Find the initial.
 763               (goto-char wordstart)
 764               (skip-syntax-forward "^w" (1- end))
 765               ;; Change just that.
 766               (upcase-initials-region (point) (1+ (point)))
 767               (goto-char end))))))
 768     ;; Now point is at the end of the expansion and the beginning is
 769     ;; in last-abbrev-location.
 770     (when (symbol-function abbrev)
 771       (let* ((hook (symbol-function abbrev))
 772              (expanded
 773               ;; If the abbrev has a hook function, run it.
 774               (funcall hook)))
 775         ;; In addition, if the hook function is a symbol with
 776         ;; a non-nil `no-self-insert' property, let the value it
 777         ;; returned specify whether we consider that an expansion took
 778         ;; place.  If it returns nil, no expansion has been done.
 779         (if (and (symbolp hook)
 780                  (null expanded)
 781                  (get hook 'no-self-insert))
 782             (setq value nil))))
 783     value))
 784
 785 (defvar abbrev-expand-functions nil
 786   "Wrapper hook around `expand-abbrev'.
 787 The functions on this special hook are called with one argument:
 788 a function that performs the abbrev expansion.  It should return
 789 the abbrev symbol if expansion took place.")
 790
 791 (defun expand-abbrev ()
 792   "Expand the abbrev before point, if there is an abbrev there.
 793 Effective when explicitly called even when `abbrev-mode' is nil.
 794 Returns the abbrev symbol, if expansion took place."
 795   (interactive)
 796   (run-hooks 'pre-abbrev-expand-hook)
 797   (abbrev-with-wrapper-hook abbrev-expand-functions
 798     (destructuring-bind (&optional sym name wordstart wordend)
 799         (abbrev--before-point)
 800       (when sym
 801         (let ((value sym))
 802           (unless (or ;; executing-kbd-macro
 803                    noninteractive
 804                    (window-minibuffer-p (selected-window)))
 805             ;; Add an undo boundary, in case we are doing this for
 806             ;; a self-inserting command which has avoided making one so far.
 807             (undo-boundary))
 808           ;; Now sym is the abbrev symbol.
 809           (setq last-abbrev-text name)
 810           (setq last-abbrev sym)
 811           (setq last-abbrev-location wordstart)
 812           ;; If this abbrev has an expansion, delete the abbrev
 813           ;; and insert the expansion.
 814           (abbrev-insert sym name wordstart wordend))))))
 815
 816 (defun unexpand-abbrev ()
 817   "Undo the expansion of the last abbrev that expanded.
 818 This differs from ordinary undo in that other editing done since then
 819 is not undone."
 820   (interactive)
 821   (save-excursion
 822     (unless (or (< last-abbrev-location (point-min))
 823                 (> last-abbrev-location (point-max)))
 824       (goto-char last-abbrev-location)
 825       (when (stringp last-abbrev-text)
 826         ;; This isn't correct if last-abbrev's hook was used
 827         ;; to do the expansion.
 828         (let ((val (symbol-value last-abbrev)))
 829           (unless (stringp val)
 830             (error "Value of abbrev-symbol must be a string"))
 831           ;; Don't inherit properties here; just copy from old contents.
 832           (insert last-abbrev-text)
 833           ;; Delete after inserting, to better preserve markers.
 834           (delete-region (point) (+ (point) (length val)))
 835           (setq last-abbrev-text nil))))))
 836
 837 (defun abbrev--write (sym)
 838   "Write the abbrev in a `read'able form.
 839 Only writes the non-system abbrevs.
 840 Presumes that `standard-output' points to `current-buffer'."
 841   (unless (or (null (symbol-value sym)) (abbrev-get sym :system))
 842     (insert "    (")
 843     (prin1 (symbol-name sym))
 844     (insert " ")
 845     (prin1 (symbol-value sym))
 846     (insert " ")
 847     (prin1 (symbol-function sym))
 848     (insert " ")
 849     (prin1 (abbrev-get sym :count))
 850     (insert ")\n")))
 851
 852 (defun abbrev--describe (sym)
 853   (when (symbol-value sym)
 854     (prin1 (symbol-name sym))
 855     (if (null (abbrev-get sym :system))
 856         (indent-to 15 1)
 857       (insert " (sys)")
 858       (indent-to 20 1))
 859     (prin1 (abbrev-get sym :count))
 860     (indent-to 20 1)
 861     (prin1 (symbol-value sym))
 862     (when (symbol-function sym)
 863       (indent-to 45 1)
 864       (prin1 (symbol-function sym)))
 865     (terpri)))
 866
 867 (defun insert-abbrev-table-description (name &optional readable)
 868   "Insert before point a full description of abbrev table named NAME.
 869 NAME is a symbol whose value is an abbrev table.
 870 If optional 2nd arg READABLE is non-nil, a human-readable description
 871 is inserted.  Otherwise the description is an expression,
 872 a call to `define-abbrev-table', which would
 873 define the abbrev table NAME exactly as it is currently defined.
 874
 875 Abbrevs marked as \"system abbrevs\" are omitted."
 876   (let ((table (symbol-value name))
 877         (symbols ()))
 878     (mapatoms (lambda (sym) (if (symbol-value sym) (push sym symbols))) table)
 879     (setq symbols (sort symbols 'string-lessp))
 880     (let ((standard-output (current-buffer)))
 881       (if readable
 882           (progn
 883             (insert "(")
 884             (prin1 name)
 885             (insert ")\n\n")
 886             (mapc 'abbrev--describe symbols)
 887             (insert "\n\n"))
 888         (insert "(define-abbrev-table '")
 889         (prin1 name)
 890         (insert " '(")
 891         (mapc 'abbrev--write symbols)
 892         (insert "    ))\n\n"))
 893       nil)))
 894
 895 (put 'define-abbrev-table 'doc-string-elt 3)
 896 (defun define-abbrev-table (tablename definitions
 897                                       &optional docstring &rest props)
 898   "Define TABLENAME (a symbol) as an abbrev table name.
 899 Define abbrevs in it according to DEFINITIONS, which is a list of elements
 900 of the form (ABBREVNAME EXPANSION ...) that are passed to `define-abbrev'.
 901 PROPS is a property list to apply to the table.
 902 Properties with special meaning:
 903 - `:parents' contains a list of abbrev tables from which this table inherits
 904   abbreviations.
 905 - `:case-fixed' non-nil means that abbreviations are looked up without
 906   case-folding, and the expansion is not capitalized/upcased.
 907 - `:regexp' describes the form of abbrevs.  It defaults to \\=\\<\\(\\w+\\)\\W* which
 908   means that an abbrev can only be a single word.  The submatch 1 is treated
 909   as the potential name of an abbrev.
 910 - `:enable-function' can be set to a function of no argument which returns
 911   non-nil if and only if the abbrevs in this table should be used for this
 912   instance of `expand-abbrev'."
 913   ;; We used to manually add the docstring, but we also want to record this
 914   ;; location as the definition of the variable (in load-history), so we may
 915   ;; as well just use `defvar'.
 916   (eval `(defvar ,tablename nil ,@(if (stringp docstring) (list docstring))))
 917   (let ((table (if (boundp tablename) (symbol-value tablename))))
 918     (unless table
 919       (setq table (make-abbrev-table))
 920       (set tablename table)
 921       (push tablename abbrev-table-name-list))
 922     ;; We used to just pass them to `make-abbrev-table', but that fails
 923     ;; if the table was pre-existing as is the case if it was created by
 924     ;; loading the user's abbrev file.
 925     (while (consp props)
 926       (abbrev-table-put table (pop props) (pop props)))
 927     (dolist (elt definitions)
 928       (apply 'define-abbrev table elt))))
 929
 930 (defun abbrev-table-menu (table &optional prompt sortfun)
 931   "Return a menu that shows all abbrevs in TABLE.
 932 Selecting an entry runs `abbrev-insert'.
 933 PROMPT is the prompt to use for the keymap.
 934 SORTFUN is passed to `sort' to change the default ordering."
 935   (unless sortfun (setq sortfun 'string-lessp))
 936   (let ((entries ()))
 937     (mapatoms (lambda (abbrev)
 938                 (when (symbol-value abbrev)
 939                   (let ((name (symbol-name abbrev)))
 940                     (push `(,(intern name) menu-item ,name
 941                             (lambda () (interactive)
 942                               (abbrev-insert ',abbrev)))
 943                           entries))))
 944               table)
 945     (nconc (make-sparse-keymap prompt)
 946            (sort entries (lambda (x y)
 947                 (funcall sortfun (nth 2 x) (nth 2 y)))))))
 948
 949 (provide 'abbrev)
 950
 951 ;; arch-tag: dbd6f3ae-dfe3-40ba-b00f-f9e3ff960df5
 952 ;;; abbrev.el ends here