[bug #12162] Enhancement req: finding files less than 2Gb in size [needs community feedback]

[Tino Calancha]

Follow-up Comment #31, bug #12162 (project findutils):

>I am totally happy with -filesize option suggestion, yet, it would be
>important to also have comparing bigger, smaller or equal.
>How would you solve this?

>I suggest:

>-size lt 1M: less than one MiB (< 1048576 bytes, 1048575 matches 1048576 does
not match)
>-size lte 1M: less than or equal one MiB (<= 1048576 bytes)
>-size gt 1M: more than one MiB (> 1048576 bytes)
>-size gte 1M: more or equal than one MiB (>= 1048576 bytes)
>-size eq 1M: exactly one MiB (=1048576 bytes)
Your suggestion is interesting and more ambitious.  So far i have restricted
myself to bring the behaviour that many people are looking for, causing
most of the bug reports/stackoverflow questions:
A new predicate size without rounding.

(Once we have this solved we always could think how to extend these
predicates to allow things as <= or >=).

I follow the Nigel suggestion (#16 in this thread).

Below is my patch:

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

>From 6ec1877385228aa5cd540c26fbebf09ba283654b Mon Sep 17 00:00:00 2001
From: Tino Calancha <address@hidden>
Date: Fri, 8 Jul 2016 13:01:54 +0900
Subject: [PATCH 1/4] Merge with remote rep

---
 gnulib | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/gnulib b/gnulib
index 97173b2..0ef1689 160000
--- a/gnulib
+++ b/gnulib
@@ -1 +1 @@
-Subproject commit 97173b26d27d9f31de1789e994dfe014e3a40162
+Subproject commit 0ef1689f914462d778c5e279dfc48702fecbabbf
-- 
2.8.1

>From 897fe8422701651af0c022aff797ff3aec5ff14d Mon Sep 17 00:00:00 2001
From: Tino Calancha <address@hidden>
Date: Fri, 8 Jul 2016 14:39:27 +0900
Subject: [PATCH 2/4] Predicate size without rounding

* find/defs.h: New predicate filesize; as predicate size but
without rounding (Bug#12162).
* find/parser.c: Idem.
* find/pred.c: Idem.
* find/tree.c: Idem.
---
 find/defs.h   |  1 +
 find/parser.c | 15 +++++++++++----
 find/pred.c   | 28 ++++++++++++++++++++++++++++
 find/tree.c   |  1 +
 4 files changed, 41 insertions(+), 4 deletions(-)

diff --git a/find/defs.h b/find/defs.h
index 52e522f..66e2648 100644
--- a/find/defs.h
+++ b/find/defs.h
@@ -464,6 +464,7 @@ PREDICATEFUNCTION pred_readable;
 PREDICATEFUNCTION pred_regex;
 PREDICATEFUNCTION pred_samefile;
 PREDICATEFUNCTION pred_size;
+PREDICATEFUNCTION pred_filesize; 
 PREDICATEFUNCTION pred_true;
 PREDICATEFUNCTION pred_type;
 PREDICATEFUNCTION pred_uid;
diff --git a/find/parser.c b/find/parser.c
index 3ed5c31..e1e5800 100644
--- a/find/parser.c
+++ b/find/parser.c
@@ -138,6 +138,7 @@ static bool parse_regex         (const struct
parser_table*, char *argv[], int *
 static bool parse_regextype     (const struct parser_table*, char *argv[],
int *arg_ptr);
 static bool parse_samefile      (const struct parser_table*, char *argv[],
int *arg_ptr);
 static bool parse_size          (const struct parser_table*, char *argv[],
int *arg_ptr);
+static bool parse_filesize      (const struct parser_table*, char *argv[],
int *arg_ptr);
 static bool parse_time          (const struct parser_table*, char *argv[],
int *arg_ptr);
 static bool parse_true          (const struct parser_table*, char *argv[],
int *arg_ptr);
 static bool parse_type          (const struct parser_table*, char *argv[],
int *arg_ptr);
@@ -303,6 +304,7 @@ static struct parser_table const parse_table[] =
   PARSE_OPTION     ("show-control-chars",    show_control_chars), /* GNU,
4.3.0+ */
 #endif
   PARSE_TEST       ("size",                  size), /* POSIX */
+  PARSE_TEST       ("filesize",              filesize), /* GNU */
   PARSE_TEST       ("type",                  type), /* POSIX */
   PARSE_TEST       ("uid",                   uid),          /* GNU */
   PARSE_TEST       ("used",                  used),         /* GNU */
@@ -2129,7 +2131,7 @@ parse_size (const struct parser_table* entry, char
**argv, int *arg_ptr)
 
   len = strlen (arg);
   if (len == 0)
-    error (EXIT_FAILURE, 0, _("invalid null argument to -size"));
+    error (EXIT_FAILURE, 0, _("invalid null argument to %s"), argv[*arg_ptr -
1]);
 
   suffix = arg[len - 1];
   switch (suffix)
@@ -2179,7 +2181,7 @@ parse_size (const struct parser_table* entry, char
**argv, int *arg_ptr)
 
     default:
       error (EXIT_FAILURE, 0,
-            _("invalid -size type `%c'"), argv[*arg_ptr][len - 1]);
+            _("invalid %s type `%c'"), argv[*arg_ptr - 1], argv[*arg_ptr][len -
1]);
     }
   /* TODO: accept fractional megabytes etc. ? */
   if (!get_num (arg, &num, &c_type))
@@ -2189,8 +2191,8 @@ parse_size (const struct parser_table* entry, char
**argv, int *arg_ptr)
       tail[1] = 0;
 
       error (EXIT_FAILURE, 0,
-            _("Invalid argument `%s%s' to -size"),
-            arg, tail);
+            _("Invalid argument `%s%s' to %s"),
+            arg, tail, argv[*arg_ptr - 1]);
       return false;
     }
   our_pred = insert_primary (entry, arg);
@@ -2211,6 +2213,11 @@ parse_size (const struct parser_table* entry, char
**argv, int *arg_ptr)
   return true;
 }
 
+static bool
+parse_filesize (const struct parser_table* entry, char **argv, int *arg_ptr)
+{
+  return parse_size (entry, argv, arg_ptr);
+}
 
 static bool
 parse_samefile (const struct parser_table* entry, char **argv, int *arg_ptr)
diff --git a/find/pred.c b/find/pred.c
index f7e9b59..f4a4636 100644
--- a/find/pred.c
+++ b/find/pred.c
@@ -128,6 +128,7 @@ struct pred_assoc pred_table[] =
   {pred_regex, "regex   "},
   {pred_samefile,"samefile "},
   {pred_size, "size    "},
+  {pred_filesize, "filesize    "},
   {pred_true, "true    "},
   {pred_type, "type    "},
   {pred_uid, "uid     "},
@@ -979,6 +980,33 @@ pred_size (const char *pathname, struct stat *stat_buf,
struct predicate *pred_p
 }
 
 bool
+pred_filesize (const char *pathname, struct stat *stat_buf, struct predicate
*pred_ptr)
+{
+  uintmax_t f_val;
+
+  (void) pathname;
+  f_val = (stat_buf->st_size / pred_ptr->args.size.blocksize);
+  if (f_val == pred_ptr->args.size.size)
+      f_val = f_val + (stat_buf->st_size % pred_ptr->args.size.blocksize !=
0);
+  switch (pred_ptr->args.size.kind)
+    {
+    case COMP_GT:
+      if (f_val > pred_ptr->args.size.size)
+       return (true);
+      break;
+    case COMP_LT:
+      if (f_val < pred_ptr->args.size.size)
+       return (true);
+      break;
+    case COMP_EQ:
+      if (f_val == pred_ptr->args.size.size)
+       return (true);
+      break;
+    }
+  return (false);
+}
+
+bool
 pred_samefile (const char *pathname, struct stat *stat_buf, struct predicate
*pred_ptr)
 {
   /* Potential optimisation: because of the loop protection, we always
diff --git a/find/tree.c b/find/tree.c
index 2bbfbe5..e404721 100644
--- a/find/tree.c
+++ b/find/tree.c
@@ -980,6 +980,7 @@ static struct pred_cost_lookup costlookup[] =
     { pred_regex     ,  NeedsNothing         },
     { pred_samefile  ,  NeedsStatInfo        },
     { pred_size      ,  NeedsStatInfo        },
+    { pred_filesize  ,  NeedsStatInfo        },
     { pred_true             ,  NeedsNothing         },
     { pred_type      ,  NeedsType            },
     { pred_uid       ,  NeedsStatInfo        },
-- 
2.8.1

>From 44c5e3486d2948e4a24070a7eec323ddc20d8d70 Mon Sep 17 00:00:00 2001
From: Tino Calancha <address@hidden>
Date: Fri, 8 Jul 2016 14:58:04 +0900
Subject: [PATCH 3/4] * doc/find.texi (2.4 size): Document predicate filesize

---
 doc/find.texi | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/doc/find.texi b/doc/find.texi
index b3c5d10..812369a 100644
--- a/doc/find.texi
+++ b/doc/find.texi
@@ -1037,8 +1037,9 @@ indicates that the test should succeed if the file uses
less than
 @var{n} units of storage.  Bear in mind that the size is rounded up to
 the next unit. Therefore @samp{-size -1M} is not equivalent to
 @samp{-size -1048576c}. The former only matches empty files, the latter
-matches files from 1 to 1,048,575 bytes.  There is no `=' prefix, because
-that's the default anyway.
+matches files from 1 to 1,048,575 bytes.  If you prefer that the size
+not be rounded you may want to use predicate @samp{-filesize}.
+There is no `=' prefix, because that's the default anyway.
 
 The size does not count indirect blocks, but it does count blocks in
 sparse files that are not actually allocated.  In other words, it's
@@ -1048,6 +1049,10 @@ and @samp{%b} format specifiers for the @samp{-printf}
predicate.
 
 @end deffn
 
address@hidden Test -filesize address@hidden@r{]}
+Same as test @samp{-size} but the size is not rounded up to the next unit.
address@hidden deffn
+
 @deffn Test -empty
 True if the file is empty and is either a regular file or a directory.
 This might help determine good candidates for deletion.  This test is
-- 
2.8.1

>From f8d116b8f652ef4b806f2bcd798cf7be9ba49d35 Mon Sep 17 00:00:00 2001
From: Tino Calancha <address@hidden>
Date: Fri, 8 Jul 2016 15:31:25 +0900
Subject: [PATCH 4/4] Predicate blocksize alias to predicate size

* find/defs.h: New predicate blocksize; alias to predicate size
(Bug#12162).
* find/parser.c: Idem.
* find/pred.c: Idem.
* find/tree.c: Idem.

* doc/find.texi (2.4 size): Document predicate blocksize; mention
that filesize is a GNU extension.
---
 doc/find.texi | 5 +++++
 find/defs.h   | 1 +
 find/parser.c | 8 ++++++++
 find/pred.c   | 7 +++++++
 find/tree.c   | 1 +
 5 files changed, 22 insertions(+)

diff --git a/doc/find.texi b/doc/find.texi
index 812369a..281ba70 100644
--- a/doc/find.texi
+++ b/doc/find.texi
@@ -1049,8 +1049,13 @@ and @samp{%b} format specifiers for the @samp{-printf}
predicate.
 
 @end deffn
 
address@hidden Test -blocksize address@hidden@r{]}
+Same as test @samp{-size}, but not POSIX compliant.
address@hidden deffn
+
 @deffn Test -filesize address@hidden@r{]}
 Same as test @samp{-size} but the size is not rounded up to the next unit.
+This is a GNU extension.
 @end deffn
 
 @deffn Test -empty
diff --git a/find/defs.h b/find/defs.h
index 66e2648..a850c79 100644
--- a/find/defs.h
+++ b/find/defs.h
@@ -464,6 +464,7 @@ PREDICATEFUNCTION pred_readable;
 PREDICATEFUNCTION pred_regex;
 PREDICATEFUNCTION pred_samefile;
 PREDICATEFUNCTION pred_size;
+PREDICATEFUNCTION pred_blocksize;
 PREDICATEFUNCTION pred_filesize; 
 PREDICATEFUNCTION pred_true;
 PREDICATEFUNCTION pred_type;
diff --git a/find/parser.c b/find/parser.c
index e1e5800..b186bc8 100644
--- a/find/parser.c
+++ b/find/parser.c
@@ -138,6 +138,7 @@ static bool parse_regex         (const struct
parser_table*, char *argv[], int *
 static bool parse_regextype     (const struct parser_table*, char *argv[],
int *arg_ptr);
 static bool parse_samefile      (const struct parser_table*, char *argv[],
int *arg_ptr);
 static bool parse_size          (const struct parser_table*, char *argv[],
int *arg_ptr);
+static bool parse_blocksize     (const struct parser_table*, char *argv[],
int *arg_ptr);
 static bool parse_filesize      (const struct parser_table*, char *argv[],
int *arg_ptr);
 static bool parse_time          (const struct parser_table*, char *argv[],
int *arg_ptr);
 static bool parse_true          (const struct parser_table*, char *argv[],
int *arg_ptr);
@@ -304,6 +305,7 @@ static struct parser_table const parse_table[] =
   PARSE_OPTION     ("show-control-chars",    show_control_chars), /* GNU,
4.3.0+ */
 #endif
   PARSE_TEST       ("size",                  size), /* POSIX */
+  PARSE_TEST       ("blocksize",             blocksize), /* GNU */
   PARSE_TEST       ("filesize",              filesize), /* GNU */
   PARSE_TEST       ("type",                  type), /* POSIX */
   PARSE_TEST       ("uid",                   uid),          /* GNU */
@@ -2214,6 +2216,12 @@ parse_size (const struct parser_table* entry, char
**argv, int *arg_ptr)
 }
 
 static bool
+parse_blocksize (const struct parser_table* entry, char **argv, int
*arg_ptr)
+{
+  return parse_size (entry, argv, arg_ptr);
+}
+
+static bool
 parse_filesize (const struct parser_table* entry, char **argv, int *arg_ptr)
 {
   return parse_size (entry, argv, arg_ptr);
diff --git a/find/pred.c b/find/pred.c
index f4a4636..32a2281 100644
--- a/find/pred.c
+++ b/find/pred.c
@@ -128,6 +128,7 @@ struct pred_assoc pred_table[] =
   {pred_regex, "regex   "},
   {pred_samefile,"samefile "},
   {pred_size, "size    "},
+  {pred_blocksize, "blocksize    "},
   {pred_filesize, "filesize    "},
   {pred_true, "true    "},
   {pred_type, "type    "},
@@ -980,6 +981,12 @@ pred_size (const char *pathname, struct stat *stat_buf,
struct predicate *pred_p
 }
 
 bool
+pred_blocksize (const char *pathname, struct stat *stat_buf, struct predicate
*pred_ptr)
+{
+  return pred_size (pathname, stat_buf, pred_ptr);
+}
+
+bool
 pred_filesize (const char *pathname, struct stat *stat_buf, struct predicate
*pred_ptr)
 {
   uintmax_t f_val;
diff --git a/find/tree.c b/find/tree.c
index e404721..c5d2ee4 100644
--- a/find/tree.c
+++ b/find/tree.c
@@ -980,6 +980,7 @@ static struct pred_cost_lookup costlookup[] =
     { pred_regex     ,  NeedsNothing         },
     { pred_samefile  ,  NeedsStatInfo        },
     { pred_size      ,  NeedsStatInfo        },
+    { pred_blocksize ,  NeedsStatInfo        },
     { pred_filesize  ,  NeedsStatInfo        },
     { pred_true             ,  NeedsNothing         },
     { pred_type      ,  NeedsType            },
-- 
2.8.1


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

find (GNU findutils) 4.7.0-git
Repository revision: 155c9d1c229aa5d12b6e8919516fd6331a28ba1e


    _______________________________________________________

Reply to this item at:

  <http://savannah.gnu.org/bugs/?12162>

_______________________________________________
  Message sent via/by Savannah
  http://savannah.gnu.org/