static toff_t _tiffSeekProc(thandle_t fd, toff_t off, int whence) { long fpos, size; if (GetEOF((short) fd, &size) != noErr) return EOF; (void) GetFPos((short) fd, &fpos); switch (whence) { case SEEK_CUR: if (off + fpos > size) SetEOF((short) fd, off + fpos); if (SetFPos((short) fd, fsFromMark, off) != noErr) return EOF; break; case SEEK_END: if (off > 0) SetEOF((short) fd, off + size); if (SetFPos((short) fd, fsFromStart, off + size) != noErr) return EOF; break; case SEEK_SET: if (off > size) SetEOF((short) fd, off); if (SetFPos((short) fd, fsFromStart, off) != noErr) return EOF; break; } return (toff_t)(GetFPos((short) fd, &fpos) == noErr ? fpos : EOF); }
static void SaveToPICT (SFReply *reply) { Rect MyPicFrame ; CQDProcs MyPicProcs,*SavePtr ; OSErr error ; long LongZero, LongCount ; short Counter ; CGrafPtr theCGrafPort; WindowPtr theWindow; OpenCPicParams myOpenCPicParams; /* get my window */ theWindow = myWindow.theWindow; theCGrafPort = (CGrafPtr) theWindow; error = FSOpen(reply->fName, reply->vRefNum, &FileSys_RefNR ) ; SetStdCProcs ( &MyPicProcs ) ; SavePtr = (CQDProcs *) theWindow->grafProcs; theWindow->grafProcs = (QDProcs *) (&MyPicProcs) ; MyPicProcs.putPicProc = NewQDPutPicProc(MyPutPicData) ; LongZero = 0 ; LongCount = 4 ; PicCounter = sizeof(Picture) ; for (Counter=1 ; Counter <= 128+sizeof(Picture) ; Counter++ ) error = FSWrite(FileSys_RefNR, &LongCount, &LongZero ); error = SetFPos(FileSys_RefNR, fsFromStart, 512+sizeof(Picture)) ; SetPort((GrafPtr)(theWindow)); MyPicFrame = ((GrafPtr)(theWindow))->portRect; MyPicFrame.right = MyPicFrame.right-16; MyPicFrame.bottom = MyPicFrame.bottom-16; MyPicHand = NULL ; myOpenCPicParams.srcRect = MyPicFrame; myOpenCPicParams.hRes = cHRes; myOpenCPicParams.vRes = cVRes; myOpenCPicParams.version = -2; myOpenCPicParams.reserved1 = 0; myOpenCPicParams.reserved2 = 0; MyPicHand = OpenCPicture ( &myOpenCPicParams ); ClipRect(&MyPicFrame); /* draw picture */ RefreshCommand(); ClosePicture() ; /* close File */ error = SetFPos(FileSys_RefNR, fsFromStart, 512) ; LongCount = sizeof(Picture) ; error = FSWrite(FileSys_RefNR, &LongCount, (void *) (*MyPicHand) ); error = FSClose(FileSys_RefNR) ; KillPicture(MyPicHand); theWindow->grafProcs = (QDProcs *) SavePtr ; return; }
void QTCmpr_PromptUserForDiskFileAndSaveCompressed (Handle theHandle, ImageDescriptionHandle theDesc) { FSSpec myFile; Boolean myIsSelected = false; Boolean myIsReplacing = false; short myRefNum = -1; StringPtr myImagePrompt = QTUtils_ConvertCToPascalString(kQTCSaveImagePrompt); StringPtr myImageFileName = QTUtils_ConvertCToPascalString(kQTCSaveImageFileName); OSErr myErr = noErr; // do a little parameter checking.... if ((theHandle == NULL) || (theDesc == NULL)) goto bail; if ((**theDesc).dataSize > GetHandleSize(theHandle)) goto bail; // prompt the user for a file to put the compressed image into; in theory, the name // should have a file extension appropriate to the type of compressed data selected by the user; // this is left as an exercise for the reader QTFrame_PutFile(myImagePrompt, myImageFileName, &myFile, &myIsSelected, &myIsReplacing); if (!myIsSelected) goto bail; HLock(theHandle); // create and open the file myErr = FSpCreate(&myFile, kImageFileCreator, (**theDesc).cType, 0); if (myErr == noErr) myErr = FSpOpenDF(&myFile, fsRdWrPerm, &myRefNum); if (myErr == noErr) myErr = SetFPos(myRefNum, fsFromStart, 0); // now write the data in theHandle into the file if (myErr == noErr) myErr = FSWrite(myRefNum, &(**theDesc).dataSize, *theHandle); if (myErr == noErr) myErr = SetFPos(myRefNum, fsFromStart, (**theDesc).dataSize); if (myErr == noErr) myErr = SetEOF(myRefNum, (**theDesc).dataSize); if (myRefNum != -1) myErr = FSClose(myRefNum); bail: free(myImagePrompt); free(myImageFileName); HUnlock(theHandle); }
OSErr PAS_decodeData(PASEntry *entry, FSSpec *outFile, short inRefNum) { OSErr err; short outRefNum; Ptr buffer; SInt32 currentWrite = PAS_BUFFER_SIZE; SInt32 totalSize; buffer = NewPtr(currentWrite); err = FSpOpenDF(outFile, fsRdWrPerm, &outRefNum); if (err != noErr) return err; err = SetFPos(inRefNum, fsFromStart, (*entry).entryOffset ); if (err != noErr) return err; err = SetFPos(outRefNum, fsFromStart, 0 ); if (err != noErr) return err; totalSize = (*entry).entryLength; while(totalSize > 0) { currentWrite = PAS_BUFFER_SIZE; if (totalSize < currentWrite) { currentWrite = totalSize; } err = FSRead( inRefNum, ¤tWrite, buffer); if (err != noErr && err != eofErr) return err; err = FSWrite(outRefNum, ¤tWrite, buffer); if (err != noErr) return err; totalSize = totalSize - currentWrite; } FSClose(outRefNum); DisposePtr(buffer); return noErr; }
int __PHYSFS_platformSeek(void *opaque, PHYSFS_uint64 pos) { SInt16 ref = *((SInt16 *) opaque); OSErr err = SetFPos(ref, fsFromStart, (SInt32) pos); BAIL_IF_MACRO(oserr(err) != noErr, NULL, 0); return(1); } /* __PHYSFS_platformSeek */
long file_seek(FILEH handle, long pointer, int method) { SInt32 pos; SInt32 setp; setp = pointer; switch(method) { case FSEEK_SET: break; case FSEEK_CUR: if (GetFPos(handle, &pos) != noErr) { return(-1); } setp += pos; break; case FSEEK_END: if (GetEOF(handle, &pos) != noErr) { return(-1); } setp += pos; break; default: return(-1); } SetFPos(handle, fsFromStart, setp); if (GetFPos(handle, &pos) != noErr) { return(-1); } return((long)pos); }
int TFRnd::GetFLen(){ int FPos=GetFPos(); EAssertR( fseek(FileId, 0, SEEK_END)==0, "Error seeking into file '"+TStr(FNm)+"'."); int FLen=GetFPos(); SetFPos(FPos); return FLen; }
/// Load page with given index from the file into buffer int TPgBlobFile::LoadPage(const uint32& Page, void* Bf) { SetFPos(Page * PG_PAGE_SIZE); EAssertR( fread(Bf, 1, PG_PAGE_SIZE, FileId) == PG_PAGE_SIZE, "Error reading file '" + TStr(FNm) + "'."); return 0; }
/// Save buffer to page within the file int TPgBlobFile::SavePage(const uint32& Page, const void* Bf, int Len) { SetFPos(Page * PG_PAGE_SIZE); Len = (Len <= 0 ? PG_PAGE_SIZE : Len); EAssertR( (Access != TFAccess::faRdOnly) && (int)fwrite(Bf, 1, Len, FileId) == Len, "Error writing file '" + TStr(FNm) + "'."); return 0; }
int TFIn::GetFLen() const { const int FPos=GetFPos(); EAssertR( fseek(FileId, 0, SEEK_END)==0, "Error seeking into file '"+GetSNm()+"'."); const int FLen=GetFPos(); SetFPos(FPos); return FLen; }
PicHandle OpenPICTFile( short vRefNum, Str255 fName) { short fRefNum; OSErr err; long curEOF; PicHandle myPic; long count; Ptr buffer; /* open PICT file */ err = FSOpen(fName, vRefNum, &fRefNum); if (err != 0) { /*printf("Error - cannot open file\n"); */ exit(-1); } /* get size of file */ err = GetEOF(fRefNum, &curEOF); if (err != 0) { /*printf("Error - cannot get EOF\n"); */ exit(-2); } /* move the file mark to 512 */ err = SetFPos(fRefNum, SEEK_SET, 512L); if (err != 0) { /*printf("Error - cannot seek 512\n"); */ exit(-3); } /* size of data to read */ count = curEOF - 512; /* create the PicHandle */ myPic = (PicHandle)NewHandle(count); HLock((Handle)myPic); /* read the PICT info */ buffer = (Ptr)(*myPic); err = FSRead(fRefNum, &count, buffer); if (err != 0) { /*printf("Error - cannot read\n");*/ exit(-4); } HUnlock((Handle)myPic); /* release the file */ err = FSClose(fRefNum); if (err != 0) { /*printf("Error - cannot close file \n"); */ exit(-5); } return (myPic); }
INT64 NCSFileSeek(int hFile, INT64 nOffset, int origin) { #ifdef WIN32 return((INT64)_lseeki64(hFile, (__int64)nOffset, origin)); #elif defined MACINTOSH long fpos, size; if (GetEOF((short) hFile, &size) != noErr) return EOF; (void) GetFPos((short) hFile, &fpos); switch (origin) { case SEEK_CUR: if (nOffset + fpos > size) SetEOF((short) hFile, nOffset + fpos); if (SetFPos((short) hFile, fsFromMark, nOffset) != noErr) return EOF; break; case SEEK_END: if (nOffset > 0) SetEOF((short) hFile, nOffset + size); if (SetFPos((short) hFile, fsFromStart, nOffset + size) != noErr) return EOF; break; case SEEK_SET: if (nOffset > size) SetEOF((short) hFile, nOffset); if (SetFPos((short) hFile, fsFromStart, nOffset) != noErr) return EOF; break; } return (INT64)(GetFPos((short) hFile, &fpos) == noErr ? fpos : EOF); #else /* WIN32 */ #error: NCSFileSeek() #endif /* WIN32 */ }
void *__PHYSFS_platformOpenAppend(const char *filename) { SInt16 *retval = macDoOpen(filename, fsRdWrPerm, 1); if (retval != NULL) /* got a file; seek to end. */ { if (oserr(SetFPos(*retval, fsFromLEOF, 0)) != noErr) { FSClose(*retval); return(NULL); } /* if */ } /* if */ return(retval); } /* __PHYSFS_platformOpenAppend */
void *__PHYSFS_platformOpenRead(const char *filename) { SInt16 *retval = macDoOpen(filename, fsRdPerm, 0); if (retval != NULL) /* got a file; seek to start. */ { if (oserr(SetFPos(*retval, fsFromStart, 0)) != noErr) { FSClose(*retval); return(NULL); } /* if */ } /* if */ return((void *) retval); } /* __PHYSFS_platformOpenRead */
void *__PHYSFS_platformOpenWrite(const char *filename) { SInt16 *retval = macDoOpen(filename, fsRdWrPerm, 1); if (retval != NULL) /* got a file; truncate it. */ { if ((oserr(SetEOF(*retval, 0)) != noErr) || (oserr(SetFPos(*retval, fsFromStart, 0)) != noErr)) { FSClose(*retval); return(NULL); } /* if */ } /* if */ return((void *) retval); } /* __PHYSFS_platformOpenWrite */
FILEH file_open_rb(const char *path) { FILEH ret; FSSpec fss; Str255 fname; mkstr255(fname, path); FSMakeFSSpec(0, 0, fname, &fss); if ((FSpOpenDF(&fss, fsRdWrShPerm, &ret) == noErr) || (FSpOpenDF(&fss, fsRdPerm, &ret) == noErr)) { SetFPos(ret, fsFromStart, 0); return(ret); } return(-1); }
write_backing_store (j_common_ptr cinfo, backing_store_ptr info, void FAR * buffer_address, long file_offset, long byte_count) { long bytes = byte_count; long retVal; if ( SetFPos ( info->temp_file, fsFromStart, file_offset ) != noErr ) ERREXIT(cinfo, JERR_TFILE_SEEK); retVal = FSWrite ( info->temp_file, &bytes, (unsigned char *) buffer_address ); if ( retVal != noErr || bytes != byte_count ) ERREXIT(cinfo, JERR_TFILE_WRITE); }
globle void GetSeekSetBinary( void *theEnv, long offset) { #if MAC SetFPos(SystemDependentData(theEnv)->BinaryRefNum,fsFromStart,offset); #endif #if IBM_TBC || IBM_MSC || IBM_ICB /* || IBM_MCW || IBM_ZTC */ lseek(SystemDependentData(theEnv)->BinaryFileHandle,offset,SEEK_SET); #endif #if (! MAC) && (! IBM_TBC) && (! IBM_MSC) && (! IBM_ICB) /* && (! IBM_MCW) && (! IBM_ZTC) */ fseek(SystemDependentData(theEnv)->BinaryFP,offset,SEEK_SET); #endif }
void XMLMacCarbonFile::reset() { OSErr err = noErr; if (!mFileValid) ThrowXML(XMLPlatformUtilsException, XMLExcepts::File_CouldNotResetFile); if (gHasHFSPlusAPIs) err = FSSetForkPosition(mFileRefNum, fsFromStart, 0); else err = SetFPos(mFileRefNum, fsFromStart, 0); if (err != noErr) ThrowXML(XMLPlatformUtilsException, XMLExcepts::File_CouldNotResetFile); }
P3(PUBLIC pascal trap, LONGINT, PutScrap, LONGINT, len, ResType, rest, Ptr, p) { OSErr retval; LONGINT l, swappedlen; INTEGER f; LONGINT *lp; if (Cx(ScrapState) < 0) { retval = ZeroScrap(); if (retval != noErr) /*-->*/ return(retval); } #if defined(X) || defined(NEXTSTEP) || defined (SDL) PutScrapX(rest, len, (char *) p, CW (ScrapCount)); #endif /* defined(X) */ if (Cx(ScrapState) == 0) { retval = FSOpen(MR(ScrapName), CW (BootDrive), &f); if (retval != noErr) /*-->*/ return(retval); SetFPos(f, fsFromStart, (LONGINT)Cx(ScrapSize)); l = 4; rest = CL(rest); FSWriteAll(f, &l, (Ptr) &rest); l = 4; swappedlen = CL(len); FSWriteAll(f, &l, (Ptr) &swappedlen); l = len = (len + 1) & -2L; FSWriteAll(f, &len, p); FSClose(f); } else { SetHandleSize(MR(ScrapHandle), (Size)Cx(ScrapSize) + 8); if (MemErr != noErr) /*-->*/ return CW(MemErr); /* alignment stuff */ lp = (LONGINT *)((char *)STARH(MR(ScrapHandle)) + Cx(ScrapSize)); *lp++ = CL(rest); *lp++ = CL(len); len = (len + 1) & -2L; PtrAndHand(p, MR(ScrapHandle), (Size)len); } ScrapSize = CL(CL(ScrapSize) + 8 + len); return noErr; }
void DebugStart(StringPtr s) { if (0 == gDebugRefNum) { // ask debug file FSSpec fspec = {0, 0, "\pDebugOutput.txt"}; OSErr err = noErr; // attempt to create, ignore error err = ::FSpCreate(&fspec, 'ttxt', 'TEXT', smSystemScript); err = ::FSpOpenDF(&fspec, fsCurPerm, &gDebugRefNum); if (err || 0 == gDebugRefNum) { SysBeep(0); return; } // always concat at end err = SetFPos(gDebugRefNum, fsFromLEOF, 0); }
FILEH file_create(const char *path) { FILEH ret; FSSpec fss; Str255 fname; OSType creator = kUnknownType; OSType fileType = kUnknownType; mkstr255(fname, path); FSMakeFSSpec(0, 0, fname, &fss); FSpDelete(&fss); if (FSpCreate(&fss, creator, fileType, smSystemScript) == noErr) { if ((FSpOpenDF(&fss, fsRdPerm | fsWrPerm, &ret) == noErr) || (FSpOpenDF(&fss, fsRdPerm, &ret) == noErr)) { SetFPos(ret, fsFromStart, 0); return(ret); } } return(-1); }
SHORT RIFFClass::RIFFSeek(INT lOffset, SHORT shWhence) { switch (byWhereIsRIFFData) { case RIFF_ONDISK: return (fseek(pFile, lOffset, shWhence)); //break; #ifdef USE_MACINTOSH case RIFF_ONMACDISK: if (shWhence == SEEK_SET) shWhence = fsFromStart; // 0 -> 1 else if (shWhence == SEEK_CUR) shWhence = fsFromMark; // 1 -> 3 else if (shWhence == SEEK_END) shWhence = fsFromLEOF; // 2 -> 2 return (SetFPos(fRefNum, shWhence, lOffset)); //break; #endif default: return(-1); } }
OSErr QTInfo_MakeFilePreview (Movie theMovie, short theRefNum, ICMProgressProcRecordPtr theProgressProc) { unsigned long myModDate; PreviewResourceRecord myPNOTRecord; long myEOF; long mySize; unsigned long myAtomHeader[2]; // an atom header: size and type OSType myPreviewType; OSErr myErr = noErr; ////////// // // determine whether theRefNum is a file reference number of a data fork or a resource fork; // if it's a resource fork, then we'll just call the existing ICM function MakeFilePreview // ////////// if (QTInfo_IsRefNumOfResourceFork(theRefNum)) { myErr = MakeFilePreview(theRefNum, theProgressProc); goto bail; } ////////// // // determine the preview type // ////////// // if the movie has a movie preview, use that as the file preview; otherwise use a thumbnail // of the movie poster frame as the file preview if (QTInfo_MovieHasPreview(theMovie)) myPreviewType = MovieAID; else myPreviewType = kQTFileTypePicture; ////////// // // construct the 'pnot' atom // ////////// // fill in the 'pnot' atom header myAtomHeader[0] = EndianU32_NtoB(sizeof(myAtomHeader) + sizeof(myPNOTRecord)); myAtomHeader[1] = EndianU32_NtoB(ShowFilePreviewComponentType); // fill in the 'pnot' atom data GetDateTime(&myModDate); myPNOTRecord.modDate = EndianU32_NtoB(myModDate); // the modification time of the preview myPNOTRecord.version = EndianS16_NtoB(0); // version number; must be 0 myPNOTRecord.resType = EndianU32_NtoB(myPreviewType); // atom type containing preview myPNOTRecord.resID = EndianS16_NtoB(1); // the 1-based index of the atom of the specified type to use ////////// // // write the 'pnot' atom at the end of the data fork // ////////// // get the current logical end-of-file and extend it by the desired amount myErr = GetEOF(theRefNum, &myEOF); if (myErr != noErr) goto bail; myErr = SetEOF(theRefNum, myEOF + sizeof(myAtomHeader) + sizeof(myPNOTRecord)); if (myErr != noErr) goto bail; // set the file mark myErr = SetFPos(theRefNum, fsFromStart, myEOF); if (myErr != noErr) goto bail; // write the atom header into the file mySize = sizeof(myAtomHeader); myErr = FSWrite(theRefNum, &mySize, myAtomHeader); if (myErr != noErr) goto bail; // write the atom data into the file mySize = sizeof(myPNOTRecord); myErr = FSWrite(theRefNum, &mySize, &myPNOTRecord); if (myErr != noErr) goto bail; ////////// // // write the preview data atom at the end of the data fork // ////////// if (myPreviewType == MovieAID) { // in theory, we don't need to do anything here, since our 'pnot' atom points // to the 'moov' atom; in practice, this doesn't work correctly (it seems like // a bug in StandardGetFilePreview) } if (myPreviewType == kQTFileTypePicture) { PicHandle myPicture = NULL; PicHandle myThumbnail = NULL; // get the poster frame picture myPicture = GetMoviePosterPict(theMovie); if (myPicture != NULL) { // create a thumbnail myThumbnail = (PicHandle)NewHandleClear(4); if (myThumbnail != NULL) { myErr = MakeThumbnailFromPicture(myPicture, 0, myThumbnail, theProgressProc); if (myErr == noErr) { myAtomHeader[0] = EndianU32_NtoB(sizeof(myAtomHeader) + GetHandleSize((Handle)myThumbnail)); myAtomHeader[1] = EndianU32_NtoB(myPreviewType); // write the atom header into the file mySize = sizeof(myAtomHeader); myErr = FSWrite(theRefNum, &mySize, myAtomHeader); if (myErr == noErr) { // write the atom data into the file mySize = GetHandleSize((Handle)myThumbnail); myErr = FSWrite(theRefNum, &mySize, *myThumbnail); } } KillPicture(myThumbnail); } KillPicture(myPicture); } } #if 0 // here's how you'd add a text preview; note that the text is hard-coded here.... if (myPreviewType == kQTFileTypeText) { char myText[] = "The penguin gradually appears from the mist of the ice floe."; myAtomHeader[0] = EndianU32_NtoB(sizeof(myAtomHeader) + strlen(myText)); myAtomHeader[1] = EndianU32_NtoB(myPreviewType); // write the atom header into the file mySize = sizeof(myAtomHeader); myErr = FSWrite(theRefNum, &mySize, myAtomHeader); if (myErr != noErr) goto bail; // write the atom data into the file mySize = strlen(myText); myErr = FSWrite(theRefNum, &mySize, myText); if (myErr != noErr) goto bail; } #endif #if TARGET_OS_MAC if (myErr == noErr) { short myVolNum; // flush the volume myErr = GetVRefNum(theRefNum, &myVolNum); if (myErr != noErr) goto bail; myErr = FlushVol(NULL, myVolNum); } #endif bail: return(myErr); }
void TFRnd::SetRecN(const int& RecN){ IAssert(RecAct); SetFPos(HdLen+RecN*RecLen); }
P3(PUBLIC pascal trap, LONGINT, GetScrap, Handle, h, ResType, rest, LONGINT *, off) { OSErr retval; LONGINT l = 0, incr, s, ltoread, restlen[2]; unsigned char *p; int found; INTEGER f; Handle temph; #if !defined (LETGCCWAIL) s = 0; #endif /* LETGCCWAIL */ if (h) temph = 0; else { temph = NewHandle((Size) 0); h = temph; } #if defined(X) || defined(NEXTSTEP) || defined (SDL) s = GetScrapX(rest, (char **) h); if (s >= 0) { *off = 0; /* ack... could mess people up */ /*-->*/ RETURN(s); } #endif /* defined(X) */ if (Cx(ScrapState) < 0) { retval = ZeroScrap(); if (retval != noErr) /*-->*/ RETURN(retval); } if (ScrapState == 0) { retval = FSOpen(MR(ScrapName), CW (BootDrive), &f); if (retval != noErr) /*-->*/ RETURN(retval); found = FALSE; while (l < Cx(ScrapSize) && !found) { ltoread = 8; FSReadAll(f, <oread, (Ptr) restlen); s = CL(restlen[1]); if (rest == CL(restlen[0])) found = TRUE; else { incr = (8 + s + 1) & ~1L; l += incr; SetFPos(f, fsFromMark, incr); } } if (l >= Cx(ScrapSize)) { FSClose(f); /*-->*/ RETURN(noTypeErr); } ReallocHandle(h, s); if (MemErr != noErr) /*-->*/ RETURN(CW(MemErr)); HLock(h); ltoread = s; FSReadAll(f, <oread, STARH(h)); HUnlock(h); FSClose(f); } else { HLock(MR(ScrapHandle)); p = MR(*(unsigned char **)MR(ScrapHandle)); #if 1 || !defined(QUADALIGN) while (l < Cx(ScrapSize) && rest != CL(*(LONGINT *)p)) { s = CL (*((LONGINT *) p + 1)); incr = (8 + s + 1) & ~1L; l += incr; p += incr; } if (l >= Cx(ScrapSize)) { HUnlock(MR(ScrapHandle)); /*-->*/ RETURN(noTypeErr); } s = CL (*((LONGINT *)p + 1)); #else /* QUADALIGN */ while (l < Cx(ScrapSize) && rest != SNAGLONG(p)) { incr = 8 + ((s = SNAGLONG(p + sizeof(LONGINT))) + 1) & -2L; l += incr; p += incr; } if (l >= Cx(ScrapSize)) { HUnlock(MR(ScrapHandle)); /*-->*/ RETURN(noTypeErr); } s = *((LONGINT *)p + 1); #endif /* QUADALIGN */ PtrToXHand((Ptr) (p+8), h, s); HUnlock(MR(ScrapHandle)); } *off = CL(l+8); RETURN(s); }
NCSError NCSRemoveDir( const char *pDirName) { #ifdef LINUX if(rmdir(pDirName) == 0) { #elif defined(_WIN32_WCE) if(RemoveDirectory(OS_STRING(pDirName)) != 0) { #else if(rmdir(pDirName) == 0) { #endif return(NCS_SUCCESS); } else { return(NCS_FILEIO_ERROR); } } /* ** Seek to given position */ INT64 NCSFileSeekNative(NCS_FILE_HANDLE hFile, INT64 nOffset, NCS_FILE_ORIGIN origin) { #if defined WIN32 LARGE_INTEGER li; li.QuadPart = nOffset; li.LowPart = SetFilePointer(hFile, // file handle li.LowPart, // low 32 bits &li.HighPart, // high 32 bits origin); // relative to start of file if( li.LowPart == 0xFFFFFFFF && GetLastError() != NO_ERROR ) return( -1 ); else return( li.QuadPart ); #elif defined PALM switch(origin) { case NCS_FILE_SEEK_START: hFile->iOffset = nOffset; break; case NCS_FILE_SEEK_CURRENT: hFile->iOffset += nOffset; break; case NCS_FILE_SEEK_END: hFile->iOffset = hFile->nDBSize + nOffset - 1; } return(hFile->iOffset); #elif defined MACINTOSH UINT32 myOffset; int result; myOffset = U32SetU(nOffset); if(!myOffset) result = 0; result = SetFPos((short)hFile, fsFromStart, myOffset); if(!result) return myOffset; else return (0); #elif defined SOLARIS return (INT64) llseek(hFile, (offset_t)nOffset, origin); #elif defined LINUX return (INT64) lseek64(hFile, (__off64_t)nOffset, origin); #elif defined HPUX return (INT64) lseek64(hFile, (off64_t)nOffset, origin); #elif defined IRIX return (INT64) lseek64(hFile, (off64_t)nOffset, origin); #elif defined MACOSX return (INT64) lseek(hFile, nOffset, origin); #endif } /* ** Get current file position */ INT64 NCSFileTellNative(NCS_FILE_HANDLE hFile) { #if defined WIN32 LARGE_INTEGER li; li.QuadPart = 0; li.LowPart = SetFilePointer(hFile, // file handle li.LowPart, // low 32 bits &li.HighPart, // high 32 bits FILE_CURRENT); // relative to present position if( li.LowPart == 0xFFFFFFFF && GetLastError() != NO_ERROR ) return(-1); else return(li.QuadPart); #elif defined MACINTOSH long myOffset; OSErr result; result = GetFPos((short)hFile, &myOffset); if (result==noErr) return ((INT64)myOffset); else return ((INT64)-1); #elif defined PALM return(hFile->iOffset); #elif defined SOLARIS INT64 nOffset = llseek(hFile, (offset_t)0, SEEK_CUR); return(nOffset); #elif defined IRIX return((INT64)telli64(hFile)); #elif defined LINUX return (INT64) lseek64(hFile, (__off64_t)0, SEEK_CUR); #elif defined HPUX return (INT64) lseek64(hFile, (off64_t)0, SEEK_CUR); #elif defined MACOSX return (INT64) lseek(hFile, (long)0, SEEK_CUR); #else #error ERROR: EcwFileGetPos() routine is not defined for this platform #endif }
OSErr PAS_decodeMisc(PASEntry *entry, FSSpec *outFile, short inRefNum) { OSErr err; short outRefNum; PASMiscInfo info; SInt32 infoSize; FInfo theFInfo; infoSize = sizeof(PASMiscInfo); err = SetFPos(inRefNum, fsFromStart, (*entry).entryOffset ); if (err != noErr) return err; err = FSRead( inRefNum, &infoSize, &info); if (err != noErr) return err; if(infoSize != sizeof(PASMiscInfo)) { return -1; } err = FSpOpenDF(outFile, fsRdWrPerm, &outRefNum); if (err != noErr) return err; memset(&theFInfo, 0, sizeof(FInfo)); theFInfo.fdType = info.fileType; theFInfo.fdCreator = info.fileCreator; theFInfo.fdFlags = info.fileFlags; err = FSpSetFInfo(outFile, &theFInfo); if (err != noErr) return err; FSClose(outRefNum); if (info.fileHasResFork) { outRefNum = FSpOpenResFile(outFile, fsRdWrPerm); if (outRefNum < noErr) { // maybe it does not have one! FSpCreateResFile(outFile, info.fileCreator, info.fileType, smSystemScript); outRefNum = FSpOpenResFile(outFile, fsRdWrPerm); if (outRefNum < noErr) { return err; } } SetResFileAttrs(outRefNum, info.fileResAttrs); CloseResFile(outRefNum); } return noErr; }
OSErr PAS_decodeResource(PASEntry *entry, FSSpec *outFile, short inRefNum) { OSErr err = noErr; short outRefNum; PASResFork info; SInt32 infoSize; short oldResFile; PASResource pasRes; SInt32 pasResSize; long bufSize; Handle buffer; long counter=0; infoSize = sizeof(PASResFork); err = SetFPos(inRefNum, fsFromStart, (*entry).entryOffset ); if (err != noErr) return err; err = FSRead( inRefNum, &infoSize, &info); if (err != noErr) return err; if(infoSize != sizeof(PASResFork)) { err = -1; goto error; } oldResFile=CurResFile(); outRefNum = FSpOpenResFile(outFile, fsRdWrPerm); if (outRefNum < noErr) return outRefNum; UseResFile(outRefNum); while (1) { pasResSize = sizeof(PASResource); err = FSRead( inRefNum, &pasResSize, &pasRes); if (err != noErr) { if(err == eofErr) err = noErr; break; } bufSize = pasRes.length; buffer = NewHandle(bufSize); HLock(buffer); if(buffer == NULL) { /* if we did not get our memory, try updateresfile */ HUnlock(buffer); UpdateResFile(outRefNum); counter=0; buffer = NewHandle(bufSize); HLock(buffer); if(buffer == NULL) { err = memFullErr; break; } } err = FSRead( inRefNum, &bufSize, &(**buffer)); if (err != noErr && err != eofErr) break; AddResource(buffer, pasRes.attrType, pasRes.attrID, pasRes.attrName); WriteResource(buffer); SetResAttrs(buffer, pasRes.attr); ChangedResource(buffer); WriteResource(buffer); ReleaseResource(buffer); if (counter++ > 100) { UpdateResFile(outRefNum); counter=0; } } error: UseResFile(oldResFile); CloseResFile(outRefNum); return err; }
OSErr PAS_DecodeFile(FSSpec *inSpec, FSSpec *outSpec) { OSErr err; short inRefNum; PASHeader header; PASEntry dataEntry, miscEntry, resourceEntry; long sizeOfEntry; if (inSpec == NULL || outSpec == NULL) return paramErr; FSpDelete( outSpec ) ; err = FSpCreate( outSpec, kCreator, kType ,smSystemScript ); if (err != noErr) return err; err = FSpOpenDF(inSpec, fsRdPerm, &inRefNum); if (err != noErr) goto error; /* Read Header */ err = PAS_decodeHeader(inRefNum, &header); if (err != noErr) goto error; if( header.magicNum != PAS_MAGIC_NUM || header.versionNum != PAS_VERSION) { err = -1; goto error; } /* Read Data Entry */ err = SetFPos(inRefNum, fsFromStart, sizeof(PASHeader)); if (err != noErr) goto error; sizeOfEntry = sizeof(PASEntry); err = FSRead(inRefNum, &sizeOfEntry, &dataEntry); if (err != noErr) goto error; /* Read Misc Entry */ err = SetFPos(inRefNum, fsFromStart, (sizeof(PASHeader) + sizeof(PASEntry))); if (err != noErr) goto error; sizeOfEntry = sizeof(PASEntry); err = FSRead(inRefNum, &sizeOfEntry, &miscEntry); if (err != noErr) goto error; /* Read Resource Entry */ err = SetFPos(inRefNum, fsFromStart, (sizeof(PASHeader) + (2 * sizeof(PASEntry)))) ; if (err != noErr) goto error; sizeOfEntry = sizeof(PASEntry); err = FSRead(inRefNum, &sizeOfEntry, &resourceEntry); if (err != noErr) goto error; err = PAS_decodeData(&dataEntry, outSpec, inRefNum); if (err != noErr) goto error; err = PAS_decodeMisc(&miscEntry, outSpec, inRefNum); if (err != noErr) goto error; err = PAS_decodeResource(&resourceEntry, outSpec, inRefNum); if (err == kResFileNotOpened) { // there was no resource fork err = noErr; } else if (err != noErr) { goto error; } FSClose(inRefNum); return noErr; error: if (inRefNum != kResFileNotOpened) { FSClose(inRefNum); } FSpDelete( outSpec ) ; return err; }