1 ;;; ls-lisp.el --- emulate insert-directory completely in Emacs Lisp
3 ;; Copyright (C) 1992, 1994, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
4 ;; 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
6 ;; Author: Sebastian Kremer <sk@thp.uni-koeln.de>
7 ;; Modified by: Francis J. Wright <F.J.Wright@maths.qmw.ac.uk>
9 ;; Keywords: unix, dired
12 ;; This file is part of GNU Emacs.
14 ;; GNU Emacs is free software: you can redistribute it and/or modify
15 ;; it under the terms of the GNU General Public License as published by
16 ;; the Free Software Foundation, either version 3 of the License, or
17 ;; (at your option) any later version.
19 ;; GNU Emacs is distributed in the hope that it will be useful,
20 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
21 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 ;; GNU General Public License for more details.
24 ;; You should have received a copy of the GNU General Public License
25 ;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
29 ;; OVERVIEW ==========================================================
31 ;; This file redefines the function `insert-directory' to implement it
32 ;; directly from Emacs lisp, without running ls in a subprocess. It
33 ;; is useful if you cannot afford to fork Emacs on a real memory UNIX,
34 ;; or other non-UNIX platforms if you don't have the ls
35 ;; program, or if you want a different format from what ls offers.
37 ;; This function can use regexps instead of shell wildcards. If you
38 ;; enter regexps remember to double each $ sign. For example, to
39 ;; include files *.el, enter `.*\.el$$', resulting in the regexp
42 ;; RESTRICTIONS ======================================================
44 ;; * A few obscure ls switches are still ignored: see the docstring of
45 ;; `insert-directory'.
47 ;; TO DO =============================================================
49 ;; Complete handling of F switch (if/when possible).
51 ;; FJW: May be able to sort much faster by consing the sort key onto
52 ;; the front of each list element, sorting and then stripping the key
57 ;; Written originally by Sebastian Kremer <sk@thp.uni-koeln.de>
58 ;; Revised by Andrew Innes and Geoff Volker (and maybe others).
60 ;; Modified by Francis J. Wright <F.J.Wright@maths.qmw.ac.uk>, mainly
61 ;; to support many more ls options, "platform emulation" and more
66 (eval-when-compile (require 'cl
))
69 "Emulate the ls program completely in Emacs Lisp."
73 (defcustom ls-lisp-emulation
74 (cond ;; ((eq system-type 'windows-nt) 'MS-Windows)
76 '(hpux usg-unix-v irix berkeley-unix
))
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
)
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 :set-after
'(ls-lisp-emulation)
99 (defcustom ls-lisp-dirs-first
(eq ls-lisp-emulation
'MS-Windows
)
100 "Non-nil causes ls-lisp to sort directories first in any ordering.
101 \(Or last if it is reversed.) Follows Microsoft Windows Explorer."
102 ;; Functionality suggested by Chris McMahan <cmcmahan@one.net>
103 :set-after
'(ls-lisp-emulation)
107 (defcustom ls-lisp-verbosity
108 (cond ((eq ls-lisp-emulation
'MacOS
) nil
)
109 ((eq ls-lisp-emulation
'MS-Windows
)
110 (if (and (fboundp 'w32-using-nt
) (w32-using-nt))
111 '(links))) ; distinguish NT/2K from 9x
112 ((eq ls-lisp-emulation
'UNIX
) '(links uid
)) ; UNIX ls
113 (t '(links uid gid
))) ; GNU ls
114 "A list of optional file attributes that ls-lisp should display.
115 It should contain none or more of the symbols: links, uid, gid.
116 A value of nil (or an empty list) means display none of them.
118 Concepts come from UNIX: `links' means count of names associated with
119 the file; `uid' means user (owner) identifier; `gid' means group
122 If emulation is MacOS then default is nil;
123 if emulation is MS-Windows then default is `(links)' if platform is
124 Windows NT/2K, nil otherwise;
125 if emulation is UNIX then default is `(links uid)';
126 if emulation is GNU then default is `(links uid gid)'."
127 :set-after
'(ls-lisp-emulation)
128 ;; Functionality suggested by Howard Melman <howard@silverstream.com>
129 :type
'(set (const :tag
"Show Link Count" links
)
130 (const :tag
"Show User" uid
)
131 (const :tag
"Show Group" gid
))
134 (defcustom ls-lisp-use-insert-directory-program
135 (not (memq system-type
'(ms-dos windows-nt
)))
136 "Non-nil causes ls-lisp to revert back to using `insert-directory-program'.
137 This is useful on platforms where ls-lisp is dumped into Emacs, such as
138 Microsoft Windows, but you would still like to use a program to list
139 the contents of a directory."
143 ;;; Autoloaded because it is let-bound in `recover-session', `mail-recover-1'.
145 (defcustom ls-lisp-support-shell-wildcards t
146 "Non-nil means ls-lisp treats file patterns as shell wildcards.
147 Otherwise they are treated as Emacs regexps (for backward compatibility)."
151 (defcustom ls-lisp-format-time-list
154 "List of `format-time-string' specs to display file time stamps.
155 These specs are used ONLY if a valid locale can not be determined.
157 If `ls-lisp-use-localized-time-format' is non-nil, these specs are used
158 regardless of whether the locale can be determined.
160 Syntax: (EARLY-TIME-FORMAT OLD-TIME-FORMAT)
162 The EARLY-TIME-FORMAT is used if file has been modified within the
163 current year. The OLD-TIME-FORMAT is used for older files. To use ISO
164 8601 dates, you could set:
166 \(setq ls-lisp-format-time-list
169 :type
'(list (string :tag
"Early time format")
170 (string :tag
"Old time format"))
173 (defcustom ls-lisp-use-localized-time-format nil
174 "Non-nil means to always use `ls-lisp-format-time-list' for time stamps.
175 This applies even if a valid locale is specified.
177 WARNING: Using localized date/time format might cause Dired columns
178 to fail to line up, e.g. if month names are not all of the same length."
182 (defvar original-insert-directory nil
183 "This holds the original function definition of `insert-directory'.")
185 (defvar ls-lisp-uid-d-fmt
"-%d"
186 "Format to display integer UIDs.")
187 (defvar ls-lisp-uid-s-fmt
"-%s"
188 "Format to display user names.")
189 (defvar ls-lisp-gid-d-fmt
"-%d"
190 "Format to display integer GIDs.")
191 (defvar ls-lisp-gid-s-fmt
"-%s"
192 "Format to display user group names.")
193 (defvar ls-lisp-filesize-d-fmt
"%d"
194 "Format to display integer file sizes.")
195 (defvar ls-lisp-filesize-f-fmt
"%.0f"
196 "Format to display float file sizes.")
198 ;; Remember the original insert-directory function
199 (or (featurep 'ls-lisp
) ; FJW: unless this file is being reloaded!
200 (setq original-insert-directory
(symbol-function 'insert-directory
)))
203 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
205 (defun insert-directory (file switches
&optional wildcard full-directory-p
)
206 "Insert directory listing for FILE, formatted according to SWITCHES.
207 Leaves point after the inserted text.
208 SWITCHES may be a string of options, or a list of strings.
209 Optional third arg WILDCARD means treat FILE as shell wildcard.
210 Optional fourth arg FULL-DIRECTORY-P means file is a directory and
211 switches do not contain `d', so that a full listing is expected.
213 This version of the function comes from `ls-lisp.el'.
214 If the value of `ls-lisp-use-insert-directory-program' is non-nil then
215 it works exactly like the version from `files.el' and runs a directory
216 listing program whose name is in the variable
217 `insert-directory-program'; if also WILDCARD is non-nil then it runs
218 the shell specified by `shell-file-name'. If the value of
219 `ls-lisp-use-insert-directory-program' is nil then it runs a Lisp
222 The Lisp emulation does not run any external programs or shells. It
223 supports ordinary shell wildcards if `ls-lisp-support-shell-wildcards'
224 is non-nil; otherwise, it interprets wildcards as regular expressions
225 to match file names. It does not support all `ls' switches -- those
226 that work are: A a B C c F G g h i n R r S s t U u X. The l switch
227 is assumed to be always present and cannot be turned off."
228 (if ls-lisp-use-insert-directory-program
229 (funcall original-insert-directory
230 file switches wildcard full-directory-p
)
231 ;; We need the directory in order to find the right handler.
232 (let ((handler (find-file-name-handler (expand-file-name file
)
237 (funcall handler
'insert-directory file switches
238 wildcard full-directory-p
)
239 ;; Remove --dired switch
240 (if (string-match "--dired " switches
)
241 (setq switches
(replace-match "" nil nil switches
)))
242 ;; Convert SWITCHES to a list of characters.
243 (setq switches
(delete ?\
(delete ?-
(append switches nil
))))
244 ;; Sometimes we get ".../foo*/" as FILE. While the shell and
245 ;; `ls' don't mind, we certainly do, because it makes us think
246 ;; there is no wildcard, only a directory name.
247 (if (and ls-lisp-support-shell-wildcards
248 (string-match "[[?*]" file
)
249 ;; Prefer an existing file to wildcards, like
250 ;; dired-noselect does.
251 (not (file-exists-p file
)))
253 (or (not (eq (aref file
(1- (length file
))) ?
/))
254 (setq file
(substring file
0 (1- (length file
)))))
257 (setq wildcard-regexp
258 (if ls-lisp-support-shell-wildcards
259 (wildcard-to-regexp (file-name-nondirectory file
))
260 (file-name-nondirectory file
))
261 file
(file-name-directory file
))
262 (if (memq ?B switches
) (setq wildcard-regexp
"[^~]\\'")))
264 (ls-lisp-insert-directory
265 file switches
(ls-lisp-time-index switches
)
266 wildcard-regexp full-directory-p
)
268 ;; Maybe they wanted a literal file that just happens to
269 ;; use characters special to shell wildcards.
270 (if (equal (cadr err
) "Unmatched [ or [^")
272 (setq wildcard-regexp
(if (memq ?B switches
) "[^~]\\'")
273 file
(file-relative-name orig-file
))
274 (ls-lisp-insert-directory
275 file switches
(ls-lisp-time-index switches
)
276 nil full-directory-p
))
277 (signal (car err
) (cdr err
)))))
278 ;; Try to insert the amount of free space.
280 (goto-char (point-min))
281 ;; First find the line to put it on.
282 (when (re-search-forward "^total" nil t
)
283 (let ((available (get-free-disk-space ".")))
285 ;; Replace "total" with "total used", to avoid confusion.
286 (replace-match "total used in directory")
288 (insert " available " available
)))))))))
290 (defun ls-lisp-insert-directory
291 (file switches time-index wildcard-regexp full-directory-p
)
292 "Insert directory listing for FILE, formatted according to SWITCHES.
293 Leaves point after the inserted text. This is an internal function
294 optionally called by the `ls-lisp.el' version of `insert-directory'.
295 It is called recursively if the -R switch is used.
296 SWITCHES is a *list* of characters. TIME-INDEX is the time index into
297 file-attributes according to SWITCHES. WILDCARD-REGEXP is nil or an *Emacs
298 regexp*. FULL-DIRECTORY-P means file is a directory and SWITCHES does
299 not contain `d', so that a full listing is expected."
300 (if (or wildcard-regexp full-directory-p
)
301 (let* ((dir (file-name-as-directory file
))
302 (default-directory dir
) ; so that file-attributes works
304 (directory-files-and-attributes dir nil wildcard-regexp t
305 (if (memq ?n switches
)
312 ;; do all bindings here for speed
313 total-line files elt short file-size fil attr
314 fuid fgid uid-len gid-len
)
315 (cond ((memq ?A switches
)
317 (ls-lisp-delete-matching "^\\.\\.?$" file-alist
)))
318 ((not (memq ?a switches
))
319 ;; if neither -A nor -a, flush . files
321 (ls-lisp-delete-matching "^\\." file-alist
))))
323 (ls-lisp-handle-switches file-alist switches
))
324 (if (memq ?C switches
) ; column (-C) format
325 (ls-lisp-column-format file-alist
)
326 (setq total-line
(cons (point) (car-safe file-alist
)))
327 ;; Find the appropriate format for displaying uid, gid, and
328 ;; file size, by finding the longest strings among all the
329 ;; files we are about to display.
330 (dolist (elt file-alist
)
333 uid-len
(if (stringp fuid
) (string-width fuid
)
334 (length (format "%d" fuid
)))
336 gid-len
(if (stringp fgid
) (string-width fgid
)
337 (length (format "%d" fgid
)))
338 file-size
(nth 7 attr
))
339 (if (> uid-len max-uid-len
)
340 (setq max-uid-len uid-len
))
341 (if (> gid-len max-gid-len
)
342 (setq max-gid-len gid-len
))
343 (if (> file-size max-file-size
)
344 (setq max-file-size file-size
)))
345 (setq ls-lisp-uid-d-fmt
(format " %%-%dd" max-uid-len
))
346 (setq ls-lisp-uid-s-fmt
(format " %%-%ds" max-uid-len
))
347 (setq ls-lisp-gid-d-fmt
(format " %%-%dd" max-gid-len
))
348 (setq ls-lisp-gid-s-fmt
(format " %%-%ds" max-gid-len
))
349 (setq ls-lisp-filesize-d-fmt
351 (if (memq ?s switches
)
352 (length (format "%.0f"
353 (fceiling (/ max-file-size
1024.0))))
354 (length (format "%.0f" max-file-size
)))))
355 (setq ls-lisp-filesize-f-fmt
357 (if (memq ?s switches
)
358 (length (format "%.0f"
359 (fceiling (/ max-file-size
1024.0))))
360 (length (format "%.0f" max-file-size
)))))
361 (setq files file-alist
)
362 (while files
; long (-l) format
363 (setq elt
(car files
)
367 file-size
(nth 7 attr
))
369 (setq sum
(+ file-size
370 ;; Even if neither SUM nor file's size
371 ;; overflow, their sum could.
372 (if (or (< sum
(- 134217727 file-size
))
377 (insert (ls-lisp-format short attr file-size
378 switches time-index
))))
379 ;; Insert total size of all files:
381 (goto-char (car total-line
))
383 ;; Shell says ``No match'' if no files match
384 ;; the wildcard; let's say something similar.
385 (insert "(No match)\n"))
386 (insert (format "total %.0f\n" (fceiling (/ sum
1024.0))))))
387 (if (memq ?R switches
)
388 ;; List the contents of all directories recursively.
389 ;; cadr of each element of `file-alist' is t for
390 ;; directory, string (name linked to) for symbolic
393 (setq elt
(car file-alist
)
394 file-alist
(cdr file-alist
))
395 (when (and (eq (cadr elt
) t
) ; directory
396 ;; Under -F, we have already decorated all
397 ;; directories, including "." and "..", with
398 ;; a /, so allow for that as well.
399 (not (string-match "\\`\\.\\.?/?\\'" (car elt
))))
400 (setq elt
(expand-file-name (car elt
) dir
))
401 (insert "\n" elt
":\n")
402 (ls-lisp-insert-directory
403 elt switches time-index wildcard-regexp full-directory-p
)))))
404 ;; If not full-directory-p, FILE *must not* end in /, as
405 ;; file-attributes will not recognize a symlink to a directory,
406 ;; so must make it a relative filename as ls does:
407 (if (file-name-absolute-p file
) (setq file
(expand-file-name file
)))
408 (if (eq (aref file
(1- (length file
))) ?
/)
409 (setq file
(substring file
0 -
1)))
410 (let ((fattr (file-attributes file
'string
)))
412 (insert (ls-lisp-format
413 (if (memq ?F switches
)
414 (ls-lisp-classify-file file fattr
)
417 switches time-index
))
418 (message "%s: doesn't exist or is inaccessible" file
)
419 (ding) (sit-for 2))))) ; to show user the message!
421 (defun ls-lisp-column-format (file-alist)
422 "Insert the file names (only) in FILE-ALIST into the current buffer.
423 Format in columns, sorted vertically, following GNU ls -C.
424 Responds to the window width as ls should but may not!"
425 (let (files fmt ncols collen
(nfiles 0) (colwid 0))
426 ;; Count number of files as `nfiles', build list of filenames as
427 ;; `files', and find maximum filename length as `colwid':
430 (setq nfiles
(1+ nfiles
)
431 file
(caar file-alist
)
432 files
(cons file files
)
433 file-alist
(cdr file-alist
)
435 (if (> len colwid
) (setq colwid len
))))
436 (setq files
(nreverse files
)
437 colwid
(+ 2 colwid
) ; 2 character column gap
438 fmt
(format "%%-%ds" colwid
) ; print format
439 ncols
(/ (window-width) colwid
) ; no of columns
440 collen
(/ nfiles ncols
)) ; floor of column length
441 (if (> nfiles
(* collen ncols
)) (setq collen
(1+ collen
)))
442 ;; Output the file names in columns, sorted vertically:
447 (insert (format fmt
(nth j files
)))
448 (setq j
(+ j collen
)))
449 ;; FJW: This is completely unnecessary, but I don't like
450 ;; trailing white space...
451 (delete-region (point) (progn (skip-chars-backward " \t") (point)))
455 (defun ls-lisp-delete-matching (regexp list
)
456 "Delete all elements matching REGEXP from LIST, return new list."
457 ;; Should perhaps use setcdr for efficiency.
460 (or (string-match regexp
(caar list
))
461 (setq result
(cons (car list
) result
)))
462 (setq list
(cdr list
)))
465 (defsubst ls-lisp-string-lessp
(s1 s2
)
466 "Return t if string S1 is less than string S2 in lexicographic order.
467 Case is significant if `ls-lisp-ignore-case' is nil.
468 Unibyte strings are converted to multibyte for comparison."
469 (let ((u (compare-strings s1
0 nil s2
0 nil ls-lisp-ignore-case
)))
470 (and (numberp u
) (< u
0))))
472 (defun ls-lisp-handle-switches (file-alist switches
)
473 "Return new FILE-ALIST sorted according to SWITCHES.
474 SWITCHES is a list of characters. Default sorting is alphabetic."
475 ;; FILE-ALIST's elements are (FILE . FILE-ATTRIBUTES).
476 (or (memq ?U switches
) ; unsorted
477 ;; Catch and ignore unexpected sorting errors
481 ;; Copy file-alist in case of error
482 (sort (copy-sequence file-alist
) ; modifies its argument!
483 (cond ((memq ?S switches
)
484 (lambda (x y
) ; sorted on size
485 ;; 7th file attribute is file size
486 ;; Make largest file come first
489 ((setq index
(ls-lisp-time-index switches
))
490 (lambda (x y
) ; sorted on time
491 (time-less-p (nth index
(cdr y
))
492 (nth index
(cdr x
)))))
494 (lambda (x y
) ; sorted on extension
495 (ls-lisp-string-lessp
496 (ls-lisp-extension (car x
))
497 (ls-lisp-extension (car y
)))))
499 (lambda (x y
) ; sorted alphabetically
500 (ls-lisp-string-lessp (car x
) (car y
))))))))
501 (error (message "Unsorted (ls-lisp sorting error) - %s"
502 (error-message-string err
))
503 (ding) (sit-for 2)))) ; to show user the message!
504 (if (memq ?F switches
) ; classify switch
505 (setq file-alist
(mapcar 'ls-lisp-classify file-alist
)))
506 (if ls-lisp-dirs-first
507 ;; Re-sort directories first, without otherwise changing the
508 ;; ordering, and reverse whole list. cadr of each element of
509 ;; `file-alist' is t for directory, string (name linked to) for
510 ;; symbolic link, or nil.
513 (if (or (eq (cadr (setq el
(car file-alist
))) t
) ; directory
514 (and (stringp (cadr el
))
515 (file-directory-p (cadr el
)))) ; symlink to a directory
516 (setq dirs
(cons el dirs
))
517 (setq files
(cons el files
)))
518 (setq file-alist
(cdr file-alist
)))
520 (if (memq ?U switches
) ; unsorted order is reversed
524 ;; Finally reverse file alist if necessary.
525 ;; (eq below MUST compare `(not (memq ...))' to force comparison of
526 ;; `t' or `nil', rather than list tails!)
527 (if (eq (eq (not (memq ?U switches
)) ; unsorted order is reversed
528 (not (memq ?r switches
))) ; reversed sort order requested
529 ls-lisp-dirs-first
) ; already reversed
530 (nreverse file-alist
)
533 (defun ls-lisp-classify-file (filename fattr
)
534 "Append a character to FILENAME indicating the file type.
536 FATTR is the file attributes returned by `file-attributes' for the file.
537 The file type indicators are `/' for directories, `@' for symbolic
538 links, `|' for FIFOs, `=' for sockets, `*' for regular files that
539 are executable, and nothing for other types of files."
540 (let* ((type (car fattr
))
541 (modestr (nth 8 fattr
))
542 (typestr (substring modestr
0 1)))
545 (concat filename
(if (eq type t
) "/" "@")))
546 ((string-match "x" modestr
)
547 (concat filename
"*"))
548 ((string= "p" typestr
)
549 (concat filename
"|"))
550 ((string= "s" typestr
)
551 (concat filename
"="))
554 (defun ls-lisp-classify (filedata)
555 "Append a character to file name in FILEDATA indicating the file type.
557 FILEDATA has the form (FILENAME . ATTRIBUTES), where ATTRIBUTES is the
558 structure returned by `file-attributes' for that file.
560 The file type indicators are `/' for directories, `@' for symbolic
561 links, `|' for FIFOs, `=' for sockets, `*' for regular files that
562 are executable, and nothing for other types of files."
563 (let ((file-name (car filedata
))
564 (fattr (cdr filedata
)))
565 (setq file-name
(propertize file-name
'dired-filename t
))
566 (cons (ls-lisp-classify-file file-name fattr
) fattr
)))
568 (defun ls-lisp-extension (filename)
569 "Return extension of FILENAME (ignoring any version extension)
570 FOLLOWED by null and full filename, SOLELY for full alpha sort."
571 ;; Force extension sort order: `no ext' then `null ext' then `ext'
572 ;; to agree with GNU ls.
574 (let* ((i (length filename
)) end
)
575 (if (= (aref filename
(1- i
)) ?.
) ; null extension
577 (while (and (>= (setq i
(1- i
)) 0)
578 (/= (aref filename i
) ?.
)))
579 (if (< i
0) "\0\0" ; no extension
580 (if (/= (aref filename
(1+ i
)) ?~
)
581 (substring filename
(1+ i
))
582 ;; version extension found -- ignore it
584 (while (and (>= (setq i
(1- i
)) 0)
585 (/= (aref filename i
) ?.
)))
586 (if (< i
0) "\0\0" ; no extension
587 (substring filename
(1+ i
) end
))))
590 (defun ls-lisp-format (file-name file-attr file-size switches time-index
)
591 "Format one line of long ls output for file FILE-NAME.
592 FILE-ATTR and FILE-SIZE give the file's attributes and size.
593 SWITCHES and TIME-INDEX give the full switch list and time data."
594 (let ((file-type (nth 0 file-attr
))
595 ;; t for directory, string (name linked to)
596 ;; for symbolic link, or nil.
597 (drwxrwxrwx (nth 8 file-attr
))) ; attribute string ("drwxrwxrwx")
598 (concat (if (memq ?i switches
) ; inode number
599 (let ((inode (nth 10 file-attr
)))
601 (if (consp (cdr inode
))
602 ;; 2^(24+16) = 1099511627776.0, but
603 ;; multiplying by it and then adding the
604 ;; other members of the cons cell in one go
605 ;; loses precision, since a double does not
606 ;; have enough significant digits to hold a
607 ;; full 64-bit value. So below we split
608 ;; 1099511627776 into high 13 and low 5
609 ;; digits and compute in two parts.
610 (let ((p1 (* (car inode
) 10995116.0))
611 (p2 (+ (* (car inode
) 27776.0)
612 (* (cadr inode
) 65536.0)
614 (format " %13.0f%05.0f "
615 ;; Use floor to emulate integer
617 (+ p1
(floor p2
100000.0))
620 (+ (* (car inode
) 65536.0)
622 (format " %18d " inode
))))
623 ;; nil is treated like "" in concat
624 (if (memq ?s switches
) ; size in K
625 (format ls-lisp-filesize-f-fmt
626 (fceiling (/ file-size
1024.0))))
627 drwxrwxrwx
; attribute string
628 (if (memq 'links ls-lisp-verbosity
)
629 (format "%3d" (nth 1 file-attr
))) ; link count
630 ;; Numeric uid/gid are more confusing than helpful;
631 ;; Emacs should be able to make strings of them.
632 ;; They tend to be bogus on non-UNIX platforms anyway so
633 ;; optionally hide them.
634 (if (memq 'uid ls-lisp-verbosity
)
635 ;; uid can be a string or an integer
636 (let ((uid (nth 2 file-attr
)))
637 (format (if (stringp uid
)
641 (if (not (memq ?G switches
)) ; GNU ls -- shows group by default
642 (if (or (memq ?g switches
) ; UNIX ls -- no group by default
643 (memq 'gid ls-lisp-verbosity
))
644 (let ((gid (nth 3 file-attr
)))
645 (format (if (stringp gid
)
649 (ls-lisp-format-file-size file-size
(memq ?h switches
))
651 (ls-lisp-format-time file-attr time-index
)
653 (if (not (memq ?F switches
)) ; ls-lisp-classify already did that
654 (propertize file-name
'dired-filename t
)
656 (if (stringp file-type
) ; is a symbolic link
657 (concat " -> " file-type
))
661 (defun ls-lisp-time-index (switches)
662 "Return time index into file-attributes according to ls SWITCHES list.
663 Return nil if no time switch found."
664 ;; FJW: Default of nil is IMPORTANT and used in `ls-lisp-handle-switches'!
665 (cond ((memq ?c switches
) 6) ; last mode change
666 ((memq ?t switches
) 5) ; last modtime
667 ((memq ?u switches
) 4))) ; last access
669 (defun ls-lisp-format-time (file-attr time-index
)
670 "Format time for file with attributes FILE-ATTR according to TIME-INDEX.
671 Use the same method as ls to decide whether to show time-of-day or year,
672 depending on distance between file date and the current time.
673 All ls time options, namely c, t and u, are handled."
674 (let* ((time (nth (or time-index
5) file-attr
)) ; default is last modtime
675 (diff (- (float-time time
) (float-time)))
676 ;; Consider a time to be recent if it is within the past six
677 ;; months. A Gregorian year has 365.2425 * 24 * 60 * 60 ==
678 ;; 31556952 seconds on the average, and half of that is 15778476.
679 ;; Write the constant explicitly to avoid roundoff error.
680 (past-cutoff -
15778476)) ; half a Gregorian year
682 ;; Use traditional time format in the C or POSIX locale,
683 ;; ISO-style time format otherwise, so columns line up.
684 (let ((locale system-time-locale
))
686 (let ((vars '("LC_ALL" "LC_TIME" "LANG")))
687 (while (and vars
(not (setq locale
(getenv (car vars
)))))
688 (setq vars
(cdr vars
)))))
689 (if (member locale
'("C" "POSIX"))
692 (if (and (<= past-cutoff diff
) (<= diff
0))
693 (if (and locale
(not ls-lisp-use-localized-time-format
))
695 (nth 0 ls-lisp-format-time-list
))
696 (if (and locale
(not ls-lisp-use-localized-time-format
))
698 (nth 1 ls-lisp-format-time-list
)))
700 (error "Unk 0 0000"))))
702 (defun ls-lisp-format-file-size (file-size human-readable
)
703 (if (not human-readable
)
704 (format (if (floatp file-size
)
705 ls-lisp-filesize-f-fmt
706 ls-lisp-filesize-d-fmt
)
708 (if (< file-size
1024)
709 (format " %4d" file-size
)
710 (do ((file-size (/ file-size
1024.0) (/ file-size
1024.0))
711 ;; kilo, mega, giga, tera, peta, exa
712 (post-fixes (list "k" "M" "G" "T" "P" "E") (cdr post-fixes
)))
714 (format " %3.0f%s" file-size
(car post-fixes
)))))))
718 ;;; ls-lisp.el ends here