home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / PROGRAMS / UTILS / HARDDISK / BADCLU.ZIP / AE.ZIP / GETARGS.C < prev    next >
Encoding:
C/C++ Source or Header  |  1990-04-15  |  4.0 KB  |  151 lines
  1. /*------------------------------------------------------------
  2.  * 
  3.  * getargs.c
  4.  * 
  5.  * command line argument parser
  6.  * 
  7.  * by J. Alan Eldridge
  8.  *
  9.  * this code is placed in the public domain
  10.  *
  11.  * 07/18/89 jae fixed bug in parsing integer args of form -i 2
  12.  * 07/28/89 jae made it so an arg appearing more than once is error
  13.  * 04/09/90 jae made multiple character options, added function
  14.  *              pointer to validate arg when it is found
  15.  *
  16.  *----------------------------------------------------------*/
  17.  
  18. #include <ctype.h>
  19. #include <stddef.h>
  20.  
  21. #include "getargs.h"
  22.  
  23. int
  24. _getargs(acp, av, nargs, argsp, ignorebad)
  25. int     *acp;
  26. char    **av;
  27. int     nargs;
  28. CMD_ARG *argsp;
  29. int     ignorebad;
  30. {
  31.     int ac = *acp;
  32.     int argn,
  33.         an = 0,
  34.         slide,
  35.         n;
  36.     
  37.     while (an < ac) {
  38.         if (av[an][0] == '-' || av[an][0] == '+') {
  39.             int len;
  40.                         
  41.             for (argn = 0; argn < nargs; argn++) {
  42.                 if ((len = strlen(argsp[argn].optstr)) < 2)
  43.                     return -2;  /* pgmer error */
  44.                 if (!strncmp(argsp[argn].optstr, av[an], len))
  45.                     break;
  46.             }
  47.             if (argn == nargs) {
  48.                 if (ignorebad) {
  49.                     an++;
  50.                     continue;
  51.                 } else
  52.                     return -1;
  53.             }
  54.             if (argsp[argn].argtype & ARG_FOUND)
  55.                 return -1;
  56.             if (argsp[argn].argtype  == ARG_BOOL) {
  57.                 if (len == strlen(av[an])) {
  58.                     *ARG_IP(argsp[argn].ptr) = !(*ARG_IP(argsp[argn].ptr));
  59.                     slide = 1;
  60.                 } else
  61.                     return -1;
  62.             } else if ((argsp[argn].argtype & ~ARG_REQD) == ARG_INT) {
  63.                 if (av[an][len]) {
  64.                     if (isdigit(av[an][len]) || av[an][len] == '-') 
  65.                         *ARG_IP(argsp[argn].ptr) = atoi(av[an] + len);
  66.                     else
  67.                         return -1;
  68.                     slide = 1;
  69.                 } else {
  70.                     if (an + 1 == ac)
  71.                         return -1;
  72.                     if (isdigit(av[an + 1][0]) || av[an + 1][0] == '-')
  73.                         *ARG_IP(argsp[argn].ptr) = atoi(av[an + 1]);
  74.                     else
  75.                         return -1;
  76.                     slide = 2;
  77.                 }
  78.             } else if ((argsp[argn].argtype & ~ARG_REQD) == ARG_STR) {
  79.                 if (av[an][len]) {
  80.                     *ARG_CPP(argsp[argn].ptr) = av[an] + len;
  81.                     slide = 1;
  82.                 } else {
  83.                     if (an + 1 == ac)
  84.                         return -1;
  85.                     *ARG_CPP(argsp[argn].ptr) = av[an + 1];
  86.                     slide = 2;
  87.                 }
  88.             }
  89.             argsp[argn].argtype |= ARG_FOUND;
  90.             argsp[argn].argtype &= ~ARG_REQD;
  91.             if (argsp[argn].valfun != ARG_NOFUNC
  92.                && argsp[argn].valfun(argsp[argn].optstr,
  93.                argsp[argn].ptr) != 0)
  94.                return -1;
  95.             ac -= slide;
  96.             for (n = an; n < ac; n++)
  97.                 av[n] = av[n + slide];
  98.         } else {
  99.         an++;
  100.         }
  101.     }
  102.     for (argn = 0; argn < nargs; argn++) {
  103.         if (argsp[argn].argtype & ARG_REQD)
  104.            return -1;
  105.     }
  106.     *acp = ac;
  107.     return 0;
  108. }
  109.  
  110. int
  111. getargs(acp, av, nargs, argsp)
  112. int     *acp;
  113. char    **av;
  114. int     nargs;
  115. CMD_ARG *argsp;
  116. {
  117.     return _getargs(acp, av, nargs, argsp, 0);
  118. }
  119.     
  120. int
  121. argfound(
  122.     CMD_ARG *arr,
  123.     int     nopts,
  124.     char    *opt)
  125. {
  126.     int n;
  127.  
  128.     for (n = 0; n < nopts; n++)
  129.         if (!strcmp(arr[n].optstr,opt))
  130.             break;
  131.     if (n < nopts) {
  132.         arr[n].argtype &= ~ARG_REQD;
  133.         arr[n].argtype |= ARG_FOUND;
  134.         return 0;
  135.     } else
  136.         return -1;
  137. }           
  138.  
  139. void
  140. argfixbl(
  141.     char    *str,
  142.     int     c)
  143. {
  144.     while (*str) {
  145.         if (*str == c)
  146.             *str = ' ';
  147.         str++;
  148.     }
  149. }
  150.     
  151.