|
2233
|
1 ;;; ls-lisp.el --- emulate insert-directory completely in Emacs Lisp
|
|
|
2
|
|
74442
|
3 ;; Copyright (C) 1992, 1994, 2000, 2001, 2002, 2003, 2004,
|
|
79721
|
4 ;; 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
|
|
14169
|
5
|
|
38412
|
6 ;; Author: Sebastian Kremer <sk@thp.uni-koeln.de>
|
|
|
7 ;; Modified by: Francis J. Wright <F.J.Wright@maths.qmw.ac.uk>
|
|
|
8 ;; Maintainer: FSF
|
|
|
9 ;; Keywords: unix, dired
|
|
183
|
10
|
|
14169
|
11 ;; This file is part of GNU Emacs.
|
|
183
|
12
|
|
94678
|
13 ;; GNU Emacs is free software: you can redistribute it and/or modify
|
|
183
|
14 ;; it under the terms of the GNU General Public License as published by
|
|
94678
|
15 ;; the Free Software Foundation, either version 3 of the License, or
|
|
|
16 ;; (at your option) any later version.
|
|
14169
|
17
|
|
|
18 ;; GNU Emacs is distributed in the hope that it will be useful,
|
|
183
|
19 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
20 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
21 ;; GNU General Public License for more details.
|
|
14169
|
22
|
|
183
|
23 ;; You should have received a copy of the GNU General Public License
|
|
94678
|
24 ;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
|
|
14169
|
25
|
|
|
26 ;;; Commentary:
|
|
183
|
27
|
|
34884
|
28 ;; OVERVIEW ==========================================================
|
|
623
|
29
|
|
34884
|
30 ;; This file redefines the function `insert-directory' to implement it
|
|
|
31 ;; directly from Emacs lisp, without running ls in a subprocess. It
|
|
|
32 ;; is useful if you cannot afford to fork Emacs on a real memory UNIX,
|
|
|
33 ;; under VMS or other non-UNIX platforms if you don't have the ls
|
|
|
34 ;; program, or if you want a different format from what ls offers.
|
|
183
|
35
|
|
34884
|
36 ;; This function can use regexps instead of shell wildcards. If you
|
|
|
37 ;; enter regexps remember to double each $ sign. For example, to
|
|
|
38 ;; include files *.el, enter `.*\.el$$', resulting in the regexp
|
|
|
39 ;; `.*\.el$'.
|
622
1d4abb4dfecb
(dired-lisp-format-time): in Emacs 19 we can format times.
Sebastian Kremer <sk@thp.uni-koeln.de>
diff
changeset
|
40
|
|
34884
|
41 ;; RESTRICTIONS ======================================================
|
|
|
42
|
|
|
43 ;; * A few obscure ls switches are still ignored: see the docstring of
|
|
|
44 ;; `insert-directory'.
|
|
183
|
45
|
|
34884
|
46 ;; TO DO =============================================================
|
622
1d4abb4dfecb
(dired-lisp-format-time): in Emacs 19 we can format times.
Sebastian Kremer <sk@thp.uni-koeln.de>
diff
changeset
|
47
|
|
34884
|
48 ;; Complete handling of F switch (if/when possible).
|
|
|
49
|
|
|
50 ;; FJW: May be able to sort much faster by consing the sort key onto
|
|
|
51 ;; the front of each list element, sorting and then stripping the key
|
|
|
52 ;; off again!
|
622
1d4abb4dfecb
(dired-lisp-format-time): in Emacs 19 we can format times.
Sebastian Kremer <sk@thp.uni-koeln.de>
diff
changeset
|
53
|
|
34884
|
54 ;;; History:
|
|
183
|
55
|
|
34884
|
56 ;; Written originally by Sebastian Kremer <sk@thp.uni-koeln.de>
|
|
|
57 ;; Revised by Andrew Innes and Geoff Volker (and maybe others).
|
|
183
|
58
|
|
34884
|
59 ;; Modified by Francis J. Wright <F.J.Wright@maths.qmw.ac.uk>, mainly
|
|
67079
|
60 ;; to support many more ls options, "platform emulation" and more
|
|
|
61 ;; robust sorting.
|
622
1d4abb4dfecb
(dired-lisp-format-time): in Emacs 19 we can format times.
Sebastian Kremer <sk@thp.uni-koeln.de>
diff
changeset
|
62
|
|
2233
|
63 ;;; Code:
|
|
|
64
|
50767
5e248d2a95e7
(ls-lisp-format-file-size): New function to implement "-h" switch.
Juanma Barranquero <lekktu@gmail.com>
diff
changeset
|
65 (eval-when-compile (require 'cl))
|
5e248d2a95e7
(ls-lisp-format-file-size): New function to implement "-h" switch.
Juanma Barranquero <lekktu@gmail.com>
diff
changeset
|
66
|
|
34884
|
67 (defgroup ls-lisp nil
|
|
|
68 "Emulate the ls program completely in Emacs Lisp."
|
|
35011
|
69 :version "21.1"
|
|
34884
|
70 :group 'dired)
|
|
|
71
|
|
|
72 (defcustom ls-lisp-emulation
|
|
|
73 (cond ((eq system-type 'macos) 'MacOS)
|
|
|
74 ;; ((eq system-type 'windows-nt) 'MS-Windows)
|
|
|
75 ((memq system-type
|
|
87595
|
76 '(hpux usg-unix-v unisoft-unix irix berkeley-unix))
|
|
34884
|
77 'UNIX)) ; very similar to GNU
|
|
|
78 ;; Anything else defaults to nil, meaning GNU.
|
|
|
79 "*Platform to emulate: GNU (default), MacOS, MS-Windows, UNIX.
|
|
|
80 Corresponding value is one of the atoms: nil, MacOS, MS-Windows, UNIX.
|
|
|
81 Sets default values for: `ls-lisp-ignore-case', `ls-lisp-dirs-first',
|
|
|
82 `ls-lisp-verbosity'. Need not match actual platform. Changing this
|
|
|
83 option will have no effect until you restart Emacs."
|
|
|
84 :type '(choice (const :tag "GNU" nil)
|
|
|
85 (const MacOS)
|
|
|
86 (const MS-Windows)
|
|
|
87 (const UNIX))
|
|
|
88 :group 'ls-lisp)
|
|
|
89
|
|
|
90 (defcustom ls-lisp-ignore-case
|
|
|
91 ;; Name change for consistency with other option names.
|
|
|
92 (or (memq ls-lisp-emulation '(MS-Windows MacOS))
|
|
|
93 (and (boundp 'ls-lisp-dired-ignore-case) ls-lisp-dired-ignore-case))
|
|
|
94 "*Non-nil causes ls-lisp alphabetic sorting to ignore case."
|
|
|
95 :type 'boolean
|
|
|
96 :group 'ls-lisp)
|
|
13883
|
97
|
|
34884
|
98 (defcustom ls-lisp-dirs-first (eq ls-lisp-emulation 'MS-Windows)
|
|
|
99 "*Non-nil causes ls-lisp to sort directories first in any ordering.
|
|
|
100 \(Or last if it is reversed.) Follows Microsoft Windows Explorer."
|
|
|
101 ;; Functionality suggested by Chris McMahan <cmcmahan@one.net>
|
|
|
102 :type 'boolean
|
|
|
103 :group 'ls-lisp)
|
|
|
104
|
|
|
105 (defcustom ls-lisp-verbosity
|
|
|
106 (cond ((eq ls-lisp-emulation 'MacOS) nil)
|
|
|
107 ((eq ls-lisp-emulation 'MS-Windows)
|
|
|
108 (if (and (fboundp 'w32-using-nt) (w32-using-nt))
|
|
|
109 '(links))) ; distinguish NT/2K from 9x
|
|
|
110 ((eq ls-lisp-emulation 'UNIX) '(links uid)) ; UNIX ls
|
|
|
111 (t '(links uid gid))) ; GNU ls
|
|
|
112 "*A list of optional file attributes that ls-lisp should display.
|
|
|
113 It should contain none or more of the symbols: links, uid, gid.
|
|
77711
|
114 A value of nil (or an empty list) means display none of them.
|
|
21620
|
115
|
|
34884
|
116 Concepts come from UNIX: `links' means count of names associated with
|
|
|
117 the file\; `uid' means user (owner) identifier\; `gid' means group
|
|
|
118 identifier.
|
|
|
119
|
|
|
120 If emulation is MacOS then default is nil\;
|
|
|
121 if emulation is MS-Windows then default is `(links)' if platform is
|
|
|
122 Windows NT/2K, nil otherwise\;
|
|
|
123 if emulation is UNIX then default is `(links uid)'\;
|
|
|
124 if emulation is GNU then default is `(links uid gid)'."
|
|
|
125 ;; Functionality suggested by Howard Melman <howard@silverstream.com>
|
|
|
126 :type '(set (const :tag "Show Link Count" links)
|
|
|
127 (const :tag "Show User" uid)
|
|
|
128 (const :tag "Show Group" gid))
|
|
|
129 :group 'ls-lisp)
|
|
|
130
|
|
49328
|
131 (defcustom ls-lisp-use-insert-directory-program
|
|
|
132 (not (memq system-type '(macos ms-dos windows-nt)))
|
|
34884
|
133 "*Non-nil causes ls-lisp to revert back to using `insert-directory-program'.
|
|
23452
|
134 This is useful on platforms where ls-lisp is dumped into Emacs, such as
|
|
|
135 Microsoft Windows, but you would still like to use a program to list
|
|
34884
|
136 the contents of a directory."
|
|
|
137 :type 'boolean
|
|
|
138 :group 'ls-lisp)
|
|
|
139
|
|
49328
|
140 ;;; Autoloaded because it is let-bound in `recover-session', `mail-recover-1'.
|
|
|
141 ;;;###autoload
|
|
34884
|
142 (defcustom ls-lisp-support-shell-wildcards t
|
|
|
143 "*Non-nil means ls-lisp treats file patterns as shell wildcards.
|
|
|
144 Otherwise they are treated as Emacs regexps (for backward compatibility)."
|
|
|
145 :type 'boolean
|
|
|
146 :group 'ls-lisp)
|
|
23452
|
147
|
|
47329
|
148 (defcustom ls-lisp-format-time-list
|
|
|
149 '("%b %e %H:%M"
|
|
|
150 "%b %e %Y")
|
|
|
151 "*List of `format-time-string' specs to display file time stamps.
|
|
75426
|
152 These specs are used ONLY if a valid locale can not be determined.
|
|
|
153
|
|
|
154 If `ls-lisp-use-localized-time-format' is non-nil, these specs are used
|
|
|
155 regardless of whether the locale can be determined.
|
|
47329
|
156
|
|
|
157 Syntax: (EARLY-TIME-FORMAT OLD-TIME-FORMAT)
|
|
|
158
|
|
|
159 The EARLY-TIME-FORMAT is used if file has been modified within the
|
|
|
160 current year. The OLD-TIME-FORMAT is used for older files. To use ISO
|
|
|
161 8601 dates, you could set:
|
|
|
162
|
|
|
163 \(setq ls-lisp-format-time-list
|
|
|
164 '(\"%Y-%m-%d %H:%M\"
|
|
|
165 \"%Y-%m-%d \"))"
|
47510
22c6e92cccfb
(ls-lisp-format-time-list): Fix type and provide :tag's.
Markus Rost <rost@math.uni-bielefeld.de>
diff
changeset
|
166 :type '(list (string :tag "Early time format")
|
22c6e92cccfb
(ls-lisp-format-time-list): Fix type and provide :tag's.
Markus Rost <rost@math.uni-bielefeld.de>
diff
changeset
|
167 (string :tag "Old time format"))
|
|
47329
|
168 :group 'ls-lisp)
|
|
|
169
|
|
75426
|
170 (defcustom ls-lisp-use-localized-time-format nil
|
|
|
171 "*Non-nil causes ls-lisp to use `ls-lisp-format-time-list' even if
|
|
|
172 a valid locale is specified.
|
|
|
173
|
|
|
174 WARNING: Using localized date/time format might cause Dired columns
|
|
|
175 to fail to lign up, e.g. if month names are not all of the same length."
|
|
|
176 :type 'boolean
|
|
|
177 :group 'ls-lisp)
|
|
|
178
|
|
48917
|
179 (defvar original-insert-directory nil
|
|
|
180 "This holds the original function definition of `insert-directory'.")
|
|
|
181
|
|
94345
|
182 (defvar ls-lisp-uid-d-fmt "-%d"
|
|
|
183 "Format to display integer UIDs.")
|
|
|
184 (defvar ls-lisp-uid-s-fmt "-%s"
|
|
|
185 "Format to display user names.")
|
|
|
186 (defvar ls-lisp-gid-d-fmt "-%d"
|
|
|
187 "Format to display integer GIDs.")
|
|
|
188 (defvar ls-lisp-gid-s-fmt "-%s"
|
|
|
189 "Format to display user group names.")
|
|
|
190 (defvar ls-lisp-filesize-d-fmt "%d"
|
|
|
191 "Format to display integer file sizes.")
|
|
|
192 (defvar ls-lisp-filesize-f-fmt "%.0f"
|
|
|
193 "Format to display float file sizes.")
|
|
|
194
|
|
34884
|
195 ;; Remember the original insert-directory function
|
|
|
196 (or (featurep 'ls-lisp) ; FJW: unless this file is being reloaded!
|
|
48917
|
197 (setq original-insert-directory (symbol-function 'insert-directory)))
|
|
34884
|
198
|
|
|
199
|
|
|
200 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
23452
|
201
|
|
|
202 (defun insert-directory (file switches &optional wildcard full-directory-p)
|
|
|
203 "Insert directory listing for FILE, formatted according to SWITCHES.
|
|
|
204 Leaves point after the inserted text.
|
|
|
205 SWITCHES may be a string of options, or a list of strings.
|
|
|
206 Optional third arg WILDCARD means treat FILE as shell wildcard.
|
|
|
207 Optional fourth arg FULL-DIRECTORY-P means file is a directory and
|
|
|
208 switches do not contain `d', so that a full listing is expected.
|
|
|
209
|
|
34884
|
210 This version of the function comes from `ls-lisp.el'.
|
|
|
211 If the value of `ls-lisp-use-insert-directory-program' is non-nil then
|
|
|
212 it works exactly like the version from `files.el' and runs a directory
|
|
|
213 listing program whose name is in the variable
|
|
|
214 `insert-directory-program'; if also WILDCARD is non-nil then it runs
|
|
|
215 the shell specified by `shell-file-name'. If the value of
|
|
|
216 `ls-lisp-use-insert-directory-program' is nil then it runs a Lisp
|
|
|
217 emulation.
|
|
|
218
|
|
|
219 The Lisp emulation does not run any external programs or shells. It
|
|
|
220 supports ordinary shell wildcards if `ls-lisp-support-shell-wildcards'
|
|
|
221 is non-nil; otherwise, it interprets wildcards as regular expressions
|
|
|
222 to match file names. It does not support all `ls' switches -- those
|
|
87992
|
223 that work are: A a c i r S s t u U X g G B C R n and F partly."
|
|
23452
|
224 (if ls-lisp-use-insert-directory-program
|
|
48917
|
225 (funcall original-insert-directory
|
|
|
226 file switches wildcard full-directory-p)
|
|
34884
|
227 ;; We need the directory in order to find the right handler.
|
|
|
228 (let ((handler (find-file-name-handler (expand-file-name file)
|
|
52897
|
229 'insert-directory))
|
78043
0ef88721691e
(insert-directory): If an invalid regexp error is thrown, try using FILE
Eli Zaretskii <eliz@gnu.org>
diff
changeset
|
230 (orig-file file)
|
|
52897
|
231 wildcard-regexp)
|
|
34884
|
232 (if handler
|
|
|
233 (funcall handler 'insert-directory file switches
|
|
|
234 wildcard full-directory-p)
|
|
50992
|
235 ;; Remove --dired switch
|
|
|
236 (if (string-match "--dired " switches)
|
|
|
237 (setq switches (replace-match "" nil nil switches)))
|
|
34884
|
238 ;; Convert SWITCHES to a list of characters.
|
|
|
239 (setq switches (delete ?- (append switches nil)))
|
|
52897
|
240 ;; Sometimes we get ".../foo*/" as FILE. While the shell and
|
|
|
241 ;; `ls' don't mind, we certainly do, because it makes us think
|
|
|
242 ;; there is no wildcard, only a directory name.
|
|
|
243 (if (and ls-lisp-support-shell-wildcards
|
78039
ed97a96f45fc
(insert-directory): Don't treat FILE as a wildcard if FILE exists as
Eli Zaretskii <eliz@gnu.org>
diff
changeset
|
244 (string-match "[[?*]" file)
|
78043
0ef88721691e
(insert-directory): If an invalid regexp error is thrown, try using FILE
Eli Zaretskii <eliz@gnu.org>
diff
changeset
|
245 ;; Prefer an existing file to wildcards, like
|
78039
ed97a96f45fc
(insert-directory): Don't treat FILE as a wildcard if FILE exists as
Eli Zaretskii <eliz@gnu.org>
diff
changeset
|
246 ;; dired-noselect does.
|
78043
0ef88721691e
(insert-directory): If an invalid regexp error is thrown, try using FILE
Eli Zaretskii <eliz@gnu.org>
diff
changeset
|
247 (not (file-exists-p file)))
|
|
52897
|
248 (progn
|
|
|
249 (or (not (eq (aref file (1- (length file))) ?/))
|
|
|
250 (setq file (substring file 0 (1- (length file)))))
|
|
|
251 (setq wildcard t)))
|
|
34884
|
252 (if wildcard
|
|
52897
|
253 (setq wildcard-regexp
|
|
34884
|
254 (if ls-lisp-support-shell-wildcards
|
|
|
255 (wildcard-to-regexp (file-name-nondirectory file))
|
|
|
256 (file-name-nondirectory file))
|
|
|
257 file (file-name-directory file))
|
|
52897
|
258 (if (memq ?B switches) (setq wildcard-regexp "[^~]\\'")))
|
78043
0ef88721691e
(insert-directory): If an invalid regexp error is thrown, try using FILE
Eli Zaretskii <eliz@gnu.org>
diff
changeset
|
259 (condition-case err
|
0ef88721691e
(insert-directory): If an invalid regexp error is thrown, try using FILE
Eli Zaretskii <eliz@gnu.org>
diff
changeset
|
260 (ls-lisp-insert-directory
|
0ef88721691e
(insert-directory): If an invalid regexp error is thrown, try using FILE
Eli Zaretskii <eliz@gnu.org>
diff
changeset
|
261 file switches (ls-lisp-time-index switches)
|
0ef88721691e
(insert-directory): If an invalid regexp error is thrown, try using FILE
Eli Zaretskii <eliz@gnu.org>
diff
changeset
|
262 wildcard-regexp full-directory-p)
|
0ef88721691e
(insert-directory): If an invalid regexp error is thrown, try using FILE
Eli Zaretskii <eliz@gnu.org>
diff
changeset
|
263 (invalid-regexp
|
0ef88721691e
(insert-directory): If an invalid regexp error is thrown, try using FILE
Eli Zaretskii <eliz@gnu.org>
diff
changeset
|
264 ;; Maybe they wanted a literal file that just happens to
|
0ef88721691e
(insert-directory): If an invalid regexp error is thrown, try using FILE
Eli Zaretskii <eliz@gnu.org>
diff
changeset
|
265 ;; use characters special to shell wildcards.
|
0ef88721691e
(insert-directory): If an invalid regexp error is thrown, try using FILE
Eli Zaretskii <eliz@gnu.org>
diff
changeset
|
266 (if (equal (cadr err) "Unmatched [ or [^")
|
0ef88721691e
(insert-directory): If an invalid regexp error is thrown, try using FILE
Eli Zaretskii <eliz@gnu.org>
diff
changeset
|
267 (progn
|
0ef88721691e
(insert-directory): If an invalid regexp error is thrown, try using FILE
Eli Zaretskii <eliz@gnu.org>
diff
changeset
|
268 (setq wildcard-regexp (if (memq ?B switches) "[^~]\\'")
|
0ef88721691e
(insert-directory): If an invalid regexp error is thrown, try using FILE
Eli Zaretskii <eliz@gnu.org>
diff
changeset
|
269 file (file-relative-name orig-file))
|
0ef88721691e
(insert-directory): If an invalid regexp error is thrown, try using FILE
Eli Zaretskii <eliz@gnu.org>
diff
changeset
|
270 (ls-lisp-insert-directory
|
0ef88721691e
(insert-directory): If an invalid regexp error is thrown, try using FILE
Eli Zaretskii <eliz@gnu.org>
diff
changeset
|
271 file switches (ls-lisp-time-index switches)
|
0ef88721691e
(insert-directory): If an invalid regexp error is thrown, try using FILE
Eli Zaretskii <eliz@gnu.org>
diff
changeset
|
272 nil full-directory-p))
|
0ef88721691e
(insert-directory): If an invalid regexp error is thrown, try using FILE
Eli Zaretskii <eliz@gnu.org>
diff
changeset
|
273 (signal (car err) (cdr err)))))
|
|
42239
|
274 ;; Try to insert the amount of free space.
|
|
|
275 (save-excursion
|
|
|
276 (goto-char (point-min))
|
|
|
277 ;; First find the line to put it on.
|
|
|
278 (when (re-search-forward "^total" nil t)
|
|
|
279 (let ((available (get-free-disk-space ".")))
|
|
|
280 (when available
|
42427
f1a88fb2fb4e
(insert-directory): Modify the "total" line wording, in accordance with
Eli Zaretskii <eliz@gnu.org>
diff
changeset
|
281 ;; Replace "total" with "total used", to avoid confusion.
|
f1a88fb2fb4e
(insert-directory): Modify the "total" line wording, in accordance with
Eli Zaretskii <eliz@gnu.org>
diff
changeset
|
282 (replace-match "total used in directory")
|
|
42239
|
283 (end-of-line)
|
|
|
284 (insert " available " available)))))))))
|
|
416
|
285
|
|
34884
|
286 (defun ls-lisp-insert-directory
|
|
52897
|
287 (file switches time-index wildcard-regexp full-directory-p)
|
|
34884
|
288 "Insert directory listing for FILE, formatted according to SWITCHES.
|
|
|
289 Leaves point after the inserted text. This is an internal function
|
|
|
290 optionally called by the `ls-lisp.el' version of `insert-directory'.
|
|
|
291 It is called recursively if the -R switch is used.
|
|
|
292 SWITCHES is a *list* of characters. TIME-INDEX is the time index into
|
|
52897
|
293 file-attributes according to SWITCHES. WILDCARD-REGEXP is nil or an *Emacs
|
|
34884
|
294 regexp*. FULL-DIRECTORY-P means file is a directory and SWITCHES does
|
|
|
295 not contain `d', so that a full listing is expected."
|
|
52897
|
296 (if (or wildcard-regexp full-directory-p)
|
|
34884
|
297 (let* ((dir (file-name-as-directory file))
|
|
|
298 (default-directory dir) ; so that file-attributes works
|
|
|
299 (file-alist
|
|
87992
|
300 (directory-files-and-attributes dir nil wildcard-regexp t
|
|
|
301 (if (memq ?n switches)
|
|
|
302 'integer
|
|
|
303 'string)))
|
|
34884
|
304 (now (current-time))
|
|
|
305 (sum 0)
|
|
94345
|
306 (max-uid-len 0)
|
|
|
307 (max-gid-len 0)
|
|
|
308 (max-file-size 0)
|
|
34884
|
309 ;; do all bindings here for speed
|
|
94345
|
310 total-line files elt short file-size fil attr
|
|
|
311 fuid fgid uid-len gid-len)
|
|
34884
|
312 (cond ((memq ?A switches)
|
|
|
313 (setq file-alist
|
|
|
314 (ls-lisp-delete-matching "^\\.\\.?$" file-alist)))
|
|
|
315 ((not (memq ?a switches))
|
|
|
316 ;; if neither -A nor -a, flush . files
|
|
|
317 (setq file-alist
|
|
|
318 (ls-lisp-delete-matching "^\\." file-alist))))
|
|
|
319 (setq file-alist
|
|
|
320 (ls-lisp-handle-switches file-alist switches))
|
|
|
321 (if (memq ?C switches) ; column (-C) format
|
|
|
322 (ls-lisp-column-format file-alist)
|
|
|
323 (setq total-line (cons (point) (car-safe file-alist)))
|
|
94345
|
324 ;; Find the appropriate format for displaying uid, gid, and
|
|
|
325 ;; file size, by finding the longest strings among all the
|
|
|
326 ;; files we are about to display.
|
|
|
327 (dolist (elt file-alist)
|
|
|
328 (setq attr (cdr elt)
|
|
|
329 fuid (nth 2 attr)
|
|
94580
|
330 uid-len (if (stringp fuid) (string-width fuid)
|
|
|
331 (length (format "%d" fuid)))
|
|
94345
|
332 fgid (nth 3 attr)
|
|
94580
|
333 gid-len (if (stringp fgid) (string-width fgid)
|
|
|
334 (length (format "%d" fgid)))
|
|
94345
|
335 file-size (nth 7 attr))
|
|
|
336 (if (> uid-len max-uid-len)
|
|
|
337 (setq max-uid-len uid-len))
|
|
|
338 (if (> gid-len max-gid-len)
|
|
|
339 (setq max-gid-len gid-len))
|
|
|
340 (if (> file-size max-file-size)
|
|
|
341 (setq max-file-size file-size)))
|
|
|
342 (setq ls-lisp-uid-d-fmt (format " %%-%dd" max-uid-len))
|
|
|
343 (setq ls-lisp-uid-s-fmt (format " %%-%ds" max-uid-len))
|
|
|
344 (setq ls-lisp-gid-d-fmt (format " %%-%dd" max-gid-len))
|
|
|
345 (setq ls-lisp-gid-s-fmt (format " %%-%ds" max-gid-len))
|
|
|
346 (setq ls-lisp-filesize-d-fmt
|
|
|
347 (format " %%%dd"
|
|
|
348 (if (memq ?s switches)
|
|
|
349 (length (format "%.0f"
|
|
|
350 (fceiling (/ max-file-size 1024.0))))
|
|
|
351 (length (format "%.0f" max-file-size)))))
|
|
|
352 (setq ls-lisp-filesize-f-fmt
|
|
|
353 (format " %%%d.0f"
|
|
|
354 (if (memq ?s switches)
|
|
|
355 (length (format "%.0f"
|
|
|
356 (fceiling (/ max-file-size 1024.0))))
|
|
|
357 (length (format "%.0f" max-file-size)))))
|
|
34884
|
358 (setq files file-alist)
|
|
|
359 (while files ; long (-l) format
|
|
|
360 (setq elt (car files)
|
|
|
361 files (cdr files)
|
|
|
362 short (car elt)
|
|
|
363 attr (cdr elt)
|
|
|
364 file-size (nth 7 attr))
|
|
|
365 (and attr
|
|
|
366 (setq sum (+ file-size
|
|
|
367 ;; Even if neither SUM nor file's size
|
|
|
368 ;; overflow, their sum could.
|
|
|
369 (if (or (< sum (- 134217727 file-size))
|
|
|
370 (floatp sum)
|
|
|
371 (floatp file-size))
|
|
|
372 sum
|
|
|
373 (float sum))))
|
|
|
374 (insert (ls-lisp-format short attr file-size
|
|
|
375 switches time-index now))))
|
|
|
376 ;; Insert total size of all files:
|
|
|
377 (save-excursion
|
|
|
378 (goto-char (car total-line))
|
|
|
379 (or (cdr total-line)
|
|
|
380 ;; Shell says ``No match'' if no files match
|
|
|
381 ;; the wildcard; let's say something similar.
|
|
|
382 (insert "(No match)\n"))
|
|
|
383 (insert (format "total %.0f\n" (fceiling (/ sum 1024.0))))))
|
|
|
384 (if (memq ?R switches)
|
|
|
385 ;; List the contents of all directories recursively.
|
|
|
386 ;; cadr of each element of `file-alist' is t for
|
|
|
387 ;; directory, string (name linked to) for symbolic
|
|
|
388 ;; link, or nil.
|
|
1334
|
389 (while file-alist
|
|
|
390 (setq elt (car file-alist)
|
|
34884
|
391 file-alist (cdr file-alist))
|
|
|
392 (when (and (eq (cadr elt) t) ; directory
|
|
|
393 (not (string-match "\\`\\.\\.?\\'" (car elt))))
|
|
|
394 (setq elt (expand-file-name (car elt) dir))
|
|
|
395 (insert "\n" elt ":\n")
|
|
|
396 (ls-lisp-insert-directory
|
|
52897
|
397 elt switches time-index wildcard-regexp full-directory-p)))))
|
|
34884
|
398 ;; If not full-directory-p, FILE *must not* end in /, as
|
|
|
399 ;; file-attributes will not recognize a symlink to a directory,
|
|
|
400 ;; so must make it a relative filename as ls does:
|
|
|
401 (if (eq (aref file (1- (length file))) ?/)
|
|
|
402 (setq file (substring file 0 -1)))
|
|
53320
|
403 (let ((fattr (file-attributes file 'string)))
|
|
34884
|
404 (if fattr
|
|
|
405 (insert (ls-lisp-format file fattr (nth 7 fattr)
|
|
|
406 switches time-index (current-time)))
|
|
|
407 (message "%s: doesn't exist or is inaccessible" file)
|
|
|
408 (ding) (sit-for 2))))) ; to show user the message!
|
|
|
409
|
|
|
410 (defun ls-lisp-column-format (file-alist)
|
|
|
411 "Insert the file names (only) in FILE-ALIST into the current buffer.
|
|
|
412 Format in columns, sorted vertically, following GNU ls -C.
|
|
|
413 Responds to the window width as ls should but may not!"
|
|
|
414 (let (files fmt ncols collen (nfiles 0) (colwid 0))
|
|
|
415 ;; Count number of files as `nfiles', build list of filenames as
|
|
|
416 ;; `files', and find maximum filename length as `colwid':
|
|
|
417 (let (file len)
|
|
|
418 (while file-alist
|
|
|
419 (setq nfiles (1+ nfiles)
|
|
|
420 file (caar file-alist)
|
|
|
421 files (cons file files)
|
|
|
422 file-alist (cdr file-alist)
|
|
|
423 len (length file))
|
|
|
424 (if (> len colwid) (setq colwid len))))
|
|
|
425 (setq files (nreverse files)
|
|
|
426 colwid (+ 2 colwid) ; 2 character column gap
|
|
|
427 fmt (format "%%-%ds" colwid) ; print format
|
|
|
428 ncols (/ (window-width) colwid) ; no of columns
|
|
|
429 collen (/ nfiles ncols)) ; floor of column length
|
|
|
430 (if (> nfiles (* collen ncols)) (setq collen (1+ collen)))
|
|
|
431 ;; Output the file names in columns, sorted vertically:
|
|
|
432 (let ((i 0) j)
|
|
|
433 (while (< i collen)
|
|
|
434 (setq j i)
|
|
|
435 (while (< j nfiles)
|
|
|
436 (insert (format fmt (nth j files)))
|
|
|
437 (setq j (+ j collen)))
|
|
|
438 ;; FJW: This is completely unnecessary, but I don't like
|
|
|
439 ;; trailing white space...
|
|
|
440 (delete-region (point) (progn (skip-chars-backward " \t") (point)))
|
|
|
441 (insert ?\n)
|
|
|
442 (setq i (1+ i))))))
|
|
416
|
443
|
|
1334
|
444 (defun ls-lisp-delete-matching (regexp list)
|
|
34884
|
445 "Delete all elements matching REGEXP from LIST, return new list."
|
|
417
|
446 ;; Should perhaps use setcdr for efficiency.
|
|
416
|
447 (let (result)
|
|
|
448 (while list
|
|
34884
|
449 (or (string-match regexp (caar list))
|
|
416
|
450 (setq result (cons (car list) result)))
|
|
|
451 (setq list (cdr list)))
|
|
|
452 result))
|
|
|
453
|
|
34884
|
454 (defsubst ls-lisp-string-lessp (s1 s2)
|
|
|
455 "Return t if string S1 is less than string S2 in lexicographic order.
|
|
|
456 Case is significant if `ls-lisp-ignore-case' is nil.
|
|
|
457 Unibyte strings are converted to multibyte for comparison."
|
|
|
458 (let ((u (compare-strings s1 0 nil s2 0 nil ls-lisp-ignore-case)))
|
|
|
459 (and (numberp u) (< u 0))))
|
|
|
460
|
|
1334
|
461 (defun ls-lisp-handle-switches (file-alist switches)
|
|
34884
|
462 "Return new FILE-ALIST sorted according to SWITCHES.
|
|
|
463 SWITCHES is a list of characters. Default sorting is alphabetic."
|
|
416
|
464 ;; FILE-ALIST's elements are (FILE . FILE-ATTRIBUTES).
|
|
34884
|
465 (or (memq ?U switches) ; unsorted
|
|
|
466 ;; Catch and ignore unexpected sorting errors
|
|
|
467 (condition-case err
|
|
|
468 (setq file-alist
|
|
|
469 (let (index)
|
|
|
470 ;; Copy file-alist in case of error
|
|
|
471 (sort (copy-sequence file-alist) ; modifies its argument!
|
|
|
472 (cond ((memq ?S switches)
|
|
|
473 (lambda (x y) ; sorted on size
|
|
|
474 ;; 7th file attribute is file size
|
|
|
475 ;; Make largest file come first
|
|
|
476 (< (nth 7 (cdr y))
|
|
|
477 (nth 7 (cdr x)))))
|
|
|
478 ((setq index (ls-lisp-time-index switches))
|
|
|
479 (lambda (x y) ; sorted on time
|
|
|
480 (ls-lisp-time-lessp (nth index (cdr y))
|
|
|
481 (nth index (cdr x)))))
|
|
|
482 ((memq ?X switches)
|
|
|
483 (lambda (x y) ; sorted on extension
|
|
|
484 (ls-lisp-string-lessp
|
|
|
485 (ls-lisp-extension (car x))
|
|
|
486 (ls-lisp-extension (car y)))))
|
|
|
487 (t
|
|
|
488 (lambda (x y) ; sorted alphabetically
|
|
|
489 (ls-lisp-string-lessp (car x) (car y))))))))
|
|
|
490 (error (message "Unsorted (ls-lisp sorting error) - %s"
|
|
|
491 (error-message-string err))
|
|
|
492 (ding) (sit-for 2)))) ; to show user the message!
|
|
|
493 (if (memq ?F switches) ; classify switch
|
|
|
494 (setq file-alist (mapcar 'ls-lisp-classify file-alist)))
|
|
|
495 (if ls-lisp-dirs-first
|
|
|
496 ;; Re-sort directories first, without otherwise changing the
|
|
|
497 ;; ordering, and reverse whole list. cadr of each element of
|
|
|
498 ;; `file-alist' is t for directory, string (name linked to) for
|
|
|
499 ;; symbolic link, or nil.
|
|
|
500 (let (el dirs files)
|
|
|
501 (while file-alist
|
|
67079
|
502 (if (or (eq (cadr (setq el (car file-alist))) t) ; directory
|
|
|
503 (and (stringp (cadr el))
|
|
|
504 (file-directory-p (cadr el)))) ; symlink to a directory
|
|
34884
|
505 (setq dirs (cons el dirs))
|
|
|
506 (setq files (cons el files)))
|
|
|
507 (setq file-alist (cdr file-alist)))
|
|
|
508 (setq file-alist
|
|
|
509 (if (memq ?U switches) ; unsorted order is reversed
|
|
|
510 (nconc dirs files)
|
|
|
511 (nconc files dirs)
|
|
|
512 ))))
|
|
|
513 ;; Finally reverse file alist if necessary.
|
|
|
514 ;; (eq below MUST compare `(not (memq ...))' to force comparison of
|
|
|
515 ;; `t' or `nil', rather than list tails!)
|
|
|
516 (if (eq (eq (not (memq ?U switches)) ; unsorted order is reversed
|
|
|
517 (not (memq ?r switches))) ; reversed sort order requested
|
|
|
518 ls-lisp-dirs-first) ; already reversed
|
|
|
519 (nreverse file-alist)
|
|
|
520 file-alist))
|
|
|
521
|
|
|
522 (defun ls-lisp-classify (filedata)
|
|
|
523 "Append a character to each file name indicating the file type.
|
|
|
524 Also, for regular files that are executable, append `*'.
|
|
|
525 The file type indicators are `/' for directories, `@' for symbolic
|
|
|
526 links, `|' for FIFOs, `=' for sockets, and nothing for regular files.
|
|
63504
|
527 \[But FIFOs and sockets are not recognized.]
|
|
34884
|
528 FILEDATA has the form (filename . `file-attributes'). Its `cadr' is t
|
|
|
529 for directory, string (name linked to) for symbolic link, or nil."
|
|
67079
|
530 (let ((file-name (car filedata))
|
|
|
531 (type (cadr filedata)))
|
|
|
532 (cond (type
|
|
34884
|
533 (cons
|
|
67079
|
534 (concat file-name (if (eq type t) "/" "@"))
|
|
34884
|
535 (cdr filedata)))
|
|
|
536 ((string-match "x" (nth 9 filedata))
|
|
|
537 (cons
|
|
|
538 (concat file-name "*")
|
|
|
539 (cdr filedata)))
|
|
|
540 (t filedata))))
|
|
|
541
|
|
|
542 (defun ls-lisp-extension (filename)
|
|
|
543 "Return extension of FILENAME (ignoring any version extension)
|
|
|
544 FOLLOWED by null and full filename, SOLELY for full alpha sort."
|
|
|
545 ;; Force extension sort order: `no ext' then `null ext' then `ext'
|
|
|
546 ;; to agree with GNU ls.
|
|
|
547 (concat
|
|
|
548 (let* ((i (length filename)) end)
|
|
|
549 (if (= (aref filename (1- i)) ?.) ; null extension
|
|
|
550 "\0"
|
|
|
551 (while (and (>= (setq i (1- i)) 0)
|
|
|
552 (/= (aref filename i) ?.)))
|
|
|
553 (if (< i 0) "\0\0" ; no extension
|
|
|
554 (if (/= (aref filename (1+ i)) ?~)
|
|
|
555 (substring filename (1+ i))
|
|
|
556 ;; version extension found -- ignore it
|
|
|
557 (setq end i)
|
|
|
558 (while (and (>= (setq i (1- i)) 0)
|
|
|
559 (/= (aref filename i) ?.)))
|
|
|
560 (if (< i 0) "\0\0" ; no extension
|
|
|
561 (substring filename (1+ i) end))))
|
|
|
562 )) "\0" filename))
|
|
183
|
563
|
|
626
|
564 ;; From Roland McGrath. Can use this to sort on time.
|
|
1334
|
565 (defun ls-lisp-time-lessp (time0 time1)
|
|
34884
|
566 "Return t if time TIME0 is earlier than time TIME1."
|
|
|
567 (let ((hi0 (car time0)) (hi1 (car time1)))
|
|
626
|
568 (or (< hi0 hi1)
|
|
|
569 (and (= hi0 hi1)
|
|
34884
|
570 (< (cadr time0) (cadr time1))))))
|
|
626
|
571
|
|
34884
|
572 (defun ls-lisp-format (file-name file-attr file-size switches time-index now)
|
|
|
573 "Format one line of long ls output for file FILE-NAME.
|
|
|
574 FILE-ATTR and FILE-SIZE give the file's attributes and size.
|
|
|
575 SWITCHES, TIME-INDEX and NOW give the full switch list and time data."
|
|
|
576 (let ((file-type (nth 0 file-attr))
|
|
|
577 ;; t for directory, string (name linked to)
|
|
|
578 ;; for symbolic link, or nil.
|
|
|
579 (drwxrwxrwx (nth 8 file-attr))) ; attribute string ("drwxrwxrwx")
|
|
416
|
580 (concat (if (memq ?i switches) ; inode number
|
93697
513fb6886f41
(ls-lisp-format): Support inodes that are 2- or 3-member cons cells.
Eli Zaretskii <eliz@gnu.org>
diff
changeset
|
581 (let ((inode (nth 10 file-attr)))
|
513fb6886f41
(ls-lisp-format): Support inodes that are 2- or 3-member cons cells.
Eli Zaretskii <eliz@gnu.org>
diff
changeset
|
582 (if (consp inode)
|
513fb6886f41
(ls-lisp-format): Support inodes that are 2- or 3-member cons cells.
Eli Zaretskii <eliz@gnu.org>
diff
changeset
|
583 (if (consp (cdr inode))
|
|
94341
|
584 ;; 2^(24+16) = 1099511627776.0, but
|
|
|
585 ;; multiplying by it and then adding the
|
|
|
586 ;; other members of the cons cell in one go
|
|
|
587 ;; loses precision, since a double does not
|
|
|
588 ;; have enough significant digits to hold a
|
|
|
589 ;; full 64-bit value. So below we split
|
|
|
590 ;; 1099511627776 into high 13 and low 5
|
|
|
591 ;; digits and compute in two parts.
|
|
|
592 (let ((p1 (* (car inode) 10995116.0))
|
|
|
593 (p2 (+ (* (car inode) 27776.0)
|
|
|
594 (* (cadr inode) 65536.0)
|
|
|
595 (cddr inode))))
|
|
|
596 (format " %13.0f%05.0f "
|
|
|
597 ;; Use floor to emulate integer
|
|
|
598 ;; division.
|
|
|
599 (+ p1 (floor p2 100000.0))
|
|
|
600 (mod p2 100000.0)))
|
|
|
601 (format " %18.0f "
|
93697
513fb6886f41
(ls-lisp-format): Support inodes that are 2- or 3-member cons cells.
Eli Zaretskii <eliz@gnu.org>
diff
changeset
|
602 (+ (* (car inode) 65536.0)
|
513fb6886f41
(ls-lisp-format): Support inodes that are 2- or 3-member cons cells.
Eli Zaretskii <eliz@gnu.org>
diff
changeset
|
603 (cdr inode))))
|
|
94341
|
604 (format " %18d " inode))))
|
|
417
|
605 ;; nil is treated like "" in concat
|
|
416
|
606 (if (memq ?s switches) ; size in K
|
|
94345
|
607 (format ls-lisp-filesize-f-fmt
|
|
|
608 (fceiling (/ file-size 1024.0))))
|
|
34884
|
609 drwxrwxrwx ; attribute string
|
|
|
610 (if (memq 'links ls-lisp-verbosity)
|
|
94345
|
611 (format "%3d" (nth 1 file-attr))) ; link count
|
|
34884
|
612 ;; Numeric uid/gid are more confusing than helpful;
|
|
416
|
613 ;; Emacs should be able to make strings of them.
|
|
34884
|
614 ;; They tend to be bogus on non-UNIX platforms anyway so
|
|
|
615 ;; optionally hide them.
|
|
|
616 (if (memq 'uid ls-lisp-verbosity)
|
|
53320
|
617 ;; uid can be a sting or an integer
|
|
34884
|
618 (let ((uid (nth 2 file-attr)))
|
|
94345
|
619 (format (if (stringp uid)
|
|
|
620 ls-lisp-uid-s-fmt
|
|
|
621 ls-lisp-uid-d-fmt)
|
|
|
622 uid)))
|
|
34884
|
623 (if (not (memq ?G switches)) ; GNU ls -- shows group by default
|
|
|
624 (if (or (memq ?g switches) ; UNIX ls -- no group by default
|
|
|
625 (memq 'gid ls-lisp-verbosity))
|
|
53320
|
626 (let ((gid (nth 3 file-attr)))
|
|
94345
|
627 (format (if (stringp gid)
|
|
|
628 ls-lisp-gid-s-fmt
|
|
|
629 ls-lisp-gid-d-fmt)
|
|
|
630 gid))))
|
50767
5e248d2a95e7
(ls-lisp-format-file-size): New function to implement "-h" switch.
Juanma Barranquero <lekktu@gmail.com>
diff
changeset
|
631 (ls-lisp-format-file-size file-size (memq ?h switches))
|
|
34884
|
632 " "
|
|
|
633 (ls-lisp-format-time file-attr time-index now)
|
622
1d4abb4dfecb
(dired-lisp-format-time): in Emacs 19 we can format times.
Sebastian Kremer <sk@thp.uni-koeln.de>
diff
changeset
|
634 " "
|
|
57219
|
635 (propertize file-name 'dired-filename t)
|
|
183
|
636 (if (stringp file-type) ; is a symbolic link
|
|
34884
|
637 (concat " -> " file-type))
|
|
183
|
638 "\n"
|
|
|
639 )))
|
|
|
640
|
|
1334
|
641 (defun ls-lisp-time-index (switches)
|
|
34884
|
642 "Return time index into file-attributes according to ls SWITCHES list.
|
|
|
643 Return nil if no time switch found."
|
|
|
644 ;; FJW: Default of nil is IMPORTANT and used in `ls-lisp-handle-switches'!
|
|
|
645 (cond ((memq ?c switches) 6) ; last mode change
|
|
|
646 ((memq ?t switches) 5) ; last modtime
|
|
|
647 ((memq ?u switches) 4))) ; last access
|
|
626
|
648
|
|
40755
|
649 (defun ls-lisp-time-to-seconds (time)
|
|
|
650 "Convert TIME to a floating point number."
|
|
|
651 (+ (* (car time) 65536.0)
|
|
|
652 (cadr time)
|
|
|
653 (/ (or (nth 2 time) 0) 1000000.0)))
|
|
|
654
|
|
34884
|
655 (defun ls-lisp-format-time (file-attr time-index now)
|
|
|
656 "Format time for file with attributes FILE-ATTR according to TIME-INDEX.
|
|
|
657 Use the same method as ls to decide whether to show time-of-day or year,
|
|
|
658 depending on distance between file date and NOW.
|
|
|
659 All ls time options, namely c, t and u, are handled."
|
|
|
660 (let* ((time (nth (or time-index 5) file-attr)) ; default is last modtime
|
|
40755
|
661 (diff (- (ls-lisp-time-to-seconds time)
|
|
|
662 (ls-lisp-time-to-seconds now)))
|
|
|
663 ;; Consider a time to be recent if it is within the past six
|
|
|
664 ;; months. A Gregorian year has 365.2425 * 24 * 60 * 60 ==
|
|
|
665 ;; 31556952 seconds on the average, and half of that is 15778476.
|
|
|
666 ;; Write the constant explicitly to avoid roundoff error.
|
|
|
667 (past-cutoff -15778476)) ; half a Gregorian year
|
|
24660
|
668 (condition-case nil
|
|
40755
|
669 ;; Use traditional time format in the C or POSIX locale,
|
|
|
670 ;; ISO-style time format otherwise, so columns line up.
|
|
|
671 (let ((locale system-time-locale))
|
|
|
672 (if (not locale)
|
|
|
673 (let ((vars '("LC_ALL" "LC_TIME" "LANG")))
|
|
|
674 (while (and vars (not (setq locale (getenv (car vars)))))
|
|
|
675 (setq vars (cdr vars)))))
|
|
|
676 (if (member locale '("C" "POSIX"))
|
|
|
677 (setq locale nil))
|
|
|
678 (format-time-string
|
|
|
679 (if (and (<= past-cutoff diff) (<= diff 0))
|
|
75426
|
680 (if (and locale (not ls-lisp-use-localized-time-format))
|
|
|
681 "%m-%d %H:%M"
|
|
|
682 (nth 0 ls-lisp-format-time-list))
|
|
|
683 (if (and locale (not ls-lisp-use-localized-time-format))
|
|
|
684 "%Y-%m-%d "
|
|
|
685 (nth 1 ls-lisp-format-time-list)))
|
|
40755
|
686 time))
|
|
24854
|
687 (error "Unk 0 0000"))))
|
622
1d4abb4dfecb
(dired-lisp-format-time): in Emacs 19 we can format times.
Sebastian Kremer <sk@thp.uni-koeln.de>
diff
changeset
|
688
|
50767
5e248d2a95e7
(ls-lisp-format-file-size): New function to implement "-h" switch.
Juanma Barranquero <lekktu@gmail.com>
diff
changeset
|
689 (defun ls-lisp-format-file-size (file-size human-readable)
|
|
94345
|
690 (if (not human-readable)
|
|
|
691 (format (if (floatp file-size)
|
|
|
692 ls-lisp-filesize-f-fmt
|
|
|
693 ls-lisp-filesize-d-fmt)
|
|
|
694 file-size)
|
|
|
695 (if (< file-size 1024)
|
|
|
696 (format " %4d" file-size)
|
|
|
697 (do ((file-size (/ file-size 1024.0) (/ file-size 1024.0))
|
|
|
698 ;; kilo, mega, giga, tera, peta, exa
|
|
|
699 (post-fixes (list "k" "M" "G" "T" "P" "E") (cdr post-fixes)))
|
|
|
700 ((< file-size 1024)
|
|
|
701 (format " %3.0f%s" file-size (car post-fixes)))))))
|
50767
5e248d2a95e7
(ls-lisp-format-file-size): New function to implement "-h" switch.
Juanma Barranquero <lekktu@gmail.com>
diff
changeset
|
702
|
|
1334
|
703 (provide 'ls-lisp)
|
622
1d4abb4dfecb
(dired-lisp-format-time): in Emacs 19 we can format times.
Sebastian Kremer <sk@thp.uni-koeln.de>
diff
changeset
|
704
|
|
93975
|
705 ;; arch-tag: e55f399b-05ec-425c-a6d5-f5e349c35ab4
|
|
2233
|
706 ;;; ls-lisp.el ends here
|
