about summary refs log tree commit diff
path: root/configs/shared/emacs/.emacs.d/elpa/tablist-20170220.335/tablist.el
diff options
context:
space:
mode:
Diffstat (limited to 'configs/shared/emacs/.emacs.d/elpa/tablist-20170220.335/tablist.el')
-rw-r--r--configs/shared/emacs/.emacs.d/elpa/tablist-20170220.335/tablist.el1941
1 files changed, 0 insertions, 1941 deletions
diff --git a/configs/shared/emacs/.emacs.d/elpa/tablist-20170220.335/tablist.el b/configs/shared/emacs/.emacs.d/elpa/tablist-20170220.335/tablist.el
deleted file mode 100644
index 1fbfb313528e..000000000000
--- a/configs/shared/emacs/.emacs.d/elpa/tablist-20170220.335/tablist.el
+++ /dev/null
@@ -1,1941 +0,0 @@
-;;; tablist.el --- Extended tabulated-list-mode -*- lexical-binding: t -*-
-
-;; Copyright (C) 2013, 2014  Andreas Politz
-
-;; Author: Andreas Politz <politza@fh-trier.de>
-;; Keywords: extensions, lisp
-;; Package: tablist
-;; Version: 0.70
-;; Package-Requires: ((emacs "24.3"))
-
-;; This program is free software; you can redistribute it and/or modify
-;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation, either version 3 of the License, or
-;; (at your option) any later version.
-
-;; This program is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-;; GNU General Public License for more details.
-
-;; You should have received a copy of the GNU General Public License
-;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-;;; Commentary:
-;;
-;; This package adds marks and filters to tabulated-list-mode.  It
-;; also kind of puts a dired face on tabulated list buffers.
-;;
-;; It can be used by deriving from tablist-mode and some features by
-;; using tablist-minor-mode inside a tabulated-list-mode buffer.
-;;
-
-;;; Code:
-
-(require 'cl-lib)
-(require 'ring)
-(require 'tabulated-list)
-(require 'dired)
-(require 'tablist-filter)
-
-;;
-;; *Macros
-;;
-
-(defmacro tablist-save-marks (&rest body)
-  "Eval body, while preserving all marks."
-  (let ((marks (make-symbol "marks")))
-    `(let (,marks)
-       (save-excursion
-         (goto-char (point-min))
-         (let ((re "^\\([^ ]\\)"))
-           (while (re-search-forward re nil t)
-             (push (cons (tabulated-list-get-id)
-                         (tablist-get-mark-state))
-                   ,marks))))
-       (unwind-protect
-           (progn ,@body)
-         (save-excursion
-           (dolist (m ,marks)
-             (let ((id (pop m)))
-               (goto-char (point-min))
-               (while (and id (not (eobp)))
-                 (when (equal id (tabulated-list-get-id))
-                   (tablist-put-mark-state m)
-                   (setq id nil))
-                 (forward-line)))))))))
-
-(defmacro tablist-with-remembering-entry (&rest body)
-  "Remember where body left of and restore previous position.
-
-If the current entry is still visible, move to it. Otherwise move
-to the next visible one after it.  If that also fails, goto to
-the beginning of the buffer.  Finally move point to the major
-column."
-  (declare (indent 0) (debug t))
-  (let ((re (make-symbol "re"))
-        (id (make-symbol "id"))
-        (col (make-symbol "col")))
-    `(let ((,re
-            (replace-regexp-in-string
-             "[\t ]+" "[\t ]*" (regexp-quote
-                                (or (thing-at-point 'line) ""))
-             t t))
-           (,id (tabulated-list-get-id))
-           (,col (tablist-current-column)))
-       (progn
-         ,@body
-         (let (success pos)
-           (goto-char (point-min))
-           (setq pos (point))
-           (while (and (setq success (re-search-forward ,re nil t))
-                       (> (point) (prog1 pos (setq pos (point))))
-                       (forward-line -1)
-                       (not (equal ,id (tabulated-list-get-id))))
-             (forward-line))
-           (unless success
-             (goto-char (point-min))
-             (while (and (not (eobp))
-                         (not success))
-               (if (equal (tabulated-list-get-id) ,id)
-                   (setq success t)
-                 (forward-line))))
-           (unless (and success (not (invisible-p (point))))
-             (goto-char (point-min)))
-           (tablist-skip-invisible-entries)
-           (tablist-move-to-column
-            (or ,col (car (tablist-major-columns))))
-           (dolist (win (get-buffer-window-list))
-             (set-window-point win (point))))))))
-
-(defmacro tablist-with-filter-displayed (&rest body)
-  "Display the current filter in the mode while evalling BODY."
-  (let ((state (make-symbol "state")))
-    `(let ((,state (tablist-display-filter 'state)))
-       (tablist-display-filter t)
-       (unwind-protect
-           (progn ,@body)
-         (tablist-display-filter ,state)))))
-
-;;
-;; *Mode Maps
-;;
-
-(defvar tablist-mode-filter-map
-  (let ((kmap (make-sparse-keymap)))
-    (define-key kmap "p" 'tablist-pop-filter)
-    (define-key kmap "r" 'tablist-push-regexp-filter)
-    (define-key kmap "=" 'tablist-push-equal-filter)
-    (define-key kmap "n" 'tablist-push-numeric-filter)
-    (define-key kmap "!" 'tablist-negate-filter)
-    (define-key kmap "t" 'tablist-toggle-first-filter-logic)
-    (define-key kmap "/" 'tablist-display-filter)
-    (define-key kmap "z" 'tablist-suspend-filter)
-
-    (define-key kmap "a" 'tablist-push-named-filter)
-    (define-key kmap "s" 'tablist-name-current-filter)
-    (define-key kmap "D" 'tablist-delete-named-filter)
-    (define-key kmap "d" 'tablist-deconstruct-named-filter)
-    (define-key kmap "e" 'tablist-edit-filter)
-    (define-key kmap "C" 'tablist-clear-filter)
-    kmap))
-
-(defvar tablist-mode-mark-map
-  (let ((kmap (make-sparse-keymap)))
-    (define-key kmap "c" 'tablist-change-marks)
-    (define-key kmap "!" 'tablist-unmark-all-marks)
-    (define-key kmap "r" 'tablist-mark-items-regexp)
-    (define-key kmap "n" 'tablist-mark-items-numeric)
-    (define-key kmap "m" 'tablist-mark-forward)
-    kmap))
-
-(defvar tablist-mode-regexp-map
-  (let ((kmap (make-sparse-keymap)))
-    ;; (define-key kmap "&" 'tablist-flag-gargabe-items)
-    (define-key kmap "m" 'tablist-mark-items-regexp)
-    kmap))
-
-(defvar tablist-minor-mode-map
-  (let ((kmap (make-sparse-keymap)))
-    (define-key kmap "m" 'tablist-mark-forward)
-    (define-key kmap (kbd "DEL") 'tablist-unmark-backward)
-    (define-key kmap "k" 'tablist-do-kill-lines)
-    (define-key kmap "U" 'tablist-unmark-all-marks)
-    (define-key kmap "u" 'tablist-unmark-forward)
-    (define-key kmap "t" 'tablist-toggle-marks)
-
-    (define-key kmap (kbd "TAB") 'tablist-forward-column)
-    (define-key kmap "\t" 'tablist-forward-column)
-    (define-key kmap [backtab] 'tablist-backward-column)
-
-    (define-key kmap "%" tablist-mode-regexp-map)
-    (define-key kmap "*" tablist-mode-mark-map)
-    (define-key kmap "/" tablist-mode-filter-map)
-
-    ;; (define-key kmap "e" 'tablist-edit-column)
-    ;; (define-key kmap "i" 'tablist-insert-entry)
-    (define-key kmap "s" 'tablist-sort)
-    (define-key kmap [remap back-to-indentation] 'tablist-move-to-major-column)
-    (define-key kmap [remap next-line] 'tablist-next-line)
-    (define-key kmap [remap previous-line] 'tablist-previous-line)
-    (define-key kmap "<" 'tablist-shrink-column)
-    (define-key kmap ">" 'tablist-enlarge-column)
-    (define-key kmap "q" 'tablist-quit)
-    (define-key kmap "G" 'tablist-revert)
-    (define-key kmap (kbd "C-c C-e") 'tablist-export-csv)
-    kmap))
-
-(defvar tablist-mode-map
-  (let ((kmap (copy-keymap tablist-minor-mode-map)))
-    (set-keymap-parent kmap tabulated-list-mode-map)
-    (define-key kmap "d" 'tablist-flag-forward)
-    (define-key kmap (kbd "RET") 'tablist-find-entry)
-    (define-key kmap "f" 'tablist-find-entry)
-    ;; (define-key kmap "~" 'tablist-flag-gargabe-items)
-    (define-key kmap "D" 'tablist-do-delete)
-    (define-key kmap "C" 'tablist-do-copy)
-    (define-key kmap "R" 'tablist-do-rename)
-    (define-key kmap "x" 'tablist-do-flagged-delete)
-    ;; (define-key kmap "F" 'tablist-find-marked-items)
-    ;; (define-key kmap (kbd "C-o") 'tablist-display-item)
-    kmap))
-
-;;
-;; *Variables
-;;
-
-;; Marking
-(defvar tablist-umark-filtered-entries t)
-(defvar tablist-marker-char dired-marker-char
-  "The character used for marking.")
-(defvar tablist-marker-face 'dired-mark
-  "The face used for the mark character.")
-(defvar tablist-marked-face  'dired-marked
-  "The face used for marked major columns.")
-
-;; Operations
-(defvar-local tablist-operations-function nil
-  "A function for handling operations on the entries.
-
-The function is called with varying number of arguments, while
-the first one is always a symbol describing one of the following
-operations.
-
-`supported-operations'
-
-This is the only mandatory operation. There are no other
-arguments and the function should return a list of symbols of
-supported operations.
-
-`delete'
-
-The 2nd argument will be a list of entry ID's.  The function
-should somehow delete these entries and update
-`tabulated-list-entries'.
-
-`find-entry'
-
-The 2nd argument is the ID of an entry.  The function should
-somehow find/display this entry, i.e. a kind of default
-operation.
-
-`edit-column'
-
-The function is called with 3 further arguments: ID, INDEX and
-NEW-COLUMN, where ID represents the entry to edit, INDEX is the index
-of the column and NEW-COLUMN is the proposed new value for this
-column.  It should either
-
-i.  return a new edited complete entry and update
-`tabulated-list-entries', or
-
-ii. throw an error, if NEW-COLUMN is not a valid value for this
-column.
-
-`complete'
-
-The function is called with 4 further arguments: ID, INDEX,
-STRING and POS, where ID represents an entry, INDEX is the index
-of the column to complete, STRING it's current value and POS an
-offset of the current position of point into STRING.
-
-The function should return a collection for this column, suitable
-as argument for the function `completion-in-region'.")
-
-;; Differentiating columns
-(defvar-local tablist-major-columns nil
-  "Columns used to mark and when querying.")
-
-;; Filter
-(defvar-local tablist-current-filter nil)
-(defvar-local tablist-filter-suspended nil)
-(defvar tablist-named-filter nil)
-
-;; History variables
-(defvar tablist-column-name-history nil)
-
-;; Hooks
-(defvar tablist-selection-changed-functions nil
-  "A hook run when ever point moves to a different entry.")
-
-;; Context Window
-(defvar-local tablist-context-window nil)
-(defvar-local tablist-context-window-function nil)
-(defvar tablist-context-window-display-action
-  `((display-buffer-reuse-window
-     tablist-display-buffer-split-below-and-attach)
-    (window-height . 0.25)
-    (inhibit-same-window . t)))
-
-;;
-;; *Setup
-;;
-
-(defvar savehist-additional-variables)
-(add-hook 'savehist-save-hook
-          (lambda nil
-            (add-to-list 'savehist-additional-variables 'tablist-named-filter)))
-
-;;;###autoload
-(define-minor-mode tablist-minor-mode
-  nil nil nil nil
-  (unless (derived-mode-p 'tabulated-list-mode)
-    (error "Buffer is not in Tabulated List Mode"))
-  (tablist-init (not tablist-minor-mode)))
-
-;;;###autoload
-(define-derived-mode tablist-mode tabulated-list-mode "TL"
-  (tablist-init))
-
-(defun tablist-init (&optional disable)
-  (let ((cleaned-misc (cl-remove 'tablist-current-filter
-                                 mode-line-misc-info :key 'car)))
-    (cond
-     ((not disable)
-      (set (make-local-variable 'mode-line-misc-info)
-           (append
-            (list
-             (list 'tablist-current-filter
-                   '(:eval (format " [%s]"
-                                   (if tablist-filter-suspended
-                                       "suspended"
-                                     "filtered")))))))
-      (add-hook 'post-command-hook
-                'tablist-selection-changed-handler nil t)
-      (add-hook 'tablist-selection-changed-functions
-                'tablist-context-window-update nil t))
-     (t
-      (setq mode-line-misc-info cleaned-misc)
-      (remove-hook 'post-command-hook
-                   'tablist-selection-changed-handler t)
-      (remove-hook 'tablist-selection-changed-functions
-                   'tablist-context-window-update t)))))
-
-(defun tablist-quit ()
-  (interactive)
-  (tablist-hide-context-window)
-  (quit-window))
-
-(defvar-local tablist-selected-id nil)
-(defvar tablist-edit-column-minor-mode)
-
-(defun tablist-selection-changed-handler ()
-  (unless tablist-edit-column-minor-mode
-    (let ((id tablist-selected-id)
-          (selected (tabulated-list-get-id)))
-      (unless (eq selected id)
-        (setq tablist-selected-id selected)
-        (run-hook-with-args
-         'tablist-selection-changed-functions
-         tablist-selected-id)))))
-
-(defvar tablist-context-window-update--timer nil)
-
-(defun tablist-context-window-update (&optional id)
-  (when (and tablist-context-window-function
-             (window-live-p tablist-context-window)
-             (not tablist-edit-column-minor-mode))
-    (unless id
-      (setq id (tabulated-list-get-id)))
-    (when (timerp tablist-context-window-update--timer)
-      (cancel-timer tablist-context-window-update--timer))
-    (setq tablist-context-window-update--timer
-          (run-with-idle-timer 0.1 nil
-                               (lambda (fn window)
-                                 (when (window-live-p window)
-                                   (with-selected-window window
-                                     (set-window-dedicated-p nil nil)
-                                     (save-selected-window
-                                       (funcall fn id))
-                                     (when (window-live-p (selected-window))
-                                       (set-window-dedicated-p nil t)))))
-                               tablist-context-window-function
-                               tablist-context-window))))
-
-(defun tablist-display-context-window ()
-  (interactive)
-  (unless tablist-context-window-function
-    (error "No function for handling a context is defined"))
-  (unless (window-live-p tablist-context-window)
-    (setq tablist-context-window
-          (display-buffer
-           (current-buffer)
-           tablist-context-window-display-action)))
-  (prog1
-      tablist-context-window
-    (tablist-context-window-update)))
-
-(defun tablist-hide-context-window ()
-  (interactive)
-  (when (window-live-p tablist-context-window)
-    (let ((ignore-window-parameters t))
-      (delete-window tablist-context-window)))
-  (setq tablist-context-window nil))
-
-(defun tablist-toggle-context-window ()
-  (interactive)
-  (if (window-live-p tablist-context-window)
-      (tablist-hide-context-window)
-    (tablist-display-context-window)))
-
-;;
-;; *Marking
-;;
-
-(defun tablist-revert ()
-  "Revert the list with marks preserved, position kept."
-  (interactive)
-  (tablist-save-marks
-   (tablist-with-remembering-entry
-     (tabulated-list-revert))))
-
-(defun tablist-major-columns ()
-  (if (null tablist-major-columns)
-      (number-sequence 0 (1- (length tabulated-list-format)))
-    (if (numberp tablist-major-columns)
-        (list tablist-major-columns)
-      tablist-major-columns)))
-
-(defun tablist-put-mark (&optional pos)
-  "Put a mark before the entry at POS.
-
-POS defaults to point. Use `tablist-marker-char',
-`tablist-marker-face', `tablist-marked-face' and
-`tablist-major-columns' to determine how to mark and what to put
-a face on."
-  (when (or (null tabulated-list-padding)
-            (< tabulated-list-padding 1))
-    (setq tabulated-list-padding 1)
-    (tabulated-list-revert))
-  (save-excursion
-    (and pos (goto-char pos))
-    (unless (tabulated-list-get-id)
-      (error "No entry at this position"))
-    (let ((inhibit-read-only t))
-      (tabulated-list-put-tag
-       (string tablist-marker-char))
-      (put-text-property
-       (point-at-bol)
-       (1+ (point-at-bol))
-       'face tablist-marker-face)
-      (let ((columns (tablist-column-offsets)))
-        (dolist (c (tablist-major-columns))
-          (when (and (>= c 0)
-                     (< c (length columns)))
-            (let ((beg (+ (point-at-bol)
-                          (nth c columns)))
-                  (end (if (= c (1- (length columns)))
-                           (point-at-eol)
-                         (+ (point-at-bol)
-                            (nth (1+ c) columns)))))
-              (cond
-               ((and tablist-marked-face
-                     (not (eq tablist-marker-char ?\s)))
-                (tablist--save-face-property beg end)
-                (put-text-property
-                 beg end 'face tablist-marked-face))
-               (t (tablist--restore-face-property beg end))))))))))
-
-(defun tablist-mark-forward (&optional arg interactive)
-  "Mark ARG entries forward.
-
-ARG is interpreted as a prefix-arg.  If interactive is non-nil,
-maybe use the active region instead of ARG.
-
-See `tablist-put-mark' for how entries are marked."
-  (interactive (list current-prefix-arg t))
-  (cond
-   ;; Mark files in the active region.
-   ((and interactive (use-region-p))
-    (save-excursion
-      (goto-char (region-beginning))
-      (beginning-of-line)
-      (tablist-repeat-over-lines
-       (1+ (count-lines
-            (point)
-            (save-excursion
-              (goto-char (region-end))
-              (beginning-of-line)
-              (point))))
-       'tablist-put-mark)))
-   ;; Mark the current (or next ARG) files.
-   (t
-    (tablist-repeat-over-lines
-     (prefix-numeric-value arg)
-     'tablist-put-mark))))
-
-(defun tablist-mark-backward (&optional arg interactive)
-  "Mark ARG entries backward.
-
-See `tablist-mark-forward'."
-  (interactive (list current-prefix-arg t))
-  (tablist-mark-forward (- (prefix-numeric-value arg))
-                        interactive))
-
-(defun tablist-unmark-forward (&optional arg interactive)
-  "Unmark ARG entries forward.
-
-See `tablist-mark-forward'."
-  (interactive (list current-prefix-arg t))
-  (let ((tablist-marker-char ?\s)
-        tablist-marked-face)
-    (tablist-mark-forward arg interactive)))
-
-(defun tablist-unmark-backward (&optional arg interactive)
-  "Unmark ARG entries backward.
-
-See `tablist-mark-forward'."
-  (interactive (list current-prefix-arg t))
-  (let ((tablist-marker-char ?\s)
-        tablist-marked-face)
-    (tablist-mark-backward arg interactive)))
-
-(defun tablist-flag-forward (&optional arg interactive)
-  "Flag ARG entries forward.
-
-See `tablist-mark-forward'."
-  (interactive (list current-prefix-arg t))
-  (let ((tablist-marker-char ?D)
-        (tablist-marked-face 'dired-flagged))
-    (tablist-mark-forward arg interactive)))
-
-(defun tablist-change-marks (old new)
-  "Change all OLD marks to NEW marks.
-
-OLD and NEW are both characters used to mark files."
-  (interactive
-   (let* ((cursor-in-echo-area t)
-          (old (progn (message "Change (old mark): ") (read-char)))
-          (new (progn (message  "Change %c marks to (new mark): " old)
-                      (read-char))))
-     (list old new)))
-  (when (eq new ?\n)
-    (error "Mark character \\n is not allowed"))
-  (let ((default-mark-p (equal tablist-marker-char new))
-        (tablist-marker-char old))
-    (save-excursion
-      (tablist-map-over-marks
-       (lambda nil
-         (pcase new
-           (?D
-            (tablist-flag-forward 1))
-           (_
-            (let ((tablist-marker-char new)
-                  (tablist-marked-face
-                   (and default-mark-p
-                        tablist-marked-face)))
-              (tablist-put-mark)))))))))
-
-(defun tablist-unmark-all-marks (&optional marks interactive)
-  "Remove alls marks in MARKS.
-
-MARKS should be a string of mark characters to match and defaults
-to all marks.  Interactively, remove all marks, unless a prefix
-arg was given, in which case ask about which ones to remove.
-Give a message, if interactive is non-nil.
-
-Returns the number of unmarked marks."
-  (interactive
-   (list (if current-prefix-arg
-             (read-string "Remove marks: ")) t))
-  (let ((re (if marks
-                (tablist-marker-regexp marks)
-              "^[^ ]"))
-        (removed 0))
-    (save-excursion
-      (goto-char (point-min))
-      (while (re-search-forward re nil t)
-        (let ((tablist-marker-char ?\s)
-              tablist-marker-face
-              tablist-marked-face)
-          (tablist-put-mark))
-        (cl-incf removed)))
-    (when interactive
-      (message "Removed %d marks" removed))
-    removed))
-
-(defun tablist-toggle-marks ()
-  "Unmark all marked and mark all unmarked entries.
-
-See `tablist-put-mark'."
-  (interactive)
-  (let ((marked-re (tablist-marker-regexp))
-        (not-marked-re
-         (let ((tablist-marker-char ?\s))
-           (tablist-marker-regexp))))
-    (save-excursion
-      (goto-char (point-min))
-      (tablist-skip-invisible-entries)
-      (while (not (eobp))
-        (cond
-         ((looking-at marked-re)
-          (save-excursion (tablist-unmark-backward -1)))
-         ((looking-at not-marked-re)
-          (tablist-put-mark)))
-        (tablist-forward-entry)))
-    (tablist-move-to-major-column)))
-
-(defun tablist-get-marked-items (&optional arg distinguish-one-marked)
-  "Return marked or ARG entries."
-  (let ((items (save-excursion
-                 (tablist-map-over-marks
-                  (lambda () (cons (tabulated-list-get-id)
-                                   (tabulated-list-get-entry)))
-                  arg nil distinguish-one-marked))))
-    (if (and distinguish-one-marked
-             (eq (car items) t))
-        items
-      (nreverse items))))
-
-(defun tablist-mark-items-regexp (column-name regexp)
-  "Mark entries matching REGEXP in column COLUMN-NAME."
-  (interactive
-   (tablist-read-regexp-filter "Mark" current-prefix-arg ))
-  (tablist-map-with-filter
-   'tablist-put-mark
-   `(=~  ,column-name ,regexp)))
-
-(defun tablist-mark-items-numeric (binop column-name operand)
-  "Mark items fulfilling BINOP with arg OPERAND in column COLUMN-NAME.
-
-First the column's value is coerced to a number N.  Then the test
-proceeds as \(BINOP N OPERAND\)."
-  (interactive
-   (tablist-read-numeric-filter "Mark" current-prefix-arg))
-  (tablist-map-with-filter
-   'tablist-put-mark
-   `(,binop ,column-name ,operand)))
-
-(defun tablist-map-over-marks (fn &optional arg show-progress
-                                  distinguish-one-marked)
-  (prog1
-      (cond
-       ((and arg (integerp arg))
-        (let (results)
-          (tablist-repeat-over-lines
-           arg
-           (lambda ()
-             (if show-progress (sit-for 0))
-             (push (funcall fn) results)))
-          (if (< arg 0)
-              (nreverse results)
-            results)))
-       (arg
-        ;; non-nil, non-integer ARG means use current item:
-        (tablist-skip-invisible-entries)
-        (unless (eobp)
-          (list (funcall fn))))
-       (t
-        (cl-labels ((search (re)
-                            (let (sucess)
-                              (tablist-skip-invisible-entries)
-                              (while (and (setq sucess
-                                                (re-search-forward re nil t))
-                                          (invisible-p (point)))
-                                (tablist-forward-entry))
-                              sucess)))
-          (let ((regexp (tablist-marker-regexp))
-                next-position results found)
-            (save-excursion
-              (goto-char (point-min))
-              ;; remember position of next marked file before BODY
-              ;; can insert lines before the just found file,
-              ;; confusing us by finding the same marked file again
-              ;; and again and...
-              (setq next-position (and (search regexp)
-                                       (point-marker))
-                    found (not (null next-position)))
-              (while next-position
-                (goto-char next-position)
-                (if show-progress (sit-for 0))
-                (push (funcall fn) results)
-                ;; move after last match
-                (goto-char next-position)
-                (forward-line 1)
-                (set-marker next-position nil)
-                (setq next-position (and (search regexp)
-                                         (point-marker)))))
-            (if (and distinguish-one-marked (= (length results) 1))
-                (setq results (cons t results)))
-            (if found
-                results
-              (unless (or (eobp) (invisible-p (point)))
-                (list (funcall fn))))))))
-    (tablist-move-to-major-column)))
-
-(defun tablist-marker-regexp (&optional marks)
-  "Return a regexp matching marks in MARKS.
-
-MARKS should be a string of mark characters to match and defaults
-to the current value of `tablist-marker-char' as a string."
-  (concat (format "^[%s]"
-                  (or marks (string tablist-marker-char)))))
-
-(defun tablist-get-mark-state ()
-  "Return the mark state of the entry at point."
-  (save-excursion
-    (beginning-of-line)
-    (when (looking-at "^\\([^ ]\\)")
-      (let ((mark (buffer-substring
-                   (match-beginning 1)
-                   (match-end 1))))
-        (tablist-move-to-major-column)
-        (list (aref mark 0)
-              (get-text-property 0 'face mark)
-              (get-text-property (point) 'face))))))
-
-(defun tablist-put-mark-state (state)
-  "Set the mark of the entry at point according to STATE.
-
-STATE is a return value of `tablist-get-mark-state'."
-  (cl-destructuring-bind (tablist-marker-char
-                          tablist-marker-face
-                          tablist-marked-face)
-      state
-    (tablist-put-mark)))
-
-(defun tablist-mark-prompt (arg items)
-  "Return a string suitable for use in a tablist prompt."
-  ;; distinguish-one-marked can cause the first element to be just t.
-  (if (eq (car items) t) (setq items (cdr items)))
-  (let ((count (length items)))
-    (if (= count 1)
-        (car items)
-      ;; more than 1 item:
-      (if (integerp arg)
-          ;; abs(arg) = count
-          ;; Perhaps this is nicer, but it also takes more screen space:
-          ;;(format "[%s %d items]" (if (> arg 0) "next" "previous")
-          ;;                        count)
-          (format "[next %d item%s]"
-                  arg (dired-plural-s arg))
-        (format "%c [%d item%s]" dired-marker-char count
-                (dired-plural-s count))))))
-
-;;
-;; *Movement
-;;
-
-(defun tablist-forward-entry (&optional n)
-  "Move past the next N unfiltered entries."
-  (unless n (setq n 1))
-  (while (and (> n 0)
-              (not (eobp)))
-    (forward-line)
-    (when (invisible-p (point))
-      (tablist-skip-invisible-entries))
-    (cl-decf n))
-  (while (and (< n 0)
-              (not (bobp)))
-    (forward-line -1)
-    (when (invisible-p (point))
-      (tablist-skip-invisible-entries t))
-    (cl-incf n))
-  n)
-
-(defun tablist-next-line (&optional n)
-  (interactive "p")
-  (when (and (< n 0)
-             (save-excursion
-               (end-of-line 0)
-               (tablist-skip-invisible-entries t)
-               (bobp)))
-    (signal 'beginning-of-buffer nil))
-  (when (and (> n 0)
-             (save-excursion
-               (tablist-forward-entry)
-               (eobp)))
-    (signal 'end-of-buffer nil))
-
-  (let ((col (tablist-current-column)))
-    (tablist-forward-entry (or n 1))
-    (if col
-        (tablist-move-to-column col)
-      (tablist-move-to-major-column))))
-
-(defun tablist-previous-line (&optional n)
-  (interactive "p")
-  (tablist-next-line (- (or n 1))))
-
-(defun tablist-repeat-over-lines (arg function)
-  "Call FUNCTION for the next ARG entries."
-  ;; Move out of potentially invisble area.
-  (tablist-skip-invisible-entries)
-  (let ((pos (make-marker)))
-    (while (and (> arg 0)
-                (not (eobp)))
-      (cl-decf arg)
-      (save-excursion
-        (tablist-forward-entry)
-        (move-marker pos (1+ (point))))
-      (unless (eobp)
-        (save-excursion (funcall function)))
-      ;; Advance to the next line--actually, to the line that *was* next.
-      ;; (If FUNCTION inserted some new lines in between, skip them.)
-      (goto-char pos))
-    (while (and (< arg 0) (not (bobp)))
-      (cl-incf arg)
-      (tablist-forward-entry -1)
-      (save-excursion (funcall function)))
-    (move-marker pos nil)
-    (tablist-move-to-major-column)))
-
-(defun tablist-move-to-column (n)
-  "Move to the N'th list column."
-  (interactive "p")
-  (when (tabulated-list-get-id)
-    (let ((columns (tablist-column-offsets)))
-      (when (or (< n 0)
-                (>= n (length columns)))
-        (error "No such column: %s" n))
-      (beginning-of-line)
-      (forward-char (nth n columns))
-      (when (and (plist-get (nthcdr 3 (elt tabulated-list-format n))
-                            :right-align)
-                 (not (= n (1- (length columns)))))
-        (forward-char (1- (car (cdr (elt tabulated-list-format n)))))))))
-
-(defun tablist-move-to-major-column (&optional first-skip-invisible-p)
-  "Move to the first major column."
-  (interactive (list t))
-  (when first-skip-invisible-p
-    (tablist-skip-invisible-entries))
-  (tablist-move-to-column (car (tablist-major-columns))))
-
-(defun tablist-forward-column (n)
-  "Move n columns forward, while wrapping around."
-  (interactive "p")
-  (unless (tabulated-list-get-id)
-    (error "No entry on this line"))
-  (let* ((columns (tablist-column-offsets))
-         (current (1- (length columns))))
-    ;; find current column
-    (while (and (>= current 0)
-                (> (nth current columns)
-                   (current-column)))
-      (cl-decf current))
-    ;; there may be an invisible spec here
-    (when (bolp)
-      (forward-char))
-    ;; before any columns
-    (when (< current 0)
-      (goto-char (+ (point-at-bol) (if (> n 0)
-                                       (car columns)
-                                     (car (last columns)))))
-      (setq n (* (cl-signum n) (1- (abs n)))))
-    (when (/= n 0)
-      (tablist-move-to-column
-       (mod (+ current n) (length columns))))))
-
-(defun tablist-backward-column (n)
-  "Move n columns backward, while wrapping around."
-  (interactive "p")
-  (tablist-forward-column (- n)))
-
-;;
-(defun tablist-skip-invisible-entries (&optional backward)
-  "Skip invisible entries BACKWARD or forward.
-
-Do nothing, if the entry at point is visible.  Otherwise move to
-the beginning of the next visible entry in the direction
-determined by BACKWARD.
-
-Return t, if point is now in a visible area."
-
-  (cond
-   ((and backward
-         (not (bobp))
-         (get-text-property (point) 'invisible))
-    (when (get-text-property (1- (point)) 'invisible)
-      (goto-char (previous-single-property-change
-                  (point)
-                  'invisible nil (point-min))))
-    (forward-line -1))
-   ((and (not backward)
-         (not (eobp))
-         (get-text-property (point) 'invisible))
-    (goto-char (next-single-property-change
-                (point)
-                'invisible nil (point-max)))))
-  (not (invisible-p (point))))
-
-;;
-;; *Operations
-;;
-
-(defun tablist-yes-or-no-p (operation arg items)
-  "Query the user whether to proceed with some operation.
-
-Operation should be a symbol or string describing the operation,
-ARG the prefix-arg of the command used in
-`tablist-get-marked-items' or elsewhere, to get the ITEMS."
-
-  (let ((pp-items (mapcar 'tablist-pretty-print-entry
-                          (mapcar 'cdr items)))
-        dired-no-confirm
-        (op-str (upcase-initials
-                 (if (stringp operation)
-                     operation
-                   (symbol-name operation)))))
-    (dired-mark-pop-up
-     (format " *%s*" op-str) nil
-     pp-items
-     dired-deletion-confirmer
-     (format "%s %s "
-             op-str
-             (tablist-mark-prompt arg pp-items)))))
-
-(defun tablist-operation-available-p (op)
-  (and (functionp tablist-operations-function)
-       (memq op (funcall tablist-operations-function
-                         'supported-operations))))
-
-(defun tablist-do-delete (&optional arg)
-  "Delete ARG entries."
-  (interactive "P")
-  (unless (tablist-operation-available-p 'delete)
-    (error "Deleting entries is not available in this buffer"))
-  (let ((items (tablist-get-marked-items arg)))
-    (when (tablist-yes-or-no-p 'delete arg items)
-      (tablist-do-kill-lines arg)
-      (funcall tablist-operations-function
-               'delete (mapcar 'car items))
-      (tablist-move-to-major-column))))
-
-(defun tablist-do-flagged-delete (&optional interactive)
-  "Delete all entries marked with a D."
-  (interactive "p")
-  (let* ((tablist-marker-char ?D))
-    (if (save-excursion
-          (goto-char (point-min))
-          (re-search-forward (tablist-marker-regexp) nil t))
-        (tablist-do-delete)
-      (or (not interactive)
-          (message "(No deletions requested)")))))
-
-(defun tablist-do-kill-lines (&optional arg interactive)
-  "Remove ARG lines from the display."
-  (interactive (list current-prefix-arg t))
-  (save-excursion
-    (let ((positions
-           (tablist-map-over-marks 'point arg))
-          (inhibit-read-only t))
-      (dolist (pos positions)
-        (goto-char pos)
-        (tabulated-list-delete-entry))
-      (when interactive
-        (message (format "Killed %d line%s"
-                         (length positions)
-                         (dired-plural-s (length positions))))))))
-
-(defun tablist-do-operation (arg fn operation &optional delete-p revert-p)
-  "Operate on marked items.
-
-ARG should be the `current-prefix-arg', FN is a function of two
-arguments \(ID ENTRY\) handling the operation.  It gets called
-repeatly with all marked items.  OPERATION is a symbol or string
-describing the operation, it is used for display.
-
-Optional non-nil DELETE-P means, remove the items from the display.
-Optional REVERT-P means, revert the display afterwards."
-  (let ((items (tablist-get-marked-items arg)))
-    (unless items
-      (error "No items marked"))
-    (when (tablist-yes-or-no-p operation arg items)
-      (when delete-p
-        (tablist-do-kill-lines arg))
-      (dolist (item items)
-        (funcall fn (car item)))
-      (when revert-p
-        (tablist-revert))
-      (tablist-move-to-major-column))))
-
-;;
-;; *Editing
-;;
-(defvar tablist-edit-column-minor-mode-map
-  (let ((kmap (make-sparse-keymap)))
-    (set-keymap-parent kmap (current-global-map))
-    (define-key kmap [remap self-insert-command] 'self-insert-command)
-    (define-key kmap "\r" 'tablist-edit-column-commit)
-    (define-key kmap (kbd "C-g") 'tablist-edit-column-quit)
-    (define-key kmap (kbd "C-c C-c") 'tablist-edit-column-commit)
-    (define-key kmap (kbd "C-c C-q") 'tablist-edit-column-quit)
-    (define-key kmap "\t" 'tablist-edit-column-complete)
-    (define-key kmap (kbd "TAB") 'tablist-edit-column-complete)
-    (define-key kmap [remap end-of-buffer] 'end-of-line)
-    (define-key kmap [remap beginning-of-buffer] 'beginning-of-line)
-    (define-key kmap [remap mark-whole-buffer] 'tablist-edit-column-mark-field)
-    kmap))
-
-(define-minor-mode tablist-edit-column-minor-mode
-  "" nil nil nil
-  (unless (or tablist-minor-mode
-              (derived-mode-p 'tablist-mode))
-    (error "Not in a tablist buffer"))
-  (cond
-   (tablist-edit-column-minor-mode
-    (add-to-list 'mode-line-misc-info
-                 '(tablist-edit-column-minor-mode "[edit]"))
-    (add-hook 'post-command-hook 'tablist-edit-column-constrain-point nil t)
-    (read-only-mode -1))
-   (t
-    (remove-hook 'post-command-hook 'tablist-edit-column-constrain-point t)
-    (read-only-mode 1))))
-
-(defun tablist-edit-column (&optional n)
-  (interactive "P")
-  (unless n (setq n (tablist-current-column)))
-  (tablist-assert-column-editable n)
-  (let* ((offsets (append (tablist-column-offsets)
-                          (list (- (point-at-eol)
-                                   (point-at-bol)))))
-         (beg (+ (point-at-bol)
-                 (nth n offsets)))
-         (end (+ (point-at-bol)
-                 (nth (1+ n) offsets)))
-         (entry (tabulated-list-get-entry beg))
-         (inhibit-read-only t)
-         (inhibit-field-text-motion t)
-         (alist `((entry . ,entry)
-                  (column . ,n)
-                  (id . ,(tabulated-list-get-id beg))))
-         ov)
-    (goto-char beg)
-    (delete-region beg end)
-    (add-text-properties
-     (point-at-bol) (point-at-eol)
-     '(read-only t field t))
-    (unless (= beg (point-at-bol))
-      (put-text-property (1- beg) beg 'rear-nonsticky t))
-    (save-excursion
-      ;; Keep one read-only space at the end for keeping text
-      ;; properties.
-      (insert
-       (propertize
-        (concat
-         (tablist-nth-entry n entry)
-         (propertize " "
-                     'display `(space :align-to ,(- end (point-at-bol)))))
-        'field nil
-        'front-sticky '(tablist-edit)
-        'rear-nonsticky '(read-only field)
-        'tablist-edit alist))
-      (setq end (point)))
-    (add-text-properties
-     (1- end) end '(read-only t field 'tablist-edit-end))
-    (setq ov (make-overlay beg end))
-    (overlay-put ov 'priority 9999)
-    (overlay-put ov 'face '(:background "deep sky blue" :foreground "white"))
-    (overlay-put ov 'evaporate t)
-    (overlay-put ov 'tablist-edit t)
-    (tablist-edit-column-minor-mode 1)))
-
-(defun tablist-edit-column-quit ()
-  (interactive)
-  (tablist-edit-column-commit t))
-
-(defun tablist-edit-column-commit (&optional abandon-edit)
-  (interactive (list current-prefix-arg))
-  (let ((inhibit-read-only t)
-        (inhibit-field-text-motion t)
-        bounds)
-    (condition-case nil
-        (setq bounds (tablist-edit-column-bounds))
-      (error
-       (tablist-edit-column-minor-mode -1)
-       (tabulated-list-revert)
-       (put-text-property (point-min) (point-max)
-                          'tablist-edit nil)
-       (error "Unable to complete the edit")))
-    (let* ((beg (car bounds))
-           (end (cdr bounds))
-           (alist (get-text-property beg 'tablist-edit))
-           (column (cdr (assq 'column alist)))
-           (id (cdr (assq 'id alist)))
-           (entry (cdr (assq 'entry alist)))
-           (item (buffer-substring-no-properties beg (1- end))))
-
-      (unless abandon-edit
-        ;; Throws an error, if item is invalid.
-        (setq entry (funcall tablist-operations-function
-                             'edit-column id column item)))
-      (tablist-edit-column-minor-mode -1)
-      (remove-overlays beg end 'tablist-edit t)
-      (put-text-property beg end 'tablist-edit nil)
-      (delete-region (point-at-bol) (1+ (point-at-eol)))
-      (save-excursion
-        (tabulated-list-print-entry id entry))
-      (forward-char (nth column (tablist-column-offsets))))))
-
-(defun tablist-edit-column-complete ()
-  (interactive)
-  (unless (tablist-operation-available-p 'complete)
-    (error "Completion not available"))
-  (cl-destructuring-bind (beg &rest end)
-      (tablist-edit-column-bounds t)
-    (let* ((string (buffer-substring-no-properties
-                    beg end))
-           (alist (get-text-property beg 'tablist-edit))
-           (completions (funcall tablist-operations-function
-                                 'complete
-                                 (cdr (assq 'id alist))
-                                 (cdr (assq 'column alist))
-                                 string
-                                 (- (point) beg))))
-      (unless completions
-        (error "No completions available"))
-      (completion-in-region beg end completions))))
-
-(defun tablist-column-editable (n)
-  (and (tablist-operation-available-p 'edit-column)
-       (not (tablist-column-property n :read-only))))
-
-(defun tablist-assert-column-editable (n)
-  (unless (and (>= n 0)
-               (< n (length tabulated-list-format)))
-    (error "Invalid column number: %s" n))
-  (unless (tablist-operation-available-p 'edit-column)
-    (error "Editing columns not enabled in this buffer"))
-  (when (tablist-column-property n :read-only)
-    (error "This column is read-only")))
-
-(defun tablist-edit-column-constrain-point ()
-  (unless tablist-edit-column-minor-mode
-    (error "Not editing a column"))
-  (unless (get-text-property (point) 'tablist-edit)
-    (let ((bounds (tablist-edit-column-bounds)))
-      (when bounds
-        (if (> (point) (cdr bounds))
-            (goto-char (1- (cdr bounds)))
-          (goto-char (car bounds)))
-        (point)))))
-
-(defun tablist-edit-column-bounds (&optional skip-final-space)
-  (unless tablist-edit-column-minor-mode
-    (error "Not editing a column"))
-  (let ((pos (next-single-property-change
-              (point) 'tablist-edit))
-        beg end)
-    (cond
-     ((null pos)
-      (setq end (previous-single-property-change
-                 (point-max) 'tablist-edit)
-            beg (previous-single-property-change
-                 end 'tablist-edit)))
-     ((get-text-property pos 'tablist-edit)
-      (setq beg pos
-            end (next-single-property-change
-                 pos 'tablist-edit)))
-     (pos
-      (setq end pos
-            beg (previous-single-property-change
-                 pos 'tablist-edit))))
-
-    (unless (and beg end (get-text-property beg 'tablist-edit))
-      (error "Unable to locate edited text"))
-    (cons beg (if skip-final-space (1- end) end))))
-
-(defun tablist-edit-column-mark-field ()
-  (interactive)
-  (push-mark (field-beginning))
-  (push-mark (field-end) nil t)
-  (goto-char (field-beginning)))
-
-(defun tablist-find-entry (&optional id)
-  (interactive)
-  (unless (tablist-operation-available-p 'find-entry)
-    (error "Finding entries not supported in this buffer"))
-  (funcall tablist-operations-function
-           'find-entry
-           (or id (tabulated-list-get-id))))
-
-;;
-;; *Utility
-;;
-
-(defun tablist-column-property (n prop)
-  (plist-get
-   (nthcdr 3 (aref tabulated-list-format n))
-   prop))
-
-(defun tablist-current-column ()
-  "Return the column number at point.
-
-Returns nil, if point is before the first column."
-  (let ((column
-         (1- (cl-position
-              (current-column)
-              (append (tablist-column-offsets)
-                      (list most-positive-fixnum))
-              :test (lambda (column offset) (> offset column))))))
-    (when (>= column 0)
-      column)))
-
-(defun tablist-column-offsets ()
-  "Return a list of column positions.
-
-This is a list of offsets from the beginning of the line."
-  (let ((cc tabulated-list-padding)
-        columns)
-    (dotimes (i (length tabulated-list-format))
-      (let* ((c (aref tabulated-list-format i))
-             (len (nth 1 c))
-             (pad (or (plist-get (nthcdr 3 c) :pad-right)
-                      1)))
-        (push cc columns)
-        (when (numberp len)
-          (cl-incf cc len))
-        (when pad
-          (cl-incf cc pad))))
-    (nreverse columns)))
-
-(defun tablist-pretty-print-entry (item)
-  (mapconcat (lambda (i)
-               (tablist-nth-entry i item))
-             (tablist-major-columns) " "))
-
-(defun tablist--save-face-property (beg end)
-  ;; We need to distinguish ,,not set'' from ''no face''.
-  (unless (and (text-property-not-all beg end 'face nil)
-               (< beg end))
-    (put-text-property beg (1+ beg) 'face 'default))
-  (unless (text-property-not-all beg end 'tablist-saved-face nil)
-    (tablist-copy-text-property beg end 'face 'tablist-saved-face)))
-
-(defun tablist--restore-face-property (beg end)
-  (when (text-property-not-all beg end 'tablist-saved-face nil)
-    (tablist-copy-text-property beg end 'tablist-saved-face 'face)))
-
-(defun tablist-copy-text-property (beg end from to)
-  "Copy text property FROM to TO in region BEG to END."
-  (let ((inhibit-read-only t))
-    (save-excursion
-      (while (< beg end)
-        (goto-char beg)
-        (put-text-property
-         (point)
-         (setq beg (next-single-property-change
-                    (point) from nil end))
-         to
-         (get-text-property (point) from))))))
-
-;;
-(defun tablist-read-column-name (arg &optional prompt default)
-  "Read the name of a column using ARG.
-
-If ARG is a number, return column ARG.
-If ARG is nil, return DEFAULT or the current column.
-Else ask the user, using PROMPT and DEFAULT."
-  (cond
-   ((numberp arg)
-    (or (tablist-column-name
-         (prefix-numeric-value arg))
-        (error "No such column: %d" (prefix-numeric-value arg))))
-   ((null arg)
-    (or default
-        (tablist-column-name
-         (or (tablist-current-column)
-             (car (tablist-major-columns))
-             0))))
-   (t
-    (let* ((default (or default
-                        (tablist-column-name
-                         (car (tablist-major-columns)))))
-           (result
-            (completing-read
-             (format "%s %s: "
-                     (or prompt "Use column")
-                     (if default
-                         (format "(default %s)"
-                                 default)
-                       ""))
-             (tablist-column-names)
-             nil t nil 'tablist-column-name-history)))
-      (if (> (length result) 0)
-          result
-        (if (not default)
-            (error "No column selected")
-          default))))))
-
-(defun tablist-column-name (n)
-  "Return the name of column N."
-  (when (and n
-             (>= n 0)
-             (< n (length tabulated-list-format)))
-    (substring-no-properties
-     (car (elt tabulated-list-format n)) 0)))
-
-(defun tablist-column-names ()
-  "Return a list of all column-names."
-  (mapcar 'tablist-column-name
-          (number-sequence 0 (1- (length tabulated-list-format)))))
-
-(defun tablist-nth-entry (n &optional entry)
-  (unless entry (setq entry (tabulated-list-get-entry)))
-  (when (and entry
-             (>= n 0)
-             (< n (length entry)))
-    (let ((str (elt entry n)))
-      (if (stringp str)
-          str
-        (car str)))))
-
-(defun tablist-major-column-name ()
-  "Return a list of the major column names."
-  (tablist-column-name (car (tablist-major-columns))))
-
-(defun tablist-export-csv (&optional separator always-quote-p
-                                     invisible-p out-buffer display-p)
-  "Export a tabulated list to a CSV format.
-
-Use SEPARATOR (or ;) and quote if necessary (or always if
-ALWAYS-QUOTE-P is non-nil).  Only consider non-filtered entries,
-unless invisible-p is non-nil.  Create a buffer for the output or
-insert it after point in OUT-BUFFER.  Finally if DISPLAY-P is
-non-nil, display this buffer.
-
-Return the output buffer."
-
-  (interactive (list nil t nil nil t))
-  (unless (derived-mode-p 'tabulated-list-mode)
-    (error "Not in Tabulated List Mode"))
-  (unless (stringp separator)
-    (setq separator (string (or separator ?\;))))
-  (let* ((outb (or out-buffer
-                   (get-buffer-create
-                    (format "%s.csv" (buffer-name)))))
-         (escape-re (format "[%s\"\n]" separator))
-         (header (tablist-column-names)))
-    (unless (buffer-live-p outb)
-      (error "Expected a live buffer: %s" outb))
-    (cl-labels
-        ((printit (entry)
-                  (insert
-                   (mapconcat
-                    (lambda (e)
-                      (unless (stringp e)
-                        (setq e (car e)))
-                      (if (or always-quote-p
-                              (string-match escape-re e))
-                          (concat "\""
-                                  (replace-regexp-in-string "\"" "\"\"" e t t)
-                                  "\"")
-                        e))
-                    entry separator))
-                  (insert ?\n)))
-      (with-current-buffer outb
-        (let ((inhibit-read-only t))
-          (erase-buffer)
-          (printit header)))
-      (save-excursion
-        (goto-char (point-min))
-        (unless invisible-p
-          (tablist-skip-invisible-entries))
-        (while (not (eobp))
-          (let* ((entry (tabulated-list-get-entry)))
-            (with-current-buffer outb
-              (let ((inhibit-read-only t))
-                (printit entry)))
-            (if invisible-p
-                (forward-line)
-              (tablist-forward-entry)))))
-      (if display-p
-          (display-buffer outb))
-      outb)))
-
-;;
-
-(defun tablist-enlarge-column (&optional column width)
-  "Enlarge column COLUMN by WIDTH.
-
-This function is lazy and therfore pretty slow."
-  (interactive
-   (list nil (* (prefix-numeric-value current-prefix-arg)
-                3)))
-  (unless column (setq column (tablist-current-column)))
-  (unless column
-    (error "No column given and no entry at point"))
-  (unless width (setq width 1))
-  (when (or (not (numberp column))
-            (< column 0)
-            (>= column (length tabulated-list-format)))
-    (error "No such column: %d" column))
-  (when (= column (1- (length tabulated-list-format)))
-    (error "Can't resize last column"))
-
-  (let* ((cur-width (cadr (elt tabulated-list-format column))))
-    (setcar (cdr (elt tabulated-list-format column))
-            (max 3 (+ cur-width width)))
-    (tablist-with-remembering-entry
-      (tablist-save-marks
-       (tabulated-list-init-header)
-       (tabulated-list-print)))))
-
-(defun tablist-shrink-column (&optional column width)
-  (interactive
-   (list nil (* (prefix-numeric-value current-prefix-arg)
-                3)))
-  (tablist-enlarge-column column (- (or width 1))))
-
-;; *Sorting
-;;
-
-(defun tablist-sort (&optional column)
-  "Sort the tabulated-list by COLUMN.
-
-COLUMN may be either a name or an index.  The default compare
-function is given by the `tabulated-list-format', which see.
-
-This function saves the current sort column and the inverse
-sort-direction in the variable `tabulated-list-sort-key', which
-also determines the default COLUMN and direction.
-
-The main difference to `tabulated-list-sort' is, that this
-function sorts the buffer in-place and it ignores a nil sort
-entry in `tabulated-list-format' and sorts on the column
-anyway (why not ?)."
-
-  (interactive
-   (list
-    (if (null current-prefix-arg)
-        (tablist-column-name
-         (or (tablist-current-column)
-             (car (tablist-major-columns))
-             0))
-      (tablist-read-column-name
-       '(4) "Sort by column"
-       (tablist-column-name (car (tablist-major-columns)))))))
-
-  (unless column
-    (setq column (or (car tabulated-list-sort-key)
-                     (tablist-column-name (car (tablist-major-columns)))
-                     (tablist-column-name 0))))
-  (when (numberp column)
-    (let ((column-name (tablist-column-name column)))
-      (unless column-name
-        (error "No such column: %d" column))
-      (setq column column-name)))
-
-  (setq tabulated-list-sort-key
-        (cons column
-              (if (equal column (car tabulated-list-sort-key))
-                  (cdr tabulated-list-sort-key))))
-
-  (let* ((entries (if (functionp tabulated-list-entries)
-                      (funcall tabulated-list-entries)
-                    tabulated-list-entries))
-         (reverse (cdr tabulated-list-sort-key))
-         (n (tabulated-list--column-number ;;errors if column is n/a
-             (car tabulated-list-sort-key)))
-         (compare-fn (nth 2 (aref tabulated-list-format n))))
-
-    (when (or (null compare-fn)
-              (eq compare-fn t))
-      (setq compare-fn
-            (lambda (a b)
-              (setq a (aref (cadr a) n))
-              (setq b (aref (cadr b) n))
-              (string< (if (stringp a) a (car a))
-                       (if (stringp b) b (car b))))))
-
-    (unless compare-fn
-      (error "This column cannot be sorted: %s" column))
-
-    (setcdr tabulated-list-sort-key (not reverse))
-    ;; Presort the entries and hash the result and sort the buffer.
-    (setq entries (sort (copy-sequence entries) compare-fn))
-    (let ((hash (make-hash-table :test 'equal)))
-      (dotimes (i (length entries))
-        (puthash (caar entries) i hash)
-        (setq entries (cdr entries)))
-      (tablist-with-remembering-entry
-        (goto-char (point-min))
-        (tablist-skip-invisible-entries)
-        (let ((inhibit-read-only t))
-          (sort-subr
-           nil 'tablist-forward-entry 'end-of-line
-           (lambda ()
-             (gethash (tabulated-list-get-id) hash 0))
-           nil (if reverse '< '>))))
-      (tablist-move-to-column n)
-      ;; Make the sort arrows display.
-      (tabulated-list-init-header))))
-
-;;
-;; *Filter
-;;
-
-(defun tablist-read-filter-name (prompt)
-  (let ((filter (cdr (assq major-mode tablist-named-filter))))
-    (unless filter
-      (error "No filter defined for %s mode" mode-name))
-    (let ((name (completing-read
-                 (format "%s: " prompt)
-                 filter
-                 nil t)))
-      (unless (> (length name) 0)
-        (error "No filter selected"))
-      name)))
-
-(defun tablist-apply-filter (&optional filter)
-  "Apply FILTER to the current tabulated list.
-
-FILTER defaults to `tablist-current-filter'."
-  (unless filter (setq filter tablist-current-filter))
-  (tablist-filter-unhide-buffer)
-  (when (and filter
-             (null tablist-filter-suspended))
-    (tablist-with-remembering-entry
-      (tablist-map-with-filter
-       (lambda nil
-         (if tablist-umark-filtered-entries
-             (save-excursion (tablist-unmark-forward)))
-         (tablist-filter-hide-entry))
-       (tablist-filter-negate filter))))
-  (force-mode-line-update))
-
-(defadvice tabulated-list-print (after tabulated-list activate)
-  "Reapply the filter."
-  (when (or tablist-minor-mode
-            (derived-mode-p 'tablist-mode))
-    (tablist-apply-filter)))
-
-(defun tablist-eval-filter (filter)
-  (tablist-filter-eval
-   filter
-   (tabulated-list-get-id)
-   (tabulated-list-get-entry)
-   (cdr (assq major-mode tablist-named-filter))))
-
-(defun tablist-map-with-filter (fn filter &optional show-progress
-                                   distinguish-one-marked)
-  "Call FN for every unfiltered entry matching FILTER."
-  (prog1
-      (cl-labels ((search ()
-                          (tablist-skip-invisible-entries)
-                          (while (and (not (eobp))
-                                      (not (tablist-eval-filter filter)))
-                            (tablist-forward-entry))
-                          (unless (eobp)
-                            (point-marker))))
-        (let (next-position results)
-          (save-excursion
-            (goto-char (point-min))
-            (setq next-position (search))
-            (while next-position
-              (goto-char next-position)
-              (if show-progress (sit-for 0))
-              (push (funcall fn) results)
-              ;; move after last match
-              (goto-char next-position)
-              (forward-line 1)
-              (set-marker next-position nil)
-              (setq next-position (search)))
-            (if (and distinguish-one-marked (= (length results) 1))
-                (setq results (cons t results))))))))
-
-;;
-;; **Filter Commands
-;;
-(defun tablist-push-filter (filter &optional interactive or-p)
-  (setq tablist-current-filter
-        (tablist-filter-push
-         tablist-current-filter
-         filter or-p))
-  (tablist-apply-filter)
-  (when interactive
-    (tablist-display-filter-temporarily)))
-
-(defun tablist-pop-filter (&optional n interactive)
-  "Remove the first N filter components."
-  (interactive (list (prefix-numeric-value current-prefix-arg) t))
-  (while (and tablist-current-filter
-              (> n 0))
-    (setq tablist-current-filter
-          (tablist-filter-pop
-           tablist-current-filter))
-    (cl-decf n))
-  (tablist-apply-filter)
-  (when interactive
-    (when (> n 0)
-      (message "The filter is empty."))
-    (tablist-display-filter-temporarily))
-  n)
-
-(defun tablist-negate-filter (&optional interactive)
-  "Negate the current filter."
-  (interactive (list t))
-  (setq tablist-current-filter
-        (tablist-filter-negate
-         tablist-current-filter))
-  (tablist-apply-filter)
-  (when interactive
-    (tablist-display-filter-temporarily)))
-
-(defun tablist-toggle-first-filter-logic ()
-  "Toggle between and/or for the first filter operand."
-  (interactive)
-  (setq tablist-current-filter
-        (pcase tablist-current-filter
-          (`(or ,x1 ,x2)
-           `(and ,x1 ,x2))
-          (`(and ,x1 ,x2)
-           `(or ,x1 ,x2))
-          (`(not ,x) x)
-          (x `(not ,x))))
-  (tablist-apply-filter)
-  (tablist-display-filter-temporarily))
-
-(defun tablist-suspend-filter (&optional flag)
-  "Temporarily disable filtering according to FLAG.
-
-Interactively, this command toggles filtering."
-  (interactive
-   (list (not tablist-filter-suspended)))
-  (let ((state tablist-filter-suspended))
-    (unless (eq (not (not state))
-                (not (not flag)))
-      (set (make-local-variable 'tablist-filter-suspended) flag)
-      (tablist-apply-filter))))
-
-(defun tablist-read-regexp-filter (operation arg)
-  (let ((column-name (tablist-read-column-name arg)))
-    (list
-     column-name
-     (let ((re
-            (read-regexp (format "%s where %s matches: " operation column-name))))
-       (unless (> (length re) 0)
-         (error "No regexp given"))
-       re))))
-
-(defun tablist-read-equal-filter (operation arg)
-  (let ((column-name (tablist-read-column-name arg)))
-    (list
-     column-name
-     (read-string (format "%s where %s equals: " operation column-name)))))
-
-(defun tablist-read-numeric-filter (operation arg)
-  (let* ((entry (tabulated-list-get-entry 1))
-         (default (cl-some
-                   (lambda (idx)
-                     (let ((value (tablist-nth-entry idx entry)))
-                       (when (or (not (eq 0 (string-to-number value)))
-                                 (equal "0" value))
-                         (tablist-column-name idx))))
-                   (number-sequence 0 (length entry))))
-         (column-name (tablist-read-column-name arg nil default))
-         (op (completing-read
-              (format "%s %s matching binary op: " operation column-name)
-              '("=" "<" ">" "<=" ">=") nil t))
-         oper)
-
-    (when (equal "" op)
-      (error "No operation selected"))
-    (setq op (intern op))
-    (setq oper (number-to-string
-                (read-number
-                 (format "%s where %s %s " operation column-name op))))
-
-    (list op column-name oper)))
-
-(defun tablist-push-regexp-filter (column-name regexp)
-  "Add a new filter matching REGEXP in COLUMN-NAME.
-
-The filter is and'ed with the current filter.  Use
-`tablist-toggle-first-filter-logic' to change this."
-  (interactive
-   (tablist-with-filter-displayed
-    (tablist-read-regexp-filter "Filter" current-prefix-arg)))
-  (tablist-push-filter
-   `(=~ ,column-name ,regexp)
-   (called-interactively-p 'any)))
-
-(defun tablist-push-equal-filter (column-name string)
-  "Add a new filter whre string equals COLUMN-NAME's value.
-
-The filter is and'ed with the current filter.  Use
-`tablist-toggle-first-filter-logic' to change this."
-  (interactive
-   (tablist-with-filter-displayed
-    (tablist-read-equal-filter "Filter" current-prefix-arg)))
-  (tablist-push-filter
-   `(== ,column-name ,string)
-   (called-interactively-p 'any)))
-
-(defun tablist-push-numeric-filter (op column-name 2nd-arg)
-  "Add a new filter matching a numeric predicate.
-
-The filter is and'ed with the current filter.  Use
-`tablist-toggle-first-filter-logic' to change this."
-  (interactive
-   (tablist-with-filter-displayed
-    (tablist-read-numeric-filter "Filter" current-prefix-arg)))
-  (tablist-push-filter
-   `(,op ,column-name ,2nd-arg)
-   (called-interactively-p 'any)))
-
-(defun tablist-push-named-filter (name)
-  "Add a named filter called NAME.
-
-Named filter are saved in the variable `tablist-named-filter'."
-  (interactive
-   (tablist-with-filter-displayed
-    (list
-     (tablist-read-filter-name "Add filter"))))
-  (when (and name (symbolp name))
-    (setq name (symbol-name name)))
-  (tablist-push-filter name (called-interactively-p 'any)))
-
-(defun tablist-delete-named-filter (name &optional mode)
-  (interactive
-   (tablist-with-filter-displayed
-    (list
-     (tablist-read-filter-name "Delete filter"))))
-  (setq tablist-current-filter
-        (tablist-filter-map
-         (lambda (f)
-           (when (equal f name)
-             (setq f (tablist-get-named-filter f)))
-           f)
-         tablist-current-filter))
-  (unless mode (setq mode major-mode))
-  (let ((mode-filter
-         (assq mode tablist-named-filter)))
-    (when mode-filter
-      (setcdr mode-filter
-              (cl-remove name (cdr mode-filter)
-                         :test 'equal :key 'car)))))
-
-(defun tablist-name-current-filter (name)
-  (interactive
-   (list (tablist-with-filter-displayed
-          (read-string
-           "Add name for current filter: "))))
-  (unless tablist-current-filter
-    (error "Filter is empty"))
-  (unless (> (length name) 0)
-    (error "No name given"))
-  (tablist-put-named-filter
-   name (if (stringp tablist-current-filter)
-            (tablist-get-named-filter
-             tablist-current-filter)
-          tablist-current-filter))
-  (setq tablist-current-filter name)
-  (force-mode-line-update))
-
-(defun tablist-deconstruct-named-filter ()
-  (interactive)
-  (let (found)
-    (setq tablist-current-filter
-          (tablist-filter-map
-           (lambda (f)
-             (when (and (not found)
-                        (stringp f))
-               (setq found t)
-               (let ((df (tablist-get-named-filter f)))
-                 (unless df
-                   (error "Filter is not defined: %s" f))
-                 (setq f df)))
-             f)
-           tablist-current-filter))
-    (unless found
-      (error "No named filter found"))
-    (force-mode-line-update)))
-
-(defun tablist-filter-names (&optional mode)
-  (mapcar 'car (cdr (assq (or mode major-mode)
-                          tablist-named-filter))))
-
-(defun tablist-get-named-filter (name &optional mode)
-  (cdr (assoc name
-              (cdr (assq (or mode major-mode)
-                         tablist-named-filter)))))
-
-(defun tablist-put-named-filter (name filter &optional mode)
-  (unless mode (setq mode major-mode))
-  (let ((mode-filter
-         (assq mode tablist-named-filter)))
-    (unless mode-filter
-      (setq mode-filter (cons mode nil))
-      (push mode-filter tablist-named-filter))
-    (let ((entry (assoc name mode-filter)))
-      (if entry
-          (setcdr entry filter)
-        (setcdr mode-filter
-                (list (cons name filter)))))))
-
-(defun tablist-validate-named-filter (filter)
-  (tablist-filter-map
-   (lambda (f)
-     (when (and (stringp f)
-                (null (tablist-get-named-filter f)))
-       (error "Undefined named filter: %s (defined: %s)" f
-              (mapconcat 'identity (tablist-filter-names) ","))))
-   filter))
-
-(defun tablist-edit-filter ()
-  (interactive)
-  (setq tablist-current-filter
-        (tablist-with-filter-displayed
-         (tablist-filter-edit-filter
-          "Edit filter: "
-          tablist-current-filter
-          nil
-          'tablist-validate-named-filter)))
-  (tablist-apply-filter))
-
-(defun tablist-clear-filter ()
-  (interactive)
-  (setq tablist-current-filter nil)
-  (tablist-apply-filter))
-
-;; **Displaying filter
-;;
-
-(defconst tablist-display-filter-mode-line-tag nil)
-
-(defun tablist-display-filter (&optional flag)
-  "Display the current filter according to FLAG.
-
-If FLAG has the value 'toggle, toggle it's visibility.
-If FLAG has the 'state, then do nothing but return the current
-visibility."
-  (interactive (list 'toggle))
-  (let* ((tag 'tablist-display-filter-mode-line-tag)
-         (displayed-p (not (not (assq tag mode-line-format)))))
-    (if (eq flag 'state)
-        displayed-p
-      (let ((display-p (not (not (if (eq flag 'toggle)
-                                     (not displayed-p)
-                                   flag)))))
-        (unless (eq displayed-p display-p)
-          (setq mode-line-format
-                (if display-p
-                    (list (cons tag mode-line-format)
-                          '(:eval
-                            (replace-regexp-in-string
-                             "%" "%%"
-                             (concat
-                              (propertize "Filter: " 'face 'minibuffer-prompt)
-                              (and tablist-filter-suspended
-                                   "[suspended] ")
-                              (if tablist-current-filter
-                                  (tablist-filter-unparse
-                                   tablist-current-filter t)
-                                "[none]")))))
-                  (cdr (assq tag mode-line-format)))))
-        (force-mode-line-update)
-        display-p))))
-
-(defun tablist-display-filter-temporarily ()
-  (tablist-with-filter-displayed
-   (sit-for 9999)))
-
-;;
-;; **Hiding/Unhiding Entries
-;;
-(defun tablist-filter-set-entry-hidden (flag &optional pos)
-  (save-excursion
-    (when pos (goto-char pos))
-    (beginning-of-line)
-    (let ((inhibit-read-only t))
-      (add-text-properties
-       (point-at-bol)
-       (1+ (point-at-eol))
-       `(invisible ,flag)))))
-
-(defun tablist-filter-hide-entry (&optional pos)
-  (interactive)
-  (tablist-filter-set-entry-hidden t pos))
-
-(defun tablist-filter-unhide-entry (&optional pos)
-  (tablist-filter-set-entry-hidden nil pos))
-
-(defun tablist-filter-unhide-buffer ()
-  (let ((inhibit-read-only t))
-    (remove-text-properties
-     (point-min) (point-max)
-     '(invisible))))
-
-(defun tablist-window-attach (awindow &optional window)
-  "Attach AWINDOW to WINDOW.
-
-This has the following effect.  Whenever WINDOW, defaulting to
-the selected window, stops displaying the buffer it currently
-displays (e.g., by switching buffers or because it was deleted)
-AWINDOW is deleted."
-  (unless window (setq window (selected-window)))
-  (let ((buffer (window-buffer window))
-        (hook (make-symbol "window-attach-hook")))
-    (fset hook
-          (lambda ()
-            (when (or (not (window-live-p window))
-                      (not (eq buffer (window-buffer window))))
-              (remove-hook 'window-configuration-change-hook
-                           hook)
-              ;; Deleting windows inside wcch may cause errors in
-              ;; windows.el .
-              (run-with-timer
-               0 nil (lambda (win)
-                       (when (and (window-live-p win)
-                                  (not (eq win (selected-window))))
-                         (delete-window win)))
-               awindow))))
-    (add-hook 'window-configuration-change-hook hook)))
-
-(defun tablist-display-buffer-split-below-and-attach (buf alist)
-  "Display buffer action using `tablist-window-attach'."
-  (let ((window (selected-window))
-        (height (cdr (assq 'window-height alist)))
-        newwin)
-    (when height
-      (when (floatp height)
-        (setq height (round (* height (frame-height)))))
-      (setq height (- (max height window-min-height))))
-    (setq newwin (window--display-buffer
-                  buf
-                  (split-window-below height)
-                  'window alist display-buffer-mark-dedicated))
-    (tablist-window-attach newwin window)
-    newwin))
-
-(defun tablist-generate-sorter (column compare-fn &optional read-fn)
-  "Generate a sort function for `tabulated-list' entries.
-
-Example:
-
-     \(tablist-generate-sorter 0 '< 'string-to-number\)
-
-would create a sort function sorting `tabulated-list-entries' on
-the 0-th column as numbers by the less-than relation."
-
-  (lambda (e1 e2)
-    (funcall compare-fn
-             (funcall (or read-fn 'identity)
-                      (aref (cadr e1) column))
-             (funcall read-fn
-                      (aref (cadr e2) column)))))
-
-(provide 'tablist)
-;;; tablist.el ends here