1 ;;; ls-lisp.el --- emulate insert-directory completely in Emacs Lisp
3 ;; Copyright (C) 1992, 1994, 2000, 2001, 2002, 2003, 2004,
4 ;; 2005, 2006, 2007 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
11 ;; This file is part of GNU Emacs.
13 ;; GNU Emacs is free software; you can redistribute it and/or modify
14 ;; it under the terms of the GNU General Public License as published by
15 ;; the Free Software Foundation; either version 2, or (at your option)
18 ;; GNU Emacs is distributed in the hope that it will be useful,
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.
23 ;; You should have received a copy of the GNU General Public License
24 ;; along with GNU Emacs; see the file COPYING. If not, write to the
25 ;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
26 ;; Boston, MA 02110-1301, USA.
30 ;; OVERVIEW ==========================================================
32 ;; This file redefines the function `insert-directory' to implement it
33 ;; directly from Emacs lisp, without running ls in a subprocess. It
34 ;; is useful if you cannot afford to fork Emacs on a real memory UNIX,
35 ;; under VMS or other non-UNIX platforms if you don't have the ls
36 ;; program, or if you want a different format from what ls offers.
38 ;; This function can use regexps instead of shell wildcards. If you
39 ;; enter regexps remember to double each $ sign. For example, to
40 ;; include files *.el, enter `.*\.el$$', resulting in the regexp
43 ;; RESTRICTIONS ======================================================
45 ;; * A few obscure ls switches are still ignored: see the docstring of
46 ;; `insert-directory'.
48 ;; TO DO =============================================================
50 ;; Complete handling of F switch (if/when possible).
52 ;; FJW: May be able to sort much faster by consing the sort key onto
53 ;; the front of each list element, sorting and then stripping the key
58 ;; Written originally by Sebastian Kremer <sk@thp.uni-koeln.de>
59 ;; Revised by Andrew Innes and Geoff Volker (and maybe others).
61 ;; Modified by Francis J. Wright <F.J.Wright@maths.qmw.ac.uk>, mainly
62 ;; to support many more ls options, "platform emulation" and more
67 (eval-when-compile (require 'cl
))
70 "Emulate the ls program completely in Emacs Lisp."
74 (defcustom ls-lisp-emulation
75 (cond ((eq system-type
'macos
) 'MacOS
)
76 ;; ((eq system-type 'windows-nt) 'MS-Windows)
78 '(hpux dgux usg-unix-v unisoft-unix rtu irix berkeley-unix
))
79 'UNIX
)) ; very similar to GNU
80 ;; Anything else defaults to nil, meaning GNU.
81 "*Platform to emulate: GNU (default), MacOS, MS-Windows, UNIX.
82 Corresponding value is one of the atoms: nil, MacOS, MS-Windows, UNIX.
83 Sets default values for: `ls-lisp-ignore-case', `ls-lisp-dirs-first',
84 `ls-lisp-verbosity'. Need not match actual platform. Changing this
85 option will have no effect until you restart Emacs."
86 :type
'(choice (const :tag
"GNU" nil
)
92 (defcustom ls-lisp-ignore-case
93 ;; Name change for consistency with other option names.
94 (or (memq ls-lisp-emulation
'(MS-Windows MacOS
))
95 (and (boundp 'ls-lisp-dired-ignore-case
) ls-lisp-dired-ignore-case
))
96 "*Non-nil causes ls-lisp alphabetic sorting to ignore case."
100 (defcustom ls-lisp-dirs-first
(eq ls-lisp-emulation
'MS-Windows
)
101 "*Non-nil causes ls-lisp to sort directories first in any ordering.
102 \(Or last if it is reversed.) Follows Microsoft Windows Explorer."
103 ;; Functionality suggested by Chris McMahan <cmcmahan@one.net>
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 ;; Functionality suggested by Howard Melman <howard@silverstream.com>
128 :type
'(set (const :tag
"Show Link Count" links
)
129 (const :tag
"Show User" uid
)
130 (const :tag
"Show Group" gid
))
133 (defcustom ls-lisp-use-insert-directory-program
134 (not (memq system-type
'(macos ms-dos windows-nt
)))
135 "*Non-nil causes ls-lisp to revert back to using `insert-directory-program'.
136 This is useful on platforms where ls-lisp is dumped into Emacs, such as
137 Microsoft Windows, but you would still like to use a program to list
138 the contents of a directory."
142 ;;; Autoloaded because it is let-bound in `recover-session', `mail-recover-1'.
144 (defcustom ls-lisp-support-shell-wildcards t
145 "*Non-nil means ls-lisp treats file patterns as shell wildcards.
146 Otherwise they are treated as Emacs regexps (for backward compatibility)."
150 (defcustom ls-lisp-format-time-list
153 "*List of `format-time-string' specs to display file time stamps.
154 These specs are used ONLY if a valid locale can not be determined.
156 If `ls-lisp-use-localized-time-format' is non-nil, these specs are used
157 regardless of whether the locale can be determined.
159 Syntax: (EARLY-TIME-FORMAT OLD-TIME-FORMAT)
161 The EARLY-TIME-FORMAT is used if file has been modified within the
162 current year. The OLD-TIME-FORMAT is used for older files. To use ISO
163 8601 dates, you could set:
165 \(setq ls-lisp-format-time-list
168 :type
'(list (string :tag
"Early time format")
169 (string :tag
"Old time format"))
172 (defcustom ls-lisp-use-localized-time-format nil
173 "*Non-nil causes ls-lisp to use `ls-lisp-format-time-list' even if
174 a valid locale is specified.
176 WARNING: Using localized date/time format might cause Dired columns
177 to fail to lign up, e.g. if month names are not all of the same length."
181 (defvar original-insert-directory nil
182 "This holds the original function definition of `insert-directory'.")
184 ;; Remember the original insert-directory function
185 (or (featurep 'ls-lisp
) ; FJW: unless this file is being reloaded!
186 (setq original-insert-directory
(symbol-function 'insert-directory
)))
189 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
191 (defun insert-directory (file switches
&optional wildcard full-directory-p
)
192 "Insert directory listing for FILE, formatted according to SWITCHES.
193 Leaves point after the inserted text.
194 SWITCHES may be a string of options, or a list of strings.
195 Optional third arg WILDCARD means treat FILE as shell wildcard.
196 Optional fourth arg FULL-DIRECTORY-P means file is a directory and
197 switches do not contain `d', so that a full listing is expected.
199 This version of the function comes from `ls-lisp.el'.
200 If the value of `ls-lisp-use-insert-directory-program' is non-nil then
201 it works exactly like the version from `files.el' and runs a directory
202 listing program whose name is in the variable
203 `insert-directory-program'; if also WILDCARD is non-nil then it runs
204 the shell specified by `shell-file-name'. If the value of
205 `ls-lisp-use-insert-directory-program' is nil then it runs a Lisp
208 The Lisp emulation does not run any external programs or shells. It
209 supports ordinary shell wildcards if `ls-lisp-support-shell-wildcards'
210 is non-nil; otherwise, it interprets wildcards as regular expressions
211 to match file names. It does not support all `ls' switches -- those
212 that work are: A a c i r S s t u U X g G B C R and F partly."
213 (if ls-lisp-use-insert-directory-program
214 (funcall original-insert-directory
215 file switches wildcard full-directory-p
)
216 ;; We need the directory in order to find the right handler.
217 (let ((handler (find-file-name-handler (expand-file-name file
)
221 (funcall handler
'insert-directory file switches
222 wildcard full-directory-p
)
223 ;; Remove --dired switch
224 (if (string-match "--dired " switches
)
225 (setq switches
(replace-match "" nil nil switches
)))
226 ;; Convert SWITCHES to a list of characters.
227 (setq switches
(delete ?-
(append switches nil
)))
228 ;; Sometimes we get ".../foo*/" as FILE. While the shell and
229 ;; `ls' don't mind, we certainly do, because it makes us think
230 ;; there is no wildcard, only a directory name.
231 (if (and ls-lisp-support-shell-wildcards
232 (string-match "[[?*]" file
)
233 ;; Prefer an existing directory to wildcards, like
234 ;; dired-noselect does.
235 (not (file-directory-p file
)))
237 (or (not (eq (aref file
(1- (length file
))) ?
/))
238 (setq file
(substring file
0 (1- (length file
)))))
241 (setq wildcard-regexp
242 (if ls-lisp-support-shell-wildcards
243 (wildcard-to-regexp (file-name-nondirectory file
))
244 (file-name-nondirectory file
))
245 file
(file-name-directory file
))
246 (if (memq ?B switches
) (setq wildcard-regexp
"[^~]\\'")))
247 (ls-lisp-insert-directory
248 file switches
(ls-lisp-time-index switches
)
249 wildcard-regexp full-directory-p
)
250 ;; Try to insert the amount of free space.
252 (goto-char (point-min))
253 ;; First find the line to put it on.
254 (when (re-search-forward "^total" nil t
)
255 (let ((available (get-free-disk-space ".")))
257 ;; Replace "total" with "total used", to avoid confusion.
258 (replace-match "total used in directory")
260 (insert " available " available
)))))))))
262 (defun ls-lisp-insert-directory
263 (file switches time-index wildcard-regexp full-directory-p
)
264 "Insert directory listing for FILE, formatted according to SWITCHES.
265 Leaves point after the inserted text. This is an internal function
266 optionally called by the `ls-lisp.el' version of `insert-directory'.
267 It is called recursively if the -R switch is used.
268 SWITCHES is a *list* of characters. TIME-INDEX is the time index into
269 file-attributes according to SWITCHES. WILDCARD-REGEXP is nil or an *Emacs
270 regexp*. FULL-DIRECTORY-P means file is a directory and SWITCHES does
271 not contain `d', so that a full listing is expected."
272 (if (or wildcard-regexp full-directory-p
)
273 (let* ((dir (file-name-as-directory file
))
274 (default-directory dir
) ; so that file-attributes works
276 (directory-files-and-attributes dir nil wildcard-regexp t
'string
))
279 ;; do all bindings here for speed
280 total-line files elt short file-size fil attr
)
281 (cond ((memq ?A switches
)
283 (ls-lisp-delete-matching "^\\.\\.?$" file-alist
)))
284 ((not (memq ?a switches
))
285 ;; if neither -A nor -a, flush . files
287 (ls-lisp-delete-matching "^\\." file-alist
))))
289 (ls-lisp-handle-switches file-alist switches
))
290 (if (memq ?C switches
) ; column (-C) format
291 (ls-lisp-column-format file-alist
)
292 (setq total-line
(cons (point) (car-safe file-alist
)))
293 (setq files file-alist
)
294 (while files
; long (-l) format
295 (setq elt
(car files
)
299 file-size
(nth 7 attr
))
301 (setq sum
(+ file-size
302 ;; Even if neither SUM nor file's size
303 ;; overflow, their sum could.
304 (if (or (< sum
(- 134217727 file-size
))
309 (insert (ls-lisp-format short attr file-size
310 switches time-index now
))))
311 ;; Insert total size of all files:
313 (goto-char (car total-line
))
315 ;; Shell says ``No match'' if no files match
316 ;; the wildcard; let's say something similar.
317 (insert "(No match)\n"))
318 (insert (format "total %.0f\n" (fceiling (/ sum
1024.0))))))
319 (if (memq ?R switches
)
320 ;; List the contents of all directories recursively.
321 ;; cadr of each element of `file-alist' is t for
322 ;; directory, string (name linked to) for symbolic
325 (setq elt
(car file-alist
)
326 file-alist
(cdr file-alist
))
327 (when (and (eq (cadr elt
) t
) ; directory
328 (not (string-match "\\`\\.\\.?\\'" (car elt
))))
329 (setq elt
(expand-file-name (car elt
) dir
))
330 (insert "\n" elt
":\n")
331 (ls-lisp-insert-directory
332 elt switches time-index wildcard-regexp full-directory-p
)))))
333 ;; If not full-directory-p, FILE *must not* end in /, as
334 ;; file-attributes will not recognize a symlink to a directory,
335 ;; so must make it a relative filename as ls does:
336 (if (eq (aref file
(1- (length file
))) ?
/)
337 (setq file
(substring file
0 -
1)))
338 (let ((fattr (file-attributes file
'string
)))
340 (insert (ls-lisp-format file fattr
(nth 7 fattr
)
341 switches time-index
(current-time)))
342 (message "%s: doesn't exist or is inaccessible" file
)
343 (ding) (sit-for 2))))) ; to show user the message!
345 (defun ls-lisp-column-format (file-alist)
346 "Insert the file names (only) in FILE-ALIST into the current buffer.
347 Format in columns, sorted vertically, following GNU ls -C.
348 Responds to the window width as ls should but may not!"
349 (let (files fmt ncols collen
(nfiles 0) (colwid 0))
350 ;; Count number of files as `nfiles', build list of filenames as
351 ;; `files', and find maximum filename length as `colwid':
354 (setq nfiles
(1+ nfiles
)
355 file
(caar file-alist
)
356 files
(cons file files
)
357 file-alist
(cdr file-alist
)
359 (if (> len colwid
) (setq colwid len
))))
360 (setq files
(nreverse files
)
361 colwid
(+ 2 colwid
) ; 2 character column gap
362 fmt
(format "%%-%ds" colwid
) ; print format
363 ncols
(/ (window-width) colwid
) ; no of columns
364 collen
(/ nfiles ncols
)) ; floor of column length
365 (if (> nfiles
(* collen ncols
)) (setq collen
(1+ collen
)))
366 ;; Output the file names in columns, sorted vertically:
371 (insert (format fmt
(nth j files
)))
372 (setq j
(+ j collen
)))
373 ;; FJW: This is completely unnecessary, but I don't like
374 ;; trailing white space...
375 (delete-region (point) (progn (skip-chars-backward " \t") (point)))
379 (defun ls-lisp-delete-matching (regexp list
)
380 "Delete all elements matching REGEXP from LIST, return new list."
381 ;; Should perhaps use setcdr for efficiency.
384 (or (string-match regexp
(caar list
))
385 (setq result
(cons (car list
) result
)))
386 (setq list
(cdr list
)))
389 (defsubst ls-lisp-string-lessp
(s1 s2
)
390 "Return t if string S1 is less than string S2 in lexicographic order.
391 Case is significant if `ls-lisp-ignore-case' is nil.
392 Unibyte strings are converted to multibyte for comparison."
393 (let ((u (compare-strings s1
0 nil s2
0 nil ls-lisp-ignore-case
)))
394 (and (numberp u
) (< u
0))))
396 (defun ls-lisp-handle-switches (file-alist switches
)
397 "Return new FILE-ALIST sorted according to SWITCHES.
398 SWITCHES is a list of characters. Default sorting is alphabetic."
399 ;; FILE-ALIST's elements are (FILE . FILE-ATTRIBUTES).
400 (or (memq ?U switches
) ; unsorted
401 ;; Catch and ignore unexpected sorting errors
405 ;; Copy file-alist in case of error
406 (sort (copy-sequence file-alist
) ; modifies its argument!
407 (cond ((memq ?S switches
)
408 (lambda (x y
) ; sorted on size
409 ;; 7th file attribute is file size
410 ;; Make largest file come first
413 ((setq index
(ls-lisp-time-index switches
))
414 (lambda (x y
) ; sorted on time
415 (ls-lisp-time-lessp (nth index
(cdr y
))
416 (nth index
(cdr x
)))))
418 (lambda (x y
) ; sorted on extension
419 (ls-lisp-string-lessp
420 (ls-lisp-extension (car x
))
421 (ls-lisp-extension (car y
)))))
423 (lambda (x y
) ; sorted alphabetically
424 (ls-lisp-string-lessp (car x
) (car y
))))))))
425 (error (message "Unsorted (ls-lisp sorting error) - %s"
426 (error-message-string err
))
427 (ding) (sit-for 2)))) ; to show user the message!
428 (if (memq ?F switches
) ; classify switch
429 (setq file-alist
(mapcar 'ls-lisp-classify file-alist
)))
430 (if ls-lisp-dirs-first
431 ;; Re-sort directories first, without otherwise changing the
432 ;; ordering, and reverse whole list. cadr of each element of
433 ;; `file-alist' is t for directory, string (name linked to) for
434 ;; symbolic link, or nil.
437 (if (or (eq (cadr (setq el
(car file-alist
))) t
) ; directory
438 (and (stringp (cadr el
))
439 (file-directory-p (cadr el
)))) ; symlink to a directory
440 (setq dirs
(cons el dirs
))
441 (setq files
(cons el files
)))
442 (setq file-alist
(cdr file-alist
)))
444 (if (memq ?U switches
) ; unsorted order is reversed
448 ;; Finally reverse file alist if necessary.
449 ;; (eq below MUST compare `(not (memq ...))' to force comparison of
450 ;; `t' or `nil', rather than list tails!)
451 (if (eq (eq (not (memq ?U switches
)) ; unsorted order is reversed
452 (not (memq ?r switches
))) ; reversed sort order requested
453 ls-lisp-dirs-first
) ; already reversed
454 (nreverse file-alist
)
457 (defun ls-lisp-classify (filedata)
458 "Append a character to each file name indicating the file type.
459 Also, for regular files that are executable, append `*'.
460 The file type indicators are `/' for directories, `@' for symbolic
461 links, `|' for FIFOs, `=' for sockets, and nothing for regular files.
462 \[But FIFOs and sockets are not recognized.]
463 FILEDATA has the form (filename . `file-attributes'). Its `cadr' is t
464 for directory, string (name linked to) for symbolic link, or nil."
465 (let ((file-name (car filedata
))
466 (type (cadr filedata
)))
469 (concat file-name
(if (eq type t
) "/" "@"))
471 ((string-match "x" (nth 9 filedata
))
473 (concat file-name
"*")
477 (defun ls-lisp-extension (filename)
478 "Return extension of FILENAME (ignoring any version extension)
479 FOLLOWED by null and full filename, SOLELY for full alpha sort."
480 ;; Force extension sort order: `no ext' then `null ext' then `ext'
481 ;; to agree with GNU ls.
483 (let* ((i (length filename
)) end
)
484 (if (= (aref filename
(1- i
)) ?.
) ; null extension
486 (while (and (>= (setq i
(1- i
)) 0)
487 (/= (aref filename i
) ?.
)))
488 (if (< i
0) "\0\0" ; no extension
489 (if (/= (aref filename
(1+ i
)) ?~
)
490 (substring filename
(1+ i
))
491 ;; version extension found -- ignore it
493 (while (and (>= (setq i
(1- i
)) 0)
494 (/= (aref filename i
) ?.
)))
495 (if (< i
0) "\0\0" ; no extension
496 (substring filename
(1+ i
) end
))))
499 ;; From Roland McGrath. Can use this to sort on time.
500 (defun ls-lisp-time-lessp (time0 time1
)
501 "Return t if time TIME0 is earlier than time TIME1."
502 (let ((hi0 (car time0
)) (hi1 (car time1
)))
505 (< (cadr time0
) (cadr time1
))))))
507 (defun ls-lisp-format (file-name file-attr file-size switches time-index now
)
508 "Format one line of long ls output for file FILE-NAME.
509 FILE-ATTR and FILE-SIZE give the file's attributes and size.
510 SWITCHES, TIME-INDEX and NOW give the full switch list and time data."
511 (let ((file-type (nth 0 file-attr
))
512 ;; t for directory, string (name linked to)
513 ;; for symbolic link, or nil.
514 (drwxrwxrwx (nth 8 file-attr
))) ; attribute string ("drwxrwxrwx")
515 (concat (if (memq ?i switches
) ; inode number
516 (format " %6d" (nth 10 file-attr
)))
517 ;; nil is treated like "" in concat
518 (if (memq ?s switches
) ; size in K
519 (format " %4.0f" (fceiling (/ file-size
1024.0))))
520 drwxrwxrwx
; attribute string
521 (if (memq 'links ls-lisp-verbosity
)
522 (format " %3d" (nth 1 file-attr
))) ; link count
523 ;; Numeric uid/gid are more confusing than helpful;
524 ;; Emacs should be able to make strings of them.
525 ;; They tend to be bogus on non-UNIX platforms anyway so
526 ;; optionally hide them.
527 (if (memq 'uid ls-lisp-verbosity
)
528 ;; uid can be a sting or an integer
529 (let ((uid (nth 2 file-attr
)))
530 (format (if (stringp uid
) " %-8s" " %-8d") uid
)))
531 (if (not (memq ?G switches
)) ; GNU ls -- shows group by default
532 (if (or (memq ?g switches
) ; UNIX ls -- no group by default
533 (memq 'gid ls-lisp-verbosity
))
534 (let ((gid (nth 3 file-attr
)))
535 (format (if (stringp gid
) " %-8s" " %-8d") gid
))))
536 (ls-lisp-format-file-size file-size
(memq ?h switches
))
538 (ls-lisp-format-time file-attr time-index now
)
540 (propertize file-name
'dired-filename t
)
541 (if (stringp file-type
) ; is a symbolic link
542 (concat " -> " file-type
))
546 (defun ls-lisp-time-index (switches)
547 "Return time index into file-attributes according to ls SWITCHES list.
548 Return nil if no time switch found."
549 ;; FJW: Default of nil is IMPORTANT and used in `ls-lisp-handle-switches'!
550 (cond ((memq ?c switches
) 6) ; last mode change
551 ((memq ?t switches
) 5) ; last modtime
552 ((memq ?u switches
) 4))) ; last access
554 (defun ls-lisp-time-to-seconds (time)
555 "Convert TIME to a floating point number."
556 (+ (* (car time
) 65536.0)
558 (/ (or (nth 2 time
) 0) 1000000.0)))
560 (defun ls-lisp-format-time (file-attr time-index now
)
561 "Format time for file with attributes FILE-ATTR according to TIME-INDEX.
562 Use the same method as ls to decide whether to show time-of-day or year,
563 depending on distance between file date and NOW.
564 All ls time options, namely c, t and u, are handled."
565 (let* ((time (nth (or time-index
5) file-attr
)) ; default is last modtime
566 (diff (- (ls-lisp-time-to-seconds time
)
567 (ls-lisp-time-to-seconds now
)))
568 ;; Consider a time to be recent if it is within the past six
569 ;; months. A Gregorian year has 365.2425 * 24 * 60 * 60 ==
570 ;; 31556952 seconds on the average, and half of that is 15778476.
571 ;; Write the constant explicitly to avoid roundoff error.
572 (past-cutoff -
15778476)) ; half a Gregorian year
574 ;; Use traditional time format in the C or POSIX locale,
575 ;; ISO-style time format otherwise, so columns line up.
576 (let ((locale system-time-locale
))
578 (let ((vars '("LC_ALL" "LC_TIME" "LANG")))
579 (while (and vars
(not (setq locale
(getenv (car vars
)))))
580 (setq vars
(cdr vars
)))))
581 (if (member locale
'("C" "POSIX"))
584 (if (and (<= past-cutoff diff
) (<= diff
0))
585 (if (and locale
(not ls-lisp-use-localized-time-format
))
587 (nth 0 ls-lisp-format-time-list
))
588 (if (and locale
(not ls-lisp-use-localized-time-format
))
590 (nth 1 ls-lisp-format-time-list
)))
592 (error "Unk 0 0000"))))
594 (defun ls-lisp-format-file-size (file-size human-readable
)
595 (if (or (not human-readable
)
597 (format (if (floatp file-size
) " %9.0f" " %9d") file-size
)
598 (do ((file-size (/ file-size
1024.0) (/ file-size
1024.0))
599 ;; kilo, mega, giga, tera, peta, exa
600 (post-fixes (list "k" "M" "G" "T" "P" "E") (cdr post-fixes
)))
601 ((< file-size
1024) (format " %8.0f%s" file-size
(car post-fixes
))))))
605 ;;; arch-tag: e55f399b-05ec-425c-a6d5-f5e349c35ab4
606 ;;; ls-lisp.el ends here