Restoring authorship annotation for <lsurn@yandex-team.ru>. Commit 1 of 2.

2 files changed, 216 insertions, 216 deletions

diff --git a/util/folder/fts.cpp b/util/folder/fts.cpp
index 0e6a6f86eb..7d9417ea35 100644
--- a/util/folder/fts.cpp
+++ b/util/folder/fts.cpp
@@ -1,38 +1,38 @@
-/*-
- * Copyright (c) 1990, 1993, 1994
+/*- 
+ * Copyright (c) 1990, 1993, 1994 
  *    The Regents of the University of California.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
+ * 
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions 
+ * are met: 
+ * 1. Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer. 
+ * 2. Redistributions in binary form must reproduce the above copyright 
+ *    notice, this list of conditions and the following disclaimer in the 
+ *    documentation and/or other materials provided with the distribution. 
+ * 3. All advertising materials mentioning features or use of this software 
+ *    must display the following acknowledgement: 
  *    This product includes software developed by the University of
  *    California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
+ * 4. Neither the name of the University nor the names of its contributors 
+ *    may be used to endorse or promote products derived from this software 
+ *    without specific prior written permission. 
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 
+ * SUCH DAMAGE. 
  *
  * $OpenBSD: fts.c,v 1.22 1999/10/03 19:22:22 millert Exp $
- */
-
+ */ 
+ 
 #include <util/memory/tempbuf.h>
 #include <util/system/compat.h>
 #include <util/system/compiler.h>
@@ -52,10 +52,10 @@
     #include "dirent_win.h"
     #include "lstat_win.h"
 #endif
-
-#include <sys/stat.h>
-
-#include <fcntl.h>
+ 
+#include <sys/stat.h> 
+ 
+#include <fcntl.h> 
 
 #include "fts.h"
 #include <limits.h>
@@ -165,7 +165,7 @@ dird get_dird(char* path) {
 }
 
 #endif // ndef _win_
-
+ 
 #ifdef _win_
     #define S_ISDIR(st_mode) ((st_mode & _S_IFMT) == _S_IFDIR)
     #define S_ISREG(st_mode) ((st_mode & _S_IFMT) == _S_IFREG)
@@ -187,10 +187,10 @@ static int fts_safe_changedir(FTS*, FTSENT*, int, dird);
         #define dirfd(dirp) ((dirp)->dd_fd)
     #endif
     #define D_NAMLEN(dirp) (strlen(dirp->d_name))
-#else
+#else 
     #define D_NAMLEN(dirp) (dirp->d_namlen)
-#endif
-
+#endif 
+ 
 static FTSENT* fts_alloc(FTS*, const char*, int);
 static FTSENT* fts_build(FTS*, int);
 static void fts_lfree(FTSENT*);
@@ -201,20 +201,20 @@ static int fts_palloc(FTS*, size_t);
 static FTSENT* fts_sort(FTS*, FTSENT*, int);
 static u_short fts_stat(FTS*, FTSENT*, int);
 static int fts_safe_changedir(FTS*, FTSENT*, int, const char*);
-
+ 
 #define ISDOT(a) (a[0] == '.' && (!a[1] || (a[1] == '.' && !a[2])))
-
+ 
 #define CLR(opt) (sp->fts_options &= ~(opt))
 #define ISSET(opt) (sp->fts_options & (opt))
 #define SET(opt) (sp->fts_options |= (opt))
-
+ 
 #define FCHDIR(sp, fd) (!ISSET(FTS_NOCHDIR) && chdir_dird(fd))
-
-/* fts_build flags */
+ 
+/* fts_build flags */ 
 #define BCHILD 1 /* yfts_children */
 #define BNAMES 2 /* yfts_children, names only */
 #define BREAD 3  /* yfts_read */
-
+ 
 static u_short
 yfts_type_from_info(u_short info) {
     if (info == FTS_D || info == FTS_DP || info == FTS_DOT) {
@@ -229,24 +229,24 @@ yfts_type_from_info(u_short info) {
 
 static void*
 yreallocf(void* ptr, size_t size)
-{
+{ 
     void* nptr;
-
+ 
     nptr = realloc(ptr, size);
     if (!nptr && ptr) {
         free(ptr);
     }
     return (nptr);
-}
+} 
 
 FTS* yfts_open(char* const* argv, int options, int (*compar)(const FTSENT**, const FTSENT**))
-{
+{ 
     FTS* sp;
     FTSENT *p, *root;
     int nitems;
     FTSENT *parent, *tmp;
     int len;
-
+ 
     errno = 0;
 
     Y_ASSERT(argv);
@@ -260,7 +260,7 @@ FTS* yfts_open(char* const* argv, int options, int (*compar)(const FTSENT**, con
         errno = EINVAL;
         return nullptr;
     }
-
+ 
     /* Allocate/initialize the stream */
     if ((sp = (FTS*)malloc(sizeof(FTS))) == nullptr) {
         return nullptr;
@@ -268,7 +268,7 @@ FTS* yfts_open(char* const* argv, int options, int (*compar)(const FTSENT**, con
     memset(sp, 0, sizeof(FTS));
     sp->fts_compar = compar;
     sp->fts_options = options;
-
+ 
     /* Shush, GCC. */
     tmp = nullptr;
 
@@ -276,7 +276,7 @@ FTS* yfts_open(char* const* argv, int options, int (*compar)(const FTSENT**, con
     if (ISSET(FTS_LOGICAL)) {
         SET(FTS_NOCHDIR);
     }
-
+ 
     /*
      * Start out with 1K of path space, and enough, in any case,
      * to hold the user's paths.
@@ -284,13 +284,13 @@ FTS* yfts_open(char* const* argv, int options, int (*compar)(const FTSENT**, con
     if (fts_palloc(sp, MAX(fts_maxarglen(argv), MAXPATHLEN))) {
         goto mem1;
     }
-
+ 
     /* Allocate/initialize root's parent. */
     if ((parent = fts_alloc(sp, "", 0)) == nullptr) {
         goto mem2;
     }
     parent->fts_level = FTS_ROOTPARENTLEVEL;
-
+ 
     /* Allocate/initialize root(s). */
     for (root = nullptr, nitems = 0; *argv; ++argv, ++nitems) {
         /* Don't allow zero-length paths. */
@@ -308,19 +308,19 @@ FTS* yfts_open(char* const* argv, int options, int (*compar)(const FTSENT**, con
             errno = ENOENT;
             goto mem3;
         }
-
+ 
         p = fts_alloc(sp, *argv, len);
         p->fts_level = FTS_ROOTLEVEL;
         p->fts_parent = parent;
         p->fts_accpath = p->fts_name;
         p->fts_info = fts_stat(sp, p, ISSET(FTS_COMFOLLOW));
         p->fts_type = yfts_type_from_info(p->fts_info);
-
+ 
         /* Command-line "." and ".." are real directories. */
         if (p->fts_info == FTS_DOT) {
             p->fts_info = FTS_D;
         }
-
+ 
         /*
          * If comparison routine supplied, traverse in sorted
          * order; otherwise traverse in the order specified.
@@ -341,7 +341,7 @@ FTS* yfts_open(char* const* argv, int options, int (*compar)(const FTSENT**, con
     if (compar && nitems > 1) {
         root = fts_sort(sp, root, nitems);
     }
-
+ 
     /*
      * Allocate a dummy pointer and make yfts_read think that we've just
      * finished the node before the root(s); set p->fts_info to FTS_INIT
@@ -353,7 +353,7 @@ FTS* yfts_open(char* const* argv, int options, int (*compar)(const FTSENT**, con
     sp->fts_cur->fts_level = FTS_ROOTLEVEL;
     sp->fts_cur->fts_link = root;
     sp->fts_cur->fts_info = FTS_INIT;
-
+ 
     /*
      * If using chdir(2), grab a file descriptor pointing to dot to ensure
      * that we can get back here; this could be avoided for some paths,
@@ -365,9 +365,9 @@ FTS* yfts_open(char* const* argv, int options, int (*compar)(const FTSENT**, con
     if (!ISSET(FTS_NOCHDIR) && valid_dird(sp->fts_rfd = get_cwdd())) {
         SET(FTS_NOCHDIR);
     }
-
+ 
     return (sp);
-
+ 
 mem3:
     fts_lfree(root);
     free(parent);
@@ -376,14 +376,14 @@ mem2:
 mem1:
     free(sp);
     return nullptr;
-}
-
-static void
+} 
+ 
+static void 
 fts_load(FTS* sp, FTSENT* p)
-{
+{ 
     size_t len;
     char* cp;
-
+ 
     /*
      * Load the stream structure for the next traversal.  Since we don't
      * actually enter the directory until after the preorder visit, set
@@ -400,13 +400,13 @@ fts_load(FTS* sp, FTSENT* p)
     }
     p->fts_accpath = p->fts_path = sp->fts_path;
     sp->fts_dev = p->fts_dev;
-}
-
+} 
+ 
 int yfts_close(FTS* sp)
-{
+{ 
     FTSENT *freep, *p;
     int saved_errno;
-
+ 
     /*
      * This still works if we haven't read anything -- the dummy structure
      * points to the root list, so we step through to the end of the root
@@ -420,7 +420,7 @@ int yfts_close(FTS* sp)
         }
         free(p);
     }
-
+ 
     /* Free up child linked list, sort array, path buffer. */
     if (sp->fts_child) {
         fts_lfree(sp->fts_child);
@@ -429,7 +429,7 @@ int yfts_close(FTS* sp)
         free(sp->fts_array);
     }
     free(sp->fts_path);
-
+ 
     /* Return to original directory, save errno if necessary. */
     if (!ISSET(FTS_NOCHDIR)) {
         saved_errno = chdir_dird(sp->fts_rfd) ? errno : 0;
@@ -443,49 +443,49 @@ int yfts_close(FTS* sp)
             return (-1);
         }
     }
-
+ 
     /* Free up the stream pointer. */
     free(sp);
     return (0);
-}
-
-/*
+} 
+ 
+/* 
  * Special case of "/" at the end of the path so that slashes aren't
  * appended which would cause paths to be written as "....//foo".
- */
+ */ 
 #define NAPPEND(p)                                 \
     (p->fts_path[p->fts_pathlen - 1] == LOCSLASH_C \
          ? p->fts_pathlen - 1                      \
          : p->fts_pathlen)
-
+ 
 FTSENT*
 yfts_read(FTS* sp) {
     FTSENT *p, *tmp;
     int instr;
     char* t;
     int saved_errno;
-
+ 
     ClearLastSystemError();
 
     /* If finished or unrecoverable error, return NULL. */
     if (sp->fts_cur == nullptr || ISSET(FTS_STOP)) {
         return nullptr;
     }
-
+ 
     /* Set current node pointer. */
     p = sp->fts_cur;
-
+ 
     /* Save and zero out user instructions. */
     instr = p->fts_instr;
     p->fts_instr = FTS_NOINSTR;
-
+ 
     /* Any type of file may be re-visited; re-stat and re-turn. */
     if (instr == FTS_AGAIN) {
         p->fts_info = fts_stat(sp, p, 0);
         p->fts_type = yfts_type_from_info(p->fts_info);
         return (p);
     }
-
+ 
     /*
      * Following a symlink -- SLNONE test allows application to see
      * SLNONE and recover.  If indirecting through a symlink, have
@@ -506,7 +506,7 @@ yfts_read(FTS* sp) {
         }
         return (p);
     }
-
+ 
     /* Directory in pre-order. */
     if (p->fts_info == FTS_D) {
         /* If skipped or crossed mount point, do post-order visit. */
@@ -522,14 +522,14 @@ yfts_read(FTS* sp) {
             p->fts_info = FTS_DP;
             return (p);
         }
-
+ 
         /* Rebuild if only read the names and now traversing. */
         if (sp->fts_child && ISSET(FTS_NAMEONLY)) {
             CLR(FTS_NAMEONLY);
             fts_lfree(sp->fts_child);
             sp->fts_child = nullptr;
         }
-
+ 
         /*
          * Cd to the subdirectory.
          *
@@ -561,13 +561,13 @@ yfts_read(FTS* sp) {
         sp->fts_child = nullptr;
         goto name;
     }
-
+ 
     /* Move to the next node on this level. */
 next:
     tmp = p;
     if ((p = p->fts_link) != nullptr) {
         free(tmp);
-
+ 
         /*
          * If reached the top, return to the original directory (or
          * the root of the tree), and load the paths for the next root.
@@ -580,7 +580,7 @@ next:
             fts_load(sp, p);
             return (sp->fts_cur = p);
         }
-
+ 
         /*
          * User may have called yfts_set on the node.  If skipped,
          * ignore.  If followed, get a file descriptor so we can
@@ -603,18 +603,18 @@ next:
             }
             p->fts_instr = FTS_NOINSTR;
         }
-
+ 
     name:
         t = sp->fts_path + NAPPEND(p->fts_parent);
         *t++ = LOCSLASH_C;
         memmove(t, p->fts_name, (size_t)p->fts_namelen + 1);
         return (sp->fts_cur = p);
     }
-
+ 
     /* Move up to the parent node. */
     p = tmp->fts_parent;
     free(tmp);
-
+ 
     if (p->fts_level == FTS_ROOTPARENTLEVEL) {
         /*
          * Done; free everything up and set errno to 0 so the user
@@ -624,10 +624,10 @@ next:
         errno = 0;
         return (sp->fts_cur = nullptr);
     }
-
+ 
     /* NUL terminate the pathname. */
     sp->fts_path[p->fts_pathlen] = '\0';
-
+ 
     /*
      * Return to the parent directory.  If at a root node or came through
      * a symlink, go back through the file descriptor.  Otherwise, cd up
@@ -654,17 +654,17 @@ next:
     }
     p->fts_info = p->fts_errno ? FTS_ERR : FTS_DP;
     return (sp->fts_cur = p);
-}
-
-/*
- * Fts_set takes the stream as an argument although it's not used in this
- * implementation; it would be necessary if anyone wanted to add global
- * semantics to fts using yfts_set.  An error return is allowed for similar
- * reasons.
- */
-/* ARGSUSED */
+} 
+ 
+/* 
+ * Fts_set takes the stream as an argument although it's not used in this 
+ * implementation; it would be necessary if anyone wanted to add global 
+ * semantics to fts using yfts_set.  An error return is allowed for similar 
+ * reasons. 
+ */ 
+/* ARGSUSED */ 
 int yfts_set(FTS* sp, FTSENT* p, int instr)
-{
+{ 
     (void)sp; //Unused
     if (instr && instr != FTS_AGAIN && instr != FTS_FOLLOW &&
         instr != FTS_NOINSTR && instr != FTS_SKIP) {
@@ -673,37 +673,37 @@ int yfts_set(FTS* sp, FTSENT* p, int instr)
     }
     p->fts_instr = (u_short)instr;
     return (0);
-}
-
+} 
+ 
 FTSENT*
 yfts_children(FTS* sp, int instr)
-{
+{ 
     FTSENT* p;
     dird fd;
     if (instr && instr != FTS_NAMEONLY) {
         errno = EINVAL;
         return nullptr;
     }
-
+ 
     /* Set current node pointer. */
     p = sp->fts_cur;
-
+ 
     /*
      * Errno set to 0 so user can distinguish empty directory from
      * an error.
      */
     errno = 0;
-
+ 
     /* Fatal errors stop here. */
     if (ISSET(FTS_STOP)) {
         return nullptr;
     }
-
+ 
     /* Return logical hierarchy of user's arguments. */
     if (p->fts_info == FTS_INIT) {
         return (p->fts_link);
     }
-
+ 
     /*
      * If not a directory being visited in pre-order, stop here.  Could
      * allow FTS_DNR, assuming the user has fixed the problem, but the
@@ -712,19 +712,19 @@ yfts_children(FTS* sp, int instr)
     if (p->fts_info != FTS_D /* && p->fts_info != FTS_DNR */) {
         return nullptr;
     }
-
+ 
     /* Free up any previous child list. */
     if (sp->fts_child) {
         fts_lfree(sp->fts_child);
     }
-
+ 
     if (instr == FTS_NAMEONLY) {
         SET(FTS_NAMEONLY);
         instr = BNAMES;
     } else {
         instr = BCHILD;
     }
-
+ 
     /*
      * If using chdir on a relative path and called BEFORE yfts_read does
      * its chdir to the root of a traversal, we can lose -- we need to
@@ -736,7 +736,7 @@ yfts_children(FTS* sp, int instr)
         ISSET(FTS_NOCHDIR)) {
         return (sp->fts_child = fts_build(sp, instr));
     }
-
+ 
     if (valid_dird(fd = get_cwdd())) {
         return nullptr;
     }
@@ -747,8 +747,8 @@ yfts_children(FTS* sp, int instr)
     }
     close_dird(fd);
     return (sp->fts_child);
-}
-
+} 
+ 
 static inline struct dirent* yreaddir(DIR* dir, struct dirent* de) {
     // TODO(yazevnul|IGNIETFERRO-1070): remove these macroses by replacing `readdir_r` with proper
     // alternative
@@ -762,23 +762,23 @@ static inline struct dirent* yreaddir(DIR* dir, struct dirent* de) {
     return nullptr;
 }
 
-/*
- * This is the tricky part -- do not casually change *anything* in here.  The
- * idea is to build the linked list of entries that are used by yfts_children
- * and yfts_read.  There are lots of special cases.
- *
- * The real slowdown in walking the tree is the stat calls.  If FTS_NOSTAT is
- * set and it's a physical walk (so that symbolic links can't be directories),
- * we can do things quickly.  First, if it's a 4.4BSD file system, the type
- * of the file is in the directory entry.  Otherwise, we assume that the number
- * of subdirectories in a node is equal to the number of links to the parent.
- * The former skips all stat calls.  The latter skips stat calls in any leaf
- * directories and for any files after the subdirectories in the directory have
- * been found, cutting the stat calls by about 2/3.
- */
+/* 
+ * This is the tricky part -- do not casually change *anything* in here.  The 
+ * idea is to build the linked list of entries that are used by yfts_children 
+ * and yfts_read.  There are lots of special cases. 
+ * 
+ * The real slowdown in walking the tree is the stat calls.  If FTS_NOSTAT is 
+ * set and it's a physical walk (so that symbolic links can't be directories), 
+ * we can do things quickly.  First, if it's a 4.4BSD file system, the type 
+ * of the file is in the directory entry.  Otherwise, we assume that the number 
+ * of subdirectories in a node is equal to the number of links to the parent. 
+ * The former skips all stat calls.  The latter skips stat calls in any leaf 
+ * directories and for any files after the subdirectories in the directory have 
+ * been found, cutting the stat calls by about 2/3. 
+ */ 
 static FTSENT*
 fts_build(FTS* sp, int type)
-{
+{ 
     struct dirent* dp;
     FTSENT *p, *head;
     int nitems;
@@ -795,10 +795,10 @@ fts_build(FTS* sp, int type)
     int cderrno, descend, len, level, maxlen, nlinks, saved_errno,
         nostat, doadjust;
     char* cp;
-
+ 
     /* Set current node pointer. */
     cur = sp->fts_cur;
-
+ 
     /*
      * Open the directory for reading.  If this fails, we're done.
      * If being called from yfts_read, set the fts_info field.
@@ -818,7 +818,7 @@ fts_build(FTS* sp, int type)
         }
         return nullptr;
     }
-
+ 
 #ifdef _win_
     dirpd = get_dird(cur->fts_accpath);
 #endif
@@ -839,7 +839,7 @@ fts_build(FTS* sp, int type)
         nlinks = -1;
         nostat = 0;
     }
-
+ 
     /*
      * If we're going to need to stat anything or we want to descend
      * and stay in the directory, chdir.  If this fails we keep going,
@@ -883,7 +883,7 @@ fts_build(FTS* sp, int type)
     } else {
         descend = 0;
     }
-
+ 
     /*
      * Figure out the max file name length that can be stored in the
      * current path -- the inner loop allocates more path as necessary.
@@ -904,9 +904,9 @@ fts_build(FTS* sp, int type)
     }
     ++len;
     maxlen = sp->fts_pathlen - len;
-
+ 
     level = cur->fts_level + 1;
-
+ 
     /* Read the directory, attaching each entry to the `link' pointer. */
     doadjust = 0;
 
@@ -917,7 +917,7 @@ fts_build(FTS* sp, int type)
         if (!ISSET(FTS_SEEDOT) && ISDOT(dp->d_name)) {
             continue;
         }
-
+ 
         if ((p = fts_alloc(sp, dp->d_name, (int)strlen(dp->d_name))) == nullptr) {
             goto mem1;
         }
@@ -953,7 +953,7 @@ fts_build(FTS* sp, int type)
             }
             maxlen = sp->fts_pathlen - len;
         }
-
+ 
         if (len + strlen(dp->d_name) >= USHRT_MAX) {
             /*
              * In an FTSENT, fts_pathlen is a u_short so it is
@@ -975,7 +975,7 @@ fts_build(FTS* sp, int type)
         p->fts_level = (short)level;
         p->fts_parent = sp->fts_cur;
         p->fts_pathlen = u_short(len + strlen(dp->d_name));
-
+ 
 #ifdef FTS_WHITEOUT
         if (dp->d_type == DT_WHT)
             p->fts_flags |= FTS_ISW;
@@ -1001,10 +1001,10 @@ fts_build(FTS* sp, int type)
             }
             p->fts_accpath = cur->fts_accpath;
         } else if (nlinks == 0
-#ifdef DT_DIR
+#ifdef DT_DIR 
                    || (nostat &&
                        dp->d_type != DT_DIR && dp->d_type != DT_UNKNOWN)
-#endif
+#endif 
         ) {
             p->fts_accpath =
                 ISSET(FTS_NOCHDIR) ? p->fts_path : p->fts_name;
@@ -1020,14 +1020,14 @@ fts_build(FTS* sp, int type)
             /* Stat it. */
             p->fts_info = fts_stat(sp, p, 0);
             p->fts_type = yfts_type_from_info(p->fts_info);
-
+ 
             /* Decrement link count if applicable. */
             if (nlinks > 0 && (p->fts_info == FTS_D ||
                                p->fts_info == FTS_DC || p->fts_info == FTS_DOT)) {
                 --nlinks;
             }
         }
-
+ 
         /* We walk in directory order so "ls -f" doesn't get upset. */
         p->fts_link = nullptr;
         if (head == nullptr) {
@@ -1044,7 +1044,7 @@ fts_build(FTS* sp, int type)
         close_dird(dirpd);
 #endif
     }
-
+ 
     /*
      * If realloc() changed the address of the path, adjust the
      * addresses for the rest of the tree and the dir list.
@@ -1052,7 +1052,7 @@ fts_build(FTS* sp, int type)
     if (doadjust) {
         fts_padjust(sp);
     }
-
+ 
     /*
      * If not changing directories, reset the path back to original
      * state.
@@ -1063,7 +1063,7 @@ fts_build(FTS* sp, int type)
         }
         *cp = '\0';
     }
-
+ 
     /*
      * If descended after called from yfts_children or after called from
      * yfts_read and nothing found, get back.  At the root level we use
@@ -1078,7 +1078,7 @@ fts_build(FTS* sp, int type)
         fts_lfree(head);
         return nullptr;
     }
-
+ 
     /* If didn't find anything, return NULL. */
     if (!nitems) {
         if (type == BREAD) {
@@ -1087,24 +1087,24 @@ fts_build(FTS* sp, int type)
         fts_lfree(head);
         return nullptr;
     }
-
+ 
     /* Sort the entries. */
     if (sp->fts_compar && nitems > 1) {
         head = fts_sort(sp, head, nitems);
     }
     return (head);
-}
-
-static u_short
+} 
+ 
+static u_short 
 fts_stat(FTS* sp, FTSENT* p, int follow)
-{
+{ 
     dev_t dev;
     ino_t ino;
     stat_struct *sbp, sb;
     int saved_errno;
     /* If user needs stat info, stat buffer already allocated. */
     sbp = ISSET(FTS_NOSTAT) ? &sb : p->fts_statp;
-
+ 
 #ifdef FTS_WHITEOUT
     /* check for whiteout */
     if (p->fts_flags & FTS_ISW) {
@@ -1137,7 +1137,7 @@ fts_stat(FTS* sp, FTSENT* p, int follow)
         memset(sbp, 0, sizeof(stat_struct));
         return (FTS_NS);
     }
-
+ 
     if (S_ISDIR(sbp->st_mode)) {
         /*
          * Set the device/inode.  Used to find cycles and check for
@@ -1149,12 +1149,12 @@ fts_stat(FTS* sp, FTSENT* p, int follow)
         dev = p->fts_dev = sbp->st_dev;
         ino = p->fts_ino = sbp->st_ino;
         p->fts_nlink = sbp->st_nlink;
-
+ 
         const char* fts_name_x = p->fts_name;
         if (ISDOT(fts_name_x)) {
             return (FTS_DOT);
         }
-
+ 
         /*
          * Cycle detection is done by brute force when the directory
          * is first encountered.  If the tree gets deep enough or the
@@ -1183,13 +1183,13 @@ fts_stat(FTS* sp, FTSENT* p, int follow)
         return (FTS_F);
     }
     return (FTS_DEFAULT);
-}
-
+} 
+ 
 static FTSENT*
 fts_sort(FTS* sp, FTSENT* head, int nitems)
-{
+{ 
     FTSENT **ap, *p;
-
+ 
     /*
      * Construct an array of pointers to the structures and call qsort(3).
      * Reassemble the array in the order returned by qsort.  If unable to
@@ -1221,14 +1221,14 @@ fts_sort(FTS* sp, FTSENT* head, int nitems)
     }
     ap[0]->fts_link = nullptr;
     return (head);
-}
-
+} 
+ 
 static FTSENT*
 fts_alloc(FTS* sp, const char* name, int namelen)
-{
+{ 
     FTSENT* p;
     size_t len;
-
+ 
     /*
      * The file name is a variable length array and no stat structure is
      * necessary if the user has set the nostat bit.  Allocate the FTSENT
@@ -1244,11 +1244,11 @@ fts_alloc(FTS* sp, const char* name, int namelen)
     if ((p = (FTSENT*)malloc(len)) == nullptr) {
         return nullptr;
     }
-
+ 
     /* Copy the name and guarantee NUL termination. */
     memmove((void*)p->fts_name, (void*)name, (size_t)namelen);
     p->fts_name[namelen] = '\0';
-
+ 
     if (!ISSET(FTS_NOSTAT)) {
         p->fts_statp = (stat_struct*)ALIGN(p->fts_name + namelen + 2);
     }
@@ -1261,34 +1261,34 @@ fts_alloc(FTS* sp, const char* name, int namelen)
     p->fts_pointer = nullptr;
     p->fts_type = FTS_NSOK;
     return (p);
-}
-
-static void
+} 
+ 
+static void 
 fts_lfree(FTSENT* head)
-{
+{ 
     FTSENT* p;
-
+ 
     /* Free a linked list of structures. */
     while ((p = head) != nullptr) {
         head = head->fts_link;
         free(p);
     }
-}
-
-/*
- * Allow essentially unlimited paths; find, rm, ls should all work on any tree.
- * Most systems will allow creation of paths much longer than MAXPATHLEN, even
- * though the kernel won't resolve them.  Add the size (not just what's needed)
- * plus 256 bytes so don't realloc the path 2 bytes at a time.
- */
-static int
+} 
+ 
+/* 
+ * Allow essentially unlimited paths; find, rm, ls should all work on any tree. 
+ * Most systems will allow creation of paths much longer than MAXPATHLEN, even 
+ * though the kernel won't resolve them.  Add the size (not just what's needed) 
+ * plus 256 bytes so don't realloc the path 2 bytes at a time. 
+ */ 
+static int 
 fts_palloc(FTS* sp, size_t more)
-{
+{ 
     sp->fts_pathlen += more + 256;
     sp->fts_path = (char*)yreallocf(sp->fts_path, (size_t)sp->fts_pathlen);
     return (sp->fts_path == nullptr);
-}
-
+} 
+ 
 static void
 ADJUST(FTSENT* p, void* addr)
 {
@@ -1307,16 +1307,16 @@ ADJUST(FTSENT* p, void* addr)
     (p)->fts_path = (char*)addr;
 }
 
-/*
- * When the path is realloc'd, have to fix all of the pointers in structures
- * already returned.
- */
-static void
+/* 
+ * When the path is realloc'd, have to fix all of the pointers in structures 
+ * already returned. 
+ */ 
+static void 
 fts_padjust(FTS* sp)
-{
+{ 
     FTSENT* p;
     char* addr = sp->fts_path;
-
+ 
 #define ADJUST1(p)                             \
     {                                          \
         if ((p)->fts_accpath == (p)->fts_path) \
@@ -1327,26 +1327,26 @@ fts_padjust(FTS* sp)
     for (p = sp->fts_child; p; p = p->fts_link) {
         ADJUST(p, addr);
     }
-
+ 
     /* Adjust the rest of the tree. */
     for (p = sp->fts_cur; p->fts_level >= FTS_ROOTLEVEL;) {
         ADJUST(p, addr);
         p = p->fts_link ? p->fts_link : p->fts_parent;
     }
-}
-
-static size_t
+} 
+ 
+static size_t 
 fts_maxarglen(char* const* argv)
-{
+{ 
     size_t len, max;
-
+ 
     for (max = 0; *argv; ++argv) {
         if ((len = strlen(*argv)) > max) {
             max = len;
         }
     }
     return (max + 1);
-}
+} 
 
 /*
  * Change to dir specified by fd or p->fts_accpath without getting
diff --git a/util/folder/fts.h b/util/folder/fts.h
index f3c799e8c8..02372fd04b 100644
--- a/util/folder/fts.h
+++ b/util/folder/fts.h
@@ -1,5 +1,5 @@
 #pragma once
-
+ 
 #include <sys/types.h>
 
 #include <util/system/defaults.h>
@@ -22,7 +22,7 @@ int stat64UTF(dird path, struct _stat64* _Stat);
     #endif
 #endif
 
-typedef struct {
+typedef struct { 
     struct _ftsent* fts_cur;    /* current node */
     struct _ftsent* fts_child;  /* linked list of children */
     struct _ftsent** fts_array; /* sort array */
@@ -33,7 +33,7 @@ typedef struct {
     int fts_nitems;             /* elements in the sort array */
     int(*fts_compar)            /* compare function */
         (const struct _ftsent**, const struct _ftsent**);
-
+ 
 #define FTS_COMFOLLOW 0x001  /* follow command line symlinks */
 #define FTS_LOGICAL 0x002    /* logical walk */
 #define FTS_NOCHDIR 0x004    /* don't change directories */
@@ -42,13 +42,13 @@ typedef struct {
 #define FTS_SEEDOT 0x020     /* return dot and dot-dot */
 #define FTS_XDEV 0x040       /* don't cross devices */
 #define FTS_OPTIONMASK 0x0ff /* valid user option mask */
-
+ 
 #define FTS_NAMEONLY 0x100 /* (private) child names only */
 #define FTS_STOP 0x200     /* (private) unrecoverable error */
     int fts_options;       /* yfts_open options, global flags */
-} FTS;
-
-typedef struct _ftsent {
+} FTS; 
+ 
+typedef struct _ftsent { 
     struct _ftsent* fts_cycle;  /* cycle node */
     struct _ftsent* fts_parent; /* parent directory */
     struct _ftsent* fts_link;   /* next file in directory */
@@ -60,15 +60,15 @@ typedef struct _ftsent {
     dird fts_symfd;             /* fd for symlink */
     u_short fts_pathlen;        /* strlen(fts_path) */
     u_short fts_namelen;        /* strlen(fts_name) */
-
+ 
     ino_t fts_ino;     /* inode */
     dev_t fts_dev;     /* device */
     nlink_t fts_nlink; /* link count */
-
+ 
 #define FTS_ROOTPARENTLEVEL -1
 #define FTS_ROOTLEVEL 0
     short fts_level; /* depth (-1 to N) */
-
+ 
 #define FTS_D 1       /* preorder directory */
 #define FTS_DC 2      /* directory that causes cycles */
 #define FTS_DEFAULT 3 /* none of the above */
@@ -85,22 +85,22 @@ typedef struct _ftsent {
 #define FTS_W 14      /* whiteout object */
     u_short fts_info; /* user flags for FTSENT structure */
     u_short fts_type; /* type of fs node; one of FTS_D, FTS_F, FTS_SL */
-
+ 
 #define FTS_DONTCHDIR 0x01 /* don't chdir .. to the parent */
 #define FTS_SYMFOLLOW 0x02 /* followed a symlink to get here */
 #define FTS_ISW 0x04       /* this is a whiteout object */
     u_short fts_flags;     /* private flags for FTSENT structure */
-
+ 
 #define FTS_AGAIN 1    /* read node again */
 #define FTS_FOLLOW 2   /* follow symbolic link */
 #define FTS_NOINSTR 3  /* no instructions */
 #define FTS_SKIP 4     /* discard node */
     u_short fts_instr; /* yfts_set() instructions */
-
+ 
     stat_struct* fts_statp; /* stat(2) information */
     char fts_name[1];       /* file name */
-} FTSENT;
-
+} FTSENT; 
+ 
 FTSENT* yfts_children(FTS*, int);
 int yfts_close(FTS*);
 FTS* yfts_open(char* const*, int, int (*)(const FTSENT**, const FTSENT**));