#include "xfts.h"
#include "xstrtol.h"
-extern int fts_debug;
+extern bool fts_debug;
/* The official name of this program (e.g., no `g' prefix). */
#define PROGRAM_NAME "du"
/* Name under which this program was invoked. */
char *program_name;
-/* If nonzero, display counts for all files, not just directories. */
-static int opt_all = 0;
+/* If true, display counts for all files, not just directories. */
+static bool opt_all = false;
-/* If nonzero, rather than using the disk usage of each file,
+/* If true, rather than using the disk usage of each file,
use the apparent size (a la stat.st_size). */
-static int apparent_size = 0;
+static bool apparent_size = false;
-/* If nonzero, count each hard link of files with multiple links. */
-static int opt_count_all = 0;
+/* If true, count each hard link of files with multiple links. */
+static bool opt_count_all = false;
/* If true, output the NUL byte instead of a newline at the end of each line. */
static bool opt_nul_terminate_output = false;
-/* If nonzero, print a grand total at the end. */
-static int print_grand_total = 0;
+/* If true, print a grand total at the end. */
+static bool print_grand_total = false;
/* If nonzero, do not add sizes of subdirectories. */
-static int opt_separate_dirs = 0;
+static bool opt_separate_dirs = false;
/* Show the total for each directory (and file if --all) that is at
most MAX_DEPTH levels down from the root of the hierarchy. The root
is at level 0, so `du --max-depth=0' is equivalent to `du -s'. */
-static int max_depth = INT_MAX;
+static size_t max_depth = SIZE_MAX;
/* Human-readable options for output. */
static int human_output_opts;
/* Grand total size of all args, in bytes. */
static uintmax_t tot_size = 0;
-/* Nonzero indicates that du should exit with EXIT_FAILURE upon completion. */
-static int G_fail;
-
#define IS_DIR_TYPE(Type) \
((Type) == FTS_DP \
|| (Type) == FTS_DNR)
}
/* Try to insert the INO/DEV pair into the global table, HTAB.
- If the pair is successfully inserted, return zero.
- Upon failed memory allocation exit nonzero.
- If the pair is already in the table, return nonzero. */
-static int
+ Return true if the pair is successfully inserted,
+ false if the pair is already in the table. */
+static bool
hash_ins (ino_t ino, dev_t dev)
{
struct entry *ent;
if (ent_from_table == ent)
{
/* Insertion succeeded. */
- return 0;
+ return true;
}
/* That pair is already in the table, so ENT was not inserted. Free it. */
free (ent);
- return 1;
+ return false;
}
/* Initialize the hash table. */
/* This function is called once for every file system object that fts
encounters. fts does a depth-first traversal. This function knows
that and accumulates per-directory totals based on changes in
- the depth of the current entry. */
+ the depth of the current entry. It returns true on success. */
-static void
+static bool
process_file (FTS *fts, FTSENT *ent)
{
+ bool ok;
uintmax_t size;
uintmax_t size_to_print;
- static int first_call = 1;
+ size_t level;
static size_t prev_level;
static size_t n_alloc;
/* The sum of the st_size values of all entries in the single directory
/* The sum of the sizes of all entries in the hierarchy at or below the
directory at the specified level. */
static uintmax_t *sum_subdir;
- int print = 1;
+ bool print = true;
const char *file = ent->fts_path;
const struct stat *sb = ent->fts_statp;
- int skip;
+ bool skip;
/* If necessary, set FTS_SKIP before returning. */
skip = excluded_filename (exclude, ent->fts_name);
{
case FTS_NS:
error (0, ent->fts_errno, _("cannot access %s"), quote (file));
- G_fail = 1;
- return;
+ return false;
case FTS_ERR:
/* if (S_ISDIR (ent->fts_statp->st_mode) && FIXME */
error (0, ent->fts_errno, _("%s"), quote (file));
- G_fail = 1;
- return;
+ return false;
case FTS_DNR:
/* Don't return just yet, since although the directory is not readable,
we were able to stat it, so we do have a size. */
error (0, ent->fts_errno, _("cannot read directory %s"), quote (file));
- G_fail = 1;
+ ok = false;
break;
default:
+ ok = true;
break;
}
or if it's the second encounter for a skipped directory, then
return right away. */
if (ent->fts_info == FTS_D || skip)
- return;
+ return ok;
/* If the file is being excluded or if it has already been counted
via a hard link, then don't let it contribute to the sums. */
|| (!opt_count_all
&& ! S_ISDIR (sb->st_mode)
&& 1 < sb->st_nlink
- && hash_ins (sb->st_ino, sb->st_dev)))
+ && ! hash_ins (sb->st_ino, sb->st_dev)))
{
/* Note that we must not simply return here.
We still have to update prev_level and maybe propagate
some sums up the hierarchy. */
size = 0;
- print = 0;
+ print = false;
}
else
{
: ST_NBLOCKS (*sb) * ST_NBLOCKSIZE);
}
- if (first_call)
+ level = ent->fts_level;
+ size_to_print = size;
+
+ if (n_alloc == 0)
{
- n_alloc = ent->fts_level + 10;
- sum_ent = XCALLOC (uintmax_t, n_alloc);
- sum_subdir = XCALLOC (uintmax_t, n_alloc);
+ n_alloc = level + 10;
+ sum_ent = xcalloc (n_alloc, sizeof *sum_ent);
+ sum_subdir = xcalloc (n_alloc, sizeof *sum_subdir);
}
else
{
- /* FIXME: it's a shame that we need these `size_t' casts to avoid
- warnings from gcc about `comparison between signed and unsigned'.
- Probably unavoidable, assuming that the struct members
- are of type `int' (historical), since I want variables like
- n_alloc and prev_level to have types that make sense. */
- if (n_alloc <= (size_t) ent->fts_level)
- {
- n_alloc = ent->fts_level * 2;
- sum_ent = XREALLOC (sum_ent, uintmax_t, n_alloc);
- sum_subdir = XREALLOC (sum_subdir, uintmax_t, n_alloc);
- }
- }
-
- size_to_print = size;
-
- if (! first_call)
- {
- if ((size_t) ent->fts_level == prev_level)
+ if (level == prev_level)
{
/* This is usually the most common case. Do nothing. */
}
- else if (ent->fts_level > prev_level)
+ else if (level > prev_level)
{
/* Descending the hierarchy.
Clear the accumulators for *all* levels between prev_level
and the current one. The depth may change dramatically,
e.g., from 1 to 10. */
- int i;
- for (i = prev_level + 1; i <= ent->fts_level; i++)
+ size_t i;
+
+ if (n_alloc <= level)
+ {
+ sum_ent = xnrealloc (sum_ent, level, 2 * sizeof *sum_ent);
+ sum_subdir = xnrealloc (sum_subdir, level,
+ 2 * sizeof *sum_subdir);
+ n_alloc = level * 2;
+ }
+
+ for (i = prev_level + 1; i <= level; i++)
{
sum_ent[i] = 0;
sum_subdir[i] = 0;
}
}
- else /* ent->fts_level < prev_level */
+ else /* level < prev_level */
{
/* Ascending the hierarchy.
Process a directory only after all entries in that
propagate sums from the children (prev_level) to the parent.
Here, the current level is always one smaller than the
previous one. */
- assert ((size_t) ent->fts_level == prev_level - 1);
+ assert (level == prev_level - 1);
size_to_print += sum_ent[prev_level];
if (!opt_separate_dirs)
size_to_print += sum_subdir[prev_level];
- sum_subdir[ent->fts_level] += (sum_ent[prev_level]
- + sum_subdir[prev_level]);
+ sum_subdir[level] += sum_ent[prev_level] + sum_subdir[prev_level];
}
}
- prev_level = ent->fts_level;
- first_call = 0;
+ prev_level = level;
/* Let the size of a directory entry contribute to the total for the
containing directory, unless --separate-dirs (-S) is specified. */
if ( ! (opt_separate_dirs && IS_DIR_TYPE (ent->fts_info)))
- sum_ent[ent->fts_level] += size;
+ sum_ent[level] += size;
/* Even if this directory is unreadable or we can't chdir into it,
do let its size contribute to the total, ... */
/* ... but don't print out a total for it, since without the size(s)
of any potential entries, it could be very misleading. */
if (ent->fts_info == FTS_DNR)
- return;
+ return ok;
/* If we're not counting an entry, e.g., because it's a hard link
to a file we've already counted (and --count-links), then don't
print a line for it. */
if (!print)
- return;
+ return ok;
- if ((IS_DIR_TYPE (ent->fts_info) && ent->fts_level <= max_depth)
- || ((opt_all && ent->fts_level <= max_depth) || ent->fts_level == 0))
+ if ((IS_DIR_TYPE (ent->fts_info) && level <= max_depth)
+ || ((opt_all && level <= max_depth) || level == 0))
{
print_only_size (size_to_print);
fputc ('\t', stdout);
fputc (opt_nul_terminate_output ? '\0' : '\n', stdout);
fflush (stdout);
}
+
+ return ok;
}
/* Recursively print the sizes of the directories (and, if selected, files)
named in FILES, the last entry of which is NULL.
BIT_FLAGS controls how fts works.
- If the fts_open call fails, exit nonzero.
- Otherwise, return nonzero upon error. */
+ Return true if successful. */
static bool
du_files (char **files, int bit_flags)
{
- bool fail = false;
+ bool ok = true;
if (*files)
{
{
/* FIXME: try to give a better message */
error (0, errno, _("fts_read failed"));
- fail = true;
+ ok = false;
}
break;
}
FTS_CROSS_CHECK (fts);
- process_file (fts, ent);
+ ok &= process_file (fts, ent);
}
/* Ignore failure, since the only way it can do so is in failing to
if (print_grand_total)
print_size (tot_size, _("total"));
- return fail;
+ return ok;
}
int
{
int c;
char *cwd_only[2];
- int max_depth_specified = 0;
+ bool max_depth_specified = false;
char **files;
- bool fail;
+ bool ok = true;
char *files_from = NULL;
struct Tokens tok;
/* Bit flags that control how fts works. */
int bit_flags = FTS_PHYSICAL | FTS_TIGHT_CYCLE_CHECK;
- /* If nonzero, display only a total for each argument. */
- int opt_summarize_only = 0;
+ /* If true, display only a total for each argument. */
+ bool opt_summarize_only = false;
cwd_only[0] = ".";
cwd_only[1] = NULL;
human_output_opts = human_options (getenv ("DU_BLOCK_SIZE"), false,
&output_block_size);
- fail = false;
while ((c = getopt_long (argc, argv, DEBUG_OPT "0abchHklmsxB:DLPSX:",
long_options, NULL)) != -1)
{
- long int tmp_long;
switch (c)
{
case 0: /* Long option. */
#if DU_DEBUG
case 'd':
- fts_debug = 1;
+ fts_debug = true;
break;
#endif
break;
case 'a':
- opt_all = 1;
+ opt_all = true;
break;
case APPARENT_SIZE_OPTION:
- apparent_size = 1;
+ apparent_size = true;
break;
case 'b':
- apparent_size = 1;
+ apparent_size = true;
human_output_opts = 0;
output_block_size = 1;
break;
case 'c':
- print_grand_total = 1;
+ print_grand_total = true;
break;
case 'h':
break;
case MAX_DEPTH_OPTION: /* --max-depth=N */
- if (xstrtol (optarg, NULL, 0, &tmp_long, NULL) == LONGINT_OK
- && 0 <= tmp_long && tmp_long <= INT_MAX)
- {
- max_depth_specified = 1;
- max_depth = (int) tmp_long;
- }
- else
- {
- error (0, 0, _("invalid maximum depth %s"),
- quote (optarg));
- fail = true;
- }
+ {
+ unsigned long int tmp_ulong;
+ if (xstrtoul (optarg, NULL, 0, &tmp_ulong, NULL) == LONGINT_OK
+ && tmp_ulong <= SIZE_MAX)
+ {
+ max_depth_specified = true;
+ max_depth = tmp_ulong;
+ }
+ else
+ {
+ error (0, 0, _("invalid maximum depth %s"),
+ quote (optarg));
+ ok = false;
+ }
+ }
break;
case 'm': /* obsolescent: FIXME: remove in 2005. */
break;
case 'l':
- opt_count_all = 1;
+ opt_count_all = true;
break;
case 's':
- opt_summarize_only = 1;
+ opt_summarize_only = true;
break;
case 'x':
break;
case 'S':
- opt_separate_dirs = 1;
+ opt_separate_dirs = true;
break;
case 'X':
EXCLUDE_WILDCARDS, '\n'))
{
error (0, errno, "%s", quotearg_colon (optarg));
- fail = true;
+ ok = false;
}
break;
case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
default:
- fail = true;
+ ok = false;
}
}
- if (fail)
+ if (!ok)
usage (EXIT_FAILURE);
- if (opt_all && opt_summarize_only)
+ if (opt_all & opt_summarize_only)
{
error (0, 0, _("cannot both summarize and show all entries"));
usage (EXIT_FAILURE);
if (opt_summarize_only && max_depth_specified && max_depth != 0)
{
- error (0, 0,
- _("warning: summarizing conflicts with --max-depth=%d"),
- max_depth);
+ unsigned long int d = max_depth;
+ error (0, 0, _("warning: summarizing conflicts with --max-depth=%lu"), d);
usage (EXIT_FAILURE);
}
}
}
- fail = (i != j);
+ ok = (i == j);
}
- fail |= du_files (files, bit_flags);
+ ok &= du_files (files, bit_flags);
/* This isn't really necessary, but it does ensure we
exercise this function. */
hash_free (htab);
- exit (fail || G_fail ? EXIT_FAILURE : EXIT_SUCCESS);
+ exit (ok ? EXIT_SUCCESS : EXIT_FAILURE);
}
projects / thirdparty / coreutils.git / commitdiff
