Commit 06d35594 authored by Richard M. Stallman's avatar Richard M. Stallman
Browse files

Renamed from mode-clone.el.

All functions renamed.
(define-derived-mode): Renamed from define-mode-clone.
parent 497513ad
;;; mode-clone.el -- allow inheritance of major modes. ;;; derived.el -- allow inheritance of major modes.
;;; (formerly mode-clone.el)
;; Copyright (C) 1993, 1994 Free Software Foundation, Inc. ;; Copyright (C) 1993, 1994 Free Software Foundation, Inc.
...@@ -40,12 +41,12 @@ ...@@ -40,12 +41,12 @@
;; ;;
;; In the mean time, this package offers most of the advantages of ;; In the mean time, this package offers most of the advantages of
;; full inheritance with the existing major modes. The macro ;; 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 ;; 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 ;; bindings of its parent, and will, in fact, run its parent first
;; every time it is called. For example, the commands ;; 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}" ;; "Major mode for hypertext.\n\n\\{hypertext-mode-map}"
;; (setq case-fold-search nil)) ;; (setq case-fold-search nil))
;; ;;
...@@ -79,53 +80,52 @@ ...@@ -79,53 +80,52 @@
;; untouched -- if you had added the new keystroke to `text-mode-map,' ;; untouched -- if you had added the new keystroke to `text-mode-map,'
;; possibly using hooks, you would have added it to all text buffers ;; possibly using hooks, you would have added it to all text buffers
;; -- here, it appears only in hypertext buffers, where it makes ;; -- here, it appears only in hypertext buffers, where it makes
;; sense. Second, it is possible to build even further, and clone the ;; sense. Second, it is possible to build even further, and make
;; clone. The commands ;; 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] ;; [various key definitions]
;; ;;
;; will add a new major mode for HTML with very little fuss. ;; will add a new major mode for HTML with very little fuss.
;; ;;
;; Note also the function `clone-class,' which returns the non-clone ;; Note also the function `derived-mode-class,' which returns the non-derived
;; major mode which a clone is based on (ie. NOT necessarily the ;; major mode which a derived mode is based on (ie. NOT necessarily the
;; immediate parent). ;; immediate parent).
;; ;;
;; (clone-class 'text-mode) ==> text-mode ;; (derived-mode-class 'text-mode) ==> text-mode
;; (clone-class 'hypertext-mode) ==> text-mode ;; (derived-mode-class 'hypertext-mode) ==> text-mode
;; (clone-class 'html-mode) ==> text-mode ;; (derived-mode-class 'html-mode) ==> text-mode
;;; Code: ;;; Code:
;; PUBLIC: define a new major mode which inherits from an existing one. ;; PUBLIC: define a new major mode which inherits from an existing one.
;;;###autoload ;;;###autoload
(defmacro define-mode-clone (child parent name &optional docstring &rest body) (defmacro define-derived-mode (child parent name &optional docstring &rest body)
"Create a new mode which is similar to an old one. "Create a new mode as a variant of an existing mode.
The arguments to this command are as follow: The arguments to this command are as follow:
PARENT: the name of the command for the parent mode (ie. text-mode). PARENT: the name of the command for the parent mode (ie. text-mode).
CHILD: the name of the command for the clone mode. CHILD: the name of the command for the derived mode.
NAME: a string which will appear in the status line (ie. \"Hypertext\") NAME: a string which will appear in the status line (ie. \"Hypertext\")
DOCSTRING: an optional documentation string--if you do not supply one, DOCSTRING: an optional documentation string--if you do not supply one,
the function will attempt to invent something useful. the function will attempt to invent something useful.
BODY: forms to execute just before running the BODY: forms to execute just before running the
hooks for the new mode. hooks for the new mode.
The following simple command would clone LaTeX mode into Here is how you could define LaTeX-Thesis mode as a variant of LaTeX mode:
LaTeX-Thesis 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' You could then make new key bindings for `LaTeX-thesis-mode-map'
without changing regular LaTeX mode. In this example, BODY is empty, without changing regular LaTeX mode. In this example, BODY is empty,
and DOCSTRING is generated by default. and DOCSTRING is generated by default.
On a more complicated level, the following command would clone On a more complicated level, the following command uses sgml-mode as
sgml-mode and change the variable `case-fold-search' to nil: 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.\" \"Major mode for editing technical articles.\"
(setq case-fold-search nil)) (setq case-fold-search nil))
...@@ -139,10 +139,10 @@ been generated automatically, with a reference to the keymap." ...@@ -139,10 +139,10 @@ been generated automatically, with a reference to the keymap."
(if (and docstring (not (stringp docstring))) (if (and docstring (not (stringp docstring)))
(progn (setq body (cons docstring body)) (progn (setq body (cons docstring body))
(setq docstring nil))) (setq docstring nil)))
(setq docstring (or docstring (clone-make-docstring parent child))) (setq docstring (or docstring (derived-mode-make-docstring parent child)))
(` (progn (` (progn
(clone-init-mode-variables (quote (, child))) (derived-mode-init-mode-variables (quote (, child)))
(defun (, child) () (defun (, child) ()
(, docstring) (, docstring)
(interactive) (interactive)
...@@ -155,86 +155,86 @@ been generated automatically, with a reference to the keymap." ...@@ -155,86 +155,86 @@ been generated automatically, with a reference to the keymap."
(setq major-mode (quote (, child))) (setq major-mode (quote (, child)))
(setq mode-name (, name)) (setq mode-name (, name))
; Set up maps and tables. ; Set up maps and tables.
(clone-set-keymap (quote (, child))) (derived-mode-set-keymap (quote (, child)))
(clone-set-syntax-table (quote (, child))) (derived-mode-set-syntax-table (quote (, child)))
(clone-set-abbrev-table (quote (, child))) (derived-mode-set-abbrev-table (quote (, child)))
; Splice in the body (if any). ; Splice in the body (if any).
(,@ body) (,@ body)
;;; ; Run the setup function, if ;;; ; Run the setup function, if
;;; ; any -- this will soon be ;;; ; any -- this will soon be
;;; ; obsolete. ;;; ; obsolete.
;;; (clone-run-setup-function (quote (, child))) ;;; (derived-mode-run-setup-function (quote (, child)))
; Run the hooks, if any. ; Run the hooks, if any.
(clone-run-hooks (quote (, child))))))) (derived-mode-run-hooks (quote (, 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. "Find the class of a major mode.
A mode's class is the first ancestor which is NOT a clone. A mode's class is the first ancestor which is NOT a derived mode.
Use the `clone-parent' property of the symbol to trace backwards." Use the `derived-mode-parent' property of the symbol to trace backwards."
(while (get mode 'clone-parent) (while (get mode 'derived-mode-parent)
(setq mode (get mode 'clone-parent))) (setq mode (get mode 'derived-mode-parent)))
mode) mode)
;; Inline functions to construct various names from a mode name. ;; 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." "Construct a setup-function name based on a mode name."
(intern (concat (symbol-name mode) "-setup"))) (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." "Construct a hooks name based on a mode name."
(intern (concat (symbol-name mode) "-hooks"))) (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." "Construct a map name based on a mode name."
(intern (concat (symbol-name mode) "-map"))) (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." "Construct a syntax-table name based on a mode name."
(intern (concat (symbol-name mode) "-syntax-table"))) (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." "Construct an abbrev-table name based on a mode name."
(intern (concat (symbol-name mode) "-abbrev-table"))) (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) (defun derived-mode-init-mode-variables (mode)
"Initialise variables for a new mode. "Initialise variables for a new mode.
Right now, if they don't already exist, set up a blank keymap, an 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 empty syntax table, and an empty abbrev table -- these will be merged
the first time the mode is used." the first time the mode is used."
(if (boundp (clone-map-name mode)) (if (boundp (derived-mode-map-name mode))
t t
(eval (` (defvar (, (clone-map-name mode)) (eval (` (defvar (, (derived-mode-map-name mode))
(make-sparse-keymap) (make-sparse-keymap)
(, (format "Keymap for %s." mode))))) (, (format "Keymap for %s." mode)))))
(put (clone-map-name mode) 'clone-unmerged t)) (put (derived-mode-map-name mode) 'derived-mode-unmerged t))
(if (boundp (clone-syntax-table-name mode)) (if (boundp (derived-mode-syntax-table-name mode))
t t
(eval (` (defvar (, (clone-syntax-table-name mode)) (eval (` (defvar (, (derived-mode-syntax-table-name mode))
(make-vector 256 nil) (make-vector 256 nil)
(, (format "Syntax table for %s." mode))))) (, (format "Syntax table for %s." mode)))))
(put (clone-syntax-table-name mode) 'clone-unmerged t)) (put (derived-mode-syntax-table-name mode) 'derived-mode-unmerged t))
(if (boundp (clone-abbrev-table-name mode)) (if (boundp (derived-mode-abbrev-table-name mode))
t t
(eval (` (defvar (, (clone-abbrev-table-name mode)) (eval (` (defvar (, (derived-mode-abbrev-table-name mode))
(progn (define-abbrev-table (clone-abbrev-table-name mode) nil) (progn (define-abbrev-table (derived-mode-abbrev-table-name mode) nil)
(make-abbrev-table)) (make-abbrev-table))
(, (format "Abbrev table for %s." mode))))))) (, (format "Abbrev table for %s." mode)))))))
(defun clone-make-docstring (parent child) (defun derived-mode-make-docstring (parent child)
"Construct a docstring for a new mode if none is provided." "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, It inherits all of the parent's attributes, but has its own keymap,
abbrev table and syntax table: abbrev table and syntax table:
...@@ -247,60 +247,60 @@ which more-or-less shadow ...@@ -247,60 +247,60 @@ which more-or-less shadow
\\{%s-map}" parent child child parent parent child)) \\{%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." "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)) (new-map (eval map-name))
(old-map (current-local-map))) (old-map (current-local-map)))
(if (get map-name 'clone-unmerged) (if (get map-name 'derived-mode-unmerged)
(clone-merge-keymaps old-map new-map)) (derived-mode-merge-keymaps old-map new-map))
(put map-name 'clone-unmerged nil) (put map-name 'derived-mode-unmerged nil)
(use-local-map new-map))) (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." "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)) (old-table (syntax-table))
(new-table (eval table-name))) (new-table (eval table-name)))
(if (get table-name 'clone-unmerged) (if (get table-name 'derived-mode-unmerged)
(clone-merge-syntax-tables old-table new-table)) (derived-mode-merge-syntax-tables old-table new-table))
(put table-name 'clone-unmerged nil) (put table-name 'derived-mode-unmerged nil)
(set-syntax-table new-table))) (set-syntax-table new-table)))
(defun clone-set-abbrev-table (mode) (defun derived-mode-set-abbrev-table (mode)
"Set the abbrev table if it exists. "Set the abbrev table if it exists.
Always merge its parent into it, since the merge is non-destructive." Always merge its parent into it, since the merge is non-destructive."
(let* ((table-name (clone-abbrev-table-name mode)) (let* ((table-name (derived-mode-abbrev-table-name mode))
(old-table local-abbrev-table) (old-table local-abbrev-table)
(new-table (eval table-name))) (new-table (eval table-name)))
(clone-merge-abbrev-tables old-table new-table) (derived-mode-merge-abbrev-tables old-table new-table)
(setq local-abbrev-table new-table))) (setq local-abbrev-table new-table)))
;;;(defun clone-run-setup-function (mode) ;;;(defun derived-mode-run-setup-function (mode)
;;; "Run the setup function if it exists." ;;; "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) ;;; (if (fboundp fname)
;;; (funcall fname)))) ;;; (funcall fname))))
(defun clone-run-hooks (mode) (defun derived-mode-run-hooks (mode)
"Run the hooks if they exist." "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) (if (boundp hooks-name)
(run-hooks hooks-name)))) (run-hooks hooks-name))))
;; Functions to merge maps and tables. ;; Functions to merge maps and tables.
(defun clone-merge-keymaps (old new) (defun derived-mode-merge-keymaps (old new)
"Merge an old keymap into a new one. "Merge an old keymap into a new one.
The old keymap is set to be the cdr of the new one, so that there will The old keymap is set to be the cdr of the new one, so that there will
be automatic inheritance." be automatic inheritance."
(setcdr (nthcdr (1- (length new)) new) old)) (setcdr (nthcdr (1- (length new)) new) old))
(defun clone-merge-syntax-tables (old new) (defun derived-mode-merge-syntax-tables (old new)
"Merge an old syntax table into a new one. "Merge an old syntax table into a new one.
Where the new table already has an entry, nothing is copied from the old one." Where the new table already has an entry, nothing is copied from the old one."
(let ((idx 0) (let ((idx 0)
...@@ -310,7 +310,7 @@ Where the new table already has an entry, nothing is copied from the old one." ...@@ -310,7 +310,7 @@ Where the new table already has an entry, nothing is copied from the old one."
(aset new idx (aref old idx))) (aset new idx (aref old idx)))
(setq idx (1+ idx))))) (setq idx (1+ idx)))))
(defun clone-merge-abbrev-tables (old new) (defun derived-mode-merge-abbrev-tables (old new)
"Merge an old abbrev table into a new one. "Merge an old abbrev table into a new one.
This function requires internal knowledge of how abbrev tables work, This function requires internal knowledge of how abbrev tables work,
presuming that they are obarrays with the abbrev as the symbol, the expansion presuming that they are obarrays with the abbrev as the symbol, the expansion
...@@ -324,8 +324,6 @@ This could well break with some future version of Gnu Emacs." ...@@ -324,8 +324,6 @@ This could well break with some future version of Gnu Emacs."
(symbol-value symbol) (symbol-function symbol))))) (symbol-value symbol) (symbol-function symbol)))))
old)) old))
(provide 'mode-clone) (provide 'derived)
;;; mode-clone.el ends here
;;; derived.el ends here
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment