/*__________________________________________________________________________*/
Boolean SaveDriverState (short refnum, StringPtr file, OSType creator, OSType type)
{
FSSpec spec; OSErr err; TDriverInfos dInfos;
long size, dirID; short vrefNum, ref;
Ptr ptr;
if (FindMidiShareFolder (true, &vrefNum, &dirID) != noErr) return false;
if (!MidiGetDriverInfos (refnum, &dInfos)) return false;
size = Get1DriverStateSize (dInfos.slots);
if (!size) return true;
ptr = NewPtrSys(size);
if (!ptr) return false;
Get1DriverState (refnum, dInfos.slots, ptr, size);
err = FSMakeFSSpec(vrefNum, dirID, file, &spec);
if (err == fnfErr)
err = FSpCreate (&spec, creator, type, smSystemScript);
if (err != noErr) goto err;
err = FSpOpenDF (&spec, fsWrPerm, &ref);
if (err != noErr) goto err;
err = FSWrite (ref, &size, ptr);
FSClose (ref);
DisposePtr (ptr);
return err == noErr;
err:
DisposePtr (ptr);
return false;
}
int sqCopyFilesizetosize(char *srcNameIndex, int srcNameSize, char *dstNameIndex, int dstNameSize) {
OSErr error;
FSSpec srcSpec,dstFileSpec,dstSpec;
char *pointer;
const int desiredBufferSize = 64*1024;
FSpLocationFromFullPath(srcNameSize,srcNameIndex,&srcSpec);
FSpLocationFromFullPath(dstNameSize,dstNameIndex,&dstFileSpec);
FSMakeFSSpecCompat(dstFileSpec.vRefNum, dstFileSpec.parID, "\p:", &dstSpec);
#if TARGET_API_MAC_CARBON
pointer = NewPtr(desiredBufferSize);
#else
pointer = NewPtr(desiredBufferSize);
if (pointer == NULL)
pointer = NewPtrSys(desiredBufferSize);
if (pointer == NULL)
return false;
#endif
error = FSpFileCopy(&srcSpec,
&dstSpec,
dstFileSpec.name,
pointer,
desiredBufferSize,
false);
DisposePtr((void *)pointer);
return error;
}
int sqCopyDirectorysizetosize(char *srcNameIndex, int srcNameSize, char *dstNameIndex, int dstNameSize) {
OSErr error;
FSSpec srcSpec,dstSpec,dstFolderSpec;
char *pointer;
const int desiredBufferSize = 64*1024;
char name[256];
memmove(name,srcNameIndex,srcNameSize);
memmove(name+srcNameSize,":",1);
FSpLocationFromFullPath(srcNameSize+1,name,&srcSpec);
memmove(name,dstNameIndex,dstNameSize);
memmove(name+dstNameSize,":",1);
FSpLocationFromFullPath(dstNameSize+1,name,&dstFolderSpec);
FSMakeFSSpecCompat(dstFolderSpec.vRefNum, dstFolderSpec.parID, "\p:", &dstSpec);
#if TARGET_API_MAC_CARBON
pointer = NewPtr(desiredBufferSize);
#else
pointer = NewPtr(desiredBufferSize);
if (pointer == NULL)
pointer = NewPtrSys(desiredBufferSize);
if (pointer == NULL)
return false;
#endif
memmove(name,dstFolderSpec.name,sizeof(dstFolderSpec.name));
error = FSpDirectoryCopy(&srcSpec,
&dstSpec,
(ConstStr255Param) &name,
pointer,
desiredBufferSize,
false,
&handleDupError);
DisposePtr((void *)pointer);
return error;
}
/*__________________________________________________________________________*/
void RestoreDriverState (short refnum, StringPtr file)
{
long size, dirID; short vrefNum, ref; Ptr ptr;
OSErr err; FSSpec spec; TDriverInfos dInfos;
if (FindMidiShareFolder (false, &vrefNum, &dirID) != noErr) return;
if (!MidiGetDriverInfos (refnum, &dInfos)) return;
FSMakeFSSpec(vrefNum, dirID, file, &spec);
err = FSpOpenDF (&spec, fsRdPerm, &ref);
if (err != noErr) return;
size = GetFileSize (&spec);
if (size) {
ptr = NewPtrSys (size);
if (ptr) {
err = FSRead (ref, &size, ptr);
if (err == noErr)
Set1DriverState (refnum, dInfos.slots, ptr, size);
DisposePtr (ptr);
}
}
FSClose (ref);
}
/*******************************************************************************
* UnpackPiData expands a compressed section into memory.
*******************************************************************************/
static OSErr UnpackPiData(
LogicalAddress thePEFPtr,
SectionHeaderPtr sectionHeaderPtr,
LogicalAddress * theData)
{
int cntX, cnt, rpt, dcnt, delta;
unsigned char op, b;
unsigned char * unpackBuffer;
unsigned char * originalUnpackBuffer;
unsigned char * endUnpackBuffer;
unsigned char * oldRawBuffer;
int oldRawBufferRemaining;
unsigned char * rawBuffer;
int rawBufferRemaining;
// Verify incoming section is packed.
if (sectionHeaderPtr->regionKind != kPIDataSection) {
return kIOPEFparamErr;
}
// Allocate memory to unpack into
originalUnpackBuffer = (unsigned char*)NewPtrSys(sectionHeaderPtr->initSize);
if (originalUnpackBuffer == nil) {
return kIOPEFmemFullErr;
}
unpackBuffer = originalUnpackBuffer;
endUnpackBuffer = unpackBuffer + sectionHeaderPtr->initSize;
rawBuffer = (unsigned char*)((uintptr_t)thePEFPtr +
sectionHeaderPtr->containerOffset);
rawBufferRemaining = sectionHeaderPtr->rawSize;
/* Expand the pidata instructions. EOF will terminate processing
* through the setjmp on pidData_jmpbuf above...
*/
while (rawBufferRemaining > 0) {
/*****
* The first byte of each instruction contains the opcode and a count.
* If the countis 0, the count starts in the next byte...
*/
/* Pick up the opcode and first count operand...
*/
b = PEFGetNextByte(&rawBuffer, &rawBufferRemaining);
op = PIOP(b);
cnt = PICNT(b);
if (cnt == 0) {
cnt = PEFGetCount(&rawBuffer, &rawBufferRemaining);
}
/* Unpack the data as a function of the opcode...
*/
switch (op) {
case kZero: // zero out cnt bytes...
if (unpackBuffer + cnt > endUnpackBuffer) {
goto Error;
}
memset(unpackBuffer, 0, cnt);
unpackBuffer += cnt;
break;
case kBlock: // copy cnt bytes...
if (unpackBuffer + cnt > endUnpackBuffer) {
goto Error;
}
while (--cnt >= 0) {
*unpackBuffer++ = PEFGetNextByte(&rawBuffer, &rawBufferRemaining);
}
break;
case kRepeat: // copy cnt bytes rpt times...
rpt = PEFGetCount(&rawBuffer, &rawBufferRemaining) + 1;
if (cnt == 1) {
if (unpackBuffer + rpt > endUnpackBuffer) {
goto Error;
}
b = PEFGetNextByte(&rawBuffer, &rawBufferRemaining);
memset(unpackBuffer, b, rpt);
unpackBuffer += rpt;
} else {
oldRawBufferRemaining = rawBufferRemaining;
oldRawBuffer = rawBuffer;
while (--rpt >= 0) {
if (unpackBuffer + cnt > endUnpackBuffer) {
goto Error;
}
rawBufferRemaining = oldRawBufferRemaining;
rawBuffer = oldRawBuffer;
cntX = cnt;
while (--cntX >= 0) {
*unpackBuffer++ = PEFGetNextByte(&rawBuffer,
&rawBufferRemaining);
}
}
}
break;
case kRepeatZero: //copy cnt 0's and dcnt bytes rpt times
dcnt = PEFGetCount(&rawBuffer, &rawBufferRemaining); // ...then copy cnt more 0's
rpt = PEFGetCount(&rawBuffer, &rawBufferRemaining);
goto rptPart1; // jump into loop to copy 0's first...
while (--rpt >= 0) {
if (unpackBuffer + dcnt > endUnpackBuffer) {
goto Error;
}
cntX = dcnt; // cnt repeating parts follow each other
while (--cntX >= 0) {
*unpackBuffer++ = PEFGetNextByte(&rawBuffer,
&rawBufferRemaining);
}
rptPart1: // non-repeating part is always 0's...
if (unpackBuffer + cnt > endUnpackBuffer) {
goto Error;
}
memset(unpackBuffer, 0, cnt);
unpackBuffer += cnt;
}
break;
case kRepeatBlock: // copy cnt repeating bytes and dcnt
dcnt = PEFGetCount(&rawBuffer, &rawBufferRemaining); /* non-repating bytes rcnt times... */
rpt = PEFGetCount(&rawBuffer, &rawBufferRemaining); /* ...then copy cnt repeating bytes */
oldRawBufferRemaining = rawBufferRemaining;
oldRawBuffer = rawBuffer;
delta = 0; /* the repeating part and each non-rep */
goto rptPart2; /* jump into loop to copy rptng part 1st */
while (--rpt >= 0) {
if (unpackBuffer + dcnt > endUnpackBuffer) {
goto Error;
}
rawBuffer = oldRawBuffer + cnt + delta;
rawBufferRemaining = oldRawBufferRemaining - (cnt + delta);
cntX = dcnt;
while (--cntX >= 0) {
*unpackBuffer++ = PEFGetNextByte(&rawBuffer,
&rawBufferRemaining);
}
delta += dcnt;
rptPart2:
if (unpackBuffer + cnt > endUnpackBuffer) {
goto Error;
}
rawBuffer = oldRawBuffer;
rawBufferRemaining = oldRawBufferRemaining;
cntX = cnt;
while (--cntX >= 0) {
*unpackBuffer++ = PEFGetNextByte(&rawBuffer,
&rawBufferRemaining);
}
}
rawBuffer = oldRawBuffer + cnt + delta;
rawBufferRemaining = oldRawBufferRemaining - (cnt + delta);
break;
default:
goto Error;
break;
} /* switch */
} /* for */
*theData = originalUnpackBuffer;
return noErr;
Error:
if (unpackBuffer)
DisposePtr((Ptr)originalUnpackBuffer);
*theData = nil;
return kIOPEFparamErr;
}
