home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 182.lha / Ls_v2.1 / ls.c < prev    next >
Encoding:
C/C++ Source or Header  |  1988-04-28  |  24.5 KB  |  919 lines
  1. /* --------------------------------------------------------------------- *
  2.   LS.C -- an "improved" directory listing utility to replace the
  3.   AmigaDOS DIR and LIST commands.
  4.  
  5.   V1.0   August 1986 Written from scratch by Justin V. McCormick.
  6.   V2.0 November 1988 Revised for Lattice 5.0 and made 1.3 compatible.
  7.   V2.1 December 1988 Minor size reduction, fixed a few bugs from 2.0.
  8.  
  9. Notice:
  10.  
  11.   This program is placed in the public domain with the understanding
  12. that the author makes no claims or guarantees with regard to its
  13. suitability for any given application, and that the author assumes no
  14. responsibility for damages incurred by its usage.  Any resemblance
  15. of this program to any other program, either living or dead, is
  16. purely coincidental.
  17.  
  18.   Feel free to borrow this code and make millions of dollars from its
  19. sale or commercial use, but please give credit where credit is due.
  20.  
  21. Synopsis:
  22.  
  23.   Features adaptive columnar listing, versatile sort options,
  24. UNIX-style pattern matching, recursive subdirectory listing, etc!
  25.  
  26. Usage:
  27.     ls [options] [path1] [path2] ...
  28.  
  29. Options:
  30.     -?    Help!
  31.     -c    Show file comment info, -c implies -l
  32.     -d    Show directory names only
  33.     -f    Show filenames only
  34.     -l      Long verbose listing showing filesizes and dates
  35.     -n    No sort, just spit them out in the order ExNext() returns
  36.     -r    Reverse sort direction
  37.     -s    Sorted by size smallest to largest
  38.     -t    Sorted by date oldest to newest
  39.     -R    Recursive descent of subdirectories
  40.  
  41.   All arguments are optional.  Default is to give short columnar listing,
  42. sorted alphabetically, using the current directory.  Alphabetizing is case
  43. insensitive.
  44.  
  45.   Patterns may be matched in the given names, using the UNIX-style '*'
  46. to wildcard any number of characters, and '?' to wildcard a single
  47. character.  If you need to specify a pathname with spaces in it like
  48. "Wombat Soup", you need to put quotes around it.  LS can process up to 30
  49. separate pathname patterns in one command line.
  50.  
  51. Bugs:
  52.  
  53.   Redirecting the shortlist output to PRT: gives undesirable results,
  54. since I am using relative cursor positioning commands to format the
  55. screen output.  I thought about using an array to store a virtual
  56. screen, but my primary goals were to keep the size down and display
  57. speed at a maxiumum.  Also, LS cannot pattern match devices (like "dh*:")
  58. or support multiple levels of pattern matching (like "dh0:?/L*.info").
  59. This would involve another level of recursion and groking the Device List.
  60.  
  61. Changes From 1.0 to 2.0:
  62.  
  63.  o Source code prototyped, linted, traced, optimized, tweaked, etc.
  64.  o Made resident ("pseudo-pure") by linking with cres.o from LC 5.0.
  65.  o High-volume routines recoded in assembly (lssup.a).
  66.  o Now handles multiple paths/files on a command line, up to 30.
  67.  o New sort flags, including no sort.
  68.  o Enhanced wildcards, understands complex *.?*.* expressions now.
  69.  o More efficient ExNext() performance, less ram used for recursion.
  70.  o SIGBREAKF_CTRL_C signal (Ctrl-C) cleanly aborts at any point now.
  71.  o Command line parser handles quoted pathnames now (LC 5.0 benefit).
  72.  o Short listing finally auto-adjusts to new console window sizes!
  73.  o Pen color escape codes bypassed when redirecting long output.
  74.  o Sorting by size or date is also subsorted alphabetically now.
  75.  o Long listing shows new 1.3 file attributes, plus comment indicator.
  76.  o File dates are now in international format, YY-MM-DD.
  77.  o Fixed listings with files datestamped after 99-12-31 (overflow).
  78.  o Fixed listings with files datestamped before 78-01-01 (time < 0).
  79.  
  80. Changes From 2.0 to 2.1
  81.  
  82.  o Fixed the show comment feature, a last minute bug in 2.0.
  83.  o Fixed the "Unknown option ''" message problem.
  84.  o Optimized the assembly branches, reduced code size another few bytes.
  85.  
  86. * --------------------------------------------------------------------- */
  87.  
  88. /* Don't use __builtin for a minor savings in size */
  89. #define strlen strlen
  90.  
  91. /* Pass things using registers */
  92. #define _PARM __regargs
  93.  
  94. #include "ls.h"
  95.  
  96. /* Structure used to hold file info in a linked list */
  97. struct FibEntry
  98. {
  99.   struct FibEntry *NextFib;
  100.   struct FibEntry *LastFib;
  101.   struct FileInfoBlock *Fibp;
  102. };
  103.  
  104. /* Externs from lssup.a */
  105. /*lint +fva2 */
  106. extern int  __stdargs asprintf (char *, char *,...);
  107. /*lint -fva2 */
  108.  
  109. extern void __stdargs SortFibs (long, long, struct FibEntry *);
  110. extern long __stdargs iswild (char *);
  111. extern long __stdargs wildmatch (char *, char *);
  112. extern char *__stdargs FibFileDate (struct DateStamp *);
  113. extern void __stdargs GetWinBounds (long *, long *);
  114.  
  115.  
  116. /* Local CODE */
  117. struct FibEntry *GetDir (struct FileLock *, struct FileInfoBlock *);
  118. struct FibEntry *AllocFib (void);
  119. void CleanUp (char *, long);
  120. void ColorPen2 (void);
  121. void CursorOff (void);
  122. void CursorOn (void);
  123. void _PARM DirIt (struct FileLock *, char *);
  124. void _PARM FreeAllFibs (struct FibEntry *);
  125. void _PARM FreeFib (struct FibEntry *);
  126. void _PARM LListDir (struct FibEntry *);
  127. void _PARM LListEntry (struct FileInfoBlock *);
  128. void _PARM LongList (long *, long *, struct FibEntry *);
  129. void main (int, char **);
  130. void _PARM PagePrompt (long);
  131. void ResetPen (void);
  132. void _PARM SListDir (struct FibEntry *);
  133. void TestBreak (void);
  134. void Usage (void);
  135. void _PARM WCHR (char *);
  136. void _PARM WSTR (char *);
  137.  
  138. struct FileHandle *Out = 0L;
  139. struct FileHandle *In = 0L;
  140. struct FileLock *lockp = 0L;
  141. struct FileInfoBlock *GFibp = 0L;
  142.  
  143. long BREAKFLAG = 0;
  144. long CONSOLE = 0;
  145. long dircount = 0;
  146. long DIRFILEFLAG = 0;
  147. long errstat = 0;
  148. long filecount = 0;
  149. long LISTALL = 0;
  150. long LONGLIST = 0;
  151. long maxnamlen = 0;
  152. long NOSORTFLAG = 0;
  153. long NOTEFLAG = 0;
  154. long PATHNAMED = 0;
  155. long REVFLAG = 0;
  156. long sortkey = 0;
  157. long WILDCARD = 0;
  158. long CurWinRows = 20L;
  159. long CurWinCols = 77L;
  160.  
  161. char filename[160];
  162. char pattern[160];
  163. char workstr[160];
  164.  
  165. static char Author[] = "\23333mLS 2.1\2330m by Justin V. McCormick 1988";
  166. static char usage[] = "\nUsage: ls [-cdflnrstR] [path1] [path2] ...\n";
  167.  
  168. /* -------------------------------------------------------------------- */
  169. void main (argc, argv)
  170.   int argc;
  171.   char **argv;
  172. {
  173.   struct Process *procp;
  174.   long cnt, i;
  175.  
  176.   if (argc == 0)            /* son of Workbench -- no go! */
  177.     exit (0);
  178.  
  179. /* Grab FileHandles for input and output to console (or redirection file) */
  180.   In = Input ();
  181.   Out = Output ();
  182.   CONSOLE = (IsInteractive (Out) == 0L) ? 0L : 1L; /* Is this console output? */
  183.  
  184. /* Allocate a global FileInfoBlock for ExNext() */
  185.   if ( (GFibp = (struct FileInfoBlock *)AllocMem((long)sizeof(struct FileInfoBlock), MEMF_PUBLIC | MEMF_CLEAR)) == 0L)
  186.     CleanUp("No RAM?", 103L);
  187.  
  188. /* Parse command line arguments <ugh> */
  189.   cnt = 1;
  190.   if (argc >= 2)
  191.   {
  192.     if (argv[1][0] == '-')
  193.     {
  194.       cnt++;
  195.       for (i = strlen(argv[1]) - 1; i > 0; i--)
  196.       {
  197.         switch (argv[1][i])
  198.         {
  199.       case 'c': 
  200.         LONGLIST = 1;
  201.         NOTEFLAG = 1;
  202.         break;
  203.           case 'd':
  204.             DIRFILEFLAG |= 1;
  205.             break;
  206.           case 'f':
  207.             DIRFILEFLAG |= 2;
  208.             break;
  209.       case 'l': 
  210.         LONGLIST = 1;
  211.         break;
  212.       case 'n':
  213.         NOSORTFLAG = 1;
  214.         break;
  215.       case 'r':
  216.         REVFLAG = 1;
  217.         break;
  218.       case 's':
  219.         sortkey = 1;
  220.         break;
  221.       case 't': 
  222.         sortkey = 2;
  223.         break;
  224.       case 'R': 
  225.         LISTALL = 1;
  226.         break;
  227.       case '?': 
  228.         Usage ();
  229.         break;
  230.       default:
  231.         pattern[0] = argv[1][i];
  232.         pattern[1] = 0;
  233.         (void) asprintf (workstr, "Unknown option \'%s\'\n", pattern);
  234.         WSTR (workstr);
  235.         Usage ();
  236.         break;
  237.     }
  238.       }
  239.     }
  240.   }
  241.  
  242. /* Clean up the state flags */
  243.   if ( (argc - cnt) > 1)
  244.     LISTALL |= 2;
  245.  
  246.   if (DIRFILEFLAG == 0)
  247.     DIRFILEFLAG = 3;
  248.  
  249. /* Loop through the remaining args now */
  250.   do
  251.   {
  252.     PATHNAMED = 0;
  253.     if (cnt < argc)
  254.     {
  255.       (void) stpcpy (pattern, argv[cnt]);
  256.       PATHNAMED = 1;
  257.     }
  258.  
  259.     if (PATHNAMED)            /* If user specified a pathname    */
  260.     {
  261.       WILDCARD = iswild (pattern);     /* check for wildcards         */
  262.  
  263.       if (WILDCARD)            /* If wildcards, separate    */
  264.       {                    /* pattern from pathname    */
  265.         for (i = (strlen (pattern) - 1); i >= 0; i--)
  266.         {
  267.           if (pattern[i] == '/' || pattern[i] == ':')
  268.           {
  269.         (void) strncpy (filename, pattern, (UWORD) (i + 1));
  270.         filename[i + 2] = (BYTE) 0;
  271.         (void) stpcpy (workstr, &pattern[i + 1]);
  272.         (void) stpcpy (pattern, workstr);
  273.         break;
  274.           }
  275.         }
  276. /* Disallow wildcards in pathname */
  277.         if (iswild (filename))
  278.           CleanUp ("Sorry, can't pattern match paths", 5L);
  279.       }
  280.       else                /* No wildcards, use filename as is */
  281.       {
  282.         (void) stpcpy (filename, pattern);
  283.       }
  284.  
  285. /* If the user specified a pathname, try to grab a FileLock on it */
  286. /* Discard trailing slash if silly Joe User put one there */
  287.       if (filename[1] != 0 && filename[strlen (filename) - 1] == '/')
  288.         filename[strlen (filename) - 1] = (BYTE) 0;
  289.  
  290.       lockp = Lock (filename, ACCESS_READ);
  291.  
  292.       if (!lockp)            /* Can't Lock it!         */
  293.       {
  294.         errstat = IoErr ();
  295.         (void) strcat (filename, " not found");
  296.         CleanUp (filename, (long)errstat);
  297.       }
  298.     }
  299.     else
  300.     {
  301. /*
  302.  * If no filename was specified, steal Lock on current directory from
  303.  * CLI process task info.  We durn well better get something useful back;
  304.  * we don't do any error checking on the stolen Lock.
  305.  */
  306.       procp = (struct Process *) FindTask (0L);
  307.       lockp = (struct FileLock *)procp->pr_CurrentDir;
  308.       filename[0] = 0;            /* Tell DirIt() to use current dir */
  309.     }
  310.  
  311. /* Get the directory for this path, display it */
  312.     DirIt (lockp, filename);
  313.  
  314. /* Release the lock, bump our arg counter */
  315.     if (lockp != 0 && PATHNAMED != 0)
  316.       UnLock (lockp);
  317.     lockp = 0L;
  318.     cnt++;
  319.  
  320.     if (cnt < argc)
  321.       WCHR("\n");
  322.   } while (cnt < argc && BREAKFLAG == 0);
  323.  
  324.   CleanUp ("", 0L);
  325. }
  326.  
  327. /* -------------------------------------------------------------------- */
  328. /* Deallocate and close everything                     */
  329. /* -------------------------------------------------------------------- */
  330. void CleanUp (exit_msg, exit_status)
  331.   char *exit_msg;
  332.   long exit_status;
  333. {
  334.   if (lockp && PATHNAMED)
  335.     UnLock (lockp);
  336.  
  337.   if (GFibp != 0L)
  338.     FreeMem(GFibp, (long)sizeof(struct FileInfoBlock));
  339.  
  340.   if (exit_status)
  341.   {
  342.     (void) asprintf (workstr, "ls: %s, Error #%ld\n", exit_msg, exit_status);
  343.     WSTR (workstr);
  344.   }
  345.   exit ((int) exit_status);
  346. }
  347.  
  348. /* -------------------------------------------------------------------- */
  349. void _PARM DirIt (lockp, dirname)
  350.   struct FileLock *lockp;
  351.   char *dirname;
  352. {
  353.   struct FileLock *tlockp;
  354.   struct FibEntry *fibheadp;
  355.   struct FibEntry *tfibp;
  356.   char *subdir;
  357.   long strsize;
  358.  
  359. /* Try to fill FileInfoBlock, bomb if not readable for some reason */
  360.   if (!Examine (lockp, GFibp))
  361.   {
  362.     (void) asprintf (workstr, "Can't examine file or directory\n");
  363.     WSTR (workstr);
  364.     return;
  365.   }
  366.  
  367. /* Put directory header if this is a recursive listing */
  368.   if (dirname[0] && LISTALL > 0)
  369.   {
  370.     if (CONSOLE != 0)
  371.      (void)asprintf(workstr, "\23330;41m %s \2330m\n", dirname);
  372.     else
  373.      (void)asprintf(workstr, "%s\n", dirname);
  374.     WSTR(workstr);
  375.   }
  376.  
  377. /* If this is a single file list it verbosely */
  378.   if (GFibp->fib_EntryType < 0 && (DIRFILEFLAG & 2) != 0)
  379.   {
  380.     LListEntry (GFibp);
  381.   }
  382.   else
  383.   {
  384. /* Otherwise do a directory     */
  385. /* Allocate and initialize a FibEntry head node */
  386.     if ( (fibheadp = GetDir (lockp, GFibp)) != 0L && BREAKFLAG == 0)
  387.     {
  388.       if (NOSORTFLAG == 0)
  389.         SortFibs ((long)sortkey, REVFLAG, fibheadp);
  390.  
  391.       if (LONGLIST == 0)
  392.     SListDir (fibheadp);
  393.       else
  394.     LListDir (fibheadp);
  395.  
  396.       if ( (LISTALL & 1) != 0)
  397.       {
  398.         tfibp = fibheadp;
  399.     do
  400.     {
  401.       if (tfibp->Fibp->fib_EntryType > 0)
  402.       {
  403.         strsize = (strlen (dirname) + strlen (tfibp->Fibp->fib_FileName) + 2);
  404.         subdir = (char *) AllocMem ((LONG)strsize, 0L);
  405.         if (strlen (dirname) != 0)
  406.         {
  407.           (void) stpcpy (subdir, dirname);
  408.           if (dirname[strlen (dirname) - 1] != ':')
  409.         (void) strcat (subdir, "/");
  410.         }
  411.         (void) strcat (subdir, tfibp->Fibp->fib_FileName);
  412.         tlockp = Lock (subdir, ACCESS_READ);
  413.         if (tlockp == 0L)
  414.         {
  415.           WSTR (subdir);
  416.           WSTR (" -- can't lock it!\n");
  417.           break;
  418.         }
  419.         else
  420.         {
  421.           WCHR ("\n");        /* Put a blank line between directories */
  422.           DirIt (tlockp, subdir);
  423.           UnLock (tlockp);
  424.           FreeMem (subdir, (LONG)strsize);
  425.         }
  426.       }
  427.       tfibp = tfibp->NextFib;
  428.     } while (tfibp != fibheadp && BREAKFLAG == 0);
  429.       }
  430.     }
  431. /* Clean up */
  432.     FreeAllFibs (fibheadp);
  433.   }
  434. }
  435.  
  436. /* -------------------------------------------------------------------- */
  437. /* Allocate and fill a linked list of FileInfoBlocks             */
  438. /* -------------------------------------------------------------------- */
  439. struct FibEntry *GetDir (lockp, fibp)
  440.   struct FileLock *lockp;
  441.   struct FileInfoBlock *fibp;
  442. {
  443.   long nextstat;
  444.   long tempnamlen;
  445.   struct FibEntry *tfibp;
  446.   struct FibEntry *headfib;
  447.  
  448.   maxnamlen = dircount = filecount = 0L;
  449.   headfib = 0L;
  450.  
  451.   do
  452.   {
  453.     TestBreak();
  454.     if (BREAKFLAG != 0)
  455.       return(headfib);
  456.     nextstat = ExNext (lockp, fibp);
  457.  
  458.     if (nextstat != 0)    /* We got something */
  459.     {
  460. /* See if it matches our pattern */
  461.       if (!WILDCARD || wildmatch (fibp->fib_FileName, pattern))
  462.       {
  463.  
  464. /* Bump count of files or directories */
  465.     if (fibp->fib_EntryType > 0)
  466.         {
  467.           if ((DIRFILEFLAG & 1) != 0)
  468.             dircount++;
  469.           else
  470.             goto ALLOCFIB;
  471.         }
  472.         else
  473.         {
  474.           if ((DIRFILEFLAG & 2) != 0)
  475.             filecount++;
  476.           else
  477.             continue;
  478.         }
  479.  
  480. /* See if this is the longest filename for later use in listing */
  481.     tempnamlen = strlen (fibp->fib_FileName);
  482.     if (tempnamlen > maxnamlen)
  483.       maxnamlen = tempnamlen;
  484.  
  485.         ALLOCFIB:
  486. /* Allocate another FibEntry to put the info in */
  487.         if (headfib == 0L)
  488.         {
  489.           headfib = AllocFib();
  490.           if (headfib == 0L)
  491.             return(headfib);
  492.           headfib->NextFib = headfib;
  493.           headfib->LastFib = headfib;
  494.           *(headfib->Fibp) = *(fibp);
  495.           tfibp = headfib;
  496.         }
  497.         else
  498.         {
  499.       tfibp->NextFib = AllocFib ();
  500.       if (tfibp->NextFib == 0L)
  501.         return(0L);
  502.  
  503. /* Copy FIB contents to next entry for ExNext to work with */
  504.       *(tfibp->NextFib->Fibp) = *(fibp);
  505.  
  506. /* Link it into the list */
  507.       tfibp->NextFib->LastFib = tfibp;
  508.       tfibp = tfibp->NextFib;
  509.       tfibp->NextFib = headfib;
  510.     }
  511.       }
  512.     }
  513.   } while (nextstat);
  514.  
  515. /* Return TRUE if entries found, else print message and return FALSE */
  516.   if ( (dircount + filecount) != 0)
  517.   {
  518.     return (headfib);
  519.   }
  520.   else
  521.   {
  522.     if (WILDCARD == 0 && DIRFILEFLAG == 3)
  523.       WSTR ("Volume or directory is empty.\n");
  524.     else
  525.       WSTR ("No match.\n");
  526.     return (0L);
  527.   }
  528. }
  529.  
  530. /* -------------------------------------------------------------------- */
  531. /* List a FibEntry list in a compact fashion                 */
  532. /* -------------------------------------------------------------------- */
  533. void _PARM SListDir (fibheadp)
  534.   struct FibEntry *fibheadp;
  535. {
  536.   struct FibEntry *tfibp;
  537.   long tabsize;
  538.   long maxtab;
  539.   long totrows;
  540.   long maxwinrow;
  541.   long colcnt;
  542.   long rowcnt;
  543.   long tabcnt;
  544.   long pagecnt = 1;
  545.  
  546.   CursorOff ();        /* Turn the cursor off since it will blink anyway */
  547.   GetWinBounds(&CurWinCols, &CurWinRows);
  548.  
  549.   tfibp = fibheadp;
  550.   tabcnt = rowcnt = colcnt = 0;
  551.  
  552.   tabsize = maxnamlen + 2;
  553.   if (CurWinCols < tabsize)
  554.     maxtab = 1;
  555.   else
  556.     maxtab = CurWinCols / tabsize;
  557.   maxwinrow = CurWinRows - 3;
  558.   if (maxwinrow <= 0)
  559.     maxwinrow = 1;
  560.   totrows = (dircount + filecount) / maxtab;
  561.   if ((dircount + filecount) % maxtab != 0)
  562.     totrows++;
  563.  
  564.   do
  565.   {
  566.     if (tfibp->Fibp->fib_EntryType > 0)
  567.     {
  568.       if ( (DIRFILEFLAG & 1) == 0)
  569.         goto GETNEXTFIB;
  570.       else
  571.         ColorPen2 ();
  572.     }
  573.     if (tabcnt)
  574.       (void) asprintf (workstr, "\233%ldC", (long)tabcnt);
  575.     else
  576.       workstr[0] = (BYTE) 0;
  577.     (void) strcat (workstr, tfibp->Fibp->fib_FileName);
  578.     (void) strcat (workstr, "\n");
  579.     WSTR (workstr);
  580.     if (tfibp->Fibp->fib_EntryType > 0)
  581.       ResetPen ();
  582.     rowcnt++;
  583.  
  584.     if (rowcnt == maxwinrow || rowcnt == totrows)
  585.     {
  586.       colcnt++;                /* Start a new column         */
  587. /* Check to see if we have used the last column up and are about to run
  588.  * off the screen entirely.  If so, give the user a chance to read it first.
  589.  */
  590.       if (colcnt == maxtab && rowcnt == maxwinrow && CONSOLE != 0)
  591.       {
  592.         if (maxwinrow > 1)
  593.         {
  594.          ++pagecnt;            /* Advance page number count    */
  595.      PagePrompt (pagecnt);        /* Print it, wait for user    */
  596.     }
  597.     totrows -= maxwinrow;
  598.     colcnt = tabcnt = rowcnt = 0L;
  599.       }
  600.       else    /* Just move over one row and back up to the top */
  601.       {
  602.     (void) asprintf (workstr, "\233%ldA", (long)rowcnt);
  603.     WSTR (workstr);
  604.     tabcnt += tabsize;
  605.     rowcnt = 0L;
  606.       }
  607.     }
  608.     GETNEXTFIB:
  609.     tfibp = tfibp->NextFib;
  610.   } while (tfibp != fibheadp);
  611.  
  612.   if (totrows - rowcnt > 0)        /* Cursor down till level with     */
  613.   {                    /* lowest line on screen     */
  614.     (void) asprintf (workstr, "\233%ldE", (long)(totrows - rowcnt));
  615.     WSTR (workstr);
  616.   }
  617.   CursorOn ();
  618. }
  619.  
  620. /* -------------------------------------------------------------------- */
  621. /* Reset character color to default Pen1 colors             */
  622. /* -------------------------------------------------------------------- */
  623. void ResetPen ()
  624. {
  625.   if (CONSOLE != 0)
  626.     WSTR ("\2330m");
  627. }
  628.  
  629. /* -------------------------------------------------------------------- */
  630. /* Turn the cursor on                            */
  631. /* -------------------------------------------------------------------- */
  632. void CursorOn ()
  633. {
  634.   if (CONSOLE != 0)
  635.     WSTR ("\233 p");
  636. }
  637.  
  638. /* -------------------------------------------------------------------- */
  639. /* Turn the cursor off for faster text output                 */
  640. /* -------------------------------------------------------------------- */
  641. void CursorOff ()
  642. {
  643.   if (CONSOLE != 0)
  644.     WSTR ("\2330 p");
  645. }
  646.  
  647. /* -------------------------------------------------------------------- */
  648. /* Make Pen2 <usually yellow/orange> the current charcter color     */
  649. /* -------------------------------------------------------------------- */
  650. void ColorPen2 ()
  651. {
  652.   if (CONSOLE != 0)
  653.     WSTR ("\23333m");
  654. }
  655.  
  656. /* -------------------------------------------------------------------- */
  657. /* Prompt the user to hit return, wait till return is hit         */
  658. /* -------------------------------------------------------------------- */
  659. void _PARM PagePrompt (page)
  660.   long page;
  661. {
  662.   WSTR ("\2337m -- MORE -- Press Return: \2330m");
  663.   (void) Read (In, workstr, 1L);
  664.   (void) asprintf (workstr, "\233F\233K\2334;33mPage %ld:\2330m\n", (long)page);
  665.   WSTR (workstr);
  666. }
  667.  
  668. /* -------------------------------------------------------------------- */
  669. /* List a directory in a verbose informative manner             */
  670. /* -------------------------------------------------------------------- */
  671. void _PARM LListDir (fibheadp)
  672.   struct FibEntry *fibheadp;
  673. {
  674.   long totblocks = 0L;
  675.   long totbytes = 0L;
  676.  
  677.   CursorOff ();
  678.   LongList (&totblocks, &totbytes, fibheadp);
  679.  
  680.   (void) asprintf (workstr, "Dirs:%-3ld Files:%-4ld Blocks:%-5ld Bytes:%-8ld\n",
  681.       (long)dircount, (long)filecount, totblocks, totbytes);
  682.   WSTR (workstr);
  683.   CursorOn ();
  684. }
  685.  
  686. /* -------------------------------------------------------------------- */
  687. void _PARM LongList (totblocks, totbytes, fibheadp)
  688.   long *totblocks, *totbytes;
  689.   struct FibEntry *fibheadp;
  690. {
  691.   struct FibEntry *tfibp;
  692.  
  693.   tfibp = fibheadp;
  694.   do
  695.   {
  696.     LListEntry (tfibp->Fibp);
  697.     if (tfibp->Fibp->fib_EntryType < 0)
  698.     {
  699.       *totblocks += tfibp->Fibp->fib_NumBlocks;
  700.       *totbytes += tfibp->Fibp->fib_Size;
  701.     }
  702.     tfibp = tfibp->NextFib;
  703.   } while (tfibp != fibheadp);
  704. }
  705.  
  706. /* -------------------------------------------------------------------- */
  707. /* Verbosely list a particular FibEntry                 */
  708. /* -------------------------------------------------------------------- */
  709. void _PARM LListEntry (fib)
  710.   struct FileInfoBlock *fib;
  711. {
  712.   long i, pmodes;
  713.   char *cp1;
  714.   char entry[160];
  715.  
  716.   pmodes = fib->fib_Protection & 0xff;
  717.   cp1 = stpcpy (entry, "chsparwed ");
  718.   for (i = 0; i < 4; i++)
  719.   {
  720.     if ((pmodes & (1 << i)) != 0)
  721.       entry[8 - i] = '-';
  722.   }
  723.   for (; i < 8; i++)
  724.   {
  725.     if ((pmodes & (1 << i)) == 0)
  726.       entry[8 - i] = '-';
  727.   }
  728.   if (fib->fib_Comment[0] == 0)
  729.     entry[0] = '-';
  730.  
  731.   cp1 = stpcpy (cp1, FibFileDate (&fib->fib_Date));
  732.   if (fib->fib_EntryType > 0)
  733.   {
  734.     if ( (DIRFILEFLAG & 1) == 0)
  735.       return;
  736.  
  737.     if (CONSOLE)
  738.       cp1 = stpcpy (cp1, "\23333m");
  739.     cp1 = stpcpy (cp1, "   Directory   ");
  740.     if (CONSOLE)
  741.       cp1 = strcat (cp1, "\2330m");
  742.   }
  743.   else
  744.     (void) asprintf (&entry[27], " %4ld %8ld ", fib->fib_NumBlocks, fib->fib_Size);
  745.   (void)strcat(entry, fib->fib_FileName);
  746.   (void)strcat(cp1, "\n");
  747.   WSTR (entry);
  748.  
  749.   if (NOTEFLAG != 0 && fib->fib_Comment[0] != 0)
  750.   {
  751.     if (CONSOLE)
  752.       (void)asprintf(entry, "\23333m/* %s */\2330m\n", fib->fib_Comment);
  753.     else
  754.       (void)asprintf(entry, "/* %s */\n", fib->fib_Comment);
  755.     WSTR (entry);
  756.   }
  757. }
  758.  
  759. #ifdef NOASM
  760. /* -------------------------------------------------------------------- */
  761. /* Calculate date based on DateStamp structure, return a string pointer */
  762. /* -------------------------------------------------------------------- */
  763. char *CalcDate (fib)
  764.   struct FileInfoBlock *fib;
  765. {
  766.   static long days[12] =
  767.   {
  768.     31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
  769.   };
  770.  
  771.   static char *months[12] =
  772.   {
  773.     "Jan", "Feb", "Mar", "Apr", "May", "Jun",
  774.     "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
  775.   };
  776.   char datestr[25];
  777.   long i, mdays;
  778.   long day, hour;
  779.   long minute, sec;
  780.   long ldays;
  781.   long year;
  782.  
  783.   ldays = 1461L;
  784.   year = 78L;
  785.   day = fib->fib_Date.ds_Days;
  786.   minute = fib->fib_Date.ds_Minute;
  787.   sec = fib->fib_Date.ds_Tick / 50L;
  788.   year += (day / ldays) * 4L;
  789.   day %= ldays;
  790.  
  791.   while (day)
  792.   {
  793.     mdays = 365;
  794.     if ((year & 3) == 0)
  795.       mdays++;
  796.     if (day < mdays)
  797.       break;
  798.     day -= mdays;
  799.     year++;
  800.   }
  801.  
  802.   for (i = 0L, day++; i < 12; i++)
  803.   {
  804.     mdays = days[i];
  805.     if (i == 1 && (year & 3) == 0)
  806.       mdays++;
  807.     if (day <= mdays)
  808.       break;
  809.     day -= mdays;
  810.   }
  811.   hour = minute / 60;
  812.   minute -= hour * 60;
  813.   (void) asprintf (datestr, "%02ld-%s-%02ld %02ld:%02ld:%02ld ", day, (long)months[i], year, hour, minute, sec);
  814.   return (datestr);
  815. }
  816. #endif
  817.  
  818. /* -------------------------------------------------------------------- */
  819. /* Use AmigaDos to put a string on the stdout                 */
  820. /* -------------------------------------------------------------------- */
  821. void _PARM WSTR (tstring)
  822.   char *tstring;
  823. {
  824.   (void) Write (Out, tstring, (long) strlen (tstring));
  825. }
  826.  
  827. /* -------------------------------------------------------------------- */
  828. /* Use AmigaDos to put a character on the stdout             */
  829. /* -------------------------------------------------------------------- */
  830. void _PARM WCHR (ch)
  831.   char *ch;
  832. {
  833.   (void) Write (Out, ch, 1L);
  834. }
  835.  
  836. /* -------------------------------------------------------------------- */
  837. /* Check to see if the user hit ^C                     */
  838. /* -------------------------------------------------------------------- */
  839. void TestBreak ()
  840. {
  841.   unsigned long oldsig;
  842.  
  843.   oldsig = SetSignal (0L, SIGBREAKF_CTRL_C);
  844.   if ( (oldsig & SIGBREAKF_CTRL_C) != 0L)
  845.   {
  846.     WSTR ("\2330m\233 p**BREAK\n");
  847.     BREAKFLAG = 1;
  848.   }
  849. }
  850.  
  851. /* -------------------------------------------------------------------- */
  852. /* Explain how to use                             */
  853. /* -------------------------------------------------------------------- */
  854. void Usage ()
  855. {
  856.   WSTR (Author);
  857.   WSTR (usage);
  858.   WSTR (" c > Show comments\n");
  859.   WSTR (" d > Dirs only\n");
  860.   WSTR (" f > Files only\n");
  861.   WSTR (" l > Long listing\n");
  862.   WSTR (" n > No sort\n");
  863.   WSTR (" r > Reverse sort\n");
  864.   WSTR (" s > Sort by size\n");
  865.   WSTR (" t > Sort by date\n");
  866.   WSTR (" R > Recursive listing\n");
  867.   CleanUp ("", 0L);
  868. }
  869.  
  870. /* -------------------------------------------------------------------- */
  871. /* Allocate a FibEntry structure and associated FileInfoBlock         */
  872. /* -------------------------------------------------------------------- */
  873. struct FibEntry *AllocFib ()
  874. {
  875.   struct FibEntry *tfibp;
  876.  
  877.   tfibp = (struct FibEntry *) AllocMem \
  878. ((long)( sizeof (struct FibEntry) + sizeof(struct FileInfoBlock) ), 0L);
  879.   if (tfibp != 0L)
  880.   {
  881.     tfibp->Fibp = (struct FileInfoBlock *)((ULONG)tfibp + sizeof(struct FibEntry));
  882.   }
  883.   else
  884.     BREAKFLAG = 1;
  885.   return (tfibp);
  886. }
  887.  
  888. /* -------------------------------------------------------------------- */
  889. /* Free up memory allocated to a linked list of FibEntrys         */
  890. /* -------------------------------------------------------------------- */
  891. void _PARM FreeAllFibs (fibheadp)
  892.   struct FibEntry *fibheadp;
  893. {
  894.   struct FibEntry *fibp;
  895.   struct FibEntry *tfibp;
  896.  
  897.   if (fibheadp != 0)
  898.   {
  899.     fibp = fibheadp;
  900.     do
  901.     {
  902.       tfibp = fibp->NextFib;
  903.       FreeFib (fibp);
  904.       fibp = tfibp;
  905.     } while (tfibp != fibheadp);
  906.   }
  907. }
  908.  
  909. /* -------------------------------------------------------------------- */
  910. /* Deallocate a single FibEntry structure                 */
  911. /* -------------------------------------------------------------------- */
  912. void _PARM FreeFib (fibp)
  913.   struct FibEntry *fibp;
  914. {
  915.   if (fibp != 0L)
  916.     FreeMem (fibp, (long)(sizeof (struct FibEntry) + sizeof(struct FileInfoBlock)));
  917. }
  918.  
  919.