anchor.diff:          ((stringp strsrc) strsrc)
           (t (error "Malformed string source: ~s" strsrc))))
   
  -(defun seval-arg (str)
  -  " An argument for eval command of screen must be wrapped
  -    with quote."
  -  (concat-str "'" str "'"))
  -
  -(defun sstringarg (str)
  -  " A string arguments for screen command must be double quoted."
  +(defun spacing-join (&rest strs)
  +  (format nil "~{~a~^ ~}" strs))
  +
  +(defun join/40 (&rest args)
  +  (format nil "~{~a~^\\40~}" args))
  +
  +(join/40 "split" "-v")
  +(princ
  +  (apply #'spacing-join
  +         (mapcar (papply (apply #'join/40))
  +                 '(("split" "-v")
  +                   ("focus" "right")
  +                   ("other")
  +                   ("focus" "left")))))
  +
  +(defun dqstringify (str)
     (concat-str "\"" str "\""))
  +
  +(defmacro gen-escape-fn (prepend-char &rest chars)
  +  (with-gensyms (c)
  +    `(lambda (,c)
  +       (if (inq ,c ,@chars)
  +         (list ,prepend-char ,c)
  +         (list ,c)))))
  +
  +(defmacro escape (prepend-char str &rest chars)
  +  `(coerce (mapcan (gen-escape-fn ,prepend-char ,@chars)
  +                   (coerce ,str 'cons))
  +           'string))
  +
  +(macroexpand-1 '(gen-escape-fn #\\ #\" #\# #\^))
  +
  +(defun make-dqstring (str)
  +  " Returns a string whose content is recognized identical to ``str'';{{{
  +    in the meaning of screen's double quoted string.
  +    Please be aware that ``str'' is a lisp object, string.
  +     Actually speaking, this function is a little strange. I mean,
  +    it should not exists. For example, if ^ is required to escaped
  +    by prepending a \, then it should be  done by the input side. Even
  +    if this function exists or not, the input side have to care about very
  +    similar point: which character should be escaped? If this function
  +    didn't exists, the input side must know which character must be
  +    escaped, and construct proper screen-dq-string. This function is
  +    only for reducing this annoying part. Thus, I have to do following
  +    2 things:
  +        1. DO NOT scented the existance of this function!
  +        2. Advertise NOTHING must be escaped. Just write the
  +           screen string contents, and wrap it by double quotes!
  +           The double quotes are for making it to Lisp string,
  +           not screen string.
  +  ";}}}
  +  (dqstringify
  +    (escape #\\ str #\" #\# #\^ #\\)))
  +
  +(join/40 "split" "-v")
  +(princ
  +  (apply #'spacing-join
  +         (mapcar (papply (apply #'join/40))
  +                 (maptree #'make-dqstring
  +                 '(("split" "-v")
  +                   ("focus" "right")
  +                   ("other")
  +                   ("focus" "left"))))))
  +
  +(defun make-evalarg (&rest command-components)
  +  (apply #'join/40 (mapcar #'make-dqstring command-components)))
   
   (defun state-leave-desc (state)
     (case state
  
positive.code: (comitem-stringify-form '(coerce (list #\l #\e #\f #\t) 'string))
  (comitem-stringify-form '(:lisp (concatenate 'string (list #\c #\l))))
  
  (defun com-stringify-form (com)
    (if (eq (car com) :lisp)
      (take-lispcode com)
      `(spacing-join ,@(mapcar #'comitem-stringify-form com))))
  
  (com-stringify-form '(focus left))
  (com-stringify-form '(focus (coerce (list #\l #\e #\f #\t) 'string)))
  (com-stringify-form '(:lisp (concatenate 'string "focus " (concatenate 'string "ri" "ght"))))
  
  (defun comseq-construct-form (comseq)
    (if (eq (car comseq) :lisp)
      (take-lispcode comseq)
      `(list ,@(mapcar #'com-stringify-form comseq))))
  
  (comseq-construct-form '((split -v) (focus right) (other) (focus left)))
  (comseq-construct-form '((split) (:lisp (string #\c))))
  
negative.code: (keybind-common nil "l" snormal snormal ((focus right)) (coerce (coerce "focus right" 'list) 'string))
  (keybind-common nil "l" snormal snormal ((focus right)) "")
  (keybind-common nil "^z" raw screen ())
  (keybind-common t "^" snormal-insert snormal-insert ((stuff ^)))
  
  (defun normalize-cmd-format (cmd)
    (cond ((null cmd) '())
  