/**************************************************************************** Unit Bufio; Implementation ***************************************************************************** Bufio implements the structured reading of the imput stream. As such, it will handle the necessary byte-swapping that must occur when reading a native Macintosh file. This interface will also shield the calling application from knowledge of the source format (file vs. memory). Module Prefix: IO ****************************************************************************/ #include "headers.c" #pragma hdrstop #include "filesys.h" #ifndef _OLECNV32_ //#include "status.h" #endif // _OLECNV32_ /*********************** Exported Data **************************************/ /*********************** Private Data ***************************************/ #define UNKNOWN 0 #define FILE 1 #define MEMORY 2 #define RTF 3 #define BUFFERSIZE 1024 private LongInt numBytesRead; private LongInt pictureSize; private LongInt beginOffset; private LongInt bufferCount; private Byte buffer[BUFFERSIZE]; private Byte * nextCharPtr; private Byte huge * nextCharHPtr; private Byte sourceType = UNKNOWN; private Integer fileHandle = (Integer)0; private Str255 fileName; private Boolean openFile; private Byte huge * memoryHPtr; private Handle memoryHandle; private Handle dialogHandle; /*********************** Private Function Definitions ***********************/ private void ReadNextBuffer( void ); /* Replenish the i/o buffer with the next set of characters */ /* Memory operations - check return values on usage */ #define MDisposHandle( h ) ((void) GlobalFree( h )) #define MLock( h ) ((LPtr) GlobalLock( h )) #define MUnlock( h ) ((void) GlobalUnlock( h )) #define MDR( h ) ((LPtr) GlobalLock( h )) #define MUR( h ) ((void) GlobalUnlock( h )) #define MNewHandle( s ) GlobalAlloc( GMEM_MOVEABLE, s ) /*********************** Function Implementation ****************************/ void IOGetByte( Byte far * byteLPtr ) /*============*/ /* Read a byte from the input stream. If the buffer is empty, then it is replenished. */ { /* Make sure that no global error code has been set before read */ if (ErGetGlobalError() != NOERR ) { *byteLPtr = 0; return; } /* Check for an attempt to read past the EOF or memory block. This would indicate that the opcode parsing was thrown off somewhere. */ if (numBytesRead >= pictureSize) { ErSetGlobalError( ErReadPastEOF ); *byteLPtr = 0; return; } /* Check to see if we need to replenish the read buffer */ if (bufferCount <= 0) { ReadNextBuffer(); } /* Decrement the count of characters in the buffer, increment the total number of bytes read from the file, and return the next character. */ bufferCount--; numBytesRead++; /* determine where to read the next byte from - use short or huge ptrs */ *byteLPtr = (sourceType == FILE) ? *nextCharPtr++ : *nextCharHPtr++; } /* IOGetByte */ void IOSkipBytes( LongInt byteCount ) /*==============*/ /* Skip the designated number of bytes */ { /* make sure we are skipping a valid number of bytes */ if (byteCount <= 0) { return; } /* Check for an attempt to read past the EOF or memory block. This would indicate that the opcode parsing was thrown off somewhere. */ if (numBytesRead + byteCount >= pictureSize) { ErSetGlobalError( ErReadPastEOF ); } else { /* determine if there are sufficient bytes remaining in the buffer */ if (bufferCount >= byteCount) { /* decrement # bytes remaining, increment # bytes read and pointer */ bufferCount -= byteCount; numBytesRead += byteCount; /* increment the appropriate pointer based on media type */ if (sourceType == FILE) { /* increment near pointer to data segment buffer */ nextCharPtr += byteCount; } else { /* increment huge pointer to global memory block */ nextCharHPtr += byteCount; } } else /* sourceType == FILE and buffer needs to be replenished */ { Byte unusedByte; /* continue calling IOGetByte() until desired number are skipped */ while (byteCount--) { /* call IOGetByte to make sure the cache is replenished */ IOGetByte( &unusedByte ); } } } } /* IOSkipBytes */ void IOAlignToWordOffset( void ) /*======================*/ /* Align next memory read to Word boundary. */ { /* check to see if we have read an odd number of bytes so far. Skip the ensuing byte if necessary to align. */ if (numBytesRead & 0x0001) { IOSkipBytes( 1 ); } } /* IOAlignToWordOffset */ #ifndef _OLECNV32_ void IOSetFileName( StringLPtr pictFileName ) /*================*/ /* Interface routine to set the source filename */ { lstrcpy( fileName, pictFileName ); sourceType = FILE; openFile = TRUE; } /* IOSetFileName */ void IOSetFileHandleAndSize( Integer pictFileHandle, LongInt pictFileSize ) /*=========================*/ /* Interface routine to set the source file Handle */ { fileHandle = pictFileHandle; pictureSize = pictFileSize; sourceType = FILE; openFile = FALSE; } /* IOSetFIleHandle */ #endif // !_OLECNV32_ void IOSetMemoryHandle( HANDLE pictMemoryHandle ) /*==================*/ /* Interface routine to set the source file Handle */ { memoryHandle = ( Handle ) pictMemoryHandle; sourceType = MEMORY; } /* IOSetMemoryHandle */ void IOSetReadOffset( LongInt readOffset ) /*==================*/ /* Set the beginning offset to seek to when the file is opened */ { beginOffset = readOffset; } void IOOpenPicture( Handle dialog ) /*================*/ /* Open the input stream depending on the source type set by a previous IOSet___ interface routine. Determine the size of the picture image. */ { #ifndef _OLECNV32_ OSErr openError; #endif // !_OLECNV32_ /* if the type isn't set, return error */ if (sourceType == UNKNOWN) { ErSetGlobalError( ErNoSourceFormat ); return; } /* initialize the various reader variables */ numBytesRead = 0; bufferCount = 0; /* determine how to open the soure data stream */ #ifndef _OLECNV32_ if (sourceType == FILE) { /* if we are openning and converting an entire file */ if (openFile) { /* open the file */ openError = FSOpen( (StringLPtr)fileName, OF_READ | OF_SHARE_DENY_WRITE, &fileHandle ); if (openError) { ErSetGlobalError( ErOpenFail); } else { /* and determine the file length */ FSSetFPos( fileHandle, FSFROMLEOF, 0L ); FSGetFPos( fileHandle, &pictureSize ); } } /* set position to the designated start position */ FSSetFPos( fileHandle, FSFROMSTART, beginOffset ); numBytesRead = beginOffset; } else /* if (sourceType == MEMORY) */ #endif // !_OLECNV32_ { /* lock the memory block */ memoryHPtr = (Byte huge *) MLock( memoryHandle ); if (memoryHPtr == NULL) { ErSetGlobalError( ErMemoryFail ); return; } else { /* and determine the overall memory block size */ pictureSize = (ULONG) GlobalSize( memoryHandle ); } /* set the huge character read pointer, bytes read, and buffer count */ nextCharHPtr = memoryHPtr + beginOffset; bufferCount = pictureSize - beginOffset; numBytesRead = beginOffset; } #ifndef _OLECNV32_ /* make sure that a dialog handle was supplied for update */ if (dialog) { /* save off the dialog box handle */ dialogHandle = dialog; /* calculate the interval to update the status dialog */ SendMessage( dialogHandle, SM_SETRANGE, 0, pictureSize ); } #endif // !OLECNV32 } /* IOOpenPicture */ void IOClosePicture( void ) /*=================*/ /* Close the source input stream */ { /* if this is a file-based metafile */ #ifndef _OLECNV32_ if (sourceType == FILE) { /* make sure this isn't the ImportEmbeddedGr() entry point */ if (openFile) { /* close the file if necessary */ FSCloseFile( fileHandle ); fileHandle = ( Integer ) 0; } } else #endif // !_OLECNV32_ { /* unlock the global memory block */ MUnlock( memoryHandle ); memoryHandle = NULL; } /* de-initialize the module variables */ sourceType = UNKNOWN; dialogHandle = NULL; } /* IOClosePicture */ void IOUpdateStatus( void ) /*=================*/ /* Update the status bar dialog to reflect current progress */ { #ifndef _OLECNV32_ /* update only if a dialog box was created */ if (dialogHandle) { /* calculate the interval to update the status dialog */ SendMessage( dialogHandle, SM_SETPOSITION, 0, numBytesRead ); } #endif // !_OLECNV32_ } /* IOUpdateStatus */ /******************************* Private Routines ***************************/ private void ReadNextBuffer( void ) /*-------------------------*/ /* Replenish the i/o buffer with the next set of characters. This should only be called if performing buffered I/O - not with MEMORY-based file */ { #ifndef _OLECNV32_ OSErr fileError; /* Read the required number of bytes from the file. Check the error code return and set the global status error if the read failed. */ if (sourceType == FILE) { /* Calculate the number of bytes that should be read into the buffer. This needs to be done, since this may be a memory source picture, in which an invalid read could produce a GP violation */ if (numBytesRead + BUFFERSIZE > pictureSize) bufferCount = pictureSize - numBytesRead; else bufferCount = BUFFERSIZE; /* read the bytes from the file */ fileError = FSRead( fileHandle, &bufferCount, &buffer); /* if there is any error, notify the error module */ if (fileError != 0) { ErSetGlobalError( ErReadFail ); return; } /* reset the character read pointer to the beginning of the buffer */ nextCharPtr = buffer; } #endif // _OLECNV32_ } /* ReadNextBuffer */