// 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 "Symbian Foundation License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
// e32\include\unicode.h
// The TUnicode class contains a Unicode value. It is provided for convenience in implementing the
// character attribute retrieval functions. It also contains:
// structures used to store and search the tables of character information:
// when modifying these, please remember that they form part of tables that must be initialised as aggregates,
// so they cannot have constructors, non-public members, base classes or virtual functions. I have used 'struct'
// rather than class to make that clear.
// default constructor that sets the stored Unicode value to 0xFFFF - an invalid character
// constructors and conversion functions for converting between integers and TUnicode objects
// functions to retrieve the categories and attributes
// The categories are explained in 'unicode_fields.txt', which is a key to the fields of the data file
// 'unidata2.txt'; these files are supplied on the CD-ROM that comes with the book 'The Unicode Standard,
// Version 2.0'.
// Because the category constants must be available to users they are defined not here but in the TChar
// class in e32std.h.
//
//
/**
@file
@internalTechnology
*/
#ifndef __UNICODE_H__
#define __UNICODE_H__ 1
#include <e32cmn.h>
/*
A structure to contain the raw data about a Unicode character:
it must not have a constructor because an array of these in unitable.cpp is initialised as an aggregate.
*/
struct TUnicodeData
{
// bit values for iFlags
enum
{
EHasLowerCase = 1, // adding the case offset gives the lower case form
EHasUpperCase = 2, // subtracting the case offset gives the upper case form
EHasTitleCase = 4, // a title case form exists that is distinct from the upper case form
EMirrored = 8, // this character is replaced by a mirror-image in right-to-left text
ENumericFlags = 0x70, // one of these flags is set if this number has a numeric value
ENonNumeric = 0x00, // this character has no numeric value
ESmallNumeric = 0x10, // numeric in the range 0..255 (see iDigitOffset)
EFiveHundred = 0x20, // numeric with the value 500
EOneThousand = 0x30, // numeric with the value 1000
EFiveThousand = 0x40, // numeric with the value 5000
ETenThousand = 0x50, // numeric with the value 10000
EHundredThousand = 0x60, // numeric with the value 100000
EFraction = 0x70 // numeric with a fractional value
};
TUint8 iCategory; // general category
TUint8 iBdCategory; // bidirectional category
TUint8 iCombiningClass; // combining class
TInt8 iDigitOffset; // if this character has a small numeric value, the difference between the low
// 8 bits of the character code and the numeric value
TInt16 iCaseOffset; // offset to other case; subtract to get upper case, add to get lower
// case (this makes it more likely that characters
// differing only by case have the same data, making the table smaller)
TUint8 iFlags; // flags: does this character have a lower case form, etc.
};
/*
A structure for a range of Unicode characters with the same raw data; must not have a
constructor because an array of these in unitable.cpp is initialised as an aggregate.
*/
struct TUnicodeDataRange
{
TUint16 iRangeStart; // Unicode value of the start of the range of characters
TInt16 iIndex; // index into an array of character information structures (-1 means data no available)
};
/*
A structure to hold a set of overriding character data
*/
struct TUnicodeDataSet
{
const TUnicodeData *iData; // array of character data structures
const TUnicodeDataRange *iRange; // array of ranges referring to elements of iData
TInt iRanges; // number of elements in the array of ranges
};
// A structure to hold the standard character data
struct TStandardUnicodeDataSet
{
const TUint16* iIndex1; // first trie index: 4096 elements indexed by high 12 bits of Unicode value
const TUint16* iIndex2; // second trie index, indexed by values in iIndex1
const TUnicodeData *iData; // array of character data structures, indexed by values in iIndex2, offset
// by low 4 bits of Unicode value
};
/*
A class to hold a Unicode character and provide functions for characterisation (e.g., is this character lowercase?)
composition (e.g., create a character from a base character and an accent), and decomposition
(e.g., remove the accent from this character if there is one).
*/
class TUnicode
{
public:
// Constructors
TUnicode() { iCode = 0xFFFF; }
TUnicode(TUint c) : iCode(c) {}
operator TUint() const { return iCode; }
// Attribute retrieval (functions used by the ExecHandler class, etc., in ekern.dll take IMPORT_C)
void GetInfo(TChar::TCharInfo& aInfo,const TUnicodeDataSet *aOverridingDataSet) const;
IMPORT_C TChar::TCategory GetCategory(const TUnicodeDataSet *aOverridingDataSet) const;
TChar::TBdCategory GetBdCategory(const TUnicodeDataSet *aOverridingDataSet) const;
TInt GetCombiningClass(const TUnicodeDataSet *aOverridingDataSet) const;
IMPORT_C TUint GetLowerCase(const TUnicodeDataSet *aOverridingDataSet) const;
IMPORT_C TUint GetUpperCase(const TUnicodeDataSet *aOverridingDataSet) const;
TUint GetTitleCase(const TUnicodeDataSet *aOverridingDataSet) const;
TBool IsMirrored(const TUnicodeDataSet *aOverridingDataSet) const;
TInt GetNumericValue(const TUnicodeDataSet *aOverridingDataSet) const;
TChar::TCjkWidth GetCjkWidth() const;
IMPORT_C TUint Fold(TInt aFlags,const TUnicodeDataSet *aOverridingDataSet) const;
// Utilities
static TInt Compare(const TUint16 *aString1,TInt aLength1,const TUint16 *aString2,TInt aLength2);
private:
const TUnicodeData& GetData(const TUnicodeDataSet *aOverridingDataSet) const;
const TUnicodeData *GetDataFromDataSet(const TUnicodeDataSet& aDataSet) const;
TUint GetLowerCase(const TUnicodeData& aData) const;
TUint GetUpperCase(const TUnicodeData& aData) const;
TUint GetTitleCase(const TUnicodeData& aData) const;
TInt GetNumericValue(const TUnicodeData& aData) const;
TUint iCode; // not TUint16 because values in the extended range from 0x10000 to 0xFFFFF may be used.
public:
#ifndef __KERNEL_MODE__
static const TUint16 FoldTable[256]; // fold table (strip accents, fold case) for the range 0..255
static const TUint16 CjkWidthFoldTable[256];// width fold table (convert from width variants) for range 0xFF00..0xFFFF
#else
static const TUint16* FoldTable;
static const TUint16* CjkWidthFoldTable;
#endif
};
// Declarations for tables held in unitable.cpp and used by unicode.cpp.
#ifndef __KERNEL_MODE__
extern const TStandardUnicodeDataSet TheStandardUnicodeDataSet;
extern const TUint16 TheUnicodeCompositionBuffer[];
extern const TInt TheUnicodeCompositions;
#else
extern const TStandardUnicodeDataSet* pStandardUnicodeDataSet;
extern const TUint16* TheUnicodeCompositionBuffer;
extern TInt TheUnicodeCompositions;
#endif
#endif // __UNICODE_H__