prettyness police

[unix-history] / usr / src / bin / ls / print.c

diff --git a/usr/src/bin/ls/print.c b/usr/src/bin/ls/print.c
index a6d17ec..f8b9478 100644 (file)
--- a/usr/src/bin/ls/print.c
+++ b/usr/src/bin/ls/print.c
@@ -1,6 +1,6 @@
 /*
 /*

- * Copyright (c) 1989 The Regents of the University of California.
- * All rights reserved.
+ * Copyright (c) 1989, 1993
+ *     The Regents of the University of California.  All rights reserved.

  *
  * This code is derived from software contributed to Berkeley by
  * Michael Fischbein.
  *
  * This code is derived from software contributed to Berkeley by
  * Michael Fischbein.


@@ -9,82 +9,96 @@
  */
 
 #ifndef lint
  */
 
 #ifndef lint

-static char sccsid[] = "@(#)print.c    5.26 (Berkeley) %G%";
+static char sccsid[] = "@(#)print.c    8.2 (Berkeley) %G%";

 #endif /* not lint */
 
 #include <sys/param.h>
 #include <sys/stat.h>
 #endif /* not lint */
 
 #include <sys/param.h>
 #include <sys/stat.h>

-#include <time.h>
+
+#include <err.h>

 #include <errno.h>
 #include <errno.h>

+#include <fts.h>

 #include <grp.h>
 #include <pwd.h>
 #include <grp.h>
 #include <pwd.h>

-#include <utmp.h>
-#include <tzfile.h>

 #include <stdio.h>
 #include <stdio.h>

+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <tzfile.h>
+#include <unistd.h>
+#include <utmp.h>
+

 #include "ls.h"
 #include "extern.h"
 
 #include "ls.h"
 #include "extern.h"
 

-static int     printaname __P((LS *));
-static void    printlink __P((char *));
+static int     printaname __P((FTSENT *, u_long, u_long));
+static void    printlink __P((FTSENT *));

 static void    printtime __P((time_t));
 static int     printtype __P((u_int));
 static void    printtime __P((time_t));
 static int     printtype __P((u_int));

-static char    *flags_from_fid __P((long));
+
+#define        IS_NOPRINT(p)   ((p)->fts_number == NO_PRINT)

 
 void
 
 void

-printscol(stats, num)
-       register LS *stats;
-       register int num;
+printscol(dp)
+       DISPLAY *dp;

 {
 {

-       for (; num--; ++stats) {
-               (void)printaname(stats);
+       FTSENT *p;
+
+       for (p = dp->list; p; p = p->fts_link) {
+               if (IS_NOPRINT(p))
+                       continue;
+               (void)printaname(p, dp->s_inode, dp->s_block);

                (void)putchar('\n');
        }
 }
 
 void
                (void)putchar('\n');
        }
 }
 
 void

-printlong(stats, num)
-       LS *stats;
-       register int num;
+printlong(dp)
+       DISPLAY *dp;

 {
 {

-       char modep[15], *user_from_uid(), *group_from_gid();
+       struct stat *sp;
+       FTSENT *p;
+       NAMES *np;
+       char buf[20];
+
+       if (dp->list->fts_level != FTS_ROOTLEVEL && (f_longform || f_size))
+               (void)printf("total %lu\n", howmany(dp->btotal, blocksize));

 
 

-       if (f_total)
-               (void)printf("total %lu\n", f_kblocks ?
-                   howmany(stats[0].lstat.st_btotal, 2) :
-                   stats[0].lstat.st_btotal);
-       for (; num--; ++stats) {
+       for (p = dp->list; p; p = p->fts_link) {
+               if (IS_NOPRINT(p))
+                       continue;
+               sp = p->fts_statp;

                if (f_inode)
                if (f_inode)

-                       (void)printf("%6lu ", stats->lstat.st_ino);
+                       (void)printf("%*lu ", dp->s_inode, sp->st_ino);

                if (f_size)
                if (f_size)

-                       (void)printf("%4ld ", f_kblocks ?
-                           howmany(stats->lstat.st_blocks, 2) :
-                           stats->lstat.st_blocks);
-               (void)strmode(stats->lstat.st_mode, modep);
-               (void)printf("%s %3u %-*s ", modep, stats->lstat.st_nlink,
-                   UT_NAMESIZE, user_from_uid(stats->lstat.st_uid, 0));
-               if (f_group)
-                       (void)printf("%-*s ", UT_NAMESIZE,
-                           group_from_gid(stats->lstat.st_gid, 0));
+                       (void)printf("%*qd ",
+                           dp->s_block, howmany(sp->st_blocks, blocksize));
+               (void)strmode(sp->st_mode, buf);
+               np = p->fts_pointer;
+               (void)printf("%s %*u %-*s  %-*s  ", buf, dp->s_nlink,
+                   sp->st_nlink, dp->s_user, np->user, dp->s_group,
+                   np->group);

                if (f_flags)
                if (f_flags)

-                       (void)printf("%-*s ", FLAGSWIDTH,
-                           flags_from_fid(stats->lstat.st_flags));
-               if (S_ISCHR(stats->lstat.st_mode) ||
-                   S_ISBLK(stats->lstat.st_mode))
-                       (void)printf("%3d, %3d ", major(stats->lstat.st_rdev),
-                           minor(stats->lstat.st_rdev));
+                       (void)printf("%-*s ", dp->s_flags, np->flags);
+               if (S_ISCHR(sp->st_mode) || S_ISBLK(sp->st_mode))
+                       (void)printf("%3d, %3d ",
+                           major(sp->st_rdev), minor(sp->st_rdev));
+               else if (dp->bcfile)
+                       (void)printf("%*s%*qd ",
+                           8 - dp->s_size, "", dp->s_size, sp->st_size);

                else
                else

-                       (void)printf("%8ld ", stats->lstat.st_size);
+                       (void)printf("%*qd ", dp->s_size, sp->st_size);

                if (f_accesstime)
                if (f_accesstime)

-                       printtime(stats->lstat.st_atime);
+                       printtime(sp->st_atime);

                else if (f_statustime)
                else if (f_statustime)

-                       printtime(stats->lstat.st_ctime);
+                       printtime(sp->st_ctime);

                else
                else

-                       printtime(stats->lstat.st_mtime);
-               (void)printf("%s", stats->name);
+                       printtime(sp->st_mtime);
+               (void)printf("%s", p->fts_name);

                if (f_type)
                if (f_type)

-                       (void)printtype(stats->lstat.st_mode);
-               if (S_ISLNK(stats->lstat.st_mode))
-                       printlink(stats->name);
+                       (void)printtype(sp->st_mode);
+               if (S_ISLNK(sp->st_mode))
+                       printlink(p);

                (void)putchar('\n');
        }
 }
                (void)putchar('\n');
        }
 }


@@ -92,25 +106,43 @@ printlong(stats, num)
 #define        TAB     8
 
 void
 #define        TAB     8
 
 void

-printcol(stats, num)
-       LS *stats;
-       int num;
+printcol(dp)
+       DISPLAY *dp;

 {
        extern int termwidth;
 {
        extern int termwidth;

-       register int base, chcnt, cnt, col, colwidth;
+       static FTSENT **array;
+       static int lastentries = -1;
+       FTSENT *p;
+       int base, chcnt, cnt, col, colwidth, num;

        int endcol, numcols, numrows, row;
 
        int endcol, numcols, numrows, row;
 

-       colwidth = stats[0].lstat.st_maxlen;
+       /*
+        * Have to do random access in the linked list -- build a table
+        * of pointers.
+        */
+       if (dp->entries > lastentries) {
+               lastentries = dp->entries;
+               if ((array =
+                   realloc(array, dp->entries * sizeof(FTSENT *))) == NULL) {
+                       warn(NULL);
+                       printscol(dp);
+               }
+       }
+       for (p = dp->list, num = 0; p; p = p->fts_link)
+               if (p->fts_number != NO_PRINT)
+                       array[num++] = p;
+
+       colwidth = dp->maxlen;

        if (f_inode)
        if (f_inode)

-               colwidth += 6;
+               colwidth += dp->s_inode + 1;

        if (f_size)
        if (f_size)

-               colwidth += 5;
+               colwidth += dp->s_block + 1;

        if (f_type)
                colwidth += 1;
 
        colwidth = (colwidth + TAB) & ~(TAB - 1);
        if (termwidth < 2 * colwidth) {
        if (f_type)
                colwidth += 1;
 
        colwidth = (colwidth + TAB) & ~(TAB - 1);
        if (termwidth < 2 * colwidth) {

-               printscol(stats, num);
+               printscol(dp);

                return;
        }
 
                return;
        }
 


@@ -119,14 +151,13 @@ printcol(stats, num)
        if (num % numcols)
                ++numrows;
 
        if (num % numcols)
                ++numrows;
 

-       if (f_size && f_total)
-               (void)printf("total %lu\n", f_kblocks ?
-                   howmany(stats[0].lstat.st_btotal, 2) :
-                   stats[0].lstat.st_btotal);
+       if (dp->list->fts_level != FTS_ROOTLEVEL && (f_longform || f_size))
+               (void)printf("total %lu\n", howmany(dp->btotal, blocksize));

        for (row = 0; row < numrows; ++row) {
                endcol = colwidth;
                for (base = row, chcnt = col = 0; col < numcols; ++col) {
        for (row = 0; row < numrows; ++row) {
                endcol = colwidth;
                for (base = row, chcnt = col = 0; col < numcols; ++col) {

-                       chcnt += printaname(stats + base);
+                       chcnt += printaname(array[base], dp->s_inode,
+                           dp->s_block);

                        if ((base += numrows) >= num)
                                break;
                        while ((cnt = (chcnt + TAB & ~(TAB - 1))) <= endcol) {
                        if ((base += numrows) >= num)
                                break;
                        while ((cnt = (chcnt + TAB & ~(TAB - 1))) <= endcol) {


@@ -135,29 +166,32 @@ printcol(stats, num)
                        }
                        endcol += colwidth;
                }
                        }
                        endcol += colwidth;
                }

-               putchar('\n');
+               (void)putchar('\n');

        }
 }
 
 /*
  * print [inode] [size] name
        }
 }
 
 /*
  * print [inode] [size] name

- * return # of characters printed, no trailing characters
+ * return # of characters printed, no trailing characters.

  */
 static int
  */
 static int

-printaname(lp)
-       LS *lp;
+printaname(p, inodefield, sizefield)
+       FTSENT *p;
+       u_long sizefield, inodefield;

 {
 {

+       struct stat *sp;

        int chcnt;
 
        int chcnt;
 

+       sp = p->fts_statp;

        chcnt = 0;
        if (f_inode)
        chcnt = 0;
        if (f_inode)

-               chcnt += printf("%5lu ", lp->lstat.st_ino);
+               chcnt += printf("%*lu ", (int)inodefield, sp->st_ino);

        if (f_size)
        if (f_size)

-               chcnt += printf("%4ld ", f_kblocks ?
-                   howmany(lp->lstat.st_blocks, 2) : lp->lstat.st_blocks);
-       chcnt += printf("%s", lp->name);
+               chcnt += printf("%*qd ",
+                   (int)sizefield, howmany(sp->st_blocks, blocksize));
+       chcnt += printf("%s", p->fts_name);

        if (f_type)
        if (f_type)

-               chcnt += printtype(lp->lstat.st_mode);
+               chcnt += printtype(sp->st_mode);

        return (chcnt);
 }
 
        return (chcnt);
 }
 


@@ -168,7 +202,7 @@ printtime(ftime)
        int i;
        char *longstring;
 
        int i;
        char *longstring;
 

-       longstring = ctime((time_t *)&ftime);
+       longstring = ctime(&ftime);

        for (i = 4; i < 11; ++i)
                (void)putchar(longstring[i]);
 
        for (i = 4; i < 11; ++i)
                (void)putchar(longstring[i]);
 


@@ -176,7 +210,7 @@ printtime(ftime)
        if (f_sectime)
                for (i = 11; i < 24; i++)
                        (void)putchar(longstring[i]);
        if (f_sectime)
                for (i = 11; i < 24; i++)
                        (void)putchar(longstring[i]);

-       else if (ftime + SIXMONTHS > time((time_t *)NULL))
+       else if (ftime + SIXMONTHS > time(NULL))

                for (i = 11; i < 16; ++i)
                        (void)putchar(longstring[i]);
        else {
                for (i = 11; i < 16; ++i)
                        (void)putchar(longstring[i]);
        else {


@@ -210,43 +244,21 @@ printtype(mode)
 }
 
 static void
 }
 
 static void

-printlink(name)
-       char *name;
+printlink(p)
+       FTSENT *p;

 {
        int lnklen;
 {
        int lnklen;

-       char path[MAXPATHLEN + 1];
+       char name[MAXPATHLEN + 1], path[MAXPATHLEN + 1];

 
 

-       if ((lnklen = readlink(name, path, MAXPATHLEN)) == -1) {
+       if (p->fts_level == FTS_ROOTLEVEL)
+               (void)snprintf(name, sizeof(name), "%s", p->fts_name);
+       else 
+               (void)snprintf(name, sizeof(name),
+                   "%s/%s", p->fts_parent->fts_accpath, p->fts_name);
+       if ((lnklen = readlink(name, path, sizeof(path) - 1)) == -1) {

                (void)fprintf(stderr, "\nls: %s: %s\n", name, strerror(errno));
                return;
        }
        path[lnklen] = '\0';
        (void)printf(" -> %s", path);
 }
                (void)fprintf(stderr, "\nls: %s: %s\n", name, strerror(errno));
                return;
        }
        path[lnklen] = '\0';
        (void)printf(" -> %s", path);
 }

-
-char *
-flags_from_fid(flags)
-       long flags;
-{
-       static char buf[FLAGSWIDTH + 1];
-       int size;
-
-       size = FLAGSWIDTH;
-       buf[0] = '\0';
-       if (size && (flags & NODUMP)) {
-               strncat(buf, "nodump", size);
-               size -= 6;
-       } else {
-               strncat(buf, "dump", size);
-               size -= 4;
-       }
-       if (size && (flags & IMMUTABLE)) {
-               strncat(buf, ",nochg", size);
-               size -= 6;
-       }
-       if (size && (flags & ARCHIVED)) {
-               strncat(buf, ",arch", size);
-               size -= 5;
-       }
-       return (buf);
-}