lisp/expand.el

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