home *** CD-ROM | disk | FTP | other *** search
/ DOS/V Power Report 1997 March / VPR9703A.ISO / VPR_DATA / DOGA / SOURCES / REND.LZH / REND / DIR.C < prev    next >
C/C++ Source or Header  |  1996-07-16  |  6KB  |  306 lines
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <ctype.h>
  5. #ifdef __BORLANDC__
  6. #include <malloc.h>
  7. #include <memory.h>
  8. #include <alloc.h>
  9. #endif
  10.  
  11.  
  12. #define    MAXARGS        1024
  13. #define    MAXARGBUF    4096
  14. #define MAXINDBUF    1024
  15.  
  16. /*
  17.     proto -s dir.c > temp
  18. */
  19. static    int        _extendargs( int, char*[], int, char*[] );
  20. static    int        extendwild(char *, int, char*[]);
  21. static    char    *dfind( char*, int );
  22. static    char    *dnext( void );
  23.  
  24. static    char    *argbuf = NULL ;
  25. static    int        argremain;
  26. static    char    *args[MAXARGS] ;
  27. static    char    *curargbuf ;
  28. static    int        nargs ;
  29.  
  30. int        extendargs( argcp, argvp, extn, ext )
  31. int        *argcp ;
  32. char    **argvp[] ;
  33. int        extn ;
  34. char    *ext[] ;
  35. {
  36. #if !defined(DJ) && !defined(UNIX)
  37.     int        stat ;
  38.     nargs = 1 ;
  39.     args[0] = **argvp ;
  40.     if (argbuf == NULL) {
  41.         argbuf = malloc(MAXARGBUF);
  42.         argremain = MAXARGBUF;
  43.     }
  44.     curargbuf = argbuf ;
  45.  
  46.     stat = _extendargs( *argcp, *argvp, extn, ext );
  47.     *argcp = nargs ;
  48.     *argvp = args ;
  49.     return( stat );
  50. #else
  51.     int i = 1, nargc = 1, j;
  52.     int        stat ;
  53.     char *p;
  54.  
  55.     if (argbuf == NULL) {
  56.         argbuf = malloc(MAXARGBUF);
  57.         argremain = MAXARGBUF;
  58.     }
  59.     curargbuf = argbuf ;
  60.     args[0] = **argvp ;
  61.     nargs = 1;
  62.     stat = _extendargs( *argcp, *argvp, extn, ext );
  63.     for (i = 1; i < nargs; ++i) {
  64.         p = strrchr( args[i], '.' );
  65.         if ( args[i][0] == '-' || args[i][0] == '/'
  66.          || p == NULL ) {
  67.             args[nargc++] = args[i];
  68.         } else {
  69.             for( j = 0 ; j < extn ; ++j ) {
  70.                 if ( strcmpi( p, ext[j] ) == 0 )
  71.                     break ;
  72.             }
  73.             if ( j < extn )
  74.             {
  75.                 args[nargc++] = args[i];
  76.             }
  77.         }
  78.     }
  79. #if 0
  80.     for (i = 0; i < nargc; ++i) {
  81.         printf("(%d)=%s\n", i, args[i]);
  82.     }
  83. #endif
  84.     *argcp = nargc ;
  85.     *argvp = args ;
  86.     return stat;
  87. #endif
  88. }
  89.  
  90. static    int        _extendargs( argc, argv, extn, ext )
  91. int        argc ;
  92. char    *argv[] ;
  93. int        extn ;
  94. char    *ext[] ;
  95. {
  96.     int        i;
  97.     char    *cargv;
  98.  
  99.     for( i = 1 ; i < argc ; ++i )
  100.     {
  101.         cargv = argv[i] ;
  102.         if ( nargs >= MAXARGS )
  103.             return( -1 );
  104.  
  105.         if ( cargv[0] == '@' || cargv[0] == '#')
  106.         {
  107.             FILE *fp;
  108.             char str[MAXINDBUF], *sp, *ep;
  109.             if ((fp = fopen(cargv+1, "r")) != NULL) {
  110.                 while (fgets(str,MAXINDBUF-1,fp) != NULL) {
  111.                     sp = str;
  112.                     while (*sp) {
  113.                         while (*sp && isspace(*sp)){
  114.                             sp++;
  115.                         }
  116.                         if (*sp == 0) {
  117.                             break;
  118.                         }
  119.                         for (ep = sp; *ep && !isspace(*ep); ++ep)
  120.                             ;
  121.                         if (*ep == 0) {
  122.                             ep[1] = 0;
  123.                         }
  124.                         *ep = 0;
  125.                         if ( strchr( sp, '*' ) != NULL || strchr( sp, '?' ) != NULL ) {
  126.                             extendwild(sp, extn, ext);
  127.                         } else {
  128.                             int l;
  129.                             l = strlen(sp)+1;
  130.                             if (argremain < l) {
  131.                                 argbuf = malloc(MAXARGBUF);
  132.                                 curargbuf = argbuf;
  133.                                 argremain = MAXARGBUF;
  134.                             }
  135.                             argremain -= l+1;
  136.                             strcpy(curargbuf, sp);
  137.                             args[nargs++] = curargbuf ;
  138.                             curargbuf += l+1;
  139.                         }
  140.                         sp = ep+1;
  141.                     }
  142.                 }
  143.             }
  144.         }
  145.         else if ( cargv[0] == '-' || cargv[0] == '/' )
  146.         {
  147.             args[nargs++] = cargv ;
  148.         }
  149.         else
  150.         {
  151.             if ( strchr( cargv, '*' ) != NULL || strchr( cargv, '?' ) != NULL ) {
  152.                 extendwild(cargv, extn, ext);
  153.             } else {
  154.                 args[nargs++] = cargv ;
  155.             }
  156.         }
  157.     }
  158.     return( 0 );
  159. }
  160.  
  161. static int extendwild(cargv, extn, ext)
  162. char *cargv;
  163. int extn;
  164. char *ext[];
  165. {
  166.     int     j, len ;
  167.     char    *file, *p ;
  168.  
  169.     file = dfind( cargv, 0x20 );
  170.     p = strrchr( cargv, '\\' );
  171.     if ( p == NULL )
  172.         p = strchr( cargv, ':' );
  173.     if ( p != NULL )
  174.         *(p+1) = '\0' ;
  175.     else
  176.         cargv = "" ;
  177.  
  178.     while( file != NULL )
  179.     {
  180.         if ( nargs >= MAXARGS )
  181.             return( -1 );
  182.         p = strrchr( file, '.' );
  183.         if ( p != NULL )
  184.         {
  185.             for( j = 0 ; j < extn ; ++j )
  186.             {
  187.                 if ( strcmpi( p, ext[j] ) == 0 )
  188.                     break ;
  189.             }
  190.             if ( j < extn )
  191.             {
  192.                 len = strlen( cargv ) + strlen( file ) + 1 ;
  193. #if 0
  194.                 if ( curargbuf + len >= argbuf + MAXARGBUF )
  195.                     return( -1 );
  196. #else
  197.                 if (argremain < len) {
  198.                     argbuf = malloc(MAXARGBUF);
  199.                     curargbuf = argbuf;
  200.                     argremain = MAXARGBUF;
  201.                 }
  202. #endif
  203.                 strcpy( curargbuf, cargv );
  204.                 strcat( curargbuf, file );
  205.                 args[nargs++] = curargbuf ;
  206.                 curargbuf += len ;
  207.                 argremain -= len;
  208.             }
  209.         }
  210.         file = dnext();
  211.     }
  212.     return 0;
  213. }
  214.  
  215. /*
  216.  *        directry search
  217.  */
  218.  
  219. #ifdef    X68000
  220.     #include <doslib.h>
  221.     static    struct    FILBUF        buf ;
  222. #endif
  223. #ifdef    MSC
  224.     #include <dos.h>
  225.     static    union    REGS    in, out ;
  226.     static    struct    SREGS    seg ;
  227.     static    char    *dta ;
  228. #endif
  229. #if defined(DJ) || defined(__BORLANDC__)
  230.     #include <dir.h>
  231.     static struct ffblk buf;
  232. #endif
  233.  
  234. static    char    *dfind( name, attr )
  235. char    *name ;
  236. int        attr ;
  237. {
  238.  
  239. #ifdef    X68000
  240.  
  241.     if ( FILES( &buf, (UBYTE*)name, attr ) != 0 )
  242.         return( NULL );
  243.     return( (char *)buf.name );
  244.  
  245. #endif /* XC */
  246.  
  247. #ifdef    MSC
  248.  
  249.     segread( &seg );
  250.  
  251.     /*    DTA アドレスの読み出し  */
  252.     in.h.ah = 0x2F ;
  253.     intdosx( &in, &out, &seg );
  254.     FP_SEG( dta ) = seg.es ;
  255.     FP_OFF( dta ) = out.x.bx ;
  256.  
  257.     /*  ディレクトリサーチ  */
  258.     in.h.ah = 0x4E ;
  259.     in.x.dx = FP_OFF( name );
  260.     in.x.cx = attr ;
  261.     seg.ds = FP_SEG( name );
  262.     intdosx( &in, &out, &seg );
  263.  
  264.     if( out.x.cflag )
  265.         return( NULL );
  266.     return( dta+0x1E );
  267.  
  268. #endif /* MSC */
  269.  
  270. #if defined(DJ) || defined(__BORLANDC__)
  271.     if ( findfirst( name, &buf, attr ) != 0 )
  272.         return( NULL );
  273.     return( buf.ff_name );
  274. #endif
  275. }
  276.  
  277. static    char    *dnext()
  278. {
  279. #ifdef    X68000
  280.  
  281.     if ( NFILES( &buf ) != 0 )
  282.         return( NULL );
  283.     return( (char *)buf.name );
  284.  
  285. #endif /* XC */
  286.  
  287. #ifdef    MSC
  288.  
  289.     in.h.ah = 0x4F ;
  290.     intdos( &in, &out );
  291.  
  292.     if( out.x.cflag )
  293.         return( NULL );
  294.     return( dta+0x1E );
  295.  
  296. #endif /* MSC */
  297.  
  298. #if defined(DJ) || defined(__BORLANDC__)
  299.     if (findnext(&buf) != 0)
  300.         return NULL;
  301.     return buf.ff_name;
  302. #endif
  303.  
  304. }
  305.  
  306.