home *** CD-ROM | disk | FTP | other *** search
/ ProfitPress Mega CDROM2 …eeware (MSDOS)(1992)(Eng) / ProfitPress-MegaCDROM2.B6I / UTILITY / RAMDISK / SRDSK141.ZIP / CMDLINE.C next >
Encoding:
C/C++ Source or Header  |  1992-06-06  |  5.8 KB  |  202 lines
  1. /* ReSizeable RAMDisk - command line parser
  2. ** Copyright (c) 1992 Marko Kohtala
  3. */
  4.  
  5. #include "srdisk.h"
  6. #include <stdlib.h>
  7. #include <string.h>
  8. #include <ctype.h>
  9.  
  10. /* Variables possibly supplied in command line */
  11. char drive=0;
  12. int force_f=0;        /* Nonzero if ok to format */
  13. int use_old_format_f=0; /* Take undefined parameters from the old format */
  14. int f_set_env=0;      /* Set environment variables */
  15. int verbose=-1;       /* Verbose: 1 banner, */
  16.                       /* 2 + new format, 3 + old format, 4 + long format */
  17.  
  18.  
  19. static long parse_narg(char *argp, char **next)
  20. {
  21.   long res;
  22.   if (*argp == ':') argp++, (*next)++;
  23.   res = strtol(argp, next, 10);
  24.   if (argp == *next) return -1L;
  25.   return res;
  26. }
  27.  
  28. static int ispow2(long size)
  29. {
  30.   long cmp;
  31.   for (cmp = 128; cmp; cmp <<=1)
  32.     if (cmp == size) return 1;
  33.   return 0;
  34. }
  35.  
  36. static void set_DOS_disk(long size)
  37. {
  38.   static struct {
  39.     int disk_size;
  40.     int media;
  41.     int sector_size;
  42.     int cluster_size;
  43.     int FATs;
  44.     int dir_entries;
  45.     int sec_per_track;
  46.     int sides;
  47.   } dos_disk[] = {
  48.     {    1, 0xFA, 128,  128, 1,   4,  1, 1 },
  49.     {  160, 0xFE, 512,  512, 2,  64,  8, 1 },
  50.     {  180, 0xFC, 512,  512, 2,  64,  9, 1 },
  51.     {  320, 0xFF, 512, 1024, 2, 112,  8, 2 },
  52.     {  360, 0xFD, 512, 1024, 2, 112,  9, 2 },
  53.     {  720, 0xF9, 512, 1024, 2, 112,  9, 2 },
  54.     { 1200, 0xF9, 512,  512, 2, 224, 15, 2 },
  55.     { 1440, 0xF0, 512,  512, 2, 224, 18, 2 },
  56.     {0}
  57.   };
  58.   int i;
  59.  
  60.   for (i=0; dos_disk[i].disk_size; i++)
  61.     if (dos_disk[i].disk_size == size) {
  62.       newf.size = size;
  63.       newf.media = dos_disk[i].media;
  64.       newf.bps = dos_disk[i].sector_size;
  65.       newf.cluster_size = dos_disk[i].cluster_size;
  66.       newf.FATs = dos_disk[i].FATs;
  67.       newf.dir_entries = dos_disk[i].dir_entries;
  68.       newf.sec_per_track = dos_disk[i].sec_per_track;
  69.       newf.sides = dos_disk[i].sides;
  70.       changed_format |= DISK_SIZE
  71.                       | MEDIA
  72.                       | SECTOR_SIZE
  73.                       | CLUSTER_SIZE
  74.                       | NO_OF_FATS
  75.                       | DIR_ENTRIES
  76.                       | SEC_PER_TRACK
  77.                       | SIDES;
  78.       return;
  79.     }
  80.  
  81.   syntax("Unknown DOS disk size");
  82. }
  83.  
  84. void parse_cmdline(int argc, char *argv[])
  85. {
  86.   int arg;
  87.   char *argp;
  88.   int i;
  89.   long n;
  90.  
  91.   for(arg=1; arg < argc; arg++) {
  92.     argp = argv[arg];
  93.     while(*argp) {
  94.       if (*argp == '/' || *argp == '-') {
  95.         argp++;
  96.         switch(toupper(*argp++)) {
  97.         case '?':
  98.         case 'H':
  99.           print_syntax();
  100.           exit(0);
  101.         case 'W':
  102.           switch(*argp) {
  103.           case '-': argp++;
  104.                     newf.RW_access = READ_ACCESS;
  105.                     break;
  106.           case '+': argp++;
  107.           default:  newf.RW_access = READ_ACCESS|WRITE_ACCESS;
  108.           }
  109.           changed_format |= WRITE_PROTECTION;
  110.           break;
  111.         case 'Y':
  112.           force_f++;
  113.           break;
  114.         case 'S': /* Sector size */
  115.           n = parse_narg(argp, &argp);
  116.           if (!ispow2(n) || n > 512)
  117.             syntax("Invalid sector size");
  118.           newf.bps = (int)n;
  119.           changed_format |= SECTOR_SIZE;
  120.           break;
  121.         case 'C': /* Cluster size */
  122.           n = parse_narg(argp, &argp);
  123.           if (!ispow2(n) || n > 8192)
  124.             syntax("Invalid cluster size");
  125.           newf.cluster_size = (int)n;
  126.           changed_format |= CLUSTER_SIZE;
  127.           break;
  128.         case 'D': /* Directory entries */
  129.           n = parse_narg(argp, &argp);
  130.           if (n < 2 || n > 8000)
  131.             syntax("Invalid number of directory entries");
  132.           newf.dir_entries = (int)n;
  133.           changed_format |= DIR_ENTRIES;
  134.           break;
  135.         case 'A': /* FATs */
  136.           n = parse_narg(argp, &argp);
  137.           if (n < 1 || n > 255)
  138.             syntax("Invalid number of FAT copies");
  139.           newf.FATs = (int)n;
  140.           changed_format |= NO_OF_FATS;
  141.           break;
  142.         case 'M': /* MaxK for different partitions */
  143.           memset(newf.subconf, 0, sizeof newf.subconf);
  144.           changed_format |= MAX_PART_SIZES;
  145.           i = 0;
  146.           do {
  147.             if (i == MAX_CHAINED_DRIVERS)
  148.               syntax("Too many /M values - program limit exceeded");
  149.             n = parse_narg(argp, &argp);
  150.             if (n < -1 || n > 0x3FFFFFL)
  151.               syntax("Too large partition size");
  152.             if (n != -1L) {
  153.               newf.subconf[i].maxK = n;
  154.               newf.subconf[i].userdef = 1;
  155.             }
  156.             i++;
  157.           } while(*argp == ':');
  158.           break;
  159.         case 'F': /* DOS disk format */
  160.           n = parse_narg(argp, &argp);
  161.           set_DOS_disk(n);
  162.           break;
  163.         case 'V': /* Verbose level */
  164.           n = parse_narg(argp, &argp);
  165.           if (n < 1 || n > 5)
  166.             syntax("Invalid verbose level");
  167.           verbose = (int)n;
  168.           break;
  169.         case 'O': /* Use old parameters unless overridden */
  170.           use_old_format_f = 1;
  171.           break;
  172.         case 'E': /* Set environment variables to show SRDISKs */
  173.           f_set_env = 1;
  174.           break;
  175.         default:
  176.           syntax("Unknown switch");
  177.         }
  178.       }
  179.       else {
  180.         if (*argp == ' ' || *argp == '\t') argp++;
  181.         else if (isdigit(*argp) && *(argp+1) != ':') {
  182.           n = strtol(argp, &argp, 10);
  183.           if (n > 0x3FFFFFL)
  184.             syntax("Invalid disk size");
  185.           newf.size = n;
  186.           changed_format |= DISK_SIZE;
  187.         }
  188.         else {
  189.           if (drive) syntax("Unrecognised character on command line");
  190.           drive = toupper(*argp++);
  191.           if ( !(   (drive >= 'A' && drive <= 'Z')
  192.                  || (drive >= '1' && drive <= '9')) )
  193.             syntax("Invalid drive");
  194.           if (*argp == ':') argp++;
  195.         }
  196.       }
  197.     }
  198.   }
  199. }
  200.  
  201.  
  202.