Function: eshell/du

eshell/du is a byte-compiled function defined in em-unix.el.gz.

Signature

(eshell/du &rest ARGS)

Documentation

Implementation of "du" in Lisp, passing ARGS.

Source Code

;; Defined in /usr/src/emacs/lisp/eshell/em-unix.el.gz
(defun eshell/du (&rest args)
  "Implementation of \"du\" in Lisp, passing ARGS."
  (let ((original-args args))
    (eshell-eval-using-options
     "du" args
     '((?a "all" nil show-all
           "write counts for all files, not just directories")
       (nil "block-size" t block-size
            "use SIZE-byte blocks (i.e., --block-size SIZE)")
       (?b "bytes" 1 block-size
           "print size in bytes")
       (?c "total" nil grand-total
           "produce a grand total")
       (?d "max-depth" t max-depth
           "display data only this many levels of data")
       (?h "human-readable" 1024 human-readable
           "print sizes in human readable format")
       (?H "si" 1000 human-readable
           "likewise, but use powers of 1000 not 1024")
       (?k "kilobytes" 1024 block-size
           "like --block-size 1024")
       (?L "dereference" nil dereference-links
           "dereference all symbolic links")
       (?m "megabytes" 1048576 block-size
           "like --block-size 1048576")
       (?s "summarize" 0 max-depth
           "display only a total for each argument")
       (?x "one-file-system" nil only-one-filesystem
           "skip directories on different filesystems")
       (nil "help" nil nil
            "show this usage screen")
       :external "du"
       :usage "[OPTION]... FILE...
Summarize disk usage of each FILE, recursively for directories.")
     ;; If possible, use the external "du" command.
     (when-let* (((not (seq-some
                        (lambda (i) (and (stringp i) (file-remote-p i)))
                        args)))
                 (ext-du (eshell-search-path "du")))
       (throw 'eshell-external (eshell-external-command ext-du original-args)))
     (setq block-size (or block-size 1024))
     (when (stringp block-size)
       (setq block-size (string-to-number block-size)))
     (when (stringp max-depth)
       (setq max-depth (string-to-number max-depth)))
     ;; Filesystem support means nothing under MS-Windows.
     (when (eshell-under-windows-p)
       (setq only-one-filesystem nil))
     (let ((size 0.0)
           (seen-files (make-hash-table :test #'equal))
           (print-function
            (lambda (size name)
              (let ((size-str (eshell-printable-size size human-readable
                                                     block-size t)))
                (eshell-print (concat (string-pad size-str 8) name "\n"))))))
       (dolist (arg (or args '(".")))
         (when only-one-filesystem
           (setq only-one-filesystem
                 (file-attribute-device-number
                  (eshell-file-attributes (file-name-as-directory arg)))))
         (setq size (+ size (eshell-du-sum-directory
                             (directory-file-name arg) max-depth
                             :print-function print-function :show-all show-all
                             :dereference-links dereference-links
                             :only-one-filesystem only-one-filesystem
                             :seen-files seen-files))))
       (when grand-total
         (funcall print-function size "total"))))))