Mercurial > emacs

--- a/lisp/derived.el	Tue Mar 08 17:43:37 1994 +0000
+++ b/lisp/derived.el	Tue Mar 08 19:02:50 1994 +0000
@@ -1,4 +1,5 @@
-;;; 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.

@@ -40,12 +41,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))
 ;;
@@ -79,53 +80,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:

 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\")
 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))

@@ -139,10 +139,10 @@
   (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 (quote (, child)))
        (defun (, child) ()
 	 (, docstring)
 	 (interactive)
@@ -155,86 +155,86 @@
 	 (setq major-mode (quote (, 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 (quote (, child)))
+	 (derived-mode-set-syntax-table (quote (, child)))
+	 (derived-mode-set-abbrev-table (quote (, 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 (quote (, child)))
 					; 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.
-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)
+(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 (clone-map-name mode))
+  (if (boundp (derived-mode-map-name mode))
       t
-    (eval (` (defvar (, (clone-map-name mode))
+    (eval (` (defvar (, (derived-mode-map-name mode))
 	       (make-sparse-keymap)
 	       (, (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
-    (eval (` (defvar (, (clone-syntax-table-name mode))
+    (eval (` (defvar (, (derived-mode-syntax-table-name mode))
 	       (make-vector 256 nil)
 	       (, (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
-    (eval (` (defvar (, (clone-abbrev-table-name mode))
-	       (progn (define-abbrev-table (clone-abbrev-table-name mode) nil)
+    (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 clone-make-docstring (parent child)
+(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:

@@ -247,60 +247,60 @@
 \\{%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-unmerged)
-	(clone-merge-keymaps old-map new-map))
-    (put map-name 'clone-unmerged nil)
+    (if (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-unmerged)
-	(clone-merge-syntax-tables old-table new-table))
-    (put table-name 'clone-unmerged nil)
+    (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 clone-set-abbrev-table (mode)
+(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 (clone-abbrev-table-name mode))
+  (let* ((table-name (derived-mode-abbrev-table-name mode))
 	 (old-table local-abbrev-table)
 	 (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)))

-;;;(defun clone-run-setup-function (mode)
+;;;(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)
+(defun derived-mode-merge-keymaps (old new)
   "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
 be automatic inheritance."
   (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.
 Where the new table already has an entry, nothing is copied from the old one."
   (let ((idx 0)
@@ -310,7 +310,7 @@
 	  (aset new idx (aref old 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.
 This function requires internal knowledge of how abbrev tables work,
 presuming that they are obarrays with the abbrev as the symbol, the expansion
@@ -324,8 +324,6 @@
 	    (symbol-value symbol) (symbol-function symbol)))))
    old))

-(provide 'mode-clone)
+(provide 'derived)

-;;; mode-clone.el ends here
-
-
+;;; derived.el ends here