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 ;;; Code:
  75 \f
  76 ;;; Constants:
  77
  78 (defgroup expand nil
  79   "Make abbreviations more usable."
  80   :group 'abbrev)
  81
  82 (defcustom expand-load-hook nil
  83   "Hooks run when `expand.el' is loaded."
  84   :type 'hook
  85   :group 'expand)
  86
  87 (defcustom expand-expand-hook nil
  88   "Hooks run when an abbrev made by `expand-add-abbrevs' is expanded."
  89   :type 'hook
  90   :group 'expand)
  91
  92 (defcustom expand-jump-hook nil
  93   "Hooks run by `expand-jump-to-previous-slot' and `expand-jump-to-next-slot'."
  94   :type 'hook
  95   :group 'expand)
  96
  97 ;;; Samples:
  98
  99 (define-skeleton expand-c-for-skeleton "For loop skeleton"
 100   "Loop var: "
 101   "for(" str _ @ "=0; " str @ "; " str @ ") {" \n
 102   @ _ \n
 103   "}" >
 104   )
 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 (defun expand-abbrev-hook ()
 340   "Abbrev hook used to do the expansion job of expand abbrevs.
 341 See `expand-add-abbrevs'.  Value is non-nil if expansion was done."
 342   ;; Expand only at the end of a line if we are near a word that has
 343   ;; an abbrev built from expand-add-abbrev.
 344   (if (and (eolp)
 345            (not (expand-in-literal)))
 346       (let ((p (point)))
 347         (setq expand-point nil)
 348         ;; don't expand if the preceding char isn't a word constituent
 349         (if (and (eq (char-syntax (preceding-char))
 350                      ?w)
 351                  (expand-do-expansion))
 352             (progn
 353               ;; expand-point tells us if we have inserted the text
 354               ;; ourself or if it is the hook which has done the job.
 355               (if expand-point
 356                   (progn
 357                     (if (vectorp expand-list)
 358                         (expand-build-marks expand-point))
 359                     (indent-region p expand-point nil))
 360                 ;; an outside function can set expand-list to a list of
 361                 ;; markers in reverse order.
 362                 (if (listp expand-list)
 363                     (setq expand-index 0
 364                           expand-pos (expand-list-to-markers expand-list)
 365                           expand-list nil)))
 366               (run-hooks 'expand-expand-hook)
 367               t)
 368           nil))
 369     nil))
 370
 371 (defun expand-do-expansion ()
 372   (delete-backward-char (length last-abbrev-text))
 373   (let* ((vect (symbol-value last-abbrev))
 374          (text (aref vect 0))
 375          (position (aref vect 1))
 376          (jump-args (aref vect 2))
 377          (hook (aref vect 3)))
 378     (cond (text
 379            (insert text)
 380            (setq expand-point (point))))
 381     (if jump-args
 382         (funcall 'expand-build-list (car jump-args) (cdr jump-args)))
 383     (if position
 384         (backward-char position))
 385     (if hook
 386         (funcall hook))
 387     t)
 388   )
 389
 390 (defun expand-abbrev-from-expand (word)
 391   "Test if an abbrev has a hook."
 392   (or
 393    (and (intern-soft word local-abbrev-table)
 394         (symbol-function (intern-soft word local-abbrev-table)))
 395    (and (intern-soft word global-abbrev-table)
 396         (symbol-function (intern-soft word global-abbrev-table)))))
 397
 398 (defun expand-previous-word ()
 399   "Return the previous word."
 400   (save-excursion
 401     (let ((p (point)))
 402       (backward-word 1)
 403       (buffer-substring p (point)))))
 404
 405 ;;;###autoload
 406 (defun expand-jump-to-previous-slot ()
 407   "Move the cursor to the previous slot in the last abbrev expansion.
 408 This is used only in conjunction with `expand-add-abbrevs'."
 409   (interactive)
 410   (if expand-pos
 411       (progn
 412         (setq expand-index (1- expand-index))
 413         (if (< expand-index 0)
 414             (setq expand-index (1- (length expand-pos))))
 415         (goto-char (aref expand-pos expand-index))
 416         (run-hooks 'expand-jump-hook))))
 417
 418 ;;;###autoload
 419 (defun expand-jump-to-next-slot ()
 420   "Move the cursor to the next slot in the last abbrev expansion.
 421 This is used only in conjunction with `expand-add-abbrevs'."
 422   (interactive)
 423   (if expand-pos
 424       (progn
 425         (setq expand-index (1+ expand-index))
 426         (if (>= expand-index (length expand-pos))
 427             (setq expand-index 0))
 428         (goto-char (aref expand-pos expand-index))
 429         (run-hooks 'expand-jump-hook))))
 430
 431 ;;;###autoload (define-key ctl-x-map "ap" 'expand-jump-to-previous-slot)
 432 ;;;###autoload (define-key ctl-x-map "an" 'expand-jump-to-next-slot)
 433
 434 (defun expand-build-list (len l)
 435   "Build a vector of offset positions from the list of positions."
 436   (expand-clear-markers)
 437   (setq expand-list (vconcat l))
 438   (let ((i 0)
 439         (lenlist (length expand-list)))
 440     (while (< i lenlist)
 441       (aset expand-list i (- len (1- (aref expand-list i))))
 442       (setq i (1+ i))))
 443   )
 444
 445 (defun expand-build-marks (p)
 446   "Transform the offsets vector into a marker vector."
 447   (if expand-list
 448       (progn
 449         (setq expand-index 0)
 450         (setq expand-pos (make-vector (length expand-list) nil))
 451         (let ((i (1- (length expand-list))))
 452           (while (>= i 0)
 453             (aset expand-pos i (copy-marker (- p (aref expand-list i))))
 454             (setq i (1- i))))
 455         (setq expand-list nil))))
 456
 457 (defun expand-clear-markers ()
 458   "Make the markers point nowhere."
 459   (if expand-pos
 460       (progn
 461     (let ((i (1- (length expand-pos))))
 462       (while (>= i 0)
 463         (set-marker (aref expand-pos i) nil)
 464         (setq i (1- i))))
 465     (setq expand-pos nil))))
 466
 467 (defun expand-in-literal ()
 468   "Test if we are in a comment or in a string."
 469   (save-excursion
 470     (let* ((lim (or (save-excursion
 471                       (beginning-of-defun)
 472                       (point))
 473                     (point-min)))
 474            (here (point))
 475            (state (parse-partial-sexp lim (point))))
 476       (cond
 477        ((nth 3 state) 'string)
 478        ((nth 4 state) 'comment)
 479        (t nil)))))
 480
 481 ;; support functions to add marks to jump from outside function
 482
 483 (defun expand-list-to-markers (l)
 484   "Transform a list of markers in reverse order into a vector in the correct order."
 485   (let* ((len (1- (length l)))
 486          (loop len)
 487          (v (make-vector (+ len 1) nil)))
 488     (while (>= loop 0)
 489       (aset v loop (if (markerp (car l)) (car l) (copy-marker (car l))))
 490       (setq l (cdr l)
 491             loop (1- loop)))
 492     v))
 493
 494 ;; integration with skeleton.el
 495 ;; Used in `skeleton-end-hook' to fetch the positions for  @ skeleton tags.
 496 ;; See `skeleton-insert'.
 497 (defun expand-skeleton-end-hook ()
 498   (if skeleton-positions
 499       (setq expand-list skeleton-positions)))
 500
 501 (add-hook 'skeleton-end-hook (function expand-skeleton-end-hook))
 502
 503 (provide 'expand)
 504
 505 ;; run load hooks
 506 (run-hooks 'expand-load-hook)
 507
 508 ;;; expand.el ends here