XEmacs 21.4.17 "Jumbo Shrimp".

[chise/xemacs-chise.git.1] / lisp / derived.el

diff --git a/lisp/derived.el b/lisp/derived.el
index a2c6a5c..9f3dfc7 100644 (file)
--- a/lisp/derived.el
+++ b/lisp/derived.el
@@ -1,6 +1,7 @@
-;;; derived.el --- allow inheritance of major modes.
+;;; derived.el --- allow inheritance of major modes
+;;; (formerly mode-clone.el)

 
 

-;; Copyright (C) 1993, 1994, 1997 Free Software Foundation, Inc.
+;; Copyright (C) 1993, 1994, 1999, 2003 Free Software Foundation, Inc.

 
 ;; Author: David Megginson (dmeggins@aix1.uottawa.ca)
 ;; Maintainer: XEmacs Development Team
 
 ;; Author: David Megginson (dmeggins@aix1.uottawa.ca)
 ;; Maintainer: XEmacs Development Team

@@ -23,13 +24,13 @@
 ;; Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 ;; 02111-1307, USA.
 
 ;; Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 ;; 02111-1307, USA.
 

-;;; Synched up with: FSF 19.34.
+;;; Synched up with: FSF 21.3.

 
 ;;; Commentary:
 
 ;; This file is dumped with XEmacs.
 
 
 ;;; Commentary:
 
 ;; This file is dumped with XEmacs.
 

-;; GNU Emacs is already, in a sense, object oriented -- each object
+;; XEmacs is already, in a sense, object oriented -- each object

 ;; (buffer) belongs to a class (major mode), and that class defines
 ;; the relationship between messages (input events) and methods
 ;; (commands) by means of a keymap.
 ;; (buffer) belongs to a class (major mode), and that class defines
 ;; the relationship between messages (input events) and methods
 ;; (commands) by means of a keymap.

@@ -74,12 +75,6 @@
 ;; - assign the value 'hypertext-mode' to the 'major-mode' variable
 ;; - run the body of commands provided in the macro -- in this case,
 ;;   set the local variable `case-fold-search' to nil.
 ;; - assign the value 'hypertext-mode' to the 'major-mode' variable
 ;; - run the body of commands provided in the macro -- in this case,
 ;;   set the local variable `case-fold-search' to nil.

-;; - **run the command (hypertext-mode-setup), which is empty by
-;;   default, but may be redefined by the user to contain special
-;;   commands (ie. setting local variables like 'outline-regexp')
-;;   **NOTE: do not use this option -- it will soon be obsolete.
-;; - run anything assigned to 'hypertext-mode-hooks' (obsolete, but
-;;   supported for the sake of compatibility).

 ;;
 ;; The advantages of this system are threefold.  First, text mode is
 ;; untouched -- if you had added the new keystroke to `text-mode-map,'
 ;;
 ;; The advantages of this system are threefold.  First, text mode is
 ;; untouched -- if you had added the new keystroke to `text-mode-map,'

@@ -90,19 +85,34 @@
 ;;
 ;;   (define-derived-mode html-mode hypertext-mode "HTML")
 ;;   [various key definitions]
 ;;
 ;;   (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 `derived-mode-class,' which returns the non-derived
-;; major mode which a derived mode is based on (ie. NOT necessarily the
-;; immediate parent).
+;; will add a new major mode for HTML with very little fuss.

 ;;
 ;;

-;; (derived-mode-class 'text-mode) ==> text-mode
-;; (derived-mode-class 'hypertext-mode) ==> text-mode
-;; (derived-mode-class 'html-mode) ==> text-mode
+;; Note also the function `derived-mode-p' which can tell if the current
+;; mode derives from another.  In a hypertext-mode, buffer, for example,
+;; (derived-mode-p 'text-mode) would return non-nil.  This should always
+;; be used in place of (eq major-mode 'text-mode).

 \f
 ;;; Code:
 
 \f
 ;;; Code:
 

+;;; PRIVATE: defsubst must be defined before they are first used
+
+(defsubst derived-mode-hook-name (mode)
+  "Construct the mode hook name based on mode name MODE."
+  (intern (concat (symbol-name mode) "-hook")))
+
+(defsubst derived-mode-map-name (mode)
+  "Construct a map name based on a MODE name."
+  (intern (concat (symbol-name mode) "-map")))
+
+(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 derived-mode-abbrev-table-name (mode)
+  "Construct an abbrev-table name based on a MODE name."
+  (intern (concat (symbol-name mode) "-abbrev-table")))
+

 ;; PUBLIC: define a new major mode which inherits from an existing one.
 
 ;; XEmacs -- no autoload
 ;; PUBLIC: define a new major mode which inherits from an existing one.
 
 ;; XEmacs -- no autoload

@@ -112,12 +122,24 @@
 The arguments to this command are as follow:
 
 CHILD:     the name of the command for the derived 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).
-NAME:      a string which will appear in the status line (ie. \"Hypertext\")
+PARENT:    the name of the command for the parent mode (e.g. `text-mode')
+           or nil if there is no parent.
+NAME:      a string which will appear in the status line (e.g. \"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
 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.
+           hooks for the new mode.  Do not use `interactive' here.
+
+BODY can start with a bunch of keyword arguments.  The following keyword
+  arguments are currently understood:
+:group GROUP
+       Declare the customization group that corresponds to this mode.
+:syntax-table TABLE
+       Use TABLE instead of the default.
+       A nil value means to simply use the same syntax-table as the parent.
+:abbrev-table TABLE
+       Use TABLE instead of the default.
+       A nil value means to simply use the same abbrev-table as the parent.

 
 Here is how you could define LaTeX-Thesis mode as a variant of LaTeX mode:
 
 
 Here is how you could define LaTeX-Thesis mode as a variant of LaTeX mode:
 

@@ -127,7 +149,7 @@ 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.
 
 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 uses sgml-mode as
+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-derived-mode article-mode sgml-mode \"Article\"
 the parent, and then sets the variable `case-fold-search' to nil:
 
   (define-derived-mode article-mode sgml-mode \"Article\"

@@ -135,88 +157,173 @@ the parent, and then sets the variable `case-fold-search' to nil:
     (setq case-fold-search nil))
 
 Note that if the documentation string had been left out, it would have
     (setq case-fold-search nil))
 
 Note that if the documentation string had been left out, it would have

-been generated automatically, with a reference to the keymap."
-
-                                       ; Some trickiness, since what
-                                       ; appears to be the docstring
-                                       ; may really be the first
-                                       ; element of the body.
-  (if (and docstring (not (stringp docstring)))
-      (progn (setq body (cons docstring body))
-            (setq docstring nil)))
-  (setq docstring (or docstring (derived-mode-make-docstring parent child)))
-
-  `(progn 
-       (derived-mode-init-mode-variables (quote ,child))
+been generated automatically, with a reference to the keymap.
+
+The new mode runs the hook constructed by the function
+`derived-mode-hook-name'."
+  (declare (debug (&define name symbolp sexp [&optional stringp]
+                          [&rest keywordp sexp] def-body)))
+
+  (when (and docstring (not (stringp docstring)))
+    ;; Some trickiness, since what appears to be the docstring may really be
+    ;; the first element of the body.
+    (push docstring body)
+    (setq docstring nil))
+
+  (when (eq parent 'fundamental-mode) (setq parent nil))
+
+  (let ((map (derived-mode-map-name child))
+       (syntax (derived-mode-syntax-table-name child))
+       (abbrev (derived-mode-abbrev-table-name child))
+       (declare-abbrev t)
+       (declare-syntax t)
+       (hook (derived-mode-hook-name child))
+       (group nil))
+
+    ;; Process the keyword args.
+    (while (keywordp (car body))
+      (case (pop body)
+       (:group (setq group (pop body)))
+       (:abbrev-table (setq abbrev (pop body)) (setq declare-abbrev nil))
+       (:syntax-table (setq syntax (pop body)) (setq declare-syntax nil))
+       (t (pop body))))
+
+    (setq docstring (derived-mode-make-docstring
+                    parent child docstring syntax abbrev))
+
+    `(progn
+       (defvar ,hook nil ,(format "Hook run when entering %s mode." name))
+       (defvar ,map (make-sparse-keymap))
+       ,(if declare-syntax
+           `(defvar ,syntax (make-syntax-table)))
+       ,(if declare-abbrev
+           `(defvar ,abbrev
+              (progn (define-abbrev-table ',abbrev nil) ,abbrev)))
+       (put ',child 'derived-mode-parent ',parent)
+       ,(if group `(put ',child 'custom-mode-group ,group))
+

        (defun ,child ()
         ,docstring
         (interactive)
                                        ; Run the parent.
        (defun ,child ()
         ,docstring
         (interactive)
                                        ; Run the parent.

-        (,parent)
-                                       ; Identify special modes.
-        (if (get (quote ,parent) 'special)
-            (put (quote ,child) 'special t))
-        ;; XEmacs addition
-        (let ((mode-class (get (quote ,parent) 'mode-class)))
-          (if mode-class
-              (put (quote ,child) 'mode-class mode-class)))
+        (delay-mode-hooks
+
+         (,(or parent 'kill-all-local-variables))

                                        ; Identify the child mode.
                                        ; Identify the child mode.

-        (setq major-mode (quote ,child))
-        (setq mode-name ,name)
+         (setq major-mode (quote ,child))
+         (setq mode-name ,name)
+                                       ; Identify special modes.
+         ,(when parent
+            `(progn
+               (if (get (quote ,parent) 'mode-class)
+                   (put (quote ,child) 'mode-class
+                        (get (quote ,parent) 'mode-class)))

                                        ; Set up maps and tables.
                                        ; Set up maps and tables.

-        (derived-mode-set-keymap (quote ,child))
-        (derived-mode-set-syntax-table (quote ,child))
-        (derived-mode-set-abbrev-table (quote ,child))
+               (unless (keymap-parent ,map)
+                 (set-keymap-parents ,map (list (current-local-map))))
+               ,(when declare-syntax
+                  ;; XEmacs change: we do not have char-table-parent
+                  `(derived-mode-merge-syntax-tables
+                    (syntax-table) ,syntax))))
+
+         (use-local-map ,map)
+         ,(when syntax `(set-syntax-table ,syntax))
+         ,(when abbrev `(setq local-abbrev-table ,abbrev))

                                        ; Splice in the body (if any).
                                        ; Splice in the body (if any).

-        ,@body
-;;;                                    ; Run the setup function, if
-;;;                                    ; any -- this will soon be
-;;;                                    ; obsolete.
-;;;     (derived-mode-run-setup-function (quote ,child))
-                                       ; Run the hooks, if any.
-        (derived-mode-run-hooks (quote ,child)))))
-
+         ,@body
+         )
+        ;; Run the hooks, if any.
+        ;; Make the generated code work in older Emacs versions
+        ;; that do not yet have run-mode-hooks.
+        (if (fboundp 'run-mode-hooks)
+            (run-mode-hooks ',hook)
+          (run-hooks ',hook))))))

 
 ;; PUBLIC: find the ultimate class of a derived mode.
 
 (defun derived-mode-class (mode)
 
 ;; PUBLIC: find the ultimate class of a derived 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 derived mode.
 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."
+Use the `derived-mode-parent' property of the symbol to trace backwards.
+Since major-modes might all derive from `fundamental-mode', this function
+is not very useful."

   (while (get mode 'derived-mode-parent)
     (setq mode (get mode 'derived-mode-parent)))
   mode)
   (while (get mode 'derived-mode-parent)
     (setq mode (get mode 'derived-mode-parent)))
   mode)

+(make-obsolete 'derived-mode-class 'derived-mode-p)
+
+;; PUBLIC: find if the current mode derives from another.
+;; from GNU Emacs 21 subr.el
+
+(defun derived-mode-p (&rest modes)
+  "Non-nil if the current major mode is derived from one of MODES.
+Uses the `derived-mode-parent' property of the symbol to trace backwards."
+  (let ((parent major-mode))
+    (while (and (not (memq parent modes))
+               (setq parent (get parent 'derived-mode-parent))))
+    parent))

 
 \f
 
 \f

-;; Inline functions to construct various names from a mode name.
+;;; PRIVATE

 
 

-(defsubst derived-mode-setup-function-name (mode)
-  "Construct a setup-function name based on a mode name."
-  (intern (concat (symbol-name mode) "-setup")))
+(defun derived-mode-make-docstring (parent child &optional
+                                          docstring syntax abbrev)
+  "Construct a docstring for a new mode if none is provided."

 
 

-(defsubst derived-mode-hooks-name (mode)
-  "Construct a hooks name based on a mode name."
-  ;; XEmacs change from -hooks
-  (intern (concat (symbol-name mode) "-hook")))
+  (let ((map (derived-mode-map-name child))
+       (hook (derived-mode-hook-name child)))

 
 

-(defsubst derived-mode-map-name (mode)
-  "Construct a map name based on a mode name."
-  (intern (concat (symbol-name mode) "-map")))
+    (unless (stringp docstring)
+      ;; Use a default docstring.
+      (setq docstring
+           (if (null parent)
+               (format "Major-mode.
+Uses keymap `%s', abbrev table `%s' and syntax-table `%s'." map abbrev syntax)
+             (format "Major mode derived from `%s' by `define-derived-mode'.
+It inherits all of the parent's attributes, but has its own keymap,
+abbrev table and syntax table:

 
 

-(defsubst derived-mode-syntax-table-name (mode)
-  "Construct a syntax-table name based on a mode name."
-  (intern (concat (symbol-name mode) "-syntax-table")))
+  `%s', `%s' and `%s'

 
 

-(defsubst derived-mode-abbrev-table-name (mode)
-  "Construct an abbrev-table name based on a mode name."
-  (intern (concat (symbol-name mode) "-abbrev-table")))
+which more-or-less shadow %s's corresponding tables."
+                     parent map abbrev syntax parent))))
+
+    (unless (string-match (regexp-quote (symbol-name hook)) docstring)
+      ;; Make sure the docstring mentions the mode's hook.
+      (setq docstring
+           (concat docstring
+                   (if (null parent)
+                       "\n\nThis mode "
+                     (concat
+                      "\n\nIn addition to any hooks its parent mode "
+                      (if (string-match (regexp-quote (format "`%s'" parent))
+                                        docstring) nil
+                        (format "`%s' " parent))
+                      "might have run,\nthis mode "))
+                   (format "runs the hook `%s'" hook)
+                   ", as the final step\nduring initialization.")))
+
+    (unless (string-match "\\\\[{[]" docstring)
+      ;; And don't forget to put the mode's keymap.
+      (setq docstring (concat docstring "\n\n\\{" (symbol-name map) "}")))
+
+    docstring))
+
+\f
+;;; OBSOLETE
+;; The functions below are only provided for backward compatibility with
+;; code byte-compiled with versions of derived.el prior to Emacs-21.
+
+(defsubst derived-mode-setup-function-name (mode)
+  "Construct a setup-function name based on a MODE name."
+  (intern (concat (symbol-name mode) "-setup")))

 
 \f
 ;; Utility functions for defining a derived mode.
 
 ;; XEmacs -- don't autoload
 (defun derived-mode-init-mode-variables (mode)
 
 \f
 ;; Utility functions for defining a derived mode.
 
 ;; XEmacs -- don't autoload
 (defun derived-mode-init-mode-variables (mode)

-  "Initialize 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
 empty syntax table, and an empty abbrev table -- these will be merged
 the first time the mode is used."
 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."

@@ -244,30 +351,15 @@ the first time the mode is used."
   (if (boundp (derived-mode-abbrev-table-name mode))
       t
     (eval `(defvar ,(derived-mode-abbrev-table-name mode)
   (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))
+            (progn
+              (define-abbrev-table (derived-mode-abbrev-table-name mode) nil)
+              (make-abbrev-table))

             ,(format "Abbrev table for %s." mode)))))
             ,(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 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:
-
-  `%s-map' and `%s-syntax-table'
-
-which more-or-less shadow
-
-  `%s-map' and `%s-syntax-table'
-
-\\{%s-map}" parent child child parent parent child))
-

 \f
 ;; Utility functions for running a derived mode.
 
 (defun derived-mode-set-keymap (mode)
 \f
 ;; Utility functions for running a derived 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 (derived-mode-map-name mode))
         (new-map (eval map-name))
         (old-map (current-local-map)))
   (let* ((map-name (derived-mode-map-name mode))
         (new-map (eval map-name))
         (old-map (current-local-map)))

@@ -277,8 +369,8 @@ which more-or-less shadow
     (put map-name 'derived-mode-unmerged nil)
     (use-local-map new-map)))
 
     (put map-name 'derived-mode-unmerged nil)
     (use-local-map new-map)))
 

-(defun derived-mode-set-syntax-table (mode) 
-  "Set the syntax table of the new mode, maybe merging with the parent."
+(defun derived-mode-set-syntax-table (mode)
+  "Set the syntax table of the new MODE, maybe merging with the parent."

   (let* ((table-name (derived-mode-syntax-table-name mode))
         (old-table (syntax-table))
         (new-table (eval table-name)))
   (let* ((table-name (derived-mode-syntax-table-name mode))
         (old-table (syntax-table))
         (new-table (eval table-name)))

@@ -288,7 +380,7 @@ which more-or-less shadow
     (set-syntax-table new-table)))
 
 (defun derived-mode-set-abbrev-table (mode)
     (set-syntax-table new-table)))
 
 (defun derived-mode-set-abbrev-table (mode)

-  "Set the abbrev table if it exists.  
+  "Set the abbrev table for MODE 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)
 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)

@@ -304,45 +396,45 @@ Always merge its parent into it, since the merge is non-destructive."
 ;;;    (funcall fname))))
 
 (defun derived-mode-run-hooks (mode)
 ;;;    (funcall fname))))
 
 (defun derived-mode-run-hooks (mode)

-  "Run the hooks if they exist."
-
-  (let ((hooks-name (derived-mode-hooks-name mode)))
+  "Run the mode hook for MODE."
+  (let ((hooks-name (derived-mode-hook-name mode)))

     (if (boundp hooks-name)
        (run-hooks hooks-name))))
 
 ;; Functions to merge maps and tables.
 
 (defun derived-mode-merge-keymaps (old new)
     (if (boundp hooks-name)
        (run-hooks hooks-name))))
 
 ;; Functions to merge maps and tables.
 
 (defun derived-mode-merge-keymaps (old new)

-  "Merge an old keymap into a new one.
-The old keymap is set to be the parent of the new one, so that there will
+  "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."
 be automatic inheritance."

-  ;; XEmacs change.  FSF 19.30 & 19.34 has a whole bunch of weird crap here
+  ;; XEmacs change.  FSF 19.30 to 21.3 has a whole bunch of weird crap here

   ;; for merging prefix keys and such.  Hopefully none of this is
   ;; necessary in XEmacs.
   (set-keymap-parents new (list old)))
 
 (defun derived-mode-merge-syntax-tables (old new)
   ;; for merging prefix keys and such.  Hopefully none of this is
   ;; necessary in XEmacs.
   (set-keymap-parents new (list old)))
 
 (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."

-  ;; 20.x
-  (if (fboundp 'map-char-table)
-      ;; we use map-char-table not map-syntax-table so we can explicitly
-      ;; check for inheritance.
-      (map-char-table
-       #'(lambda (key value)
-          (if (eq ?@ (char-syntax-from-code value))
-              (map-char-table #'(lambda (key1 value1)
-                                  (put-char-table key1 value1 new))
-                              old
-                              key)))
-       new)
-    ;; pre-20.0
-    (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))))))
+  ;; XEmacs change: on the other hand, Emacs 21.3 just has
+  ;; (set-char-table-parent new old) here.
+  ;; We use map-char-table, not map-syntax-table, so we can explicitly
+  ;; check for inheritance.
+  (map-char-table
+   #'(lambda (key value)
+       (let ((newval (get-range-char-table key new 'multi)))
+        (cond ((eq newval 'multi)      ; OK, dive into the class hierarchy
+               (map-char-table
+                #'(lambda (key1 value1)
+                    (when (eq ?@ (char-syntax-from-code
+                                  (get-range-char-table key new ?@)))
+                      (put-char-table key1 value new))
+                    nil)
+                new
+                key))
+              ((eq ?@ (char-syntax-from-code newval)) ;; class at once
+               (put-char-table key value new))))
+       nil)
+   old))

 
 ;; Merge an old abbrev table into a new one.
 ;; This function requires internal knowledge of how abbrev tables work,
 
 ;; Merge an old abbrev table into a new one.
 ;; This function requires internal knowledge of how abbrev tables work,

@@ -350,14 +442,14 @@ Where the new table already has an entry, nothing is copied from the old one."
 ;; as the value of the symbol, and the hook as the function definition.
 (defun derived-mode-merge-abbrev-tables (old new)
   (if old
 ;; 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)))))
+      (mapatoms
+       #'(lambda (symbol)
+          (or (intern-soft (symbol-name symbol) new)
+              (define-abbrev new (symbol-name symbol)
+                (symbol-value symbol) (symbol-function symbol))))

        old)))
        old)))

-    
+

 (provide 'derived)
 
 (provide 'derived)
 

+;;; arch-tag: 630be248-47d1-4f02-afa0-8207de0ebea0

 ;;; derived.el ends here
 ;;; derived.el ends here