// $Id: ccfile.h 1492 2006-07-20 19:19:48Z alex $ /* @@tag:xara-cn@@ DO NOT MODIFY THIS LINE ================================XARAHEADERSTART=========================== Xara LX, a vector drawing and manipulation program. Copyright (C) 1993-2006 Xara Group Ltd. Copyright on certain contributions may be held in joint with their respective authors. See AUTHORS file for details. LICENSE TO USE AND MODIFY SOFTWARE ---------------------------------- This file is part of Xara LX. Xara LX is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License version 2 as published by the Free Software Foundation. Xara LX and its component source files are distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with Xara LX (see the file GPL in the root directory of the distribution); if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ADDITIONAL RIGHTS ----------------- Conditional upon your continuing compliance with the GNU General Public License described above, Xara Group Ltd grants to you certain additional rights. The additional rights are to use, modify, and distribute the software together with the wxWidgets library, the wxXtra library, and the "CDraw" library and any other such library that any version of Xara LX relased by Xara Group Ltd requires in order to compile and execute, including the static linking of that library to XaraLX. In the case of the "CDraw" library, you may satisfy obligation under the GNU General Public License to provide source code by providing a binary copy of the library concerned and a copy of the license accompanying it. Nothing in this section restricts any of the rights you have under the GNU General Public License. SCOPE OF LICENSE ---------------- This license applies to this program (XaraLX) and its constituent source files only, and does not necessarily apply to other Xara products which may in part share the same code base, and are subject to their own licensing terms. This license does not apply to files in the wxXtra directory, which are built into a separate library, and are subject to the wxWindows license contained within that directory in the file "WXXTRA-LICENSE". This license does not apply to the binary libraries (if any) within the "libs" directory, which are subject to a separate license contained within that directory in the file "LIBS-LICENSE". ARRANGEMENTS FOR CONTRIBUTION OF MODIFICATIONS ---------------------------------------------- Subject to the terms of the GNU Public License (see above), you are free to do whatever you like with your modifications. However, you may (at your option) wish contribute them to Xara's source tree. You can find details of how to do this at: http://www.xaraxtreme.org/developers/ Prior to contributing your modifications, you will need to complete our contributor agreement. This can be found at: http://www.xaraxtreme.org/developers/contribute/ Please note that Xara will not accept modifications which modify any of the text between the start and end of this header (marked XARAHEADERSTART and XARAHEADEREND). MARKS ----- Xara, Xara LX, Xara X, Xara X/Xtreme, Xara Xtreme, the Xtreme and Xara designs are registered or unregistered trademarks, design-marks, and/or service marks of Xara Group Ltd. All rights in these marks are reserved. Xara Group Ltd, Gaddesden Place, Hemel Hempstead, HP2 6EX, UK. http://www.xara.com/ =================================XARAHEADEREND============================ */ #ifndef INC_CCFILE #define INC_CCFILE #include #include "handles.h" #include "pathname.h" #include "cammemory.h" using namespace std; typedef INT32 filedesc; typedef INT32 FilePos; // Default File Buffer Size #define CCFILE_DEFAULTSIZE (1024) // Default String Sizes #define DEF_STRING_SIZE 32 #define STRING_64_SIZE 64 #define STRING_128_SIZE 128 #define STRING_256_SIZE 256 // CCMemTextFile::Read terminators #define END_OF_LINE '\n' #define END_OF_FILE '\0' // Enumeration of all the File Access rights available enum FileAccess {CCMemRead, CCMemWrite}; class GZipFile; class GZipStream; class costream; struct IStream; /******************************************************************************************** > class CCFile : public CCObject Author: Mario_Shamtani (Xara Group Ltd) Created: 31/8/1993 Base Class: CCObject Purpose: Represents an abstract file class from which all other file classes will be derived. It therefore acts as a generic interface to file handling of all sorts. A routine can read or write to a CCFile object without caring whether it is a real file on disk, or to the clipboard, or to a block of RAM somewhere. This class contains many pure virtual functions, which should be implemented by the derived classes. The basic functions of this class are supplemented by the derived class CCLexFile, which provides functions to perform lexical analysis on a file object. (Note that CCLexFile is also an abstract base class.) The main use of this class will be for the export and import filters. The class and its derivatives in this file used to just call InformError() about any errors that were encountered by the routines. The caller had no control over this so the liklyhood was that users would see a number of errors instead of just one. This is still the default but now all error handling goes through a GotError function which can be made to call InformError() and/or throw an exception. This is controlled by two protected BOOL values and can be either set in the constructor or via the public SetReportErrors and SetThrowExceptions calls. GotError also tries to force the bad(), fail() functions to fail on the next call so that no more file accesses should happen. SeeAlso: CCLexFile; CCDiskFile; CCMemFile; CCMemTextFile ********************************************************************************************/ class CCAPI CCFile : public CCObject { CC_DECLARE_DYNAMIC(CCFile); public: // Constructor with default parameters //CCFile() {} CCFile(BOOL ErrorReporting = TRUE, BOOL ExceptionThrowing = FALSE); virtual ~CCFile() { /* empty */ } // Switch between text and binary modes. (filebuf::text is non-standard and the same as 0) virtual BOOL setMode(INT32 fileMode = 0) = 0; // Check if the file is open or not. virtual BOOL isOpen() const = 0; // File pointer access/control. virtual CCFile& seekIn(FilePos) = 0; virtual CCFile& seekIn(INT32 Offset, ios::seekdir Dir) = 0; virtual FilePos tellIn() = 0; virtual CCFile& seek(FilePos pos) = 0; virtual FilePos tell() = 0; // Read functions. virtual CCFile& read(void *buf, UINT32 length = 1) = 0; virtual CCFile& read(StringBase *buf) = 0; virtual CCFile& read(char & buf) = 0; // Write functions. virtual CCFile& write(const void *buf, UINT32 length = 1) = 0; virtual CCFile& write(const StringBase& buf, UINT32 length = 0) = 0; virtual CCFile& write(char& buf) = 0; // Get the size of an open file in bytes. virtual size_t Size() = 0; // Status functions. virtual BOOL eof() const = 0; // Close the file. virtual void close() = 0; // Non-pure status functions. virtual BOOL good() const; virtual BOOL bad() const; virtual BOOL fail() const; // Pure status setting functions. virtual void SetBadState() = 0; virtual void SetGoodState() = 0; // Allows access to the underlying fstream, is so required. // Mainly required for PNG/ZLib bits // All non-disk file classes just return NULL virtual iostream* GetIOFile() = 0; // Flush the file object's buffer (if any). virtual CCFile& flush(); // Character access. virtual CCFile& get(char&); virtual CCFile& put(const char&); // Stream operators for Strings. virtual CCFile& operator>>(StringBase *buf); virtual CCFile& operator<<(const StringBase& buf); // Error checking operators operator void*() const { return fail() ? 0 : (void*) this; } INT32 operator!() const { return fail(); } // Public way of setting the two protected variables and reading their state virtual BOOL SetReportErrors( BOOL ); virtual BOOL SetThrowExceptions( BOOL ); virtual BOOL IsReportingSet(); virtual BOOL IsThrowingSet(); // Uses the above flags to determine whether to report errors and/or throw exceptions virtual void GotError( UINT32 errorID, const TCHAR *errorString ); virtual void GotError( UINT32 errorID); // Find out whether we have a useful name to return which we can append to say // error messages to give feedback on what went wrong. virtual BOOL GetName(StringBase*) const; virtual PathName GetPathName() const; // Used to make short but informative error messages. virtual BOOL SetFileErrorMessage(UINT32 ErrorID); virtual BOOL SetZipFileErrorMessage(UINT32 ErrorID); // Get access to the file descriptor or handle for the file virtual filedesc GetFileHandle() const = 0; // Allow setting of compression of output data virtual BOOL IsCompressionSet( ); virtual BOOL SetCompression( BOOL ); virtual BOOL InitCompression(BOOL Header = FALSE) = 0; virtual BOOL StartCompression() = 0; virtual BOOL StopCompression() = 0; protected: // Determines whether InformError is to be called and/or exception throwing is required BOOL ReportErrors; // Flag to say is we report errors BOOL ThrowExceptions; // Flag to say whether we throw exceptions BOOL CompressData; // Flag to say compress the output UINT32 GZipErrorID; // current zip file error id }; /******************************************************************************************** > class CCLexFile : public CCFile Author: Tim_Browse (Xara Group Ltd) Created: 05/04/94 Purpose: Provide a derivation of the CCFile class that provides support for lexical analysis of a file. This allows a stream of tokens to be extracted from an ASCII text file. This is an abstract class - you should not try to create an object of this class; use one of the derivations such as CCDiskFile or CCMemFile. Note that the lexical analysis facilities are present in all concrete file classes, but the only overhead is a few tens of bytes on the size of the object - no buffers are allocated for lexical analysis unless you call the CCLexFile::InitLexer() function (and hence lexical analysis will not work *unless* you call this function!). SeeAlso: CCFile; CCDiskFile; CCMemFile; CCMemTextFile ********************************************************************************************/ typedef enum { TOKEN_EOF, TOKEN_EOL, TOKEN_NORMAL, TOKEN_COMMENT, TOKEN_STRING, TOKEN_LINE } LexTokenType; class CCLexFile : public CCFile { CC_DECLARE_DYNAMIC(CCLexFile); public: CCLexFile(BOOL ErrorReporting = TRUE, BOOL ExceptionThrowing = FALSE); ~CCLexFile(); BOOL InitLexer(BOOL IsSeekingRequired = FALSE,BOOL DoIgnoreStringEscapeCodes = FALSE); void DeinitLexer(); // Change behaviour of token parser void SetWhitespace(char*); void SetDelimiters(char*); void SetCommentMarker(char); void SetStringDelimiters(char*); // Read in the next token. BOOL GetToken(); // Read in hexadecimal data BOOL GetHexToken(); // Read until next token is TOKEN_NORMAL or TOKEN_STRING. // Delimiter tokens are skipped. // Return FALSE if error occurs or if TOKEN_EOF encountered BOOL GetSimpleToken(); // Read in a token in a line-based manner. If the current input position is in the // middle of a line, the data up until the end of the line is read. If at the start // of a line, the whole line is returned. // The token is still examined to work out what it is, but obviously it may not // match any proper construct, in which case the type of the token is set to TOKEN_LINE. // (NB this is the only time that TOKEN_LINE is used) BOOL GetLineToken(); // Put the current token back onto the input stream - i.e. the next time GetToken() // is called it will return the token it returned last time. // This is not nestable - you can only put back one token at once. void UngetToken(); // Get status information... UINT32 GetLineNumber() { return Line; } UINT32 GetCharOffset() { return Ofs; } virtual INT32 GetCharsRead() { return CharsRead; } LexTokenType GetTokenType() { return TokenType; } const TCHAR *GetTokenBuf() { return TokenBuf; } BOOL IsLexerInitialised() { return LexerInitialised; } // Token writing routines. // These very simple functions allow your token output code to look // far neater. Besides, if we provide a GetToken() routine, it is only // common decency to provide a PutToken() routine too... BOOL PutString( const StringBase &str, UINT32 length = 0, char* Sep=" " ); BOOL PutToken( const StringBase &str, UINT32 length = 0, char* Sep=" " ); BOOL PutToken( const TCHAR *buf, char *Sep=" " ); BOOL PutToken( INT32 n, char* Sep=" " ); BOOL PutNewLine(); void IncIndent(); void DecIndent(); void SetIndentDelta(UINT32 d) { IndentDelta = d; } // The following 3 functions shouldn't really be public...pretend they're not here. // It is possible to call these directly, but it's not recommended unless you absolutely // have to, because you might stuff up the one character look-ahead. // (see epsfiltr.cpp for example of how to do it properly). // In fact, if you need to call these, tell me (Tim) and I'll work out what sort of // function we need to have here...I'll probably change it soon, anyway. void GetLine(); void GetCh(); // Helper function in case you ever need to call GetLine() directly and want to see // what you've read in. const TCHAR *GetLineBuf() { return Buf; } // this might look like a bodge but really it's a cunning way to avoid failure in // LoadInitialSegment() which sadly always requests 1K in the asynch csae // ( cause we dont know the filesize till the downloads over virtual void SetDontFail(BOOL state){ DontFail=state;}; //Graham's HTML parsing code public: //Entry points BOOL GetHTMLToken(BOOL fIgnoreEOL=TRUE, BOOL fCorrectCase=TRUE); char* GetHTMLTokenBuffer() { return m_pcHTMLBuffer; } BOOL IsHTMLTag() { return m_fIsTag; } BOOL IsEndOfHTMLFile() { return m_fEndOfHTMLFile; } String_256 GetHTMLTagName(); String_256 GetHTMLParameterValue( const String_256 &strParameterName, BOOL fCorrectCase=TRUE); protected: //HTML code member variables char *m_pcHTMLBuffer; //The HTML buffer INT32 m_iCharsInHTMLBuffer; //Number of chars in the buffer INT32 m_iLengthOfHTMLBuffer; //Length of the buffer BOOL m_fIsTag; //Whether the token in the HTML buffer is a tag BOOL m_fIsCharacterWaiting; //Whether a character is waiting to be read char m_cWaitingCharacter; //The character waiting to be read BOOL m_fEndOfHTMLFile; //Whether we have reached the end of this file protected: //HTML code internal functions void InitHTMLLexer(); //Initialises the HTML lexer void DeleteHTMLBuffer(); //Deletes the HTML buffer void AddToHTMLBuffer(char cToAdd);//Adds a character to the HTML buffer char PeekNextHTMLChar(); //Looks at the next character to be read, without reading it char ReadNextHTMLChar(); //Reads the next character from the file BOOL IsWhitespace(char cToTest); PCSTR FindStringWithoutCase( PCSTR strToSearch, PCSTR strToFind ); protected: // Variable to cache eof status; optimises lexical analysis. BOOL EOFFound; BOOL DontFail; // Input manipulation/parsing routines BOOL IsDelim(); BOOL IsWhitespace(); BOOL GetStringToken(); // Flag set to TRUE if the token read by GetToken was a delimiter BOOL DelimiterFound; // Flag to indicate whether or not to return the current token from GetToken(), // or get a new one from the file (the latter is the usual behaviour). BOOL TokenIsCached; // Buffer to hold the current line being read String_256 *LineBuf; // And a pointer to the string data TCHAR *Buf; // Buffer to hold the current token TCHAR *TokenBuf; // Indicates what kind of token was read. LexTokenType TokenType; // The current line number UINT32 Line; // Index into the buffer (the current character) UINT32 Ofs; // The current character char Ch; // How many characters have been read. INT32 CharsRead; // File position of start of last line read - so we can return the correct // tell info... FilePos LastLinePos; // Should we do the extra seeking code (which is a bit slower) BOOL SeekingRequired; // Should escape codes in strings be ignored? // e.g. Should "hello\r" turn into "hello" + CR, or should we ignore the \r code and hence leave // the string unaltered? // I.e. if IgnoreStringEscapeCodes is TRUE, then the '\' character in strings is left alone. BOOL IgnoreStringEscapeCodes; // Delimiter/white space definitions. // (These point to char arrays that hold a null-terminated set of characters that are // considered to be delimiters and whitespace respectively). char *WhitespaceChars; char *DelimiterChars; // Comment definition - similar to whitespace and delimiters, except that it is // holds one character that starts a comment. // e.g. for PostScript, it would be "%". // Comments are deemed to last until the end of the line (i.e. the first CR or LF found). char CommentMarker; // These two characters are what bracket string tokens. // e.g. for C it would be "\"\"" and for PostScript it would be "()". char *StringDelimiters; // The number of spaces to output at the start of every line. // This can be changed using IncIndent() and DecIndent() and is used // by PutNewLine(). Together they provide a mechanism for outputting // structures of tokens. // IndentDelta is the amount that IndentSpaces is increased/decreased by // IncIndent() and DecIndent(). It can be changed using SetIndentDelta() INT32 IndentSpaces; UINT32 IndentDelta; private: // A flag to tell when the lexer has been initialised. BOOL LexerInitialised; }; /******************************************************************************************** > class CCStreamFile : public CCLexFile Author: Justin_Flude (Xara Group Ltd) (based on a Mario-ism) Created: 13/8/96 Purpose: Represents a file class that uses an iostream type object for direct I/O. CCDiskFile is derived from this, using a standard fstream object for I/O. CCMemFile should be derived from this, but isn't, using a standard strstream object. CCOleStream is also derived from this, using a custom costream object for I/O. ********************************************************************************************/ class CCAPI CCStreamFile : public CCLexFile { private: CC_DECLARE_DYNAMIC(CCStreamFile); char* buffer; // Fixed Size Buffer BOOL StreamFileInitialised; // Inherited from CCFile protected: iostream* IOFile; // Underlying implementation is an iostream GZipFile* GZFile; // the gz file class we might use GZipStream* GZStream; // the gz stream class we might use INT32 ModeOfFile; // file mode we are currently using, use ios flags public: // Constructor CCStreamFile(iostream* pstream, UINT32 bufferSize = CCFILE_DEFAULTSIZE, BOOL ErrorReporting = TRUE, BOOL ExceptionThrowing = FALSE); // Constructor that opens stream CCStreamFile(const char* pcszPath, INT32 fileMode, INT32 fileAccess = 0, UINT32 bufferSize = CCFILE_DEFAULTSIZE, BOOL ErrorReporting = TRUE, BOOL ExceptionThrowing = FALSE); virtual ~CCStreamFile(); // As at present the contructors have errors in them due to memory claims rather // than doing these in a init function, we will introduce a flag to say whether // things have gone well so that if errors are supressed then a user can check. BOOL IsInited(); // Call this to change the iostream this classes uses. virtual iostream* SetStream(iostream* pStream); // Switch between text and binary modes. (filebuf::text is non-standard and the same as 0) virtual BOOL setMode(INT32 fileMode = 0) { return(TRUE); }; // Stream files are always open and cannot be closed. virtual BOOL isOpen() const; // This may be very slow for generic iostreams, or even impossible. virtual size_t Size(); // This closes a CCStreamFile. It is a no-op. virtual void close(); // File pointer access/control. virtual CCFile& seekIn(FilePos); virtual CCFile& seekIn(INT32 Offset, ios::seekdir Dir); virtual FilePos tellIn(); virtual CCFile& seek(FilePos pos); virtual FilePos tell(); // Read functions. virtual CCFile& read(void* buf, UINT32 length = 1); virtual CCFile& read(StringBase *buf); virtual CCFile& read(char& buf); // Write functions. virtual CCFile& write(const void* buf, UINT32 length = 1); virtual CCFile& write(const StringBase& buf, UINT32 length = 0); virtual CCFile& write(char& buf); // Character access virtual CCFile& get(char& buf); virtual CCFile& put(const char& buf); // Flush the file object's buffer (if any). virtual CCFile& flush(); // Status functions. virtual BOOL good() const; virtual BOOL bad() const; virtual BOOL fail() const; virtual BOOL eof() const; // Status setting function so that bad() will fail and somebody can force a good state. virtual void SetBadState(); virtual void SetGoodState(); // Allows access to the underlying iostream, if so required. // Mainly required for PNG/ZLib bits. All non-disk file classes just return NULL. virtual iostream* GetIOFile() { return IOFile; } virtual BOOL InitCompression(BOOL Header = FALSE); virtual BOOL StartCompression(); virtual BOOL StopCompression(); virtual INT32 GetCharsRead(); // Get access to the file descriptor or handle for the file. This is faked for // plain iostreams. virtual filedesc GetFileHandle() const; }; /******************************************************************************************** > class CCOleStream : public CCStreamFile Author: Justin_Flude (Xara Group Ltd) Created: 17/8/96 Purpose: Represents an IStream within an OLE Structured Storage. Uses the custom iostream class costream for its implementation. SeeAlso: IStream; IStorage; costream; costreambuf; CCStreamFile; CCDiskFile; CCLexFile ********************************************************************************************/ PORTNOTE("other","Removed CCOleStream - makes no sense on Linux") #ifndef EXCLUDE_FROM_XARALX class CCAPI CCOleStream : public CCStreamFile { public: // Creation & destruction. CCOleStream(IStream* pIStream = 0, UINT32 bufferSize = CCFILE_DEFAULTSIZE, BOOL ErrorReporting = TRUE, BOOL ExceptionThrowing = FALSE); CCOleStream(PathName path, INT32 fileMode, INT32 fileAccess = filebuf::_Openprot, UINT32 bufferSize = CCFILE_DEFAULTSIZE, BOOL ErrorReporting = TRUE, BOOL ExceptionThrowing = FALSE); // Attributes. virtual BOOL isOpen() const; virtual INT32 Size(); virtual BOOL setMode(INT32 fileMode = filebuf::text); // Operations. virtual BOOL open_file(PathName fPath, INT32 fileMode, INT32 fileAccess = filebuf::_Openprot); virtual BOOL attach(IStream* pIstream); virtual void close(); protected: // These are shorthand. Use them to refer to CCStreamFile::IOFile as a costream instead // of a plain ol' iostream. // following two cause memory exceptions !!!!!! seems to be related to use of inline // always return TRASH !!!!! Only solution was to make NOT inline .... // see more notes in ccfile.cpp (search on "causes it to throw a wobobley") .... //inline costream& GetCoStream() { return (costream&) *IOFile; } //inline const costream& GetCoStream() const { return (const costream&) *IOFile; } costream& GetCoStream() const; private: // Implementation. CC_DECLARE_DYNAMIC(CCOleStream) }; #endif // WEBSTER-Martin-29/12/96 // no accusoft stuff #ifndef WEBSTER /******************************************************************************************** > class CCOleAccusoftStream : public CCOleStream Author: Justin_Flude (Xara Group Ltd) Created: 3/10/96 Purpose: CCOleStream that manages the Accusoft stream switching as well. SeeAlso: CCOleStream ********************************************************************************************/ PORTNOTE("other","Removed CCOleAccusoftStream - makes no sense on Linux") #ifndef EXCLUDE_FROM_XARALX class CCOleAccusoftStream : public CCOleStream { public: // Switch Accusoft to read from OLE streams. CCOleAccusoftStream(IStream* pIStream = 0, UINT32 bufferSize = CCFILE_DEFAULTSIZE, BOOL ErrorReporting = TRUE, BOOL ExceptionThrowing = FALSE); // Switch Accusoft to read from OLE streams. CCOleAccusoftStream(PathName path, INT32 fileMode, INT32 fileAccess = filebuf::_Openprot, UINT32 bufferSize = CCFILE_DEFAULTSIZE, BOOL ErrorReporting = TRUE, BOOL ExceptionThrowing = FALSE); // Switch Accusoft back again. virtual ~CCOleAccusoftStream(); }; #endif #endif //WEBSTER /******************************************************************************************** > class CCDiskFile : public CCStreamFile Author: Mario_Shamtani (Xara Group Ltd) Created: 31/8/1993 Purpose: Represents a file class that can offer buffered disk file I/O in both text and binary modes. Derived from the CCLexFile class so you can use lexical analysis functions on it. ********************************************************************************************/ class CCAPI CCDiskFile : public CCStreamFile { private: CC_DECLARE_DYNAMIC(CCDiskFile); protected: PathName filePath; // PathName of File // These are shorthand. Use them to refer to CCStreamFile::IOFile as an fstream instead // of a plain ol' iostream. inline fstream& GetFileStream() { return (fstream&) *IOFile; } inline const fstream& GetFileStream() const { return (const fstream&) *IOFile; } public: // Creation & destruction. CCDiskFile(UINT32 bufferSize = CCFILE_DEFAULTSIZE, BOOL ErrorReporting = TRUE, BOOL ExceptionThrowing = FALSE); // Creation & destruction. CCDiskFile( fstream * pfstream, UINT32 bufferSize = CCFILE_DEFAULTSIZE, BOOL ErrorReporting = TRUE, BOOL ExceptionThrowing = FALSE); CCDiskFile(PathName fPath, INT32 fileMode, INT32 fileAccess = 0, UINT32 bufferSize = CCFILE_DEFAULTSIZE, BOOL ErrorReporting = TRUE, BOOL ExceptionThrowing = FALSE); CCDiskFile(fstream * pfstream, PathName fPath, INT32 fileMode, INT32 fileAccess = 0, UINT32 bufferSize = CCFILE_DEFAULTSIZE, BOOL ErrorReporting = TRUE, BOOL ExceptionThrowing = FALSE); // Open a file on a disk. virtual BOOL open( PathName fPath, INT32 fileMode, INT32 fileAccess = 0 ); // Switch between text and binary modes. (0 is equiv. to depricated ios_base::text) virtual BOOL setMode(INT32 fileMode = 0); // Check if the file is open or not. virtual BOOL isOpen() const; // This closes a CCDiskFile. virtual void close(); // Get the size of an open file in bytes. virtual size_t Size(); // Find out whether we have a useful name to return which we can append to say // error messages to give feedback on what went wrong. virtual BOOL GetName( StringBase *name) const; virtual PathName GetPathName() const; // Get access to the file descriptor or handle for the file virtual filedesc GetFileHandle() const; }; /******************************************************************************************** > class CCMemFile : public CCLexFile Author: Mario_Shamtani (Xara Group Ltd) Created: 6/9/1993 Purpose: Represents a memory IO file - IO is in byte units. Errors: None. ********************************************************************************************/ class CCAPI CCMemFile : public CCLexFile { CC_DECLARE_DYNAMIC(CCMemFile); protected: MHANDLE MemHandle; BYTE *MemFile; size_t FileSize; UINT32 CurrentPos; BOOL IsOpen; UINT32 FileProt; BOOL WasError; // TRUE if error occurred BOOL GrowMemFile(); // A flag to tell when the disk file has been initialised ok. BOOL MemFileInitialised; public: CCMemFile(BOOL ErrorReporting = TRUE, BOOL ExceptionThrowing = FALSE); CCMemFile(void* pFile, UINT32 size, FileAccess fProt = CCMemRead, BOOL ErrorReporting = TRUE, BOOL ExceptionThrowing = FALSE); ~CCMemFile(); // As at present the contructors have errors in them due to memory claims rather // than doing these in a init function, we will introduce a flag to say whether // things have gone well so that if errors are supressed then a user can check. BOOL IsMemFileInited(); BOOL GetBuffer(BYTE** ppBuffer, UINT32* pSize); BOOL open(void* pFile, UINT32 size, FileAccess fProt = CCMemRead); // Switch between text and binary modes. virtual BOOL setMode(INT32 fileMode = 0); // Check if the file is open or not. virtual BOOL isOpen() const; // File pointer access/control. virtual CCFile& seekIn(FilePos); virtual CCFile& seekIn(INT32 Offset, ios::seekdir Dir); virtual FilePos tellIn(); virtual CCFile& seek(FilePos pos); virtual FilePos tell(); // Read functions. virtual CCFile& read(void *buf, UINT32 length = 1); virtual CCFile& read(StringBase *buf); virtual CCFile& read(char& buf); // Write functions. virtual CCFile& write(const void *buf, UINT32 length = 1); virtual CCFile& write(const StringBase& buf, UINT32 length = 0); virtual CCFile& write(char& buf); // Get the size of an open file in bytes. virtual size_t Size(); // Status functions. virtual BOOL good() const; virtual BOOL bad() const; virtual BOOL fail() const; virtual BOOL eof() const; // Status setting function so that bad() will fail and somebody can force a good state. virtual void SetBadState(); virtual void SetGoodState(); // Allows access to the underlying fstream, is so required. // Mainly required for PNG/ZLib bits // All non-disk file classes just return NULL virtual iostream* GetIOFile() { return NULL; } // Find out whether we have a useful name to return which we can append to say // error messages to give feedback on what went wrong. virtual BOOL GetName( StringBase *name ) const; // Get access to the file descriptor or handle for the file virtual filedesc GetFileHandle() const; // Close the file. virtual void close(); virtual BOOL InitCompression(BOOL Header = FALSE); virtual BOOL StartCompression(); virtual BOOL StopCompression(); }; /********************************************************************************************* > class CCMemTextFile : public CCMemFile Author: Mario_Shamtani (Xara Group Ltd) Created: 8/9/1993 Purpose: Represents a character memory IO file which can cope with unicode. Errors: None. *********************************************************************************************/ class CCAPI CCMemTextFile : public CCMemFile { CC_DECLARE_DYNAMIC(CCMemTextFile); public: CCMemTextFile(BOOL ErrorReporting = TRUE, BOOL ExceptionThrowing = FALSE); CCMemTextFile(char* pFile, UINT32 size, FileAccess fProt = CCMemRead, BOOL ErrorReporting = TRUE, BOOL ExceptionThrowing = FALSE); ~CCMemTextFile(); BOOL open(char* pFile, UINT32 size, FileAccess fProt = CCMemRead); // Read functions. //virtual CCFile& read(void *buf, UINT32 length = 1); virtual CCFile& read(StringBase *buf); virtual CCFile& read(char& buf); // Write functions. //virtual CCFile& write(const void *buf, UINT32 length = 1); virtual CCFile& write(const StringBase& buf, UINT32 length = 0); virtual CCFile& write(const char& buf); // Status functions. virtual BOOL eof() const; }; /* Alternate C-style I/O interfaces. These global functions substitute for the standard C library's read, write, and seek functions, in particular those calls used by the Accusoft library. The "file-descriptor" passed as the first parameter should be obtained by calling the fake_filedesc function. CAUTION: this won't work if sizeof(INT32) != sizeof(iostream*) !! Some wobbly code to show the general idea:- // Some C++ code that sets up and calls ... fstream fs("c:\\in.txt", ios::in); costream cs("c:\\out.txt", ios::out | costream::convert | costream::transacted); INT32 fd_fs = fake_filedesc(fs); INT32 fd_os = fake_filedesc(cs); // ... some C code that does I/O with C++ streams. char buf[256]; INT32 n = stream_read(fd_fs, buf, sizeof(buf)); if (n > 0 && stream_seek(fd_os, 0, SEEK_END)) stream_write(fd_os, buf, n); */ UINT_PTR fake_filedesc(iostream& io); iostream* unfake_filedesc(UINT_PTR nFileDesc); #if defined(__WXMSW__) #define ACCUAPI_IO FAR __cdecl #else #define ACCUAPI_IO #endif extern "C" { INT32 ACCUAPI_IO stream_read(INT32 nFileDesc, char* pchBuffer, unsigned nBufSize); INT32 ACCUAPI_IO stream_write(INT32 nFileDesc, char* pchBuffer, unsigned nBufSize); INT32 ACCUAPI_IO stream_seek(INT32 nFileDesc, INT32 nOffset, unsigned fSeekType); } #endif