Fix indentation.

(bs) <defgroup>: Add :links.

1 files changed, 305 insertions, 302 deletions

diff --git a/lisp/bs.el b/lisp/bs.el
index 20fe02c363d..48779cb98e5 100644
--- a/lisp/bs.el
+++ b/lisp/bs.el
@@ -137,6 +137,8 @@
 (defgroup bs nil
   "Buffer Selection: Maintaining buffers by buffer menu."
   :version "21.1"
+  :link '(emacs-commentary-link "bs")
+  :link '(url-link "http://home.netsurf.de/olaf.sylvester/emacs")
   :group 'convenience)
 
 (defgroup bs-appearence nil
@@ -180,7 +182,7 @@ return a string representing the columns value."
 (defun bs--make-header-match-string ()
   "Return a regexp matching the first line of a Buffer Selection Menu buffer."
   (let ((res "^\\(")
- (ele  bs-attributes-list))
+        (ele  bs-attributes-list))
     (while ele
       (setq res (concat res (car (car ele)) " *"))
       (setq ele (cdr ele)))
@@ -188,21 +190,21 @@ return a string representing the columns value."
 
 ;;; Font-Lock-Settings
 (defvar bs-mode-font-lock-keywords
-  (list ;; header in font-lock-type-face
-        (list (bs--make-header-match-string)
-       '(1 font-lock-type-face append) '(1 'bold append))
- ;; Buffername embedded by *
- (list "^\\(.*\\*.*\\*.*\\)$"
-       1 (if bs--running-in-xemacs
-      ;; problem in XEmacs with font-lock-constant-face
-      (if (facep 'font-lock-constant-face)
-   'font-lock-constant-face
-        'font-lock-comment-face)
-    'font-lock-constant-face))
- ;; Dired-Buffers
- '("^..\\(.*Dired by .*\\)$" 1 font-lock-function-name-face)
- ;; the star for modified buffers
- '("^.\\(\\*\\) +[^\\*]"     1 font-lock-comment-face))
+  (list;; header in font-lock-type-face
+   (list (bs--make-header-match-string)
+         '(1 font-lock-type-face append) '(1 'bold append))
+   ;; Buffername embedded by *
+   (list "^\\(.*\\*.*\\*.*\\)$"
+         1 (if bs--running-in-xemacs
+               ;; problem in XEmacs with font-lock-constant-face
+               (if (facep 'font-lock-constant-face)
+                   'font-lock-constant-face
+                 'font-lock-comment-face)
+             'font-lock-constant-face))
+   ;; Dired-Buffers
+   '("^..\\(.*Dired by .*\\)$" 1 font-lock-function-name-face)
+   ;; the star for modified buffers
+   '("^.\\(\\*\\) +[^\\*]"     1 font-lock-comment-face))
   "Default font lock expressions for Buffer Selection Menu.")
 
 (defcustom bs-max-window-height 20
@@ -365,18 +367,18 @@ A value of `always' means to show buffer regardless of the configuration.")
 (defun bs--sort-by-name (b1 b2)
   "Compare buffers B1 and B2 by buffer name."
   (string< (buffer-name b1)
-    (buffer-name b2)))
+           (buffer-name b2)))
 
 (defun bs--sort-by-filename (b1 b2)
   "Compare buffers B1 and B2 by file name."
   (string< (or (buffer-file-name b1) "")
-    (or (buffer-file-name b2) "")))
+           (or (buffer-file-name b2) "")))
 
 (defun bs--sort-by-mode (b1 b2)
   "Compare buffers B1 and B2 by mode name."
   (save-excursion
     (string< (progn (set-buffer b1) (format "%s" mode-name))
-      (progn (set-buffer b2) (format "%s" mode-name)))))
+             (progn (set-buffer b2) (format "%s" mode-name)))))
 
 (defun bs--sort-by-size (b1 b2)
   "Compare buffers B1 and B2 by buffer size."
@@ -415,10 +417,10 @@ don't highlight.
 The new sort aspect will be inserted into list `bs-sort-functions'."
   (let ((tupel (assoc name bs-sort-functions)))
     (if tupel
- (setcdr tupel (list fun regexp-for-sorting face))
+        (setcdr tupel (list fun regexp-for-sorting face))
       (setq bs-sort-functions
-     (cons (list name fun regexp-for-sorting face)
-    bs-sort-functions)))))
+            (cons (list name fun regexp-for-sorting face)
+                  bs-sort-functions)))))
 
 (defvar bs--current-sort-function nil
   "Description of the current function for sorting the buffer list.
@@ -431,9 +433,9 @@ naming a sort behavior.  Default is \"by nothing\" which means no sorting."
   :group 'bs
   :type  'string
   :set (lambda (var-name value)
-  (set var-name value)
-  (setq bs--current-sort-function
-        (assoc value bs-sort-functions))))
+         (set var-name value)
+         (setq bs--current-sort-function
+               (assoc value bs-sort-functions))))
 
 (defvar bs--buffer-coming-from nil
   "The buffer in which the user started the current Buffer Selection Menu.")
@@ -534,52 +536,53 @@ and `bs-buffer-sort-function'.
 If SORT-DESCRIPTION isn't nil the list will be sorted by
 a special function.  SORT-DESCRIPTION is an element of `bs-sort-functions'."
   (setq sort-description (or sort-description bs--current-sort-function)
- list (or list (buffer-list)))
+        list (or list (buffer-list)))
   (let ((result nil))
     (while list
       (let* ((buffername (buffer-name (car list)))
-      (int-show-never (string-match bs--intern-show-never buffername))
-      (ext-show-never (and bs-dont-show-regexp
-         (string-match bs-dont-show-regexp
-         buffername)))
-      (extern-must-show (or (and bs-must-always-show-regexp
-     (string-match bs-must-always-show-regexp
-            buffername))
-       (and bs-must-show-regexp
-     (string-match bs-must-show-regexp
-            buffername))))
-      (extern-show-never-from-fun (and bs-dont-show-function
-           (funcall bs-dont-show-function
-             (car list))))
-      (extern-must-show-from-fun (and bs-must-show-function
-          (funcall bs-must-show-function
-            (car list))))
-      (show-flag (save-excursion
-     (set-buffer (car list))
-     bs-buffer-show-mark)))
- (if (or (eq show-flag 'always)
-  (and (or bs--show-all (not (eq show-flag 'never)))
-       (not int-show-never)
-       (or bs--show-all
-    extern-must-show
-    extern-must-show-from-fun
-    (and (not ext-show-never)
-         (not extern-show-never-from-fun)))))
-     (setq result (cons (car list)
-          result)))
- (setq list (cdr list))))
+             (int-show-never (string-match bs--intern-show-never buffername))
+             (ext-show-never (and bs-dont-show-regexp
+                                  (string-match bs-dont-show-regexp
+                                                buffername)))
+             (extern-must-show (or (and bs-must-always-show-regexp
+                                        (string-match
+                                         bs-must-always-show-regexp
+                                         buffername))
+                                   (and bs-must-show-regexp
+                                        (string-match bs-must-show-regexp
+                                                      buffername))))
+             (extern-show-never-from-fun (and bs-dont-show-function
+                                              (funcall bs-dont-show-function
+                                                       (car list))))
+             (extern-must-show-from-fun (and bs-must-show-function
+                                             (funcall bs-must-show-function
+                                                      (car list))))
+             (show-flag (save-excursion
+                          (set-buffer (car list))
+                          bs-buffer-show-mark)))
+        (if (or (eq show-flag 'always)
+                (and (or bs--show-all (not (eq show-flag 'never)))
+                     (not int-show-never)
+                     (or bs--show-all
+                         extern-must-show
+                         extern-must-show-from-fun
+                         (and (not ext-show-never)
+                              (not extern-show-never-from-fun)))))
+            (setq result (cons (car list)
+                               result)))
+        (setq list (cdr list))))
     (setq result (reverse result))
     ;; The current buffer which was the start point of bs should be an element
     ;; of result list, so that we can leave with space and be back in the
     ;; buffer we started bs-show.
     (if (and bs--buffer-coming-from
-      (buffer-live-p bs--buffer-coming-from)
-      (not (memq bs--buffer-coming-from result)))
- (setq result (cons bs--buffer-coming-from result)))
+             (buffer-live-p bs--buffer-coming-from)
+             (not (memq bs--buffer-coming-from result)))
+        (setq result (cons bs--buffer-coming-from result)))
     ;; sorting
     (if (and sort-description
-      (nth 1 sort-description))
- (setq result (sort result (nth 1 sort-description)))
+             (nth 1 sort-description))
+        (setq result (sort result (nth 1 sort-description)))
       ;; else standard sorting
       (bs-buffer-sort result))))
 
@@ -596,31 +599,31 @@ SORT-DESCRIPTION is an element of `bs-sort-functions'"
   (let ((line (1+ (count-lines 1 (point)))))
     (bs-show-in-buffer (bs-buffer-list nil sort-description))
     (if keep-line-p
- (goto-line line))
+        (goto-line line))
     (beginning-of-line)))
 
 (defun bs--goto-current-buffer ()
   "Goto line which represents the current buffer;
 actually the line which begins with character in `bs-string-current' or
 `bs-string-current-marked'."
-  (let (point
- (regexp (concat "^"
-   (regexp-quote bs-string-current)
-   "\\|^"
-   (regexp-quote bs-string-current-marked))))
+  (let ((regexp (concat "^"
+                        (regexp-quote bs-string-current)
+                        "\\|^"
+                        (regexp-quote bs-string-current-marked)))
+        point)
     (save-excursion
       (goto-char (point-min))
       (if (search-forward-regexp regexp nil t)
-   (setq point (- (point) 1))))
+          (setq point (- (point) 1))))
     (if point
- (goto-char point))))
+        (goto-char point))))
 
 (defun bs--current-config-message ()
   "Return a string describing the current `bs-mode' configuration."
   (if bs--show-all
       "Show all buffers."
     (format "Show buffer by configuration %S"
-     bs-current-configuration)))
+            bs-current-configuration)))
 
 (defun bs-mode ()
   "Major mode for editing a subset of Emacs' buffers.
@@ -661,11 +664,11 @@ to show always.
   (make-local-variable 'font-lock-defaults)
   (make-local-variable 'font-lock-verbose)
   (setq major-mode 'bs-mode
- mode-name "Buffer-Selection-Menu"
- buffer-read-only t
- truncate-lines t
- font-lock-defaults '(bs-mode-font-lock-keywords t)
- font-lock-verbose nil)
+        mode-name "Buffer-Selection-Menu"
+        buffer-read-only t
+        truncate-lines t
+        font-lock-defaults '(bs-mode-font-lock-keywords t)
+        font-lock-verbose nil)
   (run-hooks 'bs-mode-hook))
 
 (defun bs-kill ()
@@ -676,7 +679,7 @@ to show always.
 
 (defun bs-abort ()
   "Ding and leave Buffer Selection Menu without a selection."
- (interactive)
+  (interactive)
   (ding)
   (bs-kill))
 
@@ -698,35 +701,35 @@ Take only windows of current frame into account.
 Return nil if there is no such buffer."
   (let ((window nil))
     (walk-windows (lambda (wind)
-      (if (string= (buffer-name (window-buffer wind))
-     buffer-name)
-   (setq window wind))))
+                    (if (string= (buffer-name (window-buffer wind))
+                                 buffer-name)
+                        (setq window wind))))
     window))
 
 (defun bs--set-window-height ()
   "Change the height of the selected window to suit the current buffer list."
   (unless (one-window-p t)
     (shrink-window (- (window-height (selected-window))
-        ;; window-height in xemacs includes mode-line
-        (+ (if bs--running-in-xemacs 3 1)
-    bs-header-lines-length
-    (min (length bs-current-list)
-         bs-max-window-height))))))
+                      ;; window-height in xemacs includes mode-line
+                      (+ (if bs--running-in-xemacs 3 1)
+                         bs-header-lines-length
+                         (min (length bs-current-list)
+                              bs-max-window-height))))))
 
 (defun bs--current-buffer ()
   "Return buffer on current line.
 Raise an error if not an a buffer line."
   (beginning-of-line)
   (let ((line (+ (- bs-header-lines-length)
-   (count-lines 1 (point)))))
+                 (count-lines 1 (point)))))
     (if (< line 0)
- (error "You are on a header row"))
+        (error "You are on a header row"))
     (nth line bs-current-list)))
 
 (defun bs--update-current-line ()
   "Update the entry on current line for Buffer Selection Menu."
   (let ((buffer (bs--current-buffer))
- (inhibit-read-only t))
+        (inhibit-read-only t))
     (beginning-of-line)
     (delete-region (point) (line-end-position))
     (bs--insert-one-entry buffer)
@@ -751,18 +754,18 @@ Leave Buffer Selection Menu."
     (set-window-configuration bs--window-config-coming-from)
     (switch-to-buffer buffer)
     (if bs--marked-buffers
- ;; Some marked buffers for selection
- (let* ((all (delq buffer bs--marked-buffers))
-        (height (/ (1- (frame-height)) (1+ (length all)))))
-   (delete-other-windows)
-   (switch-to-buffer buffer)
-   (while all
-     (split-window nil height)
-     (other-window 1)
-     (switch-to-buffer (car all))
-     (setq all (cdr all)))
-   ;; goto window we have started bs.
-   (other-window 1)))))
+        ;; Some marked buffers for selection
+        (let* ((all (delq buffer bs--marked-buffers))
+               (height (/ (1- (frame-height)) (1+ (length all)))))
+          (delete-other-windows)
+          (switch-to-buffer buffer)
+          (while all
+            (split-window nil height)
+            (other-window 1)
+            (switch-to-buffer (car all))
+            (setq all (cdr all)))
+          ;; goto window we have started bs.
+          (other-window 1)))))
 
 (defun bs-select-other-window ()
   "Select current line's buffer by `switch-to-buffer-other-window'.
@@ -834,21 +837,21 @@ See `visit-tags-table'."
   (interactive)
   (let ((file (buffer-file-name (bs--current-buffer))))
     (if file
- (visit-tags-table file)
+        (visit-tags-table file)
       (error "Specified buffer has no file"))))
 
 (defun bs-toggle-current-to-show ()
   "Toggle status of showing flag for buffer in current line."
   (interactive)
   (let ((buffer (bs--current-buffer))
- res)
+        res)
     (save-excursion
       (set-buffer buffer)
       (setq res (cond ((null bs-buffer-show-mark)
-         'never)
-        ((eq bs-buffer-show-mark 'never)
-         'always)
-        (t nil)))
+                       'never)
+                      ((eq bs-buffer-show-mark 'never)
+                       'always)
+                      (t nil)))
       (setq bs-buffer-show-mark res))
     (bs--update-current-line)
     (bs--set-window-height)
@@ -886,13 +889,13 @@ COUNT is the number of buffers to mark.
 Move cursor vertically down COUNT lines."
   (interactive "p")
   (let ((dir (if (> count 0) 1 -1))
- (count (abs count)))
+        (count (abs count)))
     (while (> count 0)
       (let ((buffer (bs--current-buffer)))
- (if buffer
-     (setq bs--marked-buffers (cons buffer bs--marked-buffers)))
- (bs--update-current-line)
- (bs-down dir))
+        (if buffer
+            (setq bs--marked-buffers (cons buffer bs--marked-buffers)))
+        (bs--update-current-line)
+        (bs-down dir))
       (setq count (1- count)))))
 
 (defun bs-unmark-current (count)
@@ -901,40 +904,40 @@ COUNT is the number of buffers to unmark.
 Move cursor vertically down COUNT lines."
   (interactive "p")
   (let ((dir (if (> count 0) 1 -1))
- (count (abs count)))
+        (count (abs count)))
     (while (> count 0)
       (let ((buffer (bs--current-buffer)))
- (if buffer
-     (setq bs--marked-buffers (delq buffer bs--marked-buffers)))
- (bs--update-current-line)
- (bs-down dir))
+        (if buffer
+            (setq bs--marked-buffers (delq buffer bs--marked-buffers)))
+        (bs--update-current-line)
+        (bs-down dir))
       (setq count (1- count)))))
 
 (defun bs--show-config-message (what)
   "Show message indicating the new showing status WHAT.
 WHAT is a value of nil, `never', or `always'."
   (bs-message-without-log (cond ((null what)
-     "Buffer will be shown normally.")
-    ((eq what 'never)
-     "Mark buffer to never be shown.")
-    (t "Mark buffer to show always."))))
+                                 "Buffer will be shown normally.")
+                                ((eq what 'never)
+                                 "Mark buffer to never be shown.")
+                                (t "Mark buffer to show always."))))
 
 (defun bs-delete ()
   "Kill buffer on current line."
   (interactive)
   (let ((current (bs--current-buffer))
- (inhibit-read-only t))
+        (inhibit-read-only t))
     (setq bs-current-list (delq current bs-current-list))
     (kill-buffer current)
     (beginning-of-line)
     (delete-region (point) (save-excursion
-        (end-of-line)
-        (if (eobp) (point) (1+ (point)))))
+                             (end-of-line)
+                             (if (eobp) (point) (1+ (point)))))
     (if (eobp)
- (progn
-   (backward-delete-char 1)
-   (beginning-of-line)
-   (recenter -1)))
+        (progn
+          (backward-delete-char 1)
+          (beginning-of-line)
+          (recenter -1)))
     (bs--set-window-height)))
 
 (defun bs-delete-backward ()
@@ -943,14 +946,14 @@ WHAT is a value of nil, `never', or `always'."
   (let ((on-last-line-p (save-excursion (end-of-line) (eobp))))
     (bs-delete)
     (unless on-last-line-p
- (bs-up 1))))
+      (bs-up 1))))
 
 (defun bs-show-sorted ()
   "Show buffer list sorted by buffer name."
   (interactive)
   (setq bs--current-sort-function
- (bs-next-config-aux (car bs--current-sort-function)
-       bs-sort-functions))
+        (bs-next-config-aux (car bs--current-sort-function)
+                            bs-sort-functions))
   (bs--redisplay)
   (bs--goto-current-buffer)
   (bs-message-without-log "Sorted %s" (car bs--current-sort-function)))
@@ -960,7 +963,7 @@ WHAT is a value of nil, `never', or `always'."
 SORT-DESCRIPTION is an element of `bs-sort-functions'.
 Default is `bs--current-sort-function'."
   (let ((sort-description (or sort-description
-         bs--current-sort-function)))
+                              bs--current-sort-function)))
     (save-excursion
       (goto-char (point-min))
       (if (and (nth 2 sort-description)
@@ -1020,9 +1023,9 @@ If on top of buffer list go to last line."
   (previous-line 1)
   (if (<= (count-lines 1 (point)) (1- bs-header-lines-length))
       (progn
- (goto-char (point-max))
- (beginning-of-line)
- (recenter -1))
+        (goto-char (point-max))
+        (beginning-of-line)
+        (recenter -1))
     (beginning-of-line)))
 
 (defun bs-down (arg)
@@ -1037,7 +1040,7 @@ If on top of buffer list go to last line."
 If at end of buffer list go to first line."
   (let ((last (line-end-position)))
     (if (eq last (point-max))
- (goto-line (1+ bs-header-lines-length))
+        (goto-line (1+ bs-header-lines-length))
       (next-line 1))))
 
 (defun bs-visits-non-file (buffer)
@@ -1060,28 +1063,28 @@ These variables are `bs-dont-show-regexp', `bs-must-show-regexp',
 `bs-dont-show-function', `bs-must-show-function' and
 `bs-buffer-sort-function'."
   (setq bs-dont-show-regexp nil
- bs-must-show-regexp nil
- bs-dont-show-function nil
- bs-must-show-function nil
- bs-buffer-sort-function nil))
+        bs-must-show-regexp nil
+        bs-dont-show-function nil
+        bs-must-show-function nil
+        bs-buffer-sort-function nil))
 
 (defun bs-config--only-files ()
   "Define a configuration for showing only buffers visiting a file."
   (bs-config-clear)
-  (setq ;; I want to see *-buffers at the end
-        bs-buffer-sort-function 'bs-sort-buffer-interns-are-last
- ;; Don't show files who don't belong to a file
- bs-dont-show-function 'bs-visits-non-file))
+  (setq;; I want to see *-buffers at the end
+   bs-buffer-sort-function 'bs-sort-buffer-interns-are-last
+   ;; Don't show files who don't belong to a file
+   bs-dont-show-function 'bs-visits-non-file))
 
 (defun bs-config--files-and-scratch ()
   "Define a configuration for showing buffer *scratch* and file buffers."
   (bs-config-clear)
-  (setq ;; I want to see *-buffers at the end
-        bs-buffer-sort-function 'bs-sort-buffer-interns-are-last
- ;; Don't show files who don't belong to a file
- bs-dont-show-function 'bs-visits-non-file
- ;; Show *scratch* buffer.
- bs-must-show-regexp "^\\*scratch\\*"))
+  (setq;; I want to see *-buffers at the end
+   bs-buffer-sort-function 'bs-sort-buffer-interns-are-last
+   ;; Don't show files who don't belong to a file
+   bs-dont-show-function 'bs-visits-non-file
+   ;; Show *scratch* buffer.
+   bs-must-show-regexp "^\\*scratch\\*"))
 
 (defun bs-config--all ()
   "Define a configuration for showing all buffers.
@@ -1100,20 +1103,20 @@ Intern buffers appear at end of all buffers."
 When called interactively ask user for a configuration and apply selected
 configuration."
   (interactive (list (completing-read "Use configuration: "
-          bs-configurations
-          nil
-          t)))
+                                      bs-configurations
+                                      nil
+                                      t)))
   (let ((list (assoc name bs-configurations)))
     (if list
- (if (listp list)
-     (setq bs-current-configuration name
-    bs-must-show-regexp     (nth 1 list)
-    bs-must-show-function   (nth 2 list)
-    bs-dont-show-regexp     (nth 3 list)
-    bs-dont-show-function   (nth 4 list)
-    bs-buffer-sort-function (nth 5 list))
-   ;; for backward compability
-   (funcall (cdr list)))
+        (if (listp list)
+            (setq bs-current-configuration name
+                  bs-must-show-regexp     (nth 1 list)
+                  bs-must-show-function   (nth 2 list)
+                  bs-dont-show-regexp     (nth 3 list)
+                  bs-dont-show-function   (nth 4 list)
+                  bs-buffer-sort-function (nth 5 list))
+          ;; for backward compability
+          (funcall (cdr list)))
       ;; else
       (ding)
       (bs-message-without-log "No bs-configuration named %S." name))))
@@ -1127,15 +1130,15 @@ configuration."
   "Get the next assoc after START-NAME in list LIST.
 Will return the first if START-NAME is at end."
   (let ((assocs list)
- (length (length list))
- pos)
+        (length (length list))
+        pos)
     (while (and assocs (not pos))
       (if (string= (car (car assocs)) start-name)
-   (setq pos (- length (length assocs))))
+          (setq pos (- length (length assocs))))
       (setq assocs (cdr assocs)))
     (setq pos (1+ pos))
     (if (eq pos length)
- (car list)
+        (car list)
       (nth pos list))))
 
 (defun bs-next-config (name)
@@ -1163,13 +1166,13 @@ and move point to current buffer."
   (switch-to-buffer (get-buffer-create "*buffer-selection*"))
   (bs-mode)
   (let* ((inhibit-read-only t)
-  (map-fun (lambda (entry)
-      (length (buffer-name entry))))
-  (max-length-of-names (apply 'max
-         (cons 0 (mapcar map-fun list))))
-  (name-entry-length (min bs-maximal-buffer-name-column
-     (max bs-minimal-buffer-name-column
-          max-length-of-names))))
+         (map-fun (lambda (entry)
+                    (length (buffer-name entry))))
+         (max-length-of-names (apply 'max
+                                     (cons 0 (mapcar map-fun list))))
+         (name-entry-length (min bs-maximal-buffer-name-column
+                                 (max bs-minimal-buffer-name-column
+                                      max-length-of-names))))
     (erase-buffer)
     (setq bs--name-entry-length name-entry-length)
     (bs--show-header)
@@ -1190,12 +1193,12 @@ If BUFFER-LIST is nil the result of `bs-buffer-list' will be used as
 buffer list.  The result is a cons of normally the second element of
 BUFFER-LIST and the buffer list used for buffer cycling."
   (let* ((bs--current-sort-function (if sorting-p
-     bs--current-sort-function))
-  (bs-buffer-list (or buffer-list (bs-buffer-list))))
+                                        bs--current-sort-function))
+         (bs-buffer-list (or buffer-list (bs-buffer-list))))
     (cons (or (car (cdr bs-buffer-list))
-       (car bs-buffer-list)
-       (current-buffer))
-   bs-buffer-list)))
+              (car bs-buffer-list)
+              (current-buffer))
+          bs-buffer-list)))
 
 (defun bs-previous-buffer (&optional buffer-list sorting-p)
   "Return previous buffer and buffer list for buffer cycling in BUFFER-LIST.
@@ -1204,11 +1207,11 @@ If BUFFER-LIST is nil the result of `bs-buffer-list' will be used as
 buffer list.  The result is a cons of last element of BUFFER-LIST and the
 buffer list used for buffer cycling."
   (let* ((bs--current-sort-function (if sorting-p
-     bs--current-sort-function))
-  (bs-buffer-list (or buffer-list (bs-buffer-list))))
+                                        bs--current-sort-function))
+         (bs-buffer-list (or buffer-list (bs-buffer-list))))
     (cons (or (car (last bs-buffer-list))
-       (current-buffer))
-   bs-buffer-list)))
+              (current-buffer))
+          bs-buffer-list)))
 
 (defun bs-message-without-log (&rest args)
   "Like `message' but don't log it on the message log.
@@ -1226,29 +1229,29 @@ The buffers taking part in buffer cycling are defined
 by buffer configuration `bs-cycle-configuration-name'."
   (interactive)
   (let ((bs--buffer-coming-from (current-buffer))
- (bs-dont-show-regexp   bs-dont-show-regexp)
- (bs-must-show-regexp   bs-must-show-regexp)
- (bs-dont-show-function bs-dont-show-function)
- (bs-must-show-function bs-must-show-function)
- (bs--show-all          bs--show-all))
+        (bs-dont-show-regexp   bs-dont-show-regexp)
+        (bs-must-show-regexp   bs-must-show-regexp)
+        (bs-dont-show-function bs-dont-show-function)
+        (bs-must-show-function bs-must-show-function)
+        (bs--show-all          bs--show-all))
     (if bs-cycle-configuration-name
- (bs-set-configuration bs-cycle-configuration-name))
+        (bs-set-configuration bs-cycle-configuration-name))
     (let ((bs-buffer-sort-function nil)
-   (bs--current-sort-function nil))
+          (bs--current-sort-function nil))
       (let* ((tupel (bs-next-buffer (if (or (eq last-command
-      'bs-cycle-next)
-         (eq last-command
-      'bs-cycle-previous))
-     bs--cycle-list)))
-      (next (car tupel))
-      (cycle-list (cdr tupel)))
- (setq bs--cycle-list (append (cdr cycle-list)
-         (list (car cycle-list))))
- (bury-buffer)
- (switch-to-buffer next)
- (bs-message-without-log "Next buffers: %s"
-    (or (cdr bs--cycle-list)
-        "this buffer"))))))
+                                                'bs-cycle-next)
+                                            (eq last-command
+                                                'bs-cycle-previous))
+                                        bs--cycle-list)))
+             (next (car tupel))
+             (cycle-list (cdr tupel)))
+        (setq bs--cycle-list (append (cdr cycle-list)
+                                     (list (car cycle-list))))
+        (bury-buffer)
+        (switch-to-buffer next)
+        (bs-message-without-log "Next buffers: %s"
+                                (or (cdr bs--cycle-list)
+                                    "this buffer"))))))
 
 
 ;;;###autoload
@@ -1258,38 +1261,38 @@ The buffers taking part in buffer cycling are defined
 by buffer configuration `bs-cycle-configuration-name'."
   (interactive)
   (let ((bs--buffer-coming-from (current-buffer))
- (bs-dont-show-regexp   bs-dont-show-regexp)
- (bs-must-show-regexp   bs-must-show-regexp)
- (bs-dont-show-function bs-dont-show-function)
- (bs-must-show-function bs-must-show-function)
- (bs--show-all          bs--show-all))
+        (bs-dont-show-regexp   bs-dont-show-regexp)
+        (bs-must-show-regexp   bs-must-show-regexp)
+        (bs-dont-show-function bs-dont-show-function)
+        (bs-must-show-function bs-must-show-function)
+        (bs--show-all          bs--show-all))
     (if bs-cycle-configuration-name
- (bs-set-configuration bs-cycle-configuration-name))
+        (bs-set-configuration bs-cycle-configuration-name))
     (let ((bs-buffer-sort-function nil)
-   (bs--current-sort-function nil))
+          (bs--current-sort-function nil))
       (let* ((tupel (bs-previous-buffer (if (or (eq last-command
-          'bs-cycle-next)
-      (eq last-command
-          'bs-cycle-previous))
-         bs--cycle-list)))
-      (prev-buffer (car tupel))
-      (cycle-list (cdr tupel)))
- (setq bs--cycle-list (append (last cycle-list)
-         (reverse (cdr (reverse cycle-list)))))
- (switch-to-buffer prev-buffer)
- (bs-message-without-log "Previous buffers: %s"
-    (or (reverse (cdr bs--cycle-list))
-        "this buffer"))))))
+                                                    'bs-cycle-next)
+                                                (eq last-command
+                                                    'bs-cycle-previous))
+                                            bs--cycle-list)))
+             (prev-buffer (car tupel))
+             (cycle-list (cdr tupel)))
+        (setq bs--cycle-list (append (last cycle-list)
+                                     (reverse (cdr (reverse cycle-list)))))
+        (switch-to-buffer prev-buffer)
+        (bs-message-without-log "Previous buffers: %s"
+                                (or (reverse (cdr bs--cycle-list))
+                                    "this buffer"))))))
 
 (defun bs--get-value (fun &optional args)
   "Apply function FUN with arguments ARGS.
 Return result of evaluation.  Will return FUN if FUN is a number
 or a string."
   (cond ((numberp fun)
-  fun)
- ((stringp fun)
-  fun)
- (t (apply fun args))))
+         fun)
+        ((stringp fun)
+         fun)
+        (t (apply fun args))))
 
 (defun bs--get-marked-string (start-buffer all-buffers)
   "Return a string which describes whether current buffer is marked.
@@ -1298,23 +1301,23 @@ ALL-BUFFERS is the list of buffer appearing in Buffer Selection Menu.
 The result string is one of `bs-string-current', `bs-string-current-marked',
 `bs-string-marked', `bs-string-show-normally', `bs-string-show-never', or
 `bs-string-show-always'."
-  (cond ;; current buffer is the buffer we started buffer selection.
-        ((eq (current-buffer) start-buffer)
-  (if (memq (current-buffer) bs--marked-buffers)
-      bs-string-current-marked ; buffer is marked
-    bs-string-current))
- ;; current buffer is marked
- ((memq (current-buffer) bs--marked-buffers)
-  bs-string-marked)
- ;; current buffer hasn't a special mark.
- ((null bs-buffer-show-mark)
-  bs-string-show-normally)
- ;; current buffer has a mark not to show itself.
- ((eq bs-buffer-show-mark 'never)
-  bs-string-show-never)
- ;; otherwise current buffer is marked to show always.
- (t
-  bs-string-show-always)))
+  (cond;; current buffer is the buffer we started buffer selection.
+   ((eq (current-buffer) start-buffer)
+    (if (memq (current-buffer) bs--marked-buffers)
+        bs-string-current-marked        ; buffer is marked
+      bs-string-current))
+   ;; current buffer is marked
+   ((memq (current-buffer) bs--marked-buffers)
+    bs-string-marked)
+   ;; current buffer hasn't a special mark.
+   ((null bs-buffer-show-mark)
+    bs-string-show-normally)
+   ;; current buffer has a mark not to show itself.
+   ((eq bs-buffer-show-mark 'never)
+    bs-string-show-never)
+   ;; otherwise current buffer is marked to show always.
+   (t
+    bs-string-show-always)))
 
 (defun bs--get-modified-string (start-buffer all-buffers)
   "Return a string which describes whether current buffer is modified.
@@ -1343,8 +1346,8 @@ ALL-BUFFERS is the list of buffer appearing in Buffer Selection Menu."
   (let ((name (copy-sequence (buffer-name))))
     (put-text-property 0 (length name) 'mouse-face 'highlight name)
     (if (< (length name) bs--name-entry-length)
- (concat name
-  (make-string (- bs--name-entry-length (length name)) ? ))
+        (concat name
+                (make-string (- bs--name-entry-length (length name)) ? ))
       name)))
 
 
@@ -1362,9 +1365,9 @@ default directory.
 START-BUFFER is the buffer where we started buffer selection.
 ALL-BUFFERS is the list of buffer appearing in Buffer Selection Menu."
   (let ((string (copy-sequence (if (member major-mode
-        '(shell-mode dired-mode))
-       default-directory
-     (or buffer-file-name "")))))
+                                           '(shell-mode dired-mode))
+                                   default-directory
+                                 (or buffer-file-name "")))))
     (put-text-property 0 (length string) 'mouse-face 'highlight string)
     string))
 
@@ -1375,25 +1378,25 @@ It goes over all columns described in `bs-attributes-list'
 and evaluates corresponding string.  Inserts string in current buffer;
 normally *buffer-selection*."
   (let ((string "")
- (columns bs-attributes-list)
- (to-much 0)
+        (columns bs-attributes-list)
+        (to-much 0)
         (apply-args (append (list bs--buffer-coming-from bs-current-list))))
     (save-excursion
       (while columns
- (set-buffer buffer)
- (let ((min   (bs--get-value (nth 1 (car columns))))
-       ;;(max   (bs--get-value (nth 2 (car columns)))) refered no more
-       (align (nth 3 (car columns)))
-       (fun   (nth 4 (car columns)))
-       (val   nil)
-       new-string)
-   (setq val (bs--get-value fun apply-args))
-   (setq new-string (bs--format-aux val align (- min to-much)))
-   (setq string (concat string new-string))
-   (if (> (length new-string) min)
-       (setq to-much (- (length new-string) min)))
-   ) ; let
- (setq columns (cdr columns))))
+        (set-buffer buffer)
+        (let ((min   (bs--get-value (nth 1 (car columns))))
+              ;;(max   (bs--get-value (nth 2 (car columns)))) refered no more
+              (align (nth 3 (car columns)))
+              (fun   (nth 4 (car columns)))
+              (val   nil)
+              new-string)
+          (setq val (bs--get-value fun apply-args))
+          (setq new-string (bs--format-aux val align (- min to-much)))
+          (setq string (concat string new-string))
+          (if (> (length new-string) min)
+              (setq to-much (- (length new-string) min)))
+          )                             ; let
+        (setq columns (cdr columns))))
     (insert string)
     string))
 
@@ -1402,16 +1405,16 @@ normally *buffer-selection*."
 ALIGN is one of the symbols `left', `middle', or `right'."
   (let ((length (length string)))
     (if (>= length len)
- string
+        string
       (if (eq 'right align)
-   (concat (make-string (- len length) ? ) string)
- (concat string (make-string (- len length) ? ))))))
+          (concat (make-string (- len length) ? ) string)
+        (concat string (make-string (- len length) ? ))))))
 
 (defun bs--show-header ()
   "Insert header for Buffer Selection Menu in current buffer."
   (mapcar '(lambda (string)
-      (insert string "\n"))
-   (bs--create-header)))
+             (insert string "\n"))
+          (bs--create-header)))
 
 (defun bs--get-name-length ()
   "Return value of `bs--name-entry-length'."
@@ -1420,18 +1423,18 @@ ALIGN is one of the symbols `left', `middle', or `right'."
 (defun bs--create-header ()
   "Return all header lines used in Buffer Selection Menu as a list of strings."
   (list (mapconcat (lambda (column)
-       (bs--format-aux (bs--get-value (car column))
-         (nth 3 column) ; align
-         (bs--get-value (nth 1 column))))
-     bs-attributes-list
-     "")
- (mapconcat (lambda (column)
-       (let ((length (length (bs--get-value (car column)))))
-         (bs--format-aux (make-string length ?-)
-           (nth 3 column) ; align
-           (bs--get-value (nth 1 column)))))
-     bs-attributes-list
-     "")))
+                     (bs--format-aux (bs--get-value (car column))
+                                     (nth 3 column) ; align
+                                     (bs--get-value (nth 1 column))))
+                   bs-attributes-list
+                   "")
+        (mapconcat (lambda (column)
+                     (let ((length (length (bs--get-value (car column)))))
+                       (bs--format-aux (make-string length ?-)
+                                       (nth 3 column) ; align
+                                       (bs--get-value (nth 1 column)))))
+                   bs-attributes-list
+                   "")))
 
 (defun bs--show-with-configuration (name &optional arg)
   "Display buffer list of configuration with NAME name.
@@ -1446,38 +1449,38 @@ The optional argument ARG is the prefix argument when calling a function
 for buffer selection."
   (bs-set-configuration name)
   (let ((bs--show-all (or bs--show-all arg)))
-  (unless (string= "*buffer-selection*" (buffer-name))
+    (unless (string= "*buffer-selection*" (buffer-name))
       ;; Only when not in buffer *buffer-selection*
       ;; we have to set the buffer we started the command
       (progn
- (setq bs--buffer-coming-from (current-buffer))
- (setq bs--window-config-coming-from (current-window-configuration))))
-  (let ((liste (bs-buffer-list))
- (active-window (bs--window-for-buffer "*buffer-selection*")))
-    (if active-window
- (select-window active-window)
-      (if (> (window-height (selected-window)) 7)
-   (progn
-     (split-window-vertically)
-     (other-window 1))))
-    (bs-show-in-buffer liste)
-    (bs-message-without-log "%s" (bs--current-config-message)))))
+        (setq bs--buffer-coming-from (current-buffer))
+        (setq bs--window-config-coming-from (current-window-configuration))))
+    (let ((liste (bs-buffer-list))
+          (active-window (bs--window-for-buffer "*buffer-selection*")))
+      (if active-window
+          (select-window active-window)
+        (if (> (window-height (selected-window)) 7)
+            (progn
+              (split-window-vertically)
+              (other-window 1))))
+      (bs-show-in-buffer liste)
+      (bs-message-without-log "%s" (bs--current-config-message)))))
 
 (defun bs--configuration-name-for-prefix-arg (prefix-arg)
   "Convert prefix argument PREFIX-ARG to a name of a buffer configuration.
 If PREFIX-ARG is nil return `bs-default-configuration'.
 If PREFIX-ARG is an integer return PREFIX-ARG element of `bs-configurations'.
 Otherwise return `bs-alternative-configuration'."
-  (cond ;; usually activation
-        ((null prefix-arg)
-  bs-default-configuration)
- ;; call with integer as prefix argument
- ((integerp prefix-arg)
-  (if (and (< 0 prefix-arg) (<= prefix-arg (length bs-configurations)))
-      (car (nth (1- prefix-arg) bs-configurations))
-    bs-default-configuration))
- ;; call by prefix argument C-u
- (t bs-alternative-configuration)))
+  (cond;; usually activation
+   ((null prefix-arg)
+    bs-default-configuration)
+   ;; call with integer as prefix argument
+   ((integerp prefix-arg)
+    (if (and (< 0 prefix-arg) (<= prefix-arg (length bs-configurations)))
+        (car (nth (1- prefix-arg) bs-configurations))
+      bs-default-configuration))
+   ;; call by prefix argument C-u
+   (t bs-alternative-configuration)))
 
 ;; ----------------------------------------------------------------------
 ;; Main function bs-customize and bs-show
@@ -1491,7 +1494,7 @@ Otherwise return `bs-alternative-configuration'."
 
 ;;;###autoload
 (defun bs-show (arg)
-  "Make a menu of buffers so you can manipulate buffer list or buffers itself.
+  "Make a menu of buffers so you can manipulate buffers or the buffer list.
 \\<bs-mode-map>
 There are many key commands similar to `Buffer-menu-mode' for
 manipulating buffer list and buffers itself.