Renamed from mode-clone.el.

All functions renamed.
(define-derived-mode): Renamed from define-mode-clone.

1 files changed, 74 insertions, 76 deletions

diff --git a/lisp/derived.el b/lisp/derived.el
index ead5ce532e4..db4c0ad5161 100644
--- a/lisp/derived.el
+++ b/lisp/derived.el
@@ -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 @@ 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 (quote (, child)))
        (defun (, child) ()
          (, docstring)
          (interactive)
@@ -155,86 +155,86 @@ been generated automatically, with a reference to the keymap."
          (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 @@ 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-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 @@ Where the new table already has an entry, nothing is copied from the old one."
           (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 @@ This could well break with some future version of Gnu Emacs."
             (symbol-value symbol) (symbol-function symbol)))))
    old))
     
-(provide 'mode-clone)
-
-;;; mode-clone.el ends here
-
+(provide 'derived)
 
+;;; derived.el ends here