#pragma prototyped
#define TIME_ISO "%Q/%m-%d+%H:%M/%Y-%m-%d /"
#define TIME_LONG_ISO "%_K"
#define TIME_FULL_ISO "%_EK"
#define TIME_LOCALE "%c"
static const char usage[] =
"[-?\n@(#)$Id: ls (AT&T Research) 2012-04-20 $\n]"
USAGE_LICENSE
"[+NAME?ls - list files and/or directories]"
"[+DESCRIPTION?For each directory argument \bls\b lists the contents; for each"
" file argument the name and requested information are listed."
" The directory \b.\b is assumed if no file arguments appear."
" The listing is sorted by file name by default, except that file"
" arguments are listed before directories.]"
"[+?Multi-column terminal output display width is determined by \bioctl\b(2)"
" and/or the \bCOLUMNS\b environment variable.]"
"[+?\bgetconf PATH_RESOLVE\b determines how symbolic links are handled. This"
" can be explicitly overridden by the \b--logical\b, \b--metaphysical\b,"
" and \b--physical\b options below. \bPATH_RESOLVE\b can be one of:]{"
" [+logical?Follow all symbolic links.]"
" [+metaphysical?Follow command argument symbolic links,"
" otherwise don't follow.]"
" [+physical?Don't follow symbolic links.]"
"}"
"[a:all?List entries starting with \b.\b; turns off \b--almost-all\b.]"
"[A:almost-all?List all entries but \b.\b and \b..\b; turns off \b--all\b.]"
"[b:escape?Print escapes for nongraphic characters.]"
"[B:ignore-backups?Do not list entries ending with ~.]"
"[c:ctime?Sort by change time; list ctime with \b--long\b.]"
"[C:multi-column?List entries by columns.]"
"[d:directory?List directory entries instead of contents.]"
"[D:define?Define \akey\a with optional \avalue\a. \avalue\a will be expanded"
" when \b%(\b\akey\a\b)\b is specified in \b--format\b. \akey\a may"
" override internal \b--format\b identifiers.]:[key[=value]]]"
"[e:long-iso|long-time?Equivalent to \b--long --time-style=long-iso\b.]"
"[E:full-iso|full-time?Equivalent to \b--long --time-style=full-iso\b.]"
"[f:force?Force each argument to be interpreted as a directory and list"
" the name found in each slot in the physical directory order. Turns"
" on \b-aU\b and turns off \b-lrst\b. The results are undefined for"
" non-directory arguments.]"
"[Z:format?Append to the listing format string. \aformat\a follows"
" \bprintf\b(3) conventions, except that \bsfio\b(3) inline ids"
" are used instead of arguments:"
" %[-+]][\awidth\a[.\aprecis\a[.\abase\a]]]]]](\aid\a[:\asubformat\a]])\achar\a."
" If \achar\a is \bs\b then the string form of the item is listed,"
" otherwise the corresponding numeric form is listed. \asubformat\a"
" overrides the default formatting for \aid\a. Supported \aid\as"
" and \asubformat\as are:]:[format]{"
" [+atime?access time]"
" [+blocks?size in blocks]"
" [+ctime?change time]"
" [+dev?major/minor device numbers]"
" [+device?major/minor device numbers if block or character special device]"
" [+devmajor?major device number]"
" [+devminor?minor device number]"
" [+dir.blocks?directory blocks]"
" [+dir.bytes?directory size in bytes]"
" [+dir.count?directory entry count]"
" [+dir.files?directory file count]"
" [+flags?command line flags in effect]"
" [+gid?group id]"
" [+header?listing header]"
" [+ino?serial number]"
" [+linkop?link operation: -> for symbolic, empty otherwise]"
" [+linkname?symbolic link text]"
" [+linkpath?symbolic link text]"
" [+mark?file or directory mark character]"
" [+markdir?directory mark character]"
" [+mode?access mode]"
" [+mtime?modification time]"
" [+name?entry name]"
" [+nlink?hard link count]"
" [+path?file path from original root dir]"
" [+perm?access permissions]"
" [+size?file size in bytes]"
" [+summary?listing summary info]"
" [+total.blocks?running total block count]"
" [+total.bytes?running total size in bytes]"
" [+total.files?running total file count]"
" [+trailer?listing trailer]"
" [+uid?owner id]"
" [+view?3d fs view level, 0 for the top or 2d]"
" [+----?subformats ----]"
" [+case\b::\bp\b\a1\a::\bs\b\a1\a::...::\bp\b\an\a::\bs\b\an\a?Expands"
" to \bs\b\ai\a if the value of \aid\a matches the shell"
" pattern \bp\b\ai\a, or the empty string if there is no"
" match.]"
" [+mode?The integral value as a \bfmtmode\b(3) string.]"
" [+perm?The integral value as a \bfmtperm\b(3) string.]"
" [+time[=\aformat\a]]?The integral value as a \bstrftime\b(3)"
" string. For example,"
" \b--format=\"%8(mtime)u %(ctime:time=%H:%M:%S)s\"\b"
" lists the mtime in seconds since the epoch and the"
" ctime as hours:minutes:seconds.]"
" }"
"[F:classify?Append a character for typing each entry. Turns on \b--physical\b.]"
"[g:group?\b--long\b with no owner info.]"
"[G?\b--long\b with no group info.]"
"[h:scale|binary-scale|human-readable?Scale sizes to powers of 1024 { Ki Mi Gi Ti Pi Xi }.]"
"[i:inode?List the file serial number.]"
"[I:ignore?Do not list implied entries matching shell \apattern\a.]:[pattern]"
"[k:kilobytes?Use 1024 blocks instead of 512.]"
"[K:shell-quote?Enclose entry names in shell $'...' if necessary.]"
"[l:long|verbose?Use a long listing format.]"
"[m:commas|comma-list?List names as comma separated list.]"
"[n:numeric-uid-gid?List numeric user and group ids instead of names.]"
"[N:literal|show-controls-chars?Print raw entry names (don't treat e.g. control characters specially).]"
"[o:owner?\b--long\b with no group info.]"
"[O?\b--long\b with no owner info.]"
"[p:markdir?Append / to each directory name.]"
"[q:hide-control-chars?Print ? instead of non graphic characters.]"
"[Q:quote-name?Enclose all entry names in \"...\".]"
"[J:quote-style|quoting-style?Quote entry names according to \astyle\a:]:[style:=question]{"
" [c:C?C \"...\" quote.]"
" [e:escape?\b\\\b escape if necessary.]"
" [l:literal?No quoting.]"
" [q:question?Replace unprintable characters with \b?\b.]"
" [s:shell?Shell $'...' quote if necessary.]"
" [S:shell-always?Shell $'...' every name.]"
"}"
"[r:reverse?Reverse order while sorting.]"
"[R:recursive?List subdirectories recursively.]"
"[s:size?Print size of each file, in blocks.]"
"[S:bysize?Sort by file size.]"
"[t:?Sort by modification time; list mtime with \b--long\b.]"
"[T:tabsize?Ignored by this implementation.]#[columns]"
"[u:access?Sort by last access time; list atime with \b--long\b.]"
"[U?Equivalent to \b--sort=none\b.]"
"[V:colors|colours?\akey\a determines when color is used to distinguish"
" types:]:?[key:=never]{"
" [n:never?Never use color.]"
" [a:always?Always use color.]"
" [t:tty|auto?Use color when output is a tty.]"
"}"
"[w:width?Set the screen width to \ascreen-width\a and the screen height"
" to \ascreen-height\a if specified.]:[[screen-heightX]]screen-width]"
"[W:time?Display \akey\a time instead of the modification time:]:[key]{"
" [a:atime|access|use?access time]"
" [c:ctime|status?status change time]"
" [m:mtime|time?modify time]"
"}"
"[x:across?List entries by lines instead of by columns.]"
"[X:extension?Sort alphabetically by entry extension.]"
"[y:sort?Sort by \akey\a:]:?[key]{"
" [a:atime|access|use?Access time.]"
" [c:ctime|status?Status change time.]"
" [x:extension?File name extension.]"
" [m:mtime|time?Modify time.]"
" [f:name?File name.]"
" [n:none?Don't sort.]"
" [s:size|blocks?File size.]"
" [v:version?File name version.]"
"}"
"[Y:layout?Listing layout \akey\a:]:[key]{"
" [a:across|horizontal?Multi-column across the page.]"
" [c:comma?Comma separated names across the page.]"
" [l:long|verbose?Long listing.]"
" [v:multi-column|vertical?Multi-column by column.]"
" [1:single-column?One column down the page.]"
"}"
"[z:time-style?List the time according to \astyle\a:]:[style]{"
" [i:iso?Equivalent to \b+" TIME_ISO "\b.]"
" [10:posix-iso?No change for the C or posix locales, \biso\b otherwise.]"
" [f:full-iso?Equivalent to \b+" TIME_FULL_ISO "\b.]"
" [l:long-iso?Equivalent to \b+" TIME_LONG_ISO "\b.]"
" [11:posix-full-iso?No change for the C or posix locales, \bfull-iso\b"
" otherwise.]"
" [L:locale?Equivalent to \b+" TIME_LOCALE "\b.]"
" [12:+\aformat\a?A \bdate\b(1) +\aformat\a.]"
"}"
"[1:one-column?List one file per line.]"
"[L:logical|follow?Follow symbolic links. The default is determined by"
" \bgetconf PATH_RESOLVE\b.]"
"[H:metaphysical?Follow command argument symbolic links, otherwise don't"
" follow. The default is determined by \bgetconf PATH_RESOLVE\b.]"
"[P:physical?Don't follow symbolic links. The default is determined by"
" \bgetconf PATH_RESOLVE\b.]"
"[101:block-size?Use \ablocksize\a blocks.]#[blocksize]"
"[102:decimal-scale|thousands?Scale sizes to powers of 1000 { K M G T P X }.]"
"[103:dump?Print the generated \b--format\b string on the standard output"
" and exit.]"
"[104:testdate?\b--format\b time values newer than \adate\a will be printed"
" as \adate\a. Used for regression testing.]:[date]"
"[105:testsize?Shift file sizes left \ashift\a bits and set file block counts"
" to the file size divided by 512. Used for regression testing.]#[shift]"
"\n"
"\n[ file ... ]\n"
"\n"
"[+SEE ALSO?\bchmod\b(1), \bfind\b(1), \bgetconf\b(1), \btw\b(1)]"
"[+BUGS?Can we add options to something else now?]"
;
#include <ast.h>
#include <ls.h>
#include <ctype.h>
#include <error.h>
#include <ftwalk.h>
#include <sfdisc.h>
#include <hash.h>
#include <tmx.h>
#include <fs3d.h>
#define LS_ACROSS (LS_USER<<0)
#define LS_ALL (LS_USER<<1)
#define LS_ALWAYS (LS_USER<<2)
#define LS_COLUMNS (LS_USER<<3)
#define LS_COMMAS (LS_USER<<4)
#define LS_DIRECTORY (LS_USER<<5)
#define LS_ESCAPE (LS_USER<<6)
#define LS_EXTENSION (LS_USER<<7)
#define LS_LABEL (LS_USER<<8)
#define LS_MARKDIR (LS_USER<<9)
#define LS_MOST (LS_USER<<10)
#define LS_NOBACKUP (LS_USER<<11)
#define LS_NOSTAT (LS_USER<<13)
#define LS_PRINTABLE (LS_USER<<14)
#define LS_QUOTE (LS_USER<<15)
#define LS_RECURSIVE (LS_USER<<16)
#define LS_SEPARATE (LS_USER<<17)
#define LS_SHELL (LS_USER<<18)
#define LS_TIME (LS_USER<<19)
#define LS_STAT LS_NOSTAT
#define VISIBLE(f) ((f)->level<=0||(!state.ignore||!strmatch((f)->name,state.ignore))&&(!(state.lsflags&LS_NOBACKUP)||(f)->name[(f)->namelen-1]!='~')&&((state.lsflags&LS_ALL)||(f)->name[0]!='.'||(state.lsflags&LS_MOST)&&((f)->name[1]&&(f)->name[1]!='.'||(f)->name[2])))
#define BETWEEN 2
#define AFTER 1
#define INVISIBLE (-1)
#define LISTED (-2)
#define KEY_environ (-1)
#define KEY_atime 1
#define KEY_blocks 2
#define KEY_ctime 3
#define KEY_dev 4
#define KEY_device 5
#define KEY_devmajor 6
#define KEY_devminor 7
#define KEY_dir_blocks 8
#define KEY_dir_bytes 9
#define KEY_dir_count 10
#define KEY_dir_files 11
#define KEY_flags 12
#define KEY_gid 13
#define KEY_header 14
#define KEY_ino 15
#define KEY_linkop 16
#define KEY_linkpath 17
#define KEY_mark 18
#define KEY_markdir 19
#define KEY_mode 20
#define KEY_mtime 21
#define KEY_name 22
#define KEY_nlink 23
#define KEY_path 24
#define KEY_perm 25
#define KEY_size 26
#define KEY_summary 27
#define KEY_total_blocks 28
#define KEY_total_bytes 29
#define KEY_total_files 30
#define KEY_trailer 31
#define KEY_uid 32
#define KEY_view 33
#if 0
#define BLOCKS(st) ((state.blocksize==LS_BLOCKSIZE)?iblocks(st):(state.blocksize>LS_BLOCKSIZE)?(iblocks(st)+state.blocksize/LS_BLOCKSIZE-1)/(state.blocksize/LS_BLOCKSIZE):iblocks(st)*(LS_BLOCKSIZE/state.blocksize))
#else
#define BLOCKS(st) ((state.blocksize==LS_BLOCKSIZE)?iblocks(st):(iblocks(st)*LS_BLOCKSIZE+state.blocksize-1)/state.blocksize)
#endif
#define PRINTABLE(s) ((state.lsflags&LS_PRINTABLE)?printable(s):(s))
typedef int (*Order_f)(Ftw_t*, Ftw_t*);
typedef struct
{
Sfulong_t blocks;
Sfulong_t bytes;
Sfulong_t files;
} Count_t;
typedef struct
{
char* name;
short index;
short disable;
char* macro;
} Key_t;
typedef struct
{
Count_t count;
Ftw_t* ftw;
char* dirnam;
int dirlen;
} List_t;
typedef struct
{
char flags[64];
long ftwflags;
long lsflags;
long timeflags;
long blocksize;
unsigned long directories;
unsigned long testdate;
Count_t total;
int adjust;
int comma;
int height;
int reverse;
int scale;
int testsize;
int width;
char* endflags;
char* format;
char* ignore;
char* timefmt;
Hash_table_t* keys;
Sfio_t* tmp;
Ftw_t* top;
Order_f order;
} State_t;
static char DEF_header[] =
"%(dir.count:case;0;;1;%(path)s:\n;*;\n%(path)s:\n)s"
"%(flags:case;*d*;;*[ls]*;total %(dir.blocks)u\n)s"
;
static Key_t keys[] =
{
{ 0 },
{ "atime", KEY_atime },
{ "blocks", KEY_blocks },
{ "ctime", KEY_ctime },
{ "dev", KEY_dev },
{ "device", KEY_device },
{ "devmajor", KEY_devmajor },
{ "devminor", KEY_devminor },
{ "dir.blocks", KEY_dir_blocks },
{ "dir.bytes", KEY_dir_bytes },
{ "dir.count", KEY_dir_count },
{ "dir.files", KEY_dir_files },
{ "flags", KEY_flags },
{ "gid", KEY_gid },
{ "header", KEY_header, 0, DEF_header },
{ "ino", KEY_ino },
{ "linkop", KEY_linkop },
{ "linkpath", KEY_linkpath },
{ "mark", KEY_mark },
{ "markdir", KEY_markdir },
{ "mode", KEY_mode },
{ "mtime", KEY_mtime },
{ "name", KEY_name },
{ "nlink", KEY_nlink },
{ "path", KEY_path },
{ "perm", KEY_perm },
{ "size", KEY_size },
{ "summary", KEY_summary },
{ "total.blocks", KEY_total_blocks },
{ "total.bytes", KEY_total_bytes },
{ "total.files", KEY_total_files },
{ "trailer", KEY_trailer },
{ "uid", KEY_uid },
{ "view", KEY_view },
{ "linkname", KEY_linkpath },
};
static State_t state;
static char*
printable(register char* s)
{
register char* t;
register char* p;
register int c;
static char* prdata;
static int prsize;
if (state.lsflags & LS_ESCAPE)
{
if (!(state.lsflags & LS_QUOTE))
return fmtesc(s);
if (state.lsflags & LS_SHELL)
return fmtquote(s, "$'", "'", strlen(s), (state.lsflags & LS_ALWAYS) ? FMT_ALWAYS : 0);
return fmtquote(s, "\"", "\"", strlen(s), FMT_ALWAYS);
}
c = strlen(s) + 4;
if (c > prsize)
{
prsize = roundof(c, 512);
if (!(prdata = newof(prdata, char, prsize, 0)))
error(3, "out of space");
}
t = prdata;
if (state.lsflags & LS_QUOTE)
*t++ = '"';
if (!mbwide())
while (c = *s++)
*t++ = (iscntrl(c) || !isprint(c)) ? '?' : c;
else
for (p = s; c = mbchar(s);)
if (c < 0)
{
s++;
*t++ = '?';
}
else if (mbwidth(c) <= 0)
*t++ = '?';
else
while (p < s)
*t++ = *p++;
if (state.lsflags & LS_QUOTE)
*t++ = '"';
*t = 0;
return prdata;
}
static int
key(void* handle, register Sffmt_t* fp, const char* arg, char** ps, Sflong_t* pn)
{
register Ftw_t* ftw;
register struct stat* st;
register char* s = 0;
register Sflong_t n = 0;
register Key_t* kp;
List_t* lp;
Time_t t;
static Sfio_t* mp;
static const char fmt_mode[] = "mode";
static const char fmt_perm[] = "perm";
static const char fmt_time[] = "time";
if (!fp->t_str)
return 0;
if (lp = (List_t*)handle)
{
ftw = lp->ftw;
st = &ftw->statb;
}
else
{
ftw = 0;
st = 0;
}
t = TMX_NOTIME;
if (!(kp = (Key_t*)hashget(state.keys, fp->t_str)))
{
if (*fp->t_str != '$')
{
error(3, "%s: unknown format key", fp->t_str);
return 0;
}
if (!(kp = newof(0, Key_t, 1, 0)))
error(3, "out of space");
kp->name = hashput(state.keys, 0, kp);
kp->macro = getenv(fp->t_str + 1);
kp->index = KEY_environ;
kp->disable = 1;
}
if (kp->macro && !kp->disable)
{
kp->disable = 1;
if (!mp && !(mp = sfstropen()))
error(3, "out of space");
sfkeyprintf(mp, handle, kp->macro, key, NiL);
if (!(s = sfstruse(mp)))
error(3, "out of space");
kp->disable = 0;
}
else switch (kp->index)
{
case KEY_atime:
if (st)
{
n = st->st_atime;
t = tmxgetatime(st);
}
if (!arg)
arg = state.timefmt;
break;
case KEY_blocks:
if (st)
n = BLOCKS(st);
break;
case KEY_ctime:
if (st)
{
n = st->st_ctime;
t = tmxgetctime(st);
}
if (!arg)
arg = state.timefmt;
break;
case KEY_dev:
if (st)
s = fmtdev(st);
break;
case KEY_device:
if (st && (S_ISBLK(st->st_mode) || S_ISCHR(st->st_mode)))
s = fmtdev(st);
else
return 0;
break;
case KEY_devmajor:
if (st)
n = (S_ISBLK(st->st_mode) || S_ISCHR(st->st_mode)) ? major(idevice(st)) : major(st->st_dev);
break;
case KEY_devminor:
if (st)
n = (S_ISBLK(st->st_mode) || S_ISCHR(st->st_mode)) ? minor(idevice(st)) : minor(st->st_dev);
break;
case KEY_dir_blocks:
if (!state.scale)
{
if (lp)
n = lp->count.blocks;
break;
}
case KEY_dir_bytes:
if (lp)
n = lp->count.bytes;
if (state.scale)
{
s = fmtscale(n, state.scale);
fp->fmt = 's';
}
break;
case KEY_dir_count:
if (ftw != state.top)
{
if (state.lsflags & LS_SEPARATE)
n = state.directories;
else if (state.lsflags & LS_LABEL)
n = 1;
}
break;
case KEY_dir_files:
if (lp)
n = lp->count.files;
break;
case KEY_environ:
if (!(s = kp->macro))
return 0;
break;
case KEY_flags:
s = state.flags;
break;
case KEY_gid:
if (st)
{
if (fp->fmt == 's')
s = fmtgid(st->st_gid);
else
n = st->st_gid;
}
break;
case KEY_ino:
if (st)
n = st->st_ino;
break;
case KEY_linkpath:
if (ftw && (ftw->info & FTW_SL))
{
char* dirnam;
int c;
static char* txtdata;
static int txtsize;
if ((st->st_size + 1) > txtsize)
{
txtsize = roundof(st->st_size + 1, 512);
if (!(txtdata = newof(txtdata, char, txtsize, 0)))
error(3, "out of space");
}
if (*ftw->name == '/' || !lp->dirnam)
dirnam = ftw->name;
else
{
sfprintf(state.tmp, "%s/%s", lp->dirnam + streq(lp->dirnam, "/"), ftw->name);
if (!(dirnam = sfstruse(state.tmp)))
error(3, "out of space");
}
c = pathgetlink(dirnam, txtdata, txtsize);
if (c > 0)
s = PRINTABLE(txtdata);
}
else
return 0;
break;
case KEY_linkop:
if (ftw && (ftw->info & FTW_SL))
s = "->";
else
return 0;
break;
case KEY_mark:
if (!st)
return 0;
else if (S_ISLNK(st->st_mode))
s = "@";
else if (S_ISDIR(st->st_mode))
s = "/";
#ifdef S_ISDOOR
else if (S_ISDOOR(st->st_mode))
s = ">";
#endif
else if (S_ISFIFO(st->st_mode))
s = "|";
#ifdef S_ISSOCK
else if (S_ISSOCK(st->st_mode))
s = "=";
#endif
else if (S_ISBLK(st->st_mode) || S_ISCHR(st->st_mode))
s = "$";
else if (st->st_mode & (S_IXUSR|S_IXGRP|S_IXOTH))
s = "*";
else
return 0;
break;
case KEY_markdir:
if (!st || !S_ISDIR(st->st_mode))
return 0;
s = "/";
break;
case KEY_mode:
if (st)
n = st->st_mode;
if (!arg)
arg = fmt_mode;
break;
case KEY_mtime:
if (st)
{
n = st->st_mtime;
t = tmxgetmtime(st);
}
if (!arg)
arg = state.timefmt;
break;
case KEY_name:
if (ftw)
s = PRINTABLE(ftw->name);
break;
case KEY_nlink:
if (st)
n = st->st_nlink;
break;
case KEY_path:
if (ftw)
s = ftw->path ? PRINTABLE(ftw->path) : PRINTABLE(ftw->name);
break;
case KEY_perm:
if (st)
n = st->st_mode & S_IPERM;
if (!arg)
arg = fmt_perm;
break;
case KEY_size:
if (st)
{
n = st->st_size;
if (state.scale)
{
s = fmtscale(n, state.scale);
fp->fmt = 's';
}
}
break;
case KEY_total_blocks:
if (!state.scale)
{
n = state.total.blocks;
break;
}
case KEY_total_bytes:
n = state.total.bytes;
if (state.scale)
{
s = fmtscale(n, state.scale);
fp->fmt = 's';
}
break;
case KEY_total_files:
n = state.total.files;
break;
case KEY_uid:
if (st)
{
if (fp->fmt == 's')
s = fmtuid(st->st_uid);
else
n = st->st_uid;
}
break;
case KEY_view:
if (st)
n = iview(st);
break;
default:
return 0;
}
if (s)
{
*ps = s;
if (mbwide())
{
register char* p;
int w;
int i;
for (p = s; w = mbchar(s); p = s)
if (w < 0)
s++;
else if ((i = mbwidth(w)) >= 0)
state.adjust -= (s - p) + i - 2;
}
}
else if (fp->fmt == 's' && arg)
{
if (strneq(arg, fmt_mode, sizeof(fmt_mode) - 1))
*ps = fmtmode(n, 0);
else if (strneq(arg, fmt_perm, sizeof(fmt_perm) - 1))
*ps = fmtperm(n & S_IPERM);
else
{
if (strneq(arg, fmt_time, sizeof(fmt_time) - 1))
{
arg += sizeof(fmt_time) - 1;
if (*arg == '=')
arg++;
}
if (!*arg)
arg = state.timefmt;
if ((unsigned long)n >= state.testdate)
{
n = state.testdate;
t = TMX_NOTIME;
}
*ps = t == TMX_NOTIME ? fmttime(arg, (time_t)n) : fmttmx(arg, t);
}
}
else
*pn = n;
return 1;
}
static void
pr(register List_t* lp, Ftw_t* ftw, register int fill)
{
if (state.testsize)
{
ftw->statb.st_size <<= state.testsize;
ftw->statb.st_blocks = ftw->statb.st_size / LS_BLOCKSIZE;
}
#ifdef S_ISLNK
if (ftw->level == 0 && (state.ftwflags & (FTW_META|FTW_PHYSICAL)) == (FTW_META|FTW_PHYSICAL) && !(ftw->info & FTW_D) && !lstat(ftw->path ? ftw->path : ftw->name, &ftw->statb) && S_ISLNK(ftw->statb.st_mode))
ftw->info = FTW_SL;
#endif
lp->ftw = ftw;
state.adjust = 0;
fill -= sfkeyprintf(sfstdout, lp, state.format, key, NiL) + state.adjust;
if (!(state.lsflags & LS_COMMAS))
{
if (fill > 0)
while (fill-- > 0)
sfputc(sfstdout, ' ');
else
sfputc(sfstdout, '\n');
}
}
static void
col(register List_t* lp, register Ftw_t* ftw, int length)
{
register Ftw_t* p;
register int i;
register int n;
register int files;
register char* s;
int w;
int a;
lp->ftw = ftw;
if (keys[KEY_header].macro && ftw->level >= 0)
sfkeyprintf(sfstdout, lp, keys[KEY_header].macro, key, NiL);
if ((files = lp->count.files) > 0)
{
if (!(state.lsflags & LS_COLUMNS) || length <= 0)
{
n = w = 1;
a = 0;
}
else
{
i = ftw->name[1];
ftw->name[1] = 0;
state.adjust = 2;
a = sfkeyprintf(state.tmp, lp, state.format, key, NiL) - 1;
w = a + state.adjust + 1;
length += w;
sfstrseek(state.tmp, 0, SEEK_SET);
ftw->name[1] = i;
n = ((state.width - (length + BETWEEN + 2)) < 0) ? 1 : 2;
}
if (state.lsflags & LS_COMMAS)
{
length = w - 1;
i = 0;
n = state.width;
for (p = ftw->link; p; p = p->link)
if (p->local.number != INVISIBLE)
{
if (!mbwide())
w = p->namelen;
else
for (s = p->name, w = 0; i = mbchar(s);)
if (i < 0)
{
s++;
w++;
}
else if ((n = mbwidth(i)) > 0)
w += n;
w += a;
if ((n -= length + w) < 0)
{
n = state.width - (length + w);
if (i)
sfputr(sfstdout, ",\n", -1);
}
else if (i)
sfputr(sfstdout, ", ", -1);
pr(lp, p, 0);
i = 1;
}
if (i)
sfputc(sfstdout, '\n');
}
else if (n <= 1)
{
for (p = ftw->link; p; p = p->link)
if (p->local.number != INVISIBLE)
pr(lp, p, 0);
}
else
{
register Ftw_t** x;
int c;
int j;
int k;
int l;
int m;
int o;
int q;
int r;
int w;
int z;
static unsigned short* siz;
static int sizsiz;
static Ftw_t** vec;
static int vecsiz;
if (files > sizsiz)
{
sizsiz = roundof(files, 64);
if (!(siz = newof(siz, unsigned short, sizsiz, 0)))
error(3, "out of space");
}
if (files > (vecsiz - 1))
{
vecsiz = roundof(files + 1, 64);
if (!(vec = newof(vec, Ftw_t*, vecsiz, 0)))
error(3, "out of space");
}
x = vec;
i = 0;
for (p = ftw->link; p; p = p->link)
if (p->local.number != INVISIBLE)
x[i++] = p;
n = i / (state.width / (length + BETWEEN)) + 1;
o = 0;
if ((state.lsflags & LS_ACROSS) && n > 1)
{
c = (i - 1) / n + 1;
do
{
w = -AFTER;
for (j = 0; j < c; j++)
{
z = 0;
for (l = 0, r = j; l < n && r < i; r += c, l++)
if (z < (x[r]->namelen + a))
z = x[r]->namelen + a;
w += z + BETWEEN;
}
if (w <= state.width)
o = n;
} while (c < state.width / 2 && (n = (i + c) / (c + 1)) && ++c);
n = o ? o : 1;
c = (i - 1) / n + 1;
k = 0;
for (j = 0; j < c; j++)
{
siz[k] = 0;
for (l = 0, r = j; l < n && r < i; r += c, l++)
if (siz[k] < x[r]->namelen)
siz[k] = x[r]->namelen;
siz[k] += a + BETWEEN;
k++;
}
for (j = 0; j <= i; j += c)
for (l = 0, w = j; l < k && w < i; l++, w++)
pr(lp, x[w], l < (k - 1) && w < (i - 1) ? siz[l] : 0);
}
else
{
o = 0;
if (n > 1)
{
if (!(q = i / n))
q = 1;
for (c = q; (c - q) < 2 && c <= state.width / (BETWEEN + 1); ++c)
{
n = m = (i + c - 1) / c;
if ((r = i - m * c) > state.height)
n -= (r + c - 1) / c;
for (; n <= m; n++)
{
w = -AFTER;
j = 0;
while (j < i)
{
z = 0;
for (l = 0; l < n && j < i; j++, l++)
if (z < x[j]->namelen)
z = x[j]->namelen;
w += z + a + BETWEEN;
}
if (w <= state.width)
{
q = c;
o = n;
break;
}
}
}
}
n = o ? o : 1;
j = k = 0;
while (j < i)
{
siz[k] = 0;
for (l = 0; l < n && j < i; j++, l++)
if (siz[k] < x[j]->namelen)
siz[k] = x[j]->namelen;
siz[k] += a + BETWEEN;
k++;
}
for (j = 0; j < n; j++)
for (l = 0, w = j; l < k && w < i; l++, w += n)
pr(lp, x[w], l < (k - 1) && w < (i - n) ? siz[l] : 0);
}
}
}
if (keys[KEY_trailer].macro && ftw->level >= 0)
sfkeyprintf(sfstdout, lp, keys[KEY_trailer].macro, key, NiL);
}
static int
order_none(register Ftw_t* f1, register Ftw_t* f2)
{
return 0;
}
static int
order_blocks(register Ftw_t* f1, register Ftw_t* f2)
{
if (f1->statb.st_size < f2->statb.st_size)
return 1;
if (f1->statb.st_size > f2->statb.st_size)
return -1;
return 0;
}
static int
order_atime(register Ftw_t* f1, register Ftw_t* f2)
{
Time_t t1;
Time_t t2;
t1 = tmxgetatime(&f1->statb);
t2 = tmxgetatime(&f2->statb);
if (t1 < t2)
return 1;
if (t1 > t2)
return -1;
return 0;
}
static int
order_ctime(register Ftw_t* f1, register Ftw_t* f2)
{
Time_t t1;
Time_t t2;
t1 = tmxgetctime(&f1->statb);
t2 = tmxgetctime(&f2->statb);
if (t1 < t2)
return 1;
if (t1 > t2)
return -1;
return 0;
}
static int
order_mtime(register Ftw_t* f1, register Ftw_t* f2)
{
Time_t t1;
Time_t t2;
t1 = tmxgetmtime(&f1->statb);
t2 = tmxgetmtime(&f2->statb);
if (t1 < t2)
return 1;
if (t1 > t2)
return -1;
return 0;
}
static int
order_extension(register Ftw_t* f1, register Ftw_t* f2)
{
register int n;
char* x1;
char* x2;
x1 = strrchr(f1->name, '.');
x2 = strrchr(f2->name, '.');
if (x1)
{
if (x2)
n = strcoll(x1, x2);
else
n = 1;
}
else if (x2)
n = -1;
else
n = 0;
if (!n)
n = strcoll(f1->name, f2->name);
return n;
}
static int
order_version(Ftw_t* f1, Ftw_t* f2)
{
return strvcmp(f1->name, f2->name);
}
static int
order_name(Ftw_t* f1, Ftw_t* f2)
{
return strcoll(f1->name, f2->name);
}
static int
order(register Ftw_t* f1, register Ftw_t* f2)
{
int n;
if (!(state.lsflags & LS_DIRECTORY) && (state.ftwflags & FTW_MULTIPLE) && f1->level == 0)
{
if (f1->info == FTW_D)
{
if (f2->info != FTW_D)
return 1;
}
else if (f2->info == FTW_D)
return -1;
}
n = (*state.order)(f1, f2);
return state.reverse ? -n : n;
}
static void
dir(register Ftw_t* ftw)
{
register Ftw_t* p;
register int length;
int top = 0;
List_t list;
if (ftw->status == FTW_NAME)
{
list.dirlen = ftw->namelen;
list.dirnam = ftw->path + ftw->pathlen - list.dirlen;
}
else
{
list.dirlen = ftw->pathlen;
list.dirnam = ftw->path;
}
if (ftw->level >= 0)
state.directories++;
else
state.top = ftw;
length = 0;
list.count.blocks = 0;
list.count.bytes = 0;
list.count.files = 0;
for (p = ftw->link; p; p = p->link)
{
if (p->level == 0 && p->info == FTW_D && !(state.lsflags & LS_DIRECTORY))
{
p->local.number = INVISIBLE;
top++;
}
else if (VISIBLE(p))
{
if (p->info == FTW_NS)
{
if (ftw->level < 0 || !(state.lsflags & LS_NOSTAT))
{
if (ftw->path[0] == '.' && !ftw->path[1])
error(2, "%s: not found", p->name);
else
error(2, "%s/%s: not found", ftw->path, p->name);
goto invisible;
}
}
else
{
list.count.blocks += BLOCKS(&p->statb);
list.count.bytes += p->statb.st_size;
}
list.count.files++;
if (p->namelen > length)
length = p->namelen;
if (!(state.lsflags & LS_RECURSIVE))
p->status = FTW_SKIP;
}
else
{
invisible:
p->local.number = INVISIBLE;
p->status = FTW_SKIP;
}
}
state.total.blocks += list.count.blocks;
state.total.bytes += list.count.bytes;
state.total.files += list.count.files;
col(&list, ftw, length);
state.lsflags |= LS_SEPARATE;
if (top)
{
if (list.count.files)
{
state.directories++;
state.top = 0;
}
else if (top > 1)
state.top = 0;
else
state.top = ftw->link;
for (p = ftw->link; p; p = p->link)
if (p->level == 0 && p->info == FTW_D)
p->local.number = 0;
}
}
static int
ls(register Ftw_t* ftw)
{
if (!VISIBLE(ftw))
{
ftw->status = FTW_SKIP;
return 0;
}
switch (ftw->info)
{
case FTW_NS:
if (ftw->parent->info == FTW_DNX)
break;
error(2, "%s: not found", ftw->path);
return 0;
case FTW_DC:
if (state.lsflags & LS_DIRECTORY)
break;
error(2, "%s: directory causes cycle", ftw->path);
return 0;
case FTW_DNR:
if (state.lsflags & LS_DIRECTORY)
break;
error(2, "%s: cannot read directory", ftw->path);
return 0;
case FTW_D:
case FTW_DNX:
if ((state.lsflags & LS_DIRECTORY) && ftw->level >= 0)
break;
if (!(state.lsflags & LS_RECURSIVE))
ftw->status = FTW_SKIP;
else if (ftw->info == FTS_DNX)
{
error(2, "%s: cannot search directory", ftw->path, ftw->level);
ftw->status = FTW_SKIP;
if (ftw->level > 0 && !(state.lsflags & LS_NOSTAT))
return 0;
}
dir(ftw);
return 0;
}
ftw->status = FTW_SKIP;
if (!ftw->level)
{
static List_t list;
list.ftw = ftw;
pr(&list, ftw, 0);
}
return 0;
}
#define set(f) (opt_info.num?(state.lsflags|=(f)):((state.lsflags&=~(f)),0))
#define clr(f) (opt_info.num?(state.lsflags&=~(f)):(state.lsflags|=(f)))
int
main(int argc, register char** argv)
{
register int n;
register char* s;
char* e;
Key_t* kp;
Sfio_t* fmt;
long lsflags;
int dump = 0;
static char fmt_color[] = "%(mode:case:d*:\\E[01;34m%(name)s\\E[0m:l*:\\E[01;36m%(name)s\\E[0m:*x*:\\E[01;32m%(name)s\\E[0m:*:%(name)s)s";
NoP(argc);
setlocale(LC_ALL, "");
if (s = strrchr(argv[0], '/'))
s++;
else
s = argv[0];
error_info.id = s;
state.ftwflags = ftwflags() | FTW_META | FTW_CHILDREN;
if (!(fmt = sfstropen()) || !(state.tmp = sfstropen()))
error(3, "out of space");
if (!(state.keys = hashalloc(NiL, HASH_name, "keys", 0)))
error(3, "out of space");
for (n = 1; n < elementsof(keys); n++)
hashput(state.keys, keys[n].name, &keys[keys[n].index]);
hashset(state.keys, HASH_ALLOCATE);
if (streq(s, "lc"))
state.lsflags |= LS_COLUMNS;
else if (streq(s, "lf") || streq(s, "lsf"))
state.lsflags |= LS_MARK;
else if (streq(s, "ll"))
state.lsflags |= LS_LONG;
else if (streq(s, "lsr"))
state.lsflags |= LS_RECURSIVE;
else if (streq(s, "lsx"))
state.lsflags |= LS_ACROSS|LS_COLUMNS;
else if (isatty(1))
{
state.lsflags |= LS_COLUMNS;
if (!strmatch(setlocale(LC_ALL, NiL), "*[Uu][Tt][Ff]?(-)8"))
state.lsflags |= LS_PRINTABLE;
}
state.endflags = state.flags;
state.blocksize = 512;
state.testdate = ~0;
state.timefmt = "%?%l";
lsflags = state.lsflags;
while (n = optget(argv, usage))
{
switch (n)
{
case 'a':
set(LS_ALL);
break;
case 'b':
set(LS_PRINTABLE|LS_ESCAPE);
break;
case 'c':
state.lsflags &= ~LS_ATIME;
state.lsflags |= LS_CTIME;
if (!state.order)
state.order = order_ctime;
break;
case 'd':
set(LS_DIRECTORY);
break;
case 'e':
state.lsflags |= LS_LONG;
state.timefmt = TIME_LONG_ISO;
break;
case 'f':
state.lsflags |= LS_ALL;
state.lsflags &= ~(LS_BLOCKS|LS_LONG|LS_TIME);
state.reverse = 0;
state.order = order_none;
break;
case 'g':
case 'O':
if (opt_info.num)
state.lsflags |= LS_LONG|LS_NOUSER;
else
state.lsflags |= LS_LONG|LS_NOGROUP;
break;
case 'h':
state.scale = 1024;
break;
case 'i':
set(LS_INUMBER);
break;
case 'k':
state.blocksize = 1024;
break;
case 'l':
set(LS_LONG);
break;
case 'm':
set(LS_COMMAS);
break;
case 'n':
set(LS_NUMBER);
break;
case 'o':
case 'G':
if (opt_info.num)
state.lsflags |= LS_LONG|LS_NOGROUP;
else
state.lsflags |= LS_LONG|LS_NOUSER;
break;
case 'p':
set(LS_MARKDIR);
break;
case 'q':
set(LS_PRINTABLE);
break;
case 'r':
state.reverse = !!opt_info.num;
break;
case 's':
set(LS_BLOCKS);
break;
case 't':
if (set(LS_TIME) && !state.order)
state.order = order_mtime;
break;
case 'u':
state.lsflags &= ~LS_CTIME;
state.lsflags |= LS_ATIME;
if (!state.order)
state.order = order_atime;
break;
case 'w':
state.width = strtol(opt_info.arg, &e, 0);
if (*e == 'x' || *e == 'X' || *e == '.' || *e == '+')
{
state.height = state.width;
state.width = strtol(e + 1, &e, 0);
}
if (*e)
error(2, "%s: invalid screen width specification at `%s'", opt_info.arg, e);
break;
case 'x':
set(LS_ACROSS|LS_COLUMNS);
break;
case 'y':
if (!opt_info.arg)
state.order = order_none;
else
switch (opt_info.num)
{
case 'a':
state.order = order_atime;
break;
case 'c':
state.order = order_ctime;
break;
case 'f':
state.order = 0;
break;
case 'm':
state.order = order_mtime;
break;
case 'n':
state.order = order_none;
break;
case 's':
state.order = order_blocks;
break;
case 't':
state.order = order_mtime;
break;
case 'v':
state.order = order_version;
break;
case 'x':
state.order = order_extension;
break;
}
break;
case 'z':
switch (opt_info.num)
{
case -10:
if (!strcmp(setlocale(LC_TIME, NiL), "C"))
break;
case 'i':
state.timefmt = TIME_ISO;
break;
case -11:
if (!strcmp(setlocale(LC_TIME, NiL), "C"))
break;
case 'f':
state.timefmt = TIME_FULL_ISO;
break;
case 'l':
state.timefmt = TIME_LONG_ISO;
break;
case 'L':
state.timefmt = TIME_LOCALE;
break;
case -12:
s = opt_info.arg + 1;
if (strchr(s, '\n'))
{
s = sfprints("%%Q\n%s\n", s);
if (!s || !(s = strdup(s)))
error(ERROR_SYSTEM|3, "out of space");
}
state.timefmt = s;
break;
}
break;
case 'A':
state.lsflags |= LS_MOST;
state.lsflags &= ~LS_ALL;
break;
case 'B':
set(LS_NOBACKUP);
break;
case 'C':
set(LS_COLUMNS);
break;
case 'D':
if (s = strchr(opt_info.arg, '='))
*s++ = 0;
if (*opt_info.arg == 'n' && *(opt_info.arg + 1) == 'o')
{
opt_info.arg += 2;
s = 0;
}
if (!(kp = (Key_t*)hashget(state.keys, opt_info.arg)))
{
if (!s)
break;
if (!(kp = newof(0, Key_t, 1, 0)))
error(3, "out of space");
kp->name = hashput(state.keys, 0, kp);
}
if (kp->macro = s)
{
stresc(s);
if (strmatch(s, "*:case:*"))
state.lsflags |= LS_STAT;
}
break;
case 'E':
state.lsflags |= LS_LONG;
state.timefmt = TIME_FULL_ISO;
break;
case 'F':
set(LS_MARK);
break;
case 'H':
state.ftwflags |= FTW_META|FTW_PHYSICAL;
break;
case 'I':
state.ignore = opt_info.arg;
break;
case 'J':
state.lsflags &= ~(LS_ALWAYS|LS_ESCAPE|LS_PRINTABLE|LS_QUOTE|LS_SHELL);
switch (opt_info.num)
{
case 'c':
state.lsflags |= LS_ESCAPE|LS_PRINTABLE|LS_QUOTE;
break;
case 'e':
state.lsflags |= LS_ESCAPE|LS_PRINTABLE;
break;
case 'l':
break;
case 'q':
state.lsflags |= LS_PRINTABLE;
break;
case 's':
state.lsflags |= LS_ESCAPE|LS_PRINTABLE|LS_QUOTE|LS_SHELL;
break;
case 'S':
state.lsflags |= LS_ALWAYS|LS_ESCAPE|LS_PRINTABLE|LS_QUOTE|LS_SHELL;
break;
}
break;
case 'K':
set(LS_PRINTABLE|LS_SHELL|LS_QUOTE|LS_ESCAPE);
break;
case 'L':
state.ftwflags &= ~(FTW_META|FTW_PHYSICAL|FTW_SEEDOTDIR);
break;
case 'N':
clr(LS_PRINTABLE);
break;
case 'P':
state.ftwflags &= ~FTW_META;
state.ftwflags |= FTW_PHYSICAL;
break;
case 'Q':
set(LS_PRINTABLE|LS_QUOTE);
break;
case 'R':
set(LS_RECURSIVE);
break;
case 'S':
state.order = order_blocks;
break;
case 'T':
break;
case 'U':
state.order = order_none;
break;
case 'V':
switch (opt_info.num)
{
case 't':
if (!isatty(1))
break;
case 'a':
if (kp = (Key_t*)hashget(state.keys, "name"))
{
stresc(kp->macro = fmt_color);
state.lsflags |= LS_STAT;
}
break;
}
break;
case 'W':
state.timeflags = 0;
switch (opt_info.num)
{
case 'a':
state.timeflags = LS_ATIME;
break;
case 'c':
state.timeflags = LS_CTIME;
break;
}
break;
case 'X':
set(LS_EXTENSION);
break;
case 'Y':
switch (opt_info.num)
{
case 'a':
state.lsflags |= LS_ACROSS|LS_COLUMNS;
break;
case 'c':
state.lsflags |= LS_COMMAS;
break;
case 'l':
state.lsflags |= LS_LONG;
break;
case 'v':
state.lsflags &= ~LS_ACROSS;
state.lsflags |= LS_COLUMNS;
break;
case '1':
state.lsflags &= ~(LS_ACROSS|LS_COLUMNS);
break;
}
break;
case 'Z':
if (!sfstrtell(fmt))
state.lsflags &= ~LS_COLUMNS;
sfputr(fmt, opt_info.arg, ' ');
break;
case '1':
clr(LS_COLUMNS|LS_PRINTABLE);
break;
case -101:
if (opt_info.num <= 0)
error(3, "%ld: invalid block size", opt_info.num);
state.blocksize = opt_info.num;
break;
case -102:
state.scale = 1000;
break;
case -103:
dump = 1;
break;
case -104:
state.testdate = tmdate(opt_info.arg, &e, NiL);
if (*e)
error(3, "%s: invalid date string", opt_info.arg, opt_info.option);
break;
case -105:
state.testsize = opt_info.num;
break;
case '?':
error(ERROR_USAGE|4, "%s", opt_info.arg);
break;
case ':':
error(2, "%s", opt_info.arg);
break;
default:
error(1, "%s: option not implemented", opt_info.name);
continue;
}
if (!strchr(state.flags, n))
*state.endflags++ = n;
}
argv += opt_info.index;
if (error_info.errors)
error(ERROR_USAGE|4, "%s", optusage(NiL));
if (state.lsflags == (lsflags|LS_TIME))
state.ftwflags |= FTW_SEEDOTDIR;
if (state.lsflags & LS_DIRECTORY)
state.lsflags &= ~LS_RECURSIVE;
if (!state.order)
state.order = order_name;
if (!state.timeflags)
state.timeflags = state.lsflags;
if (state.lsflags & (LS_COLUMNS|LS_COMMAS))
{
if (state.lsflags & LS_LONG)
state.lsflags &= ~(LS_COLUMNS|LS_COMMAS);
else
{
if (!state.width)
{
astwinsize(1, &state.height, &state.width);
if (state.width <= 20)
state.width = 80;
}
if (state.height <= 4)
state.height = 24;
}
}
if (state.lsflags & LS_STAT)
state.lsflags &= ~LS_NOSTAT;
else if (!(state.lsflags & (LS_DIRECTORY|LS_BLOCKS|LS_LONG|LS_MARK|LS_MARKDIR|LS_TIME
#if !_mem_d_fileno_dirent && !_mem_d_ino_dirent
|LS_INUMBER
#endif
)) && !sfstrtell(fmt))
{
state.lsflags |= LS_NOSTAT;
state.ftwflags |= FTW_DELAY|FTW_DOT;
}
if (!sfstrtell(fmt))
{
if (state.lsflags & LS_INUMBER)
sfputr(fmt, "%6(ino)u ", -1);
if (state.lsflags & LS_BLOCKS)
sfputr(fmt, "%5(blocks)u ", -1);
if (state.lsflags & LS_LONG)
{
sfputr(fmt, "%(mode)s %3(nlink)u", -1);
if (!(state.lsflags & LS_NOUSER))
sfprintf(fmt, " %%-8(uid)%c", (state.lsflags & LS_NUMBER) ? 'd' : 's');
if (!(state.lsflags & LS_NOGROUP))
sfprintf(fmt, " %%-8(gid)%c", (state.lsflags & LS_NUMBER) ? 'd' : 's');
sfputr(fmt, " %8(device:case::%(size)u:*:%(device)s)s", -1);
sfprintf(fmt, " %%(%s)s ", (state.timeflags & LS_ATIME) ? "atime" : (state.timeflags & LS_CTIME) ? "ctime" : "mtime");
}
sfputr(fmt, "%(name)s", -1);
if (state.lsflags & LS_MARK)
sfputr(fmt, "%(mark)s", -1);
else if (state.lsflags & LS_MARKDIR)
sfputr(fmt, "%(markdir)s", -1);
if (state.lsflags & LS_LONG)
sfputr(fmt, "%(linkop:case:?*: %(linkop)s %(linkpath)s)s", -1);
}
else
sfstrseek(fmt, -1, SEEK_CUR);
if (!(state.format = sfstruse(fmt)))
error(3, "out of space");
if (dump)
{
sfprintf(sfstdout, "%s\n", state.format);
return 0;
}
stresc(state.format);
if (argv[0])
{
if (argv[1])
state.lsflags |= LS_LABEL;
state.ftwflags |= FTW_MULTIPLE;
ftwalk((char*)argv, ls, state.ftwflags, order);
}
else
ftwalk(".", ls, state.ftwflags, order);
if (keys[KEY_summary].macro)
sfkeyprintf(sfstdout, NiL, keys[KEY_summary].macro, key, NiL);
return error_info.errors != 0;
}
