home *** CD-ROM | disk | FTP | other *** search
/ Simtel MSDOS 1992 June / SIMTEL_0692.cdr / msdos / c / help.arc / GETARGS.C < prev    next >
C/C++ Source or Header  |  1988-03-10  |  5KB  |  264 lines
  1. /*
  2. *
  3. * Getargs.c
  4. *
  5. *!AU: Michael A. Shiels
  6. *!CD: 21-May-86
  7. *!FR: Dr. Dobb's May 1985
  8. *
  9. */
  10.  
  11. #define GETARGS_C
  12. #define LINT_ARGS
  13. #include    <stdio.h>
  14. #include    <stdlib.h>
  15. #include    "masdos.h"
  16. #include    "maserr.h"
  17. #include    "getargs.h"
  18.  
  19. extern    void    usage( void );
  20. extern    int        stoi( char ** );
  21.  
  22. typedef int    (*PFI)();
  23.  
  24. char    ARG_Switch = '/';
  25. int        ARG_ICase = 0;
  26. static    char    getsoptb[100];
  27.  
  28. static  char    *setarg( argp, linep )
  29. ARG        *argp ;
  30. char    *linep ;
  31. {
  32.     ++linep ;
  33.  
  34.     switch( argp->type )
  35.     {
  36.     case    ARG_INTEGER :
  37.             *argp->variable = stoi( &linep ) ;
  38.             break ;
  39.  
  40.     case    ARG_FBOOLEAN :
  41.             *argp->variable = 1;
  42.             break ;
  43.  
  44.     case    ARG_TBOOLEAN :
  45.             *argp->variable = 0;
  46.             break ;
  47.  
  48.     case    ARG_SBOOLEAN :
  49.             *argp->variable = ( *argp->variable ? 0 : 1 );
  50.             break ;
  51.  
  52.     case    ARG_CHARACTER :
  53.             *argp->variable = *linep++ ;
  54.             break ;
  55.  
  56.     case    ARG_STRING :
  57.             *(char **)argp->variable = linep ;
  58.             linep = "" ;
  59.             break;
  60.     
  61.     case    ARG_PROCESS :
  62.             (* (PFI)(argp->variable) )( linep );
  63.             linep = "";
  64.             break;        
  65.  
  66.     default :
  67.             fprintf( stderr, "GetArgs: Internal Error: Bad Argument Type\n" );
  68.             break ;
  69.     }
  70.     return( linep ) ;
  71. }
  72.  
  73. static  ARG     *findarg( c, tabp, tabsize )
  74. int         c, tabsize ;
  75. ARG         *tabp ;
  76. {
  77.     for( ; --tabsize >= 0 ; tabp++ )
  78.     {
  79.         if( ARG_ICase && toupper(tabp->arg) == toupper(c) )
  80.             return( tabp );
  81.         if( tabp->arg == c )
  82.             return( tabp );
  83.         }
  84.         return( NULL );
  85. }
  86.  
  87. static  pr_usage( tabp, tabsize )
  88. ARG        *tabp;
  89. int        tabsize;
  90. {
  91.     for( ; --tabsize >= 0 ; tabp++ )
  92.     {
  93.         switch( tabp->type )
  94.         {
  95.         case    ARG_INTEGER :
  96.                 fprintf(stderr, "%c%c<num> %-40s (value is ",
  97.                     ARG_Switch, tabp->arg, tabp->errmsg) ;
  98.                 fprintf(stderr, "%-5d)\n", *(tabp->variable) ) ;
  99.                 break ;
  100.  
  101.         case    ARG_TBOOLEAN :
  102.                 fprintf(stderr, "%c%c T    %-40s (value is ",
  103.                     ARG_Switch, tabp->arg, tabp->errmsg) ;
  104.                 fprintf(stderr, "%-5s)\n", *(tabp->variable)
  105.                     ? "True" : "False") ;
  106.                 break ;
  107.  
  108.         case    ARG_SBOOLEAN :
  109.                 fprintf(stderr, "%c%c S    %-40s (value is ",
  110.                     ARG_Switch, tabp->arg, tabp->errmsg) ;
  111.                 fprintf(stderr, "%-5s)\n", *(tabp->variable)
  112.                     ? "True" : "False") ;
  113.                 break ;
  114.  
  115.         case    ARG_FBOOLEAN :
  116.                 fprintf(stderr, "%c%c F    %-40s (value is ",
  117.                     ARG_Switch, tabp->arg, tabp->errmsg) ;
  118.                 fprintf(stderr, "%-5s)\n", *(tabp->variable)
  119.                     ? "True" : "False") ;
  120.                 break ;
  121.  
  122.         case    ARG_CHARACTER :
  123.                 fprintf(stderr, "%c%c<c>   %-40s (value is ",
  124.                     ARG_Switch, tabp->arg, tabp->errmsg) ;
  125.                 fprintf(stderr, "%-5c)\n", *(tabp->variable) ) ;
  126.                 break ;
  127.  
  128.         case    ARG_STRING :
  129.                 fprintf(stderr, "%c%c<str> %-40s (value is ",
  130.                     ARG_Switch, tabp->arg, tabp->errmsg) ;
  131.                 fprintf(stderr, "<%s>)\n",
  132.                     *(char **)tabp->variable) ;
  133.                 break ;
  134.  
  135.         case     ARG_PROCESS :
  136.                 fprintf(stderr, "%c%c<str> %-40s\n",
  137.                         ARG_Switch, tabp->arg, tabp->errmsg);
  138.                 break;
  139.         }
  140.     }
  141. }
  142.  
  143. #define ARG_ERRMSG "Illegal argument <%c>. Legal arguments are:\n\n"
  144.  
  145. int         getargs( argc, argv, tabp, tabsize )
  146. int         argc, tabsize ;
  147. char        **argv ;
  148. ARG         *tabp ;
  149. {
  150.     register int    nargc ;
  151.     register char   **nargv, *p ;
  152.     register ARG    *argp ;
  153.     char buf[2], *bufp = buf;
  154.  
  155.     if( (bufp = getenv("SWITCHAR")) )
  156.         ARG_Switch = *bufp;
  157.  
  158.     nargc = 1 ;
  159.     for( nargv = ++argv ; --argc > 0 ; argv++ )
  160.     {
  161.         if( **argv != ARG_Switch || !strcmp( *argv, "-" ) )
  162.         {
  163.             *nargv++ = *argv ;
  164.             nargc++ ;
  165.         }
  166.         else
  167.         {
  168.             p = ( *argv ) + 1 ;
  169.  
  170.             while( *p )
  171.             {
  172.                 if( *p == ARG_Switch )
  173.                     p++;
  174.                 else if( argp = findarg( *p, tabp, tabsize ) )
  175.                 {
  176.                     p = setarg( argp, p ) ;
  177.                 }
  178.                 else
  179.                 {
  180.                     usage();
  181.                     fprintf( stderr, ARG_ERRMSG, *p );
  182.                     pr_usage( tabp, tabsize );
  183.                     exit( E_USAGE );
  184.                 }
  185.             }
  186.         }
  187.     }
  188.     return nargc ;
  189. }
  190.  
  191. void    getopts( tabp, tabsize, opts )
  192. int        tabsize ;
  193. ARG        *tabp ;
  194. char    *opts;
  195. {
  196.     register char   *p ;
  197.     register ARG    *argp ;
  198.     char *buf, *bufp;
  199.  
  200.     if( (buf = getmenv(opts)) )
  201.     {
  202.         while( bufp = next( &buf, ',', -1 ) )
  203.         {
  204.             p = ( bufp );
  205.             while( *p )
  206.             {
  207.                 if( argp = findarg( *p, tabp, tabsize ) )
  208.                 {
  209.                     p = setarg( argp, p ) ;
  210.                 }
  211.                 else
  212.                 {
  213.                     usage();
  214.                     fprintf( stderr, ARG_ERRMSG, *p );
  215.                     pr_usage( tabp, tabsize );
  216.                     exit( E_USAGE );
  217.                 }
  218.             }
  219.         }
  220.     }
  221. }
  222.  
  223. void    getsopts( tabp, tabsize, file )
  224. int        tabsize ;
  225. ARG        *tabp ;
  226. char    *file;
  227. {
  228.     register    char    *p ;
  229.     register    ARG        *argp ;
  230.     char    *buf = getsoptb,    *bufp = getsoptb;
  231.     FILE    *fp = NULL;
  232.  
  233.     strcat( getsoptb, getmenv("GETSOPTS") );
  234.     strcat( getsoptb, file );
  235.  
  236.     if( (fp = fopen(getsoptb, "r")) )
  237.     {
  238.         if( !getl( getsoptb, 255, fp) )
  239.         {
  240.             fclose( fp );
  241.             return;
  242.         }
  243.         else
  244.         {
  245.             while( bufp = next( &buf, ',', -1 ) )
  246.             {
  247.                 p = ( bufp );
  248.                 while( *p )
  249.                 {
  250.                     if( argp = findarg( *p, tabp, tabsize ) )
  251.                         p = setarg( argp, p );
  252.                     else
  253.                     {
  254.                             usage();
  255.                             fprintf( stderr, ARG_ERRMSG, *p );
  256.                             pr_usage( tabp, tabsize );
  257.                             exit( E_USAGE );
  258.                     }
  259.                 }
  260.             }
  261.         }
  262.     }
  263. }
  264.