home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 7 / 07.iso / c / c072 / 1.ddi / PRG5_7.C < prev    next >
Encoding:
C/C++ Source or Header  |  1987-09-19  |  5.0 KB  |  160 lines
  1. /*Program 5_7 - Copy/Find all files matching a pattern
  2.    by Stephen R. Davis, 1987
  3.  
  4.   Search all subdirectories for a particular file pattern.  All files
  5.   found matching that pattern are copied to the target path, if present.
  6.  
  7.   If a file is found on the target disk with the same name, it is not
  8.   overwritten.  Thus, if more than one file exists in the subdirectory
  9.   tree with the same name, only the first one will get copied.
  10.  
  11.   It is possible to specify a starting point.  For example,
  12.            prg5_7 c:\user\*.* b:
  13.   copies all of the files found in \USER and all of its subdirectories.
  14. */
  15.  
  16. #include <stdio.h>
  17. #include <dir.h>
  18. #include <io.h>
  19. #include <dos.h>
  20. #include <process.h>
  21. #include <fcntl.h>
  22. #include <conio.h>
  23. #include <ctype.h>
  24.  
  25. /*prototyping definitions*/
  26. void main (unsigned, char **);
  27. void copyall (char *, char *, char *);
  28. void copy (char *, char *);
  29. void append (char *, char *, char *);
  30.  
  31. /*Main - parse user input and start the ball rolling*/
  32. void main (argc, argv)
  33.      unsigned argc;
  34.      char *argv [];
  35. {
  36.      char sourcedisk [MAXDRIVE], sourcedir [MAXDIR];
  37.      char sourcefile [MAXFILE], sourceext [MAXEXT];
  38.      char fromdir [MAXPATH], pattern [MAXFILE+MAXEXT];
  39.  
  40.      /*check the argument count*/
  41.      if (argc == 1 || argc > 3) {
  42.           printf ("Wrong number of arguments\n"
  43.                   "  try 'prg5_7 <source> [<dest>]' to copy all"
  44.                   "  files from source and all of it's \n"
  45.                   "  subdirectories to destination.\n"
  46.                   "  e.g., prg5_7 c:\*.* d: to copy the entire\n"
  47.                   "  contents of C disk to D.\n"
  48.                   "  (Simply find if no destination present)\n");
  49.           exit (1);
  50.      }
  51.  
  52.      /*parse argument 1 into its two halves*/
  53.      fnsplit (argv [1], sourcedisk, sourcedir, sourcefile, sourceext);
  54.  
  55.      /*now reconstruct the two halves*/
  56.      fnmerge (fromdir, sourcedisk, sourcedir,          0,         0);
  57.      fnmerge (pattern,          0,         0, sourcefile, sourceext);
  58.  
  59.      /*now just copy them all over*/
  60.      copyall (fromdir, pattern, argv [2]);
  61.  
  62.      /*exit normally*/
  63.      exit (0);
  64. }
  65.  
  66. /*Copyall - copy all files matching a given pattern from the
  67.             current directory and all subdirectories*/
  68. void copyall (fromdir, pattern, todir)
  69.      char *fromdir, *pattern, *todir;
  70. {
  71.      char spath [MAXPATH], tpath [MAXPATH];
  72.      struct ffblk block;
  73.  
  74.      /*first copy all files patching the pattern*/
  75.      append (spath, fromdir, pattern);
  76.      if (!findfirst (spath, &block, 0))
  77.           do {
  78.                append (spath, fromdir, block.ff_name);
  79.                append (tpath,   todir, block.ff_name);
  80.  
  81.                /*if destination present, copy; else just find*/
  82.                if (todir) {
  83.                     printf ("\nCopying %s -> %s", spath, tpath);
  84.                     copy (spath, tpath);
  85.                } else {
  86.                     printf ("\nFound %s    -- continue?", spath);
  87.                     if (tolower (getche ()) == 'n') exit (1);
  88.                }
  89.  
  90.  
  91.           } while (!findnext (&block));
  92.  
  93.      /*now check all subdirectories*/
  94.      append (spath, fromdir, "*");
  95.      if (!findfirst (spath, &block, FA_DIREC))
  96.           do {
  97.  
  98.                /*only pay attention to directories*/
  99.                if (block.ff_attrib & FA_DIREC)
  100.  
  101.                     /*ignore directories '.' and '..'*/
  102.                     if (block.ff_name [0] != '.') {
  103.  
  104.                          /*now tack on name of directory + '\'*/
  105.                          append (spath, fromdir, block.ff_name);
  106.                          append (spath, spath, "\\");
  107.  
  108.                          /*and copy its contents too*/
  109.                          copyall (spath, pattern, todir);
  110.                     }
  111.           } while (!findnext (&block));
  112. }
  113.  
  114. /*Copy - given two patterns, copy the source to the destination file*/
  115. #define NSECT 17
  116. void copy (from, to)
  117.      char *from, *to;
  118. {
  119.      int fhandle, thandle, number;
  120.      char buffer [NSECT*512];
  121.  
  122.      /*open the source for reading binary*/
  123.      _fmode = O_BINARY;
  124.      if ((fhandle = open (from, O_RDONLY)) == -1) {
  125.           perror ("\nError opening source file");
  126.           return;
  127.      }
  128.  
  129.      /*now open the destination*/
  130.      if ((thandle = creatnew (to, 0)) == -1) {
  131.           perror ("\nError opening target file");
  132.           close (fhandle);
  133.           return;
  134.      }
  135.  
  136.      /*now perform the copy*/
  137.      while (number = read (fhandle, buffer, NSECT*512))
  138.           if (number != _write (thandle, buffer, number)) {
  139.                fprintf (stderr, "\nError on writing target file");
  140.                break;
  141.           }
  142.      close (fhandle);
  143.      close (thandle);
  144. }
  145.  
  146. /*Append - concatenate two strings together*/
  147. void append (to, from1, from2)
  148.      char *to, *from1, *from2;
  149. {
  150.      /*copy the first string*/
  151.      while (*from1)
  152.           *to++ = *from1++;
  153.  
  154.      /*now the second*/
  155.      while (*from2)
  156.           *to++ = *from2++;
  157.  
  158.      /*and then tack on a terminator*/
  159.      *to = '\0';
  160. }