Implement human-readable output and honor the unit command line options.

diff --git a/adu.c b/adu.c
index 93305d5ee865ed458b97c5149465d9a603811ea1..8077bd923cb2836816cb434b2280a19dc330d52d 100644 (file)
--- a/adu.c
+++ b/adu.c
@@ -483,6 +483,42 @@ static int get_dir_name(struct osl_row *row, char **name)
        return 1;
 }
 
+const uint64_t size_unit_divisors[] = {
+       [size_unit_arg_b] = 1ULL,
+       [size_unit_arg_k] = 1024ULL,
+       [size_unit_arg_m] = 1024ULL * 1024ULL,
+       [size_unit_arg_g] = 1024ULL * 1024ULL * 1024ULL,
+       [size_unit_arg_t] = 1024ULL * 1024ULL * 1024ULL * 1024ULL,
+};
+
+const uint64_t count_unit_divisors[] = {
+
+       [count_unit_arg_n] = 1ULL,
+       [count_unit_arg_k] = 1000ULL,
+       [count_unit_arg_m] = 1000ULL * 1000ULL,
+       [count_unit_arg_g] = 1000ULL * 1000ULL * 1000ULL,
+       [count_unit_arg_t] = 1000ULL * 1000ULL * 1000ULL * 1000ULL,
+};
+
+const char size_unit_abbrevs[] = " BKMGT";
+const char count_unit_abbrevs[] = "  KMGT";
+
+static void format_size_value(enum enum_size_unit unit, uint64_t value, char *result)
+{
+       if (unit == size_unit_arg_h) /* human readable */
+               for (unit = size_unit_arg_b; unit < size_unit_arg_t && value > size_unit_divisors[unit + 1]; unit++)
+                               ; /* nothing */
+       sprintf(result, "%llu%c", (long long unsigned)value / size_unit_divisors[unit], size_unit_abbrevs[unit]);
+}
+
+static void format_count_value(enum enum_count_unit unit, uint64_t value, char *result)
+{
+       if (unit == count_unit_arg_h) /* human readable */
+               for (unit = count_unit_arg_n; unit < count_unit_arg_t && value > count_unit_divisors[unit + 1]; unit++)
+                               ; /* nothing */
+       sprintf(result, "%llu%c", (long long unsigned)value / count_unit_divisors[unit], count_unit_abbrevs[unit]);
+}
+
 enum global_stats_flags {
        GSF_PRINT_DIRNAME = 1,
        GSF_PRINT_BYTES = 2,
@@ -499,7 +535,7 @@ static int global_stats_loop_function(struct osl_row *row, void *data)
 {
        struct global_stats_info *gsi = data;
        struct osl_object obj;
-       char *dirname;
+       char *dirname, formated_value[25];
        int ret, summary = gsi->flags & GSF_COMPUTE_SUMMARY;
 
        if (!gsi->count && !summary)
@@ -519,9 +555,12 @@ static int global_stats_loop_function(struct osl_row *row, void *data)
                if (ret < 0)
                        return ret;
                files = *(uint64_t *)obj.data;
-               if (gsi->count && (gsi->flags & GSF_PRINT_FILES))
-                       printf("%llu%s", (long long unsigned)files,
+               if (gsi->count && (gsi->flags & GSF_PRINT_FILES)) {
+                       format_size_value(conf.size_unit_arg, files,
+                               formated_value);
+                       printf("%s%s", formated_value,
                                (gsi->flags & GSF_PRINT_BYTES)? "\t" : "\n");
+               }
                if (summary)
                        num_files += files;
        }
@@ -531,8 +570,11 @@ static int global_stats_loop_function(struct osl_row *row, void *data)
                if (ret < 0)
                        return ret;
                bytes = *(uint64_t *)obj.data;
-               if (gsi->count && (gsi->flags & GSF_PRINT_BYTES))
-                       printf("%llu\n", (long long unsigned)bytes);
+               if (gsi->count && (gsi->flags & GSF_PRINT_BYTES)) {
+                       format_size_value(conf.size_unit_arg, bytes,
+                               formated_value);
+                       printf("%s\n", formated_value);
+               }
                if (summary) {
                        num_bytes += bytes;
                        num_dirs++;
@@ -549,12 +591,21 @@ static void print_id_stats(void)
 
        printf("--------------------- user summary (uid/dirs/files/bytes):\n");
        FOR_EACH_USER(ui) {
+               char formated_dir_count[25], formated_file_count[25],
+                       formated_bytes[25];
                if (!ui->table)
                        continue;
-               printf("%u\t%llu\t%llu\t%llu\n", (unsigned)ui->uid,
-                       (long long unsigned)ui->dirs,
-                       (long long unsigned)ui->files,
-                       (long long unsigned)ui->bytes);
+               format_count_value(conf.count_unit_arg, ui->dirs,
+                       formated_dir_count);
+               format_count_value(conf.count_unit_arg, ui->files,
+                       formated_file_count);
+               format_size_value(conf.size_unit_arg, ui->bytes,
+                       formated_bytes);
+               printf("%u\t%s\t%s\t%s\n", (unsigned)ui->uid,
+                       formated_dir_count,
+                       formated_file_count,
+                       formated_bytes
+               );
        }
 }
 
@@ -577,6 +628,7 @@ static int user_stats_loop_function(struct osl_row *row, void *data)
        struct osl_row *dir_row;
        struct osl_object obj;
        int ret, summary = usi->flags & GSF_COMPUTE_SUMMARY;
+       char formated_value[25];
 
        if (!usi->count && !summary)
                return -E_LOOP_COMPLETE;
@@ -604,11 +656,13 @@ static int user_stats_loop_function(struct osl_row *row, void *data)
                if (ret < 0)
                        return ret;
                files = *(uint64_t *)obj.data;
-               if (usi->count && (usi->flags & USF_PRINT_FILES))
-                       printf("%llu%s",
-                               (long long unsigned)files,
+               if (usi->count && (usi->flags & USF_PRINT_FILES)) {
+                       format_size_value(conf.size_unit_arg, files,
+                               formated_value);
+                       printf("%s%s", formated_value,
                                (usi->flags & USF_PRINT_BYTES)? "\t" : "\n"
                        );
+               }
                if (summary)
                        usi->ui->files += files;
        }
@@ -618,8 +672,11 @@ static int user_stats_loop_function(struct osl_row *row, void *data)
                if (ret < 0)
                        return ret;
                bytes = *(uint64_t *)obj.data;
-               if (usi->count && (usi->flags & USF_PRINT_BYTES))
-                       printf("%llu\n", (long long unsigned)bytes);
+               if (usi->count && (usi->flags & USF_PRINT_BYTES)) {
+                       format_size_value(conf.size_unit_arg, bytes,
+                               formated_value);
+                       printf("%s\n", formated_value);
+               }
                if (summary) {
                        usi->ui->bytes += bytes;
                        usi->ui->dirs++;

diff --git a/adu.ggo b/adu.ggo
index 2a7cee97a5d55bc401503e1dfb3ccfdb3f79ce5b..bb8e2a6ef123788ac47f135d4d1a96b3391747b0 100644 (file)
--- a/adu.ggo
+++ b/adu.ggo
@@ -150,16 +150,29 @@ details="
        print all lines.
 "
 
-option "units" U
-#~~~~~~~~~~~~~~~
-"select numerical output format"
-string typestr="format"
+option "size_unit" -
+#~~~~~~~~~~~~~~~~~~~
+"select output format for sizes"
+enum typestr="format"
+values="h","b","k","m","g","t"
+default="h"
+optional
+details="
+       Print sizes in the given unit: human-readable, bytes,
+       kilobytes (2^10), megabytes (2^20), gigabytes (2^30), terabytes
+       (2^40). The default is \"h\", i.e. human-readable.
+"
+
+option "count_unit" -
+#~~~~~~~~~~~~~~~~~~~~
+"select output format for counted values"
+enum typestr="format"
+values="h","n","k","m","g","t"
+default="h"
 optional
 details="
-       Print the number of files/directories and the sizes in
-       the given format.  All  sizes  are output in these units:
-       (h)uman-readable, (b)ytes, (k)ilobytes, (m)egabytes,
-       (g)igabytes, (t)erabytes.  Capitalise to use multiples
-       of 1000 (S.I.) instead of 1024. The default is \"h\",
-       i.e. human-readable.
+       Print the number of files/directories in the given unit:
+       human-readable, number, number/10^3, number/10^6, number/10^12,
+       number/10^15. The default is to print numbers in human-readable
+       format.
 "