X-Git-Url: https://git.hcoop.net/bpt/emacs.git/blobdiff_plain/b72226e37e48efc1ad2c3af40d9c8fd7dd27ebbd..01a314694499b7245c21b05a0a48bc22ae8ab575:/lisp/derived.el diff --git a/lisp/derived.el b/lisp/derived.el index 3a89407749..d50ac6d288 100644 --- a/lisp/derived.el +++ b/lisp/derived.el @@ -1,8 +1,10 @@ -;;; mode-clone.el (alpha version) -- allow inheritance of major modes. +;;; derived.el --- allow inheritance of major modes. +;;; (formerly mode-clone.el) -;; Copyright (C) 1993 Free Software Foundation, Inc. +;; Copyright (C) 1993, 1994 Free Software Foundation, Inc. ;; Author: David Megginson (dmeggins@aix1.uottawa.ca) +;; Maintainer: FSF ;; This file is part of GNU Emacs. @@ -17,8 +19,9 @@ ;; GNU General Public License for more details. ;; You should have received a copy of the GNU General Public License -;; along with GNU Emacs; see the file COPYING. If not, write to -;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. +;; along with GNU Emacs; see the file COPYING. If not, write to the +;; Free Software Foundation, Inc., 59 Temple Place - Suite 330, +;; Boston, MA 02111-1307, USA. ;;; Commentary: @@ -39,12 +42,12 @@ ;; ;; In the mean time, this package offers most of the advantages of ;; full inheritance with the existing major modes. The macro -;; `define-mode-clone' allows the user to make a clone of an existing +;; `define-derived-mode' allows the user to make a variant of an existing ;; major mode, with its own keymap. The new mode will inherit the key ;; bindings of its parent, and will, in fact, run its parent first ;; every time it is called. For example, the commands ;; -;; (define-mode-clone hypertext-mode text-mode "Hypertext" +;; (define-derived-mode hypertext-mode text-mode "Hypertext" ;; "Major mode for hypertext.\n\n\\{hypertext-mode-map}" ;; (setq case-fold-search nil)) ;; @@ -60,8 +63,9 @@ ;; - replace the current syntax table with ;; 'hypertext-mode-syntax-table', which will borrow its defaults ;; from the current text-mode-syntax-table. -;; - if 'hypertext-mode-abbrev-table' exists, it will become the -;; current abbrev table. +;; - replace the current abbrev table with +;; 'hypertext-mode-abbrev-table', which will borrow its defaults +;; from the current text-mode-abbrev table ;; - change the mode line to read "Hypertext" ;; - assign the value 'hypertext-mode' to the 'major-mode' variable ;; - run the body of commands provided in the macro -- in this case, @@ -77,53 +81,52 @@ ;; untouched -- if you had added the new keystroke to `text-mode-map,' ;; possibly using hooks, you would have added it to all text buffers ;; -- here, it appears only in hypertext buffers, where it makes -;; sense. Second, it is possible to build even further, and clone the -;; clone. The commands +;; sense. Second, it is possible to build even further, and make +;; a derived mode from a derived mode. The commands ;; -;; (define-mode-clone html-mode hypertext-mode "HTML") +;; (define-derived-mode html-mode hypertext-mode "HTML") ;; [various key definitions] ;; ;; will add a new major mode for HTML with very little fuss. ;; -;; Note also the function `clone-class,' which returns the non-clone -;; major mode which a clone is based on (ie. NOT necessarily the +;; Note also the function `derived-mode-class,' which returns the non-derived +;; major mode which a derived mode is based on (ie. NOT necessarily the ;; immediate parent). ;; -;; (clone-class 'text-mode) ==> text-mode -;; (clone-class 'hypertext-mode) ==> text-mode -;; (clone-class 'html-mode) ==> text-mode +;; (derived-mode-class 'text-mode) ==> text-mode +;; (derived-mode-class 'hypertext-mode) ==> text-mode +;; (derived-mode-class 'html-mode) ==> text-mode ;;; Code: ;; PUBLIC: define a new major mode which inherits from an existing one. ;;;###autoload -(defmacro define-mode-clone (child parent name &optional docstring &rest body) - "Create a new mode which is similar to an old one. +(defmacro define-derived-mode (child parent name &optional docstring &rest body) + "Create a new mode as a variant of an existing mode. The arguments to this command are as follow: +CHILD: the name of the command for the derived mode. PARENT: the name of the command for the parent mode (ie. text-mode). -CHILD: the name of the command for the clone mode. NAME: a string which will appear in the status line (ie. \"Hypertext\") DOCSTRING: an optional documentation string--if you do not supply one, the function will attempt to invent something useful. BODY: forms to execute just before running the hooks for the new mode. -The following simple command would clone LaTeX mode into -LaTeX-Thesis mode: +Here is how you could define LaTeX-Thesis mode as a variant of LaTeX mode: - (define-mode-clone LaTeX-thesis-mode LaTeX-mode \"LaTeX-Thesis\") + (define-derived-mode LaTeX-thesis-mode LaTeX-mode \"LaTeX-Thesis\") You could then make new key bindings for `LaTeX-thesis-mode-map' without changing regular LaTeX mode. In this example, BODY is empty, and DOCSTRING is generated by default. -On a more complicated level, the following command would clone -sgml-mode and change the variable `case-fold-search' to nil: +On a more complicated level, the following command uses sgml-mode as +the parent, and then sets the variable `case-fold-search' to nil: - (define-mode-clone article-mode sgml-mode \"Article\" + (define-derived-mode article-mode sgml-mode \"Article\" \"Major mode for editing technical articles.\" (setq case-fold-search nil)) @@ -137,94 +140,107 @@ been generated automatically, with a reference to the keymap." (if (and docstring (not (stringp docstring))) (progn (setq body (cons docstring body)) (setq docstring nil))) - (setq docstring (or docstring (clone-make-docstring parent child))) + (setq docstring (or docstring (derived-mode-make-docstring parent child))) (` (progn - (clone-init-mode-variables (quote (, child))) + (derived-mode-init-mode-variables '(, child)) + (put '(, child) 'derived-mode-parent '(, parent)) (defun (, child) () (, docstring) (interactive) ; Run the parent. ((, parent)) ; Identify special modes. - (if (get (quote (, parent)) 'special) - (put (quote (, child)) 'special t)) + (if (get '(, parent) 'special) + (put '(, child) 'special t)) ; Identify the child mode. - (setq major-mode (quote (, child))) + (setq major-mode '(, child)) (setq mode-name (, name)) ; Set up maps and tables. - (clone-set-keymap (quote (, child))) - (clone-set-syntax-table (quote (, child))) - (clone-set-abbrev-table (quote (, child))) + (derived-mode-set-keymap '(, child)) + (derived-mode-set-syntax-table '(, child)) + (derived-mode-set-abbrev-table '(, child)) ; Splice in the body (if any). (,@ body) ;;; ; Run the setup function, if ;;; ; any -- this will soon be ;;; ; obsolete. -;;; (clone-run-setup-function (quote (, child))) +;;; (derived-mode-run-setup-function '(, child)) ; Run the hooks, if any. - (clone-run-hooks (quote (, child))))))) + (derived-mode-run-hooks '(, child)))))) -;; PUBLIC: find the ultimate class of a clone mode. +;; PUBLIC: find the ultimate class of a derived mode. -(defun clone-class (mode) +(defun derived-mode-class (mode) "Find the class of a major mode. -A mode's class is the first ancestor which is NOT a clone. -Use the `clone-parent' property of the symbol to trace backwards." - (while (get mode 'clone-parent) - (setq mode (get mode 'clone-parent))) +A mode's class is the first ancestor which is NOT a derived mode. +Use the `derived-mode-parent' property of the symbol to trace backwards." + (while (get mode 'derived-mode-parent) + (setq mode (get mode 'derived-mode-parent))) mode) ;; Inline functions to construct various names from a mode name. -(defsubst clone-setup-function-name (mode) +(defsubst derived-mode-setup-function-name (mode) "Construct a setup-function name based on a mode name." (intern (concat (symbol-name mode) "-setup"))) -(defsubst clone-hooks-name (mode) +(defsubst derived-mode-hooks-name (mode) "Construct a hooks name based on a mode name." (intern (concat (symbol-name mode) "-hooks"))) -(defsubst clone-map-name (mode) +(defsubst derived-mode-map-name (mode) "Construct a map name based on a mode name." (intern (concat (symbol-name mode) "-map"))) -(defsubst clone-syntax-table-name (mode) +(defsubst derived-mode-syntax-table-name (mode) "Construct a syntax-table name based on a mode name." (intern (concat (symbol-name mode) "-syntax-table"))) -(defsubst clone-abbrev-table-name (mode) +(defsubst derived-mode-abbrev-table-name (mode) "Construct an abbrev-table name based on a mode name." (intern (concat (symbol-name mode) "-abbrev-table"))) -;; Utility functions for defining a clone mode. +;; Utility functions for defining a derived mode. -(defun clone-init-mode-variables (mode) - "Initialise variables for a new mode. -Right now, just set up a blank keymap and an empty syntax table." - - (eval (` (defvar (, (clone-map-name mode)) - (make-sparse-keymap) - (, (format "Keymap for %s." mode))))) - (put (clone-map-name mode) 'clone-merged nil) - - (eval (` (defvar (, (clone-syntax-table-name mode)) - (make-vector 256 nil) - (, (format "Syntax table for %s." mode))))) - (put (clone-syntax-table-name mode) 'clone-merged nil) - - (eval (` (defvar (, (clone-abbrev-table-name mode)) - nil - (, (format "Abbrev table for %s." mode))))) - (define-abbrev-table (clone-abbrev-table-name mode) ())) - -(defun clone-make-docstring (parent child) +;;;###autoload +(defun derived-mode-init-mode-variables (mode) + "Initialise variables for a new mode. +Right now, if they don't already exist, set up a blank keymap, an +empty syntax table, and an empty abbrev table -- these will be merged +the first time the mode is used." + + (if (boundp (derived-mode-map-name mode)) + t + (eval (` (defvar (, (derived-mode-map-name mode)) + (make-sparse-keymap) + (, (format "Keymap for %s." mode))))) + (put (derived-mode-map-name mode) 'derived-mode-unmerged t)) + + (if (boundp (derived-mode-syntax-table-name mode)) + t + (eval (` (defvar (, (derived-mode-syntax-table-name mode)) + ;; Make a syntax table which doesn't specify anything + ;; for any char. Valid data will be merged in by + ;; derived-mode-merge-syntax-tables. + (make-char-table 'syntax-table nil) + (, (format "Syntax table for %s." mode))))) + (put (derived-mode-syntax-table-name mode) 'derived-mode-unmerged t)) + + (if (boundp (derived-mode-abbrev-table-name mode)) + t + (eval (` (defvar (, (derived-mode-abbrev-table-name mode)) + (progn (define-abbrev-table (derived-mode-abbrev-table-name mode) nil) + (make-abbrev-table)) + (, (format "Abbrev table for %s." mode))))))) + +(defun derived-mode-make-docstring (parent child) "Construct a docstring for a new mode if none is provided." - (format "This major mode is a clone of `%s', created by `define-mode-clone'. + (format "This major mode is a variant of `%s', created by `define-derived-mode'. It inherits all of the parent's attributes, but has its own keymap, abbrev table and syntax table: @@ -237,68 +253,101 @@ which more-or-less shadow \\{%s-map}" parent child child parent parent child)) -;; Utility functions for running a clone mode. +;; Utility functions for running a derived mode. -(defun clone-set-keymap (mode) +(defun derived-mode-set-keymap (mode) "Set the keymap of the new mode, maybe merging with the parent." - (let* ((map-name (clone-map-name mode)) + (let* ((map-name (derived-mode-map-name mode)) (new-map (eval map-name)) (old-map (current-local-map))) - (if (get map-name 'clone-merged) - (use-local-map new-map) - (put map-name 'clone-merged t) - (use-local-map (set map-name (clone-merge-keymaps old-map new-map)))))) + (and old-map + (get map-name 'derived-mode-unmerged) + (derived-mode-merge-keymaps old-map new-map)) + (put map-name 'derived-mode-unmerged nil) + (use-local-map new-map))) -(defun clone-set-syntax-table (mode) +(defun derived-mode-set-syntax-table (mode) "Set the syntax table of the new mode, maybe merging with the parent." - (let* ((table-name (clone-syntax-table-name mode)) + (let* ((table-name (derived-mode-syntax-table-name mode)) (old-table (syntax-table)) (new-table (eval table-name))) - (if (get table-name 'clone-merged) - t - (clone-merge-syntax-tables old-table new-table)) - (set-syntax-table new-table) - (put table-name 'clone-merged t))) - -(defun clone-set-abbrev-table (mode) - "Set the abbrev table if it exists." - (let* ((table-name (clone-abbrev-table-name mode)) - (table (and (boundp table-name) (eval table-name)))) - (if table - (setq local-abbrev-table table)))) - -;;;(defun clone-run-setup-function (mode) + (if (get table-name 'derived-mode-unmerged) + (derived-mode-merge-syntax-tables old-table new-table)) + (put table-name 'derived-mode-unmerged nil) + (set-syntax-table new-table))) + +(defun derived-mode-set-abbrev-table (mode) + "Set the abbrev table if it exists. +Always merge its parent into it, since the merge is non-destructive." + (let* ((table-name (derived-mode-abbrev-table-name mode)) + (old-table local-abbrev-table) + (new-table (eval table-name))) + (derived-mode-merge-abbrev-tables old-table new-table) + (setq local-abbrev-table new-table))) + +;;;(defun derived-mode-run-setup-function (mode) ;;; "Run the setup function if it exists." -;;; (let ((fname (clone-setup-function-name mode))) +;;; (let ((fname (derived-mode-setup-function-name mode))) ;;; (if (fboundp fname) ;;; (funcall fname)))) -(defun clone-run-hooks (mode) +(defun derived-mode-run-hooks (mode) "Run the hooks if they exist." - (let ((hooks-name (clone-hooks-name mode))) + (let ((hooks-name (derived-mode-hooks-name mode))) (if (boundp hooks-name) (run-hooks hooks-name)))) ;; Functions to merge maps and tables. -(defun clone-merge-keymaps (old new) - "Merge a new keymap into an old one. -The old keymap is set to be the cdr of the new one, so that there will +(defun derived-mode-merge-keymaps (old new) + "Merge an old keymap into a new one. +The old keymap is set to be the last cdr of the new one, so that there will be automatic inheritance." - (append new old)) - -(defun clone-merge-syntax-tables (old new) - "Merge a new syntax table into an old one. + (let ((tail new)) + ;; Scan the NEW map for prefix keys. + (while (consp tail) + (and (consp (car tail)) + (let* ((key (vector (car (car tail)))) + (subnew (lookup-key new key)) + (subold (lookup-key old key))) + ;; If KEY is a prefix key in both OLD and NEW, merge them. + (and (keymapp subnew) (keymapp subold) + (derived-mode-merge-keymaps subold subnew)))) + (and (vectorp (car tail)) + ;; Search a vector of ASCII char bindings for prefix keys. + (let ((i (1- (length (car tail))))) + (while (>= i 0) + (let* ((key (vector i)) + (subnew (lookup-key new key)) + (subold (lookup-key old key))) + ;; If KEY is a prefix key in both OLD and NEW, merge them. + (and (keymapp subnew) (keymapp subold) + (derived-mode-merge-keymaps subold subnew))) + (setq i (1- i))))) + (setq tail (cdr tail)))) + (setcdr (nthcdr (1- (length new)) new) old)) + +(defun derived-mode-merge-syntax-tables (old new) + "Merge an old syntax table into a new one. Where the new table already has an entry, nothing is copied from the old one." - (let ((idx 0) - (end (min (length new) (length old)))) - (while (< idx end) - (if (not (aref new idx)) - (aset new idx (aref old idx))) - (setq idx (1+ idx))))) + (set-char-table-parent new old)) + +;; Merge an old abbrev table into a new one. +;; This function requires internal knowledge of how abbrev tables work, +;; presuming that they are obarrays with the abbrev as the symbol, the expansion +;; as the value of the symbol, and the hook as the function definition. +(defun derived-mode-merge-abbrev-tables (old new) + (if old + (mapatoms + (function + (lambda (symbol) + (or (intern-soft (symbol-name symbol) new) + (define-abbrev new (symbol-name symbol) + (symbol-value symbol) (symbol-function symbol))))) + old))) -(provide 'mode-clone) +(provide 'derived) -;;; mode-clone.el ends here +;;; derived.el ends here