[Emacs-diffs] /srv/bzr/emacs/trunk r108272: * lisp/emacs-lisp/lisp-mode.el (doc-string-elt): Move those properties to

[Stefan Monnier]

------------------------------------------------------------
revno: 108272
committer: Stefan Monnier <address@hidden>
branch nick: trunk
timestamp: Thu 2012-05-17 21:46:20 -0400
message:
  * lisp/emacs-lisp/lisp-mode.el (doc-string-elt): Move those properties to
  their respective macro declarations.
  * lisp/skeleton.el (define-skeleton):
  * lisp/progmodes/compile.el (define-compilation-mode):
  * lisp/ibuf-macs.el (define-ibuffer-sorter, define-ibuffer-op)
  (define-ibuffer-filter):
  * lisp/emacs-lisp/generic.el (define-generic-mode):
  * lisp/emacs-lisp/easy-mmode.el (define-minor-mode)
  (define-globalized-minor-mode):
  * lisp/emacs-lisp/cl-macs.el (defun*, defmacro*, defstruct, deftype):
  * lisp/emacs-lisp/byte-run.el (defsubst):
  * lisp/custom.el (deftheme): Add doc-string metadata.
modified:
  lisp/ChangeLog
  lisp/cedet/mode-local.el
  lisp/custom.el
  lisp/emacs-lisp/byte-run.el
  lisp/emacs-lisp/cl-loaddefs.el
  lisp/emacs-lisp/cl-macs.el
  lisp/emacs-lisp/cl.el
  lisp/emacs-lisp/easy-mmode.el
  lisp/emacs-lisp/generic.el
  lisp/emacs-lisp/lisp-mode.el
  lisp/ibuf-macs.el
  lisp/progmodes/compile.el
  lisp/skeleton.el

=== modified file 'lisp/ChangeLog'
--- a/lisp/ChangeLog    2012-05-17 21:51:15 +0000
+++ b/lisp/ChangeLog    2012-05-18 01:46:20 +0000
@@ -1,3 +1,18 @@
+2012-05-18  Stefan Monnier  <address@hidden>
+
+       * emacs-lisp/lisp-mode.el (doc-string-elt): Move those properties to
+       their respective macro declarations.
+       * skeleton.el (define-skeleton):
+       * progmodes/compile.el (define-compilation-mode):
+       * ibuf-macs.el (define-ibuffer-sorter, define-ibuffer-op)
+       (define-ibuffer-filter):
+       * emacs-lisp/generic.el (define-generic-mode):
+       * emacs-lisp/easy-mmode.el (define-minor-mode)
+       (define-globalized-minor-mode):
+       * emacs-lisp/cl-macs.el (defun*, defmacro*, defstruct, deftype):
+       * emacs-lisp/byte-run.el (defsubst):
+       * custom.el (deftheme): Add doc-string metadata.
+
 2012-05-17  Stefan Monnier  <address@hidden>
 
        * emacs-lisp/cl-macs.el, emacs-lisp/cl.el: Move indent info.

=== modified file 'lisp/cedet/mode-local.el'
--- a/lisp/cedet/mode-local.el  2012-01-19 07:21:25 +0000
+++ b/lisp/cedet/mode-local.el  2012-05-18 01:46:20 +0000
@@ -522,6 +522,9 @@
         (list (mode-local--override name args body))
       result)))
 
+;;;###autoload
+(put 'define-overloadable-function 'doc-string-elt 3)
+
 (defmacro define-overloadable-function (name args docstring &rest body)
   "Define a new function, as with `defun', which can be overloaded.
 NAME is the name of the function to create.
@@ -546,6 +549,7 @@
 appropriate arguments deduced from ARGS.
 OVERARGS is a list of arguments passed to the override and
 `NAME-default' function, in place of those deduced from ARGS."
+  (declare (doc-string 3))
   `(eval-and-compile
      (defun ,name ,args
        ,docstring

=== modified file 'lisp/custom.el'
--- a/lisp/custom.el    2012-05-03 02:39:23 +0000
+++ b/lisp/custom.el    2012-05-18 01:46:20 +0000
@@ -1048,6 +1048,7 @@
 
 Any theme `foo' should be defined in a file called `foo-theme.el';
 see `custom-make-theme-feature' for more information."
+  (declare (doc-string 2))
   (let ((feature (custom-make-theme-feature theme)))
     ;; It is better not to use backquote in this file,
     ;; because that makes a bootstrapping problem

=== modified file 'lisp/emacs-lisp/byte-run.el'
--- a/lisp/emacs-lisp/byte-run.el       2012-01-19 07:21:25 +0000
+++ b/lisp/emacs-lisp/byte-run.el       2012-05-18 01:46:20 +0000
@@ -96,7 +96,7 @@
 ;; This has a special byte-hunk-handler in bytecomp.el.
 (defmacro defsubst (name arglist &rest body)
   "Define an inline function.  The syntax is just like that of `defun'."
-  (declare (debug defun))
+  (declare (debug defun) (doc-string 3))
   (or (memq (get name 'byte-optimizer)
            '(nil byte-compile-inline-expand))
       (error "`%s' is a primitive" name))

=== modified file 'lisp/emacs-lisp/cl-loaddefs.el'
--- a/lisp/emacs-lisp/cl-loaddefs.el    2012-05-17 21:39:36 +0000
+++ b/lisp/emacs-lisp/cl-loaddefs.el    2012-05-18 01:46:20 +0000
@@ -286,7 +286,7 @@
 ;;;;;;  flet progv psetq do-all-symbols do-symbols dotimes dolist
 ;;;;;;  do* do loop return-from return block etypecase typecase ecase
 ;;;;;;  case load-time-value eval-when destructuring-bind function*
-;;;;;;  defmacro* defun* gentemp gensym) "cl-macs" "cl-macs.el" 
"ed94b3ba46080516e6ada69bdf617be5")
+;;;;;;  defmacro* defun* gentemp gensym) "cl-macs" "cl-macs.el" 
"c383ef0fa5f6d28796cd8e9cf65e1c5d")
 ;;; Generated autoloads from cl-macs.el
 
 (autoload 'gensym "cl-macs" "\
@@ -308,6 +308,10 @@
 
 \(fn NAME ARGLIST [DOCSTRING] BODY...)" nil (quote macro))
 
+(put 'defun* 'lisp-indent-function '2)
+
+(put 'defun* 'doc-string-elt '3)
+
 (autoload 'defmacro* "cl-macs" "\
 Define NAME as a macro.
 Like normal `defmacro', except ARGLIST allows full Common Lisp conventions,
@@ -315,6 +319,10 @@
 
 \(fn NAME ARGLIST [DOCSTRING] BODY...)" nil (quote macro))
 
+(put 'defmacro* 'lisp-indent-function '2)
+
+(put 'defmacro* 'doc-string-elt '3)
+
 (autoload 'function* "cl-macs" "\
 Introduce a function.
 Like normal `function', except that if argument is a lambda form,
@@ -327,6 +335,8 @@
 
 \(fn ARGS EXPR &rest BODY)" nil (quote macro))
 
+(put 'destructuring-bind 'lisp-indent-function '2)
+
 (autoload 'eval-when "cl-macs" "\
 Control when BODY is evaluated.
 If `compile' is in WHEN, BODY is evaluated when compiled at top-level.
@@ -335,6 +345,8 @@
 
 \(fn (WHEN...) BODY...)" nil (quote macro))
 
+(put 'eval-when 'lisp-indent-function '1)
+
 (autoload 'load-time-value "cl-macs" "\
 Like `progn', but evaluates the body at load time.
 The result of the body appears to the compiler as a quoted constant.
@@ -352,12 +364,16 @@
 
 \(fn EXPR (KEYLIST BODY...)...)" nil (quote macro))
 
+(put 'case 'lisp-indent-function '1)
+
 (autoload 'ecase "cl-macs" "\
 Like `case', but error if no case fits.
 `otherwise'-clauses are not allowed.
 
 \(fn EXPR (KEYLIST BODY...)...)" nil (quote macro))
 
+(put 'ecase 'lisp-indent-function '1)
+
 (autoload 'typecase "cl-macs" "\
 Evals EXPR, chooses among clauses on that value.
 Each clause looks like (TYPE BODY...).  EXPR is evaluated and, if it
@@ -367,12 +383,16 @@
 
 \(fn EXPR (TYPE BODY...)...)" nil (quote macro))
 
+(put 'typecase 'lisp-indent-function '1)
+
 (autoload 'etypecase "cl-macs" "\
 Like `typecase', but error if no case fits.
 `otherwise'-clauses are not allowed.
 
 \(fn EXPR (TYPE BODY...)...)" nil (quote macro))
 
+(put 'etypecase 'lisp-indent-function '1)
+
 (autoload 'block "cl-macs" "\
 Define a lexically-scoped block named NAME.
 NAME may be any symbol.  Code inside the BODY forms can call `return-from'
@@ -385,6 +405,8 @@
 
 \(fn NAME &rest BODY)" nil (quote macro))
 
+(put 'block 'lisp-indent-function '1)
+
 (autoload 'return "cl-macs" "\
 Return from the block named nil.
 This is equivalent to `(return-from nil RESULT)'.
@@ -400,6 +422,8 @@
 
 \(fn NAME &optional RESULT)" nil (quote macro))
 
+(put 'return-from 'lisp-indent-function '1)
+
 (autoload 'loop "cl-macs" "\
 The Common Lisp `loop' macro.
 Valid clauses are:
@@ -421,11 +445,15 @@
 
 \(fn ((VAR INIT [STEP])...) (END-TEST [RESULT...]) BODY...)" nil (quote macro))
 
+(put 'do 'lisp-indent-function '2)
+
 (autoload 'do* "cl-macs" "\
 The Common Lisp `do*' loop.
 
 \(fn ((VAR INIT [STEP])...) (END-TEST [RESULT...]) BODY...)" nil (quote macro))
 
+(put 'do* 'lisp-indent-function '2)
+
 (autoload 'dolist "cl-macs" "\
 Loop over a list.
 Evaluate BODY with VAR bound to each `car' from LIST, in turn.
@@ -449,11 +477,15 @@
 
 \(fn (VAR [OBARRAY [RESULT]]) BODY...)" nil (quote macro))
 
+(put 'do-symbols 'lisp-indent-function '1)
+
 (autoload 'do-all-symbols "cl-macs" "\
 
 
 \(fn SPEC &rest BODY)" nil (quote macro))
 
+(put 'do-all-symbols 'lisp-indent-function '1)
+
 (autoload 'psetq "cl-macs" "\
 Set SYMs to the values VALs in parallel.
 This is like `setq', except that all VAL forms are evaluated (in order)
@@ -471,6 +503,8 @@
 
 \(fn SYMBOLS VALUES &rest BODY)" nil (quote macro))
 
+(put 'progv 'lisp-indent-function '2)
+
 (autoload 'flet "cl-macs" "\
 Make temporary function definitions.
 This is an analogue of `let' that operates on the function cell of FUNC
@@ -480,6 +514,8 @@
 
 \(fn ((FUNC ARGLIST BODY...) ...) FORM...)" nil (quote macro))
 
+(put 'flet 'lisp-indent-function '1)
+
 (autoload 'labels "cl-macs" "\
 Make temporary function bindings.
 This is like `flet', except the bindings are lexical instead of dynamic.
@@ -487,12 +523,16 @@
 
 \(fn ((FUNC ARGLIST BODY...) ...) FORM...)" nil (quote macro))
 
+(put 'labels 'lisp-indent-function '1)
+
 (autoload 'macrolet "cl-macs" "\
 Make temporary macro definitions.
 This is like `flet', but for macros instead of functions.
 
 \(fn ((NAME ARGLIST BODY...) ...) FORM...)" nil (quote macro))
 
+(put 'macrolet 'lisp-indent-function '1)
+
 (autoload 'symbol-macrolet "cl-macs" "\
 Make symbol macro definitions.
 Within the body FORMs, references to the variable NAME will be replaced
@@ -500,6 +540,8 @@
 
 \(fn ((NAME EXPANSION) ...) FORM...)" nil (quote macro))
 
+(put 'symbol-macrolet 'lisp-indent-function '1)
+
 (autoload 'lexical-let "cl-macs" "\
 Like `let', but lexically scoped.
 The main visible difference is that lambdas inside BODY will create
@@ -507,6 +549,8 @@
 
 \(fn BINDINGS BODY)" nil (quote macro))
 
+(put 'lexical-let 'lisp-indent-function '1)
+
 (autoload 'lexical-let* "cl-macs" "\
 Like `let*', but lexically scoped.
 The main visible difference is that lambdas inside BODY, and in
@@ -516,6 +560,8 @@
 
 \(fn BINDINGS BODY)" nil (quote macro))
 
+(put 'lexical-let* 'lisp-indent-function '1)
+
 (autoload 'multiple-value-bind "cl-macs" "\
 Collect multiple return values.
 FORM must return a list; the BODY is then executed with the first N elements
@@ -526,6 +572,8 @@
 
 \(fn (SYM...) FORM BODY)" nil (quote macro))
 
+(put 'multiple-value-bind 'lisp-indent-function '2)
+
 (autoload 'multiple-value-setq "cl-macs" "\
 Collect multiple return values.
 FORM must return a list; the first N elements of this list are stored in
@@ -535,6 +583,8 @@
 
 \(fn (SYM...) FORM)" nil (quote macro))
 
+(put 'multiple-value-setq 'lisp-indent-function '1)
+
 (autoload 'locally "cl-macs" "\
 
 
@@ -545,6 +595,8 @@
 
 \(fn TYPE FORM)" nil (quote macro))
 
+(put 'the 'lisp-indent-function '1)
+
 (autoload 'declare "cl-macs" "\
 Declare SPECS about the current function while compiling.
 For instance
@@ -649,6 +701,8 @@
 
 \(fn ((PLACE VALUE) ...) BODY...)" nil (quote macro))
 
+(put 'letf 'lisp-indent-function '1)
+
 (autoload 'letf* "cl-macs" "\
 Temporarily bind to PLACEs.
 This is the analogue of `let*', but with generalized variables (in the
@@ -661,6 +715,8 @@
 
 \(fn ((PLACE VALUE) ...) BODY...)" nil (quote macro))
 
+(put 'letf* 'lisp-indent-function '1)
+
 (autoload 'callf "cl-macs" "\
 Set PLACE to (FUNC PLACE ARGS...).
 FUNC should be an unquoted function name.  PLACE may be a symbol,
@@ -668,12 +724,16 @@
 
 \(fn FUNC PLACE ARGS...)" nil (quote macro))
 
+(put 'callf 'lisp-indent-function '2)
+
 (autoload 'callf2 "cl-macs" "\
 Set PLACE to (FUNC ARG1 PLACE ARGS...).
 Like `callf', but PLACE is the second argument of FUNC, not the first.
 
 \(fn FUNC ARG1 PLACE ARGS...)" nil (quote macro))
 
+(put 'callf2 'lisp-indent-function '3)
+
 (autoload 'define-modify-macro "cl-macs" "\
 Define a `setf'-like modify macro.
 If NAME is called, it combines its PLACE argument with the other arguments
@@ -699,6 +759,8 @@
 
 \(fn NAME SLOTS...)" nil (quote macro))
 
+(put 'defstruct 'doc-string-elt '2)
+
 (autoload 'cl-struct-setf-expander "cl-macs" "\
 
 
@@ -710,6 +772,8 @@
 
 \(fn NAME ARGLIST &rest BODY)" nil (quote macro))
 
+(put 'deftype 'doc-string-elt '3)
+
 (autoload 'typep "cl-macs" "\
 Check that OBJECT is of type TYPE.
 TYPE is a Common Lisp-style type specifier.

=== modified file 'lisp/emacs-lisp/cl-macs.el'
--- a/lisp/emacs-lisp/cl-macs.el        2012-05-17 21:51:15 +0000
+++ b/lisp/emacs-lisp/cl-macs.el        2012-05-18 01:46:20 +0000
@@ -227,6 +227,7 @@
                      cl-declarations-or-string
                      [&optional ("interactive" interactive)]
                      def-body))
+           (doc-string 3)
            (indent 2))
   (let* ((res (cl-transform-lambda (cons args body) name))
         (form (list* 'defun name (cdr res))))
@@ -279,6 +280,7 @@
 \(fn NAME ARGLIST [DOCSTRING] BODY...)"
   (declare (debug
             (&define name cl-macro-list cl-declarations-or-string def-body))
+           (doc-string 3)
            (indent 2))
   (let* ((res (cl-transform-lambda (cons args body) name))
         (form (list* 'defmacro name (cdr res))))
@@ -2587,7 +2589,8 @@
 value, that slot cannot be set via `setf'.
 
 \(fn NAME SLOTS...)"
-  (declare (debug
+  (declare (doc-string 2)
+           (debug
             (&define                    ;Makes top-level form not be wrapped.
              [&or symbolp
                   (gate
@@ -2854,7 +2857,7 @@
 (defmacro deftype (name arglist &rest body)
   "Define NAME as a new data type.
 The type name can then be used in `typecase', `check-type', etc."
-  (declare (debug defmacro*))
+  (declare (debug defmacro*) (doc-string 3))
   (list 'eval-when '(compile load eval)
        (cl-transform-function-property
         name 'cl-deftype-handler (cons (list* '&cl-defs ''('*) arglist) 
body))))

=== modified file 'lisp/emacs-lisp/cl.el'
--- a/lisp/emacs-lisp/cl.el     2012-05-17 21:51:15 +0000
+++ b/lisp/emacs-lisp/cl.el     2012-05-18 01:46:20 +0000
@@ -656,6 +656,15 @@
 (fmakunbound 'dolist)
 (fmakunbound 'dotimes)
 (fmakunbound 'declare)
+;;;###autoload
+(progn
+  ;; Autoload, so autoload.el and font-lock can use it even when CL
+  ;; is not loaded.
+  (put 'defun*    'doc-string-elt 3)
+  (put 'defmacro* 'doc-string-elt 3)
+  (put 'defsubst 'doc-string-elt 3)
+  (put 'defstruct 'doc-string-elt 2))
+
 (load "cl-loaddefs" nil 'quiet)
 
 ;; This goes here so that cl-macs can find it if it loads right now.

=== modified file 'lisp/emacs-lisp/easy-mmode.el'
--- a/lisp/emacs-lisp/easy-mmode.el     2012-05-04 23:16:47 +0000
+++ b/lisp/emacs-lisp/easy-mmode.el     2012-05-18 01:46:20 +0000
@@ -142,7 +142,8 @@
   (define-minor-mode foo-mode \"If enabled, foo on you!\"
     :lighter \" Foo\" :require 'foo :global t :group 'hassle :version \"27.5\"
     ...BODY CODE...)"
-  (declare (debug (&define name stringp
+  (declare (doc-string 2)
+           (debug (&define name stringp
                           [&optional [&not keywordp] sexp
                            &optional [&not keywordp] sexp
                            &optional [&not keywordp] sexp]
@@ -335,7 +336,7 @@
 correctly with the current major mode.  This is important to
 prevent problems with derived modes, that is, major modes that
 call another major mode in their body."
-
+  (declare (doc-string 2))
   (let* ((global-mode-name (symbol-name global-mode))
         (pretty-name (easy-mmode-pretty-mode-name mode))
         (pretty-global-name (easy-mmode-pretty-mode-name global-mode))

=== modified file 'lisp/emacs-lisp/generic.el'
--- a/lisp/emacs-lisp/generic.el        2012-05-13 03:05:06 +0000
+++ b/lisp/emacs-lisp/generic.el        2012-05-18 01:46:20 +0000
@@ -151,7 +151,8 @@
 See the file generic-x.el for some examples of `define-generic-mode'."
   (declare (debug (sexp def-form def-form def-form form def-form
                        [&optional stringp] &rest [keywordp form]))
-          (indent 1))
+          (indent 1)
+           (doc-string 7))
 
   ;; Backward compatibility.
   (when (eq (car-safe mode) 'quote)

=== modified file 'lisp/emacs-lisp/lisp-mode.el'
--- a/lisp/emacs-lisp/lisp-mode.el      2012-01-29 04:45:51 +0000
+++ b/lisp/emacs-lisp/lisp-mode.el      2012-05-18 01:46:20 +0000
@@ -136,34 +136,14 @@
 ;; This was originally in autoload.el and is still used there.
 (put 'autoload 'doc-string-elt 3)
 (put 'defun    'doc-string-elt 3)
-(put 'defun*    'doc-string-elt 3)
 (put 'defmethod 'doc-string-elt 3)
 (put 'defvar   'doc-string-elt 3)
-(put 'defcustom 'doc-string-elt 3)
-(put 'deftheme 'doc-string-elt 2)
-(put 'deftype 'doc-string-elt 3)
 (put 'defconst 'doc-string-elt 3)
 (put 'defmacro 'doc-string-elt 3)
-(put 'defmacro* 'doc-string-elt 3)
-(put 'defsubst 'doc-string-elt 3)
-(put 'defstruct 'doc-string-elt 2)
-(put 'define-skeleton 'doc-string-elt 2)
-(put 'define-derived-mode 'doc-string-elt 4)
-(put 'define-compilation-mode 'doc-string-elt 3)
-(put 'easy-mmode-define-minor-mode 'doc-string-elt 2)
-(put 'define-minor-mode 'doc-string-elt 2)
-(put 'easy-mmode-define-global-mode 'doc-string-elt 2)
-(put 'define-global-minor-mode 'doc-string-elt 2)
-(put 'define-globalized-minor-mode 'doc-string-elt 2)
-(put 'define-generic-mode 'doc-string-elt 7)
-(put 'define-ibuffer-filter 'doc-string-elt 2)
-(put 'define-ibuffer-op 'doc-string-elt 3)
-(put 'define-ibuffer-sorter 'doc-string-elt 2)
 (put 'lambda 'doc-string-elt 2)
 (put 'defalias 'doc-string-elt 3)
 (put 'defvaralias 'doc-string-elt 3)
 (put 'define-category 'doc-string-elt 2)
-(put 'define-overloadable-function 'doc-string-elt 3)
 
 (defvar lisp-doc-string-elt-property 'doc-string-elt
   "The symbol property that holds the docstring position info.")

=== modified file 'lisp/ibuf-macs.el'
--- a/lisp/ibuf-macs.el 2012-01-19 07:21:25 +0000
+++ b/lisp/ibuf-macs.el 2012-05-18 01:46:20 +0000
@@ -143,7 +143,7 @@
 value if and only if `a' is \"less than\" `b'.
 
 \(fn NAME DOCUMENTATION (&key DESCRIPTION) &rest BODY)"
-  (declare (indent 1))
+  (declare (indent 1) (doc-string 2))
   `(progn
      (defun ,(intern (concat "ibuffer-do-sort-by-" (symbol-name name))) ()
        ,(or documentation "No :documentation specified for this sorting 
method.")
@@ -202,7 +202,7 @@
 macro for exactly what it does.
 
 \(fn OP ARGS DOCUMENTATION (&key INTERACTIVE MARK MODIFIER-P DANGEROUS 
OPSTRING ACTIVE-OPSTRING COMPLEX) &rest BODY)"
-  (declare (indent 2))
+  (declare (indent 2) (doc-string 3))
   `(progn
      (defun ,(intern (concat (if (string-match "^ibuffer-do" (symbol-name op))
                                 "" "ibuffer-do-") (symbol-name op)))
@@ -280,7 +280,7 @@
 bound to the current value of the filter.
 
 \(fn NAME DOCUMENTATION (&key READER DESCRIPTION) &rest BODY)"
-  (declare (indent 2))
+  (declare (indent 2) (doc-string 2))
   (let ((fn-name (intern (concat "ibuffer-filter-by-" (symbol-name name)))))
     `(progn
        (defun ,fn-name (qualifier)

=== modified file 'lisp/progmodes/compile.el'
--- a/lisp/progmodes/compile.el 2012-05-14 11:59:28 +0000
+++ b/lisp/progmodes/compile.el 2012-05-18 01:46:20 +0000
@@ -1884,6 +1884,9 @@
   (setq buffer-read-only t)
   (run-mode-hooks 'compilation-mode-hook))
 
+;;;###autoload
+(put 'define-compilation-mode 'doc-string-elt 3)
+
 (defmacro define-compilation-mode (mode name doc &rest body)
   "This is like `define-derived-mode' without the PARENT argument.
 The parent is always `compilation-mode' and the customizable `compilation-...'

=== modified file 'lisp/skeleton.el'
--- a/lisp/skeleton.el  2012-04-09 13:05:48 +0000
+++ b/lisp/skeleton.el  2012-05-18 01:46:20 +0000
@@ -121,7 +121,7 @@
   "Define a user-configurable COMMAND that enters a statement skeleton.
 DOCUMENTATION is that of the command.
 SKELETON is as defined under `skeleton-insert'."
-  (declare (debug (&define name stringp skeleton-edebug-spec)))
+  (declare (doc-string 2) (debug (&define name stringp skeleton-edebug-spec)))
   (if skeleton-debug
       (set command skeleton))
   `(progn