home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 451.lha / Free / main.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-12-09  |  4.6 KB  |  180 lines
  1. /***************************************************************************
  2.  * FREE:    Display free space on your disk devices.
  3.  *        Author:  Daniel Jay Barrett, barrett@cs.jhu.edu.
  4.  *        Inspired by "FREE" by Tom Smythe on Fred Fish Disk #66,
  5.  *         but totally rewritten.  One function, AvailSpace(), is an
  6.  *         updated version of Smythe's function avail().
  7.  *
  8.  * This program is Freely Distributable.  Make all the copies you want
  9.  * and give them away.  Use this code in any way you like.
  10.  *
  11.  * Changes/Improvements over Tom Smythe's program are:
  12.  *
  13.  *    o    Does not use self-modifying code, so it should work on
  14.  *        ALL Amigas, not just 68000-based systems.
  15.  *    o    You can specify a device list on the command line.
  16.  *    o    You can specify a device list using a Manx/ARP environment
  17.  *        variable.
  18.  *    o    Requestors are turned off, so non-mounted devices are just
  19.  *        skipped.  (See -m option.)
  20.  *    o    Data is written in correct columns, regardless of the 
  21.  *        lengths of the volume names.  (See -l option.)
  22.  *    o    Total memory free is shown, along with CHIP and FAST
  23.  *        subtotals.
  24.  *    o    Command-line options added so the user can customize the
  25.  *        program.
  26.  *    o    Written in ANSI C, in a modular and easy-to-read style.
  27.  *
  28.  * Daniel Jay Barrett makes no claims about the suitability of this program
  29.  * for any particular purpose.  Any damages incurred through the use of
  30.  * this program are entirely the responsibility of the USER.  Use at your
  31.  * own risk.  So there!   :-)
  32.  *
  33.  ***************************************************************************/
  34.  
  35. #include "free.h"
  36.     
  37. main(int argc, char *argv[])
  38. {
  39.     char *outArray = NULL;
  40.  
  41.     InitializeGlobals();
  42.  
  43.     if ((argc == 2) && (EQUAL(argv[1], HELP_ARG)))
  44.         Usage(argv[0]);
  45.     else
  46.         DoFree(argc, argv, &outArray);
  47.  
  48.     ExitCleanly(outArray, NO_ERROR, RETURN_OK);
  49. }
  50.  
  51.  
  52. /* Process the user's command-line options.
  53.  * Allocate the out[] array for output.
  54.  * Disable requestors, if necessary.
  55.  * Measure the available RAM.
  56.  * Then, measure free space on each desired device. 
  57.  * Print the output in a quick manner, using Write().
  58.  * Turn requestors back on, if they were turned off.
  59.  */
  60.  
  61. void DoFree(int argc, char *argv[], char **out)
  62. {
  63.     struct Process *proc;
  64.     APTR oldWindowPtr;
  65.     long chipRam, fastRam;
  66.     int argIndex;
  67.  
  68.     argIndex = GetOptions(argc, argv);
  69.     *out = MakeOutArray();
  70.  
  71.     if (!(flags & FLAG_REQUESTORS))
  72.          DisableRequestors(&proc, &oldWindowPtr);
  73.  
  74.     GetFreeRam(&chipRam, &fastRam);
  75.  
  76.     if (argIndex >= argc)
  77.         FreeUsingEnv(chipRam, fastRam, *out);
  78.     else
  79.         FreeFromArgs(argv+argIndex, chipRam, fastRam, *out);
  80.  
  81.     Write(Output(), *out, (long)strlen(*out));    /* For speed. */
  82.  
  83.     if (!(flags & FLAG_REQUESTORS))
  84.          EnableRequestors(proc, oldWindowPtr);
  85. }
  86.  
  87.  
  88. /* The user specified no volumes as command-line arguments.  So, check
  89.  * the environment variable.  If it has no value, then use DEFAULT_VOLUMES
  90.  * instead.
  91.  * We use the WONDERFUL function strtok() iteratively, to get the name of
  92.  * each volume, one at a time. */
  93.  
  94. void FreeUsingEnv(long chipRam, long fastRam, char out[])
  95. {
  96.     static char *defaultVolumes = DEFAULT_VOLUMES;
  97.     char *volume, *volumeList;
  98.     
  99.     volumeList = GetEnv(ENV_VARIABLE);
  100.     if (!volumeList)
  101.         volumeList = defaultVolumes;
  102.  
  103.     volume = strtok(volumeList, ENV_SEPARATOR);
  104.     while (volume)
  105.     {
  106.         ShowFree(volume, chipRam, fastRam, out);
  107.         volume = strtok(NULL, ENV_SEPARATOR);
  108.     }
  109. }
  110.  
  111.  
  112. /* The user specified volumes on the command-line.  Check each one. */
  113.  
  114. void FreeFromArgs(char *argv[], long chipRam, long fastRam, char out[])
  115. {
  116.     while (*argv)
  117.         ShowFree(*argv++, chipRam, fastRam, out);
  118. }
  119.  
  120.  
  121. /* Process the user's command-line options.
  122.  * Return the index of the first argument appearing AFTER all options. */
  123.  
  124. int GetOptions(int argc, char *argv[])
  125. {
  126.     register char c;
  127.     long m;
  128.  
  129.     while ((c = getopt(argc, argv, OPTSTRING)) != EOF)
  130.     {
  131.         switch (c)
  132.         {
  133.             case OPT_BLOCKS:
  134.                 flags |= FLAG_BLOCKS;
  135.                 break;
  136.             case OPT_REQUESTORS:
  137.                 flags |= FLAG_REQUESTORS;
  138.                 break;
  139.             case OPT_MALLOC:
  140.                 flags |= FLAG_MALLOC;
  141.                 if ((m = atoi(optarg)) > 0)
  142.                     memSize = m;
  143.                 break;
  144.             case OPT_VOLUME_NAME_LEN:
  145.                 flags |= FLAG_VOLUME_NAME_LEN;
  146.                 volumeNameLen = atoi(optarg);
  147.                 CheckVolumeNameLen(&volumeNameLen);
  148.                 break;
  149.             case OPT_UNKNOWN:
  150.                 break;
  151.             default:    /* Sanity check! */
  152.                 ExitCleanly((char *)NULL, ERROR_IMPOSSIBLE,
  153.                         RETURN_FAIL);
  154.                 break;
  155.         }
  156.     }
  157.     return(optind);
  158. }
  159.  
  160.  
  161. /* Deallocate memory, print a message, and exit. */
  162. void ExitCleanly(char *arr, ERROR errorCode, int exitCode)
  163. {
  164.     if (arr)
  165.         free(arr);
  166.     if (errorCode)
  167.         ErrorMsg(errorCode);
  168.     exit(exitCode);
  169. }
  170.  
  171.  
  172. /* Like the name says... initialize our global variables. */
  173.  
  174. void InitializeGlobals()
  175. {
  176.     flags        = 0L;
  177.     memSize        = DEFAULT_MEMORY_LIMIT;
  178.     volumeNameLen    = DEFAULT_NAME_LEN;
  179. }
  180.