lisp/expand.el

   1 ;;; expand.el --- make abbreviations more usable
   2
   3 ;; Copyright (C) 1995-1996, 2001-2011 Free Software Foundation, Inc.
   4
   5 ;; Author: Frederic Lepied <Frederic.Lepied@sugix.frmug.org>
   6 ;; Maintainer: Frederic Lepied <Frederic.Lepied@sugix.frmug.org>
   7 ;; Keywords: abbrev
   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 package defines abbrevs which expand into structured constructs
  27 ;; for certain languages.  The construct is indented for you,
  28 ;; and contains slots for you to fill in other text.
  29
  30 ;; These abbrevs expand only at the end of a line and when not in a comment
  31 ;; or a string.
  32 ;;
  33 ;;   Look at the Sample: section for emacs-lisp, perl and c expand lists.
  34 ;; For example for c-mode, you could declare your abbrev table with :
  35 ;;
  36 ;; (defconst c-expand-list
  37 ;;   '(("if" "if () {\n \n} else {\n \n}" (5 10 21))
  38 ;;     ("ifn" "if () {}" (5 8))
  39 ;;     ("uns" "unsigned ")
  40 ;;     ("for" "for(; ; ) {\n\n}" (5 7 9 13))
  41 ;;     ("switch" "switch () {\n\n}" (9 13))
  42 ;;     ("case" "case :\n\nbreak;\n" (6 8 16))
  43 ;;     ("do" "do {\n\n} while ();" (6 16))
  44 ;;     ("while" "while () {\n\n}" (8 12))
  45 ;;     ("default" "default:\n\nbreak;" 10)
  46 ;;     ("main" "int\nmain(int argc, char * argv[])\n{\n\n}\n" 37))
  47 ;;   "Expansions for C mode")
  48 ;;
  49 ;;   and enter Abbrev mode with the following hook :
  50 ;;
  51 ;; (add-hook 'c-mode-hook
  52 ;;        (lambda ()
  53 ;;          (expand-add-abbrevs c-mode-abbrev-table c-expand-list)
  54 ;;          (abbrev-mode 1)))
  55 ;;
  56 ;;   you can also init some post-process hooks :
  57 ;;
  58 ;; (add-hook 'expand-load-hook
  59 ;;        (lambda ()
  60 ;;          (add-hook 'expand-expand-hook 'indent-according-to-mode)
  61 ;;          (add-hook 'expand-jump-hook 'indent-according-to-mode)))
  62 ;;
  63 ;; Remarks:
  64 ;;
  65 ;;   Many thanks to Heddy Boubaker <boubaker@cenatls.cena.dgac.fr>,
  66 ;;                  Jerome Santini <santini@chambord.univ-orleans.fr>,
  67 ;;                  Jari Aalto <jaalto@tre.tele.nokia.fi>.
  68 ;;
  69 ;;   Please send me a word to give me your feeling about this feature or
  70 ;; to explain me how you use it (your expansions table for example) using
  71 ;; the function expand-submit-report.
  72 ;;; Code:
  73 \f
  74 ;;; Constants:
  75
  76 (defgroup expand nil
  77   "Make abbreviations more usable."
  78   :group 'abbrev)
  79
  80 (defcustom expand-load-hook nil
  81   "Hooks run when `expand.el' is loaded."
  82   :type 'hook
  83   :group 'expand)
  84
  85 (defcustom expand-expand-hook nil
  86   "Hooks run when an abbrev made by `expand-add-abbrevs' is expanded."
  87   :type 'hook
  88   :group 'expand)
  89
  90 (defcustom expand-jump-hook nil
  91   "Hooks run by `expand-jump-to-previous-slot' and `expand-jump-to-next-slot'."
  92   :type 'hook
  93   :group 'expand)
  94
  95 ;;; Samples:
  96
  97 (define-skeleton expand-c-for-skeleton "For loop skeleton"
  98   "Loop var: "
  99   "for(" str _ @ "=0; " str @ "; " str @ ") {" \n
 100   @ _ \n
 101   "}" > \n)
 102
 103 (defconst expand-c-sample-expand-list
 104   '(("if" "if () {\n \n} else {\n \n}" (5 10 21))
 105     ("ifn" "if () {}" (5 8))
 106     ("uns" "unsigned ")
 107     ("for" expand-c-for-skeleton)
 108     ("switch" "switch () {\n\n}" (9 13))
 109     ("case" "case :\n\nbreak;\n" (6 8 16))
 110     ("do" "do {\n\n} while ();" (6 16))
 111     ("while" "while () {\n\n}" (8 12))
 112     ("default" "default:\n\nbreak;" 10)
 113     ("main" "int\nmain(int argc, char * argv[])\n{\n\n}\n" 37))
 114   "Expansions for C mode. See `expand-add-abbrevs'.")
 115
 116 ;; lisp example from Jari Aalto <jaalto@tre.tele.nokia.fi>
 117 (defconst expand-sample-lisp-mode-expand-list
 118   (list
 119    (list
 120     "defu"
 121     (concat
 122      "(defun   ()\n"
 123      "  \"\"\n"
 124      "  (interactive)\n"
 125      "  (let* (\n"
 126      "         )\n"
 127      "    \n"
 128      "    ))")
 129     (list 8 11 16 32 43 59))
 130
 131    (list
 132     "defs"
 133     (concat
 134      "(defsubst   ()\n"
 135      "  \"\"\n"
 136      "  (interactive)\n"
 137      "  )")
 138     (list 11 14 19 23 39))
 139
 140    (list
 141     "defm"
 142     (concat
 143      "(defmacro  ()\n"
 144      "  \"\"\n"
 145      "  `( \n"
 146      "    ))")
 147     (list 11 13 18 25))
 148
 149    (list
 150     "defa"
 151     (concat
 152      "(defadvice   (around   act)\n"
 153      "  \"\"\n"
 154      "  \n"
 155      "  )")
 156     (list 12 22 32 36))
 157
 158     (list
 159      "defc"
 160      "(defconst   nil\n  \"\")\n"
 161      (list 11 13 20))
 162
 163     (list
 164      "defv"
 165      "(defvar   nil\n  \"\")\n"
 166      (list 9 11 18))
 167
 168     (list
 169      "let"
 170      "(let* (\n)\n    "
 171      (list 8 13))
 172
 173      (list
 174      "sav"
 175      "(save-excursion\n \n)"
 176      (list 18))
 177
 178      (list
 179      "aut"
 180      "(autoload ' \"\" t t)\n"
 181      (list 12 14))
 182
 183     )
 184    "Expansions for Lisp mode. See `expand-add-abbrevs'.")
 185
 186 ;; perl example from Jari Aalto <jaalto@tre.tele.nokia.fi>
 187 (defconst expand-sample-perl-mode-expand-list
 188   (list
 189    (list
 190     ;;   This is default perl4 subroutine template
 191     ;;
 192     "sub"
 193     (concat
 194      "#" (make-string 70 ?-) "\n"
 195      "sub   {\n"
 196      "    # DESCRIPTION\n"
 197      "    #   \n"
 198      "    #   \n"
 199      "    # INPUT\n"
 200      "    #   \n"
 201      "    #   \n"
 202      "    # RETURN\n"
 203      "    #   \n"
 204      "\n"
 205      "    local( $f ) = \"$lib.\";\n"   ;; Function name AFTER period
 206      "    local() = @_;\n"              ;; func arguments here
 207      "    \n"
 208      "    \n}\n"
 209      )
 210     (list 77 88 120 146 159 176))
 211
 212    (list
 213     "for"                               ; foreach
 214     (concat
 215      "for (  )\n"
 216      "{\n\n\}"
 217      )
 218     (list 7 12))
 219
 220    (list
 221     "whi"                               ; foreach
 222     (concat
 223      "while (  )\n"
 224      "{\n\n\}"
 225      )
 226     (list 9 15))
 227
 228
 229    ;;   The normal "if" can be used like
 230    ;;   print $F "xxxxxx"  if defined @arr;
 231    ;;
 232    (list
 233     "iff"
 234     (concat
 235      "if (  )\n"
 236      "{\n\n\}"
 237      )
 238     (list 6 12))
 239
 240    (list "loc"  "local( $ );"   (list 9))
 241    (list "my"   "my( $ );"      (list 6))
 242    (list "ope"  "open(,\"\")\t|| die \"$f: Can't open [$]\";" (list 6 8 36))
 243    (list "clo"  "close ;"       7)
 244    (list "def"  "defined  "     (list 9))
 245    (list "und"  "undef ;"       (list 7))
 246
 247    ;;   There is no ending colon, because they can be in statement
 248    ;;    defined $REXP_NOT_NEW && (print "xxxxx" );
 249    ;;
 250    (list "pr"  "print "         7)
 251    (list "pf"  "printf "        8)
 252
 253
 254    (list "gre"  "grep( //, );"  (list 8 11))
 255    (list "pus"  "push( , );"    (list 7 9))
 256    (list "joi"  "join( '', );"  (list 7 11))
 257    (list "rtu"  "return ;"      (list 8))
 258
 259    )
 260   "Expansions for Perl mode. See `expand-add-abbrevs'.")
 261
 262 ;;; Code:
 263
 264 ;;;###autoload
 265 (defun expand-add-abbrevs (table abbrevs)
 266   "Add a list of abbrev to abbrev table TABLE.
 267 ABBREVS is a list of abbrev definitions; each abbrev description entry
 268 has the form (ABBREV EXPANSION ARG).
 269
 270 ABBREV is the abbreviation to replace.
 271
 272 EXPANSION is the replacement string or a function which will make the
 273 expansion.  For example you, could use the DMacros or skeleton packages
 274 to generate such functions.
 275
 276 ARG is an optional argument which can be a number or a list of
 277 numbers.  If ARG is a number, point is placed ARG chars from the
 278 beginning of the expanded text.
 279
 280 If ARG is a list of numbers, point is placed according to the first
 281 member of the list, but you can visit the other specified positions
 282 cyclicaly with the functions `expand-jump-to-previous-slot' and
 283 `expand-jump-to-next-slot'.
 284
 285 If ARG is omitted, point is placed at the end of the expanded text."
 286
 287   (if (null abbrevs)
 288       table
 289     (expand-add-abbrev table (nth 0 (car abbrevs)) (nth 1 (car abbrevs))
 290                        (nth 2 (car abbrevs)))
 291     (expand-add-abbrevs table (cdr abbrevs))))
 292
 293 (defvar expand-list nil "Temporary variable used by the Expand package.")
 294
 295 (defvar expand-pos nil
 296   "If non-nil, stores a vector containing markers to positions defined by the last expansion.
 297 This variable is local to a buffer.")
 298 (make-variable-buffer-local 'expand-pos)
 299
 300 (defvar expand-index 0
 301   "Index of the last marker used in `expand-pos'.
 302 This variable is local to a buffer.")
 303 (make-variable-buffer-local 'expand-index)
 304
 305 (defvar expand-point nil
 306   "End of the expanded region.
 307 This variable is local to a buffer.")
 308 (make-variable-buffer-local 'expand-point)
 309
 310 (defun expand-add-abbrev (table abbrev expansion arg)
 311   "Add one abbreviation and provide the hook to move to the specified positions."
 312   (let* ((string-exp (if (and (symbolp expansion) (fboundp expansion))
 313                          nil
 314                        expansion))
 315          (position   (if (and arg string-exp)
 316                          (if (listp arg)
 317                              (- (length expansion) (1- (car arg)))
 318                            (- (length expansion) (1- arg)))
 319                        0)))
 320     (define-abbrev
 321       table
 322       abbrev
 323       (vector string-exp
 324               position
 325               (if (and (listp arg)
 326                        (not (null arg)))
 327                   (cons (length string-exp) arg)
 328                 nil)
 329               (if (and (symbolp expansion) (fboundp expansion))
 330                   expansion
 331                 nil)
 332               )
 333       'expand-abbrev-hook)))
 334
 335 (put 'expand-abbrev-hook 'no-self-insert t)
 336 ;;;###autoload
 337 (defun expand-abbrev-hook ()
 338   "Abbrev hook used to do the expansion job of expand abbrevs.
 339 See `expand-add-abbrevs'.  Value is non-nil if expansion was done."
 340   ;; Expand only at the end of a line if we are near a word that has
 341   ;; an abbrev built from expand-add-abbrev.
 342   (if (and (eolp)
 343            (not (expand-in-literal)))
 344       (let ((p (point)))
 345         (setq expand-point nil)
 346         ;; don't expand if the preceding char isn't a word constituent
 347         (if (and (eq (char-syntax (preceding-char))
 348                      ?w)
 349                  (expand-do-expansion))
 350             (progn
 351               ;; expand-point tells us if we have inserted the text
 352               ;; ourself or if it is the hook which has done the job.
 353               (if expand-point
 354                   (progn
 355                     (if (vectorp expand-list)
 356                         (expand-build-marks expand-point))
 357                     (indent-region p expand-point nil))
 358                 ;; an outside function can set expand-list to a list of
 359                 ;; markers in reverse order.
 360                 (if (listp expand-list)
 361                     (setq expand-index 0
 362                           expand-pos (expand-list-to-markers expand-list)
 363                           expand-list nil)))
 364               (run-hooks 'expand-expand-hook)
 365               t)
 366           nil))
 367     nil))
 368
 369 (defun expand-do-expansion ()
 370   (delete-char (- (length last-abbrev-text)))
 371   (let* ((vect (symbol-value last-abbrev))
 372          (text (aref vect 0))
 373          (position (aref vect 1))
 374          (jump-args (aref vect 2))
 375          (hook (aref vect 3)))
 376     (cond (text
 377            (insert text)
 378            (setq expand-point (point))))
 379     (if jump-args
 380         (funcall 'expand-build-list (car jump-args) (cdr jump-args)))
 381     (if position
 382         (backward-char position))
 383     (if hook
 384         (funcall hook))
 385     t)
 386   )
 387
 388 (defun expand-abbrev-from-expand (word)
 389   "Test if an abbrev has a hook."
 390   (or
 391    (and (intern-soft word local-abbrev-table)
 392         (symbol-function (intern-soft word local-abbrev-table)))
 393    (and (intern-soft word global-abbrev-table)
 394         (symbol-function (intern-soft word global-abbrev-table)))))
 395
 396 (defun expand-previous-word ()
 397   "Return the previous word."
 398   (save-excursion
 399     (let ((p (point)))
 400       (backward-word 1)
 401       (buffer-substring p (point)))))
 402
 403 ;;;###autoload
 404 (defun expand-jump-to-previous-slot ()
 405   "Move the cursor to the previous slot in the last abbrev expansion.
 406 This is used only in conjunction with `expand-add-abbrevs'."
 407   (interactive)
 408   (if expand-pos
 409       (progn
 410         (setq expand-index (1- expand-index))
 411         (if (< expand-index 0)
 412             (setq expand-index (1- (length expand-pos))))
 413         (goto-char (aref expand-pos expand-index))
 414         (run-hooks 'expand-jump-hook))))
 415
 416 ;;;###autoload
 417 (defun expand-jump-to-next-slot ()
 418   "Move the cursor to the next slot in the last abbrev expansion.
 419 This is used only in conjunction with `expand-add-abbrevs'."
 420   (interactive)
 421   (if expand-pos
 422       (progn
 423         (setq expand-index (1+ expand-index))
 424         (if (>= expand-index (length expand-pos))
 425             (setq expand-index 0))
 426         (goto-char (aref expand-pos expand-index))
 427         (run-hooks 'expand-jump-hook))))
 428
 429 ;;;###autoload (define-key abbrev-map "p" 'expand-jump-to-previous-slot)
 430 ;;;###autoload (define-key abbrev-map "n" 'expand-jump-to-next-slot)
 431
 432 (defun expand-build-list (len l)
 433   "Build a vector of offset positions from the list of positions."
 434   (expand-clear-markers)
 435   (setq expand-list (vconcat l))
 436   (let ((i 0)
 437         (lenlist (length expand-list)))
 438     (while (< i lenlist)
 439       (aset expand-list i (- len (1- (aref expand-list i))))
 440       (setq i (1+ i))))
 441   )
 442
 443 (defun expand-build-marks (p)
 444   "Transform the offsets vector into a marker vector."
 445   (if expand-list
 446       (progn
 447         (setq expand-index 0)
 448         (setq expand-pos (make-vector (length expand-list) nil))
 449         (let ((i (1- (length expand-list))))
 450           (while (>= i 0)
 451             (aset expand-pos i (copy-marker (- p (aref expand-list i))))
 452             (setq i (1- i))))
 453         (setq expand-list nil))))
 454
 455 (defun expand-clear-markers ()
 456   "Make the markers point nowhere."
 457   (if expand-pos
 458       (progn
 459     (let ((i (1- (length expand-pos))))
 460       (while (>= i 0)
 461         (set-marker (aref expand-pos i) nil)
 462         (setq i (1- i))))
 463     (setq expand-pos nil))))
 464
 465 (defun expand-in-literal ()
 466   "Test if we are in a comment or in a string."
 467   (save-excursion
 468     (let* ((lim (or (save-excursion
 469                       (beginning-of-defun)
 470                       (point))
 471                     (point-min)))
 472            (state (parse-partial-sexp lim (point))))
 473       (cond
 474        ((nth 3 state) 'string)
 475        ((nth 4 state) 'comment)
 476        (t nil)))))
 477
 478 ;; support functions to add marks to jump from outside function
 479
 480 (defun expand-list-to-markers (l)
 481   "Transform a list of markers in reverse order into a vector in the correct order."
 482   (let* ((len (1- (length l)))
 483          (loop len)
 484          (v (make-vector (+ len 1) nil)))
 485     (while (>= loop 0)
 486       (aset v loop (if (markerp (car l)) (car l) (copy-marker (car l))))
 487       (setq l (cdr l)
 488             loop (1- loop)))
 489     v))
 490
 491 ;; integration with skeleton.el
 492 ;; Used in `skeleton-end-hook' to fetch the positions for  @ skeleton tags.
 493 ;; See `skeleton-insert'.
 494 (defun expand-skeleton-end-hook ()
 495   (if skeleton-positions
 496       (setq expand-list skeleton-positions)))
 497
 498 (add-hook 'skeleton-end-hook (function expand-skeleton-end-hook))
 499
 500 (provide 'expand)
 501
 502 ;; run load hooks
 503 (run-hooks 'expand-load-hook)
 504
 505 ;;; expand.el ends here