Remaining documentation is further notes on directories for Copyit v4.1a:

Note: To copy a directory structure to another, specify both source and
 destination, for example:

  Copyit c:\temp /dd:\ /r/b2

 will copy the structure c:\temp to d:\temp and create the destination
 directory if it does not exist.

Note: Copyit uses directory construction, for example: if directory
 d:\1\2\3 exists, and the following is used:

  Copyit d:\1 /dd:\tmp /r/b1

 then the directory structure d:\tmp\1\2\3 will be constructed.

Note: Copyit will create nested subdirectories, for example: if d:\1\2\3
 exists and d:\x\y\z does not, and you try:

  Copyit d:\1 /dd:\x\y\z /r/b1

 then d:\x\y\z\1\2\3 will be created.

Note: Relative directories also includes default directories prepended to the
 destination directory from the target drive\directory. For example, if the
 drive D: directory has been changed to D:\tmp then using,

  Copyit *.tmp /dd:

 will copy the files with extension .tmp to the directory \tmp on drive D:

 Also, if drive D: default directory opened has subdirectory t1, then using,

  Copyit *.tmp /dd:t1

 will copy the files with extension .tmp to the directory \tmp\t1 on
 drive D:

 And, parent directory .. may be used, for example,

  Copyit *.tmp /d..

 will copy the files to the directory previous to the current one. Other
 forms could include:

  Copyit *.bak /d..\tmp2

 However, directory . does nothing since it is the current directory. For
 example, the following would be invalid:

  Copyit *.bak /d.

 would only attempt to copy the files onto itself. Except if . is included
 with a subdirectory to the one specified, for example:

  Copyit *.bkp /d.\tmp2

 although this is equivalent to:

  Copyit *.bkp /dtmp2

Note: Using /r/b2 to a directory structure which also exists with /w will
 allow the files to be updated, for example, using:

  Copyit c:\windows /dd:\ /r/b2/w

 will copy the previously existing files without prompting to over-write
 them. This is useful for backing up directories.

Note: If the source path is the same as the destination path, and /b1 or /b2
 used to copy directory structure is specified, then the error:

  "Directory cannot be copied onto itself."

 will be displayed and copying halted. Also, if the source path is the
 first part of the destination path, and /r/b1 or /r/b2 is specified to
 recursively copy directory structure, for example from \tmp to \tmp\t1
 then the error message:

  "Directory cannot be recursively copied onto itself."

 will be displayed. Otherwise, the second error message will not appear
 when the source path is both the first and last part of the destination
 path, because the last target directory is in the root, for example:

  Copyit \ /d\work /r/b2

 will copy all the directories, then try to copy \work to \work, and copying
 \work to \work will be ignored as a recursive error.

Note: Copyit will copy windows DOS 7.10 long filenames if specified in quotes,
 for example:

  Copyit "c:\program files" /d"d:\program files" /r/b2

 would recreate the windows program files directory (the progra~1 is also
 preserved) and all subdirectories, and all files (including the long
 filenames in the subdirectories).

Note: Since ambiguation is forced during copies to similar directories, the
 copy of 'progra~1' to d:, then the copy of 'program files' to d: will
 cause the second copy to ambiguate to 'progra~2' even though the long
 directory filename will be created. For example:

  Copyit c:\progra~1 /dd:\progra~1 /r/b2

 followed by

  Copyit "c:\program files" /d"d:\program files" /r/b2

 will cause the second directory 8.3 filename to be progra~2.

Note: If the directory structure already exists then the subdirectory will be
 created. For example, to update a directory structure without creating the
 subdirectory in its structure, use:

  Copyit c:\progra~1 /dc:\program.bkp /r/b2

 to rename progra~1 to program.bkp as the destination directory since the
 switch /b2 causes the first level of the recursion to be omitted.

 This is useful for the similar extended explanation:

 Copying c:\dir1\files1\files2 to c:\dir2 using

  Copyit c:\dir1 /dc:\dir2 /r/b1

 creates c:\dir2\dir1\files2\files3, since this is valid, using /b2 to
 override the recursion nesting using:

  Copyit c:\dir1 /dc:\dir2 /r/b/b2

 creates c:\dir2\files2\files3, therefore this method of using /b2 allows
 for backing up c:\progra~1 in the above example to c:\program.bkp without
 placing the first directory c:\progra~1 in c:\program.bkp since you can't
 copy c:\temp to c:\temp using /r/b1 or /r/b2.

Note: Copying directory structures more than 260 characters long to a
 destination directory, causing the copy to fail for the directory; Copyit
 will continue anyway with /r/b1 or /r/b2 because the recursively nested
 directories may not exist, and have to be created to copy the imbedded files.

Directory structure copy flowcharts:

 Copyit c:\Dir1 /dc:\Dir2 /r/b1    Copyit c:\Dir1 /dc:\Dir2 /r/b2
  c:\       c:\                     c:\       c:\
 Dir1  --> Dir2                    Dir1  --> Dir2
  +-temp1   +-Dir1                  +-temp1   +-temp1
  +-temp2      +-temp1              +-temp2   +-temp2
               +-temp2

 Copyit c:\Dir1 /dd:\ /r/b1        Copyit c:\Dir1 /dd:\ /r/b2
  c:\       d:\                     c:\       d:\
 Dir1  --> Dir1                    Dir1  --> temp1
  +-temp1   +-temp1                 +-temp1  temp2
  +-temp2   +-temp2                 +-temp2

End of further notes on directories.
