home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / misc / volume10 / parseargs / argtype.c < prev    next >
C/C++ Source or Header  |  1990-02-16  |  5KB  |  294 lines
  1. #include <useful.h>
  2. #include <parseargs.h>
  3. #include <ctype.h>
  4.  
  5. #ifdef __STDC__
  6. typedef void *pointer;
  7. #else
  8. typedef char *pointer;
  9. #endif
  10.  
  11. extern pointer malloc();
  12.  
  13. #define ALL_AD        ad = argd; ad->ad_name != '\0'; ad++
  14. #define ALL_DEFS    ad = _DefaultArgs; ad->ad_name != '\0'; ad++
  15.  
  16. extern char    *ProgName;
  17.  
  18. /*
  19. **  ARGtype -- argument translation routines.
  20. **
  21. **    Each of these converts a parameter value to the internal form,
  22. **    including validity checking.  Their parameters and return values
  23. **    all behave identically.
  24. **
  25. **    Parameters:
  26. **        ad -- the argument descriptor for this parameter.
  27. **        vp -- a pointer to the string input value.
  28. **        copyf -- if TRUE, the value will be destroyed later,
  29. **            and so should be copied if it will be retained
  30. **            (as for a string).
  31. **
  32. **    Returns:
  33. **        TRUE -- if the conversion was successful.  The actual
  34. **            value should be stored in the location indicated
  35. **            by ad->ad_valp.
  36. **        FALSE -- if the conversion failed.  The reason for failure
  37. **            should be diagnosed using usrerr().
  38. **
  39. **    Side Effects:
  40. **        The value should be stored through ad->ad_valp.
  41. */
  42.  
  43. BOOL
  44. argStr(ad, vp, copyf)
  45.     register ARGDESC *ad;
  46.     register char *vp;
  47.     BOOL copyf;
  48. {
  49.     char *cp;
  50.  
  51.     if (copyf)
  52.     {
  53.         register int i;
  54.  
  55.         i = strlen(vp) + 1;
  56.         cp = (char *) malloc(i);
  57.         if(!cp) {
  58.             usrerr("out of memory parsing %s", ad->ad_prompt);
  59.             return FALSE;
  60.         }
  61.         bcopy(vp, cp, i);
  62.     }
  63.     else
  64.     {
  65.         cp = vp;
  66.     }
  67.     *(char **) ad->ad_valp = cp;
  68.     return (TRUE);
  69. }
  70.  
  71. BOOL
  72. argChar(ad, vp, copyf)
  73.     register ARGDESC *ad;
  74.     register char *vp;
  75.     BOOL copyf;
  76. {
  77.     auto char *vpp;
  78.     extern long strtol ARGS((char *, char **, int));
  79.     int status = FALSE;
  80.     char c;
  81.  
  82.     if (strlen(vp) == 2 && vp[0]=='^')
  83.     {
  84.         c = vp[1] ^ '@';
  85.         status = TRUE;
  86.     }
  87.     else if(strlen(vp) > 1 && vp[0]=='\\')
  88.     {
  89.         c = (int) strtol(&vp[1], &vpp, 8);
  90.         if (*vpp == '\0')
  91.             status = TRUE;
  92.     }
  93.     else if(strlen(vp) == 1)
  94.     {
  95.         c = *vp;
  96.         status = TRUE;
  97.     }
  98.  
  99.     if(status == TRUE)
  100.         *(char *) ad->ad_valp = c;
  101.     else
  102.     {
  103.         usrerr("invalid character argument '%s' for %s",
  104.             vp, ad->ad_prompt);
  105.     }
  106.     return status;
  107. }
  108.  
  109. /*ARGSUSED*/
  110. BOOL
  111. argInt(ad, vp, copyf)
  112.     register ARGDESC *ad;
  113.     register char *vp;
  114.     BOOL copyf;
  115. {
  116.     auto char *vpp;
  117.     extern long strtol ARGS((char *, char **, int));
  118.  
  119.     *(int *) ad->ad_valp = (int) strtol(vp, &vpp, 0);
  120.     if (*vpp != '\0')
  121.     {
  122.         usrerr("invalid integer argument '%s' for %s",
  123.             vp, ad->ad_prompt);
  124.         return (FALSE);
  125.     }
  126.     else
  127.     {
  128.         return (TRUE);
  129.     }
  130. }
  131.  
  132. /*ARGSUSED*/
  133. BOOL
  134. argShort(ad, vp, copyf)
  135.     register ARGDESC *ad;
  136.     register char *vp;
  137.     BOOL copyf;
  138. {
  139.     auto char *vpp;
  140.     extern long strtol ARGS((char *, char **, int));
  141.  
  142.     *(short *) ad->ad_valp = (short) strtol(vp, &vpp, 0);
  143.     if (*vpp != '\0')
  144.     {
  145.         usrerr("invalid integer argument '%s' for %s",
  146.             vp, ad->ad_prompt);
  147.         return (FALSE);
  148.     }
  149.     else
  150.     {
  151.         return (TRUE);
  152.     }
  153. }
  154.  
  155. /*ARGSUSED*/
  156. BOOL
  157. argLong(ad, vp, copyf)
  158.     register ARGDESC *ad;
  159.     register char *vp;
  160.     BOOL copyf;
  161. {
  162.     auto char *vpp;
  163.     extern long strtol ARGS((char *, char **, int));
  164.  
  165.     *(long *) ad->ad_valp = strtol(vp, &vpp, 0);
  166.     if (*vpp != '\0')
  167.     {
  168.         usrerr("invalid integer argument '%s' for %s",
  169.             vp, ad->ad_prompt);
  170.         return (FALSE);
  171.     }
  172.     else
  173.     {
  174.         return (TRUE);
  175.     }
  176. }
  177.  
  178. struct booltab
  179. {
  180.     char    *bname;        /* string to match against */
  181.     char    bneedmatch;    /* number of characters that must match */
  182.     BOOL    bval;        /* value to use */
  183. };
  184.  
  185. STATIC struct booltab    _BoolTab[] =
  186. {
  187.     "yes",        1,    TRUE,
  188.     "no",        1,    FALSE,
  189.     "true",        1,    TRUE,
  190.     "false",    1,    FALSE,
  191.     "on",        2,    TRUE,
  192.     "off",        3,    FALSE,
  193.     CHARNULL
  194. };
  195.  
  196. /*ARGSUSED*/
  197. BOOL
  198. argBool(ad, vp, copyf)
  199.     register ARGDESC *ad;
  200.     register char *vp;
  201.     BOOL copyf;
  202. {
  203.     register struct booltab *b;
  204.     register char *cp;
  205.     int l;
  206.  
  207.     /* convert input to lower case */
  208.     for (l = 0, cp = vp; *cp != '\0'; l++, cp++)
  209.     {
  210.         if (isupper(*cp))
  211.             *cp = tolower(*cp);
  212.     }
  213.  
  214.     /* search for a match in the table */
  215.     for (b = _BoolTab; b->bname != CHARNULL; b++)
  216.     {
  217.         /* if too short, don't even bother trying */
  218.         if (l < b->bneedmatch)
  219.             continue;
  220.  
  221.         if (bcmp(vp, b->bname, l) == 0)
  222.         {
  223.             /* got a match */
  224.             *(BOOL *) ad->ad_valp = b->bval;
  225.             return (TRUE);
  226.         }
  227.     }
  228.  
  229.     usrerr("invalid Boolean argument '%s' for %s", vp, ad->ad_prompt);
  230.     return (FALSE);
  231. }
  232.  
  233. #ifdef TRACESTUFF
  234. /*ARGSUSED*/
  235. BOOL
  236. argTrace(ad, vp, copyf)
  237.     register ARGDESC *ad;
  238.     register char *vp;
  239.     BOOL copyf;
  240. {
  241.     traceset(vp);
  242.     return (TRUE);
  243. }
  244. #endif
  245.  
  246. /*ARGSUSED*/
  247. BOOL
  248. argEnd(ad, vp, copyf)
  249.     register ARGDESC *ad;
  250.     register char *vp;
  251.     BOOL copyf;
  252. {
  253.     return (FALSE);
  254. }
  255.  
  256. BOOL
  257. argList(ad, vp, copyf)
  258.     register ARGDESC *ad;
  259.     register char *vp;
  260.     BOOL copyf;
  261. {
  262.     char *cp;
  263.     struct namelist *nl;
  264.  
  265.     if (copyf)
  266.     {
  267.         register int i;
  268.  
  269.         i = strlen(vp) + 1;
  270.         cp = (char *) malloc(i);
  271.         if(!cp) {
  272.             usrerr("out of memory saving string %s", ad->ad_prompt);
  273.             return FALSE;
  274.         }
  275.         bcopy(vp, cp, i);
  276.     }
  277.     else
  278.     {
  279.         cp = vp;
  280.     }
  281.  
  282.     nl = (struct namelist *) malloc(sizeof *nl);
  283.     if(!nl) {
  284.         usrerr("out of memory saving arg %s", ad->ad_prompt);
  285.         if(copyf) free(cp);
  286.         return FALSE;
  287.     }
  288.  
  289.     nl->nl_next = *(struct namelist **) ad->ad_valp;
  290.     nl->nl_name = cp;
  291.     *(struct namelist **) ad->ad_valp = nl;
  292.     return (TRUE);
  293. }
  294.