home *** CD-ROM | disk | FTP | other *** search
/ Frozen Fish 2: PC / frozenfish_august_1995.bin / bbs / d02xx / d0236.lha / Ls / ls.c < prev    next >
C/C++ Source or Header  |  1989-08-09  |  43KB  |  1,425 lines
  1. /* ---------------------------------------------------------------------
  2.   LS.C -- Source code for the "improved" directory utility.
  3.  
  4.   Author: Justin V. McCormick
  5.  
  6.   V1.0    August 1986 Written from scratch, my first Amiga project.
  7.   V2.0  November 1988 Revised for Lattice 5.0 and made 1.3 compatible.
  8.   V2.1  December 1988 Minor size reduction, fixed a few bugs from 2.0.
  9.   V2.2  December 1988 Fixed status return and multiple wildcard pathnames.
  10.   V3.0  July 25, 1989 Instant sorting, best-fit output, new features.
  11.   V3.1  July 29, 1989 Bug fixes, new output width and height options.
  12.  
  13. Notice:
  14.  
  15.   This program is placed in the public domain with the
  16. understanding that the author makes no claims or guarantees with
  17. regard to its suitability for any given application, and that
  18. the author assumes no responsibility for damages incurred by its
  19. usage.  Any resemblance of this program to any other program,
  20. either living or dead, is purely coincidental.
  21.  
  22.   Feel free to borrow this code and make millions of dollars
  23. from its sale or commercial use, but please give credit where
  24. credit is due.
  25.  
  26. Synopsis:
  27.  
  28.   Features intelligent columnar listing, versatile sort options,
  29. UNIX-style pattern matching, recursive subdirectory listing, and
  30. more!
  31.  
  32. Usage:
  33.         LS [options] [pattern1] [pattern2] ...
  34.  
  35. Bugs and Limitations:
  36.  
  37.   LS cannot pattern match devices (like "dh*:"), since this
  38. would involve another level of recursion and parsing the Device
  39. List.  LS shows signs of the same "creeping featurism" which
  40. afflicted the UNIX command, evident from its bloated code size.
  41.  
  42. Changes From 1.0 to 2.0:
  43.  
  44.  o Source code prototyped, linted, traced, optimized, tweaked, etc.
  45.  o Made resident ("pseudo-pure") by linking with cres.o from LC 5.0.
  46.  o High-volume routines recoded in assembly (lssup.a).
  47.  o Now handles multiple paths/files on a command line, up to 30.
  48.  o New sort flags, including no sort.
  49.  o Enhanced wildcards, understands complex *.?*.* expressions now.
  50.  o More efficient ExNext() performance, less ram used for recursion.
  51.  o SIGBREAKF_CTRL_C signal (Ctrl-C) cleanly aborts at any point now.
  52.  o Command line parser handles quoted pathnames now (LC 5.0 benefit).
  53.  o Short listing finally auto-adjusts to new console window sizes!
  54.  o Pen color escape codes bypassed when redirecting long output.
  55.  o Sorting by size or date is also subsorted alphabetically now.
  56.  o Long listing shows new 1.3 file attributes, plus comment indicator.
  57.  o File dates are now in international format, YY-MM-DD.
  58.  o Fixed listings with files datestamped after 99-12-31 (overflow).
  59.  o Fixed listings with files datestamped before 78-01-01 (time < 0).
  60.  
  61. Changes From 2.0 to 2.1
  62.  
  63.  o Fixed the show comment feature, a last minute bug in 2.0.
  64.  o Fixed the "Unknown option ''" message problem.
  65.  o Optimized the assembly branches, reduced code size another few bytes.
  66.  
  67. Changes From 2.1 to 2.2
  68.  
  69.  o Fixed erroneous Status returns.
  70.  o Fixed bug with multiple wildcarded pathnames.
  71.  o Compiled with LC 5.0 Patch 3 and CAPE 2.0, saved another 46 bytes.
  72.  o Eliminated an extra stpcpy(), saved another few bytes.
  73.  
  74. Changes From 2.2 to 3.0
  75.  
  76.  o Added many new command line options!  See Usage descriptions and docs.
  77.  o "Instant" output sorting, now using an on-the-fly insertion sort.
  78.  o New Short listing technique is row-by-row, redirects to PRT: or file.
  79.  o Better columnization of short listings, uses best-fit optimization.
  80.  o Formatted output parsing system implemented for long listings.
  81.  o Improved ^C handling, now breaks immediately in mid-output.
  82.  o New command line parser, now handles multiple options mixed with names.
  83.  o Added separate pattern matching for directories and files.
  84.  o Now inhibits system requesters from popping up by default.
  85.  o Added custom cres.o module for more size savings.
  86.  o Now uses Exec List functions for smaller, faster code.
  87.  o Fixed random cli_ReturnCode and pr_Result2 value CLI returns.
  88.  o Rewrote many sections, further code cleaning/commenting.
  89.  o Eliminated main(), LS handles the _main() function for smaller code.
  90.  o Compiled with 5.03.90 (beta) Lattice compiler, saved a few bytes.
  91.  
  92. Changes From 3.0 to 3.1
  93.  o Fixed random errors from uninitialized argument count in GetCLIArgs().
  94.  o New -X and -Y options to specify short format columns and rows.
  95.  
  96.  --------------------------------------------------------------------- */
  97.  
  98. /* ---------------------- LS SOURCE ---------------------------------- */
  99.  
  100. /* Use Real strlen unless you comment out the following */
  101. #define strlen strlen
  102.  
  103. /* Maximum number of command line arguments */
  104. #define MAXARG 32
  105. #define PADTABSIZE 100
  106. #define WORKSIZE 300
  107.  
  108. #include "WORK:ls.h"
  109.  
  110. /* Extern CODE from lssup.a */
  111. extern BYTE *aindex __ARGS((BYTE *, BYTE));
  112. extern LONG  __stdargs asprintf __ARGS((BYTE *, BYTE *,...));
  113. extern LONG CompareDateStamps __ARGS((struct DateStamp *, struct DateStamp *));
  114. extern LONG CompFibs __ARGS((LONG, struct FileInfoBlock *, struct FileInfoBlock *));
  115. extern LONG FillFibEntry __ARGS((struct List *, struct FileInfoBlock *));
  116. extern LONG GetFileString __ARGS((BYTE *, BYTE *));
  117. extern LONG GetPathString __ARGS((BYTE *, BYTE *));
  118. extern LONG iswild __ARGS((BYTE *));
  119. extern LONG wildmatch __ARGS((BYTE *, BYTE *));
  120. extern VOID *myalloc __ARGS((LONG));
  121. extern VOID FibFileDate __ARGS((struct DateStamp *, BYTE *, BYTE *));
  122. extern VOID GetWinBounds __ARGS((LONG *, LONG *));
  123. extern VOID InsertFibNode __ARGS((struct List *, struct FibEntry *));
  124. extern VOID MakePathString __ARGS((struct FileLock *, BYTE *));
  125. extern VOID myfree __ARGS((VOID *));
  126. extern VOID NoFileExit __ARGS((BYTE *));
  127. extern VOID NoMemExit __ARGS((VOID));
  128.  
  129. /* Local DATA */
  130. struct DateStamp theolddate;     /* Show files older than this date */
  131. struct DateStamp thenewdate;     /* Show files newer than this date */
  132. struct FileHandle *ConOut;       /* Standard output */
  133. struct FileHandle *ConIn;        /* Standard input */
  134. struct FileLock *CurFLock;       /* Global Directory lock */
  135. struct FileInfoBlock *GFibp;     /* Global FIB for Examine/ExNext */
  136. APTR OldWindowPtr;               /* Copy of what was in pr_WindowPtr */
  137.  
  138. /* User flags, See ls.h for bit definitions */
  139. ULONG LSFlags = SHOWDIRS | SHOWFILES;
  140.  
  141. LONG gdircount;                 /* Grand total # of dirs for Recursive */
  142. LONG gfilecount;                /* Grand total # of files found */
  143. LONG gtotblocks;                /* Grand total # of blocks */
  144. LONG gtotbytes;                 /* Grand total # of bytes */
  145.  
  146. LONG dircount;                  /* Number of directories found */
  147. LONG filecount;                 /* Number of files found */
  148. LONG totblocks;                 /* total # of blocks */
  149. LONG totbytes;                  /* total # of bytes */
  150. LONG maxnamlen;                 /* Longest name found */
  151. LONG sortkey;                   /* 0=alpha, 1=size, 2=date */
  152.  
  153. BYTE padtab[PADTABSIZE];        /* Column table tab amounts */
  154. BYTE thePath[WORKSIZE];         /* Current filename space */
  155. BYTE theDirPat[WORKSIZE];       /* Dirname pattern workspace */
  156. BYTE theFilePat[WORKSIZE];      /* Filename pattern workspace */
  157. BYTE workstr[WORKSIZE+64];      /* Temp string space */
  158.  
  159. BYTE theblksstr[20];
  160. BYTE thedatestr[12];
  161. BYTE theprotstr[12];
  162. BYTE thesizestr[20];
  163. BYTE thetimestr[12];
  164.  
  165. LONG CurWinRows;                /* Window bounds, determined at runtime */
  166. LONG CurWinCols;
  167.  
  168. /* Initialized Strings */
  169. BYTE Author[]  = "\23333mLS 3.1\2330m PD Freeware by Justin V. McCormick 89-07-29";
  170. BYTE usage[]   = "\n  Usage: LS [-options <args>] [path1] [path2] ...\n";
  171. BYTE usage0[]  = "\tc  Show filenotes           D  Show dirs last\n";
  172. BYTE usage1[]  = "\td  Dirs only                H  No headings and subtotals\n";
  173. BYTE usage2[]  = "\tf  Files only               I  No page prompts\n";
  174. BYTE usage3[]  = "\tk  No ANSI display codes    M  Mixed output files and dirs\n";
  175. BYTE usage4[]  = "\tl  Long listing             N <name> Show newer than entry\n";
  176. BYTE usage5[]  = "\tn  No sort                  O <name> Show older than entry\n";
  177. BYTE usage6[]  = "\tp  Permit system requests   P  Show full pathnames\n";
  178. BYTE usage7[]  = "\tr  Reverse sort             R  Recursive listing\n";
  179. BYTE usage8[]  = "\ts  Sort by size             T  Total all subtotals\n";
  180. BYTE usage9[]  = "\tt  Sort by date             X <wide> Set output columns\n";
  181. BYTE usage10[] = "\tv <pattern> Avoid pattern   Y <high> Set output rows\n";
  182. BYTE usage11[] = "\tF <format> Format output (default: \042";
  183. BYTE usage12[] = "\042)\n";
  184.  
  185. /* Date and output format strings */
  186. BYTE baddatestr[]     = "00-00-00";
  187. BYTE badtimestr[]     = "00:00:00";
  188. BYTE datepat[]        = "%02ld-%02ld-%02ld";
  189. BYTE timepat[]        = "%02ld:%02ld:%02ld";
  190. BYTE dayspermonth[12] = { 31,28,31,30,31,30,31,31,30,31,30,31 };
  191. BYTE deffmtstr[40]    = "%p %d %t %4b %8s %n\\n";
  192. BYTE LongFmtStr[]     = "%ld";
  193. BYTE totalfmtstr[]    = "Dirs:%-4ld Files:%-4ld Blocks:%-5ld Bytes:%-8ld\n";
  194. BYTE TotHeaderMsg[]   = "Totals:\n";
  195. BYTE ColonStr[]       = ":";
  196. BYTE SlashStr[]       = "/";
  197. BYTE RamNameStr[]     = "RAM:";
  198.  
  199. /* ANSI color control strings */
  200. BYTE penstr0[]        = "\2330m";       /* Reset CON:   */
  201. BYTE penstr1[]        = "\2330 p";      /* Cursor off   */
  202. BYTE penstr2[]        = "\233 p";       /* Cursor on    */
  203. BYTE penstr3[]        = "\23333m";      /* Color 3 NORM */
  204. BYTE penstr4[]        = "\2331;33;40m"; /* Color 3 BOLD */
  205. BYTE penstr5[]        = "\2331;31;40m"; /* Color 1 BOLD */
  206.  
  207. /* CON: command sequence for window bounds report */
  208. BYTE gwbrstr[4] = {  0x9b, '0', ' ', 'q' };
  209.  
  210. /* Newline and "" source */
  211. BYTE NLine[4] = { 10, 0, 0, 0 };
  212.  
  213. /* Error messages */
  214. BYTE BadOptFmtStr[]   = "Unknown option: -%s\n";
  215. BYTE ErrFmtStr[]      = "LS: %s, Error #%ld\n";
  216. BYTE NoExamFmtStr[]   = "Cannot examine file or directory, Error #%ld\n";
  217. BYTE NoFindFmtStr[]   = "'%s' not found";
  218. BYTE NoRAMMsg[]       = "No RAM";
  219. BYTE NoWildPathMsg[]  = "Unable to pattern match paths";
  220. BYTE VolEmptyMsg[]    = "Volume or directory is empty.\n";
  221. BYTE NoMatchMsg[]     = "No match.\n";
  222.  
  223. /* Pointers to usage strings for quick easy output */
  224. BYTE *usagestrs[] =
  225. {
  226.   Author, usage, usage0, usage1, usage2, usage3, usage4, usage5,
  227.   usage6, usage7, usage8, usage9, usage10, usage11, deffmtstr, usage12, 0L
  228. };
  229.  
  230. BYTE *thefmtstr = deffmtstr;    /* Format string pointer for long output */
  231. BYTE *curpath;
  232. BYTE *theAntiPat;        /* Avoid pattern string */
  233.  
  234. /* Local CODE */
  235. BYTE *GetDecNum __ARGS((BYTE *, LONG *));
  236. LONG CmpDateBounds __ARGS((struct DateStamp *));
  237. LONG GetFileDate __ARGS((BYTE *, struct DateStamp *));
  238. LONG ParseCmdOptions __ARGS((LONG, LONG, BYTE **));
  239. struct FibEntry *AllocFib __ARGS((VOID));
  240. struct FibEntry *ModNextFib __ARGS((struct FibEntry *, LONG));
  241. struct List *GetDir __ARGS((struct FileLock *, struct FileInfoBlock *));
  242. VOID CleanUp __ARGS((BYTE *, LONG, LONG));
  243. VOID DirIt __ARGS((struct FileLock *, BYTE *));
  244. VOID FreeAllFibs __ARGS((struct List *));
  245. VOID GetCLIArgs __ARGS((BYTE *, LONG *, BYTE **));
  246. VOID LListDir __ARGS((struct List *));
  247. VOID LListEntry __ARGS((struct FileInfoBlock *));
  248. VOID LongList __ARGS((LONG *, LONG *, struct List *));
  249. VOID PagePrompt __ARGS((LONG, LONG));
  250. VOID ParseFormatOpts __ARGS((struct FileInfoBlock *));
  251. VOID SetConPen __ARGS((BYTE *));
  252. VOID SListDir __ARGS((struct List *));
  253. VOID TestBreak __ARGS((VOID));
  254. VOID Usage __ARGS((VOID));
  255. VOID WCHR __ARGS((BYTE *));
  256. VOID WSTR __ARGS((BYTE *));
  257. VOID _main __ARGS((BYTE *));
  258.  
  259. /* --------------------------------------------------------------------
  260.  * Allocate a FibEntry structure and associated FileInfoBlock.
  261.  * -------------------------------------------------------------------- */
  262. struct FibEntry *AllocFib ()
  263. {
  264.   struct FibEntry *tfibp;
  265.  
  266.   if ((tfibp = myalloc ((LONG)(sizeof (struct FibEntry) + sizeof (struct FileInfoBlock)))) != 0)
  267.   {
  268.     tfibp->fe_Fib = (struct FileInfoBlock *)((ULONG)tfibp + sizeof (struct FibEntry));
  269.   }
  270.   else
  271.     LSFlags |= BREAKFLAG;
  272.   return (tfibp);
  273. }
  274.  
  275. /* --------------------------------------------------------------------
  276.  * Use AmigaDOS to output a string to the stdout channel
  277.  * -------------------------------------------------------------------- */
  278. VOID WSTR (tstring)
  279.   BYTE *tstring;
  280. {
  281.   LONG i;
  282.  
  283.   i = strlen (tstring);
  284.   if (i > 0)
  285.   {
  286.     (VOID) Write ((BPTR)ConOut, tstring, i);
  287.   }
  288. }
  289.  
  290. /* --------------------------------------------------------------------
  291.  * Use AmigaDOS to put a character to the stdout
  292.  * -------------------------------------------------------------------- */
  293. VOID WCHR (ch)
  294.   BYTE *ch;
  295. {
  296.   (VOID) Write ((BPTR)ConOut, ch, 1L);
  297. }
  298.  
  299. /* --------------------------------------------------------------------
  300.  * Check to see if the user hit ^C
  301.  * -------------------------------------------------------------------- */
  302. VOID TestBreak ()
  303. {
  304.   ULONG oldsig;
  305.  
  306.   oldsig = SetSignal (0L, (LONG)SIGBREAKF_CTRL_C);
  307.   if ((oldsig & SIGBREAKF_CTRL_C) != 0)
  308.   {
  309.     WSTR ("\2330m\233 p**BREAK\n");
  310.     LSFlags |= BREAKFLAG;
  311.   }
  312. }
  313.  
  314. /* --------------------------------------------------------------------
  315.  * Prompt the user to hit return, wait till return is hit
  316.  * -------------------------------------------------------------------- */
  317. VOID PagePrompt (page, maxpage)
  318.   LONG page, maxpage;
  319. {
  320.   if (CurWinCols > maxnamlen && page > 1 && (LSFlags & NOINTERACT) == 0)
  321.   {
  322.     WSTR ("\2337m -- MORE -- ");
  323.     if (CurWinCols >= 27)
  324.       WSTR ("Press Return: ");
  325.     WSTR ("\2330m\233 p");
  326.     (VOID) Read ((BPTR)ConIn, workstr, 1L);
  327.     WSTR ("\2330 p\233F\233K");
  328.     TestBreak ();
  329.   }
  330.  
  331.   if ((LSFlags & (NOHEADERS|BREAKFLAG)) == 0)
  332.   {
  333.     if ((LSFlags & CONSOLE) != 0)
  334.     {
  335.       WSTR ("\2330 p\2334;33m");
  336.     }
  337.     (VOID) asprintf (workstr, "Page %ld of %ld:", page, maxpage);
  338.     WSTR (workstr);
  339.     SetConPen (penstr0);
  340.     WSTR (NLine);
  341.   }
  342. }
  343.  
  344. /* -------------------------------------------------------------------- */
  345. struct FibEntry *ModNextFib(tfibp, rows)
  346.   struct FibEntry *tfibp;
  347.   LONG rows;
  348. {
  349.   LONG i;
  350.  
  351.   for (i = 0; i < rows && tfibp->fe_Node.mln_Succ != 0; i++)
  352.   {
  353.     tfibp = (struct FibEntry *)tfibp->fe_Node.mln_Succ;
  354.   }
  355.   return(tfibp);
  356. }
  357.  
  358. /* --------------------------------------------------------------------
  359.  * set CON: character color to default Pen1 colors 
  360.  * -------------------------------------------------------------------- */
  361. VOID SetConPen (penstr)
  362.   BYTE *penstr;
  363. {
  364.   if ((LSFlags & CONSOLE) != 0)
  365.     WSTR (penstr);
  366. }
  367.  
  368. /* #define DEBUGSLD 1 */
  369. /* --------------------------------------------------------------------
  370.  * List a FibEntry list in a compact fashion
  371.  * -------------------------------------------------------------------- */
  372. VOID SListDir (fibheadp)
  373.   struct List *fibheadp;
  374. {
  375.   LONG avglen;
  376.   LONG colcnt;
  377.   LONG currow;
  378.   LONG dfcount;
  379.   LONG i, j, wlen;
  380.   LONG maxcol;
  381.   LONG maxpage;
  382.   LONG maxrow;
  383.   LONG maxwinrow;
  384.   LONG pagecnt;
  385.   LONG rowcnt;
  386.   LONG tlen;
  387.   LONG totlen;
  388.   struct FibEntry *hfibp, *tfibp;
  389.  
  390.   SetConPen (penstr1);        /* Turn the cursor off since it will blink anyway */
  391.   GetWinBounds (&colcnt, &currow); /* Get current window size */
  392.  
  393.   if (CurWinCols == 0)
  394.     CurWinCols = colcnt;
  395.   if (CurWinRows == 0)
  396.     CurWinRows = currow;
  397.  
  398. /* Make a average-case WxH estimate for # of display columns */
  399.   for (totlen = dfcount = 0, hfibp = (struct FibEntry *)fibheadp->lh_Head;
  400.        hfibp->fe_Node.mln_Succ != 0;
  401.        hfibp = (struct FibEntry *)hfibp->fe_Node.mln_Succ)
  402.   {
  403.     if (hfibp->fe_Fib->fib_DirEntryType > 0 && (LSFlags & CONSOLE) == 0)
  404.       (VOID) strcat (hfibp->fe_Fib->fib_FileName, SlashStr);
  405.     totlen += strlen (hfibp->fe_Fib->fib_FileName);
  406.     dfcount++;
  407.   }
  408.  
  409. /* Calc average length of all entries */
  410.   avglen = totlen / dfcount;            /* Avg name length = totlen/numentries */
  411.   if ((totlen % dfcount) != 0)
  412.     avglen++;
  413.  
  414.   if ((CurWinCols) <= maxnamlen)        /* Longest name wider than window? */
  415.     maxcol = 1;                         /* Yep, just print one column */
  416.   else
  417.   {
  418.   /* Else maxcols = winwidth/namewidth */
  419.     for (maxcol = 0, colcnt = CurWinCols; colcnt >= avglen; maxcol++)
  420.     {
  421.       colcnt -= avglen + 2;
  422.     }
  423.   }
  424. #ifdef DEBUGSLD
  425.   asprintf(workstr, "avg:%ld max:%ld\n", avglen, maxnamlen); WSTR(workstr);
  426. #endif
  427.  
  428. /* Dry run output avg-case WxH table to see if it needs adjusting */
  429.   for (;;)
  430.   {
  431.   /* Clear out previous padtab */
  432.     memset(padtab, 0, PADTABSIZE);
  433.  
  434.   /* Number of rows = total entries / entries per row */
  435.     maxrow = dfcount / maxcol;
  436.     if ((dfcount % maxcol) != 0)        /* Round up if non-integral */
  437.       maxrow++;
  438. #ifdef DEBUGSLD
  439.     asprintf(workstr, "avg: %ld rows by %ld cols\n", maxrow, maxcol); WSTR(workstr);
  440. #endif
  441.  
  442.     for (rowcnt = 0, hfibp = (struct FibEntry *)fibheadp->lh_Head;
  443.          rowcnt < maxrow && hfibp->fe_Node.mln_Succ != 0;
  444.          rowcnt++, hfibp = (struct FibEntry *)hfibp->fe_Node.mln_Succ)
  445.     {
  446.       for (colcnt = 0, tfibp = hfibp;
  447.            colcnt < maxcol && tfibp->fe_Node.mln_Succ != 0;
  448.            colcnt++, tfibp = ModNextFib (tfibp, maxrow))
  449.       {
  450.         tlen = strlen (tfibp->fe_Fib->fib_FileName);
  451.         if (tlen > padtab[colcnt])
  452.           padtab[colcnt] = tlen;
  453.       }
  454.  
  455.     /* If this is the first row, calc actual maxcol/maxrow for this dfcount */
  456.       if (rowcnt == 0)
  457.       {
  458.         maxcol = colcnt;
  459.         maxrow = dfcount / maxcol;
  460.         if ((dfcount % maxcol) != 0)    /* Round up if non-integral */
  461.           maxrow++;
  462.       }
  463.     }
  464.  
  465.   /* Calculate actual total width by adding up width of all columns */
  466.     for (colcnt = totlen = 0; (colcnt + 1) < maxcol; colcnt++)
  467.     {
  468.       totlen += (LONG)padtab[colcnt] + 2;
  469. #ifdef DEBUGSLD
  470.       asprintf(workstr, "padtab[%ld]=%ld\n", colcnt, (LONG)padtab[colcnt]); WSTR(workstr);
  471. #endif
  472.     }
  473.     totlen += (LONG)padtab[colcnt];
  474. #ifdef DEBUGSLD
  475.     asprintf(workstr, "padtab[%ld]=%ld\n", colcnt, (LONG)padtab[colcnt]); WSTR(workstr);
  476.     asprintf(workstr, "totlen %ld\n", totlen); WSTR(workstr);
  477. #endif
  478.  
  479.   /* if More than one column and 
  480.    * total width of all columns is greater > our window width,
  481.    * then decrease number of display columns
  482.    */
  483.     if (maxcol > 1 && totlen > CurWinCols)
  484.     {
  485.       maxcol--;
  486. #ifdef DEBUGSLD
  487.       asprintf(workstr, "new maxcol:%ld\n", maxcol); WSTR(workstr);
  488. #endif
  489.     }
  490.     else
  491.       break;
  492.   }
  493. #ifdef DEBUGSLD
  494.   asprintf(workstr, "adjusted: maxrow:%ld maxcol:%ld (winwidth:%ld totlen:%ld)\n", maxrow, maxcol, CurWinCols, totlen); WSTR(workstr);
  495. #endif
  496.  
  497. /* Calc number of pages */
  498.   maxwinrow = CurWinRows - 3;
  499.   if (maxwinrow <= 0)
  500.     maxwinrow = 1;
  501.   pagecnt = 1;
  502.   maxpage = maxrow / maxwinrow;
  503.   if ((maxrow % maxwinrow) != 0)
  504.     maxpage++;
  505.  
  506. /* Do actual output scan */
  507.   for (rowcnt = 0, currow = maxwinrow, hfibp = (struct FibEntry *)fibheadp->lh_Head;
  508.        (LSFlags & BREAKFLAG) == 0 && rowcnt < maxrow && hfibp->fe_Node.mln_Succ != 0;
  509.        TestBreak(), rowcnt++, currow++, hfibp = (struct FibEntry *)hfibp->fe_Node.mln_Succ)
  510.   {
  511.     if (maxpage > 1 && currow == maxwinrow)
  512.     {
  513.       currow = 0;
  514.       if ((LSFlags & CONSOLE) != 0)
  515.       {
  516.         PagePrompt (pagecnt, maxpage);
  517.         if ((LSFlags & BREAKFLAG) != 0)
  518.           break;
  519.       }
  520.       pagecnt++;
  521.     }
  522.  
  523.     for (colcnt = 0, tfibp = hfibp;
  524.          colcnt < maxcol && tfibp->fe_Node.mln_Succ != 0;
  525.          colcnt++)
  526.     {
  527.       if (tfibp->fe_Fib->fib_DirEntryType < 0)
  528.       {
  529.       /* Print a file entry */
  530.         (VOID) stpcpy (workstr, tfibp->fe_Fib->fib_FileName);
  531.         wlen = strlen (workstr);
  532.       }
  533.       else
  534.       {
  535.       /* Print a directory entry */
  536.         workstr[0] = 0;
  537.         wlen = strlen (tfibp->fe_Fib->fib_FileName);
  538.         if ((LSFlags & CONSOLE) != 0)
  539.           (VOID) strcat (workstr, penstr3);
  540.         (VOID) strcat (workstr, tfibp->fe_Fib->fib_FileName);
  541.         if ((LSFlags & CONSOLE) != 0)
  542.           (VOID) strcat (workstr, penstr0);
  543.       }
  544.  
  545.     /* Move along list to the next entry, mod maxcol, print this entry */
  546.       tfibp = ModNextFib (tfibp, maxrow);
  547.  
  548.     /* If this is not the last column, pad with spaces till we get to next column */
  549.       if ((colcnt + 1) < maxcol && tfibp->fe_Node.mln_Succ != 0)
  550.       {
  551.         for (i = (LONG)padtab[colcnt] + 1, j = strlen (workstr); i >= wlen; i--, j++)
  552.           workstr[j] = ' ';
  553.         workstr[j] = 0;
  554.       }
  555.     /* Output the final entry */
  556.       WSTR (workstr);
  557.     }
  558.  
  559.   /* Filled this row, start next down */
  560.     WCHR (NLine);
  561.   }
  562.  
  563.   SetConPen (penstr2);        /* Turn cursor back on */
  564. }
  565.  
  566. /* -------------------------------------------------------------------- */
  567. BYTE *GetDecNum (cp, spccnt)
  568.   BYTE *cp;
  569.   LONG *spccnt;
  570. {
  571.   for (*spccnt = 0; *cp >= '0' && *cp <= '9'; cp++)
  572.   {
  573.     *spccnt = *spccnt * 10 + (LONG)*cp - '0';
  574.   }
  575.   return (cp);
  576. }
  577.  
  578. /* -------------------------------------------------------------------- */
  579. VOID ParseFormatOpts (fib)
  580.   struct FileInfoBlock *fib;
  581. {
  582.   BYTE *cp1, *cp2, *reps;
  583.   BYTE *pathend, *thenamestr;
  584.   LONG i, spccnt;
  585.  
  586.   i = strlen (curpath);
  587.   pathend = curpath + i;
  588.   if (i > 1 && *(curpath + i - 1) != ':')
  589.   {
  590.     *(curpath + i) = '/';
  591.     i++;
  592.     *(curpath + i) = 0;
  593.   }
  594.   thenamestr = curpath + strlen(curpath);
  595.   cp2 = thenamestr;
  596.   if (fib->fib_DirEntryType > 0 && (LSFlags & CONSOLE) != 0)
  597.     cp2 = stpcpy (cp2, penstr3);
  598.   cp2 = stpcpy (cp2, fib->fib_FileName);
  599.   if (fib->fib_DirEntryType > 0 && (LSFlags & CONSOLE) != 0)
  600.     (VOID) stpcpy (cp2, penstr0);
  601.  
  602.   for (cp1 = workstr, cp2 = thefmtstr; *cp2 != 0; cp2++)
  603.   {
  604.     if (*cp2 != '%' && *cp2 != '\\')
  605.       *cp1++ = *cp2;
  606.     else
  607.     {
  608.       if (*cp2 == '%')
  609.       {
  610.         cp2++;
  611.         cp2 = GetDecNum (cp2, &spccnt);
  612.         if (spccnt > 99)
  613.         {
  614.           spccnt = 99;
  615.         }
  616.           
  617.         switch (*cp2)
  618.         {
  619.           case 'p':
  620.             reps = theprotstr;
  621.             break;
  622.           case 'd':
  623.             reps = thedatestr;
  624.             break;
  625.           case 't':
  626.             reps = thetimestr;
  627.             break;
  628.           case 'b':
  629.             reps = theblksstr;
  630.             break;
  631.           case 's':
  632.             reps = thesizestr;
  633.             break;
  634.           case 'n':
  635.             if (fib->fib_DirEntryType > 0 && (LSFlags & CONSOLE) != 0 && spccnt > 0)
  636.               spccnt += 7;
  637.             if ((LSFlags & FULLPATHNAMES) != 0)
  638.               reps = curpath;
  639.             else
  640.               reps = thenamestr;
  641.             break;
  642.           case '%':
  643.             *cp1++ = '%';
  644.             *cp1++ = 0;
  645.           default:
  646.             reps = &NLine[1];
  647.             break;
  648.         }
  649.         for (i = strlen(reps); i < spccnt; i++)
  650.           *cp1++ = ' ';
  651.         cp1 = stpcpy (cp1, reps);
  652.       }
  653.       else
  654.       {
  655.         cp2++;
  656.         switch (*cp2)
  657.         {
  658.           case 'n':
  659.             *cp1++ = '\n';
  660.             break;
  661.           case 't':
  662.             *cp1++ = '\t';
  663.             break;
  664.           case '\\':
  665.             *cp1++ = '\\';
  666.             break;
  667.           default:
  668.             break;
  669.         }
  670.         *cp1 = 0;
  671.       }
  672.     }
  673.   }
  674.   WSTR (workstr);
  675.  
  676.   if ((LSFlags & NOTEFLAG) != 0 && fib->fib_Comment[0] != 0)
  677.   {
  678.     SetConPen(penstr3);
  679.     (VOID)asprintf(workstr, "/* %s */\n", fib->fib_Comment);
  680.     WSTR (workstr);
  681.     SetConPen(penstr0);
  682.   }
  683.   *pathend = 0;
  684. }
  685.  
  686. /* --------------------------------------------------------------------
  687.  * Verbosely list a particular FibEntry
  688.  * -------------------------------------------------------------------- */
  689. VOID LListEntry (fib)
  690.   struct FileInfoBlock *fib;
  691. {
  692.   LONG i, pmodes;
  693.  
  694.   pmodes = fib->fib_Protection & 0xff;
  695.   (VOID)stpcpy (theprotstr, "chsparwed");
  696.   for (i = 3; i >=  0; i--)
  697.   {
  698.     if ((pmodes & (1 << i)) != 0)
  699.       theprotstr[8 - i] = '-';
  700.     if ((pmodes & (1 << (i + 4))) == 0)
  701.       theprotstr[4 - i] = '-';
  702.   }
  703.  
  704.   if (fib->fib_Comment[0] == 0)
  705.     theprotstr[0] = '-';
  706.  
  707.   FibFileDate (&fib->fib_Date, thedatestr, thetimestr);
  708.  
  709.   if (fib->fib_DirEntryType > 0)
  710.   {
  711.     (VOID)stpcpy (theblksstr, "0");
  712.     (VOID)stpcpy (thesizestr, "Dir");
  713.   }
  714.   else
  715.   {
  716.     (VOID) asprintf (theblksstr, LongFmtStr, fib->fib_NumBlocks);
  717.     (VOID) asprintf (thesizestr, LongFmtStr, fib->fib_Size);
  718.   }
  719.     
  720.   ParseFormatOpts (fib);
  721. }
  722.  
  723. /* --------------------------------------------------------------------
  724.  * List a directory in a verbose informative manner
  725.  * -------------------------------------------------------------------- */
  726. VOID LListDir (fibheadp)
  727.   struct List *fibheadp;
  728. {
  729.   struct FibEntry *tfibp;
  730.  
  731.   SetConPen(penstr1);
  732.  
  733.   totblocks = totbytes = 0;
  734.   for (tfibp = (struct FibEntry *)fibheadp->lh_Head;
  735.        tfibp->fe_Node.mln_Succ != 0;
  736.        tfibp = (struct FibEntry *)tfibp->fe_Node.mln_Succ)
  737.   {
  738.     TestBreak();
  739.     if ((LSFlags & BREAKFLAG) != 0)
  740.       return;
  741.     LListEntry (tfibp->fe_Fib);
  742.     if (tfibp->fe_Fib->fib_DirEntryType < 0)
  743.     {
  744.       totblocks += tfibp->fe_Fib->fib_NumBlocks;
  745.       totbytes += tfibp->fe_Fib->fib_Size;
  746.     }
  747.   }
  748.  
  749.   if ((LSFlags & (BREAKFLAG | NOHEADERS)) == 0)
  750.   {
  751.     (VOID) asprintf (workstr, totalfmtstr, dircount, filecount, totblocks, totbytes);
  752.     WSTR (workstr);
  753.   }
  754.  
  755.   SetConPen(penstr2);
  756. }
  757.  
  758. /* -------------------------------------------------------------------- */
  759. LONG CmpDateBounds (tdate)
  760.   struct DateStamp *tdate;
  761. {
  762.   if ((LSFlags & SHOWNEWERTHAN) != 0)
  763.   {
  764.     if (CompareDateStamps(&thenewdate, tdate) >= 0)
  765.       return (0L);
  766.   }
  767.   if ((LSFlags & SHOWOLDERTHAN) != 0)
  768.   {
  769.     if (CompareDateStamps(tdate, &theolddate) >= 0)
  770.       return (0L);
  771.   }
  772.   return (1L);
  773. }
  774.  
  775. /* --------------------------------------------------------------------
  776.  * Free up memory allocated to a linked list of FibEntrys
  777.  * -------------------------------------------------------------------- */
  778. VOID FreeAllFibs (fibheadp)
  779.   struct List *fibheadp;
  780. {
  781.   struct FibEntry *tfibp;
  782.  
  783.   if (fibheadp != 0)
  784.   {
  785.     while (fibheadp->lh_Head->ln_Succ != 0)
  786.     {
  787.       tfibp = (struct FibEntry *)RemTail(fibheadp);
  788.       myfree (tfibp);
  789.     }
  790.  
  791.   /* Now free the MinList itself */
  792.     myfree (fibheadp);
  793.   }
  794. }
  795.  
  796. /* --------------------------------------------------------------------
  797.  * Allocate and fill a linked list of FileInfoBlocks
  798.  * -------------------------------------------------------------------- */
  799. struct List *GetDir (lockp, fibp)
  800.   struct FileLock *lockp;
  801.   struct FileInfoBlock *fibp;
  802. {
  803.   BYTE *thepat;                /* Pattern pointer to dir or file pattern */
  804.   LONG matchstat;              /* Result of wildmatch() */
  805.   LONG nextstat;               /* Status of ExNext() */
  806.   LONG tempnamlen;             /* Compare length for strings */
  807.   LONG dfcount;
  808.   struct List *fibhead;        /* Temp list of Fibs created */
  809.   struct List *dirhead;        /* Temp list of dirs if SHOWDIRS == 0 */
  810.  
  811.   maxnamlen = dfcount = dircount = filecount = 0L;
  812.  
  813. /* Initialize an exec list of nodes, zero entries */
  814.   if ((fibhead = myalloc ((LONG)sizeof(struct MinList))) == 0)
  815.     return (0L);
  816.   NewList (fibhead);
  817.  
  818. /* Allocate an separate list for directories that don't match specs */
  819.   if ((dirhead = myalloc((LONG)sizeof(struct MinList))) == 0)
  820.     goto BADALLOC;
  821.   NewList (dirhead);
  822.  
  823.   do
  824.   {
  825.     TestBreak ();
  826.     if ((LSFlags & BREAKFLAG) != 0)
  827.       goto GOODRET;
  828.  
  829.   /* If we got something */
  830.     if ((nextstat = ExNext ((BPTR)lockp, fibp)) != 0)
  831.     {
  832.       dfcount++;
  833.  
  834.     /* If the entry is wanted bump count of files or directories */
  835.       if (CmpDateBounds (&fibp->fib_Date) != 0)
  836.       {
  837.         if (fibp->fib_DirEntryType > 0) /* It's a directory */
  838.           thepat = theDirPat;
  839.         else
  840.           thepat = theFilePat;
  841.  
  842.         matchstat = wildmatch (fibp->fib_FileName, thepat);
  843.         if ((LSFlags & ANTIMATCH) != 0 && matchstat != 0)
  844.           matchstat = wildmatch (fibp->fib_FileName, theAntiPat) ^ 1;
  845.  
  846.     if (matchstat == 0)    /* No match? Then move on */
  847.       continue;
  848.  
  849.         if (fibp->fib_DirEntryType > 0) /* It's a directory */
  850.         {
  851.           if (FillFibEntry (dirhead, fibp) == 0)
  852.             goto BADALLOC;
  853.           if ((LSFlags & SHOWDIRS) != 0)
  854.           {
  855.             dircount++;
  856.             gdircount++;
  857.           }
  858.           else
  859.             continue;
  860.         }
  861.         else                            /* It's a file entry */
  862.         {
  863.           if ((LSFlags & SHOWFILES) != 0)
  864.           {
  865.             filecount++;
  866.             gfilecount++;
  867.             gtotblocks += fibp->fib_NumBlocks;
  868.             gtotbytes += fibp->fib_Size;
  869.           }
  870.           else                /* Don't want this file, move on to next entry */
  871.             continue;
  872.         }
  873.  
  874.       /* See if this is the longest filename for later use in listing */
  875.         tempnamlen = strlen (fibp->fib_FileName);
  876.         if (tempnamlen > maxnamlen)
  877.           maxnamlen = tempnamlen;
  878.  
  879.       /* Allocate another FibEntry, put the info inside */
  880.         if (FillFibEntry (fibhead, fibp) == 0)
  881.           goto BADALLOC;
  882.       }
  883.     }
  884.   } while (nextstat != 0);
  885.  
  886. /* No entries found? print message and return FALSE */
  887.   if ((dircount + filecount) == 0)
  888.   {
  889.     if ((LSFlags & NOHEADERS) == 0)
  890.     {
  891.       if (dfcount == 0)
  892.         WSTR (VolEmptyMsg);
  893.       else
  894.         WSTR (NoMatchMsg);
  895.     }
  896.   }
  897.   else
  898.   {
  899.     if ((LSFlags & (SHOWDIRS|SHOWFILES)) != 0)
  900.     {
  901.       if ((LSFlags & LONGLIST) == 0)  /* Short listing wanted */
  902.         SListDir (fibhead);
  903.       else                            /* Full listing */
  904.         LListDir (fibhead);
  905.     }
  906.   }
  907.  
  908. GOODRET:
  909.   FreeAllFibs (fibhead);
  910.   return (dirhead);
  911.  
  912. BADALLOC:
  913.   FreeAllFibs (fibhead);
  914.   FreeAllFibs (dirhead);
  915.   return (0L);
  916. }
  917.  
  918. /* --------------------------------------------------------------------
  919.  * Given a directory name and a lock on that directory, create a list
  920.  * of entries.  Recursively decends into subdirectories if flaged.
  921.  * -------------------------------------------------------------------- */
  922. VOID DirIt (curlock, dirname)
  923.   struct FileLock *curlock;
  924.   BYTE *dirname;
  925. {
  926.   BYTE *subdir;
  927.   LONG dnamlen;
  928.   struct FibEntry *tfibp;
  929.   struct FileLock *sublock;
  930.   struct List *fibheadp;
  931.  
  932. /* Try to fill FileInfoBlock, bomb if not readable for some reason */
  933.   if (Examine ((BPTR)curlock, GFibp) == 0)
  934.   {
  935.     (VOID) asprintf (workstr, NoExamFmtStr, IoErr());
  936.     WSTR (workstr);
  937.     return;
  938.   }
  939.  
  940. /* Put directory header for each listing, if we know the name && recursive */
  941.   if (dirname[0] != 0 && (LSFlags & LISTALL) != 0 && (LSFlags & NOHEADERS) == 0)
  942.   {
  943.     if ((LSFlags & CONSOLE) != 0)
  944.      (VOID)asprintf (workstr, "\23330;41m %s \2330m\n", dirname);
  945.     else
  946.      (VOID)asprintf (workstr, "%s\n", dirname);
  947.     WSTR (workstr);
  948.   }
  949.  
  950. /* If this is a single file list it verbosely */
  951.   if (GFibp->fib_DirEntryType < 0)
  952.   {
  953.     if ((LSFlags & SHOWFILES) != 0)
  954.     {
  955.       (VOID) GetPathString (thePath, thePath);
  956.       LListEntry (GFibp);
  957.     }
  958.   }
  959.   else /* It is a directory entry */
  960.   {
  961.   /* Allocate, fill, and display a dir of entries, check for no ram or abort */
  962.     if ((fibheadp = GetDir (curlock, GFibp)) != 0)
  963.     {
  964.     /* Recursively descend any subdirs in this list, if wanted */
  965.       if ((LSFlags & LISTALL) != 0)
  966.       {
  967.         for (tfibp = (struct FibEntry *)fibheadp->lh_Head;
  968.               tfibp->fe_Node.mln_Succ != 0;
  969.               tfibp = (struct FibEntry *)tfibp->fe_Node.mln_Succ)
  970.         {
  971.           TestBreak ();
  972.           if ((LSFlags & BREAKFLAG) != 0)
  973.             break;
  974.  
  975.           if (tfibp->fe_Fib->fib_DirEntryType > 0)
  976.           {
  977.           /* Alloc length of path + 1 + newdir name +1 + length of maxname + 1 for NULL
  978.            * + 1 for null + 3 for rounding.
  979.            */
  980.             dnamlen = (LONG)(strlen (dirname) + strlen (tfibp->fe_Fib->fib_FileName) + 36);
  981.             if ((subdir = myalloc ((LONG)dnamlen)) != 0)
  982.             {
  983.               if (dirname[0] != 0)
  984.               {
  985.                 (VOID) stpcpy (subdir, dirname);
  986.                 dnamlen = strlen (dirname) - 1;
  987.                 if (dirname[dnamlen] != ':' && dirname[dnamlen] != '/')
  988.                 {
  989.                   (VOID) strcat (subdir, SlashStr);
  990.                 }
  991.               }
  992.               (VOID) strcat (subdir, tfibp->fe_Fib->fib_FileName);
  993.  
  994.               if ((sublock = (struct FileLock *)Lock (subdir, (LONG)ACCESS_READ)) != 0)
  995.               {
  996.                 if ((LSFlags & NOHEADERS) == 0)
  997.                   WCHR (NLine);                 /* Put a blank line between directories */
  998.         
  999.         curpath = subdir;
  1000.  
  1001.                 DirIt (sublock, subdir); /* Recurse into this subdirectory */
  1002.  
  1003.                 UnLock ((BPTR)sublock);     /* Unlock our sublock */
  1004.               }
  1005.               myfree (subdir);           /* Free the current namespace */
  1006.             }
  1007.           }
  1008.         }
  1009.       }
  1010.     /* Free up this fib list */
  1011.       FreeAllFibs (fibheadp);
  1012.     }
  1013.   }
  1014. }
  1015.  
  1016. /* -------------------------------------------------------------------- */
  1017. VOID GetCLIArgs (line, argc, argv)
  1018.   BYTE *line;
  1019.   LONG *argc;
  1020.   BYTE **argv;
  1021. {
  1022.   BYTE **pargv, *qarg;
  1023.  
  1024.   *argc = 0;
  1025.   while (*argc < MAXARG)
  1026.   {
  1027.     while (*line == ' ' || *line == '\t' || *line == '\n')
  1028.       line++;
  1029.     if (*line == 0)
  1030.       break;
  1031.     pargv = &argv[*argc];
  1032.     *argc += 1;
  1033.  
  1034.     if (*line == '"')
  1035.     {
  1036.       qarg = line;
  1037.       line += 1;
  1038.       *pargv = line;                 /* ptr inside quoted string */
  1039.       while (*line != 0 && *line != '"')
  1040.         line++;
  1041.       if (*line == 0)                /* Hit end of string without quote! */
  1042.       {
  1043.         *pargv = qarg;               /* Must be okay */
  1044.         break;
  1045.       }
  1046.       else
  1047.         *line++ = 0;                 /* terminate arg ontopof quote */
  1048.     }
  1049.     else                             /* non-quoted arg */
  1050.     {
  1051.       *pargv = line;
  1052.       while (*line != 0 && !(*line == ' ' || *line == '\t' || *line == '\n'))
  1053.         line++;
  1054.       if (*line == 0)
  1055.         break;
  1056.       else
  1057.         *line++ = 0;                 /* terminate arg */
  1058.     }
  1059.   }                                  /* while */
  1060. }
  1061.  
  1062. /* -------------------------------------------------------------------- */
  1063. LONG GetFileDate(name, ptime)
  1064.   char *name;
  1065.   struct DateStamp *ptime;
  1066. {
  1067.   LONG status;
  1068.   struct FileLock *flock;
  1069.   struct FileInfoBlock *fib;
  1070.  
  1071.   status = 0;
  1072.   if ((fib = myalloc ((LONG)sizeof(struct FileInfoBlock))) != 0)
  1073.   {
  1074.     if ((flock = (struct FileLock *)Lock (name, (LONG)ACCESS_READ)) != 0)
  1075.     {
  1076.       if (Examine ((BPTR)flock, fib) != 0)
  1077.       {
  1078.         *ptime = fib->fib_Date;     /* Copy the Date structure */
  1079.         status = 1;
  1080.       }
  1081.       UnLock ((BPTR)flock);
  1082.     }
  1083.     myfree (fib);
  1084.   }
  1085.   return (status);
  1086. }
  1087.  
  1088. /* --------------------------------------------------------------------
  1089.  * Deallocate and close everything
  1090.  * -------------------------------------------------------------------- */
  1091. VOID CleanUp (exit_msg, exit_status, result2)
  1092.   BYTE *exit_msg;
  1093.   LONG exit_status, result2;
  1094. {
  1095.   BYTE workstr[WORKSIZE];
  1096.   struct Process *procp;
  1097.  
  1098. /* Make sure we unlock any locks we created! */
  1099.   if (CurFLock != 0 && (LSFlags & PATHNAMED) != 0)
  1100.     UnLock ((BPTR)CurFLock);
  1101.  
  1102. /* Free our fib */
  1103.   myfree (GFibp);
  1104.  
  1105.   if (*exit_msg != 0)
  1106.   {
  1107.     (VOID) asprintf (workstr, ErrFmtStr, exit_msg, result2);
  1108.     WSTR (workstr);
  1109.   }
  1110.  
  1111. /* Put windowptr back */
  1112.   procp = (struct Process *) FindTask (0L);
  1113.   procp->pr_WindowPtr = OldWindowPtr;
  1114.  
  1115. /* Set return status, exit */
  1116.   procp->pr_Result2 = result2;
  1117.   exit ((int)exit_status);
  1118. }
  1119.  
  1120. /* --------------------------------------------------------------------
  1121.  * Explain how to use.
  1122.  * -------------------------------------------------------------------- */
  1123. VOID Usage ()
  1124. {
  1125.   LONG i;
  1126.  
  1127.   for (i = 0; usagestrs[i] != 0; i++)
  1128.     WSTR (usagestrs[i]);
  1129.   CleanUp (&NLine[1], 20L, 120L);
  1130. }
  1131.  
  1132. /* -------------------------------------------------------------------- */
  1133. LONG ParseCmdOptions (ncnt, argc, argv)
  1134.   LONG ncnt, argc;
  1135.   BYTE **argv;
  1136. {
  1137.   BYTE tmpmsg[4];
  1138.   LONG i, cnt, len;
  1139.   struct Process *procp;
  1140.  
  1141.   cnt = ncnt;      /* Current arg number that contains the options */
  1142.   ncnt += 1;       /* Advance to next arg */
  1143.  
  1144.   for (i = 1, len = strlen (argv[cnt]); i < len; i++)
  1145.   {
  1146.     switch (argv[cnt][i])
  1147.     {
  1148.       case '?':
  1149.       case 'h':
  1150.         Usage ();
  1151.         break;
  1152.       case 'D':
  1153.         LSFlags |= FILESFIRST;
  1154.         break;
  1155.       case 'F':
  1156.         if (argc < (ncnt + 1))     /* Missing required format string */
  1157.           Usage ();
  1158.         thefmtstr = argv[ncnt];    /* Else our format string is the next arg */
  1159.         ncnt += 1;                 /* Bump arg counter */
  1160.         LSFlags |= LONGLIST;
  1161.         break;
  1162.       case 'H':
  1163.         LSFlags |= NOHEADERS;
  1164.         break;
  1165.       case 'I':
  1166.         LSFlags |= NOINTERACT;
  1167.         break;
  1168.       case 'M':
  1169.         LSFlags |= MIXFILESDIRS;
  1170.         break;
  1171.       case 'N':
  1172.         if (argc < (ncnt + 1))     /* Missing required name string */
  1173.           Usage ();
  1174.         else
  1175.         {
  1176.           if (GetFileDate (argv[ncnt], &thenewdate) == 0)
  1177.             NoFileExit (argv[ncnt]);
  1178.           ncnt += 1;                 /* Bump arg counter */
  1179.           LSFlags |= SHOWNEWERTHAN;
  1180.         }
  1181.         break;
  1182.       case 'O':
  1183.         if (argc < (ncnt + 1))     /* Missing required name string */
  1184.         {
  1185.           Usage ();
  1186.         }
  1187.         else
  1188.         {
  1189.           if (GetFileDate (argv[ncnt], &theolddate) == 0)
  1190.             NoFileExit (argv[ncnt]);
  1191.           ncnt += 1;                 /* Bump arg counter */
  1192.           LSFlags |= SHOWOLDERTHAN;
  1193.         }
  1194.         break;
  1195.       case 'P':
  1196.         LSFlags |= (FULLPATHNAMES | LONGLIST);
  1197.         break;
  1198.       case 'R':
  1199.         LSFlags |= LISTALL;
  1200.         break;
  1201.       case 'T':
  1202.         LSFlags |= TOTALIZE;
  1203.         break;
  1204.       case 'X':
  1205.         if (argc < (ncnt + 1))     /* Missing required width number */
  1206.         {
  1207.           Usage ();
  1208.         }
  1209.         else
  1210.         {
  1211.           (VOID) GetDecNum (argv[ncnt], &CurWinCols);
  1212.           ncnt += 1;                 /* Bump arg counter */
  1213.         }
  1214.         break;
  1215.       case 'Y':
  1216.         if (argc < (ncnt + 1))     /* Missing required height number */
  1217.         {
  1218.           Usage ();
  1219.         }
  1220.         else
  1221.         {
  1222.           (VOID) GetDecNum (argv[ncnt], &CurWinRows);
  1223.           ncnt += 1;                 /* Bump arg counter */
  1224.         }
  1225.         break;
  1226.       case 'c':
  1227.         LSFlags |= LONGLIST | NOTEFLAG;
  1228.         break;
  1229.       case 'd':
  1230.         LSFlags &= ~SHOWFILES;
  1231.         break;
  1232.       case 'f':
  1233.         LSFlags &= ~SHOWDIRS;
  1234.         break;
  1235.       case 'k':
  1236.         LSFlags &= ~CONSOLE;
  1237.         break;
  1238.       case 'l':
  1239.         LSFlags |= LONGLIST;
  1240.         break;
  1241.       case 'n':
  1242.         LSFlags |= NOSORTFLAG;
  1243.         break;
  1244.       case 'p':
  1245.         procp = (struct Process *) FindTask (0L);
  1246.         procp->pr_WindowPtr = OldWindowPtr;
  1247.         break;
  1248.       case 'r':
  1249.         LSFlags |= REVFLAG;
  1250.         break;
  1251.       case 's':
  1252.         sortkey = 1;
  1253.         break;
  1254.       case 't':
  1255.         sortkey = 2;
  1256.         break;
  1257.       case 'v':
  1258.         if (argc < (ncnt + 1))         /* Missing required pattern string */
  1259.           Usage ();
  1260.         theAntiPat = argv[ncnt];    /* Point to pattern area */
  1261.         ncnt += 1;            /* Skip over arg */
  1262.         LSFlags |= ANTIMATCH;        /* Set flag to use antipat */
  1263.         break;
  1264.       default:
  1265.         tmpmsg[0] = argv[cnt][i];
  1266.         tmpmsg[1] = 0;
  1267.         (VOID) asprintf (workstr, BadOptFmtStr, tmpmsg);
  1268.         WSTR (workstr);
  1269.         Usage ();
  1270.         break;
  1271.     }
  1272.   }
  1273.   return(ncnt);
  1274. }
  1275.  
  1276. /* -------------------------------------------------------------------- */
  1277. VOID _main (line)
  1278.   BYTE *line;
  1279. {
  1280.   BYTE *argv[MAXARG];             /* arg pointers */
  1281.   LONG argc;                      /* arg count */
  1282.   LONG cnt;
  1283.   struct Process *procp;
  1284.  
  1285. /* Prevent system request from occuring by default */
  1286.   procp = (struct Process *) FindTask (0L);
  1287.   OldWindowPtr = procp->pr_WindowPtr;
  1288.   procp->pr_WindowPtr = (APTR)-1L;
  1289.   
  1290. /* Construct list of args */
  1291.   GetCLIArgs (line, &argc, argv);
  1292.  
  1293. /* Grab FileHandles for input and output to console (or redirection file) */
  1294.   ConIn = (struct FileHandle *)Input ();
  1295.   ConOut = (struct FileHandle *)Output ();
  1296.  
  1297. /* Is this a CLI? Set a flag */
  1298.   if (IsInteractive ((BPTR)ConOut) != 0 && IsInteractive ((BPTR)ConIn) != 0)
  1299.     LSFlags |= CONSOLE;
  1300.  
  1301. /* Allocate a global FileInfoBlock for ExNext() */
  1302.   if ((GFibp = myalloc ((LONG) sizeof (struct FileInfoBlock))) == 0)
  1303.     NoMemExit ();
  1304.  
  1305. /* Initialize arg count, zero grand totals */
  1306.   cnt = 1;
  1307.   gtotblocks = gtotbytes = gdircount = gfilecount = 0;
  1308.  
  1309. /* Parse command line arguments, if any */
  1310.   do
  1311.   {
  1312.     if (cnt < argc && argv[cnt][0] == '-')
  1313.     {
  1314.     /* Reset for next arg */ 
  1315.       LSFlags &= CONSOLE;
  1316.       LSFlags |= SHOWDIRS | SHOWFILES;
  1317.       thefmtstr = deffmtstr;
  1318.  
  1319.       do
  1320.       {
  1321.         cnt = ParseCmdOptions(cnt, argc, argv);
  1322.       } while (cnt < argc && argv[cnt][0] == '-');
  1323.     }
  1324.  
  1325.   /* Is there an named path arg to do? */
  1326.     if (cnt < argc)
  1327.     {
  1328.       LSFlags |= PATHNAMED;                  /* Flag that we have a name */
  1329.       theFilePat[0] = 0;                     /* Terminate pattern strings */
  1330.       theDirPat[0] = 0;
  1331.       (VOID) stpcpy (thePath, argv[cnt]);    /* Copy this arg to work space */
  1332.       cnt++;                                 /* Advance arg counter */
  1333.  
  1334.     /* Wild pathname? Separate into components until we find a non-wild path */
  1335.       if (iswild (thePath) != 0)
  1336.       {
  1337.         (VOID) GetFileString (theFilePat, thePath);
  1338.         (VOID) stpcpy (theDirPat, theFilePat);
  1339.         (VOID) GetPathString (thePath, thePath);
  1340.  
  1341.       /* Still wild?  First part must be wild filename to match */
  1342.         if (iswild (thePath) != 0)
  1343.         {
  1344.           (VOID) GetFileString (theDirPat, thePath);
  1345.           (VOID) GetPathString (thePath, thePath);
  1346.         }
  1347.       }
  1348. #ifdef DEBUGIT
  1349.       asprintf(workstr, "path: %s\n", thePath); WSTR (workstr);
  1350.       asprintf(workstr, " dir: %s\n", theDirPat); WSTR (workstr);
  1351.       asprintf(workstr, "file: %s\n", theFilePat); WSTR (workstr);
  1352. #endif
  1353.  
  1354.     /* No wildcards allowed in the final pathname! */
  1355.       if (iswild (thePath) != 0)
  1356.         CleanUp (NoWildPathMsg, 20L, 120L);
  1357.  
  1358.     /* Now try to lock the dir (or file) */
  1359.       if ((CurFLock = (struct FileLock *)Lock (thePath, (LONG)ACCESS_READ)) == 0)
  1360.       {
  1361.         NoFileExit (thePath);
  1362.       }
  1363.     }
  1364.     else
  1365.     {
  1366.     /*
  1367.      * If no filename was specified, steal Lock on current directory from
  1368.      * CLI process task info.  We durn well better get something useful back;
  1369.      * since we don't do any error checking on the "borrowed" Lock.
  1370.      */
  1371.       CurFLock = (struct FileLock *)procp->pr_CurrentDir;
  1372.     }
  1373.  
  1374.   /* Make a full pathname string from given CurFLock if no colon in path */
  1375.     if (aindex(thePath, ':') == 0)
  1376.       MakePathString (CurFLock, thePath);
  1377.     curpath = thePath;
  1378.  
  1379. #ifdef DEBUGIT
  1380.     asprintf(workstr, "Final path: %s\n", thePath); WSTR (workstr);
  1381. #endif
  1382.  
  1383.   /* If there isn't a dir pattern or file pattern specified, match everything */
  1384.     if (theDirPat[0] == 0)
  1385.     {
  1386.       theDirPat[0] = '*';               /* "*" default matchall dir pattern */
  1387.       theDirPat[1] = 0;                 /* Null terminate string */
  1388.     }
  1389.  
  1390.     if (theFilePat[0] == 0)
  1391.     {
  1392.       theFilePat[0] = '*';
  1393.       theFilePat[1] = 0;
  1394.     }
  1395.  
  1396.   /* Get the directory for this path, display it */
  1397.     DirIt (CurFLock, thePath);
  1398.  
  1399.   /* Release the lock if we locked it */
  1400.     if (CurFLock != 0 && (LSFlags & PATHNAMED) != 0)
  1401.     {
  1402.       UnLock ((BPTR)CurFLock);
  1403.     }
  1404.     CurFLock = 0;
  1405.  
  1406.   /* Still more args? Put a linefeed between listing outputs
  1407.     if (cnt < argc && (LSFlags & NOHEADERS) == 0)
  1408.       WCHR (NLine);
  1409.    */
  1410.     TestBreak();
  1411.     if ((LSFlags & TOTALIZE) != 0)
  1412.     {
  1413.       SetConPen (penstr4);
  1414.       WSTR (TotHeaderMsg);
  1415.       SetConPen (penstr5);
  1416.       (VOID) asprintf (workstr, totalfmtstr, gdircount, gfilecount, gtotblocks, gtotbytes);
  1417.       WSTR (workstr);
  1418.       SetConPen (penstr0);
  1419.     }
  1420.   } while (cnt < argc && (LSFlags & BREAKFLAG) == 0);
  1421.  
  1422. /* All done! Clean exit */
  1423.   CleanUp (&NLine[1], 0L, 0L);
  1424. }
  1425.