home *** CD-ROM | disk | FTP | other *** search
/ Simtel MSDOS 1992 June / SIMTEL_0692.cdr / msdos / dirutl / free16.arc / FREE.C < prev    next >
Encoding:
Text File  |  1989-02-17  |  35.7 KB  |  769 lines
  1. /****************************************************************************
  2.  
  3.     FREE   : free.c checks disk free space, with options
  4.  
  5.     Author : Howard S. Kapustein
  6.  
  7.     Program, Source, Documentation Copyright (c) 1988,1989 all rights reserved.
  8.  
  9.     Compiled code may be used in your library, and linked to your programs
  10.     BUT, the source code nor a library based on the compiled modules may be
  11.     commercially distributed.
  12.     I retain all rights to the source (this is all lawyer talk. I just don't
  13.     want someone making money off my efforts.)
  14.     No donation is expected. If you like FREE, send me a picture postcard
  15.     or, if you must, $5. I am a poor starving college student and will
  16.     gladly accept all comments, questions, suggestions and/or donations.
  17.  
  18.     For a quick start try   FREE -?
  19.  
  20.     I know this is a pretty simple program. There are plenty of versions
  21.     of free disk space programs in the public domain, but none suited my 
  22.     needs. I needed 3 features besides the standard disk space free:
  23.  
  24.         1) Check more than 1 drive per run
  25.         2) Optionally check all drives
  26.         3) Optionally wait for a keypress after execution for use
  27.            with DESQview (tm)
  28.  
  29.     FREE.C, FREE.EXE and FREE.DOC must be distributed together.
  30.  
  31.     FREE was compiled with Turbo C (tm) 2.0 on an IBM PC with the Tiny
  32.     memory model optimized on Speed and all optimizations turned on
  33.     (Register and Jump optimization).
  34.  
  35.     Release notes:      2-2-88  Version 1.0 - Initial release
  36.  
  37.                         2-22-88 Version 1.1
  38.                                   - checks for drive ready before checking
  39.                                     free space
  40.                                   - skips drive B: only 1 drive present
  41.                                     (B: is a logical drive, not a physical
  42.                                     drive)
  43.                                   - optional wait after execution can now
  44.                                     wait for a specific key (specify its
  45.                                     decimal scan code, only valid for keys
  46.                                     1-255 (no extended keys i.e. Alt-C, etc.)
  47.                                   - fixed a bug with the strtocomma() function.
  48.                                     If a 4-digit number (i.e. 9216) was passed
  49.                                     to it it would not insert any commas
  50.                                   - I no longer make FREE.COM, for some reason
  51.                                     under DESQview FREE.COM 1.0 still needed
  52.                                     approx 70K, so until I can figure out how
  53.                                     to get FREE to use appropriate only the 11K
  54.                                     or so it needs, I'm not going to bother
  55.                                     playing with COM files
  56.  
  57.                         2-29-88 Version 1.2
  58.                                   - recompiled under Turbo C 1.5 (it only took
  59.                                     them 6 weeks instead of the 2-3 it should
  60.                                     have...) I turned on ALL optimizations
  61.                                     (speed, use regs, optimize regs and jumps.)
  62.                                     Previous versions were only compiled with
  63.                                     speed and use registers.
  64.                                   - modified the parsing for more coherent
  65.                                     program flow
  66.                                   - made waitforkey() after having extensive
  67.                                     difficulties getting the -w option to work.
  68.                                     This seems to have fixed the runtime bugs
  69.                                     I was getting after recompiling with TC 1.5
  70.                                   - changed the HEAP and STACK size so it will
  71.                                     run with less memory
  72.                                   - removed some needless comments left over
  73.                                     from old coding
  74.                                   - include a DESQview .DVP file for use with
  75.                                     DESQview.
  76.  
  77.                         3-19-88 Version 1.3
  78.                                   - fixed the bug with multiple drives
  79.                                     specified on the command line. It seems
  80.                                     that TC 1.5 DOES NOT let you use the
  81.                                     generic argc and argv as in
  82.                                     main(int argc, char *argv[]) Now Borland
  83.                                     wants you to use their global variables
  84.                                     (extern int argc, etc.). Nice of them not
  85.                                     to mention the fact that the old method
  86.                                     no longer works.
  87.  
  88.                         3-23-88 Version 1.31  -  Internal release only
  89.                                   - if you try to do a   FREE -   with no
  90.                                     parms free would check the default drive.
  91.                                     This has been fixed to display the help
  92.                                     (technically, doing   FREE -   is wrong)
  93.                                   - version 1.2 allowed -w[n] option to check
  94.                                     for extended key codes, but I forgot to
  95.                                     document it. Use this formula to get the
  96.                                     value for the wait option:
  97.  
  98.                                         extended * 256 + scancode
  99.  
  100.                                     where extended is 0 if False and 1 if True
  101.                                     and scancode is the scan code returned by
  102.                                     the key (refer to one of Norton's books
  103.                                     or some other reference guide for a list
  104.                                     of IBM extended scan codes.)
  105.  
  106.                         4-10-88 Version 1.32  -  Internal release only
  107.                                   - I removed a printf() left over from
  108.                                     debugging
  109.                                   - included info about contacting me during
  110.                                     the school year
  111.  
  112.                          5-6-88 Version 1.33  - Internal release only
  113.                                   - included % free
  114.  
  115.                         5-11-88 Version 1.34  - Internal release only
  116.                                   - fixed -w option, was skipping past
  117.                                     1st digit of keycode ([n])
  118.                                   - also, discovered the problem with the
  119.                                     -w option. Compiled w/full optimization,
  120.                                     the waitkey value was stored in a
  121.                                     register which was destroyed during the
  122.                                     absread(). This is a problem of the
  123.                                     TC library itself. I don't remember
  124.                                     who it was who discovered this flaw, but
  125.                                     if you drop me a line I'll update these
  126.                                     docs. He has notified Borland, so
  127.                                     hopefully the next TC will have this bug
  128.                                     fixed (if not sooner, but I'm not
  129.                                     holding my breath.) Thank you for the
  130.                                     debugging, it gave me many a restless
  131.                                     hour. DO NOT compile FREE with register
  132.                                     variables on, or unknown results may
  133.                                     (and probably will) occur
  134.  
  135.                         11-9-88 Version 1.4
  136.                                   - recompiled under TC 2.0 in Small model,
  137.                                     Merge duplicate strings On, Standard
  138.                                     stack frame Off, and all Debug info
  139.                                     left out. Couldn't compile under Tiny
  140.                                     (Cannot generate COM file: segment-
  141.                                     relocatable items present) probably because
  142.                                     of the FP emulator - see below
  143.                                   - added optional message if wait for key
  144.                                   - added -f and -n (search only floppies,
  145.                                     non-floppies). The -x option is equivalent
  146.                                     to -fn
  147.                                   - added -e option (full error display, useful
  148.                                     if you want to see any errors during a -f,
  149.                                     -n, or -x run). This setting is turned on
  150.                                     automatically for single mode (if -f, -n
  151.                                     and -x are not specified)
  152.                                   - minor code tinkering for aesthetics
  153.                                   - DESQview 2.2 .DVP file
  154.                                   - for some reason, FREE running under
  155.                                     DV 2.2 now requires 65K. According to my
  156.                                     estimates, it needs anywhere from 44K to
  157.                                     66K. I think this is related to the Tiny
  158.                                     problem (inability to make .COM file). If
  159.                                     anyone can figure out why, please let me
  160.                                     know. Without the FP emulator, I can't
  161.                                     display a % free, but requiring 65K to get
  162.                                     a free disk space count is ridiculous
  163.  
  164.                          2-7-89 Version 1.5
  165.                                   - new option -N, Network compatibility,
  166.                                     skips the absolute disk read before
  167.                                     checking free space. If a free space
  168.                                     request is attempted on drive A: with
  169.                                     no floppy in the drive, DOS bombs out to
  170.                                     the Abort,Ignore,Retry message. Turning on
  171.                                     this option should allow execution on
  172.                                     drives not physically available (networks,
  173.                                     those accessed via device drivers, etc.)
  174.                                   - changed option letter -N to -H to allow
  175.                                     network compatibility. The -H option
  176.                                     will scan non-floppy drives (generally
  177.                                     fixed disks, C: and up.)
  178.                                   - no longer compiled with the FP emulation,
  179.                                     the % free real number is now achieved via
  180.                                     integers. Without the FP emulation FREE can
  181.                                     be compiled with the Tiny memory model.
  182.                                   - added check for DOS environment variable
  183.                                     FREEOPT for options
  184.                                   - changed the Heap size to 4K and the stack
  185.                                     to 1K
  186.                                   - changed the command line parsing to a
  187.                                     separate function, and no longer copy each
  188.                                     *_argv before processing it. The pointer
  189.                                     char *temp replace the older char temp[30]
  190.                                     for several reasons: instead of a strcpy()
  191.                                     we can just do a temp = *_argv, and if an
  192.                                     argument string was longer than 29
  193.                                     characters, we would have problems copying
  194.                                     to temp[30]. Pointers make life simpler
  195.                                   - you can now check multiple drives via
  196.                                     command line switch, and specific drives
  197.                                     via drive letter, in the same run (i.e.
  198.                                     FREE /F B: checks all floppy drives and
  199.                                     drive B:)
  200.                                   - IMPORTANT! FREE is now distributed as a
  201.                                     .COM file! If you are using an earlier
  202.                                     verison with a .EXE extension, make sure
  203.                                     you delete it otherwise DOS may not find
  204.                                     the proper file to run. See above regarding
  205.                                     FP emulation as to why we're back to a
  206.                                     .COM file.
  207.                                Note: I've enclosed the substitute division
  208.                                      function within a conditional #if...#endif
  209.                                      set so you can recompile easily with the
  210.                                      emulation or 8087 library and not have
  211.                                      unnecessary code. If MATH_FP87 or MATH_EMU
  212.                                      is #defined, the rdiv() function will not
  213.                                      be compiled. Otherwise, no math library
  214.                                      will be linked in, and the final .COM
  215.                                      will only need ~15K to run.
  216.  
  217.                          2-8-89 Version 1.51
  218.                                   - if no command line arguments given, only
  219.                                     the current drive would be checked, even
  220.                                     if FREEOPT=X. Fixed
  221.  
  222.                         2-17-89 Version 1.6
  223.                                   - new option -t gives disk total size, used
  224.                                     disk space, etc. a list of all disk space
  225.                                     info. To do this, the functions rsub_t(),
  226.                                     rnormalize() and lpow() were created (real
  227.                                     subtraction w/o a math library), as well
  228.                                     as their attendant global variables.
  229.                            WARNING: these substitute floating point math
  230.                                     functions have minimal error checking.
  231.                                     Given the scope of this program, they
  232.                                     are adequate, but for a more complete
  233.                                     implementation of these (and other)
  234.                                     functions, try my Turbo C library TCHK
  235.                                     (currently distributed as TCHK20.ARC).
  236.                               NOTE: as per the rdiv() function, these
  237.                                     substitute fp functions/variables are
  238.                                     enclosed within #if...#endif to avoid
  239.                                     compilation if a fp library is used.
  240.                            FURTHER: the compiler may generate 2 warnings
  241.                                     (structure passed by value) if your
  242.                                     warning settings are just right. Don't
  243.                                     worry about it, those are the structures
  244.                                     passed to rsub(). It's valid C (or at
  245.                                     least ANSI C) but potentially erroneous
  246.                                     to pass structures instead of pointers to
  247.                                     structures, so Turbo C warns you.
  248.                                   - changed the code to check only as many
  249.                                     drives as DOS recognizes. Under DOS 1.x,
  250.                                     2.x and 3.x, there can be as many as 16,
  251.                                     63 or 26 drives available, respectively.
  252.                                     Previously I just checked drives 1-26
  253.                                     (A:-Z:), which was an erroneous assumption
  254.                                     on my part. Thanks to John Craven for
  255.                                     mentioning Int 21h Function 0Eh (setdisk()
  256.                                     in Turbo C) as the proper method for
  257.                                     detecting the number of logical drives.
  258.                                   - changed the code to skip B: if it does
  259.                                     not physically exist. This should clear
  260.                                     up the problem Michael Thompson has been
  261.                                     having with the scan drives (/x or /f)
  262.                                     option.
  263.  
  264.  
  265.     I can be reached at:
  266.  
  267.     Home:   Howard S. Kapustein
  268.             1695 Barbara Lane
  269.             East Meadow, New York 11554  
  270.             Phone: (516) 481-9612           
  271.  
  272.     College (until 5-19-89):    Howard S. Kapustein
  273.                                 404 Davison
  274.                                 Rensselaer Polytechnic Institute
  275.                                 Troy, NY 12180
  276.                                 (518) 276-7381
  277.  
  278.     Modem:  The BOSS (201) 568-7293  ***Support BBS
  279.             Software Society (201) 729-7410
  280.             Computer Connection (202) 547-2008
  281.             GEnie
  282.  
  283.         Until graduation (May 19, 1989) please try to contact me
  284.     at college. If you call my home while I'm in Troy you're not
  285.     likely to get much information (my parents aren't exactly
  286.     computer people.)
  287.  
  288.  
  289. ****************************************************************************/
  290.  
  291. #include <ctype.h>
  292. #include <bios.h>
  293. #include <dos.h>
  294. #include <string.h>
  295. #include <stdlib.h>
  296. #include <stdio.h>
  297. #include <dir.h>
  298. typedef struct rdiv_t {
  299.             long rint;              /* real - integer */
  300.             long rfrac;             /* real - fraction */
  301.             int precision;          /* precision of fraction (# of decimal places) */
  302.         };
  303.  
  304. #define TRUE        1
  305. #define FALSE       0
  306. #define boolean     char
  307. #define BUFF_LEN    512                 /* buffer length for disk read */
  308. #define FLOPPY      0x10
  309. #define FIXED       0x20
  310. #define ALLDRIVES   (FIXED|FLOPPY)
  311. #define isBlogical()    ((biosequip()&0xB0)?FALSE:TRUE)
  312. #define MAXRPRECISION   8               /* maximum real precision (decimal places) */
  313. #define _HEADING_       "FREE     Free disk space      Version 1.6     2-17-89               FREE/?\n"
  314. #define _HEADINGCOPY_   "Copyright (c) 1988,1989 Howard Kapustein. All Rights Reserved      for help\n\n"
  315.  
  316. typedef struct options {
  317.         char scandrives;
  318.         boolean network;
  319.         boolean disktotal;
  320.         boolean checkmemory;
  321.         boolean errormsg;
  322.         boolean wait;
  323.         boolean waitmsg;
  324.         int waitkey;
  325.     };
  326.  
  327. /* Global variables */
  328. struct options flag;
  329. #if !defined(MATH_FP87) && !defined(MATH_EMU)   /* using no math library */
  330. int _r_minpre, _r_maxpre;
  331. boolean _r_maximum = FALSE;                 /* should rnormalize() try to minimize or maximize the precision */
  332. #endif
  333.  
  334. /* function prototypes */
  335. void main();                                /* prevents compiler warning */
  336. void check(int drive);                      /* actual free space check and output */
  337. char *strtocomma(char *source);             /* convert a string to xx,xxx,xxx format */
  338. void help(void);                            /* help */
  339. void waitforkey(int keycode, boolean msg);  /* wait for keypress when done */
  340. void parsecommandline(char *cmdline);       /* parse a command line */
  341. void bye(int errcode);                      /* generalized quit routine */
  342. struct rdiv_t rdiv(long int numer, long int denom, int precision);  /* real division without FP emulator library */
  343. struct rdiv_t rsub(struct rdiv_t val, struct rdiv_t sval, int precision);   /* real subtraction without FP emulator library */
  344. void rnormalize(struct rdiv_t *r1, struct rdiv_t *r2);  /* normalize emulated fp values (fix the decimal places) */
  345. long lpow(long base, int exponent);         /* raise a base to an exponent */
  346.  
  347.  
  348. void main()
  349. {
  350.     extern int _argc;
  351.     extern char **_argv;
  352.     extern unsigned _heaplen, _stklen;
  353.     char *temp;
  354.     boolean Blogical;
  355.     int i, floppies, totaldrives;
  356.  
  357.     _heaplen = 4096u;        /* heap  = 4K */
  358.     _stklen = 1024u;         /* stack = 1K */
  359.  
  360.     _argc--;
  361.     _argv++;
  362.  
  363.     flag.scandrives = FALSE;                    /* initialize settings */
  364.     flag.network = FALSE;
  365.     flag.disktotal = FALSE;
  366.     flag.checkmemory = FALSE;
  367.     flag.errormsg = FALSE;
  368.     flag.wait = FALSE;
  369.     flag.waitmsg = TRUE;
  370.     flag.waitkey = 0;
  371.  
  372.     if ((temp = getenv("FREEOPT")) != NULL)
  373.         parsecommandline(temp);
  374.  
  375.     if (_argc > 0)                      /* check for options */
  376.         for (temp = *_argv; (temp[0] == '-') || (temp[0] == '/'); temp = *_argv) {
  377.             if (temp[1] == '\0')
  378.                 help();
  379.             parsecommandline(temp+1);
  380.             _argc--;
  381.             _argv++;
  382.             if (_argc == 0)
  383.                 break;
  384.         }
  385.  
  386.     if (flag.disktotal)
  387.         fputs("\n" _HEADING_ _HEADINGCOPY_
  388.               "Drive     Size        Used        Free     % Used  % Free\n"
  389.               "-----  ----------  ----------  ----------  ------  ------\n",stdout);
  390.  
  391.     if (flag.scandrives) {               /* check multiple drives? */
  392.         floppies = ((biosequip() & 0xB0) >> 6) + 1;
  393.         Blogical = (floppies > 1) ? FALSE : TRUE;
  394.         if (flag.scandrives & FLOPPY)        /* check floppy drives? */
  395.             for (i=1; i<=floppies; i++)      /* check floppies */
  396.                 if (!(Blogical && i==2))
  397.                     check(i);
  398.         if (flag.scandrives & FIXED) {       /* check non-floppies? */
  399.             totaldrives = setdisk(getdisk());
  400.             i = ++floppies;
  401.             if (Blogical)
  402.                 i++;
  403.             for (; i<=totaldrives; i++)      /* check hard drives */
  404.                 check(i);
  405.         }
  406.     }
  407.  
  408.     if ((_argc == 0) && !flag.scandrives) {      /* ok, just parms (no drive specified) */
  409.         flag.errormsg = TRUE;    /* force error message display for non-multiple mode */
  410.         check(0);
  411.         if (flag.wait)
  412.             waitforkey(flag.waitkey,flag.waitmsg);
  413.         bye(3);
  414.     }
  415.  
  416.     flag.errormsg = TRUE;    /* force error message display for non-multiple mode */
  417.     for (; _argc>0; _argc--, _argv++) {
  418.         strcpy(temp,*_argv);
  419.         if (!isalpha(temp[0]=toupper(temp[0])))
  420.             printf("Invalid drive: %c\n",temp[0]);
  421.         else
  422.             check(temp[0]-64);
  423.     }
  424.  
  425.     if (flag.wait)
  426.         waitforkey(flag.waitkey,flag.waitmsg);
  427. }
  428.  
  429.  
  430. void check(int drive)
  431. {
  432.     extern struct options flag;
  433.     struct dfree df;
  434.     char size[30];
  435.     unsigned char buffer[BUFF_LEN];
  436.     long avail, total;
  437. #if defined(MATH_FP87) || defined(MATH_EMU)     /* using 80x87 or Emulation math library */
  438.     double percent;
  439. #else                                           /* using No math library */
  440.     struct rdiv_t percent, percentused, percent100;
  441.     percent100.rint = 100l;
  442.     percent100.rfrac = 0l;
  443.     percent100.precision = MAXRPRECISION;
  444. #endif
  445.  
  446.     if (drive==0)
  447.         drive = getdisk() + 1;
  448.     if (!flag.network && absread(drive-1,1,0,buffer)==-1) {      /* error */
  449.         if (flag.errormsg)
  450.             printf("Drive %c: is not available (drive not ready)\n",drive+64);
  451.     } else {
  452.         getdfree(drive,&df);
  453.         if (df.df_sclus == (unsigned)(-1)) {            /* error */
  454.             if (flag.errormsg)
  455.                 printf("Drive %c: is not available (can't get free space)\n",drive+64);
  456.         } else {
  457.             avail = (long)df.df_avail * df.df_bsec * df.df_sclus;
  458.             total = (long)df.df_total * df.df_bsec * df.df_sclus;
  459. #if defined(MATH_FP87) || defined(MATH_EMU)     /* using 80x87 or Emulation math library */
  460.             percent = (avail * 100.0) / ((long)df.df_total * df.df_bsec * df.df_sclus);
  461.             if (flag.disktotal)
  462.                 printf(" %c:    %10ld  %10ld  %10ld  %6.2lf  %6.2lf\n",drive+64,total,total-avail,avail,100.0-percent,percent);
  463.             else {
  464.                 ltoa(avail,size,10);
  465.                 printf("Drive %c: has %s bytes free (%.2lf %%)\n",drive+64,strtocomma(size),percent);
  466.             }
  467. #else                                           /* using No math library */
  468.             percent = rdiv(avail,total,4);
  469.             percent.rint = percent.rint * 100l + percent.rfrac / 100l;
  470.             percent.rfrac %= 100l;
  471.             percent.precision -= 2;
  472.             percentused = rsub(percent100,percent,2);
  473.             if (flag.disktotal)
  474.                 printf(" %c:    %10ld  %10ld  %10ld  %3ld.%02ld  %3ld.%02ld\n",drive+64,total,total-avail,avail,
  475.                        percentused.rint,percentused.rfrac,percent.rint,percent.rfrac);
  476.             else {
  477.                 ltoa(avail,size,10);
  478.                 printf("Drive %c: has %s bytes free (%ld.%02ld %%)\n",drive+64,strtocomma(size),percent.rint,percent.rfrac);
  479.             }
  480. #endif
  481.         }
  482.     }
  483. }
  484.  
  485.  
  486. char *strtocomma(char *source)    /* convert a string to xx,xxx,xxx format */
  487. {
  488.     char temp[80],*t,*s;
  489.     int i,len;
  490.  
  491.     len = strlen(source) * 4/3 + 1;
  492.     strcpy(temp,"");
  493.     if ((len = strlen(source)) <= 3)
  494.         strcpy(temp,source);
  495.     else
  496.         for (i=len, t=temp, s=source; i>0; i--) {
  497.             if ((i%3 == 0) && (i != len))
  498.                 *t++ = ',';
  499.            *t++ = *s++;
  500.         }
  501.     *t = '\0';
  502.     strcpy(source,temp);
  503.     return(source);
  504. }
  505.  
  506.  
  507. void help(void)
  508. {
  509.     fputs(_HEADING_ _HEADINGCOPY_,stdout);
  510.     fputs("Usage: FREE [options] [drive] [drive] [drive] ...\n",stdout);
  511.     fputs("Options are:\n",stdout);
  512.     fputs("        -e = display all error messages      -f = check all floppy drives\n",stdout);
  513.     fputs("        -n = network compatibility           -h = check all non-floppy drives\n",stdout);
  514.     fputs("        -t = display total disk size         -x = check all drives\n",stdout);
  515.     fputs("  -w[0][n] = wait for keypress when done     -? = help\n\n",stdout);
  516.     fputs("If you like FREE send me a picture postcard or $5. I can be reached at:\n\n",stdout);
  517.     fputs("VOICE: Howard Kapustein            MODEM: The BOSS (201) 568-7293 **Support BBS\n",stdout);
  518.     fputs("       1695 Barbara Lane                  Software Society (201) 729-7410\n",stdout);
  519.     fputs("       East Meadow, New York 11554        Computer Connection (202) 547-2008\n",stdout);
  520.     fputs("       Phone: (516) 481-9612              GEnie: Howard S. Kapustein\n\n",stdout);
  521.     fputs("I am a poor starving college senior,          404 Davison\n",stdout);
  522.     fputs("so all donations (and job offers)             Rensselaer Polytechnic Institute\n",stdout);
  523.     fputs("will be appreciated. Until graduation         Troy, NY 12180\n",stdout);
  524.     fputs("(May 19, 1989) PLEASE contact me at ->        Phone: (518) 276-7381\n\n",stdout);
  525.     fputs("I also write Subtree Find (SF310.ARC), TCHK (TCHK20.ARC) and other shareware.\n",stdout);
  526.     bye(9);
  527. }
  528.  
  529.  
  530. void waitforkey(int keycode, boolean msg)   /* wait for keypress when done */
  531. {
  532.     int key;
  533.  
  534.     if (msg) {
  535.         if (keycode == 0)
  536.             fputs("Press any key to end...",stdout);
  537.         else
  538.             printf("Press key #%d to end...",keycode);
  539.     }
  540.     if (keycode == 0)
  541.         bioskey(0);
  542.     else
  543.         do {
  544.             key = bioskey(0);
  545.             if (key & 0xFF)
  546.                 key = key & 0xFF;
  547.             else
  548.                 key = ((key & 0xFF00) >> 8) + 256;
  549.         } while (key != keycode);
  550. }
  551.  
  552.  
  553. void parsecommandline(char *cmdline)
  554. {
  555.     extern struct options flag;
  556.     int i;
  557.  
  558.     for (i=0; cmdline[i]!='\0'; i++)
  559.         switch (toupper(cmdline[i])) {
  560.             case '/': { if (cmdline[++i] == '\0')
  561.                             bye(67);
  562.                         break; }
  563.             case 'N': { switch (cmdline[i+1]) {
  564.                             case '-': { flag.network = FALSE;
  565.                                         i++;
  566.                                         break; }
  567.                             case '*': { flag.network ^= TRUE;
  568.                                         i++;
  569.                                         break; }
  570.                             case '+': i++;
  571.                              default: flag.network = TRUE;  break;
  572.                         }
  573.                         break; }
  574.             case 'E': { switch (cmdline[i+1]) {
  575.                             case '-': { flag.errormsg = FALSE;
  576.                                         i++;
  577.                                         break; }
  578.                             case '*': { flag.errormsg ^= TRUE;
  579.                                         i++;
  580.                                         break; }
  581.                             case '+': i++;
  582.                              default: flag.errormsg = TRUE;  break;
  583.                         }
  584.                         break; }
  585.             case 'F': { switch (cmdline[i+1]) {
  586.                             case '-': { flag.scandrives &= ~FLOPPY;
  587.                                         i++;
  588.                                         break; }
  589.                             case '*': { flag.scandrives ^= FLOPPY;
  590.                                         i++;
  591.                                         break; }
  592.                             case '+': i++;
  593.                              default: flag.scandrives |= FLOPPY;  break;
  594.                         }
  595.                         break; }
  596.             case 'H': { switch (cmdline[i+1]) {
  597.                             case '-': { flag.scandrives &= ~FIXED;
  598.                                         i++;
  599.                                         break; }
  600.                             case '*': { flag.scandrives ^= FIXED;
  601.                                         i++;
  602.                                         break; }
  603.                             case '+': i++;
  604.                              default: flag.scandrives |= FIXED;  break;
  605.                         }
  606.                         break; }
  607.             case 'M': { switch (cmdline[i+1]) {
  608.                             case '-': { flag.checkmemory = FALSE;
  609.                                         i++;
  610.                                         break; }
  611.                             case '*': { flag.checkmemory ^= TRUE;
  612.                                         i++;
  613.                                         break; }
  614.                             case '+': i++;
  615.                              default: flag.checkmemory = TRUE;  break;
  616.                         }
  617.                         break; }
  618.             case 'T': { switch (cmdline[i+1]) {
  619.                             case '-': { flag.disktotal = FALSE;
  620.                                         i++;
  621.                                         break; }
  622.                             case '*': { flag.disktotal ^= TRUE;
  623.                                         i++;
  624.                                         break; }
  625.                             case '+': i++;
  626.                              default: flag.disktotal = TRUE;  break;
  627.                         }
  628.                         break; }
  629.             case 'X': { switch (cmdline[i+1]) {
  630.                             case '-': { flag.scandrives &= ~ALLDRIVES;
  631.                                         i++;
  632.                                         break; }
  633.                             case '*': { flag.scandrives ^= ALLDRIVES;
  634.                                         i++;
  635.                                         break; }
  636.                             case '+': i++;
  637.                              default: flag.scandrives |= ALLDRIVES;  break;
  638.                         }
  639.                         break; }
  640.             case 'W': { if (isdigit(cmdline[i+1])) {
  641.                             flag.waitmsg = (cmdline[++i] == '0') ? FALSE : TRUE;
  642.                             flag.waitkey = atoi(cmdline+i);
  643.                             for (; isdigit(cmdline[i+1]); i++);
  644.                         } else
  645.                             flag.waitkey = 0;
  646.                         switch (cmdline[i+1]) {
  647.                             case '-': { flag.wait = FALSE;
  648.                                         i++;
  649.                                         break; }
  650.                             case '*': { flag.wait ^= TRUE;
  651.                                         i++;
  652.                                         break; }
  653.                             case '+': i++;
  654.                              default: flag.wait = TRUE;  break;
  655.                         }
  656.                         break; }
  657.             case '?': help();
  658.             default : { printf("Unknown parameter: %c\n",cmdline[i]);  bye(11); }
  659.         }
  660. }
  661.  
  662.  
  663. void bye(int errcode)                       /* generalized quit routine */
  664. {
  665.     exit(errcode);
  666.  
  667. /*  A separate quit function is not really necessary at this time,
  668.     but it allows for potential error checking and cleanup just before
  669.     exiting. Perhaps a future version will have more here. Included for
  670.     upward compatibility purposes.                                      */
  671. }
  672.  
  673.  
  674. #if !defined(MATH_FP87) && !defined(MATH_EMU)   /* using no math library */
  675. struct rdiv_t rdiv(long int numer, long int denom, int precision)   /* real division without FP emulator library */
  676. {
  677.     struct rdiv_t retval;
  678.     long i;
  679.  
  680.     if (denom == 0l) {
  681.         retval.rint = -1;
  682.         retval.rfrac = -1;
  683.         return(retval);
  684.     }
  685.     retval.precision = precision;           /* store precision of fraction */
  686.     retval.rint = numer / denom;
  687.     denom -= numer * retval.rint;
  688.     retval.rfrac = 0l;
  689.     if (denom == 0l)
  690.         return(retval);
  691.     for (; precision >= 0; precision--) {
  692.         numer *= 10l;
  693.         i = numer / denom;
  694.         if (precision != 0)
  695.             retval.rfrac = retval.rfrac * 10l  +  i;
  696.         else
  697.             if (numer / denom >= 5l)          /* round off last decimal place */
  698.                 retval.rfrac++;
  699.         numer = numer - i * denom;
  700.     }
  701.     return(retval);
  702. }
  703.  
  704.  
  705. struct rdiv_t rsub(struct rdiv_t val, struct rdiv_t sval, int precision)    /* real subtraction without FP emulator library */
  706. {
  707.     extern int _r_minpre;
  708.     struct rdiv_t retval;
  709.     int i;
  710.  
  711.     rnormalize(&val,&sval);
  712.     retval.rint = val.rint - sval.rint;
  713.     if (val.rfrac < sval.rfrac) {
  714.         retval.rint--;                          /* carry the one... */
  715.         val.rfrac += lpow(10l,val.precision);
  716.     }
  717.     retval.rfrac = val.rfrac - sval.rfrac;
  718.     retval.precision = precision;
  719.     i = precision - _r_minpre;
  720.     if (i < 0)
  721.         for (; i<0; i++)
  722.             retval.rfrac /= 10l;
  723.     else if (i > 0)
  724.         for (; i>0; i--)
  725.             retval.rfrac *= 10l;
  726.     return(retval);
  727. }
  728.  
  729.  
  730. void rnormalize(struct rdiv_t *r1, struct rdiv_t *r2)   /* normalize emulated fp values (fix the decimal places) */
  731. {
  732.     extern int _r_minpre, _r_maxpre;
  733.     extern boolean _r_maximum;
  734.     struct rdiv_t *r;
  735.     int i;
  736.  
  737.     _r_minpre = min(r1->precision,r2->precision);
  738.     _r_maxpre = max(r1->precision,r2->precision);
  739.     i = r1->precision - r2->precision;
  740.     if (i == 0)
  741.         return;
  742.     if (i < 0) {
  743.         i = -i;
  744.         r = (_r_maximum) ? r1 : r2;
  745.     } else
  746.         r = (_r_maximum) ? r2 : r1;
  747.     if (_r_maximum)                 /* adjust to largest amount of precision (extend) */
  748.         for (; i>0; i--) {
  749.             r->rfrac *= 10l;
  750.             r->precision++;
  751.         }
  752.     else                            /* adjust to smallest amount of precision (truncate) */
  753.         for (; i>0; i--) {
  754.             r->rfrac /= 10l;
  755.             r->precision--;
  756.         }
  757. }
  758.  
  759.  
  760. long lpow(long base, int exponent)          /* raise a base to an exponent */
  761. {
  762.     long retval;
  763.  
  764.     for(retval = 1l; exponent > 0; exponent--)
  765.         retval *= base;
  766.     return(retval);
  767. }
  768. #endif
  769.