anchor.diff:  (keybind t "^c" raw screen ((focus up)) ())
   (keybind t "^p" window-select window-select
            ((prev))
  -         ((echo (sstringarg "[window-select] (prev)"))))
  -
  -(let ((x "focus down")
  +         ((echo (make-dqstring "[window-select] (prev)"))))
  +;;; Both of following two commands outputs [s] as an echo message:
  +;;;     1. eval "echo"\40"[s]"
  +;;;     2. eval "echo"\40"\"[s]\""
  +;;; In 1., [s] is the argument for echo command. The argument for echo command
  +;;; in 2. is "[s]".
  +;;;     alt-1. echo [s]
  +;;;     alt-2. echo "[s]"
  +
  +;;; The :LISP form allows follwing thing. This example is not preferrable, though.
  +(let ((x "'focus down'")
         (y "-v"))
     (keybind nil "j" window-select window-select
              ((:lisp x) (focus up) (split (:lisp y)))
              ()))
   
  +(define-symbol-macro escape (format t "~&escape ~a~%" (resolve-string (read))))
  +
   (defparameter *hardstatus-string* "")
  +
  +;;; Dec. 3rd 2012, chiku
  +;;; In order to output one ^ in the hardstatus line, a man should provide
  +;;; "\"\\^\\^\"" to screen-keybind, and screen-keybind will convert it into
  +;;; "\"\\\"\\\\\\^\\\\\\^\\\"\"". That user is responsible for providing the
  +;;; first one. This DEFAULT-MESSAGE function has same responsibility. This is
  +;;; the reason for why I write the escape process in this function and why
  +;;; I do not write such escape process for MESSAGE function.
  +(defun default-message (dst primary-command-desc)
  +  (make-dqstring
  +    (concat-str "%{= }%?%E[" (resolve-string dst) "]"
  +                (if (not (zerop (length primary-command-desc)))
  +                  (concat-str " ("
  +                              (escape #\^ primary-command-desc #\^)
  +                              ")")
  +                  "")
  +                "%:[raw]%?" *hardstatus-string*)))
  +
  +(defun message (msg &optional (hardstatus-format *hardstatus-string*))
  +  (make-dqstring
  +    (concat-str msg hardstatus-format)))
   
   (defun set-hardstatus-string (str)
     (progn (setf *hardstatus-string* str)
  -         (format t "~&hardstatus string ~a~%" str)))
  +         (format t "~&hardstatus string ~a~%"
  +                 (default-message 'screen ""))))
   
   (define-symbol-macro hardstatus-string
                        (set-hardstatus-string (read)))
   
  -(define-symbol-macro escape (format t "~&escape ~a~%" (resolve-string (read))))
  -
  -(defun default-message (dst comdesc)
  -  (concat-str "%{= }%?%E[" (resolve-string dst) "]"
  -              (if (not (zerop (length comdesc)))
  -                (concat-str " (" comdesc ")")
  -                "")
  -              "%:[raw]%?" *hardstatus-string*))
  +(set-hardstatus-string "%030=%{B.} %{-}%-w%{=b Mw}%{+u}%{+s}%n %t%{-}%{-}%{-}%+w%{B.} %{-}%=%m/%d %02c")
   
   (defmacro keybind-common (strm key start dst (&rest commands) &optional message)
     " message : any form that is evaluated into a string.
  
positive.code:         ((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."
    (concat-str "\"" str "\""))
  
  (defun state-leave-desc (state)
    (case state
  
negative.code:             ,commands
              (,(cond ((null message)
                       `(hardstatus string
                                    (:lisp (default-message
                                             ',dst
                                             (spacing-join
                                               ,@(mapcar #'comitem-stringify-form
                                                         (car commands)))))))
                      ((zerop (length message)) ())
                      (t `(hardstatus string (:lisp (message ,message))))))))
  
  (keybind-common t "j" snormal snormal ((focus down)))
  (keybind-common t "k" screen raw ((focus up)) "focus up")
  