// Copyright (c) 1995-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// which accompanies this distribution, and is available

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// e32\euser\us_exec.cpp

// 

//

#include "us_std.h"

#include "us_data.h"

#include <e32kpan.h>

#include <unicode.h>

#include <videodriver.h>

#include "compareimp.h"

#ifdef __VC32__

  #pragma setlocale("english")

#endif

#ifdef __TOOLS2__

#include <stdlib.h>

extern TInt gAllocCount;

extern TInt gAllocFailRate;

extern RAllocator::TAllocFail gAllocFailType;

#endif

_LIT(KLitSpace, " ");

_LIT(KLitOpeningBracket, "(");

_LIT(KLitMinusSign, "-");

_LIT(KLitZeroPad, "0");

// 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;

	}

#ifndef __TOOLS2__

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);

	}

#endif // __TOOLS2__

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: