lisp/expand.el

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