global: convert indentation-TABs to spaces

Transformed via this shell code:
t=$'\t'
git ls-files \
  | grep -vE '(^|/)((GNU)?[Mm]akefile|ChangeLog)|\.(am|mk)$' \
  | grep -vE 'tests/pr/|help2man' \
  | xargs grep -lE "^ *$t" \
  | xargs perl -MText::Tabs -ni -le \
    '$m=/^( *\t[ \t]*)(.*)/; print $m ? expand($1) . $2 : $_'

1 files changed, 175 insertions, 175 deletions

diff --git a/src/chown-core.c b/src/chown-core.c
index 3d6bb0e62..7e5774ee1 100644
--- a/src/chown-core.c
+++ b/src/chown-core.c
@@ -83,8 +83,8 @@ gid_to_name (gid_t gid)
   char buf[INT_BUFSIZE_BOUND (intmax_t)];
   struct group *grp = getgrgid (gid);
   return xstrdup (grp ? grp->gr_name
-		  : TYPE_SIGNED (gid_t) ? imaxtostr (gid, buf)
-		  : umaxtostr (gid, buf));
+                  : TYPE_SIGNED (gid_t) ? imaxtostr (gid, buf)
+                  : umaxtostr (gid, buf));
 }
 
 /* Convert the numeric user-id, UID, to a string stored in xmalloc'd memory,
@@ -97,8 +97,8 @@ uid_to_name (uid_t uid)
   char buf[INT_BUFSIZE_BOUND (intmax_t)];
   struct passwd *pwd = getpwuid (uid);
   return xstrdup (pwd ? pwd->pw_name
-		  : TYPE_SIGNED (uid_t) ? imaxtostr (uid, buf)
-		  : umaxtostr (uid, buf));
+                  : TYPE_SIGNED (uid_t) ? imaxtostr (uid, buf)
+                  : umaxtostr (uid, buf));
 }
 
 /* Tell the user how/if the user and group of FILE have been changed.
@@ -107,7 +107,7 @@ uid_to_name (uid_t uid)
 
 static void
 describe_change (const char *file, enum Change_status changed,
-		 char const *user, char const *group)
+                 char const *user, char const *group)
 {
   const char *fmt;
   char const *spec;
@@ -116,22 +116,22 @@ describe_change (const char *file, enum Change_status changed,
   if (changed == CH_NOT_APPLIED)
     {
       printf (_("neither symbolic link %s nor referent has been changed\n"),
-	      quote (file));
+              quote (file));
       return;
     }
 
   if (user)
     {
       if (group)
-	{
-	  spec_allocated = xmalloc (strlen (user) + 1 + strlen (group) + 1);
-	  stpcpy (stpcpy (stpcpy (spec_allocated, user), ":"), group);
-	  spec = spec_allocated;
-	}
+        {
+          spec_allocated = xmalloc (strlen (user) + 1 + strlen (group) + 1);
+          stpcpy (stpcpy (stpcpy (spec_allocated, user), ":"), group);
+          spec = spec_allocated;
+        }
       else
-	{
-	  spec = user;
-	}
+        {
+          spec = user;
+        }
     }
   else
     {
@@ -142,18 +142,18 @@ describe_change (const char *file, enum Change_status changed,
     {
     case CH_SUCCEEDED:
       fmt = (user ? _("changed ownership of %s to %s\n")
-	     : group ? _("changed group of %s to %s\n")
-	     : _("no change to ownership of %s\n"));
+             : group ? _("changed group of %s to %s\n")
+             : _("no change to ownership of %s\n"));
       break;
     case CH_FAILED:
       fmt = (user ? _("failed to change ownership of %s to %s\n")
-	     : group ? _("failed to change group of %s to %s\n")
-	     : _("failed to change ownership of %s\n"));
+             : group ? _("failed to change group of %s to %s\n")
+             : _("failed to change ownership of %s\n"));
       break;
     case CH_NO_CHANGE_REQUESTED:
       fmt = (user ? _("ownership of %s retained as %s\n")
-	     : group ? _("group of %s retained as %s\n")
-	     : _("ownership of %s retained\n"));
+             : group ? _("group of %s retained as %s\n")
+             : _("ownership of %s retained\n"));
       break;
     default:
       abort ();
@@ -184,9 +184,9 @@ describe_change (const char *file, enum Change_status changed,
 
 static enum RCH_status
 restricted_chown (int cwd_fd, char const *file,
-		  struct stat const *orig_st,
-		  uid_t uid, gid_t gid,
-		  uid_t required_uid, gid_t required_gid)
+                  struct stat const *orig_st,
+                  uid_t uid, gid_t gid,
+                  uid_t required_uid, gid_t required_gid)
 {
   enum RCH_status status = RC_ok;
   struct stat st;
@@ -199,15 +199,15 @@ restricted_chown (int cwd_fd, char const *file,
   if (! S_ISREG (orig_st->st_mode))
     {
       if (S_ISDIR (orig_st->st_mode))
-	open_flags |= O_DIRECTORY;
+        open_flags |= O_DIRECTORY;
       else
-	return RC_do_ordinary_chown;
+        return RC_do_ordinary_chown;
     }
 
   fd = openat (cwd_fd, file, O_RDONLY | open_flags);
   if (! (0 <= fd
-	 || (errno == EACCES && S_ISREG (orig_st->st_mode)
-	     && 0 <= (fd = openat (cwd_fd, file, O_WRONLY | open_flags)))))
+         || (errno == EACCES && S_ISREG (orig_st->st_mode)
+             && 0 <= (fd = openat (cwd_fd, file, O_WRONLY | open_flags)))))
     return (errno == EACCES ? RC_do_ordinary_chown : RC_error);
 
   if (fstat (fd, &st) != 0)
@@ -215,18 +215,18 @@ restricted_chown (int cwd_fd, char const *file,
   else if (! SAME_INODE (*orig_st, st))
     status = RC_inode_changed;
   else if ((required_uid == (uid_t) -1 || required_uid == st.st_uid)
-	   && (required_gid == (gid_t) -1 || required_gid == st.st_gid))
+           && (required_gid == (gid_t) -1 || required_gid == st.st_gid))
     {
       if (fchown (fd, uid, gid) == 0)
-	{
-	  status = (close (fd) == 0
-		    ? RC_ok : RC_error);
-	  return status;
-	}
+        {
+          status = (close (fd) == 0
+                    ? RC_ok : RC_error);
+          return status;
+        }
       else
-	{
-	  status = RC_error;
-	}
+        {
+          status = RC_error;
+        }
     }
 
   { /* FIXME: remove these curly braces when we assume C99.  */
@@ -245,9 +245,9 @@ restricted_chown (int cwd_fd, char const *file,
    Return true if successful.  */
 static bool
 change_file_owner (FTS *fts, FTSENT *ent,
-		   uid_t uid, gid_t gid,
-		   uid_t required_uid, gid_t required_gid,
-		   struct Chown_option const *chopt)
+                   uid_t uid, gid_t gid,
+                   uid_t required_uid, gid_t required_gid,
+                   struct Chown_option const *chopt)
 {
   char const *file_full_name = ent->fts_path;
   char const *file = ent->fts_accpath;
@@ -261,44 +261,44 @@ change_file_owner (FTS *fts, FTSENT *ent,
     {
     case FTS_D:
       if (chopt->recurse)
-	{
-	  if (ROOT_DEV_INO_CHECK (chopt->root_dev_ino, ent->fts_statp))
-	    {
-	      /* This happens e.g., with "chown -R --preserve-root 0 /"
-		 and with "chown -RH --preserve-root 0 symlink-to-root".  */
-	      ROOT_DEV_INO_WARN (file_full_name);
-	      /* Tell fts not to traverse into this hierarchy.  */
-	      fts_set (fts, ent, FTS_SKIP);
-	      /* Ensure that we do not process "/" on the second visit.  */
-	      ent = fts_read (fts);
-	      return false;
-	    }
-	  return true;
-	}
+        {
+          if (ROOT_DEV_INO_CHECK (chopt->root_dev_ino, ent->fts_statp))
+            {
+              /* This happens e.g., with "chown -R --preserve-root 0 /"
+                 and with "chown -RH --preserve-root 0 symlink-to-root".  */
+              ROOT_DEV_INO_WARN (file_full_name);
+              /* Tell fts not to traverse into this hierarchy.  */
+              fts_set (fts, ent, FTS_SKIP);
+              /* Ensure that we do not process "/" on the second visit.  */
+              ent = fts_read (fts);
+              return false;
+            }
+          return true;
+        }
       break;
 
     case FTS_DP:
       if (! chopt->recurse)
-	return true;
+        return true;
       break;
 
     case FTS_NS:
       /* For a top-level file or directory, this FTS_NS (stat failed)
-	 indicator is determined at the time of the initial fts_open call.
-	 With programs like chmod, chown, and chgrp, that modify
-	 permissions, it is possible that the file in question is
-	 accessible when control reaches this point.  So, if this is
-	 the first time we've seen the FTS_NS for this file, tell
-	 fts_read to stat it "again".  */
+         indicator is determined at the time of the initial fts_open call.
+         With programs like chmod, chown, and chgrp, that modify
+         permissions, it is possible that the file in question is
+         accessible when control reaches this point.  So, if this is
+         the first time we've seen the FTS_NS for this file, tell
+         fts_read to stat it "again".  */
       if (ent->fts_level == 0 && ent->fts_number == 0)
-	{
-	  ent->fts_number = 1;
-	  fts_set (fts, ent, FTS_AGAIN);
-	  return true;
-	}
+        {
+          ent->fts_number = 1;
+          fts_set (fts, ent, FTS_AGAIN);
+          return true;
+        }
       if (! chopt->force_silent)
         error (0, ent->fts_errno, _("cannot access %s"),
-	       quote (file_full_name));
+               quote (file_full_name));
       ok = false;
       break;
 
@@ -311,7 +311,7 @@ change_file_owner (FTS *fts, FTSENT *ent,
     case FTS_DNR:
       if (! chopt->force_silent)
         error (0, ent->fts_errno, _("cannot read directory %s"),
-	       quote (file_full_name));
+               quote (file_full_name));
       ok = false;
       break;
 
@@ -325,9 +325,9 @@ change_file_owner (FTS *fts, FTSENT *ent,
       file_stats = NULL;
     }
   else if (required_uid == (uid_t) -1 && required_gid == (gid_t) -1
-	   && chopt->verbosity == V_off
-	   && ! chopt->root_dev_ino
-	   && ! chopt->affect_symlink_referent)
+           && chopt->verbosity == V_off
+           && ! chopt->root_dev_ino
+           && ! chopt->affect_symlink_referent)
     {
       do_chown = true;
       file_stats = ent->fts_statp;
@@ -337,25 +337,25 @@ change_file_owner (FTS *fts, FTSENT *ent,
       file_stats = ent->fts_statp;
 
       /* If this is a symlink and we're dereferencing them,
-	 stat it to get info on the referent.  */
+         stat it to get info on the referent.  */
       if (chopt->affect_symlink_referent && S_ISLNK (file_stats->st_mode))
-	{
-	  if (fstatat (fts->fts_cwd_fd, file, &stat_buf, 0) != 0)
-	    {
-	      if (! chopt->force_silent)
-	        error (0, errno, _("cannot dereference %s"),
-		       quote (file_full_name));
-	      ok = false;
-	    }
-
-	  file_stats = &stat_buf;
-	}
+        {
+          if (fstatat (fts->fts_cwd_fd, file, &stat_buf, 0) != 0)
+            {
+              if (! chopt->force_silent)
+                error (0, errno, _("cannot dereference %s"),
+                       quote (file_full_name));
+              ok = false;
+            }
+
+          file_stats = &stat_buf;
+        }
 
       do_chown = (ok
-		  && (required_uid == (uid_t) -1
-		      || required_uid == file_stats->st_uid)
-		  && (required_gid == (gid_t) -1
-		      || required_gid == file_stats->st_gid));
+                  && (required_uid == (uid_t) -1
+                      || required_uid == file_stats->st_uid)
+                  && (required_gid == (gid_t) -1
+                      || required_gid == file_stats->st_gid));
     }
 
   /* This happens when chown -LR --preserve-root encounters a symlink-to-/.  */
@@ -370,89 +370,89 @@ change_file_owner (FTS *fts, FTSENT *ent,
   if (do_chown)
     {
       if ( ! chopt->affect_symlink_referent)
-	{
-	  ok = (lchownat (fts->fts_cwd_fd, file, uid, gid) == 0);
-
-	  /* Ignore any error due to lack of support; POSIX requires
-	     this behavior for top-level symbolic links with -h, and
-	     implies that it's required for all symbolic links.  */
-	  if (!ok && errno == EOPNOTSUPP)
-	    {
-	      ok = true;
-	      symlink_changed = false;
-	    }
-	}
+        {
+          ok = (lchownat (fts->fts_cwd_fd, file, uid, gid) == 0);
+
+          /* Ignore any error due to lack of support; POSIX requires
+             this behavior for top-level symbolic links with -h, and
+             implies that it's required for all symbolic links.  */
+          if (!ok && errno == EOPNOTSUPP)
+            {
+              ok = true;
+              symlink_changed = false;
+            }
+        }
       else
-	{
-	  /* If possible, avoid a race condition with --from=O:G and without the
-	     (-h) --no-dereference option.  If fts's stat call determined
-	     that the uid/gid of FILE matched the --from=O:G-selected
-	     owner and group IDs, blindly using chown(2) here could lead
-	     chown(1) or chgrp(1) mistakenly to dereference a *symlink*
-	     to an arbitrary file that an attacker had moved into the
-	     place of FILE during the window between the stat and
-	     chown(2) calls.  If FILE is a regular file or a directory
-	     that can be opened, this race condition can be avoided safely.  */
-
-	  enum RCH_status err
-	    = restricted_chown (fts->fts_cwd_fd, file, file_stats, uid, gid,
-				required_uid, required_gid);
-	  switch (err)
-	    {
-	    case RC_ok:
-	      break;
-
-	    case RC_do_ordinary_chown:
-	      ok = (chownat (fts->fts_cwd_fd, file, uid, gid) == 0);
-	      break;
-
-	    case RC_error:
-	      ok = false;
-	      break;
-
-	    case RC_inode_changed:
-	      /* FIXME: give a diagnostic in this case?  */
-	    case RC_excluded:
-	      do_chown = false;
-	      ok = false;
-	      break;
-
-	    default:
-	      abort ();
-	    }
-	}
+        {
+          /* If possible, avoid a race condition with --from=O:G and without the
+             (-h) --no-dereference option.  If fts's stat call determined
+             that the uid/gid of FILE matched the --from=O:G-selected
+             owner and group IDs, blindly using chown(2) here could lead
+             chown(1) or chgrp(1) mistakenly to dereference a *symlink*
+             to an arbitrary file that an attacker had moved into the
+             place of FILE during the window between the stat and
+             chown(2) calls.  If FILE is a regular file or a directory
+             that can be opened, this race condition can be avoided safely.  */
+
+          enum RCH_status err
+            = restricted_chown (fts->fts_cwd_fd, file, file_stats, uid, gid,
+                                required_uid, required_gid);
+          switch (err)
+            {
+            case RC_ok:
+              break;
+
+            case RC_do_ordinary_chown:
+              ok = (chownat (fts->fts_cwd_fd, file, uid, gid) == 0);
+              break;
+
+            case RC_error:
+              ok = false;
+              break;
+
+            case RC_inode_changed:
+              /* FIXME: give a diagnostic in this case?  */
+            case RC_excluded:
+              do_chown = false;
+              ok = false;
+              break;
+
+            default:
+              abort ();
+            }
+        }
 
       /* On some systems (e.g., GNU/Linux 2.4.x),
-	 the chown function resets the `special' permission bits.
-	 Do *not* restore those bits;  doing so would open a window in
-	 which a malicious user, M, could subvert a chown command run
-	 by some other user and operating on files in a directory
-	 where M has write access.  */
+         the chown function resets the `special' permission bits.
+         Do *not* restore those bits;  doing so would open a window in
+         which a malicious user, M, could subvert a chown command run
+         by some other user and operating on files in a directory
+         where M has write access.  */
 
       if (do_chown && !ok && ! chopt->force_silent)
-	error (0, errno, (uid != (uid_t) -1
-			  ? _("changing ownership of %s")
-			  : _("changing group of %s")),
-	       quote (file_full_name));
+        error (0, errno, (uid != (uid_t) -1
+                          ? _("changing ownership of %s")
+                          : _("changing group of %s")),
+               quote (file_full_name));
     }
 
   if (chopt->verbosity != V_off)
     {
       bool changed =
-	((do_chown & ok & symlink_changed)
-	 && ! ((uid == (uid_t) -1 || uid == file_stats->st_uid)
-	       && (gid == (gid_t) -1 || gid == file_stats->st_gid)));
+        ((do_chown & ok & symlink_changed)
+         && ! ((uid == (uid_t) -1 || uid == file_stats->st_uid)
+               && (gid == (gid_t) -1 || gid == file_stats->st_gid)));
 
       if (changed || chopt->verbosity == V_high)
-	{
-	  enum Change_status ch_status =
-	    (!ok ? CH_FAILED
-	     : !symlink_changed ? CH_NOT_APPLIED
-	     : !changed ? CH_NO_CHANGE_REQUESTED
-	     : CH_SUCCEEDED);
-	  describe_change (file_full_name, ch_status,
-			   chopt->user_name, chopt->group_name);
-	}
+        {
+          enum Change_status ch_status =
+            (!ok ? CH_FAILED
+             : !symlink_changed ? CH_NOT_APPLIED
+             : !changed ? CH_NO_CHANGE_REQUESTED
+             : CH_SUCCEEDED);
+          describe_change (file_full_name, ch_status,
+                           chopt->user_name, chopt->group_name);
+        }
     }
 
   if ( ! chopt->recurse)
@@ -472,18 +472,18 @@ change_file_owner (FTS *fts, FTSENT *ent,
    Return true if successful.  */
 extern bool
 chown_files (char **files, int bit_flags,
-	     uid_t uid, gid_t gid,
-	     uid_t required_uid, gid_t required_gid,
-	     struct Chown_option const *chopt)
+             uid_t uid, gid_t gid,
+             uid_t required_uid, gid_t required_gid,
+             struct Chown_option const *chopt)
 {
   bool ok = true;
 
   /* Use lstat and stat only if they're needed.  */
   int stat_flags = ((required_uid != (uid_t) -1 || required_gid != (gid_t) -1
-		     || chopt->affect_symlink_referent
-		     || chopt->verbosity != V_off)
-		    ? 0
-		    : FTS_NOSTAT);
+                     || chopt->affect_symlink_referent
+                     || chopt->verbosity != V_off)
+                    ? 0
+                    : FTS_NOSTAT);
 
   FTS *fts = xfts_open (files, bit_flags | stat_flags, NULL);
 
@@ -493,19 +493,19 @@ chown_files (char **files, int bit_flags,
 
       ent = fts_read (fts);
       if (ent == NULL)
-	{
-	  if (errno != 0)
-	    {
-	      /* FIXME: try to give a better message  */
-	      if (! chopt->force_silent)
-	        error (0, errno, _("fts_read failed"));
-	      ok = false;
-	    }
-	  break;
-	}
+        {
+          if (errno != 0)
+            {
+              /* FIXME: try to give a better message  */
+              if (! chopt->force_silent)
+                error (0, errno, _("fts_read failed"));
+              ok = false;
+            }
+          break;
+        }
 
       ok &= change_file_owner (fts, ent, uid, gid,
-			       required_uid, required_gid, chopt);
+                               required_uid, required_gid, chopt);
     }
 
   /* Ignore failure, since the only way it can do so is in failing to