home *** CD-ROM | disk | FTP | other *** search
/ The Fred Fish Collection 1.5 / ffcollection-1-5-1992-11.iso / ff_progs / prog_c / dmake.lzh / DMAKE / EXPAND.C < prev    next >
Encoding:
C/C++ Source or Header  |  1991-08-15  |  5.2 KB  |  267 lines
  1.  
  2. /*
  3.  *  EXPAND.C
  4.  *
  5.  */
  6.  
  7. #include "defs.h"
  8.  
  9. #include <exec/memory.h>
  10.  
  11. extern void *AllocMem();
  12. extern struct FileLock *Lock();
  13. extern struct FileLock *CurrentDir();
  14.  
  15. #ifndef NULL
  16. #define NULL 0L
  17. #endif
  18.  
  19. struct DPTR {             /* Format of directory fetch pointer */
  20.    struct FileLock *lock;     /* lock on directory    */
  21.    struct FileInfoBlock *fib;     /* mod'd fib for entry */
  22. };
  23.  
  24. struct DPTR *
  25. dopen(name, stat)
  26. char *name;
  27. register int *stat;
  28. {
  29.     register struct DPTR *dp;
  30.  
  31.     *stat = 0;
  32.     dp = (struct DPTR *)malloc(sizeof(struct DPTR));
  33.     /*
  34.     *if (*name == '\0')
  35.     *     dp->lock = DupLock (Clock);
  36.     *else
  37.     */
  38.     dp->lock = Lock (name, ACCESS_READ);
  39.     if (dp->lock == NULL) {
  40.     free (dp);
  41.     return (NULL);
  42.     }
  43.     dp->fib = (struct FileInfoBlock *)AllocMem(sizeof(struct FileInfoBlock), MEMF_PUBLIC);
  44.     if (!Examine (dp->lock, dp->fib)) {
  45.     perror (name);
  46.     dclose (dp);
  47.     return (NULL);
  48.     }
  49.     if (dp->fib->fib_DirEntryType >= 0)
  50.     *stat = 1;
  51.     return (dp);
  52. }
  53.  
  54. dnext(dp, pname, stat)
  55. register struct DPTR *dp;
  56. char **pname;
  57. int *stat;
  58. {
  59.     if (dp == NULL)
  60.     return (0);
  61.     if (ExNext (dp->lock, dp->fib)) {
  62.     *stat = (dp->fib->fib_DirEntryType < 0) ? 0 : 1;
  63.     *pname = dp->fib->fib_FileName;
  64.     return (1);
  65.     }
  66.     return (0);
  67. }
  68.  
  69.  
  70. dclose(dp)
  71. register struct DPTR *dp;
  72. {
  73.     if (dp == NULL)
  74.     return (1);
  75.     if (dp->fib)
  76.     FreeMem (dp->fib, sizeof(*dp->fib));
  77.     if (dp->lock)
  78.     UnLock (dp->lock);
  79.     free (dp);
  80.     return (1);
  81. }
  82.  
  83.  
  84. isdir(file)
  85. char *file;
  86. {
  87.     register struct DPTR *dp;
  88.     int stat;
  89.  
  90.     stat = 0;
  91.     if (dp = dopen (file, &stat))
  92.     dclose(dp);
  93.     return (stat == 1);
  94. }
  95.  
  96.  
  97. free_expand(av)
  98. register char **av;
  99. {
  100.     register char **base = av;
  101.  
  102.     if (av) {
  103.     while (*av) {
  104.         free (*av);
  105.         ++av;
  106.     }
  107.     free (base);
  108.     }
  109. }
  110.  
  111. /*
  112.  * EXPAND(wild_name, pac)
  113.  *    wild_name      - char * (example: "df0:*.c")
  114.  *    pac         - int  *  will be set to # of arguments.
  115.  */
  116.  
  117.  
  118. char **
  119. expand(base, pac)
  120. char *base;
  121. int *pac;
  122. {
  123.     register char *ptr;
  124.     char **eav = (char **)malloc (sizeof(char *));
  125.     short eleft, eac;
  126.     char *name;
  127.     char *bname, *ename, *tail;
  128.     int stat, scr;
  129.     register struct DPTR *dp;
  130.  
  131.     *pac = eleft = eac = 0;
  132.  
  133.     base = strcpy(malloc(strlen(base)+1), base);
  134.     for (ptr = base; *ptr && *ptr != '?' && *ptr != '*'; ++ptr);
  135.     for (; ptr >= base && !(*ptr == '/' || *ptr == ':'); --ptr);
  136.     if (ptr < base) {
  137.     bname = strcpy (malloc(1), "");
  138.     } else {
  139.     scr = ptr[1];
  140.     ptr[1] = '\0';
  141.     bname = strcpy (malloc(strlen(base)+1), base);
  142.     ptr[1] = scr;
  143.     }
  144.     ename = ptr + 1;
  145.     for (ptr = ename; *ptr && *ptr != '/'; ++ptr);
  146.     scr = *ptr;
  147.     *ptr = '\0';
  148.     tail = (scr) ? ptr + 1 : (char *)NULL;
  149.  
  150.     if ((dp = dopen (bname, &stat)) == NULL  ||  stat == 0) {
  151.     free (bname);
  152.     free (base);
  153.     free (eav);
  154.     puts ("Could not open directory");
  155.     return (NULL);
  156.     }
  157.     while (dnext (dp, &name, &stat)) {
  158.     if (WildCmp(ename, name)) {
  159.         if (tail) {
  160.         int alt_ac;
  161.         char *search, **alt_av, **scrav;
  162.         struct FileLock *lock;
  163.  
  164.         if (!stat)           /* expect more dirs, but this not a dir */
  165.             continue;
  166.         lock = CurrentDir (dp->lock);
  167.         search = malloc(strlen(name)+strlen(tail)+2);
  168.         strcpy (search, name);
  169.         strcat (search, "/");
  170.         strcat (search, tail);
  171.         scrav = alt_av = expand (search, &alt_ac);
  172.         CurrentDir (lock);
  173.         if (scrav) {
  174.             while (*scrav) {
  175.             if (eleft < 2) {
  176.                 char **scrav = (char **)malloc(sizeof(char *) * (eac + 10));
  177.                 movmem(eav, scrav, (eac + 1) << 2);
  178.                 free (eav);
  179.                 eav = scrav;
  180.                 eleft = 10;
  181.             }
  182.             eav[eac] = malloc(strlen(bname)+strlen(*scrav)+1);
  183.             strcpy(eav[eac], bname);
  184.             strcat(eav[eac], *scrav);
  185.             free (*scrav);
  186.             ++scrav;
  187.             --eleft, ++eac;
  188.             }
  189.             free (alt_av);
  190.         }
  191.         } else {
  192.         if (eleft < 2) {
  193.             char **scrav = (char **)malloc(sizeof(char *) * (eac + 10));
  194.             movmem(eav, scrav, (eac + 1) << 2);
  195.             free (eav);
  196.             eav = scrav;
  197.             eleft = 10;
  198.         }
  199.         eav[eac] = malloc (strlen(bname)+strlen(name)+1);
  200.         eav[eac] = strcpy(eav[eac], bname);
  201.         strcat(eav[eac], name);
  202.         --eleft, ++eac;
  203.         }
  204.     }
  205.     }
  206.     dclose (dp);
  207.     *pac = eac;
  208.     eav[eac] = NULL;
  209.     free (bname);
  210.     free (base);
  211.     if (eac)
  212.     return (eav);
  213.     free (eav);
  214.     return (NULL);
  215. }
  216.  
  217. /*
  218.  *  OUTDATED()
  219.  *
  220.  *  if date(dest) < date(src) return true
  221.  */
  222.  
  223. OutDated(dest, src, validright)
  224. char *dest, *src;
  225. short *validright;
  226. {
  227.     struct FileLock *lock, *lock2;
  228.     FIB *fib = malloc(sizeof(FIB));
  229.     DATESTAMP Ds;
  230.     short result = 1;
  231.  
  232.     if (lock = Lock(dest, SHARED_LOCK)) {
  233.     if (Examine(lock, fib) && fib->fib_DirEntryType < 0) {
  234.         Ds = fib->fib_Date;
  235.         if (lock2 = Lock(src, SHARED_LOCK)) {
  236.         if (Examine(lock2, fib) && fib->fib_DirEntryType < 0) {
  237.             if (Ds.ds_Days > fib->fib_Date.ds_Days)
  238.             result = 0;
  239.             else if (Ds.ds_Days == fib->fib_Date.ds_Days) {
  240.             if (Ds.ds_Minute > fib->fib_Date.ds_Minute)
  241.                 result = 0;
  242.             else if (Ds.ds_Minute == fib->fib_Date.ds_Minute) {
  243.                 if (Ds.ds_Tick > fib->fib_Date.ds_Tick)
  244.                 result = 0;
  245.             }
  246.             }
  247.         }
  248.         UnLock(lock2);
  249.         }
  250.     }
  251.     UnLock(lock);
  252.     }
  253.     if (result == 0) {
  254.     *validright = 1;
  255.     } else {
  256.     *validright = 0;
  257.     if (lock = Lock(src, SHARED_LOCK)) {
  258.         if (Examine(lock, fib) && fib->fib_DirEntryType < 0)
  259.         *validright = 1;
  260.         UnLock(lock);
  261.     }
  262.     }
  263.     free(fib);
  264.     return(result);
  265. }
  266.  
  267.