path: root/meta/packages/findutils/findutils-4.4.2/01-27017.patch

commit af974034b68bf59337c7a384e488a518a77dfecd
Author: James Youngman <jay@gnu.org>
Date:   Sat Jul 11 19:55:27 2009 +0100

    Fix Savannah bug #27017: find -D opt / -fstype ext3 -print , -quit coredump.
    
    Fix Savannah bug #27017: find -D opt / -fstype ext3 -print , -quit
    coredumps.
    * find/tree.c (set_new_parent): Initialise struct
    predicate->arg_text to NULL (instead of leaving it uninitialised).
    (get_new_pred_noarg): Likewise.
    (get_new_pred): Initialise predicate->arg_text to
    "ThisShouldBeSetToSomethingElse" to make it easier to notice
    bugs.
    (get_new_pred_chk_op): Use get_new_pred_noarg.
    (print_predicate): Use an if statement instead of
    two ternary operators.
    * find/util.c (insert_primary_withpred): Accept new argument, arg,
    being the argument (if any) of this predicate.  Pass it to
    get_new_pred_chk_op.
    (insert_primary): Likewise (pass arg to insert_primary_withpred).
    (insert_primary_noarg): New function; calls insert_primary with
    arg=NULL.
    * find/parser.c (collect_arg_stat_info): Add an output parameter;
    the filename from which we collected the stat information.
    (parse_closeparen, parse_delete, parse_and, parse_or,
    parse_comma): Use get_new_pred_noarg.
    (parse_cnewer, parse_newer, parse_anewer): Use new
    collect_arg_stat_info and insert_primary interface.
    (parse_print, parse_prune, parse_nouser, parse_empty): Use
    insert_primary_noarg.
    (parse_accesscheck, parse_false): Use insert_primary_noarg.
    (parse_used, parse_iname, parse_fprint, insert_fprint,
    parse_fstype, parse_ilname): Use new collect_arg and
    insert_primary interfaces.
    (parse_ipath, parse_lname, do_parse_xmin, parse_name, parse_path,
    parse_perm, parse_size, parse_user, parse_time): Use new
    collect_arg and insert_primary_withpred interface.
    (parse_negate, parse_openparen): Use new get_new_pred_chk_op interface.
    (parse_newerXY, parse_nogroup): Use new insert_primary interface.
    (insert_regex, parse_samefile): Use new insert_primary_withpred
    interface.
    (insert_type, insert_fprintf, new_insert_exec_ok, insert_num): Use
    new insert_primary_withpred interface.
    * find/defs.h (struct predicate.arg_text): make const.
    Add declarations for new function get_new_pred_noarg and
    insert_primary_noarg.  Add 'arg' parameter to get_new_pred_chk_op
    and insert_primary_withpred.

diff --git a/ChangeLog b/ChangeLog
index 6e346b8..e8ba0f8 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,0 +1,45 @@
+2009-07-11  James Youngman  <jay@gnu.org>
+
+	Fix Savannah bug #27017: find -D opt / -fstype ext3 -print , -quit
+	coredumps.
+	* find/tree.c (set_new_parent): Initialise struct
+	predicate->arg_text to NULL (instead of leaving it uninitialised).
+	(get_new_pred_noarg): Likewise.
+	(get_new_pred): Initialise predicate->arg_text to
+	"ThisShouldBeSetToSomethingElse" to make it easier to notice
+	bugs.
+	(get_new_pred_chk_op): Use get_new_pred_noarg.
+	(print_predicate): Use an if statement instead of
+	two ternary operators.
+	* find/util.c (insert_primary_withpred): Accept new argument, arg,
+	being the argument (if any) of this predicate.  Pass it to
+	get_new_pred_chk_op.
+	(insert_primary): Likewise (pass arg to insert_primary_withpred).
+	(insert_primary_noarg): New function; calls insert_primary with
+	arg=NULL.
+	* find/parser.c (collect_arg_stat_info): Add an output parameter;
+	the filename from which we collected the stat information.
+	(parse_closeparen, parse_delete, parse_and, parse_or,
+	parse_comma): Use get_new_pred_noarg.
+	(parse_cnewer, parse_newer, parse_anewer): Use new
+	collect_arg_stat_info and insert_primary interface.
+	(parse_print, parse_prune, parse_nouser, parse_empty): Use
+	insert_primary_noarg.
+	(parse_accesscheck, parse_false): Use insert_primary_noarg.
+	(parse_used, parse_iname, parse_fprint, insert_fprint,
+	parse_fstype, parse_ilname): Use new collect_arg and
+	insert_primary interfaces.
+	(parse_ipath, parse_lname, do_parse_xmin, parse_name, parse_path,
+	parse_perm, parse_size, parse_user, parse_time): Use new
+	collect_arg and insert_primary_withpred interface.
+	(parse_negate, parse_openparen): Use new get_new_pred_chk_op interface.
+	(parse_newerXY, parse_nogroup): Use new insert_primary interface.
+	(insert_regex, parse_samefile): Use new insert_primary_withpred
+	interface.
+	(insert_type, insert_fprintf, new_insert_exec_ok, insert_num): Use
+	new insert_primary_withpred interface.
+	* find/defs.h (struct predicate.arg_text): make const.
+	Add declarations for new function get_new_pred_noarg and
+	insert_primary_noarg.  Add 'arg' parameter to get_new_pred_chk_op
+	and insert_primary_withpred.
+
diff --git a/find/defs.h b/find/defs.h
index 1708d83..4539fd9 100644
--- a/find/defs.h
+++ b/find/defs.h
@@ -297,7 +297,7 @@ struct predicate
   boolean artificial;
 
   /* The raw text of the argument of this predicate. */
-  char *arg_text;
+  const char *arg_text;
   
   /* Information needed by the predicate processor.
      Next to each member are listed the predicates that use it. */
@@ -480,13 +480,16 @@ void show_success_rates(const struct predicate *node);
 /* tree.c */
 struct predicate * build_expression_tree PARAMS((int argc, char *argv[], int end_of_leading_options));
 struct predicate * get_eval_tree PARAMS((void));
+struct predicate *get_new_pred_noarg (const struct parser_table *entry);
 struct predicate *get_new_pred PARAMS((const struct parser_table *entry));
-struct predicate *get_new_pred_chk_op PARAMS((const struct parser_table *entry));
+struct predicate *get_new_pred_chk_op PARAMS((const struct parser_table *entry,
+					      const char *arg));
 float  calculate_derived_rates PARAMS((struct predicate *p));
 
 /* util.c */
-struct predicate *insert_primary PARAMS((const struct parser_table *entry));
-struct predicate *insert_primary_withpred PARAMS((const struct parser_table *entry, PRED_FUNC fptr));
+struct predicate *insert_primary PARAMS((const struct parser_table *entry, const char *arg));
+struct predicate *insert_primary_noarg PARAMS((const struct parser_table *entry));
+struct predicate *insert_primary_withpred PARAMS((const struct parser_table *entry, PRED_FUNC fptr, const char *arg));
 void usage PARAMS((FILE *fp, int status, char *msg));
 extern boolean check_nofollow(void);
 void complete_pending_execs(struct predicate *p);
diff --git a/find/parser.c b/find/parser.c
index 534b670..2e6b989 100644
--- a/find/parser.c
+++ b/find/parser.c
@@ -640,11 +640,13 @@ collect_arg(char **argv, int *arg_ptr, const char **collected_arg)
 }
 
 static boolean
-collect_arg_stat_info(char **argv, int *arg_ptr, struct stat *p)
+collect_arg_stat_info(char **argv, int *arg_ptr, struct stat *p,
+		      const char **argument)
 {
   const char *filename;
   if (collect_arg(argv, arg_ptr, &filename))
     {
+      *argument = filename;
       if (0 == (options.xstat)(filename, p))
 	{
 	  return true;
@@ -656,6 +658,7 @@ collect_arg_stat_info(char **argv, int *arg_ptr, struct stat *p)
     }
   else
     {
+      *argument = NULL;
       return false;
     }
 }
@@ -679,7 +682,7 @@ parse_and (const struct parser_table* entry, char **argv, int *arg_ptr)
   (void) argv;
   (void) arg_ptr;
 
-  our_pred = get_new_pred (entry);
+  our_pred = get_new_pred_noarg (entry);
   our_pred->pred_func = pred_and;
   our_pred->p_type = BI_OP;
   our_pred->p_prec = AND_PREC;
@@ -691,11 +694,12 @@ static boolean
 parse_anewer (const struct parser_table* entry, char **argv, int *arg_ptr)
 {
   struct stat stat_newer;
+  const char *arg;
 
   set_stat_placeholders(&stat_newer);
-  if (collect_arg_stat_info(argv, arg_ptr, &stat_newer))
+  if (collect_arg_stat_info(argv, arg_ptr, &stat_newer, &arg))
     {
-      struct predicate *our_pred = insert_primary (entry);
+      struct predicate *our_pred = insert_primary (entry, arg);
       our_pred->args.reftime.xval = XVAL_ATIME;
       our_pred->args.reftime.ts = get_stat_mtime(&stat_newer);
       our_pred->args.reftime.kind = COMP_GT;
@@ -713,7 +717,7 @@ parse_closeparen (const struct parser_table* entry, char **argv, int *arg_ptr)
   (void) argv;
   (void) arg_ptr;
 
-  our_pred = get_new_pred (entry);
+  our_pred = get_new_pred_noarg (entry);
   our_pred->pred_func = pred_closeparen;
   our_pred->p_type = CLOSE_PAREN;
   our_pred->p_prec = NO_PREC;
@@ -725,11 +729,12 @@ static boolean
 parse_cnewer (const struct parser_table* entry, char **argv, int *arg_ptr)
 {
   struct stat stat_newer;
+  const char *arg;
 
   set_stat_placeholders(&stat_newer);
-  if (collect_arg_stat_info(argv, arg_ptr, &stat_newer))
+  if (collect_arg_stat_info(argv, arg_ptr, &stat_newer, &arg))
     {
-      struct predicate *our_pred = insert_primary (entry);
+      struct predicate *our_pred = insert_primary (entry, arg);
       our_pred->args.reftime.xval = XVAL_CTIME; /* like -newercm */
       our_pred->args.reftime.ts = get_stat_mtime(&stat_newer);
       our_pred->args.reftime.kind = COMP_GT;
@@ -747,7 +752,7 @@ parse_comma (const struct parser_table* entry, char **argv, int *arg_ptr)
   (void) argv;
   (void) arg_ptr;
 
-  our_pred = get_new_pred (entry);
+  our_pred = get_new_pred_noarg (entry);
   our_pred->pred_func = pred_comma;
   our_pred->p_type = BI_OP;
   our_pred->p_prec = COMMA_PREC;
@@ -786,7 +791,7 @@ parse_delete (const struct parser_table* entry, char *argv[], int *arg_ptr)
   (void) argv;
   (void) arg_ptr;
 
-  our_pred = insert_primary (entry);
+  our_pred = insert_primary_noarg (entry);
   our_pred->side_effects = our_pred->no_default_print = true;
   /* -delete implies -depth */
   options.do_dir_first = false;
@@ -831,7 +836,7 @@ parse_empty (const struct parser_table* entry, char **argv, int *arg_ptr)
   (void) argv;
   (void) arg_ptr;
 
-  our_pred = insert_primary (entry);
+  our_pred = insert_primary_noarg (entry);
   our_pred->est_success_rate = 0.01f; /* assume 1% of files are empty. */
   return true;
 }
@@ -856,7 +861,7 @@ parse_false (const struct parser_table* entry, char **argv, int *arg_ptr)
   (void) argv;
   (void) arg_ptr;
 
-  our_pred = insert_primary (entry);
+  our_pred = insert_primary_noarg (entry);
   our_pred->need_stat = our_pred->need_type = false;
   our_pred->side_effects = our_pred->no_default_print = false;
   our_pred->est_success_rate = 0.0f;
@@ -866,7 +871,7 @@ parse_false (const struct parser_table* entry, char **argv, int *arg_ptr)
 static boolean
 insert_fls (const struct parser_table* entry, const char *filename)
 {
-  struct predicate *our_pred = insert_primary (entry);
+  struct predicate *our_pred = insert_primary_noarg (entry);
   if (filename)
     open_output_file (filename, &our_pred->args.printf_vec);
   else
@@ -899,7 +904,7 @@ parse_fprint (const struct parser_table* entry, char **argv, int *arg_ptr)
   const char *filename;
   if (collect_arg(argv, arg_ptr, &filename))
     {
-      our_pred = insert_primary (entry);
+      our_pred = insert_primary (entry, filename);
       open_output_file (filename, &our_pred->args.printf_vec);
       our_pred->side_effects = our_pred->no_default_print = true;
       our_pred->need_stat = our_pred->need_type = false;
@@ -915,7 +920,7 @@ parse_fprint (const struct parser_table* entry, char **argv, int *arg_ptr)
 static boolean
 insert_fprint(const struct parser_table* entry, const char *filename)
 {
-  struct predicate *our_pred = insert_primary (entry);
+  struct predicate *our_pred = insert_primary (entry, filename);
   if (filename)
     open_output_file (filename, &our_pred->args.printf_vec);
   else
@@ -960,7 +965,7 @@ parse_fstype (const struct parser_table* entry, char **argv, int *arg_ptr)
   const char *typename;
   if (collect_arg(argv, arg_ptr, &typename))
     {
-      struct predicate *our_pred = insert_primary (entry);
+      struct predicate *our_pred = insert_primary (entry, typename);
       our_pred->args.str = typename;
 
       /* This is an expensive operation, so although there are
@@ -1090,7 +1095,7 @@ parse_group (const struct parser_table* entry, char **argv, int *arg_ptr)
 	      return false;
 	    }
 	}
-      our_pred = insert_primary (entry);
+      our_pred = insert_primary (entry, groupname);
       our_pred->args.gid = gid;
       our_pred->est_success_rate = (our_pred->args.numinfo.l_val < 100) ? 0.99 : 0.2;
       return true;
@@ -1160,7 +1165,7 @@ parse_ilname (const struct parser_table* entry, char **argv, int *arg_ptr)
   const char *name;
   if (collect_arg(argv, arg_ptr, &name))
     {
-      struct predicate *our_pred = insert_primary (entry);
+      struct predicate *our_pred = insert_primary (entry, name);
       our_pred->args.str = name;
       /* Use the generic glob pattern estimator to figure out how many
        * links will match, but bear in mind that most files won't be links.
@@ -1227,7 +1232,7 @@ parse_iname (const struct parser_table* entry, char **argv, int *arg_ptr)
     {
       if (check_name_arg("-iname", name))
 	{
-	  struct predicate *our_pred = insert_primary (entry);
+	  struct predicate *our_pred = insert_primary (entry, name);
 	  our_pred->need_stat = our_pred->need_type = false;
 	  our_pred->args.str = name;
 	  our_pred->est_success_rate = estimate_pattern_match_rate(name, 0);
@@ -1268,7 +1273,7 @@ parse_ipath (const struct parser_table* entry, char **argv, int *arg_ptr)
   fnmatch_sanitycheck ();
   if (collect_arg (argv, arg_ptr, &name))
     {
-      struct predicate *our_pred = insert_primary_withpred (entry, pred_ipath);
+      struct predicate *our_pred = insert_primary_withpred (entry, pred_ipath, name);
       our_pred->need_stat = our_pred->need_type = false;
       our_pred->args.str = name;
       our_pred->est_success_rate = estimate_pattern_match_rate (name, 0);
@@ -1316,7 +1321,7 @@ parse_lname (const struct parser_table* entry, char **argv, int *arg_ptr)
   fnmatch_sanitycheck();
   if (collect_arg(argv, arg_ptr, &name))
     {
-      struct predicate *our_pred = insert_primary (entry);
+      struct predicate *our_pred = insert_primary (entry, name);
       our_pred->args.str = name;
       our_pred->est_success_rate = 0.1 * estimate_pattern_match_rate(name, 0);
       return true;
@@ -1391,7 +1396,7 @@ do_parse_xmin (const struct parser_table* entry,
 				 "arithmetic overflow while converting %s "
 				 "minutes to a number of seconds"))
 	{
-	  struct predicate *our_pred = insert_primary (entry);
+	  struct predicate *our_pred = insert_primary (entry, minutes);
 	  our_pred->args.reftime = tval;
 	  our_pred->est_success_rate = estimate_timestamp_success_rate(tval.ts.tv_sec);
 	  return true;
@@ -1427,7 +1432,7 @@ parse_name (const struct parser_table* entry, char **argv, int *arg_ptr)
       fnmatch_sanitycheck();
       if (check_name_arg("-name", name))
 	{
-	  struct predicate *our_pred = insert_primary (entry);
+	  struct predicate *our_pred = insert_primary (entry, name);
 	  our_pred->need_stat = our_pred->need_type = false;
 	  our_pred->args.str = name;
 	  our_pred->est_success_rate = estimate_pattern_match_rate(name, 0);
@@ -1445,7 +1450,7 @@ parse_negate (const struct parser_table* entry, char **argv, int *arg_ptr)
   (void) &argv;
   (void) &arg_ptr;
 
-  our_pred = get_new_pred_chk_op (entry);
+  our_pred = get_new_pred_chk_op (entry, NULL);
   our_pred->pred_func = pred_negate;
   our_pred->p_type = UNI_OP;
   our_pred->p_prec = NEGATE_PREC;
@@ -1458,11 +1463,12 @@ parse_newer (const struct parser_table* entry, char **argv, int *arg_ptr)
 {
   struct predicate *our_pred;
   struct stat stat_newer;
+  const char *arg;
 
   set_stat_placeholders(&stat_newer);
-  if (collect_arg_stat_info(argv, arg_ptr, &stat_newer))
+  if (collect_arg_stat_info(argv, arg_ptr, &stat_newer, &arg))
     {
-      our_pred = insert_primary (entry);
+      our_pred = insert_primary (entry, arg);
       our_pred->args.reftime.ts = get_stat_mtime(&stat_newer);
       our_pred->args.reftime.xval = XVAL_MTIME;
       our_pred->args.reftime.kind = COMP_GT;
@@ -1530,7 +1536,7 @@ parse_newerXY (const struct parser_table* entry, char **argv, int *arg_ptr)
 	      (*arg_ptr)++;
 	    }
 
-	  our_pred = insert_primary (entry);
+	  our_pred = insert_primary (entry, argv[*arg_ptr]);
 
 
 	  switch (x)
@@ -1623,7 +1629,7 @@ parse_nogroup (const struct parser_table* entry, char **argv, int *arg_ptr)
   (void) &argv;
   (void) &arg_ptr;
 
-  our_pred = insert_primary (entry);
+  our_pred = insert_primary (entry, NULL);
   our_pred->est_success_rate = 1e-4;
 #ifdef CACHE_IDS
   if (gid_unused == NULL)
@@ -1660,7 +1666,7 @@ parse_nouser (const struct parser_table* entry, char **argv, int *arg_ptr)
   (void) arg_ptr;
 
 
-  our_pred = insert_primary (entry);
+  our_pred = insert_primary_noarg (entry);
   our_pred->est_success_rate = 1e-3;
 #ifdef CACHE_IDS
   if (uid_unused == NULL)
@@ -1716,7 +1722,7 @@ parse_openparen (const struct parser_table* entry, char **argv, int *arg_ptr)
   (void) argv;
   (void) arg_ptr;
 
-  our_pred = get_new_pred_chk_op (entry);
+  our_pred = get_new_pred_chk_op (entry, NULL);
   our_pred->pred_func = pred_openparen;
   our_pred->p_type = OPEN_PAREN;
   our_pred->p_prec = NO_PREC;
@@ -1732,7 +1738,7 @@ parse_or (const struct parser_table* entry, char **argv, int *arg_ptr)
   (void) argv;
   (void) arg_ptr;
 
-  our_pred = get_new_pred (entry);
+  our_pred = get_new_pred_noarg (entry);
   our_pred->pred_func = pred_or;
   our_pred->p_type = BI_OP;
   our_pred->p_prec = OR_PREC;
@@ -1756,7 +1762,7 @@ parse_path (const struct parser_table* entry, char **argv, int *arg_ptr)
   const char *name;
   if (collect_arg(argv, arg_ptr, &name))
     {
-      struct predicate *our_pred = insert_primary_withpred (entry, pred_path);
+      struct predicate *our_pred = insert_primary_withpred (entry, pred_path, name);
       our_pred->need_stat = our_pred->need_type = false;
       our_pred->args.str = name;
       our_pred->est_success_rate = estimate_pattern_match_rate (name, 0);
@@ -1894,7 +1900,7 @@ parse_perm (const struct parser_table* entry, char **argv, int *arg_ptr)
       rate = 0.9986; /* probably matches anything but a broken symlink */
     }
 
-  our_pred = insert_primary (entry);
+  our_pred = insert_primary (entry, perm_expr);
   our_pred->est_success_rate = rate;
   if (havekind)
     {
@@ -1928,7 +1934,7 @@ parse_print (const struct parser_table* entry, char **argv, int *arg_ptr)
   (void) argv;
   (void) arg_ptr;
 
-  our_pred = insert_primary (entry);
+  our_pred = insert_primary_noarg (entry);
   /* -print has the side effect of printing.  This prevents us
      from doing undesired multiple printing when the user has
      already specified -print. */
@@ -1981,7 +1987,7 @@ parse_prune (const struct parser_table* entry, char **argv, int *arg_ptr)
   (void) argv;
   (void) arg_ptr;
 
-  our_pred = insert_primary (entry);
+  our_pred = insert_primary_noarg (entry);
   if (options.do_dir_first == false)
     our_pred->need_stat = our_pred->need_type = false;
   /* -prune has a side effect that it does not descend into
@@ -1994,7 +2000,7 @@ parse_prune (const struct parser_table* entry, char **argv, int *arg_ptr)
 static boolean
 parse_quit  (const struct parser_table* entry, char **argv, int *arg_ptr)
 {
-  struct predicate *our_pred = insert_primary (entry);
+  struct predicate *our_pred = insert_primary_noarg (entry);
   (void) argv;
   (void) arg_ptr;
   our_pred->need_stat = our_pred->need_type = false;
@@ -2036,7 +2042,7 @@ insert_regex (char **argv,
     {
       struct re_pattern_buffer *re;
       const char *error_message;
-      struct predicate *our_pred = insert_primary_withpred (entry, pred_regex);
+      struct predicate *our_pred = insert_primary_withpred (entry, pred_regex, rx);
       our_pred->need_stat = our_pred->need_type = false;
       re = xmalloc (sizeof (struct re_pattern_buffer));
       our_pred->args.regex = re;
@@ -2061,6 +2067,7 @@ static boolean
 parse_size (const struct parser_table* entry, char **argv, int *arg_ptr)
 {
   struct predicate *our_pred;
+  char *arg;
   uintmax_t num;
   char suffix;
   enum comparison_type c_type;
@@ -2073,42 +2080,43 @@ parse_size (const struct parser_table* entry, char **argv, int *arg_ptr)
    */
   if ((argv == NULL) || (argv[*arg_ptr] == NULL))
     return false;
+  arg = argv[*arg_ptr];
 
-  len = strlen (argv[*arg_ptr]);
+  len = strlen (arg);
   if (len == 0)
     error (1, 0, _("invalid null argument to -size"));
 
-  suffix = argv[*arg_ptr][len - 1];
+  suffix = arg[len - 1];
   switch (suffix)
     {
     case 'b':
       blksize = 512;
-      argv[*arg_ptr][len - 1] = '\0';
+      arg[len - 1] = '\0';
       break;
 
     case 'c':
       blksize = 1;
-      argv[*arg_ptr][len - 1] = '\0';
+      arg[len - 1] = '\0';
       break;
 
     case 'k':
       blksize = 1024;
-      argv[*arg_ptr][len - 1] = '\0';
+      arg[len - 1] = '\0';
       break;
 
     case 'M':			/* Megabytes */
       blksize = 1024*1024;
-      argv[*arg_ptr][len - 1] = '\0';
+      arg[len - 1] = '\0';
       break;
 
     case 'G':			/* Gigabytes */
       blksize = 1024*1024*1024;
-      argv[*arg_ptr][len - 1] = '\0';
+      arg[len - 1] = '\0';
       break;
 
     case 'w':
       blksize = 2;
-      argv[*arg_ptr][len - 1] = '\0';
+      arg[len - 1] = '\0';
       break;
 
     case '0':
@@ -2127,14 +2135,14 @@ parse_size (const struct parser_table* entry, char **argv, int *arg_ptr)
       error (1, 0, _("invalid -size type `%c'"), argv[*arg_ptr][len - 1]);
     }
   /* TODO: accept fractional megabytes etc. ? */
-  if (!get_num (argv[*arg_ptr], &num, &c_type))
+  if (!get_num (arg, &num, &c_type))
     {
       error(1, 0,
 	    _("Invalid argument `%s%c' to -size"),
-	    argv[*arg_ptr], (int)suffix);
+	    arg, (int)suffix);
       return false;
     }
-  our_pred = insert_primary (entry);
+our_pred = insert_primary (entry, arg);
   our_pred->args.size.kind = c_type;
   our_pred->args.size.blocksize = blksize;
   our_pred->args.size.size = num;
@@ -2162,9 +2170,10 @@ parse_samefile (const struct parser_table* entry, char **argv, int *arg_ptr)
   struct predicate *our_pred;
   struct stat st, fst;
   int fd, openflags;
+  const char *filename;
 
   set_stat_placeholders(&st);
-  if (!collect_arg_stat_info(argv, arg_ptr, &st))
+  if (!collect_arg_stat_info(argv, arg_ptr, &st, &filename))
     return false;
 
   set_stat_placeholders(&fst);
@@ -2289,7 +2298,7 @@ parse_samefile (const struct parser_table* entry, char **argv, int *arg_ptr)
 	}
     }
 
-  our_pred = insert_primary (entry);
+  our_pred = insert_primary (entry, filename);
   our_pred->args.samefileid.ino = st.st_ino;
   our_pred->args.samefileid.dev = st.st_dev;
   our_pred->args.samefileid.fd  = fd;
@@ -2350,7 +2359,7 @@ parse_true (const struct parser_table* entry, char **argv, int *arg_ptr)
   (void) argv;
   (void) arg_ptr;
 
-  our_pred = insert_primary (entry);
+  our_pred = insert_primary_noarg (entry);
   our_pred->need_stat = our_pred->need_type = false;
   our_pred->est_success_rate = 1.0f;
   return true;
@@ -2369,7 +2378,7 @@ parse_accesscheck (const struct parser_table* entry, char **argv, int *arg_ptr)
   struct predicate *our_pred;
   (void) argv;
   (void) arg_ptr;
-  our_pred = insert_primary (entry);
+  our_pred = insert_primary_noarg (entry);
   our_pred->need_stat = our_pred->need_type = false;
   our_pred->side_effects = our_pred->no_default_print = false;
   if (pred_is(our_pred, pred_executable))
@@ -2414,7 +2423,7 @@ parse_used (const struct parser_table* entry, char **argv, int *arg_ptr)
       struct timespec zero = {0,0};
       if (get_relative_timestamp(offset_str, &tval, zero, DAYSECS, errmsg))
 	{
-	  our_pred = insert_primary (entry);
+	  our_pred = insert_primary (entry, offset_str);
 	  our_pred->args.reftime = tval;
 	  our_pred->est_success_rate = estimate_file_age_success_rate(tval.ts.tv_sec / DAYSECS);
 	  return true;
@@ -2472,7 +2481,7 @@ parse_user (const struct parser_table* entry, char **argv, int *arg_ptr)
 	      return false;
 	    }
 	}
-      our_pred = insert_primary (entry);
+      our_pred = insert_primary (entry, username);
       our_pred->args.uid = uid;
       our_pred->est_success_rate = (our_pred->args.uid < 100) ? 0.99 : 0.2;
       return true;
@@ -2650,7 +2659,7 @@ insert_type (char **argv, int *arg_ptr,
 	  error(1, 0, _("Unknown argument to -type: %c"), (*typeletter));
 	  return false;
 	}
-      our_pred = insert_primary_withpred (entry, which_pred);
+      our_pred = insert_primary_withpred (entry, which_pred, typeletter);
       our_pred->est_success_rate = rate;
 
       /* Figure out if we will need to stat the file, because if we don't
@@ -2706,7 +2715,7 @@ insert_fprintf (struct format_val *vec,
   struct segment **segmentp;	/* Address of current segment. */
   struct predicate *our_pred;
 
-  our_pred = insert_primary_withpred (entry, func);
+  our_pred = insert_primary_withpred (entry, func, format_const);
   our_pred->side_effects = our_pred->no_default_print = true;
   our_pred->args.printf_vec = *vec;
   our_pred->need_type = false;
@@ -3045,7 +3054,7 @@ new_insert_exec_ok (const char *action,
   if ((argv == NULL) || (argv[*arg_ptr] == NULL))
     return false;
 
-  our_pred = insert_primary_withpred (entry, func);
+  our_pred = insert_primary_withpred (entry, func, "(some -exec* arguments)");
   our_pred->side_effects = our_pred->no_default_print = true;
   our_pred->need_type = our_pred->need_stat = false;
 
@@ -3374,7 +3383,7 @@ parse_time (const struct parser_table* entry, char *argv[], int *arg_ptr)
   if (!get_relative_timestamp(timearg, &tval, origin, DAYSECS, errmsg))
     return false;
 
-  our_pred = insert_primary (entry);
+  our_pred = insert_primary (entry, orig_timearg);
   our_pred->args.reftime = tval;
   our_pred->est_success_rate = estimate_timestamp_success_rate(tval.ts.tv_sec);
 
@@ -3487,7 +3496,7 @@ insert_num (char **argv, int *arg_ptr, const struct parser_table *entry)
 
     if (get_num (numstr, &num, &c_type))
       {
-	struct predicate *our_pred = insert_primary (entry);
+	struct predicate *our_pred = insert_primary (entry, numstr);
 	our_pred->args.numinfo.kind = c_type;
 	our_pred->args.numinfo.l_val = num;
 
diff --git a/find/tree.c b/find/tree.c
index 7420c60..60a0601 100644
--- a/find/tree.c
+++ b/find/tree.c
@@ -269,10 +269,14 @@ predicate_is_cost_free(const struct predicate *p)
 /* Prints a predicate */
 void print_predicate(FILE *fp, const struct predicate *p)
 {
-  fprintf (fp, "%s%s%s",
-	   p->p_name,
-	   p->arg_text ? " " : "",
-	   p->arg_text ? p->arg_text : "");
+  if (p->arg_text)
+    {
+      fprintf (fp, "%s %s", p->p_name, p->arg_text);
+    }
+  else
+    {
+      fprintf (fp, "%s", p->p_name);
+    }
 }
 
 
@@ -832,7 +836,8 @@ set_new_parent (struct predicate *curr, enum predicate_precedence high_prec, str
   new_parent->need_stat = false;
   new_parent->need_type = false;
   new_parent->p_cost = NeedsNothing;
-  
+  new_parent->arg_text = NULL;
+
   switch (high_prec)
     {
     case COMMA_PREC:
@@ -1393,6 +1398,18 @@ init_pred_perf(struct predicate *pred)
   p->visits = p->successes = 0;
 }
 
+
+struct predicate *
+get_new_pred_noarg (const struct parser_table *entry)
+{
+  struct predicate *p = get_new_pred(entry);
+  if (p)
+    {
+      p->arg_text = NULL;
+    }
+  return p;
+}
+
 
 /* Return a pointer to a new predicate structure, which has been
    linked in as the last one in the predicates list.
@@ -1433,6 +1450,8 @@ get_new_pred (const struct parser_table *entry)
   last_pred->no_default_print = false;
   last_pred->need_stat = true;
   last_pred->need_type = true;
+  last_pred->p_cost = NeedsUnknown;
+  last_pred->arg_text = "ThisShouldBeSetToSomethingElse";
   last_pred->args.str = NULL;
   last_pred->pred_next = NULL;
   last_pred->pred_left = NULL;
@@ -1449,7 +1468,8 @@ get_new_pred (const struct parser_table *entry)
    predicate is an operator.  If it isn't, the AND operator is inserted. */
 
 struct predicate *
-get_new_pred_chk_op (const struct parser_table *entry)
+get_new_pred_chk_op (const struct parser_table *entry,
+		     const char *arg)
 {
   struct predicate *new_pred;
   static const struct parser_table *entry_and = NULL;
@@ -1471,13 +1491,14 @@ get_new_pred_chk_op (const struct parser_table *entry)
       case PRIMARY_TYPE:
       case CLOSE_PAREN:
 	/* We need to interpose the and operator. */
-	new_pred = get_new_pred (entry_and);
+	new_pred = get_new_pred_noarg (entry_and);
 	new_pred->pred_func = pred_and;
 	new_pred->p_name = "-a";
 	new_pred->p_type = BI_OP;
 	new_pred->p_prec = AND_PREC;
 	new_pred->need_stat = false;
 	new_pred->need_type = false;
+	new_pred->arg_text = NULL;
 	new_pred->args.str = NULL;
 	new_pred->side_effects = false;
 	new_pred->no_default_print = false;
@@ -1488,6 +1509,7 @@ get_new_pred_chk_op (const struct parser_table *entry)
       }
   
   new_pred = get_new_pred (entry);
+  new_pred->arg_text = arg;
   new_pred->parser_entry = entry;
   return new_pred;
 }
diff --git a/find/util.c b/find/util.c
index a06eada..cc9a3eb 100644
--- a/find/util.c
+++ b/find/util.c
@@ -89,11 +89,13 @@ static struct debug_option_assoc debugassoc[] =
    operator. */
 
 struct predicate *
-insert_primary_withpred (const struct parser_table *entry, PRED_FUNC pred_func)
+insert_primary_withpred (const struct parser_table *entry,
+			 PRED_FUNC pred_func,
+			 const char *arg)
 {
   struct predicate *new_pred;
 
-  new_pred = get_new_pred_chk_op (entry);
+  new_pred = get_new_pred_chk_op (entry, arg);
   new_pred->pred_func = pred_func;
   new_pred->p_name = entry->parser_name;
   new_pred->args.str = NULL;
@@ -118,10 +120,16 @@ insert_primary_withpred (const struct parser_table *entry, PRED_FUNC pred_func)
    either not there at all (we are the very first node) or is an
    operator. */
 struct predicate *
-insert_primary (const struct parser_table *entry)
+insert_primary (const struct parser_table *entry, const char *arg)
 {
   assert (entry->pred_func != NULL);
-  return insert_primary_withpred(entry, entry->pred_func);
+  return insert_primary_withpred(entry, entry->pred_func, arg);
+}
+
+struct predicate *
+insert_primary_noarg (const struct parser_table *entry)
+{
+  return insert_primary(entry, NULL);
 }