diff -r 000000000000 -r 044383f39525 bintools/rcomp/inc/RCBINSTR.H
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/bintools/rcomp/inc/RCBINSTR.H	Tue Oct 27 16:36:35 2009 +0000
@@ -0,0 +1,123 @@
+/*
+* Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of the License "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: 
+*
+*/
+
+
+#ifndef __RCOFSTRM_H__
+#define __RCOFSTRM_H__
+
+#if defined(__VC32__) && !defined(__MSVCDOTNET__)
+#pragma warning( disable : 4710 )	// function not inlined
+#endif
+
+#if defined(__MSVCDOTNET__) || defined(__TOOLS2__)
+#include <fstream>
+using std::ofstream;
+#else //!__MSVCDOTNET__
+#include <fstream.h>
+#endif //__MSVCDOTNET__
+
+#include "ASTRING.H"
+#include "NUMVAL.H"
+#include "ARRAY.H" 
+
+class RCBinaryStream
+	{
+public:
+	RCBinaryStream();
+	~RCBinaryStream();
+	void OpenForAppend(const String& aFileName);
+	int IsOpen();
+	RCBinaryStream& operator<<(char aChar);
+	RCBinaryStream& operator<<(char* aCharPtr);
+	static int SizeOfCompressedInteger(unsigned int aInteger);
+	void WriteCompressedInteger(unsigned int aInteger);
+	void Write(const unsigned char* aCharPtr, unsigned long aCount);
+	unsigned long GetPosition();
+	void SetPosition(unsigned long NewPosition);
+private:
+	ofstream iOs;
+	};
+
+class ResourceDataStream // this class knows about resources that contain compressed Unicode - i.e. that each run of alternating compressed-Unicode and other-stuff needs to be preceded by a 1-2 byte run-length
+	{
+public:
+	ResourceDataStream();
+	~ResourceDataStream();
+	void StartOfBlockWithSizePrefix(DataType aDataTypeOfSizePrefix); // StartOfBlockWithSizePrefix/EndOfBlockWithSizePrefix blocks can be nested
+	void EndOfBlockWithSizePrefix();
+	void StartOfCompressedUnicodeRun(int aUncompressedUnicodeSizeInBytes, const unsigned char* aUncompressedUnicodeBuffer); // StartOfCompressedUnicodeRun/EndOfCompressedUnicodeRun runs *cannot* be nested
+	void EndOfCompressedUnicodeRun();
+	void TwoByteAlignmentPoint();
+	void EnquireStreamPositionWhenKnown(unsigned long& aStreamPosition);
+	void StreamIn(const unsigned char* aBuffer, int aNumberOfBytes);
+	void MakePlaceHolder(int aNumberOfBytes);
+	bool StreamOutReturningWhetherContainsCompressedUnicode(RCBinaryStream& aStream, int& aSizeWhenUncompressed);
+	void Dump(const char* aDumpFile) const;
+private:
+	enum MarkType
+		{
+		EMarkType_StartOfBlockWithSizePrefix, // uses iOtherData to store the address of the NumericValue of the size-prefix
+		EMarkType_EndOfBlockWithSizePrefix,
+		EMarkType_StartOfCompressedUnicodeRun, // uses iOtherData to store a BinaryBuffer which contains the uncompressed Unicode - a EMarkType_StartOfCompressedUnicodeRun mark is always followed in ResourceDataStream's iArrayOfMarks by a EMarkType_EndOfCompressedUnicodeRun
+		EMarkType_EndOfCompressedUnicodeRun, // uses iOtherData to store the combined size of the run taking into account any extra bytes caused by other marks, e.g. a padding byte caused by a EMarkType_TwoByteAlignmentPoint
+		EMarkType_TwoByteAlignmentPoint, // uses iOtherData to store whether a padding byte is required or not (iOtherData is set to non-zero if it is and zero if it isn't)
+		EMarkType_EnquireStreamPositionWhenKnown // uses iOtherData to store the address of the unsigned long to write the stream-position to
+		};
+	class BinaryBuffer
+		{
+	public:
+		static BinaryBuffer* New(int aNumberOfBytes, const unsigned char* aBuffer);
+		void Destroy();
+		inline int NumberOfBytes() const {return iNumberOfBytes;}
+		inline const unsigned char* Buffer() const {return iBuffer;}
+	private:
+		BinaryBuffer(); // defined (as private) but not declared to prevent anyone instantiating this class apart from the static New function
+	private:
+		int iNumberOfBytes;
+		unsigned char iBuffer[1];
+		};
+	class Mark : public ArrayItem
+		{
+	public:
+		inline Mark(int aBufferPosition, MarkType aMarkType, unsigned int aOtherData) :iBufferPosition(aBufferPosition), iMarkType(aMarkType), iOtherData(aOtherData) {}
+	public:
+		int iBufferPosition;
+		MarkType iMarkType;
+		unsigned int iOtherData;
+		};
+	class ArrayOfMarks : public Array
+		{
+	public:
+		inline ArrayOfMarks() {}
+		inline void AppendMark(int aBufferPosition, MarkType aMarkType, unsigned int aOtherData=0xbebebebe) {Add(new Mark(aBufferPosition, aMarkType, aOtherData));}
+		inline void InsertMark(int aIndex, int aBufferPosition, MarkType aMarkType, unsigned int aOtherData=0xbebebebe) {Add(aIndex, new Mark(aBufferPosition, aMarkType, aOtherData));}
+		inline void RemoveMark(int aIndex) {Discard(aIndex);}
+		inline Mark& MarkAt(int aIndex) const {return *(Mark*)(*this)[aIndex];}
+		};
+private:
+	void EnsureEnoughSpareBytes(int aNumberOfBytes);
+	int NumberOfBytesToNextMark(int aMarkIndex) const;
+	void ConvertCompressedRunToUncompressed(int aIndexOfStartOfCompressedUnicodeRun); // aIndexOfStartOfCompressedUnicodeRun is an index into iArrayOfMarks
+private:
+	unsigned char* iBuffer;
+	int iNumberOfBytesAllocated;
+	int iNumberOfBytesUsed;
+	ArrayOfMarks iArrayOfMarks;
+	bool iContainsCompressedUnicode;
+	};
+
+#endif