home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / dos / directry / ztwildc / zglob.c
Encoding:
C/C++ Source or Header  |  1992-09-21  |  6.6 KB  |  179 lines
  1. /*-------------------------------- ZGLOB.C (version 1.0) ----------------------*
  2. *
  3. * NAME:
  4. *
  5. *      zglob - Zortech C++ v3.0 command line filename wildcard expansion.
  6. *
  7. * SYNOPSIS:
  8. *
  9. *      int zglob(argc, argv, attr) 
  10. *      int *argc;           <- pointer to argument.
  11. *      char **argv[];       <- pointer to argument array pointer.
  12. *      int attr;            <- file type search attributes.
  13. *
  14. * DESCRIPTION:
  15. *
  16. *      Zglob() expands command line arguments containing '*' and/or '?' into
  17. *      existing file names. The wildcards can be in the file name or extension,
  18. *      but not the path. The function arguments 'argc' and 'argv' are replaced 
  19. *      with the expanded argument count and list. Individual wildcard file name
  20. *      arguments are sorted alphabetically in the expanded argument list. The 
  21. *      attribute argument is the file attribute of the files to be found. An 
  22. *      attribute value of 0 will find all normal files. The attribute bits are
  23. *      defined in <dos.h>.
  24. * 
  25. *      Errors encountered during the expansion process (no match, no memory) are
  26. *      written to ERROR. Zglob() returns a 1 on success, or a 0 on failure.
  27. *      
  28. *      Zglob() uses the Zortech C++ v3.0 library functions findfirst() and 
  29. *      findnext(). All other function calls are ANSI compliant. A singly linked
  30. *      list is first built containing pointers to the expanded file names. When
  31. *      the original argument list is exhausted, an array of pointers (argv) to 
  32. *      character strings is allocated. The argument pointers in the linked list
  33. *      are then copied to the new argv. A vector of integers, which point to 
  34. *      where to old arguments start in the new argv, is also built. The integer
  35. *      vector is used with qsort() to alphabetize individual wildcard arguments.
  36. *
  37. * USAGE:
  38. *
  39. *      main(int argc, char *argv[])
  40. *      {
  41. *         int i;
  42. *         if( !zglob(&argc,&argv,0))            <-- call with 0 attr.
  43. *             return EXIT_FAILURE;              <-- an errror occured, bye!
  44. *         for( i=0; i<argc, i++) { ... }        <-- as before, but expanded.
  45. *         
  46. * AUTHOR:
  47. *
  48. *      Version 1.0 - Jeff Dragovich (09/21/92).
  49. *
  50. * ACKNOWLEDGEMENTS:
  51. *
  52. *      This routine is modeled after, and very similar to GLOB.C, v1.06, written
  53. *      by Bob Kamins (11/28/87).
  54. *
  55. * BUGS:
  56. *
  57. *      Allocated memory is not free()'d when an error occurs. 
  58. *      File name expansion is attempted on all arguments containing a wildcard.
  59. *      Old argv and argc are lost forever.
  60. *
  61. *-----------------------------------------------------------------------------*/
  62. #include <stdio.h>  
  63. #include <dos.h>
  64. #include <string.h>
  65. #include <stdlib.h>
  66. #include <io.h>
  67.  
  68. int glob(int *, char ***, int);                 
  69. static int insert(char *);                          
  70. static int expand(char *, int);
  71. static int fcmp( char **, char **);
  72.  
  73. typedef struct node Node;         /* linked list node */
  74. struct node {
  75.     char *s;
  76.     Node *pn;
  77. };
  78.  
  79. #define ERROR stdout              /* predefined error output stream */
  80.  
  81. static struct node *phead;        /* pointer to list head */
  82. static struct node *ptail;        /* pointer to list tail */
  83. static int newc;                  /* new number of arguments */
  84. static int *srtz;                 /* integer array of pointers to elements of */
  85.                                   /* old arguments start location in new argv */
  86.  
  87. /*------------------------------------------------------------------- zglob() */
  88. int zglob(int *argc, char **argv[], int attr)
  89. {
  90.     int i;
  91.     char **pnew;
  92.     char err[] = "memory allocation error in zglob() : %s\n";
  93.     struct node *pcurr,*pnext;
  94.  
  95.     newc = 0;       /* just to make sure */
  96.     phead = NULL;
  97.  
  98.     srtz = (int *)malloc( (*argc+1)*sizeof(int) );    /* integer vector */
  99.     if( srtz == NULL )    {
  100.         fprintf(ERROR,err,"srtz");
  101.         return(0);
  102.     }
  103.  
  104.     for( i=0; i<*argc; i++) {               /* expand all arguments */
  105.         srtz[i] = newc;
  106.         if( !expand( (*argv)[i], attr ) ) return(0);
  107.     }
  108.     srtz[*argc] = newc;
  109.  
  110.     pnew = (char **)malloc( newc*sizeof(char *) );   /* new argv */
  111.     if( pnew == NULL ) {
  112.         fprintf(ERROR,err,"pnew");
  113.         return(0);
  114.     }
  115.     for( i=0, pcurr=phead; i<newc; i++) {     /* write over to new argv */
  116.         pnew[i] = pcurr->s;
  117.         pnext = pcurr->pn;
  118.         free(pcurr);                          /* free up node */
  119.         pcurr = pnext;
  120.     }
  121.     *argv = pnew;
  122.  
  123.     /* sort new argv by reference to old argv elements location */
  124.  
  125.     for( i=1; i<*argc; i++) 
  126.         qsort( &((*argv)[srtz[i]]), srtz[i+1]-srtz[i], sizeof(char**), fcmp);
  127.     *argc = newc;
  128.     free(srtz);
  129.     return(1);
  130. }
  131. /*------------------------------------------------------------------ expand() */
  132. static int expand( char *argv, int attr)
  133. {
  134.     int ret;
  135.     struct FIND *pfind;
  136.  
  137.     if( strpbrk(argv,"*?") == NULL )            /* is there a wildcard */
  138.         return( insert(argv) );                 /* no, but add to list */
  139.  
  140.     pfind = findfirst(argv,attr);               /* attempt to expand */
  141.     if( pfind == NULL ) {
  142.         fprintf(ERROR,"%s : No Match\n",argv);  /* must be a "no match" */
  143.         return(0);                              /* go back with error */
  144.     }
  145.     while( pfind != NULL ) {                    /* loop until no more matches */
  146.         ret = insert(pfind->name);      /* put expanded name in list */
  147.         if ( !ret ) return(ret);        /* must be a malloc error in insert() */
  148.         pfind = findnext();             /* get next match */
  149.     }     
  150.     return(1);                          /* everything ok */
  151. }
  152. /*------------------------------------------------------------------ insert() */
  153. static int insert(char *str)
  154. {
  155.     char *p;
  156.     struct node *nptr;
  157.  
  158.     p = (char *) malloc( strlen(str) + 1 );                /* new argv[i] */
  159.     nptr = (struct node *)malloc( sizeof(struct node) );   /* get node */
  160.     if( (p==NULL) || (nptr==NULL) ) {                      /* no memory */
  161.         fprintf(ERROR,"memory allocation failure in glob()->insert()\n");
  162.         return(0);
  163.     }
  164.     strcpy(p,str);                                     /* copy over to heap */
  165.     newc++;                                            /* another argument */
  166.  
  167.     if( phead == NULL ) phead = nptr;                  /* update linked list */
  168.     else ptail->pn = nptr;
  169.     ptail = nptr;
  170.     ptail->pn = NULL;
  171.     ptail->s = p;
  172.     return(1);
  173. }
  174. /*-------------------------------------------------------------------- fcmp() */
  175. static int fcmp( char **a, char **b )                  /* used by qsort */
  176. {
  177.     return( strcmp(*a,*b) );
  178. }
  179.