lisp/derived.el

   1 ;;; derived.el -- allow inheritance of major modes.
   2 ;;; (formerly mode-clone.el)
   3
   4 ;; Copyright (C) 1993, 1994 Free Software Foundation, Inc.
   5
   6 ;; Author: David Megginson (dmeggins@aix1.uottawa.ca)
   7 ;; Maintainer: FSF
   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
  23 ;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  24 \f
  25 ;;; Commentary:
  26
  27 ;; GNU Emacs is already, in a sense, object oriented -- each object
  28 ;; (buffer) belongs to a class (major mode), and that class defines
  29 ;; the relationship between messages (input events) and methods
  30 ;; (commands) by means of a keymap.
  31 ;;
  32 ;; The only thing missing is a good scheme of inheritance.  It is
  33 ;; possible to simulate a single level of inheritance with generous
  34 ;; use of hooks and a bit of work -- sgml-mode, for example, also runs
  35 ;; the hooks for text-mode, and keymaps can inherit from other keymaps
  36 ;; -- but generally, each major mode ends up reinventing the wheel.
  37 ;; Ideally, someone should redesign all of Emacs's major modes to
  38 ;; follow a more conventional object-oriented system: when defining a
  39 ;; new major mode, the user should need only to name the existing mode
  40 ;; it is most similar to, then list the (few) differences.
  41 ;;
  42 ;; In the mean time, this package offers most of the advantages of
  43 ;; full inheritance with the existing major modes.  The macro
  44 ;; `define-derived-mode' allows the user to make a variant of an existing
  45 ;; major mode, with its own keymap.  The new mode will inherit the key
  46 ;; bindings of its parent, and will, in fact, run its parent first
  47 ;; every time it is called.  For example, the commands
  48 ;;
  49 ;;  (define-derived-mode hypertext-mode text-mode "Hypertext"
  50 ;;    "Major mode for hypertext.\n\n\\{hypertext-mode-map}"
  51 ;;    (setq case-fold-search nil))
  52 ;;
  53 ;;  (define-key hypertext-mode-map [down-mouse-3] 'do-hyper-link)
  54 ;;
  55 ;; will create a function `hypertext-mode' with its own (sparse)
  56 ;; keymap `hypertext-mode-map.'  The command M-x hypertext-mode will
  57 ;; perform the following actions:
  58 ;;
  59 ;; - run the command (text-mode) to get its default setup
  60 ;; - replace the current keymap with 'hypertext-mode-map,' which will
  61 ;;   inherit from 'text-mode-map'.
  62 ;; - replace the current syntax table with
  63 ;;   'hypertext-mode-syntax-table', which will borrow its defaults
  64 ;;   from the current text-mode-syntax-table.
  65 ;; - replace the current abbrev table with
  66 ;;   'hypertext-mode-abbrev-table', which will borrow its defaults
  67 ;;   from the current text-mode-abbrev table
  68 ;; - change the mode line to read "Hypertext"
  69 ;; - assign the value 'hypertext-mode' to the 'major-mode' variable
  70 ;; - run the body of commands provided in the macro -- in this case,
  71 ;;   set the local variable `case-fold-search' to nil.
  72 ;; - **run the command (hypertext-mode-setup), which is empty by
  73 ;;   default, but may be redefined by the user to contain special
  74 ;;   commands (ie. setting local variables like 'outline-regexp')
  75 ;;   **NOTE: do not use this option -- it will soon be obsolete.
  76 ;; - run anything assigned to 'hypertext-mode-hooks' (obsolete, but
  77 ;;   supported for the sake of compatibility).
  78 ;;
  79 ;; The advantages of this system are threefold.  First, text mode is
  80 ;; untouched -- if you had added the new keystroke to `text-mode-map,'
  81 ;; possibly using hooks, you would have added it to all text buffers
  82 ;; -- here, it appears only in hypertext buffers, where it makes
  83 ;; sense.  Second, it is possible to build even further, and make
  84 ;; a derived mode from a derived mode.  The commands
  85 ;;
  86 ;;   (define-derived-mode html-mode hypertext-mode "HTML")
  87 ;;   [various key definitions]
  88 ;;
  89 ;; will add a new major mode for HTML with very little fuss.
  90 ;;
  91 ;; Note also the function `derived-mode-class,' which returns the non-derived
  92 ;; major mode which a derived mode is based on (ie. NOT necessarily the
  93 ;; immediate parent).
  94 ;;
  95 ;; (derived-mode-class 'text-mode) ==> text-mode
  96 ;; (derived-mode-class 'hypertext-mode) ==> text-mode
  97 ;; (derived-mode-class 'html-mode) ==> text-mode
  98 \f
  99 ;;; Code:
 100
 101 ;; PUBLIC: define a new major mode which inherits from an existing one.
 102
 103 ;;;###autoload
 104 (defmacro define-derived-mode (child parent name &optional docstring &rest body)
 105   "Create a new mode as a variant of an existing mode.
 106
 107 The arguments to this command are as follow:
 108
 109 PARENT:    the name of the command for the parent mode (ie. text-mode).
 110 CHILD:     the name of the command for the derived mode.
 111 NAME:      a string which will appear in the status line (ie. \"Hypertext\")
 112 DOCSTRING: an optional documentation string--if you do not supply one,
 113            the function will attempt to invent something useful.
 114 BODY:      forms to execute just before running the
 115            hooks for the new mode.
 116
 117 Here is how you could define LaTeX-Thesis mode as a variant of LaTeX mode:
 118
 119   (define-derived-mode LaTeX-thesis-mode LaTeX-mode \"LaTeX-Thesis\")
 120
 121 You could then make new key bindings for `LaTeX-thesis-mode-map'
 122 without changing regular LaTeX mode.  In this example, BODY is empty,
 123 and DOCSTRING is generated by default.
 124
 125 On a more complicated level, the following command uses sgml-mode as
 126 the parent, and then sets the variable `case-fold-search' to nil:
 127
 128   (define-derived-mode article-mode sgml-mode \"Article\"
 129     \"Major mode for editing technical articles.\"
 130     (setq case-fold-search nil))
 131
 132 Note that if the documentation string had been left out, it would have
 133 been generated automatically, with a reference to the keymap."
 134
 135                                         ; Some trickiness, since what
 136                                         ; appears to be the docstring
 137                                         ; may really be the first
 138                                         ; element of the body.
 139   (if (and docstring (not (stringp docstring)))
 140       (progn (setq body (cons docstring body))
 141              (setq docstring nil)))
 142   (setq docstring (or docstring (derived-mode-make-docstring parent child)))
 143
 144   (` (progn
 145        (derived-mode-init-mode-variables (quote (, child)))
 146        (defun (, child) ()
 147          (, docstring)
 148          (interactive)
 149                                         ; Run the parent.
 150          ((, parent))
 151                                         ; Identify special modes.
 152          (if (get (quote (, parent)) 'special)
 153              (put (quote (, child)) 'special t))
 154                                         ; Identify the child mode.
 155          (setq major-mode (quote (, child)))
 156          (setq mode-name (, name))
 157                                         ; Set up maps and tables.
 158          (derived-mode-set-keymap (quote (, child)))
 159          (derived-mode-set-syntax-table (quote (, child)))
 160          (derived-mode-set-abbrev-table (quote (, child)))
 161                                         ; Splice in the body (if any).
 162          (,@ body)
 163 ;;;                                     ; Run the setup function, if
 164 ;;;                                     ; any -- this will soon be
 165 ;;;                                     ; obsolete.
 166 ;;;      (derived-mode-run-setup-function (quote (, child)))
 167                                         ; Run the hooks, if any.
 168          (derived-mode-run-hooks (quote (, child)))))))
 169
 170
 171 ;; PUBLIC: find the ultimate class of a derived mode.
 172
 173 (defun derived-mode-class (mode)
 174   "Find the class of a major mode.
 175 A mode's class is the first ancestor which is NOT a derived mode.
 176 Use the `derived-mode-parent' property of the symbol to trace backwards."
 177   (while (get mode 'derived-mode-parent)
 178     (setq mode (get mode 'derived-mode-parent)))
 179   mode)
 180
 181 \f
 182 ;; Inline functions to construct various names from a mode name.
 183
 184 (defsubst derived-mode-setup-function-name (mode)
 185   "Construct a setup-function name based on a mode name."
 186   (intern (concat (symbol-name mode) "-setup")))
 187
 188 (defsubst derived-mode-hooks-name (mode)
 189   "Construct a hooks name based on a mode name."
 190   (intern (concat (symbol-name mode) "-hooks")))
 191
 192 (defsubst derived-mode-map-name (mode)
 193   "Construct a map name based on a mode name."
 194   (intern (concat (symbol-name mode) "-map")))
 195
 196 (defsubst derived-mode-syntax-table-name (mode)
 197   "Construct a syntax-table name based on a mode name."
 198   (intern (concat (symbol-name mode) "-syntax-table")))
 199
 200 (defsubst derived-mode-abbrev-table-name (mode)
 201   "Construct an abbrev-table name based on a mode name."
 202   (intern (concat (symbol-name mode) "-abbrev-table")))
 203
 204 \f
 205 ;; Utility functions for defining a derived mode.
 206
 207 ;;;###autoload
 208 (defun derived-mode-init-mode-variables (mode)
 209   "Initialise variables for a new mode.
 210 Right now, if they don't already exist, set up a blank keymap, an
 211 empty syntax table, and an empty abbrev table -- these will be merged
 212 the first time the mode is used."
 213
 214   (if (boundp (derived-mode-map-name mode))
 215       t
 216     (eval (` (defvar (, (derived-mode-map-name mode))
 217                (make-sparse-keymap)
 218                (, (format "Keymap for %s." mode)))))
 219     (put (derived-mode-map-name mode) 'derived-mode-unmerged t))
 220
 221   (if (boundp (derived-mode-syntax-table-name mode))
 222       t
 223     (eval (` (defvar (, (derived-mode-syntax-table-name mode))
 224                (make-vector 256 nil)
 225                (, (format "Syntax table for %s." mode)))))
 226     (put (derived-mode-syntax-table-name mode) 'derived-mode-unmerged t))
 227
 228   (if (boundp (derived-mode-abbrev-table-name mode))
 229       t
 230     (eval (` (defvar (, (derived-mode-abbrev-table-name mode))
 231                (progn (define-abbrev-table (derived-mode-abbrev-table-name mode) nil)
 232                       (make-abbrev-table))
 233                (, (format "Abbrev table for %s." mode)))))))
 234
 235 (defun derived-mode-make-docstring (parent child)
 236   "Construct a docstring for a new mode if none is provided."
 237
 238   (format "This major mode is a variant of `%s', created by `define-derived-mode'.
 239 It inherits all of the parent's attributes, but has its own keymap,
 240 abbrev table and syntax table:
 241
 242   `%s-map' and `%s-syntax-table'
 243
 244 which more-or-less shadow
 245
 246   `%s-map' and `%s-syntax-table'
 247
 248 \\{%s-map}" parent child child parent parent child))
 249
 250 \f
 251 ;; Utility functions for running a derived mode.
 252
 253 (defun derived-mode-set-keymap (mode)
 254   "Set the keymap of the new mode, maybe merging with the parent."
 255   (let* ((map-name (derived-mode-map-name mode))
 256          (new-map (eval map-name))
 257          (old-map (current-local-map)))
 258     (if (get map-name 'derived-mode-unmerged)
 259         (derived-mode-merge-keymaps old-map new-map))
 260     (put map-name 'derived-mode-unmerged nil)
 261     (use-local-map new-map)))
 262
 263 (defun derived-mode-set-syntax-table (mode)
 264   "Set the syntax table of the new mode, maybe merging with the parent."
 265   (let* ((table-name (derived-mode-syntax-table-name mode))
 266          (old-table (syntax-table))
 267          (new-table (eval table-name)))
 268     (if (get table-name 'derived-mode-unmerged)
 269         (derived-mode-merge-syntax-tables old-table new-table))
 270     (put table-name 'derived-mode-unmerged nil)
 271     (set-syntax-table new-table)))
 272
 273 (defun derived-mode-set-abbrev-table (mode)
 274   "Set the abbrev table if it exists.
 275 Always merge its parent into it, since the merge is non-destructive."
 276   (let* ((table-name (derived-mode-abbrev-table-name mode))
 277          (old-table local-abbrev-table)
 278          (new-table (eval table-name)))
 279     (derived-mode-merge-abbrev-tables old-table new-table)
 280     (setq local-abbrev-table new-table)))
 281
 282 ;;;(defun derived-mode-run-setup-function (mode)
 283 ;;;  "Run the setup function if it exists."
 284
 285 ;;;  (let ((fname (derived-mode-setup-function-name mode)))
 286 ;;;    (if (fboundp fname)
 287 ;;;     (funcall fname))))
 288
 289 (defun derived-mode-run-hooks (mode)
 290   "Run the hooks if they exist."
 291
 292   (let ((hooks-name (derived-mode-hooks-name mode)))
 293     (if (boundp hooks-name)
 294         (run-hooks hooks-name))))
 295
 296 ;; Functions to merge maps and tables.
 297
 298 (defun derived-mode-merge-keymaps (old new)
 299   "Merge an old keymap into a new one.
 300 The old keymap is set to be the cdr of the new one, so that there will
 301 be automatic inheritance."
 302   (setcdr (nthcdr (1- (length new)) new) old))
 303
 304 (defun derived-mode-merge-syntax-tables (old new)
 305   "Merge an old syntax table into a new one.
 306 Where the new table already has an entry, nothing is copied from the old one."
 307   (let ((idx 0)
 308         (end (min (length new) (length old))))
 309     (while (< idx end)
 310       (if (not (aref new idx))
 311           (aset new idx (aref old idx)))
 312       (setq idx (1+ idx)))))
 313
 314 ;; Merge an old abbrev table into a new one.
 315 ;; This function requires internal knowledge of how abbrev tables work,
 316 ;; presuming that they are obarrays with the abbrev as the symbol, the expansion
 317 ;; as the value of the symbol, and the hook as the function definition.
 318 (defun derived-mode-merge-abbrev-tables (old new)
 319   (if old
 320       (mapatoms
 321        (function
 322         (lambda (symbol)
 323           (or (intern-soft (symbol-name symbol) new)
 324               (define-abbrev new (symbol-name symbol)
 325                 (symbol-value symbol) (symbol-function symbol)))))
 326        old)))
 327
 328 (provide 'derived)
 329
 330 ;;; derived.el ends here