diff -r 000000000000 -r ba25891c3a9e secureswitools/swianalysistoolkit/source/common/ucmp.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/secureswitools/swianalysistoolkit/source/common/ucmp.h Thu Dec 17 08:51:10 2009 +0200 @@ -0,0 +1,345 @@ +/* +* Copyright (c) 2006-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: +* Ported from ucmp.h +* Header for the Standard Compression Scheme for Unicode. +* This code is compiled only in the Unicode build. +* +*/ + + +/** + @file + @internalComponent +*/ + +#ifndef __UCMP_H__ +#define __UCMP_H__ 1 + +#include "symbiantypes.h" +#include + + +typedef std::istream Deserialiser; +typedef std::ostream Serialiser; + +#define KMaxTInt 0x7FFFFFFF +/** + * @internalComponent + */ + +class TUnicodeCompressionState + { + public: + TUnicodeCompressionState(); + void Reset(); + static TInt32 StaticWindowIndex(TUint16 aCode); + static TInt32 DynamicWindowOffsetIndex(TUint16 aCode); + static TUint32 DynamicWindowBase(TInt32 aOffsetIndex); + static TBool EncodeAsIs(TUint16 aCode); + + enum TPanic + { + EUnhandledByte, // expander code fails to handle all possible byte codes + ENotUnicode, // expander can't handle Unicode values outside range 0x0..0x10FFFF; + // that is, 16-bit codes plus 32-bit codes that can be expressed using + // 16-bit surrogates + EOutputBufferOverflow // output buffer is not big enough + }; + + static void Panic(TPanic aPanic); + + protected: + + enum + { + EStaticWindows = 8, + EDynamicWindows = 8, + ESpecialBases = 7 + }; + + TBool iUnicodeMode; // TRUE if in Unicode mode as opposed to single-byte mode + TUint32 iActiveWindowBase; // base of the active window - bases are 32-bit because they + // can be set to the surrogate area, which represents codes + // from 0x00010000 to 0x0010FFFF - planes 1-16 of ISO-10646. + static const TUint32 iStaticWindow[EStaticWindows]; // bases of the static windows + static const TUint32 iDynamicWindowDefault[EDynamicWindows]; // default bases of the dynamic windows + static const TUint16 iSpecialBase[ESpecialBases]; // bases for window offsets F9..FF + + TUint32 iDynamicWindow[EDynamicWindows]; // bases of the dynamic windows + TInt32 iUnicodeWords; // Unicode words processed; read by compressor, written by expander + TInt32 iMaxUnicodeWords; // maximum number of Unicode words to read or write + TInt32 iCompressedBytes; // compressed bytes processed: read by expander, written by compressor + TInt32 iMaxCompressedBytes; // maximum number of compressed bytes to read or write + }; + +/** + * @internalComponent + */ + +class MUnicodeSource + { + public: + virtual TUint16 ReadUnicodeValue() = 0; + }; + +/** + * @internalComponent + A class to read Unicode values directly from memory. + */ +class TMemoryUnicodeSource: public MUnicodeSource + { + public: + inline TMemoryUnicodeSource(const TUint16* aPtr); + inline TUint16 ReadUnicodeValue(); + + private: + const TUint16* iPtr; + }; + +/**Deserialiser& Deserialiser:: + * @internalComponent + A class to read Unicode values from a stream built on a memory object. + */ +class TMemoryStreamUnicodeSource: public MUnicodeSource + { + public: + inline TMemoryStreamUnicodeSource(Deserialiser& aStream); + inline TUint16 ReadUnicodeValue(); + + private: + Deserialiser& iStream; + }; + +/** + * @internalComponent + */ +class MUnicodeSink + { + public: + virtual void WriteUnicodeValue(TUint16 aValue) = 0; + }; + +/** + * @internalComponent + A class to write Unicode values directly to memory. + */ +class TMemoryUnicodeSink: public MUnicodeSink + { + public: + inline TMemoryUnicodeSink(TUint16* aPtr); + inline void WriteUnicodeValue(TUint16 aValue); + + private: + TUint16* iPtr; + }; + +/** + * @internalComponent + A class to write Unicode values to a stream built on a memory object. + */ +class TMemoryStreamUnicodeSink: public MUnicodeSink + { + public: + inline TMemoryStreamUnicodeSink(Serialiser& aStream); + inline void WriteUnicodeValue(TUint16 aValue); + + private: + Serialiser& iStream; + }; + +/** + * @internalComponent +A class to hold functions to compress text using the Standard Compression Scheme for Unicode. + +A note on error handling and leaving. + +Although all the public functions except the constructor can leave, it is possible to guarantee success: that is, +guarantee that a call will not leave, and that compression will be completed. To do this, (i) supply a MUnicodeSource +object with a non-leaving ReadUnicodeValue function, such as a TMemoryUnicodeSource; (ii) write output to a +Serialiser with a non-leaving Write function, or to a buffer that you already know to be big enough, which can be +found out using CompressedSize. + +This guarantee of success is particularly useful when compressing from one memory buffer to another. +*/ +class TUnicodeCompressor: public TUnicodeCompressionState + { + public: + TUnicodeCompressor(); + void Compress(Serialiser& aOutput,MUnicodeSource& aInput, + TInt32 aMaxOutputBytes = KMaxTInt,TInt32 aMaxInputWords = KMaxTInt, + TInt32* aOutputBytes = 0,TInt32* aInputWords = 0); + void Compress(TUint8* aOutput,MUnicodeSource& aInput, + TInt32 aMaxOutputBytes = KMaxTInt,TInt32 aMaxInputWords = KMaxTInt, + TInt32* aOutputBytes = 0,TInt32* aInputWords = 0); + TInt32 Flush(Serialiser& aOutput,TInt32 aMaxOutputBytes,TInt32& aOutputBytes); + TInt32 Flush(TUint8* aOutput,TInt32 aMaxOutputBytes,TInt32& aOutputBytes); + static TInt32 CompressedSize(MUnicodeSource& aInput,TInt32 aInputWords); + + private: + + // A structure to store a character and its treatment code + struct TAction + { + // Treatment codes: static and dynamic window numbers, plain ASCII or plain Unicode + enum + { + EPlainUnicode = -2, // character cannot be expressed as ASCII or using static or dynamic windows + EPlainASCII = -1, // character can be emitted as an ASCII code + EFirstDynamic = 0, // values 0..255 are for dynamic windows with offsets at these places in the offset table + ELastDynamic = 255, + EFirstStatic = 256, // values 256..263 are for static windows 0..7 + ELastStatic = 263 + }; + + inline TAction(); + TAction(TUint16 aCode); + + TUint16 iCode; // Unicode value of the character + TInt32 iTreatment; // treatment code: see above + }; + + void DoCompress(Serialiser* aOutputStream,TUint8* aOutputPointer,MUnicodeSource* aInput, + TInt32 aMaxCompressedBytes,TInt32 aMaxUnicodeWords, + TInt32* aCompressedBytes,TInt32* aUnicodeWords); + void FlushInputBuffer(); + void FlushOutputBuffer(); + void WriteRun(); + void WriteCharacter(const TAction& aAction); + void WriteSCharacter( const TAction& aAction); + void WriteUCharacter(TUint16 aCode); + void WriteByte(TUint32 aByte); + void WriteCharacterFromBuffer(); + void SelectTreatment(TInt32 aTreatment); + + enum + { + EMaxInputBufferSize = 4, + EMaxOutputBufferSize = EMaxInputBufferSize * 3 // no Unicode character can be encoded as more than three bytes + }; + TAction iInputBuffer[EMaxInputBufferSize]; // circular buffer; queue of Unicode characters to be processed + TInt32 iInputBufferStart; // position of first Unicode character to be processed + TInt32 iInputBufferSize; // characters in the input buffer + TUint8 iOutputBuffer[EMaxOutputBufferSize]; // circular buffer; queue of compressed bytes to be output + TInt32 iOutputBufferStart; // position of first compressed byte to be output + TInt32 iOutputBufferSize; // characters in the output buffer + TInt32 iDynamicWindowIndex; // index of the current dynamic window + Serialiser* iOutputStream; // if non-null, output is to this stream + TUint8* iOutputPointer; // if non-null, output is to memory + MUnicodeSource* iInput; // input object + }; + +/** + * @internalComponent + +A class to hold functions to expand text using the Standard Compression Scheme for Unicode. + +A note on error handling and leaving. + +Although all the puTUnicodeExpanderblic functions except the constructor can leave, it is possible to guarantee success: that is, +guarantee that a call will not leave, and that expansion will be completed. To do this, (i) supply a MUnicodeSink +object with a non-leaving WriteUnicodeValue function, such as a TMemoryUnicodeSink; (ii) read input from a Deserialiser +with a non-leaving Read function; (iii) supply a big enough buffer to write the ouput; you can find out how big by +calling ExpandedSize, using methods (i) and (ii) to guarantee success. + +This guarantee of success is particularly useful when expanding from one memory buffer to another. +*/ +class TUnicodeExpander: public TUnicodeCompressionState + { + public: + TUnicodeExpander(); + void Expand(MUnicodeSink& aOutput,Deserialiser& aInput, + TInt32 aMaxOutputWords = KMaxTInt,TInt32 aMaxInputBytes = KMaxTInt, + TInt32* aOutputWords = 0,TInt32* aInputBytes = 0); + void Expand(MUnicodeSink& aOutput,const TUint8* aInput, + TInt32 aMaxOutputWords = KMaxTInt,TInt32 aMaxInputBytes = KMaxTInt, + TInt32* aOutputWords = 0,TInt32* aInputBytes = 0); + TInt32 Flush(MUnicodeSink& aOutput,TInt32 aMaxOutputWords,TInt32& aOutputWords); + static TInt32 ExpandedSize(Deserialiser& aInput,TInt32 aInputBytes); + static TInt32 ExpandedSize(const TUint8* aInput,TInt32 aInputBytes); + + private: + void DoExpand(MUnicodeSink* aOutput,Deserialiser* aInputStream,const TUint8* aInputPointer, + TInt32 aMaxOutputWords,TInt32 aMaxInputBytes, + TInt32* aOutputWords,TInt32* aInputBytes); + void HandleByte(); + void FlushOutputBuffer(); + TBool HandleSByte(TUint8 aByte); + TBool HandleUByte(TUint8 aByte); + TBool ReadByte(TUint8& aByte); + TBool QuoteUnicode(); + TBool DefineWindow(TInt32 aIndex); + TBool DefineExpansionWindow(); + void WriteChar(TUint16 aChar); + void WriteChar32(TUint32 aChar); + + enum + { + EMaxInputBufferSize = 3, // no Unicode character can be encoded as more than 3 bytes + EMaxOutputBufferSize = 2 // no byte can be expanded into more than 2 Unicode characters + }; + TUint8 iInputBuffer[EMaxInputBufferSize]; // buffer containing a group of compressed bytes representing + // a single operation; when an input source ends in the + // middle of an operation, this buffer enables the next + // expansion to start in the correct state + TInt32 iInputBufferStart; // next read position in the input buffer + TInt32 iInputBufferSize; // bytes in the input buffer + TUint16 iOutputBuffer[EMaxOutputBufferSize]; // circular buffer; queue of Unicode characters to be output + TInt32 iOutputBufferStart; // position of first Unicode character to be output + TInt32 iOutputBufferSize; // characters in the output buffer + MUnicodeSink* iOutput; // output object + Deserialiser* iInputStream; // if non-null, input is from this stream + const TUint8* iInputPointer; // if non-null, input is from memory + }; + +// inline functions start here + +inline TMemoryUnicodeSource::TMemoryUnicodeSource(const TUint16* aPtr): + iPtr(aPtr) + { + } + +inline TUint16 TMemoryUnicodeSource::ReadUnicodeValue() + { + return *iPtr++; + } + +inline TMemoryStreamUnicodeSource::TMemoryStreamUnicodeSource(Deserialiser& aStream): + iStream(aStream) + { + } + +inline TMemoryUnicodeSink::TMemoryUnicodeSink(TUint16* aPtr): + iPtr(aPtr) + { + } + +inline void TMemoryUnicodeSink::WriteUnicodeValue(TUint16 aValue) + { + *iPtr++ = aValue; + } + +inline TMemoryStreamUnicodeSink::TMemoryStreamUnicodeSink(Serialiser& aStream): + iStream(aStream) + { + } + +inline TUnicodeCompressor::TAction::TAction(): + iCode(0), + iTreatment(EPlainUnicode) + { + } + +#endif // __UCMP_H__ +