// Copyright (c) 1995-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:

 // e32\euser\us_exec.cpp

 // 

 //

 #include "us_std.h"

 #include "us_data.h"

 #include <e32des8_private.h>

 #include <e32kpan.h>

 #include <unicode.h>

 #include <videodriver.h>

 #include "CompareImp.h"

 #include <e32atomics.h>

 #include "locmapping.h"

 #ifdef __VC32__

   #pragma setlocale("english")

 #endif

 _LIT(KLitSpace, " ");

 _LIT(KLitOpeningBracket, "(");

 _LIT(KLitMinusSign, "-");

 _LIT(KLitZeroPad, "0");

 #ifdef SYMBIAN_DISTINCT_LOCALE_MODEL

 _LIT(KFindLan, "elocl_lan.");

 _LIT(KFindReg, "elocl_reg.");

 _LIT(KFindCol, "elocl_col.");

 _LIT(KLoc, "elocl.");

 #endif

 // Private use area ranges of printable/non-printable characters.

 // This is a sorted list of numbers indicating the ranges in which characters

 // are printable and non-printable. The elements 0, 2, 4... are the first

 // characters of printable ranges and The elements 1, 3, 5... are the first

 // characters of non-printable ranges

 // We will assume that anything in the End User Sub-area is printable.

 static const TInt PUAPrintableRanges[] =

 	{

 	0xE000, 0xF6D9,		// End user area + unassigned corporate use area

 	0xF6DB, 0xF6DC,		// Replacement for character not in font

 	0xF6DE, 0xF700,		// various EIKON and Agenda symbols

 	0x10000, KMaxTInt	// everything else printable

 	};

 static TBool IsPUAPrintable(TInt aChar)

 	{

 	if (0x110000 <= aChar)

 		return 0;	// non-characters not printable

 	TInt i = 0;

 	while (PUAPrintableRanges[i] <= aChar)

 		++i;

 	return i & 1;

 	}

 EXPORT_C TBool User::JustInTime()

 /**

 Tests whether just-in-time debugging is on or off.

 The function is used by the Kernel, on the Emulator, to decide whether to do

 just-in-time debugging for panics. The function applies to the current process.

 Unless overridden by calling User::SetJustInTime(EFalse), just-in-time debugging 

 is on by default.

 @return True, if just-in-time debugging is on. False otherwise.

 @see RProcess::JustInTime

 */

 	{

 	return RProcess().JustInTime();

 	}

 EXPORT_C void User::SetJustInTime(const TBool aBoolean)

 /**

 Sets just-in-time debugging for this process on or off.

 While the function can be called by code running on both the Emulator and ARM,

 it only has an effect on the Emulator. Turning just-in-time debugging off

 prevents the debug Emulator closing down when a panic occurs.

 By default, just-in-time debugging is on.

 Note that the emulator handles panics in the nomal manner, i.e. by killing 

 the thread.

 @param aBoolean ETrue, if just-in-time debugging is to be set on. EFalse, 

                 if just-in-time debugging is to be set off.

                 EFalse causes _asm 3 calls to be disabled.

 @see RProcess::SetJustInTime

 */

 	{

 	RProcess().SetJustInTime(aBoolean);

 	}

 extern const LCharSet* GetLocaleDefaultCharSet();

 extern const LCharSet* GetLocalePreferredCharSet();

 // Convert to folded.

 EXPORT_C TUint User::Fold(TUint aChar)

 /**

 @deprecated

 Folds the specified character.

 Folding converts the character to a form which can be used in tolerant

 comparisons without control over the operations performed. Tolerant comparisons

 are those which ignore character differences like case and accents.

 The result of folding a character depends on the locale and on whether this 

 is a UNICODE build or not.

 Note that for a non-UNICODE build, if the binary value of the character aChar

 is greater than or equal to 0x100, then the character returned is the same as

 the character passed to the function.

 @param aChar The character to be folded.

 @return The folded character.

 @see TChar::Fold()

 */

 	{

 	// ASCII chars excluding 'i's can be handled by naive folding

 	if (aChar < 0x80 && aChar != 'I')

 		return (aChar >= 'A' && aChar <= 'Z') ? (aChar | 0x0020) : aChar;

 	else

 		return TUnicode(aChar).Fold(TChar::EFoldStandard,GetLocaleCharSet()->iCharDataSet);

 	}

 // Convert to a folded version, specifying the folding methods.

 EXPORT_C TUint User::Fold(TUint aChar,TInt aFlags)

 /**

 Folds the character according to a specified folding method.

 @param aChar  The character to be folded.

 @param aFlags A set of flags defining the folding method. They are:

               TChar::EFoldCase, convert characters to their lower case form,

               if any;

               TChar::EFoldAccents, strip accents;

               TChar::EFoldDigits, convert digits representing values 0..9 to

               characters '0'..'9';

               TChar::EFoldSpaces, convert all spaces (ordinary, fixed-width,

               ideographic, etc.) to ' ';

               TChar::EFoldKana, convert hiragana to katakana;

               TChar::EFoldWidth, fold full width and half width variants to

               their standard forms;

               TChar::EFoldAll, use all of the above folding methods.

 @return The folded character.

 @see TChar::Fold()

 */

 	{

 	return TUnicode(aChar).Fold(aFlags,GetLocaleCharSet()->iCharDataSet);

 	}

 // Convert to collated.

 EXPORT_C TUint User::Collate(TUint aChar)

 /**

 Converts the character to its collated form.

 Collating is the process of removing differences between characters that are 

 deemed unimportant for the purposes of ordering characters. The result of 

 the conversion depends on the locale and on whether this is a UNICODE build 

 or not.

 Note that for a non UNICODE build, if the binary value of the character aChar

 is greater than or equal to 0x100, then the character returned is the same as

 the character passed to the function.

 @param aChar The character to be folded.

 @return The converted character.

 */

 	{

 	return TUnicode(aChar).Fold(TChar::EFoldStandard,GetLocaleCharSet()->iCharDataSet);

 	}

 // Convert to lower case.

 EXPORT_C TUint User::LowerCase(TUint aChar)

 /**

 Converts the specified character to lower case.

 The result of the conversion depends on the locale and on whether this is

 a UNICODE build or not.

 Note that for a non-UNICODE build, if the binary value of the character

 aChar is greater than or equal to 0x100, then the character returned is

 the same as the character passed to the function.

 @param aChar The character to be converted to lower case.

 @return The lower case character.

 */

 	{

 	// ASCII chars excluding 'i's can be handled by naive folding

 	if (aChar < 0x80 && aChar != 'I')

 		return (aChar >= 'A' && aChar <= 'Z') ? (aChar | 0x0020) : aChar;

 	else

 		return TUnicode(aChar).GetLowerCase(GetLocaleCharSet()->iCharDataSet);

 	}

 // Convert to upper case.

 EXPORT_C TUint User::UpperCase(TUint aChar)

 /**

 Converts a specified character to upper case.

 The result of the conversion depends on the locale and on whether this is

 a UNICODE build or not.

 Note that for a non UNICODE build, if the binary value of the character aChar

 is greater than or equal to 0x100, then the character returned is the same as

 the character passed to the function.

 @param aChar The character to be converted to upper case.

 @return The upper case character.

 */

 	{

 	// ASCII chars excluding 'i's can be handled by naive folding

 	if (aChar < 0x80 && aChar != 'i')

 		return (aChar >= 'a' && aChar <= 'z') ? (aChar & ~0x0020) : aChar;

 	else

 		return TUnicode(aChar).GetUpperCase(GetLocaleCharSet()->iCharDataSet);

 	}

 // Return the title case version of a character, which is the case of composite characters like Dz.

 EXPORT_C TUint User::TitleCase(TUint aChar)

 /**

 Converts a specified character to its title case version.

 @param aChar The character to be converted.

 @return The converted character.

 */

 	{

 	return TUnicode(aChar).GetTitleCase(GetLocaleCharSet()->iCharDataSet);

 	}

 EXPORT_C TUint TChar::GetUpperCase() const

 /**

 Gets the character value after conversion to uppercase or the character's 

 own value, if no uppercase form exists.

 The character object itself is not changed.

 @return The character value after conversion to uppercase.

 */

 	{

 	return User::UpperCase(iChar);

 	}

 EXPORT_C TUint TChar::GetLowerCase() const

 /**

 Gets the character value after conversion to lowercase or the character's 

 own value, if no lowercase form exists.

 The character object itself is not changed.

 @return The character value after conversion to lowercase.

 */

 	{

 	return User::LowerCase(iChar);

 	}

 EXPORT_C TUint TChar::GetTitleCase() const

 /**

 Gets the character value after conversion to titlecase or the character's 

 own value, if no titlecase form exists.

 The titlecase form of a character is identical to its uppercase form unless 

 a specific titlecase form exists.

 @return The value of the character value after conversion to titlecase form.

 */

 	{

 	return User::TitleCase(iChar);

 	}

 EXPORT_C TBool TChar::IsLower() const

 /**

 Tests whether the character is lowercase.

 @return True, if the character is lowercase; false, otherwise.

 */

 	{

 	return GetCategory() == TChar::ELlCategory;

 	}

 EXPORT_C TBool TChar::IsUpper() const

 /**

 Tests whether the character is uppercase.

 @return True, if the character is uppercase; false, otherwise.

 */

 	{

 	return GetCategory() == TChar::ELuCategory;

 	}

 // Return TRUE if the character is title case, which is the case of composite characters like Dz.

 EXPORT_C TBool TChar::IsTitle() const

 /**

 Tests whether this character is in titlecase.

 @return True, if this character is in titlecase; false, otherwise.

 */

 	{

 	return GetCategory() == TChar::ELtCategory;

 	}

 EXPORT_C TBool TChar::IsAlpha() const

 /**

 Tests whether the character is alphabetic.

 For Unicode, the function returns TRUE for all letters, including those from 

 syllabaries and ideographic scripts. The function returns FALSE for letter-like 

 characters that are in fact diacritics. Specifically, the function returns 

 TRUE for categories: ELuCategory, ELtCategory, ELlCategory, and ELoCategory; 

 it returns FALSE for all other categories including ELmCategory.

 @return True, if the character is alphabetic; false, otherwise.

 @see TChar::IsAlphaDigit()

 @see TChar::TCategory

 */

 	{

 	return GetCategory() <= TChar::EMaxLetterOrLetterModifierCategory;

 	}

 EXPORT_C TBool TChar::IsDigit() const

 /**

 Tests whether the character is a standard decimal digit.

 For Unicode, this function returns TRUE only

 for the digits '0'...'9' (U+0030...U+0039), 

 not for other digits in scripts like Arabic, Tamil, etc.

 @return True, if the character is a standard decimal digit; false, otherwise.

 @see TChar::GetCategory()

 @see TChar::GetNumericValue

 */

 	{

 	return iChar >= '0' && iChar <= '9'; // standard decimal digits only

 	}

 EXPORT_C TBool TChar::IsAlphaDigit() const

 /**

 Tests whether the character is alphabetic or a decimal digit.

 It is identical to (IsAlpha()||IsDigit()).

 @return True, if the character is alphabetic or a decimal digit; false, otherwise.

 @see TChar::IsAlpha()

 @see TChar::IsDigit()

 */

 	{

 	TInt cat = (TInt)GetCategory();

 	return cat <= TChar::EMaxLetterOrLetterModifierCategory ||

 		   (iChar < 256 && cat == TChar::ENdCategory);	// accept any letter, but accept only standard digits

 	}

 EXPORT_C TBool TChar::IsHexDigit() const

 /** 

 Tests whether the character is a hexadecimal digit (0-9, a-f, A-F).

 @return True, if the character is a hexadecimal digit; false, otherwise.

 */

 	{

 	/*

 	The following code will actually run faster than the non-Unicode version, which needs

 	to call the Exec function.

 	*/

 	return iChar <= 'f' && iChar >= '0' &&

 		   (iChar <= '9' || iChar >= 'a' || (iChar >= 'A' && iChar <= 'F'));	// only standard hex digits will do

 	}

 EXPORT_C TBool TChar::IsSpace() const

 /**

 Tests whether the character is a white space character.

 White space includes spaces, tabs and separators.

 For Unicode, the function returns TRUE for all characters in the categories: 

 EZsCategory, EZlCategory and EZpCategory, and also for the characters 0x0009 

 (horizontal tab), 0x000A (linefeed), 0x000B (vertical tab), 0x000C (form feed), 

 and 0x000D (carriage return).

 @return True, if the character is white space; false, otherwise.

 @see TChar::TCategory

 */

 	{

 	/*

 	The Unicode characters 0009 .. 000D (tab, linefeed, vertical tab, formfeed, carriage return)

 	have the category Cc (control); however, we want to avoid breaking traditional programs

 	by getting IsSpace() to return TRUE for them.

 	*/

 	return (iChar <= 0x000D && iChar >= 0x0009) ||

 		   (GetCategory() & 0xF0) == TChar::ESeparatorGroup;

 	}

 EXPORT_C TBool TChar::IsPunctuation() const

 /**

 Tests whether the character is a punctuation character.

 For Unicode, punctuation characters are any character in the categories:

 EPcCategory, EPdCategory, EPsCategory, EPeCategory, EPiCategory,

 EPfCategory, EPoCategory.

 @return True, if the character is punctuation; false, otherwise.

 @see TChar::TCategory

 */

 	{

 	return (GetCategory() & 0xF0) == TChar::EPunctuationGroup;

 	}

 EXPORT_C TBool TChar::IsGraph() const

 /**

 Tests whether the character is a graphic character.

 For Unicode, graphic characters include printable characters but not the space 

 character. Specifically, graphic characters are any character except those 

 in categories: EZsCategory,EZlCategory,EZpCategory, ECcCategory,ECfCategory,

 ECsCategory, ECoCategory, and ,ECnCategory.

 Note that for ISO Latin-1, all alphanumeric and punctuation characters are 

 graphic.

 @return True, if the character is a graphic character; false, otherwise.

 @see TChar::TCategory

 */

 	{

 	TUint type = TUnicode(iChar).GetCategory(0);

 	return type <= TChar::EMaxGraphicCategory ||

 		(type == TChar::ECoCategory && IsPUAPrintable(iChar));

 	}

 EXPORT_C TBool TChar::IsPrint() const

 /**

 Tests whether the character is a printable character.

 For Unicode, printable characters are any character except those in categories: 

 ECcCategory, ECfCategory, ECsCategory, ECoCategory and ECnCategory.

 Note that for ISO Latin-1, all alphanumeric and punctuation characters, plus 

 space, are printable.

 @return True, if the character is printable; false, otherwise.

 @see TChar::TCategory

 */

 	{

 	TUint type = TUnicode(iChar).GetCategory(0);

 	return type <= TChar::EMaxPrintableCategory ||

 		(type == TChar::ECoCategory && IsPUAPrintable(iChar));

 	}

 EXPORT_C TBool TChar::IsControl() const

 /**

 Tests whether the character is a control character.

 For Unicode, the function returns TRUE for all characters in the categories: 

 ECcCategory, ECfCategory, ECsCategory, ECoCategory and ECnCategoryCc.

 @return True, if the character is a control character; false, otherwise.

 @see TChar::TCategory

 */

 	{

 	return GetCategory() == TChar::ECcCategory;

 	}

 EXPORT_C TBool TChar::IsAssigned() const

 /**

 Tests whether this character has an assigned meaning in the Unicode encoding.

 All characters outside the range 0x0000 - 0xFFFF are unassigned and there 

 are also many unassigned characters within the Unicode range.

 Locales can change the assigned/unassigned status of characters. This means 

 that the precise behaviour of this function is locale-dependent.

 @return True, if this character has an assigned meaning; false, otherwise.

 */

 	{

 	return GetCategory() <= TChar::EMaxAssignedCategory;

 	}

 EXPORT_C void TChar::GetInfo(TCharInfo& aInfo) const

 /** 

 Gets this character;s standard category information. 

 This includes everything except its CJK width and decomposition, if any.

 @param aInfo On return, contains the character's standard category information.

 */

 	{

 	TUnicode(iChar).GetInfo(aInfo,GetLocaleCharSet()->iCharDataSet);

 	}

 EXPORT_C TChar::TCategory TChar::GetCategory() const

 /**

 Gets this character's Unicode category.

 @return This character's Unicode category.

 */

 	{

 	//for unicode non private user area just use the default charset

 	if (iChar>=0xE000 && iChar<=0xF8FF)

 		return TUnicode(iChar).GetCategory(GetLocaleCharSet()->iCharDataSet);

 	else

 		return TUnicode(iChar).GetCategory(GetLocaleDefaultCharSet()->iCharDataSet);

 	}

 EXPORT_C TChar::TBdCategory TChar::GetBdCategory() const

 /**

 Gets the bi-directional category of a character.

 For more information on the bi-directional algorithm, see Unicode Technical 

 Report No. 9 available at: http://www.unicode.org/unicode/reports/tr9/.

 @return The character's bi-directional category.

 */

 	{

 	return TUnicode(iChar).GetBdCategory(GetLocaleCharSet()->iCharDataSet);

 	}

 EXPORT_C TInt TChar::GetCombiningClass() const

 /**

 Gets this character's combining class.

 Note that diacritics and other combining characters have non-zero combining 

 classes.

 @return The combining class.

 */

 	{

 	//for unicode non private user area just use the default charset

 	if (iChar>=0xE000 && iChar<=0xF8FF)

 		return TUnicode(iChar).GetCombiningClass(GetLocaleCharSet()->iCharDataSet);

 	else

 		return TUnicode(iChar).GetCombiningClass(GetLocaleDefaultCharSet()->iCharDataSet);

 	}

 EXPORT_C TBool TChar::IsMirrored() const

 /**

 Tests whether this character has the mirrored property.

 Mirrored characters, like ( ) [ ] < >, change direction according to the

 directionality of the surrounding characters. For example, an opening

 parenthesis 'faces right' in Hebrew or Arabic, and to say that 2 < 3 you would

 have to say that 3 > 2, where the '>' is, in this example, a less-than sign to

 be read right-to-left.

 @return True, if this character has the mirrored property; false, otherwise.

 */

 	{

 	return TUnicode(iChar).IsMirrored(GetLocaleCharSet()->iCharDataSet);

 	}

 EXPORT_C TInt TChar::GetNumericValue() const

 /**

 Gets the integer numeric value of this character.

 Numeric values need not be in the range 0..9; the Unicode character set

 includes various other numeric characters such as the Roman and Tamil numerals

 for 500, 1000, etc.

 @return The numeric value: -1 if the character has no integer numeric 

         value,-2 if the character has a fractional numeric value.

 */

 	{

 	return TUnicode(iChar).GetNumericValue(GetLocaleCharSet()->iCharDataSet);

 	}

 EXPORT_C TChar::TCjkWidth TChar::GetCjkWidth() const

 /**

 Gets the Chinese, Japanese, Korean (CJK) notional width.

 Some display systems used in East Asia display characters on a grid of

 fixed-width character cells like the standard MSDOS display mode.

 Some characters, e.g. the Japanese katakana syllabary, take up a single

 character cell and some characters, e.g., kanji, Chinese characters used in

 Japanese, take up two. These are called half-width and full-width characters.

 This property is fixed and cannot be overridden for particular locales.

 For more information on returned widths, see Unicode Technical Report 11 on 

 East Asian Width available at: http://www.unicode.org/unicode/reports/tr11/

 @return The notional width of an east Asian character.

 */

 	{

 	return TUnicode(iChar).GetCjkWidth();

 	}

 /**

 Composes a string of Unicode characters to produce a single character result.

 For example, 0061 ('a') and 030A (combining ring above) compose to give 00E5 

 ('a' with ring above).

 A canonical decomposition is a relationship between a string of characters -  

 usually a base character and one or more diacritics - and a composed character. 

 The Unicode standard requires that compliant software treats composed

 characters identically with their canonical decompositions. The mappings used

 by these functions are fixed and cannot be overridden for particular locales.

 @param aResult If successful, the composed character value. If unsuccessful, 

                this value contains 0xFFFF.

 @param aSource String of source Unicode characters.

 @return True, if the compose operation is successful in combining the entire

 		sequence of characters in the descriptor into a single compound

 		character; false, otherwise.

 */

 EXPORT_C TBool TChar::Compose(TUint& aResult,const TDesC16& aSource)

 	{

 	aResult = 0xFFFF;

 	if(aSource.Length() > 0)

 		{

 		TChar combined;

 		if(::CombineAsMuchAsPossible(aSource, combined) == aSource.Length())

 			{

 			aResult = (TUint)combined;

 			return ETrue;

 			}

 		}

 	return EFalse;

 	}

 /**

 Maps this character to its maximal canonical decomposition.

 For example, 01E1 ('a' with dot above and macron) decomposes into 0061 ('a') 

 0307 (dot) and 0304 (macron).

 Note that this function is used during collation, as performed by

 the Mem::CompareC() function, to convert the compared strings to their maximal

 canonical decompositions.

 @param aResult If successful, the descriptor represents the canonical decomposition 

                of this character. If unsuccessful, the descriptor is empty.

 @return True if decomposition is successful; false, otherwise.

 @see Mem::CompareC()

 @see TChar::Compose()

 */

 EXPORT_C TBool TChar::Decompose(TPtrC16& aResult) const

 	{

 	return ::DecomposeChar(iChar, aResult);

 	}

 EXPORT_C TInt TFindChunk::Next(TFullName &aResult)

 /**

 Finds the full name of the next chunk which matches the match pattern.

 @param aResult A reference to a TBuf descriptor with a defined maximum length. 

                If a matching chunk is found, its full name is set into

                this descriptor.

                If no matching chunk is found, the descriptor length is set

                to zero.

 @return KErrNone, if a matching chunk is found;

         KErrNotFound otherwise.

 */

 	{

 	return NextObject(aResult,EChunk);

 	}

 EXPORT_C TUint8 * RChunk::Base() const

 /**

 Gets a pointer to the base of the chunk's reserved region.

 @return A pointer to the base of the chunk's reserved region.

 */

 	{

 	return(Exec::ChunkBase(iHandle));

 	}

 EXPORT_C TInt RChunk::Size() const

 /**

 Gets the current size of this chunk's committed region.

 @return The size of the chunk's committed region.

 */

 	{

 	return(Exec::ChunkSize(iHandle));

 	}

 EXPORT_C TInt RChunk::Bottom() const

 /**

 Gets the offset of the bottom of the double ended chunk's committed region 

 from the base of the chunk's reserved region.

 Note that the lowest valid address in a double ended chunk is the sum of the 

 base of the chunk's reserved region plus the value of Bottom().

 @return The offset of the bottom of the chunk's committed region from the 

         base of the chunk's reserved region.

 */

 	{

 	return(Exec::ChunkBottom(iHandle));

 	}

 EXPORT_C TInt RChunk::Top() const

 /**

 Gets the offset of the top of the double ended chunk's committed region 

 from the base of the chunk's reserved region.

 Note that the highest valid address in a double ended chunk is the the sum 

 of the base of the chunk's reserved region plus the value of Top() - 1.

 @return The offset of the top of the chunk's committed region from the base 

         of the chunk's reserved region.

 */

 	{

 	return(Exec::ChunkTop(iHandle));

 	}

 EXPORT_C TInt RChunk::MaxSize() const

 /**

 Gets the maximum size of this chunk.

 This maximum size of this chunk is set when the chunk is created.

 @return The maximum size of this chunk.

 */

 	{

 	return(Exec::ChunkMaxSize(iHandle));

 	}

 /**

 Finds the full name of the next LDD factory object which matches the match pattern.

 @param aResult A reference to a TBuf descriptor with a defined maximum length. 

                If a matching LDD factory object is found, its full name is set into

                this descriptor.

                If no matching LDD factory object is found, the descriptor length is set

                to zero.

 @return KErrNone, if a matching LDD factory object is found;

         KErrNotFound otherwise.

 */

 EXPORT_C TInt TFindLogicalDevice::Next(TFullName &aResult)

 	{

 	return NextObject(aResult,ELogicalDevice);

 	}

 /**

 Finds the full name of the next PDD factory object which matches the match pattern.

 @param aResult A reference to a TBuf descriptor with a defined maximum length. 

                If a matching PDD factory object is found, its full name is set into

                this descriptor.

                If no matching PDD factory object is found, the descriptor length is set

                to zero.

 @return KErrNone, if a matching PDD factory object is found;

         KErrNotFound otherwise.

 */

 EXPORT_C TInt TFindPhysicalDevice::Next(TFullName &aResult)

 	{

 	return NextObject(aResult,EPhysicalDevice);

 	}

 /**

 Gets the device capabilities.

 @param aDes	A descriptor into which capability's information is to be written.

 */

 EXPORT_C void RDevice::GetCaps(TDes8 &aDes) const

 	{

 	Exec::LogicalDeviceGetCaps(iHandle,aDes);

 	}

 /**

 Checks if a device supports a particular version.

 @param aVer	The requested device version.

 @return	ETrue if supported, EFalse if not.

 */

 EXPORT_C TBool RDevice::QueryVersionSupported(const TVersion &aVer) const

 	{

 	return(Exec::LogicalDeviceQueryVersionSupported(iHandle,aVer));

 	}

 /**

 Checks if a specified unit number, additional info and a specific PDD is supported.

 @param aUnit			The requested unit number.

 @param aPhysicalDevice	The requested PDD name.

 @param anInfo			The additional information.

 @return ETrue if supported, EFalse if not. 

 */

 EXPORT_C TBool RDevice::IsAvailable(TInt aUnit, const TDesC* aPhysicalDevice, const TDesC8* anInfo) const

 	{

 	TInt r;

 	if(aPhysicalDevice)

 		{

 		TBuf8<KMaxKernelName> physicalDevice;

 		physicalDevice.Copy(*aPhysicalDevice);

 		r = Exec::LogicalDeviceIsAvailable(iHandle,aUnit,(TDesC8*)&physicalDevice,anInfo);

 		}

 	else

 		r = Exec::LogicalDeviceIsAvailable(iHandle,aUnit,(TDesC8*)NULL,anInfo);

 	return r;

 	}

 /**

 Queues an asynchronous request for the device driver, taking no parameters.

 The request is handled on the kernel-side by the logical channel's

 DLogicalChannelBase::Request().

 Outstanding requests can be cancelled by calling DoCancel().

 @param aReqNo   A number identifying the request to the logical channel. 

 @param aStatus  The request status object for this request.     

 */

 EXPORT_C void RBusLogicalChannel::DoRequest(TInt aReqNo,TRequestStatus &aStatus)

 	{

 	TAny *a[2];

 	a[0]=NULL;

 	a[1]=NULL;

 	aStatus=KRequestPending;

 	Exec::ChannelRequest(iHandle,~aReqNo,&aStatus,&a[0]);

 	}

 /**

 Queues an asynchronous request for the device driver, taking one parameter.

 The request is handled on the kernel-side by the logical channel's

 DLogicalChannelBase::Request().

 Outstanding requests can be cancelled by calling DoCancel().

 @param aReqNo   A number identifying the request to the logical channel. 

 @param aStatus  The request status object for this request.

 @param a1       A 32-bit value passed to the kernel-side. Its meaning depends

                 on the device driver requirements.           

 */

 EXPORT_C void RBusLogicalChannel::DoRequest(TInt aReqNo,TRequestStatus &aStatus,TAny *a1)

 	{

 	TAny *a[2];

 	a[0]=a1;

 	a[1]=NULL;

 	aStatus=KRequestPending;

 	Exec::ChannelRequest(iHandle,~aReqNo,&aStatus,&a[0]);

 	}

 /**

 Queues an asynchronous request for the device driver, taking two parameters.

 The request is handled on the kernel-side by the logical channel's

 DLogicalChannelBase::Request().

 Outstanding requests can be cancelled by calling DoCancel().

 @param aReqNo   A number identifying the request to the logical channel. 

 @param aStatus  The request status object for this request.

 @param a1       A 32-bit value passed to the kernel-side. Its meaning depends

                 on the device driver requirements.           

 @param a2       A 32-bit value passed to the kernel-side. Its meaning depends

                 on the device driver requirements.           

 */

 EXPORT_C void RBusLogicalChannel::DoRequest(TInt aReqNo,TRequestStatus &aStatus,TAny *a1,TAny *a2)

 	{

 	TAny *a[2];

 	a[0]=a1;

 	a[1]=a2;

 	aStatus=KRequestPending;

 	Exec::ChannelRequest(iHandle,~aReqNo,&aStatus,&a[0]);

 	}

 /**

 Cancels one or more outstanding asynchronous requests.

 All outstanding requests complete with KErrCancel.

 @param aRequestMask A set of bits identifying the requests to be cancelled.

                     Each bit can be used to identify a separate outstanding

                     request. It is up to the driver to define how the bits map

                     to those outstanding requests.

 */

 EXPORT_C void RBusLogicalChannel::DoCancel(TUint aRequestMask)

 	{

 	Exec::ChannelRequest(iHandle,KMaxTInt,(TAny*)aRequestMask,0);

 	}

 /**

 Makes a synchronous request to the device driver, taking no parameters.

 This function does not return until the request has completed, successfully

 or otherwise.

 @param aFunction A number identifying the request.

 @return KErrNone, if successful; otherwise one of the other system-wide

         error codes.

         The value returned depends on the implementation of the device driver.

 */

 EXPORT_C TInt RBusLogicalChannel::DoControl(TInt aFunction)

 	{

 	return Exec::ChannelRequest(iHandle,aFunction,NULL,NULL);

 	}

 /**

 Makes a synchronous request to the device driver, taking one parameter.

 This function does not return until the request has completed, successfully

 or otherwise.

 @param aFunction A number identifying the request.

 @param a1        A 32-bit value passed to the kernel-side. Its meaning depends

                  on the device driver requirements.           

 @return KErrNone, if successful; otherwise one of the other system-wide

         error codes.

         The value returned depends on the implementation of the device driver.

 */

 EXPORT_C TInt RBusLogicalChannel::DoControl(TInt aFunction,TAny *a1)

 	{

 	return Exec::ChannelRequest(iHandle,aFunction,a1,NULL);

 	}

 /**

 Makes a synchronous request to the device driver, taking two parameters.

 This function does not return until the request has completed, successfully

 or otherwise.

 @param aFunction A number identifying the request.

 @param a1        A 32-bit value passed to the kernel-side. Its meaning depends

                  on the device driver requirements.           

 @param a2        A 32-bit value passed to the kernel-side. Its meaning depends

                  on the device driver requirements.           

 @return KErrNone, if successful; otherwise one of the other system-wide

         error codes.

         The value returned depends on the implementation of the device driver.

 */

 EXPORT_C TInt RBusLogicalChannel::DoControl(TInt aFunction,TAny *a1,TAny *a2)

 	{

 	return Exec::ChannelRequest(iHandle,aFunction,a1,a2);

 	}

 EXPORT_C void User::WaitForAnyRequest()

 /**

 Waits for any asynchronous request to complete.

 The current thread waits on its request semaphore.

 The function completes, and control returns to the caller when the current 

 thread's request semaphore is signalled by any of the service providers which 

 handle these asynchronous requests.

 The request status of all outstanding asynchronous requests must be examined 

 to determine which request is complete.

 @see TRequestStatus

 */

 	{

 	Exec::WaitForAnyRequest();

 	}

 EXPORT_C void User::WaitForRequest(TRequestStatus &aStatus)

 /**

 Waits for a specific asynchronous request to complete.

 The current thread waits on its request semaphore.

 The function completes and control returns to the caller when the current 

 thread's request semaphore is signalled by the service provider handling the 

 request associated with aStatus. Before signalling, the service provider sets 

 an appropriate value in aStatus, other than KRequestPending.

 Note that if other asynchronous requests complete before the one associated

 with aStatus, the request semaphore is adjusted so that knowledge of their

 completion is not lost. In this a case, a subsequent call to

 User::WaitForAnyRequest() or User::WaitForRequest() will complete and return

 immediately.

 @param aStatus A reference to the request status object associated with the 

                specific asynchronous request.

 @see KRequestPending

 */

 	{

 	TInt i=(-1);

 	do

 		{

 		i++;

 		Exec::WaitForAnyRequest();

 		} while (aStatus==KRequestPending);

 	if (i)

 		Exec::RequestSignal(i);

 	}

 EXPORT_C void User::WaitForRequest(TRequestStatus &aStatus1,TRequestStatus &aStatus2)

 /**

 Waits for either of two specific asynchronous requests to complete.

 The current thread waits on its request semaphore.

 The function completes and control returns to the caller when the current 

 thread's request semaphore is signalled by either the service provider handling 

 the request associated with aStatus1 or the service provider handling the 

 request associated with aStatus2. Before signalling, the completing service 

 provider sets an appropriate value in the status object, other

 than KRequestPending.

 Note that if other asynchronous requests complete before the ones associated

 with aStatus1 and aStatus2, the request semaphore is adjusted so that knowledge

 of their completion is not lost. In this a case, a subsequent call to

 User::WaitForAnyRequest() or User::WaitForRequest() will complete and return

 immediately.

 @param aStatus1 A reference to the request status object associated with the 

                 first specific asynchronous request.

 @param aStatus2 A reference to the request status object associated with the 

                 second specific asynchronous request.

 @see KRequestPending                

 */

 	{

 	TInt i=(-1);

 	do

 		{

 		i++;

 		Exec::WaitForAnyRequest();

 		} while (aStatus1==KRequestPending && aStatus2==KRequestPending);

 	if (i)

 		Exec::RequestSignal(i);

 	}

 EXPORT_C void User::WaitForNRequest(TRequestStatus * aStatusArray[], TInt aNum)

 /**

  Waits for any one of  specific asynchronous requests to complete.

 The current thread waits on its request semaphore.

 The function completes and control returns to the caller when the current 

 thread's request semaphore is signalled by the service provider handling 

 the request associated with any member of aStatusArray[]. Before signalling, 

 the completing service provider sets an appropriate value in the status object, 

 other than KRequestPending.

 Note that if other asynchronous requests complete before the ones associated

 with aStatusArray the request semaphore is adjusted so that knowledge

 of their completion is not lost. In this a case, a subsequent call to

 User::WaitForAnyRequest() or User::WaitForRequest() will complete and return

 immediately. 

 @param aStatusArray[] 	An array of pointers to the request status objects

 @param TInt aNum    	The size of aStatusArray[]

 */

 	{

      	TRequestStatus* aptr;

      	TBool m = ETrue;

      	TInt i = (-1);

      	do

 		{

 	 	i++;

         	Exec::WaitForAnyRequest();

         	for(TInt j = 0; j<aNum; j++)

         		{

          		aptr =  aStatusArray[j];

          		if(aptr)

          			{

          			if(aptr->Int()!= KRequestPending)

          				{	

          				m = EFalse;	

          				break;

          				}

          			}

         		}

      		}while(m);

 	if(i)

 		Exec::RequestSignal(i);	

 	}

 EXPORT_C TInt TFindLibrary::Next(TFullName &aResult)

 /**

 Finds the next DLL whose full name matches the match pattern.

 If a DLL with a matching name is found, the function copies the full name of

 the DLL into the descriptor aResult.

 @param aResult A buffer for the fullname of the DLL. This is a template

                specialisation of TBuf defining a modifiable buffer descriptor

                taking a maximum length of KMaxFullName.

                If no matching DLL is found, the descriptor length is

                set to zero. 

 @return KErrNone, if a matching DLL is found;

         KErrNotFound, otherwise.

 */

 	{

 	return NextObject(aResult,ELibrary);

 	}

 EXPORT_C TLibraryFunction RLibrary::Lookup(TInt anOrdinal) const

 /**

 Gets a pointer to the function at the specified ordinal within this DLL.

 @param anOrdinal The ordinal of the required function in this DLL.

                  This value must be positive.

 @return A pointer to the function at position anOrdinal in this DLL.

         The value is NULL if there is no function at that ordinal. 

 @panic USER 116 if anOrdinal is negative

 */

 	{

 	__ASSERT_ALWAYS(anOrdinal>=0,Panic(EBadLookupOrdinal));

 	return (Exec::LibraryLookup(iHandle,anOrdinal));

 	}

 EXPORT_C TFileName RLibrary::FileName() const

 /**

 Gets the name of the DLL's file.

 @return The DLL's filname.

 */

 	{

 	TFileName n;

 	TPtr8 n8(((TUint8*)n.Ptr()) + KMaxFileName, KMaxFileName);

 	Exec::LibraryFileName(iHandle,n8);

 	n.Copy(n8);

 	return(n);

 	}

 EXPORT_C TUidType RLibrary::Type() const

 /**

 Gets this DLL's UID type.

 The UID type is a property of a Symbian OS file; for a DLL, its value is set

 during the building of that DLL.

 @return The UID type of this DLL. Note that the first TUid component of

         the TUidType has the value KDynamicLibraryUid.

 */

 	{

 	TUidType u;

 	Exec::LibraryType(iHandle,u);

 	return(u);

 	}

 EXPORT_C TInt RLibrary::GetRamSizes(TInt& aCodeSize, TInt& aConstDataSize)

 /**

 Gets the current size of the code and the const data for this DLL.

 This function can be called on a RAM loaded DLL or a ROM based DLL.

 @param aCodeSize      The current size of the code for a RAM loaded DLL.

                       This is zero for a ROM based DLL.

 @param aConstDataSize The current size of the const data for a RAM loaded DLL.

                       This is zero for a ROM based DLL.

 @return KErrNone if successful, otherwise one of the system-wide error codes. 

 */

 	{

 	TModuleMemoryInfo info;

 	TInt r=Exec::LibraryGetMemoryInfo(iHandle,info);

 	if (r==KErrNone)

 		{

 		aCodeSize=info.iCodeSize;

 		aConstDataSize=info.iConstDataSize;

 		}

 	return r;

 	}

 /**

 Sets the home time to a specified time value.

 @param aTime A reference to a time representation object containing the time 

              value.

 @return KErrNone if successful or one of the system-wide error codes.

 @deprecated Set the time using User::SetUTCTime if the UTC time is known;

 			otherwise, use the timezone server to set the time.

 @capability WriteDeviceData

 */

 EXPORT_C TInt User::SetHomeTime(const TTime &aTime)

 	{

 	return(Exec::SetUTCTimeAndOffset(aTime.Int64(),0,ETimeSetTime|ETimeSetLocalTime,0));

 	}

 /**

 Sets the secure home time to a specified time value.

 @param aTime A reference to a time representation object containing the 

 			 secure time value.

 @return KErrNone if successful or one of the system-wide error codes.

 @capability TCB

 @capability WriteDeviceData

 */

 EXPORT_C TInt User::SetHomeTimeSecure(const TTime &aTime)

 	{

 	return(Exec::SetUTCTimeAndOffset(aTime.Int64(),0,ETimeSetTime|ETimeSetLocalTime|ETimeSetSecure,0));

 	}

 /**

 Sets the UTC time to a specified time value.

 @param aUTCTime A reference to a time representation object containing the time 

                 value.

 @return KErrNone if successful or one of the system-wide error codes.

 @capability WriteDeviceData

 */

 EXPORT_C TInt User::SetUTCTime(const TTime &aUTCTime)

 	{

 	return(Exec::SetUTCTimeAndOffset(aUTCTime.Int64(),0,ETimeSetTime,0));

 	}

 /**

 Sets the secure UTC time to a specified time value.

 @param aUTCTime A reference to a time representation object containing the secure time 

                 value.

 @return KErrNone if successful or one of the system-wide error codes.

 @capability TCB

 @capability WriteDeviceData

 */

 EXPORT_C TInt User::SetUTCTimeSecure(const TTime &aUTCTime)

 	{

 	return(Exec::SetUTCTimeAndOffset(aUTCTime.Int64(),0,ETimeSetTime|ETimeSetSecure,0));

 	}

 /**

 Gets the UTC offset - the difference between UTC and the current local time

 due to any time zones and daylight savings time that may be in effect. A positive

 offset indicates a time ahead of UTC, a negative offset indicates a time behind UTC.

 @return The UTC offset, in seconds.

 */

 EXPORT_C TTimeIntervalSeconds User::UTCOffset()

 	{

 	return(TTimeIntervalSeconds(Exec::UTCOffset()));

 	}

 /**

 Sets the UTC offset to the given number of seconds. This should include both time

 zone differences and the effect of any applicable daylight savings time.

 A positive offset indicates a time ahead of UTC, a negative offset indicates a time

 behind UTC.

 @param aOffset The UTC offset, in seconds.

 @capability WriteDeviceData

 */

 EXPORT_C void User::SetUTCOffset(TTimeIntervalSeconds aOffset)

 	{

 	Exec::SetUTCTimeAndOffset(0,aOffset.Int(),ETimeSetOffset,0);

 	}

 /**

 Sets the UTC time and UTC offset to the specified values, atomically. This is equivalent

 to calling both SetUTCTime and SetUTCOffset, but without the possibility of an incorrect

 time being observed between the two calls. If the operation is not successful, an error

 code will be returned and both the time and offset will be left unchanged.

 @param aUTCTime A reference to a time representation object containing the time 

                 value.

 @param aOffset The UTC offset, in seconds.

 @return KErrNone if successful or one of the system-wide error codes.

 @capability WriteDeviceData

 */

 EXPORT_C TInt User::SetUTCTimeAndOffset(const TTime &aUTCTime, TTimeIntervalSeconds aOffset)

 	{

 	return(Exec::SetUTCTimeAndOffset(aUTCTime.Int64(),aOffset.Int(),ETimeSetTime|ETimeSetOffset,0));

 	}

 /**

 Gets the current tick count.

 The period between ticks is usually 1/64 second, but may be hardware dependent.

 @return The machine dependent tick count.

 */

 EXPORT_C TUint User::TickCount()

 	{

 	return(Exec::TickCount());

 	}

 EXPORT_C TTimeIntervalSeconds User::InactivityTime()

 /**

 Gets the time since the last user activity.

 @return The time interval.

 */

 	{

 	return TTimeIntervalSeconds(Exec::UserInactivityTime());

 	}

 /**

 Resets all user inactivity timers.

 */

 EXPORT_C void User::ResetInactivityTime()

 	{

 	Exec::ResetInactivityTime();

 	}

 /**

 Gets the nanokernel tick count.

 This is the current value of the machine's millisecond tick counter.

 On the emulator the resolution defaults to 5 milliseconds; however

 you can change it to N milliseconds when you launch the emulator

 from the command line by specifying -Dtimerresolution=N as a parameter

 to epoc.exe, for example:

 @code

 epoc.exe -Dtimerresolution=3

 @endcode

 On most hardware the resolution is about 1 millisecond.

 You can get the nanokernel tick period in microseconds by calling

 into the Hardware Abstraction Layer:

 @code

 TInt nanokernel_tick_period;

 HAL::Get(HAL::ENanoTickPeriod, nanokernel_tick_period);

 @endcode

 @return The nanokernel tick count.

 */

 EXPORT_C TUint32 User::NTickCount()

 	{

 	return Exec::NTickCount();

 	}

 /**

 Gets the fast counter.

 This is the current value of the machine's high resolution timer.  If a high

 resolution timer is not available, it uses the millisecond timer instead.

 The freqency of this counter can be determined by reading the HAL attribute

 EFastCounterFrequency.

 This function is intended for use in profiling and testing; it should not be

 used in production code. User::NTickCount() should be used instead.

 This is because the implementation of the FastCounter is platform-specific:

 its frequency can be anywhere from a few KHz to many MHz. It may also not

 be activated when needed, since it is expensive in terms of clock cycles and

 battery life, and use of a platform-specific API may be necessary to enable

 it.

 @return The fast counter value.

 @see User::NTickCount()

 */

 EXPORT_C TUint32 User::FastCounter()

 	{

 	return Exec::FastCounter();

 	}

 EXPORT_C TTimerLockSpec User::LockPeriod()

 /**

 Returns which of the periods the clock is currently in.

 @return The fraction of a second at which the timer completes.

 */

 	{

 	return(Exec::LockPeriod());

 	}

 EXPORT_C TName RHandleBase::Name() const

 /**

 Gets the name of the handle.

 @return The name of the handle.

 */

 	{

 	TName n;

 	TPtr8 n8(((TUint8*)n.Ptr()) + KMaxName, KMaxName);

 	Exec::HandleName(iHandle,n8);

 	n.Copy(n8);

 	return(n);

 	}

 EXPORT_C TFullName RHandleBase::FullName() const

 /**

 Gets the full name of the handle.

 Note: This method is stack consuming (it takes 512 bytes on stack to execute).

 For an alternative way to obtain the full name of the object, see RHandleBase::FullName(TDes& aName) const.

 @see RHandleBase::FullName(TDes& aName) const

 @return The full name of the handle.

 */

 	{

 	TFullName n;

 	TPtr8 n8(((TUint8*)n.Ptr()) + KMaxFullName, KMaxFullName);

 	Exec::HandleFullName(iHandle,n8);

 	n.Copy(n8);

 	return(n);

 	}

 EXPORT_C void RHandleBase::FullName(TDes& aName) const

 /**

 Gets the full name of the handle.

 @param aName On return, contains the full name of the handle.

 @panic KERN-EXEC 35, If full name of the handler is longer that the maximum length of aName descriptor.

 					 To avoid this, the maximum length of aName should be at least KMaxFullName.

 @see KMaxFullName

 */

 	{

 	// Kernel will copy string in n8, whose data lives in the upper half of aName desciptor data

 	TPtr8 n8(((TUint8*)aName.Ptr()) + aName.MaxLength(), aName.MaxLength());

 	Exec::HandleFullName(iHandle,n8);

 	aName.Copy(n8); // Expands 8bit descriptor into 16bit unicode descriptor.

 	}

 EXPORT_C void RHandleBase::HandleInfo(THandleInfo* anInfo)

 /**

 Gets information about the handle.

 @param anInfo A pointer to a THandleInfo object supplied by the caller;

               on return, contains the handle information. 

 */

 	{

 	Exec::HandleInfo(iHandle,anInfo);

 	}

 EXPORT_C TInt RHandleBase::BTraceId() const

 /**

 Returns a unique object identifier for use with BTrace

 */

 	{

 	return Exec::GetBTraceId(iHandle);

 	}

 EXPORT_C TUint RHandleBase::Attributes() const

 //

 // Get handle attributes

 //

 	{

 	return Exec::HandleAttributes(iHandle);

 	}

 EXPORT_C TInt User::AllocLen(const TAny *aCell)

 /**

 Gets the length of the specified allocated heap cell.

 The cell is assumed to be in the current thread's heap.

 @param aCell A pointer to the allocated cell whose length

              is to be fetched.

 @return The length of the allocated cell.

 */

 	{

 	return(GetHeap()->AllocLen(aCell));

 	}

 EXPORT_C TAny* User::Alloc(TInt aSize)

 /**

 Allocates a cell of specified size from the current thread's heap.

 If there is insufficient memory available on the heap from which to allocate a cell 

 of the required size, the function returns NULL.

 The resulting size of the allocated cell may be rounded up to a value greater 

 than aSize, but is guaranteed to be not less than aSize.

 @param aSize The size of the cell to be allocated from the current thread's 

              heap.

 @return A pointer to the allocated cell. NULL, if there is insufficient memory 

         available.

 @panic USER 47, if the maximum unsigned value of aSize is greater

                 than or equal to KMaxTInt/2. For example,

                 calling Alloc(-1) raises this panic.

 */

 	{

 	return(GetHeap()->Alloc(aSize));

 	}

 EXPORT_C TAny* User::AllocL(TInt aSize)

 /**

 Allocates a cell of specified size from the current thread's heap, and leaves 

 if there is insufficient memory in the heap.

 The resulting size of the allocated cell may be rounded up to a value greater 

 than aSize, but is guaranteed to be not less than aSize.

 @param aSize The size of the cell to be allocated from the current thread's 

              heap.

 @return A pointer to the allocated cell.

 @panic USER 47, if the maximum unsigned value of aSize is greater

                 than or equal to KMaxTInt/2. For example,

                 calling Alloc(-1) raises this panic.

 */

 	{

 	return(GetHeap()->AllocL(aSize));

 	}

 EXPORT_C TAny *User::AllocLC(TInt aSize)

 /**

 Allocates a cell of specified size from the current thread's default heap, and,

 if successful, places a pointer to the cell onto the cleanup stack.

 The function leaves if there is insufficient memory in the heap.

 The resulting size of the allocated cell may be rounded up to a value greater 

 than aSize, but is guaranteed to be not less than aSize.

 @param aSize The size of the cell to be allocated from the current thread's

              default heap.

 @return A pointer to the allocated cell.

 @panic USER 47, if the maximum unsigned value of aSize is greater

                 than or equal to KMaxTInt/2. For example,

                 calling Alloc(-1) raises this panic.

 */

 	{

 	return(GetHeap()->AllocLC(aSize));

 	}

 EXPORT_C TAny* User::AllocZ(TInt aSize)

 /**

 Allocates a cell of specified size from the current thread's default heap,

 and clears it to binary zeroes.

 If there is insufficient memory available on the heap from which to allocate a cell 

 of the required size, the function returns NULL.

 The resulting size of the allocated cell may be rounded up to a value greater 

 than aSize, but is guaranteed to be not less than aSize.

 @param aSize The size of the cell to be allocated from the current thread's 

              default heap.

 @return A pointer to the allocated cell. NULL, if there is insufficient memory 

         available.

 @panic USER 47, if the maximum unsigned value of aSize is greater

                 than or equal to KMaxTInt/2. For example,

                 calling Alloc(-1) raises this panic.

 */

 	{

 	return GetHeap()->AllocZ(aSize);

 	}

 EXPORT_C TAny* User::AllocZL(TInt aSize)

 /**

 Allocates a cell of specified size from the current thread's default heap,

 clears it to binary zeroes, and leaves if there is insufficient memory in

 the heap.

 The resulting size of the allocated cell may be rounded up to a value greater 

 than aSize, but is guaranteed to be not less than aSize.

 @param aSize The size of the cell to be allocated from the current thread's 

              heap.

 @return A pointer to the allocated cell.

 @panic USER 47, if the maximum unsigned value of aSize is greater

                 than or equal to KMaxTInt/2. For example,

                 calling Alloc(-1) raises this panic.

 */

 	{

 	return GetHeap()->AllocZL(aSize);

 	}

 EXPORT_C TInt User::Available(TInt &aBiggestBlock)

 /**

 Gets the total free space currently available on the current thread's 

 default heap, and the space available in the largest free block.

 The space available represents the total space which can be allocated.

 Note that compressing the heap may reduce the total free space available and the space 

 available in the largest free block.

 @param aBiggestBlock On return, contains the space available in the largest

                      free block on the current thread's default heap.

 @return The total free space currently available on the current thread's heap.

 */

 	{

 	return(GetHeap()->Available(aBiggestBlock));

 	}

 EXPORT_C void User::Check()

 /**

 Checks the validity of the current thread's default heap.

 The function walks through the list of allocated cells and the list of free

 cells checking that the heap is consistent and complete.

 @panic USER 47 if any corruption is found, specifically	a bad allocated

                heap cell size.

 @panic USER 48 if any corruption is found, specifically a bad allocated

                heap cell address.

 @panic USER 49 if any corruption is found, specifically a bad free heap

                cell address.

 */

 	{

 	GetHeap()->Check();

 	}

 EXPORT_C void User::Free(TAny *aCell)

 /**

 Frees the specified cell and returns it to the current thread's default heap.

 @param aCell A pointer to a valid cell to be freed. If NULL this function 

              call will be ignored.

 @panic USER 42, if aCell is not NULL and does not point to a valid cell.

 */

 	{

 	if (aCell)

 		GetHeap()->Free(aCell);

 	}

 EXPORT_C void User::FreeZ(TAny * &aCell)

 /**

 Frees the specified cell, returns it to the current thread's default heap, and resets 

 the pointer to NULL.

 @param aCell A reference to a pointer to a valid cell to be freed. If NULL 

              this function call will be ignored.

 @panic USER 42, if aCell is not NULL and does not point to a valid cell.             

 */

 	{

 	if (aCell)

 		GetHeap()->FreeZ(aCell);

 	}

 EXPORT_C TAny* User::ReAlloc(TAny* aCell, TInt aSize, TInt aMode)

 /**

 Increases or decreases the size of an existing cell in the current

 thread's heap.

 If the cell is being decreased in size, then it is guaranteed not to move,

 and the function returns the pointer originally passed in aCell. Note that the

 length of the cell will be the same if the difference between the old size

 and the new size is smaller than the minimum cell size.

 If the cell is being increased in size, i.e. aSize is bigger than its

 current size, then the function tries to grow the cell in place.

 If successful, then the function returns the pointer originally

 passed in aCell. If unsuccessful, then:

 -# if the cell cannot be moved, i.e. aMode has the ENeverMove bit set, then

    the function returns NULL.

 -# if the cell can be moved, i.e. aMode does not have the ENeverMove bit set,

    then the function tries to allocate a new replacement cell, and, if

    successful, returns a pointer to the new cell; if unsuccessful, it

    returns NULL.

 Note that in debug mode, the function returns NULL if the cell cannot be grown

 in place, regardless of whether the ENeverMove bit is set.

 If the reallocated cell is at a different location from the original cell, then

 the content of the original cell is copied to the reallocated cell.

 If the supplied pointer, aCell is NULL, then the function attempts to allocate

 a new cell, but only if the cell can be moved, i.e. aMode does not have

 the ENeverMove bit set.

 Note the following general points:

 - If reallocation fails, the content of the original cell is preserved.

 - The resulting size of the re-allocated cell may be rounded up to a value

   greater than aSize, but is guaranteed to be not less than aSize.

 @param aCell A pointer to the cell to be reallocated. This may be NULL.

 @param aSize The new size of the cell. This may be bigger or smaller than the

              size of the original cell. The value can also be zero, but this is

              interpreted as a request for a cell of minimum size; the net

              effect is the same as if the caller had explicitly requested

              a cell of minimum size.

              Note that the minimum size of a heap cell is device dependent.

 @param aMode Flags controlling the reallocation. The only bit which has any

              effect on this function is that defined by the enumeration

              ENeverMove of the enum RAllocator::TReAllocMode.

              If this is set, then any successful reallocation guarantees not

              to have changed the start address of the cell.

              By default, this parameter is zero.

 @return A pointer to the reallocated cell. This may be the same as the original

         pointer supplied through aCell. NULL if there is insufficient memory to

         reallocate the cell, or to grow it in place.

 @panic USER 42, if aCell is not NULL, and does not point to a valid cell.

 @panic USER 47, if the maximum unsigned value of aSize is greater

                 than or equal to KMaxTInt/2. For example,

                 calling ReAlloc(someptr,-1) raises this panic.

 @see RAllocator::TReAllocMode

 */

 	{

 	return GetHeap()->ReAlloc(aCell, aSize, aMode);

 	}

 EXPORT_C TAny* User::ReAllocL(TAny* aCell, TInt aSize, TInt aMode)

 /**

 Increases or decreases the size of an existing cell, and leaves 

 if there is insufficient memory in the current thread's default heap.

 If the cell is being decreased in size, then it is guaranteed not to move,

 and the function returns the pointer originally passed in aCell. Note that the

 length of the cell will be the same if the difference between the old size

 and the new size is smaller than the minimum cell size.

 If the cell is being increased in size, i.e. aSize is bigger than its

 current size, then the function tries to grow the cell in place.

 If successful, then the function returns the pointer originally

 passed in aCell. If unsuccessful, then:

 -# if the cell cannot be moved, i.e. aMode has the ENeverMove bit set, then

    the function leaves.

 -# if the cell can be moved, i.e. aMode does not have the ENeverMove bit set,

    then the function tries to allocate a new replacement cell, and, if

    successful, returns a pointer to the new cell; if unsuccessful, it

    leaves.

 Note that in debug mode, the function leaves if the cell cannot be grown

 in place, regardless of whether the ENeverMove bit is set.

 If the reallocated cell is at a different location from the original cell, then

 the content of the original cell is copied to the reallocated cell.

 If the supplied pointer, aCell is NULL, then the function attempts to allocate

 a new cell, but only if the cell can be moved, i.e. aMode does not have

 the ENeverMove bit set.

 Note the following general points:

 - If reallocation fails, the content of the original cell is preserved.

 - The resulting size of the re-allocated cell may be rounded up to a value

   greater than aSize, but is guaranteed to be not less than aSize.

 @param aCell A pointer to the cell to be reallocated. This may be NULL.

 @param aSize The new size of the cell. This may be bigger or smaller than the

              size of the original cell. The value can also be zero, but this is

              interpreted as a request for a cell of minimum size; the net

              effect is the same as if the caller had explicitly requested

              a cell of minimum size.

              Note that the minimum size of a heap cell is device dependent.

 @param aMode Flags controlling the reallocation. The only bit which has any

              effect on this function is that defined by the enumeration

              ENeverMove of the enum RAllocator::TReAllocMode.

              If this is set, then any successful reallocation guarantees not

              to have changed the start address of the cell.

              By default, this parameter is zero.

 @return A pointer to the reallocated cell. This may be the same as the original

         pointer supplied through aCell.

 @panic USER 42, if aCell is not NULL, and does not point to a valid cell.

 @panic USER 47, if the maximum unsigned value of aSize is greater

                 than or equal to KMaxTInt/2. For example,

                 calling ReAlloc(someptr,-1) raises this panic.

 @see RAllocator::TReAllocMode

 */

 	{

 	return GetHeap()->ReAllocL(aCell, aSize, aMode);

 	}

 EXPORT_C RAllocator& User::Allocator()

 /**

 Gets the current thread's default current heap.

 @return The current heap.

 */

 	{

 	return *GetHeap();

 	}		

 EXPORT_C TInt User::AllocSize(TInt &aTotalAllocSize)

 /**

 Gets the total number of cells allocated on the current thread's default heap, 

 and the total space allocated to them.

 @param aTotalAllocSize On return, contains the total space allocated to

                        the cells.

 @return The number of cells currently allocated on the current thread's heap.

 */

 	{

 	return(GetHeap()->AllocSize(aTotalAllocSize));

 	}

 EXPORT_C TInt User::CountAllocCells()

 /**

 Gets the total number of cells allocated on the current thread's default heap.

 @return The number of cells allocated on the current thread's default user heap.

 */

 	{

 	return(GetHeap()->Count());

 	}  

 EXPORT_C TInt User::CountAllocCells(TInt &aFreeCount)

 /**

 Gets the the total number of cells allocated, and the number of free cells, 

 on the current thread's default heap.

 @param aFreeCount On return, contains the number of free cells 

                   on the current thread's default heap.

 @return The number of cells allocated on the current thread's default heap.

 */

 	{

 	return(GetHeap()->Count(aFreeCount));

 	}

 EXPORT_C RAllocator* User::SwitchAllocator(RAllocator* aA)

 /**

 Changes the current thread's heap.

 @param aA A pointer to the new heap handle.

 @return A pointer to the old heap handle.

 */

 	{

 #ifdef __USERSIDE_THREAD_DATA__

 	// Just cache the pointer user-side.  We still need to let the kernel know what's going on so

 	// the heap can be cleaned up correctly later.

 	LocalThreadData()->iHeap=aA;

 #endif

 	return Exec::HeapSwitch(aA);

 	}

 // The suffix table

 const TText16* const __DefaultDateSuffixTable[KMaxSuffixes] =

 	{

 	_S16("st"),_S16("nd"),_S16("rd"),_S16("th"),_S16("th"),

 	_S16("th"),_S16("th"),_S16("th"),_S16("th"),_S16("th"),

 	_S16("th"),_S16("th"),_S16("th"),_S16("th"),_S16("th"),

 	_S16("th"),_S16("th"),_S16("th"),_S16("th"),_S16("th"),

 	_S16("st"),_S16("nd"),_S16("rd"),_S16("th"),_S16("th"),

 	_S16("th"),_S16("th"),_S16("th"),_S16("th"),_S16("th"),

 	_S16("st")

 	};

 // The day names

 const TText16* const __DefaultDayTable[KMaxDays] =

 	{

 	_S16("Monday"),

 	_S16("Tuesday"),

 	_S16("Wednesday"),

 	_S16("Thursday"),

 	_S16("Friday"),

 	_S16("Saturday"),

 	_S16("Sunday")

 	};

 // The abbreviated day names

 const TText16* const __DefaultDayAbbTable[KMaxDays] =

 	{

 	_S16("Mon"),

 	_S16("Tue"),

 	_S16("Wed"),

 	_S16("Thu"),

 	_S16("Fri"),

 	_S16("Sat"),

 	_S16("Sun")

 	};

 // The month names

 const TText16* const __DefaultMonthTable[KMaxMonths] =

 	{

 	_S16("January"),

 	_S16("February"),

 	_S16("March"),

 	_S16("April"),

 	_S16("May"),

 	_S16("June"),

 	_S16("July"),

 	_S16("August"),

 	_S16("September"),

 	_S16("October"),

 	_S16("November"),

 	_S16("December")

 	};

 // The abbreviated month names

 const TText16* const __DefaultMonthAbbTable[KMaxMonths] =

 	{

 	_S16("Jan"),

 	_S16("Feb"),

 	_S16("Mar"),

 	_S16("Apr"),

 	_S16("May"),

 	_S16("Jun"),

 	_S16("Jul"),

 	_S16("Aug"),

 	_S16("Sep"),

 	_S16("Oct"),

 	_S16("Nov"),

 	_S16("Dec")

 	};

 // The am/pm strings

 const TText16* const __DefaultAmPmTable[KMaxAmPms] =

 	{

 	_S16("am"),

 	_S16("pm")

 	};

 const TText16* const __DefaultLMsgTable[ELocaleMessages_LastMsg] =

 	{

 // Fileserver

 	_S16("Retry"),								// Button 1

 	_S16("Stop"),									// Button 2

 	_S16("Put the disk back"),					// Put the card back - line1

 	_S16("or data will be lost"),					// Put the card back - line2

 	_S16("Batteries too low"),					// Low power - line1

 	_S16("Cannot complete write to disk"),		// Low power - line2

 	_S16("Disk error - cannot complete write"),	// Disk error - line1

 	_S16("Retry or data will be lost"),			// Disk error - line2

 // SoundDriver

 	_S16("Chimes"),								// Chimes

 	_S16("Rings"),								// Rings

 	_S16("Signal"),								// Signal

 // MediaDriver diskname (max 16 chars)

 	_S16("Internal"),								// Internal

 	_S16("External(01)"),							// External(01)

 	_S16("External(02)"),							// External(02)

 	_S16("External(03)"),							// External(03)

 	_S16("External(04)"),							// External(04)

 	_S16("External(05)"),							// External(05)

 	_S16("External(06)"),							// External(06)

 	_S16("External(07)"),							// External(07)

 	_S16("External(08)"),							// External(08)

 // MediaDriver socketname (max 16 chars)

 	_S16("Socket(01)"),							// Socket(01)

 	_S16("Socket(02)"),							// Socket(02)

 	_S16("Socket(03)"),							// Socket(03)

 	_S16("Socket(04)")							// Socket(04)

 	};

 LOCAL_C void LocaleLanguageGet(SLocaleLanguage& locale)

 	{

 	TPckg<SLocaleLanguage> localeLanguageBuf(locale);

 	TInt r = RProperty::Get(KUidSystemCategory, KLocaleLanguageKey, localeLanguageBuf);

 	__ASSERT_DEBUG(r == KErrNone || r == KErrNotFound, Panic(EBadLocaleParameter));

 	if(r == KErrNotFound)

 		{

 		locale.iLanguage			= ELangEnglish;

 		locale.iDateSuffixTable		= (const TText16*)__DefaultDateSuffixTable;

 		locale.iDayTable			= (const TText16*)__DefaultDayTable;

 		locale.iDayAbbTable			= (const TText16*)__DefaultDayAbbTable;

 		locale.iMonthTable			= (const TText16*)__DefaultMonthTable;

 		locale.iMonthAbbTable		= (const TText16*)__DefaultMonthAbbTable;

 		locale.iAmPmTable			= (const TText16*)__DefaultAmPmTable;

 		locale.iMsgTable			= (const TText16* const*)__DefaultLMsgTable;

 		}

 	}

 LOCAL_C void LocaleSettingsGet(SLocaleLocaleSettings& locale)

 	{

 	TPckg<SLocaleLocaleSettings> localeSettingsBuf(locale);

 	TInt r = RProperty::Get(KUidSystemCategory, KLocaleDataExtraKey, localeSettingsBuf);

 	__ASSERT_DEBUG(r == KErrNone || r == KErrNotFound, Panic(EBadLocaleParameter));

 	if(r == KErrNotFound)

 		{

 		Mem::Copy(&locale.iCurrencySymbol[0], _S16("\x00a3"), sizeof(TText16) << 2);

 		locale.iLocaleExtraSettingsDllPtr = NULL;

 		}

 	}

 LOCAL_C void LocaleTimeDateFormatGet(SLocaleTimeDateFormat& locale)

 	{

 	TPckg<SLocaleTimeDateFormat> localeTimeDateFormatBuf(locale);

 	TInt r = RProperty::Get(KUidSystemCategory, KLocaleTimeDateFormatKey, localeTimeDateFormatBuf);

 	__ASSERT_DEBUG(r == KErrNone || r == KErrNotFound, Panic(EBadLocaleParameter));

 	if(r == KErrNotFound)

 		{

 		Mem::Copy(&locale.iShortDateFormatSpec[0], _S16("%F%*D/%*M/%Y"), sizeof(TText16) * 13);

 		Mem::Copy(&locale.iLongDateFormatSpec[0], _S16("%F%*D%X %N %Y"), sizeof(TText16) * 14);

 		Mem::Copy(&locale.iTimeFormatSpec[0], _S16("%F%*I:%T:%S %*A"), sizeof(TText16) * 16);

 		locale.iLocaleTimeDateFormatDllPtr = NULL;

 		}

 	}

 EXPORT_C void TDayName::Set(TDay aDay)

 /**

 Re-retrieves the current locale's text for the specified day of the week.

 @param aDay Identifies the day of the week.

 @panic USER 184, if the specified day is outside the permitted range.

 */

 	{

 	__ASSERT_ALWAYS(aDay>=EMonday && aDay<=ESunday,Panic(EBadLocaleParameter));

 	SLocaleLanguage localeLanguage;

 	LocaleLanguageGet(localeLanguage);

 	Copy((reinterpret_cast<const TText* const*>(localeLanguage.iDayTable))[aDay]);

 	}

 EXPORT_C void TDayNameAbb::Set(TDay aDay)

 /**

 Re-retrieves the current locale's abbreviated text for the specified day of 

 the week.

 @param aDay Identifies the day of the week.

 @panic USER 184, if the specified day is outside the permitted range.

 */

 	{

 	__ASSERT_ALWAYS(aDay>=EMonday && aDay<=ESunday,Panic(EBadLocaleParameter));

 	SLocaleLanguage localeLanguage;

 	LocaleLanguageGet(localeLanguage);

 	Copy((reinterpret_cast<const TText* const*>(localeLanguage.iDayAbbTable))[aDay]);

 	}

 EXPORT_C void TMonthName::Set(TMonth aMonth)

 /**

 Re-retrieves the current locale's text for the specified month.

 @param aMonth Identifies the month.

 @panic USER 184, if the specified month is outside the permitted range.

 */

 	{

 	__ASSERT_ALWAYS(aMonth>=EJanuary && aMonth<=EDecember,Panic(EBadLocaleParameter));

 	SLocaleLanguage localeLanguage;

 	LocaleLanguageGet(localeLanguage);

 	Copy((reinterpret_cast<const TText* const*>(localeLanguage.iMonthTable))[aMonth]);

 	}

 EXPORT_C void TMonthNameAbb::Set(TMonth aMonth)

 /**

 Re-retrieves the current locale's abbreviated text for the specified month.

 @param aMonth Identifies the month.

 @panic USER 184, if the specified month is outside the permitted range.

 */

 	{

 	__ASSERT_ALWAYS(aMonth>=EJanuary && aMonth<=EDecember,Panic(EBadLocaleParameter));

 	SLocaleLanguage localeLanguage;

 	LocaleLanguageGet(localeLanguage);

 	Copy((reinterpret_cast<const TText* const*>(localeLanguage.iMonthAbbTable))[aMonth]);

 	}

 EXPORT_C void TDateSuffix::Set(TInt aSuffix)

 /**

 Re-retrieves the current locale's date suffix text for the specified day of 

 the month.

 @param aSuffix A value identifying the day of the month. The value can 

                range from 0 to 30 so that the first day of the month is

                identified by 0, the second day by 1 etc.

 @panic USER 69, if aDateSuffix is outside the range 0 to 30.

 */

 	{

 	__ASSERT_ALWAYS(aSuffix>=0 && aSuffix<KMaxSuffixes,Panic(ETLoclSuffixOutOfRange));

 	SLocaleLanguage localeLanguage;

 	LocaleLanguageGet(localeLanguage);

 	Copy((reinterpret_cast<const TText* const*>(localeLanguage.iDateSuffixTable))[aSuffix]);

 	}

 EXPORT_C void TAmPmName::Set(TAmPm aSelector)

 /**

 Re-retrieves the current locale's text for identifying time before or after 

 noon as identified by the specified selector.

 @param aSelector The am/pm selector.

 @panic USER 69, if aDateSuffix is outside the range 0 to 30.

 */

 	{

 	__ASSERT_ALWAYS(aSelector==EAm || aSelector==EPm,Panic(ETLoclSuffixOutOfRange));

 	SLocaleLanguage localeLanguage;

 	LocaleLanguageGet(localeLanguage);

 	Copy((reinterpret_cast<const TText* const*>(localeLanguage.iAmPmTable))[aSelector]);

 	}

 EXPORT_C void TCurrencySymbol::Set()

 /**

 Re-retrieves the current locale's currency symbol(s).

 */

 	{

 	SLocaleLocaleSettings locale;

 	LocaleSettingsGet(locale);

 	Copy(&locale.iCurrencySymbol[0]);

 	}

 EXPORT_C void TShortDateFormatSpec::Set()

 /**

 Sets the contents of the short date format specification from the system-wide 

 settings.

 */

 	{

 	SLocaleTimeDateFormat locale;

 	LocaleTimeDateFormatGet(locale);

 	Copy(&locale.iShortDateFormatSpec[0]);

 	}

 EXPORT_C void TLongDateFormatSpec::Set()

 /**

 Sets the contents of the long date format specification from the system-wide 

 settings.

 */

 	{

 	SLocaleTimeDateFormat locale;

 	LocaleTimeDateFormatGet(locale);

 	Copy(&locale.iLongDateFormatSpec[0]);

 	}

 EXPORT_C void TTimeFormatSpec::Set()

 /**

 Sets the contents of the time string format specification from the system-wide

 settings.

 */

 	{

 	SLocaleTimeDateFormat locale;

 	LocaleTimeDateFormatGet(locale);

 	Copy(&locale.iTimeFormatSpec[0]);

 	}

 EXPORT_C TInt User::SetCurrencySymbol(const TDesC& aSymbol)

 /**

 Sets the system wide currency symbol.

 On successful return from this function, a call to the Set() member function 

 of a TCurrencySymbol object fetches the new currency symbol.

 @capability WriteDeviceData

 @param aSymbol A reference to the descriptor containing the currency symbol 

                to be set.

 @return KErrNone if successful, otherwise one of the other system wide error codes.

 @panic USER 119, if the length of aSymbol is greater than KMaxCurrencySymbol. 

 @see TCurrencySymbol

 @see TCurrencySymbol::Set()

 @see KMaxCurrencySymbol

 */

 	{

 	TExtendedLocale locale;

 	return locale.SetCurrencySymbol(aSymbol);

 	}

 EXPORT_C TLanguage User::Language()

 /**

 Gets the language of the current locale.

 @return One of the TLanguage enumerators identifying the language of the

         current locale.

 */

 	{

 	SLocaleLanguage localeLanguage;

 	LocaleLanguageGet(localeLanguage);

 	return localeLanguage.iLanguage;

 	}

 EXPORT_C TRegionCode User::RegionCode()

 	{

 #ifdef SYMBIAN_DISTINCT_LOCALE_MODEL

 	TLocale locale;

 	locale.Refresh();	

 	return static_cast<TRegionCode>(locale.RegionCode());

 #else

 	return static_cast<TRegionCode>(0);

 #endif

 	}

 EXPORT_C TLocale::TLocale()

 /**

 Default constructor.

 It constructs the object with the system's locale settings.

 A single copy of the locale information is maintained by the system. This 

 copy may be refreshed under application control with TLocale::Refresh(), and 

 the settings may be saved to the system with TLocale::Set(). However, the 

 settings are never updated by the system apart from under application control. 

 This enables applications to guarantee that consistent locale information 

 is used.

 @see TLocale::Refresh()

 @see TLocale::Set()

 */

 	{

 	Refresh();

 	}

 const TUint8 __DefaultDateSeparator[KMaxDateSeparators] = { 0, '/', '/', 0 };

 const TUint8 __DefaultTimeSeparator[KMaxTimeSeparators] = { 0, ':', ':', 0 };

 void TLocale::SetDefaults()

 	{

 	iCountryCode = 44;

 	iUniversalTimeOffset = 0;

 	iDateFormat = EDateEuropean;

 	iTimeFormat = ETime12;

 	iCurrencySymbolPosition = ELocaleBefore;

 	iCurrencySpaceBetween = EFalse;

 	iCurrencyDecimalPlaces = 2;

 	iNegativeCurrencyFormat = TNegativeCurrencyFormat(EFalse);

 	iCurrencyTriadsAllowed = ETrue;

 	iThousandsSeparator = ',';

 	iDecimalSeparator = '.';

 	TInt i=0;

 	for(; i<KMaxDateSeparators; i++)

 		iDateSeparator[i] = __DefaultDateSeparator[i];

 	for(i=0; i<KMaxTimeSeparators; i++)

 		iTimeSeparator[i] = __DefaultTimeSeparator[i];

 	iAmPmSymbolPosition = ELocaleAfter;

 	iAmPmSpaceBetween = ETrue;

 	iHomeDaylightSavingZone = EDstEuropean;

 	iWorkDays = 0x1f;

 	iStartOfWeek = EMonday;

 	iClockFormat = EClockAnalog;

 	iUnitsGeneral = EUnitsImperial;

 	iUnitsDistanceLong =  EUnitsImperial;

 	iUnitsDistanceShort =  EUnitsImperial;

 	iExtraNegativeCurrencyFormatFlags = 0;

 	iLanguageDowngrade[0] = ELangNone;

 	iLanguageDowngrade[1] = ELangNone;

 	iLanguageDowngrade[2] = ELangNone;

 #ifdef SYMBIAN_DISTINCT_LOCALE_MODEL

 	iRegionCode = ERegGBR;

 #else

 	iRegionCode = 0;

 #endif

 	iDigitType = EDigitTypeWestern;

 	iDeviceTimeState = TDeviceTimeState(EDeviceUserTime);

 	}

 EXPORT_C void TLocale::Refresh()

 /**

 Refreshes the contents of this object with the system's locale settings.

 */

 	{

 	TPckg<TLocale> localeDataBuf(*this);

 	TInt r = RProperty::Get(KUidSystemCategory, KLocaleDataKey, localeDataBuf);

 	__ASSERT_DEBUG(r == KErrNone || r == KErrNotFound, Panic(EBadLocaleParameter));

 	if(r == KErrNone)

 		{

 		iUniversalTimeOffset = Exec::UTCOffset();

 		iDaylightSaving = 0;

 		}

 	else if(r == KErrNotFound)

 			{

 			SetDefaults();

 			}

 	}

 EXPORT_C TInt TLocale::Set() const

 /**

 Transfers the locale settings from this object to the system. Note that

 the timezone offset and daylight savings flags are ignored as setting these

 through TLocale is no longer supported.

 After this function has been called, other applications may use the new

 settings for newly-constructed TLocale objects,

 or if they use TLocale::Refresh(), to refresh their settings from