---

du.cpp File Reference

#include <config.h>
#include <inttypes.h>
#include <stdio.h>
#include <getopt.h>
#include <sys/types.h>
#include <assert.h>
#include "system.h"
#include "error.h"
#include "exclude.h"
#include "human.h"
#include "quote.h"
#include "save-cwd.h"
#include "savedir.h"
#include "xstrtol.h"
#include "en_tree.h"

Include dependency graph for du.cpp:

Compounds
struct	entry
struct	htab
struct	String
	String class from orignal du. More...
Defines
#define	PROGRAM_NAME   "du"
#define	AUTHORS   "Torbjorn Granlund, David MacKenzie, Larry McVoy, and Paul Eggert"
#define	INITIAL_HASH_MODULE   100
#define	INITIAL_ENTRY_TAB_SIZE   70
#define	INITIAL_PATH_SIZE   100
#define	S_ISLNK(s)   0
Typedefs
typedef String	String
Enumerations
enum	{ EXCLUDE_OPTION = CHAR_MAX + 1, BLOCK_SIZE_OPTION, MAX_DEPTH_OPTION }
Functions
int	stat (const char *, struct stat *buf)
int	lstat (const char *, struct stat *buf)
void	usage (int status)
int	en_tree_init (en_tree *target)
en_tree *	en_tree_new ()
en_tree *	en_tree_seek_end (en_tree *cur)
int	en_tree_add_child (en_tree *target, en_tree *child)
void	en_tree_rdestroy (en_tree *target)
int	en_tree_remove (en_tree *target)
int	en_tree_set (en_tree *target, uintmax_t n_blocks, const char *name)
int	print_size_p (uintmax_t size, uintmax_t max_blocks, const char *name)
int	en_tree_print (en_tree *target, uintmax_t max_blocks)
int	en_tree_swap_contents (en_tree *t1, en_tree *t2)
int	en_tree_swap_children (en_tree *t1, en_tree *t2)
int	en_tree_insert_after (en_tree *target, en_tree *after)
int	en_tree_insert_before (en_tree *target, en_tree *before)
int	en_tree_swap (en_tree *t1, en_tree *t2)
int	en_tree_sort (en_tree *target)
int	en_tree_sort_r (en_tree *target)
int	fmain (int argc, char **argv)
Variables
char *	program_name

---

Define Documentation

#define PROGRAM_NAME   "du"

#define AUTHORS   "Torbjorn Granlund, David MacKenzie, Larry McVoy, and Paul Eggert"

#define INITIAL_HASH_MODULE   100

#define INITIAL_ENTRY_TAB_SIZE   70

#define INITIAL_PATH_SIZE   100

#define S_ISLNK (  s    )     0

---

Typedef Documentation

typedef struct String String

---

Enumeration Type Documentation

anonymous enum

Enumeration values: EXCLUDE_OPTION  BLOCK_SIZE_OPTION  MAX_DEPTH_OPTION  { EXCLUDE_OPTION = CHAR_MAX + 1, BLOCK_SIZE_OPTION, MAX_DEPTH_OPTION };

---

Function Documentation

int stat (  const char *   , struct stat *    buf )

int lstat (  const char *   , struct stat *    buf )

void usage (  int    status )

{ if (status != 0) fprintf (stderr, _("Try `%s --help' for more information.\n"), program_name); else { printf (_("Usage: %s [OPTION]... [FILE]...\n"), program_name); printf (_("\ Summarize disk usage of each FILE, recursively for directories.\n\ \n\ -a, --all write counts for all files, not just directories\n\ --block-size=SIZE use SIZE-byte blocks\n\ -b, --bytes print size in bytes\n\ -c, --total produce a grand total\n\ -D, --dereference-args dereference PATHs when symbolic link\n\ -h, --human-readable print sizes in human readable format (e.g., 1K 234M 2G)\n\ -H, --si likewise, but use powers of 1000 not 1024\n\ -k, --kilobytes like --block-size=1024\n\ -l, --count-links count sizes many times if hard linked\n\ -L, --dereference dereference all symbolic links\n\ -m, --megabytes like --block-size=1048576\n\ -S, --separate-dirs do not include size of subdirectories\n\ -s, --summarize display only a total for each argument\n\ -x, --one-file-system skip directories on different filesystems\n\ -X FILE, --exclude-from=FILE Exclude files that match any pattern in FILE.\n\ --exclude=PAT Exclude files that match PAT.\n\ --max-depth=N print the total for a directory (or file, with --all)\n\ only if it is N or fewer levels below the command\n\ line argument; --max-depth=0 is the same as\n\ --summarize\n\ --help display this help and exit\n\ --version output version information and exit\n\ ")); puts (_("\nReport bugs to <bug-fileutils@gnu.org>.")); } exit (status); }

int en_tree_init (  en_tree *    target )

{ if (target==NULL) return -1; target->size=0; target->next=NULL; target->prev=NULL; target->parent=NULL; target->child=NULL; target->name=NULL; return 0; }

en_tree* en_tree_new (    )

{ en_tree *new_tree; new_tree=(en_tree *) xmalloc(sizeof(en_tree)); en_tree_init(new_tree); return new_tree; }

en_tree* en_tree_seek_end (  en_tree *    cur )

{ en_tree *current; for (current=cur; current->next!=NULL; current=current->next); return current; }

int en_tree_add_child (  en_tree *    target, en_tree *    child )

{ if (target==NULL) return -1; if (target->child==NULL) target->child=child; else { en_tree *end; end=en_tree_seek_end(target->child); end->next=child; child->prev=end; } child->parent=target; return 0; }

void en_tree_rdestroy (  en_tree *    target )

{ en_tree *cur; for (cur=target->child; cur!=NULL; cur=cur->next) { en_tree_rdestroy(cur); } free(target->name); free(target); }

int en_tree_remove (  en_tree *    target )

{ if (target==NULL) return -1; // remove reference in the previous node if (target->prev!=NULL) target->prev->next=target->next; // remove reference in the next node if (target->next!=NULL) target->next->prev=target->prev; // remove reference in the parent node if (target->parent!=NULL && target->parent->child==target) target->parent->child=target->next; }

int en_tree_set (  en_tree *    target, uintmax_t    n_blocks, const char *    name )

{ target->size=n_blocks; if (target->name!=NULL) free (target->name); if (name==NULL) target->name=NULL; else target->name=strdup(name); }

int print_size_p (  uintmax_t    size, uintmax_t    max_blocks, const char *    name )

{ if (opt_percent_mode>0) { printf("%i%%\t", 100*size/max_blocks); printf("%s\n", name); } else print_size(size, name); }

int en_tree_print (  en_tree *    target, uintmax_t    max_blocks )

{ uintmax_t childtotal=(opt_percent_mode==2)?target->size:max_blocks; if (opt_root_first) print_size_p(target->size, max_blocks, target->name); if (!opt_siblings_first) if (target->child!=NULL) en_tree_print(en_tree_seek_end(target->child), childtotal); if (target->prev!=NULL) en_tree_print(target->prev, max_blocks); if (opt_siblings_first) if (target->child!=NULL) en_tree_print(en_tree_seek_end(target->child), childtotal); if (!opt_root_first) print_size_p(target->size, max_blocks, target->name); }

int en_tree_swap_contents (  en_tree *    t1, en_tree *    t2 )

{ uintmax_t size; char *name; size=t1->size; t1->size=t2->size; t2->size=size; name=t1->name; t1->name=t2->name; t2->name=name; }

int en_tree_swap_children (  en_tree *    t1, en_tree *    t2 )

{ en_tree *child=t1->child; t1->child=t2->child; t2->child=child; for (child=t1->child; child!=NULL; child=child->next) { child->parent=t1; } for (child=t2->child; child!=NULL; child=child->next) { child->parent=t2; } }

int en_tree_insert_after (  en_tree *    target, en_tree *    after )

{ after->prev=target; after->next=target->next; after->parent=target->parent; target->next=after; if (after->next!=NULL) after->next->prev=after; }

int en_tree_insert_before (  en_tree *    target, en_tree *    before )

{ before->next=target; before->prev=target->prev; before->parent=target->parent; target->prev=before; if (before->prev!=NULL) before->prev->next=before; if (before->parent!=NULL && before->parent->child==target) before->parent->child=before; }

int en_tree_swap (  en_tree *    t1, en_tree *    t2 )

{ en_tree *first, *second, *prev, *next; if (t1->next==t2) { first=t2; second=t1; } else { first=t1; second=t2; } prev=second->prev; next=first->next; en_tree_remove(first); en_tree_insert_after(prev, first); en_tree_remove(second); en_tree_insert_before(next, second); }

int en_tree_sort (  en_tree *    target )

{ en_tree *cur=target; if (target==NULL) return -1; while (target->next!=NULL) { if (target->next->size<target->size) { en_tree_swap_contents (target, target->next); en_tree_swap_children (target, target->next); //en_tree_swap(target, target->next); if (target->prev!=NULL) target=target->prev; } else target=target->next; } }

int en_tree_sort_r (  en_tree *    target )

{ en_tree *cur; en_tree_sort(target); for (cur=target; cur!=NULL; cur=cur->next) { en_tree_sort(cur->child); } }

int fmain (  int    argc, char **    argv )

{ int c; char *cwd_only[2]; int max_depth_specified = 0; /* If nonzero, display only a total for each argument. */ int opt_summarize_only = 0; cwd_only[0] = "."; cwd_only[1] = NULL; program_name = argv[0]; setlocale (LC_ALL, ""); bindtextdomain (PACKAGE, LOCALEDIR); textdomain (PACKAGE); atexit (close_stdout); exclude = new_exclude (); xstat = lstat; human_block_size (getenv ("DU_BLOCK_SIZE"), 0, &output_block_size); while ((c = getopt_long (argc, argv, "abcfhgHklmpPrsxDLSX:", long_options, NULL)) != -1) { long int tmp_long; switch (c) { case 0: /* Long option. */ break; case 'a': opt_all = 1; break; case 'b': output_block_size = 1; break; case 'c': print_totals = 1; break; case 'f': opt_siblings_first = 1; break; case 'g': output_block_size = 1024 * 1024 * 1024; break; case 'h': output_block_size = -1024; break; case 'H': output_block_size = -1000; break; case 'k': output_block_size = 1024; break; case MAX_DEPTH_OPTION: /* --max-depth=N */ if (xstrtol (optarg, NULL, 0, &tmp_long, NULL) != LONGINT_OK || tmp_long < 0 || tmp_long > INT_MAX) error (1, 0, _("invalid maximum depth %s"), quote (optarg)); max_depth_specified = 1; max_depth = (int) tmp_long; break; case 'm': output_block_size = 1024 * 1024; break; case 'l': opt_count_all = 1; break; case 'p': opt_percent_mode = 1; break; case 'P': opt_percent_mode = 2; break; case 'r': opt_root_first = 1; break; case 's': opt_summarize_only = 1; break; case 'x': opt_one_file_system = 1; break; case 'D': opt_dereference_arguments = 1; break; case 'L': xstat = stat; break; case 'S': opt_separate_dirs = 1; break; case 'X': if (add_exclude_file (add_exclude, exclude, optarg, '\n') != 0) error (1, errno, "%s", quote (optarg)); break; case EXCLUDE_OPTION: add_exclude (exclude, optarg); break; case BLOCK_SIZE_OPTION: human_block_size (optarg, 1, &output_block_size); break; case_GETOPT_HELP_CHAR; case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS); default: usage (1); } } if (opt_all && opt_summarize_only) { error (0, 0, _("cannot both summarize and show all entries")); usage (1); } if (opt_summarize_only && max_depth_specified && max_depth == 0) { error (0, 0, _("warning: summarizing is the same as using --max-depth=0")); } if (opt_summarize_only && max_depth_specified && max_depth != 0) { error (0, 0, _("warning: summarizing conflicts with --max-depth=%d"), max_depth); usage (1); } if (opt_summarize_only) max_depth = 0; /* Initialize the hash structure for inode numbers. */ hash_init (INITIAL_HASH_MODULE, INITIAL_ENTRY_TAB_SIZE); str_init (&path, INITIAL_PATH_SIZE); du_files (optind == argc ? cwd_only : argv + optind); exit (exit_status); }

---

Variable Documentation

char* program_name

---