1 ;;; derived.el --- allow inheritance of major modes.
2 ;;; (formerly mode-clone.el)
4 ;; Copyright (C) 1993, 1994, 1999 Free Software Foundation, Inc.
6 ;; Author: David Megginson (dmeggins@aix1.uottawa.ca)
8 ;; Keywords: extensions
10 ;; This file is part of GNU Emacs.
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 2, or (at your option)
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.
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., 59 Temple Place - Suite 330,
25 ;; Boston, MA 02111-1307, USA.
30 ;; Use the `derived-major-mode' provided by easy-mmode.el instead.
31 ;; It is only kept for backward compatibility with byte-compiled files
32 ;; which refer to `derived-mode-init-mode-variables' and other functions.
36 ;; GNU Emacs is already, in a sense, object oriented -- each object
37 ;; (buffer) belongs to a class (major mode), and that class defines
38 ;; the relationship between messages (input events) and methods
39 ;; (commands) by means of a keymap.
41 ;; The only thing missing is a good scheme of inheritance. It is
42 ;; possible to simulate a single level of inheritance with generous
43 ;; use of hooks and a bit of work -- sgml-mode, for example, also runs
44 ;; the hooks for text-mode, and keymaps can inherit from other keymaps
45 ;; -- but generally, each major mode ends up reinventing the wheel.
46 ;; Ideally, someone should redesign all of Emacs's major modes to
47 ;; follow a more conventional object-oriented system: when defining a
48 ;; new major mode, the user should need only to name the existing mode
49 ;; it is most similar to, then list the (few) differences.
51 ;; In the mean time, this package offers most of the advantages of
52 ;; full inheritance with the existing major modes. The macro
53 ;; `define-derived-mode' allows the user to make a variant of an existing
54 ;; major mode, with its own keymap. The new mode will inherit the key
55 ;; bindings of its parent, and will, in fact, run its parent first
56 ;; every time it is called. For example, the commands
58 ;; (define-derived-mode hypertext-mode text-mode "Hypertext"
59 ;; "Major mode for hypertext.\n\n\\{hypertext-mode-map}"
60 ;; (setq case-fold-search nil))
62 ;; (define-key hypertext-mode-map [down-mouse-3] 'do-hyper-link)
64 ;; will create a function `hypertext-mode' with its own (sparse)
65 ;; keymap `hypertext-mode-map.' The command M-x hypertext-mode will
66 ;; perform the following actions:
68 ;; - run the command (text-mode) to get its default setup
69 ;; - replace the current keymap with 'hypertext-mode-map,' which will
70 ;; inherit from 'text-mode-map'.
71 ;; - replace the current syntax table with
72 ;; 'hypertext-mode-syntax-table', which will borrow its defaults
73 ;; from the current text-mode-syntax-table.
74 ;; - replace the current abbrev table with
75 ;; 'hypertext-mode-abbrev-table', which will borrow its defaults
76 ;; from the current text-mode-abbrev table
77 ;; - change the mode line to read "Hypertext"
78 ;; - assign the value 'hypertext-mode' to the 'major-mode' variable
79 ;; - run the body of commands provided in the macro -- in this case,
80 ;; set the local variable `case-fold-search' to nil.
82 ;; The advantages of this system are threefold. First, text mode is
83 ;; untouched -- if you had added the new keystroke to `text-mode-map,'
84 ;; possibly using hooks, you would have added it to all text buffers
85 ;; -- here, it appears only in hypertext buffers, where it makes
86 ;; sense. Second, it is possible to build even further, and make
87 ;; a derived mode from a derived mode. The commands
89 ;; (define-derived-mode html-mode hypertext-mode "HTML")
90 ;; [various key definitions]
92 ;; will add a new major mode for HTML with very little fuss.
94 ;; Note also the function `derived-mode-class,' which returns the non-derived
95 ;; major mode which a derived mode is based on (ie. NOT necessarily the
98 ;; (derived-mode-class 'text-mode) ==> text-mode
99 ;; (derived-mode-class 'hypertext-mode) ==> text-mode
100 ;; (derived-mode-class 'html-mode) ==> text-mode
104 ;; PUBLIC: define a new major mode which inherits from an existing one.
107 (defmacro define-derived-mode
(child parent name
&optional docstring
&rest body
)
108 "Create a new mode as a variant of an existing mode.
110 The arguments to this command are as follow:
112 CHILD: the name of the command for the derived mode.
113 PARENT: the name of the command for the parent mode (e.g. `text-mode').
114 NAME: a string which will appear in the status line (e.g. \"Hypertext\")
115 DOCSTRING: an optional documentation string--if you do not supply one,
116 the function will attempt to invent something useful.
117 BODY: forms to execute just before running the
118 hooks for the new mode.
120 Here is how you could define LaTeX-Thesis mode as a variant of LaTeX mode:
122 (define-derived-mode LaTeX-thesis-mode LaTeX-mode \"LaTeX-Thesis\")
124 You could then make new key bindings for `LaTeX-thesis-mode-map'
125 without changing regular LaTeX mode. In this example, BODY is empty,
126 and DOCSTRING is generated by default.
128 On a more complicated level, the following command uses `sgml-mode' as
129 the parent, and then sets the variable `case-fold-search' to nil:
131 (define-derived-mode article-mode sgml-mode \"Article\"
132 \"Major mode for editing technical articles.\"
133 (setq case-fold-search nil))
135 Note that if the documentation string had been left out, it would have
136 been generated automatically, with a reference to the keymap."
138 ; Some trickiness, since what
139 ; appears to be the docstring
140 ; may really be the first
141 ; element of the body.
142 (if (and docstring
(not (stringp docstring
)))
143 (progn (setq body
(cons docstring body
))
144 (setq docstring nil
)))
145 (setq docstring
(or docstring
(derived-mode-make-docstring parent child
)))
148 (derived-mode-init-mode-variables (quote ,child
))
154 ; Identify special modes.
155 (if (get (quote ,parent
) 'special
)
156 (put (quote ,child
) 'special t
))
157 ; Identify the child mode.
158 (setq major-mode
(quote ,child
))
159 (setq mode-name
,name
)
160 ; Set up maps and tables.
161 (derived-mode-set-keymap (quote ,child
))
162 (derived-mode-set-syntax-table (quote ,child
))
163 (derived-mode-set-abbrev-table (quote ,child
))
164 ; Splice in the body (if any).
166 ;;; ; Run the setup function, if
167 ;;; ; any -- this will soon be
169 ;;; (derived-mode-run-setup-function (quote ,child))
170 ; Run the hooks, if any.
171 (derived-mode-run-hooks (quote ,child
)))))
174 ;; PUBLIC: find the ultimate class of a derived mode.
176 (defun derived-mode-class (mode)
177 "Find the class of a major MODE.
178 A mode's class is the first ancestor which is NOT a derived mode.
179 Use the `derived-mode-parent' property of the symbol to trace backwards."
180 (while (get mode
'derived-mode-parent
)
181 (setq mode
(get mode
'derived-mode-parent
)))
185 ;; Inline functions to construct various names from a mode name.
187 (defsubst derived-mode-setup-function-name
(mode)
188 "Construct a setup-function name based on a MODE name."
189 (intern (concat (symbol-name mode
) "-setup")))
191 (defsubst derived-mode-hook-name
(mode)
192 "Construct the mode hook name based on mode name MODE."
193 (intern (concat (symbol-name mode
) "-hook")))
195 (defsubst derived-mode-map-name
(mode)
196 "Construct a map name based on a MODE name."
197 (intern (concat (symbol-name mode
) "-map")))
199 (defsubst derived-mode-syntax-table-name
(mode)
200 "Construct a syntax-table name based on a MODE name."
201 (intern (concat (symbol-name mode
) "-syntax-table")))
203 (defsubst derived-mode-abbrev-table-name
(mode)
204 "Construct an abbrev-table name based on a MODE name."
205 (intern (concat (symbol-name mode
) "-abbrev-table")))
208 ;; Utility functions for defining a derived mode.
211 (defun derived-mode-init-mode-variables (mode)
212 "Initialise variables for a new MODE.
213 Right now, if they don't already exist, set up a blank keymap, an
214 empty syntax table, and an empty abbrev table -- these will be merged
215 the first time the mode is used."
217 (if (boundp (derived-mode-map-name mode
))
219 (eval `(defvar ,(derived-mode-map-name mode
)
221 ,(format "Keymap for %s." mode
)))
222 (put (derived-mode-map-name mode
) 'derived-mode-unmerged t
))
224 (if (boundp (derived-mode-syntax-table-name mode
))
226 (eval `(defvar ,(derived-mode-syntax-table-name mode
)
227 ;; Make a syntax table which doesn't specify anything
228 ;; for any char. Valid data will be merged in by
229 ;; derived-mode-merge-syntax-tables.
230 (make-char-table 'syntax-table nil
)
231 ,(format "Syntax table for %s." mode
)))
232 (put (derived-mode-syntax-table-name mode
) 'derived-mode-unmerged t
))
234 (if (boundp (derived-mode-abbrev-table-name mode
))
236 (eval `(defvar ,(derived-mode-abbrev-table-name mode
)
238 (define-abbrev-table (derived-mode-abbrev-table-name mode
) nil
)
240 ,(format "Abbrev table for %s." mode
)))))
242 (defun derived-mode-make-docstring (parent child
)
243 "Construct a docstring for a new mode if none is provided."
245 (format "This major mode is a variant of `%s', created by `define-derived-mode'.
246 It inherits all of the parent's attributes, but has its own keymap,
247 abbrev table and syntax table:
249 `%s-map' and `%s-syntax-table'
251 which more-or-less shadow
253 `%s-map' and `%s-syntax-table'
255 \\{%s-map}" parent child child parent parent child
))
258 ;; Utility functions for running a derived mode.
260 (defun derived-mode-set-keymap (mode)
261 "Set the keymap of the new MODE, maybe merging with the parent."
262 (let* ((map-name (derived-mode-map-name mode
))
263 (new-map (eval map-name
))
264 (old-map (current-local-map)))
266 (get map-name
'derived-mode-unmerged
)
267 (derived-mode-merge-keymaps old-map new-map
))
268 (put map-name
'derived-mode-unmerged nil
)
269 (use-local-map new-map
)))
271 (defun derived-mode-set-syntax-table (mode)
272 "Set the syntax table of the new MODE, maybe merging with the parent."
273 (let* ((table-name (derived-mode-syntax-table-name mode
))
274 (old-table (syntax-table))
275 (new-table (eval table-name
)))
276 (if (get table-name
'derived-mode-unmerged
)
277 (derived-mode-merge-syntax-tables old-table new-table
))
278 (put table-name
'derived-mode-unmerged nil
)
279 (set-syntax-table new-table
)))
281 (defun derived-mode-set-abbrev-table (mode)
282 "Set the abbrev table for MODE if it exists.
283 Always merge its parent into it, since the merge is non-destructive."
284 (let* ((table-name (derived-mode-abbrev-table-name mode
))
285 (old-table local-abbrev-table
)
286 (new-table (eval table-name
)))
287 (derived-mode-merge-abbrev-tables old-table new-table
)
288 (setq local-abbrev-table new-table
)))
290 ;;;(defun derived-mode-run-setup-function (mode)
291 ;;; "Run the setup function if it exists."
293 ;;; (let ((fname (derived-mode-setup-function-name mode)))
294 ;;; (if (fboundp fname)
295 ;;; (funcall fname))))
297 (defun derived-mode-run-hooks (mode)
298 "Run the mode hook for MODE."
300 (let ((hooks-name (derived-mode-hook-name mode
)))
301 (if (boundp hooks-name
)
302 (run-hooks hooks-name
))))
304 ;; Functions to merge maps and tables.
306 (defun derived-mode-merge-keymaps (old new
)
307 "Merge an OLD keymap into a NEW one.
308 The old keymap is set to be the last cdr of the new one, so that there will
309 be automatic inheritance."
310 ;; ?? Can this just use `set-keymap-parent'?
312 ;; Scan the NEW map for prefix keys.
314 (and (consp (car tail
))
315 (let* ((key (vector (car (car tail
))))
316 (subnew (lookup-key new key
))
317 (subold (lookup-key old key
)))
318 ;; If KEY is a prefix key in both OLD and NEW, merge them.
319 (and (keymapp subnew
) (keymapp subold
)
320 (derived-mode-merge-keymaps subold subnew
))))
321 (and (vectorp (car tail
))
322 ;; Search a vector of ASCII char bindings for prefix keys.
323 (let ((i (1- (length (car tail
)))))
325 (let* ((key (vector i
))
326 (subnew (lookup-key new key
))
327 (subold (lookup-key old key
)))
328 ;; If KEY is a prefix key in both OLD and NEW, merge them.
329 (and (keymapp subnew
) (keymapp subold
)
330 (derived-mode-merge-keymaps subold subnew
)))
332 (setq tail
(cdr tail
))))
333 (setcdr (nthcdr (1- (length new
)) new
) old
))
335 (defun derived-mode-merge-syntax-tables (old new
)
336 "Merge an OLD syntax table into a NEW one.
337 Where the new table already has an entry, nothing is copied from the old one."
338 (set-char-table-parent new old
))
340 ;; Merge an old abbrev table into a new one.
341 ;; This function requires internal knowledge of how abbrev tables work,
342 ;; presuming that they are obarrays with the abbrev as the symbol, the expansion
343 ;; as the value of the symbol, and the hook as the function definition.
344 (defun derived-mode-merge-abbrev-tables (old new
)
348 (or (intern-soft (symbol-name symbol
) new
)
349 (define-abbrev new
(symbol-name symbol
)
350 (symbol-value symbol
) (symbol-function symbol
))))
355 ;;; derived.el ends here