CopyFile XCMD
Volume Number: | | 5
|
Issue Number: | | 10
|
Column Tag: | | HyperChat
|
Related Info: File Manager
XCMD Corner: CopyFile
By Donald Koscheka, Arthur Young & Co., MacTutor Contributing Editor
Note: Source code files accompanying article are located on MacTech CD-ROM or source code disks.
CopyFile XCMD
From time to time I monitor the developer forums on AppleLink and MacNet to see what the rest of the Macintosh development community is up to. Recently, Richard Greenawalt of Foremost Computer Systems issued a request for some help. It seems he needed a routine that copies Macintosh files, data fork, resource fork and finder information.
Not one to miss an opportunity to write an interesting XCMD, I 'linked Rick back and told him that I would be happy to write the routine for him.
The moral of the story is: ask and you might receive. If you need some help with an XCMD or if this column just doesnt do it for you, let me know; I will be more than happy to help you out. Although I am up on AppleLink, I prefer to use MacNet (KOSCHEKA). If you dont have access to a modem, write me care of MacTutor.
Copying a Macintosh file is not difficult as long as you keep in mind that Mac files are really two files in one. Each file on the Macintosh has a split personality - the data fork and the resource fork. Although the two forks act as one entity, the file manager treats them as separate files.
CopyFile is a handy little XCMD that lets you copy files from Hypercard. Actually the routine is written to work from any programming milieu which is why Ive split it into two listings. The first consists of the Hypercard interface. Note that you need to pass both the file name and the working directory id. The second listing contains the actual code, void of any references to Hypercard. This approach lets me build libraries of usable routines that I can use with or without Hypercard, and I intend to use it for all future listings.
The CopyFile function expects to see the name of the input file, the name of the output file and the working directory ids of both. This gives you some flexibility in naming the copy as well as deciding what folder to put it in. For example, you can concatenate the name of the input file to copy of so that the duplicated file is called copy of file. Put this concept in a loop and you get the finder like capability of creating files and naming them copy of ... , copy of copy of ... and so on. I chose not to implement this approach because I think the user should have the opportunity to specify the name of the copied file.
Although there are several ways to go about copying a file, I chose a path that goes something like this: First, get the collective size of the data and resource fork along with the finder information about the input file. Using this information, attempt to create a file that is as large as the input file (ie as large as the data and resource fork combined). If the space can be allocated, then copy each fork in turn. If not, delete the newly created file and quit.
Space for each fork is allocated before we do the copy so that we can determine a priori whether the file will fit. To be safe, we reposition the file mark at the beginning of the file before we start copying. If, for any reason, the file copy fails, delete what remains of the file and return the error message to the caller.
The real work is done by the function, CopyFork. This routine will attempt to read the entire fork into a single buffer. Failing that, it divides the size in half until enough memory can be allocated to read some of the fork. Note that copyfork attempts to allocate a buffer large enough to read the entire fork into memory. If that much memory is not available, it keeps dividing the original size by two until a large enough buffer can be allocated.
Thats file copying in a nutshell. Its not particularly difficult once you realize that youre really copying two files - the data fork and the resource fork. Ive tried it with files up to 4 megabytes in size and it works fine.
/**********************************/
/* File: FileCopy.c*/
/* param0 = file reference num*/
/* ( file is open) IN: */
/* params[0]= name of input */
/* params[1]= wdid of input */
/* params[2] = name of output */
/* params[3] = wdid of output */
/**********************************/
#include<MacTypes.h>
#include<OSUtil.h>
#include<MemoryMgr.h>
#include<FileMgr.h>
#include<ResourceMgr.h>
#include<pascal.h>
#include<string.h>
#include HyperXCMD.h
#includeHyperUtils.h
pascal void main( paramPtr )
XCmdBlockPtr paramPtr;
/*****************************
*params[0]= name of input
*params[1]= wdid of input
*params[2] = name of output
*params[3] = wdid of output
*****************************/
{ OSErr err;
short inWD;
short outWD;
long temp;
Str31 errCode;
char inFile[256];
char outFile[256];
paramPtr->returnValue = 0L;
/*** (1) Get input parameters ***/
HLock( paramPtr->params[0] );
ZeroToPas( paramPtr, *(paramPtr->params[0]), &inFile );
HUnlock( paramPtr->params[0] );
inWD = (short)paramtoNum( paramPtr, 1 );
HLock( paramPtr->params[2] );
ZeroToPas( paramPtr, *(paramPtr->params[2]), &outFile );
HUnlock( paramPtr->params[2] );
outWD = (short)paramtoNum( paramPtr, 3 );
temp = (long)CopyFile( inFile, inWD, outFile, outWD );
/*** Flush the output volume ***/
err = FlushVol( 0L, 0 );
NumToStr( paramPtr, temp, &errCode );
paramPtr->returnValue = PasToZero( paramPtr, &errCode );
}
LISTING 1: CopyFile XCMD.
OSErr CopyFork( inref, outref, siz )
short inref; short outref; longsiz;
/*****************************
* Given that the caller has opened
* a fork and passed you the names of
* the input, copy the number of bytes
* from the input fork to the output
* fork.
* The input mark should be set to
* start of fork.
* We use a semi-smart algorithm
* to do the copy. If the entire
* fork can be copied, we try doing
* that, otherwise, we keep dividing
* the size by two until we get enough
* room to read some data in.
******************************/
{
OSErr rd_err = noErr;
OSErr wrt_err = noErr;
long rd_len; /*** actual bytes read ***/
Ptr inbuf;
/*** make sure that the size is even ***/
if( siz % 2 )
++siz;
if( siz > 0 ){
do{
inbuf = NewPtr( siz );
if( !inbuf )
siz = ( siz >> 1 );
}while( !inbuf );
/*** inbuf is the buffer that we ***/
/*** read the data into. If not ***/
/*** allocated, dont attempt to do ***/
/*** the read ***/
if( inbuf ){
do{
rd_len = siz;
rd_err = FSRead( inref, &rd_len, inbuf );
wrt_err= FSWrite( outref, &rd_len, inbuf );
}while( !rd_err && !wrt_err );
DisposPtr( inbuf );
}
}
return( wrt_err );
}
OSErr CopyFile( inFile, inWD, outFile, outWD )
char *inFile;
short inWD; char *outFile;
short outWD;
/*****************************
* (1) Determine the size of the input
* file.
* (2) Attempt to allocate that
* much space for the output file.
* (3) If allocation successful,
* create the output file.
* (4) Once the file is created,
* copy the data fork, the resource
* fork and the finder information
* from the input file.
* The file will be called copy of...
* Each time we create the file, first
* see if that name exists, if so, keep
* sticking copy of onto the name.
******************************/
{
OSErr err;
OSErr err2;
short inref;
short outref;
long data_eof = 0L;
long rsrc_eof = 0L;
FInfo fndrinfo;
/*** (2) Determine how big the input file is ***/
if( (err = FSOpen( inFile, inWD, &inref )) == noErr){
err = GetEOF( inref, &data_eof );
err = FSClose( inref );
}
if( (err = OpenRF( inFile, inWD, &inref )) == noErr ){
err = GetEOF( inref, &rsrc_eof );
err = FSClose( inref );
}
/*** (2) Create output file and allocate space***/
if( ( err = GetFInfo( inFile, inWD, &fndrinfo ) ) != noErr )
return( err );
if( ( err = Create( outFile, inWD, fndrinfo.fdCreator, fndrinfo.fdType
)) != noErr )
return( err );
/*** (3) Try to allocate enough space for both***/
/*** forks. Note that if we get enough space. ***/
if( (err = FSOpen( outFile, outWD, &outref )) != noErr)
return( err );
if( (err = SetEOF( outref, data_eof )) != noErr ){
err2 = FSClose( outref );
err2 = FSDelete( outFile, outWD );
return( err );
}
err2 = FSClose( outref );
err = OpenRF( outFile, outWD, &outref );
if( (err = SetEOF( outref, rsrc_eof )) != noErr ){
err2 = FSClose( outref );
err2 = FSDelete( outFile, outWD );
return( err );
}
err2 = FSClose( outref );
/*** (4) Copy the Data fork***/
err = FSOpen( inFile, inWD, &inref );
if( !err ){
err2 = SetFPos( inref, fsFromStart, 0L );
err = CopyFork( inref, outref, data_eof );
err2 = FSClose( inref );
err2 = FSClose( outref );
}
if( err ){
err2 = FSDelete( outFile, outWD );
return( err );
}
/*** (5) Now copy the resource fork ***/
err = OpenRF( inFile, inWD, &inref );
if( !err ){
err2 = SetFPos( inref, fsFromStart, 0L );
err = OpenRF( outFile, outWD, &outref );
err = CopyFork( inref, outref, rsrc_eof );
err2 = FSClose( inref );
err2 = FSClose( outref );
}
if( err ){
err2 = FSDelete( outFile, outWD );
return( err );
}
return( noErr );
}
LISTING 2: CopyFile and CopyFork Functions.